From f9298b454a16aeecc91d5aee5fe0380cb08f61fa Mon Sep 17 00:00:00 2001 From: Florian Baader Date: Wed, 10 Feb 2016 23:40:23 +0100 Subject: [PATCH] Updated Source Code to Version v0.3 v0.3 +Added tooltip messages to system tray icon +Leftclick on icon opens settingsform +Some GUI updates +Code improvements +Better user experience --- SourceCode/InputMonitor.cpp | 8 +- SourceCode/InputMonitor.h | 6 +- SourceCode/MessageWindow.cpp | 23 + SourceCode/MessageWindow.h | 125 ++ SourceCode/MessageWindow.resx | 259 ++++ SourceCode/MetroSettingsForm.cpp | 212 ++- SourceCode/MetroSettingsForm.h | 280 +--- SourceCode/MetroSettingsForm.resx | 899 +++++++++++ SourceCode/ProcessItem.cpp | 4 +- SourceCode/ProcessItem.h | 2 +- SourceCode/ProcessSelectionForm.cpp | 39 +- SourceCode/ProcessSelectionForm.h | 43 +- SourceCode/ProcessSelectionForm.resx | 123 ++ SourceCode/Setting.h | 3 +- SourceCode/SettingsProvider.cpp | 45 +- SourceCode/SettingsProvider.h | 17 +- SourceCode/Systemaccess.cpp | 2 +- SourceCode/TimeoutWindow.cpp | 55 + SourceCode/TimeoutWindow.h | 58 +- SourceCode/TimeoutWindow.resx | 2119 ++++++++++++++++++++++++++ SourceCode/resource1.h | Bin 998 -> 992 bytes SourceCode/standbye_main.cpp | 120 +- SourceCode/standbye_main.h | 50 +- 23 files changed, 4062 insertions(+), 430 deletions(-) create mode 100644 SourceCode/MessageWindow.cpp create mode 100644 SourceCode/MessageWindow.h create mode 100644 SourceCode/MessageWindow.resx create mode 100644 SourceCode/MetroSettingsForm.resx create mode 100644 SourceCode/ProcessSelectionForm.resx create mode 100644 SourceCode/TimeoutWindow.cpp create mode 100644 SourceCode/TimeoutWindow.resx diff --git a/SourceCode/InputMonitor.cpp b/SourceCode/InputMonitor.cpp index 4c14125..3bced30 100644 --- a/SourceCode/InputMonitor.cpp +++ b/SourceCode/InputMonitor.cpp @@ -1,11 +1,13 @@ #include "stdafx.h" #include "InputMonitor.h" +#include "standbye_main.h" //Is needed here to prevent cross including + #define TO_MILLISECONDS(X) ((X) * 1000) -InputMonitor::InputMonitor(SettingsProvider* s, void(*f)()) { +InputMonitor::InputMonitor(mainApplication^ parent, SettingsProvider* s) { aborted = false; - OnFinished = f; + this->parent = parent; settings_provider = s; Start(); } @@ -24,7 +26,7 @@ void InputMonitor::Monitor() { if (SystemAccess::GetLastInputTime() > wait_time) { DEBUG("Wait Time is over!"); - OnFinished(); + parent->CheckUsage(); } //Sleep only 10 milliseconds at once to handle to Close() Event for (int x = 0; x < wait_time; x = x + 10) { diff --git a/SourceCode/InputMonitor.h b/SourceCode/InputMonitor.h index 4872c64..83210be 100644 --- a/SourceCode/InputMonitor.h +++ b/SourceCode/InputMonitor.h @@ -4,17 +4,19 @@ #include "SystemMetricWatcher.h" #include "SystemAccess.h" +ref class mainApplication; + ref class InputMonitor { private: - void(*OnFinished)(); int wait_time; bool aborted; + mainApplication^ parent; ThreadStart^ thread_start; Thread^ watcher; SettingsProvider* settings_provider; public: - InputMonitor(SettingsProvider* s, void(*f)()); + InputMonitor(mainApplication^ parent, SettingsProvider* s); ~InputMonitor(); void Reset(); diff --git a/SourceCode/MessageWindow.cpp b/SourceCode/MessageWindow.cpp new file mode 100644 index 0000000..a848c44 --- /dev/null +++ b/SourceCode/MessageWindow.cpp @@ -0,0 +1,23 @@ +#include "stdafx.h" +#include "MessageWindow.h" +using namespace StandBye; + +System::Void MessageWindow::TimeoutWindow_Load(System::Object^, System::EventArgs^) { + this->ControlBox = true; + this->MaximizeBox = false; + this->MinimizeBox = false; + + //Gets the Working Space + Drawing::Rectangle WorkArea = Screen::PrimaryScreen->WorkingArea; + this->Location = Point((WorkArea.Width - this->Size.Width) / 2, (WorkArea.Height - this->Size.Height) / 2); + this->Update(); + System::Media::SystemSounds::Asterisk->Play(); +} +System::Void MessageWindow::metroButtonOK_Click(System::Object^ sender, System::EventArgs^ e) { + this->DialogResult = Windows::Forms::DialogResult::OK; + this->Close(); +} +System::Void MessageWindow::metroButtonCancel_Click(System::Object^ sender, System::EventArgs^ e) { + this->DialogResult = Windows::Forms::DialogResult::Cancel; + this->Close(); +} \ No newline at end of file diff --git a/SourceCode/MessageWindow.h b/SourceCode/MessageWindow.h new file mode 100644 index 0000000..7eb51e8 --- /dev/null +++ b/SourceCode/MessageWindow.h @@ -0,0 +1,125 @@ +#pragma once +#include "stdafx.h" + +using namespace System; +using namespace System::ComponentModel; +using namespace System::Collections; +using namespace System::Windows::Forms; +using namespace System::Data; +using namespace System::Drawing; +using namespace System::Threading; + +/// +/// Summary for TimeoutWindow +/// +namespace StandBye { + public ref class MessageWindow : public MetroFramework::Forms::MetroForm + { + private: MetroFramework::Controls::MetroButton^ metroButtonCancel; + + private: MetroFramework::Controls::MetroLabel^ metroLabel1; + + private: MetroFramework::Controls::MetroButton^ metroButtonOK; + public: + MessageWindow(String^ text) { + InitializeComponent(); + metroLabel1->Text = text; + } + + protected: + /// + /// Clean up any resources being used. + /// + ~MessageWindow() + { + if (components) + { + delete components; + } + } + + protected: + + private: System::ComponentModel::IContainer^ components; + + private: + /// + /// Required designer variable. + /// + +#pragma region Windows Form Designer generated code + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + void InitializeComponent(void) + { + System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(MessageWindow::typeid)); + this->metroButtonCancel = (gcnew MetroFramework::Controls::MetroButton()); + this->metroButtonOK = (gcnew MetroFramework::Controls::MetroButton()); + this->metroLabel1 = (gcnew MetroFramework::Controls::MetroLabel()); + this->SuspendLayout(); + // + // metroButtonCancel + // + this->metroButtonCancel->Location = System::Drawing::Point(167, 154); + this->metroButtonCancel->Name = L"metroButtonCancel"; + this->metroButtonCancel->Size = System::Drawing::Size(92, 35); + this->metroButtonCancel->TabIndex = 3; + this->metroButtonCancel->Text = L"No"; + this->metroButtonCancel->UseSelectable = true; + this->metroButtonCancel->Click += gcnew System::EventHandler(this, &MessageWindow::metroButtonCancel_Click); + // + // metroButtonOK + // + this->metroButtonOK->Location = System::Drawing::Point(276, 154); + this->metroButtonOK->Name = L"metroButtonOK"; + this->metroButtonOK->Size = System::Drawing::Size(92, 35); + this->metroButtonOK->TabIndex = 4; + this->metroButtonOK->Text = L"Yes"; + this->metroButtonOK->UseSelectable = true; + this->metroButtonOK->Click += gcnew System::EventHandler(this, &MessageWindow::metroButtonOK_Click); + // + // metroLabel1 + // + this->metroLabel1->AutoSize = true; + this->metroLabel1->FontSize = MetroFramework::MetroLabelSize::Tall; + this->metroLabel1->Location = System::Drawing::Point(39, 72); + this->metroLabel1->Name = L"metroLabel1"; + this->metroLabel1->Size = System::Drawing::Size(103, 25); + this->metroLabel1->TabIndex = 6; + this->metroLabel1->Text = L"metroLabel1"; + this->metroLabel1->WrapToLine = true; + // + // MessageWindow + // + this->AeroWindowSnapActive = false; + this->AutoScaleDimensions = System::Drawing::SizeF(6, 13); + this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font; + this->BackColor = System::Drawing::Color::FromArgb(static_cast(static_cast(255)), static_cast(static_cast(255)), + static_cast(static_cast(255))); + this->BackImage = (cli::safe_cast(resources->GetObject(L"$this.BackImage"))); + this->BackImagePadding = System::Windows::Forms::Padding(0, 10, 0, 0); + this->BackMaxSize = 50; + this->ClientSize = System::Drawing::Size(400, 200); + this->ControlBox = false; + this->Controls->Add(this->metroLabel1); + this->Controls->Add(this->metroButtonOK); + this->Controls->Add(this->metroButtonCancel); + this->Location = System::Drawing::Point(100, 100); + this->Name = L"MessageWindow"; + this->Resizable = false; + this->StartPosition = System::Windows::Forms::FormStartPosition::Manual; + this->Style = MetroFramework::MetroColorStyle::Green; + this->Text = L" Stand-Bye!"; + this->TopMost = true; + this->Load += gcnew System::EventHandler(this, &MessageWindow::TimeoutWindow_Load); + this->ResumeLayout(false); + this->PerformLayout(); + } +#pragma endregion + private: System::Void MessageWindow::TimeoutWindow_Load(System::Object^, System::EventArgs^); + private: System::Void metroButtonOK_Click(System::Object^ sender, System::EventArgs^ e); + private: System::Void metroButtonCancel_Click(System::Object^ sender, System::EventArgs^ e); + }; +} diff --git a/SourceCode/MessageWindow.resx b/SourceCode/MessageWindow.resx new file mode 100644 index 0000000..9c492c1 --- /dev/null +++ b/SourceCode/MessageWindow.resx @@ -0,0 +1,259 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAo + mgAAKJoBFzohsgAAHuFJREFUeF7tXXlwVdd5R0gILQVJIAntgDDGxkY2u21WA0KAhCTQvu8rQgsSQkgC + iUVgdmMMeDKp207bxEmT/NPJ2jRxksZZnTZtM87E6ea2cdI0GSdO4qw9/X7fve/pSfrue/c+vU0SZ+Y3 + o9G7957l+863ne+cM282luDwSLUwcYWKfGSjitq0Vy3ZfVTFHaxWy460qcTSHpVUeUqlNIyo1NYxldoy + plLqz9L/+lViSTc900rPVqklu46oqI17VOSaDWphQpqaHxah9M8/KIFU5i8MV+Fpa1TUlkwVl12nkmsG + ibCXvIKkqgFijhpmqrCU1Wp+6MIHTOHrEhQ0n2dk1Nb9allBO89giVg+QfNFlhhgiNC4FBUUFPSAIbxR + MLBhSSvVkp15Xp3h00VS1SkVsy1HLVyWqqjRD5hhuiUkcjHr4aSKk+KABzISy06oxU/uVLBH9O48KGYL + ZlBsZhmLWGlwZxSaLqile4pUaGziA0ZwVcJSHlLxeU3yQM4CxGXXkv2y/AEjTC4YlPi8ZnHQZiPgrYTG + JT1ghJDFMSp2f7k4SLMfY6QaClUw2Tn6cMydEhQcwsZdStN5YWDmFhCQWpyxXQXNnz83GGHhsjSOuEmD + MZeRUNihQpfOYkMxKDhYRW3N8m/gRsdTnafUjq4+9XRnv9rSOaA2HB9UGR1n1NpjI2pFmz8DSxfU4g27 + Z580CIlaqhIKjsmd9jGWE4F/8mKkUi/NExCkthJzSO/5EvCEgiOjZgcTRKxcy4stUkf9gYMnOgTCa3jz + drz4jj+QXDukwskt1odx5hWEb6M2Z4qd8ycujRwUiQ/88cVt4jt+A6nLRU/smHlMEBSygNy7MrlTfsYX + r60WiQ/U9NeI7/gbWM4Omh88MxgB6+bLjrSIHfE3VrefV+/dXyAS/zf3Q9Sa1jMBYaRKQPBo/oIAX34O + jlikEou7xA4EAspO1ovEB758ZTmvNKY0nqNnA5MJlh1tU/MXBmhiCqxWrIBJDQ8U3Du3UyQ+cLH3Kc4W + Sq4bZndMej8QkFB0XAWHBdgKI8/8sl6xwYGEf7yZLBIf2FeZT4PbqTNAYK9CggmQCaUPv38LdH7CDIjs + PXFsSP0f+fkS8X/8QphaltvAEUp2WQPUDnAEqwN/2wSw9pESJTUw0NA2UCoSH/jomXQVn9/MiScpTbAB + 5G8EGmAY+s07gJ8fm1UhNiwQ8YGxzSLxgeOtOzi/MKn6dEDrfwlwEXWS+LZEb9kvNigwMabeeiFGJD7C + vxmFpeP6v2XmZSEtfmK7b5kgIv1xsSFmcaS3VVX214u/eQM7uk4IhNfwxrUYFZ/bxB5MSsMoPe97/d80 + UKkO9BwXfzMFslmQTaWTx7tlQXSsvqlCaIgJNA5UqV/fX8Co6q8Tn/E0BodyReID9/sf48AVNob4Iz+h + 7XS5+v1Lwerde2Gq7GSD+IwZYO3A6wtISORIKHSfU7sGi6mz8+2D7ysm+MRzj00guiOK6/bzSiWnm/tY + /9uIb2sLopH1p6rFZ81gWV6Twr4JnVyeL9FPHxQrNoOewSL1Bwfi2wAmqPQiE6xovaDeuRs+pV6u+16w + SsurUQnFXeT+IQzsO/0/mfg2/O5+sGo8VSW+YwbIJ9DJ5dmCvXbu+setA+Ui8W3wJhMcPtEm1gm8eiGJ + 194Ty3tVSqPv9L8R8W2AJKhw10YiKebxzCL4++6GeUtONnKHpI46wltMcHUkU6wPGO3cxAEV7PlD/r70 + vqcB4v/OCfFt+OW9hSrnhHtJNAmFxzybVYSNl1JFrvBsd4/6mYH4leANJnjt+kqxLmB3eT7bNDCgfBH+ + dTXzJ+N/XlzE6WvSt1xhkadcw5CoWLeMo8ePnVX/djtW7JgzeJIJ1rSPqN8aSJ8f3Q7Xw789Pgn/WiW+ + Df98K0k93G49OglPzSMp59hXL1XgDGltl9Rnrz4qdsgMfno3ghlI+rYVVJ+sEb8PfHh4lc/Cv0hANWJE + M/jo5Q3id10B+w50MrpXwpLTxQ+7woWzh8SOmAHEXrabum8y3nd+u1gH0N6yk8O/yT4K/7YMVBgmo5hB + 71Ch+F3nGFOhse7uQAoKIgOpXfioc2T1dLrN7W/djlbbO3rE77qDN24liPVgVfCxgjIfh3/H1NGeRrKJ + wsQ2ucIvyCjcTpJE/rYxsGCkU9RaCV/xiPhBZ0hvu6i+cytR7IAr/MetxWpTbZNKqfVMQsaGjtOGy7+/ + uz9fvX4lXn3rWoL61o0U9fc3U51i+jYJ2RdN56lvQyqrqVy98+JCsV2u8LUbKzmtXa7DGG5tSHVn9l8Z + 3S823BV++HyE2lRUoJblt6jE0hMqpe7MtJmg83SxWJd1eGCvAPUFjI2MI/TxQEW2+sVd99TB4HC+XIcT + YFeyTlZzxR3d/0xnv1s67hcvLlDPlmSr2ANV3FAc5MSG2TQXZj58aYNYn1V8/3ac+H3TIO8ipX5EJZX3 + ce5E3KFa6mulKqnew5JIqtMZENV8soPcVqkuJ7B0PoE7lv/Hr6wTG+wMENFVdbs4ryA2q5IGp0aTAojM + 0aC5q5vTiHHevhMl1mkVf3rxabEO06A+pNSdZcmGLfAYW/QVfT7Vbpyj4Ax/MbZVrssJcEiFTl7nJWTx + Ess+cX4vwq2yvnWGmz2PjxOfBiY+t5Hz3WCZaytz7kmAZ7u7xfrcQUM/kl7cl0R4F5nGyVWnVEJBh4o/ + 3KBiHZjglcF0sV5nwILanm6LxnLTBXPH1UQ/dUD+gBN8+foqsaHO8LVL8SrhYPlU4lcNTDsuf3Y4R6zT + Kn5PIvqRRlJHSBWfTqAIUqCB1EBlP+8CHmeCCpWWXaLevL5YrN8ZPn7Fek4GzizSySwXxI/ZLxZeNkJh + X7PYQGf45d0Qtelo3jjxaUA04tPM90Be/qb2PrW3pU7tripSO0sPq53F2Q7IUbtKc9WuiqP8+76aQvXe + Pdlt/caVRC1V3BOeCTPBKB9SqTFBPTFBFTNBZulBZjapDUaA+szssbYHA31xenpZeNrD4ovO8Lmra8QG + OsOZjo3ccQwAEx/xeJ750yc+i1waaCxeIdMHxqWmZhwAg5MYD4c+wiKX2ghc713PxOJcQU8sFtmZgCRB + wTEVn0NMoLfvTu9asQ3O8LHL6+V6nCAUR9gZFRgK0ktGwGKPka9thO9cjdFEP3U8PqeOB4KPbvXUciwN + MoI7CPJoA6zpWiNc7npCbCdwuDpbk0yeXCyyqQPydBLI1UagBmORll2q/uuW0bZ1Gcgd2HzcmsSO2ZYt + MwAOcLC6jfvli8+IDXOGgqq9TBS4Q+Mun/sW/xSQqEZ2zzJiLLiVNmPLCK9dXCa2811yT5Pz6ryzVwBM + QN9k1zB/3DVsbdwmtsUZbo7uk+swAA6zFE80DUtdLb5gBGy0NMq0McIXLiTQoOvuHrlEnIjJg+u5UCy8 + B6zvI5CF2YW6IOolrDhcoX5Ls0hq62fOpWqLRUQkTTXJ9bkNBIfqzmjBIVJVbAsdqFD/dMUoe1nGf9+J + tnyqSWhc8lQGwBGn0sNGaD9dJjbIGXIq9tv1PjaRaqLVswsxYIDk6kHt5G+SAkj4MEJFs/Gi1VDHVnpG + 3yvgrWQRtJWkFasrGIWkCmrqjPcvGsFqMinONtbJPl7AidLDRvjUFeNESwlfvxSniX6alZyESaJIW4b1 + oGgFWMeOMnOBeEnkWRjhfWeNAzE7yo5q+t+ri0VajABGIRgSqgBSwKpb+MqlTcK3jQG1o5NdK0gckB40 + wpr2Ucth36aG7SzmlrFYtUX6PEx8G/BdSBYAs1fEefXdW/FiW99+PoI8CJJSNCm0FHgvtRPQ7QGoQ2T1 + YowGLEYIf3o3Uq1ss8CkZNBO2FcY8VCG/KABGk5Vig0xwk9eCFNJh8rZKk8o7iSx53nRbxUbOwaobbIH + 86Ghh4hRW8hAxV4BL+j/yaCx0FRBB3tG6YdL1K/uWltSL+izdtIq7jvQyW9d///5xa1iI4zw/v41muF3 + pFWz+n2YgWuErtNFYluB9lYki/hyr4AWu0iqgFfQwgbqx4ZXiG0zwp1zzwrfNcYEO8DqDt9/uR0nNsII + ORVZWsCHDT9E1bylU83jI5fWi22FVFhXWKZJKixLe03/TwJLgSF7/KKqbrfQNmO8fiNN/q4BoGqY+PAJ + tRkpPzgZ6zsGqULzwZ//xd77bNzXQ7Mf2688Eu2bHrBa+MM7sqHlv72CMAghBU6yFEjLqVDvWVADcGcf + bjNPR7jKzAAhUUvEB4xQ118lNsAIHxleqel+pF8FyOzf290lthV4ifcKglnhpfh4r6BNChQeZ1vgb88b + n2gi4cgJa3YAnzISvnyN+KMRbo7sFSs3QnfbMxz04YCKT2eUMUbPGMf/y+ozOf7vH0PVto7Ry1LoXOdG + sY1GwCqo/F0ZOLd53qJ1Vg5HHFMfd7LRUsK20iPk92NAfb/50gifvfqI2FaI0ZX5NSqhxPd7Be0gFxUr + sghC5VRZy67+y4vW4gGRD69X5AFkiz+KoAH57i05di4B6V4JPtx8YQbpbec5w1Zq72tjCfpeQYR//SSt + EBdAiJgM5hX51eoPFuytr163tn8TR/bPs3JhQxrN4F/dCxUrl/D6c3G+9adNoKC3SWwrcLlnA0fkfLlX + UAJHB8tPcgrZv94wHxV8mwxbKzYWLsecF08Ekn6UkNGG4IlcuYQPn3lIC/v6Qfwvb9NOBp+M50efFdsK + jHZtViXNeaqsq1xV9NWqipP1duBYeakerwDGINRAQbv6m/OpYlslYAf2ymbzngDWHiysAYypfcePiRUb + 4Wbfer/svQeK+ppZ1EOEOsKd3MUvXV/Nq59SPV4BjZUtp+Hl09YSRZANJX5TAK8JmE4BI91S1FMrVmqE + U5072KL1lz4t7muypLIk+Jz4jPGspsu91tYFMo9jP4e5scb5jvM010x+YAKIK+t7jc/ak9Dcvl8L/vja + n3bAdJjAP8TXAJsJQaH+LmvLw0e760xLW9BmnmmjgfRS+8mjYqVGqGg9HBDuX3Ffo2Um+NK1h4j4Nsnl + B2+AjFAsZ3ccNz7gQkJ5T4VpQzCZPLN50g8iiIhdfcanbUkoaj2iRf98rP8Z+pIwpA9mE9SXWSb44pV0 + 9VDjIInhEVZfLMG4Dz5kBBiCtUOqucP4ggsJ1T0l5iccjZF5BqBBsMoAxW2F2j4/XzMAdQyuFCeFkEsH + UQdXtKC1SP3SxZ68L1xKVSvLj3MuAOwXiGFIMV7DsOBjTxs0ZliMaj5uHLWUUNNNDGDWhWUGMCkuMAva + T+SJlRqhouOodxM/jECDx0mXRHhY0vDt4e4ivJpfc5D3JUjtffViEp8aFn+4kZ5t5BgGsoLARL5nAGJi + 6sOxbmvRwPLOUk1iSd+cBNDGtBGIAajvtmYDtHTn+in+T4NHYh8bTXh5FUmXyBA+WM2+b15l5hQmePVC + okrNLuPf8RxS18AAnBXkiY0hlgEGGFH9fdZsgCPHKrjv8jcnAgte89hIE36cCIjUUVV0zJoXcOpkFr/n + ewYgQArYtmPxnjzsxNG2YwGOTMDEP1Sq/cYp63rWMrlJvCjEM8oPTEyT5/Jpa17AvpY6TVqJ35wI9G8e + dq1KP06ExgB7m63FAW4ObdcZQPqmDzCBCY7pTDC+UwhM8MmR1AAkPqAxwMsj1lYEN9a3mWYALHvPg5iT + fpwIrTHratrFSo3wofMZphvjNbhgAjsCiviANuk+c8n4lrPJwC6t5ZUn9Ennut2cFYTOSz9OhMYAyeW9 + 6tcGGyklfONaiv8ZAJjMBNgy5sgEAUd8QGOAN2+ZP2rvRy9EWlrJ5MUgcwmhWmNwcMP3bpjfuYIDkVK5 + MdI3fQxREsAoDETiA2NqVdOwpVNEvv5cItFI384ufnMiODF0UcZ28ceJsDFAn/rkeeOTNyVsP4YtzP4e + TB1TmKBBs/YDjvjAmMrpsrb1/gNnH1WJyLo26QVErtmg5oWveFT8cTLwUXz8Vv8msXIjdA0cpfcDhAEA + RyYgHx/p33D1Aov4hJYxNTJkLQp4tmcb98tsHGBh4nLFF0BIP04GPgq/sb4tS6zcCK+MbeDOSN/0G5gJ + yKYhFzipekCLVgYS8QFq46ees3ba6pHGfD2ZxRwDBIdFKD4VxJTOwOIEffzJ8mqxciMgSyWNOiN+068g + YutrBVo0NLCYNL31nHrXwqGSOGFkVXGT6c2sSAPgtHAUhEqlhyaABiuJZgySFd+6tUhshBGye6yfOTjX + gYwkaSyN8O2rsfpuJlJlJqKWE84OjNmRKz40ATRLsLiClOkPDj8sNsII98/tlL/5AIb44Jg1W+te/zq2 + aczuZo7avG+cASJXPyk+NAH0UaxOIcWrucU4r07CD+5EqRWtgagGAhOr289ZumcBKK4/yBk+ZrOvw9PW + jDNAyKJo8aGJQDBohC3m1UerLJ9yWdvv/mVIcw3dg4XiGBrh3RdDVUp+vfntbMQg80PDxhkABUEe8WEH + wFhELADpyp+/kCQ2xgivXrN2BM1cxj/cTBHH0AgfO7OSl7t557WJGADsOJ3s42XJjjzx4QnQPQEYjZ2t + Vg80ClJZ07kccY6g+KTxvgUjVDfsZaKyB2DCAIzekjmVAcKXmzge3sEQTM+rsHyIgTunW841vHbd2tGx + OHwjObfGkgG4MCFtKgPgZjBNf8gvMfQsFYRNEUZ9ZeghsVFGwGqVuzdhzQVgA4o0bs5w/+RaokWjlrhi + IvsK/r/h5ZJLM0vFlxwBOwA7fWEHZJVbvxrmazdW8J1C0rfnMla2jak3nrd22QYm1FNF+Zy5ZFb/Q9Xr + 5J5awlesFV+aALIDeNsS6RycavWNS9ZOCwG6B4vlb89hjJ6xfsD1Z86lcEAHC1tm0+9xAahO7qkFp4Vy + Grfwoh0cDxjmeADW1astHmUC/ORupFrvxqUHsxW4bMNox7IzHK7cz6o4sRj+v+vs68SKPvmUUMcS84yr + 7eLjS8PYSh1/qIrP/5Ua6AyfvrJWpYnfn1vAKZ9fuWH9zoAvX1w2fuwexL+J9RzeDu6qLIgxcUUKiRpt + 96p2Hm9VrXUpAAyfMeF6znJcH7WW9WsDTl3VDt00efgGeXCmL5KEaBc/YoPdG+hhCzTuYJX66ph86KIz + 4E7hvF4TC1GzFLiNzNml2kb45GiqQvo69i7wJVsmrH8Y+Dp5XRcz9wbA4kR+ADJLkVK1r/SQvv1abrQR + tPtx+8U6ZjNw5YvVeD/wm3vBamtBHhvg44dZuF7/X+jsnoAphQwFBBakD9kBY5AMRjYG9YOOXz5lbZXQ + hjdvL1MZHS6Mz1mEzccH1H++YN1uAm72rNNmv834M7H1DpJCp6z5ErFqnfixcWjGIAwQ+KE43XJVTrH6 + wfMRYsNd4ds3U9RjHrgvONCx/vgQMbx1dQl8//pilXKoTEtitXDuYljyKusMAHcB26qkD9phCw0X227n + qFJlNVgqtq4KADBBRgdxtFTXLABu93CX+H+4H6QOlWc5zH791FWXs7/JOvFtxfUZgg5SQLcFcCHEn7ip + CoDvkTqYjTbB7u4T6q0Xloh9NgPtij09hd3C7Bfj/lYKuE36sB0sBYaZI/EsOBRbrdyJDdgAwxB3EYr1 + zUCUn2xQ79x1TzUC8LD4niW+bIMsfyR+mND9OAFOJ6P7JXRpgouKIAXII6gij4CsUtv9N1sKctXP7rh/ + Pg9cxOHh3BkdLMKpZM+NZPFFj1IfzeBHt8PVuvyjPKZa2LedLX9Xqd/w0kIWxUyfAVCiXUUHiUG061F7 + ODqICBW2XJXU7LF8H95kfPrqWjacxHoDGFs7B9TfXbe2WjoZcPlY7+v3K/IGFpP3LC3e+KxniI+C2yWg + c6SK7MAiUQ324+OgY80gBBP0t20RO2cFWDvoHiyaEauImPW44fvn98yndEvASl9z43YeQ83ws1224Trq + h9zAoOAQzzEASniqq+CQbhBW2gxCTRWgAzfId5U6aRVYSg7kfALcovrtW9bSuYxgv1zTJvoR9DFj+LWM + aYdAe6PE7HRxdz1UQT2uQsP9N83EBFAF1AHqyPv65QOarQIzA5lFWSdcuKg+RG5vu36Dqnvu72Rc7c7Q + iG+/Yq9FO2/RhOiP3rLfO8RHmb8glPW8VLEdWCiqGRr3CnR7IO6A55hAQ5D6wrWHVe2pGsv35nkC6W0X + VctAhfrqDWubZV1hAvFp7Djej42rta43fGBxDkv6Orm8U0KXJrqwQDWvAHcB8yXJDnvxIQngz0odnw7e + vhOl7p/fpbJJPXjTToB+z+9tVe+/sE39mFxVqS3uApJtxCb2AXb5SO/jXmUke/KYGzM6pAOu/tfJ5N0S + +chGsRHjICaw7cBF5lC2dj+urXP9bZun7R0YAczwoUubVA8ZjTu6e6fFECA47kfuGypQH7283uNEtwHW + fmvTtnHiw+ijiYNMH7P3KkesXOsb4ttKzPbDYkPsgD3QoN+Pe6RtChOUVO9R70wjTmAWP78brr55Y7n6 + q8sb1a1ze9lCbztdrqr7a/nGTaDmVC3fhDo0nKdun9tDxN6gvnUzza0sHav48e0w7UZVB+LzOr+Fe5Un + bPPyVcGu4ricOrFBdpDO4ssPyIAZvyR5nAkQLJpOxHCm45uX4lRG/pEpxOdLtWnimDH6YjPLXKd5eatg + e5HLZWM7E5BnIDABwsbaMrJnLOiZAORN3Ol9TCUivCsRHxY/Qr2ujL78FoV0fp0c/inBkYs4P1BqoB3M + BMMaEyBGMEkdAFhFdHcpeSbh328uUrmVmRP67g7xkYfBt34FQoH1ibUAqaF26JIAHURHcS3a5OPa0nOK + eSXRncyiQAc2097tW6vSsvUzCRmVmrUPgw+BHhb7romPiRQcsSgwiG8rIVFLzTEB6TV0FN4BOq6tG2gR + Qxv2lhxSX3EjxzBQ8bnzSWpbUc6EPtr9/MMNiq19GHzQ+WaIbza509clZHGMCXXgcEgT4gRIKkUegR42 + tgGBo8raXTPaSHz9cqwqrNo7oV8MhHepzwjywIZiV8+EtY/gWsDN/MkFDXSZSQQXkXzb5OoB7hRy28eN + w4mMgPv0q+t2ubUDyV/40sUEVUxuLgJfjn2xiXzE9vkgakT4qk9r8X0XxIftNB+HOs2EAu8AOl7qyDjG + eM0aIU6INejA+JwGTSVMkgY27C87oF4ZXGV5V7Iv8O6LC9SfDaxWu0uyxbZrs14X+djKTbYQh3ddRPiA + 2Kxy/1v7VgviBC6DRei4zS6ASsDZ/lhEohmiGYgyI6wkY7Gz5Wn1edKtVk8q8SQQwfv0aIpqbdw2ybhz + BGb9+PHzWNKFrcS5/KzvnRM/ast+//n5nigIG7vctcoqgaRBzaAmDQrIQLTbBsaMAKw6XKwaG3aoD5Bk + eOvmH4mE8hyC+CJHzPRaUksrskvENmmgNsO9I9XGuh6GXjnN+pohUyIfNkFE+uMzl/COBQtILlcRHaQB + FpKgH/mmDxKZZhjBhoz8o6qmbifnIHxiJFV971qUes/CAdc2QM28cTVa/fXZNF6hq6zdrdbmFYh1ToSN + 8Lh5pIH7gL7D3jE762EcL4iKnR3EtxUsJbvMJwAwM0hicMyArGM2EskA0hhBNxQNbAQjwJB8JLdQ7SrO + VvmVmWxUItvmWNMzDPxdRR4H7g/YQc+syS1iL0T6liHQJoh6zHiSXkx4YmIW9wjsQNe72L6F36OfPuj5 + bJ5AKmGpq1nfiwPgCJtaqNUZgSUCqQYSp1iDwEYUs1LBawDRMdupLWgTcvDRRkfCs/pzIe4BqD6ne/dn + U0GOIW9DdzkwNGPACDaJANVQSjYCiUgYVCwVyLiyMwNLBm8yBAjuQHSqm2c7SSis22PRC+oLCbLjhHcx + 65suqOjNmTPPyvdEWbA0gYkoDsxkYDBJjEKP8iHPFf0805gZoCJIMnBkkTyICQxhZwpAIqoE/Xnb+3aC + k3inOnimM9E7qA093Ba4dBzMYVHvesYD8HQWRC+de4SfXHBqpcvgkR26sQipAIMRzEAqhb0HuJFkbTND + 4PAKmp0aU5CUIN0Mw4wJiVjDJOB//BuewbOY3SA2vkGuKb6Jb8ONQ11QS2zRUxt4tjebmO06YB+EJaU/ + ILxjga+LDanmGYEAo4qZgSQDjn8nNaExBNkM5X1sfWPVDOKZGYP0MxaimEGgQhzABMZveAaEpnfwLr6B + b2kEH+Q6UJd2yjhZ9K4MOweA8DiOD7uv9W4/KFMKDQ7OJ4ij2ScNojGIEBC9NoZoJCJBXYApaoc1xqg+ + zXYEiAmpAdHNwN/4H36jZ5jQeIeJ7XB9LBPc/ExnEINAujyY8W4UHFcDY5F3wUqD6xQgko0pNMZgkNHF + DMIgNcIg4jL0Zxj0jp3YFgiuAzH+6K1ZvkvUnM0Fqc4RKx5VsZmlLH6lAQ8EwB5YuqeIJRhC4XrzHxRP + FrhL2LYesyOP3S6JEL4EbATcvBaWstr7OfkPytSCo+5x38GSHblswLFFLhDKE4D0QV4jCB6xKiNwEzPm + coHoxUVYuA0NV+KBWPDtef299AQbeKxGHH11+pu9CNLbmNHIT8DeetgfizK2scRBxtOMXpUTy7x5/w8A + gNAf+DkozQAAAABJRU5ErkJggg== + + + \ No newline at end of file diff --git a/SourceCode/MetroSettingsForm.cpp b/SourceCode/MetroSettingsForm.cpp index 5f76380..7fbbc90 100644 --- a/SourceCode/MetroSettingsForm.cpp +++ b/SourceCode/MetroSettingsForm.cpp @@ -1,2 +1,212 @@ #include "stdafx.h" -#include "MetroSettingsForm.h" \ No newline at end of file +#include "MetroSettingsForm.h" +using namespace StandBye; + +void MetroSettingsForm::forceRefreshUI() { + timerUIRefresh_Tick(gcnew System::Object, gcnew System::EventArgs); +} +System::Void MetroSettingsForm::MetroSettingsForm_Load(System::Object^ sender, System::EventArgs^ e) { + //Focus on first tabPage + metroTabControl1->SelectedTab = metroTabPage1; + + //Load Settings + metroTrackBarCPU->Value = settings_provider->getThreshold(SettingName::MAX_CPU); + metroTrackBarRAM->Value = settings_provider->getThreshold(SettingName::MAX_RAM); + setTextBoxValue(metroTextBoxNET, (double)settings_provider->getThreshold(SettingName::MAX_NET) / 1000); + setTextBoxValue(metroTextBoxHDD, (double)settings_provider->getThreshold(SettingName::MAX_HDD) / 1000); + setTextBoxValue(metroTextBoxWAITTIME, settings_provider->getThreshold(SettingName::WAIT_TIME) / 60); + metroToggleCPU->Checked = settings_provider->isActive(SettingName::USE_CPU); + metroToggleHDD->Checked = settings_provider->isActive(SettingName::USE_HDD); + metroToggleNET->Checked = settings_provider->isActive(SettingName::USE_NET); + metroToggleRAM->Checked = settings_provider->isActive(SettingName::USE_RAM); + + //Load AutoStart Setting + metroToggleAutoStart->Checked = SystemAccess::IsInAutoStart(); + + //Update UI + metroLabelCPUPer->Text = String::Format("{0} %", metroTrackBarCPU->Value); + metroLabelRAMPer->Text = String::Format("{0} %", metroTrackBarRAM->Value); + + //ListView processes + listViewProc->Font = BasicFunc::getMetroFont(9); + + //Load Processes + refreshIcons(); + for each(std::string str in settings_provider->getProcessList()) { + listViewProc->Items->Add(gcnew ProcessItem(str, listViewProc)); + } + listViewProc->Update(); + + //Start Timer + timerRefresh->Start(); + forceRefreshUI(); +} +bool MetroSettingsForm::isNumber(std::string line) { + char* p; + strtol(line.c_str(), &p, 10); + return *p == 0; +} + +double MetroSettingsForm::getTextBoxValueAsDouble(MetroFramework::Controls::MetroTextBox^ box) { + box->Text = box->Text->Replace(",", "."); + double value = -1; + value = atof(BasicFunc::StringToString(box->Text).c_str()); + return value; +} + +void MetroSettingsForm::setTextBoxValue(MetroFramework::Controls::MetroTextBox^ box, double value) { + box->Text = String::Format("{0:00.0}", value); +} + +System::Void MetroSettingsForm::metroTextBoxWAITTIME_TextChanged(System::Object^ sender, System::EventArgs^ e) { + if (isNumber(BasicFunc::StringToString(metroTextBoxWAITTIME->Text)) == false) { + metroTextBoxWAITTIME->Text = ""; + } + forceRefreshUI(); +} +void MetroSettingsForm::changeLabelBackgroundColor(MetroFramework::Controls::MetroLabel^ label, double SettingsValue, double readValue) { + if (SettingsValue > readValue) { + label->BackColor = lightGreen; + } + else { + label->BackColor = lightRed; + } +} + +System::Void MetroSettingsForm::timerUIRefresh_Tick(System::Object^ sender, System::EventArgs^ e) { + float curCPU, curRAM, curHDD, curNET; + //gets current system Usage + curCPU = system_watcher->GetSystemMetric(SystemAccess::SystemMetric::CPU); + curRAM = system_watcher->GetSystemMetric(SystemAccess::SystemMetric::RAM); + curHDD = system_watcher->GetSystemMetric(SystemAccess::SystemMetric::HDD); + curNET = system_watcher->GetSystemMetric(SystemAccess::SystemMetric::NETWORK); + + //changes Background Color of the currentUsage Labels + changeLabelBackgroundColor(metroLabelCurCPU, metroTrackBarCPU->Value, curCPU); + changeLabelBackgroundColor(metroLabelCurRAM, metroTrackBarRAM->Value, curRAM); + changeLabelBackgroundColor(metroLabelCurHDD, getTextBoxValueAsDouble(metroTextBoxHDD), curHDD / 1000); + changeLabelBackgroundColor(metroLabelCurNET, getTextBoxValueAsDouble(metroTextBoxNET), curNET / 1000); + + //Formats Text on the currentUsage Labels + metroLabelCurCPU->Text = String::Format("{0:00.00} %", curCPU); + metroLabelCurHDD->Text = String::Format("{0:00.00} MBit/s", curHDD / 1000); + metroLabelCurRAM->Text = String::Format("{0:00.00} % ", curRAM); + metroLabelCurNET->Text = String::Format("{0:00.00} MBit/s", curNET / 1000); + + //Sets tool-tip to real-time usage and not the buffered one + metroToolTip1->SetToolTip(metroLabelCurCPU, String::Format("Now: {0:00.00} %", system_access->GetMetric(SystemAccess::SystemMetric::CPU))); + metroToolTip1->SetToolTip(metroLabelCurRAM, String::Format("Now: {0:00.00} % ", system_access->GetMetric(SystemAccess::SystemMetric::RAM))); + metroToolTip1->SetToolTip(metroLabelCurHDD, String::Format("Now: {0:00.00} MBit/s", system_access->GetMetric(SystemAccess::SystemMetric::HDD) / 1000)); + metroToolTip1->SetToolTip(metroLabelCurNET, String::Format("Now: {0:00.00} MBit/s", system_access->GetMetric(SystemAccess::SystemMetric::NETWORK) / 1000)); +} +System::Void MetroSettingsForm::metroButtonOK_Click(System::Object^ sender, System::EventArgs^ e) { + settings_provider->setSetting(SettingName::MAX_CPU, Decimal::ToInt32(metroTrackBarCPU->Value)); + settings_provider->setSetting(SettingName::MAX_RAM, Decimal::ToInt32(metroTrackBarRAM->Value)); + settings_provider->setSetting(SettingName::MAX_HDD, (int)(getTextBoxValueAsDouble(metroTextBoxHDD) * 1000)); + settings_provider->setSetting(SettingName::MAX_NET, (int)(getTextBoxValueAsDouble(metroTextBoxNET) * 1000)); + settings_provider->setSetting(SettingName::WAIT_TIME, getTextBoxValueAsDouble(metroTextBoxWAITTIME) * 60); + settings_provider->setActiveState(SettingName::USE_CPU, metroToggleCPU->Checked); + settings_provider->setActiveState(SettingName::USE_HDD, metroToggleHDD->Checked); + settings_provider->setActiveState(SettingName::USE_RAM, metroToggleRAM->Checked); + settings_provider->setActiveState(SettingName::USE_NET, metroToggleNET->Checked); + + for each(ListViewItem^ l in listViewProc->Items) { + ProcessItem^ p = (ProcessItem^)l; + p->Write(settings_provider); + } + + if (settings_provider->saveSettingsToFile() == false) { + MessageBoxA(NULL, "Writing Settings not successful!", "Writing not successful!", MB_OK); + } + this->DialogResult = Windows::Forms::DialogResult::OK; + this->Hide(); +} +System::Void MetroSettingsForm::metroButtonCancel_Click(System::Object^ sender, System::EventArgs^ e) { + this->DialogResult = Windows::Forms::DialogResult::Cancel; + this->Hide(); +} +System::Void MetroSettingsForm::metroButtonAddFromFile_Click(System::Object^ sender, System::EventArgs^ e) { + OpenFileDialog^ ofd = gcnew OpenFileDialog(); + ofd->InitialDirectory = "C:\\"; + ofd->Filter = "exe files(*.exe)|*.exe"; + ofd->FilterIndex = 1; + ofd->RestoreDirectory = true; + if (ofd->ShowDialog() == System::Windows::Forms::DialogResult::OK) { + if (ofd->CheckFileExists != false) { + settings_provider->addProcessToProcessList(BasicFunc::StringToString(ofd->FileName)); + listViewProc->Items->Add(gcnew ProcessItem(BasicFunc::StringToString(ofd->FileName), listViewProc)); + } + } +} +System::Void MetroSettingsForm::metroButtonAddFromList_Click(System::Object^ sender, System::EventArgs^ e) { + using namespace StandBye; + ProcessSelectionForm^ ProcForm = gcnew ProcessSelectionForm; + if (ProcForm->ShowDialog() == Windows::Forms::DialogResult::OK) { + if (ProcForm->selectedProcessPath != "") { + listViewProc->Items->Add(gcnew ProcessItem(BasicFunc::StringToString(ProcForm->selectedProcessPath), listViewProc)); + } + } + delete ProcForm; +} +System::Void MetroSettingsForm::metroButtonRemove_Click(System::Object^ sender, System::EventArgs^ e) { + ProcessItem^ proc = (ProcessItem^)listViewProc->SelectedItems[0]; + settings_provider->removeProcessFromProcessList(BasicFunc::StringToString(proc->GetPath())); + delete proc; + refreshIcons(); +} +System::Void MetroSettingsForm::listViewProc_SelectedIndexChanged(System::Object^ sender, System::EventArgs^ e) { + metroButtonRemove->Enabled = (listViewProc->SelectedItems->Count > 0); +} +System::Void MetroSettingsForm::metroToggleView_CheckedChanged(System::Object^ sender, System::EventArgs^ e) { + if (metroToggleView->Checked) { + listViewProc->View = Windows::Forms::View::Details; + } + else { + listViewProc->View = Windows::Forms::View::Tile; + } +} + +void MetroSettingsForm::refreshIcons() { + ImageList^ imglistSmall = gcnew ImageList, ^imglistLarge = gcnew ImageList; + + imglistSmall->ImageSize = Drawing::Size(24, 24); + imglistLarge->ImageSize = Drawing::Size(50, 50); + + listViewProc->SmallImageList = imglistSmall; + listViewProc->LargeImageList = imglistLarge; + + for each(ProcessItem^ p in listViewProc->Items) { + p->addIconToLists(listViewProc); + } +} +System::Void MetroSettingsForm::metroTrackBarRAM_Scroll(System::Object^ sender, System::Windows::Forms::ScrollEventArgs^ e) { + metroLabelRAMPer->Text = String::Format("{0} %", metroTrackBarRAM->Value); +} +System::Void MetroSettingsForm::metroTrackBarCPU_Scroll(System::Object^ sender, System::Windows::Forms::ScrollEventArgs^ e) { + metroLabelCPUPer->Text = String::Format("{0} %", metroTrackBarCPU->Value); +} +System::Void MetroSettingsForm::metroToggleAutoStart_CheckedChanged(System::Object^ sender, System::EventArgs^ e) { + SystemAccess::SetAutoStart(metroToggleAutoStart->Checked); +} +System::Void MetroSettingsForm::metroTileHomepage_Click(System::Object^ sender, System::EventArgs^ e) { + ShellExecute(0, 0, "http://www.stand-bye.de", 0, 0, SW_SHOW); +} +System::Void MetroSettingsForm::metroTileGithub_Click(System::Object^ sender, System::EventArgs^ e) { + ShellExecute(0, 0, "https://github.com/flobaader/Stand-Bye", 0, 0, SW_SHOW); +} +System::Void MetroSettingsForm::metroLinkHomepage_Click(System::Object^ sender, System::EventArgs^ e) { + ShellExecute(0, 0, "http://www.stand-bye.de", 0, 0, SW_SHOW); +} +System::Void MetroSettingsForm::ReformatTextBoxValueOnReturn(System::Object ^sender, System::Windows::Forms::KeyEventArgs ^e) { + using MetroFramework::Controls::MetroTextBox; + if (e->KeyCode == Windows::Forms::Keys::Return) { + MetroTextBox^ txt = (MetroTextBox^)sender; + if (getTextBoxValueAsDouble(txt) == -1) { + txt->Text = ""; + } + else { + txt->Text = String::Format("{0:00.0}", getTextBoxValueAsDouble(txt)); + } + forceRefreshUI(); + } +} \ No newline at end of file diff --git a/SourceCode/MetroSettingsForm.h b/SourceCode/MetroSettingsForm.h index c573bae..6bfc9f4 100644 --- a/SourceCode/MetroSettingsForm.h +++ b/SourceCode/MetroSettingsForm.h @@ -12,15 +12,15 @@ using namespace System::Windows::Forms; using namespace System::Data; using namespace System::Drawing; -namespace SmartLogout { +namespace StandBye { /// /// Provides a Form to set up the Settings for the Application /// public ref class MetroSettingsForm : public MetroFramework::Forms::MetroForm { private: - SystemAccess^ SysAcs; - SettingsProvider* STP; + SystemAccess^ system_access; + SettingsProvider* settings_provider; SystemMetricWatcher^ system_watcher; Drawing::Color lightGreen, darkGreen, lightRed, darkRed; @@ -94,8 +94,8 @@ namespace SmartLogout { public: MetroSettingsForm(SystemMetricWatcher^ smw, SettingsProvider* pro) { - STP = pro; - SysAcs = gcnew SystemAccess(STP); + settings_provider = pro; + system_access = gcnew SystemAccess(settings_provider); InitializeComponent(); this->MinimizeBox = false; this->MaximizeBox = false; @@ -109,7 +109,7 @@ namespace SmartLogout { protected: ~MetroSettingsForm() { - delete SysAcs; + delete system_access; if (components) { delete components; @@ -556,7 +556,7 @@ namespace SmartLogout { this->metroTextBoxHDD->Text = L" "; this->metroTextBoxHDD->TextAlign = System::Windows::Forms::HorizontalAlignment::Right; this->metroTextBoxHDD->UseSelectable = true; - this->metroTextBoxHDD->KeyUp += gcnew System::Windows::Forms::KeyEventHandler(this, &MetroSettingsForm::OnTextBoxTextChanged); + this->metroTextBoxHDD->KeyUp += gcnew System::Windows::Forms::KeyEventHandler(this, &MetroSettingsForm::ReformatTextBoxValueOnReturn); // // metroTextBoxNET // @@ -574,7 +574,7 @@ namespace SmartLogout { this->metroTextBoxNET->Text = L" "; this->metroTextBoxNET->TextAlign = System::Windows::Forms::HorizontalAlignment::Right; this->metroTextBoxNET->UseSelectable = true; - this->metroTextBoxNET->KeyUp += gcnew System::Windows::Forms::KeyEventHandler(this, &MetroSettingsForm::OnTextBoxTextChanged); + this->metroTextBoxNET->KeyUp += gcnew System::Windows::Forms::KeyEventHandler(this, &MetroSettingsForm::ReformatTextBoxValueOnReturn); // // metroToggleCPU // @@ -862,8 +862,8 @@ namespace SmartLogout { this->metroLabel17->Name = L"metroLabel17"; this->metroLabel17->Size = System::Drawing::Size(204, 134); this->metroLabel17->TabIndex = 1; - this->metroLabel17->Text = L"If at least one of the set up processes is running, the programm will prevent the" - L" system from changing over to standby mode."; + this->metroLabel17->Text = L"If at least one of the set up processes is running, the program will prevent the " + L"system from changing over to standby mode."; this->metroLabel17->TextAlign = System::Drawing::ContentAlignment::MiddleCenter; this->metroLabel17->UseCustomBackColor = true; this->metroLabel17->WrapToLine = true; @@ -873,7 +873,7 @@ namespace SmartLogout { this->metroTabPage4->Controls->Add(this->tableLayoutPanel11); this->metroTabPage4->HorizontalScrollbarBarColor = true; this->metroTabPage4->HorizontalScrollbarHighlightOnWheel = false; - this->metroTabPage4->HorizontalScrollbarSize = 10; + this->metroTabPage4->HorizontalScrollbarSize = 0; this->metroTabPage4->Location = System::Drawing::Point(4, 38); this->metroTabPage4->Name = L"metroTabPage4"; this->metroTabPage4->Size = System::Drawing::Size(718, 274); @@ -881,7 +881,7 @@ namespace SmartLogout { this->metroTabPage4->Text = L"Advanced Settings"; this->metroTabPage4->VerticalScrollbarBarColor = true; this->metroTabPage4->VerticalScrollbarHighlightOnWheel = false; - this->metroTabPage4->VerticalScrollbarSize = 10; + this->metroTabPage4->VerticalScrollbarSize = 0; // // tableLayoutPanel11 // @@ -1120,7 +1120,7 @@ namespace SmartLogout { // timerRefresh // this->timerRefresh->Interval = 1000; - this->timerRefresh->Tick += gcnew System::EventHandler(this, &MetroSettingsForm::timer1_Tick); + this->timerRefresh->Tick += gcnew System::EventHandler(this, &MetroSettingsForm::timerUIRefresh_Tick); // // metroStyleManager1 // @@ -1146,7 +1146,6 @@ namespace SmartLogout { this->BorderStyle = MetroFramework::Forms::MetroFormBorderStyle::FixedSingle; this->ClientSize = System::Drawing::Size(746, 456); this->Controls->Add(this->tableLayoutPanel1); - this->Icon = (cli::safe_cast(resources->GetObject(L"$this.Icon"))); this->Name = L"MetroSettingsForm"; this->Padding = System::Windows::Forms::Padding(0, 60, 0, 0); this->Resizable = false; @@ -1179,236 +1178,41 @@ namespace SmartLogout { this->PerformLayout(); } #pragma endregion - private: void forceRefresh() { - timer1_Tick(gcnew System::Object, gcnew System::EventArgs); - } - private: System::Void MetroSettingsForm_Load(System::Object^ sender, System::EventArgs^ e) { - //Focus on first tabPage - metroTabControl1->SelectedTab = metroTabPage1; - - //Load Settings - metroTrackBarCPU->Value = STP->getThreshold(SettingName::MAX_CPU); - metroTrackBarRAM->Value = STP->getThreshold(SettingName::MAX_RAM); - setTextBoxValue(metroTextBoxNET, (double)STP->getThreshold(SettingName::MAX_NET) / 1000); - setTextBoxValue(metroTextBoxHDD, (double)STP->getThreshold(SettingName::MAX_HDD) / 1000); - setTextBoxValue(metroTextBoxWAITTIME, STP->getThreshold(SettingName::WAIT_TIME) / 60); - metroToggleCPU->Checked = STP->isActive(SettingName::USE_CPU); - metroToggleHDD->Checked = STP->isActive(SettingName::USE_HDD); - metroToggleNET->Checked = STP->isActive(SettingName::USE_NET); - metroToggleRAM->Checked = STP->isActive(SettingName::USE_RAM); - - //Load AutoStart Setting - metroToggleAutoStart->Checked = SystemAccess::IsInAutoStart(); - - //Update UI - metroLabelCPUPer->Text = String::Format("{0} %", metroTrackBarCPU->Value); - metroLabelRAMPer->Text = String::Format("{0} %", metroTrackBarRAM->Value); - - //ListView processes - listViewProc->Font = BasicFunc::getMetroFont(9); - - //Load Processes - refreshIcons(); - for each(std::string str in STP->getProcessList()) { - listViewProc->Items->Add(gcnew ProcessItem(str, listViewProc)); - } - listViewProc->Update(); + private: + //Main + System::Void MetroSettingsForm_Load(System::Object^ sender, System::EventArgs^ e); + System::Void metroTrackBarRAM_Scroll(System::Object^ sender, System::Windows::Forms::ScrollEventArgs^ e); + System::Void metroTrackBarCPU_Scroll(System::Object^ sender, System::Windows::Forms::ScrollEventArgs^ e); + System::Void metroTextBoxWAITTIME_TextChanged(System::Object^ sender, System::EventArgs^ e); + System::Void metroButtonOK_Click(System::Object^ sender, System::EventArgs^ e); + System::Void metroButtonCancel_Click(System::Object^ sender, System::EventArgs^ e); - //Start Timer - timerRefresh->Start(); - forceRefresh(); - } - private: bool isNumber(std::string line) { - char* p; - strtol(line.c_str(), &p, 10); - return *p == 0; - } + //Processes + System::Void metroButtonAddFromFile_Click(System::Object^ sender, System::EventArgs^ e); + System::Void metroButtonAddFromList_Click(System::Object^ sender, System::EventArgs^ e); + System::Void metroButtonRemove_Click(System::Object^ sender, System::EventArgs^ e); + System::Void listViewProc_SelectedIndexChanged(System::Object^ sender, System::EventArgs^ e); + System::Void metroToggleView_CheckedChanged(System::Object^ sender, System::EventArgs^ e); + void refreshIcons(); - private: double getTextBoxValue(MetroFramework::Controls::MetroTextBox^ box) { - box->Text = box->Text->Replace(",", "."); - double value = -1; - value = atof(BasicFunc::StringToString(box->Text).c_str()); - return value; - } + //Settings + System::Void metroToggleAutoStart_CheckedChanged(System::Object^ sender, System::EventArgs^ e); - private: void setTextBoxValue(MetroFramework::Controls::MetroTextBox^ box, double value) { - box->Text = String::Format("{0:00.0}", value); - } + //Timer + System::Void timerUIRefresh_Tick(System::Object^ sender, System::EventArgs^ e); + void forceRefreshUI(); - private: System::Void metroTextBoxWAITTIME_TextChanged(System::Object^ sender, System::EventArgs^ e) { - if (isNumber(BasicFunc::StringToString(metroTextBoxWAITTIME->Text)) == false) { - metroTextBoxWAITTIME->Text = ""; - } - forceRefresh(); - } - private: void changeColor(MetroFramework::Controls::MetroLabel^ label, double SettingsValue, double readValue) { - if (SettingsValue > readValue) { - label->BackColor = lightGreen; - } - else { - label->BackColor = lightRed; - } - } + //Others + System::Void metroTileHomepage_Click(System::Object^ sender, System::EventArgs^ e); + System::Void metroTileGithub_Click(System::Object^ sender, System::EventArgs^ e); + System::Void metroLinkHomepage_Click(System::Object^ sender, System::EventArgs^ e); - private: System::Void timer1_Tick(System::Object^ sender, System::EventArgs^ e) { - float curCPU, curRAM, curHDD, curNET; - curCPU = system_watcher->GetSystemMetric(SystemAccess::SystemMetric::CPU); - curRAM = system_watcher->GetSystemMetric(SystemAccess::SystemMetric::RAM); - curHDD = system_watcher->GetSystemMetric(SystemAccess::SystemMetric::HDD); - curNET = system_watcher->GetSystemMetric(SystemAccess::SystemMetric::NETWORK); + bool isNumber(std::string text); + double getTextBoxValueAsDouble(MetroFramework::Controls::MetroTextBox^ box); + void setTextBoxValue(MetroFramework::Controls::MetroTextBox^ box, double value); - changeColor(metroLabelCurCPU, metroTrackBarCPU->Value, curCPU); - changeColor(metroLabelCurRAM, metroTrackBarRAM->Value, curRAM); - changeColor(metroLabelCurHDD, getTextBoxValue(metroTextBoxHDD), curHDD / 1000); - changeColor(metroLabelCurNET, getTextBoxValue(metroTextBoxNET), curNET / 1000); + void changeLabelBackgroundColor(MetroFramework::Controls::MetroLabel^ label, double SettingsValue, double readValue); - metroLabelCurCPU->Text = String::Format("{0:00.00} %", curCPU); - metroLabelCurHDD->Text = String::Format("{0:00.00} MBit/s", curHDD / 1000); - metroLabelCurRAM->Text = String::Format("{0:00.00} % ", curRAM); - metroLabelCurNET->Text = String::Format("{0:00.00} MBit/s", curNET / 1000); - - metroToolTip1->SetToolTip(metroLabelCurCPU, String::Format("Now: {0:00.00} %", SysAcs->GetMetric(SystemAccess::SystemMetric::CPU))); - metroToolTip1->SetToolTip(metroLabelCurRAM, String::Format("Now: {0:00.00} % ", SysAcs->GetMetric(SystemAccess::SystemMetric::RAM))); - metroToolTip1->SetToolTip(metroLabelCurHDD, String::Format("Now: {0:00.00} MBit/s", SysAcs->GetMetric(SystemAccess::SystemMetric::HDD) / 1000)); - metroToolTip1->SetToolTip(metroLabelCurNET, String::Format("Now: {0:00.00} MBit/s", SysAcs->GetMetric(SystemAccess::SystemMetric::NETWORK) / 1000)); - } - private: System::Void metroButtonOK_Click(System::Object^ sender, System::EventArgs^ e) { - std::vector RESULT; - RESULT.push_back(STP->setSetting(SettingName::MAX_CPU, Decimal::ToInt32(metroTrackBarCPU->Value))); - RESULT.push_back(STP->setSetting(SettingName::MAX_RAM, Decimal::ToInt32(metroTrackBarRAM->Value))); - RESULT.push_back(STP->setSetting(SettingName::MAX_HDD, (int)(getTextBoxValue(metroTextBoxHDD) * 1000))); - RESULT.push_back(STP->setSetting(SettingName::MAX_NET, (int)(getTextBoxValue(metroTextBoxNET) * 1000))); - RESULT.push_back(STP->setSetting(SettingName::WAIT_TIME, getTextBoxValue(metroTextBoxWAITTIME) * 60)); - RESULT.push_back(STP->setActiveState(SettingName::USE_CPU, metroToggleCPU->Checked)); - RESULT.push_back(STP->setActiveState(SettingName::USE_HDD, metroToggleHDD->Checked)); - RESULT.push_back(STP->setActiveState(SettingName::USE_RAM, metroToggleRAM->Checked)); - RESULT.push_back(STP->setActiveState(SettingName::USE_NET, metroToggleNET->Checked)); - - for each(ListViewItem^ l in listViewProc->Items) { - ProcessItem^ p = (ProcessItem^)l; - RESULT.push_back(p->Write(STP)); - } - - bool success = true; - for each (bool b in RESULT) { - if (b == false) { - success = false; - break; - } - } - if (success) { - } - else { - MessageBoxA(NULL, "Writing Settings not successful!", "Writing not successful!", MB_OK); - } - this->DialogResult = Windows::Forms::DialogResult::OK; - this->Hide(); - } - private: System::Void metroButtonCancel_Click(System::Object^ sender, System::EventArgs^ e) { - this->DialogResult = Windows::Forms::DialogResult::Cancel; - this->Hide(); - } - private: System::Void metroButtonAddFromFile_Click(System::Object^ sender, System::EventArgs^ e) { - OpenFileDialog^ ofd = gcnew OpenFileDialog(); - ofd->InitialDirectory = "C:\\"; - ofd->Filter = "exe files(*.exe)|*.exe"; - ofd->FilterIndex = 1; - ofd->RestoreDirectory = true; - if (ofd->ShowDialog() == System::Windows::Forms::DialogResult::OK) { - if (ofd->CheckFileExists != false) { - bool res = STP->addProcessToProcessList(BasicFunc::StringToString(ofd->FileName)); - if (res) { - listViewProc->Items->Add(gcnew ProcessItem(BasicFunc::StringToString(ofd->FileName), listViewProc)); - } - else { - MessageBoxA(NULL, "Writing Setting not successful!", "Writing not successful!", MB_OK); - } - } - } - } - private: System::Void metroButtonAddFromList_Click(System::Object^ sender, System::EventArgs^ e) { - using namespace SmartLogout; - ProcessSelectionForm^ ProcForm = gcnew ProcessSelectionForm; - if (ProcForm->ShowDialog() == Windows::Forms::DialogResult::OK) { - if (ProcForm->selectedProcessPath != "") { - listViewProc->Items->Add(gcnew ProcessItem(BasicFunc::StringToString(ProcForm->selectedProcessPath), listViewProc)); - } - } - delete ProcForm; - } - private: System::Void metroButtonRemove_Click(System::Object^ sender, System::EventArgs^ e) { - ProcessItem^ proc = (ProcessItem^)listViewProc->SelectedItems[0]; - bool res = STP->removeProcessFromProcessList(BasicFunc::StringToString(proc->GetPath())); - if (!res) { - MessageBoxA(NULL, "Writing Settings not successful!", "Writing not successful!", MB_OK); - } - delete proc; - refreshIcons(); - } - private: System::Void listViewProc_SelectedIndexChanged(System::Object^ sender, System::EventArgs^ e) { - metroButtonRemove->Enabled = (listViewProc->SelectedItems->Count > 0); - } - private: System::Void metroToggleView_CheckedChanged(System::Object^ sender, System::EventArgs^ e) { - if (metroToggleView->Checked) { - ResizeListViewColumns(listViewProc); - listViewProc->View = Windows::Forms::View::Details; - } - else { - listViewProc->View = Windows::Forms::View::Tile; - } - } - - private: void ResizeListViewColumns(ListView^ lv) - { - for each(ColumnHeader^ column in lv->Columns) - { - column->AutoResize(Windows::Forms::ColumnHeaderAutoResizeStyle::ColumnContent); - } - } - - private: void refreshIcons() { - ImageList^ imglistSmall = gcnew ImageList, ^imglistLarge = gcnew ImageList; - - imglistSmall->ImageSize = Drawing::Size(24, 24); - imglistLarge->ImageSize = Drawing::Size(50, 50); - - listViewProc->SmallImageList = imglistSmall; - listViewProc->LargeImageList = imglistLarge; - - for each(ProcessItem^ p in listViewProc->Items) { - p->addIconToLists(listViewProc); - } - } - private: System::Void metroTrackBarRAM_Scroll(System::Object^ sender, System::Windows::Forms::ScrollEventArgs^ e) { - metroLabelRAMPer->Text = String::Format("{0} %", metroTrackBarRAM->Value); - } - private: System::Void metroTrackBarCPU_Scroll(System::Object^ sender, System::Windows::Forms::ScrollEventArgs^ e) { - metroLabelCPUPer->Text = String::Format("{0} %", metroTrackBarCPU->Value); - } - private: System::Void metroToggleAutoStart_CheckedChanged(System::Object^ sender, System::EventArgs^ e) { - SystemAccess::SetAutoStart(metroToggleAutoStart->Checked); - } - private: System::Void metroTileHomepage_Click(System::Object^ sender, System::EventArgs^ e) { - ShellExecute(0, 0, "http://www.stand-bye.de", 0, 0, SW_SHOW); - } - private: System::Void metroTileGithub_Click(System::Object^ sender, System::EventArgs^ e) { - ShellExecute(0, 0, "https://github.com/flobaader/Stand-Bye", 0, 0, SW_SHOW); - } - private: System::Void metroLinkHomepage_Click(System::Object^ sender, System::EventArgs^ e) { - ShellExecute(0, 0, "http://www.stand-bye.de", 0, 0, SW_SHOW); - } - private: System::Void OnTextBoxTextChanged(System::Object ^sender, System::Windows::Forms::KeyEventArgs ^e) { - using MetroFramework::Controls::MetroTextBox; - if (e->KeyCode == Windows::Forms::Keys::Return) { - MetroTextBox^ txt = (MetroTextBox^)sender; - if (getTextBoxValue(txt) == -1) { - txt->Text = ""; - } - else { - txt->Text = String::Format("{0:00.0}", getTextBoxValue(txt)); - } - forceRefresh(); - } - } + System::Void ReformatTextBoxValueOnReturn(System::Object ^sender, System::Windows::Forms::KeyEventArgs ^e); }; } diff --git a/SourceCode/MetroSettingsForm.resx b/SourceCode/MetroSettingsForm.resx new file mode 100644 index 0000000..0154656 --- /dev/null +++ b/SourceCode/MetroSettingsForm.resx @@ -0,0 +1,899 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + 304, 17 + + + +About this application: + +This application has been created for Jugend Forscht 2016. + +License: +The MIT License (MIT) + +Copyright (c) 2016 Florian Baader, https://github.com/flobaader + +Copyright (C) 2016 Matthias Weirich, https://github.com/vavido + +Copyright (C) 2016 Stephan Le, https://github.com/stephanLe + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Thanks to: + +Sven Walter and Dennis Magno for creating the MetroFramework +(https://github.com/cecon/winforms-modernui) + +The MIT License (MIT) + +Copyright (c) 2011 Sven Walter, http://github.com/viperneo + +Copyright (c) 2013 Dennis Magno, http://github.com/dennismagno + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +And all the persons, who have supported us during the development: our families, friends and girlfriends. + + + 17, 17 + + + 138, 17 + + + + + iVBORw0KGgoAAAANSUhEUgAAAvgAAAA8CAIAAACcplk/AAAABGdBTUEAALGOfPtRkwAAACBjSFJNAACH + DwAAjA8AAP1SAACBQAAAfXkAAOmLAAA85QAAGcxzPIV3AAAKOWlDQ1BQaG90b3Nob3AgSUNDIHByb2Zp + bGUAAEjHnZZ3VFTXFofPvXd6oc0wAlKG3rvAANJ7k15FYZgZYCgDDjM0sSGiAhFFRJoiSFDEgNFQJFZE + sRAUVLAHJAgoMRhFVCxvRtaLrqy89/Ly++Osb+2z97n77L3PWhcAkqcvl5cGSwGQyhPwgzyc6RGRUXTs + AIABHmCAKQBMVka6X7B7CBDJy82FniFyAl8EAfB6WLwCcNPQM4BOB/+fpFnpfIHomAARm7M5GSwRF4g4 + JUuQLrbPipgalyxmGCVmvihBEcuJOWGRDT77LLKjmNmpPLaIxTmns1PZYu4V8bZMIUfEiK+ICzO5nCwR + 3xKxRoowlSviN+LYVA4zAwAUSWwXcFiJIjYRMYkfEuQi4uUA4EgJX3HcVyzgZAvEl3JJS8/hcxMSBXQd + li7d1NqaQffkZKVwBALDACYrmcln013SUtOZvBwAFu/8WTLi2tJFRbY0tba0NDQzMv2qUP91829K3NtF + ehn4uWcQrf+L7a/80hoAYMyJarPziy2uCoDOLQDI3fti0zgAgKSobx3Xv7oPTTwviQJBuo2xcVZWlhGX + wzISF/QP/U+Hv6GvvmckPu6P8tBdOfFMYYqALq4bKy0lTcinZ6QzWRy64Z+H+B8H/nUeBkGceA6fwxNF + hImmjMtLELWbx+YKuGk8Opf3n5r4D8P+pMW5FonS+BFQY4yA1HUqQH7tBygKESDR+8Vd/6NvvvgwIH55 + 4SqTi3P/7zf9Z8Gl4iWDm/A5ziUohM4S8jMX98TPEqABAUgCKpAHykAd6ABDYAasgC1wBG7AG/iDEBAJ + VgMWSASpgA+yQB7YBApBMdgJ9oBqUAcaQTNoBcdBJzgFzoNL4Bq4AW6D+2AUTIBnYBa8BgsQBGEhMkSB + 5CEVSBPSh8wgBmQPuUG+UBAUCcVCCRAPEkJ50GaoGCqDqqF6qBn6HjoJnYeuQIPQXWgMmoZ+h97BCEyC + qbASrAUbwwzYCfaBQ+BVcAK8Bs6FC+AdcCXcAB+FO+Dz8DX4NjwKP4PnEIAQERqiihgiDMQF8UeikHiE + j6xHipAKpAFpRbqRPuQmMorMIG9RGBQFRUcZomxRnqhQFAu1BrUeVYKqRh1GdaB6UTdRY6hZ1Ec0Ga2I + 1kfboL3QEegEdBa6EF2BbkK3oy+ib6Mn0K8xGAwNo42xwnhiIjFJmLWYEsw+TBvmHGYQM46Zw2Kx8lh9 + rB3WH8vECrCF2CrsUexZ7BB2AvsGR8Sp4Mxw7rgoHA+Xj6vAHcGdwQ3hJnELeCm8Jt4G749n43PwpfhG + fDf+On4Cv0CQJmgT7AghhCTCJkIloZVwkfCA8JJIJKoRrYmBRC5xI7GSeIx4mThGfEuSIemRXEjRJCFp + B+kQ6RzpLuklmUzWIjuSo8gC8g5yM/kC+RH5jQRFwkjCS4ItsUGiRqJDYkjiuSReUlPSSXK1ZK5kheQJ + yeuSM1J4KS0pFymm1HqpGqmTUiNSc9IUaVNpf+lU6RLpI9JXpKdksDJaMm4ybJkCmYMyF2TGKQhFneJC + YVE2UxopFykTVAxVm+pFTaIWU7+jDlBnZWVkl8mGyWbL1sielh2lITQtmhcthVZKO04bpr1borTEaQln + yfYlrUuGlszLLZVzlOPIFcm1yd2WeydPl3eTT5bfJd8p/1ABpaCnEKiQpbBf4aLCzFLqUtulrKVFS48v + vacIK+opBimuVTyo2K84p6Ss5KGUrlSldEFpRpmm7KicpFyufEZ5WoWiYq/CVSlXOavylC5Ld6Kn0Cvp + vfRZVUVVT1Whar3qgOqCmrZaqFq+WpvaQ3WCOkM9Xr1cvUd9VkNFw08jT6NF454mXpOhmai5V7NPc15L + Wytca6tWp9aUtpy2l3audov2Ax2yjoPOGp0GnVu6GF2GbrLuPt0berCehV6iXo3edX1Y31Kfq79Pf9AA + bWBtwDNoMBgxJBk6GWYathiOGdGMfI3yjTqNnhtrGEcZ7zLuM/5oYmGSYtJoct9UxtTbNN+02/R3Mz0z + llmN2S1zsrm7+QbzLvMXy/SXcZbtX3bHgmLhZ7HVosfig6WVJd+y1XLaSsMq1qrWaoRBZQQwShiXrdHW + ztYbrE9Zv7WxtBHYHLf5zdbQNtn2iO3Ucu3lnOWNy8ft1OyYdvV2o/Z0+1j7A/ajDqoOTIcGh8eO6o5s + xybHSSddpySno07PnU2c+c7tzvMuNi7rXM65Iq4erkWuA24ybqFu1W6P3NXcE9xb3Gc9LDzWepzzRHv6 + eO7yHPFS8mJ5NXvNelt5r/Pu9SH5BPtU+zz21fPl+3b7wX7efrv9HqzQXMFb0ekP/L38d/s/DNAOWBPw + YyAmMCCwJvBJkGlQXlBfMCU4JvhI8OsQ55DSkPuhOqHC0J4wybDosOaw+XDX8LLw0QjjiHUR1yIVIrmR + XVHYqLCopqi5lW4r96yciLaILoweXqW9KnvVldUKq1NWn46RjGHGnIhFx4bHHol9z/RnNjDn4rziauNm + WS6svaxnbEd2OXuaY8cp40zG28WXxU8l2CXsTphOdEisSJzhunCruS+SPJPqkuaT/ZMPJX9KCU9pS8Wl + xqae5Mnwknm9acpp2WmD6frphemja2zW7Fkzy/fhN2VAGasyugRU0c9Uv1BHuEU4lmmfWZP5Jiss60S2 + dDYvuz9HL2d7zmSue+63a1FrWWt78lTzNuWNrXNaV78eWh+3vmeD+oaCDRMbPTYe3kTYlLzpp3yT/LL8 + V5vDN3cXKBVsLBjf4rGlpVCikF84stV2a9021DbutoHt5turtn8sYhddLTYprih+X8IqufqN6TeV33za + Eb9joNSydP9OzE7ezuFdDrsOl0mX5ZaN7/bb3VFOLy8qf7UnZs+VimUVdXsJe4V7Ryt9K7uqNKp2Vr2v + Tqy+XeNc01arWLu9dn4fe9/Qfsf9rXVKdcV17w5wD9yp96jvaNBqqDiIOZh58EljWGPft4xvm5sUmoqb + PhziHRo9HHS4t9mqufmI4pHSFrhF2DJ9NProje9cv+tqNWytb6O1FR8Dx4THnn4f+/3wcZ/jPScYJ1p/ + 0Pyhtp3SXtQBdeR0zHYmdo52RXYNnvQ+2dNt293+o9GPh06pnqo5LXu69AzhTMGZT2dzz86dSz83cz7h + /HhPTM/9CxEXbvUG9g5c9Ll4+ZL7pQt9Tn1nL9tdPnXF5srJq4yrndcsr3X0W/S3/2TxU/uA5UDHdavr + XTesb3QPLh88M+QwdP6m681Lt7xuXbu94vbgcOjwnZHokdE77DtTd1PuvriXeW/h/sYH6AdFD6UeVjxS + fNTws+7PbaOWo6fHXMf6Hwc/vj/OGn/2S8Yv7ycKnpCfVEyqTDZPmU2dmnafvvF05dOJZ+nPFmYKf5X+ + tfa5zvMffnP8rX82YnbiBf/Fp99LXsq/PPRq2aueuYC5R69TXy/MF72Rf3P4LeNt37vwd5MLWe+x7ys/ + 6H7o/ujz8cGn1E+f/gUDmPP8usTo0wAAAAlwSFlzAAALEwAACxMBAJqcGAAAni5JREFUeF7t/QdwHEfa + aAsWPLrLdTe8pdFIGitHeYkO3nvvvQdIkABBwnvvCZAEvfcG9AbeE4YAQS87kmZ038bdiLvx9u7dF/H2 + 7Wq/zOwuFBoARUmURjM/GCcqsrKyMrOrCdTBl5lV1KqwEmPv7cYe2UbuWw3dthi4Zho6bTJyzDB0yDAA + HNMNHTcZOmcaum019Nhm5LXD2Dvf2K/IOKDEOLDMOLjCOKTSJLTKJKzGJLzGJLLOJKreJKrBJLrRJLrZ + NKbJNLbZJLbFNG4nYBLfhkhoRyTuVrHHJLHDJKnDJLnDVEzKXjPEPrxFmKfOpZdZZpllno9pSofJHHsJ + xoj9BKOUfQbJHcbxu42i2xQRTUb+5Z94xCW7OLQ7vtHtYDzkxA65sENuhkNu5r0uVt2Aq2W3q0WXi2WX + ixXG8o6zFXBbtVXihLi1zDLLYG46WYq5oeK6imuOiKuYK5jLDohOFZfsERftLS9gzttZnMOctUWcsbU4 + bWtxysbipI3FCRuL4xstjm20OLrR/OgG8yMbzA9vMD/u/BpFh1TQIVV0SKUUQweVMwFltG+x1KtQ6pFH + u+VIXbMkzpkSx0ypfabEdpPEJl1/Q6r+hhT9jUCa1GaT1H6LxCFL6rxN6por9SiUehVJvUto3zKpfzkd + UEkHVtFB1UxwLRNSy4TWM6ENTBjQyIQ3MREtdCQmqpWO2klHtSGigXblNgbYRcfshi0Ts5uJVRGzm41d + QNyCnGWWWea/NqpfGrsIdOwuqZLddBxCGtdBx+2l4zr04/ZS0ceo4MOUd6OJ0xYnO6+tG945sM58cK3O + 4DpqcCM1aKffa8Pf2Si/s1F2e6OccAtzU4lMlZDf3IAREsss81+bGyKur1dybb0MuKriyjrE5XWyTsyl + tYiLa2UXMOc/lZ37VHYWc+YT2elPeODUx/zJj/kTmOMf8cc+4o9+xB/5kD/0IX/wA+7AB9z+D7h973OU + cVi5xK9I6l8sDSiVBpZJgyukIVXSsBo6op6ObKCjm+ioJiaqkYlspCNAUMBXqqWBlVK/Mtq7mPYsABmS + um6nnXKkjtskDlsldpkSm81S281SOxCjrRLHbVJnUKU8qWeR1Avsp4L2q6QDqunAGiaolgmuZ0KI+mDv + CW9hIoFWRNROJrqNiWljotsZ5DqIOdFB7EHEqbZxHWxcB9kuYO+CnGWWWea/EJwojX9dKH9pAKA40vgO + acJeacI+acJ+aeIBncSDVPwJKvo0FXKA8qp63Tkx0N65bMNfL65TjKyjRmyoETvNETum30beY2PQbavo + AmwIcoE7NgbzUWBUuxsNbm9ULLPMfzC3FrJByUL7UXkP4up6+ZV1iMuYznXyS2sRF9fKL6yVn/9UDrpD + jAfrDuLUx7KTH8tOfCw7/pHs2Eeyox/JwHUOY9058AF/ZIM5Eh3av4j2L6YDSujAUjqwjA4qp4NxmCe0 + ig6ppkNr6PA6OryeiWiURjXRMS10XBsTv4uN3w3Q8bsgzcSCjuxkolqRsgTXMoFVUv8K2ruE9iyUuuXT + rrm083ZsQtkS+yypAyRypM47JK4FUvdiqVcp7VPOIAEi9tPAhDQwoY1sWDML6hMBCOpD7AdHdwhz0tOB + wL+5EPHAXtUW2CfALrPMMstgVL8fEDRiH52wT5K4T5q4n048CGglHKHiT1ORp6nAffDL6mPH0GTbtW3r + V/euk4ytp8bsqDF7yZg932+n6LWV99rKCD02sm4buUCXLaiPDIMcqNtGAeC0YEjLLPOfyZ2N81hEg0Tq + I0iPYDxEeojuEON5Ed1Rc51jSHTCK7DlFM+znOBKPJ5VzYTWoChOWB2DRAdoYCIbmcgmBoV5mpnoFia6 + FSlOHOjObiZhD5u0l03ez6YcVJJ8gE3azyTuY+P2sFFtyFpCG9igWtq/kvapoL1KGI8iGkzIOVfqtEPi + iHHKlbrkSd0KpZ4lUq9yqV8V7V/DBNbh8E8TE9rEhDUx4c048LOTBaDa6HY2ehcbsxshCvbQiA56Tncw + CfuYBLIF9rPLLLPMMspfCAhpwkHMAWkiSRyEhG7SESrxBBV7lgo/QfntNHXNcrb33b5xzfGNpuO2knFn + vXEH+ZCt4ZC9YsBe3m8n77dVYSPvs0VgE5L3qGGj2s6hWGaZ/ySI2av8Xl2A5nmPSnoWGo9agEesO0uF + dgTXOb4RiU4lshwUzplnOUyomuUsoTgxO9nYNiVx7WycMtIDMIl7GbAcIPkgk3qYSTvCpB9nM06wm09y + m05Agks/yqUc5pMOsvF7kalEtNJhTXRQHeNfxfhWMl5ltEcx7VpAO+dJnQCQoTypS77SgbwraORAtVCe + DmmkkQA1M+EtUAmxHzaqnY3aBdWSwA8buwdHrUm8B/31hr1HqTuYA0oSEWziQQEOgLMCy1mv7ZzHFt5j + k8wT2Czz2MR7ZLKe2YxfMRvZioots8wy/4aw+KeeQIPfiEkiiUPS5COS1MP6qSc0085SqRepmHOUXwfl + kPunT31d33jr2HvcqA07uFZ+d4NiwlZx114xYq8YtpMP2ckH0VYBDNqBBikGQIPsFEAfSijTKuR9KN9g + mWX+Y+i1naNHRbeKLhsEGdK9jRGCPTc3Km5sQFzfoLi2QXF1veIK5vJ6Rec6xaV1iovrsO6slZ9bKz/7 + qfzMp/LTn8pPfSI/+Ykcuc7HsmMfy458JDtuY0EZR4Do4EErsBwkOgtiOc8J5CgtB/wGzwWO38PGd7AJ + ewlMIljOAQSIDoZNOYRIPcymHWHTjyIyjnGbTnKZJ7ktZ7itZ7ksDCS2nObAh8CEkg9y8Xu5qF1ceCsd + 2sAE1dJ+1bRPBeNZQrsVS10KpKBBiHwpGQiDfORA1XQAOFADDgI1M2GtTDgWoEgQIGQ/OPyDAj/YfvZi + 9jHx+xGC9MCvvLBGxitb4ZdtHlO6IrNl9fZ9q/MOrc47uDr3AObg6vxDq3fsX7m13TKx0igoh/PaygRX + csmHlllmmX8jWNXvKII0GbTmsDTlCJ12jE4/Lk07IU09IUk+qhe/Xzdmt05Uu2bYTi2/Gk23QhAdas0O + 2R/WX4jm7qZJbgXRXW5Mtx09sI4fWyub2CifsFeM2ytG7eUj9vJhhAwA+xmyVwCDyHvQVgCZkL3BMsv8 + J9EvQmk/KnowSunB3LFVGY+NAgDdQcazUXF9I9adDYorG7DrrFdcWo9dZ538/DrsOmvlZ9Yi1wGQ63wi + O/6J7OjHshO2SHSq1KfmKC2nDltOAxOBFIcmlgN+E438Bk0TjmtXjljF76YTOmhkNnuZpH2I5P1M8gEm + 5SAi9SCbCnJziE07xKYfRmSA34jYdAxznN10ArH5BJt5ErHlFAu6A9KTfZ7NuQBwOef57HP81rNwiMs4 + waUdZZMOgKlwUe1ceDMb3MD4V9O+lbR3Oe1RQrsW0aBBLgWwhbTUvUTqVYbGy/yqmYB6JqiJDmmmw1uY + 8J1sBAr/MNG7mOjdbDQa+WJjOxjfQoXPFuvUWqQyuQfAcqxTa6ySq6ySKhdinVK9YlPjqpy9rxQcWZHZ + ahS8nfXJ5VKOLLPMMr9/2OTDTMphJvUok3aMST/OZJyk00+C4khTDkvjD0ijO/Qi2nRCmnUC6jV9qjQ9 + yjRdizWdC7TsszU3bqI+zmH/4NEdI5tpNpiuMJoqMxjO5XrTmdsRzC0f+o4j07uBHVrL3V3PT2wwGLcz + GLOXjdrLRpQohjFD9uA9iGEHhZghB4NllvkPYNB+DjX1EXuP2HhAd4jxEN0hxvN83VnKdU5i0alWWU4l + HTxnOXR4PR3RQEc2guLQUc00UZxYjFJxkOWwiXvYxA46qYNO3suk7GNS9jOpB0BumDQEm66Sm/QjS8jN + cWQ2BOI3amw+zWaeZjJPASTNbjnDbj3LZJ1ls86x20CALrHbMTmXQIlAg7jNp7n043zKYS5+Hxq6Ao8J + aWKC6tE4l08l7VVKuxfTroVYgAqlAFgRmhBdSfvV0IF1UvdchfeWVdm7kbVkNFolVlglASqnSaqwTKqS + xLVKYlv5+MYVyXOHEIkVyI1y96/OO2Qcnk/75DPJRxDwyxRIPSrALbPMMv8yjnGpx7n0E2zGSQDMhgW/ + STlCJxym4w/QMXuk4W36wS16/g26PjXaXpVanmWanqVaXuVaXpWaXlWaXhVargWUbRG1rsDwdd+DLtxs + A3u/3GimxHC21HC2DHG/TDFRLBvIYnsSJbdD9Lo8pN32TO96dnQtP7FeNmmnmHCQjzvIRx0UYw4K2GLk + IxjVLmBIGFFiMOJogLbLLPPvw7AINfXB8UtFPwYP2ip67RQ9GOV6RlvFHVvF7TnXkd/YKL++UX5tg/zq + BvmVDfLL6+Wd6+WX1suF0M7ZtbIza2WnP5Wd+lR28hMZuM4pJDqRNdKgCmlwpRQts6qmw2rRGiu0trye + jmpEy8ujm+mYVia2lYnbycS3MfHtTMIuJnE3k7iHSepgkvYyiyqOMn5zZJ7iCJGbzWAwYqE5BTCbwWbA + aQTO/GS2nGWQA51jsy+w28B+OtkdwGV2xyUu55Is+wK3BTToJJ92lE3cj2btRO1CQ1rBDUwgGhFjvCtY + m/iVma2vFBwFX7FKLJ8nMSpMEmveTM17Oz337bRcy6RKQK0AdqPK1Tv2r849IPfNokEQsesgko8yKSpS + jzEpx9hUTNpxAW6ZZZZ5qfBpJ/j0k9ymU9ym07DlM06wacdY+KlMOCCN2UtH76bDdtLBzVL/Bn2/Wj2f + Gj3vaj3vGj3fWl0/oE7Hr1bLt0bTr1rLu0bLu5LyqKIc6rVsM33f/+Dsp9TDcuZhjeFssWK21GC2RD5b + onhQaviwVPGwzOBhueHDcsVsuexuATewhe6Kk94JkHa5SnptmMG1/Ng6+dRG+T17xZSjwYSDwbiDwV1H + xZgYB8O7jogxJ8AI4Ywh6WWW+d0zKsbRkDCiYhgz5IAYdDAcwPTbG/Zheu0Ne+wMuzFddjjAY2twy9bg + po3BDRuD68BGg2sbDa5uMLi8QRXaWa+4sE5xbp3i7FrFmbWKU5/KT34qP21nSRlH10hDKqShldKwKjq8 + ho6ooyPr6KgGpeXEguW0MHEqywHFWdxyQHGUljOnOEq/UUZumE0nlGw+iRGbjchURLA/j60LOYdAAnSe + 3XYRBYHAfnKvsLlXZduvyHM6QYPgUxiH5f2h+MSKzc2WCYsrDqAf1/pGWv7/sUvn/3NU81L1W5rRey2S + Fh/PAk+yTq15pei4ZWIV7b2DTUDzmpmkg2zSITbpMJsMHGGTjwJId1KOI1IFTiDSRKSfQH+Awi9rnFhm + mWWWAH5GTvIZp7jNZwB+81l+0xkefnbgpyzpMBMPf+HsZSN2sSGtTHATiuAG1En9MQEN0sBGaWCzJLAJ + 0Afp8W/Q9a8HdPzqtAH/Gsq3nvLooFwaHVz8djtyfe9Sj7dIHjebPCxRPCpVPCoxAL+BLaSR6EC6FNIG + j8oNHlcoCDNl/Ggu259Od0VI7vjo9zrSfRvY4XWyqfWKGVuDaQeDSScF6M5d2KoYV2Iw7mg47mg07mQ4 + 7rzMMv8G3HWaB/Z1xChBJD3DjgbAkIPBIGbAQTWwZW/Qa4+HtOwMVK6juGWruGmjuGGjuA5sVFzbqBzJ + wq4jv7geT9lBoR356bVycJ0z9haUcUwdHVpJKy2nFlmOMpbTSMcgy6HnxXKw4iRixQGUgZyDTOohDF5a + hVZXHUVkHGMyjiOQ3xC5WcxvFjoN8ZKFZJ0XcQFDEuL8n4SyBvi8lim1rxQexYIyfzRKhHVSJRV5KHl7 + 8A9HqR9OUAUF7lTEIbUyalgmlK3avndVzl7GMZWJ3M1Gd7AxHehXbex+Nm4/G3+ATTjEJmL1QfYD6oPt + J4VwTOk9ymDPCSbtJEtIV+MUB7/Zl1nmvyKnuU3IabjMswAPiYzT6OcFfpTghyt2PxPVwUa0MSHNTHAj + E9TIBCDYwGY2uBlN1MNIg4EmgiS4WRLUrB/QCOgGNurC1r9Bx7+e8u+gvI+87rG1wfeP0z7U1XeovhDm + abPR43L+can8Uan8cakMbcswaFcFznlSJn8KlCuelhs+rTB4UsHPFDOj2+jeZP2uEEm3h6TXXjq0nhtf + J5+2MbhvZzDjaDjprJhwUjLpbDCHkyFhwhnKLLPM7wX4D7koC+3nOcajpjvEdRbVHTXXUcV1VNOT1+H5 + OmvlZ+0tKePYevRgwPBqVTgHLKcBWQ4esVJZTjsd104n7KIT9tCJHXTiXjppLz1vxrHKcp6vOEv5zRIq + w2Vf5LJhe4HDRkLSIr95OdDhtSsyW1fv2A9SoqYpCwHROVH+HljOD3uoNVHx2tGtS81QFoBqoX6wKHpt + JONeznhWMt7VtF+dNLABfsOyYTuZyHY2ChxoDxsDArSPi9vPxR/gEg5yCYe4ROAwRxwITfQ5ioe6lPbD + qeI9DNqCAJ0C4yFw6acRcA9YZpn/HEBiiNOc47acx5xFu+knOfirIOEo+sGJ3sNE7mJCd4LHsIFNTGAD + E9TABjVzIS0sopUJ2amilQ5tIUhDWqTBrZKgFkRgs35gi15gE4iOXkCTXmADFdBO+Z6Q+NVsDrSdDNB4 + 4kcd/IC64CB5Vm/ypFoGfjMf8B7+CYakBXCmjPC0VP6sXPGsQv60UvaonJsopAe2SHrjpF0Bkj43etCO + G9nAT29QzNoaPHAwmHExmHIxuIe3U66G9xYD8pdZ5vfGpIgJFeMuiLuYMcyos5IRzLCTwZCTwSBmwNGg + 39Ggz9Gg18Ggx8Gg296gy97gjr3BbTvFLTvFDVvFdcw1G8VVG8XljYrOjYqLG+QXNsjPb5CfXS8/A8bj + SEQnrFoaViMNr5VG1EsjG6QonNNMR7dg0dlJx7bRcbvo+J9oOURxlJYjUpyFfjNPay4i+YDtbwWY3MrM + llXb94KOrEwu5+Mb2fimVcmLD10ZJtRx8Y3fNst/OE09rqS1vbabJNctJTpQm0FCPR3XDAmrhPIVm5pe + KTzGOiYz4fAbtpkOrGf8ahivCtqznPYoo91LGY9yxquS8amh/eto+AUd0kKHt8OvbDZqDxu9j0SA4Pc4 + HgIj9nOESz4K4MDPMTTnAP6KTQfQOBeDwzwAk36aFaESIHzDgL+DM86gwD7iLEbYXWaZ3wnn+cwL/NYL + 3Fa05TPP8mA8aaf4ZDCbg1wcWnAAfy2Ax3BBLSA0TBAK1SCnCW1lQXdEMKGt89lJh7YB0pCdBAlxncBm + vaBW3SDY1msFNlN+xym//V7BkbdCDT8PpUb8qKMbtI9/qPmsyOjzJvlTUJZy/mkZgsiNUnFKuMVQUx9s + PGVQgwyM5xkO88yW03fzJAObpD3Rkl4/SZ+LdMSWH9+guG9j8NDB4KGLwayL4TQC7MdwxtVoKabdllnm + X8M9N0M1FqrPosYj1h1wHUF3Xtx1rmDXubRRTlzn3HrkOuex6DQgywmrlYbXIcuJbKSjlBOQseiA5bRj + y9mNRQdbDlpAvrjlkBk58+finATFIUulEMhvMFl40owQWVmgIIhtl146HAHNy+lkN5+wTKxanbvfMr5s + VXKZfuzOFYkVryaX6MS0w66auABaMbvWb8r8YS8FotOe9SfKq3FFWq1aGQJ2piaThJq/JBdSMbtRbeA6 + ma2rcw8w4dVc3nV++1U++xK/5RyXfooHZYk7yMbsYyPa0S/owEa8QKyK9qyQeoAGYbwqaZ9qxreWDmyA + vz6Z8DYmYhcT1cFE7+VwEAiPgh1EApQIAoSGwOBvXPRnLokAkZAP2E/aKUSGwGmAQdsz7KaznJjNZ9H8 + hmWW+S3JPEe0ht96EW23XIBM+BnhUo7Df2w+bj8fvYeF//wgMcEtTFATmI1Ka3aC7rBhbQsBoWFC25lQ + SCDo0HbkNyHgN5jgNkkwKM5OSVCrflALoIto0g1soQL2U/7H3wjI2R/xxy+iqGfBVLev1gVn3UNvU9Pp + /Bdt8s/KuGdYcVSiwwkgpwGKsd/AllDCPSrhF6IsXIIMCSp8VsE/q+SfVPL3StnRHEl/iqQ7TL/HRzLg + xNzdwE1tkN+3NXzgaDTrAkJjMO0KumN4H2F0381o1g1tBWZ+x6jdHQlqZX4l1BoF1Aos81JQu8hq0qNm + PEvpzo+6zk2V65CgDrhOJ3YdIahzYU50lgrngOXECZbTwSTtA8tB4Zz5loMf/Se2HHEgRzlQtTCEo+43 + 84yk8yeBrAW2YnIu/yiGQdteKTqGptEkl+nGtuvGtD9pMf1+F6+Ia6Si96q5jnVSBRVxeHue5w9HqB8O + U4GxzlTwTuuUGnEZAlgOG9cMha/X/PX/sV/yZmoeFXkQu07ZqpwO69RauG5c7jUu7waXf5MrvM0X3uGL + uriiOyidf5PfcY3fdhl+y8tAPlKOs4mH0ZBWZDsHv6/hD1b/Btq3RupdxXiWMx5ltEeZ1LOC9q6ifeto + /wYUB4Lf7BG7mag94EBM7D4m7gAbj0fBkuaCQMSB0ArbNDR5E8V+5tSHQNSHcFaA23SO26yEXwJdp0zN + 1R9KQ+rU8pdZRp3M80hlsi7yWZdkAArYnOcyTvOpJ9F/1/iDDNh/1C4GfCVkJxuM5SakVRmqmW8zC8Fy + o/QbLDe7MJBol4a2S0LbJCEYrDh6wa16QS2AbmCzdlADmo7jd5r1r88LtfkymvoykhoL0ezy17nqqbP/ + Hao3kPmyzfDzKv4LoFL2WQXAf1aOpIfwFFynDOAfw1aQHswj5DrqiEI+3JMSZZjnWbnss0oeWgEeV3KT + RcxwFtMbr98TpN/rQQ/Ys6MbZFMbDWbtjR44GarCPCTGg9Rnxs1wxt3ovoCH0ayH8X13Y9iKmflXMK3i + nvscQuaiqNXw8xBqE7er1rTaKb8HhL4t1W218r8HhL4hoKsqSM+nMJNuiAnMOOauK2LMBTHqYjTiYjTs + bDTkbDTobDTgZNTvZNTnZNTraNTjaNjtaNjlYHjHwfC2g+Ete8ObdoY37Ayv2RpctTW4YmvQaWNwycbg + wkaD8xsNzm5QXHC2AtFpxOEcIjoiy1EL55AJyMn75watnjNiJbYcojjEcgTFWdxvVOKSc3lRuO1XwE6U + abL7olxdCOu34w/FJ5GXJGEvido3VP/KD8eoH45Sz1pNFPGNerFtaNRJpS+WSVVQ5lr1X384Rf2/Wyjr + gGQ6rmnhuBX4kGFCPRW1/3jF+2jO8lHqf+/QX51UTkXvA9cBqXql6LihX6ZaZ0Rc43KvEwfSj2rU+iRY + 8/V1GqwZbHVs4uCqolAQXKIt51FgBpQFJCaqg4lox8NhDbRfHQPS41kh9SyTggaBA3lVIwcKaKCDWuAP + WXAgNroD7h8MGgs7yMYf4hJwECiJjIJhBwIBSlVNeV5oPxmC95xjNyvhNp9HwH1r83mtvzhQFIXW9MLu + j6HrnKljk6iGnmfeC57+y6Gj26FFiX+5Wv4yL58tWGu2gtZ0yrI6IYEm2Ww6w6Wd5JKP8QmH+Nh9bGQH + G96OhpmQ1mCI04QD7S9MGxPWzoSBISmhw9vp8DZpWBsoDgIFclAURz9kpz5SHIROSKt2cAsV1Er5n6B8 + 9weFhA1Gyb6Kph5EUEOh+v2BWre8tY5+qNVpq/dVg8mXDUhxvqySf1nBf17BAZ+Vs5+VcTjGgyDjWUh3 + UIAHFGeezTwqZpdCKANngTA9harKZJ+VI+95Vil7UsXfL+PG8qT9GZLuSGmXL93jIh2wZcY2yGZsjR44 + GD9wMZoF1yHS44YiPQ/cjAizYDnuJg88jB94wBYwBWbnYXL/12cGM+2+JKTAoqhV9eIINai1JUYoo3bu + b8Oi7ZL+iDt5T4WQ8y/ssxjSjaWYFhLzP8gUZtLNZAIz7mZy15VAXMd4xMV42Nl4yNl40Nl4wMm438lY + 5TpG3Y5GXQ5Gtx2MbtkjbtoZXUeuY3jF1vCyjeElG8OLGw1BdM5tMLjgbE0ZxzWRcSs6kiwpXyqcs3DQ + 6oUtZy6QMz+Ks8BvFggKZsfVHycX/OAnwGYcXbGpcWVmq1VihWliDRVx5GzFOz8cR1OMf9iFVlT9rz36 + 5ok1fHyjYDCQNkus+h87JT+cpS7kWlEuLbqJHXqxO9n4JvFjA80Sq7Wjd9+u+zP4EKptN/XDEeq7nXIJ + WGNs64qkcquU6lcKjzL++UhoRPC5NwCcuA5XSetNF9AF+Kdh8VfN1z7VYE1RmjXVj2rgim5zJV1cSS9X + 2seV9fElfVxJD59zhc+7CZ7Eb70ENw825TiTeJiNO8BG7uJC27jAZiagUepXK/VCGoRNqJL2Jg7USMMf + yvC3b8QeOhoJEAkCsQmHWSRAx+AmBLWhsYO0E+ielHaKS0MTfZD3zAV7zinZfE5z9Ycapn/CAnSehT/Q + My9wmXBLAy4A6FYnQnP1R+Rjqv3ToI31vPLUCv8a6NgmQXOSgHK1/GV+MRfhvyKfdZnPvsJnX5Zld8pA + cTLPoclhqSfYxKMM/B+L3sdF7Ib/n2xoKxPSwoTsZCEdvgst//6Z7AaY8F1MOGznoMN3SYEwsJxdBElI + O2anTmi7TkibXnCLVnArFXiECjj5bnDO8YjX/x5L/T2amojQHwvXGwrU6fbVOWujdfJ9jS8K5X/fKf+6 + SvZVtfxLBPdlJfdFBQt8BrojUCZ7ViZ7SmQF86SE/elgTyqBSkCbZE+AUvmTctkTsKgK2cMKbrKUGdxG + 9yVLu0L1er2kfY7s8EZ+YqP8gZ3hYyfDh2A57gagOA+VGD7wUPLQw+ihhzHwyNPkkaepwEPMg1+NWcx9 + D8SMh+m0uxJIk0yCuJiwS1Cr8AUh55LaxO2qpEG9LbXTfyVIW89H3GfSW6HPat1Wq/y3YWFXCTPwnapA + u9hyxD6kpjvgOkR3wHVUuvNCrnNH5TogOjfsDMF1rmLX6cSucwGLzkWl6ISrJujME5154RwsOgsGrV7Q + cuYHcoQpMsohJDWtAdQkZgeoyTwn+OXIfbf+oeg4mYBMRRxN2R6Ioi8d2Ev2ItG5WP2WSWK9QUKdYDBU + 9F73Lck/HKB+OEbVZL5tHlryYWbuBxk5H2Rss8DxHlLMPLGajttZWuCKgkMHsTZBncepzso3QKfMoVhi + +aqcDrOoQjb7gnL0CsMX3AIgAfIHZgN3X62PAunUg0IBXa8dIDoAk3lKyCTouGRAef2oRraoiynpAQHi + wYHKMSW9sqJuPv82BxaVcxmNF6BQ0BE0pycK/fVMh7SQUBAa/wL7IfhUSX1rpQENTBDcftrAgdCE6Bhw + oINM/CHkQElHWBCg5GNIgFJPcKlYgMB+ko9ATzRXfaAUoM2E86rYDyQuKLeZF5m0k6jw6o/Is09YvJUE + VOjYJmvQJnBIGtaI7pe/Jlp/dYSG6JhdavnL/EQu8Vs7QWjQqOu2yzLYZndCPgf/B3DABq0ijNnHRu5h + w3YhmwlBIAUPa8dmgwTll8OE7xGgxYTtBpSKg8at2vVDgDa9kJ26IW06ITupkIOU/wWjoNrSyHXfxFLf + xFAzUdqT0XoT4fojQbo9ftqXXbQPvaMxk8J8s8vw62ru79X8VyiiI/uykv+ykv2ykvmigvm8glVGd0B6 + ylGM51kZAJbDPitlYfszIMbzGCjmHmEeFHOzCBYSD0tkD8vkjypl98uZu4X0QJakO16/K0jS6yEdtqcn + wXhsDB47GD51NXzsbvDIzfChuxHwCEMSjz2MH3uaiDB97GkGPPIye+D5EngoguTMepjd9zCbcTfDd27T + KbyFNOQAcPQ5CNX+VIQaoAnSqBjSAeiV0Iq42wsR1yzwnEOAcK5aMaFjYtQOia/VlBtG1W04JO72b4/Q + STXE0oNEZ854lEyTLb7y8FkmMRNupuNKlKGdMReTUReTEReTYWeTIWeTQWeTAScT7DrGvY7G3Y7GXQ7G + dxyMbzsYq4I6Rtdsja7YGl22MVIFdQwvOq9QiQ4ZtxKmIasvtpofzhEPWoksBz/v+BSad4z8RlAcFMUh + K6pEE4HnKQ5PhGYu4jLfS8AGfik3xTDJ+1dmtlqnN6xIqtCPbVuZVPl/dWgggwEj2YMnGm/5A2VbJo+r + W5WitBwkOhGHG4ptUdSng/r/7dFAPgSFj1BXqt/UED020Dq5yjK5mnJuiIhYhwqTakGhjlBBWTFU5GE0 + HJZY8UrRMdY3h8sHs1FHe2Mc3Hp1nDep5QPgOnBI66MgtXytt1whn93WyeffAtSOcuBPhbe5wi6uuIcr + 6+PK+rlyBMgQD1ZUdAdUiYdvYetFFv7aTjnBgcfE7qMj0eNimcBmxq+B9qnFAlQOSL0rUWQooEEa1EyH + 7mQidtNRe5kYMhB2WN8tD3X+0xghCET0Bc0nJau9yLyfzWeZzef0Q+qhsPYn4WzmeTbzApMJ9nOB3XIR + HEgvoAJ90r86clvhDnqJbH8NNF/5CKRKLXOZHwcNP+Fozbar/LYrSGuyLrGZZ9GjDdA41BH0/yFyLwvO + gSfK4BEo4jR7XjYdBBSSjOgAGLxVonIdKYhO2G5J2C49Qmi7bmi7TmgbFdxOBZyhAg5HhIdPxzDfxlNP + oqjJaP17UZKpCJ2xUO3+AN1bnjpH36H6fKTf7jH4pk72VS3/VQ33dTX7VRX3VRUYD/dlBQt8UT4HSM9n + 5QwCjWQR4/k5KHWnFLnOw2J2toi9X8jOFHDT+ey9fHa6gJsp5GeK+AfF8okC/nEF96iSnQHpyacHN0l6 + YvT7/PSHXaUj9uy9jYpHdgbPnIyeuYHcGD4C3GFr9NgTANcxfuRFMCGQ0M5Dr1/KI+95QM4DL9P7niY9 + joY732e7HAynPEzuYdDohqcJHBIHCQhwihhx/S8COQvq6XU0hFagrUl3k9v2hrAlkNZJ06R+tW6rIa78 + xVlYA+kY6duinxSATOgY6TZcK9Jh4aIJV4wUFtr6tRG6RyCdh54IQMdw30xn4ajoA0IOgRSAzyV8NPLp + JtxNxlXcdTcZczMGRgFX4xFX42FX4yEX40EX4wEX4z5no15nox4no24nozuORrcdjW46GN1wMLxub3jN + 3vCKneFlW8NLtoYXbQw6XVFEpxmFc+ZEZ8G4lTicoxId9AZyssYqQ/VKB/QaB7y6aqHlbJsfxVH6DZ6S + Mk9xnm8282TllyDzzX6l8JgVevxxBRVx5FzFOyj6AjqyC1lOX6kx9U6SxCV9ZVKZdUo10ReTxFq9mJ1f + tJj+cBLHaY5igwF9OU5tz/OkIg6SYojkqhUpVUZ+m6g3M4pT/vbDGdUA1mHqf9vJSWN3KhLqQXRWbd9r + EprD7biCLGQ+GqyZhsXf1DIF4BAUWCRz6VMWooweIfu5zRd38SXdfGkvD+pTOSCrHJRVDckrBhVl/fKS + Hh7K5N5At7HN5/iUU1zSUTbuABMNdw70BDY07OVbS3tXS70qpZ5VkNB+NwSJzocR6Dkl4bvRhOiYA2zc + ISbhCKOcCXSMTT7B4CCQnmsOFNZ1zECPSNkEDnRWGPBiMs9rmP5JgzZG6pOJ1Aex5RLALUTtHvzCcBmn + oAPgOmr5y6ijdJorspxrshxsNlmdaFAy4wybeoqB/xV4HAppR9huMguYDd3FhuNAS+SeX5kOZFSRe8Fv + xKhiOaA4e6ShwG5J6G59RLteSLtuSJtWSDsVdJoKOvNpWNbF6Fe+i6O+i6VmoqUz0ZKZKP17kfoTobqj + AVpdvlonP9Hq3Kj9XYPiu52Kb2r5r2vlCOQ6Mgz/FYL7smqOzypZFTzhWQX3M3hazj0p547H6u8J09sd + qtceotsWotsarNsSrNcShOhMpScL2dYQvTWWGjPF3P0S7kEpGI/scZXsYQ1IDz2aK+nP0B+IkA54M8PO + zIQdP2Mjf+xggMI8ngYPPQyQ9HgYPfI2fox56IV4gDB6ALsIk1/CI8xjH7SF3QdeJmc3yKx0NNawmhmv + 6U24GwOTHsb3PIynPREznsa179DX7OT3vYwJsyrgXDFCE0vlC0ehkh5HA/hhv+NgAM3dtEfp5veYcXdj + AHJI66QtOIX0WdxzAXG1izYn8KNHyYeCRuEjA6R18SmQhszT62XVb9ObXtdreY/pdzYiHRauGDmLnLhU + c+SQgNpRgUWPCmctROg/+Qjk6zu9Ttb2PiPMRL4PPcSfDn1AkBsslMRyVK6DPsiUB/pQAJqVjL8U4K6b + 8V13JDrYdYxGXY1GXI2GXY0GXYwGXIzgUoDr9DgZdjsZdjka3nY0vOVgeBOLznV7g6t2BpdtDTptDeaL + Dhm3UokOem1n/C78HOQO5TvJyaAVfggyS5ZZIdFBlsMttBy0bvw8euEUiuIsYTmLKM7LtJmlgI5ZxpWi + iE5ShU7MrjXp23/YT/2wT+ki/2uPlsHGQMp+q9hyALOkmhWp1R5JQc5Btq5Bth96Bh7JfZ3MwlkTFa8z + /7GB1th1OJ8s6t3k8XIDVAwqB905Sm3K9QO1QnN6kqtX5XTQwSVqCqIf2QA/gdo2cWr5Apqvr4UCLFxM + VQ6kIUfrbTckJapMSIvhtsOVR6jlPwckYblXZeBAJeBAfXzlIF85LK8cUVQMycv6ZaW98qI7svyb3Jaz + 6HVC6O/4I3C303rHBzqj75TDBDQxvnVS5EBVNGiQV7XUp0biX08HNjMhbeh2GNWh/VE4FNZz3YHnAx1l + 0XygE1zySTIVWnPV++iTQrXKlV+qwS8c/lEBAiQk5msQjgORh+eq37ZVSMOboAntTyPV8v+rk0UGoa4i + p0Fc4bIuoVXfGWf5VPiij7Pxh5mY/UzkHuSySq1pR2NSIDrqFvIbMM9vBMVBfqNCH4VwQHF26Ye26Ybu + 1iVjVUGXLEIa6qLXfhdPgeU8iNGeipXcB8tB4Rz9qTCdkUDtPh+tc/baR9dQn+XKv9tjAJbzd4Ts6xoe + UQ3g0A5GsJwv5ixHKTpq+vLiENEJWqP1npXGu5YaYDOWLOIdC423MeVeOnfzmOZAXciZLGRAeoBpbDwP + y/jHlbLPqvnPa7gntcx0KTOcLe1PkPYF6fd7SAcd2fEN8lkbgydOBk/cDJ6A8bgDePqOp9EDtCbLaNbT + aEaFcEMlNzYxJF/tKNmF2yG5XxJFgN0xNyOwnPy/SuCudtfdCCB3Nbhzw92O3LzBgTa/rkdunARyp1Te + L0WtPAehS3AK1NDlgOQGFAc6cM1eAemGd5kRNyMA+gCdgdZJQ3AK6fOikBv8Um0RljpK/ECoAdpCTuCJ + PjX54OTTCeWBuNU60NV3WE2CpY7GsbW8cMWEs8iJL464CbVDLwi0CE0D5CPA1YP+ACBk8PUJnwgBCYyQ + gxJ4F8CKA9cf/hugLwKALwgAxQHRmYvoiERnyEXpOjioYwiuA6JzB7sOiA4O6hhcsze4YodE55KtwWUk + OgnN+BWeDeJwzjzRQW972CdYjmoxuej1nC/FchaN2agNwfwc8CwW1e0fYELKVu/YDzqyAodzOko/ReEZ + EBHgNLUl9m3qo+3WSaXWaXOzc5C7pFQBlHMW9V4k9UEc9eaWKwXWP1ymHlcyOt7bTZLq1ZZfWafWrkyt + ohxy/+bm+sMhCrkUiM5h6vMmY92YXcaJNWj0quCozCeThFUE9KMa4b+1jstmtXwBzdfXQQG4jHzhHW2b + eNglORoWfyNpacIetF5dBeyCA0EB8g+K6QVXiAsIwLm6PnmQgNahGCkP55K2MMSB8GL4HVd13LZocOak + mOafN+pH1skrhzT/vAF2ZTuuywpu8zuuslvhj370EBQ2AS0VRrfG0DYmsIn1b2C8azQt34PC+k55tE8N + Wi/m30gHtzJhbQzcumIOaBi8qqFvyCUcYROPcUnHNVe8r/1hsHItmDAQloEe+aPruFlz9YdorZbSeC4y + mRd1XLZqmP4Z947SoE203vVloCdbO7msOfS8C+GormsWurX/lyW7U4aiNdf4nOuAMmCz9SIPWpl+Cg1B + JhzmYvZzaD0UmM0uJgw7DZlYgz3jX0MUsAebzV4xdDiITocUREeFJGy3XvguHdiGteuFtlGh+6mgTiro + YFJk0JN4yT/iqc/itGdi6dkYyUyMPlgObKfCdcaDtfv9Na65ah94k5qI5/5xwOjbev6bOiV/B5DxcF/X + sF/VcGqi82Ul+wXoThX3eSX7eSVswXWU25+KUncquMdl3MNS0Bd2s632JhvtiQL2bt4czYF6IDoT+Sxh + qoC9V8ROF7H3i9lHpdzjcu4pVFXFP62WPa7m71cxdwvo/kz97mhJvz8z6MbetedmbOSPHAyfuRg+cTN8 + 4G54390APQrF3QhuSDMeRoRpFSr7Ud5iF6ByI0+jWS+jB15GD72MH+FYEaR7HJFk3LZXwI1tzM1w1M0Q + tpAmd7tJd6MpD6PLNvIuB8U9D5SGLSA0LbQu6ob6ITUgH+qBFqHdG/byEVfDq3ZySNevoYddDQHIgQ6Q + pqEwdBtFs0Q9J50n/YdPpFb/iwM1E8gufEboxh0HBTQNn520TopBK8AWLA2n1vFKD3AzLH9LAq5z014h + XCvxxSHVLuQ5h3425NuBzpNvk/QQtrfsFZ02cugbQvX1kcJCGu1C50kZ5UdDCP8fMFh38JaAXQd9WfCV + DboYDrgY9jsb9mHR6XYC0TG47Whwy8HghoOBSnQUl20Vl2wVl12tsOgI663Qm62I5ZDXWoHldDDJonBO + Gn5qjvCqTjQpZ77oiCyHzSZP58OKA38UkrEqZDnXRPOLbywSyFGXlduLsdihAnXIHZojFCHk/tteyT8M + niFLaDBOrP0fbVI0CIXDLf+tQVd7YwwbVroifZ7lIMBjEivMQreZBm7W9s1/NSz1/9qt8cNZanfWnyjv + xR8bCKpknlhOfZJ9YZsFKBQSqQ404OWUmaoR3QEFVmbvMg3LhSum7B5GEoVjDLYJIBNLAZJBEsrF55ZI + SojlAOCaQkkQFzikwZpBSR3XTNhCGnL0QiqFMgTSLpQHsxHKk5pRrGh+YegANIRqtvwbdBVKkl2oVoMz + 0/zjer60V1bWx5cPcFVDfNUwXz3CVY/yVaOyiiE0Q6i4m8+7yWdf0TD5k4bUiE0+juZzRHegZ58EtzAB + TbRvrZ5dFlQIJkR710r96qUBzZpmb0IOelJc9H42Fs0HYhOOIgdKPq5h9LqGxIhNOISXg51hk49q/tke + nb76Q52NaL06WdsFWzQBSAkK/2jbJkO+fmAVEqCtlxFZaItGauZxBaOW+W8KmVVzlc+5JtsOWgNyA853 + CY1DpaPRST7xKI++jr1s5G5kM2G7OCAcOw1yi72/F6CH0R1M1F4mEgRaCR2+l47YK0Wi0yGJ6NCP2KMf + DpYDirNHN2yPduguKvgcFXzWPiLzRvzKfyZR/4yn7sfSD2KlwP1o/fvRejNAlN5kiPawn+ZtL61D71Hd + bnr/3GPyzxbZd/Xst3U8hgO+qeW/qeXAdb6qBddhvwTAdYQBLEhUg+uwXyDpQU/cAeNB7lLFflYF2xfl + GQhKJdKUJxXcwzLufim72U57ky0WnXx2TEUTjuiM53HA3Vx2PJ+ZyGemCpl7RQzSnRJuFg1poe0sCFMZ + GdviHtQw9yrou7n0ULq0P1Iy4EcPunCjdvLpjYYP7AwfOKHHu026GU64Gk26Gk+5GREmYYvvUuRpKIDy + yS74r3M02QKvoyELasgSm1k0jwQB6W4HQ/ihu2VvMOZqPOyCGHFBMzDIM1TG0VNVlIuNMc/fVc5ZUdsl + kD6gFT2ogHK46pqtwZCzcacNSte9www4GwPQB+gAbtoYCk/jPpNV09DnByogTdYNkWpJzWptiTOFLpF8 + ckEANCsFF7hlr7wU5BEy0DoUI1cMGHVBoa+291lclfL6AG8zmhVv0fhSoKshbksNckg4KuwShN4K5QUW + FhMKC0Dr0O0bduhKwha+TbiG5HtEw08YKKMsLIDrJ0urhAVWY64mZAoOmoXjgmbhCP8r4BApgOI6uH60 + CAuXGXQ2Vj5ZxwkvNXfEy68cjG6goSvDa3j5FZqmY2N4BUd0WpThHLCcOdERhXNAdFJUc5DTyNQcIjo4 + nINEByxHvMBqMcsRROf5ljMnN4LE4ITYXTDKXRzkIMEGnJ4zhsXJvwFusTJrF3gGFbUvICsOTbghi61O + UyXJf6Xsylam1yx8Og7BOqVmRWotFXskZkf0D4dRhCY0zokKbhMPcolZmV5HeVXbBDiiwtAK1qmWko1U + 5GGrpAowoRUZDUx4tZpDoDk6rJnYV54PeAb8V5MmdqjlE3dRUx86/Siq3/JvQg6BKBEURiEclUgBJBoE + ZylzioFurXfcIVPHLRPSArq++RqWb0A+HAWVWUAvV9LLlvSqZkMPsiXdqMW/2PA1Y1z1GFc5ypcNyIp7 + +fwuLueq1rtoCEzPswBP/oC/1Ns1zFHlaG28dw2NhsOqpd41Ur867ffR+Jf2u0HoMYnoXRkHtP6Gpmbr + 2KSyScfRWFjKSTb1lPaHoZCp67hJORC2+SybeU4TP/KHST/BbsGToFUCpKKT3XoJwKNgYANYg9S94fcI + 6aQMg+bW5FzjwWm234AtXFsuuxOt8884i65M0gmOTK+J7GDDd3Ohu/DcGjII9XvSGgKSGxWR0GeEUnEi + 5hRHaTnhYDl79MJ264bv1gntoEKOU0EX/hBWszPmk38mU/9MpB7GSR/E0Q/jlKIzGy0B15mJ0p0M1xkN + 0O7y1jqxjjr/sfY/6gz/2a74toH7toH/pl72DYrrcKrQDvc1UMt+TXQHGQ9RHPYLsBy0JQkZQB7993n1 + T+azKh4FYyrBTvgHZdwWe21wnckibqKQGy9Q0hyEIjo3Mpm0jdpvWWj4vKV1LE4fTGi8gBkvZKaK2APR + en5va0EZ2LaG6N0r5mdK+Pul3KMK/lkN/6xe9rCOnSqTjGyT5NtorzfT/BurEWKpdfpddmyDwbid8YST + yYSLcfMaxtZQ6x1G09dce9+H3ATcmxEmwKWNBpD5DqsJBVre5SfczQiT7ub3PMxnPJW0vc9vel0CP3Tp + r+mnvqp/xwHuWKalb7JnNxjC7luM5p4PZXfdzMrfYpve5SEx6mY25mZ2w944aqXe26ymjaFW2VssZAIj + rmaN7/LAhY2GPuY6cBTKQEk4izDublb5FmtnqAWH0l7TP/Ipij1csTXqdza9aGME6Zp3uD5n08K/MbVr + uGFXVCcAZ7W8x1e/zUK3p3HP72PGXE0zX5eMuprCIfiYUG3FW6zQFjDgbJL7FxraArb/hb5ubww9hwoh + fXytQrggJ9YqoBgk4HS4CNAN6BvQ7WgClUC+0O6hT1DYqcsB/AD1Smhox19oOBdyCLfsjaNXKS8OXDfS + KHBuoyHswgWBVuAoXKJjaxWkBigD270fych18zbXgctIzgIgDRcfzoVDsIUmoANwTeCbJfXAUagBrj98 + cfCtQSdhS75NuIwNa3jhOyLfHekAAPlj7pBpCoy4mTa+yzWu4c5uMPAy14avPnyF7iUbo34X0wHMoIsZ + lAGEqshHg3aHXeEoKgOFe51Ne5xNu51M7zia3HY0ueVgctPB5Lq9yTV74yt2xp22xpdsjS+7rpovOrHi + casOLDpkpdUBZDlopRWZmoMthyyzAsvJxLGcxUVnvuUQ0VnKcuYGmEBlyFgJ2AnWF/Tg4JcAk7IfJMY6 + vQFNQ4481FRsgx5zDP6xD60qf9/fRzOkYam3OmCqrJPBkA4fKPv4h1PU/9lKvRKUKIlrfo4YKRLqdFzT + v67WVzZ0mBqvX6kd226WiNxo9fZ9rG+OWBcAEAj4rwPSIIluVju0KJp/xINZudfU8omO0BnH1PM/QfOF + 2axzQo4MGrVLgEyoCqSEL+4R0PUtgHzYohVbGP3oFsjR+iRUyBFQCdAWtfxFIfXMFcar4sGB+PIBHW80 + SVnbOY2rGeOrR2VVI7LyIR23rZCpH1aH5ANu0qknucQjbOx+TYu3IV/qVU77NdI+NTofRMGu1p+cpb51 + Uv8maTB6TCIb3kEHojFBzdc2svHH2MRjxIE0V76vufIDNu0MfhAiEiD86Gflww/RQ4DmIkAAeE8nmwVc + VkIiQFlXuGwl+Jkx85Btu6qW8+uCQzVoEGrHdW7HDS7nuiz7qgw6v+k8ixb/H2Pjj7AxB5A0hHewYbsR + 4WjhEhe5wCp+h2DFQTPc5wdy5kQnYq8EAZYD7NULA/ZQoQepoE6t4H2bon2/SpJ+n0J9niB5Es88SZA8 + iqcfxYPl6D+IlYDrzETrT0fojAVr9/ppXXLQPvqW1mfbZd8fMviukf22SY5oBHhkPA0yRD3/93ruaxVf + 1bGIesSXYDxzyETIfypfVCM+q5I/rZQ/rpBttdfZYqczXSybKpqjNUQfJMbudc10G+3GQD3vt7QsWI3e + bdxYPsA2BelZshq5LjqQgAKQbgnWmyrm7xXLZkpljyq5J9Xcsxrus1pZjovOeys0qoJ1agN13P6kaapH + HXfRu+nCdNnwxa9LLLU1qv9Kt6xht/8FDaA0r2HH0Z/vJsfXymE34zW9pvfY8rdoSJe/zYx7mAITHqZT + nmb3vMymMTs/ANFBt8aM1/VTX9O/42Q05GbyFqu50VAL7tOQc9bGYNTdFG6KcO+HBNznrtkbWehoRK7S + rX+XK3mLhjQUG3YzBSDhbaENp5e+xQCQgF10FqbsLQYKQz0N73FQEuqHdi/bGfa5mFy0RaGUmjUspLf+ + WbLBUAu6obytupuCx1S+w0x6op7PeJnd90b0OhvDKf6WOn6WOs3vc1At7B5dKydtAeAB0DrpCbQFkApz + /iKF9Ji7KQGKpb+uDwnoHqkE+gZ0OxvfhcvlaUquFbTb/iH/LqcJu9ATcjEF4KoCkLjpYARXO2qVLnxG + aJdcHGgULg5cLrgg5Ko2vMtB3+AotIJ662YK5WEX+gbFoACkoYxwVeEscuka3+Ogq/Btou/0LQZ2IRMO + 7f5IBiWL36RTXtWDj5Dymh5w2xF9m3A6tEuqumpvBF+lt7k2VE6+oMiVuqP4EG5IDw6B4hS/QRe9Qb/J + aHqaa/e7mCBcTQZdUZkRNxMoL1w9+HZgF31AcB1XkwFcuNfZpMfZpNvZ5I6T8W1H45uOxjccjK87GEPr + V+yNOu2MrritJKLTSEcpx61osBwkOruR6JDZOYuIDp6dg0QHD1oJogOWs/U8Fh0hnIMtRxAdNCMHtqp1 + Vfk30RsPCjCFykVA8wIwC0zlF8JE1KzcigIw5knVGtG7u2r+iGIt4B9HqK+q9CVeWw2TGpaylhVJ6NGC + +rE7NWLaP28y/uEcdbPAlHJr0E/cbZFUBUfVyhNWpNdSHtUHs19By7Wgof3U/2zXeyW5lItvgqOr8w9x + XpsF4RDQxtoB/0AdflR3QIlAUNQyAciEetQywV3ALaBmadJesdBo/nE9ZIIVCSJCUNcRlc0sLAmQmvVC + qtTyF4UoFNQGZ4HbEaDDJCwEWkOK8TgUBA6k454F+XC1wX642rt83bisdlya1AGZ2mvDUOH829y2K1p/ + cdCQGtHo5V8H0R0xfBcT3ML6NTI+tZrGf9HgrGnvGkgzYEW+dXCu5upP4a7Jxh5AY2EgAciB0Low5ZOB + 0s5w6Wf5jHMcAK6AngBEZkNf5NAqMAyO+iCUDjRnQnMalLXASF4KgtZsvyEDIIGm13Ty0FXwtpQTaHQv + 9iBSBLAZpDW70BZFaxY4xO8WcRQnaj+w0G+UlhOOIjqS8A49IGwPoBW2lwo6TwWddY1KG0xcAYrzfYLW + w3jmUQLzJJ5+DIl4BoVz4vSB2Vj96Si9iVDtQT+t627ah9+iJiLo7w8bf9fCf9ss/65R9i0CWQ4O7RBw + REdQHBFLi87PAQWEqvGTkUF0HLS32mvPlICmKJkq4ltD0P2m0kd3vIAHuenZxoLogPGM5nHdWShd7qU7 + ms+N5LJA2kZt29c1xwu5ySLuXjE3W8o9LEehnQvpUqgEtg8q+fvl/HQ5Z/snzWwX7Ttb9c9F64L0lL2v + e8uB7drID603rPwzba/QGkfDCsa2Blrpr+qNuhnDbWnE1XjPhzzcC6/bG465oRXCEx4mk1h3gElPs1uO + yBjgDg13XLgvCqJDbs+whXy4O5IbNhyFP/cBSAy4ovtf7RrWXEfjjqMR7MJdFho6u9GA1HN4LQqBgBhB + PaRauLmSSgBIw9GForMPB0467QxJMagNdi/aGCCZwNpBXKfHCXU7drUeaAe544I6QCdJW8TAupyMIQ0d + g1Zgd9eHMtiFTEiTnsD9HtLQQ/QxscNBnWgXq5Ka6LR9wK/BogOZYssRgPI+FtrQDeFK1r3LQv1wcUAC + 6tawUDm0S3pIukFsBgqQLpHekisJXwGcBYCyiDvZ44xOBMVRGqSbKchKxEpd8nWQKwmfl+zC6YLoQOXZ + f5ZAtSjtigDzUPYB76a8ipzpzAYFkZX9+Iu4YGMI6V4X1CsoA82NupkQy7k7X3SGVKIDX+KiooOCOnOi + k9iqLjrxuxaIjnIa8jzRQeNWItHZepYTZuegCciXuO2d3I7LZPEO5hqXN6c4GDxERaI4v77lAGxQ4eod + +6ySqowS6+Tx9Z+BrxzE/nGCOp+3gvKtsUpdMDtHhVli7TtpuYrEho0Zm8lDBeu3vGkQXO6WnfFqSgk4 + kFp5gnVqDRXQtiV1LVrBDg3BiR3U+k2btWLb4ejq3ANyn014SEhNR7rRfBd8y4d/kECzahaUAeCqQgHQ + BVXOnLsQiC6IIabCgm6KMjU4c3AdcQ6BiI4Q0YGzYHfRkoC2XSIcXdSBFkKsaNF/Wp+GsvnXudIeMfqx + uCd+hVwpeI8SrTUekElvOcVVDnHVI/S287CrvTFaBhpUMyqrGubLB2TgSQW3wbY1V38IR9n4fWQ4TM8V + jdZpv+PP+NYxYD/eVbClvcGBGuiAFjqkjQnbzYAQxBxg4w4hByJTgpKOI4FAGiS8Bx49EloUBEKgd3Qg + ByIaREJBqjiQ2IGwBonERZRW5yogI1OGtyuRwZ8Q6Ok159Gk7NQTfOJR1FW0zLuDDcOP5vu305qFqCzn + x6I4e/XDO/TRQFWHbthe3bBdVPBxKvDyH8PK98e/+30q9X0S9TSefZLAPoYtUhwaeBgveRBLP4ihZ9E0 + ZN2JcJ1hf80ub62j71E3HbW/7zD4fpf82ybZt038t03st03ctw0s8Pd67u8NmHr2a4ya5XxVy4tF54va + l8DnNdyzau5JFYdEx0H7fhk7XcreK1HSGqpryWkM5jLjRexoAeJtC43UjdrDeezBWH0Qna5sZiiPGchF + HIpDgYTrmfTdAnaqmLlfyjwoZx6WM/UBOo5/0pwtY+6VspPF7EQxW+mr846VxngJtzcWjTddzJTc2qJ/ + NVb3ZoBk11pUycWPuWsfY1FYpyDzJ0acTWD7NqNZ9gaN/xw3Hle6jtkEwvyWA3oWKIgO3LTgFggIRgJp + 2MLdFHKIQ9x2NAKtaf+Qh5so3M8AOBFywFEgJ+lVPeJA6I97V5MreMoL3OxhF8QF0sSB4BDkkKNwSxZu + z0R0bkCF2hpFb9JQDCh+k4bWoW9wZwWZADkjsahuLDqnNyhAO8gtn9zRSf2e5trb/iKBVkg/YQs5YA+Q + A9Rjv4EOQHlQIjiFQLokiA40Bxb1gqIDltOLFWQ31inoAzRKLhe4IKTh08FRwb1gC62DxEB/Dnwqh2JQ + mPQWgBzoCVw0yEl+VQ88hnw16BtxNyVxHeH7gkreYjTJuRfwlbyET4RdaEh8Wd5kNEveZMBXyHWABNQM + QGLABYkOfH1QDJmNswkoDlRV/Q5LdqFCKIY6oArqgOiQbgiiA3WKRafLCa6AMZi0muhcnSc6aMnVTjpW + EJ09aCYymqMjEh0ybrWZLClH41bcljMcWWmVjS1nG36xA1hOTidazwyWg1ZXLSo6Cy1HJDoLHOWlwPrv + IEuuZPFNqxJL/nuraibycao5+20qsA28RHAUNZi41g8ztv9zt0J5ym7q/9WuA/pyrvpdNq7FOGGJAa/k + Kipid2CSt/K5O8B+yndLHBWD5iOv3r7PwC8TrpIgLmqA3xAvgX84PKPuMZIFEZcfBTRFzVSYLOwHdoni + TAKJu4DukN2FAR4xJCwkKBScS9oSQE2U4FGqEmVh0Bc1wHIgX2uNu5roSJL3oqbdtwg59OZjqOSnoUKO + rh/qrV5YFaR5/H4MtnyArRzkqoa5mlHNv9hqrHiHr5uQ1dyVVY/qRaCIjl5wBbf9BnrvUsZp9Jr3hMNs + zH6QA/TK68Bm2q8WTwmqZpRTgupp/yYmuJUOa0frfdBjEokDKYfDUCgoRfmQaCQfKA4kXhUP9kMmA4mm + AZERMZUJiQToKoe1hsMBGw7MJucaml4DRoWm15zgwLrA2NALX9H0GqXWhHdwYDn/1mYDCCGcxSxHFL9B + SML36mPLwVGc3bporOoQFXhBGrwnK9b7uzSd71OoL+L1H4HiJIDoMI+VsRw8aAWiEyN9GC2djdadCtce + CdTu9dY6uZ46+b72NzUG3+8z+q6Z/0cT9x1yHe7bRoD/hihOI//3Bh6NWDWIRUcZ2nnplgMIopPliERn + tpydKUWuQ9gZqrvGUmOqhJ0oYscKEUR0QG5qA3TfNNeoC9Ct8VdS7IlWLF/LpMGHoDx4EmjTbDm3xUE7 + YI1mW5huS4huY7BuY5Dudhc042ekgGsM0XvbUmOiVHavnJ+q4MfKuf586Zl4vRuReqUfaUNt5z7hBtcZ + jmw0GnVEM0YjV+qkvqrb7YRu7W+rlkb3u6DRGRALKA9buIMO4RsnlGl4jx9xNxtG93uzEQ8zyIH75ZC7 + 6SUc8yh6i6lZw1VhqtdwcPuE3T5X06RX9ZNxsQE3BNzVoHDdexykoQCkL9sbQRpK9ruZQprkwO5FO5Su + eRdV0utqGrZSF7wESkIxSGT/RUq6cdfTbNLL7J63+bS3OdxH4ZQuZ5MJL7NRD3SU3NEH8VnQpay/SKFC + 6B4ArXuYaye9pg+HoFoos9FQCwpvMNSCXQHSJbgfQ23AuKi5GW/ztg+x6HibQ4twyNcSzachlL/NQh/g + RDi95C2m9l3UIkG4OCgNwuGOWid9gA6kvKYPaaEYdJVc1cI3UbgLLgu6qq/pQzH4LuBc9I14oM+LmnMw + 3vWRrO5dDi4R1AzXrdvF9Lwt+gjwNcEnhXOhcuGykO8OykMmHEWXwt205C0WjpKcpNf04OuDs3pcTbpd + TM5jN61cw3VDza64NnezQVEfxjwRkCB9g0NQT58b+gZ7XE27XEzuuJjcckbccDK55mh81dH4soPxJdAd + j1VYdKIahCVXKKKTgGciKy1nH5N6gElD05Dxc5CPKhdbIcs5xW7Bi62yXkR0rr2A6PzScI6aJSyE88tZ + nXsADIOJb/lzcu7/bNNRLvw+SpVnf0qF7rFKXnxaMaaCitoTujX6hxNoqAs9XfAcNdj4qn5UMx/XKH7d + 1TxAdKJ3uyRHoFgODueA8YRtDaOi9sHRVdv3GgZshesm6uScxAgCAXpBtGChixARWWq0CJwDCmh9Eiqo + BqkH5ElcTC1sI0YtSKPenMpaCMqwEKRV2iFuF4AccgjQsHoDEHbFaNujRsWFATYfBZPEAkSUCARIyCEn + qjUqQA6xpb0sOBAaC8uGHDrrDF8zIqu9i4JA4EAoFDQmrxqWo5nRPVz+DXbbZeQWaadY/LBEtPgorJ0N + apH6N0h8a2hv5EBIhvzqwIHooFYmtB09nDd6HxN3UOlA6PlAKA6Eh8NOs+loOAxkRTkliIyIZV7Az/7p + hObYnCvstqssiM6WTm7TBfQWVTQhCU2vQU9fjNjLKaM1u8j0mn97rVmIWHEi5wVy1KI4gDBQpRe2Szu0 + gwo6QwWf8I5IHk20+D6V+keixsMEDilOPAt+A5ajjOWgmcj6s3F6D2Iks1F6MxHaYyFaPb7alx21Dr1B + Pdii+P6YyT9a+H+0GH3XYvhtiwINYLXIvm2Rf9Ms+6ZFBtu/N87xNUiPiq/qOTW+aJD9cj6vlz2rkz2t + lWU562x10p6t5Gcq+GkVO8P11lhpTJXzk6X83RIEeEmarfZwIVcbqGfOarxpgXjDXJkAfenewY4WcxOl + 6HSo6n4lv8VR24rTgHresVQ+pAfwflsLRKchSA/Sd4u5yRLZZJl8ulx2v1J+v1o2XS2rD9WFn6PTUXrX + QyRXveirjkzXBnnqCt2MVXpjLiaN7zFAM/A+M+FhBNzCC5JvOhiMuhsPuwHoBlz/HofuZ6AX7uhORoau + BNGBuzLwhgpIt34oQ7dkleiQe/lC0elU3YBhC2nIAbeAtJroQG3mOhq3nNCoByQOrpWTm+uYhxlIxpKi + 8/o80YF7v1onwc/gEHQGyoAiwOlCDkEsOlAnER1iOUD7R3iOjkp0Oj6RNb7PA94WOtA0XKir5OJAu+xc + o8LFgSsA3RMuDiRgVxAd+Jikt38TdRg+PrqqKtEhQN9AcaBRCx0NqAHaIuf2uCC3OEsiOkuLDkgYOoSB + o/DtwFFSGEQH2oIEiA5ARAesa6HoDHuYikUHuvSzRCe6kY5pRjOR49po5cLyPar1VvsXEx3V43P+daIj + MoOfAOe3bTUWHTq+9c+JO+ZE5whVvn0DFb53qQk6gHVKtXVsAWVftj7ABw14XaXOF6yi1mfr+OStSi57 + zolU9B7X1Ggy31kpOltC50THfytcPaU3LA0oCxnJUhsYIgNAkqS94kwCSAl5zg2exDPvfq8WkiH6IoRt + xJDyLHxxWGVIc/oxLYLNCDB42EgcX3kOysILwjaEhaEaglKkcHrRGkhvycecx5+UgAnxZT0EMuzFFdzg + y3r5sj6+rF9JOZoQzVfihfE1o7LacTkIUP2krH5CVjsmqx6VVQyihygW3EZTZNCqbPzA6Pj96A4dtpsN + bkFPCfKpkXpXS7xRHIhGU4IamMAWJqSdCd/DRO1jY7ADJYL9nERzhJH6nEHP4gOhSTrGJuA3kcFtPgLH + adDj+NqUT+RDy7zJg2QWyMF/FPvQdBy0qEo9kCPEcpRjVdhydMN2a4e1UyHHqMCLb4SVHI97C03HSaLA + bx7Hc08SlNNxsN9gxUFTjyWzMXoPY/UeRElnwvXGQ7X6/TRueGgfeIsaDpF+f9T4u3b59y2Kf7TKv20x + AL8hlqMUHczfm3hgacWBXSVqyvLzUBOdB1VITUBQCG0RSHRQuKWcB3cZJ6Jjpz1SxNUF6YHWDBZwA/lc + fx7Xn89BGvLBcsCHpsrQ6aBNAIjOFgftmTJ+ClSpiBsr5EaBAoBtDNaFCsdBjEoQkyX8vVI4UTFdIWuL + RGNY3fncRCXfX8jc2iK5Hqcf8xfN2Ne0btvJetcZ3N1gfM/B9L6rKVmffBuP19xyQE+EG3UzGXU3B61p + fI+HxAhmDOekviYZcjO7ZIeCFhftjPtczHowkOhzVQKig27JbmZQctANbvyocN27/ICrWc0aHtJwej+U + xKd04qou28O93OyiLUpDGVSPi9lNRxO4ee/8UIaMR1vjlqMJ1AbVQpcmPM2nvCzueVl0O6HXKnc5mUIO + 6Sr0EN/RzaAJuPGT2npVnYRM6AYcBaB7ESv1oAlPcx3IJ8BR6AzUedXeBGqDOsc9zCc9zaGtaS+LGW+L + tg9leOjKAlq862E+5jHXLgDdu4JPh89I2gUgIdQP/YHuCRcHErCLRAcfgg5DJ+GUbmdTocMEKAOyMuxu + DqfAFlq0MdSOXKXX5WwK50IBuOxYdMwg5xxev6a8zvhDwenkssC3NneRMVCm9l3Uq37sMYmv6iPRcYMr + Bn0wPY/LV6/hu6FX0Dco72YGrjOMGYWPj4H+wC7UPwBX3g0Vg550g3U5m95xNr3lZHrTyfS6o8lVB5Mr + Diad9iYX7U0uuyPR2UlHNy0mOvgJOi8iOi916Eq1jFndUV4KKKKDhq6q+ITmVXEF/71F/wfVQ3RaCz+h + wvdZL+0roDLWyZVmgRnUmtTwsI9PFK2mPorSsk1eEZtvtcTycgIVtTc4Mxw1pBq68smIoPCjdNDQle9m + uG5cUbfgFktBdEQt7gJ3cchUm3ADECOBo2r6ohdSBfnzIkAlytAIk32e2Mwc890CALFAJbedF3IE9PEc + GvHQ0nN4fmESvBG3S4AcIQgE50IZqAfS2FQQoDJQQNh9PkR91DIXAAIkTvfhF2UMggOhOUC147K6Sb5h + Ul4/Lq8dk0NO5TBf2i8r7EYzabZcQK+2SD3GxaN5M+ghwiEtdEAD7Vsj8aqWeFRJXMslrsUS1yKpaxHt + Vix1L5Z4lJIXijHelYxvDe1XywSAITWzQS1oSnVIKxu6Ez1Qkbw0SvzeKKX9qAQItvNMCLxBvPt7RQjk + QIcj0aRjtdXjQhQHzTgOA3bpguWE7qHC0DMAuZA9+dGu36Vog+I8S5A+SqCfgtzgsSplCEfpN/rA/Wi9 + +9G6D6L1ZyL174ZpDQZodntpHXufumyj/f0e4+/3geIY/KNVpgrk8N/O9xsljdzXKr5qYMWi8yVSE/4l + 8lkd/7SWf1LDZzlpo4hOFTdToWS6nGvDER1ITJVxk6WId6w00pWiowuiM1TADhaw/fnsQD4Laci/i8I5 + qPz9Cm62koMKQXTi1mndK0f5Y8XcKMgQiA5sC9imIF1LVmMgl5ksZseL2KkSbqqEbQvTmy7jT6egKcw9 + uex0pWymUna/ip+p5mz+rLnVRetOhv6NSMltP6bbjR2wV4zaGM3YmfThW2MXfhXDmAearfwOq9n8Hjvu + gWZgjOEJKCA6aeheCyqACp/eaEBujX0uppAYxDESgNySR1X3QjKU0/AeP+RmehBPOoHToRicApCqrtgb + DbiaXsIRnbp3OeFo+EpdqA1u4WErdWEXjam5m931MJtAS8ZQfKUHR3S6nUzARSB/zMMs7XW0ahrfdFFE + p/gtBmoWdxKJAubwWoUFnpsMrkMaJRAzg25DbSh65Gk25WU+jZsDSMDmsp0RtDjugToDn3TEHQ2ZIRFB + oqO8OKRdaBQS0HMCNARKQU6BTsJWGSdTDV1BeTir12Wuw+REUj+cSOj4GMWirjsYQw1wFIolY9GBs8BO + LuChK3KdSetwLrQLiVs4PEaGrtBlwXG1bX+hN6LxO5AeFDpKxhGmXhxXU4bZ1nAkQgPloZhy6ArH+Qio + G6owFVSICrugQbQuZ5M7zia3nExuOplg0TG+4mDcaW980d7454kOmqPzS0QHr7RSvm4JITxvV7CcX811 + 2IC8Vdv3gbIYJTXwkWXwFxJ6bDGO6Fys+BsV2SG8hHxxUqpXpNWYh26l1kZR70YwLkkrEovVnqG8ECri + YNZ2D+Xy8n1ouy4pcW4ysnc6CxeqqBuMBOyEyTo/pyDzIQNMasEYEq0R5wB0BoqIQD4SILG4qEIy4uEe + AAkEZy7OISwM0kBJyFk4Uxgg82OIefwo4sk0CxGLjsgzerXWIiHjCm4A0GGtNR7io5CJzvpxd1ECJXX9 + C9UyXxixAJHdfhmKAw1y1Wg+EFd3V1Y3wdcTDZpAQ2PVo1BAXtwjB9HPvsxuOskm7GPDd7IBtbRPqb57 + gcR5u8Q2S7ohQ299ut66NP11aZKNGfq2W/Udc6Su+aBBtHcF2A8D9uNfTwc0soFNbBByIDZkzoHIizPR + WjP0nimxAy20nwW7/3LIWJXaMwBVURwaR3EAMlCFFWeXBlhO0AUq6HRQZPxUgtH3ydS3CZoPVPGbJ8qJ + OLRYcYjlzETpzkbpzkTqTERojwRq9Hprn7HROPaW5peVxt8fNfoHjuV8h8I54DpYdFp4ZDlCIKeJm2c5 + jexXDXOW81W97PMGdVP5hcyJjrNSdEBQBNpxRIdID7gLAKKzyV4bbOZcOg0/F0cSJSOFHCjOcCGyHPAY + sJnJMlQeLOdBFQKUyIrXGClkIX+8BJkQgIynmDufgWzmRLJkEs9TBss5EKtnxWkM5zPD+Swkqv11UdPl + /L1yfqSIh3qOJEof1PAzddx4FTOUr9+zSb8nSr/XT3rRDk0H6fpUMeNods/FdNLdGESn5T0GvecIYTLh + iXIy0Bps+PMdxSFK32KH4RarupHjSAMC7qlgG0Q7gBsOyBsa30fTfbqcTIhbQGG4KQJn8HIqcAtIE+mp + f5cnR6HOErz4Gahdw0ErkA+VgF6AZBDz6MWiA7oD3gNGAkAPQR1ABaAnESv1vMx1iAfA6bAlNRBsDLXA + 2yABHwStQoJT8EcgZgbdho8AbQlSRbjvbe5grJ35JwnYDxxaKDrQHHQYek7aJY2SKwOA8EH34CxyImyR + PuIxr7MbUVDt0Fo5nCLokXAidDX9dX2iVkDz+7yljka/iwn5pFAyYqUutEs8idgJXFXSHygAfSP+B7te + 5tpwZXBIifTQDD4+uA6OxyBPBcgIFEDGFmtUQ12oY1Dni4lO1wuITusC0dmlLjrkmcjpR+aLzkmR6BDX + UYoOWm+FLYffcRWRe5XPu8bnXefzwXKeKzq/suswIaUrt7ZZpdRYpNRSIQ13ylYoF0MdpL5qMuDiGgwT + f8RawHWsU2tNAjMV7vFWcT9uOdZIdA4cKXsfvWgCGjpA/T9bNFdGZfMJzXB0df4h3iMNrQkq6laOCi02 + fkRYKDrgMZCjnHAjshkysQYNMC1wCBKSEZvKUuETYGHc5TmiQ+bH0JuPqeUvCilMfGu+MSCkKfvgKGiN + Wr6OO3qUDptzAQQFEmqa8lNF5yUiK0egAS+gDMGVi6gY5CqGOPSE6FG+ZgwNgTVOyZumFS0z8pb7isZp + BShR9YistFeWd1OGXppxgk08wMTspsNaGL8a2rtE4lYgcczRt9msvyFNf32aZH2GZONmfdssfYccqXM+ + 7V4s9SoXHIhFDtTIBjWhQTRVHIglDqQMBe0mr9vklCak7kBovf1vhhDFUSFMyiGKQ0cisOKQp+OgGcdo + Og5aV3WKCuhcE5Z3Nv4NNFaVSIHcPIpn8RZHcXAg5yG2HLHoACA69yN10fvJg7UHfLQ7XTX2v0HNZHDf + Hzf7R5v8HzsVxHLIcBVKNMu+bVKJTiP/daPsyybZl428wBcNAKfi5QxXifm8XvYZHr3a5qyT5azzqIZ/ + UDXH7ki9d601IEHm7gDgPZsdtKfK0EhW9Kda71hqXNhEg7L05nJNoXoZ9ugQSMn9SnQ61AaA30Al8eu0 + wITg6GA+l+euU+mnO14qA/zWaAF3ctipUv7ONhbSIFJQDOQm30MHmjuVKpmEswq4mLVa9n/SnIaeVMke + VMsf1ymeNsq/aOaeNLFTNczVzWio64KvtM+L6XfkR2yM1kg1d7/Fz7iZT7qbTrmaTGH12fSa/oS76V30 + 8EC0ZGnPh/IRUAc3syNrDbwtdHqdTUGD0l6XZLwumfBEA0x3PcxvOiIXaXmfh/QoHH1NYmOofdbGCO7B + cGvfaIgmTV+1N4FdEkrBM6DN0RiNu3mXsym0AtxxMoEbM+SMeaBq7+FRpPveFn0uaOgK2oVdsB8AmoZ+ + juNBpXM2ZME2C4KFmrMxilylB5nQjfK3WRCFGw4mUKwHt4KmEuOxql4XUzhU8TYLqgFtQZ1Cc4TD+CGH + +X9DsSJo6LqDSdlbaC0VMj/cbUjA7q6P5FhxzMnFgVagchA+6B65OHAubLE+SsjFge6BrEA/4cNCn+vf + 41Nfk5BepYuuKnDL0QQ6WfkOC1eg2xmFZKBFOBfJiqsZXC7SHzgEHYDrCV8K9j/UvV0fyuEoFkrzO05o + JjLsXrE3RuqjGiND4oJMyIyMxNWtQSOP/WjUzxx/EehLJx3D4osG1MjpUIyMvpFBNOC2k+ktR9MbjqZw + odDQlT0eurIz6XRbRHTaRKKzd3HRwfORuS2nuC2nObSqHDjHZZ/nsvGLylE4Z77rCKKjdB3y+JwXcx3C + AmX5eTCxLWgEKr3BOqWaCmxvyH4XzSwG/9iLYi2fZGzVitkt1pTFSa5GM3ISK5Z6ILIYMCc6rumbZoVy + Hfsx6m6FkWZQpXkKej3W6h37GPcMNG6lEh21kak5VPoinqK71ADQc3QEDqk5DZkQA+YhziQsDNI8v+ZF + w0LcAi0AQEegHtX8GHWI0CwMt+iFVUO+JLaVTGRWOwpAtS9RdGTlfT+R/kXBk34WAg4EAiR2oLuyhklZ + 87QcCdADRNOMom5SXj0mLxuUF95Bj9/MOMUnHeJi97BhLdLAOtq3VOpeIHHKkdpslW7I0EekSzZmSGy2 + Suy3SZ1zabci2quM9qlCwuRfzxAHEsbCQsUORMbCVHEgMsd5gQMtwo8WeA5qloOH2JDlRIhm5ETukwAR + ZGnVXt2wDt2w3VToYSq4UxHWVhFt/30S9X0y9RSNVbHCXGNkOaA4quEqkeigESu81ZmO1B0P1R3y07zt + obXvLarLV+/7o6b/7JD/o1UBovNtK1gOoAC+IVNzsOh83QSWs6joCJZDUDeVX4hYdLKddR7XyEBNHlYr + 2R2l9561BiSI6wCgLFsctacrkIgAIB/ws/OOlYYlhziVKgXLAR8ilgO1EQbyWcc/a1rxaEqyFadh9yfN + O9tZUkPXdtb/XS3IJJVAhVCDAEgV1A9nwSE4q2sHcw98C3pShbr3tF7+eYP8C9CdFsVEBZom3FfCjJXT + /Vn6PfHSN2QaNe/pDjoaTGw0mnU0eehu/i6rmfm63hRelz7haQZ3WbjXwu0TQGbwDjfuaTHhYZHxR+mm + P0rveVtMeZkDcKuDmnd+JJtEE3jNbzmZ2hmjXsFZcH8tfwe1e93RdNTT4pojKtn8gWzCy+KuCh9LHW9L + nRFPc2AM6veymALb8LWc9bV84GfZ74ZentPnZgY5Mz6W0z6Wm/8kXcNpQZkJwMvixEZD6BvpJ5SMXq0H + mQNuZsgS1nCTpJi3RcuHMsi55WxKdjf9CYXKIOeOs+k9H1Sz0CIBJMZKVwN4h0PVQkn4IEKfx70s4Gqg + RjlNALX1DgftAtAQmuLjYwlAJ2ELvYU+o57gAtBDqJBcHDjx+AZDqA3yM/4khV6REwnV76KgDgGuEnQA + ziIXCkh7XfkRbjqZQg3wpUBXIUF6qOwebgU4ut5gbO5ECTDqaU4gX0rD+7IhD3NgGMqQLTpqAcCJUAx2 + h3GBAXfzfndzNMXHzazb1azL1ey2i9ktF7ObzqY3nE2vOZlecTS97Gh6ycHkssdqNdHZiUVnN5OERIdN + 3semHGBTD7Bph9j0w2zGEfTyB9UcHZXonHkh0VkY1Hm+6yyqOy/CArkBhBcRsFvPmoZuX5W1ywpEJ6zd + N94TDV11YAU5SlUUOFHhx1Yml6vJyiKALb2A5VijhVr7HTPTlBN0oJWTVHPWm5Rf64rUGuu0OuuMRqnv + dq7oNlfSTZZPo/CMEJsR6QK4BWgEIJYMIjpqq5OApXSEiIua6CxVCbAwSCOOxBCIE5AYzItLBnyQpQrT + mcfRJ13MY0BxoBUyiXjRUScytgU1qOU/H9m/COWkH3XQhGhZWT+HXpSBo0FkTnTdhKxxWt48oyBAun5K + UTMqrxiQFXXJtl/lMs9wKUfYOBCFNiYYHKiC9iimnXbo220BAZKsR2Nh+usz9DdulthvlTjtkLoU0J6l + jHc5jSYD1TEBdUxgPSMKBTHBO9mQnWgedFgbE96OiAB2MygIRMCDYlGqiUEvzjy/2ackSjVcFbFPigM5 + ZKuPXlm1Vz9snyQMtns0wvZTwZeo4ONhURH3khT/TKG+idd6kMACj+PZR3Esnm6sfKsDerFDDPgNUhz8 + Kit99Cor/H5yNGgVpj0coHXHS+vYB5pnP9X5x27Tfx4y/EerwXc7FYRvW+XfIMsx+KZZ/vdm+VdNMgD5 + zTzFgTSICIno8GjEitD48vmsgX/WwE9XcsCTOv5xHf+odo7Jcg62D2v5BzUcMF7G3i1lZ6u5mSolV7bS + OyP1TqdLhotZ2L1fxcFRKAn1QG0EUuf5TZJdUXrXsmjhXFIeuJpFt0XqwRZlViKmK5SJnlymLULvdJpk + RjWgRiwHROpJrexZvfwzojtNMujYl83yL5oVn7XKnrRww5XMWLF0YJOkL5ruC2CH3Pk+GzSh56GL2QN3 + ixlvs2kfk2E345YP+H2fygbdTMFjpgAfi2EPM7gXzviCjljc90P0uJvO+FtM+1tO+Sk5aWvY8rFswNNs + wtfilpspbAmQnvSzACYIvha+1jrl73JjPhbAOJTxs7jnbzkTYDkbaPkg0PJRkNWAl9nDQLQLmcCojzkA + CSgGDcF2yMt8/3oFNCdUDtxxM4NDBFKsy30uBzhtZ3RwvQEkSLWkOQDaAiAx5mN+xt5o5ydy+CzQB2WH + MaSJQS8zaBSahoTwwaHCEW/UPQHSYfHF6XQyhhNP4GpJVZA57K38XGKgKugAlEftwtVzNYVLRIAc6Bi0 + TmqAiwBAPaoKLQY9Tfevk+9bJ+/3hOtvPu6DuOtj3u9pBkCZcR9UJ1R108UU8gHowJi3OXxwvEXfCAbl + j3qbQ2egiUEv8wFP8z4Ps14Psx4PM7iqcKnhyt90Nb0OuJhedTa97GzS6WRyxWs1ZZK4k4luYmKamdhW + Jq5N9TpPQXT2I9FJPYhEJ52IjnLoissE18GiIw7qzBOdhUGdF3Gd+bqjZjz4fQXIXYq6BH35Sch9Nr9S + cBgsRJbQaOC3+X80aiofjnyQ+m+tvDSuVZ7QIJaVX0RyBZjT+Yq30bjVbhw3OkjZR/pQYa3gSauyd5mF + b6djm9GkEywNZFxpoXMw284Td1E7tFREh0wuFkdiADgXBGJhefGsXjXEwkScgMRU1AaVwHJIzaBB4vyl + ABFZWAkBRWtwVdCQ2iGAzbkAh+AflFE7RFCa0PyaQSn0w6pBj8SSIY1tBcQ5vxv60PtQ0RvBlLDlCNUu + FiDsQHzFIF+J5kTzdXf5xilwIAMQoJb7kJDDbt24HI6CLude47acZVOPcQkgE+BADYxfJe1VLHHJlYDx + bNgsWZ+qvy5Vf326ZEOmvl2WPnYgxqOE9qpgfKrRcFgACgUxQU1MUDMb3IxCQcGtyIFQKKiNDW8HsACh + aBDWIDIraEkBQk+sxuAoDnnYMQHNPiZRHBTIUUZxyNKqDp3wvVTIKSr43Efh2y7Hv45eyZlAzcazD+Pp + R3HMA0goQzhIbkSKgxBZDgAJyVS4zmiQZq+P5pmNmgf/pvVFidE/Txn9o032XRuIjiESHTx0hWM5KJzz + 92ZkOUrXmbMcpd+oojjqavJyIaIDPK1HCHaiBsiK4ECC9wCgNWIgB44SyyEVCtWqnaiGWj2LAAqFeVjN + PSaWU4fCUYTP0QQmFU38Z82yL1oMvmpRfLmTf9zKT1WzowXS/nTpQAQz5MsPuxiMOxjNOpg8cjN94IUH + dNBzitH8FTSRxcf8vq/5rJ+FCkvCfT/LGV/LGT8rwj3feUz5WsJ22nfuKOQMeZpb6mrAX//j3pbAhA8q + A0dn/a0e+Fs9CrAWeIhzADhEuK9qiCDUvBRq5WGX5MCWNAdNqDUnnAKVk08BiRdpSOikgFAVYdF6Fp64 + sAOA2pWcVw9cfxHTvpZTPnNMes9LAxPomlsA494Wd70txgAvxF1vy7telmOAt8WoF2LE02LY02LIw2LQ + wwJFdNzNe93Mu93Mu1zNb7uiiM4NZ7PrzmbXnMyuOpGIjukVz1cWFR3l0BWbvHeB6ByZG7pCovPCo1cv + 7jpFYDYC6qvKgUUzXxzGZ9vqXPTMwJVptZRbbcfWV5WvFsdBnaxcHyr8xMrksnm+8rNYmVxORe97O30H + WsEOigNNHKe+qJRoueUYJ6GZPa8UHpV5pLDZ55DolHQDbN418uIqLfRihEz9mGZdv3ytT0M0OBQ11bZL + IMUE6E1o1AmOQmEoKeTDiSQfMpWVvONOdiEfCgslATgEmey28zzYzHzAJ8B11DKJ/YBL6YVVAUSqSKQH + XEqt8KJIsJ9pWM1b9A5ADsrnzJeqh8PTieAfyJmQqSYK2jioA1qj518IKgNbEgFCAaSCG6QMg00L/gk5 + vyo8mr6zCNwvpUeQofmABvVzlQN4efyYrGFC3jitAPtpvS9rJlOCJvHrw/pk+Te4rItc+kk28SAbtZsN + aaL9q6TexbRrntR+m/7Gzch+1qYB+hs26dtuhUypU57UrYjxLEfDYb41jH8d49+ANCgQQCaE3j8f0sqE + 7mRC25jQdiZsFyJ8N0ADYEKRSmi07RCGqFR0SCM60DMAw/fphe/VDUePyZGE76LCj1LBV81DG+pjNv4j + ifpHAvUoVn8W/AaZjer147GS+yKtwWajPxOF3kY+EyWdiYK0znSUzlSk7ni4/miwdr+P5hVXrY4/U+Px + sn+cMv9ul+LbNsU3AIrlKL5plf+9BQDF4TGgOHICieKgQA6IDoJTIfv81+SzBsQzFU/rf4QndYjHKh7V + ykBfCJAGIBMKkMLiOslZpMxSCFUJtanlk12o52md7Nmc3KCgDkmrvIfkyL9oQjGeL0F62gy/bJM9bGYm + KpnBHOlgonQglB304kecFVN2JrPOFo89LB76mM/6ms36mj/wMX8IruMLWwuMJeEBHgAi9oMGmxaARohE + hwreZPytdPF91wKABCnzwM/yEWiHv9VjFWQXeOhnSRCGmQBSpxjiXuSQuOSiQG1C/YDQHOQLNZOOiStf + ClLhQoTmoIxQlbi2hSeqlScXjSA+UQ0wTgFwHYJyRAxJEkpM490pH7jm6MqTET3QHWKcapYjiA5YzoAH + HrpyN+/BonPH1UxNdK44KUXnMoiOcWKrSHR2MnNzdPYoRQeNXh3Eo1dYdBYdvfoproPWXqlZDnrRFUG1 + zrzozq8EndBuGVe8MhMNHmmH1L/p54dEBAAROUD9zz16Jgl12jG7XmgAa2mskyqMEuqoiCMjdavReiuo + HDhNpce/T7nXrUqrsUquXpXTIXVNYfOu4KGrLgKbd1Xr02ByGxb+ab3jph/TJJQRA/ZDyqD3cYrydf3y + iB6Rf2AzYEUSLEAgOnxJtwCcqGH5hjiHAAaGTvw0RC0f6iE2Rv5BK3qhlUShoH61wosCHSDnqv0jL+eC + dtXKAzIQGgzyIc6cz78u5KgBh3SwdQn/kDm5bxGXAasjDifO/OUI7qUGV/YL6V4MtTI96JWoKvjSfoTy + yUDK+dF82SBfPshXDPGVI7LqMb5mXNYwJWuakTU/kDU/lDfPIh+qmzCoGpHDWQU3uW3nmU0n0IPRY9rp + 8EY6oJr2LpW65UkdcyQ2mdJ1IEApeutS9NenSW02S+yypU47pK4FjEcp460KBfmBBtUzAfU0aFBQMw0E + t9AhLdKQnXRIGx3aJg1rl4bukobtkiB2S8L36Ift1g+DLVpUpQOE7tYI3UcFXaRCDkdHhjxIYL5LpJ7G + 6c7EgdbQs7H0/RipCgkek8LDUjgxHaVPuBeldy9KgojUvRelOxGpOxyi0++nfdNTY9/fNK64S747bvHt + XsNv2wy+2Wn4TavB160KRAsg/wr8RsWXoDhwM0Z+o2RuoEqJ7DPQkV+TOct5AZ6AsogguqMGOUTKC9U+ + p/xPRagfXIeA5IaIziLIgc/RdYaLb/BlK0iP/PN2braRGS9hBrdK+mP0B9HYlmLM2WDGyfSJq/kzb8tH + fkRxMJAm+Fs+DACsHvhbArPzsAAeqDi8XrGG17TS1bjiZHzP12IKM+1nMQOShAtAPY8CLB8HKoE0gCtf + BKFaQNyQWrHnQ5oQA5niOhfWTNJqkEPPQa28gFoxAXJU3AehG2LEhXECpAeF3MjwIgDXFoNjb+BAGOHi + T5LQjg8K7dz1QdGdUW80YjXqZT7iZT7sZT7kaT7oaQ6ig8at3M163M263NC4FYjOTVfTGy6m151Nrzmb + guh0OppccjS57Inn6CDRAWJblKJDRq8WnaYjjF7ND+rgF12pREdkOeyOywCIDllezgNEdLDrYG4ilE/T + WaA7YhYoy89G5pn2StEx0BHLlGrKpuDCNrMfzuInHYOLHKV6al+nwo/J4ht/tuuA5VgmVVJhp/Pz3JSL + rXA45783aOvZJ8tiqtG4Vc5e09BtdEwju+OSWFAITPZZMBsCvemo2lE1JMkdYBgL/YDLuwb5AKiJOFNI + L5Uj8JxDUtyo2GyeU3ghUFgM2Mlz3EWAwfOm1axlUUBlpLEtBLVDhBdpDlBTljlUTx0Uo24eP46au6gh + LtmL53SrT+VRGkwpZk5ogEGEemY/X96HgNPL+7gKBI/oxds+vrKPrxrgq4f52lG+4a6seVLeMiNrnQX4 + 5hl5wwTokax8QFbYxWdf4TadYZIPM7F7mPBmOrBW6lMudSuUOuXo22aimUBrU/U/TdZfl6K3MUPPZou+ + XY7EKVfPrVDPs0ziVanvU42p1fOt0/Or1/Vv0A0AGnUDm3QDmrUDW7QDm3WCmrWDWqnAI1TA0U9Ct16N + eeW7eOq7WOpeDHMvjpkWMYO29HSMgHQ6GnEPXAczFaU/FaU3FSmZjmTuRerfDdUeDNK+46N1/GPqxAea + 37abfXfa9JtdJt/sNv56t+G37QbftCu+BtrkX++Ufd0q/6pV9lWL7MsW/ktwnfl80cx/0SRDoQgUjZB/ + 1ix71vRb8LTxJ/BExOMGdUj+oqeolXw+S51C8lGdTYhncImaZU/Rp5B/1oj4vEkmRrieXzYrvmqWf9kq + /3Kn4qudBl+3G3y1y+BpOz9dx4wW0oObpENR9JA/M+ZmcM/B5JGzxWfuVp/5WD0OsHjkb/EIS88jP8tH + vjgcgrAWsQKj3O1zM9v1saLXzWxGNR4EoLEbP6sHfujER/7WjwOeBxQQI9QsRq3M81GrH4BMtQoFhLPU + 8gHhEKBWm4DaKQRxAXF5tWIC4qMPRPkCD/yUzGLu+yLggouvuWo4zGrSx2oCM+5tddfbcgzwshzFjHha + Dnta4nCORb+7RZ+7RY+bRbebBR63Mr/lYn7Txfy6M2B21cnssqNZp6PZRQezTg8U0WlhohrnREd9mg4K + 6nCpB7jUgxy4DonobMYRHfQWCOU0Hby8/Czca9HTdLZdQIvMc9DTdNgFroOfpgMscB1Bd+YZD2GB9PxU + iuZ5kjSwaOWWndbp9SvTanX8K6ydAtDjbQ5jHcEDWG2l66mwk/L4hp/hOirLOem/NR7NdIaaodq9KJwT + FPox5Vi2Kh29TuuVouOMQwy6YrlXuOI7z4Ev6foPQFba/cvRsUfhK9AdtfyXAr8gB1ggHz+PrgWQfLHK + KFnSZoi7zFkLgRQgCOVVQqM2WFbRw5cT5ucT9VEH6hHqh8QgXz7EVw7zVWN8zYSs/p6scUbWNCtveiBv + mJHX3eOr7srKBmVFXVzOVWbzOSb5CBvbQUe0SgLrpD4VErd8fcds3Y0ZOp8maX8Ur/VhvBZsP0nSXpuq + vSFD2zZLy3GHtnO+lmuJpnuxpkeptkcZ5VFHeeyx8M6tC3rvm0jq20hqPFx6N4KeiJBMREruRtETAtH0 + JGYKtjGAdDJaQpjCljMZiZiI1JuKko6H6w0Fa3X5aV+w0z74F+pxvuG3Z83/vsfk7x2GX+82/WqXGdxQ + /94GlgM3V6w4rYovW+TAF0Rr0HaOz5t4fHtGQQhy//69QTzjRfh5Z70g4srV+AyMRwmk+c+bEfjyoi1S + HzRtGX0FX7Yovmo1+BIEdJf8y12KR63cZDU9misdSJYMhdEjPrJxZ4P7jibPXKw/97R+4mf+GPAxf+Rr + /sgP42/+EDQoQDU2pJwBg27MAGgNyA2ZiaK0HNU9m5QUi4IYcvSl85wmhC79VBat7VeC+I0AuZj4Oqtc + R3W1AWI5ZDulspwJbxAdSyQ68y2HzM4B0QHL6XVTis4dLDpgOTeQ5ZjjcSskOpccFooOGb1CQ1ftTKI4 + ooOn6aShaTpkhTmz6RgjuM4W/NjAn+A65MmBC3VnMeNZ3HsWZYHZCAk1Cm5weVflnil/KDoOwrEipYJa + n5ce/fYP51QzaWB7lGoqsaHCj+rEtqPXOyywmaUAMVIk1IPlBGTFo/XkB3CFwDnqRp4J9XGmSWwZDud0 + WETlSUPK2Oyz0HkebObfFhlIDKiMKvHrwedd1eDMtD8NVsv/qfCli8C9HO6oUMvvxiinePOlvTwaXerj + S/BWHTzqpETtkAokIniqtVJcMOAxasx3GuU053lVPbeVF0OG14jx5cN85SjSnbopWcO0rPG+omkWtjyk + a8e5yiH0irHc69yWc3TqMTp+vySiTRJYo+9drOOWq2OfpbU+TfvDeM33Y6n3I6j3wqn3E60+Ds6w/fOU + K/WNJzXmhdZ+9/jp9Qbo9QVI+gMl/UH6A8H6gyGSoRDJSIh0JEQyGioZC5WOhUnHwgmSsQhMpP7dSHAj + 6Vi0dDRSZzhEu9dX+7Kbdsefqb4Y2TdnV/59t+nXuwy/2m30VbvxV21GWHEM0A21BRQHQW60cMeF2/Ac + jYhnjRweUUKRCbVb+zI/j6dN8idgjeiqKi8ysh8S78H28yWKrsm/bFV81Wb4dZvB17sVn+/mH7Sw4xXS + 4WzpcAw9EsiPeComnQ0fOpk9cbd65mP12N/yob/FIz+Lx7D1B9FBg0Hklv8wwPpBwArCrP+K++gGPJfz + MGDFo0DE42V+IuS6CcB1JjxQMQvS4299HzPjbz3th7jnZz3li5j0tZrwtRr3sbrrYzXmYzXqbTXibTXs + ZTmEGfS0HPC07Pew7PWw6HG36Ha36HKzuO1mccvV4oar+XUX86vO5leczS87mXc6mV10NOv0/ANeXh7V + SMc00bEtyhXmCe20+qN09jNpB9HzkcF1MpSuIwR1Xsh1sO4g11EP7ah0Z1HjQdJzc0mV+Zncgi1IxopN + TSvwTB3DiELq/bTOXPMfzqu8BLvO+Zq35XFNoDvGCbU/GtpZQQI5UfupyP35BR4oPkQsZxf1wynq/7ZT + V7I2XNcrD4VzUmpeKTxK20WxW05w2y/yxbd/58hKQGL+9ejYxaNwzqYjavlLwb0cbi+GWhkEj7bCFO8e + 9DIsBLaZkv7FIIfUwSYkgOJMfBmhCyPsImRl4sLgTyrmKlyyoR9FhlHLhA+1SCYyHpWcIenBVPTLEAN8 + 1RBfPcLXjnGNk3zztKzlvrz1obzlobwJNGgKPUW6vI/Pv0VnXZSmH2XiD+hH7KIDqwICPE/4mB92Ndzr + ID+3kbq9jupfS42upcbWU+Mbqbu21IgjNeRM9XtQ3V6aXT66YEJdfno9/liGAvX7EXoDQXqDwXpDQIju + SLD+QKBel4/WFQ/tfW9rnLfX+/sR678fMP2q3eTLNpMvYbvTEMVvUAhH8cWc3yj5rEn2tFmOwHGIJ008 + Bg3KPGuUP22QPW5c5iUihy0YD4ZcanS1cdSHBIFUwR4sPV+Cnu6Sf7Vb8bRddq9BOlok7c+QDqCxLW7E + DaTH+JGL+TPPFU/84KaLgjp4EokFmsGDl4vPBljNwq0XXGc+D+AODffpoJWPgmCLEd28l3kOcN3EwJUk + CNf2PmbGHzHtv+KevzUw5Wc9iZnwsx73tb7raz3mYz3qYz3iYzXsbTUEeFkNelkNeFn1e1r1eYLoWHZ7 + WHa5W95xt7zlZnHTDUTH4pqrxVUXi8sgOs7ml5zMLziad3q9iiI6SHTm3uu5k45vA9GhVUEd0YsgDiLR + QUEd7DqiAawfd52lQjtzunONy1e5DsgN8ptfjbwrXP411in2D8Un0KTgtGo9jxzqw+ipGjmK6xDX6UCu + 89928WHbYjSi91ARR6RxLeaJVdbz/QZ2LZOqZPGNVOQBKvLg2k1ZA42vonk5ZMQKLOcE9X8e0HjNwYva + kLUyBdnSK0XHDL1TmNgmbutJvvAGX3TrX4us6PbvHH7HZT2fXLAcbbs4NQkjcL8JOILVpWLeg5pU9D4X + VTE0S6kLxIgvFaH0GADSGJQvCjuhU/C5qBLyfnuoc+5d9z+fosWRFStRSpvKomRkS0a4lGNkKshcH7XM + RcDjZRVYhqoGZDUjsvq7sqZ7MqxBiMZJad2URsWkfumQIv/66qxDb6fXbkjc7hWdGBEakBZgl+v9drXr + qj12ipMbtC6vo+58SvV/Qg2vpUbWUcMbqUE7qs+J6nGlbrtRtzw1b3lr3/bWueWhedVV+7yjdscHmrve + 0vyswuSrAybPGo2etWCaDZ81GzxFKADlLRbdbglz9+BHGGWiYZlfhYcYtUyC6htRfilk6s+TZtBQ2Wct + 8s9bDT7fafh5u+LZLtmDVm68Wjq4Q78/Sdofwg56y0ZdDO45mTx0NX/kZfXI1/KBv/msv+V9f6sZf4v7 + Aarl6GjX+n4AYjoQ7MdauEkv87NR8xux4hDLAcUhlgOK8+KW06OynNtuSHTAcq5jy7mCRafT2fwiFp1L + Xiii00xHNahEp0UlOu1IdNSCOuSlV4sOYC3lOjkX2BxwnYvs9jnRYXOvoIkpeVcxRHEwBddFoPcZ/Yrk + XoZPZOS3+ZXCY1bJVauSyyjbzXofh0/VKZDrgOUQ3TmIXoM13rQyeUfIayklGjG7qchDIDRU1AEUvIEt + 7EbvNUus8ctOuFD9NimvnH0MnKL+jwOaa1zcqA8zrOLy0aDVtg7rtDqJx2Z20xEUzim8+WsjQyrzbwZf + fIvD6Ec3aFj+DRQH/mn+cS2b20nyfwo3VdulwMVQqG/ekJyKBVrwHJCLEO7wJbefjwyj2hXNxBJ86Ecg + japlLk3RfMSHkD/1yFAUag7hyUlziEbBlKgV+KUo53TjNfl9bPmApHJEr+quVs19qv4Z1fAl1fgl2tZ/ + SdV+RlXN6JaMsAU3LLYdfyOjeW1Snkt0cnBoaJK/Y7bne2Uuf2h2kB9ar3XhY+rmx1TPB1T/e9Tt96jL + b1OH/0I1raLGYrW+bONmytnpCh69irIKcR+oBuSzNTLCg1rZgzq0fViHERL1z0V1n17m1warj1wlQBjs + PU+b5c9aFJ+1Gn7eZvB5u+xZm/xeIztUpte/VdIfK+0LlA26y8acjO45mT50s3zsbQW6M+NvPuMH2znu + K7fK4RUlqvu0cOde5kcRLhqg5jdixREHcl7Qckg4h1jOTTdkOWrhHBCd8/NEJ2r+6NXiQZ1FBrCUrrMF + i87W+aKzjYgOdh0QnR2ETjYXXEdNd+Ybj8A89Xmp5F0B15EGl1glVqzeccA6uXpFQiG1IU3zw8hLRSuQ + 6xxSrcMCa4H0Eep/7dbtq3u9vXT99jyv5O3BSdtDtub61hfbXal+47+18aSMcpYPsA/Ny/milX3dwZt6 + P9UiIsc6pWZF5s7VuQektlFsyj5uy0m+4MZLY4Hf/O4oWhzuuTBbT2m+/img45qBlqctKCDixmIIR4nK + 3Mavx1+ULnUVmAd5XqWqMJokjmM8c5pCEHJu86UkcQshNidlWy+bwiWAQyT+JESDSAIPinFoq9SL3y9k + /A6NzXXjnF6urJ8pH5RUjurUTFJ1D6iGZ1TjF1TTF1TDF1TtM6rqvmbZGF1w2zjn9Oub2j9KKraPzvAK + Dgn1dol0/CBizetldhY9ObLhDOpBBvVsE/VFJvXFVuqLbdQXOdTTXOpBvuZ0od5EMT1ezI2X8uNl/EQZ + N1nOT1VgKvl7VbLpaoCfqQFkwH2gFjFbp+RBvRwZkkA9/6Aetsu8XOCqKnnYoA4OvMkfN6LI3NMW+bNW + xbM2g2ft8gdt3EQdPVgg6c2Q9kbS/b7ssKt83MF01tnyIXo8j+Wsj8W0L8FqxofEeKxn/OaDjQdu2MKd + WwnsYoT7OgIX+6/JvIsz328WVRxxIOcFLWfhoJVaOOeco9lFNEcnoZmOrF8yqINEZw+TspdJ2accvRJE + Z9NRZvMxJvM4kwmig11nK3adrDNsNojOWXYbuI6gO6q4jqA7SxqPSnrEqAnQT4QvuL4QbvtFQOqxeWVm + y6rte61Tqq3j8qmNSdSauOyk99EkmzMqcQHXAcBdiM3AIUgQyO5+1RseSOGTKJZzOPc16adh1IdJluFZ + UPmKzJZXCo8xtuFM/E424zCfd0WtPz9CIdjMvwcLbOMlcn0xyCFsM6opXHNSMsd8M1BHXBJOV1GMwkuY + m3MgdxEjlBdXshSLtvgCiJ8VLiAuMDespnzuAIoPoWEvpdagaT1kq4Is/por8C+GRMLmD9iVdslK74iA + XcIdGZqihGYpqSYq9fKl6GGJTPmQpGJUu2qKqn1I1X9GNXxONX1ONX5O1X1O1TzSKJ+As4zzLryW3fFR + doXb1q1hm2PSM7wL09c3pL91IHXV+WRFV4rGeAr1IJV6mk59vpn6PJN6mkU93E7d30FN5mnfLZCOFTGj + RfxYMX+3hFfKUDk/WSGbVJoQf6+an65BzNTKMPx9xJwJYXhEPd7Oy1/mxSFXb44HBLED4RgbivqA94D0 + NCs+b5E/bVc8bldMt/CjlZLBHP2eRGlfKNfvxQ87G03am806Wzz0sJ71sprxNr8H3oMeaqdcAk0A15lW + Ux/MtP/KZYB7fivUmBIx6YuYwIxj7vogxnxWEL8Z9bYe8bYe9kIMeVkPelkPeFojxfGw6vWw6vGw6na3 + 6nK3uuNmhWM5ljdcLa8DLpbXXCyvOIPlWFxysrjoaHHB0eKcg/lZB/PzHmiODohOHR0tiE4rHdcqiA6d + tJtJFkRnP5N2gEk/yKQfYjIOM5tewHWUunNeXXcWNx6l9CymPs9lgdm8IKhvWWekLikrMltX79iP3kwe + V8g4J1BvJf3V1ftC8Sr0bnPQHfI+zh8FTOgU4l6doUeIPfVOArUh3ipyG1jOyq1trxQcZe0i6Kh6JnUf + cixRN/iC3zvc7wU8eUuJeGnebcydxSCHAChG5n6Rue14tpY4FFR8nSuGLUaViWNON+ZmdwmT4ueq/U0Q + ac3cgxLIAwiECdFza75ECEd/N4gCYErUZpEvgCyXU8tU9yEB0CCyJQkCXvvWS5f2SSuGdCpGqfIpquIR + Vf4MUYopuk8V3tXP7zbcfvHV7P3vZ9U4bckJ2JyQlOGfm2ZfnfrenpQ/nEg2vpasN5xC3UumHqVRTzKo + x5nU4y3Ug2xqejs1kac9ki8ZLmBGCpmRIm6khBst4cZK+bvl/DhQwU9UyoDJKn6qSgYmdA+FhWRqPqTa + 8vfrCDIlOGJ0v06+zGLAlYFrxWHwdatXbREywmwDIAceotEu/lGT/HGzwdMWg6c75bM7uYlG6UCpfs8W + aXc02xPA9bsbjNgbTTiY3Xexuu9hNY1eU2CO37FFHmpnOeVjNeVjfc93cUisQhmuQKGLlSLm3fX/4yFa + I5abhX6jpjjEcoji/CTLuYotp1NlOecdkeWcsTc/pxSdKCw6MXj0Kq4Fi85OOqGNTkSjV9h1On6C6/y4 + 7ixtPOrec5nLu4KeHaxkgeL8Ytis02zmCXAdq+SqVwqPWqfVWsWXmvomUx/FUe/GbwxwOZ7/h/+5RwcF + aU6jd4+jKM5+7DQAJMikHOw3PxyguisswqPXU59EUe8mGLjFWcXgeTk79q3avpexi2Aia9mUDm7beR7k + 5nfJArFAsC+Bq0sjlLkOKGdQCQvu5lSGsMAA5oCjgo7cRIGlwuvzuaakSC0fSopVBhC3KEatuRcmX7UV + Iy6gCkQhlGsDMXPzoHFCffHXXIF/OSistQAZ4pYKsvsc7vxyniNPqszbuACeIIVNkS3pYku6mdJeSemA + TtmwRvkEVf6QqniKKH9KlT2lSh9QhRN6+X2y3Csrtx96Z1u97ZZ8v4zk2IzgLRnOZWnvt6b+8XCKZWey + tD+Zmkih7qdSj8CBNlOPBAfaoTWapz9cQA8XsgiiQaXcWBk/Vs7dLecmQIOQCfGgQZNVMmxCsqlq2b0a + HpiuAR8SUatkpla+jDp1spk6fh71BJmSBthi+0Hew882yh40yh42yh+18o/a5I/aDGZauZEaSV++pCuN + uR3B9vnIBpwVw44mU86W992tZryt7oHl+FpOIsB4rCbRWmjEFCgOXiCN1kiLANGZ9F8BTClZqULI+c+B + fNKFTPjNMY65ixnztQZGMSNorMp62Md6CPBGDHpbo+EqL6s+TK+nVY+nVbeHVZeH1R0Py9vuljdBdNws + r7tZXnO1vOpqcdkF0elscdHJ4oKT+Xkn87OO5mcczc95gugkNCHRiapXuk5sM3KdeOI67cR1UFCHuA6a + kjzfddAY1tKhnUV0R914uO2XuB0CnfMA0fnV6UQd3nRE4pFpErztleITK7fstEqqtAjPVrjGUB8g3Vnp + 4h8Tu/bA9tcnqw3/7zv1/78dGsq3Ruyl/vd23Sf1srMFq7amfPC2tyf1YSy1JoF2iDYP2mSVUGad0fhK + 8XGrxEqpbSQTVcsm7eayz6JBq381XP7isD+Ty4shHL2KuSYgjmYt9kwBwQbIrlDgxtzpoERojR6ZcaUy + mMKrygTOmReLQmepTplDqFm9oZ9GnhJehVoB8rYT1AQJKSmF7BaeOaRCOXV6PuIC/wLI3KZ5iOdXEWTP + Q32auQr1hXW/CiLlUtMyAfYFYIrvSEp6dEoGNEtHqLJ7VNkDqvwxVfqYKnlMFd+nisa08nu47Zctso+8 + ubVxfWah56aMiIyQjDSXouSPG1P+ciDJ8mwSezuJGkmippOpB+nUwwzqYSY1u5W6t40a364xkqc/lC8d + yqeHCrmhIn6omBsu4UdKZaOlsrFS7m4ZigndreDHKxFEhqYAbEKEezUiauWIGrwV0mhXgXehAKbuPwvh + w87L55XUqlDmQzH5NEI2XccjsAkh+wHvaVY8AloUs23yuy3sYIW0K0dyO4G+Hcx2eSkGnA1HHcwmXSyn + Pa3u+ViO+1re9UVbJX5W48p1Q3BHJwkEZArc9bce918xj4D5u/9B3J3PGJgNZtTPWmAEFMfXehgDijOI + GfCx7ve2Avq8rXq9rHq8rLq9rLo8re54Wt32sLzlYXnTw/KGu+V1ACzHzfKqm8UVV4tOF4tLLhYXXSzO + O5ufA8txMj/taH4KXAfP0WmSRtYqgzrIdZqw64DotKKgDnEdMoC1VFxngevM052s01zWGbjBK9l2DpFz + HnNBCZ4ug7k0x5z9/OqwmcfZjEPS4GLeNQFE55XCYys2NVnGl5oHbzF0j6XWR1HvJQCa6yPNnQLe8PL8 + yNf1Yz/Xd7w9Vrr66W8Mpz6Mp95NpD6JkTtHmwWkW8YUWqfVrc47tDr3gKFPusQxgYlpYJN2cdmn+dzO + XwkwtkVhXwKXlkAoMG/MkRU/O2CO60sjKpZHXhKC4235gCBhlxEFGJQW8nExZXxONKkLEFeLWKy5X85c + iyKFQvqFo1PKcJEI1aAYHhH7XSCeXyXiuqzwmgpI/yg3f2PUfEuATD9nfxmMCmFXOCTAFN1iim5Lirr0 + inu1SwapsgmqfJYqe4gofUgVz1KFk1T+IJ17w2TbiT9tbf0os8R18+bQjMiUNPcdKetqUt7Yk2R9IlF+ + PVFzOJEaT6bupyENmt1M3d9CTWVT49uokR1ag7mSgTxmoIDtL+QGi7jBYpUJlclGy2Rj5ZgKxHilbLxK + NlEtm6iSTcK2WjZZI5vAQGKyRj6FQGnYLsVkHT9ZB9sF1C6GWpnfA2o9xEypUO6SD1srF/IhDeozhQUI + OVC9fKZBfr9BPtskn22Wz7bK77XKRuqYnmL9W5mSGzHMzQC+y9Wg38F4zMFsysVqytN6nLypwNtizIdg + OeZjRVYPqUFiGAg/gTkD+M9D7DQCRG7EfkMUB/yGKA74jVhxftRyLoss54KzBbGcM07Ick46mJ9GohPf + KI2owa6jCurMDWA913Ww7rDph9iMw+wm4Ai7+Si7+RiSBqXonGC3ktCOSnfExqMuPSLvmac+vzr89ksA + t+UUCx8nrlXqlGjot3lV9p5Xio6tzGy1TCgzj9hh6p9u5BHHOUbrbIym1sZQn8ZSn8RCQnNDNG0fbeAW + a+KbYh6abRlXvCKjYXX+YbAc0/AdtF0k7ZfHxDSxyR189lnS0C9ETdEEVCOAP4OLiyEuoBxS5NAzkMTg + xz8irqq4JkLIRLDo4UkCoohaXifmEqaTy8coMzFI14TyQoviRn8x2xdDXECpboJREQlThYv+TeALri4A + Bb1kBVeXAA4t5Ppvg/pk/AWobHIeZAD0R2EwapkCUA9qQt38lmS+OKLxULbwJlN4iy66o1/Uo108QJWM + USXTVMksAgSoaIYqGKdy+/S3XzfMPvnqlrb3M0vtNm3xT4uOS/XKSt5QlvzOzsTVRxIMLiXo9CRSo0nU + VAo1m0bdz6CmN1OTWdTdbGp4u3b/DklfLtObz/YVcP0F/EAhN4BMiBsqAfjhUh5MCFHOj1bwSIYq5wAl + WpxqMTxGNl7zHwVyQTEkRymFclVCZUU4CDRdr5hpVNxvks20yMab+IFK+nau9Fqq5EYoc8uL73ZSDNiZ + jDpYTrhajXtZ4pdsm6vetm056g2gZ/uOeqM5KMAYRjkrBYNHbaxQQmUA/0kM+1gJDKkYxAx4I5TBGzI+ + heTGEuj2tOzCoFEq7De33C1vulvccLO47mZxzc3iqiuK4qCxKhfzSy7mF53NLzjj4SpQHEez045mpxzM + TjqYnbA3O4VeAUFEJ6JmkQGsuFYGiQ5yHSZpFzNvss4+Nm0/MoP0gwtcR6Q7xHiQ7iijO4sbjyA96urz + EuBzLrwo0Cv4RMl76JAy2iHWwCfdOq3ulcKjrxQcWbm1zTq52jK22Dwy1zwsxyw02ywkyzxsGziQRUyh + VVLFis3Nq3MPIjfa2mYclMXYRUrdMpiIarAcLuMQv+2celsiuO2Lw740zosQcoSjF1WIwmlo+hR+8zzi + CpeDIQnYzoOUAaC8eOQRG1iuCqIyc+mL83IA1YnIqOaaJixs6yeSswDhkMrYeLGKiSaE8YLcACSANC+M + 9HuEz7ssQn3gcgHoM/4ayDDzMvOfh3BtVcOdvwpCK8TzFmWB3ilRK/YcuIKrS3CNKbhBF97UL7ytU9RD + FQ1SxeNUyQwCBKhwhsofp/IGtHJvcjlnrbfsfTuzcsOmLK/0+OgU/4wUu6Kk95qSXt2XaHI2QdodTw0n + UhPJ1EwqNZ1BTW2mxrdQo1nUQI5W7w697ly6O4/tLkD0FnF9RVx/Ed9fzA2UcAOl/FAZPwyUy4CRcn6k + AmRINioyIUQVr6R6ce4ugVqxl8jdqp+A2rlzqD6XWnkVRPLkKojt8Sr7kd+rl99rNLjXbDDZIh+uZ7vL + pDezJNdj2WtB7A13/o6DUb+d2YiTxV13MBvLIW/zYS+LIQDSPkqGfTGQQPd+1awUnxVKfK0IKNThaz3o + p2To35lB+CAqBjD9Pkr6fKyAXkyPt1U3psvL6g7mtpfVLU9LAgrkeFhe97C85m551d3yipvFZTeLTjeL + S64WF10tLrhYnHMxP+tsfsbZ/LQT4qSj+QlHs+OgOx4ootNAR1TTaqIT08TEtSDikevgt1+B6BDXEcd1 + ltCdedEdtQDPXIzned7z4ogN6SVwFrqNPmP8Tjq4ROIYzzrGGPpusowrBYNZnXfolYKjSH0EYDf/8Kpt + e6ySq4yDtvLOsVKbCIlHJh1eCdcT6uG2nJhXf84isC+HsyLE+efFqPzvoopLXE7nHNuIBwg5+C306EX0 + qgAYmlOlhN1xgZvH+QWJi8qtcDqgbFRAaEvU3E9i23OBAsjbBP0SEKJEmLwFiI/+LiDBLYF5mWrjmHzu + 5SW48luiWkOghP1NUGtUydxY5xUeI8OQ9C+EVKWGoFMLIDPG1CFT8pmC69KCG5KCW7oF3ZqF/VTxKFU8 + SRXdowrvUQX3qPwJaseA1vabTPY58y37/7qp9pOMbW7p8WEpAYnJTjuSPqxJ/NPuBMuTcfTVeKovAc0K + mkymptKpiQxqLJMa3koNZFPd2/Xv7GC6drBduVxXHteTz/UUcL2FyIT6irm+Eq6/hB8olQ2W8oNlyIeG + KhDDCBlhRMVwJa9iLj1SyWEg8fIZRUL2oqiduxC18iK4sUp+rILDCRFKPZLdrZbdrZFP1MrRYFmDYrJJ + Mdak6KthbhVIr2ToX46QXPXhr7sY3LEz6rM3H3KxHPawBNcZ9LIY8AYs+wEfyz4ftCU3ezxks4IwqEoA + /YAfYuDfnH4wGxV9mF4fJT2YbkyXN+KOtzX4DVIczE1PxA1Pq+seVtc8sOK4W152t+x0s7zkZnnR1fKC + q8V5V7Aci7MuFmecLU5jTjqB5ZgfdzQ/6mB+Ag9dNdDhIDrV9LyZOo1MbPOc68Tv/HHXUdedhQEeUYxn + TnpU3iNSnzn7EVCTm18b6MOmI+iTxrXQkXVSvzyJQ4LUNoKxDeccImXOMXKXOLlrnMwlhneIZG3DpBvD + JLZREvdN4EZwJZnoBiZlD5N5jN12hgVzEsHM3/2JQG3qFc4Hz/XOPs9tu6DiIpd9EW1fEOXQoeBDKhvb + fpbbDtv5zBUjoNnl6HTSrpif1IelgErEiA6hKe0LIaEpYXRPCB0JCId+X4AdqsMjLv0UOn9LkDjOGdgc + ollcLx+1tgRDnR/N+rUQmsMs8KqXhOBtxOGYvGuSvBu6eXc083upwiGqaJwqmETkTVK549T2IWrbbWn2 + RaPMg69uqvswPdchNTUwNTghyTk7cW15wt9aEywPxXOX4jV74qmhBGo8kRpPpcYyqLubqJEtVH+WRk+O + 7u0cya0dzO1c7lYedzufvV3AdhVy3UVcD1DM9ZZwfaVcXxnXX8YPAOWyOSp4wiCIUaUMAwmSRgmkSioZ + wmL0s1DJ1guhdu7zmXcuN0clQmlvVfx8ZKPVcmCsVnG3TjFer5hoVIw3yQcbuK5y5nqOpDNReimY6fTi + rjkZ3LE1HrAD6bEacrfq97Ls8zTv97IggzVkvAYgE1P6vFeIWEm2yHhUIZB/O/pE9Hor6VHR7YXowiij + OJ5WtzA3PaxuYEBxrrvjQA6akWN5xc3ysptlp6vlJVdLNCnHxeK8i8U5Z4uzzhZnnCzQvBwUyzE/7oA4 + am92AkV04urp8CrsOjVqrjMvroNc50dDO6LozlLGoyY92Hu4rScxp+ZArvOvBroBfU7dhz47XA24MhHV + 0pBSaUCBxD9P4pcr9c+TBhVKQ8ukEZV0ZDUdU08ntjHp+9ktx9jsU2z26RcGCotROypwBnOWzQKbETiv + 4oI6WcKhBcy5EZGn58FtQ/KnWjq3sMXzz2vox+CylKBKCAvKqLiA356mgoy7gV2RxI4lIEf/paiNSC6E + fyEu/pag2NsC3wIWzOX6tVGzQCULxO5ngPRRtuPSQuCoWnMq5iKCwsQ1lrzW5l8IeRLHjivSvGu6+Te1 + 8u9QBf1UwRiaBkTIG6d2DFHbb+ltu2iw5egrm5rXZBTYpqV5p0TGJnlsStxQnPBWY8KKvfGGZ+J0bsVR + /QnUcBI1loIYzaCGMqn+rVR3tvatbZKb25mbO1jgVh57K5+9U8ABXYV8d7GSnhJZL1CG6APK+X4VA0qQ + FQ2iLUpDYrCcx9vfFXIR0D0BboiAo1wIpdIhhqvkI8R7auTIexoMRxoUfdXsrWLJ5UzJxWhJpx/b6Sq/ + amfYZWvab28x4GLZ72HVi57za9HjiaakKOemYHrwPNwerxUYa9iqFEFI/NsgOI2gNYLZiOVmKb8RFAf8 + 5vmKc3q+5RyzR5ZzxN7suDsSnTo6rBK5DhnAEmYlC65DQjuLus4C3Zk/mDVnPNymI4jNRzHHEJnHlYDo + LIrSfn5rRKEmFVtOgKXRGYfotP10SgedtItObAenQdvk3XTKXshnMg4xmceYrSeYrScXAJkLERc4hTkN + oHdozHF2Mc6JmMtnYItevnFGBNEjlTltUzHnTAtQNio0vUhDLxeOJObej0YeQCB+DMG/DXMBsPnwi3P+ + 10O27bxsQaYaCwJyyk/B/PrMa/fHhE8mQu3Qz4XIHErPG1RVIZq1pgZ+7tdvzLxlAci38ILHi/PXP6II + pVoOgcntpHMvS/Ku6OZd18q7TeX3UgXDWIPGqPwxKneM2j5I5XRrb7vMbzlunbHzrfTSdWmb3VJiIhK9 + 0hJscuPfrYn/w644oxMxeldjqe54ajAejYiNJFMjadTgJqo3k+raqnkzW//6Nvp6DnNjB3c9j7uZx97M + 427l88iEChFdRVxXMQ90l8h6Sgl8b6kMAwle5UY8BksSpn8BAxjxLkqU/8oom+MEBgCsbiBAykSFTMxQ + lRwYqVGM1hmM1isG6/muCuZKruR8muR8KHPJi+90VlyzMe62tehztOp1s+r2tOhyt+jysERg7+n2RFNV + VMyZgeAK/xaIew4QrRHMRiw3i/qNoDjgNwsV50Us57AdEZ3YWjqsArsOHsBaNK6jPow1pzts8h4AdIdN + 2cuC5RDmDWYdZDNwdAfpDgFLz5z3qNRHbD8Cavbz8gB9YV4OxxdDrYwAefspfgHqHGfZLWfmQ/KFhAj0 + aKJTSkDCsgROYEhiLp/LQhEy1fggPh1Qq/PXhgicYGBzanWWwYgiTCrmYkj/WpT9JKgGN89w2afF8NvO + ILKX4uxinPv14ADRzDCRO87B/JqQ+ucJjQg15foNmN8B5dJO1aO8fmPAJtVyLsxfKKAChSTP/2JE0U0R + zI6LzI4L9I5L0h2X9Hdc0dlxQzPvDpXfT+UPU/kjVN4ItQMYprZ1a2Z3wi8us4z2v6SVfZKa5ZwcG5jk + Fx9vnx33Xlnc682xxoejpRdiqBtxVF8cNZRIDSdTQ6nUYAbVt5m6s1XjRpbu9Wz66jbm6nbu2g4OTOhG + Lncjn7uZz90q4G4X8reLuNtF/B2MSoYwpTzIUE/ZvG2vGGxIIEOQRgXms2jmywIqVzkZol9Fb7mKCr6v + QtZXKe/HDFYqhqoMhqsVI7UGQ/WK3lr+Rom0M1v/XJzkfBB9yV12yc7g2gbjO3aWPU5WPW5W6BVObhbA + bXeL2x4AWnYkmAHGmiB4g4hFM/8FzO8wgjiNoDWC2SjlZn78Ri2E8+KKo2Y5B23Njrr9gUIrjELLF3cd + HNphYtVER+k6bGI7m7iLBddJ2o1AxtOBdEfdeEQBHmQ8BLH3iNRnnv38ZNjMxWFeGkdUqHI2K58exKIH + CM2hfKP7IpxaDMhXDeQhyNAeEiZWYOsCxEe3gBSeAFQ1iNsi6V/MZsIJtMU5jPgoaUvpcCqvyjrFqJiT + s983yAt/PgtGP399xDPbBJjfBHGLWP5+JcROqXZoIYKh/v4gBp9zZv66gX8ZHEYtkyHbbWfpnPPSnAv6 + ORd1ci5rbL9B7eimdgwitg9SOYPUtn4q6w619bJ+5mlFxp7XUivfTcm2S4z3SQyIjnPIiPmoKPpPDdEW + e6LpU1HUtWjqTgzVH4sGxfqTqJ406vomzQuZ9PlM5uJW+lIW05nNXN7GXs7hrm5nru1gr+Vy14E8pQ/d + LEDcKkTcBpAYcXeKxSgNSQyo0p0S7rehq4TrxqDdUq6rlBfoLgNAxeQ9pXLY9pbL+8sV/ZWKgUr5QLW8 + t1Z+s5K5nEefzZCeiqTP+LLnnPlLNobXNprcsbfocbW85WZ+09X0ppvZTXfzm+4WKtAq65v4cTI3PayX + YE4mficITjOnNSKzEYI3avEbwW/EA1WLKo6a5YDiHMKWc8DWbL+tGfVKapNJbK1JXJ1JXL1JfL1pQqNp + YpNpYrNpUgsiudU0eadpSptpartp6i7TtN2I9D2m6R2IjA6zTXvNNu0z20zYb5Z5AHPQbMshxNbDIo5g + jiKyjinJPq7ihBjzbT+C6W/NSbNtpzCnRZwRcXY+4kMick6rsx04Zbb9JN7Ow5wk1MqrVbgkz+3GTyLn + rJLtKnYA5xYhV4Va/u8Gc8RZESRHLVOMUOA3J3cec9dWhOmvjFmeEvN/JecXxSzvwu+C/KU4/28L6ry5 + eg7CNP+CCcY4/5JRQaei8CpXdIst7maLBtjiIbZoiC0cYvOH2Lxedsc1Puec5dYDf86s/2hzvkN6pn9q + ZHSq9+Yk2+LENc3xrxxKMDqRrDiRanAizfBkhtHpTUZnM43ObUWczzK+sM344jaTzu2ml3eYXsk1vZpn + ei3f7FqB2bUi0+tFZjeKzW6UmN8sRdwqNb9dhrhTbt5VboGosOhGWOItptL8t6PKvKfKAgOJOXqrLVRY + Imqs+mqtBuqsB+qtBxutB1qse1usbtWYXy4yvpBpfC7O5GKI5WXvFbe9Xun2efW27yu3/f5w2+/VO36v + dfm9dtv/9TkC/ijiT3ME/p6Y18k/3lJx01/JDcx1zDU/xFXMFd/Xgcu+r3diLvm8fhFzwfv1896vn/N6 + jXDW67UznojTHq+d8nj1pMerJzxePe7x6jH3V4+6v3rE/dUT/m/+/wEdr0Rzaft5IwAAAABJRU5ErkJg + gg== + + + + 469, 17 + + \ No newline at end of file diff --git a/SourceCode/ProcessItem.cpp b/SourceCode/ProcessItem.cpp index 3e58d3f..7266e43 100644 --- a/SourceCode/ProcessItem.cpp +++ b/SourceCode/ProcessItem.cpp @@ -15,8 +15,8 @@ ProcessItem::ProcessItem(const string settings_value, Windows::Forms::ListView^ this->SubItems->Add(path); } -bool ProcessItem::Write(SettingsProvider* settings_provider) { - return settings_provider->addProcessToProcessList(BasicFunc::StringToString(path)); +void ProcessItem::Write(SettingsProvider* settings_provider) { + settings_provider->addProcessToProcessList(BasicFunc::StringToString(path)); } ProcessItem::~ProcessItem() { diff --git a/SourceCode/ProcessItem.h b/SourceCode/ProcessItem.h index 190c315..3690f94 100644 --- a/SourceCode/ProcessItem.h +++ b/SourceCode/ProcessItem.h @@ -10,7 +10,7 @@ ref class ProcessItem : ListViewItem { public: ~ProcessItem(); ProcessItem(const string settings_value, Windows::Forms::ListView^ list); - bool Write(SettingsProvider* settings_provider); + void Write(SettingsProvider* settings_provider); String^ GetPath(); void addIconToLists(Windows::Forms::ListView^ list); }; \ No newline at end of file diff --git a/SourceCode/ProcessSelectionForm.cpp b/SourceCode/ProcessSelectionForm.cpp index 1a6ce88..aa0d071 100644 --- a/SourceCode/ProcessSelectionForm.cpp +++ b/SourceCode/ProcessSelectionForm.cpp @@ -1,2 +1,39 @@ #include "stdafx.h" -#include "ProcessSelectionForm.h" \ No newline at end of file +#include "ProcessSelectionForm.h" +using namespace StandBye; + +System::Void ProcessSelectionForm::ProcessSelectionForm_Load(System::Object^ sender, System::EventArgs^ e) { + tableLayoutPanel1->Visible = false; + + listViewProc->Font = BasicFunc::getMetroFont(9); + //Prepare ListView + ImageList^ imglistSmall = gcnew ImageList, ^imglistLarge = gcnew ImageList; + imglistSmall->ImageSize = Drawing::Size(24, 24); + imglistLarge->ImageSize = Drawing::Size(50, 50); + listViewProc->SmallImageList = imglistSmall; + listViewProc->LargeImageList = imglistLarge; +} + +System::Void ProcessSelectionForm::metroButtonOK_Click(System::Object^ sender, System::EventArgs^ e) { + if (listViewProc->SelectedItems->Count > 0) { + ProcessItem^ p = (ProcessItem^)listViewProc->SelectedItems[0]; + selectedProcessPath = p->GetPath(); + this->DialogResult = Windows::Forms::DialogResult::OK; + } + else { + this->DialogResult = Windows::Forms::DialogResult::Cancel; + } + this->Close(); +} +System::Void ProcessSelectionForm::metroButtonCancel_Click(System::Object^ sender, System::EventArgs^ e) { + this->DialogResult = Windows::Forms::DialogResult::Cancel; + this->Close(); +} +System::Void ProcessSelectionForm::ProcessSelectioNForm_OnShown(System::Object ^sender, System::EventArgs ^e) { + for each(std::string path in SystemAccess::GetRunningProccesses()) { + listViewProc->Items->Add(gcnew ProcessItem(path, listViewProc)); + Application::DoEvents(); + } + + tableLayoutPanel1->Visible = true; +} \ No newline at end of file diff --git a/SourceCode/ProcessSelectionForm.h b/SourceCode/ProcessSelectionForm.h index 6020874..930c518 100644 --- a/SourceCode/ProcessSelectionForm.h +++ b/SourceCode/ProcessSelectionForm.h @@ -3,7 +3,7 @@ #include "SystemAccess.h" #include "ProcessItem.h" -namespace SmartLogout { +namespace StandBye { using namespace System; using namespace System::ComponentModel; using namespace System::Collections; @@ -187,41 +187,10 @@ namespace SmartLogout { this->ResumeLayout(false); } #pragma endregion - private: System::Void ProcessSelectionForm_Load(System::Object^ sender, System::EventArgs^ e) { - tableLayoutPanel1->Visible = false; - - listViewProc->Font = BasicFunc::getMetroFont(9); - //Prepare ListView - ImageList^ imglistSmall = gcnew ImageList, ^imglistLarge = gcnew ImageList; - imglistSmall->ImageSize = Drawing::Size(24, 24); - imglistLarge->ImageSize = Drawing::Size(50, 50); - listViewProc->SmallImageList = imglistSmall; - listViewProc->LargeImageList = imglistLarge; - } - - private: System::Void metroButtonOK_Click(System::Object^ sender, System::EventArgs^ e) { - if (listViewProc->SelectedItems->Count > 0) { - ProcessItem^ p = (ProcessItem^)listViewProc->SelectedItems[0]; - selectedProcessPath = p->GetPath(); - this->DialogResult = Windows::Forms::DialogResult::OK; - } - else { - this->DialogResult = Windows::Forms::DialogResult::Cancel; - } - this->Close(); - } - private: System::Void metroButtonCancel_Click(System::Object^ sender, System::EventArgs^ e) { - this->DialogResult = Windows::Forms::DialogResult::Cancel; - this->Close(); - } - - private: System::Void ProcessSelectioNForm_OnShown(System::Object ^sender, System::EventArgs ^e) { - for each(std::string path in SystemAccess::GetRunningProccesses()) { - listViewProc->Items->Add(gcnew ProcessItem(path, listViewProc)); - Application::DoEvents(); - } - - tableLayoutPanel1->Visible = true; - } + private: + System::Void ProcessSelectionForm_Load(System::Object^ sender, System::EventArgs^ e); + System::Void ProcessSelectioNForm_OnShown(System::Object ^sender, System::EventArgs ^e); + System::Void metroButtonOK_Click(System::Object^ sender, System::EventArgs^ e); + System::Void metroButtonCancel_Click(System::Object^ sender, System::EventArgs^ e); }; } diff --git a/SourceCode/ProcessSelectionForm.resx b/SourceCode/ProcessSelectionForm.resx new file mode 100644 index 0000000..935eedf --- /dev/null +++ b/SourceCode/ProcessSelectionForm.resx @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + 17, 17 + + \ No newline at end of file diff --git a/SourceCode/Setting.h b/SourceCode/Setting.h index cc43eb0..159bb7d 100644 --- a/SourceCode/Setting.h +++ b/SourceCode/Setting.h @@ -14,10 +14,9 @@ enum class SettingName { class Setting { private: const vector NAME_STRINGS = { "MAX_CPU", "MAX_HDD", "MAX_NET", "MAX_RAM", "WAIT_TIME", "PROC_EXCP", "NET_ADAPT", "USE_CPU", "USE_HDD", "USE_NET", "USE_RAM" }; - + string ConvertSettingNameToString(SettingName n); vector value; SettingName name; - string ConvertSettingNameToString(SettingName n); SettingName ConvertStringToSettingName(string name); public: diff --git a/SourceCode/SettingsProvider.cpp b/SourceCode/SettingsProvider.cpp index 6effddc..99608c2 100644 --- a/SourceCode/SettingsProvider.cpp +++ b/SourceCode/SettingsProvider.cpp @@ -18,6 +18,7 @@ SettingsProvider::SettingsProvider() { }; SettingsProvider::~SettingsProvider() { + saveSettingsToFile(); for each(Setting* s in SettingsList) { delete s; } @@ -25,7 +26,14 @@ SettingsProvider::~SettingsProvider() { } string SettingsProvider::getRawSetting(SettingName name) { - return SettingsProvider::getSettingbyName(name)->GetValue().at(0); + try { + return SettingsProvider::getSettingbyName(name)->GetValue().at(0); + } + catch (Exception^ e) { + DEBUG("Could not get Raw Setting!"); + DEBUG(e->Data + "\n" + e->InnerException + "\n" + e->Message); + return ""; + } } int SettingsProvider::getThreshold(SettingName name) { @@ -62,33 +70,29 @@ bool SettingsProvider::setActiveState(SettingName name, bool status) { return writeSettingsFile(); } -bool SettingsProvider::setSetting(SettingName name, const string value) { +void SettingsProvider::setSetting(SettingName name, const string value) { getSettingbyName(name)->ChangeValue(value); - return writeSettingsFile(); }; -bool SettingsProvider::setSetting(SettingName name, const int value) { - return SettingsProvider::setSetting(name, std::to_string(value)); +void SettingsProvider::setSetting(SettingName name, const int value) { + SettingsProvider::setSetting(name, std::to_string(value)); }; vector SettingsProvider::getProcessList() { return SettingsProvider::getSettingbyName(SettingName::PROC_EXCP)->GetValue(); }; -bool SettingsProvider::addProcessToProcessList(const string process) { +void SettingsProvider::addProcessToProcessList(const string process) { if (!getSettingbyName(SettingName::PROC_EXCP)->Contains(process)) { getSettingbyName(SettingName::PROC_EXCP)->AddValue(process); - return writeSettingsFile(); } else { DEBUG("Process already added"); - return true; } }; -bool SettingsProvider::removeProcessFromProcessList(const string process) { +void SettingsProvider::removeProcessFromProcessList(const string process) { getSettingbyName(SettingName::PROC_EXCP)->RemoveValue(process); - return writeSettingsFile(); }; bool SettingsProvider::reset() { @@ -104,9 +108,12 @@ bool SettingsProvider::reset() { SettingsList.push_back(new Setting(SettingName::MAX_RAM, MAX_RAM_DEFAULT)); SettingsList.push_back(new Setting(SettingName::WAIT_TIME, WAIT_TIME_DEFAULT)); SettingsList.push_back(new Setting(SettingName::PROC_EXCP, PROC_EXCP_DEFAULT)); + return writeSettingsFile(); +} - //Returns true if succeeded - return SettingsProvider::writeSettingsFile(); +bool SettingsProvider::saveSettingsToFile() +{ + return writeSettingsFile(); }; bool SettingsProvider::repairFile() { @@ -118,8 +125,8 @@ bool SettingsProvider::repairFile() { } else { //Folder does not exist --> Creating Folder - string LogoutFolderPath = SettingsProvider::getAppDataFolderPath(); - _mkdir(LogoutFolderPath.c_str()); + string StandByeFolderPath = SettingsProvider::getStandByeFolderPath(); + _mkdir(StandByeFolderPath.c_str()); return SettingsProvider::reset(); } return false; @@ -199,16 +206,16 @@ string SettingsProvider::getSettingsFilePath() { String^ a = Environment::GetFolderPath(Environment::SpecialFolder::ApplicationData); //Adds the Path to the Settings file - a = Path::Combine(a, "SmartLogout"); + a = Path::Combine(a, "StandBye"); a = Path::Combine(a, "Settings.ini"); return BasicFunc::StringToString(a); }; -string SettingsProvider::getAppDataFolderPath() { +string SettingsProvider::getStandByeFolderPath() { //Gets the AppData Path String^ a = Environment::GetFolderPath(Environment::SpecialFolder::ApplicationData); - a = Path::Combine(a, "SmartLogout"); + a = Path::Combine(a, "StandBye"); return BasicFunc::StringToString(a); }; @@ -223,4 +230,8 @@ Setting* SettingsProvider::getSettingbyName(SettingName name) { if (repairFile()) { return SettingsProvider::getSettingbyName(name); } + + DEBUG("Invalid settingName entered!"); + DEBUG("Could not get Setting!"); + return nullptr; }; \ No newline at end of file diff --git a/SourceCode/SettingsProvider.h b/SourceCode/SettingsProvider.h index f9ec811..a08ce6b 100644 --- a/SourceCode/SettingsProvider.h +++ b/SourceCode/SettingsProvider.h @@ -33,7 +33,7 @@ class SettingsProvider { SettingsProvider(); ~SettingsProvider(); - ///Returns the value of a specified Setting in percent or kbit/s + ///Returns the value of a specified Setting in percent or kBit/s ///use namespace SettingName:: to get the Names! /// int getThreshold(SettingName name); @@ -53,28 +53,31 @@ class SettingsProvider { /// bool setActiveState(SettingName name, const bool status); - ///Sets the value for a specified Setting in percent or kbit/s + ///Sets the value for a specified Setting in percent or kBit/s ///The maximum value - bool setSetting(SettingName name, const int limit); + void setSetting(SettingName name, const int limit); ///Sets the value for a specified Setting ///The maximum value - bool setSetting(SettingName name, const string value); + void setSetting(SettingName name, const string value); ///Returns the set List of blocked Processes vector getProcessList(); ///Adds one Process to the blocked process list ///path of the process - bool addProcessToProcessList(const string process); + void addProcessToProcessList(const string process); ///Adds one Process to the blocked process list. ///path of the process - bool removeProcessFromProcessList(const string process); + void removeProcessFromProcessList(const string process); ///Resets all settings to factory settings bool reset(); + ///Saves settings to the save file + bool saveSettingsToFile(); + private: bool writeSettingsFile(); @@ -87,5 +90,5 @@ class SettingsProvider { string getSettingsFilePath(); - string getAppDataFolderPath(); + string getStandByeFolderPath(); }; diff --git a/SourceCode/Systemaccess.cpp b/SourceCode/Systemaccess.cpp index 1b5b498..63d9571 100644 --- a/SourceCode/Systemaccess.cpp +++ b/SourceCode/Systemaccess.cpp @@ -62,12 +62,12 @@ float SystemAccess::GetMetric(SystemMetric s) { case SystemMetric::HDD: return getHddUsage(); } - return 0.0f; } catch (Exception^ ex) { DEBUG("Could not get Metric!"); DEBUG("Error Details: " + ex->Message + "\n" + ex->Data + "\n" + ex->Source); } + return 0.0f; } void SystemAccess::StartESM() diff --git a/SourceCode/TimeoutWindow.cpp b/SourceCode/TimeoutWindow.cpp new file mode 100644 index 0000000..1b2b9e4 --- /dev/null +++ b/SourceCode/TimeoutWindow.cpp @@ -0,0 +1,55 @@ +#pragma once +#include "stdafx.h" +#include "TimeoutWindow.h" +using namespace StandBye; + +System::Void TimeoutWindow::TimeoutWindow_Load(System::Object^, System::EventArgs^) { + this->ControlBox = true; + this->MaximizeBox = false; + this->MinimizeBox = false; + + //Gets the Working Space + Drawing::Rectangle WorkArea = Screen::PrimaryScreen->WorkingArea; + this->Location = Point(WorkArea.Width - this->Size.Width, WorkArea.Height - this->Size.Height); + this->Update(); + + //Starts Time + timer = gcnew System::Windows::Forms::Timer; + timer->Interval = 10; + counter = 0; + timer->Tick += gcnew System::EventHandler(this, &TimeoutWindow::RefreshUI); + timer->Start(); + + //Plays sound + System::Media::SystemSounds::Asterisk->Play(); +} + +System::Void TimeoutWindow::RefreshUI(System::Object^, System::EventArgs^) { + int past_millis = Environment::TickCount - startTime; + + //If user shows activity the standby can be canceled + if (SystemAccess::GetLastInputTime() < settings_provider->getThreshold(SettingName::WAIT_TIME)) { + this->DialogResult = Windows::Forms::DialogResult::Cancel; + this->Close(); + } + + if (past_millis < delay) { + metroButtonCancel->Text = "Cancel [" + Math::Truncate((delay - past_millis) / 1000).ToString() + "]"; + this->metroLabelTime->Text = String::Format("{0:0.00}s", (double)(delay - past_millis) / 1000); + metroProgressBar1->Value = 100 - Math::Truncate(((double)past_millis / (double)delay) * 100); + counter++; + this->BringToFront(); + } + else { + this->DialogResult = Windows::Forms::DialogResult::OK; + this->Close(); + } +} +System::Void TimeoutWindow::metroButtonOK_Click(System::Object^ sender, System::EventArgs^ e) { + this->DialogResult = Windows::Forms::DialogResult::OK; + this->Close(); +} +System::Void TimeoutWindow::metroButtonCancel_Click(System::Object^ sender, System::EventArgs^ e) { + this->DialogResult = Windows::Forms::DialogResult::Cancel; + this->Close(); +} \ No newline at end of file diff --git a/SourceCode/TimeoutWindow.h b/SourceCode/TimeoutWindow.h index 15e0da5..7ef7927 100644 --- a/SourceCode/TimeoutWindow.h +++ b/SourceCode/TimeoutWindow.h @@ -1,6 +1,8 @@ #pragma once #include "stdafx.h" #include +#include "SettingsProvider.h" +#include "SystemAccess.h" using namespace System; using namespace System::ComponentModel; @@ -13,12 +15,13 @@ using namespace System::Threading; /// /// Summary for TimeoutWindow /// -namespace SmartLogout { +namespace StandBye { public ref class TimeoutWindow : public MetroFramework::Forms::MetroForm { int delay; // in milliseconds double startTime; //in milliseconds System::Windows::Forms::Timer^ timer; + SettingsProvider* settings_provider; int counter; private: MetroFramework::Controls::MetroLabel^ metroLabel1; private: MetroFramework::Controls::MetroLabel^ metroLabelTime; @@ -26,12 +29,13 @@ namespace SmartLogout { private: MetroFramework::Controls::MetroButton^ metroButtonCancel; private: MetroFramework::Controls::MetroButton^ metroButtonOK; public: - TimeoutWindow(const int duration) { + TimeoutWindow(const int duration, SettingsProvider* prov) { InitializeComponent(); this->DoubleBuffered = true; delay = duration * 1000; startTime = Environment::TickCount; RefreshUI(gcnew Object, gcnew EventArgs); + settings_provider = prov; } protected: @@ -147,48 +151,10 @@ namespace SmartLogout { this->PerformLayout(); } #pragma endregion - private: System::Void TimeoutWindow_Load(System::Object^, System::EventArgs^) { - this->ControlBox = true; - this->MaximizeBox = false; - this->MinimizeBox = false; - - //Gets the Working Space - Drawing::Rectangle WorkArea = Screen::PrimaryScreen->WorkingArea; - this->Location = Point(WorkArea.Width - this->Size.Width, WorkArea.Height - this->Size.Height); - this->Update(); - - //Starts Time - timer = gcnew System::Windows::Forms::Timer; - timer->Interval = 10; - counter = 0; - timer->Tick += gcnew System::EventHandler(this, &TimeoutWindow::RefreshUI); - timer->Start(); - - System::Media::SystemSounds::Asterisk->Play(); - } - - private: System::Void RefreshUI(System::Object^, System::EventArgs^) { - int past_millis = Environment::TickCount - startTime; - - if (past_millis < delay) { - metroButtonCancel->Text = "Cancel [" + Math::Truncate((delay - past_millis) / 1000).ToString() + "]"; - this->metroLabelTime->Text = String::Format("{0:0.00}s", (double)(delay - past_millis) / 1000); - metroProgressBar1->Value = 100 - Math::Truncate(((double)past_millis / (double)delay) * 100); - counter++; - this->BringToFront(); - } - else { - this->DialogResult = Windows::Forms::DialogResult::OK; - this->Close(); - } - } - private: System::Void metroButtonOK_Click(System::Object^ sender, System::EventArgs^ e) { - this->DialogResult = Windows::Forms::DialogResult::OK; - this->Close(); - } - private: System::Void metroButtonCancel_Click(System::Object^ sender, System::EventArgs^ e) { - this->DialogResult = Windows::Forms::DialogResult::Cancel; - this->Close(); - } + private: + System::Void TimeoutWindow_Load(System::Object^, System::EventArgs^); + System::Void RefreshUI(System::Object^, System::EventArgs^); + System::Void metroButtonOK_Click(System::Object^ sender, System::EventArgs^ e); + System::Void metroButtonCancel_Click(System::Object^ sender, System::EventArgs^ e); }; -} \ No newline at end of file +} diff --git a/SourceCode/TimeoutWindow.resx b/SourceCode/TimeoutWindow.resx new file mode 100644 index 0000000..9d42eb3 --- /dev/null +++ b/SourceCode/TimeoutWindow.resx @@ -0,0 +1,2119 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAAIGNIUk0AAHolAACAgwAA+f8AAIDpAAB1 + MAAA6mAAADqYAAAXb5JfxUYAAAAJcEhZcwAACxMAAAsTAQCanBgAAP+WSURBVHhe7P15fJzneR6MvvPO + joWUKMmLbEuWLNmyZcmbvMT7LlnetEsU9x0AwX3fsO+z7zNYJDk+n1r3uFWOzqeUCVsmdeqkbdqTr+lp + k5N+bdO0SdrEm0RxAQnwPtd1vzPgEHosiSIIDID3j+s3wAMSmHne57nv694tEXHhwoULFy5cLDIYF124 + cOHChQsXCxvGRRcuXLhw4cLFwoZx0YULFy5cuHCxsGFcdOHChQsXLlwsbBgXXbhw4cKFCxcLG8ZFFy5c + uHDhwsXChnHRhQsXLly4cLGwYVx04cKFCxcuXCxsGBdduHDhwoULFwsbxkUXLly4cOHCxcKGcdGFCxcu + XLhwsbBhXHThwoULFy5cLGwYF124cOHChQsXCxvGRRcuXLhw4cLFwoZx0YULFy5cuHCxsGFcdOHChQsX + LlwsbBgXXbhw4cKFCxcLG8ZFFy5cuHDhwsXChnHRhQsXLly4cLGwYVx04cKFCxcuXCxsGBdduHAxv2Df + 8b6A56Mfeqf1uU/cbX3jNz5rffeL91sPfeVB6/HvPmo98b1Hrae+/4T19MPL7ZWPrvSufnyNf+2T6wPr + ntpE8Guu8Wf8N/pv+X/4f/k7+Lv4O/G7+Tf4t0zvwYULF/MLxkUXLlzMLXz3fOBt3s999G7f977/YOCJ + xx8NrF+zyb+z6Yjn2O6kNXT4h1au6yVrtP+kt9h7nLDzfS8B4sn1Av1iZfsUdn5gClbhzeGy/1P+Pfyd + /N38G/xblb/L96DvBe+J743vke+V75nv3fMb995l333nMtNndOHCxdzCuOjChYtrC++H71gWhoK3n3r8 + CXvz6lb/kR0xb+zYj6xS7wlrdOCkNTx4wipSIXeJVewRz/CAwioOipUfAiLiKUTxCmVfQc75Gdd9hZj4 + i3Hx5gYUb5YEVP5d5f/xd/B3OX8Lf1f/xqW/6axHnJ/hvV16nz34fXzvWOdnGY2c9JA04DP6Dm8fsjes + bLIef+jR0Gc/chf3wrRHLly4uLYwLrpw4WJmYN39sXfbX/zSx+wVT670Hdo55It3/ggKFtb6wEueDKxr + gxJeXABRAOkhOfClu17wd+4vBDevbQ3c/62v2J/4zJ2mPXXhwsXMwLjowoWLK0Pw3bd5fZ/65O32w9/7 + rnf75oP+nkPD/lTfC57csZesQgesYCi6ESi80YjYwzEJFGMSzscMCnFxIZgbVE+DehSKwDBI0XA3ftYu + Vubwi1Zx8LgVOfK8ta+5x1rx2Ervlz/3Md/77gybnoELFy6uDMZFFy5cvD6sL/7Gvf7Hv/OoFT36vDfV + +YKd633JykLJU5ENR6HoodyHI+IdHRIvX+mGT0PRpfFzvlLpFQYvU4aLEZ5SVDwFkKLsoPjTgxLIDEmg + MCTBYWAkIlYW/wY/9+Uj4s/0SzDTJ/WZ/heD8Y4feXoPjoUf//aj/i9+5l7TM3LhwsXrw7jowoWLy+H9 + yufv8zav3O3t2z9GZe8pRI97CnFV5nZ+SHzFKJTUoPgK/eIv9uG1V+xcl6PoYeX6C1EJFmISKsYlMBwX + G6TAgpIzKcXFBRAivFLBh3LYoywUPYiAle4VK9UtVhF7OEKvAL7HnmpexAjIVQn7l+4TP4iWvzR4wp/t + ejHYf/C54K5NbYFvP/B17+0faDA9RxcuXFyCcdGFi8UM70fveaf19LeWWwdW94fTkRf86aEXPLnBlyxY + pproVuyH0u8Tb7ZXPCOdUEZAsRvr+J4/Z6JcpgwmwVFZDePrEpQXyIFV0Ex6EAQqtWpluPjgdaoKsDf0 + nGCNryXsFckRgL0Xb2ZIvSd2th//vkd8pV7xD+N1GPuexb9Vzwp+B8kWCAKfjz/T+2Iw0f1j68Dafuvp + by/3fuwj7zY9axcuFjOMiy5cLCZ4b31fwP+db37du2dDp2do/w+tbOeLam1SSdGdD9glWPmw8ANZWJ2Z + bvHlesSfh8IvQLlnoLQAL772l2JQUk4WfqCUkCWpQakHEfDlHMXvZMfTQ9AvgWnKcDHCD4XtBXGyoNSt + EkMo3UqswlDq3Ds/9tHOggAQeQcMCyjwtX90UMMFoTzzCfp1X6d+P8MxOfx7Erd870usQPDva+7xf/fB + +3233uV6CFwsehgXXbhY6PB+9BO3Wk9891Fr8NAPPcm2H9uFHrFHYL1D0VtFKPWio/it4XagC+s9auE7 + yoX/hj+Dks9lxJdJiScdEw+UlFMOV1b0RSaz0SKl9U/LFlAPANZy+FuZsqJaxKiUKCo5quyR7hP2jHtJ + UqD7iL3Hc7GL2Od8Ev8vDXKQxTPgfrL3gQNn76tQiuMVADHzjMaBqHoI7GTHjz2DR35orX98k/XZz91t + OiMuXCx0GBdduFiICH37K1/3Hdo8ZGWOvQjlcJxxe81ApzLSmntHiXiz3bD0e2BRwhLNQslnoHjSVNiD + aoFq0hpfocTtQicsWJCDPOP9XVjvE38pojkBGgogWcDvv1RbP6QeAov5A6WU87cXMajQ6TnxYW+mkC8r + /0ryH/saYI1768l3O3utPQY6JQgy4M/GxZdloiV7I5C84esCvS4D+DmeI8MGSiBAJkogBcP9TpgAz5y/ + n2fByhx90cLZ8H77S183nR0XLhYijIsuXCwUWN//3oOBPds667K9L1rDQycsxpupvEtQwqr0XSxuOGSN + VQjseOgdHjwRLvQf9x7dE7PWPL3edKZcuFgoMC66cDGf4fnO/V+32lsz1mjXyesT3T9uyPdTsKvApxVe + B6uP9edWmvF4k1JwsWiA80APRLAYmQrV2KUBaQAZuCHa/bz1g/6fWm2tSd93Hvi67/Y73BkILhYUjIsu + XMw3WN/78v32saakXeg8bpUGT9Cy8xfTYj9DoU6rv1stvGAGBCAzKH66mRlrNikFF4sGzPkgKWS4wCEA + XGcyYq8mFlo5lmzGxT+GV848wBmznrz/CfvOW91mRC7mPYyLLlzMBwQf+PoXfP2HngulOl8IFvs5EEdj + +P7CkMaNNQaf7YUQZ0LYoASGo9pkxqMNe4BRlwAsdrAfgw46yvSJrzgk9lhMuzVWwkNarpntF1+WRAHn + qhST8GhUwpnuF+3ePWP2d9ycARfzF8ZFFy5qFdZddzZYzSt212d7XqzPDr1opSComZE/EofAhsKHsvcW + 6Mal0u9Wdz+Vvgp3WHtM/iI0Q7xS6udi8aLEvg6DmjRIT4BOUsS6jTPFhk1s48zEQ/5cBx/lQA6YOMhk + w/wAiGbPcV+m/UXvjvVHrHs/+k7TmXXholZhXHThotbg+d4D93sHDjxnj0V+ooKbJV9jfbK0FBU/671Z + RjYCa45lfLT480MSGE1qAxkV6lzLOeVkJAMh/JyhgMuUgYtFCXoB2K5ZRx8nu8WT7nXOTWZAQmxVzPOj + swqo+OkV4PqQNFQ6OWYHnP8/2nfS6t0xZj/+7Uft997uNZ1jFy5qCcZFFy5qAeG77nmbtXdtZx0sLP/o + 4EkrBeWdjUj9SEoFcB2bvuTaofghsEdg2Wd7xJfuk3AOyp+ldlTwjPXDwlPrv9xpjgKcLt0Qfle1InCx + +KDZ/yw5LCcBsoQzCKVPkkjFH8rFxJPqFy/OHptAsTR0qqSw2CXLijiL5fbF3ixJAkgE2xanj73g79kz + XPfFz7tzClzULIyLLlzMJYJPfu+Juv4Dz3mGe0/YxYRYEMCqtEcgqJnMl+l0WshC4IYLTgxX3fkjUPSA + 49rHv2OMn1Yarf9Mt/4fx/0P4c8WvQwdGJSCi8UDzh5gbN9p7sRXrNPaV4vfyQHQZNFRvIJoWvlOh2iC + QJKM6jnLsUkUm0ixtDQqds7pSaDtiUs9J5Z07Stc/8h3vms66y5czCWMiy5czDas2+8IWC1P77aGu09A + kZ8MwKKqz7oK2sX8RmMeBJbJqGODP7GK3ce9W9fu89z9oWWmO+DCxWzDuOjCxWzBf+9H32ntXH3E90zX + TxoL/VI/1Akrq0esZ2FBuWV6LuY72G1wJCqh7KAEkt3iHxuQwLPdP/XsXttm/cZ9d5nuhAsXswXjogsX + 1xrWNz/3WburuaAtefPlunwmWXFyHgQnJ+V5smz5ahCqLlzMF6Q7pDJnwmIIq8DBRhwc1c+1k4H+Pc8F + v3O/W0roYk5gXHTh4loh9NgDD3kie5+3Cr3HmWBlPeP02m9MRiAYKSDZc58NewDG601C1YWLeYLAiDPC + 2Mp2C8sGA5khWZKISDANostxxymWGvYftyMHng8+/sCjpjvjwsW1gnHRhYuZhHXnLeHwpidag4WO49bo + 4ElPakD8UPhWPgYByMQ8WEds1cvSvSLWxiAU2YzF9QC4mOewM7D+S1D8UPZsP81+AtYYzjaIgZXq0n4D + oVzUmQw5OnCSdySw/vFNpnvkwsVMw7jowsVMwbP+yU11Q0d+6B2JQuANiAeWDyfAMb7PeGiI2fxanw8r + SWP+QBrfs+SKWdUGoerCxXxBHRQ8PVp6pvO9ThVKvlvDAuEiyO9wm1jFDuffp4bEygyJbzRxsi7a8by/ + ed1u051y4WKmYFx04eJqYT367Yd82WMvWsORE2yU4k9DsBViOq5VrSAq/EKHhFNloThMV2mfhLL92nyF + 7XxZ0z9doLpwMa8Apc9ulEtx9n3aXrhXAuleaUj3Sx37BpQ6xDvCNsQDTvfBUkLvipXBz0ZjJ0PFzuOe + px56wnTHXLi4WhgXXbh4q7CefOAJf/LIj33PJn5qscY6CUufiX207vNdavn4YOVzDnuokNIcAJICJgGy + WQ+JgFYBaF3/NGHqwsU8A/tU6Ncgt0x2ZQdKnndLzzoUfi4ldobjiPu15bBV6MI67kjJyYOhR8AaiZwM + pNpe8K56eI3pzrlw8VZhXHTh4kphff/+B8MDx57zjyROcsSquvArrVJduHDxlhBk90o2Jcr1iz2W+Ekw + 3vEj64nvusmCLmYExkUXLt4srOUPLL++d/fY9cMDJyxO2csOqHU/1Z3PINRcuHDxJpHt0G6EwZEEvgeh + zvVJ43D/iaV9e8asFd9ZabqTLly8WRgXXbh4I1hf+Py9du+BMb/O3oegKg6oa5NlTmx6wjpnx5U/TaC5 + cOHizWPEmW7pz5RHEnPq5SiTaPGzfP9L3v5Dz1lf+fJ9pjvqwsUbwbjowsWvg33vPW+zDjUNWaP9J71Q + +A2ZhHjinMM/qANUrHSvDkUJsKmPTumbJtBcuHBxReBd4p3y5HC3OHWQCYKxHqnH3WPioLYYbmtNej5y + jzuO2MUVwbjowoUJ1sanmihsmLXvS/Y6o1LjvRIeS4j3GRVEarFoVn+aiX5uGZ8LF1cDfwHWvlbD9MLy + x73i5MtnoxJgrwzcQW8O/4aEIM9ug30n7aYVO0x314ULE4yLLlxUgx3K/JljL3JIj5Xsl3A6ov3NOY/f + z6z9bKdYqWNi5TqxPqCNT3QMbyUD2oULF28JHsb+WS6Y7dXKAF8JRAD3zMp1gXD3iPVMvzbSqsuREIAo + DA+cYOmg99FvPmS6yy5cVMO46MIFYX34nrdZiQM/tljPn4cAynNWekLsYVgl+X7tchbkDPVUj9TDEgkz + +z/RoQmAPsYpOYbXINRcuHDxJpHhAKG4ltLayS4JZ/oU/kyvhEeHxAtioOWz+SG9m7yj2kGz2HHcSh18 + wf+JT9xqutsuXBDGRReLG9YH71pqtazeHXg28tNAJiYNsC7q8jEnsY/1/EUodhAAbeFbHHLmoEMA0eqv + kAMr3SV1/PcmoebChYs3hVB+QDzZHr1res+yXMddG2Ei4JASA6fixgkTME8gnItKXSYq/nRUPM8M/sRq + XrXb+sAHGkx33cXihnHRxeJF4DsPft0fb/uR7wdx7cxnEkouXLiYJ8j3ivXskHhjx34U/P53HjTdeReL + F8ZFF4sPde//4FJrz/pO6zf7/pVa+Al2JHOT+Fy4mN8YcpIE6bl7tuen/oNb+hs+9OFlJhngYvHBuOhi + ccG3/JHlVqn9hE1LgQlHdDEOR8RTcAmACxfzGb4sy3EHtUxX7/YzWC+1nbBWPOI2EXLhEoDFDOuu9zZY + 0UPP++LtPwqle8XOQzjA6mes0WYznwwz+S8XKC5cuJg/0NydZL94SzHxjLGioFeTdv2Z7het6MHn6z5z + 750m2eBiccC46GLhw9rwVNOSkaGT7OAXeCbBEaROgxEQgQAn8XFyGUv8DELFhQsX8wQj/RJ6Nq53WsN6 + uUEJjCa1jNfD6oFU2wt20yq3d8AihXHRxcKF79Mfv9POHXnJUxw8bhXi4k/Dys/2ackeBUJwhJP5+sXD + UiLWHJuEigsXLuYHSj3aM4AJvUrqWbmTxb1O9UgwyZ+nxBodOhnKt70U+OIn7zXJDBcLF8ZFFwsT1obH + m6zhrhPeWIdTUpTm4B4IBE7tKw1oVzGWHVFYsJyIRMAoVFy4cDEvEGbr4HSXjuBuYHiPI4Z515+J6whi + XyGmoT5PuhvkoO14oGm56w1YRDAuulhYsD5zz51W77YxWADH7VREvKW4o/iLPfpK96DG/0sOGdD6fgqQ + MTcJ0IWL+QzeZd5xp1cAUBnRzSZd7C2Q75IA1rx55v3g7g8PnPD0b3/O+vRdbm7AIoBx0cXCgfX0w8uX + 9B0eWzICSyDXA0U/JH5m9+eo7F0FP9+hlRqjcQlm8P3YUfXcWOmEHMh9V46kH5Q9mUdkZ+ZhacXrluyj + si77iKzE61PZx+TJ3GPynexG+XZ2s9wPfDW3RT4PfCbXJJ/IN8nHCk3y4ewOuaPUJrdkDslNw0fk/bAU + 3148Ku8sHWQimfE9uZhHoAzQEd6DjhEAGbEE52nJUMcPrTUr1ptkiouFA+Oii4UBa/+GnuuGjv1wqXbt + Yw9xZ5qYtgtN4Xt6AUxCwcW8QTh7TMKpbvGkcxDkKR3J/IXiNnklFRBJ4BgkvYCtmEh55ULaL+fws7Np + IBUSieHfVBD3yMWERyYTtlxI+hQSt+RiCv8/auH/8N955EwSX6cs+QeJe4zvycU8QgmyINMvwWJEAkoG + urR5UCMMhKWRzuetfet6TLLFxcKAcdHF/Ib3S5/4mJU+/EJ9PvFSKN8ndqkPTJ8YdAhAbkDjf3726zcJ + BRfzBvZwt/iLbRIsxbVlrDXcIfsLD4lQWSf8MglFTVyE0ha8Cl/1a49iHGsVXFCABEDhV6AEAr9HYngt + //+LIAgkE0+n1xnfk4t5BIb70r0qE5QAsGFQoUcHejFnoK6QOG5ljrwY+Oqn7jPJGhfzG8ZFF/MXVvNT + u2HtH2/M4DJzYh8ZPRS/9SyUPcMAWRCCTJ8mBenYXpNQcDFv4E/iuY72STCf1PAOBfgfRj4mF0EAzkXq + ZAKvxEUob2KKABAJKPw0lDkwmYGCT1PJl6GeA6+cBwk4nwBZSIT0317IOv/3l+mg3JzrML4nF/MLdP2z + SRCTgGkgWCP0DPaKlYHsgMygLPEO95+wti7fZ5I5LuYvjIsu5h+su25rsHq2DVujkZP1+QwUARRDplvs + YlSnhenEMJb7pbtgMQ6IbwTf52ExGgSCi/mDxiQE9jMxCG92bozI9YU2mRwKy2QOx4IhAFjrU4hDkRO6 + 7oBEgagQBUXmEugFmGB4IFknZ1NhOYs1/r9/m3qnk0dieE8u5hEgA7wwENQgYDMwVgYUh8RbGFRQhlCW + 1BfTOGfRn6iM+cB73cFCCwTGRRfzC9bn77vbSrb92IYSCNHyB3snq68vMNsfCiINS798ue18n3PhK41A + TELBxfwBLH4+SzvbLuFCp9yfX6VW+s/y9XIqUy8XYcXTuicmyjif9ch4ziPn84ztw9KPMdbvU9c+rX7+ + H4KeAQ0lRC39/yQADBWQAETTn4Xy6DS/JxfzB5z7gTOkcgHQJmA5GAgMCRQj0jAcd4gAZEooF4PxEAfx + 63rJ+vKnP2aSRS7mF4yLLuYPGp9+ZHko0fZjWn/+fEL8IAHBYedi+9J96hb25pj5z9Ghg47bnyVAbAai + o0VdzGukO8SXAOnLwIKDpZbPfFUtenXhx225WE7uq4BJfpeFAeLTUOUdYMz/YiYsEvGAAHjkQnKJTCYC + cj4elM9nt5vfj4t5Ba8mB/eoJ4Bxf44XZihAZQPgZbJwoUt8JcgShgnyIADFqARhcNSvfNSdJzDPYVx0 + Ufuwbnu313fg6X6rGDvuzOXvFjvZobPA2dxDLzXWONiHYQC98HT5K+NnyQ+Yftb1AMx3+EudsND6IaDx + rJ/plz9NvUdkEEoeJICZ/pXY/2vi/2WFP56xFRrfL+cDVCcBns8FtUJAQwqsLACpeBmvPp6pYSoH8/ty + MT/gg5zw5Onmh2FA2UDDgA3AWB0AeEYoQ/pwzmIShpFhpTqwjn8zwpyi1EnPQcig998KlmiWUy5qG8ZF + F7UN62P3vDvUtadAJm661C4WDwKZSJnIHZN3FfbJy7T+416ZhHJnyd9lSv8tgJUB9AawimA8i9esLc+y + /G84D4XQ/pr342KRoZSUcP+h56yP3fVuk6xyUdswLrqoXVhf/9KnrUzHi4106butel0ATOCy8kPyWGal + jCcdF/84lTYs+OkK/UqhvwO/63zWK+e5BkKwNf2w5o/QejS9HxeLB/W5PlmCs2cP956wvnv//SaZ5aJ2 + YVx0UZuwtzy+wxrtPdmYpot/UKyxiPFSulhEGKUS7hFvLis/SN6n1j8V9xla7qz1r1LmbwUXk36nT0A+ + KBdj+H0gAx/MHRPfcKdzBk3vycWigXesV6xUtzSkU2I9l/ip1bTCnSUwj2BcdFF7sA4291sjfScb2bM7 + 3+dk9Q/HjZfSxeIBLC/N9WjMJ+S/Ja8XifnVSteufUwENCj1KwGrAc6DSExkfFD+HvnP8QYlG95ShxMr + NrwnF4sIzBPggKF0v9Qn8fVY8ie+oztjJhnmovZgXHRRWwj1734Ol+24nzXf+QHxwfL3Zrulzm3lu+jR + QCWMM/Gh/H65QKWfCKviZkKfpKC0pyn0K4XmAPBrVhNkLSmlPgLLP6M9B7xFNwSw2OFPD2npYICDw7K9 + UpeijOp/ye7dM+a77QNuv4Aah3HRRW3A+uTdt1uxYz8K5/teCozgwg0P4LIlxYr1i+85XrRDxkvpYvGg + kUOAcoPSkn1QM//PJ5n57yh/Wu/TFfqVQnsB8OuIJedyPnkks9wpEyskJMRucYb35GIRIdupfSisRK/4 + x+Laitoe6ZOl7Bcw2PNDyjCTbHNRGzAuuph7WF/4/L3hdNsL1g/SEPB9QDsuVj8Y96CESyABtPyexbrp + UrpYNPDnB8WbjcnvJG9WRX0h7bTvlSQb++AoVSnztwSW/tELgN/119ml8p7MEbELnTh/MQllXQ/UYofn + GZyBZJdTesw15gSUurSJkDWaFJVhkGUmGedi7mFcdDG38D754BOBYu9xD6y7UJIJXkMSAqN2hr10iTff + LZ5Uv/hyIAfTLqSLRYbhPu3Qdoou+lhQG/acVaud3fywdtVo0NDCeMYr/yn5dvGmWf/fBgKAM5kEETW9 + JxeLCBHtQ+Ev9uooapalhtksKNMtdbkOoQyjLKNMM8k6F3ML46KLuYPV/Phuq9R+wpcakGA+a7hwLhYV + 2MoZypbw5PpVyLLNsw5wofDNDMrnCts1Pi+xgEykQ87wnlTQaeNrVOpXgAFLTo9Ycga/f3Dw21IHAe9P + c0hMu1hp5z2pN6oaps/hYlHCl8+ITU9Rsf24temRVpPMczF3MC66mBtYhzcNscVmkO16n4NwjUHQGi6V + i0WEsvK/9H1ZwVbWgUOpb6ib/kLScdefT4agvAPllsBXiRR+F37nRMKSL6U3ipVtE38C5zIb0dawOmCq + ApcAuJgGPSPPDIo/3yuhTMeL/kObh0yyz8XcwLjoYvbhH9z7w2Axctwzxvj+gHCOvzXmDltZ9KhW/lNr + EKqswSdKEfmj2DIoa7+cK8frxzONwhn+k+WmQFeDizm/SMyWn0froOQPi5U6DGLaI95EUr0RVgYoEwDH + Q+GSABdVKIEwjuKc4hwzT8DOD7wUjB543iQDXcw+jIsuZhdWbNePrELXcYt1/ZmYxnStHAdwsA+34VK5 + WDwwKVOulYe13FQ4Jue0r3/AIQData/e6enPxj0GpX4lmMxa+L0h+e3YHWLFIMxjOJOxXrGTXY7yTzvQ + WvBqEjD9PbtYlOAsAc4oCaYjkGlxCQ4zbwSyLrX7heC7bvea5KGL2YNx0cXswLrjPYHg0NEfWtGjz7O2 + nwI0mGX2bFRra4NJCFXDpXKxiJCHgn3NGgmAo3C/ndngxP9p8Sd8MpEKyvm8Ty5wbn9kBjwAaSATlC3R + +yXUf1TsSKd4ATvVLr5om1ipHgdlEnCZF8D1BCx6NCYHxObY8eGINOqocpyP0SGxB4+IN3bsR9adt7iD + hOYQxkUXs4PQwK7nrLG4XJ+O6SxuOwfr6llO6qNw75UlJTfL38VrQQVr53rFizOSTXxOzhcCqvwlYevM + /oksx/fiiEUBg1K/EnD4D0cAv7+/STwDh8Ua2ieBnv3iifZL48B+sZI4swRIAAkAY76XkQDD+3exeFBX + SECW9YuviO+f7RcvvQHFQVlaTIIURCU8uPuHJtnoYnZgXHRxbRF4393LfNljL9qlvhN2HBbeWFR8FKIl + R6h7hwclWCJbHnzNhXKxCKF5AGVAqZIsBrI9Esx2y5+lbnIG9SS8mvXPcr1JEAE2Ajo/A0mALCv8D9G3 + ia8dyr8LCr9npwS6d4mnd0iCQwfFineJJ+EQAKMXwPR5XCwiVGRYn4SYEDg2IHa8U70CrHSiDPTn2l4K + 3vHhZSZZ6eLawrjo4trB+tRHb7ciu54PlJgYEwMrHlCB7iviQrDkqxjRBisBunhH3BDAosdlyn9QFasv + x1BRt9Rnu8ru/3IFQB6v+P5iNCgS98vL+N6k1K8Ek/jdY7G7xTrULnWHt0ugbZ/Y/bvF04GzmWpTAqCg + B2AaAVASYPpMLhYPSiCqOAchnmPIOJatskkQPVjWCJCLisrC6O7nKRtNMtPFtYNx0cW1gffjn73LG2v7 + kfVMRPwq1F0B6eINkIlI3TAs7ALr/6FcYUF5hrLiS/fJ1tx3jUr7SnAxYQN1IAz4Ph2SM5nrVelz8I92 + EoxZ8rX2b4vVuU2sw3sl3L5LrCO7JNhxQKy+g+KJgARE252kQCYEkriyc6Vr/bt4M6BHi62lnwU5SLb/ + 2PfJz95lkp0urg2Miy5mHtZvfPyuUPLoj9nZryEHSx/Kn7Ew46Vw4aKCYgxksUuFZJCZ9oVu8VFg5obk + +cTHjEr9ysCugSAA+rV3qpcA6//H00E5FfPJLQeWQ/lvFd+BFrEPbxfr2G7xdh0RLwiANXRMCYAn0ekS + ABdXjAaWPed61esZTHVJfa7tJetLn8LBNstRFzML46KLmYX1hfvuDY11/MQawQEvxVSA2yODsOLcaWou + 3gDDMU0O5fS9UApKNdUhdZzFXxySv443lhX3W8ckX6HsJ5g7EPeUPQGWnE3UyblsnfzL6E1i7WgSa2+z + hHdvEOtAq1hte8TqPibB3gMuAXBxVfAlcWZwVuw0B50NiVVql+BI50nrs59wPQGzAOOii5mD52OfvL0+ + c+xFq9QhDcNRRzgW+8VH93+erl3zxXDhgvAXcV7YSrXEOuo+CSQ7JYyz88HCXsdSn6bQrxQ67jdhy/mc + Xy6yhTDzCdK2nI34lAgc7fmIWNu2ib1zm4R2bxbPgWax2kEAug6Kv9slAC6uEpUQAM93dkDqipCRRZDc + dNsLgU9+wR0idI1hXHQxM7Du+8it/kT7j8OpbghtCPFMj/hLMZ3g5h/FgWcSjOlSuHBRRiAPBZuNi80k + KiaLUlhmE7Iz+70Z6fWv/QJg9etr0isTKb+8mglo7J8E4+MHHpDgDij+HdvF2rtdwoebxGrbK77OXeoF + cAmAi6vCWES8wxHxZYfER+Wf6VcvKUOl/kTHj63PfOROk2x1MTMwLrq4egRvv3uZNbjzh0xuqcfhptJn + 3as32y/B3KAEn4u7HgAXbwhPoU3sXELqkk7tv+MJGJTfTX0ACrs8q/8qQNc/rf5xJvzFPXImVe8QAPzs + fyYbxLf1Cbl+23qxtm8V68BOqT+8Raxj+yXYBULQB8UfaRNPrMNNAnTx1pDtFRsEwA/FzyoShrZIBrQJ + 2jMgBsn9P7ZvvdNtFnSNYFx0cfXwZ4696C+Wh2FAcHtKQ1r+4mHiXwlrsWNSP1qeoe3Cxa8By6b46s/0 + SiOEpZUZknfk9sjfJ5dASV89AdAcgHRAzmo7YUvOJOscb0DKIz/o/qBYLask0NIkgV1Q/Ie2SvDAFvG0 + HRZ/126xBqD4af2XCUClHbAq/wqmfR4XLqpRNwKrP3pUfCP0ADh5ANo5MNujpdGsfAnkOl+y3LbB1wTG + RRdvHdbt7/ayu5VV6Dlul5JgtAPS+EwKArLHsYyeYflfn3PwM64HwMXrY0ksI9YIzslIn1zPuvrIkHw+ + twZWuxOjNyn1K8GFCF6zS+R0AlY/CMB4whkjfAbfb9r/ZWnYvkaspv1Sv3eTeI4B+5rE135M7N4DYg+1 + KQFgYxdvqtslAC6uGFTwISr8HOQj+55A8ftTPVI3mtBcKauE13yPNMb2/8i+8zbXEzDDMC66eOuw+g6M + WSMc6AMFP+Jm+bu4OoQKObyCAPygz/EAxAZkKPdpJwGQWfsGpX4lmMzZIkNBGc+zJwDka5xdBD0ykbXk + PdtXiKXu/01i7W4S68A2sY7uFKtzn/YAsAY4GdDpBFjdBMhV/C5mDMM9Ek6DIMBg8g8cfs4kc128dRgX + Xbw16ISrSNvzdakhdfl73UY/Lq4SjfkuvEIA5nslyByAQq/82+QtIhlbzqd8RqV+JeDUQCr9Czk/fh++ + jvnlLAjAf4wFpZHKn9ixWcsArYPsAbDLIQD9h8QzeEQJAL1bGr+F9e8SABczCU+a3q+ILEtGxRM5+rwV + 3emOEp5BGBddXDm8A3ues/KdL3mfiWqDH8ZEAyz7MxxqFy7eLOpzR6BQOVClU4LZHrlp9IhcSIRkMu2D + 8sbRMyj1K8Fkue7/YrpBzjH2D8V/DqQg1XWnWM1Q+rD+PTu3iGdfi1iHd4jVtlus7v2O9c8EwPIcgMus + f5cAuJghUIZ6E10qUwPPMmeq67i3f7frCZghGBddXBk8Bzf2e4qDx3XWdaZL6mj5j11K4HLh4i2j2KdV + I55ShwShaB/OrpbxrE8mYambFPqV4iLL/TTpr14m8HoxHpCLGb/cv/9LYjU1Odb/7ibxHNgqniM7xWrf + K1bPARCAoy4BcHHNofNRRvqdfhiZXvE9k2bFwIvWgQ39Jlns4spgXHTx5mG1PLHbThz9sW84IZ6RjIQS + OLjPDWgii5ZsGQ61CxdvGiNxqct0QgDi60y/jMU/Jq/kwiLRkJMHYFDqVwZbzqUCIAFOUuGZhC1nUo1y + /fZHJdCy9hIB2M/4f9n9X9UCePoQIFf5u5hZDOqEVI5J98R7xZtPij2ahJxt+7HV9NgOk0x28eZhXHTx + 5mA98d1HrWL78VAJBzXbL+F8XJNVGPu3scb+1uZD7cLFmwTLozLt4ouzoqRD/iJZD6XNjP2AnMrMQBJg + xivjiVC59I9lgJb8dOAWLf+r37ZaLJb/VeL/JAAcCdx/xBkCFHMIAOv/qfyVAJg+gwsXbxHBDEcGDzj5 + VKNRCWdjYuXYMZA/bztuP/bAQybZ7OLNwbjo4o3h++xn77JK/SesBNjpD6Kca621/T6W9+GA+kdj5eEt + rz3ULly8WfgKULBMrotF5YOFFmfGf8SWi0m/nGUC3zSFfqW4kPaKxGw5CwIwnsHvS1iy7/CnxW5dL/au + dY71v69FPId2iKfK/W+RAMQ7Lnf/T3vv3qlZ8C5cvDWEIUuDRTa/6pfGkXIuDJNhnwMxTvHfdBy3Pvcb + d5tktIs3hnHRxevD+sT7bg1ljr7IDm3hYt6Jg451iTXcJQ3pQQkW2OUPh9Od5+/iKhHIdImH5ynXIWsz + D0Npe+VMjJZ68DXK/K2ACX9s+3sq7ZdX6FGIW/Kp7ffLku0bxNoDy39Pk1j7WjX+fxkBqLT/dQmAi2sK + yFaco8Z8QurSPFM4c8/1iB3vlkAhq51V/bmjL1mf/rDbMvgtwLjo4tfDe8cHl1rRvuetsSSYaPu0wzr/ + 4CmwX0Gv+EvdclO8V+wUWHYJ1t3oMSgfN4dhrmCDQFKp2oWU2LB62AHwR5l71UKfAM6CCMxEI6CLwIWc + T2v/L8ZD8vNoWEJNK8XavkZ8u8vuf63/r7j/Dznuf1j/SnwzsMaISgmg4bO4mDv4CjEoTMip0Q6922/D + HQ9RqZZ6F8T9DtPLypHC0bbnfXe8L2CS2S5+PYyLLn49rN7dY415xvlh3SyATn5+fgYm2eRTACzNUgHr + +J4/ZwbutH/vYnZQIQDhFJ5FsVcaM0fkz1M3gACE5HTWLxep/BMzUAkA6/981isX2FY47pEXu98pnubV + Ym3bKL4dm2D9O/F/z7Hd4uH0v4HDU+5/7W5ZVv4uAahRpAZ1gJSH7cgLeeeOF9MAyeUCaFSW7hdfflAa + 8v3i6d0+ZpLZLn49jIsuzPAd3RmDkHvJHqZQ7pKGApin6VDOI/hyfRpj82QPS6A0KOHsPqkvxB1hPjL/ + P998RYUAhNJsBNQrv5HerOV6k/F6EICwSA5fs32vSalfCaJB9QBcSDtkYvWh+8Rq3SD2jlbx7dzgZP8f + Zvx/zzT3P4gjEwBdAlDT8JaSOmhnSY7VJPvEjzvuyR3R+noPW+0a/s98Qn2RHssu8QzjDOb7X/Id2540 + yW4XZhgXXbwW1sblTVYpdmJJBgx6FMJvpEdCmfnf6MeTjuHz0BrgZ+qTABi1NQzLPzPouAoN/8fFtUeF + AFijMbEzPXIk9YASgPNRD0hASK12HeRztYjXadvfiwwp4Pv37HpIrO0bJbBzu9i71zvWP+P/HftgYV0q + /yMBqHT/qyh/lwDUHhjaszhKmq10QQQsGC9+WP7+4X7xJ+f/MLIQh63RIBsdkCUZGCzDAyeszY+0mmS4 + i9fCuOjictgPfvMr1jPxnyxJwFLOwGJ+JiHeHIS0tmY1H8x5A7r58Vms5yDIU33if2ZIFU5guEt8an1O + +/cuZgVTBGAMhDPZJyezd2mZ3mQURzIenpEKAEUKZKI8V+Avh64Xq2WjeFrXi297i1gH1op1yCn/IwFg + /F8JAMv/ki4BmBfIdop3BBZytke8z4II4I77nhuA/BoSP+eVmP7PPIInBzKaGxT/aAafdUAak1h/tu+n + 1re//nWTLHdxOYyLLi7B+sgH3mllO15cks3onGqtR431SHgkJb4FMM8/WIKSz8MSgDUQKnZCUETFV+qV + EMlNEQLD8H9cXHtUCACboNSl2+Rn+aUar5cUWwDXyRnW7ceungRMZPD7+DUIwGjHh8VqbYbyBwHYsUWs + wxsvtf8tJwA68X+cmXL9f7Xy53s2fRYXcwhY/w14RsFSH4h9VO+4lWKuT1z8IAbG/zOPYOe6RDuwRnpV + NnvzfbIkx3LBjhetez70NpNMd3EJxkUXDqz33RwI9B0Yq0vTyulVAcf5/l7W+jPpZAF4AHzFNq2nfTsE + +t7so7IMn7GByUH5jARdi27OUCEAoUSbfCW7Ujv1TcS9zmsqKGezOKLxq08CZCMgvnKw0IP7HphK/vPv + 3Azrv8UZ/vOa8j8QXyUAjuJ3CUDtooEhvVxWluZ75QY8nz2ZR+SmNEs38fPSMeP/mU+g9a9nb4Rkuds5 + g+kBTZ4N9O4ds+54j1sZ8DowLrpw4Dn4VL8Fdqm9/Uch8IajEiiCPYN1Ws/wAM7/LHlfkW7AiPyj/J3a + C/5fpm+SxuIBCQx3SF02+5p/72J2UCEA7APQnvksrH2vnMqE5SIt/yFbTue82gxoukK/UkxypHAiIK+k + AtLY+hQIwNPa/pckwN7nTP+rxP89g+X2v0kQAG3/67xHlwDULnyZFJRjuzSUDsgfpG6USRDHf1L4gMqx + OvaXMPyfeQVWLz0L+Zw/IgF+X4oJpwc25AdVXnsPrxwyyXYXDoyLLsSqW/nQSms4fsJ46OYVSFq6oeiH + ygoFpIWu/Vy3eKD435U5KC+OfUgk4pGXh24Qyfrkd7N3yjuYKJQekjpcJF+mE/+nT1l2IA8LEMKfZTds + wmH+my7ePOLqnmU1BptJMffierb9zUGw0V2bG5K/zrwNBCCsdf8v53E8s1D+sUa84muDUr8iRCz5BZT/ + 8ciNYrW0infbcrF2r5fAzlaxOPynbU+5/3+5/W+5+1/F/e/2/p9jlHBHtYy3X0KpY1CCeCYjAxKItUl4 + eFACqSFpHDskJ9Lv1ef9N3Gco4QlJ0dvkbdnQO6yMACKR6Es+8WXzujvZEKwN4fnTGU6/e/NNxTjx0Mr + Hl5pkvEuXAJghPWVz9wXTre9YA0bDtR8w1iv1JWguBO9UOQl8Y70iC8VkWA+KbcPb5M/zd8iF2KWnE0B + tC5z9SIpv5yI3SB1z3ZByENBDae16xbDIJ5Sl9SN0fORlAB+r/FvunjzgOD2FXo1qVRJVr4PJG1Ia5sp + hG/J7pW/zyzRJj0U4GeYsQ9MchgQn1e1Mn8LGI+zrbBXjnZ8WOxtsPq3bXAIwH6n/a+6/xn/LxOASvc/ + lwDUBlT5FwpKzj0j3ThDfB5JqR/NgTzGxH6uXf5532141n6ZyDXIOJtI4a5z/sNfZG+W2wtHJTTSqYN2 + LMqJYkz8mSNOhROz6w1/c15hZEjq420/8nzx0/eaZP1ih3FxMYMxIyvX+ZI1AvYLy9l4qOYRgukIFD8+ + y2gBaJM6xvfx2T6e2iP/LvV2OcP+77346OkGtSjHo5aWhUkuIP86u0zeVYDgfw7CgIONON2wGBFvogek + AMKHuRGGv+niStClnhk2ltKs7Cz2uIT9zXep+391+hE5m/bJeTb9iVtyAcL7InsAxIIz0gnw5RQswqRP + PrrrW+LbsUasndvF2rVegoe3in0AX9P67zkgnv6q9r/q/i/X/bsEYG6B/feO4hWkjOPH/bmI2Lir9sig + vKN0WE5m360hnkmcmVM4P44nCXedCaXJJfInmevl4+ltuNcsqcPZG8UZHCtq98kQSZ7pb84nDMPgKUZh + 9HS+YN35Hnx4s9xfrDAuLmZ4+3c+583jwBQSuFQd5kM1j+BPl8RThPIeaZfwSJ/4sx3ylfQW+Sta+lAA + 4xmvvJK5Sb8+C6vglWRYJqFkJlLXiwxZ8pP4bXJjHpZfKQqhcEwCsPooaKwSfh8rCAx/08UVoERLelAr + L4J0x5KslbqdkEBuQH6Q+oiW/3FMrzAJEK+M407G8HXq6qsAzmR88texpeJrXiE+Tv/bs1us3etAAKAU + jjjtfyvxf0+M7n8887L17xKAuUcjiKKVw72EzGL5rpU7CsIel8bUIfkXqdtFQOjPp50JkqdTfjmNZ06P + z5ncdTJBAhmz5X/mLflqdiPuNkjACH5v6ZA+1yBkh+lvzid4UyCsbGxWiEqob5fbKXAajIuLFdamR1tx + eX5KQUwWHWZ5nOFQzSc0MoERDJglP6HkQXm4sE5+lQzh4nP+O5QILv+FfEBjwbQKzhWWyWQaP6fgiN2o + a39QeLc0JPB7hofEm2uTYCmO3wkFsBBchHMN7KmViYi/1Okk/mWHoPwhyFMgA9jj/5QGOWN4JsVBPZcI + wMUEvufaNIV+xYAS+Ad9d4rVvEbslnVi7W8Va+96Ce7fIRZr/7sv9f93CUDtQc/KGO43LH9vCc8Hyj+Y + 6JU/GLlV7+5EokHO0vJn34jcEhnHWdLnnq2TCdz9i0osLXklHZRHCk34v4fwe47i7A1KI5+v4W/OJ9Qr + qebAIOzRWPwn1rqHN5lk/2KFcXExwv+VT95nl/pO+LVGlhnNfc4gDcOhmk8I5w6LNToCoZ2U9cXvOkIB + FsF4qkEu4uJPRG05V16TArYiAQzcoOVmMgxCUAzIxSFL/jh/O34XlNUoAEshWMw4wsfwN128eXiYaJWN + SKjYju+ZWNkrASrYZEzuLO6A1eZM/dNRvezWB4GtlhufU3oGCACw6vBXYf2vEU/LJvHs3yzWgc0S2AcC + wN7/vUCFAGj83yUANYVir3ieKeC59IFMDkgDCOT/lb5NJnBnzxf8IkUoeSr9/kaQepwX3PEL+To5j+c+ + MeS0kh6PL5ELPGf4+brMWjzfFIhEVIIpyA7T35xPwP1SOVUaEH82if3qOR744ifcfIAyjIuLEVbq0AtL + c1D+UG7MmLfyODQLQLh5nx0UK35MWodXgulDCMDSv0j3Mdj/aSaRQSCciYSh9KFgYFn+IufXmnB6B04l + PXKaneeSN6pH4F/n3iPvSB8BCegTP8shC/M/RDLX8LNcqTAodUW6ch1hxfi6DWzPfksF9MW4TyZzeD6c + 2AfLX2f4g7yNM1ejrMTfKn6GZ3zHtpVa+scEQC/b/x7eKoGDO0EADorVB3AAULRd7CTeow6PcpS/SwDm + HvXpbm3w4xuLSEPyoJzM3+w823iDnAex/znDRHFbLsSWyc/yIAAkjwPL5DRlQY7joBucZFLec3oBoz5p + HXlcrES7eDk0yPA35xWGeUZ7dN4Jq58aOQwpeejHJh2wGGFcXGyw9q7prC8mj1ulQVj9/Vofy+Y49kKY + 5588JvuKT8gvaOHjop/LBOXVLJWJpcNkLqRtVfhnIQwoHGgtMEtYovw3ITmTC2j72ZdLIAUQEH+YvkPe + PnYUAoIhkgWwP3OMeg7TGe13QjW5DM4fiCesumChTf5R6h4V5uPRsGb+8/lMQmGfT8Jyg3DXqo0qZf5W + 8GeJsPg3bBVr5zYo/3XiBQmwj+6QwNFW8XZA+dP6Hzyi7n8SALaUrRAArft3CcCcIsis/2JSE/5+kn6f + KvIzGY+ek4lcyAnnRXza40PSHPtsyasg/+czIVj9IAQxnCUQzHNYO4czNoE7/vNEUA6Nfgekj+TU/Hfn + C3y4WxxYxeoGp7EZ5FYpecLav67HpAsWG4yLiwnW6qfXLB1of27JKJghrS8cEn9hCF/jAHEojuFQ1RSG + 83iFQE53ytJkRMKjsMrT7fgMDF+0yROja+Xn8SUq7P9aBQIuPITBz6hQmBE8TSG8BumwvEIrYgjCIQ+r + AQLkRPR2uZmlgJlOWK4DEmZv+GKfsO64Pou/n+uTpRyXzKoB03t2UQVY0qUOdU9q++Vcp3jz3eJNDmHf + YZ2ZnskVYDJhOx4fPLeXQfYupOj+hVLA96dAACPt90hox2r1AIT2bhLrwF7xH9wjvkM7xdO/Xbv/XVb/ + D+XP5+sq/lnCG9T5e5P98raxqPx25Ha916dGcddJDmnRv5lx0fGg/CqL8wFyyTDT3+eDejb+Onm9rBpb + i7PZI/6RtNTh+YfZL4DTQ3EOmBRslYrm91xLGGYOAAy7fASyHTIJ+7h0LCZLBo49Z614bNH3BzAuLhZY + n777ziVDHT9s1IPBuCYbsbBxDhRXFodnPvTCz3XLdSUc6hQE8kinJgNZzz0DEtAhewtPys/YMIbJPlDi + pwfrIRx4wb1yJsnYMi6+SShU4QxwMe+Rc5nr5cIgFEgcvwPC4g/wf98xgn3LxbWngFViExEIp+EuCT6D + 95DOLIgkolkBKwHyMQmwOVPeKQv8TKJVzjEUM+15XCmYLzDBZ46vX2bnQFiBDCFcoEWYCsmje78k1tb1 + Ym1vkobdIAAHt4mvbZdYR3eL1Y3XQYcAVMr/XAIwu3ijOv9luIP/jOcESluiS2RiwCNnk3Tve+Q0vXrT + zsNrEIUsYCIgv8bd/mVymVzk1wlL/iq2RA4MPyFW4hhkyzNiF9icymm/Wz/M5lUghIb3XFMoy3JWSXiZ + b6Pt2/ukAa+N/Uefsz71QTAns35YDDAuLhbYfTvG6kZwMMCk6XZl8l9wJKZxWcZhjQeq5jCE9woLko16 + hnEhn2USWb80jz0uP4tf51xsCvwIFPcgBAUs/0kK/7iN1zdOIjsVd6zQM4WwJg7pet6JQZ9M3CnvLB4W + 3wiIEv5mKBfVgUlsFesfddi2+T27qID1/6zSoGvSDwKqIQCQuJ7Elx1BfJVgxcD5ZFgFOi1+kje6g3+Z + DcmrsQa5cetTIACbJbi9Rep2kgBsEm8XGwAdFk/P/qrxv1UEgM/VfbazA+zz69X5H8cd1Ph9gV4eD8ie + JaezDuEbTzmev9dF2q+VAZMwEiTjlYlIUM7F8f+VIFryv5Ih2Vl6FM8dipS9UVgZNTYCotqhnirje64h + eEqUjyQrA5BTuGdlWU+ZX1/C132ti7o00Li4GGCteXQ9FNdJWv10X1tjQ2LjsLC9Leth2YltPgg5P5i4 + lYfyh/V/UyGBi3lQNhS+CoEPZQ+h/7eFOjkbgUUwROuPJWQ+uQglwAs+mXnjEMC5bL26kJkbMJkBiYAy + YfXA+VidKhPWGt+Qo4XglAiyTwDzJ6xiB1g2a3Bf+55dVKMHSh+WFc4aWy57aOHh/P2r1M1KskzP5IqA + 5zyRgeLHWTgLi59rk/i953IBOdnzTrFaW2H9b5Lwribx7mxRAmB37hSr84h4K9P/GOKpyv53CcDs4Q3r + /AuWXIw4CX+ayc+kPt5Vhn4SbyLElw1o3w/G/y8UYBDg64uxsPYG+VkhJJP8N/GAbBi+XwKJIxJmYiC7 + iXJOyDArV8zvu2ZQHFSSzSFuenZZdjsGIlDEz7Cf/tLgCWvjY00mHbEYYFxc6Ah9/tN3+0Z7T1opsEMc + ECp+Zv7rIQHT9kO44WDgstU+w2Vvfu9ovwQLMQlkOmRtcqWcpssfF5c1vhrzpwuYlj+Uv/Qvk4vRoFwg + 409QoeP19cD64ZhHQwFnYA1cSIUdzwGsBA0jQLH8XuFdUpfE3uFikQRo/wQoMj/DKob37KIKxS4J5RJq + oQSYYY9zeF3usPxSnxsw/XlcMUDe8OyZ2HkRSl8nCtJizFmy8/AnQQC2S3jnCvHtbRJr307xsAMg+/93 + HRbvEAgAlb/G/7umuv9V4A7/ufZ4ozr/nxeh5HEXlaCzXfRQCPcez5p5O7TijWfiEi4kA0roJVovE8ll + cp5ygXc+Xq93XuJ1cloJhSWrcys0OTWUHZRQvg9yEwrV8J5rCyDW9PLS08YhViABlPd2kWsR8dBYKbWd + 8H7qI4syFGBcXOgIZ4+96El3Czv+Md7PPuwUwHT92zmO/YWg01jbPFBgxaMSiIPRjibke6lNuNQB+VVp + iUxGnPafjivPq25/Wv5U/pJwkn7YA8AkFC4DZ85DYZyDUBjn78L/O50Pydn0dSqALhShVAYs+dPM7XId + Bw2ROCUhGBijZFjF9J5dVKFTQyfB3KAEmGGPc/itzFp9brTEjM/kSkASgd+lJZ8gAOMJPH8QOvYQuGfP + 9yW4dYPU73hcrL2w/g/tFV/bDvF0HBBv1yHxRMsEINn5mvI/Kn+XAMwC3qjOH3dzPL1UQ3R8zrTYNbuf + Sp1ewOnnYToiQUdOKNFv0MqSCX6vJAKvrATCv3m5WKf/7vHEKtxxEPxMUg0l43uuNbATKl55bunZ1XAA + 9pGVAd5SXLxscJU++IJJVyx0GBcXMgIta3dbpf4TfPhkgprsBygJgPWlil97AODizQMFxqSxusyg3Jfe + jssL67wAIQ82zwtMK+/ngGOpQ+njcqvlzxAAfn6GryahUIVz+D+n0hA0UPYcEkSCwYoAxg3HYX2c5TrJ + QMSSn5ZukRsyR8Gs+zUxMJzuMr5nF5fgNJzCWYM14i32SCjZI+nEF51nlXwTAvyNEHUS/jTpL2Hjd9oy + AUL4Z4P1Et6+VgKta8S/YwUIwB4JHNot3s5WsXoOS6DnoBP/T0A4lglARfm7BGD28EZ1/ozhcz4E7+fF + DO5nDsDd1l4eXJ9+Hl4DEPgiiENZ6TMcwLPCBNSXcz71JgjOzMsM/2F9POmRLyV3iA8Ghz9T+wSA2f+V + kBXlvb8UccK7lPuQmwGWfuOz4N8etzY8tehCAcbFhYrwfXffGsh1v8S6WSfxCooeB0JLWnhImHHLfAAw + bSp/L4mA4VDVFtLykeHN8r8SjRoP1PIfWOR05Z2LB2QS7F3bx7I2mDH/RL1a/mfpxqf70CgULuECrH1t + OBPF/4dVcTZTpxUBLBm6EPNprTEF0fk8BE65T8C7ho9iL2HVqhfF9J5dVMC20yy1olXlGemUZdF2+aPo + XSpsz78JgvZGYBjoLK27tFcmB7EGAX8265V/0v52sZo26uAfi9n/ew7L0gPbxe5oEmvgoIT6DopnAASO + BABEjvX/LgGYfbxRnT8b95zL43uQcMb8lQwwzIPXU28iyfcCG0yxXHAo4AycyoLgK+HHfY76ZRxr4yQH + /ZAnOEs0Kv5XrF4+n94g1nMp43uuJTiTNSNis6Rbw7qQ71h3yhixVugSm5VThbiEcj0veT98xzKT7lio + MC4uVFiD+39oD8ckmHSYoR6CaQem5lBqB/J4z/uhVCNg3QWdEmeNxtX6v3m0Q/40eZNezHNRJ+v/zDCU + R2yJIwimXfgZxxv0CQgOD0mQGeQjfTpBkMOILFi9moHLhBzTZ15E8KexDyXsT5Zuyj55V3q/Tv+bpPuW + wty051cCVgHgbEzGKOQ9cn7EcQ8/duAL4tnZrAmA1q4tYu1vEesw+//v1fa/HP5jg4xo7T/rvtmdMHtJ + 8bvKf4YAq/Sa1vlfLVJ+OROvl1OQKTyP4xHIGLz+efRGeV+hQ2WQNRbD2WDvkQKIYlTCsf3iKeTnx6yQ + 4qCGgesYvqRnIHF0UXUJNC4uRHhXPbamLj/4kpUf0ktljyWgoGrfQtUsYLxPLxhsEIc1CBLgZLR2y3tA + Dv5V9BYIBFvjdaeH6vC1R7v3nYk1qpVgvNQziDfsE5BOSl0hBcKVAfvul0AOpIB9AhJpWTpvSi2vHRzr + A1YInymsk4czT+iz5MQ2TeSatt9XitNZKAkojovxkEyyCZASRb/ctetR8Wxdow2ArN1N4jmwVawjzP7f + 57T/HXp9AmD6LC6uHNe8zv9qAbIxMdQo51lJErfl1WjYyQVK2PIHiVvlPdk2KM5eDZ+ygkoTqEdj+Awg + AvOgTFDPMgwRH0ebQzcEM30vWk9+7wmTDlmIMC4uNDTc9eFlzPRsYA1tMYqHDsuziIfPHADDoaglBFJ4 + j6NDEk6ynAXCYZgCIi7X547JcZ31jY+Y9kIo+LUGWGPHOb/T/Q1WufFSzyDeqE/A20qHJUBLn81DshQM + EfEmoFCeATlg2MXwmRcXsDcUoBSWIHqjmQ/rHk5mvJqhXdnnt4qXsyGcCa96FC5kIbyx9h8GblDlb7es + Ec/OLeLZ0yzWwe1iHXPG/14+/Q8EIN07VQHgEoAZBu7ANa3zv1pAhkzGPXKBCYcFkAGQ+7PpgFxkRRFI + ycnke+XGDEgAZBK9fD7I1VAKd/sZEAL23Td95hqCjkqHfOLZJgGgjrCyR1+kzjDpkoUG4+JCg3f/ph5V + OGWWR8WvFs0YFZL5YNQKAukDUA6wBobTEogdFes5COORdvnnsdvkIi7kuVhYXmW9Lyd94XKeznk1dsze + /nQlGy/1DOKN+gT8s9RtUl/A+2ZLzmGWEOGiscMiOwaW3CRBNp/iWfTm+3QK4H/mHjIZK+OR82zIYtjz + KwGTuaj4p8gZhHm048NitawS/7ZWx/rfV3b/t+0Wq+eAtv/V5j+/hgAYP4eLt4RrXud/leDfYeMo3u+z + BcgTeh2w9otsnbzCOQP4/p8P3Yb73C7Wbw5JKAEywHHhOtdiHkwTLIF0sZkaiQC9wywNpK7Ys77TpEsW + GoyLCwmh733vfuuZ3p+EaPUz6SPpuKvqmB1aTgipacBCaMgdkRCzgccisKYPSyT1OQgCP6x+WAVRKFq6 + B6E0Xk3Xy6uDEAq9PhkHQz/DxDzDpZ5RvFGfAJCBn2bfJXVpWAalqHgKbXJ9FgKihO/nQyvRawxfsUsn + /zH++IH0QZnIQtiqV4dJlzMQwkn4deATqzm0NAzP5Yv7vyHWjlUS3galDwJg7WsVD93/7U78n+1/L+v+ + V24A5BKAmce1rvO/WozDoJjgaPAev5wZrJMzabwfElTKnGhYTjPPKBeWgewXxVc6op6LhkyvXJc/Mm/k + K/saaAiD487xypJc6zcH/5XvwQe/YtIpCwnGxYUC6847w/5424+Y2U9mZxedNr+c+MeyP427mg5FLSEf + E48OKjomXiiLp7JrcTHr5OIAM/CZpQ8rj665TEBOsdMb3f6DsB4z+JqKxHCpZxRv0CdgsghSELHkz9Pv + k/osLxk+UxrKZISzA6BgTJ95EcGX7yxbfoOyOf2k7h9L9Vh6NROtgNnIhQTxDM6IpEAQI0skvPNxKP7N + UteyWay9zeLZv02so7sui/+z/t+T6L5M+aub1PAZXFwFrnWd/1WC1v/ZPIj8EP7mAM6ReqXwd8vk4xxl + 0FBALmTr5fHcOqeVdeaYBEcS5fwWw2euIVDpUybRA8f+ACzHZYmgB8/CFzv2I+v978fGm/XLQoBxcaHA + 2rJih/XMoPjZ7Ymx52S/BJ/BwYT1aaU6tRGE6VDUEhpYr8q4/3NFuTu2WU6nwbj7g3Kayh2X70zKq7W5 + 2vCFP8MaE71eyYO5zwIBeKM+Aa/y3+WWyQW8l5+U3iV1OSgYDr8Zjos/3W78zIsJJKHebDfQKy+mnfG/ + 2qqZlntZyF4NJuOQX3gW55gHkA7JP+28Taxtq8Xe0Sr+HevEA+uf8X/Psd3l+D8sN53+1+W4/zmu2LX+ + rxmufZ3/VQJ/6wxkyUXIFFaU0BMhiaCcydjyyxzkThGyhmRkAGu5kNwbB6Ec5ZTAfrlOS63Nn7tWQB2g + 5LZcssymXBaTGUnInhsUa/OKVpNuWSgwLi4EeD/2sXf7fhD9KYUWE/982YgEM0NijeBBl3pU4DLmM/1A + 1BrYqMJK9cst+Z3y33P1Wo/7i2yDKolfZZaJRBgGwEeGgBiHsDiTq5MLtMrpCWBGvulSzyDeqE/ARQiF + C3h/E1BAtCD+KHG7vGf4MC5ZVOpKrkVpZWKwPrqlLtMpf5NtVIFLLwDdvszjMO35leBiMgjF75PzbASF + 333k4CfE2r5OGlqo+Leo9e85tEPb/3q6q+L/tP5dAnDNca3r/K8aCeb4ePT8nM6GlUgq8aAXAmuvsP8I + iOov8tfp/f7vmUa5tbAHZyai4QDTZ64lsBOgh14uDi+Dbqgv4HsYjKFn0jj7OtTspOeee99m0jELAcbF + hQAreeDHAQhX00OvKeRZh9otweGscAocx1TWswNh/oA0FJJYS2i53O+n3yEXwbZPsZ6bFzATlNNxWtz4 + uoah3okohAaU2cUIiYBP/h1IQCP7G2STYhe6xZPthBBkU5GI1OfbJVRkXTygjToMe7YAUHGpq5sUSvab + mU0qSE/Hl6iiZpx3RnIAIKjP0UKDYGZ56C3b75fGZsb9V0po5xaxDmxzyv/a94qn95L7X7v/cQAQlL+C + FRtu1cYVg1U8ND4ChSEJZXPYS0597BDvMKxMliEXI3I7COC/GfqgkuQLJH9QpKcjePYREHzTM60hnKfx + oc2DQP6HwnrPfy/zDlma7dZ2u3WFBGTYfrz2SD1bXdMQg6yjzNO6e8Oe1RJCmTjuw74fmXTMQoBxcb7D + 98g3vmsVO46H07WvQHyloxLk+2RiXCEr/mEI4EKXXFcs4uKwjnZIhnP3yBkdDgPLPxZWNs6e3eMFxorx + kWsYZ4dhybAb4ZBXY9qTIAGSaZC/yLxHlo1sA+HBZyzmZRkERF2uA19HVSh600lZFueemPdtvqNCAMLs + sZ+LSlvqq0oAtBsbFPb5FLO8r/75chgUqzIYN/7z+A1y/bYnJNCyHgRgo/j3sP//dhCAXeLpqIr/V4b/ + pPHeXAJwdRhrw3kGoc9l8LyPyPXMgRkBsU/D+h8ekMZCh/yb5E2aQ8N5DXxeWmpXInk2P9NaAisD6JVg + JZAmKSbqQGL88lz2Xnxuelh75fpSCV93S6BE2QZDB4YZiZFnHlQJ1KcZxug47n34a9816Zr5DuPifAcs + yONslKPdnQwPtZZA9y+TEq0EhATr5cci4k/1yBLWzOd7ZU/iqzLBunpm3/YD+YBm+0/g0k1ozB0fuZZB + 6zMRll/h61PFBieGGbHlLNb/dXaZ1HOccRaXLMdYnDOMyV/EvmBP/EwoMuzZQkCFANRnjkA4JuVfx9+B + /QqVpzh65AyfLeO81Xv5FjCeBvkCYWTy2LOdHxTv9s3i2bpKLCh/Tf47BOtfp//tF8/AYa3/rxCASgLg + FAEwfA4Xrw/OzfexMU4+piEUTw57XcjIjSMxCYIQvJSGlZ9xlL6TRwMlirvNpLpXmbg57XnWGs6nl6rH + 6hzk0wRIiwyBtNJYwT3flXwQZ7tPluTiEmQ4aZTdV4fETnD+Rb/OvjDtWS1BdQh0SSjf9pJJ18x3GBfn + M+zNT7daI4MntZlGHoLL8FBrCtmc1JdgaY32QPG1iZ3NSJijKxMd8v3SRihKxtp88krSqQ8fzwOZsmU4 + BGEx7ULWHCLX6VyCyXi9vJLxOLkBDGEMBtXa/ePY2+RWxt2g+BuKR7AHcVw6egFK86OO+C2iQgACuW65 + LtfhxOijPs26ZonXWcZYWeZp2tMrgA4USjku2qf2fk0s1v5vcwiAdQhfw/onAbg8/k/3P4RzVQWASwDe + KkpyY3TIGY2dPSyB0U4JpmNSD9L7R9kbRUZwn/uZO+PBswJBjtpyhrk9A3XqETI905rCwBINM53O4V6T + sEBG/ZKkM+2X8VhAvltYD0LZDgU6IHY6reOEKesahnG+cjnDftUWSNq0PHB04KS16ckFlxBoXJyv8H7s + I++2h3tPWGCYXsZW50GSWSCd0GzTIDP9C0MSTrFEMS03j+6XP0m+G0waipJxNlwsdvjjwB26dCeSzO6e + gRjxNcbpxFKnj3gMwo3ufyY5QRldjEMpwcqlwtuc+BYEA6zO4Yh2Q2PXQ7rFPcMQFoY9WwioEACrEJNv + pFjaCVI34GTrMxZMi53P3LSnVwRYla+WLcx3b31CvK1bxLNjo1h7gUMgAcz+L8f/2f+fBEDnppcJwNT7 + dAnAWwJr+q1n6QqPg9TiXCc7xc4l5B+m7lMF/0ourKWZbPjzqyLueMQjE6mlesfVI2B6pjWGc6mQ02gK + 53eCzYFA8E/z/ee88n9lbpF3jR1QmUbZxnLXQAmG2bNQrql5kKMFHeIvwCDBe/eUuk54PvLhd5p0z3yF + cXG+wt+xPcNRvo15KFXWcs6HaXScBAdhy9JEfyLhCFscut9J360XSZv70D2Y9cg5vrIeN1Mnk1CkOtp3 + 2mWsNVygIMhAyNHqT9TDMvDIK1ifzFpyKrlEmvJflOBITDxshcuyQFhGmhfAmeNMBjTt2QJANQFIxn9D + LSZWbpxL49myzSr3byYIAM7JKfy+fxu5SazmDRJqXS/2riYQgC3iPdTsEACt/z9S5f4vW/+ZKgJg+Awu + 3gTGoPzzONclkPx8l1xXSKlx8v5kq5zMv0eVphRvkItJv5K+8yAEWkbLhEB2/pv+PGsM7EFykRVH9F4M + BuUUS5GB0/jZL0EA6Hn6neyHtccBz1EQMo7tgvWMUfaZ9qyG4IyHH5KGIpMZO8XftjVp0j3zFcbF+Qjr + q1+5zyp0HWcXJ2/B6eyksUvDQ60pMA6GyxAiw8wMSLjUJVvS33USwZgQphbcEi3BYS09S7pYWsefOw1j + 8PFrGawdjgbV4mdMUy0DKKRTyevlK5n1uFRFzZLmlEarFNVnFy4wDwIWU7Jg3rMFgIpiZfnfXyRu1pp/ + KoCJWEgm6fqdgQRAgqWZ57NeaW+7V6yWjVK/dQuU/2ax9+0W+wiIQPsesbr3i6d/WvlflfvfLf9762Bo + iwovUOyVujzOcx6kli3JR5PCCXrPpT+rHrGJIdx1evpyLLtjOahX50GYnmktQbuR0rOXDuvAoHNYYz7A + 2XSDTLI0uSzDKNPqhrt1zkE4jb2hd4n5P4Y9qyXw/HMQG4kAwxgwSo5bX/nSfSYdNB9hXJyP8PUfeo5W + f7AYAevuEz+sFyoT00OtJbALlafIrnj4/pk++UymRX6eYsvNkM7t14tWvkSC9Z9ngnIejPtCPjAzFuI1 + xplyjwC6OM8wZAHr4Jc9N8s96d3SWDgmYXbBY3kQrAGOFg3ywjF8k+0U7yizhl+7ZwsBFQLwzuRe7FOd + EgCn41o5IYxx+xkI8TC7nK7mr+z5svi3rXfa/+5fJ7592Nu2Zmf8b88hjf9X9/6vJP+5BOBqATKbHpQQ + 81oKXSAAg5rk2sBzX8rQrSz7U9+T8ZxHJtn3oR8A+WNvjcl5cL8lEpJzhTo5B/LyS+YmMXkVpFPnFMT8 + MhF3+gf8Il0vn023qGx29iU9LzqxekuxcrvmXglxeBzuhN27b8ykg+YjjIvzDdaKB1eCab8UTrLhz5DW + 2LKJgwXmZnqos4lQsk98JRCSYhrvBwoOSs7PblNjB0FWjuDf4OfJXhCWrDQUj8m/z74dF8snp2PO3G3j + pashnGOtcjqgTYheTuHSl9e1hA1WzDiVWRRCobz+B/n3yYeGd+P59MnSRaBYfLm4NhgJpPDMf/OYeLI4 + Awmcy3waRKdDtiYecYQllLRaS9ijX6VgVUVDTmvl8r69VYxnA/JKtEHqW1eI3bpaQts2ibWPFQDbxX8Y + z6F3P5T/QVj/OIvxNhCADrxHkDFYrk4S7euDLVOvBowJswd+gH8zHdGWrHX4OpzGPWZbVsOeLijk2Osj + K08OPy5/S48eyDJHQWvOT8Er53IOEaRFrQO2oFx11gbOytSAp5qGT15ls6BkQP597j1SP3JQ/Nm0+OMg + +vlyaeDoQZy5Ia2Y8OY4MCyFs9HnVA6Y9mw2ARmlY9gZCkjjHpdSuNN9L1kPfe1Bky6abzAuzjdc37t7 + zD8WFztRjldmOqSeTWQ4gc70UGcVUAClTjBHXHS+n+d6lVVyJkEwldFQRYBxwmRMfpj7uJwfxEeCJXCe + U/VmIAt8NsBOfzq6FiRAR4cyJkjrha1CYd3+XcavswH+ae6DEszsB/Mfkka2C8VzMu/ZwoE3j2c+DGUG + a8czehTCPqYdKWkVMl/lB/GPQ/nbcg4W33iCddSWvELSBMHJbnCm/b4SUEn8Tvet4t26XqzWzeLbtVUJ + gH1gh3iPsvwPwrf3sHgG28Ub7dIQAMu07DSztlmOCaX8OuBo7asBG11xEI72f9AwEPaNseGyR8i0pwsK + I8DwEfGk+uXzxT3yP0qO14+5IBMRJxdggqEBhs7yDAt6NVFQu2/Grr5M9FqDFS3nGNLA+2Uy8w/znxIr + EdVqCD53fyaHczSoLXi9I3juozwLCTz/dvEw+c60Z7OJUU5mBNllY7IxvJ9Ij/hHY7JscN8PTbpovsG4 + OJ9gPfrgQ9eNDJyk4NA68jEcoORRaeSIRyaSmR7qLMI3jMPMJKAslH6B6BEbSoB1wVYxJg382WhOmvJP + aDMNuvrHWU5Dl7/hQtUaNNGHAkoTgZx480SKMX+fnE1ZmtFO6/a3Eneo8mO3QysFjDolcKY9W2gg4dNY + Iqe95dISwFp9olMCePZ/xWE9IHyvZnxTFh73jQKTo3un7/dbwbZDvwHlv0Gs7Vug+LeItX+DBA61it25 + Xby9R8Q3cEx80Q71RPnSfUpWnCEpuEO4U68HWvBXhdEOTQD1FPG3S91Sn8G5KHIkKydfgiBM28uFBht3 + gArGDwOA/SDuyR+U/5lfIq/qvQJAAuhCP8PBP7hnE5ANkxzLyy6gvHeG511T4FkGYdFhVPRexIKyJfc4 + nntCGrI0ACijOTgopp4fDmxjBZCdPQZyNPeNwNgqeAksfyt9TLy/GRcf58pA1zQ8N/RT67v332/SSfMJ + xsX5hFC0/Xk2auAAB875t54BEWAsme4jWhiGhzqbYAKQtvxkK9BcrzRG8V7ZonikT0LD+/F1v9xZ2isv + p5epC3gy69ekOY0Hk/WbLlUN4eU0hFGiXpXXL8ny2QyElz6Kz5EJa3ez/2fsVli9AxJM9kk41iUBztvO + dYL5g1Uv8A5zXlj5nhIsByhTnZQGq9mXg4Wd7JF7cy26hxfV+sd+gTSxCZC6dlnhMRMxYPyOe3Y8JlZL + C0hAq3gPtGoFQPDg3nL3v3IIIHYUxKzNsXSIHKxvgkmqrwec46vBdbi37AqneQb0lHGELEd1QzHYKZBn + w54uCJTPPZPLmPzL5OUl6R5tkPPe2GH5q8EbcI9s+RWrf1Ll9tDxkEwkWHcPIpDCeck63oKaRtyWswVb + JiNBmcjVybm0R2XdncVDkH3dEi7h/LFcO5eQEO7E0kyvegaYH1ALVVz01mkoTNu14/sREhb8LNMl9bHO + ed8i2Lg4X2Cv+t4aCNcTVKLhElgkDg2zbJkD4E3RuqwBC4I1r7D2fYVep/MVqxNw4INYvyHTp+Mn/zD2 + fselh8tBS/oVzvpO3ySvsNbfdKlqCVT68evkXOI6tVp+DqE0jkuvHgz8bCTyYfHHSNAGpSHRrySItdAh + ZkRD0VSS4TR0swCJgJ+5KDwDjHuWItrsyZfE58xGZE/mfp2ydo4Jf8ykxn6y/Ssz9yXreE5es99XiD9P + 1ol3+2qxtq4Taxtr/4GDzeJl+V/3Ps3+t4fwnuK4N7gzHJKlEwo5IpUJqlXP51pAk+NA1H1MjuPzx91g + 1nWQzaEYPjPs6bxGWfFX4BsB8cozCXhQu0LakSP4flDeG90tf5i4WcNoLyec83Ex59cM+8pZuRipe83z + rjWcZnlg5jrINBgK9BLivFPW/WH0bjWO6kH4GqFgPeyRANlIGanVAeoJmPsQUBD31Mp2iXcU9wGGpg2Z + 7R+hVxfEoBg9bi1/cLlJN80XGBfnCwKpthdo+XP2dIjWPq1+CBBNLgKTVI+A4aHOJjQGPBbHQcJ7g7K3 + xmI68IYWoVXKybHsd2QSjL4S7x+n1Zfyymla0WyeM+1C1RygpM6w1395QtnLUQgrrL+S8Ut84P1S39Mu + jVEo/QjJD7PM24TJmiw502SfaQrBtIfzGaxG0Zh2LgMCEAMBOCLeOD4nlOvvpm+TV/JBGY9eEurM2qcX + QMcqzwABSPbeDcW/TnytwM51Eti3UYL7d4j/2B7xdcD6GsJZjOK5VJr/8P2qFV5WUiqYryFGI+J9pl3D + DVYCpDDjuIKD7AmRP2jc03mNKuVPLE1AyY1EJZQYFN8g9p8DcqKHQJS75Ja+rXIicqdW0DBPZJxnhF+X + p4JOJOaBfIiF5Yx+jffP1xSTHP3ayvxY9iHsCZ55DsYBZSKta5DkYB77gLuig7JMezjL8HF+A70UMOKY + 1K26hu81C/kePzSvvQDGxfkA68nvP+EZjZ6k61Br/tNdarmQDDiWP9g1e+wbHuhsoj6D9zM6KCGWVuXi + 0ljslUZ2B8tH5J6xTfLLVFj74pPpnx/0y9kcGXNAztGCplKtvky1CBCWcbx/WiYcZKKNZ6JeGRq6T4Jd + 22Fl4mL3tkkw1gfrZgeUzFF83SNhXKpAol2fmbr7KgSAgtGwj/MVTHhU7w8+LytUrJEejSO+K3NQfp4K + aez/IqsksI+TsPS0IQwsJLp7jft9hfhFtFF+u+c2+d3eO+V3hm6Xk723yMmBe+W3Ex+Sk9F75Peit8rv + x94rv5e4TX4vdTtwm/x++nbFv8i8T/4Zvn898N9fDX4Hf/NE7mZpzd0vNxXaJTDSK75RkBHeaU6MM+zp + fALlUwXVRLcC33BcrMFDYsWHpI4JwfjaHoJi6cJd6YhJeHCn/FFsmVrOOlRrsFHO4Jycx52bGK39RkGa + 00LikvbK2WJIxgdBdnMwcHDef5lqlE+WtuA5x9T9r1NQCwlpABkNjOC+0Hgy7OnsguV/DOGBmLFTK404 + zskASdb+ANBB1uPffdSko+YDjIvzAYH8sZfoRtV5+elOYacpPhALDE0t7RFmmNaAAAFL9JV6xc9M0pEh + uY5lL4mcLBlOyO/Eb9GLQdf/BElA9DpNolMlmnu70zPfdKlqCBPJG/H+LR32oxZrNiQ93V8V3yE2mNkr + dv9eFWZ27x6pH4TSH2Scl4oeFk/2kHgyIAYLmAAw+ZNkx1/oAOGBgBtNaB34pxPN6jFx8iXYCx5EKsbB + KgGZhJV3gZ6UGUgCfJUzBthoBqRysog1CuMErDKGnHDmHG+DrdnaBCsPiIvlszeRtl8Xlf/3lpF0lFhv + 5vNaAmjlk+Xk3by8fR4M83ojvB4B0F4LscMSSg2KP3kElv9eyLKjYkX2i9UD4twDEnDskFx3rEX+cd97 + RIa9ToUIn2ERhsM8SALkOXo1DwKD93ohi2edWOLIOhoLGRsE8L2yrJgQT7wAmciSwIgmoepsFMpMw57O + Jhj3pzHJBG42LKMngF1bQ3yPw5RVcawfe9Gko+YDjIu1Dmvt8vXWcOSEPgTDQ6slMKmFpST16W7xM8kJ + DNeX6ZSNqacc4W+4NDWFRMhp2wtFop6KIjP8aZ0GnLgePoM2rknXy6mYX1ID7xPv/k1i7d4pjQc5aW63 + JpvprPmBwxBubTpv3hk4AyZNklZuOFNxi/JrR2jSk2Pe1/kCH7OcQQJCI51Sp7H/Xgi4mLQXvgblW7XP + ixVxnCsQiU+Vlos3HZUAlSKzv4d7JMgpkYY9nU+oKP/K2a6cbxJf7YYHuWAnu7QJkzfSLvbgEbF7DjoJ + mrg7/kPrxTp8SN6xfYP8fj8NBihU7NsEJ4RmfNpi+wwb8HAWf5yDhHAnSe5AIn81H0IEeK9rcsu1EsQq + pbQxEmWlNRqTJZm5zwF4IzBJ0CoNnLDWPr7epKtqHcbFWkf9UPsPaVn7lYGZH0ytwGlJTI9ETOrYPKXY + LR8qHpH/kVgmv6K1b7oUNYSzHE8aA1unUEl5oOzrVAgJ+xUM12ntOrPWL8QseaH/TrFaNol/10ax9+0U + z/6NYh1xSADHzeq8+cFLJED7zqdxyavazi40AsApcHY25UxBY9kTLYjsoPw0cef8yOK+1oj65L8lG+XG + kT3YL/bHgLWVhkXMPh4FuoTN+zpfMJ0A6BknyeGZT/U4RBj3gHMYPFT+fYfE7sRd4Z3B3QmBSHNoU93B + NXJT6wr5/wy8U0n3q8mgnMGdm2S1SF9Q84gYJphMh+QU7ifvo8RrP4mYZcR/G1smd5eOQjb2SIMSQJBm + 3H16ykx7WkvgOWUVR3308PPWbTdDoJt1Vq3CuFjLsFc/vCbwTOonah0Ua58haqlbJqVfBzjcptgrv8VJ + YFCoWu9tuBQ1hShn1AchdLwyWfLKxT6sxXxyeiQgE/w5hAwHgPy/+m4Qa/MmsXduE6t5i1g7t8Jy2STW + AXx/eIcj0HToDD0BR53BMzp5jp4ACEJaRLz8ZSLgkID5TwDsQjdIYFTY9Y+Nf0gI3p45hH2t15JP454v + JsQ98luJ96v1x1iwXeqTMCziUIHfY88MezqfQOVfIbZT55tnnQmXTLzkHeBd4Chm3g0SZd4V3pmD2yTE + qY078P32LeLZt1qWtK6Uv+h9h3MHuX8JNgdqlAsMJUKm8K6eTi4RHRwWqX0D4yLDGXjfv524T/dGe2Vg + 3zyZJM4E9mbaftYcQFqoiwLPxsS7+vtrTDqrlmFcrGX4c20a++fceCtb+weEWd+M8WleQuGYPJ1/WuO8 + r2bLmd6GS1FTiDvNO9irnm1lz0br1Mo4l4IAYtli3Cf/bBDKv2mN2FshrFrWSl3LGrlh+yqx9rHmfKt4 + 9l9OAirhAJafqReAgrCq/7wKyQVCACxYMZ4RkBx8bUOoXZ/olu+ll4NQ+eZFjsc1B87V1vT38cxLIEm4 + IxwYA9LkzcfFR7fw9P2cZ5giANVnm67/KstfQ2NU/iTIFeVP4oy7Y29dJfX7cY+2bxZvy3Kp37ZW3rZ5 + ufwXtgrH/ft5eonuIzsHnkoudbx1CXrpPDPSSvqag71P2PEyEZQnIBstNgCCrGRVSKjAVunmfa0ZQAc5 + umhQqJtMOquWYVysVQQeu/8h65mhn9g6WGMIggIs2vRQagiM/XoyGcaJ5CZ2+UreIOdZCsOGL2n2yMZH + q2FcADs/o5PpGmRyIKixxdNFS/5mAEIGAubF/lvkpk3fkUDLavFsWSnWlqck1AKhtXmV+HdsEmsXLJc9 + zUoCPFXhAHV1DuKCUwDGuxyLqIoEOF4AEifzvs4XaH1zqUeVWygTFz8+51jiU3IqaztuW8OeLyZcxBn6 + YPGgBPIxCaTxzKn0OTAm3Ye1+Z8DUHH9TxEA5rww94XEt+z2t/oPTVn+vCNKmPc2690Jbl0nQZJpKH7f + xrUS3rhKgq0b5Y4dD8t/BDHXcEAWdzOKvYxD+afqNUnwZSZysmTQsOe1BMrAc+wdkrHlbxM3yNISiNDw + oASSGQmwGsS0pzUEbVcNQ4VzLKyxoZ8EH73/IZPuqlUYF2sVnqH9P2T8VLP9871OfN3wUGoJdgHKfxQM + MdkvyeJXwdDZOAcfR+tia99Fdy7nk4k8iEAElgbddRDY6vovheXfttfLe3c+Lt5WCKh1yyXYtAaWyjqQ + gNUSatoswZYtYu3YLJ6dDgmwD2wX++gu8XTuVS+Ah5bPEBh/FCSJY2hJAJg0uYAIQIhx7ExK6lMcdkJh + 0SX/NfZ2HQEraScDfjHjv6auF7uUlDAbwED5h9mMCArASreDPC2AToDVBABnm0l/av3T9T9UVv49B8Tq + 2OPkyxzcrspf7wzujncH7tSW9eLdvFWCWzaL1bxerJYNUtf0hHx+1zfkbwe9sKBh+dP9zzMVZ2WFV17B + 9zIDsySuNV7WYUdeOUMyDGQLXxZvEvv2bEJC2fKU1BqGl6Xm2sKY7YtxxyN7nzfprlqFcbEW4X3ga1+w + Cv3HtTMTs+lhVWlPfcNDqSlkc2CyB+RzyV1yIW1rpjxbvmrsznAhag3nMtfre/0lv8f7/1X0OrkAAsNa + /3t33C9W00YIpTXiXf+0o/C3wmppeUoatm7AzzbBcoHA2r7JEWj7WhwBd2yXdqFzkgKPimcI1pDRCzD/ + CQD723sSSVmSxGcbbpMPZHY5sxIorJMzU+s/nzGS/jT2KeV0ARzu1FkAmjRX6FoYnQD5udhYaZr174kc + dVz/VP5de507cQh3Y3/LlPL3tK4XT8sK3KGtuE9bxLdmLe4acwJWirXpMdy5Jnms/Vtyth3Kv2TJ32dB + BIZA1lnuCaWqpaSGPa8lTEC20AvE6aFnoj71BnwuuUPqhkGMsgXzntYQaJBqvwroowBbvBd6j/sf+NIX + TDqsFmFcrEWEB/Y9F0gnnL7qOkKyS+xM7QuIulybvs8XRm7RRj+SYdLcUnmZ7V/nQ4wu5pNXh2xtVPS3 + +Ru0nvfV+BL5wt4HxbvpKQlseEqCG78vAVj91vq14m16Gop/lXg3PCm+rU+J1coWtCABEGjWniYntnkU + lk4nLJ4ekAAmPw3CGlqgBMB6plfnUmg5aKlPNg48rdaa9nugR8W054sIq/OPSyA9KL54UqyxTglyAFCu + XyfDaYmVaU/nEwwEwMOxy7T+SQBIhNvLcX/G+nlHKsqf7ZtBpAObV4i/ZaV4mr4r1sZHpW7zJqnbsEas + zcuBJ2V376fk3CCMChDz05kGOR8Pyi84lz9a+x4A4lw8IGfpxYBMnOj3ym9BVtq5BGRn7SeB0uqnLrKK + nWIXE+JPD0loYMdzJh1WizAu1hqsT37sdgiGE4wN0eUSSndBoOIBjNRAjHDsqAQiaU308sbAAMfi4i32 + 4gAfctxDI93ySGmNXOwPaj294HIyDPByHAeeJTyGCzGrYDMXsHD2n2deApuzXGoGY8tplgGCqJyK4JUN + avAZ9uz9DATPVij+R2CJQOETEFJTIBlohoACKMQozKydsFwo3GDhUNh52vc45U59R8QzyDAAewNQQIIE + VIUBjHs+n1CCciv0iDeeUXLzz/PvkclonZxOY7/LTXAWMk7zzCeWCLvXac4DQM+XNiDK+LTlLSdkahMg + 3TMqfYAJoAshCZTnuFzzz7Ot45bp/tesf5z9Tlj/mvgHYsy7sQfKf8dG8Wxbi7uDO9QCq5+hNd6pTasc + XHbXVooFMlBsu1WT/i5y9HYEyp9Jpmm/3m0+B95lbTqWImqHGHAWxstMWozh/cUhdzKQOwM+eaQIg2HY + GY7kyR4Qm9VUY1HxJqLieaZTQjHIXI7XNu35bAKEldMCwxm8V4akcd8DpcET1FkmXVZrMC7WGqw9azs5 + GaqBLpYiLhQULF2F6g0wPZRZhOO6TMmSUg/eEy55gSVfEfGOUnlFJDwckT9hr/ekT87Ccj4FgcjZ+efV + BVwbOQAUEo6gwCWkgOBr5WuSA1j9k7io5zN1kjn8Xij++2XpVgokKPZqYVQRSFUEQAUYLZkdG8TazVG0 + DgGw2vY4zU76FzYB0AEiUHDOuNd2+c+pBlj+Pgjq4PzI0r5KjFPp45yPJ4IgPVQ+rCrxqgfk32ferX3f + tVeCgQA4oYB5jjdNAOgBwN3YvUms7RuUAFhMrG12CIBns5kAeNetE3/LUxJqfUx+t3uJXODAHXbcwz4z + 5HjpWZQ7L5IIVD2fuQeToSkTfSobKSNZEfAnIMnhYbrUI2KP9sDShiwo0qPaJQ3DsLhH0jg3NeAhLEak + Lu3oJCp/6ihN/IXOMumyWoNxsZZgve+OABjfT7jZy+JU+LhMULYcqerTsaGGhzKL8KeSwtn2bPe7hBZ/ + elAFfr02MonLwej39TJKEQo0EpDTtPrjPjBdvKpwnFtcUv4ALYNq64Bf83LifbLf///Zd4f4Ni6HQILl + D8FUt2GVeDZVKX+Cyp+g1VImAJd7AFpfQwCcREAIxUo54AIiAJ5slyq3YHJQPjjc6gx7YhJoekmZBC5w + cDIkzvqFREjDXuoF4GjYvFcG019Ty/+S8r8cC4EA6BnGWa4mAHrWSQBIfssd/y4RAIYAQJZJmqcRAEUV + AdCqm82PA1uwvkHe0fR9+ZNEvUyW7/N41jfteVQIQA2RAJyHSR0pTm+RX85HPXKx7Bk9GH0YRDAioRKT + qbFvMPoaIFvtYewlZG4gmTbu+WxCp2ZmqfxhuEA3qY6CUag6C7rLpNNqCcbFWoLVsmo3XahU9ppwAcVv + 5xyLgZtveiiziWCamcpQYsUhkICcJiaGi0fxGpG7MwfllwMhGc/fJOdoQeuBx5mg0o0HnBHA1ZdhDlDp + BT+1RuFRAb/P+eVUKiT/ue96WQph49kBZb5lM4TPcqlb/4gSgCkSQOFUIQAVDwAFGSwaljRpaROTAI/u + Eqsdlg9Ln8oEgK1Q1fqnoCwr/wURAiiCqFJIJIfkUO4B3VN97lCIOjK5su8LFTG/TIAAjKeDcpaeAK6x + Qx3uw9czOEd8xvSiVQP7RuX/64jBfMJ0AjDV/Iekd4oA7HEIAPNjyjkAmjejJOC1BKBy30gA/BseFW8z + vQMbxNO0RT6541vyf+NOa5tuJhtfRuod5X/JEzD3RIB34WKs0rGwQc6DEOhcjMIylZ0fSh/AORjSpEDK + VO9wpTLgiITYLGjafs82HJJaJrF5GH8c/gVdRZ1ltazYbdJptQTjYi3BKnWfqE+A9XG0L6dlFXEIsNka + G6KrxfBQZhPaurLYof3d7VJWrOGojjO1Sr1SSn5FBZ3Ox09wlnedyFBATmONXboqA1fmEpcJgunKP+WV + 8xQmiSXymZ3fEi+t/43rpbF5pdSteUrsLSAEFQIwXflTcBEUZGXr33OA3QEd61+bnjADehCWkPYCWKAE + gP0qtMvhgPy7GOO0Xn3+E9qqdRGUAca9Gos+nfPia0vOMacE359KeuTGPJ479kUnrU0jAQvl+U8RgGoS + UO4BoGefJJh34dhupwqAzbPoBdherqCp3KPqMEDZA0AsIyFY9yjuHL5vwr9fv1Ge3PM1rTLRYUEa868K + 61XAcAxhemazCb6HqE/OsBxwyMb5YGMj25GZuCeUoRYs/nAeezeMu1RKq6ylzG3UcJF532cNJWfqLIkA + x31b0FMsCQxDZ1nD3SdMOq2WYFysFdQ/8f1HrZHBkw0cmUkvADY6pDP++8WfqQ3h4C91K0P1F6JSn+0q + C7C0fCzfKhdSdTJZ8DkXMQflD+v/3AAON+PAFP61RACqFT9jhxDSdM3RU7HrwMeg2NdIw5anZMm6J8Va + t0bqmIG8BYqdAsmk/Gm9bMPPd5at/32w/ingWAHQAeufyr/v4FRLYNZGa4e0ckvghaIAmBXMz7W0dEAm + YQ1zbLImaIEAXMjWX/YsFiTiHplI1slZVj2QACTDOgPh92M3lxUj9klx6ZlfQg3EeK8Slc9STQIu9QE4 + JlYvSwEPOR6xoyAB9JBNhQKcaoDpnoBqAmBt3igNG1ZIALC28E6ukSUbVkr3gY9okvEElD/7Aug9VzJQ + 9ghwXe++4ZnNNmAcjSdvkHOcL5JgcrQfMtOWiYJHz8tHCyBF+ZTKVspYylpvPir+YeynYc9nFSAAqouK + /RIs4X0VeGb7pI4J6iP9J30Pf+u7Jt1WKzAu1grCffvHPCls8BhbLXZKAJa1DojIQVhAUejFMj2UWUWv + BMsWTDh7TGzmAJT65B8kPwElio8BpXoqfZ1m51Lha//uSIMzVGf6RZgDvMYVqHF/v5xnq19Yb7/ZdTes + ikclsPlpdTku3QICsB4CqZnZ/xsdgUTFz5j/lOKH0KIFQ9ClSeV/EJeYrn82PKHy7z80lfxnxzvFm+p2 + nmn5uU4JTuOezx8EMkPiTfbLd/IrdH/ZBVISPpkExmkVV/Z9gWKSrxDwF3jGcP7PJ0M4c5bsS3wTypAK + Ec+YHQDx3JnodWk09KDCtKfzCVPnuEwAlOBWOgFWcgH6jojVvb9MAnBHQAK0Zwa9ZjtAohlCqyIBTqJt + GZvWi92yQeo3PCne9aulsQX3s+lJ8TWtln/R/W5tNnY+4ZAAvecVAjDtOc0lJtLsXrjEkY00irIBOZVa + prKTMvT/kfi4eNj3JT0gddoqeEBCOSjYknnPZxNMTtfny5w0hoFZ8snEVuosnOtg5+6CSbfVCoyLtYCG + ez7+bmu450RDjhvZI2GNsUBR0AsAUsCMy5pIEsJBZJaqL9nLVpBgp1m5t7AdB9sjrzLzP8PLhovXF5Zz + WRz2UXw8WEVUvMyGNl2I2cRrCYBXrYZXY7b8YsCSJVufkMBaCJUt68S/ldb+GqlvflICa5aLTYuDAqmi + /ImK8qf1stPJ+reh/D1HINTa94inh3F/Kv8jmg3N2L9j/TsE4JICKF8s057PJ7AsCKRwMPk1HdjCpifc + 58lko6McFzi0CoCCPOqRCzkflBFL0zzy+UyTeBO400koRVjFDJN42FFNSYCj/D2ssTbt6TzC1DmuIgDV + 3QCdWQBHxUNPAOdkHCu3A2a4jB0Bd21SEmBv2+D0BVASgHtINK8SX+sm8a19VDtxhraCBDQ9JdbGdXJz + 82NyQ9PjSuLPJWyHgFUIQPnZTCX/ziEmYOlPJpy8qIkRdh7Feu8SfZ8cE625DPh3H861ip9egGcGxZ/C + Ho5R6c59HxibJGRkyGljDTLABlZh6Cgr0yV1+Zh4R/pO+m+/q8Gk42oBxsVagHW4ZYhjFk2bXktQYlJK + aOw/XOrC5U7I7+Rv18zn07HasPJfFzFLfpark4lyQuLpeKNeRs4cv7uZWcZV7saNsPoVXHfc/vQA2Fuq + rP/tIAC7GPPf7Lgy6fZni1NaN2XLv5L1f1niH0EBSWFZjgOb9nu+gOSUn4VeK1oHf55+J4QbBB0E2jgt + YpZWQjkSjNdOAKwMmQ7+7HXB//9rwIEwpnXnbzk115oxju+Z6CnpBjnNcFWEHSCDM+OlYlkaXbxF/F3m + PSR88iv8XisGMh+F4isTwKlzUFUBUg3THs8blM+zfg4SAX5Ofl7Ai8+vRJjesKmZAHtwb3BnDuDu7AUR + YDhgJxMDca8qJIChtnJI4DW5AVV9Ob6+/QGZyDjhl1czPplgKDJia+Ld5WWCtQl2CuSZ+cf5e7FvafEP + H3bmRcDQChRZJmjY71oCvVh7N9dsSaBxsRZgxQ//KDgPWoEGc7i4pZz4Gf8fjsnnsy1yCoL7VNKZ0lXz + yATkIoQDM2/ZmIY9CsYLlmzZ92m5biNLjMpCBXCS/ej6d5Q/BRCVP0uV1DqpSvhT5U+3f9UAoCnlzyEo + FcFfVv7Vrn/TPs83VAgABf4d+d1yKtYo56iQKdCgYM9qu1Y/hButH0AnQ5YBhTkFZnK/LsKXEGNlQRmV + tcrvn/43yqBV/kv8HZJVliXS+zMBK+xcHu+X79V0Zq4AE3GGPPxKZljixbV/mrgFZ6BL/ByEQzc43eHl + sdBKAAwkwLTH8wrTCUCZBDD8pXdBPQFQbpyRwcoA5gOABDiDgUACmEejiYHTSECZhCsJqLqrFfian5Te + Qx8QyfrlXLJRLpS7TzIxs/o51SxAWH+ZWSKvJBrlvkIzZC3PB85KMemQa9Ne1xC8hYj440d/ZNJxtQDj + 4lzDeuj+B61Sz4kAxywaNrWWwF7vdF9yJCTdly8U73DcbLCkxnOX3G01ixQsPVr/TEzLQShAUD/ffasj + WOjiny5UKkl/VW5/Kn+6KKfa/UL5ew5tE/vojqpyP8ftPyXw2RK1SvlXBH5NhHVmAFOKC59veeYpnf9w + PmXLWZyNiYhHflaCQhwMa2korRyiugNjBROw0l4f+L9lsF/DdFR+7wX83enQfIT0DfIyFIPGXvHs2fqZ + SvtM8jo9w8YzcwU4mwbRoBuXbmh6APA+Nw1+CcquS0J95WFQVH4VEqC9IMpEoIoEmPZ4vmHqs1SRADuJ + e8AQ2BQJYDigTALa9oh9GARaBwSVSYChRFBBQk5Mv6+b8e/WrZI/Sr5LQwFaeop7Ts8PR3ybnlkt4Rzz + ZDjiGF//o+JdYqc4da9ffKlB8RVhdBn2uZZAAsAwgPWtr3zFpOvmGsbFuYbVv+s5KwtBUAONft4I3mFe + aMaC0vL19HrHsovj0EJ4noOwm36gaw0U0BzJeT4P4QCh8HeJOnnH1oedhj+t04RJRflT0FRn+zNJqUr5 + a6kfp/61vzbhr6L8pyt+YqEo/4q1RyzLD0oq+WXdW2GWM8jW2XSDXCxB+cYvuflVAROVZ1P5mj97PVRi + u9OguR3MOcC/0d9PYc+/Beu+GtqMiEQA7+/n8SVOjgKsxb9L3eC47yvv5y3iPD0N/J0xEAASD7ynO7pw + fnqPia8bVi69QkyEmyIBuPflcMBC8woRU5+HJIBnn0SA94Hkh59/igSAHHWBCLA8sJwYqCWCvGNKAsqe + AN7DsifAIQC4n1V3NrBuo/YJuG37d+Q0nsNEJiCvlFtQvwqrevrzqjWcytCzha/LhIW5I9ZIQaxij4Tm + g7woQoelQfD6do2ZdN1cw7g4l7A++vF3W6N9J72wptlYwbipNQU84BJYXmZITuTv0CQnSYe19I/xVtOh + riUw9suubBNQTny/K/Z/SULrN2gykX/Tk1D45Xjir1X+09z+jPlzshmH/dDyp3CvxPyrYr0q3KsE/IJR + /sRl7t6DcmthD7BXbhk4LO8e2ia3tW+S93eskre1bZD3H1wv79+3Vu7YtUru2LFC7tj2tNy+9Um5reUJ + eW/z43I7Xl8XWx+awvtaH5bbgfdte0Rxx/ZH5Y7dKx3sWSV37l0td+xfI3ceWOvg0Dr50N4V8v6jG+Td + x56Wu441yX/iTHkQE9bp68hiw5m5IkDxKwFhn/ecLf+/xI3ihVLzdu6HlbutKi+k7B1KkCAuXAJAVD6T + giRYSQA+M8lPFQlgoyCdl1GpDnhNnwDcu7IXbooEKAG4RAJCG56W8KanxLdhlRw6/Ck5jTt+Hor0f6ev + F4k4lnUt42wq7IxPp5cy4pP/d+FDYmeZDNivMte0vzUFEgA8V99zQz+1PvyRd5p03lzCuDiXsFrX7KMA + rWP8H6/GTa0lZCLakOiB9BpNqjkfa5BfpZc47jWSAcOhriWczcJS1P7hlvwfPR8Qa+1aCTevksD6dWJv + eGpKoGiMsWJlTCl/CCFN+Jum/Kvr/DnqtzLvvyzYL2v1Ox+e8ZWCn6ls4VlsFc3S1Sg+fz8w1CmBY53i + bT8gnjZme7NHAvZxJ/azFUJ860oIcwjvJtZ0Y//fCJtYClZJygSaqggasR3fc6b8Lny9B2Rt3wbx7Mcz + O+DA3rdR34O9a6tcf6BZflUIyzm2YuVQmZkYVhT1aHhCcx9yfhnt/zDOyT7x85wcgzKrNIRi/LvaC7CA + CYCCZ6T6nPBOTJGALocEgDjbfSBH3J+qEkElAQwHMDGQY7cr4YBqElAh7OufkEDLagluXCn1a9bIT3pv + lvEM7nwhqImoxmdWQ2BeEt8vq6nG4w2QqUH5WmGl+AqJeXEuPLleCY9Ql+HZNq+quc6AxsW5hJ069gLr + g+uVAOBSGDa1lhDM9kg4G5Pfz77dEZipejkbs2QCglSTtAyHuqYA4fyzIa/8NSyzm1pXSrjpMbHWrAYJ + gCDZCKGiigVfE5W4f1n5c2Z5JdufMX8VUDrml1ad0+KXyt+OX1L+avGUlf/rEoCKgDT9rJYxTbDXJ7EH + mS4JxGDdEgNtEurcKfYRCPGDzdg/EKcdIFBbQQKaQLq2rBPflvXiZXIlSBdfXw+VToz25pXap8FuWqXw + 4PnZLXhezVD6gKeVpWTOM9PnNoUdeA9QKju3ykNHvokzEZBznPyYAJk1nZcrBEv+zrMnPQlAIiQPH/26 + trz1H9kmnsM4KxyFy5G4DBNxRv70MMBCJQAEzon2Oig3QlJyTEyRgI5L1QHTSUClOoD3EM/2NSSgTAB8 + G5/AGs7ZZpyTtU/Jp1ofk5+nbpRzkFFM/DU9s5pCzCfnil4ZZ+UCc5Titvx+5r1Sz7p7tts17WstIdcl + daMpPFcOBDv2Y5POm0sYF+cK9oNf/EpouP+E9UxC6lNs/YuLYNrUWkIxIvclWuVsgeVdQc2orxzec8na + 7/T2KgVzNijf33Y/hAUsys1PSEMzSMCGNeLf8vRlyl8Hk0DIUOBQidjlOn9m+zPhT2P+1dn+UTb56RY7 + 2aOxTir/6jr/153lsEAIgJU7Kt5or/jijPG2id1xVDz9myVwBAL8MPaK8xGoiGnJYY9tKH1V5pWKC535 + /jqoWHpEhaxVvAAESVvFI0AlwQQy7dXA13USbn1SgjvxdesaebbzNj0TF2NetdrP0FKcdl6uFOeytozn + cA9iHpGhOrll3yMgACA7h1okcBDnhJ6Arr1O4lslSXSxEACAXURfQwL42UkA6DmLtCkJ4P4wHMCcACYG + VqoDKoRO7ySf73QvAL1Ja5eLvWmt2M28309J875PKvFnOarpmdUSWJXCHAD2UCGJZOKr4Fx+PAHi+Az2 + y7CntQQOMfKl8PVz0GnF/uPW137j0ybdN1cwLs4VrO5dw6ybDKUhAKD8Q7laqPPsd7o7lSiMcBHTMfHm + k9KYP+jEd/ID8g9HPqFu9Is4qGxqMRm15WwJH4n9rA2HejbxSsxpOUxrbpylPyQoOZb+gVlzMBHe84/6 + 36/Wpm/NRlifj0MhbRR/8/dl6VoIlErHsWnWP60PdivzHKI1uxvKH0K8GwK9yvL3xJxkv4rLn6gI9IUo + 2JnHQOhnK8d2NcmLCo2KjXFdWHLaEOkQCBOEOBu9TE1/KwtvZ8qbE8N9Q1QTgDIqZWEatqkmAxXwOVbQ + BJKxdasE8Xz/y+BNcpFJrJGQvFLA2SU5nHaerhQ8Z3z9Ve46+Tfd7xRrZ7M07Fon9n4Qn6MgkGx807Gv + TAAc0jhVErgICICiTBr1c1ZIAME9wD2iJ0DnBrBqQvsEQPnp8CCQSBLISolgxQvAu8pGQThHwXXrZMna + h0HwQBZb1kjdRpD1pofkJ9Flmq9EeTXOypO8R8aHIB+Ktrys4UufTnCc/jxnG+dSPpngmYw6MyXUwIpa + 8oOxj2N/sF8cEVzYJ/6RtNgp6IuRLvHB2vawZTzIlXG/ZxGhXALvsc/RaWxu1bWzpjoDGhfnCnWZ7het + YtRRuCOc9jf3D9CH90Ml78+1ib8UkQDXs3EJcD5BrktuHTsop/rrlZn+XZE12LCccHmodHXwieFQzyog + xH8FFj1OQQwWzUzsc4NQ/PwaF+lCpF7eue1RCIxHpaHp+xJe3yI+WJ4BWqTMAVDlD2FSrfwhcKj8tcPf + 4V2wSvaodWJzvjmFuMZyWd6EQ0/lP62ka0qoz0cL/3VgIgAqxEkAyoldnu4DKsBJABjLVQJQafU6QwSA + uIwAVGAgAj5YiP6WjXLX9sfk5USdXGD8PxqS83h1ukROO09XCigZLXPM+CR95G6nOyTIo+8Aq0WAaQRA + m0ORAJSV4NRZMez3QkPls06dHX5+3qFKToBWB2CfOsuhgMoIYZKA6Y2CeGeJTcsl1IT1LU9IeN16WbqF + 5+ZR+cDub+PZ2PIrPiPIqlMDkFWZgBP2gQy7kF8mF6uf4xzhQiKs3opX2Eod3/9d0UlcPNVbJzc/wwmB + 2JsxGGIpyGMYafWlmITyOEOcz5LDumGfZxNevodh6A/KOhiMdamOF0y6b65gXJwLWN/78v2h0tAJqxR3 + pvwVITgLuASGTZ1NhMgi8X58uR7xDadY06lMLlxK4nVA+rLfUkZ6PmfJyzkn1vkKLWsw1cn43BMAbTeL + C/2rTFDf2/l4UDuDnR+CcIeQbzvyKSj6p8XTskICGx8TewMJwGMQGhQeTVOKQoeSQFGpAC+P9dWWpbD8 + 1TVZseDKyp+KT63faZZ/RUma9nq+Y0r5VwtxjedCINEr0nfQSXqbiuNScEM4kwBQaHOvZ4gAEEoA6Aqu + zuOoBizFYLOTN7D5wJeVFI5n6R1yCKJ6iKadpysFk7g0zISv79/9dfEx9ADy6OfoW00ahTVL7xHOj+6R + 5gA4BIB7WNlP034vNFTOj96Xag+ShgSwL0oCys2CSALKRFLDAVPlgesvtQxWoof9bsGzbl4tDevwrFev + kDCnBuKMJY/e6fQAgXyYiF/vVC2RrCWdPvwTqRlIAr1aRMJaRfILkBM1Zope5z0PWnIs9y3sFZTrSEI8 + cezXaJ/UFVLSoB6VAanP1EAVmRo5kIWq06JsE3zc+s6Xvm7SgXMB4+JcwNe1raBxsEJM7GGwJnZ7Gpl7 + AsBJT4ECDtdwFg8T76uE74udsiTTJUvwUP/H0DI5V6qXSR5KHliw6jOJgJxNgwzUQAjgFEkIyAm/vsjS + RNbVwipjk5g/jt4M4f+0vL3lISiDDWKvhRBh45AtT0mg6WGxm3c6gkQt/yrlT+Fd1eFvSvnTfUtBVXHf + UogtEuVPVAtwVf7cA5Y+MvmvTAC0wQuJk8Zwm0WHvTAmr1ZbubXrlRCAtwj+DSJAIrBpjfxW1+1KCHVY + TxLWFs4HZ/hPP09XDJw1lhO+jLN33bannIZR+7aId/8O8R2EBUsCQFJUmQyp56ccOqo6O6b9XoioJpHV + RGCKSFaRAA0HlD0Bep6YFFgmARVPQF3zJrw+BgLQrN4ez8pVEmjeKA1bH5XrQPj/e+RG+VWsXq3sX9BI + YJgw7ZVxkAKJgQiYnulsAvL0bNYvEwxl6mhpnEue03yd/I/B63Uce2O2W0KQyer2h1EWzOWhcHtrggB4 + OLEw3YX3FsX30B94lv6O1oxJB84FjItzgcBI/0klAFCyvuG4+KFEfGOv3dBZB6z9JQxJFLPiyUMw4WI2 + DOM12ScbCyudYSfJOi0BPIvDyViVRP1OB7QayLI9nwnpDHoKdO3EBiZ9ig1pQAq+s/PrYq9bIfVbYSms + Xy6NzRAeG2Htb1wj3m2MGcJybIUgoWuRgkXL/Vod1yOzt7tghWgjF3MJ12JS/sRrCAC9ICQAJEaM4TKT + m9MQKbBhBTtZ3GX3PwkAlPFsEYAKPJthMeLv/QJKgI1iLpIwsnMfzgrHQZvO1JXBlosgx7/XdwM+K8/S + ZvEcwOu+bRI+gLOkiaNOFQCVm9MeGgKzyvrXPTXs90LFdBJQOUsVEqB3jbk2vbh3ZU+A3slKjwAlAU44 + wE/vT+tqadzgkIIGEHstH23BOVu9QTbv/QqetUdnQEwW66D4abwwZAP5Bevb/ExnD/SsTrBlNnsWQLby + vemAtVSd5gOszT+NPYK1PwKZXKLLv138uZyE6D2ugUZybBTnw3PzlmL6fjjfhrrOpAPnAsbF2Ybnew/c + bxX6jwfp/seh51jFECeClRgGMG/srGE0LnXpPvGmevG+OsSX78YrWGY6In+SfRsULOf8O5bTGRABbZ8K + psoSm5kRoFcJunJJSPJsOxuWCYCW3g/abldFvwwEQBUO3cbNT0toHV83OiVkWx+5pPwpWChgKGjamLkN + od0Lhca4JAU3Y7e03CiopmL+nOp2iQAY93cBwUgAKi1eqeA48pXCuuz+p0dlat57xf1/hQTgqsnC+nXy + 0Z3fVrL6c8b82XaVrn+eY2Zgm87UFUDr/2HBHWSoaRs+5/ZNEtgPsrOvWeroAaj0jACJnEoAzEDRVZFH + 3VPDfi94VCcGVvcJ4D7Ro1ROKlUPCqspDnGM8OUkwNMENK+Wui2Pa9mo1fxtnDPs/6aVEsb9Z57AP++6 + 2XleUK6cCfFKqgHf23Jq2rOcC0zCeHH6SIBIJthGOywXo0E9r5S9f5J7B/YqJgEajyM94i91ag5ZiI3k + RuY+iZyDizi9li2B+RxDw0wKHDhuf+/B+026cLZhXJxt2J07CxZd7cyqz3WpIPXpKFAcesOmzipGBrV0 + jSzOh/cToPWfi8lT2XWq+CXWIC8XcEDpNo2WY/5pj5yj9R+rAQIAlqwd3RJ+OZVulDNg06dTIbmpdbnO + DPdshFWw8TFZwljhxqckxPKzVgiPpjXibQUZYHIRBAoFiyauaa2/47KlUlPlBoGk/cyZ6UrFN6X8LxEA + 494uMFxGACisqwlAJf5PQc3s7bKQVgJQdv9rXJ6x+yskAFdDAjhD/mj7vSpQdfhPAsK1XM7qzJCvOktv + AUwkG880yr3bHxUbnzXACoB9+OwHQQQOgRCRSNL9P3jkEolcTARA49W/5vNh3SkTLJ+pKa8SSQDuG5ts + kVhW9QiwD2wXey/uKsN1SgJaxE+Lf9sq8bOvx8bHNQdg6dTEwEflo3tXyGkOi4pYkBFL8fxxFuIBOUMZ + Nu15zjo4zphnE4aMzq4YhIyN++RXrAxI1KsM/n5xA84MlP1Yp4RKsLCxT97CoMpu477OJkBG/OnyM8x3 + SpChgMyQ2B27ayIMYFycbVjP9v/UX0yr688Cg7NL2DASgGHDhs4yPMwo5QSqXEpsliWO8uuYHM/c5Qxu + wSE9G79eJ6jx4rBU5QwIATugKaYf6FkGe69rr3cI9Aspxv8tOXDo01A4zVA4T4iflucGKKLNT0i9ugbX + SGgLLbWt4t0K5aTKv0UFi5P0t8cROBQ8Q5dm+utQE1y8S65/EKeK8Pp1Am6BwUQAuD9TCYC0dpk7QQJQ + Lt2qJgCatPcWCcBbJQHB9Svkd6Jvn0r408SvBKysytdVZ+mtgOOOf5m4UezNG8XXvEEa94BU7t2Bs4TP + fQhWP70iGv8vNwFyCcBl4B2q3CPeLQ4e074aMRhKEZAA9k7gXWQuTrlHgM3y0j2Oh8nauVp823m+sL6p + RRp51jY+iHMGMr/lMVm27nv4+kmJdX5Sn5dWAUBGnFHvz9zLL7aQPg/Ln3F/eqd4nihfz8eXqfKfTNjy + f2Y/AKs6I/YwZHMpIcEE5XSfBAs4T4Y9nU0wL8GGLlNCAt3Gs6267pn+n5h04WzDuDibsFY+vnJZtPP5 + cMG5CB5NlOgXbx5MiR4Bw6bOKthv+jmWcfRKKDWosaWbC9ucBhWmA1tj4EAiNnaRdEiTAP8m0SCBzVQ6 + qyW08UkIAyiOcsa4KiASArqkGZtmhjqbjTDBiIqLVgbd/oMQ3GXLv6LoaJ1Ux22Ne7kA4QhofM2zW/7s + SoK4J1BoSgAqrtq2cv0/CdUuECtaaE3Ya7pkAc9mvG7C/m/Ec6iA318F6teyYdBa8bPD48ZN+HuPiIfx + 4HXrxLf5Sbm+6XGZBDlkj3i2/6WQncA5uZBrVEVgOlPVOANocxbeB/x7uvyd8kEb584DK9In/7DrNieX + ZOc28bI18YENYh9h7HqXcOiNp/+oQySr20WXCYBpzxcVygRB96LiBSC4T9XhgEqIibk5h3FfWR7InB3e + 4UqSKe52hWQqePdx7ho2PCrXNT0tv4DVz6Fg54t4lhGfXNDBUubnXjvwwACz5J0jO7QzYDDJyi3s0xj2 + qDD3IQDqMH8pJt7MoFPWjmdYlx+UGyKdz1tPP7bcpBNnE8bF2YTv6O7YddgoTxEHvDSgyRJ2dlB8TODQ + qoA5RrFbgrle5+HleaAGpT33NRV4dKebD2Xt4CzduJmAnI3iMkM47z7yGVmy/hEIgE0gArD4y8q/eq6/ + WqU64AcKquz616lkzDqmJUuBQ8GjFltZYFcRAFWIpr1cgHhDAjBE9z+sNO4d97Aq/q89FbRUC6hUAFQL + 6PKzuRoEN9D6A5lrfko8m/j6uPg2rhfvRvz+LSvlq7sf0HNCRc4wAEsA6f4/nwur9TX9PE0HLTDGZvlv + HeUPcL4EFL+SAhBQdp7zbquMjN4gnoP43Mf2io+5JJx6B4LkEoBfgyoCMHW2KgQA0LAJ7yKTTEnOmZir + Zaa4t5poir3GXTZ5mhQgAL5NKyW4/mEZOnavGja0sscz9ZAX80G+4T2mvXI091XoD0dGM9GOLdprIocs + 26u6jCFtEgE+Sy+M3euLQ0LdZ9KJswnj4mwikOl+0T8KZc+6/+EB8Y1EtUWsv4CHyex706bOIljy50/1 + SYDvp5DUfgB/lb5JD5/jJsPHqGFcSDaoYD+f8slfDC2VJS2rtNWsH5ahtg+FMHiN8i8n/VGAVOL+lWYt + mqxF65/ZyJqxfbnyJxYlAcDXlc+ve1LJ2GZ5JAmAxv9BAFhCyVJK7jEJAIUywP3nc9BnUaXAK2tvFdYW + KN2t+Ft47kF6GJqWi3/TOgkzBNC8QaKdH9PzMc6SVShrHd/LZlHsafFmQlgx/D9WDDBngC7ZDIgACUAa + /5fA2nu2PiyBHesk0ArFs7tVvIfw+dt3SYgJkZXmURUCUKX8dS+n7fdixdR+cG8qJADQ0Ft1omlPudMk + PXYgAXrWqvJN9I7zrpfPl8UywfVPibd5pby9+VH575HrQOpg/dPlziY8pmdeQ1ADJ+uT/zu1TLxFyKFi + SnxpyOt0P3TI3IcAqMN8sPi92X4JDNOrzTXmkg1JMNP3okknziaMi7MF64HPfwGM6CWrxCYJONzYFBWm + ONisBDBu6CwjyEtXHJSGEi5dNi5fyGzGwXO6m2kSoOFQ1hYCcp4Z3QW/tBz6Ilg/FHzTZmlc+z1HMTB2 + TKugovyplBifpguRseqjlTa/ECzTyv20SQmgAqkstPn8FhMBYHZvNQHgPqhwJgGItYs9wIluZQ8A9vI1 + HgCGW4gyCdBkwJlEM5M58XeaV0s9S8KaV4m3aaMEm5/G1+vl3w+9TRU1W8KSCGj5KsiiDop5M0msIAls + ga2Z2lT8WbzibighwOt/idSL1bpBAjs3ix8kwNqzQ/xHQCrbWyTYjj25rIrkcutf93Pafi9WVO7VdBLA + xNupUtNyKEDvKnN16AngHd4HEmBqF8y7TwKw4XE8I/ybTavl8OH78FxDMq7y7U0QwBqAE3Lyyudz+IyQ + 0Q0cEgT9obLbsJezCQ+NWuoyPCu+ao8bEICyV+clz/2f/4JJN84WjIuzBfvQpiHNFIcQ9WJj2GpXBUC6 + RxMBlS0ZNnU2ocK9yPaS/L5Xnk1+AkLPK2d5OSgkDQeypqANPSz5t9HrpL55heP63fiU9vz30AXYRCEA + YUDBoHF/uv0hDGipsl6dlj/b11KwUPmzqQ2Vm0FYV4SU7plhLxcipocAXpcA0APAMkqSq7JV5gzlAUjA + KsJ5BsEOj0H+3qZV0tAEqx/K2G4BAdm6Rm7d9rgmWOk5YfY/lPcUAWDlSPyNkwCp6JkDcCFn67x/XS+f + OTZxyXfehTO1STzb8Xk5wW7/NgkcwT4c2yTeHlj9bP9LAqBVJK8lk6Y9X4yovluV+zZ11pg4yfLJKhKg + 5405Ozxv6nViPgDOW6VJkIadcPc3LscZwev6dRJueULLBf9n71KZ4PPDeZj+vGsOMMJOk6wk/DKa/gTu + YY/Uq7c26ugQw17OKmDUaoOiTK9Wk9ELoEQAcoNhZe/BTf0m3ThbMC7OFqxc+0u6CYC/7CZRxUJhWiME + wBrulGCK4xyTsnRsh/yCtf6DFJS2jHPMqelQ1hAq2d1P7f8yLvvTElr/lAQ3PSm+5icdAgCLUBVFxfVf + 3eyHJWtMXqMCq8T9K8pfa/0vCaNqAUUY93IB4s0QAI1zV0IAKpChCNU1C4uFQpmgdcaeC9UwrV0h2NAp + xHGxLaukjmWdO/A3t+EZgwis2v9555xox0qcEwh8VrFw7Ty9W29ilgUrYSayHiUA6gWg4qDHCRbZ+UxA + vrXvq1Kn0wbxGXmugNDRPeI7BhI02OWQSpwrurKnE0rTfi9WVN+tyv4opsIBl0iAhlR45pgUyDuspBN7 + z7uNMzWVD8C7v+lp8WqjoKed6Z+bHpFNe74MhWrJK/nazwFglZO2mk745GfJsCwZ3S6efFb8iYRYY7iD + hr2cXZQJAL/G2daS8pxT5h7IR/EM218y6cbZgnFxNmB96pO3W6X+ExaT6zLOQdbDTEHKvsnYMG2ecNlm + zgGKnRJO4TBlE7Kp+C1lnKyXvQCBeZatMw2HspZwNhOWn/Yt0/ivvRmXfAMs/6aNUtfEOeGw+FvXOLFB + tqSlVUrrlAKDfcbZtpbKn1nsRuX/2jrbyrOrCKvpP19oIAFQZfVrCMBUDoA2AdrjVFMcoiLEPtPTQiJA + wcycCzYGqgIrBZSUXQU8O9eKnzP/d2wS/y4IfpAOH0kASMc/6H2fc57jfnWjqis14XUS+XB2JtJvTAB0 + OlvaIQEaFlPL3+mE+fcgyct2Pi71IBvW9s1i78frwW0SPLJbAsdYRoq9mXL/O93/KgSA+2na78WGX3uP + uD/Tzxw7KFbCAbyzJAH0ApSbBOmZ01AA80LWAauB9RLYslIa6AVYt1Zuan4YcmG9/IeBsLySWmJ85rUE + GjiUxSxz5syAjSXOB0g6Mptld9P3bZah8gF6TEkAnxlkp6PrnJ/Zpb4T1ic+catJR84GjIuzAWvtI+u1 + 2Q/jI7D+qTjostEYCTePiRwsBZy2obMNdnFiKUdwuF9+P/kh+ZkKSXyEwWA59oSvaxl4rxsOfU68ax4T + q6lFPFuW43Wd2EwOo+LfBmKwbYPYdNPuadYJf1NJf3T9l2O0l2X8szqDyh8HuHqv+AwXGwGoNDsyEoBy + FQDL3NSTQi8AidURCGPu84FyiSW7t7Hccs/lYEMXazfDBVcDEomD+vu1Ac/ezRKERe7ds0X+InGdnGFb + 1URIh0ZNgAjoGFi1/i1tI208U9UYAhgOY8IfqwbiXvUc/Czlkz+LWlA4q8XX1KRkpm4fzt6RXUoA/G3Y + pyHsCZWVni2HAEwpf8Kw34sN3I83IgCXnTvuIwmVhgLKoSeSAPbw4HnjHcdd14oMkH8SAD+rRJo4DAxy + gKWiLQ/JloMfh6FT+0nODEFJvF6//rusV/5F6m4JFHuhR2ISSGA/pu/bLMOfgw6jscQGQMPUdzjjlJF8 + fvQEANbKh1aadORswLg4G7AGD/1QS+sMm1ZLCOfxwIb75IPZw/JKBgeO2bFJW6fq1UKM7AKbtTBemwhq + SZZadOXknQkI4/86sNQZAbp2tdSvI+PfImGO/93G0qCnHWuAJX+0/umapoXKhjUsKWIskbPIY52aoV1J + +lNhwwoNV0hfBhXGtGJVEIMsAUoAKl6AKRKwxwkHQBnqfldAz0s1aLVNX7ti4O+04RnvAtE4sEu8OoCn + VT53ZK2cmoFOla9wPOsgfg9bCOP78zmcRxJkEIPDXZ+8PLF0qpV0VTMpdrQrn62KB8A9V1cA3kMC+6YE + ivvIagrcWb273GPeZd5p7j3vOO96uT9AkHNAmjdLqAUyoblJZQRbhC/dulL+W+w6fZbsxa/9+PF86Rli + Rz4nVFQDBAEyeJyDgpLOWWYjo7sTB1Rms3Orcc9qCKwQoC406cjZgHFxNmAnO3483YKsSWgzoi7pT39T + JGM7E9LAjNViyjqKdi7BuKsKX7yeSTRA+fvKkwl9Ovb3yOG7NM5nNa+AJbZWrC0gAJtx2cH867dACIAA + aEY6XdHMUKe7kEqq3J5VBUnVeF9XSP96GAkAY7L0oNAlS2FcIQGsrKBlxlK4anD/mb1dwfSfXyna8Ry7 + WsU+vEt8x/Y7pXedu2VH14M4I1fvwZog4YyG5XzmOqeVMMknziBdsl/Y981yeGmzKp2phlJURuwnwaqS + GN3WZXLJc+WerSsD94ooEwB2CtSzxzvLu8uyXe615qDgPF1WhbLBsf63bZC65seF1UHsCcDOgN4NT0rX + 0btUrlD5j6c488Sj5cRc0yZBfN6GMzGb0NJTegEgA1/NBDQXpSf5TZAixv9rIIT8JmCn2l8w6cjZgHHx + WsPzwFe/4GPsoxaS/N4ALOOwM13yV4mbcPBxEch6o1C4rJ2uBQaMy3i+HIr4ZXKJM8ULl3My65O/jF8v + b2v9vlgbVoq3lRng68TauFGTAOkCDDfBIoNlpm1D6R5U4Vy2zqZK/i4JaLUwKi5Hw14tdlRcsdUkQGu0 + y3XaU54ACmTuMaAlW2WouxawOy+hsvaW0en8Hat7j/g6D4mfjWJ69shLgxDuVN7Tz9OVIorzl1gqE/lG + p3QMGE81yCuwygJbV+CcbXJyGnDGLiOYIEO6H1RUDJdUCEBFoRn218WvR+VeMslsygvAu6vkEySAZwB3 + W9t5T3kBNounaRNe10mwiVVBIAPsE7IFZGDdcnlP63ch9xpV8Z9lG3E2P0vjlaSg/KyNZ2IWMcEGZ/TM + 4rydygZU7v2X1NuxB51O+13DXtUUoAOpC6kTTbryWsO4eK1h717f5h1lPMSwITWG+nynfCRzRJtjqGLF + oZtkqVTWD+E39wRAQwD6tVdOl7/WiX+4FPGjHxVr8xbxbVyrg39Y+qMNQJjwwy5/OyEINOu/peyahXVI + pUHhTMFRlfin1gWFC5VcWUBX4v0uHFSE8BQBILB/mpjFOHfFGzB0zFF+9ApQOJehfRbKUG8Bn8O09SuF + Cv5exoTp1cHf7T0oS/q2yd9HnSmW1WfprcGW02wYQ68Tfh+ntp2JNcrv9rzDCS8x65wEoNJUiu5/JkRO + 5ZY43iWXAFwlsGdTBKDiBeDd5R2uLg3kHedd553n3d/WJPbODeJtBlnbDLnQAlkBEqCTA7dskUzb3ZdZ + /GdZGVIOMV5MVmTP3GFiCDI4H5jyTJCY0GPxofQhCRXoBTDsVS2h2CfUhdSJJl15rWFcvNbwxQ79SIck + 5HFQTZtSS8j1ybH0k3qwdDoahNzpPA4bY2KMuRsO5Wzi1XS9Zl7/ghUJvJj4+lwuoPO972l9WLzr1kq4 + Gcp/My75llXi2fqkJv94d4EA7N/iCALGmsuJf5e3+r0knC+z/l0CYASTtXR/pnkBpoRxAvtJIsBeCtxf + Ayohgwr4/dXABxLgHeIz5HPFexhqk9+IrFJhfqYsyK8Gk6k6pyU2hK9DKHBHYrbsPPAJ8ewCAaD7vzr+ + z7AHSUmFAFQRzKmz5RKAK0eZACiqzx7vMM6BtgpmWI93nKGlSlXA3ibx79gkrArwtiwX35b1UPybJbgV + z279OvnktofkZQ4F4rNlhQcUrXo+8bzPpTk22DkHcwYmnsLweVW7T0L58z2CrBxOP+HkRpj2qoZAHUhd + SJ1o0pXXGsbFawnrQ3cu9RZ7jrM+knObTZtSU8DF+uPU+zSmKXSDpcNyipnTOGjaLtN0KGcRZ+JONYL2 + cudQFiUqljzfexcu8Brt8c06X17qAGt/SQBw2Vkb7j2w0REEdAt27i23+oWgqFhmFM4UJGXrbLqAdgnA + a1ERwmrNEpX9qyYCis7XQJvhzDD8IBu+GP5+7jCIB95XrFuOxr6kAv0VWk1VZ+ktIW47PTHSQScEoOte + +cSOb2mSmRKAqvi/KiCWp1VIZuWMGc6XiytAed+mzl/lzHF/eZd5p3m3y6EAzcVQErBJfNucwVSebask + wMFU6zeKf/MqaVj9iHCA1D/pv8UhAHy2DAPQG4rvX003XjoHcwU2Y4tY8jKU/2QmLJPl0tV/F78DZ8qw + TzUGtpZXXciQ+N13LTPpzGsJ4+K1hPXkN59gXN0qRiVAAWnYlFrCBwq7ZKI8FGUcyv8iDlml3pmTsy47 + jHMBdiVkOALv6VzGq13ZXhmw5HMHHsVFhsXfBIXfDGW/BVb/tnWa8OPfvkV8rZsksB/C+SgEQftuJw5N + t3G18qcA0Zp/Rzi/RkC7BOA1qHgBpvaLQoioEIHpqBCDa4WkMz7WykL4J/rEm+yQP0zcLBzgc46le6Yz + dSXgucPvoTtYLUMohj+L3ShLW5eL1QICQOu/kmDKVsh0Q/cdcTwc09r/Xna2gHkRw51rVO5gee8unTvs + J++ungHcZVby8G5XQgGcGoi7bx+E8t/eJIFdW8XaDjkBYyGwYYXYm9aKdyNkyMaN8uC+B+RlNYBwZlJ0 + tztyT8MB08/DLINJf5qHgq8n0nVyLuuEtiiz35/HZ5y+XzUGP0dfQxeqToRuNOnMawnj4rWEdXBlv374 + kRg+PA7otA2pNbRkH1OGySzY/53BYSPjxGVgrPMiJ1FNO5CzDrJxvJ+z+bIAxtqfDjSKta5ZGpofw6Vu + Ft+mrdK44QlYYyAAO3ZI3V4ofSZlMRmoDcq/bP3bg+X5/kwgqhLMU0JlmoB2CYAZlf1ywD4B2CclAthL + urqrcBkZqIImcs0AdJw1a8Nz7VD+/VKfadcyrnFOeuNZnn6erhCTaZ+coXVI1yu+5u/+zd4PCpvMkGQ6 + BGBreaLknqneEhqiiHdOnbOp81W1jy4BeBMw3MHK2VMSUCEAIPW657jjvOu880zIDLApFZ5ReDdkwbYW + 8exeLUu2PCp2M4yDHWslvIUjw7fIX8KomISB8bJ6QfGsQfwuzEAI6WpxOh9wBgKRoAC/ykAOppzQxKoS + CMy0vak1KAEYjTvP8eCaWW8LbFy8lggle36sH7bYJ4EacNHUJyN4L7B4x3BRCmmd/sfZzdZv4uepiPx5 + 6nr5OzDLCxSWPPg4WEwy0XwAHrqqwzgXmIyAAOTAzLMgJXEwcrzPVXu+AQYP66vpaYD9/hn7Lw/7oUuW + HejKrn8nSxxWAd2DdMkmYJWxrWjZ8p9S+tOVv4s3hUtEwAzd49eB6f9cCaxcVBr4u5JA7qA8HV8lE3mc + XZBaKm/TmboSsPuaxAMgnyDJOHucBvj07u9J3a61Yu1cMxX/1+zz6hwT5kHQ08RzVuVlMu2hiytE5a4y + xMq9TZdJAO92xQvAREyWY1ZCAZzTwDAAyzbZJbAsN5xpgetkx4EvihTxjNk2Ol4vF3OwunGGTGdi1pHy + qUxmW2pa/xdyfvnbzFL5/8Zvwj6AAI/0STDeL4GRI/g64TTkAbnUGnzT/s0ifFnon2E8F7zPYLT/eZPO + vJYwLl4reN57ZziY639JP/zIoGasTt+Q2YY/x1pRXI5Sv44h5gxpOxUTG2vvSx2U/52+3il9oZUD1kvX + 6RQBYCjAdCBnE6k6mQAR+SXnt4ORnx/wys1bnxK76RHxb9roKP/m1c6lZlZ2dUIWk4G6IZB7DztZ6RqT + hVVGVloRyK7yvypUK+O5AGuhw9lOHZHKltuZ2Jec/hU8yzzTpjN1BaD7XxtQ4WuWoHKc8F07vg9rcrXU + cdDRnnL8n2etXP6nBIDJkFRKFaLpEoCZQ/Wd5d5yj9UTgLvNO17JBeDz4HOhLKBMoGxgXxAaC0wchuwI + bNoq9ubvyR3bn5SLMVr8XjmVbnTCoKyGmnYeZh18HyAAjP1TNusaiOjpbFj+Jr1E3pM5ArneIb4E9mUY + hDMHxV8cEl+B92PuCYBN/YP3xU6B/uTgj01681rCuHitYH3jq5/1jYB94WB6WAZYC0kaUPx8P+zLHISg + 5PeeVEoC8R7ZnH7SaYBR5WKi65+ldxMprM2AAL1q4H2c09KckFzIWvKPjtwm1qaVEmrhoA8o/RZH+U9Z + /1Px2F3OmF8q/37HJcukMZ0sVnbJqkCuFiam/XNxVai0TP51qDyHtwqtM84ekUC2R0LJuPxZ/F1qtdOj + xZJW45m6ApyBEmD8VcsB0175i8EbxQcCyk6TdTthPdKyxHnzsPOhlpjCCqvkmVApuQTg2qB8Z3VPub8M + B2G/Kz0pKp0ptRkVSUC5QdBlXgDIDsqQcMuTYm1ZJy+2vUuf+YW0Dfm3VGXP9PMw69AqgECZANA7UV7H + +T6f9cmqLEhMskMHzlkczQvSGYahFwYBqI0kQRKAHp2G6y1Ejltf/dx9Jt15rWBcvFbwbF2zzxqJ4FD2 + ij0C9lULD2AYF6MwpPkInB+tyRj5iE6T+q3sR3GYyocqBuUPsB8A22DWyhwAWv/jGZCUmBdkxZIv7vqm + eDc9JaHNLO2B0tfMf1r/+J7NP8ruWC3HokCGNUDr30nIcpR/RRhTAbmK/9piusKfaWilTQ7EDs/xg/E2 + FZYkrucgIDm0x3SmrgSVeQEXkj5YhpZkjn1AAs2bJbCDJWY4c2VvkyqacvkfrdCpPJMq5e8SgBnENAJQ + yTdRks/9rzSl0q6UVb0BKCPoKVQCANnR9LQ0lGcFPLDrG44RhOc9mbtOJnXq4xyjygOgvVqYi1IhAcA/ + zH5C7BSUbAlyDcYdPWF12X4JlKB/NAPfsHezCegavjcNR7DrbPOK3Sbdea1gXLxW8PUfeI4f0q8Hsxes + DB/YtCmzCB+bERWHJAAh6ckn1TXEKVKN2bj8baZBmeQkBKY2AOLoU8aa1PVVxTbnEmC9k7gEHODyH/vf + 4Vj+zSvEs+ExCWwDo2f3P46GVevfsca0Dz2Uv5b9lcuxtGyMAoKCwhXICwb1jP8ymQ5kYEPySZxnx3NF + sigxeremnacrRQZCF+fvlTKx+MbeL0v91mYJ78aZIwE4sG2KcE6dN8b/6f53CcC1RZkA6L5yn8teADve + 7VRhkARUQgFVbYIrcwIoO4J49W9i75Dlcn3Tevlvg8vkFeZ9ELGw+UzMJkgAygnZk4mAQwKSXtFQLX72 + N+l6qc8kIOM7NL+LLndNvBuOipe5X6Z9m0XoOHzmI/CeFgcl0HdgzKQ7rxWMi9cKgVz3S4zBBPjhwb6C + 2bmf9qcTB8EG/QVYwMUsDgcJQJt8OrtPD9hkDlY2552noWiZNKVDMKD89eAB0w/kLEOTE2H9k6jsPvoF + sTavlfrNJAHLJcAyLB3F6lj/jMV6DuOiqzV2qModS+sfB7Bs/bsCeeGgLolnmuc46175P9J364x+5q9M + 6LmZgUYuKY+OBD4NYnwhXi/Ldj4FBYIzt2OV1LPZFBPMGG5iAuBU/B+ClwSgyttE0GNh+gwu3hzYl2N6 + b46pe8x9LnsBWBaqMxiGcO/5TCq9AeipqbQJ3oFnCOXva1kDGbJGQpwVsGmjHOz4tMoa7YOSroEQQBlU + +EoC6AkAJlJB9UrxZ/cl8fmKR6UuRxkfh6GHs1eKSWB47j0AnIhrF0FGUp34vo9e6JdMuvNawbh4LRD8 + 8mc/5i30H6fLQ63uQq/4MrHLNmMu4AUB4AXxD+NylPB1cgiHpE/ak99Ri4YWjs5KZx6Axv3LiSZQ/rUQ + BjjN9wiWewoX8m07nwABWCHLNq4Wz7ZtYrVAGFcmsVWsf9Zik/HT/afWGBvGXN7rX92HlfI1w565mD/w + ZqFYM1FZmjki/z1Tr0LyPC3/PMNHVx8C4L3Q8cEgxb/X817HfbyXFuQaaWSrWVr/bP9LjxPHIlfH/9OX + LFTCJQBXh9cjAESFBOhdZwgmCqUzBDlQ6Q2guQCtjhdgN+QGSUDzSjzTrXLTJsiSLU/KO3Y/IRc4RTJR + L2dJBAxnYjYxJYPLngAdRJVySK7KbPzsYOwByPROCaXoCaN8x2eH/vHXQCt6HYkPMkJS4in2Ux+9ZH/2 + 03eZdOi1gHHxWqBx+feXq2LRpgdQtqMQTum59wDwQNiZHvGOcF4zLJJ0SnyFlPxO5G65kA0K55tfhIVN + 6AHjQSu7/i9mHYY5l+AQDMlZ8i8GbhRr41OytGUFLmqTBJq2infnKsf1T+ufsf+pXuxOx7+ppj8QxhXl + r4KiTACYGGncMxfzBxBy/lSf3J7dM2W5jUeuExm25JzhPF0pzlf6CeBOHDx0t1hsIYuzFmyF8j8IJVJJ + Ni3X/zuVJo7178lcrqBcAnB1qBCAahLAPb1sj5UQlptD4e57Ingm5ZkRnvY9Yh/ernMblAAwFLB9i9jN + m8QL6z+09TuQLRvkT/rfBeuf8m/uDSD1aFVIAOUyDTPmASghoId0ibwQux2yfUj8yYzYOcj4EZy9XLsS + 4+r9mwtocuIICAB0IgmAlY1Iw5MPzVpDIOPitYDdd2SM8X9PCQqHYYBiQUvuTJsyqwAh0YEMDAXgfdUX + cCHwEMajYRmvgVa/bwgcdhKRrfs/Dot/hdg7wODXLofVD+W/DV+Xlb8m+VQGsdD1r7F/Zv1D+Zet/4o7 + 1rhPLuYPqmK/9STZILZHY/er9+oCE7cGIBgLrJuedpbeApzfAXKcteSjOx4D6WQ9OazGfducpDLmm2j8 + v9z+tzr+n6EgdhX/NUUVGdC7jTteyQVQqBcAz4UygbKBMoKygh7DXVskuJV5RJAlGyFTdoDUNa2RfQc+ + 4+QA1EIO1BtgHOdyInI97kSv1OXxGTM0bCDnCnGszX0OGj0TdjblhAFKHXg+IG19h2YtD8C4eC0QGGr/ + oTUSF3sYlx+K1pfP4AEw7mHYlFmEI3xAANgDIDskvmKXfCS3Uy7GA0583XCoaglsvHI22Sif2PZ1sHNc + Us74b10nXl5aXFgd9cvYfyXzv5KJzSSgWMUV6xCAitIw7ZOLeYTq5K8MXrNdciL+AVXSp+nVGmTJFAQj + hbjhTF0J2ABIkgH5m4Qty5pWOJnjO9fizHHs7BZVKIz/wwAoe5wg5KbF/10CcA0xjQAoSPbLJEBlAJ8L + ZQJlA8kaZQWNBhoPO7eIv3md+LeudSYENq2Wj++8X85wEmDccbHXMjTXJV4n92ZbxS5A30DBevM9OHND + zv2o3qu5AMMR6YTqRE1KHI5KKNE5a/0AjIszDfu29wW0A+BIDB8SCgcflhn3Vg4f2LQpswgeBhVCuW7x + p3lZBuVIBtZS0icThgNVa7iY88u/HnyPeNm4Y9NT4tkM4btrk9ita8Xeucmx/qvrsMuxf158dQNSELgE + YGGhmgBkO+WdqYPyKgQ2rfVzhZAwe3syBuGYuvocAM6f4F15oe89YjW3KPEM7N4g9r7dYh8FASDpLJ87 + zTzXXhPlc+cSgFnFVDigQgB475n/QxJALwBlA3M1KCsoMxg23LVBwzk+zgnYAqNiM0hA8xr548F3OPF2 + w5moKXDeRcojB9LfwB70iQ+GnnoA8t3izWIPDPs0m/DksfeZGJ4LCQB00Whc6jP9L1JnmnTpTMO4ONPw + fvHz9wYz+MDDULBU+iQAJXbbgyAwbMpsggRAXUE4EIHUkDLE30vfqodbu12ZDlUtAQz30JGP4lJug/W/ + wlH8LRvE2rVevLsYh8VFBqM31WF7U2XF7yr/hYUqAsAGQF9Pr9US1vNRCENaRLD8mbg3Gbv6aW4MJTDW + unH/Z2D575bALliLuzbi/O2A5b9NrX8dNHVZsyncObqiXQIw69A7zn0vkwCtCNCEwEsdAjVng14AyI6A + VhC1QL6sFWsHp4ridWOrHD12j9MG2nAmagokKTjzJ5O34V70OAPomONU6ILsx9eGPZpNaEUC9I+3AFAX + FQckiGfj/fLnPmbSpTMN4+JMw7PikZVBKH3G2j0QSOp+KUXL1QBzCxU+RQ5jADtMDcrbU4flZ3HWNPum + ykhqGQxT3Lv1WxJqgtBtgfLfvk7srWDru9eLxRasjOe9pgzLKfvTYTFlIewK4gWEag9ALiqDmc/L2Zhf + LsZ9wiYuJADns7DcZ6CO+2IWrzFLbm99FMq/Wb1O9s4NOH+tsP53ORUnVCrVraZdAjBnmDoXlf2nDGBI + hrkZmgtwSOzOckUAZQeUv3d3M2TLOpC6NeKBnKnbuF4+tv0bcpZj0Q1nopbAkkASgL+P18vbMwe0Ksap + BIC8Z/6XYY9mE/RGMDdOCUCOa71aiu5Z+fhKky6daRgXZxrW/pYe7XQ0zOY/jLNj49mVqQaGMXgKTALk + QRjSw/FAEtZSHIIt6XXa/RoOVS3hTxI3SGjDSvFvhgDeCrbOGOz+FqcPO2v+tQzLGfer2b5Vmf/qAiwL + BBUKhv1xMQ9xWQhgSP4kdbNMRkBq85Y2cZmIslzKadxjOlNXhJRH/jIa0nNXvw0WYutm8e3dKAGWnLZB + kTCxrO+gsdukSwDmBpfOBvafngDKAsoEzQU47Hhs2vc4JODIdmncttUhAVtXiLe1STxbHpHwpifkP8Zu + NJ+JGgLDXMx1YYOgb6QgG3nuaIyWoHyLc1+G7nQA7BMb91Tn0kBH+ugROLRtyKRLZxrGxZmGJ3L0eQ97 + Hpe69UMqASh2lxnP3EKz/wvdTnlMvkM6Ul/RTn9TgyVqHIOd94q1eaPYW550Sq+2bRB7f7OEduLCHtnm + KH+6YTkCdMoKA+NXAkA27Cr+BYcqAvCezB4nYSsGpV9wevdPROnZKjcDMpypK4NXRnvvEo6aDrJ97LZW + 8R3cIMGj9AAcdMJOsCovxf8vEYDKe3QJwByA957nhKHZiheAIRoSNcoKegwhO6y2Vqlr3SrBfZQtq5QA + WGwKtGWFJNs/YjgPNQaQXPa+4KCqo6mvawhayQ/2QAfxTN+XWQaVPXWhJzMI3QhdBAJAXelNdsxKIqBx + caZhlwZOqNul0KnjD+nuYPmD1kAaNmU24SMByB8TXxLMq3BEns9+VM5nl0zVkRoPVQ3hoZ1f0mY/ga1b + xN7GSX8t4mcbz33bxHcEl5UdvpiEVRbCl2dhm/fExTxHFQH4TmK5lonSo8WW1pIoe7Xw9avlPv5XA46g + Xnv4C2LtZP4Jzt6uPeI9sFY8B3EmQQBUmcCqrMT/PWmcvSrlT7gEYA5QIQDMx5ryApQHBVUaA0F2NB6G + TNmzUxM7rX0bxNe0WRqbN4q19Ul5ZPeXjWei5pAIyrlsnfwg9XFNutNWwPleGH1z74FWHVjqwWtEQrkY + 3hfkc6ZfAs8kfmLSpTMN4+JMwnPvfbfa+baXvOyxzw9d7JclnIFMN0wN1GH6Sjj8eB8NHJiS7JfTqZCc + z9SpwGT7X+OBmkUwxjrBZkSw4ib4fph4A5xLBbSfO1t12kTrehAAXNKd5Z7/lXn/XWDyvbDCBg+Xa7Dx + Odl3mlPYOCjGsCcu5hNSUs/mJoUOsVPt4hsbgEBP43vesT55rvhB+dUQh0VZcjYNIsDEv7hTHy1vopXr + Bba9Tgbklzp1zZIzGvMPKzmmVcVucNfh3HlZJsa8E3aR279Trj9K8nkEyuRIlfvfCTu5rv8aAl3ifCbp + Lkc2TCUDkgQcmEoGVJlSNSmQMoeVR+cTHjmf5ChyJ19KZ/JD4dKDOsmzMu08zTritpzJ4fzjvP5l+m1l + +dcvjfR8lOY+BKDt8GGIhUkEOK0wP+jMyim0Hbfu+/SdJp06kzAuziTsr37902rt5/t06AFjL/Vsf4gP + WQud5lj+Z2HTg9keeVdyj5xn8l8qrAe4JrJc6aal8MWlmsyACDCGW+5+9S/7b9S53RUCcNm8/3Lsv+KC + vZT8hwtQGcFKK8CwJy7mD5jDwkFWmseCV94pIkwrB/jjzM1yHlY6SeOZPM5PAsI6Zqs34M3kuGijn1RQ + TisRsOQ070SiHqTUo4T03ww1SF0z+06s1u5x9n6Sz71yXft2sbud+nJ1/7sEoCahXhh6AHheoBz1OVVK + AkECtCSQyYCUKZQtkDE6Xhxyh/iX/cuUSGrYFOfDOVNQuFC8KrvK52iuoKHclEfOZYJyLlYv9flDEkp2 + qZKthfOnrYDxXpQAQDf6C0POBM8S7vTXv/FZk06dSRgXZxK+tSvWs/UiE+yCBTAufEiduKeJD3OvgOiS + 1HKQzKA8kn5CD80FWDyO0sVHmHagZh1KAICEH4zaJ2dphaUhxCGIDx76hFhNqzQBS5l51bx/XtypzH8I + 4ctKsFwCsGDAs+vJQWAPlztrpiBASr3SkGqTd2X3yDhbRSdh+cMaO1uEgM7iXLMcMIZz/iY8AFo1gP+v + M+BxH85wFkaqQU6TSOBn/e0fkuDWDRLavhYKolnzTzyH90i4fZd4emBJlgnAVOUJlY1LAGoGfAYVEkBZ + SBlBWaFegN7DYlOG6IyA7U5joLIXQJONIXsOHf2INpg6mwlDNoEUwjgRng0QgFqYlVLBePI6laOfyUFG + 5hgG6JcASY9hT2YTqgNL0I14Bhb0oh+Ens/DGukRe/XyNSadOpMwLs4kvMd2J60RKP3UgITzIADD+HBs + BoQPTVJg2pRZBSwSXwEKMRmXSOrT6uY8nwxpCKAWCAA7/TktN/F+MracSdi4aE7s9tPbv6dNOcjIlZnv + BENn+1Uy9krs/zIL7LUZ2MY9cTFvoB4sdhMbKUiI5zgTEX8J34MIrC48KhKhEvdqyIjZ0BM5nCWS2wiE + NcnAtPM2HSQAF3XIilfOQ6A7g38CDgEAOf3G/m/B+t8kdTuhFHZvE++BVrGP7BabHQAr7X8r5LPK+nfP + Xm2gQgBUJvD5QEZMeQH6j2hJoFYEaHtgkDvImCkCANnz6V3f1nNwDkYJvUTqpdQugW+OYF5z0GOFMzsZ + Xabf78rc7xih6R4Jk4wa9mRWASPMMwzLP4+9Zwkgq9KYmzWGtUM7r3klgHFxJmEnO35sjQyJneiTELMc + ofiZ9MB4Ry0QAJZf6BCGxKD8buIWPSzjqTrR0b81QAAmyvPWVQjjMJ/T92TL30OwL2tZWWX9b1SGzvnr + 1tGdU/XXvMiO9e9M/HMJwAID+2oMR3CfYtKY4kSxQdwrEIBMVv5x/v0qiM+kQ3IhUq+W/wSsNY3rRyCo + SQYMZ64aFOITMXzNxljs+sfzh9/JEMDfZUJyw9YVYm3dJIEyAfAdBI7txfk7IPYAlAitf1qU07L/Xe9T + 7aBCACrJgJqsyec2eNQxIthEjCHFcntgDTXS6IDsuX7rGvk5B6WBYNI4UWXLV5yd8RoIAdBrytfxeAPO + v0+ezd4lFpPtcl0STM99DlqFADgN6WCMMi9OCUBEfNG25006dSZhXJxJWIWe4+xH7Un1awmgKlu2PMSH + rgUFFMgM4f0MSTjZKX8ZXyIX6QHI1KnirRzkuYTG1PA+9L3wvdGtBiH8T7tvEu9WZuNWWf90/zP5r23X + VP21FQGbj3ZeavtbpfxdAjD/4cn1ij2aVC9APUc7c9JmukuTnP4Olvp5KPnTTGqNQABGbCUA59K2XIx5 + 3hQBGE/7tW2w5qDkyveB34MEvBS5VZW/tW2j+Dg9bnezeA/ugPVPAuB4n1T5q/sfliXdzBXl7xKA2gGf + BePOlA2QEVOdAekFYAIxjYlj5TBA2QtgsdKIyYBbt8jx7nfhfHhknJMhcT40ERDGSi3MUmFuwjiJa9Qr + 55L18qeppRpj53wMb3bukwAJu4RXjgPGXSYB0MqMEoxm6E6TTp1JGBdnCp4Pv2/Z/5+9/wyT67yuROFT + uToBIEBSpEQlKlrZytESlUmJQQzIsXMC0MhAN4DOuXLsAFDy6I6+8TMa6xvN8H685phjy+HaHvvaHo/t + 0b0O155nxkmBJIjUAftba59zCtWNIzF0d3U1cH6sp6oPGkDVOftde+397ndvOPunWdmoXwqLn6cB2AJY + CwJ5EsDhhpQSYRbF5YfkDenjciVm7nUyZcpiu3IQAArtSmgKgKspM7124uSHsQgbdSHa0b/nRJup1HtA + wFy4bPzDaV9FI3+Lnb+7B7v2oQVD02yr3S/BBDMAIPNMj3w506rp/ysZr45MtY//MYrnuWiOt55/GQRN + AUB7m49VqHhgLYr+GURox5mPi6e93hKfbeI52iTezkPiYQMgCgA6EPvkCfdb6WBc519eYCG2nsii3VzP + ApiNgSDcWEPETCKzANwG4BajnQWgCNjfJCdPfUTt4Sprk/BqBitm5L3a4DHVK7TbiCHPZypkJhaS29PH + xM9TD2VwDJpH4s3xzVgf1lA6Hg1kMaAxNfiM921vxE119q/LAceLy4XQp97/biqbMIxMGwGBrFgAqGAH + pDI4BVAVh5PEZ/xA7gCM1yMz3DOCEdPZMtXuZFQlB/dvmQlgBiCDSA6E/LVDXzXHc3IRdoCEj7SI92S7 + WbBjnfs3xrpAwIgKrfS/HYHZzt8VAGsfYW6jTSByoBAAievJmql+OZl7SGTUmmdBW+b2ERy+bimBBMUS + u472VoQrFpHPxqo0optLMDsWVJL/zKGvIQLcpfZnHGmVwNF6c/+/F2uK7X+5l+wKgPIG7UVhPReKgEIW + ANwxyqOcp8yCYrYUZ5BBAcBnTu5B8PH1I1/RrNCVFLgJ9qY1AHoSwNmmSon5SNi0f0DrurJB+UCkAd99 + 0LRJp3tSQgTyEO/Kw7jnEO98z0x5mD0KJuA7P/SuNzr51uWC48XlgnfLI5udvvRqwnZ8hDrCbD/eD0l9 + 8utmgVPEZ5119splRE9ORlVSYBG9wFeQ72UacHKdvIDPt7F1N8h3O5Q4jJnHc+ziPxbsULGz8n/sLMgX + Rk5FXyQAnO6LizWKcwNSlczIunRMjPOdEoxFJDQxLr8XuQdO/6WL/F4KPAbINCprYq6N4xocP0Xy3yRD + EuYESnUC1ukTbj8xVcztJzqN8dNmJMnMRLH9uQKg/IBnosGBnQEgbxBWMaA+07NWMSC5Ro8ENkiweYdU + HdgJ5097qZGrcTj/LISibhutPn/yWDeLpy9P4ufxsJ5UaEzeL6EMRGkONlkUDBGO92Y18cBX73PyrcsF + x4vLhUDjrnbHL7WKKH7YfPg6HSo7Kn3Jz5lKMeo3jTnqgfEsnUCXDK2+5vEa1gMEhOe4/3t0gwRad+rk + PyVfLf4rSv9bvdf1OI8rAG5q+PMD4snHpCKJiCbbA0c7LrdnuuR/Rqq1A6CjTb0ieFUEcNuApwd0eww/ + /8rw68TDqZMH7eZTlgDoPmw6C/aUpwCIW9tPrgAobxQLADwrWwRoMSBrOaxtAJ0samcBwD1sABVq3y4/ + jDMz6VeHy+1Ts4HU6guAeRYogjtZCyNjIc2IDSQ+Kd70gB7BK3cB4Nn++DYn37pccLy4XPCfOZBw+lKr + iWLnT4TYESodle/F32UJADO9qYVOTJ86GFUpoUdpEG1xiIvuq4GE/03/O8XAovOyLzeVOMmXBTqMvora + /vrs5iu2ALCM3em+uFibCPIYII/Upk/rNEsjn5BfSuyxtrGWQQDEfTLH1yibCQXMIlT8vOv0J8RoNaPA + BRkoHj8t1J9cF6B0LDbhugKgPKHPhgGRLQAAPUHEGSIMKop7ApBz+NzZF6Bti/zrkXuVM3kM8BLsYz4T + 0oLqG+yp1IiYDd14BFbGQ7ouvp94G74j/ABg+4FyFQCBjsYuJ9+6XHC8uFzwxk9/1+lLrSaKnT8R5ECc + 9DgU7O0qAHT/yi50KoM9LM1CxIPyPD6b3ROgg73XD+4U70GrO1cx+drpfyxcb6z3uvO3oi9XANxkyPVr + Ya0vhygtGxdjIiPD8U9q1LMsKVishTkVxhWaUeA2GServfHIoxAA9Wb0f6SoAJUV4zx9wtTxIgFgrzlX + AJQn9NnYAsASAazj0D4iw7AvBhccLnYKXHMMAuAwuKejXQXAfghCU3R6VABcS0MALLal1cC46fzZlOha + hLUJhvx1YgO+G+wxed0PEOXIjf6BY1NOvnW54HhxuWBM9D/t9KVWE8UCwC54Caf65AWOR2XqilXPGjmB + PKkaFxtUiaFFXCBypmG1fzsU7ScPP6gCwHMAixDkaxy3Wv8WkS8XrjfRd30x87uWqZG7WAImeYY4IoF8 + D55xFM51TP40drcKgOXoxDYfC5uFsez/n/JoC+G/jt4O+9tjFgD+jAyUOXbaykDB/tz0f/mjmBdt3tAG + ThRyi7YBtCfAUXDPgTbxH9gunzr8NfCmaW9mwfJybD8tA6Ie7UfAzARtmdkA1gFsSEKg0jYtXixXbvTE + u1d0KqDjxeWCMTX8jNOXWk3YAkCNXA29T96aPGyqRGAGUQ6NhZHPyzknXTJgcfE4y6XxCtnUvll8HSBf + nf73EuRrtf0tVwN3sTTwvLAxMS4hDgRKDMtr0x0aoXM/9moWduxkS68A83Geo8b7mJkVowD4Zv/7Qfy1 + 4mvfYUaBdgbKnj1hnf8vtJ6mI7FI1uk7uCgTWHUABW4kdzCDQy5hRgfBBTsDFrYBwD2+/RAAHXvl7tYt + 8hzrADRwMutFFtvSqgDBE/sAzIPLacta6A2ef08CAkaPAprftWz5MTPwfSffulxwvLgcCL7v7XcaEyNl + lwEoEJFt5Klu+VKyTp0+IyYOONEpVuNsfIJXJ6MqKSwS10JAv/zp6Cbxtu4Tz6E6c/+Vnf9Avtqus4h8 + C8V/5W7gLpaEIM8L5wf17DCzWbtTj8BerEiMR/4W2NIrx7W42TiI/yb3dK/i2uPHHhB/+z5E/zz+xwxU + qxkVMjoctNL/dBo6ee16lHWD/en550XXXKwqbuBHcoj2BDC3ATz9J663Bgb3+A8iADlaL4GWXfJn45t0 + 75+Fy7p9ugynUJYKNiXibJdrefyMoM5uqPZIYrdyfzE/6vd2uCerCV925CnPu9663snHLgccLy4HQp/+ + 4LvLMd232MC9yTOyO7nNbHiizhYGQgEwGjIbnzgYVSmhg4lAwiRenq39DyN3idEK0oX69h5C5AUlrpW5 + vUXky7PXWLh0COVs3C6WDg4RCSbP4v24dhQ7l/oU7ASRDgkvsgxpWJClHqXCKwXypWRAXt+6XSpb94D4 + 4QS4/398v2mDLBKz9/+t7n8/TwCYDVAWXnOxylicBaAAYDDBjA5PFg2cFG+PtQ0A7gl0kIsaxWirlWeH + XiMzuUqzEyA4S1tHO9lUCcGW1br3z/UQZVdLfKa0IY3xx8SXwrqxvme5cmSATfQ+8b53OvnY5YDjxeWA + 7+GHH9Ce/w5farVAAiL0YdvHXaACI/HPyWVEOS8y4o+C8NKVIM8aNWInoyopxjnGFQtqzJDnQMKRs5+R + YPseWdeMRXcS6ptHr4qb/xTS/yBfu/kKQTHm7r+WHL70qHbpM853i3dqUAJ8JpMQaN/q0cYfZuevVw9j + qkdPAuj7XEr+R2aTpl+fy1l7sU429QpwmYWnRLxGt8h+a+geMdqbxN/CfvBtEADtiAQPiffscUSHXRAA + cP6jiPzHIUBjXGOwOcCT5rrDvbAbz7D7nHYCTeA+DIp/ok+8WTYLS+PaAIjvBO5TbsG9dFEC2DxhO8YU + M4ngEnCKHgkkx5BruOVI7jnZrFmAwIG9kux7v/xLmjMnYHsZOl6rmHoVMYt1cC1ebXE61gU4/mLKI9HY + L0koge/D7amiAukbslSrjeyAeB966CtOPnY54HhxOeB//LFH1oIAYKHcr8Q+oqkhPf/PaFvb7cJgHAyq + 5Ijhc1EAQJhchnLt6PqCnr2tAAmrANC91yNmas46emVOXrsuAFTZus5/dTBNR8dz+kmpzkbNXv1wfKH4 + uARjTN8vDT52AsxN4jmPyPszh83Ua7xKrjKbNWZOjVwK2AmQhahzPEKFf3vgzHu1+U9o/17xHKzV8b/e + rnbx9XSId/AYbJBHULvEG+8WH9tss+FKFrZI5GCPcO4m+L7frGFAlOPHn3FGO0eHV+fwd3MxMeL8jg73 + 1MXKAs9BOYMigBzCOQ6FYsBO5RpyjnIPOMgLAcAtoWNnPiwvpmFzehwQAiAWdLSpUoKileOJ55KwX+VQ + j25p/Zv4hySoW1RlLgDYHviJxx5z8rHLAceLywHfnp21xiQibMcvtTooOP8iAcCWl/819haQmw8G69f0 + EDvuaeOTcsgAJIMyY49tzRjyheNf0+l/XvZf72wWo+uQeLqPampO23bq/j8MGwtXv6MrAFYXE8B0j/gn + h6QiPSDBTKf4pofEey5jVe+bfb9fLe7I9EtFHoICzvZ44mElOfaOuAZnPZ9cBhGrZ/89JoFiPXz82P0Q + APXiO8QMFGzwBG1wvxi9iAiH4BjGECHGzsBpwA7TveJPgcAgUgh/lrMLFmYwNqSj+D38bjYpgWkONQLO + nZHgJERBvjyGtdxyKBIA6hyZBSCn6DZAl7nVyNkAzDyeahXjcCsEQJ08cPw+swCQvAmbMVsCL7KnUkMF + sZX6x88skGUzqz+Ov8Xc3igSAES5CQBu6wX27W5w8rHLAceLywHfgcaTOvrX4UutFmwBoMoWD16R6Jfn + E+tgKKZiZeX/TBwOlwUsZSAA2IZVG2oQab+8/tAW8bL6n0dwulrEOHNY9165KDVFV9h7XbT/7wqAVUEg + A+efTUkADs04BxLNJcWXTktlFs9qAoJtYnxp4CSxSThcONj/I/oeuZTYINcgYhm1X8otwx4sCJQnZK5k + KuXHY5tkY8dm8bID4H6mfxEFnoIj6DoOGzwl3kE4iJFe8UQHxBuH00/gs3EEOJHjEUU6dGAC0b06d2Aa + tsqMwLlj2pb7NpLy1Hkxvtktd8VwjxzuqYsVhiUAFFagVLwNoAJAJwQehg20C+dA+A/Uy5sPPwqeuu70 + yV0LbGk1QAEAhz/PUwms6YqGhaPVn4utFyNuCoBiriw3AcAMmf9g04o1A3K8uBzwnO1IlFuV7w0CgIVy + ibNw9j6ZhWKdYdMTGIk5QKU8BIDZghXvQcIvxNdJ4MAus/L2WLv4O7H4mIqz9v+vCwAYdtHxP/3ODvfD + RQkwFZNgEg4wD6f3zWGpzvdJRRKOL5sAuUIc5AeXBINCYvqs3Jbvln+OIuJPsmEPyDdWtTyNWJhRgKCY + zQbkR+N3ysGeD8iZrg/IqdMfk5ODH5Wuvk9L1+AvSdfI56Qz8nk5Ff2SnIp/WU4lvyKdqa/KsYyJ49n7 + HXEs9oCc+OZn5Vj6QTk5+nkZSePvTzwqX43Btsssg3grweaN6wIAnLK4DoBbj1ZToEBHI7BXLjKYAlfx + 9AjnRzjaVKmBwImFiTzVxemAKgbiPjGizFRZIqBMBYCO0j9zOOHkY5cDjheXA57xru+UW5WvkwBYHz+u + yvAqImzuDc3yFAANJFEexqtnukHCzAD8t/F7EHntEf9hUwAEurD42Ptfe6/bx/8QZdKo+R3L1ahvKWTF + Ow2imUZ0nOmT9yUbpD7/hHRObZHjuQflVPr+JWGYDjfzFRlOfNY84gRnfZHn/2HDWo3tYFOvBFfTNeZx + 2AybAFXJP2cR4eH/UHGMV/YFIJgloFBgzwD2q+BeqxYQ8vd+npAeRpQYrZJLmSrYOOcXVMrvjK6X152D + ozlP4eR0T12sNIq5UkUAOcXaBlCuIefwNEDnIW0E5T/aqG2B/2L8djxXRNx4tuXQClg/QyqgJ1g4/ZL8 + Pq9ZAUPWRfAdyl0AEGOd33byscsBx4vLASPb+1Q5jPstxgIBwAcPvDN6UAtWSGIkLz0yQqcbr9DxqYsN + qtTQKWx8n/TIrw69XYwDu8VzrFm7//mYguu10v+jZve/YoNmKo/f2RUAq4dwAs9hKi6BHAXnoKxPD8pQ + 4ityyRJ1JKilQKI1cjEekstRk+Sez4StI6MsZl16FfZMqkY/J49T8QggoylujzGNeoWOnZkynjZImeBn + ICg+rsUB6+fFKPw+nMUl/PtX8/i/Jjzyu2MbpOrcOOz3tGu3qwibNxYHTMoxVlMgo4+zAY6L92ireE9w + PHCT/MfB14M7AxpQlUUnVXI4JxTCRudiARWpFKTs+/LWCMSL5QfKVgBMwIfClzr52OWA48XlgDE9+Kx5 + zMfhS60SFhi09eA/Odpq7lXBKPTc/ygiERjMNRCrjgV2MKpS4lrWNFoabLb/veI9uFOMk1DbJ9q1+E+V + +CAnrxWl/y1jtr9z2Rn1LQTvNNOoeC5474cQoCgOTJyVgxNfFxmDI3R45q8E7HJ2kURLx4zI5nJ2HUQB + u59V4nXpGYCLMa4H2F8UUR3XQ8xnOX6/XM1wcBb+DGDKl1jw9/F5Fjh9bVC0CPg3L1oFhs8m3ixv5Mkh + 7kFPxyWYcb6nLlYeNm/YnFnIAtjbAOAc5Z4zp8R/pFU8J2shAJrlyW4OBQrKZQoAotgeVgGz3I6I8DQM + xOZoUOaYzcL1qxDKH0bwZ/uBshYA00PPOvnY5YDjxeWAL9P/fXYoc/xSJYQnj2iC71kEZxe3WMbMoy07 + xjarg72MSFsnRoG0riRhMCAmRjmLDarU4HlaiZqFNZ3dnxXvkf1iQHEHTkJ9d3eY3f+GusQzhoUZvz53 + 3TTo1b//tzpY/OdPwPHjNXiuW2pSSbz/lmw8f1b6hx/Qhj1zYxCgsLvnp1iAikgez5oNVSS+9GN8q435 + TEBm+J7OgN8nAkEbwftx87TCzCjeZyrk/8i8We5g2n8iLmF1OqM65MjpnrooHZRDyCXgFOUWcgy4hpxj + zgbokMoTiKTZDOhwq5w+8348d59uD3F8uZNNlBJ2L4w55VCPcj0nWs7jdUtks3m8kb6A349Bk+Un9Lvb + vmM1kYE4WbMCYAKOyOlLlRL2NsTPEABNY4+qMTCS0jOjKgBAyGUiADRlFTMFwIHTnxXP4XYxjrdJ4BTU + NwUAU3Ejp8U73usKgDKENulJj2q1vn+qV25L9kkghZ+nh+S2c2ekO/11mWPHPtjcZUROz8MZ6uhd2OGl + cqiiXiIoqmeyIZmNrdcpcT/O88SNWZR1gccU02F5Kr5BaqaSsg6OxZvF/ZmGmJ0acjMAZQAnAUCu0ToA + ck/PEak6eRic1CTGkTY5dOZDEHrgTTz35WhEtVQUBIDOsjAFgNZ54XVv5Bs/VwCUwxa23v+1JgCMd7y9 + 2p8deIqdzpy+VEnxEgLgZOQragwsENEoJUqFCELW9P/qG7DupVlR4bbOL4hxqE2Mk23iPwMB0HukIACM + SK94E1CL3Kuz0lmuACgDUMFPgTjZ9S8/Kp7JPqnJn5Uwj8ZNfkuqJnulO/Ml3cOXeKWmK3XfMlYB0lpo + C2sSXFtw/jrKOmvIPL7XC6kwRAH+LO7TyJ/OX6PK3CgEAGx24qxUsWnQZML5nrooGcgh6hjBKeQW5Rhw + TUEA9B+Tii7wEJuSHW2T3V2fgu2y9oNbQ2WQQbUEgNmUyKeC1J4HcCTywJoQABDDz/jvfSu+gLO/XQoc + Ly4Vxgffe48/ixtaDqcAFgkA25CpZLmfFYvCYKlWGf0TMF4aDbMC5SQAGDF99tT9pgDobBcv+67zLC6P + 5IyxALBPDdkVAOUFXyYuxpNDms4OJlIQAwnxnxuUTekBqdKtAdjh+RHpTX/WnFSmzr9SLuSqzDkQDjax + poAo/0UKGRXU62R2DK9YZ1cyVfKfk3fLnee7ZT0jyvyYBJ+EvbKnQTKD+8R+AatPwLc6FgsAdZbkGhYC + knv6j0voNLsCNqsA+Grn/bBfrxZ3LscplKWCXK5F1PhMFJzM8mpmN27ISPQzZk0DfYHFm+UmANgsi9kw + /3vevdHJ1y4VjheXCuMzH36fL1MmzqdIANiGbKey+PC/Hf+AqkGtqFYBYBYsacRSBgJAnQKHuyT88vaT + j5gCoAvoOwoBcAJK3C4ANAXA9fS/KwDKAdXsdDeFyCk3pA4/lEybxVUT3UCXhCbGpSo1Lh6KgMzHredd + pdsBz00utIU1CXyPH+VqZC4alrlxHg+sxDrbKL8bu0Nel+vEuoyKn73/2TGRzj/7pHY/q8Q1f668iohv + RRQLADtzSq5RzmHr8YFT4mcvkq4W8Rxrl/eeeFwdrHaOdLKHEoOnqFikym0J9lQxt3lNAXA+9osFAUCf + YPNm+QkAvH7sg29z8rVLhePFpcL46qc+U44CoNiIVQBEuuWpGO6rLQAQfc3F4PST5l4RFaOTUZUS+rkg + RGZiIVl/cpv4WQR4ul3T/96e02KMYhFiMS5QsQVDdgXAaoN72mYf/EHxw8kR+lzYwe9cREJY3OF0RIKj + aa0L6Mt8Tq5oujKg21FONrGWoAV/8YA8T4dAW87cLr8bfatsnIqovQbSwHSPpv2NeEq3SjjiOJjuwevC + e+liFQBbtQWAwg6eKADIPYPgoB4IgNOt4ju2X+48tscUAAk2pVpoC6sBCgBt7AYwiDIzbAjuYob8+8Q7 + 1Afo9ykKnspNAGhH3fs+8WEnX7tUOF5cKoxHPvcABUA5HKng9DEzGraMmE7SUrF8+L8Zf4M2hphjDUCG + RgLyhUqcoVJkqsjBqEqNa1GPXI1UiHFyj4SPdYhxpk2M/sMS6MMiHLf7/y8UAGrErgAoA+AZ5BAxcU8b + Dp7bAXwN5iISzsDpP8me+RMSTI5JOI7ff3JUerJf1sLAeQ7gcbCHNQUIAKaCr2JtXUpVyP8Zv1M2TUfF + iPaKAfHDIUZMcVZSJE2MSwXuU4gDhNLcHsE6dbynLkoGcogVPBX40xoPrNwzhFdmI8FJFADeY83aM2I2 + VuNsD6VGylcQADPgdm7tsj8FRcCvp95ofg8re2rzp+0vdHKl0z0pIXxZfAZupd//S/c5+dqlwvHiUmE8 + /sVH1ooA+L3468xpZywWAUnNJMJlJwDmQaJXxivFOFUrFccPie9suwqAUD+IkoswCiMuMmDT+bsCoBxQ + lcqqgvfBsYXjo+JNx2CTEABZkGhmQPzJcTG+1Svh6VGd/W1MDUj1VJ+cTX1NZnLO9rCWwGOAz/P4X9wn + v5l+nZn2p63i+/ry3XovwiTa8xncp3HxZoZ1KqBnirYLG3a4py5KCFsA2CLA5k9yDrlnuEcLAT3gpOCx + A2IcbVcBMBNfr07XySZKCgiAWauYlse72etFG1QBv5N+7doQAHz/0H0rMhLY8eJSYTzx4GO6z1kGAkCx + 2IDtlpbjZ+Vv4tVykef+YawsFtFMADtHcZ+IIqDYmFYDSVO5/l0MAuBIh/hONpiTuPrPSGjkeNkbsAsH + 2PYIBBH1BvncoPJDkxFZn4qIcS4tm57sloGRB9UG5iOwRZDYpWzQLAplbQo79I0vspVVwHwmdP2cf4JH + GPEZSfxRNlvxywy3ALIBeSr7Btlw/gycfEwnAjLyZ2GkzROLwRMThOP9c1EyvFQA5Rs+LMbAWfH0nED0 + Xy/GoXb5ewRRs/ZUwEX2UnLQLqMmp5vcbl5nNorcr9un2kEV38fiT12bDvdiNaCCGMLYePQBkIGzv10K + HC8uFcZmUwCo0Th8qZIDD7TYgL0J03hZyPL38Sq5xLGVDgLA3H9fZeAzcO/qr2M1UNeHxHuqQaf/cdEF + Rk66AmAtwnL+fEbB1LD40xCkE/3in+iRDfHTZlZgIgKHeUS6Mo9oBkggUp+DEHw+bXXmoyDQQtVF9lJi + MHs2kw7KXGSdnvP/yQQjP/PUygV+VvzZf4zXSPVkQtaN9WkmxD+FtTc5IBWphfdisQggHO+fi5LhJQXA + iMlFKgBOIDg5sl/+JlFpCoBFtrJq0KI/UwDoiQDgMtYTuV+LGfE91CcU8afTvVgNUAD4eRrmsa894uRr + lwrHi0uFsfXhzfzw5XAjbSIpNmBbAPAoyz8kK820P5UhnK0aCRuV8DhgmWQA2Ljiv0XXqwDwdDZZAuCM + BDh7nUKmjItYXNwIm1BNmwSZWnvdWicw2SXVeIYhbh1MZyV8bkB6Mp+VC3E42fQmJbDLzABY55tXHayf + GavRkzMssLoWrZAX02Gz5WrcI8+k3iTr8nEdE2xkxxD9g2DzZ6U6jTWYTyy8F5YYWIBF985FiWFzCJ8F + neOiImpTAJxRAeA5wTHlB+QvY+sK5+9XG2Z3VwqAQJEA8Cjn/0O8wjzOqBwK+7whgFp0L1YB/BwqALY8 + tNnJ1y4VjheXCmPbI9u0B0AZLODFAsA8AmhtAeDh/wjRvxb+MQMAZ8ue+6xiZYSlJwEWGVTJkTT3q/5w + /A4obAiA063i5RCOwdPiG+uCEi/vYywursO2w2Jole85vGbiEogntTAuMN0nt6eGpYY/67jfURlIfdIS + qSAzptcTm/De72wzpUQsLBeZoVCxfP2c/9VstfxG6i65A9H++qEe2OaoVJwnqZ6GzaZwP8bx3SzBuhi2 + 8y+Gw/10UQIUCQDlFjyf4mPU3tGTykXe3uNidLaJ53iH/FF0oykIdd6DZSerBHK4Fv1BNKsA4BqCAOAx + xR/FggsEQDGHEuUiALyTeAbwqU6+dqlwvLhUeHY+tlMrF8tg4RYLAKrXxQLgBZCoztzn0RUQFwWAjlKF + AOB0QCejKilSMF4Y7Q/G7hYfW26eaTcFwFCX+MZhvGXeyOJWxwL7KwZtEahK8hlBwOF95XhSgtEEnuNZ + 8WQQUWX6JBwblMpkjwQn4zISf7/MksCi62V+1JDnJlafYOejAfnnfI0e+5qDMDHP+W+Q341tknvynWKk + o+JP9UHg8DgZBGvqHL7XgIRSiBpTlt3asAWAhcX3zBUCq4DiDADBZ6McagoAz5h5FFAFwOkD4KgO+cH4 + a0yxWg59VMjh4HOT3zmlEj+zuDsekAtxnxijEKSsA7AEgGY4LNsrBwFAMJj2wqc6+dqlwvHiUuHb/cQe + D1VLGSxYm3z1ofLh6v4VDJd7P3j4lznOlIYKY1ADsQTANbYEzpRBGivFz2bI06NvlMDJQ2KcPSS+/qPi + GYbh2qkrK/1fIEn7vrsCYNVhO68C+JwskEh9CTyrFMRo9iScZL85OIg2moW4y4+JB060KpaTUBS/PzUi + fYlPyRXOhsiWR5+AK3xNhXQMsZ6xTt8mvz32RtnA7w/bDMQGJJCFrSZPYb1FQLK94otDEEROij8J2+WR + Mn5fwhICem9+lghYdH9drDAWCQDbhpVz6DTH4fwZjPSdUG7ynzoErno9OJQ1VavPn3MWn9Ppk9tnyffa + 38WnNSv0AWYjNRYCWjZYZgKAwbR/z+ZaJ1+7VDheXCr4YctRAOjD5UPmw2bqBw9fj/slmBry6nQyFQAk + VmA+s/opVjayoAD4/si9Ejx1WIyew+IfOCa+YSjvWJ8rAMocSpiW/RU7/gK4Fw4n6E2BQHOIkDlCOz0o + wUQPon+IgemTeM5xCUQRSceO4s9j0pv5gjnzf3y9o82UFLBNrhkeWbycrNB5/hv5fQfg8CFstMd/vEsq + mSqO9UoVHH9wFN91FPcnSeLF97dhiQFNxQK8VyyCIgr3sQw45ZbCSwgAI0IBcApByXFtCBToPCTfH32T + JQBWvxDQFAB4T4DfOQnQzEzgPbhfMwD0BeUsAIDgvq0NTr52qXC8uFTww3qnxstisdrEUSDeYgEw3HWD + ALiWgYFQAMBgykkA/Lvht5oCoPvIyxYAZTHO8hZHsf0VbNAGnlslnKKRiGp/9fAIBMBYv3hiZ8UfgbMf + 75GqEdhqpkdCkRNSAXs14melKnZa+kc/C/t0tplSYjbLLn8VsFGP/FbyLrkncgTOv1N80TMSGD0q3tEu + CXN0bBTfd7xL/EOd+j09May/CBw+vqMOlyHUnq+LADsl6wqA1cNLjVNnFrIgAHqPS7DrMLjq3vISABaf + czu1WACw7TZ9wGIBYHNpOQmAcN32Zidfu1Q4XlwqykkA2GpOMwCIrBhl8NynB8TEaVYX2AMAhkBj4dEQ + NRw4XKaKzHkA5p+tFrQ3fDQk3x25U0KdMNT+g+IbOCy+USttZadQ7e/pdA9clBxKlEVQ2yPU8VvCDc/P + CwHggz16SaRjZwvQtCSIKQwb9Y0iChvvFf/IIanqwzMfGZO7xg/IcN9X1Uau8Pw9IvDnJ0C6UZDbuKHn + 7y+nll4jMJesMUUyMDcekrmINScj7pdLWCOX+Gd4fWr8Dtk4dlCMwW6pGOwSb+9JfHaIVE6MAzyDJjhD + Xl+HT4lnBEIBQpYiwTuGSJJbWlybtqjlvbII2bZvvZcO99tFaaD3n1xKziH3QLgFEEVzW5IdAf2nj8iv + DL9FbcfcXl1oT6WGznUpGkpU4HjgYqLStE3Yn/YC4PfhGi32GQ73YDWwpgRAOW0BLHiYDgJAo5efIQC0 + AM8yltWC9iKIBeV7Y68xBUDfQfEMHHUFQJmDz8JGwfZSeE5KnKbzpx3S6WkEouNVaZPFgAMdOC7hgdPi + GTomwaH9sqkfDpQtoAeOyO1DDXJ8+HOwj0ptuXtxLCgXJqrNbay8oQ7ayaZeKeYmvHIxFpAXYYs/4YAi + CAxWU/+E6yPlk6ejNVIz1C3rTx6RYHeHGD3NEhw8KoFTeM+JlRb0+GoPHAV/ZsQIMWALAooBz+gZU/hE + Wdti2bUrAMoKBXsuCIBu8UG8kZM4n4QC4N+NvEntxoy2b7SnUuIGAZC6PmHzhUQV1tjaEABragugnIoA + C6RRZLS2ACDx/DhZbRoEIhm2irSPrpSVAIgH5X8fv0v8nXAI/R3iHTyGiAkG6wqAsoVtd5q+pgPTyN8i + TT43Rrt0dpyoxrGqg3CGdIp9FmzH2XNcAnD2Rt9+vD8o4d7Dsu4M3nMG+5l+8fbvl/6e90MAVMnVVEBn + CMzmQL5Mey7HMUH8O3PRENYGiBPOfxYiYyYbMLv/YX382vDtUtPTJb7jB8V/DJ/pVLuEzrZK4Hi9GKfx + nU5DBHQRh67jzGExOEGOHS35HfF9NStAEUQxRFEU6zNnz7sCoKyg97+ISynWNGMFgaoZgK5j8tToGzSo + Mo8CLrKnEoOfYZacDsHKn9WOrT/7caLGFJ/FAqCIS8vG1tZaEWA5HQMsPMhioyX5MgOA6OMfYASaAQBM + 47AEgPW62lABACL/jfHXiI+E2tcBo0XURAEQBVm6AqAsYdvdYgGgka3l/BnxqvNnmpxOEBGyh06RzpGA + o9Sjn310mrh+DL/beViCnXWy/mijVB+BeDi+V8Jdx2Ws5xdkjlX4rAsYNOTF2Dqzv4WDTb0ixCrlp6N4 + nQLg7HWtQCxfS2+S/zy0STaebpCa9mbxHmyXwNk2CR/bK8ahY+Jn9H+yVYwT+8VzfL94TxxQGCeBzoMq + BDxnrO9JEcBswBCImPeE9wf3yRUA5Qe9/wsEAJ4X6ziGyE2w19PHwFWvg+1wn708OLSYy2coimHDPA74 + D4n1ZgaKvoCis0wFwJo7BlhWjYCsAqIbBIDOsj4hfxe/zdxnB2gcdrpIO1nxumU4qwWmWqlifz/yGvF2 + HRUPBIA6DC46VwCULWwC+VkCoJD2pwAgCTE9Tmd4Go6RETOd5KkDEjzUhveIqo8elE37j4vvKAQBomvv + 4Z3iP1IrgY5WqWzbK4HD7TLSfa9chXOez27UAqyLy5DBejHuked/2S+zAyDRmCEXc2FdL7/bv0HuPLFV + jMMHJNzRIEZHvVQe2inGUUSEHXXiP7ZPPIdw/XCzwnOkRbxH23VmPAWB59RB83syG0DRw6yHKwDKHnr/ + bxAAfcpJ5CYvxOgfRO6A7YA/rah7VQFbLRYAOhJYud4jfxvfaK49+gIHAcC163QPSgn9HGutEVBZtQLG + QyyQsEXAWmxkCYC/im00j1RZhkIBoGmjMullzS5WbGbxX6N3aSrV2wvSpNPAovNG4EBcAVCW4LOwoYS5 + OANAR6f7/hBzTP3T+duOn1HycUTPx1okcISvdeI5vFdCh+rM64dbxHOwEdf3yvpD9WIwAm9tU4d76swv + yIs5EF5q3bIQ8CU2G4qyKZZJ6HMRQ35v9E2mY29vkMB+/P8Ht0qwA86/uVX8B2rFexyfr3mLBA9DABzE + Z8Zn9XQ0KYzD/D7t+h0pAih49LsvEgB6LJB27QqAskLBnvlsVADAhnmaA5zk68Pz7DwmfxZFUEVHWy4C + gL1UrJ9VDEAks0DxL+N3FgSA+gSuTa5R2JvtN5zuQSnB+732WgGX0TCgxQJA9xaLBMB/j91hVqsWCQCm + 3MtJAHCW+g9jrzE7bTEdTMcR7dejVq4AKE/wWdhQwmRxkUWaWoOi+/94jvbevy0AbOd/tEWMI83iO9wG + p7lHjEM78DNf94l3f51UtDfB2baK58A2XEMU3dIolY378Lu1curY+0QiHrkct+pblgL8O6z6v5r2yoWR + sPzp4B3i398ooRb8n217xWjaLYGOveKrfwyfq0GFgK/xcTj9/WIc2C3G/lq8QsAcrLcEAITDUXynE/hz + ih07A0AiHraaslAA2HbtCoCyQsGeLVtWDoriPWzZzzqVzhPyQ9gdJ5he49E7J5sqMfR4N4I6O5tKAXAR + 1/6MnFokAGzRWU4CgJ9h7Q0DKqNxwD9XAIB4/zx6XQDQ+StS5SMA2MXqCgTA38TvAlkeFH8/CJPp4/iA + +GMgS1cAlCUKzorbYHbPezsLUCwA7AxAjy0A2hFBw0GqAEDk3Ib3cKAhRNFVre3ia0bE3bYV2CbBBoiB + tiYJ1j8um+p3SagZAqFhi2xo2ylnTn1SZvIO9vRKMW7Ic+yImfXIr4/dIXcceFR8dRAa9TvF3/YIPgde + GxD9H4Bzb9slRuM2fCa8tkKwtOKzOgkAOwPA72ul/3mW3DtyxorEzGOAer9cAVBW0PtfJAD8Ue6f49mM + npFAP8Rr1wn560S1FlSXmwBgRqIgAJIB+eMYOBVrr9wFwNobB/zYFx7x4YP7chHHL1UK2BmIgsEq+eIB + 8/gVydfae/19GEEhVUUREPdrS9Mr3D9djirqpYJGi9ermTDI8rCEe3lkCgQZPyO+RI/5vSxyLKfGFS4s + 0Pb4fOjELAGgRBPBsxsH6Vh2qIVwZw5pVOw5wai/2XSYHUyx14nRDqfbioibaIGjJ5oRYbfjtR2/17xX + Qk07JNgM4dDQKHc1f03OnPgEHDdsma2DYUOXcrDpuHlk8GrMq9X8kvBrD39BlM+6AVb3c1CKjNXIHFti + U0Tg938wco9sat0mRh2ERst2fI5a8TTgczXhM1B42NDPBgFAtOLP2vC5KQK4ZXEYn/MYvttJnmJg9I/v + q4Ot8P0pyLkui0+2WGSssNey0z12UTIUMrsWpyoHxbvFO9ovFX2w5d7D4CpE/+QuzuHn62oiDjuHw6fT + 16JYcLwtBsj9uvawBtUn0PboI4o4dbV51ZeF858AHrrvK06+dqlwvLhUGI/c9wAFwGrOo3+5AuA3o6+/ + biy2AICxXKHRaCWr9WerCC6mmTQFQIcpAEbhOFwBsCZg26DtyOzIyYhCxFEE0PFZpwCMs4c1KtZqeWYA + KAJYSPdzBEBl/Q6pboRIqN8q3voHZT1EgNEEZ9u4XUXAqc6Pguzg6FMBuRKtkIvZKpmlg58wRQCd/1y+ + Si5GqhEVGfLCk7C5iEdmEb39FL/Dwr8/zN4pnvo9clvjHgk3wPnXfUN89dvED9GhAqBYBNifjcBn9bQz + A9BgipkjiP6PI/o/he9H589tD2Y/+P2t439O0b9m8Fz7LgssFgBeOP+FAuCgzGQ4YI22U14CYD5+XQBw + O4DcvzYEwKgY9//SfU6+dqlwvLhUGPd/+j4KgNXsRf+yBADI5/vRt6mhqCqkccQoACyjKRMBQMykg7Kh + d78E+05YAqDHFQBrALYNKigC1A7h4OKwRYgAtUWIAA/PwTMLABGgWYDjiJJVBJgV9hpFM5qmU22B46Wz + peNt3KZ7/95mpt8flaq6x2TDPjpp/G5js1Q1bpEzne/V6v2ZbIXIaEhmJg25RKELciQxXhirlCuJKj3q + NzcC558LytwE/jxryG+Nvk6MfTulomWHeOv4725nVzJZB+FhtOD/aNglnsYiEVDk/PXzwvmb0f/11L+e + dOg+ak6Qo/MfsboAFjn/gmAqEyJ2YcJRAMS4pdqr3LShr0XrRTSrWg4CIOYxuTzpMYM7OwOAP/v++FtN + AboWBMB9n/iwk69dKhwvLhXGZz/6i37ue5apANBow9p7fXL8/UqCnARI41CjTZl9ojkf4AaDWg3AiFmF + /Y7eBvH3HTU/P4UMF1+RsboEWX7gM7Ft0a5FKYgAZgLo+FSQmn0p9DggK+NZIMdCOUbNHXCgdKROAqBt + t3jhgH1N/HMIhqZdEt77iFTXb5Vwa5sYex7D390nXV1vkznaN5z6/JBfnkuzBTacfjIoL9LG6Px7qnUt + CCK4q4lN8usjd8nGls2yrm4nRMBm8TR9Q25vgwhowOdqhCBphAiAAFAsFgD4rBr90/kfatLjf8XO39N/ + QrwDpvPn99dGLDb5AsWRf2EdO9xfF6WFbcs2pyoHcUsLQUmg/5i8o6/OHKPO7SOdw4/3qwl8Dj3mDU5X + bsd7m+vPj71vYQaqLAXAmLCpnu9jH0Sk6uxvlwLHi0uF8aH3vTGQw82jcnH4UqWAbajFxuokAMZGP7FQ + AMDpswfAHK6VjwDw6rnVz/WB6AcQIY4iYoyyn7wrAModfCY21B7tyFbtESKA9hjFc6RNWiJAC+OsegA9 + EWCLAB65s0SAOlk43VBTnfjhnAOI0r0tcLDt+P2WJyTY8LD46zdLqBmCYM828TVvl8jJN8s8bT1fJTPx + KrkAMcCOl0z7M/LnOvhJ0qwD+MP+2+WOVoiHuh1Sib9rNGw3awBqWyXUvlN8rVvEuxPCoDgDUIj868zP + StHCY4ys+ofz9xY7f6voT2exF3dhK7ZnzSJacLi3LkoP246LBYCHpwAgAMhN9/Xvuj6Dv+j8/WqBIoRc + rn1dyOdFAmBk6BNrQwBMjYj/Pe/e6ORrlwrHi0uF8QtvW+/PDjy1FgTAsaHPK/GZlaL4+DASHmHR2eY6 + Nxqvq4hr+GwS82saa3P/VjEGO/D5O8UfBWHyFEAxYa6iobr42eBzWWyPBSFQ2A6wRABnAFAEsGc+j8hx + v5z75hQBjKaLMgF0uJX19XDAj4u/4RsSqt+J97Xia9oh/kY46/rtEmzZgkh9u1TWtkugbZd0dr5VLuQR + /WeBOOsA/FqsdZWTL5kmTfvk98dfi397q3j3bYOA2CLBpsekqgHRfm2zBNvw7zY8in/vcf2/PE0QAXb0 + z8/Ubjl/Cham/fnZF0X+9nn/QuX1IudfTL6u8y8v2HZscyoFgD+K97RdcNPmgSdklt0owZ3Kpw6cVkow + iGOHTD3VxVMJ+EzaFwCvhwe/UPYCQD/D1Mgz/nvfCqfk7G+XAseLywEKAGMChuHwpUqBxYTrKAD6jknD + wP3q7JliNwfvsCUwyFEFQBlkAFRNB1RVtww+js8NMh3vlCAXHeepuwJgTaDYHgs2WbBLOL8F2wFFJwPs + 7YAFIgBO1hYBzXh/ABF5y+MSrIWz37dVQrWI2uvokCEO6h6AU8bfbdklFbVw1vv3SOeJd8G2EenHYOfD + lTJHIZD1yMXIevnjodeIrx1/vwVCo34z/v2dEmjYIuvr8L5xjwTbt0hV3RNi7N4rPjYhYu2B7fz5mWzn + j8hf0/787PgOXrY5pvPnd+P6U+d/PfJXMWTdE/seufZcfrDtuGC7iW5wEX5WTu2QlqFHTAEQg5Mth1kq + rOMCd2qbd25JWAKARYp1ffebp1DKWADofZ4afMbJxy4HHC8uB3yZ/u+XtQDg0SM8/F0DDxcEAPtDl5sA + uKZqOqwC4MjgN0CgIFQIgHAM38sVAGsH3BKz7LEY120TTjDeaxbDsRseSYk1Ad1HTBHAc/PHWs2TAQfh + ZO2iQEbcLfUSrq3VvgDG/t2IzLdKxV6IgZbt8pq6OhUBzBJ4G7cjin9Capq3yamTH9G5ASRIrfbPGrrn + f2cbROYeConHxN+2Vav/WfFPARFo3SmhvYj26xnpcwsCgoICoOD8zYp/Pe53tM0sZLQifxb8Me2v380u + uOJUxKLIX++HlfKnLbv2XH6webVgtxAAocioJQAOyJGhhywBECiLceoqAPB5TAGAaxAAnFJIAbCj9yFT + ANAXuAJgeWGcG3q2vI4B4sGCcLQJC4c/WBmAz53ZLZdpqHmfOUwlCufPxkCxSm3A42RUpQRTsjy2NZcM + SHL8QxIeQAQV7TL3/+NYeK4AWNuwmwRZnQLNVsFwjDzpMQxS6oed9oKguB2wOBNAh7vfcsY8c28VBuqe + vBbn7YTTh5Nug1Nu3CU1DdvE246/29Qgr2u6X06c+hjs3Csz+YD85tgmqcDvBtq3weE/Aie/RwI8y89j + f4RV8Ldgv98GBUBR5K+fkZ+1qNGPVloXt/ktivzt6F/XqiUAHO+Vi1XHYgHgiYLjk3imY13iHz0p0+Mf + 1mCK25ZaeOfAaaXEHIStROH8sxQj1TJLEZDyysVMQD52FnZc2AKAT7AFQBq2adnjqvPqxLgEpobXoADI + 9j7lyZZTDYCzAPjg6Tpznx3Ofh7q0OwDAGOJV5rVrA5GVUrY0wD5+m+j75IABQBnAMS7xBdfGD25AmAN + gs6O9kkBgGfJATgs8NRhTxQBg2xZjWdu1wRwP13nARRtB1AI6HYAnDFQEAD1cOi1W83rdU9IYN/XpRrR + v7+pXkJ1W+We5gekp/MD8nuDt8uGfY+Irxm/W4t/Z/fXNb0f2vMN0/HbsAUA/70i5+9ph/O3qv31qB/r + Fuj8rR7/esTROupnRv6m81cHAudfXO3vOv/yxmIB4I/CbhNnxDd2Wjwjp+Q/xt5tFgGyCRADKQdOKyXm + NRsB/iS/p8Iyz6ZXCa/MZTzyC2f3lb8AyI9hffR+38nHLgccLy4HjLHObxtrQAC84UyLaSicAWAV22nq + Ck5Xq0UXGVSpoUdYWFCD938Sf51GUv7IWXyXUxLiuWlXAKxt2BEvnyGj4WIREIG96nYA7NU+HcCUOofo + FE4HwPkW1QTwiKC36boI8MLRh/DewyK+ukckCKyHKPDU8/eb5fbax2Uj/n713kck0LhLCwgD++HM9yLq + r2MB4ULnXxAAFBzEKzjnbxIsHH+R87fXaGGtOt0jF2WDxQIgyGwVuCg8Bk4aOSl/mXitGVBBAOjrIj4r + OTSb61GHP0s+j4LXNQtgyJ1nIVjLPgOAez7a+W0nH7sccLy4HPCePhR1/EIlwssVABVnD+je0CyVYbRC + B+/QWEwDWn0BoB0J4zBavP9pskZ8Q8ex6GCgiU5XANwMWCwAikWANbnS3F81RUChTwAdrfYJgPP9eY2C + EKUH6ndLoAG/0wInDSEQqH1YKhu36DAhA39mNDXJnZwvUNckFW0UDhAUdXWyvvlxdfyOzt+uP7Cr/Yuc + v532Z+RvV/ubTX6wBmmvzHYsIljXdtcGbF41OXVQQhSq5KLxHvEPH5MLqRqz30TUp0eXnTittDC3IZjN + vaKZiQqZiXPiqyGBs1g/5S4AJkfF13Uo6uRjlwOOF5cDvgONJ9nAwPFLlQC2oV43VmcBwP76/xKr0rao + EqnUPaOrWWvvSs+y4nUVcUm7aoV174oFLXcMH5DAOCKoxGkJJM1FaBurS6JrEEUCQJ+jJQL0uTJSJikt + EgF2JuDGPgHXRYA6asDTigh932bx1u3EezjoVjYLelzC9RABtZsl3LZZNjUh0m/Yq0WCIUT+gV3fkGAb + nX5twfGr87f3/hef81/s/G1S5bCj4sjfdv7aJMz63k73xEXZYrEA8CfwPMFF/kif3Dm0XySNYIXH7WIh + ONzVrwEwj3J7dbbLDAVArFKLAP85XqncX+4CgD7Uv7/xpJOPXQ44XlwO+PfuqmUDA6cvVQq8bAFw9pD8 + XuQec341i0UQcV/O+ESbADFV5GRUJcSVLD5XImwObIGi/tDIHvFTACTPmh3lXAGw9kFHaBcDFoPOEjbL + ts8/s09AJ6IYDg+yRQAn77EDn6bod4u/vk689U+It+Eb4m8wf/Y1wbk3cbDPdjh2RP71O6Wy4TGpauTv + 1Upl4zapqH8MogD/Hp2+Ddv50/Fr5N9kFvzZe/4F54/PiM9qtlflugOhWnaq39MWAE73wkVZY7EAUA5K + nBHveK98dHi3WUsFruLgHe0t4cBppQWzuH65BO7U+QT8XBAmvxu9R7m//DMAwxLYs6vWyccuBxwvLgf8 + jz/2CD+845cqAV62ADjdLr889h6tsp+ncoWRXIKKvRaDGGAqa4ExlR7cjuCUNk5kY9pq6/gjEABwBHHA + jqosY3UFwBqGHRHboM0SJCPaLkXAgkzAKfN0AGcH0PkWRIBVE8BsAE8HNNaJn2f5m7ZqPYB33w7x1+0w + MwQ8HVDfIOvq7xdvE4UC/h4nCzbskZqWeqlufNB0+jYoKhj5s9iPcwqYfbCcf6HJT9E5f037Lz7n7zr/ + NY3FAoCc6o+zxuO07Bp9SK6y6n7ckKsJn8wUtlJXEVrIXaUCgEe8WdfFaYXfGn2P+DiRstwFQG5QAo89 + 9oiTj10OOF5cDvgefOgrRh4G4vSlSoCXKwB8nU0yMvwRmYPT1yMiUY9cYKOIaIVlPKsMVrFSxUJVs0Dx + UORLEoqcwqLrNJ2CKwDWNArdMhcLAEKzAhB5JCQSEwiq0CfAOh3g6UXUTRFwCpG4ng5gdG6LADjsjibx + tjSaNQBsGgQnrpP89m3RI4LBJvxObS3+fDuc/D6p3vcQnD+P/u0UX7OdSbDAPX8W/FFo8P86if/TqvZn + wd/iPX9f0nT+Gilya4Nr0f5u+M6+/OoVCbt4dbhBAMTPSjjaKd7ocTk+9gW5mANfjRlyhVxaBvyppwAS + 1RAAPg2iWAfArOrg0Ecl1AnRXO4CAJ8l8LUHV2QUMOF4cTkQ+vQH323kyukUAIzVIlGNUKxGQMHO/VLb + +1VE2oiw03D6iPy1IVA8rD2knYyqlJhLcy4B6xN8Mj/ul2eSbxZjBN8l2idVKTcDcNPD3hp41X0CrLoA + RvBWYaDu52tx387rVf5Ox/zU8eO1Da+M/LXa39rzL077u+f8bxksFgAVCTxrjrYe65Xfi73JrFkaZ+Tv + 1TkTTpxWalyLV+Jz4f04kA7KZXyunb0PiqezpUgAwHZtAVDEqavNq740fOjH3rMig4AIx4vLgeB733mn + kR9+2ulLlQIvKQDsDEDXIbn/7KO692/2iw6Zqf8kBQD3j/B+NaEqmgKAKSyP/EnqbgmP4TskeszF5wqA + mxt0lrTfpfQJaF9UGFgQAFajn8UCwN7vJyzn77GP+lmDfezI3z3nf2thsQDQk0ixbgmNn5X/J3mX2QMA + kbZyVhlsobKO60qiQi7zc7EfQAIBFa594czj4umCHZe5AMDa+b7xC29Z7+RjlwOOF5cLxuTQM05fqhR4 + WQKAD//0UXlb5y41Fm0RCbUoULEUAzpBarFBlRpquF6Z54kELKgfp6vkdWOI+NLdEuR3KTJWVwDchLAj + Zj5jRtN43svZJ2Cx8y9kAOy0v+X8vYeaF4z0LUT+XEfuOf9bBosFQCDeJ75Et9wzflKeS5njpK9FWbdU + BtxJxAy5lArLlXQAnylk9gCIe+VNJ/fodMpyFwBGZmDFmgARjheXC8bEQHlnAPDwPWeOSfhEExw/U1aG + zMYrYMR+swGPVpDydRWhAiAAccIOhXif9Mgnxhvwnc6IN4ZIq8hYXQFwE2KxACgWAS+nTwCidk9Hk1m5 + X3xE0Krst50+QWFQcP743UKHP/4bi50/BQfWkHvO/9aCzasFTo1TBHTLp0ebTL4Cb5Kr2L68XDIAl8Hn + V1Mh7QTIOq85fDb/iVbxnz5c/hmARM93nXzrcsHx4nLBHzv7K05fqhSwDXWBsToIAB/Tpsf3yz9GatTB + zsdZ/W8dGSmDPSzWITArQQVrigFD6sYfxPcB8Ses72UZq0uyNyGKBIA+Z0sEmPaMSJv2vEgE2JmAQp8A + VuxrnwA49MUigK/FUOdfZwoGgnv+dtrfdv4kTVb7u+f8bzncIACSw+KPdUvDyEPmsWngYiYkV1KVZcGf + BDlUW7xTlODn/5nYhHXRIRVnOspeAAQGT5538q3LBceLy4Xg6QOr1g3w5wmAwshVPHxvN0jtxAH5z6Nv + NNNXiZDp/IFrydXPAPAzcA9rJhswaxKihuSiHzTPhbuNgG4N0JHaxYDFeFl9AiACtGMgtwNYE1CUCbD3 + +W3Yzt8u+LN7+9t7/gXnj/8D/5d7zv/Ww40CYEgzQNNjH9TghHVKF3N+UwCUQwaVWVMKALZ6Z68XBFG/ + NvZWCIAjEj59/RigacsLBQCx6gKgo7HLybcuFxwvLhcC9Tubnb5UKfCyBIBGSx0SOr5f4n0f0mN2kmCn + KLzC8erRESejKiXiXrnIHgVZZgI82p/gv6TvkuBYN9NDrgC4VWBH1DYsgnrJPgFnrEyALQLswsDiroE2 + +HOh2p9pf0T/xdX+XC/WOX+SvjcG8eGe87+lsFgAcP/fN35G/mviLjN7GvXK5QlDZrQDnwOflRgmp3Oi + Kl5jAS1SHOr/qHghAHx2BoAnWMpUABjbHtvm5FuXC44Xlwu+J77xmOOXKgFevgA4JNXH2+Xg2c/IRSjW + a8l15pGRZFCeS8CgHYyqpICqfpHGq+l/j8wla+THE5VSM3RGgnEQvSsAbmostU+A0XPEFAF05MdazEr+ + 4mZBdPqAdg9kdgDO33OkBQTZJt6ic/7FR/1s5++L4/9cVPBX+Gz4zO45/5sPiwVAKH5K/OOdcjFTIXOp + Ku2jcjVnmJ1LuSXgxGklhHInhInOVIlVyOWUV+rP3ieB44fFOL0GBMD9X7nPybcuFxwvLhdCn3r/u438 + gFTkx8UDkBj8eQvsEZBb+VkBCwWAVT2tUZJZAxDuhBF07pH3n9gnwi5WMBI9ykLEw45GVUqogo145Aoi + /6u5AISJX8cW3xerlyDTv1bBlU26xXAFwS0Ae2uAdkD7XtwngCKgj5kAEB47n53cv1AIMNq3wZQ/swTs + KsisgXvO/5aHI4fw+do2Fx2WL8W2yRz4ci65Xq5lvDJD7kp6de/didNKiniNzGozIHN7l6/v6YTYBbyd + EMb2SRb6BNp1kaDl8dUbvvsyw5cdN4XyBO5n3lxH/syYhOkbJ/plwwfee7eTb10uOF5cLnjf/ZaNxuTg + M4H8GMhhVAnCB+fvmxg0v3QJxgUvFgD6kIsEQOAMopvOJnnD8b3yAivt4yG5AiNmByltB1xsTKuAWe6j + xQy5nAgUTSk05ED8AfEl8Z1steoKgFsTxWQMW3DsE8BmQawJYBEfMwF08CwMpAgoBp2/3eSHv8sOg+45 + /1saP1cAkHsSQ9IRR5CqKfZKHQF8le8TzFau/jYAC6gZ0HEUMLcoLsS88vrjEABdrbBxS9yuogDwwtGb + WT6sKQgA/p++7JjQZxqTA89UvOVNcELO/nU54HhxOeGZGHzawBf0JIclALXjmcBNnQBJTVnO2eGmLCec + BEBhCwACwNOD6AjRTvjIPvm/x9bDaLxyOQNnyw58MUTcDkZVSlyLV+gMAB5l0UVmpdW+l3g7vg8Mh9/p + Z2QBXAFwC4DP3CJkjcaLRVGkxFQAANMlSURBVEBxnwCmOhnN2zUBJ9vFAyHAfX7d66fjZ50A/4zOv+eI + eDkrg+QI5389RXqdIBWW47fh+BldrFncwCG287cyTkZqWP5d5g0mL42ZBdSabsfrXKJiAZetBuj0WTx9 + IRNEQOeX/zZ2G7i+DjbOrTHY94ItgNILADp/9Ym5ftxrRP85+EgGy5NjDJSfdvKpywnHi8sJnmM0psfE + Gx+ScDai042gbMSAAPCV4AYvNlimSBfUAPRABJzC69FaeXrgzepkL6WCMk8RUAbjgKmqqWB1RDEWGQsB + qa7/R7JSgnF8N8tgFwsAGpYrAG4BLBYAxSKguE8AK/dp772cgMn9T0sIFMPa72cvAQ72sXv7O+2PFjt9 + 2plrazcn+FwLdSiEzae0A3BPTapX/l9OLI2Cn0YgAMBPV7MWb7KnymI+KzFMvvTJTzMh5c9fHXqrGIfr + 4fyxFrgOrMJW2rhun62GAGAwnMHayg9JcCKK+4s/OzcmgWj3rzj51OWE48XlhO/M4YQxDWefGJaKHL7c + JIxnAjcZQqCkAsAy2hsEAAgv2AVSPN4g490f0SMj7AjIZkDXyqCIRaIhuZrBZ8rxSI1Hx2xyL2sWn/Pt + EajXIgHgRmC3IIoEgNqAJQJsgtYGPcUigBE9057MBnAeOgv8bPAaBQLXBbMGTuf8+f+4lf63LJRjLC6l + TXwgvl9meEKJw9PG6GQD4CorW1kGGVRF3KsD3viZens/gWCvSfxnsAbOQPQuFgD0EdYaKpUAMH0htwAG + iwTAiAQ7D405+dTlhOPF5YRvz/ZaY2pAnX0oTwEwokWALHooxQ1eQJB8uHZUNNJpkiFUYJDVoCea5fGu + r5t7/6oaeXYUX2G1EfNpBoDHAHmOlZ0KZ3g6AZ+zdfxxk+Rto3UFwK0J2rddDFgMzXr1mSIg2m0KXzp1 + il8Ow2L6sxgsGGTNAH+HgkEjf0Qm7jl/FxY060OusQTAwdgDykUziQprhHpQt09ZC0DH68hppYQWc+Pz + kdPx/pGuB7UI1k/OP33IzHLRF9AnFNm5ZrZK4J80cwZfGCJ3T4xIIB8x/1/4TD98p5NPXU44XlxOeO77 + wseMiV7x5YbMwj8IgKqMWf3PAojFN2TZsUgAMDVaLAC8Z4+L53SrBI62yZuO7db0P3vv03g0E7DYoEoM + 7v+zmlYrarG4JGpOKbyWN+TXIu8xU70/SwC4JH3rwLbzYntXEcC0Jp04RAAjedj+dSGAKF+zAhaKHT8n + vFl7orZ9FQSA/X84fQ4XNxcWPediAUDu+bU4G6hZc1NScLLJkO6560mqMhAAM2lwJjO5UUNeTPvlTUd3 + iu9Ym3i62sXotgtcLQFQlOXS77mYT1cA3oy5vaJV/1MIjnOj4ucag8/0fuFLn3TyqcsJx4vLCeO9H3qj + J3vmKRY46JeeGJZ1mXEQCb54Dq9FN2NFUEyIltHqw7YEgK8Hr6ebpPLIATEOt8hPeJY15lfjUTGwyKBK + DY3+U37NRlxLBGDIAATA7KQhz8fW60mABQLAXrD29158P1zcVCjsz9rPuxggEk9RnwBmAjzRIhEAZ697 + /DZwTa/T+fOM/6Jq/4J9Efg/3X3/WwBFz5uvxQKA3POTGKN9cCYDFCtLydqpy2lPWXRSvZSp0mPTMuaR + H2XDEjjYoMGe0dUiRu/pVRcAvjQcP5x+5UTErIvLjmg2wJfvftr40MdWbAywDceLyw3v5Mgz5pn/XvHD + +fvYEwAKhxWPTjdlOWE/SI1gGM1wn0cFAKKdoU7x9h2R2482i3GyU08C/PLgm82UFg26HGoAXgKfTe0U + 79SgVA7DEWTi4j/HoiyQfCYCo2JhifN9cXGLgMKXsI4JKsnRsdPBE+wZQDDat9P9/B0LXDdMSRYI0XYG + Lm4JVKfAK0/CJvJ94s2CXyZGpGKcXBOT+xOPO3JSeQEiJFIh8zlDcqNvkXUH6+H8T0ioc78Y3e3qA/Sk + DHyCBodFYlft3eGeLCfM7fAxCcH5h3BPeZ95/t83lXzGyZcuNxwvLjc846e/o42AJvv1KKCfagdfsiRF + FtaDVAHAh2sLgFErBdp/XGp4/OnUKfEfqZOus7+oatZM/6++gn0pnM18Ht8LDp/nSZP8zn1SkRiFyAKp + T0dvuB8ubi0oidkigALAFgGWENCiWK6JYsdv/x7ANeoKgFsZCfGeP2NGqulhCTKbNAkujw3LSPKXHDmp + nDDHLYBIWDn9UPcHJUQB0HlCawC87I1BH8BMWLRnVQRAAIKKAsCfH5QABQALAqfwf0cHVvwEAOF4cblh + HG8d0M5/iFTZ5MDMAAxpusPppiwnCg/SJkASHQWAXRXd3ymhLnZJgzEcrZcvHPmaVoteTfhgPOZWQDnj + /0q/zizw4r1lY6DMoFSkxiQ4ie84nXa8Jy5uHdj2b68BWwjb0O2j4p/557Zg4O8X/X39Nxz+Dxc3MXIJ + CYBLQty2hQAIcADZOdhFtE/+LHm3IyeVE2ZzlRAAZkOiTx67X7wddRAAxxH9d4iv1/IBlgAoiN8iu3e8 + J8sIWwCwRo4dALkNEIQI8Bw/MODkS5cbjheXG54dj+4Mcc+f7Q6hIM1GBxEIgZW/wYUHSULjw8VD1odt + C4C+0+JhN8Cu/SoANu3fp1335uPeBZ33yhWstn1t4qRUZBDxc5slFRffZI+wuYQv42YAbnnY+7ZFUIJj + lGPBdvYLiI+R/qK/60b/tx68KbyCV3zT3AKACECUWgEOf33q2JrYIp3JhrQA8EKsWmoO7hXjSK0YJ8H3 + ve0S6EWQtEgA2OuhYPMO92Q5wdo4+kJmxTUjDh8Z5Frc8fhOJ1+63HC8uNzwfuZT7wum8OWmIAKyfVoA + 6JmMijcPxeVwU5YT2siCD5I3tUgAFCqh+8yjgMapZvEc5YCU/fLHkdfBeKyjLA5GVVbAIqxLPyFGAt8X + C9WbSonB6B9kHbYqTF3cwrAc+WJnvhjFv+cIp3/bxU2PygwzQzHxTndLgMe400B8VJpyj4iMO/BRmYEt + gNlK/Q/G3iTGwTYJHK8X74kDYnS3SLAX/A8fQF/A4VbFxdRESYpcMwPinYiKL4eAOAd/ODUmoTT81mc/ + +YtOvnS54XhxueF5072+ULz/u9yT9rLnMQVALmGKAaebstwggRUJAB6HsgWAZ+C4eM526OSzwNF6MTpa + ZXzgozAes3GEk1GVFeJ++fX0O3AvhyWE78a9Oh4t8eewYCGyHO+Hi1sHix35y4HTv+PiloR/ekwC4JVg + xixY87L7aHpUfiN7LyLr1T8l9VJga2IeRxzt/4QYh9skeLxRBYCnu1X8bIhlCQA9IVMkAEq2DuADPfkI + 7um4+Cb6xHs+KpXJse/5VngGgA3HiyuB4Fj3t42pKCJ/MwPgyyJSzfY435TlBh8mBQBTO3zIfNgUANwG + GDwu3u6DYpw4JsGjLeI9sk8+d+oRmUty8h4++iKDKjfwc16MB+Ud6YMSSlj7SLi/FfluzbI43g8XLmy4 + Tt/Fz8NURKozPQgqzH1qdnR9d7pDm5FdLoNj0i+JuDmT4HOnHhLj6D4JHGsRz8nDEug+LJ6hI+oD2BfG + FgB2+r9kayLXr9E/Myu6dXsuJsHxoe84+dCVgOPFlYB3qOu8wQlHE724yWx4kMUNKHEGwEkADEEA9ByG + ADgtwSP7peL4Nll/0KwDWAunAC5bna5aoo+INxs15y2cG5SKCXxXKHXH++HCxc8BewuwaZc7z9+FkRmV + ddqYpk8LuA3wy4HxbyjnPJ+7kY/KEVeT62TDoV0SOrJN/OB449RxCXEI3HB5CIDgZBz3NQkBAJ/EbYf+ + s1NOPnQl4HhxJbB++2PbDB4lyQ+K7xxuLo8+lOAUgKJIAGilMx524SRA5Lj4ug5LmKcATtSJ93CteDv2 + yx+NbyhMkppPeETbA3M4kDUgiB365tOrXySoKa6UIc8k3iXBRL/4p0/jO0fFn4hrfwDH++HChQsXLwOB + yVEJxOGgKAinTug2439KvFc5RxvsLOKjUuNaxo/Pwip/7vWDp6P4XDGA44jxGS/jM/5B9C4xDh4yMwCd + TRI42SZVZw8i+Dtl+QBTANgnABQlEgBBHfsbUa7mveZWwLotj2x28qErAceLK4HgL33qfb5c5CkjBwEw + gRtdLgJg9JT4e7useQAHJXy0QYz99TLc/y7TwNgPgG0ubcDQOCRIO/OVwQLgSYVrUZ9cTPhl3US3ppOC + mdOI/h3ugwsXLly8EuTG9SRAIHNSj22TYy4lQtotdaYcTknB+ZsdBy0oR5t/pvwMrh7ofh84vVGCR/aK + cbIDXN9u7v8PW6fBVlEAmD5wXLQWYGKYJy2e8n7yY+908qErAceLK4VQdlgFgDfNLzuqhSVON2XZgYep + aR1LAGhfdEsA+NkJaqjfFAAnT0nVkWYxDuyUD538uqpcGpAkYeisJk2xvaXl/HndNsJVhM4IGMXnyxmy + N/uwGEkoSh4HzAyIJ9fvfD9cuHDh4mWAvMl20p4seBNCgBxDrpExr8k9DpxUWpiOn7ysDl/nEZjC5FoM + P4OnP3AIvLh/l1QeqRfj+CkJ9iL6H+wS7wj8gCUA1CdYAqCUWwDaDXeCPRbA1fCJgdzwU06+c6XgeHGl + 4B8+8S1+SV9mUHsA6J6Sw01ZTuhRjsUCgMNROBhl/Kz4OBFwoF+8p2EUnce1ENDTsVd8B2vlHzjPmkZE + Q6Pjt50/DY2GVwbDLua5JREx5HLeL38Yew2+Y694M2n9zv5JfFeHe+LChQsXLwcB9m4Bl3gzSXBLj/xR + 7LXgmoAeAWSq3YmTSgrdkr0enOnRbfIzAzTw4j/FQ+Jrbxbvgd0SOt6IIO+YBHuOgPNPi2/4tDXxkj0A + 4BMWCYBSHANkxlZrbnjccmpM6COdfOdKwfHiSsFo2XGYVaU6GIjOiZGqw01ZTth9AGwBoI0ebAEQYSHg + MR0K4TtzWHynW8Q40ibhQ61itDbLvx16A4zLTCkx4p/Dq+57qcrEdaseYDUxGw/D2H0yi/ccFvT+7AEJ + RvEdp8bFO+l8T1y4cOHi5cA7CY4GlwRjfcot1xIhcA64J+kH56z+KQDu+SsXUwDA+ZOfC9lZ8PO/Gb4H + 0X+HBnTGySbxdrWL/zQbAZ0SYxjBH32AJQAWNwEqSR8AFm3nBhH5jwrb5Xuath908p0rBceLKwXjC5/6 + GL7k0zrBbMo8Duh4U5YRfIg3ZAGYbonjoUe78fBPwBi6xNd9VEJn6iAADkjF4f0SaquTfZ2f0El819Kc + wAcDg2Fp0R1TTDC6slDAHBEMqNGnDflm/ONiJHBfzw2VrsbChQsXNyV87E4HLjESw8ot5BhO+5tPgXPI + i06cVEIoBysfE5bzZ10APhs/447Oj0moo128HQ1iHG+WUFezeE8dEV8PnP8YuJ8+gL6APmFR9F8KAaDd + FSf6JTA5zu2Ap4zPfqIkDYBsOF5cSQRSY9/jDTbOMVVdmgyAowDgng8ffuS0GP1nJNhzyMwAHD8qwUMt + 4u+ok7ccfEIuILq+mgpcN3ZbXVIAJFY/A8BtiHksyplUlYqTC7Gw1OT6tKlEOOXWALhw4eLVg1X//oke + WZfrUW6hw+WxOnJOOfRJUQ629vxtbiZXX02FwN0BeTM43NvRJL7D+8DtbRLoOij+M0fF02+dAKAPoC9Y + JQHgZ3dFBMO+qXEJpca/5+QzVxKOF1cS4fjodzmwxnuuT4JpqB+Hm7Kc+LkCINYtHhaCDJ6VYO9+MbqO + SOAUlGHHXlWLRmuj/OMInCpEgCkAmPbH17BU5nz6esXpamE+AgHAohx+pkiVzOU98tXcdv2e2lPa4Z64 + cOHCxcsBW7izCPCrua3KLRJZr1wzm7eibwdOKiX0KDa3ZMl/3A5gC/e06fz/adQQfxt4HAIgcGyXeI6T + 409JoO+ojgE2xuAH4ANWVQCwCHAKn2ECYis2UpIJgMVwvLiSME7uGWYhoHEuJgHedIebspywHyRREABa + CDggOgp1tEuMYahBHgs5c0iMkwfEc6RFjIONYuyvlfGzH5ALVrOdy/FKGFtA98CuZPA+sfrTAs3KV0Oe + z1TIfCosMmbI05m3a2/rqlSvBCdiMLJR8U3ge/4yvv+5ManiWM+JvDsu2IWLWx1TEanK5qWSTcN4Dv1J + 8ONkJ67BOU3gz5JDEogNyDPZtyu3sC/KT9kBEJxTDlsATPnPJ2pkRn/2yGzErEtgI7eB7vcqh5PLldPB + 7crxegTwlHK/jsKGLyguACz2GY73bBkR5P9rd2w9sXPYyWeuJBwvriSMLV/e7JnCl4VxlYMA8I6dFs8I + 1CCNgkOBaCRHLQFwoE6+cPiL5lhgql4Y/2UiXo0FAAFQBgr4WpQK2KfFL7PJCplLVMq/4P072Ao404cF + TkWbhqGNSjg3JL6pUfFnBySUZT+GlR/G5MKFi/KFL9evXBBKD2nBH9+HkxACuSQcEzgS18klP9Z0f6XM + JP1aDM0iQEGU7cRJpcS8FgEGwclhmcHnYSE0r8+lffKZw19VDlcuJ6eT28nx4HpyvnL/KguAQBr/L3yh + +sStXy5ZAyAbjhdXEsa737nRPzn0DNsC0xE53ZTlRPFDdBQAPANKATBwwjSOzoPiOdYqno4mGE+DhFp2 + yt/ENqlhzWfMzlKXEhtgZDA2pp0WGWSpMT8eUnHCZhhmAQwWQNqQ4cznsYjHtb+0kctAAKSlGsbm5/xp + 3ItAukv8JZjG6MKFi/KFn71Ccme0yY8HAqAyNSBV8TScf0p8cPzkEHIJOUVSIT1br/vujLxjFY6cVEro + WX9w30y8Rq4o/+GzJfzy/4Cj/c17lcPJ5eR0crtyPLmeAkAbAN0oAOx7UwoBwPkKbIrnnRp8xnjP2zc6 + +cyVhOPFlYY/eupXaGx6HNDhpqwk9AFbAsCbAGgEo2fEM3hSjO6j4unqEM+JNjEON5vKsbVR4j3vlhfT + YZmzHD4H8Fxj8V1q9bcAJGouQmYpzMVgyEx6o/zzuCF3T5yRCij4Sm4BTMbw3fG9eR8m8J7NPdxhQS5c + 3NJQDmCv/3xM96HZqp3bhqGJYXDHgNyV75R/iZBTNpl8g/ezDDLAM9diq38MkAWAHEwkkbB+ptkUkKiW + 0f73i9FiRf/gcnI6uV05HlxPzif30wfYAqDY+ZcOEB3whb7YqZLv/xOOF1ca3sO1Z33nxmBwqyMAdOSj + JQIKLYHZEKj3mBgUACwWsQRA8ECdfPzgV+RK1i9XLQdL9Xs1xk5YMDonoywl4gG5kvGqQr9MQYLPNhdZ + p9sTRzP3Q9XGJZTplRCP8nC4CxY7K06NXNQsQHG4Ry5cuLg1oKNoeRZ9iq/gCES9vvODUpEBL2ZicjT7 + ZeUSm1Musw0wnOyVDLinqO3uaoF1CC+qAEDkDw68gmvz6Qr50KGvS/jA3usCQAsAIQDI8eR6uwMgM8F0 + /vQJqyIARnTksvfQvrNOvnKl4XhxpeH56uc/o9sAVjq6lLhBAPAYiAqATtM4TpuFgAZbAnfAeA7ulorG + nfK3ifVaaHIljQXAfbCYT2bt4yerCB530ag/45EXtTARYmAMf5ZdL3+avFMq8qxwHZDK/ID4suPizYxK + 5VS/pp0qUj2O98iFCxe3BoLpHnDiqJ7K8qVHxZ8ZF/8UOCPRL8GJXvnj1B0iOTh/ckrcJy+mqnR/nZzD + 49FOnFRKcGtWU//A5VS1XE145O8SVRJs3ia+A/Umh5PLyenkdhUAPAFgHQEsAwEQmBh62vPl+z7p5CtX + Go4XSwFvsvt7TjdjxcEeBEV1AHZLYGO4S4x+FgIeuV4IeKhJe0gbbfUy2vs+NbiZWAgLIGhW35dBJ8Ar + ybCpzCFMLmlGwmxYNJurlGsxv9RmH8X3Hddin4ocjByqfh1HMkMAhLN9zvfIhQsXtwRMDhiV6jyEALhB + OSKHa6kR5Q462BlyCZ0suOUy+EaDIPys3OPASaXEfNSn/U+YBZ2J8nN6ZbD3XWK07tP9f+XwQgEguJ0c + T64vtAA20//qE+gbHO7RSoLd/7yJnu86+chSwPFiKWCMnvo2j6c53ZQVRZEA0CyAtgSGEhw5rcUhnu6j + ZrHIUdYBNEmobQ8UZK287/CDmm6XMSyCLAyPKTBr/31VEYUSz2zUBalTupidwGe7muKfBeS/xN4i67Mx + Maah6KcY8edkA7//REI80xzz6XCPXLhwcUvAfy4hxmRSNiXBheCGwDQ4YqJPKnNR+cPoWxBchBFZGzIH + zpM4uM+qsteaAKbdF/NRicFJqBQAz+d9ZpYi6pW3HXoQzr9Jggf3Kocrl7O4m9yuBYDgenI+uF99wCoK + AB8nAY51ftvJR5YCjhdLAWPvo7V+dgJEJGoUC4EpXhsVjrMNc2+q6GYtBzTNw4fN4xfA9dHAUIWDMA4O + iqAAON6q6tF7ZJ+EW2rFaG+Wv4pskheY/mKEzeMnPB64yCDLDRQqn55qlpBOnBrW870svvQn8P1L0IrZ + hQsXZYzsmARi4APdEjR/ZgvxX5pqkWus/HfglLJCvFLmmY0Az11IeOQvRl8v3tY9EmiD8+f4X9Zygcu1 + uLuXDYC4/w+uj1ojgC0/QJ+wElsAwRx8mD31lv1v8KrzFbj9PTFstmvf+chOJx9ZCjheLAWMj37kXmNy + +BmdhsQ9KPac5oOACmNVpN6ozPI7qIIAsESAN9EnnihUr1UISCPRalEKAC0EZFvgfVLRsFcGz75XhJF/ + 3KuvV2JrQAAkq+Q34u/Ed4+IdyIi/jyMfxr3AkLLM4H77XCPXLhwcWuAU1m9U1ExJockOAkOZFAwEZXf + iL4V/FF1A5+UG15MsgAaQRmzsSlDznS/WwIN+8ToQNB2AK+c7spTXdz/ZwdANn0j11sDgGznv1ICwJdH + MAvHr07fyj7T19n/l5e1cB/60BudfGQp4HixVDCy3U/RyTMTwGlIKgL4IHjDtFJ9+R+IkwDQVJDWAVgd + AWEsWjXKvaP97XhtlMqG3fLOgw9CbfLMKQwu7ZVLDgZZdogxNVYhX8xsw/2MmU5/EuqXjScmoYAd7pEL + Fy5uEUwOi28aUerEabwOgBdH5Mu5bSKjYd1CdOSUMsKL3OpkZ8KxoHLzOw99WXyNdPyN4jvQaHK4XQBI + bmfPF3A9o38PZ6WssAAwILDMI+8MaM2In75OX/MIwuADnXxjqeB4sVTwnmoY0/RIDjcIN4kTkViNyYeh + R9VW4JQAH/ICEcAqUKaCKABgHJ5+qyEQjeZ4q/gPNolx+KDZUrKpTn6//3a5SuOLYXGshRQZ6wFifvmN + /OvEnxyRymwK93VAh3wYrPZ1uEcuXLi4RTAxJKH4IAKCQQllxiWYGZBns3fIfAwCgIXOTpxSToAAYEB2 + Ge9/MPB6zdQa7XvE21EH3m41M7mnWAB4vQEQt3xNAbDQ+a+IAOBRd4gsCg02WwpNRsysAP4vigLfyYaS + t/8thuPFUsH46qc/g2j/aXPfHzcJr9p9Cc6JN2mlMgA3CgAowQWFgFYdwIn9EuhoFM9BGFDHbgiANqk/ + /kldGPNx/5oQABdzYS2SmZsMy0NpqOJUQjwTaQnGcS+w6J3ukQsXLm4NaOAVYcCVFA8ChEdye2Vmwies + +r+YrnbklLJC0iuXkgjGIAR2n/qihBoQsHXslMDBOrP///F2k8t7jpjN3hYd/1txATBpdl9lYMs6C93e + hshiwyVffvhpz1c+/Rkn31gqOF4sJULZwacC5xDt8zgKRAAjfx9TJSwMXAEBQIGxQAQwEk5AABT6AZwU + T4/ZEMg4uV+NyHu4UarbtojR3CY1B/fKjyMVMpv36BEUR6MsI8zGK1SoXE565DfTb8V3HpVq3ttMVOcC + ON0jFy5c3BqgU+Ix4Uo6JUSrv55+vVxNezXImYuUvwAgr13OB+T5kbCsO4ggraVWgvu3a/tf/+EG5XBt + 7kZOX7D/j+9rCQDbH6xI69/sgAQgABj9+6diEAS8NigVHMqWHVrV9D/heLGU8J05nKjJwRHnGI3C8eMm + sSaAk6g4L8Dxpi4BxQJARQCNgMawuA6AU6NOHRDvcajIo82yrnWPeNsaxWhtlWTP22Uuj48/joXiYJTl + hGs8rZBaL1d1VKYh38jskZosxM7EuNZaON0jFy5c3BrQduyT41KV7pJH83u1op7TTiWxTo8YL+aTcsPF + mAfBWEDSZ9+LAI2nteqkBlxtHG4X/7E6M/q3JgDq0LdF5/+LfcGKCIBMvwazrHXzaet1+DgIgk35UQl1 + dUSdfGIp4XixlDB2b9mzMdL7nQoWS8AhBXiTUngYWdYAlE4A2NsANJJCHQCMJ9jJvaQO8R9ol/D+PeJr + 2iPvP/I5mWMTILYGdjDKcsLzkz6ZHTVPLczFAvKn0Tfogg+y9ScHgTjcIxcuXNwa8OR62IlOjHPj8ieR + 1yPyD2rGcG7cIy9MlH+GUyJBmU0a8s6TX5JQ/U4JtjVJTXu9WbfV2WBmcsHl5HQd/c6tXmZ8SyUAcnT4 + 8GPwaTztxnbLVQhsbx/t+bax9ZGST/9bDMeLpYbxzeHfCU6moZbwUKb69IZ5M2NmpbrTTV0G2EJAtwFU + BJinAZgisgcDGWcgAo7BiI61S8Xhegk24n1LnR4L/O3earma98olqE+7WObyeECupUM6M/tKGczKNuGT + KxlW9FIAQLTkDWnLfFn3pEJQp95MEvd8QPw6EASiazqq1akswLQnB7pw4WJtwjtprut1afAb1raHQ3+m + 8R4BgC+bkopsRIOfQ5z4NwkOiwZklsN/MtUi4058UmIgyLqS9KuTn08F5VLE4tW4IZeyQbmY88vv9K2X + YAecPrg50FAvIXb/O84i7lqTw60BQAuO/5HzrfT/ijh+G7jn3izAvX/4NiPdD8GVEOPJgR84+cJSw/Fi + qeHp68jzNIAdlfKBBNO4Ybot4HBTlwE/SwBwG0CnRXHPCMYTOA4DOrpPfAdrxbsfAqB5D7BNajs/oE71 + ciagMwLoaGejiLRTftFWvCkfhACvry4oSFggM886gFS1Ts76i1SV3EFVCuXP+QC+iU4IgW6pjEN0cTjI + +VHx5gekkscyHe6dCxcu1gaquJ3KTN83R7UpTUVqTCrghDxTXXBMcT2OdtfEuPxZJqTDxK4m15l9TsAd + bHm+mE9KD6/MAuaocwgBbkskPTILYaCzCCAM9p76uBgNe8Tbshk8vVd8hxD1H2sR/4lG5XByuXJ6If1f + QgHADEBmHP8H/Rm7sYJf4eu8vQfyTr6w1HC8WGp4HvrqV4zJkWfCU3F9IDwBoF2pJlYuRX2jAFhUB8Ch + EWePiP/kMQkehpLsqBPv4Z3iacf7lh2y/sBm+fHoejVQTgmcYUMKGimMU/fdYbzlkAVQEcKiHn7OeFhb + ZzLFN5j6HO5DTrwcGZxMwvF34n73SCiZlpDVIdCbdbcIXLhYywhnRsUzCYc3EZOqJNv+npHKdK+E03BE + jEizCRnNI/rPgMPYSjdRqVH3PDCbXf1GZzrsDILErGXCK67N4lUns8Z98k+RKqk5sEuMpt3g5u3iO7Jd + jEMHJHS4WYKn2pXDlcvB6dcFgJn+L4kAQCAVQjDLlr/8v+jjjImRp70Pf+UBJ19YajheXA2Ezo08q3sk + OUSkk1HxJ/rFO830ldNNXToWCAA2g9A6gF6dEe0ZPm3WAXAb4FSbVB09CEXZJBUdT0AINOuQCU9dvST7 + 3mvWAUCFXkl5zK0AnRQIxw8xcJkNKhYZdKlxCZ9plsd5RrGYmdKDIODErBfxZx+OnzEjftZdnB+UMO5J + OB0T38SgBPIgB6pWh3vnwoWLNYJsBHx6VoMqdl1dzz4r0+DZCXYCjcuHMscQqMDhs+kPuOwa+Ywz/5OV + Mr+IS1YDKgDwmTh9VVuvk7+sUwq8PtLzfjHq94KXiVYJHtgixpEGqTzSbnZ0Zfqf+//gdOV29nyhALAa + AK20APCdGxZ/asDstgjfRh8XnB5+1skHrgYcL64G/H37dRvAyEfNs5IcVTuNh+RwU5cDCwSAnQWA6GBb + YM+oVQegXQFbxdt5SHzH9ktlO5TmwToxWpsktHe3vOvIV+VH42GzwA6Gyb3/q6kKuYxIm9sD2jHQwahL + icv4TBxixElZjPyvZvGZKARyFfKr478oxrkM7gWETiYjFdmc1gMY5xAh5E/pNad758KFizWCXEoCE6ex + rruVTyszeQj+lIRyneLF2v9u8l0iWTjZUTj/bFiugccucQsgGTSbATlwSikxm4DTh6O/kqiQmXRYeZbb + meTcH41XyFsO3i+BvXD6B2rBzYj6WyEEjraI79R+Mc4gcGP1P9P/5HS2fGcBoBX9l0IAGBAARhqiY5on + AAD8n4Ge9rSTD1wNOF5cDRgPfvYr4cmxZ4ypuFkwMYmHxOpUp5u6DLguAPCzLQCYBYCReMfOijHUJcYA + nCBTSF314j+yXwIHD8r6/TvEaGoUP4+aNG+V7/Tdq46VipT76xyVeQkigAKA43idjLq0qFJF/3y+Rq5N + IvKnwo/7saDwM/78wcyjGhkE4kkJc0zw9JB42ZMBQkBPYjjcOxcuXKwRTILn8uPiz58Bn45rVtWXHhP/ + ZFa2ZL6hvHUhVo3IOiiXkj6IAEMuZsBf4IlrcQQNN/BJaXGNE07xWS6nTQEwkwSn4jNTCPxvfW9GMLZN + PC1s0lYnNQe3ir+jQ3xHDyNwaxJfFwQAORxcTk5XAVCU/if3r7gA0E6Ag2ZQOxmTEBvfff2zX3TygasB + x4urhYpU3/eMCTgjNgCCctJRiU43dRmwUAAAtgAo3gYYhEru7RTjRL0EjnI2QIfUHNghvtYW8e6vg9Ht + ki8e+ZL8PZUyjHQWkT+zACwM5M9lMUwjFpSrcUNenAjoopkdM+Rq7na5xv0+/PzD4Up53TdxHyaH5e7k + cfFDDGjBCvswrGANhgsXLkoAiHp/nmO/xySUTsjG9AlcG5TX/fKQ/NUweAtOn3v/Fyc3avU/OWMmG5I5 + 1jNZxYCriXkEKpoBYD1CyqMcy5//LhqSzx39MgTAXi3Q9rfUSfX+bWIcPyr+Ex1inGoQ71lG/503pv9V + AODelEAAqA+DL1OfBk6lj3PyfasFx4urBYOnAdgvmVWacD6BFRgHbMMWAFp3QGNIQ6XBMHgkplgAGEOd + ctuRwxLqhAA4wUYT+8Tf3iaVHDjRDINr2St/OLYBUbYHET8XFNPsHm2oMZ/a6GjUpYRW0Gbwnvt8o3wN + QqD4ZI5FP3EIlSmPRMc+ASOFoZ6Pye0JngxISVWOcwLMYkAXLlysTTDaD08g+s9MSDX3vSnsEYkmRn8R + a9+Q52M1MpfzyVVmMRM+uRbhUeaAHrvTfXYHTiklZlObVIyQU/l55uH4uYX5+6PrwL97xWisleqWLebs + /7ZmPbLtRfS//lirGP09iwRAv9n+V/f/yf/Xe/I73bvlQIjHLicHJMQj7jn8f/BxTr5vteB4cbXg+/Kn + P1mRG3zK+OWE+BPD4tczrM43drlgigBmAobMQUTWNgD3jIzhLvH2HjebAnGgxLEWMQ42moOBuNfUsgdG + 1yCPH7pPLsBY55KmWmUFraTMbICTUZcVktUyFzXk09N1YmSTuAejuO+nYbS89yt//124cLFyCPI1zYLq + M+aWXjomHzlfKxL1ynxk9ff4Xwoa+SOwmgGnXqMgiVXLRVz/6okv6FascjC4WE9nkZvJ0eTqbnA2a7jA + 4YX9f3K7NWyuwPuL7tdywzcxoEPYjG/GpGpi+GnPFz/5MSfft1pwvLiaCCTOfNdI9kvlOTijLJSaw01d + TiwWAJoFoADgkZGRotMAbCnJyVJsMnEAzrJtnxpfqGmbbGh5QlPpF9JVmlafGQ/KpRwMl2m0RQZddoCa + /smET/4g9TqpyIIwJmLiZZRAdTy5chkYFy5clAATcPoTo9rwh9Eo54D8Sfx18r+mEZxYx5XLGVf4mgxC + ACDyzxt6lPmHg1Xi279ZqpvY+3+PeMjF5GRtAASOJldb1f/K4eztQk4nt5dYAHDGDX2ZkRoQ+jYnn7ea + cLy4mvC27z1mZPul6nyqJA/IUQBwVCSNxjoNoE2BOE/6xH4xDjeL52C9qTi5/9S6TY+htJ/6MAzUJ1eY + +s8E5GI8qGLAyajLCZeZrcgBeO1NfVGM6ZQE02zHPMaCFcd75sKFi7UBDwes5WLmms4nZCT9FQ1MZsFN + L5ZBiv+lMIPPORcNg6NCCLA8wp4m7Sc+JOz7H2jZVYj+ycnkZuVocnWv1fyHHE4uJ6evhgDIDEAAsAYD + wWzzzoNOPm814XhxNeF9/wfv8f3y2O9oocYKDANyQrEI4P/rTfSZcwGYBbCHA3Eb4OQBPWLCSVO6DUDl + 2VYrNS27JdC6U34YW2eeneV+e9Qn8zTYRQZdbriSDYp22RoP65HBj+axkKJsXTkkFRwU4nC/XLhwsTZQ + kYYDYkvvZEw+lK/TlPoMa5XGEU1nyqHT388H6xNk3GxedhmC5W+j66WidY+E2vYg+rcyseBi5WRws3I0 + uVrT/1bzH3C5cjp9SimdP8F9f/y/wX8V+T3j3e+708nnrSYcL642/KNHv22kes30ldNNXQHYRqEKMdln + 7hnBcAxOkBpYtA1Apcl+AO37xNNSK9627WLU1cq+E5/QNJWMACxYYRbAwajLChMeuTS6QeZTIIWMIb8b + vVv806elWp2/uwXgwsWaRi4qodyABKfPyG+n79FjfhIPyYuR29SpOnJCGYH9//X9MABurTvxaXBtA7h3 + p3gbzKJs5WJyclH6Xzmb3M1ATvf/wenM8JbS+RMcvZ7uE9/IkW85+brVhuPF1Ybx4Oe/4p0eelb3op1u + 6kogd10AeFL9ZsqIhjPWJcbQSbOd5OlD4jm+XzxHrhcD+pt5BnWHVLTskMqmXfLnsY2aTpcY21aufivg + lwSj/0gVlHYAgoVzDDxy9twnzeFAbh8AFy7WOMCh6X7pP/9pkVRAro15ZD6NiDpeI3PkKSdOKCNc41FE + a/Lqn8fvkIrG3RIC3xqNOyXUzL1/q/iP0X9R+p+czel/uvev6X9wuiUAyPXO92r5wSPV/nPDzxoPfP4+ + J1+32nC8WA4IJLq+a85Pdr6xy4XCTHwahSUCuGDs4UA6P5pKst/cBvCcOiieY61myoktgdv2iQ+O3ziw + FUJgr+w79jm5ggWm+1ZsD+xg1GWFUUNmoKyvxaC0sch+zOFB4z75/PQO2cgOVovulwsXLtYOqjM98pXJ + HVjbAXmRDcqY+o9D7GeNwrn/skYS/BQLy9WMX2qPf0GMBm67bpVgwy7xtdUrB7P4TzkZ3FxI/3OsO7nb + Hv7DAUi287cEQIH7VxDsAxCInf4VJx9XDnC8WA4wTjQOs3rV6aYuJxYYgSUAPDyzyZQRG0dwG2DU3Abw + dB8Rb2eHGpu5DdAo3jaoz4PMAjwhwZYnJFS3W/5+tApONawTqxyNuqwQlIvJgMxkPOaxxTFD+27/VeJO + 2TDZteBeuXDhYm3hjswp+fv0axHxB7Qj6NWcX9f6TxNY68nyPwbI2QRXwKV/O1wBbt0r/pYtYrRsE8/+ + veJphgDoAP9a6X/lZnC0nf6/3vwHXA5OXxz9l0IA6DyVo429Tj6uHOB4sRyw7j0ffqMxOfxMRYb9kwfN + QpYJKLn8kASSQ2JMj5ktg51u+quEGkjRaQDtGkUBwDnS3AboOybGmUNmockRUwD4OhD9N+yRTc0N4mnd + ifdtUnvioyIssOEcfhjxZW4FxHmO1SvPx9ljG0atPQJWf1YAP9c81DVHa84zImCHwHgIpLFRfjd1lxi4 + J5xg5cv0awMRirLqJyGIptKyPpN0vI8uXLgoDW5Lw4lhfdZMYU1q47S0BNKDWLPMng7KH6Xvkv+V3FAQ + AOz5oWN/dUJoEQ+sFjLkQJ+OHn6BxxJ5MiHpkauso0rjlbNL0j7ZeuTTCLLaxNu8SzawHfvePeLjlFam + /8nFTP+Tm8nR5GpyNrmbZ//B5VrbZRUAOt3HVwvvJF7PjUswhcBxAv/2RL9U5OlH+qUyh2fw5NAPgm9+ + Z7WTjysHOF4sF1QMHT9v4MYGzsPx5PrEnx0QP4UA96f5MJdZwWn0T9BYigWAngZANGxtA2ijCe458dxp + R52EOvC+fptU1e+WEJTpOrz/q1HzJADH8L6YWyfzo+v0TCv78Ut0o1ygsZfDMUF8jnkQwgwW4Ax/ZtYC + C5A9Df4udZu05x6QcGZcZ1r7J86K55u4V/FBWZ8aM5+Fw3104cJFacBGMxsy4EGsSeP8CNZkn3ZQDaVH + ZP/kA+r8dTYJ1jTX+yxeOaZ8LgluKoM+ADwppZP+KFAmglqXcAnOfwYBiKR8OlDtL4cNWdfwuHhb62Qd + Z7Ds2y1huxCbHEwuJieTm8nR5Gpwtln8Z7b+tff/l1sA0Onrvwmf5J8AJ9I35QZMn0Xf1Xe4rDr/LYbj + xXJBeOuDm43p0Wcrp3Ez8wPig7IKTbFPPW5senkfJHGDAKDhFLYBTosxaJ4G0DGTx9rN1BPbBLdvF6Nt + j1TX7cL7ejFq90rdiQ9qdP08e1er4t4kP7XGWUqkUsdvzrAi12FRlBRKAlDgqbDMYsFxGpjdApR1Af+Q + DMtXsm0QAF0SmGAGoFeqY30w+LSEcxBGDvfRhQsXpUEojzU4kZFqTrlj338OU8t2yZcz7Vi7laZjpfPn + efo0z/+ba93OCNzAByXGlQyL/IAouBGf76epoPw0WaUnkn7CCab4s+0nPwhOfUK8bfWyrmmfGA0t4j+4 + A/xrcTC42B79qxxNrrbT/zaPr5AA4AwV9UWTI5p1oQhglrpyOiLG9PCzwYe/WhZz/38WHC+WE4zpgWcr + 4gNmtA8EJsdVCPiZZnF6IEuBXQRo9QMgvAkoSBaSMKXEngDWaQBNOVF5HoHhNW+W4IEmCbdsFaOxRara + +dogvz9+uxo597FmcoZczW+Qa2NQu0yzZ9bpcJ7FC6LUUIfPHuBw9jy1oOM2KQCYCdCUnF/+Gu9fw7GW + ULdBRBqV51KakdGhQU730YULF6UB08wTcDhPpiRIEZAb1LX6Vxz5zeDDcvJ0/myqw5M+3OITRNba/2MR + H5QaWozIzxkNIihC9J8PyWy+St/zRNL/OXKnNv2pbtksRmu9BBp3SdUB8G7zVvEeheNnPRa3ZIuq/5Wr + wdns/W/zeCH9X1QDsBzwTI2oL/Ll6ZvwLCbHtJMqfRZ9l5NPKyc4XiwnGG27j/kR/ftz41BxuOl4gF49 + o778+zlEQQAQHBrBPSQakp4GgLJkgQlTTdoToF38HXvFONQqARinnycB6neIj+Mpd++Sr5/8khr5j3iW + lQuSA3hSNTI3FpSZDFRumSxAsxEQU4KmCJhJejVVyOM3FAicv/1riXth0AmpTMLpU4RNJVUEON1DFy5c + lAjZEQlMZSACxqUyAe46F5X/FHujuabZ7x/inWuZkb86/wgif671BNZ4OfQBACe+EF+Hzxo2OZFZUXzm + f2TdAgKRr564T7y7Ee23NImnaad2XvUd2C2eA20SPFxnBmLkYnKyFv+Bo7X6H9zE9L8O/jH5fCX8hQ6V + m7B8Um5UvJkxCeQjEpjA/9u647CTTysnOF4sJxhvfVuF58neH9Dxb4yxyAU3enJAfBlE59z7cngoS0Jx + FoCgEVFZR68XA2prYKacTh0Q75E9EjzYaraibN0r3tbHpKJ2J5TqHqjUffK/Db7OTKkDz7MYkGl2ztmO + VchVK9W+muBUQCULRgoREESCQ4zCWhRIXGSlMFOHQDzxOfFQ5aZwP6ZiEszhfjjdQxcuXJQEwXQPxHga + PDWoR87Sic9qtM+1fRk8w4I/3fPXtL95xFcnl2LNX8XaX8wHpYZOHUxVyFzEq+1+f5qsMLOPOY98u/9N + cPxbJVxbK+HmevHVbxMvR/4e3CPrDnL7tdHc+wcXKyfb0T+5mpxN7i52/ssc/RM+CDDd94dP4ta06aMg + Cuiz3vJWRH7Ofq1c4Hix3GAc3ddLlVXNftYTuNn5AalM4XUlOgXSSAg+VILpIxoSU0osLGFPAKs1MPed + 2BjIu79OvKxIbYNKhULd2LgF79vFgAh4x+H75blhOPy8X/45dptuB8xz4UWr5AVE2k6LoqRgkw3rvZkS + BEEk/VoYOJtClJAIInLwymXu1UV8si/7NdnAMcGZTrPa1ekeunDhoiQI58bg3M7I+mxE9ma+jvXMcd9c + t151+jMc/c2CP+75x83In+t8PgERUAankC4h4OBJAKb8ufX4T8lN4J+g/DOCkbcffFSMhu0QAe1ye/NW + 8TTuNnuvHKqTwMF94F44fzv6ByeTm6+f/Qdnk7ttHrd53eEeLgnwQVVpBI2M+CdH1UfpdjV8lpMvKzc4 + Xiw3GB/5xXtDU2PPGFOjuv8fTvVJDY8CTpVOAOg2AAtLRrvEO3DSPG96+pCEjjMTcEi8zY+JcbhVAg3s + T90gVc2bpbJxBwx4lyR7PyyzPNYSh1PNVWJB4j0jbM62dlgUJQVrEuDgmQnQwRu8RgVOMUAwmuD2BVuH + 4s//3/Rt8tGJw+JDxGFMQ5A53UMXLlyUBudjujX6wYkj8ldpOM8s1nBsk8xT2E9g3ZJruJ51T93M+LH4 + WJ1/xGqzu4q4FmNfgmp9f4lF0gyKwJUDZz6hAVRN3V6paHsc7/eJv3mnGB0dUt0KUdB1TELc/2cQBi7m + 5D9ys1n8Z87912LulRYAU2OyLjWsMxe0ABA/q6+Cz3LyZeUGx4vliNBwx7f8yVHxTsTFw3TL+UHxsUeA + 00NZCmxDscEUklULYGYBTlsDgo6Kzpw+iUifPah5HGW/uQ1gNO8Ro2mn7llVND4u62u3y/9KhHSYhSQq + AZ9cSIVkTiPu8scFbgHwsydfo3t2fzF6h9z7r3rFExuSqkkIo2yfhDOdUokFUJ3BIsgxDdYnFRl3i8CF + i6UgnAPfYC0Z4DoevV2H6LIye1LXXNUUuCnZLff+cr/8WbTC3D9P3S6zeL3MrTvr6F85gz1ILrNGKuKR + q8lKuZjyyN8nwhJu2AHeZHdVOP1mc+qfOfgHHHsYXEvOPQXu1bn/4GId/IN7ZUf/9t7/Yj53uMdLQSAX + V1/E8/+efEwCeEbhkYNl2fffCY4XyxH+r/zSZ4z84NM61tLaBmDBhdNDWTKKDKZQD7BYAPQfE6PniBid + +8U40WYaJdtS0kiLRIDRWC+hlp3SevRjGlFfSvq0MIdp9msOC6LswD1DOP0X8mF5np97fINIOih/OuqT + e85BcU9SlOVw39IgpRNQwBmpnsTCYI+ADI9vLrq3Lly4eNkIpuIQASNmI7RzLPaD859MSiDPNTcur508 + K/9lDEFFMijXIhvlp+SYbFiuZQMio6sf4b8UzBNHXpnhFoA1Qn3PqY/LujpyZ6Pp/MmltgAgx2rjH3Au + uZccTC5eLACK9/1tONzfpUKL05n+h08yRy4PPh346i99xsmHlSMcL5YrvOMnvkOn753AjcYD5tELp4ey + ZBQZTUEAcCsgYfYE0CETg1iIrAVgMSCzAMdatCsVZ1NfFwC78doiwfY94tmzW/5weKMes5OUV/sAaHrO + YVGUEzgimAKAjv9FXhsFuK8IMfC/Z+9FRNKrzUiMfMp8HpPdeD8um1K4b5OJhffVhQsXrwzTKdmQwiuP + ++X7JJQZh9BOqtOpPjco30+9Wwf8cGuRa/MSOSXCfXRDW3w7remyAgSLFkdDAJAbf2dso3h37xJfO9ur + w9Fbzp8zV3QEO1v/kmsZ/ZN7ufevc//N9L9yNLm6VAIAwoz/D32SJz0KEXL0O06+q1zheLFcEXrsK48Y + 5yM/8KSwGKC8fFReDg9l2bBYAFgDggpZgAVHAq1tgEVZAL+OCt4rFXVb5GMdD8L5e2QmHZYrMHwdwOO0 + KMoIlybxOs4+AXiNV2nmgqcXZmIbRHJeSaY/KEGIAE+6RzZSmOVwn1LdclsWSnxqhQSaCxe3CiajclsG + vIP1xZ83TMaxvvoknO+XbPYjEOMBuZyskJm4xxz1m4Iz5VoFLrMGwGFNlxNmUjzz75PL6Qo9afTxAw9J + sH6zGPV7JNy2TYwWSwAwsCK32un/4qN/C6J/3KvFAmDxPV1GePMIfliImYIwOzf6LH2Uk+8qVzheLGf4 + M2e+b0AFB7kQSnAOvSAACj0BrM6APG/KYydMQdmNgaz5AIUsAIzX3/SoBOu2SmUDC1maZLzzXbpXNw8B + MFsGRTgvhSskFajzC1kPIox18nzaOqubqpArkXUaaXTHv2wWBE4NSGU6ItVZ3KvzVvMmh3vqwoWLlwdv + Futqul+qcr0S5vtJcNFkUs7GvqIFuldj1TKfw3rMGPIcBPn8eEgucA4J1u5VrtlF67ncQAGggiVvyOjp + 98LxN0lF/WPir98qoWZwJnnUjv7Z999u+8u+/+RecjC5WIv/wM1F+//K3Q73dFmR7TU7pKbHhL7JyWeV + MxwvljN8ux/eE3wy/oNQJmLVAjg8lGVEQQDckAU4a7ac5P7Tz8sC1O+EkoWirdst1U27JdywXX44DpVO + AcCJXA6LopxwGYtTjy2m/TIfC5uLNe2VF/JYuMN4H6nAd/HKgamHIQBwf/IJCeUS2hjDqwNJnO+rCxcu + XgamzUAnlIWYZk0N1tX+3KOic/KTfjPtnw2bQ3M47Ge8Qq5SpCc9cjFW47imywoxfAcEFH89Fpaqpp1S + 2QbO3LtHKtq3iNG8uxD9e+j8ral/yrX23j84eMHYXyv6L5kAgA+iL6JPom9y8lnlDMeL5Y6q8dPf4X6L + f8JsurCSoBEtFgGFLMDYGfEMHBdP71EzC3DygHiOtKixahYAIsDXjFeeBmiDMdftwPt98vjBj8sVnq1P + sfEOvlI5YywoV3lkCCLgWg4RBftzs5XxONQ7Io+ZMZAMxABHHzfknpDguaT2xtbe5O4xQRculgTfZEKq + 6NwycHLfHJc9+a1yJYr1l6uSa6NBmWX0zyZeKsZrZIbFfylDLqSwLsfM43XlDHLL5ZhHHjzycfE0wtHX + 7zFrpvBqHIDTZyB1oE48HQisGP3bbX9Z+Q/u1cY/dvS/yPmXQgCwNT2PYVaOdX3byVeVOxwvljuMfZsb + jMnxZ0Lcd3F4KMsJbfVYJAL0bKl1IoAtJ71MQUGJes4cFs+pg+I92moaq50FaN4nlfVbdTsg3PqYGPV7 + JVS7S/513z1YqHCsDoui3HAlGZT50Q3aUpRtgdlj/Cper6TNvt2X2ScAv3chsU52p/aJZyIugSncK+5d + OtxTFy5cvEwg8vdOwblNDMje9HZ5kS1y4TQvwelfPQfnmfKajX5S5tpkId1cNCQziaBZvLtoLZcdEAT9 + f/peK/46c6x6dcNj4q3bKd5GDlhrKET/3kPN2vefHKtN2OD8lXuLGv8oNxc5f3K34z1dRnBSqjEx9rSx + 5/FaJ19V7nC8uBYQyJ5+isUXARad5bBAps1TAcwMGNyTgTLj8Rmnh/aKUVQMqFOlqDQZ4bLftFUMWGgP + fLJdswBGR725b9WyTfz798jtDVCzLQ0Sat4igfrdcnf75+VHiSpdsNzHY2r9SqZSLmVq5BIXRtYjlyPs + GYD35Yw4gEV8if288f4Svs/mc/iuGdy3iYhUcT9umg0yImYFMwcIsX4jH5ealNsnwMUtjuxpvKawVrJ4 + RTTJVtvcOpsYkzBraabAO+lheWyiRV6MMwOHNabd86y157QmywiXYhVyLRsEP3jlYqZCLmcgVvAdrkbX + q2D5x4hP7jnwAATADjNAamoGV8LZtz0hRjuzAHUml2r0375g6I92ZSUHg4tvmPm/TMV/GsRMjkogHxVP + EtemRsQ3NSpB+gDWY2Qj4k11fc/JR60FOF5cCzC2PLTZcy7ybGEyYLJXvJlhCU5xn4z9ATiUga83PtRX + jJ8lAOJ95vETigC7PTAUqipVzQLUwfk3QwjskorGnRAA+LlxmwRr94lRv01aOz+hxS/XdFGbzn6W6TwW + 9+jiLv8agSsQMdcSIc0IzKd98uLEbXJ11JDHpjpwzwb1iGBlhosF9+9cn9Rke6Ua91F/noRwc7rfLlzc + Ksh2i3dyRGqwJmpS3XD8vRLk+wQdD9ZHdkwene6Qq2OGXJio1mj/CqJ+Du1ij3+nNVleCIMj8Ap+mOHW + IQKdiwm/igDJ+qXx1MfEaNwhvn17xdfMtr+1WitltOyUEPv9W+n/4uhfuZaV/+RecPBKCgDylJf/bnZU + fNMxPBtc41FDq8CZPsh44sHHnHzUWoDjxbWCQKLru5zAREdfyWOBdDRZGAAejp5JVyGw6IG+GlgCQEFj + oADgNgAMzzt2VgwqUWYB2JKSrSm1MZB5IiB4EO/bdoi/frN4mhtg2Hsk1LhXjNpm8Tfvlv/QfzsWh3l0 + RwfvIJq+Ng5nmoXzt1LrZQ0IlucyNSK5oMzxdMBoCN9ho8zjsz8+CfU+EZUgxVguLv4cRFMemIxIOI97 + yJnZTvfbhYtbBeAoHunjGFkj3S3VyR6pTmN9MPoHhz020Saz5IHMOq290UE/maA8n8XPTuux3KBchiCH + gU0yKC/GrWE/GY881fca8cDhG40IjOrBic314m3dI5XN3DLdCwHQaFb+g0vJqV5E/6y3ss/9a/EfAzFy + sSUAbJ5etgwAfQkCS4N8BVSmRsyCzIkx4Th0f7zzu06+aa3A8eJagbH9a9sC56LPMkVWCXWmmYBsjwSn + R0yltlwZAMA2LGYZVARYAkALUGiIVhaAtQBaqMKUFU8EdNSKp22XhBDxBxth7K37dKRlZf0OMfbulPe0 + fV3+hfOwsVhmMxUyk9wIxYxFkjLkcnRt1AjwSKMWCMbvkBk2Cop45OJEjbyAxb8rvUdqplK4XzEJpaLi + nRoXD49vZhNSDfHmdK9duLhVUKHNs5JwKD3iyw1JGM6fW5jB8zHZl9wlz8NxvjixHmvKb66tRI0e+9Nu + otznd1iP5YSLukUILotXy9VktcxkEP3j2o+iVfK+tvvFqNsjFU3b4Px55r9ewnD8PA3gb9kn3gN79Ny/ + Y/QPzvVEewoCgJys3GwLAId7/Wqg25Zw/N5p/JsQZwEGnDyZkRzk67PGtge2OfmmtQLHi2sJFZGz39ER + wXD4jPp93xrX5gzBOB4aG9M4PNRXA9uwbBFQyAJwD8ruC6BZAChUZgGOW30BDtdJxYFG8bXslkDTdvE1 + Q+k27pTKhsdkw75H8b5Bmo9/QlNkTO1xTPBMLAwh4JH5TBkMC3oppDxaszA3bp3nTd6mUQobkzA78AIW + fVvycZAantHkgKzPRyWUHpFw6qRJfg732oWLWwXMXvpyndpDfmM6prVMxpMjUp99XF7kiZso15JPZuFE + JWn23WDjnEvkh2T51wjNZgPgMr9V58STT7gOfmg9+lmN/NfVPSKhhi1iNO3SYT9BbgfgfeUBBEt2178T + +01O7TlmdmDl8Wut/L8e/Rc7f8LpXr8aVGQhyDIQGOCu8PSoWVio2QWItbGza7LyvxiOF9cSjEe++sDt + 34z8jsFe2akhCXwLiyh5RiqgCH2TeO/wUF8N+OBtqIFxH5sigAqUIoDHUYa6FmYBjreL73C7BA/BiA/s + g8J9VNbzWGBdm6a4glC64UZ2vWqRJ/veqPUAunCg9K9kwmuiyOcaFvQ1EBOnj5GY+B3mk1V6tOcKzylj + sV8Fie2fhtj5ZgL3DGIph4hnOg3iO+V4r124uFUQTnRiLeTxPiNGvAdOJi3HJh63on2snXSVCmyO59bp + fvGA1txcS28qzP0va4DDLuXw2bn/n0BQkDPkyf57xGholIoGBEStiPwRBHma2uW2lh3iaeYo9X0SOlIn + xiH2Vmm/3vWP0T85Viv/zb1/5WBr37+Yo53u9asBg8j1CFiM9FnxfAtiIArBMTki6/5V5PeMr33pi04+ + aS3B8eJaw20DR6YC52PijVtHP9I9OpmOledOD/XVoNi49P+gALCnBNIQx3s0C6BjKa0sAEVAiEZ8CFH/ + YYiA9m1S2bpbgvUw6v2sB6gTb92jEm7YJTWte+WHcJwXOXwHC4etgjWiXrygyg38jGk/hACICmKAEw6f + S280mwaBoNhI6NpkhczHvdKduF/CbBbEaY6TWQgBtwjQxS2OZI8O0/JMDUkI62Igdj+cpVckG5ZLXFtZ + zu0PaJ0Nh4dxjV1L34a1Vf7pfwUCAT3VhM99cdwvP0zUSE3bDqlApO/fR2fPk1J1+PmArGvdo/VSxn6e + +d8nvkMIotj1D1zqtaN/Zlqj4A0r9W93/buBn53u9avB5LjclmV9Bvgdjt8XG9btmXWDh847+aK1BseL + aw3G1q9s9uaGnqpOx8Wf5DGNYQkwTUMR4PRQXwUWG1ghC2ALABilZ/SMeIdOibcXSpXHVaBcq47A2R/e + IlWHjpiGDcUbrN0jodatEtjH6J/pr0YJNe2Q+zo+r40x2OXrhRQc6BoY58kzyXzlkZ55fmZe46yANN5D + zMwlAzITXSfCcaURQ6ZTH5MNHB6UG5Lbs7hvDvfahYtbBaEpOJaJIbkz3y/51IdlnusnFpC5SLWmz/XI + HFv7Yk1xrXE92ZE/MwHX12GZAo7/Qmq9SDyk25r3HfqshHXCX5sYDVskWLdDAk2PSGU9hEDzbvHuhxjo + QNB0bI8EjjQqhzKjSk4lt2qmldF/kfNfHP0TTvf6VQE+hMXlwfyQ+CAEgpNJ/vx949EvPejki9YaHC+u + RXgHj51nHUAluwOeGxR/qm9letFTWBB0/oRdC0ARoLUA5okAbVV55pB4TxzQIhatZuUsa1a9csIV4Gnc + jcWwXfzbH4YIwJ+1Nkv07FvM0wBwoDNZQ15kFIBFNJP0Qvlj0ePni8OVcKY2KZQ3ZrD4NZJhSjO9Ua/9 + auJN5ihh3jeo6eAEFlgWqn6S1bURLGCo/MkzskEnoDk8Axcu1gh0ZPn0EHipRx2IkemVULZbqvJj4mEx + WXRY7jl/Vv594vXmdlrqdu3qx8mbWgxctJbKEtzyywTkIgQLe5pwoM8sixPTPi1ivkyxkqySS/GgxM++ + HRE+HH9rvfh3PCZVTPmDA20+VG4kR4IryZnkzkLPf3IquZUca0f/VvpfYfOywzNYCsxTAPh/zg9JeJL1 + AHimgyduiuifcLy4FmHc97kPG/m+pyuwyNgbIABnwnPoTg91yYCh2RmAwrFAGiU7Uo3ZfQGOXu8LwILA + woyAOvG08MiLZfSNOzUdFqrbKlWNj0t13aPy+0O3wenzrC++WrpCZnn8B8r/0sQGrbin47+MaODH6fKP + AFjAxELBq9kKbWF6JYnvhu/yhxG/3PvNM+JP9kgwNSyhyZjOEDBy/eKdTMmdqRTu9Qo9PxcuSgTPVFbW + JyFsWfdyHgHK+aye7TfScGhTI/LGb/XJfx3za6p/BmtjNmrN2cC6ueqwnsoNP+EwnzHwEIORcaz37Hq5 + gvUuQ/g57ZFrLAaGMPijwbu14K+q+TEJsBtq8xPCiX82DyonghuVI8GV5Mzrlf/gUnIquZUcS64F5yr3 + koPJxSvg/BX4d72TEGsQAuEMA8q+p+lrnHzQWoTjxbWKwNm2hJHpl3V5DtAY0wYbjg91qSgSAMXHAtmP + 2svqVLsvAPetrFoA4yiUL5Vte73Oti6IgPa9UtGyS9tf+vZ9QxsEvbPlG/IiHSedPRbVZZ755bAPLLiZ + dCUUt19Hfz7HFqCLFmS5YW4c5ABSY89ypjfnQQrzkxyG5JU/j94uvzjRKesmqOqh6CfHpeqbaalMcoF3 + yTqmR53uvwsXawTV+ZNw9sMSzoErzkHgZkfEnxqSOyci8ov5g/LDyF0yF4OTzPrN8/JwlhTMwvG+kfIX + +JfHA3KNzj8akBlmLJjtw8/PT3ALkO85lCgg7255BNy2U7y1j+truAWRf9t156+cCG7UTCm5EpxpV/4r + l4JTlVutiX/2sb8VFwBsWJYfk5ocfAp8i/9Me8LJ96xVOF5cq/C+/z13GxP9T7NlYyAfMY/UOD3UpcIS + AAXYWYBkn55N9Y6dNhUr01ZnzeZAWs3KhhYqAtgbwJwWGDyE173bxNdYJ56GHeJp3YHrTbKv4yM655uV + 9Fe4wOBAr2JBXU2u00I7TuTTISAOi7KcwNoAJTJE/xc4wCSJz43o4No4RY0hP8zXyI70o1hoUanKDoo/ + DTGQxyI/H9MIyfH+u3CxVsBtyG/idbJX65NCaUT/E+PSkH5A/iW1Ude1jNaYEXPKJy/mzbbgHMKl8/0d + 1lTZIcNOpszurZMrPAk0aRYrXkiH5WIyJHsPfAqcxqAHTr/Bivr37JMwi6M57U+df/HEv3aTM8GdyqHg + UnKqnvu3Jv6Rc4s5eMUEADiIbYCNBP59+pb3vudOJ9+zVuF4cS3DqNvSbJwbedafYzfAFTIKYIHxcQ9K + BYCZBSj0BeCwiu6jYvBYIKtZqWx1K6AO6tcUAOwPwAFB4dqt4mGHwJZa2XCAQ4N2SeLsu3SP7X/Q0TMy + gBNVZ5ry6jTBNdEpMOvTWgZ+7mtj6/V0wBwI4yKuzUc3mKlDRA8T6Y9jgaW033Z4EmBWIDvheO9duFgz + mEjrnr9ub8HxG99MyXDyUxDviPLh/Oci63Vu/1WuhwiiZoiB+XjQzAZksMad1lQ5AbzElP81fpcouCnu + x+c25H9F/OAun0RPv0eM2i2ysW2LigCjabeE9kEA8BRAU61yoD3xT7mRHKnz/sGZ5E5y6OJ5/+RaK/Iv + cLDTvV8G0Ido7ca5sWfpW5x8zlqG48W1jnDu7FNGttfas3F+sEuFfRKgIAAKIgAKNdZjdgek4fbDgHtg + yDwVcGI/DLzl+qAgGH6AabG2Rgk0bBf/3iekunUrFscuWd/yiNzZtFX+vz33iJy/TS6PY0FBADB1/kJ+ + k8zy/RqYFXANBEcnz0rmF9P4DoxuouvkciYgMypq8N3SID+Q3n+Kv1bufrJXW2/6M2NayOl07124WCuo + jPVKKB+D8z8tG6YH5OnIG0WbfuU47Kta5rBGLkzwhMxtEMSGPMeon+sEDpWC2WlNlReC2uv/cvo1enpB + gxJmM85Vy//v9J1ye/NW5TKjYbfUtGwX397N4qtnprNBTwCo8ycX2gN/yJHkSnImuZNHq/Xc//Xo3+Zb + m3+Xtep/EXTaX6Zfwrmep5x8zVqH48W1Dt83vvigMdHzdMUKjgu2j5s4iYBCFoBHVgY7TUNmOotHWljd + erhRPAfrNe1V08YjMVTADbK+9hEJ1JpjML11XDR18saWrfI/E+t1kMZPExtkDuRwEc6S9QFX0uVfA8B+ + BhdS1tCSOGcemCRxFc5/NhfW/gBXYn6ZxZ/Pp4LyV4mQfHYChJAeFe95Tg10vv8uXKwFhLnvnx6UT+aa + 5L9zDVD0MqNHRxn1y0w+oCd7ZiiMx7GuY16ZRwTNIl9O0Fu8nsoNHAnO7/KCnlgIyoXoermCn38cqQB3 + PYqIf594a7eIZ/9eCezbLev3PSbGQWYAmmV9K4SApv7rTU7kaSlt+gOuJGeSO19i3r/Nw073fjmgPiTX + /ZT3kS884ORr1jocL94MMGJHfiWUWb5OgIvx8wSApqmoWO0sAA3Zag7k5bjgo03i7WiA0+c2QL349m+G + 098uHjj8wL69EqqHCIAoCDTuEk/dA/KJgw/KC1nzCN2PUpVmFA2nqd3BFi3IsoMWMlbotEPuCzL1f5Wd + waJBmScRcgsgEQYJbsA1EF40IP+QqJH2ifux8HAfHe69CxdrBhPD0jH5oPyEI3yZHsd6YI+Py+kK3RrT + rF7ED0EcwNrw6hq5hN+TKH7faT2VGVi0aPYuMOSf0uAmrOefZDfJBw8jgGl6xDrmt1PCdVbqv6lOx/z6 + Dz4h3pZG5UByoXIiuZF7/0z9kzPJnYXof+Gxv1IJgGA6CgFy9DtOPuZmgOPFmwGB933wnuD5sR+wZzMH + 0PgQUeqWwESfFgd6OaoW150e+isGC1CIYgHAoyoAmwOxiMXoPw7DPmwq3ONQutaxQCpjj1bDwtljsdgw + GnaZYNOMhhbpOfoePQrIiPoSSSPtkatwojwudCULYoEg4Fl7nsW9wsIidaxrAPicc2mfEqAKAkQP12JB + +fv0Rvm9zGtlU/aMVGdAAqyixvOr5pAn7qXmxyUEgRDMxvEz7rVOf8ziuUYlhPtfkRwUD7sOOj0vFy5e + NoakKj0socwAbAt2l06bx/hoc7lRCWmvkXHxwNHrmGu85wmkDZluuW3ipPxR+i75X0mIW2a/YN9zWLuX + IdyvsojXaT2UGyjguYWXN7lFRrg+/XI5h8g/5pMZ/k7OqycZKF74vbo73g/OgiNX7jKxgNvIdeA8cp99 + 7M/gBFU6/97rhX/KnRaPLhAANt86Pq9XiKkx8abxb7M5GfiCw374/IJPglcSPRJ6cvwH3ne//24nH3Mz + wPHizQJv056DxpPDEsAC5mL1JdjGMSLeSTrqXglPLWOjGRikqtLCiQBTBHBcsGf4tNnGsveYub8FpauD + glj1ynnX7VYxDI/ELBIAGxqgpPdul/VNO+Q73a/Vxcbz9NolMOXTCOJFOn0WDHFfPVsBkkH0MAbC4YJd + vKDLDYgcmMmgAJjld2J2A68X0lUqAv4uvl6+PIX7kYtoN66aXJ85KpXPkAs11yWhqZQEp2ISyHYiGjgt + /nODeLZ85iBqp2flwsXLBM9/+2lr0xCckwNSne/UwTBsWBWc6MXvwBbZLCZljri+jfvU+PNfOr9D/uf4 + JnX+l1IV5nqFvdPGOcefc/01+l+8HsoN5BBwyXysSqeVsgUxueYCG/zg88+xJTHW7GUWLcY98t3eeyXQ + +Jh49m2WmsbHbxAAegKAlf/kPBb+ceAPuZCcyKY/5Eir8E9HrRc5f7vyf9mcP8Dny34xnkwfuGMIHAIB + NzmuPsPzJMRAw652J99ys8Dx4s0C461vDQZip3+FC9KPBeuBOg/iofsQOXJ0sBrTIoNYCvTfs7MAlgjw + 6bFAiAC7N0C3fSyw1TR8Fr8UnQrgAoFwKYgA355HpZpjMXdvkeqWPfJ743fpniHBYiJ23OK0Le6lc7FS + gc8mOCu8Shel46IuJygJ+hBdcAKiV+aZuSDpgCiZCZhhV7F4UEYmPyGVk4gI0nE8v4jO5A5O4Z7mOEiF + E9VOg6R78JwZncXE+FYEURiehcNzcuHi5aKanfy+OQanD0xRCPRJZRrCnuKSwnPytBk1MvJPIKB48oyM + 5T8FpxjUSF8jfzp/2DRb+M5CtNPW7YyA45ooI1zK8LVG5uLrtJWvmVlk5I91afMOs3ijhvxh4k1a1GzU + Pi7hA5slsM8UAOQycprt/AtV/+Q+ciC5kJlRu+Mfo//xs8qdhcifwHpebs4mAhPwCZl+cAr/bQYNwPSQ + +MZOfdt4+9ugepz9y80Ax4s3EyoefvAB43zfD6qg6nQ2AAyJSk+HBS1zL/pCTQCVqpUJ8MZ61ZALWwEL + pgVSBEAB26cCqIytBkGFLEALFkrdY/iznfpntzXtlr+LsFMYW256tQjniqYYcY3OFMJgJuOT2VylmZ4r + c6jDB6GwV/iclVLUZihMPeqWgE9e1AjKkN9Kv0Y+msP9ymQlzDGd+QGpwbP0JvFss3gG580R0KF4VHxp + EPb5xA3PyIWLVwIvW4sDvnRaApmYFf3DOUCE1lBggkc4MtaXSsi7z9fK76bugbP3y+WktR4tJ68jsmHX + 89zfh61z6471AIvXQ7mB63E+V6XNxwrFi7Eq5ZzLybDZ3Atr83+OrpMNzduVpwItcPANW0wuswSAchp/ + pgCwq/7JfeRAciEzo9asfxb+aT8VcCc51OZTcuuy7/fjWVZCwKkIIIfk8Z4Zhm8N/o73q1/+jJNPuZng + ePFmg/d43YDvl+Hwk/0SgBDgfp3u+0xTuS8yiCWguCjQNlpvgr0BIDSs3gDcCvD0HjX3u7Q3QEuhHqA4 + C8DzsjwOaHBR7duiAzT8Dbsl3LBDfqH5QflxqkauJiu1HuD5ZFAuZmuwYM20IlsIa8OdSPnvM7IngL7n + ueFIQAmSURJTpdfwXS5TIIB4eEZ6LuORK/j9sdRnpRrO38ilcd9HZVMGxHFuSEKprFSlcP1cr1RkEI2x + e5fDc3Lh4mVjMiKVFJgTveooQtmcpv7vTB6DndHGIlKdHZTezBc0GmZh3zzWHdcgj+rOQ5DTlmnT6vxh + 4xS1PMLLvvmL10PZgZMJOdabYoXOn6cTshvkhVRIuedyxivPJ6rkba0PSmXjNs0A+FsaxLsL/NWy0+Qw + ctmC6N/a9yf3WdP+yInKjQyUtOq/3+TOIue/IgIgP6jZYO34B8fvYy3Rk3h/dF+vky+52eB48WZD1Tve + td6YPPtMFRQeC/9oSFR+zgaxNBSLAE1ZMXXFNBYnWOmpgE4dGawFgRQBLH455iACVADswIJ6CIunXhsF + GXV7paL2Ealo2iafbL9f/jG5zlyYcJI/Svt031xS60A+PrmokXVw4WIuQ1AAaCTE6IIigJkAbgdwrxHE + w20MHS6SwJ9Fg3KZE9AQSf1J/G759DTu1SSc/CQiMnZYm0yClEelKjMgFWmIrinu0To/JxcuXg4YLPhz + vVprQpGphaacUzGNP58el89N7pPfzdyttnw5HoYNB7Wolbb8fM4s+NM9f03788gc/4w98g25aovfckY8 + YHEJRUuNXEDg8WNmA3SbzpB/ws+fO/RFCTY8LOsawVG790kVghSjvk4C5CxwmHLZYudPzrMK/3RblGPU + yY1a9d9nOv+itP/KOP8RPFs4fG33a/68jls7yZPfq37nuzc6+ZKbDY4Xb0Z4dz66szI//DRVHntxe89D + vXOcZJExLAcWZAEoAlKAVRBoRK3eACxyYbGLfSqAzS+sokA9F8uFolmAndopMASnb7QekA11D4vBRdWA + RVb3mNSd/Ij8c/ROLFKQDiKNnzJ6zmyS+UzILAzMYqE6LepyQswkw0I6lNEGwCKp2ZQXpFop1/L4Lrj2 + XLTajEjwe/8w6dMoKxf5mNz9TRBzNinhPEh6OiqBJJ8F7vEUtwlufEYuXLxssH4o3ymVCYjLCdhW7pgE + J2Jyz7dGJDL+CUTAEN4swKWThA3/OH4bhGq1zE2azp/bcVrwxz1/zvdA5E9bn0/A7tWpWnZfpriYCSDa + x+flscX0RvlJDN+H9UcQO/8Qu1OaTnxcnX+IvUx2b5VNTVsQqDTqiN8AeIocpul/cJoW/rHwmVxHztMz + /4fNmSmLon9ypid5nUeJlRAAWr8xOWoKAfxcqaN+778pRv2+HDhevFlhjB//Dqs+K1NQflY2YLFBLAeK + jVYFAJUsBYDVIVCVrmYBzN4A5rCgFvF0NOk8bC9FgNYCMH3WIJ6m7RJseULrAWqat+FaHZT1duAhGTzz + TvmnyB1KQJwedjllRf2697gGBMAYydGrmQDNBjCyiAIkGf0dn3ZI00xHyqOE+wJTp/x+0fUiEx752+Eq + 2ZKCSGIGgH27zw1gYcfFm165PhAubg1UItr35zhXBJHpBE8QZWRz4jH54WCFzE3TDlkgx8FcHNSFtQfb + 5NhutVk4SxUGtGX8TMdPG9fW2HT+HOm9eD2UG7htoWvRJ5cSIT2GzO9I59939h3gIKy7WgYs7bKezp9H + /JqfEF89eIptzvkzuIycRm4jx2nq3xr2o2f+rb3/Qse/QuX/QgHg9HyWCg4UIsKM/Hm6KH76u06+42aF + 48WbFaEPvPPuitzgU0YuiofOB84jO+Pi4ZxnFn5w7jO3BqaY+hvU0wJORvNKoIbLYiHdCsD/RwPnWEtm + AQaOi4cLgAUw3AtjWgwKWRcKFTMXUEtRPQDTaYsBlf2v++81ZwMgmr6YqZCrTEGqSg9qLUAxpHiCIBdz + 8WJfg7gaqzZJF0T7q7F3yMcyx/AM4/o8q9hOOI/nmMUrSNzHSm09tz0kngyeLY+HTscklOmVynSvDpDy + 8jghnr03DxLSfgPOz9XFGgHWtifXh7Xcr8+WdlCR6tFnbpyDnaSsOhEODptC1ImI38MhVOAFFgtXp+NY + w7CZbFI+nDopvxr9gApRDrJaC+N6XxLFHABuuJEvQvpnzMBdSFbi98NyFfh27xu10M+Rk+x9f3JX627l + MnKaOenPdP565E8b/phV/9dH/S7s+HfD83yFCKa59vEsGewh0jey5r+pnM9nTB/AQs98XKpS/d8z3vuW + m2rYz0vB8eLNDE/TzoOeidGnedSjgn0A2FgGYAUoj5Bxz0870OUGVQQsNqhXigUCINVntrS0agEoAnTc + JWdeL2gQZGYBdN+Mi6j5ZwuAUNMOqWrYKb/W+1rTEdLx41XSIbk8wkpjpth5Bpmpcxv485sEHDNMscNJ + ZJILycWUIUOZz8qdTOmBTDRtqAIvKaH4uIQS+JmOfToqlRCCXPh6OoTFP1k4CwiDQLpLx7eGpyYXPEsX + aw/BibwE9ZmeMcfH6jPHs6Zd5BISxM+BCQqDUfElIRLiFId0CLAR2AD3oV93bkzGpz4jl3isNhOSS7FN + cm0Mtsc+HA42uXZxnSNs3rg4FsS6qrie1cgE5JneN0hl/Q4JtvwcAUDOUgFw/cy/Rv/2kT9yXuHMP7iw + 0O4XDtkSAMsR9dP5a3AHcK4/i8A13U/eZ3M4btmej7P472nvvm0NTj7jZobjxZsdnkzn94MsNJmIgiDG + TecPcD+IHQKp/FUIIHp0MqpXArsmoDgLwCMumu6ytgJUBFARW6cCdKEU9wawswA8Frh4sTXsk1DdVgm3 + 7pL/MHCP6fzjlVDpAV3Uhf11C4W9doLneguLf23iRZDypcx6iACmVA2ZY09yfMe/SIbl6PRXxTgflYps + FyIBRPRaJIhncR5EwxMgePbrEBHUTLApFMgfBMGqbpIFnUY1t28cnqmLtYMqjgZnrQ+dABy9bzKqz7o6 + 3yM1mUE8Z/yeZRPM/PggCswz4V169v9g7gn58wTsi/vgLH7TzJpHZnI1cpXi08Em1xSKOGAxT5hc4YO4 + 5lYFkDHkPw6+Xmf568ySRjj2G/ioOPq3C/8Wpv6Z8bTn/CsHcltUz/wvdP7LIQAUmvUzeZjOn1zPYWNB + 5f+YZh68qVPfc/IVNzscL97sCHz8Q2/znht41hsfhaOH08dCZ/SvEUKS+8fDUIqMCOE0FhvTK0SxANDj + LCkebykSAUx/cSEwHWafCrAbBFkTA3Uh2VmAYhHQsF17bPtaOD54s3jadslvD74VC9grV8cCMpfH1y1e + 7ERhYUPpF28HrFWkzf7qHJzCNCW3QXjUiicHOKL0j6Ovl29M4P5xaweKXzt9TeAZ5DslxElfuSyeTQzP + iFEhnQQIYgLPjAJQRaDzc3WxRjDJZ8nR4KYT0BSwZv1YH5KTCoj9YPaUbhFwdognFdXffzy/D7Zzjxag + aptq2hXs7SrHW2v3O26zmenxNQ3lAEb8eK+8sBDaU4QjyPH+t4feKN794J/6reJtekIq68FR4KAFzt+O + /m3nXzjzz8I/q90vua6o4Y+e+ScnghvJkcsrAOD0p7n9h+fP2gL82+R79nfglmAwCdE/3f1s4KMfuNfJ + V9zscLx4K8DY/Y094XORZ40M94BgdOdhFDAMjqJlVKBpIjoER6N6+ViQASiIgEFNd6kIYOXrUJc5K8Ca + GKhpssNQzGyTaYsAOwsAaGMNe9E17ZNw/cPiaf6aeBtq5fbmHfJHvbepWn+encjU0YO8bKVfWOjWHl/R + Yl+TAAmzWcllFg8SjM5iYbkYqzHnq2v0YshvpN8gD2V2I7JjVmdcu0IaEACByW5tLezTFqDcChjSBi90 + DGws5PRMXawhPGk+y2rNAgAU/Ij++MyDU4g6IQi0AUw2ohnAr2dq5T8n36w2Y/ejuJgMyxVmligws7Cv + LKv4YWvjZpZtLcPkAKBYABT4wivPUeTg+/5xX7Xc3vK4+NiltPlBCdUi6GhqKPCQcpLFT8pVBecPDiOX + FVL/4DhyHTiP3KccSC4kJ1rOf1kFgCX+NLjjvz2FNX4+guv4s/SAhKfHnzWaNx908hG3Ahwv3iowhg6c + r6Q6nIKz537/5LCEeIwMRKDG6GRQrxC2ACgWAeZWgHU0kFmA4qOB9lYAF4x1NFAXkr0VYDcJIqi2W6HA + G7bIhtqdEmjYphW5dx14TP7bKPt28ww9HD0rjheJAN3juwkEAIerXMpXyAv5Srk6ju8zguskakZpUR69 + wu/EzPTt/GRAfiN7h3wpvQXPJipVk1Go/37x5wekYmJAZwh4cC2QTEk4OYrrEGYOz9TF2oEvd0qC8WF9 + plrgeX5IwhO9GvHz2a+Dg6Dw+1xum/x2+rUiExVyOR+QS9axvmtsfpOBkExVi4wG5PK4Xy5MhuTy1HUb + XMvQYj9wwWLnT84gd1BQ/+VYpdzd8ZAYdTsl2LRZ1u8D79Syyp/OH+9tPiI32al/cpZ95I9cRk4jt/VZ + +/7s9kfuK1T8gxNtfgTIl1q/4/BMXwm0hTO4XNP+4HrD4npyfhWzvIPt5518w60Cx4u3CowPvfON68Z6 + vl2j6V8aYB+iAg75YHQIA9LisBuN6pVA1ScNmdkEoCAEbBHAylcuhNHT17cCdGCQKQLMeoBFXQJtEYDF + V9n8CBZdu/jr8H7fVjHa6zUFd2/bQ/Ln4+uEo0WvYjEXRAAX/U0kABidzNpHrVIhmU9XywxIex6YyVTj + FWIgyRoB/MzrcQiDSJX8RvRe+US+TjZm4zpBkEeA2PCFRUFGNo1nlDL3hx2eqYu1g6A6lDieaUILOwN5 + rLfMgHgyY/rsPz7VJL8VeRui+Wq5moLzpyPkEdP4Oq2jmc2ba4aZgDnWmiQhKvHnV6J0kmt/C8AWAOa2 + IGA5f3IGueMvhjfI29oeBsfA0bfXShUcv6+WDr9VqpogCmwBYPOSnfoHZxWK/qx9f6PHqvon11mp/2Ln + r9xo8SQ5czkEgBb8Yh0HeQqIgl8zgEPavbFm+PS3jI+885ZM/dtwvHgrwdi9fc/6ke5vrTsXg3GAGGCE + AQ6DYFpwGfoEUAAU9h8t414gAKz+AIUsAM/E2qcCTrSZiwhK2gPHbh4NtESAnQHYVy/ruOAatou/9hHZ + 1EZV3iTh2s3y5oNPyAsRvy5kVfOKm0sA6CyBKL7HeBjfM2i2V82CpCEGGNU8N8E9TjYWuk0uZGu0J7vE + vCD0CpmHePjD6FukPvuYVE7hOeSTKgC87CA4OSxhCoNFz9PF2kIFq/6nmNnpMbd/4PSZAeAz/7/icPw8 + lx+vkmtRCmQWlFbh5xqZx8/P5eAco7SxKp16x4542hWPDX2AGUbODja5lnCDAABHkCvIGeSOe9ufkKq6 + LWLU18vGNjj/+m+Aa3ZKFXuU7AGKBAC5yWz4gyCEnAXu8nDf367619S/Ff1r6h9rDjyo26JFzp/Pjc6/ + wJtLAZuBpdnohx1gGegNy/rzUVk3cuZbxo7Hdzr5hFsJjhdvNRiHd52tycWf0gKw7JA5aCYBJz1Ntehg + VK8AtpK1QUO3swC6zQARYM4KgNOhCGBRoCUC2ChDFxCrZ62tAC4wMxPAhcde21YtwA3Ypnjz/oflL0bv + 0P3x56Du5/NwjEmfXGSUk6qUqzk6y2oQWkD30dl6l21LGQXQQS4mjJsOEVM0/PfsBunOfVHunsS9p+NP + jYl/chAkNCy+DEgK5MGzwywQ1P3ENKIUFonyzPiEWTjmmzxt9g/IpPBsEyAdioobbcLFywezMsY0nXha + QqlxrernZE+zy2NEhZs+nxR+j/MhzuH65Lj4GO3nRnVrhxE/p0jeBQFwKPeY/FH2DXByfqu3/S0AiJYr + Oa5rvB+F04/5zS6hHEjE0b4QxCqE8oZ2+uPv/99j6+Ut7XD2Fo84cwxADiLs1H+7Gf3bqX9t9kPnXzTo + h1xX6PZn7fvbvLiYL51s4pXAfx6cC5FRmUeAp+3Bx6UyG3vKOLZvwMkX3GpwvHgrwkh1fW99CuTBbl80 + PNYEWE0jlopigy4WAGr4ha2AvoWzAjga8/Qh8Z5sF8+xVjEOY0ExrcYugSoCqLotEeAoBMyFS/X+lpZv + yJ+NVIiABGYQKV9OwOnzSBNU/ywIglHNnDb8qER0HDTb7UZABCn83mIyucmgxYMxfO+UmQ15YSwgY5Nf + lDd9+5Q6ejqS4FSfeM7jmcGxaFUxREBoMiahHB39iKxLDch6CAZfNos/T2q06Z3uBtksQwRzq2MyCRHW + C7HVhfUIAseaZBq/OtctVVyfjOwgzEJTZsMXPcapx3exnjJYb3Aw7zrXL5GJL8uPtDsft4aq5FKW8yYW + 2sJNCdo3TwRF8X2z4IBMQOf5s1V4YVphKigzEAOz7EwIEfAnY2F5ffuDEmRv/58lAGzeUecPHipK/bOX + CTmL3GWm/s1e/3renxxHrqPzt1L/P0sAONrDKwb+D84KYTYB3L6OQ8LSXd938gG3Ihwv3ooI3feRD3vz + A09XZJKa/mXkR3JxNqpXh2IRUDB8KmAuBGsroHA0kIq5+6h4eWb21EFdUJpSO1hfJAKKtgMcRQBQB/HQ + vFvuPvi4/FHvJiVAdvOi4teOgVGftjJlWpydA9m/XKMjCAEdYOJEKjcR2MedzYMEBDmfuE1mMyBJ3KML + ox75zeRt8vjUbrmTUX1iVCoTIKg8JxAi4sydRLQ5Kv6ppB4hNRjtZ3p1z3l9NmJuH2hDGWdbcPEykejS + 5k0VPLnxLTiO8916UidAsc4hLk/GIdLgWODsvbmchNO4nk3IbRPD8kh+j/yH1Dvkn/ms8Yxns9Uyr0N5 + zNT3nCX6bmYwoyeJKqzpdVjv+L64Dzq1UAtlfeagIgohDipKeOSPB26T1+x/BNwBPqlvvJFPCHX81r6/ + FfkvaPbzclr9Wqn/YgFg8yPhaAuvBuBwH4M5jv3NprB+B54Of/6jH3byAbciHC/eqvA0bzloTI89W51P + QKFaWwFORrUE2AKgWAToUCKtBzCPBmpbTIqAgRM6KatQFOjUJIiL8OeIgA1N+LMDWJy1+2QDfv7t4Xu0 + cO5aJCCX0xUghg1yNcktAD/I0ZB/4bnnDCKBZIVcgkhwIpWbCmOVZoEk30c8OsKVxwq1KhqiiHujlyNh + +dfJT8mH8ngOjCyzY1pdbJzH80mBzCbPSGC6RypBNmw9aiBiNSYGpCpttZl18arBqn1jEveT3TnZsW8y + LYF8VIKpUQnFRvQMP0c/+ygIsv3y1vwBySY/Lj+Owr51vz4k11LVcPjmM72+103xe/NnuGjLs7lKPc+v + 4p9Rf9yc538lHZLncix2hCjIGfJbI/fKpuYnxGCVf1u93M65I4v4ZIHzJwqRf5Hz56AfO/Vvnfcnpym3 + sdUvuY6cV+T8iwWAkx28WmjfD3B5RS7G438/MBqfaHfi/lsVjhdvZXj62vOhqYRWhnvYI8DBqJaCYgHw + s0SAtsVkfwDNBEBBW1MDPcexsLgVoPUA9eZ+GxcgVbgKAMBeqGzQAXAoR0X9E+Jn8476OvF3bJWnBu8G + ESIaACFwiMlPM5y1v16PDVIESBTRQTS0NsaVLhG6LxrdIC+mNsmFPL437se1WFBeSAZllunR6Ead6c4h + RTxB8F8id8nu9IOyYbJbeHqEe4w6WwDRDItHgzxnjJ+NbC/IBxGPgw24eCWI6TaL7vPzyB7uLTv1aUr3 + yYyEsIY2TvVJS+4x+cvEGxDhwtlB4F6GLc+mN0C8QdCyKyYb3iDin0lVaefIK6z4T978GS6JQMSy0I/v + 6fwhfC5ma+R52Dfn+et4YvzZ0wNvEP/+neJp2KVNfoIcNsYGYxaPXBcAFs8U7/mTi8hJ5KZj7WbRHzmL + 3MXI35ry9/OcP7Hczl+RRlAFG/JDNHr79085cf6tDMeLtzKMt74+aKS6v+ebhmKchLE6GdUS4SgCuCi0 + HsCcF6DpMhbM8NiM3R+AC4sLrEgEFLYCbBHAqlxbANRz8e4Wb912WVe3U3ytD+PnxyTUsl1+rftuucqI + gA4PpPA8U4TMBLBxDiLfK6yK1jn8+J2bGYh+LkLoXLIcPJu/6ETCpB+O5Da9P7O52yGM8DPeX6ZIQLR0 + MRaQ/xR5lxyLfkPekcEzYtYozQFEeH6cPTCVlGpGHw7P38XLR3UihXsZE9+5YalOQ5Cn4fghst442SE7 + Ug/Lv0/8gvyYdoxn9mLGI3N4RuwOOZ9apwVvF3OwYTxfjsi+ymE2MY9ucV3i1Ez+rpNN3FQwTy9olgv3 + 5EK6Sn7ErT9+d9j+i1GvPNP3Ogm3gjNqH4Pzv1/WN+wUP3jDaMI15RBbALDm6LrzV+5xcv7kKnIWuYsV + /+Ay7fNvt/q1BEAxB66I8yfA4crlye7vkdudOP9WhuPFWx3Gpz707srU2e9ph0Ano1oGOIkARpEsjLmh + VbDdJKhQD3BdBDjWA1jtgj0NO6SyGYu3ab8uYu0Y2LhZgvu2SnXTVvnX/W+Uf4wg8h8PywwipR8lA4ia + QJxwgnrciUWBjqRyE4G1D3QgfI/IkVmPWfzMuoiriCIvAVfwZ7pnys6KPPrFAsmYmS0QRFfsPPjb8bdJ + S36zvH7qtJ4xNxJMPTIb4Pz8XbxMTGJ9YF34U0Pyhsxpqc9tkV/LvENe4F4+hRrB/WuN8j2I7D1yGU5e + h2LxzxDl8lnOAxR2cxQE3PPGM72QqlloCzchWO3Pgj8KoNnMJvlp3G/N8w/KP0fvlHPDb5BA63YECVvF + 0/SoVO77hgYMRmObrIcAIIeYAYXl/K20PzlH9/0t509OIjfpdqU95IfRP50/uMxs9Xt937+Y+1bM+QPM + GlUme75nfPrD73bi+lsdjhddiFG5/eFtxkTkaSejWjbkri8CXQgZvGKB+JIQAbFe8RXVA+jQoO4j4u3s + EN+JA+I9ap4M0NHBlgiwewTYrYK5eD21O+DsN0O1b8MC3iNV9fh7jQ0SbGY2YKe0Db5P/mGcTt/QOfsz + cQgCRP/cCpjJ3/wZABZGMRq8lKrAzxx3Csce4xRFCgPL0ae8Mo+oic1R2HSIEwiv5r1yBffrxRwLq/h7 + +PfgbLhd8Dfp2yWd/4R8fYIdBx2eu4uXjS+l6qU3fb/8QfoN5okNOHL7ubALpO5xs8EVr4/DwScqZD4H + ZMz+F+wBwWzOfBrP1zrVMp+AUEiao7IX28PNB3x/bmXh/WXYuY4whg3/U+QOGTzzTnDAFvE3PQFOqJV1 + jU14BZq3SQUbjNWDUywBoJxCbimc9Tfn+ysHgYuUk8BN5Cit+GfgAu4ihymXgdPIbcpxRZxHOD335UPk + 6aqtj2x24ngXrgD4uQgd3dJrnIvKuhQMlfuP0xEdEsQjSV7OD88mHAzuVcISA7odoFsBAwrveK+5FTAM + IcCiwF7rZIDdH0DHBzcsrAf4uccDbVjHe5q+LrVHPyr/nNwkc9kwCNR0YgLCnIsFtFiQZ4XNDnq4DvJ4 + IVspP+FM9FvlHPUS8JNMWJ7KvEUa0l+Tt2UPio/n0nmccMIcSxqY7BXvJJ45r+XG8PzN/e5AblBCsDnN + JrCZzSS3pFj5zuNMAH9/Ko5X/nuADjgywTa37EGgfQim+kzo78GuirNa/P8I+2f+GX+Hv2v9Pd1vB9jz + wJuHPQI6Jhu/55nC709gDfBcvn4mpuf5WZP492JaR8PGStynZ+W+dtdkYS0Hb+Hf4XE+H4sms8SQBHPd + 8q5MuxxIPyi/nny7XLwVMlBLxLWMWcdzlSd7LBGqhY9Ys7NRvyl0sK719/nnsMd/Sd0udcc+Br548DoP + OHKEBZtLyC2Efdaf3MPCZHCRchK4ySz6A1eBs5S7LB5TTrMif7vZz3KA/TZ0ZsfEaQnyGm0xPyyVtDe8 + 9x/b5p73/zlwvOjChHHva33Vg8fPh9V4zXHBATaT4PhQGLFZ8X2jUb5a2AJA02SWCPBE+8S7oCjwuHjO + HDa3AigC2HCDC5F7cRQAuhXwCgRAw16pbviGfPrAV+UfODyHBMI9U0ZU3DeMsGMg3vPkAI8GMsrCe45D + FfYLWERILhZiVon5+jbDjxCF/R+Ze6Uz9UV5MLVTqlIcPTsIQQnnyV4D53iqAM+dXevSo3qEiZMJmSbl + qOpApg9AVMWjiRATnF2vrYz1yCrskU54Gq/TsKnz+PvpNJxvEojrwCP9d3KIxCyxUACv4c/4O/q7/Dv4 + u/w39N/iv6l9EOisx/T/1bn5k/hscOZBCAR+Nn5Gm+R53UhZW10UFedg11g7nimzRW9lsl8+n2qTg5mH + 5XuZX5D/kauEs8J9SuO+pXg8E/a36H66WIh5Zjm4lYH1OoO1eyUD0cR7GPXIPAS79vnn7zKjh9cfRavk + U/u/IqGWR8WoA1e8lACweYScQm6x9/3JOeAecpByETipcNwPXKWcBe4qOP9iAeDAfa8WIXIwB/tMD+qA + J24VGSzOTfRLTf+xKePN98CInPndhSsAXhL+97x7o5HteYpHAxnJ+NkfIALCO5eEwcG4HYzy1cKuCygW + Ad4ESF47BZoiwDt0Srx9x0wRwKM27LVdNDTo+laAKQI0dbdohPCCqt5miIimPRKsf1Te2/ao/G2kWqvf + GUFcHIfzzxtyMV4hP+U+K0eicsgOU7Gjhjyf2nADIblYBDgzFmCxTkCnE7K40hIDxOVkhfx54nVyPvoR + aYg+LB9JNMntmS51ksaTCfGyRTHPu8Px+nIR2OCohBHd0IEyU8BqeGYSfHDKBCfdMarmsTjCDxslfDnC + bIjCbBanIS4ArvHP9Hfwu4W/Z/07/De9GU5V4/9FoWC2avWmEcmnQb74TByvzM/IaYsqDKZA+ufj+l3u + yHXKR5PN+h2fjH5I/jx2l1xKhM1TGLwXVmp/FrY2m+B5fcvO7PvowhGXOOdiGO95r3KcheGDyAzLpRi3 + PHBt3C8v4vd4CuDvYuvkTe0PSbDlCfHVIZJv5Hbgz+AFcIY54c90/nbqvzDkx4r8tVspuIicRG6yK/7J + WeSuxc5/uQVAOD8owcm4GDHy5oCEJ8ekis1+cr1Ped79CxudON3FdThedLEQ3vu/cJ/x5NAPKhHNGCS6 + qRQIEZERB4s4GOVSUCwCdNFw8VBF20OD2Clw8KR4eo6Z52zZcKPoeGChKNAuCAQcRYD1vqZ5s577rWzY + LP76zXJbyw75g9gbNFq4NhGSf04E5UIGt4G99ceDcnUkKC8kqrRtqAoCi4hcOENPDoCILyYDWmcwm6zU + 3vLziRrtwfCTfLVczCLyZWdGEnbSI8/FK+UvYnfK70TfJN2Jr8u+5Bb5eLpZNuVOwLH2ArCHSUQ7ID+D + HQf1GjABsYCoW9sX05kDZlc8QNP7/Hv4nSm8KqztAftn/hl/R7cJzL/Hrof67zHtz4ie/wf/ryn8v/i/ + KRaYiTD/7V65PX9SPpFpkbr0NulNPaTf4S/jd8rzEDpaNMnvmIa4zIX1u4t2oGSkz318r8yxEDXhN4v4 + rL1rFz8bWv+AezoTrZYLFJnavKtSa1X+Efam5/+zIfmtsbulqmWbVvsHOcp3707ZwNogB0647vwB8gj3 + /q19/0LRHzhHi/7YshxcRE663ukPXMXsJblr0ZE/J85bGrqlMj2OYAwiYAoCNI7/98nRH/i++LmPOXG5 + i4VwvOjiRhh1jzQb08PPVmcSIDoYMgiP0ZKzUS4NtlLWBWMLAHbPioJ0VQRYkwOtkwHFxwM9lgi4Xg9g + oeh0wALgzzYoIewTfzPUfsM2CTbskX87/Ha5wO0ARLA6E3zMq/uNLzBSY8OcfI02EHEiJRdFyCKSZdaE + Ryo5tIhODfeV2ypKzrg2DyFFwcX6Cz2vTbAIMRqUKzlOocPPdJ4JzmvYIH+RfpN8L/1+yaQ+JR3JrdKU + 2iVPpGvls5k2eUfmqGzI/f/be/Mgu6o7TfC+/b3MlAS47G63Xa4yhjI2Bhtjg8G7jaHALALtQlvuqV1C + AiS0ZqZSqdy3l7sEuOgmxjFMqYMJOtStCc0ENe6Iiuio7qjomOnqWSqqpqfG0TU1LmMWbfCb7/vdc27e + 9/IIyFRKaDl/fJH5znvv3vvuPb992xMKagpyuke5r0ZCC56WfHagW3J9PSXgmrXyo7wAflcVgma5cewF + uW1kB86xQZYWa6VpaLVsH1whw8X75V8Wv6HXxGvTMlJcK69Zu9AxiZL7xAh/KkSqXNI1DYv/7HBGO/JF + Ap97jr+fv5nft/fDw4kzuJ9nxufjXiblPd5D3mfQ6m/oAcD9ewv3/F8c+IJUrK9Vek9XL5Ogplaq6kHz + 68ETyvkBeURM8EclfzQsjPCPyv1sxj95EXkSeRN5FHmVdf1fIsvfguGxYJhKbOj1Cn7R9atgzWNrXTzc + Yzqcix5u5PZs6UkV218PmAAIy2keu0s5NuWcgIkyBLXnciUgSgrcHbbavECPAMbr1HVnqgNcSkC6AQxh + 82apgvWfgFWQpPJQv1xyNU/Kwee/Kf/YAYZerISVmpTTZORjYDgTgbzdnVEG7mJKHlPgPHnGYvX/IpUo + VhSEeRWhEMR7uK/nByAMoShw6hyz1nUYE+O7FIiM5+JzOvmQAFPnMc4xq92u8XgALUKunxnMKf6Pvk/J + fxr4tPzlwGflzwd/X/7H4hflX418WY6PfkVeG/2qgv9zje/xM/wsv8PvhseBVT6YCgW1OX9oyTNWTwFu + XuO9KIlUr5sxajahwT5hbX4xo7+Rx9L7g999DorRuYGcrrMDJXEWa2eg/JzpxO8399HDDVaxnO3CnhnD + XhrHa9535pwMzJP/C/dx97N3SnYTaHztYinUr5NM3TopVEP4bwSv2Mhe/27hH/ENGhLltf52tj95D3mQ + SfpzCf+Ij7l43BygQqc94pyjrRzjfiL1/IZ2F+/2cMO56HFhpFu3TBSYBzDWIUmGBBybck5gCEc155gS + UDo5EITHEZvUwl1KAIcHMRxADd4oAdPCAXUrpaLmUfyP9+qA+qclv4VJQWAOjVvl+88ulL9pr5IPxvJg + KGntm3+6mIeVAaZDpu9gSh4xUPBRUMKiPQOLjKWDKjDVwodSBaFKAXieGe89sNq6IfS6Q4F/pj8Bqzqt + ZYrvFAsQjrjv7EdABt8NdNKDwNfhGksXwzHPOD6rNHAu0Xp5Kgr4DNEffkYVihjCZDEKDvM5fke/a5QV + gsfmdWtSIz7Dc3fwOnAenY/P3vI5vdb38PdMMa1K43mGiuj9gFDn4CWGQVSx0FkUvBe4Btyr09xbAJUK + tu+VwU+V3kuP6aBSDlrkcCPW+/8dlcaRgvyX9vnynZ2Pg/a3qfCv2AZab1olqbWM6VdLqv5RU+8/JfyV + NxjhrzyDvIPZ/i7hT55D3mOFf2zCX9zyL+drYTfH0rWLQXog/Fs53iGZg5uGXDzb48JwLnpcGMEtN2ex + 4V8JJvvChMCyDTljXEg7NgqAzQmIVwYke1u1xCbRAY2bDTdIiNTG92yT5PNbpqYHgnA1dmc8AdYLoIQe + KQCrJdu4TvK1i/EehP76GsmsWybz6ugihOXQsFA+t2Gx/OmePwBDBjOnVdcOhl5M+SztjwHOjKeA1XwJ + 9Zgw8S2vwu89WPE2IVDbtVJwE/yuxnYhhMngIVg/4ARHNrvhcYzAZKY8wzLqLreCWoU0jxuCygYb4EQw + wjx+jeH5DWKfVUVFhf2UcsEaev0+zkcvxPkiXvNzvE6cTz/Ha6UywTVVOvCXwPd4zHAIDxWCUODzXjD2 + r7kAvB/8ffgsxzTHr9FjOtj0SJ8FFLG3i7inY4H8671fkltIu40LIeiXyvz6xZKoXgqhDoG+cYVk60Jv + QFA7ZQjEY/5q/Ru+YYW/TvcDb9Ee/+Q1ZrY/eRB5EXmSFf7kVeRZ5F1xnqbJp3OsAGi539E+KCF7X8ne + /CVomG6+7eGGc9HjwxHc9aXPF4b2vs7hJLmRYmiZv3xIOLs8N3RE5o1gQ7LmeaTFuWlnBCoCHHtaHgro + w7E5VpOxN5YHMg5HwmRcTgcHbQyHc5CAbYkg43kkclvaY5UAJ8LyoATjhGAWN9Qtke49d8jp/koVCKwU + CF3SoUAic+ckvXco5NgfAAz9nR5fx+3hcTHQUBsrcEBv7+L1uWEqgXiPnhMqSKA75uro4KOheXJ0713h + QJ8NayS3njT+EWV+2jrcuP4JE/MPttZKsK1OktthSICXKE8hb7HCnzyHvIc8iLyo3PWvo5rnwEBiJcng + YSmM90sVe2IU90viRZyLY6GLg1rylxvcdzz49tdudvFqjw+Hc9Hjo5H5zn23BZNtpyjoEy92aeOWAArA + jSxJAQEkJ7qwYR0beqYwnoDyUIASHJDsBEHEewSwExdLc1gZQMK14YC4EjCDPgHpuhWSrFsGpvKkBGuW + yopt35O3+sGQwHzo6n2rWCXvQAF4e4hWLSwQWKO03N4lk2Lf/DKG5uHhMQOM5LQVtSaCDtLrk5HTo3kV + +L/tZyIuaHEESgDob83W70qweol8uu5xya9bLEm2Af8oBcAKfnoHrfBnqR+Ef7CjIWzxy4x/8hROJmWt + v1r++5T3WD4UF/7KqwzfcvK0GaByAMd7sQfHZ2OsLhyf1S44FxNclb+2nEje/13f5neWcC56fDwkl/x8 + UTC6/0R+HBux2C4cSxpMdmlogOVT9Aa4NvVsoGGAslAAoX22tUfAHlUCbMtg7RHAEkETDrDVAVPhgFAJ + mJYTUFYPnKtbZaoDVkvVVqxvqJMvb3xK3uz8LBhQJkxUo+DvDLQb2XvA+8Y6oWLgZGoeHh4fC8yVUO9a + B/4fmC/nWfd/xLzfV4DinZV/1/l5uW0zFHTQ9e+tXypBzRpJb1gt+WpD0w66jsf8S9z+sWx/5R3kIUb4 + 2xa/ttEPW/xaPkSeZF3/qgA4eNhskB1slzx4KhtV8XUlvatD7ab89MCJzFN//JiLN3t8PDgXPT4+Eg2L + NyUH9h1PHu2HwO9XTTV4qUMKFNRah+3e2LPBNCWARMcpW6y7BUGWzw2gyy7MCTCJgUwKNErAVDjgw/sE + pOqwXve0Ng8hg0lshvIApWD+qkelb88tOiTnbXYEVGHP5K6bYKlk5UwXy8B8oyAPj4vBb/uyUKgzIsPz + 5DQs/veZ/Nmflve685pgeWzfbVJZtxA0u0IqGkHTDdWS3bwcr9dIdh3o2kHTkfC3lr9J+NPyYdPil8Jf + vYjgIZHlTy+jJvyx0U+zDviJ+NAlEP6K8S6pYH7Bn3RKuh/HHuqR3Di7Wh58I1H3VJOLJ3t8fDgXPWaG + xLM1h5JDh18PXh7Q7ldZzoM/Bs2Vfc9dm3q2iIcCysMBkRIwFQ5gvM56AjQcYOYGKKFH4QADMoO4EhBh + nVQ1snMYEwLxGsI/U/2U3Fj3FD7fJN/f9AP5T/15dUMyRsks8N9xbgCY07vFymkMzcPD4+PjzHBBS0nf + 6sHfsbycNUmX/0tPhTyw8yegxybJNz4hyfpFUqDlz8S+usWSaVgkifqw9r8EpHEr+Anj9o8L/yjmz6oi + xvyN2195S3mjH8LwI+VNc+D2j6OKba4nWqXS5EElJ3rZXOj1/M66Zhcv9pgZnIseM0fy8PZjbBmcPdat + QylSfS3QVOdYASDKlQDrgospAZoTYKsD9kN7pxLA8p2YEmBzAtT1pyGBCygBjU9LYf1qydeulFzN05Kn + 9cAJYU30ItRJtnGpFBpXyNGDn5f3Gack4+oO5O1eKAUmw93Dw2OWAC29NxDSkg2t/Un7F2T+ppWSroOl + D1pWL13tCkk3rZGK2rWSqmGoDijP8YkJ/4juTcxf3f5W+JNX7Nke8g6T7R81+iGPKYv5XyrhTzDur62m + OafiKPv+t55Itj/zsosHe8wczkWP2SE4suXloHvPqwv6u9iUAoQBInFs6osGCc3CauFGEaBrjjO4tS0n + Cdd4AlQJ0JyAWJ8AKAEaDjCKgDKGsnDA/MYnJaiukUzdGsnWLNP4Ym7TGpnXhP/XLAVDqZFCA3MEmqRh + 573yX3vprmTWckLe6/ZVAB4eF4MzPQvUA8AEwP+3t0I2PvcD0Fqd5LVPR4Mkq1dIDrSYp1K+GsKfM/zX + w5pfC7psfKJE+NuYvxX8SvtbTMJfLOYf7H2m1PKH8FeeUi78iTgvcvGqi0WxVeZN9knVEIypjhdeCfp3 + vObivR6zg3PRY/bIte0+xriVTgpkG1XXpp4LGKJLDB2JcgLokmNcjomBUWWAVQKgzTMcMOM+AQ3r5Mb1 + KyQLCyOoWyGFTewVAIFfu0bm11PwL5Nk7UIoAYvw/Ua5c+Mj8i8P3qhT3TiYxMXUPDw8Ph60F8NwWv5V + 6z+Vb2x5GDRWKwXO7ahh347FsoCJfnWg3fVr5cbGlZJZA/qEclC5ZaWk14GeDR3HY/5q/Ru6D4V/vfIE + 5Q2a8GeEfxuMCAh/rTRisjFj/jHhT95zSYU/wa6rgzj+RI/ku/a96uK5HrOHc9Fj9ghu+f1sReeOV4Kx + wyc4E53lKpVHeyQ1AM15CATE8aqjh6Uwgb9DzdM3/Axx4ZwAnAtItO+FErAn7BNwEIS9b7skdm+eUgK2 + gwGw5pczvukOtHkBZBa2RpigV8BmEluAseTrluE7jdpVbEHN45JqwLFqGmTV1u/Irwc59CYh5zgIpj8l + Z/s5DCccCsPueIxnnusN5J3BhJzHa66fHUhOTYnjmoMpenhcTeBe5lyEM2aPsxvkW0MJOdOXUTrgGj/3 + bl9Wq2g4T4HTENkc6jededm8+15JqdK9UubVPSmZDfi/cZ1UrIPSHSnqgKXLOrwfp10j+G28X2mdNE/a + N5Y/eYJ2+COPIK8Az1DeYfjIBd3+Dp40EyTHj2iWf8DJqhw7PdQqGZyHPDMcYgUeOt5+srJr56vBzX60 + 71zDuehx8cgMHjieGQtnuDMUwL4AGc5Sx6bXUa9de7DJOV+9lCBmDHoBQIgKWx0AAmJbTh3JafsEUJtn + PO/gDklqs6BNoRKwoyG0Alj7S4sgFg6w3oDysEAcbCkaMIGosUaVgaomrDfieA0r5XPbnpBXW76oyYHa + Ntj0xD89NE//vt2bkXPD+B9MkG1kf9czT851Q0FQJpiW8z6HwOMqx3mOOGbsviuH11VyfrhK2A5ZOkKl + mHMWzvdBQWD3xKJpr43XbwOvt/2hfG7LA5JgLL+2UQq1K6SCQ3xYwgv6TNc/NY0eFaqsl2b6W7d/OM/f + uP21zp9u/00hTwBvUB4BXmHr/C0fscK/JNt/Diz/yhch4Hv2SRoCP0PPKXhkchx8kooAR2BzEuXQ3tdd + PNbj4uFc9Lh45G7+yoKgY9srwctdUjHUoRuboQHOD+BM9+xL0HDZPMhBFDOFbRecLIZKQDRCGEhFfQLC + kEC8RDB4IfQEJHasD7sGbqnVYUDxkECyMcwLiCsBTAK0yK5bJ7l6MJN6MBa8TkIByK1fKRlYIgkmDeI4 + jz37Y/nP7BfPSgH2lwdDPMNe8mwHSybJroIsb6Lg7waj7DDtc0fD9z08rlZwGJL0fkqFPvf56e6MnB6s + kNPDHBGNz/D9ARi2QykdGc1GWn/dW5BVz35PKutAc7WgqZp1UK7XgqaWabJfoqZJsvUbJUe6jNGiFf6W + XpVmjfAnTeugL9A4aV1pnsIfPMCW+pXX+ZN3WD5CnkLeojyGvKasze+sUWyV1GS31vvrbBXwyHSxUzID + MGZe7JREz45f5m+93c/1v0RwLnrMDRL33Hlzpu/Aa7m+ZimMwtof4Hx1bPaRbklj0weTF69BW5QrAaqt + Axq3Ky8R1HAAlAANB2yVxPMbIyUguRkMwlEmGFcCSpnOSsnWLpSq+ifDhkFN9AY8LenGRZJueAyfx3c3 + 1ErlxnXSceCr8r7mBiR0QMzp/kJYMshGQiN5bSWs/QQg/Ok2Pc3e5g6m6uFxtYDNe3ReA4V9T1I79+ns + BODsYKWGxRgK0C5/w0np2P81uXH9akmRjqBAp9YvluR65t1A+QY9ZtiDo3aVVLC7X+PiUlqMW/6Gbq3b + nzSttG2FP2me8/zV7Q9eQJ5A3mDq/MkzNJ+IxsSlEv7E0Q61/DPDAN39xQ4pTPRIjsZL/8HXgnu/dquL + t3rMDZyLHnOHxDfuubkwsO84xwdXjsPqH4LQH+PcdQp/CGoXUcwCVgFQ0AtglADV4PtNs6BolDAIXcMB + O40nAEoAm37sMNUBsBKmhQOMEhAxGct0GI9kRjKsE2Yma2mSxiDx/bpquWFjmDzIEqWgoUHu3/a4/NkR + KPRkjkV6ARLyXwd/T/6RvQSwdno4Le8MV4jOxacyYBiph8fViay6+N8aysi50flq4b81kJZ/6PsUFIK0 + fIB17vN/27ZA7tsKhRk0koMCTZq5aeMSvAYtcnBPIwR4YzVocClo8Qn8z94coMs6xvwZ+58u/Evc/qRp + 0jZoXGndzvMnDyAvsMKfPEKz/U2XPyP8FYa/zKkCUDwk6WH8nYBBNNwpeZZOjx2UwuD+45l7fIvfSw3n + osfcIvjuN28vvNj8plUCMiMd2OQdkh4EgbmIYpaIKwHTEwNB0H0xT8DhFyRoe14SB58N633JEJ4HY9i5 + PqwHZpLQlhq13iNvAOOJRKQErIbQr8faBjCqOklUL5H02se1Z8D8xlr5vVp8bx3W1oMBVS/T7OWKxlWS + qVkpa577nvyfjI0yNGBj/WCEdIP+bnCenGM4gHPOpzFUD4+rCNzjfTdBAbhRfgvhr5MU2cwH/3Og1t92 + pmXTrvslW18tFTWLpaL2SQjvGqnaAnqrXiqfq2mQqtqn1f2fblgGugMaoVQ3Vcu8GtAplW1DjxF9Wquf + tMsyP034Y40/aJs0TlpnVRBpHzxAeYG1/MkjYsI/nvA358IfYL8U5hKkhjrCXv+jByQzefBUcP/dt7l4 + qcfcwrnoMfcI7r/rtnz/3tfy/S0ybwRa7shhbPi5bRVsYYlVYT0Bqgi0aJ+AqXDAnpIyQfUEPL8xZBRM + DmR50KY6WBDTlYDIG9CwEOsrIeQ5N2BFOGO8Hu818O8T6hFIgrFlG8K/LB9MbayT+XWsXV4trQfvlr/r + TGgI4O+H/qmcpUIwFMj50U/Le0d8CMDj6sa5nqScHlkAJTelPfzfGqxQhfftlqyMt3xLbgAt5UE3eWbv + Q/BnGpdLgV02q5+WyqbVoUcNinPQuExSTSuhKGCtaZ0Z9PPzkAbLhT9zeEC3SrugYaVl0LTSthH+UY1/ + NM8/bO9LHmH5RdzqJ1y85mKh2f7DbVKA9U+3f8XQgdeD799zp4uHesw9nIselwbJu+69NdWz75fBS52S + ggKgZS4OopgTmOqAKDGQAFGzHJFDPKLEQHb4IiNohjXAZCCbE/BsE5gGEwNN18C4EkAXo2E4FOLhvAAy + ITCmDWvBxFZCEViuSoJmMG9gkuByydUvkvyGp3EMHLuhSUcMB/jsl7cvl8k9t8j7FP7DeflHMMkzZKAj + QBlD9fC4qgBL/yz+/magUoSDfbDH//mh35c7n39UAijEVXVQihkuW98g+fVLQU9QqGHVp5ogwOuw3rRc + UnifnrYMS/pql+l6qr4ONAbasoLfCn91+dPyB90SoGHSchTzp9uftG4b/JiEP/IE8gab7EfYmP8lrfMf + OSQphgBe7taYf/Lu7/iY/2WEc9Hj0iG46/bPB4e3HEuMgag4K+AoCaxNS17yxS4JJru1SqBiEAoCZ2G7 + iGYmIPESdOOBqENPAEMCYXlPotM0DWLdb+vzkjy4MyoTDJ5jmSCE9TZYEFupCIAhaW4AGQ6ZTzhNcMob + wKTAUiQg4ImpsaSloAIR1NHCeVIe3vkD+Z/bPgfGmZXzg3mdhHZ2MGwodHaII1AL8gHLpfqwxv4Cgyn5 + YLBKZCAvH/Ql5Vx/Ut7jIKJBJhPic76M0ONiYWr0WZvPUbzvDSTkXYD9LD4YuEE+KCbDFr38TJF7M4O9 + mNDvsZKFo7HfZ+VLX4X8WdvvycPP3g8aYvLeCplXQ5px08UU3UynKdJaRHekQ5YFkiY11k+XP2iVLn/S + LmnYlPmRtjXTn7QOmlfaZ4lfrMZfeQTd/pZvuHjKTDAOqx68TKugjnZrgzQV+Kz7J+8b7dXpqYmuZ15l + 0rSLZ3pcOjgXPS4tcrd8dUFl/4HX2OAiGDiseQGaD3DssFT0s1IABHIMygATBl1ENRMYQlZN3igBmtlr + lICg27YOhjXQtktSLVACTNdAMg4tFbJ5AeoNAIOxSoCpR6b1oczIxaw+ApmNEP6wbsgMK5jMhOM9sfk+ + +fcH0iLDuF2DCXmvFwyVTJbVAV0sIUyGTYIIMl4mC1LYE/j/A4DKwJl+34nQ4+Jwti+le0lf2z1m9pkq + B8VcOJ8fiugHvdlIYXi/tyBni5WaAPjXbYE0Pn+PJDeAjmpXm8FatVJoZJKfmy4+DKHgJ/3RGxcT/qRN + 0qiJ99saf+0ACpombZPGo9a+oH0r/K3lb+P9c6UApFj9RF42elhyVDZebJcszlExBuOnu0WSkx2n0gP7 + jxdu8aV+nwScix6XB/nD244FE70n5xV7lCjygyCQP+kUnX090CZVR4emEdSMEVMAFMYLYJUAtQDYMRAM + Qd2Bh3dLqvW5qFcA3YZsEapKgGkfzHKiUAlwVAk4GNaHon6VfKpxmWRr8X/1OilwbdMSuWnz47J488/k + b3puUMuLVpU2VGEJFUcQc+YAmOt7Q7DIYPW/C6ufXdTYeEWZMxk2P2sYuYfHrEBhj7/nYPVzb73fjT3W + A6HPPVhkox/swa6MvA9FQBXSDoAK6GhG/kvnAtm26/vyKXbxwz6vbAzd++nateEsDdJQOT18BJTGLL2Z + LH9b4qdZ/qazn7b1NS5/0jJpmrStlr/29Wc+0JTwL4/5z5UCkB/rU16WYufTf94l6QEYHOBz5HmpYwPC + rqku3uhxeeBc9Lh8yBx54eUASE92qvatYYBjPVoOU2BjDAdRzRZxJcAqAlFIgHW/mhewJ2QUdBW27JTU + vmemRgqbQUK2aRAZj/YTZ9zRoQRomWCMebmQbVwnqfqlkqlZJkkOFWInwQZYMvVQODjUZM0aWbbjp/Lv + ez+j8dTfdbNLGoS8ZlSHnoAPimk5O1yQM8U8hP6U1a/vW0bu4TELMLREjxIte+6n8wM5eX+gAvssHQp8 + voe9SG/TWSqow4H8r/03Se2zP5b0GuznhvWSrVsaJvNtAO2AZmj5p7GWqAPNOGgijjgNxYW/Cn7Qnvbs + MM19VEEnjXLoF2iWtEsa1tCeCn/QNhOAWeZHmo8L/rjwd/CO2SI/0B52QJ3olMwglIDhw5J5sZvX8kq6 + fffLwa1fKLj4osflgXPR4/Ii6Nn+y2Ck+Y0E+wQMdkuek6+GWyQ5AQ3dQVQXg/J+ARrvM0qArRBgC1Ct + Cz68S5LN9AawXwCYCceEksEwtmhCAsqArBJgqgRm5AngIJO6eklvWCK5jU9IBq8La1dJRf1iSa1fIwua + lqrVlKtdLrU7viX/uZuNgwJ5pz+pnoFzXSntKnh6EMy5mFBmrMwaa+d7/DRCj4sDO1dqCICu/UEIeu69 + gYy815OVcx0ZOTtUIf/QB6VgOCn/W/+NUrPrO1LQnvxrpbBhhWQ2LJeKDfgfNJFZ96Skah4FjazA+7WS + XIe976IJB5SmShL9rPCvD3N0SJOkTTPKlzRL2g0z/XeHNE0FXzP9jfCnuz8m+Oe6xI9ITeJc4GXZIRg2 + AwB5HHhd0LXVD/a5AuBc9Lj8SLU/83JqtONElt2whkCQExDMR0GsDqK6WHxYv4CSMsEO5gW8EHYJoxJA + iyLqF7AxZDp0O7LOODZLQC0UowiwCsDCxdg+3bBMCtuZ7LRaglVPawiAVQTBmpVQAug6XSY5MFEy0wAW + UwUsqWd2f1v+qnd+2ClQ66wBMOfzEP6nBxNh7J+thrt9DoDHRYIKJf4yBMWE1DOw8M+xOmUAymZ3Ut4d + SshfHa6SDc99S7Lc49XVUsHY/vpF+H+xVDVh365+Cvt4jaQ3N2iZLL1dldjj+XXuXv5xmokEv7H6lcZI + a6Q5dfkz3g9atPX9pFHSKmhWaRc0XFrmNyX8VQG4hMJfMb4/5GWjnZKb6GdY4Y2gdcuEiwd6XH44Fz0+ + GeSeqdmfHNh3PDfWLmkmzhRBqC6imivYON80JaA1VAJMXoCWCh7aHZYPsYaYIQFaGs/FvAFlA4WsqzLZ + tLqEoU1jeBuqJb12pRTqngaDpOdguc4R0M6BNUwKBKODNRXUrdGJaLoOy2le7VL54+0/k3/bNk/+uisj + 52ih0SULxkwFgMlX05i5h8dMAaGv2fxRpj9eA3/Tk5U/b6+Sxc/8SKo4oGftGqmCEkuLn6V6mtPC1thr + V0sOdJFb/5Qkajifv0ayDSzhw95mg6wyeojTCmnH0lGJ8CetRVn+dPnHhL9O8wOttoeZ/qThUPiH8f64 + 8J+rOP+HgjxsskOSwzh//57Xcs/VH3LxPo9PBs5Fj08OyfpFmxKj+08ExSOSGym6iWqOYT0B6g4Eg0j2 + g1FwBCizhMk8yETYMIRWhe0caJUAbRrkVgKYpMRhQhbqEaBFw9I/g0pYSZmNYG6NAAU+lYSmsLUw+wcw + YYqdA7O1yyXZEJZG5eqXAOyKhu80NMpPnnlU/kXLbfL33VVg0rDMwKjpHXh3zOcAeFwcOJaXCqUOp4IS + 8FZHQf60+Uvy0LMPYp/TMq9WrxX3ZoC9zdr8fP3TkmnAnq+plnkbQA/Y41rax5wZxvRruMfZqY+hgCla + sPRRQjPxdr7lwp+0RxqMW/7a1nequY/SMGiZND0t09/BC+YameIgzgceM37wZLJxyVYXz/P45OBc9Phk + kXjq4ceCibaTnIWd7+uQ3NARKbB2dgyC+Vi7cFhGpr9DUiO9TqKbEaw1EMcQtHaWJVpvQA+YCJUA2zSI + XcQ0JFBWJUDGRLdkbJaAlihxkEmJ9W+Yns4MmLJ+Zgecl42GGpbLlzY8Ip3N35R/GJynMdt3yMQHKuSD + HsPAYbl9MBw2ZjmH1xxBLP0V8j4HErFvwABnE+BzfWD8+P7ZYlqHErHngNZ2sxyR09v6k2FC2KBXMD5p + sEdEmOwJ6OS98FnxmfHZyUClzpU4DzBnRHtL8Lu06Hsy8sFQTt7DPniXz5keJIDd+97He9KXk99w3wwl + 5Dc986Vz351y6+aHsNfYwApCHwLavSdnANvKlzRh10grpBnSjhX+tpc/Xf7PYs8zKdd29SMtkibp8ieN + WuEfJfsBpGkXrbt4wgyQGRnC8dslPY7jjzdDsWiTPPgWB55V9WNtqIcDf06lVixc4eJ1Hp8snIsenzxS + 99x7a2Fo7+vBLwZAqCCkMRDrSLsqA8lxEB9fH51OkDMGjmnjgNYToCDDIOIhATCWRHvYL8AqAdpg5IVt + OmBE646ZiUwrpbxKwCQIRrCWT5wZzgKfWvOwdkijyzRX86Qkq5+WfO0aWbr9e3LyyKflPAQ5Y7ZnRtLy + dn9azvSwVrtKRJsFQQFgrwEw/TMQGL/rrdBSQs5pJ9N/vwgBwdAC470KKgzMCg8FjK8y+OTBZxApAJqs + h2fEZ6Xv4blCiEsvG/FwHn9KTg9kQxST8jb2hYaKmNHPBlNQCvj63EhWzg1nVEn8i84FUr/nbqlav1gS + 1atlXk1YuULLv4pVK449OSMYy7+ENkyiXzzLX2mKtMXGPs+D1uiBY8MuhuVAixrvLxf+7Olv6djQdQmt + z4X7/8U2SYx1CHOXONFPjZRx8Aue70+Kkhvcdzx1nx/qc6XCuehxZSD45q2fDzp3v1IYJaF2gri6JTEA + ohsAgb3UAQIGobuIcpZwJQeqy5BWBJhJouegaRoEZkNPwCF2Dny2tGfAc1OjhRNb2Y98KiSgjM3GNK0S + 4GKKMwBLqdK1+AvGHDTWSmpTPY67TIJ1i2GhVcudGx+Rtn3fkr/rvjGs6QaT1yxuMv1uZnlnYekbRYAJ + XprlnZPTvVn5gK2JbS4Brf1BCn16BMKkMPUKGEHk8UkhFPx8LqqscbS09czg2b0Hy/53A3l5q29e2ECK + lj89PgOVcn4Ie0C9BnjuBCx/fucfu1MycuBmuXvbg5LZtExS9ZxwyTI+5qRA6K+DYF67NmzN69iTM0Ek + /OOxfgp/0I3W9luXPxv7xNr5kuZIe0qHtrNfFO9nsl8LBL8RxDHBTxqf24S/PZJ9qUsS/Z2SKLKzKf6O + tUnl2JETQffeV4PvfNm39r2C4Vz0uHIQfO7mVK5ly2iWXQP7QMyT/ZIa6ZY8iDg7AcHsJMrZo1wJiJQB + Jg/RoqBlYbwBVAToDdCeAXRDGm9A0nYQhMWS1J4B7CAIRhaFBWhBhUpAPOmphDHWh4ivOVFfJ/Ob1sin + 6ldIUI1j1OOYTUskX/+UZGtXSF7dtNVS0bRSlu78ifyb1i/I+z0Q+BAMv6USgL/vQEC81xcOaSFoUZ6m + a5lKgQoMgILfCn8KGgoehgRKhJHHZQcFOK1+o5zprH19PoA+O7aMZrhmav3t/qy8Q09QZ1L+Pz5bKgKD + GfmL9k/Lhl33yw2bsGfqGzX3hGWqOsiqEUql1u2vlps2PCU3bHjyYymwrn1csuet8Ld0QRohrbDEli5/ + TfSb6uinVj9oTWv7D0H4s1InLvh1kp8Z6HPJhf8RqRw+Al6Ec0zg9XiXBD04z0TXyczhbcdc/MzjyoJz + 0ePKQ7Czujn4RcevcsUuyY32QhBD+LO7loMoLwZxBUCFP92EZCTqSoRFEZ8oGOUFhAmCYZVAaeMgegPU + dam5AWWKgIYFyARDlCsBHw9MGMTxqsGoYfUX6hdKdj2YNd20dThnI4cVPa39BdhymAz39k0PSOuer8p/ + 6Pm8DmdhzwC6hd+DoDg7wNgxLEqdOZALBQyEBpvBMI5MJYDCRoWOVwA+efAZ8FnA8qfw5zPSxj18D8/u + XO+CMNeDygHWo9wAfqYrkP+99yZp3X+H/NGmR7CPKPBZddKoniUmm2bXwBJvWCWZjUuksmmRVNWulHRd + DYQ2PVsz36+h0I+BNECQJjbh3Eb4q9WvLn9b2w+aAm0pjZHWSHOkPTO/v8TqN8I/TsfEXAt/gsZI0Nus + 7ctz/eATL3a8GTzX6DP9rxI4Fz2uTARrF9UER1tPcWxmMMbuWiA+B1FeLEq8AFQA4koAmQsZjfUGUAmg + N4CZxyZBMGwcBEuFSUq2gyBrlaMkQTA4MjzCMkAbFiBsfsDHsLA4PpV9A1K09KkI0EqrXSvJ+hqdoHZj + Lax/KABJ1mY3cu4ALbnlYffBhqfk1s3L5NC+O+Svuyvk/EBGzvYzXgyBQQEB4cIs8A+GoAxw8BDXqACY + nABNLIwLI4/LDn0G5nlYIc9n9f5gWp+nloZC6J/tzcnv+jLCKZP/d09eBvffJvdvfxh7okmyNcukUL0I + exB7b8NKqWp4RObVPQnFcYNUrn8aAh/KI/aUhpaw5xK1dZKqrZEElc+y/TgN8b1s9zf3ut33ZVZ/mOEP + i580E9X2h1a/5t1oYx+T5U/ai+b3lwr/cgXgUgh/xWSHJEa7paIP/Oil9l8FdU82uXiXx5UJ56LHlYvg + h/fdFYzuOZEb65DCSI+bKOcAVgkoUQDIVFgqaPMCTIJgomdqloB2EIy8AcwNmN48SNuWxpsHEdYFWq4M + uJhqDOmaxWCuZKosOVwhuboVmqSVZhOhNQtxTHwO64zj8v3ERhx7Yy2Y9zpJrV0l+Uacm6GD6uXylS1P + yMHWe7SVK93JHDz0Vm9aM8dVCaCQoYCxwgeCJS6MPC4/Sp6BeTZ8VvTo/LYnJb/FM2QP/7/t/T0ZPPhV + +e6Wn0m+hoIbe2Yrnn/tYkkzrs+9x791K8MWvew/sQECuf5p7T/B2fyVdWtCd/6GFbqXblj1MRSAcqFv + 97nd96QB0ILSBN39ccFP2iENWasftBXV9ke9/CH8B/F/EbRoSvwum/AHGIqcP9YlydHWE8FPvvctF8/y + uHLhXPS4shHc/rWb8gd3DgXaYctNmDMFM3ktSt4rUwB0RjgZjXoCDoX1xTNRAhjPfAZKwHYwV6MERImC + VhGwSgDhYqoxJDg3QMcJA/werLVETcigg02rJL1+GT7DdsLLQ8Zei+ObMaypDXiPDL0e32lcJQXGeWvB + 8KFE3L/9ITnYcqf8+kigliPLxbQ6wFr9g8aVbIWPxycCPgPNyaDw15h/Ur02VNz+n/ZA2g5+TX6w44dm + D6yVHJ5zun6lpGpWyry1q0PPEF4zwz9Xhz1QFz5/WvuphsWSasRr5gJUs84f+6ZpJb7DuRV4zRp/x54s + gd3HcWsf0D1v6vpJCxoq01h/WN6X2Lcj9KSVCX+N97NHRzTCN7T8qQCQNuMKAAV/XPhfkMYvBsMdkm3d + MRF84/bPuniVx5UN56LHlY/gi59PpZ9f2R6M950MOD54sk0nbS0Y6wdhshynTVKTVBA6JcnRmyTWEYYO + sDbeAcbQKeli5xQhXwCWicQtCstkFBoWiHsDbKWAzQ2AMsDmJGRm+8L8AJ1URkuHMc4oLABmuCmmBJBp + WssJKGkg5GK0Dswup6AUqbrV8vtNi2Tpju/LKy1flF9z5CuFDwTOu70cDIP/hyCEimk5VyzI6WKlnB4s + aH26up/xGWF2OZMLIaDO9eNzA3y/Cu/PCz+jYQUAx9U4NT/LCgP+PwwM0cql8pEBGJ7A8XhOvMd8BU6q + s+Brnpt/ibiwtMcPEZYyajmjVjSE6+Wft8exxyw/1/kxXN8IvktliFn2hIZQkuHx8LtYhx8d2/xOdm7k + XP23x3jP8jpkR9s3U8HCZ3ld2tJZ4/U8Jj0wWXkf95kz+FXgd5jMfR4Xn/s13v/Tts9KzbN3y80bH9NZ + Eq5neslg9mdJZj//xoW/sfi1f7/G+TcoLShNaJKfaehDwU+6MbF+Va5JW2r1U/ADsfI+Ik6j5cL/QkgP + Q3EYBe1qEh9oexjHosLP8CKQmMA5+JnhLmH+UTDULEnylQnwjvHuk6kXVnUGX/xneFBuPuVxZcO56HH1 + ILvs8aXzB5qPp4Yh6Mch/GGRVx2jwA8FMwU93+NErgwEf2LMEDl7CxSnM4RyWEZSrgQQkQIQ5QZQCQgT + BFUJYJySDIw1yhwxzJLBuBLA3gElSYLuCYMRIyUuswKgYBmYohZWYa18e8tj0nHgq/IXvQwVzA+FEwUS + hZcRYNINod2VUgGu/eQpjBmThqBjUtr7+Mx5KAQcL/tBNwU7BRkFXkbOD7FWPS3vQUC+3weBxzp3Kgo8 + jh4L38N5WLrGLHftfqhCksAxcBwdhgRl4Wx/Vs7iWGyCw5g4Y+Pa8Ihg9jthXtu4OT/L7/C7PAaPpddm + BLtCz5mQs51Vcq67oAJcwyTDGVWGeCwqOzI4T5WdM0MVchrvs59+qATgWPxON5QD/A4qEB/wt7HPPv/i + twu+z6oLVVJwD6hwMElTFQcoWW8P3SD/oeszcnj/HfL1rY9KqgnWdH2j5GvYcQ/7ZC4a9cwEujd5XiP8 + iQsJf+55lvYZ4a+9NGD1R7F+Y/WThpSWovI+Cn9Dc0YBKKfLOM26aDqOFAwFCngaB+wvkhnvAr/Ae+QN + QGYIdA5ekoHhkBrqkPRonyTGuyXbt++1vG/uc9XDuehxdSG475u3ZYdaXw8g6CsmBsAgWiQ31iWFyX5J + j0BrHwQRg2nQRZgcASFPgJAnod2Pf7QHYBpsSKAsNGDDAjpb3CYI9oSKgA0LsGQwnC5o+gZQEdgFBvjc + RmWGtIhY+sT657gioO1QY4qAWliG6c6ZkL8AONglQ3dw3Qqt+87UrdJmQ8E6XEtdvdxQs0p+tPlR6dz7 + bfmL9s/J73oYKoDQgtV+epgCFUIYwuttCPx/hOD6DQTuewwnQMiqoIawoxub3enehWBljwIKfwo+VSQ0 + KZEKhlESmPVulQwIxvcgTJnYdgZ/aVVHZXAGFMLv47iE9SpEiko58J56BsznVYDHjsVj8xw8F8/Jc2ul + BL0ivRD8+A5/h33vND5vr+0MFZDBvCo0/Azff4dKDe+DUU6o8Lxr3uM9o1Jxvo/tnakshPforzpvlIl9 + d8jCbT+X32cXvVrskVoqZ4s1sZNu/FzNai0BzXCSpOOZziW4/xTW6jfCP97CV939VG7tyF5T08+9T3e/ + NtPaH07v05JaCn6W2HZNZfmTpuJz+y3dTaNHF81+KHBMCHd28EuBN2RGOiQFPkFkwUPmg5/oOF98plDs + gSLAYWXNrwc/vOcuFy/yuLrgXPS4+hDc8vls9tDWCQj1k7mRQRB2p2TBIOj+T0LQE8owoBxkxo5AAcBr + hgScTOFjAgynxPoAY4rnByhM34AwLPBCqAiAySWaYekc3KHMz7YTZu+AqSZCsJI2s5FQ2ExomlfAKAKW + AU9jzI7669kgy791OHc9E8KqpVC/XKpqF0keCkGK/QXqOKOACgner62RXO1SuXvjA7Jx191SbL1d3dJv + 0YKHAIsAgcYOde/0FUKLnD0FIDxDC7sAYVohwlHG3RCunRDaPbSGIXwhMNnBjk2MzvYX5FzvvFA4GrB0 + kUKTlQyn8b52NTTWfdghj5+j9f4hsJ8z3+MxeCweU618lkfGzsmWuRyXe7aYkDPacZHKD38nvk+lRZvr + hI13PhishLCngmTewz04DcVD3fjqZcAaQyeDoSLwW7z337bdInv23inf3f4jmc94PZ8FkGDfhwaWfC6R + fMNiKdSZ+RANjN/jmdWv0efjeqYzwUftIxX8dk8SVFiN0OfejWr6uafL4vzc+8H+HaFnzMzsVxqh54w0 + 0wPasXRkBL8iRnOzE/oxgAeoQTCK4+EcNBJSowwRHtG/Wl0AHlLJlr+TnacSLZtGgy//IbQyNx/yuLrg + XPS4ehHULmoKJg+fqmRXLpYKFkHA7BfwUg8IuEuVgCSYiBI8wwEupjADxJmRMiRrmVgXJZkXE5Zoydiw + gO0k2AZFgN4A1jcz/snkp+dMtQDjo3SV2rLB8v4BRgmI6qktU2YtdxwxZj07rJB0wzK1JlNNOF6jDUFw + MBGUAKynGxdJsv5JCIPFkmjCZxuXq+dAS8lqVskfNj0lT2z7sTTvukP+u4Ofk/94ZH7YhGgUFvxgVl3b + GuuG0GNogJYuhT3DB+9BoJ4u0pKHBQ8hqYBC8QEF7SSscioHUdzdgHkCBudZymiseevWPzNYgHVeUQKu + ReEC4zXgd+PHKj0HrgHn1hwAXKdeExSW97tgtXfjOPiMWvH4bfQCnAZYo68KEH8rfh9/I13+v8P6Xx5Z + IP/NwS/KCy98Sx595qdyc9PjUrFukRTW0brHPV8PKxpWNas5CnVQwBqflPQm3HMme9bXQimAcG1okCSe + UaZpUfismCA67XnOMazgL3H1m5I+7l07qz8+spd7nXseCnAY52dpXyzDn56zqK7f0JGhq2n05qDJmUKF + PQX/MP6noTDJJEGel7yjS+YPdDFUcCJoWuaH+VxjcC56XN1I3v/125KDe47nRntPsEtXchzMgxUDUARS + IOg0CR0Enzl68WWEZB7TmJKJHyqsN4BKAL0BxiMQdO6RoAOKAGOdZq4ArSFljvHeARx+YpUBMlYmClol + IA7rfmUMlgLDwsW0ZwCOJk7UwLKsXirJ2uWSa3xa8hAuOQiePOvA10PQMDO8YZX2HggacZ0KXCMHxnCd + Y13X43gUVvhOvmGpfLZpiXx542LZ9ux3pXfvN+Tk4S/I3/bMV/e/xr9NLfsZWMScSWBd5eopsC57CE7G + 1BlCsKCLnv3sLdTlb2Hc/KGrvxSuzxDxY+mxY+fSeL56LmJQzwCun9/Hsc4MQwHRJMaEKi+/7rxB/ofW + z0vnC1+Tpp3fkj/cslw+s36Z5DlSt24x7uVSPF/cUw7DaVgrhZo1kqutgeCv0wY8meo1kl6H92pwf7GW + q8X7UADzTavCefx1+G7NcknWLYNitqTkWc4KJXsJsPuMPQPs3uN+JLg3uUe3QvhrnB/7lnu4pJkP9jhH + 9lLwa5yfdDDVzc+6+63VH6elcjr7ODH+jwQrAnAeuv5zk+AHTAQcDfMB5uH1vLGBE8HQntczP/62L/G7 + BuFc9Lg2EOyqbb+hc98rC+iq12SftlABYF7AAF6D6J1MYQYgE7IIGVNHCdRysUqAIuwkmOilpWO8AYx5 + 2iZCZtxw4oXtIdOky5SgFaUVA2HpoFpaFnGFgIzZMmlVCBxMfSaoq1XBnoM1qQKeneIgkJIQTAwDBDVr + hQlnySZ8VoU8UA9hhDXOhw8ansLaUi0n42wCziugYKMikG7Ee5wsx+ZEHCxTXy0VjWvlD9Yvl/s3Py6P + bv2Z7N11p4zsvVX+p+Z/Ir8+nJMPuvBoKaSZWzCcm7Ko1YsAYJ1JhhZq9cMSVw8CQxG0wq0lHodZ52fU + pY+//G78WBoasOfhOfE95jlElQwQ+v/Qk5E/7/yMvNL2JelsuUPW7P6J/GznI3Lz5qWS5rPhPcTvTNav + k0LDGihYK0IXOz0rzNrfiP83LBc22UlUL5FMwyIV5joqun6NKlM5KF0s2VRPQO1iSWkOAJ91OEKX56Hi + NTceoJjgt0LfCnwC+09j/DbBj3tU6/mNu18t/tDVr0puzOJXJdgI/jDD31j9RviH7v5SerKC38JFkzMC + 2/cOtWvOUJaZ/5zbP9Im83CuBV3NrwbP1fiuftcwnIse1w6ClU+umH/4hWPz6f5nOc8IKwJI6BDOc9BJ + 0MYLp9CpjCpZDMH/1XVpcgMSg62SGmiVZD8VgbKwgM0PMEpA2D9gsyR2AxyEYuYLaN00Bw0BkTJgGbJV + BOZKAdBubwb1jDMvgqUJK5VWPZvFrIegYSignt0FmQ+A1/oehQ+EfG04rIhCSuPJDesUaQisXA2EH6xW + xrOjgTP4LBUInpv16kxmC49JAbRKPQ//bP1i+frGJ+R7mx+T5du/IzU775Fnd90lR/beJi8f+EP571s/ + LX/WvkD+3ZF58pftN8l/bL9R/qrjBvnrrvnydz3z5O/7KuS3AwUdkkPwf67xPX6Gn+V3+F0eg8fiMXls + noPn4jl57u9v/7ncueVR+Scbn9SeC8EGKmGhkE9BSUpBSNNzwjn5LKnMwUJnUqX21oe1n2ik9wSKgOZP + 1EjWJPCxfbMqBlCGeC+ZgKnNnXif9FngvjEfAO9T4Fc0cC4/80GglPHYeJ/d+qY/zxnC7qO48LeKJ/ae + 3Yfa1yKW4Mfe/dy7tpmPjfOr8OdeLxP8Sg+gDTuz38b643RE2orTmsboHTQ5I5AHFI/AKAjpmDxi/tFe + md958JVg3aoaF0/xuHbgXPS4thDce9utQfOG0fTYkROpoU4Qe7ck6Q0Yg0LAbN9RrhlmoqWC+B/MRq2D + coYxU9jsZMLmBsQ9An2weIgeWD9kiuwfQOuI7lGWDjJZ0OYI0CPwPMcOl/cQYI4AmH28j4BVAsoVApMz + cKHkwZmDbv0Pg+s7Hpccs84BKbP2y+P76ubHXrMxfiqkTFylckrBT4ufia0HIPS5d62rXwU/9jb3OPc6 + 97xt5mMsfoWJ80c046KpGYLZ/Erfpg8I4/yqPJDOx1olN4HX472SHuiQ7ETnyaB1w0Rw9x/9gYuXeFxb + cC56XJsI1i2uCcaaT9ACL4z3geGEmr8mB4IJMDGwMIw1/E0BdAu6GMqsAGamjM2GBCzIBDU/AAyRFlFc + CQDT1OzoWOmgMthdpofANEXAlA/SJWuVAP61/8cSB+dOAfC4mhHtA4VRErlXYntnKqufgr823GvccxT+ + rFxRi9828jGjeltg8R+KuftNMx/d42zmY4S/Le0j4hn+ThqaBdgynO2CSdOVLOdj50AoAemX+vR8WtYH + mk91HZD0i4feTNQu9r38ryM4Fz2uXSTv/fqtlcP730i82PNmMNYfNvogAxqCdQCGkR1nHTBfg0FpQpCb + scwGEXMzIQEiUgRoBdlEQasIdO6RxJEXtDzKhgbYHtU2E6IywB4CtnxQGbKWEIalg5Gr1noFCJu1rW56 + wCEUPK4j2H1g94XdJ2bfcB9pXwruKdbxxwS/9q/AHuRe1D1prH5b0pfs2BPuYSP4wwS/UPCXCH0LQx/q + infQz6zATn4jrVAA2mjda3If6S89eFgKMACC0V7mBZ1MDu95I/ntO2928QyPaxfORY9rH8HKJ1bkR9tO + 0PrPvQRFgBUBJms/i7/qIpyYWwWAsEzOQj0CRiEIFQGTJMiEKDDMJBhnspNeAVM6WFY1oB3Udoflg3FF + IAoNRCWEsNysImC9AQCTxgjtKeCCqQMvh2abEy6h4nHZ4Ho2JXA9U8A+d5fg1/p9u3cA28DHuvp1r7F3 + BfZeVM5nu/eZGH+ycy/27r5Q6ANRgp8R+tG+L6OHORX+xMQhyR7rljS7fzLsMNKuTcAYBmAjsEyx5fWg + fuUmF4/wuPbhXPS4PpD++h99Nuje/Wq698Av8/2HJM2+AUd7JRjrkiSsA7b+dDKVi4EJBVhoW2JtTWxg + LKMwGzpUBtR6Uo8AkwXtjAGTI1DWR2CqhJCKgLHYWJJlFQHOXLfMHmDHtpJOg0BcUEwTOja2POsYs8ec + 4iOeQ8mzjD9j+9xjgr9kHj/3DPeO1vBjL3FPmQY+to5f915JjB9KKvdo3OI3+zja13afm31fQgtzFPOP + o8AW4X2mIdixPs3Byfa3Smaw5XjQ9dyr+bu/6mP91zGcix7XF4Kljy0KRva9kXiR7n8yIiYHdeHvHOYA + uECGZxAxwWmKgA0NgImWNBNinsAebS+sTNhOHtwXthi2CYNah02QkccVAYuYMlCaJxAiEh7xenALtqJ1 + CB2PywjHcykR+rFnqc82FttX2H1grP0poY89Q6HPPYS9pHuKc/m5x+J1/Cr4sRet4I+17i1P7iNKhL2F + izbmCLnRHu3dnxrtkhzOm3yZOT8HT6VWL1rr4gUe1xecix7XHyq//NUFwY6a5uAXh38VTBwJrYaJi28U + 9JGICf+IOVolwFYMxBQBO3pYLSwyXdZSu8ID+8q8AnYUse0nQDBMwIxuW0poQwRxZcAiLkgIWx/uEkoe + lxH2OQDx5xN/dnGhb5+zfe42oc8Kfu4R7hVr7Zt2vSVDerjXbB2/EfxRHT+V1Xic3+7lmPCP9vklFv4W + uSH8Hce1HG0+lXq+rr3qtttvcvEAj+sPzkWP6xfJP37w++muva8mX+oOGZiDocwVWG5oa5otIuYYMU6s + kYHhWpgxnRpok2T/IUn2gsl2x8ID7CrIPgJtYeWATRgkA9ee60YR0Ixt1mrbpEFTx83s7mgIEQEhoXCE + CEoEjcMCLYFTaHnMGeLPgog/JyB6jua58hlrtYh97swXIejmp/A3gn8qo39nVMOv3iYKfu416+YHKPxZ + x8996bL6XcLfQkvxHLQxV+CQn+AXnZLp3fvLzM8ffsBF8x7XL5yLHtc3gtu+XJVoXLU1PXnkVKbYK5wC + lmdfgFEwM2YVszpgBAKZfcOZLHi0RxKj3bA0OqUwYrwGxVbJ4DPlDGnGsG5Sy0wNc9XyKTBbmzCog1Os + V8CEB4LDYNTWK0C3LS05NmbZbUIEbNFKps+ubdYzQIvQegY2hYJjmmeAbWotYsJH3c7lpYUME8QxEwXh + GihTZCKeaz1C+f0ou1+2TC9C3K1PAb8e95wdBPksyqz86NnxWdK9z+dqW/TyeWu3PuwB7gXuCdO0R/dK + ZO3Tu0Tlcrq1rxY/96AV+ITdp3bfuvb0DMDsfU7pY7+OdBGCfLhLMqNs2dul5bvs7KlCnrQ5hmvB/5X4 + XNVQj+QGeyT9ctevgvpVm4Jbbi24aN3j+oZz0cODCL5y+01B9zOvBqMHTwTD4Yjh3Djrhju0T0C2eEjr + jKv622TBcKekx8C0Bg/qrIGKSXwOjMvF1GYEw0gjq8mUTE0pAVPJglYJCEsIjSJwuCxPwFQPaHvWKDyw + MVQE4p4BZn5TYLDum5gWJoDQAaZ5B4Bk0+pIYE0TcOVwCcVrCDYbP1qLJ1AqHPckhrjwjwt+i8RGiymh + r4LfPjcj+JPbSy19W7uveyDeqpd7hMml3DNMNuUe6piK8UeufrvvjOC3+zKy7OdIAVCvmPUSDEGpHmqT + qpEOmTfaKRVQChKD2Pdj+Dsajv9m05+giOsjzfbu/GX6G3d93kXbHh6Ec9HDI47sEw88wt4BAcsGuw9J + 5SAsDwr3F49IXuuKwXAGwSBHWyR9rEMSE1iDkpAZvvhWwxbx8ACtoUgRYL8CgG1UrSKgSVjWPUumzSlr + 6hHYFTJ2WHfabpjuXeYK0NW7Jywn5Iz2qO0whAUFR6QMbAtDBVQGIkFjrU6LSDhBgFERiCWkuRAXltci + pikAZXDdkzguWKdvYJ+DFfq2Xp/PTZ+dKd1jzb7O3y9z8ese4F7gnlChTzc/lEbsmah+n4iX8hF235l9 + qHvS7k/sVdceng2SsPi1bfc4jn0Ma+M8L65rqDmkvWNUsg9LBT1v/fh/sv1UYfTAicyiBxe6aNnDIw7n + ooeHC4nqpfWpsUMn6GZkE5GwiRAY3i/6JHiJSgE9AlgbAyMCQ8yN9k5jaBeDuBJgYV2ukUKgXgETi9Xq + AaMMGK+AMvZY0qB2GdR8AViALCc0ykDkHaC1aJQBGyZQhYDKAGGyyLV2vMRDYBApBGUwIYPIqjWvy+ES + mlcTnL+p7Dfr/657RFhBX2Lhm/uumftQyPgcqKAxhGOsfCv0+Qy1TwSeKXNBVOFjCR+eOZ+9TerjnlBF + 0Vj6VuiXJPURxtqP9l3ZfpxL4R+ClTidwpCbuvihBKRe7JbkBNZBf5zix74dHOKTGD90MlG/wtf0e3xs + OBc9PC6ExNe/9tnMwU1DwVjrCc4LyE0MSqL3sKQHoBCMd0kSzLEw0A6LBAxq4hIkOMXDAUB5iMAqA6oI + WGWADLwPzJwlWsYroIyerl3TcjjKFaALmI1dqAyw7IuKAGHLCuM5AzZvwCoFGjIwQsl4CaYpBITmERgB + F/+fiAlGRcwFHrnCHYL2SoDzWs3viWB/p+selN8nI/A1/GLj+DaWb+57FM83rv2SDH5CS/dMlz5j6Ucu + fk3oC937kbXPPcK9Es/ktzBCX1G276K96NqzF4OjoCMcN0WFergjbN2tijfobbBbshPs29F6IrV3fU9w + x1c/46JZD48Lwbno4fFRCH70w7uC9udeznF4CGOUdPszIQkWCxMG87CEkiNglC6mdrEwzLcccSUggpYS + GiVAYUIEtqeAQxlw5gwcMAoBvQNUBnZB0FDY2D4DO2MKARPNbM8Bjog1CoHCWLLThJ0VglYolgvMOOIC + 9UqC61rjv8ui/LcT9r5Ewh73TO8d7qG9n7y3KuwJc9+ZxMfnwGdCgU+3PpW3eEw/SugzQp/hoFhcv6R2 + 3+4T7hnunfhesnDsPYVrr140oFyPwtIf7dRmPqQxpTW8lxlpfyN1+LljwY9/5Gf1e8wKzkUPj4+LYPFD + CxccfuZYxYtH3uQoUW0nzBGjYIhZWk3TGNoco4zxlisB0f8lPQVaDLOPKQPdU8pAgj3cGSaw3oE2CA/r + IYh7B/YaZcAqBNY7EPcQ0CVtrVVarpGXwIDCjhPm7CRDl3JQDpdQvRLgulYL+9vsb40Efexe2Ptj7xfv + nbXuNWOfFj6Evr3nFPg2ls9nwmdjkvj0ecWFvu3S5xT6APeE3R9G8Jcrk/o6LvDL9t4lwVCrJvZRsdbr + OtohNxzrfHPBwS1DwfKHl7po0sPj48K56OExUwSPPfRQ9sjelzOTfac4u1yZ5aSDoV0G8NwR8+YaGbVl + 4iZXwCYNRsoA3b4UCN0HdP5AomvvlCJglAH1DMQVASAJS9MmEjLGnHyBMefNmnCmCYU2f4CgQAMYLihJ + LLTJhUC8F0GSfyE043AK1w+DS1DPBK5jfgimXW/cojfQ+nv7u3EPovth7o+9X7x3TMgMk/dwL3Ffo/p8 + Dt8hmLvB58BcjnitvoXG9mMDeQgr+M3z1zn8Zl/YfRIJd7tvyoV/bL9dSqQnO3F+CP6RTqk8NvhmoX3v + y8GTDz/mokEPj5nCuejhMVsESx9clOvb81r6aM+pYLhbsn1HJDPabRIDmyU5ekjjmOmRbsmPDgjHELNN + KROZNIGKnxuGcB4+JImj7DMwnSnOBFYZKFEK4oi8AodC9EMYcFwrWw8TFBwWUagAioFWFUAxoEJAi7M8 + ZEClQBUDk1BIWE+B5hJAqOnMAuPKjnkLIuUgjrilbNvXKoyAjcEqEBo/txb3LFFyLMe5Sq4lfo3x67b/ + x616Ax3pDHDAzrT4PWHvo3Xps0bfWvlEG56BrdO3bn1r5XezbA8CnmAHST5X+5ztcy/bD9P2i2NPzQTM + i9H/jdLAIVtJ9tTQuRs9kh0tSnqoL1zTvhm4xok2ndqnyX3FLkke63kzN7jveGLVY6tcNOfhMVs4Fz08 + LhbBEw8/UhjYdzyY6D6ZGOqQ7ECnCn3OF1BBP0Ihv18K7OzHcqaJdkmyumCYM8y7VElQBhhjprMBz1Ve + PTCN6ZcnDQJWYGh/gViPAUJLC61CYC3NeCIhoJUFTDpj7gBhwwa2wsAoBDpZziAaYhTzFpTAusatQCWs + JR2D7XKnlnbM8p4NSo7lOFfJtdjrc127sei1qoJllgYq8I3Qj0rzrEufMGV6UQIf7vFUud7usKrDlOxF + Vj4tfCB8dqWCv7xuv2QfxPaI3TeuPTUjYE/ThV810SsZ9smAkOc+Zw3/PHa4HME1Tx7WQVzp0R5JTQxA + IeiR5GCHBC/1/6ow3nIyWPRzX9LncUngXPTwmCsE65bU5I/sflmbmfRD+A50S3KMnczaJXOMwh5/YfUn + xsCY2WFwFKB7fqhN8nMwi8Ay8nIloBzx3gIUElOAADHhArZ7jSsECiN4IkHUDiv08B5JagMi4yEoUwwi + LwFhBB6FX0n5Id3eMUEZCUwK0HhYIWZNK1zCNw4rpC8E13fiKD+fuQ6XcNfrNVY9S/GskNfWzPZ37wvv + A1vuJmOCXt356tJ/QaH3k/f2CEMz+3REtN53+xwIPBc+o8itrwifY1zou55/HPE949pTM8E8Kr06+S/s + 0scGWsEY9tPoIZmH/5MvtWD/49rG8TlY+0E/FOSJnpOprn2vpmvXNrloysNjruBc9PCYSwQ3fyGVq1lU + nx058EYw2XkqwZLBQXoDeiQzAIbMlsIsGWTzoHFYQS/2wiqiS5SM0s1YPy7izDyOcmYfvY4rAjGUewhs + tni5QhDmDxjhBEQ5BCaPIPIUEHRhUzFott4CKgYxb4EmGpYqCJGSYGFDChdAiTBmEl0cNmGxbL3kO45j + RuC5Y9dSco1WyNvfgd+kpXjNsOiBoBW/lzCKUWTZ06pn3N7G7mPCnvdWPTDmXodWfqmFHz0nwnp3HBa+ + 3R/Rc4/tjTjie2lWgODPjHdIfrIrHLdNRZilfczk10ZC3PdY78f1TRw5mRprOZGtW+oFv8dlgXPRw+NS + IbfkjxclOp97JRhufSMzCMZ3rFs7Blb1dYbMEEySQjgLhp0z5U6XEnFmHxcQFlZ4KOLChVChE1qciv5Q + GbAuaAWFFhUBwsanGauO5hUAGseG8LPVBjafwCgGFqogxL0HhBWwFsw5oAA2KBHKMWGtiGfTx1DynTh4 + 7PLzxa/FXF/JNfN3UMDzN/G38Xca930Ik0/B+2HujypODmEfCvxY1r6iTOiXle5Fz/ETSOBTHD0saa2O + ASD8UxD2N/Z0SSUsfSoCmZEBSY90vZHs2fXL1LJHfFa/x2WFc9HD41IjePB79yeaN4wGY4dPsMaZHc0C + 9jGf7JHkOJSAYcZKL94DMGsYYRFXBlSQxISLIl5eSFhL1MJWFxAsPbMoVwpKFAMrHI3HwCCqQrBKQhzW + kjaKQwSrNMQRF9pxuD5bfjx7nvLzm+uK4vMWVG4cQj6CvQ+ELc0zgj4U9qGnpeSexu535KGJCXt9TnGB + T7ie8WVAog+/aQzXfBTCf6JLFQANCYwelux4x8kUy/ke+emPXTTi4XGp4Vz08LhcyNz5jc8G29fuT7/Y + 8iZjovO6wexZCfASlAHNCXAz1suFD/MOENMUAiImoCKhZQVZOWy1gbF4ifIwglrEEJY2z0AFaTnoSYiD + gtd6FiJhDCH9cVDyHXucsuM7riG6Pl5r2fVb930Eqwj10XMSux/mfsVj93HEXfpE/FnEvTmuZ/mJgMJ+ + kpZ+h+R7WyU30S7c68GOdc3Bvd+61UUTHh6XC85FD4/LjeCLX8oGTSu2BuOtJ5OTHaeyfe1SMQQlwMVU + LyPiAmYmcCoDFGBloNCzcWxavMneKaQB6wInKERdyoEKWMbJjQAuVRIgvC8KpcKdiBLwyq/BXl/smlP2 + 2s1vspZ9aN3TlT8l8Evuk7Hs4/gooV8O1/O0+DifmQsURnpx7fgfezqYaD2Z2LxuV/rLX1ngogEPj8sN + 56KHxyeJ3OJHF+YO7ZwIxg+dZKIg+54rQ6VHgENPhtu0vlpHoCqDhWAYgSCZhOCYgAAZhlWpr5lsZVyu + Q606wZCjUwOWY2lCVvc0hj1TxIXRx0GkGFhhZoVbXAAaoejClLIwpTREIQYXaG1fDFzHNAgFeen1uK45 + Quw3Rr+bIRSL+H1x3DsXXM9kJsgVu0O3PAfu6L7A+W3IgDX83HPYS4nxQ5I6iv8n8DtGmc3fJfmxPkmx + eoXxfV43j4H1xKipdGFYa6Lt5ILW5yZufOpR37zH44qDc9HD40pA4bY7PhPsrG6uKh58vfBi15tUBHLF + XimM9+skwgzdx8MQRmDKFPyJYotkIGgKYOhZll9RcdDcgg7NK9AxxWDotPzSxU7Js+yqTCDMFC6hFIe1 + NONrJYLOCMJIIMaEZByRx6BcqFrE3egxxC3u2cB1TIXrGoDoOi+Aab+3TPDrPYndq4+C65nMBMki9oc2 + 5unQuftULFl+ymoUNufJjvVKdgh7ZaBdcrhelqymjuK7VAZGmrHWqY2ushD4qWE8ZyiYeP9Uum/va8Gu + 9e0VP/jena697eFxJcC56OFxpSF46KffT8GSSk10ndRpaGyP+oseWQDBntEOaod1RKoOTCmGAjdzlA1V + wv/DWmwILlhvLMfiwKIKVh04hMJcwioA5UqAC+WCMI5ywWnhErJxTNXDzw6uY8bhuibC9RssLvSb4+vR + +457Orfo1H3DBD09n1FidN8MQVHEXqFgJ3QuP/YRFYXCaIdUck+91Bt6CuhtOtp2KmjeNBosfOgR1x72 + 8LjS4Fz08LhSEXzljxYETSu3FgZbjkOAvx4MQBApAwYjptUPi07brY6DOY8d1LHEWTB5MnL1AsBCC8MA + eB/KgFsozB3iCkAcVsC51uKwWeyu94i4AHXB9Z2ZwHXMOFzfIT7suj/qN8ffd93TOcUYroHledgzasHj + /FynIqmjdsebIfRbws6U4314D2vD2G+qDHRI1fiRk9mB/cfTW2p2Zb757Ztde9bD40qFc9HD42pA8MAP + 7023P/tyfqD5eG6s4wRdthxERJcsSwuZK6CeAlpqYPLZCTB1rjNmyxwBunHLBcJlRlzYuVDy+Y9QBlyw + 35ktXMe8EKLvxa7Z9ZviiH/2k0ByEoKcygysflUSj/VofX4wbrxDA826l3KjzEWBcgIFc/7R3lPzim2v + Bwe2DAU/ve9e19708Lga4Fz08LjaEDz2w4eC/ev7EyMtb4B5n2QyVmasX5IvgpHTG8CugmD0uaEj6vrX + vgNXQJnhrBATzJHQdcF89qLwEccouY74NV4toPUPyz+t8XvuCa5zv7RJHgpKdnxINOQ02i75ySOnss2b + R4Of/+AB1x708Lja4Fz08LiaETz64APB/s39wWTzqRv7Wl+rgnBKsdUwGD6ZPcMCObpwBw9NCYKrDNaC + tgI4blXH4fruTOA6JlF+Xtd3rwoUw4x+Wvg6c38MvwdKQBWUxU/1tPwyONb2Zrptx7HC0oWLUl/8Uta1 + 3zw8rlY4Fz08rhUETzz+SHbH5uYKumwnOk8GI7TuOsPhKyz7cgmFywlrTbveA2iVqmUaW4sLYoY9XKBQ + I+Lfmw3scVznCDF1LfHvua67BB/xuy8bmOTH38dqAFj6TDItjHacSO17pj9Yu7zGtac8PK4VOBc9PK5F + 5B750Y/Tuxs6g8G9x9mCOD3SpXMIUsPMAIcAACjUuM7Sr8Jgp4YRUiNM/ILCMAyBN9atpWJMCksV2yU9 + fjisBWclAgQarUiOdc0QI32SwnF4fB6XAkeFIgUn1rg+TSBdZ+B9sPfGKgX0LKQYpuGsCLymRa4jo+28 + /PE2SUwwr+OQ5Eb6JVNkqV7YZpf3n8me6dFwnkQezyjHvhH4rk6cnMA5xnEOPIcMz03Bj70QDO19PdhV + 35585Ae+La/HdQPnoofHtY7UN+7+g2DJozqYKN33wmup4YNvpK1gYW6AegdowR6A0GjRJjApCg8KKZaE + 0YNwtC+c3V4Mkw9ViOEYwWhL+L3RfTgO3comqYzH1bwDnAOfpaCzgvC6BRM0eU8plCdwT0yvBn2PeRpU + DqgwAWFyZzg8Kj/co9D7rRUdh/GZUCkIxg30fyhvLA3FM9Byv6NQDqC0JfsPvhYceeHloHpxfXD/d293 + 7REPj2sdzkUPj+sNqQe/f39q2+o9ye4drwZjzSeSk7AgJyB4IDRUGMGaTBVpSWIdr5OjEC7DLZJgcqF2 + HmxVK5W5BvoXyoM2lYHgYr4BrVF+PxxwdDgUdMxAt4LweoUqRVSaDklq5JBOzgst9w5FdpLhBQp31uR3 + 4zMs9cQz4Tjp4T79vo7bhdWfg1Wv8/apYFmFYhSfpeegePD1oOu5V9M765qzjz30UOoLtxZc+8DD43qC + c9HD43pGcMcdnwmWProoeGbN/mx326v5gY7j2ZHuN+haDj0AoUDK0qqcxP9QFlSgU6BpKIGlht0ArM+j + EFQU9LasjK5olidqyICCz3zvegVH5dpxufzL8kx6X3jPYK0nKeQ5E4Kuenye/R0Sk61AsySPHsTn+Uwo + 5BlGAPhd3Ndkf8tr6e79rwbPV7cHK3++Irjz9s+4nrWHx/UM56KHh0cpgh/cc2eiceXWXPuulwujXSey + Y70nEoOsDWe8uU/j/okiBFAxtP7TzCaH5cpucoxN03WdG++V/ESf/mXrWFq00wTidQYdBQ3wflgwB4PV + GskilC1VkkIXv1WYwjwKvDfQIunJbt7rE5liy+vZjt2v5LbX7889+vADqS/6gTseHh8F56KHh8eHI/29 + +26fv2zh0qB716upwf3H0yPNbwTDwEhL2GDoJSgDx45oLTl7DmgrWSgHFlQM2G62XCBeb0j1t4f3wd6X + 4fBeMdSS0xyJQxqzz4536Gv2cKga7Dqe72p7NdGyfzS98MFHgvvuvs31jDw8PD4czkUPD4+ZI3vv3bem + F/98YXJb7Z50x65XsmNtJxLDB97QpEBOKeQQmWNhMhrDB8wPcAnF6wkc3JQzCXq8N8ExWPeTh/DeQSgD + +94IJvtPBX1trwUvbO0M1i6tCX76vXsTt32pynX/PTw8ZgbnooeHx9wg+NZ3bk098OD92XVravJ7d/Tk + +ppfo8s6GG8/GUBBcAnF6wrM1p9oO5nCvcj0HPhlZve2zvTalTWJnz14f/Dt+7xl7+FxCeFc9PDwuPSY + 97Uv3xQ88LP7U0ueXJTZWr8n0/rsBMvTEsNtb6SGj7zB9rRBsVlj3xxgFA4zYjKcTXhjJjyt5cO6rkOQ + Rjq1tl3zDrTHAXMQmI8QwimEY7Cfs98LjxEek8fmOcJrOKznToz3aIkdr4frvEZm4mui41BzeE7W2U+2 + nwomD58KBg8cT+zZ0hPUrKwPFv78kcrv3HVr5qtf8vF6D49PAM5FDw+PTxbBHbd+Jvj+N+5MPf7kY+kl + SxdlqtfUp7c27mGHukTnC68kh1veSFKownpWwXqUAhaCmWV1tsMhBbIR6CqIy4T9hVDyHRX2/Avw2Jqd + b4Q5zp04duRNzl/gNfHaMlsad9HbkcE1px5b+Mj8+75xW8VXbvEC3sPjCoRz0cPD4+pC+uabU+mv3X5T + 8p67bg5+8p1vJR754Y+DJ37ySLDksUXB0scXBcufWBqsfHJFctWiVak1S9Zm1i2ryVYvryf4P9f4Hj+j + n+V3+F0cQ4+FY/LYPAfP5boGDw+PqwvORQ8PDw8PD49rG85FDw8PDw8Pj2sbzkUPDw8PDw+PaxvORQ8P + Dw8PD49rG85FDw8PDw8Pj2sbzkUPDw8PDw+PaxvORQ8PDw8PD49rG85FDw8PDw8Pj2sbzkUPDw8PDw+P + axvORQ8PDw8PD49rG85FDw8PDw8Pj2sbzkUPDw8PDw+PaxvORQ8PDw8PD49rG85FDw8PDw8Pj2sbzkUP + Dw8PDw+PaxvORQ8PDw8PD49rG85FDw8PDw8Pj2sbzkUPDw8PDw+PaxvORQ8PDw8PD49rG85FDw8PDw8P + j2sbzkUPDw8PDw+PaxkS/P9lcNy7IgzneAAAAABJRU5ErkJggg== + + + \ No newline at end of file diff --git a/SourceCode/resource1.h b/SourceCode/resource1.h index ae08447a6336998a6b68d1730ab744d1309fd6ee..a48c269c987d832d317b9b5d5f2c11b7fecc5322 100644 GIT binary patch delta 24 fcmaFH{(ybLD&7)?M20+u6b2`TN`};pdo`H>XA=i~ delta 30 kcmaFB{)~OXD&bs)M1~@U5(XcJe1>!&E@dd$xLuPO0F@dD Download .txt from git hub which defines the newest version. (http://stackoverflow.com/questions/4604663/download-single-files-from-github) https://raw.githubusercontent.com/flobaader/Stand-Bye/gh-pages/index.html -//TODO: delete vector with delete[] XY -//TODO: Migrate to System::String? -//TODO: Cancel MessageWindow on mouse movement -//TODO: Debug Form -//TODO: Implement Log System -//TODO: Implement statistics -//TODO: Discussion: Use perfMon to read RAM Usage? -//TODO: Discuss the standard values -//TODO: Watcher --> analyses the average usage -//TODO: Always standby after f. ex. 10 o clock -//TODO: Implement message window and make a welcome and good bye message -//TODO: Message after Canceling the Standby Countdown: would you like to enable the presentation mode? -//TODO: Names and Copyright in all files -//TODO: pictures and team description -//TODO: booth design -//TODO: umfrage - #define threshold(X) settings_provider->getThreshold(SettingName::X) #define active(X) settings_provider->isActive(SettingName::X) #define sysMetric(X) system_watcher->GetSystemMetric(SystemAccess::SystemMetric::X) -using namespace SmartLogout; +using namespace StandBye; + +[STAThread] //Because of FileDialog --> Application is single threaded - Windows needs that +int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, PWSTR, int) { + mainApplication^ standbye = gcnew mainApplication(hInstance); +} -NotifyIconAppContext::NotifyIconAppContext(HINSTANCE hinst) { - GenerateIcon(hinst); +NotifyIconAppContext::NotifyIconAppContext(mainApplication^ app, HINSTANCE hinst) { + app->GenerateIcon(hinst); } -void SettingsOpend(Object^, System::EventArgs^) { - using namespace SmartLogout; - MetroSettingsForm^ settings_form = gcnew MetroSettingsForm(system_watcher, settings_provider); - if (settings_form->ShowDialog() == ::DialogResult::OK) { +void mainApplication::OpenSettings(Object^, System::EventArgs^) { + using namespace StandBye; + if (settingsForm->Visible) { + return; + } + if (settingsForm->ShowDialog() == ::DialogResult::OK) { input_monitor->Reset(); } - - delete settings_form; + //Recreates SettingsForm + settingsForm = gcnew MetroSettingsForm(system_watcher, settings_provider); + settingsForm->Visible = false; } -void Quit(Object^, System::EventArgs^) { +void mainApplication::Quit(Object^, System::EventArgs^) { onExit = true; input_monitor->Stop(); delete system_watcher, input_monitor, settings_provider; System::Windows::Forms::Application::Exit(); } -void PresentationMode(Object^ s, System::EventArgs ^) +void mainApplication::SetPresentationMode(Object^ s, System::EventArgs ^) { MenuItem^ item = (MenuItem^)s; if (item->Checked == false) { SystemAccess::SetPresentationMode(true); item->Checked = true; + trayicon->ShowBalloonTip(3000, "Stand-Bye!", "The Presentation mode has been activated!", System::Windows::Forms::ToolTipIcon::Info); } else { SystemAccess::SetPresentationMode(false); + trayicon->ShowBalloonTip(3000, "Stand-Bye!", "The Presentation mode has been deactivated!", System::Windows::Forms::ToolTipIcon::Info); item->Checked = false; } inPresentationMode = item->Checked; } -void CheckUsage() { +void mainApplication::CheckUsage() { if (inPresentationMode) { DEBUG("Application in presentation mode! \n Canceled Sleep mode!"); return; @@ -86,31 +77,45 @@ void CheckUsage() { if (((bool)active(USE_RAM) ? threshold(MAX_RAM) < sysMetric(RAM) : false))return; if (((bool)active(USE_NET) ? threshold(MAX_NET) < sysMetric(NETWORK) : false)) return; - TimeoutWindow^ msgWnd = gcnew TimeoutWindow(15); + TimeoutWindow^ msgWnd = gcnew TimeoutWindow(15, settings_provider); if ((msgWnd->ShowDialog()) == (::DialogResult::OK)) { DEBUG("Going to Sleep mode!"); SystemAccess::StartESM(); } + else { + DEBUG("The User has canceled the MessageWindow!"); + + //Asks User if he wants to enable presentation mode + MessageWindow^ msgPres = gcnew MessageWindow("Do you like to enable the presentation mode?" + "\n" + "There will be no more interruptions!"); + if (msgPres->ShowDialog() == DialogResult::OK) { + //Enable presentation mode + SystemAccess::SetPresentationMode(true); + PresentationModeItem->Checked = true; + } + else { + //Do nothing + } + } } -ContextMenu^ GetContextMenu() { +ContextMenu^ mainApplication::GetContextMenu() { using namespace System::Windows::Forms; ContextMenu^ contextMenu = gcnew ContextMenu(); MenuItem^ settingsItem = gcnew MenuItem(); settingsItem->Text = "&Settings\0"; - settingsItem->Click += gcnew System::EventHandler(&SettingsOpend); + settingsItem->Click += gcnew System::EventHandler(this, &mainApplication::OpenSettings); - MenuItem^ PresentationModeItem = gcnew MenuItem(); + PresentationModeItem = gcnew MenuItem(); PresentationModeItem->Text = "&Presentation mode\0"; PresentationModeItem->Checked = false; - PresentationModeItem->Click += gcnew System::EventHandler(&PresentationMode); + PresentationModeItem->Click += gcnew System::EventHandler(this, &mainApplication::SetPresentationMode); MenuItem^ exitItem = gcnew MenuItem(); exitItem->Text = "&Exit\0"; - exitItem->Click += gcnew System::EventHandler(&Quit); + exitItem->Click += gcnew System::EventHandler(this, &mainApplication::Quit); contextMenu->MenuItems->Add(settingsItem); contextMenu->MenuItems->Add(PresentationModeItem); @@ -119,36 +124,45 @@ ContextMenu^ GetContextMenu() { return contextMenu; } -NotifyIcon^ GenerateIcon(HINSTANCE hInstance) { +NotifyIcon^ mainApplication::GenerateIcon(HINSTANCE hInstance) { using namespace System::Windows::Forms; - ::NotifyIcon^ icon = gcnew NotifyIcon(); - icon->Icon = System::Drawing::Icon::FromHandle((IntPtr)LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON1))); - icon->Text = "Stand-Bye"; - icon->ContextMenu = GetContextMenu(); - icon->Visible = true; - return icon; + trayicon = gcnew NotifyIcon(); + trayicon->Icon = System::Drawing::Icon::FromHandle((IntPtr)LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON1))); + trayicon->Text = "Stand-Bye"; + trayicon->MouseClick += gcnew System::Windows::Forms::MouseEventHandler(this, &mainApplication::OnMouseClick); + trayicon->ContextMenu = GetContextMenu(); + trayicon->Visible = true; + trayicon->ShowBalloonTip(4000, "Stand-Bye!", "Standby is active. The environment will thank you!", System::Windows::Forms::ToolTipIcon::Info); + return trayicon; } -void OnThreadException(System::Object ^ sender, System::Threading::ThreadExceptionEventArgs ^ args) { - //TODO: Implement on exception +void mainApplication::OnThreadException(System::Object ^ sender, System::Threading::ThreadExceptionEventArgs ^ args) { + //TODO: Implement on exception --> Log system } -[STAThread] //Because of FileDialog --> Application is single threaded - Windows needs that -int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, PWSTR, int) { - Application::ThreadException += gcnew System::Threading::ThreadExceptionEventHandler(&OnThreadException); +mainApplication::mainApplication(HINSTANCE hInstance) { + Application::ThreadException += gcnew System::Threading::ThreadExceptionEventHandler(this, &mainApplication::OnThreadException); //Application::SetUnhandledExceptionMode(ThrowException) - onExit = false; while (onExit == false) { settings_provider = new SettingsProvider(); system_watcher = gcnew SystemMetricWatcher(settings_provider, 2, 30);//Sample 2 times/second, space for 30 samples, average over 15 seconds system_watcher->Start(); - input_monitor = gcnew InputMonitor(settings_provider, &CheckUsage); + input_monitor = gcnew InputMonitor(this, settings_provider); + settingsForm = gcnew MetroSettingsForm(system_watcher, settings_provider); + settingsForm->Visible = false; using System::Windows::Forms::Application; - ApplicationContext^ context = gcnew NotifyIconAppContext(hInstance); - Application::ApplicationExit += gcnew System::EventHandler(&Quit); + ApplicationContext^ context = gcnew NotifyIconAppContext(this, hInstance); + Application::ApplicationExit += gcnew System::EventHandler(this, &mainApplication::Quit); Application::Run(context); //Synchronous } +} + +void mainApplication::OnMouseClick(System::Object ^sender, System::Windows::Forms::MouseEventArgs ^e) +{ + if (e->Button == Windows::Forms::MouseButtons::Left) { + mainApplication::OpenSettings(nullptr, nullptr); + } } \ No newline at end of file diff --git a/SourceCode/standbye_main.h b/SourceCode/standbye_main.h index 38e0c84..b3b7601 100644 --- a/SourceCode/standbye_main.h +++ b/SourceCode/standbye_main.h @@ -6,28 +6,40 @@ #include "TimeoutWindow.h" #include "SystemAccess.h" #include "SystemMetricWatcher.h" -#include "InputMonitor.h" #include "MetroSettingsForm.h" +#include "MessageWindow.h" +#include "InputMonitor.h" +using namespace StandBye; -ref class NotifyIconAppContext : System::Windows::Forms::ApplicationContext { -public: - NotifyIconAppContext(HINSTANCE hinst); -}; +int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, PWSTR pCmdLine, int nCmdShow); -HWND hwnd; -gcroot system_watcher; -SettingsProvider* settings_provider; -gcroot input_monitor; -boolean inPresentationMode; -bool onExit; +ref class mainApplication { +private: + MetroSettingsForm^ settingsForm; + NotifyIcon^ trayicon; + MenuItem^ PresentationModeItem; //Has to be accessed -void SettingsOpend(Object^ s, System::EventArgs^ event_args); -void Quit(Object^ s, System::EventArgs^ event_args); -void PresentationMode(Object^ s, System::EventArgs^ event_args); + SystemMetricWatcher^ system_watcher; + SettingsProvider* settings_provider; + InputMonitor^ input_monitor; -ContextMenu^ GetContextMenu(); -NotifyIcon^ GenerateIcon(HINSTANCE hInstance); -void CheckUsage(); -void OnThreadException(System::Object^ sender, System::Threading::ThreadExceptionEventArgs^ args); + bool inPresentationMode; + bool onExit; -int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, PWSTR pCmdLine, int nCmdShow); +public: + mainApplication(HINSTANCE hInstance); + NotifyIcon^ GenerateIcon(HINSTANCE hInstance); + void CheckUsage(); +private: + void OpenSettings(Object^ s, System::EventArgs^ event_args); + void Quit(Object^ s, System::EventArgs^ event_args); + void SetPresentationMode(Object^ s, System::EventArgs^ event_args); + ContextMenu^ GetContextMenu(); + void OnThreadException(System::Object^ sender, System::Threading::ThreadExceptionEventArgs^ args); + void OnMouseClick(System::Object ^sender, System::Windows::Forms::MouseEventArgs ^e); +}; + +ref class NotifyIconAppContext : System::Windows::Forms::ApplicationContext { +public: + NotifyIconAppContext(mainApplication^ app, HINSTANCE hinst); +};