diff --git a/.gitignore b/.gitignore index 3a3e6d33..6a22ed7b 100644 --- a/.gitignore +++ b/.gitignore @@ -252,3 +252,4 @@ paket-files/ *.sln.iml /ReClass.NET/Resources/BuildDate.txt +*.bat diff --git a/NativeCore/.vscode/c_cpp_properties.json b/NativeCore/.vscode/c_cpp_properties.json new file mode 100644 index 00000000..1bebdad0 --- /dev/null +++ b/NativeCore/.vscode/c_cpp_properties.json @@ -0,0 +1,19 @@ +{ + "configurations": [ + { + "name": "Linux", + "includePath": [ + "${workspaceFolder}/**", + "C:/Users/josua/AppData/Local/Android/android-ndk-r21/sysroot/usr/include", + "C:/Users/josua/Documents/Proj/FreeFireHackV2/src", + "C:/Users/josua/source/repos/ProfilerTIme/ReClass.NET/NativeCore/Shared", + "C:/Users/josua/source/repos/ProfilerTIme/ReClass.NET/NativeCore/Unix" + ], + "defines": [], + "compilerPath": "C:\\Users\\josua\\AppData\\Local\\Android\\android-ndk-r21\\ndk-build.cmd", + "cppStandard": "c++14", + "IntelliSenseMode": "gcc-arm" + } + ], + "version": 4 +} \ No newline at end of file diff --git a/NativeCore/.vscode/settings.json b/NativeCore/.vscode/settings.json new file mode 100644 index 00000000..0e5f504d --- /dev/null +++ b/NativeCore/.vscode/settings.json @@ -0,0 +1,78 @@ +{ + "files.associations": { + "*.embeddedhtml": "html", + "*.php": "php", + "xiosbase": "cpp", + "vector": "cpp", + "string": "cpp", + "unordered_map": "cpp", + "algorithm": "cpp", + "atomic": "cpp", + "bit": "cpp", + "cctype": "cpp", + "chrono": "cpp", + "clocale": "cpp", + "cmath": "cpp", + "codecvt": "cpp", + "compare": "cpp", + "concepts": "cpp", + "cstddef": "cpp", + "cstdint": "cpp", + "cstdio": "cpp", + "cstdlib": "cpp", + "cstring": "cpp", + "ctime": "cpp", + "cwchar": "cpp", + "exception": "cpp", + "filesystem": "cpp", + "functional": "cpp", + "initializer_list": "cpp", + "iomanip": "cpp", + "ios": "cpp", + "iosfwd": "cpp", + "istream": "cpp", + "iterator": "cpp", + "limits": "cpp", + "list": "cpp", + "locale": "cpp", + "memory": "cpp", + "new": "cpp", + "ostream": "cpp", + "ratio": "cpp", + "sstream": "cpp", + "stdexcept": "cpp", + "stop_token": "cpp", + "streambuf": "cpp", + "system_error": "cpp", + "thread": "cpp", + "tuple": "cpp", + "type_traits": "cpp", + "typeinfo": "cpp", + "utility": "cpp", + "xfacet": "cpp", + "xhash": "cpp", + "xlocale": "cpp", + "xlocbuf": "cpp", + "xlocinfo": "cpp", + "xlocmes": "cpp", + "xlocmon": "cpp", + "xlocnum": "cpp", + "xloctime": "cpp", + "xmemory": "cpp", + "xstddef": "cpp", + "xstring": "cpp", + "xtr1common": "cpp", + "xutility": "cpp", + "charconv": "cpp", + "csignal": "cpp", + "format": "cpp", + "forward_list": "cpp", + "fstream": "cpp", + "iostream": "cpp", + "map": "cpp", + "mutex": "cpp", + "optional": "cpp", + "xtree": "cpp", + "deque": "cpp" + } +} \ No newline at end of file diff --git a/NativeCore/Android/jni/Android.mk b/NativeCore/Android/jni/Android.mk new file mode 100644 index 00000000..13292e3f --- /dev/null +++ b/NativeCore/Android/jni/Android.mk @@ -0,0 +1,21 @@ +LOCAL_PATH := $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_MODULE := rcserver +LOCAL_C_INCLUDES += \ +$(LOCAL_PATH)/../../Shared \ +$(LOCAL_PATH)/../../Unix \ +$(LOCAL_PATH)/../.. + +LOCAL_SRC_FILES := \ +main.cpp \ +Client.cpp \ +Utils.cpp \ +../../Unix/LinuxProcess.cpp \ +../../Unix/LinuxSocketWrapper.cpp \ +../../Shared/SocketWrapper.cpp + +LOCAL_CFLAGS := -fexceptions +LOCAL_CPPFLAGS := -Wno-format -Wno-address-of-packed-member + +include $(BUILD_EXECUTABLE) \ No newline at end of file diff --git a/NativeCore/Android/jni/Application.mk b/NativeCore/Android/jni/Application.mk new file mode 100644 index 00000000..f399fc65 --- /dev/null +++ b/NativeCore/Android/jni/Application.mk @@ -0,0 +1,2 @@ +APP_STL := c++_static +APP_ABI := armeabi-v7a arm64-v8a x86 \ No newline at end of file diff --git a/NativeCore/Android/jni/Client.cpp b/NativeCore/Android/jni/Client.cpp new file mode 100644 index 00000000..ebc3dc03 --- /dev/null +++ b/NativeCore/Android/jni/Client.cpp @@ -0,0 +1,615 @@ +#include "Client.h" +#include "SnapshotBase.h" +#include +#include +#include + +#define PHYSICAL_ADDRESS 0xFEFEFE + +bool getMapsSegments(uint32_t pid, std::deque& outSeg) +{ + char mapsPath[260] {}; + + // if(pid == PHYSICAL_ADDRESS) + // { + // SectionInfo seg{}; + + // seg.mType = SectionType::Private; + // seg.mProt = SectionProtection::Read | SectionProtection::Write | SectionProtection::Execute; + // strcpy(seg.mPath, "/dev/port"); + // seg.mStart = 0x0; + // seg.mEnd = 0x7FFFFFFFFFFF; + + // outSeg.push_front(seg); + + // return true; + // } + + sprintf(mapsPath, "/proc/%d/maps", int(pid)); + + printf("Opening %s\n", mapsPath); + + FILE *fp = fopen(mapsPath,"r"); + + if (fp) + { + char* line =(char*) malloc(4096); + //printf("%s Opened\n", mapsPath); + + if(line) + { + while (fgets(line,4096, fp)) { + SectionInfo seg{}; + + //printf("%s\n", line); + + uint64_t offset, unk; + char r; + char w; + char x; + char m; + + sscanf(line,"%llx-%llx %c%c%c%c %llx %llx:%llx %llx %260[^\n\t]", + (void*)&seg.mStart, + (void*)&seg.mEnd, + &r, &w, &x, &m, + (void*)&offset, + (void*)&unk, + (void*)&unk, + (void*)&unk, + seg.mPath); + + /*printf("%llx-%llx %c%c%c%c %llx %llx:%llx %llx %s\n", + seg.mStart, + seg.mEnd, + r, w, x, m, + offset, + unk, + unk, + unk, + seg.mPath);*/ + + if(r == 'r') + seg.mProt |= SectionProtection::Read; + + if(w == 'w') + seg.mProt |= SectionProtection::Write; + + if(x == 'x') + seg.mProt |= SectionProtection::Execute; + + if(m == 'p') + { + seg.mType = SectionType::Private; + seg.mProt |= SectionProtection::CopyOnWrite; + } + + if(offset != 0) + { + seg.mType = SectionType::Image; + if(outSeg.size() > 0) + outSeg[outSeg.size() - 1].mType = SectionType::Image; + } + + outSeg.push_back(seg); + } + + + free(line); + printf("%lu Segments Parsed\n", outSeg.size()); + return true; + } + } + + return false; +} + +SnapshotProcesses::SnapshotProcesses() +{ + type = SNAPSHOT_PROCESSES; + + DIR* pProcDir = opendir("/proc/"); + + if(pProcDir) + { + struct dirent* pDirEnt = nullptr; + + while((pDirEnt = readdir(pProcDir))) + { + uint32_t currPid = atoi(pDirEnt->d_name); + + if(currPid) + { + char currCmdLinePath[256] {}; + + sprintf(currCmdLinePath, "/proc/%d/cmdline", int(currPid)); + + FILE* fCmdLine = fopen(currCmdLinePath, "r"); + + if(fCmdLine) + { + char cmdLineBuff[MAX_PROC_NAME * sizeof(char)]; + std::string cmdLineStr = ""; + + while (fgets(cmdLineBuff, sizeof(cmdLineBuff), fCmdLine)) + cmdLineStr += std::string(cmdLineBuff); + + ProcessInfo pi; + + pi.mProcessId = currPid; + strcpy(pi.mProcessName, cmdLineStr.c_str()); + + //printf("%s %d\n", pi.mProcessName, pi.mProcessId); + + mArray.push_front(pi); + + fclose(fCmdLine); + } + } + } + + closedir(pProcDir); + } + + ProcessInfo pi; + + pi.mProcessId = PHYSICAL_ADDRESS; + strcpy(pi.mProcessName, "Physical Address"); + + mArray.push_front(pi); +} + +SnapshotSections::SnapshotSections(uint32_t pid) +{ + type = SNAPSHOT_SECTIONS; + + printf("Creating SnapshotSections PID %d\n", pid); + + getMapsSegments(pid, mArray); + + printf("SnapshotSections Created PID %d, %d Sections\n", pid, mArray.size()); + +} + +SnapshotModules::SnapshotModules(uint32_t pid) +{ + type = SNAPSHOT_MODULES; + + printf("Creating Snap Modules -> PID %d\n", pid); + + SnapshotSections snapshotSect = SnapshotSections(pid); + + if(snapshotSect.mArray.size() > 0 == false) + return; + + std::unordered_map > modMatchs; + + SectionInfo si = snapshotSect.mArray.front(); + + do { + if(strstr(si.mPath, ".so")) + { + std::string mPathStr = std::string(si.mPath); + + if(modMatchs.find(mPathStr) == modMatchs.end()) + modMatchs[mPathStr] = std::deque(); + + modMatchs[mPathStr].push_back(si); + } + si = snapshotSect.mArray.front(); snapshotSect.mArray.pop_front(); + } while(snapshotSect.mArray.size() > 0); + + for(const auto& kv : modMatchs) + { + if(kv.second.size() > 1) + { + ModuleInfo currMi; + + const auto& pFirst = kv.second[0]; + const auto& pLast = kv.second[kv.second.size() - 1]; + + currMi.mBase = pFirst.mStart; + currMi.mSize = pLast.mEnd - currMi.mBase; + strcpy(currMi.mPath, pFirst.mPath); + + //printf("Module %s\n", pFirst.mPath); + + mArray.push_back(currMi); + } + } + + printf("%d Modules Found\n", mArray.size()); +} + +void ReclassClient::setClientSocket(std::unique_ptr& socket) +{ + mClientSocket = std::move(socket); +} + +void ReclassClient::onReceivedMessage() +{ + //printf("Message Received, ID: %d\n", getPacketCMDId()); + + switch(getPacketCMDId()) + { + case CMD_CREATE_REMOTE_TOOL_HELP: HandleCreateToolHelpCMD(); break; + + case CMD_PROCESS_FIRST: HandleProcessFirstCMD(); break; + case CMD_PROCESS_NEXT: HandleProcessNextCMD(); break; + + case CMD_SECTION_FIRST: HandleSectionFirstCMD(); break; + case CMD_SECTION_NEXT: HandleSectionNextCMD(); break; + + case CMD_MODULE_FIRST: HandleModuleFirstCMD(); break; + case CMD_MODULE_NEXT: HandleModuleNextCMD(); break; + + case CMD_STATUS: HandleStatusCmd(); break; + case CMD_OPEN_REMOTE_PROCESS: HandleOpenProcessCmd(); break; + case CMD_CLOSE_REMOTE_PROCESS: HandleCloseProcessCMD(); break; // TODO + case CMD_READ_MEMORY_CHUCK: HandleReadMemoryCMD(); break; + /*case CMD_REMOVE_REMOTE_PROCS_TOOL_HELP: HandleCmdRemoveProcsToolHelp(pClientSocket, packet); break; + //case CMD_REMOVE_REMOTE_MODS_TOOL_HELP: HandleCmdRemoveProcsToolHelp(pClientSocket, packet); break; // TODO + //case CMD_REMOVE_REMOTE_SECS_TOOL_HELP: HandleCmdRemoveProcsToolHelp(pClientSocket, packet); break; // TODO + case CMD_WRITE_MEMORY_CHUCK: HandleCmdWriteMemory(pClientSocket, packet); break; // TODO + case CMD_DISCONNECT: HandleCmdDisconnect(pClientSocket); bDisconnecting = true; break;*/ + } +} + +bool ReclassClient::WaitMessage() +{ + if(mIsDisconnecting == true) + return false; + + return mClientSocket->Recive(mPacket, MAX_PACKET_SIZE, &mReceivedPacketLen); +} + +bool ReclassClient::ReceiveAndValidateFirstCMD() +{ + WaitMessage(); // Waiting first msg + + if(getPacketCMDId() != CMD_HI) + return false; // invalid conection, rejecting + + mClientSocket->SendMsg(CMD_WELLCOME); // Responding to that valid conn + + return true; // Valid Connection +} + +void ReclassClient::DettachProcess() +{ + if(mAttachedProcess) + mAttachedProcess.reset(); +} + +void ReclassClient::RunThread() +{ + if(mHandlerThread) + return; + + mHandlerThread = std::make_unique([&]{ + Run(); + }); +} + +void ReclassClient::Run() +{ + if(ReceiveAndValidateFirstCMD() == false) + return; + + printf("Client Connected!\n"); + + while(WaitMessage()) // at this point, we are in a valid connection + onReceivedMessage(); +} + +void ReclassClient::HandleCreateToolHelpCMD() +{ + Packet* toolHelp = CastPacket>(); + + switch(toolHelp->mPacketContent.mToolType) + { + case ToolType::PROCS: HandleCreateToolHelpProcs(); break; + case ToolType::SECTIONS: HandleCreateToolHelpSegments(); break; + case ToolType::MODULES: HandleCreateToolHelpModules(); break; + } +} + +void ReclassClient::HandleCreateToolHelpProcs() +{ + CreateRemoteToolHelpOut toolHelpProcs {}; + + // Defaulting to invalid + toolHelpProcs.mHandleTool = HandleValue::INVALID; + + // Create the snapshot + std::unique_ptr snapshot = std::make_unique(); + SnapshotProcesses* pSnapshot = snapshot.get(); + + // Compute the Handle Value + toolHelpProcs.mHandleTool = mHandleSeed++; + + // Save the Snapshot respectively + mToolHelpProcs[pSnapshot] = std::move(snapshot); + mHandlesToolHelpProcs[toolHelpProcs.mHandleTool] = pSnapshot; + + // Report handle to Client + mClientSocket->Send(&toolHelpProcs, sizeof(toolHelpProcs)); +} + +void ReclassClient::HandleProcessFirstCMD() +{ + Packet* procFirstin = CastPacket>(); + HANDLE_API hSnap = procFirstin->getPayload()->mHandleSnap; + + // Remaining = False by default + + ProcessFirstOut procFirstOut { 0 }; + + if(mHandlesToolHelpProcs.find(hSnap) != mHandlesToolHelpProcs.end()) + { + SnapshotProcesses* snapshot = mHandlesToolHelpProcs[hSnap]; + + procFirstOut.mInfo = snapshot->mArray.front(); snapshot->mArray.pop_front(); + procFirstOut.mRemaining = snapshot->mArray.empty() != true; + + if(procFirstOut.mRemaining == false) + OnConsumedProcessList(); + + } + + mClientSocket->Send(&procFirstOut, sizeof(procFirstOut)); +} + +void ReclassClient::HandleProcessNextCMD() +{ + Packet* procNextIn = CastPacket>(); + HANDLE_API hSnap = procNextIn->getPayload()->mHandleSnap; + + // Remaining = False by default + + ProcessNextOut procNextOut { 0 }; + + if(mHandlesToolHelpProcs.find(hSnap) != mHandlesToolHelpProcs.end()) + { + SnapshotProcesses* snapshot = mHandlesToolHelpProcs[hSnap]; + + procNextOut.mInfo = snapshot->mArray.front(); snapshot->mArray.pop_front(); + procNextOut.mRemaining = snapshot->mArray.empty() != true; + + if(procNextOut.mRemaining == false) + OnConsumedProcessList(); + } + + mClientSocket->Send(&procNextOut, sizeof(procNextOut)); +} + +void ReclassClient::OnConsumedProcessList() +{ + mHandlesToolHelpProcs.clear(); + mToolHelpProcs.clear(); +} + +void ReclassClient::HandleCreateToolHelpSegments() +{ + CreateRemoteToolHelpIn* toolhelpIn = CastGetPacketInfo(); + CreateRemoteToolHelpOut toolHelp {}; + + // Defaulting to invalid + toolHelp.mHandleTool = HandleValue::INVALID; + + // Create the snapshot + std::unique_ptr snapshot = std::make_unique(toolhelpIn->mProcessId); + SnapshotSections* pSnapshot = snapshot.get(); + + // Compute the Handle Value + toolHelp.mHandleTool = mHandleSeed++; + + // Save the Snapshot respectively + mToolHelpSegments[pSnapshot] = std::move(snapshot); + mHandlesToolHelpSegments[toolHelp.mHandleTool] = pSnapshot; + + // Report handle to Client + mClientSocket->Send(&toolHelp, sizeof(toolHelp)); +} + +void ReclassClient::HandleSectionFirstCMD() +{ + SectionFirstIn* in = CastGetPacketInfo(); + HANDLE_API hSnap = in->mHandleSnap; + + // Remaining = False by default + + SectionFirstOut out { 0 }; + + if(mHandlesToolHelpSegments.find(hSnap) != mHandlesToolHelpSegments.end()) + { + SnapshotSections* snapshot = mHandlesToolHelpSegments[hSnap]; + + out.mInfo = snapshot->mArray.front(); snapshot->mArray.pop_front(); + out.mRemaining = snapshot->mArray.empty() != true; + + if(out.mRemaining == false) + OnConsumedSectionList(); + } + + mClientSocket->Send(&out, sizeof(out)); +} + +void ReclassClient::HandleSectionNextCMD() +{ + SectionNextIn* in = CastGetPacketInfo(); + HANDLE_API hSnap = in->mHandleSnap; + + // Remaining = False by default + + SectionNextOut out { 0 }; + + if(mHandlesToolHelpSegments.find(hSnap) != mHandlesToolHelpSegments.end()) + { + SnapshotSections* snapshot = mHandlesToolHelpSegments[hSnap]; + + out.mInfo = snapshot->mArray.front(); snapshot->mArray.pop_front(); + out.mRemaining = snapshot->mArray.empty() != true; + + if(out.mRemaining == false) + OnConsumedSectionList(); + } + + mClientSocket->Send(&out, sizeof(out)); +} + +void ReclassClient::OnConsumedSectionList() +{ + mHandlesToolHelpSegments.clear(); + mToolHelpSegments.clear(); +} + +void ReclassClient::HandleCreateToolHelpModules() +{ + CreateRemoteToolHelpIn* toolhelpIn = CastGetPacketInfo(); + CreateRemoteToolHelpOut toolHelp {}; + + // Defaulting to invalid + toolHelp.mHandleTool = HandleValue::INVALID; + + // Create the snapshot + std::unique_ptr snapshot = std::make_unique(toolhelpIn->mProcessId); + SnapshotModules* pSnapshot = snapshot.get(); + + // Compute the Handle Value + toolHelp.mHandleTool = mHandleSeed++; + + // Save the Snapshot respectively + mToolHelpModules[pSnapshot] = std::move(snapshot); + mHandlesToolHelpModules[toolHelp.mHandleTool] = pSnapshot; + + // Report handle to Client + mClientSocket->Send(&toolHelp, sizeof(toolHelp)); +} + +void ReclassClient::HandleModuleFirstCMD() +{ + ModuleFirstIn* in = CastGetPacketInfo(); + HANDLE_API hSnap = in->mHandleSnap; + + // Remaining = False by default + + ModuleNextOut out { 0 }; + + if(mHandlesToolHelpModules.find(hSnap) != mHandlesToolHelpModules.end()) + { + SnapshotModules* snapshot = mHandlesToolHelpModules[hSnap]; + + out.mInfo = snapshot->mArray.front(); snapshot->mArray.pop_front(); + out.mRemaining = snapshot->mArray.empty() != true; + + if(out.mRemaining == false) + OnConsumedModuleList(); + } + + mClientSocket->Send(&out, sizeof(out)); +} + +void ReclassClient::HandleModuleNextCMD() +{ + ModuleNextIn* in = CastGetPacketInfo(); + HANDLE_API hSnap = in->mHandleSnap; + + // Remaining = False by default + + ModuleNextOut out { 0 }; + + if(mHandlesToolHelpModules.find(hSnap) != mHandlesToolHelpModules.end()) + { + SnapshotModules* snapshot = mHandlesToolHelpModules[hSnap]; + + out.mInfo = snapshot->mArray.front(); snapshot->mArray.pop_front(); + out.mRemaining = snapshot->mArray.empty() != true; + + if(out.mRemaining == false) + OnConsumedModuleList(); + } + + mClientSocket->Send(&out, sizeof(out)); +} + +void ReclassClient::OnConsumedModuleList() +{ + mHandlesToolHelpModules.clear(); + mToolHelpModules.clear(); +} + +void ReclassClient::HandleStatusCmd() +{ + mClientSocket->SendMsg(CMD_OK); +} + +void ReclassClient::HandleOpenProcessCmd() +{ + Packet* pOpenProcInf = CastPacket>(); + + OpenRemoteProcessOut openProcOutInf { 0 }; + + // Attaching to the process + openProcOutInf.hProc = AttachProcess(pOpenProcInf->mPacketContent.mProcessId); + + mClientSocket->Send(&openProcOutInf, sizeof(openProcOutInf)); +} + +void ReclassClient::HandleCloseProcessCMD() +{ + // TODO, not used in the client +} + +void ReclassClient::HandleReadMemoryCMD() +{ + ReadMemoryIn* in = CastGetPacketInfo(); + unsigned char mHolderPacket[MAX_PACKET_SIZE + 1]{0}; + ReadMemoryOut* out = (ReadMemoryOut*)(mHolderPacket); + + out->mBytesReaded = -1; + + if(in->mhProc && mAttachedProcess && in->mhProc == mAttachedProcess->getMemFd()) + { + // printf("Reading %d bytes\n", int(in->mSize)); + out->mBytesReaded = mAttachedProcess->ReadMemory(in->mAddr, out->mBuff, in->mSize); + } + + //printf("%d Bytes Readed\n", int(out.mBytesReaded)); + + mClientSocket->Send(out, out->mBytesReaded != -1 ? out->mBytesReaded + sizeof(int64_t) : sizeof(int64_t)); +} + +short ReclassClient::getPacketCMDId() +{ + return *((short*)mPacket); +} + +size_t ReclassClient::getPacketSize() +{ + return mReceivedPacketLen; +} + +HANDLE_API ReclassClient::AttachProcess(uintptr_t procId) +{ + // Detaching from alredy attached process (if attached) + DettachProcess(); + + // Attaching to a new process + mAttachedProcess = std::make_unique(procId); + + // Computing Handle + int openFdLinux = mAttachedProcess->getMemFd(); + HANDLE_API hProc = openFdLinux < 0 ? HandleValue::INVALID : openFdLinux; + + return hProc; +} + +ReclassClient::~ReclassClient() +{ + if(mHandlerThread) + { + if( mHandlerThread->joinable()) + mHandlerThread->join(); + } +} \ No newline at end of file diff --git a/NativeCore/Android/jni/Client.h b/NativeCore/Android/jni/Client.h new file mode 100644 index 00000000..b9b823e2 --- /dev/null +++ b/NativeCore/Android/jni/Client.h @@ -0,0 +1,122 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +enum { + SNAPSHOT_PROCESSES, + SNAPSHOT_MODULES, + SNAPSHOT_SECTIONS +}; + +bool getMapsSegments(uint32_t pid, std::vector& outSeg); + +struct SnapshotProcesses : SnapshotBase { + SnapshotProcesses(); +}; + +struct SnapshotSections : SnapshotBase { + SnapshotSections(uint32_t pid); +}; + +struct SnapshotModules : SnapshotBase { + SnapshotModules(uint32_t pid); +}; + +class ReclassClient { +private: + + std::atomic mHandleSeed; + + std::unique_ptr mClientSocket; + bool mIsDisconnecting = false; + + unsigned char mPacket[MAX_PACKET_SIZE + 1]{0}; + + uintptr_t mReceivedPacketLen = 0; + std::unique_ptr mHandlerThread; + + std::unordered_map> mToolHelpProcs; + std::unordered_map mHandlesToolHelpProcs; + + std::unordered_map> mToolHelpSegments; + std::unordered_map mHandlesToolHelpSegments; + + std::unordered_map> mToolHelpModules; + std::unordered_map mHandlesToolHelpModules; + + std::unique_ptr mAttachedProcess; + + public: + + ~ReclassClient(); + + short getPacketCMDId(); + size_t getPacketSize(); + + HANDLE_API AttachProcess(uintptr_t procId); + + void setClientSocket(std::unique_ptr& socket); + + bool WaitMessage(); + + void onReceivedMessage(); + + bool ReceiveAndValidateFirstCMD(); + + void RunThread(); + void Run(); + + void DettachProcess(); + + void HandleCreateToolHelpCMD(); + + void HandleCreateToolHelpProcs(); + void HandleProcessFirstCMD(); + void HandleProcessNextCMD(); + void OnConsumedProcessList(); + + void HandleCreateToolHelpSegments(); + void HandleSectionFirstCMD(); + void HandleSectionNextCMD(); + void OnConsumedSectionList(); + + void HandleCreateToolHelpModules(); + void HandleModuleFirstCMD(); + void HandleModuleNextCMD(); + void OnConsumedModuleList(); + + void HandleStatusCmd(); + void HandleOpenProcessCmd(); + void HandleCloseProcessCMD(); + + + void HandleReadMemoryCMD(); + + template + T* CastPacket(); + + template + T* CastGetPacketInfo(); +}; + +template +T* ReclassClient::CastPacket() +{ + return (T*)mPacket; +} + +template +T* ReclassClient::CastGetPacketInfo() +{ + Packet* pckt = CastPacket>(); + + return pckt->getPayload(); +} diff --git a/NativeCore/Android/jni/Remote.cpp b/NativeCore/Android/jni/Remote.cpp new file mode 100644 index 00000000..229131fe --- /dev/null +++ b/NativeCore/Android/jni/Remote.cpp @@ -0,0 +1,524 @@ +#include "Remote.h" +#include "LinuxSocketWrapper.h" +#include "API.h" +#include +#include +#include "Utils.h" +#include "dirent.h" +#include "LinuxProcess.h" +#include +#include "ReClassNET_Plugin.hpp" +#include + +enum { + SNAPSHOT_PROCESSES, + SNAPSHOT_MODULES, + SNAPSHOT_SECTIONS +}; + +struct OpenedProcessInfo; +struct SnapshotProcesses; +struct SnapshotSections; +struct SnapshotModules; + +std::unordered_map gProcs; +std::unordered_map> gSnapSecs; +std::unordered_map> gSnapProcs; +std::unordered_map> gSnapMods; + +struct SnapshotProcesses : SnapshotBase{ + + SnapshotProcesses() + { + type = SNAPSHOT_PROCESSES; + + DIR* pProcDir = opendir("/proc/"); + + if(pProcDir) + { + struct dirent* pDirEnt = nullptr; + + while((pDirEnt = readdir(pProcDir))) + { + uint32_t currPid = atoi(pDirEnt->d_name); + + if(currPid) + { + char currCmdLinePath[256] {}; + + sprintf(currCmdLinePath, "/proc/%d/cmdline", int(currPid)); + + FILE* fCmdLine = fopen(currCmdLinePath, "r"); + + if(fCmdLine) + { + char cmdLineBuff[MAX_PROC_NAME * sizeof(char)]; + std::string cmdLineStr = ""; + + while (fgets(cmdLineBuff, sizeof(cmdLineBuff), fCmdLine)) + cmdLineStr += std::string(cmdLineBuff); + + ProcessInfo pi; + + pi.mProcessId = currPid; + strcpy(pi.mProcessName, cmdLineStr.c_str()); + + //printf("%s %d\n", pi.mProcessName, pi.mProcessId); + + mArray.push_back(pi); + + fclose(fCmdLine); + } + } + } + + closedir(pProcDir); + } + } + + static std::unordered_map>& getSnaps() {return gSnapProcs;} +}; + +bool getMapsSegments(uint32_t pid, std::vector& outSeg) +{ + char mapsPath[260] {}; + sprintf(mapsPath, "/proc/%d/maps", int(pid)); + + printf("Opening %s\n", mapsPath); + + FILE *fp = fopen(mapsPath,"r"); + + if (fp) + { + char* line =(char*) malloc(4096); + //printf("%s Opened\n", mapsPath); + + if(line) + { + while (fgets(line,4096, fp)) { + SectionInfo seg{}; + + //printf("%s\n", line); + + uint64_t offset, unk; + char r; + char w; + char x; + char m; + + sscanf(line,"%lx-%lx %c%c%c%c %lx %lx:%lx %lx %260[^\n\t]", &seg.mStart, &seg.mEnd, &r, &w, &x, &m, &offset, &unk, &unk, &unk, seg.mPath); + + //printf("%lx-%lx %s\n", seg.mStart, seg.mEnd, seg.mPath); + + if(r == 'r') + seg.mProt |= SectionProtection::Read; + + if(w == 'w') + seg.mProt |= SectionProtection::Write; + + if(x == 'x') + seg.mProt |= SectionProtection::Execute; + + if(m == 'p') + { + seg.mType = SectionType::Private; + seg.mProt |= SectionProtection::CopyOnWrite; + } + + if(offset != 0) + { + seg.mType = SectionType::Image; + if(outSeg.size() > 0) + outSeg[outSeg.size() - 1].mType = SectionType::Image; + } + + outSeg.push_back(seg); + } + + + free(line); + printf("%d Segments Parsed\n", outSeg.size()); + return true; + } + } + + return false; +} + +struct SnapshotSections : SnapshotBase{ + SnapshotSections(uint32_t pid) + { + type = SNAPSHOT_SECTIONS; + + printf("Creating SnapshotSections PID %d\n", pid); + + getMapsSegments(pid, mArray); + + printf("SnapshotSections Created PID %d, %d Sections\n", mArray.size()); + + } + + static std::unordered_map>& getSnaps() {return gSnapSecs;} +}; + +struct SnapshotModules : SnapshotBase{ + SnapshotModules(uint32_t pid) + { + type = SNAPSHOT_MODULES; + + printf("Creating Snap Modules -> PID %d\n", pid); + + SnapshotSections snapshotSect = SnapshotSections(pid); + std::unordered_map > modMatchs; + + SectionInfo* si; + + printf("Parsing Snap Sections\n", pid); + + if(snapshotSect.PopFirst(&si)) + { + do { + if(strstr(si->mPath, ".so")) + { + std::string mPathStr = std::string(si->mPath); + + if(modMatchs.find(mPathStr) == modMatchs.end()) + modMatchs[mPathStr] = std::vector(); + + modMatchs[mPathStr].push_back(si); + } + } while(snapshotSect.PopNext(&si)); + } + + for(const auto& kv : modMatchs) + { + if(kv.second.size() > 1) + { + ModuleInfo currMi; + + const auto* pFirst = kv.second[0]; + const auto* pLast = kv.second[kv.second.size() - 1]; + + currMi.mBase = pFirst->mStart; + currMi.mSize = pLast->mEnd -currMi.mBase; + strcpy(currMi.mPath, pFirst->mPath); + + mArray.push_back(currMi); + } + } + + printf("%d Modules Found\n", mArray.size()); + } + + static std::unordered_map>& getSnaps() {return gSnapMods;} +}; + +struct OpenedProcessInfo{ + ClientSocketLinux* pOwner; + LinuxProcess* mProcess; +}; + +bool CreateToolSecs(uint32_t pid, SnapshotSections** outSnap) +{ + *outSnap = new SnapshotSections(pid); + + return true; +} + +bool CreateToolMods(uint32_t pid, SnapshotModules** outSnap) +{ + *outSnap = new SnapshotModules(pid); + + return true; +} + +bool CreateToolProcs(SnapshotProcesses** outSnap) +{ + *outSnap = new SnapshotProcesses(); + + return *outSnap != 0; +} + + +void HandleCreateToolProcs(ClientSocketLinux* pClientUnique, HANDLE_API& outHandle) +{ + SnapshotProcesses* pProcsSnap = nullptr; + + if(CreateToolProcs(&pProcsSnap)) + { + gSnapProcs[pClientUnique].push_back(pProcsSnap); + outHandle = gSnapProcs[pClientUnique].size() - 1; + } +} + +void HandleCreateToolMods(ClientSocketLinux* pClientUnique, uint32_t pid, HANDLE_API& outHandle) +{ + SnapshotModules* pModsSnap = nullptr; + + if(CreateToolMods(pid, &pModsSnap)) + { + gSnapMods[pClientUnique].push_back(pModsSnap); + outHandle = gSnapMods[pClientUnique].size() - 1; + } + +} + +void HandleCreateToolSecs(ClientSocketLinux* pClientUnique, uint32_t pid, HANDLE_API& outHandle) +{ + SnapshotSections* pSecsSnap = nullptr; + + if(CreateToolSecs(pid, &pSecsSnap)) + { + gSnapSecs[pClientUnique].push_back(pSecsSnap); + outHandle = gSnapSecs[pClientUnique].size() - 1; + } +} + +void HandleCmdCreateToolHelp(ClientSocketLinux* pClientUnique, void* pInPacket) +{ + Packet* packet = (Packet*)pInPacket; + CreateRemoteToolHelpOut resultPacket; + HANDLE_API& rHandleResult = resultPacket.mHandleTool; + uint32_t pid = packet->getPayload()->mProcessId; + + //packet->Print(); + + printf("Creating Tool %d pid %d\n", packet->getPayload()->mToolType, packet->getPayload()->mProcessId); + + rHandleResult = HandleValue::INVALID; + + switch(packet->getPayload()->mToolType) + { + case ToolType::PROCS: HandleCreateToolProcs(pClientUnique, rHandleResult); break; + case ToolType::MODULES: HandleCreateToolMods(pClientUnique, pid, rHandleResult); break; + case ToolType::SECTIONS: HandleCreateToolSecs(pClientUnique, pid, rHandleResult); break; + } + + if(rHandleResult != HandleValue::INVALID) + printf("Handle Tool Created %d\n", rHandleResult); + + pClientUnique->Send(&resultPacket, sizeof(resultPacket)); +} + +void HandleCmdHi(ClientSocketLinux* pClientSocket) +{ + pClientSocket->SendMsg(CMD_WELLCOME); +} + +bool ProcessAttached(ClientSocketLinux* pClientSocket) +{ + bool bIsAttached = false; + + OpenedProcessInfo* pOpenedProcInf = gProcs[pClientSocket]; + + if(pOpenedProcInf) + { + if(pOpenedProcInf->mProcess) + { + if(pOpenedProcInf->mProcess->getMemFd() != -1) + bIsAttached = true; + } + } + + return bIsAttached; +} + +void DetachProcess(ClientSocketLinux* pClientSocket) +{ + OpenedProcessInfo* pOpenedProcInf = gProcs[pClientSocket]; + + if(pOpenedProcInf) + { + if(pOpenedProcInf->mProcess) delete pOpenedProcInf->mProcess; + delete pOpenedProcInf; + gProcs[pClientSocket] = nullptr; + } +} + +void HandleDisconnect(ClientSocketLinux* pClientSocket) +{ + DetachProcess(pClientSocket); + printf("Client Disconnected\n"); +} + +template +bool ValidToolHandle(std::unordered_map>& rSnap, ClientSocketLinux* pClientUnique, HANDLE_API handle, bool bCheckRange = true) +{ + if(bCheckRange) + { + if(!(handle >= 0 && handle < rSnap[pClientUnique].size())) + return false; + } + + return rSnap[pClientUnique][handle] != nullptr; // Vector Alredy Created on entry + // Dont worry! +} + +void HandleCmdRemoveProcsToolHelp(ClientSocketLinux* pClientUnique, void* pInPacket) +{ + Packet* pckt = ((Packet*)pInPacket); + HANDLE_API hTool = pckt->getPayload()->mHandleSnap; + + printf("Removing Tool Procs %d\n",hTool); + + if(ValidToolHandle(gSnapProcs, pClientUnique, hTool)) { + delete (gSnapProcs[pClientUnique][hTool]); + gSnapProcs[pClientUnique][hTool] = nullptr; + + printf("Procs Tool Removed %d\n",hTool); + } +} + +void HandleCmdStatus(ClientSocketLinux* pClientUnique) +{ + //printf("Process Ping\n"); + pClientUnique->SendMsg(CMD_OK); +} + +void HandleCmdDisconnect(ClientSocketLinux* pClientUnique) +{ + HandleDisconnect(pClientUnique); + pClientUnique->SendMsg(CMD_OK); +} + +template +void HandleToolOp(ClientSocketLinux* pClientSock, void* pInPacket, bool bFirst, std::function fnPostValidOp = nullptr) +{ + Packet* pcktIn = (Packet*)pInPacket; + ToolOut pOut{}; + HANDLE_API hSnap = pcktIn->getPayload()->mHandleSnap; + pOut.mRemaining = false; + auto& rSnaps = ToolType::getSnaps(); + + if(ValidToolHandle(rSnaps, pClientSock, hSnap)) + { + ToolType* pSnap = rSnaps[pClientSock][hSnap]; + + pOut.mRemaining = bFirst ? pSnap->PopFirst(pOut.mInfo) : pSnap->PopNext(pOut.mInfo); + + if(fnPostValidOp) + fnPostValidOp(pOut); + } + + pClientSock->Send(&pOut, sizeof(pOut)); +} + +void HandleCmdOpenProcess(ClientSocketLinux* pClientUnique, void* pInPacket){ + Packet* pcktIn = (Packet*)pInPacket; + OpenRemoteProcessOut pOpenProcOut {}; + + if(ProcessAttached(pClientUnique)) + DetachProcess(pClientUnique); + + pOpenProcOut.hProc = HandleValue::INVALID; + OpenedProcessInfo openedProcInf {}; + + printf("Opening Process PID %d\n", pcktIn->getPayload()->mProcessId); + + openedProcInf.mProcess = new LinuxProcess(pcktIn->getPayload()->mProcessId); + + if(openedProcInf.mProcess) + { + pOpenProcOut.hProc = (HANDLE_API)openedProcInf.mProcess->getMemFd(); + + if(pOpenProcOut.hProc != -1) + { + openedProcInf.pOwner = pClientUnique; + gProcs[pClientUnique] = new OpenedProcessInfo(openedProcInf); + printf("Process Opened %d\n", pOpenProcOut.hProc); + } else delete openedProcInf.mProcess; + } + + pClientUnique->Send(&pOpenProcOut, sizeof(pOpenProcOut)); +} + +void HandleCmdReadMemory(ClientSocketLinux* pClientUnique, void* pInPacket) +{ + Packet* pckt = (Packet*)pInPacket; + HANDLE_API hProc = pckt->getPayload()->mhProc; + unsigned char packetHolder[MAX_PACKET_SIZE]{}; + ReadMemoryOut* pRdMemOut = (ReadMemoryOut*)packetHolder; + const OpenedProcessInfo* hProcInf = gProcs[pClientUnique]; + + pRdMemOut->mBytesReaded = -1; + + if(hProcInf && hProc == hProcInf->mProcess->getMemFd()) + { + // printf("Reading %d bytes\n", int(pckt->getPayload()->mSize)); + pRdMemOut->mBytesReaded = hProcInf->mProcess->ReadMemory(pckt->getPayload()->mAddr, pRdMemOut->mBuff, pckt->getPayload()->mSize); + } + + //printf("%d Bytes Readed\n", int(pRdMemOut->mBytesReaded)); + + pClientUnique->Send(pRdMemOut, pRdMemOut->mBytesReaded != -1 ? pRdMemOut->mBytesReaded + sizeof(int64_t) : sizeof(int64_t)); +} + +void HandleCmdWriteMemory(ClientSocketLinux* pClientUnique, void* pInPacket) +{ + Packet* pckt = (Packet*)pInPacket; + HANDLE_API hProc = pckt->getPayload()->mhProc; + WriteMemoryOut pWrMemOut{}; + const OpenedProcessInfo* hProcInf = gProcs[pClientUnique]; + + pWrMemOut.mBytesWrited = -1; + + if(hProcInf && hProc == hProcInf->mProcess->getMemFd()) + { + printf("Writing %d bytes\n", int(pckt->getPayload()->mSize)); + pWrMemOut.mBytesWrited = hProcInf->mProcess->WriteMemory(pckt->getPayload()->mAddr, pckt->getPayload()->mBuff, pckt->getPayload()->mSize); + } + + printf("%d Bytes Writed\n", int(pWrMemOut.mBytesWrited)); + pClientUnique->Send(&pWrMemOut, sizeof(pWrMemOut)); +} + +std::function gfnHandleConn = [](ClientSocketLinux* pClientSocket) +{ + unsigned char packet[MAX_PACKET_SIZE + 1]{0}; + short* pCmdId = (short*)packet; + bool bDisconnecting = false; + uintptr_t outRecvSize = 0; + bool bFirstTime = true; + + gSnapProcs[pClientSocket] = std::vector(); + gSnapMods[pClientSocket] = std::vector(); + gProcs[pClientSocket] = nullptr; + + printf("Client Connected\n"); + + while(!bDisconnecting && pClientSocket->Recive(packet, MAX_PACKET_SIZE, &outRecvSize)) + { + if(bFirstTime) + { + if(*pCmdId != CMD_HI) + return; + + bFirstTime = false; + } + + switch(*pCmdId) + { + case CMD_HI: HandleCmdHi(pClientSocket); break; + case CMD_CREATE_REMOTE_TOOL_HELP: HandleCmdCreateToolHelp(pClientSocket, packet); break; + case CMD_PROCESS_FIRST: HandleToolOp(pClientSocket, packet, true); break; + case CMD_PROCESS_NEXT: HandleToolOp(pClientSocket, packet, false); break; + case CMD_MODULE_FIRST: HandleToolOp(pClientSocket, packet, true); break; + case CMD_MODULE_NEXT: HandleToolOp(pClientSocket, packet, false); break; + case CMD_SECTION_FIRST: HandleToolOp(pClientSocket, packet, true); break; + case CMD_SECTION_NEXT: HandleToolOp(pClientSocket, packet, false); break; + case CMD_REMOVE_REMOTE_PROCS_TOOL_HELP: HandleCmdRemoveProcsToolHelp(pClientSocket, packet); break; + //case CMD_REMOVE_REMOTE_MODS_TOOL_HELP: HandleCmdRemoveProcsToolHelp(pClientSocket, packet); break; // TODO + //case CMD_REMOVE_REMOTE_SECS_TOOL_HELP: HandleCmdRemoveProcsToolHelp(pClientSocket, packet); break; // TODO + case CMD_OPEN_REMOTE_PROCESS: HandleCmdOpenProcess(pClientSocket, packet); break; + //case CMD_CLOSE_REMOTE_PROCESS: HandleCmdCloseProcess(pClientSocket, packet); break; // TODO + case CMD_READ_MEMORY_CHUCK: HandleCmdReadMemory(pClientSocket, packet); break; + case CMD_WRITE_MEMORY_CHUCK: HandleCmdWriteMemory(pClientSocket, packet); break; // TODO + case CMD_STATUS: HandleCmdStatus(pClientSocket); break; + case CMD_DISCONNECT: HandleCmdDisconnect(pClientSocket); bDisconnecting = true; break; + } + } + + LEAVE: + HandleDisconnect(pClientSocket); + delete pClientSocket; +}; \ No newline at end of file diff --git a/NativeCore/Android/jni/Remote.h b/NativeCore/Android/jni/Remote.h new file mode 100644 index 00000000..4e081409 --- /dev/null +++ b/NativeCore/Android/jni/Remote.h @@ -0,0 +1,7 @@ +#pragma once + +#include + +struct ClientSocketLinux; + +extern std::function gfnHandleConn; \ No newline at end of file diff --git a/NativeCore/Android/jni/SnapshotBase.h b/NativeCore/Android/jni/SnapshotBase.h new file mode 100644 index 00000000..45051d01 --- /dev/null +++ b/NativeCore/Android/jni/SnapshotBase.h @@ -0,0 +1,17 @@ +#pragma once + +#include +#include + +template +struct SnapshotBase { + protected: + short type; + + public: + std::deque mArray; + short getSnapshotType() + { + return type; + } +}; \ No newline at end of file diff --git a/NativeCore/Android/jni/Utils.cpp b/NativeCore/Android/jni/Utils.cpp new file mode 100644 index 00000000..ca366cc9 --- /dev/null +++ b/NativeCore/Android/jni/Utils.cpp @@ -0,0 +1 @@ +#include "Utils.h" \ No newline at end of file diff --git a/NativeCore/Android/jni/Utils.h b/NativeCore/Android/jni/Utils.h new file mode 100644 index 00000000..cc1a5d71 --- /dev/null +++ b/NativeCore/Android/jni/Utils.h @@ -0,0 +1,18 @@ +#pragma once + +#include +#include +#include + +template +bool UMapExist(const std::unordered_map& map, const T& key) +{ + return map.find(key) != map.end(); +} + +template +void StoreUMap(const std::unordered_map& uMap, std::vector>& outVec) +{ + for (const auto& kv : uMap) + outVec.push_back(kv); +} \ No newline at end of file diff --git a/NativeCore/Android/jni/main.cpp b/NativeCore/Android/jni/main.cpp new file mode 100644 index 00000000..248fe95c --- /dev/null +++ b/NativeCore/Android/jni/main.cpp @@ -0,0 +1,40 @@ +#include "stdio.h" +#include +#include +#include +#include +#include +#include + +int main() +{ + std::unique_ptr pServerSocket = std::make_unique("127.0.0.1", API_PORT); + + if(!pServerSocket->Init()) + { + printf("Error, Cant create the server"); + } + + // Server Main Loop + std::unordered_map> allConn; + + while(true) + { + SocketWrapper* pIncomingClient = nullptr; + + if((pIncomingClient = pServerSocket->WaitConnection()) == nullptr) + continue; + + std::unique_ptr clientSocket = std::unique_ptr(pIncomingClient); + + std::unique_ptr currConn = std::make_unique(); + + currConn->setClientSocket(clientSocket); + + currConn->RunThread(); + + allConn[currConn.get()] = std::move(currConn); + } + + return 0; +} \ No newline at end of file diff --git a/NativeCore/Android/libs/arm64-v8a/rcserver b/NativeCore/Android/libs/arm64-v8a/rcserver new file mode 100644 index 00000000..912522ab Binary files /dev/null and b/NativeCore/Android/libs/arm64-v8a/rcserver differ diff --git a/NativeCore/Android/libs/armeabi-v7a/rcserver b/NativeCore/Android/libs/armeabi-v7a/rcserver new file mode 100644 index 00000000..87e68b81 Binary files /dev/null and b/NativeCore/Android/libs/armeabi-v7a/rcserver differ diff --git a/NativeCore/Shared/API.h b/NativeCore/Shared/API.h new file mode 100644 index 00000000..72cfac15 --- /dev/null +++ b/NativeCore/Shared/API.h @@ -0,0 +1,152 @@ +#pragma once + +#include "PackDefs.h" + +typedef int32_t HANDLE_API; + +#define CMD_OK 1 +#define CMD_HI 2 +#define CMD_DISCONNECT 3 +#define CMD_WELLCOME 4 +#define CMD_CREATE_REMOTE_TOOL_HELP 5 +#define CMD_REMOVE_REMOTE_PROCS_TOOL_HELP 6 +#define CMD_REMOVE_REMOTE_MODS_TOOL_HELP 7 +#define CMD_REMOVE_REMOTE_SECS_TOOL_HELP 8 +#define CMD_STATUS 9 +#define CMD_PROCESS_FIRST 10 +#define CMD_PROCESS_NEXT 11 +#define CMD_MODULE_FIRST 12 +#define CMD_MODULE_NEXT 13 +#define CMD_SECTION_FIRST 14 +#define CMD_SECTION_NEXT 15 +#define CMD_OPEN_REMOTE_PROCESS 16 +#define CMD_CLOSE_REMOTE_PROCESS 17 +#define CMD_READ_MEMORY_CHUCK 18 +#define CMD_WRITE_MEMORY_CHUCK 19 + +#define API_PORT 3443 +#define MAX_PACKET_SIZE 4096 +#define MAX_PROC_NAME 360 + +enum HandleValue { + INVALID = -1, + NONE +}; + +enum ToolType { + PROCS, + MODULES, + SECTIONS +}; + +/* Perspective of the packet structures*/ +/*struct [Name]In <-- In in perspective o Server*/ +/*struct [Name]Out --> Are Going Out of the server*/ +/*This server is asuming, Host and Dest are same endianesses*/ +/*We can even consider a TODO of the endianesses conversions*/ + +#define CREATE_TOOL_PACKETS(toolName, payloadType) \ +PACK(struct toolName##FirstIn{ \ + HANDLE_API mHandleSnap; \ +}); \ +PACK(struct toolName##FirstOut { \ + payloadType mInfo; \ + bool mRemaining; \ +}); \ +PACK(struct toolName##NextIn { \ + HANDLE_API mHandleSnap; \ +}); \ +PACK(struct toolName##NextOut { \ + payloadType mInfo; \ + bool mRemaining; \ +}); + +PACK(struct CreateRemoteToolHelpIn { + uint16_t mToolType; + uint32_t mProcessId; +}); + +PACK(struct CreateRemoteToolHelpOut { + HANDLE_API mHandleTool; +}); + +PACK(struct RemoveRemoteProcsToolHelpIn { + HANDLE_API mHandleSnap; +}); + +PACK(struct RemoveRemoteModsToolHelpIn { + HANDLE_API mHandleSnap; +}); + +PACK(struct RemoveRemoteSecsToolHelpIn { + HANDLE_API mHandleSnap; +}); + +// Proceses +PACK(struct ProcessInfo { + int32_t mProcessId; + char mProcessName[MAX_PROC_NAME]{}; +}); + +CREATE_TOOL_PACKETS(Process, ProcessInfo) + + +// Modules +PACK(struct ModuleInfo { + uint64_t mBase; + uint64_t mSize; + char mPath[260]; +}); + +CREATE_TOOL_PACKETS(Module, ModuleInfo) + +// Sections +enum class SectionProtection; +enum class SectionType; + +PACK(struct SectionInfo { + uint64_t mStart; + uint64_t mEnd; + SectionType mType; // TODO + SectionProtection mProt; + char mPath[260]; +}); + +CREATE_TOOL_PACKETS(Section, SectionInfo) + +PACK(struct OpenRemoteProcessIn { + uint32_t mProcessId; + uint32_t mFlagsAccess; // TODO, ignored for now +}); + +PACK(struct ReadMemoryIn { + HANDLE_API mhProc; + uint64_t mAddr; + uint64_t mSize; +}); + +PACK(struct ReadMemoryOut { + int64_t mBytesReaded; + uint8_t mBuff[1]; +}); + +PACK(struct WriteMemoryIn { + HANDLE_API mhProc; + uint64_t mAddr; + uint64_t mSize; + uint8_t mBuff[1]; +}); + +PACK(struct WriteMemoryOut { + int64_t mBytesWrited; +}); + +PACK(struct OpenRemoteProcessOut { + HANDLE_API hProc; +}); + +enum class ClientStatus { + CONN_OK, + CONN_ALREDY, + CONN_FAILED +}; \ No newline at end of file diff --git a/NativeCore/Shared/IProcess.h b/NativeCore/Shared/IProcess.h new file mode 100644 index 00000000..e07c3632 --- /dev/null +++ b/NativeCore/Shared/IProcess.h @@ -0,0 +1,46 @@ +#pragma once + +#include +#include +#include + +class Process { +protected: + uintptr_t pid; +public: + Process(uintptr_t _pid) + : pid(_pid) + {} + + ~Process() = default; + + virtual int ReadMemory(uintptr_t addr, void* buffer, size_t size) = 0; + + virtual int WriteMemory(uintptr_t addr, void* buffer, size_t size) = 0; + + uintptr_t getProcId() + { + return pid; + } + + virtual Process* Clone() = 0; + + template + T ReadMemoryWrapper(uintptr_t addr) + { + T obj; + + ReadMemory(addr, &obj, sizeof(obj)); + + return obj; + } + + template + bool WriteMemoryWrapper(uintptr_t addr, const T& obj) + { + return WriteMemory(addr, &obj, sizeof(T)); + } + + virtual bool isOpen() = 0; +}; + diff --git a/NativeCore/Shared/PackDefs.h b/NativeCore/Shared/PackDefs.h new file mode 100644 index 00000000..826603be --- /dev/null +++ b/NativeCore/Shared/PackDefs.h @@ -0,0 +1,9 @@ +#pragma once + +#ifdef __GNUC__ +#define PACK( __Declaration__ ) __Declaration__ __attribute__((__packed__)) +#endif + +#ifdef _MSC_VER +#define PACK( __Declaration__ ) __pragma( pack(push, 1) ) __Declaration__ __pragma( pack(pop)) +#endif \ No newline at end of file diff --git a/NativeCore/Shared/Packet.h b/NativeCore/Shared/Packet.h new file mode 100644 index 00000000..b862df3d --- /dev/null +++ b/NativeCore/Shared/Packet.h @@ -0,0 +1,44 @@ +#pragma once + +#include +#include +#include "PackDefs.h" + + + +template +#pragma pack( push, 1 ) +struct Packet { + uint16_t mPacketId = packetId; + PacketType mPacketContent {}; + + void* getEntry() + { + return this; + } + + size_t getSize() + { + return sizeof(PacketType) + sizeof(uint16_t); + } + + PacketType* getPayload() + { + return &mPacketContent; + } + + void Print() + { + for(int i = 0; i < getSize(); i++) + printf("%02X ", ((uint8_t*)this)[i]); + + printf("\n"); + } + + void SetPacketid(short pcktId) + { + mPacketId = pcktId; + } +}; + +#pragma pack( pop ) \ No newline at end of file diff --git a/NativeCore/Shared/SocketWrapper.cpp b/NativeCore/Shared/SocketWrapper.cpp new file mode 100644 index 00000000..2e20384c --- /dev/null +++ b/NativeCore/Shared/SocketWrapper.cpp @@ -0,0 +1,16 @@ +#include "SocketWrapper.h" + +bool SocketWrapper::SendMsg(int32_t id) +{ + return Send(&id, sizeof(int32_t)); +} + +int32_t SocketWrapper::GetMsg() +{ + int32_t id; + + if(!Recive(&id, sizeof(int32_t))) + id = -1; + + return id; +} diff --git a/NativeCore/Shared/SocketWrapper.h b/NativeCore/Shared/SocketWrapper.h new file mode 100644 index 00000000..eee85686 --- /dev/null +++ b/NativeCore/Shared/SocketWrapper.h @@ -0,0 +1,28 @@ +#pragma once +#include + +class SocketWrapper { +protected: + std::string ip; + short port; +public: + SocketWrapper() + : ip("") + , port(0x0) + {} + + SocketWrapper(const std::string& _ip, short _port) + : ip(_ip) + , port(_port) + {} + + virtual ~SocketWrapper(){} + + virtual bool Init() = 0; + virtual bool Send(void* buff, uintptr_t size) = 0; + virtual bool Recive(void* buff, uintptr_t size, uintptr_t* outRecvSize = nullptr) = 0; + bool SendMsg(int32_t id); + int32_t GetMsg(); +}; + +#define ASSERT_SOCK_RESULT(x) (-1 != x && x != 0) diff --git a/NativeCore/Unix/FDUtils.h b/NativeCore/Unix/FDUtils.h new file mode 100644 index 00000000..a2a3fa57 --- /dev/null +++ b/NativeCore/Unix/FDUtils.h @@ -0,0 +1,13 @@ +#pragma once +#include +#include "sys/stat.h" + +class FDUtils{ + public: + static bool isValid(int fd) + { + struct stat fdStat; + + return !fstat(fd, &fdStat); + } +}; \ No newline at end of file diff --git a/NativeCore/Unix/LinuxProcess.cpp b/NativeCore/Unix/LinuxProcess.cpp new file mode 100644 index 00000000..f9dab185 --- /dev/null +++ b/NativeCore/Unix/LinuxProcess.cpp @@ -0,0 +1,110 @@ +#include "LinuxProcess.h" +#include +#include +#include +#include + +LinuxProcess::LinuxProcess(uintptr_t _pid) + : Process(_pid) + , mapF(nullptr) + , memFd(-1) +{ + char memPath[1024]; + + sprintf(mapPath, "/proc/%d/maps", int(pid)); + sprintf(memPath, "/proc/%d/mem", int(pid)); + + mapF = fopen(mapPath, "r"); + memFd = open(memPath, O_RDWR); +} + +LinuxProcess::LinuxProcess(void* fd) + : Process(0) + , mapF(nullptr) + , memFd(size_t(fd)) +{} + +LinuxProcess::~LinuxProcess() +{ + if(mapF) + { + fclose(mapF); + } + + if(memFd != -1) + { + close(memFd); + } +} + +int LinuxProcess::ReadMemory(uintptr_t addr, void* buffer, size_t size){ + std::lock_guard lck(ioLock); + + if(lseek64(memFd, addr, SEEK_SET)) + { + return read(memFd, buffer, size); + } + + return -1; +} + +int LinuxProcess::WriteMemory(uintptr_t addr, void* buffer, size_t size){ + std::lock_guard lck(ioLock); + + if(lseek64(memFd, addr, SEEK_SET)) + { + return write(memFd, buffer, size); + } + + return -1; +} + +bool LinuxProcess::Find(const std::string& procName, LinuxProcess** ppOutProc) +{ + DIR* procDir = nullptr; + int cmdLineBuffLen = procName.size() + 1; + + *ppOutProc = nullptr; + + if((procDir = opendir("/proc/")) != nullptr) + { + dirent* currDir = nullptr; + char* cmdLineBuff = (char*)malloc(cmdLineBuffLen); + + while(((currDir = readdir(procDir)) != nullptr) && !*ppOutProc) + { + int currPid = 0; + + if((currPid = atoi(currDir->d_name)) != 0) + { + char cmdLinePath[1024]; + int currProcCmdLineFd = -1; + + sprintf(cmdLinePath, "/proc/%d/cmdline", currPid); + + if((currProcCmdLineFd = open(cmdLinePath, O_RDONLY)) != -1) + { + if(read(currProcCmdLineFd, cmdLineBuff, cmdLineBuffLen)) + { + if(!strcmp(cmdLineBuff, procName.c_str())) + { + *ppOutProc = new LinuxProcess(currPid); + } + } + + close(currProcCmdLineFd); + } + } + } + + free(cmdLineBuff); + closedir(procDir); + + if(*ppOutProc) + { + return true; + } + } + + return (bool)(*ppOutProc); +} \ No newline at end of file diff --git a/NativeCore/Unix/LinuxProcess.h b/NativeCore/Unix/LinuxProcess.h new file mode 100644 index 00000000..b7d64837 --- /dev/null +++ b/NativeCore/Unix/LinuxProcess.h @@ -0,0 +1,51 @@ +#pragma once + +#include "IProcess.h" +#include "FDUtils.h" +#include + +class LinuxProcess : public Process +{ + private: + char mapPath[1024]; + FILE* mapF; + int memFd; + std::mutex ioLock; + public: + LinuxProcess(uintptr_t _pid); + LinuxProcess(void* fd); + + ~LinuxProcess(); + + int ReadMemory(uintptr_t addr, void* buffer, size_t size) override; + + int WriteMemory(uintptr_t addr, void* buffer, size_t size) override; + + Process* Clone() override { + return nullptr; + } + + bool isOpen() override{ + return FDUtils::isValid(memFd); + } + + static bool Find(const std::string& procName, LinuxProcess** ppOutProc); + + void Refresh() + { + fclose(mapF); + mapF = fopen(mapPath, "r"); + } + + FILE* getMapFile() + { + fseek(mapF, 0, SEEK_SET); + + return mapF; + } + + int getMemFd() + { + return memFd; + } +}; \ No newline at end of file diff --git a/NativeCore/Unix/LinuxSocketWrapper.cpp b/NativeCore/Unix/LinuxSocketWrapper.cpp new file mode 100644 index 00000000..d53f9652 --- /dev/null +++ b/NativeCore/Unix/LinuxSocketWrapper.cpp @@ -0,0 +1,127 @@ +#include "LinuxSocketWrapper.h" +#include +#include +#include + +LinuxSocketWrapper::LinuxSocketWrapper(const std::string& _ip, short _port) + : SocketWrapper(_ip, _port) + , bCloseSocket(true) +{} + +bool LinuxSocketWrapper::Init() +{ + // Creating The Socket + family = AF_INET; + + if ((sock = socket(family, SOCK_STREAM, 0)) == -1) + return false; + + return true; +} + + +LinuxSocketWrapper::LinuxSocketWrapper(int _sock) + : sock(_sock) + , bCloseSocket(false) + , sai{} +{} + +LinuxSocketWrapper::~LinuxSocketWrapper() +{ + if(bCloseSocket && sock != -1) + close(sock); +} + +bool LinuxSocketWrapper::Send(void* buff, uintptr_t size) +{ + uintptr_t recvSize = write(sock, buff, size); + + return ASSERT_SOCK_RESULT(recvSize); +} + +bool LinuxSocketWrapper::Recive(void* buff, uintptr_t size, uintptr_t* outRecvSize) +{ + uintptr_t recvSize = read(sock, buff, size); + + if(outRecvSize) + *outRecvSize = recvSize; + + return ASSERT_SOCK_RESULT(recvSize); +} + +ClientSocketLinux::ClientSocketLinux(int _sock) + : LinuxSocketWrapper(_sock) +{} + +ClientSocketLinux::ClientSocketLinux(const std::string& _ip, short _port) + : LinuxSocketWrapper(_ip, _port) +{} + +bool ClientSocketLinux::Init() +{ + if(LinuxSocketWrapper::Init()) + { + // Setting Up Hint Values + sai.sin_family = family; + sai.sin_port = htons(port); + sai.sin_addr.s_addr = inet_addr(ip.c_str()); + + // Making the Connection + if(0 != connect(sock, (const sockaddr*)&sai, sizeof(sai))) + { + close(sock); + return false; + } + + return true; + } + return false; +} + +bool ServerSocketLinux::Init() +{ + if(!LinuxSocketWrapper::Init()) + return false; + + // Forcefully attaching socket to the port 8080 + int opt = 1; + + if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, + &opt, sizeof(opt))) + { + close(sock); + return false; + } + + // Binding the Socket + sai.sin_family = family; + sai.sin_port = htons(port); + sai.sin_addr.s_addr = inet_addr(ip.c_str()); + + if(0 != bind(sock, (const sockaddr*)&sai, sizeof(sai))) + { + close(sock); + return false; + } + + // Making the Socket to Listen + if(0 != listen(sock, SOMAXCONN)) + { + close(sock); + return false; + } + + return true; +} + +ServerSocketLinux::ServerSocketLinux(const std::string& _ip, short _port) + : LinuxSocketWrapper(_ip, _port) +{} + +ClientSocketLinux* ServerSocketLinux::WaitConnection() +{ + //Waiting the COnnection + socklen_t sockAddrLen = sizeof(sai); + + return new ClientSocketLinux(accept(sock, (sockaddr*)&sai, &sockAddrLen)); +} \ No newline at end of file diff --git a/NativeCore/Unix/LinuxSocketWrapper.h b/NativeCore/Unix/LinuxSocketWrapper.h new file mode 100644 index 00000000..2133d69d --- /dev/null +++ b/NativeCore/Unix/LinuxSocketWrapper.h @@ -0,0 +1,36 @@ +#pragma once +#include "../Shared/SocketWrapper.h" +#include + +struct LinuxSocketWrapper : public SocketWrapper{ + private: + bool bCloseSocket; + protected: + int sock; + int family; + struct sockaddr_in sai; + public: + LinuxSocketWrapper(const std::string& _ip, short _port); + LinuxSocketWrapper(int _sock); + ~LinuxSocketWrapper(); + + virtual bool Init() override; + + bool Send(void* buff, uintptr_t size) override; + bool Recive(void* buff, uintptr_t size, uintptr_t* outRecvSize = nullptr) override; +}; + +struct ClientSocketLinux : public LinuxSocketWrapper{ + public: + ClientSocketLinux(int _sock); + ClientSocketLinux(const std::string& _ip, short _port); + bool Init() override; +}; + +struct ServerSocketLinux : public LinuxSocketWrapper{ +private: + public: + ServerSocketLinux(const std::string& _ip, short _port); + bool Init() override; + ClientSocketLinux* WaitConnection(); +}; diff --git a/NativeCore/Unix/NativeCore.Unix.vcxproj b/NativeCore/Unix/NativeCore.Unix.vcxproj index 83bff48a..147a9743 100644 --- a/NativeCore/Unix/NativeCore.Unix.vcxproj +++ b/NativeCore/Unix/NativeCore.Unix.vcxproj @@ -89,6 +89,7 @@ + @@ -97,6 +98,7 @@ + @@ -116,6 +118,8 @@ + + diff --git a/NativeCore/Unix/NativeCore.Unix.vcxproj.filters b/NativeCore/Unix/NativeCore.Unix.vcxproj.filters index 3076be6b..9680bbfb 100644 --- a/NativeCore/Unix/NativeCore.Unix.vcxproj.filters +++ b/NativeCore/Unix/NativeCore.Unix.vcxproj.filters @@ -13,6 +13,9 @@ {976c6ca6-4172-4080-8162-a7913375df1a} + + {a0a634f8-a935-4a80-a6a1-6957d2c86881} + @@ -75,6 +78,12 @@ Shared + + Shared + + + Functions\Networking + @@ -115,5 +124,12 @@ Dependencies\distorm + + + Shared + + + Functions\Networking + \ No newline at end of file diff --git a/NativeCore/Windows/CloseRemoteProcess.cpp b/NativeCore/Windows/CloseRemoteProcess.cpp index 413ef8a1..f5efc8af 100644 --- a/NativeCore/Windows/CloseRemoteProcess.cpp +++ b/NativeCore/Windows/CloseRemoteProcess.cpp @@ -1,6 +1,12 @@ #include #include "NativeCore.hpp" +#include "ServerRemoteTool.h" + +void CloseWindowsHandle(RC_Pointer handle) +{ + CloseHandle(handle); +} void RC_CallConv CloseRemoteProcess(RC_Pointer handle) { @@ -9,5 +15,6 @@ void RC_CallConv CloseRemoteProcess(RC_Pointer handle) return; } - CloseHandle(handle); + if (ServerManager::getInstance()->IsConnected()) CloseServerProcess(handle); + else CloseWindowsHandle(handle); } diff --git a/NativeCore/Windows/EnumerateProcesses.cpp b/NativeCore/Windows/EnumerateProcesses.cpp index 534b4a84..0455f777 100644 --- a/NativeCore/Windows/EnumerateProcesses.cpp +++ b/NativeCore/Windows/EnumerateProcesses.cpp @@ -2,14 +2,18 @@ #include #include #include - #include "NativeCore.hpp" +#include "ServerRemoteTool.h" +#include "Utils.h" + enum class Platform { Unknown, X86, - X64 + X64, + ARM32, + ARM64 }; Platform GetProcessPlatform(HANDLE process) @@ -43,13 +47,8 @@ Platform GetProcessPlatform(HANDLE process) return Platform::Unknown; } -void RC_CallConv EnumerateProcesses(EnumerateProcessCallback callbackProcess) +void EnumerateProcessesWindows(EnumerateProcessCallback callbackProcess) { - if (callbackProcess == nullptr) - { - return; - } - const auto handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); if (handle != INVALID_HANDLE_VALUE) { @@ -62,12 +61,12 @@ void RC_CallConv EnumerateProcesses(EnumerateProcessCallback callbackProcess) const auto process = OpenRemoteProcess(reinterpret_cast(static_cast(pe32.th32ProcessID)), ProcessAccess::Read); if (IsProcessValid(process)) { - const auto platform = GetProcessPlatform(process); -#ifdef RECLASSNET64 + //const auto platform = GetProcessPlatform(process); +/*#ifdef RECLASSNET64 if (platform == Platform::X64) #else if (platform == Platform::X86) -#endif +#endif*/ { EnumerateProcessData data = { }; data.Id = pe32.th32ProcessID; @@ -79,12 +78,23 @@ void RC_CallConv EnumerateProcesses(EnumerateProcessCallback callbackProcess) } } - + CloseRemoteProcess(process); - + } while (Process32NextW(handle, &pe32)); } CloseHandle(handle); } } + +void RC_CallConv EnumerateProcesses(EnumerateProcessCallback callbackProcess) +{ + if (callbackProcess == nullptr) + { + return; + } + + if (ServerManager::getInstance()->IsConnected()) EnumerateProcessesServer(callbackProcess); + else EnumerateProcessesWindows(callbackProcess); +} diff --git a/NativeCore/Windows/EnumerateRemoteSectionsAndModules.cpp b/NativeCore/Windows/EnumerateRemoteSectionsAndModules.cpp index 066b077b..7fbb5be0 100644 --- a/NativeCore/Windows/EnumerateRemoteSectionsAndModules.cpp +++ b/NativeCore/Windows/EnumerateRemoteSectionsAndModules.cpp @@ -6,6 +6,7 @@ #include #include "NativeCore.hpp" +#include "ServerRemoteTool.h" PPEB GetRemotePeb(const HANDLE process) { @@ -110,15 +111,9 @@ bool EnumerateRemoteModulesWinapi(const RC_Pointer process, const InternalEnumer return true; } -void RC_CallConv EnumerateRemoteSectionsAndModules(RC_Pointer process, EnumerateRemoteSectionsCallback callbackSection, EnumerateRemoteModulesCallback callbackModule) +void EnumerateRemoteSectionsAndModulesWindows(RC_Pointer process, EnumerateRemoteSectionsCallback callbackSection, EnumerateRemoteModulesCallback callbackModule) { - if (callbackSection == nullptr && callbackModule == nullptr) - { - return; - } - std::vector sections; - MEMORY_BASIC_INFORMATION memory = { }; memory.RegionSize = 0x1000; size_t address = 0; @@ -129,7 +124,7 @@ void RC_CallConv EnumerateRemoteSectionsAndModules(RC_Pointer process, Enumerate EnumerateRemoteSectionData section = {}; section.BaseAddress = memory.BaseAddress; section.Size = memory.RegionSize; - + section.Protection = SectionProtection::NoAccess; if ((memory.Protect & PAGE_EXECUTE) == PAGE_EXECUTE) section.Protection |= SectionProtection::Execute; if ((memory.Protect & PAGE_EXECUTE_READ) == PAGE_EXECUTE_READ) section.Protection |= SectionProtection::Execute | SectionProtection::Read; @@ -139,7 +134,7 @@ void RC_CallConv EnumerateRemoteSectionsAndModules(RC_Pointer process, Enumerate if ((memory.Protect & PAGE_READWRITE) == PAGE_READWRITE) section.Protection |= SectionProtection::Read | SectionProtection::Write; if ((memory.Protect & PAGE_WRITECOPY) == PAGE_WRITECOPY) section.Protection |= SectionProtection::Read | SectionProtection::CopyOnWrite; if ((memory.Protect & PAGE_GUARD) == PAGE_GUARD) section.Protection |= SectionProtection::Guard; - + switch (memory.Type) { case MEM_IMAGE: @@ -170,9 +165,9 @@ void RC_CallConv EnumerateRemoteSectionsAndModules(RC_Pointer process, Enumerate if (callbackSection != nullptr) { auto it = std::lower_bound(std::begin(sections), std::end(sections), static_cast(data.BaseAddress), [§ions](const auto& lhs, const LPVOID& rhs) - { - return lhs.BaseAddress < rhs; - }); + { + return lhs.BaseAddress < rhs; + }); IMAGE_DOS_HEADER imageDosHeader = {}; IMAGE_NT_HEADERS imageNtHeaders = {}; @@ -192,8 +187,8 @@ void RC_CallConv EnumerateRemoteSectionsAndModules(RC_Pointer process, Enumerate for (; it != std::end(sections); ++it) { auto&& section = *it; - - if (sectionAddress >= reinterpret_cast(section.BaseAddress) + + if (sectionAddress >= reinterpret_cast(section.BaseAddress) && sectionAddress < reinterpret_cast(section.BaseAddress) + static_cast(section.Size) && sectionHeader.VirtualAddress + sectionHeader.Misc.VirtualSize <= data.Size) { @@ -213,7 +208,7 @@ void RC_CallConv EnumerateRemoteSectionsAndModules(RC_Pointer process, Enumerate std::memcpy(buffer, sectionHeader.Name, IMAGE_SIZEOF_SHORT_NAME); MultiByteToUnicode(buffer, section.Name, IMAGE_SIZEOF_SHORT_NAME); } - catch (std::range_error &) + catch (std::range_error&) { std::memset(section.Name, 0, sizeof(section.Name)); } @@ -225,7 +220,7 @@ void RC_CallConv EnumerateRemoteSectionsAndModules(RC_Pointer process, Enumerate } } }; - + if (!EnumerateRemoteModulesNative(process, moduleEnumerator)) { EnumerateRemoteModulesWinapi(process, moduleEnumerator); @@ -239,3 +234,14 @@ void RC_CallConv EnumerateRemoteSectionsAndModules(RC_Pointer process, Enumerate } } } + +void RC_CallConv EnumerateRemoteSectionsAndModules(RC_Pointer process, EnumerateRemoteSectionsCallback callbackSection, EnumerateRemoteModulesCallback callbackModule) +{ + if (callbackSection == nullptr && callbackModule == nullptr) + { + return; + } + + if(ServerManager::getInstance()->IsConnected()) EnumerateRemoteSectionsAndModulesServer(process, callbackSection, callbackModule); + else EnumerateRemoteSectionsAndModulesWindows(process, callbackSection, callbackModule); +} diff --git a/NativeCore/Windows/IsProcessValid.cpp b/NativeCore/Windows/IsProcessValid.cpp index 7f880dfe..4b4b86f3 100644 --- a/NativeCore/Windows/IsProcessValid.cpp +++ b/NativeCore/Windows/IsProcessValid.cpp @@ -1,8 +1,9 @@ #include #include "NativeCore.hpp" +#include "ServerRemoteTool.h" -bool RC_CallConv IsProcessValid(RC_Pointer handle) +bool IsProcessValidWindows(RC_Pointer handle) { if (handle == nullptr) { @@ -17,3 +18,9 @@ bool RC_CallConv IsProcessValid(RC_Pointer handle) return retn == WAIT_TIMEOUT; } + +bool RC_CallConv IsProcessValid(RC_Pointer handle) +{ + if(!ServerManager::getInstance()->IsConnected()) return IsProcessValidWindows(handle); + return true; // TODO +} diff --git a/NativeCore/Windows/NativeCore.hpp b/NativeCore/Windows/NativeCore.hpp index db0fa692..db95611d 100644 --- a/NativeCore/Windows/NativeCore.hpp +++ b/NativeCore/Windows/NativeCore.hpp @@ -23,4 +23,6 @@ bool RC_CallConv SetHardwareBreakpoint(RC_Pointer id, RC_Pointer address, Hardwa RC_Pointer RC_CallConv InitializeInput(); bool RC_CallConv GetPressedKeys(RC_Pointer handle, Keys* state[], int* count); -void RC_CallConv ReleaseInput(RC_Pointer handle); \ No newline at end of file +void RC_CallConv ReleaseInput(RC_Pointer handle); +int32_t RC_CallConv ConnectServer(const char* pIpStr, short port); +void RC_CallConv DisconnectServer(); \ No newline at end of file diff --git a/NativeCore/Windows/NativeCore.vcxproj b/NativeCore/Windows/NativeCore.vcxproj index 5600a51a..1892288d 100644 --- a/NativeCore/Windows/NativeCore.vcxproj +++ b/NativeCore/Windows/NativeCore.vcxproj @@ -179,6 +179,7 @@ + @@ -189,6 +190,10 @@ + + + + @@ -207,9 +212,17 @@ + + + + + + + + diff --git a/NativeCore/Windows/NativeCore.vcxproj.filters b/NativeCore/Windows/NativeCore.vcxproj.filters index eb42b939..7c86978f 100644 --- a/NativeCore/Windows/NativeCore.vcxproj.filters +++ b/NativeCore/Windows/NativeCore.vcxproj.filters @@ -61,6 +61,21 @@ Shared + + Functions\Networking + + + Shared + + + Functions\Networking + + + Functions\Networking + + + Shared + @@ -78,6 +93,9 @@ {faf06b55-02ad-4707-a65d-37e1c0d13640} + + {a6132f88-9963-44aa-880f-f93f8367980c} + @@ -121,5 +139,29 @@ Dependencies\distorm + + Functions\Networking + + + Shared + + + Shared + + + Shared + + + Shared + + + Functions\Networking + + + Shared + + + Shared + \ No newline at end of file diff --git a/NativeCore/Windows/OpenRemoteProcess.cpp b/NativeCore/Windows/OpenRemoteProcess.cpp index d8944dd3..a231cb4e 100644 --- a/NativeCore/Windows/OpenRemoteProcess.cpp +++ b/NativeCore/Windows/OpenRemoteProcess.cpp @@ -1,21 +1,22 @@ #include #include "NativeCore.hpp" +#include "ServerRemoteTool.h" -RC_Pointer RC_CallConv OpenRemoteProcess(RC_Pointer id, ProcessAccess desiredAccess) +RC_Pointer OpenRemoteProcessWindows(RC_Pointer id, ProcessAccess desiredAccess) { DWORD access = STANDARD_RIGHTS_REQUIRED | PROCESS_TERMINATE | PROCESS_QUERY_INFORMATION | SYNCHRONIZE; switch (desiredAccess) { - case ProcessAccess::Read: - access |= PROCESS_VM_READ; - break; - case ProcessAccess::Write: - access |= PROCESS_VM_OPERATION | PROCESS_VM_WRITE; - break; - case ProcessAccess::Full: - access |= PROCESS_VM_READ | PROCESS_VM_OPERATION | PROCESS_VM_WRITE; - break; + case ProcessAccess::Read: + access |= PROCESS_VM_READ; + break; + case ProcessAccess::Write: + access |= PROCESS_VM_OPERATION | PROCESS_VM_WRITE; + break; + case ProcessAccess::Full: + access |= PROCESS_VM_READ | PROCESS_VM_OPERATION | PROCESS_VM_WRITE; + break; } const auto handle = OpenProcess(access, FALSE, static_cast(reinterpret_cast(id))); @@ -27,3 +28,9 @@ RC_Pointer RC_CallConv OpenRemoteProcess(RC_Pointer id, ProcessAccess desiredAcc return handle; } + +RC_Pointer RC_CallConv OpenRemoteProcess(RC_Pointer id, ProcessAccess desiredAccess) +{ + if (ServerManager::getInstance()->IsConnected()) return OpenRemoteProcessServer(id); + else return OpenRemoteProcessWindows(id, desiredAccess); +} diff --git a/NativeCore/Windows/ReadRemoteMemory.cpp b/NativeCore/Windows/ReadRemoteMemory.cpp index a29b8ae2..4ee8beba 100644 --- a/NativeCore/Windows/ReadRemoteMemory.cpp +++ b/NativeCore/Windows/ReadRemoteMemory.cpp @@ -1,16 +1,25 @@ #include #include "NativeCore.hpp" +#include "ServerRemoteTool.h" + +int ReadMemoryWindows(RC_Pointer handle, RC_Pointer address, RC_Pointer buffer, int size) +{ + SIZE_T numberOfBytesRead; + + if (!ReadProcessMemory(handle, address, buffer, size, &numberOfBytesRead)) + return -1; + + return numberOfBytesRead; +} bool RC_CallConv ReadRemoteMemory(RC_Pointer handle, RC_Pointer address, RC_Pointer buffer, int offset, int size) { + int numberOfBytesReaded; buffer = reinterpret_cast(reinterpret_cast(buffer) + offset); - SIZE_T numberOfBytesRead; - if (ReadProcessMemory(handle, address, buffer, size, &numberOfBytesRead) && size == numberOfBytesRead) - { - return true; - } + if (ServerManager::getInstance()->PartiallyConnected()) numberOfBytesReaded = ReadMemoryServer(handle, address, buffer, size); + else numberOfBytesReaded = ReadMemoryWindows(handle, address, buffer, size); - return false; + return size == numberOfBytesReaded; } diff --git a/NativeCore/Windows/ServerManager.cpp b/NativeCore/Windows/ServerManager.cpp new file mode 100644 index 00000000..a4b76364 --- /dev/null +++ b/NativeCore/Windows/ServerManager.cpp @@ -0,0 +1,82 @@ +#include "ServerRemoteTool.h" +#include "WindowsSocketWrapper.h" + +ServerManager* ServerManager::mInstance = nullptr; + +ServerManager::ServerManager() : mSocket(nullptr) {} + +ServerManager::~ServerManager() { + Disconnect(); +} + +bool ServerManager::Disconnect() +{ + std::lock_guard lck(gMtxReq); + if (mSocket) mSocket->SendMsg(CMD_DISCONNECT); + + CleanUp(); + + return true; +} + +bool ServerManager::IsConnected() +{ + return PartiallyConnected() && CheckConnection(); +} + +bool ServerManager::CheckConnection() +{ + std::lock_guard lck(gMtxReq); + mSocket->SendMsg(CMD_STATUS); + + if (mSocket->GetMsg() == CMD_OK) + return true; + + return false; +} + +bool ServerManager::CleanUp() +{ + if (mSocket) + delete mSocket; + + mSocket = nullptr; + + return true; +} + +bool ServerManager::TryConnect(const std::string& ip, short port) +{ + std::lock_guard lck(gMtxReq); + mSocket = new ClientSocketWindows(ip, port); + + if (mSocket) + { + if (mSocket->Init()) + { + if (mSocket->SendMsg(CMD_HI)) + { + if (mSocket->GetMsg() == CMD_WELLCOME) + return true; + } + } + } + + CleanUp(); + return false; +} + +ClientSocketWindows* ServerManager::getServerSocket() { return mSocket; } + +ServerManager* ServerManager::getInstance() +{ + if (!mInstance) + mInstance = new ServerManager(); + + return mInstance; +} + +bool ServerManager::PartiallyConnected() +{ + return mSocket != nullptr; +} \ No newline at end of file diff --git a/NativeCore/Windows/ServerRemoteTool.cpp b/NativeCore/Windows/ServerRemoteTool.cpp new file mode 100644 index 00000000..21e56333 --- /dev/null +++ b/NativeCore/Windows/ServerRemoteTool.cpp @@ -0,0 +1,355 @@ +#include "ServerRemoteTool.h" +#include "NativeCore.hpp" + +#include "WindowsSocketWrapper.h" +#include "../Shared/API.h" +#include "../Shared/Packet.h" +#include +#include "Utils.h" + +unsigned char gPacketHolder[MAX_PACKET_SIZE + 1]{ 0 }; +std::mutex gMtxReq; + +int32_t RC_CallConv ConnectServer(const char* pIpStr, short port) +{ + auto* pServerMgr = ServerManager::getInstance(); + + if (pServerMgr->IsConnected()) + return 1; + + pServerMgr->CleanUp(); + + if (pServerMgr->TryConnect(std::string(pIpStr), port)) + return 0; + else + return 2; +} + +void RC_CallConv DisconnectServer() +{ + ServerManager::getInstance()->Disconnect(); +} + +HANDLE_API CreateRemoteTool(uint32_t type, uint32_t pid) +{ + std::lock_guard lck(gMtxReq); + auto* pSocket = ServerManager::getInstance()->getServerSocket(); + Packet pckt; + + pckt.getPayload()->mProcessId = pid; + pckt.getPayload()->mToolType = type; + + if (pSocket->Send(pckt.getEntry(), pckt.getSize())) + { + if (pSocket->Recive(gPacketHolder, MAX_PACKET_SIZE)) + return ((CreateRemoteToolHelpOut*)gPacketHolder)->mHandleTool; + } + + return HandleValue::INVALID; +} + +void RemoveRemoteProcsTool(HANDLE_API hTool) +{ + std::lock_guard lck(gMtxReq); + auto* pSocket = ServerManager::getInstance()->getServerSocket(); + Packet pckt; + + pckt.getPayload()->mHandleSnap = hTool; + + pSocket->Send(pckt.getEntry(), pckt.getSize()); +} + +template +bool ToolOp(HANDLE_API hSnap, ToolType* pPi) +{ + std::lock_guard lck(gMtxReq); + auto* pSocket = ServerManager::getInstance()->getServerSocket(); + Packet pckt{}; + + pckt.getPayload()->mHandleSnap = hSnap; + + if (pSocket->Send(pckt.getEntry(), pckt.getSize())) + { + if (pSocket->Recive(gPacketHolder, MAX_PACKET_SIZE)) + { + PacketOut* pOut = ((PacketOut*)gPacketHolder); + *pPi = pOut->mInfo; + + return pOut->mRemaining; + } + } + + return false; +} + +void CloseServerProcess(HANDLE_API hProc) +{ + +} + +std::unordered_map gPids; + +uint32_t PidFromHandle(HANDLE_API hProc) +{ + if (gPids.find(hProc) != gPids.end()) + return gPids[hProc]; + + return 0; +} + +RC_Pointer OpenRemoteProcessServer(RC_Pointer id) +{ + std::lock_guard lck(gMtxReq); + auto* pSocket = ServerManager::getInstance()->getServerSocket(); + Packet pckt; + + pckt.getPayload()->mProcessId = (uint32_t)id; + pckt.getPayload()->mFlagsAccess = 0; // TODO, ignored for now + + if (pSocket->Send(pckt.getEntry(), pckt.getSize())) + { + if (pSocket->Recive(gPacketHolder, MAX_PACKET_SIZE)) + { + HANDLE_API hProc = ((OpenRemoteProcessOut*)gPacketHolder)->hProc; + + if (hProc != HandleValue::INVALID) + gPids[hProc] = (uint32_t)id; + + return (RC_Pointer)hProc; + } + + } + + return (RC_Pointer)HandleValue::INVALID; +} + +int ReadMemoryChuckServer(HANDLE_API handle, uint64_t address, RC_Pointer buffer, int size) +{ + std::lock_guard lck(gMtxReq); + int bytesReaded = -1; + + if (size <= (MAX_PACKET_SIZE - sizeof(int64_t))) + { + auto* pSocket = ServerManager::getInstance()->getServerSocket(); + Packet pckt; + + pckt.getPayload()->mAddr = address; + pckt.getPayload()->mSize = size; + pckt.getPayload()->mhProc = handle; + + if (pSocket->Send(pckt.getEntry(), pckt.getSize())) + { + if (pSocket->Recive(gPacketHolder, MAX_PACKET_SIZE)) + { + ReadMemoryOut* pRdMemOut = (ReadMemoryOut*)(gPacketHolder); + + if((bytesReaded = pRdMemOut->mBytesReaded) != -1) + memcpy(buffer, pRdMemOut->mBuff, pRdMemOut->mBytesReaded); + } + } + } + + return bytesReaded; +} + +int WriteMemoryChuckServer(HANDLE_API handle, uint64_t address, RC_Pointer buffer, int size) +{ + std::lock_guard lck(gMtxReq); + int bytesWrited = -1; + constexpr size_t pcktHeaderSize = sizeof(uint64_t) * 2 + sizeof(uint32_t); + + if (size <= (MAX_PACKET_SIZE - pcktHeaderSize)) + { + auto* pSocket = ServerManager::getInstance()->getServerSocket(); + Packet* pckt = (Packet*)gPacketHolder; + + pckt->SetPacketid(CMD_WRITE_MEMORY_CHUCK); + pckt->getPayload()->mAddr = address; + pckt->getPayload()->mSize = size; + pckt->getPayload()->mhProc = handle; + + memcpy(pckt->getPayload()->mBuff, buffer, size); + + if (pSocket->Send(pckt->getEntry(), pcktHeaderSize + size)) + { + if (pSocket->Recive(gPacketHolder, MAX_PACKET_SIZE)) + { + WriteMemoryOut* pWrMemOut = (WriteMemoryOut*)(gPacketHolder); + bytesWrited = pWrMemOut->mBytesWrited; + } + } + } + + return bytesWrited; +} + +int ReadMemoryServer(RC_Pointer handle, RC_Pointer address, RC_Pointer buffer, int size) +{ + uint64_t bytesReaded = -1; + constexpr size_t rdMemMaxPacketSize = MAX_PACKET_SIZE - sizeof(int64_t); + + if (size > rdMemMaxPacketSize) // need split? + { + bytesReaded = 0; + int nSends = (int)(size / rdMemMaxPacketSize); + int64_t currBytesReaded = 0; + + uint64_t offset = 0; + + for (int i = 0; i < nSends; i++, offset += rdMemMaxPacketSize) + { + currBytesReaded = 0; + + if ((currBytesReaded = ReadMemoryChuckServer((HANDLE_API)handle, ((uintptr_t)address) + offset, (RC_Pointer)((uintptr_t)buffer + offset), rdMemMaxPacketSize)) == -1) + return bytesReaded; + + bytesReaded += currBytesReaded; + } + + // Reading Bytes Remainings + currBytesReaded = ReadMemoryChuckServer((HANDLE_API)handle, (uintptr_t)address + bytesReaded, (RC_Pointer)((uintptr_t)buffer + bytesReaded), size % rdMemMaxPacketSize); + + bytesReaded = currBytesReaded != -1 ? bytesReaded + currBytesReaded : bytesReaded; + } + else + bytesReaded = ReadMemoryChuckServer((HANDLE_API)handle, (uintptr_t)address, buffer, size); + + return bytesReaded; +} + +int WriteMemoryServer(RC_Pointer handle, RC_Pointer address, RC_Pointer buffer, int size) +{ + uint64_t bytesWrited = -1; + constexpr size_t rdMemMaxPacketSize = MAX_PACKET_SIZE - (sizeof(int64_t) * 2 + sizeof(HANDLE_API)); + + if (size <= rdMemMaxPacketSize) bytesWrited = WriteMemoryChuckServer((HANDLE_API)handle, (uint64_t)address, buffer, size); + + return bytesWrited; +} + +void RemoveRemoteModulesTool(HANDLE_API hSnap) +{ + std::lock_guard lck(gMtxReq); + auto* pSocket = ServerManager::getInstance()->getServerSocket(); + Packet pckt; + + pckt.getPayload()->mHandleSnap = hSnap; + + pSocket->Send(pckt.getEntry(), pckt.getSize()); +} + +void RemoveRemoteSectionsTool(HANDLE_API hSnap) +{ + std::lock_guard lck(gMtxReq); + auto* pSocket = ServerManager::getInstance()->getServerSocket(); + Packet pckt; + + pckt.getPayload()->mHandleSnap = hSnap; + + pSocket->Send(pckt.getEntry(), pckt.getSize()); +} + +void EnumerateRemoteSectionsServer(HANDLE_API hProc, EnumerateRemoteSectionsCallback callbackSection) +{ + HANDLE_API hSnap = CreateRemoteTool(ToolType::SECTIONS, PidFromHandle(hProc)); + + if (hSnap != HandleValue::INVALID) + { + SectionInfo si{}; + + if (ToolOp(hSnap, &si)) + { + do { + EnumerateRemoteSectionData ermd{}; + + ermd.BaseAddress = (RC_Pointer)si.mStart; + ermd.Type = si.mType; // TODO + ermd.Size = si.mEnd - si.mStart; + ermd.Protection = si.mProt; + ermd.Category = SectionCategory::Unknown; // TODO + + constexpr int32_t RdProt = (int)SectionProtection::Read; + constexpr int32_t RdWrProt = (int)SectionProtection::Read | (int)SectionProtection::Write; + constexpr int32_t ExProt = (int)SectionProtection::Execute; + + if (((int32_t)ermd.Protection & ExProt) == ExProt) + ermd.Category = SectionCategory::CODE; + else if(((int32_t)ermd.Protection & RdProt) == RdProt || + ((int32_t)ermd.Protection & RdWrProt) == RdWrProt) + ermd.Category = SectionCategory::DATA; + + lstrcpyW((wchar_t*)ermd.Name, L""); // TODO + lstrcpyW((wchar_t*)ermd.ModulePath, StrtoWStr(std::string(si.mPath)).c_str()); + + callbackSection(&ermd); + } while (ToolOp(hSnap, &si)); + } + + //RemoveRemoteSectionsTool(hSnap); + } +} + +void EnumerateRemoteModulesServer(HANDLE_API hProc, EnumerateRemoteModulesCallback callbackModule) +{ + HANDLE_API hSnap = CreateRemoteTool(ToolType::MODULES, PidFromHandle(hProc)); + + if (hSnap != HandleValue::INVALID) + { + ModuleInfo mi{}; + + if (ToolOp(hSnap, &mi)) + { + do { + EnumerateRemoteModuleData ermd{}; + + ermd.BaseAddress = (RC_Pointer)mi.mBase; + ermd.Size = (RC_Size)mi.mSize; + lstrcpyW((wchar_t*)ermd.Path, StrtoWStr(std::string(mi.mPath)).c_str()); + + callbackModule(&ermd); + } while (ToolOp(hSnap, &mi)); + } + + //RemoveRemoteModulesTool(hSnap); + } +} + +void EnumerateProcessesServer(EnumerateProcessCallback callbackProcess) +{ + HANDLE_API hSnap = CreateRemoteTool(ToolType::PROCS, 0); + + if (hSnap != HandleValue::INVALID) + { + ProcessInfo pi{}; + if (ToolOp(hSnap, &pi)) + { + do { + if (strlen(pi.mProcessName) > 0) + { + EnumerateProcessData enumProcData{}; + + enumProcData.Id = pi.mProcessId; + lstrcpyW((wchar_t*)enumProcData.Name, StrtoWStr(pi.mProcessName).c_str()); + + callbackProcess(&enumProcData); + } + } while (ToolOp(hSnap, &pi)); + } + + RemoveRemoteProcsTool(hSnap); + } +} + +void EnumerateRemoteSectionsAndModulesServer(RC_Pointer process, EnumerateRemoteSectionsCallback callbackSection, EnumerateRemoteModulesCallback callbackModule) +{ + EnumerateRemoteSectionsServer((HANDLE_API)process, callbackSection); + EnumerateRemoteModulesServer((HANDLE_API)process, callbackModule); +} + +void CloseServerProcess(RC_Pointer hProc) +{ + +} + + + diff --git a/NativeCore/Windows/ServerRemoteTool.h b/NativeCore/Windows/ServerRemoteTool.h new file mode 100644 index 00000000..e964a26c --- /dev/null +++ b/NativeCore/Windows/ServerRemoteTool.h @@ -0,0 +1,51 @@ +#pragma once + +#include +#include "../Shared/API.h" +#include +#include "NativeCore.hpp" +#include + +class ClientSocketWindows; + +class ServerManager { +private: + ClientSocketWindows* mSocket; + static ServerManager* mInstance; +public: + ServerManager(); + + ~ServerManager(); + + bool Disconnect(); + + bool IsConnected(); + + bool CheckConnection(); + + bool CleanUp(); + + bool TryConnect(const std::string& ip, short port); + + bool isValid(); + + bool PartiallyConnected(); + + ClientSocketWindows* getServerSocket(); + + static ServerManager* getInstance(); +}; + +extern std::mutex gMtxReq; + +HANDLE_API CreateRemoteTool(uint32_t type, uint32_t pid); +void RemoveRemoteProcsTool(HANDLE_API hTool); + +RC_Pointer OpenRemoteProcessServer(RC_Pointer id); +void CloseServerProcess(RC_Pointer hProc); + +int ReadMemoryServer(RC_Pointer handle, RC_Pointer address, RC_Pointer buffer, int size); +int WriteMemoryServer(RC_Pointer handle, RC_Pointer address, RC_Pointer buffer, int size); + +void EnumerateRemoteSectionsAndModulesServer(RC_Pointer process, EnumerateRemoteSectionsCallback callbackSection, EnumerateRemoteModulesCallback callbackModule); +void EnumerateProcessesServer(EnumerateProcessCallback callbackProcess); diff --git a/NativeCore/Windows/Utils.cpp b/NativeCore/Windows/Utils.cpp new file mode 100644 index 00000000..dd8288a9 --- /dev/null +++ b/NativeCore/Windows/Utils.cpp @@ -0,0 +1,17 @@ +#include "Utils.h" + +void StrtoWStr(const std::string& in, std::wstring& outWStr) +{ + std::wstring_convert> converter; + + outWStr = converter.from_bytes(in); +} + +std::wstring StrtoWStr(const std::string& in) +{ + std::wstring result = L""; + + StrtoWStr(in, result); + + return result; +} diff --git a/NativeCore/Windows/Utils.h b/NativeCore/Windows/Utils.h new file mode 100644 index 00000000..4579fafe --- /dev/null +++ b/NativeCore/Windows/Utils.h @@ -0,0 +1,8 @@ +#pragma once + +#include +#include + +void StrtoWStr(const std::string& in, std::wstring& outWStr); + +std::wstring StrtoWStr(const std::string& in); diff --git a/NativeCore/Windows/WindowsSocketWrapper.cpp b/NativeCore/Windows/WindowsSocketWrapper.cpp new file mode 100644 index 00000000..002249f1 --- /dev/null +++ b/NativeCore/Windows/WindowsSocketWrapper.cpp @@ -0,0 +1,99 @@ +#include "WindowsSocketWrapper.h" + +bool gWSAInited = false; + +WindowsSocketWrapper::WindowsSocketWrapper(std::string ip, short port) + : SocketWrapper(ip, port) + , sket(INVALID_SOCKET) + , sai{} +{} + +WindowsSocketWrapper::~WindowsSocketWrapper() +{ + // Freeing the Socket + if (sket != INVALID_SOCKET) + closesocket(sket); + + // Checking for WSA Initted + if (gWSAInited) + { + WSACleanup(); + gWSAInited = false; + } +} + +bool WindowsSocketWrapper::Init() +{ + // Checking for WSA Not Initted + if (!gWSAInited) + { + WSAData wd; + + if (WSAStartup(MAKEWORD(2, 2), &wd) != 0) + return false; + + if (wd.wVersion != MAKEWORD(2, 2)) + { + WSACleanup(); + return false;; + } + + gWSAInited = true; + } + + // Creating The Socket + auto family = AF_INET; + + if ((sket = socket(family, SOCK_STREAM, 0)) == INVALID_SOCKET) + { + WSACleanup(); + return false; + } + + //Binding the Socket + sai.sin_family = family; + sai.sin_addr.S_un.S_addr = inet_addr(ip.c_str()); + sai.sin_port = htons(port); + + bind(sket, (const sockaddr*)&sai, sizeof(sai)); + + return true; +} + +bool WindowsSocketWrapper::Send(void* buff, uintptr_t size) +{ + uintptr_t sendedBytes = send(sket, (char*)buff, int(size), 0); + + return ASSERT_SOCK_RESULT(sendedBytes); +} + +bool WindowsSocketWrapper::Recive(void* buff, uintptr_t size, uintptr_t* outRecvSize) +{ + uintptr_t recvdSize = recv(sket, (char*)buff, int(size), 0); + + if (outRecvSize) + *outRecvSize = recvdSize; + + return ASSERT_SOCK_RESULT(recvdSize); +} + +ClientSocketWindows::ClientSocketWindows(const std::string& _ip, short _port) + : WindowsSocketWrapper(_ip, _port) +{} + +bool ClientSocketWindows::Init() +{ + if (WindowsSocketWrapper::Init()) + { + if (connect(sket, (const sockaddr*)&sai, sizeof(sai)) == SOCKET_ERROR) + { + closesocket(sket); + WSACleanup(); + return false; + } + + return true; + } + + return false; +} diff --git a/NativeCore/Windows/WindowsSocketWrapper.h b/NativeCore/Windows/WindowsSocketWrapper.h new file mode 100644 index 00000000..440195ac --- /dev/null +++ b/NativeCore/Windows/WindowsSocketWrapper.h @@ -0,0 +1,25 @@ +#pragma once +#include "../Shared/SocketWrapper.h" +#include + +#pragma comment(lib, "Ws2_32.lib") + +class WindowsSocketWrapper : public SocketWrapper { +protected: + SOCKET sket; + struct sockaddr_in sai; + virtual bool Init() override; +public: + WindowsSocketWrapper(std::string ip, short port); + ~WindowsSocketWrapper(); + + + bool Send(void* buff, uintptr_t size) override; + bool Recive(void* buff, uintptr_t size, uintptr_t* outRecvSize = nullptr) override; +}; + +class ClientSocketWindows : public WindowsSocketWrapper { +public: + ClientSocketWindows(const std::string& _ip, short _port); + bool Init() override; +}; \ No newline at end of file diff --git a/NativeCore/Windows/WriteRemoteMemory.cpp b/NativeCore/Windows/WriteRemoteMemory.cpp index e0dac2df..a1f8c560 100644 --- a/NativeCore/Windows/WriteRemoteMemory.cpp +++ b/NativeCore/Windows/WriteRemoteMemory.cpp @@ -1,25 +1,32 @@ #include #include "NativeCore.hpp" +#include "ServerRemoteTool.h" -bool RC_CallConv WriteRemoteMemory(RC_Pointer handle, RC_Pointer address, RC_Pointer buffer, int offset, int size) +int WriteMemoryWindows(RC_Pointer handle, RC_Pointer address, RC_Pointer buffer, int size) { - buffer = reinterpret_cast(reinterpret_cast(buffer) + offset); + SIZE_T numberOfBytesWrited = -1; DWORD oldProtect; if (VirtualProtectEx(handle, address, size, PAGE_EXECUTE_READWRITE, &oldProtect)) { - SIZE_T numberOfBytesWritten; - if (WriteProcessMemory(handle, address, buffer, size, &numberOfBytesWritten)) + if (WriteProcessMemory(handle, address, buffer, size, &numberOfBytesWrited)) { - VirtualProtectEx(handle, address, size, oldProtect, nullptr); - - if (size == numberOfBytesWritten) - { - return true; - } + VirtualProtectEx(handle, address, size, oldProtect, 0); } } - return false; + return numberOfBytesWrited; +} + + +bool RC_CallConv WriteRemoteMemory(RC_Pointer handle, RC_Pointer address, RC_Pointer buffer, int offset, int size) +{ + int numberOfBytesWrited; + buffer = reinterpret_cast(reinterpret_cast(buffer) + offset); + + if (ServerManager::getInstance()->PartiallyConnected()) numberOfBytesWrited = WriteMemoryServer(handle, address, buffer, size); + else numberOfBytesWrited = WriteMemoryWindows(handle, address, buffer, size); + + return size == numberOfBytesWrited; } diff --git a/NativeCore/Windows/exports.def b/NativeCore/Windows/exports.def index 0d5093cb..9842b443 100644 --- a/NativeCore/Windows/exports.def +++ b/NativeCore/Windows/exports.def @@ -17,3 +17,4 @@ EXPORTS InitializeInput GetPressedKeys ReleaseInput + ConnectServer diff --git a/ReClass.NET/Core/CoreFunctionsManager.cs b/ReClass.NET/Core/CoreFunctionsManager.cs index 92af4d6e..166faa8a 100644 --- a/ReClass.NET/Core/CoreFunctionsManager.cs +++ b/ReClass.NET/Core/CoreFunctionsManager.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections.Generic; using System.Diagnostics.Contracts; using System.IO; @@ -65,6 +65,11 @@ public void SetActiveFunctionsProvider(string provider) #region Plugin Functions + public int ConnectServer(string ip, short port) + { + return currentFunctions.ConnectServer(ip, port); + } + public void EnumerateProcesses(Action callbackProcess) { var c = callbackProcess == null ? null : (EnumerateProcessCallback)delegate (ref EnumerateProcessData data) diff --git a/ReClass.NET/Core/ICoreProcessFunctions.cs b/ReClass.NET/Core/ICoreProcessFunctions.cs index 1c96f4df..49e9f0e3 100644 --- a/ReClass.NET/Core/ICoreProcessFunctions.cs +++ b/ReClass.NET/Core/ICoreProcessFunctions.cs @@ -1,4 +1,4 @@ -using System; +using System; using ReClassNET.Debugger; namespace ReClassNET.Core @@ -9,6 +9,8 @@ namespace ReClassNET.Core public interface ICoreProcessFunctions { + int ConnectServer(string ip, short port); + void EnumerateProcesses(EnumerateProcessCallback callbackProcess); void EnumerateRemoteSectionsAndModules(IntPtr process, EnumerateRemoteSectionCallback callbackSection, EnumerateRemoteModuleCallback callbackModule); diff --git a/ReClass.NET/Core/NativeCoreWrapper.cs b/ReClass.NET/Core/NativeCoreWrapper.cs index bdca5954..6d829ab1 100644 --- a/ReClass.NET/Core/NativeCoreWrapper.cs +++ b/ReClass.NET/Core/NativeCoreWrapper.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Runtime.InteropServices; using ReClassNET.Debugger; using ReClassNET.Extensions; @@ -10,6 +10,8 @@ public class NativeCoreWrapper : ICoreProcessFunctions { #region Native Delegates + private delegate int ConnectServerDelegate(string ip, short port); + private delegate void EnumerateProcessesDelegate([MarshalAs(UnmanagedType.FunctionPtr)] EnumerateProcessCallback callbackProcess); private delegate void EnumerateRemoteSectionsAndModulesDelegate(IntPtr process, [MarshalAs(UnmanagedType.FunctionPtr)] EnumerateRemoteSectionCallback callbackSection, [MarshalAs(UnmanagedType.FunctionPtr)] EnumerateRemoteModuleCallback callbackModule); @@ -42,6 +44,7 @@ public class NativeCoreWrapper : ICoreProcessFunctions [return: MarshalAs(UnmanagedType.I1)] private delegate bool SetHardwareBreakpointDelegate(IntPtr id, IntPtr address, HardwareBreakpointRegister register, HardwareBreakpointTrigger trigger, HardwareBreakpointSize size, [param: MarshalAs(UnmanagedType.I1)] bool set); + private readonly ConnectServerDelegate connectServerDelegate; private readonly EnumerateProcessesDelegate enumerateProcessesDelegate; private readonly EnumerateRemoteSectionsAndModulesDelegate enumerateRemoteSectionsAndModulesDelegate; private readonly OpenRemoteProcessDelegate openRemoteProcessDelegate; @@ -78,6 +81,7 @@ public NativeCoreWrapper(IntPtr handle) awaitDebugEventDelegate = GetFunctionDelegate(handle, "AwaitDebugEvent"); handleDebugEventDelegate = GetFunctionDelegate(handle, "HandleDebugEvent"); setHardwareBreakpointDelegate = GetFunctionDelegate(handle, "SetHardwareBreakpoint"); + connectServerDelegate = GetFunctionDelegate(handle, "ConnectServer"); } protected static TDelegate GetFunctionDelegate(IntPtr handle, string function) @@ -90,6 +94,11 @@ protected static TDelegate GetFunctionDelegate(IntPtr handle, string return Marshal.GetDelegateForFunctionPointer(address); } + public int ConnectServer(string ip, short port) + { + return connectServerDelegate(ip, port); + } + public void EnumerateProcesses(EnumerateProcessCallback callbackProcess) { enumerateProcessesDelegate(callbackProcess); diff --git a/ReClass.NET/Forms/MainForm.Designer.cs b/ReClass.NET/Forms/MainForm.Designer.cs index e2b2a199..be1d3b16 100644 --- a/ReClass.NET/Forms/MainForm.Designer.cs +++ b/ReClass.NET/Forms/MainForm.Designer.cs @@ -30,243 +30,243 @@ protected override void Dispose(bool disposing) /// private void InitializeComponent() { - this.components = new System.ComponentModel.Container(); - System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(MainForm)); - this.processUpdateTimer = new System.Windows.Forms.Timer(this.components); - this.splitContainer = new System.Windows.Forms.SplitContainer(); - this.projectView = new ReClassNET.Controls.ProjectView(); - this.projectClassContextMenuStrip = new System.Windows.Forms.ContextMenuStrip(this.components); - this.deleteClassToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator19 = new System.Windows.Forms.ToolStripSeparator(); - this.removeUnusedClassesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator20 = new System.Windows.Forms.ToolStripSeparator(); - this.showCodeOfClassToolStripMenuItem2 = new System.Windows.Forms.ToolStripMenuItem(); - this.projectClassesContextMenuStrip = new System.Windows.Forms.ContextMenuStrip(this.components); - this.enableHierarchyViewToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.autoExpandHierarchyViewToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator21 = new System.Windows.Forms.ToolStripSeparator(); - this.expandAllClassesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.collapseAllClassesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator22 = new System.Windows.Forms.ToolStripSeparator(); - this.addNewClassToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.projectEnumContextMenuStrip = new System.Windows.Forms.ContextMenuStrip(this.components); - this.editEnumToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.projectEnumsContextMenuStrip = new System.Windows.Forms.ContextMenuStrip(this.components); - this.editEnumsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.memoryViewControl = new ReClassNET.Controls.MemoryViewControl(); - this.selectedNodeContextMenuStrip = new System.Windows.Forms.ContextMenuStrip(this.components); - this.changeTypeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.addBytesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.integerToolStripMenuItem1 = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.integerToolStripMenuItem2 = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.integerToolStripMenuItem3 = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.integerToolStripMenuItem4 = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.integerToolStripMenuItem5 = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.integerToolStripMenuItem6 = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.integerToolStripMenuItem7 = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.toolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem(); - this.insertBytesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.integerToolStripMenuItem8 = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.integerToolStripMenuItem9 = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.integerToolStripMenuItem10 = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.integerToolStripMenuItem11 = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.integerToolStripMenuItem12 = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.integerToolStripMenuItem13 = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.integerToolStripMenuItem14 = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.toolStripMenuItem2 = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator8 = new System.Windows.Forms.ToolStripSeparator(); - this.createClassFromNodesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator13 = new System.Windows.Forms.ToolStripSeparator(); - this.dissectNodesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator9 = new System.Windows.Forms.ToolStripSeparator(); - this.searchForEqualValuesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator15 = new System.Windows.Forms.ToolStripSeparator(); - this.findOutWhatAccessesThisAddressToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.findOutWhatWritesToThisAddressToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator14 = new System.Windows.Forms.ToolStripSeparator(); - this.copyNodeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.pasteNodesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator10 = new System.Windows.Forms.ToolStripSeparator(); - this.removeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator12 = new System.Windows.Forms.ToolStripSeparator(); - this.hideNodesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.unhideNodesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.unhideChildNodesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.unhideNodesAboveToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.unhideNodesBelowToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator18 = new System.Windows.Forms.ToolStripSeparator(); - this.copyAddressToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator11 = new System.Windows.Forms.ToolStripSeparator(); - this.showCodeOfClassToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.shrinkClassToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStrip = new System.Windows.Forms.ToolStrip(); - this.attachToProcessToolStripSplitButton = new System.Windows.Forms.ToolStripSplitButton(); - this.toolStripSeparator6 = new System.Windows.Forms.ToolStripSeparator(); - this.openProjectToolStripButton = new System.Windows.Forms.ToolStripButton(); - this.saveToolStripButton = new System.Windows.Forms.ToolStripButton(); - this.toolStripSeparator7 = new System.Windows.Forms.ToolStripSeparator(); - this.newClassToolStripButton = new System.Windows.Forms.ToolStripButton(); - this.addBytesToolStripDropDownButton = new System.Windows.Forms.ToolStripDropDownButton(); - this.add4BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.add8BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.add64BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.add256BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.add1024BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.add2048BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.add4096BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.addXBytesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.insertBytesToolStripDropDownButton = new System.Windows.Forms.ToolStripDropDownButton(); - this.insert4BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.insert8BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.insert64BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.insert256BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.insert1024BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.insert2048BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.insert4096BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); - this.insertXBytesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.nodeTypesToolStripSeparator = new System.Windows.Forms.ToolStripSeparator(); - this.statusStrip = new System.Windows.Forms.StatusStrip(); - this.processInfoToolStripStatusLabel = new System.Windows.Forms.ToolStripStatusLabel(); - this.infoToolStripStatusLabel = new System.Windows.Forms.ToolStripStatusLabel(); - this.mainMenuStrip = new System.Windows.Forms.MenuStrip(); - this.fileToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.attachToProcessToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.reattachToProcessToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.detachToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator1 = new System.Windows.Forms.ToolStripSeparator(); - this.openProjectToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.mergeWithProjectToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.clearProjectToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator2 = new System.Windows.Forms.ToolStripSeparator(); - this.saveToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.saveAsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator3 = new System.Windows.Forms.ToolStripSeparator(); - this.settingsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.pluginsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator5 = new System.Windows.Forms.ToolStripSeparator(); - this.quitToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.processToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.processInformationsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.memorySearcherToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.namedAddressesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator23 = new System.Windows.Forms.ToolStripSeparator(); - this.isLittleEndianToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator17 = new System.Windows.Forms.ToolStripSeparator(); - this.loadSymbolToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.loadSymbolsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator4 = new System.Windows.Forms.ToolStripSeparator(); - this.resumeProcessToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.suspendProcessToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.terminateProcessToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.projectToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.goToClassToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.cleanUnusedClassesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.showEnumsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.toolStripSeparator16 = new System.Windows.Forms.ToolStripSeparator(); - this.generateCppCodeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.generateCSharpCodeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.helpToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.aboutToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - ((System.ComponentModel.ISupportInitialize)(this.splitContainer)).BeginInit(); - this.splitContainer.Panel1.SuspendLayout(); - this.splitContainer.Panel2.SuspendLayout(); - this.splitContainer.SuspendLayout(); - this.projectClassContextMenuStrip.SuspendLayout(); - this.projectClassesContextMenuStrip.SuspendLayout(); - this.projectEnumContextMenuStrip.SuspendLayout(); - this.projectEnumsContextMenuStrip.SuspendLayout(); - this.selectedNodeContextMenuStrip.SuspendLayout(); - this.toolStrip.SuspendLayout(); - this.statusStrip.SuspendLayout(); - this.mainMenuStrip.SuspendLayout(); - this.SuspendLayout(); - // - // processUpdateTimer - // - this.processUpdateTimer.Enabled = true; - this.processUpdateTimer.Interval = 5000; - this.processUpdateTimer.Tick += new System.EventHandler(this.processUpdateTimer_Tick); - // - // splitContainer - // - this.splitContainer.Dock = System.Windows.Forms.DockStyle.Fill; - this.splitContainer.FixedPanel = System.Windows.Forms.FixedPanel.Panel1; - this.splitContainer.Location = new System.Drawing.Point(0, 49); - this.splitContainer.Name = "splitContainer"; - // - // splitContainer.Panel1 - // - this.splitContainer.Panel1.Controls.Add(this.projectView); - // - // splitContainer.Panel2 - // - this.splitContainer.Panel2.BackColor = System.Drawing.SystemColors.Control; - this.splitContainer.Panel2.Controls.Add(this.memoryViewControl); - this.splitContainer.Size = new System.Drawing.Size(1141, 524); - this.splitContainer.SplitterDistance = 201; - this.splitContainer.TabIndex = 4; - // - // projectView - // - this.projectView.ClassContextMenuStrip = this.projectClassContextMenuStrip; - this.projectView.ClassesContextMenuStrip = this.projectClassesContextMenuStrip; - this.projectView.Dock = System.Windows.Forms.DockStyle.Fill; - this.projectView.EnumContextMenuStrip = this.projectEnumContextMenuStrip; - this.projectView.EnumsContextMenuStrip = this.projectEnumsContextMenuStrip; - this.projectView.Location = new System.Drawing.Point(0, 0); - this.projectView.Name = "projectView"; - this.projectView.Size = new System.Drawing.Size(201, 524); - this.projectView.TabIndex = 0; - this.projectView.SelectionChanged += new ReClassNET.Controls.ProjectView.SelectionChangedEvent(this.classesView_ClassSelected); - // - // projectClassContextMenuStrip - // - this.projectClassContextMenuStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(MainForm)); + this.processUpdateTimer = new System.Windows.Forms.Timer(this.components); + this.splitContainer = new System.Windows.Forms.SplitContainer(); + this.projectView = new ReClassNET.Controls.ProjectView(); + this.projectClassContextMenuStrip = new System.Windows.Forms.ContextMenuStrip(this.components); + this.deleteClassToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator19 = new System.Windows.Forms.ToolStripSeparator(); + this.removeUnusedClassesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator20 = new System.Windows.Forms.ToolStripSeparator(); + this.showCodeOfClassToolStripMenuItem2 = new System.Windows.Forms.ToolStripMenuItem(); + this.projectClassesContextMenuStrip = new System.Windows.Forms.ContextMenuStrip(this.components); + this.enableHierarchyViewToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.autoExpandHierarchyViewToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator21 = new System.Windows.Forms.ToolStripSeparator(); + this.expandAllClassesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.collapseAllClassesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator22 = new System.Windows.Forms.ToolStripSeparator(); + this.addNewClassToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.projectEnumContextMenuStrip = new System.Windows.Forms.ContextMenuStrip(this.components); + this.editEnumToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.projectEnumsContextMenuStrip = new System.Windows.Forms.ContextMenuStrip(this.components); + this.editEnumsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.memoryViewControl = new ReClassNET.Controls.MemoryViewControl(); + this.selectedNodeContextMenuStrip = new System.Windows.Forms.ContextMenuStrip(this.components); + this.changeTypeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.addBytesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.integerToolStripMenuItem1 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem2 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem3 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem4 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem5 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem6 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem7 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.toolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem(); + this.insertBytesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.integerToolStripMenuItem8 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem9 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem10 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem11 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem12 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem13 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem14 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.toolStripMenuItem2 = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator8 = new System.Windows.Forms.ToolStripSeparator(); + this.createClassFromNodesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator13 = new System.Windows.Forms.ToolStripSeparator(); + this.dissectNodesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator9 = new System.Windows.Forms.ToolStripSeparator(); + this.searchForEqualValuesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator15 = new System.Windows.Forms.ToolStripSeparator(); + this.findOutWhatAccessesThisAddressToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.findOutWhatWritesToThisAddressToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator14 = new System.Windows.Forms.ToolStripSeparator(); + this.copyNodeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.pasteNodesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator10 = new System.Windows.Forms.ToolStripSeparator(); + this.removeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator12 = new System.Windows.Forms.ToolStripSeparator(); + this.hideNodesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.unhideNodesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.unhideChildNodesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.unhideNodesAboveToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.unhideNodesBelowToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator18 = new System.Windows.Forms.ToolStripSeparator(); + this.copyAddressToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator11 = new System.Windows.Forms.ToolStripSeparator(); + this.showCodeOfClassToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.shrinkClassToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStrip = new System.Windows.Forms.ToolStrip(); + this.attachToProcessToolStripSplitButton = new System.Windows.Forms.ToolStripSplitButton(); + this.toolStripSeparator6 = new System.Windows.Forms.ToolStripSeparator(); + this.openProjectToolStripButton = new System.Windows.Forms.ToolStripButton(); + this.saveToolStripButton = new System.Windows.Forms.ToolStripButton(); + this.toolStripSeparator7 = new System.Windows.Forms.ToolStripSeparator(); + this.newClassToolStripButton = new System.Windows.Forms.ToolStripButton(); + this.addBytesToolStripDropDownButton = new System.Windows.Forms.ToolStripDropDownButton(); + this.add4BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.add8BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.add64BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.add256BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.add1024BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.add2048BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.add4096BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.addXBytesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.insertBytesToolStripDropDownButton = new System.Windows.Forms.ToolStripDropDownButton(); + this.insert4BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.insert8BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.insert64BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.insert256BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.insert1024BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.insert2048BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.insert4096BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.insertXBytesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.nodeTypesToolStripSeparator = new System.Windows.Forms.ToolStripSeparator(); + this.statusStrip = new System.Windows.Forms.StatusStrip(); + this.processInfoToolStripStatusLabel = new System.Windows.Forms.ToolStripStatusLabel(); + this.infoToolStripStatusLabel = new System.Windows.Forms.ToolStripStatusLabel(); + this.mainMenuStrip = new System.Windows.Forms.MenuStrip(); + this.fileToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.attachToProcessToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.reattachToProcessToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.detachToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator1 = new System.Windows.Forms.ToolStripSeparator(); + this.openProjectToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.mergeWithProjectToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.clearProjectToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator2 = new System.Windows.Forms.ToolStripSeparator(); + this.saveToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.saveAsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator3 = new System.Windows.Forms.ToolStripSeparator(); + this.settingsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.pluginsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator5 = new System.Windows.Forms.ToolStripSeparator(); + this.quitToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.processToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.processInformationsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.memorySearcherToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.namedAddressesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator23 = new System.Windows.Forms.ToolStripSeparator(); + this.isLittleEndianToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator17 = new System.Windows.Forms.ToolStripSeparator(); + this.loadSymbolToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.loadSymbolsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator4 = new System.Windows.Forms.ToolStripSeparator(); + this.resumeProcessToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.suspendProcessToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.terminateProcessToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.projectToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.goToClassToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.cleanUnusedClassesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.showEnumsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator16 = new System.Windows.Forms.ToolStripSeparator(); + this.generateCppCodeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.generateCSharpCodeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.helpToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.aboutToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + ((System.ComponentModel.ISupportInitialize)(this.splitContainer)).BeginInit(); + this.splitContainer.Panel1.SuspendLayout(); + this.splitContainer.Panel2.SuspendLayout(); + this.splitContainer.SuspendLayout(); + this.projectClassContextMenuStrip.SuspendLayout(); + this.projectClassesContextMenuStrip.SuspendLayout(); + this.projectEnumContextMenuStrip.SuspendLayout(); + this.projectEnumsContextMenuStrip.SuspendLayout(); + this.selectedNodeContextMenuStrip.SuspendLayout(); + this.toolStrip.SuspendLayout(); + this.statusStrip.SuspendLayout(); + this.mainMenuStrip.SuspendLayout(); + this.SuspendLayout(); + // + // processUpdateTimer + // + this.processUpdateTimer.Enabled = true; + this.processUpdateTimer.Interval = 5000; + this.processUpdateTimer.Tick += new System.EventHandler(this.processUpdateTimer_Tick); + // + // splitContainer + // + this.splitContainer.Dock = System.Windows.Forms.DockStyle.Fill; + this.splitContainer.FixedPanel = System.Windows.Forms.FixedPanel.Panel1; + this.splitContainer.Location = new System.Drawing.Point(0, 49); + this.splitContainer.Name = "splitContainer"; + // + // splitContainer.Panel1 + // + this.splitContainer.Panel1.Controls.Add(this.projectView); + // + // splitContainer.Panel2 + // + this.splitContainer.Panel2.BackColor = System.Drawing.SystemColors.Control; + this.splitContainer.Panel2.Controls.Add(this.memoryViewControl); + this.splitContainer.Size = new System.Drawing.Size(1141, 524); + this.splitContainer.SplitterDistance = 201; + this.splitContainer.TabIndex = 4; + // + // projectView + // + this.projectView.ClassContextMenuStrip = this.projectClassContextMenuStrip; + this.projectView.ClassesContextMenuStrip = this.projectClassesContextMenuStrip; + this.projectView.Dock = System.Windows.Forms.DockStyle.Fill; + this.projectView.EnumContextMenuStrip = this.projectEnumContextMenuStrip; + this.projectView.EnumsContextMenuStrip = this.projectEnumsContextMenuStrip; + this.projectView.Location = new System.Drawing.Point(0, 0); + this.projectView.Name = "projectView"; + this.projectView.Size = new System.Drawing.Size(201, 524); + this.projectView.TabIndex = 0; + this.projectView.SelectionChanged += new ReClassNET.Controls.ProjectView.SelectionChangedEvent(this.classesView_ClassSelected); + // + // projectClassContextMenuStrip + // + this.projectClassContextMenuStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { this.deleteClassToolStripMenuItem, this.toolStripSeparator19, this.removeUnusedClassesToolStripMenuItem, this.toolStripSeparator20, this.showCodeOfClassToolStripMenuItem2}); - this.projectClassContextMenuStrip.Name = "contextMenuStrip"; - this.projectClassContextMenuStrip.Size = new System.Drawing.Size(206, 82); - // - // deleteClassToolStripMenuItem - // - this.deleteClassToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Class_Remove; - this.deleteClassToolStripMenuItem.Name = "deleteClassToolStripMenuItem"; - this.deleteClassToolStripMenuItem.Size = new System.Drawing.Size(205, 22); - this.deleteClassToolStripMenuItem.Text = "Delete class"; - this.deleteClassToolStripMenuItem.Click += new System.EventHandler(this.deleteClassToolStripMenuItem_Click); - // - // toolStripSeparator19 - // - this.toolStripSeparator19.Name = "toolStripSeparator19"; - this.toolStripSeparator19.Size = new System.Drawing.Size(202, 6); - // - // removeUnusedClassesToolStripMenuItem - // - this.removeUnusedClassesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Chart_Delete; - this.removeUnusedClassesToolStripMenuItem.Name = "removeUnusedClassesToolStripMenuItem"; - this.removeUnusedClassesToolStripMenuItem.Size = new System.Drawing.Size(205, 22); - this.removeUnusedClassesToolStripMenuItem.Text = "Remove unused classes"; - this.removeUnusedClassesToolStripMenuItem.Click += new System.EventHandler(this.removeUnusedClassesToolStripMenuItem_Click); - // - // toolStripSeparator20 - // - this.toolStripSeparator20.Name = "toolStripSeparator20"; - this.toolStripSeparator20.Size = new System.Drawing.Size(202, 6); - // - // showCodeOfClassToolStripMenuItem2 - // - this.showCodeOfClassToolStripMenuItem2.Image = global::ReClassNET.Properties.Resources.B16x16_Page_Code_Cpp; - this.showCodeOfClassToolStripMenuItem2.Name = "showCodeOfClassToolStripMenuItem2"; - this.showCodeOfClassToolStripMenuItem2.Size = new System.Drawing.Size(205, 22); - this.showCodeOfClassToolStripMenuItem2.Text = "Show C++ Code of Class"; - this.showCodeOfClassToolStripMenuItem2.Click += new System.EventHandler(this.showCodeOfClassToolStripMenuItem2_Click); - // - // projectClassesContextMenuStrip - // - this.projectClassesContextMenuStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.projectClassContextMenuStrip.Name = "contextMenuStrip"; + this.projectClassContextMenuStrip.Size = new System.Drawing.Size(206, 82); + // + // deleteClassToolStripMenuItem + // + this.deleteClassToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Class_Remove; + this.deleteClassToolStripMenuItem.Name = "deleteClassToolStripMenuItem"; + this.deleteClassToolStripMenuItem.Size = new System.Drawing.Size(205, 22); + this.deleteClassToolStripMenuItem.Text = "Delete class"; + this.deleteClassToolStripMenuItem.Click += new System.EventHandler(this.deleteClassToolStripMenuItem_Click); + // + // toolStripSeparator19 + // + this.toolStripSeparator19.Name = "toolStripSeparator19"; + this.toolStripSeparator19.Size = new System.Drawing.Size(202, 6); + // + // removeUnusedClassesToolStripMenuItem + // + this.removeUnusedClassesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Chart_Delete; + this.removeUnusedClassesToolStripMenuItem.Name = "removeUnusedClassesToolStripMenuItem"; + this.removeUnusedClassesToolStripMenuItem.Size = new System.Drawing.Size(205, 22); + this.removeUnusedClassesToolStripMenuItem.Text = "Remove unused classes"; + this.removeUnusedClassesToolStripMenuItem.Click += new System.EventHandler(this.removeUnusedClassesToolStripMenuItem_Click); + // + // toolStripSeparator20 + // + this.toolStripSeparator20.Name = "toolStripSeparator20"; + this.toolStripSeparator20.Size = new System.Drawing.Size(202, 6); + // + // showCodeOfClassToolStripMenuItem2 + // + this.showCodeOfClassToolStripMenuItem2.Image = global::ReClassNET.Properties.Resources.B16x16_Page_Code_Cpp; + this.showCodeOfClassToolStripMenuItem2.Name = "showCodeOfClassToolStripMenuItem2"; + this.showCodeOfClassToolStripMenuItem2.Size = new System.Drawing.Size(205, 22); + this.showCodeOfClassToolStripMenuItem2.Text = "Show C++ Code of Class"; + this.showCodeOfClassToolStripMenuItem2.Click += new System.EventHandler(this.showCodeOfClassToolStripMenuItem2_Click); + // + // projectClassesContextMenuStrip + // + this.projectClassesContextMenuStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { this.enableHierarchyViewToolStripMenuItem, this.autoExpandHierarchyViewToolStripMenuItem, this.toolStripSeparator21, @@ -274,108 +274,108 @@ private void InitializeComponent() this.collapseAllClassesToolStripMenuItem, this.toolStripSeparator22, this.addNewClassToolStripMenuItem}); - this.projectClassesContextMenuStrip.Name = "rootContextMenuStrip"; - this.projectClassesContextMenuStrip.Size = new System.Drawing.Size(222, 126); - // - // enableHierarchyViewToolStripMenuItem - // - this.enableHierarchyViewToolStripMenuItem.Name = "enableHierarchyViewToolStripMenuItem"; - this.enableHierarchyViewToolStripMenuItem.Size = new System.Drawing.Size(221, 22); - this.enableHierarchyViewToolStripMenuItem.Text = "Enable hierarchy view"; - this.enableHierarchyViewToolStripMenuItem.Click += new System.EventHandler(this.enableHierarchyViewToolStripMenuItem_Click); - // - // autoExpandHierarchyViewToolStripMenuItem - // - this.autoExpandHierarchyViewToolStripMenuItem.Name = "autoExpandHierarchyViewToolStripMenuItem"; - this.autoExpandHierarchyViewToolStripMenuItem.Size = new System.Drawing.Size(221, 22); - this.autoExpandHierarchyViewToolStripMenuItem.Text = "Auto expand hierarchy view"; - this.autoExpandHierarchyViewToolStripMenuItem.Click += new System.EventHandler(this.autoExpandHierarchyViewToolStripMenuItem_Click); - // - // toolStripSeparator21 - // - this.toolStripSeparator21.Name = "toolStripSeparator21"; - this.toolStripSeparator21.Size = new System.Drawing.Size(218, 6); - // - // expandAllClassesToolStripMenuItem - // - this.expandAllClassesToolStripMenuItem.Enabled = false; - this.expandAllClassesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Tree_Expand; - this.expandAllClassesToolStripMenuItem.Name = "expandAllClassesToolStripMenuItem"; - this.expandAllClassesToolStripMenuItem.Size = new System.Drawing.Size(221, 22); - this.expandAllClassesToolStripMenuItem.Text = "Expand all classes"; - this.expandAllClassesToolStripMenuItem.Click += new System.EventHandler(this.expandAllClassesToolStripMenuItem_Click); - // - // collapseAllClassesToolStripMenuItem - // - this.collapseAllClassesToolStripMenuItem.Enabled = false; - this.collapseAllClassesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Tree_Collapse; - this.collapseAllClassesToolStripMenuItem.Name = "collapseAllClassesToolStripMenuItem"; - this.collapseAllClassesToolStripMenuItem.Size = new System.Drawing.Size(221, 22); - this.collapseAllClassesToolStripMenuItem.Text = "Collapse all classes"; - this.collapseAllClassesToolStripMenuItem.Click += new System.EventHandler(this.collapseAllClassesToolStripMenuItem_Click); - // - // toolStripSeparator22 - // - this.toolStripSeparator22.Name = "toolStripSeparator22"; - this.toolStripSeparator22.Size = new System.Drawing.Size(218, 6); - // - // addNewClassToolStripMenuItem - // - this.addNewClassToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Class_Add; - this.addNewClassToolStripMenuItem.Name = "addNewClassToolStripMenuItem"; - this.addNewClassToolStripMenuItem.Size = new System.Drawing.Size(221, 22); - this.addNewClassToolStripMenuItem.Text = "Add new class"; - this.addNewClassToolStripMenuItem.Click += new System.EventHandler(this.newClassToolStripButton_Click); - // - // projectEnumContextMenuStrip - // - this.projectEnumContextMenuStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.projectClassesContextMenuStrip.Name = "rootContextMenuStrip"; + this.projectClassesContextMenuStrip.Size = new System.Drawing.Size(222, 126); + // + // enableHierarchyViewToolStripMenuItem + // + this.enableHierarchyViewToolStripMenuItem.Name = "enableHierarchyViewToolStripMenuItem"; + this.enableHierarchyViewToolStripMenuItem.Size = new System.Drawing.Size(221, 22); + this.enableHierarchyViewToolStripMenuItem.Text = "Enable hierarchy view"; + this.enableHierarchyViewToolStripMenuItem.Click += new System.EventHandler(this.enableHierarchyViewToolStripMenuItem_Click); + // + // autoExpandHierarchyViewToolStripMenuItem + // + this.autoExpandHierarchyViewToolStripMenuItem.Name = "autoExpandHierarchyViewToolStripMenuItem"; + this.autoExpandHierarchyViewToolStripMenuItem.Size = new System.Drawing.Size(221, 22); + this.autoExpandHierarchyViewToolStripMenuItem.Text = "Auto expand hierarchy view"; + this.autoExpandHierarchyViewToolStripMenuItem.Click += new System.EventHandler(this.autoExpandHierarchyViewToolStripMenuItem_Click); + // + // toolStripSeparator21 + // + this.toolStripSeparator21.Name = "toolStripSeparator21"; + this.toolStripSeparator21.Size = new System.Drawing.Size(218, 6); + // + // expandAllClassesToolStripMenuItem + // + this.expandAllClassesToolStripMenuItem.Enabled = false; + this.expandAllClassesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Tree_Expand; + this.expandAllClassesToolStripMenuItem.Name = "expandAllClassesToolStripMenuItem"; + this.expandAllClassesToolStripMenuItem.Size = new System.Drawing.Size(221, 22); + this.expandAllClassesToolStripMenuItem.Text = "Expand all classes"; + this.expandAllClassesToolStripMenuItem.Click += new System.EventHandler(this.expandAllClassesToolStripMenuItem_Click); + // + // collapseAllClassesToolStripMenuItem + // + this.collapseAllClassesToolStripMenuItem.Enabled = false; + this.collapseAllClassesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Tree_Collapse; + this.collapseAllClassesToolStripMenuItem.Name = "collapseAllClassesToolStripMenuItem"; + this.collapseAllClassesToolStripMenuItem.Size = new System.Drawing.Size(221, 22); + this.collapseAllClassesToolStripMenuItem.Text = "Collapse all classes"; + this.collapseAllClassesToolStripMenuItem.Click += new System.EventHandler(this.collapseAllClassesToolStripMenuItem_Click); + // + // toolStripSeparator22 + // + this.toolStripSeparator22.Name = "toolStripSeparator22"; + this.toolStripSeparator22.Size = new System.Drawing.Size(218, 6); + // + // addNewClassToolStripMenuItem + // + this.addNewClassToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Class_Add; + this.addNewClassToolStripMenuItem.Name = "addNewClassToolStripMenuItem"; + this.addNewClassToolStripMenuItem.Size = new System.Drawing.Size(221, 22); + this.addNewClassToolStripMenuItem.Text = "Add new class"; + this.addNewClassToolStripMenuItem.Click += new System.EventHandler(this.newClassToolStripButton_Click); + // + // projectEnumContextMenuStrip + // + this.projectEnumContextMenuStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { this.editEnumToolStripMenuItem}); - this.projectEnumContextMenuStrip.Name = "projectEnumContextMenuStrip"; - this.projectEnumContextMenuStrip.Size = new System.Drawing.Size(138, 26); - // - // editEnumToolStripMenuItem - // - this.editEnumToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Enum_Type; - this.editEnumToolStripMenuItem.Name = "editEnumToolStripMenuItem"; - this.editEnumToolStripMenuItem.Size = new System.Drawing.Size(137, 22); - this.editEnumToolStripMenuItem.Text = "Edit Enum..."; - this.editEnumToolStripMenuItem.Click += new System.EventHandler(this.editEnumToolStripMenuItem_Click); - // - // projectEnumsContextMenuStrip - // - this.projectEnumsContextMenuStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.projectEnumContextMenuStrip.Name = "projectEnumContextMenuStrip"; + this.projectEnumContextMenuStrip.Size = new System.Drawing.Size(138, 26); + // + // editEnumToolStripMenuItem + // + this.editEnumToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Enum_Type; + this.editEnumToolStripMenuItem.Name = "editEnumToolStripMenuItem"; + this.editEnumToolStripMenuItem.Size = new System.Drawing.Size(137, 22); + this.editEnumToolStripMenuItem.Text = "Edit Enum..."; + this.editEnumToolStripMenuItem.Click += new System.EventHandler(this.editEnumToolStripMenuItem_Click); + // + // projectEnumsContextMenuStrip + // + this.projectEnumsContextMenuStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { this.editEnumsToolStripMenuItem}); - this.projectEnumsContextMenuStrip.Name = "projectEnumsContextMenuStrip"; - this.projectEnumsContextMenuStrip.Size = new System.Drawing.Size(143, 26); - // - // editEnumsToolStripMenuItem - // - this.editEnumsToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Category; - this.editEnumsToolStripMenuItem.Name = "editEnumsToolStripMenuItem"; - this.editEnumsToolStripMenuItem.Size = new System.Drawing.Size(142, 22); - this.editEnumsToolStripMenuItem.Text = "Edit enums..."; - this.editEnumsToolStripMenuItem.Click += new System.EventHandler(this.editEnumsToolStripMenuItem_Click); - // - // memoryViewControl - // - this.memoryViewControl.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; - this.memoryViewControl.Dock = System.Windows.Forms.DockStyle.Fill; - this.memoryViewControl.Location = new System.Drawing.Point(0, 0); - this.memoryViewControl.Name = "memoryViewControl"; - this.memoryViewControl.NodeContextMenuStrip = this.selectedNodeContextMenuStrip; - this.memoryViewControl.Size = new System.Drawing.Size(936, 524); - this.memoryViewControl.TabIndex = 0; - this.memoryViewControl.DrawContextRequested += new ReClassNET.Controls.DrawContextRequestEventHandler(this.memoryViewControl_DrawContextRequested); - this.memoryViewControl.SelectionChanged += new System.EventHandler(this.memoryViewControl_SelectionChanged); - this.memoryViewControl.ChangeClassTypeClick += new ReClassNET.Controls.NodeClickEventHandler(this.memoryViewControl_ChangeClassTypeClick); - this.memoryViewControl.ChangeWrappedTypeClick += new ReClassNET.Controls.NodeClickEventHandler(this.memoryViewControl_ChangeWrappedTypeClick); - this.memoryViewControl.ChangeEnumTypeClick += new ReClassNET.Controls.NodeClickEventHandler(this.memoryViewControl_ChangeEnumTypeClick); - this.memoryViewControl.KeyDown += new System.Windows.Forms.KeyEventHandler(this.memoryViewControl_KeyDown); - // - // selectedNodeContextMenuStrip - // - this.selectedNodeContextMenuStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.projectEnumsContextMenuStrip.Name = "projectEnumsContextMenuStrip"; + this.projectEnumsContextMenuStrip.Size = new System.Drawing.Size(143, 26); + // + // editEnumsToolStripMenuItem + // + this.editEnumsToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Category; + this.editEnumsToolStripMenuItem.Name = "editEnumsToolStripMenuItem"; + this.editEnumsToolStripMenuItem.Size = new System.Drawing.Size(142, 22); + this.editEnumsToolStripMenuItem.Text = "Edit enums..."; + this.editEnumsToolStripMenuItem.Click += new System.EventHandler(this.editEnumsToolStripMenuItem_Click); + // + // memoryViewControl + // + this.memoryViewControl.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; + this.memoryViewControl.Dock = System.Windows.Forms.DockStyle.Fill; + this.memoryViewControl.Location = new System.Drawing.Point(0, 0); + this.memoryViewControl.Name = "memoryViewControl"; + this.memoryViewControl.NodeContextMenuStrip = this.selectedNodeContextMenuStrip; + this.memoryViewControl.Size = new System.Drawing.Size(936, 524); + this.memoryViewControl.TabIndex = 0; + this.memoryViewControl.DrawContextRequested += new ReClassNET.Controls.DrawContextRequestEventHandler(this.memoryViewControl_DrawContextRequested); + this.memoryViewControl.SelectionChanged += new System.EventHandler(this.memoryViewControl_SelectionChanged); + this.memoryViewControl.ChangeClassTypeClick += new ReClassNET.Controls.NodeClickEventHandler(this.memoryViewControl_ChangeClassTypeClick); + this.memoryViewControl.ChangeWrappedTypeClick += new ReClassNET.Controls.NodeClickEventHandler(this.memoryViewControl_ChangeWrappedTypeClick); + this.memoryViewControl.ChangeEnumTypeClick += new ReClassNET.Controls.NodeClickEventHandler(this.memoryViewControl_ChangeEnumTypeClick); + this.memoryViewControl.KeyDown += new System.Windows.Forms.KeyEventHandler(this.memoryViewControl_KeyDown); + // + // selectedNodeContextMenuStrip + // + this.selectedNodeContextMenuStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { this.changeTypeToolStripMenuItem, this.addBytesToolStripMenuItem, this.insertBytesToolStripMenuItem, @@ -401,20 +401,20 @@ private void InitializeComponent() this.toolStripSeparator11, this.showCodeOfClassToolStripMenuItem, this.shrinkClassToolStripMenuItem}); - this.selectedNodeContextMenuStrip.Name = "selectedNodeContextMenuStrip"; - this.selectedNodeContextMenuStrip.Size = new System.Drawing.Size(270, 410); - this.selectedNodeContextMenuStrip.Opening += new System.ComponentModel.CancelEventHandler(this.selectedNodeContextMenuStrip_Opening); - // - // changeTypeToolStripMenuItem - // - this.changeTypeToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Exchange_Button; - this.changeTypeToolStripMenuItem.Name = "changeTypeToolStripMenuItem"; - this.changeTypeToolStripMenuItem.Size = new System.Drawing.Size(269, 22); - this.changeTypeToolStripMenuItem.Text = "Change Type"; - // - // addBytesToolStripMenuItem - // - this.addBytesToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.selectedNodeContextMenuStrip.Name = "selectedNodeContextMenuStrip"; + this.selectedNodeContextMenuStrip.Size = new System.Drawing.Size(270, 410); + this.selectedNodeContextMenuStrip.Opening += new System.ComponentModel.CancelEventHandler(this.selectedNodeContextMenuStrip_Opening); + // + // changeTypeToolStripMenuItem + // + this.changeTypeToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Exchange_Button; + this.changeTypeToolStripMenuItem.Name = "changeTypeToolStripMenuItem"; + this.changeTypeToolStripMenuItem.Size = new System.Drawing.Size(269, 22); + this.changeTypeToolStripMenuItem.Text = "Change Type"; + // + // addBytesToolStripMenuItem + // + this.addBytesToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { this.integerToolStripMenuItem1, this.integerToolStripMenuItem2, this.integerToolStripMenuItem3, @@ -423,85 +423,85 @@ private void InitializeComponent() this.integerToolStripMenuItem6, this.integerToolStripMenuItem7, this.toolStripMenuItem1}); - this.addBytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_X; - this.addBytesToolStripMenuItem.Name = "addBytesToolStripMenuItem"; - this.addBytesToolStripMenuItem.Size = new System.Drawing.Size(269, 22); - this.addBytesToolStripMenuItem.Text = "Add Bytes"; - // - // integerToolStripMenuItem1 - // - this.integerToolStripMenuItem1.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_4; - this.integerToolStripMenuItem1.Name = "integerToolStripMenuItem1"; - this.integerToolStripMenuItem1.Size = new System.Drawing.Size(154, 22); - this.integerToolStripMenuItem1.Text = "Add 4 Bytes"; - this.integerToolStripMenuItem1.Value = 4; - this.integerToolStripMenuItem1.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); - // - // integerToolStripMenuItem2 - // - this.integerToolStripMenuItem2.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_8; - this.integerToolStripMenuItem2.Name = "integerToolStripMenuItem2"; - this.integerToolStripMenuItem2.Size = new System.Drawing.Size(154, 22); - this.integerToolStripMenuItem2.Text = "Add 8 Bytes"; - this.integerToolStripMenuItem2.Value = 8; - this.integerToolStripMenuItem2.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); - // - // integerToolStripMenuItem3 - // - this.integerToolStripMenuItem3.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_64; - this.integerToolStripMenuItem3.Name = "integerToolStripMenuItem3"; - this.integerToolStripMenuItem3.Size = new System.Drawing.Size(154, 22); - this.integerToolStripMenuItem3.Text = "Add 64 Bytes"; - this.integerToolStripMenuItem3.Value = 64; - this.integerToolStripMenuItem3.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); - // - // integerToolStripMenuItem4 - // - this.integerToolStripMenuItem4.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_256; - this.integerToolStripMenuItem4.Name = "integerToolStripMenuItem4"; - this.integerToolStripMenuItem4.Size = new System.Drawing.Size(154, 22); - this.integerToolStripMenuItem4.Text = "Add 256 Bytes"; - this.integerToolStripMenuItem4.Value = 256; - this.integerToolStripMenuItem4.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); - // - // integerToolStripMenuItem5 - // - this.integerToolStripMenuItem5.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_1024; - this.integerToolStripMenuItem5.Name = "integerToolStripMenuItem5"; - this.integerToolStripMenuItem5.Size = new System.Drawing.Size(154, 22); - this.integerToolStripMenuItem5.Text = "Add 1024 Bytes"; - this.integerToolStripMenuItem5.Value = 1024; - this.integerToolStripMenuItem5.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); - // - // integerToolStripMenuItem6 - // - this.integerToolStripMenuItem6.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_2048; - this.integerToolStripMenuItem6.Name = "integerToolStripMenuItem6"; - this.integerToolStripMenuItem6.Size = new System.Drawing.Size(154, 22); - this.integerToolStripMenuItem6.Text = "Add 2048 Bytes"; - this.integerToolStripMenuItem6.Value = 2048; - this.integerToolStripMenuItem6.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); - // - // integerToolStripMenuItem7 - // - this.integerToolStripMenuItem7.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_4096; - this.integerToolStripMenuItem7.Name = "integerToolStripMenuItem7"; - this.integerToolStripMenuItem7.Size = new System.Drawing.Size(154, 22); - this.integerToolStripMenuItem7.Text = "Add 4096 Bytes"; - this.integerToolStripMenuItem7.Value = 4096; - this.integerToolStripMenuItem7.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); - // - // toolStripMenuItem1 - // - this.toolStripMenuItem1.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_X; - this.toolStripMenuItem1.Name = "toolStripMenuItem1"; - this.toolStripMenuItem1.Size = new System.Drawing.Size(154, 22); - this.toolStripMenuItem1.Text = "Add ... Bytes"; - this.toolStripMenuItem1.Click += new System.EventHandler(this.addXBytesToolStripMenuItem_Click); - // - // insertBytesToolStripMenuItem - // - this.insertBytesToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.addBytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_X; + this.addBytesToolStripMenuItem.Name = "addBytesToolStripMenuItem"; + this.addBytesToolStripMenuItem.Size = new System.Drawing.Size(269, 22); + this.addBytesToolStripMenuItem.Text = "Add Bytes"; + // + // integerToolStripMenuItem1 + // + this.integerToolStripMenuItem1.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_4; + this.integerToolStripMenuItem1.Name = "integerToolStripMenuItem1"; + this.integerToolStripMenuItem1.Size = new System.Drawing.Size(154, 22); + this.integerToolStripMenuItem1.Text = "Add 4 Bytes"; + this.integerToolStripMenuItem1.Value = 4; + this.integerToolStripMenuItem1.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); + // + // integerToolStripMenuItem2 + // + this.integerToolStripMenuItem2.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_8; + this.integerToolStripMenuItem2.Name = "integerToolStripMenuItem2"; + this.integerToolStripMenuItem2.Size = new System.Drawing.Size(154, 22); + this.integerToolStripMenuItem2.Text = "Add 8 Bytes"; + this.integerToolStripMenuItem2.Value = 8; + this.integerToolStripMenuItem2.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); + // + // integerToolStripMenuItem3 + // + this.integerToolStripMenuItem3.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_64; + this.integerToolStripMenuItem3.Name = "integerToolStripMenuItem3"; + this.integerToolStripMenuItem3.Size = new System.Drawing.Size(154, 22); + this.integerToolStripMenuItem3.Text = "Add 64 Bytes"; + this.integerToolStripMenuItem3.Value = 64; + this.integerToolStripMenuItem3.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); + // + // integerToolStripMenuItem4 + // + this.integerToolStripMenuItem4.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_256; + this.integerToolStripMenuItem4.Name = "integerToolStripMenuItem4"; + this.integerToolStripMenuItem4.Size = new System.Drawing.Size(154, 22); + this.integerToolStripMenuItem4.Text = "Add 256 Bytes"; + this.integerToolStripMenuItem4.Value = 256; + this.integerToolStripMenuItem4.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); + // + // integerToolStripMenuItem5 + // + this.integerToolStripMenuItem5.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_1024; + this.integerToolStripMenuItem5.Name = "integerToolStripMenuItem5"; + this.integerToolStripMenuItem5.Size = new System.Drawing.Size(154, 22); + this.integerToolStripMenuItem5.Text = "Add 1024 Bytes"; + this.integerToolStripMenuItem5.Value = 1024; + this.integerToolStripMenuItem5.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); + // + // integerToolStripMenuItem6 + // + this.integerToolStripMenuItem6.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_2048; + this.integerToolStripMenuItem6.Name = "integerToolStripMenuItem6"; + this.integerToolStripMenuItem6.Size = new System.Drawing.Size(154, 22); + this.integerToolStripMenuItem6.Text = "Add 2048 Bytes"; + this.integerToolStripMenuItem6.Value = 2048; + this.integerToolStripMenuItem6.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); + // + // integerToolStripMenuItem7 + // + this.integerToolStripMenuItem7.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_4096; + this.integerToolStripMenuItem7.Name = "integerToolStripMenuItem7"; + this.integerToolStripMenuItem7.Size = new System.Drawing.Size(154, 22); + this.integerToolStripMenuItem7.Text = "Add 4096 Bytes"; + this.integerToolStripMenuItem7.Value = 4096; + this.integerToolStripMenuItem7.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); + // + // toolStripMenuItem1 + // + this.toolStripMenuItem1.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_X; + this.toolStripMenuItem1.Name = "toolStripMenuItem1"; + this.toolStripMenuItem1.Size = new System.Drawing.Size(154, 22); + this.toolStripMenuItem1.Text = "Add ... Bytes"; + this.toolStripMenuItem1.Click += new System.EventHandler(this.addXBytesToolStripMenuItem_Click); + // + // insertBytesToolStripMenuItem + // + this.insertBytesToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { this.integerToolStripMenuItem8, this.integerToolStripMenuItem9, this.integerToolStripMenuItem10, @@ -510,261 +510,261 @@ private void InitializeComponent() this.integerToolStripMenuItem13, this.integerToolStripMenuItem14, this.toolStripMenuItem2}); - this.insertBytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_X; - this.insertBytesToolStripMenuItem.Name = "insertBytesToolStripMenuItem"; - this.insertBytesToolStripMenuItem.Size = new System.Drawing.Size(269, 22); - this.insertBytesToolStripMenuItem.Text = "Insert Bytes"; - // - // integerToolStripMenuItem8 - // - this.integerToolStripMenuItem8.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_4; - this.integerToolStripMenuItem8.Name = "integerToolStripMenuItem8"; - this.integerToolStripMenuItem8.Size = new System.Drawing.Size(161, 22); - this.integerToolStripMenuItem8.Text = "Insert 4 Bytes"; - this.integerToolStripMenuItem8.Value = 4; - this.integerToolStripMenuItem8.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); - // - // integerToolStripMenuItem9 - // - this.integerToolStripMenuItem9.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_8; - this.integerToolStripMenuItem9.Name = "integerToolStripMenuItem9"; - this.integerToolStripMenuItem9.Size = new System.Drawing.Size(161, 22); - this.integerToolStripMenuItem9.Text = "Insert 8 Bytes"; - this.integerToolStripMenuItem9.Value = 8; - this.integerToolStripMenuItem9.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); - // - // integerToolStripMenuItem10 - // - this.integerToolStripMenuItem10.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_64; - this.integerToolStripMenuItem10.Name = "integerToolStripMenuItem10"; - this.integerToolStripMenuItem10.Size = new System.Drawing.Size(161, 22); - this.integerToolStripMenuItem10.Text = "Insert 64 Bytes"; - this.integerToolStripMenuItem10.Value = 64; - this.integerToolStripMenuItem10.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); - // - // integerToolStripMenuItem11 - // - this.integerToolStripMenuItem11.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_256; - this.integerToolStripMenuItem11.Name = "integerToolStripMenuItem11"; - this.integerToolStripMenuItem11.Size = new System.Drawing.Size(161, 22); - this.integerToolStripMenuItem11.Text = "Insert 256 Bytes"; - this.integerToolStripMenuItem11.Value = 256; - this.integerToolStripMenuItem11.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); - // - // integerToolStripMenuItem12 - // - this.integerToolStripMenuItem12.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_1024; - this.integerToolStripMenuItem12.Name = "integerToolStripMenuItem12"; - this.integerToolStripMenuItem12.Size = new System.Drawing.Size(161, 22); - this.integerToolStripMenuItem12.Text = "Insert 1024 Bytes"; - this.integerToolStripMenuItem12.Value = 1024; - this.integerToolStripMenuItem12.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); - // - // integerToolStripMenuItem13 - // - this.integerToolStripMenuItem13.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_2048; - this.integerToolStripMenuItem13.Name = "integerToolStripMenuItem13"; - this.integerToolStripMenuItem13.Size = new System.Drawing.Size(161, 22); - this.integerToolStripMenuItem13.Text = "Insert 2048 Bytes"; - this.integerToolStripMenuItem13.Value = 2048; - this.integerToolStripMenuItem13.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); - // - // integerToolStripMenuItem14 - // - this.integerToolStripMenuItem14.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_4096; - this.integerToolStripMenuItem14.Name = "integerToolStripMenuItem14"; - this.integerToolStripMenuItem14.Size = new System.Drawing.Size(161, 22); - this.integerToolStripMenuItem14.Text = "Insert 4096 Bytes"; - this.integerToolStripMenuItem14.Value = 4096; - this.integerToolStripMenuItem14.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); - // - // toolStripMenuItem2 - // - this.toolStripMenuItem2.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_X; - this.toolStripMenuItem2.Name = "toolStripMenuItem2"; - this.toolStripMenuItem2.Size = new System.Drawing.Size(161, 22); - this.toolStripMenuItem2.Text = "Insert ... Bytes"; - this.toolStripMenuItem2.Click += new System.EventHandler(this.insertXBytesToolStripMenuItem_Click); - // - // toolStripSeparator8 - // - this.toolStripSeparator8.Name = "toolStripSeparator8"; - this.toolStripSeparator8.Size = new System.Drawing.Size(266, 6); - // - // createClassFromNodesToolStripMenuItem - // - this.createClassFromNodesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Class_Add; - this.createClassFromNodesToolStripMenuItem.Name = "createClassFromNodesToolStripMenuItem"; - this.createClassFromNodesToolStripMenuItem.Size = new System.Drawing.Size(269, 22); - this.createClassFromNodesToolStripMenuItem.Text = "Create Class from Nodes"; - this.createClassFromNodesToolStripMenuItem.Click += new System.EventHandler(this.createClassFromNodesToolStripMenuItem_Click); - // - // toolStripSeparator13 - // - this.toolStripSeparator13.Name = "toolStripSeparator13"; - this.toolStripSeparator13.Size = new System.Drawing.Size(266, 6); - // - // dissectNodesToolStripMenuItem - // - this.dissectNodesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Camera; - this.dissectNodesToolStripMenuItem.Name = "dissectNodesToolStripMenuItem"; - this.dissectNodesToolStripMenuItem.Size = new System.Drawing.Size(269, 22); - this.dissectNodesToolStripMenuItem.Text = "Dissect Node(s)"; - this.dissectNodesToolStripMenuItem.Click += new System.EventHandler(this.dissectNodesToolStripMenuItem_Click); - // - // toolStripSeparator9 - // - this.toolStripSeparator9.Name = "toolStripSeparator9"; - this.toolStripSeparator9.Size = new System.Drawing.Size(266, 6); - // - // searchForEqualValuesToolStripMenuItem - // - this.searchForEqualValuesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Eye; - this.searchForEqualValuesToolStripMenuItem.Name = "searchForEqualValuesToolStripMenuItem"; - this.searchForEqualValuesToolStripMenuItem.Size = new System.Drawing.Size(269, 22); - this.searchForEqualValuesToolStripMenuItem.Text = "Search for equal values..."; - this.searchForEqualValuesToolStripMenuItem.Click += new System.EventHandler(this.searchForEqualValuesToolStripMenuItem_Click); - // - // toolStripSeparator15 - // - this.toolStripSeparator15.Name = "toolStripSeparator15"; - this.toolStripSeparator15.Size = new System.Drawing.Size(266, 6); - // - // findOutWhatAccessesThisAddressToolStripMenuItem - // - this.findOutWhatAccessesThisAddressToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Find_Access; - this.findOutWhatAccessesThisAddressToolStripMenuItem.Name = "findOutWhatAccessesThisAddressToolStripMenuItem"; - this.findOutWhatAccessesThisAddressToolStripMenuItem.Size = new System.Drawing.Size(269, 22); - this.findOutWhatAccessesThisAddressToolStripMenuItem.Text = "Find out what accesses this address..."; - this.findOutWhatAccessesThisAddressToolStripMenuItem.Click += new System.EventHandler(this.findOutWhatAccessesThisAddressToolStripMenuItem_Click); - // - // findOutWhatWritesToThisAddressToolStripMenuItem - // - this.findOutWhatWritesToThisAddressToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Find_Write; - this.findOutWhatWritesToThisAddressToolStripMenuItem.Name = "findOutWhatWritesToThisAddressToolStripMenuItem"; - this.findOutWhatWritesToThisAddressToolStripMenuItem.Size = new System.Drawing.Size(269, 22); - this.findOutWhatWritesToThisAddressToolStripMenuItem.Text = "Find out what writes to this address..."; - this.findOutWhatWritesToThisAddressToolStripMenuItem.Click += new System.EventHandler(this.findOutWhatWritesToThisAddressToolStripMenuItem_Click); - // - // toolStripSeparator14 - // - this.toolStripSeparator14.Name = "toolStripSeparator14"; - this.toolStripSeparator14.Size = new System.Drawing.Size(266, 6); - // - // copyNodeToolStripMenuItem - // - this.copyNodeToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Page_Copy; - this.copyNodeToolStripMenuItem.Name = "copyNodeToolStripMenuItem"; - this.copyNodeToolStripMenuItem.Size = new System.Drawing.Size(269, 22); - this.copyNodeToolStripMenuItem.Text = "Copy Node(s)"; - this.copyNodeToolStripMenuItem.Click += new System.EventHandler(this.copyNodeToolStripMenuItem_Click); - // - // pasteNodesToolStripMenuItem - // - this.pasteNodesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Page_Paste; - this.pasteNodesToolStripMenuItem.Name = "pasteNodesToolStripMenuItem"; - this.pasteNodesToolStripMenuItem.Size = new System.Drawing.Size(269, 22); - this.pasteNodesToolStripMenuItem.Text = "Paste Node(s)"; - this.pasteNodesToolStripMenuItem.Click += new System.EventHandler(this.pasteNodesToolStripMenuItem_Click); - // - // toolStripSeparator10 - // - this.toolStripSeparator10.Name = "toolStripSeparator10"; - this.toolStripSeparator10.Size = new System.Drawing.Size(266, 6); - // - // removeToolStripMenuItem - // - this.removeToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Delete; - this.removeToolStripMenuItem.Name = "removeToolStripMenuItem"; - this.removeToolStripMenuItem.Size = new System.Drawing.Size(269, 22); - this.removeToolStripMenuItem.Text = "Remove Node(s)"; - this.removeToolStripMenuItem.Click += new System.EventHandler(this.removeToolStripMenuItem_Click); - // - // toolStripSeparator12 - // - this.toolStripSeparator12.Name = "toolStripSeparator12"; - this.toolStripSeparator12.Size = new System.Drawing.Size(266, 6); - // - // hideNodesToolStripMenuItem - // - this.hideNodesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Eye; - this.hideNodesToolStripMenuItem.Name = "hideNodesToolStripMenuItem"; - this.hideNodesToolStripMenuItem.Size = new System.Drawing.Size(269, 22); - this.hideNodesToolStripMenuItem.Text = "Hide selected Node(s)"; - this.hideNodesToolStripMenuItem.Click += new System.EventHandler(this.hideNodesToolStripMenuItem_Click); - // - // unhideNodesToolStripMenuItem - // - this.unhideNodesToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.insertBytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_X; + this.insertBytesToolStripMenuItem.Name = "insertBytesToolStripMenuItem"; + this.insertBytesToolStripMenuItem.Size = new System.Drawing.Size(269, 22); + this.insertBytesToolStripMenuItem.Text = "Insert Bytes"; + // + // integerToolStripMenuItem8 + // + this.integerToolStripMenuItem8.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_4; + this.integerToolStripMenuItem8.Name = "integerToolStripMenuItem8"; + this.integerToolStripMenuItem8.Size = new System.Drawing.Size(161, 22); + this.integerToolStripMenuItem8.Text = "Insert 4 Bytes"; + this.integerToolStripMenuItem8.Value = 4; + this.integerToolStripMenuItem8.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); + // + // integerToolStripMenuItem9 + // + this.integerToolStripMenuItem9.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_8; + this.integerToolStripMenuItem9.Name = "integerToolStripMenuItem9"; + this.integerToolStripMenuItem9.Size = new System.Drawing.Size(161, 22); + this.integerToolStripMenuItem9.Text = "Insert 8 Bytes"; + this.integerToolStripMenuItem9.Value = 8; + this.integerToolStripMenuItem9.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); + // + // integerToolStripMenuItem10 + // + this.integerToolStripMenuItem10.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_64; + this.integerToolStripMenuItem10.Name = "integerToolStripMenuItem10"; + this.integerToolStripMenuItem10.Size = new System.Drawing.Size(161, 22); + this.integerToolStripMenuItem10.Text = "Insert 64 Bytes"; + this.integerToolStripMenuItem10.Value = 64; + this.integerToolStripMenuItem10.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); + // + // integerToolStripMenuItem11 + // + this.integerToolStripMenuItem11.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_256; + this.integerToolStripMenuItem11.Name = "integerToolStripMenuItem11"; + this.integerToolStripMenuItem11.Size = new System.Drawing.Size(161, 22); + this.integerToolStripMenuItem11.Text = "Insert 256 Bytes"; + this.integerToolStripMenuItem11.Value = 256; + this.integerToolStripMenuItem11.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); + // + // integerToolStripMenuItem12 + // + this.integerToolStripMenuItem12.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_1024; + this.integerToolStripMenuItem12.Name = "integerToolStripMenuItem12"; + this.integerToolStripMenuItem12.Size = new System.Drawing.Size(161, 22); + this.integerToolStripMenuItem12.Text = "Insert 1024 Bytes"; + this.integerToolStripMenuItem12.Value = 1024; + this.integerToolStripMenuItem12.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); + // + // integerToolStripMenuItem13 + // + this.integerToolStripMenuItem13.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_2048; + this.integerToolStripMenuItem13.Name = "integerToolStripMenuItem13"; + this.integerToolStripMenuItem13.Size = new System.Drawing.Size(161, 22); + this.integerToolStripMenuItem13.Text = "Insert 2048 Bytes"; + this.integerToolStripMenuItem13.Value = 2048; + this.integerToolStripMenuItem13.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); + // + // integerToolStripMenuItem14 + // + this.integerToolStripMenuItem14.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_4096; + this.integerToolStripMenuItem14.Name = "integerToolStripMenuItem14"; + this.integerToolStripMenuItem14.Size = new System.Drawing.Size(161, 22); + this.integerToolStripMenuItem14.Text = "Insert 4096 Bytes"; + this.integerToolStripMenuItem14.Value = 4096; + this.integerToolStripMenuItem14.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); + // + // toolStripMenuItem2 + // + this.toolStripMenuItem2.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_X; + this.toolStripMenuItem2.Name = "toolStripMenuItem2"; + this.toolStripMenuItem2.Size = new System.Drawing.Size(161, 22); + this.toolStripMenuItem2.Text = "Insert ... Bytes"; + this.toolStripMenuItem2.Click += new System.EventHandler(this.insertXBytesToolStripMenuItem_Click); + // + // toolStripSeparator8 + // + this.toolStripSeparator8.Name = "toolStripSeparator8"; + this.toolStripSeparator8.Size = new System.Drawing.Size(266, 6); + // + // createClassFromNodesToolStripMenuItem + // + this.createClassFromNodesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Class_Add; + this.createClassFromNodesToolStripMenuItem.Name = "createClassFromNodesToolStripMenuItem"; + this.createClassFromNodesToolStripMenuItem.Size = new System.Drawing.Size(269, 22); + this.createClassFromNodesToolStripMenuItem.Text = "Create Class from Nodes"; + this.createClassFromNodesToolStripMenuItem.Click += new System.EventHandler(this.createClassFromNodesToolStripMenuItem_Click); + // + // toolStripSeparator13 + // + this.toolStripSeparator13.Name = "toolStripSeparator13"; + this.toolStripSeparator13.Size = new System.Drawing.Size(266, 6); + // + // dissectNodesToolStripMenuItem + // + this.dissectNodesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Camera; + this.dissectNodesToolStripMenuItem.Name = "dissectNodesToolStripMenuItem"; + this.dissectNodesToolStripMenuItem.Size = new System.Drawing.Size(269, 22); + this.dissectNodesToolStripMenuItem.Text = "Dissect Node(s)"; + this.dissectNodesToolStripMenuItem.Click += new System.EventHandler(this.dissectNodesToolStripMenuItem_Click); + // + // toolStripSeparator9 + // + this.toolStripSeparator9.Name = "toolStripSeparator9"; + this.toolStripSeparator9.Size = new System.Drawing.Size(266, 6); + // + // searchForEqualValuesToolStripMenuItem + // + this.searchForEqualValuesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Eye; + this.searchForEqualValuesToolStripMenuItem.Name = "searchForEqualValuesToolStripMenuItem"; + this.searchForEqualValuesToolStripMenuItem.Size = new System.Drawing.Size(269, 22); + this.searchForEqualValuesToolStripMenuItem.Text = "Search for equal values..."; + this.searchForEqualValuesToolStripMenuItem.Click += new System.EventHandler(this.searchForEqualValuesToolStripMenuItem_Click); + // + // toolStripSeparator15 + // + this.toolStripSeparator15.Name = "toolStripSeparator15"; + this.toolStripSeparator15.Size = new System.Drawing.Size(266, 6); + // + // findOutWhatAccessesThisAddressToolStripMenuItem + // + this.findOutWhatAccessesThisAddressToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Find_Access; + this.findOutWhatAccessesThisAddressToolStripMenuItem.Name = "findOutWhatAccessesThisAddressToolStripMenuItem"; + this.findOutWhatAccessesThisAddressToolStripMenuItem.Size = new System.Drawing.Size(269, 22); + this.findOutWhatAccessesThisAddressToolStripMenuItem.Text = "Find out what accesses this address..."; + this.findOutWhatAccessesThisAddressToolStripMenuItem.Click += new System.EventHandler(this.findOutWhatAccessesThisAddressToolStripMenuItem_Click); + // + // findOutWhatWritesToThisAddressToolStripMenuItem + // + this.findOutWhatWritesToThisAddressToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Find_Write; + this.findOutWhatWritesToThisAddressToolStripMenuItem.Name = "findOutWhatWritesToThisAddressToolStripMenuItem"; + this.findOutWhatWritesToThisAddressToolStripMenuItem.Size = new System.Drawing.Size(269, 22); + this.findOutWhatWritesToThisAddressToolStripMenuItem.Text = "Find out what writes to this address..."; + this.findOutWhatWritesToThisAddressToolStripMenuItem.Click += new System.EventHandler(this.findOutWhatWritesToThisAddressToolStripMenuItem_Click); + // + // toolStripSeparator14 + // + this.toolStripSeparator14.Name = "toolStripSeparator14"; + this.toolStripSeparator14.Size = new System.Drawing.Size(266, 6); + // + // copyNodeToolStripMenuItem + // + this.copyNodeToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Page_Copy; + this.copyNodeToolStripMenuItem.Name = "copyNodeToolStripMenuItem"; + this.copyNodeToolStripMenuItem.Size = new System.Drawing.Size(269, 22); + this.copyNodeToolStripMenuItem.Text = "Copy Node(s)"; + this.copyNodeToolStripMenuItem.Click += new System.EventHandler(this.copyNodeToolStripMenuItem_Click); + // + // pasteNodesToolStripMenuItem + // + this.pasteNodesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Page_Paste; + this.pasteNodesToolStripMenuItem.Name = "pasteNodesToolStripMenuItem"; + this.pasteNodesToolStripMenuItem.Size = new System.Drawing.Size(269, 22); + this.pasteNodesToolStripMenuItem.Text = "Paste Node(s)"; + this.pasteNodesToolStripMenuItem.Click += new System.EventHandler(this.pasteNodesToolStripMenuItem_Click); + // + // toolStripSeparator10 + // + this.toolStripSeparator10.Name = "toolStripSeparator10"; + this.toolStripSeparator10.Size = new System.Drawing.Size(266, 6); + // + // removeToolStripMenuItem + // + this.removeToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Delete; + this.removeToolStripMenuItem.Name = "removeToolStripMenuItem"; + this.removeToolStripMenuItem.Size = new System.Drawing.Size(269, 22); + this.removeToolStripMenuItem.Text = "Remove Node(s)"; + this.removeToolStripMenuItem.Click += new System.EventHandler(this.removeToolStripMenuItem_Click); + // + // toolStripSeparator12 + // + this.toolStripSeparator12.Name = "toolStripSeparator12"; + this.toolStripSeparator12.Size = new System.Drawing.Size(266, 6); + // + // hideNodesToolStripMenuItem + // + this.hideNodesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Eye; + this.hideNodesToolStripMenuItem.Name = "hideNodesToolStripMenuItem"; + this.hideNodesToolStripMenuItem.Size = new System.Drawing.Size(269, 22); + this.hideNodesToolStripMenuItem.Text = "Hide selected Node(s)"; + this.hideNodesToolStripMenuItem.Click += new System.EventHandler(this.hideNodesToolStripMenuItem_Click); + // + // unhideNodesToolStripMenuItem + // + this.unhideNodesToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { this.unhideChildNodesToolStripMenuItem, this.unhideNodesAboveToolStripMenuItem, this.unhideNodesBelowToolStripMenuItem}); - this.unhideNodesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Eye; - this.unhideNodesToolStripMenuItem.Name = "unhideNodesToolStripMenuItem"; - this.unhideNodesToolStripMenuItem.Size = new System.Drawing.Size(269, 22); - this.unhideNodesToolStripMenuItem.Text = "Unhide..."; - // - // unhideChildNodesToolStripMenuItem - // - this.unhideChildNodesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Eye; - this.unhideChildNodesToolStripMenuItem.Name = "unhideChildNodesToolStripMenuItem"; - this.unhideChildNodesToolStripMenuItem.Size = new System.Drawing.Size(163, 22); - this.unhideChildNodesToolStripMenuItem.Text = "... Child Node(s)"; - this.unhideChildNodesToolStripMenuItem.Click += new System.EventHandler(this.unhideChildNodesToolStripMenuItem_Click); - // - // unhideNodesAboveToolStripMenuItem - // - this.unhideNodesAboveToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Eye; - this.unhideNodesAboveToolStripMenuItem.Name = "unhideNodesAboveToolStripMenuItem"; - this.unhideNodesAboveToolStripMenuItem.Size = new System.Drawing.Size(163, 22); - this.unhideNodesAboveToolStripMenuItem.Text = "... Node(s) above"; - this.unhideNodesAboveToolStripMenuItem.Click += new System.EventHandler(this.unhideNodesAboveToolStripMenuItem_Click); - // - // unhideNodesBelowToolStripMenuItem - // - this.unhideNodesBelowToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Eye; - this.unhideNodesBelowToolStripMenuItem.Name = "unhideNodesBelowToolStripMenuItem"; - this.unhideNodesBelowToolStripMenuItem.Size = new System.Drawing.Size(163, 22); - this.unhideNodesBelowToolStripMenuItem.Text = "... Node(s) below"; - this.unhideNodesBelowToolStripMenuItem.Click += new System.EventHandler(this.unhideNodesBelowToolStripMenuItem_Click); - // - // toolStripSeparator18 - // - this.toolStripSeparator18.Name = "toolStripSeparator18"; - this.toolStripSeparator18.Size = new System.Drawing.Size(266, 6); - // - // copyAddressToolStripMenuItem - // - this.copyAddressToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Page_Copy; - this.copyAddressToolStripMenuItem.Name = "copyAddressToolStripMenuItem"; - this.copyAddressToolStripMenuItem.Size = new System.Drawing.Size(269, 22); - this.copyAddressToolStripMenuItem.Text = "Copy Address"; - this.copyAddressToolStripMenuItem.Click += new System.EventHandler(this.copyAddressToolStripMenuItem_Click); - // - // toolStripSeparator11 - // - this.toolStripSeparator11.Name = "toolStripSeparator11"; - this.toolStripSeparator11.Size = new System.Drawing.Size(266, 6); - // - // showCodeOfClassToolStripMenuItem - // - this.showCodeOfClassToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Page_Code_Cpp; - this.showCodeOfClassToolStripMenuItem.Name = "showCodeOfClassToolStripMenuItem"; - this.showCodeOfClassToolStripMenuItem.Size = new System.Drawing.Size(269, 22); - this.showCodeOfClassToolStripMenuItem.Text = "Show C++ Code of Class"; - this.showCodeOfClassToolStripMenuItem.Click += new System.EventHandler(this.showCodeOfClassToolStripMenuItem_Click); - // - // shrinkClassToolStripMenuItem - // - this.shrinkClassToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Chart_Delete; - this.shrinkClassToolStripMenuItem.Name = "shrinkClassToolStripMenuItem"; - this.shrinkClassToolStripMenuItem.Size = new System.Drawing.Size(269, 22); - this.shrinkClassToolStripMenuItem.Text = "Shrink Class"; - this.shrinkClassToolStripMenuItem.Click += new System.EventHandler(this.shrinkClassToolStripMenuItem_Click); - // - // toolStrip - // - this.toolStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.unhideNodesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Eye; + this.unhideNodesToolStripMenuItem.Name = "unhideNodesToolStripMenuItem"; + this.unhideNodesToolStripMenuItem.Size = new System.Drawing.Size(269, 22); + this.unhideNodesToolStripMenuItem.Text = "Unhide..."; + // + // unhideChildNodesToolStripMenuItem + // + this.unhideChildNodesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Eye; + this.unhideChildNodesToolStripMenuItem.Name = "unhideChildNodesToolStripMenuItem"; + this.unhideChildNodesToolStripMenuItem.Size = new System.Drawing.Size(163, 22); + this.unhideChildNodesToolStripMenuItem.Text = "... Child Node(s)"; + this.unhideChildNodesToolStripMenuItem.Click += new System.EventHandler(this.unhideChildNodesToolStripMenuItem_Click); + // + // unhideNodesAboveToolStripMenuItem + // + this.unhideNodesAboveToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Eye; + this.unhideNodesAboveToolStripMenuItem.Name = "unhideNodesAboveToolStripMenuItem"; + this.unhideNodesAboveToolStripMenuItem.Size = new System.Drawing.Size(163, 22); + this.unhideNodesAboveToolStripMenuItem.Text = "... Node(s) above"; + this.unhideNodesAboveToolStripMenuItem.Click += new System.EventHandler(this.unhideNodesAboveToolStripMenuItem_Click); + // + // unhideNodesBelowToolStripMenuItem + // + this.unhideNodesBelowToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Eye; + this.unhideNodesBelowToolStripMenuItem.Name = "unhideNodesBelowToolStripMenuItem"; + this.unhideNodesBelowToolStripMenuItem.Size = new System.Drawing.Size(163, 22); + this.unhideNodesBelowToolStripMenuItem.Text = "... Node(s) below"; + this.unhideNodesBelowToolStripMenuItem.Click += new System.EventHandler(this.unhideNodesBelowToolStripMenuItem_Click); + // + // toolStripSeparator18 + // + this.toolStripSeparator18.Name = "toolStripSeparator18"; + this.toolStripSeparator18.Size = new System.Drawing.Size(266, 6); + // + // copyAddressToolStripMenuItem + // + this.copyAddressToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Page_Copy; + this.copyAddressToolStripMenuItem.Name = "copyAddressToolStripMenuItem"; + this.copyAddressToolStripMenuItem.Size = new System.Drawing.Size(269, 22); + this.copyAddressToolStripMenuItem.Text = "Copy Address"; + this.copyAddressToolStripMenuItem.Click += new System.EventHandler(this.copyAddressToolStripMenuItem_Click); + // + // toolStripSeparator11 + // + this.toolStripSeparator11.Name = "toolStripSeparator11"; + this.toolStripSeparator11.Size = new System.Drawing.Size(266, 6); + // + // showCodeOfClassToolStripMenuItem + // + this.showCodeOfClassToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Page_Code_Cpp; + this.showCodeOfClassToolStripMenuItem.Name = "showCodeOfClassToolStripMenuItem"; + this.showCodeOfClassToolStripMenuItem.Size = new System.Drawing.Size(269, 22); + this.showCodeOfClassToolStripMenuItem.Text = "Show C++ Code of Class"; + this.showCodeOfClassToolStripMenuItem.Click += new System.EventHandler(this.showCodeOfClassToolStripMenuItem_Click); + // + // shrinkClassToolStripMenuItem + // + this.shrinkClassToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Chart_Delete; + this.shrinkClassToolStripMenuItem.Name = "shrinkClassToolStripMenuItem"; + this.shrinkClassToolStripMenuItem.Size = new System.Drawing.Size(269, 22); + this.shrinkClassToolStripMenuItem.Text = "Shrink Class"; + this.shrinkClassToolStripMenuItem.Click += new System.EventHandler(this.shrinkClassToolStripMenuItem_Click); + // + // toolStrip + // + this.toolStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { this.attachToProcessToolStripSplitButton, this.toolStripSeparator6, this.openProjectToolStripButton, @@ -774,68 +774,68 @@ private void InitializeComponent() this.addBytesToolStripDropDownButton, this.insertBytesToolStripDropDownButton, this.nodeTypesToolStripSeparator}); - this.toolStrip.Location = new System.Drawing.Point(0, 24); - this.toolStrip.Name = "toolStrip"; - this.toolStrip.Size = new System.Drawing.Size(1141, 25); - this.toolStrip.TabIndex = 3; - // - // attachToProcessToolStripSplitButton - // - this.attachToProcessToolStripSplitButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; - this.attachToProcessToolStripSplitButton.Image = global::ReClassNET.Properties.Resources.B16x16_Magnifier; - this.attachToProcessToolStripSplitButton.ImageTransparentColor = System.Drawing.Color.Magenta; - this.attachToProcessToolStripSplitButton.Name = "attachToProcessToolStripSplitButton"; - this.attachToProcessToolStripSplitButton.Size = new System.Drawing.Size(32, 22); - this.attachToProcessToolStripSplitButton.ToolTipText = "Attach to Process..."; - this.attachToProcessToolStripSplitButton.ButtonClick += new System.EventHandler(this.attachToProcessToolStripSplitButton_ButtonClick); - this.attachToProcessToolStripSplitButton.DropDownClosed += new System.EventHandler(this.attachToProcessToolStripSplitButton_DropDownClosed); - this.attachToProcessToolStripSplitButton.DropDownOpening += new System.EventHandler(this.attachToProcessToolStripSplitButton_DropDownOpening); - // - // toolStripSeparator6 - // - this.toolStripSeparator6.Name = "toolStripSeparator6"; - this.toolStripSeparator6.Size = new System.Drawing.Size(6, 25); - // - // openProjectToolStripButton - // - this.openProjectToolStripButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; - this.openProjectToolStripButton.Image = global::ReClassNET.Properties.Resources.B16x16_Folder; - this.openProjectToolStripButton.ImageTransparentColor = System.Drawing.Color.Magenta; - this.openProjectToolStripButton.Name = "openProjectToolStripButton"; - this.openProjectToolStripButton.Size = new System.Drawing.Size(23, 22); - this.openProjectToolStripButton.ToolTipText = "Open Project..."; - this.openProjectToolStripButton.Click += new System.EventHandler(this.openProjectToolStripMenuItem_Click); - // - // saveToolStripButton - // - this.saveToolStripButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; - this.saveToolStripButton.Image = global::ReClassNET.Properties.Resources.B16x16_Save; - this.saveToolStripButton.ImageTransparentColor = System.Drawing.Color.Magenta; - this.saveToolStripButton.Name = "saveToolStripButton"; - this.saveToolStripButton.Size = new System.Drawing.Size(23, 22); - this.saveToolStripButton.ToolTipText = "Save Project"; - this.saveToolStripButton.Click += new System.EventHandler(this.saveToolStripMenuItem_Click); - // - // toolStripSeparator7 - // - this.toolStripSeparator7.Name = "toolStripSeparator7"; - this.toolStripSeparator7.Size = new System.Drawing.Size(6, 25); - // - // newClassToolStripButton - // - this.newClassToolStripButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; - this.newClassToolStripButton.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Class_Add; - this.newClassToolStripButton.ImageTransparentColor = System.Drawing.Color.Magenta; - this.newClassToolStripButton.Name = "newClassToolStripButton"; - this.newClassToolStripButton.Size = new System.Drawing.Size(23, 22); - this.newClassToolStripButton.Text = "addClassToolStripButton"; - this.newClassToolStripButton.ToolTipText = "Add a new class to this project"; - this.newClassToolStripButton.Click += new System.EventHandler(this.newClassToolStripButton_Click); - // - // addBytesToolStripDropDownButton - // - this.addBytesToolStripDropDownButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; - this.addBytesToolStripDropDownButton.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.toolStrip.Location = new System.Drawing.Point(0, 24); + this.toolStrip.Name = "toolStrip"; + this.toolStrip.Size = new System.Drawing.Size(1141, 25); + this.toolStrip.TabIndex = 3; + // + // attachToProcessToolStripSplitButton + // + this.attachToProcessToolStripSplitButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.attachToProcessToolStripSplitButton.Image = global::ReClassNET.Properties.Resources.B16x16_Magnifier; + this.attachToProcessToolStripSplitButton.ImageTransparentColor = System.Drawing.Color.Magenta; + this.attachToProcessToolStripSplitButton.Name = "attachToProcessToolStripSplitButton"; + this.attachToProcessToolStripSplitButton.Size = new System.Drawing.Size(32, 22); + this.attachToProcessToolStripSplitButton.ToolTipText = "Attach to Process..."; + this.attachToProcessToolStripSplitButton.ButtonClick += new System.EventHandler(this.attachToProcessToolStripSplitButton_ButtonClick); + this.attachToProcessToolStripSplitButton.DropDownClosed += new System.EventHandler(this.attachToProcessToolStripSplitButton_DropDownClosed); + this.attachToProcessToolStripSplitButton.DropDownOpening += new System.EventHandler(this.attachToProcessToolStripSplitButton_DropDownOpening); + // + // toolStripSeparator6 + // + this.toolStripSeparator6.Name = "toolStripSeparator6"; + this.toolStripSeparator6.Size = new System.Drawing.Size(6, 25); + // + // openProjectToolStripButton + // + this.openProjectToolStripButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.openProjectToolStripButton.Image = global::ReClassNET.Properties.Resources.B16x16_Folder; + this.openProjectToolStripButton.ImageTransparentColor = System.Drawing.Color.Magenta; + this.openProjectToolStripButton.Name = "openProjectToolStripButton"; + this.openProjectToolStripButton.Size = new System.Drawing.Size(23, 22); + this.openProjectToolStripButton.ToolTipText = "Open Project..."; + this.openProjectToolStripButton.Click += new System.EventHandler(this.openProjectToolStripMenuItem_Click); + // + // saveToolStripButton + // + this.saveToolStripButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.saveToolStripButton.Image = global::ReClassNET.Properties.Resources.B16x16_Save; + this.saveToolStripButton.ImageTransparentColor = System.Drawing.Color.Magenta; + this.saveToolStripButton.Name = "saveToolStripButton"; + this.saveToolStripButton.Size = new System.Drawing.Size(23, 22); + this.saveToolStripButton.ToolTipText = "Save Project"; + this.saveToolStripButton.Click += new System.EventHandler(this.saveToolStripMenuItem_Click); + // + // toolStripSeparator7 + // + this.toolStripSeparator7.Name = "toolStripSeparator7"; + this.toolStripSeparator7.Size = new System.Drawing.Size(6, 25); + // + // newClassToolStripButton + // + this.newClassToolStripButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.newClassToolStripButton.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Class_Add; + this.newClassToolStripButton.ImageTransparentColor = System.Drawing.Color.Magenta; + this.newClassToolStripButton.Name = "newClassToolStripButton"; + this.newClassToolStripButton.Size = new System.Drawing.Size(23, 22); + this.newClassToolStripButton.Text = "addClassToolStripButton"; + this.newClassToolStripButton.ToolTipText = "Add a new class to this project"; + this.newClassToolStripButton.Click += new System.EventHandler(this.newClassToolStripButton_Click); + // + // addBytesToolStripDropDownButton + // + this.addBytesToolStripDropDownButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.addBytesToolStripDropDownButton.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { this.add4BytesToolStripMenuItem, this.add8BytesToolStripMenuItem, this.add64BytesToolStripMenuItem, @@ -844,87 +844,87 @@ private void InitializeComponent() this.add2048BytesToolStripMenuItem, this.add4096BytesToolStripMenuItem, this.addXBytesToolStripMenuItem}); - this.addBytesToolStripDropDownButton.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_X; - this.addBytesToolStripDropDownButton.ImageTransparentColor = System.Drawing.Color.Magenta; - this.addBytesToolStripDropDownButton.Name = "addBytesToolStripDropDownButton"; - this.addBytesToolStripDropDownButton.Size = new System.Drawing.Size(29, 22); - // - // add4BytesToolStripMenuItem - // - this.add4BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_4; - this.add4BytesToolStripMenuItem.Name = "add4BytesToolStripMenuItem"; - this.add4BytesToolStripMenuItem.Size = new System.Drawing.Size(154, 22); - this.add4BytesToolStripMenuItem.Tag = ""; - this.add4BytesToolStripMenuItem.Text = "Add 4 Bytes"; - this.add4BytesToolStripMenuItem.Value = 4; - this.add4BytesToolStripMenuItem.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); - // - // add8BytesToolStripMenuItem - // - this.add8BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_8; - this.add8BytesToolStripMenuItem.Name = "add8BytesToolStripMenuItem"; - this.add8BytesToolStripMenuItem.Size = new System.Drawing.Size(154, 22); - this.add8BytesToolStripMenuItem.Text = "Add 8 Bytes"; - this.add8BytesToolStripMenuItem.Value = 8; - this.add8BytesToolStripMenuItem.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); - // - // add64BytesToolStripMenuItem - // - this.add64BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_64; - this.add64BytesToolStripMenuItem.Name = "add64BytesToolStripMenuItem"; - this.add64BytesToolStripMenuItem.Size = new System.Drawing.Size(154, 22); - this.add64BytesToolStripMenuItem.Text = "Add 64 Bytes"; - this.add64BytesToolStripMenuItem.Value = 64; - this.add64BytesToolStripMenuItem.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); - // - // add256BytesToolStripMenuItem - // - this.add256BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_256; - this.add256BytesToolStripMenuItem.Name = "add256BytesToolStripMenuItem"; - this.add256BytesToolStripMenuItem.Size = new System.Drawing.Size(154, 22); - this.add256BytesToolStripMenuItem.Text = "Add 256 Bytes"; - this.add256BytesToolStripMenuItem.Value = 256; - this.add256BytesToolStripMenuItem.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); - // - // add1024BytesToolStripMenuItem - // - this.add1024BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_1024; - this.add1024BytesToolStripMenuItem.Name = "add1024BytesToolStripMenuItem"; - this.add1024BytesToolStripMenuItem.Size = new System.Drawing.Size(154, 22); - this.add1024BytesToolStripMenuItem.Text = "Add 1024 Bytes"; - this.add1024BytesToolStripMenuItem.Value = 1024; - this.add1024BytesToolStripMenuItem.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); - // - // add2048BytesToolStripMenuItem - // - this.add2048BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_2048; - this.add2048BytesToolStripMenuItem.Name = "add2048BytesToolStripMenuItem"; - this.add2048BytesToolStripMenuItem.Size = new System.Drawing.Size(154, 22); - this.add2048BytesToolStripMenuItem.Text = "Add 2048 Bytes"; - this.add2048BytesToolStripMenuItem.Value = 2048; - this.add2048BytesToolStripMenuItem.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); - // - // add4096BytesToolStripMenuItem - // - this.add4096BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_4096; - this.add4096BytesToolStripMenuItem.Name = "add4096BytesToolStripMenuItem"; - this.add4096BytesToolStripMenuItem.Size = new System.Drawing.Size(154, 22); - this.add4096BytesToolStripMenuItem.Text = "Add 4096 Bytes"; - this.add4096BytesToolStripMenuItem.Value = 4096; - this.add4096BytesToolStripMenuItem.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); - // - // addXBytesToolStripMenuItem - // - this.addXBytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_X; - this.addXBytesToolStripMenuItem.Name = "addXBytesToolStripMenuItem"; - this.addXBytesToolStripMenuItem.Size = new System.Drawing.Size(154, 22); - this.addXBytesToolStripMenuItem.Text = "Add ... Bytes"; - this.addXBytesToolStripMenuItem.Click += new System.EventHandler(this.addXBytesToolStripMenuItem_Click); - // - // insertBytesToolStripDropDownButton - // - this.insertBytesToolStripDropDownButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; - this.insertBytesToolStripDropDownButton.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.addBytesToolStripDropDownButton.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_X; + this.addBytesToolStripDropDownButton.ImageTransparentColor = System.Drawing.Color.Magenta; + this.addBytesToolStripDropDownButton.Name = "addBytesToolStripDropDownButton"; + this.addBytesToolStripDropDownButton.Size = new System.Drawing.Size(29, 22); + // + // add4BytesToolStripMenuItem + // + this.add4BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_4; + this.add4BytesToolStripMenuItem.Name = "add4BytesToolStripMenuItem"; + this.add4BytesToolStripMenuItem.Size = new System.Drawing.Size(154, 22); + this.add4BytesToolStripMenuItem.Tag = ""; + this.add4BytesToolStripMenuItem.Text = "Add 4 Bytes"; + this.add4BytesToolStripMenuItem.Value = 4; + this.add4BytesToolStripMenuItem.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); + // + // add8BytesToolStripMenuItem + // + this.add8BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_8; + this.add8BytesToolStripMenuItem.Name = "add8BytesToolStripMenuItem"; + this.add8BytesToolStripMenuItem.Size = new System.Drawing.Size(154, 22); + this.add8BytesToolStripMenuItem.Text = "Add 8 Bytes"; + this.add8BytesToolStripMenuItem.Value = 8; + this.add8BytesToolStripMenuItem.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); + // + // add64BytesToolStripMenuItem + // + this.add64BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_64; + this.add64BytesToolStripMenuItem.Name = "add64BytesToolStripMenuItem"; + this.add64BytesToolStripMenuItem.Size = new System.Drawing.Size(154, 22); + this.add64BytesToolStripMenuItem.Text = "Add 64 Bytes"; + this.add64BytesToolStripMenuItem.Value = 64; + this.add64BytesToolStripMenuItem.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); + // + // add256BytesToolStripMenuItem + // + this.add256BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_256; + this.add256BytesToolStripMenuItem.Name = "add256BytesToolStripMenuItem"; + this.add256BytesToolStripMenuItem.Size = new System.Drawing.Size(154, 22); + this.add256BytesToolStripMenuItem.Text = "Add 256 Bytes"; + this.add256BytesToolStripMenuItem.Value = 256; + this.add256BytesToolStripMenuItem.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); + // + // add1024BytesToolStripMenuItem + // + this.add1024BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_1024; + this.add1024BytesToolStripMenuItem.Name = "add1024BytesToolStripMenuItem"; + this.add1024BytesToolStripMenuItem.Size = new System.Drawing.Size(154, 22); + this.add1024BytesToolStripMenuItem.Text = "Add 1024 Bytes"; + this.add1024BytesToolStripMenuItem.Value = 1024; + this.add1024BytesToolStripMenuItem.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); + // + // add2048BytesToolStripMenuItem + // + this.add2048BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_2048; + this.add2048BytesToolStripMenuItem.Name = "add2048BytesToolStripMenuItem"; + this.add2048BytesToolStripMenuItem.Size = new System.Drawing.Size(154, 22); + this.add2048BytesToolStripMenuItem.Text = "Add 2048 Bytes"; + this.add2048BytesToolStripMenuItem.Value = 2048; + this.add2048BytesToolStripMenuItem.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); + // + // add4096BytesToolStripMenuItem + // + this.add4096BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_4096; + this.add4096BytesToolStripMenuItem.Name = "add4096BytesToolStripMenuItem"; + this.add4096BytesToolStripMenuItem.Size = new System.Drawing.Size(154, 22); + this.add4096BytesToolStripMenuItem.Text = "Add 4096 Bytes"; + this.add4096BytesToolStripMenuItem.Value = 4096; + this.add4096BytesToolStripMenuItem.Click += new System.EventHandler(this.addBytesToolStripMenuItem_Click); + // + // addXBytesToolStripMenuItem + // + this.addXBytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Add_Bytes_X; + this.addXBytesToolStripMenuItem.Name = "addXBytesToolStripMenuItem"; + this.addXBytesToolStripMenuItem.Size = new System.Drawing.Size(154, 22); + this.addXBytesToolStripMenuItem.Text = "Add ... Bytes"; + this.addXBytesToolStripMenuItem.Click += new System.EventHandler(this.addXBytesToolStripMenuItem_Click); + // + // insertBytesToolStripDropDownButton + // + this.insertBytesToolStripDropDownButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.insertBytesToolStripDropDownButton.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { this.insert4BytesToolStripMenuItem, this.insert8BytesToolStripMenuItem, this.insert64BytesToolStripMenuItem, @@ -933,127 +933,127 @@ private void InitializeComponent() this.insert2048BytesToolStripMenuItem, this.insert4096BytesToolStripMenuItem, this.insertXBytesToolStripMenuItem}); - this.insertBytesToolStripDropDownButton.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_X; - this.insertBytesToolStripDropDownButton.ImageTransparentColor = System.Drawing.Color.Magenta; - this.insertBytesToolStripDropDownButton.Name = "insertBytesToolStripDropDownButton"; - this.insertBytesToolStripDropDownButton.Size = new System.Drawing.Size(29, 22); - this.insertBytesToolStripDropDownButton.ToolTipText = "Insert bytes at selected position"; - // - // insert4BytesToolStripMenuItem - // - this.insert4BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_4; - this.insert4BytesToolStripMenuItem.Name = "insert4BytesToolStripMenuItem"; - this.insert4BytesToolStripMenuItem.Size = new System.Drawing.Size(161, 22); - this.insert4BytesToolStripMenuItem.Tag = ""; - this.insert4BytesToolStripMenuItem.Text = "Insert 4 Bytes"; - this.insert4BytesToolStripMenuItem.Value = 4; - this.insert4BytesToolStripMenuItem.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); - // - // insert8BytesToolStripMenuItem - // - this.insert8BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_8; - this.insert8BytesToolStripMenuItem.Name = "insert8BytesToolStripMenuItem"; - this.insert8BytesToolStripMenuItem.Size = new System.Drawing.Size(161, 22); - this.insert8BytesToolStripMenuItem.Text = "Insert 8 Bytes"; - this.insert8BytesToolStripMenuItem.Value = 8; - this.insert8BytesToolStripMenuItem.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); - // - // insert64BytesToolStripMenuItem - // - this.insert64BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_64; - this.insert64BytesToolStripMenuItem.Name = "insert64BytesToolStripMenuItem"; - this.insert64BytesToolStripMenuItem.Size = new System.Drawing.Size(161, 22); - this.insert64BytesToolStripMenuItem.Text = "Insert 64 Bytes"; - this.insert64BytesToolStripMenuItem.Value = 64; - this.insert64BytesToolStripMenuItem.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); - // - // insert256BytesToolStripMenuItem - // - this.insert256BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_256; - this.insert256BytesToolStripMenuItem.Name = "insert256BytesToolStripMenuItem"; - this.insert256BytesToolStripMenuItem.Size = new System.Drawing.Size(161, 22); - this.insert256BytesToolStripMenuItem.Text = "Insert 256 Bytes"; - this.insert256BytesToolStripMenuItem.Value = 256; - this.insert256BytesToolStripMenuItem.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); - // - // insert1024BytesToolStripMenuItem - // - this.insert1024BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_1024; - this.insert1024BytesToolStripMenuItem.Name = "insert1024BytesToolStripMenuItem"; - this.insert1024BytesToolStripMenuItem.Size = new System.Drawing.Size(161, 22); - this.insert1024BytesToolStripMenuItem.Text = "Insert 1024 Bytes"; - this.insert1024BytesToolStripMenuItem.Value = 1024; - this.insert1024BytesToolStripMenuItem.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); - // - // insert2048BytesToolStripMenuItem - // - this.insert2048BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_2048; - this.insert2048BytesToolStripMenuItem.Name = "insert2048BytesToolStripMenuItem"; - this.insert2048BytesToolStripMenuItem.Size = new System.Drawing.Size(161, 22); - this.insert2048BytesToolStripMenuItem.Text = "Insert 2048 Bytes"; - this.insert2048BytesToolStripMenuItem.Value = 2048; - this.insert2048BytesToolStripMenuItem.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); - // - // insert4096BytesToolStripMenuItem - // - this.insert4096BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_4096; - this.insert4096BytesToolStripMenuItem.Name = "insert4096BytesToolStripMenuItem"; - this.insert4096BytesToolStripMenuItem.Size = new System.Drawing.Size(161, 22); - this.insert4096BytesToolStripMenuItem.Text = "Insert 4096 Bytes"; - this.insert4096BytesToolStripMenuItem.Value = 4096; - this.insert4096BytesToolStripMenuItem.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); - // - // insertXBytesToolStripMenuItem - // - this.insertXBytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_X; - this.insertXBytesToolStripMenuItem.Name = "insertXBytesToolStripMenuItem"; - this.insertXBytesToolStripMenuItem.Size = new System.Drawing.Size(161, 22); - this.insertXBytesToolStripMenuItem.Text = "Insert ... Bytes"; - this.insertXBytesToolStripMenuItem.Click += new System.EventHandler(this.insertXBytesToolStripMenuItem_Click); - // - // nodeTypesToolStripSeparator - // - this.nodeTypesToolStripSeparator.Name = "nodeTypesToolStripSeparator"; - this.nodeTypesToolStripSeparator.Size = new System.Drawing.Size(6, 25); - // - // statusStrip - // - this.statusStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.insertBytesToolStripDropDownButton.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_X; + this.insertBytesToolStripDropDownButton.ImageTransparentColor = System.Drawing.Color.Magenta; + this.insertBytesToolStripDropDownButton.Name = "insertBytesToolStripDropDownButton"; + this.insertBytesToolStripDropDownButton.Size = new System.Drawing.Size(29, 22); + this.insertBytesToolStripDropDownButton.ToolTipText = "Insert bytes at selected position"; + // + // insert4BytesToolStripMenuItem + // + this.insert4BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_4; + this.insert4BytesToolStripMenuItem.Name = "insert4BytesToolStripMenuItem"; + this.insert4BytesToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + this.insert4BytesToolStripMenuItem.Tag = ""; + this.insert4BytesToolStripMenuItem.Text = "Insert 4 Bytes"; + this.insert4BytesToolStripMenuItem.Value = 4; + this.insert4BytesToolStripMenuItem.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); + // + // insert8BytesToolStripMenuItem + // + this.insert8BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_8; + this.insert8BytesToolStripMenuItem.Name = "insert8BytesToolStripMenuItem"; + this.insert8BytesToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + this.insert8BytesToolStripMenuItem.Text = "Insert 8 Bytes"; + this.insert8BytesToolStripMenuItem.Value = 8; + this.insert8BytesToolStripMenuItem.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); + // + // insert64BytesToolStripMenuItem + // + this.insert64BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_64; + this.insert64BytesToolStripMenuItem.Name = "insert64BytesToolStripMenuItem"; + this.insert64BytesToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + this.insert64BytesToolStripMenuItem.Text = "Insert 64 Bytes"; + this.insert64BytesToolStripMenuItem.Value = 64; + this.insert64BytesToolStripMenuItem.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); + // + // insert256BytesToolStripMenuItem + // + this.insert256BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_256; + this.insert256BytesToolStripMenuItem.Name = "insert256BytesToolStripMenuItem"; + this.insert256BytesToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + this.insert256BytesToolStripMenuItem.Text = "Insert 256 Bytes"; + this.insert256BytesToolStripMenuItem.Value = 256; + this.insert256BytesToolStripMenuItem.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); + // + // insert1024BytesToolStripMenuItem + // + this.insert1024BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_1024; + this.insert1024BytesToolStripMenuItem.Name = "insert1024BytesToolStripMenuItem"; + this.insert1024BytesToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + this.insert1024BytesToolStripMenuItem.Text = "Insert 1024 Bytes"; + this.insert1024BytesToolStripMenuItem.Value = 1024; + this.insert1024BytesToolStripMenuItem.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); + // + // insert2048BytesToolStripMenuItem + // + this.insert2048BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_2048; + this.insert2048BytesToolStripMenuItem.Name = "insert2048BytesToolStripMenuItem"; + this.insert2048BytesToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + this.insert2048BytesToolStripMenuItem.Text = "Insert 2048 Bytes"; + this.insert2048BytesToolStripMenuItem.Value = 2048; + this.insert2048BytesToolStripMenuItem.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); + // + // insert4096BytesToolStripMenuItem + // + this.insert4096BytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_4096; + this.insert4096BytesToolStripMenuItem.Name = "insert4096BytesToolStripMenuItem"; + this.insert4096BytesToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + this.insert4096BytesToolStripMenuItem.Text = "Insert 4096 Bytes"; + this.insert4096BytesToolStripMenuItem.Value = 4096; + this.insert4096BytesToolStripMenuItem.Click += new System.EventHandler(this.insertBytesToolStripMenuItem_Click); + // + // insertXBytesToolStripMenuItem + // + this.insertXBytesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Insert_Bytes_X; + this.insertXBytesToolStripMenuItem.Name = "insertXBytesToolStripMenuItem"; + this.insertXBytesToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + this.insertXBytesToolStripMenuItem.Text = "Insert ... Bytes"; + this.insertXBytesToolStripMenuItem.Click += new System.EventHandler(this.insertXBytesToolStripMenuItem_Click); + // + // nodeTypesToolStripSeparator + // + this.nodeTypesToolStripSeparator.Name = "nodeTypesToolStripSeparator"; + this.nodeTypesToolStripSeparator.Size = new System.Drawing.Size(6, 25); + // + // statusStrip + // + this.statusStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { this.processInfoToolStripStatusLabel, this.infoToolStripStatusLabel}); - this.statusStrip.Location = new System.Drawing.Point(0, 573); - this.statusStrip.Name = "statusStrip"; - this.statusStrip.Size = new System.Drawing.Size(1141, 22); - this.statusStrip.TabIndex = 1; - // - // processInfoToolStripStatusLabel - // - this.processInfoToolStripStatusLabel.Name = "processInfoToolStripStatusLabel"; - this.processInfoToolStripStatusLabel.Size = new System.Drawing.Size(112, 17); - this.processInfoToolStripStatusLabel.Text = "No process selected"; - // - // infoToolStripStatusLabel - // - this.infoToolStripStatusLabel.Name = "infoToolStripStatusLabel"; - this.infoToolStripStatusLabel.Size = new System.Drawing.Size(23, 17); - this.infoToolStripStatusLabel.Text = "<>"; - this.infoToolStripStatusLabel.Visible = false; - // - // mainMenuStrip - // - this.mainMenuStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.statusStrip.Location = new System.Drawing.Point(0, 573); + this.statusStrip.Name = "statusStrip"; + this.statusStrip.Size = new System.Drawing.Size(1141, 22); + this.statusStrip.TabIndex = 1; + // + // processInfoToolStripStatusLabel + // + this.processInfoToolStripStatusLabel.Name = "processInfoToolStripStatusLabel"; + this.processInfoToolStripStatusLabel.Size = new System.Drawing.Size(112, 17); + this.processInfoToolStripStatusLabel.Text = "No process selected"; + // + // infoToolStripStatusLabel + // + this.infoToolStripStatusLabel.Name = "infoToolStripStatusLabel"; + this.infoToolStripStatusLabel.Size = new System.Drawing.Size(23, 17); + this.infoToolStripStatusLabel.Text = "<>"; + this.infoToolStripStatusLabel.Visible = false; + // + // mainMenuStrip + // + this.mainMenuStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { this.fileToolStripMenuItem, this.processToolStripMenuItem, this.projectToolStripMenuItem, this.helpToolStripMenuItem}); - this.mainMenuStrip.Location = new System.Drawing.Point(0, 0); - this.mainMenuStrip.Name = "mainMenuStrip"; - this.mainMenuStrip.Size = new System.Drawing.Size(1141, 24); - this.mainMenuStrip.TabIndex = 2; - // - // fileToolStripMenuItem - // - this.fileToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.mainMenuStrip.Location = new System.Drawing.Point(0, 0); + this.mainMenuStrip.Name = "mainMenuStrip"; + this.mainMenuStrip.Size = new System.Drawing.Size(1141, 24); + this.mainMenuStrip.TabIndex = 2; + // + // fileToolStripMenuItem + // + this.fileToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { this.attachToProcessToolStripMenuItem, this.reattachToProcessToolStripMenuItem, this.detachToolStripMenuItem, @@ -1069,126 +1069,126 @@ private void InitializeComponent() this.pluginsToolStripMenuItem, this.toolStripSeparator5, this.quitToolStripMenuItem}); - this.fileToolStripMenuItem.Name = "fileToolStripMenuItem"; - this.fileToolStripMenuItem.Size = new System.Drawing.Size(37, 20); - this.fileToolStripMenuItem.Text = "File"; - this.fileToolStripMenuItem.DropDownOpening += new System.EventHandler(this.fileToolStripMenuItem_DropDownOpening); - // - // attachToProcessToolStripMenuItem - // - this.attachToProcessToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Magnifier; - this.attachToProcessToolStripMenuItem.Name = "attachToProcessToolStripMenuItem"; - this.attachToProcessToolStripMenuItem.Size = new System.Drawing.Size(195, 22); - this.attachToProcessToolStripMenuItem.Text = "Attach to Process..."; - this.attachToProcessToolStripMenuItem.Click += new System.EventHandler(this.attachToProcessToolStripSplitButton_ButtonClick); - // - // reattachToProcessToolStripMenuItem - // - this.reattachToProcessToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Magnifier_Arrow; - this.reattachToProcessToolStripMenuItem.Name = "reattachToProcessToolStripMenuItem"; - this.reattachToProcessToolStripMenuItem.Size = new System.Drawing.Size(195, 22); - this.reattachToProcessToolStripMenuItem.Text = "<>"; - this.reattachToProcessToolStripMenuItem.Click += new System.EventHandler(this.reattachToProcessToolStripMenuItem_Click); - // - // detachToolStripMenuItem - // - this.detachToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Magnifier_Remove; - this.detachToolStripMenuItem.Name = "detachToolStripMenuItem"; - this.detachToolStripMenuItem.Size = new System.Drawing.Size(195, 22); - this.detachToolStripMenuItem.Text = "Detach"; - this.detachToolStripMenuItem.Click += new System.EventHandler(this.detachToolStripMenuItem_Click); - // - // toolStripSeparator1 - // - this.toolStripSeparator1.Name = "toolStripSeparator1"; - this.toolStripSeparator1.Size = new System.Drawing.Size(192, 6); - // - // openProjectToolStripMenuItem - // - this.openProjectToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Folder; - this.openProjectToolStripMenuItem.Name = "openProjectToolStripMenuItem"; - this.openProjectToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.O))); - this.openProjectToolStripMenuItem.Size = new System.Drawing.Size(195, 22); - this.openProjectToolStripMenuItem.Text = "Open Project..."; - this.openProjectToolStripMenuItem.Click += new System.EventHandler(this.openProjectToolStripMenuItem_Click); - // - // mergeWithProjectToolStripMenuItem - // - this.mergeWithProjectToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Folder_Add; - this.mergeWithProjectToolStripMenuItem.Name = "mergeWithProjectToolStripMenuItem"; - this.mergeWithProjectToolStripMenuItem.Size = new System.Drawing.Size(195, 22); - this.mergeWithProjectToolStripMenuItem.Text = "Merge with Project..."; - this.mergeWithProjectToolStripMenuItem.Click += new System.EventHandler(this.mergeWithProjectToolStripMenuItem_Click); - // - // clearProjectToolStripMenuItem - // - this.clearProjectToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Arrow_Refresh; - this.clearProjectToolStripMenuItem.Name = "clearProjectToolStripMenuItem"; - this.clearProjectToolStripMenuItem.Size = new System.Drawing.Size(195, 22); - this.clearProjectToolStripMenuItem.Text = "Clear Project"; - this.clearProjectToolStripMenuItem.Click += new System.EventHandler(this.clearProjectToolStripMenuItem_Click); - // - // toolStripSeparator2 - // - this.toolStripSeparator2.Name = "toolStripSeparator2"; - this.toolStripSeparator2.Size = new System.Drawing.Size(192, 6); - // - // saveToolStripMenuItem - // - this.saveToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Save; - this.saveToolStripMenuItem.Name = "saveToolStripMenuItem"; - this.saveToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.S))); - this.saveToolStripMenuItem.Size = new System.Drawing.Size(195, 22); - this.saveToolStripMenuItem.Text = "Save"; - this.saveToolStripMenuItem.Click += new System.EventHandler(this.saveToolStripMenuItem_Click); - // - // saveAsToolStripMenuItem - // - this.saveAsToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Save_As; - this.saveAsToolStripMenuItem.Name = "saveAsToolStripMenuItem"; - this.saveAsToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)(((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.Shift) + this.fileToolStripMenuItem.Name = "fileToolStripMenuItem"; + this.fileToolStripMenuItem.Size = new System.Drawing.Size(37, 20); + this.fileToolStripMenuItem.Text = "File"; + this.fileToolStripMenuItem.DropDownOpening += new System.EventHandler(this.fileToolStripMenuItem_DropDownOpening); + // + // attachToProcessToolStripMenuItem + // + this.attachToProcessToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Magnifier; + this.attachToProcessToolStripMenuItem.Name = "attachToProcessToolStripMenuItem"; + this.attachToProcessToolStripMenuItem.Size = new System.Drawing.Size(195, 22); + this.attachToProcessToolStripMenuItem.Text = "Attach to Process..."; + this.attachToProcessToolStripMenuItem.Click += new System.EventHandler(this.attachToProcessToolStripSplitButton_ButtonClick); + // + // reattachToProcessToolStripMenuItem + // + this.reattachToProcessToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Magnifier_Arrow; + this.reattachToProcessToolStripMenuItem.Name = "reattachToProcessToolStripMenuItem"; + this.reattachToProcessToolStripMenuItem.Size = new System.Drawing.Size(195, 22); + this.reattachToProcessToolStripMenuItem.Text = "<>"; + this.reattachToProcessToolStripMenuItem.Click += new System.EventHandler(this.reattachToProcessToolStripMenuItem_Click); + // + // detachToolStripMenuItem + // + this.detachToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Magnifier_Remove; + this.detachToolStripMenuItem.Name = "detachToolStripMenuItem"; + this.detachToolStripMenuItem.Size = new System.Drawing.Size(195, 22); + this.detachToolStripMenuItem.Text = "Detach"; + this.detachToolStripMenuItem.Click += new System.EventHandler(this.detachToolStripMenuItem_Click); + // + // toolStripSeparator1 + // + this.toolStripSeparator1.Name = "toolStripSeparator1"; + this.toolStripSeparator1.Size = new System.Drawing.Size(192, 6); + // + // openProjectToolStripMenuItem + // + this.openProjectToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Folder; + this.openProjectToolStripMenuItem.Name = "openProjectToolStripMenuItem"; + this.openProjectToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.O))); + this.openProjectToolStripMenuItem.Size = new System.Drawing.Size(195, 22); + this.openProjectToolStripMenuItem.Text = "Open Project..."; + this.openProjectToolStripMenuItem.Click += new System.EventHandler(this.openProjectToolStripMenuItem_Click); + // + // mergeWithProjectToolStripMenuItem + // + this.mergeWithProjectToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Folder_Add; + this.mergeWithProjectToolStripMenuItem.Name = "mergeWithProjectToolStripMenuItem"; + this.mergeWithProjectToolStripMenuItem.Size = new System.Drawing.Size(195, 22); + this.mergeWithProjectToolStripMenuItem.Text = "Merge with Project..."; + this.mergeWithProjectToolStripMenuItem.Click += new System.EventHandler(this.mergeWithProjectToolStripMenuItem_Click); + // + // clearProjectToolStripMenuItem + // + this.clearProjectToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Arrow_Refresh; + this.clearProjectToolStripMenuItem.Name = "clearProjectToolStripMenuItem"; + this.clearProjectToolStripMenuItem.Size = new System.Drawing.Size(195, 22); + this.clearProjectToolStripMenuItem.Text = "Clear Project"; + this.clearProjectToolStripMenuItem.Click += new System.EventHandler(this.clearProjectToolStripMenuItem_Click); + // + // toolStripSeparator2 + // + this.toolStripSeparator2.Name = "toolStripSeparator2"; + this.toolStripSeparator2.Size = new System.Drawing.Size(192, 6); + // + // saveToolStripMenuItem + // + this.saveToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Save; + this.saveToolStripMenuItem.Name = "saveToolStripMenuItem"; + this.saveToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.S))); + this.saveToolStripMenuItem.Size = new System.Drawing.Size(195, 22); + this.saveToolStripMenuItem.Text = "Save"; + this.saveToolStripMenuItem.Click += new System.EventHandler(this.saveToolStripMenuItem_Click); + // + // saveAsToolStripMenuItem + // + this.saveAsToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Save_As; + this.saveAsToolStripMenuItem.Name = "saveAsToolStripMenuItem"; + this.saveAsToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)(((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.Shift) | System.Windows.Forms.Keys.S))); - this.saveAsToolStripMenuItem.Size = new System.Drawing.Size(195, 22); - this.saveAsToolStripMenuItem.Text = "Save as..."; - this.saveAsToolStripMenuItem.Click += new System.EventHandler(this.saveAsToolStripMenuItem_Click); - // - // toolStripSeparator3 - // - this.toolStripSeparator3.Name = "toolStripSeparator3"; - this.toolStripSeparator3.Size = new System.Drawing.Size(192, 6); - // - // settingsToolStripMenuItem - // - this.settingsToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Cogs; - this.settingsToolStripMenuItem.Name = "settingsToolStripMenuItem"; - this.settingsToolStripMenuItem.Size = new System.Drawing.Size(195, 22); - this.settingsToolStripMenuItem.Text = "Settings..."; - this.settingsToolStripMenuItem.Click += new System.EventHandler(this.settingsToolStripMenuItem_Click); - // - // pluginsToolStripMenuItem - // - this.pluginsToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Plugin; - this.pluginsToolStripMenuItem.Name = "pluginsToolStripMenuItem"; - this.pluginsToolStripMenuItem.Size = new System.Drawing.Size(195, 22); - this.pluginsToolStripMenuItem.Text = "Plugins..."; - this.pluginsToolStripMenuItem.Click += new System.EventHandler(this.pluginsToolStripButton_Click); - // - // toolStripSeparator5 - // - this.toolStripSeparator5.Name = "toolStripSeparator5"; - this.toolStripSeparator5.Size = new System.Drawing.Size(192, 6); - // - // quitToolStripMenuItem - // - this.quitToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Quit; - this.quitToolStripMenuItem.Name = "quitToolStripMenuItem"; - this.quitToolStripMenuItem.Size = new System.Drawing.Size(195, 22); - this.quitToolStripMenuItem.Text = "Quit"; - this.quitToolStripMenuItem.Click += new System.EventHandler(this.quitToolStripMenuItem_Click); - // - // processToolStripMenuItem - // - this.processToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.saveAsToolStripMenuItem.Size = new System.Drawing.Size(195, 22); + this.saveAsToolStripMenuItem.Text = "Save as..."; + this.saveAsToolStripMenuItem.Click += new System.EventHandler(this.saveAsToolStripMenuItem_Click); + // + // toolStripSeparator3 + // + this.toolStripSeparator3.Name = "toolStripSeparator3"; + this.toolStripSeparator3.Size = new System.Drawing.Size(192, 6); + // + // settingsToolStripMenuItem + // + this.settingsToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Cogs; + this.settingsToolStripMenuItem.Name = "settingsToolStripMenuItem"; + this.settingsToolStripMenuItem.Size = new System.Drawing.Size(195, 22); + this.settingsToolStripMenuItem.Text = "Settings..."; + this.settingsToolStripMenuItem.Click += new System.EventHandler(this.settingsToolStripMenuItem_Click); + // + // pluginsToolStripMenuItem + // + this.pluginsToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Plugin; + this.pluginsToolStripMenuItem.Name = "pluginsToolStripMenuItem"; + this.pluginsToolStripMenuItem.Size = new System.Drawing.Size(195, 22); + this.pluginsToolStripMenuItem.Text = "Plugins..."; + this.pluginsToolStripMenuItem.Click += new System.EventHandler(this.pluginsToolStripButton_Click); + // + // toolStripSeparator5 + // + this.toolStripSeparator5.Name = "toolStripSeparator5"; + this.toolStripSeparator5.Size = new System.Drawing.Size(192, 6); + // + // quitToolStripMenuItem + // + this.quitToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Quit; + this.quitToolStripMenuItem.Name = "quitToolStripMenuItem"; + this.quitToolStripMenuItem.Size = new System.Drawing.Size(195, 22); + this.quitToolStripMenuItem.Text = "Quit"; + this.quitToolStripMenuItem.Click += new System.EventHandler(this.quitToolStripMenuItem_Click); + // + // processToolStripMenuItem + // + this.processToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { this.processInformationsToolStripMenuItem, this.memorySearcherToolStripMenuItem, this.namedAddressesToolStripMenuItem, @@ -1201,206 +1201,207 @@ private void InitializeComponent() this.resumeProcessToolStripMenuItem, this.suspendProcessToolStripMenuItem, this.terminateProcessToolStripMenuItem}); - this.processToolStripMenuItem.Name = "processToolStripMenuItem"; - this.processToolStripMenuItem.Size = new System.Drawing.Size(59, 20); - this.processToolStripMenuItem.Text = "Process"; - // - // processInformationsToolStripMenuItem - // - this.processInformationsToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Category; - this.processInformationsToolStripMenuItem.Name = "processInformationsToolStripMenuItem"; - this.processInformationsToolStripMenuItem.Size = new System.Drawing.Size(194, 22); - this.processInformationsToolStripMenuItem.Text = "Process Informations..."; - this.processInformationsToolStripMenuItem.Click += new System.EventHandler(this.memoryViewerToolStripMenuItem_Click); - // - // memorySearcherToolStripMenuItem - // - this.memorySearcherToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Eye; - this.memorySearcherToolStripMenuItem.Name = "memorySearcherToolStripMenuItem"; - this.memorySearcherToolStripMenuItem.Size = new System.Drawing.Size(194, 22); - this.memorySearcherToolStripMenuItem.Text = "Memory Searcher..."; - this.memorySearcherToolStripMenuItem.Click += new System.EventHandler(this.memorySearcherToolStripMenuItem_Click); - // - // namedAddressesToolStripMenuItem - // - this.namedAddressesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Custom_Type; - this.namedAddressesToolStripMenuItem.Name = "namedAddressesToolStripMenuItem"; - this.namedAddressesToolStripMenuItem.Size = new System.Drawing.Size(194, 22); - this.namedAddressesToolStripMenuItem.Text = "Named Addresses..."; - this.namedAddressesToolStripMenuItem.Click += new System.EventHandler(this.namedAddressesToolStripMenuItem_Click); - // - // toolStripSeparator23 - // - this.toolStripSeparator23.Name = "toolStripSeparator23"; - this.toolStripSeparator23.Size = new System.Drawing.Size(191, 6); - // - // isLittleEndianToolStripMenuItem - // - this.isLittleEndianToolStripMenuItem.CheckOnClick = true; - this.isLittleEndianToolStripMenuItem.Name = "isLittleEndianToolStripMenuItem"; - this.isLittleEndianToolStripMenuItem.Size = new System.Drawing.Size(194, 22); - this.isLittleEndianToolStripMenuItem.Text = "Is Little Endian"; - this.isLittleEndianToolStripMenuItem.Click += new System.EventHandler(this.isLittleEndianToolStripMenuItem_Click); - // - // toolStripSeparator17 - // - this.toolStripSeparator17.Name = "toolStripSeparator17"; - this.toolStripSeparator17.Size = new System.Drawing.Size(191, 6); - // - // loadSymbolToolStripMenuItem - // - this.loadSymbolToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Pdb; - this.loadSymbolToolStripMenuItem.Name = "loadSymbolToolStripMenuItem"; - this.loadSymbolToolStripMenuItem.Size = new System.Drawing.Size(194, 22); - this.loadSymbolToolStripMenuItem.Text = "Load Symbol..."; - this.loadSymbolToolStripMenuItem.Click += new System.EventHandler(this.loadSymbolToolStripMenuItem_Click); - // - // loadSymbolsToolStripMenuItem - // - this.loadSymbolsToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("loadSymbolsToolStripMenuItem.Image"))); - this.loadSymbolsToolStripMenuItem.Name = "loadSymbolsToolStripMenuItem"; - this.loadSymbolsToolStripMenuItem.Size = new System.Drawing.Size(194, 22); - this.loadSymbolsToolStripMenuItem.Text = "Load all Symbols"; - this.loadSymbolsToolStripMenuItem.Click += new System.EventHandler(this.loadSymbolsToolStripMenuItem_Click); - // - // toolStripSeparator4 - // - this.toolStripSeparator4.Name = "toolStripSeparator4"; - this.toolStripSeparator4.Size = new System.Drawing.Size(191, 6); - // - // resumeProcessToolStripMenuItem - // - this.resumeProcessToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Control_Play; - this.resumeProcessToolStripMenuItem.Name = "resumeProcessToolStripMenuItem"; - this.resumeProcessToolStripMenuItem.Size = new System.Drawing.Size(194, 22); - this.resumeProcessToolStripMenuItem.Text = "Resume"; - this.resumeProcessToolStripMenuItem.Click += new System.EventHandler(this.ControlRemoteProcessToolStripMenuItem_Click); - // - // suspendProcessToolStripMenuItem - // - this.suspendProcessToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Control_Pause; - this.suspendProcessToolStripMenuItem.Name = "suspendProcessToolStripMenuItem"; - this.suspendProcessToolStripMenuItem.Size = new System.Drawing.Size(194, 22); - this.suspendProcessToolStripMenuItem.Text = "Suspend"; - this.suspendProcessToolStripMenuItem.Click += new System.EventHandler(this.ControlRemoteProcessToolStripMenuItem_Click); - // - // terminateProcessToolStripMenuItem - // - this.terminateProcessToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Control_Stop; - this.terminateProcessToolStripMenuItem.Name = "terminateProcessToolStripMenuItem"; - this.terminateProcessToolStripMenuItem.Size = new System.Drawing.Size(194, 22); - this.terminateProcessToolStripMenuItem.Text = "Kill"; - this.terminateProcessToolStripMenuItem.Click += new System.EventHandler(this.ControlRemoteProcessToolStripMenuItem_Click); - // - // projectToolStripMenuItem - // - this.projectToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.processToolStripMenuItem.Name = "processToolStripMenuItem"; + this.processToolStripMenuItem.Size = new System.Drawing.Size(59, 20); + this.processToolStripMenuItem.Text = "Process"; + // + // processInformationsToolStripMenuItem + // + this.processInformationsToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Category; + this.processInformationsToolStripMenuItem.Name = "processInformationsToolStripMenuItem"; + this.processInformationsToolStripMenuItem.Size = new System.Drawing.Size(194, 22); + this.processInformationsToolStripMenuItem.Text = "Process Informations..."; + this.processInformationsToolStripMenuItem.Click += new System.EventHandler(this.memoryViewerToolStripMenuItem_Click); + // + // memorySearcherToolStripMenuItem + // + this.memorySearcherToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Eye; + this.memorySearcherToolStripMenuItem.Name = "memorySearcherToolStripMenuItem"; + this.memorySearcherToolStripMenuItem.Size = new System.Drawing.Size(194, 22); + this.memorySearcherToolStripMenuItem.Text = "Memory Searcher..."; + this.memorySearcherToolStripMenuItem.Click += new System.EventHandler(this.memorySearcherToolStripMenuItem_Click); + // + // namedAddressesToolStripMenuItem + // + this.namedAddressesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Custom_Type; + this.namedAddressesToolStripMenuItem.Name = "namedAddressesToolStripMenuItem"; + this.namedAddressesToolStripMenuItem.Size = new System.Drawing.Size(194, 22); + this.namedAddressesToolStripMenuItem.Text = "Named Addresses..."; + this.namedAddressesToolStripMenuItem.Click += new System.EventHandler(this.namedAddressesToolStripMenuItem_Click); + // + // toolStripSeparator23 + // + this.toolStripSeparator23.Name = "toolStripSeparator23"; + this.toolStripSeparator23.Size = new System.Drawing.Size(191, 6); + // + // isLittleEndianToolStripMenuItem + // + this.isLittleEndianToolStripMenuItem.CheckOnClick = true; + this.isLittleEndianToolStripMenuItem.Name = "isLittleEndianToolStripMenuItem"; + this.isLittleEndianToolStripMenuItem.Size = new System.Drawing.Size(194, 22); + this.isLittleEndianToolStripMenuItem.Text = "Is Little Endian"; + this.isLittleEndianToolStripMenuItem.Click += new System.EventHandler(this.isLittleEndianToolStripMenuItem_Click); + // + // toolStripSeparator17 + // + this.toolStripSeparator17.Name = "toolStripSeparator17"; + this.toolStripSeparator17.Size = new System.Drawing.Size(191, 6); + // + // loadSymbolToolStripMenuItem + // + this.loadSymbolToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Pdb; + this.loadSymbolToolStripMenuItem.Name = "loadSymbolToolStripMenuItem"; + this.loadSymbolToolStripMenuItem.Size = new System.Drawing.Size(194, 22); + this.loadSymbolToolStripMenuItem.Text = "Load Symbol..."; + this.loadSymbolToolStripMenuItem.Click += new System.EventHandler(this.loadSymbolToolStripMenuItem_Click); + // + // loadSymbolsToolStripMenuItem + // + this.loadSymbolsToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("loadSymbolsToolStripMenuItem.Image"))); + this.loadSymbolsToolStripMenuItem.Name = "loadSymbolsToolStripMenuItem"; + this.loadSymbolsToolStripMenuItem.Size = new System.Drawing.Size(194, 22); + this.loadSymbolsToolStripMenuItem.Text = "Load all Symbols"; + this.loadSymbolsToolStripMenuItem.Click += new System.EventHandler(this.loadSymbolsToolStripMenuItem_Click); + // + // toolStripSeparator4 + // + this.toolStripSeparator4.Name = "toolStripSeparator4"; + this.toolStripSeparator4.Size = new System.Drawing.Size(191, 6); + // + // resumeProcessToolStripMenuItem + // + this.resumeProcessToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Control_Play; + this.resumeProcessToolStripMenuItem.Name = "resumeProcessToolStripMenuItem"; + this.resumeProcessToolStripMenuItem.Size = new System.Drawing.Size(194, 22); + this.resumeProcessToolStripMenuItem.Text = "Resume"; + this.resumeProcessToolStripMenuItem.Click += new System.EventHandler(this.ControlRemoteProcessToolStripMenuItem_Click); + // + // suspendProcessToolStripMenuItem + // + this.suspendProcessToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Control_Pause; + this.suspendProcessToolStripMenuItem.Name = "suspendProcessToolStripMenuItem"; + this.suspendProcessToolStripMenuItem.Size = new System.Drawing.Size(194, 22); + this.suspendProcessToolStripMenuItem.Text = "Suspend"; + this.suspendProcessToolStripMenuItem.Click += new System.EventHandler(this.ControlRemoteProcessToolStripMenuItem_Click); + // + // terminateProcessToolStripMenuItem + // + this.terminateProcessToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Control_Stop; + this.terminateProcessToolStripMenuItem.Name = "terminateProcessToolStripMenuItem"; + this.terminateProcessToolStripMenuItem.Size = new System.Drawing.Size(194, 22); + this.terminateProcessToolStripMenuItem.Text = "Kill"; + this.terminateProcessToolStripMenuItem.Click += new System.EventHandler(this.ControlRemoteProcessToolStripMenuItem_Click); + // + // projectToolStripMenuItem + // + this.projectToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { this.goToClassToolStripMenuItem, this.cleanUnusedClassesToolStripMenuItem, this.showEnumsToolStripMenuItem, this.toolStripSeparator16, this.generateCppCodeToolStripMenuItem, this.generateCSharpCodeToolStripMenuItem}); - this.projectToolStripMenuItem.Name = "projectToolStripMenuItem"; - this.projectToolStripMenuItem.Size = new System.Drawing.Size(56, 20); - this.projectToolStripMenuItem.Text = "Project"; - // - // goToClassToolStripMenuItem - // - this.goToClassToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Class_Type; - this.goToClassToolStripMenuItem.Name = "goToClassToolStripMenuItem"; - this.goToClassToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.F))); - this.goToClassToolStripMenuItem.Size = new System.Drawing.Size(198, 22); - this.goToClassToolStripMenuItem.Text = "Go to class..."; - this.goToClassToolStripMenuItem.Click += new System.EventHandler(this.goToClassToolStripMenuItem_Click); - // - // cleanUnusedClassesToolStripMenuItem - // - this.cleanUnusedClassesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Chart_Delete; - this.cleanUnusedClassesToolStripMenuItem.Name = "cleanUnusedClassesToolStripMenuItem"; - this.cleanUnusedClassesToolStripMenuItem.Size = new System.Drawing.Size(198, 22); - this.cleanUnusedClassesToolStripMenuItem.Text = "Remove unused classes"; - this.cleanUnusedClassesToolStripMenuItem.Click += new System.EventHandler(this.cleanUnusedClassesToolStripMenuItem_Click); - // - // showEnumsToolStripMenuItem - // - this.showEnumsToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Category; - this.showEnumsToolStripMenuItem.Name = "showEnumsToolStripMenuItem"; - this.showEnumsToolStripMenuItem.Size = new System.Drawing.Size(198, 22); - this.showEnumsToolStripMenuItem.Text = "Show Enums..."; - this.showEnumsToolStripMenuItem.Click += new System.EventHandler(this.showEnumsToolStripMenuItem_Click); - // - // toolStripSeparator16 - // - this.toolStripSeparator16.Name = "toolStripSeparator16"; - this.toolStripSeparator16.Size = new System.Drawing.Size(195, 6); - // - // generateCppCodeToolStripMenuItem - // - this.generateCppCodeToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Page_Code_Cpp; - this.generateCppCodeToolStripMenuItem.Name = "generateCppCodeToolStripMenuItem"; - this.generateCppCodeToolStripMenuItem.Size = new System.Drawing.Size(198, 22); - this.generateCppCodeToolStripMenuItem.Text = "Generate C++ Code..."; - this.generateCppCodeToolStripMenuItem.Click += new System.EventHandler(this.generateCppCodeToolStripMenuItem_Click); - // - // generateCSharpCodeToolStripMenuItem - // - this.generateCSharpCodeToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Page_Code_Csharp; - this.generateCSharpCodeToolStripMenuItem.Name = "generateCSharpCodeToolStripMenuItem"; - this.generateCSharpCodeToolStripMenuItem.Size = new System.Drawing.Size(198, 22); - this.generateCSharpCodeToolStripMenuItem.Text = "Generate C# Code..."; - this.generateCSharpCodeToolStripMenuItem.Click += new System.EventHandler(this.generateCSharpCodeToolStripMenuItem_Click); - // - // helpToolStripMenuItem - // - this.helpToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.projectToolStripMenuItem.Name = "projectToolStripMenuItem"; + this.projectToolStripMenuItem.Size = new System.Drawing.Size(56, 20); + this.projectToolStripMenuItem.Text = "Project"; + // + // goToClassToolStripMenuItem + // + this.goToClassToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Class_Type; + this.goToClassToolStripMenuItem.Name = "goToClassToolStripMenuItem"; + this.goToClassToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.F))); + this.goToClassToolStripMenuItem.Size = new System.Drawing.Size(198, 22); + this.goToClassToolStripMenuItem.Text = "Go to class..."; + this.goToClassToolStripMenuItem.Click += new System.EventHandler(this.goToClassToolStripMenuItem_Click); + // + // cleanUnusedClassesToolStripMenuItem + // + this.cleanUnusedClassesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Chart_Delete; + this.cleanUnusedClassesToolStripMenuItem.Name = "cleanUnusedClassesToolStripMenuItem"; + this.cleanUnusedClassesToolStripMenuItem.Size = new System.Drawing.Size(198, 22); + this.cleanUnusedClassesToolStripMenuItem.Text = "Remove unused classes"; + this.cleanUnusedClassesToolStripMenuItem.Click += new System.EventHandler(this.cleanUnusedClassesToolStripMenuItem_Click); + // + // showEnumsToolStripMenuItem + // + this.showEnumsToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Category; + this.showEnumsToolStripMenuItem.Name = "showEnumsToolStripMenuItem"; + this.showEnumsToolStripMenuItem.Size = new System.Drawing.Size(198, 22); + this.showEnumsToolStripMenuItem.Text = "Show Enums..."; + this.showEnumsToolStripMenuItem.Click += new System.EventHandler(this.showEnumsToolStripMenuItem_Click); + // + // toolStripSeparator16 + // + this.toolStripSeparator16.Name = "toolStripSeparator16"; + this.toolStripSeparator16.Size = new System.Drawing.Size(195, 6); + // + // generateCppCodeToolStripMenuItem + // + this.generateCppCodeToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Page_Code_Cpp; + this.generateCppCodeToolStripMenuItem.Name = "generateCppCodeToolStripMenuItem"; + this.generateCppCodeToolStripMenuItem.Size = new System.Drawing.Size(198, 22); + this.generateCppCodeToolStripMenuItem.Text = "Generate C++ Code..."; + this.generateCppCodeToolStripMenuItem.Click += new System.EventHandler(this.generateCppCodeToolStripMenuItem_Click); + // + // generateCSharpCodeToolStripMenuItem + // + this.generateCSharpCodeToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Page_Code_Csharp; + this.generateCSharpCodeToolStripMenuItem.Name = "generateCSharpCodeToolStripMenuItem"; + this.generateCSharpCodeToolStripMenuItem.Size = new System.Drawing.Size(198, 22); + this.generateCSharpCodeToolStripMenuItem.Text = "Generate C# Code..."; + this.generateCSharpCodeToolStripMenuItem.Click += new System.EventHandler(this.generateCSharpCodeToolStripMenuItem_Click); + // + // helpToolStripMenuItem + // + this.helpToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { this.aboutToolStripMenuItem}); - this.helpToolStripMenuItem.Name = "helpToolStripMenuItem"; - this.helpToolStripMenuItem.Size = new System.Drawing.Size(44, 20); - this.helpToolStripMenuItem.Text = "Help"; - // - // aboutToolStripMenuItem - // - this.aboutToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Information; - this.aboutToolStripMenuItem.Name = "aboutToolStripMenuItem"; - this.aboutToolStripMenuItem.Size = new System.Drawing.Size(116, 22); - this.aboutToolStripMenuItem.Text = "About..."; - this.aboutToolStripMenuItem.Click += new System.EventHandler(this.aboutToolStripMenuItem_Click); - // - // MainForm - // - this.AllowDrop = true; - this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); - this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; - this.ClientSize = new System.Drawing.Size(1141, 595); - this.Controls.Add(this.splitContainer); - this.Controls.Add(this.toolStrip); - this.Controls.Add(this.statusStrip); - this.Controls.Add(this.mainMenuStrip); - this.MainMenuStrip = this.mainMenuStrip; - this.MinimumSize = new System.Drawing.Size(200, 100); - this.Name = "MainForm"; - this.Text = "ReClass.NET"; - this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.MainForm_FormClosing); - this.DragDrop += new System.Windows.Forms.DragEventHandler(this.MainForm_DragDrop); - this.DragEnter += new System.Windows.Forms.DragEventHandler(this.MainForm_DragEnter); - this.splitContainer.Panel1.ResumeLayout(false); - this.splitContainer.Panel2.ResumeLayout(false); - ((System.ComponentModel.ISupportInitialize)(this.splitContainer)).EndInit(); - this.splitContainer.ResumeLayout(false); - this.projectClassContextMenuStrip.ResumeLayout(false); - this.projectClassesContextMenuStrip.ResumeLayout(false); - this.projectEnumContextMenuStrip.ResumeLayout(false); - this.projectEnumsContextMenuStrip.ResumeLayout(false); - this.selectedNodeContextMenuStrip.ResumeLayout(false); - this.toolStrip.ResumeLayout(false); - this.toolStrip.PerformLayout(); - this.statusStrip.ResumeLayout(false); - this.statusStrip.PerformLayout(); - this.mainMenuStrip.ResumeLayout(false); - this.mainMenuStrip.PerformLayout(); - this.ResumeLayout(false); - this.PerformLayout(); + this.helpToolStripMenuItem.Name = "helpToolStripMenuItem"; + this.helpToolStripMenuItem.Size = new System.Drawing.Size(44, 20); + this.helpToolStripMenuItem.Text = "Help"; + // + // aboutToolStripMenuItem + // + this.aboutToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Information; + this.aboutToolStripMenuItem.Name = "aboutToolStripMenuItem"; + this.aboutToolStripMenuItem.Size = new System.Drawing.Size(116, 22); + this.aboutToolStripMenuItem.Text = "About..."; + this.aboutToolStripMenuItem.Click += new System.EventHandler(this.aboutToolStripMenuItem_Click); + // + // MainForm + // + this.AllowDrop = true; + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(1141, 595); + this.Controls.Add(this.splitContainer); + this.Controls.Add(this.toolStrip); + this.Controls.Add(this.statusStrip); + this.Controls.Add(this.mainMenuStrip); + this.MainMenuStrip = this.mainMenuStrip; + this.MinimumSize = new System.Drawing.Size(200, 100); + this.Name = "MainForm"; + this.Text = "ReClass.NET"; + this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.MainForm_FormClosing); + this.Load += new System.EventHandler(this.MainForm_Load); + this.DragDrop += new System.Windows.Forms.DragEventHandler(this.MainForm_DragDrop); + this.DragEnter += new System.Windows.Forms.DragEventHandler(this.MainForm_DragEnter); + this.splitContainer.Panel1.ResumeLayout(false); + this.splitContainer.Panel2.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)(this.splitContainer)).EndInit(); + this.splitContainer.ResumeLayout(false); + this.projectClassContextMenuStrip.ResumeLayout(false); + this.projectClassesContextMenuStrip.ResumeLayout(false); + this.projectEnumContextMenuStrip.ResumeLayout(false); + this.projectEnumsContextMenuStrip.ResumeLayout(false); + this.selectedNodeContextMenuStrip.ResumeLayout(false); + this.toolStrip.ResumeLayout(false); + this.toolStrip.PerformLayout(); + this.statusStrip.ResumeLayout(false); + this.statusStrip.PerformLayout(); + this.mainMenuStrip.ResumeLayout(false); + this.mainMenuStrip.PerformLayout(); + this.ResumeLayout(false); + this.PerformLayout(); } diff --git a/ReClass.NET/Forms/MainForm.cs b/ReClass.NET/Forms/MainForm.cs index 010eea25..cfd1bcea 100644 --- a/ReClass.NET/Forms/MainForm.cs +++ b/ReClass.NET/Forms/MainForm.cs @@ -440,7 +440,7 @@ private void attachToProcessToolStripSplitButton_ButtonClick(object sender, Even { AttachToProcess(pb.SelectedProcess); - if (pb.LoadSymbols) + if (pb.LoadSymbols && !pb.networkingForm.mConnected) //TODO, Load Server Symbols { LoadAllSymbolsForCurrentProcess(); } @@ -1049,5 +1049,10 @@ private void memoryViewControl_DrawContextRequested(object sender, DrawContextRe args.BaseAddress = address; } } + + private void MainForm_Load(object sender, EventArgs e) + { + + } } } diff --git a/ReClass.NET/Forms/NetworkingForm.Designer.cs b/ReClass.NET/Forms/NetworkingForm.Designer.cs new file mode 100644 index 00000000..a4486389 --- /dev/null +++ b/ReClass.NET/Forms/NetworkingForm.Designer.cs @@ -0,0 +1,127 @@ +namespace ReClassNET.Forms +{ + partial class NetworkingForm + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(NetworkingForm)); + this.label1 = new System.Windows.Forms.Label(); + this.tbIp = new System.Windows.Forms.TextBox(); + this.tbPort = new System.Windows.Forms.TextBox(); + this.label2 = new System.Windows.Forms.Label(); + this.button1 = new System.Windows.Forms.Button(); + this.label3 = new System.Windows.Forms.Label(); + this.SuspendLayout(); + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(10, 34); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(17, 13); + this.label1.TabIndex = 0; + this.label1.Text = "IP"; + this.label1.Click += new System.EventHandler(this.label1_Click); + // + // tbIp + // + this.tbIp.Location = new System.Drawing.Point(33, 31); + this.tbIp.Name = "tbIp"; + this.tbIp.Size = new System.Drawing.Size(106, 20); + this.tbIp.TabIndex = 1; + this.tbIp.Text = "127.0.0.1"; + // + // tbPort + // + this.tbPort.Location = new System.Drawing.Point(155, 31); + this.tbPort.Name = "tbPort"; + this.tbPort.Size = new System.Drawing.Size(37, 20); + this.tbPort.TabIndex = 3; + this.tbPort.Text = "3443"; + // + // label2 + // + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(198, 34); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(26, 13); + this.label2.TabIndex = 2; + this.label2.Text = "Port"; + this.label2.Click += new System.EventHandler(this.label2_Click); + // + // button1 + // + this.button1.Location = new System.Drawing.Point(33, 57); + this.button1.Name = "button1"; + this.button1.Size = new System.Drawing.Size(159, 27); + this.button1.TabIndex = 4; + this.button1.Text = "Connect"; + this.button1.UseVisualStyleBackColor = true; + this.button1.Click += new System.EventHandler(this.button1_Click); + // + // label3 + // + this.label3.AutoSize = true; + this.label3.Location = new System.Drawing.Point(143, 34); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(10, 13); + this.label3.TabIndex = 5; + this.label3.Text = ":"; + // + // NetworkingForm + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(231, 108); + this.Controls.Add(this.label3); + this.Controls.Add(this.button1); + this.Controls.Add(this.tbPort); + this.Controls.Add(this.label2); + this.Controls.Add(this.tbIp); + this.Controls.Add(this.label1); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "NetworkingForm"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; + this.Text = "Networking"; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Label label1; + private System.Windows.Forms.TextBox tbIp; + private System.Windows.Forms.TextBox tbPort; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Button button1; + private System.Windows.Forms.Label label3; + } +} \ No newline at end of file diff --git a/ReClass.NET/Forms/NetworkingForm.cs b/ReClass.NET/Forms/NetworkingForm.cs new file mode 100644 index 00000000..3243d631 --- /dev/null +++ b/ReClass.NET/Forms/NetworkingForm.cs @@ -0,0 +1,62 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace ReClassNET.Forms +{ + public partial class NetworkingForm : IconForm + { + public bool mConnected = false; + + public NetworkingForm() + { + InitializeComponent(); + } + + private void label1_Click(object sender, EventArgs e) + { + + } + + private void label2_Click(object sender, EventArgs e) + { + + } + + private void button1_Click(object sender, EventArgs e) + { + string ipStr = tbIp.Text; + string portStr = tbPort.Text; + + if (!string.IsNullOrEmpty(ipStr) && !string.IsNullOrEmpty(portStr)) + { + short port = 0; + + if (short.TryParse(portStr, out port)) + { + switch(Program.CoreFunctions.ConnectServer(ipStr, port))//[MarshalAs(UnmanagedType.LPStr)] + { + case 0: mConnected = true; Close(); return; // Sucessfully Connected + case 1: MessageBox.Show("Alredy Connected"); Close(); return; + case 2: mConnected = false; MessageBox.Show("Connection Failed"); return; + } + + } else + { + MessageBox.Show("Invalid Port"); + } + + } else + { + MessageBox.Show("Fields Empty"); + } + } + + } +} diff --git a/ReClass.NET/Forms/NetworkingForm.resx b/ReClass.NET/Forms/NetworkingForm.resx new file mode 100644 index 00000000..44a4a388 --- /dev/null +++ b/ReClass.NET/Forms/NetworkingForm.resx @@ -0,0 +1,3847 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + AAABAAcAEBAAAAEAIABoBAAAdgAAACAgAAABACAAqBAAAN4EAAAwMAAAAQAgAKglAACGFQAAQEAAAAEA + IAAoQgAALjsAAGBgAAABACAAqJQAAFZ9AACAgAAAAQAgACgIAQD+EQEAAAAAAAEAIAAPTgEAJhoCACgA + AAAQAAAAIAAAAAEAIAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJjtMSRkZHFoAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAGIiQwBmLeUAbTbDAAAAAAAAAAAAAAAAAAMcR1RXUP9vbm3/JjM/PAAA + AAAAAAAAAAAAAAAAAAAAZjMKAGEilRh9T/81iFr/EntI/wVxP1wAAAAAAAAAAAAJFVQWExD/V1ZT/2ho + Z/0gLTk+AAAAAAAAAAAAZCFMBW0y2zGWlP9DpJD/HX9A/0KOYv87jFzcAAAAAAAAAAAAAAAAAAAKSRAQ + D/9XVFH/aGhn/Ro7OE0AZyCjJH9g/1ilr/9RraD/VIhe/0JvSv8DbTX/NZBk/yyIW7IAAAAAAAAAAAAA + AAAAAApJEBAQ/1JPSv9FW1H6Oo+T/2KxwP9PqoD/Un5K/4JXXf9pd17/LohW/y+QZfMggE51AAAAAAAA + AAAAAAAAADkYHwBIHMUaNS7/lpiY/2yopP9mjWX/am5T/2V/Zf9ghGL/C202/wZyPOwAajkfAAAAAAAA + AAAAAAAAAGsycBJxPPBMmZj/d8HJ/4e8nf+5xrj/eGFc/4lzb/+Bqo//k7Ok/5ezo/9fnID/D3RHYAAA + AAAAAAAAAAAAAABpLsQchln/bbGk/3mXc/91YFX/iJiE/6Wuqf+2u7f/9O7o//Pq3v/06Nn/9Oja/77H + vvpoaG8nAAAAAAAAAAAAazUTGoFR+Gqoc/92b1//hnRu/y9+Rv/f3t3////5///36f//8+P//+/b///r + 0f//7tH/yMzF939/fwoAAAAAAAAAAAptPUYyj2P2S5Vm/xR1Pf9gjZD///73///67P/77t//+urX//no + 0v/56dT//+vO///24P9/f4FsAAAAAAAAAAAAORgfBXUx5iiHaf9Xq53/obi3///88f/+8eD/+uvX//no + 0v/56NH/+evW///z5f//9OD/tbGuqwAAAAAAazJwEnE88EyZmP93wcn/cLiO/5utm///++v//ezZ//no + 0v/56NH/+uvW//vt3f//+O////zw/7m2sq0AAAAAAGkuxByGWf9tsaT/eZdz/3VgVf98iHz///7w///r + 0f/56dP/+erW//vt3f/88+j////+/////f+IiIZyAAAAAABrNRMagVH4aqhz/3ZvX/+RdXP/gKeE/8XN + xPv/8tX//+rO///05v//+fD////+////+//V0c3tf3+RDgAAAAAAAAAACm09RjKPY/Zxron/a7CB/xSC + TpUkPDYq19TO0f3r1P/669b/+O/k//fy6//W0s/bf39/LAAAAAAAAAAAAAAAAAAAAAAagk+wN4pm5QBT + KUMAAAAAAAAAAAAAAACytbVkvbq1nMjFwJ+7uLZtv7+/CAAAAAAAAAAA/+cAAJ+HAACPAwAAxAEAAOAD + AADgBwAAwAcAAIADAADAAQAA4AEAAOAAAADAAAAAgAEAAMABAADhAwAA588AACgAAAAgAAAAQAAAAAEA + IAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoGAAcHIAAAAA0AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVQADAG43bwBt + OfQAbjn1AG0yIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFy5FC1FVWbxCQ0jfCAgQHwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG02KgBu + OMcAbzn/AG86/wFwO/8Abzi+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXLgs+P0O9Xl5e/2Bg + YP9GSkvOEyc6DQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGYzBQBu + OX0Abzj4AG86/wRyPf8DcT3/CnZE/wt3RP8AbzdlAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQHERUZvTIy + Mv9JSUn/XFxc/19fX/9GSkvOHi0tEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABu + NzMAbjnSAG86/wNxPf8Md0X/qbeS/1KSX/8IdEH/JIZa/wl0QPAAazoaAAAAAAAAAAAAAAAAAAAAAAAS + JA4FCArcGRkZ/zExMf9ISEj/XFxc/15eXv9GSUvOGSYzFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABx + OAkAbjiLAG83/AFvOv8igEz/Tqep/0yYd/8uhVH/E3hF/wNwPP9knXL/Vptv/wFvOakAAAAAAAAAAAAA + AAAAAAAAAAAAAAAIGB8ECArdGRkZ/zExMf9GRkb/XFxc/19fX/9GSkvOGSYzFAAAAAAAAAAAAAAAAAAA + AAAAbzdAAG852gBvOv8JdED/UJp5/zav3v9MqrX/L4dX/wx4Rv8IdUL/BHE9/3+pgf97rof/AG84rAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGB8ECArdFxcX/y8vL/9HR0f/XFxc/19fX/9GSkvOGSYzFAAA + AAAAdToNAG45mABvOf4CcDv/ModW/2istv9Qsd7/Upx+/xqAUP8yiFX/c5xn/w54Rf8Fcj//AXA7/w13 + RP8OdkTqCnVC1wBrNRMAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGB8EBQndFxcX/y8vL/9HR0f/XFxc/19f + X/9GSkvOBWE5WQBtOeQAbzr/EHhG/2Oghv9jreH/bKuw/zmNX/8uiVn/YZtm/4eJZv9cWFL/Xote/wZz + QP8CcDz/AG85/1ynhv9ytJf/AG84ogAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGB8EBQndFxcX/y8v + L/9HR0f/XFxc/19fX/8aXED/BHE9/z+PYv9fpcH/Xqja/2Cff/8oiV3/RJJi/4qeb/9uaFn/WFZU/2Vi + Yf+DfnH/K4FO/wNxPf8XfUz/ZKyL/yqHW/YAbzduAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI + GB8EBQndFxcX/y8vL/9HR0f/XFxc/y5qUP9hoZT/Nprj/2CkrP9ElWr/RJRo/zKMYP9hmWn/XVhT/2Bd + W/9saWj/fHdz/4CUbf8xg03/Rplz/1KhfP8IdD2/AHE4JAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAA2JDgFDw31FxcX/y8vL/9PUVP/r7m2/0aazP9jo4T/PZVt/2Ogcf+OnnL/iIZo/zKL + Xv9/jW7/c29u/5GLeP9Iilb/A3A7/wRwPP8eglDzAG84ZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAbzhnAG858QBjNv8WSzP/QGll/6y1t/+hoaH/Y5N6/1Wedf+Hqnr/hoJm/1ZT + UP9hXlz/eJVv/z6PYP+AmG7/E3dB/wBvOf8Abzr/AXA7/wBvN8UAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAcTgkAG45wABvOv8JdUH/WJx1/2ux0v9as9H/c6yN/4Wyn//Hycj/iZd8/2Vg + Vf9bWFf/aGVj/3Nwbv+hmXz/JH1S/0COaP9ZnHz/V5t7/ziJY/8Rd0j/C3dE/wBvN2UAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAG83bgBtOfYAbzr/KoZW/2KmqP9KouT/eq+k/1ekfv9pqYD/ia6A/5C3 + oP/Iycj/dXJt/29rav+CfXX/k6aH/63Fuf/Z29r/zMzM/8DAv//CwcH/z8/P/9XZ1/+gwLL/L4Na8wBr + OhoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbjiiAG86/wJwO/9Jm3H/b6qx/2qphv9WpH7/fa+C/5ed + dv9iXVT/go5w/4Kznf/GxsX/iYmC/6avqf/X2Nf/ycjG/9nUzv/q4tn/8und//Ln2v/o3dD/1s7D/8rH + w//X2Nf/faaR1z8/PwQAAAAAAAAAAAAAAAAAAAAAAAAAAABrNRMAbzfqCHRC/xV9TP9Ponz/Yad//5Su + gP9/eWL/VlNS/2NgXv91cGz/eqR8/7DDuf/Jycn/2NfX/+Le2P/68+n//PPo//zy5f/78OL/++/f//vt + 2//669j/9ubS/93Txf/Y19b/v7+/qFVVVQMAAAAAAAAAAAAAAAAAAAAAAAAAAABvN1cKdkT/HYJU/0uR + X/9CkWL/eHBf/11aWf9qZmX/d3Jw/5iXe/8whFH/r7ez/93d3P/s5+H//PXr//zz6P/88uX/+/Di//vu + 3//77dv/+uvY//rp1P/559H/+ebN/+bYxf/a2dj/payojgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABt + ObEoiFz/xcWk/0yVZv99nnf/cm5s/4qDd/9zm23/CXM+/y58V//W19b/6ubg//z16//88+j//PLl//vw + 4v/77t//++3b//rr2P/66dT/+ejS//nmzv/45Mr/9+LG/+XYx//Nzs79kJCQLgAAAAAAAAAAAAAAAAAA + AAAAAAAAAGs6Gg14RfA+lm3/KYlc/1Sjff+TpXz/K4JO/wBvOv8EcT3/lqqf/+fm4//68+r//PPo//zy + 5f/78OL/++7f//vt2//669j/+unV//np1P/56dP/+enT//no0v/448j/89y9/+Pf2f+urq6kAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAG85PgBtOaEcgFD/IINU/wRyPP8Abzr/G35N/2Gbj//Ky8z/7unj//zz + 6P/88uX/+/Di//vu3//77dv/+uvY//rp1f/56dT/+enT//np0//56tX/+uvX//rs2v/44sb/6tvI/8LC + wvI4ODgJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG84mRyAUP8Abzr/B3M//ziRZv95rJP/WZvD/9ra + 2v/x6uD//PLl//vw4v/779//++3b//rr2P/66dX/+enU//np0//56dP/+erV//rr1//67dv/++7e//vu + 3//r1bn/19fX/4iIiDYAAAAAAAAAAAAAAAAAAAAAAAAAAQBvOGcAbzjzAG86/yWDUv9lraD/bra3/1Wh + e/9tnoT/3dzc//bs4P/78OL/++/f//vt2//669j/+unV//np1P/56dP/+enT//nq1f/669f/+u3b//vu + 3v/78OP//PPo/+/awP/d3dz/mZmZUwAAAAAAAAAAAAAAAABxOCQAbjnAAG86/wl1Qf9YnHX/a7HS/1qz + 0f9srIn/TqB8/2Sbgv/b29r/9uvd//vu3//77dv/+uvY//rp1f/56dT/+enT//np0//56tX/+uvX//rt + 2//7797/+/Dj//zz6P/89u3/8N/K/97e3f+amppWAAAAAAAAAAAAbzduAG059gBvOv8qhlb/Yqao/0qi + 5P96r6T/V6R+/2mpgP+JroD/Z5x9/9bW1v/x5tf/++3b//rr2P/66dX/+enU//np0//56dP/+erV//rr + 1//67dv/++7e//vw4//88+j//Pbt//348v/u4dD/2NjY/4yMjDwAAAAAAAAAAABuOKIAbzr/AnA7/0mb + cf9vqrH/aqmG/1akfv99r4L/l512/2JdVP+AjG7/u8C+/+3k2f/669j/+unU//no0v/56dP/+enT//nq + 1f/669f/+u3b//vu3v/78OP//PPo//z27f/9+PL//vv3/+zh1P/Hx8f3Tk5ODQAAAAAAAAAAAGs1EwBv + N+oIdEL/FX1M/0+ifP9hp3//lK6A/395Yv9WU1L/Y2Be/3VwbP+aqpv/4t7Z//jo0//559H/+ebO//np + 0//56tX/+uvX//rt2//77t7/+/Dj//zz6P/89u3//fjy//779//69e//5N/X/6+vr7AAAAAAAAAAAAAA + AAAAAAAAAG83Vwp2RP8dglT/S5Ff/0KRYv94cF//XVpZ/2pmZf93cnD/oJl+/3mgef/Jy8r/6NzN//nm + zf/45Mr/+enT//rr1//67dv/++7e//vw4//88+j//Pbt//348v/++/f//v37/+fe0v/S0tL9lZWVOgAA + AAAAAAAAAAAAAAAAAAAAAAAAAG05sSiIXP/FxaT/TJVm/32ed/9ybmz/ioN3/6Sug/9Zm2v/YKiF/22e + iP3X19T/6dnE//jixv/45Mn/+u3a//vu3v/78eP//PPo//z27f/9+PL//vv3//79+//p4NT/29rY/7S0 + tJYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAazoaDXhF8D6Wbf8piVz/VKN9/5+pgv97p3b/Vp92/1ek + gf8OdkPSAGs1NL6+vpfX1tT+39C9//Xdvv/45Mn/++/h//zz6P/89u3//fjy//779//79vD/39bK/9jW + 1P/FxcW2bW1tBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzk+AG05oRyAUP8yj2T/NpFm/2Gp + hv8til33AG45fQB/PwQAAAAAAAAAAcHBwXTY2Nj2zsjA/9bFsP/mz7H/8d3D//Hhzf/o28r/1sy+/8rE + vP/Y2Nn8xsbGlG1tbQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbziMXqiI/22y + lP9RoHz/CnRBxwBtNioAAAAAAAAAAAAAAAAAAAAAAAAAAKenpyPZ2dmW3t7e6dbW1f7Kycj/ycjG/9TU + 1P/e3t7z29vbqrS0tDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABt + MiMihFX1JYRX9ABuN28AAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzMzMFsbGxK9TU + 1EjW1tZMvr6+M2ZmZgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA///+f+f/+D/D//A/gf/AH4D/ + AA/AfgAP4DgAB/AQAAP4AAAH/AAAD/4AAD/8AAA/8AAAP+AAAB/AAAAP4AAAB/AAAAPwAAAD+AAAAfwA + AAH8AAAB/AAAAfAAAAHgAAABwAAAAeAAAAHwAAAD8AAAA/gCAAf8D4AP/B/AP/5///8oAAAAMAAAAGAA + AAABACAAAAAAAABIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQBuNzMAbjbAAG448ABs + ODYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAfLz1wGyYsdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbSQHAG44fwBv + OfEAbzr/AG85/wBuNsQAVBwJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAC08THFqZ2b/XFpX/yg0QH8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQBs + Nj0AbjjQAG85/wBvOv8Abzr/AXA7/wBvOf4Abjd4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAIC1Ab1lZWf9sa2n/aGdm/1ZWVf8mLzqLAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAZjMPAG83jgBvN/MAbzr/AG86/wFvOv8Abzr/BHI+/wd0Qf8Abjn0AG80JwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPHS1wOTk4/05OTP9XV1j/Y2Nj/2ZlZP9WVlX/KTVAjgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABuOUMAbDfTAG85/wBvOv8Abzr/BXI+/wd0Qf8DcTz/CXVD/xJ7TP8Ld0T/AG85twBt + JAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEoLAIPIXMYFhT/LCsp/zk5Of9JSUn/WFhY/2Rk + ZP9nZWT/V1VU/yg0PZIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAbTAVAG04ngBtN/sAbzr/AG86/wNxPf8Ld0T/i6h5/7++mP8ce0f/BHI9/xqA + Uv8jhln/B3RA/wBvN2kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsaRAAIE5oKCAb/GBgX/ygo + Kf85OTn/SUlJ/1lZWf9lZWX/ZmRk/1JRUP8nMj2NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAD8ABABuN1MAbzjaAG85/wBvOv8BcDv/HH1K/1eXZ/8Rekj/faV1/7C9 + k/8Xekb/A3E8/xJ7Sv8xjWP/KYhd/wJvO+kAbjclAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAgABRCsCAgI/xkYF/8pKSn/OTk5/0pKSv9YWFj/YWFh/2ZlZf9VVFP/JzI9jgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaDkWAG43pgBtN/sAbzr/AG86/wd0QP9HkF7/YLG4/zux + 3/9Qk2H/DHhG/wl2Q/8HdEH/BHE9/x1/Tf+hson/iq6D/yCDVP8AbzieAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAFAAcPqAgICf8YGBf/KSkq/zg4OP9GRkb/WFhY/2VlZf9mZmX/V1VU/ygy + PZIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGYzBQBvOF4AbznoAG85/wBvOv8DcTz/J4JR/22p + jv8wsOf/Kq/o/2upkv8og1H/DXhG/wp3RP8IdEH/BXI+/yWBTv/NyKn/sMGa/yeIWv8AbjiUAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAHD7EJCAj/FxYV/yQkJf83Nzf/SEhI/1lZ + Wf9lZWX/ZmZl/1VUU/8nMj2NAAAAAAAAAAAAAAAAAAAAAAAAAAAAbDYhAG42sgBtN/sAbzr/AXA6/xB4 + Rf9XmGv/a7PD/yOu8/9XscP/UJdq/xd+Tv8Rekr/IoBN/wx3Rf8IdUL/BnM//wRxPf8qhVT/RZhv/xJ6 + SP8Abjh/AG83VwBtMBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgABRCsBgYG/xYV + FP8mJib/Nzc3/0dHR/9YWFj/ZGRk/2ZlZP9VVFP/JzI9jgAAAAAAAAAAAFUAAwBuOGgAbjfpAG85/wBv + Ov8Ecj3/L4dX/4Ctlv9Vr+f/UbHm/3Gpkv8wiVn/Fn9Q/yKCUv9TlF//mqpz/1qTXv8JdkP/BnNA/wRx + Pf8Bbzv/AnA7/wl0QP8Yfk7/F31M/wBvOKMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAFAAYPqAcHB/8WFBP/JiYm/zc3N/9HR0f/WFhY/2VlZf9mZmX/V1VT/ys3RI4AbTYqAG44wgBv + Of8Abzr/AXA6/xd8Sv9poXj/fLLL/0yr9f97sr3/WJlp/x+DVv8fg1T/SZJf/4Omb/+QlGv/X1pR/357 + Y/8sg0//B3NA/wRyPf8BcDv/AG85/xyAUP9/vKP/gL2j/xJ5R/kAbTZUAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAABQAFDrEHBwb/FRUU/yYnJ/83Nzf/R0dH/1lZWf9lZWX/aGdl/1FT + V/4CWi/xAG85/wBvOv8IdED/QpBi/3+tof9Up+v/Zq3e/3upjv82jWD/JIZa/zyOX/9qnmr/i6Fv/3x2 + Xv9UUU7/WVdW/2ZiX/+HmG7/CnVC/wVyP/8CcDz/AG85/wNxPP9pr5D/i8Or/yuJXf8Abzm3AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgABQ6sBgcG/xYVFP8mJib/Nzc3/0dH + R/9YWFj/aGdm/11gY/8DXDL/AXA6/x6AUP9xpX7/XqbP/zee9f+BsLj/WZtv/yyLYP8niF3/QJBh/4Gm + cf+Zlm7/XllR/1VSUf9eW1r/ZmNi/29rav+Df3P/R4xW/wZzP/8DcTz/D3hG/2Gqif9ssZL/E3lI/QBu + OKsAbzcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAYNqAcH + B/8WFBP/JiYm/zc3N/9ISEj/W1lY/1pfYv8NZDz/Uphs/3WrrP8bk/L/SqHZ/3upif86kmf/Mo5k/zeO + Y/8oiV3/RJJj/42FZ/9RTk3/W1hW/2NgXv9saGf/dHBv/2Z4af8meUf/B3E7/wZyPv83kGb/fryg/zaQ + Zf8AbzfgAG44UQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABQAFDrIHBwb/FRQT/ycnJv80NTP/LS4v/5GUmP+Po5X/Sp3T/x6U8P9xqbD/Wp52/zmS + af85kmf/YZ5v/5GseP9mnGz/J4dc/4CZbv9mYV3/aGRj/3Bsa/90c2//SX1Z/wlyPP8Abzr/AG85/xh9 + S/9fp4X/D3dG9wBvOZwAajUYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAGYzDwBoNJIAKBz8BgkH/xISEf8pKyv/aG1w/5aXl//FxsX/V5S7/3iq + jP9ImXL/PJVu/1accP9+qXf/mqZ3/3NsWv+Ff2X/QZFj/ziNX/+SkXT/dHBv/2J3Zv8geEX/AG85/wBv + Ov8Abzr/AXA7/wBvOf8AbzfuAG85RwB/AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/AAIAbThIAG043wBvOf8Aazn/BFk6/ydwUf9nkX3/rb7A/62s + q/+lpqb/eo+C/0aXc/9RnHT/bqV3/5Gte/+UjGv/U1BN/1dUU/9gXVv/j511/ymIXP9al2b/SoJW/wdy + O/8Abzr/AG86/wFvOv8Abzr/BHI+/wd0Qf8Abzn1AG80JwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGsxGgBuN50Abzf4AG86/wFwOv8UfEr/ZqN5/3u2 + vP8frfL/Vqm+/42wlv+xxLv/4eHh/3GHe/+Dq33/qKd5/29oWP9UUU//XFlX/2RhYP9taWj/hoB0/1CR + X/8GcT7/DnZD/yKBVP8Paj7/EmxB/yODVv8KdEH/CXVD/xJ7TP8Ld0T/AG85twBtJAcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAbDdSAG044gBvOf8Abzr/BXI+/zeO + YP+Kspb/Zq/i/1Gv7f+Dt6v/ZqiA/1Ciff9WoH//vtHJ/93d3f+IhXn/VlJO/1dUU/9gXVz/aWVk/3Fu + bP9tc23/Q3tX/z15W/+RtaT/xdfP/9fc2v/y9PP/8vPz/+Li4P+80cb/a5eC/0qNb/8nh1v/B3RA/wBv + N2kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG83IABvOKwAbTj9AG86/wFw + Ov8Yfkz/bqd//22qwf81nfb/e7HJ/4KwiP9Ro37/VaR+/2qpgP+Dr4L/W6J8/8LTy//d3d3/eXd2/2Vi + YP9uamn/dHFu/1l0Xv+Dp5L/197b//f3+P/S0tP/v7+//7e2tf+xsa//srGx/7m3t//ExMX/4eLj/+vs + 7f/Bzsj/ZZmB/wZxPuoAbjclAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG03uABv + Of8Abzr/AG86/yKFVv90rID/TaHY/y+Y5v+EsaP/YKeA/1Gjfv9YpH7/hbGD/6azgv+Kg2b/kKN5/1Se + fP/H1c7/3d3d/3t6ef9namb/b4F1/7/Hw//r6+z/zs7O/8C+vP/Gw7//083G/+DYzv/m3dH/5NvP/93T + x//RyLz/xb+3/8G/vP/U1db/4eLk/6q/tf8XaEGvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAG02VABtOfkAbzr/AXA7/w13RP9Nn3n/kLSZ/3itiP9To37/UaN+/3Ssgf+XtYX/oJ93/2Vf + VP9UUVD/enRl/3OmfP9QnHr/vci+/8fHx/+kpKT/2dna/93d3v/IxsX/2tXQ//Ts4///+e7///ns///3 + 6f//9Of///Pk///z4///8+H///Dc/+/fzf/Uyr3/ycfE/+Di5P/T2Nb5enp6UwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQBvOKMAbzr/BXI//wh1Qv8ihVf/UaN+/1Gjfv9oqYD/hbGD/6Gw + gf+FfGL/UE1M/1lWVf9iX13/a2dm/5yae/9KmG//gqmW/9XV1f/W19f/2tvc/9bT0f/z7OP///vw///4 + 7f/88uf//PLm//zx4//77+D/++/f//vu3P/77Nr/++zZ//7u2f//7NT/7NrE/9LMw//h4+X/3N/e/mFx + aVwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABpNB0AbzfhCXVD/xJ8TP8OeEf/Mo9j/z6W + bv9wqn//pJ11/2FcUv9VUlH/XltZ/2ZjYv9va2r/dnNw/1mAX/8LcD3/jqKY/9fX1//d3d7/39zZ//ny + 6f//+u///fXq//zy5//88uX//PHk//vv4f/7797/++7c//vt2//669j/+urW//ro0//76dP//urR//Hd + wv/b08j/5Obo/8PJx/k1NTUrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzZeA3E8/hqB + U/8jhVn/W5Zj/1CTYf82ilj/iYFn/1lXVf9iX17/a2dm/3Nwbv9odWr/KHpJ/wBvOf8GZjj/pq6q/+Xl + 5v/k4t//9/Ho///47v/89On//PLn//zy5v/88eP//O/h//vu3//77tz/++3b//vr2P/66dX/+ujT//rm + 0f/55s7/+eXM//zmy//w2r7/4NnQ/+Lk5/+dqaLSf39/AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAG44sBF6SP8wjWP/0sao/8fHpP8jhFf/faV5/3hzaf9wbGv/cnNv/059W/8Mcz3/AG85/wBv + Ov9Wg23/5ufn/+fm5f/y6+P///ju//z06v/88uj//PLm//zx4//77+D/++/f//vu3P/77Nn/+uvY//rp + 1f/66NP/+ejS//nn0P/55s3/+OTJ//jixv/84sP/69a6/+bj4P/U1tn/eHh4agAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAG43JQJuOuksil//cah+/22pgP8jhVb/UKB6/52lgP9peWn/JXpI/wFu + Of8Abzr/AXA6/yd9U/+wtbL/6urq/+vn4f/+9+z//fXq//zy5//88uX//PHk//zv4f/77t//++7d//vt + 2//669j/+urW//rp1P/66dT/+enT//np0//56NP/+ejS//jky//64cL/9ty4/+jax//p6uz/qqus0AAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvN2kMdkP+NI9l/0KYcf8af0//S554/zKK + Wv8GcDr/AG86/wBvOv8MdkT/Uphs/2yLi//f3+D/7uzq//Tt4///9+z//PLn//zy5v/88eP/++/h//vv + 3//77tz/++3a//vr2P/66dX/+unU//np1P/56dP/+unT//np0//66tX/+urW//rs2f/559D/++G//+zT + sv/r6OL/2dve/0pKSk8SEhIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtJAcAbzeFAG84ugBt + OPUReEb/CHM//wBuOf8Abzr/BHE9/yeHWP95qof/SZ/X/2GMrv/n6Oj/7+vm//716v/88uj//PLm//zx + 4//77+D/++7f//vu3P/77Nr/+uvY//rp1f/66dT/+unU//np0//56dP/+enT//rp1P/66tb/+uvX//rs + 2v/77+D/+ujS//XXsf/r4NH/5Obp/3BycoxDQ0M1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAGoyNwNwOfgDcDv/AG86/wBvOv8PeEb/SZpw/1GhfP+Dr6H/UqDR/5ymof/q6ur/8evk//70 + 6P/88uX//PHk//vv4f/779//++7d//vt2//669j/+urW//rp1P/66dT/+enT//rp0//56dP/+enU//rq + 1f/669f/+uzZ//rt3P/77+D//PHl//niw//r2L7/6Ojp/5ucnLiGhoZoAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAB/AAIAbThIAG046wBvOf8Abzr/BXI9/zOMXv9/spP/e7q8/2OngP9co3z/Z6F9/6Or + qP/s7Ov/9e3j//3z5v/88eP/++/h//vu3//77tz/++3a//vr1//66dX/+unU//rp0//56dP/+unT//np + 0//66dT/+urV//rq1//67Nn/++3c//vu3//77+D//fTr//zs1//t1rf/7Oro/6aoqdmVlZWPAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAGsxGgBuN50Abzf4AG86/wFwOv8UfEr/ZqN5/3u2vP8frfL/WbXM/3at + hf9Nn3r/VJt7/6yxr//r6uj/9+7j//3x4//77+D/++/f//vu3P/77Nr/+uvY//rp1f/66dT/+enU//np + 0//66dP/+enT//np1P/66tb/+uvX//rt2f/77dz/++7e//vv4f/88uT//PTq//3z5//v2bz/7enj/66v + sembm5uiAAAAAAAAAAAAAAAAAAAAAAAAAAEAbDdSAG044gBvOf8Abzr/BXI+/zeOYP+Kspb/Zq/i/1Gv + 7f+Dt6v/ZqiA/1Ciff9OoHv/VJx8/6qvrf/r6ej/+O3h//zw4f/77t7/++7c//vt2//669j/+urW//rp + 1P/66dT/+enT//rp0//56dP/+enU//rq1f/669f/+uzZ//vu2//77t7/++/h//zx5f/88+j//PXs//75 + 8v/v28D/7Oji/6+wseudnZ2lAAAAAAAAAAAAAAAAAG83IABvOKwAbTj9AG86/wFwOv8Yfkz/bqd//22q + wf81nfb/e7HJ/4KwiP9Ro37/VaR+/2qpgP+Dr4L/XaB8/5yno//r6un/9evd//zv3//77tz/++3b//vs + 2P/66dX/+unU//np0//56dP/+unT//np0//56dT/+urV//rq1//67Nn/++3c//vu3v/77+H//PHk//zz + 6P/99Ov//ffv///89//v3sX/7Onk/6mqq9+VlZWWAAAAAAAAAAAAAAAAAG03uABvOf8Abzr/AG86/yKF + Vv90rID/TaHY/y+Y5v+EsaP/YKeA/1Gjfv9YpH7/hbGD/6azgv+Kg2b/kKN5/4adkv/p6Oj/8efb//3v + 3f/77Nr/+uvY//rp1f/66dP/+unU//rp0//56dP/+enT//rp1P/66tb/+uvX//rt2f/77tz/++7e//zv + 4f/88uT//PPo//317P/99+///fjz///89v/u4Mz/6ebj/6CgosCOjo5xAAAAAAAAAAAAAAAAAG02VABt + OfkAbzr/AXA7/w13RP9Nn3n/kLSZ/3itiP9To37/UaN+/3Ssgf+XtYX/oJ93/2VfVP9UUVD/enRl/3GI + df/j4+T/7ebd//3u2f/769j/+urW//ro0//66NL/+enT//rp0//56dP/+enU//rq1f/669f/+uzZ//vt + 3P/77t3/++/g//zx5f/88+j//PTr//337//9+PL///37//vz6P/s4tT/5ubm/3p6epZQUFA/AAAAAAAA + AAAAAAAAAAAAAQBvOKMAbzr/BXI//wh1Qv8ihVf/UaN+/1Gjfv9oqYD/hbGD/6Gwgf+FfGL/UE1M/1lW + Vf9iX13/a2dm/4SCbP/W19n/7Ojk//Pj0P/97dj/+ujU//rn0f/56NH/+unT//np0//66dT/+urV//rq + 1//67dn/++3c//vt3//87+H//PHk//zz6P/99ez//ffv//738//++fX///////Dk1P/r49r/3+Hk/1BQ + UFwZGRkUAAAAAAAAAAAAAAAAAAAAAABpNB0AbzfhCXVD/xJ8TP8OeEf/Mo9j/z6Wbv9wqn//pJ11/2Fc + Uv9VUlH/XltZ/2ZjYv9va2r/d3Nx/5aNev+iqqL/5ebm/+vg0f/86dH/++jS//nmzf/55s7/+enU//rq + 1f/66tb/+uvX//rt2f/77tz/++7e//vv4f/88uT//PPo//317P/99+///fjy//779f////7//fr0/+nd + zf/p6Ob/sbKz2EVFRQsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzZeA3E8/hqBU/8jhVn/W5Zj/1CT + Yf82ilj/iYFn/1lXVf9iX17/a2dm/3Nwbv98d3T/pp+A/5+0gv9ki2z/0dPV/+Xi3P/x38j//enP//nl + zP/45Mr/+enT//rq1v/669f/+uzZ//vu3P/77t3/++/g//zx5f/88+j//PTr//337//9+PL//vr1//78 + +f//////8OTW/+bf1v/i5Of/a2trfgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG44sBF6 + SP8wjWP/0sao/8fHpP8jhFf/faV5/3hzaf9wbGv/d3Ny/5KKev+us4X/gKt5/0OQYP9jq4v/laui/+Di + 5P/i2s3/9ODE//vmy//44sb/+OXM//rs2v/67dn/++3b//vu3//77+D//PHk//zz6f/99Oz//ffv//75 + 8//++vX//vz5///////17eP/4dfK/+Tm5//AwMDPTk5ODQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAG43JQJuOuksil//cah+/22pgP8jhVb/UKB6/52lgP+BfHX/q6SB/6C1g/9cm2r/RJdv/3O1 + l/81jmX+CGg43cTJx+vk5eb/3dPF//Pewf/95MX/+eHD//np0//77+D/++/f//zv4P/88uT//PPo//31 + 7P/99+///fjy//769f////3///////fw5f/bz8D/4uLi/8/P0PlmZmY+AAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvN2kMdkP+NI9l/0KYcf8af0//T6F8/2mogP+wt4b/e6p4/zyO + X/9rr5D/XqiG/w92RfsAbjedAHIzFFlZWTnc3d725OXm/9XLvv/t1rj//eK///ziwv/66tX//PLm//3z + 6f/89On//PXr//327v/9+PP///z6//////////v/7+bY/9PIuv/f3t7/3t/h/4eHh2QAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtJAcAbzeFAG84ugBuOPUWfEv/LItf/0yg + ev8ti1//T5x0/3a3m/8qh1z+AG450gBuNUMAAAAAAAAAAAAAAABdXV0/2drb3+Pl6P/OycL/1sWv/+7T + sP/73bj//ufL///x3///+e////33////+/////3///vx//Lm1v/Vybn/yMG4/9/g4v/e3t79iYmJYgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG02KgZx + PfBiq4v/OpNq/yqJXf9rsJH/VKJ+/wt1Q/MAbjiNAGYzDwAAAAAAAAAAAAAAAAAAAAAAAAAAOjo6GsfH + x67h4+X/3d3e/8nDvP/Ju6j/0bqe/9vCov/iyq3/4c2z/9zKsv/Qwa3/xrus/8G5rv/X1dP/8fP2/9DQ + 0NFlZWU6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAG02XRR7Sv6AvaP/h8Go/3W2mv8ohln+AG440ABuNzwAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACTk5NTy83Owu7x9Prx8/X/09LS/8G/u/+6tK7/uLOs/765tP/Lx8T/6ejo//Hz + 9v/MzdDakJCQdqKiogsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAFQcCQBuOcRIm3X/TZ14/wZyPvEAbzh+AD8ABAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYiIiDiHh4d+19jYrenr7Mzn6erd6Onq4Onq + 6tPj5OS4m5ubj52dnVF/f38IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsODYCbzrwAG05vwBwODIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8/PwQ+Pj4pvb29WeLi + 4n/m5uaT5efnl+Li4ojPz89mW1tbOHNzcwsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA/////+f/AAD/////w/8AAPn///8D/wAA8H///AH/AADgP//4AP8AAMAf/+AA/wAAgA//wAB/ + AADAB/8AAD8AAOAD/gAAPwAA8AH4AAB/AAD4APAAAA8AAPwAQAAADwAA/gAAAAAHAAD/AAAAAA8AAP+A + AAAAPwAA/8AAAAB/AAD/wAAAAf8AAP+AAAAB/wAA/gAAAAD/AAD8AAAAAP8AAPAAAAAAfwAA4AAAAAA/ + AADwAAAAAD8AAPAAAAAAHwAA+AAAAAAPAAD8AAAAAAcAAPwAAAAABwAA/gAAAAADAAD/AAAAAAMAAP8A + AAAAAQAA/8AAAAABAAD/gAAAAAAAAP4AAAAAAAAA/AAAAAAAAADwAAAAAAAAAOAAAAAAAQAA8AAAAAAB + AADwAAAAAAMAAPgAAAAAAwAA/AAAAAAHAAD8AAAAAAcAAP4AAAAADwAA/wAGAAAfAAD/AB8AAD8AAP/A + P4AAfwAA/8D/4AH/AAD/w//8B/8AAP/n//8f/wAAKAAAAEAAAACAAAAAAQAgAAAAAAAAgAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAPz8EAG44fwBuN/MAbDg7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzc3AG830wBvOf8Abzn/AG421wBtJAcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAdMRoADxYiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqKgwAbjiLAG03+wBvOf8Abzr/AG86/wBv + Of8AbTiHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAABssQi5HSlDhQENG9BEXIiwAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtOD8AbTnfAG85/wBv + Ov8BcDv/AXA7/wFwO/8Abzn/AG84+gBsNi8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYtQy1UVlzjYWFh/15eXv9DRUbzGic5OgAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG8vEABu + OZsAbzn/AG85/wBvOv8Abzr/AG85/wBvOv8BcDv/BHI+/wFvOv8AbTfPAFUAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYnPi1GSE7kXV1d/2tr + a/9bW1v/XV1d/0JERvUfLD5RAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAHA5SwBuOOMAbzn/AG86/wFwO/8Abzn/AXA7/wRxPv8Abzr/B3NA/wt3Rf8Ld0X/AG85/wBt + N3cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsc + Mi0yNDrjSEhI/1paWv9XV1f/aGho/15eXv9aWlr/RUdI9RwsO1EAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAZjMUAG44qwBvOf8Abzn/AXA7/wBvOv8Abzn/BnM//wl1Qv8Gc0D/AnA8/wd0 + QP8Re0v/FX5P/wp2RP8Abjf3AG80JwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAUWLS0dHyXjLy8u/0NDQ/9DQ0P/WFhY/1paWv9jY2P/Y2Nj/1VVVf9GSEn1HCw7UQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbjhfAG046wBvOf8Abzr/AXA7/wBvOf8Dcj3/C3dF/2ea + ZP/Ov5v/g6Vu/wVyPv8Bbzr/FH1O/x2CVv8hhVj/BXI9/wBsOMMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARKx0KDRDkFhYW/yoqKv8sLCz/QkJC/0ZGRv9UVFT/X19f/19f + X/9mZmb/U1NT/0ZISvUcLDtRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtNhwAbzezAG85/wBvOf8BcDv/AG86/wFw + Ov8KdkT/FXxK/w55R/+arnr/1tPP/7vAkf8Gc0D/A3E8/wdzQP8mh1z/LItg/yOFWP8Abzn/AG05awAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEig4AwQF/BAQEP8VFRX/KCgo/y4u + Lv8+Pj7/SkpK/1BQUP9jY2P/XV1d/2dnZ/9SUlL/Q0VG9RwsO1EAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwOWsAbjfzAG85/wBv + Ov8BcDv/AG85/wZzQP8ziFb/jrOR/32mdf8OeUf/K4RQ/3ihaP81hlH/BnNA/wVyPf8Abzr/IoRX/z+U + af87k2z/F31N/wBtN/IAajkfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAK + GHsDBAX8Dw8P/xcXF/8lJSX/MjIy/zk5Of9OTk7/Tk5O/2NjY/9dXV3/YWFh/1hYWP9ERUf1HCw7UQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG86JwBv + OMMAbzn/AG85/wFwO/8Abzr/AnA7/xN8S/9xoW7/dLnB/wSq/v9ouMr/PYtX/wx4Rv8Kd0X/CXVC/wZz + QP8Fcj7/AG86/2Cdbf/Ov5v/wsCR/0SZc/8Hcz//AG83kwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAoYewMEBPwODg7/Ghoa/yIiIv81NTX/Nzc3/05OTv9NTU3/XV1d/2Nj + Y/9hYWH/WFhY/0RFR/UcLDtRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAPz8EAG43cwBuN/cAbzn/AG86/wFwO/8Abzn/C3ZE/0COXf+St5r/Jq/s/wCp//9ct9P/gKl6/xx+ + TP8NeEb/C3dF/wl1Q/8HdEH/BXI+/wFvOv+AqHb/1c7D/+DSrP9RoXz/A3E8/wBuOH8AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEADBh7BAQF/AwMDP8cHBz/ISEh/zY2 + Nv82Njb/SEhI/1NTU/9dXV3/Y2Nj/2FhYf9YWFj/REVH9RwsO1EAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAbDYvAG03zwBvOf8Abzr/AXA7/wBvOv8EcTz/HoFR/4OpeP9zucv/A6n//xut + 8v+MuKT/SJBd/xF8TP8PeUj/DnlH/wx4Rv8Kd0P/B3RB/wZzQP8DcTv/G35L/4uwfv96roX/QZhx/wBv + Of8AbjczAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAM + GHsFBQb8CwsL/xwcHP8fHx//Ly8v/zs7O/9HR0f/U1NT/11dXf9jY2P/YWFh/1hYWP9ERUf1HCw7UQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABfHwgAbjiDAG03+wBvOf8Abzr/AXA7/wBvOf8Rekj/TpVl/5+6 + of9CsPD/Gqv//2i4zv+BqHb/HIFS/xR9Tv8SfEz/Fn1M/1uWYP8Tekj/CndE/wh0Qv8Gc0D/BXI9/wFw + O/8Abzn/D3hG/ySFV/8Abzn/AG44qwBuOMcAbTeXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAoYewUFBvwKCgr/FhYW/yIiIv8vLy//Ozs7/0dHR/9TU1P/XV1d/2Nj + Y/9hYWH/WFhY/0RFR/UcLDtRAAAAAAAAAAAAAAAAAAAAAABvNzcAbjfXAG85/wBvOv8BcDv/AG86/wdz + P/8qh1n/jq5//4G30/8xqf//TbHs/5i3nf9HkWD/GYFS/xZ/UP8hglL/NIhW/22eZ/+nsnj/tqx6/x9/ + S/8JdUL/BnNA/wVyPv8DcDz/AXA7/wBvOf8BcDr/FHtK/yOEVv8oiFv/AG85/wBtNk8AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAChh7AwQF/AwMDP8WFhb/IiIi/y8v + L/87Ozv/R0dH/1NTU/9dXV3/Y2Nj/2FhYf9YWFj/REVH9RwsO1EAAAAAAGoqDABvOZMAbzn/AG85/wBv + Ov8Abzr/AW86/xZ9Tf9ln2//n7mr/1Gr8v8/qf3/i7nI/4Gndf8ihFf/HYJV/xmBUv9Hkl//RpFe/4an + b/+zqnj/a2RV/1hUT/+QpHD/CXVD/wd0Qf8Fcj7/A3E8/wFwO/8Abzn/AG85/1ikgv+Dv6f/isOs/yWG + WP8AbTjiAGYzDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAK + GHsDBAT8DAwM/xYWFv8iIiL/Ly8v/zs7O/9HR0f/U1NT/11dXf9jY2P/YWFh/1hYWP9ERUf1EEc7fQBt + Od8Abzn/AG86/wFwO/8Abzn/CnVC/zaOYv+Ysob/eLDY/zuk//9irun/obeW/0ORY/8ihlr/IIRX/x2C + Vf9nnmn/T5Rh/6izev+Uh2f/TkxJ/1NQT/9aV1b/jIFs/1KSW/8HdEH/BnNA/wRyPf8BcDv/AG85/wBv + Of8QeUb/hcGo/5TJs/+Ev6b/AnA7/wBtN5cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAoYewMEBPwMDAz/FhYW/yIiIv8vLy//Ozs7/0dHR/9TU1P/XV1d/2Nj + Y/9hYWH/WFhY/y9IQ/8Abzn/AG86/wBvOv8BcDv/H4JU/3Gldv+YtrL/PqD2/zyh+/+Ut73/e6Z1/yyK + Xv8lh1z/I4Za/yyJXP+OrHT/caFs/7OneP9iXFH/UE1M/1dUU/9dWln/ZGFf/2pnZv+rpXv/FnpG/wZz + QP8Fcj3/AnA8/wBvOf8Abzn/IIJU/4zErP9/vKH/IoRV/wBvOf8AbTd7AAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAChh7AwQE/AwMDP8WFhb/IiIi/y8v + L/87Ozv/R0dH/1NTU/9dXV3/Y2Nj/2FhYf86Tkz/AW87/wBvOf8Od0X/SJZq/5azkP9VpN3/HJb//1qn + 4/+itpL/RpRo/yyLYP8pil//Jodc/yeHW/+YsHj/na14/42AZP9OTEr/VFFQ/1pYVv9hXl3/Z2Rj/25q + af9yb27/QnZX/wdxO/8FcT7/BXI+/wJwPP8Gcz//VKJ//5XJtP9Pn3r/AnA7/wBtNtsAbTg/AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAK + GHsDBAT8DAwM/xYWFv8iIiL/Ly8v/zs7O/9HR0f/U1NT/11dXf9jY2P/PlVR/wNxPP8oiFv/gKt9/4Kw + uf8Mj/n/FJP5/4yzuP93pnX/Mo9l/zCNZP8ti2H/Kopf/yeIXP8oiFz/tK97/11YT/9QTkz/WFVU/15b + Wv9kYWD/a2dm/3Fubf9dcmX/FXFD/wBvOf8Abzn/AW84/wJwOv8lhlj/hcCn/3q6nf8Yfk3/AG84+gBu + OIsAbSQHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAoYewMEBPwMDAz/FhYW/yIiIv8vLy//Ozs7/0dHR/9TU1P/XV1d/z5W + Uf9UnXP/oLeW/zub4/8Ai///SKDc/5Sxj/9MmG7/NpFo/zOPZf82j2X/f6h1/0WUZv8xi2D/JYdb/4Kn + cv9rZFr/W1hX/2JfXf9oZGP/bmtq/29xbP83cVP/Am45/wBvOf8Abzr/AG86/wBvOf8siV3/k8iy/0WZ + cf8CcDv/AG03zwBuNzMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAChh7AwQE/AwMDP8WFhb/IiIi/y8v + L/87Ozv/R0dH/1VXWf+orbD/gJaX/wmN+/8UkfX/i7Kz/3Wnef88lW3/OZJq/zaRaP9Smmz/l7F8/4Sq + d/+xoHX/jql2/yaHXP8qiFv/qah5/2djYf9saGf/cm5t/1pyZP8Qb0H/AG85/wBvOv8BcDv/AXA7/wFw + O/8Abzn/AnA6/w94Rf8AbTn2AG44fwBVAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPz8EAG04cAA9 + J/kDBQX/DAwM/xYWFv8iIiL/Ly8v/zc6PP9oa2//1NTT/9DQ0P9ek7b/mrWL/02bdP9AlnD/PZVu/0OW + bf9loHL/obR+/6Guev98clz/TktK/5KFav9WmGj/JIZa/02VZP+flHn/bnJs/y9wUP8Abzn/AG85/wBv + Ov8Abzr/AG85/wBvOv8BcDv/BHI+/wFvOv8AbTj0AG0wKgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAbzonAG44xwBvOf8Abzn/AUIr/wMSEv8KFxf/FiMj/yowMP+mqq7/kZGR/3p6ev+1tbX/bI9y/0aa + dP9DmXP/Rphx/1iec/91pnf/srqD/5+Vb/9UUEv/UU9O/1lWVf9fXFv/qqh7/yqJXf8ihln/YZhj/w9x + P/8Abzn/AG86/wFwO/8Abzn/AXA7/wRxPv8Abzr/B3NA/wt3Rf8Ld0X/AG85/wBtN3cAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAA/PwQAbjh/AG439wBvOf8Abzr/AXA7/wBvOf8dflL/Z6J6/5e3oP8lqub/arPX/+Li + 4v+Tk5P/wcHB/4yRj/9QknT/YKJ4/22mef+Pr37/v7SA/3duWv9PTEv/VVNR/1xZWP9jX17/aWZk/4J7 + cP+ApHD/DHZD/wBvOf8Abzn/AXA7/wBvOv8Abzn/BnM//wl1Qv8Gc0D/AnA8/wd0QP8Re0v/FX5P/wp2 + RP8Abjf3AG80JwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvNzcAbTfPAG85/wBvOv8BcDv/AG86/wp1Qf9Almz/nbiK/4G4 + z/8iq///J6/w/5i7pP+OrZb/cZ2J/+jp6P/X19f/i5CO/3SceP+ruYP/nZFt/1JPSv9SUE//WVZV/19d + W/9mY2L/bWlo/3Nvbv9Lclz/DXI+/wBvOf8Abzr/AXA7/wBvOf8Dcj3/C3dF/2eZZP/Ov5v/g6Vu/wVy + Pv8Bbzr/FH1O/x2CVv8hhVj/BXI9/wBsOMMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF8fCABuOIsAbTf7AG85/wBvOv8BcDv/AXA6/yOF + V/9yqn//pLuq/1Oq8v88qf//hLnL/5q3iv9VpH7/UaN+/1Chff9ypo7/5+no/9fX1/+PkY7/enFh/09M + S/9WU1L/XVpY/2NgX/9qZmX/cG1r/2lxa/8kcEr/AG85/wBuOf8Mb0D/OIJf/26iif+WuKj/sMi8/7nO + xP/R1sv/2trY/8rMuv9XlXj/H3ZM/wlwP/8mh1z/LItg/yOFWP8Abzn/AG05awAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG04PwBtOdsAbzn/AG86/wFw + O/8Abzn/DHdD/0iacP+at4//a6vS/yqb//9Zqez/qryh/2yqgP9Ro37/UaN+/1Gjfv+GsYP/V6N8/3Kl + jv/n6ej/19fX/5CQjv9fXFv/YF1c/2djYv9tamn/dHBu/0ZyWv8Gbzv/A205/zuCYP+duaz/4ufl//b2 + 9v/z8/P/6enp/+Dg4P/a2tr/3Nzc/+Tk5P/u7u7/9vb2//Lz8//F08z/f6mW/0uQbf87k2z/F31N/wBt + N/IAajkfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG83ewBv + Of8Abzn/AG86/wFwO/8BcDr/KIhb/3asgP+PtLD/GJLz/wuP/f+GssL/kbSG/1Ojfv9Ro37/UaN+/2Gn + f/+guIb/h7GD/8Cxf/+as4H/cKSN/+fp6P/X19f/j4+N/2tpZ/9xbWz/ZHJp/x1xRv8AbTj/OoBe/7TF + vf/r7Ov/5eXl/9HR0f+8vLz/rq6u/6enp/+kpKP/o6Kh/6Kiof+ko6P/qKen/7Gysv/FxcX/29vb/+zs + 7P/n5+b/wsGx/0yUdP8Hcz//AG83kwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABvOZcAbzn/AXA7/wFwO/8BcDv/BXI9/0med/9xq4H/XKXR/zeb5P+euJz/aKmA/1Gj + fv9Ro37/WKR+/3Grgf+pu4f/qbeE/5KEZv9OTEn/k4hr/2mmfP9uo4z/5+no/9fX1/+Ojo3/UG9e/zts + U/9LbVz/lKie/+Lj4v/f39//zMzM/7y8vP+5uLf/wb+7/9HMxf/e2M//59/U/+vi1//r4dX/5tzQ/9zS + x//Oxrz/vrq0/7i3tf/AwMD/1NTU/+Xl5f/S1tT/TIls/wFrNoIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZjMPAG044gBvOf8BcDv/AXA7/wFvOv8af0//UaN+/5i2 + if+PtIT/UaN+/1Gjfv9Ro37/ZqiA/3qugv+yvYj/qaV5/2JcUv9QTkz/V1VT/19cWv+urX//Spx3/22j + i//o6un/ycnJ/5+goP+EhIT/wMDA/97e3v/V1dX/ycnJ/8XDwv/X0sz/7+jf//ry6P/88+j//PLn//zy + 5f/88eT/+/Di//vv4P/779//++7d//jq2P/q3Mz/0ci8/8PBvf/Ly8v/29vb/9zd3P+nsau+S0tLEQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtNk8Abzn/AG86/wNx + Pf8HdEH/A3I9/zaRZ/9Ro37/UaN+/1Gjfv9hp4D/eK2C/4axg//Fvof/in5j/01KSf9UUVD/W1hX/2Fe + Xf9oZGP/hH1v/5Cvfv8ig1X/UYht/+Dg4P+1tbX/zMzM/9ra2v/X19f/zs3N/9fTzv/z7OT//PXr//z0 + 6v/88+j//PLn//zy5f/88eT//PDi//vv4P/779//++7d//vt2//77Nr/+uvY//nq1f/s3cr/0ci8/8/O + zP/Y2Nj/2tra/5mtpPIMajygAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAG44qwBvOf8IdUL/DnhH/xB6Sv8KdUL/S595/1Gjfv9Ro37/gbCC/5+4hv+xonb/XVhP/1FO + Tf9YVVT/Xlta/2VhYP9raGf/cm5t/11yZf8bdkP/AG85/4Golf/g4OD/ysrK/9fX1//c3Nz/0tHQ/+fh + 2//89ez//PXr//z06v/88+j//PLn//zy5f/88eT/+/Di//vv4P/779//++7d//vt2//77Nr/+uvY//rq + 1v/66dT/+ujT//flz//e0L7/09DM/9vb2//V1dX/jaaa/wtnOVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABrNRMAbzfqBXI+/xN9Tv8YgFL/FHxM/w94Rf8VfEv/KYlc/4ux + gv+PgmX/TktK/1RSUP9bWFf/Yl9d/2hlZP9va2r/b3Ft/zNxUv8Abzn/AG85/wBvOv+dsaf/xMTE/9PT + 0//h4eH/19bT/+7o4f/89u3//PXr//z06v/88+j//PLn//zy5f/88eT/+/Di//vv4P/7797/++7d//vt + 2//77Nr/+uvY//rq1v/66dT/+ujT//rn0f/558//+OXN/+XUvv/X1M//39/f/9DQ0P9yk4P1AFAoEwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG44XwBvOf8Re0v/IYVY/yeI + XP9voGz/mLB9/zGIWf8kgk//qZ93/1hVVP9fXFr/ZWJh/2xoZ/9yb23/VnNi/xBwQf8Abzn/AG86/wFw + O/8Abjj/kZ6Y/8zMzP/k5OT/29rY/+7p4v/99u3//fXr//z06v/88+j//PLn//zy5f/88eT//PDi//vv + 4P/77t//++7d//vt2//77Nr/+uvY//rq1v/66dT/+ujT//rn0f/55s//+ebN//jly//45Mn/5NO8/9zZ + 1f/e3t7/xsfG/01/Z8IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAbTezAnA7/yeHXP8vjWP/1MOg/9POyf+RsX7/FHtK/3urfP+Jf2v/aWVk/29sav9ucmz/LXBO/wBv + Of8Abzn/AG86/wBvOv8BcDv/P4Fi/8LDwv/g4OD/4+Lh/+nk3f/89u3//PXr//z06v/88+j//PLn//zy + 5f/88eT/+/Di//vv4P/779//++7d//vt2//77Nr/+uvY//rq1v/66dT/+ujT//rn0f/55s//+ebN//nl + zP/45Mr/+OPI//fixv/fzrn/5eTj/9XV1f+ytrT2VVVVHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAGo5HwBtN/ITe0n/OJJq/6S4h//LyqD/aqZ8/x+CU/9CmXH/rLSE/3p0 + cP9Qcl//Cm89/wBvOf8Abzr/AXA7/wBvOf8Od0X/R5No/6espv/Ozs7/7Ozs/+Dc1//89ez//PXr//z0 + 6v/88+j//PLn//zy5f/88eT/+/Di//vv4P/779//++7d//vt2//77Nn/+uvY//rq1v/66dT/+ujT//no + 0v/559H/+efP//nlzP/45Mr/+OPI//jix//44cT/9d7B/9vQwf/q6ur/x8fH/5ubm5oAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcDlrAG85/y+MYf9Hm3b/TJ96/0ec + df8QeUf/T6J9/1ahd/86gFD/AG85/wBvOf8BcDv/AG86/wNxPP8oiFv/gKt9/4Cgpv+8vb3/5eXl/+Lh + 3v/17ub//PXr//z06v/88+j//PLn//zy5f/88eT//PDi//vv4P/77t//++7d//vt2//77Nr/+uvY//rq + 1v/66dX/+unU//rp1P/56dP/+enT//np0//56dP/+ejS//jlzP/44cT/+OHD//fgwf/p1Lb/5eHd/9ra + 2v+2trb1UlJSHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABv + OMMIdED/Kold/zmTav8+lm3/D3lG/zGOYv8FcTz/AG85/wBvOv8BcDv/AG85/xV8S/9UnXP/oLeW/zub + 4/9vmbz/yMjI//Hx8f/k39j//PXr//z06v/88+j//PLn//zy5f/88eT/+/Di//vv4P/779//++7d//vt + 2//77Nr/+uvY//rq1v/66dX/+unU//rp1P/56dP/+enT//rp0//56dP/+enU//rq1f/66tb/+enT//jh + xf/337//9t29/97Qvv/u7u7/wMDA/5GRkX4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAbzonAG450gBtN/IAbzn/AG85/wNwPP8Abzn/AG85/wFwO/8Abzr/BXI9/zGO + Y/9sqH7/j7K0/wmN+/8Wiuf/q62t/9ra2v/p6Ob/8uvi//z06v/88+j//PLn//zy5f/88eT/+/Di//vv + 4P/779//++7d//vt2//77Nn/+uvY//rq1v/66dX/+unU//rp1P/56dP/+unT//np0//56dP/+enU//rq + 1f/66tb/+uvX//rs2f/67Nn/9+HD//fdvP/mz7H/7evp/9DQ0P+jo6PRAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPz8EAG44wgBuOP8Abzn/AG86/wFw + O/8Abzn/GoBP/1ujev9QoX3/T597/5y3oP9Uo9f/j6OE/7q6uv/r6+v/4+Db//vz6f/88+j//PLn//zy + 5f/88eT//PDi//vv4P/77t//++7d//vt2//77Nr/+uvY//rq1v/66dX/+unU//rp1P/56dP/+enT//np + 0//56dP/+enU//rq1f/66tb/+uvX//rs2f/67Nr/++3c//rt2//33r7/8ti2/+Pb0P/h4eH/srKy+k1N + TSEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzonAG03zQBv + Of8Abzn/AXA7/wBvOv8IdED/OJJn/5e2h/+Qv7j/ga+C/02gfP9opn3/dKl9/2iUgP+8vLz/9PT0/+Tf + 2P/78+j//PLn//zy5f/88eT/+/Di//vv4P/779//++7d//vt2//77Nr/+uvY//rq1v/66dX/+unU//rp + 1P/56dP/+enT//rp0//56dP/+enU//rq1f/66tb/+uvX//rs2f/67dr/++3d//vu3v/77+D/+ujU//Xa + t//h0b7/7+/v/7m5uf98fHxYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/ + PwQAbjh/AG439wBvOf8Abzr/AXA7/wBvOf8eglP/bKh9/529pP8mr+z/AKn//6jAo/9ToXz/TJ55/0qc + eP94mIn/w8PD//T09P/q4tn//PLn//zy5f/88eT/+/Di//vv4P/779//++7d//vt2//77Nn/+uvY//rq + 1v/66dX/+unU//rp1P/56dP/+unT//np0//56dP/+enU//rq1f/66tb/+uvX//rs2f/67Nr/++7d//vu + 3v/77+D//PDj//vy5f/23r3/4Myw//b29v+9vb3/kJCQgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABvNzcAbTfPAG85/wBvOv8BcDv/AG86/wp1Qf9Almz/nbiK/4G4z/8iq///J6/w/5q9 + pv9xq4H/T6F8/0yfev9KnXj/gpqQ/8rKyv/w7+7/7ubb//zy5f/88eT/+/Di//vv4P/77t//++7d//vt + 2//77Nr/+uvY//rq1v/66dX/+unU//rp1P/56dP/+enT//np0//56dP/+enU//rq1f/66tb/+uvX//rs + 2f/67Nr/++3c//vu3v/77+D/+/Dj//zy5f/88+j/+efQ/+PKqv/19fT/xMTE/5eXl6AAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAF8fCABuOIsAbTf7AG85/wBvOv8BcDv/AXA6/yOFV/9yqn//pLuq/1Oq + 8v88qf//hLnL/5q3iv9VpH7/UaN+/1Chff9Nn3r/Sp54/4Wbkf/MzMz/7ezq//Ho3P/88eT/+/Di//vv + 4P/779//++7d//vt2//77Nr/+uvY//rq1v/66dX/+unU//np1P/56dP/+enT//rp0//56dP/+enU//rq + 1f/66tb/+uvX//rs2f/67dr/++3d//vu3v/77+D/+/Dj//zy5f/88+j//PTr//vv3//kyqj/9PPx/8nJ + yf+bm5uuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG04PwBtOdsAbzn/AG86/wFwO/8Abzn/DHdD/0ia + cP+at4//a6vS/yqb//9Zqez/qryh/2yqgP9Ro37/UaN+/1Gjfv+GsYP/V6N8/02eef+EnJL/y8vL/+3s + 6v/x59v/+/Di//vv4P/77t7/++7d//vt2//77Nr/+uvY//rq1v/66dX/+unU//rp1P/56dP/+unT//np + 0//56dP/+enU//rq1f/66tb/+uvX//rs2f/67dr/++7d//vu3v/77+D//PDj//zy5f/88+j//PTr//32 + 7f/89ev/5Mmm//Py8f/Kysr/m5ubsQAAAAAAAAAAAAAAAAAAAAAAAAAAAG83ewBvOf8Abzn/AG86/wFw + O/8BcDr/KIhb/3asgP+PtLD/GJLz/wuP/f+GssL/kbSG/1Ojfv9Ro37/UaN+/2Gnf/+guIb/h7GD/8Cx + f/+as4H/fZmN/8bGxv/w7u3/7+TW//vv4P/77t//++7d//vt2//77Nn/+uvY//rq1v/66dX/+unU//rp + 1P/56dP/+enT//np0//56dP/+enU//rq1f/66tb/+uvX//rs2f/67Nr/++7c//vu3v/77+D/+/Dj//zy + 5f/88+j//PTq//327f/99/D//ffw/+LJqP/19PT/xsbG/5mZmagAAAAAAAAAAAAAAAAAAAAAAAAAAABv + OZcAbzn/AXA7/wFwO/8BcDv/BXI9/0med/9xq4H/XKXR/zeb5P+euJz/aKmA/1Gjfv9Ro37/WKR+/3Gr + gf+pu4f/qbeE/5KEZv9OTEn/k4hr/36bh/+/v7//8/Ly/+nf0f/779//++7d//vt2//77Nr/+uvY//rq + 1v/66dT/+unU//np1P/56dP/+enT//rp0//56dP/+enU//rq1f/66tb/+uvX//rs2f/67dr/++3d//vu + 3v/77+D/+/Dj//zy5f/88+j//PTr//327f/99/D//fjy//348f/hyqz/9/f3/7+/v/+RkZGMAAAAAAAA + AAAAAAAAAAAAAAAAAAAAZjMPAG044gBvOf8BcDv/AXA7/wFvOv8af0//UaN+/5i2if+PtIT/UaN+/1Gj + fv9Ro37/ZqiA/3qugv+yvYj/qaV5/2JcUv9QTkz/V1VT/19cWv+enX//urq6/+/v7//k29D/++7d//vt + 2//77Nr/+uvY//rq1v/66dT/+unT//rp1P/56dP/+unT//np0//56dP/+enU//rq1f/66tb/+uvX//rs + 2f/67dr/++7d//vu3v/77+D//PDj//zy5f/88+j//PTr//327f/99/D//fjy//759f/89u3/4M63//Ly + 8v+6urr/hISEZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtNk8Abzn/AG86/wNxPf8HdEH/A3I9/zaR + Z/9Ro37/UaN+/1Gjfv9hp4D/eK2C/4axg//Fvof/in5j/01KSf9UUVD/W1hX/2FeXf9oZGP/fHZq/7Kz + sv/g4OD/49zV//ns2v/77Nn/+uvY//rq1v/66dT/+ujT//ro0v/56dP/+enT//rp0//56dP/+enU//rq + 1f/66tb/+uvX//rs2f/67Nr/++7c//vu3v/77+D/+/Dj//zy5f/88+j//PTr//327f/99/D//fjy//76 + 9f/++/f/9+vb/+LYy//m5ub/tra2/WFhYS8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG44qwBv + Of8IdUL/DnhH/xB6Sv8KdUL/S595/1Gjfv9Ro37/gbCC/5+4hv+xonb/XVhP/1FOTf9YVVT/Xlta/2Vh + YP9raGf/cm5t/3Zycf+lopz/zs7O/+jl4v/x49L/+uvY//rq1v/66dT/+ujT//rn0f/56NH/+unT//rp + 0//56dP/+enU//rq1f/66tb/+uvX//rs2f/67dr/++3d//vu3v/77+D/+/Dj//zy5f/88+j//PTr//32 + 7f/99/D//fjy//759f/++/f//vz5/+nYwf/t6+f/1NTU/6ioqOIAAAAIAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABrNRMAbzfqBXI+/xN9Tv8YgFL/FHxM/w94Rf8VfEv/KYlc/4uxgv+PgmX/TktK/1RS + UP9bWFf/Yl9d/2hlZP9va2r/dXFw/3h0c/+Ui3r/saeK/8DAwP/r6+v/4tfJ//nq1v/66dT/+ujT//rn + 0f/558//+efQ//np0//56dP/+enU//rq1f/66tb/+uvX//rs2f/67dr/++3d//vu3v/77+D//PDj//zy + 5f/88+j//PTr//327f/99/D//fjy//759f/++/f//vz5//379//ezLb/8PDw/8PDw/+ZmZmUAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG44XwBvOf8Re0v/IYVY/yeIXP9voGz/mLB9/zGI + Wf8kgk//qZ93/1hVVP9fXFr/ZWJh/2xoZ/9yb23/d3Ry/4B6df+vpYH/xMKJ/2KbdP+tsa7/2NjY/+Hd + 1//y487/+ujT//rn0f/558//+ebN//nmzf/56dP/+enU//rq1f/66tb/+uvX//rs2f/67dr/++7c//vu + 3v/77+D/+/Dj//zy5f/88+j//PTr//327f/99/D//fjy//769f/++/f//vz5//79+//v4tD/5N/Y/9/f + 3/+5ubn7ZGRkMwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbTezAnA7/yeH + XP8vjWP/1MOg/9POyf+RsX7/FHtK/3urfP+Jf2v/aWVk/29sav91cnD/eHRz/5mOe/+1t4b/rbuH/1KZ + av8pg1D/gKGT/8bGxv/n5+f/39TF//nn0P/558//+ebN//nly//45Mr/+enT//rq1f/66tb/+uvX//rs + 2f/67dr/++7c//vu3v/77+D/+/Dj//zy5f/88+j//PTr//327f/99/D//fjy//769f/++/f//vz5//79 + +//8+PT/28y4/+zs7P/Jycn/oqKitgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAGo5HwBtN/ITe0n/OJJq/6S4h//LyqD/aqZ8/x+CU/9CmXH/rLSE/3p0cP93dHL/gXx2/7us + hP+guIb/pLiE/y2GU/85kmf/jMSs/2SliP+jrqn/0tLS/+Lg3P/n18L/+ObN//jly//45Mr/+OPI//jm + zv/66tb/+uvX//rs2f/67dr/++3d//vv3v/77+D//PDj//zy5f/88+j//PTr//327f/99/D//fjy//75 + 9f/++/f//vz5//79+//+/fz/4tG9/+Xj4f/Z2dn/vb2992lpaTMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcDlrAG85/y+MYf9Hm3b/TJ96/0ecdf8QeUf/T6J9/2Gn + f/+wpoL/npN8/8G9iP9/r4L/daNu/xd9TP9usZT/hsCn/zCMYP8Abzn/OHhXzMbGxvvb29v/2tXO/+za + wv/45Mr/+OPI//jixv/44sX/+erW//rs2f/67dr/++7c//vu3v/77+D/+/Dj//zy5f/88+j//PTr//32 + 7f/99/D//fjy//769f/++/f//vz5//79+//+/v3/6drI/9vWz//h4eH/ycnJ/pqamosAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvOMMIdED/Kold/zmT + av8+lm3/D3lG/06he/9Ro37/hLCD/6u7h/9ppnn/Q4tU/0GXb/+Oxa7/X6mH/wl0Qf8AbzfqAG44XwAA + AAGhoaGQzs7O/t3d3f/W0Mf/6ti///jixv/44cT/+ODD//jjyP/67Nr/++7c//vu3v/77+D//PDj//zy + 5f/88+j//PTq//327f/99/D//fjy//759f/++/f//vz5//79+////v3/6drI/9bNw//g4OD/0dHR/7Cw + sMZFRUULAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAbzonAG450gBtN/IAbzn/AG85/wx2Q/8oiFv/UaN+/0+hfP8ujF7/L4ZV/3K1mP+Ev6X/JoZY/wBv + Of8AbjirAGs1EwAAAAAAAAAAKioqBq2trazU1NT+29vb/9HMxf/k0Lj/9+DC//fgwv/337//+OPI//ru + 3v/77+D//PDj//zy5f/88+j//PTr//327f/99+///fjy//759f/++/f//vz5//79+//8+vb/4NC7/9HL + xP/c3Nz/1dXV/8DAwNtiYmIfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG85kwFwOv9iqov/G4BQ/zSQZv8Te0r/SJt1/5DG + r/9ToX7/B3M+/wBtOOIAbDZLAAAAAAAAAAAAAAAAAAAAAAAAAAAzMzMKsrKyqtnZ2f7a2tr/zsvI/9TG + sv/u2Ln/9t6+//fdvP/34MH/+uza//zy5v/88+j//PTr//327f/99/D//fjy//759f/++/f//vz6//78 + +f/w5NT/0MGs/87Myf/Y2Nj/2tra/8XFxdlra2smAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG02HABuN/c2kGf/fbyi/26z + lf8nh1r/ebmd/3+8ov8hg1X/AG85/wBuNpsAZjMPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoq + KgaqqqqL29vb+t7e3v/Ozc3/xL61/9XDrP/r0rL/9dq4//bbuP/34cT/+uvX//zy5v/99u///fjy//75 + 9P/9+PH/+e/j/+vbxf/Rv6j/wruz/8vLy//a2tr/39/f/729vcJmZmYeAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABq + OCQAbzj6PpVt/4fBqf+Oxq7/ksix/0ydeP8CcDr/AG043wBtOD8AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAZWVlU3Pz8/d5ubm/tvb2//FxcX/ubWw/8C1pv/PvKT/3MSm/+XK + p//ozKj/6M2q/+TKqf/aw6T/zLif/72xoP+3tK//wMDA/9XV1f/l5eX/3Nzc9aurq4Q4ODgJAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAG84hwJwOv92t5r/dbaa/xyAUP8Abzj6AG44iwBtJAcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAT09PELOzs33c3Nzn7+/v/ubm + 5v/R0dH/vLy9/62trP+mpKL/o6Cd/6Kgnf+lo6H/q6qq/7e3t//Jysr/39/f/+3t7f/o6Oj2xcXFrH9/ + fy4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtJAcAbjfXDndE/wJwOv8AbDfTAG83NwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAVFRUErCwsGHS0tK36urq7/j4+P75+fn/8/Pz/+7u7v/s7Oz/8PDw//b29v/6+vr/8fHx+d3d + 3dXDw8OIeXl5LAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHA4OwBt + N/IAbjh/AFUAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUhISBWbm5tAxMTEbdLS0onX19ea2NjYntXV + 1ZTIyMh5sLCwVHJyciYAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD///////9//////////D/////////wH//+f////+Af//w/////gA//+B////8A + D//wD////AAH/+AH///4AAP/wAP//+AAA//AAf//wAAB/+AA//8AAAD/8AB//gAAAf/4AD/4AAAB//wA + H+AAAAA//gAPwAAAAD//AAcAAAAAH/+AAgAAAAAP/8AAAAAAAB//4AAAAAAAP//wAAAAAAB///gAAAAA + Af///AAAAAAH///8AAAAAA////AAAAAAD///4AAAAAAH//+AAAAAAAP//gAAAAAAA//8AAAAAAAB//gA + AAAAAAD/8AAAAAAAAP/4AAAAAAAA//wAAAAAAAA//AAAAAAAAD/+AAAAAAAAH/8AAAAAAAAP/wAAAAAA + AA//gAAAAAAAB//AAAAAAAAH/8AAAAAAAAf/4AAAAAAAA//4AAAAAAAD//AAAAAAAAP/4AAAAAAAAf+A + AAAAAAAB/gAAAAAAAAH8AAAAAAAAAfgAAAAAAAAB8AAAAAAAAAH4AAAAAAAAA/wAAAAAAAAD/AAAAAAA + AAP+AAAAAAAAA/8AAAAAAAAH/wAAAAAAAAf/gAAAAAAAD//AAAAAAAAP/8AAGAAAAB//4AA8AAAAP//4 + AP4AAAB///gB/wAAAP//+Af/wAAB///4D//wAAf///w///wAH////v///8P//ygAAABgAAAAwAAAAAEA + IAAAAAAAACABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAVQADAG04SABuNsAAbjf4AG44ywBrNSYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAD8ABABrNSYAbzijAG04+QBvOf8Abzn/AG85/wBuOKsAVSoGAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCRs2OAcV + JEYAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbTYOAG44XwBuOckAbzn/AG85/wBv + Of8Abzn/AG85/wBvN/gAbjdTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAMgMUVnQkhM7UJDRvscJTHFAAMGTgAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABt + NhwAbTijAG046wBuOP4Abzn/AG86/wBvOv8Abzr/AG85/wBuOP4AbjfFAGoxJAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyUzR2dUV1nvXFxc/1VVVf9ISUr8Ii03swAG + DSYAAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAaC4WAG43agBuOOcAbzn/AG85/wBvOf8BcDv/AXA7/wFwO/8BcDv/AXA7/wBv + Of8AbTf7AG04lQB1Og0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACHS9FYFVY + WvJlZGT/YWFh/2ZmZv9RUVH/RERE/SIvPJ0ADy8QAAAAAgAAAAEAAAABAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8/BABwODIAbjirAG438wBvOf8Abzn/AG86/wFw + O/8Abzr/AG86/wFwO/8BcDv/AXA7/wFwO/8Abzn/AG046wBuN1MAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAMdL0BnS01Q811dXf9jY2P/b29v/1paWv9aWlr/XV1d/0VFRf0hLzyhAA8vEAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaioMAG83bgBu + OdIAbzn/AG85/wBvOv8Abzr/AG86/wBvOf8Abzn/AG85/wBvOv8BcDv/A3E9/wVzP/8CcTz/AG85/wBt + ONQAcTgJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxgnO2c8QUXvT09P/1hYWP9nZ2f/XFxc/2Nj + Y/9paWn/UlJS/1lZWf9LS0z7JC88oQASNg4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAF8fCABvNzcAbjnAAG85/wBvOf8Abzn/AG86/wBvOv8Abzr/AG85/wFvOv8DcD3/AW86/wFv + Ov8Fcj7/CHRB/wp3RP8Ld0X/A3E8/wBuOP4AbjiNAF8fCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDx80YTAy + NfJAQD//SEhI/1tbW/9SUlL/W1tb/2xsbP9ZWVn/aGho/11dXf9PTk7/SkpL/SIvPpwAEjYOAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbTYcAG03ewBtOdsAbzn/AG85/wBvOv8BcDv/AXA7/wBv + Ov8Abzn/A3E9/wZzQP8Gc0D/A3E9/wBvOv8HdED/DHdF/w55SP8Re0v/C3dF/wFwOv8AbTjiAGw2SwAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAPwQJGi5oHyIl8i8vLv84ODj/S0tL/0JCQv9PT0//YGBg/1FRUf9paWn/ZWVl/1lZ + Wf9mZmb/UFBQ/0RERf0mMT+hAA8vEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABuNy4AbjbEAG449QBv + Of8Abzn/AG86/wBvOv8Abzr/AG85/wBvOv8HdED/CXZD/wl1Q/8HdEH/BnNA/wFwO/8Dcj3/DnlI/xJ8 + TP8Vfk//F39Q/wl1Qf8AbTj9AG03swBxOBsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgQWKWgTFhjvHh4e/ycnJ/85OTn/MzMz/z8/ + P/9RUVH/RkZG/15eXv9eXl7/Wlpa/29vb/9ZWVn/XFxc/1xcXP9GRkf7JC88oQASNg4AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAbTYqAG44iwBuOPAAbzn/AG85/wBvOv8BcDv/AG86/wBvOv8BcDr/BXM//wt3Rf81h1P/sbaA/9nG + lf+PqXL/GXpH/wVyPv8Bbzr/CnZE/xd+UP8bgVT/H4RW/x+DVv8DcTz/AG85/wBuN4oAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMrQAcJ + DfEPDw//FxcX/ygoKP8lJSX/Li4u/0JCQv83Nzf/T09P/1FRUf9PT0//aWlp/1paWv9jY2P/ampq/1BQ + UP9aWlr/SUpK/SItPJwAEjYOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAF8fCABuOUwAbjjHAG03+wBvOf8Abzr/AG86/wFwO/8Abzr/AG86/wNx + PP8KdkT/DnhH/w55R/94oWz/zcCk/8bCvv/Nx53/TI9Y/wVyP/8CcDv/A3E8/xV9Tf8hhFj/JIdb/yiJ + Xf8Zf1D/AW86/wBuOOwAbDYvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAABElZgMDA/4JCQn/FhYW/xUVFf8fHx//MDAw/ycnJ/8/Pz//QkJC/0BA + QP9bW1v/T09P/11dXf9qamr/WFhY/2pqav9cXFz/Tk5O/0VFRf0kLz2hAA8vEAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbTAVAG44iABtOOIAbzn/AG85/wBv + Ov8Abzr/AG86/wBvOf8Bbzr/CHRB/w55SP8egE7/D3lI/w55R/9tnWj/282v/9/b1v/NyJr/RYxW/wZz + QP8EcT3/AXA6/wh0Qf8mh1z/Kopf/y2MYv8ti2H/D3hG/wBuOP4AbjiwAGM4EgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMxGgAHEM4EBAX+CQkJ/xAQ + EP8eHh7/GRkZ/y4uLv8zMzP/MTEx/0tLS/9CQkL/Tk5O/2BgYP9TU1P/aWlp/2RkZP9YWFj/XFxc/1VV + Vf9HSEn7JC89oQASNg4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG8vEABu + N1MAbTbkAG85/wBvOf8Abzn/AXA7/wBvOv8Abzr/AG85/wRyPv8Zfkz/T5Ng/5e0i/+XsHv/G35M/w54 + R/8jgU3/i6lv/662ev9ommL/DHZC/wZzQP8Fcj3/A3A8/wBvOf8cgFP/MI5k/zySaP85kmr/L4xh/wp1 + Qv8Abzj1AG43fQBtJAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAXLiwABxDPAwMD/g0NDf8NDQ3/Gxsb/yMjI/8iIiL/Ojo6/zMzM/9AQED/UlJS/0VF + Rf9eXl7/Xl5e/1paWv9lZWX/YWFh/1tbW/9VVVX/RkdH/SItPJwAEjYOAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAazgyAG85kwBtN+8Abzn/AG85/wBvOv8BcDv/AG86/wBvOf8CcTz/C3dF/yaE + Uv+Ap3X/h7ir/0Cz4f96uLf/X5hi/xF6SP8NeEb/C3dF/wp2RP8JdUL/B3RB/wZzQP8Fcj7/A3A8/wBv + Of8jhFX/ZqFy/5uxf/+Aqnr/UJxz/yiHW/8Abzn/AG022wBvNTkAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEzMoAAcPywMDA/4LCwv/EhIS/xQU + FP8oKCj/JCQk/zAwMP9BQUH/NjY2/1BQUP9QUFD/Tk5O/11dXf9iYmL/ZGRk/2FhYf9bW1v/VVVV/0ZH + R/0kLz2hAA8vEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFUqBgBtOVQAbTfYAG04+QBvOf8Abzn/AG86/wBv + Ov8Abzr/AG85/wVyPv8Wfk3/SJJf/6K0gP9lt8v/F6z0/wGp/v80sOX/obeK/y6FUv8NeEb/C3dF/wp3 + Rf8JdkL/B3RB/wZzQP8Fcj//A3A8/wBvOf9RmGv/v7uO/8W6pv/QxaH/h69//0ebdf8QeUf/AG04/QBu + OGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAABMzKAAHDc8EBAT+BwcH/xUVFf8VFRX/Hx8f/zAwMP8oKCj/Pz8//0FBQf9BQUH/T09P/1dX + V/9dXV3/YmJi/2RkZP9hYWH/W1tb/1VVVf9HSEn7JC89oQASNg4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABVAAMAbzc3AG44qwBt + OPkAbzn/AG85/wBvOv8BcDv/AG86/wBvOf8Fcj7/EXpJ/zaKW/+IrH3/k760/x2u8f8Aqf//Dav4/0S0 + 3/+euJP/apxm/xl9S/8NeEb/DHhG/wt3Rf8JdkP/CHRC/wd0Qf8Fcj//A3E8/wBvOf9dnG7/0sWh/9LO + yv/h18L/m7aF/1ChfP8IdED/AG85+gBvN04AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXLiwABxDPBAQE/ggICP8QEBD/Hx8f/xoa + Gv8uLi7/MjIy/zExMf9AQED/R0dH/1BQUP9XV1f/XV1d/2JiYv9kZGT/YWFh/1tbW/9VVVX/RkdH/SIt + PJwAEjYOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAGYzFABuN2oAbjjVAG85/wBvOf8Abzr/AXA7/wBvOv8Abzn/AXA6/wp1Qv8ig1T/Ypto/5u2 + j/9ct9T/D6v4/wCp/v8jru//ebm8/5Gvf/85ilj/EHpK/w95SP8OeUf/DHhG/wt3Rf8JdkT/CXVC/wd0 + Qf8Fcj//BHI9/wFvOf80iln/r7yL/+DSrf/LyZ3/eq6E/0WadP8Abzn/AG842gBrOC0AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAEzMoAAcQywMDA/4MDAz/DAwM/x0dHf8hISH/ISEh/y8vL/83Nzf/Pz8//0dHR/9PT0//VlZW/11d + Xf9iYmL/ZGRk/2FhYf9bW1v/VVVV/0ZHR/0kLz2hAA8vEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbTYqAG44qwBvOPEAbzn/AG85/wBvOv8Abzr/AG86/wBv + Of8DcDv/E3tL/y2IWf+ZsXz/j7uz/z6y5/8Dqf7/Aan+/z6z4v+ju5r/ZZ1r/yWDUv8SfEz/EHpK/w95 + SP8OeUf/DHhG/wt3Rf8Kd0T/CXVC/wd0Qf8Gc0D/BXI+/wNxO/8Icz//PI5f/26off9tq4T/XKeF/zGN + Yv8Abzn/AG42qQByMxQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkzKAAHDc8DAwP+DAwM/xISEv8TExP/Hh4e/ycn + J/8vLy//Nzc3/z8/P/9HR0f/T09P/1dXV/9dXV3/YmJi/2RkZP9hYWH/W1tb/1VVVf9HSEn7JC89oQAS + Ng4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAG02HABvN2kAbTb2AG85/wBv + Of8Abzn/AXA7/wBvOv8Abzr/AnA7/w13Rf8viVz/bKBw/6+9mf9jtt//Iaz//xar/v81sOn/ibqy/5Wv + ev8khFX/FX5P/xR9Tf8SfEz/EHtL/xV8S/9YlV//FHtI/w95R/8Kd0T/CXVD/wd0Qf8Gc0D/BXI+/wRx + Pf8CcDv/AG85/wBvOf8Te0r/OJFo/xd9Tf8Abzn/AG42twBuOIsAbzmlAG45twBsN1cAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAX + LiwABg3PBAQE/gcHB/8PDw//FhYW/x4eHv8nJyf/Ly8v/zg4OP8/Pz//R0dH/1BQUP9XV1f/XV1d/2Ji + Yv9kZGT/YWFh/1tbW/9VVVX/RkdH/SItPJwAEjYOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAbjVMAG83swBuN/cAbzn/AG85/wBvOv8BcDv/AG86/wBvOv8Hc0D/GH9P/0qVZP+XsYP/krm6/1Ox + 7P8nqv//Ma34/2m41/+Xtpb/Zpxo/ySEVf8Wf1D/FX5Q/xR9Tf8dgE//P41a/yeDUf+isnf/dqFp/2ib + ZP8Ld0X/CXZD/wl1Qv8Gc0D/BXI//wVyPf8DcTz/AXA7/wBvOv8Abzn/CnVC/wVyPf8Abzn/AG85/wBv + Of8Abzn/AG85/wBuN+AAcjQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEzMoAAcQywMDA/4JCQn/Dw8P/xYWFv8eHh7/JiYm/y8v + L/83Nzf/Pz8//0dHR/9PT0//VlZW/11dXf9iYmL/ZGRk/2FhYf9bW1v/VVVV/0ZHR/0kLz2hAA8vEAAA + AAAAAAAAAAAAAAAAAAAAAAAAAGoqDABtN3IAbzjjAG04/QBvOf8Abzr/AG86/wBvOv8Abzr/AHA6/w94 + Rv8siV3/caJw/6+7kv9ws+D/QKv4/zKp/v9LsPD/or+z/4isf/85jFz/HYJU/xmBUv8XgFD/FX5Q/zGI + V/8ohFP/iKhw/12XYv+YrXT/t6h5/72vfP85iVT/CndE/wl1Qv8Gc0D/BnNA/wVyPv8EcTz/AXA7/wFv + O/8Abzn/AG85/wRxPP8af0//Kold/ziRaP9DmHH/GH5N/wBuOP4AbjmPAFUqBgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMzKAAG + Dc8DAwP+CQkJ/w8PD/8WFhb/Hh4e/ycnJ/8vLy//Nzc3/z8/P/9HR0f/T09P/1dXV/9dXV3/YmJi/2Rk + ZP9hYWH/W1tb/1VVVf9HSEn7JC89oQASNg4AAAAAAAAAAABxOAkAbTZPAG03zwBvOf8Abzn/AG85/wBv + Ov8Abzr/AG86/wBvOf8KdkL/JoZY/1aaa/+hto7/nrvB/0uq9f87qf7/Sqz1/3q21f+uuIT/WJhn/yGE + V/8dglX/G4JU/xmBUv8nhlX/LIdX/3Oha/9/pW7/b55o/8Gzfv+OgWT/UU5K/2RdVP+or3j/IoBM/wl1 + Q/8HdEH/BnNA/wVyPv8EcTz/AnA8/wFvO/8Abzn/AG85/wBvOf9Uon//fbui/4O/pv+Hwqr/YKqJ/w13 + RP8AbjfpAG02XQBVAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXLiwABg3PAwMD/gkJCf8PDw//FhYW/x4eHv8nJyf/Ly8v/zg4 + OP8/Pz//R0dH/1BQUP9XV1f/XV1d/2JiYv9kZGT/YWFh/1tbW/9VVVX/RkdH/SAuOpUAACQHAG83IABt + OIIAbTbtAG85/wBvOf8Abzr/AXA7/wBvOv8Abzn/BHE8/xZ9TP88kGL/gKp5/6e5ov9usN//Qab+/zym + /v9tsuH/m7mv/4ysfP85jl//IYVZ/x+DV/8dglX/H4NV/ymHV/9Kk2D/h6lx/0iRXv/SwYb/oZhv/25m + Vv9NSkn/UU9O/1ZSUf+Xjm//dZ9o/xJ5Rv8IdEH/BnNA/wVyP/8Ecj3/AnA8/wFvO/8Abzn/AG85/wBv + Of8dgVH/crWY/4jDq/+Oxa//i8Ss/z2VbP8Abzn/AG44xwBvNykAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEzMoAAcPywMD + A/4JCQn/Dw8P/xYWFv8eHh7/JiYm/y8vL/83Nzf/Pz8//0dHR/9PT0//VlZW/11dXf9iYmL/ZGRk/2Fh + Yf9bW1v/VVVV/z5BRvQGTDl0AG84wwBuN/cAbzn/AG85/wBvOv8Abzr/AG86/wBvOf8JdUH/JYZZ/0yX + a/+tuYj/j7XB/1On7/87pP7/RKb9/4m3z/+quZD/XJtr/y6KXf8jhlr/IoVZ/yCEV/8eglX/Oo1d/5Wu + dv8zi1n/mrB3/7+6gP+FemD/WVRN/09NS/9UUVD/V1VU/1xZWP9xbGP/q6Z5/zyKVP8IdEL/BnNA/wZz + QP8Ecj3/A3A8/wFwO/8Abzr/AG85/wBvOf8EcTz/RJhy/4nDrP+UybP/mMu2/4jBqP8Fcj7/AG03+wBu + OH8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAABMzKAAGDc8DAwP+CQkJ/w8PD/8WFhb/Hh4e/ycnJ/8vLy//Nzc3/z8/ + P/9HR0f/T09P/1dXV/9dXV3/YmJi/2RkZP9hYWH/W1tb/0tNT/4HWTr/AG85/wBvOf8Abzn/AXA7/wBv + Ov8Bbzr/BnM+/xl+T/9OmW7/jK6B/6+8p/9Tpuv/MZ7//zyh/P9srtz/q7ui/4mreP8wi1//J4hc/yWH + W/8jhlr/KIhb/yOGWf+QrHX/SpNh/5Csdf+7tn7/pJZw/15ZUP9OS0r/Uk9O/1ZUUv9bWFf/X11b/2Ng + X/9oZWT/jYNx/6iuef8SeEb/B3RB/wZzQP8Fcj7/A3E8/wJwPP8Abzr/AG85/wBvOf8KdUH/R5p0/47G + rv+TyLL/brGT/yGDVP8Abzn/AG837gBvOHUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXLiwABg3PAwMD/gkJ + Cf8PDw//FhYW/x4eHv8nJyf/Ly8v/zg4OP8/Pz//R0dH/1BQUP9XV1f/XV1d/2JiYv9kZGT/YWFh/1BT + Vv8HWTv/AG86/wBvOv8BcDv/AG86/wBvOf8Te0n/Lotf/2iidP+htpL/fa/I/zee9f8pmv//RaLy/461 + yf+cs4j/W5ts/zCMYf8pil//KIhd/yWHXP8mh1v/X5xq/1CVZf9rn2v/sLh+/6Smdf+EeWD/VVBL/09N + TP9UUlD/WVZV/11aWP9iXl3/ZWJh/2pmZf9ua2n/dHBu/5ybd/85h1D/CHM//wZzQP8Fcj//BHI9/wJw + PP8Abzr/AG85/xh+Tf9dp4b/kMev/4rDqv9Blm//DHZD/wBuOP4AbjnSAG05awBmMw8AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAEzMoAAcPywMDA/4JCQn/Dw8P/xYWFv8eHh7/JiYm/y8vL/83Nzf/Pz8//0dH + R/9PT0//VlZW/11dXf9iYmL/ZGRk/1VYWf8HXDz/AXA7/wBvOv8Abzn/A3E8/x6BUv9Hl23/lrJ//5e0 + qP8+nun/HZb7/x2X/v9fqOL/qbup/4esff9Bkmf/LYxi/yyLYP8pil//KIle/yaHXP8lh1r/Vphn/6S0 + fP+ksXr/ppdw/2lhVP9OTEv/UU9N/1ZTUv9bWFb/X1xb/2NgX/9oZGP/a2hn/3Bsa/9zcW7/VXFi/yBx + Rv8FcDr/C3M9/wVyPv8Fcj//BHE9/wFvO/8Fcj3/OJFn/3m4nf+XyrX/cbOW/yeGWf8BcDr+AG83+ABv + N7MAaTcpAGYzBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMzKAAGDc8DAwP+CQkJ/w8P + D/8WFhb/Hh4e/ycnJ/8vLy//Nzc3/z8/P/9HR0f/T09P/1dXV/9dXV3/YmJi/1VZW/8GXjz/AG86/wJw + O/8VfEv/QJRq/2+mev+nuZ3/X6bS/wmO+/8JkP3/Mpvv/4Wxv/+ktX//UJls/zKPZf8wjWT/Loxj/y2L + YP8ril//KYpe/yeIXP8lh1v/YZxq/8K2gP90a1n/S0lH/1BNTP9WU1L/WVdW/15aWf9iX17/Z2Ni/2pm + Zf9vbGv/cW9s/2RxaP8scU7/A245/wBvOf8Abzn/AG85/wJwO/8DcD3/BHE9/xh+Tf9ssZL/l8u1/4XA + pv80jmP/A3E8/wBtN/sAbjjHAG43UwBmMwUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAXLiwABg3PAwMD/gkJCf8PDw//FhYW/x4eHv8nJyf/Ly8v/zg4OP8/Pz//R0dH/1BQ + UP9XV1f/XV1d/1BWV/8FXTj/CXRB/yWGWf9dn3X/lLKH/46ysP8wmOj/Aov//wOM/v9To9f/m7Wi/4Sr + fP8+k2r/NJBm/zKPZf8xjmT/N49l/1iaa/8ril//KYpe/yeIXf8mh1z/ZJ1r/66md/9RTkz/UlBP/1dT + Uv9cWVj/YF1b/2RgX/9oZmT/bWlo/3FtbP9vcm3/S3Jc/xlvRf8Abzn/AG85/wBvOf8Abzn/AG85/wBv + OP8JdED/QZdv/327of+TyLH/YquJ/yGDVP8Abzn/AG836gBtOJoAbzcpAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEzMoAAcPywMDA/4JCQn/Dw8P/xYW + Fv8eHh7/JiYm/y8vL/83Nzf/Pz8//0dHR/9PT0//VFVW/4eOlv9jf3L/Nodi/3OofP+1vZX/WaTR/xSR + 9f8Ai/7/GZLz/4exvf+Wsov/XJ5y/z2Ta/82kWj/NJBm/zOPZf86kWb/PZFl/6e2fv9VmWr/SZVm/y6K + X/8mh1v/K4lc/5Sud/+FemT/WVZV/11aWf9iX17/ZmJh/2pmZf9ubGr/c29u/2lxa/8rcE3/Cm89/wFu + OP8Abzn/AG86/wBvOv8Abzr/AG85/wBuOP8ZfU3/fbqe/4vEq/8zj2P/DHZD/wBvOf4AbTjUAG43UwBv + LxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAABMzKAAGDc8DAwP+CQkJ/w8PD/8WFhb/Hh4e/ycnJ/8vLy//Nzc3/z8/P/9ERUb/b3V9/+rr + 6//U1dT/ipCE/46oo/8Ukff/AIv//w+P9/9WpNX/rLqW/3moev88lW3/O5Rs/zmSav82kWj/Q5Vq/zyT + aP+Ornr/gah2/3yndP/MuYL/wrR//2Gca/8mh1z/JYdb/zGLXf+2sX7/fHRm/2VhYP9qZmX/bWpo/3Ju + bf9scWv/RnJa/wxvPv8Abzn/AG85/wBvOf8BcDv/AXA7/wFwO/8BcDv/AXA7/wBvOf8Cbzr/JoVY/w14 + RP8Abzf8AG055ABuOJYAXz8IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvLzsAEBHnAwMD/wkJCf8PDw//FhYW/x4e + Hv8nJyf/Ly8v/zIzNP9ETFT/cnNz/7a2tv/t7e3/19fX/26Nof8Divr/MJno/4Owu/+Xs4T/YKB2/0CW + b/89lW7/O5Rt/zqTa/87k2r/cKR0/4Kqd/9gnnD/wb2E/62idv9yaVj/dWxb/6+ve/80jGD/JYdb/yOG + Wv9rn2z/qqB6/3Rvaf9wbGv/cm9u/2ByZ/8ocEz/Bm87/wBvOf8Abzn/AG86/wFwO/8Abzr/AG86/wFw + O/8BcDv/AXA7/wFwO/8Abzn/AW45/wBuOP4AbjmyAG02TwBxOAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVQADAG43PABu + OLQAXjX3AB4Z/wMGBv8ICQn/Dg8P/xYXF/8dHx7/IiUm/2lxeP+srK3/dnZ2/3Nzc/+zs7P/2NjY/4WP + ff9hps//pLmd/3urf/9Km3T/QZdy/0CWb/89lW7/PJRt/02Zb/+XsX3/Tplt/7m9g/+0tn//lIho/15Y + T/9OS0r/VlNQ/5uNb/+FqXT/Jodb/ySGWv8wil3/lKt3/5SLdv9wcm7/RHJZ/xVvQ/8Abzn/AG85/wBv + Ov8Abzr/AG86/wBvOf8Abzn/AG85/wBvOv8BcDv/A3E9/wVzP/8CcTz/AG85/wBuOOwAbTojAAAAAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAgBtNhwAbTeOAG438wBvOf8Abzn/AGY5/wFLM/8BRDD/AkUw/wZLNf8YW0X/NmpX/9DW + 0v/k5OT/rq6u/3V1df91dXX/iYmJ/3yDe/+Vq4D/Vp94/0aadP9DmXP/Qpdy/0SXcf9MmnH/hax7/1Ob + cP+nt4H/uLeB/7Gjd/9fWU//TEpJ/1FPTf9WVFP/WlhW/19bWv+xqn3/Y51s/yaHW/8ihln/P49f/4yl + b/8hckj/AG85/wBvOf8Abzn/AG86/wBvOv8Abzr/AG85/wFvOv8DcD3/AW86/wFvOv8Fcj7/CHRB/wp3 + RP8Ld0X/A3E8/wBuOP4AbjiNAF8fCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZjMKAG06TwBvN7MAbzn/AG85/wBvOf8Abzr/AXA7/wBv + Ov8BcDr/EXpI/zOQZP9zq4D/oruS/3WlqP/M2+L/5eXl/6enp/+4uLj/2NjY/6Kiov9ygHr/TJV1/0aa + dP9EmXP/Qphy/3uqe/9foHX/ia58/5yzfv+vrXv/j4Jl/1hUTf9PTUv/U1BQ/1dVU/9dWVj/YV5d/2Vi + YP+JgW//n6x7/zqOYP8fg1b/EXlJ/w91QP8Abzn/AG85/wBvOv8BcDv/AXA7/wBvOv8Abzn/A3E9/wZz + QP8Gc0D/A3E9/wBvOv8HdED/DHdF/w55SP8Re0v/C3dF/wFwOv8AbTjiAGw2SwAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxOAkAbjeYAG435QBt + OP0Abzn/AG86/wBvOv8Abzr/AG86/wBvOf8ihVb/S5x0/5K0hP+nv6X/S7Td/wmq+v8Ultj/sMjS/5mc + hv/P09H/+fn5/9nZ2f+lpaX/dH96/0yVdP9honj/ZaN4/3Gnev+2vIX/rbmD/7Kjdv9qY1T/UU5L/1FO + Tf9VU1H/WldW/15bWv9jX17/Z2Ri/2tnZv91cW3/rKB9/2ebaP8IdD//AW85/wBvOf8Abzn/AG86/wBv + Ov8Abzr/AG85/wBvOv8HdED/CXZD/wl1Q/8HdEH/BnNA/wFwO/8Dcj3/DnlI/xJ8TP8Vfk//F39Q/wl1 + Qf8AbTj9AG03swBxOBsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAYzgSAG04VgBvONUAbzn/AG85/wBvOf8BcDv/AXA7/wBvOv8CcDv/FHxK/z2Uav96roP/sL6X/4y6 + yP8nrP//D6r//xqt8/90usT/pbOH/2+qgP9so4v/ztLQ//j4+P/Z2dn/paWl/3J/ef9pnXf/q7mE/4mu + ff+8rn3/g3hf/1BNSf9PTUz/VFFQ/1lWVf9dW1n/Yl5d/2VjYf9rZ2b/b2tq/3Nvbv9jcmf/PHRU/wty + Pf8Abzn/AG85/wJtOv8Ibz7/EW9C/xx0Sv8jd07/KHpT/yt9V/9Gh17/qKx+/868kP+MpXD/GXlG/wVy + Pv8Bbzr/CnZE/xd+UP8bgVT/H4RW/x+DVv8DcTz/AG85/wBuN4oAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtNioAbjedAG037wBvOf8Abzn/AG86/wFwO/8Abzr/AG85/wVy + Pv8oiFv/WaJ3/5a1hf+hu7T/bbLi/zqq/P8vq/z/V7Ti/5W+sP+UtYX/Yad//1Gjfv9Qon3/aaGI/9PV + 1P/4+Pj/2dnZ/6Kiov92gXr/rK1//6uacv9nYFP/TUtJ/1FOTf9XVFP/W1hX/19cW/9jYV//aGRj/2xp + Z/9xbWz/cHBs/1RyYf8bcEX/Amw4/wprPP8seFT/YpV9/5e2p/+9zsb/1N/a/+Xr6P/s8O7/7fHv/+vw + 7f/r7uv/6ejm/+Df3//U0sj/kayW/zuAX/8RbUD/A206/xV9Tf8hhFj/JIdb/yiJXf8Zf1D/AW86/wBu + OOwAbDYvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVSoGAG02VABuNskAbjf8AG85/wBv + Ov8Abzr/AG86/wBvOv8BcDr/E3tJ/zmTaf91q4D/s72S/4i0yv9MqPX/Paf+/0Cq/v+avb7/qr2X/3et + g/9Uo37/UaN+/1Gjfv9Qon3/T6B8/2igh//N0tD/+fn5/9nZ2f+lpaX/goF7/2ReVv9PTEv/VFFQ/1hV + VP9dWln/YV5c/2ViYf9qZ2X/bmpp/3Jubf9tc2z/OHFU/xZsQf84fVv/hKeW/83Y0v/y8/P/+Pj4//r6 + +v/6+vr/+Pj4//T09P/y8vL/8PDw//Hx8f/09PT/9/f3//r6+v/7+/v/+vr6//X29v/b4d7/nLeq/06J + bf8wgl7/KYhe/y2MYv8ti2H/D3hG/wBuOP4AbjiwAGM4EgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFUqBgBt + NioAbji0AG04+QBvOf8Abzn/AG86/wBvOv8Abzr/AW86/wl0QP8vjGD/YqZ8/5S1jP+jurL/R6Lr/y6d + //9Bo/r/c7Hc/7a/n/+Ms4P/VKN+/1Gjfv9Ro37/UaN+/1Gjfv9rqYD/dqyA/1GhfP9qoYj/zdLQ//j4 + +P/Z2dn/paWl/358d/9cWVf/W1lY/19cW/9lYWD/aGVk/21paP9ybmz/bnFs/1BxXv8XbUH/SoVo/67B + uP/l6Ob/8fHx//Ly8v/r6+v/3t7e/8/Pz//AwMD/tra2/66urv+oqKj/pqam/6enp/+rq6v/srKy/7u7 + u//Kysr/2dnZ/+np6f/x8fH/9PT0/+zt7f/J087/fqOT/0iMa/85kGn/L4xh/wp1Qv8Abzj1AG43fQBt + JAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAby8QAHA5awBvN9MAbzn/AG85/wBvOf8BcDv/AXA7/wBvOv8DcTv/GX9O/zyU + av+GsYT/oLid/2aozP8Wk/n/GJX//0ai7v+Ut77/ormR/3Ssgf9Ro37/UaN+/1Gjfv9Ro37/Y6iA/3mu + gv9zrIH/q7uG/5m2hP96rH//ZqCG/9PV1P/4+Pj/2dnZ/6Kiov95eHb/ZGFf/2ZiYf9rZ2b/b2xq/3Nv + bv9gcWf/M29R/0F9X/+qvLP/5Obl/+3t7f/p6en/29vb/8fHx/+5ubn/sbGx/6ysrP+pqan/p6en/6al + pP+lpKP/pKOi/6Sjov+lpKP/paWk/6enp/+pqan/ra2t/7S0tP/BwcH/1NTU/+fn5//u7u7/6+zs/9TW + 0v+WqJT/UZNv/yiHW/8Abzn/AG022wBvNTkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzd3AG037wBvOf8Abzn/AG86/wBv + Ov8BcDv/AG86/wNxO/8wjWL/T594/5+4hv+QtLL/L5nq/wWM/P8Hjf3/VKTd/7C9pv+FsYX/XKZ//1Gj + fv9Ro37/UaN+/1Gjfv9yq4L/ZKiA/7e+iP9+r4L/xMCH/6iZcf+5uYT/ZKV7/2aehf/N0tD/+fn5/9nZ + 2f+lpaX/eXh4/2tpZ/9saWj/a2lo/1xsZP9Ga1n/iZ+U/+Dh4f/n5+f/5OTk/9XV1f/ExMT/u7u8/7i4 + uP+1tbT/t7Wz/7+8t//Kxb7/1M7G/9zVy//h2c//49vQ/+Paz//h18z/2tLG/9HIvv/Gv7b/vLex/7Wz + sP+1tLP/uLi4/76+vv/Ozs7/4ODg/+jo6P/m5ub/wsfB/2GWfv8QdkX/AG04/QBuOGgAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAbjh/AG85+gBvOf8BcDv/AXA7/wFwO/8BcDv/AG86/wt2Q/9Ln3n/UaN+/5O1hf9qqcv/CY77/yWV + 7P+Ms7T/p7qK/2WogP9Ro37/UaN+/1Gjfv9So37/Y6iA/1qlf/+rvIf/kbSE/6u5hf+6pnn/cWlX/05M + Sf+FfGT/obOC/1Sfef9mn4b/zdLQ//j4+P/Z2dn/pKSk/39/fv99f37/cXJx/3d3d/+8vbz/4OHg/+Li + 4v/Z2dn/zMzM/8TExP+/v7//v727/8nFwf/b1c7/6uTa//Tt4//58OX/+vLm//vy5v/78eX/+/Hk//zx + 4//78OL/++/g//nt3v/369v/8ubW/+bayv/Uyr7/xL62/727uP+/v7//xcXF/9PT0//g4OD/4+Pj/9TX + 1f9nkn3/CWo7+wBvN04AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbTYqAG44xwBvOf8Abzr/AXA7/wFwO/8BcDv/AXA7/wBv + Of8oiVv/T6J9/1ikf/+qu5j/fq/C/6G5n/+DsIP/WqV+/1Gjfv9Ro37/UaN+/1ulf/9fpn//krSF/5C0 + hP+TtIX/ybmD/5qNa/9ZVE3/TkxL/1JQTv9jXlj/pp13/3qrff9Im3f/ZJ6E/9PW1f/x8fH/wMDA/66u + rv+SkpL/i4uL/83Nzf/e3t7/3d3d/9TU1P/MzMz/yMjH/8TCwf/RzMj/5+HZ//fv5v/79Or//PTq//zz + 6P/88+f//PLm//zy5f/88eT//PHj//vw4v/78OH/++/g//vu3v/77t7/++3c//vt2//569n/8uTS/+DU + w//Lwrf/w8C9/8jIyP/Ozs//2tra/9/f3//Y2dn/j6Wb9idcQk0AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVQADAG02XQBu + N+oAbzn/AG86/wFwO/8BcDv/AXA7/wFvO/8KdUH/O5Rr/1Gjff93rYP/n7iI/22qgP9Ro37/UaN+/1Gj + fv9Ro37/UaN+/3asgv+huIb/c6yB/8TCif+upXn/dGxZ/1JPTP9QTkz/VVJR/1lXVf9eW1r/gHhp/7q1 + g/9Pnnj/R5t1/2KZgP+7vr3/3Nzc/7+/v/+mpqb/1NTU/9nZ2f/b29v/1dXV/9DR0f/Kycj/0M3I/+rj + 3P/68+r//fXs//z16v/89Or//PPo//zz5//88ub//PLl//zx5P/88eP//PDi//vv4f/779//++/f//vu + 3v/77d3/++3b//vs2v/67Nn/+uvY//nq1v/05dH/4dPB/8vDuf/Kycf/0dHR/9jY2P/c3Nz/2tra/7i6 + udhoaGg4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAGYzBQBuOY8Abzn/AG85/wBvOv8CcDv/BHE+/wd0QP8Ecj3/FXxL/0ac + df9Ro37/UaN+/1Gjfv9Ro37/UqN+/1ylf/9pqYD/ormG/2mpgP/DwYn/xLeC/5OFZ/9KSEf/T0xL/1RR + UP9ZVlX/XVlY/2BeXP9mYmH/amZl/56Rd/+jtoP/RZhv/z6FY//a4N3/6enp/7i4uP/Pz8//1tbW/9vb + 2//Z2dn/1NTU/83Myf/f29T/9vDn//z17P/89ev//PXq//z06f/88+j//PPn//zy5v/88uX//PHk//zx + 4//78OL/+/Dh//vv3//77t//++7e//vt3P/77dv/++za//vs2f/669j/+uvW//rq1v/66dT/+ejT/+/e + yf/Xyrn/zcnE/9XV1f/Z2dn/2dnZ/9TV1P+ksKrxHGxFxgBsN1cAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABuMx4AbDfhAG85/wBv + Ov8Gcz//CHRC/wt3RP8Ld0X/BHI9/yqKXf9Ro37/UaN+/1Gjfv9Ro37/VaR+/523hv9pqYD/n7iG/7O7 + hv+mm3P/cGhX/1BMSv9ST07/VVNS/1pXVv9fXFr/Y2Bf/2dkYv9saGf/cGxr/3dyb/+Am2z/JIFN/1qM + c//19fX/ycnJ/8zMzP/S0tL/29vb/93d3f/X19f/0M7L/+rk3f/79ez//fbs//316//89Or//PTq//zz + 6P/88uf//PLm//zy5f/88eT//PHj//vw4v/78OH/++/g//vu3//77t7/++3c//vt2//77Nr/+uzZ//rr + 2P/66tf/+urW//rp1P/66dP/+ujS//rn0f/148z/39C8/87IwP/Z2dn/3d3d/9bW1v/Q0dD/lqmg/wtp + O+QAcjQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAbjlmAG83+ABvOf8HdEH/DHdG/w95SP8Se0v/C3dG/wd0QP9Fm3T/UKJ9/1Ci + ff9Qon3/UqN+/4Wxg/+7wIn/u7eD/4yAZP9ZVE3/TkxL/1NRT/9YVVT/XFlY/2BdXP9lYmD/aWVk/21q + af9ybm3/cHJt/0JxWP8Qcj//AW85/36ejv/S0tL/xcXF/87Ozv/b29v/4eHh/9ra2f/V0s3/7+ni//z2 + 7v/99u3//fXr//z16v/89On//PPo//zz5//88ub//PLl//zx5P/88eP//PDi//vw4f/779//++/f//vu + 3v/77dz/++3b//vs2v/77Nn/+uvY//rr1v/66tb/+urU//ro0//66NL/+ufR//nn0P/55s7/+OXN/+XU + vf/Syb//3Nzc/9/f3//U1NT/z8/P/3yYiv8JZjmaAFUqBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZjMPAG85kwBuOPoDcT3/D3lJ/xN9 + Tf8Wf1D/GYFS/wx2RP8PeEb/IoVW/yGEVf81kWf/TJ53/5y3hf+0oXb/Y1xR/01LSv9ST07/VlRT/1tX + Vv9gXVv/Y2Bf/2hkY/9taWj/cW1s/3Bwbf9TcmD/F3BD/wBvOf8Abzn/AG85/3aOg//BwcH/ysrK/9fX + 1//k5OT/39/e/9bTz//x7OT//fbt//317P/89ev//PXr//z06f/88+j//PPn//zy5v/88uX//PHk//zx + 4//78OL/+/Dh//vv3//77t//++7e//vt3P/77dv/++za//rs2f/669j/+uvX//rq1v/66dT/+unT//ro + 0v/659H/+efQ//nmzv/55s3/+eXM//fkyv/m1Lz/08vA/+Hh4f/h4eH/0NDQ/8XFxf9UgWv2Amk0YQBV + AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAG43MwBvN9MAbzn/CnZE/xZ/Uf8cglT/H4RX/x+CVv8SeUb/J4JP/yeCUP8MdkT/Gn9N/4uu + ev+bjWz/Uk9N/1NRUP9ZV1X/XVpZ/2FeXf9mYmH/amdl/25qaf9zcG3/Z3Jq/ztwVf8Jbzv/AG85/wBv + Of8Abzr/AW06/32Nhf/Hx8f/0NDQ/+bm5v/j4+P/1tPQ//Dq4//99u7//fXs//z16//89Or//PTq//zz + 6P/88+f//PLm//zy5f/88eT//PHj//vw4v/78OH/++/g//vv3//77t7/++3c//vs2//77Nr/+uzZ//rr + 2P/66tb/+urW//rq1P/66dP/+ujS//nn0f/559D/+ebO//nmzv/55cz/+OXL//jkyv/248j/5NK5/9XO + xv/l5OT/3t7e/8rKyv+3vLn/K29N2QBvNykAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFUAAwBwOG0Abjj+AnA7/xZ+T/8hhVj/JIdb/yiJ + Xf96pXH/ubqH/7y8hv9Tl2n/E3pJ/yKCUP+4tIL/fXNh/1pXVv9fXFr/Y2Bf/2dkYv9saGf/cG1r/3Rx + b/9TcmH/HHBG/wRvOv8Abzn/AG85/wBvOv8Abzr/KW9N/7/Av//IyMj/5OTk/+no6P/Z19T/7Obf//z2 + 7f/99ez//fXr//z16v/89Or//PPo//zz5//88ub//PLl//zx5P/88eP//PDi//vw4f/779//++/f//vu + 3v/77dz/++3b//vs2v/669n/+uvY//rr1v/66tb/+unU//rp0//66NL/+ujR//nn0P/55s7/+ebN//nl + zP/45cv/+OTJ//jkyf/448j/9+HG/9/MtP/c2NL/6enp/9fX1//Gxsb/j5+X/gllN4oAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAbjiwAG83/AZzPv8mh1v/K4tg/y+NY//cxpX/wry2/9LNxP+3vIT/Mo5k/wl0QP9ppXn/r6Z8/3Br + Y/9nY2L/amdm/29rav9xb2z/Y3Jo/zNxUf8Abzn/AG85/wBvOf8Abzn/AXA7/wBvOv8IbDz/hpuR/8PE + xP/Z2dn/7Ozs/+Df3v/j3tj/+/Tt//317P/89ev//PXq//z06v/88+j//PPn//zy5v/88uX//PHk//zx + 4//78OL/+/Dh//vv4P/779//++7e//vt3P/77dv/++za//rs2f/669j/+urW//rq1v/66dT/+unT//ro + 0v/559H/+efQ//nmzv/55s3/+eXM//jly//45Mr/+OTJ//jjyP/44sb/+OLF//PdwP/YybX/5OPg/+jo + 6P/MzMz/wMHA/1p8aroAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbTQ6AG052wBvOf8Zf1D/MI1k/zWQZ//SxpP/2tHA/+Pa + xf+vuoX/Q5hy/w94Rv8/lWr/nLWF/56Tdv9taWj/cW5s/3Jwbv9Hclr/G3BF/wJuOf8Abzn/AG86/wBv + Ov8BcDv/AG86/wBvOf88eVz/u7y8/8fHx//q6ur/6urq/9rX0f/38On//fXs//z16//89Or//PTq//zz + 6P/88+f//PLm//zy5f/88eT//PHj//vw4v/78OH/++/g//vv3//77t7/++3c//vt2//77Nr/++zZ//rr + 2P/66tf/+urW//rp1P/66dT/+ujT//ro0v/56NL/+ejR//nn0P/55s7/+eXM//jkyv/45Mn/+OPI//ji + x//44cX/+OHE//jgw//s1rn/2M7A/+3s7f/f39//w8PD/6urq+VQUFAjAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbSQHAG43fQBv + OPUIdED/Kold/zqTa/96qXv/v8KR/7fAkP9lpXz/Q5ly/w54Rf8+l27/ZaiA/7y6hv+EfHP/aHJr/zBw + UP8Hbzz/AG85/wBvOf8Abzr/AXA7/wBvOv8Abzn/A3E8/x98UP+Pn5f/v7+//9ra2v/w8PD/3tza/+3n + 3//89ez//PXr//z06v/89Or//PPo//zz5//88ub//PLl//zx5P/88eP//PDi//vv4f/779//++/f//vu + 3v/77dz/++3b//vs2v/67Nn/+uvY//rq1v/66tb/+unV//rp1P/66dT/+unU//np0//56dP/+unT//rp + 0//56dP/+enT//no0f/45s3/+OLI//jhxf/44cT/+OHD//fgwv/238D/3suv/+Pg3P/u7u7/zMzM/729 + vf6GhoaFAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAGk8EQBvOLAAbzn/EnpI/zqTa/9FmnT/SZx3/0yeev9On3v/K4pe/w54 + Rf9OoHv/UaN+/2unev9ylWb/EG8//wBvOf8Abzn/AG86/wFwO/8Abzr/AG86/wJwO/8VfEv/QJRq/22S + dP+2t7b/wsLC/+zs7P/t7Oz/3dnT//rz6v/89ev//PTq//z06f/88+j//PPn//zy5v/88uX//PHk//zx + 4//78OL/+/Dh//vv3//77t7/++7e//vt3P/77dv/++za//vs2f/669j/+uvW//rq1f/66dX/+unU//rp + 1P/66dT/+enT//np0//56dP/+unT//np0//56dP/+enU//nq1f/66dX/+ejT//jly//44cP/9+DC//ff + wf/237//8Nm5/9jMvP/v7+//4ODg/7+/v/+lpaXZPz8/GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvOjAAbTbtAnA6/yiI + XP9Knnn/TqB7/1Gifv9Knnj/FXxL/yCEVP9QoXz/QJhv/x6BUv8EcDr/AG85/wBvOf8Abzr/AXA7/wBv + Ov8Abzn/CXRB/yWGWf9dn3X/lLKH/42bmv+6u7v/0tLS//T09P/i4N3/7Obd//z16//89Or//PTq//zz + 6P/88uf//PLm//zy5f/88eT//PHj//zw4v/78OH/++/g//vu3//77t7/++3d//vt2//77Nr/+uzZ//rr + 2P/66tf/+urW//rp1f/66dT/+unU//rp1P/56dP/+enT//np0//66dP/+enT//np0//56dT/+urV//rq + 1f/66tX/+urX//rr1//56NH/9+DD//ffv//33r7/9t29/97Krv/o5eH/8PDw/8TExP+2trb6cnJyWQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAbjeKAG44/gZzPv8VfEv/IYRV/zGOY/86k2r/JIZX/w14RP8rilz/DXdE/wFv + Of8Abzn/AG85/wBvOv8Abzr/AG86/wBvOf8Xfk3/OZNq/3OofP+1vZX/VZrE/5Ogq/+8vLz/5OTk//Ly + 8v/d2dT/+fHn//z16v/89On//PPo//zz5//88ub//PLl//zx5P/88eP//PDi//vw4f/77+D/++/f//vu + 3v/77dz/++3b//vs2v/77Nn/+uvY//rr1v/66tb/+urV//rp1P/66dT/+unU//np0//56dP/+unT//rp + 0//56dP/+enT//np1P/66tX/+urV//rq1f/66tb/+uvX//rr2f/67Nr/+erW//fgwf/33r3/9928/+3U + s//c0sT/8/P0/9XV1f+7u7v/kJCQqwAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcTgbAG42qQBtOOsAbzj1AG85/wBv + Of8Abjj/AG44/wNwOv8Abzn/AG85/wBvOf8BcDv/AXA7/wBvOv8BcDv/DXdE/y2LX/9Yonv/n7eI/5m1 + sP8Ukff/FHzU/7S2t//BwcH/8PDw/+vq6f/l39f//PTq//z06f/88+j//PPn//zy5v/88uX//PHk//zx + 4//78OL/+/Dh//vv3//77t//++7e//vt3P/77dv/++za//rs2f/669j/+uvX//rq1f/66dX/+unU//rp + 1P/66dT/+enT//np0//66dP/+unT//np0//56dP/+enU//np1P/66tX/+urV//rq1v/669f/+uvY//rs + 2f/67dr/+u3c//rr1//337//9927//Tauf/ayLD/8PDu/+bm5v+8vLz/oqKi5SgoKBMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAACAG80JwBsOVkAbThtAG04hwBtONoAbzn/Am86/wBvOf8Abzn/AG86/wBvOv8Abzr/AG85/wJw + Ov8hhFX/P5dv/06ge/9ao33/prmM/0ug2v8DjP7/U4y2/7i4uP/MzMz/9vb2/+Lf3f/w6N///PTq//zz + 6P/88+f//PLm//zy5f/88eT//PHk//vw4v/78OH/++/g//vv3//77t7/++3c//vt2//77Nr/+uzZ//rr + 2P/66tb/+urW//rp1f/66dT/+unU//np0//56dP/+enT//rp0//66dP/+enT//np0//56dT/+urV//rq + 1f/66tX/+urW//rr1//669n/+uzZ//rs2v/67dz/++7d//vv3v/56dL/99y6//bbuf/hyqz/6eXh//Hx + 8f/BwcH/s7Oz/FZWVj4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVQADAG01VgBuOPAAbjf/AG85/wBv + Of8Abzr/AG86/wBvOv8Abzn/CXVB/zCOYv9co3z/ZqiA/1Chff9Nn3v/cal//6q7nv9gpc7/lp2T/7i4 + uP/Y2Nj/9/f3/93Z1P/27+X//PPo//zz5//88ub//PLl//zx5P/88eP//PDi//vw4f/779//++/f//vu + 3v/77dz/++3b//vs2v/67Nn/+uvY//rr1v/66tb/+unV//rp1P/66dT/+unU//np0//56dP/+unT//rp + 0//56dP/+enT//np1P/56tT/+urV//rq1f/669b/+uvX//rr2f/67Nn/+u3a//rt3P/77t3/++7e//vv + 4P/77+H/+OLH//bbuP/q0a//4djM//b29v/MzMz/uLi4/3d3d3cAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgBt + NhwAbTaRAG04+QBvOf8Abzn/AG86/wFwO/8Abzr/AG85/wZzPv8hhFT/VaB3/4qyhf+3xKL/qb2U/2Om + f/9OoHz/TJ96/4iwgf+YsYD/i5qS/7i4uP/i4uL/9fX1/97Z0f/68ef//PPn//zy5v/88uX//PHk//zx + 4//78OL/+/Dh//vv4P/779//++7e//vt3P/77dv/++za//rs2f/669j/+uvW//rq1v/66dX/+unU//rp + 1P/56dT/+enT//np0//66dP/+unT//np0//56dP/+enU//nq1P/66tX/+urV//rq1v/669f/+uvZ//rs + 2f/67dr/+u3c//vu3f/77t7/++/f//vw4f/88OP/++3e//bbuP/w1bL/2826//f39//Y2Nj/uLi4/4+P + j6QAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAZjMKAG06TwBvN7MAbzn/AG85/wBvOf8Abzr/AXA7/wBvOv8BcDr/EXpI/zOQ + ZP9zq4D/oruS/3u7v/8frvH/bbnI/460if9OoHz/TZ96/0+eef9IlHP/lZ+b/7m5uf/p6en/8fHw/+Lb + 0v/78uf//PLm//zy5f/88eT//PHj//vw4v/78OH/++/f//vv3//77t7/++3c//vt2//77Nr/++zZ//rr + 2P/66tb/+urW//rp1f/66dT/+unU//rp1P/56dP/+enT//np0//66dP/+enT//np0//56dT/+erU//rq + 1f/66tb/+uvW//rr1//669j/+uzZ//rt2v/67dz/++7d//vu3v/779//+/Dh//vw4//88eT//PLm//fi + xv/z17P/2cau//b29v/h4eH/uLi4/5aWlsMZGRkKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxOAkAbjeYAG435QBtOP0Abzn/AG86/wBv + Ov8Abzr/AG86/wBvOf8ihVb/S5x0/5K0hP+nv6X/S7Td/wmq+v8Aqf7/QrPf/8DFmP9ao33/TZ97/0ye + ef9JkXH/n6aj/7q6uv/v7+//7Ovp/+ff1f/78ub//PLl//zx5P/88eP/+/Di//vw4f/77+D/++/f//vu + 3v/77dz/++3b//vs2v/67Nn/+uvY//rq1v/66tb/+unV//rp1P/66dT/+unU//np0//56dP/+unT//rp + 0//56dP/+enT//np1P/56tT/+urV//rq1f/66tb/+uvX//rs2f/67Nn/+u3a//vt3P/77t3/++7e//vv + 3//78OH//PDj//zx5f/88ub//PPo//rr2f/02LP/2sSn//Tz8v/p6en/ubm5/56entg1NTUTAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYzgSAG04VgBv + ONUAbzn/AG85/wBvOf8BcDv/AXA7/wBvOv8CcDv/FHxK/z2Uav96roP/sL6X/4y6yP8nrP//D6r//xqt + 8/90usT/r76P/3Crgf9QoX3/TqB8/0yfev9KkHH/o6im/7y8vP/y8vL/6efl/+ri1//78eX//PHk//zx + 4//78OL/+/Dh//vv3//779//++7e//vt3P/77dv/++za//vs2f/669j/+uvX//rq1f/66dX/+unU//rp + 1P/66dT/+enT//np0//56dP/+unT//np0//56dP/+enU//nq1P/66tX/+urW//rq1v/669f/+uvZ//rs + 2v/67dr/+u3c//vu3f/7797/++/f//vw4f/78OP//PHk//zy5v/88+j//PTq//zy5v/12rb/3MSl//Lw + 7//u7u7/urq6/6WlpeM6OjoaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABtNioAbjedAG037wBvOf8Abzn/AG86/wFwO/8Abzr/AG85/wVyPv8oiFv/WaJ3/5a1 + hf+hu7T/bbLi/zqq/P8vq/z/V7Ti/5W+sP+UtYX/Yad//1Gjfv9Qon3/TqB8/0yfev9LkHH/pKmn/729 + vf/y8vL/5+Xj/+zj2P/78eT//PHj//zw4v/78OH/++/f//vu3//77t7/++3c//vt2//77Nr/+uzZ//rr + 2P/66tf/+urW//rp1f/66dT/+unU//rp1P/56dP/+enT//np0//66dP/+enT//np0//56dT/+urV//rq + 1f/66tX/+urW//rr1//669j/+uzZ//rt2v/77dz/++7d//vu3v/779//+/Dh//zw4//88eT//PLm//zz + 6P/89Or//fXs//z27f/23b3/3cSj//Hv7P/v7+//u7u7/6enp+hHR0cgAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVSoGAG02VABuNskAbjf8AG85/wBvOv8Abzr/AG86/wBv + Ov8BcDr/E3tJ/zmTaf91q4D/s72S/4i0yv9MqPX/Paf+/0Cq/v+avb7/qr2X/3etg/9Uo37/UaN+/1Gj + fv9Qon3/T6B8/02fev9KkXH/o6im/7y8vP/x8fH/5+Xi/+zj1//78eP//PDi//vw4f/779//++/e//vu + 3v/77dz/++3b//vs2v/77Nn/+uvY//rr1v/66tb/+unV//rp1P/66dT/+unU//np0//56dP/+unT//rp + 0//56dP/+enT//np1P/66tX/+urV//rq1f/66tb/+uvX//rr2f/67Nn/+u3a//rt3P/77t3/++/e//vv + 3//78OH//PDj//zx5f/88ub//PPo//z06v/99ev//fbt//337//34sf/3cOi//Dv7P/w8PD/u7u7/6Wl + pepFRUUhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFUqBgBtNioAbji0AG04+QBv + Of8Abzn/AG86/wBvOv8Abzr/AW86/wl0QP8vjGD/YqZ8/5S1jP+jurL/R6Lr/y6d//9Bo/r/c7Hc/7a/ + n/+Ms4P/VKN+/1Gjfv9Ro37/UaN+/1Gjfv9rqYD/dqyA/1GhfP9MlHP/n6aj/7q6uv/v7+//6Obk/+vh + 1P/78OL/+/Dh//vv3//77t//++7e//vt3f/77dv/++za//rs2f/669j/+uvX//rq1f/66dX/+unU//rp + 1P/66dT/+enT//np0//56dP/+unT//np0//56dP/+enU//np1P/66tX/+urV//rq1v/669f/+uvY//rs + 2f/67dr/++3c//vu3f/7797/++/f//vw4f/88OP//PHk//zy5v/88+j//PTq//z17P/99u3//ffv//33 + 8f/45cz/28Ki//Hw7v/v7+//urq6/6WlpedEREQeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAby8QAHA5awBvN9MAbzn/AG85/wBvOf8BcDv/AXA7/wBvOv8DcTv/GX9O/zyUav+GsYT/oLid/2ao + zP8Wk/n/GJX//0ai7v+Ut77/ormR/3Ssgf9Ro37/UaN+/1Gjfv9Ro37/Y6iA/3mugv9zrIH/q7uG/5m2 + hP91o3n/laCb/7m5uf/q6ur/7Oro/+je0P/77+H/++/g//vv3//77t7/++3c//vt2//77Nr/+uzZ//rr + 2P/66tb/+urW//rp1f/66dT/+unU//rp1P/56dP/+enT//rp0//66dP/+enT//np0//56dT/+urV//rq + 1f/66tX/+urW//rr1//669n/+uzZ//rs2v/67dz/++7d//vv3v/779//+/Dh//zw4//88eX//PLm//zz + 6P/89Or//PXr//327f/99+///ffx//348v/45s//2sKk//Pz8v/r6+v/ubm5/6GhoeA1NTUYAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzd3AG037wBvOf8Abzn/AG86/wBvOv8BcDv/AG86/wNx + O/8wjWL/T594/5+4hv+QtLL/L5nq/wWM/P8Hjf3/VKTd/7C9pv+FsYX/XKZ//1Gjfv9Ro37/UaN+/1Gj + fv9yq4L/ZKiA/7e+iP9+r4L/xMCH/6iZcf+zs4D/jpyT/7i4uP/j4+P/8O/u/+LYzP/67t//++/f//vu + 3v/77dz/++3b//vs2v/67Nn/+uvX//rr1v/66tX/+unU//rp1P/66dT/+unU//np0//56dP/+unT//rp + 0//56dP/+enT//np1P/56tT/+urV//rq1f/66tf/+uvX//rr2f/67Nn/+u3a//rt3P/77t3/++/e//vv + 4P/78OH//PDj//zx5P/88ub//PPo//z06v/89ez//fbt//337//9+PH//fjy//759P/35c3/2cSp//b2 + 9v/k5OT/uLi4/5iYmM0kJCQOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbjh/AG85+gBv + Of8BcDv/AXA7/wFwO/8BcDv/AG86/wt2Q/9Ln3n/UaN+/5O1hf9qqcv/CY77/yWV7P+Ms7T/p7qK/2Wo + gP9Ro37/UaN+/1Gjfv9So37/Y6iA/1qlf/+rvIf/kbSE/6u5hf+6pnn/cWlX/05MSf+DemL/lZuK/7i4 + uP/Y2Nj/9PTz/97Vyv/57d3/++7e//vt3P/77dv/++za//rs2f/669j/+uvW//rq1v/66dT/+unU//rp + 1P/56dT/+enT//np0//66dP/+unT//np0//56dP/+enU//nq1P/66tX/+urV//rq1v/669f/+uvZ//rs + 2f/67dr/+u3c//vu3f/77t7/++/f//vw4f/88OP//PHl//zy5v/88+j//PTq//z17P/99u3//fbv//33 + 8P/9+PL//vn0//769v/z4Mb/28u1//f39//b29v/uLi4/4+Pj7AAAAAGAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAbTYqAG44xwBvOf8Abzr/AXA7/wFwO/8BcDv/AXA7/wBvOf8oiVv/T6J9/1ik + f/+qu5j/fq/C/6G5n/+DsIP/WqV+/1Gjfv9Ro37/UaN+/1ulf/9fpn//krSF/5C0hP+TtIX/ybmD/5qN + a/9ZVE3/TkxL/1JQTv9jXlj/kYx3/7i4uP/Ly8v/9fb1/93Wzf/26tr/++3c//vt2//77Nr/+uzZ//rr + 2P/66tb/+urW//rp1P/66dP/+ujU//rp1P/56dP/+enT//np0//66dP/+enT//np0//56dT/+erU//rq + 1f/66tX/+uvW//rr1//669j/+uzZ//rt2v/67dz/++7d//vu3v/779//+/Dh//vw4//88eT//PLm//zz + 6P/89Or//PXs//327f/99+///ffw//348v/++fT//vr1//789//s1rj/4NXH//b29v/Q0ND/uLi4/4OD + g4oAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVQADAG02XQBuN+oAbzn/AG86/wFw + O/8BcDv/AXA7/wFvO/8KdUH/O5Rr/1Gjff93rYP/n7iI/22qgP9Ro37/UaN+/1Gjfv9Ro37/UaN+/3as + gv+huIb/c6yB/8TCif+upXn/dGxZ/1JPTP9QTkz/VVJR/1lXVf9eW1r/dW9j/7Ozsv/BwcH/8fHx/+Hd + 2P/v4tL/++3b//vs2v/67Nn/+uvY//rr1v/66tb/+unU//ro0//66NL/+ujT//np0//56dP/+unT//rp + 0//56dP/+enT//np1P/56tT/+urV//rq1f/66tb/+uvX//rs2f/67Nn/+u3a//vt3P/77t3/++7e//vv + 3//78OH//PHj//zx5f/88ub//PPo//z06v/89ev//fbt//337//99/D//fjy//759P/++vb//vv3//36 + 9f/hx6f/6OPd//T09P/FxcX/tLS0/mtra1MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAGYzBQBuOY8Abzn/AG85/wBvOv8CcDv/BHE+/wd0QP8Ecj3/FXxL/0acdf9Ro37/UaN+/1Gj + fv9Ro37/UqN+/1ylf/9pqYD/ormG/2mpgP/DwYn/xLeC/5OFZ/9KSEf/T0xL/1RRUP9ZVlX/XVlY/2Be + XP9mYmH/ZmJh/6Khnv+9vb3/5OTk/+ro5v/k2Mn/+uza//vs2f/669j/+urW//rq1f/66dT/+unT//ro + 0v/659H/+ejS//np0//56dP/+unT//np0//56dP/+enU//nq1P/66tX/+urW//rq1v/669f/+uvY//rs + 2v/67dr/+u3c//vu3f/7797/++/f//vw4f/78OP//PHk//zy5v/88+j//PTq//z17P/99u3//ffv//33 + 8P/9+PL//vn0//769f/++/f//vz5//rx5v/axKj/8O/u/+vr6/++vr7/ra2t8To6OiMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABuMx4AbDfhAG85/wBvOv8Gcz//CHRC/wt3 + RP8Ld0X/BHI9/yqKXf9Ro37/UaN+/1Gjfv9Ro37/VaR+/523hv9pqYD/n7iG/7O7hv+mm3P/cGhX/1BM + Sv9ST07/VVNS/1pXVv9fXFr/Y2Bf/2dkYv9saGf/cGxr/4SCgf+7u7v/0tLS//Lx8f/c08j/9+jW//rr + 2P/66tb/+urW//rp1P/66NP/+ujS//rn0f/559D/+ejS//np0//66dP/+enT//np0//56dT/+erU//rq + 1f/66tX/+urW//rr1//669j/+uzZ//rt2v/77dz/++7d//vu3v/779//+/Dh//vw4//88eT//PLm//zz + 6P/89Or//fXs//327f/99+///ffw//348v/++fT//vr1//779//+/Pn//vz6//Hizv/cz73/9PT0/9vb + 2/+7u7v+l5eXxwAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAbjlmAG83+ABvOf8HdEH/DHdG/w95SP8Se0v/C3dG/wd0QP9Fm3T/UKJ9/1Ciff9Qon3/UqN+/4Wx + g/+7wIn/u7eD/4yAZP9ZVE3/TkxL/1NRT/9YVVT/XFlY/2BdXP9lYmD/aWVk/21qaf9ybm3/dnJw/3Nw + cP+0tLP/w8PD/+7u7v/h3df/693L//nq1v/66tX/+unU//rp0//66NL/+ufR//nnz//55s7/+ejR//rp + 0//56dP/+enT//np1P/66tX/+urV//rq1v/66tb/+uvX//rr2f/67Nn/+u3a//rt3P/77t3/++/e//vv + 3//78OH//PDj//zx5f/88ub//PPo//z06v/99ez//fbt//337//99/H//fjy//759P/++vX//vv3//78 + +f/+/Pr//v37/9/HqP/n4t3/8/Pz/8nJyf+5ubn9gYGBdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZjMPAG85kwBuOPoDcT3/D3lJ/xN9Tf8Wf1D/GYFS/wx2 + RP8PeEb/IoVW/yGEVf81kWf/TJ53/5y3hf+0oXb/Y1xR/01LSv9ST07/VlRT/1tXVv9gXVv/Y2Bf/2hk + Y/9taWj/cW1s/3Rwb/94dHP/e3d0/4Z+dP+npJz/v7+//9zc3P/s6+n/3NHC//fo1P/66dT/+ujT//ro + 0v/659H/+efQ//nmzv/55s7/+efP//np0//56dP/+enU//np1P/66tX/+urV//rq1v/669f/+uvY//rs + 2v/67dr/++3c//vu3f/77t7/++/f//vw4f/88OP//PHk//zy5v/88+j//PTq//z17P/99u3//ffv//33 + 8P/9+PL//vn0//769v/++/f//vv4//78+v/+/fv/9+3g/9fGrv/v7+//5eXl/8DAwP+vr6/qT09PLQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG43MwBv + N9MAbzn/CnZE/xZ/Uf8cglT/H4RX/x+CVv8SeUb/J4JP/yeCUP8MdkT/Gn9N/4uuev+bjWz/Uk9N/1NR + UP9ZV1X/XVpZ/2FeXf9mYmH/amdl/25qaf9zcG3/dnJx/3h0c/9/enX/p5p+/8G4hv+OnID/vr6+/8rK + yv/s7Oz/3djR/+vcyf/56dP/+ujS//rn0f/559D/+ebO//nmzf/55cz/+ebN//np0//56dT/+urV//rq + 1f/66tX/+urW//rr1//669n/+uzZ//rt2v/67dz/++7d//vv3v/779//+/Dh//zw4//88eX//PLm//zz + 6P/89Or//fXs//327f/99+///ffx//348v/++fT//vr1//779//++/n//vz6//79/P/+/Pn/4cyv/+Ld + 1v/w8PD/0dHR/76+vv6SkpKnAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAFUAAwBwOG0Abjj+AnA7/xZ+T/8hhVj/JIdb/yiJXf96pXH/ubqH/7y8 + hv9Tl2n/E3pJ/yKCUP+4tIL/fXNh/1pXVv9fXFr/Y2Bf/2dkYv9saGf/cG1r/3Rxb/94dHP/eHRz/4mB + d/+8roT/tLqH/8nDif9TlnL/nKWd/8LDw//a2tr/6urp/9nOwP/15M//+ufR//nn0P/55s7/+ebN//nl + zP/45cv/+OTK//np0//56tT/+urV//rq1f/66tf/+uvX//rr2f/67Nn/+u3a//rt3P/77t3/++/e//vv + 3//78OH//PDj//zx5P/88ub//PPo//z06v/89ez//fbt//337//99/D//fjy//759P/++vX//vv3//78 + +f/+/Pr//v37///+/f/y5tf/1sez/+3t7f/k5OT/xMTE/7a2tvJfX19AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbjiwAG83/AZz + Pv8mh1v/K4tg/y+NY//cxpX/wry2/9LNxP+3vIT/Mo5k/wl0QP9ppXn/r6Z8/3BrY/9nY2L/amdm/29r + av9zcG7/d3Ny/3h0c/+Ffnb/q51//7+8iP+5v4j/cKl9/3qndf8+iVP/RH5j/7/AwP/Kysr/5ubm/9/b + 1//h08D/+ObP//nmzv/55s3/+eXM//jly//45Mr/+OTJ//nn0P/66tX/+urV//rq1v/669f/+uvZ//rs + 2f/67dr/+u3c//vu3f/77t7/++/f//vw4f/88OP//PHl//zy5v/88+j//PTq//z17P/99u3//ffv//33 + 8f/9+PL//vn0//769f/++/f//vz5//78+v/+/fz///79//r28P/ZxKr/5OHe/+vr6//Q0ND/w8PD/5SU + lKUfHx8IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAbTQ6AG052wBvOf8Zf1D/MI1k/zWQZ//SxpP/2tHA/+Paxf+vuoX/Q5hy/w94 + Rv8/lWr/nLWF/56Tdv9taWj/cW5s/3VxcP94dHP/enZ0/5OKev+4roT/xsGK/4qyhP9zqHr/ZZtl/xJ5 + Rv9DmHH/eLSa/56qpf/Gxsb/09PT/+jo5//Y0Mf/6tnC//jlzf/55cz/+OXL//jkyv/45Mn/+OPI//jj + yf/56dX/+urX//rr1//669n/+uzZ//rt2v/67dz/++7d//vu3v/779//+/Dh//vw4//88eT//PLm//zz + 6P/89Or//PXs//327f/99+///fjw//348v/++fT//vr1//779//+/Pn//vz6//79+////v3//v37/+LO + tv/b08n/6enp/9zc3P/Hx8f/tbW1705OTjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbSQHAG43fQBvOPUIdED/Kold/zqT + a/96qXv/v8KR/7fAkP9lpXz/Q5ly/w54Rf8+l27/ZaiA/7y6hv+EfHP/dnNy/3h0c/9/enX/rZ+A/8u9 + if+uvIf/eq6C/6i4gv8WfEn/JoRT/1yohv+Oxa7/hsCn/0aJaf+psq7/ysrK/9ra2v/j4uH/1Mq+/+7c + xP/45cv/+OTJ//jkyf/448j/+OLG//jixf/558//+uvX//rr2f/67Nn/+u3a//vt3P/77t3/++7e//vv + 3//78OH//PHj//zx5f/88ub//PPo//z06v/89ev//fbt//337//99/H//vjy//759P/++vb//vv3//78 + +f/+/Pr//v38///+/f/+/fv/6djD/9TIuf/l5eX/4uLi/8vLy//Gxsb7goKCfQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAGk8EQBvOLAAbzn/EnpI/zqTa/9FmnT/SZx3/0yeev9On3v/K4pe/w54Rf9OoHv/UaN+/3Ws + gf+/sIX/hX52/5KJef/EuIf/ur+I/2mpgP+ftH3/Po1b/xF5R/9KnHb/icKq/4rDqv9Wo4D/EnpH/wBt + OP4/eVzuwcLB/M/Pz//e3t7/3t3c/9XIuf/u28L/9+PJ//jjyP/44sf/+OLF//jhxP/44sX/+urV//rs + 2v/67dr/+u3c//vu3f/7797/++/f//vw4f/78OP//PHk//zy5v/88+f//PTq//z17P/99u3//ffv//33 + 8P/9+PL//vn0//769f/++/b//vz5//78+v/+/fv///79//79/P/r3Mj/0cGu/+Dg3//i4uL/0tLS/8nJ + yf6fn5+4PDw8EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvOjAAbTbtAnA6/yiIXP9Knnn/TqB7/1Gi + fv9Knnj/FXxL/yCEVP9Ro37/UaN+/1Gjfv+gtYX/w7KG/9XBiv+HsoT/p7qH/2Kfbv8ngk//NIxe/2Gq + if+SyLL/d7eb/ziRZ/8DcTv/AG84+gBtN8YGZTRTlZiXos3Nzf7T09P/3d3d/9rZ1//Tx7f/7dm///fi + xv/44cX/+OHE//jhw//34ML/9+LH//rs2v/77dz/++7d//vu3v/779//+/Dh//vw4//88eT//PLm//zz + 6P/89On//PXr//327f/99+///ffw//348v/++fT//vr1//779//+/Pn//vz6//79+////v3//v79/+nY + xP/QwKz/3NrZ/+Dg4f/W1tb/zs7O/rOzs9xfX18wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAbjeKAG44/gZzPv8VfEv/IYRV/zGOY/86k2r/JIZX/w14RP9Lnnj/UaN+/1Gjfv9kqID/hbGD/6S5 + hv+MsH7/NIpZ/xt7Rv9LnXf/gr6k/5TJs/9Xo4D/GX5N/wJwO/4AbTfvAG43igBvNykAAAAAMzMzD6Wl + pbbQ0ND91tbW/9zc3P/X1tT/z8S2/+fTuf/34MP/+OHD//fgwv/338H/99+///jixv/67dz/++/e//vv + 3//78OH//PDj//zx5f/88ub//PPo//z06v/99ez//fbt//337//99/D//fjy//759P/++vX//vv2//78 + +f/+/Pr///37///+/f/79/H/4s+3/8zAr//Y2Nf/3d3d/9jY2P/S0tL+v7+/6mVlZUQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcTgbAG42qQBtOOsAbzj1AG85/wBvOf8Abzn/AG85/wl0 + QP8gg1X/TaB7/1Gjfv9Qon3/Sp54/ziRZf8/iVP/Kolb/3O2mf+Rx7D/cLOV/yeGWf8Abzn/AG049ABs + OMMAbjksAAAAAAAAAAAAAAAAAAAAAFFRURysrKy51NTU/dnZ2f/a2tr/1NPT/8zEuf/dyrH/8tu+//bf + wf/337//99++//fevf/34cT/+uzZ//vw4v/78OP//PHk//zy5v/88+j//PTq//z17P/99u3//ffv//33 + 8P/9+PL//vn0//769v/++/f//vz5//78+v/+/fz//vz6//Pp2//Wwqj/y8O4/9XV1f/a2tr/2dnZ/9XV + 1f7GxsbpfHx8WAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAG80JwBs + OVkAbThtAG04hwBuN9cAbzn/DndE/0GWcP8Nd0T/NpFn/1Ciff8/l2//HoJS/xV8S/9SoX3/g7+m/4jC + qf9Onnn/E3pI/wBuOP4AbzjaAG03ewBnOBsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABRUVEcqqqqstjY + 2P7c3Nz/2tra/9HR0f/JxcD/zsCt/+bRs//03Lz/9969//fdvP/33bv/9929//nn0f/78OP/+/Pm//zz + 6P/89Or//fXs//327f/99+///ffx//348v/++fT//vr1//779//+/Pn//v37//79+//58eb/48+1/8q5 + pP/KxsL/0dHR/9fX1//c3Nz/2dnZ/snJyeh7e3tXAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHA0IgBuOMsBbzr/Mo5k/2+yl/83kWf/E3tJ/ymJ + Xf8Nd0T/Kohc/22xlP+RyLD/dLWY/yqJXP8Fcj3+AG44/gBuOL4AbDg2AG0kBwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAJycnDaGhoZnT09P34ODg/97e3v/S0tL/x8fG/8O8s//Pv6n/5M2v//LZ + t//227n/9tu5//bbuP/23r3/+OfQ//vw4v/89Or//fbu//338P/9+PH//fjz//759f/++/f//vv3//77 + 9//79e3/9OfW/+HLsP/Ktp3/wrqx/8jIyP/Ozs7/2dnZ/9/f3//b29v9v7+/2WxsbEIAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbSQHAG45gQBt + OPkZfk7/aK6Q/327of9ytpn/K4pd/xd9TP9cp4X/jsau/4XAqP9EmHH/B3M//wBuOP4AbznRAG04bQBz + LgsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMzMwqQkJBqzs7O4eLi + 4v7k5OT/2tra/8jIyf+/vrz/vreu/8i5pf/Zw6f/586u/+/Vsv/z2LT/9dm0//batv/33r3/+OPI//no + 0v/769j/++3c//nr2P/25c//8N3E/+TLrP/TvJ//w7Od/7y2rf+/v73/xcXG/9LS0v/g4OD/4+Pj/93d + 3fmxsbGyZWVlLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAbjMeAG45uwBvOf8zjmT/fr2j/4O/pv+Hwan/dLaZ/3i4nP+Pxq//Zq2M/yyK + Xf8Abzn/AG038gBvOaoAbTkxAFUAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABZmZmNLe3t7Xh4eH66enp/ufn5//Z2dn/xcXF/7i4uP+0sq7/tq+m/76x + oP/Jtp//07yg/9vCov/fxaP/4cai/+DEoP/dw57/2b6c/9C4mf/Fspj/u6yb/7WupP+0sq//uLi4/7+/ + wP/Ozs7/4eHh/+jo6P/m5ub+0tLS6ZGRkXQ/Pz8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZjMKAG45jwBtN/segVP/dbaa/4nC + q/+Oxq7/ksix/5HHsP89lGz/DndE/wBvOf4AbTjmAG44aABtMBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcHAmJiYlZxsbGx+np + 6fnv7+/+7u7u/+Tk5P/Q0ND/vb6+/7Cxsf+qqqn/pqak/6Win/+loZz/pJ+a/6Sgmv+loZ3/paKf/6al + pP+qqar/rq6u/7e4uP/FxcX/2NjY/+np6f/u7u7/7e3t/9vb2+uwsLCbW1tbKgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAG0yIwBvN8UBbzr/O5Nq/4nCqv+Lw6v/ZKyM/xl+Tf8AbTj9AG836gBtOaEAaS0RAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAUFBQE5WVlWHHx8e75+fn7/Ly8v329vb/8/Pz/+vr6//e3t7/0dHR/8bG + xv+9vb3/uLi5/7a3t/+5ubn/wcHB/8zMzP/W1tb/5eXl/+7u7v/09PT/9PT0/+3t7frc3NzetLS0lnFx + cTgfHx8IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtNlQAbTj5C3VC/1Oiff86kmn/CXRA/wBu + OP4AbTjIAG44XwB1Og0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqKioMfX19N6+v + r4PR0dHI6Ojo7vf39/77+/v+/Pz8/vz8/P78/Pz//Pz8//v7+//8/Pz/+/v7/vv7+/77+/v++vr6/vLy + 8vjh4eHnxcXFspubm2ZkZGQmAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABV + KgYAbjirAG44/gp1Qf8BcDr+AG83+ABtN6EAbjclAFUAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHBwJWVlZKJGRkVS1tbWEy8vLp9XV1b/e3t7M5OTk1OXl + 5dji4uLW2tray9PT07XCwsKbqampcX9/f0RCQkIXAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaDQnAG44ywBuN/cAbzi+AGs5RwB/AAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABAAAABUxMTApVVVUPYWFhFVxcXBZjY2MSVVVVDz8/PwgAAAADAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVSoGAG81RwBu + OHEAcjQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////4/ + //////////////gf//////////////Af////x////////8AP////g////////4AH////Af///////gAH + ///+AP///////AAD///8AH//////8AAB///4AD//////4AAB///wAB//////gAAA///gAA/////+AAAA + f//AAAf////8AAAAf//AAAP////wAAAAP//AAAH////gAAAAP//gAAD///+AAAAAH//wAAB///8AAAAA + H//4AAA///wAAAAAH//8AAAf//gAAAAAH//+AAAP/+AAAAAAH///AAAH/8AAAAAAA///gAAD/wAAAAAA + Af//wAAB/gAAAAAAAP//4AAA+AAAAAAAAP//8AAAYAAAAAAAAH//+AAAQAAAAAAAAH///AAAAAAAAAAA + AH///gAAAAAAAAAAAP///wAAAAAAAAAAAf///4AAAAAAAAAAB////8AAAAAAAAAAD////+AAAAAAAAAA + P/////AAAAAAAAAAf/////gAAAAAAAAB//////AAAAAAAAAD/////8AAAAAAAAAB/////4AAAAAAAAAB + /////gAAAAAAAAAA/////AAAAAAAAAAAf///8AAAAAAAAAAAf///4AAAAAAAAAAAP///gAAAAAAAAAAA + P///AAAAAAAAAAAAH//+AAAAAAAAAAAAH//+AAAAAAAAAAAAH//+AAAAAAAAAAAAH///AAAAAAAAAAAA + D///AAAAAAAAAAAAA///gAAAAAAAAAAAAf//wAAAAAAAAAAAAP//wAAAAAAAAAAAAP//4AAAAAAAAAAA + AH//8AAAAAAAAAAAAD//8AAAAAAAAAAAAD//+AAAAAAAAAAAAD///AAAAAAAAAAAAB///AAAAAAAAAAA + AB///gAAAAAAAAAAAB///gAAAAAAAAAAAA///wAAAAAAAAAAAA///+AAAAAAAAAAAA////AAAAAAAAAA + AA///8AAAAAAAAAAAAf//4AAAAAAAAAAAAf//gAAAAAAAAAAAAf//AAAAAAAAAAAAAf/8AAAAAAAAAAA + AAf/4AAAAAAAAAAAAAf/gAAAAAAAAAAAAAf/AAAAAAAAAAAAAAf+AAAAAAAAAAAAAAf+AAAAAAAAAAAA + AAf+AAAAAAAAAAAAAAf/AAAAAAAAAAAAAA//AAAAAAAAAAAAAA//gAAAAAAAAAAAAA//wAAAAAAAAAAA + AB//wAAAAAAAAAAAAB//4AAAAAAAAAAAAB//8AAAAAAAAAAAAD//8AAAAAAAAAAAAD//+AAAAAAAAAAA + AH///AAAAAAAAAAAAP///AAAAAAAAAAAAP///gAAACAAAAAAAf///gAAAHAAAAAAA////wAAAfgAAAAA + B////+AAB/wAAAAAD/////AAD/4AAAAAH////+AAP/+AAAAAP////+AAf//AAAAA/////+AB///wAAAB + //////AD///8AAAH//////gP////AAA///////gf////8AP///////x///////////////////////// + //8oAAAAgAAAAAABAAABACAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAbzlQAG053wBtN+8AbzowAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbz8QAG03rwBvOf8Abzn/AG85/wBtOb8AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG83YABt + N+8Abzn/AG85/wBvOf8Abzn/AG85/wBvOHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAG83IABtOb8Abzn/AG85/wBvOf8Abzn/AG85/wBvOf8Abzn/AG037wBv + NyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVKgwIHDZZCRktbwAA + EQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvOHAAbTfvAG85/wBv + Of8Abzn/AG85/wFwO/8BcDv/AG85/wBvOf8Abzn/AG05vwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAETMPIS9Dl0BESfNCQ0b7JC03ygAKFRgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABvOjAAbTm/AG85/wBvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8BcDv/AG85/wBv + Of8Abzn/AG83YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEzDyY1SJhSVFb6WllZ/1NT + Uv9KSkn/JzE62gANGyUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzmAAG85/wBvOf8Abzn/AG85/wBv + Of8BcDv/AXA7/wFwO/8BcDv/AXA7/wFwO/8BcDv/AG85/wBvOf8AbTfvAG8/EAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAARMw8lNEmWWlxe+2JiYf9dXV3/WVlZ/1tbW/9QUFD/KTM61QAYMBUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAbzowAG03zwBvOf8Abzn/AG85/wBvOf8BcDv/AXA7/wFwO/8BcDv/AXA7/wFwO/8BcDv/AXA7/wFw + O/8Abzn/AG85/wBvOf8AbTevAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEjYOIC9Fl1laXPxlZGT/ZGRk/2Ji + Yv9ra2v/WVlZ/0hISP9HR0b/KjU92AAbOy8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbz8QAG85gABvOf8Abzn/AG85/wBvOf8Abzn/AXA7/wFw + O/8BcDv/AXA7/wBvOf8BcDv/AXA7/wFwO/8BcDv/AnA8/wRyPf8Abzn/AG85/wBvOf8AbzlQAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAABM6DR0uQplQUVP9XV1d/2FhYf9lZWX/cnJy/2FhYf9NTU3/Xl5e/15eXv9KSkr/KjE82AAb + PDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG83QABt + Od8Abzn/AG85/wBvOf8Abzn/AXA7/wFwO/8BcDv/AXA7/wBvOf8Abzn/AG85/wBvOf8BcDv/AXA7/wRy + Pf8Fcz7/B3RB/wVzQP8Abzn/AG85/wBtN+8Abz8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASNg4aKz2aR0lK+lRTU/9YWFj/Xl5e/3Bw + cP9kZGT/VFRU/2dnZ/9sbGz/TExM/01NTf9JSUj/LjY+2AAbPDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAG8/EABuOY8Abzn/AG85/wBvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFw + O/8Abzn/AG85/wJwPP8CcDz/AG85/wJwO/8Fcj3/BnNA/wl1Qv8Kd0X/DHhG/wRyPf8Abzn/AG85/wBu + OZ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAETMPFyQ5mzs9PvlISEj/TU1N/1RUVP9nZ2f/XV1d/1JSUv9ra2v/cXFx/1NTU/9YWFj/aGho/1dX + V/9GRkb/KTE72AAbPDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvN0AAbTnfAG85/wBv + Of8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8Abzn/AG85/wFwO/8Gc0D/B3RB/wZzQP8Abzn/AW87/wd0 + Qf8KdUP/DHhG/w55R/8Qekr/EHpK/wBvOf8Abzn/AG85/wBvN0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABI2DhAhNJguMDT6PDs7/0FBQf9ISEj/W1tb/1NT + U/9LS0v/Y2Nj/25ubv9WVlb/X19f/29vb/9fX1//SkpK/1VVVf9RUFD/KzU+2AAbPDcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABvPxAAbTevAG85/wBvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8BcDv/AG85/wBv + Of8Fcz7/CXVD/wl1Qv8HdEH/BnNA/wRyPf8Abzn/BXM+/wx4Rv8PeUj/EHpL/xN9Tf8Vfk//C3hG/wBv + Of8Abzn/AG053wBvPxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAR + Mw8KGzGWIyUn+y8uLv81NTX/PDw8/09PT/9JSUn/QEBA/1hYWP9mZmb/UFBQ/1tbW/9xcXH/ZWVl/1JS + Uv9hYWH/ZmZm/0xMTP9GRUX/KTE72AAbPDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzlQAG037wBvOf8Abzn/AG85/wBv + Of8BcDv/AXA7/wFwO/8BcDv/AG85/wBvOf8BcDv/CXVC/wp3Rf8Kd0P/CXVD/wd0Qf8HdEH/BnNA/wFw + O/8Abzn/DHhH/xF8TP8UfU3/Fn9Q/xmBUv8bglT/BnM+/wBvOf8Abzn/AG45jwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEjYOCBgsmRobHf0iIiL/KCgo/y4uLv9DQ0P/Pj4+/zU1 + Nf9NTU3/XFxc/0dHR/9SUlL/ampq/2NjY/9UVFT/aGho/29vb/9RUVH/UlJS/1paWv9SUVH/KjI92AAb + NzcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAbzcgAG03rwBvOf8Abzn/AG85/wBvOf8BcDv/AXA7/wFwO/8BcDv/AXA7/wBvOf8Abzn/B3RB/wx4 + Rv8MeEb/eKFp/9jHiP/mzI3/oLB1/xV5Rv8Gc0D/BXI+/wBvOf8Ecj3/FX5P/xh/Uf8agVT/HYJV/x+F + V/8dglT/AG85/wBvOf8Abzn/AG83QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcuCwMV + J5kPERL9FxYW/xwcHP8jIyP/Nzc3/zIyMv8pKSn/QUFB/1FRUf88PDz/R0dH/2FhYf9cXFz/TU1N/2Vl + Zf9zc3P/WFhY/1lZWf9paWn/Xl5e/0hISP9HR0f/KjE92AAbPDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG84cABtN+8Abzn/AG85/wBvOf8Abzn/AXA7/wFw + O/8BcDv/AXA7/wBvOf8Abzn/AnI8/wx4Rv8OeUf/DnlH/zaIVP/iyY//vLOl/7+6tf/hzJn/d6Bo/wZz + QP8Fcj7/AnA8/wBvOf8MeEb/G4JU/x6DVv8ihVn/JIZa/yeIXP8VfUz/AG85/wBvOf8AbTfPAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFStqBggL+gwLC/8QEBD/FxcX/ygoKP8lJSX/Hx8f/zU1 + Nf9FRUX/MTEx/zw8PP9WVlb/UVFR/0NDQ/9dXV3/bW1t/1VVVf9bW1v/cXFx/2ZmZv9NTU3/Wlpa/15e + Xv9MTEz/KjE82AAbPDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG83IABt + Ob8Abzn/AG85/wBvOf8Abzn/AXA7/wFwO/8BcDv/AXA7/wFwO/8Abzn/AXA7/wl1Qv8Qekr/D3lI/w95 + SP8OeUf/eaNq/9bDnP/EwsH/09HQ/+LXv/+vt3r/BnNA/wZzQP8Fcj3/AXA7/wBvOf8af1H/I4Za/yWH + W/8oil7/LItg/y6MY/8Gcz7/AG85/wBvOf8AbzmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAP + JJIDAwP/BwcH/wwMDP8aGhr/GRkZ/xUVFf8oKCj/Nzc3/yUlJf8yMjL/SkpK/0ZGRv86Ojr/U1NT/2Nj + Y/9NTU3/VVVV/29vb/9paWn/U1NT/2RkZP9tbW3/UFBQ/0xMTP9HRkb/KjI82AAbPDcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvOHAAbTfvAG85/wBvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFw + O/8Abzn/AG85/wVzPv8Qekr/EXxM/yqFUv8PeUj/D3lI/w55R/82iFT/5cyR/9zXzv/n5N//59Ok/3eg + aP8HdEH/BnNA/wVyPv8Ecj3/AG85/wZzQP8niFz/Kopf/y2MYf8vjWT/M5Bm/yiIXP8Abzn/AG85/wBv + Of8AbzowAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcyTAAEB/UDAwP/CwsL/w0NDf8NDQ3/Ghoa/ycn + J/8bGxv/JiYm/zw8PP85OTn/Ly8v/0dHR/9WVlb/Q0ND/0xMTP9mZmb/YWFh/1BQUP9oaGj/dHR0/1ZW + Vv9UVFT/Wlpa/1NTU/9KSkr/KjI92AAbPDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvOjAAbTfPAG85/wBv + Of8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8Abzn/AG85/wFwO/8LeEX/FH1N/0iQXP++vYH/vr2B/xB6 + Sv8PeUj/DnlH/wx4Rv+HqG7/5syN/+bMjf+vt3r/FXpG/wd0Qf8Gc0D/BXI+/wVyPf8BcDv/AG85/xh+ + UP8ujGP/MY9l/zSQZv83kWn/O5Rr/xp/UP8Abzn/AG85/wBtN88AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAD8EABMqeAACBfYEBAT/BQUF/w4ODv8ZGRn/EhIS/xoaGv8tLS3/LS0t/yQkJP85OTn/SkpK/zg4 + OP9CQkL/Wlpa/1hYWP9JSUn/YWFh/3BwcP9aWlr/XFxc/2JiYv9dXV3/WVlZ/1NTU/9KSkr/KjI92AAb + PDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAbzmAAG85/wBvOf8Abzn/AG85/wBvOf8BcDv/AXA7/wFwO/8BcDv/AG85/wBv + Of8Gc0D/E31N/yKDVP+LqXL/18mV/1641f+5xqX/bp5m/w95SP8OeUf/DnlH/wx4Rv8Ld0X/CndF/wl1 + Q/8JdUL/B3RB/wZzQP8Fcj7/BXI9/wJwPP8Abzn/D3lH/zOQZv82kWj/ZKBz/zyUbf8+lm//PZVu/wl0 + Qf8Abzn/AG85/wBvOYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoGABIseQADBvYDAwP/DAwM/wkJ + Cf8PDw//ICAg/yEhIf8aGhr/LCws/z09Pf8tLS3/NTU1/05OTv9NTU3/Pz8//1VVVf9nZ2f/U1NT/1hY + WP9kZGT/ZGRk/2FhYf9dXV3/WVlZ/1NTU/9KSkr/KjI92AAbPDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzdAAG03zwBvOf8Abzn/AG85/wBv + Of8BcDv/AXA7/wFwO/8BcDv/AG85/wBvOf8BcDv/EXxL/xiBUf9Kkl//zMKG/6rDrf8Rrvv/AKn//yCv + 9P/Yx4r/KoNR/w95SP8OeUf/DHhG/wt3Rf8Kd0X/CndD/wl1Qv8HdEH/BnNA/wZzQP8Fcj3/AnA8/wBv + Of8ihVb/V5xv/9vIi//fx5D/3MiM/4Grff9GmnT/N5Fo/wBvOf8Abzn/AG037wBvNyAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAACoGABIqeQACBfYDAwL/BgYG/xISEv8VFRX/EBAQ/x8fH/8wMDD/IyMj/ykp + Kf9BQUH/QkJC/zQ0NP9KSkr/XV1d/0pKSv9QUFD/XV1d/2FhYf9kZGT/ZGRk/2FhYf9dXV3/WVlZ/1NT + U/9KSkr/KjI92AAbPDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAbz8QAG45jwBvOf8Abzn/AG85/wBvOf8Abzn/AXA7/wFwO/8BcDv/AXA7/wBvOf8Abzn/CXVC/xiB + Uf8lhlb/jKtz/9fJlf9euNX/AKn//wCp//8Aqf//AKn//6rDrf+wuHz/D3lI/w55R/8MeEb/DHhG/wp3 + Rf8Kd0P/CXVD/wd0Qf8HdEH/BnNA/wVyPv8CcDz/AG85/zaQaP/RxIr/yLme/7m1tP/Sx7P/3MmM/0qe + eP9Mn3r/HoJS/wBvOf8Abzn/AG83QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoGABIseQAD + BfYEBAT/CQkJ/wgICP8UFBT/IiIi/xgYGP8eHh7/NTU1/zY2Nv8pKSn/PT09/1JSUv9AQED/RUVF/1RU + VP9YWFj/XV1d/2FhYf9kZGT/ZGRk/2FhYf9dXV3/WVlZ/1NTU/9KSkr/KjI92AAbPDcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG83QABtOd8Abzn/AG85/wBvOf8Abzn/AXA7/wFw + O/8BcDv/AXA7/wBvOf8Abzn/BHI9/xR8TP8dglX/Wpll/9rHiv+awbX/Aqv//wCp//8Aqf//AKn//yCv + 9P+qw63/zMKF/0WPWv8PeUj/DnlH/wx4Rv8MeEb/C3dF/wp3Q/8JdUP/B3RB/wd0Qf8Gc0D/BXI+/wJw + PP8Abzn/NpBo/+bMjf/Bvr3/0M3M/9/c2//mzI3/V6N9/1Gjfv8PeUb/AG85/wBvOf8AbzcgAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoGABIqeQEDBvYDAwL/CQkJ/xMTE/8NDQ3/ExMT/ygo + KP8qKir/Hh4e/zIyMv9GRkb/NDQ0/zk5Of9JSUn/TU1N/1NTU/9YWFj/XV1d/2FhYf9kZGT/ZGRk/2Fh + Yf9dXV3/WVlZ/1NTU/9KSkr/KjI92AAbPDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG8/EABu + OY8Abzn/AG85/wBvOf8Abzn/AXA7/wFwO/8BcDv/AXA7/wFwO/8Abzn/AG85/w54R/8dglX/KodZ/6i1 + fP/XyZX/QLTk/wCp//8Aqf//AKn//wCp//9tus3/5syN/3ykbf8RfEv/EHpK/w95SP8OeUf/DnlH/wx4 + Rv8Ld0X/CndF/wl1Q/8JdUL/B3RB/wZzQP8Fcj7/BHI8/wBvOf8piFz/vr+H/+DOqP/l4dz/6du//9PH + jP9So3//S554/wBvOf8Abzn/AG053wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAACoGABUseQACBfYEBAT/BgYG/woKCv8ZGRn/HBwc/xQUFP8lJSX/ODg4/ygoKP8vLy//PDw8/0FB + Qf9HR0f/TU1N/1NTU/9YWFj/XV1d/2FhYf9kZGT/ZGRk/2FhYf9dXV3/WVlZ/1NTU/9KSkr/KjI92AAb + PDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvOVAAbTfvAG85/wBvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFw + O/8Abzn/AG85/wVyPf8Zf1H/IIVZ/2qfa//ax4r/oMK1/wur//8Aqf//AKn//wCp//8gr/T/ucal/7+9 + gf87jFn/E3xM/xF8TP8Qekr/D3lI/w95SP8OeUf/DHhG/wx4Rv8Kd0X/CndD/wl1Qv8HdEH/BnNA/wZz + QP8Fcj3/AW85/wRyPf9ho3j/v8GI/+bMjf/LxIv/cKuD/1emg/84kmn/AG85/wBvOf8AbjmPAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoGABIseQEDBvYDAwL/CgoK/w4O + Dv8MDAz/GRkZ/ykpKf8dHR3/JCQk/y8vL/81NTX/Ozs7/0FBQf9HR0f/TU1N/1NTU/9YWFj/XV1d/2Fh + Yf9kZGT/ZGRk/2FhYf9dXV3/WVlZ/1NTU/9KSkr/KjI92AAbPDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvPxAAbTevAG85/wBv + Of8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8BcDv/AG85/wBvOf8QeUj/IoVZ/zuPYP+1un//zcie/0i0 + 7v8Lqv//Aqr//wCp//8Cq///bbrN/9rHiv9+pW//FX5P/xR9Tf8TfEz/EXxM/xB6Sv8PeUj/D3lI/w55 + R/8MeEb/DHhG/wp3Rf8Kd0P/CXVD/wd0Qf8HdEH/BnNA/wVyPv8Ecjz/AG85/wp1Qv83kWj/UqN//1al + gv9ZpoX/XKmH/x2BUv8Abzn/AG85/wBvN0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAACoGABUseQACBfYEBAT/BQUF/w0NDf8aGhr/FBQU/xgYGP8iIiL/KCgo/y4u + Lv81NTX/Ozs7/0FBQf9HR0f/TU1N/1NTU/9YWFj/XV1d/2FhYf9kZGT/ZGRk/2FhYf9dXV3/WVlZ/1NT + U/9KSkr/KjI92AAbPDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAbzlQAG037wBvOf8Abzn/AG85/wBvOf8BcDv/AXA7/wFwO/8BcDv/AG85/wBv + Of8HdED/H4NW/yWHXP95pXD/2siK/5K+xv8srv//Gav//xCr//8Hqv//OLLs/8jInv+zuX7/MYpZ/xV+ + UP8Vfk//FH1N/xN8TP8RfEz/EHpL/xB6Sv9Fj1r/DnlH/wx4Rv8MeEb/C3dF/wp3Q/8JdUP/B3RB/wd0 + Qf8Gc0D/BXI+/wVyPf8CcDz/AG85/wBvOf8Abzn/Fn1M/yiIW/9gqor/BnM+/wBvOf8Abzn/AG83QABv + OHAAbzmAAG45nwBuOZ8Abz8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoGABIseQAD + BvYDAwP/DAwM/woKCv8ODg7/FhYW/xwcHP8iIiL/KCgo/y4uLv81NTX/Ozs7/0FBQf9HR0f/TU1N/1NT + U/9YWFj/XV1d/2FhYf9kZGT/ZGRk/2FhYf9dXV3/WVlZ/1NTU/9KSkr/KjI92AAbPDcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzcgAG05vwBvOf8Abzn/AG85/wBv + Of8BcDv/AXA7/wFwO/8BcDv/AXA7/wBvOf8Abzn/FX1M/ymKXv9AkWP/t7qB/9DInv9bs+7/KKv//yOr + //8dq///I67//4e9xv/ax4r/c6Ft/xmBUv8Wf1H/Fn9Q/xV+UP8UfU3/FH1N/xF8TP8RfEv/KoVS/+bM + jf83iFX/G35L/xp9S/8Ld0X/CndF/wl1Q/8JdUL/B3RB/wZzQP8Fcj7/BXI9/wRyPf8CcDz/AXA7/wBv + Of8Abzn/AG85/yyKXv8Abzn/AG85/wBvOf8Abzn/AG85/wBvOf8Abzn/AG85/wBtN68AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoGABIseQACBfYDAwP/BgYG/wwMDP8QEBD/FhYW/xwc + HP8iIiL/KCgo/y4uLv81NTX/Ozs7/0FBQf9HR0f/TU1N/1NTU/9YWFj/XV1d/2FhYf9kZGT/ZGRk/2Fh + Yf9dXV3/WVlZ/1NTU/9KSkr/KjI92AAbPDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAG84cABtN+8Abzn/AG85/wBvOf8Abzn/AXA7/wFwO/8BcDv/AXA7/wBvOf8Abzn/CXRB/ySG + Wf8qi2D/iKt1/+bMjf+Pus3/M6r//y+q//8qqv//J6v//1+15f/NyJ7/tLl//zSLW/8ZgVL/GYFS/xiB + Uf8Wf1D/FX5Q/xR9Tf8UfU3/YZpl/3ykbf8Qekr/eqNr/769gf/LwoX/sLd8/wx4Rv8Kd0X/CndD/wl1 + Qv8HdEH/BnNA/wZzQP8Fcj3/BHI9/wJwPP8BcDv/AXA7/wBvOf8Abzn/AG85/wBvOf8Abzn/AG85/wBv + Of8Abzn/AG85/wBvOf8Abzn/AG85/wBvOVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAACoGABIseQADBvYDAwP/BwcH/wsLC/8QEBD/FhYW/xwcHP8iIiL/KCgo/y4uLv81NTX/Ozs7/0FB + Qf9HR0f/TU1N/1NTU/9YWFj/XV1d/2FhYf9kZGT/ZGRk/2FhYf9dXV3/WVlZ/1NTU/9KSkr/KjI92AAb + PDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG83IABtOb8Abzn/AG85/wBvOf8Abzn/AXA7/wFw + O/8BcDv/AXA7/wFwO/8Abzn/AnI8/xp/UP8tjGP/T5dp/8O/hf/GxqX/Wq/0/zep//80qf//Mqr//zmt + //+rwrX/2seK/1yaaP8dglX/G4JU/xqCVP8ZgVL/GIFR/xZ/UP8VflD/SJFe/yKCUf87i1n/5syN/0aP + W/+IqG//3MOI/4x/ZP/SvIX/Xpdg/wp3Rf8Kd0P/CXVD/wd0Qf8HdEH/BnNA/wVyPv8Fcj3/AnA8/wJw + PP8BcDv/AG85/wBvOf8Abzn/B3RA/x6BUv80kGX/PZVt/0+gfP9hq4v/Qpdw/wBvOf8Abzn/AG053wBv + PxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoGABIqeQACBfYDAwP/BwcH/wsL + C/8QEBD/FhYW/xwcHP8iIiL/KCgo/y4uLv81NTX/Ozs7/0FBQf9HR0f/TU1N/1NTU/9YWFj/XV1d/2Fh + Yf9kZGT/ZGRk/2FhYf9dXV3/WVlZ/1NTU/9KSkr/KjI92AAbPDcAAAAAAAAAAAAAAAAAAAAAAAAAAABv + OYAAbzn/AG85/wBvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8Abzn/AG85/wx3Rf8qil//O5Fm/4qt + eP/mzI3/kbnN/zyo//87qf//Oan//zep//9rtOX/28mV/6m1ff8tiFv/H4NW/x2CVf8dglX/GoJU/xmB + Uv8YgVH/Fn9R/xZ/UP+yuX7/faVu/xN8TP+WrnX/5syN/76qev9bVk3/S0hH/3RrW//Yx4j/GXxK/wp3 + Q/8JdUP/B3RB/wd0Qf8Gc0D/BXI+/wVyPf8CcDz/AnA8/wFwO/8Abzn/AG85/wBvOf8Abzn/W6aF/3y6 + oP9/vaT/g7+m/4bBqf+Iw6v/I4VW/wBvOf8Abzn/AG45jwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAACoGABIseQACBfYDAwP/BwcH/wsLC/8QEBD/FhYW/xwcHP8iIiL/KCgo/y4u + Lv81NTX/Ozs7/0FBQf9HR0f/TU1N/1NTU/9YWFj/XV1d/2FhYf9kZGT/ZGRk/2FhYf9dXV3/WVlZ/1NT + U/9KSkr/KjI92AAcPTYAAAAAAAAAAABvOjAAbTfPAG85/wBvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFw + O/8Abzn/AG85/wRyPP8dglL/Mo9l/1+eb//QxIj/vMKt/1Kq+/89pv//PKb//zuo//9Qrfv/sMG1/9rI + iv9gnGr/IoZa/yCFWf8fg1b/HoNW/x2CVf8bglT/GYFS/zKLWv+/voL/I4VU/y+IV//mzI3/pLN5/9zD + iP94blr/SkdG/01LSv9QTU3/VFFQ/7CfeP+hsnf/CndF/wl1Q/8JdUL/B3RB/wZzQP8Fcj7/BXI9/wRy + Pf8CcDz/AXA7/wBvOf8Abzn/AG85/wBvOf8QeUb/ebme/4W/qP+Hwqr/i8St/4/Gr/91uJv/AG85/wBv + Of8Abzn/AG83QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoGABIseQAC + BfYDAwP/BwcH/wsLC/8QEBD/FhYW/xwcHP8iIiL/KCgo/y4uLv81NTX/Ozs7/0FBQf9HR0f/TU1N/1NT + U/9YWFj/XV1d/2FhYf9kZGT/ZGRk/2FhYf9dXV3/WVlZ/1NTU/9KSkr/JzM91QAePCIAbzmAAG85/wBv + Of8Abzn/AG85/wBvOf8BcDv/AXA7/wFwO/8BcDv/AG85/wBvOf8ReUj/Mo9l/0CUaf+Xsnz/28mV/4W0 + 0/88pP//PKX//z2m//89pv//hrfV/9vJlf+Srnj/Motf/yOGWv8ihlr/IoVZ/x+DV/8eg1b/HYJV/yiH + V/9AkF7/GYFS/7O5fv+LqnP/VpZj/9rHiv+0oXX/Uk1I/0xKSP9PTEv/UlBP/1ZUUv9aVlX/ZWFc/93E + i/9PkVv/CndD/wl1Qv8HdEH/BnNA/wZzQP8Fcj7/BHI9/wJwPP8BcDv/AXA7/wBvOf8Abzn/AG85/wBv + Of9DmXD/iMOr/4zGrv+Qx7D/ksiz/5bLtf9Nnnn/AG85/wBvOf8AbTnfAG8/EAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoGABIseQACBfYDAwP/BwcH/wsLC/8QEBD/FhYW/xwc + HP8iIiL/KCgo/y4uLv81NTX/Ozs7/0FBQf9HR0f/TU1N/1NTU/9YWFj/XV1d/2FhYf9kZGT/ZGRk/2Fh + Yf9dXV3/WVlZ/1NTU/9HR0f/CUY67wBvOf8Abzn/AG85/wBvOf8BcDv/AXA7/wFwO/8BcDv/AG85/wBv + Of8Ecj3/J4db/zeRaf9hoHL/0MSI/7nBrf9Mpfv/OKH//zuk//88pP//Uqr7/7zDrf/Ow4f/V5pp/yeI + XP8lh1v/JIZa/yOGWv8ihVn/IIVX/x6DVv8dglX/aJ5q/83Dhv8lhlb/S5Rg/+bMjf/cw4j/eW9a/0pH + Rv9NS0r/UU9N/1VSUf9XVVT/W1lX/19bWv9hX17/jYNu/9jHiP8YfEj/CXVD/wd0Qf8HdEH/BnNA/wVy + Pv8Fcj3/AnA8/wJwPP8BcDv/AG85/wBvOf8Abzn/AG85/wBvOf9ztZn/kciy/5XJtP+ZzLf/m825/5XJ + s/8KdUL/AG85/wBvOf8AbzhwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAACoGABIseQACBfYDAwP/BwcH/wsLC/8QEBD/FhYW/xwcHP8iIiL/KCgo/y4uLv81NTX/Ozs7/0FB + Qf9HR0f/TU1N/1NTU/9YWFj/XV1d/2FhYf9kZGT/ZGRk/2FhYf9dXV3/WVlZ/1FRUP8ZQz3/AG44/wBv + Of8Abzn/AXA7/wFwO/8BcDv/AXA7/wBvOf8Abzn/E3pK/zeRaf9Flm3/r7mC/9vJlf9yrtz/MZ7//zSg + //83oP//OaP//5G4zP/cyZX/la95/zaNYf8pil7/J4hc/yWHXP8khlr/I4Za/yKGWf8ghVn/qLV8/0+V + Y/8dglX/tLl//7O5fv/ax4r/oJBt/1JPSv9MSkj/T0xM/1JQT/9WVFL/WldW/1xaWf9gXlz/Y2Bf/2Zk + Y/9qZmX/wa2C/5Stcv8JdUP/B3RB/wd0Qf8Gc0D/BXI+/wVyPf8CcDz/AnA8/wFwO/8Abzn/AG85/wBv + Of8Abzn/AG85/2Wtjf+Xy7X/ms24/57Ouv94uJv/FHxK/wBvOf8Abzn/AG85/wBvOHAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoGABIseQACBfYDAwP/BwcH/wsL + C/8QEBD/FhYW/xwcHP8iIiL/KCgo/y4uLv81NTX/Ozs7/0FBQf9HR0f/TU1N/1NTU/9YWFj/XV1d/2Fh + Yf9kZGT/ZGRk/2FhYf9dXV3/V1dW/xxEQP8AbTn/AXA7/wFwO/8BcDv/AXA7/wBvOf8Abzn/B3RA/y6M + Yf88lW3/cKV3/9vIi/+ovLT/MZz//yqb//8unP//Mp///1ao8//GxKX/w7+G/1CXaf8si2D/KYpf/ymK + Xv8niFz/JYdc/yWHW/8jhlr/Updm/yCFWf93o27/zcOG/0KQX/+zuX//0rqD/29mVv9KR0b/TUtK/1FP + Tf9VUlH/WVVU/1tZV/9fW1r/YV9e/2VhYP9pZWT/a2hm/29rav95dG//38eM/0CLVv8JdUL/B3RB/wZz + QP8Gc0D/BXI9/wRyPf8CcDz/AXA7/wBvOf8Abzn/AG85/xN6SP9ws5b/mcy3/5zOuf+VybP/Mo1j/wBv + Of8Abzn/AG85/wBvOf8AbzmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAACoGABIseQACBfYDAwP/BwcH/wsLC/8QEBD/FhYW/xwcHP8iIiL/KCgo/y4u + Lv81NTX/Ozs7/0FBQf9HR0f/TU1N/1NTU/9YWFj/XV1d/2FhYf9kZGT/ZGRk/2FhYf9bW1v/HEZC/wFv + O/8BcDv/AXA7/wFwO/8Abzn/AG85/x2BUf87lGv/SJpw/7K6g//YyJX/V6bi/xuW//8imf//J5r//yyc + //+LtMz/5syN/4utef8ujGP/LYxh/yyLYP8qi2D/KYpe/yiIXv8lh1z/JYdb/y+LXv/ayIr/UpZl/x+D + V//Nw4f/5syN/6CQbf9ST0r/TEpI/1BNTP9UUVD/VlRS/1pXVv9eWln/YF5c/2RgX/9mZGP/amZl/25q + af9wbWv/dHBv/3dzcv90jWn/GXhD/wFvOf8Gc0D/BnNA/wZzQP8Fcj7/BHI9/wJwPP8BcDv/AG85/wBv + Of9Bl2//jcSu/5rNuP+e0Lr/brKU/wp1Qv8Abzn/AG85/wBvOf8AbTfPAG86MAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoGABIseQAC + BfYDAwP/BwcH/wsLC/8QEBD/FhYW/xwcHP8iIiL/KCgo/y4uLv81NTX/Ozs7/0FBQf9HR0f/TU1N/1NT + U/9YWFj/XV1d/2FhYf9kZGT/ZGRk/19fX/8bSEL/AW86/wFwO/8Abzn/AG85/wl0Qf8yjWT/QZdy/4iu + ff/cyIz/grDD/xiU//8Rkv//GJX//x6X//9Vpev/w8Ol/8TBhv9Umm3/MY1k/y+NY/8tjGP/LYtg/yqL + YP8pil//KIhe/yeIXP8lh1v/JIZa/2ugbf/Nw4f/wb6D/8izf/9lXlH/S0hH/01LS/9RT03/VVJR/1lW + Vf9cWVf/X1xb/2NfXv9lY2H/aWVk/2tpaP9va2r/c29u/3VycP9wdHD/JnBL/wBvOf8Abzn/AG85/wJw + O/8HdEH/BnNA/wVyPv8Ecj3/AW87/wBvOf8bgVD/ebme/5nMt/+czrn/lcmz/zKNY/8Abzn/AG85/wBv + Of8AbTfvAG85gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoGABIseQACBfYDAwP/BwcH/wsLC/8QEBD/FhYW/xwc + HP8iIiL/KCgo/y4uLv81NTX/Ozs7/0FBQf9HR0f/TU1N/1NTU/9YWFj/XV1d/2FhYf9kZGT/YmJi/xtK + Qv8Bbzv/AG85/wBvOf8jhVf/Q5lz/1efd/+9v4f/yMSc/zSb6v8AjP//BY///wyR//8gl///jbTD/9vI + i/+Cqnj/M5Bm/zKPZf8xjWT/L41k/y2MY/8ti2D/LItg/ymKX/8pil7/J4hc/yWHXP8lh1v/hal0/+bM + jf+WiGj/SEZF/0xKSP9QTUz/VFFQ/1dVVP9aV1b/XlpZ/2BeXP9kYWD/aGRj/2pmZf9uamn/cG5t/3Rw + b/93c3L/S3Nd/whuPP8Abzn/AG85/wBvOf8Abzn/AG85/wRyPf8Gc0D/AnA8/wBvOf8Abzn/Spx3/5fL + tf+azbj/ntC6/1qmgv8KdUL/AG85/wBvOf8Abzn/AG05vwBvNyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAACoGABIseQACBfYDAwP/BwcH/wsLC/8QEBD/FhYW/xwcHP8iIiL/KCgo/y4uLv81NTX/Ozs7/0FB + Qf9HR0f/TU1N/1NTU/9YWFj/XV1d/2FhYf9hYWH/GEpC/wBuOf8OeEX/OZJq/0aadP+Lr3//3MiM/36v + w/8Jj///AIv//wCL//8Ajf//QJ/q/8zEnP+6vYX/TJlt/zaRaP8zkGb/Mo9l/zKPZf8vjWT/Loxj/y2L + Yf8si2D/KYpf/ymKXv8niFz/JYdc/zGLXv/ayIr/jYFk/0tIR/9PTEv/UU9N/1VSUf9ZVlX/XFlX/19c + W/9jX17/ZWNh/2llZP9taWj/b2tq/3Nvbv91cnD/aXNr/x5wSP8Abzn/AG85/wBvOf8Abzn/AG85/wBv + Of8Abzn/AG45/wFwOv8Abzn/G4FQ/3m5nv+ZzLf/nM65/4vEq/8oiFr/AG85/wBvOf8Abzn/AG037wBv + OHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoGABIseQACBfYDAwP/BwcH/wsL + C/8QEBD/FhYW/xwcHP8iIiL/KCgo/y4uLv81NTX/Ozs7/0FBQf9HR0f/TU1N/1NTU/9YWFj/XV1d/1xb + Wv8WSD3/JYZZ/0qceP9lpHr/yMOI/7q/pP80m+r/AIv//wCL//8Ai///CY///3+vw//byIv/hqt6/ziS + av83kWn/NpFo/zSQZv8yj2X/Mo9l/zGNZP9RmWr/la96/yyLYP8qi2D/KYpe/yiIXv8lh1z/JYdb/2Cc + av/cxIr/WVVQ/1RRUP9XVVT/W1dW/15bWv9hXlz/ZGFg/2hkY/9qaGb/bmpp/3Jubf90cG//eHRy/0Ry + Wv8Ibjz/AG85/wBvOf8Abzn/AG85/wFwO/8BcDv/AG85/wBvOf8Abzn/AnA7/1Sjfv+Xy7X/ms24/57Q + uv9apoL/CnVC/wBvOf8Abzn/AG85/wBtN68AbzcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAACoGABIseQACBfYDAwP/BwcH/wsLC/8QEBD/FhYW/xwcHP8iIiL/KCgo/y4u + Lv81NTX/Ozs7/0FBQf9HR0f/TU1N/1NTU/9WVVP/ZGx1/4SOj/8+dlz/l7SD/+bMjf9wq8v/AIv//wCL + //8Ai///AIv//0Of4f/XyJX/srqD/0aXb/87lGv/OZJq/zeRaf82kWj/NJBm/zOQZv89kmj/PJFm/zuR + Zf/byIv/Zp9u/1qba/9Mlmj/KIhe/yeIXP8lh1z/JIZa/6m3ff+ol3P/WVZV/1xaWf9fXFv/Y2Bf/2Zj + Yf9pZWT/bWlo/29ta/9zb27/d3Nw/2FzaP8ecEj/AG85/wBvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFw + O/8BcDv/AG85/wBvOf8Abzn/X6mH/5zOuf+BvqP/HoJS/wBvOf8Abzn/AG85/wBtN+8AbzlQAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoGABIseQAC + BfYDAwP/BwcH/wsLC/8QEBD/FhYW/xwcHP8iIiL/KCgo/y4uLv81NTX/Ozs7/0FBQf9HR0f/TExL/15n + cf/d4eb/2dnY/5ycmP+Ljnz/JZfx/wCL//8Ai///AIv//wmP//+cuLT/3MiM/3Omef89lW7/PJVt/zuU + a/85kmr/N5Fp/zaRaP80kGb/M5Bm/5eyfP+uuIH/L41k/3Okcv/byIv/5syN/8O/hf8pil7/J4hc/yWH + XP8lh1v/PI9g/9rIiv9/d2b/YV5c/2RhYP9oZGP/a2hm/25qaf9ybm3/dHBv/3h0c/88clb/AG85/wBv + Of8Abzn/AG85/wBvOf8BcDv/AXA7/wFwO/8BcDv/AXA7/wFwO/8BcDv/AG85/wBvOf8KdED/S512/wBv + Of8Abzn/AG85/wBvOf8AbTevAG8/EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoGABIseQAEBvsDAwP/BwcH/wsLC/8QEBD/FhYW/xwc + HP8iIiL/KCgo/y4uLv81NTX/Ozs7/z8/P/86RE7/lJeb/93c2//4+Pj/1tbW/46YoP8Kabn/AIv//wCL + //9SpNr/18iV/7O8hf9LmnL/PpZv/z6Wb/88lW3/O5Rt/zmSav84kmr/NpFo/6S1f/8+lGn/PZJo/9vI + i/+WsHz/28iL/7Shdf9RTUj/ybSB/4eqdf8oiF7/JYdc/yWHW/8jhlr/eKVw/9a+h/9uaWT/amZl/21p + aP9wbWv/c29u/3dzcv9idGn/F29D/wBvOf8Abzn/AG85/wBvOf8BcDv/AXA7/wFwO/8BcDv/AXA7/wFw + O/8BcDv/AXA7/wFwO/8Abzn/AG85/wBvOf8Abjj/AG85/wBvOf8AbTnfAG85UAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABv + OjAAajjQAEMz/wAGB/8DAwP/BwcH/wsLC/8QEBD/FhYW/xwcHP8iIiL/KCgo/y4uLv8xMTH/MjtF/19i + ZP9xcXD/oqKi/9jY2P/4+Pj/2dnZ/4+bpf8WheH/q7yt/9LGi/9tpXn/Qpdy/0GXcv9Alm//PpZv/z2V + bv87lG3/O5Rr/0OWbf83kWn/r7mC/665gf8+lGn/ub2D/9zDiP94b1r/SkdG/01LSv9tZVn/5syN/0uV + Zv8niFz/JYdb/ySGWv8ihlr/tbqB/7Cgff9ua2r/cm5t/3VycP9wdHD/PHJW/wBvOf8Abzn/AG85/wBv + Of8Abzn/AXA7/wFwO/8BcDv/AXA7/wBvOf8BcDv/AXA7/wFwO/8BcDv/AnA8/wRyPf8Abzn/AG85/wBv + Of8Abzn/AG45jwBvPxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvPxAAbjmPAG85/wBvOf8AbDn/AEQy/wAICf8DAwL/BwcF/wsL + Cv8REA//FxYV/x0cG/8jIiH/Jycm/zdASP+prK7/kJCQ/2hoaP9vb2//oqKi/9nZ2f/u7u7/V3uR/9PE + kv+gt4P/T551/0OZc/9DmXP/QZdy/0CWb/8+lm//PZVu/zuUbf9bnnL/28iL/0KVa/9BlWr/5syN/9vI + i/+0oXX/Uk1I/0xKSP9PTEv/UlBP/1ZUUv+gkXL/w7+F/yeIXP8lh1z/JIZa/yOGWv87j1//2seK/4iB + dP93c3L/W3Nl/w9vQP8Abzn/AG85/wBvOf8Abzn/AXA7/wFwO/8BcDv/AXA7/wBvOf8Abzn/AG85/wBv + Of8BcDv/AXA7/wRyPf8Fcz7/B3RB/wVzQP8Abzn/AG85/wBuN/MAbz8QAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzdAAG053wBv + Of8Abzn/AG85/wBvOf8BbTv/AU42/wAlIv8CGx3/Ax4c/wYfIf8KJyb/Fi4x/x47Pf8mODj/0tbb/+fn + 5/+9vb3/j4+P/2hoaP9vb2//nJyc/3Jycv99emz/cKZ9/0ebdf9GmnT/Q5lz/0OZc/9Cl3L/QJZw/z6W + b/99qnr/fKl5/zuUa/+lt4H/r7mC/7q9hf/SuoP/b2ZW/0pHRv9NS0r/UU9N/1VSUf9XVVT/W1lX/19b + Wv/NuIX/h6p1/yWHXP8lh1v/I4Za/yKGWf93pG//xbeD/zVxU/8Abzn/AG85/wBvOf8Abzn/AG85/wFw + O/8BcDv/AXA7/wFwO/8Abzn/AG85/wJwPP8CcDz/AG85/wJwO/8Fcj3/BnNA/wl1Qv8Kd0X/DHhG/wRy + Pf8Abzn/AG85/wBuOZ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAbz8QAG45jwBvOf8Abzn/AG85/wBvOf8Abzn/AXA7/wFwO/8BcDv/AW07/wBm + OP8AZjn/IH1U/0WSdP9VnXv/qrOC/8y/jf9wnK7//f39/+fn5/+9vb3/jo6O/2ZmZv+Kior/rq6u/42N + jf9ne3P/SZh1/0aadP9FmnT/Q5lz/0KXcv9VnnT/PpZv/2ikd//byIv/Rpdu/5CvfP/mzI3/oJBt/1JP + Sv9MSkj/T0xM/1JQT/9WVFL/WldW/15aWf9gXlz/ZGBf/353av/ayIv/PZBj/yWHW/8jhlr/IoZa/xh/ + UP8YeEL/AG85/wBvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8Abzn/AG85/wFwO/8Gc0D/B3RB/wZz + QP8Abzn/AW87/wd0Qf8KdUP/DHhG/w55R/8Qekr/EHpK/wBvOf8Abzn/AG85/wBvN0AAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG85UABtOd8Abzn/AG85/wBv + Of8Abzn/AXA7/wFwO/8BcDv/AXA7/wBvOf8Abzn/CnVC/z2Wbf9Ro37/f6+D/93JjP+awbX/Aqv//wCh + 8/9Xlrf//f39/+fn5/+6u7v/n5+f//Hx8f/b29v/sbGx/4qKiv9ne3L/SZh1/0WadP9DmXP/Q5lz/8fC + iP+Irn3/PpZv/6a4gv/byIv/0rqD/29mVv9LSEf/TUtK/1FPTf9VUlH/WVVU/1tZV/9fW1r/YV9e/2Vj + Yf9pZWT/a2lo/7Khfv+3uoH/JYdb/yKFWP8LdkP/AG85/wBvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFw + O/8BcDv/AG85/wBvOf8Fcz7/CXVD/wl1Qv8HdEH/BnNA/wRyPf8Abzn/BXM+/wx4Rv8PeUj/EHpL/xN9 + Tf8Vfk//C3hG/wBvOf8Abzn/AG053wBvPxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAG8/EABtN68Abzn/AG85/wBvOf8Abzn/AXA7/wFwO/8BcDv/AXA7/wFwO/8Abzn/AG85/yOG + V/9Mn3r/ZKiB/8HCiv/NyJ7/T7Xl/wCp//8Aqf//AKn//wCh8/+FnaD/8fDt/2aBcf+1urj/+Pj4//j4 + +P/a2tr/sbGx/4qKiv9ne3L/W513/5+1gv9DmXP/aqV5/9zIjP+ctIH/5syN/5aIaP9ST0r/TEpI/1BN + TP9UUVD/VlRS/1pXVv9eWln/YF5c/2RgX/9oZGP/amZl/25qaf9wbm3/fHdw/9jBiv9TlGD/AnA6/wBv + Of8Abzn/AG85/wBvOf8BcDv/AXA7/wFwO/8BcDv/AG85/wBvOf8BcDv/CXVC/wp3Rf8Kd0P/CXVD/wd0 + Qf8HdEH/BnNA/wFwO/8Abzn/DHhH/xF8TP8UfU3/Fn9Q/xmBUv8bglT/BnM+/wBvOf8Abzn/AG45jwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvOVAAbTfvAG85/wBvOf8Abzn/AG85/wFw + O/8BcDv/AXA7/wFwO/8Abzn/AG85/w95Rv89lm3/UaN+/5K0hf/dyYz/lb3G/y+u//8Uq///Aqr//wCp + //8xsuz/yMie/7i5hP9ViWv/Tp16/2Kfg/+6vr3/+Pj4//j4+P/a2tr/sbGx/4qKiv9pfHL/zMGJ/4uv + fv9goXf/0saK/8izf/9lXlH/S0hH/01LS/9RT03/VVJR/1lWVf9cWVf/X1xb/2NfXv9lY2H/aWVk/21p + aP9va2r/c29u/3VycP9pc2v/L3dN/wBvOf8Abzn/AG85/wBvOf8BcDv/AXA7/wFwO/8BcDv/AXA7/wBv + Of8Abjj/B3RB/wx1RP8Md0X/d6Bo/9fGh//mzI3/oLB1/xV5Rv8Gc0D/BXI+/wBvOf8Ecj3/FX5P/xh/ + Uf8agVT/HYJV/x+FV/8dglT/AG85/wBvOf8Abzn/AG83QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABv + NyAAbTm/AG85/wBvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8BcDv/AG85/wBvOf8pilz/UaN+/2So + gf/Bwor/0cee/2Sy7P8yqv//Kar//x6r//8brf//f73E/93JjP+StIX/UaN+/1Gjfv9Ro37/UKF9/2Ce + g/+6vrz/+Pj4//j4+P/a2tr/sbGx/4qKiv9wfXP/1sOK/+bMjf+WiGj/SEZF/0xKSP9QTUz/VFFQ/1dV + VP9aV1b/Xlta/2BeXP9kYWD/aGRj/2poZv9uamn/cm5t/3Rwb/93c3L/RHJa/whuPP8Abzn/AG85/wBv + Of8Abzn/AXA7/wFsOf8JaTv/FGxC/yp0UP89fl7/WIxz/2aWgP95n43/c56K/4Skj//Ct57/r6qj/6up + pv/AsY//c5Nn/wtsP/8GbTz/AnA8/wBvOf8MeEb/G4JU/x6DVv8ihVn/JIZa/yeIXP8VfUz/AG85/wBv + Of8AbTfPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzhwAG037wBvOf8Abzn/AG85/wBvOf8BcDv/AXA7/wFw + O/8BcDv/AG85/wBvOf8PeUb/Qply/1Gjfv+cuIb/3cmM/5G4zP9Hqf//O6n//zap//8vqv//VrPu/83I + nv/Bwor/ZKiB/1Gjfv9Ro37/UaN+/1Gjfv9QoX3/TaB8/2Cdgv+6vrz/+Pj4//j4+P/a2tr/sbGx/4qK + iv+DfnP/XFdP/0tIR/9PTEv/UlBP/1VSUf9ZVlX/XFlX/19cW/9jX17/ZmNh/2llZP9taWj/b21r/3Nv + bv91cnD/aXNr/x5wSP8Abzn/AG85/wBvOf8Aazf/Cmk8/yNwS/9ViXD/jKmb/7vLw//h5+T/7PDu//j5 + +f/5+vr///////7+/v/+/v7//Pz8//z8/P/+/v7/+Pj4//b19f/p6eb/vs3G/46snv9ViXD/JHFM/whp + Ov8ZfE//I4Za/yWHW/8oil7/LItg/y6MY/8Gcz7/AG85/wBvOf8AbzmAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzcgAG05vwBv + Of8Abzn/AG85/wBvOf8BcDv/AXA7/wFwO/8BcDv/AXA7/wBvOf8Fcz3/Loxg/1Gjfv9tqoH/y8SL/8TD + pf9XqfP/O6T//z2l//88qP//Rav//6/Btf/dyYz/irKF/1Gjfv9Ro37/UaN+/1Gjfv9Ro37/UaN+/1Ch + ff9PoXz/TZ96/2Cdgv+6vrz/+Pj4//j4+P/a2tr/sbGx/4qKiv9paGj/Uk9O/1RRUP9XVVT/W1dW/15b + Wv9hXlz/ZGFg/2hkY/9raGb/bmpp/3Jubf90cG//eHRy/0RyWv8Ibjz/AG85/wBvOf8GaDj/LXJQ/26W + g/+3yMD/5+ro//b29v/7+/v/+/v7//v7+//9/f3//Pz8//7+/v/7+/v//f39//v7+//8/Pz//v7+//39 + /f/9/f3//f39//z8/P/7+/v/+vr6//j4+P/n6+n/ucjA/3CXhf9Dgmb/LIJc/yyJX/8vjWT/M5Bm/yiI + XP8Abzn/AG85/wBvOf8AbzowAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAG85gABtN+8Abzn/AG85/wBvOf8Abzn/AXA7/wFwO/8BcDv/AXA7/wBv + Of8Abzn/FHxL/0ecdf9Ro37/nLiG/+bMjf+Cssz/KZv//zKf//84of//PKT//3Ky5P/cyZX/uL+I/1ql + f/9Ro37/UaN+/1Gjfv9Ro37/UaN+/1Gjfv9apX//f6+C/0+hfP9NoHz/TJ96/1+dgf+6vrz/+Pj4//j4 + +P/a2tr/sbGx/4qKiv9ramr/WldW/1xaWf9fXFv/Y2Bf/2ZjYf9pZmX/bWlo/3Bta/9zb27/d3Nw/2J0 + aP8Xb0P/AG85/wBtOP8NaDz/SH5k/6C1q//i5+T/9vb2//T09P/19fX/+Pj4//T09P/u7u7/5+fn/9fX + 1//S0tL/xMTE/8HBwf+3t7f/ubm5/7q6uv+8vLz/x8fH/8/Pz//X19f/5ubm/+/v7//19fX/9/f3//b2 + 9v/19fX/9vb2/+Pm5P+ywbr/Y5F8/zqFY/82j2j/O5Rr/xp/UP8Abzn/AG85/wBtN88AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG86MABtN88Abzn/AG85/wBv + Of8Abzn/AXA7/wFwO/8BcDv/AXA7/wBvOf8Abzn/BXM9/y6MYP9Ro37/d62C/9PHjP+rvK3/MZvx/xaV + //8jmf//LZz//0Cj//+wv7T/3cmM/3+vg/9Ro37/UaN+/1Gjfv9Ro37/UaN+/1Gjfv9Ro37/UaN+/2So + gf/dyYz/a6l//1ejff9WoXz/S555/16dgP+6vrz/+Pj4//j4+P/a2tr/sbGx/4qKiv9tbGz/Yl9d/2Rh + YP9oZGP/a2hm/25rav9ybm3/dXJv/3h0c/88clb/AG85/wBuOP8JZzn/TYFo/7HBuf/m6ej/8vLy//Dw + 8P/w8PD/7e3t/+Hh4f/Ozs7/wMDA/7S0tP+srKz/qamp/6SkpP+kpKT/oKCg/6CgoP+enp7/np6e/6Ch + of+goKD/o6Sj/6ampv+pqan/sLCw/729vf/Q0ND/4ODg/+3t7f/y8vL/8fHx//Hx8f/r7Ov/xs3I/3OY + iP8/iGf/PJNs/wl0Qf8Abzn/AG85/wBvOYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABvOYAAbzn/AG85/wBvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8Abzn/AG85/xl/ + T/9HnHX/WqV//6W6h//XyJX/YajS/wCL//8AjP//DpH//xuW//96sNP/28mV/6W6h/9apX//UaN+/1Gj + fv9Ro37/UaN+/1Gjfv9Ro37/UaN+/5y4hv+luof/UaN+/5y4hv/JxIr/3MmM/7/BiP9Lnnn/Sp54/16b + gP+6vrz/+Pj4//j4+P/a2tr/sbGx/4qKiv9ubm3/amZl/21paP9wbWv/c3Bu/3dzcv9bc2X/F29D/wBv + Of8Dajj/N3VX/6i4sP/m5+f/6+vr/+zs7P/r6+v/4+Pj/9HR0f+/v7//tra2/7Ozs/+vr6//ra2t/6ur + q/+oqKj/p6em/6ampP+mpaT/pqWj/6akov+lpKL/pqWi/6ako/+mpqX/p6am/6ioqP+rq6z/ra2t/6+v + r/+0tLT/vb29/8/Pz//h4eH/7Ozs/+3t7f/u7u7/6enp/8HFwP9pkoD/N4hj/wBvOf8Abzn/AG037wBv + NyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzhwAG85/wBvOf8Abzn/AG85/wFw + O/8BcDv/AXA7/wFwO/8BcDv/AG85/wVzPf84kmn/UaN+/2Sogf/Tx4z/q7yt/xiU+f8Ai///AIv//wCL + //8flvn/sr6t/9PHjP93rYL/UaN+/1Gjfv9Ro37/UaN+/1Gjfv9Ro37/UaN+/4qyhf9apX//ZKiB/93J + jP93rYL/uL+I/9zDiP+Dd1//0ryF/4+ygv9Knnj/Spx4/1yagP+6vrz/+Pj4//j4+P/a2tr/sbGx/4qK + iv9xcG//cm5t/3VycP9pbWn/PGlS/yRqSP8oZkj/LWNI/32Xiv/d397/5ubm/+fn5//o6Oj/39/f/8zM + zP++vr7/urq6/7m5uf+1tbX/srKy/7KxsP+0sq//u7iz/8O+uP/Lxr7/0svC/9jQx//b08n/3dXK/9vU + yf/a0cb/1s3D/8/Ivf/Jwbj/v7my/7i0rf+zr6z/sbCu/7Kzs/+2trf/uLi4/729vf/Jycn/29vb/+jo + 6P/q6ur/6Ojo/+Hj4v+er6f/NHlY/wBtOP8Abzn/AG83QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABvOHAAbzn/AG85/wBvOf8BcDv/AXA7/wFwO/8BcDv/AXA7/wFwO/8Abzn/FHxL/1Gj + fv9Ro37/UaN+/8HCiv9wq8v/AIv//wCL//8Ai///YajS/9fIlf+luof/WqV//1Gjfv9Ro37/UaN+/1Gj + fv9Ro37/UaN+/1Gjfv9Ro37/wcKK/6W6h/9Ro37/uL+I/+bMjf+qmXL/Uk9I/0xKSP90bVz/3MmM/16k + fP9KnHj/SJx3/1yafv+6vrz/+Pj4//j4+P/a2tr/sbGx/4uLi/9tbGz/Y25o/19waP9scW//amtr/3R1 + dP/Cw8L/4uLi/+Pj4//k5OT/3t7e/8/Pz//ExMT/wcHB/7+/v/+7urr/ubi3/727uP/Jxb//2NLK/+Xe + 1f/v593/9Ozh//fv5P/68eX/+vDk//vx5f/68OT/+/Dj//vw4v/67+D/+e7f//Xq3P/x5tf/69/R/+HW + yP/Sybz/w7yz/7u2sf+4t7X/vLu7/76/v//BwcH/y8vL/93d3f/l5eX/5OTk/+Pj4//Hzsv/SHxj/wRp + OP8AbzcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG8/EABtOd8Abzn/AG85/wFw + O/8BcDv/AXA7/wFwO/8BcDv/AXA7/wFwO/8Abzn/M5Bk/1Gjfv9Ro37/ZKiB/93JjP8ll/H/JZfx/7q/ + pP/LxIv/d62C/1Gjfv9Ro37/UaN+/1Gjfv9Ro37/UaN+/1Gjfv9tqoH/y8SL/1qlf/9kqIH/3cmM/8vE + i//SuoP/b2ZW/0pHRv9NS0r/UU9N/1VSUf+omXT/tb2H/0qeeP9InHj/R5t1/1yafv+6vrz/+Pj4//j4 + +P/b29v/qqqq/5iYmP+Sk5L/hISE/21tbf+EhIT/ysrK/+Dg4P/g4OD/4ODg/9bW1v/Ly8v/yMjI/8TE + xP/Av7//v727/8jFv//Z1M3/6+Tb//Xu5P/68+n//PTq//zz6P/88+j//PPn//zy5v/88uX//PHk//zx + 5P/88eP//PHi//vw4f/78OD/++/f//vv3//7797/+u3d//jq2f/y5NP/5NfH/9LHuv/Cu7L/vbu3/8HA + wP/ExMT/yMjI/9HR0f/g4OD/4uLi/+Dg4P/X2dj/eZWH9kVFRTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAG83QABvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8BcDv/AXA7/wBv + Of8Fcz3/TJ96/1Gjfv9Ro37/nLiG/8jEnP/mzI3/nLiG/1Gjfv9Ro37/UaN+/1Gjfv9Ro37/UaN+/1Gj + fv9tqoH/baqB/1Gjfv/Bwor/pbqH/5K0hf/dyYz/oJBt/1JPSv9MSkj/UE1M/1RRUP9WVFL/WldW/2Vh + XP/Wvof/eq1+/0qceP9Hm3X/R5t1/1qaff+7v73/+Pj4/97e3v+/v7//tbW1/6Kiov+CgoL/m5ub/9bW + 1v/c3Nz/3t7e/9vb2//T09P/zc3N/8vLy//Hxsb/w8G//8zIxP/h29P/8uzj//vz6v/89Or//PXq//z0 + 6f/88+j//PPo//zz5//88ub//PLl//zy5f/88eT//PHj//zx4v/78OH/+/Dg//vv3//7797/++/e//vu + 3f/77dz/++3b//vt2//67Nr/9+jV/+zey//Yy7v/x7+0/8K/vP/IyMj/ysrL/9DQ0P/a2tr/39/f/97e + 3v/b29v/tbW11FJSUkQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG45jwBv + Of8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8CcDz/AnA8/wBvOf8Zf0//UaN+/1Gjfv9Ro37/rr2I/22q + gf9Ro37/UaN+/1Gjfv9Ro37/UaN+/1Gjfv9Ro37/UaN+/4qyhf/Tx4z/WqV//3+vg//mzI3/yLJ//29m + Vv9LSEf/TUtL/1FPTf9VUlH/WVZV/1tZV/9fXFv/YV9e/42Db//cyYz/VKB5/0ebd/9Hm3X/Rpp0/1OU + eP+nqqn/zMzM/9jY2P/Gxsb/np6e/6qqqv/c3Nz/2NjY/9vb2//a2tr/1NTU/9LS0v/Nzc3/x8bF/8vI + w//g29T/9O3k//z17P/99ez//PXr//z16v/89On//PPo//zz5//88+f//PLm//zy5f/88uX//PHk//zx + 4//88eL/+/Dh//vw4P/779//++/f//vu3v/77t7/++3c//vt2//77dv/++za//vs2f/669j/+uvX//fp + 1P/s3cr/1sq5/8a/tf/Ix8X/zs7O/9LS0v/X19f/3d3d/9vb2//b29v/vb294V1dXVIAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbz8QAG053wBvOf8Abzn/AXA7/wFwO/8BcDv/AnA8/wVy + Pv8HdEH/BHI9/wBvOf84kmn/UaN+/1Gjfv9Ro37/UaN+/1Gjfv9Ro37/UaN+/1Gjfv9Ro37/UaN+/8HC + iv9/r4P/UaN+/8HCiv/Bwor/5syN/5aIaP9IRkX/TEpI/1BNTP9UUVD/V1VU/1pXVv9eWln/YF5c/2Rg + X/9oZGP/amZl/8Gugv+1vYf/SJx3/0ebdf8wjWH/BnA8/3mWiP/09PT/5+fn/729vf+zs7P/1dXV/9XV + 1f/Y2Nj/29vb/9jY2P/V1dX/z8/P/8nIxf/Y1M3/8Ori//v06//99u3//fXr//316//89er//PTq//zz + 6P/88+f//PPn//zy5v/88uX//PLl//zx5P/88eP//PDi//zw4f/78OD/++/f//vv3//77t7/++7d//vt + 3P/77dv/++3b//vs2f/77Nn/+uvY//rr1//669b/+urW//rq1P/25tD/59fD/8/DtP/JxL//0dHR/9XV + 1f/Y2Nj/29vb/9jY2P/Y2Nj/sLe09ipoSb8AaTwRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAbzlQAG85/wBvOf8Abzn/AXA7/wRyPf8Gc0D/B3RC/wp3Q/8LeEX/AXA7/wVzPf9Mn3r/UaN+/1Gj + fv9Ro37/UaN+/1Gjfv9Ro37/WqV//4qyhf9Ro37/f6+D/9PHjP93rYL/y8SL/8izf/9lXlH/S0hH/09M + S/9RT03/VVJR/1lWVf9cWVf/X1xb/2NfXv9lY2H/aWVk/21paP9va2r/enVv/9/HjP9qo3X/EnlI/wBv + Of8Qaj7/ytHO//7+/v/b29v/ubm5/9HR0f/S0tL/19fX/9zc3P/b29v/2NjY/9DPzv/Nysb/5eDY//jy + 6v/99u3//fbs//316//89ev//PXq//z06v/88+j//PPn//zz5//88ub//PLm//zy5f/88eT//PHj//zw + 4v/78OH/+/Dg//vv4P/779//++7e//vu3f/77dz/++3c//vt2//77Nn/++zZ//rr2P/669f/+uvW//rq + 1v/66tT/+unT//ro0//559L/8eDJ/9nKt//Kw7r/09LR/9jY2P/b29v/2dnZ/9bW1v/U1NT/qLKt/yNm + RscAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbTevAG85/wBvOf8BcDv/B3RB/wl1 + Q/8Ld0X/DnlH/w96SP8MeEf/AG85/yOGV/9Ro37/UaN+/1Gjfv9Ro37/UaN+/1Gjfv9apX//3cmM/3+v + g/9apX//08eM/9zDiP+WiGj/SEZF/0xKSv9QTUz/VFFQ/1dVVP9aV1b/Xlta/2FeXP9kYWD/aGRj/2po + Zv9uamn/cm5t/3Rwb/94dHL/V4Je/w10Pf8Abzn/AG85/zFvUP/4+Pj/6urq/7u7u//Nzc3/0dHR/9TU + 1P/e3t7/3t7e/9vb2//R0M//0c7J/+zm3//89e3//fbt//327P/99ez//PXr//z06v/89Or//PPo//zz + 6P/88+f//PLm//zy5f/88uX//PHk//zx4//88OL/+/Dh//vv4P/77+D/++/f//vv3v/77t3/++3c//vt + 2//77dv/++za//vs2f/669j/+uvX//rq1v/66tb/+urU//rp1P/66NP/+ujS//ro0f/659D/9ePL/+DQ + u//Mwrb/1NPR/9vb3P/e3t7/2NjY/9LS0v/S0tL/n6ym/yNbQHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABvPxAAbTfvAG85/wBvOf8Gc0D/DHhG/w95SP8Qekr/E3xM/xR9T/8HdEH/AG85/z2W + bf9Ro37/UaN+/1Gjfv9Ro37/UaN+/1Gjfv9/r4P/08eM/9PHjP++qnr/W1ZN/0tIR/9PTEv/UlBP/1ZU + Uv9ZVlX/XFlX/19cW/9jX17/ZmNh/2llZP9taWj/b21r/3Nvbv93c3D/aXNr/x5wSP8Abzn/AG85/wBv + Of8Abzn/UH5o//Pz8/+9vb3/ycnJ/83Nzf/S0tL/39/f/+Hh4f/d3d3/09LQ/9XRy//x6+P//Pbu//32 + 7f/99uz//fXs//z16//89er//PTp//zz6P/88+j//PPn//zy5v/88uX//PHk//zx5P/88eP//PHi//vw + 4f/77+D/++/f//vv3//7797/++7d//vt3P/77dv/++zb//vs2v/77Nn/+uvY//rr1//66tb/+urW//rq + 1P/66dT/+ujT//ro0v/66NH/+ufQ//nnz//55s7/9+TM/+bVvf/OwrT/19XT/97e3//g4OD/19fX/9DQ + 0P/Pz8//ipuT+StIOTUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvOVAAbzn/AG85/wFv + O/8PeUj/EXxL/xR9Tf8VflD/GIFR/xmBUv8CcDv/CnVC/zOQZP8pilz/Loxg/0KZcv9Ro37/WqV//6W6 + h//cw4j/jH9k/0pHRv9NS0r/UE1M/1RRUP9XVVT/W1dW/15bWv9hXlz/ZGFg/2hkY/9raGb/bmpp/3Ju + bf90cG//eHRz/zxyVv8Abzn/AG85/wBvOf8Abzn/AG85/wFwO/9lh3f/ysrK/8DAwP/Ly8v/zs7O/9/f + 3//k5OT/4eHh/9XU0v/X083/8+3m//327v/99u3//fbs//317P/89ev//PXq//z06f/88+j//PPo//zz + 5//88ub//PLl//zy5f/88eT//PHj//zx4v/78OH/+/Dg//vv3//7797/++/e//vu3f/77dz/++3b//vt + 2//77Nn/++zZ//rr2P/669f/+uvW//rq1f/66dT/+unU//ro0//66NL/+ujR//rn0P/558//+ebO//nm + zv/55sz/+OTL/+jWvf/Pw7T/2tjW/+Hh4v/i4uL/1NTU/83Nzf/Jycn/cId82x8fHxAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtN68Abzn/AG85/wZzQP8UfU//Fn9R/xmBUv8bglX/H4NW/xh+ + T/8Abzn/AG85/wBvOf8Abzn/AG85/xR8S/9Qn3f/3cmM/42BZP9LSEf/T0xL/1JQT/9WVFL/WVZV/1xa + Wf9gXFv/Y2Bf/2ZjYf9pZmX/bWlo/3Bta/9zb27/d3Ny/2J0af8Xb0P/AG85/wBvOf8Abzn/AG85/wFw + O/8BcDv/AXA7/1JxYv+6urr/yMjI/8vLy//b29v/5+fn/+Xl5P/Y19b/1tLN//Tu5//99u7//fbt//32 + 7P/99ez//PXr//z16v/89On//PPo//zz5//88+f//PLm//zy5f/88uX//PHk//zx4//88eL/+/Di//vw + 4P/779//++/f//vu3v/77t3/++3c//vt2//77dv/++za//vs2f/669j/+uvX//rr1v/66tX/+urU//rp + 0//66NP/+ujS//ro0f/659D/+efP//nnz//55s7/+ebM//nlzP/45cv/9+TJ/+fUvP/Ow7P/3dzZ/+Tk + 5P/j4+P/z8/P/8rKyv/AwsH/WnFlmwAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG83IABt + N+8Abzn/AG85/xB6Sv8aglT/HoNV/yCFV/8jhlr/J4dc/xp/Uf9DkF//XJxt/0uVZf8af1H/AG85/wVz + Pf96rX7/3MSK/1pWUf9VUlH/V1VU/1tZV/9eW1r/YV9e/2VhYP9oZGP/a2hm/25rav9ybm3/dXJv/3h0 + c/88clb/AG85/wBvOf8Abzn/AG85/wBvOf8BcDv/AXA7/wFwO/8CbDn/boJ4/8fHx//IyMj/1dXV/+jo + 6P/n5+f/3Nva/9TRy//y7OX//Pbu//327f/99uz//fXr//316//89er//PTq//zz6P/88+f//PPn//zy + 5v/88ub//PLl//zx5P/88eP//PDi//zw4f/78OD/++/f//vv3//77t7/++7d//vt3P/77dv/++3b//vs + 2f/77Nn/+uvY//rr1//669b/+urV//rq1P/66dP/+ujT//ro0v/66NH/+ufQ//nnz//55s7/+ebO//nm + zP/55cz/+OXK//jkyv/45Mn/9uPH/+XSuP/PxLf/4eHg/+bm5v/f39//y8vL/8jIyP+orqv9QFJLRwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG84cABvOf8Abzn/AXA7/x2CVf8ihln/JIdb/yiI + Xv8qi1//fah0/+LJj//YxJX/5MuQ/3qoeP8xjWT/AG85/xR8S/+4v4j/uaZ6/1pWVf9cWln/YFxb/2Ng + X/9mY2H/amZl/21paP9wbWv/c3Bu/3dzcv9bc2X/D29A/wBvOf8Abzn/AG85/wBvOf8BcDv/AXA7/wFw + O/8BcDv/AG45/yVoSP+4u7r/xcXF/8zMzP/o6Oj/6urq/+Pi4v/T0Mv/7ujh//z27v/99u3//fbs//31 + 6//89ev//PXq//z06v/88+j//PPn//zz5//88ub//PLm//zy5f/88eT//PHj//zw4v/78OH/+/Dg//vv + 4P/779//++7e//vu3f/77dz/++3c//vt2//77Nn/++zZ//rr2P/669f/+uvW//rq1v/66tT/+unT//ro + 0//66NL/+ujR//rn0P/558//+ebO//nmzf/55sz/+eXM//nlyv/45Mr/+OTJ//jkyP/448j/9uDF/9/L + sv/UzML/5ubm/+np6f/Y2Nj/yMjI/8XFxf98i4PbEhISDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAG05vwBvOf8Abzn/C3dD/yeHXP8pil//LItg/y+NY//mzI3/vbSo/7+8uv/TzL//3MiL/0GX + cP8egVL/AG85/1Cfd//dyYz/gXhm/2FfXv9lYWD/aGVk/2toZv9va2r/cm5t/3VycP9wdHD/NXFT/wBv + Of8Abzn/AG85/wBvOf8Abzn/AXA7/wFwO/8BcDv/AXA7/wBvOf8EaDf/hZeP/8XFxf/FxcX/3t7e/+zs + 7P/p6en/1dLP/+bh2f/79e3//fbt//327P/99ez//PXr//z06v/89Or//PPo//zz6P/88+f//PLm//zy + 5f/88uX//PHk//zx4//88eL/+/Dh//vv4P/77+D/++/f//vv3v/77t3/++3c//vt2//77dv/++za//vs + 2f/669j/+uvX//rq1v/66tb/+urU//rp1P/66NP/+ujS//ro0f/659D/+efP//nmzv/55s7/+ebM//nl + zP/55cv/+OTK//jkyf/45Mj/+OPH//jix//44sX/897C/9fFrv/b1tH/6urq/+jo6P/Nzc3/xcXF/7q6 + uv1jY2NpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzcgAG037wBvOf8Abzn/IINW/y2M + Yf8xjWT/M5Bm/+bMjf/JxL//1tPS/+Tg2//mzI3/RZp0/zaQaP8Abzn/OJJp/4qyhf/Wvof/b2pl/2pm + Zf9tamn/cG1r/3Rwb/93c3L/W3Nl/w9vQP8Abzn/AG85/wBvOf8Abzn/AXA7/wFwO/8BcDv/AXA7/wBv + Of8Abzn/B3M//0t8Zv+7vLv/wsLC/9DQ0P/u7u7/7Ozs/93c2v/c2NH/+fPr//327f/99uz//fXs//z1 + 6//89er//PTp//zz6P/88+j//PPn//zy5v/88uX//PHk//zx5P/88eP//PHi//vw4f/78OD/++/f//vv + 3//7797/++7d//vt3P/77dv/++zb//vs2f/77Nn/+uvY//rr1//66tb/+urW//rq1P/66dT/+ujT//ro + 0v/66NH/+efQ//nnz//55s7/+ebN//nmzP/55cz/+eXK//jkyv/45Mn/+OTI//jjyP/44sb/+OLF//ji + xf/34MP/7ti7/9HCr//l5OL/7Ozs/+Li4v/Gxsb/wsLC/56entklJSUbAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAbzmAAG85/wBvOf8Gcz7/L41j/zSQaP84kmn/vL6F/+LQpP/n387/59Wp/76/ + iP9KnHj/R5t1/wBvOf8pilz/UaN+/8HCiv+woH3/b2tq/3Jvbv91cnD/cHRw/yZwS/8Abzn/AG85/wBv + Of8Abzn/AXA7/wFwO/8BcDv/AXA7/wFwO/8Abzn/AG85/x2BUf85iGT/kp6Y/8LCwv/Dw8P/5OTk//Dw + 8P/o6Of/1dLM//Ls5P/99u3//fXs//317P/89ev//PXq//z06f/88+j//PPo//zz5//88ub//PLl//zy + 5f/88eT//PHj//zx4v/78OH/+/Dg//vv3//779//++/e//vu3f/77dz/++3b//vt2//77Nn/++zZ//rr + 2P/669f/+uvW//rq1f/66dT/+unU//rp0//66NP/+ujT//no0//56NL/+ejS//no0f/559D/+ebO//nl + y//45Mr/+OTJ//jkyP/448j/+OLH//jixf/44sX/+OHE//jhw//34ML/482x/9XMwf/s6+z/7u7u/9HR + 0f/CwsL/vLy8/2pqanUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbTfPAG85/wBv + Of8Yfk3/OZJq/zyVbf9KmnL/qbmD/76/h/+ht4X/VKB6/02gev83kmj/AG85/z2Wbf9Ro37/ZKiB/93J + jP+Rh3f/d3Ny/1NzYf8Ibjz/AG85/wBvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8Abzn/AG85/wl0 + Qf8yjWT/QZdy/3yTdv+3trX/wMDA/8/Pz//y8vL/7+/u/9vZ1v/l39j//PXs//327P/99ev//PXr//z1 + 6v/89On//PPo//zz5//88+f//PLm//zy5f/88uX//PHk//zx4//88eL/+/Di//vw4P/779//++/f//vu + 3v/77t3/++3c//vt2//77dv/++za//vs2f/669f/+uvX//rr1v/66tX/+urV//rp1P/66tT/+unU//rp + 1P/66dT/+enT//np0//66dP/+unT//rp0//56dP/+enS//jn0f/45s3/+OTJ//jhxv/44sX/+OHE//jh + xP/44cP/+ODC//fgwv/y3L3/1cOq/+Pg3P/v7+//5ubm/8PDw//AwMD/m5ub2jIyMhkAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvOjAAbzn/AG85/wBvOf8ujGH/QZdw/0OZc/9Gm3X/Spx4/0yf + ev9PoHz/UqN+/xV8S/8Fcz3/TJ96/1Gjfv9Ro37/krSF/8q8hf8mcEv/AG85/wBvOf8Abzn/AG85/wFw + O/8BcDv/AXA7/wFwO/8BcDv/AG85/wBvOf8jhVf/Q5lz/1efd/+ytH//m5qS/7+/v//AwMD/4+Pj//Ly + 8v/p6Oj/1tPN//bv5v/99uz//fXr//z16//89er//PTq//zz6P/88+f//PPn//zy5v/88ub//PLl//zx + 5P/88eP//PDi//zw4f/78OD/++/f//vv3//77t7/++7d//vt3P/77dz/++3b//vs2f/77Nn/+uvY//rr + 1//669b/+urV//rq1f/66dT/+unU//rp1P/66dT/+unU//np0//56dP/+unT//rp0//66dP/+enT//np + 0//56dT/+erV//rq1f/66dP/+OXN//jixf/44cP/+OHD//jhw//34ML/99/A//bfv//n0bL/1Mm6/+7u + 7v/x8fH/z8/P/7+/v/+5ubn9X19fYwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABv + OYAAbzn/AG85/wl0Qf9FmnT/SJx3/0ueef9NoHr/UKF9/1Skf/8qil7/AG85/ymKXP9Ro37/UaN+/1Gj + fv8tjF//DHM9/wBvOf8Abzn/AG85/wBvOf8BcDv/AXA7/wFwO/8BcDv/AG85/wBvOf8OeEX/OZJq/0aa + dP+Lr3//3MiM/3GVpP+pr7P/vb29/8nJyf/x8fH/8vLy/9za1//n4dn//PXr//316//89ev//PTq//z0 + 6v/88+j//PPn//zz5//88ub//PLm//zy5f/88eT//PHj//zw4v/78OH/+/Dg//vv4P/779//++7e//vu + 3f/77dz/++3c//vt2//77Nn/++zZ//rr2P/669f/+uvW//rq1v/66tX/+unU//rp1P/66dT/+unU//rp + 1P/56dP/+enT//rp0//66dP/+unT//rp0//56dP/+enU//nq1P/66tX/+urV//rq1f/66tf/+enU//jk + yv/44ML/9+DC//fgwf/337//99++//TcvP/Ww6n/5eLe//Ly8v/l5eX/wMDA/729vf+QkJDCAAAACgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtN88Abzn/AG85/ySGWf9Mn3r/T6F8/1Kj + fv9VpIH/V6aD/y2MX/8Abzn/Loxg/1Gjfv9HnHX/FHtK/wBvOf8Abzn/AG85/wBvOf8BcDv/AXA7/wFw + O/8BcDv/AXA7/wBvOf8Abzn/JYZZ/0qceP9lpHr/yMOI/7q/pP80m+r/RYG0/7i5uf+9vb3/3Nzc//X1 + 9f/t7Oz/19LM//Xv5f/99ez//PXr//z06v/89Or//PPo//zz6P/88+f//PLm//zy5f/88uX//PHk//zx + 4//88eL/+/Dh//vv4P/77+D/++/f//vv3v/77t3/++3c//vt2//77dv/++za//vs2f/669j/+uvX//rq + 1v/66tb/+urV//rp1f/66dT/+unU//rp1P/66dT/+enT//rp0//66dP/+unT//rp0//66dT/+enT//np + 1P/56tT/+urV//rq1f/66tX/+urW//rr1//669f/+uvY//nnz//338H/99+///ffv//33r7/9t29/+bP + r//XzcD/8fHx//Ly8v/IyMj/vb29/6qqqvRHR0c5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAG83QABvOf8Abzn/AG85/wBvOf8PeUb/FX1L/yyLX/8ujGD/R5t1/wx3Q/8Fcz3/KIha/wVx + PP8Abzn/AG85/wBvOf8Abzn/AXA7/wFwO/8BcDv/AXA7/wBvOf8Abzn/FHxK/0KZcv9Knnj/l7SD/+bM + jf9wq8v/AIv//wGD8P96kqX/u7u7/7+/v//r6+v/9PT0/+Lg3//h3NT/+/Pq//z16//89er//PTp//zz + 6P/88+j//PPn//zy5v/88uX//PHk//zx5P/88eP//PHi//vw4f/78OD/++/f//vv3//7797/++7d//vt + 3P/77dv/++zb//vs2f/77Nn/+uvY//rr1//669b/+urV//rq1f/66dX/+unU//rp1P/66dT/+enT//np + 0//66dP/+unT//rp0//66dP/+enT//np0//56dT/+urV//rq1f/66tX/+urV//rq1v/669f/+uvX//rr + 2f/67Nn/+uza//no0v/338D/996+//fevf/33rz/8di3/9TCqv/s6un/9PT0/9nZ2f+9vb3/u7u7/21t + bYAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG45jwBvOf8Abzn/AG85/wBv + Of8Abzn/AG85/wBvOf8Abzn/AG85/wBuOf8Abzn/AG85/wBvOf8Abzn/AXA7/wFwO/8BcDv/AXA7/wFw + O/8Abzn/BXM9/yyLX/9Nn3r/aah+/8nDiv+6v6T/JZfx/wCL//8Ai///DXjS/6arr/+7u7v/yMjI//T0 + 9P/09PT/2NXR//Dp4P/89Ov//PXq//z06f/88+j//PPn//zz5//88ub//PLl//zy5f/88eT//PHj//zx + 4v/78OH/+/Dg//vv3//779//++/e//vu3f/77dz/++3b//vt2//77Nn/++zZ//rr2P/669f/+uvW//rq + 1f/66dX/+unV//rp1P/66dT/+unU//rp1P/56dP/+unT//rp0//66dP/+unT//np0//56dP/+enU//rq + 1f/66tX/+urV//rq1f/66tb/+uvX//rr1//77Nn/+uzZ//rs2v/67dv/++3c//np0//33b3/9968//fd + u//227r/3sep/+Da0v/09PT/6+vr/76+vv+6urr/kpKSxwAAAAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAbz8QAG45jwBtOb8AbTfPAG85/wBvOf8Abzn/AG85/wBvOf8Abzn/AG85/wBv + Of8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8Abzn/AG85/xR8S/9HnHX/T6F8/02gfP+tvIb/ur+k/wCL + //8Ai///AIv//wCL//9Zh6b/ubm5/7u7u//Y2Nj/9/f3/+7t7f/Z08z/+PHn//z16v/89On//PPo//zz + 5//88+f//PLm//zy5f/88uX//PHk//zx4//88eL/+/Di//vw4P/779//++/f//vu3v/77t3/++3c//vt + 2//77dv/++za//vs2f/669j/+uvX//rr1v/66tX/+urV//rp1P/66dT/+unU//rp1P/66dT/+enT//np + 0//66dP/+unT//rp0//56dP/+enT//np1P/66tX/+urV//rq1f/66tX/+urW//rr1//669f/++zZ//rs + 2f/67Nr/+u3a//vt2//77t3/++7e//no0f/33bv/99y6//fcuv/r0rD/1si4//Pz9P/09PT/xsbG/7q6 + uv+hoaHuNjY2KgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAG83IABuOOUAbjj/AG85/wBvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8Abzn/AG85/wVz + Pf84kmn/UaN+/1Gjfv9QoX3/TaB8/1ahfP/cyYz/Q5/h/wCL//8YlPn/qrus/52ZhP+4uLj/u7u7/+fn + 5//29vb/5OPh/+La0v/79On//PTq//zz6P/88+f//PPn//zy5v/88ub//PLl//zx5P/88eP//PDi//zw + 4f/78OD/++/f//vv3//77t7/++7d//vt3P/77dz/++3b//vs2f/77Nn/+uvY//rr1//669b/+urV//rq + 1f/66dT/+unU//rp1P/66dT/+unU//np0//56dP/+unT//rp0//66dP/+enT//np0//56dT/+erU//rq + 1f/66tX/+urV//rq1v/669f/+uvX//rr2f/67Nn/+u3a//rt2v/77dv/++7c//vu3v/779//++/f//jj + yP/33Lr/99y5//HXtf/Uwaj/8O/t//b29v/U1NT/urq6/7Gxsf5cXFxbAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvPxAAbjmyAG85/wBvOf8Abzn/AG85/wBv + Of8BcDv/AXA7/wFwO/8BcDv/AG85/wBvOf8Zf0//TJ96/1qlf/+KsoX/UaN+/1Chff9NoHz/TZ96/3yt + gf/XyJX/YajS/9fIlf+asX7/g5KK/7i4uP++vr7/8PDw//f39//c2dX/7OXb//v06f/88+j//PPo//zz + 5//88ub//PLl//zy5f/88eT//PHj//zw4v/78OH/+/Dg//vv4P/779//++7e//vu3f/77dz/++3c//vt + 2//77Nn/++zZ//rr2P/669f/+uvW//rq1v/66tX/+unU//rp1P/66dT/+unU//rp1P/56dP/+enT//rp + 0//66dP/+unT//rp1P/56dP/+enU//nq1P/66tX/+urV//rq1f/669b/+uvX//rr1//669j/+uzZ//rs + 2v/67dv/++3b//vu3f/77t7/++/e//vv3//78OD/++7f//fcu//227n/9Nm2/9rDpf/o5N//9vb2/+Li + 4v+6urr/uLi4/3R0dJMAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAbzdAAG053wBvOf8Abzn/AG85/wBvOf8BcDv/AXA7/wFwO/8BcDv/AG85/wBvOf8Fcz3/OJJp/1Gj + fv9/r4P/3cmM/+bMjf9/r4P/UKF9/0+hfP9NoHz/TJ96/7W9h//Sxov/b6h9/0OObP+VnZn/uLi4/8PD + w//19fX/9fX1/9fTzf/z7OL//PPo//zz6P/88+f//PLm//zy5f/88eT//PHk//zx4//88eL/+/Dh//vv + 4P/77+D/++/f//vv3v/77t3/++3c//vt2//77dv/++za//vs2f/669j/+uvX//rq1v/66tb/+urV//rp + 1f/66dT/+unU//rp1P/66dT/+enT//rp0//66dP/+unT//rp0//66dT/+enT//np1P/56tT/+urV//rq + 1f/66tX/+urW//rr1//669f/+uvY//rs2f/67Nr/+u3b//vt2//77t3/++7e//vv3v/779//+/Dg//zw + 4v/88eP/+ebQ//bat//12rb/4smo/9/Wy//29vb/7u7u/7y8vP+4uLj/jIyMwgAAAAcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbz8QAG45jwBvOf8Abzn/AG85/wBvOf8Abzn/AXA7/wFw + O/8BcDv/AXA7/wBvOf8Abzn/I4ZX/0yfev9apX//uL+I/9fJlf9AtOT/QLTk/93JjP9apX7/T6F8/02g + fP9Nn3r/VaB6/0qeeP9InHj/Q4Zo/6Wnpv+4uLj/y8vL//j4+P/y8vL/2NPM//jv5f/88+j//PPn//zy + 5v/88uX//PLl//zx5P/88eP//PHi//vw4f/78OD/++/f//vv3//7797/++7d//vt3P/77dv/++zb//vs + 2f/77Nn/+uvY//rr1//669b/+urV//rp1f/66dX/+unU//rp1P/66dT/+enT//np0//66dP/+unT//rp + 0//66dP/+enT//np0//56dT/+urV//rq1f/66tX/+urV//rq1v/669f/+uvX//rr2f/67Nn/+uza//rt + 2//77dv/++7d//vu3v/7797/++/f//vw4P/88OL//PHj//zx5P/78eT/9t28//batv/qz6z/18q5//f2 + 9//19fX/wcHB/7i4uP+YmJjeFxcXFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG85UABt + Od8Abzn/AG85/wBvOf8Abzn/AXA7/wFwO/8BcDv/AXA7/wBvOf8Abzn/CnVC/z2Wbf9Ro37/f6+D/93J + jP+awbX/Aqv//wCp//8Aqf//msG1/6W6h/9QoX3/TaB8/02fev9Lnnn/Sp54/0qceP9Hgmf/rq6u/7e3 + t//S0tL/+Pj4/+3t7f/c1cz/+vHm//zz5//88ub//PLl//zy5f/88eT//PHj//zx4v/78OH/+/Dg//vv + 3//779//++/e//vu3v/77dz/++3b//vt2//77Nn/++zZ//rr2P/669f/+uvW//rq1f/66dX/+unU//rp + 1P/66dT/+unU//rp1P/56dP/+enT//rp0//66dP/+unT//np0//56dP/+enU//rq1f/66tX/+urV//rq + 1f/66tb/+uvX//rr1//77Nn/+uzZ//rs2v/67dv/++3b//vu3f/77t7/++/e//vv3//78OD//PDi//zx + 4//88eX//PLl//zz5//55s//9tq1/+7Sr//Uw63/9fX1//j4+P/Gxsb/uLi4/6GhofAsLCwoAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAG8/EABtN68Abzn/AG85/wBvOf8Abzn/AXA7/wFwO/8BcDv/AXA7/wFw + O/8Abzn/AG85/yOGV/9Mn3r/ZKiB/8HCiv/NyJ7/T7Xl/wCp//8Aqf//AKn//wCp//98vcT/5syN/2Om + f/9PoXz/TZ96/0yfev9Knnj/Spx4/01/av+2trb/uLi4/9nZ2f/5+fn/6ejm/+DYz//68eX//PLm//zy + 5f/88uX//PHk//zx4//88OL//PDi//vw4P/779//++/f//vu3v/77t3/++3c//vt2//77dv/++za//vs + 2f/669j/+uvX//rr1v/66tX/+urV//rp1P/66dT/+unU//rp1P/66dT/+enT//np0//66dP/+unT//rp + 0//56dP/+enT//np1P/56tT/+urV//rq1f/66tX/+urW//rr1//669f/++zZ//rs2f/67Nr/+u3a//vt + 2//77t3/++7e//vv3//779//+/Dg//vw4f/88eP//PHl//zy5f/88+b//PPo//vw4v/22rX/8dSw/9TA + pv/z8vH/+fn5/87Ozv+4uLj/p6en+URERDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvOVAAbTfvAG85/wBv + Of8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8Abzn/AG85/w95Rv89lm3/UaN+/5K0hf/dyYz/lb3G/y+u + //8Uq///Aqr//wCp//8xsuz/yMie/8HCiv9kqIH/UKF9/0+hfP9NoHz/TJ96/0ueef9KnHj/UH9q/7i4 + uP+3t7f/3t7e//n5+f/m5OH/49zR//vx5v/88ub//PLl//zx5P/88eP//PDi//vw4f/78OD/++/g//vv + 3//77t7/++7d//vt3P/77dz/++3b//vs2f/77Nn/+uvY//rr1//669b/+urV//rq1f/66dT/+unU//rp + 1P/66dT/+unU//np0//56dP/+unT//rp0//66dP/+enT//np0//56dT/+erU//rq1f/66tX/+urV//rq + 1v/669f/+uvX//rr2f/67Nn/+u3a//rt2v/77dv/++7c//vu3v/779//++/f//vw4P/78OL//PHj//zx + 5f/88uX//PPm//zz5//89On//PXr//fdvP/y1rD/1L+i//Hv7f/4+Pj/1dXV/7i4uP+wsLD9TExMTQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABvNyAAbTm/AG85/wBvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8BcDv/AG85/wBv + Of8pilz/UaN+/2Sogf/Bwor/0cee/2Sy7P8yqv//Kar//x6r//8brf//f73E/93JjP+StIX/UaN+/1Gj + fv9Ro37/UKF9/02gfP9Nn3r/S555/0qeeP9TgG3/uLi4/7i4uP/h4eH/+fn5/+Lg3f/m3dP/+/Hl//zy + 5f/88eT//PHj//zw4v/78OH/++/g//vv4P/779//++/e//vu3f/77dz/++3c//vt2//77Nn/++zZ//rr + 2P/669f/+uvW//rq1v/66tX/+unU//rp1P/66dT/+unU//rp1P/56dP/+enT//rp0//66dP/+unT//rp + 1P/56dP/+enU//nq1P/66tX/+urV//rq1f/66tf/+uvX//rr1//669j/+uzZ//rs2v/67dv/++3b//vu + 3f/77t7/++/e//vv3//78OD/+/Dh//zx4//88eT//PLl//zz5v/88+j//PTp//z06v/99ez/+eXM//PW + sP/WvqH/7+3q//j4+P/Z2dn/uLi4/7Kysv5WVlZbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzhwAG037wBvOf8Abzn/AG85/wBv + Of8BcDv/AXA7/wFwO/8BcDv/AG85/wBvOf8PeUb/Qply/1Gjfv+cuIb/3cmM/5G4zP9Hqf//O6n//zap + //8vqv//VrPu/83Inv/Bwor/ZKiB/1Gjfv9Ro37/UaN+/1Gjfv9QoX3/TaB8/02fev9Lnnn/Sp54/1WA + bf+4uLj/uLi4/+Hh4f/5+fn/4t7b/+fe1P/88uT//PHk//zx4//88eL/+/Dh//vv4P/779//++/f//vv + 3v/77t3/++3c//vt2//77dv/++za//vs2f/669j/+uvX//rq1v/66tb/+urV//rp1f/66dT/+unU//rp + 1P/56dP/+enT//rp0//66dP/+unT//rp0//66dT/+enT//np1P/56tT/+urV//rq1f/66tX/+urW//rr + 1//669f/+uvY//rs2f/67Nr/+u3b//vt2//77tz/++7e//vv3v/779//+/Dg//zw4v/88eP//PHk//zy + 5f/88+b//PPo//z06f/89Or//fXs//327f/67Nj/89Wv/9a+oP/u7Oj/+Pj4/9vb2/+4uLj/srKy/ltb + W2QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAbzcgAG05vwBvOf8Abzn/AG85/wBvOf8BcDv/AXA7/wFwO/8BcDv/AXA7/wBvOf8Fcz3/Loxg/1Gj + fv9tqoH/y8SL/8TDpf9XqfP/O6T//z2l//88qP//Rav//6/Btf/dyYz/irKF/1Gjfv9Ro37/UaN+/1Gj + fv9Ro37/UaN+/1Chff9PoXz/TZ96/0yfev9Knnj/VIBt/7i4uP+4uLj/39/f//n5+f/i3tv/6N/T//vw + 4//88eP//PHi//vw4f/78OD/++/f//vv3v/7797/++7d//vt3P/77dv/++3b//vs2f/77Nn/+uvY//rr + 1//669b/+urV//rp1f/66dX/+unU//rp1P/66dT/+enT//np0//66dP/+unT//rp0//66dP/+enT//np + 0//56dT/+urV//rq1f/66tX/+urV//rq1v/669f/+uvX//rr2f/67Nn/+uza//rt2//77dv/++7d//vu + 3v/7797/++/f//vw4P/88OL//PHj//zx5P/88uX//PPm//zz6P/89On//fXr//317P/99u3//ffu//vx + 5P/z1a7/176e/+3r6P/4+Pj/3Nzc/7i4uP+zs7P+Xl5eZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG85gABtN+8Abzn/AG85/wBvOf8Abzn/AXA7/wFw + O/8BcDv/AXA7/wBvOf8Abzn/FHxL/0ecdf9Ro37/nLiG/+bMjf+Cssz/KZv//zKf//84of//PKT//3Ky + 5P/cyZX/uL+I/1qlf/9Ro37/UaN+/1Gjfv9Ro37/UaN+/1Gjfv9apX//f6+C/0+hfP9NoHz/TJ96/0ue + ef9QgGv/t7e3/7e3t//d3d3/+fn5/+Lg2//n3dH//PDj//zx4v/78OH/+/Dg//vv3//779//++7e//vu + 3v/77dz/++3b//vt2//77Nn/++zZ//rr2P/669f/+uvW//rq1f/66tX/+unU//rp1P/66dT/+unU//rp + 1P/56dP/+enT//rp0//66dP/+unT//np0//56dP/+enU//rq1f/66tX/+urV//rq1f/66tb/+uvX//rr + 1//77Nn/+uzZ//rs2v/67dr/++3b//vu3f/77t7/++/e//vv3//78OD//PDi//zx4//88eX//PLl//zz + 5v/88+j//PTp//316//99ez//fbt//327v/99/D//PTp//PVrv/VvZ7/7+3q//j4+P/b29v/uLi4/7Ky + sv5aWlpjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG86MABt + N88Abzn/AG85/wBvOf8Abzn/AXA7/wFwO/8BcDv/AXA7/wBvOf8Abzn/BXM9/y6MYP9Ro37/d62C/9PH + jP+rvK3/MZvx/xaV//8jmf//LZz//0Cj//+wv7T/3cmM/3+vg/9Ro37/UaN+/1Gjfv9Ro37/UaN+/1Gj + fv9Ro37/UaN+/2Sogf/dyYz/a6l//1ejff9WoXz/S555/0yDa/+ysrL/t7e3/9fX1//5+fn/5eLf/+Ta + zv/78OH//PDi//vw4P/779//++/f//vu3v/77t3/++3c//vt2//77dv/++zZ//vs2f/669j/+uvX//rr + 1v/66tX/+urV//rp1P/66dT/+unU//rp1P/66dT/+enT//np0//66dP/+unT//rp0//56dP/+enT//np + 1P/56tT/+urV//rq1f/66tX/+urW//rr1//669f/++zZ//rs2f/67Nr/+u3a//vt2//77tz/++7e//vv + 3//779//+/Dg//vw4v/88eP//PHl//zy5f/88+b//PPo//z06f/99ev//fXs//327f/99u7//ffv//34 + 8f/99u7/8tWv/9S9n//w7uz/+fn5/9jY2P+4uLj/srKy/lRUVFsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvOYAAbzn/AG85/wBvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFw + O/8Abzn/AG85/xl/T/9HnHX/WqV//6W6h//XyJX/YajS/wCL//8AjP//DpH//xuW//96sNP/28mV/6W6 + h/9apX//UaN+/1Gjfv9Ro37/UaN+/1Gjfv9Ro37/UaN+/5y4hv+luof/UaN+/5y4hv/JxIr/3MmM/7/B + iP9Lnnn/SYdr/6usrP+4uLj/0dHR//j4+P/p5+X/4djK//vv4P/78OD/++/g//vv3//77t7/++7d//vt + 3P/77dz/++3b//vs2f/77Nn/+uvY//rr1//669b/+urW//rq1f/66dT/+unU//rp1P/66dT/+unU//np + 0//56dP/+unT//rp0//66dP/+enT//np0//56dT/+erU//rq1f/66tX/+urV//rq1v/669f/+uvX//rr + 2P/67Nn/+u3a//rt2v/77dv/++7d//vu3v/7797/++/f//vw4P/78OL//PHj//zx5f/88uX//PPm//zz + 5//89On//PTq//317P/99u3//ffu//338P/9+PH//vjy//337//x06//072i//Ly8f/5+fn/0dHR/7i4 + uP+vr6/8SEhISgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzhwAG85/wBv + Of8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8BcDv/AG85/wVzPf84kmn/UaN+/2Sogf/Tx4z/q7yt/xiU + +f8Ai///AIv//wCL//8flvn/sr6t/9PHjP93rYL/UaN+/1Gjfv9Ro37/UaN+/1Gjfv9Ro37/UaN+/4qy + hf9apX//ZKiB/93JjP93rYL/uL+I/9zDiP+Dd1//0ryF/4+ygv9Gi2z/oaWj/7i4uP/Kysr/+Pj4/+3s + 6v/c0sb/+e7e//vv4P/779//++/e//vu3f/77dz/++3b//vt2//77Nr/++zZ//rr1//669f/+urW//rq + 1v/66tT/+unU//rp1P/66dT/+unU//rp1P/56dP/+enT//rp0//66dP/+unT//rp1P/56dP/+enT//nq + 1P/66tX/+urV//rq1f/66tf/+uvX//rr1//669j/+uzZ//rs2v/67dv/++3b//vu3f/77t7/++/e//vv + 3//78OD/+/Dh//zx4//88eT//PLl//zz5v/88+j//PTp//z06v/99ez//fbt//337v/9+PD//fjx//74 + 8v/++fP//ffv/+7RrP/Twan/9fX1//j4+P/Kysr/uLi4/6WlpfU0NDQ1AAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvOHAAbzn/AG85/wBvOf8BcDv/AXA7/wFwO/8BcDv/AXA7/wFw + O/8Abzn/FHxL/1Gjfv9Ro37/UaN+/8HCiv9wq8v/AIv//wCL//8Ai///YajS/9fIlf+luof/WqV//1Gj + fv9Ro37/UaN+/1Gjfv9Ro37/UaN+/1Gjfv9Ro37/wcKK/6W6h/9Ro37/uL+I/+bMjf+qmXL/Uk9I/0xK + SP90bVz/3MmM/1iYdP+Smpb/uLi4/8LCwv/09PT/8vHw/9fQxf/369z/++/f//vv3v/77t3/++3c//vt + 2//77Nv/++za//vs2f/669j/+uvX//rq1v/66tb/+urU//rp1P/66dT/+unU//rp1P/56dP/+enT//rp + 0//66dP/+unT//rp0//66dP/+enT//np1P/66tX/+urV//rq1f/66tX/+urW//rr1//669f/+uvY//rs + 2f/67Nr/+u3b//vt2//77tz/++7e//vv3v/779//+/Dg//zw4v/88OP//PHk//zy5f/88+b//PPo//z0 + 6f/89Or//fXs//327f/99+///ffv//348f/++PL//vnz//769f/99u3/6cyn/9fJtf/39/f/9/f3/8LC + wv+4uLj/n5+f6B8fHyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG8/EABt + Od8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8BcDv/AXA7/wFwO/8Abzn/M5Bk/1Gjfv9Ro37/ZKiB/93J + jP8ll/H/JZfx/7q/pP/LxIv/d62C/1Gjfv9Ro37/UaN+/1Gjfv9Ro37/UaN+/1Gjfv9tqoH/y8SL/1ql + f/9kqIH/3cmM/8vEi//SuoP/b2ZW/0pHRv9NS0r/UU9N/1VSUf+omXT/sLiD/36RiP+4uLj/vLy8/+7u + 7v/19fT/18/G//Po2P/7797/++7d//vt3P/77dv/++3b//vs2f/77Nn/+uvY//rr1//669b/+urV//rq + 1P/66dT/+unU//rp1P/66dT/+enT//np0//66dP/+unT//rp0//66dP/+enT//np0//56dT/+urV//rq + 1f/66tX/+urV//rq1v/669f/+uvX//rr2f/67Nn/+uza//rt2//77dv/++7d//vu3v/7797/++/f//vw + 4P/88OL//PHj//zx5f/88uX//PPn//zz6P/89On//fXr//317P/99u3//ffu//338P/9+PH//vjy//75 + 8//++vX//vr2//v06f/ixZ//3dTH//f39//x8fH/vb29/7i4uP+RkZHREhISDgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG83QABvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFw + O/8BcDv/AXA7/wBvOf8Fcz3/TJ96/1Gjfv9Ro37/nLiG/8jEnP/mzI3/nLiG/1Gjfv9Ro37/UaN+/1Gj + fv9Ro37/UaN+/1Gjfv9tqoH/baqB/1Gjfv/Bwor/pbqH/5K0hf/dyYz/oJBt/1JPSv9MSkj/UE1M/1RR + UP9WVFL/WldW/2VhXP/VvYb/dYt3/7i4uP+7u7v/4uLi//b29v/b1tD/7OHS//vu3v/77dz/++3b//vt + 2//77Nr/++zZ//rr2P/669f/+uvW//rq1f/66tT/+unU//ro0//66dT/+unU//rp1P/56dP/+enT//rp + 0//66dP/+unT//np0//56dP/+enU//rq1f/66tX/+urV//rq1f/66tb/+uvX//rr1//77Nn/+uzZ//rs + 2v/67dr/++3b//vu3f/77t7/++/e//vv3//78OD//PDi//zx4//88eX//PLl//zz5v/88+j//PTp//31 + 6//99ez//fbt//327v/99+///fjx//748v/++fT//vn1//769v/++/f/+e7f/9m9mv/n4tv/9vb2/+jo + 6P+6urr/uLi4/4GBga0AAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAG45jwBvOf8Abzn/AG85/wFwO/8BcDv/AXA7/wFwO/8CcDz/AnA8/wBvOf8Zf0//UaN+/1Gj + fv9Ro37/rr2I/22qgf9Ro37/UaN+/1Gjfv9Ro37/UaN+/1Gjfv9Ro37/UaN+/4qyhf/Tx4z/WqV//3+v + g//mzI3/yLJ//29mVv9LSEf/TUtL/1FPTf9VUlH/WVZV/1tZV/9fXFv/YV9e/42Db/+toXn/srKy/7u7 + u//T09P/9vb2/+Ti3v/h1sf/+uzb//vt2//77dv/++zZ//vs2f/669j/+uvX//rr1v/66tX/+urU//rp + 0//66dP/+ujS//rp1P/66dT/+enT//np0//66dP/+unT//rp0//56dP/+enT//np1P/56tT/+urV//rq + 1f/66tX/+urW//rr1//669f/++zZ//rs2f/67Nr/+u3a//vt2//77tz/++7e//vv3//779//+/Dg//vw + 4v/88eP//PHl//zy5f/88+b//PPo//z06f/89Or//fXs//327f/99u7//ffv//348f/++PL//vn0//76 + 9f/++vb//vv3//78+v/14cn/07ue/+7t6//29vb/3Nzc/7q6uv+zs7P+bm5uegAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbz8QAG053wBvOf8Abzn/AXA7/wFw + O/8BcDv/AnA8/wVyPv8HdEH/BHI9/wBvOf84kmn/UaN+/1Gjfv9Ro37/UaN+/1Gjfv9Ro37/UaN+/1Gj + fv9Ro37/UaN+/8HCiv9/r4P/UaN+/8HCiv/Bwor/5syN/5aIaP9IRkX/TEpI/1BNTP9UUVD/V1VU/1pX + Vv9eWln/YF5c/2RgX/9oZGP/amZl/6ubdf+kpaH/u7u7/8XFxf/z8/P/7u3s/9jNwP/36dj/++3b//vs + 2f/77Nn/+uvY//rr1//669b/+urW//rq1P/66dP/+ujT//ro0v/66NH/+unU//np0//56dP/+unT//rp + 0//66dP/+unT//np0//56dT/+erU//rq1f/66tX/+urV//rr1v/669f/+uvX//rr2P/67Nn/+u3a//rt + 2v/77dv/++7d//vu3v/7797/++/f//vw4P/78OL//PHj//zx5P/88uX//PPn//zz5//89On//PTr//31 + 7P/99u3//ffu//338P/9+PH//vjy//758//++vX//vv2//779v/+/Pj//vz6/+vRsP/UxLD/8/Pz//f3 + 9//Nzc3/urq6/6+vr/hOTk5EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAbzlQAG85/wBvOf8Abzn/AXA7/wRyPf8Gc0D/B3RC/wp3Q/8LeEX/AXA7/wVz + Pf9Mn3r/UaN+/1Gjfv9Ro37/UaN+/1Gjfv9Ro37/WqV//4qyhf9Ro37/f6+D/9PHjP93rYL/y8SL/8iz + f/9lXlH/S0hH/09MS/9RT03/VVJR/1lWVf9cWVf/X1xb/2NfXv9lY2H/aWVk/21paP9va2r/dnFs/6Gb + jP+7u7v/vr6+/+jo6P/z8/P/1s/G//Di0f/77Nr/++zZ//rr2P/669f/+urW//rq1v/66tT/+unU//ro + 0//66NL/+ujR//rn0P/56dP/+unT//rp0//66dP/+unT//rp1P/56dP/+enT//nq1P/66tX/+urV//rq + 1f/66tf/+uvX//rr1//669j/+uzZ//rs2v/67dv/++3b//vu3f/77t7/++/e//vv3//78OD/+/Dh//zx + 4//88eT//PLl//zz5v/88+j//PTp//z06v/99ez//fbt//337//99/D//fjx//748v/++fP//vr1//76 + 9v/++/b//vz4//78+f/89+//3sKe/+DYzv/19fX/7+/v/8HBwf+7u7v/nJyc3xwcHBsAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbTevAG85/wBv + Of8BcDv/B3RB/wl1Q/8Ld0X/DnlH/w96SP8MeEf/AG85/yOGV/9Ro37/UaN+/1Gjfv9Ro37/UaN+/1Gj + fv9apX//3cmM/3+vg/9apX//08eM/9zDiP+WiGj/SEZF/0xKSv9QTUz/VFFQ/1dVVP9aV1b/Xlta/2Fe + XP9kYWD/aGRj/2poZv9uamn/cm5t/3Rwb/94dHL/g31y/7m5uf+9vb3/1dXV//T09P/i39v/4dTE//nq + 2P/669j/+uvX//rq1v/66tb/+urU//rp1P/66NP/+ujS//ro0f/659D/+efP//rp0v/66dP/+unT//rp + 0//66dP/+enT//np1P/66tX/+urV//rq1f/66tX/+urW//rr1//669f/+uvY//rs2f/67Nr/+u3b//vt + 2//77tz/++7e//vv3v/779//+/Dg//zw4v/88OP//PHk//zy5f/88+b//PPo//z06f/89Or//fXs//32 + 7f/99+7//ffw//348f/9+PL//vnz//769f/++vb//vv3//78+f/+/Pn//v37//fs3P/Su53/7Orn//T0 + 9P/i4uL/vLy8/7u7u/9+fn6qAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvPxAAbTfvAG85/wBvOf8Gc0D/DHhG/w95SP8Qekr/E3xM/xR9 + T/8HdEH/AG85/z2Wbf9Ro37/UaN+/1Gjfv9Ro37/UaN+/1Gjfv9/r4P/08eM/9PHjP++qnr/W1ZN/0tI + R/9PTEv/UlBP/1ZUUv9ZVlX/XFlX/19cW/9jX17/ZmNh/2llZP9taWj/b21r/3Nvbv93c3D/eHRz/3l1 + dP9va2r/qKaj/729vf/Gxsb/7+/v/+3s6//XzL//8+XS//rr1//669b/+urV//rp1P/66dT/+ujT//ro + 0v/66NH/+ufQ//nnz//55s7/+unS//rp0//66dP/+enT//np0//56dT/+urV//rq1f/66tX/+urV//rq + 1v/669f/+uvX//vs2f/67Nn/+uza//rt2//77dv/++7d//vu3v/7797/++/f//vw4P/88OL//PHj//zx + 5f/88uX//PPm//zz6P/89On//fXr//317P/99u3//ffu//338P/9+PH//vjy//758//++fX//vr2//77 + 9//+/Pj//vz6//78+v///v3/6M+w/9bHtv/x8PD/9PT0/9DQ0P+8vLz/srKy+mJiYlsAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABv + OVAAbzn/AG85/wFvO/8PeUj/EXxL/xR9Tf8VflD/GIFR/xmBUv8CcDv/CnVC/zOQZP8pilz/Loxg/0KZ + cv9Ro37/WqV//6W6h//cw4j/jH9k/0pHRv9NS0r/UE1M/1RRUP9XVVT/W1dW/15bWv9hXlz/ZGFg/2hk + Y/9raGb/bmpp/3Jubf90cG//eHRz/3l1dP95dXT/eXV0/6udff+imoj/vb29/7+/v//g4OD/8fHx/9rV + zv/l2MX/+erW//rq1f/66tT/+unT//ro0//66NL/+ujR//rn0P/558//+efP//nmzv/66NH/+unT//np + 0//56dP/+enU//rq1f/66tX/+urV//rq1f/66tb/+uvX//rr1//77Nn/+uzZ//rs2v/67dr/++3b//vu + 3f/77t7/++/e//vv3//78OD//PDi//zx4//88eX//PLl//zz5v/88+j//PTp//316//99ez//fbt//32 + 7v/99+///fjx//748v/++fT//vn1//769v/++/b//vz4//78+v/+/fr///37//vz6f/Wu5j/5N/Z//Ly + 8v/r6+v/w8PD/76+vv+goKDfIyMjHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtN68Abzn/AG85/wZzQP8UfU//Fn9R/xmB + Uv8bglX/H4NW/xh+T/8Abzn/AG85/wBvOf8Abzn/AG85/xR8S/9Qn3f/3cmM/42BZP9LSEf/T0xL/1JQ + T/9WVFL/WVZV/1xaWf9gXFv/Y2Bf/2ZjYf9pZmX/bWlo/3Bta/9zb27/d3Ny/3l1dP95dXT/eXV0/42G + ef/SvIj/08aL/7KmfP+wsrH/v7+//8vLy//w8PD/6Ofk/9bLvP/05NH/+urU//rp0//66NP/+ujS//ro + 0f/659D/+efP//nmzv/55s7/+ebM//nn0P/56dP/+enT//np1P/56tT/+urV//rq1f/66tX/+urW//rr + 1//669f/+uvZ//rs2f/67dr/+u3a//vt2//77t3/++7e//vv3//779//+/Dg//vw4v/88eP//PHl//zy + 5f/88+b//PPo//z06f/89Or//fXs//327f/99u7//ffv//348f/++PL//vn0//769f/++vb//vv3//78 + +P/+/Pr//v36///+/P///v7/7NnA/9LCrf/u7u3/8vLy/9fX1/+/v7//v7+//3R0dJUAAAAEAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAG83IABtN+8Abzn/AG85/xB6Sv8aglT/HoNV/yCFV/8jhlr/J4dc/xp/Uf9DkF//XJxt/0uV + Zf8af1H/AG85/wVzPf96rX7/3MSK/1pWUf9VUlH/V1VU/1tZV/9eW1r/YV9e/2VhYP9oZGP/a2hm/25r + av9ybm3/dXJv/3h0c/95dXT/eXV0/3l1dP+woYH/5syN/7e+h/9Lnnn/qrF//5mdkv/AwMD/w8PD/+Li + 4v/v7+//2NTM/+PVwv/56NP/+ujT//ro0v/66NH/+ufQ//nnz//55s7/+ebN//nmzP/55cz/+ebN//np + 0//56dT/+erU//rq1f/66tX/+urV//rr1v/669f/+uvX//rr2P/67Nn/+uza//rt2//77dv/++7d//vu + 3v/7797/++/f//vw4P/78OH//PHj//zx5P/88uX//PPn//zz5//89On//PTr//317P/99u3//ffu//33 + 8P/9+PH//vjy//758//++vX//vv2//779v/+/Pj//vz5//79+v///fv///79//z06//Uu5j/4dzW/+/v + 7//s7Oz/x8fH/8DAwP+rq6vwRkZGMwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG84cABvOf8Abzn/AXA7/x2C + Vf8ihln/JIdb/yiIXv8qi1//fah0/+LJj//YxJX/5MuQ/3qoeP8xjWT/AG85/xR8S/+4v4j/uaZ6/1pW + Vf9cWln/YFxb/2NgX/9mY2H/amZl/21paP9wbWv/c3Bu/3dzcv95dXT/eXV0/3l1dP+Vi3r/0ryI/8HC + iv+bt4X/3MmM/1ahfP89kmb/Wn9c/7a4t//CwsL/zMzM/+zs7P/n5+b/1Mm7//HgzP/66NL/+ujR//rn + 0P/558//+ebO//nmzv/55sz/+eXM//nly//45Mr/+enT//nq1P/66tX/+urV//rq1f/66tf/+uvX//rr + 1//669j/+uzZ//rs2v/67dv/++3b//vu3P/77t7/++/e//vv3//78OD/+/Dh//zx4//88eT//PLl//zz + 5v/88+j//PTp//z06v/99ez//fbt//337//99/D//fjx//748v/++fT//vr1//769v/++/b//vz4//78 + +f/+/fr///37///+/f///v3/5tG1/9PEsv/s6+v/7+/v/9jY2P/CwsL/wsLC/4SEhKgAAAAHAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAG05vwBvOf8Abzn/C3dD/yeHXP8pil//LItg/y+NY//mzI3/vbSo/7+8 + uv/TzL//3MiL/0GXcP8egVL/AG85/1Cfd//dyYz/gXhm/2FfXv9lYWD/aGVk/2toZv9va2r/cm5t/3Vy + cP94dHP/eXV0/3l1dP9/enX/t6aC/93JjP/dyYz/f6+C/0+hfP+3voj/aZtj/wBvOf8RdEX/iJiR/8PD + w//FxcX/3Nzc/+zs7P/d2dT/2826//flzv/559D/+efP//nmzv/55s7/+ebM//nlzP/55cr/+OTK//jk + yf/459D/+urV//rq1f/66tX/+urW//rr1//669f/+uvY//rs2f/67Nr/+u3b//vt2//77t3/++7e//vv + 3v/779//+/Dg//zw4v/88OP//PHk//zy5f/88+b//PPo//z06f/89Or//fXs//327f/99+7//ffw//34 + 8f/9+PL//vnz//769f/++vb//vv3//78+f/+/Pr//v36///9+////v3///7+//To2P/PuZz/5OLe/+3t + 7f/o6Oj/yMjI/8LCwv+vr6/xR0dHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzcgAG037wBv + Of8Abzn/IINW/y2MYf8xjWT/M5Bm/+bMjf/JxL//1tPS/+Tg2//mzI3/RZp0/zaQaP8Abzn/OJJp/4qy + hf/Wvof/b2pl/2pmZf9tamn/cG1r/3Rwb/93c3L/eXV0/3l1dP95dXT/lYt6/9jBi//dyYz/ZKiB/3+v + g//dyYz/QJVp/wVyPf8Abzn/PpZu/4jDqv+Dp5j/tri3/8XFxf/Kysr/5eXl/+jo6P/TzMH/5tXA//jm + zv/55s7/+ebO//nmzP/55cz/+OXK//jkyv/45Mn/+OTI//jly//66tX/+urV//rq1v/669f/+uvX//vs + 2f/67Nn/+uza//rt2//77dv/++7d//vu3v/7797/++/f//vw4P/88OL//PHj//zx5f/88uX//PPm//zz + 6P/89On//fXr//317P/99u3//ffu//338P/9+PH//vjy//758//++fX//vr2//779//+/Pj//vz6//78 + +v///fv///79///+/f/79/D/2L+h/9nRyP/q6uv/6+vr/9LS0v/FxcX/xcXF/319fZsAAAADAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzmAAG85/wBvOf8Gcz7/L41j/zSQaP84kmn/vL6F/+LQ + pP/n387/59Wp/76/iP9KnHj/R5t1/wBvOf8pilz/UaN+/8HCiv+woH3/b2tq/3Jvbv91cnD/eHRz/3l1 + dP95dXT/f3p1/72rhf/dyYz/krSF/9PHjP9/r4P/R5x1/2qbY/8PdT7/EXpI/22ylP+UybP/l8u1/47C + rP9jhnX/w8PD/8jIyP/T09P/6Ojo/+Li4P/Rxrf/7NvE//jlzv/55sz/+eXM//jlyv/45Mr/+OTJ//jk + yP/448j/+OLG//nn0f/66tb/+uvX//rr1//77Nn/+uzZ//rs2v/67dr/++3b//vu3f/77t7/++/f//vv + 3//78OD/+/Dh//zx4//88eX//PLl//zz5v/88+j//PTp//316//99ez//fbt//327v/99+///fjx//74 + 8v/++fT//vn1//769v/++/f//vz4//78+v/+/fr///37///+/P///v3//vz5/+PMsP/RxLP/5uXm/+rq + 6v/g4OD/yMjI/8XFxf+oqKjiMTExLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAbTfPAG85/wBvOf8Yfk3/OZJq/zyVbf9KmnL/qbmD/76/h/+ht4X/VKB6/02gev83kmj/AG85/z2W + bf9Ro37/ZKiB/93JjP+Rh3f/d3Ny/3l1dP95dXT/eXV0/5uRfP/gx4z/08eM/8HCiv9Ro37/f6+D/8G+ + gv8Fcz3/AG85/z6Wbv+Iw6r/lsm0/5nMt/9qsJH/CnVB/whnOf+MnZX/ycnJ/8rKyv/Z2dn/5ubm/9vZ + 1f/TxbT/8N3F//nlzP/45cv/+OTK//jkyf/45Mn/+OPI//jixv/44sX/+OPJ//rr1//669f/+uvZ//rs + 2f/67dr/+u3a//vt2//77tz/++7e//vv3//779//+/Dg//vw4v/88eP//PHl//zy5f/88+b//PPo//z0 + 6f/89Or//fXs//327f/99u7//ffw//348f/++PL//vn0//769f/++vb//vv3//78+P/+/Pr//v36///+ + /P///v3///79//79+//q18D/zbuj/+Hf3v/n5+j/4+Pj/83Nzf/IyMj/wMDA+mlpaW8AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvOjAAbzn/AG85/wBvOf8ujGH/QZdw/0OZ + c/9Gm3X/Spx4/0yfev9PoHz/UqN+/xV8S/8Fcz3/TJ96/1Gjfv9Ro37/krSF/9jBiv95dXT/eXV0/396 + df/EsIb/5syN/5K0hf9apX//08eM/3+rfP8UfEv/AG85/xt/UP91t5v/lMmz/5fLtf+Hwaj/MY1h/wBv + Of8Abzn/AG85/yBoRPSytLP4y8vL/87Ozv/f39//5OTk/9bRzP/WxrP/8t7F//jkyv/45Mn/+OTI//jj + yP/44sf/+OLF//jhxP/44cT/+efQ//rr2f/67Nn/+uza//rt2//77dv/++7d//vu3v/7797/++/f//vw + 4P/78OH//PHj//zx5P/88uX//PPm//zz5//89On//PTr//317P/99u3//ffu//338P/9+PH//vjy//75 + 8//++vX//vv2//779v/+/Pj//vz5//79+v///fv///79///+/f/+/fz/7d3J/823m//b2dT/5OTl/+Xl + 5f/T09P/ysrK/8bGxv6Pj4+yERERDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABvOYAAbzn/AG85/wl0Qf9FmnT/SJx3/0ueef9NoHr/UKF9/1Skf/8qil7/AG85/ymK + XP9Ro37/UaN+/1Gjfv9Ro37/wcKK/7Chgf+jln7/4MeM/669iP+uvYj/wcKK/1Gjfv9KlGP/OYdP/wBv + Of9Im3X/ksiy/5bJtP+ZzLf/V6SB/wp1Qf8Abzn/AG85/wBvOf8AbTm/AGMxJHt7e4jFxcX8zc3N/9LS + 0v/f39//4eHh/9POx//WxrL/8N3D//jkyP/448f/+OLH//jixf/44sX/+OHE//jhw//44cP/+urW//rs + 2v/67dv/++3b//vu3P/77t7/++/e//vv3//78OD//PDi//zx4//88eT//PLl//zz5v/88+j//PPp//z0 + 6v/99ez//fbt//337//99+///fjx//748v/++fP//vr1//769v/++/b//vz4//78+f/+/fr///37///+ + /f///v3//v79/+7eyv/NtZj/19LN/+Hh4v/j4+P/2NjY/8zMzP/MzMz/pqam2kVFRSwAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtN88Abzn/AG85/ySG + Wf9Mn3r/T6F8/1Kjfv9VpIH/V6aD/y2MX/8Abzn/Loxg/1Gjfv9Ro37/UaN+/1Gjfv9kqIH/5syN/9PH + jP/dyYz/ZKiB/1qlf//Tx4z/MYNN/wBvOf8khlf/dbeb/5TJs/+Xy7X/h8Go/yeHWv8Abzn/AG85/wBv + Of8AbTfvAG84cAAAAAAAAAAAIiIiD5CQkK3Nzc3+0NDQ/9TU1P/e3t7/397f/9HMxf/UxbD/79vA//ji + xv/44sX/+OLF//jhxP/44cP/+ODC//fgwv/34cT/+ezZ//vt2//77t3/++7e//vv3v/779//+/Dg//zw + 4v/88eP//PHk//zy5f/88+b//PPo//z06f/89Or//fXs//327f/99+7//ffw//348f/9+PL//vnz//76 + 9f/++vb//vv3//78+P/+/Pr//v36///9+////v3///79///+/P/r2ML/zLSX/9TQyv/e3t//4eHh/9nZ + 2f/Q0ND/0NDQ/7e3t+xgYGBSAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAG83QABvOf8Abzn/AG85/wBvOf8PeUb/FX1L/yyLX/8ujGD/R5t1/wx3 + Q/8Fcz3/R5x1/1Gjfv9Ro37/UaN+/1Gjfv93rYL/WqV//6W6h//Bwor/KYpc/wBvOf8JdEH/UaB8/5LI + sv+WybT/mcy3/1ekgf8KdUH/AG85/wBvOf8Abzn/AG03rwBvNyAAAAAAAAAAAAAAAAAAAAAAMTExGp+f + n8LQ0ND+0tLS/9fX1//d3d3/3Nvc/8/Lxf/Qwa7/6tW6//fhxP/44cT/+OHD//jgwv/34ML/99/A//ff + v//34cT/+u3c//vu3v/7797/++/f//vw4P/88OL//PHj//zx5f/88uX//PPm//zz6P/89On//fXr//31 + 7P/99u3//fbu//338P/9+PH//vjy//758//++fX//vr2//779v/+/Pj//vz6//78+v///fv///79///+ + /f/89u7/5M+0/8q2nf/Sz8v/3Nzd/97e3v/a2tr/0tLS/9LS0v/FxcX1ampqcQAAAAQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG45jwBv + Of8Abzn/AG85/wBvOf8Abzn/AG85/wBvOf8Abzn/AG85/wBvOf8Zf0//UaN+/1Gjfv9Ro37/UaN+/1Gj + fv9Ro37/Rplu/2WXXv8Abzn/JIZX/369o/+UybP/l8u1/326oP8dgVH/AG85/wBvOf8Abzn/AG037wBv + OVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODg4JKWlpcrS0tL+1dXV/9nZ2f/b29v/2NjY/8/M + yP/Mv67/4s2y//TdwP/44cP/9+DC//ffwf/337//99+///fevv/34ML/+u3b//vv3//78OD/+/Dh//zx + 4//88eX//PLl//zz5v/88+j//PTp//316//99ez//fbt//327v/99+///fjx//748v/++fT//vn1//76 + 9v/++/f//vz4//78+v/+/fr///37///+/f///v3/9u7i/9nCpP/Iuqf/0dDO/9jY2P/b29v/2tra/9bW + 1v/S0tL/zMzM+XNzc4AAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbz8QAG45jwBtOb8AbTfPAG85/wBvOf8Abzn/AG85/wBv + Of8Abzn/MY1h/wBvOf84kmn/UaN+/1Gjfv9Ro37/TJ96/yOGV/8Abzn/CXRB/1GgfP+SyLL/lsu0/5rM + t/9Nnnn/AG85/wBvOf8Abzn/AG85/wBtN68Abz8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAQUFBJ6enp8nW1tb+2NjY/9vb2//a2tr/1dXV/8/Pzf/IvrL/1sOr/+zVuP/138D/99/A//ff + vv/3377/9969//fevP/33r7/+ejS//zw4v/88eT//PHl//zy5f/88+b//PPo//z06f/89Or//fXs//32 + 7f/99u7//ffw//348f/++PL//vnz//769f/++vb//vv3//78+P/+/Pr//v36///+/f/+/vz/+/Xt/+nW + u//MtZX/x76y/9HR0P/V1dX/2NjY/9vb2//Y2Nj/1tbW/8/Pz/d4eHiFAAAACAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAG83IABtOd8Abzn/AG85/ziRaP9rsJT/D3hG/wVzPf9Mn3r/UaN+/z2W + bf8KdUL/AG85/y2LX/+Hwqn/lMmz/5fLt/9ztZn/HYFR/wBvOf8Abzn/AG85/wBtOd8AbzdAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQUFBI6SkpLzY2Nj+3Nzc/93d + 3f/b29v/09PT/83Nzf/Gwrz/ybup/97Jrf/w2Ln/9t69//fevv/33r3/9927//fcuv/33Lr/+OLH//rs + 2//88+b//PPn//zz6P/89On//PTr//317P/99u3//ffu//338P/9+PH//vjy//758//++vX//vr2//77 + 9v/+/Pj//vz6//7+/P///fz//fjx//DfyP/Wvp7/xbSf/8fEwP/Ozs//0tLS/9fX1//c3Nz/29vb/9ra + 2v/R0dHxeXl5fgAAAAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzlQAG85/wBv + Of8HdED/bbKV/3i4nv9cqIb/AG85/xl/T/8eglT/AG85/wl0Qf9jq4v/ksiy/5bLtP+Qxq//Q5lw/wBv + Of8Abzn/AG85/wBvOf8AbjmPAG8/EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAKioqGJiYmKXS0tL739/f/9/f3//e3t7/1NTU/8vLy//GxcT/wrux/8u7 + pf/fyaz/7ta1//Xcuv/23Lr/99y6//fcuf/22rf/9tu5//jjyP/67dz/+/Po//z17P/99u7//fbt//33 + 7//99+///fjw//748v/++fT//vr1//769v/++/j//vz6//79/P/9+fP/+vDk/+/bwv/Yvpz/xbCX/8C5 + sP/Hxsf/ysvL/8/Pz//Y2Nj/3t7e/97e3v/d3d3/wsLC7HJycm0AAAAIAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtOd8Abzn/AG85/0qcd/95uZ//fbyh/3++pP85kmn/AG85/wBv + Of82kGX/h8Kp/5TJs/+Xy7f/c7WZ/xR6Sv8Abzn/AG85/wBvOf8AbTnfAG83QAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJycnDYOD + g3zKysrs4uLi/+Li4v/j4+P/2dnZ/8zNzf/Dw8T/wL67/762rf/Ht6L/2MKl/+nPr//y17X/9Nm3//bb + t//227f/9tm2//Xatf/33r7/+eTK//rr2P/78uX//Pbu//327v/++PH//vr2//348v/++vb//ffu//v0 + 6v/56tn/8Nq+/+LJqP/RuJb/wa+Y/7y1q//Av77/xcXG/8jIyf/S0tL/3t7e/+Li4v/g4OD/4eHh/7Ky + stFiYmJOAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzhwAG85/wBv + Of8WfUz/erqg/369o/+CvqX/hcGo/3+9o/80kGX/a7CS/5LIsv+Wy7T/kMav/0OZcP8Abzn/AG85/wBv + Of8Abzn/AG85gABvPxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABF1dXUq1tbXJ3t7e/ubm5v/m5ub/5OTk/9bW + 1v/FxcX/vr6//7q5t/+5tK3/vrKj/8m2oP/Wv6L/4smo/+vQrf/w1LD/89ay//TXsv/12LH/9dex//XX + sf/22bT/9tu5//bcu//02rn/89m4/+7Srv/pzaj/3cCb/9C0kv/Dr5b/ua6f/7e0rv+7u7r/vr/A/8HB + wf/Ly8v/29vb/+Xl5f/l5eX/5+fn/9jY2PSdnZ2nPj4+JQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvOYAAbzn/AG85/x+CVP9/vqT/g7+m/4fBqf+Kw6v/jcau/5DH + sP+UybP/l8u3/2qvkP8KdUH/AG85/wBvOf8Abzn/AG03zwBvOjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAADc3NyCNjY2J0tLS7Ofn5/3q6ur/6+vr/+fn5//Y2Nj/xcbG/7q6u/+0tbX/srGv/7Gt + qP+0q6D/u66b/8Oxmv/Ltpv/07ud/9a+nf/av5//28Ge/9q/nf/Yvpz/1buZ/9C3mP/HsZT/wK6W/7ep + mP+yqqD/sK2p/7KxsP+1trf/uLm5/76+vv/Kysr/3d3d/+np6f/q6ur/6Ojo/+Li4v7AwMDYcXFxZxIS + Eg4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG8/EABt + N+8Abzn/AG85/1umhf+Iwqr/i8St/4/Hr/+SyLL/lsu0/5DGr/8xjGH/AG85/wBvOf8Abzn/AG85/wBv + OYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARdXV08paWlrtzc + 3PLv7+//7+/v//Dw8P/s7Oz/4uLi/8/Pz/+9vb3/srKy/6ysrP+qqqr/qKem/6alov+mo5//p6Kc/6ah + m/+mn5f/pqCY/6ahmv+mopz/pqOf/6elpP+np6f/q6ur/6ysrP+vsLD/tra2/8LCwv/T09P/5OTk/+3t + 7f/t7e3/7e3t/+vr6//R0dHnkpKSjUFBQScAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG83YABvOf8Abzn/CXRB/4XBqP+Rx7D/lMmz/5fL + t/9qr5D/CnVB/wBvOf8Abzn/AG85/wBtOb8AbzcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVFRUMY2NjSq2tra/b29vv8PDw/fLy8v/09PT/9PT0//Dw + 8P/m5ub/2NjY/8TExP+2t7f/r6+v/6ipqf+ioqL/oKGh/5+foP+dnZ7/oKGi/6Ghof+np6f/qqqq/7Oz + s/+8vLz/y8vL/9nZ2f/n5+f/8fHx//Pz8//x8fH/8/Pz/+/v7/zR0dHgmJiYk1FRUTgAAAAFAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAG05vwBvOf8Abzn/Lotf/5bLtP+Gwaj/J4dZ/wBvOf8Abzn/AG85/wBtN+8AbzhwAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAFxcXC2JiYj6enp6Ozs7O1urq6vf39/f/+Pj4//j4+P/5+fn/+fn5//f39//x8fH/6+vr/+bm + 5v/f39//29vb/9zc3P/Z2dn/4uLi/+Tk5P/u7u7/8fHx//j4+P/4+Pj/+Pj4//n5+f/29vb/9fX1/+bm + 5vLIyMjJj4+PfkZGRi8AAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzcgAG037wBvOf8Abzn/OZJp/wp1 + Qf8Abzn/AG85/wBvOf8AbTm/AG83IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAU9PT0Zc3NzUqSk + pJXQ0NDR6Ojo7vb29v76+vr//f39//39/f/+/v7//v7+//7+/v///////v7+//7+/v/+/v7//v7+//z8 + /P/9/f3/+/v7//z8/P/z8/P35OTk7snJyc2fn5+LampqSjIyMhkAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAbzhwAG85/wBvOf8Abzn/AG85/wBvOf8AbTfvAG83YAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCoqKhhfX187jY2NZaurq5bIyMjA19fX1ePj + 4+Hr6+vs8vLy9fPz8/H09PT58/Pz9PLy8vPp6ent4eHh4dTU1MzExMS6o6Oji4KCgmZYWFgxEhISDgAA + AAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbTm/AG85/wBv + Of8Abzn/AG03rwBvPxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgqKioYTExMKF9fXzBiYmI5dHR0SHBwcER2dnZHZWVlP19f + XzM/Pz8gKioqGAAAAAUAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvOjAAbTfvAG053wBvOVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + /////////////z////////////////////wf///////////////////4H///////////////////4A// + /////////////////8AH//////w///////////8AB//////4H//////////8AAP/////8A////////// + +AAB/////+AH/////////+AAAf/////AA//////////AAAD/////gAH/////////AAAAf////wAA//// + /////gAAAH////4AAH////////gAAAA////8AAA////////wAAAAH///+AAAH///////wAAAAB////AA + AA///////4AAAAAP///wAAAH//////4AAAAAB///4AAAA//////8AAAAAAf///AAAAH/////8AAAAAAD + ///4AAAA/////8AAAAAAAf///AAAAH////+AAAAAAAH///4AAAA////+AAAAAAAB////AAAAH////AAA + AAAAAf///4AAAA////AAAAAAAAH////AAAAH///gAAAAAAAB////4AAAA///gAAAAAAAA/////AAAAH/ + /wAAAAAAAAMf///4AAAA//wAAAAAAAAAD////AAAAH/4AAAAAAAAAA////4AAAA/4AAAAAAAAAAH//// + AAAAH4AAAAAAAAAAA////4AAAA8AAAAAAAAAAAP////AAAAEAAAAAAAAAAAB////4AAAAAAAAAAAAAAA + Af////AAAAAAAAAAAAAAAAH////4AAAAAAAAAAAAAAAB/////AAAAAAAAAAAAAAAB/////4AAAAAAAAA + AAAAAA//////AAAAAAAAAAAAAAA//////4AAAAAAAAAAAAAA///////AAAAAAAAAAAAAAf//////4AAA + AAAAAAAAAAf///////AAAAAAAAAAAAAP///////4AAAAAAAAAAAAP///////8AAAAAAAAAAAAH////// + /8AAAAAAAAAAAAD///////+AAAAAAAAAAAAAf//////+AAAAAAAAAAAAAH///////AAAAAAAAAAAAAA/ + //////AAAAAAAAAAAAAAH//////gAAAAAAAAAAAAAB//////gAAAAAAAAAAAAAAP/////wAAAAAAAAAA + AAAAB/////wAAAAAAAAAAAAAAAf////wAAAAAAAAAAAAAAAD////4AAAAAAAAAAAAAAAAf///4AAAAAA + AAAAAAAAAAH///+AAAAAAAAAAAAAAAAB////gAAAAAAAAAAAAAAAAf///4AAAAAAAAAAAAAAAAH////A + AAAAAAAAAAAAAAAA////wAAAAAAAAAAAAAAAAH///+AAAAAAAAAAAAAAAAAf///wAAAAAAAAAAAAAAAA + D///8AAAAAAAAAAAAAAAAA////gAAAAAAAAAAAAAAAAH///8AAAAAAAAAAAAAAAAA////AAAAAAAAAAA + AAAAAAH///4AAAAAAAAAAAAAAAAB////AAAAAAAAAAAAAAAAAP///wAAAAAAAAAAAAAAAAD///+AAAAA + AAAAAAAAAAAAf///gAAAAAAAAAAAAAAAAH///8AAAAAAAAAAAAAAAAA////gAAAAAAAAAAAAAAAAP/// + 4AAAAAAAAAAAAAAAAB////AAAAAAAAAAAAAAAAAf///4AAAAAAAAAAAAAAAAD///+AAAAAAAAAAAAAAA + AA////wAAAAAAAAAAAAAAAAP////4AAAAAAAAAAAAAAAD////8AAAAAAAAAAAAAAAAf///+AAAAAAAAA + AAAAAAAH///+AAAAAAAAAAAAAAAAB////AAAAAAAAAAAAAAAAAf///AAAAAAAAAAAAAAAAAH///gAAAA + AAAAAAAAAAAAB///gAAAAAAAAAAAAAAAAAf//wAAAAAAAAAAAAAAAAAH//wAAAAAAAAAAAAAAAAAB//w + AAAAAAAAAAAAAAAAAAf/4AAAAAAAAAAAAAAAAAAH/4AAAAAAAAAAAAAAAAAAB/+AAAAAAAAAAAAAAAAA + AAf/gAAAAAAAAAAAAAAAAAAH/4AAAAAAAAAAAAAAAAAAB//AAAAAAAAAAAAAAAAAAAf/wAAAAAAAAAAA + AAAAAAAP/+AAAAAAAAAAAAAAAAAAD//wAAAAAAAAAAAAAAAAAA//8AAAAAAAAAAAAAAAAAAP//gAAAAA + AAAAAAAAAAAAH//8AAAAAAAAAAAAAAAAAB///AAAAAAAAAAAAAAAAAAf//4AAAAAAAAAAAAAAAAAP/// + AAAAAAAAAAAAAAAAAD///wAAAAAAAAAAAAAAAAB///+AAAAAAAAAAAAAAAAAf///gAAAAAAAAAAAAAAA + AP///8AAAAAAAAAAAAAAAAH////gAAAAAAAAAAAAAAAB////4AAAAABAAAAAAAAAA/////AAAAAB4AAA + AAAAAAf////4AAAAA/AAAAAAAAAP////+AAAAA/4AAAAAAAAD/////wAAAAf/AAAAAAAAB//////4AAA + f/4AAAAAAAB//////+AAAP//AAAAAAAA///////AAAP//8AAAAAAAf//////wAAH///gAAAAAAP///// + /4AAH///8AAAAAAP///////AAD////wAAAAAH///////4AD/////AAAAAH///////+AD/////8AAAAP/ + ///////wB//////4AAAP////////+B///////4AA//////////g////////////////////8//////// + ////////iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAAAAXNSR0IArs4c6QAAAARnQU1B + AACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAP+lSURBVHhe7J0HWBRZ9vbbyWEnz07YyTntREfF + nHMOY84JAzlLziIq5iyIiKAoICYwgYLknESCYs45h3He75zbdZvqplFnv53dcf9Tz3Oeaprupqm67+++ + 59xbtzT/V7bGkzQfNLHSjDWx0GxrbKY528hCc7yxhSaewsnEXNOy8QTNG/XHa55UXv7X9tf21/a/srGw + Sfw/N7HQ+DQy0+wn0YODIFBG+xWNLDUTm1hqGjeZrPkHvbye9l1/bX9tf23/E9vPNpr3qJc3p94/kXr/ + 27Rn8aOBmeZuQ3PNMRNLTXojc82ixuaaYewUlLf9tf21/bU94lu9JvaaF0ysNO0aWmjCTcw0J6inBwOA + xI8G5loQ8M/0u2pyA2vJJUwwsdY0pHjnr5Tgr+2v7RHeWk7S/I1E3YAsviv18oUk9F+F9Sfh/0wAqD+Z + 9hTkAvi53xpM1pyi32eSW1hK7xlJz3/9yy+ax5WP+2v7821/pWt/bXVvwvpzj26h2UoAOMfC556/IQWD + wMSiHn6cqMH3EzT4iUDAv2M3INICK816cge2BIJWFB92Mtc8rXzsX9t/bntG2Wvefvvt15WHT33yySfv + 0f55imc++uijN19//fW3+Rdvvvnm8++//z4/ltB+jOKv8/Z/cfvaQ/MUCbk1iX4l2f/Tjcw097jH/4EE + 38jyMXRzfRW9PN9GY6un8M14Db41JQhMUgDBoKD3NLTU5BEQwhqbayabTNZ8+1dK8G/fWKBiUwT+Iu9/ + +umnRiTyb3r06NGib9++QwcNGtTLxsZm5MSJE20mTJhgMX36dHsfHx9fZ2dnLzc3N5tZs2b5WVlZeUye + PNncw8PDzNTUdNLQoUPHdOvWrWWLFi0at2rVqimB4vMXX3zxVfobj7/22msv0P4vMPyvbixUtu/UczuS + gAuUXh0/ksC/I6G3d3oFdss6YNq6ETBb2BxtHV/ED+QC/kkg4N+zK5BuoAmBgCKeHjswULhIaGKteVb5 + U39tv2+Tgn+Ke+0PPvjgZRJny+bNm3e1tLQcSWKeQeKeGhMTs462XYmJidtycnJKysrKDldUVBQdPHjw + 6NmzZ2+cPHnyyPHjx09cvXoV9PjMqVOnjpw7d+7qmTNnrlVXV1eWlpbuo9cfy8jIKIyNjY3fuHHj2pCQ + kFW+vr7zCSSTCSr9CS7t6tev3/Djjz/+TPlOcvsrrXjUN7b+1PNPpEggq3+ZxS96fxJ5I/PHMW5WA4Qn + +SC1LApbshfCa1U/dHN7U7iDr8dpIVCfYMEpA0OAUoEL5CLyaB9GMYmifssRNfb0r+2BGx+rv7E9J7F3 + 7NmzZ3d3d3cfEvvCLVu2bEhNTS0vKSkpO3bs2KWbN2/iypUrl2/dugXebty4cVc8MLLdu3dPeQT89ttv + yiPtRp/zq/IQ165du0NwuECQuHnkyJFrmZmZlbt27dq+atWqyLlz5y4ZP368TZcuXfp/8803n1Aa8car + r776ovKd/9oetY17Z87bTcw1q0j8JznXZ/F/S7379yTs3l7vYfaGidhTGoGSo4koOrQN23OXYXasKUZM + /xbNrJ8RAODXMzA4LWCAMAhMzDSnaL+VPtONINCeawOcaih/+q+tZhM9Pdn55z777LPv27dv34Ksu31Q + UNA86o0TqWeuoh760MWLF3H79u17JFBFqsCvv+p0e1+Bqzf179Tv4e3u3Rp+8Ovo7yk/ARcuXLhx9OjR + M8XFxSfoO1UQEDZSWjGNvuswExOTpl999dVnf/vb32Tt4a/tz75xr0zi/CeJ01bk75T3s3C5Z/9qrAYt + bJ6Da2gPbKZeP708WjiAvfvWIq1sHfYUhSEqOQC+EYMwwO9D/ETv+XwUOQJ6n15twExznv5GEUW4qA1Y + a75t6aF5QvkK/+e3v//972/R9nfqUXtaWFhYLlq0KIx6+cz8/PwqFvr58+dv3LlzRwiQe3vepDBZvDIe + FgTqnw0f82fwnt/PIOCf+TH/fTUI+OdLly79SgFKLe5R2nEsPDx886xZs2aPGDFiTJs2bVp/QRv9e3+l + fn/mreUkzVtNLTQjSPTRJNRTimAVS/8YRs/8AeGJHkguWY09xasRn7OEUoBFSCwMRdq+KGSVx4jfhWxz + hunshmhu/bwoDvL7xUgBg0BxA03o8xtbauIJNk6070j7z3jOgfJV/i9tAn6ff/75R99++62JOW0BAQHB + JPqkffv2Xace9jwLncVHdl4nQH6O91KMsqfmvRSy+vnr16+L4PdTisCCFZ/BzxFUxGfz32DI8HMSIGqx + 8+fKvymfl9+DX89pB7+Xn+PPo+9+Nzk5uXjt2rWb6H+a0atXr0GNaHvhhRdeE//5X9ufa2tmqWnEY/g8 + 4efnyZq7bP25J+d9X6/3MStmHDZnzsPOvGAS/2JsSJuN2PRZog6wqyAUe0vXaN1AaSTi6HX+kUPQ0+Nd + Ifx/KrUBmRJwfYBcxgX6eyUmlpoNja00TgSBZvXHa55Tvs7/he3F77///h3qIQeSQHxCQ0OTcnNz95Nw + hIguX74sRMdiYmGxwPh5KToWNz/m1/DvWdS8P3HiBChXZwGitLQUZNFRVFSEvXv3Ii0tDdnZ2di9ezco + jwfl80hJSUFiYiLIxqOgoADkNsT+4MGDOHbsGBcKxWdyysF/k78HfycJGP4u/Hfld+S9BAm/hr/XgQMH + zmzevDmL/sewoUOHmjVu3LgFOR2eNfrXPJH/9sZj9DyPny/2aWymyWBxck/NYmUAdJjyMtxW9sb6vdOw + NWshNmfMw4bUWYhOnYGYtBkCApuz5mNb3nIkl0Yg9+AWlBxNQgoBYX6cOUYGfodWtn8Tn8V1BAYB1wd4 + MhG7AUoHbjSx0OxtYqmZSo+7sRvgSUjK1/uf21566aWX33zzzQ8HDBgwctq0afMTEhIKKysrr5Jo77CY + WfgsMBY3V+pZSFL4HCw6yr/F606dOoX9+/ejoqIC6enpQsws7tjYWGzcuBFxcXFYuXIl1qxZI2L58uXi + 59WrV9PjZQgODhaPKX9HMP0uIiIC0dExWLduHdavXw9yIuLzGBD82YWFheJvMRD4b589e1aInYXPYufv + Kr8z7/k7suNgSPD+zJkzN7dv315CIIi1srJyatiwYZsPP/yQQfBXevDf2hpM1rzWzErTjqz4XMrLjzAA + xEw/AkBjy8cwavq3WLrVFgm5i7E1ewFi9s5E1J4ArKWcf11KIEEgCBsz52JrzkLsLFyBVHIBBQcTUHxo + OzL3x2B9ynR4rOyL3p7v0mfWE7UBrino1QbMNVdJ/OX0t2Np70QupOn/YkrwySef/EQ94EBPT8+VJKoc + Ej6L6Y4UDfeWLBQOtfi59+WfuWfnnpl79NTUVCHKDSR2FjzHqlVhiIyMFBG6IgRhYWGgfBwrQoKxMnSF + ED8/Dibxr1hBP4eGYkXwMoTR8+EEAf555cpQ8R7+DP681fSYgRATEyOC/w67h9TUNJBjAaUq3MPj9OnT + QvBS/Pw/SADw92doMdgYGPxaciLVS5cu3ero6OhKIGiuFAz/qgf9pzfu/aknHkHCiyYA8KW+YorvzyTQ + NvbPwnxBM6za5Yrt+UsFANYlT0NEki8id/vT40DEpc+mNGAB4jJmI2KPL73WC5sy5iO7Ihblx/ag4vhu + cgORmL/JCsMCv0UTq6eE+OUswu+VNIP/bkMzzRX6Hlo3YKnp1cxG8zkBgoeVHuXtiU8//fRdsr0Dqcdf + Tj3gfrLm17jXpB5RiIUFwiEFI+08//748eOi183JyRGi515569atQoiUXyMmOhpRa6mHj4wQP6+JXE29 + +iqEr45ARDiJmsQdGhYuxLwiZAWWh6xESCgFAWA5/bxiJUGCfhdGwl8ZtgqrI1bT+wgAq8OFa1hLn71u + bST9jbXkDqKFM4iKitI5hB07dgiHwOkFg4kBxe6ABc//B4f8/7jewMG/YxCwk8jKyrpAzmTjiBEj7H/4 + 4Yev6XjxLMW/tv/U1mCS5i0S2yASYATteahO9MwsyhY2T8F0TgMsT7CnvH8BWf15iEqZitWJ3ohM8hMO + YGPGHGwmB7Bqlxu8Vv8Cm6VtELB2GDmF6QICFSeSUXYsCWn712N96kz4rx2OIdO+RDObJ0WRkGcS8kiD + qA0wBCzIDVhqKhpZajaxG2hqqWnFLkX5uo/Sxr3ZCy1atOhMPf50Es/+srKy82ybWejnzp3T9Ywcsqfk + 37MwWPQsqD179iApKQmbN20Slp6tfUz0eiHGmBgS5LooRK5dh8iodVi1OhIrVkchNDIKy8LWYPGqdVga + Ho1Fq9Zj/sp1WBS+AQtWxWDOinWYvyoWC1dFY95K7e8W0+uW0OsXh0Zi6aoorIyIQhh9HkfkmihyAevp + 75IToL/N8ImLixXuY8OGWGyi70apDAhuAgYkalF/OHz4sOjt+f9Ti5//d4YbB/+/DAz6Py/MnDkzimsE + L7zwwufaQ/jX9odv9R01L/H1/CaWGm++3p8BwGLk+f287+fzAQKjRpGgubcPIvvvTwDwQSTto0nkDIB1 + yVNJ9EMxyP9TtLZ/XswXcFzehcDhhB35wSg8tA0HTmcQDFJFihC6wxVWi1qjneOLwgXIeQbsDNh9MAgI + AtcbW2lS6LvNaEaAamGu+bHZRM0rytf+U2+U579Cdv9TasyuZKe3kVW+Rz3jHRY5N3jZ8KUoWPgsAhZM + SUmJEBCLngWVEB9P4t8oRMZ7Ft36mA1Ytz4aK9dEI2xdHILXbsCSiE1Yui4BC9ftxIL1u7B4QwoWbkjF + grh0LNmShUWbsrBwSx4Wx+dh0ZYcLKDHCzbn0ONszN+YgblxGZi/IR0LovdgzrokzFmzHQuiErBo7VYs + Wb0By1bHIHRNDCLXxSjwicEGAtLmzZuwhWLrls2IJ2eybds28b05TeDCo6wbsJPh/1kNAP6ZAcGPGXrF + xcW/EQiqKS1Y3rJly24ffPDBh8oh/Wv7ozae+ss9LAm/N+XgCSS+W1wHYAfA0cruWUya3xSLN9sgimy/ + Nv+finUEhA0EhJjU6ZgfNxmjZ36PRuZP4pMRGnwxmtyD7YsYHvhP6vGHIi5zDvIObqZ0IBn7j+1GXhU1 + mqwFBJaRGDr1czSxeALfjCU3MK6mQChqA5QSkCOoIgjsbGqumWZirulE3+9N5av/Kbc33njj4960Ua+/ + ihrzMW7gXE3nRs8Vdf6ZG74EATd8rgVwtZ4Fk5ycTL1pvBDRdtqzzd68ZSv1uBsRGR2HyNjNCInajGXr + E7AsNgmLSOhLt2YhOCEfy3eVYuXuCqxMrkJY2hFEZB7H6syjWJ1zCmtzzmAN7SNyTiMy7xzW5J5BeOZJ + hGWdRng27TOOITiVIuUIQpKrsXjnfizYvg8LthVhAcFjflwa5kYlYv6aBCwlKISu2yy+T1RMLGI3bqbv + uRU7ttH33sZOYBt27twpgkHGkZeXB3JA4ljw/83Hg4+F+pgwBHn4kNOC4ODgpHHjxtnyZCg6rFwU/mua + 8R+5NTbTfEkCm9rYXLOvgYXmJqcB3BvzvrPza3CiHj043hHrU6Yhlqw8i59jxXYn6s1boqXtc/iShP/J + cA0+pvicHtef/Bi6e7wN26XtsSzeDtvzlqHgwFYCwR4BgszyGITv9IDVgpZo7/Cy9noDAgAHpwWiNsCp + gZnmLqUDRQSp+fQdh/DFRSbWGr445c+0Pfbee+/9bG5u7hkZGZlJvf5v3LhlA2eh82Nu/NzQuUdk4XMP + ycLngt6unTtETs3CYUsdtzkesZsTEBa9BStjdyB4QyKWbtyLFdtyEbyjGKv2ViEy/RAis04guvAcxVnE + FF1EXOkVbNx3BRtKr2Lj/uuIK7+ODfuuImYf7cuuI5Yery2+hmjl54jCK4guvYZN5dewOu8iIvIvY33x + ZazJv4jgjJNYtvcEVmQcx5JdlZi9tRiz4nIxJyYN88gtLFm/HSuiE7A6ZhOiCQSb4hPo/yAHQP9LUuIu + HQA4lWG4ceGQQcBuh48HHwt5PPgYMRgYBuSE7tCxqPTy8lr63Xffdafj+9fFZH/kxqkA5d09KBUIIft9 + VOTjnAqQEH+eXA8D/T7GjHWjsD45AFsy55H1n43I3T7wXt0PXVzeEJV9HuJrYfMs2tq/gCaWT4mfvx5D + nzP5WQz0/RS+EYOxITUIuZUbBQDKKLKryN5mzKfPHoOR5CKaWD8pZhCyI2A3IEcKGk7W3CLxV9N32057 + 76Zmms5t/iRu4N133321TZs23X18fCKpoR+qrq4WDZqDezxu2BxKDycKZTzeLsfkWRh7khKxY+cubN+x + k0Qfj7Wbt2PVhp0IjkvGivgshGwvwuqUChJ8NdbnnUZc0XnElVzE5rIr2EoC37L/GrZU3MDWyptiz7Gx + /CY2U8SW3UAMxbaqWyR43t9E6pHbiKfX7j18G3kn74p9zvHbKDx1B9nH7yD50E3knKDnKLbyZ5VdxfaK + K4gpvohQgsL8xEOYv6MS8+OLMHtDNubFJGNx9E6ExiQgKo4cy9Zt2EUA2LM7Ecl7dgsAMOQ40jMyBAjK + y8tx6NAh3fHh4OPDox187Ph4kTO6tXDhwt1kqiZ/+eWXXBv4a6Tgj9rYXptYacZSr5tGQrvD9QCu1nOO + 3sbhOdgva4fVuzwRT/Y9eu80zImdgEFTvyTB1hO2v73TSxg363tYLGyCkTO+QmeXV/Advff9QZQWjNKg + 05Q3YCfcgAPicxcjl9KCylOpKD+ZiozyWKxK9CK30BadnF8X4FFfU8BugEFAkLpJ3y2niblmQTNzzbD/ + dm2Ar4gbNWrUxGXLlpFzzbrAvb2ciMMhJ9PwnofLuDjGjT9V6fX3Uoh8f2ci4uJ3ImLjToRt3o3gLekI + 21lIoq9EVNZxEvw5bCTBb91/FQkV1xFPkUBCjq+8ISKhgoWvFf/Gcm0kkMBZ8Gkk9t3Vt1BA4q48fxel + Z+7gwo17OHHlVxy59Cuu3QYu3wJOX7snHt/5FThDj8/d+A137gHn6bWH6XVHr9zDwQv0GeduYy8BYivB + JyrvLFalH8ey3VWYvbkQszZkYu56+v6xOxEZl4CN8eRoEpPo/9xD/3OK+L95xIAnHvHIBqc+XCNgEPAx + 4pDHj0HKj6uqqngostra2np6o0aNmimXJP+1/bs3vh6AXQBX4Ml2X2EA8HwA7sl5AZDhgV9ibuxExKYE + YkWCI6wXtiJ38DTeHULitHgao2Z8C+/wfpi+fiQ8w/vAfGFT9PZ6l17zFD7ltGAkf87T5CY+hxf9Pnpv + AHIPxKH8RDL2U1qQd2Az4rMXEVhMMWL6P9HU6kkBAQ4GkViBiBwBuYIbBIND9P0Sm1pqawONbTVvKP/G + f2zj6bv29vZTuXGSlb/DPZZstLIRc0/GjZt7OxY+9/rp6WliSI/FsH1XEjZuS0Lkpl0I27IXK8neh+0p + w7rMw4jJP02Cv4IEsuYJJOwdB25hG4ldBIk/gYWvxBYSfDy9Jo4s/e7qm9hJUUyC52CRn71Ogr9KYr/z + G67cuodLN+/h5t3f6Od7JH7tY46rt3/DrbvAXYLALeW5X5XLBG7SA34//8hguEyfceDCXRSevI2Ug1ex + ufgs1mQfx7zt+xG0MR+zo1OwNIb/tx3YvG0ndiXtQRr935n0/2cSACQEeOYhzyfg4ySPHacI8lgyQAmc + dygtOhoYGBjRokWLLnT4H/Xh4f/sxstztbTRvE495ydNrTTfUG//HeX7P5qYaRpSj9qCnm9NeXY3Er8L + CSuZnucxeTQg0TEEuPft7PwyrBa3wrzYSfANH4Be7u+Koh87gD7e78FheQcS/yjMjjPF9OiR8I4cANtl + 7TEs8CvK8bUVf379V+QWOji+TABpggUbTbEhfQbS969DOaUElcdTkEVuIHK3HzmOjujq+oaAD9cEGERy + tIBrA/T97uhqA9q5DA3+A6sT82c/9sMPP3T29/dfSXnqJa7cc8/FDZaDG69sxNx7cePmhs7iz8rMQFp6 + OvYkp2DT9iREJexB6JYUhO/MR8TeCsTkncCmknOIL7+KHVU3sJ1iJwl/O9n37SR6DhY/Q4CFz/ZcuoCk + gzeRfewWys7ewdHLd0UPz2Jn8bPgObg3l48v8p5+zwDg/ZVbBAAOgsA1ihskdl0QCG4RAO7cq9nL7Vd6 + fI4dxdV7qCKHkHXoMjYUnkXw7gMIjCvArNg0LCEQRG1JQsLOJEp5UpCRnoHsrCw6JhzZokjI7ki6AT5+ + 8nhyysTPsYNiaMyZMyehc+fO4/662vDht3rNbTTvNSOBk9BtuNhHAgqi/QISThiJfQvtd9HPSdTz59PP + PB9ApAAsfLbfLMCfzeqhu8dbmDyvCUbP/BFNrJ4W+XoHp5dhvqAJvCN+wbR1wxG4fgSmRg2D39oh8IkY + AOcVXTFhbgNyA++gkcWT+Iwg8Dk5gkb0uX0934YDpQUrtjkgpXQ1yskJVJzci/yDCdhVuBJLtthgwpyG + aG33nJg3wH+PQSLqAhwWmlv0fatNLDUp9H0XEtSG/YGrE/Pc9afJhg6gRriFrOxtnorLQufGKRssN1YO + /h2P5XPjzhUAyCLxZ2B7YjLWk/DDE9IQtiMPa9MqEUvCTyi/hG3lV7CLhLyTLPtO2u84oA0pfh0AKLZQ + 7r9L/P4G9pHo2dqfvf6rED6Lmx+fufarEOc5ggCLXwb/XoaEgDa0AJAQuE7i55AQkE6BIcBxm0K98QoE + 1ylOXAPKT5MzKTmP1emHMWMTpQcx6VgWtwcx9L/vSd6LLBIziz83N0e4Iz5OfLy4SMjHk4XPx5MfM0h5 + z06KXvdrZGRkXo8ePSxeeumlj5Tz8tdmdPPQPNbcSvM29frdm1po5pBIEknkxY3NNBW0P0wCusBCJxfA + +bXoWbnwxnabe3623tzzfjVGgy+5oGfxBOX2L6Od04uiat/M6imMnvFPuK/qBX8SvN/aQQSC/vCK6Aev + yF/gt2Yg/NcMgEd4T1gvaY5BUz9AK9sn8T3Zev5Mrvi3I3cwLuh7BJFr2JI1HwXV8ag+k4nD53JRWL1N + TDhyCu6Kzq5/F+IXk4doL0YKFHdCAOALjA6RC1jbzFwzkd2AMmT473IDYjms9u3bj6F8P5V6/V+5is+N + VDZO2VvxYxY/V/jFxTX5ecik3i45NQNx2/cgclsqVpHwo0j4cfnHkbD/EgmZxHzwBhIP3hLBEOCQAFBD + gMUfT/l+yqFbyD1+GxXn7uAUCV0E2fzTtFcHOwAOQwhwHUAHAQoJAXYCHAwAGWonIEGghsAdCjYFEgec + InCcuwkcvnQHu/afQ+jeQ5i7lRxB9F6EbdqDLbv2Ij0jE4X5ueIY8bFiAEgI8HHl4ymPsQw+vuSqbhEE + CgcMGOD26quvvquco782w43H+JtYaLpQzz+7iZmmkIRxmXrM2yT8X7nSz8EA4D0LSYpfTtf9UREaC05Y + cNpzgU7YcLLm/cj625PN91szSACAXYD7qt5wIyB4UHiv7g3fiD7wi+gJr5UdYb+kIcbP+gIDp32Lbv7N + 0cz5e/ww+XnUn1APXae8AYdlbbBmtzuyK6PJDSSLyUMMgW25yzEvbjLGBv2IFjbPiCXI1CsQiWXKzTW/ + sXshsGXR/7mQHE1/gtq/YzLJ4zy5p3fv3hahoaEFLH5ulGxXGQKyUfJz/DM3Xi5uMQAKKb9Ny8jCjpR0 + RMUnI2JHNiKS92EjCT9+33kS+3UkUb4uggSdSKLnkABgF6B2Aix+tvrph2+h+uKvqKYcnAt2x6nX5xyf + 4yQFg0DCgF2AcAISAioQXDACAAmB+zkBNQQYABICnBrcVaUHvN0mEFyizys9Q/9f+Tks312FeZtzsTA2 + BWvpmOzey7WAXBTT8SopLhLHjtMqPo58PPnY8jHmx+wAODhF4J+jo6MPDB482Pftt9/+ks7TXwvMqDfO + +znXJ4H7UGRTL3+dxc6FNJ5swyLm4McsfA4Cg/YqPct6ZPEfQ0vbZ9BpyquUi7+O1vbPEQy0FX8GQWeX + VzF5fhPq3fsKu+9Lvb3X6r4EgJ5wC+tB0Q3uYd0JBD3gtaoLfFa2hndoC3iu7gP3GHc4bQzDqFBvNHf+ + Bh8P1eDDAeQozJ/GhNn/xNzYMWKoMatiA8qO7iEYUFpwYCti02bBNbQnenr+g77r4wJMXBeQ1xTINQfo + /z5EriCMHk8gsJlQvPsvLkz6OF/D3rdvX7uwsLCKgoKCe9wYuYfnhigBIBsoN9qSkmLRiIuKCpGclonN + iWmIJLu/ZncRYrIOI6H0LHZVXcGeQzcpbukAkKgKCQAJASn+tCO3kH/itijsHbustfvHaS/jfhCo0wko + EODgwl5dENBzAhTqdEAHACXukug51Bu/jv9e3rHriM47iSU792FOXCZWbk5Gwu50ZGbniGMmAcA1AT7O + 8hhLAPBzXFdRQPtbTEzMsZEjRwa+/vrrhmsU/p/e6v1E1t/ESjOERL2DcuNrwuaTOBqQ0Nm+ywq7mHBD + zzexqkcif4as9qvo6fEm+nq/ixHTvyGRN8XEeY3Q2/sd1Dd7HF+QdW9q/SRGzfyWRN4TvpGD4BM5UFh/ + DwmAlZ3hFtqBANADnpHD4LVmBP2e3AClBdM2uWHW3u2YnV0Jj4RoDJ3dRtQDPhlMQSCoT2Lu7f46HJe1 + Q+gOZ6SURBAEkgQECg9uQ1JhGIK3O1NK0QadnF8V/ws7AuFO6HPYyVD8RinBcTGkybUBC80ocgNf/U4I + PM4r7fbr188+IiLiAFnUe9zrc8MzBIBsmGXUMLnxFlJDTkrNQvSONETszMG61HJsKT6NxMor2E1WP/kw + i18bXLXXuQAKAQESvdoJbCMA8Jj8PsrzD1+6i6MkdnXoIMBAUNwAQ4BDpgLSCUgIqEEg0wFRINQ5AW0q + IEFQlxMwTAWkE9C6AYhRBLUn4KLhscu3kVZ9mdKCavitz8LijWnYsCsNGdm5JHzq/ek4SpHL42wMADLd + ioqKqho1atT0v//9758o5+7/9sbr+5EIWlOjn0dW+IjSK4poTNa9GQm4jf2L6OLyJnp5vYt+vh9goP8n + GEH5/MR5JmJ2n+3SdnBd2ROe4f1gubgVeni+LQqBDSj60Hvsl7cXtl9r/fvT61j8ZP9XdoPbirZwC2lJ + vX1/+G2eioBdoZi6Y76ImSlbMC+nDPOz8hG4dRbslrbC8IAP0N3nOzR1+hZfmr6AL0dp0NLqGYyd8Q1m + rh+B2NTpSNu3VoDg4KkMFB/eiU3ZCzA1ajiGBHyJplZPi1SFnQADQc4bIOGD4FdN/380wcCmoZWmzUOu + Tvw4L4WtiP9gbm7uPW5o3CsZAqCmYZaJhpmbX4AdezMRtSMDa5IKsSH7EHbsv4A9ZPdTyLqnHL4tJtrI + YADUBQHhAEj8BaduiyG36ot3ceTyXQEBdgEy2A1w6CBAwr9fOmDMCUgXIECgg4A2DNMBnRNQXACHTAXU + 6QDXAQQEKDgz4JAbvR2nrtxCXP4JLNq+D/NiU7E6fi+SMxkC1PuX7UO56jhLFyABwKF2C5s2bTrL6QBB + 4FPlHP7f3X620nxMDZ6H9HJI9HfYGjegnp9ggDZ2z2KA70fCvjuGdIFzaHc4r+wOF7LW7qv6Ut4+EFPX + DhNz9QNIYM6h3TA08Gs0t31WpAwdHF/ExLmN4EX5fsC64ZT/Dybr3496+14k/u7U83ci8beAOwHAe70F + AlOTMIt6v1mFRxFUUI05xWcwJ/8gZiaGwT+yDzyW14dX5FB4x4fAIiYMnab1pvz+CXwyRIMfKM/vTo7E + bmkbBCfYY09xGEEgERUn9qLo8A4k71sjLkFmWPHiJZwS8DUFwg3Qd+V0h9zFPfr/T1PkEhDDGlk/cHXi + x1555ZWXunfvbkW2v4rFz41NNjR1ryQbJTuDffR8Zm4e4vdkInJ7JqL3lmFL4QkkVV1FCgl9L4v/yG0B + gWSy/tqocQK1AEDBYCgk8bPoWfyHKKpJ/IcoGAISBLWcAIcKAmonwKGXDqhAoFcYVAFAOgGZClynUENA + gIBEL91AXU6AwxAEV27fQ8ahy+IahvmbshG2NRWJ5J7yC4uE2GWthXt7DjUEtKlWkTgftL8XHh5ePnDg + QK/XXnuNh4P/T271WlpqXqaerxsBIJYAcIl7f7HIB/WKTSwfQ2/Pd2CzuDX8Sbg8bh+4fiSmrhsG/6hh + okedtm4kgmLGidV+/dcMgdmCJmS1tbP6WGA9Pd4SM/b81w4Ww35cAPQil8B23zW0I1xXtCYItCZRD0LA + 9hAEZR9DUO6vCMq8jll5tzFnPzCr5CimJs4n19AZ3qs6YfaOhQjedw7zCs/DJmoaurm/J8T/+QhtmtLW + 6QWMCfoeU9cMwNo9Xti7LxL7ju3BgVOZKDmSiPjcpfCLGCTmI5jQ/8huQKxJqAIBHwcT7SXPWwkAutWJ + De5cxKvyPtehQ4fxwcHB+7Ozs4X4uZEZ5qWyOn2AYj81wLSsPGzenYk1ZPk3ZFZhe+kZ7D10Qwifp9oK + AKjCEAKGToDrA8Ukfhb5QRa+QRiDQC0noEoH7usEFAgwAPRqAgYQkE6A4/cUBtUQkADg5QtlXKHPKzxx + HdFZRzAjLg+L4lKRsDcHxXTMKwkAVVVaAMhRAT7+agDwnsHMhddVq1ZV9ejRw+a5557jOx3pbqDyf2Lj + Of08sYcaeQBBoJwtMDf8BiQAru63sX8OY2f+AI+w3iSmodQDU/4e0ZcE3JuiF7wpfOnnaVFDMJ1A4LN6 + ACZRSiAAoIwCdHX7O8wXNae8f4AWAGsJAJz7h3Un8VPaENIMHhG94L99JmZkFmB60mH4rs2B18o98N9Q + TM9dQlDxSUzP2AL/bVMxbdtMzEnfgyUl57EopwR+G1xhPu8H9Pd5B+3dPkFTx/fxs9VzqE//Qzv75zFh + 1o9YtHECdhetRMXxFIJABkoOJyK5JAKhO1xgTXDj78ujGNIN8P9OQBQpEKUG5xuqVyfWv3PRky1atBi8 + ePHivMzMzHssem5gEgDc6LjxySG/g9QoKyoqhfjjksj2J+VjS041dpHlT6U8P/XILTHvXguBmtAHgTYV + UNcDdtPjolN3hMjZ+h/kINGrQcC/kyFTAQkBtRNgABiDQC0noLiAWk5ABQI1BKQbqOUEFAjoOQEKBoAh + BDjkxukC1wa2Fp3C7C1FWBiXjs3kpnILSwiylThUrRW/nGvB54GBzOdGN+RaUMBxd8mSJcVt2rQxpfP5 + sva0/h/ZeBUdathOJPpk2ovenxs+A4Ar+7w0l/WiNgSAvvAkCDgHd4DjkmZwXNxIhNOSRnBZ3hweKzvC + d3UfSgf6izsBDfT/lPJs7QU+zWyfwfAZX8OV7D4DgJ0AV/a58OcaQr3/ijbw2WiNmbnp1POfJ/FnYIrv + XNg7+WBKwBJ4rdqBgB0FmJFeiKD8QswuqcTs4sOYlZWL6QmzMXV1d3itaAbn8OGwXuONUctt0M7zRzH6 + 8O4vJOhRGgzyfgcBEX2wIXUGsnjhkeOpOHQ2FyWHdmJT5nz4RQ6hNOdjErx2pICDhzS5PqA9FuyGtKsT + 0zESdy76eZTm439+/1WvGTNmJLP4uWFxg5IA4MbGdpQboGiEFJWVVUjNzteKf08hEgqOYk/lJaST8Lli + z6GFgDaMA0DfCewhALDtZ9FXKSEAIEMFAUMnIFMBPQgYOAEJArUTOKNAQA0CY0OEMhWQIJA1AeEEFAA8 + yAkwADjUEGAXIDe+LUl61XnMjS/FvA3piNudjfziUp0D4GMvZ1ry+eDenwHA54ohwOkAL3gaGBiY2Lx5 + 874ki/8bi82KxT3MNT3J1vJqOpeocf/GPZ68vr4j5chjg36Cw/LOcKbc33FZa9gsNIHV/Pqwnv8Txc+w + WdAA9osaw2lZcxJze/gIZ9AHFgubkfV/Gz+Z1ROFti7kAqyWtBILgbBb8Apn+0+9PzkAzzXDEJgSQVb/ + IqYnn4br7AjYmNvCcvx42FhYw8HFm54Lhn9sCgHiHOZW/obZ/Nr0RPhutKWUoA2lI0MxY9dqzMoogfe2 + DRi7cABa2byAz4do8NFAsvbUs3dyfJ6cQn0s3WKOpMIVlArsRPmJvSg+vAt7iskN7HSDPf2vPeh7swPg + Kwx5hWKexyBSAgajufbORXR8Vv3Y6+UZju62u5OTk39lwfPMNAkAbmTc2OQsv8MUBw4cRFpOAYk/G+uT + i7C9+DhSDl5BxrFbyDh6SwcBYwAwDgFF/Ce54McX7mgv3qkk0bMLqMsJqCFg6AT0QECil26grnSAQ88J + KBAQIFAgIEPtBPQKgxSyMCghoHMCpHadE6AwBgF6Glfp85PKL2D65n2UimYiNjEbecX7UE0AOErCV0+3 + 5vPC54jFzzMKOXjq9fbt26/7+flt/vHHHxuTPP63LydmC0vCb0Sinyaq3tTDce/PwmcAtLB7GoOmfgar + xW3guLwjbBc3hRXZbEsSvdWSDrAOGQTr0DEUo2C3YhAcgrvCaWkreIV2gD/1tK5k70cH/YCWds+JIbdm + 1k9hLFlxnuobwClAWCfq+VuKYcCp24Mwq6gSs3KvUkqxBw7O/rAynQircWNhPWECrCdNhp2tI1ymL4HP + 2jQE7j6KmTknMYNOXEDycvhtdcG0nQsxJ6sAC/MOIyhxLVxW9sfYwI/Ry/M9tHH7Ej/bvYtvTB9Hg0mP + YaDP+wSN7li9yxV7SlYRCHaJCURcG9hVEIY5cZMxasZ39N2fF7UBrmWoi4QMgp9GP3lumEXXI7EbYu7I + hqQGAPcqstEdof3Bg9VIzy0UvVNMSgl2kPj3Vl9BJotfCQaADDUE6gLBnupbyD1xG1Uk+goSP4cAgAIB + dgI6CFCoAWBYGJROgEMHAA4FANIJyFRAgkCmA3pOgMIYBKQTkKmAHgSkEyDRG4OANrROgMMQArzxcGHW + wYtYsqsc8+MysYFAm19cJuDL54DPBV9sxXuGALsACQAJgZiYmDvjxo2b+/nnn39HMvnfXVSEi1lsZU14 + aW9lHr8EQBOrx9Hd/S2YzmpAwm8H2yUtYUHiN5/zLYm/ExzWOMBlcwjcEmIo1sFl4xI4rbGDY3BPSgda + wzusM+X4vei1LbUuYFI9MeFm4NRP4RLalQDRlwDQntKKdtSDWyMoLw1zim/CN7YQjt5zYG1uLURvY24B + W0tr2FpYibCzcYSDWwBc566CX0wqpQRVmFVYiZkF+ZhVsA9zi45jTkYqpm1yIRC1IcC0h+t6FzhsDMew + EBeYOH6CDwdr8MUwDdraPofxs/5JvcUYbMtdhMJDCaI+UHIoEaml68R0Yh6t6Ov9vnAAvH6BmANBEPh5 + 3GPoMv5bLF4+7x5fbCIbkAQAF/24kYnLe8VlqoeQmVdM4qcGtrcEO0tOIFURvwzpAkSQ4A3TAUMAJFNk + HruN/efuopyCp/dqAVDjBGQ68P/lBOoYIuRQO4G6AFDbCejXBHTpgBoCCgiMpQPGagKyMMgb/5x5+Arm + bi/HzBiCwJ5clJaVCwDIy60ZAgxnLgKy6GXwOeTl0lesWHFo0KBBjiST/8FUwEPzGF8PT5a/G/X6G0j0 + l5RClwh+3N6Jl+f6huwy9foLm5L468Ns7k+wXNIVjlEe8E5MwOzcaiwvOYfgotOYm7UfPju3wHmdD5xC + B5Kt70R5e1e4rOhIn/MVAeVJMeGmm/ubsFzUCJ5hHeCzujP81o3AjJTVmLvvIvXqp+AYGArzyVaw4N7f + 3BK2tvaws3cSvb+dlQ1BwBI2Zuaws3PEFP+5BJoEBCZVY3bRdcyruId5lTcwI3M7fOPMyGn0QGDcFCzI + TMOigtPwTFiPgTOboz715J8RAPi6gsZW9TDA7wO4r+wmVjLeXbQKRYd2ovJEOvYfSxb3Kli8xRojZ/5I + DuZZUc/4lkDQePg/4DbVXixaoW48DADO++VlvdzYDhMIcgpKsHkPiT+lFLtKTiL98DVkHb+FLBI9hx4E + OEjwxpyAGgJpBIqS03eE+HUAUCCg5wQo7pcOMACMQUDPCSj1ALUTkOkAh0wF1BCo5QQo6nICHLWcAIWx + wqBunoAifj0QaBlAQLmHHILAvG37sWBjFuL30nkprxQwPq4AgBcTYQhwqiZ7f3mVYVJS0r3p06dnN2jQ + oDcp5n/rHgQ85EcWtiUJP4DsfwX3+ix67qE5mts+KRb25CvqLOY3hdmcH2A68zNMnN8cdlFe8N2TgYVF + FxBb9Sv2HiPangC2Vt/BsuLz8EvOwpTomZhCEPAM7SjCdPZPaGX/gqgDtHH8G8bO/BTOy01I/AMRlLQA + 84qrMDPzAlyXx8PMygUTRo3B5PGmsKTc34aEbssAEBBwIAdgB1sGgSU5Ais7OEzh2kAY/GNyEJR1EXPK + bmFGfjb8d83B1G3TMGtvPIn/EBZm5ZMr8IPNYhMMC3gf3X2+R0u3H/CT9atC1M0tn8FIAlVQ9Agk5C4U + bqD8RArKju5GTtVmbMiYA7ew3ujq9gZ+GPI8xtgNRHzCVtFoeEFOCQG2/lxwUq9WU1C8H1uTcxC7t5h6 + /uNIP3QNOSfuaAGgQKCWE+BQ1QQM6wLsAPIp799/lgDAoUDgQU5ApgISBMacgASBUSfwgMKgTAX03IAR + AEgIGHUCCgDUEPg9TkC9ZVA6MHvrPszbmImdmXRuKBU4SeJnAPCaARxcKORUgMXPhUB2dHxOd+/efdfe + 3n7jRx991IBk878zNEg57Edk/21I/LvVVX/u/bnq39X1NYyc/k9MmtuYen0TTJjxBUZP/QdMF3WEy7Y4 + zC2+hfXldHCrrqP66EWcOnsdlWeBHceBRfvuwn0n5fDh5iToVnBf3gzjg74jALwocmmeNjx6+gdwCW6O + GQkuWFhSKD7PY20mzB19MW7MeIwfORqTyAGYk+W3JMFb2dgrIJhCIFCCnrNlQHCKYOOAKT4z4bViCwLi + ixCYVoQZWekIol53TtkFzM6voudnwzu0LTyW/hNekSPhtnk5JkctRLdpnfDNuCfxTl8Nvh6pQW+31+BO + 0ArbOQU7C0NQUM2rE2ei6lQGUvathdfykRjr2BPrYtaInkI2Fm48XAfgYSYW/smTJ0Qj20e9zjbqfWKT + C7Gz+BiJ/6pYRkuGGgK1QKCkAxICagBkkPXna/gZALxXQ0DtBNQQeGBhkIQv3YBhOqBzAhTSCXDIVEBd + D5Ch5wQUCHDc79oBvZoARZ2FQQpZGFQDQAcCEj/H1Vu/Ynf5BQRuKsKSzZnYm1uCQ4e1dQAWv1x7kesB + fD4lAPh88hDu6tWrz/MkoVdfffUdRT6P9sa31ybRtyXBrybhn6P4TYqfQdDO4XkM8vtUXEE3YU4jTJj9 + M8ZM+xgj/F7H+MXd4Z6SheD9wPaSOygiYR0rLcblw9W4dOYySgkCaw4BnmkVsIlwhCP1tg4LvsXwgI/F + bcB/IuvdyelZTJ7zDXyjRmBuxnosqryGgMSTsPRZilGjxmHUkKEYN3IMJppOwmRKAcwp/7egHl9AgNIA + Wzt2AwQATgmsyQ2wE+D6AD22d/TAlMCF8I5IwPTd5ZhTehPzDgAz88vgt9kdXmEt4buqA4K2LcTcnAOY + mpIHs1ALsdDIl5QSvD9Qgy8JAm3snsa4Wd9hZvRwbMwIQv7BzThwMh2ZJVuweGUAlocsFr09NxQJALaQ + nE9yw5KNqurgISRl5JP487Gj4DAyKOfngp1cN48BkC0goIDAEAAySPBqCPCex/ul+GXUcgIkfMN0oFZN + gELtAjjUTkCmAobpgKETkKmAYU1AzwlQSCdQUxOoGSKUqYAeBBQnIFMBPQiQ0oUTIKXTj/oA4BAeQLvt + KD0jlh8LS8hCXnE5nR86T8riovJ88XwNCQAOfszrL86aNaugffv2nAo82htX/UnoX5PgHcUiHor1FwAw + 4yr9E+jl+Q5GUe8/btaPGD+rPtn17zDC/z0M83kZ45f2hldmGcIq6IBmX0LurhRU7I7HmfxUXD54AFUn + fkXsEcAn+xiso9xhs+BnTA76CH09XqfPr4f6ZLV7uzyLKSGtMGf3fCwqPYignEtwWBKP0RNsMHTgIIwY + NBhjR42FKQFgwiRzTDKzIBBYkRuwhSVZfitrBQQMAIYB76UbmGwuQODoNYPcQDwCdx1GUN4VzMwrR+De + 1Zi63QfTeLQhdRfm5VRg5p54uEeOxYSZn6AP/d8tpnyGHyzfxtcTnqDjUg/9vN6G0/IWCI63wrbspYhJ + WI6FS2aL9evlGnUSAJxHsvjlCr5HKc9MyykRBahteQeRfvAS8kjkeSR8HQQUF6CFQI0TqAUBAyfAr+EL + fNTi52AgiJTgAU6gFgRI9HWlA9IJcDxMYdAYBNROQLoAAQIdBLQgqNMJKC6AQ6YC+umA8ZqAujB4lr5P + XP5JBMXlIGpXLvZVHsQZFQD4Xgt8/jiFk+eVzzFHbGzsXXNz89VvvfUW34Xo0V1I5GcbzXsk9okUCeQC + LusAwGFJvT/l5wN9P8HoGd+R8L/HGIpR07/GcP93MNTnFQJAT3hnFCOEHMDGjEtIik9FZnw8yvam4CDl + 8bkH7mJNFeCfVQX7dW6wmPu9cA7t7J8WY/ANCACDfV6Ff9wELN9fgPmlt+ASkYExVm4YPHAwhg4YiOFD + hmPU6HEYO34Sxk2YDNOJZloQTLaCmbk1gcAGFgQCa7L9upSAQcAQsLIlR2Aj9vbOPqI24LNmN6YlFREE + yhBE35GnE88qOIAZe7fR93CC58o28AhtB/d19BkxCzBsmQNaun2Lf9J3/Wa0Bs0tHicH8yk8lveH7yx7 + rFsfpWsYsqGwdeSKv3rd+oLS/dhE4t+aXYG9leeF8GUwAIw5AQECEreMWk5AgQBP+GEAGIMAh54LUEFA + 7QQ49NIBCkMAqJ2ATAf0nACHCgJqJ8AhUwEBARUIHnqIkMLQCdR97UANBDjUIJDbkYt3sHLvIczflINt + 6YWoPnREBwBeVpzPH08aYvsvzzGvw8ijAqtWrTrXpUsXp0d1SbF6fONME76hJ09ltdCcpPxfWH4WP1/P + 39L2KfTyeBvDpn5Oov9GiX9ixLQvMczvXQzxfR3jFrWF+66NWFB0G6tzqLfffRTxiaVISjuAlKJL2FIO + LC2+Cb89SXCKMMPEoC/R2/VZ/DyxHr4coUFTchqm8+pjXkY4QqlBB6ach6n7AvTvOwD9e/XAEHIAw4aN + xIiRlAqMMcXocRMwlpzAeALBhInmmDjJkkBgKRyBBYnciiAgagMMACXs7QgMlDbwSIEtuQUn7+kk3mhM + jS8hN3ALcwhQc/ZfRWDaZvjEThKjEQEx1liQnoaF+afhvX0TRs7rihbWT+NrvinpGHZIT6O7+VeYvWCa + aAxqAHDvz+P93Hi49+coqzyA7Wl52Jy2D3vKzyD3+E1RsOMwBEHtdOA+ToCCX1dKIuelvDjKHsIJ6EBQ + hxOQALifE1BD4H6Fwfs6AQUCDABdYVAFAAkB6QQ4dIVBNQQoZDognIAAgDbuVxikX6Hg+HUs31WB5Vuz + sTdvH44cO46zdM4kABjenPvL88wAYCDwfRhcXV13fPvtty0UTT06W8tJmr+R6BtQL+9K+6LG5pp7tNcV + /ppaPYYuzq9goN9HGD7tCwzTBYmfgDDM730M838bo+fUh+3aKZi6N4fEchMrswkEmRexJvcqIkuB4JJb + mJGaB/cNgbBZ0hlDfd9CS6t6+IoXAaXg6wGcY+2wvPIQFpffg9PKZAwabYVenbuiX4+uGDRgEIYQAIYN + H00QGIORlAqMHjMeYwgE48eTG5hAboBBMJnSAsr7za1sRJHQ2pbdAAGA3IC9qA/Yw86K5w5YEgRsYD/F + E84zlsNnbQamp53BrOLLmJGbg4DExfDb4o3pu9diQeFJLC48jelk820XNccQ71fp+76Ltu7fwcScjoFV + D3EDDrEyLwU3Dm4kbBm50XDjOXfuLA4fOYY9OUXYlFqIpOJjyD12AwUn7+gAUCcESNjGIGDoBIpO14if + Q+cEOFQQ4KgFACMQqOUEDCFAwpduQKYCEgJqJ8AAMAaBWk5AcQECBAoEONSFQcN0gMNYOlCrJkAhC4P0 + UB8CWgbQ++4hsewcgjYVIWJHLkorDuI8nbdzCgD4NmQ8csM1HQkAeW+CsLCw82PGjAl49dVXH63VhZta + aN4n8U+kHn8r9fznWPzc+4sgALSzf47y3XcwxP9TDA34DIPJ8g6a+gmGTP0MQymGTf0Yw6d+iJGBX2Ds + vFawXuMCr8QdmJlRhbkZhzAv6zBmZR+Bf3IanKMDYLa4IzmGf6CNzRPCRvOYe3PLxzAppBvmF6YguBrw + 2bQfo+z80bv3QPQkAPTt2QMDyQEMphRAC4FRGD5itIDAKILA2LETMI7SgvGm2rSAITDJ3BJmokhoSymB + rA1M0aYG7AhEkZDcABcJ6fcOHtPgtmgt/OLSEZhcjJlZeZQa5GJ26WHMKT2PmXt3wSdiJKbM+wT2CxvC + Lpw+f3Ug+jsPx9xFs8XNOLgnkADgnoHHkcX9+tgBnD6D/JJybE7Jw/a8A8g+dIXEr71xBu8fCAEOHQQU + EKgAkE0/q8WvjjrTAQ41CEj4NelAHU5AAUFdTkCmAnrpgJHCYF1OQA0C40OENYVBCQGdEyDhy5CpQO2a + wP2vHTh99S5Wph9BUFw2Nu8txKGjxwW8GQB8z0W+OzGP5nARkM+1vP0a134CAwMLfvjhh/Ykq0djmjBf + ttrQTNOGevuVZPVPm5hp7gnrT8JnELS0eRI9XF/DAN93McjvQ+EC+tOeg+/sM2Tqp5QDf0GpAPWC/h9i + gM87GDD1K4xe3BdWa90xZcNsOG+cB4fY6TBbOR7DZ/6MHi4vkd2nnp8sNC/bxbcNHzHnexLdEqyovkJC + u0DWfzG6d++Dru07oGe37ujbty/6kwMYOGgoBg0ZJkAwdNgIgsAo4QZ4hGA0pQVjJAg4LRBFQiUloNxf + FAkpLbAm8WvrAwQBrg0QCLSTiBgEDnDymQHP0DgEJu7D7JIrmEtAmlV2Bn67VsCNL01e+hN811thRtIO + 2K1aA0d/d2zbvk17Uw4VAHi2n7yLLTeeg5RT7kjPx9aMMmRUnUfBiVtC/CLIBWidQI0bMAoBEr4xJ8AA + yD9ZNwA4jEGgzsIghWE6cF8noIKAdAIceukAB4leuoH7pgNGnID+6IA21E7gQYVBnRMgteucAIUaAnIr + O30DixPLxY1O0wv345QoBGodAAOAawPs7uQt2HjCF5/39evX3xw1atQCvp+jIrE/78ZV/yaWmi8oz7fl + i1d0vb4Szcj6d3J6AX0938IvPv+geIfiXfTzeQ+/+L5PUPgAg/0/xrAAEn/AlyT+99DV6Tm0stKgte3T + ZJH/gb5+X6N/wPfo6/sFOru8Rj19Pfw4VoMvyPJ/MZJSDBL/wOlfwzveH0tKKjAv+yKs5m1Et55D0LL+ + T+jQohl6du+BPn37o+8vA/ALQWDAoCEYOHioAoGRAgLDR3BKMA6jRlNKQCAYO34iQYBHCsgNTCI3MJl6 + ay4SkhuwVNyAAIC9M6UFFHYOsOMpxZPNRH3AwdUXHoujERC/D0G5FzGz6DgCUmPhuWkKvDe6YvqerZQa + FMBx7hysDF8pTr50ABxsEdn6i3vZU6M5To8z8kuxmax/8r4TKCDrzzfY0AFACXU6oAaAHgQ4FAgIEJD4 + OYpO30bJmdtGxS/jYQqDOhDonIBSGCThSxBIJ6AGwJ9iUREDCAgQkOhrpQOkdnVNgEMNAV50dHfFecxP + KMLaXXkopbRUOAA6l+wCOHiCEKd5EgB83nlPLmDf999/35Uk9ue+5Rjf8IKs/0jq7WMJAGIpbxlNKFrb + PoVuLq+ij9db6OtN4fW2NrwJBt7vkuDfJ1fwEUHgU3GZbA/Xv6MFL5wxXoNvx2jEntfi4/H9H5UpsqJw + RsEXz7SyfgxD/d+F6/pJmJ+fjYXFN+ERux+DLf3QqmkLmHz9BVo1aoguHTujV68+6NWnH/oQBPr1H0Ru + YLBwAyIlGDqCQDBKVxvgUQJtbcAU40wnwlQUCbUQYDdgxm7A2l47UsCpANcGeG9DToBHCXg6Me3tHdzh + PHUhvFclICCxBNMzizE9O4PSghLMKjwNl3XxcJvmJawfn3gJAG4UbBG5t+CGwva/rPKgmG66g6x/zuHL + 2jvsUL7O4/UcdUHAEAQ6AHCQ+DnYBWSTm2DxyzAmfhn/jsLgwzgBNQT+5cKgEQBwqF2AujAoUwEdCCQE + FBAYSwcMawIyFTh26Q5W7D2CeZtysD2jhCB+GpcU8V++fFkAgWcISuFzsPOLjo6+PGLEiNnPPvvsn3cF + IWXM34R6/8WU5x+gx3f5aj+u/nO0sHkcHZ3+hh5ur6G355va8HgTfTjIETAE+lOPz2nBAN8P0cv9LbS1 + e06InS+R5SvjeJ0/vmSW1+vn4N+ZWDyJ1vYvoJfH3zEm8CNMWd4KM7f5Y1HRPszJvwmX9fsw3HEW2nfu + hSY//ogm33+H1k1M0LljJ/To2Zsg8At69yUI/DJQSQmGYNBgTglGEAiU2sBIAgHXBggEY8YSBMgNmJoq + BUJ2A2baIUMLS9uaeQMMABlcNKSUgGcR2pArcHD1htvCCPhvzMKM9GOYu+83TMs5D5sFIVgVEa47+RIA + fLEPV425kXBjOUa9f0pOIbakFSO98jTZ/Ztijj4DQIDACADqggC7AGPpAL9GiJ9dAIUx4cvQFQZVAJBR + CwDGnADF/dIBBoAMmQoYcwIyFTCEQC0noECglhNQgUBdD5BRywlQyLqAzglQ6NIBFQQ4eOgwrfoa5iTs + w8rtOSgsryaon9cB4Pr162JaN4/2yDbAwXdinjFjRmGjRo1aKXL7c20tPTRPNDfTfESCN6XeP40AcFst + /mZWj6Ot/bPo4vIyuhMAerj/XURPil7ubwgY9PV+m4T/nrhQpo/XP9De8W9oMLme6NkbWz6J7vTaAf4f + og+lDd3ceAnw18g9vCsu/OHVgOyX8RJfHeC7ujcC42wRtGctgrL2IWDvCTitzcUot4Xo0msomjdqgmY/ + 10eb5s3QqUNHdOvWHT169EHv3v3Qt19//NKfQTAYAwcOJRAM14JgGDkCAQJKCxQ3MHbcxJragAKCyQQC + njdgtDYgrivgeQNW2iKhnTOmTJ0H75XxmLajGm5xxXCZOV+Inm/EKQHAvT8v6XX16lVh/9kFlFQcwFbq + /XcXHkL+0ask1DsCAIYQqO0EagCghoAEgdoJ8HuLCQAcAgIP4QT4zj+GAPi9TkCmAhIEaifAKcHDOAGZ + CkgQqJ0AA0CGDgJ1AEDtBGQ6IJyAAgA1BB7GCfB2+TawKvM4Zm7MFQA/QS6AAcDn9tq1a8IF8CQvPvc8 + K5CDHWFISMi1gQMHevA6kIrs/jwbX+lHFr8viX4VL3PN4pcAaELBhb/2js+LoT8WLkc3CoYBQ6C3xxsk + 5rfQj1wApwednF+inv0xcSmsicUTBIWPYLW4JRyCO8J6aWuYLWgqlgHnJbddVnQXq/36rx2EqWt+gQ/f + 3GP1L/CNtqW8OhpzS05hdvGv8E44jEkz16DvaEu0ad0ezRs2RKvGjdG+VWtyA53RvXsv9GII9O1PbmCA + gMAAgsDAQcO0RUJKC4YMJ0eguIHRXBsYO0FbG+CRAjFkyGlBjRuwtOYhQ3IDBAA5bMgg4HTAeuIk2Eya + DIcpnnCdvwY2M0OxcGkwEhMT9QDAk364979y5YpoJEdPnERyThG2Ze1H1oFzKDmlLdQJCFAIACgQqJUO + 6JzAgwuDOqCoIfAAJ8AhnACHAQT+LdcOUBhzAnoQoJBOgMMwHZBOgEPPCSgQECBQIKB2AmoI6JwAhSwM + 1qoJUEgnoAYA7/KOXxOXDocm5KCg7ADOnT8vHABDnoNHergGxO2AAcB7HhJ2cnJK/fLLL3nhkD/X7MAm + VpqfSegLGptrjpDo78iev4klL+39OFrbPS0A0MnpRXQmCDAIBAxcXkF3AkEvN3IBlAr0Ihh0JZfQgoDB + V8yx7e/l+S5sl7WDT2R/+EYO0K7sy8t6h/USN/vwIvH7rhkkbu/lG9ELnmEd4R7aGZ5rxiFgRwjmFFRi + YeUtzC29hmmph+AUuRtD7XzRvmN3gkAjtGhkgnYt26BTxy7o1r0Hevbqgz59fxEFQq4N/CJAMEQZLVAP + GY7VFgnJDYwepxQJCQTsBkRtQLgBa3IDPIHIXrgBGwdnLQR4QpGZOazGjYGV6XhMtnGDk3cgtm7dqgcA + tv/c+3PPwAC4QD1FYVkl4tPykVxyBEUnrqGURMmikwDQCZcEL0PtAjgeVBjMpefVnyU+TwHAQzkBCjUA + ZDzMtQOyMKh2AmoASAhIJyBTAb10gJ2AAgDpBGQqYFgT0HMCFLUhUDNEKFMBPQgoTkCmAnrpAKleOAFS + Pf2og8DV2/cQnXcK87bw5K0iHD91BteuXhHnmINnCjL4pQPg9sC1gEWLFl1s27btRJLcn2NeAOf9yg09 + J5lo7+ojenwZPOGnOYm5jd0zaOfwHDqSre805SV05qBevovzywICPdwoJaDoSs+1tXtKXCfAvT+v7DNp + fmOxSIZ2Xb8hWqETCHixT4YCA4CX/vYk6+++sqNY689j9SD4bJyOaUnbMTO9ALMy0zE7axvmFWZgTvEJ + eG2vhGlgJHoOnYxWrdqhZZOmaN2iJTq0boMunTpTSkBuoE8/9KaUoO8vAyktGIQBhkXC4aPFSAG7gZFj + KC0YSxCgtEBCQJsSWJAb4CFDHimglIDcgA0DgFMDa1ux8pD5mDEYP8kOM2bPFydaAoBPPFf+eaYfNwru + GdguJmcXISGzFDmHzpP4bwnbLW+6ySGFe18nQGFYE1DDgB1CseqzxOepncC/CAHDdKAuJ1BXYVDtBiQE + 6nQCBhAwdAJqCKidgASAoRN42GsHOGqnA1onIN3AnV95AZFrmLeDXMD2PBRVHsLVK5d1AOBzzeDn0QBu + B9wmuEPYsmXLvYkTJ0a++uqrXykS/O9uXPUn6z+U7P76RpaaC8YA0NJWCwCuAbRzfA4dCAIdnV4gm/+i + sPp8E8+urpTTEwzaOzxL79PeZruh+WNiNR++6ce0dSMQEDVUiF8In0TPtp/v8ccuwCO8D9xWdad0oC1c + V7SH93p7TKMDNiPrCAJp7xfnCt/1QzFtuzfmFhVhfiUwPfc2nKKyMXxKEDr16I/mjRqh2U8/om2zZujc + oRO6detBIOgt0oI+BkXCwZQSMATYDXBtYJhqFuHYcdp5A9qRAh4yNNe6AYKAhZW9tjZAqYGVhRWsJ9Pv + JlrCzN4T0TGxIteTAGD7z1N+ZaNgi1heVY1taQVILj4sen8pLAEBRXRqJ6CGgASBDgIk8roKg/x78T7V + Z9WEAgEKY8KXIb+PGgAy9FyACgJ6ToBCLx1QQKAGgDEIPKwT4JCpgCEEHnqIkMLQCch0oLYTqCkMshHg + 7xKcegzzNuchIaMUZ86e07mAW7duiXkByhoBok3IdjFr1qzyxo0b85Dgf3fjy3xJ5I0JAItJ+AcbmWvu + qsWvBUA9tLB9QqQAEgLtKTpQOtBhygvoyBBwYTfwIj33HJpTusBr4P1A0ZlSA5ulbcQtvaZSz8/CZ7G7 + r+ojBC+D0wERvNx3aHu4rewC3w0+mJ5agBmZB+EfHwK3kLZwXvQlPNeOxsy0PVhQfg2LDtzEvNIz8E3c + B/O5Eeg1bAJaNmtBacHPaN20Mdq3bovOnboqtYFftPMG+g3QuoGBgzFokHbykKgNiLkDozFypLo2MAHj + J9QMGU6ebA1zc4KAuTXMKPc3G28KCzM7TJoSANepQeJEqwHAs8L4klFp/8+cO4+M/H2U++9D7sFzKD11 + U09UEgJSgGrR1gkBCnU9QEKAp/+K99HnyNB91u90Av/WawcMIKB2AhIERp0Axf2cgC4VUIFAVxhUAUBC + QDoBDl1h0AgEdE5AAEAbDAEGAMe2/ZcQtKVU3IW5svq4DvY8GsAugC8X5o6A2wUH1wFWrlx5afjw4V4k + wf/e0mFc9W9mpfm4qaXGlHr/dAKAKu/XB0Bzm8fJBTyBVrZPURAIKNraU0rgJCHwAtrzZB+7J8TqQHyj + jCbWT2P0rO/hTRY/IGqYuFefZ3gv6uV7UPCdgXopwpcA4J/pdys7UxrQA97RjpT/R2LqtlXwijKDy7JG + cA1uDd+NAZQS5GFOXgWlBNsxK309grKSMSOjCu4bCzHGcz46du+LZuQGWlC0o5Sgs6gN9BS1ATFvQAGB + tkioqg0QCIYNG4URygSi0WO18wZkWjCR0oLJnBYQECaOGYuJo8fC3M4L5r6LsTQ4VJxcNQC4EiwLQ9wo + qo8ex870QuwuPoSiY1eFgNSikqlALSdAYegE1ABgF2BYGNQBQBUSALUg8LBOgEP1fTlqAcAIBGo5ARK9 + HgRI+NINGKYDOidAwQCoCwJ1OgEFAhz/zhuS8mxB3g7T91+85zAWbcnF3oJynDt/UZxrhv7NmzfFNQKc + +/MwoARAbGzsb1OmTNnx0Ucffa7I8T+/cdW/maWmV2MLzQoCwHEpfq78q8UvwroemtlwLeAJUQ9oJWoC + BAHq8dsTBBgELe2ehIlFPbEePjsAXiPAMbiLyPvZ+nuF9xRDfLzgphA59fa1IUBgWEnPh/WCZ+RoSgOs + 4bVmnLgFGN8bwGeDFwKTUzAzsxKBiTHwiZkMn+jRmLE7GIsqTmNRNRCQfgGWi7eh90grtGrRBi1MTNC6 + SVO0a9UKnTp2RFdKC3r27IPefVS1AXID6rkDPIGI3cCIUWMwimsDPItw3CSM5yFDTg9I+ONHjSYgWMFq + 6jI4zlgqin9qAHC+x8t637hxQwDgMuWHBfsqsD2jGJkVp1BGuT+LRvakalFJwelBQApXAYAhBCQI1ABQ + i15AgD5H3wlwPLwTEBAw+K4cv+faAXU6oHYBHGonIFOBWumAygmo0wHDmoAaBMaGCO977QCH4gRkKqAH + AcUJ8OQgBkFc8TnM2VqEmOQCHD15RpxvBgC7AJ7yzcVANQC2b9+OgICAI40aNepBUvzvXB/QwlzzI4l8 + hom5Zj/t77Dg1Q5AJ34FAAIC1o+JEYHm1k+QI3garSnfb0NOoJX90+IW33xLMI4OTi9h0rzGlOcPJPEP + od6fcnyy9Zzbu/LNPMnmu5Oo3ek5vs2XEL50AWFad+Cxit4T1oeA0Rauy5vBc814BOyMxsyMMlET8Il2 + gmtIc0ohemLarhDMKzmKBRVXML/iMmaX3ILH5gqMcl+ATj36oUn9+mj60w9o3awZOnTogK5ded4A1wa0 + aYF2yHCgcAMDeMhwME8gIjcwnNIC3ZChKcZQajB6+CiMHjoc48ZMgLXnbNgs3gSf2QvFCVYDgHM/Hg/m + RsCN4dSZs0jJLkYSOZfCo5f1RHM/JyDFJyGg7tHvVxiU4pd73XuVz9E9p3YCDwAAhzEISIjpACCdAIWx + dKBOJ6CCgHQCHP+OwqAaAoYpgdoJ1FUYlKmADgRKKsCRdZTS0cQqrNieh5KqI3oA4D0vHcbtQrYRdoeU + Btzp2bOn139+rQAPzWONbTVvkPUfTrn/Lurxb7Hg1aEnfoNoJuIJMczH6wFwfYDdAVf9eRlsXiGIb/Xt + Ef6L6Pl9V5OYV3Kv3w3uEcO1wXf1FXf2YRgYugEFApQGuK2knj+khbgLkFfUBEyNDxYQ8N0YSK/7RdQF + vNfbkitIRFDOQUoN9mJWRhzml2QSDC5gWtppWMzfhF7DzLRuoHFTtG7ektKCtujcoTO6daO0oHdfZciQ + QCCGDCUEuEg4HEN53gC7gZFjMYJHDQYPxUj63UQLF7isSILD8o1YvHx5LQDwUl/qRlB+4BB2pBcgrewY + 9f43SRwslJpek8NQWNIFcNRyAhwk+FpOQEkHeMhPG8pr1e+jzzEEgUwFHgYExiDAof5fOGQ6oHUCdRcG + 1QD4U1w7QKGGgAABiV66AUMncPDCbazKPIGFW/OxM2c/Ll26jBt03vncswPkVZ65DqBuI+wYJ06cGPP6 + 669zGvCfu49Ag8ma10j8ncn6LyTxHzYU/4MAwNGcnEALK3ICFFzx5+sE+Oo9XsKru/ub4g66AetGYFrU + IHitbEdCbQa3iMHw3DwTnlzQo97bhSy9uL0XuwGREhAg2A2IUAAQ1lVAgFMGj9UDCQKTKCbCPbw/va+L + SBMCEsIQlHUQM9JL4Ld1Dnyjx2DaFjvMyozDvH3nMKvwNtw3VWCM12J07TcMLQkALRs3QdsWLdGxfUd0 + YzfQSzuBSNQG+lNaIGsDJPZBBAGeRTiERw0oTRhGMXrUOFgHhMAroRoOc5fw7aLFiZUnl082r/bDJ58b + AdcBcovKxNzx/EPnqfe/LYRgCADDdOB+TkAnZhK9MSeg/T0Luua1usf0GYYQkE5AvIcdwQMg8G8tDJLw + 63ICagj83sKgoRN42GsHOB6qMKhAgP9OdOEFLNi2D2uSCnDi9Fk691oAcB2AZ37yepASABzsAry9vQu/ + +uqrtiTL/9CkIOr9Taw135JgfRpZarIorhor+j0ohAuwfAxNKecXPT+Jn6O90wvidt58n79p64bAL5J6 + 89A2lL93gscGV3inpMAj9yympJfCYctcuKweQuLmu/zyzTg4OpCwu2ohINICJcghiNuBEwhcVrSES3Az + AkR37VDhjvWYkZpPzmA9PNaMgltwY3jS3w/cGYK5pUewuPoOFpRfR0ByOawWR6H/BHu079QdLZs2Q+um + TdGhdWt07tRJO4GI3EBvhoBSG+g/kEDAECDRD+jXDwP69MXQIcMxwd4bntGFcE8ohOs0X3Ey1QBg+8+5 + nwTAGUoFdmcVYnd+FUqOXyFB1PSGhhDgUItKDQE9J0Ahe3ZjTkAnbF3Prnq9DP4c2uteKz5Tvv4hC4Oq + 7ypD/b/o0gEDCHDoOQEDCDAAZMhUQEJA7QQYAMYgUMsJKBCo5QRUIFBDQLqBWk5AgYDaCfBVgklV17A4 + 6SCWxedQGnBY5/4YABzsCNkZchvhGgDDICQk5GynTp0mkTLrun38v3drMEnzlomVZgj1/jsamWuukPh/ + UwPAmNjrCn49LwzCwufZfo3JDQwP/Bqeq/ohkG8BHtGTrH9bOFPP7rzeCl67ojEj5yhmlgLe+wGn/LNw + 3B4B57Vj4UwuwDm4uXYOgBgFYAhQWqDUA7RpAQGAr7sPaUnRip7rDa91VvDbOBN+mxeSM7AmkJDb4CHE + OH/M2JuKWbll5ASSEJS2HnNyUzAr7xA8t5TAdGoIegwYLSDQvEF9tG7WlNxAe3Tp0k03nVi6gX4DCAS/ + DEDf7t3Rt1t3DBttDsclCZiefRl2Icswe16QTvwcfGL5Jh/cACQAqg8fI/tfiPSyo9hP9l8KQIQQiT4A + DJ0AhxoCLEA9J6AAQLoBQwDI0P6s+h19Rl1OQKYCD0wHDL6njFpOgIRfkw7U4QQUENTlBGQqYMwJyFRA + gkDtBBgAMnQQqAMAMiQEdE5AAYAxJ8AbH98lKccwf3MeknLKcOmydiiQxX/nzh0xNZgLwxIA27Zt43UC + bg0bNmz2H39tAPX87bS38+7I1p+n+0rRGy363Se0NQCy/fQevhcgV/356r4enm/DfllHsv0jEBg1mKw/ + iX95U9itGQe7xFj4ZVUhMi2bess4xKcmY0nBBXjkX4BDUgIcYlzhtHoQpQXdhCMQowW8pxRA6wZqIKBN + FbqLGoNHxDB4RI6h9GAYiZ/f1x4+Mc6YvjcLQXlnMG3PDvjwSEJEf0zfOQMLy6ux+DAwM+caHEL3YKCZ + K9p17IoWJo3QqrEJ2rZshY7tOqBrl+66IcPe1Ov37klQ6NIV/Xr/AlPXueQmzmFadgUsplohIjJCnEwJ + AKa8tP8cXBAqKqvErsxi5B08gwqy/3xPPg41CNgVqAXDRUK1oNROgIWncwIsWlXIdEAKWidsBQDax+rn + KZTP0T2nhgCFoegNQzgBDtX3FQDgkACQToBCzwmQ6O/nBNQQMHQCajcgnQCHYTognQCHnhNQICBAoEBA + htoJ6BUGKWRhUEKARwNOEIRWZJ7BvPgSbEguwumz5wUAuA3cvn1bXAvCF4VJACQkJGDDhg33bG1tt7z/ + /vt/7EIh4kIfS80PTbR39Smlx6LqrwsStDqMCV8Gi7+pFV/go6348/qAHVxewYT5jcXMvmk82y+yN9xX + tIITWXqbuKlwyKzCYsrTC+K8cWPZzxQNUbphClZR3u5VeI9+fwBOCSvgEmUGN+rZ2eq7MgBo7xbGIwUk + +lUKCMIYBqqhQ+EMOhAAWsGDnvPbPBczMsoxI+sA/LbMF4VCt2UNMHXjFMwtKKKUAFhY9RtmE3y8t+/H + pDlr0X3QWFEg5OsKWjdrjg5t2qJL584Egq7owkOH5A56de+N4ZOd4Lx6L+YUX4drXCis3Mfy1E5xMiUA + eOon238mP598zv8yCkqxO68cpccvk/DviMZuFAJCKHVDgEO6AA41BHRiJvFzqAVd83vpBpTX6p6noM+p + BQIFAA/lBCgMvyuH7n9RQqYDWieg/O98PNQQoFADwLAwKJ0AhwSA4egAh0wFDGsCek6AwhgEpBOQqYAe + BBQnIFOBu/f4eWB94SUs2FmOVdvzUHVEOwGM2wC3Be4IeDhQDYDNmzfzcGBp/fr1mylS/WO2Zhaa+hRD + m1podlHvf1tt+zlY2A8LAI4mBABeHozzf14WfPSsHynv7kd5/zD4RfQRVX/n0M5wipoEl51RmJm+Hzu2 + R+Li0iaAlwbw1ODu7NdQtWYkNu5JxOzCW3DPvwqnpB2YssEbzpGj4EI9Pw8b8kiBuygUkhsQToDFz8Kn + x2KkoItwC64EAY/wAWT//RCwM1ZMIPJcawrX4BbwDO+HqQlLEZRVitm5BzEri0ScuxPzSsoQmH0K9qvS + yA14o2PXX9CmRVu0ptSgVZPGaN2EgGDyM9o3bYy+g8bAal4cgeUcgnLzYLlwEpy9rEXvrwYAF3v4ZEsA + HD91GsmU/6eXHkL56eu6Bi4BYAgBTgnUgjFMBwydAIcxCKiFrA61E9B/nsLws9RO4F+EgPz+6v/JWE1A + pgP/X07AAAKGTkANAbUTkACo7QT0awK6dECBgHQCtwkAnAnsqLiGpcmHsHRrLnLLqgkAWgfAbYHdANcB + 1ADgmD9//pnWrVsPIpn+cbcRI7s+nIQ+lcRfyeI3BgCtsB8MAH499/7alYEfF3fBdQzpgqDY8QiKGQW/ + cBLqijaYsmY0XLaFYXpaIWJI5IfWjMK96S8DzgSAKRQEgt+mP4sL1DvnbvJHRGY5fIvuwiG7Go7bVws3 + wCmBC+X1AgQred6AUhtgN8D1AWXUwI1dAL2WHYAn/R3PqMmUFgwR7/MI7w9/cgJiWnH6PgTsWE1pghn8 + 4iZgxt5wzNt3EnP3AX6JJ2E+Nwa/jLNF2/ad0Pinn2Dyz6/Q9Pt/iinFI+2mwXfHMSyouAi/bfNh6tkV + QXMCdSeSTyzn/7w8tDzpvK+sPoLEjELkVZ1E5dmb2oatNHTR6LnxKyEh8O8oDJYqoRa5TtjCBWhBIF+v + C/lZ9LgmFAhQGBO+DPl91N9Vhvp/0aUDhk6Ago9LXRBgABiDgKETkKmAoRPgkKmAIQTuVxhUOwEOQyfA + Q4R3KQ/IOnYToRmnsHBrARJz9+Pi5SuiHXDwtQE8MYyLxBIAvA8JCbnTp0+fKSTTP25aMOX9biT61RTn + JABkqAEgBK56bBj8O34P9/4czWyeQD/fD+G8ohvmbDClGINpET3gtYp65TgPeKYVYX7hdexI3o1zq7oC + U+vVAMCNwoPCV4M7s1/F0cgB2LlnKxYUXYFn/hU4CzfgRW5gBLmBnqKHd+MiXyjXBmRKoBopkKMFYZQ+ + EIBcljeA6/LG8Fo7AdN2bcTMjApMS9oGb4KD67L65Co6YOr2RZhTWIVFVZcoLmJm9mE4hidgqL0vOvUc + gOaNm6N1i1boO8IMdsE7MbvoKr0+Ay6RYzHesRNWha/UAwCfXC72yJN+7fo1FO6rRGJWCYoOn8OB87d1 + jVoHAWr0hgDg+D2FQSlAtXDFc3oirgkJADUEdL+j9xmmA7/bCRh8T47f6wQEAGSoIKB2AhIERp2AAoK6 + nIAuFVCBwPiMwdqjAzonoACAg4cD9529jdW557FoR6moA5w8d56EXwMAXg+SrxeRAGD3uHbtWgwdOnSx + MiHoj5kPQKLltf3DG1lqzqjFL0PnBhSRG4YeBPg9igMwsayHTq6vYsLcRuIa/8B1QxC4pi/81wyE39YZ + ovA3twSIzqrA/lh73J7/jhA8pwBwV0KBAGY+gxtLv0H5BlesydgPv+JfMYUEOWVbOJyjzAUEXCgVECAQ + tQE5UqBfJBT1AwZAcGPK/1sSAEzhn7Ccev51lB74iHUGXMl1eK2dhMDduxCUU4WgzETMTF1JqQqBIrsU + PjvLyA1EY8BEdwyY4AbzObEISDmGOQX7qPefDutFnTHZqR9XcfUAwFVenv3HJ5tP+qUrV5BVWIY9uWXY + d+IyNeY7ukYsG7chBNQgqOUEVILiuJ8TkFEXBDgkALSP1c/r/yyeU0OAwpjw1SGcAIfq+3IYLQwaQOCB + hUESvnQDhumAzglQSCcgAaCGQJ1OQIEAx++5ISnXAg7Qd19beBHLkiqxelc+Dp84jdsqAHA9iNeHkGkj + B9cBTE1NY999991PSap/TBpgYq7pT7bdmYS7V4791xXGQKAGgISAvDtQU3IBXVz/LoYArRc1J5veBVPX + Dsb0ze6YnrwFM7KphyVbv2HPThTFueF8aAvK/98gz62IXzoBhgI/N5fcQNQYJOxNwYJierrgGhx3J8GR + 3MCUiKEEgm7aKwZ5FqFIDQxGCkR6wKMJPJzYGZ6UCnivt4H3OksxcsAuwjNiOAK2h5PYDyEwNR8+cb7w + jOxHqcIUzKUeftGhu5iefR1TIovhEF4I/z0XMaf4DKYlhtDf74dJgU1h4zJWTACSJ5KpzlVeXhpKAuDc + hYtIzStGalEV5f/XUE2NWQcAGUpDV6cDEgByiNCwMFjLCSiC04MAiVamATLUghaiJiHXhBEI0OfoOwEO + BQIP4wQo1N9ThhoCAgQkfMN0QDoBHQQodABQQu0EZCpgmA6onYA6HTCsCahBINMB/WnDNUOEMhVQ1wS4 + FsB/O6bkMlakHELI9lyUHjymAwCPBHAdgK8QVQOAXaOdnV26cjvxP2ZCUENe689K05QE7skQoP11tegN + wxAChgBoqrxO1AIoGpETaG7zFLq5vY7RM7+FUzDZ66jhmL7RDtO2zcW05O2YmVONZbnHkUCPK9ab4ebC + jwF/RfwMAXYD3hTTKOa/gsvh3VC4LRhrco7Ct/g32GafgJ1wA5PhQpBx4fkADAF2A3xNgQ4EnA5IGPBj + vuS4vxYK5Az4Z98N3gjck4gZmWXw374W7quHgq8r8Ik1R1BGAhaUn8G8sjsIyruNmXm/Yc6+3zAzMx0e + 9LftF5pgvFcjuPnY651IBgBXefkkMwBu0Uk/eeoskrMLkbnvECrPXMchg0YsAaCDADd8JXQQ4FCJhcNo + KsChEp+u91ceSygYi/s6AYP3GaYDasEbC2MQMEwH6nICtSCgHDP1MTSsCXD8pwuD0gWcunoPcWVXsTLt + GJYm5CGj9KAQvwQAtwu+Hby63fCwsbe3d+Vnn33WjqT6x10YxPf5a2KlaU4AcCLhbiYBV9TlBgQAZBgD + AIfye64F8HwAHhJkV9CWbxbq9yHM5v0I5+XN4Lu6D6Zt8YJP6k64553GtMIbiMwoRu7mQJwnEd+b9YoW + BJwGcARQzKCY+zfcC2mAExsckZiahkVFv8Iz7zKckrbDfoMvHCNGipECMV9AuAHtJCCt6JWRAukIVnWF + Wyhfd9AOHhFD4LPBE/7bQilWwDvaXsDDY/UA+G+dj8C9qQhMzyZnkEyiT8OsnHzMSNsNn42BcF7RE7YL + G2KMWxMEBvnpnUg5AUiIX3EAh4+ewO6sIuRWHMOBczdxiBusEnoQ4FAauhoEaggYOoH9FIbCki6AQwCA + Q4pXeWzMCXAYOgG9oPcagkCmAg+dDhh8Vw75vxhCQO0EOORxkbA0BIDaCch0QM8JcKggoHYCHHrpgAoE + Dz1ESMEAOHPtHjbtv47wzJNYnFCApLxy6hC0BWFuEwwBXh9A1gA4OHUMDAw81aBBg/4k0z92RiDl7S+S + aL8gAPSm/VSREmhnBNaCgDrUbkAfCPR7dgAEgQYEAZ4QJEYHrB9HhynPY7DfO7Be8BO8I3rCf6MNPHct + hzuJy6/gMhbnX8CW3QmoiJqA60u+AmY/A0wn4XMwAIIeAxa8BgR/hztr+uNI/AxsYWEW3oZj3iXY79qC + KesdxLwBngHoSuLmKcfi+gE5UqAUBsU8AukSKA3wXDMSnmvHwyOSL0yi50M7Uu/vgsCUVEzPqILfzlh4 + xU6Bd4wpfGMtxDUIbmGDMCW4I+wozRnj3AZz58+uBQBeAkqSnk96VfURJGUVo+DgabL/t3WNVQ0ADkMI + GHUBFIY1AdmTSkEZcwJS9EL4ys/6Qq4JrRPg0Apf9zy9zxAC0gmI97AjeIAbeKSuHVAgwADQFQZVAJAQ + kE6Ag53AGXrf5vIbiMg5jUXbihCfWYorV7XrAnCb4BmB3Ea4rch2wzCYN2/elbZt2/KU4L9plfoHb8pd + f5uyGyDxxtK+nIR+2VD4taIWALQhLwgSICAI/ETBC4PwGgG81r/prK/gEtwcflGD4RfvB6/UbdSbH0cA + gWBVehEyEpbi5NoRuLP8B2DeCyR+AsAsijlPEQReBha/BaxsiHNxtkhNScTKgivwKgRs9xbCPi4ITuQG + nMkNiAKhcpWhOw8byuFC4QokEHqSU+gqhgh5joBrcGMBAb+N0zA9NQ/TUgvgvXE6XFZ0gPOSH+CyrClF + a3Iz7TBlOQFgQXuMm9IVy4OX6U4ih5wBKAHAQ4D7Kw9hd04pio+cI/t/hxrnr3oQqAUCpYGrIWAIA0MI + cKhFpYaAHggoZCqgA4KRMEwHDJ2A3mslAJRQ/y3DkN/HaGFQ9b/UlQ5w6DkBPl6qY6c7rgoA1BBQOwEG + gDEI1HICigsQIFAgIEBAYQwC7AT4vVsIAGvzzhEASrEhpQjnL14S6aAEALcRzvtlu+FOJCQk5HaPHj1c + SJovaxX6H9haTtL8jSz7ZwSC7iReniG4m6LWMKFh1HYBCgQ46Pc8RZgnCLEjkG6gE7kBvtuP3aJG8Ino + A/8Nk+CzLQgeqZT/UFowl9KC6Mz9KEpYjKvh3YFF7xIInqUgV7DgJfr5dWDZ+8AqE9xYNwRHt83ENkoj + phX+Btucc7DdtZXcgBOlBL3hQgBwDWkjhgtFj8+XIQtHoICA04ZQ7doEbisYFm0EFLyjHeCfsAK+W5eQ + MxgP52XNMGVJfdo3J/G3od6/PUVn2MzviPFOvREeHo74+HjdieThHR7mkQDgIcDisiok55Vh3/ELYuUY + bpSyl5IQ0AOADCMQkCL4vdcO6AmRRCtC9VgtaCFqErIM7c+q39H76nICAgIP4QQEBAy+K0ctJ0DCr0kH + 6nACHKrjx8HHVR5jmQroQcBIYdDQCXBPzhBQg8DYEKFMBSQItAC4jqiC81iyowzrkgpx+twFHQDu3r0r + 1gnki8dku+FYv379rwMGDJhBsvwPrw1A23e2mudFbcBcY0dAiGhkqcmjEIuD1hV1QUA7TVg7V0AUCAkA + HJwm8HqCfAsx01lfw2lZI/hGdEfAZjt4J8fAJf8kvIp/Q0jOCaTuXIcT0Za4E9YKWP4psPQfFOQAltF+ + +YdAKKULkc1xZaMZMlMSsLToMjyLAMe9BXCImwXHiDFwprSA1xkQowQcYs2BGgegvdRYSQ0EHHqLdQo8 + 104k8Y+Da1gfOIe0I5i0pehEuX9nTFnRBVNCusJqbgeYOmiHAPmabnkS5RAgU55P9hWe+llSjpT8/dh/ + 4pJokEeoAcreSddjGTRgCYD7QoDC8NoBowDgMBCgED3tdaEI2TAMnYD6sVEnoIKA3t8zEsYgICGmA4B0 + AhSG6cD9nACHhIA81jIV0AMBiV66gfumA0acgP7ogDZqAHADUUUXsHRXOSIT83H81FldCsAA4Gni3FnI + dsOdSFxc3L1hw4Ytef75599UZPmf3USB0FzzCQm1LQnXgQQcT3FKCt5YSAioQ14oxBAQboCEz1cMcmrQ + yIKeJzfQ0VlbG7BZ8BN8VnfD1LjJ8N4+B64pe+BDAJhP+X0MpQUl2xbhetQwIKwRsOJzIPgDineAkPfo + uc8IAg1xJ6YfDu+YibisfZhGEHDKOQOHnfGYEuMB1/CBlBJ0JCvPcwd48hDXBtgRsPDZDXCBUBYKtY/5 + PgVuBAfXUJ6B2FWJbnCmnzmmhHSD+ax2mOgwQIzfSgDwSeRrAPimHxIAly5dQU5RmVgnruLklRoAcKid + ADdYJfQgwKFq7EYhIISiDwJDYbHYZOhESKKVIKjLCQhhK05AlwLonmfRa0P/PTUQ+FedgPp/4ZDpgNYJ + KP87Hw/luEhYqgFQa1EROubSDegAwKEAQDoBmQoYpgN6ToBClw6oAMAu4DQXAQkA64q0cwHCd+Th8PHT + egDgNsJtRQKA29CmTZvujR07Nuy/ft9AXiiU1wtobKWZTDAIpyiiHvw823pjENAFCd5YfUCAwVLrCNgJ + 8GgBjxTwUmK9PN/CmJlfwmmpibh0OCDOBt6JkXDPqoAP5fjBuceQtnsLTm32xO2oX8j+N6De/2OCAaUH + oQwBTgko1jbE6a2WSE2LR3jheUwr+BUuqfvguGU5nKIsyA30E8OG4lJhMZPQyApEwhnwRUUECerp3RgA + oT1I9BQrugvhc+8/JbgLJs9si8mOQ0TupgYAL/zIF39IAFy8dBlZhaVIK6pE1amrugZoCIGHcQIcdToB + A8HInlQK6r5OgEP92Eg80AlwyOcMnMC/AgFDJ8BhrCYg04GHcQICAnS8ZTqgcwK/pzBoBAAcahfAnxm3 + /wbWF19G8J4DWLk9F9XHTukVAXlxGL5jkBoAGzduvDd+/PhIAsC7ihT/e1snc83TlAJ8SEJtT+FGvfhW + AsCpB0KAQxE9i1/PDVDIlIBrAwyBJlaPo43DM/jF601Yzv0ePmEdMDV6DLwTpsNj70545Z3CrIKbiM6q + RMnOMFyPNaVevyWJ/msS/0cUlBaEvQ6EU2qw9p+4E9cJJ3a4IjkzGQsLb8Ip7yZs9+TAKS4QzuGDycqT + pV/RVrgB7VqEbP+VtIAhIIYUtRAQDoDE77JCHwBOBIBJ09vCwmmUqN6qUwC+GSTPAZAA4OJPZkEpMoqr + cOA0AUCxojoQ0M/GIFDLCSgNXLgADm78StQFAQ61qNQQMHQCMhV4kBPQ9u6K8NXB76e97rXiZ/n6hywM + qr6rDPX/oksHDJ0AhXRIxiCgO64U8njL4692AjIVMISAoROQEKjlBBQQ8LnbUKYFQEjyQXHDkKqjJ/UA + wCsGc2dhCICJEyeuf+aZZ95TZPjf31qO0DxDQq1PMYnEH9bQUpNHcd/aAIehC1AHpwVcD5Ag4ElEfD1B + d9fXMWb6Z3Bc8jN8wrsgcJMDfPeswxQSv1feRYRmVyNtTzxOJEzDnQ3DSfDNgAhyA6v+TvEqQeBlYPVL + QNS7uLWpC0qSF2NV4Rn4lwCu6QfgsCUUDmusyQ0MgCuJn9cNEPMCeKRAQEBxAyIF4NWLu5P4u5P4yfpT + CPGHdIFjcGeYTm0NG5fxtQDAqwDpAeDCRWTmlyKz9AAOnrlGALir630EAGTQ83U5AdmgJQgEBKjRGwKA + 418qDJJgdcJX/awWtBA1CVmG9mfV7+h9Mmqe+51OwOB7cvxeJyBBKUEgj6EI5Rg/yAnIVECCQO0EZCqg + 5wYMAMB/a0PZdQEAMRtwWx4qDh+vBQCeMaoGwIYNG34zNzePJQC8r8jvz7FROvBs40maD0iwrbk2QACI + JyCcNiZ8GSzyB0GA3QDXBQQIKEwsH0MruyfR1/M1mM/7Dt7hXTEtdjy84/3gkhQNn4z9mJ1/GWtyjiA3 + ORqXtlgC61uRIyAIhBMAVj1NbuAxgsDjBIcXcW/DVzi9YxhS0sKxuOAUXPJ+he3uXDhtCIJbxAgSOC9D + 1pp6egIB1wXEECG7AF6LgK85qBG/IQDG+7WGrcuEWgDIzs4WQ38SABcUAGQpADh2+a5oZLUgoHMCdRcG + OWTjNoSAGgS/d1ERXbBwaS8gwHtFyIbxwHRA/ZwaAhR6f89ICCfAofq+AgAcagAYgcDDLirCoXYCehCg + kE6AwzAdkE6AQ88JqCDAx4EBEF1yGaF7fx8AzMzMYl566aWPFOn9uTa+fyDXBhpybcBSE0opAq8nyPcS + EEuKGYbI/Q2ErxfK6xgE7AR43gDPJOQbkHT34OnEX8JpWWP4hneCf8x4+OwKgWvWPngUXMeivPNITEvB + sR3kBuL6kuC/Igg8SxDQEACUiKSIegzXNn2N4t2uWJtbAv9iwDHjNBzi18IpygZTqLd3WaFdi5CvDNSm + BDxHQAEAF/5UAOCQALBznVQLALwOAJ9oYwCoZgAovYxsdHoQ4BAQUNwAN1iDBlzLCXBQ41cDQEBACKVu + CHBI623UDageqwUtRE1CrgnjEKgFAgUA/2pNgONRuHaAHUDqkVuIoxSArwdgAIQKAJx4YArAAJg0aVI0 + AeBDRXJ/vk1VG2hG+4mcFtD+kKH4ZTwQAlZatyBqAwQBWRtoav2EuP9gf++3YDb7G7iHtIbfuuHw2eoH + 96TN8Mg8hBn517FWuIF1uBhvCkR/Dax5htICBQDhyn6NBnejX8OZ+A5ITg/HgsKLcM77DfYpJXDctADO + q4dpC4NidWJefbg7pQiU+0sAKBCQAOAagKlfG9i71QYA3wTUEABZBQSAkiocPH1VB4AHQYBTgrqcgASA + DgLc8JVQQ+ChFxWh0BMhi5b2f5gT+BchYJgO1OUEakFAHjPl+KkhUKcT4HNEwjdWEzCEgNoJ8IjAzoM3 + sXG/BEA1VoqVgfRrADwKYKwIOHHixLV/iiLgw2ycFvAVhpTPLyQRZ5HgecjQuBvgIMEbA4LhkKFICxgE + tOc7EHVxeQXDAz6CzcIf4cVFQr4T0I5guKTlwyv3Epbknsbu9F04luiFW1s6EAj+ru392Q2EKXuGAYHg + 5saPUJrkiHU5WZiXfxrTMsros6LgHu0K17CB5AY6U0rAwQXA2ikAjwA4Lu+C8b6tHg4AFy8ip2gfMosr + BQBEz2IEArIX0k8HagBg6AZ0jVpp6HWB4EGFQQ6ZDhg6AR0E6LExJyCELVxAjRPQC+X9+u9RIEChFrxh + yO9j+F051P+LGgJqJ8Ahj4uEpSEAjEGAQ88JqCCgdgIcMhUQEFBAcPbGr2IasA4AKdUIIwAcNBgF4KtF + DYcBlVGAsOeee+5tRWJ/+q0e9dZvEgAakHgn0n5tYzNNNRf4jAFA9zOLXRG9BICEAAe/hl0A1wY4eO4A + 33ykt+drmBj0lVjfz3/dSPhs8oR74np4Z1ZgLtcG8o4gK20tzm4bhN9i3q4NASUtuLv+JZzbYoL8JFfE + 5qRiXsEF+KQUwTXGn0TfE64h7QkEXZSenyGgBcGUFdz7UwrAAPDhFGCi0RRAXQO4SKTPLS5DRnG5FgCX + 7+oBQA0BCQLDdEA21gemA9ToDQHA8e8qDOoLWRsSAFpRa4Wv+x29zzAd+L1O4N967QCH6vhxSAhIEPDx + l+fCWDrwICdwiD6DhwB5HkBMySUCwEExD6D6xJlaDoDvG2EIgFGjRi0lXf13JgL9/2zsBpqZa4aReBdR + WsA3GT1KIBA3GhW9vxS/Koy5AXWItIAAUF9ZcZgnEHV2fglD/D6A9fyfyA10xNTYCdSDL4N7egE8c85j + Xu4JJKTvRGXiFFze1AC/rXta2/tLEIQqQTC4uLkhdmetx+JSwCf7HFw2ztcCILi1MvNPDv1pw4kBwDUA + AoCpbxtYO4/TAwDPA+BRADUALlOul19ajvSi/Thw6jJOKACQcV8IKD2TIQRqgUBp3IYQUIPgQU5Alw4Y + CJBD7QSkkA3DWDqgdgPyd+J5NQQoDP+eOnROgEP1fTnU/0td6QCHnhPg46U+fqpjK4+3hIDOCVAwAIxB + QO0EuBCYe+KOEL8EwIrkSkTsysfRkzUzAblt8ExAnjWqBkBsbOy9wYMHzyY5vaZV1aO11WsyWfMPEnpj + pTYQQm5gH0OgLgDIMAYBrSOoKRDK4UL+uaXNE+jl/qq4uMg9tB0CokfAZ7MH3HeEw2NvIQJzr2JF/lkk + pkfhxLYuwPpntL0/AyCEIpgB8Dj9ris2Zu/EzLxzcE/aA+coezgHU++/vCU5AAkAtv2dxNoGHI7Lab+s + IyZMbQ3LKaPFFV1qB8CVXfUw4NVr11C0rwKpBWWoOnmRRH9XNKL7AUAPAhzUOGUvJSGgBwAZEgIc1PDV + ADC2qIhRJ6AITk+IJFrDUAtaiJqEXBP6ohc/0+foOwEOBQIP4QQEBAy+K8f9C4P6TkAHAQr18ePg4yqP + MR97GToIKOdJnQ4YOgF2AbsO3BIpgABA8UWE7C7H2qR8nDytXSFaAoCvF1FfC8BtaPXq1Xf79evnTVp6 + RSupR3TjImFTS02fphaamXzfQYpDTcw1N4yJX4Z0A2pXICDAv1Neo4YBL0TayfllDJ/2KewW/wyvla3F + bcj84mfDLSULrrk3Mb3wFmKzElG5awLl/p8Ca0n4K7VxJ+YfyE2ZhkU5B+CWnAnnGA9Mod7feXkruAS3 + EQDg6b9TQrqQ4NvBcWkTOCxuAIclJnBc0hITp7bAZMdhYiag+mIgXuqJK7wSALwibGl5FVJzS1F54jw1 + Jjr5KgCoISCjFgSUnolD9lZGIaA0bkMnoIOAEmrBGE0FOAwEKERPe+EEeK8I2TCMOQH5WA0A8ZzaCTwA + ABzGIGCYDuicAIWxdKBOJ0AhIaA+3vJc6CDA504Jw3TgGL0+vvKGuA6AIRBTdAHBiWWISSnEmXMXdQDg + qcB8u3D11YDchpYtW3azR48e9iShF7RKelQ35cajza00P3FaQOJfQE4gh8Bw01D4tcIQACIYENrfi0uN + FQiYmNdDK9unyA28Qm7gc7iFtIL/mgHw2eAAtx2r4ZZeCb/8X7E8/wRS9i7FmfjW5AaeEnF6ey/EZqfB + M+s0bLeshFNYH0xZ3lyI3zWErx3g2491Flf+OS3vRABoBfvFjWC3pCEcFjXF5GlNMMGhP1/AoTuJHJzX + 8ZpvEgA3btxExcFqpOaUoPzYORy/dFvXg6hBUBcAdBDgoAamcwLcYJXQgwCH0tDVIFADwNAJcBgKSzoB + PRBI8SqPjTkBDkMnIEEgIWAIApkKPAwIjEGAQ/2/cMh0QOsEav53eVwkLNUAqHXtAB3vWk6Ag8+b6hzK + VID/vy0VBACKzfuvI7rgPJbvLMXm9BJcuHRZzwEcOHBAbz0A7kjmzJlzqWPHjqakoD9uZeD/9NbGQvNm + UzNNZ4KANwl4O0HgMO3vGCsUypAAMAyGQFNlzQGuDXBdgNcd4NuVd3J5CUMCPoTlvO/gHtIC/uuGY2rC + PHikFcMl9w7m5JzC9rR1OLjHDod3WyElPQLzc47CISkLNmvtyN63ESsXuYbwzUV4qbF2wg3wtf/OK4di + CqUH9tHusI0YD/ulHWE27WeMte2MqKgo3UlkivMVXnyppwQAXwJ6iGifmluM0kOn6gRAXRCQIDCEwH2d + AIfSwOtyAoYAMEwHjDoBauCGENAXck3U6QTofYYQkE5AvIcdwQMg8O8oDD6ME1BDQJ4LnROgUNcE2AHs + rr6pAsA1rMs7g+Xbi7Ejax+uXNPeI4LbhFwRiFcBUgNg+vTpZ5o1a9aPZPO0Vj3/I5uJteZVcTNS7f0I + F5LISxtZaH41FL4MtvzGAMDBroABwdckiKsLyQnwnmcRNrd9El1dXsTowI8xZVlzcgOD4L/JDe47ouCd + kod5JPhVxecQUXIai/JPwTs5C04xAXAK7U25P68gTL0/WX9X6vmdl7eAE9l9pxU94RIbAI89GeQWquGy + OxEOUc4wm9sWI23bISwsTHcSOXhBELZ3cj0ABsBxyvfSCACFVcdw/OIt0WDUEKgLBIYQECCgBqkNfQjU + AoHSwIUL4ODGr0RdEOBQi0oNgVpOgPYP4wS0PTs/Ngh+P+11r6Wfa17/kIVB1XeVof5fdOmAAQQ49JwA + Hy/VsdMdVwp5vOXxVzsBdSrAn7WVhM8hARCVewLLt+WLK0H5NuESABwFBQWigCzbDT/28PCo+Oabb1qT + ZP64NQH/mxsPGZqYazqRyKc1NtNkEAwu0eOHmjdg6ApkfYBfywBgNyDXI2zvxOsRvgezOd+SG2iFgKhh + CNgaCL+UVHjl34RnMeCeeRxumxfAdVU/uArb314RP+X+5AKclzaFE+X9jhGmJPokTCu8iyVFd8k1HIf7 + nlRMipqGYVN6Y/GSRXonkm3dwYMHawBAcfbcOWTmFyO//BCOXbihyx3VIDAGAGMQqHECSiogQ9WABQBk + KA3dGAD+5UVFSLC6UP2sFrQQNQlZhvZn1e/ofXU5AZkKPDAdMPieMmo5ARJ+TTqg7wQkKCUI1MeQj+vD + OIFT1PtnHrsl8v94BQKb9l/FmqxjWLEtF7n7q3GTUkEJAB4l4inj6nbDbsDGxibtgw8++IGk8oRWMf+D + G9+fsLG55kcSrymlBluaWGjOEQiMQqBWkOglCBgAOggoKQFPHuIwsaiHFrZPoIvzCxhJaYHzsqYEgYGY + utEVnjvWwXNPOu2j4bHOAmIh0WBeWVjb87vwij/LW1Pe3xKOob3gtGkuPEj0y/PPI3HPNiQlrseyrHI4 + ZhzG8CB/zJobpJfL8Yncv3+/Tvx80i9R/pdbVIqcfVU4cu6aUQAYQkANAqMQUHqmf/XaAR0EKP7oawfU + oQcBDoP36UGAQu/vGQnhBDhU31cAgEMCQDoBCj0noByXupwAhzy2aieghgCfJ/799qobSFAAwLFp3xWs + TqtG+M5clB08JtqBBIC8FFgNAE4fJ02atPWNN974mGTyx90e7M+ysRtoZqYZROLdSDb+Ign8d0NAHbze + AMFEOABeb4AdAYOhncNz6O/7Dszm/SDuVTht3UhM3+SMwLgp8F0zhJ7jnJ+vCuT1ATtRz98cDkuawn5F + dzjEeMEtJRMLso9gz44wnA7vgcuhLVC02R8rsw9icmQKfIOCRP4mTySf1MLCQkF5CYCrV/nOQPuRWViG + 6tOXcOrKHdFrPAgExgDAoe8E/qDCoEpQMqT1NuoGVI/VgtYJW3ECuhRA9zyLXhuGr39oJ0Bh+F05dP+L + EjId0DoB5X/n48HiV4UaABwscHmM+djLYABw5T/z6G3R6wsAUGytuI5NJZewMrkCUUn5OKbMAZAAOH36 + tN6dgTiio6MxcuTIpX/onYH+bFtzK83bvOiIiYUmW96slEVbS/QGUWdKQMG/5ysLeZRAuAF63MT6MXR2 + fhFjZmhHCqat7Y8Z64dj6tqB8OWbmPJaACt7khvoiCk83Le0BewiLeC4Oxmzc05g945VOB/cBAh4CvB7 + DL/OexcHoydj3tpYuAct4hlcegBge8eUlwDgJaHLKg8gPa8YlcfPEgBu6yrHD3ICEgJ1OgEO0TtpG6oM + dQOWAJBRlxN46GsHVOITwaKl/YOcgEwFaj+vAED13t+dDlCoxc8hv7/6fzJWE5DpgKET4DCEgKETYGju + VHp/GVsrrmFD0Tms2FWKLWnFOH/xsugQJAD4tnHqewNyhIaG3u3du7cjyeJ/YwTgl180j7e00bzOS4w1 + tdJ8Qz3zd2z9Tcw0DUmkLej51iT2bo0sNS4UqdR7X2fxs2A51II3FhICxmDAowVi2JA+j2EgagPkENo7 + vYDBUz+GxYJG4qKfqWsGam9jTnsvvgyYnnMObocpq4bBKSES3nmXEJuWi7NhXQAfDeBIwfc05BuXzHoe + BQs6YGqAr96twfik8lVe6luDcVQfOSoAsK/6BE5cuqmbPKJ2AXWB4IEQUBqlcAEyuNGqGrAaAsIFcHDj + V0JC4D9RGJQgULsBYxDQhgIBCrXgDUN+H/V3laH+X3TpgKEToJAOSR4nQwAYQoDPTdrh20L025QQACi/ + iuj801ixvQCpBeViXUgJAN7LEQAJAHaQc+fOPdu8efMBJJ3/iQJgveY2mveakcBJ6DYk6KmNzDVBtF9A + vX0YQWAL7XfRz0lk//Pp51P08x0e3uOCnnb+f23RG4u6ICBAQL/nz9PNGxDrET6BjlNexIjpX8IppCP8 + IgfBf+0g+KzqAU++nwDfPWhjIDzTSzC78CaSd8Xg1sJvABcSvYMCAL57ka8GV30fxwrnnoiMWK0DAJ9Y + nuJ54sQJUQiUADh58jSyuBC4vxrHLlyn3v+uAIChE1BDwBgA6oQAhxEI6AFAhtLQjQGA4/+3MCghoC9k + bUgAqCGg+x29zzAd+N1OwOB7cvxeJ6ADAIdy/NQg0ELgrvgfEypuYluVEgoAtnABMPMoVm3PRVHlIVy7 + XnN7cL5lPDtENQA43N3dS7799lsT0s4fc1uw/9jmoXmMrT31+t2bWmjmkKgTSeTFjc00FbQ/3NBCc4GF + zuKlnl8nUFHFn6TBjxNrQuTxnNuTmA2Fr477Q4Deq4CF/w67AZ470NruaQzw+wiWS1qJ6/+9w7rBN7w7 + /KLGwDdhIfwySjC34Cq2pqTjSMQY/DrjJe19C/n2Za5aCNyhx3EWXyA8eIEeAHgokCd6SADwyefJQQUl + ZcgqKsfhM5e1ALheM43UGADUEDCEgVEI6JzAv2FREZVYRKgExaF2AoYiVDsBKWTDkADQPlY/r/+zeE4N + AQrDv2cYwglwqL4vh9HCoAEEOPScAB8v9fFTAMCF0z2HbmI7CZ9DQiCB8v/NpZewKqUSUYn5OHz8lJga + LgHAzpBni6oBwOsAWFpaxr/yyiu8FNijXQAkcb1Gdr4L9fyzm5hpCkl8l6mHv03C/5V7dQ7R01NwTy/F + /5MU/wQNfpAQ4IuA6PcsXh73NyZ+GXUBQARDhF6j+7v0mfx3m1g/ji5ur2PkjG9hSyDwCusO/zVD4B/n + DP/EdZieVYnFeecQSxAojbbGzUUfAgFPalMAvpchQWDPxNcQHOSuBwAeFSguLhYnndMA3l+9egVlFQeQ + lluCiqNncfrqHZxlACgQeBgnUBcA9CDAoTgB4Qao0RpCoJYT4KAGrQbAX9cOqCBAYXj8so7fxo4DN0VI + CHCwA4grOovQxFJs5fz/wkU9APANQfgaADUA1qxZ8+vw4cNnknxe1KroEd047yeBfUdC86HIJmFeZ9Gx + 4FjILHIOfswC5JAX+Gh7+sfQ0vYZdJryKrq6vo7W9s/S6+vhe4ICv7YZCba5zRO1xC9D7QTqhIGV9u+J + qwzpM3+mfUv7p9HP531MnNMAU5a3g0/EQEzd4Aj/7aHwTs+HX+5ZBGdUIH3bcpyJ6I2789/W3rvQS4PC + Sc9gmcdY3cnkE8vBNo8v+WQXwCefVwo+fOQY0nIKUVx1DCcu3hRXkAkAqCCgHh2oywlICBjCwBAChpOF + DBuxbNyGTkAHAQ6VWDiMpgIcBgIUoqe9LhQhG8Z9nYDB+wzTAb2/ZySMQcAwHdA5AQpj6YChEzhy+S4K + Tt0Wi35sNwqA64jOOymWAcsoqsTVK1d0AOA9DxFzB6EGwPz588936tRpNEnoj70n4B+81fuJrD/P9iNR + 72hsrrnGouQel8XLvfm347UhJ+ywSFvbP4POrq+ip8eb6Ov9LuXm32Dy/KaYOK8Renu/QyJ9HF+N49c+ + ge7ub6IbRUu7Zx7oCDgMISDnDvDzMi2QMOLViTtOeRlDAz6DzaKm8FzZFT48TBjnDldegSj3DIJK7iIm + oxClsU64yvcxnPY4Dts+hmDzVnri5+DFHrgOIB0AB08Iyi4sQV5pFY6eu6pcRsqXk2oBIEPtAuoCQV0A + qJ0O1ADA0A3IRi0hoAaBGgKGToDDUFjSCeiBQIpXeWzMCXAYOgG9oPcagkCmAg+dDhh8Vw71/8Ih0wGt + E6j53+Vx4WPEx5Jht4vEv1MRvzoYAPH7ryAyvVrk//sPHiXwX9UBgC8S445BDQAeDXBxccmn/L85aejR + zf954VDqVVtTXj/PxFxzhHtZFjlHYwsSnvWTaGP/Irq4vIleXu+in+8HGOj/CUbM+CeJ3QRWi1rCdinf + 2LMnPMP7wXJxK/TwfJsEWo8EWg+9Pd8RUBhPvXQ/34/QwfkVtLB9yqjwZcjZhGoIqINfIwHFaQgDoRXB + pZfnG2I6sfW8b8XaAN7rJsN9VxQcco/DrRQIyTmG9PhFOBXWFacC3saaSZ8hYtVKnbXj4BNbUVGhO/mi + AVAaULK/QqwReODEOUoD7uogYOgE1OmAMQDUBQFjTkAHAQUEtZwAx30AwGEIAMN0wKgTILHqhK/8rC/k + mtA6AQ6t8HXP0/sMISCdgHgPO4IHuIF/x7UDfNz4fUnVWvELCCihAwDZ/82lFxCWtA9xyYU4eeascH6y + DfA1IlwgVgNg69atv/FS4JT/80rAj+74/89Wmo9JQC4k/BwS1R05Fs9Dem3snsUAEu3k+U3gGMIr7XSH + 88ruYvEN91V94b2aLPfaYQiMGomAqOFiJZ6hgV+juS2nABp0cHwRE+c2gnt4H4q+sF7SlsDxLbq5sRt4 + upbwZQgAcBgRvwz1DU05+DszFNrYPYk+Hq9h4swv4Lq8DbzWjIbr5ulwSN4N97zzmFtwDbGp2chZ54qN + U37GgmkuovgnAcDBE4J4PgCffNEIKA4dOYqMvCKUHjyGk5dv4ew17WIShhAwdAJqCNQFAqMQMHQCCgRq + gYAauSEEDGFgCAEOtajUENADAYVMBXRAMBKG6YChE9B7rQSAEuq/ZRjy+/yri4owIPn/Sj5MwlfErw4J + gG0V1xGTfxIrd+SLe0FevnxJDwDcIXAnoQbAqlWr7vTr149vCMqXAD+SAKjX0lLzMlnqbiSgWBLTJRYU + W2u2+k0sHxO9t83i1vBfMxjT149C4PqRmLpuGPyjhmEqCZ5n5wXFjMPsWFNRhDNb0ASdqIf/jtKFHyj/ + 7+nxFrmDtvBfO5heOxw+kQNgt6w9Rs38lj77bbR3fB4tbJ6sGwAcRsSvDnm5MQOARyN438ya71XwGkYG + fEJu4Ce4BbeHR9REuCYEwzl9H7wKbmBx1hGsWhGE2V4WYlEHeXI5eHEQpr4aAGfOnkUupwH7KnD47BWc + IRfAC0nIVEAHAiNOQA2CBwFADwIcJHyGgDol0AOADCMQkAD4l68d4CDRilA9VgtaiJqELEP7s+p39L66 + nICAwEM4AQEBg+/KUcsJkPBl8PHg75py+Jbo/RNJ8DIkAKQLiC+7TPb/INYk5qHswBFcI8svAcBrAObl + 5YlOQrYRfhwYGHjUxMSkE+noKa2cHrGtvqPmJRJOCxJ9AEGgnHNrBgALiG11G/vnMHbmD/AI642pa4bC + P3IQfCL6wiu8N0UveFP40s/TooZgOq/zt3oAJlFKIABgqhEFwK5uf4f5ouZC+AwAv7WD4EHvt1/eFpPm + /oQhUz9Ad4830crhhVoQUIcEgYxaEKDfs2Ph787BhUJeeKQNuYxebq/CdMbncFzSFC5hfTFlvSOcdkTB + NfMgfJJPwH36HERGRupOLu95uicPB3ID4ODGcPHiJZSVV4mLg8qPnBbTgs/xYpICAtp4WCdgDAKGMDB0 + Ahz3TQeowd8XAhT/jmsHRChCNgxDJ6B+bNQJSAhQ6P09I2HMCQgAcEgAKE6g6gL9DfrslEM3hfgFAFSh + 7wKuY2PRGbL/JUhIL8Kps+dEzs/nnDuAY8eOifn/agCwA7Cystr6/vvv8/z/RzP/b2aj+ZxE70SiT6a9 + 6P2llebKfm/Pd2G9qA0BoC88CQLOvKzWkmZwXNxIhNOSRnBZ3hweKzvCd3UfSgf6U+/eAQP9PyXxPSUg + 0Mz2GQyf8TVcKW1gALAT8KTXuq3sTJ/XEpYLGmDswjYYPK8buvn8RHn8q6LuYBQAHCx2A/Hrgr6zhBj/ + H/ICo2Y2vB7hixjk+45YmNRxaXO4RY6Aa/wS2KcVY1LwZixYulzM6uKTyzUAtns8HMhpgJwEwo3iyLHj + yKQ0oKC8GsfOXxMAEKGDgJHC4EOAwBgAajuB2kOEahAYOoG66gK1CoMqQclgscnQiZBEK0Gge2wkatyA + Inzd8yx6bRi+/v/XCdQAQLvnz0sm8fN1/hIAeiAg4UsnsL3yKtZnH0X4jlzkllaJcy4BwPDn6j93CGoA + rF69+ubgwYP9SEY8/Pfo2X/u/ZuYa3o2stRsYvGTyH7j/JntP/eeXFUfG/QTHJaTUPmOOstaw2ahCazm + 1xeLelrP/xk2JF77RY3htKy5uCTXRziDPrBY2Iys/9v4yawevp+oQRdyAVZLWiFg7VDhFrzC+e697SBu + 9hlBQNg2F+57dmBSaCB6OZuglcWLdQOAg8RuDALymgI5lViCQBQzlTsX9XB7BWOmfw77xc3gFj4AU6Id + MTF4BnzmaicE8QlmAPDJ5nsF8vpvPBogAcCjAYWlZeKegQeOnxVilwBQQ0DtBP7jhUESvoy6nMD/17UD + HOrHRuKBToBDPqd2Av8iBLSpAP/uLgpOUs5/6Bb2kNB5wg9DwBAEEgK7DtzA1rILWLWnDHHJ+ag+ekJ3 + rhkAPPmHV4vmDkECgNuHv79/VYsWLbqTlB69y3/5LkEk/EYkrGmNzTXVPCzHYmHhMwBakG0eNPUzWC1u + A8flHWG7uCms5v0ASxK91ZIOsA4ZBOvQMRSjYLdiEByCu8JpaSt4hXaAf0QfuIZ1x+igH9DS7jn8czzn + 409h7KwfKX0YQBAYBK+wTnBb0RIeq/ti6vYgzCqqxKzcq5gSEoWRDr+g5+Rv0N78DbS0eN44ADiE0GtD + QD/0/y/ey3sVDPZ7n9zA17Bf2BDW87rD0tceUevXixMtAcBV3/Lycl1PwI2C4+ChI8IFlFQdwckrt2pc + AEVNOnD/IUI1BOoCgSEEBAiUVMAQArWcgAIA4QLqAMG/XBhk4dL+YZyA1t4rwleH8n7da8Vj+fqHLAzS + d5PQ2k/iLzx1GzknyPZTzs8AYAfAwRDgqAUAip2V1xCbexyrduYhJXcfzl+4oDvPbP95fQgeFlYDgINv + A/bWW299QHJ69Hp/Ev+HJAwHEzNNBlf9WSRSKDym3t39LZjOakDCbwfbJS1hQeI3n/Mtib8THNY4wGVz + CNwSYijWwWXjEjitsYNjcE9KB1rDO6wzvFb3ote21LqASfXERT0Dp34Kl9CuBIi+BID2lFa0g+9GawTl + pWFO8U34xhbC0Xs2JpuPw7jJ/TDEojV6WH6ldQOiB68dxoAgQz1vQK5AxP8f1wmaWj2G1rZPoRulBcN9 + 34XZzB8wxrkDZi0I0uV6HHzS+WYhZ86c0QHgOvUOZ86cRX5RKbIL96H61AWcvXpXrCv/e52AGgTGAHB/ + J6AqCioQ0AOADAkBRfxqABiDgKET0IFAJUApegmCuiBQkwrUQED3O3qfjJrnfp8T4O8pYEB7Fn7GUUX8 + FDUQ0IKgLieQQL3/mpRyxOzOQ/mBI7ii2H8OLv7xaBDbfzUAQkJCrnTr1m0SSel5raIelc1D85hY1MNC + 041EsYFEf4ntMQuDgx+3dyJRBH4D83nU6y9sSuKvD7O5P8FySVc4RnnAOzEBs3OrsbzkHIKLTmNu1n74 + 7NwC53U+cAodKK7L91rVFS4rOtLnfEUCfFLcN5AnAVkuagTPsA7wWd0ZfutGYEbKaszddxGBu0/BMTAU + 5pOtYGE6EVbmljCzGY+Rtr3Qx+pHdLB4Cy0snjMKAb1QBM+hdgLiOR4ypNcwAGRtoKnl42jv8Dz60ncb + 4PAxrF1GijRA5nt80nnud3V1tS4v5Nlh3DAqq6qRmVugdQEXb+huL2XMCaghcD8noIaAGgRGIaBzAv/F + awdYuLQXEOC9ImTDeGA6oH5ODQEKvb+nhPwe/Pr8k7eRfVwr/L2K8A1D7QTUENhVdQ0b8o5h1a58JOeW + EtjPiRmg4jwT6PnSX04D1QDgvYODQ9pnn3326K3+w0N+JICWJPwAEkwF9/osejHuT8Hr8vXz+QAT5jSE + xfymMJvzA0xnfoaJ85vDLsoLvnsysLDoAmKrfsXeY0DmCWBr9R0sKz4Pv+QsyqdnYgpBwDO0owjT2T+h + lf0Log7QxvFvGDvzUzgvNyHxD0RQ0gLMK67CzMwLcF0eDzMrF0wYNQaTx5vC0sIaNnaOsLAzxwS7ERhm + 3Z7cwBfCDfB3riV8VRgDgDrYLQgIMPAoxApENo+jo82LGGDeCMtDlgnrL082Py4qKhK5oMwNGQYnTp5C + fnEJsov24cDxcyRsrQuo7QRUQ4QKAAQEHgIExgCgBwEOJR1QFwb1ACBDQkAFAp0TINEzBPRAoAKADgSK + +PRAQCIUoXqsFrQQNQm5JoxDwBgIpBMopZB/k0FUdEobmUdvUa+vFTnf1HMvBz2WUQMAfSfAkVR9A/H7 + ziEydT/W786l3v+wALsEAD8uKSkRK0VzG+C2wBEZGXlr8ODBU0lOr2pV9Qht1Ot9RPbfhoSymwt/AgCK + GLjq35XHzaf/E5PmNqZe3wQTZnyB0VP/AdNFHeGyLQ5zi29hfTmQUXUd1Ucv4tTZ66g8C+w4Dizadxfu + O/fAIdycBN0K7subYXzQdwSAF8UFQjxtePT0D+AS3BwzElywsKRQfJ7H2kyYO/pi3JjxGD9yNCaRAzC3 + sIKljR2sbOwFCMzsJmGETXf0tv4JHSzfRUvLF0XvbSh+GfcDgAwuFPL/z+BjCDazeQKtTP8OzwB74QIY + AEx+Pvk8J4B7A04DGALcSM6dP4/KAweRmVeI4opDigv4rRYE6nICIhVQQcAYANQQqNMJcAg3oLgAI05A + AuBB6cBDXztAoQMAB4uW9n+EE2Dx8/v4c4toX0A9fg71+LyOXzqJm4WfRsF7AQFF/GoA1ECgxgnsqrqC + uNyjCN9FuX9eKU6dPoNLKgDw4rB8pyjZBqQD8PDwKGnRokVnktOjdeXf1x6ap0j0bUnwq6nhn6P4TZcX + kwDakRUe5Pcpxgb9SA6gESbM/hljpn2MEX6vY/zi7nBPyULwfmB7CZ2I/CocKy3G5cPVuHTmMkoJAmsO + AZ5pFbCJcITjYhM4LPgWwwM+RjPrZ/DTBA06OT2LyXO+gW/UCMzNWI9FldcQkHgSlj5LMWrUOIwaMhTj + Ro7BRNNJmEwpgLmlNSysbLQQsHWEua0ZuYGRGG7TFb0pLWhr8TqaWDxmFAAypBswdAXa2oD2NTL94WPw + 84TH0N+8OULDgsUJlyefewEeEuTLgiUA+L6BPFGooHgfsgv24SCPCFy9ow8AIxBQOwHDekBdIDAGAQZA + 7XSgBgCGbsDQCahBoIZArZoAhRoCOhCQIA2dgA4C9NiYExDCFhCo2wnw++XzRRRc2CsUor9Feb62x89g + 8Su9fzqJnkMC4H4gkE5g98HrlPufQ8SeUsQl56Hy4GFxuy/pANjhce/P6R+ffxlxcXF3TE1Nl73++ut8 + A9BHp/jHVX9q5F+T4B3FIh7c83Nw46dcmGfN9fJ8B6Oo9x8360eMn1Wf7Pp3GOH/Hob5vIzxS3vDK7MM + YRXU22dfQu6uFFTsjseZ/FRcPngAVSd+RewRvkffMVhHucNmwc+YHPQR+nq8Tp9fD/VNNejt8iymhLTC + nN3zsaj0IIJyLsFhSTxGT7DB0IGDMGLQYIwdNRamBIAJk8wxycyCQGBFbsAWllbkBqy1ILCwNccY2/7o + Z9UInS3fR2tKC5pa1n2VoQgSvLH1CDkd4N/z8eBgN9Bw+Ctw8bUSKwNx9VeefM4FDx06JHoHbiQCAgSE + yoNaF1C4/wCOnbuC8yRwCQEBAhJ+TTpg3Ak8qDCoBoAaAsacQF2FQWMQMOoCKP6VwiALVid65Wfjoe3R + tTm+VuS8Z9HzYw6+Yq/gxG3K7+8gi0SfTeLnHl8GA0AXDAISPLsAtRNQQ8DQCeyqvIKYrEOI3JmDjMIy + nKbe/4ICAD6/PPEnMzNTDwDcIQQGBlaamJjw0N+jtfLPzzaa90jsEykSyAVc1gGAgwTQjvLzgb6fYPSM + 70j432MMxajpX2O4/zsY6vMKAaAnvDOKEUIOYGPGJSTFpyIzPh5le1NwkPL43AN3saYK8M+qgv06N1jM + /V44h3b2T+O7cSQsAsBgn1fhHzcBy/cXYH7pLbhEZGCMlRsGDxyMoQMGYviQ4Rg1ehzGjp+EcRMmw3Qi + 9fgMgslWMDO3JhDYwIJAYG3jAEt7a0y0G42RNt3Ql9xAe8s3/2UISBCI2gAdj59GPoZe45sQ7TeIEQHZ + ABgG3CtwLYB7CG4s7AhOnDyJotIycY3A/kPHcPrSTVwg4XPoOQGKutIBDmMAUEPAEAZGIWDoBBQI1AIB + id9YOqCGQa3CIEUtAKggIHt/GaJHpzy9hIL3Mm8XQqc99+xyz7aegwWfS8LPVWw+B1+7n0UAEEGC56gF + gjqcgNoFSBDsod5/S9EpRCYVISE1HwePHBPilw6Azy/XfPjcqwHAa0eOHz9+8fPPP/8GSeqRsf/1mthr + XjCx0rQj4YdTnGQxSADw9fx86+5eHm9j2NTPSfTfKPFPjJj2JYb5vYshvq9j3KK2cN+1EQuKbmN1DvX2 + u48iPrEUSWkHkFJ0CVvKgaXFN+G3JwlOEWaYGPQlers+i58n1sOXIzRoSj2r6bz6mJcRjlA6YYEp52Hq + vgD9+w5A/149MIQcwLBhIzFiJKUCY0wxetwEjCUnMJ5AMGGiOSZOsiQQWApHYGFlS2mBg7ZISG5grE1/ + 9Lduis5WH6KV5Ysk5LprAzKMQUAbdGz4ysKhr8Ld31FQXw0AvhyURwRE70+NhRvNubNnUX3oMLLzi5BD + 6cChk+dxgYR98WaNC9CBgMSvdQKqwqACgYdxAnUBQA8CHCR8XWFQgYAeAGQYgYDOCZDgH8oJkNhl6ABA + Ihe9OgteCa3Ya0Ir+JrII+FzMAB4SE8XBACu8utAoIi/lhNQAPAgJ7Bj/wWsS63AusQccm2VOEvnj0XP + 55LBzuP+3PurAcBucNasWZXNmjXrRpp6dK77bzlJ8zcSfQPq5V1pX9TYXHOP9rrCH4+Hd3F+BQP9PsLw + aV9gmC5I/ASEYX7vY5j/2xg9pz5s107B1L05WJh/EyuzCQSZF7Em9yoiS4HgkluYkZoH9w2BsFnSGUN9 + 30JLEtRXJP6vKfh6AOdYOyyvPITF5ffgtDIZg0ZboVfnrujXoysGDRiEIQSAYcNHEwTGYCSlAqPHjMcY + AsH48eQGJpAbYBBMprTAgtICKxtRJLS2ZTdghUl2YzHCtgd6W/+ItpYPrg1wyLqADAaAnEnYcPzjGGje + DjGx60X+z8GNgRuCHBHgxiIAQI/ZQu6vqBSpQFFFNU6cv0apwF09J6CGQI0T+IMWFVGcAMd904E6nIAO + AhSG1w7UWRgk4evSAQUCwgUoIR2ADgLU2/OMPe71DSGgBwISfg0EapyAhIAOBqqagDEAiGsCqq4iLoes + /6487M4qxvETJ3QAYKDzkt981x8+zxIADP7169f9OnLkyDkkqbe0ynpEtqYWmvdJ/BOpx99KjZ5v4qHL + d3korJ39c+jn9Q6G+H8qFtMYHPApBk39BEOmfoahFMOmfozhUz/EyMAvMHZeK1ivcYFX4g7MzKjC3IxD + mJd1GLOyj8A/OQ3O0QEwW9yRHMM/0MbmCXwzWoPPhmnQ3PIxTArphvmFKQiuBnw27ccoO3/07j0QPQkA + fXv2wEByAIMpBdBCYBSGjyB7TxAYRRAYO3YCxlFaMN5UmxYwBCbxPAFRJLSllEDWBiww2nYA+lmbCDfQ + 2vJlNLOsfZVhrVAAICHAIeYMDHsF7tNsxcQPbggc3Ci4d+CLhNj+c8je4/jxEygsLq1JBS7fxEUSvNoJ + 6NIBEr66JiCcAAnfWDpQFwiMAaC2E6g9RKgGgaETqKsuwE7A0A2oISBAQKKv0wlwkOg51C6AQwuB2gDQ + gwCHAgEBAhK8IQSkE5CpgCEEUqqvY2vhSazdU4ytKXmoqKoWE7wkAHjPsz75/KoBwJV/J3e7g82bN+9I + knp0LvrpZK55uqGZpg319ivJ6p82MdPcE9afhM8gaGnzJHq4voYBvu9ikN+HwgX0pz3HQL+PCQKfYnjA + F5QKkBPw/xADfN7BgKlfYfTivrBa644pG2bDeeM8OMROh9nK8Rg+82f0cHmJ7D71/KM0+HioBj9P0mDE + nO8RmLwEK6qvYObeC2T9F6N79z7o2r4Denbrjr59+6I/OYCBg4Zi0JBhAgRDh40gCIwSboBHCEZTWjBG + goDTAlEkVFICS3IDXCSktMDczgoT7SiNsO2DX6waoYPlOw+uDVAYOgGORqaPodeEhoiIDBfDQRIAHHxp + KA8TSQfAjef0qdM4QPYxK7cAWUV8nQA1rqu3BQDULkDtBNQQMHQC6nTAGAB+LwQexglw1OkEDABgmA7c + zwmoIVDLCVCoIWAIAh0AOEj8HHU5AQEBxQnoFQYP38SOfWexfu9+xCTloqC0HKdOnRQ9vgQAF3h51icP + +UoA8HkPW7Xyev9h3ZYouf+jsXHVv4ml5gvK821J/Hm6Xl+JZmT9Ozm9gL6eb+EXn39QvEPxLvr5vIdf + fN8nKHyAwf4fY1gAiT/gSxL/e+jq9BxaUY7c2vZpsvT/QF+/r9E/4Hv09f0CnV1eo56+Hn4cq8EXZPm/ + GEkpBol/4PSv4R3vjyUlFZiXfRFW8zaiW88haFn/J3Ro0Qw9u/dAn7790feXAfiFIDBg0BAMHDxUgcBI + AYHhIzglIFGPppSAQDB2/ESCAI8UkBuYRG5gMrkBLhKSG7BU3ICNvS3G2w3DIJvW6Gr1Cdo8hBswhEBj + M3IBw1+CpctoSgG0owASAPy4rKxMXCjEEBAAoMZ04sRJ7N9fgYzcfOSVVuDo2UsiFTCEgM4JUNSkA/oQ + MHQCagjUBQJDCAgQKKmAIQRqOQEFAMIF1AGC31MY1HMCFLp0gARv6AQYAHVBQBQFDQCgqwmQ4A3dgLGa + QFLFRWzIPIC1u3KRlleCY8eOiyFcCQDec4GXzysHA4D3O3bsuOcwxTrjk+/f5Jt+PjrDfk0ma/5B1n8k + 9faxBACxlLcMvgVXa54H7/Iq+ni9hb7eFF5va8ObYOD9Lgn+fXIFHxEEPiUYfExO4e9oQVb+B14XcIxG + 7OtP1Ijx/R9N6TkS/tfU63PPzwuBtLJ+DEP934Xr+kmYn5+NhcU34RG7H4Mt/dCqaQuYfP0FWjVqiC4d + O6NXrz7o1acf+hAE+vUfRG5gsHADIiUYOoJAMEpXG+BRAm1twBTjTCfCVBQJtRBgN2DGbsDaXowUWNnZ + YLLdeIy2kW7gH+QGnrrveoRqCHCYTHoM7UZ+ipCVy0QuyA2DewgOvkKMC4IyDeBGxHH0yFEUlexDek4B + issPEQQuG4VAbSfw/18YvL8T+DdcO0CCf6jCIAeJ/n5OQLoBfRDUAEANAQkCtROoqyagAwAHOYE9VVew + Jf8o5f352JGeLwq2vN6jBACnAZWVlaLAqwYAF/+C5s4407Fzm8maTx+hW34rY/4m1Psvpjz/AD2+q270 + Ytqr09/Qw+019PZ8Uxseb6IPBzkChkB/6vE5LRjg+yF6ub+FtnbPCbF/Q0LXrvJbTywY8j2JnYN/Z2Lx + JFrbv4BeHn/HmMCPMGV5K8zc5o9FRfswJ/8mXNbvw3DHWWjfuRea/Pgjmnz/HVo3oXy9Yyf06NmbIPAL + evclCPwyUEkJhmDQYE4JRhAIlNrASAIB1wYIBGPGEgTIDZiaKgVCdgNm2iFDC0tb3bwBBsF426EYaNOK + 3MBnaG35yu+qDTQa8zS9fwAXgkTjYPHLhsIXivCYMTciCQB2BQerDyGvoAjpuYUoreJZgtcFALgmUBcE + apzAv7aoiBoERiGgcwL/2rUDOghQ/N5FRepyAn9kYZABsPfgVWwrOoGo3UXYnJyDfeWV4nxJAHCw9c/P + zxe5vzyvfI6j1kXdHWc6OuS99977B8nq0Rj2a+mheaK5meYjErwp9f5pBIDbavE3s3ocbe2fRReXl9Gd + ANDD/e8ielL0cn9DwKCv99sk/PcwwO8Dcgj/QHvHv6HB5HqiZ29MwulOrx3g/yH6UNrQzY2XAH+N3MO7 + 4sIfXg3IfllruIV2gO/q3giMs0XQnrUIytqHgL0n4LQ2F6PcFqJLr6Fo3qgJmv1cH22aN0OnDh3RrVt3 + 9OjRB71790Pffv3xS38GAbmBgUMJBMO1IBhGjkCAgNICxQ2MHTexpjaggGAygYDnDcjagAVBYJKdKUbb + 9hNFwo5WD1EbkE6AUpv2w77BrFlBOmsog3NEvlXU8ePHhfi5QXHj4kZWWVWF7LwCZOQXiTvMniIIXLjx + Ky7d+s14OkDCV9cEhBNQACAg8BAgMAYAPQhwKOmAujCoBwAZEgIqEOhBgISv5wZUANCBgARfKx2QToAE + L0PtAjj+HYXB1ENXsaP0JNallCAuKRt51BEdIXfG50cCgKd38wxPdnMSALII6O3nlvvtT2K130dnuS++ + 0o8sfl8S/aqGlprjLH4JAJ7owoU/XoOPh/5YuBzdKBgGDIHeHm+QmN9CP3IBnB50cn6JevbHxHLgJhZP + iLvxWC1uCYfgjrBe2hpmC5qKZcCtl7SBy4ru8I7oL27VNXXNL/CJ6Amv1b/AN9oW0/dEY27JKcwu/hXe + CYcxaeYa9B1tiTat26N5w4Zo1bgx2rdqTW6gM7p374VeDIG+/ckNDBAQGEAQGDiIcnouElJaMGQ4OQLF + DYzm2sDYCdraAI8UiCFDTgtq3IClNQ8ZOsLa3hbj7GrcQFtLrl3UvTApB0Og5ZCP4ebhKq4RUDsABgD3 + HrxgJDcqhoBsYMcIChUVlcjKpd4lvxgVh0+KSUIMgIs39SGgdgJqCKidwL8yRKiGgA4AHMINKC7AiBOQ + AHiQE3joRUUoDNOB+zoBCsOagBoGhk6AQzqBTIrUQ9ewq+w0oveWInY3WXs6/tXU05+gc8Kw5vPDe4Y3 + i18CgINTgUVLFp3p0LWlFUnqb1plPSJbEyvNzyT0BY3NNUeo8d7RNWLqxfjGHHxLLQZAJ6cX0ZkgwCAQ + MHB5RSyg2cuNXAClAr0IBl3JJfBinXJtv16e78J2WTv4RPaHb+QAEnc/uK/qDbewXvAI7wsvEr/vmkHi + Zp2+Eb3gGdYR7qGd4blmHAJ2hGBOQSUWVt7C3NJrmJZ6CE6RuzHUzhftO3YnCDRCi0YmaNeyDTp17IJu + 3XugZ68+6NP3F1Eg5NrALwIEQ5TRAvWQ4VhtkZDcwOhxSpGQQMBuQNQGhBuwJjfAE4jstW7AfgLGkK0f + aN0CnSw+QAuLZ2sJXxcW9dB2xGcInBHAt4ESy0Gx8GVj4cbDY8c8gYTtv2xc7AK4hyndV4aMrFxkFZQS + BE7gzJUaCNQCgBI16YC+EzCsB9QFAmMQ0BUFdQBQFQZJ8IZuwBACdYHgQYVBHQhI+IZOQA0BCQIdBHTp + gHEAGEsHsk/cQdrha0gqO4PY1DLEUs+fmlOIAwer6XwcFedEAoDzfh7N4co/n0M+pxxr1kbeHDK8//xX + 3331HUVWf/6N837lhp6TTLR39RE9vgye8MMr4bSxewZ8z/2OZOs7TXkJnTmol+/i/LKAQA83SgkoutJz + be2eEtcJcO/PK/tMmt+YxK1d2dd/7RCt0AkEvNgnQ4EB4BXxCzzJ+ruv7Ai3FW3gsXoQfDZOx7Sk7ZiZ + XoBZmemYnbUN8wozMKf4BLy2V8I0MBI9h05Gq1bt0LJJU7Ru0RIdWrdBl06dKSUgN9CnH3pTStD3l4GU + FgzCAMMi4fDRYqSA3cDIMZQWjCUIUFogIaBNCSzIDfCQIY8UOChuwBETbcdgsFVbdDcnN2D+KppbPadd + M4BCAoDh2WHMl4hcGy4ayubNm8WQID+WAODgKjLnkzoAHD2Ko0ePiOdKSvchPSsP2YWlqDp2mpzADZEO + /KtO4EGFQTUA1BCQIFA7gf/vwiDFv1QYJOHr0oG6IEChrgeoIaDnBDgIABlHriNp/xlsSN+PDYk5SMkq + oFTsAJ2LI+K2XhIADGuu3xgCgB2eld3E7d99992PJKtH51p/rvqT9R9KDXd9I0vNBWMAaGmrBQDXANo5 + PocOBIGOTi+QzX9RWP3O1ON3daWcnmDQ3uFZ0fD5Mt6G5o+J1Xz4ph/T1o1AgHJLbiF8Ej3bfm8SPrsA + j/A+cFvVndKBtnBd0R7e6+0xbc8ezMg6gkDa+8W5wnf9UEzb7o25RUWYXwlMz70Np6hsDJ8ShE49+qN5 + o0Zo9tOPaNusGTp36IRu3XoQCHqLtKCPQZFwMKUEDAF2A1wbGKaaRTh2nHbegHakgIcMzbVugCBgYfX/ + 2vsOsCqu7ftrSTUxPWqaMV0Tk1gR6SIgAmIDG2IBAem9dwQBAXvvvffeu1hQwN41McUY07tJXP+9ztzB + K2KSV/7v98zjfN/+5t65c9vMWWuvvc+ZfWJUbiA8IgKDQwdiYHBn9BA14JrQDDaxT98xUtDe51UsWDxP + Zft5hyDnhXN2oCkBsDNxaJDzA0gC3LLTfSgqgKMFR4+dwL4DhxUJnLksSuAbUQJCAHdNDIqZKgFTEqBV + RQCmJFCZDKokgcpKoBIJVJCBgL8qEjAlgj9TAhXhgID/NiUgVlkJmBIAVcCfJQYPi+ffL55/hxH8lP27 + DhzB2XPn5fxfVkqM10IHP+N+qjadAGi8npm5KWdsHc24zPe9I/15m6+A3FwIYIJ01otmIYZfTcGvEUAN + WEfVViGATgIOYo4SDjgmPAonkkAS1UBd2fcwrCRc4KIe74s5S2gQOamdeHuJ7cXzE/gEe+rsrgrwujEc + UDbLDckzHJAysyOGrMjCsL1lKDhwETnrpyFlmj0Sx7+F9IUDUbhvJ8ae+R7jL/yE0SeuYci2kwgZNQ+d + +wbAxtJawoKWsLMwh4OdPZw7uBhzAx7avIHuPTQ10LM3evXSJg+p3ICaOzAQ/fub5gYC4Bdwa8gwKCgC + ISFCAiERCA4MQrCfP0J5o1FuBvwnpaHnaA84pTUSxXRr5aJ2g17EhGmj8Pvvv6tZgFxDgMYwQO9A7Ez0 + KswHsLPpBMDORwKg5CwtP4p9Bw/hQNlxnL4kUvRLbcqwSgyazBisIAEBv6YE/vUhQlMCuI0EaAL8fzkx + KICvnBisUgkYCeA2EtCVgJEAKpOATgRVEQCN4N9++jOs2HcKK7aXCPgP4/SZs/jg8iV17nUC4OMTJ06o + 62RKAMzjjJ4w4jM3D/uUp158iFn/e6Mx628ZbnjFIszgL16rWDqrSdx/OwFYRdYSFVAbtlH3iwkRiNnH + SEgQr5PAo3DgZJ/o2uq22KYS+7eNeAADh7+HTJH4uYv6CgmIxJ/TWbx8JzGuDNTZCHydAPhcXpvpLGFA + J2QujZP4fz6GbpyNjEXBSJpsppbrGrIqV0KCIxh55KyEBJswvHgJig7uQsH+80hdVQ6f9DFwcusGS1ED + 1mLtJSRwVrkBd5UbUPMGjESgJQlNcgNCBH37DkA/4wSigb7avAE9LBgsYUEQwwIhhME+vhg80BeRCUOR + uXg/hh44i7i1o+E93FwVDtUWLKkBW//6yCpIwM2bN1WhSMr9tWvXKq/BzqMTAB/zXgFOKWWnIwnoBHDp + 0kWcv3AeR+W9xQdL1BDhyYuiFr74zhgOaErgjhGCChWgWeVw4N9778DdlYBOAH8WDtBMVUCVoQBNgH/X + xKDY3RODJiEBwX/pW2w/+QlW7D2BldsPYmfxYZw6fQaXLl5Q3l4nAD6mQuP1MSUA7pszd8YPPfq5TXv6 + uUffMELr3mjM+luGGTqbhxqmCwF8rIOfEtYU/MoiasAykrmA2iofYKtyAkIC4vEdhARIBDbR94ElsrgY + KBUAawTETe2o4n5K/4w57mqIL0XkvQK5ePs7SUCIYabsn9UZ6fMHShgQgYwFg+R9HdTaAFkrMpC/azcK + D5xD/rZlyFoWhKylA1GwYyrGn/0M4y8BucVfImzCRnTpHw5b63awbtMGdm0t0N7WFh2cnOAiYYG7e1d0 + 6WqSGxA1YDp3gBOIqAb6DfDBAOYGOItwUCD8OGTI8ECA7zdgIAIDI5A4ehGGl/yI0ee+ROaGPASPMUOf + oY3gnlpPzs1jaBf0LKJTBysFwMbKQJT/jBk5GqB3Jm7ZwUgQVALseDoBsANSPZw5e0Ydt3f/QSGBMhw/ + q00Wuv79DZUTME0O6qFA5ZyAUgIC/KrCgbsRwd0IoKpwwFQJmBJBZSVgSgSmBFBZCdBMSUARgYD+rkqA + JoD/IyVw5JOfUXzxG2w9dgXLdx/FKgH/ruISnDx5CheFaM+fP6/OOXMwPO8EOq+LKQFw3+p1K37pG9Bl + S8MWdWyNsLp3mnWIoZmAvKBNiOG0bG8Q8KYKoAL8RgJQJBBRU40IWEXUFkXwAOwk3m8nSsA25gFwiW8u + CUZzlI4fONpcLbedu6iPeH+J8UXWM7ZPlhg/RWR+qoA6VfalzuqkAV9XAbM0dZA2W94zq6sQhj2Sp1gi + fYEfcrcsReH+UyonkLU0HsnTrCSEcEfe1mkYffwKxp79FmPOfoMRx39G2pqzGJA6Fh06dUfbFi1g0fx9 + 2FlawtHRES4unDfA3IAWFmhDhj2VGujBIcPenEAkasBbwoKKIUN/+EhoMNB7AAZ6eWOQTwAiM0eJQrmA + Med+R37xOiTN80LUODMJR1rAb3gzeOW+hU4JDdEn1EkN87FRCXAKKW8X5sgAhwbZodix2MF0EqDs17z/ + LQJgx6RCKGc4cOCghAQSOpy6gEufXMe1b39WCkAlBysTQSUSqKwETMOBqgjgbiRwmxKg/UlO4I5wwEgA + VZGAKQFUDgf+SAmYkkBVSuDIxz9jz/kvsLnsMpbtLMWaHQewZ/9hHBd5f+7cWXXeeZ553nnOubAHpT9j + f50AuG/dhjW/BEUN3Nuk7bOdmEg3wuoeaGmGmuZRhmdF+ntL7L9VPP7PBLyp3Qb+SqaVzK6tJC7rATA/ + QHXArH/zwVqFIC71nTbHQ3n+IXMFzDPp9V2ROs9bM3mcMs1OgTtlRmU1YCQBCQNSZornn2YtZidhQACG + rp+qSGDIqnw5zkPlBTKXRIkq2IaikosSGuzB8P0rMeb4ASGDL5G37zOEjlmNzn2DNTVgbgE7KxsJC+zh + 7OgMV1cJC7p0Mw4ZChGoIUOdBJgk9IYX5w1QDfT3RT+OGvT2Qn95bXBoEtLm7sPo00BRWSnSRK3ETbZH + zHgLRE+wQvTEdggZa4V+Q99D97DW2LlruyIAvTHZx7sFqQRIAOxUOgGws9HDsDMS/DR2Sj4/KwRwWl7j + e4r3l2CvxKyHj53C+U8+x9Wvf9RuJa5KCYjdCgduJ4HKSsCUBO5GBJVJQBGBiRIwJYE7iEDAX0ECdyGC + yiRAu00FmJDAbUpArCIcEMAfu/prBfgPf/QDdp2+hvUl57Fc4v31O/dj/6EjOHb8hBDraUWuOgHQqMR4 + HUwJgMds3rLp56j4wYdatnulpyDq3qrt3yrI8JSA31mk/zgB/weVwf9nBECzEiVgHS5KQEzd/hqq3b3H + El5cy5/Lfecu7oe8Rb2QMbO9ANVSW8VnTSHSmdAT750kkp7AVmpAhQRCEFQDyowEMMtFkQBDhrS5PYUE + AsUGI3WOp7yvowoTcjfMQtHBiygoPo7sdSMxZKkP8tZGY/iBlRh98jqGl/+C1NVn4ZMxAS7d+8JGCMDG + vC3srW3g5OAEV6qBztoEIpUb8JSwQM8NCNh7CQlwFmEfjhpImNBXbOCAQYjMm46C/d+J9P8KWetzED+F + 4G+L2AnWiBHwR8s5iJrkiJDRthiQZoGRE4fim2+/UgqA4QDzAexcy5cvV0qAQ0m6h2Fn40QTkgI7pO79 + +ZgdUO+UZWXlQgIiX/dJRy49hhMXPsCVa1+Lt9fqCegkcKcS+M8kBv8lJSCA/zMlUEEERhKorASOf/ar + EIBWF/DgB99g+/GPsbr4JFZuO4hNu4px6HApjsq5JqHynJoSAB/z/JsSAAlh69YtP6akJ+xsadW4x2sd + 7qF5/qqJ928TYWgqgM0yCzMcFPuuqqTfn5lSAWE1YSExv/L8An6aQ/yjajlvrvOXt7gPsueLN5/RTuL3 + DkhbkYzM3buRdvhzJBSfQOzaUUia20fA7SRhQTs19p8y3VGA7aKRgAoLjCYKIUUIg0SQNN0GSVMthSDc + tKHCzUtQsLdUlMESpC0YgJSp5kiX78/fMg2jTnyICZduYOyZH5C76wzCJyyCZ0AMHDq4wcbCEnYWFnC0 + s4Nzhw7aBCJRA11IAsbcgGdPIQKSgIC+R/fu6NG1G7z6eCMgJhOZK44L+G8gr3gFkkTtxI5rqZY6i5lo + i5hJDkIAjkIADoiaaI+Q4bYISe2GsmMluHHjhlovkJWBmOjjvIC5c+cqImAnYwdkhyMBsPPpJFCZAGg8 + hoRx4OAhIYFi7DlYgtJTcuxH14yjBL8pNaArAp0EbimBf31B0ipJoEIJ/GfvHbilBH5VdlTAX/rxD9h3 + 7jo2l17Aip1lWL19P7YK+EtFQZFwTc+1TgA0nndTAuC+Xbt2fZ+VlbXJzMyso6Dp3qrtx9Yq0FC/Tbih + j3j/zWYhhm8F/DdNCaAqsN/NeDwLgxD4nO1nLmrAO78J0md3Rz6XAJ/nLtLfHoni2ROXhCNj61IUlFxB + 4QkgU2RzfOnniNs0D4kLfZEoKiBxqpU2B0CNApAEmAwkATA0YFggBDBDyGKajZit7OuCjMXhyF5ViOw1 + 40QZRAiRiNrgEOLKHBTs2Yvhh0+JEtiOon1LMPLwbgw/chnpa4/Df+g0dOoxUJGAVasWsLO0EDXggI4d + XSumE+tqoHsPIQKPHujm5oZurm7oOzAEcRM3YMTRX1BUXoLUpcEi/dshluAfbyngFyUw2VERQLSAP2qC + DSJEGQQmu2LpsiWqGhBNn0/OzseFRWfMmIFly5ZVhAN6x+RjdszKBMDXmCsgaZTLew6VHMIeIYFdxQdx + oPS4qIEP8eHn8j1f/4zPv9fCAtrtSuCWGtAJQJHAXyCCv6YE/j8lBk0I4DYiUCTwq1ICZZ/8gJIPvsaO + Ex9j/f6TWLHtANZvL8bOvcU4ckQbcTl+/Jg6hzyXPK/08Pp5NiUAhmDbt2//NicnZ5O5ubmLQOkeW9Jb + PH97bTlvJ0p/TvfVQV9l0u8PTMsBaCvlcM08Zv15d1+n9AbS8Z1E9vdD/qLeIv0F/FMkHl4wCNHbliP7 + 4HnM33dITuRKrN+7CxPLvkRa6ZeI3b4BscuSET+3l4QFrkoRqNECbiUE0NTALRLQQgU3lWNIm9cXafN9 + JDzoK+Dn+xyQtSwRw/YcRNGRa8jbuRlZHEmY54lhWwow7swlTPgAKCz5HrEzdqJncDLaO7nAuo0ZbM3b + wN7GFk7tHeHS0a1iyLCLeP0u7kIKHV3QvYsH/JNHIW/3Fxh99hqGbMpD/PQO2qrHE+0QK9Kf3l8RAE32 + qUVRR5hhaEE6pk+frgDLOgAcW2YHY0fk7aNUAUVFRWqpcZKAnn3WCYCd0rRzkiB0AuBncCSBYcTuPftU + J999oARHTpzBmcuf4qMvvsNnXI7cqAi+MCGCqnIC/18Tg2K3qQAjAeh2NyXwV+8dOH71ZxwRuV989jNs + LDmLNbtLsWLzHuX19wpBlgr49SFXnjueQ55PnlvTUIv7aCRp8fxfDRkyZK3R89976/mrG33CDO+31Vb1 + OSGPVda/wgTQplYV8HXTat/xBh8t48/6gI5JTyBgjLma2ZfH2X7zuyB1uq2AwxGRK4ci9sB5TJA4vWxl + Jn6c3FKsNU6sSMBsidszyn+X1y8gfsN0JC0KRop4dkr9ZBKAbFNmcaRAQD/bSASzSAYmQ4dKGTgKAdgi + TfZlrxklsfkZFBy8gOy1Y1SiMGVyKwxdlYBRZUclJADGnb+JEUI+mZtOI3DkQrj18lUJQt5XYGdpBcd2 + 9ujo7CxE4IKOHDoUddDZrQu8g+KROHePhBY/ofDgOqQs6IO4SZYC/LYaAejgp/en/J9gi7jxdsgfmaKy + /hz7X7JkiSoMQnAT6BwK1EcEJk6cqEhg3rx5yhsxRODWlADYSfmY769QAByakk7Njs2Zhezo23ftxrbd + e7H3oOw/KbL2w8/UkuRUAwQ8CUAjgpsVJHCHEjASQGUSMCWCPyWBinDAhAQE9HcoASMB/Fli0FQJnL3+ + m1p74KRa/Ufk/kffYv/5a9hedglr95Zh5dZ9WLt1F7bv3meceKXNuiwtPWJUALfAr2f9+ZjGc87pv3LN + Pk9JSVn8/vvvtxco3Xuyn80y1NBCzMsi1LBVvP8vprKfRmD/VQKgcWEMlgdj/M+y4AOHN5O4u7vE/X2R + Pa+ryvonznBG/KJAJG1ZhMLi09i8aT6+mtQWyDAA6Qb8OuIpnF/QH6t2bsOI8p+RWvod4rdvRsKKTCTO + H4Ak8fwcNuRIQapKFIoaUEqA4Cfw5bEaKeio1EKykEDanB4i/7ORu2W5mkCUvtAfyVOtkT6nO4ZumISi + gycw4vBFDD+4R0KCLRh9/BTyD11FzOx9ogYy4eTigXbW9rCT0MC2rTns2gohtGkJBwtzdOvlg/DRK4VY + rgt5lCFzdRISpjkZvb+VgF/CAAE/VVD0ZAfx/kKAE50wckKO8vAc+mPyj52KteIIfM4HIPg5MWjp0qVc + OBK5ubmIj4/H5MmT1esEug58bk1HBfiaAr8QCTs27bAQwKGDWoGKXRIGbduxC9t27cO+kjKUnRDvduUz + XLn+Ha59d0MDvQCdqxJpRPCPJwZNCeCuJECrggRuIwDddBKoggBMlcDZL39Xq/qeuPoTjn78Pfafu4Yd + 5RextviYivNXbdqBLTt2Y7cqz3UAJcap15x4xfNF4iSR8lzqw608x/p55nbL1o3XY2NjZzZu3Ji39t5b + q/mYNpHr3gL0oQL+cwR/VQSgAfvPCYDH0/trlYFroVvmS4ib1hFFy/1QtGwAsucIUKe3Q8KCgUjaOAvD + 9pVjmYD88oIB+H3Y40CiEECCmBDBzWEP4UvxzodX52DegTMYcvRXxB66hLhNc5UaYEiQJHG9IoKZnDdg + zA1QDTA/YBw1SKEKkGOpANLle9IXBUlY0Ee9L22OJ3JECahpxcUnkbt5roQJwcheGYCCPXMw+uSnGHUS + yN72KUJGLYPHoCjYO3SAefPmaPNOY1i8946aUtw/Og9DNn+EsWe/Qu7W8Uic6S7AtxYTLz/JDnGT2wsB + OCkC4ChI/AQnjBifrYb6WPTjt99+Mw4AQnkdTgdev359BfjnzJmDKVOmsIQ0kpOTERUVhXHjxqlOW5kA + 9A7Lx/wsejJ2bP3eAhIHPR7nGGgLlOzCViGC7Tv3YY8ogsMnROJe/gSXr32NT7/+6TbPT2Xw+Y+3SOCP + lIBOApXJoEoSqFACfz0xeBsRfPmbpgJoAvzjEuOXXfkGB+jxBfjr9x3Fii37sHrLbqzfvA07du7GHiHA + g3IeGBrxnHBL8PN88VyaTrbSzyeNOYG5i6f85Bvaa82LrzxjaYTRvdsk7k8R0M8Vu64TgG6mBKAAbvK4 + svE1vofen8Y18boPeRmJ010xcoW/mA/y5nVCxmzxyivTkC4XZUz5D9i8aweuz3YBhta4RQApYmliQwy4 + MeJJXJnfA1t2rsPYo98ivfRbJCo1kCFqoJ+oAXfl4VOY5JvB3IAeEpiMFOijBbMkfBACSprSCslTzJGx + MAB5W1ehcP9Z5G3fiEwhh+TJLURVOGLopvEYWX4e489/LfYVCg99gLg5G+AVMwQd3HvAytwKdta26NYv + GNFTt2DE0e/k+P1IXxogwG+L2PEi/SfZC/gdlWmxvwPiJ7lWCf5ff/1V3RTEzkfwz5w5U8l9GsE/apSE + LwUFyMjIQGRkJAIDA5Ui4LHstEwcMixgZ+UsNb0D8/OYE9BDAHZ0EgBVAAtU7JZwYPv2Hdi6bTu2bN8l + 53kPdhwQojh2GsfOfYgLn14XVfADPhNV8Nl3v6rtdQkP1CiBkQQ++/73KongzwjgNhKgGZVAhRqoTAAV + 9puRBH5T4D8rEv/0tZ8F+N/j8MXr2HfyCrYePof1eyTG37oXKzdux7pN27B56zZFent27xEC1Iqw8FzQ + CH5Ke567yvdbcMv9VFGFEzLRKaD5R293eSCdiXOB0L011l+5CWhZ23+OWZjhmin4datQA0aQV7bbSIDv + MSqANmE10CH5SQSMMlP3+Ocv7oP8Bd2Qs6AnstcVqMTfqOPA0oNncXp5DH4Z87wCPEMApBrNSAIofBA/ + TnobZ1YkY8H+08g+9hsSBJAJG+cgcVGIIoEkCQUUEajcgD5ScHuSUOUPSABTzSX+txEC8EfOhini+RdL + eJCl6gwki+rIWBiI/B1bUVRyHkUHtqFw70wJVYQoDp1A1pZTogaWosfgVPQISEHIyOXI3f0RRpadRM6m + AiQK+ai4f4I14hX4O4iJ9xfPn6DAn/OH4Kc3ogKYNGmSAjhBP3LkKBQWFqrnqampiImJga+vL/r06YOE + hATMmjVLgVvvsDoBsBPT+JwhATuwrgB0AuBQI0HBuxG3CkA2bdqMTdxuY3wsxxw5qlTBKVEFFz/5Ele+ + +AGffvOzsmsCfBKBHgqQCGi3lID2uCoiMCUDkkBlNaArAaUKjARwWR5fErvwxQ1cFDtz7Scc+/hbHP3w + axw4+yl2lV/ApgPHsGb7AazavBvL124S4G/Fxs1bVDjFcGuP/Fe9DiON6oihEr07z5XpHZfc8jxyu23H + FsTl+MPW90U0H1DrjCjdiDYRhtc8PO6hkt5VtTYhBk/5M4kC3D362P/drCoiMCUAnQT01YEsRAV0TH5G + DQFGjLcSmd4RQxf2xrA1qRi2ay0KDomHFVm/YucWHF2Zgi9mWEv8/6xobiP4dSVAUuC+UaIGFvlgw57d + GHtMdpd9j7gd2xEnaiBhnpcQgat2xyBnEarQoNJIgQoPOJrA4URnpEsokLkkEpmLw9TIAVVE+jxv5G6a + I2C/jPy9pchaOQTp87tLqJCAUeLhx1/+FcMO/YCE+ccQO6ccOTu/wshj15C3bRqSZ3sgborI/skS4yvv + 7yTSv4OK//8K+CnLmfBjvD9s2DDl6QcN8kNERCRi4+IU2JOSkriOvHotODiYy0rJ6xEYO3asAjfzCey0 + OgHo96rzMeNaqgEepwNAJ4BdAg6SAHMQmzZvxvoNG8U2YcOWbdi4dSe27z2AfYePoUTI4MSFj3Du488l + TPgGH3z+HT768kdc/fZXfCr2yTdUCkIIJkTAx598SxMSEFKg6QTwsez/SEyRALdit5SAAP5Lgv0XBfhz + 137E6avf4+Sn36Ls8nUcOPMRdh+9iM0HjmPdzoNYsWk3Vm7YipXrNmHNuvXyP7Zgs9hO6SP6gqw0Jlr5 + v5nsYyKV50Yv6MHzRcDzMYmTz5eumgfvqA5o6/MEWvjV4LJ3x/42BNCatf7CDRYC8HSSgGx/MAV9ZatM + ApUJwMJ4nMoFiJmJEuAtsK4pT2NgYVPETxV5vcgbw1ZFI2/jKOTt2oTCkkuYfPhjbJDHZ5cE46dxrwA5 + RvCTBKgGMsXyxMY8gW/muKJ841QsKLmCIcduIurQJ4hWaiAISUIySZwPQBKgGuA9BRVEwHBAJwM+5i3H + nhopiDLg8yErMpG/cxsKDpwSj74QqXO9wPsKspaHoGj/Bow9cw2jT91A0ZFfUHjkJkaevInCA8VIk++O + nWCuvH/8FInzp9DzOysCSJzsLuAf+pfAP3XqVC4WqcAeGhqmahD07++DQX4B8BUyCAwKRpAY8wBUAoGB + g9Gvf19FAswRMKlF8LMDs5IQOzM7Nx/rYQK/j5KXSsAUGHy8XQhg69at6rdyKvK6teuwZs1arBNCWLth + M9ZJDL155z7s2F+C/aJ6Dp86j+NCCCcvX8XZj64LKXyLS0IKH3z+Pa589RM+/vqGbH/Bh1/I429+FdD/ + ig/l+Uey/yMB+RUC/ctf1Pay7L9w/UcB/S84//kPOPPJNzj1ydc49uEXOHLhKg6dvoJ9xz/A9pKT2Ly/ + HKu3F2PVpp1YJoBfunItVq/dgNXyWzdu3ICNmzap/7B1q+b9SWz8f7rXZ36EwOd50Y3niYDnNWJehWQ5 + evpQdPBtihY+96H1YAE/+3SIYZ/08YF/ixCAjev8tQ03WAkBxAtw18ifO3s3NaAIQLeqCIBmfJ25AM4H + 4JAgT5w9FwvNfhnBo5shcYolhsztiry1GcjauwWpRz5DXvmPmL//GA6vyccXAuLfhz+hEQHDAFquWIHY + qEfw+7RW+GRFHLbt3YfxR39D+pFvEL99E2JWDEHcvP5qpEDNF1BqQJsEpIHeOFKgK4LZLkiZwfsO2iNt + Xh9krUhHzsYZYtORuTRGkUfa3B7IWTcG+Xv2Ir/4kCiDXQL6fRheUoqCfTuQtSofidPdETPBDLGTLAX8 + jkJ0HUUNOAv4O/+T4A9FQIB4eL0eYWAIBviyRJkvfHz9RBn4y2sBCA0PhW/gAPQc0BnuPR0QHhOEOYum + Yf/BffjoY60zm3ZykgD3saPrREBQEBwsS0bw6wSwSUDEiUgMSVixaOWqVVjF7eo1WL5KtmuFFBhb79yD + rXsOYueBI9hXegL7j55G6ZnLKD17BWXnruD4pas4+eE1nPrwcyGKazjz0Rc4LXbiA9l3RbYfXsexS9dQ + fuFTlImVnP0IxccvoPjoeWyXsGtLcSk27D6E1Vv3iLTfhaWrNwrg12HZqrVYumwlVq1eJcBfI2Ql4BfS + 4m/eJLZZfj//C/8HzzEJjx6fnp3nQDeeF50wWY79xMnjEjasQ1yuDyz7NcD7Ptp0dsHGTcHI9TbBhvmC + BacWfoaHjRC695vE7XUFtG/Kn+wi26EqJNBmBN5BAqZmqgZuJwR5XWNLtBIS4IQgNToQUQuOCXXQO/t5 + RIxtjsx57shZFYn0rVOQKuDKLvsGE0q/xNodG3B2UQB+mNgYGPEgMEyATyMBFNUExj4FTH0XNxZ44sP1 + BVhLYJb/grgjXyNm61okLIlV8wY4AzBZwM0px+r+AX2kwJgYVPMIdJUgYUD6gv5IX+iHtPm8MUn2z3AS + 75+E/N17MWz/eWRvWY6M5QnIXOaPIctD1T0IKbN6IWGqk3h8GwG9vYDfScwZSVO6YOSEfw78vr7+2loF + VaxcFMCaA/KYS5hx3YLAsGD4BPeHV1BntPd8D50HmSNhaBAOHCqukLR6dWEaH5t2foYGHPqiLCYR0PMT + NDoBMNFIElgrIGPVopXye/mbly1fgUWLl2Lx0qVYunwVlq1cg2Wr12HFmg1YI8SwdvNOrN22Gxt3Fqv5 + 9dv2lmCLssPYVnxYgC2P9x3Gxl0HsEkAvl5i97UC8tVbd4lX34IVYktWrsdCAfli+fyFS5djgXzfEtku + XboMy5cvU79ntRDA2rVCAOvWaqpFfit/O887wxt6fCb49POgL7pC4zngOeH1IAmUlpdgwowieMe1Qxuf + R9As4FbfFWx8LX1+R5swQ4x5sOEtTqIzwufv04yr/lpQDQh4l8v2jPzpb0xBX6XdQQCa6TcEKSKQE9lc + jIVBWCOAtf79hzdG0lQrZC/qjez12cjYu1G8+cfIFSKYXXwU+zdMwqcL++HGlPeB0Y8K+IUAhouNvF9I + 4HFgQn1gZmtcXxmFvbu3YWbZt8goB6L2lCNmZRHiRQ0kihpQCULjXYapHDZU+QAqAppOCO6iFFzUECHn + CCRPNVckkL0qD8P2HkHe3jJkrhqGpOmOSJz4PpImW4jZiZppj4QpTmIdlOcn+JMV+HP/KfCz/FjFOoa8 + zbiiOnGgKkMWyMVMuVaBWtpcK0qqzLhWQfcQa1VvsEewHSbMKlQJQHZydngCXgc/fweN+/k6E4gc5mKC + kLJZB76+Xb16tQIcTRHAsmUCxCVqqHLRwoVYMH8BFnK7cBHmzp+POfPmY8GixZi/aAlmz1+I+QLe+YuX + Ye7CpZi7QPbL83nyfPY87bV5sn/23AXymjxfsEjev0DNflwon7dgwQIsXrxQfReN4OdvWLVqJVauXKkU + Co1DpyQxAl+P8XWAm667yP/MxyQETr8+ceK4kNc8ZIwIReewprAMeUh5fRPws5+flW1umxCDjU2Y4XEj + ZP5+zSbQ8IhI9teFCNz4h+WP7xC7Y5iwst2pAowkQJPXOUWYE4SoCHQ10EHUAFf7iR5vhqx5XZGzIhBZ + G4uQtncbMiUsGCVhwdIDp3F0wwR8N8cNGP+CEMFDYqIKxj4mz58GJr8EzG6DHxf3wZWNhdgoYURe+U1E + lVxH1NZ1ogbiJSTogiQhgORp7dRwofL4vA1ZKQIjETBsmKHVJkiZTrJop0ghc2kscjZMx5B1E0UZ+Ims + t0TCxBaytRLwtxPv74CEac6ydRHwC4FM6fZPgT8kJFSAPwC9+xorEHlr6xhyrQJWJ+aqxoOEBLQyZMbq + xKIAQsI0IuDqRWFCAoNj/DEgqhtc/VrAyacJQjN6YfKckbh0+aK60agyCLiCLbe6Z6RqIHAYHhBI9KY6 + uEgCGvCXVmyXLlmCxYsWYZEYgTp//jxlc+fNw+zZszB7ltjsOZg1a7ZKcM6cMQMzZs5Qj2fMmI6Z8roy + 2cc5D7S5YvyMhfJ5NBIMZ0qq71q8WN0gpRHBckVQ/G38rRzmZHyve3uCm/+PW/0/8vl3332nYn5en9Ub + FyGzMByDM53hGd8UHRIfVyErw1c6Kz6m9xdbIQ7RlbNn/5bev3J7N8pQR+UGQgzRchLmmYUZjoip4qB3 + s7uRgDZNWJsrQDYlAdAYJrCeIJcQ8x/eBPGTzTBknhty10Qjc9cyJJV+ioxjNzGt5BPs3bIYnywNw41Z + tsCU14BJz4mJApgs2ykvAzMkXJhvhW9XBePA7g2YdPQbpB8F4vaUIXblcMTN80GihAWsM6BGCWiq5sAt + BaDdaiykwNBAkUMXVacgfeFgAf8gJM/qisRp7YVM7MU6SOwvwJ/eUcxFSIDg7y7gz/snwB+C3r37oqd+ + q3HvWyTABUvUykU6CZiUKNdWLrpFBGERsQiPildEMChSUwNO/m8pIogZOgALV83A4bKD+OWXXxQISAg6 + KAiSb7/9toIUuJ8gIRlw5ICJQpIBAUci0AFPQNL4mPMWNBKYj7lzNTDTOFRJ4/wGEsD06QL+6QJ+Phfg + 87XZs2djjhi3c+fNNX6GtqWy4GfzO3Xw8xzzN+mxPYfy9N/N6kr8L/x//F868XE/r8MHVy5j7/5dGDEl + DQEpbhiQaY4BuS3RKbW+9N+aSrFqSWxFADfE6++Xfhsrz182wuN/o6kEYYjhVQGqPU+AAHi92FUd8FWZ + TgKmpt8oRBJQaoCsSnZVDCv7RQ04JWq5gcixzZE11xVDVwYhc9NIJO/eiSwhgDES3y+TsOD4xvH4YVFf + YJYZMP0NYGpDseeBaS/KvteFBFrjxrLu+GBzIVYePIk8IYH4kmuI3bIeCcvSkDynp4QETiLlOXeAk4eY + G6AiIPCpBpgg1BOF2mOuU5Ai5JA8gzMQXYzmikR5TkuQx8nT6Pn/cfBzOK9Hj15aUVJVnVhbtEQrQ+YN + L50IjGGBlhu4tXKRP4mAy5tXhAVcuUjUQJRx5aJID3Qe3AbtB74Ot8D3EZHljWXr5+JI+UEFGP5OnQwI + Ftr333+vAMT9NB7HGJn5AioDelrmDJg4JCDpnWkkAgKYdzASsAQ//yufcz8fc2ITb36iAuC0Zj7WX+Nj + Al4jhpkK6CQUfgcTegxFSEYcuyfo9fCFt1HzN9NYT4Fb/g/+doKev5+kd/L0cezcswWFE5PhE++I/mlm + GJRvjqAxbdEz5zVVzYqynypV9VH26RDDJenXeQJ+s3urws+/sbFQKOsFmIcbgoQM5ogdFQ/+hTpBf2QC + +KryA4oYwjRFQCVAuUWpxVJindPrw6fwLcRPaqNuHc5dGYnMbfORevAssiTGn3r4I+zbsRZX16Tjl0Ue + Iv9bifd/RchAwoMZJAGGBGILW+OzdWHYu2895pR/gbyy35C09yTi1k5B/KJQUQPd1bChulVYzSSsogKR + Uga8qUhIQjx9CglgRicBvdh0N/H6An7x/Cn/JPiDAgPh7uKqKhDpy5d1V8uXsR6hVpSUyoDVibWVjW/l + BvSViwYFSFjAEuUsTGpc1ZjLm4erlYuoCKLhF9UffSId4RzQGNb9nxMieA/ROf0xd9lklB4/iA+vfKB+ + 788//6xAo5MAwaNvCSDWLCAx8D8yn8BwgaTAmYa8oYmkwC1DBoYINIKXICa46clpPAf07iQMXSUwt0DA + U13wM6g2OGav39jE79JzGfwtpr+Jj/Xfqv9ennt6fRICM/+rN4vUHxEB/3Rn9Ix7H36FzRBQ2FotPdc3 + rwkc4utqfVGP+3lLvEh/Af5qcYLuLeIMjxnh8L/ZOoQYHqAEEqA6iKUIQ66Tk3T1T0mAZgQ9wX+bGhAj + 0/KEk3VJAm3Da6Fd7IPwyKiHsFHvIWuWI4Yu9UHmhmFIE/bOOHIVw8t+wtKD53B8yyz8sNxfvL6NgL6J + gL+RmIQFs54G5khosPAd3FjZAZ9sTsauA7swrvwnxB/5CVE7SxC/Mh+Jc3qLlBdJP91eqQGtFiHlvzEs + IAmoIUWNBJQCEPAnTb9FACnT/jnZHxQYhPZWVrBtawEnewd1h6F7p87qNmNFBBWFSTUi0MICbeUivTrx + AB9/rTqx6cpFEhYES1jAlYv03EBoVBSCo4QsonqhZ4QNHAIaou3Ax9HO52UEpncTKZyFvSXbcerscUUC + rE6kkwG9K0HELY2A481LfF1/TiNpMO4mQLkl6PTaBSQJZuPpvZmco4rgY27pyUkgPE8MOfg+fgY/j3Ke + 38Nzyt/A38XH3Mfv5Jb7aXzO36vvP3v+JI4eL8fMxWMRNcQb/ZKs0Tn6dfTOaqzmpPgPb4mgkW0wqKgZ + 3FKeVXKfMb8Cv/RDgl+2u2QbbxlpuLcq+/7/bDb9DA8KUFuIBQr4Z7UOMxwR+8PcAK2yCjA1hgVyoiuI + gPEX7ydwS34aPsNeR9zElsia0xH5q2MxZOdiJAj4M458hRmHLmHfzvX4ZEMebqzwFsBbAvNEDcx+RuxJ + IYHHgbmPAYtewM+rO+L4rgmYXX4NOceB5OILiF07A7ELIkQN9ECygJ91A9S8AI4UKBIwqgEVArB6MRco + cRPwi/QX+2fBHxYZDa+gFHRw6wkbcytYm7WGvZUlnJ2c4Obmjs6sQMTqxMa1CtSCpiYrF7FEecXKRWpB + 09tXLgoM4oIl+vLmGhFwZeOIqBi1chHVQKeIJmgX9jTMfR+FRf+n0DvaGilFQZi7YhL2HtqOq599ooDO + /0KvSmDxMY3Ap/fl6/p+vfGxfh7YCE79Od/DzyKQ2Uwf8zW98Xh9Px/rpoNb/w7+DjYe+9m1q8rzHyzd + i8WrZ2Do2Bj4pzrDM6oZuqe8oswr9w214Gz/gqYC/ObwL2qBnkMawTrqfqVCmaQ2gp/GKb9Mglv/z3v/ + yk3CgYfMAw0NBbB2cpJihQDWCyF8Vhn0pkaQ/xkJ8OSrBAyJgEwcVhO20fehW/pTCBn9LjLnuCBvuR8y + 12cjaftSZO0/jRGl32BByYc4vGspvl4bBiyxFUUgJDBHCGD2A6IGagoJ1BJyqIvfVzTGZ5v7Yve+OZhQ + dhVJR35D1I7DiF9RhJR5/QTgLENmJ55eiIB5ATVESBXAWgS85+AW+FOne/xT4I+MS0Tu5gtIW3sCfjlT + 4Nq9L6zMzGHZsrm2qrFTB0UCndxZeMQDXZUaYHXiW8ub91ElyrWVi1idWK1VMFBIwJgb8B/MeQMSFqjc + gBYWcPUiNVIg5EM14BvVEz0ireAc9jKswh5GS7+aaD3gITj4NUKfGBskFAzCjCVjsPvAVpUfIEC//OpL + BXq96RKcTScLNgLS9Dg2HdB/1vg+/VhTMuFj/fP5vSQWHnv2wimUlBdj0eqZSBruh35xDvCIaQr3qFfg + md4IPbMbodeQV9A751V4DX1d5P5b6D/sHQwQEiAhOCU+ppSn8v6yZR8U+9o4DO5qHPK792f8/f9oTIow + N9CauYEwwwyRUawnyLUEVEmxyqZi/0rAv82Mx/EiUAlw3gBnEnIBErc0Tid+C/GTzTFkTgfkLPND1tZp + SD54EmllP2D8kS+wbd9ufLRZ1MDKbgL4xkICDwkJGIQAjDZfbFFNfL+6CY7tSMbCw8eRcwyI2/8ZYtcv + RPyiSCSIt0+a3k4bBpzhKOBnSMA5AkYCkDCA4B818R8Hf0RsLIZtK8HYc1cw4uhpDNl8BKFjFqO7byRs + bdrDomVLWLdtA4d29tqiJa4sQ9ZNSMBDkYCHyg30rkgQUg3ouQFWJ67IDfiLGmBuwLiqcRBXNQ4WJWBc + 3jyS6xhGRcPfmBvoFNYE9iFPwzr0QZgF10CrQbXQZmAdtPN/Hu6h7yEkyxMjp2di/dYVOHm2HEdPHsHX + 336p/jObDky96eejqvZHRGD6mulnUimwEfgnzpSKvD+F1VsWYdhkOafZfeEW0hQ2AxvANuhxOMc+ja4p + L6jl6HsOeUm2DdEz62X0EiLonfOaEMCb6J//NvoMfQNuqc/CQvoWHY6WkFZ974ZYiTxPahlueMXY1avb + 3ZpJbsBStoMZFsj2cmXw6/anJBCuqQWSgD5vgBfGIqK2Wn/QM7M+gke8jdRpdshe7I2sddlI3b4GaQcu + o6D0ByxUamAxvlrvDyxtAix4UMICIwHMMW4XGPDr0qdwbb0jdhXPwdjyr5B45CZidh9H3OqxSJzbV0sM + qurErD7sJiGCxP5CAKkz/knwx0j4smI1hmyYgIzV8cjeOhJFJaUoOvIl0lYdg0/6eHTo3BMWrVrDslVL + 2FvbooNendi9i7ZyUYUauLVykb6W4d1WLhrkJ2ogIAyDA0UJGNUASSBcSCAsOhpBUQEYGNYdPYMt4BL6 + OtpFSVhgvFZmQTXQ2l+UgV9ttPGpAzvf59Ar2hLBGR4YMTMVo2ZkYsOO5bhw6SwuXj6Hyx+dwxdfXlfn + g96Z1Y71Vhn4P/38o/GRhAk/3Xr87Xff4xuJ5Qn2i1c+wfFzZ3Go9AAmzs9H9hhRL5ld0SPaTCmVtn6P + oOXA2mg9uKbI+PvgHP84uqbVh0fmc2o5eo/M58VekD6jEUGvHAkD8l6Dd+6b6JbxAmwi768Mfo5OfSj9 + d7RSt6J0jd28uv2VxrCAdxiKdBonID4onYhDhlWrAZoAvipCqDxkqMICEoFsuQIRl9jyzm2EyHHNkMEk + IVcC2jwVSftKkXH4a0w8/Bl2FG/FR9sy8PNaRyGCZzTvTzUwy7glGQgR/LSqEU5sj8PikoMYXfoZ8vaf + ks9ahNSlyUie1VPUgLOEBDRXpM3w/KfBn7NuP7LWz0X05I4IHfGGkEx/FBzYjYkfABMuArl7ryBswkpR + A9Gws3OEjTkrD5mjva2NCgtcuFZBZ+YGRA10N1YnVrkBY1hQMVxIEtBXLiIRiBrwC4a/f4hSA5xApEYK + hATCIsRCQhESOBiDI3wxMNUbvfI94ZbdGnbxT926XhowtOsh16H1oNqwHPQkrHyfglNQQ3QSD+wVbYvE + Il8kFPpg+PQUzF4+His2zsXKLXOxYtNclB7n+oU7sWnPchQf3oGDZbuxZd9y8eQLsG3vBizasAhz1q3A + /I0bMXblamROm4qEcfnwG9oPLkFN0G7Qs2g76D5Y+N0PyxDZhmtrTrB/cGEarlDN5ei7ptdH1wwx47Zb + egNFAhoBiAoYKqGBPHaKF+kv/0nF/rJl1l+efythwGYWyG0ebmggXbpa+v+DrYYwaT3pMK2kswyW7ULz + YMMldiBT8NPYmSqeE+xG0OsEoJMAjceQoXmhFGOH1lCLj3RJfwqDixqLp7ZHzuL+yFqdjtRtS5B54CxG + MTdw5EMc3LcQn2/shZvLGtxJAsaw4Nclj+H62jYo3Z6M5SV7MbrsS2TtPorkZTni9d2RPM0BadO7/VPg + D48KR8aShcjZug6J8wR4I5ogdPhbSF4Yi8L95ao0+egTH2J46XEUHLqE9DUn4Zc9HW7dvWBtbgYrs5Zo + Z2MNJ0cnuLhwVWNjbqCbVqaci5Z4KjWgLV+mr2qsr1xUERZQDaibi0IQyLCAaoBLnPv7I3hwIKJSsoXs + liBl41YMnp8Kt6wmimwrrlFVJuAxF5XQNoRkXQNmvg8KSOvAMuARIYjHYT2wHjoEvQr7gOfU8KOrANk1 + 7C04BTYSD/4yukY2hWNgAzj6vwSXsDfhHPcWHKPfhWNsc7RPeB22EfVgHVIHNhFyvZXVFKulwK9ISYzf + axt9P5wTHkUnIQD3tGfQScw99Rl0TntW+kg9dBM14CnhQK+cl4UIXlIOhKNNjPtVrkn7rO/Mgg0HZZsl + fe3de/5W3//rRjVgGWLoKx1lvLArFxm9IhdNLTSqvL9pRzJaVWrA1HihSAAtjPO0OYHIOfEx9MluiIgx + zUUNOGHo8gDx4JORWlyG9JIvMPrwJ9hQvAXntiXgm9WtcHPxA5r314lghtGEDL5a0xrrdsxGwZ7PkXXo + OpJWjVEEkD7VBaP+iem94ZHBiJ8QiJQlrGcYjqgJ7RAxthUS5gYoQhh+6Aryd+9HxppRyNqQj+FHdmDs + 2e8x7MAPiJ66E73DsuDo3Bm2lhZilsbcAFcuEiIQNdC5mzFJqNSARgIcLlTzBrhyEVcs6kcSuDVSwJDA + 3z8YAf6BGCzgD/QbhJDQSCQOn42iXdcw4vR3CF+Wga5ZjQSID8KW6z4K8CpfK3W9TE2uT4UJIejXTM33 + CKpZkd9p5S9hhVw79RkhNWEZWlO+g+AWT85rSlLh3XeDta30IQV+Wy5CK0C3lt9jIZ/JvsDPsJQYvn3c + Q+iYWBeuyU/ALeVJuKQ8pbadUp9WJNA1owE8s0QFZL2ITilPK2K75Uzkc2gi/S1CDOO5OA4XyTF24+r2 + L7QabYMMz0nnMDfmBqaJxzhJEtA7jd6RKltVJKApAo2tmRfQhwv53EY6RefUJ9XNRakz2iN3aT9krUlD + 6uY5SNtTjvzD32F66efYVrwIn2zsCCx5UPP+JIBpYlNJALWwYYwl0guz4ZU9AZFLliFxUQzSpnUW8P+1 + Yh6m4A8T8EeNdEfs1E6IndIJkeMtEDaqKWKndROwz0XBwcvI33cSyUtyETHBHtHTOiBr03CMPHYeY88B + o04AOTuuIqhoETr19IG1hRWsWrdGO0srODk4omNHF7h16nxr0RIVFvS+RQR9hAioCLwqzSIUElCjBRIm + DOrfH4P9AhCZkoshiw6JErmJrOId8JvkJtL5CbgnPQwXAVb72IfU8u53XKfKJtdIt8rXj9dOIwGtdDzN + XJQc38fXrMSs5bEy2W8pZiXHWst7bQXkBD9Vn+nv4PfYyH7mhpwT6goJPF5hruLl3ZKfNBKAhAKZDdQN + aPZCagS9ivt1Agg2/GIRatgmv8+by+P9T8z1/082Jgnl5HaVk1zIdQfFLrcNMfxo2pkqm2ln0juUIgG+ + ZjzGlAxYiJQ3cnjnvYboCS2RMdNOLUOWvX4EUnYfRPLhnzCs/GcsP7gN57YGSOz/GrBQgD9Ts+JhzyAu + up8C9/qdu9A7ti/8cuwxfd4YNSPtHwV/5IhOiJ5kj6iJtogcZ4bwkU0QLgQQN1PIacN8DN2xG2mrJyFi + kguCCl9B+AQHpK8ei4L9ZSg6fAxFR0ow8vglCQuuImbmNvQMSoGDkzts2mqVidvbabkBbXnzbujaxQPd + uvXQJhCpdQy9jIpAHykYYMwN+GEA5w94eWNgn74YHBSJ5AmrMOLQ10KUpxA6N0Ti5EbwSH9M7El0F+/Z + SYDkQDUQVUvF25wvr65RZTO5Vn9kPEa/fjTuo8rgUvN20ffBLuYBsfvRzmh2BL/s5yrUFkY1wu8jGdhF + PygEVQdOcY+iQ8JjQgSPoaOYi/QFNyGBzqkSBqTVEzXwFBzjH5b3a4U99O8WIrohdoKl8UV9vGfsstXt + 39qEUcmswvLNGRYI+MeKEigRYviJF/MPzdhh2Elu5QXY2bTXyeI6CbQR6WkrXqJz6hOiBt5AyjRb5Czo + gawVsUjZPBcpxeeQXfobppR+gt17JuHaejtRA/fjUN59yAh3UeDW2+z509GzrzvGjBnzT4DfDdET26uF + QKMmWAsBmCN8TAux1oie0hUJ8yMRvyAakVO7IXhkU4SMbonEhQnI3VmM/L1lQgyjEM+6BGsyUVBSjBHH + vkT2lg8QPHwJOvceBBsLC1i3ETVgreUGXF3d4K5WNaYa4IKmxtwAk4TqvgLjLEIhAW+GBlzctGdvIYH+ + CE0uRP6WDzH63PeIX5OPvsPegqeAv0fGU+ghXpNDaR6ydU8WLxvHeg51YZ/wjBqVMQW/fr1M9+mEoJtO + ADT9+iklYDye5MIhX4KdHt8uWohATEl/LjZL8Mt7eTzzAAwH+Lp9zENCUHUE4I/CSX4fiaCjhIYuQgCU + /O4pzyiFYC2fLX1Oma5CmPUXIhgnn+kkIUFdY4+tbv+/WrtQQz1hWmchgUw56Zt4s4VckJ9VHCYXpCqr + 3HlMO5EeDzKeUzdyiLGjdEh6DH1yX0bY6HeROs0aOYu9MXTDaKTtO4akwzcwsuQqNu1bjJWTvJAa6anA + zcbhJ85zP3bsqLphJScnR91Tr7c/Bn8QIoscRYHYqOW/SAJRE+3UQiBR44UIxpIM7EXyt0fo2LYIGtEE + QSPfRfSMXkoVFOy/iOytmxE+1RN+wxoifJIjcrbPx/hL32LSFaDo4DeImbEJPYPj0d7RGVZmrWHDlYus + RQ20d4Cri6uogS6KBLp219TArZuLmBvwRs8ePdGzuwd6C0H4BEQgZcY2jDl1E3mH92HwVDcB/yPwSHkE + PbMIfo6lvyixc310T62DzskPoEdBK3hN6I3OuTYivRsIKd+ZKKxMAlXdD6JdPzHje/Trr65ppEh/ATfN + RuJ1bq0ia6r3aIRBZ1BL9gtRCOHzjtJbJPAInCRs6SAEwFDAJelJpQp4DPMR6i4/en6tz/woBLBdnnsZ + S3xVt/9EaxNheJITiDjcIhdijFz8o8wNmHYiU2Mnqdx5dKMqYEdix1AxnSgBbjmL0CrqPukAdTEw/xUk + TLYSNdALOatTkMobQ3YfQcystQhIyDRC+xb4OYedt5nyxhQW6JwwYYKa08655rztlGW0qvL84UX2asmv + qPGWAnobzSQEiFJKQGw8k4A2QkptlOcPGvEWwoQY4ueFIGPdbAzZvBaJi7MQOMoM/oVvIma2v4QKGzCi + /AJGlp/F8COnUHj4A2Rx5aJhc1RuwMq8LSxaNIetuTkc27WDS8eOcOukLW/OIUPtLkPtnoIePUUZdOmM + 7q6u8Orjg6i8mSL9v8XwEx8hekkS+hW+ix7i/T0l/u/FrLmYZ2Y9CQWegIcoAq+CdxCxYihSd25H2MwR + 6JniCIfQekLCf5wfuBsB6FZBAkZTJCAkTiK3FJlP046j9+eWZFBLhQQ6CehKgPkAh3ghggQhAvH6jgmP + ShjxkPoM1UeMBCBE8JOA/7hYgTihZtVx//9BkwtRTy5AB7noeUIE20QJXJaLUWVuQHUmdgITM+1ETBpp + SSaNAKgG9HqEXKWoZ/aLCnSpEhbkLuorj0PhHRVthP7t4GcRSd6iykKbiYmJEjMPUDX5WXiCnp/EoIM/ + Pj4e4TExCJudi/CZfRCh1v0zV0TALUOAqAlUARoJRIwjAViI7G+FYJH+4RMdETvTR0KCeMTNC5fnrgga + 1QpRM/oia/NKDNsvYcu2DUhcmiYWg6F7l2Ps+e8x8uhPSJx3BF7huejg1gO2ltZKDbRTC5q2h4uoAU4n + 7tJF1IC6r0DIoGtndHFzRXcJF/zCs5C74TLGXfhNwqNpGDjSEr2HPC+e/xnx+A3QK/tlRQDd0x5Ht9SH + 0Sv/VYQujEDekZMYvv9zJE+aD7/YfvAIaoEOwc/DNvTRO4igggCMZnq9Kl8/dU1N3qMZ9+lW87bnDAG0 + kEFTCZzUYxfzoLqRzD7OSARi7WQfj+H3K8lv9P7SL66JCp0parQr+6GxS1a3/3RjhRUy8G25gVAJCeRi + 3dUE4ByDbusvnaGvdIYBNWDlKyTgxeey308usrdcZC+xgXKsHGc9qBacQuqgf87L8E1+D77h3YzQvxP8 + vD1VB/+gQYPQq1cvVYk3PT1dqQHes87XtTr90Ri5bicSSj5BxKaliJgbINLdHuHjJe4XEogY1xZR4yzE + rMRsRAHYIkxCgdCxlmIWCBtnJ6TRQYDfUZ7biCp4HyFjrJC0ZIiEBOdRcPAjJC4bDv+RLeBX2Ahxi4NR + dPQUJn8EjDsH5O74FJGT16FHUBJsbR1g/v57sGnbBo7t28O5A6cTu6OTKAI38fqdOnZA506d0dc3DAmT + NmHMCWDYkcMImt5bwP8ceqQ9gZ4S7+vevydn1KU+hm7pdeEz0QmZxVsx6ujPoqT2IzatAMHBAfAL6gnv + UCd0CXsf9mFPK6BWec3EFKh1sBuBX9nuTgC3XlMjCnKsJUlAjMlApQZECajcQcwDCvjtRBUwfOB7K36H + gJ/WJthQahlq8LMKNzTg7e7G7ljd/q8aWZi5Abk4GWLr5GJVXZ2YS44LyM3aG/Bemxp4v1kNNH6rBpq2 + qIlmzWrivXfEWtZCM7PaaNWqFprTLO5DS+taaN22NizaP4imrR8xQh+4cePXPwR/376iFoKDkZmZiaFD + h6oFOXr06KHKcseEB+LMJDccXZODWSWXkFb+E6J27UX40gyETfdAmHj88LGtETG6uVhLMSGFsVYCeiEB + IYNQeUwSCBltJoqkOQKHvyPWBMFCBAkLk8Xzb0bmxuUIn+aFAUOfhW/+y4idH41hB45hzJnvMfrUZQw/ + Woq8A+WiDvZhQOo4dOjUCzYWVrC1soKdWHtbWzjZ28OpnQ2c29nBo9cARBQuFC/+HUae+BSxy9NF+r+j + En+eQgC9sl4Qewk9MkT6i/fvnvYY+hY2RczqYRh56hsUbfsUCblTEBIcgRA/IbvgMIRGBcEnSkKNyDZw + Dn8J7cIeh1XY/bdft0qmwFwJ/IoAaPrrVYL/zvcoImC4EFlLJQttJPSjEfwqRDR5v3z3Telr37UNNWwW + AujJcNTYBavb/3XjxRAl0ISyTOSaVp042KQ6sb90gE4GvPGmAc8/UwMP1K6JRx+phboP3YeHH3oAdes+ + hGefeBjPPPEInnryCbz4/ON4qf6TeLHBs2jUqB7eePUZvPFSPbzd8CmMHBKLi2dO4NOrV3Hi+HFVcaYq + 8LNcF4HP11jwgmGAj48PvHp2w6mYOkB2Tfw2+gVcXBqEJcVHkH0SiCn9AuEbFiJ01iCEjhNvP6q5yH6O + ApiJtREFYGFUAJoKCJH9waNaKO+vbIwQxZRuiJk9GBFTPBEw/D34F72LqJmDMWTLJlEFlzBkxwbEL41C + 7OKByNw2DUXlVyRc+ArRU7fB0y8O7R1dYNm6NSxbNId16xawbd0MTnb2GBCeg9xNVzHxMpC+Yy58RW30 + oOyXGL9XZn3x/Lx55kXx/HXRNfkB9Mx5AWHzQ5B/5ARGlXyHtCnrEBqRhMG+fggc5I+wkHB1c1FYTAQG + Rw9E/0g3eIS3RIew52EZpo0UVFy/SlYZ1KbqQJGDAFe9Vum4u5lGBKIG9LyBkTxMv0+2N42OpVxIYBid + DhPTxi5Y3f4bWpXVif0M31s4G/DScwYBfg0YatRE7dq1ULP2/aj9wIN4+OGH8VCdR1Dn0cfwxBNP4qmn + n8bTz9ZHvedewIsvvICXGr6Mhq++gddefx1vvv4qmr/5PHKTI3BMwH+g5Ajmzp1XJfg5CkDwkyBYOZft + iMjm2E6v4dcYA37jeoZcuGR4HXw6xxVbdqzChOO/IuPoLwjfshlBCzMQOq0PwidIWDCmNUJHvqcIIVSI + gODXiSBkTFtRAm0QLBY4shUGi+QPGP4ufHOfE3seYZO6IWPjMhSWfIqcnaIypvdHv+zH4FPwMpJW52H0 + 6WuYfAUYc/JnpK4ow4DkkXDz7A9rC0uYvf0WLN5/F+5dvSQMWauk//CTZxA2bwB6ZzdQib9eWc/JYy3u + 5/Bf99RHlPf3He+A7OJNGHvqpposFBqfhUE+/vAbOAiD/QaLOgrXypBFxWpEEB0Gv6g+6BVpC5fw10QN + PCFqoOopxToBKBMA30EAFaYdYwr2qozeniTA/ID6DBPw699nkgP4WULJwww7GX5yiLp6EtB/UdOrEwv4 + Xc37GUZb2BsuvVjfcLOGoQZq1KyJmrVq4b777sODD2rgryPgr1u3roD/CQX+evXq4bnnnsMLL7yIhgL+ + V159FW+88QbeatwYbzV5B02aNIF1y8ZICvPBnFkzMGrU6D8EP2vLsxwW29dff4VZWf4ocnoYn0vnvMnV + i4aIDauFHyY2xfllEVi1dw+GnvgNUaXfI3LzakTMC5eQwF6kfjMxxvmthATMjEQg4CcBjLEQAmirCEB5 + /YI34TO0HnzzGooi8ELG+mUC/n2IXzIUvsPeQJ8UAwJGWSJz0xKMOv45Rql7CspRdOQ8cnddRsy0LfAY + FCPhQHs4OnSGb+JoDN16CSOPf4jENfkYKCTTk2P+6U+i95AX0TvnZTX855nxNDwzn4V34fuIW1OE0ee/ + Q9Hu64jImoAB/TmJqC8GDfCFv1+gVqY8VMKBcBYljUZEZCzCoyMQxHqEUd1EDZjBKew5UQNVhwSVScAU + 0FWTwV+w2yV/hRH4vIFITQEWaxVk+LE1J6WFGrZykpoog65i/1uFP//bW9vmhlctmxom1H/C8IVBwF9T + wF9LwH+/CfgfeeQW+J++DfwvCPgb4lUj+BsL+N955x289957aNasGZq88Spavl4Pg3o4Iy46UhXS8Pb2 + rhL8HALUwP+1KjvN4cDh2Uk46CMEkCzgJwlwHcMseV70CK7PdsT+rTMx5djXyGRYsKcUoUvzETi5q5L4 + IUIEISOaInjEu+L5WyBkrOwTRRAsRBA4sg0GjyAJNINf4VsYVNgEIRPcELcgFbFiQeOdMUBUwSAJCxKW + 5qFw/wUUHvwA6eunCzlEI33zGIw4dgbDy75D4vxS+CTPQEDGQmSuFPAf+xLp8rsGjbUV0DdALwF7r4z6 + 8vhlUQAN4Zn+lPL+XsPeRPiCEBSeOIdRR28gfvxq+AREwatHL3j37g0fUQB+vNXYWJSUaxWEhEQiNEyr + PkQ1wLUK/KO8lBpwDX9dqQHLu6gBGgGrJ/ho/ygBVBxv/CxTEuDsRRJA88EGvBegWfNAjQgk3LwhSuCk + bKfJ88HyHnNOY5fuV3034P9la/ui4TmrFw3x9esYLpqC39Tz/zPgb968OVpLfGxmboE2bczRvu376Nmp + PfoK+COjY7SYf/bsO8DPOnWcFKRXw43pY4kyiXNVCMC1DPVVjdVahjVxY8xLuLzIF6uL96HgFBBb9g1C + Nq1C8OxgBI+1RqAQwOAR7yBoVDMEjW6lLHBUazEhAEUCZhg8vAX8hQgGj7YU4HdQHt8n/3UMEoUQOXsw + srdvRdHBK8jauBahk3pKSPAGQqZ1Qub2+UICn2HkUaBg7w0U7ftVSf+8A4cQMtNbvH19AXtdkf4NBPwN + 0YfyP+t5eKY9CQ/ZP2iiE4Ye2qZGGtLmFcMnNAF9WISkR2949+mLgbzLUBQA1yrwUxWIjGsVkAiMhUfC + I2IRGqWpAZ8oD3hEtBE18Lx4aG1YriojYBnz3wZoscpgr8qqAj+Nn+uWWh8eqvzXw2jia8BbAw1o6qcN + FXMWqQD/hijOK0ISxfJ4vIQHfXlDm7ErVrf/dKsA/8OG8/8/wG9ubg5LS0tYWtvAsq0ZHNo0gXfndsjJ + TFMlre8Gft4UxPr0ngP9MSo3Ep/N7YJfxzTQ1i7MEOOCpjQSAZ/n3YcvprfFni1zMOPoNQw5DkTuOorA + JcMQMMUTg8daicdvhsDhbyNAyGDwyOZiAnwSgLLWsr8l/EY0h2/h2xgg4cCA3JcQMMYKMfNikL5hITI2 + LEbU7HAMzH8D/XIaIHhKD6Stn4v84nIML/8Qo09xUdNrKDh8HAnL8+EzvDV6ZnDCj8T+Iv375DRS4O+R + 8YzE/8+ib0FTxKzMxOhz3yF/61UMTixCDwG+R7du6N2zJ7y9+qlFS1VRUr06sfFWY65VoCoQsQxZaJQi + AlYnjoiOgl90X/QUNdAx/FVjbuCBOwiAVgFeHdRGqwr0tNuOM32/GJOBHZOeRtxUV4xfG4nEGe5wSa6H + FoE1FAE09TeoJcB4hylDA5Uj0G5hX2ip3dLeiiNU0iWr1cB/qv2nwG9jY4127dqhvYMj7NvZoXsHa2TE + hmDnjp345LPrFaWoKoPffWA/9B23BIXHbmDZ/nKcWB6P77iOYV4tDfRUAroxLMgz4MdxL+PDhT7YuGsz + Co//hsjyrxC8ZbOogVAECpgDipqIp2+KABLAiBbi+bVtgCKAVvAb/r4QQGMMHPa6ePm34C/kEDKxK8Kn + +yBsSm/4FrVEXwG//1gHpKyZhby95cjcugEJKwsQzyXUV2YjemEcAid0Rr/cxgL4emIi/VkkQ2J/z3Tx + /Cl10DvvFYTODxTvvx8FxZ8jauQKeA0IQTf3zujW2V1NJdbXKuDKRdqtxlzC7FZh0sHGwiOsORASyiSh + toSZWrko2g8DIrvCI9wcHcJegnXYw1WSwG1mAvDK4Kfpr1X1XseExxE6zhYzt6Rh36kl2Fw6HROECAaP + aQOb6IcVCbwzyID3JTSgGjDmB24KCVxtG2w4KAQwrk2IwbM6N/Afav8p8Ftba+B3cHBAhw4d0KGjm5pG + 69PDDXMnFOCLa1cF+jdVzH8b+HvaoF9KJ6RuWYjYwx8jRWT1tJKPULx+PK7OcsEvo54HhtaoOizIr4kv + RQ0c2jwJs8s+UPUIY3aVI2hxLvwnewh4bUXitxYieAf+BHnhOwiQEIAE4C9kMEhIgNJ/UBHtffgVNYNv + wbuiCl5H3+wG6J//JiLnxiBv30kMO/gB4pcVwWdEG/TLfw0D5fiB8lmsiNt36Bsi+RvBS6xPziuiAl5Q + 8/+7Jz8E3wn2yD6wBqOOf4v4advQNyABXbt4oourG7p36YKePXvdqk6sSEC71VhVJzaSgKo3oHIDIQgK + MSYJjUVJIzhSEBkOvygJQyLbo1PE22gf9oyogQerBPBtpkYD/jr4aS7JzyJ1VjesPTgOpz/aicvXSnD8 + g61YeWAkkmd1Rqf059FGQpJmQgAkAW6ZG1DVhkgGoYbLbcIMs0QZBAg5tBF74X92gZD/3+3/CvwuLi7o + 1KkT3N3d4e7qjAifHti1ZgG++PwaLl7+AFskHCD423duDjf/F5E8uR0yFgxE8pphiN21A6lHvsCosu+x + fO8hHFuZjm+ntAAKH9BGBqgA9LBAhQQ18Ou4hvhkfk/s2roQE0q/QkLp9wjatgsBC1IQMN4JfiL1Bw17 + DX4kgaJ3xd4Xa6bCgEGKCGQrJMCQYGDeq+g39CWxl+ErYI+Wz8jevhsZG9ciaHJv9GaSL62OgL0B+ua+ + DK+hrwgBCGHk0F6T+P8l9BQl0EOO88p7E7ErUjHq1BXkbb8Cn5gCuHRwh7MoJHcSQDcPtYqRfqsx6w3w + VmMSQV8uYSYkwNuNtcIj+qrGoggqr1wkRBAeFYmgaGN14ggrCQskPv8rakBMJ4EK8AsxVHUc7xuwj30E + g0ebY8aWZBw4uxyXrh3Eh18cwemPd2L3qQWYujkBIeOt4ZTwBJoJ8N/2NeA9CQtUboCKINhws3Wo4WNR + BfuEBMYJIQwQNdC4mgT+ze3/GvxdxLt1kxi3k7qJphsSw/wxb8oo8fybsWTZcrR2bop3utVSdef6576q + ZvelTHVA2qLBSN4wFYnFJ5FR9iMmihrYuWU+Pl7QF7+Me015feX9SQB6SMDnQyUsGP8qTq5Kw+LDF5Bz + Coja/wECl4+D32RP+I00U9n/QQVvKCLwK2oqwG8mZiQAhgRCDj5CAj7DmkhY8I68xxKh0/ojen4ywmcE + waeoNfpkPYs+QySuH9oQfYUs+ua+JvaGUgFeQgA9MwX8Eg70K2yGiHkRGLp3D/L3fozwkcvg1tkL1i1a + oL2VJTq5uaMrbzVWhUn1CkTGJcxEDbAUWV9WJ2bhkYqVi7igqSiCAK5cdCs3oFcnDldDhsbqxFFCMkoN + PHvX3ICpqdl9OvirIADG8vqQn0NCXTk3LVGwzAerDo5C6cW1QgQH8NGXZTjz6R6sPzIJ2XK9emS/Jp9b + q2KU4H3jSAE/Q0IBTj+/JJ+7VMggsnW4oZ2qgVldOPRfb/8t4OcU3969efusdPCunTGguxMyY4Ng7fo2 + 3nTXOgLvQuMc884pT4pMfwNxEy2QJBIzYUkc4jcvQvKBiygo/wkLDp5BiSiEr6eZA0UPaWpADwloVANC + AjfHPIMv5nfHvu1LMbb8B8QdvYkwUQNBc6PgP8ZKvPxbmhW9LfaO0ZqKiQIQZaCs8F0VCgwqEnIQFeA7 + wgIDC1uK9H9LgP6yWCN4E/gMFfIE/EIAXiSA7FfRM+NZpQD8J3VG5vbVKCr5CmnLTqFfVD7srNrBrPEb + sGnVAs6OHeDWqcsdFYgqVi5iWGBUA/36SUigVi4aZKxOLGpAhQV6bsCYJNTXKhA1EKzUgLZyEdcq+Ktq + 4G5GAmB2n8N+TPC1Da8N5+SnETzOElM3xaP45CJcuFqMD68fwSlRA3tOLcS8HUMQPcUJTolPKOC/46ep + Ad5YJqCHWZDhd1EDn0k/OCwqYJaogUCxFlwsx9iVq9s/2v6bwM+bfry8vNRcgD59vSXe7YHOTs3RuIPW + odgJlFcR47xz58S6Ej8/rwqTxk2yQsr8fkhePxGx+08ipewHUQNXsH3bEny4cICogZeB3Bq3QgJdCeSI + FdXGT9PNcXz9aCw68jHyTwKxxecRsGwEBk7qjoGjBNQC/IHDXsXA/IayfU099xVF4CuhwSBFAE3hk98E + /Vn2OqchvAl6AXu//Mbol/eWRgb5b6qFMbxy31SLYnjlkACeERVQz0gAazH88HfIXHMRfllT4dLFCxbN + W6DN241hbdYKju0d4NLJXVRSd+PKRfryZbevXOTVl7UIuXKRD/r7iCIwSRAGcKRAiGBwxZAhy5RrScKI + aK5cNBB9IkQNhGtqwDrsoSoB/mfGW4qpEnitmosnf5dgFjKwinoAfeS85MzvjeX7ilByfhUufrYfV74Q + NfDJbmwsm4qhi73hmf0KWofWVElCvvd9IQKSgio8w5ECLovHe1ZCDSlCAg5MErJEvrFbV7e/0v7bwM8b + fTgLsH///sp69umLdpavw7IHp5ZKx+KFNxKBXHTpaNrKRZ1SnhAZ/gZiJlgiZU4PJCwVNbBxDjKECIrE + q88rOY8j64fj26lmQIGogSwj+LmlMnYYgvwAAE3zSURBVBAlgML78PvEV/HZEj/s2bUJE8u/Q3zZT/Df + vge+81PgO8YO/fNfkfDjeQzIaySSX5P9NF+jMRRgQtBb4nzv3NcV+PsPe1sthNFfyIHLYvXNo2kk0Gfo + 6+iV2UDF/94FzRE5PwFD9+wXEvgKQzZcQnDREnTpMxjWbczR5t2msjWDQ/v26Mi1ClQFou4SFrDwiMnK + RcYyZKxApAqT9mcpMiEBlRuQkIBqgIVJGRYEhkhYECpqILxiQdOwyCiERAViUFRv9IqwUxOIrMMeuQPg + f2Rt5dpYs4owqwiJYmOlKMbzVAI6iDk6ECwKa9L6WOwV739BSODy5yUqJNh3dhlmbE1F6AQ7Oe4JBf4m + PtqQoZ4gZGER+ZwvpE+wlsUc8xBDEGtcVN9Z+BfbfzP4Bw4cqKyfPHa2eweWnjVhwXoDEnNyphpJgOGA + XlNeX6ugd/ZLogaaIGZcayTN6I6UVQVI3HcEyUd/xNjS69ixbSk+XeCNG+MbCRHU1rw/CSDbSALDxMY8 + jh9mOeDkhrFYcvhD5J8AYvZ/iMErJmDg5J4YMKIFBgx7EwPyX8fAXFEEeW8K8N8WIhAFUPC2KIQmAvy3 + K0wRgBBDP7VfIwAvRQBvCQG8qaYA90h/SkjgWfiMskPS2gkYc+YrTL4sP7H4G0RNXo/eQUlo79ARbVu1 + hKUoAXsbkekMCVzd0bkzScBYeIRqQFUg0qsTiyLw7nd7UVKfAJUfUEuYBXDIkBOIbpGAmjcQGavmDgyO + 8kXfKBd0jngPDmH1/1pYQGKWa8Ly4QzVbMXj8+Yg1gIUr62Se+8KkJntt416UM5HEwxd2Bcr9o/E4fOr + tbDgi8M4+fEOrDs8CbmLRNHkNpbPeEjNF2BIQGPCkCXF+Z1tRQ0I6ayXfhEr32/fNsTwKu9nMXb16la5 + /beDn3f7+fqynPZAdGzfHG271BCvot9soiWf2JlUSCDG4SLegGIXdT9cJSzwHvICwkY2Q8JUV8QvCkes + qIHEA5eQd+w3LDx4DmVrivD1DFtg1ONAvoCek4h0KyQJ1MWv083w+bIIHNq+CjOPXEO6hBRhu0sQsChT + 1EA7IYA3RQ00UpKfjwcOe0tCAM4TeBsDCt4V0DetAH//YRIGyGsMBfoK8Al+pQDEVM2/9CfhKQQwcIQd + ElaOwojySxh//juMPHYduXvPInXFAQQMlZDAsz8szNrAsmVL2FtZG1cuYuERrlzUrWKtgttyA737avMG + TFYu4kiBj2lYMDhYSCCkYuUifTpxeFQMgqNFLUTL+yMc4Bb2BmxD764GVLFSuRYCQAG3Vi/QTkCulxWz + jNSmA1MJtBACoCpg/YKOyU8jZLwVpm2Mxz5RA+c+3S2KoBjHr2xD8ZllWLq3AJlzPOGR2RAt5b2NRQ0w + P6AnCJUqDDV8KargiGznmYcbokUxWr0bZahj7PLVTW/3Avh5Q5Cfn58ogAFwad8CFp1rqXjyjvFn2Uci + IAHouQFWxWFtuu5p9eCb/xoixrZEwixPxIkaiNpVjGSR1+MOXcWWbavxwbIo/DDDChhbT9xtDTVhSBEC + SWDkg8CEl/HLHBdcWF+I9YeOY9yJm0g8/AUGr5mPgVMkTBluJtL+dfQf2lDsRQwQ6d9fgM6xflMC6Gck + AG8Bfl/x+jQvMYYAPbKeU/P/+w7jKEASsrZtkzCgBGkbF6vfnLplOgqOnEDB/i8QN2s/eocMgZNzV9hZ + WsOubVvjykVCBMbqxMwN6Eub60uY9TYuaKqtaizKaqC+cpFOAkY1oE8nVglCDhkacwOiBriEWb8wZ3QO + eQeOofVhG/G4XANjBSIBoD4kSPlvKdfFNuo+Ab+mAFhOnKXDrFRhUbmWQuYsHUcC0Mf9rYUs+ua/hbzF + /RTg955chNNXduDK9VJcunZIwoTFagKR34hW8pmPqLBA5QcYFpBM5PPYD+T3XBfbIaSQK8/dhBBe541t + xu7/v93uJfBz692vHzo6CAG411SdxpQATI1TThUJiFEVtJFjWYHWRdSAV05DBI9qjugpjoiaNxCRa8Yg + fs8R5B35DjNLv8TeHesl7vfH75NeB0bcJ0Qg4KcNFxt1PzCuHm5Oa46vlviibNtCzC3/Bqknf0fg3lPw + WZiD/qNsJeZ/AV5ZEsfnvCBe/jUB+1vK+isT8CsCaGJCANooQJ+cV1X8z+m/ARM9kbltCwoPX0PK+uUY + OLqDeLxn4Du+PbJ2rcGkD4CJFyVS2foJggvmo2sff1WGzLJFM9hamMOxPdcq0HIDrEWo1AALk6okobZW + gbZOAYcLK69cRCIIMBJBMAICOW9AiCA0XBGBShLKNijYB35hvdAvzl0UixM6pL6pSX4SgICe4LeS62Ej + 554EwFqBCvxGAuD6garAaIRWXozXjCTARWhpvH5OCU+qeQNjV4ViW9kMnP1oNz78/DDOXd2HQxIirCge + idyFXvDIaqRCgjf6a4qAREISYG5InMI3QgBnpC8sl+fxbYINFv/zIcG9Bn4+581BHe1bw9LtjwlANyYK + KQcZG7IjWEpnYxntbhn1VeIudFQTxE51QOzSRERv34rY0u8wTMKCtcUluLA2F9/PdROUNRLvL0RAAhhB + JVAbGP2wqIEXcGO2Iz5YPxybSi9ixDkg5sjX8F85A/0meMJL4n2vnBfRN/s59M15SY0C9MtjIvBNRQZM + AHpLLKt5f50AXlEEwFoAQVP6ifffipw9pQibHYsuSXXgJP+h77BWSN+0AuPO/YRxl1hA9DKG7j6OmOlr + 4RWWDscO7rCSc2/N6sQ2tujgyJWLNDWgr1zEoqSenkICFbkB05WLRA2ouQODJOzyl3NPEghRJKBGCkLC + Vc2BYCGHYLk2YVERCCvIRMCkJHQd1l489yMKzJT+FvJ7SbwMxW4Dv5EAWDZMlQ8TU8VD1HXTrhUJQPfo + beX1njmvI3O2JxZsy8bu4/MlHNiC8xIWnP5kD/ZLWDBjU5IadrUIf7BiOjG3nDvA3BA/UxTht0JOeyQk + GSr9oos4ijeFZP73So/fi+Dn/j59vOBs3wptXbXYUoszjVLTaDr4tdyAdgw9iR4bsjoxO6Vz/INq/j1v + +omcZIvI2d4IX1GEyF0lyJb4fmbZV9i5ews+XhaJm1ObAWOeEAXwgJgQgCKBOsCkhsAcO3y/MgLHdy3D + 7PIvkXYMCN9ZBr956fAeYSWgflGb9UcSyH1FLZTircb/jfG/IoDXlfUZ+ip6Cvh5I5DPSHuEz41H+JwY + eBe1EgJ4QMIDCWHmZiB3bznyDhxDwobxiFwWh+RN05B/4CRytp5H+JiV6NYvBDZUAy1biBqwUGrAxcUN + bu7avAFNDfRSuQE1gUhCAn3lIi89LKi4r0BIgLMI/YPgN5hqwLiM2UBfBAlBxKUUYNjKExh35iYSti2C + q/xGSznPNGs5/1zKTJP+JACj1xdjoraCACR0MCUAXieO9XMqsJoAJCRAZdA+ri4GDW+JkcsHY8ORiSi9 + tAGnPt6FYx9uxcGzK7C+ZDyGLR4Az6xXVF6BdxhytIAkoNSA1g++Mw82nBV1skbIIL51uMHqf0oN3Kvg + 5+u9evVGB/uWsHCRWNNIABUmnaeqctcMB/i6Ar+YvgAlX3OMewRd054RcL6g5g6wXHjMgmhE8aadki9R + VP4zVh84gfMbxuHnBT2BaUIE4+sJ+B8SQhAyGFdXSKA+MPUt/DrfHRc3jcS6I2cx9sRvSDx4HX6r5qHv + xD7ok/+uALwR+mQ/L2TwnCiDl9Sy2JwEpMb/jQTgNfQ19MpuiJ5DXhAykLChsLVKDHZPexS95fVwUQLZ + u0uRt/88YpaOQO/89+AhnxcyLwhFR09j0ofy04SAUhaUwjsiF46ObrBo1RLWXNDU2gqOci1cuGiJe1d0 + NZYo11Yu6q1NJ+YsQiECr763bi5iklBPEPJWY19fUQYDRfoLOYQERyF19EKMPfwLis5cQ+8Joj7kXCvP + r9YP1Ly/WkzESABabUCNAKjImAPg0KBWOegWaTOXQ9Km96acp0d/W8w8rLaci9eQPb8XFuzIwVYJC/af + XY7yy5twXIhgz4mFmL4xESFjLNE+9gmlIBr7GocM5XOMeQHaD1QDsk1ntStRB42MEPn7tnsZ/DyuR4+e + cLIzg4WzEIB0DOOFvGXSge5W855EoHID0jm1eQM8jotZSFgQ+6CA7Gn4D3sTkeMtETmjNyKWFSFh50Hk + lX+P6Ud/wO59+/DZ6jT8PtsemPyqhADPChmIKpjwuNjTat/vc63x5aowlO1egYVl1zCk/HcEizz3WVSI + /mOc0VuA3yvrGQH5cwLwl8V4808jIYRX1CSgPiJze8vjnlw6O/tltQhIt9Q66Jp8PwaMsEbiqqnI2XsM + SWsXov9IAXOMQRFYxPxkDDt8CqNPfY1Rp7/CyPKvkL3pAkKLFqJzbz/YtLUQNdBctuZwsLdHR2cXuLlx + yLBrxVoF2qrG+vLmXujj5S0k0F/lBjhkqHIDPn4Y0NcbA8UCAkIRO2Qshq09iTGnf0b0xslwTHoS5gIy + en9tWTGT1YR0BcDY3+j9bxEAvb9GABVLzZEIjGqA3pvgpRogmDns55L8HBKmumDO1nRsK5+JfaeXKhVw + 4OxKIYFFQtxjMXpViJpybCNhiQoJxKgsWvPzxcxYi1BIQL4jUYjB0wiTv2e718HP4z08POFgZ3azrUOt + 36okABOrigQ00zqYigmFCGhMWnGlGvfkpyRmFzVQIN52nC2i50ciZvMqxB76BHll32PV/uM4s3kavl0W + iJtz2onnf0MjgnEkApLA88DM9/DLkh64smkUdh08iqknfkbqke8RtH4t+k0ehF7DmqGXgL+3qIFeQ1j3 + 73m1mjLj/z45ogCECHplN1IE0GPI8+iWVlfVAuw/3BLh81IQvbgAfhP6qHX23ZPqwGdMZ6RvXIv8/WeR + tmUtYlcXInnrNOSVlKJg/2dIWXQUPknj4NqtL2ytbGAj16mdlaiB9u3h0lEbMuzSrbu2cpEnVy7SZhL2 + 6i3KxasvvDhvgGpArH+//ujXuzcGyP6Q6AxkzSvGGNZb3L8T3UWtcCFRC7kuXEBU8/wP3kYAFXG/0UzB + f0sBkKyFyPXraNzSSARviKx/rhcVQQ34FL6PqRvjsPHIJGwtn4HtR2di57H5KBYyYIKw+PQyuWajkb2g + N7pnvSzEr91lqKYSyzXnZwoJXJPrP0ceJxuh8vdrfwfw831d5TPsrVr+auFQ66rZYMOvese4m6nOZGLs + YFqcqXUwfd4AO0Mb6XRWEbXVopvdU5+Cb/7rqi5g2DRPhCxKRuTmNcg8fB1Tyn/E5uJDuLI2F7/P7yxh + QVMJA14CJkooMOkZYIpGAjcXdMRP4oE+2D4Dqw9fQC7vKdh3ET6LR6PvaEdtbfysehLz11PTl1kIRKv/ + T/Br1jObKwHVV9Ynrwn6CQl4FbSGR+aL6JL8BPoMa64IIf/ABeTsPoLgmeHw5B2Go1ogenUuCssuY+IF + YNSRnxA/cyd6BCbAzs4BFi3FK4oacKQa4KrG7p3hrs8b6N7TuIRZLwkJ5LyLElBTiiVE6CMhWF/Z5+Mz + GDHDZmHk/m8x4uxXGDjbXyS/gFiAZSPntmLMXwjAVrY2tAoCuEUCdyUAmpEElHIjaYvxWjGuf6G3hAUB + tZXMn7c9C5tLpwgJTMbGw5Ow+cg0IYE5KD61WBTBShw5v1aFBWNXh6Jr5ktqpEDlBOSzGGbId3CYcK6Q + QIoRLn+v9ncBP9/fyd0dthYtf7awqLnTPNCwWS5c1WsVVDaTjqWpAJ0EjPMGTNWA7OOKNlzKukdGffjm + NZKO1hLhM70RtnY6og5cFml/A4sPXcCZrXPx/YpwYK4TMF2IgOCfIopgqmynSZgwS/YtcsG1DVnYffAA + pp28gbSynxAgasBrykD0GPYePFn5J5NlwGm8EegFYwhgJAF57Jn1opDAc+ie/hQ6Jz2ATgm1JTR4Gv1G + 2CF6SSEyt21H7PJx6JXfAk5RBnTJfBZhCxKRd/AYJlz6AeMvf438g2cQN28DBiQWwtWjP2yt7WDdpg3s + rCyNuYFO6KTmDWhDhmo6sSiBHr0ZevWBZ9fu8JRr6eXVH8EJechZcUyVJ4vZMg1OafVhLuC3kvNnJ8Dm + jD8qKtPsvzb5p1IIUBH/c6kxYwhgNFPPz2tEkqbn5oQfynm3lAbIXdAXq/ePxJayKdhweLyqMUDbUDJJ + DRnuO7kIZRc34NjlzVi4c6gorzdU+MC8AOeIUPm1DTGck+8aKqGHtxEyf5/2dwI/P8fF1RU2rd750eKd + WtmtAw3dBbi5jOGkk/xQAfa7WIVnMelktzqbEIF0BnYyXQ3QI9lLDNsl5XEMyOXcgfcROrkjghYmImzL + BqSXXMXUo99jp4DsyqZxuLG4t3j+9wX4LwoJNNBs2guy701ggTV+WOWHsztmYVX5R8g/DoTsvYD+i4ej + 10hH8ejPq7r/XPjDM6OeEMJzKhHIWYE9RBF4inz1yGggoH8cnZMfEhKoIyFAPfTOew++EzwweHoA+o1s + j06yv5Mog0GTvJG2cQ1y9h5C6ub5iFqRitg1w5Gz5yCG7b2KhNm70Ts4De1sHWEu19OqdSs42LdXuQFX + IQJ3Y1jQzVMLC7qTFFzc0M3VDf19w5A2bRvGn/odQw7tQ/fh5rAS76zi/gghTwX+hypkv62AXVsqrGoC + 4N2cmpkSgOb59WvHa8Ipw/TclPD28Y8gclJ7zN6SJl5/vHj/CVhzcDRWFo9U8wLWHhiDraVTsffkAuw/ + sxTrhBTSZnWFQ1xdBX6OLpAA2gYbfrEINWyV3+4l1sIIm79H+7uBn5/p6OQMy3de+dj6RUOn1h0MdaVj + WAoBxAt410hH+VM18EckoIzHSWfT1QCJgTLWVUDVU+J1n/xXETiqGUKn9UTE6gmILT6D3PLfsKj0Go7t + XIFvV0UL2EUNzHxHwC9hwTRRAtNp8njWO/htsRuubczBgYMHMf24qIEj32Lw+nXoPSUQHsPM4MEioOlC + AjQuB57VQKyhEMLLogBeFBJ4ThFBd4n/u8vj7pkvwCO7IbpL+MDlwt0SamHAmI5I37IZRSXXkLxuCbwK + reGa8AD6j+2A3IN7MfNziVQuAhmrT8AneTQ6uPaElVlbsVZqAhFXLnKW69hJwoLOQgJc3didpCChgoeE + ByFpYzH6wDcYffEafGb0l/NTU2X+7aJqyuP7FPC12F/kv9HzmxKAFgKYEgCBrxuvDa+TRgA0fTSAoGUS + zyykJgYMfw/j1kVIfD8K6w+Nw5oDI7F8XyGW7SuS7XBRAWNEAUzHrhNzsebQGGTM9kSHhKcUeagcgHye + 9BUufnuirTgRmzDD+1wSzwide7/93cDfuXNnODt3hI21FSxfqbvK8iVDE/mbNTh+K53kTSGALtJRhrYW + NSCd5VtjbFelmZKAKRHouQF2OnocdjrpJPIeeU06Kte3c016VGL0eqowSODE9gicF4GwjauRdvgrTDgB + bDp0Gh9tHIHfF3sAc1oJ6N8CZrwsRCBqYPpzwOzGEhLY4dc1friyY6IczyKhvyD60NfwW70UfcZ7wpP3 + AqRpaoAzAj0lDPEU0HtkCNhJAkYjAXQVtdBZVIFb4gPoGGdA55S6GDzNHzm7S1QZsuBZ0egY+zDs5L/0 + Gy0EcOAQpn0CjL/4E4YdPofsHacQN307egWmoJ2dI9qqVYtawV6uawdHuZ4C+o4Ojuho74gu7h4YEJKI + rKXlmCAEErdlKjqm14clk35ynuyiRfpL6MTwicbY35QAbge/WIQQwG1eX78mGgFUXDPjtdDnBPA+gSHz + e4unHy7ef6KAfwxWCPCX7S0QAijEKlEA6w6NV0nBLWVTMW5NKLqkv6QqDzN0aCG/l9e1TYjhQ/nscfId + Tu3jDI8Z/i4LkPwdwc+VdW3t7GDxfqOPLF+q6deigeFh499VTV+5SICrVi4SQjjzj+QGTDuh6oh8TTqe + ij2l8ykykOfsuI7xD6Nr2hPwznkeASPeQ8j0PghdPQ3R+84hRzz64pLLOLl7Ob5bl4LflwoRzBUiUCrg + aSGD+kICDYF5jXFziSOub0zE4QPbsOTU98g9Bgzedhi9ZyTCc1gbpQZIAt1E8ndNfhTd055RoYJH1ksS + EghJyONuAsAuaU+J7H8EbkkSrqQ/C5/x3dQcgfAFWeg1rCWcY2uhW9ariFiYg2EHL2DYofNIWDcNUauy + kVm8DkWlV5G19jwCcxagq1cY2tu7wMbcEjZmZrBtYwY7s5ZwsLRGD68gxI5bi3GngJySg/AsaisAl3Mi + 58VGgKzF/ZT+lQlAS/7djQB04lXnXTchXf0a8TZf3hvAEMA+rg6iJjpg/o5sbC+biW2l00Tuj8XKvcMV + CawsHiGKYAK2yP4tZdOweE8ugsdZoEVgTbxpLDsu1/ImnYR87mYuh98q0FDf2I3u/fZ3BT+/q02LJtes + GtbK4380/t3bmunKRVQDst1jfpelzSvMpNOZEoAyeV0nAp0AqAb4ml1UbfG6j6CPhAX+w9/F4AkdEDQ7 + BBFrZyN5/yWMFXm/sewDnN05Hz+u9AXmCwnMbiSKQFTArHradu5rwOK2+Hl1H1zdXoA9JYcw8tgNhBz8 + FgNWLYfXOIm9M55HJ/HuHO7rmvqkGvPvLiDvLsCnAugmyqBrej0hgafhLqTUhfmD3CboPaw1ugvoXRIe + FPA3RAgnEO0oxtA95Qibl4nuuW+jW+4bCF0Ui4LSU5hwHhh5+AZSlxyFr0h8l659YNnaDGZNGqNt03fg + aOeEQfGjUbTnK4y+8BX8Zvurc8DY3zayBtpF3aeSfirxp0IAbVVgnQB0EtDAX3kEwER90eQcKzOqAHps + xv58L2/8mbg2GusOjMOWI1OxQTz9qv0S94vsJ/i12J+jALOx6sAoNfznmPCY8vxM/qnaA6GG78Q5HBQn + kdUmyNC02vPfK+B/+b4i6+cNrxv/7l1bCz/DwwJWLTcQZlghUu+4XPAv7wC/id2VBJTJMQJ+JgmpCLjl + c0506SAk0D39GTXff1DBWwie5IbgpcMQvLsMqUd/weyyL3F430Z8uTEFvy3vAixoJkTwIjCTJCA2W5QB + iWCROb5fF4Dyfcsx5/iXyDoOhG49gj5To9FlaHN0lpifyUgm/7okcfbik+p+hgoSEODT+3eW3+IuIYFr + Qm04RBjgGGlAr/zmoghGIXPrNsQuGw/P3JZoJ//DNelJhMxNwrCSkxh95gsUHb+IvJJTSFu7HwHDpqGz + 12DYWTtIOOCAHv0jkDhjD8ae/g2J22bBJeNFWAgpkgDaxdRGewkzlPyn19fBXyUBCPAjBfi0qghAB7+6 + Jtq1oedn3E4g0/uPWx2O2ZtTxVIwa0syZm9NxbwdWViyO18bESidgs2lkzF+TTh65Lyq6gQwfNCnApsF + GT6Q6zeOi5C2CjI8Zew293b724P/pfuK2j5neNP4d/+0MSRQakDiO9nGtw4zrJfHV3XA3810IqiKEJQa + EKsgAemoXALbTgDgnPCQuomHcwf8R1vBd7ovAlfNRNL+D9VEmTVHzuP8zim4saqfAjvmviHgbyAk8ISQ + gdgcUQSLmuLX1e74lNNbRWKPkvdFH7yGActmosdIVwE51cBDyjqnPKakf7f0p8We0QhA2bPolFJXPP/9 + cIqWeFnkv+fQt+E/ZRCCZkbBe6Sz/NY6cIx6QB67IkNIobD0E6RuXYbghVEIXZKMtG1rMWTbCcRO34qB + cSMxIKIQseO3YNieT5C1b7coE2cBey0V99tICNAu9gEhgDqwjzFm/pUCuDX55x8hgNuuhRgBq4Ar5hD3 + qCoWwqXc46Y4I3GaK1JmuiNrnqea/89x/hmbEzF/eyYmr49Wy71bRz6gyofpdQKkL/zclusOhhm8/zYL + j1aD/+6N5aBYFqp1uCFIWH+O2FEJC75QIDbpbLcZOyIBb+yUt5EAzXgcSYDxKT+HN7Q4xD0M9+THVNnv + gfmvwn9cewSyGvD2/Ugr+xkzj15H2f4t+HpLDn5b1VPUwHtCAk8JATwsRFBHSOAxCRWeAZa+g683DkLJ + wdVYfOorDD36O4I27UGfaVHomtcandLqw10IwD25jhDBw+iS+qgKATQCqCcq4GkhASYG66BT0qMSIjwP + jxyR/EPeUqMZHeJqwyO7MaIWFaKw5GPk7D0Kn0n90VF+ezcJDWLWjsLIE1cxuvxXDF0nr6+8glEHb6Cw + 7EP4S5jjlFhXZD8LfEgoFFsb9rEPit1SALfAbyQAkzyARgBGk3PGzL9GAloy0PQ6qPMrwOfYPx9zyja/ + p0PiE3BNpdppgG6ZL8BzSCNVVYlTfsMn2CJyQjt1VyBXH2odXEOFD1QRAv4bQiin5foVWIcYmhm7yL3d + dPDXqwb/XVuTNMP9EgK8LB3AQQggRTrTOgHt1bsSgIlVJgBTUx5KOiYzytqxNdVsOKc4ibtFontnvwCf + wqYYNMVT1MB0xB74GKNPARtE4l/Ysxi/rBE1sLAJMO9JAf8jQgZCBLPvF3UgZLCkkbzugqs7srH38EFM + OP474g59A5/Va9FjwiB0GfI6XBPvh0siy6JriqBz6hPoLN/LMKBzmgAkRbYpTylzS3ocHeLvh2OsSH8h + Ae8RzhIOjFMTiCKECDpnvAo7+Q9dc95BzKoxGH70Msad/gVjJIwZJ+HI+DMQZbAGXeR1a/nPthJe2Av4 + 28t/bRf7kGYmBEDgV4BfEcCtsX/dLCNqq3OmqwAVaslvINh5XjlTj+BXc/fpvY3GxzTWeGANSFYQspDP + so5i8vERZZYR99/6DCERErWowI/l+k+3DDN0/lsM+engb1AN/r/UWCpaOkULsUAB/yzpEEf+LDdQFfBv + M+Nx7LQ06WCqY9sLGFwTH4Fn+hPol/sC/MZYYfDCTIRsL0Fq6c+YVXodJcWb8PmWNPy+2gVYTCIQ7z/n + QSGBGrKtJc8fFSJ4HT+u98CZ/bOw8uTnKOJaBXuuwGtOHtzyreCa/pwQwKNqGNAtibMXH4F7qoCeBKBI + 4GlRCk/Kb3lUCOA+Ze7ynj5FNvCb4gv/qf7oOcxcVMGDcM94DSFz0pC1sxjZu/cjZdMyJG2ch7StK2S7 + EIPkWKf4x4yz/WqI7BfpL6qnMgHo4L/l/U2HAU0JwHTyjyb5eQ4JWHpsbglwJv/Mw2tVFBBlnQDTx9zq + cT69vbp9WB6r4T75PCMR/CrXvFjM3zLc8Mo9XyjUVPbXrGEEf+3auP/++6vB/weNi0Zw8QjxIHbS2WIF + vOulg3xmCnpTY6e8W05AN9OQoIII5LmVAkltAaHErkMbYuCIVug/vgsGzc9B7PbDKOQEoqNf4ljxUvy0 + YRCwrJWEBfVFAYgKmGMQIhCbW1vIQYhhTUt8vX0wSg8tw+yjXyP58O/wXb8HvSaFoGt2EwF/HVED98M1 + 6SF0EkJwT64r3/u42JPyXAhAFEBHISSam5BC54yX0HXIa0IGL8AxjsrgPvQb64HsXSUYUfYV4lfPgdco + V3TNfRfdhzVHt7zmcEtrCIcY8fARNWAfVVP+20OKABj7t1NWBQEYwV+ZAFT8r6oA3X7u6NmZ8COAuSCI + a8qzIvNfFLXxqAK6AraAnrUBdHXA5yQCkoD+Xj7Wi4BIyPe7AP+iPJ4g32dORWjsDvdmqyz76fVJALWF + AKrB/9cal5FibsCcuYEwwwwOC4l9LI9vskNWNlMiqIoEaHpn1mUqO5+FdHLKZNck7Y6+PkPqY0BRcwya + HoTA9RsQX/Itxh+/gX1HSnB9Rw5+F9mPJZwnIMAnCdDmii0QW/IIfl5rgXN78rDu6CkMl7AgbPen6DNv + NDoXtIdLWn0hgQfhEl8DLnEi9RMeUDkJd4YAYi4i/V2SaI+rRKBTfC20jxZvLt6Xt0MPnOAlBHAQ2XtK + MWiyH9rHPAoLARIlv53E/O0k5m8fc7/R8z+owN8+RgggWsBfMfyn2+0EQPBrBCBG6S/nRZ0rASlBTMAq + jy6mx+zOSU9i8Ki2CBlrLURQX4Gb3p1JQd7TL4TxjTw+K1Yu5/uMfM4VsyDDJ+LtP2sVaviyTZDhe7kG + nAtC8M8TIujbNqjqIeR7plWV8KPk1+2hhx5S4H/ssceqwf8njYtGGHMDlrIdzLBAtpd10Fe2u5GAaRZb + DwkIfhqTiezs1pE14SCelrE6VwD2znsTA8a4IGBhHqJ2HccwibNXHL+Gk8WL8P3G/sDyxsDCOkIEEg6Q + AGjzxBbdj99WNsSXW7qg5MBsTD32BWJLb2LghmL0mBQEN/HsHeJqoEOskIDE/JyrwNmLLkmPKRXgIqAi + CXRMrKOSgU4x8rsE2E4C6h55ZgicHQf/6WHoPKQxbOR/qLv7ZGsnx9hHC2EIUSjgx9eRrZb5vxP8mukE + oINfEYBx8g/vtSBJKvALqPXSXeoGHXnNIfZh+A5vjtyF3sic64kuGS9WyHv9Jh4m9IQExsh1i5FznSPn + fYrsZ6J3qezbKK8Vy+M9YtMtQg295X+8fE+vH3i3mJ+gr1OnDh544AFlJIAnn3yyGvz/QFNryoUYPKWz + jBOgH5TOxCHDO9SAIgHddNDfYXxNO16XtnxM2cvcQMf4h1R9v96Z9UQNtILfzBAEbNiAhENfYEr5N9hX + sgdXd2Xj1/VOwFIJCeYL8BkO0KgIFBHch5/WvI1zuxOx+ugRjDz5K6J3XUDP2blwzbeDS/pLAvjHhAQk + 7o+tCef4B0QdyHOlAGh1tZBAgNxBQO0k0p7k0DnzdXTKeAUdEh4VYHN2n4BevL6jyH3HOJqAX1kdtJNt + O1EA2rz/PycATfqL55fzQQnfWoxVnTifgDcS2QvJdEp6ED0yn4JvQWOkz+qMiWsjkL+4nxrPpyogCSgF + IMe3DjUcEOD7yWc0ayXSXvZ1kc/uKTagbYghRCxJHsfL53ta3evVfqqM+QX8jPkJ+KeeekqBno9JBo8/ + /ng1+P+xVkM6Uz3pMK0sRQ0IYBcKIVwST3J3AqBVSQC3jFVx2eE1EmCYUFNAUEOByzXhYXim11fFQ/uO + dcbAeemI2VGCoqO/YfHxz3F8/yL8uMkTWCYksMCoBEgCs4xEsNAgauAZfLPJHseLC7Cg7CwSDt9A/00l + 6DUlHl2GvI2OEgY4xhjEw9eUxw8r0LMyslIEDAkSGQ7UhZOAWQP4gxXmIM8d4mW/kIRT/CNq6yjA53Cn + lvz7cwLgnYAEv6WYkv1CjGpoT6Q+ge8i39N3SD0MLmyEiNGNETehBRKnWCJ9RgcULfYSAghB3iJv9Bv2 + jpy32ir5p+YFMAQIM5SI+cvnNeK8D8sQwzOc1ivK4gUqOyGZN+SasgR4/Xs66VdVzK8bPT4BT/A3aNBA + gZ7yn/E/H7/00kt4+eWXq8H/DzSqAcaL0onGSwcrlm1FbsAU/KakUBX4K0yAz+MYEqjcAL2eAMEu6j4B + 3kPqFl6P9MfgNawJfKb7IWDdGsQe+BLjy77G/sPb8NnuJPy4wQq/L31CI4GZRlNJQrEFJILn8dEOP2wt + 3auGGqP3f4F+i6agS4GDxNJPiwevJZJfjGpAQpGOSRIaJDMkeEII4DEB+KMauCUUYD7ASYCv9ikj+B8R + 4Gvg1wnAXmX+jXP/K4DPKkBiBL9RATDu5+2+lP360J6VkCCnMAeNtUHywkBkr8nC0PXDkLs2B7nLo5G/ + qB9GLOmNUcu9MXRBTwwe1QZOCY+rnAGVAM9j6zDDKTmv6XJeW9zzib27tbvF/JT9uuRn0o+gr1+/Pho1 + aqS8/TPPPKNCgOeff74a/P94q8FkkXSyNuK5A4QEKnIDlcGvW2US0HMFpvkBqgmSgB4SkBgsI0gE4p1F + ondLfULVA/QaZY8Bc9MQtmUPCsu+x+KT3+PAkc34bGtfUQOPad6fKsCUCBgmLH0UP20wx0mqgeMfI/3Y + 7/DfUg6PqQlwzmyiSKB9pAGO0QY1J4CzF51FFXQQcDvFiwoQsDspby8mIYCTKAMd/Jrnv+X97YW4dALQ + sv86CWjANy0EQs/N4Tx9eI95ku4Z9REzoweyN0xC3v4SFJR+imGl15B34DRyti5H9ooUDF3ohfwFXZEz + rzOiJtmjW0ZDIc8aKhlIIpHr85GcxxlCCl3/Vrfy6s0U/DVMhvoIenr4Rx99VGX9SQYkAHp8EsDbb7+t + AE9FQFJ45ZVX1L6mTZtWg/8fbJSSKjcgakCsWIB+WWLLKm8wMiUBnQD4uHKSUCcQEgKN3pFAcRLP2ynx + YU0N5L2BARP7wn/FfMQUf46i48C68mO4sjsWv61tAiy+7/aQQFcDQgS/L38cH23vjy1lezDu9E3ElfwE + r6WL0bGoCxySn4eDSvwZ4KDIgAlA+W4F/roS+2vmRFWgE4AAXyeACvBXIoCqhgB1AmBNf07Eoeen+umY + +CjCJ3XCsG3zMKb0A0w5+zsWXJa/JDbrLDDq0GVkb16O9KWJyJzXHdlznJE60xne+e8IedZUiUCSiRDp + N+bBht2yjZVr8qrxkv09WmXPT7lfs+atST4kAHp4xv4kAhof0+O//vrreP/999GkSRO8+OKLyt58881q + 8P9zTeUGrCIMrS2ZXAozjBXwlggx/GQKft0Ibh38OgHcaTzmFgHQ+F5LhgWRNUSi10bXlMfgmdUQnsNa + o+/UUARv2I7Mst8x/dTvOHBoEb7a5CxqoK42PGhKBDQmCZc+iG83WOPk3lwsLT+HzGOA7+7P4DGrAC5Z + b6vhv3byfe1EgTjE1DJ6fs3r6+YohHBXAhDwa+P/GvjvRgBcAMRcYn/lsYUA2kXWhPewd5G2chhGH76A + 2ad/x6ZLQPknN3H2c+Dwp8CK879h1OGPkL5pEVIW+GHIbAdFAv4jW8l5q63Ke6swINjwq3mo4YqEa+OZ + CDRer3u/VSX7OcZP0+U/CeDZZ59V8T1BzxwATff4BLuFhQVatmypCIHKgPLfzMwMbdu2rQb/P9FIBOLB + nQXkmQLYTdLpLgkR/GwK4tuJ4PawoLKRIHisyg2Iccs74biElkPcA3COry2K4H70yHoJ3uM8MGjZHITt + /RwFx25ic1kJPtqTgF82tBGwP6yFBXpIoCsCIYIbK57HhzuCsKP8ACaf/hGxB79Hv6Xz0Hm4GxyT6gmI + a8MhuiYcmelnwi9BwgGR/xr4b8X/txOAFv/rQ4Cmw4Cm4Kf3Z/zfRv4nAcuagZ0k7Aie5I4hOzZj4vFf + sOrEryg99Tk+u/Qxfrp2HV9d/wFHhARmn7uJjN1HEL84AZmzHJA71wlhE6xgG1tH3dbLz1OhVLDhR1EV + y+U62P6tbuypaqiPsT6z/gwBdI/PDD8BTiJg3E9j4o/xfqtWrWBjY6NATwVAIyEQ+La2ttXg/ydamwjD + k5xAxEIS0gHHiAc6KuC/UZkAbpHAncC/zYzHEvw0rd6ANlLAYhtOsbXhnvSIKv7Rq6A1vKcGI3D9Zgwp + /QXzT/+AA6VrcH1LVyGBRzTPb6oGSAay7/flz+C7jTa4sCcJKw/vR37pd4jacQoD549E9+Ed4Zz8rJBA + LVECrIj8gBH0JuA3WgUBxBrNSAA6+O8gAGb/Rf6bhdZQNf1JAJ6pjyJ6jh9yD5zE9BPAxiNfo7y4FB8d + 3ovvzpXjx4+v4NzV37BYVEFm8TnELslA2kxH5M11RPw0B3RKayCxfw01jMjzRRIQ2yUE0JW3gRsv073Z + TD1/5em9OuA5vMesP40TfRjnkwDo8Ql6yn098ceYnyrA0dERdnZ26hiqAIYABCT3V4P/n2vS+eq1CTF0 + EPDmCfi3SQe8LIrgjtyAIgGagL2ymRIBj9HfY+zUaj9rDtiLd+4Qd58QwUPoMeQleI1xhe+SiYjacxkF + AqC1h7bhw53h+Hl9M2C5EAHDApKArgaMuYGbS5/E5xs7YF/Jcsw79SMKSr9H1PrV6D22JzokPgX7SAPs + RQ0w0eeoVMDtJMD9GvB1027//VMCMCbu2ghoe6U/hvgF4Sg4fAnTjwNriq9hz8btKN+wHJf3bcanx4/i + +OXvseiCEIBa/SgTKTPaI3dOO6TOdEGfvMawFdJhLkENBcp5Mt7TMchY2aeGdoXusaaDv/JQH2W/6VAf + JT69PAnBNPGnA/vdd99VaoAqgDmANm3aKC9PMBLwLVq0QLNmzZQyIPBdXV2rwf9PNmaeGXtacoppiGGs + qIG75gbuMILehABuIwLds6ljZb8Y19hziK6h5vx3zWwAj2HN0XvCAPgvn4P0fZcx4+g17D28Gp9sH4hf + V7+iJgrdkRugLaiF7zbZoOzIUiwQEsg9fB2DF4+F25CmsOOIhJBA+/iH4Jio5wKYFyAB6CFAHSEBoxkr + /1ZFAJT/avIPh/90AggWAsh4Eglz/ZC/vxQTy3/H/H1fYs36g9i+agMObtqK0gPHsOP0T5h5Sghg71HE + SAiQNNUaQ2baChG4YEDB+2pxV54XNRRIIggzHJPzFSHK7DUPD0Mt4+W5d1pVMb+e7NMlP+U/vT8n9jDG + p6dnElAf6nvttdcUsBnb63E/95EQGPOTBLp27apAzwQgycLe3r4a/P+G1o65gWCDc1uWmAozbBK7KPaD + BuC7W1VKoIIIxPh+U0/HW43tYzh3oBZcE+9Dl4wn0HO4JbznFSBox3nklP6KlWWncLp4OL7e7CzS/2lt + eJDAnyE2TWy62PJncW5/Ieac+AopxR+h/6x0uKS/phRAOzFOAPpDAtBJoIIAbh/7NyUA1vsnAXACDydF + dU9/EuETHZG5biKK9n+AiQd/xNw9X2Lp9g+weuclrD54HQuP38TYsu+RvmUd4ub6InFyW2RMb4fYKQ5q + hWAWHOH5UOeG23uZAEzBX3moj16eM/v4mDkAEoDpsB5lPhUA9/ExwU7JT7Bzy2P0XADBTqB7e3srImAO + gGTh7OwMT09P9OzZsxr8/0JjbkA647tiXq3CDCNahRj2C4C/qQr4plYVAehDhooEqASMZs7l0OU9VAPt + owxwERLonP4Euua+A4/xA+C7YjkyDn6F6Sd/xvayvbiyYzB+W9VACwlIAgS/bH9d3xr7jqzFkJKv0Xfh + DHQc0hzto++Tz6wBByEYNQNQ5L4Db/iJecBo9wvo70c72dqJtZN9WuafpoH+bgTA382YncqGU5AHcP3F + aZ5IWzsDBQeuYHw5MEVs6hFgUhkwsvRb5Ozaj+Rl2RL3d0LSZCskTrHDoOHNhIDqqpmE+g1BigBCDPvk + XA6850KAyp5fDfWJ6d6fEp8eXp/iS0LQPT4Tehzqe+utt1QiUB/q4z4rKysV2xPkjPv1XAD3de/eXZEA + QU9S4DEELYHs5eVVDf5/sancQLihvXilZLFl0jlPy/au1Yl1FaBbZTLQcwjqeCMRcKSAy5u3U2rgPkUE + 7il14VlgCZ95hQgXNTC07DcsKzuBc8VD8OumVsAyCQkWG3Bz5XO4uDsZUw+fh8+63XDMdxVCqQU7+VyH + 6NrgdGAmAjlV2UaIhiW/LQS83Eqoo0wVAhWyYJl0Vf3XBPg6+G+FALXF84tcJ2DlO9rFPojumc/Ct7AJ + Iqb1RMq6ycjeV468Qx9h6IEPkLWnHCkblyN+UQrip3cX+e+IhMn2CBjeHK7Jzyivr08Hls+7KefkuoQW + 8+X8ON1TScDKMb8+1EcS0If69BifMT2TfUz66VN+dclPYHNLBUBlQLBT8utg55ajAAwLCHZKfgKdoCaI + O3bsqBQD1YEO/gEDBlSD/19o74UZHm8ZZnhTOuet6sR/YeUiWlUkoBMBCcCUBCwkZrcSo2x3imF+4BF0 + GfIGeozujUFL5yC5+CqmHvsWhw4vxZc7vPH99i64XJyBFSW7kLhtP7pNioJtwrNagQ/mGNQowP1itdFO + FAZvAzYXsLVmKW0xM3/5bonlOYffhvmCaCEOUQ63gV9Af9sNQCQAPV6Xz+OwIKcge+c2xOBRzRAyuQPC + Z/sjemGqsojZAQiZ5IrwsZaIm2gjBOCk1mfsnPacfE4tNfzHCUX8PDkPX8s52yHnOMY82PDWPTMMqIO/ + qqE+ml7UQ/f49O4EPBN7fM4kIKf7MslHec9hPQKcs/9ofMysv5ubm/L03JIUGPuTELiPIA8KClKg5usk + AgKaYNetGvz/WqNHEkXwD61cRLsbCdAIJhKAqTFksI3kMmYcNjTALbkuPPLN4T07B8FbyjDi4IfYWlqM + 0hP7sOX8Zxh+5DP4zi9Ch4zGqqQ3y3sR8PbRvEmJt/3WUFl/59SX4TykNTpkt4dDVjs4ZLSBQ8pbojwe + UyqAqwFZq+FKksCtxT9NjbUS+ZvpsWmWQgiuSU8JAbwK/8I34Vf4KgYVNUHA6LYYPMZSPP27CCh8BaEj + myB2giWiJtqi99A3YC2fT+CbgJ/n6qxscyUUsLER0jWe9v/uZir7qxrqo4en52fWX7+tl4k/AptynluG + ADR9+I+S38nJSREBFYA+4ad9+/Yq3qfHJ1BJCjyGYCd4fX19ERYWpoBOBUAiILC5vxr8/55WeeUiqgGR + sd9WBn1l+yMSYAZcBz8TharmAOW6kuYs7lFT1QDoPOQteIzugYDFE5C75yhmnP4Vky8AyTvL0WOkuyiH + 2rCV97O6j32MeHNREpT9jPW75VvAf+4QxG7ahOTdh5G85zDitu1C6KoF6D1uAOzjn1bj+hbyG2yEfEgC + pmv/K/CLcRiQv1cBVwiAC4d0y3gBA/ObCAG8Db+CN+ArNqhIHhc1lX2NETyyKSLGmSF8vBUGFr6HDomP + q1if0385o5CP5b9/LbZCzqerug/gXvD+Vi8ZGtwR8xulf+WhPn2KL8mAz/WhPnp3JveoCqgCuE8f6nN3 + d1dxPUMCGgHPfQQtQc1EH4cCeQzBS2CHhIQgNjYWgYGB8PDwUIBmjiAgIEARQDX4/z3NdOUi6bgsWHHC + PMTwRVXg103PC1RFBvSqPEYRgMnWQjyyDRfq4Ow+kfKU293z28JndhqiN21D/PZDCJg3FJ0y31DgV9WA + mPiLFS9u9OodUhti0JxM5B+6iAUfAJs+B7Z/BayV7dQLvyNhyw54DO8kYcADigC0xUFqyvfWrpD/qvKP + POctwCQqEgB/H2sOeIlH9y14TwD/PgaJx/ctbCr2jjwX7z+iGULHWiBigi38R7ZGp9T68v9rqthfzZaU + z5BzeEO8/n753Fh5/rLxFP93N/vnDE9ZvWCIEfCf02U/Y30CXx/q0yf30LsznueWREDZr8/44zg+s/ec + 08+wgPuY+NOTfPT4zOyTFKgCCHadBPS4n0OBVAwEPEOB4OBgxMTEqC1JgsDm8fT+1eD/9zV95SLptM4C + 2FTpwKo6MYHxR2ZKBJXJQO2TY0gAGglwH4mAntmA9kIEHZMeR6esN9GtqD16je4Cj2EWsu8Z2KuwgUTB + Ml+iBhgKxDyA7sNdEb9pC2af+x0HPgM+/uomvvrhd3zwA7BTSGBc+ecIWTwObtktNIkv4CRx2AjYNQLQ + pgBbyufz9+tZe+YIuKbhgGHvwKfwfbH3MFBA7yPmW/gu/Ie/j8BRrREy1gpBEvf3zHlNVIUm/Y1JP+0/ + hhguyefmyXk0uycq/Ng0NDwo4O/zQl3DGdOYX4/zCXwSAMf6SQD6sB6H8PQpvtxHwOtZfnp8gpzHMBdA + sHMfE38ELJN9PI5kocf3JIDw8HAFbJICiYD76e2joqKQnJyM0NBQRQycIMRcAdUAQ4hq8P/7mipF9g9W + J6bM1ycPVUUEpsdqRCAhgRiX625HiS/GuwA7JjwsquBJrQaAGu5j1p/LeknsL0TQScKGQbPTkbfvPFae + AU5c+BHfXP4Uv1/9BD98+QNOCwGsvPgbcnYfgdfkENjEPF6RGOQ8BZ0AKP35G+U/qiHAtqE14ZIo3j/n + dQwsaIoBBe+i37C30a+giTwmIdD7N0fQqDYIHN1GLQDiEF9XxfsVcT9rMoj0l3O1WkjHvQUX9LwHWg0u + Z/XOs4bFNWveAr+e6efYPgFO4DPm500+fE6PzyE+07ifSUDuo/fnTD56fIJcv81XH9fXSYBqgCDVh/q4 + j2AnCVDe83USBUHOhGBkZKQKBwYPHqxyAvwskgEJgMqAn1sN/n9Pa1NFdWKxP1YDAihTAqhMAvo+0/dw + 3gCJQC3hpUYLNBJgebCOElvz1l9m/xn/OyY/gZ6jXBC9cjbGHLiKNeU/o/TwB/ioZB++Or4PX166hIsf + /4SdHwHjj34O/4XDYZf4Alr5y3cJSJkQtI7S5D9/Bz02PTeLeHDpMI+MF1UtxP4S/3vnN4aXPO6b95YQ + QROJ9SX+H9ESQSPbYFBRM7ilPKvkvvG+f/VZBL9sd8k23jLS8IbxVP53Nw+DoZb584Z2DR8xXDTUuAV+ + en/TQh6M5znkR0JgHoCAJ/Ap+SnvOcmHeQD9Tj/dsxPE9PwcDaARmPTuBLW/vz969+6tiIKxP703JX1V + cT8lPkmBr0VHRyu1QHLg+5gc5PdoqsEVdtXg/7c1SljeXKSqE5usXGQKYlPTQa6bKQGY2u1hgRCB7LNR + cwd4738dAb8QgCoO+riEAA+oUQBH2ddjpBNiVs4QAvgEy478hB27zuDwhvU4tW0Nzh0pw9HzX2Pzh8CY + 8qvwX1CAdjoBBArJCAFocT8LgIj3N4KXOQH31GfQK6cRvHJfR5+hr6P30NeUeeW+ocigv6iCQUXN4V/U + Aj2HNFK3ETPpp88fkPNCOyOPc+X/WN8r3t/QooXhvrYNDO7P1alx4f77CP7b6/aTABjj07tT4tPzM+7X + x/91eU9Pz8Qej6EK4FRe06E+kgFDAg738TH3MYFHkJMMKPe5n4RAFUBvn5CQoABPEiDY9TwB90VERKj3 + MxRgvoDvt7W1U0t0mzWvBv+/s5lUJ3YQ+7euXKSTgPZZrEBUA7ac9RfHJbYegzNVAKf5xnKBz9pwy2gE + /zlJyN93FnPKfsfq3Z9g69rd2Ld+B/bvP49tp3/CvLO/Imv3AXhN9INdzGMw4zRfAaqVfKeVhAGse0jQ + 0pgE5JTi7rybMedlVfGoZ3Yj9Mp+RR6/Ci8hA6qA/sPekVCgqSIEJ/ldKnQggRg/R+xrIZTlQgKuxiG/ + e2PGn1IALxisX3miZtmD91e9Yg8BT49PYNPTE+R6MU8m+Qh8Sn4CkWqAmX/Kfo7r0/vrMp0emsdxqI+A + pWwnoDnUx7ifnp6EQRKgOiDI4+LiFEnQwxPslPn8LB7PYxj78z1ubswpWKN1s8bV4P//1O5YuSjEcFge + fyaK4PeqwE+rCvimph+nA1InFavImmoqr0P8o1oFIE79jTYoIvAobIf49aswruwXLCgF1uz/ElsPXsem + 479i0Vmg8PAnCFpYBLesd2HNlX3kc2kVpc/kMb0/FQpXDOok3t8j6wX0GPKiePeXZNsQPbNeFhJoJCTw + mhAAw4K3RRm8AbfUZ2EhSoXKgZ9BIpDPuyFWIs+TWoYbXjGernun2TQ01G/ZoEbWMw/X/qKOxP11FPhv + 1e1nYQ8CnhKfwKbs57ReDvVRBehgpxynpybIGQYwF8Asvy7hCVqSAfdxDgAfcx8Te5T8JAM9idevXz+V + 9WfyjyRAsPOzSTKM//l5eva/SxctzLBr3bQa/P+fW0VuINzQTlRBpHT8pcasdwWYTY1evjLoTU2FCsbj + aHyPTgT0zjbRHAFgxZ+H4BBTQ1UK6phSHwOnDEb69mKMLf8Zs84ACy4Csy8Ao459h6jVC9A1X9Rg5AMq + +8/8gra4J72/cY6C7Gc+gCFG17T68Mh8TlTAc6qugQcX9MzUiKAXayDmvQbv3DfV/AAuIloJ/Jzz/6Gc + i9Gy347nx3iq7qlWs31DQ+MWDWpMb/DEg18/Jp7/cSP4KfV1b888AON+xvKM8Znx52iArgIqx/0MA/Q5 + AAQ1AUuQE7RM4DH2Z+ZeH+/nUB8TfHrcT0/PuJ8JQCYGOSRI5cDPo5ogIbi6uslzR7RpLp7/5Wrw/6ca + cwPS6RsLCAYICMYJIPbJ8ztWLqoAtxHsVZHAbcb36cAS43sYozMsYHFSzgKkGmBJ8YGTBiFs5STEbd+G + xF0HELtpAwIXFcGzyBn2cXVhJe/njUmcd8DhQBIAgc/PZf1/Jv7ckp9C1/T66JohZtx2S2+gSEAjAFEB + Q1+BpzzmuoMEvor9ZSufdVOefythwGYWYGkebmggp+bevN+foYDVS4a2zerXmlLvqUd+eeIp8fz16t8G + fib49Bl/jPnpyUkGVAOc/EMVoI/fE+QEK0MCHkuZzn2M7yn5mezjPsp6Ap0ynwTAoT4+phIgwBkm6LkC + kgDzBSQZqo127exVzN/6nTerPf//QSMJCBBeELujOvHdjGRAkOuAvxspKDUgQFXv4XMm8MRs1KxAJgof + gXPyM+iY+QpccpqiY/b76JDxJhwS68Mu+iE1vEjgqwlARvDrxEIVYCvKwjnhUXQSAnBPewadxJgI5IKl + XdLroZuoAU8JB5gXYJETJiTbhtdScT/NSFDfmQUbDso2S4jw3XvyXv/Krd1LhuYtnqs9++WnH7v+/HMN + 8PyLLynw09MT/MwDEOyU9xy+oxdnYo9xvz4HQL+Flx6fnpzHMftPZWA61KeP99NICPT0lPwkAj3LrycM + GRLweF9fX6UaPDw8YW1tA6tWTa5ZVIP//7wJ8LXqxMaVi8T+0spFulVFAkoNiBnBph7ry5jxHgHe8EMv + byEemVn+NmLc8o5AEoBtVG0FdK7bz6Il+mdYSgzfXkKKjol1wcVH3FKehItan/BJdEp9WpFA14wG8GRe + IOtFdEp5Wg0d0uvTKP0VOYn0twgxjJff6dwqyPCU8VTc242TgmyfN5i1eP7+6S/Xf/LnF5Xnv71uPxOB + lPz07vTgBDYz/swNUPbrc/wJasbuBCw9tq4O6NFJAIz7+Tq9vX63n54U5FCfnuXXcwv8TFon43CfTeu3 + q2X/f0+7Y+WiqtTAbQRAE6DfnQQ0tcDRASXd+ThUjpUtX2Nsby2Plcl+SzErOdZa3msrICf4eQMQ5X/F + 98trKq8gYYRzApcf46rEmrmKl3dLftJIABIKZDaQx8/APvZBBXoV9+sEEGz4xSLUsE1+n7d5lOHZe+ZO + v7/abJ43tGn1/P3T3mz41Oevv/Yq3mrcBG8L+PXkHqU/JT8TfvTgzM4TqCQAEgPlP4FPr824Xo/7uV+X + /PT28fHxShEQ2HqegKTAxCBJgp6f7yN5kAzs7Nppsr/pW9Xg/y9tTBKKd+xLNSCg280koZDBz39EAHeC + /3bjMXy/rga4j0N6rEnIW361e/+1giCqKAjBL/v1+f76d5MMWCSEiUWnOI4wPKZmHXYU4zJkbkICnVMl + DEirJ2rgKbASMe9fIOj17xYiYpHVE21DDbmiPt4z/u2/V+P8AIYDZi/dP7Npo+e/a9Lkbbz73vsK/AQ5 + wc+kH4f0CHyCncBmXM8wgMRAr62P6+txP/fReCyBrpMAPT9VAEGuhw9MAPK9fM79LmJW8n3VQ33/9U2t + XEQ1IIDpJ6aqEwsIb5iCn6C8gxSMYK+KGCoWNBXT38dknpV4e4KdHr+i9h+lv5CDWuxT3svjmQdgOMDX + WTDUgaML8dpaAyQCTj7iUmSU/O4pzyiFwMImQl7KdBXCrL/8J5Kbk4QEdY3/+e/ZLF8yWJi9XGfKe681 + /O59kf2tW5sJ+G/V7af0Z1aewCdoKdsJZMb8OjEwbqc3p6ynIuDrNB5LT8+Yn0N9PI5Ap8fXpwtTAZAs + GCbYS2hRPdR3bzXKYwFMRXViAW2VKxdVJgF9WrEpAWgkIGZ8j4rD1fEC7kiOFtRWps33r63mEvA9GmGw + lFkt2a8VCGG58Fsk8AicEoUEOPtQVADvCKQq4DFMGOprItD7C+B/lP+zXZ57GUt8/f2bzXOG99s0fGh2 + 83de/cLMrLWAX/PwOsiZCGSyjqCml6c3J/C5n2BmJp/ApwrQE3wENGU/s/r6FF89y8/38HMZWuiTfBwl + BKge6rs3223Vif9g5SJTErgbAehWQQJG0+4w5HoFtFrKtOPo/bklGdRSIYFOAroSYD7AIV6IQC06UleV + HG8n+/kZJA8V/xP8oYafBPzHxQr4f/52cf/dWofXDA9YP2cwb/ty3Wltmr3zi6U1wW9fAX7G9QQqY3jO + zGPMT89Oz62/RmAzy09Pn5SUVCH5GQ4wP0Dvr5MA38fP5edXxPzVQ333fBMQVbly0W1ANpr+/DbQmzzW + n+vH3zIN9JppE3900xY0YcigqQRO6mHNQNYB5HJiigjEOAORx/D7leQ3en/5/ddEvcyUuL8r/4vxb/3v + NKsXDK3NGz0yw7xlk2v2dnY3nZ07qricICb46dX1+J1JPnp8Sni+TrDrZb4Y9+tZfpIDSYIqgeqBREC1 + wM/p3t1DhRn8PouXalWD/2/QWJ2YNxeZrlxkFmL4VQd8ZVOg1sFuBH5luzsB3HpNjSjIsZwRSGMyUKkB + UQIqd2CsItxOVAHDB7634ncI+Gltgw0HLUMNflbhhgb39Hr+/2yjErBsYGhh8Wrd6Tbm7/3g3NFFDckR + 3AQ/ZT8VAD06wc25/BzqI6j1ITwSAhN7fI0kQNAzfGCWXyeRbhL/d+rkjo5CDLbVQ31/y0YPqucGBKBb + xNOel+d/WIpMgbkS+BUB0PTXqwT/ne9RRMBwIbKWShayXJhWMqy2vHb7++W7b4ha+ZCLq9iEG1oa/8L/ + brN6ztDW6vXHpzpYtP6qUyc38dSeAv5bdfsp4QlsPctP2c84n0RBIwnwNSoEGt9Dya8P9bWzN87wqx7q + +1u3itxAmKGXAK1AgLZbtj8YQVel6aDUgWyqDhQ5CHDVa5WOu5tpRCBqQM8bGMnD9PskTPlYCGq2ebih + OxWM8ef/T7ea1s8Zmtm8UXdmB8vWX9Nr9+7dRwGZ8p/gpwKglKe317P8fK4n9qgWmBcgEfAYThCiEugo + qqJ6qO9/q9kHGZ4SwNqKzI4XwK0WOyuAq7I6MQFZYQLgOwigwrRjTMFeldHbV9woJI9NwW/8Po75F4v5 + WwUbGv1PSv+qGucJSDhgYfPmM1M6trf5pZcQgLd3PyP4tbr9lP5M9jHuJwnQdMmvT/ElCTA3oA31dde8 + f/VQ3/9c43g6q+gI6DoL6Ia2/YPqxBUEQDMBM61qMvgLdrvkV2bMTVyU3zLBIsTQ5p6o7/efblYNDM3b + vfnETHdH88+9eve6OdDHVwGfkp/g55ZkwC1HBnTJT7nPLD/jfioC5hKcnDqohB9lv+Vz90hJper2b216 + dWKqAQEgC2ycEQl+95WLxPQEH+0fJYCK442fdRsJhBi+EPAvFvPixCbjT6xupo2JQfP6hlbt3npqaheX + 9j8NGCief5DfbeBnOMC4n4851EciYNZfH+rTK/m0fuetaxYv3zekRYN7fB316vYvNb06sYBfW7mI04n/ + YOUiRQI0U0CLVQZ7VVYV+Gn83DahhkOWoYZAq0jDi9Xe/09a2+dqm9tLOODh3P76gP4DMMjPXykBgp+y + nxKfnp+Sn/sp+xn3U/azkg9r+Fm8eF9eNfirm94EdGrlIiGBBAHjGlEEp8W+qkwAtArw6qA2WlWgp912 + nOn7xSj924QYPpHHE61DDa2MP6e6/VFjTsD8aUMzu8ZPzfBwtv+2f7/+GGAEPxODBD9HCRj3E/jcUvZz + qM/S7N3rbV64b+SbTxkeNX5cdatuqt22clGoIUtUwWYB/J+uVWBaofiPCKDK9/LzQw1LeaefZYjhGeNP + qW5/odWweNFgad+k/uTuzvY/9O3bD97GufwEPzP/nAvAkQBXifuZ8Gvd7PUvW71Qe/YLdQ2vGT+julW3 + OxqThGZhBjMBZpgogtkC0nLG6JWAe6ep0YB/APwhht/le47I90RZhBveZh1E40+obn+1tXna0Nz+zSdm + uTpaXu/h2V0NEXKeACf4uLt3Vl6fNxG1fbfx1+/Vr73y6QcNVsa3VrfqdtfGkKB1sKGRhAUOAtZkAek6 + 2f65GhDTSaAC/EIMVR0n9ikJRkjA9l6t7/d/3pgYbPucwdzuzaemuNq1/ZmZ/k5uruBNPR1cOsHOxgrm + 7771zbv1am968gFDe+Pbqlt1+0tNr04sBKCqE9Nji/3xykVianafDv6qCeAbif83yGcNbhlpeNH4ddXt + n21t6hla277xxGj71u+etzVv+b29tQVsWrz3bZvGL119+9naax9/0GBtPLS6Vbd/qNE7q+rEJisXCSl8 + VgnQ/5AJmZQJ+OPkM5tUZ/3/De01UQKt6xuaWLz0YHTbVx+fZvbqs2uavfDgmteeqJH9xH2Gd4yHVbfq + 9k83ApU3F7UONwRVqIF/lAgY92vrG8wkoTRJM9xv/Pjq9i82lkiu2fI5w4tNnzW0aVTX0LreA2q55Gp2 + rW7/tlaxcpE2nThKiGCJAPmjKsFetV1nPkGUREC19P/3N0UCYpxDfW/WTK9u90Tz8DDUonwXIujfJsQw + SUB9QMBdZXVi3eTY32RbLsakYitOQjJ+XHWrbtXtXmvGkOB5sdZtxaMLsBeKtL/rykWc8CPAn9Mm3NCe + cw7kI6qdVHWrbn+HxiQhy5AJ0MdLWFAsRPARZ/kp8LPIR4jhF9m/TUggpFr6V7fq9vdrqjpx2zCDuUj9 + wQL66bI9pcDPEl/BhtOcXdg23NCyOutf3arb37AR2OYBqjKxjYA+XozDhR+bBxs+F/BvFOnvS6VgPPxv + 3gyG/wfGDZuMbR+lTgAAAABJRU5ErkJggg== + + + \ No newline at end of file diff --git a/ReClass.NET/Forms/ProcessBrowserForm.Designer.cs b/ReClass.NET/Forms/ProcessBrowserForm.Designer.cs index d4e111d5..f48d5331 100644 --- a/ReClass.NET/Forms/ProcessBrowserForm.Designer.cs +++ b/ReClass.NET/Forms/ProcessBrowserForm.Designer.cs @@ -30,231 +30,243 @@ protected override void Dispose(bool disposing) /// private void InitializeComponent() { + this.processDataGridView = new System.Windows.Forms.DataGridView(); - this.iconColumn = new System.Windows.Forms.DataGridViewImageColumn(); - this.processNameColumn = new System.Windows.Forms.DataGridViewTextBoxColumn(); - this.pidColumn = new System.Windows.Forms.DataGridViewTextBoxColumn(); - this.pathColumn = new System.Windows.Forms.DataGridViewTextBoxColumn(); - this.filterCheckBox = new System.Windows.Forms.CheckBox(); - this.refreshButton = new System.Windows.Forms.Button(); - this.attachToProcessButton = new System.Windows.Forms.Button(); - this.loadSymbolsCheckBox = new System.Windows.Forms.CheckBox(); - this.filterGroupBox = new System.Windows.Forms.GroupBox(); - this.previousProcessLinkLabel = new System.Windows.Forms.LinkLabel(); - this.label2 = new System.Windows.Forms.Label(); - this.label1 = new System.Windows.Forms.Label(); - this.filterTextBox = new System.Windows.Forms.TextBox(); - this.bannerBox = new BannerBox(); - ((System.ComponentModel.ISupportInitialize)(this.processDataGridView)).BeginInit(); - this.filterGroupBox.SuspendLayout(); - ((System.ComponentModel.ISupportInitialize)(this.bannerBox)).BeginInit(); - this.SuspendLayout(); - // - // processDataGridView - // - this.processDataGridView.AllowUserToAddRows = false; - this.processDataGridView.AllowUserToDeleteRows = false; - this.processDataGridView.AllowUserToResizeColumns = false; - this.processDataGridView.AllowUserToResizeRows = false; - this.processDataGridView.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left) + this.iconColumn = new System.Windows.Forms.DataGridViewImageColumn(); + this.processNameColumn = new System.Windows.Forms.DataGridViewTextBoxColumn(); + this.pidColumn = new System.Windows.Forms.DataGridViewTextBoxColumn(); + this.pathColumn = new System.Windows.Forms.DataGridViewTextBoxColumn(); + this.filterCheckBox = new System.Windows.Forms.CheckBox(); + this.refreshButton = new System.Windows.Forms.Button(); + this.attachToProcessButton = new System.Windows.Forms.Button(); + this.loadSymbolsCheckBox = new System.Windows.Forms.CheckBox(); + this.filterGroupBox = new System.Windows.Forms.GroupBox(); + this.networkingButton = new System.Windows.Forms.Button(); + this.previousProcessLinkLabel = new System.Windows.Forms.LinkLabel(); + this.label2 = new System.Windows.Forms.Label(); + this.label1 = new System.Windows.Forms.Label(); + this.filterTextBox = new System.Windows.Forms.TextBox(); + this.bannerBox = new ReClassNET.Controls.BannerBox(); + ((System.ComponentModel.ISupportInitialize)(this.processDataGridView)).BeginInit(); + this.filterGroupBox.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.bannerBox)).BeginInit(); + this.SuspendLayout(); + // + // processDataGridView + // + this.processDataGridView.AllowUserToAddRows = false; + this.processDataGridView.AllowUserToDeleteRows = false; + this.processDataGridView.AllowUserToResizeColumns = false; + this.processDataGridView.AllowUserToResizeRows = false; + this.processDataGridView.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left) | System.Windows.Forms.AnchorStyles.Right))); - this.processDataGridView.CellBorderStyle = System.Windows.Forms.DataGridViewCellBorderStyle.SingleHorizontal; - this.processDataGridView.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize; - this.processDataGridView.Columns.AddRange(new System.Windows.Forms.DataGridViewColumn[] { + this.processDataGridView.CellBorderStyle = System.Windows.Forms.DataGridViewCellBorderStyle.SingleHorizontal; + this.processDataGridView.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize; + this.processDataGridView.Columns.AddRange(new System.Windows.Forms.DataGridViewColumn[] { this.iconColumn, this.processNameColumn, this.pidColumn, this.pathColumn}); - this.processDataGridView.Location = new System.Drawing.Point(12, 199); - this.processDataGridView.MultiSelect = false; - this.processDataGridView.Name = "processDataGridView"; - this.processDataGridView.ReadOnly = true; - this.processDataGridView.RowHeadersVisible = false; - this.processDataGridView.ScrollBars = System.Windows.Forms.ScrollBars.Vertical; - this.processDataGridView.SelectionMode = System.Windows.Forms.DataGridViewSelectionMode.FullRowSelect; - this.processDataGridView.Size = new System.Drawing.Size(549, 291); - this.processDataGridView.TabIndex = 0; - this.processDataGridView.CellMouseDoubleClick += new System.Windows.Forms.DataGridViewCellMouseEventHandler(this.processDataGridView_CellMouseDoubleClick); - // - // iconColumn - // - this.iconColumn.DataPropertyName = "icon"; - this.iconColumn.HeaderText = ""; - this.iconColumn.MinimumWidth = 18; - this.iconColumn.Name = "iconColumn"; - this.iconColumn.ReadOnly = true; - this.iconColumn.Resizable = System.Windows.Forms.DataGridViewTriState.True; - this.iconColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.Automatic; - this.iconColumn.Width = 18; - // - // processNameColumn - // - this.processNameColumn.AutoSizeMode = System.Windows.Forms.DataGridViewAutoSizeColumnMode.AllCells; - this.processNameColumn.DataPropertyName = "name"; - this.processNameColumn.HeaderText = "Process"; - this.processNameColumn.Name = "processNameColumn"; - this.processNameColumn.ReadOnly = true; - this.processNameColumn.Width = 70; - // - // pidColumn - // - this.pidColumn.AutoSizeMode = System.Windows.Forms.DataGridViewAutoSizeColumnMode.AllCells; - this.pidColumn.DataPropertyName = "id"; - this.pidColumn.HeaderText = "PID"; - this.pidColumn.Name = "pidColumn"; - this.pidColumn.ReadOnly = true; - this.pidColumn.Width = 50; - // - // pathColumn - // - this.pathColumn.AutoSizeMode = System.Windows.Forms.DataGridViewAutoSizeColumnMode.Fill; - this.pathColumn.DataPropertyName = "path"; - this.pathColumn.HeaderText = "Path"; - this.pathColumn.Name = "pathColumn"; - this.pathColumn.ReadOnly = true; - // - // filterCheckBox - // - this.filterCheckBox.AutoSize = true; - this.filterCheckBox.Checked = true; - this.filterCheckBox.CheckState = System.Windows.Forms.CheckState.Checked; - this.filterCheckBox.Location = new System.Drawing.Point(9, 72); - this.filterCheckBox.Name = "filterCheckBox"; - this.filterCheckBox.Size = new System.Drawing.Size(158, 17); - this.filterCheckBox.TabIndex = 1; - this.filterCheckBox.Text = "Exclude common processes"; - this.filterCheckBox.UseVisualStyleBackColor = true; - this.filterCheckBox.CheckedChanged += new System.EventHandler(this.filterCheckBox_CheckedChanged); - // - // refreshButton - // - this.refreshButton.Image = global::ReClassNET.Properties.Resources.B16x16_Arrow_Refresh; - this.refreshButton.Location = new System.Drawing.Point(9, 99); - this.refreshButton.Name = "refreshButton"; - this.refreshButton.Size = new System.Drawing.Size(158, 23); - this.refreshButton.TabIndex = 2; - this.refreshButton.Text = "Refresh"; - this.refreshButton.TextAlign = System.Drawing.ContentAlignment.MiddleRight; - this.refreshButton.TextImageRelation = System.Windows.Forms.TextImageRelation.ImageBeforeText; - this.refreshButton.UseVisualStyleBackColor = true; - this.refreshButton.Click += new System.EventHandler(this.refreshButton_Click); - // - // attachToProcessButton - // - this.attachToProcessButton.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left) + this.processDataGridView.Location = new System.Drawing.Point(12, 222); + this.processDataGridView.MultiSelect = false; + this.processDataGridView.Name = "processDataGridView"; + this.processDataGridView.ReadOnly = true; + this.processDataGridView.RowHeadersVisible = false; + this.processDataGridView.ScrollBars = System.Windows.Forms.ScrollBars.Vertical; + this.processDataGridView.SelectionMode = System.Windows.Forms.DataGridViewSelectionMode.FullRowSelect; + this.processDataGridView.Size = new System.Drawing.Size(549, 291); + this.processDataGridView.TabIndex = 0; + this.processDataGridView.CellMouseDoubleClick += new System.Windows.Forms.DataGridViewCellMouseEventHandler(this.processDataGridView_CellMouseDoubleClick); + // + // iconColumn + // + this.iconColumn.DataPropertyName = "icon"; + this.iconColumn.HeaderText = ""; + this.iconColumn.MinimumWidth = 18; + this.iconColumn.Name = "iconColumn"; + this.iconColumn.ReadOnly = true; + this.iconColumn.Resizable = System.Windows.Forms.DataGridViewTriState.True; + this.iconColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.Automatic; + this.iconColumn.Width = 18; + // + // processNameColumn + // + this.processNameColumn.AutoSizeMode = System.Windows.Forms.DataGridViewAutoSizeColumnMode.AllCells; + this.processNameColumn.DataPropertyName = "name"; + this.processNameColumn.HeaderText = "Process"; + this.processNameColumn.Name = "processNameColumn"; + this.processNameColumn.ReadOnly = true; + this.processNameColumn.Width = 70; + // + // pidColumn + // + this.pidColumn.AutoSizeMode = System.Windows.Forms.DataGridViewAutoSizeColumnMode.AllCells; + this.pidColumn.DataPropertyName = "id"; + this.pidColumn.HeaderText = "PID"; + this.pidColumn.Name = "pidColumn"; + this.pidColumn.ReadOnly = true; + this.pidColumn.Width = 50; + // + // pathColumn + // + this.pathColumn.AutoSizeMode = System.Windows.Forms.DataGridViewAutoSizeColumnMode.Fill; + this.pathColumn.DataPropertyName = "path"; + this.pathColumn.HeaderText = "Path"; + this.pathColumn.Name = "pathColumn"; + this.pathColumn.ReadOnly = true; + // + // filterCheckBox + // + this.filterCheckBox.AutoSize = true; + this.filterCheckBox.Checked = true; + this.filterCheckBox.CheckState = System.Windows.Forms.CheckState.Checked; + this.filterCheckBox.Location = new System.Drawing.Point(9, 72); + this.filterCheckBox.Name = "filterCheckBox"; + this.filterCheckBox.Size = new System.Drawing.Size(158, 17); + this.filterCheckBox.TabIndex = 1; + this.filterCheckBox.Text = "Exclude common processes"; + this.filterCheckBox.UseVisualStyleBackColor = true; + this.filterCheckBox.CheckedChanged += new System.EventHandler(this.filterCheckBox_CheckedChanged); + // + // refreshButton + // + this.refreshButton.Image = global::ReClassNET.Properties.Resources.B16x16_Arrow_Refresh; + this.refreshButton.Location = new System.Drawing.Point(9, 99); + this.refreshButton.Name = "refreshButton"; + this.refreshButton.Size = new System.Drawing.Size(158, 23); + this.refreshButton.TabIndex = 2; + this.refreshButton.Text = "Refresh"; + this.refreshButton.TextAlign = System.Drawing.ContentAlignment.MiddleRight; + this.refreshButton.TextImageRelation = System.Windows.Forms.TextImageRelation.ImageBeforeText; + this.refreshButton.UseVisualStyleBackColor = true; + this.refreshButton.Click += new System.EventHandler(this.refreshButton_Click); + // + // attachToProcessButton + // + this.attachToProcessButton.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left) | System.Windows.Forms.AnchorStyles.Right))); - this.attachToProcessButton.DialogResult = System.Windows.Forms.DialogResult.OK; - this.attachToProcessButton.Image = global::ReClassNET.Properties.Resources.B16x16_Accept; - this.attachToProcessButton.Location = new System.Drawing.Point(12, 519); - this.attachToProcessButton.Name = "attachToProcessButton"; - this.attachToProcessButton.Size = new System.Drawing.Size(549, 23); - this.attachToProcessButton.TabIndex = 3; - this.attachToProcessButton.Text = "Attach to Process"; - this.attachToProcessButton.TextAlign = System.Drawing.ContentAlignment.MiddleRight; - this.attachToProcessButton.TextImageRelation = System.Windows.Forms.TextImageRelation.ImageBeforeText; - this.attachToProcessButton.UseVisualStyleBackColor = true; - // - // loadSymbolsCheckBox - // - this.loadSymbolsCheckBox.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left))); - this.loadSymbolsCheckBox.AutoSize = true; - this.loadSymbolsCheckBox.Location = new System.Drawing.Point(12, 496); - this.loadSymbolsCheckBox.Name = "loadSymbolsCheckBox"; - this.loadSymbolsCheckBox.Size = new System.Drawing.Size(92, 17); - this.loadSymbolsCheckBox.TabIndex = 4; - this.loadSymbolsCheckBox.Text = "Load Symbols"; - this.loadSymbolsCheckBox.UseVisualStyleBackColor = true; - // - // filterGroupBox - // - this.filterGroupBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + this.attachToProcessButton.DialogResult = System.Windows.Forms.DialogResult.OK; + this.attachToProcessButton.Image = global::ReClassNET.Properties.Resources.B16x16_Accept; + this.attachToProcessButton.Location = new System.Drawing.Point(12, 519); + this.attachToProcessButton.Name = "attachToProcessButton"; + this.attachToProcessButton.Size = new System.Drawing.Size(549, 23); + this.attachToProcessButton.TabIndex = 3; + this.attachToProcessButton.Text = "Attach to Process"; + this.attachToProcessButton.TextAlign = System.Drawing.ContentAlignment.MiddleRight; + this.attachToProcessButton.TextImageRelation = System.Windows.Forms.TextImageRelation.ImageBeforeText; + this.attachToProcessButton.UseVisualStyleBackColor = true; + // + // loadSymbolsCheckBox + // + this.loadSymbolsCheckBox.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left))); + this.loadSymbolsCheckBox.AutoSize = true; + this.loadSymbolsCheckBox.Location = new System.Drawing.Point(12, 496); + this.loadSymbolsCheckBox.Name = "loadSymbolsCheckBox"; + this.loadSymbolsCheckBox.Size = new System.Drawing.Size(92, 17); + this.loadSymbolsCheckBox.TabIndex = 4; + this.loadSymbolsCheckBox.Text = "Load Symbols"; + this.loadSymbolsCheckBox.UseVisualStyleBackColor = true; + // + // filterGroupBox + // + this.filterGroupBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) | System.Windows.Forms.AnchorStyles.Right))); - this.filterGroupBox.Controls.Add(this.previousProcessLinkLabel); - this.filterGroupBox.Controls.Add(this.label2); - this.filterGroupBox.Controls.Add(this.label1); - this.filterGroupBox.Controls.Add(this.filterCheckBox); - this.filterGroupBox.Controls.Add(this.refreshButton); - this.filterGroupBox.Controls.Add(this.filterTextBox); - this.filterGroupBox.Location = new System.Drawing.Point(12, 60); - this.filterGroupBox.Name = "filterGroupBox"; - this.filterGroupBox.Size = new System.Drawing.Size(549, 133); - this.filterGroupBox.TabIndex = 5; - this.filterGroupBox.TabStop = false; - this.filterGroupBox.Text = "Filter"; - // - // previousProcessLinkLabel - // - this.previousProcessLinkLabel.AutoSize = true; - this.previousProcessLinkLabel.Location = new System.Drawing.Point(103, 47); - this.previousProcessLinkLabel.Name = "previousProcessLinkLabel"; - this.previousProcessLinkLabel.Size = new System.Drawing.Size(19, 13); - this.previousProcessLinkLabel.TabIndex = 3; - this.previousProcessLinkLabel.TabStop = true; - this.previousProcessLinkLabel.Text = "<>"; - this.previousProcessLinkLabel.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.previousProcessLinkLabel_LinkClicked); - // - // label2 - // - this.label2.AutoSize = true; - this.label2.Location = new System.Drawing.Point(6, 47); - this.label2.Name = "label2"; - this.label2.Size = new System.Drawing.Size(92, 13); - this.label2.TabIndex = 2; - this.label2.Text = "Previous Process:"; - // - // label1 - // - this.label1.AutoSize = true; - this.label1.Location = new System.Drawing.Point(6, 22); - this.label1.Name = "label1"; - this.label1.Size = new System.Drawing.Size(79, 13); - this.label1.TabIndex = 1; - this.label1.Text = "Process Name:"; - // - // filterTextBox - // - this.filterTextBox.Location = new System.Drawing.Point(103, 19); - this.filterTextBox.Name = "filterTextBox"; - this.filterTextBox.Size = new System.Drawing.Size(270, 20); - this.filterTextBox.TabIndex = 0; - this.filterTextBox.TextChanged += new System.EventHandler(this.filterTextBox_TextChanged); - // - // bannerBox - // - this.bannerBox.Dock = System.Windows.Forms.DockStyle.Top; - this.bannerBox.Icon = global::ReClassNET.Properties.Resources.B32x32_Magnifier; - this.bannerBox.Location = new System.Drawing.Point(0, 0); - this.bannerBox.Name = "bannerBox"; - this.bannerBox.Size = new System.Drawing.Size(573, 48); - this.bannerBox.TabIndex = 6; - this.bannerBox.Text = "Select the process to which ReClass.NET is to be attached."; - this.bannerBox.Title = "Attach to Process"; - // - // ProcessBrowserForm - // - this.AcceptButton = this.attachToProcessButton; - this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); - this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; - this.ClientSize = new System.Drawing.Size(573, 554); - this.Controls.Add(this.bannerBox); - this.Controls.Add(this.filterGroupBox); - this.Controls.Add(this.loadSymbolsCheckBox); - this.Controls.Add(this.attachToProcessButton); - this.Controls.Add(this.processDataGridView); - this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; - this.MaximizeBox = false; - this.MinimizeBox = false; - this.Name = "ProcessBrowserForm"; - this.ShowInTaskbar = false; - this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; - this.Text = "ReClass.NET - Attach to Process"; - ((System.ComponentModel.ISupportInitialize)(this.processDataGridView)).EndInit(); - this.filterGroupBox.ResumeLayout(false); - this.filterGroupBox.PerformLayout(); - ((System.ComponentModel.ISupportInitialize)(this.bannerBox)).EndInit(); - this.ResumeLayout(false); - this.PerformLayout(); - + this.filterGroupBox.Controls.Add(this.networkingButton); + this.filterGroupBox.Controls.Add(this.previousProcessLinkLabel); + this.filterGroupBox.Controls.Add(this.label2); + this.filterGroupBox.Controls.Add(this.label1); + this.filterGroupBox.Controls.Add(this.filterCheckBox); + this.filterGroupBox.Controls.Add(this.refreshButton); + this.filterGroupBox.Controls.Add(this.filterTextBox); + this.filterGroupBox.Location = new System.Drawing.Point(12, 60); + this.filterGroupBox.Name = "filterGroupBox"; + this.filterGroupBox.Size = new System.Drawing.Size(549, 156); + this.filterGroupBox.TabIndex = 5; + this.filterGroupBox.TabStop = false; + this.filterGroupBox.Text = "Filter"; + // + // networkingButton + // + this.networkingButton.Location = new System.Drawing.Point(10, 127); + this.networkingButton.Name = "networkingButton"; + this.networkingButton.Size = new System.Drawing.Size(157, 23); + this.networkingButton.TabIndex = 4; + this.networkingButton.Text = "Networking"; + this.networkingButton.UseVisualStyleBackColor = true; + this.networkingButton.Click += new System.EventHandler(this.button1_Click); + // + // previousProcessLinkLabel + // + this.previousProcessLinkLabel.AutoSize = true; + this.previousProcessLinkLabel.Location = new System.Drawing.Point(103, 47); + this.previousProcessLinkLabel.Name = "previousProcessLinkLabel"; + this.previousProcessLinkLabel.Size = new System.Drawing.Size(19, 13); + this.previousProcessLinkLabel.TabIndex = 3; + this.previousProcessLinkLabel.TabStop = true; + this.previousProcessLinkLabel.Text = "<>"; + this.previousProcessLinkLabel.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.previousProcessLinkLabel_LinkClicked); + // + // label2 + // + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(6, 47); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(92, 13); + this.label2.TabIndex = 2; + this.label2.Text = "Previous Process:"; + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(6, 22); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(79, 13); + this.label1.TabIndex = 1; + this.label1.Text = "Process Name:"; + // + // filterTextBox + // + this.filterTextBox.Location = new System.Drawing.Point(103, 19); + this.filterTextBox.Name = "filterTextBox"; + this.filterTextBox.Size = new System.Drawing.Size(270, 20); + this.filterTextBox.TabIndex = 0; + this.filterTextBox.TextChanged += new System.EventHandler(this.filterTextBox_TextChanged); + // + // bannerBox + // + this.bannerBox.Dock = System.Windows.Forms.DockStyle.Top; + this.bannerBox.Icon = global::ReClassNET.Properties.Resources.B32x32_Magnifier; + this.bannerBox.Location = new System.Drawing.Point(0, 0); + this.bannerBox.Name = "bannerBox"; + this.bannerBox.Size = new System.Drawing.Size(573, 48); + this.bannerBox.TabIndex = 6; + this.bannerBox.Text = "Select the process to which ReClass.NET is to be attached."; + this.bannerBox.Title = "Attach to Process"; + // + // ProcessBrowserForm + // + this.AcceptButton = this.attachToProcessButton; + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(573, 554); + this.Controls.Add(this.bannerBox); + this.Controls.Add(this.filterGroupBox); + this.Controls.Add(this.loadSymbolsCheckBox); + this.Controls.Add(this.attachToProcessButton); + this.Controls.Add(this.processDataGridView); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "ProcessBrowserForm"; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; + this.Text = "ReClass.NET - Attach to Process"; + ((System.ComponentModel.ISupportInitialize)(this.processDataGridView)).EndInit(); + this.filterGroupBox.ResumeLayout(false); + this.filterGroupBox.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.bannerBox)).EndInit(); + this.ResumeLayout(false); + this.PerformLayout(); } #endregion @@ -274,5 +286,6 @@ private void InitializeComponent() private System.Windows.Forms.Label label1; private System.Windows.Forms.TextBox filterTextBox; private BannerBox bannerBox; + private System.Windows.Forms.Button networkingButton; } } \ No newline at end of file diff --git a/ReClass.NET/Forms/ProcessBrowserForm.cs b/ReClass.NET/Forms/ProcessBrowserForm.cs index d4ed7cb3..a87316be 100644 --- a/ReClass.NET/Forms/ProcessBrowserForm.cs +++ b/ReClass.NET/Forms/ProcessBrowserForm.cs @@ -13,6 +13,8 @@ public partial class ProcessBrowserForm : IconForm { private const string NoPreviousProcess = "No previous process"; + public NetworkingForm networkingForm; + private static readonly string[] commonProcesses = { "[system process]", "system", "svchost.exe", "services.exe", "wininit.exe", @@ -135,5 +137,16 @@ private void ApplyFilter() } ((DataTable)processDataGridView.DataSource).DefaultView.RowFilter = filter; } + + private void button1_Click(object sender, EventArgs e) + { + networkingForm = new NetworkingForm(); + networkingForm.ShowDialog(); + + if (networkingForm.mConnected == true) + { + RefreshProcessList(); + } + } } } diff --git a/ReClass.NET/ReClass.NET.csproj b/ReClass.NET/ReClass.NET.csproj index 0c990cc2..416a041d 100644 --- a/ReClass.NET/ReClass.NET.csproj +++ b/ReClass.NET/ReClass.NET.csproj @@ -231,6 +231,12 @@ InputCorrelatorForm.cs + + Form + + + NetworkingForm.cs + Form @@ -561,6 +567,9 @@ InputCorrelatorForm.cs + + NetworkingForm.cs + ScannerForm.cs