diff --git a/.gitignore b/.gitignore index bf3516b..a4edba2 100644 --- a/.gitignore +++ b/.gitignore @@ -3,3 +3,8 @@ ################################################################################ /imageEnhancer/.vs/imageEnhancer/v15/Browse.VC.opendb +/imageEnhancer/.vs/MyGUI/v15/Browse.VC.opendb +/imageEnhancer/.vs/MyGUI/v15/Browse.VC.opendb +*.opendb +/imageEnhancer/.vs/MyGUI/v15/Browse.VC.opendb +/imageEnhancer/.vs/MyGUI/v15/Browse.VC.opendb diff --git a/imageEnhancer/.vs/MyGUI/v15/.suo b/imageEnhancer/.vs/MyGUI/v15/.suo new file mode 100644 index 0000000..351f9c4 Binary files /dev/null and b/imageEnhancer/.vs/MyGUI/v15/.suo differ diff --git a/imageEnhancer/.vs/MyGUI/v15/Browse.VC.db b/imageEnhancer/.vs/MyGUI/v15/Browse.VC.db new file mode 100644 index 0000000..2da432d Binary files /dev/null and b/imageEnhancer/.vs/MyGUI/v15/Browse.VC.db differ diff --git a/imageEnhancer/.vs/MyGUI/v15/Solution.VC.db b/imageEnhancer/.vs/MyGUI/v15/Solution.VC.db new file mode 100644 index 0000000..eef51c8 Binary files /dev/null and b/imageEnhancer/.vs/MyGUI/v15/Solution.VC.db differ diff --git a/imageEnhancer/.vs/MyGUI/v15/ipch/AutoPCH/MYGUI-f50ecd77/EXIF-614048d0/EXIF.ipch b/imageEnhancer/.vs/MyGUI/v15/ipch/AutoPCH/MYGUI-f50ecd77/EXIF-614048d0/EXIF.ipch new file mode 100644 index 0000000..681da59 Binary files /dev/null and b/imageEnhancer/.vs/MyGUI/v15/ipch/AutoPCH/MYGUI-f50ecd77/EXIF-614048d0/EXIF.ipch differ diff --git a/imageEnhancer/.vs/MyGUI/v15/ipch/AutoPCH/MYGUI-f50ecd77/IMAGEENHANCER-8bae410a/IMAGEENHANCER.ipch b/imageEnhancer/.vs/MyGUI/v15/ipch/AutoPCH/MYGUI-f50ecd77/IMAGEENHANCER-8bae410a/IMAGEENHANCER.ipch new file mode 100644 index 0000000..7af8938 Binary files /dev/null and b/imageEnhancer/.vs/MyGUI/v15/ipch/AutoPCH/MYGUI-f50ecd77/IMAGEENHANCER-8bae410a/IMAGEENHANCER.ipch differ diff --git a/imageEnhancer/.vs/MyGUI/v15/ipch/AutoPCH/MYGUI-f50ecd77/IMAGEENHANCER-e6f993ef/IMAGEENHANCER.ipch b/imageEnhancer/.vs/MyGUI/v15/ipch/AutoPCH/MYGUI-f50ecd77/IMAGEENHANCER-e6f993ef/IMAGEENHANCER.ipch new file mode 100644 index 0000000..4c4af5a Binary files /dev/null and b/imageEnhancer/.vs/MyGUI/v15/ipch/AutoPCH/MYGUI-f50ecd77/IMAGEENHANCER-e6f993ef/IMAGEENHANCER.ipch differ diff --git a/imageEnhancer/.vs/MyGUI/v15/ipch/AutoPCH/MYGUI-f50ecd77/MYFORM-40f9695d/MYFORM.ipch b/imageEnhancer/.vs/MyGUI/v15/ipch/AutoPCH/MYGUI-f50ecd77/MYFORM-40f9695d/MYFORM.ipch new file mode 100644 index 0000000..86de9a7 Binary files /dev/null and b/imageEnhancer/.vs/MyGUI/v15/ipch/AutoPCH/MYGUI-f50ecd77/MYFORM-40f9695d/MYFORM.ipch differ diff --git a/imageEnhancer/.vs/MyGUI/v15/ipch/AutoPCH/_SFI_F009069B-48E7-40C5-B5B9-B643A2BBADBC_-6a0b1373/SYSTEM-39e88dfb/SYSTEM.ipch b/imageEnhancer/.vs/MyGUI/v15/ipch/AutoPCH/_SFI_F009069B-48E7-40C5-B5B9-B643A2BBADBC_-6a0b1373/SYSTEM-39e88dfb/SYSTEM.ipch new file mode 100644 index 0000000..7f97882 Binary files /dev/null and b/imageEnhancer/.vs/MyGUI/v15/ipch/AutoPCH/_SFI_F009069B-48E7-40C5-B5B9-B643A2BBADBC_-6a0b1373/SYSTEM-39e88dfb/SYSTEM.ipch differ diff --git a/imageEnhancer/.vs/imageEnhancer/v15/.suo b/imageEnhancer/.vs/imageEnhancer/v15/.suo index 7486ffd..feb92ae 100644 Binary files a/imageEnhancer/.vs/imageEnhancer/v15/.suo and b/imageEnhancer/.vs/imageEnhancer/v15/.suo differ diff --git a/imageEnhancer/.vs/imageEnhancer/v15/Browse.VC.db b/imageEnhancer/.vs/imageEnhancer/v15/Browse.VC.db index c9f88b0..d8affc4 100644 Binary files a/imageEnhancer/.vs/imageEnhancer/v15/Browse.VC.db and b/imageEnhancer/.vs/imageEnhancer/v15/Browse.VC.db differ diff --git a/imageEnhancer/MyGUI.sln b/imageEnhancer/MyGUI.sln new file mode 100644 index 0000000..49cad39 --- /dev/null +++ b/imageEnhancer/MyGUI.sln @@ -0,0 +1,30 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 15 +VisualStudioVersion = 15.0.26228.4 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MyGUI", "MyGUI\MyGUI.vcxproj", "{DF1BCE6D-B074-4C0F-9339-2916E4225333}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{E12FC840-D7D8-4E18-A948-3121A632883D}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {DF1BCE6D-B074-4C0F-9339-2916E4225333}.Debug|x64.ActiveCfg = Debug|x64 + {DF1BCE6D-B074-4C0F-9339-2916E4225333}.Debug|x64.Build.0 = Debug|x64 + {DF1BCE6D-B074-4C0F-9339-2916E4225333}.Debug|x86.ActiveCfg = Debug|Win32 + {DF1BCE6D-B074-4C0F-9339-2916E4225333}.Debug|x86.Build.0 = Debug|Win32 + {DF1BCE6D-B074-4C0F-9339-2916E4225333}.Release|x64.ActiveCfg = Release|x64 + {DF1BCE6D-B074-4C0F-9339-2916E4225333}.Release|x64.Build.0 = Release|x64 + {DF1BCE6D-B074-4C0F-9339-2916E4225333}.Release|x86.ActiveCfg = Release|Win32 + {DF1BCE6D-B074-4C0F-9339-2916E4225333}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/imageEnhancer/MyGUI/ImageEnhancer.cpp b/imageEnhancer/MyGUI/ImageEnhancer.cpp new file mode 100644 index 0000000..8a38357 --- /dev/null +++ b/imageEnhancer/MyGUI/ImageEnhancer.cpp @@ -0,0 +1,14 @@ +#include "ImageEnhancer.h" + +using namespace System; +using namespace System::Windows::Forms; + +[STAThreadAttribute] + +int main(array^ args) +{ + Application::EnableVisualStyles(); + Application::SetCompatibleTextRenderingDefault(false); + MyGUI::MyForm form; + Application::Run(%form); +} diff --git a/imageEnhancer/MyGUI/ImageEnhancer.h~Stashed changes b/imageEnhancer/MyGUI/ImageEnhancer.h~Stashed changes new file mode 100644 index 0000000..0f1fb46 --- /dev/null +++ b/imageEnhancer/MyGUI/ImageEnhancer.h~Stashed changes @@ -0,0 +1,726 @@ +#pragma once + +#include +#include +#include +#include +#include "spline.h" +#include "math.h" + +cv::Mat editedImage; +cv::Mat tempAdjusted; +cv::Mat bgrAdjusted; +cv::Mat adjRchan, adjGchan, adjBchan; + + +namespace MyGUI { + + using namespace System; + using namespace System::ComponentModel; + using namespace System::Collections; + using namespace System::Windows::Forms; + using namespace System::Data; + using namespace System::Drawing; + + /// + /// Summary for MyForm + /// + public ref class MyForm : public System::Windows::Forms::Form + { + public: + MyForm(void) + { + InitializeComponent(); + // + //TODO: Add the constructor code here + // + } + + protected: + /// + /// Clean up any resources being used. + /// + ~MyForm() + { + if (components) + { + delete components; + } + } + private: System::Windows::Forms::MenuStrip^ menuStrip1; + protected: + private: System::Windows::Forms::ToolStripMenuItem^ fileToolStripMenuItem; + private: System::Windows::Forms::ToolStripMenuItem^ importToolStripMenuItem; + private: System::Windows::Forms::ToolStripMenuItem^ exitToolStripMenuItem; + private: System::Windows::Forms::PictureBox^ pictureBox1; + private: System::Windows::Forms::TrackBar^ trackBar1; + private: System::Windows::Forms::Label^ label1; + private: System::Windows::Forms::Label^ label2; + private: System::Windows::Forms::Label^ label3; + private: System::Windows::Forms::Label^ label4; + private: System::Windows::Forms::Panel^ tempPanel; + + + private: System::Windows::Forms::Button^ tempApply; + private: System::Windows::Forms::NotifyIcon^ notifyIcon1; + private: System::Windows::Forms::Button^ loadColourAdj; + private: System::Windows::Forms::Button^ loadTempAdj; + private: System::Windows::Forms::Panel^ rgbPanel; + + private: System::Windows::Forms::Label^ label5; + private: System::Windows::Forms::Button^ rgbApply; + private: System::Windows::Forms::TrackBar^ blueTrackBar; + + private: System::Windows::Forms::TrackBar^ greenTrackBar; + private: System::Windows::Forms::TrackBar^ redTrackBar; + private: System::Windows::Forms::Label^ label7; + private: System::Windows::Forms::Label^ label6; + + + + 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) + { + this->components = (gcnew System::ComponentModel::Container()); + System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(MyForm::typeid)); + this->menuStrip1 = (gcnew System::Windows::Forms::MenuStrip()); + this->fileToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); + this->importToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); + this->exitToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); + this->pictureBox1 = (gcnew System::Windows::Forms::PictureBox()); + this->trackBar1 = (gcnew System::Windows::Forms::TrackBar()); + this->label1 = (gcnew System::Windows::Forms::Label()); + this->label2 = (gcnew System::Windows::Forms::Label()); + this->label3 = (gcnew System::Windows::Forms::Label()); + this->label4 = (gcnew System::Windows::Forms::Label()); + this->tempPanel = (gcnew System::Windows::Forms::Panel()); + this->tempApply = (gcnew System::Windows::Forms::Button()); + this->notifyIcon1 = (gcnew System::Windows::Forms::NotifyIcon(this->components)); + this->loadColourAdj = (gcnew System::Windows::Forms::Button()); + this->loadTempAdj = (gcnew System::Windows::Forms::Button()); + this->rgbPanel = (gcnew System::Windows::Forms::Panel()); + this->label7 = (gcnew System::Windows::Forms::Label()); + this->label6 = (gcnew System::Windows::Forms::Label()); + this->label5 = (gcnew System::Windows::Forms::Label()); + this->rgbApply = (gcnew System::Windows::Forms::Button()); + this->blueTrackBar = (gcnew System::Windows::Forms::TrackBar()); + this->greenTrackBar = (gcnew System::Windows::Forms::TrackBar()); + this->redTrackBar = (gcnew System::Windows::Forms::TrackBar()); + this->menuStrip1->SuspendLayout(); + (cli::safe_cast(this->pictureBox1))->BeginInit(); + (cli::safe_cast(this->trackBar1))->BeginInit(); + this->tempPanel->SuspendLayout(); + this->rgbPanel->SuspendLayout(); + (cli::safe_cast(this->blueTrackBar))->BeginInit(); + (cli::safe_cast(this->greenTrackBar))->BeginInit(); + (cli::safe_cast(this->redTrackBar))->BeginInit(); + this->SuspendLayout(); + // + // menuStrip1 + // + this->menuStrip1->BackColor = System::Drawing::Color::SkyBlue; + this->menuStrip1->Items->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(1) { this->fileToolStripMenuItem }); + this->menuStrip1->Location = System::Drawing::Point(0, 0); + this->menuStrip1->Name = L"menuStrip1"; + this->menuStrip1->Size = System::Drawing::Size(1264, 24); + this->menuStrip1->TabIndex = 0; + this->menuStrip1->Text = L"menuStrip1"; + // + // fileToolStripMenuItem + // + this->fileToolStripMenuItem->DropDownItems->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(2) { + this->importToolStripMenuItem, + this->exitToolStripMenuItem + }); + this->fileToolStripMenuItem->Name = L"fileToolStripMenuItem"; + this->fileToolStripMenuItem->Size = System::Drawing::Size(37, 20); + this->fileToolStripMenuItem->Text = L"File"; + // + // importToolStripMenuItem + // + this->importToolStripMenuItem->Name = L"importToolStripMenuItem"; + this->importToolStripMenuItem->Size = System::Drawing::Size(110, 22); + this->importToolStripMenuItem->Text = L"Import"; + this->importToolStripMenuItem->Click += gcnew System::EventHandler(this, &MyForm::importToolStripMenuItem_Click); + // + // exitToolStripMenuItem + // + this->exitToolStripMenuItem->Name = L"exitToolStripMenuItem"; + this->exitToolStripMenuItem->Size = System::Drawing::Size(110, 22); + this->exitToolStripMenuItem->Text = L"Exit"; + // + // pictureBox1 + // + this->pictureBox1->BackColor = System::Drawing::SystemColors::ControlLightLight; + this->pictureBox1->BackgroundImage = (cli::safe_cast(resources->GetObject(L"pictureBox1.BackgroundImage"))); + this->pictureBox1->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Center; + this->pictureBox1->Location = System::Drawing::Point(28, 96); + this->pictureBox1->Name = L"pictureBox1"; + this->pictureBox1->Size = System::Drawing::Size(640, 480); + this->pictureBox1->SizeMode = System::Windows::Forms::PictureBoxSizeMode::StretchImage; + this->pictureBox1->TabIndex = 1; + this->pictureBox1->TabStop = false; + // + // trackBar1 + // + this->trackBar1->Location = System::Drawing::Point(32, 43); + this->trackBar1->Maximum = 5; + this->trackBar1->Minimum = -5; + this->trackBar1->Name = L"trackBar1"; + this->trackBar1->Size = System::Drawing::Size(166, 45); + this->trackBar1->TabIndex = 2; + this->trackBar1->TickFrequency = 0; + this->trackBar1->Scroll += gcnew System::EventHandler(this, &MyForm::tempTrackBar_Scroll); + // + // label1 + // + this->label1->AutoSize = true; + this->label1->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 10, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label1->ForeColor = System::Drawing::SystemColors::ActiveCaptionText; + this->label1->Location = System::Drawing::Point(72, 16); + this->label1->Name = L"label1"; + this->label1->Size = System::Drawing::Size(96, 18); + this->label1->TabIndex = 3; + this->label1->Text = L"Temperature "; + // + // label2 + // + this->label2->AutoSize = true; + this->label2->Font = (gcnew System::Drawing::Font(L"Microsoft Sans Serif", 10, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label2->Location = System::Drawing::Point(95, 12); + this->label2->Name = L"label2"; + this->label2->Size = System::Drawing::Size(55, 17); + this->label2->TabIndex = 4; + this->label2->Text = L"Colour"; + // + // label3 + // + this->label3->AutoSize = true; + this->label3->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 8.25F, System::Drawing::FontStyle::Italic, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label3->ForeColor = System::Drawing::Color::Blue; + this->label3->Location = System::Drawing::Point(3, 43); + this->label3->Name = L"label3"; + this->label3->Size = System::Drawing::Size(31, 16); + this->label3->TabIndex = 5; + this->label3->Text = L"Cold"; + // + // label4 + // + this->label4->AutoSize = true; + this->label4->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 8.25F, System::Drawing::FontStyle::Italic, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label4->ForeColor = System::Drawing::Color::Red; + this->label4->Location = System::Drawing::Point(196, 43); + this->label4->Name = L"label4"; + this->label4->Size = System::Drawing::Size(37, 16); + this->label4->TabIndex = 6; + this->label4->Text = L"Warm"; + // + // tempPanel + // + this->tempPanel->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->tempPanel->BorderStyle = System::Windows::Forms::BorderStyle::FixedSingle; + this->tempPanel->Controls->Add(this->label4); + this->tempPanel->Controls->Add(this->label3); + this->tempPanel->Controls->Add(this->tempApply); + this->tempPanel->Controls->Add(this->label1); + this->tempPanel->Controls->Add(this->trackBar1); + this->tempPanel->Location = System::Drawing::Point(858, 257); + this->tempPanel->Name = L"tempPanel"; + this->tempPanel->Size = System::Drawing::Size(240, 130); + this->tempPanel->TabIndex = 8; + this->tempPanel->Visible = false; + // + // tempApply + // + this->tempApply->Location = System::Drawing::Point(75, 74); + this->tempApply->Name = L"tempApply"; + this->tempApply->Size = System::Drawing::Size(80, 24); + this->tempApply->TabIndex = 0; + this->tempApply->Text = L"Apply"; + this->tempApply->UseVisualStyleBackColor = true; + this->tempApply->Click += gcnew System::EventHandler(this, &MyForm::tempApply_Click); + // + // notifyIcon1 + // + this->notifyIcon1->Text = L"notifyIcon1"; + this->notifyIcon1->Visible = true; + // + // loadColourAdj + // + this->loadColourAdj->BackColor = System::Drawing::Color::DimGray; + this->loadColourAdj->BackgroundImage = (cli::safe_cast(resources->GetObject(L"loadColourAdj.BackgroundImage"))); + this->loadColourAdj->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Stretch; + this->loadColourAdj->Location = System::Drawing::Point(28, 27); + this->loadColourAdj->Name = L"loadColourAdj"; + this->loadColourAdj->Size = System::Drawing::Size(64, 64); + this->loadColourAdj->TabIndex = 9; + this->loadColourAdj->UseVisualStyleBackColor = false; + this->loadColourAdj->Click += gcnew System::EventHandler(this, &MyForm::loadColourAdj_Click); + this->loadColourAdj->MouseHover += gcnew System::EventHandler(this, &MyForm::loadColourAdj_MouseHover); + // + // loadTempAdj + // + this->loadTempAdj->BackColor = System::Drawing::Color::Yellow; + this->loadTempAdj->BackgroundImage = (cli::safe_cast(resources->GetObject(L"loadTempAdj.BackgroundImage"))); + this->loadTempAdj->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Stretch; + this->loadTempAdj->Location = System::Drawing::Point(98, 27); + this->loadTempAdj->Name = L"loadTempAdj"; + this->loadTempAdj->Size = System::Drawing::Size(64, 64); + this->loadTempAdj->TabIndex = 10; + this->loadTempAdj->UseVisualStyleBackColor = false; + this->loadTempAdj->Click += gcnew System::EventHandler(this, &MyForm::loadTempAdj_Click); + this->loadTempAdj->MouseHover += gcnew System::EventHandler(this, &MyForm::loadTempAdj_MouseHover); + // + // rgbPanel + // + this->rgbPanel->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->rgbPanel->Controls->Add(this->label7); + this->rgbPanel->Controls->Add(this->label6); + this->rgbPanel->Controls->Add(this->label5); + this->rgbPanel->Controls->Add(this->rgbApply); + this->rgbPanel->Controls->Add(this->blueTrackBar); + this->rgbPanel->Controls->Add(this->greenTrackBar); + this->rgbPanel->Controls->Add(this->redTrackBar); + this->rgbPanel->Controls->Add(this->label2); + this->rgbPanel->Location = System::Drawing::Point(858, 217); + this->rgbPanel->Name = L"rgbPanel"; + this->rgbPanel->Size = System::Drawing::Size(240, 216); + this->rgbPanel->TabIndex = 11; + this->rgbPanel->Visible = false; + // + // label7 + // + this->label7->AutoSize = true; + this->label7->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 9.75F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label7->ForeColor = System::Drawing::Color::Blue; + this->label7->Location = System::Drawing::Point(207, 116); + this->label7->Name = L"label7"; + this->label7->Size = System::Drawing::Size(16, 18); + this->label7->TabIndex = 19; + this->label7->Text = L"B"; + // + // label6 + // + this->label6->AutoSize = true; + this->label6->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 9.75F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label6->ForeColor = System::Drawing::Color::Green; + this->label6->Location = System::Drawing::Point(207, 77); + this->label6->Name = L"label6"; + this->label6->Size = System::Drawing::Size(17, 18); + this->label6->TabIndex = 18; + this->label6->Text = L"G"; + // + // label5 + // + this->label5->AutoSize = true; + this->label5->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 9.75F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label5->ForeColor = System::Drawing::Color::Red; + this->label5->Location = System::Drawing::Point(207, 40); + this->label5->Name = L"label5"; + this->label5->Size = System::Drawing::Size(16, 18); + this->label5->TabIndex = 17; + this->label5->Text = L"R"; + // + // rgbApply + // + this->rgbApply->Location = System::Drawing::Point(81, 164); + this->rgbApply->Name = L"rgbApply"; + this->rgbApply->Size = System::Drawing::Size(80, 24); + this->rgbApply->TabIndex = 16; + this->rgbApply->Text = L"Apply"; + this->rgbApply->UseVisualStyleBackColor = true; + this->rgbApply->Click += gcnew System::EventHandler(this, &MyForm::rgbApply_Click); + // + // blueTrackBar + // + this->blueTrackBar->Location = System::Drawing::Point(42, 113); + this->blueTrackBar->Maximum = 20; + this->blueTrackBar->Minimum = 1; + this->blueTrackBar->Name = L"blueTrackBar"; + this->blueTrackBar->Size = System::Drawing::Size(166, 45); + this->blueTrackBar->TabIndex = 15; + this->blueTrackBar->TickFrequency = 0; + this->blueTrackBar->Value = 10; + this->blueTrackBar->Scroll += gcnew System::EventHandler(this, &MyForm::blueTrackBar_Scroll); + // + // greenTrackBar + // + this->greenTrackBar->Location = System::Drawing::Point(42, 76); + this->greenTrackBar->Maximum = 20; + this->greenTrackBar->Minimum = 1; + this->greenTrackBar->Name = L"greenTrackBar"; + this->greenTrackBar->Size = System::Drawing::Size(166, 45); + this->greenTrackBar->TabIndex = 14; + this->greenTrackBar->TickFrequency = 0; + this->greenTrackBar->Value = 10; + this->greenTrackBar->Scroll += gcnew System::EventHandler(this, &MyForm::greenTrackBar_Scroll); + // + // redTrackBar + // + this->redTrackBar->Location = System::Drawing::Point(42, 39); + this->redTrackBar->Maximum = 20; + this->redTrackBar->Minimum = 1; + this->redTrackBar->Name = L"redTrackBar"; + this->redTrackBar->Size = System::Drawing::Size(166, 45); + this->redTrackBar->TabIndex = 13; + this->redTrackBar->TickFrequency = 0; + this->redTrackBar->Value = 10; + this->redTrackBar->Scroll += gcnew System::EventHandler(this, &MyForm::redTrackBar_Scroll); + // + // MyForm + // + this->AutoScaleDimensions = System::Drawing::SizeF(6, 13); + this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font; + this->ClientSize = System::Drawing::Size(1264, 681); + this->Controls->Add(this->loadTempAdj); + this->Controls->Add(this->loadColourAdj); + this->Controls->Add(this->pictureBox1); + this->Controls->Add(this->menuStrip1); + this->Controls->Add(this->rgbPanel); + this->Controls->Add(this->tempPanel); + this->MainMenuStrip = this->menuStrip1; + this->Name = L"MyForm"; + this->Text = L"MyForm"; + this->menuStrip1->ResumeLayout(false); + this->menuStrip1->PerformLayout(); + (cli::safe_cast(this->pictureBox1))->EndInit(); + (cli::safe_cast(this->trackBar1))->EndInit(); + this->tempPanel->ResumeLayout(false); + this->tempPanel->PerformLayout(); + this->rgbPanel->ResumeLayout(false); + this->rgbPanel->PerformLayout(); + (cli::safe_cast(this->blueTrackBar))->EndInit(); + (cli::safe_cast(this->greenTrackBar))->EndInit(); + (cli::safe_cast(this->redTrackBar))->EndInit(); + this->ResumeLayout(false); + this->PerformLayout(); + + } +#pragma endregion + private: System::Void importToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) { + + // Displays an OpenFileDialog so the user can select an image file. + OpenFileDialog ^ openFileDialog1 = gcnew OpenFileDialog(); + openFileDialog1->Filter = "All Graphics Types|*.bmp;*.jpg;*.jpeg;*.png;*.tif;*.tiff"; + openFileDialog1->Title = "Select an Image File"; + + // Show the Dialog. + // If the user clicked OK in the dialog and + if (openFileDialog1->ShowDialog() == System::Windows::Forms::DialogResult::OK) + { + // Assign the cursor in the Stream to + // the Form's Cursor property. + // cache.jpg is the copy of the original image used for editing + pictureBox1->Load(openFileDialog1->FileName); + pictureBox1->Image->Save("cache.jpg", System::Drawing::Imaging::ImageFormat::Jpeg); + editedImage = cv::imread("cache.jpg", cv::IMREAD_COLOR); + } + } + + private: System::Void tempTrackBar_Scroll(System::Object^ sender, System::EventArgs^ e) { + // Acquire track bar value + int trackBarValue = trackBar1->Value; + + // Initiate a Mat to save the cache.jpg image + cv::Mat mainImage; + mainImage = editedImage; + colourTempAdjustment(&mainImage, trackBarValue); + tempApply->Enabled = true; + } + + private: System::Void loadColourAdj_MouseHover(System::Object^ sender, System::EventArgs^ e) { + System::Windows::Forms::ToolTip^ ToolTip1 = gcnew System::Windows::Forms::ToolTip; + ToolTip1->SetToolTip(loadColourAdj, "Adjust RGB Palettes"); + } + + private: System::Void loadTempAdj_MouseHover(System::Object^ sender, System::EventArgs^ e) { + System::Windows::Forms::ToolTip^ ToolTip1 = gcnew System::Windows::Forms::ToolTip; + ToolTip1->SetToolTip(loadTempAdj, "Adjust Colour Temperature"); + } + + private: System::Void tempApply_Click(System::Object^ sender, System::EventArgs^ e) { + editedImage = tempAdjusted.clone(); + tempApply->Enabled = false; + } + + private: System::Void loadColourAdj_Click(System::Object^ sender, System::EventArgs^ e) { + // Updating global RGB channels + cv::Mat edited2[3]; + split(editedImage, edited2); + adjRchan = edited2[2]; + adjGchan = edited2[1]; + adjBchan = edited2[0]; + + // Controlling panels + rgbPanel->Visible = true; + tempPanel->Visible = false; + } + + private: System::Void loadTempAdj_Click(System::Object^ sender, System::EventArgs^ e) { + // Controlling panels + rgbPanel->Visible = false; + tempPanel->Visible = true; + } + + private: System::Void rgbApply_Click(System::Object^ sender, System::EventArgs^ e) { + editedImage = bgrAdjusted.clone(); + } + + private: System::Void redTrackBar_Scroll(System::Object^ sender, System::EventArgs^ e) { + cv::Mat edited2[3], redChan, greenChan, blueChan; + split(editedImage, edited2); + redChan = edited2[2]; + greenChan = edited2[1]; + blueChan = edited2[0]; + float fGamma = redTrackBar->Value / 10.0; + unsigned char lut[256]; + + for (int i = 0; i < 256; i++) + { + lut[i] = cv::saturate_cast(pow((float)(i / 255.0), fGamma) * 255.0f); + } + + cv::MatIterator_ it, end; + + for (it = redChan.begin(), end = redChan.end(); it != end; it++) + + *it = lut[(*it)]; + + adjRchan = redChan; + + // Merging the BGR channels + std::vector < cv::Mat > arrayToMerge; + arrayToMerge.push_back(adjBchan); + arrayToMerge.push_back(adjGchan); + arrayToMerge.push_back(adjRchan); + + + // Image with altered red abd blue channels + cv::Mat bgrAdjusted; + merge(arrayToMerge, bgrAdjusted); + refreshPicBox(bgrAdjusted); + } + + private: System::Void greenTrackBar_Scroll(System::Object^ sender, System::EventArgs^ e) { + cv::Mat edited2[3], redChan, greenChan, blueChan; + split(editedImage, edited2); + redChan = edited2[2]; + greenChan = edited2[1]; + blueChan = edited2[0]; + float fGamma = greenTrackBar->Value / 10.0; + unsigned char lut[256]; + + for (int i = 0; i < 256; i++) + { + lut[i] = cv::saturate_cast(pow((float)(i / 255.0), fGamma) * 255.0f); + } + + cv::MatIterator_ it, end; + + + for (it = greenChan.begin(), end = greenChan.end(); it != end; it++) + + *it = lut[(*it)]; + adjGchan = greenChan; + // Merging the BGR channels + std::vector < cv::Mat > arrayToMerge; + arrayToMerge.push_back(adjBchan); + arrayToMerge.push_back(adjGchan); + arrayToMerge.push_back(adjRchan); + + // Image with altered red abd blue channels + cv::Mat bgrAdjusted; + merge(arrayToMerge, bgrAdjusted); + refreshPicBox(bgrAdjusted); + } + + private: System::Void blueTrackBar_Scroll(System::Object^ sender, System::EventArgs^ e) { + cv::Mat edited2[3], redChan, greenChan, blueChan; + split(editedImage, edited2); + redChan = edited2[2]; + greenChan = edited2[1]; + blueChan = edited2[0]; + float fGamma = blueTrackBar->Value / 10.0; + unsigned char lut[256]; + + for (int i = 0; i < 256; i++) + { + lut[i] = cv::saturate_cast(pow((float)(i / 255.0), fGamma) * 255.0f); + } + + cv::MatIterator_ it, end; + + + for (it = blueChan.begin(), end = blueChan.end(); it != end; it++) + + *it = lut[(*it)]; + adjBchan = blueChan; + // Merging the BGR channels + std::vector < cv::Mat > arrayToMerge; + arrayToMerge.push_back(adjBchan); + arrayToMerge.push_back(adjGchan); + arrayToMerge.push_back(adjRchan); + + // Image with altered red abd blue channels + cv::Mat bgrAdjusted; + merge(arrayToMerge, bgrAdjusted); + refreshPicBox(bgrAdjusted); + } + // Functions defined in opencv + // Display image + int displayImage(cv::Mat *mainImage, cv::String imageDes) + { + cv::Mat tempImage; + tempImage = *mainImage; + if (tempImage.empty()) // Check for invalid input + { + return -1; + } + namedWindow(imageDes, cv::WINDOW_AUTOSIZE); // Create a window for display. + imshow(imageDes, tempImage); // Show our image inside it. + cv::waitKey(0); // Wait for a keystroke in the window + return 0; + } + + //Colour temperature adjustment + int colourTempAdjustment(cv::Mat *mainImage, int tempValue) + { + int absTemp = abs(tempValue); + cv::Mat resolvedImage[3]; + cv::Mat blueChannel, greenChannel, redChannel; + split(*mainImage, resolvedImage); // Splitting the BGR channels + + // Create warmer image + // Done by increasing the red channel and decreasing the blue channel + // and increasing saturation of the image in HSV colour space + + // Create a cooler image + // Done by decreasing the red channel and increasing blue channel + // and decreasing the saturation of the image in the HSV colour image + + // Spline interpolation + std::vector X(5), Y(5), Z(5); + X[0] = 0; X[1] = 64; X[2] = 128; X[3] = 192; X[4] = 255; + + Y[0] = 5 * absTemp; Y[1] = 64 + (7 * absTemp); Y[2] = 128 + (8 * absTemp); + Y[3] = 192 + (10 * absTemp); Y[4] = 255; + + Z[0] = 0; Z[1] = 64 - (5 * absTemp); Z[2] = 128 - (7 * absTemp); + Z[3] = 192 - (8 * absTemp); Z[4] = 255 - (10 * absTemp); + + // Creating spline functions + tk::spline incIntensity, decIntensity; + incIntensity.set_points(X, Y); + decIntensity.set_points(X, Z); + + redChannel = resolvedImage[2]; //+ (10 * tempValue); + blueChannel = resolvedImage[0]; //- (10 * tempValue); + greenChannel = resolvedImage[1]; + + int width = redChannel.cols; + int height = redChannel.rows; + int nElements = width*height; + + // Calculating interpolated value for each matrix element + uchar* p1 = redChannel.data; + uchar* p2 = blueChannel.data; + + for (int i = 0; i < nElements; ++i) + { + if (tempValue >= 0) + { + p1[i] = (uchar)(incIntensity(p1[i])); + p2[i] = (uchar)(decIntensity(p2[i])); + } + else + { + p1[i] = (uchar)(decIntensity(p1[i])); + p2[i] = (uchar)(incIntensity(p2[i])); + } + } + + // Merging the BGR channels + std::vector < cv::Mat > arrayToMerge; + arrayToMerge.push_back(blueChannel); + arrayToMerge.push_back(greenChannel); + arrayToMerge.push_back(redChannel); + + // Image with altered red abd blue channels + cv::Mat bgrAdjusted; + merge(arrayToMerge, bgrAdjusted); + + // Convert image to HSV colour space and splitting layers for saturation adjustment + cv::Mat hsvImage; + cv::Mat hsvResolved[3]; + cvtColor(bgrAdjusted, hsvImage, CV_BGR2HSV); + split(hsvImage, hsvResolved); + + // Adjusting saturation + cv::Mat hNew, sNew, vNew; + hNew = hsvResolved[0]; + sNew = hsvResolved[1]; // +(10 * tempValue); + vNew = hsvResolved[2]; + + // Calculate interpolated value for saturation layer + uchar* p3 = sNew.data; + + for (int i = 0; i < nElements; ++i) + { + if (tempValue >= 0) + { + p3[i] = (uchar)(incIntensity(p3[i])); + } + else + { + p3[i] = (uchar)(decIntensity(p3[i])); + } + } + + // Merging the HSV channels + std::vector < cv::Mat > arrayToMergeHSV; + arrayToMergeHSV.push_back(hNew); + arrayToMergeHSV.push_back(sNew); + arrayToMergeHSV.push_back(vNew); + + // Converting the image back to BGR + cv::Mat hsvAdjusted; // Image with altered saturation channel + merge(arrayToMergeHSV, hsvAdjusted); + cvtColor(hsvAdjusted, tempAdjusted, CV_HSV2BGR); + refreshPicBox(tempAdjusted); + return 0; + } + + int refreshPicBox(cv::Mat displayImage) + { + System::Drawing::Graphics^ graphics = pictureBox1->CreateGraphics(); + System::IntPtr ptr(displayImage.ptr()); + System::Drawing::Bitmap^ b = gcnew System::Drawing::Bitmap(displayImage.cols, displayImage.rows, displayImage.step, System::Drawing::Imaging::PixelFormat::Format24bppRgb, ptr); + System::Drawing::RectangleF rect(0, 0, pictureBox1->Width, pictureBox1->Height); + graphics->DrawImage(b, rect); + return 0; + } + + +}; + +} diff --git a/imageEnhancer/MyGUI/ImageEnhancer.resx b/imageEnhancer/MyGUI/ImageEnhancer.resx new file mode 100644 index 0000000..2332a8b --- /dev/null +++ b/imageEnhancer/MyGUI/ImageEnhancer.resx @@ -0,0 +1,723 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAAABGdBTUEAALGPC/xhBQAAHbBJREFUeF7t + nGmUlNWdxvNhPs6ck3NyZr7MTCaT+ZDMh0QS44q7owHUqAQEWZV934VmkV3Z9x0RUMEohkgUZVFABA60 + 7IsssooLLiCCqDExuXOfqnur/vXW7e7q6ltvVb3v8zvnOTmRprvu/z6/fy9U9Q9Icfmnjv9dT+eijopR + cN56ZgSExBctwkghRpwy0oyAkPgCEQJixCVcAIRABCvFL6bUVw+91iSywfnsWXFuMwJC4gtEsFJwARAS + MyCCleIXU+urZq83iWxwPntWnNuMgJD4AhGsFMkF0DSy4QIgJABEsFL8UgvSXIsS1eB89qw4txkBIfEF + IlgpEgtgjZYlouECICQARLBSQJCHtShRDRcAIQEggpWCC4CQmAERrBRXTb1JtVj7UGSD89mz4txmBITE + F4hgpbhqWsQXgD6fPSvObUZASHyBCFYKCNJSixLVcAEQEgAiWCkSC2CdliWi4QIgJABEsFLU04K00qJE + NTifPSvObUZASHyBCFaK5AJoFtlwARASACJYKSBI6/XNIhsuAEICQAQrRb3pEV8A+nz2rDi3GQEh8QUi + WCl+pQVpo0WJanA+e1ac24yAkPgCEawUiQXwhpYlouECICQARLBS/Gr6zartG80jG5zPnhXnNiMgJL5A + BCsFFwAhMQMiWCl+rQV5RIsS1eB89qw4txkBIfEFIlgpfj1DL4A3tSwRDc5nz4pzmxEQEl8ggpUCgjz6 + 5sORDRcAIQEggpUCgrTTokQ1XACEBIAIVoqrsQA2aFkiGpzPnhXnNiMgJL5ABCsFBGmvRYlquAAICQAR + rBRcAITEDIhgpbh65s2qw8YWkQ3OZ8+Kc5sREBJfIIKV4jczb3GKE5XgfPasOLcZASHxBSJYKSBIRy1K + VMMFQEgAiGClSCyATVqWiIYLgJAAEMFKAUE6aVGiGi4AQgJABCvFNYkF0DKywfnsWXFuMwJC4gtEsFJA + kM5vtYxsuAAICQARrBTXzIr4AtDns2fFuc0ICIkvEMFKAUG6aFGiGi4AQgJABCvFtVgAm7UsEQ3OZ8+K + c5sREBJfIIKV4tpZt6qum1tFNjifPSvObUZASHyBCFYKLgBCYgZEsFJAkG5alKiGC4CQABDBSnHdbL0A + 3tayRDQ4nz0rzm1GQEh8gQhWCgjSXYsS1XABEBIAIlgpkgugdWTDBUBIAIhgpYAgPba0jmy4AAgJABGs + FNdHfAHgfPasOLcZASHxBSJYKa6ffZvquaVNZIPz2bPi3GYEhMQXiGClgCC9tj4S2XABEBIAIlgpbphz + uxbl0cgG57NnxbnNCAiJLxDBSnHDnDtU763tIhucz54V5zYjICS+QAQrBQTps7V9ZMMFQEgAiGCluHHO + narPtg6RDc5nz4pzmxEQEl8ggpUCgvTd1imy4QIgJABEsFLcOOf/VL9tnSMbnM+eFec2IyAkvkAEK0X9 + OXdpUbpENjifPSvObUZASHyBCFaK+nPvUv23d41scD57VpzbjICQ+AIRrBT1596tBmzvFtngfPasOLcZ + ASHxBSJYKW5KLIAekQ3OZ8+Kc5sREBJfIIKV4qa5v1WPbe8Z2eB89qw4txkBIfEFIlgpbprbQA3c0Suy + wfnsWXFuMwJC4gtEsFLcnFgAvSMbnM+eFec2IyAkvkAEK8XNcxuqQTv6RDY4nz0rzm1GQEh8gQhWilu0 + IBU7+kU2OJ89K85tRkBIfIEIVopb5jVSFZX9Ixucz54V5zYjICS+QAQrBQQZXDkgsuECIEVFl66ezqYS + y2mdhBS3zrtHDal8LLLB+exZzbld8yhm6pmqkChiLlmWsKRy67x71dDKgZENzuc6dwllk6kKiSL6gpcE + Lryk0npVOzX0nYrIBudznbuEssRUhUQRfcE/1NkrLlzVm3SHarOqfdHT8fUuatg7gyMfnNN1/rCDe5c9 + 0EEvfmiqQqIKLtlcdury71/WXD3+zhAmJsF9y/vXofxxApetk/rhG9JsRVtdjqFMxNN2VQcpPoIeUP64 + oS8d/yJw0ZRA/XP3n6nOa7qr4TuHMREN7hf3bO/c3D9/8h9XcPmmBGIJ9FAjdj7ORCy4V8pPskAJTBlS + S6DLmp66NCOYiAT3SflJlegy3CbKoX7U7xeqYusQNXLnSKbMg3vEfcr71XnAXD0hSXQpHpEl+feKq9Xg + bUPVqF2jmDIN7g/3KO9V5xFz5YRkgnLIsiSXwDBdptFMmQX3RvlJrUFJZGlQotG7xjBlFspP8kaXJeMp + w1dPuluN2fUEUybBfcn70+FTfEntQGlkia6e/Fs1ZveTTIkH9yTvTYfyk/xAeWSZUK6xu8cxJRrKT7yj + S5TxEuJ7l7RUT+wez5RYcC/ynnT40l5Sd3SRsl481GR5O126CUyJBPch70eHL+4h/kCZTKlSJWv6fHv1 + 5J5JTJGDe5D3okP5iX9QKlOuVNlQvnF7JjNFSpuV3aT4COUnhUOX6yc66dcN9Pi56r2+Qo3fM4UJOZg7 + 5m/vwtwLn99PCgtKZsomlsBgXcqpTEjBvCk/KRoomyldagn0WT9UTdg7jSlwMGfKT4oOSidKmCjlqB0T + 1cS9M5gCBfMNyI/cZq6EkHDR5ct43cB/DL5WjU4sgZmM52CumK+ctw6f30+KC0ooS/mfuqRjKiepSXtn + MZ6CeWKucs46lJ+UBiijLGdyCUxRk/fNZuoYzJHyk5JHl3KaLOm1U+7TBZ7D1DGYo5yrzjQzckJKC13O + jBcPXafLO2XfXCbPYH5ynjp8cQ8pbVBSWVqUeOr++UwtQ/lJ2aLL+rIs722zm+pSL2ByTMOnWkvxkZfN + aAkpfXRhs1430PKFHmra/oVMDcGc5Nx0+Px+Un6gtKa8qTK3fKGns/RMMpiPnJcO5SflC8prSpwqdfIr + gQVMIPzMTyIJSqyTet0A8tiGMWr6gQWMCebxLz3+V8qPef3EjJCQ8kaXOePFQyj7wA2jdfnnxz6Yg0N+ + vriHRAuU2pTbLIGfx34JJOXnK/tITEC5TclTS2D41glOOaIenDsgP0L5SbTRJQ+8buA6NW7ndC3FvNgE + 58W55Rx0+Px+Eg9Qdln+H2sZxmspZmg5oh6cE+eV59eh/CReoPRSgsQS2DVNzTg4N7LB+Sg/IQZd/pFS + hqvG3e0UJyrB+eR5dUaaURAST7QEGS8eun7qfU55yj04lzynDl/cQwiADFKO5BKYE5lQfkJqAFJISSDN + TC1Puef2OU2k+AjlJ8SFliPjdQOtVnRVMw/NLtvg8cvz6PD5/YRUBeQwkqSkKdclQPkJyQNIYmRJyZNc + ArPKJpSfkDoAWXROG3kS6bV2kFO2UsugjcOl+Aie+kz5CakNWpqs1w1UaLlmaclKNXh8fHEPIZ6APEai + 9BLY9Lia9e7MkgseF+UnxDOQyMhUskuA8pM60fqRR+vpjGTcub7d3ZuEXOrHQ65VE/dM1PLNKHrwOPB4 + 5OO7ut2de13nYFLhcpTogVzUUUzVqd+uYYZkpbAEXPLjcboeP5ORi6b6BDgGxDjiWgKTtISztYxhBx+X + 8ucfU30C5GD+9PIqppr0e3pkhnSQcPa700PPz0bdnPE48Lhcj5dJR/bcVJ8AORhSM48uHpAh3w3T7lGz + D2sxQwo+nvz4eDykZmTPTfUJkIMhuZG9BBppOacVPPg48uNS/tyRPTfVJ0AOhuRO2EuA8tcN2XNTfQLk + YEjtuGNS8wwpmy5ro+Ycnuo9bV7qmPFxfj26kXkEJFdkz031CZCDIbXj4teXEjJKOSGrS+J845IfH5fU + DtlzU30C5GBI7XEugT/qJXBEC1zH4P3I90v580f23FSfADkYkh+uJdD51e5a4il5p+/6fhnv76cVN1P+ + OiB7bqpPgBwMyZ99Zw+rH/W+KiUsnp8/ZPNgp9w1BX9PPr8f7xfvn+SP7LmpPgFyMKRuuJdAhZp7ZHLO + wdtTfv/InpvqEyAHQ+pOXZYA5S8csuem+gTIwRA/bDq2IyUx8q/9f6mm7H9CzT06qcrgz/F28u+t2rvO + vEdSV2TPTfUJkIMh/li67aUMmf9ryDVa8rFVyD828efy7fH3iT9kz031CZCDIX7JZQlQ/nCQPTfVJ0AO + hvjHvQTGqHlHJyZC+cNB9txUnwA5GFIY+r4wOkPy+tMbJOTH/8r/zuf3Fw7Zc1N9AuRgSOEIvnjo3wI/ + 8KP8hUX23FSfADkYH5z74lt19KPLjCMNp/bIkN4G/9319szlRJ98IHtuqk+AHIwPVr3zEVNNbhjbJkP+ + Xw5v7Hw7Jh0fyJ6b6hMgB+MD1wUy6Szfckz9T8XdCfnxv/j/rrdj0vGB7LmpPgFyMD6QF7f2wGeOfJ7I + OuRg9VlfXQ4l80aOeTOYd2XOJ7Ihh2y0OVx9NtWQFe8cUm8dOV9NLiSy2ZWj2Xk7h2xBjlWfrdXmC7X1 + vS/UthyzPZjj2dlRRWSPfCB7bqpPgByMD+TFvfXeRZMvU9mMHE/n7WBOfKm2OLLV5uSlRLY5sh05lZkd + gVSelrmcyDs2Z9LZGcgu5P3M7E7lq0T2nM3O3mA++ErtC2S/zYfIlUQOOHLwo8wcCubjK+rdVL5O5TBy + Lp0jjhz9JDvHUvlGHfv0G/WeI8dtPkvnRCAnP5f5NpFTMueTOS0ie+QD2XNTfQLkYHwgLy4u4rvkp/j5 + iY+c0ZE98oHsuak+AXIwPpAXR/Hd4qfkp/hZ4tvIHvlA9txUnwA5GB/Ii5PiZ8kvZC858ZESEj9L/gzx + 0/KXvPiIkb0q8c9cSEb2yAey56b6BMjB+EBeXF3Ed8lP8XMT3yV/uYj/vonskQ9kz031CZCD8YG8uDDF + z5Sf4tdGfJf8KfERLXlY4r9/4S+JyB75QPbcVJ8AORgfyIsruvhC/qD4Kfkpfq3Fz5Tfr/jIWS6A8JCD + 8YG8uPITPy1/UPws+QPCU/yqxc+QP0v8tPwQ/+wXycge+UD23FSfADkYH8iLy0t8RMtd7uK75C+q+FV8 + n19q4nMBhIwcjA/kxVH83MXPlD++4n9gInvkA9lzU30C5GB8IC8uKD/F9ye+S/60+EZ+I3s5iZ/IRS6A + 0JCD8YG8uKrET8mv5ab44YifIb8WvFTF/9BE9sgHsuem+gTIwfhAXpwv8TPk13LnKn6m/CUgPlKV+AH5 + iy1+lvxC9kKKzwUQMnIwPpAXV27iu+Sn+LmJnyl//uIjH+nIHvlA9txUnwA5GB/Ii4uG+Gn5g+K75Kf4 + uYnvkh/i28ge+UD23FSfADkYH8iLo/iZ4qfk13JTfLf4H335XSKyRz6QPTfVJ0AOxgfy4kpSfCQgfamK + nyl/iYsfkD9f8T82kT3ygey5qT4BcjA+kBdXtfhp+UtCfCQC4rvkL6r4iJE9V/G5AEJGDsYH8uJqI75L + forvQ/y0/EHxXfIXW3zknI7skQ9kz031CZCD8YG8uEKK75Kf4nsQH6lC/JT8WvBCiX/uUjKyRz6QPTfV + J0AOxgfy4kpJ/JT8FD808TPk13LnIj7yCRdAeMjB+EBeXK3ER0pI/Cz5M8RPy1/y4iNG9lIX38rPBRAi + cjA+kBcXJ/Fd8lP82ovPBRAycjA+kBdXDuIPnvycuqVxT/XShn2hiu+SPyU+oiWPo/ifXk5G9sgHsuem + +gTIwfhAXlxQ/JT8JSB+5fHPVave49VvGnRIZd6KDSUrfqb8uYufIX8ZiJ/MXzN65APZc1N9AuRgfCAv + Ljfx0/IHxc+SPyB8PuIjq3ccUw1aDcyQ32bIlOf8i1/Fl/vFEz8tf1D8LPmF7GGIj3zGBRAecjA+kBcX + tvgu+aX4CD7LB6UPptPgGWrXifMU35Gg+C756yJ+Il9xAYSGHIwP5MWVkvhI7zELncK70rjTCLX54AcU + 38SX+JnyZ4tvI3vkA9lzU30C5GB8IC+uVMTfdOCsatxxhFP06oIfDq6tfK9a+dPiG/mN7BS/FuIL+T83 + kT3ygey5qT4BcjA+kBdXbPHx03z8dB8iS7FrE/zdBS9tzEv8DPm14BS/ZvG5AEJGDsYH8uKKKT4yZelq + p9T55Mn5fyy4+FnyC9lLTnxEy+1bfOS8juyRD2TPTfUJkIPxgby4XMR3yV9X8d85/nniB3lSYB/pN3ah + 2nvqfMmInyl/NMQ/fyUZ2SMfyJ6b6hMgB+MDeXH5i5+WPyi+S34rPvLajmN5fb+fa37faYTae/pCWYrv + kj8lPqLlLrb4yAUugPCQg/GBvLgwxUeeWb29Tt/v55qGrQaq9TuPR178lPxa7rDEt5E98oHsuak+AXIw + PpAXF5S/UOLj2Xt4Ak9Q1EIGi+b51yuLK35A/mKLnyG/ljsf8S9c+Vsiskc+kD031SdADsYH8uKqFR/x + IP7OE9lP6Q0zi1ZuKi3xESN7qYufKX9S/C++Tkb2yAey56b6BMjB+EBeXCHFx9N1X6+s+im9Yab/2IUB + 8dPyB8V3yU/x0+JzAYSMHIwP5MUVSnxk/oqNThmLlTZ9x6uD71/IT3ykCvFT8mvB4yA+clFH9sgHsuem + +gTIwfhAXlxKfo/i4wU6fcc+pa5p2LHk0qTLKLVh94miip8hv5a73MS3kT3ygey5qT4BcjA+kBdXW/Gz + 5M8Q/4p66+AHWrLR6rp7Opdsbm/aR23co5eAkb3UxXfJnxY/LX9Y4ifyDRdAaMjB+EBenC/x8Vl/5aaD + 6o6H+qnr7+tWFlm6anMkxXfJ71P8L01kj3wge26qT4AcjA/kxfkQH5nx3Fp14/09yi6jZ70Qe/Fd8lcn + PhdAyMjB+EBeXF3F33Xyguo+Yr6q/2Cvsk2vUfPV4Q8uUnwru4xDfOSSjuyRD2TPTfUJkIPxgby4fMXH + b+FZt/OEerjXBHVz4z5ln5a9J6gjiSXgFj9LfiG7T/G3HTipHuoyUg0at0idOvdlfuIjBRT/0rfJyB75 + QPbcVJ8AORgfyIvLR3z8Ao7n1+1WDVoPUbc06ReZNGgzRL29/7QX8V3y1/QZf9mfN6tbf59+mjQWwfYD + p0pO/Evffq8u68ge+UD23FSfADkYH8iLc4mfKX/2790bNeeP6raHBkQyjdoOU8tXbw9V/JP6Mz0+41vx + ZbAQlr+yuaTEt5E98oHsuak+AXIwPpAXVxvxd5+6oDoNnatubz4w8pn57JqCi49sN1/yS+ldqRi/SJ35 + 5FK2/EUQnwsgZORgfCAvLhfxkfW7T6mm3cerO1tUxCYjZrxQMPGRZfozu/ySv6ZgUVQePFWN+Gn5g+Jn + yR8Qvjbif/WXZGSPfCB7bqpPgByMD+TFOcUPyL/klR3qrpZDYpl2g2aq9z7+MnfxES13deLjh3sVVXzJ + X1OwMJ5/dXPBxXfJb8XnAggZORgfyIurTnz8gs1hM15Ud7ceFuu06D1Z7Tj0fp3Fx0/0c/2Sv6YM1t8S + nP30UlHER67oyB75QPbcVJ8AORgfyIurSvythz9W7SrmqAZtRzA6D3Z5Uq1++2De4iOr3txZqy/5a0oz + vUh2Hjoduvg2skc+kD031SdADsYH8uKC4iOvbjuqGncdrxo+OooJ5KX1u9Lya7lzER//hj9m5nKnxHXN + bXqhLHpxbZ7iJ+WvrfhXvktG9sgHsuem+gTIwfhAXpwUH1mwcou6p/0Yppo8Mf/lnMU/ePKcly/5a0qv + 4bPUB59dLqz4iBb/axPZIx/InpvqEyAH4wN5cVb8Pae/UIOmvKDu7fAEk0P6j3tWnfrkcpXiI76/5K8p + 97QZpHYfPl1w8ZP5e0aPfCB7bqpPgByMD+TFQf4Ne99XnYcvUr/rNI6pRbqNXKR2HvkwS3ykUF/y55Kn + 9bcEuYjvkj8X8b8xkT3ygey5qT4BcjA+kBe3bM1u1bzPdHV/lwlMHnlYz27X0Y9S4of1JX9N6a2/Jfjo + /GWv4qfk/2syskc+kD031SdADsYH9tIWrzmkHuw2ifGQVRv3h/4lf025V39LsPfwGe/iI99yAYSHHIwP + 7KUteGWvatxjCuMhtzcr/i8+rSqLV6zzKr4NF0BIyMH4IL0A9qkmPacxdUjj7lPUTQ/2dopXSuk9YpY6 + d+GrHMRPyl+d+FwAISMH44PUAnh1n2raewaTZ+7r+KS6tlFnp3ClGHxLsO/ImTqL/5e/JcMFEBJyMD6w + l7bw1f2qWd/ZJZvfdR6vmvaa4fyzYueuVsOckpVDlr60rk7icwGEjByMD+QCeLj/3JIMnnV3baNO6vr7 + uqoHukx0vk0x8lCfWerWJv0Sj62c03fUHPXpF1fyEh/5TocLICTkYHyQWgCrD6gWj80vqTTvN0d/dh2a + 9Rt8f9t2uPPtwwy+37/xgZ5Zj61c80D7Yerge2erlL8q8W24AEJCDsYH9tKeWn1QtRq4sGQC+fHT9PoP + 9HIGf9a090zn3y107mk/1vmYopBlL2+slfjfff+PRLgAQkIOxgepBfDaQdW6YlFJBGLjV3K5flefDN7m + fv0tget9FCItBy5IvCTY9ViilIrxT6vzX17JSfy/mnABhIQcjA/spS167ZBqO2Rx0fNg98n6s/tjtUqj + dqO1oE8535+v4Hv+Ox6ucH78KKZZ9yfV4ZMfZotv5LficwGEjByMD1IL4PVD6pFhS4uWNoMXq991Hqfu + bDE4r+BnBZDU9b7rGvwbv+tjxiEvrt5Srfg2XAAhIQfjg/QCeFe1G/5cUdJGf4bF99V3t368zsEP51wf + I59A/vs7T3B+nDhl+LTl6uLlb5zi/w35OxdAaMjB+MBe2tNr3lXtRywLPfjSvVG7MVm/bKMuwavzsFRc + Hy/X4O/jpb6u9x/HtB0wXR07fS5LfBsugJCQg/FBegEcVh1H/SHUtBgwT93TYWxBgmfm4f27Pm5NKeTj + Kvf8aV1lhvjfm3ABhIQcjA/spS1ee1h1GvNiaMEz6PDsvkLnoT4zE1K7HkMweDu8vev9MOmMnbtSXbry + bUp+LoAQkYPxQXoBHFFdnnip4IFoeO78g90mh5bG3acmvqd3PR6bDiOXqyY9pzv/PpOdTsMWqhNnP1Xf + /+Mf6u86XAAhIQfjA7kAuo5bWdB0HP2HhPzBV9GFFfxbvutx2Z/0M7XPqxv36AWQ7hEXQIGRg/GBvbQl + 646q7uNfLljwgzU8d77YwdN4O49dkXhM3bT8bQY/7Xw7JvdMfHq1WrH1DBdAGMjB+EAugJ4T/1yQPDLs + GfXwgHklEywBLCR8ReD6c6b2wWtJuABCQA7GB/bSlq4/pnpNftVrek56RbUdukS1GvQUE/HgtSRcACEg + B+MDuQD6TH3NW3rgM7+W3/W0WiZ6WfQaF0AoyMH4ILUA3nhP9Z2+1ku6T3hZPfr4s0yMgqeScwGEgByM + D+ylPaMXQP8Z6+oc/GCtw8jnmZgFzyTlAggBORgfpBbAm8fVgFlv5p3+M9errk+uVJ3HvMjEMHgiGRdA + CMjB+EAugIFzNuaV/jPf0J/5/+T8N3YmHsHzSLgAQkAOxgf20p5984QaNO+tWgef+fEDPybewT8jcwGE + gByMD1ILYMMJNXjB27UKPvP3nvIawyT+FYkLIATkYHxgL+25DSfVkIVbc8uCLfr7/jdUv+lrGSYR/CsS + F0AIyMH4ILUANp5SwxZtrzFYAI/N3pD1Q0Am3sHPkLgAQkAOxgdyATy+uLLaDH1qW/J7/7kMkxn8DIkL + IATkYHxgL23ZptNqxNKdVWbYoh3Z3wowjAm+heQCCAE5GB/IBTDq2T1ZGfnMboXP/sOe3sEwVQZfQXIB + hIAcjA9SC+CtM2r0c3szMurZvWrk0l36KwCGqT74BMIFEAJyMD6wl7ZcL4Cxyw+kMmbZfr0E9jFMTkF/ + uABCQA7GB/bSVu74UF/i+yJnGCbnoD9cACEgB+MDe2kM4ys+kD031SdADsYHlccvOC+RYfLJ1iPnTbPq + huy5qT4BcjCERBXZc1N9AuRgCIkqsuem+gTIwRASVWTPTfUJkIMhJKrInpvqEyAHQ0hUkT031SdADoaQ + qCJ7bqpPgBwMIVFF9txUnwA5GEKiiuy5qT4BcjCERBXZc1N9AuRgCIkqsuem+gTIwRASVWTPTfUJkIMh + JKrInpvqEyAHQ0hUkT031SdADoaQqCJ7bqpPgBwMIVFF9txUnwA5GEKiiuy5qT4BcjCERBXZc1N9AuRg + GCYOMdUnwDUgholyTPUJ0ANZEhwQw0Q4S0z1i8wPfvD/4/NKrjKwX20AAAAASUVORK5CYII= + + + + 132, 17 + + + + iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAAABGdBTUEAALGPC/xhBQAASiFJREFUeF7t + nQeY3NS5/uP1zvbibV5vs73e4vW67a67ve42YIyNDQZjDKYEsDFgCL0FggtgSgBfIEBCC6GFFJJLCjUJ + NwESEkICN9yQ3ARyU7n3Qsg/DS7J+X+v9jtjSXMkHWk0O5pdfc/ze+zZ0fvpHOl7z2hG0tGH4ogjjjgC + x4oVS0YQeSZG8FuBIs4X5/MTcb708qUVtPKRdvitQBHni/P5iThf2vmCDR4QEvlEwgReB0oIHevjfAEC + OtbH+QIEdKwfTvkwgOTxn/SDxWhAgQm8Tqcxcb44n1ZAx/o4X4CAjsDg4X8AYHEhUWQCr9NpTJwvzqcV + 0LE+zhcgoCMweAB/AwCL0YBiE3idTmPifHE+rYCO9XG+AAEdgcFDHkFgANDLRQvi18YSotQEXvv/DkEB + HevjfAECOtbH+QIEdKwfTvkweIDkAMBvuwctCDEaUGYCr9NpTJwvzqcV0LE+zhcgoCMweMgjCAwA+fy2 + e9CCsjEVJtCgdBoDfZwvQEDH+jhfgICO9cMpH/wL5ACg9wMiFiIwcsgGVfK/6TRG5pHE+TQDOtbH+QIE + dKwfTvngXSAHAL0fELEQgdECQvOIFG98jYCO9XG+AAEd6+N8AQI61gM5AMDP2ubHSIERQw4AIN74GgEd + 6+N8AQI61sf5AgR0rJd54F0cyWubH98RMFrIAQDEG18joGN9nC9AQMf6OF+AgI715lz6/qUFcYUQfiWU + A0C6px4y2bk4n4+AjvVxvgABHetzKZ/+kTstiAsD8OkvBwAQb3yNgI71cb4AAR3r43wBAjrWB8tHC+LQ + 3zwApHO5Ybzx43zaAR3r43wBAjrWB8+HhQk5AOidJ1QE54lW50wBHevjfAECOtbH+QIEdKyPVj4ICAwA + 6dxiGG/8OJ92QMf6OF+AgI716eeDiNC/OcAWrI9m5yigY32cL0BAx/o4X4CAjvWRzIeEgYyPwEp55aE0 + BjrWx/kCBHSsj/MFCOhYPyzypRVYKa88lMZAx/o4X4CAjvVxvgABHeuHRb60AivllYfSGOhYH+cLENCx + Ps4XIKBj/bDIhyBtsCN/rJRXHkpjoGN9nC9AQMf6OF+AgI71wyWfPO3vXw8REeXOxfnifNoBHeuHSz6Y + P/CcgPHGj/NpB3Ssj/MFCOhYH1Y+ea8P8DcAYGEiyp2L88X5tAM61g+XfDB/WnMCRrlzcb44n3ZAx/rh + lE/e35McAPht96AFIcZdRWE2JuobK84X59MK6Fgf5XyhzAkY1c7F+eJ8WgEd64dTPjmnhxwA9O71wUJE + PCdgnE8roGN9nC9AQMf6MPPBu0AOAPGcgKqAjvVxvgABHevjfAECOgJ65JGEkQ/IAQB+1jZ/PCdgnE8r + oGN9nC9AQMf6TOTDv/BuPCegKqBjfZwvQEDH+jhfgICO9ZnKh//r+5cWjOcEjPNpBXSsj/MFCOhYn8l8 + +kfutCAuDMCnvxwAQLzxNQI61sf5AgR0rI/zBQjoWB8sHy2IQ3/zABDPCagZ0LE+zhcgoGN9nC9AQMf6 + 4PmwMCEHAL3zhIrgPNHqnCmgY32cL0BAx/o4X4CAjvXRygcBgQEgnhNQM6BjfZwvQEDH+jhfgICO9enn + g4jQvznAFqyPZucooGN9nC9AQMf6OF+AgI71kcyHhIGMj8BKeeWhNAY61sf5AsT06VNG1tbWTC8rK91Y + XFx0fmFh4S2JROLRESNGPEtvv0r8lvgj8TfiHwz+j7/hvVeIbxKPENeT7ozS0pIjRo+um7ZkSf+odNsH + HetD6S90rI/zDXZgpbzyUBoDHevjfPrRTGwk9pFZn8/Pz/8zIfYzUtDfBb3vG+igN+X7f4lE/gv095vo + /SOIRkI70C/uXzr9TQZ0rI/zDXZgpbzyUBoDHevjfO5RRKwi9hE/I5zMarwO0fxO+f6DuIE4gCgglIF+ + cf/89lcZ0LE+zhcwSBvsyB8r5ZWH0hjoWB/nU0eCWEt8hvgTYTFhFs1vB18j7iUOJpK3nKJf3D/d/roG + dKyP8wUI0snT/v71EBFR7txQytdJXEu8RagMFyXz2/kdcRXpO7h/Ov31DOhYH+cLEKSD+eM5AXUCOtYP + dr6VxNcJlbGSRNj8BpzvnwUFia9XVJQf4tJfrYCO9V7bTyugY/1wySfv9QH+BgAsTES5c7meD9/HDide + JpSGMpMj5rfly/9hXl7eofS+78B24u3ltP18BXSsHy75YP54TkCdgI71g5VvNfFDQmkmO7lpfku+7xIr + CK3AduLt5bT9fAV0rB9O+eT9PckBgN92D1oQYtxVFGZjor6xBivfZOIJwmIgN3TMmqD/t5UWigPqKsSp + 42rFdd1N4pGZreLxue3iOws6xcuLJ4mfLZssfnfAVPGblVPFK8umiBcWd4un+rvEl+d1ivtntolrSLON + tCvqykVrSYHIN+V3Q6d9Jh4j8DuHY2A78fZSbT/fAR3rh1O+eE5AnYCO9RnNV1paWk5vf5z4gFAZQ4mT + uSoS+YbZr5jYIJ6a1yF+T8b+nwOnefLfxH8dOF38ygRe4+/2ZTFYYAC5vLNBrKgtF2X5edrtczC/5H3i + KgKnNy1B2yqul/TzyTk95ACgd68PFiLiOQFDzkffgQ+it39JqMzgiN1cEytKxHlkxqfJ8G8dkGpYL/yY + X8UfaEB4kgaE89rqjSOEgOY38zqxhDCCtlVcL+nng3eBHADiOQFVAR3rM5avu3viaDLDbfS2qvhdkeZq + LisW2yaMEV+bP9GXWe2ka3470D1GXx1Obq0XDaVFQcwv+Sfx8VGjKlGsObV/+XXU8gE5AMDP2uaP5wQM + MR8V9Hwyw2v0tqroXYGJ5tZUiLv6Jog3DgjHrGGb35zvl3Q0ckdvq+irLFH2x4uBwS7/lZqa6tmmbRjp + /cuvo5gP/8K78ZyAqoCO9RnLV1xcvJWK+q/0trLgnaC9JQ4aXSG+OLcjY2bNdL4vzZoglteWK/unYsD8 + ya8Rfy4tLdnC2zOuP42AjvXmXPr+pQXjOQFDyjdv3uzqgoKC21HU9LYv8IPetxd0DqpZ/eIn37fmd4ol + NWXKvkps5meMrxHX0Pu+94l9fzCRrRcm7Hz6R+60IC4MwKe/HADAcNpYoeWbOLGjKZFIPOHX/O2lheKh + Ga1ZNasOQfN9une8GFdckNJvF/PLZb5AFBNaYd8fTGTrhclePloQh/7mASCeE1AzoGO9kaupqbGTCvjH + fsxfTsW+c2KDcaotKmZ1It18v105VVzSMUaUjBw4jahhfgkuHqolXMO+P5jI1guT3XxYmJADgN55QkVw + nmh1zhTQsT4j+caMqZ9CBfyffsw/t6pU/HBRl2GOqJnVTpj5XlzYJXorS3TNL/l3wnEOAvv+YCJbL0z2 + 80FAYACI5wTUDOhYb+QaPbq2hwr4v3TNjyvrLmyvN86nwxBRNivIRD6cMdjR3iAKElrml/ycGEdYwr4/ + mMjWCxONfBAR+jcH2IL10ewcBXSsz0g+/uTXNj++B399TrvFDFE3aybzfW5Oh2gpLdIxvwSDQANhhH1/ + MJGtFyYy+ZAwkPERWCmvPJTGQMf6nMjX1NQwkcyvfdg/jw75cR2+kxnCNleu5HttabeY4e/aAXwdqLXv + Dyay9cJEJl9agZXyykNpDHSsz4l8nZ3tzWT+V3TNv6FhlPEjmJcZom7WTOX79YopYk19pXLbqaDt/gKu + sJT7g4lsvTCRyZdWYKW88lAaAx3rcyLfnDkzahKJxJO65j+nbbQvM/hlqOTD69PG1ym3oRlsd/xmUFBQ + 8OWFC+dV8X6JbL0wkcmHIG2wI3+slFceSmOgY33O5KPCu0PX/Lgd117k2TCXLlHIt7urUbktgTT/wA+H + +aKwsPAG3j/Dpv74ddB88rS/fz1ERJQ7l/F8xcVF23TNfyUVstkgQ9GsbqST77LOhpTtaTf/ACNFXl7e + Bnrfd6j2L78eqvUM88dzAuoEdKxP5hs1qnIBFSEepJFSnHZw77y5oKNkLhVRzIfbjeX2dDI/D8aYLbmL + 0A7V/uXXQ7We5b0+wN8AgIWJKHcu4/m6ujrrqdgwD36yKJ04v73eUshRNJeZKOc7vbXOy/wSTKvm+GwC + c6j2L78eqvUM88dzAuoEdKy35KNiu53eNheckmObqy0FHGVzgVzIt76pxsv8kusI16B9ORzrWd7fkxwA + +G33oAUhxl1FYTYm6hsrJR99x8TDLlQFZ2HmqJL4VF8G8v10xVQxdVSpl/kBJhVZRCiD9mVO1h+RTr54 + TkCdgI71lnwlJSUV9PYbhKrgkowuzBevLpmUUrxhm2G45ntu0SRRVzQw/Zhq+5vA17RCwhK0L3Oy/oh0 + 8sk5PeQAoHevDxYi4jkBB/LdSKgKLQlm4v3KnDbH4g3bDMM13+dmThAjvQcAsJtIBvYj70/V/vUd0LE+ + yvngXSAHgHhOQFVAx3pVvqmE5+y9OGXlVbxRN1eu5MNFVap9YOM9oo3I9frzHdCxHsgBAH7WNn88J+D+ + fE8RqgJLgttah/NdfYOdD7+xTCorUu4LG49iP/L+dNq/vgI61udCPvwL78ZzAqoCOtY75VtDqAorSUHe + CPFvCzq1i9cPcT7nfJiS3OurAH4rKCsrW+2yf30FdKzPlXz4v75/acF4TsD9+TBi/ohQFpcE9/T7LV4d + 4nze+c5odb5nAObH2YJEIvFdh/3rK6BjvVO9+AroWJ/JfPpH7rQgLgzAp78cAMBw2lj2fEcQyuKSTKTD + UDyFJwpmcGOo5sNjzXTmGKSjgA2K/asd0LHerV60AzrWRyMfLYhDf/MAEM8J+KEP/ZhIKS4z9/WOj4wZ + nBjq+W6bNtayT+zmB4lE/ouK/asV0HF9eNWLVkDH+ujkw8KEHAD0zhMqgvNEq3OmgI71XvkOJCyFZWfW + qJLImcHOcMiHZSeXD/wgqDK/6aKhfsJXoC64PrzqRSugY3208kFAYACI5wQcCM8n9n55dlvkzGBmOOV7 + qK/Vy/zgUUI7UBdcHzr14hnQsT56+SAi9G8OsAXro9k5CuhYr5MPd5RZzG4HT8eNqhnAcMw3v7bCzfzg + H8R4wjNQF1wfOvXiGdCxPpL5kDCQ8RFYKa88lMZAx/ps5bueMBeOBRRVLj+uyy+5ku/+WW1u5pfsIlwD + dcH1oVsvrgEd6yOZL63ASnnloTQGOtZnKx9uJf1vQlU8RlFNGVUaevHG+dTLe2HO9ybRXj7wnAEH84Nf + E453waEuuD5068U1oGN9JPOlFVgprzyUxkDH+mzmW0eoCscoKhTXtVPHhl68cT7/qPJd0d3sZn7JSiIl + UBdcH37qxTGgY30k8yFIG+zIHyvllYfSGOhYn+18DxIpRSPNX11UaNyWmonijfPp45Tv58sni2J+5JgL + nyIsgbrg+vBbL8qAjvVRzSdP+/vXQ0REuXNB8+Hhk38mLAUjzY/vlqe01meseON8enjlw2Qs9n1o43+J + BGEE6oLrw2+9KAM61kc1H8wfzwmoiJTr/s3mB4/NG3hkd66YwS9DId+jsyZY9qEDS4mhXs8pQTp5rw/w + NwBgYSLKnUs33y1Eskjs5m8uKzYKLpfM4Iehkg93ZVYlRprNrmIv6oLrI2i9WAI61kc1H8wfzwnoEr8g + jAKxmx8cN64u58ygy1DLd2Rjld3wFmj//pjrI516SQZ0rI9yPnl/T3IA4LfdgxaEGHcVhdmYqG0sXCAi + iyPF/Hj98IxWZbF5kW0zeDEU893TMy7F9BK5f8eObW5Lo16SAR3r06m/ZEDH+jDzxXMCesRmwtH85Yl8 + y0SfukTBDG4M1Xy/WjFFFOalng4079+ystKj06gXI6Bjfbr1ZwR0rA8zn5zTQw4Aevf6YCFiuMwJeIuT + +fH35bXlykJzIypmcGKo55tbVepoflBYWHhTGvUS9XqW+eBdIAeAeE5AVVBxfM/J/PS2OLfN+pAPL6Jm + BjvDId920wNGVYN7IpH/b0HrBTqut1DqDzrWh50PyAEAftY2/7CZE7CtrZXqIf+v5uIwmx880DdeWWQq + omgGM8Ml3yenD8wToDI/719cD+A7UGdcb6HUH3Ssz0Q+/AvvxnMCqgK6mprqPkVxJM0PXlvarSwyO1E1 + g2Q45fvBoi4388t920RoB+qF6y20+mN9pvLh//r+pQWH3ZyApaWlR7uZv6kooSwwO1E2AxiO+fAQERfz + gxWEVsh6IUKtP86TqXz6R+60IC4MwKe/HABAlDsXSr7i4qKLncwPVtR5/wCYC2YYjvn66yrdzA9OJjzD + XC8mIlnPJvTz0YI49DcPAMNmTsDCwoLbncwPttge9GnHXry4LRWPsHqwr1Xs6WoU28bVirX1lWLOqFLR + Xloo6gryRcnIPJHP66ONbDxVqCw/T9QXJkQHLTOvtkKsbaoW2yaMEbsmN4v7ZraJ79MhbRBDZMpcTvnw + 7/cXdhmz9KD/p1L/11D/8as8+oY+llL/0Wf0Hdu9MJEvKgoLRENpkZhYUWL0/9AxlYb2qkmN4qEZreIl + zf6b27ehpdbN/OBKwjXs9cJEtp4Zf/mwMCEHAL3zhIrgPNHqnCmgY30yXyKR+Fcn84MLbI/5NoNie3np + ZHF7b6thVhRuJRW4Wz43oEOx7v/UshYvBgkYCb9w39UzTvzU47cJsxlUZvWLKt9LSyYbP7hhoJs9qsQw + t71fTnj11045vTeP+n8a9R8X+9j7b2/f6W0NrvmI+wnHUNULvx465kdAQGAAGHZzAlJxfIfeVhWHwU1T + mi1FhmnAccMJTNhdKZ9W6128Xvg1A8AnaHd5kfH8/C/Paks+nUhlBhCG+X9xwDTx8Ox2Y8BD/wezv3bQ + f0wIiucDYI7GN6ht5v7u7m7xyoe5H5VBtZGT9Uz4zwcRoX9zgC1YH83OUUDHelU+PElWVRwGj8xsFW9R + YX1h5gSxmQ7LcaNJGMVrJqx8NfT1Al9ZvkSDgdkIIB3z/4H6/9CsdnF0S52oLS4M3D5Jprbf6JIicczY + OvFZGqDQ53t7xyuXN/ESkRKoC64PVb34DuhYH8l8SBjI+AislFceSmOgY/1g5XuLUBWHAW4saSxKJF9n + qnjDzjeuvFic19kgXlzSHdj8P1o8ybgIqpm+m4fdvkznaykuEBsaRik1Jt4kLIG64PpwqhdfAR3rI5kv + rcBKeeWhNAY61g9mvpRJQJwYrOINMx9+YFs/ZpR4Ym670uQqvjqn3fjhLj8vLyVf1PvrMx/mf0wG6oLr + w61etAM61kcyX1qBlfLKQ2kMdKwf7Hz/R6iKw0IEi9eCTr6F1WX09WCC0vQAz96X19Bno31+CCnfu4QR + qAuuD6960QroWB/JfAjSBjvyx0p55aE0BjrWD3Y+bABVYViIaPEm8ZtvUU2Z8XRdaXx84ptvnsl2+7wI + Md/fiaFUz1pBOnna378eIiLKnfOTbxyhKowkQYotf2S+aK0bLxZ39YvN844UZx94uthz+OXiE1tuEJ/Z + +knx0Gn3iM/veEA8etaDBl848wHxudM/Iz5zyqeMZbDsRw44TWyas0Es7JwvxtWMFSPz1LPcBDUDfkE/ + nL4j43y75e8B85lJJEaIKd1l4sj19eKSc8eLW2/oFl96qFc8/+Qc8dqLC8RvfrpI/OX3S8X//e8yg7/9 + Yal4+81F4o1XF4iXnp0tvvq5HnHHvi5De8S60UYu5ETuMNpn4v1EItHM9aFTL54BHeujmg/mH/ZzAmJC + hHMJ1+//usVWUVxuGPXUZSeJfcdcKx77yOfE18/5YgpfO+cL4stnPSy+dNZDSfAaf1ctb+bLZ35W3Hj0 + XnHKkhPEvPbZoqxw4BRciGYInK+6KiHWHVInPn5lh3jh6ZniL79bIj54e5l4n8z9p98sE+/+ej94jb/j + fT/89fdLxHNPzhR7d3aKQw8ZI2pr5A+T6fY3/0/FxUXnL1w4r8qlXrQCOtZ71Z9WQMf6sPLJe32AvwEA + CxNR7pxuvtnEy4SyKCReZhhb3SyOnnuk2Lf5WvG1s70NnI75VXzl7M+JvRt3iQ2z14mWmqaU9vnFq792 + JraXiAs/Mk5854mZ4v3/WZpi2DDND+z53vnVUvHMY7OMNnS2lSjb6Ia9v3Qk8FJlZWW/ol60AjquN6/6 + 0wroWB9WPph/WM8JiDnQLic+IJRFIXEyw6iSSrFh5jrjMF1lSifCNr8q38c3XyUO7V0tyovKlH1yQ9f8 + dbUJceapLeL735ylNKkk0+ZX5UOb0Lbamv2nbJ1w6e/79P4FhK86RJ1xvbnVn3ZAx/ow88n7e5IDAL/t + HrQgxLirKMzGDPbGwnf9bxPKgjCjKo7JzZPERYec43ho78ZgmN+cD18Vzl21Q7TXa02PrWX+WX0V4r47 + JhuH4WZjqsiG+c2gjZ++vdtos7mfEp3+Es8QWrcKo8643tzqTzugY32Y+Yb1nICriT8S5h2sRFUcp688 + JWNm9YvffFcfsVM0VNYr+wq8zIDD/G881qc0mopsm9/O9Xs6fPXXxv8QywnHQJ1xvbnVn3ZAx/ow88k5 + PeQAoHevDxYicn1OwAsJPBZatYMtOBXHWQdsV5rLi2ybH2xZsEmM+JCyuLXMkJc3Qlx9RbvSXHaiZn5w + w1WdvvqrAF8XzyRSAnXG9eZWf9oBHevDzAfvAjkADJs5AYuIBwjVTk3BrTg2zT1CaS43sm1+fA1YPLFf + 2Vfg1wxbNjUYp+pUJgNRND8469QWo/1++6vgLgJPjjYCdcb15lR/vgI61oedD8gBAH7WNn8uzwlYQXyT + UO3IFLyKY9mkRUqTOZFt83/+9PvF1ObJKf2UBDXDiiXV4o//tTjFZFE1Pzh0dV3g/ip4nIAfcsX8Mg+8 + O2zmBKwlvk+odmAKKIKy2lbX4sAFPSqjqci2+R889W6jveY+mknXDDN6y8Uffr4wabAomx+0tRa79reh + 3d8ZE9I9N25cy1iX+vMV0LE+U/nwf33/0oK5PCdgI/Eaodx5dkbmJ8S4OSeIniNvVxaHJD9vpNav/1k3 + /7a7RUt1k6XtZuzmLy4uFldffbXYs2eP8VqlUTFtSpkxCETd/G+/uVgkEs7mx+8bu55aKFaf3iZGJrwn + MZHbL5FI/LvpqUKZrGdfAR3rzfn0j9xpQVwYgE9/OQCAKHfOnA+f/D8hlDvPTnFFo+hes1fMOOYzBiUV + 9ZbisHOrx3n/XDN/e3u7+Pa3vy3+8Y9/CMR3vvMd0dIy8H1Zh6mTy8Qbry4MzayZGEye/NLMZH/t5gd1 + 40rE1d9eYrDj7pmiurHY0kcz9u1Hg8CPx48f22KqP18BHdevUz37CuhYHywfLYhDf/MAkEtzAlYSmNhB + ufPsVDb1ip6Nn0yaH1S3zHA0Pzh9+SlK44Fsmx/f+Sf4OOxfvny5+PWvf500v4y33npL9Pc7/3Aokfnm + zKwSv3t9cSTND/3OSzqSfbabH0xbNjo5AIDLvrpAtFOfzMsA+/Yz5Xue3i8jfAXqluvXqZ59BXSsD54P + CxNyANA7T6gIzjOYncOv/VoX+ID67jVixub7LOYHDdOOUC4vwS/qKvNl2/z4tX9Kc7eyzcBevKeeuk28 + ++67KeaX8d5774kTTzxRmQvY861cWif+942lkTM/8qxaOZrbqT6yO3h7m2UAAFc+u1jM37D/SMrF/HKZ + p4nk2QGvQN1y/TrVs6+AjvXp5YOAwACQa3MCPkgkd5gzI0TzzONSjA/6jn1YdKz8qEKzn+rSqhTzZdv8 + wM+pvp07d4q//OUvjuY3x6WXXuqZT5rhhM0NSjN6kUnzv/3mUlFdhZuF1OYH22/vSxkAJAdtm6Bjfsmd + hGegbrl+3epZO6Bjffr5ICL0bw6wBesHu3OXEfadkcKIESPF+AWnOZq/79jPip5N9xnLqfSSW479eNJ4 + UTD/MfOPUrYTmIu3oKBA3HLLLdrml3HjjTcmi93LDNfs0rtYSJJJ84PHvzDD0j47BUUjxZ5vLlaaH1z1 + b0vEYed10bZLKPur4BzCMVC3XL9u9awd0LE+lHxIGMj4CKyUVx5KY6BjvVu+DcQ/CdXO2A/tsNaFZ7qa + X1Jaa71s1M6x8zcZxouC+S8/9CKtK/wSiYS4/fbbfJtfBgYOL/MD/KL+9S/0KM1pJ9PmBx85bbybWY3v + +irjA5h/99PEU0vEhgsn0Tb0ND/A1aa45DwlULdcv271rB3QsT6UfGkFVsorD6Ux0LHeLd8E4k+EakeY + GCHGzd+uZX7QMN39d4CO+rZImP+ek24z5gJQtdFu/iCf/OaA7rrrrmPTq80vwZ2Cv/rJAqVJJYNhfrzG + PQz29pnBqT8v80vWnT3Ry/wSPGy0mUgG6pbr162etQM61oeSL63ASnnloTQGOta75UsQ3yNUO8BC86wT + tM0PulbvVeaRoAhuO/5GX2Z1I4j5cT1CZ327Y/vMn9S7du1K2/zQ//nPfxYXX3yRq/klC+aOEu/9t/qS + 4cEy//eemaVsm5nzHpqjZX68xt/xg6Eqj4JvEcZttqhbrl+3etYO6FgfSj4EaYMd+WOlvPJQGgMd673y + XUOoNryF0V2rfJlfkiipVuaT5jpq3oasmR8cNWeDa/uk+bdu3Rqa+SVbthzran7J7o+2aZs1bPPj7zu2 + uV/PYD7/r2N+ucycQxuV+RRcjrrl+vWqZ62AjvVh5ZOn/f3rISKy0bl+wvN7f2XzDOWpPi/zgzoaOOz5 + zOZqrGoQj575YFbMj+nA8kakXrFmN//KlSvFn/70p1DNj9d///vfxcKFC1PWb6egIM+Y10/HrGZT6+KW + Dzcsja4rULZLsnTLON/mB1d+a7HomK3+gDBD++ODysqKxRr1rBXQsT6sfDB/zs0JiHOtnlf6FZU3iJ6N + nwpkfjBx1ZWWfHZzgcvWXTjo5sehP6YgM7dN1b4JEyYoL/LRDSfzy3y///3vRVOT8xWHkt7p5cZXgcE0 + P97HpCWq9pg55/7Zvs0vufxr/aJqTJEyL5D7A1cKzpkzo8alnrUCOtZ7+UMrSCfv9QH+BgAsTITZGD/5 + PkYoN7oE1/Z3H3JVYPNLiioGDvVU5sfrvnHTlSb1Iqj5wfH9m1P6a29faWmJeP755zJmfhnPP/+8sT57 + e+xgMo7BND+YM1M9C5Ckuas8aWa/5pecdkef8t4B+/4oKiq6zKWePQM61uv4wzNIB/Pn5JyAncR7RMpG + l2Djj5/74bTNDxp7NzmaH3/H+m477ialUZ1Ix/z3nny7KMi3Htaq2rd3796Mm18GfmA0t8cO2jeqskD8 + 9AcLBs38mDFY1RYza8/qMEwc1PySNWdaf4hV10v+X4k2et93wAfsBx1/eAZ0hLy/JzkA8NvuQQtCjLuK + wmyMn849Slg2uBls/Krm3lDMD6YdcYdIFLg/C8/p0mAV6Zgf2K/2UxUbru//4IMP2J7+wq/5EVjXggUL + LO1StW/L0U2DYn6wamWNsj2SguKR4orH+9M2P8CyE3oHnjuoNn+yXnClqq+AD9gPuv5wDeiInJ0TcCFh + 2ZFmsJELisrEtMP2hWJ+6KCva1+s2pmW9d5xwr8oDWsmXfPjhz/7eu3FVlFRId544w22pr8IYn4Zr7/+ + Og5zXduHK+leeGpOxs2PZxGY26Fi/uFNoZhfcv4jc0Vh8UB9mPeHrV7wo/VMQivgA/aDrj9cAzpCzukh + BwC9e32wEJHtOQFfICw7UiKLzX7on675QffqgXvkbTvTQn/HPKVpJemaH5hn9lGZH6+vv/56tqS/SMf8 + Mnbv3u3ZvoNW1FjMqouu+cEBy9x/nR8x4kPi3Admh2Z+AN2aMzpT+quol28QngEfsB/8+MMxoCPgXSAH + gJyaE3AtYd+YBrLYyuvaLKf8wjC/pKppumpnWrhu4x6lccMw/94jdybX42Sunp6eQIf+YZgf8f7774vu + 7m7H9snth09ou2nd8GP+xz47PbmdnJiypC5080O/84nForGtIqW/ClYQjgEfsB/8+MMxoGM9kAMA/Kxt + /ijMCYj7rVM2prnYug68LGnYMM0PJh6034BOYO59+1OBwjA/mNYyxViHm7meeeYZtqJ+hGV+GY899phj + ++R2OvgA/aMAP+b/+1tLRfdE9WXREtynsONT9OkfsvllrhOv60npr4KnCGXAB+wHv/5QBnSsl3ng3Zyb + E3ARkbIhzWaoaZ2bNGvY5pf5KhqmpbTBzmmmyULCMv9Nm68xcruZf+3atWxB/Qjb/DLfihUrUtpn304/ + fm5OioHt+DE/uOpj7pfooh1Tl9RnzPwy36QF7j9AMim/BcAH7Ae//lAGdKw359L3Ly0YlTkBv0JYNqDF + DImEmMJTemXK/KDr4Kto3a4juyguKBb3nfLJ0MwPlnQtdDU/ePXVV9mGepEp8yMPphdzMz/48LGNShNL + /Jr/P74/TxQXOc/lh3YUFOSLM++ak1Hz4++YUgy/M6jaYeIRIhnwAfshiD9SAjrWm/PpH7nTgrgwAJ/+ + cgAA2TA/zp1aLvm1m6F2woIUs/rD2/yS6gmLzDtRyazWvtDMf//WO43HizuZH+vbsGED21AvMml+ycEH + r3I0PygqzBO//9n+GYXN+DU/Hka6cP7AaTgVsl4WHNaScfPLZSYvqlW2xQQeMmI8bgw+YD8E8UdKQMf6 + YPloQRz6mweAbM4JeCWR3HB28+fnJ8TkNdcqzaqHvvnB1MNvE3n5heYdaUG2b+uyE9M2Pziuf7Otv1bz + g5dffpmt6B2DYX68fu655yzbRQWuDkwxs0/zg12XOj/3UO6P8lFF4pIvLhgU84Mdd3mfiiQugQ/YD0H9 + YQnoWB88HxYm5ACgd55QEZwnncbg6qTfEsYGSzV/vqhq7iFjDo75JU19qZfi2ttXXFgs9h1zTVrmh645 + +ahvtfnxfVs3Bsv8Mt+8efMs28fO1MllFiMHMT+u+MvPVx9pmPfHoWd1DZr5Ja3TK5XtklD7/nPJkn6z + N/z6wxLQsT69fBAQGACyPSfgGkJurOTONJuhbdlFSpN6E8z8oPeYB0VJdat9Z6a0r6W2STxy+n1Kc3sB + 8+/duNOSz25+8Oijjxpm84rBNj/i/vvvt7RVxYvfGHi0eBDz//an/aKlSX0zjnl/tPVUi11PupvVC7/m + B5t3eT+Rqby8fE0a/kgGdKxPx28DARGhf3OALVgfRmPuJxzNX1RWT4YM8ukf3PySSauvoXYNzBvo1D78 + fcb43pRTg17A/DhyWNO3KiUf1icZN26cloGzYX4Erguor3d+GjE4b8e4QObHrb7989Tf+837o6ikQHzk + 3jmDbn6AWYUr6lK/LprbV1hYcE8a/jACOtan67eBIGEg4yOwUl55uo3BbD/vuJmrYdoGpTndSd/8Ekwb + 5tY+ar/B+hlrlEZXIc3/6FkPitGVdcp8kksuuYSt5hzZMr+Ms846K6XdZvC4Lr/mBziLoMpn3x+rt3dk + xfySRZusE5Io6uUP/f1zRwXwhxHQsb/S9Vv6gZXyysNozEovc01et09pTGfCMz/AV4HKhm7H9pk5adFx + SsObkebHD4fXHrXbNR947bXX2GbqyLb5ET/4wQ+UbQdy/z73xBxf5v/o+davX/Z8cl9MmlcndpFhs2V+ + cOa9+38MtLdP7t+8vDxMbuM74Cv2Vxh+Sy+wUl55KI2hjXWLamNJM5TWtitN6Uy45pf5cONRUWllSvvs + YNbecw7aoTQ+MJsfbJp3hGu+3t5etpg6omB+GV1dXSntN5sBT+3RNf/N101MyWXPB0aNLhYXf2FBVs0v + GdNWmtK+AZL7F1Pb+Qr4iv0Vit8QpA125I+V8spDaQx0tIF+7rCxDHCfvtqYKjJjfknn8gtEfiLf0j4V + eP+8VWd6mh90N7nPPnvFFVewvVIjSuZHnH/++Za2o19mMyxZWKtl/ls/jm1i3Q6qfIVFCXHyTX2RMD9Y + dtw4S/sGsNTzy4R2wB/sr7D8Jk/7+9dDRIRq/sbGMe0uG8sAP8KpzWkns+aXNPUdY2mfE+iH+UhAZf4H + t9+Dw0KlXvLSSy+xvawRNfMjnn322WS77WYFxcUJGgCWKE0v+Zdr9cwP1p/TFRnzQ7ftX/Bgkv3tU9Qz + niOAZ1p6BvzB/grLbzB/tOYELC0tOd5lY4lEcZXCmCoGx/wyX/UE70kyAb4O4DcBlfnxevfhlyl1koaG + BraWNaJofgTuUBw1apTSrHL/fuurfUrjg8su0PvOD+avb4mU+aHf9cRiUVFdzG1MrWdG+SARc0h/EGH5 + Td7rA/wNAFiYCN38yFNYWHCH28aqbl1oMqUTg2t+0Lv5AVHeMDWlvSrQr7UzDjZmFTabH4PCMfM2KjWS + jRs3srX2R1TNL2P16tXG/jSb1bx/cSOP3fi4u++kLXq/9oMpC0eLPd9yfsSXG5kyv8w1dfEYS38V7CUc + w+wPE+maP5pzAiYSiRfdNlbL7A8nTadm8M0v6dn0aVFS431XmizemRP6xAOn3pk0P74W4F4ClU5y8803 + s60GIurmh27PHjmpSqr5wfo1dRbz/+71hWJxf+rjuYF5+0nae2vErqcXKc3oRabND3A60qmemWcIZdj9 + waTrN3l/T3IA4LfdgxaEGHcVhdmYZOeWLOkfRTv0z24by/37f/bML5l25J2iaJT6gRSq4m2qaRS3btn/ + sNGaMvfbSX/4wx+ytXLD/NA//fTTpj6nDu7tE4qT5v/u07PE2GbvK/wkY7tHiY99vV9pRi8Gw/x4feqt + vcr+mHiLSAm7P5h0/RbdOQHr6mqnuJk/b2SB6D3mIaXxomB+CQaB4qpxlrarileaITEyIbYt/bB45LT7 + LBo7eLovrrAzmytss2YiH54hgOcTqswPMFHHu79eLK68vI2WU+9/1fYbP6XKmJ9fZUYvBsv8xt+/sYhq + 17mumdFEMlT+4Nfp+E3O6SEHAL17fbAQkfE5AfPy8hyn/gLF1eOVhouS+SXTjryLvg4M3KnmZn5z/8bX + jrW8tjNt2rQUc4Vt1kzl6+hwPwyePMl5Nh/V9mudVi0+9vhCpRm9GEzzy2VqW9wfUkosI4wgL2TC/PAu + kANAJOcEPJtQbRyDqvELFGaLnvkl04+615hJSMf8OmzevDknzY/X69evV/bJC5X5J/ePFjufzB3zg+5+ + zzkCTiUyZX7ogRwA4Gdt8w/mnIAfJ1Qbx6Bh+kabyaJr/gFIt/leMbpjqamAg5kffPSjlw6KWTOR7+yz + z1b2yQ2V+TGxB57NZzaXLtkyP1i82f3ojtgNH7AfnPzhK6BjvcwD70Z6TsCHCNXGMRg3/zSLucI2aybz + tfQdZXwPDmp+6D7xiU8ozRUkBtP8iH379in75YTd/LjCD1NvD4ZZdfCbb905ncp+Sqi/d7Mf3PyhHdCx + 3pxL37+0YDbmBHyWUG4g0L78EqW5JFE1v6RjxaUiv7Bc2Tc3pBluvPHGQTGr39DJd9111yn7psJuflzb + f8q+6FzeGyTfsVcOzOysAv2lD4enNPyhFdCx3pxP/8idFsSFAfj0lwMAyLT5Ea8Tyo0EJh0yMP2XylxR + N7/MN+WwW0XZaPVNLSrsZpg1a5a48847xV//+le2lr8YTPOjjWgrnlmg6psKe387ZtSICx+Zn9PmB9tv + V1/fIftLA8ArGv7wDOhYr+O31KAFcehvHgAGc07A5BRgKqZuuM3VXP7JzmCCU5nGg0fzBiYVccJuhgEG + fkOorq4WO3bsEC+++CJb0TsGy/x4avD27duNS4BV/XLC3N+i4gLjApps39JrJp185392jmt/E4n8X2j4 + wzWgY72u31IDCxNyANA7T6gIzuO3Me8QKRsKYGP1HHmHp7n0yf6RRNfqvcapTaf+OpnfvmxbW5tx1x2m + 5HZ6OlAmzf/HP/5RPPHE48YEIK2t6mv3vTD3d+zkUWLHnQOP7xoK5geXfGm+Y38BDQC/0/CHY0DHej9+ + Sw0ICAwA2ZgT8G+EZUMBubF6N92tbS53sm9+CY4GmmceJ/Ly91/95sf8dvCpu27dOnHDDTcYs/P+7W9/ + C9380OPqvquvvkoccsghoqqqSrt9KmR/yyqLxNqzJho30Awl8wNcsGTvr3X/5r+j4Q9lQMf+8uu31ICI + 0L85wBasD9IYrM9SGMC8sWYck5ln/0Uh39TDP+FSHMHNBf3kyZPF4YcfLi644AJx6623GpOJYraeN998 + U7zzzjvivffeE//85z+NAQH/f/vtt42nDGOZr3zlK+KOO+4QF110kTjssMOMCT5wRWJY7ZP9xa/8+K4f + BbOaCSvf7mcGninhsn/x4ec74Cv2l1+/qYOEgYyPwEp55UEakzIA2DeWfPjnUDP/AA+7FYdlu+iSS/nw + nT8qZpWEmW/nU+5PeKLt8XfCV8BX7K8gfgs3sFJeeTqN+T8ipTgkPRs/ZRhFbSAvomx+8LBIFBRa+huW + uXIhHw7/h6r5AX4D8Nh+7xLaAV+xv9LxWziBlfLK023MnwnHYsNhsto8XkTf/NAXFpdZ+huWuXIhX2Vd + 8ZA1P3QfuW+Opb+K7ae8I1AV8BX7K12/JYO0wY78sVJeeRiNecut2LrX3qAwjxe5YX5QVFZt6S9tDwuz + 1h8pqpvUtxpL3LafankvwshXM3a8mHnoEcb/nfJVjSlSmseLXDA/9KfdjqcYuW6/NwnPgK/YX2H4zTA+ + gd/8/OshIkJrDG2U/3ArNjyhV20iJ3LH/KCsqtmpOAy23vmQ2PvjN8Sp9z4i5m08VpTVWG8wcTKXUz4v + 0slXMbpeLDj6eHHaZ74ornnlTXHirfe45mvsLFMayI1cMT/ynHRDr6W/im32EuEa8BX7KxS/kQ7mj86c + gIlE/vOq4qC3DTpWXqYwkRO5ZX5QOabb1Vybr73ZMJNk749+KbZ/+vNi6UmniaZJU0SiAPfcO28/P0Dn + ZFbl8nl5omXKdLF86xni9PsfNQYqc1uP3HmNa77OOdVKEzmRS+YHx+4ZuCvUZX88QTgG/MH+Cstv8l4f + 4G8AwMJEqOaHvqAg8ZhbsY2bt01hJBW5Z34wamzq1WJm1l5wucVUEpjtyhf/Q1z61Atiy/W3iiXHbxUd + s+eK4vIKZR4vdMxfXFEp2ufMNwafE26+S1zx3CvKtgG0b9UZ57jm6ztojNJIKnLN/AA3MrmYH+BReMqQ + /iDC8hvMH705AQsLC25TFYekfvJahZns5Kb58fe6iQel9NkMDqlV5oL5r/zea/uh1/IT+OInnxcn3X6f + WH/JLrH4+FPE9IPWiAkz54r6tg7jML2orEyM5LsU8SmeT0cRpZWjRHVDIx2WdxkDSe+qNWLxCVvFYR/d + I07+5P3ikqe/m9IOJ2T7Zq/Dw07U5ge4XVZlJju5aH68nre+ydJfBXgUfkqY/WEiXb/J+3uSAwC/7R60 + IMS4qyjMxiQ7V1xcdLGT+UFl80ybmezkrvnxPq4IVPVb0rlgsdJcTub3SybzTZgx29H84LDzJyoNZSZX + zY+/t89QT3Jq4mTCEnZ/MOn6LbpzApaWlhzlZH5QWNFgMpOd3DY/wOPOVf2W4AyAylxhmzUT+SrpaMNt + cD/l5h6lqSSDaVbV8l545VM9KdjGCiIZKn/w63T8Juf0kAOA3r0+WIjI+JyAVCBd9LZq4xjgkdy9mx9M + GmY/uW9+gAeeqvotgXl2Pv9qzpn/4q9/29X8ABfK2E0lGWyz+sUrH6YvU/XZRiNhBHkhE+aHd4EcACI5 + JyD4C6HaQAYDcwL4N5c+2cuHG4Mw87Gq35JT6Dt4LpkfbLnhNlfzF5fnp5hKMthm9YtOvu23uT/rgfgf + wgj4gP2g8ofvgI71QA4A8LO2+QdzTkDE9wjVRjLA9+T9phk65peU1jlPFgITrdpxrsVcUTc/Xq/YukPZ + H0nHrCqLqSTZMKsfdPMdcLLnLdLfIDJpfpkH3o30nICImwnVRjKobJ7BZhl65gejJ61W9hvmx2F098Kl + GTVrJvK1zZqr7JNk6ZZxFsOAbJlVFz/52rx/ANwLH7AfvPyhFdCx3pxL37+0YDbmBEQcTag2ksHIRAkd + Kj8YyFzORGcwaV14ZkqfpfnxK3pJebnY9dwrOWP+3fR/nGa098nMsVdNsRgmm2bVwU8+PBQkv8D9ac95 + eXmHsh90/OEZ0LHenE//yJ0WxIUB+PSXAwAYDPMjxhHKDQVghkmrdgYyl5poHUlM3XB7Sn+l+SWn3HFf + Tpgf75/4iXst/bEzIm+EuOyrC5KGyaZZdfCb7+R97vMhYv+2tDS1+vCHa0DH+mD5aEEc+psHgMGcE1DG + fxLKjQUzYIrtIOZKJVrmlxRVDlw0ojI/XuOCHrsRdRhs84P5m7ak7EczzV3lSbNk26xeBMm37DjrI+LM + DOzffPNkoLr+UAZ0rA+eDwsTcgDQO0+oCM4TtDEpvwOYzVBeMz6wufYTTfOD0V2rHM2Pv1c1NluMqEM2 + zI97Fcpr6yz70c7SYweuAIyCWd0Imq+mqVjZb7l/CwsLbwjgj5SAjvVB/LY/ICAwAGRjTkAZq4mUjWU2 + Q/fqK8ksQ8/8oH3ZRSn9leaX22THQ/9qMaQb2TA/2HbPZ5PtdWLrLb2RMasTQfOd+gn1U4HN9VxRUb46 + gD8sAR3rg/ptf0BE6N8cYAvWp9uYIuL/EUrz4zV+LVeZx5tom9/QHX2vKCypsPTXbH7Qf8yJFrM5kS3z + gzkbNlnabKe8usB4zFcUzOpEOvnmHNqY0mdbPf/vnDkzagL4IxnQsT4dv+0PEgYyPgIr5ZWH0Zj7ncyP + vyeKKl0eFe5E9M0vc4zuWGzpL20PCyWVo8SV3389xXRmsmn+3d/9iSgocX7iL5h3WFNkzKoinXz49R8X + OJn7a6/nwsKCe9LwR/jmTyewUl55KI3BqREn89PbBrh2Xm0kFbljftCx7LyU/trZdPVNKcaTZNP8YMPH + 9irbLEG/TrqxN5C5VETJ/GDzrskp/bXXc1lZ6dqg/oCO/RWK39IKrJRXHkpjoOvpmVpDG+m/92+wVDOU + j5miMJKK3DK/kWvzvaKg2P3JOi1Te5Tmy7b5QUPnJGWbAfZjXXOZ2PVkMHPZiZr5wdjJ++diUJmf+E1L + S1OC3vcd8Af7KxS/IUgb7MgfK+WVh9IY6FhfWVhYuM/J/JKJq/YoDGUm98wv842Z4v1M/W13P2wxXhTM + /2GXc//SDAee3B4Zs5oJI99JN01P6a/V/EY976T3fYfZHybS8Zs87e9fDxGREfOD2tqamW7mB5VNfTZD + mcld8+P9yev/hfro3HfQ1b8kabwomB84XforzVBQOLQfAjKhd+DIzcX8/6D3ccGbr7D7g0nX/NGZE5D1 + lny0sTBXWkoxmZm0+hqTqfTM5Z/s5MMAp+qzGTkHXxTMv/Wuh5VtNJuhZ0VDZMwqCSufPPXnYn68/0XC + V5AXMmF+ea2PvwEACxMZNz+BfAcQlmKyg7n0zKbJlln10c/XecAVyj6bwRRfUTA/GDst9dy33QyYInso + mh9gclMP84MFhHbAB+wHlT98B+lg/ujNCWjCnu9lwlJUdvbPGDx0zC8pre1Q9hnIYjt+3yezbv4tN97h + 2D5phM6ZtUPW/MddM1XH/M8R2gEfsB/c/KEd0BHy/p7kAMBvuwctCDHuKgqzMTqdO5ywFJYdXD/fu/kB + 3+ZyJxqDSdvSC5R9NhdbfWub2PmdH2fN/Hu+/1PjEmWn9kk+fH3PkDT/rqcXieqGopT+2swPDiS0Aj5g + P3j5QyugI6I7JyC/VuXD4QkenGDekBawkZttNwnpmMuZaB1J2CcKUZnrwO0fyYr5wbKTT/ds38TZtUPS + /AA3/WiY/98IrYAP2A86/vAM6Ag5p4ccAPTu9cFCRMbnBCTc8h1MmDdmEllsBUUlYur6G32bK5VomR90 + Hrj/twCVuQb6XyTOe+wbSoO6ka75z/7iE5Z7/lXtSyRGijPunKE0jxdRN/+5D8ymba/1UJZFhGfAB+wH + P/5wDOgIeBfIASCScwJ6xeOEZaPai62qpZfMdR+ZZuiYX4LZkJzML4sNP8Jd/aNfKI2qIl3zX/XD/xSN + Xd2O+0O2b/qK0UrzeBF18+/51mLR3luT0l+F+T9PeAZ8wH4I4o+UgI71QA4A8LO2+Qd7TkC36CZcHyGO + 1019m5UG8ia65geYNbigAN8zrf21F9uBZ5yrNKuddM0Plp9yRnK9TvujqCRfXPzoPKWB3Ii6+aFbvqU1 + pb8K8+PZ/62Ea8AH7Ieg/rAEdKyXeeDdyM8J6BXXE47Fhr9j+vDOA3cpTeRMtM0v8zX3bEjpL7aHmbyR + +cYDRFWGlYRhfjwlCE8T8tofh5zRrjSQG7lg/hOv77E9j1G9P4iPEa4BH7Af0vWHEdCx3pxL37+0YLbm + BPSKEtrIv3AqNnrfoKC0Rkw78k6FkVTkhvmNHJvuFqVVTW7FZlBRN1pc9s0fKI0bhvkveeoFakeNsS60 + w2l/NLSXGbf8qkzkRC6Y/8LPzReVdcUp/bXvB+InRAHhGPAB+yEMfzjl0z9ypwVxYQA+/eUAAKJgfiNf + WVnpoapio7ctVDT1atwynDvml0w66GMiL29kSn/tTJgxR1z10s8txg3D/LgNWV7w42b+kYk8cea9M5Um + ciIXzL/z8cWiY4b5e7+j+XHJr+tFP6hn9kNo/mB9sHy0IA79zQNANuYEVAZ0rMeDRO/w2PgGtR3LFaaS + 5J75ZT6dG4VA35rDksYNw/xYduoBBxu53cyP9w/aNkFpIidywfy7KEffgQ3K/iq4mnAMcz2bCMUfJvzl + w8KEHAD0zhMqgvNkrHPTpk2upx3wmpv5JWOmHm4zlru5UpfVYXDz4aKnkmrPB04YrNh2ZijmB3hKMHJ6 + mb91eqW46ln9Q/9cMD/0CzfifL+W+b9PON7ua69nJjR/MP7zQUBgAMjmnICWgI71lnwjR46cTm+7PkpM + 0jL7RG1z+Sc7+XC34MgC91l3AIr0kLMvStv8OLsg87mZv6y6wNev/rli/lVb25X9VfAu0UEog2o3muZH + QETo3xxgC9YPZuc2E6qdYGOEGL/gDG1z6ZPdfAOXCTsfBZnNuu7CywOb/5BzL03JpzJDXt4IcfJN05VG + UpEr5j/svEkikdAy/z+JQwlloG65fp3q2VdAx/pQ8iFhIOMjsFJeeSiNgY71XvluJFQ7w8KIEXli3Ozj + tM3lTTQGk4ZpGxz6azVrIpEQa86+OGOf/ODg7W1KI6nIFfMfvK1D1/xgN6EM1C3Xr1c9awV0rA8lX1qB + lfLKQ2kMdKzXyYe7mR4jVDvEwFy8TVPXaZvLmWgdSVS3Wh9B7WZWXLyjMrqKRced7JlPrhOz4KqMpCIX + zI8f/Hx85wefJZQfoKhbrl+devYM6FgfSr60AivllYfSGOhY7ydfKaG8YUhVvPWdy41nDKrM5E20zA96 + j75flI0emIdPx6wzDt2QcorQDE719axaq50P98FfqfmjXy6YH6f6+g7Q/rUffIfAdPYpgbrl+vVTz44B + HetDyYcgbbAjf6yUVx5KY6BjfZB89cTrRHLHuBVvReN0HxcLSaJnfsn0jXcbZwa8zCoZ3ztTXP7sSynm + v/SZF0XLlIF57dy2n8wzbmql2PnkQqWZ7OSC+XGRj+Z5fskrRA2REqhbrt8g9ZwS0LE+rHzytL9/PURE + 1DrXQrxBaBVvoqRadB64U2moVKJr/gEeFtOPuE2U1egftlbWN1guGz7lUw8kH+els/2aJpaLj329X2km + O7lgflzeq3mFnwQfOGOIlEDdcv2mU8/JgI71YeWD+aM9JyARJN8E2mm/9CpeCX4cbOzdZBhIbSwQffPL + HNM23CrKqlt0itcAVxUeePq5YsXWHVrX9ktdY0eZ5cm+bkTd/LhceflxE3Sv7Zf8jBhLpATqlus3jHrO + lPnltT7+BgAsTES5c3n19aO7Eon8n/nYmaKiYZqYsv5mV3OZiaL5JTgSKKlpU/bTCx3zj59WOWQ++c99 + cI5o79O6pdcMDvtz+ZM/p+YE1A7oWF/Z3NzUkUgkfqhjfkneyALR2LPRuNLOyVwgyuaX+aYfda8oH2N9 + Qo0XOuafOLfamAJLZSY7UTb/7mcWieXHjxOFepN5mMG8frn6nR/55P09yQGA33YPWhBi3FUUZmMyurEm + TmwfQzvT9RShisKKBtGx4lJHc6nN6MXgDyYYyGraFiv7aEfH/DjVp3t3X5TNf/w1U0V1I77r631NNIFT + fTn5az90RE7OCegZ0LFelQ8j3McJ1Q5VIs1QPW626D54l9Jc/sjukURT3zHiQy6F7WV+XOG39qwOpZlU + RNX822/vExPn1Xj2VwGu8NtD5OR5fugIOaeHHAD07vXBQkS25wR0DOhY75XvKMLz3gFVcVQ19xjz8qnM + 5U12zQ/al18sCsvqtftrN0NtS4nxyCuVqexE0fwn7+sRbTOqtPtrA9f2ryOUgTrjevOqP62AjvVh5oN3 + gRwAcnJOwJSAjvW6+aYQ+AFHtaM9i6OsfpJoW3o+HVrrXkSUPfP3bLpPjJ27VRSPaknpp8SvGfDL/4aL + uhx/A4iS+fd8Y5E4Zs9k4zoF2X6//SV+QHQSykCdcb3p1p9rQMf6sPMBOQDAz9rmj9KcgJaAjvV+8+E7 + 3D7CsrP9FEd+UYWo61olug6+KsV4+8mG+R8WEw/aJWo7VoiRieKUdpsJYIYkxWX5Yu76RnHaHX1Jw0XF + /DjMR9tKKvbPVAx89heTeewlcu+WXg7oWC/zwLs5PyegEdCxPp18y4mfE2mZAQ8laZh+pDEP4f4jg8Ez + P9bZsfJyMXrSalFQWqtso510+msHD8RYeFSLOPnGXrHzicWDbn580m+9uUcsP2G8qG1WD3o++/sa0U84 + BuqM6y2d+ksGdKzPVD78X9+/tGBU5wQMO18xFcE1VAzvaxaHK3n5RaKisUe0zDja+PGwd9PdFrOqze2F + 1fy9R90pug68TDTNONZ4eKjXJ70dn2bwxJyvrLJITO4fLVZv7xDbP9GnfbrQjJf5kRNHHphxqGNWlUgU + uU+P5qO/mL0Xj+0uJBwDdcb1Fkb9DVY+/SN3WhAXBuDTXw4AIMqdSzsfHkVeUJB4PEwzGCQSoriy3rjv + YHTXwaJlzkmifdlFxtHCpEOuNS48wv0IOF2H+QtxU8+0I+8SUw67RXSt3ivaaNnx804SjVPXiprxcweu + 8Evkh9e+gf7+g/5+L71/P4Ffu5VaFQ75ku3D2YPR40vF1KV1YumxY8XhF0wUJ1w3Tey4a6a48PNzxeVf + 6xe76RMcswfh348+tkCcc/9ccfonZ4mt+/rEcVdPF2vP6hTzNzSJjtnVompMEeVWt0WFV/tMfIGYQLiG + rBci1PrjPNnPRwvi0N88AERyTkAToeYrKytdR8XxPXrbXiCe+Cg2LQYjXyKReHzkyJF99L6MWcSThDKH + mVzsryIf7uJbQniGql749dAwPwILE3IA0DtPqAjOE63OmQI61jvlW0vgF2BzsTiSpeLVxp6PjnaeqKgo + X2nqrz0WE44DQa71V5HvBWIVoRXYTlwfTvXiK6BjfbTyQUBgAIj8nIDEYORbRnyFcDw0zkLx+sKU772C + goIHqqpGLXDprz1mEvhq4PlEpgj2154P+/BLxEJCO7CdeHvp1ItnQMf66OWDiNC/OcAWrI9m5yigY73f + fO3EVcTvCZ1isxSlLpnJl//zoqKiy1tamtp99NceDcQllM/zoSx+yEx/7fnyf0N/x1Rd4wlfge3E28tv + vSgDOtZHMh8SBjI+AivllYfSGOhYH6V8OC+MJxXfQ0X1xwib4beku4UO81ek2d9kQLdkSX8l5VxVWFhw + J7XvrQj1157vbTra+TR+06GBz/Fcvlugv7y9Qtt+rI9kvrQCK+WVh9IY6Fgf2Xw9PVNrysvL1hUWFt6S + SCR+mmUz4MIVTImG69XntbW14itcRrdff//cUXl5efitAA/AeJnQPoMQQn8tDOTL/wnti33l5eVrZs7s + reX2Dtn6Y30o+dIKrJRXHkpjoGN9TuWjQaCJ3t5A3EB8m8A15MqCNRPQDG8TzxD4WoIfLKsII6gt2dp+ + tQSumccVdN8k/kiktD0k879DPEtcR4PQYY2NDW0a7dMK6Fg/LPIhSBvsyB8r5ZWH0hjoWD9U8o0j8Gvz + duIa4mECxv0xge+m75AB/kp8QPyD+DvxLv39v+j9V4lvEA8S0J5GrCQw7Zky0A5uj277XAM61gfNh/4f + QJxOXEv9epgGymeJ1xKJ/N9SX/+EPtPfcQTzAYGbtTC4/Zr4EYFt9RCBQWUbcSCR7D/awe0J2j5LQMf6 + 4ZJPnvb3r8+BzsX54nzaAR3rh0s+mH9IzgkY54vz+QroWD9c8sl7fYC/AQALE1HuXJwvzqcd0LF+uOSD + +Yf+nIAm4nyaAR3r43wBAjrWRzmfvL8nOQDw2+5BC0KMu4rCbEzUN1acL86nFdCxPsr5huWcgL4DOtbH + +QIEdKyP8wUI6FgfZj45p4ccAPTu9cFCxFCYE1AroGN9nC9AQMf6OF+AgI71YeaDd4EcAIbtnICuAR3r + 43wBAjrWx/kCBHSsDzsfkAMA/Kxt/qE4J6AyoGN9nC9AQMf6OF+AgI71mciHf+HdeE5AVUDH+jhfgICO + 9XG+AAEd6zOVD//X9y8tOFzmBIzzxfl8BXSsz6V8+kfutCAuDMCnvxwAQLzxNQI61sf5AgR0rI/zBQjo + WB8sHy2IQ3/zADCs5gTk13E+jYCO9XG+AAEd66OTDwsTcgDQO0+oCM4Trc6ZAjrWx/kCBHSsj/MFCOhY + H618EBAYAOI5ATUDOtbH+QIEdKyP8wUI6Fiffj6ICP2bA2zB+mh2jgI61sf5AgR0rI/zBQjoWB/JfEgY + yPgIrJRXHkpjoGN9nC9AQMf6OF+AgI71wyJfWoGV8spDaQx0rI/zBQjoWB/nCxDQsX5Y5EsrsFJeeSiN + gY71cb4AAR3r43wBAjrWD4t8CNIGO/LHSnnloTQGOtbH+QIEdKyP8wUI6Fg/XPLJ0/7+9RARUe5cnC/O + px3QsX645IP54zkBdQI61sf5AgR0rI/zBQjoWB9WPnmvD/A3AGBhIsqdi/PF+bQDOtYPl3wwf1pzAuLG + AjRAku4twnG+OJ9WQMf6OF+AgI6Q9/ckBwB+2z1oQYjN8wKAdG8RjvPF+bQCOtbH+QIEdERacwJCjAZI + 0r1FOM4X59MK6Fgf5wsQ0LEeeeQAoHevDxZiAYQSvA56uXCcL86nHdCxPs4XIKBjvTmfrzkBsTASSNK5 + RTjOF+fTDuhYH+cLENCx3n8+LETgMAHfFSR6hw2KgI71cb4AAR3r43wBAjrWx/m8AgsRuEgAAkk6twjH + +eJ82gEd6+N8AQI61gfLRwvi3KAFfitQxPnifH4izpfFfLQwRg/8aigJNArJiPPF+fwE9ITcdnE+nwE9 + IbedZr4Pfej/A2YhfszJF9lbAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAAABGdBTUEAALGPC/xhBQAAHzxJREFUeF7t + nX/kZ1X+x5MkychIMsYYI2OMJGNkZIyRkZGMkTGSJEkykiRrJZGVkbXWWslK1spIkqysZCXJylpfWWtl + Za211lpZX2t9feXra7/PR3Pe327vOff9uee+732/z4/nk8cfTZ973+ee87rnnvM6r/M6V1mWZVmV69+X + rjolXhjIqXCZZVk1SC/1y+LfA3k5XGZZVg3ipV56yVfhDsCyahIv9dJLvgp3AJZVk3ipl17yVbgDsKya + xEu99JKvwh2AZdUkXuqll3wV7gAsqybxUi+95KtwB2BZNYmXeuklX4U7AMuqSbzUSy/5KtwBWFZN4qVe + eslX4Q7AsmoSL/XSS74KdwCWpRfha2oQL3V4uYfgDsBqV3oBrhYHxIvi1vDPRYuXWsRe9hjuAKz2JMOH + mwQ74v4heBl+Lm4If1Ks9AxNdgB6llvFM2KvuDr8s2V9WzKOa8X94nPRfRn+VzwtipbK31wHoOfYJX4R + nulLcVG4I7C+kYwBMIpL4n/E8ssAfxdHwiVFSuVvqgPQMzCN48tPB959tr+KZ8VuYbUsGQBGcp/4o+ga + SYz3xa5waXFS2VvrAG4Xf+s80zK/Fw+I68MlVktSw/PyPyn+S8QMZJnFVKDI4aPK3UwHoPIznWNEF3u2 + LrTpB+IO4WlBS1KD7xF/EDHD6IOpwB3hFkVJ5W6pAzgthnbswAhwf7jcakFqcMDbvzxH3In3RHGrAipz + Ex2Ayn6j+KjzLEN4W1wTbmG1IjU6S36/CUYwFByFT4iihowqb/UdgMoNj4g+Z26Mf4mT4RZWa1Lj4wTE + CGLG0cdfxKFwiyKk8rbQAdwiftd5jiG8I64Nt7Bakxr/GvFaMIYUGDYW40FWWavuAFRmnLrPdZ5hCP76 + W18bD2G/Q5YCu3wlHhZFSOWsvQM4KBiZxZ6nD3/9rcuSITwueKljhtLHF+JAuEXWUjmr7QBUXkZxr3bK + P4T/FMfDLazWJWO4QSzCRlNg+pD9V0RlrLkDOCZ4oWPP0sfPhD3/1jeSQdwpWOuPGUwfrDefEVlL5auy + A1BZrxfvdso+BDZ6HQ23sKzLklEAW4BTYwM+E3vCbbKUyldrB0Dnmzp1+4lw5J91pWQYxAb8OhhKCt8X + 2Q4pVbbqOgCVk6CfTzrlHgL7A24Lt7CsKyUDuVekxgb8U5wIt8hOKltVHYDKCI+J1NHaD4S//la/ZCB4 + lV8Xqcb1sdgdbpOVVK7aOgD2crCjL1b+Pv4sqsjwZM0sDEWkxgbQYbAHPbsvjMpUTQeg8o0J+qFt2Pth + WcMkYyHmP9XBxBzz9nCLbKQy1dQBjAn6Yefn3nALy9pZMpixsQFEmGUVJqzyVNEBqGxMz37cKesQ2Bz0 + VLiFZQ2XDGdMbAAG95DIRipLLR0A7ZEa9MMy7U3hFpY1XDIcGBMbQJhwNkkmVJbiOwCVi6AfRlexMvfx + 9Z6NcAvLSpcMaGxsAPHpWYQJqxw1dABs3f7vTjmHwMpMsbkcrUwkIyLNFGv9MSPrgzBhYgq2LpWh6A5A + ZRoT9EP9nw23sKzxkiHhfCKENHUqQMahm8NttiaVodgOQOUBMv2k1j3p264Lt7Gs9SRj2i9SE4kCPoSt + xgbo90vuAMZk+mG05mQf1rSSUfElSp2Hbn33mX6/yA5AZSHo5zudsg3F232t6SWjwhPNeYExo1sF8QRb + yyas3y61AyBbEyG8sXL2UfxJTlbGwrjEqlNnYhAbwOhhK9LvXhA40YZwIVy2Vakc+F3YZRmrzz7wE/xI + eMOPNY9kXPC8SEk/Dewt2BduY+0g1RXHe3GoZ6wu+/iTOBhuYVnzSEbG4ZK/CkaXAl8nz013kOqI471+ + GupsKHz92SRkWfNLhna3SA1LxTvtZJQ7SHV0QqQc7wWsFNwSbmFZ80rGhof6hyJ1fZqThos7XmxTom5C + HcXqrg9Cfh8Lt7CszUhGR2KK1DVqfAdnwi2sjlQvcD7UUazu+sB56ZBfa/OS4Z0TKcNVpgH3hsutjlQv + +FZS9118nZk53MKyNisZHw6rN8SQqQCJLB4QdgRGpHoZE/LLDkGH/FrbkwyQLDUsQcUMFBjSfiCIIbB6 + pLohaWdKB8Ay4bFwuWVtTzLEJ0UshRiRbE8LO/52kOroZsFpS0OmVHQUZAdy0I+1fckQl73XpBYnJv2Q + sAZKdcWUCr8KOylXOQMZcTnLr5WPZJBHBU4sYv/JBeDTZ0dKdUcilqfE52J5WkDH8Ez4UysnqWFYHz8r + 7hLNObv0zLtafO65pLrcK9gR2O0IiMK8MfyJlZPUMIcFO7JY7mI+d5vwPM0aLdkPEHPxqHhb3B3+l5WT + 1DDM394U3eEaO+fYjkpCDWsGUa+CNXT8DcfFw4KvJrvpOOXoLUGGHFYiluHf+f9A/D2Zj2gvNjzh2CQw + h9Bc7o2TzqMb60rJMIDceX2HabAbjpNztp4iq3SpDplmMTRmmsU8mU6X9Ncsi6Wuow+BezKqI+qRTuOi + IEknJyh5DX5GqX7JiLRP5C0VkLnvTlFcGNJ/iAeFl8USRH0JtshyYhHBL6QeTz25aEpoy7+KjwTHbjHy + YIRgTaBQl+Rx4AzE34p8t5KrcMBprTFDiYHh/lKcEvaU90h1QwYiVhYYjn8qUncfbhJSpTFCYMrB6MAj + vRFSvfEhZQrHh7I7mrsk8nxXVDCWbPgidQ1iCKyV82BEyNlRKFEPgqE10yU2ueT80vdBB89XCx/EMZHV + UWk5SnWE/4wPIiOqWPwD/0YYeV5SgTDY74rlAqfA/JKttRh+k9Jz87U/KXDEMbSeYy6/DejkGe1hvD6i + a0mqE2DljHanrmJ1uAA/Wl6HnKpAOChSz8/rg+guOpNmEjvoWRnyEfn2oUhNglESfMEYFbA6QbLP5qU6 + YJ5PFqOU045fEXmsxKggwPw0VtCx8OXDUNgZVu0ebz0bp93gDGWYv01n3qahffmSYfhNHtmt52a0x/Lq + 8jx/CHwk8sgqpYIAO+FYhkrNl78TvBTMhwiprWapiWcRZwQv/qpY99rB8Inua2ZpWM/JdBmfCKnl13lf + mFLl806oMIsNHKxFxwq8DsyLCFLhaOhiHYWUXbBu/66oeaifCh0BG38IH682pkDPxlSZ7c6pmY5jUGf3 + hVvnIxWKoAXWhFPz5g+BiiOrLiOOoqTyUi9E13FKUOzZzOVOkZEksQ7VSM+Cj+dxwbFyqcP9VTAKyG9Z + UIXiS0cjkiVn6i8dFViMo1Bl5HALhvtj5nqtwgoI04KiA8VUfkbFRMZyRPnUUz0+sNRRvmHZKtyiAvrW + NdeBl4npRraOQpWLrz4e252WdsyVYC/sUShuNKDy8gG8Q/ABnLrt8RuwGYr7lzEdVkEZAhElSEhj7KHW + oesozGI4pHIAYbFE7vmrvx5kUyL0uQjfgMrJ/oyXBKOY2POsA6PI+0V5fhIVelE53xNz+AeycBTqt/Hw + k/5rqrgIc/mr96rINohIZVvM8/nITd3p874w5S1/n4UeYOEfIFXWHENjHIUMuzfuKNTvYQQ4KadeDjWX + XypGereH6s5CKg/TXEaflG3qWA78Z0wj6sunoQdaxD0T/TbHWjhDRwJNNuIo1O+QrIK5Wcvr+puA/Sa8 + cFsVvy/m+pDR2TF9ZENV3Rvl9IB8NXHkpZ6uMwQqkvuSRWY2R6HuTRw3nl7P9zcDQ+KHxFa+ivpdOvu5 + 5vmscJHfYXf4ufqlh11UKvEDc1TqwlHIisRkParuBTj75nBumtWwQ5JsRRv7Quq3CN9lmy4flak7e56H + FOfNboajgvEP8DUlJRX5BGMVtQ58OW4LP7eWdB8g8jFlE4eZFobebCyatRPQ/YnlICUaKd/nCHcnLJjw + YKdaQ1SE4MtKxUzpWCGV1dpLKLrH4uWfIqTTrAeOsmfFLC+P7ssXGafy1DkZGEGwrIcdOVdCTFSMID6c + FNDrDrn4WkxyIKfuc4+YY6pixsFokdRZk/kEdC98U0wx2LU49XCfUSMjF6dPGyJVEtluCQZh51isQoeA + h36Krz8jk1VnAJrtwBcaZ/La0j2IV+Fgl6mX9eiomN6SXbmuZb25pQpbNMyLIjWQiKH6neFWo6V7EH65 + Tidk5oWNVuyxX0u6nuW3KZdzuRf+A/wIdS/rzS1VYKqjkOEbWzDX6nF1PYFFzNliv2HygY/DWlM9Xc+K + FDv3YvdPhcQ2LFk6A/aUUoUSSITnlKH9Ks8sS3RrpVPW9Yw8SN4Ru7/JD4KFRq/26Fpgp906owA6Ipa1 + 6UysuaTKJfaeyLBYRCEdw8PhT0dJ15OLnz0GUzuCzLywV350MI2uJcs1SUpi914FqxIk9/RxeJuUKhuv + LVlnuysGZN4ZvcSia5lukO9wameQmR8+BuzLGD3n1rUs0Q3NZ8Hv0encLTzP35ZU+STaJFqLl3+toB9d + zxJkiTn5zWV4eQkDHyVdx+iSKWbs3l0W8/xqE9gWJTXEovFGS9cSADKVI8hsD+I1RmfQ1bWs/PStOnk9 + v0apMek8OK3I8/464LzKUVmHdR3TQHaVdv1LjAqZXvCR8Dy/JqlBgcQO3tNfD3Tk7N4b9bLqOqaVOJmx + CZKWcoyd4/ZrlBqWGANyCcQMyZQLwWDHQjMnS9fytSele7Vpy5uXGpfYAjKwxAzIlA/hvQ7IseKSceD1 + H7rsY8qD5dwnQnNb1jeSYeDJdahv/bC779bQ7JZ1WTIKQj/t9W+D14SdeNZlyRg4s81r/u2AQ/BoaH6r + ZckQgC3G/vq3xevCo4DWJSM4IJzgoz0YBdwRzMBqVTICTlzx179NOG3IkXytSo3PXm2n9G4Xjm/L6qQh + a4NS45Nn0F//tiHjr0cBrUmNTqIPcgfEjMK0A2Hf+4NZWK1IjX5SOOrPMAJ8NJiF1YLU4GzxJBgkZhCm + PSY5MMYqRGrs/cJLf2YB+/u9JNiK1NjkDrTzz3R5IZiHVbPU0Az/h+R5M23BRrAbg5lYtUqNzPDfCT/M + MmwVPhHMxKpVauT7hYf/JsbzwUysWqVGJvwz1vjGkNffG4RqlRqX5I5O+mH6cFBQzVLjkuN9yIGipk2Y + Gp4O5mLVJjUup8TEGt6YBReDuVi1SY3r6D+zEx8LRwXWJjXq9eLT0MjG9GE/QI1So3KwA+fExRrdmAWc + /nMkmI1Vi9SonOrSPd/NmD7OBbOxapEaleObY41tzDLPBbOxapEalcMhY41tzDJvBLOpX3rYo4LTcEvg + bCh2snTtWyLW2MYs84loYyVAD/qCIACiBD4JxU6SruPQT5Z3Yo1tzDIcErMnmE+SdB2h5p8XwoVFBxCr + hBwZ2wEQAvxZ5z7GrIIzAw4F80mSrnuvc5/ceaGVDmCv+KJzH2NW8S8xKl24rnMHMCNjO4CD4m+d+xiz + CnIDjDo7UNe5A5iRsR3AbYK8b7F7GhPjrmA+SdJ17gBmZGwHcEQ4BbhJYdSuQF3nDmBGxnYAdwpHAZoU + HgjmkyRd5w5gRsZ2AMeW7mPMTjwWzCdJus4dwIy4AzCb4olgPknSde4AZsQdgNkUzXQA58U7hfBSqOck + 6Tr7AEwqo84L1HV0ALEo1hxp4zAUPahXAUwqY52ALDmfKIR9odh1Sw9KozgZqEnhfDAfq3SpMQ8IZwMy + KZwM5mOVLjXmHsEOr1hDG7MMewF8WnAtUmP6QBCTAvtGbg3mY5UuNeY14sPQuMbsBHvlbwnmY9UgNajP + BDBDIX38DcF0rBqkBv1up4GNWcWbwWysWqRGPbfUyMb08WIwG6sWqVE5GBTvbqzBjeniGIDapEa9ReDc + iTW4MQs4GWhUNiArY6lRWQn4IDSyMX2MzghsZS417MVOQxsT431xTTAZqyapYc8IdkHFGt4YsAOwVqlx + fUKwWQUfh3uDuVi1SY3LCUEfhcY2Zpk/if3BXKwapQZ+sdPgxnT5ufD8v2apgUmEwFJPzABM21wIZmLV + KjXybuFzAs0yHBzjLcAtSA39g07DGwP4hq4PJmLVLDX0SeFpgOnyVDAPq3apsZkGOEGIWfB3cTiYh9WC + 1ODeHmwWkMr72mAaVgtSgx8WPjLccF7EuWAWVitSo18t3gxGYNqFFaHdwSyslqSGPy18YEi7EPr7bDAH + qzWp8a8X3iLcLn8WB4I5WC1KBnBWfBUMwrTFy8IqXWpENvlcHf4zSbpul/hYxAzE1MtfxMFgBlaJUgPi + yLtdXBKnwz8nS9dyQrJHAW3xQzHqo2FtWWo4uEmwlv+loEHx5o5K5aTrbhD2BbQDOSEc+FOi1HAM9+8R + HN7QbVQ8uvTqo7Zz6rpTwlmD6wc7YUt4srhG3CyuC/9kbUqh8veLV0Xf0h07uu4OlyRJ19GxMJWI3dfU + w+/EqGO/dB2p5cks/bY4Lhw9uAmpohmiPyL+KGKN2gWH3o3h0iTpOvwJOIdi9zXlg5/n4dDcSdJ1OIu7 + 00RGiz8TdApOIjKHVLE4+Y4KYrUJ2ew2Zh/83dMiWVwjng33iN3blM0vRPKZf7oGnhIxu/iH+JEg36Sd + ilNIFQkc5MFcjQpervSdYKQw6nhnXcdR4s4bWB84/kYd+KHreLl3Gn1y/xfEXmGNlSrvOkH67nWz9nxf + jI0NIF/AmI7H5Alf7mdEsnQNo9BXROy+Mb4QTwpWqayhUmVR0QfFT8UUyTqYy48dBVCW54WnAnXAYR+7 + QvMmSdfdJVI/Bqw0/EY8KEb9blOiksQTgtjsWIWOAYfPOsFBlAnDid3blAOpvkfl+tN1jEbfDfcZAx+Q + DwXL1l46XJYqhS/tMYF3lV4zVoljYD6GMy/Z4dOVrsfDiwHFfsPkD576B0NzJkvX3iem2C3KiPYtgUPb + KwaqBMDJ95Jg7T5WaWOgosntzou7triHeED8U8R+z+QLX1+Sv44NDCMuZOoRILaOP6HdFQM9OBU7hZOv + C6MHnC+Pikkzu+p+nCqMP8B7BcqCUeXoRB+6luE/q1CLUPMpwT9FGDsfwTbEg4oDYion3wKGedxzlMNv + iHRv8gbwG1NOU8x8/FasvdNP92CKSsQfnckcWaSJSnxYjApcK0Z6QF4gHnRIJN9QeBkZRbCff/aQTP0G + yzpML9wJ5A1f1+Oh2SaR7of9PiR4Yaduf6YqxJ3cK+pyFOqB6EFvE8ROT7mkxrCMZA6jYrrHSr+3R0zt + sDTTwRwbn80s0n0Zsn9PzHHCNCMM3pM7RfmOQj0Ey2gERExZWczDfykYlm3FiaLfpROgx3YnkBc4ah8X + s9qF7g981JgSzuEcXjgKiYkpz1FIoQXLHVN+KbkPy3EXxFpLe1NIZWBX4ifCnUAe4AfiY7OxLye/Je4W + c/kH+HDifOaDU4ZUUOLoWX+f0nPKOiy7rrJK36TysJTzaxErs9kcvPzfEVsZNut38Q8Q8cdJU3NEjv5e + sLqVr6NQhVt89RmeT/nVx5t7TmS571rlOiQI+YyV38wPw2W+/Fu3D5UBJzEfPxzdU48MuR8jTpbP83IU + qkBzfPWJvSaIY1SKr01KZWSuRg4CTwc2C+f54ZnPap6s8jAyJDMV5YuVex2YahCazP6E7ToKVYA5vvqL + JRF24xXjAFFZmafRMHMMAc2VsGeEr2GWUrl4N46IN8QcjkLu+RPBCHTz0o8Szcfmnam++nQgOPkYzhW5 + e0rlZiREurI5HELmMtgJfpc7Q7VnLZWz6yicI5IURyHRipvNQaAfY9g7laHjxHldFJ+jXc9A+CgrFT50 + dHoYXbFOvi9UdzFSmUlpx3SFwLU5poqj8xyOkn6MEQBpumKFGQoVgQONHVflBz4E6VnghMArPEdjtwjO + PjaOFb23XuUno/AcjkKmGpt9h/SD7LgbO7/BQcLQ5eZwu+qkZ2NY9prw4aPj4SXh61bbR4I9MTi5p3AU + co/Nn2+oH8XRcTEUYijMgxg54DysXnpGRkoM/dipGKsP0w9TTOI/9ofqrEp6Lt4fPqLrOgpJdbYdh7l+ + mLVPeuhYwbrQk5NPndTek27XLUF6Zry1JITwaGBnFl99gmuqz6KjZ8RRyKE0rKalOgqJk9legJB+HNjF + tMohyPyNtMnFOW+mlJ4fByFBTfYN9MNwlqHx3lBtzUjPjKOQTm+oo5C/wZ62KxWAHow1yeUC4rUlH1pR + a/pzS3WBI4j00axluyO4DB8JNtewdt60rej5hzoKebfyGE2rIATCMMRfFK7oNf25pXoBllKJGGt5yZAX + n6kRuzurcfJNIdXHKkchI+4T4U+3LxUGmMfwVWM0MFt2npqkesIRxNZStn/Oscc8Vwgg44tPQli/+D1S + 3SwchThDu45C6i6velOBKCy9lhs0UaHuGBEwNfiDqHFqwDMxSmTliDMYbScDRV0JptIcbTb6vAurAKlx + mU6x/ROv8Bxx5JuGYT6hsKSEy35zV85S/bH1+LCwT612hcYmPRRHnLHcU9IeA8qKN5v0WTj2fCiGZY2V + XiDiLQgvJg8iy4jsn4i9eNuEGAfKRhkp6+iU3JZl9UgvFrsO+aqyGxMPOvPqbQQYEbRChCOZkjmOnejO + utNbW9ayZPSs227lpBd+U5Cplg6BkGOWjfAdkEaK5cUpOgbiOfBFsLTLVlxCV1niJSkF+x228dyMiEgA + +lD4J8vavGSAfI35AuKZZflz64Es+n08xotOifIwHCd5BlFmjBr4WnMqTQxy6/E3OOzOCw61xA+B155E + qFuN69Dv4xch7Te7SOmY6JQOhf9tWZuTDA9YtutmASJog7BnlvSsiaS6ZFMVnVEsAy+5JLykaG1WMjoC + NPqi+AiIek5s9OCS2qT6Y4rD6INpR5/jk+nJ6GPgLStZMjiG2RhlzCAXEPiCV/x+kWVW45ylOiMegpwR + Q0KlyZhrB6S1GcnYCHseGqSDI45pQXPboMdKdcXLn7JrkmnYM+Fyy5pPMjS2bTIXjRliH/z91k80KkXU + VaizWF32we654vNKWplLRoaHPCUqj/Xy+8Ll1kCpzsimm7KMyWiBlRg7BK15JONieY2w3JgB9sG6vL/+ + iVKdkUBlJz/LMuw7OBVuYVnTSsbFOnl32W8n+PqfCZdbiVLdsdLCKVGxuu2DRBnucK1pJaNiqzPzzJjR + 9eG5/xpS3bHaQnRjrG77oNN9LNzCstaXDIr1aLL3pOzTx0/g9ek1pTokAjG142V/RNM5KK0JJWNio0tq + DnfOCvTS35pSHdL5PiVSOl/+ll2J3jdvrScZEWGob4qYofVB1NrxcAtrTaku2fyTegw7HfbRcAvLGicZ + 0WmRuv+eHG6O/ptIqksgojI1bz5nCToZiTVOMh4CUvAqx4yrD5ai7gi3yEIqD1uGWb7kwI2d+CxclpVU + LnYCMq2K1XkfxBGcC7ewrDTJeAj6Sf3qcER4VsEoKs8+MXT58qtwWXZS2cgiTAcbK3cfTB2qPYPSmkkY + jSCvXcyo+mDeeTjcIhupTLV0ACwLsq8iVu4+cAiyM9OyhksGQ9BPiucZOMI6O8+zylRFB4BUPhKdsN06 + VvY+SNiSXcdsZSoZy5igH/4+y5NsVa6aOgCWBTkRN7VzduIQa2fJSDAwos9SDYxUW1muO6tc1XQASGVk + epa6LMj2be8TsFZLRkIGmtTz+vAVZJv9R2WrrQMATsZNddCyouPzKq24ZBw4mTh3LWY8fTBSeERkK5Wt + qg4AqZwsC5KQNfYMfXifgNUvGQcZdFOXmbJPR6XyVdcBIJWV1OSp7eV9AtaVklGw//y9YCRDYcNP9tt9 + VcZaOwBGbD/ulH0IjNi8T8D6tmQQhJqmZPoBOozsN/yojFV2AEjlZcWG8wFiz9IH8RpHwi2s1iVj4ICP + XwXjGEoxG35Uzpo7gDG7BYENXt6vYX1tRBwzNfQFWYCzsAgDUjmr7QCQyrxbfNp5hiGwT8C5GluXjIAU + 1JylFzOSPhhC3h5ukb1U1qo7AKRyc/xZ6hSOUZ9PMW5Vanx4XqQOHzmzvxgnksraQgeAE/edznMMgTp5 + MtzCak1qfM7wS40rzzbkt08qb/UdAFLZOcg0NYko7Xkg3MJqRWp0nEevBCNIgTj0oqTyttIBjN0tSOi3 + lwVbkhqcPH+pXwtCfovbW64yN9EBIJV/zEauL4WXBVuRGpsvxaXQ+EPhBSJBSHFSmVvqAOBJ4WVBKy41 + 9Ekx9HDPBcVuJFG5m+kAkJ5h7LLgPeEWVq1SI7OJ5P3Q6EMp2jhU9qY6AKTnGLMs6N2CtUsNfFakbiNl + ulDs8FBlb7EDYFnwrc5zDQG7OBtuYdUmNe4u8XFo7KEU7yBS+ZvrAJCe5Yig/WLPGYO/9XkOtUqNS8w/ + J84OfRmgqKCfmFT+VjsAlnovdp5tFaRNZzu4lwNrlhqYoeF5QQ78mCF0+UIUv3ecZxDNdQBIz7NXkAMg + 9qyAf4dzH0kzZrUgGlrgKWYXWd+aMctIF0Tx0jO03AHAQzxXeL4FtC9OP5KKOFloi1LDA+fOsW68/JWo + ZqOInqPZDgDpmRj1sc6/eEaG+w8KH95q/X9HgIOQL8VHggjBao721rM03QEgPRfHjLNZiK3ftLVlfVsY + heA0YEYF1TiD9CzuAL5pW8tqSzL65jsAy2pWeqndAVhWq9JL7Q7AslqVXmp3AJbVqvRSuwOwrFall9od + gGW1Kr3U7gAsq1XppXYHYFmtSi+1OwDLalV6qd0BWFar0kvtDsCyWpVeancAltWq9FK7A7CsVqWX2h2A + ZVmW1dVVV/0fpEjmdGILDGsAAAAASUVORK5CYII= + + + + 25 + + \ No newline at end of file diff --git a/imageEnhancer/MyGUI/Images/1.jpg b/imageEnhancer/MyGUI/Images/1.jpg new file mode 100644 index 0000000..6cf0dd7 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/1.jpg differ diff --git a/imageEnhancer/MyGUI/Images/104775-200.png b/imageEnhancer/MyGUI/Images/104775-200.png new file mode 100644 index 0000000..e0cab18 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/104775-200.png differ diff --git a/imageEnhancer/MyGUI/Images/2.jpg b/imageEnhancer/MyGUI/Images/2.jpg new file mode 100644 index 0000000..378ffa1 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/2.jpg differ diff --git a/imageEnhancer/MyGUI/Images/20091110-Death-Valley-534.jpg b/imageEnhancer/MyGUI/Images/20091110-Death-Valley-534.jpg new file mode 100644 index 0000000..7416548 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/20091110-Death-Valley-534.jpg differ diff --git a/imageEnhancer/MyGUI/Images/3.jpg b/imageEnhancer/MyGUI/Images/3.jpg new file mode 100644 index 0000000..1e03608 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/3.jpg differ diff --git a/imageEnhancer/MyGUI/Images/4.jpg b/imageEnhancer/MyGUI/Images/4.jpg new file mode 100644 index 0000000..6749299 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/4.jpg differ diff --git a/imageEnhancer/MyGUI/Images/5032-512.png b/imageEnhancer/MyGUI/Images/5032-512.png new file mode 100644 index 0000000..0dec55a Binary files /dev/null and b/imageEnhancer/MyGUI/Images/5032-512.png differ diff --git a/imageEnhancer/MyGUI/Images/Contrast.png b/imageEnhancer/MyGUI/Images/Contrast.png new file mode 100644 index 0000000..dfa9bb9 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/Contrast.png differ diff --git a/imageEnhancer/MyGUI/Images/EXIF/image2.jpg b/imageEnhancer/MyGUI/Images/EXIF/image2.jpg new file mode 100644 index 0000000..eb5d8ac Binary files /dev/null and b/imageEnhancer/MyGUI/Images/EXIF/image2.jpg differ diff --git a/imageEnhancer/MyGUI/Images/EXIF/image3.jpg b/imageEnhancer/MyGUI/Images/EXIF/image3.jpg new file mode 100644 index 0000000..f5663db Binary files /dev/null and b/imageEnhancer/MyGUI/Images/EXIF/image3.jpg differ diff --git a/imageEnhancer/MyGUI/Images/EXIF/image4.jpg b/imageEnhancer/MyGUI/Images/EXIF/image4.jpg new file mode 100644 index 0000000..3ca5d78 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/EXIF/image4.jpg differ diff --git a/imageEnhancer/MyGUI/Images/EXIF/image5.jpg b/imageEnhancer/MyGUI/Images/EXIF/image5.jpg new file mode 100644 index 0000000..d960f82 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/EXIF/image5.jpg differ diff --git a/imageEnhancer/MyGUI/Images/EXIF/image6.jpg b/imageEnhancer/MyGUI/Images/EXIF/image6.jpg new file mode 100644 index 0000000..a87afdd Binary files /dev/null and b/imageEnhancer/MyGUI/Images/EXIF/image6.jpg differ diff --git a/imageEnhancer/MyGUI/Images/EXIF/image7.jpg b/imageEnhancer/MyGUI/Images/EXIF/image7.jpg new file mode 100644 index 0000000..faa7981 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/EXIF/image7.jpg differ diff --git a/imageEnhancer/MyGUI/Images/PRE_S1_Jesse_walking-_MC_0044_V5x935x658-640x450.jpg b/imageEnhancer/MyGUI/Images/PRE_S1_Jesse_walking-_MC_0044_V5x935x658-640x450.jpg new file mode 100644 index 0000000..84a8d29 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/PRE_S1_Jesse_walking-_MC_0044_V5x935x658-640x450.jpg differ diff --git a/imageEnhancer/MyGUI/Images/boardwalk_thru_sand_dunes_parker_river_0909-edit.jpg b/imageEnhancer/MyGUI/Images/boardwalk_thru_sand_dunes_parker_river_0909-edit.jpg new file mode 100644 index 0000000..c031b46 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/boardwalk_thru_sand_dunes_parker_river_0909-edit.jpg differ diff --git a/imageEnhancer/MyGUI/Images/ccs-85721-0-61317600-1366599465.png b/imageEnhancer/MyGUI/Images/ccs-85721-0-61317600-1366599465.png new file mode 100644 index 0000000..34a86de Binary files /dev/null and b/imageEnhancer/MyGUI/Images/ccs-85721-0-61317600-1366599465.png differ diff --git a/imageEnhancer/MyGUI/Images/cold.jpg b/imageEnhancer/MyGUI/Images/cold.jpg new file mode 100644 index 0000000..394b02b Binary files /dev/null and b/imageEnhancer/MyGUI/Images/cold.jpg differ diff --git a/imageEnhancer/MyGUI/Images/color-chart-rgb-cmyk-256.png b/imageEnhancer/MyGUI/Images/color-chart-rgb-cmyk-256.png new file mode 100644 index 0000000..094678d Binary files /dev/null and b/imageEnhancer/MyGUI/Images/color-chart-rgb-cmyk-256.png differ diff --git a/imageEnhancer/imageEnhancer/Images/flower.jpg b/imageEnhancer/MyGUI/Images/flower.jpg similarity index 100% rename from imageEnhancer/imageEnhancer/Images/flower.jpg rename to imageEnhancer/MyGUI/Images/flower.jpg diff --git a/imageEnhancer/MyGUI/Images/hot.jpg b/imageEnhancer/MyGUI/Images/hot.jpg new file mode 100644 index 0000000..c282324 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/hot.jpg differ diff --git a/imageEnhancer/MyGUI/Images/icon=170x.png b/imageEnhancer/MyGUI/Images/icon=170x.png new file mode 100644 index 0000000..1be33c1 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/icon=170x.png differ diff --git a/imageEnhancer/MyGUI/Images/icon_noisereduction_180.jpg b/imageEnhancer/MyGUI/Images/icon_noisereduction_180.jpg new file mode 100644 index 0000000..3c32265 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/icon_noisereduction_180.jpg differ diff --git a/imageEnhancer/MyGUI/Images/import-512.png b/imageEnhancer/MyGUI/Images/import-512.png new file mode 100644 index 0000000..ba20406 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/import-512.png differ diff --git a/imageEnhancer/MyGUI/Images/import-picture-icon-38598.png b/imageEnhancer/MyGUI/Images/import-picture-icon-38598.png new file mode 100644 index 0000000..057ded9 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/import-picture-icon-38598.png differ diff --git a/imageEnhancer/MyGUI/Images/jl.jpg b/imageEnhancer/MyGUI/Images/jl.jpg new file mode 100644 index 0000000..1e1a43f Binary files /dev/null and b/imageEnhancer/MyGUI/Images/jl.jpg differ diff --git a/imageEnhancer/MyGUI/Images/long-shadow-ninja.jpg b/imageEnhancer/MyGUI/Images/long-shadow-ninja.jpg new file mode 100644 index 0000000..c463f5b Binary files /dev/null and b/imageEnhancer/MyGUI/Images/long-shadow-ninja.jpg differ diff --git a/imageEnhancer/MyGUI/Images/mediterranean-landscape.jpg b/imageEnhancer/MyGUI/Images/mediterranean-landscape.jpg new file mode 100644 index 0000000..1bc6b07 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/mediterranean-landscape.jpg differ diff --git a/imageEnhancer/MyGUI/Images/rgb-icon.svg b/imageEnhancer/MyGUI/Images/rgb-icon.svg new file mode 100644 index 0000000..c55ed87 --- /dev/null +++ b/imageEnhancer/MyGUI/Images/rgb-icon.svg @@ -0,0 +1,127 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/imageEnhancer/MyGUI/Images/sun-2-xxl.png b/imageEnhancer/MyGUI/Images/sun-2-xxl.png new file mode 100644 index 0000000..bde810e Binary files /dev/null and b/imageEnhancer/MyGUI/Images/sun-2-xxl.png differ diff --git a/imageEnhancer/MyGUI/Images/sun-hot-air-conditioner-mode-function-climate-control-256.png b/imageEnhancer/MyGUI/Images/sun-hot-air-conditioner-mode-function-climate-control-256.png new file mode 100644 index 0000000..d9ee04d Binary files /dev/null and b/imageEnhancer/MyGUI/Images/sun-hot-air-conditioner-mode-function-climate-control-256.png differ diff --git a/imageEnhancer/MyGUI/Images/vibrant-landscape.jpg b/imageEnhancer/MyGUI/Images/vibrant-landscape.jpg new file mode 100644 index 0000000..08988f7 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/vibrant-landscape.jpg differ diff --git a/imageEnhancer/MyGUI/Images/wb.jpg b/imageEnhancer/MyGUI/Images/wb.jpg new file mode 100644 index 0000000..dc19693 Binary files /dev/null and b/imageEnhancer/MyGUI/Images/wb.jpg differ diff --git a/imageEnhancer/MyGUI/MyForm.cpp b/imageEnhancer/MyGUI/MyForm.cpp new file mode 100644 index 0000000..644ac7f --- /dev/null +++ b/imageEnhancer/MyGUI/MyForm.cpp @@ -0,0 +1,14 @@ +#include "MyForm.h" + +using namespace System; +using namespace System::Windows::Forms; + +[STAThreadAttribute] + +int main(array^ args) +{ + Application::EnableVisualStyles(); + Application::SetCompatibleTextRenderingDefault(false); + MyGUI::MyForm form; + Application::Run(%form); +} diff --git a/imageEnhancer/MyGUI/MyForm.h~Stashed changes b/imageEnhancer/MyGUI/MyForm.h~Stashed changes new file mode 100644 index 0000000..8a13cbe --- /dev/null +++ b/imageEnhancer/MyGUI/MyForm.h~Stashed changes @@ -0,0 +1,3528 @@ +#pragma once + +#include +#include +#include +#include +#include "spline.h" +#include "math.h" +#include +#include +#include "exif.h" +#include "exif.cpp" +#include + +cv::Mat editedImage; +cv::Mat tempAdjusted; +cv::Mat bgrAdjusted; +cv::Mat adjRchan, adjGchan, adjBchan; + +int Sharpsigma = 0; +int Sharpweight = 0; + +std::string cameraMake = ""; +std::string cameraModel = ""; +std::string imageWidth = ""; +std::string imageHeight = ""; +std::string imageDate = ""; +std::string imageExposure = ""; +std::string imageIso = ""; + +std::string sharpningType; +std::string filterType; + + +namespace MyGUI { + + using namespace System; + using namespace System::ComponentModel; + using namespace System::Collections; + using namespace System::Windows::Forms; + using namespace System::Data; + using namespace System::Drawing; + + bool imageImport = false; + bool cropSelected = false; + bool cropStarted = false; + bool vignetteSelected = false; + + int rectSX = 0; + int rectSY = 0; + int rectWidth = 0; + int rectHeight = 0; + int vignetteCenterX = 0, vignetteCenterY = 0; + + cv::Mat cropVigImage, croppedImage, vignetteImage, cropImage; + + /// + /// Summary for MyForm + /// + private ref class MyForm : public System::Windows::Forms::Form + { + public: + MyForm(void) + { + InitializeComponent(); + // + //TODO: Add the constructor code here + // + } + + protected: + /// + /// Clean up any resources being used. + /// + ~MyForm() + { + if (components) + { + delete components; + } + } + private: System::Windows::Forms::MenuStrip^ menuStrip1; + protected: + private: System::Windows::Forms::ToolStripMenuItem^ fileToolStripMenuItem; + private: System::Windows::Forms::ToolStripMenuItem^ importToolStripMenuItem; + private: System::Windows::Forms::ToolStripMenuItem^ exportToolStripMenuItem; + + + private: System::Windows::Forms::NotifyIcon^ notifyIcon1; + private: System::Windows::Forms::Button^ loadColourAdj; + private: System::Windows::Forms::Button^ loadTempAdj; + private: System::Windows::Forms::Button^ loadLuminance; + private: System::Windows::Forms::Button^ loadContrast; + private: System::Windows::Forms::Button^ loadExposure; + private: System::Windows::Forms::Button^ loadHueSat; + private: System::Windows::Forms::TrackBar^ trackBarLuminance; + private: System::Windows::Forms::Label^ label10; + private: System::Windows::Forms::Button^ luminanceApply; + private: System::Windows::Forms::Panel^ luminancePanel; + private: System::Windows::Forms::Label^ label8; + private: System::Windows::Forms::TrackBar^ trackBarContrast; + private: System::Windows::Forms::Button^ contrastAutoAdjust; + private: System::Windows::Forms::Button^ contrastApply; + private: System::Windows::Forms::Panel^ contrastPanel; + private: System::Windows::Forms::TrackBar^ trackBar1; + private: System::Windows::Forms::Label^ label1; + private: System::Windows::Forms::Button^ tempApply; + private: System::Windows::Forms::Label^ label3; + private: System::Windows::Forms::Label^ label4; + private: System::Windows::Forms::Panel^ tempPanel; + private: System::Windows::Forms::TrackBar^ trackBarExposure; + private: System::Windows::Forms::Button^ exposureAutoAdjust; + private: System::Windows::Forms::Label^ label9; + private: System::Windows::Forms::Button^ exposureApply; + private: System::Windows::Forms::Panel^ exposurePanel; + private: System::Windows::Forms::Button^ rgbApply; + private: System::Windows::Forms::Label^ label5; + private: System::Windows::Forms::Label^ label6; + private: System::Windows::Forms::Label^ label7; + private: System::Windows::Forms::Label^ label2; + private: System::Windows::Forms::TrackBar^ redTrackBar; + private: System::Windows::Forms::TrackBar^ greenTrackBar; + private: System::Windows::Forms::TrackBar^ blueTrackBar; + private: System::Windows::Forms::Panel^ rgbPanel; + private: System::Windows::Forms::Label^ label11; + private: System::Windows::Forms::TrackBar^ trackBarHue; + private: System::Windows::Forms::Label^ label12; + private: System::Windows::Forms::TrackBar^ trackBarSaturation; + private: System::Windows::Forms::TrackBar^ trackBarValue; + private: System::Windows::Forms::Label^ label13; + private: System::Windows::Forms::Label^ label14; + private: System::Windows::Forms::Button^ valueApply; + private: System::Windows::Forms::Button^ saturationApply; + private: System::Windows::Forms::Button^ hueApply; + private: System::Windows::Forms::Panel^ hueSatPanel; + private: System::Windows::Forms::PictureBox^ RGBHist; + private: System::Windows::Forms::Label^ label15; + private: System::Windows::Forms::Button^ loadSharpen; + private: System::Windows::Forms::Panel^ sharpeningPanel; + private: System::Windows::Forms::ComboBox^ sharpeningSelect; + + + private: System::Windows::Forms::Label^ label16; + private: System::Windows::Forms::Label^ label17; + private: System::Windows::Forms::Label^ label18; + private: System::Windows::Forms::Label^ label19; + private: System::Windows::Forms::Label^ sharpninglabel; + private: System::Windows::Forms::Label^ weight; + private: System::Windows::Forms::Label^ sigmaValue; + private: System::Windows::Forms::TrackBar^ weightTrack; + private: System::Windows::Forms::TrackBar^ sigmatrack; + private: System::Windows::Forms::Button^ sharpenApply; + private: System::Windows::Forms::ToolStripMenuItem^ exitToolStripMenuItem; + + private: System::Windows::Forms::ToolStripMenuItem^ viewToolStripMenuItem; + private: System::Windows::Forms::ToolStripMenuItem^ imageMetadataToolStripMenuItem; + private: System::Windows::Forms::PictureBox^ pictureBox1; + private: System::Windows::Forms::Panel^ vignettePanel; + private: System::Windows::Forms::Label^ label20; + private: System::Windows::Forms::Button^ vignetteCancelButton; + private: System::Windows::Forms::Button^ vignetteResetButton; + private: System::Windows::Forms::Button^ vignetteApplyButton; + +private: System::Windows::Forms::Button^ loadVignette; +private: System::Windows::Forms::Button^ loadCrop; +private: System::Windows::Forms::TrackBar^ vignetteTrackBar; +private: System::Windows::Forms::Panel^ cropPanel; +private: System::Windows::Forms::Label^ label21; +private: System::Windows::Forms::Button^ cropApplyButton; +private: System::Windows::Forms::Button^ cropCancelButton; +private: System::Windows::Forms::Button^ cropResetButton; +private: System::Windows::Forms::Panel^ pnlFiltering; +private: System::Windows::Forms::Label^ lblhindredColor; +private: System::Windows::Forms::Label^ lblhundredLuma; +private: System::Windows::Forms::Label^ lblzeroColor; +private: System::Windows::Forms::Label^ lblzeroLumina; +private: System::Windows::Forms::Label^ lblColor; +private: System::Windows::Forms::Label^ lblLuminance; +private: System::Windows::Forms::Label^ lblFilterType; +private: System::Windows::Forms::Label^ lblNoiseReduction; +private: System::Windows::Forms::Button^ btnColorApply; +private: System::Windows::Forms::TrackBar^ trkBarColor; +private: System::Windows::Forms::Button^ btnLuminaApply; +private: System::Windows::Forms::TrackBar^ trkBarLumina; +private: System::Windows::Forms::ComboBox^ cmboxNoiseReduction; +private: System::Windows::Forms::Button^ loadNoiseRed; +private: System::Windows::Forms::Panel^ pnlShadowHighlights; +private: System::Windows::Forms::Label^ lblMaxHighlights; +private: System::Windows::Forms::Label^ lblMaxShadow; +private: System::Windows::Forms::Label^ lblMinHighlights; +private: System::Windows::Forms::Label^ lblMinShadow; +private: System::Windows::Forms::Label^ lblHIghlights; +private: System::Windows::Forms::Label^ lblShadow; +private: System::Windows::Forms::Label^ lblShadowHighlights; +private: System::Windows::Forms::TrackBar^ trkBarHighlights; +private: System::Windows::Forms::TrackBar^ trkBarShadow; +private: System::Windows::Forms::Button^ btnHighLightsApply; +private: System::Windows::Forms::Button^ btnShadowApply; +private: System::Windows::Forms::Button^ loadShadHighlts; +private: System::Windows::Forms::Button^ resetTemp; +private: System::Windows::Forms::Button^ autoWhiteBal; + + + + + 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) + { + this->components = (gcnew System::ComponentModel::Container()); + System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(MyForm::typeid)); + this->menuStrip1 = (gcnew System::Windows::Forms::MenuStrip()); + this->fileToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); + this->importToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); + this->exportToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); + this->exitToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); + this->viewToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); + this->imageMetadataToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); + this->notifyIcon1 = (gcnew System::Windows::Forms::NotifyIcon(this->components)); + this->loadColourAdj = (gcnew System::Windows::Forms::Button()); + this->loadTempAdj = (gcnew System::Windows::Forms::Button()); + this->loadLuminance = (gcnew System::Windows::Forms::Button()); + this->loadContrast = (gcnew System::Windows::Forms::Button()); + this->loadExposure = (gcnew System::Windows::Forms::Button()); + this->loadHueSat = (gcnew System::Windows::Forms::Button()); + this->trackBarLuminance = (gcnew System::Windows::Forms::TrackBar()); + this->label10 = (gcnew System::Windows::Forms::Label()); + this->luminanceApply = (gcnew System::Windows::Forms::Button()); + this->luminancePanel = (gcnew System::Windows::Forms::Panel()); + this->label8 = (gcnew System::Windows::Forms::Label()); + this->trackBarContrast = (gcnew System::Windows::Forms::TrackBar()); + this->contrastAutoAdjust = (gcnew System::Windows::Forms::Button()); + this->contrastApply = (gcnew System::Windows::Forms::Button()); + this->contrastPanel = (gcnew System::Windows::Forms::Panel()); + this->trackBar1 = (gcnew System::Windows::Forms::TrackBar()); + this->label1 = (gcnew System::Windows::Forms::Label()); + this->tempApply = (gcnew System::Windows::Forms::Button()); + this->label3 = (gcnew System::Windows::Forms::Label()); + this->label4 = (gcnew System::Windows::Forms::Label()); + this->tempPanel = (gcnew System::Windows::Forms::Panel()); + this->resetTemp = (gcnew System::Windows::Forms::Button()); + this->autoWhiteBal = (gcnew System::Windows::Forms::Button()); + this->trackBarExposure = (gcnew System::Windows::Forms::TrackBar()); + this->exposureAutoAdjust = (gcnew System::Windows::Forms::Button()); + this->label9 = (gcnew System::Windows::Forms::Label()); + this->exposureApply = (gcnew System::Windows::Forms::Button()); + this->exposurePanel = (gcnew System::Windows::Forms::Panel()); + this->rgbApply = (gcnew System::Windows::Forms::Button()); + this->label5 = (gcnew System::Windows::Forms::Label()); + this->label6 = (gcnew System::Windows::Forms::Label()); + this->label7 = (gcnew System::Windows::Forms::Label()); + this->label2 = (gcnew System::Windows::Forms::Label()); + this->redTrackBar = (gcnew System::Windows::Forms::TrackBar()); + this->greenTrackBar = (gcnew System::Windows::Forms::TrackBar()); + this->blueTrackBar = (gcnew System::Windows::Forms::TrackBar()); + this->rgbPanel = (gcnew System::Windows::Forms::Panel()); + this->label11 = (gcnew System::Windows::Forms::Label()); + this->trackBarHue = (gcnew System::Windows::Forms::TrackBar()); + this->label12 = (gcnew System::Windows::Forms::Label()); + this->trackBarSaturation = (gcnew System::Windows::Forms::TrackBar()); + this->trackBarValue = (gcnew System::Windows::Forms::TrackBar()); + this->label13 = (gcnew System::Windows::Forms::Label()); + this->label14 = (gcnew System::Windows::Forms::Label()); + this->valueApply = (gcnew System::Windows::Forms::Button()); + this->saturationApply = (gcnew System::Windows::Forms::Button()); + this->hueApply = (gcnew System::Windows::Forms::Button()); + this->hueSatPanel = (gcnew System::Windows::Forms::Panel()); + this->RGBHist = (gcnew System::Windows::Forms::PictureBox()); + this->label15 = (gcnew System::Windows::Forms::Label()); + this->loadSharpen = (gcnew System::Windows::Forms::Button()); + this->sharpeningPanel = (gcnew System::Windows::Forms::Panel()); + this->sharpenApply = (gcnew System::Windows::Forms::Button()); + this->sharpeningSelect = (gcnew System::Windows::Forms::ComboBox()); + this->label16 = (gcnew System::Windows::Forms::Label()); + this->label17 = (gcnew System::Windows::Forms::Label()); + this->label18 = (gcnew System::Windows::Forms::Label()); + this->label19 = (gcnew System::Windows::Forms::Label()); + this->sharpninglabel = (gcnew System::Windows::Forms::Label()); + this->weight = (gcnew System::Windows::Forms::Label()); + this->sigmaValue = (gcnew System::Windows::Forms::Label()); + this->weightTrack = (gcnew System::Windows::Forms::TrackBar()); + this->sigmatrack = (gcnew System::Windows::Forms::TrackBar()); + this->vignettePanel = (gcnew System::Windows::Forms::Panel()); + this->vignetteTrackBar = (gcnew System::Windows::Forms::TrackBar()); + this->label20 = (gcnew System::Windows::Forms::Label()); + this->vignetteCancelButton = (gcnew System::Windows::Forms::Button()); + this->vignetteResetButton = (gcnew System::Windows::Forms::Button()); + this->vignetteApplyButton = (gcnew System::Windows::Forms::Button()); + this->pictureBox1 = (gcnew System::Windows::Forms::PictureBox()); + this->loadVignette = (gcnew System::Windows::Forms::Button()); + this->loadCrop = (gcnew System::Windows::Forms::Button()); + this->cropPanel = (gcnew System::Windows::Forms::Panel()); + this->label21 = (gcnew System::Windows::Forms::Label()); + this->cropApplyButton = (gcnew System::Windows::Forms::Button()); + this->cropCancelButton = (gcnew System::Windows::Forms::Button()); + this->cropResetButton = (gcnew System::Windows::Forms::Button()); + this->pnlFiltering = (gcnew System::Windows::Forms::Panel()); + this->lblhindredColor = (gcnew System::Windows::Forms::Label()); + this->lblhundredLuma = (gcnew System::Windows::Forms::Label()); + this->lblzeroColor = (gcnew System::Windows::Forms::Label()); + this->lblzeroLumina = (gcnew System::Windows::Forms::Label()); + this->lblColor = (gcnew System::Windows::Forms::Label()); + this->lblLuminance = (gcnew System::Windows::Forms::Label()); + this->lblFilterType = (gcnew System::Windows::Forms::Label()); + this->lblNoiseReduction = (gcnew System::Windows::Forms::Label()); + this->btnColorApply = (gcnew System::Windows::Forms::Button()); + this->trkBarColor = (gcnew System::Windows::Forms::TrackBar()); + this->btnLuminaApply = (gcnew System::Windows::Forms::Button()); + this->trkBarLumina = (gcnew System::Windows::Forms::TrackBar()); + this->cmboxNoiseReduction = (gcnew System::Windows::Forms::ComboBox()); + this->loadNoiseRed = (gcnew System::Windows::Forms::Button()); + this->pnlShadowHighlights = (gcnew System::Windows::Forms::Panel()); + this->lblMaxHighlights = (gcnew System::Windows::Forms::Label()); + this->lblMaxShadow = (gcnew System::Windows::Forms::Label()); + this->lblMinHighlights = (gcnew System::Windows::Forms::Label()); + this->lblMinShadow = (gcnew System::Windows::Forms::Label()); + this->lblHIghlights = (gcnew System::Windows::Forms::Label()); + this->lblShadow = (gcnew System::Windows::Forms::Label()); + this->lblShadowHighlights = (gcnew System::Windows::Forms::Label()); + this->trkBarHighlights = (gcnew System::Windows::Forms::TrackBar()); + this->trkBarShadow = (gcnew System::Windows::Forms::TrackBar()); + this->btnHighLightsApply = (gcnew System::Windows::Forms::Button()); + this->btnShadowApply = (gcnew System::Windows::Forms::Button()); + this->loadShadHighlts = (gcnew System::Windows::Forms::Button()); + this->menuStrip1->SuspendLayout(); + (cli::safe_cast(this->trackBarLuminance))->BeginInit(); + this->luminancePanel->SuspendLayout(); + (cli::safe_cast(this->trackBarContrast))->BeginInit(); + this->contrastPanel->SuspendLayout(); + (cli::safe_cast(this->trackBar1))->BeginInit(); + this->tempPanel->SuspendLayout(); + (cli::safe_cast(this->trackBarExposure))->BeginInit(); + this->exposurePanel->SuspendLayout(); + (cli::safe_cast(this->redTrackBar))->BeginInit(); + (cli::safe_cast(this->greenTrackBar))->BeginInit(); + (cli::safe_cast(this->blueTrackBar))->BeginInit(); + this->rgbPanel->SuspendLayout(); + (cli::safe_cast(this->trackBarHue))->BeginInit(); + (cli::safe_cast(this->trackBarSaturation))->BeginInit(); + (cli::safe_cast(this->trackBarValue))->BeginInit(); + this->hueSatPanel->SuspendLayout(); + (cli::safe_cast(this->RGBHist))->BeginInit(); + this->sharpeningPanel->SuspendLayout(); + (cli::safe_cast(this->weightTrack))->BeginInit(); + (cli::safe_cast(this->sigmatrack))->BeginInit(); + this->vignettePanel->SuspendLayout(); + (cli::safe_cast(this->vignetteTrackBar))->BeginInit(); + (cli::safe_cast(this->pictureBox1))->BeginInit(); + this->cropPanel->SuspendLayout(); + this->pnlFiltering->SuspendLayout(); + (cli::safe_cast(this->trkBarColor))->BeginInit(); + (cli::safe_cast(this->trkBarLumina))->BeginInit(); + this->pnlShadowHighlights->SuspendLayout(); + (cli::safe_cast(this->trkBarHighlights))->BeginInit(); + (cli::safe_cast(this->trkBarShadow))->BeginInit(); + this->SuspendLayout(); + // + // menuStrip1 + // + this->menuStrip1->BackColor = System::Drawing::Color::SkyBlue; + this->menuStrip1->Items->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(2) { + this->fileToolStripMenuItem, + this->viewToolStripMenuItem + }); + this->menuStrip1->Location = System::Drawing::Point(0, 0); + this->menuStrip1->Name = L"menuStrip1"; + this->menuStrip1->Size = System::Drawing::Size(1350, 24); + this->menuStrip1->TabIndex = 0; + this->menuStrip1->Text = L"menuStrip1"; + // + // fileToolStripMenuItem + // + this->fileToolStripMenuItem->DropDownItems->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(3) { + this->importToolStripMenuItem, + this->exportToolStripMenuItem, this->exitToolStripMenuItem + }); + this->fileToolStripMenuItem->Name = L"fileToolStripMenuItem"; + this->fileToolStripMenuItem->Size = System::Drawing::Size(37, 20); + this->fileToolStripMenuItem->Text = L"File"; + // + // importToolStripMenuItem + // + this->importToolStripMenuItem->Image = (cli::safe_cast(resources->GetObject(L"importToolStripMenuItem.Image"))); + this->importToolStripMenuItem->Name = L"importToolStripMenuItem"; + this->importToolStripMenuItem->Size = System::Drawing::Size(110, 22); + this->importToolStripMenuItem->Text = L"Import"; + this->importToolStripMenuItem->Click += gcnew System::EventHandler(this, &MyForm::importToolStripMenuItem_Click); + // + // exportToolStripMenuItem + // + this->exportToolStripMenuItem->Image = (cli::safe_cast(resources->GetObject(L"exportToolStripMenuItem.Image"))); + this->exportToolStripMenuItem->Name = L"exportToolStripMenuItem"; + this->exportToolStripMenuItem->Size = System::Drawing::Size(110, 22); + this->exportToolStripMenuItem->Text = L"Export"; + this->exportToolStripMenuItem->Click += gcnew System::EventHandler(this, &MyForm::exportToolStripMenuItem_Click); + // + // exitToolStripMenuItem + // + this->exitToolStripMenuItem->Name = L"exitToolStripMenuItem"; + this->exitToolStripMenuItem->Size = System::Drawing::Size(110, 22); + this->exitToolStripMenuItem->Text = L"Exit"; + // + // viewToolStripMenuItem + // + this->viewToolStripMenuItem->DropDownItems->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(1) { this->imageMetadataToolStripMenuItem }); + this->viewToolStripMenuItem->Name = L"viewToolStripMenuItem"; + this->viewToolStripMenuItem->Size = System::Drawing::Size(44, 20); + this->viewToolStripMenuItem->Text = L"View"; + // + // imageMetadataToolStripMenuItem + // + this->imageMetadataToolStripMenuItem->Image = (cli::safe_cast(resources->GetObject(L"imageMetadataToolStripMenuItem.Image"))); + this->imageMetadataToolStripMenuItem->Name = L"imageMetadataToolStripMenuItem"; + this->imageMetadataToolStripMenuItem->Size = System::Drawing::Size(160, 22); + this->imageMetadataToolStripMenuItem->Text = L"Image Metadata"; + this->imageMetadataToolStripMenuItem->Click += gcnew System::EventHandler(this, &MyForm::imageMetadataToolStripMenuItem_Click); + // + // notifyIcon1 + // + this->notifyIcon1->Text = L"notifyIcon1"; + this->notifyIcon1->Visible = true; + // + // loadColourAdj + // + this->loadColourAdj->BackColor = System::Drawing::Color::DimGray; + this->loadColourAdj->BackgroundImage = (cli::safe_cast(resources->GetObject(L"loadColourAdj.BackgroundImage"))); + this->loadColourAdj->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Stretch; + this->loadColourAdj->Location = System::Drawing::Point(28, 37); + this->loadColourAdj->Name = L"loadColourAdj"; + this->loadColourAdj->Size = System::Drawing::Size(64, 64); + this->loadColourAdj->TabIndex = 9; + this->loadColourAdj->UseVisualStyleBackColor = false; + this->loadColourAdj->Click += gcnew System::EventHandler(this, &MyForm::loadColourAdj_Click); + this->loadColourAdj->MouseHover += gcnew System::EventHandler(this, &MyForm::loadColourAdj_MouseHover); + // + // loadTempAdj + // + this->loadTempAdj->BackColor = System::Drawing::Color::Yellow; + this->loadTempAdj->BackgroundImage = (cli::safe_cast(resources->GetObject(L"loadTempAdj.BackgroundImage"))); + this->loadTempAdj->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Stretch; + this->loadTempAdj->Location = System::Drawing::Point(98, 37); + this->loadTempAdj->Name = L"loadTempAdj"; + this->loadTempAdj->Size = System::Drawing::Size(64, 64); + this->loadTempAdj->TabIndex = 10; + this->loadTempAdj->UseVisualStyleBackColor = false; + this->loadTempAdj->Click += gcnew System::EventHandler(this, &MyForm::loadTempAdj_Click); + this->loadTempAdj->MouseHover += gcnew System::EventHandler(this, &MyForm::loadTempAdj_MouseHover); + // + // loadLuminance + // + this->loadLuminance->BackColor = System::Drawing::Color::CadetBlue; + this->loadLuminance->BackgroundImage = (cli::safe_cast(resources->GetObject(L"loadLuminance.BackgroundImage"))); + this->loadLuminance->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Stretch; + this->loadLuminance->Location = System::Drawing::Point(308, 37); + this->loadLuminance->Name = L"loadLuminance"; + this->loadLuminance->Size = System::Drawing::Size(64, 64); + this->loadLuminance->TabIndex = 12; + this->loadLuminance->UseVisualStyleBackColor = false; + this->loadLuminance->Click += gcnew System::EventHandler(this, &MyForm::loadLuminance_Click); + this->loadLuminance->MouseHover += gcnew System::EventHandler(this, &MyForm::loadLuminance_MouseHover); + // + // loadContrast + // + this->loadContrast->BackColor = System::Drawing::Color::White; + this->loadContrast->BackgroundImage = (cli::safe_cast(resources->GetObject(L"loadContrast.BackgroundImage"))); + this->loadContrast->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Stretch; + this->loadContrast->Location = System::Drawing::Point(168, 36); + this->loadContrast->Name = L"loadContrast"; + this->loadContrast->Size = System::Drawing::Size(64, 64); + this->loadContrast->TabIndex = 13; + this->loadContrast->UseVisualStyleBackColor = false; + this->loadContrast->Click += gcnew System::EventHandler(this, &MyForm::loadContrast_Click); + this->loadContrast->MouseHover += gcnew System::EventHandler(this, &MyForm::loadContrast_MouseHover); + // + // loadExposure + // + this->loadExposure->BackColor = System::Drawing::Color::SandyBrown; + this->loadExposure->BackgroundImage = (cli::safe_cast(resources->GetObject(L"loadExposure.BackgroundImage"))); + this->loadExposure->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Stretch; + this->loadExposure->Location = System::Drawing::Point(238, 37); + this->loadExposure->Name = L"loadExposure"; + this->loadExposure->Size = System::Drawing::Size(64, 64); + this->loadExposure->TabIndex = 15; + this->loadExposure->UseVisualStyleBackColor = false; + this->loadExposure->Click += gcnew System::EventHandler(this, &MyForm::loadExposure_Click); + this->loadExposure->MouseHover += gcnew System::EventHandler(this, &MyForm::loadExposure_MouseHover); + // + // loadHueSat + // + this->loadHueSat->BackColor = System::Drawing::Color::Crimson; + this->loadHueSat->BackgroundImage = (cli::safe_cast(resources->GetObject(L"loadHueSat.BackgroundImage"))); + this->loadHueSat->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Stretch; + this->loadHueSat->Location = System::Drawing::Point(378, 37); + this->loadHueSat->Name = L"loadHueSat"; + this->loadHueSat->Size = System::Drawing::Size(64, 64); + this->loadHueSat->TabIndex = 24; + this->loadHueSat->UseVisualStyleBackColor = false; + this->loadHueSat->Click += gcnew System::EventHandler(this, &MyForm::loadHueSat_Click); + this->loadHueSat->MouseHover += gcnew System::EventHandler(this, &MyForm::loadHueSat_MouseHover); + // + // trackBarLuminance + // + this->trackBarLuminance->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->trackBarLuminance->Location = System::Drawing::Point(39, 34); + this->trackBarLuminance->Maximum = 255; + this->trackBarLuminance->Minimum = -255; + this->trackBarLuminance->Name = L"trackBarLuminance"; + this->trackBarLuminance->Size = System::Drawing::Size(166, 45); + this->trackBarLuminance->TabIndex = 10; + this->trackBarLuminance->TickFrequency = 0; + this->trackBarLuminance->Scroll += gcnew System::EventHandler(this, &MyForm::trackBarLuminance_Scroll); + // + // label10 + // + this->label10->AutoSize = true; + this->label10->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label10->Location = System::Drawing::Point(79, 9); + this->label10->Name = L"label10"; + this->label10->Size = System::Drawing::Size(86, 20); + this->label10->TabIndex = 11; + this->label10->Text = L"Luminance"; + // + // luminanceApply + // + this->luminanceApply->Location = System::Drawing::Point(82, 66); + this->luminanceApply->Name = L"luminanceApply"; + this->luminanceApply->Size = System::Drawing::Size(80, 24); + this->luminanceApply->TabIndex = 18; + this->luminanceApply->Text = L"Apply"; + this->luminanceApply->UseVisualStyleBackColor = true; + this->luminanceApply->Click += gcnew System::EventHandler(this, &MyForm::luminanceApply_Click); + // + // luminancePanel + // + this->luminancePanel->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->luminancePanel->BorderStyle = System::Windows::Forms::BorderStyle::FixedSingle; + this->luminancePanel->Controls->Add(this->luminanceApply); + this->luminancePanel->Controls->Add(this->label10); + this->luminancePanel->Controls->Add(this->trackBarLuminance); + this->luminancePanel->Location = System::Drawing::Point(1030, 401); + this->luminancePanel->Name = L"luminancePanel"; + this->luminancePanel->Size = System::Drawing::Size(240, 108); + this->luminancePanel->TabIndex = 24; + this->luminancePanel->Visible = false; + // + // label8 + // + this->label8->AutoSize = true; + this->label8->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label8->Location = System::Drawing::Point(85, 14); + this->label8->Name = L"label8"; + this->label8->Size = System::Drawing::Size(67, 20); + this->label8->TabIndex = 5; + this->label8->Text = L"Contrast"; + // + // trackBarContrast + // + this->trackBarContrast->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->trackBarContrast->Location = System::Drawing::Point(38, 39); + this->trackBarContrast->Maximum = 100; + this->trackBarContrast->Name = L"trackBarContrast"; + this->trackBarContrast->Size = System::Drawing::Size(166, 45); + this->trackBarContrast->TabIndex = 22; + this->trackBarContrast->TickFrequency = 0; + this->trackBarContrast->Value = 50; + this->trackBarContrast->Scroll += gcnew System::EventHandler(this, &MyForm::trackBarContrast_Scroll); + // + // contrastAutoAdjust + // + this->contrastAutoAdjust->Location = System::Drawing::Point(33, 71); + this->contrastAutoAdjust->Name = L"contrastAutoAdjust"; + this->contrastAutoAdjust->Size = System::Drawing::Size(80, 24); + this->contrastAutoAdjust->TabIndex = 20; + this->contrastAutoAdjust->Text = L"Auto-Adjust"; + this->contrastAutoAdjust->UseVisualStyleBackColor = true; + this->contrastAutoAdjust->Click += gcnew System::EventHandler(this, &MyForm::contrastAutoAdjust_Click); + // + // contrastApply + // + this->contrastApply->Location = System::Drawing::Point(138, 71); + this->contrastApply->Name = L"contrastApply"; + this->contrastApply->Size = System::Drawing::Size(80, 24); + this->contrastApply->TabIndex = 17; + this->contrastApply->Text = L"Apply"; + this->contrastApply->UseVisualStyleBackColor = true; + this->contrastApply->Click += gcnew System::EventHandler(this, &MyForm::contrastApply_Click); + // + // contrastPanel + // + this->contrastPanel->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->contrastPanel->BorderStyle = System::Windows::Forms::BorderStyle::FixedSingle; + this->contrastPanel->Controls->Add(this->contrastApply); + this->contrastPanel->Controls->Add(this->contrastAutoAdjust); + this->contrastPanel->Controls->Add(this->trackBarContrast); + this->contrastPanel->Controls->Add(this->label8); + this->contrastPanel->Location = System::Drawing::Point(1027, 294); + this->contrastPanel->Name = L"contrastPanel"; + this->contrastPanel->Size = System::Drawing::Size(240, 106); + this->contrastPanel->TabIndex = 23; + this->contrastPanel->Visible = false; + // + // trackBar1 + // + this->trackBar1->Location = System::Drawing::Point(32, 43); + this->trackBar1->Maximum = 5; + this->trackBar1->Minimum = -5; + this->trackBar1->Name = L"trackBar1"; + this->trackBar1->Size = System::Drawing::Size(166, 45); + this->trackBar1->TabIndex = 2; + this->trackBar1->TickFrequency = 0; + this->trackBar1->Scroll += gcnew System::EventHandler(this, &MyForm::tempTrackBar_Scroll); + // + // label1 + // + this->label1->AutoSize = true; + this->label1->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label1->ForeColor = System::Drawing::SystemColors::ActiveCaptionText; + this->label1->Location = System::Drawing::Point(72, 16); + this->label1->Name = L"label1"; + this->label1->Size = System::Drawing::Size(105, 20); + this->label1->TabIndex = 3; + this->label1->Text = L"Temperature "; + // + // tempApply + // + this->tempApply->Location = System::Drawing::Point(143, 126); + this->tempApply->Name = L"tempApply"; + this->tempApply->Size = System::Drawing::Size(80, 24); + this->tempApply->TabIndex = 0; + this->tempApply->Text = L"Apply"; + this->tempApply->UseVisualStyleBackColor = true; + this->tempApply->Click += gcnew System::EventHandler(this, &MyForm::tempApply_Click); + // + // label3 + // + this->label3->AutoSize = true; + this->label3->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 8.25F, System::Drawing::FontStyle::Italic, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label3->ForeColor = System::Drawing::Color::Blue; + this->label3->Location = System::Drawing::Point(3, 43); + this->label3->Name = L"label3"; + this->label3->Size = System::Drawing::Size(31, 16); + this->label3->TabIndex = 5; + this->label3->Text = L"Cold"; + // + // label4 + // + this->label4->AutoSize = true; + this->label4->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 8.25F, System::Drawing::FontStyle::Italic, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label4->ForeColor = System::Drawing::Color::Red; + this->label4->Location = System::Drawing::Point(196, 43); + this->label4->Name = L"label4"; + this->label4->Size = System::Drawing::Size(37, 16); + this->label4->TabIndex = 6; + this->label4->Text = L"Warm"; + // + // tempPanel + // + this->tempPanel->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->tempPanel->BorderStyle = System::Windows::Forms::BorderStyle::FixedSingle; + this->tempPanel->Controls->Add(this->tempApply); + this->tempPanel->Controls->Add(this->resetTemp); + this->tempPanel->Controls->Add(this->autoWhiteBal); + this->tempPanel->Controls->Add(this->label4); + this->tempPanel->Controls->Add(this->trackBar1); + this->tempPanel->Controls->Add(this->label3); + this->tempPanel->Controls->Add(this->label1); + this->tempPanel->Location = System::Drawing::Point(747, 293); + this->tempPanel->Name = L"tempPanel"; + this->tempPanel->Size = System::Drawing::Size(240, 166); + this->tempPanel->TabIndex = 8; + this->tempPanel->Visible = false; + // + // resetTemp + // + this->resetTemp->Location = System::Drawing::Point(32, 126); + this->resetTemp->Name = L"resetTemp"; + this->resetTemp->Size = System::Drawing::Size(80, 24); + this->resetTemp->TabIndex = 8; + this->resetTemp->Text = L"Reset"; + this->resetTemp->UseVisualStyleBackColor = true; + this->resetTemp->Click += gcnew System::EventHandler(this, &MyForm::resetTemp_Click); + // + // autoWhiteBal + // + this->autoWhiteBal->Location = System::Drawing::Point(76, 72); + this->autoWhiteBal->Name = L"autoWhiteBal"; + this->autoWhiteBal->Size = System::Drawing::Size(80, 37); + this->autoWhiteBal->TabIndex = 7; + this->autoWhiteBal->Text = L"Auto-White Balance"; + this->autoWhiteBal->UseVisualStyleBackColor = true; + this->autoWhiteBal->Click += gcnew System::EventHandler(this, &MyForm::autoWhiteBal_Click); + // + // trackBarExposure + // + this->trackBarExposure->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->trackBarExposure->Location = System::Drawing::Point(38, 39); + this->trackBarExposure->Maximum = 100; + this->trackBarExposure->Name = L"trackBarExposure"; + this->trackBarExposure->Size = System::Drawing::Size(166, 45); + this->trackBarExposure->TabIndex = 21; + this->trackBarExposure->TickFrequency = 0; + this->trackBarExposure->Value = 50; + this->trackBarExposure->Scroll += gcnew System::EventHandler(this, &MyForm::trackBarExposure_Scroll); + // + // exposureAutoAdjust + // + this->exposureAutoAdjust->Location = System::Drawing::Point(33, 71); + this->exposureAutoAdjust->Name = L"exposureAutoAdjust"; + this->exposureAutoAdjust->Size = System::Drawing::Size(80, 24); + this->exposureAutoAdjust->TabIndex = 20; + this->exposureAutoAdjust->Text = L"Auto-Adjust"; + this->exposureAutoAdjust->UseVisualStyleBackColor = true; + this->exposureAutoAdjust->Click += gcnew System::EventHandler(this, &MyForm::exposureAutoAdjust_Click); + // + // label9 + // + this->label9->AutoSize = true; + this->label9->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label9->Location = System::Drawing::Point(78, 14); + this->label9->Name = L"label9"; + this->label9->Size = System::Drawing::Size(73, 20); + this->label9->TabIndex = 5; + this->label9->Text = L"Exposure"; + // + // exposureApply + // + this->exposureApply->Location = System::Drawing::Point(138, 71); + this->exposureApply->Name = L"exposureApply"; + this->exposureApply->Size = System::Drawing::Size(80, 24); + this->exposureApply->TabIndex = 17; + this->exposureApply->Text = L"Apply"; + this->exposureApply->UseVisualStyleBackColor = true; + this->exposureApply->Click += gcnew System::EventHandler(this, &MyForm::exposureApply_Click); + // + // exposurePanel + // + this->exposurePanel->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->exposurePanel->BorderStyle = System::Windows::Forms::BorderStyle::FixedSingle; + this->exposurePanel->Controls->Add(this->exposureApply); + this->exposurePanel->Controls->Add(this->label9); + this->exposurePanel->Controls->Add(this->exposureAutoAdjust); + this->exposurePanel->Controls->Add(this->trackBarExposure); + this->exposurePanel->Location = System::Drawing::Point(1027, 294); + this->exposurePanel->Name = L"exposurePanel"; + this->exposurePanel->Size = System::Drawing::Size(240, 106); + this->exposurePanel->TabIndex = 22; + this->exposurePanel->Visible = false; + // + // rgbApply + // + this->rgbApply->Location = System::Drawing::Point(81, 164); + this->rgbApply->Name = L"rgbApply"; + this->rgbApply->Size = System::Drawing::Size(80, 24); + this->rgbApply->TabIndex = 16; + this->rgbApply->Text = L"Apply"; + this->rgbApply->UseVisualStyleBackColor = true; + this->rgbApply->Click += gcnew System::EventHandler(this, &MyForm::rgbApply_Click); + // + // label5 + // + this->label5->AutoSize = true; + this->label5->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label5->ForeColor = System::Drawing::Color::Red; + this->label5->Location = System::Drawing::Point(199, 39); + this->label5->Name = L"label5"; + this->label5->Size = System::Drawing::Size(18, 20); + this->label5->TabIndex = 17; + this->label5->Text = L"R"; + // + // label6 + // + this->label6->AutoSize = true; + this->label6->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label6->ForeColor = System::Drawing::Color::Green; + this->label6->Location = System::Drawing::Point(198, 75); + this->label6->Name = L"label6"; + this->label6->Size = System::Drawing::Size(19, 20); + this->label6->TabIndex = 18; + this->label6->Text = L"G"; + // + // label7 + // + this->label7->AutoSize = true; + this->label7->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label7->ForeColor = System::Drawing::Color::Blue; + this->label7->Location = System::Drawing::Point(198, 113); + this->label7->Name = L"label7"; + this->label7->Size = System::Drawing::Size(18, 20); + this->label7->TabIndex = 19; + this->label7->Text = L"B"; + // + // label2 + // + this->label2->AutoSize = true; + this->label2->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label2->Location = System::Drawing::Point(88, 8); + this->label2->Name = L"label2"; + this->label2->Size = System::Drawing::Size(53, 20); + this->label2->TabIndex = 4; + this->label2->Text = L"Colour"; + // + // redTrackBar + // + this->redTrackBar->Location = System::Drawing::Point(27, 39); + this->redTrackBar->Maximum = 20; + this->redTrackBar->Minimum = 1; + this->redTrackBar->Name = L"redTrackBar"; + this->redTrackBar->Size = System::Drawing::Size(166, 45); + this->redTrackBar->TabIndex = 13; + this->redTrackBar->TickFrequency = 0; + this->redTrackBar->Value = 10; + this->redTrackBar->Scroll += gcnew System::EventHandler(this, &MyForm::redTrackBar_Scroll); + // + // greenTrackBar + // + this->greenTrackBar->Location = System::Drawing::Point(27, 74); + this->greenTrackBar->Maximum = 20; + this->greenTrackBar->Minimum = 1; + this->greenTrackBar->Name = L"greenTrackBar"; + this->greenTrackBar->Size = System::Drawing::Size(166, 45); + this->greenTrackBar->TabIndex = 14; + this->greenTrackBar->TickFrequency = 0; + this->greenTrackBar->Value = 10; + this->greenTrackBar->Scroll += gcnew System::EventHandler(this, &MyForm::greenTrackBar_Scroll); + // + // blueTrackBar + // + this->blueTrackBar->Location = System::Drawing::Point(27, 113); + this->blueTrackBar->Maximum = 20; + this->blueTrackBar->Minimum = 1; + this->blueTrackBar->Name = L"blueTrackBar"; + this->blueTrackBar->Size = System::Drawing::Size(166, 45); + this->blueTrackBar->TabIndex = 15; + this->blueTrackBar->TickFrequency = 0; + this->blueTrackBar->Value = 10; + this->blueTrackBar->Scroll += gcnew System::EventHandler(this, &MyForm::blueTrackBar_Scroll); + // + // rgbPanel + // + this->rgbPanel->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->rgbPanel->BorderStyle = System::Windows::Forms::BorderStyle::FixedSingle; + this->rgbPanel->Controls->Add(this->blueTrackBar); + this->rgbPanel->Controls->Add(this->greenTrackBar); + this->rgbPanel->Controls->Add(this->redTrackBar); + this->rgbPanel->Controls->Add(this->label2); + this->rgbPanel->Controls->Add(this->label7); + this->rgbPanel->Controls->Add(this->label6); + this->rgbPanel->Controls->Add(this->label5); + this->rgbPanel->Controls->Add(this->rgbApply); + this->rgbPanel->Location = System::Drawing::Point(747, 293); + this->rgbPanel->Name = L"rgbPanel"; + this->rgbPanel->Size = System::Drawing::Size(240, 216); + this->rgbPanel->TabIndex = 11; + this->rgbPanel->Visible = false; + // + // label11 + // + this->label11->AutoSize = true; + this->label11->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label11->Location = System::Drawing::Point(99, 16); + this->label11->Name = L"label11"; + this->label11->Size = System::Drawing::Size(115, 20); + this->label11->TabIndex = 4; + this->label11->Text = L"Hue/Saturation"; + // + // trackBarHue + // + this->trackBarHue->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->trackBarHue->Location = System::Drawing::Point(40, 47); + this->trackBarHue->Maximum = 360; + this->trackBarHue->Minimum = -360; + this->trackBarHue->Name = L"trackBarHue"; + this->trackBarHue->Size = System::Drawing::Size(166, 45); + this->trackBarHue->TabIndex = 31; + this->trackBarHue->TickFrequency = 0; + this->trackBarHue->Scroll += gcnew System::EventHandler(this, &MyForm::trackBarHue_Scroll); + // + // label12 + // + this->label12->AutoSize = true; + this->label12->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 9.75F, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label12->Location = System::Drawing::Point(212, 47); + this->label12->Name = L"label12"; + this->label12->Size = System::Drawing::Size(31, 18); + this->label12->TabIndex = 32; + this->label12->Text = L"Hue"; + this->label12->TextAlign = System::Drawing::ContentAlignment::MiddleCenter; + // + // trackBarSaturation + // + this->trackBarSaturation->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->trackBarSaturation->Location = System::Drawing::Point(40, 124); + this->trackBarSaturation->Maximum = 255; + this->trackBarSaturation->Minimum = -255; + this->trackBarSaturation->Name = L"trackBarSaturation"; + this->trackBarSaturation->Size = System::Drawing::Size(166, 45); + this->trackBarSaturation->TabIndex = 37; + this->trackBarSaturation->TickFrequency = 0; + this->trackBarSaturation->Scroll += gcnew System::EventHandler(this, &MyForm::trackBarSaturation_Scroll); + // + // trackBarValue + // + this->trackBarValue->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->trackBarValue->Location = System::Drawing::Point(40, 205); + this->trackBarValue->Maximum = 255; + this->trackBarValue->Minimum = -255; + this->trackBarValue->Name = L"trackBarValue"; + this->trackBarValue->Size = System::Drawing::Size(166, 45); + this->trackBarValue->TabIndex = 38; + this->trackBarValue->TickFrequency = 0; + this->trackBarValue->Scroll += gcnew System::EventHandler(this, &MyForm::trackBarValue_Scroll); + // + // label13 + // + this->label13->AutoSize = true; + this->label13->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 9.75F, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label13->Location = System::Drawing::Point(212, 124); + this->label13->Name = L"label13"; + this->label13->Size = System::Drawing::Size(69, 18); + this->label13->TabIndex = 39; + this->label13->Text = L"Saturation"; + this->label13->TextAlign = System::Drawing::ContentAlignment::MiddleCenter; + // + // label14 + // + this->label14->AutoSize = true; + this->label14->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 9.75F, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label14->Location = System::Drawing::Point(212, 204); + this->label14->Name = L"label14"; + this->label14->Size = System::Drawing::Size(38, 18); + this->label14->TabIndex = 40; + this->label14->Text = L"Value"; + this->label14->TextAlign = System::Drawing::ContentAlignment::MiddleCenter; + // + // valueApply + // + this->valueApply->Location = System::Drawing::Point(86, 245); + this->valueApply->Name = L"valueApply"; + this->valueApply->Size = System::Drawing::Size(80, 24); + this->valueApply->TabIndex = 16; + this->valueApply->Text = L"Apply"; + this->valueApply->UseVisualStyleBackColor = true; + this->valueApply->Click += gcnew System::EventHandler(this, &MyForm::valueApply_Click); + // + // saturationApply + // + this->saturationApply->Location = System::Drawing::Point(86, 161); + this->saturationApply->Name = L"saturationApply"; + this->saturationApply->Size = System::Drawing::Size(80, 24); + this->saturationApply->TabIndex = 41; + this->saturationApply->Text = L"Apply"; + this->saturationApply->UseVisualStyleBackColor = true; + this->saturationApply->Click += gcnew System::EventHandler(this, &MyForm::saturationApply_Click); + // + // hueApply + // + this->hueApply->Location = System::Drawing::Point(86, 78); + this->hueApply->Name = L"hueApply"; + this->hueApply->Size = System::Drawing::Size(80, 24); + this->hueApply->TabIndex = 42; + this->hueApply->Text = L"Apply"; + this->hueApply->UseVisualStyleBackColor = true; + this->hueApply->Click += gcnew System::EventHandler(this, &MyForm::hueApply_Click); + // + // hueSatPanel + // + this->hueSatPanel->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->hueSatPanel->BorderStyle = System::Windows::Forms::BorderStyle::FixedSingle; + this->hueSatPanel->Controls->Add(this->hueApply); + this->hueSatPanel->Controls->Add(this->saturationApply); + this->hueSatPanel->Controls->Add(this->valueApply); + this->hueSatPanel->Controls->Add(this->label14); + this->hueSatPanel->Controls->Add(this->label13); + this->hueSatPanel->Controls->Add(this->trackBarValue); + this->hueSatPanel->Controls->Add(this->trackBarSaturation); + this->hueSatPanel->Controls->Add(this->label12); + this->hueSatPanel->Controls->Add(this->trackBarHue); + this->hueSatPanel->Controls->Add(this->label11); + this->hueSatPanel->Location = System::Drawing::Point(719, 293); + this->hueSatPanel->Name = L"hueSatPanel"; + this->hueSatPanel->Size = System::Drawing::Size(309, 287); + this->hueSatPanel->TabIndex = 25; + this->hueSatPanel->Visible = false; + // + // RGBHist + // + this->RGBHist->BackColor = System::Drawing::Color::White; + this->RGBHist->Location = System::Drawing::Point(904, 75); + this->RGBHist->Margin = System::Windows::Forms::Padding(2); + this->RGBHist->Name = L"RGBHist"; + this->RGBHist->Size = System::Drawing::Size(400, 156); + this->RGBHist->TabIndex = 26; + this->RGBHist->TabStop = false; + // + // label15 + // + this->label15->AutoSize = true; + this->label15->Cursor = System::Windows::Forms::Cursors::Default; + this->label15->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label15->Location = System::Drawing::Point(1066, 49); + this->label15->Margin = System::Windows::Forms::Padding(2, 0, 2, 0); + this->label15->Name = L"label15"; + this->label15->Size = System::Drawing::Size(78, 20); + this->label15->TabIndex = 27; + this->label15->Text = L"Histogram"; + // + // loadSharpen + // + this->loadSharpen->BackColor = System::Drawing::Color::LimeGreen; + this->loadSharpen->BackgroundImage = (cli::safe_cast(resources->GetObject(L"loadSharpen.BackgroundImage"))); + this->loadSharpen->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Stretch; + this->loadSharpen->Location = System::Drawing::Point(448, 37); + this->loadSharpen->Name = L"loadSharpen"; + this->loadSharpen->Size = System::Drawing::Size(64, 64); + this->loadSharpen->TabIndex = 28; + this->loadSharpen->UseVisualStyleBackColor = false; + this->loadSharpen->Click += gcnew System::EventHandler(this, &MyForm::loadSharpen_Click); + this->loadSharpen->MouseHover += gcnew System::EventHandler(this, &MyForm::loadSharpen_MouseHover); + // + // sharpeningPanel + // + this->sharpeningPanel->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->sharpeningPanel->BorderStyle = System::Windows::Forms::BorderStyle::FixedSingle; + this->sharpeningPanel->Controls->Add(this->sharpenApply); + this->sharpeningPanel->Controls->Add(this->sharpeningSelect); + this->sharpeningPanel->Controls->Add(this->label16); + this->sharpeningPanel->Controls->Add(this->label17); + this->sharpeningPanel->Controls->Add(this->label18); + this->sharpeningPanel->Controls->Add(this->label19); + this->sharpeningPanel->Controls->Add(this->sharpninglabel); + this->sharpeningPanel->Controls->Add(this->weight); + this->sharpeningPanel->Controls->Add(this->sigmaValue); + this->sharpeningPanel->Controls->Add(this->weightTrack); + this->sharpeningPanel->Controls->Add(this->sigmatrack); + this->sharpeningPanel->Location = System::Drawing::Point(1031, 293); + this->sharpeningPanel->Margin = System::Windows::Forms::Padding(2); + this->sharpeningPanel->Name = L"sharpeningPanel"; + this->sharpeningPanel->Size = System::Drawing::Size(273, 221); + this->sharpeningPanel->TabIndex = 29; + this->sharpeningPanel->Visible = false; + // + // sharpenApply + // + this->sharpenApply->Location = System::Drawing::Point(98, 183); + this->sharpenApply->Name = L"sharpenApply"; + this->sharpenApply->Size = System::Drawing::Size(80, 24); + this->sharpenApply->TabIndex = 7; + this->sharpenApply->Text = L"Apply"; + this->sharpenApply->UseVisualStyleBackColor = true; + this->sharpenApply->Click += gcnew System::EventHandler(this, &MyForm::sharpenApply_Click); + // + // sharpeningSelect + // + this->sharpeningSelect->BackColor = System::Drawing::SystemColors::ScrollBar; + this->sharpeningSelect->FormattingEnabled = true; + this->sharpeningSelect->Items->AddRange(gcnew cli::array< System::Object^ >(2) { L"Gaussian", L"Luminance" }); + this->sharpeningSelect->Location = System::Drawing::Point(59, 37); + this->sharpeningSelect->Margin = System::Windows::Forms::Padding(2); + this->sharpeningSelect->Name = L"sharpeningSelect"; + this->sharpeningSelect->Size = System::Drawing::Size(155, 21); + this->sharpeningSelect->TabIndex = 12; + this->sharpeningSelect->SelectedIndexChanged += gcnew System::EventHandler(this, &MyForm::sharpeningSelect_SelectedIndexChanged); + // + // label16 + // + this->label16->AutoSize = true; + this->label16->Location = System::Drawing::Point(195, 167); + this->label16->Margin = System::Windows::Forms::Padding(2, 0, 2, 0); + this->label16->Name = L"label16"; + this->label16->Size = System::Drawing::Size(19, 13); + this->label16->TabIndex = 8; + this->label16->Text = L"10"; + // + // label17 + // + this->label17->AutoSize = true; + this->label17->Location = System::Drawing::Point(195, 107); + this->label17->Margin = System::Windows::Forms::Padding(2, 0, 2, 0); + this->label17->Name = L"label17"; + this->label17->Size = System::Drawing::Size(19, 13); + this->label17->TabIndex = 7; + this->label17->Text = L"16"; + // + // label18 + // + this->label18->AutoSize = true; + this->label18->Location = System::Drawing::Point(52, 167); + this->label18->Margin = System::Windows::Forms::Padding(2, 0, 2, 0); + this->label18->Name = L"label18"; + this->label18->Size = System::Drawing::Size(13, 13); + this->label18->TabIndex = 6; + this->label18->Text = L"0"; + // + // label19 + // + this->label19->AutoSize = true; + this->label19->Location = System::Drawing::Point(52, 107); + this->label19->Margin = System::Windows::Forms::Padding(2, 0, 2, 0); + this->label19->Name = L"label19"; + this->label19->Size = System::Drawing::Size(13, 13); + this->label19->TabIndex = 5; + this->label19->Text = L"0"; + // + // sharpninglabel + // + this->sharpninglabel->AutoSize = true; + this->sharpninglabel->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->sharpninglabel->Location = System::Drawing::Point(103, 7); + this->sharpninglabel->Margin = System::Windows::Forms::Padding(2, 0, 2, 0); + this->sharpninglabel->Name = L"sharpninglabel"; + this->sharpninglabel->Size = System::Drawing::Size(79, 20); + this->sharpninglabel->TabIndex = 4; + this->sharpninglabel->Text = L"Sharpness"; + // + // weight + // + this->weight->AutoSize = true; + this->weight->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 9.75F, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->weight->Location = System::Drawing::Point(117, 122); + this->weight->Margin = System::Windows::Forms::Padding(2, 0, 2, 0); + this->weight->Name = L"weight"; + this->weight->Size = System::Drawing::Size(49, 18); + this->weight->TabIndex = 3; + this->weight->Text = L"Weight"; + // + // sigmaValue + // + this->sigmaValue->AutoSize = true; + this->sigmaValue->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 9.75F, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->sigmaValue->Location = System::Drawing::Point(120, 69); + this->sigmaValue->Margin = System::Windows::Forms::Padding(2, 0, 2, 0); + this->sigmaValue->Name = L"sigmaValue"; + this->sigmaValue->Size = System::Drawing::Size(44, 18); + this->sigmaValue->TabIndex = 2; + this->sigmaValue->Text = L"Sigma"; + // + // weightTrack + // + this->weightTrack->Location = System::Drawing::Point(55, 142); + this->weightTrack->Margin = System::Windows::Forms::Padding(2); + this->weightTrack->Name = L"weightTrack"; + this->weightTrack->Size = System::Drawing::Size(166, 45); + this->weightTrack->TabIndex = 1; + this->weightTrack->TickFrequency = 0; + this->weightTrack->Scroll += gcnew System::EventHandler(this, &MyForm::weightTrack_Scroll); + // + // sigmatrack + // + this->sigmatrack->Location = System::Drawing::Point(55, 85); + this->sigmatrack->Margin = System::Windows::Forms::Padding(2); + this->sigmatrack->Maximum = 16; + this->sigmatrack->Name = L"sigmatrack"; + this->sigmatrack->Size = System::Drawing::Size(166, 45); + this->sigmatrack->TabIndex = 0; + this->sigmatrack->TickFrequency = 0; + this->sigmatrack->Scroll += gcnew System::EventHandler(this, &MyForm::sigmatrack_Scroll); + // + // vignettePanel + // + this->vignettePanel->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->vignettePanel->BorderStyle = System::Windows::Forms::BorderStyle::FixedSingle; + this->vignettePanel->Controls->Add(this->vignetteTrackBar); + this->vignettePanel->Controls->Add(this->label20); + this->vignettePanel->Controls->Add(this->vignetteCancelButton); + this->vignettePanel->Controls->Add(this->vignetteResetButton); + this->vignettePanel->Controls->Add(this->vignetteApplyButton); + this->vignettePanel->Location = System::Drawing::Point(735, 293); + this->vignettePanel->Name = L"vignettePanel"; + this->vignettePanel->Size = System::Drawing::Size(264, 149); + this->vignettePanel->TabIndex = 30; + this->vignettePanel->Tag = L"Vignette "; + this->vignettePanel->Visible = false; + // + // vignetteTrackBar + // + this->vignetteTrackBar->LargeChange = 1; + this->vignetteTrackBar->Location = System::Drawing::Point(27, 47); + this->vignetteTrackBar->Maximum = 100; + this->vignetteTrackBar->Name = L"vignetteTrackBar"; + this->vignetteTrackBar->Size = System::Drawing::Size(209, 45); + this->vignetteTrackBar->TabIndex = 200; + this->vignetteTrackBar->TickFrequency = 0; + this->vignetteTrackBar->Value = 50; + this->vignetteTrackBar->ValueChanged += gcnew System::EventHandler(this, &MyForm::vignetteTrackBar_ValueChanged); + // + // label20 + // + this->label20->AutoSize = true; + this->label20->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label20->Location = System::Drawing::Point(95, 14); + this->label20->Margin = System::Windows::Forms::Padding(2, 0, 2, 0); + this->label20->Name = L"label20"; + this->label20->Size = System::Drawing::Size(69, 20); + this->label20->TabIndex = 203; + this->label20->Text = L"Vignette"; + // + // vignetteCancelButton + // + this->vignetteCancelButton->Location = System::Drawing::Point(14, 104); + this->vignetteCancelButton->Name = L"vignetteCancelButton"; + this->vignetteCancelButton->Size = System::Drawing::Size(71, 23); + this->vignetteCancelButton->TabIndex = 202; + this->vignetteCancelButton->Text = L"Cancel"; + this->vignetteCancelButton->UseVisualStyleBackColor = true; + this->vignetteCancelButton->Click += gcnew System::EventHandler(this, &MyForm::vignetteCancelButton_Click); + // + // vignetteResetButton + // + this->vignetteResetButton->Location = System::Drawing::Point(95, 104); + this->vignetteResetButton->Name = L"vignetteResetButton"; + this->vignetteResetButton->Size = System::Drawing::Size(75, 23); + this->vignetteResetButton->TabIndex = 201; + this->vignetteResetButton->Text = L"Reset"; + this->vignetteResetButton->UseVisualStyleBackColor = true; + this->vignetteResetButton->Click += gcnew System::EventHandler(this, &MyForm::vignetteResetButton_Click); + // + // vignetteApplyButton + // + this->vignetteApplyButton->Location = System::Drawing::Point(176, 104); + this->vignetteApplyButton->Name = L"vignetteApplyButton"; + this->vignetteApplyButton->Size = System::Drawing::Size(75, 23); + this->vignetteApplyButton->TabIndex = 1; + this->vignetteApplyButton->Text = L"Apply"; + this->vignetteApplyButton->UseVisualStyleBackColor = true; + this->vignetteApplyButton->Click += gcnew System::EventHandler(this, &MyForm::vignetteApplyButton_Click); + // + // pictureBox1 + // + this->pictureBox1->BackColor = System::Drawing::SystemColors::ControlLightLight; + this->pictureBox1->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Center; + this->pictureBox1->BorderStyle = System::Windows::Forms::BorderStyle::FixedSingle; + this->pictureBox1->Location = System::Drawing::Point(28, 119); + this->pictureBox1->Name = L"pictureBox1"; + this->pictureBox1->Size = System::Drawing::Size(640, 480); + this->pictureBox1->TabIndex = 1; + this->pictureBox1->TabStop = false; + this->pictureBox1->MouseClick += gcnew System::Windows::Forms::MouseEventHandler(this, &MyForm::pictureBox1_MouseClick); + this->pictureBox1->MouseDown += gcnew System::Windows::Forms::MouseEventHandler(this, &MyForm::pictureBox1_MouseDown); + this->pictureBox1->MouseMove += gcnew System::Windows::Forms::MouseEventHandler(this, &MyForm::pictureBox1_MouseMove); + this->pictureBox1->MouseUp += gcnew System::Windows::Forms::MouseEventHandler(this, &MyForm::pictureBox1_MouseUp); + // + // loadVignette + // + this->loadVignette->BackColor = System::Drawing::Color::Orange; + this->loadVignette->BackgroundImage = (cli::safe_cast(resources->GetObject(L"loadVignette.BackgroundImage"))); + this->loadVignette->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Stretch; + this->loadVignette->Location = System::Drawing::Point(518, 38); + this->loadVignette->Name = L"loadVignette"; + this->loadVignette->Size = System::Drawing::Size(64, 64); + this->loadVignette->TabIndex = 30; + this->loadVignette->UseVisualStyleBackColor = false; + this->loadVignette->Click += gcnew System::EventHandler(this, &MyForm::loadVignette_Click); + this->loadVignette->MouseHover += gcnew System::EventHandler(this, &MyForm::loadVignette_MouseHover); + // + // loadCrop + // + this->loadCrop->BackColor = System::Drawing::Color::Orange; + this->loadCrop->BackgroundImage = (cli::safe_cast(resources->GetObject(L"loadCrop.BackgroundImage"))); + this->loadCrop->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Stretch; + this->loadCrop->Location = System::Drawing::Point(588, 37); + this->loadCrop->Name = L"loadCrop"; + this->loadCrop->Size = System::Drawing::Size(64, 64); + this->loadCrop->TabIndex = 31; + this->loadCrop->UseVisualStyleBackColor = false; + this->loadCrop->Click += gcnew System::EventHandler(this, &MyForm::loadCrop_Click); + this->loadCrop->MouseHover += gcnew System::EventHandler(this, &MyForm::loadCrop_MouseHover); + // + // cropPanel + // + this->cropPanel->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->cropPanel->BorderStyle = System::Windows::Forms::BorderStyle::FixedSingle; + this->cropPanel->Controls->Add(this->label21); + this->cropPanel->Controls->Add(this->cropApplyButton); + this->cropPanel->Controls->Add(this->cropCancelButton); + this->cropPanel->Controls->Add(this->cropResetButton); + this->cropPanel->Cursor = System::Windows::Forms::Cursors::Arrow; + this->cropPanel->Location = System::Drawing::Point(89, 616); + this->cropPanel->Name = L"cropPanel"; + this->cropPanel->Size = System::Drawing::Size(264, 80); + this->cropPanel->TabIndex = 32; + this->cropPanel->Visible = false; + // + // label21 + // + this->label21->AutoSize = true; + this->label21->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label21->Location = System::Drawing::Point(93, 10); + this->label21->Margin = System::Windows::Forms::Padding(2, 0, 2, 0); + this->label21->Name = L"label21"; + this->label21->Size = System::Drawing::Size(88, 20); + this->label21->TabIndex = 7; + this->label21->Text = L"Crop Image"; + // + // cropApplyButton + // + this->cropApplyButton->Location = System::Drawing::Point(178, 40); + this->cropApplyButton->Name = L"cropApplyButton"; + this->cropApplyButton->Size = System::Drawing::Size(75, 23); + this->cropApplyButton->TabIndex = 6; + this->cropApplyButton->Text = L"Apply"; + this->cropApplyButton->UseVisualStyleBackColor = true; + this->cropApplyButton->Click += gcnew System::EventHandler(this, &MyForm::cropApplyButton_Click); + // + // cropCancelButton + // + this->cropCancelButton->Location = System::Drawing::Point(16, 40); + this->cropCancelButton->Name = L"cropCancelButton"; + this->cropCancelButton->Size = System::Drawing::Size(75, 23); + this->cropCancelButton->TabIndex = 5; + this->cropCancelButton->Text = L"Cancel"; + this->cropCancelButton->UseVisualStyleBackColor = true; + this->cropCancelButton->Click += gcnew System::EventHandler(this, &MyForm::cropCancelButton_Click); + // + // cropResetButton + // + this->cropResetButton->Location = System::Drawing::Point(97, 40); + this->cropResetButton->Name = L"cropResetButton"; + this->cropResetButton->Size = System::Drawing::Size(75, 23); + this->cropResetButton->TabIndex = 4; + this->cropResetButton->Text = L"Reset"; + this->cropResetButton->UseVisualStyleBackColor = true; + this->cropResetButton->Click += gcnew System::EventHandler(this, &MyForm::cropResetButton_Click); + // + // pnlFiltering + // + this->pnlFiltering->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->pnlFiltering->BorderStyle = System::Windows::Forms::BorderStyle::FixedSingle; + this->pnlFiltering->Controls->Add(this->lblzeroColor); + this->pnlFiltering->Controls->Add(this->lblzeroLumina); + this->pnlFiltering->Controls->Add(this->lblColor); + this->pnlFiltering->Controls->Add(this->lblLuminance); + this->pnlFiltering->Controls->Add(this->lblFilterType); + this->pnlFiltering->Controls->Add(this->lblNoiseReduction); + this->pnlFiltering->Controls->Add(this->btnColorApply); + this->pnlFiltering->Controls->Add(this->trkBarColor); + this->pnlFiltering->Controls->Add(this->btnLuminaApply); + this->pnlFiltering->Controls->Add(this->trkBarLumina); + this->pnlFiltering->Controls->Add(this->cmboxNoiseReduction); + this->pnlFiltering->Controls->Add(this->lblhundredLuma); + this->pnlFiltering->Controls->Add(this->lblhindredColor); + this->pnlFiltering->Location = System::Drawing::Point(738, 294); + this->pnlFiltering->Name = L"pnlFiltering"; + this->pnlFiltering->Size = System::Drawing::Size(258, 259); + this->pnlFiltering->TabIndex = 33; + this->pnlFiltering->Visible = false; + // + // lblhindredColor + // + this->lblhindredColor->AutoSize = true; + this->lblhindredColor->Location = System::Drawing::Point(228, 202); + this->lblhindredColor->Name = L"lblhindredColor"; + this->lblhindredColor->Size = System::Drawing::Size(25, 13); + this->lblhindredColor->TabIndex = 19; + this->lblhindredColor->Text = L"100"; + // + // lblhundredLuma + // + this->lblhundredLuma->AutoSize = true; + this->lblhundredLuma->Location = System::Drawing::Point(228, 99); + this->lblhundredLuma->Name = L"lblhundredLuma"; + this->lblhundredLuma->Size = System::Drawing::Size(25, 13); + this->lblhundredLuma->TabIndex = 18; + this->lblhundredLuma->Text = L"100"; + // + // lblzeroColor + // + this->lblzeroColor->AutoSize = true; + this->lblzeroColor->Location = System::Drawing::Point(6, 197); + this->lblzeroColor->Name = L"lblzeroColor"; + this->lblzeroColor->Size = System::Drawing::Size(13, 13); + this->lblzeroColor->TabIndex = 17; + this->lblzeroColor->Text = L"0"; + // + // lblzeroLumina + // + this->lblzeroLumina->AutoSize = true; + this->lblzeroLumina->Location = System::Drawing::Point(6, 99); + this->lblzeroLumina->Name = L"lblzeroLumina"; + this->lblzeroLumina->Size = System::Drawing::Size(13, 13); + this->lblzeroLumina->TabIndex = 14; + this->lblzeroLumina->Text = L"0"; + // + // lblColor + // + this->lblColor->AutoSize = true; + this->lblColor->Location = System::Drawing::Point(112, 176); + this->lblColor->Name = L"lblColor"; + this->lblColor->Size = System::Drawing::Size(31, 13); + this->lblColor->TabIndex = 16; + this->lblColor->Text = L"Color"; + // + // lblLuminance + // + this->lblLuminance->AutoSize = true; + this->lblLuminance->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 9, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->lblLuminance->Location = System::Drawing::Point(98, 80); + this->lblLuminance->Name = L"lblLuminance"; + this->lblLuminance->Size = System::Drawing::Size(67, 18); + this->lblLuminance->TabIndex = 15; + this->lblLuminance->Text = L"Luminance"; + // + // lblFilterType + // + this->lblFilterType->AutoSize = true; + this->lblFilterType->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 9, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->lblFilterType->Location = System::Drawing::Point(13, 30); + this->lblFilterType->Name = L"lblFilterType"; + this->lblFilterType->Size = System::Drawing::Size(67, 18); + this->lblFilterType->TabIndex = 14; + this->lblFilterType->Text = L"Filter Type"; + // + // lblNoiseReduction + // + this->lblNoiseReduction->AutoSize = true; + this->lblNoiseReduction->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->lblNoiseReduction->Location = System::Drawing::Point(72, 9); + this->lblNoiseReduction->Name = L"lblNoiseReduction"; + this->lblNoiseReduction->Size = System::Drawing::Size(122, 20); + this->lblNoiseReduction->TabIndex = 13; + this->lblNoiseReduction->Text = L"Noise Reduction"; + // + // btnColorApply + // + this->btnColorApply->Location = System::Drawing::Point(91, 218); + this->btnColorApply->Name = L"btnColorApply"; + this->btnColorApply->Size = System::Drawing::Size(80, 24); + this->btnColorApply->TabIndex = 12; + this->btnColorApply->Text = L"Apply"; + this->btnColorApply->UseVisualStyleBackColor = true; + this->btnColorApply->Click += gcnew System::EventHandler(this, &MyForm::btnColorApply_Click); + // + // trkBarColor + // + this->trkBarColor->Location = System::Drawing::Point(19, 197); + this->trkBarColor->Name = L"trkBarColor"; + this->trkBarColor->Size = System::Drawing::Size(208, 45); + this->trkBarColor->TabIndex = 11; + this->trkBarColor->TickFrequency = 0; + this->trkBarColor->Scroll += gcnew System::EventHandler(this, &MyForm::trkBarColor_Scroll); + // + // btnLuminaApply + // + this->btnLuminaApply->Location = System::Drawing::Point(91, 120); + this->btnLuminaApply->Name = L"btnLuminaApply"; + this->btnLuminaApply->Size = System::Drawing::Size(80, 24); + this->btnLuminaApply->TabIndex = 1; + this->btnLuminaApply->Text = L"Apply"; + this->btnLuminaApply->UseVisualStyleBackColor = true; + this->btnLuminaApply->Click += gcnew System::EventHandler(this, &MyForm::btnLuminaApply_Click); + // + // trkBarLumina + // + this->trkBarLumina->Location = System::Drawing::Point(19, 99); + this->trkBarLumina->Name = L"trkBarLumina"; + this->trkBarLumina->Size = System::Drawing::Size(208, 45); + this->trkBarLumina->TabIndex = 10; + this->trkBarLumina->TickFrequency = 0; + this->trkBarLumina->Scroll += gcnew System::EventHandler(this, &MyForm::trkBarLumina_Scroll); + // + // cmboxNoiseReduction + // + this->cmboxNoiseReduction->FormattingEnabled = true; + this->cmboxNoiseReduction->Items->AddRange(gcnew cli::array< System::Object^ >(4) { L"Box", L"Gaussian", L"Median", L"" }); + this->cmboxNoiseReduction->Location = System::Drawing::Point(9, 50); + this->cmboxNoiseReduction->Name = L"cmboxNoiseReduction"; + this->cmboxNoiseReduction->Size = System::Drawing::Size(218, 21); + this->cmboxNoiseReduction->TabIndex = 0; + this->cmboxNoiseReduction->SelectedIndexChanged += gcnew System::EventHandler(this, &MyForm::cmboxNoiseReduction_SelectedIndexChanged); + // + // loadNoiseRed + // + this->loadNoiseRed->BackColor = System::Drawing::Color::Orange; + this->loadNoiseRed->BackgroundImage = (cli::safe_cast(resources->GetObject(L"loadNoiseRed.BackgroundImage"))); + this->loadNoiseRed->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Stretch; + this->loadNoiseRed->Location = System::Drawing::Point(658, 37); + this->loadNoiseRed->Name = L"loadNoiseRed"; + this->loadNoiseRed->Size = System::Drawing::Size(64, 64); + this->loadNoiseRed->TabIndex = 34; + this->loadNoiseRed->UseVisualStyleBackColor = false; + this->loadNoiseRed->Click += gcnew System::EventHandler(this, &MyForm::loadNoiseRed_Click); + this->loadNoiseRed->MouseHover += gcnew System::EventHandler(this, &MyForm::loadNoiseRed_MouseHover); + // + // pnlShadowHighlights + // + this->pnlShadowHighlights->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->pnlShadowHighlights->BorderStyle = System::Windows::Forms::BorderStyle::FixedSingle; + this->pnlShadowHighlights->Controls->Add(this->btnHighLightsApply); + this->pnlShadowHighlights->Controls->Add(this->lblMaxShadow); + this->pnlShadowHighlights->Controls->Add(this->btnShadowApply); + this->pnlShadowHighlights->Controls->Add(this->trkBarShadow); + this->pnlShadowHighlights->Controls->Add(this->lblMinHighlights); + this->pnlShadowHighlights->Controls->Add(this->lblMinShadow); + this->pnlShadowHighlights->Controls->Add(this->lblHIghlights); + this->pnlShadowHighlights->Controls->Add(this->lblShadow); + this->pnlShadowHighlights->Controls->Add(this->lblShadowHighlights); + this->pnlShadowHighlights->Controls->Add(this->trkBarHighlights); + this->pnlShadowHighlights->Controls->Add(this->lblMaxHighlights); + this->pnlShadowHighlights->Location = System::Drawing::Point(741, 293); + this->pnlShadowHighlights->Name = L"pnlShadowHighlights"; + this->pnlShadowHighlights->Size = System::Drawing::Size(251, 256); + this->pnlShadowHighlights->TabIndex = 35; + this->pnlShadowHighlights->Visible = false; + // + // lblMaxHighlights + // + this->lblMaxHighlights->AutoSize = true; + this->lblMaxHighlights->Location = System::Drawing::Point(223, 163); + this->lblMaxHighlights->Name = L"lblMaxHighlights"; + this->lblMaxHighlights->Size = System::Drawing::Size(19, 13); + this->lblMaxHighlights->TabIndex = 23; + this->lblMaxHighlights->Text = L"50"; + // + // lblMaxShadow + // + this->lblMaxShadow->AutoSize = true; + this->lblMaxShadow->Location = System::Drawing::Point(221, 64); + this->lblMaxShadow->Name = L"lblMaxShadow"; + this->lblMaxShadow->Size = System::Drawing::Size(19, 13); + this->lblMaxShadow->TabIndex = 22; + this->lblMaxShadow->Text = L"50"; + // + // lblMinHighlights + // + this->lblMinHighlights->AutoSize = true; + this->lblMinHighlights->Location = System::Drawing::Point(3, 163); + this->lblMinHighlights->Name = L"lblMinHighlights"; + this->lblMinHighlights->Size = System::Drawing::Size(22, 13); + this->lblMinHighlights->TabIndex = 21; + this->lblMinHighlights->Text = L"-50"; + // + // lblMinShadow + // + this->lblMinShadow->AutoSize = true; + this->lblMinShadow->Location = System::Drawing::Point(0, 64); + this->lblMinShadow->Name = L"lblMinShadow"; + this->lblMinShadow->Size = System::Drawing::Size(22, 13); + this->lblMinShadow->TabIndex = 20; + this->lblMinShadow->Text = L"-50"; + // + // lblHIghlights + // + this->lblHIghlights->AutoSize = true; + this->lblHIghlights->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 9, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->lblHIghlights->Location = System::Drawing::Point(94, 145); + this->lblHIghlights->Name = L"lblHIghlights"; + this->lblHIghlights->Size = System::Drawing::Size(61, 18); + this->lblHIghlights->TabIndex = 18; + this->lblHIghlights->Text = L"Highlights"; + // + // lblShadow + // + this->lblShadow->AutoSize = true; + this->lblShadow->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 9, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->lblShadow->Location = System::Drawing::Point(99, 48); + this->lblShadow->Name = L"lblShadow"; + this->lblShadow->Size = System::Drawing::Size(50, 18); + this->lblShadow->TabIndex = 17; + this->lblShadow->Text = L"Shadow"; + // + // lblShadowHighlights + // + this->lblShadowHighlights->AutoSize = true; + this->lblShadowHighlights->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->lblShadowHighlights->Location = System::Drawing::Point(57, 15); + this->lblShadowHighlights->Name = L"lblShadowHighlights"; + this->lblShadowHighlights->Size = System::Drawing::Size(137, 20); + this->lblShadowHighlights->TabIndex = 17; + this->lblShadowHighlights->Text = L"Shadow/Highlights"; + // + // trkBarHighlights + // + this->trkBarHighlights->Location = System::Drawing::Point(19, 163); + this->trkBarHighlights->Maximum = 50; + this->trkBarHighlights->Minimum = -50; + this->trkBarHighlights->Name = L"trkBarHighlights"; + this->trkBarHighlights->Size = System::Drawing::Size(208, 45); + this->trkBarHighlights->TabIndex = 5; + this->trkBarHighlights->TickFrequency = 0; + this->trkBarHighlights->Scroll += gcnew System::EventHandler(this, &MyForm::trkBarHighlights_Scroll); + // + // trkBarShadow + // + this->trkBarShadow->Location = System::Drawing::Point(19, 64); + this->trkBarShadow->Maximum = 50; + this->trkBarShadow->Minimum = -50; + this->trkBarShadow->Name = L"trkBarShadow"; + this->trkBarShadow->Size = System::Drawing::Size(208, 45); + this->trkBarShadow->TabIndex = 4; + this->trkBarShadow->TickFrequency = 0; + this->trkBarShadow->Scroll += gcnew System::EventHandler(this, &MyForm::trkBarShadow_Scroll); + // + // btnHighLightsApply + // + this->btnHighLightsApply->Location = System::Drawing::Point(86, 196); + this->btnHighLightsApply->Name = L"btnHighLightsApply"; + this->btnHighLightsApply->Size = System::Drawing::Size(77, 26); + this->btnHighLightsApply->TabIndex = 3; + this->btnHighLightsApply->Text = L"Apply"; + this->btnHighLightsApply->UseVisualStyleBackColor = true; + this->btnHighLightsApply->Click += gcnew System::EventHandler(this, &MyForm::btnHighLightsApply_Click); + // + // btnShadowApply + // + this->btnShadowApply->Location = System::Drawing::Point(84, 95); + this->btnShadowApply->Name = L"btnShadowApply"; + this->btnShadowApply->Size = System::Drawing::Size(79, 26); + this->btnShadowApply->TabIndex = 2; + this->btnShadowApply->Text = L"Apply"; + this->btnShadowApply->UseVisualStyleBackColor = true; + this->btnShadowApply->Click += gcnew System::EventHandler(this, &MyForm::btnShadowApply_Click); + // + // loadShadHighlts + // + this->loadShadHighlts->BackColor = System::Drawing::Color::DodgerBlue; + this->loadShadHighlts->BackgroundImage = (cli::safe_cast(resources->GetObject(L"loadShadHighlts.BackgroundImage"))); + this->loadShadHighlts->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Zoom; + this->loadShadHighlts->Location = System::Drawing::Point(728, 38); + this->loadShadHighlts->Name = L"loadShadHighlts"; + this->loadShadHighlts->Size = System::Drawing::Size(64, 64); + this->loadShadHighlts->TabIndex = 36; + this->loadShadHighlts->UseVisualStyleBackColor = false; + this->loadShadHighlts->Click += gcnew System::EventHandler(this, &MyForm::loadShadHighlts_Click); + this->loadShadHighlts->MouseHover += gcnew System::EventHandler(this, &MyForm::loadShadHighlts_MouseHover); + // + // MyForm + // + this->AutoScaleDimensions = System::Drawing::SizeF(6, 13); + this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font; + this->ClientSize = System::Drawing::Size(1350, 729); + this->Controls->Add(this->loadShadHighlts); + this->Controls->Add(this->vignettePanel); + this->Controls->Add(this->pnlShadowHighlights); + this->Controls->Add(this->tempPanel); + this->Controls->Add(this->loadNoiseRed); + this->Controls->Add(this->sharpeningPanel); + this->Controls->Add(this->pnlFiltering); + this->Controls->Add(this->cropPanel); + this->Controls->Add(this->luminancePanel); + this->Controls->Add(this->loadCrop); + this->Controls->Add(this->loadVignette); + this->Controls->Add(this->loadSharpen); + this->Controls->Add(this->label15); + this->Controls->Add(this->RGBHist); + this->Controls->Add(this->hueSatPanel); + this->Controls->Add(this->loadHueSat); + this->Controls->Add(this->contrastPanel); + this->Controls->Add(this->exposurePanel); + this->Controls->Add(this->loadExposure); + this->Controls->Add(this->loadContrast); + this->Controls->Add(this->loadLuminance); + this->Controls->Add(this->loadTempAdj); + this->Controls->Add(this->rgbPanel); + this->Controls->Add(this->loadColourAdj); + this->Controls->Add(this->pictureBox1); + this->Controls->Add(this->menuStrip1); + this->MainMenuStrip = this->menuStrip1; + this->Name = L"MyForm"; + this->StartPosition = System::Windows::Forms::FormStartPosition::CenterScreen; + this->Text = L"Image Enhancer v1.0"; + this->WindowState = System::Windows::Forms::FormWindowState::Maximized; + this->menuStrip1->ResumeLayout(false); + this->menuStrip1->PerformLayout(); + (cli::safe_cast(this->trackBarLuminance))->EndInit(); + this->luminancePanel->ResumeLayout(false); + this->luminancePanel->PerformLayout(); + (cli::safe_cast(this->trackBarContrast))->EndInit(); + this->contrastPanel->ResumeLayout(false); + this->contrastPanel->PerformLayout(); + (cli::safe_cast(this->trackBar1))->EndInit(); + this->tempPanel->ResumeLayout(false); + this->tempPanel->PerformLayout(); + (cli::safe_cast(this->trackBarExposure))->EndInit(); + this->exposurePanel->ResumeLayout(false); + this->exposurePanel->PerformLayout(); + (cli::safe_cast(this->redTrackBar))->EndInit(); + (cli::safe_cast(this->greenTrackBar))->EndInit(); + (cli::safe_cast(this->blueTrackBar))->EndInit(); + this->rgbPanel->ResumeLayout(false); + this->rgbPanel->PerformLayout(); + (cli::safe_cast(this->trackBarHue))->EndInit(); + (cli::safe_cast(this->trackBarSaturation))->EndInit(); + (cli::safe_cast(this->trackBarValue))->EndInit(); + this->hueSatPanel->ResumeLayout(false); + this->hueSatPanel->PerformLayout(); + (cli::safe_cast(this->RGBHist))->EndInit(); + this->sharpeningPanel->ResumeLayout(false); + this->sharpeningPanel->PerformLayout(); + (cli::safe_cast(this->weightTrack))->EndInit(); + (cli::safe_cast(this->sigmatrack))->EndInit(); + this->vignettePanel->ResumeLayout(false); + this->vignettePanel->PerformLayout(); + (cli::safe_cast(this->vignetteTrackBar))->EndInit(); + (cli::safe_cast(this->pictureBox1))->EndInit(); + this->cropPanel->ResumeLayout(false); + this->cropPanel->PerformLayout(); + this->pnlFiltering->ResumeLayout(false); + this->pnlFiltering->PerformLayout(); + (cli::safe_cast(this->trkBarColor))->EndInit(); + (cli::safe_cast(this->trkBarLumina))->EndInit(); + this->pnlShadowHighlights->ResumeLayout(false); + this->pnlShadowHighlights->PerformLayout(); + (cli::safe_cast(this->trkBarHighlights))->EndInit(); + (cli::safe_cast(this->trkBarShadow))->EndInit(); + this->ResumeLayout(false); + this->PerformLayout(); + + } +#pragma endregion + // Import image menubar item + + private: System::Void importToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) { + + // Displays an OpenFileDialog so the user can select an image file. + OpenFileDialog ^ openFileDialog1 = gcnew OpenFileDialog(); + openFileDialog1->Filter = "All Graphics Types|*.bmp;*.jpg;*.jpeg;*.png;*.tif;*.tiff"; + openFileDialog1->Title = "Select an Image File"; + + // Show the Dialog. + // If the user clicked OK in the dialog and + if (openFileDialog1->ShowDialog() == System::Windows::Forms::DialogResult::OK) + { + // Assign the cursor in the Stream to + // the Form's Cursor property. + // cache.jpg is the copy of the original image used for editing + pictureBox1->Load(openFileDialog1->FileName); + pictureBox1->Image->Save("cache.jpg", System::Drawing::Imaging::ImageFormat::Jpeg); + editedImage = cv::imread("cache.jpg", cv::IMREAD_COLOR); + + vignetteSelected = false; + FILE *fp = fopen("cache.jpg", "rb"); + + //MessageBox::Show("EXIF"); + if (!fp) { + MessageBox::Show("Can't open file"); + + } + fseek(fp, 0, SEEK_END); + unsigned long fsize = ftell(fp); + rewind(fp); + unsigned char *buf = new unsigned char[fsize]; + if (fread(buf, 1, fsize, fp) != fsize) { + MessageBox::Show("Can't read file"); + delete[] buf; + + } + fclose(fp); + + // Parse EXIF + easyexif::EXIFInfo result; + int code = result.parseFrom(buf, fsize); + delete[] buf; + if (code) { + MessageBox::Show("Error parsing EXIF"); + + } + + cameraMake = result.Make.c_str(); + cameraModel = result.Model.c_str(); + imageWidth = std::to_string(result.ImageWidth); + imageHeight = std::to_string(result.ImageHeight); + imageDate = result.DateTime.c_str(); + imageExposure = std::to_string((unsigned)(1.0 / result.ExposureTime)); + imageIso = std::to_string(result.ISOSpeedRatings); + + + refreshHistBox(Histogram(&editedImage)); + } + } + + // Mouse hover + + private: System::Void loadColourAdj_MouseHover(System::Object^ sender, System::EventArgs^ e) { + System::Windows::Forms::ToolTip^ ToolTip1 = gcnew System::Windows::Forms::ToolTip; + ToolTip1->SetToolTip(loadColourAdj, "RGB"); + } + + private: System::Void loadTempAdj_MouseHover(System::Object^ sender, System::EventArgs^ e) { + System::Windows::Forms::ToolTip^ ToolTip1 = gcnew System::Windows::Forms::ToolTip; + ToolTip1->SetToolTip(loadTempAdj, "Colour Temperature"); + } + + private: System::Void loadContrast_MouseHover(System::Object^ sender, System::EventArgs^ e) { + System::Windows::Forms::ToolTip^ ToolTip1 = gcnew System::Windows::Forms::ToolTip; + ToolTip1->SetToolTip(loadContrast, "Contrast"); + } + + private: System::Void loadLuminance_MouseHover(System::Object^ sender, System::EventArgs^ e) { + System::Windows::Forms::ToolTip^ ToolTip1 = gcnew System::Windows::Forms::ToolTip; + ToolTip1->SetToolTip(loadLuminance, "Luminance"); + } + + private: System::Void loadExposure_MouseHover(System::Object^ sender, System::EventArgs^ e) { + System::Windows::Forms::ToolTip^ ToolTip1 = gcnew System::Windows::Forms::ToolTip; + ToolTip1->SetToolTip(loadExposure, "Exposure"); + } + + private: System::Void loadHueSat_MouseHover(System::Object^ sender, System::EventArgs^ e) { + System::Windows::Forms::ToolTip^ ToolTip1 = gcnew System::Windows::Forms::ToolTip; + ToolTip1->SetToolTip(loadHueSat, "Hue/Saturation"); + } + + private: System::Void loadSharpen_MouseHover(System::Object^ sender, System::EventArgs^ e) { + System::Windows::Forms::ToolTip^ ToolTip1 = gcnew System::Windows::Forms::ToolTip; + ToolTip1->SetToolTip(loadSharpen, "Sharpening"); + } + + private: System::Void loadVignette_MouseHover(System::Object^ sender, System::EventArgs^ e) { + System::Windows::Forms::ToolTip^ ToolTip1 = gcnew System::Windows::Forms::ToolTip; + ToolTip1->SetToolTip(loadVignette, "Vignette"); + } + + private: System::Void loadCrop_MouseHover(System::Object^ sender, System::EventArgs^ e) { + System::Windows::Forms::ToolTip^ ToolTip1 = gcnew System::Windows::Forms::ToolTip; + ToolTip1->SetToolTip(loadCrop, "Crop Image"); + } + + private: System::Void loadNoiseRed_MouseHover(System::Object^ sender, System::EventArgs^ e) { + System::Windows::Forms::ToolTip^ ToolTip1 = gcnew System::Windows::Forms::ToolTip; + ToolTip1->SetToolTip(loadNoiseRed, "Noise Reduction"); + } + + private: System::Void loadShadHighlts_MouseHover(System::Object^ sender, System::EventArgs^ e) { + System::Windows::Forms::ToolTip^ ToolTip1 = gcnew System::Windows::Forms::ToolTip; + ToolTip1->SetToolTip(loadShadHighlts, "Shadow/Highlights"); + } + + // Temperature adjustment controls + + private: System::Void loadTempAdj_Click(System::Object^ sender, System::EventArgs^ e) { + // Controlling panels + rgbPanel->Visible = false; + tempPanel->Visible = true; + contrastPanel->Visible = false; + exposurePanel->Visible = false; + luminancePanel->Visible = false; + hueSatPanel->Visible = false; + sharpeningPanel->Visible = false; + vignettePanel->Visible = false; + cropPanel->Visible = false; + pnlFiltering->Visible = false; + pnlShadowHighlights->Visible = false; + + vignetteSelected = false; + cropSelected = false; + + refreshPicBox(editedImage); + refreshHistBox(Histogram(&editedImage)); + } + + private: System::Void tempTrackBar_Scroll(System::Object^ sender, System::EventArgs^ e) { + // Acquire track bar value + int trackBarValue = trackBar1->Value; + + // Initiate a Mat to save the cache.jpg image + cv::Mat mainImage; + mainImage = editedImage.clone(); + colourTempAdjustment(&mainImage, trackBarValue); + } + + private: System::Void tempApply_Click(System::Object^ sender, System::EventArgs^ e) { + editedImage = tempAdjusted.clone(); + trackBar1->Value = 0; + } + + private: System::Void autoWhiteBal_Click(System::Object^ sender, System::EventArgs^ e) { + whiteBalance(&editedImage); + } + + private: System::Void resetTemp_Click(System::Object^ sender, System::EventArgs^ e) { + autoWhiteBal->Enabled = true; + refreshHistBox(Histogram(&editedImage)); + refreshPicBox(editedImage); + trackBar1->Value = 0; + } + + // RGB adjustment controls + + private: System::Void loadColourAdj_Click(System::Object^ sender, System::EventArgs^ e) { + // Updating global RGB channels + cv::Mat edited2[3], cacheImage; + cacheImage = editedImage.clone(); + split(cacheImage, edited2); + adjRchan = edited2[2]; + adjGchan = edited2[1]; + adjBchan = edited2[0]; + + // Controlling panels + rgbPanel->Visible = true; + tempPanel->Visible = false; + contrastPanel->Visible = false; + exposurePanel->Visible = false; + luminancePanel->Visible = false; + hueSatPanel->Visible = false; + sharpeningPanel->Visible = false; + vignettePanel->Visible = false; + cropPanel->Visible = false; + pnlFiltering->Visible = false; + pnlShadowHighlights->Visible = false; + + refreshPicBox(editedImage); + refreshHistBox(Histogram(&editedImage)); + + vignetteSelected = false; + cropSelected = false; + } + + private: System::Void redTrackBar_Scroll(System::Object^ sender, System::EventArgs^ e) { + cv::Mat edited2[3], redChan, greenChan, blueChan; + split(editedImage, edited2); + redChan = edited2[2]; + greenChan = edited2[1]; + blueChan = edited2[0]; + + float fGamma = redTrackBar->Value / 10.0; + unsigned char lut[256]; + + for (int i = 0; i < 256; i++) + { + lut[i] = cv::saturate_cast(pow((float)(i / 255.0), fGamma) * 255.0f); + } + + cv::MatIterator_ it, end; + for (it = redChan.begin(), end = redChan.end(); it != end; it++) + *it = lut[(*it)]; + + adjRchan = redChan; + + // Merging the BGR channels + std::vector < cv::Mat > arrayToMerge; + arrayToMerge.push_back(adjBchan); + arrayToMerge.push_back(adjGchan); + arrayToMerge.push_back(adjRchan); + + // Image with altered red abd blue channels + merge(arrayToMerge, bgrAdjusted); + refreshPicBox(bgrAdjusted); + refreshHistBox(Histogram(&bgrAdjusted)); + } + + private: System::Void greenTrackBar_Scroll(System::Object^ sender, System::EventArgs^ e) { + cv::Mat edited2[3], redChan, greenChan, blueChan; + split(editedImage, edited2); + redChan = edited2[2]; + greenChan = edited2[1]; + blueChan = edited2[0]; + float fGamma = greenTrackBar->Value / 10.0; + unsigned char lut[256]; + + for (int i = 0; i < 256; i++) + { + lut[i] = cv::saturate_cast(pow((float)(i / 255.0), fGamma) * 255.0f); + } + + cv::MatIterator_ it, end; + for (it = greenChan.begin(), end = greenChan.end(); it != end; it++) + *it = lut[(*it)]; + + adjGchan = greenChan; + // Merging the BGR channels + std::vector < cv::Mat > arrayToMerge; + arrayToMerge.push_back(adjBchan); + arrayToMerge.push_back(adjGchan); + arrayToMerge.push_back(adjRchan); + + // Image with altered red abd blue channels + merge(arrayToMerge, bgrAdjusted); + refreshPicBox(bgrAdjusted); + refreshHistBox(Histogram(&bgrAdjusted)); + } + + private: System::Void blueTrackBar_Scroll(System::Object^ sender, System::EventArgs^ e) { + cv::Mat edited2[3], redChan, greenChan, blueChan; + split(editedImage, edited2); + redChan = edited2[2]; + greenChan = edited2[1]; + blueChan = edited2[0]; + float fGamma = blueTrackBar->Value / 10.0; + unsigned char lut[256]; + + for (int i = 0; i < 256; i++) + { + lut[i] = cv::saturate_cast(pow((float)(i / 255.0), fGamma) * 255.0f); + } + + cv::MatIterator_ it, end; + for (it = blueChan.begin(), end = blueChan.end(); it != end; it++) + *it = lut[(*it)]; + + adjBchan = blueChan; + // Merging the BGR channels + std::vector < cv::Mat > arrayToMerge; + arrayToMerge.push_back(adjBchan); + arrayToMerge.push_back(adjGchan); + arrayToMerge.push_back(adjRchan); + + // Image with altered red abd blue channels + merge(arrayToMerge, bgrAdjusted); + refreshPicBox(bgrAdjusted); + refreshHistBox(Histogram(&bgrAdjusted)); + } + + private: System::Void rgbApply_Click(System::Object^ sender, System::EventArgs^ e) { + editedImage = bgrAdjusted.clone(); + redTrackBar->Value = 10; + blueTrackBar->Value = 10; + greenTrackBar->Value = 10; + } + + + // Contrast Adjustment + + private: System::Void loadContrast_Click(System::Object^ sender, System::EventArgs^ e) { + rgbPanel->Visible = false; + tempPanel->Visible = false; + contrastPanel->Visible = true; + exposurePanel->Visible = false; + luminancePanel->Visible = false; + hueSatPanel->Visible = false; + sharpeningPanel->Visible = false; + vignettePanel->Visible = false; + cropPanel->Visible = false; + pnlFiltering->Visible = false; + pnlShadowHighlights->Visible = false; + + vignetteSelected = false; + cropSelected = false; + + refreshPicBox(editedImage); + refreshHistBox(Histogram(&editedImage)); + } + + private: System::Void trackBarContrast_Scroll(System::Object^ sender, System::EventArgs^ e) { + // Acquire track bar value + int trackBarValueExposure = trackBarExposure->Value; // Get Exposure slider value + int trackBarValueContrast = trackBarContrast->Value; // Get Contrast slider value + + // Initiate a Mat to save the cache.jpg image + cv::Mat mainImage; + mainImage = editedImage.clone(); + Contrast(&mainImage, trackBarValueExposure, trackBarValueContrast); //Call Contrast function + contrastApply->Enabled = true; + } + + private: System::Void contrastApply_Click(System::Object^ sender, System::EventArgs^ e) { + editedImage = tempAdjusted.clone(); // Contrast changes made permanent + contrastApply->Enabled = false; + trackBarContrast->Value = 50; // Center slider + } + + private: System::Void contrastAutoAdjust_Click(System::Object^ sender, System::EventArgs^ e) { + cv::Mat img; + std::vector channels; + cvtColor(editedImage, img, CV_BGR2YCrCb); // Change the color image from BGR to YCrCb format + cv::split(img, channels); // Split the image into channels + cv::equalizeHist(channels[0], channels[0]); // Equalize histogram on the 1st channel (Y) + cv::merge(channels, img); // Merge the 3 channels + cvtColor(img, tempAdjusted, CV_YCrCb2BGR); // Back to BGR + //imshow("Histogram Equalized Image", img); // Shows image + refreshPicBox(tempAdjusted); // Update picture displayed + refreshHistBox(Histogram(&tempAdjusted)); + editedImage = tempAdjusted.clone(); + } + + // Exposure Adjustment + + private: System::Void loadExposure_Click(System::Object^ sender, System::EventArgs^ e) { + rgbPanel->Visible = false; + tempPanel->Visible = false; + contrastPanel->Visible = false; + exposurePanel->Visible = true; + luminancePanel->Visible = false; + hueSatPanel->Visible = false; + sharpeningPanel->Visible = false; + vignettePanel->Visible = false; + cropPanel->Visible = false; + pnlFiltering->Visible = false; + pnlShadowHighlights->Visible = false; + + vignetteSelected = false; + cropSelected = false; + + refreshPicBox(editedImage); + refreshHistBox(Histogram(&editedImage)); + } + + private: System::Void trackBarExposure_Scroll(System::Object^ sender, System::EventArgs^ e) { + // Acquire track bar value + int trackBarValueExposure = trackBarExposure->Value; // Get Exposure slider value + int trackBarValueContrast = trackBarContrast->Value; // Get Contrast slider value + + // Initiate a Mat to save the cache.jpg image + cv::Mat mainImage; + mainImage = editedImage.clone(); + Exposure(&mainImage, trackBarValueExposure, trackBarValueContrast); //Call Exposure function + exposureApply->Enabled = true; + } + + private: System::Void exposureApply_Click(System::Object^ sender, System::EventArgs^ e) { + editedImage = tempAdjusted.clone(); // Exposure changes made permanent + exposureApply->Enabled = false; + trackBarExposure->Value = 50; + } + + private: System::Void exposureAutoAdjust_Click(System::Object^ sender, System::EventArgs^ e) { + double min, max, alpha, beta; + cv::Mat tempIm = editedImage.clone(); + cv::minMaxLoc(tempIm, &min, &max); + alpha = 255 / (max - min); + beta = - min * alpha; + tempIm.convertTo(tempAdjusted, -1, alpha, beta); //Linear Transform per pixel + refreshHistBox(Histogram(&tempAdjusted)); + refreshPicBox(tempAdjusted); // Update picture displayed + editedImage = tempAdjusted.clone(); + + } + + // Luminance Adjustment + + private: System::Void loadLuminance_Click(System::Object^ sender, System::EventArgs^ e) { + rgbPanel->Visible = false; + tempPanel->Visible = false; + contrastPanel->Visible = false; + exposurePanel->Visible = false; + luminancePanel->Visible = true; + hueSatPanel->Visible = false; + sharpeningPanel->Visible = false; + vignettePanel->Visible = false; + cropPanel->Visible = false; + pnlFiltering->Visible = false; + pnlShadowHighlights->Visible = false; + + vignetteSelected = false; + cropSelected = false; + + refreshPicBox(editedImage); + refreshHistBox(Histogram(&editedImage)); + } + + private: System::Void trackBarLuminance_Scroll(System::Object^ sender, System::EventArgs^ e) { + // Acquire track bar value + int trackBarValueLuminance = trackBarLuminance->Value; // Get Luminance slider value + + // Initiate a Mat to save the cache.jpg image + cv::Mat mainImage; + mainImage = editedImage.clone(); + Luminance(&mainImage, trackBarValueLuminance); // Call Luminance function + luminanceApply->Enabled = true; + } + + private: System::Void luminanceApply_Click(System::Object^ sender, System::EventArgs^ e) { + editedImage = tempAdjusted.clone(); // Luminance changes made permanent + luminanceApply->Enabled = false; + trackBarLuminance->Value = 0; // Center slider + } + + //HSV Adjustment + + private: System::Void loadHueSat_Click(System::Object^ sender, System::EventArgs^ e) { + rgbPanel->Visible = false; + tempPanel->Visible = false; + contrastPanel->Visible = false; + exposurePanel->Visible = false; + luminancePanel->Visible = false; + hueSatPanel->Visible = true; + sharpeningPanel->Visible = false; + vignettePanel->Visible = false; + cropPanel->Visible = false; + pnlFiltering->Visible = false; + pnlShadowHighlights->Visible = false; + + vignetteSelected = false; + cropSelected = false; + + refreshPicBox(editedImage); + refreshHistBox(Histogram(&editedImage)); + } + + // Hue Adjustment + + private: System::Void trackBarHue_Scroll(System::Object^ sender, System::EventArgs^ e) { + // Acquire track bar value + int trackBarValueHue = trackBarHue->Value; + int trackBarValueSaturation = trackBarSaturation->Value; + int trackBarValueValue = trackBarValue->Value; + + // Initiate a Mat to save the cache.jpg image + cv::Mat mainImage; + mainImage = editedImage.clone(); + Hue(&mainImage, trackBarValueHue, trackBarValueSaturation, trackBarValueValue); //Call Hue function + hueApply->Enabled = true; + } + + private: System::Void hueApply_Click(System::Object^ sender, System::EventArgs^ e) { + editedImage = tempAdjusted.clone(); // Hue changes made permanent + hueApply->Enabled = false; + trackBarHue->Value = 0; // Center slider + } + + // Saturation adjustment + + private: System::Void trackBarSaturation_Scroll(System::Object^ sender, System::EventArgs^ e) { + // Acquire track bar value + int trackBarValueHue = trackBarHue->Value; + int trackBarValueSaturation = trackBarSaturation->Value; + int trackBarValueValue = trackBarValue->Value; + + // Initiate a Mat to save the cache.jpg image + cv::Mat mainImage; + mainImage = editedImage.clone(); + Saturation(&mainImage, trackBarValueHue, trackBarValueSaturation, trackBarValueValue); // Call Saturation function + saturationApply->Enabled = true; + } + + private: System::Void saturationApply_Click(System::Object^ sender, System::EventArgs^ e) { + editedImage = tempAdjusted.clone(); // Saturation changes made permanent + saturationApply->Enabled = false; + trackBarSaturation->Value = 0; // Center slider + } + + // Value adjustment + + private: System::Void trackBarValue_Scroll(System::Object^ sender, System::EventArgs^ e) { + // Acquire track bar value + int trackBarValueHue = trackBarHue->Value; + int trackBarValueSaturation = trackBarSaturation->Value; + int trackBarValueValue = trackBarValue->Value; + + // Initiate a Mat to save the cache.jpg image + cv::Mat mainImage; + mainImage = editedImage.clone(); + Value(&mainImage, trackBarValueHue, trackBarValueSaturation, trackBarValueValue); //Call Value function + valueApply->Enabled = true; + } + + private: System::Void valueApply_Click(System::Object^ sender, System::EventArgs^ e) { + editedImage = tempAdjusted.clone(); // Value changes made permanent + valueApply->Enabled = false; + trackBarValue->Value = 0; // Center slider + } + + // Sharpening + + private: System::Void loadSharpen_Click(System::Object^ sender, System::EventArgs^ e) { + rgbPanel->Visible = false; + tempPanel->Visible = false; + contrastPanel->Visible = false; + exposurePanel->Visible = false; + luminancePanel->Visible = false; + hueSatPanel->Visible = false; + sharpeningPanel->Visible = true; + vignettePanel->Visible = false; + cropPanel->Visible = false; + pnlFiltering->Visible = false; + pnlShadowHighlights->Visible = false; + + vignetteSelected = false; + cropSelected = false; + + refreshPicBox(editedImage); + refreshHistBox(Histogram(&editedImage)); + } + + private: System::Void sharpeningSelect_SelectedIndexChanged(System::Object^ sender, System::EventArgs^ e) { + msclr::interop::marshal_context context; + sharpningType = context.marshal_as(sharpeningSelect->SelectedItem->ToString()); + } + + private: System::Void sigmatrack_Scroll(System::Object^ sender, System::EventArgs^ e) { + // Acquire track bar value + Sharpsigma = sigmatrack->Value; + + // Initiate a Mat to save the cache.jpg image + cv::Mat mainImage; + mainImage = editedImage; + + if (sharpningType == "Gaussian") + { + GaussianSharpning(&mainImage, &editedImage, Sharpsigma, Sharpweight); + } + + else if (sharpningType == "Luminance") + { + LuminanceSharpning(&mainImage, &editedImage, Sharpsigma, Sharpweight); + } + refreshHistBox(Histogram(&mainImage)); + } + + private: System::Void weightTrack_Scroll(System::Object^ sender, System::EventArgs^ e) { + // Acquire track bar value + Sharpweight = weightTrack->Value; + + // Initiate a Mat to save the cache.jpg image + cv::Mat mainImage; + mainImage = editedImage; + + if (sharpningType == "Gaussian") + { + GaussianSharpning(&mainImage, &editedImage, Sharpsigma, Sharpweight); + } + + else if (sharpningType == "Luminance") + { + LuminanceSharpning(&mainImage, &editedImage, Sharpsigma, Sharpweight); + } + refreshHistBox(Histogram(&mainImage)); + } + + private: System::Void sharpenApply_Click(System::Object^ sender, System::EventArgs^ e) { + editedImage = tempAdjusted.clone(); + } + + // View image metadata + + private: System::Void imageMetadataToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) { + //void displaydata(); + MessageBox::Show( + "Camera Make : " + gcnew String(cameraMake.c_str()) + "\n" + + "Camera Model : " + gcnew String(cameraModel.c_str()) + "\n" + + "Image Width : " + gcnew String(imageWidth.c_str()) + "\n" + + "Image Height : " + gcnew String(imageHeight.c_str()) + "\n" + + "Date : " + gcnew String(imageDate.c_str()) + "\n" + + "Exposure : " + gcnew String(imageExposure.c_str()) + "\n" + + "ISO : " + gcnew String(imageIso.c_str()), TEXT("Image Metadata") + ); + + } + + // Vignette + + private: System::Void loadVignette_Click(System::Object^ sender, System::EventArgs^ e) { + cropVigImage = editedImage.clone(); + + cropStarted = false; + cropSelected = false; + vignetteSelected = true; + vignettePanel->Visible = true; + vignetteCenterX = cropVigImage.cols / 2; + vignetteCenterY = cropVigImage.rows / 2; + int tabValue = vignetteTrackBar->Value; + int sigma = cropVigImage.cols * tabValue / 100; + vignetteImage = vignetteFilterOffset(&cropVigImage, sigma, vignetteCenterX, vignetteCenterY); + + refreshPicBox(vignetteImage); + refreshHistBox(Histogram(&vignetteImage)); + + rgbPanel->Visible = false; + tempPanel->Visible = false; + contrastPanel->Visible = false; + exposurePanel->Visible = false; + luminancePanel->Visible = false; + hueSatPanel->Visible = false; + sharpeningPanel->Visible = false; + vignettePanel->Visible = true; + cropPanel->Visible = false; + pnlFiltering->Visible = false; + pnlShadowHighlights->Visible = false; + } + + private: System::Void vignetteCancelButton_Click(System::Object^ sender, System::EventArgs^ e) { + refreshPicBox(editedImage); + refreshHistBox(Histogram(&editedImage)); + vignetteSelected = false; + vignettePanel->Visible = false; + } + + private: System::Void vignetteTrackBar_ValueChanged(System::Object^ sender, System::EventArgs^ e) { + int tabValue = vignetteTrackBar->Value; + if (vignetteSelected) { + + int sigma = cropVigImage.cols * tabValue / 100; + vignetteImage = vignetteFilterOffset(&cropVigImage, sigma, vignetteCenterX, vignetteCenterY); + refreshPicBox(vignetteImage); + refreshHistBox(Histogram(&vignetteImage)); + } + } + + private: System::Void vignetteApplyButton_Click(System::Object^ sender, System::EventArgs^ e) { + cropVigImage = vignetteImage; + System::IntPtr ptr(cropVigImage.ptr()); + System::Drawing::Bitmap^ b = gcnew System::Drawing::Bitmap(cropVigImage.cols, cropVigImage.rows, cropVigImage.step, System::Drawing::Imaging::PixelFormat::Format24bppRgb, ptr); + pictureBox1->Image = b; + vignetteSelected = false; + vignettePanel->Visible = false; + editedImage = cropVigImage; + } + + private: System::Void vignetteResetButton_Click(System::Object^ sender, System::EventArgs^ e) { + cropVigImage = editedImage; + vignetteTrackBar->Value = 50; + vignetteSelected = true; + vignetteCenterX = cropVigImage.cols / 2; + vignetteCenterY = cropVigImage.rows / 2; + int tabValue = vignetteTrackBar->Value; + int sigma = cropVigImage.cols * tabValue / 100; + vignetteImage = vignetteFilterOffset(&cropVigImage, sigma, vignetteCenterX, vignetteCenterY); + refreshPicBox(vignetteImage); + } + + private: System::Void pictureBox1_MouseClick(System::Object^ sender, System::Windows::Forms::MouseEventArgs^ e) { + if (vignetteSelected) { + + vignetteCenterX = e->X; + vignetteCenterY = e->Y; + + int tabValue = vignetteTrackBar->Value; + int sigma = cropVigImage.cols * tabValue / 100; + vignetteImage = vignetteFilterOffset(&cropVigImage, sigma, vignetteCenterX, vignetteCenterY); + refreshPicBox(vignetteImage); + } + } + + // Cropping + + private: System::Void loadCrop_Click(System::Object^ sender, System::EventArgs^ e) { + cropSelected = true; + rgbPanel->Visible = false; + tempPanel->Visible = false; + contrastPanel->Visible = false; + exposurePanel->Visible = false; + luminancePanel->Visible = false; + hueSatPanel->Visible = false; + sharpeningPanel->Visible = false; + vignettePanel->Visible = false; + cropPanel->Visible = true; + pnlFiltering->Visible = false; + pnlShadowHighlights->Visible = false; + + vignetteSelected = false; + cropImage = editedImage; + refreshPicBox(editedImage); + refreshHistBox(Histogram(&editedImage)); + } + + private: System::Void cropCancelButton_Click(System::Object^ sender, System::EventArgs^ e) { + //cropImage = editedImage; + cropSelected = false; + cropStarted = false; + cropPanel->Visible = false; + //refreshPicBox(editedImage); + //refreshHistBox(Histogram(&editedImage)); + } + + private: System::Void cropResetButton_Click(System::Object^ sender, System::EventArgs^ e) { + pictureBox1->Refresh(); + cropStarted = false; + cropSelected = true; + refreshPicBox(cropImage); + refreshHistBox(Histogram(&cropImage)); +} + + private: System::Void cropApplyButton_Click(System::Object^ sender, System::EventArgs^ e) { + cropSelected = false; + cropStarted = false; + editedImage = croppedImage; + cropPanel->Visible = false; + refreshPicBox(editedImage); + refreshHistBox(Histogram(&editedImage)); +} + + private: System::Void pictureBox1_MouseUp(System::Object^ sender, System::Windows::Forms::MouseEventArgs^ e) { + if (cropSelected && cropStarted) { + + cropStarted = false; + // rectWidth = cropVigImage.cols * rectWidth/ 600 ; // 600- width of the picture box + //rectHeight = cropVigImage.rows * rectHeight/ 500 ; // 400- height of the picture box + cv::Rect cropRectangle(rectSX, rectSY, rectWidth, rectHeight); + croppedImage = cropImage(cropRectangle); + pictureBox1->Refresh(); + refreshPicBox(croppedImage); + refreshHistBox(Histogram(&croppedImage)); + + } + } + + private: System::Void pictureBox1_MouseDown(System::Object^ sender, System::Windows::Forms::MouseEventArgs^ e) { + if (cropSelected) { + + rectSX = e->X; + rectSY = e->Y; + cropStarted = true; + } +} + + private: System::Void pictureBox1_MouseMove(System::Object^ sender, System::Windows::Forms::MouseEventArgs^ e) { + if (cropSelected && cropStarted) { + + //pictureBox1->Refresh(); + System::Drawing::Pen^ myBrush = gcnew System::Drawing::Pen(System::Drawing::Color::Red); + System::Drawing::Graphics^ formGraphics; + + formGraphics = pictureBox1->CreateGraphics(); + + System::IntPtr ptr(cropImage.ptr()); + System::Drawing::Bitmap^ b = gcnew System::Drawing::Bitmap(cropImage.cols, cropImage.rows, cropImage.step, System::Drawing::Imaging::PixelFormat::Format24bppRgb, ptr); + formGraphics->DrawImage(b, 0, 0, cropImage.cols, cropImage.rows); + + rectWidth = e->X - rectSX; + rectHeight = e->Y - rectSY; + formGraphics->DrawRectangle(myBrush, System::Drawing::Rectangle(rectSX, rectSY, rectWidth, rectHeight)); + + delete myBrush; + delete formGraphics; + + } +} + + // Saving image + + private: System::Void exportToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) { + char savePath[200]; + SaveFileDialog ^ saveFileDialog1 = gcnew SaveFileDialog(); + saveFileDialog1->Filter = + "JPEG Image|*.jpg|Bitmap Image|*.bmp|GIF Image|*.gif|PNG Image|*.png"; + saveFileDialog1->Title = "Save an Image File"; + saveFileDialog1->ShowDialog(); + + if (saveFileDialog1->FileName) + { + std::string filePath = msclr::interop::marshal_as(saveFileDialog1->FileName); + sprintf(savePath, "%s", filePath.c_str()); + cv::imwrite(savePath, editedImage); + } + } + + // Noise Reduction + + private: System::Void loadNoiseRed_Click(System::Object^ sender, System::EventArgs^ e) { + rgbPanel->Visible = false; + tempPanel->Visible = false; + contrastPanel->Visible = false; + exposurePanel->Visible = false; + luminancePanel->Visible = false; + hueSatPanel->Visible = false; + sharpeningPanel->Visible = false; + vignettePanel->Visible = false; + cropPanel->Visible = false; + pnlFiltering->Visible = true; + pnlShadowHighlights->Visible = false; + + vignetteSelected = false; + cropSelected = false; + + refreshPicBox(editedImage); + refreshHistBox(Histogram(&editedImage)); + } + + private: System::Void cmboxNoiseReduction_SelectedIndexChanged(System::Object^ sender, System::EventArgs^ e) { + msclr::interop::marshal_context context; + filterType = context.marshal_as(cmboxNoiseReduction->SelectedItem->ToString()); + } + + private: System::Void trkBarLumina_Scroll(System::Object^ sender, System::EventArgs^ e) { + // Acquire track bar value + int trackBarValue = (trkBarLumina->Value); + trackBarValue = trackBarValue * 2 + 1; + // Initiate a Mat to save the cache.jpg image + cv::Mat mainImage; + mainImage = editedImage; + //colourTempAdjustment(&mainImage, trackBarValue); + lumaNoiseFiltering(&mainImage, trackBarValue); + btnLuminaApply->Enabled = true; + } + + private: System::Void trkBarColor_Scroll(System::Object^ sender, System::EventArgs^ e) { + // Acquire track bar value + int trackBarValue = (trkBarColor->Value); + trackBarValue = trackBarValue * 2 + 1; + // Initiate a Mat to save the cache.jpg image + cv::Mat mainImage; + mainImage = editedImage; + //colourTempAdjustment(&mainImage, trackBarValue); + colorNoiseFiltering(&mainImage, trackBarValue); + btnColorApply->Enabled = true; + } + + private: System::Void btnLuminaApply_Click(System::Object^ sender, System::EventArgs^ e) { + editedImage = tempAdjusted; + btnLuminaApply->Enabled = false; + } + + private: System::Void btnColorApply_Click(System::Object^ sender, System::EventArgs^ e) { + editedImage = tempAdjusted; + btnColorApply->Enabled = false; + } + + // Highlights and shadow recovery + + private: System::Void loadShadHighlts_Click(System::Object^ sender, System::EventArgs^ e) { + rgbPanel->Visible = false; + tempPanel->Visible = false; + contrastPanel->Visible = false; + exposurePanel->Visible = false; + luminancePanel->Visible = false; + hueSatPanel->Visible = false; + sharpeningPanel->Visible = false; + vignettePanel->Visible = false; + cropPanel->Visible = false; + pnlFiltering->Visible = false; + pnlShadowHighlights->Visible = true; + + cropSelected = false; + vignetteSelected = false; + + refreshPicBox(editedImage); + refreshHistBox(Histogram(&editedImage)); + } + + // Highlights + + private: System::Void trkBarHighlights_Scroll(System::Object^ sender, System::EventArgs^ e) { + int trackBarValue = (trkBarHighlights->Value); + + // Initiate a Mat to save the cache.jpg image + cv::Mat mainImage; + mainImage = editedImage; + highlightsRecovery(&mainImage, trackBarValue); + btnHighLightsApply->Enabled = true; + } + + private: System::Void btnHighLightsApply_Click(System::Object^ sender, System::EventArgs^ e) { + editedImage = tempAdjusted; + btnHighLightsApply->Enabled = false; + } + + // Shadow recovery + + private: System::Void trkBarShadow_Scroll(System::Object^ sender, System::EventArgs^ e) { + // Acquire track bar value + int trackBarValue = (trkBarShadow->Value); + + // Initiate a Mat to save the cache.jpg image + cv::Mat mainImage; + mainImage = editedImage; + shadowRecovery(&mainImage, trackBarValue); + btnShadowApply->Enabled = true; + } + + private: System::Void btnShadowApply_Click(System::Object^ sender, System::EventArgs^ e) { + editedImage = tempAdjusted; + btnShadowApply->Enabled = false; + } + + + //************************ Functions defined in opencv************************************** + + // Display image + int displayImage(cv::Mat *mainImage, cv::String imageDes) + { + cv::Mat tempImage; + tempImage = *mainImage; + if (tempImage.empty()) // Check for invalid input + { + return -1; + } + namedWindow(imageDes, cv::WINDOW_AUTOSIZE); // Create a window for display. + imshow(imageDes, tempImage); // Show our image inside it. + cv::waitKey(0); // Wait for a keystroke in the window + return 0; + } + + // Colour temperature adjustment function + int colourTempAdjustment(cv::Mat *mainImage, int tempValue) + { + int absTemp = abs(tempValue); + cv::Mat resolvedImage[3]; + cv::Mat blueChannel, greenChannel, redChannel; + split(*mainImage, resolvedImage); // Splitting the BGR channels + + // Create warmer image + // Done by increasing the red channel and decreasing the blue channel + // and increasing saturation of the image in HSV colour space + + // Create a cooler image + // Done by decreasing the red channel and increasing blue channel + // and decreasing the saturation of the image in the HSV colour image + + // Spline interpolation + std::vector X(5), Y(5), Z(5); + X[0] = 0; X[1] = 64; X[2] = 128; X[3] = 192; X[4] = 255; + + Y[0] = 5 * absTemp; Y[1] = 64 + (7 * absTemp); Y[2] = 128 + (8 * absTemp); + Y[3] = 192 + (10 * absTemp); Y[4] = 255; + + Z[0] = 0; Z[1] = 64 - (5 * absTemp); Z[2] = 128 - (7 * absTemp); + Z[3] = 192 - (8 * absTemp); Z[4] = 255 - (10 * absTemp); + + // Creating spline functions + tk::spline incIntensity, decIntensity; + incIntensity.set_points(X, Y); + decIntensity.set_points(X, Z); + + redChannel = resolvedImage[2]; //+ (10 * tempValue); + blueChannel = resolvedImage[0]; //- (10 * tempValue); + greenChannel = resolvedImage[1]; + + int width = redChannel.cols; + int height = redChannel.rows; + int nElements = width*height; + + // Calculating interpolated value for each matrix element + uchar* p1 = redChannel.data; + uchar* p2 = blueChannel.data; + + for (int i = 0; i < nElements; ++i) + { + if (tempValue >= 0) + { + p1[i] = (uchar)(incIntensity(p1[i])); + p2[i] = (uchar)(decIntensity(p2[i])); + } + else + { + p1[i] = (uchar)(decIntensity(p1[i])); + p2[i] = (uchar)(incIntensity(p2[i])); + } + } + + // Merging the BGR channels + std::vector < cv::Mat > arrayToMerge; + arrayToMerge.push_back(blueChannel); + arrayToMerge.push_back(greenChannel); + arrayToMerge.push_back(redChannel); + + // Image with altered red abd blue channels + cv::Mat bgrAdjusted; + merge(arrayToMerge, bgrAdjusted); + + // Convert image to HSV colour space and splitting layers for saturation adjustment + cv::Mat hsvImage; + cv::Mat hsvResolved[3]; + cvtColor(bgrAdjusted, hsvImage, CV_BGR2HSV); + split(hsvImage, hsvResolved); + + // Adjusting saturation + cv::Mat hNew, sNew, vNew; + hNew = hsvResolved[0]; + sNew = hsvResolved[1]; // +(10 * tempValue); + vNew = hsvResolved[2]; + + // Calculate interpolated value for saturation layer + uchar* p3 = sNew.data; + + for (int i = 0; i < nElements; ++i) + { + if (tempValue >= 0) + { + p3[i] = (uchar)(incIntensity(p3[i])); + } + else + { + p3[i] = (uchar)(decIntensity(p3[i])); + } + } + + // Merging the HSV channels + std::vector < cv::Mat > arrayToMergeHSV; + arrayToMergeHSV.push_back(hNew); + arrayToMergeHSV.push_back(sNew); + arrayToMergeHSV.push_back(vNew); + + // Converting the image back to BGR + cv::Mat hsvAdjusted; // Image with altered saturation channel + merge(arrayToMergeHSV, hsvAdjusted); + cvtColor(hsvAdjusted, tempAdjusted, CV_HSV2BGR); + refreshPicBox(tempAdjusted); + refreshHistBox(Histogram(&tempAdjusted)); + return 0; + } + + // Auto white balance + int whiteBalance(cv::Mat *mainImage) + { + cv::Mat resolvedImage[3]; // Matrix for splitting BGR channels + cv::Mat grayImage; // Convert to grayscale image + cvtColor(*mainImage, grayImage, CV_BGR2GRAY); + split(*mainImage, resolvedImage); // Splitting the BGR channels + + double meanGray, meanBlue, meanGreen, meanRed; // Declare variables to store mean channel values + meanGray = mean(grayImage)[0]; // Mean grayscale intensity + meanBlue = mean(resolvedImage[0])[0]; // Mean blue intensity + meanGreen = mean(resolvedImage[1])[0]; // Mean green intensity + meanRed = mean(resolvedImage[2])[0]; // Mean red intensity + + // Calculating each channel so that the mean is equal in all three + // Contains BGR channels with mean intensity equal to the mean grayscale intensity + cv::Mat equalizedImage[3]; + equalizedImage[0] = resolvedImage[0] * meanGray / meanBlue; + equalizedImage[1] = resolvedImage[1] * meanGray / meanGreen; + equalizedImage[2] = resolvedImage[2] * meanGray / meanRed; + + // Merging the BGR channels and obtaining the white balanced image + std::vector < cv::Mat > arrayToMerge; + arrayToMerge.push_back(equalizedImage[0]); + arrayToMerge.push_back(equalizedImage[1]); + arrayToMerge.push_back(equalizedImage[2]); + + cv::Mat finalImage; + merge(arrayToMerge, finalImage); + tempAdjusted = finalImage; + refreshPicBox(tempAdjusted); + refreshHistBox(Histogram(&tempAdjusted)); + return 0; + } + + // Exposure Adjustment function + void Exposure(cv::Mat *mainImageEx, int tempValueExposure, int tempValueContrast) + { + int exposure = tempValueExposure - 50; + double ContrastNew = tempValueContrast / 50.0; // Or divide by smaller no. to increase range + cv::Mat temp = *mainImageEx; + temp.convertTo(tempAdjusted, -1, ContrastNew, exposure); //Linear Transform - per pixel + //imshow("image", tempAdjusted); + refreshPicBox(tempAdjusted); // Update picture displayed + refreshHistBox(Histogram(&tempAdjusted)); + } + + // Contrast adjustment function + void Contrast(cv::Mat *mainImageCon, int tempValueExposure, int tempValueContrast) + { + int exposure = tempValueExposure - 50; + double ContrastNew = tempValueContrast / 50.0; // Or divide by smaller no. to increase range + cv::Mat temp = *mainImageCon; + temp.convertTo(tempAdjusted, -1, ContrastNew, exposure); //Linear Transform - per pixel - contrast*im+brightness + // imshow("image", tempAdjusted); + refreshPicBox(tempAdjusted); // Update picture displayed + refreshHistBox(Histogram(&tempAdjusted)); + } + + // Luminance adjustment function + void Luminance(cv::Mat *mainImageLum, int tempValue) + { + cv::Mat img; + cvtColor(*mainImageLum, img, CV_BGR2YCrCb); // Change the color image from BGR to YCrCb format + + //Initialize + int luminosity = tempValue; // Slider Value + //int luminosity = elem4 - 255; + + // Loop for each pixel in Y plane + for (int y = 0; y(cv::Point(y, x))[0]; // Y-Luminosity Plane + cur1 += luminosity; // Change + if (cur1 < 0) cur1 = 0; else if (cur1 > 255) cur1 = 255; // Check thresholds + img.at(cv::Point(y, x))[0] = cur1; // Adjust pixel + } + } + cvtColor(img, tempAdjusted, CV_YCrCb2BGR); // Back to BGR + refreshPicBox(tempAdjusted); // Update picture displayed + refreshHistBox(Histogram(&tempAdjusted)); + } + + // Hue Adjustment + void Hue(cv::Mat *mainImageHue, int tempValueHue, int tempValueSaturation, int tempValueValue) + { + cv::Mat img; + cvtColor(*mainImageHue, img, CV_BGR2HSV); //Convert from BGR to HSV + + //Initialize + int hue = tempValueHue; // Hue slider value + + // Loop for each pixel in Hue plane + for (int y = 0; y(cv::Point(y, x))[0]; // Hue Plane + cur1 += hue; + if (cur1 < 0) cur1 = 0; else if (cur1 > 255) cur1 = 255; // Check thresholds + img.at(cv::Point(y, x))[0] = cur1; // Adjust pixel Hue + } + } + cvtColor(img, tempAdjusted, CV_HSV2BGR); // Convert HSV to BGR + refreshPicBox(tempAdjusted); // Update picture displayed + refreshHistBox(Histogram(&tempAdjusted)); + } + + // Saturation adjustment + void Saturation(cv::Mat *mainImageSat, int tempValueHue, int tempValueSaturation, int tempValueValue) + { + cv::Mat img; + cvtColor(*mainImageSat, img, CV_BGR2HSV); //Convert from BGR to HSV + //Initialize + int saturation = tempValueSaturation; // Saturation Slider value + // Loop for each pixel in Saturation plane + for (int y = 0; y(cv::Point(y, x))[1]; // Saturation Plane + cur2 += saturation; + if (cur2 < 0) cur2 = 0; else if (cur2 > 255) cur2 = 255; // Check thresholds + img.at(cv::Point(y, x))[1] = cur2; // Adjust pixel Saturation + } + } + cvtColor(img, tempAdjusted, CV_HSV2BGR); // Convert HSV to BGR + // imshow("image", tempAdjusted); // Dispay adjusted image + refreshPicBox(tempAdjusted); // Update picture displayed + refreshHistBox(Histogram(&tempAdjusted)); + } + + // Value Adjustment + void Value(cv::Mat *mainImageVal, int tempValueHue, int tempValueSaturation, int tempValueValue) + { + cv::Mat img; + cvtColor(*mainImageVal, img, CV_BGR2HSV); //Convert from BGR to HSV + //Initialize + int value = tempValueValue; // Value Slider Value + // Loop for each pixel in Value plane + for (int y = 0; y(cv::Point(y, x))[2]; // Value Plane + cur3 += value; + if (cur3 < 0) cur3 = 0; else if (cur3 > 255) cur3 = 255; // Check Threshholds + img.at(cv::Point(y, x))[2] = cur3; // Adjust pixel Value + } + } + cvtColor(img, tempAdjusted, CV_HSV2BGR); // Convert HSV to BGR + refreshPicBox(tempAdjusted); // Update Picture displayed + refreshHistBox(Histogram(&tempAdjusted)); + } + + // Histogram Drawing Funtion + cv::Mat Histogram(cv::Mat* editedImage) + { + cv::Mat dst; + cvtColor(*editedImage, dst, cv::COLOR_BGR2GRAY); + + /// Separate the image in 3 places ( B, G and R ) + std::vector bgr_planes; + split(*editedImage, bgr_planes); + + /// Establish the number of bins + int histSize = 254; + int ShadowHistSize = 2.55 * 25; + int HighlightHistSize = 2.55 * 25; + + /// Set the ranges ( for B,G,R) ) + float range[] = { 1, 255 }; + const float* histRange = { range }; + + float ShadowRange[] = { 0, 2.55 * 25 }; + const float* ShadowHistRange = { ShadowRange }; + + float HighlightRange[] = { 2.55 * 75, 255 }; + const float* HighlightHistRange = { HighlightRange }; + + bool uniform = true; bool accumulate = false; + + cv::Mat b_hist, g_hist, r_hist, hist, shadowHist, highlightHist; + + /// Compute the histograms: + calcHist(&bgr_planes[0], 1, 0, cv::Mat(), b_hist, 1, &histSize, &histRange, uniform, accumulate); + calcHist(&bgr_planes[1], 1, 0, cv::Mat(), g_hist, 1, &histSize, &histRange, uniform, accumulate); + calcHist(&bgr_planes[2], 1, 0, cv::Mat(), r_hist, 1, &histSize, &histRange, uniform, accumulate); + calcHist(&dst, 1, 0, cv::Mat(), hist, 1, &histSize, &histRange, uniform, accumulate); + calcHist(&dst, 1, 0, cv::Mat(), shadowHist, 1, &ShadowHistSize, &ShadowHistRange, uniform, accumulate); + calcHist(&dst, 1, 0, cv::Mat(), highlightHist, 1, &HighlightHistSize, &HighlightHistRange, uniform, accumulate); + + // Draw the histograms for B, G and R + int hist_w = 800; int hist_h = 300; + int bin_w = cvRound((double)hist_w / histSize); + int bin_Sw = cvRound((double)hist_w / ShadowHistSize); + int bin_Hw = cvRound((double)hist_w / HighlightHistSize); + + cv::Mat histImage(hist_h, hist_w, CV_8UC3, cv::Scalar(200, 200, 200)); + cv::Mat histnew(hist_h, hist_w, CV_8UC3, cv::Scalar(255, 255, 255)); + cv::Mat ShadowHist(hist_h, hist_w, CV_8UC3, cv::Scalar(255, 255, 255)); + cv::Mat HighlightHist(hist_h, hist_w, CV_8UC3, cv::Scalar(255, 255, 255)); + + /// Normalize the result to [ 0, histImage.rows ] + normalize(b_hist, b_hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat()); + normalize(g_hist, g_hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat()); + normalize(r_hist, r_hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat()); + normalize(hist, hist, 0, histnew.rows, cv::NORM_MINMAX, -1, cv::Mat()); + normalize(shadowHist, shadowHist, 0, ShadowHist.rows, cv::NORM_MINMAX, -1, cv::Mat()); + normalize(highlightHist, highlightHist, 0, HighlightHist.rows, cv::NORM_MINMAX, -1, cv::Mat()); + + /// Draw for each channel + for (int i = 1; i < histSize; i++) + { + line(histImage, cv::Point(bin_w*(i - 1), hist_h - cvRound(b_hist.at(i - 1))), + cv::Point(bin_w*(i), hist_h - cvRound(b_hist.at(i))), + cv::Scalar(255, 0, 0), 2, cv::LINE_AA, 0); + line(histImage, cv::Point(bin_w*(i - 1), hist_h - cvRound(g_hist.at(i - 1))), + cv::Point(bin_w*(i), hist_h - cvRound(g_hist.at(i))), + cv::Scalar(80, 200, 80), 2, cv::LINE_AA, 0); + line(histImage, cv::Point(bin_w*(i - 1), hist_h - cvRound(r_hist.at(i - 1))), + cv::Point(bin_w*(i), hist_h - cvRound(r_hist.at(i))), + cv::Scalar(0, 0, 255), 2, cv::LINE_AA, 0); + + + line(histnew, cv::Point(bin_w*(i - 1), hist_h - cvRound(hist.at(i - 1))), + cv::Point(bin_w*(i), hist_h - cvRound(hist.at(i))), + cv::Scalar(0, 0, 0), 1, cv::LINE_AA, 0); + } + + for (int i = 1; i < ShadowHistSize; i++) + { + line(ShadowHist, cv::Point(bin_Sw*(i - 1), hist_h - cvRound(shadowHist.at(i - 1))), + cv::Point(bin_Sw*(i), hist_h - cvRound(shadowHist.at(i))), + cv::Scalar(0, 0, 0), 1, cv::LINE_AA, 0); + } + + for (int i = 1; i < HighlightHistSize; i++) + { + line(HighlightHist, cv::Point(bin_Sw*(i - 1), hist_h - cvRound(highlightHist.at(i - 1))), + cv::Point(bin_Sw*(i), hist_h - cvRound(highlightHist.at(i))), + cv::Scalar(0, 0, 0), 1, cv::LINE_AA, 0); + } + return histImage; + } + + // Gaussian Sharpening + int GaussianSharpning(cv::Mat* mainImage, cv::Mat* editedImage, int Gvalue, int Wvalue) { + + cv::Mat Gimage, Simage; + if (Gvalue == 0 || Wvalue == 0) { *mainImage = *editedImage; refreshPicBox(*mainImage); return 0; } + else { + GaussianBlur(*editedImage, Gimage, cv::Size(0, 0), Gvalue); + addWeighted(*editedImage, (Wvalue + 1), Gimage, -Wvalue, 0, Simage); + *mainImage = Simage; + tempAdjusted = Simage; + refreshPicBox(*mainImage); + return 0; + } + } + + // Luminance Sharpening + int LuminanceSharpning(cv::Mat* mainImage, cv::Mat* editedImage, int Gvalue, int Wvalue) { + if (Gvalue == 0 || Wvalue == 0) { *mainImage = *editedImage; refreshPicBox(*mainImage); return 0; } + else { + cv::Mat dst, Limage; + cvtColor(*editedImage, dst, cv::COLOR_BGR2YUV); + /// Separate the image in 3 places ( B, G and R ) + std::vector yuv_planes; + split(dst, yuv_planes); + cv::Mat Y0; + GaussianBlur(yuv_planes[0], Limage, cv::Size(0, 0), Gvalue); + addWeighted(yuv_planes[0], (Wvalue + 1), Limage, -Wvalue, 0, Y0); + yuv_planes[0] = Y0; + merge(yuv_planes, dst); + cvtColor(dst, Limage, cv::COLOR_YUV2BGR); + *mainImage = Limage; + tempAdjusted = Limage; + refreshPicBox(*mainImage); + return 0; + } + } + + // Vignette + cv::Mat vignetteFilterOffset(cv::Mat *image, int sigma, int offset_x, int offset_y) { + + cv::Mat imageTemp = *image; + std::vector channels(3), filtChannel; + cv::Mat filteredChannel[3]; + + int im_height = imageTemp.rows; + int im_width = imageTemp.cols; + + int xLen = 0, yLen = 0; + bool xFlag = false, yFlag = false; + if ((im_height - offset_y) < im_height / 2) + { + yLen = offset_y; + } + else + { + yLen = im_height - offset_y; + yFlag = true; + } + + if ((im_width - offset_x) < im_width / 2) + { + xLen = offset_x; + } + else + { + xLen = im_width - offset_x; + xFlag = true; + } + + int cropX = 0, cropY = 0; + if (xFlag | yFlag) + { + cropY = yFlag ? yLen - offset_y : 0; + cropX = xFlag ? xLen - offset_x : 0; + } + + cv::Mat kernel_x = cv::getGaussianKernel(yLen * 2, sigma); + cv::Mat kernel_y = cv::getGaussianKernel(xLen * 2, sigma); + cv::Mat filter = kernel_x * kernel_y.t(); + cv::Mat mask(imageTemp.rows, imageTemp.cols, CV_8UC1); + + cv::Rect cropRect(cropX, cropY, imageTemp.cols, imageTemp.rows); + + cv::Mat filterCropped = filter(cropRect); + cv::normalize(filterCropped, mask, 0, 255, cv::NORM_MINMAX, CV_8UC1); + split(imageTemp, channels); + + filteredChannel[0] = channels[0].mul(mask) / 255; + filteredChannel[1] = channels[1].mul(mask) / 255; + filteredChannel[2] = channels[2].mul(mask) / 255; + + filtChannel.push_back(filteredChannel[0]); + filtChannel.push_back(filteredChannel[1]); + filtChannel.push_back(filteredChannel[2]); + + cv::Mat filteredImage(imageTemp.rows, imageTemp.cols, CV_8UC3); + cv::merge(filtChannel, filteredImage); + return filteredImage; + + } + + // Lumina noise filtering + /* this function luminance noise reduction is done. It will used different filtering methods for the luma noise reduction. + It is used the y component of the YCbCr color space for the enahncement. After enhancing the y + both the three components are merged and convet in to RGB color space*/ + + //@para: Mat * inputImage :- pointer varible for the input image + // Mat *outputImage :- pointer variable for the outout image + //@return value: integer + + int lumaNoiseFiltering(cv::Mat *inputImage, int tempValue) + { + cv::Mat YCrCb; + cv::Mat channels[3]; //creating array of Mat variables for the 3 cmponents of the YCrCb + + cvtColor(*inputImage, YCrCb, cv::COLOR_BGR2YCrCb, 3); + split(YCrCb, channels); + + int parameter = tempValue; //taking input values to select the filter type and its main parameter value for the process + + if (filterType == "Box") + { + lumaNoiseBoxFilter(channels[0], channels[1], channels[2], parameter); + } + else if (filterType == "Gaussian") + { + lumaNoiseGaussianFilter(channels[0], channels[1], channels[2], parameter); + } + else if (filterType == "Median") + { + lumaNoiseMedianFilter(channels[0], channels[1], channels[2], parameter); + } + else if (filterType == "Bilateral") + { + lumaNoiseBilateralFilter(channels[0], channels[1], channels[2], parameter); + } + return 0; + } + + //filter the Cr and Cb components of the YCrCb image using Box filter + int lumaNoiseBoxFilter(cv::Mat y, cv::Mat Cb, cv::Mat Cr, int i) + { + cv::Mat outputImage; + blur(y, y, cv::Size(i, i), cv::Point(-1, -1)); + + std::vector finalChannels = { y, Cb, Cr }; + + merge(finalChannels, outputImage); // merge the filtered components and the luma part to creat the output image in YCrCb color space + cvtColor(outputImage, tempAdjusted, cv::COLOR_YCrCb2BGR); + refreshPicBox(tempAdjusted); + refreshHistBox(Histogram(&tempAdjusted)); + return 0; + } + + //filter the Cr and Cb components of the YCrCb image using Gaussian filter + int lumaNoiseGaussianFilter(cv::Mat y, cv::Mat Cb, cv::Mat Cr, int i) + { + + cv::Mat outputImage; + GaussianBlur(y, y, cv::Size(i, i), 0, 0, 1); + + std::vector finalChannels = { y, Cb, Cr }; + + merge(finalChannels, outputImage); + + cvtColor(outputImage, tempAdjusted, cv::COLOR_YCrCb2BGR); + refreshPicBox(tempAdjusted); + refreshHistBox(Histogram(&tempAdjusted)); + return 0; + } + + int lumaNoiseMedianFilter(cv::Mat y, cv::Mat Cb, cv::Mat Cr, int i) + { + cv::Mat outputImage; + medianBlur(y, y, i); + + std::vector finalChannels = { y, Cb, Cr }; + merge(finalChannels, outputImage); + cvtColor(outputImage, tempAdjusted, cv::COLOR_YCrCb2BGR); + refreshPicBox(tempAdjusted); + refreshHistBox(Histogram(&tempAdjusted)); + return 0; + } + + //filter the Cr and Cb components of the YCrCb image using Bilateral filter + int lumaNoiseBilateralFilter(cv::Mat y, cv::Mat Cb, cv::Mat Cr, int i) + { + + cv::Mat outputImage; + bilateralFilter(y, y, i, i * 2, i / 2); + + std::vector finalChannels = { y, Cb,Cr }; + merge(finalChannels, outputImage); + cvtColor(outputImage, tempAdjusted, cv::COLOR_YCrCb2BGR); + refreshPicBox(tempAdjusted); + refreshHistBox(Histogram(&tempAdjusted)); + return 0; + } + + // Colour noise filtering + + int colorNoiseFiltering(cv::Mat *inputImage, int tempValue) + { + cv::Mat YCrCb; + cv::Mat channels[3]; //creating array of Mat variables for the 3 cmponents of the YCrCb + + cvtColor(*inputImage, YCrCb, cv::COLOR_BGR2YCrCb, 3); + split(YCrCb, channels); + + int parameter = tempValue; //taking input values to select the filter type and its main parameter value for the process + + if (filterType == "Box") + { + colorNoiseBoxFilter(channels[0], channels[1], channels[2], parameter); + } + else if (filterType == "Gaussian") + { + colorNoiseGaussianFilter(channels[0], channels[1], channels[2], parameter); + } + else if (filterType == "Median") + { + colorNoiseMedianFilter(channels[0], channels[1], channels[2], parameter); + } + else if (filterType == "Bilateral") + { + colorNoiseBilateralFilter(channels[0], channels[1], channels[2], parameter); + } + + return 0; + + } + + int colorNoiseBoxFilter(cv::Mat y, cv::Mat Cb, cv::Mat Cr, int i) + { + cv::Mat outputImage; + cv::blur(Cb, Cb, cv::Size(i, i), cv::Point(-1, -1)); + cv::blur(Cr, Cr, cv::Size(i, i), cv::Point(-1, -1)); + + std::vector finalChannels = { y, Cb, Cr }; + + merge(finalChannels, outputImage); // merge the filtered components and the luma part to creat the output image in YCrCb color space + cvtColor(outputImage, tempAdjusted, cv::COLOR_YCrCb2BGR); + refreshPicBox(tempAdjusted); + refreshHistBox(Histogram(&tempAdjusted)); + return 0; + } + + int colorNoiseGaussianFilter(cv::Mat y, cv::Mat Cb, cv::Mat Cr, int i) + { + + cv::Mat outputImage; + cv::GaussianBlur(Cb, Cb, cv::Size(i, i), 0, 0, 1); + cv::GaussianBlur(Cr, Cr, cv::Size(i, i), 0, 0, 1); + + + std::vector finalChannels = { y, Cb, Cr }; + + merge(finalChannels, outputImage); + + cvtColor(outputImage, tempAdjusted, cv::COLOR_YCrCb2BGR); + refreshPicBox(tempAdjusted); + refreshHistBox(Histogram(&tempAdjusted)); + return 0; + } + + //filter the Cr and Cb components of the YCrCb image using Median filter + int colorNoiseMedianFilter(cv::Mat y, cv::Mat Cb, cv::Mat Cr, int i) + { + cv::Mat outputImage; + cv::medianBlur(Cb, Cb, i); + cv::medianBlur(Cr, Cr, i); + + std::vector finalChannels = { y, Cb, Cr }; + merge(finalChannels, outputImage); + cvtColor(outputImage, tempAdjusted, cv::COLOR_YCrCb2BGR); + refreshPicBox(tempAdjusted); + refreshHistBox(Histogram(&tempAdjusted)); + return 0; + } + + //filter the Cr and Cb components of the YCrCb image using Bilateral filter + int colorNoiseBilateralFilter(cv::Mat y, cv::Mat Cb, cv::Mat Cr, int i) + { + cv::Mat outputImage; + cv::bilateralFilter(Cb, Cb, i, i * 2, i / 2); + cv::bilateralFilter(Cr, Cr, i, i * 2, i / 2); + + std::vector finalChannels = { y, Cb, Cr }; + merge(finalChannels, outputImage); + cvtColor(outputImage, tempAdjusted, cv::COLOR_YCrCb2BGR); + refreshPicBox(tempAdjusted); + refreshHistBox(Histogram(&tempAdjusted)); + return 0; + } + + // Highlights and recovery + + // Shadow recovery + int shadowRecovery(cv::Mat * image, int gamma) + { + cv::Mat im = *image; + int x, y; + + cv::Mat redChan, greenChan, blueChan; + cv::Mat edited2[3]; + split(*image, edited2); + redChan = edited2[2]; + greenChan = edited2[1]; + blueChan = edited2[0]; + + double gammaUnder = 0; + double gammaUpper = 0; + + gammaUnder = 1 + 0.03*abs(gamma); //define the appropriate gamma values for the shadow recovery + gammaUpper = 1 - 0.006*abs(gamma); + + for (x = 0; x < im.rows; x++) { // check the pixel values of the image change the value if the pixel values are below the 90 + for (y = 0; y < im.cols; y++) { + + int blue = blueChan.at(x, y); + int green = greenChan.at(x, y); + int red = redChan.at(x, y); + + //blue value + if (blue < 90 && gamma >0) //changing the RGB values seperately + { + blue = (int)90 * pow(((blue) / (double)90), gammaUpper); + } + else if (blue < 90 && gamma <0) + { + blue = (int)90 * pow(((blue) / (double)90), gammaUnder); + } + //green value + if (green < 90 && gamma >0) + { + green = (int)90 * pow(((green) / (double)90), gammaUpper); + + } + else if (green < 90 && gamma <0) + { + green = (int)90 * pow(((green) / (double)90), gammaUnder); + + } + //red value + if (red < 90 && gamma >0) + { + red = (int)90 * pow(((red) / (double)90), gammaUpper); + } + else if (red < 90 && gamma <0) + { + red = (int)90 * pow(((red) / (double)90), gammaUnder); + } + + //im.at(x, y) = cv::Vec3b(blue, green, red); + blueChan.at(x, y) = blue; + greenChan.at(x, y) = green; + redChan.at(x, y) = red; + } + } + std::vector finalChannels = { blueChan, greenChan, redChan }; + merge(finalChannels, tempAdjusted); + + refreshPicBox(tempAdjusted); + refreshHistBox(Histogram(&tempAdjusted)); + return 0; + } + + //Highlights + int highlightsRecovery(cv::Mat * image, int gamma) + { + cv::Mat im = *image; + + int x, y; + + cv::Mat redChan, greenChan, blueChan; + cv::Mat edited2[3]; + split(*image, edited2); + redChan = edited2[2]; + greenChan = edited2[1]; + blueChan = edited2[0]; + + double gammaUnder = 0; + double gammaUpper = 0; + + gammaUpper = 1 + 0.03*abs(gamma); //define the appropriate gamma values for the shadow recovery + gammaUnder = 1 - 0.006*abs(gamma); + + + for (x = 0; x < im.rows; x++) { // check the pixel values of the image change the value if the pixel values are below the 90 + for (y = 0; y < im.cols; y++) { + /*cv::Vec3b intensity = im.at(x, y); + uchar blue = intensity.val[0]; //obtain the RGB values seperately + uchar green = intensity.val[1]; + uchar red = intensity.val[2]; */ + + int blue = blueChan.at(x, y); + int green = greenChan.at(x, y); + int red = redChan.at(x, y); + + //blue value + if (blue > 153 && gamma >0) //changing the RGB values seperately + { + blue = 255 - (int)102 * pow(((255 - blue) / (double)102), gammaUpper); + } + else if (blue > 153 && gamma <0) + { + blue = 255 - (int)102 * pow(((255 - blue) / (double)102), gammaUnder); + } + //green value + if (green > 153 && gamma >0) + { + green = 255 - (int)102 * pow(((255 - green) / (double)102), gammaUpper); + } + else if (green > 153 && gamma <0) + { + green = 255 - (int)102 * pow(((255 - green) / (double)102), gammaUnder); + } + //red value + if (red > 153 && gamma >0) + { + red = 255 - (int)102 * pow(((255 - red) / (double)102), gammaUpper); + } + else if (red > 153 && gamma <0) + { + red = 255 - (int)102 * pow(((255 - red) / (double)102), gammaUnder); + } + + //im.at(x, y) = cv::Vec3b(blue, green, red); + blueChan.at(x, y) = blue; + greenChan.at(x, y) = green; + redChan.at(x, y) = red; + + } + + } + std::vector finalChannels = { blueChan, greenChan, redChan }; + merge(finalChannels, tempAdjusted); + + refreshPicBox(tempAdjusted); + refreshHistBox(Histogram(&tempAdjusted)); + return 0; + } + + int refreshPicBox(cv::Mat displayImage) + { + // pictureBox1->Refresh(); + System::Drawing::Graphics^ graphics = pictureBox1->CreateGraphics(); + //graphics->Clear(System::Drawing::Color::White); + System::IntPtr ptr(displayImage.ptr()); + try { + System::Drawing::Bitmap^ b = gcnew System::Drawing::Bitmap(displayImage.cols, displayImage.rows, displayImage.step, System::Drawing::Imaging::PixelFormat::Format24bppRgb, ptr); + pictureBox1->Image = b; + } + catch (System::ArgumentException^ e) { + if (!displayImage.empty()) { + System::Drawing::Bitmap^ b = gcnew System::Drawing::Bitmap(displayImage.cols, displayImage.rows, displayImage.step, System::Drawing::Imaging::PixelFormat::Format24bppRgb, ptr); + pictureBox1->Image = b; + } + } + return 0; + } + + int refreshHistBox(cv::Mat displayImage) + { + System::Drawing::Graphics^ graphics = RGBHist->CreateGraphics(); + System::IntPtr ptr(displayImage.ptr()); + System::Drawing::Bitmap^ b = gcnew System::Drawing::Bitmap(displayImage.cols, displayImage.rows, displayImage.step, System::Drawing::Imaging::PixelFormat::Format24bppRgb, ptr); + System::Drawing::RectangleF rect(0, 0, RGBHist->Width, RGBHist->Height); + graphics->DrawImage(b, rect); + return 0; + } + + +}; +} diff --git a/imageEnhancer/MyGUI/MyForm.h~Updated upstream b/imageEnhancer/MyGUI/MyForm.h~Updated upstream new file mode 100644 index 0000000..4c3cf31 --- /dev/null +++ b/imageEnhancer/MyGUI/MyForm.h~Updated upstream @@ -0,0 +1,725 @@ +#pragma once + +#include +#include +#include +#include +#include "spline.h" +#include "math.h" + +cv::Mat editedImage; +cv::Mat tempAdjusted; +cv::Mat bgrAdjusted; +cv::Mat adjRchan, adjGchan, adjBchan; + + +namespace MyGUI { + + using namespace System; + using namespace System::ComponentModel; + using namespace System::Collections; + using namespace System::Windows::Forms; + using namespace System::Data; + using namespace System::Drawing; + + /// + /// Summary for MyForm + /// + public ref class MyForm : public System::Windows::Forms::Form + { + public: + MyForm(void) + { + InitializeComponent(); + // + //TODO: Add the constructor code here + // + } + + protected: + /// + /// Clean up any resources being used. + /// + ~MyForm() + { + if (components) + { + delete components; + } + } + private: System::Windows::Forms::MenuStrip^ menuStrip1; + protected: + private: System::Windows::Forms::ToolStripMenuItem^ fileToolStripMenuItem; + private: System::Windows::Forms::ToolStripMenuItem^ importToolStripMenuItem; + private: System::Windows::Forms::ToolStripMenuItem^ exitToolStripMenuItem; + private: System::Windows::Forms::PictureBox^ pictureBox1; + private: System::Windows::Forms::TrackBar^ trackBar1; + private: System::Windows::Forms::Label^ label1; + private: System::Windows::Forms::Label^ label2; + private: System::Windows::Forms::Label^ label3; + private: System::Windows::Forms::Label^ label4; + private: System::Windows::Forms::Panel^ tempPanel; + + + private: System::Windows::Forms::Button^ tempApply; + private: System::Windows::Forms::NotifyIcon^ notifyIcon1; + private: System::Windows::Forms::Button^ loadColourAdj; + private: System::Windows::Forms::Button^ loadTempAdj; + private: System::Windows::Forms::Panel^ rgbPanel; + + private: System::Windows::Forms::Label^ label5; + private: System::Windows::Forms::Button^ rgbApply; + private: System::Windows::Forms::TrackBar^ blueTrackBar; + + private: System::Windows::Forms::TrackBar^ greenTrackBar; + private: System::Windows::Forms::TrackBar^ redTrackBar; + private: System::Windows::Forms::Label^ label7; + private: System::Windows::Forms::Label^ label6; + + + + 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) + { + this->components = (gcnew System::ComponentModel::Container()); + System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(MyForm::typeid)); + this->menuStrip1 = (gcnew System::Windows::Forms::MenuStrip()); + this->fileToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); + this->importToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); + this->exitToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); + this->pictureBox1 = (gcnew System::Windows::Forms::PictureBox()); + this->trackBar1 = (gcnew System::Windows::Forms::TrackBar()); + this->label1 = (gcnew System::Windows::Forms::Label()); + this->label2 = (gcnew System::Windows::Forms::Label()); + this->label3 = (gcnew System::Windows::Forms::Label()); + this->label4 = (gcnew System::Windows::Forms::Label()); + this->tempPanel = (gcnew System::Windows::Forms::Panel()); + this->tempApply = (gcnew System::Windows::Forms::Button()); + this->notifyIcon1 = (gcnew System::Windows::Forms::NotifyIcon(this->components)); + this->loadColourAdj = (gcnew System::Windows::Forms::Button()); + this->loadTempAdj = (gcnew System::Windows::Forms::Button()); + this->rgbPanel = (gcnew System::Windows::Forms::Panel()); + this->label7 = (gcnew System::Windows::Forms::Label()); + this->label6 = (gcnew System::Windows::Forms::Label()); + this->label5 = (gcnew System::Windows::Forms::Label()); + this->rgbApply = (gcnew System::Windows::Forms::Button()); + this->blueTrackBar = (gcnew System::Windows::Forms::TrackBar()); + this->greenTrackBar = (gcnew System::Windows::Forms::TrackBar()); + this->redTrackBar = (gcnew System::Windows::Forms::TrackBar()); + this->menuStrip1->SuspendLayout(); + (cli::safe_cast(this->pictureBox1))->BeginInit(); + (cli::safe_cast(this->trackBar1))->BeginInit(); + this->tempPanel->SuspendLayout(); + this->rgbPanel->SuspendLayout(); + (cli::safe_cast(this->blueTrackBar))->BeginInit(); + (cli::safe_cast(this->greenTrackBar))->BeginInit(); + (cli::safe_cast(this->redTrackBar))->BeginInit(); + this->SuspendLayout(); + // + // menuStrip1 + // + this->menuStrip1->BackColor = System::Drawing::Color::SkyBlue; + this->menuStrip1->Items->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(1) { this->fileToolStripMenuItem }); + this->menuStrip1->Location = System::Drawing::Point(0, 0); + this->menuStrip1->Name = L"menuStrip1"; + this->menuStrip1->Size = System::Drawing::Size(1264, 24); + this->menuStrip1->TabIndex = 0; + this->menuStrip1->Text = L"menuStrip1"; + // + // fileToolStripMenuItem + // + this->fileToolStripMenuItem->DropDownItems->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(2) { + this->importToolStripMenuItem, + this->exitToolStripMenuItem + }); + this->fileToolStripMenuItem->Name = L"fileToolStripMenuItem"; + this->fileToolStripMenuItem->Size = System::Drawing::Size(37, 20); + this->fileToolStripMenuItem->Text = L"File"; + // + // importToolStripMenuItem + // + this->importToolStripMenuItem->Name = L"importToolStripMenuItem"; + this->importToolStripMenuItem->Size = System::Drawing::Size(110, 22); + this->importToolStripMenuItem->Text = L"Import"; + this->importToolStripMenuItem->Click += gcnew System::EventHandler(this, &MyForm::importToolStripMenuItem_Click); + // + // exitToolStripMenuItem + // + this->exitToolStripMenuItem->Name = L"exitToolStripMenuItem"; + this->exitToolStripMenuItem->Size = System::Drawing::Size(110, 22); + this->exitToolStripMenuItem->Text = L"Exit"; + // + // pictureBox1 + // + this->pictureBox1->BackColor = System::Drawing::SystemColors::ControlLightLight; + this->pictureBox1->BackgroundImage = (cli::safe_cast(resources->GetObject(L"pictureBox1.BackgroundImage"))); + this->pictureBox1->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Center; + this->pictureBox1->Location = System::Drawing::Point(28, 96); + this->pictureBox1->Name = L"pictureBox1"; + this->pictureBox1->Size = System::Drawing::Size(640, 480); + this->pictureBox1->SizeMode = System::Windows::Forms::PictureBoxSizeMode::StretchImage; + this->pictureBox1->TabIndex = 1; + this->pictureBox1->TabStop = false; + // + // trackBar1 + // + this->trackBar1->Location = System::Drawing::Point(32, 43); + this->trackBar1->Maximum = 5; + this->trackBar1->Minimum = -5; + this->trackBar1->Name = L"trackBar1"; + this->trackBar1->Size = System::Drawing::Size(166, 45); + this->trackBar1->TabIndex = 2; + this->trackBar1->TickFrequency = 0; + this->trackBar1->Scroll += gcnew System::EventHandler(this, &MyForm::tempTrackBar_Scroll); + // + // label1 + // + this->label1->AutoSize = true; + this->label1->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 10, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label1->ForeColor = System::Drawing::SystemColors::ActiveCaptionText; + this->label1->Location = System::Drawing::Point(72, 16); + this->label1->Name = L"label1"; + this->label1->Size = System::Drawing::Size(96, 18); + this->label1->TabIndex = 3; + this->label1->Text = L"Temperature "; + // + // label2 + // + this->label2->AutoSize = true; + this->label2->Font = (gcnew System::Drawing::Font(L"Microsoft Sans Serif", 10, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label2->Location = System::Drawing::Point(95, 12); + this->label2->Name = L"label2"; + this->label2->Size = System::Drawing::Size(55, 17); + this->label2->TabIndex = 4; + this->label2->Text = L"Colour"; + // + // label3 + // + this->label3->AutoSize = true; + this->label3->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 8.25F, System::Drawing::FontStyle::Italic, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label3->ForeColor = System::Drawing::Color::Blue; + this->label3->Location = System::Drawing::Point(3, 43); + this->label3->Name = L"label3"; + this->label3->Size = System::Drawing::Size(31, 16); + this->label3->TabIndex = 5; + this->label3->Text = L"Cold"; + // + // label4 + // + this->label4->AutoSize = true; + this->label4->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 8.25F, System::Drawing::FontStyle::Italic, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label4->ForeColor = System::Drawing::Color::Red; + this->label4->Location = System::Drawing::Point(196, 43); + this->label4->Name = L"label4"; + this->label4->Size = System::Drawing::Size(37, 16); + this->label4->TabIndex = 6; + this->label4->Text = L"Warm"; + // + // tempPanel + // + this->tempPanel->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->tempPanel->BorderStyle = System::Windows::Forms::BorderStyle::FixedSingle; + this->tempPanel->Controls->Add(this->label4); + this->tempPanel->Controls->Add(this->label3); + this->tempPanel->Controls->Add(this->tempApply); + this->tempPanel->Controls->Add(this->label1); + this->tempPanel->Controls->Add(this->trackBar1); + this->tempPanel->Location = System::Drawing::Point(858, 257); + this->tempPanel->Name = L"tempPanel"; + this->tempPanel->Size = System::Drawing::Size(240, 130); + this->tempPanel->TabIndex = 8; + this->tempPanel->Visible = false; + // + // tempApply + // + this->tempApply->Location = System::Drawing::Point(75, 74); + this->tempApply->Name = L"tempApply"; + this->tempApply->Size = System::Drawing::Size(80, 24); + this->tempApply->TabIndex = 0; + this->tempApply->Text = L"Apply"; + this->tempApply->UseVisualStyleBackColor = true; + this->tempApply->Click += gcnew System::EventHandler(this, &MyForm::tempApply_Click); + // + // notifyIcon1 + // + this->notifyIcon1->Text = L"notifyIcon1"; + this->notifyIcon1->Visible = true; + // + // loadColourAdj + // + this->loadColourAdj->BackColor = System::Drawing::Color::DimGray; + this->loadColourAdj->BackgroundImage = (cli::safe_cast(resources->GetObject(L"loadColourAdj.BackgroundImage"))); + this->loadColourAdj->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Stretch; + this->loadColourAdj->Location = System::Drawing::Point(28, 27); + this->loadColourAdj->Name = L"loadColourAdj"; + this->loadColourAdj->Size = System::Drawing::Size(64, 64); + this->loadColourAdj->TabIndex = 9; + this->loadColourAdj->UseVisualStyleBackColor = false; + this->loadColourAdj->Click += gcnew System::EventHandler(this, &MyForm::loadColourAdj_Click); + this->loadColourAdj->MouseHover += gcnew System::EventHandler(this, &MyForm::loadColourAdj_MouseHover); + // + // loadTempAdj + // + this->loadTempAdj->BackColor = System::Drawing::Color::Yellow; + this->loadTempAdj->BackgroundImage = (cli::safe_cast(resources->GetObject(L"loadTempAdj.BackgroundImage"))); + this->loadTempAdj->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Stretch; + this->loadTempAdj->Location = System::Drawing::Point(98, 27); + this->loadTempAdj->Name = L"loadTempAdj"; + this->loadTempAdj->Size = System::Drawing::Size(64, 64); + this->loadTempAdj->TabIndex = 10; + this->loadTempAdj->UseVisualStyleBackColor = false; + this->loadTempAdj->Click += gcnew System::EventHandler(this, &MyForm::loadTempAdj_Click); + this->loadTempAdj->MouseHover += gcnew System::EventHandler(this, &MyForm::loadTempAdj_MouseHover); + // + // rgbPanel + // + this->rgbPanel->BackColor = System::Drawing::SystemColors::ActiveCaption; + this->rgbPanel->Controls->Add(this->label7); + this->rgbPanel->Controls->Add(this->label6); + this->rgbPanel->Controls->Add(this->label5); + this->rgbPanel->Controls->Add(this->rgbApply); + this->rgbPanel->Controls->Add(this->blueTrackBar); + this->rgbPanel->Controls->Add(this->greenTrackBar); + this->rgbPanel->Controls->Add(this->redTrackBar); + this->rgbPanel->Controls->Add(this->label2); + this->rgbPanel->Location = System::Drawing::Point(858, 217); + this->rgbPanel->Name = L"rgbPanel"; + this->rgbPanel->Size = System::Drawing::Size(240, 216); + this->rgbPanel->TabIndex = 11; + this->rgbPanel->Visible = false; + // + // label7 + // + this->label7->AutoSize = true; + this->label7->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 9.75F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label7->ForeColor = System::Drawing::Color::Blue; + this->label7->Location = System::Drawing::Point(207, 116); + this->label7->Name = L"label7"; + this->label7->Size = System::Drawing::Size(16, 18); + this->label7->TabIndex = 19; + this->label7->Text = L"B"; + // + // label6 + // + this->label6->AutoSize = true; + this->label6->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 9.75F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label6->ForeColor = System::Drawing::Color::Green; + this->label6->Location = System::Drawing::Point(207, 77); + this->label6->Name = L"label6"; + this->label6->Size = System::Drawing::Size(17, 18); + this->label6->TabIndex = 18; + this->label6->Text = L"G"; + // + // label5 + // + this->label5->AutoSize = true; + this->label5->Font = (gcnew System::Drawing::Font(L"Trebuchet MS", 9.75F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->label5->ForeColor = System::Drawing::Color::Red; + this->label5->Location = System::Drawing::Point(207, 40); + this->label5->Name = L"label5"; + this->label5->Size = System::Drawing::Size(16, 18); + this->label5->TabIndex = 17; + this->label5->Text = L"R"; + // + // rgbApply + // + this->rgbApply->Location = System::Drawing::Point(81, 164); + this->rgbApply->Name = L"rgbApply"; + this->rgbApply->Size = System::Drawing::Size(80, 24); + this->rgbApply->TabIndex = 16; + this->rgbApply->Text = L"Apply"; + this->rgbApply->UseVisualStyleBackColor = true; + this->rgbApply->Click += gcnew System::EventHandler(this, &MyForm::rgbApply_Click); + // + // blueTrackBar + // + this->blueTrackBar->Location = System::Drawing::Point(42, 113); + this->blueTrackBar->Maximum = 20; + this->blueTrackBar->Minimum = 1; + this->blueTrackBar->Name = L"blueTrackBar"; + this->blueTrackBar->Size = System::Drawing::Size(166, 45); + this->blueTrackBar->TabIndex = 15; + this->blueTrackBar->TickFrequency = 0; + this->blueTrackBar->Value = 10; + this->blueTrackBar->Scroll += gcnew System::EventHandler(this, &MyForm::blueTrackBar_Scroll); + // + // greenTrackBar + // + this->greenTrackBar->Location = System::Drawing::Point(42, 76); + this->greenTrackBar->Maximum = 20; + this->greenTrackBar->Minimum = 1; + this->greenTrackBar->Name = L"greenTrackBar"; + this->greenTrackBar->Size = System::Drawing::Size(166, 45); + this->greenTrackBar->TabIndex = 14; + this->greenTrackBar->TickFrequency = 0; + this->greenTrackBar->Value = 10; + this->greenTrackBar->Scroll += gcnew System::EventHandler(this, &MyForm::greenTrackBar_Scroll); + // + // redTrackBar + // + this->redTrackBar->Location = System::Drawing::Point(42, 39); + this->redTrackBar->Maximum = 20; + this->redTrackBar->Minimum = 1; + this->redTrackBar->Name = L"redTrackBar"; + this->redTrackBar->Size = System::Drawing::Size(166, 45); + this->redTrackBar->TabIndex = 13; + this->redTrackBar->TickFrequency = 0; + this->redTrackBar->Value = 10; + this->redTrackBar->Scroll += gcnew System::EventHandler(this, &MyForm::redTrackBar_Scroll); + // + // MyForm + // + this->AutoScaleDimensions = System::Drawing::SizeF(6, 13); + this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font; + this->ClientSize = System::Drawing::Size(1264, 681); + this->Controls->Add(this->loadTempAdj); + this->Controls->Add(this->loadColourAdj); + this->Controls->Add(this->pictureBox1); + this->Controls->Add(this->menuStrip1); + this->Controls->Add(this->rgbPanel); + this->Controls->Add(this->tempPanel); + this->MainMenuStrip = this->menuStrip1; + this->Name = L"MyForm"; + this->Text = L"MyForm"; + this->menuStrip1->ResumeLayout(false); + this->menuStrip1->PerformLayout(); + (cli::safe_cast(this->pictureBox1))->EndInit(); + (cli::safe_cast(this->trackBar1))->EndInit(); + this->tempPanel->ResumeLayout(false); + this->tempPanel->PerformLayout(); + this->rgbPanel->ResumeLayout(false); + this->rgbPanel->PerformLayout(); + (cli::safe_cast(this->blueTrackBar))->EndInit(); + (cli::safe_cast(this->greenTrackBar))->EndInit(); + (cli::safe_cast(this->redTrackBar))->EndInit(); + this->ResumeLayout(false); + this->PerformLayout(); + + } +#pragma endregion + private: System::Void importToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) { + + // Displays an OpenFileDialog so the user can select an image file. + OpenFileDialog ^ openFileDialog1 = gcnew OpenFileDialog(); + openFileDialog1->Filter = "All Graphics Types|*.bmp;*.jpg;*.jpeg;*.png;*.tif;*.tiff"; + openFileDialog1->Title = "Select an Image File"; + + // Show the Dialog. + // If the user clicked OK in the dialog and + if (openFileDialog1->ShowDialog() == System::Windows::Forms::DialogResult::OK) + { + // Assign the cursor in the Stream to + // the Form's Cursor property. + // cache.jpg is the copy of the original image used for editing + pictureBox1->Load(openFileDialog1->FileName); + pictureBox1->Image->Save("cache.jpg", System::Drawing::Imaging::ImageFormat::Jpeg); + editedImage = cv::imread("cache.jpg", cv::IMREAD_COLOR); + } + } + + private: System::Void tempTrackBar_Scroll(System::Object^ sender, System::EventArgs^ e) { + // Acquire track bar value + int trackBarValue = trackBar1->Value; + + // Initiate a Mat to save the cache.jpg image + cv::Mat mainImage; + mainImage = editedImage; + colourTempAdjustment(&mainImage, trackBarValue); + tempApply->Enabled = true; + } + + private: System::Void loadColourAdj_MouseHover(System::Object^ sender, System::EventArgs^ e) { + System::Windows::Forms::ToolTip^ ToolTip1 = gcnew System::Windows::Forms::ToolTip; + ToolTip1->SetToolTip(loadColourAdj, "Adjust RGB Palettes"); + } + + private: System::Void loadTempAdj_MouseHover(System::Object^ sender, System::EventArgs^ e) { + System::Windows::Forms::ToolTip^ ToolTip1 = gcnew System::Windows::Forms::ToolTip; + ToolTip1->SetToolTip(loadTempAdj, "Adjust Colour Temperature"); + } + + private: System::Void tempApply_Click(System::Object^ sender, System::EventArgs^ e) { + editedImage = tempAdjusted.clone(); + tempApply->Enabled = false; + } + + private: System::Void loadColourAdj_Click(System::Object^ sender, System::EventArgs^ e) { + // Updating global RGB channels + cv::Mat edited2[3]; + split(editedImage, edited2); + adjRchan = edited2[2]; + adjGchan = edited2[1]; + adjBchan = edited2[0]; + + // Controlling panels + rgbPanel->Visible = true; + tempPanel->Visible = false; + } + + private: System::Void loadTempAdj_Click(System::Object^ sender, System::EventArgs^ e) { + // Controlling panels + rgbPanel->Visible = false; + tempPanel->Visible = true; + } + + private: System::Void rgbApply_Click(System::Object^ sender, System::EventArgs^ e) { + editedImage = bgrAdjusted.clone(); + } + + private: System::Void redTrackBar_Scroll(System::Object^ sender, System::EventArgs^ e) { + cv::Mat edited2[3], redChan, greenChan, blueChan; + split(editedImage, edited2); + redChan = edited2[2]; + greenChan = edited2[1]; + blueChan = edited2[0]; + float fGamma = redTrackBar->Value / 10.0; + unsigned char lut[256]; + + for (int i = 0; i < 256; i++) + { + lut[i] = cv::saturate_cast(pow((float)(i / 255.0), fGamma) * 255.0f); + } + + cv::MatIterator_ it, end; + + for (it = redChan.begin(), end = redChan.end(); it != end; it++) + + *it = lut[(*it)]; + + adjRchan = redChan; + + // Merging the BGR channels + std::vector < cv::Mat > arrayToMerge; + arrayToMerge.push_back(adjBchan); + arrayToMerge.push_back(adjGchan); + arrayToMerge.push_back(adjRchan); + + + // Image with altered red abd blue channels + cv::Mat bgrAdjusted; + merge(arrayToMerge, bgrAdjusted); + refreshPicBox(bgrAdjusted); + } + + private: System::Void greenTrackBar_Scroll(System::Object^ sender, System::EventArgs^ e) { + cv::Mat edited2[3], redChan, greenChan, blueChan; + split(editedImage, edited2); + redChan = edited2[2]; + greenChan = edited2[1]; + blueChan = edited2[0]; + float fGamma = greenTrackBar->Value / 10.0; + unsigned char lut[256]; + + for (int i = 0; i < 256; i++) + { + lut[i] = cv::saturate_cast(pow((float)(i / 255.0), fGamma) * 255.0f); + } + + cv::MatIterator_ it, end; + + + for (it = greenChan.begin(), end = greenChan.end(); it != end; it++) + + *it = lut[(*it)]; + adjGchan = greenChan; + // Merging the BGR channels + std::vector < cv::Mat > arrayToMerge; + arrayToMerge.push_back(adjBchan); + arrayToMerge.push_back(adjGchan); + arrayToMerge.push_back(adjRchan); + + // Image with altered red abd blue channels + cv::Mat bgrAdjusted; + merge(arrayToMerge, bgrAdjusted); + refreshPicBox(bgrAdjusted); + } + + private: System::Void blueTrackBar_Scroll(System::Object^ sender, System::EventArgs^ e) { + cv::Mat edited2[3], redChan, greenChan, blueChan; + split(editedImage, edited2); + redChan = edited2[2]; + greenChan = edited2[1]; + blueChan = edited2[0]; + float fGamma = blueTrackBar->Value / 10.0; + unsigned char lut[256]; + + for (int i = 0; i < 256; i++) + { + lut[i] = cv::saturate_cast(pow((float)(i / 255.0), fGamma) * 255.0f); + } + + cv::MatIterator_ it, end; + + + for (it = blueChan.begin(), end = blueChan.end(); it != end; it++) + + *it = lut[(*it)]; + adjBchan = blueChan; + // Merging the BGR channels + std::vector < cv::Mat > arrayToMerge; + arrayToMerge.push_back(adjBchan); + arrayToMerge.push_back(adjGchan); + arrayToMerge.push_back(adjRchan); + + // Image with altered red abd blue channels + cv::Mat bgrAdjusted; + merge(arrayToMerge, bgrAdjusted); + refreshPicBox(bgrAdjusted); + } + // Functions defined in opencv + // Display image + int displayImage(cv::Mat *mainImage, cv::String imageDes) + { + cv::Mat tempImage; + tempImage = *mainImage; + if (tempImage.empty()) // Check for invalid input + { + return -1; + } + namedWindow(imageDes, cv::WINDOW_AUTOSIZE); // Create a window for display. + imshow(imageDes, tempImage); // Show our image inside it. + cv::waitKey(0); // Wait for a keystroke in the window + return 0; + } + + //Colour temperature adjustment + int colourTempAdjustment(cv::Mat *mainImage, int tempValue) + { + int absTemp = abs(tempValue); + cv::Mat resolvedImage[3]; + cv::Mat blueChannel, greenChannel, redChannel; + split(*mainImage, resolvedImage); // Splitting the BGR channels + + // Create warmer image + // Done by increasing the red channel and decreasing the blue channel + // and increasing saturation of the image in HSV colour space + + // Create a cooler image + // Done by decreasing the red channel and increasing blue channel + // and decreasing the saturation of the image in the HSV colour image + + // Spline interpolation + std::vector X(5), Y(5), Z(5); + X[0] = 0; X[1] = 64; X[2] = 128; X[3] = 192; X[4] = 255; + + Y[0] = 5 * absTemp; Y[1] = 64 + (7 * absTemp); Y[2] = 128 + (8 * absTemp); + Y[3] = 192 + (10 * absTemp); Y[4] = 255; + + Z[0] = 0; Z[1] = 64 - (5 * absTemp); Z[2] = 128 - (7 * absTemp); + Z[3] = 192 - (8 * absTemp); Z[4] = 255 - (10 * absTemp); + + // Creating spline functions + tk::spline incIntensity, decIntensity; + incIntensity.set_points(X, Y); + decIntensity.set_points(X, Z); + + redChannel = resolvedImage[2]; //+ (10 * tempValue); + blueChannel = resolvedImage[0]; //- (10 * tempValue); + greenChannel = resolvedImage[1]; + + int width = redChannel.cols; + int height = redChannel.rows; + int nElements = width*height; + + // Calculating interpolated value for each matrix element + uchar* p1 = redChannel.data; + uchar* p2 = blueChannel.data; + + for (int i = 0; i < nElements; ++i) + { + if (tempValue >= 0) + { + p1[i] = (uchar)(incIntensity(p1[i])); + p2[i] = (uchar)(decIntensity(p2[i])); + } + else + { + p1[i] = (uchar)(decIntensity(p1[i])); + p2[i] = (uchar)(incIntensity(p2[i])); + } + } + + // Merging the BGR channels + std::vector < cv::Mat > arrayToMerge; + arrayToMerge.push_back(blueChannel); + arrayToMerge.push_back(greenChannel); + arrayToMerge.push_back(redChannel); + + // Image with altered red abd blue channels + cv::Mat bgrAdjusted; + merge(arrayToMerge, bgrAdjusted); + + // Convert image to HSV colour space and splitting layers for saturation adjustment + cv::Mat hsvImage; + cv::Mat hsvResolved[3]; + cvtColor(bgrAdjusted, hsvImage, CV_BGR2HSV); + split(hsvImage, hsvResolved); + + // Adjusting saturation + cv::Mat hNew, sNew, vNew; + hNew = hsvResolved[0]; + sNew = hsvResolved[1]; // +(10 * tempValue); + vNew = hsvResolved[2]; + + // Calculate interpolated value for saturation layer + uchar* p3 = sNew.data; + + for (int i = 0; i < nElements; ++i) + { + if (tempValue >= 0) + { + p3[i] = (uchar)(incIntensity(p3[i])); + } + else + { + p3[i] = (uchar)(decIntensity(p3[i])); + } + } + + // Merging the HSV channels + std::vector < cv::Mat > arrayToMergeHSV; + arrayToMergeHSV.push_back(hNew); + arrayToMergeHSV.push_back(sNew); + arrayToMergeHSV.push_back(vNew); + + // Converting the image back to BGR + cv::Mat hsvAdjusted; // Image with altered saturation channel + merge(arrayToMergeHSV, hsvAdjusted); + cvtColor(hsvAdjusted, tempAdjusted, CV_HSV2BGR); + refreshPicBox(tempAdjusted); + return 0; + } + + int refreshPicBox(cv::Mat displayImage) + { + System::Drawing::Graphics^ graphics = pictureBox1->CreateGraphics(); + System::IntPtr ptr(displayImage.ptr()); + System::Drawing::Bitmap^ b = gcnew System::Drawing::Bitmap(displayImage.cols, displayImage.rows, displayImage.step, System::Drawing::Imaging::PixelFormat::Format24bppRgb, ptr); + System::Drawing::RectangleF rect(0, 0, pictureBox1->Width, pictureBox1->Height); + graphics->DrawImage(b, rect); + return 0; + } + +}; + +} diff --git a/imageEnhancer/MyGUI/MyForm.resx b/imageEnhancer/MyGUI/MyForm.resx new file mode 100644 index 0000000..3130924 --- /dev/null +++ b/imageEnhancer/MyGUI/MyForm.resx @@ -0,0 +1,5351 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + +<<<<<<< Updated upstream + + + iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAAABGdBTUEAALGPC/xhBQAAHbBJREFUeF7t + nGmUlNWdxvNhPs6ck3NyZr7MTCaT+ZDMh0QS44q7owHUqAQEWZV934VmkV3Z9x0RUMEohkgUZVFABA60 + 7IsssooLLiCCqDExuXOfqnur/vXW7e7q6ltvVb3v8zvnOTmRprvu/z6/fy9U9Q9Icfmnjv9dT+eijopR + cN56ZgSExBctwkghRpwy0oyAkPgCEQJixCVcAIRABCvFL6bUVw+91iSywfnsWXFuMwJC4gtEsFJwARAS + MyCCleIXU+urZq83iWxwPntWnNuMgJD4AhGsFMkF0DSy4QIgJABEsFL8UgvSXIsS1eB89qw4txkBIfEF + IlgpEgtgjZYlouECICQARLBSQJCHtShRDRcAIQEggpWCC4CQmAERrBRXTb1JtVj7UGSD89mz4txmBITE + F4hgpbhqWsQXgD6fPSvObUZASHyBCFYKCNJSixLVcAEQEgAiWCkSC2CdliWi4QIgJABEsFLU04K00qJE + NTifPSvObUZASHyBCFaK5AJoFtlwARASACJYKSBI6/XNIhsuAEICQAQrRb3pEV8A+nz2rDi3GQEh8QUi + WCl+pQVpo0WJanA+e1ac24yAkPgCEawUiQXwhpYlouECICQARLBS/Gr6zartG80jG5zPnhXnNiMgJL5A + BCsFFwAhMQMiWCl+rQV5RIsS1eB89qw4txkBIfEFIlgpfj1DL4A3tSwRDc5nz4pzmxEQEl8ggpUCgjz6 + 5sORDRcAIQEggpUCgrTTokQ1XACEBIAIVoqrsQA2aFkiGpzPnhXnNiMgJL5ABCsFBGmvRYlquAAICQAR + rBRcAITEDIhgpbh65s2qw8YWkQ3OZ8+Kc5sREBJfIIKV4jczb3GKE5XgfPasOLcZASHxBSJYKSBIRy1K + VMMFQEgAiGClSCyATVqWiIYLgJAAEMFKAUE6aVGiGi4AQgJABCvFNYkF0DKywfnsWXFuMwJC4gtEsFJA + kM5vtYxsuAAICQARrBTXzIr4AtDns2fFuc0ICIkvEMFKAUG6aFGiGi4AQgJABCvFtVgAm7UsEQ3OZ8+K + c5sREBJfIIKV4tpZt6qum1tFNjifPSvObUZASHyBCFYKLgBCYgZEsFJAkG5alKiGC4CQABDBSnHdbL0A + 3tayRDQ4nz0rzm1GQEh8gQhWCgjSXYsS1XABEBIAIlgpkgugdWTDBUBIAIhgpYAgPba0jmy4AAgJABGs + FNdHfAHgfPasOLcZASHxBSJYKa6ffZvquaVNZIPz2bPi3GYEhMQXiGClgCC9tj4S2XABEBIAIlgpbphz + uxbl0cgG57NnxbnNCAiJLxDBSnHDnDtU763tIhucz54V5zYjICS+QAQrBQTps7V9ZMMFQEgAiGCluHHO + narPtg6RDc5nz4pzmxEQEl8ggpUCgvTd1imy4QIgJABEsFLcOOf/VL9tnSMbnM+eFec2IyAkvkAEK0X9 + OXdpUbpENjifPSvObUZASHyBCFaK+nPvUv23d41scD57VpzbjICQ+AIRrBT1596tBmzvFtngfPasOLcZ + ASHxBSJYKW5KLIAekQ3OZ8+Kc5sREBJfIIKV4qa5v1WPbe8Z2eB89qw4txkBIfEFIlgpbprbQA3c0Suy + wfnsWXFuMwJC4gtEsFLcnFgAvSMbnM+eFec2IyAkvkAEK8XNcxuqQTv6RDY4nz0rzm1GQEh8gQhWilu0 + IBU7+kU2OJ89K85tRkBIfIEIVopb5jVSFZX9Ixucz54V5zYjICS+QAQrBQQZXDkgsuECIEVFl66ezqYS + y2mdhBS3zrtHDal8LLLB+exZzbld8yhm6pmqkChiLlmWsKRy67x71dDKgZENzuc6dwllk6kKiSL6gpcE + Lryk0npVOzX0nYrIBudznbuEssRUhUQRfcE/1NkrLlzVm3SHarOqfdHT8fUuatg7gyMfnNN1/rCDe5c9 + 0EEvfmiqQqIKLtlcdury71/WXD3+zhAmJsF9y/vXofxxApetk/rhG9JsRVtdjqFMxNN2VQcpPoIeUP64 + oS8d/yJw0ZRA/XP3n6nOa7qr4TuHMREN7hf3bO/c3D9/8h9XcPmmBGIJ9FAjdj7ORCy4V8pPskAJTBlS + S6DLmp66NCOYiAT3SflJlegy3CbKoX7U7xeqYusQNXLnSKbMg3vEfcr71XnAXD0hSXQpHpEl+feKq9Xg + bUPVqF2jmDIN7g/3KO9V5xFz5YRkgnLIsiSXwDBdptFMmQX3RvlJrUFJZGlQotG7xjBlFspP8kaXJeMp + w1dPuluN2fUEUybBfcn70+FTfEntQGlkia6e/Fs1ZveTTIkH9yTvTYfyk/xAeWSZUK6xu8cxJRrKT7yj + S5TxEuJ7l7RUT+wez5RYcC/ynnT40l5Sd3SRsl481GR5O126CUyJBPch70eHL+4h/kCZTKlSJWv6fHv1 + 5J5JTJGDe5D3okP5iX9QKlOuVNlQvnF7JjNFSpuV3aT4COUnhUOX6yc66dcN9Pi56r2+Qo3fM4UJOZg7 + 5m/vwtwLn99PCgtKZsomlsBgXcqpTEjBvCk/KRoomyldagn0WT9UTdg7jSlwMGfKT4oOSidKmCjlqB0T + 1cS9M5gCBfMNyI/cZq6EkHDR5ct43cB/DL5WjU4sgZmM52CumK+ctw6f30+KC0ooS/mfuqRjKiepSXtn + MZ6CeWKucs46lJ+UBiijLGdyCUxRk/fNZuoYzJHyk5JHl3KaLOm1U+7TBZ7D1DGYo5yrzjQzckJKC13O + jBcPXafLO2XfXCbPYH5ynjp8cQ8pbVBSWVqUeOr++UwtQ/lJ2aLL+rIs722zm+pSL2ByTMOnWkvxkZfN + aAkpfXRhs1430PKFHmra/oVMDcGc5Nx0+Px+Un6gtKa8qTK3fKGns/RMMpiPnJcO5SflC8prSpwqdfIr + gQVMIPzMTyIJSqyTet0A8tiGMWr6gQWMCebxLz3+V8qPef3EjJCQ8kaXOePFQyj7wA2jdfnnxz6Yg0N+ + vriHRAuU2pTbLIGfx34JJOXnK/tITEC5TclTS2D41glOOaIenDsgP0L5SbTRJQ+8buA6NW7ndC3FvNgE + 58W55Rx0+Px+Eg9Qdln+H2sZxmspZmg5oh6cE+eV59eh/CReoPRSgsQS2DVNzTg4N7LB+Sg/IQZd/pFS + hqvG3e0UJyrB+eR5dUaaURAST7QEGS8eun7qfU55yj04lzynDl/cQwiADFKO5BKYE5lQfkJqAFJISSDN + TC1Puef2OU2k+AjlJ8SFliPjdQOtVnRVMw/NLtvg8cvz6PD5/YRUBeQwkqSkKdclQPkJyQNIYmRJyZNc + ArPKJpSfkDoAWXROG3kS6bV2kFO2UsugjcOl+Aie+kz5CakNWpqs1w1UaLlmaclKNXh8fHEPIZ6APEai + 9BLY9Lia9e7MkgseF+UnxDOQyMhUskuA8pM60fqRR+vpjGTcub7d3ZuEXOrHQ65VE/dM1PLNKHrwOPB4 + 5OO7ut2de13nYFLhcpTogVzUUUzVqd+uYYZkpbAEXPLjcboeP5ORi6b6BDgGxDjiWgKTtISztYxhBx+X + 8ucfU30C5GD+9PIqppr0e3pkhnSQcPa700PPz0bdnPE48Lhcj5dJR/bcVJ8AORhSM48uHpAh3w3T7lGz + D2sxQwo+nvz4eDykZmTPTfUJkIMhuZG9BBppOacVPPg48uNS/tyRPTfVJ0AOhuRO2EuA8tcN2XNTfQLk + YEjtuGNS8wwpmy5ro+Ycnuo9bV7qmPFxfj26kXkEJFdkz031CZCDIbXj4teXEjJKOSGrS+J845IfH5fU + DtlzU30C5GBI7XEugT/qJXBEC1zH4P3I90v580f23FSfADkYkh+uJdD51e5a4il5p+/6fhnv76cVN1P+ + OiB7bqpPgBwMyZ99Zw+rH/W+KiUsnp8/ZPNgp9w1BX9PPr8f7xfvn+SP7LmpPgFyMKRuuJdAhZp7ZHLO + wdtTfv/InpvqEyAHQ+pOXZYA5S8csuem+gTIwRA/bDq2IyUx8q/9f6mm7H9CzT06qcrgz/F28u+t2rvO + vEdSV2TPTfUJkIMh/li67aUMmf9ryDVa8rFVyD828efy7fH3iT9kz031CZCDIX7JZQlQ/nCQPTfVJ0AO + hvjHvQTGqHlHJyZC+cNB9txUnwA5GFIY+r4wOkPy+tMbJOTH/8r/zuf3Fw7Zc1N9AuRgSOEIvnjo3wI/ + 8KP8hUX23FSfADkYH5z74lt19KPLjCMNp/bIkN4G/9319szlRJ98IHtuqk+AHIwPVr3zEVNNbhjbJkP+ + Xw5v7Hw7Jh0fyJ6b6hMgB+MD1wUy6Szfckz9T8XdCfnxv/j/rrdj0vGB7LmpPgFyMD6QF7f2wGeOfJ7I + OuRg9VlfXQ4l80aOeTOYd2XOJ7Ihh2y0OVx9NtWQFe8cUm8dOV9NLiSy2ZWj2Xk7h2xBjlWfrdXmC7X1 + vS/UthyzPZjj2dlRRWSPfCB7bqpPgByMD+TFvfXeRZMvU9mMHE/n7WBOfKm2OLLV5uSlRLY5sh05lZkd + gVSelrmcyDs2Z9LZGcgu5P3M7E7lq0T2nM3O3mA++ErtC2S/zYfIlUQOOHLwo8wcCubjK+rdVL5O5TBy + Lp0jjhz9JDvHUvlGHfv0G/WeI8dtPkvnRCAnP5f5NpFTMueTOS0ie+QD2XNTfQLkYHwgLy4u4rvkp/j5 + iY+c0ZE98oHsuak+AXIwPpAXR/Hd4qfkp/hZ4tvIHvlA9txUnwA5GB/Ii5PiZ8kvZC858ZESEj9L/gzx + 0/KXvPiIkb0q8c9cSEb2yAey56b6BMjB+EBeXF3Ed8lP8XMT3yV/uYj/vonskQ9kz031CZCD8YG8uDDF + z5Sf4tdGfJf8KfERLXlY4r9/4S+JyB75QPbcVJ8AORgfyIsruvhC/qD4Kfkpfq3Fz5Tfr/jIWS6A8JCD + 8YG8uPITPy1/UPws+QPCU/yqxc+QP0v8tPwQ/+wXycge+UD23FSfADkYH8iLy0t8RMtd7uK75C+q+FV8 + n19q4nMBhIwcjA/kxVH83MXPlD++4n9gInvkA9lzU30C5GB8IC8uKD/F9ye+S/60+EZ+I3s5iZ/IRS6A + 0JCD8YG8uKrET8mv5ab44YifIb8WvFTF/9BE9sgHsuem+gTIwfhAXpwv8TPk13LnKn6m/CUgPlKV+AH5 + iy1+lvxC9kKKzwUQMnIwPpAXV27iu+Sn+LmJnyl//uIjH+nIHvlA9txUnwA5GB/Ii4uG+Gn5g+K75Kf4 + uYnvkh/i28ge+UD23FSfADkYH8iLo/iZ4qfk13JTfLf4H335XSKyRz6QPTfVJ0AOxgfy4kpSfCQgfamK + nyl/iYsfkD9f8T82kT3ygey5qT4BcjA+kBdXtfhp+UtCfCQC4rvkL6r4iJE9V/G5AEJGDsYH8uJqI75L + forvQ/y0/EHxXfIXW3zknI7skQ9kz031CZCD8YG8uEKK75Kf4nsQH6lC/JT8WvBCiX/uUjKyRz6QPTfV + J0AOxgfy4kpJ/JT8FD808TPk13LnIj7yCRdAeMjB+EBeXK3ER0pI/Cz5M8RPy1/y4iNG9lIX38rPBRAi + cjA+kBcXJ/Fd8lP82ovPBRAycjA+kBdXDuIPnvycuqVxT/XShn2hiu+SPyU+oiWPo/ifXk5G9sgHsuem + +gTIwfhAXlxQ/JT8JSB+5fHPVave49VvGnRIZd6KDSUrfqb8uYufIX8ZiJ/MXzN65APZc1N9AuRgfCAv + Ljfx0/IHxc+SPyB8PuIjq3ccUw1aDcyQ32bIlOf8i1/Fl/vFEz8tf1D8LPmF7GGIj3zGBRAecjA+kBcX + tvgu+aX4CD7LB6UPptPgGWrXifMU35Gg+C756yJ+Il9xAYSGHIwP5MWVkvhI7zELncK70rjTCLX54AcU + 38SX+JnyZ4tvI3vkA9lzU30C5GB8IC+uVMTfdOCsatxxhFP06oIfDq6tfK9a+dPiG/mN7BS/FuIL+T83 + kT3ygey5qT4BcjA+kBdXbPHx03z8dB8iS7FrE/zdBS9tzEv8DPm14BS/ZvG5AEJGDsYH8uKKKT4yZelq + p9T55Mn5fyy4+FnyC9lLTnxEy+1bfOS8juyRD2TPTfUJkIPxgby4XMR3yV9X8d85/nniB3lSYB/pN3ah + 2nvqfMmInyl/NMQ/fyUZ2SMfyJ6b6hMgB+MDeXH5i5+WPyi+S34rPvLajmN5fb+fa37faYTae/pCWYrv + kj8lPqLlLrb4yAUugPCQg/GBvLgwxUeeWb29Tt/v55qGrQaq9TuPR178lPxa7rDEt5E98oHsuak+AXIw + PpAXF5S/UOLj2Xt4Ak9Q1EIGi+b51yuLK35A/mKLnyG/ljsf8S9c+Vsiskc+kD031SdADsYH8uKqFR/x + IP7OE9lP6Q0zi1ZuKi3xESN7qYufKX9S/C++Tkb2yAey56b6BMjB+EBeXCHFx9N1X6+s+im9Yab/2IUB + 8dPyB8V3yU/x0+JzAYSMHIwP5MUVSnxk/oqNThmLlTZ9x6uD71/IT3ykCvFT8mvB4yA+clFH9sgHsuem + +gTIwfhAXlxKfo/i4wU6fcc+pa5p2LHk0qTLKLVh94miip8hv5a73MS3kT3ygey5qT4BcjA+kBdXW/Gz + 5M8Q/4p66+AHWrLR6rp7Opdsbm/aR23co5eAkb3UxXfJnxY/LX9Y4ifyDRdAaMjB+EBenC/x8Vl/5aaD + 6o6H+qnr7+tWFlm6anMkxXfJ71P8L01kj3wge26qT4AcjA/kxfkQH5nx3Fp14/09yi6jZ70Qe/Fd8lcn + PhdAyMjB+EBeXF3F33Xyguo+Yr6q/2Cvsk2vUfPV4Q8uUnwru4xDfOSSjuyRD2TPTfUJkIPxgby4fMXH + b+FZt/OEerjXBHVz4z5ln5a9J6gjiSXgFj9LfiG7T/G3HTipHuoyUg0at0idOvdlfuIjBRT/0rfJyB75 + QPbcVJ8AORgfyIvLR3z8Ao7n1+1WDVoPUbc06ReZNGgzRL29/7QX8V3y1/QZf9mfN6tbf59+mjQWwfYD + p0pO/Evffq8u68ge+UD23FSfADkYH8iLc4mfKX/2790bNeeP6raHBkQyjdoOU8tXbw9V/JP6Mz0+41vx + ZbAQlr+yuaTEt5E98oHsuak+AXIwPpAXVxvxd5+6oDoNnatubz4w8pn57JqCi49sN1/yS+ldqRi/SJ35 + 5FK2/EUQnwsgZORgfCAvLhfxkfW7T6mm3cerO1tUxCYjZrxQMPGRZfozu/ySv6ZgUVQePFWN+Gn5g+Jn + yR8Qvjbif/WXZGSPfCB7bqpPgByMD+TFOcUPyL/klR3qrpZDYpl2g2aq9z7+MnfxES13deLjh3sVVXzJ + X1OwMJ5/dXPBxXfJb8XnAggZORgfyIurTnz8gs1hM15Ud7ceFuu06D1Z7Tj0fp3Fx0/0c/2Sv6YM1t8S + nP30UlHER67oyB75QPbcVJ8AORgfyIurSvythz9W7SrmqAZtRzA6D3Z5Uq1++2De4iOr3txZqy/5a0oz + vUh2Hjoduvg2skc+kD031SdADsYH8uKC4iOvbjuqGncdrxo+OooJ5KX1u9Lya7lzER//hj9m5nKnxHXN + bXqhLHpxbZ7iJ+WvrfhXvktG9sgHsuem+gTIwfhAXpwUH1mwcou6p/0Yppo8Mf/lnMU/ePKcly/5a0qv + 4bPUB59dLqz4iBb/axPZIx/InpvqEyAH4wN5cVb8Pae/UIOmvKDu7fAEk0P6j3tWnfrkcpXiI76/5K8p + 97QZpHYfPl1w8ZP5e0aPfCB7bqpPgByMD+TFQf4Ne99XnYcvUr/rNI6pRbqNXKR2HvkwS3ykUF/y55Kn + 9bcEuYjvkj8X8b8xkT3ygey5qT4BcjA+kBe3bM1u1bzPdHV/lwlMHnlYz27X0Y9S4of1JX9N6a2/Jfjo + /GWv4qfk/2syskc+kD031SdADsYH9tIWrzmkHuw2ifGQVRv3h/4lf025V39LsPfwGe/iI99yAYSHHIwP + 7KUteGWvatxjCuMhtzcr/i8+rSqLV6zzKr4NF0BIyMH4IL0A9qkmPacxdUjj7lPUTQ/2dopXSuk9YpY6 + d+GrHMRPyl+d+FwAISMH44PUAnh1n2raewaTZ+7r+KS6tlFnp3ClGHxLsO/ImTqL/5e/JcMFEBJyMD6w + l7bw1f2qWd/ZJZvfdR6vmvaa4fyzYueuVsOckpVDlr60rk7icwGEjByMD+QCeLj/3JIMnnV3baNO6vr7 + uqoHukx0vk0x8lCfWerWJv0Sj62c03fUHPXpF1fyEh/5TocLICTkYHyQWgCrD6gWj80vqTTvN0d/dh2a + 9Rt8f9t2uPPtwwy+37/xgZ5Zj61c80D7Yerge2erlL8q8W24AEJCDsYH9tKeWn1QtRq4sGQC+fHT9PoP + 9HIGf9a090zn3y107mk/1vmYopBlL2+slfjfff+PRLgAQkIOxgepBfDaQdW6YlFJBGLjV3K5flefDN7m + fv0tget9FCItBy5IvCTY9ViilIrxT6vzX17JSfy/mnABhIQcjA/spS167ZBqO2Rx0fNg98n6s/tjtUqj + dqO1oE8535+v4Hv+Ox6ucH78KKZZ9yfV4ZMfZotv5LficwGEjByMD1IL4PVD6pFhS4uWNoMXq991Hqfu + bDE4r+BnBZDU9b7rGvwbv+tjxiEvrt5Srfg2XAAhIQfjg/QCeFe1G/5cUdJGf4bF99V3t368zsEP51wf + I59A/vs7T3B+nDhl+LTl6uLlb5zi/w35OxdAaMjB+MBe2tNr3lXtRywLPfjSvVG7MVm/bKMuwavzsFRc + Hy/X4O/jpb6u9x/HtB0wXR07fS5LfBsugJCQg/FBegEcVh1H/SHUtBgwT93TYWxBgmfm4f27Pm5NKeTj + Kvf8aV1lhvjfm3ABhIQcjA/spS1ee1h1GvNiaMEz6PDsvkLnoT4zE1K7HkMweDu8vev9MOmMnbtSXbry + bUp+LoAQkYPxQXoBHFFdnnip4IFoeO78g90mh5bG3acmvqd3PR6bDiOXqyY9pzv/PpOdTsMWqhNnP1Xf + /+Mf6u86XAAhIQfjA7kAuo5bWdB0HP2HhPzBV9GFFfxbvutx2Z/0M7XPqxv36AWQ7hEXQIGRg/GBvbQl + 646q7uNfLljwgzU8d77YwdN4O49dkXhM3bT8bQY/7Xw7JvdMfHq1WrH1DBdAGMjB+EAugJ4T/1yQPDLs + GfXwgHklEywBLCR8ReD6c6b2wWtJuABCQA7GB/bSlq4/pnpNftVrek56RbUdukS1GvQUE/HgtSRcACEg + B+MDuQD6TH3NW3rgM7+W3/W0WiZ6WfQaF0AoyMH4ILUA3nhP9Z2+1ku6T3hZPfr4s0yMgqeScwGEgByM + D+ylPaMXQP8Z6+oc/GCtw8jnmZgFzyTlAggBORgfpBbAm8fVgFlv5p3+M9errk+uVJ3HvMjEMHgiGRdA + CMjB+EAugIFzNuaV/jPf0J/5/+T8N3YmHsHzSLgAQkAOxgf20p5984QaNO+tWgef+fEDPybewT8jcwGE + gByMD1ILYMMJNXjB27UKPvP3nvIawyT+FYkLIATkYHxgL+25DSfVkIVbc8uCLfr7/jdUv+lrGSYR/CsS + F0AIyMH4ILUANp5SwxZtrzFYAI/N3pD1Q0Am3sHPkLgAQkAOxgdyATy+uLLaDH1qW/J7/7kMkxn8DIkL + IATkYHxgL23ZptNqxNKdVWbYoh3Z3wowjAm+heQCCAE5GB/IBTDq2T1ZGfnMboXP/sOe3sEwVQZfQXIB + hIAcjA9SC+CtM2r0c3szMurZvWrk0l36KwCGqT74BMIFEAJyMD6wl7ZcL4Cxyw+kMmbZfr0E9jFMTkF/ + uABCQA7GB/bSVu74UF/i+yJnGCbnoD9cACEgB+MDe2kM4ys+kD031SdADsYHlccvOC+RYfLJ1iPnTbPq + huy5qT4BcjCERBXZc1N9AuRgCIkqsuem+gTIwRASVWTPTfUJkIMhJKrInpvqEyAHQ0hUkT031SdADoaQ + qCJ7bqpPgBwMIVFF9txUnwA5GEKiiuy5qT4BcjCERBXZc1N9AuRgCIkqsuem+gTIwRASVWTPTfUJkIMh + JKrInpvqEyAHQ0hUkT031SdADoaQqCJ7bqpPgBwMIVFF9txUnwA5GEKiiuy5qT4BcjCERBXZc1N9AuRg + GCYOMdUnwDUgholyTPUJ0ANZEhwQw0Q4S0z1i8wPfvD/4/NKrjKwX20AAAAASUVORK5CYII= +======= + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAglNJREFUeF7t + vQvQfFta1gfn/K/nMufMDRhAtPACjBcUUVBHHBBEI6BGJZpSoyZRQxAvYKICOkfxiiilVqmlSYwVCysx + aiWaqIkSNUZjNLG8RMtYKvECcVCjIMxEwLy/nmf1dH+9d++13l67e3X381Q9deY/3b9n7Xft9e31ft39 + 7f4Qy7Isy7KsZn3mZ777Q8Mv7PhD9VBKznNei5znvBY5z3kture8JsVgLz60HkrJec5rkfOc1yLnOa9F + 95ZXrRiIruNR+PGO+Xeq+4AT77yE4MQ7LyE48c5LCE688xKCE++8hODEO29tMYgGfLJj/n1KMc5zXpXg + xDsvITjxzksITrzzEoIT77yE4MR3yWsSg4Sfhp/tmH+fUozznFclOPHOSwhOvPMSghPvvITgxDsvITjx + XfKaxCAa8PmO+fcpxTjPeVWCE++8hODEOy8hOPHOSwhOvPMSghPfJQ9Vs/FEPl34UvjlHfPvF/SUJsGJ + d15CcOKdlxCceOclBCfeeQnBiXdeQnDinZdQcDQTfGhwmedJYQZ8Zcf8+5RinOe8KsGJd15CcOKdlxCc + eOclBCfeeQnBie+Vx+bPBwaXGwCeEGawN+2YAzilGHjnJQQn3nkJwYl3XkJw4p2XEJx45yUEJ955CQXH + 5s8HBvHxBkBP5mWGcgCv6b+nFFNyip1XKTjxzksITrzzEoIT77yE4MQ7LyE48c5LKDj2cz4wWP5qgAZg + +jMAPBDmAwblpQcGHqkY5zmvWnDinZcQnHjnJQQn3nkJwYl3XkJwYfZzvG0A9PC+4oHSKfApw933HjzZ + FYIT77yE4MQ7LyE48c5LCE688xKCE++8hODE98zjlfzyVwM0AI/08L7igfIeAU8sDcApHzjwyXNeteDE + Oy8hOPHOSwhOvPMSghPvvITgxPfMK3t4aQDY32df+ufTgXQIpQE49U8XRp8c5zmvSnDinZcQnHjnJQQn + 3nkJwYm/p7zy6n1pAOZvGhQP8KEAuoPSAGBPdoXgxDsvITjxzksITrzzEoIT77yE4MQ7LyG4MDw5xT3y + cGkA2M+PfuhvtwFI314wOJ8851ULTrzzEoIT77yE4MQ7LyE48c5LCE78Gnn8lwaAV/Ln9/N4EKg0APPv + ESxIOWsV47xGwYl3XkJw4p2XEJx45yUEJ955CcGJv9c8/vfyZ/h4QpgG4JSvKLz3yXZeg+DEOy8hOPHO + SwhOvPMSghPvvITgxK+ZV/fXezwpPH9jgAWJv7bJcV6l4MQ7LyE48c5LCE688xKCE++8hODE32ZePDG1 + 8SMG0WC5wR8ITrzzEoIT77yE4MQ7LyE48c5LCE688xKCE++8tcUgGqzL4HDinZcQnHjnJQQn3nkJwYl3 + XkJw4p2XEJx4560tBtFgXQaHE++8hODEOy8hOPHOSwhOvPMSghPvvITgxDtvbTGIBusyOJx45yUEJ955 + CcGJd15CcOKdlxCceOclBCfeeWuLQTRYl8HhxDsvITjxzksITrzzEoIT77yE4MQ7LyE48c5bWwyiwboM + DifeeQnBiXdeQnDinZcQnHjnJQQn3nkJwYl33tpiEA3WZXA48c5LCE688xKCE++8hODEOy8hOPHOSwhO + vPOSCrbur/8YRIN1GRxOvPMSghPvvITgxDsvITjxzksITrzzEoIT77yEgiu3/l/meVKYOwr1Gtwnz3nV + ghPvvITgxDsvITjxzksITrzzEoIT3yuPzZ87/i43ADwhzL2Edw9gpGKc57xqwYl3XkJw4p2XEJx45yUE + J955CQXH5l++7+d4A6An8y1C/PZfDmKkYpznvGrBiXdeQnDinZcQnHjnJQQn3nkJBcd+zrf88m2/pQGY + /gwAD4T5/mB++y8NwEjFOM951YIT77yE4MQ7LyE48c5LCE688xKCC7Of420DoIf3FQ+UTuF5uDQAdd8q + NCG4MAdPEcU+eZWCE++8hODEOy8hOPHOSwhOvPMSghPvvITgwrySz35eGoBHenhf8UB5j4AnlgZg+fuE + ZwQXHn1ynOe8KsGJd15CcOKdlxCceOclBCf+nvLKHl4aAPb32Zf++XQgHUJpAOgcPNkVghPvvITgxDsv + ITjxzksITrzzEoIT77yE4MT3zCuv3pcGgFf2Zzd/PhRAd1AaAOzJrhCceOclBCfeeQnBiXdeQnDinZcQ + nHjnJQQnvnceLg0A+/nRD/3tNgDzncKCgvPJc1614MQ7LyE48c5LCE688xKCE++8hODEr5HHf2kAeCV/ + fj+PB4FKAzD/HsGClLNWMc5rFJx45yUEJ955CcGJd15CcOKdlxCc+HvN438vf4aPJ4RpAPgMgDf/CsGJ + d15CcOKdlxCceOclBCfeeQnBiXdeQnDi18yr++s9nhSevzHAgsRf2+Q4r1Jw4p2XEJx45yUEJ955CcGJ + d15CcOJvMy+emNr4EYNosNzgDwQn3nkJwYl3XkJw4p2XEJx45yUEJ955CcGJd97aYhAN1mVwOPHOSwhO + vPMSghPvvITgxDsvITjxzksITrzz1haDaLAug8OJd15CcOKdlxCceOclBCfeeQnBiXdeQnDinbe2GESD + dRkcTrzzEoIT77yE4MQ7LyE48c5LCE688xKCE++8tcUgGqzL4HDinZcQnHjnJQQn3nkJwYl3XkJw4p2X + EJx4560tBtFgXQaHE++8hODEOy8hOPHOSwhOvPMSghPvvITgxDtvbTGIBusyOJx45yUEJ955CcGJd15C + cOKdlxCceOclBCfeeUkFW/fXfwyiwboMDifeeQnBiXdeQnDinZcQnHjnJQQn3nkJwYl3XkLBlVv/L/M8 + KcwdhRi02JNdKTjxzksITrzzEoIT77yE4MQ7LyE48c5LCE58rzw2f+74u9wA8IQw9xLePYCRinGe86oF + J955CcGJd15CcOKdlxCceOclFBybf/m+n+MNgJ7Mtwjx2385iJGKcZ7zqgUn3nkJwYl3XkJw4p2XEJx4 + 5yUUHPs53/LLt/2WBmD6MwA8EOb7g/ntvzQAIxXjPOdVC0688xKCE++8hODEOy8hOPHOSwguzH6Otw2A + Ht5XPFA6hefh0gDUfavQhODCo0+O85xXJTjxzksITrzzEoIT77yE4MTfUx6v5LOflwbgkR7eVzxQ3iPg + iaUBWP4+4RnBhUefHOc5r0pw4p2XEJx45yUEJ955CcGJv6e8soeXBoD9ffalfz4dSIdQGgA6B092heDE + Oy8hOPHOSwhOvPMSghPvvITgxDsvITjxPfPKq/elAeCV/dnNnw8F0B2UBgB7sisEJ955CcGJd15CcOKd + lxCceOclBCfeeQnBie+dh0sDwH5+9EN/uw3AfKewoOB88pxXLTjxzksITrzzEoIT77yE4MQ7LyE48Wvk + 8V8aAF7Jn9/P40Gg0gDMv0ewIOWsVYzzGgUn3nkJwYl3XkJw4p2XEJx45yUEJ/5e8/jfy5/h4wlhGgA+ + A+DNv0Jw4p2XEJx45yUEJ955CcGJd15CcOKdlxCc+DXz6v56jyeF528MsCDx1zY5zqsUnHjnJQQn3nkJ + wYl3XkJw4p2XEJz428yLJ6Y2fsQgGiw3+APBiXdeQnDinZcQnHjnJQQn3nkJwYl3XkJw4p23thhEg3UZ + HE688xKCE++8hODEOy8hOPHOSwhOvPMSghPvvLXFIBqsy+Bw4p2XEJx45yUEJ955CcGJd15CcOKdlxCc + eOetLQbRYF0GhxPvvITgxDsvITjxzksITrzzEoIT77yE4MQ7b20xSJjBGLTYk10pOPHOSwhOvPMSghPv + vITgxDsvITjxzksITnyXvCYxiAbrMjiceOclBCfeeQnBiXdeQnDinZcQnHjnJQQn3nlri0E0WJfB4cQ7 + LyE48c5LCE688xKCE++8hODEOy8hOPHOSyrYur/+YxAN1mVwOPHOSwhOvPMSghPvvITgxDsvITjxzksI + TrzzEgqu3Pp/medJYe4o1GtwnzznVQtOvPMSghPvvITgxDsvITjxzksITnyvPDZ/7vi73ADwhDD3Et49 + gJGKcZ7zqgUn3nkJwYl3XkJw4p2XEJx45yUUHJt/+b6f4w2Ansy3CPHbfzmIkYpxnvOqBSfeeQnBiXde + QnDinZcQnHjnJRQc+znf8su3/ZYGYPozADwQ5vuD+e2/NAAjFeM851ULTrzzEoIT77yE4MQ7LyE48c5L + CC7Mfo63DYAe3lc8UDqF5+HSANR9q9CE4MKjT47znFclOPHOSwhOvPMSghPvvITgxN9THq/ks5+XBuCR + Ht5XPFDeI+CJpQFY/j7hGcGFR58c5zmvSnDinZcQnHjnJQQn3nkJwYm/p7yyh5cGgP199qV/Ph1Ih1Aa + ADoHT3aF4MQ7LyE48c5LCE688xKCE++8hODEOy8hOPE988qr96UB4JX92c2fDwXQHZQGAHuyKwQn3nkJ + wYl3XkJw4p2XEJx45yUEJ955CcGJ752HSwPAfn70Q3+7DcB8p7Cg4HzynFctOPHOSwhOvPMSghPvvITg + xDsvITjxa+TxXxoAXsmf38/jQaDSAMy/R7Ag5axVjPMaBSfeeQnBiXdeQnDinZcQnHjnJQQn/l7z+N/L + n+HjCWEaAD4D4M2/QnDinZcQnHjnJQQn3nkJwYl3XkJw4p2XEJz4NfPq/nqPJ4XnbwywIPHXNjnOqxSc + eOclBCfeeQnBiXdeQnDinZcQnPjbzIsnpjZ+xCBhT7bzqgQn3nkJwYl3XkJw4p2XEJx45yUEJ37IvCYx + iAbrMjiceOclBCfeeQnBiXdeQnDinZcQnHjnJQQn3nlri0E0WJfB4cQ7LyE48c5LCE688xKCE++8hODE + Oy8hOPHOW1sMosG6DA4n3nkJwYl3XkJw4p2XEJx45yUEJ955CcGJd97aYhAN1mVwOPHOSwhOvPMSghPv + vITgxDsvITjxzksITrzz1haDaLAug8OJd15CcOKdlxCceOclBCfeeQnBiXdeQnDinbe2GESDdRkcTrzz + EoIT77yE4MQ7LyE48c5LCE688xKCE++8pIKt++s/BtFgXQaHE++8hODEOy8hOPHOSwhOvPMSghPvvITg + xDsvoeDKrf+XeZ4U5o5CvQb3yXNeteDEOy8hOPHOSwhOvPMSghPvvITgxPfKY/Pnjr/LDQBPCHMv4d0D + GKkY5zmvWnDinZcQnHjnJQQn3nkJwYl3XkLBsfmX7/s53gDoyXyLEL/9l4MYqRjnOa9acOKdlxCceOcl + BCfeeQnBiXdeQsGxn/Mtv3zbb2kApj8DwANhvj+Y3/5LAzBSMc5zXrXgxDsvITjxzksITrzzEoIT77yE + 4MLs53jbAOjhfcUDpVN4Hi4NQN23Ck0ILjz65DjPeVWCE++8hODEOy8hOPHOSwhO/D3l8Uo++3lpAB7p + 4X3FA+U9Ap5YGoDl7xOeEVx49MlxnvOqBCfeeQnBiXdeQnDinZcQnPh7yit7eGkA2N9nX/rn04F0CKUB + oHPwZFcITrzzEoIT77yE4MS35k0+Die+NW9ScOKdlxCceOclBCf+nvLKq/elAeCV/dnNnw8F0B2UBgB7 + sisEJ955CcGJd15CcOKP5T0O/8jwV4a/NvwPw+8L/+vwvwr/o/CfCn/VCy+88KO/7/f93m9dyKsWnHjn + JQQn3nkJwYm/tzxcGgD286Mf+tttAOY7hQUF55PnvGrBiXdeQnDi5/I+KvxV4W8Ms9kf9Yd+6If+60eP + Xgw/+mdPnz79re94x0e880Fek+DEzx1fk+DEOy8hOPHOSwhO/DXk8V8aAF7Jn9/P40Gg0gDMv0ewIOWs + VYzzGgUn3nkJwYm/xrzn4a8Il9/yF72z+e/6ffH//6p4/Fm4SRyHjmfq+JoFJ955CcGJd15CcOKvJY// + vfwZPp4QpgHgMwDe/CsEJ955CcGJd15CcOKn8r5n+P8MT270U57e/F/c/P96zl8Pk1sljkPHM3V8zYIT + 77yE4MQ7LyE48deUV/fXezwpPH9jgAWJv7bJcV6l4MQ7LyE48efI+8zwN4X3Nvhjrtj8i/9F+LPCR8Vx + 6Himjq9ZcOKdlxCceOclBCf+NvPiiamNHzGIBssN/kBw4p2XEJx45yUEJ/4a89j83x9+uHHPumHzL+Yt + hdkmgOPQ8UwdX7PgxDsvITjxzksITvxd5DWJQTRYl8HhxDsvITjxzksITvw15vHy/Fq/+T80rwS8M7wn + jkPHM3V8zYIT77yE4MQ7LyE48XeR1yQG0WBdBocT77yE4MQ7LyE48deYxwf0eI9+arOe9AmbfzHjbT8Y + yHHoeKaOr1lw4p2XEJx45yUEJ/4u8prEIBqsy+Bw4p2XEJx45yUEJ/5a835FeGqTnnSHzb+YcX0+nNck + OPHOSwhOfJe8JjGIBusyOJx45yUEJ955CcGJv9a8d4S/NTy1QR+44+aPv+Xx48cfpeOZO74mwYl3XkJw + 4p2XEJz4u8hrEoNosC6Dw4l3XkJw4p2XEJz4a8779eGpzfnAnTf/DffkyZOvXji+asGJd15CcOKdlxCc + +LvIaxKDaLAug8OJd15CcOKdlxCc+GvO4/a+/zg8uUHveo3NX3nf+Cmf8v3LbYOvbf6qBSfeeQnBiXde + QnDiu+ShYOv++o9BNFiXweHEOy8hOPHOSwhO/LXn/Yjw5Aa96xU3/41fffWVHzNzfFWCE79Ub5XgxDsv + ITjxzksITvyoeeXW/8s8TwpzR6Feg/vkOa9acOKdd6hfG57cpIvX3vzx06dPfuPM8S0KTvXV1LsoOPHO + SwhOvPMSghM/ah6bP3f8XW4AeEKYewnvHsBIxTjPedWCE38ref9DeHKjxufY/JX3J+LxZlGX6qut96jg + xDsvITjxzksITvyoeWz+5ft+jjcAejLfIsRv/+UgRirGec6rFpz4W8r7unDrZj35/CUv5P29cJOoS/W1 + 1DsrOPHOSwhOvPMSghM/ah77Od/yy7f9lgZg+jMAPBDm+4P57b80ACMV4zznVQtO/K3lfXO4dbNudkXe + t4SrRV2qr7XeScGJd15CcOKdlxBcGJ6c4tHy2M/xtgHYHPxDxQOlU3geLg1A3bcKTQguPPrkOM95VYIT + P0Led4RbN+smN+RVibpUX6beA8GJd15CcOKdlxCc+JHzeCWf/bw0AI/08L7igfIeAU8sDcDy9wnPCC48 + +uQ4z3lVghM/St7eJnzBzR8virpUX7bePcGJd15CcOKdlxCc+JHzyh5eGgD299mX/vl0IB1CaQDoHDzZ + FYIT77yE4MQ7r17bDfjCmz8+KupSfafUuxWceOclBCfeeQnBiR85r7x6XxoAXtmf3fz5UADdQWkAsCe7 + QnDinZcQnHjntWmz+Q6w+eNZUZfqO7XejeDEOy8hOPHOSwhO/Oh5uDQA7OdHP/S32wDMdwoLCs4nz3nV + ghPvvHaNsvnjSVGX6utRr/Oc1yQ48feYx39pAHglf34/jweBSgMw/x7BgpSzVjHOaxSceOclBCd+yLyB + Nn98IOpSfV3qhRPvvITgxDsvITjx15LH/17+DB9PCNMA8BkAb/4VghPvvITgxDsvIbiBNn+8J45P9XWr + V7zzEoIT77yE4MRfU17dX+/xpPD8jQEWJP7aJsd5lYIT77yE4MR3zTths95zh80fb1WOL9y1XuU4r1Fw + 4p2XEJz428yLJ6Y2fsQgGiw3+APBiXdeQnDinZcQnPjh8wba/PFGu8e34yHnb8fOqxSceOclBCd+yLwm + MYgG6zI4nHjnJQQn3nkJwYm/iryBNn/s8+u8JsGJd15CcOK75DWJQTRYl8HhxDsvITjxzksITvzV5A20 + +f/rqePTv31+KwQn3nkJwYl33tpiEA3WZXA48c5LCE688xKCE39VeaNs/nBTxxf2+a0QnHjnJQQn3nlr + i0E0WJfB4cQ7LyE48c5LCE78NeZNbsjHvMbmDz9zfM2CE++8hODEOy8hOPF3kdckBtFgXQaHE++8hODE + Oy8hOPHXmje5Kc95rc2fnJnjaxKc+Ll6mwQn3nkJwYl3XkJw4ofMaxKDaLAug8OJd15CcOKdlxCc+GvO + m9yYp7zm5r/TAFzb/FULTrzzEoIT77yE4MR3yUPB1v31H4NosC6Dw4l3XkJw4p2XEJz4a8+b3Jwfeu3N + H88cX5XgxC/VWyU48c5LCE688xKCC8OTUzxSXrn1/zKvwbmj0KjFOM951YITfwt5kxv0rs+x+fPvmeNb + FJzqq6l3UXDinZcQnHjnJQQnftQ8Nn/u+LvcAPCEMPcS3j2AkYpxnvOqBSf+VvImN+nic23+ymsWdam+ + 2nqPCk688xKCE++8hODEj5rH5l++7+d4A6An8y1C/PZfDmKkYpznvGrBib+lvINNuvjMmz9uEnWpvpZ6 + ZwUn3nkJwYl3XkJw4kfNYz/nW375tt/SAEx/BoAHwnx/ML/9lwZgpGKc57xqwYm/tby9Tbr4Aps/rhZ1 + qb7WeicFJ955CcGJd15CcOJHzmM/x9sGQA/vKx4oncLzcGkA6r5VaEJw4dEnx3nOqxKc+BHydjfgjS+0 + +eMqUZfqy9R7IDjxzksITrzzEoITP3Ier+Szn5cG4JEe3lc8UN4j4ImlAVj+PuEZwYVHnxznOa9KcOJH + ydvbhC+4+eNFUZfqy9a7JzjxzksITrzzEoITP3Je2cNLA8D+PvvSP58OpEMoDQCdgye7QnDinZcQnHjn + 1Wu7AV9488dHRV2q75R6t4IT77yE4MQ7LyE48SPnlVfvSwPAK/uzmz8fCqA7KA0A9mRXCE688xKCE++8 + Nm023wE2fzwr6lJ9p9a7EZx45yUEJ955CcGJHz0PlwaA/fzoh/52G4D5TmFBwfnkOa9acOKd165RNn88 + KepSfT3qdZ7zmgQn/h7z+C8NAK/kz+/n8SBQaQDm3yNYkHLWKsZ5jYIT77yE4MQPmTfQ5o8PRF2qr0u9 + cOKdlxCceOclBCf+WvL438uf4eMJYRoAPgPgzb9CcOKdlxCceOclBDfQ5o/3xPGpvm71indeQnDinZcQ + nPhryqv76z2eFJ6/McCCxF/b5DivUnDinZcQnPiueSds1nvusPnjrcrxhbvWqxznNQpOvPMSghN/m3nx + xNTGjxhEg+UGfyA48c5LCE688xKCEz983kCbP95o9/h2POT87dh5lYIT77yE4MQPmdckBtFgXQaHE++8 + hODEOy8hOPFXkTfQ5o99fp3XJDjxzksITnyXvCYxiAbrMjiceOclBCfeeQnBib+avIE2/823AT48Pv3b + 57dCcOKdlxCceOetLQbRYF0GhxPvvITgxDsvITjxV5U3yuYPN3V8YZ/fCsGJd15CcOKdt7YYJMxgDFrs + ya4UnHjnJQQn3nkTm/GS19j84WeOr1lw4p2XEJx45yUEJ/4u8prEIBqsy+Bw4p2XEJx45yUEJ/5a8yY3 + 5TmvtfmTM3N8TYITP1dvk+DEOy8hOPHOSwhO/JB5TWIQDdZlcDjxzksITrzzEoITf815kxvzlNfc/Hca + gGubv2rBiXdeQnDinZcQnPgueSjYur/+YxAN1mVwOPHOSwhOvPMSghN/7XmTm/NDr73545njqxKc+KV6 + qwQn3nkJwYl3XkJw4kfNK7f+X+Z5Upg7CvUa3CfPedWCE++8Q01u0Ls+x+bPv2eOb1Fwqq+m3kXBiXde + QnDinZcQnPhR89j8uePvcgPAE8LcS3j3AEYqxnnOqxac+FvJm9yki8+1+SuvWdSl+mrrPSo48c5LCE68 + 8xKCEz9qHpt/+b6f4w2Ansy3CPHbfzmIkYpxnvOqBSf+lvIONuniM2/+uEnUpfpa6p0VnHjnJQQn3nkJ + wYkfNY/9nG/55dt+SwMw/RkAHgjz/cH89l8agJGKcZ7zqgUn/tby9jbp4gts/rha1KX6WuudFJx45yUE + J955CcGJHzmP/RxvGwA9vK94oHQKz8OlAaj7VqEJwYVHnxznOa9KcOJHyNvdgDe+0OaPq0Rdqi9T74Hg + xDsvITjxzksITvzIebySz35eGoBHenhf8UB5j4AnlgZg+fuEZwQXHn1ynOe8KsGJHyVvbxO+4OaPF0Vd + qi9b757gxDsvITjxzksITvzIeWUPLw0A+/vsS/98OpAOoTQAdA6e7ArBiXdeQnDinVev7QZ84c0fHxV1 + qb5T6t0KTrzzEoIT77yE4MSPnFdevS8NAK/sz27+fCiA7qA0ANiTXSE48c5LCE6889q02XwH2PzxrKhL + 9Z1a70Zw4p2XEJx45yUEJ370PFwaAPbzox/6220A5juFBQXnk+e8asGJd167Rtn88aSoS/X1qNd5zmsS + nPh7zOO/NAC8kj+/n8eDQKUBmH+PYEHKWasY5zUKTrzzEoITP2TeQJs/PhB1qb4u9cKJd15CcOKdlxCc + +GvJ438vf4aPJ4RpAPgMgDf/CsGJd15CcOKdlxDcQJs/3hPHp/q61SveeQnBiXdeQnDirymv7q/3eFJ4 + /sYACxJ/bZPjvErBiXdeQnDiu+adsFnvucPmj7cqxxfuWq9ynNcoOPHOSwguDE9O8e3kxRNTGz9ikPDt + Ts4DwYl3XkJw4p2XEJz41wba/PFGu8e34yHnb8fOqxSceOclBCd+yLwmMYgG6zI4nHjnJQQn3nkJwYm/ + iryBNn/s8+u8JsGJd15CcOK75DWJQTRYl8HhxDsvITjxzksITvzV5A20+W++DfDh8enfPr8VghPvvITg + xDtvbTGIBusyOJx45yUEJ955CcGJv6q8UTZ/uKnjC/v8VghOvPMSghPvvLXFIBqsy+Bw4p2XEJx45yUE + J/4a8yY35GNeY/OHnzm+ZsGJd15CcOKdlxCc+LvIaxKDaLAug8OJd15CcOKdlxCc+GvNm9yU57zW5k/O + zPE1CU78XL1NghPvvITgxDsvITjxQ+Y1iUE0WJfB4cQ7LyE48c5LCE78NedNbsxTXnPz32kArm3+qgUn + 3nkJwYl3XkJw4rvkoWDr/vqPQTRYl8HhxDsvITjxzksITvy1501uzg+99uaPZ46vSnDil+qtEpx45yUE + J955CcGJHzWv3Pp/medJYe4o1GtwnzznVQtOvPMONblB7/ocmz//njm+RcGpvpp6FwUn3nkJwYl3XkJw + 4kfNY/Pnjr/LDQBPCHMv4d0DGKkY5zmvWnDibyVvcpMuPtfmr7xmUZfqq633qODEOy8hOPHOSwhO/Kh5 + bP7l+36ONwB6Mt8ixG//5SBGKsZ5zqsWnPhbyjvYpIvPvPnjJlGX6mupd1Zw4p2XEJx45yUEJ37UPPZz + vuWXb/stDcD0ZwB4IMz3B/Pbf2kARirGec6rFpz4W8vb26SLL7D542pRl+prrXdScOKdlxCceOclBCd+ + 5Dz2c7xtAPTwvuKB0ik8D5cGoO5bhSYEFx59cpznvCrBiR8hb3cD3vhCmz+uEnWpvky9B4IT77yE4MQ7 + LyE48SPn8Uo++3lpAB7p4X3FA+U9Ap5YGoDl7xOeEVx49MlxnvOqBCd+lLy9TfiCmz9eFHWpvmy9e4IT + 77yE4MQ7LyE48SPnlT28NADs77Mv/fPpQDqE0gDQOXiyKwQn3nkJwYl3Xr22G/CFN398VNSl+k6pdys4 + 8c5LCE688xKCEz9yXnn1vjQAvLI/u/nzoQC6g9IAYE92heDEOy8hOPHOa9Nm8x1g88ezoi7Vd2q9G8GJ + d15CcOKdlxBcGJ6c4hHzcGkA2M+PfuhvtwGY7xQWFJxPnvOqBSfeee0aZfPHk6Iu1dejXuc5r0lw4u8x + j//SAPBK/vx+Hg8ClQZg/j2CBSlnrWKc1yg48c5LCE78kHkDbf74QNSl+rrUCyfeeQnBiXdeQnDiryWP + /738GT6eEKYB4DMA3vwrBCfeeQnBiXdeQnADbf54Txyf6utWr3jnJQQn3nkJwYm/pry6v97jSeH5GwMs + SPy1TY7zKgUn3nkJwYnvmnfCZr3nDps/3qocX7hrvcpxXqPgxDsvITjxt5kXT0xt/IhBNFhu8AeCE++8 + hODEOy8hOPHD5w20+eONdo9vx0PO346dVyk48c5LCE78kHlNYhAN1mVwOPHOSwhOvPMSghN/FXkDbf7Y + 59d5TYIT77yE4MR3yWsSg2iwLoPDiXdeQnDinZcQnPiryRto8998G+DD49O/fX4rBCfeeQnBiXfe2mIQ + DdZlcDjxzksITrzzEoITf1V5o2z+cFPHF/b5rRCceOclBCfeeWuLQTRYl8HhxDsvITjxzksITvw15k1u + yMe8xuYPP3N8zYIT77yE4MQ7LyE48XeR1yQG0WBdBocT77yE4MQ7LyE48deaN7kpz3mtzZ+cmeNrEpz4 + uXqbBCfeeQnBiXdeQnDih8xrEoNosC6Dw4l3XkJw4p2XEJz4a86b3JinvObmv9MAXNv8VQtOvPMSghPv + vITgxHfJQ8HW/fUfg2iwLoPDiXdeQnDinZcQnPhrz5vcnB967c0fzxxfleDEL9VbJTjxzksITrzzEoIT + P2peufX/Ms+TwtxRqNfgPnnOqxaceOcdanKD3vU5Nn/+PXN8i4JTfTX1LgpOvPMSghPvvITgxI+ax+bP + HX+XGwCeEOZewrsHMFIxznNeteDE30re5CZdfK7NX3nNoi7VV1vvUcGJd15CcOKdlxCc+FHz2PzL9/0c + bwD0ZL5FiN/+y0GMVIzz9vMehb97+F3hHxX+/PDPDP+88C8Nf9mu46L95U+fPv2Vz549/Ypi/s3///C5 + Nb7hPObuQMy75n/ufDQJTnxL3sEmXRx1Hdusm12R1yTqUn0t9c4KTvw270bW36TPkPcr499fHv//L4jH + f1b4x4ffHf648LPwUU2dD/37nD8fs4ITfy957Od8yy/f9lsagOnPAPBAmO8P5rf/0gCMVMxd533Yh73t + +z5//uznxA/nr4+H/1D4b4T/v/DeRXvOwS1dzJt843nfFt7Tw/MhX2K9TB3vpeavWtSl+lrrnRSc+L28 + leut9g3mfUf4H4X/ZPirwz89/PHhjWLuR/n5mBSc+HvKYz/H2waAuThQPFA6hefh0gDUfavQhODCPnkn + 5H3ER3zYx7300ks/+8mTJ7/38eNH//eVXzyOesC8vQaA86Hz2e38is/kHRzvBeevStSl+jL1HghO/FTe + w2Nc9AXnr8qD5703uD8Qv5z83He84yPeOXE+mgUnfur8NgtO/D3l8Uo++3lpAHi1+FDxQHmPgCeWBmD5 + +4RnBBcefXJGzXtz/DB9QWz4f6HTD+foF49R87YNAOdR57PH+e2Rt3esF56/RVGX6svWuyc48XN5U8c5 + 6wvP36KvLe/x48d/6dmzp18a//2YeLxZnEedz7nz2yQ48feUV/bw0gCwv8++9M+nA+kQSgNA5+DJrhCc + +FPyeFnmc8O/P36Y3ndNP+w3nLdpADiPOp+nnN+t4MSfkrc9zgHm76ioS/WdUu9WcOKP5U0d56QHmL+j + vvK8bw//kfCPCU+/9PxAnEedz2Pnt1pw4u8pr7x6XxoAXtmf3fz5UADdQWkAsCe7QnDis3mPw/9u+P8K + n/uHs9l3lvdtnEedz+z53ROc+FPzNsc4yPzNirpU36n1bgQnfilv6jgPPMj8zfrG8v5O+IvCL4cnxXnU + +Vw6v1WCE39vebg0AOznRz/0t9sAzHcKCwrOJ68+j0/TfmH468KbH5AL/3Au+g7zaABGWS8PNdL8TYq6 + VF+Pelvzpo5zzwPN36RvOO+94S8JPw9vxXnU+aw5v4uCE3+PefyXBoBX8uf383gQqDQA8+8RLEg5axVz + a3k/Jcwnabc/FAP9cE76TvNoADLn90Bw4rvkDTZ/B6Iu1delXjjxtXlTx7n1YPN34DvJ+4dh/oqAX0JH + uj4fCE78teTxv5c/w8cTwjQAfAbAm3+F4MS35r0z/LXhvR+EQX84t77jvN0GYKj1N9j87YnjU33d6hXf + kjd1nBt3qHfPzjs57y+89tqbPq3x/M4KTvw959X99R5PCs/fGGBB4q9tcs6d91L414UP/l7/Cn447zmv + NADDrb+V6s3mbVWOL9y1XuW05E0dZ696t3Zet7xve/r06W955zs//h2V53dScOJb18uk4MTfZl48MbXx + IwbRYLnBHwhO/C3lfe8wN+s5tvh37ItHrc+QVz4DMNz6W6nebN5Gu8e340vN38Fxdqx3Y+etkffob734 + 4oufHI83i3Wh9ZFZLweCE38XeU1iEA3WZXA48beU9++HvyVcufh98aj1mfJoAIZcfyvVm80b8ed37xg7 + 1+u8dfN4pfSLw9ViXWh9ZNfLnuDE30VekxhEg3UZHE78reS9Ev4vwgcLH5/5h6nZztvmHdwKuEasC62P + 2vVyVHDit3kjzd/U8enfl/z53R5f73qdd7a8/zLMtfSoWBdaH6esl63gxN9FXpMYRIN1GRxO/K3kfWT4 + r4YfLuaNL/jDVGXn7eU1NwCsC62P2vVyVHDi9/JGmr+p4wtf+ud3e3y963XeWfP+Svg7hSfFutD6OHW9 + bAQn/i7ymsQgGqzL4HDibyXve4T/XnhqIY/ww3TUzjvIa2oAWBdaH7Xr5ajgxE/l7dVS47Xmb+b4mgUn + vkfeavU67+x5/Mn09wvviXWh9dFjvdxdXpMYRIN1GRxO/K3k8cGVfxyeWsAj/TBN2nmTedUNAOtC66N2 + vRwVnPi5vN3jXPSa8zdzfE2CEz9Xb5PWrNd508wxd8j75+EfEt6IdaH10WW9wIm/i7wmMYgG6zI4nPhb + yfuM8DeFpxbuiD9Me3bebF5VA8C60PqoXS9HBSf+WN7DY5312vM3c3zVghN/rN5qwa1Zr/Pa3DHvm8Of + zvnV+ui2XsTfRR4Ktu6v/xhEg3UZHE78reT9gLA3f/nG8hYbANaF1kftejkqOPFLeVPHe+BzzN/M8VUJ + TvxSvVWCg989vt71Oq/eK+R985ve9OpnaZ10Wy/KuYe8cuv/ZV6Dc0ehMtG3PjmteR8X5r7WBwsfX8EP + k/OO5x1tAFgXWh+16+Wo4MTX5E0d757PNX8zx7coONVXU++i4MSPdp+EjZ3XLe+fv/nNr7+L86zzPdz6 + 2/FIeWz+3PF3uQHgCWHuJbx7ACMVc+m8jwr7A3/yjebNNgCsC62P2vVyVHDia/OmjnfrM89fs6hL9dXW + e1Rw4jdZK9fbbOf1zXv8+NHXf/iHf9jH91ovcrf1J4+Ux+Zfvu/neAOgJ/MtQvz2Xw5ipGIuncffpvpP + /eQbzptsAFgXWh+16+Wo4MS35E0d78YXmL8mUZfqa6l3VnDit3kr19tk562Wx58ILt4n4KGm1ov+fc6f + 31nBie+Vx37Ot/zybb+lAZj+DAAPhPn+YH77Lw3ASMWMkPd7w62LdfL5S3beRfMOGgDWhdZHy3qZFZz4 + 1ryp473U/FWLulRfa72TghO/l7dyvdV23up53CyoWrE2Rvn5nRSc+J557Od42wDo4X3FA6VTeB4uDUDd + twpNCC48+uS05nF7371FWnyBxd9k5zXn7TUArAutj5b1Mis48Zm8g+O94PxVibpUX6beA8GJn8p7eIyL + vuD8Vdl5s3m/MLwo1oXWx9R6aRac+JHzeCWf/bw0AI/08L7igfIeAU8sDcDy9wnPCC48+uS05n2f8LeG + Hy7ASy7+KjsvlbdtAFgXWh8t62VWcOKzeXvHeuH5WxR1qb5svXuCEz+XN3Wcs77w/C3aeUfz3h/+pPCs + WBdaH3PrpUlw4kfOK3t4aQDY32df+ufTgXQIpQGgc7jlyWnNezn8N8MHC/DCi3/RzkvnbRoA1oXWR8t6 + mRWc+FPytsc5wPwdFXWpvlPq3QpO/LG8qeOc9ADzd9TOq8rj2vw8fCDWhdbHsfVSLTjxI+eVV+9LA8Ar + +7ObPx8KoDsoDQC+5cnJ5P368MHCG2Txz9p5J+Vtvg1Q66N1vUwKTvypeZtjHGT+ZkVdqu/UejeCE7+U + N3WcBx5k/mbtvKa8rwzviXWh9bG0XqoEJ370PFwaAPbzox/6220A5juFBQV3q5P9PcN8ReXeghts8R/Y + eSfn0QCMsP6mNNL8TYq6VF+Pelvzpo5zzwPN36Sd15zHK3bfP7wR60Lro2a9LApO/DXk8V8aAF7Jn9/P + 40Gg0gDMv0ewIOWsVcyl8/5UeG+xDbj49+y8Lnk0AJn1ciA48V3yBpu/A1GX6utSL5z42ryp49x6sPk7 + sPPSeX8hzC+1I+0fB4ITv1Ye/3v5M3w8IUwDwGcAvPkf6qeG9xbZwIt/Y+d1y9ttAIZaz4PN3544PtXX + rV7xLXlTx7lxh3r37Lyx8l544UN/utZHy3qZFZz4a8qr++s9nhSevzHAgsRf2+TU5vGhkq8PbxfX6Ivf + eV3zSgMw3Hpeqd5s3lbl+MJd61VOS97Ucfaqd2vnjZj36Ou/1/f6hI9oXC+TghPfuv4mBSd+jLx4Ymrj + RwyiwXKDPxCc+FHyvij8YHH5h/OO8spnAIZbzyvVm83baPf4dnyp+Ts4zo71buy8cfOePXv2pY3r5UBw + 4jPr70Bw4ofMaxKDaLAug8OJHyXvSfjvhw8WV+/F6rxp5pjPlEcDMOR6XqnebN6IP797x9i5XueNn/fe + j/u478arAEP+/MrD5DWJQTRYl8HhxI+Ut73j3xUufuc1+Ejewa2Aa8Q603o7Zf1tBSd+mzfS/E0dn/59 + yZ/f7fH1rtd5V5PHK7jNYp1pvZ2y/raCEz9kXpMYRIN1GRxO/Eh53Cv5b4fPuVgnn79k562a19wAsM60 + 3k5Zf1vBid/LG2n+po4vfOnrwfb4etfrvKvJ+zvh6fvez4h1pvV26vrbCE78kHlNYhBNxq1Pzo8N+4fJ + eU0NAOtM6+3U9bcRnPipvL1aarzW/M0cX7PgxPfIW61e511VHtfyKrHOtN56rL/h85rEIBqsy+Bw4kfM + +4MXWqzVPpL33nj8T4f/s/BXh39V+CuWHNyvevr0yVc+ffp0x0++kv9/6vlLvpG8N8JVYp1pvfVYfzV5 + k+tizlHX3HqZfP6Sd/Nmjq9JcOLn6m1S5fmt9h3mfeWTJ49/z+PHj/90nOP39lwvH/RZ8v5IeFGsM623 + LusPTvyQeU1iEA3WZXA48SPmvTUW0fsvtFir/DAvfkj/92fPnv7iF1988XvF481injRfPebPeefJm1wb + U157/c0cX7XgxB+rt1pw4p2XEJz4bd5b3/qWT4rz/vPj4T8XnlwXc157/S3k8SreR4VnNVWv/n2T5xcF + W/fXfwyiwboMDid+yLxYRF94wcW66J28b3/y5MkfePObX3/XKfXCie8yf3DinZcQnPilvMn18dArrr+t + Z46vSnDil+qtEpx45yUEJ/5Y3ieGvyb8HeHJdVJ8jvVXkTf7dcHUpfqO1VstOPGj5pVb/y/zPCnMHYV6 + DT78ZD9+/OgvNi6uWa+1+OM3/v/j9ddf+/Qe9YrvNn/inZcQnPiavMk1suu11t/DvJnjWxSc6qupd1Fw + 4p2XEJz42rxPDv/FcNN66b3+KvL+1/CBqEv11dZ7VHDiR81j8+eOv8sNAE8Icy/h3QMYqZjueR/+4W// + hMTimvRKi/87nj59+ps+5VO+/1t71Cu+2/yJd15CcOJr8ybXSfFK628ur1nUpfpq6z0qOPHOSwhOfGve + o/CvDu+9GnDm9Vfjjw5vRV2qr7XeScGJHzWPzb9838/xBkBP5luE+O2/HMRIxayS99JLz79gkMW65w/k + PXr/yy+/xD2uh50/5TivUXDiW/Im1wpeZ/0dzWsSdam+lnpnBSfeeQnBiT8l7yeE3xe+xPqr8b8X3oi6 + VN8p9W4FJ37UPPZzvuWXb/stDcD0ZwB4IMz3B/Pbf2kARipmtbwnT578vkEW69YfyHv0/ldffeXHcYzy + kPO3Y+dVCk58a96R9XL2i2+1qEv1tdY7KTjxzksITnyPvB8R6+J9F1h/Nf6vw/d6ftnP8bYB0MP7igdK + p/A8XBqAum8VmhBcePTJ2eY9fvzoHw6yWDdW3nfEb/7/TjlGHe9dnA/ZedOaWy87a6/L+qvJqxJ1qb5M + vQeCE++8hODEd8t76aXnPy3WyXcsrJcqd17P7/3ET/xe/OY79PyJ75nHK/ns56UB4C2bQ8UD5T0Cnlga + gOXvE54RXHj0ydnmvf3tb/ukgRbrNu/p06e/sRyjjvcuzofsvHlNrpfe668yb1HUpfqy9e4JTrzzEoIT + 3z0vrllfdeb1t2i4t7zlzZ/M8e14yPnb8al5ZQ8vDQD7++xL/3w6kA6hNAB0Drc8OXt5z58/+4KRFis8 + f9//g37QD3yLjnHo+dO/nVchOPGn5B2sl97rryHvqKhL9Z1S71Zw4p2XEJz4VfL4kHKsmb98xvV31CXv + pZee/4flGHW8t3w+yqv3pQHglf3ZzZ+XRugOSgOAb3lyDvJikXxVPDy5gI55rcUaOd/++uuvvbscX/iu + zkfYecf1cL3s+KybP54Vdam+U+vdCE688xKCE79q3osvvvgp8fDifQIees31/PTpk99Wji986+cDlwaA + /fzoh/52G4D5TmFBwV3L5Ezl/bfhyUU05zUX65MnT37/g+NrFpz4qXqbBSfeeQnBie+Rt+r6a8ybFHWp + vh71Ou/68n5feGq9THrt9cxtjR8cX5PgxM/V2yQ48Wvk8V8aAF7Jn9/P40Gg0gDMv0ewIOWsVcw58v5W + eHIhTXntxfqWt7z5hzw4vibBiZ+rt0lw4p2XEJz4Lnlrr7/GvANRl+rrUi+ceOclBCf+nHncMXBqvRz4 + POv50Tc8OL5qwam+Y/VWC078Wnn87+XP8PGEMA0AnwG4183/SfhfhScX00OvvVijU/2LD46vSXDi5+pt + Epx45yUEJ75b3prrL5G3J45P9XWrV7zzEoITf4m8xe8O6LD+9nwkj7cknoWbRF2qr6beRcGJXzOv7q/3 + eFKYBuBeN3/08eHJxfTQ51isz549/UUPjq9acKrvWL3VghPvvITgxHfN210vvddfIm+rcnzhrvUqx3mN + ghN/qbyfF55aMxt3Wn9bV+Rxra8WdWn+b+V87CuemNr4EYNosNzgDwQn/tx57w7vLaQpn2uxhj8hHm8W + dam+pXqrBCfeeQnBie+et+b6S+RttHt8Ox5y/nbsvErBiW/J++7hqTXTc/1tXJn36eEqUZfqa6l3VnDi + h8xrEoNosC6Dw4m/RN7nhncXyYHPuFi/IR5vFnWpvpp6FwUn3nkJwYlfJW/F9Tf5/AX7/DrvmP6f8N6a + 6bz+WvJ+YnhR1KX6MvUeCE78kHlNYhAN1mVwOPGXyvvJ4YcLZeszL9avDTeJulRfbb1HBSfeeQnBiV8t + b8X11+yp49O/fX4rBCf+VvP+x/B2vfRef415Pyd8VNSl+rL17glO/JB5TWIQDdZlcDjxl8z7WeGpxXKJ + xfq7wtWiLtXXUu+s4MQ7LyE48avmrbj+mgw3dXxhn98KwYm/5Tyuadv10nv9Neb9wvCsqEv1nVLvVnDi + h8xrEoNosC6Dw4m/dN4Xhw8Wy4UW628IV4m6VF9rvZOCE++8hODEnyNvd81Uea31PHN8zYIT77yE4MSP + lvdrw6utv8a8XxyeFHWpvlPr3QhO/JB5TWIQDdZlcDjxI+T9svDeQrngYn0jvCjqUn2Zeg8EJ955CcGJ + P1few3Vz1Guu55njaxKc+Ll6mwQn3nkJwYnvkffGmuuvMY9r/YGoS/X1qHf4vCYxiAbrMjic+FHy3hPe + LpILL1aO5aioS/Vl690TnHjnJQQn/px5U2tn0muv55njqxac+GP1VgtOvPMSghPfJS/Wyxtrrr/GvIPr + K3Wpvi71wokfMg8FW/fXfwyiwboMDid+pLxtA3Di4jpwIu9oA0Bdqu+UereCE++8hODEnztvau0c+Bzr + eeb4qgQnfqneKsGJd15CcOK75T19+uTX7K6X3uuvMW/v+srxqb5u9YofNa/c+n+Z50lh7ijUa/BRJ2fT + AHRYXHtO5s02ANSl+k6tdyM48c5LCE78JfKm1s6ez7WeZ45vUXCqr6beRcGJd15CcOK75j179vTXrrn+ + GvO219dyfOGu9SpnxDw2f+74u9wA8IQw9xLePYCRiumZ955Oi2vrE/ImGwDqUn096nXe9edNrZ2tz7ye + m0Vdqq+23qOCE++8hODEd8/7YANwkevpQ2+ur7vHt+Mh52/Hp+Sx+Zfv+zneAOjJfIsQv/2XgxipmK55 + sYj8HpXzqgUn/pJ5U2tn4xPX34Er8ppEXaqvpd5ZwYl3XkJw4lfJ+0ADcLHr6UO/5+HxycPOn3xKHvs5 + 3/LLt/2WBmD6MwA8EOb7g/ntvzQAIxXTPc/vUTmvVnDiL503tXZ6Xyxr86pFXaqvtd5JwYl3XkJw4lfL + 4/q68vqrdnBvPDw+/fuWzwf7Od42AHp4X/FA6RSeh0sDUPetQhOCC48+OX6PynlVghM/Qt7B2um0/rZu + yKsSdam+TL0HghPvvITgxK+aF+uFP21+uGYWvcZ6phl5eHzhWz4fvJLPfl4agEd6eF/xQHmPgCeWBmD5 + +4RnBBcefXI2eX6Pql1w4p2XEJz4bN7euum4/jZuzFsUdam+bL17ghPvvITgxJ8jj2va1LqZ9VrrmWv9 + xPE1C078VL3NghPfM6/s4aUBYH+ffemfTwfSIZQGgM7hlidnm+f3qNoEJ955CcGJPyVvu2Y6r79M3lFR + l+o7pd6t4MQ7LyE48efKa2oA1lzPOw3ANc1fk+DC5dX70gDwyv7s5s+HAugOSgOAb3ly9vL8HlW94MQ7 + LyE48afmlfXSe/1l8mZFXarv1Ho3ghPvvITgxJ8zr7oBWHs9qwG4h/OBSwPAfn70Q3+7DcB8p7Cg4K5l + cvbyYpH4PaoKwYl3XkJw4nvkrbL+knmToi7V16Ne511vXlUDcI71rOvrPZwP/ksDwCv58/t5PAhUGoD5 + 9wgWpJy1ilk7z+9RLQhOvPMSghPfJW+t9ZfMOxB1qb4u9cKJd15CcOIvkbd4fT3jeq76rpWHoi7VV1Pv + ouDEr5XH/17+DB9PCNMA8BmAe9z8kd+jOiI48c5LCE58t7y11l8yb08cn+rrVq945yUEJ/5SeUevrx3W + 354X8jiWJlGX6qut96jgxK+ZV/fXezwpPH9jgAWJv7bJeZhX3QCsvVjv6D0q5yUEB7/W+kvmbVWOL9y1 + XuU4r1Fw4i+ZN3t97bT+tq7Ia2oAqEv1tdQ7KzjxY+TFE1MbP2IQDZYb/IHgxJ87r6oBOMdivaP3qJzX + KDjxr621/pJ5G+0e346HnL8dO69ScOJb8yavrx3X38aVedUNAHWpvtZ6JwUnfsi8JjGIBusyOJz4S+Qt + NgBnXKz38h6V8xoEJ36TteL6m3z+gn1+nXdMB9fXzuuvJa+qAaAu1Zep90Bw4ofMaxKDaLAug8OJv1Te + 0QbgzIu1ukMtoi7VV1vvUcGJd15CcOJXy1tx/TV76vj0b5/fCsGJv9W8vetr7/XXmLd4faUu1Zetd09w + 4ofMaxKDaLAug8OJv2TebANwgcXa1ABQl+prqXdWcOKdlxCc+FXzVlx/TYabOr6wz2+F4MTfct72+rrG + +mvMO3p9pS7Vd0q9W8GJHzKvSQyiwboMDif+0nmTDcCFFmt1A0Bdqq+13knBiXdeQnDiz5G3u2aqvNZ6 + njm+ZsGJd15CcOJHy9tcX9daf415s9dX6lJ9p9a7EZz4IfOaxCAarMvgcOJHyDtoAC64WKsaAOpSfZl6 + DwQn3nkJwYk/V97DdXPUa67nmeNrEpz4uXqbBCfeeQnBie+R9541119j3uT1lbpUX496h89rEoNosC6D + w4kfJW+vAbjwYl1sAKhL9WXr3ROceOclBCf+nHlTa2fSa6/nmeOrFpz4Y/VWC0688xKCE98lL9bLG2uu + v8a8g+srdam+LvXCiR8yDwVb99d/DKLBugwOJ36kvG0DcOLiOnAi72gDQF2q75R6t4ITP3zeu9/9rtff + +ta3/MCXXnr+02L+vjgeZq7wLwz/hPDHh48u7N28HQ9Z746n8qbWzoHPsZ5njq9KcOKX6q0SnPhuee96 + 16ey7j715Zdf+hnPnj378qdPn/y6mIdfGQ9/Sfjzw58Qrrqgkqfj6XZ84ofN40+bd9dL7/XXmLd3feX4 + VF+3esWPmldu/b/M86QwdxTqNfiok7NpADosrj0n82YbAOpSfafWuxGc+GHzYtN/7dVXX/28J0+efE3M + 3zdWzN97w/95+IeH90Sejqfb8Ym/RN5U7Xs+13qeOb5Fwam+mnoXBSe+R96HvvDCC5/95Mnj3xd1/tPd + emfmr6y7zwhPiuPQ8fQ4vqvJ4+ZmFfO36E7reXt9LccX7lqvckbMY/Pnjr/LDQBPCHMv4d0DGKmYnnl+ + j2rAvJdeeunffvz48d844Xz81fCPDd/i/E3Vu/WZ13OzqEv11dZ7VHDie+T9hKjrr58wf38l/GPCW3Ec + Op4ex3dVeR9sAFZbfy3eXF93j2/HQ87fjk/JY/Mv3/dzvAHQk/kWIX77LwcxUjFd82IR+T2qgfJi0//o + 8B9Pzt+Bg/vv3vGOD//uvY4PTvwl8yZrxSeuvwNX5DWJulRfS72zghN/at5Hh/9Yx/n7w+GP4Dh0PKce + 30Zw4q8i7wMNwKrrr8XveXh88rDzJ5+Sx37Ot/zybb+lAZh+y4oHwnx/ML/9lwZgpGK65/k9qnHyXnjh + hR8Wc/beE+Zvzzvn4x+/9tqbPvvU44MT36VeOPGteUv17nj19Vwt6lJ9rfVOCk78qXk/LPyNK8zf17/p + Ta9+Zofj2whO/NXkcX09Yf56n4834piuav7071Py2M/xtgHQw/uKB0qn8DxcGoC6bxWaEFx49Mnxe1SD + 5MXm/zkxZ+87cf62njgf3/ryyy/9hOzxwam+LvXCic/k1dS7+XfH+ZvLqxJ1qb5MvQeCE39q3ueG37fi + /H3rq6++8uNOOL6N4MSfWu9GcOJXzYt54Pbmk3N0zGucD33Xyt7xhW/5fPBKPvt5aQAe6eF9xQPlPQKe + WBqA5e8TnhFcePTJ2eT5Pap2wYnvkheb/6fFnH1rh/nb+Mj5eF88/qPDTaIu1delXjjx2bzaeveeV+vG + vEVRl+rL1rsnOPGn5n1e+P1nmL9vfdObXv2MxPFtBKf6Tq13Izjx58jjmjY5T3Ne63xwrZ84vmbBiZ+q + t1lw4nvmlT28NADs77Mv/fPpQDqE0gDQOdzy5Gzz/B5Vm+DEd8njPf+YszVe9p/La2oCqEv1dakXTvwp + eS31NjmRd1TUpfpOqXcrOPGn5p1r8y95/yge/7Bwk6hL9Z1a70Zw4s+V19QArHk+dhqAa5q/JsGFy6v3 + pQHglf3ZzZ8PBdAdlAYA3/Lk7OX5Pap6wYnvlhcNwB/rOH8bviKvqgng+FRft3rFn5rXWm+Vk3mzoi7V + d2q9G8GJPzXv3Jt/ec4fCFeLulTfqfVuBCf+nHnVDcDa50MNwLXNX7XgxOPSALCfH/3Q324DMN8pLCi4 + a5mcvbxYJH6PqkJw4rvlvfTSSz+55/w1no+jTQDHp/q61Su+R16m3qM+IW9S1KX6etTbM+9Sm3/xjwwv + irpU36n1bgQn/tx5VQ3AOc6Hrq/XNn9VghNfcmgAeCV/fj+PB4FKAzD/HsGClLNWMWvn+T2qBcGJ75oX + v/3/9Z7zlzgfk01AOb5w13qVc3LeCfVO+sS8A1GX6utSL5z4U/MuvfnjvxA+KupSfafWuxGc+EvkLV5f + z3g++GWvWdSl+mrqXRSc+LXy+N/Ln+HjCWEaAD4DcI+bP/J7VEcEJ75r3pve9Cqf+u86f8m8vSagHF+4 + a73K6ZJ3Yr177jB/e+L4VF+3esWfmjfC5l/8g8OToi7Vd2q9G8GJv1Te0evrmc8Hx9Ik6lJ9tfUeFZz4 + NfPq/nqPJ4XnbwywIPHXNjkP86obgLUX6x29R/XakydPfm/v+Tshb9ME7B7fjoebvw71btxp/rYqxxfu + Wq9yTskbafPHvy18IOpSfafWuxGc+EvmzV5fL3A+mhoA6lJ9LfXOCk78GHnxxNTGjxhEg+UGfyA48efO + q2oAzrFY7+U9Kr7YJ+p9b+/5OzHvfS+//NJP5Ph2POT8dap3w3eYv412j2/HI8zfaJs//vvhPVGX6ju1 + 3o3gxF86b/L6eqHzUd0AUJfqa613UnDih8xrEoNosC6Dw4m/RN5iA3DGxXoX71G97W1v/f4rzd/k85e8 + k/e+V155+fN1nMPOX8d6d5zOG3n9jbj5F3/n8EbUpfpOrXcjOPEj5B1cXy94PqoaAOpSfZl6DwQnfsi8 + JjGIBusyOJz4S+UdbQDOvFirO9Qi6lJ9tfUeFZz41fL4op+V5q/ZE3nllYBh569zvZt/Z/Omjk//vvT8 + jbz5438jfJb1on9fKm/v+nrh87F4faUu1Zetd09w4ofMaxKDaLAug8OJv2TebANwgcXa1ABQl+prqXdW + cOJXzYt6f348vDc3NT7j+ai6T8BDRW3nmr/Jepa8xvxNHV/40utv9M0f/xzqUn2n1rsRnPiR8rbX1wHO + x9HrK3WpvlPq3QpO/JB5TWIQDdZlcDjxl86bbAAutFirGwDqUn2t9U4KTvw58r4svFv3oi9wPpqaAOpS + fVP1NgtO/FTeXi01Xmv+Zo6vWXDiT827hs0f7hervlPr3QhO/Gh5m+vrIOdj9vpKXarv1Ho3ghM/ZF6T + GESDdRkcTvwIeQcNwAUXa1UDQF2qL1PvgeDEnyuvqQG44Pl4f3ixCaAu1TdXb5PgxM/lPTzOo15z/maO + r0lw4ufqrdW1bP7/+unTp1/eod6N4MSPmPeegc7H5PWVulRfj3qHz2sSg2iwLoPDiR8lb68BuPBiXWwA + qEv1ZevdE5z4c+Z9UXiq/gNf+Hzgo00Adam+Y/VWC078sbyp45z02vM3c3zVghN/rN4aXc3mD//8+fOf + f2K9G8GJP3X+NoIT3yUv6n1joPNxcH2lLtXXpV448UPmoWDr/vqPQTRYl8HhxI+Ut20ATlxcB07kHW0A + qEv1nVLvVnDiz533Y8NT9e95gPNRPNkEUJfqW6q3SnDil/KmjvHA55i/meOrEpz4pXqXdFWbPzmvvvrK + jz+h3o3gxJ86fxvBie+Wx582rzF/yby96yvHp/q61St+1Lxy6/9lnieFuaNQr8FHnZxNA9Bhce05mTfb + AFCX6ju13o3gxF8i77uGp+rfepDzseu9JoC6VF9NvYuCE1+TN3V8ez7X/M0c36LgVF9Nvcd0dZs/fsc7 + PuKdyXo3ghN/6vxtBCe+ax43N1tj/pJ52+trOb5w13qVM2Iemz93/F1uAHhCmHsJ7x7ASMX0zPN7VJfJ + 4+tRp+ag1w/71h3zNk0Adam+lnpnBSe+Nm/q2LY+8/w1i7pUX229c7rKzf/x40dfl6x3Izjxp87fRnDi + u+d9sAEY4nxsrq+7x7fjIedvx6fksfmX7/s53gDoyXyLEL/9l4MYqZiuebGI/B7VZfJ+Z/hgDk6cvwOv + kPf+Ae4YOHls+ALz1yTqUn0t9U7pKjd//OTJk9+RqHcjOM3XqfO3EZz4VfI+0AAMcz7e8/D45GHnTz4l + j/2cb/nl235LAzD9GQAeCPP9wfz2XxqAkYrpnuf3qC6W967wXv2df9jXzHv/he8YuHR8O159/qpFXaqv + td6HutrNn3+/+OKLnxKPN4t50nydOn8bwYlfLY/r60Dn442Hx6d/Dzt/+vcpeezneNsA6OF9xQOlU3ge + Lg1A3bcKTQguPPrk+D2qy+b9pfCm9k7zt/UZ8sorAZeYv5rj2/z7DPNXJepSfZl6d3XVm3/8/382Hm8W + 86T5OnX+NoITv2pe1MvtzSfn6JjXOB/6rpW94wsPPX/hU/J4JZ/9vDQAj/TwvuKB8h4BTywNwPL3Cc8I + Ljz65Gzy/B5Vu+DEn5r3o8I952/jM+ZV3SfgoZgnzVd2/mqPb+95tW7MWxR1qb5svUXXvvnz+KeHm8Q8 + ab5Onb+N4MSfI49r2sEcHfNa54Nr/cTxNQtO/FS9zYIT3zOv7OGlAWB/n33pn08H0iGUBoDO4ZYnZ5vn + 96jaBCe+S17M0x/sOH+9z0dNXlMTwDxpvk6Zv5bja3Ii76ioS/WdUi+6hc3/a8JNYp40X6fO30Zw4s+V + 19QArHk+dhqAa5q/JsGFy6v3pQHglf3ZzZ8PBdAdlAYA3/Lk7OX5Pap6wYnvlvfRH/2RH/v48aOv7zR/ + G77j+ajNq2oCqFfzder8tR5flZN5s6Iu1Xdqvbew+X9d+C3hajFPmq9T528jOPHnzKtuANY+H2oArm3+ + qgUnHpcGgP386If+dhuA+U5hQcFdy+Ts5cUi8XtUFYIT3z3v9ddf+4yYv2/p+cPe43w05h1tAnbr3XF2 + /kaot3hS1KX6Tq33Fjb/bwp/v3C1mCfN16nztxGc+HPnVTUA5zgfur5e2/xVCU58yaEB4JX8+f08HgQq + DcD8ewQLUs5axayd5/eoFgQnfrW8V155+fNiHr4lHp6co2Ne63wk8mgCPie8p6l69e/U/A1ULz4Qdam+ + U+u9hc3/X4bfHa4W86T5OnX+NoITf4m8xevrGc8Hv+w1i7pUX029i4ITv1Ye/3v5M3w8IUwDwGcA7nHz + R36P6ojgxJ8j77PCTU3AmucjmbfXBFCX6puqt1lwg9W7J45P9Z1a761s/k0f+mOeNF+nzt9GcOIvlXf0 + +nrm88GxNIm6VF9tvUcFJ37NvLq/3uNJ4fkbAyxI/LVNzsO86gZg7cV6R+9RHcurbgLWPh8n5G2aAOpS + fcfqrRYcfIfj27hTvVuV4wufWq83/9PmbyM48ZfMm72+nvl84KYGgLpUX0u9s4ITP0ZePDG18SMG0WC5 + wR8ITvy586oagHMs1jt6j2opb7EJOMf5ODGP+wSUmwUt1bsoOPGvDVbvRrvHt+NMvd78T5u/jeDEXzpv + 8vp65vNRXN0AUJfqa613UnDih8xrEoNosC6Dw4m/RN5iA3DGxXov71HV5M02AWc8H5PPX/JOHncM/Lcq + 650VnPjN3A1Wb8/14s3/tPnbCE78CHkH19czn49dVzUA1KX6MvUeCE78kHlNYhAN1mVwOPGXyjvaAJx5 + sVZ3qEXUpfpq6z0qOPEj5B00AWc+H82eyCuvBHSbv5HqnTo+/bu1Xm/+p83fRnDiR8nbu76e+Xw89OL1 + lbpUX7bePcGJHzKvSQyiwboMDif+knmzDcAFFmtTA0Bdqq+l3lnBiR8pb9sEXOB8NPlI3uRfByyJedJ8 + 7c3fSPVOHV+4db148z9t/jaCEz9S3vb6eubzMeWj11fq0vzf8vnIiUE0WJfB4cRfOm+yAbjQYq1uAKhL + 9bXWOyk48SPmfVbM0+Y+AQvzV+3K81HtirymJoB50nxNzd/e2DVeq96Z42uRN//T5m8jOPGj5W2ur2c+ + H3Oevb5Sl+o7td6N4MQPmdckBtFgXQaHEz9C3kEDcMHFWtUAUJfqy9R7IDjxw+a98srLPybm7VsX5q/K + Fzy/VU0A9Wq+5ubvYe5Rr1nvzPHVypv/afO3EZz4EfPec+bzccyT11fqUn096h0+r0kMosG6DA4nfpS8 + vQbgwot1sQGgLtWXrXdPcOKHz3v11Vd+bMxfNAEXuXhMOpF3tAnYrXfHD+dvKnfSa9c7c3w18uY/f36r + BSd+yLyYpzfOeD6WfHB9pS7V16VeOPFD5qFg6/76j0E0WJfB4cSPlLdtAE5cXAdO5B1tAKhL9Z1S71Zw + 4q8mj1cCYv6q7hPw0AOc3+LJJmCqXv374fxNZR74HPXOHN+SvPkfP79VghM/bB5/2jwzf83ucH73rq8c + n+rrVq/4UfPKrf+XeZ4U5o5CvQYfdXI2DUCHxbXnZN5sA0Bdqu/UejeCE3+NedU3Cyoe5Pzueq8JoC7V + N1XvQ03l7flc9c4c3zF5818+v4uCEz90Hjc3O8P5qPX2+lqOL9y1XuWMmMfmzx1/lxsAnhDmXsK7BzBS + MT3z/B7VdeZVNwEDnd+Hpgn4XOpSfcfq3dVU1tZnrrdF3vzrzu9RwYkfPu+DDcAQ53dzfd09vh0POX87 + PiWPzb9838/xBkBP5luE+O2/HMRIxXTNi0Xk96iuN2+xCTjxfBx4hTzuE1BuFrRUb9FkFr5AvbXy5l9/ + fmcFJ/4q8j7QAAxzft/z8PjkYedPPiWP/Zxv+eXbfksDMP0ZAB4I8/3B/PZfGoCRiume5/eorj5vtgno + fPFYM487Bv6kynrRUt6OV6+3Rt7869fzrODEX00e19eBzu8bD49P/77l88F+jrcNgB7eVzxQOoXn4dIA + 1H2r0ITgwqNPjt+juo28gyag0/nY+gx55ZWAmnpr8jb/PkO9S/Lm376eDwQn/qryYv64vfnBfC95jfOr + 71rZO77wLZ8PXslnPy8NwCM9vK94oLxHwBNLA7D8fcIzgguPPjmbPL9H1S448SPlbZuAjudj4zPmbT4T + EF5Sbd7e82rdmHdM3vzz63krOPHXmMc17WDOj3mt88u1fuL4mgUnfqreZsGJ75lX9vDSALC/z770z6cD + 6RBKA0DncMuTs83ze1RtghM/Yt6t3DFwqQloyWtyIm9O3vxPX8+3kNfUAKx5fncagGuavybBhcur96UB + 4JX92c2fDwXQHZQGAN/y5Ozl+T2qesGJHzbvhu4YeKwJaM2rcjJvSt78O61n8decV90ArH1+1QBc2/xV + C048Lg0A+/nRD/3tNgDzncKCgruWydnLi0Xi96gqBCd++LwbumPgXBMwwvEVP5Q3/87recfXmFfVAJzj + /Or6eg/ng//SAPBK/vx+Hg8ClQZg/j2CBSlnrWLWzvN7VAuCE381ea+88vLnxbxW3Sfgodc6v4m8ySZg + oOPDu/Lm/0EP/fOhf58jb/H6esbzyy97zaIu1VdT76LgxK+Vx/9e/gwfTwjTAPAZgHvc/JHfozoiOPHX + mPeZ4aYmYM3zm8zbawKoa7DjK7qVzf/d4WpxPrTeptZfs+DE30re0evrmc8vx9Ik6lJ9tfUeFZz4NfPq + /nqPJ4XnbwywIPHXNjkP86obgLUX6x29R3XOvOomYO3ze0LepgmgLurrkLdxp+ND3vzn11+14MTfUt7s + 9fXM5xc3NQDUFb7d8xtPTG38iEE0WG7wB4ITf+68qgbgHIv1jt6jOnfeYhNwjvN7Yt72joGDHZ83/+X1 + tyg48beWN3l9PfP5La5uAKhL9bXWOyk48UPmNYlBNFiXweHEXyJvsQE442K9l/eoLpE32wSc8fxOPn/J + O3mbOwYOdnze/OvW36zgxN9i3sH19cznd9dVDQB1qb5MvQeCEz9kXpMYRIN1GRxO/KXyjjYAZ16s1R1q + EXWpvtp6jwpO/C3mHTQBZz6/zZ7Ie//gx3dNed78FwQnPpu3d3098/l96MXrK3Wpvmy9e4ITP2RekxhE + g3UZHE78JfNmG4ALLNamBoC6VF9LvbOCE3/Ledsm4ALnt8nOWzXPm/+C4MSfkre9vp75/E756PWVulTf + KfVuBSd+yLwmMYgG6zI4nPhL5002ABdarNUNAHWpvtZ6JwUn/h7yPjPm/drvGNhk5+3lefNfEJz4U/M2 + 19czn985z15fqUv1nVrvRnDih8xrEoNosC6Dw4kfIe+gAbjgYq1qAKhL9WXqPRCc+LvJ4z4BcR6u/Y6B + VXbeXp43/wXBie+R954zn99jnry+Upfq61Hv8HlNYhAN1mVwOPGj5O01ABderIsNAHWpvmy9e4ITf3d5 + r776im4bfJGL0aSdt2qeN/8FwYnvkhfz/sYZz++SD66v1KX6utQLJ37IPBRs3V//MYgG6zI4nPiR8rYN + wImL68CJvKMNAHWpvlPq3QpO/N3m3cgdAyftvL08b/4LghPfLY8/bZ45H83usF72rq8cn+rrVq/4UfPK + rf+XeZ4U5o5CvQYfdXI2DUCHxbXnZN5sA0Bdqu/UejeCE++8eDjc1AQMsl5m7by9PG/+C4IT3zWPm5ud + 4fzWent9LccX7lqvckbMY/Pnjr/LDQBPCHMv4d0DGKmYnnl+j8p5qLoJGGi9TNp5e3ne/BcEJ7573gcb + gCHWy+b6unt8Ox5y/nZ8Sh6bf/m+n+MNgJ7Mtwjx2385iJGK6ZoXi8jvUTmvaLEJOPH8Hth5q+Z5818Q + nPhV8j7QAAyzXt7z8PjkYedPPiWP/Zxv+eXbfksDMP0ZAB4I8/3B/PZfGoCRiume5/eonPdAs01A54uR + 89bN8+a/IDjxq+VxfR1ovbzx8Pj071s+H+zneNsA6OF9xQOlU3geLg1A3bcKTQguPPrk+D0q503poAno + dH63dt6qed78FwQnftW8OB/c3vzg/C15jfWi71rZO77wLZ8PXslnPy8NwCM9vK94oLxHwBNLA7D8fcIz + gguPPjmbPL9H1S448bect20COp7fjZ23ap43/wXBiT9HHte0g3N4zGutF671E8fXLDjxU/U2C058z7yy + h5cGgP199qV/Ph1Ih1AaADqHW56cbZ7fo2oTnPh7yPMdA68rz5v/guDEnyuvqQFYc73sNADXNH9NgguX + V+9LA8Ar+7ObPx8KoDsoDQC+5cnZy/N7VPWCE383eb5j4NXkefNfEJz4c+ZVNwBrrxc1APdwPnBpANjP + j37ob7cBmO8UFhTctUzOXl4sEr9HVSE48XeX9+qrr6oJuJrNsNlXnufNf0Fw4s+dV9UAnGO96Pp6D+eD + /9IA8Er+/H4eDwKVBmD+PYIFKWetYtbO83tUC4ITf7d5r7zy8ufGeaq6T8BDr7VenLfJY/P/YeFqTZ1f + /ds/HxWCE1+Tt3h9PeN64Ze9ZlGX6qupd1Fw4tfK438vf4aPJ4RpAPgMwD1u/sjvUR0RnHjnfciH/PBw + UxOw5npxnjf/JcGJv1Te0evrmdcLx9Ik6lJ9tfUeFZz4NfPq/nqPJ4XnbwywIPHXNjkP86obgLUX6x29 + R3XNedVNwNrr5c7zvPkvCE78JfNmr69nXi+4qQGgLtXXUu+s4MSPkRdPTG38iEE0WG7wB4ITf+68qgbg + HIv1jt6juva8xSbgHOvljvO8+S8ITvyl8yavr2deL8XVDQB1qb7WeicFJ37IvCYxiAbrMjic+EvkLTYA + Z1ys9/Ie1S3kzTYBZ1wvk89f8pXnefNfEJz4EfIOrq9nXi+7rmoAqEv1Zeo9EJz4IfOaxCAarMvgcOIv + lXe0ATjzYq3uUIuoS/XV1ntUcOKdt6yDJuDM66XZV57nzX9BcOJHydu7vp55vTz04vWVulRftt49wYkf + Mq9JDKLBugwOJ/6SebMNwAUWa1MDQF2qr6XeWcGJd169tk3ABdZLk688z5v/guDEj5S3vb6eeb1M+ej1 + lbpU3yn1bgUnfsi8JjGIBusyOJz4S+dNNgAXWqzVDQB1qb7WeicFJ9557frhcR59x8D18rz5LwhO/Gh5 + m+vrmdfLnGevr9Sl+k6tdyM48UPmNYlBNFiXweHEj5B30ABccLFWNQDUpfoy9R4ITrzzEoLjPgFxXn3H + wInnL3khz5v/guDEj5j3njOvl2OevL5Sl+rrUe/weU1iEA3WZXA48aPk7TUAF16siw0Adam+bL17ghPv + vITgxPuOgRPPX/JCnjf/BcGJHzIvzuMbZ1wvSz64vlKX6utSL5z4IfNQsHV//ccgGqzL4HDiR8rbNgAn + Lq4DJ/KONgDUpfpOqXcrOPHOSwhO/DbPdwys90KeN/8FwYkfNo8/bZ45v83usP72rq8cn+rrVq/4UfPK + rf+XeZ4U5o5CvQYfdXI2DUCHxbXnZN5sA0Bdqu/UejeCE++8hODET+VV3yyoeJD1N+sz53nzXxCc+KHz + uLnZGdZLrbfX13J84a71KmfEPDZ/7vi73ADwhDD3Et49gJGK6Znn96ic1yQ48cfyqpuAgdbfpM+c581/ + QXDih8/7YAMwxPrbXF93j2/HQ87fjk/JY/Mv3/dzvAHQk/kWIX77LwcxUjFd82IR+T0q51ULTnxN3mIT + cOJ6OfCV53nzXxCc+KvI+0ADMMz6e8/D45OHnT/5lDz2c77ll2/7LQ3A9GcAeCDM9wfz239pAEYqpnue + 36NyXq3gxLfkzTYBnS9u157nzX9BcOKvJo/r60Dr7404pns7H+zneNsA6OF9xQOlU3geLg1A3bcKTQgu + PPrk+D0q51UJTnwm76AJ6LRetr7yPG/+C4ITf1V5cX65vfnBeljyGutP37Wyd3zhWz4fvJLPfl4agEd6 + eF/xQHmPgCeWBmD5+4RnBBcefXI2eX6Pql1w4p1Xr20T0HG9bHzled78FwQn/hrzuKYdrIljXmv9ca2f + OL5mwYmfqrdZcOJ75pU9vDQA7O+zL/3z6UA6hNIA0Dnc8uRs8/weVZvgxDuvXb5j4H6eN/8FwYm/1rym + BmDN9bfTAFzT/DUJLlxevS8NAK/sz27+fCiA7qA0APiWJ2cvz+9R1QtOvPMSgvMdA7d53vwXBCf+mvOq + G4C1158agGubv2rBicelAWA/P/qhv90GYL5TWFBw1zI5e3mxSPweVYXgxDsvITjxvmPgh3zIN4e9+R8R + nPhrz6tqAM6x/nR9vYfzwX9pAHglf34/jweBSgMw/x7BgpSzVjFr5/k9qgXBiXdeQnDit3mvvPLy58R5 + r7pPwEOvtf7OlOfNf0Fw4m8hb/H6esb1xy97zaIu1VdT76LgxK+Vx/9e/gwfTwjTAPAZgHvc/JHfozoi + OPHOSwhO/FTeZ4SbmoA1198Z8rz5LwhO/K3kHb2+nnn9cSxNoi7VV1vvUcGJXzOv7q/3eFJ4/sYACxJ/ + bZPzMK+6AVh7sd7Re1TO+6Cqm4C119/Ked78FwQn/pbyZq+vZ15/uKkBoC7V11LvrODEj5EXT0xt/IhB + NFhu8AeCE3/uvKoG4ByL9Y7eo3LevhabgHOsvxXzvPkvCE78reVNXl/PvP6KqxsA6lJ9rfVOCk78kHlN + YhAN1mVwOPGXyFtsAM64WO/lPSrnHWq2CTjj+pt8/pIX8rz5LwhO/C3mHVxfz7z+dl3VAFCX6svUeyA4 + 8UPmNYlBNFiXweHEXyrvaANw5sVa3aEWUZfqq633qODEOy8hOPGZvIMm4Mzrr9kLed78FwQn/lbz9q6v + Z15/D714faUu1Zetd09w4ofMaxKDaLAug8OJv2TebANwgcXa1ABQl+prqXdWcOKdlxCc+FPytk3ABdZf + kxfyvPkvCE78Ledtr69nXn9TPnp9pS7Vd0q9W8GJHzKvSQyiwboMDif+0nmTDcCFFmt1A0Bdqq+13knB + iXdeQnDie+R9RqyLa75joDf/BcGJv/W8zfX1zOtvzrPXV+pSfafWuxGc+CHzmsQgGqzL4HDiR8g7aAAu + uFirGgDqUn2Zeg8EJ955CcGJ75bHfQJinVzjHQO9+S8ITvw95L3nzOvvmCevr9Sl+nrUO3xekxhEg3UZ + HE78KHl7DcCFF+tiA0Bdqi9b757gxDsvITjx3fNeffVV3Tb4IhfLSS/kefNfEJz4u8iLdfHGGdffkg+u + r9Sl+rrUCyd+yDwUbN1f/zGIBusyOJz4kfK2DcCJi+vAibyjDQB1qb5T6t0KTrzzEoITv1reFd0x0Jv/ + guDE300ef9o8s16a3WE9711f7/B8lFv/L/M8KcwdhXoNPurkbBqADotrz8m82QaAulTfqfVuBCfeeQnB + iT9HXvXNgorPvJ69+S8ITvxd5XFzszOsv1pvr6/l+MJd61XOiHls/tzxd7kB4Alh7iW8ewAjFdMzz+9R + Oa9JcOLPmVfdBJx5PXvzXxCc+LvL+2ADcJHr6UNvrq+7x7fjIedvx6fksfmX7/s53gDoyXyLEL/9l4MY + qZiuebGI/B6V86oFJ/4SeYtNwInr78ALed78FwQn/i7zPtAAXOx6+tDveXh88rDzJ5+Sx37Ot/zybb+l + AZj+DAAPhPn+YH77Lw3ASMV0z/N7VM6rFZz4S+bNNgGdL5ZLed78FwQn/m7zuL6utP6aHdwbD49P/77l + 88F+jrcNgB7eVzxQOoXn4dIA1H2r0ITgwqNPjt+jcl6V4MSPkHfQBHRaf1sv5HnzXxCc+LvOi/XC7c0P + 1teS11jP+q6VveML3/L54JV89vPSADzSw/uKB8p7BDyxNADL3yc8I7jw6JOzyfN7VO2CE++8hODEn5K3 + bQI6rr+NF/K8+S8ITrzzPnBNO1hjx7zWeuZaP3F8zYITP1Vvs+DE98wre3hpANjfZ1/659OBdAilAaBz + uOXJ2eb5Pao2wYl3XkJw4nvknfuOgd78FwQn3nkfUFMDsLD+mr2bt9MAXNP8NQkuXF69Lw0Ar+zPbv58 + KIDuoDQA+JYnZy/P71HVC0688xKCE98t74x3DPTmvyA48c77oKobgIX11+yHeWoArm3+qgUnHpcGgP38 + 6If+dhuA+U5hQcFdy+Ts5cUi8XtUFYIT77yE4MR3z9MdA/9lz4vlg/X8L8KfFq7W7vHteMj527HzKgUn + fimvqgFYWH/NnsrT9fUezgf/pQHglfz5/TweBCoNwPx7BAtSzlrFrJ3n96gWBCfeeQnBiV8t77XX3vRp + sY7+QTw8ucaOeWE9f134+4arNXV8+rfPb4XgxN9C3uL1dWH9NftIHr/sNYu6VF9NvYuCE79WHv97+TN8 + PCFMA8BnAO5x80d+j+qI4MQ7LyE48efIe1v4vwpPrrUpL6znrwm/JVwtjkPHM3V8zYIT77yE4MRfKu/o + 9XXN6+lEHsfSJOpSfbX1HhWc+DXz6v56jyeF528MsCDx1zY5D/OqG4C1F+sdvUflvITgxC/lfVb4z4cn + 113xkfX8Z+PxTw83iePQ8SwdX5XgxDsvITjxl8ybvb6ufT2dyGtqAKhL9bXUOys48WPkxRNTGz9iEA2W + G/yB4MSfO6+qATjHYr2j96ic1yg48S15nxr+rWFexj+6/h4/fvR1T548+e0vvvgCTLM4Dh1Py/HNCk68 + 8xKCE3/pvMnr6zmupxN51Q0Adam+1nonBSd+yLwmMYgG6zI4nPhL5C02AGdcrPfyHpXzGgQn/pS8jw7/ + yPDPinX2i549e/qlz58//6JXX33l3/zIj/yIT0jkbQUn/pTj2wpOvPMSghM/Qt7B9fWM19OHz61qAKhL + 9WXqPRCc+CHzmsQgGqzL4HDiL5V3tAE482Kt7lCLqEv11dZ7VHDinZcQnHjnJQQn3nkJwYkfJW/v+nrm + 6+lDL15fqUv1ZevdE5z4IfOaxCAarMvgcOIvmTfbAFxgsTY1ANSl+lrqnRWceOclBCfeeQnBiXdeQnDi + R8rbXl8vcD196KPXV+rS/N/y+ciJQTRYl8HhxF8675eHDxbLhRZrdQNAXaqvtd5JwYl3XkJw4p2XEJx4 + 5yUEJ360vE0DcKHr6UNzrZ8Udam+U+vdCE78kHlNYhAN1mVwOPEj5P3S8N5CueBi/dXhRVGX6svUeyA4 + 8c5LCE688xKCE++8hODEj5j3ay94PX3oXxI+EHWpvh71Dp/XJAbRYF0GhxM/St6XhLeL5MKL9beHj4q6 + VF+23j3BiXdeQnDinZcQnHjnJQQnfsi8uM79zgteTx/6F4b3RF2qr0u9cOKHzEPB1v31H4NosC6Dw4kf + Ke8LwpsFcuLiOnAi778Pz4q6VN8p9W4FJ955CcGJd15CcOKdlxCc+GHzHj9+/Ccbrn9H3eH6/B+Et+L4 + VF+3esWPmldu/b/M86QwdxTqNfiok/OTwj0W156TedzKdVLUpfpOrXcjOPHOSwhOvPMSghPvvITgxA+d + F9e9b2i4/s260/X588MbleMLd61XOSPmsflzx9/lBoAnhLmX8O4BjFRMz7zP6rS4tj4x72PCe6Iu1dej + Xuc5r0lw4p2XEJz4u8r7sA97+ycOcD3d9WeE7/F8sPmX7/s53gDoyXyLEL/9l4MYqZiueS+++OL36bS4 + Nu6wWH92eCvqUn1d6oUT77yE4MQ7LyE48c5LCE788HnPnz//4gGup7t+5+7x7XjI+dvxKXns53zLL9/2 + WxqA6c8A8ECY7w/mt//SAIxUTPe87/bdPvYjOy2uXov1T4Y34vhUX7d6xTsvITjxzksITrzzEoITfxV5 + jx8//l8GuJ5u/corL+/+Utu9Xnm0PPZzvG0A9PC+4oHSKTwPlwYA3/LkbPJiYf2TUxdXx8X6HeGP2z2+ + HQ85fzt2XqXgxDsvITjxzksITvwqeW9961s+ZZDr6cbBfcPu8cnDzp98ah6v5LOflwbgkR7eVzxQ3iPg + iaUBWP4+4RnBhUefnG1edKp/frDF+p/uHp887PzJzqsUnHjnJQQn3nkJwYlfLe/Jk8dfM9D1lC+7+jO7 + xxceev7071Pyyh5eGgD299mX/vl0IB1CaQDoHG55cvbynjx58rtGWqzB/ys66J1jHHr+9G/nVQhOvPMS + ghPvvITgxK+W9/rrr/3guI59ezw8eY075pWup3zT6u/YOcah50//PiWvvHpfGgBe2Z/d/PlQAN1BaQDw + LU/OQV4skp8TD08uoGNea7GSw/tnP/SH/qA363jv6nyEnVchOPHOSwhOvPMSghO/zXvXuz719biO/bl4 + ePIad8xrXk9feun5z9UxDj1/+vepebg0AOznRz/0t9sAzHcKCwruWiZnKu8Tw5OLaM5rLtbip0+f/nId + X7PgVN9Uvc2CE++8hODEOy8hOPHOSwhO/Kp5cR37ZfHw5DXumNe+nr71rW/5VB3vPZwP/ksDwCv58/t5 + PAhUGoD59wgWpJy1ijlHHv/95+HJxfTQay/Wnbxvi8f5DvcmUZfqm6u3SXDinZcQnHjnJQQn3nkJwYlf + Ne+FF174vHi4+aX/M1xP/9m73/0ujvFezgf/e/kzfDwhTAPAZwDudfMv+sPhyQW16zMs1od53xT+weEq + UZfqW6q3SnDinZcQnHjnJQQn3nkJwYlfNS82/0+Lh/9leO/6tuRzXE8fP378R+IY7+l81P31Hk8Kz98Y + YEHir21y5vK+MDy5qIrPsVhn8mgCPjt8VNSl+mrqXRSceOclBCfeeQnBiXdeQnDiV82Lzf9z4uEhN3/l + 7X0HQK2itts+v/HE1MaPGESD5QZ/IDjxl8r7ruHJhYXPuFgnnx/m7YD/KDx5zqhL9dXWe1Rw4p2XEJx4 + 5yUEJ955CcGJXy1PH/j70niYa9PUNWvWZ76efudwk6bq1b9v8vw2iUE0WJfB4cRfOu+vhlsXV7NPzPuf + wh8f3oq6VF9rvZOCE++8hODEOy8hOPHOSwhO/Gp5b37z6z8wrlf/czw8dY066jNfT/9SuElT9erfN3l+ + m8QgGqzL4HDiR8j7snDL4mp2p7x/Ff4d4e9KXaovU++B4MQ7LyE48c5LCE688xKCE79K3tvf/rbv9+TJ + 498d1yuuQVPXpqO+wPWUV02r9bBeedjzIafzmsQgGqzL4HDiR8n7buGWxdXkFfK+/fHjx3/ipZeef8FH + fdRHfo9EvXuCE5+dvz3BiXdeQnDinZcQnHjnJQQH/1Ef9Y6Pi2vMF8a15mvjevXtA13/lvK4rXr1y/+l + 3nDX+VPOcHlNYhAN1mVwOPGj5X1t+BKLtcnTeY/+bvz/fyge/01hXs34ReEvqXFwv+jZs6df+uzZsy/7 + oJ9+Kf//1POX7Dzntdh5w+Tx/C8L7qtjw//Djx8/+rsfvL6Mfv07yPvj4SqxT2i/OHX/2AhO/JB5TWIQ + DdZlcDjxI+b95Ast1mo7z3ktdp7zWnxDeZ8fXhT7hPaLHvvH8HlNYhAN1mVwOPFD5r3lLW9+FgvqH1Us + ripfcPFX2XnOa7HznNfiC+b9/fDj8FGxT2i/6LJ/wIkfMg8FW/fXfwyiwboMDid+6Lxnz56958yLtcrO + c16Lnee8Ft9Y3heHj6pc78Nd9w/ljJhXbv2/zPOkMHcU6jX41Uz2x37sd/mYWFz//IoX/6Kd57wWO895 + Lb5w3j8Jvyk8q93r/Y6H3I92fEoemz93/F1uAHhCmHsJ7x7ASMWsnvf06dNffaWLf9HOc16Lnee8Fg+Q + 90vCs5q63uvft7q/sfmX7/s53gDoyXyLEL/9l4MYqZiz5D1//vz1ePgbw1MLbNYDLP6jdp7zWuw857V4 + gLx/HH4lPKm4tl/lfhTO5rGf8y2/fNtvaQCmPwPAA2G+P5jf/ksDMFIx585b/H6AXQ+w+I/aec5rsfOc + 1+JB8n52eFJc13V9n7veNwlO/Mh57Od42wDo4X3FA6VTeB4uDUDdtwpNCC48+uQs5T0K/7Xw1ELb8yCL + f9bOc16Lnee8Fg+S95fDk/sB13Vd349d76sFJ37kPF7JZz8vDQD72aHigfIeAU8sDcDy9wnPCC48+uTU + 5vE1l9xRamrBbTzI4p+185zXYuc5r8WD5H17ePJr07mu6/pec71fFJz4kfPKHl4aAPb32Zf++XQgHUJp + AOgcbnlyWvO47/7Uohtl8c/aec5rsfOc1+KB8n5r+EBc13V9b7nezwpO/Mh55dX70gDwyv7s5s+HAugO + SgOAb3lyMnmvhf9eeG/RDbT4J+0857XYec5rMRz8B+fuYnl/J/xqeE9c13V9b73eTwpO/Oh5uDQA7OdH + P/S32wDMdwoLCu7WJ/uHhnmZabOAWZQszgEW/6Sd57wWO895LR4oj28l/EHhPXFd1/U9e73fE5z4a8jj + vzQAvJI/v5/Hg0ClAZh/j2BBylmrmJHy3giPtPgn7Tzntdh5zmvxYHl86dmeuK7r+n7q9X4jOPHXksf/ + Xv4MH08I0wDwGQBv/st6IRblHx1o8R/Yec5rsfOc1+LB8v6b8N6+xXVd1/ce1/trzav76z2eFJ6/McCC + xF/b5JyU9zEf852+8+PHj/7OAIv/wM5zXoud57wWD5b3N8N8Nmsrrs+6vne73ou/zbx4YmrjRwyiwXKD + PxCc+OHz3v72t31SLNZ/ckM/TAd2nvNa7DzntfjEPO7297HhrXavzzsecv/Y8TB5TWIQDdZlcDjxV5P3 + 6quv/ohYrN8SD08t0KMe7IfpwM5zXoud57wWn5j3zeFPDW81dX3Wv+9mP9K/U3lNYhAN1mVwOPHXmPfZ + 4feHpxbqpAf7YTqw85zXYuc5r8Un5r0v/MPDW3Ed1vV46vrcLDjxd5HXJAbRYF0GhxN/zXmfF65qAgb7 + YTqw85zXYuc5r8Un5rH5f054K67Duh4fuz5XC078XeQ1iUE0WJfB4cTfQh6vBBx9O2CwH6YDO895LXae + 81p8Yh4v+39meCuuw7oe11yfFwUn/i7ymsQgGqzL4HDibynvh4Qnvz54sB+mAzvPeS12nvNafGLee8N7 + N/rhOqzrccv1eVZw4u8ir0kMosG6DA4n/hbzvkf4b4e3C3iwH6YDO895LXae81p8Yt7fCn/X8FZch3U9 + zlyfDwQn/i7yULB1f/3HIBqsy+Bw4m857y3hPxoe7YfpwM5zXoud57wWn5j3h8Ovh7fiOqzr8SnX563g + xN9LXrn1/zLPk8LcUajX4Pc02dwx8CtisX97cvEf+MQfpgM7z3ktdp7zWnxC3reFf3nYd/jrm8fmzx1/ + lxsAnhDmXsK7BzBSMVeR96Y3vfqjHz9+9A8u+MM0aec5r8XOc16LT8jjG1ffFd5TuZ6Gu16flXMPeWz+ + 5ft+jjcAejLfIsRv/+UgRirmqvI+9mO/y8c8efL4d9/AD+eknee8FjvPeRP+jvBvD78pvKeH11N52Ou9 + PFIe+znf8su3/ZYGYPozADwQ5vuD+e2/NAAjFXPNeZ8e/hvhqR+ASQ/ywzlr5zmvxc5z3oT/WpivWj8Q + 101dP6eup82CE39PeezneNsA6OF9xQOlU3geLg1A3bcKTQguPPrknDvvUfjnhf9peOqHYWt+aPjh+eCF + 4yZ+2GftPOe12HlXn/dPwl8YntyQuG7q+nnselotOPH3lMcr+eznpQFg/zlUPFDeI+CJpQFY/j7hGcGF + R5+cS+bx6dZfEf4X4YMfjgF+OI/aec5rsfOct+P/N8yH/A5e7i/iuqnrZ+319KjgxN9TXtnDSwPA/j77 + 0j+fDqRDKA0AnYMnu0Jw4jN5/Mngl4W/Ibz5AbnwD+einee8FjvPefLXh39p+M3hWXHd1PUzcz09EJz4 + e8orr96XBoBX9mc3fz4UQHdQGgDsya4QnPhT856Gf2r80PyZC/1wVtl5zmux85wX/lPhnxLmGndUXDd1 + /Tz1eroRnPh7y8OlAWA/P/qhv90GYL5TWFBwPnkd8t72trd+8rNnT3/N48eP/+YV/rBX23nOa7HzriqP + D/Z9efi7h6tUrn/hrtdT5dxbHv+lAeCV/Pn9PB4EKg3A/HsEC1LOWsXcbV78QL0zHv4F4T8e/pfhgx/E + KZ/5h73ZznNei503fN63xC8sfyL+f65VHxduUlzrfL3vm8f/Xv4MH08I0wDwGQBv/hWCE3/uPD7B+QPC + XxT+T8L/W/ibwks/nJt/d/xhd16Dnee8Fl9B3jc9fvzoLz158uT3PH/+7D9+/fXX3v0DfsAnvXnielUl + OF3vlq5/VYITf895dX+9x5PC8zcGWJD4a5ucW8t7W5jG4PPih/NnPnv29EvDv/rp06dfGf7N8YP6m+P/ + /6p4/De0Gg4+cn5LsfPq7TzntXiQvK8Mf0X4l4W/JPwzwp8b/uTg367r0ynXq63gxDsvITjxubx4Ymrj + RwyiwXKDPxCceOclBCfeeQnBiXdeQnDinZcQnHjnJQQn3nlri0E0WJfB4cQ7LyE48c5LCE688xKCE++8 + hODEOy8hOPHOW1sMosG6DA4n3nkJwYl3XkJw4p2XEJx45yUEJ955CcGJd97aYhAN1mVwOPHOSwhOvPMS + ghPvvITgxDsvITjxzksITrzz1haDaLAug8OJd15CcOKdlxCceOclBCfeeQnBiXdeQnDinbe2GESDdRkc + TrzzEoIT77yE4MQ7LyE48c5LCE688xKCE++8tcUgGqzL4HDinZcQnHjnJQQn3nkJwYl3XkJw4p2XEJx4 + 5yUVbN1f/zGIBusyOJx45yUEJ955CcGJd15CcOKdlxCceOclBBeGJ6fYeZUKrtz6f5nnSWHuKNRrcJ88 + 51ULTrzzEoIT77yE4MQ7LyE48c5LCE58rzw2f+74u9wA8IQw9xLePYCRinGe86oFJ955CcGJd15CcOKd + lxCceOclFBybf/m+n+MNgJ7Mtwjx2385iJGKcZ7zqgUn3nkJwYl3XkJw4p2XEJx45yUUHPs53/LLt/2W + BmD6MwA8EOb7g/ntvzQAIxXjPOdVC0688xKCE++8hODEOy8hOPHOSwguzH6Otw2AHt5XPFA6hefh0gDU + favQhODCo0+O85xXJTjxzksITrzzEoIT77yE4MTfUx6v5LOflwaAb5Q9VDxQ3iPgiaUBWP4+4RnBhUef + HOc5r0pw4p2XEJx45yUEJ955CcGJv6e8soeXBoD9ffalfz4dSIdQGgA6B092heDEOy8hOPHOSwhOvPMS + ghPvvITgxDsvITjxPfPKq/elAeCV/dnNnw8F0B2UBgB7sisEJ955CcGJd15CcOKdlxCceOclBCfeeQnB + ie+dh0sDwH5+9EN/uw3AfKewoOB88pxXLTjxzksITrzzEoIT77yE4MQ7LyE48Wvk8V8aAF7Jn9/P40Gg + 0gDMv0ewIOWsVYzzGgUn3nkJwYl3XkJw4p2XEJx45yUEJ/5e8/jfy5/h4wlhGgA+A+DNv0Jw4p2XEJx4 + 5yUEJ955CcGJd15CcOKdlxCc+DXz6v56jyeF528MsCDx1zY5zqsUnHjnJQQn3nkJwYl3XkJw4p2XEJz4 + 28yLJ6Y2fsQgGiw3+APBiXdeQnDinZcQnHjnJQQn3nkJwYl3XkJw4p23thhEg3UZHE688xKCE++8hODE + Oy8hOPHOSwhOvPMSghPvvLXFIBqsy+Bw4p2XEJx45yUEJ955CcGJd15CcOKdlxCceOetLQbRYF0GhxPv + vITgxDsvITjxzksITrzzEoIT77yE4MLw5BQ7bw0xiAbrMjiceOclBCfeeQnBiXdeQnDinZcQnHjnJQQn + 3nlri0E0WJfB4cQ7LyE48c5LCE688xKCE++8hODEOy8hOPHOW1sMosG6DA4n3nkJwYl3XkJw4p2XEJx4 + 5yUEJ955CcGJd15Swdb99R+DaLAug8OJd15CcOKdlxCceOclBCfeeQnBiXdeQnDinZdQcOXW/8s8Twpz + R6Feg/vkOa9acOKdlxCceOclBCfeeQnBiXdeQnDie+Wx+XPH3+UGgCeEuZfw7gGMVIzznFctOPHOSwhO + vPMSghPvvITgxDsvoeDY/Mv3/RxvAPRkvkWI3/7LQYxUjPOcVy048c5LCE688xKCE++8hODEOy+h4NjP + +ZZfvu23NADTnwHggTDfH8xv/6UBGKkY5zmvWnDinZcQnHjnJQQn3nkJwYl3XkJwYfZzvG0A9PC+4oHS + KTwPlwag7luFJgQXHn1ynOe8KsGJd15CcOKdlxCceOclBCf+nvJ4JZ/9vDQAj/TwvuKB8h4BTywNwPL3 + Cc8ILjz65DjPeVWCE++8hODEOy8hOPHOSwhO/D3llT28NADs77Mv/fPpQDqE0gDQOXiyKwQn3nkJwYl3 + XkJw4p2XEJx45yUEJ955CcGJ75lXXr0vDQCv7M9u/nwogO6gNADYk10hOPHOSwhOvPMSghPvvITgxDsv + ITjxzksITnzvPFwaAPbzox/6220A5juFBQXnk+e8asGJd15CcOKdlxCceOclBCfeeQnBiV8jj//SAPBK + /vx+Hg8ClQZg/j2CBSlnrWKc1yg48c5LCE688xKCE++8hODEOy8hOPH3msf/Xv4MH08I0wDwGQBv/hWC + E++8hODEOy8hOPHOSwhOvPMSghPvvITgxK+ZV/fXezwpPH9jgAWJv7bJcV6l4MQ7LyE48c5LCE688xKC + C8OTU+y8SsGFb3f+4ompjR8xiAbLDf5AcOKdlxCceOclBCfeeQnBiXdeQnDinZcQnHjnrS0G0WBdBocT + 77yE4MQ7LyE48c5LCE688xKCE++8hODEO29tMYgG6zI4nHjnJQQn3nkJwYl3XkJw4p2XEJx45yUEJ955 + a4tBNFiXweHEOy8hOPHOSwhOvPMSghPvvITgxDsvITjxzltbDKLBugwOJ955CcGJd15CcOKdlxCceOcl + BCfeeQnBiXfe2mIQDdZlcDjxzksITrzzEoIT77yE4MQ7LyE48c5LCE6889YWg2iwLoPDiXdeQnDinZcQ + nHjnJQQn3nkJwYl3XkJw4p2XVLB1f/3HIBqsy+Bw4p2XEJx45yUEJ955CcGJd15CcOKdlxCceOclFFy5 + 9f8yz5PC3FGo1+A+ec6rFpx45yUEJ955CcGJd15CcOKdlxCc+F55bP7c8Xe5AeAJYe4lvHsAIxXjPOdV + C0688xKCE++8hODEOy8hOPHOSyg4Nv/yfT/HGwA9mW8R4rf/chAjFeM851ULTrzzEoIT77yE4MQ7LyE4 + 8c5LKDj2c77ll2/7LQ3A9GcAeCDM9wfz239pAEYqxnnOqxaceOclBCfeeQnBiXdeQnDinZcQXJj9HG8b + AD28r3igdArPw6UBqPtWoQnBhUefHOc5r0pw4p2XEJx45yUEJ955CcGJv6c8XslnPy8NwCM9vK94oLxH + wBNLA7D8fcIzgguPPjnOc16V4MQ7LyE48c5LCE688xKCE39PeWUPLw0A+/vsS/98OpAOoTQAdA6e7ArB + iXdeQnDinZcQnHjnJQQn3nkJwYl3XkJw4nvmlVfvSwPAK/uzmz8fCqA7KA0A9mRXCE688xKCE++8hODE + Oy8hOPHOSwguDE9OsfMqBRdeY/5waQDYz49+6G+3AZjvFBYUnE+e86oFJ955CcGJd15CcOKdlxCceOcl + BCd+jTz+SwPAK/nz+3k8CFQagPn3CBaknLWKcV6j4MQ7LyE48c5LCE688xKCE++8hODE32se/3v5M3w8 + IUwDwGcAvPlXCE688xKCE++8hODEOy8hOPHOSwhOvPMSghO/Zl7dX+/xpPD8jQEWJP7aJsd5lYIT77yE + 4MQ7LyE48c5LCE688xKCE3+befHE1MaPGESD5QZ/IDjxzksITrzzEoIT77yE4MQ7LyE48c5LCE6889YW + g2iwLoPDiXdeQnDinZcQnHjnJQQn3nkJwYl3XkJw4p23thhEg3UZHE688xKCE++8hODEOy8hOPHOSwhO + vPMSghPvvLXFIGE+YMCAxXUfOJgQnHjnJQQn3nkJwYl3XkJw4p2XEJx45yUEJ955a4tBwvxpAQMWL/+p + wYzgxDsvITjxzksITrzzEoIT77yE4MQ7LyE48c5bWwwS5qYCDFh86u2Cnee8KsGJd15CcOKdlxCceOcl + BCfeeQnBie+S16QYpHxFMPcULp6/veCC4MQ7LyE48c5LCE688xKCE++8hODEOy8hOPHOS6qa5Ylhbg/M + gMWn3C7Yec6rFpx45yUEJ955CcGJd15CcOKdlxCc+J553Pdn+ZUDPbl8R0DxKbcLdp7zqgUn3nkJwYl3 + XkJw4p2XEJx45yUEJ75nHnf8XW4Adp7MgMWn3C7Yec6rFpx45yUEJ955CcGJd15CcOKdlxCc+DXyqhoA + nrRnPZSS85zXIuc5r0XOc16LnHekkeDBMJ86LE51HUXOc16LnOe8FjnPeS2CD5NTfId5H/Ih/z+wibca + ybhi0AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAg95JREFUeF7t + vQmYJNld3avOrMqurKqu6ume7ume6dkXjUbSjNYZaRZNM8wny4BZjAFjFrHbMjKyDDIfNs9PvGeEbPwQ + PDBGNoYnBNhPFmCBDeiJHSQwMiBkIZBBWEhiFdq3Gc3C+5/oE9m53Ii495+RmTczzvm+80k9mb8TFf97 + I+6/KiMjHiNJkiRJkpSs++8/3582X3JJecpLkfKUlyLlKS9FXcuLlm3oiHnbPBgz/n2Eb0kSOPLKcwgc + eeU5BI688hwCR155DoEjrzyHwJFX3qKFjZh3zMMx49/z7IzylBclcOSV5xA48spzCBx55TkEjrzyHAJH + vpW8JNlGeuY98/6Y8e8e35IkcOSV5xA48spzCBx55TkEjrzyHAJHXnkOgSOvvEULGzEfmA/HjH/PszPK + U16UwJFXnkPgyCvPIXDklecQOPLKcwgc+VbykmQbwQUGx80nxox/uy46AEdeeQ6BI688h8CRV55D4Mgr + zyFw5JXnEDjyynPIOHyMEMfijeaT5lNjxr/n2RnlKS9K4MgrzyFw5JXnEDjyynMIHHnlOQSOfFt5WPxx + wWAzjzeZT5vPjBn/nmdnlKe8KIEjrzyHwJFXnkPgyCvPIXDklecQOPJt5eFjBFwwiG8N1GfgDWZs7NyY + z5q3+JYkgSOvPIfAkVeeQ+DIK88hcOSV5xA48spzCBx55TlkHBZ/XDCIbw3UNwB40Yw/M6DjwIavNl9h + nmdnwCOntPIiBY688hwCR155DoEjrzyHwJFXnkPgyCvPIeOwnuOCQXxroL4BsBfQKeACA3zWUDYAm1wc + 5SkvWuDIK88hcOSV5xA48spzCBz5ruRh8cd6jm8NlA3ANl+elL1QftUAVxmWDcC8f8bIuTjKU160wJFX + nkPgyCvPIXDklecQOPJdySv/ko/1vGwAwjcNwn804zMCvLFsAHANgIodIXDklecQOPLKcwgceeU5BI68 + 8hwCR155DoEj32Ye1m+s42UDgPW9cvFHZ4AOoWwA5vmqgQZPedECR155DoEjrzyHwJFXnkPgyCvPIXDk + 28zDX+7xF/yyAai+aZC9gO8F4rOBsgGY5yYDGjzlRQsceeU5BI688hwCR155DoEjrzyHwJnBI6d0G3m4 + dq9sALCeVy7++JwAVwWWDQA6BS3+EQJHXnkOgSOvPIfAkVeeQ+DIK88hcOSV5xA48ovIKxuA+r/k40Vz + 2QC4HyxgnAZPedECR155DoEjrzyHwJFXnkPgyCvPIXDkF5WHBqD5pkF4gxkNAK4B0OIfIXDklecQOPLK + cwgceeU5BI688hwCR155DoEjv8g8XAPQ/Jd8vMmMawC8zydWsZUXLXDklecQOPLKcwgceeU5BI688hwC + Rz6PPHsjGgAt/hECR155DoEjrzyHwJFXnkPgyCvPIXDklecQOPJZ5iUJG+HGWtk4OPLKcwgceeU5BI68 + 8hwCR155DoEjrzyHwJFX3qKFjXBjrWwcHHnlOQSOvPIcAkdeeQ6BI688h8CRV55D4Mgrb9HCRrixVjYO + jrzyHAJHXnkOgSOvPIfAkVeeQ+DIK88hcOSVt2hhI9xYKxsHR155DoEjrzyHwJFXnkPgyCvPIXDklecQ + OPLKW7SwEW6slY2DI688h8CRV55D4MgrzyFw5JXnEDjyynMIHHnlLVrYCDfWysbBkVeeQ+DIK88hcOSV + 5xA48spzCBx55TkEjrzyHDIOz/6Ju9svNsKNtbVx5SkvWuDIK88hcOSV5xA48spzCBx55TkEjnxbeVj8 + cd+f6JsE4Y5CbW1cg6e8aIEjrzyHwJFXnkPgyCvPIXDklecQOPJt5fXMuOMv7vwbdYtg3EsY9xTOcWeU + p7xogSOvPIfAkVeeQ+DIK88hcOSV55BxWPzxrB8886e+AcCLZjxFCE8TKhuATS6O8pQXLXDklecQOPLK + cwgceeU5BI58V/KwnuMpv3jab30DYC+gU8Dzg/Ec4bIB2OTiKE950QJHXnkOgSOvPIfAkVeeQ+DIdyUP + iz/W80Nz2QBsoxYzshew+KNTOGEuGwBcA6BiRwgceeU5BI688hwCR155DoEjrzyHwJFXnkPgyLeVV/4l + H+t52QDgGoDZZ//gP5rxGQHeWDYAuAZAxY4QOPLKcwgceeU5BI688hwCR155DoEjrzyHwJFvMw/rN9bx + sgHA+l65+KMzQIdQNgDoHOK+Kzgl4zR4yosWOPLKcwgceeU5BI688hwCR155DoEj32Ye/nKPv+CXDQD+ + st/jWyZlL+B7gfhsoGwA8JmBFv8IgSOvPIfAkVeeQ+DIK88hcOSV5xA48spzCBz5tvNw7V7ZAGA9r1z8 + 8TkBrgosGwB0Clr8IwSOvPIcAkdeeQ6BI688h8CRV55D4MgrzyFw5BeRVzYA9X/Jx4vmsgHAZwThTqFB + xmnwlBctcOSV5xA48spzCBx55TkEjrzyHAJHflF5aABwDUD9L/N4gxkNAK4B0OIfIXDklecQOPLKcwgc + eeU5BI688hwCR155DoEjv8g8XAPQ/Jd8vMmMawBmrw6MkHEqtvKiBY688hwCR155DoEjrzyHwJFXnkPg + yOeRZ29EA6DFP0LgyCvPIXDklecQOPLKcwgceeU5BI688hwCRz7LvCRhI9xYKxsHR155DoEjrzyHwJFX + nkPgyCvPIXDklecQOPLKW7SwEW6slY2DI688h8CRV55D4MgrzyFw5JXnEDjyynMIHHnlLVrYCDfWysbB + kVeeQ+DIK88hcOSV5xA48spzCBx55TkEjrzyFi1shBtrZePgyCvPIXDklecQOPLKcwgceeU5BI688hwC + R155ixY2wo21snFw5JXnEDjyynMIHHnlOQSOvPIcAkdeeQ6BI6+8RQsb4cZa2Tg48spzCBx55TkEjrzy + HAJHXnkOgSOvPIfAkVeeQ8bh2T9xd/vFRrixtjauPOVFCxx55TkEjrzyHAJHXnkOgSOvPIfAmcEjp/Q8 + eVj8cd+f6JsE4Y5CbW1cg6e8aIEjrzyHwJFXnkPgyC8j73bzK8y/Y36v+d3mN5r/lflO88xdWsGRD+Ul + Cxx55TkEjnyueT0z7viLO/9G3SIY9xLGPYVz3BnlKS9a4MgrzyFw5JXnEDjyobyvND9s/qsaozH4O+bi + xA2OfCgvWeDIK88hcORzzcPij2f94Jk/9Q0AXjTjKUJ4mlDZAGxycZSnvGiBI688h8CRV95jHvMUc9Pi + P+63bG9v30M+lJcscOSV5xA48rnmYT3HU37xtN/6BsBeQKeA5wfjOcJlA7DJxVGe8qIFjrzyHAJHXnkX + 9DpzaKEP+siRI3919OjRR44d2//+pz71SY8L5CUJHPmqny9J4MgrzyFw5NvKw+KP9fzQXDYA23x5UvYC + Fn90CifMZQOAawBU7AiBI688h8CRV55D4MgrzyFw5JeVd4X5EXNwsZ82F/+/2tnZKTwcDt999uxlnzaW + lyRw/Hmqfr4kgSOvPIfAkW8rr/xLPtbzsgHANQCzz/7BfzTjMwK8sWwAcA2Aih0hcOSV5xA48spzCBx5 + 5TkEjvwy877MHFzspz29+MP4t/33j9jrX2hOEn4O/jx1P1+0wJFXnkPgyLeZh/Ub63jZAGB9r1z80Rmg + QygbAHQOzV8VCMg4DZ7yogWOvPIcAkdeeQ6BI7/svO80Bxf8cdcs/uPve6V5z9wo/Bz8eZp+viiBI688 + h8CRbzMPf7nHX/DLBgB/2Z/5JkkhewHfC8RnA2UDgM8MtPhHCBx55TkEjrzyHAJHXnkOgSO/iryfNY8v + 4jOOXPxL/4b5OnOl8HPw54n5+RoFjrzyHAJHvu08XLtXNgBYzysXf3xOgKsCywYAnYIW/wiBI688h8CR + V55D4MgrzyFw5FeVh6/2hRbywomLf+kPmz/fPCP8HPx5Yn++WoEjrzyHwJFfRF7ZANT/JR8vmssGAJ8R + hDuFBhmnwVNetMCRV55D4MgrzyFw5FeZ9x5zaBH3Lv7jfrn5qLkQfg7+PCk/X6XAkVeeQ+DILyoPDQCu + Aaj/ZR5vMKMBwDUAWvwjBI688hwCR155DoEjrzyHwJFfdd4D5pnFu4XFv/SvmIufgz9P6s8XFDjyynMI + HPlF5uEagOa/5ONNZlwDMHt1YISMU7GVFy1w5JXnEDjyynMIHPkc8ma+Atji4l/YuA+eOHHJVzp/vhmB + I688h8CRzyPP3ogGQIt/hMCRV55D4MgrzyFw5JXnEDjyOeThPdOLdduLf5n3yOHhwbedP3/PNQk/34zA + kffs74zAkVeeQ+DIt5KXJGyEG2tl4+DIK88hcOSV5xA48spzCBx55cVpYA4t1m0v/iMPh8Nf290dXmWv + Jwv7xf3z7u+EwJFXnkPgyLeSlyRshBtrZePgyCvPIXDklecQOPLKcwgceeXFa9QALGPxH8v7C/OzzdHC + fnH/5tnfkcCRV55D4Mi3kpckbIQba2Xj4MgrzyFw5JXnEDjyynMIHHnlpaloAJa8+JfGw4debG686Bv7 + xf2bd38LgSOvPIfAmcEjp7Q7L0nYCDfWysbBkVeeQ+DIK88hcOSV5xA48spL12BFi/+4f8x83BwU9ov7 + 18b+Ki+zvCRhI9xYKxsHR155DoEjrzyHwJFXnkPgyCvPoSuvvGJ3xYt/6XeZ7zJPCPvF/Wtlf8GRV55D + 4Mi3kpckbIQba2Xj4MgrzyFw5JXnEDjyynMIHHnlOQTumc+8/VrHYh30HIt/6YfMo48E8PNx/1rbX/LK + cwgc+bby8OyfuLv9YiPcWFsbV57yogWOvPIcAkdeeQ6BI99q3p133nFDJov/uH/i2LFjuHtc9vVjjvIS + ZRwWf9z3J/omQbijUFsb1+ApL1rgyCvPIXDklecQOPKt55UNQEaLf8FZxh9ffvmZz8LPSGdZvzErL1LG + 9cy44y/u/Bt1i2B0g7incI47ozzlRQsceeU5BI688hwCR77IQgOQ2+I/lvfQ4eHBt9x337Nw7tf4Rggc + +VzzsPjjWT945k99A4AXzXiKEJ4mVDYAm1wc5SkvWuDIK88hcOQ7m4drADJd/Ed5vV7vNfb6JeYkhfaX + /9Z8iRA48m3lYT3HU37xtN/6BsBeQKeA5wfjOcJlA7DJxVGe8qIFjrzyHAJHvtN5+BaAvRxckOu8rMV/ + LO8d5jvMUbJ90/jmlYfFH+v5oblsALb58qTsBSz+6BROmMsGANcAqNgRAkdeeQ6BI688h8CRV55D4Mgv + I2/iVsAxXsHiXxpPLXyBuVbYL+5faH+TBY688hwyrvxLPtbzsgHANQCzz/7BfzTjMwK8sWwAcA2Aih0h + cOSV5xA48spzCBx55TkEjvyy8pIagBUu/uP+UfOheUbYL+5f1f4mCRx55TkEzoz1G+t42QBgfa9c/NEZ + oEMoGwB0DnHfFZyScRo85UULHHnlOQSOvPIcAkd+mXnRDUAmi3/pt5lvM4+E/eL+1e1vtMCRV55D4Mz4 + yz3+gl82APjLfvjWz/YCvheIzwbKBgCfGWjxjxA48spzCBx55TkEjrzyHAJHftl5UQ1AZot/6Y+bi48E + sF/cv6b9jRI48spzCBx5XLtXNgBYzysXf3xOgKsCywYAnYIW/wiBI688h8CRV55D4MgrzyFw5FeR19gA + ZLr4j9zr9X7oKU+57cbI/W0UOPLKcwgceeSUDUD9X/LxorlsAPAZQeMTokIyToOnvGiBI688h8CRV55D + 4MivKq+2Ach98S/zhsPhH1x11blnR+xvrcCRj61frcCR72oeGgBcA1D/yzzeYEYDgGsAtPhHCBx55TkE + jrzyHAJHXnkOgSO/yrzKBmBdFv+xvI8fP374oob9rRQ41iulfpUCR77LebgGoPkv+XiTGdcAzF4dGCHj + VGzlRQsceeU5BI688hwCR37VecEGYA0X//G8HzDj/gbRQp1Yr9T6BQWOvPJiZG9EA6DFP0LgyCvPIXDk + lecQOPLKcwgc+RzyZhqAJS/WyY7Me6v58eZGoU6sl6d+MwJHXnmLFjbCjbWycXDklecQOPLKcwgceeU5 + BI688uI00QCsaLGOdmLeh8yfb64U6sR6ees3IXDklbdoYSPcWCsbB0deeQ6BI688h8CRV55D4MgrL16j + BmDFi3Wj58jDRwJD84RQJ9ZrnvqNBI688hYtbIQba2Xj4MgrzyFw5JXnEDjyynMIHHnlpaloADJarINu + Ie83zTeYC6FOrNe89SsEjrzyFi1shBtrZePgyCvPIXDklecQOPLKcwgceeWla5DhYj3hFvM+aP5c1In1 + aqN+mn9z5iUJG+HGWtk4OPLKcwgceeU5BI688hwCR155DuFpgJku1oUXkbe3t/eDd955xw1t1A8c+VbG + Axz5TuQlCRvhxlrZODjyynMIHHnlOQSOvPIcAkdeeQ6Be+Yzb7+2zcU198W/zNvdHb75uuuuuWfe+pFv + bTzIdyUPz/6Ju9svNsKNtbVx5SkvWuDIK88hcOSV5xA48q3m4TfhthfXdcnb2Tn6oX6//7n2erLK+plb + HQ/mdCEPiz/u+xN9kyDcUaitjWvwlBctcOSV5xA48spzCBz51vPKBiD3xXqBeY+av8O8bY7SeP3GnOX4 + jjmnvJ4Zd/zFnX+jbhGMewnjnsI57ozylBctcOSV5xA48spzCBz5IgsNwBot1slOyPt18zXmWk3Xj852 + fOmc8rD441k/eOZPfQOAF814ihCeJlQ2AJtcHOUpL1rgyCvPIXDkO5uHawDWcLGOsiPvPea/bg4qVD/+ + W/MvQsZhPcdTfvG03/oGwF5Ap4DnB+M5wmUDsMnFUZ7yogWOvPIcAke+03n4FoC9HFoMa53BYl3rOfKC + HwlYrTRf5svD4o/1/NBcNgDhj13sBSz+6BROmMsGANcAqNgRAkdeeQ6BI688h8CRV55D4MgvIy/4MKA6 + Z7RYB91S3i+aLzdrvsyfV/4lH+t52QDgGoDZZ//gP5rxGQHeWDYAuAZAxY4QOPLKcwgceeU5BI688hwC + R35ZeUkNQKaL9cgt571re3vrXtarqn5JAke+S3lYv7GOlw0A1vfKxR+dATqEsgFA5xD3XcEpGdfFYitP + eVECR155DoEjv8550Q1A5ov1ovIePTg49t333nvXtRX1ixY48nXjES1w5HPOw1/u8Rf8sgHAX/Z7fMuk + 7AV8LxCfDZQNAD4z0OIfIXDklecQOPLKcwgceeU5BI78svOiGoA1WawXlre3t/uGm2664cmB+kUJHOvf + NB5RAkc+9zxcu1c2AFjPKxd/fE6AqwLLBgCdwiYs/qfM95u/0vx/mn+g1zvyuuFw57eGw+Hb7X//wvyB + nZ2jH7BJ9wF7fWZyN3ndDqYO5+Fe5LjS+LfMP2z+UvNxc60wzzjfPPNvRuDIK88hcOQ3Ie+oOTiPSy/x + +Ai+v8lLzHuHvX67OUmoO+sfMx6NAkd+HfLKBqD+L/l40Vw2APiMINwpNMi4VRbnCvNnmP+5+afNf2KO + nVwT74u18tY+72Pm7zKfMc8I84zzLWb+NQoceeU5BI78puRdaQ7Ny8IZHB+1XkHeQ+YXm6PWJ9Sd9Y8d + j1qBI78ueWgAcA1A/S/zeIMZDQCuAViXxf+Y+TPN/9r8++aJyTTtFUzWJCtvpXnvNX+OeSTMM863qvmX + JHDklecQOPKblPdsc2g+5nZ8zHjFef/JfGCuFOrO+qeMR6XAkV+nPFwD0PyXfLzJjGsAZq8OjJBxSynO + 7u7wanv5+ebXmh8whybHjFc8WRutvCzy8B1k/HaxtPlsVl6EwJHftLzvNc/MxUyPj5EzycMvfU8yzwh1 + Z/1TxyMocOQ3M8/eiAYgy8X/jjuedtMllxx/fq93BIv+w+bQZKh0JpO10srLK6/f733d+PyjW5vPtPIi + BY78puXhl5mPmyfmX+7HR2Z5+Ejg682jtQt1Z/1TxyMocOQ7kZckbIQba2Xj4MhffeON1z0TXwHZ2Tn6 + vg2ZrDNWXpZ5D507d/mnYg7SrcznMSsvUuDIb2LeD5lD86/t+dyFvB804+J1zb858pKEjXBjrWwcHPir + rjr37P39vR+3yfDwhk7WwsrLN293d/eNbc1n5rR2fDBHeYkCRz6HvC8wV86/tudzR/J+99y5K+5zjseM + wJHvRF6SsBFurJWNg7viisvv39vbe61NhEcznFzK61jeZZed+pvzzGceD60dH+SV5xA48jnk3W2e+NP/ + Oh4fmeY9ePz44YsTx2NG4Mh7xndG4MhnmZckbIQba2Xjw+Hwmr293f/XBu+RlidD25NLeYH3N3ld83q9 + Hi7QShaOAx4PrRwf4MgrzyFw5HPIe6L5L8yN8y/34yPnPPtF8j+cPn0K3xJLFsaR4+kZ3xmBI59lXpKw + EW6sjY0P7ST7TTs7Rz8+Pni5Ty7lxXvN8/7QnCQcBzwe2jg+lLdZec804+umsfMv2cqbyPtt803maGEc + OZ6e8Z0ROPJZ5iUJG+HG2tj4p9sgvWOJkyHZyut8Hr4WGP1bBI4DHg9tHB/K26w8XKmOK9ZT5l+SlRfM + w0ctuAtsozCOHE/P+M4IHPlc8/Dsn7i7/WIj3Ni8G8etV39gRZMh2spTHn2zuVE4Dng8zHt8FAJHXnkO + gSO/6jzc6/+7zRPzaoXzOcobmIe7feK2y0FhHDmeqeMbFDjyueZh8cd9f6JvEoQ7Cs278U8yvzODyVBr + 5SlvzE8x1wrHAY+HeY+PQuDIK88hcORXnYf71r/ZPDGnVjyfG73BeW80X2ueEMaR45k6vkGBI59rXs+M + O/7izr9RtwjGvYRxT2HvxtEFf4f50YwmQ9DKU96Uaz9DxHHA46Gtg1N56503NH+W+T+b8RHSxHzKYD7X + ugN57zN/urkQxpHjGTu+tQJHPtc8LP541g+e+VPfAOBFM54ihKcJlQ1A6sbxNL6fN+c4GSasPOVNufYa + ABwHPB7aOjiVt355++Znmb/W/KPmj5pDcymH+VzrDuXhuP7WG264Dr8FL3u+RAsc+bbysJ7jKb+4YVJ9 + A2AvoFPA84PxHOGyAUjd+K3m/2XOeTIUVp7yAn6nOSgcBzwe2jo4lZd53lOf+qQbtra2/pq9jOdF/IR5 + 5mmjVc5kPle6i3nD4c6br7vumnvGxjjr+cd/e/Ow+GM9PzSXDcA2X56UvYDFH53CCXPZAOAagJSNf4r5 + w+ZOTi7lbUTej5lnhOPAnPPBrrwW8p74xFtuPXXq0q84duzY9w6Hw9+w+TJz3/4YZzSfg+5ynjUB773s + slNf0MZ8Mbc6/5jTRl75l3ys52UDgL9+zD77B//RjM8I8MayAcA1ACkbx9cuiof2rNNkUF6YqfOG5+Gr + WxPCcWDO+WBXnj/vmn6//7y9vd1X24L/RxnMvxkrbyF5j/Z6ve+018O/EdcI84zzrY35t6g8rN9Yx8sG + AOt75eKPzgAdQtkAoHOI+67gBX21+RHzuk4G5UW6A3n3mUey42AdDnblxeddZv5c8782v8XmxaOZzb8J + K2/hea8znzZHCfOM8807/yYEjnybefjLPf6CXzYA+Mt+j2+ZlL2A7wXis4GyAcBnBimL/zeaY4udZOUp + L8Ut5OEvWKMLAO04WIeDXXn1ebgHyeeYX25+u3k03hnOvwkrb2l57zHjOo9aYZ5xvqXMv0qBI992Hq7d + KxsArOeViz8+J8BVgWUDgE4hZfF/oTm12FFWnvJS3FLe75gL2XGwLge78maFe+9/nfm15o+ZZ8Y60/k3 + svKWnoc7Nr7IPPtnchPmGedbzPxrFDjyi8grG4D6v+TjRXPZAOAzgnCnENbzzUXxMhi8WitPeZH+9+Z1 + O9iVd+GvNvgt/wfMEw/dCTnj+VdYeSvN+znzGfNImGecb1XzL0ngyC8qDw0ArgGo/2UebzCjAcA1ACmL + /98064I/5SU787y/a8fBuh3sncw7duwYPrf9QvOrzB80h8ZzxpnPP+XlkYevsT/NvK7HB64BaP5LPt5k + xjUAwT97VAjf89dX/ZSX7Nzztre3n27Hwrod7J3Ju+mmG24/PDz4Zza+r7eXi4uOU5z7/FNeVnkP9Xq9 + /+P8+buvLOcfne3xQcfn2RvRAKQs/leYixthZD54ylNeko376N13P3P8QEo7mKYEjrzyHAIHHjdtsUX/ + Zbu7w/+54fNPeRnm7e3tvu7WWx9/a1vzmTmtHR/MmTsvRgj+RfPaDJ7ylBdjcMPh8I1tHUzgyCvPIVvw + Lz1+/PBFdvJ9g43twznOF+V1J8/ODW8/d+7y+73zGRyPh1aOD3DkW8mL1b8wr93gKS/NXc07duzYv2vj + YAJHvpWDExz5Tc/D/fW/uNc78jM2HsWi3+b4Kk95Ma7Je8Bef4E5STgOeDzMe3wUAke+lbxY4eYojyyx + 2MH3N1l5ykvxeN7Jkyf+wbwHEzjyrRyc4Mhvah4uPL7X/G/N71un+aK8MFPnDcn7PjOe/tgoHAc8HrzH + x4TAkW8lL1YnzH+yomJHW3nKS/F03vXXX3v3PAcTOPKtHJzgyG9i3vXmbzK/wxwcj7bHV3lpVl5t3m+b + 1/qR4Sl65YqL3WjlKS/F03nD4c575jmYwJFv5eAER36T8i414zkLuNlS7Xi0Pb7KS7PyovLwkCg8/2ZG + OA54PKQcH5UCR76VvBQ9J5NiV1p5yktxKG93d/iz3oMJHA/GVg5OcOQ3IQ8PWsENevAYXXyGGjUeuc8X + 5cW7A3m4+dSeuRCOAx4PMcdHo8CRbysPz/6JutvvrhXhjzIr9oSVp7wUV+X1ej086z1ZOAh5MLZ1cG5K + 3m3m7zDXPjt/XeeL8uLcoby3mh+P44DHQ9PxESVw5NvKw+KP+/40NwB2UvynR48ORhNhgwevsPI6nfds + c5JwEJpzPtiXnYff9j/P/AvmR80zYzDuJY9vspWnvBQb9/6TJ098Wc3xkSRw5NvK65lxx1/c+be+AbBi + XD4YDD4yXqDMiq085UW7IQ9/mt41RwsHobnNg3Od864x47f995tnah/yksc32cpTXorH8/b3937k9tuf + +tix4yNZ4MiHjrdkGYfFH8/6wTN/6hsAvGg78v347b/cqVyLrbwwU2flzeS92hwtOz46v/jfd9+zzm1t + 9T/TXsaz1JNuybuC8U2y8pSX4lDecLjz5p2do4+115MVOt74b+/xi7v94im/eNpvfQNgL/TOnLns1sFg + +xNlA5B7sZUXb+UF8z7VHCU7Pjq9+N922xOeeHBw7CVWv/9pL4/XMMorGt9oK095KW7IwwOqcAFstKaP + N3qe4xeL/3HzoblsAPBR3azsBfyZ4MA6l1dYA2A7ggZgsC7FTrbylGf+VXPUszDs2Ojs4n/VVVfef+zY + /g/ZueHDaza+0Vae8lIcmYdrYfDx2MBcq/HjbczzHL9Y/E+aT5jLBgDXAMye7/AfzXv22/8Ttre3P4EG + AF6zYkdbecqj7zY3yo6NTi7+dj74nL29vdda/R5e0/GNsvKUl2JH3s+Zz5iDKo83c5vH72nzKXPZAOAa + gMrFH53Bvu3Ey6wBwGNR17nYtVae8ugfNTfKjou1WKyZM3fe6dOnjuGRu8Ph8A+XPB5RVp7yUpxR3l+a + /7p5QjhOeby2cvyCM581nzGXDQCuAcBtt2dlL+B7gcMbb7zusq2trQ+aN6HYQStPefTvmo+Za2XHRZcW + /5N4/vnOztG/iKhflFc4vlFWnvJS3EJe+ZFA8Tk8jlMer20cv+N558xlA4BrACoXf3xOgKsCh3bgf/XW + Vn+Tij1h5SmP/qj5ieZa2THRlcX/cvO/tDp9YEXjEWXlKS/Fmef91P7+PhboRZ0PygYA1wDUf+XPXDQA + tvi/cUOLrTzllX7Q/FnmWtnx0IXF/ylm3KJXT/lUXpKVN3+e/cL9l5ddduoL5zh+RwJHvsxCA4BrAOpv + +IM3mAd7e3s4GQR/2CavQ7GVpzzzh8zPMtfKjodNX/zvNGPhL+7Wt8LxiLLylJfiNct7+PDw4GXnz999 + ZcLxOyFwPP7Hzwe4BqB+8YfwJvO2/VC4F3rwB67zgoujvEQrrzLvXeZ7zLWyY2GTF3/s/0+aR7fpXeF4 + RFl5ykvxuub1er3X2OuXmJOE457Hv+d8MGoA8NUAXBQV/KGrvK7FVl6cNyjv+8yH5lrhoOHB4zuYpgSO + /Krz/oYZ9zuYqMsKxyPKylNeijcg793mu8xRwnHP4z/1fDCjm80TP2yTV1CcJCtPeWYselEP+cFBw4Nn + 7oMJAkd+lXlY+N9gHq9J4RWNR7SVp7wUb1DeQ2b8NT581T6F457Hf8r5oFIvNE//IJVeYXGirLxO5+EA + +v/M95ujhIOGB08rBxM48qvKw76/3jxTO3jJ45Fs5SkvxRua9+PmE+YZ4bjn8R97PmgUHugR+iFmnElx + Kq28TuU9PBzuvMf8pl6v90p7HY+iTfocDQcND55WDiZw5FeR9zjzfzEHawev2fgqL9HK26i8t5lvNY+E + 457Hf8z5IEpHzR83B3dg3Pih8cOXhV7DYr/XjM7qRWZcDf4E85Xm4OfDKCqL20qxwZFXnkPgyCtvUrjF + 6A+Ya5/Kt4LjLcnKU16KO5KHR5W/wNz6+aUU7oUe2vCEMy3OyDV5H7HXX2E+b4566AuEorK4rRQbHHnl + OQSOvPIuaseMzwsxx4PHReklHm/B9zdZecpLcdfyer3ef37iE2+5peF84NI3mIMbLZ17cUJ5eGqZFQ37 + 1ni712mhqCxuK8UGR155DoEjr7wLQiP7xeZ3moPHxLjX8fhVXryV1408PJvjyiuveE7gfJAk4/Dsn9E9 + AvD9w+CG4XUpznje7u7wZ81X2+vJQlFZ3KqTb5LAkVeeQ+DIK++C8LHVT5uDx8O01/H4VV68ldetvOFw + 5yOXXHL8+WPngyQZh8Ufz/4ZNQDvMNdsfLCwnVlA3iMHB8e+eY7iaLFRXrTAkV9G3jXmV5lHN/Fp8hKO + N+UlWHnKS3FDHi563jNHy84jPTOe+otb/xcNwHFz8ISCjQwG2xM/wAJ3JtmBvEetM3oBT5bJAmde1sk8 + WeDIK88hcOTXKu/48UN8FeilZjzAKHgshLyE4015CVae8lIcmYeb9+Evgo2ycwkW/z3z0DxqAHDXofHA + wtjI9jYW/8Hoh1jCzkQ7lGe/+b/EdkqLTYTAkVeeQ+DILyzvWc+686p+v/88e/mPzcHjoMrLON6UF2/l + KS/FiXkfM3+5uVJ2PsHdfg/M++aJBgAXEk0EYiNbW1v87f9CA7DEnWl0KG93d/jaO+54WvF85VRZIbR4 + KS9a4MgvLO+KKy6/3+Z55Y186ryM40158Vae8lLszMNf8b/dPDBPyM4nWPyPmw/NZQMwWiv/d/NE2NZW + v/jt/2IDMMi6ODs7Rz9qDcBV9nqyrBBavJQXLXDkF5J3yy03P3lvb/fVNs+jP+cf9zKON+XFW3nKS3EL + eb9pvsFcyM4pWPxPmk+YywYA1wCMvg6Ph6SMAvr9fvHbf9kAwLkXp9frvcxeT5YVQYuX8qIFjnzreefP + 33PN8eOHL7Zm9v25H2/Ki7PylJfiFvPwyPPP4/nltPmUuWwAcA3AxL1w8GjQArSFdKIBgNegOLjz2XXm + JFkROrvYjFl5kQJHvvW8K644++m7u8M3L+j4CL6/ycpTXoqVl1/e7u7uK5/xjKddZeeYsgHANQAzDxj6 + dXMBjDcAcE47U5P3S+YkWRG0eCkvWuDIt5r3zGc+/caDg2P/t83nhxZ4fCRbecpLsfLyzIOHw51fvvnm + m26w8w2uAQg+XfAPAGDxv9gA9LPbmZq8f2KOVnnyNbd6MmeO8hIFjnyn8s6ePfM37bf+31/C8ZFk5Skv + xcrLNw//i+v3BoPB721vb+MeIkH9JaDxBiDHnanJe445SuXJ19zqyZw5yksUOPKdybvllpufsL+/9yM2 + lx9d0vERbeUpL8XKyzsP/3/sGj7cMjzYBHwIbygbAPu3y4vemZq8ys5mXDj58uTd2smcvPIcAke+M3mX + Xnryi4bD4buXfHxEWXnKS7Hy1iFv5tt7bzHPPBfnQbzJu2E4vPGlFafxQT84+fLk3drJnLzyHAJHvhN5 + h4cHl+7t7f6nyPnc6BUfb41WnvJSrLyl5uFW4hPfAnjUu2EYLDZW7siSdwYOXthQCidtnrxbOZmDI688 + h8CR70Te1lb/s3d2jr4nYT7XOoPjrdbKU16KlbeSvC8zjxR6Q5Qz2BncLKVSOGnz5N3KyRwceeU5BI58 + F/J2e73ed9v8LT7rj5zPtc7geKu18pSXYuWtLO/PzYfmQqE3NDqTnalsAHDS5sm7jZO58pSXok+yeftH + GRwflVae8lKsvI3L+0ZzodCLtc5oZ4INAE7aPHm3cTJXnvJiddT8zTZvH87k+AhaecpLsfI2Mg8PGCse + BhR6sdKZ7cxMA4CTNk/e857MC4EjrzyHwJHf9LxPNxf31Mjo+Jix8pSXYuVtdN695uALQWe4MxMNAE7a + PHnPezIvBI688hwCR36T8/AtlO8353h8TFh5ykux8jY7z/wvzcEXZpzpzowaAJy0efKe52Q+EjjyynMI + HPlNzkMHjRts5Hp8jKw85aVYeZudBxv78/a/4RfHnfHOFA0ATto8ec9zMh8JHHnlOQSO/Kbm4bOzf2p+ + yJzz8VFYecpLsfI2Ow8Ga36X/f/wG0pf2PigtY1fyGttZx7FSZsnb+/JfELgyCvPIXDkNzXvRnPxAC24 + 5fmsPOUlWXnKS3V511/L+Jj9O/wmGBvBvYTHf4CcdsY4NAA5LQ4TAkdeeQ6BI59L3t8yv89czr+257Py + lBdt5SkvxeDwrJ+xBuBB++/Vb97exuI/GP0Que2M8WgAvCfzCYEjrzyHwJHfxLyh+QfM0/Ov7fmsPOVF + WXnKSzE4POV3qgH4M3ut6s1b/O3/QgOQ284wb7wB2JTFZkbgyCvPIXDkPXlnzL9kDs2/tuez8gLvb7Ly + lJfiLuZhPYfLBoBZ/808C6BTwG//FxuAmacKRXsROzOWVzYAm7LYzAgceeU5BI68J+9u85+Yq+Zf2/NZ + eYlWnvJS3MU8rOXweAPA119ungTwBryxbADGniec7EXszFReeQ2AFq8IgSOvvHrhAVMvNj9srpt/bc9n + 5SVYecpLcRfzyjV8vAEYe89nmi8C6AzGGwA4p50J5KEB0OIVIXDklVcvfN7/SnPM/Mv9+FBepJWnvBSv + R96Fv95fbAAmFv8PmXfNF4HxBgDOa2eCecFnATQJiwAXg9TFIShw5JXnEDjyq867zvxmc+z8m3hfrJWn + vBQrT3kpBgf+gi80AIH1/GXmQsULWPwvNgD97HamIi+5AcAiwMUgdXEIChx55TkEjvyq8/B5P66KTZl/ + yVae8lKsPOWleDwP/4sGIPCXfHz973pzoeLF8QagjY23vTMVeUkNABYBLgapi0NQ4MgrzyFw5Fed9/Xm + ic/74RXM5yQrT3kpVl638vD/K67h+ybzSMUbygYA//Z40TtTkRfdAGAR4GKQujgEBY688hwCR36VeQMz + roQdn1OFVzSfo6085aVYeV3MC3577y3m4rP/UsWbvBuGwxtfSnGiGgAsAlwMUhaHSoEjrzyHwJFfZR6+ + 3/8r5uk5tcr5HGXlKS/FylMe/UHzY80Tcm8YXuHOwI0NABYBLgYpi0OlwJFXnkPgyK8y77z5PeaZObXi + +dxo5SkvxcpTHo2r/p9pntH0G6O9wp0pXdsAYBHgYpCyOFQKHHnlOQSO/Crzvsj8cfPMfMpgPtdaecpL + sfKUR3/Y/NfMQU2/Ocor3JlxVzYAWAS4GKQsDpUCR155DoEjv6o8PML328yheZTLfK608pSXYuUpj36H + +TZzpaaBRq9wZ6YdbACwCHAxiF0cagWOvPIcAkd+VXmH5p8yh+ZQTvM5aOUpL8XKUx79WvMpc62moVqv + cGdCnmkAsAhwMYhdHGoFjrzyHAJHflV5t5j/wByaP7nN5xkrT3kpVp7yzJ8wv8B8xNyocbDWK9qZOk80 + AFgEuBjELg61AkdeeQ6BI7+qvE8z4+KX0NzJcT5PWHnKS7HylGfGn/xvN0drHK70inamyaMGAIsAF4PY + xaFW4MgrzyFw5FeVF7y5T+lM5/PIylNeipWnPDM+5rzU3Cg7bx4x47qoyQ2FvKKdiXHRAGAR4GIQuzjU + Chx55TkEjvwq8vBnr39lDs2XwhnP58LKU16Kldf5PKyD32KOOr/aeROL/7a5uQG4sPFB3caTHLEzKS6e + Bmhe1WLTKHDklecQOPIxeTvmHzOH5krhluef8pSXZOUpL8UReX9qxn1NomTnzZ55xzww1zcA2AjuJTz+ + Ayx4Z5JsHBqAVS02jQJHXnkOgSMfk3dg/nlzcK7AC5h/ylNetJWnvBRH5P2M+bQ5SnbexOK/Zx6a6xsA + bARPEcJv/+UPseCdSTLz0ADELA6NAkdeeQ6BI7+KPBwE/90cnCvwguaf8pQXZeUpL8UNeY+YX2yOPrfa + ebNvPjDvm+sbAGwEzw++8Nv/hQZggTuT7LG88QZgXRevRoEjr7xZ3WB+uzk4V+AFzj/lBd7fZOUpL8XK + m8h7rxnfboqWnTex+B83H5rLBmCbL18sdOmtrX7x2//FBiD4VKEoL7g4ZQOwrotXo8CRV96sbjL/kTk4 + V+AFzz/lJVp5ykux8iby3mS+0RwtO29i8T9pPmEuGwBcAzC6R8DED9Dv94vf/ssGoOJ5wlFeQnHKawC0 + GEYIHPlNyHu6+X3m4FyBlzD/lJdg5SkvxcqbyHupOem8ivOm+bT5lLlsAHANwMQNgkY/QK/Xm2gA4MyL + gwZAi2GEwJHfhLxnmN9vDs4VeEnzT3mRVp7yUqy8UR7Oc59pThLOm+az5jPmsgHANQA9vmWk0Q8w3gDA + C9iZ4PubXJM3cyvgGFkRtLiub96d5g+Yg3MFXuL8C76/ycpTXoqV19m837bXk/7kD+G8yfPnOXPZAOAa + gJnFHyp+ACz+FxuA/iJ2Jvj+JjfkJTcAVgQtruubd7/5I+aZeVJ6yfMv2cpTXoqV1808W4u/017HfU2S + hPMmz584j5YNAK4BKK74D6n4IcYbgNyLM5aX1ABYEbS4rm/es80fM0/MkXGvYP4lWXnKS7Hyupe3s3P0 + o7YGf4m9niycN3n+LM+laABwDUDl4g8VP0jZAODfHi+jOIG86AbAiqDFdX3z8BnYg+bxsZ/wiuZftJWn + vBQrr3t5w+HO244eHTzBXk8Wzps8f46fT3ENQO3iDxU/jHdH4GUUpyIvqgGwImhxXd+8v2XG4y2nx37k + Fc6/KCtPeSlWXvfy9vZ2//OJE5cct9eThfMmz58x59MZuXcEXkZxavIaGwAUgcVwFWda4MgrzyFw5GPy + nmuufKIfvOL512jlKS/Fyutc3scvueT4CyrOf40Cx/NnzPk0qOAPGuMMil3bAKAILIa7OOMCR155DoEj + H5P3ZWbc8jI07oUzmH+1Vp7yUqy8buUNh8N3XH75medUnP8aBY7nz5jzaaWCP2yTMyl2ZQOAIrAYcxWn + FDjyynMIHPmYPFwEo9/8x6w85aVYeXnn7e3t/uLjHvfYJ1ac/xoFjufPmPNprYI/cJ0zKnawAUARWIy5 + iwOBI688h8CRj8l7nhnjGhrvwhnNv6CVp7wUK69TeZ84fvzwxffd9yxcoZ/F+Tn4Q1c5s2LPNAAoAovR + SnHAkVeeQ+DIx+R9lVmL/5iVp7wUKy/fvOFw+K4rrjj7N2rOf40CRz7mfBql4A8ecobFnmgAUAQWo5Xi + gCOvPIfAkY/J+0KzPvMfs/KUl2Ll5Zu3t7f7C49//OOeVHP+axQ48jHn02gFf/hpZ1rsUQOAIrAYrRQH + HHnlOQSOfEze55v1mf+Ylae8FCsv27yHDw8PvuW++561zPNpo4w7Yi7uERDcgXFnXOyiAUARWIy2iqO8 + 5eX9dfMD5tD4Fs54/hVWnvJSrLxu5A2HO+87ffrSL2k4/zUKHPmY82mjjMPiv21ubgAu7Mwg18ErngZo + brM4ylte3iebdYe/MStPeSlWXp55e3u7v3zLLY99SsP5r1HgyMecTxtlXM+8Yx6Y6xsA7MxgsD1RoMyK + jQagzeJosV5e3m3mD5qDYwsvYL4oT3nRVp7yUsy8Rw4PD1527713Xdtw/msUOPIx59NGGYfFf888NNc3 + ANiZ7W0s/oNRkTIsNhqAtoqjxXp5eVeb/9gcHFt4QfNFecqLsvKUl2JwOztH33/69KVfGnH+axQ48jHn + 00YZ1zcfmPfN9Q0AdmZra4u//V9oAHIrNvPGG4Cciq286rwT5t8xB8cWXuB8UV7g/U1WnvJS3MW84XD4 + 32+88fpnRJz/GgWOfMz5tFHGYfE/bj40lw3ANl+e3aGtrX7x2//FBmCQVbHH8soGIKdiK68676j558zB + sYUXPF+Ul2jlKS/FXczb29v7oTvueNpNEee/RoEjH3M+bZRxWPxPmk+YywYA1wAc4Vsmd6jf7xe//ZcN + AJxTsafyymsA1nExbBQ48puQhwn3g+bg2MJLmC/KS7DylJfiDuZ95JJLjn9N5PmvUeDIt5l32nzKXDYA + uAZgtPhDox3q9XoTDQCcUbFDeWgA1nExbBQ48puS9y3m4NjCS5ovyou08pSX4g7m/fp1111zR8L5r1bg + yLeZd9Z8xlw2ALgGoMe3jFTu0EQDAGdU7Kq8mVsBx8iKsGmLa63AkV9V3t81B8cWXuJ8Cb6/ycpTXoqV + t9l5tk5+5x13PO26hPNfrcCRbzsPzxsoGwBcAzCz+ENFIbD4X2wA+tkUuyEvuQGwImza4lorcORXlYfv + +n/CPDO28JLnS7KVp7wUK2+j8z5g6+Pn8HwXe/6rFTjyi8grGwBcA1Bc8R9SUYzxBiCTYsfkJTUAVoRN + W1xrBY78qvKeYK78rv8K5kuSlae8FCtvo/PeZOwtPN/Fnv9qBY78ovLQAOAagMrFHyoKUjYA+LfHKxq8 + 6AbAirBpi2utwJFfVd6l5reZx8dr5BXNl2grT3kpVt5G5/3QiROX4E/oqzyf1goc+fE8XANQu/hDRVG8 + hYZbLnZKXlQDYEXYtMW1VuDIryrvmPk3zNPjVXiF8yXKylNeipW3sXkfNn8hznM838We/2oFjnwWee5C + wysevMYGAEVgMVzFmRY48soLC9/1/1lzaLxWPV8arTzlpVh5G5v3ZvNjcZ7j+S72/FcrcOSzyQvtfJQz + GLzaBgBFYDHcxRkXOPLKCwvfL/1hc2iscpgvtVae8lKsvI3N+7dm3C2vE+f7UAEancngVTYAKAKLMVdx + SoEjr7xqvcQcGqdc5kullae8FCtvI/M+Yv5ic6fO96FC1DqjwQs2ACgCizF3cSBw5JVXrS8xh8Yop/kS + tPKyyPuQ+X3mPzXuDy3jj3Z3h2++4N1fs//9pV7vyM/Y669L8K+Zf5N5fzYc7nzA/vch5883ckv7O7Ly + ssh7u/mp5s6d7yeK2WQUFcUtB27FgzfTAKAILEYrxQFHXnnVus8c/K5/ZvNlxspbWB4uoMK3QF5vfo35 + e83fbP6H5i80P8f8JPM5M64bKYR5xvmWMv8qBY78KO/8+buv3N/fO2svP9Z8p/lvmJ9r/kdm/BXrFebX + mv+H+S/NMfs7UZdYKy+LvB8xH5o39fxcq1BBgs5w8CYaABSBxWilOODIK69at5jfb54Znwzny4SVN1fe + u+038p/f29t75eHh4UtOnjzxD8+cOf23r7zy3L34ypS9nizMM863lPlXKXDk581Dg3Ld1tbWs48fP3zR + wcGx77IG4sd3d4e/tbNz9D0bOr5dyHvQ/AJzcW98zAvOj3nnSyFw5LPMKxUqzIwzHDx41ACgCCxGK8UB + R1551brM/IfmmbHJdL6MrLyoPPxJ/r+ZX2n+38yfZ36KGU8U0/FxMW/PjJte4S8J+CvHm8yheo6cyfhW + ugN5/8t8u7kQxpHjGRrfZIEjn2veEXNxj4BQcSac4eCVLhoAFIHFaKs4ymvOG5rxGevMuGQ8XworbyYP + vwn9d/O/M/99811m3MgpKMwLzo+U+VIpcOQ3Ke9p5h8z4xyVOh5JVl5yHj6SusRcCOPI8UwZ30qBI59r + Hhb/bXNzA3Ch2IN5ij3hFgZv3MXTAM05F3tT815unhmTlsdXee3nPTIc7ryt1+v9e3v9S834HH7bHCXM + C86P1PkSFDjym5qHZ2G8y1w1HrnPl03Kw3VKX2sePQ4X48jx9I7vhMCRzzWvZ94xD8z1DQCKOhhsTxR8 + hYM3Y+PQAORc7E3N+3xzaDzaHl/lzZm3s3P0o3t7u798eHjwstOnT33xrbc+/nER4xsUOM6P1PkSFDjy + m56H3zZ/ch3mywbnvdP8TPNIGEeO57zjWwgc+VzzsPjvmXGPg/oGAEXd3sbiPxgVfYWDN2PmoQFoqzhd + mwzePFz0h+/Lhsaj7fFVXnree8yv6vf7zzt37or7zp+/55rE8Q0KHPnU+RIUOPKdyLv55puO7u/v/T8t + jG/hjOdf4czy/qP5wDwSxpHj2cr4giOfa17ffGDG9Tv1DQCKurW1xd/+LzQAKxy8GY/ljTcAmzx4ueTt + mH/LXDUebY+v8gLvnzK+v4yL9J5vxveYcaBrPmeYd999z7ramoCfWPF8mfEG5z1k/nrz6E/+UDke5lbH + lzk55uGcgIcZHZrLBmD0sd9M4ba2+sVv/xcbgEGuk6FsADZ58HLK+9fmuvFoe3yVN+s/MeM79V9gxnfo + J4Rx5Hh6xndG4MgrzyFw5Iuspz3tyTcPhztvXeP5V+uM8t5tvsc8oenxoLOdL/Q8eVj8T5pPmMsGANcA + jJqiicL1+/3it/+yAYAzngzlNQCbOng55X2GuWk82h5f5T3mMY+Y8VU8fA0PX8Gb+G1mXBhHjqdnfGcE + jrzyHAJHfiJvMBjcZi8Hb5xV5xXNv2hnlPfT5lPmCVntuzj/TptPmcsGANcATJxDRoXr9XoTDQCc+WRA + A7DJg5dLHu6ahs+Wm8Yj9/myLnlYHH7K/OXm0+ZGYRw5np7xnRE48spzCBz5qrxvM8/Miyovef4lO5O8 + h83faO6ZJ4S6s/5V45EkcORzzjtrPmMuGwBcAzBTm6J4KOx4AwAvefAqXZM3cyvgGFkRujgZvHnoFnFb + 1JjxmBi3WCuvyPuEHX//1V7HMxVG31GOEcaR4+kZ3xmBI688h8CRr8vDGH/cHJwj417T+bzsPHw0dt48 + I9Sd9a8bj2iBI5973jlz2QDgGoCZxR8qCovF/2ID0F/24FW6IS+5AbAidHUyePNwf/TY8Uh2x/M+ure3 + 95OXXHL8HxweHlTeeKdOGEeOp3d8JwSOvPIcAkc+Ju9V5uA8Kb1m83lVeXhIFO5KOiPUnfWPGY9GgSO/ + DnllA4BrAIor/kMqijveACx58CodkZfUAFgRujwZPHn4rPIBc+x4JLmLeTs7R9+3v7/3n06duvQrbr/9 + qY9NHI8JgSPvHd8JgSOvPIfAkY/N+2xzcK7A6zCfV5yH62NebA4ubqg76x87HrUCR35d8tAA4BqAysUf + KgpcNgD4t8crmgzRDYAVoeuTITUPt/r9HXPKeES7Y3kfsmPrladOnfw7995717XO8ZgQOPLe8Z0QOPLK + cwgc+ZS868yh+ZL7fM4h78/N95uDQt1Z/5TxqBQ48uuUh2sAahd/qCiyd+Bgx+DVOiEvqgGwImgypOeN + vvK3wvGNcqZ5uJDvv5g/337bx8U3uY3vSODIK88hcORT8/AQoZm5k+l8HjmDvF8yX24OCnVn/VPHIyhw + 5Dcyzz1w8IonV2MDgCKYNRnS8j7NjNquenwbnWEeno74j83F15BQd9Z/nvEYCRx55TkEjnwOebgZy8T8 + yXA+T3jFeTgnvdRcWVvUnfX3jMeMwJHf2LxQoaO84skA1zYAKAKL4S7OuMCR3+S8q8x4DGwO41vrjPLw + 2z4u6LrbPBLqzvrPMx4jgSOvPIfAkc8lb6IByGg+B73ivD81B6/yL4W6s/7e8ZgQOPIbnRcqdqNXPBlK + VzYAKAKLMVdxSoEjv8l5+Mofvn+ey/hWOpO8D5i/1Xy9eUKoO+s/z3iMBI688hwCRz6nvFEDkMl8rvSK + 83AjrKvNlULdWf95xmMkcOQ3Pi9U8FqveDKMO9gAoAgsxtzFgcCR3/S8F5lzGt+gM8j7H+YvNh81zwh1 + Z/3nHY9C4MgrzyFw5HPLKxqADOZzrVeYV17lX1tX1J31n3c8CoEj34m86aLXeoWTIeSZBgBFYDFaKQ44 + 8pued7v5E5mN74xXmIe59hPmiT/zTwt1Z/3nHY9C4MgrzyFw5HPM217hfI7yCvPea/5Uc61Qd9a/jfHo + XB40XfhKr3AyVHmiAUARWIxWigOO/Kbn7Zt/P8PxnfCK8j5q/g7zjeZaoe6s/7zjUQgceeU5BI58lnnX + XHPVcAXzOdorzHuD+UpzrVB31r+V8QBHvhN5paaLH/QKJ0OdRw0AisBitFIccOS7kPc9mY7vyCvIe5cZ + jxKdeahISKg769/GeCivA3l33nnHNTXzL8krOD6SHJmH83ntVf6lUD/Wv7XxIN+VvCPm4h4B4wMQ9Iom + Q4yLBgBFYDHaKk6X8j7F6v5opuNbeMl5v2/+e+Zdc5RQd9a/jfFQXkfy7rrrGdcvYT4ne0V5HzF/kblR + Zf3MrY4Hc7qQh8V/29zcAFwYvEHT4EU7cjLEungaoDnnYuecd7nV/T0tjkfb47u0vF6vh5v21H6+HxLq + zvq3MR7K61Be2QCsw/Gx4LzfMjd+xAaN12/MWY7vmHPK65l3zANzfQOAQRoMticGcAmTIdrGoQHIudg5 + 5x2xRe8nWx6Ptsd30XmP7u4Of3Zra+s+ez1ZqDvr38Z4KK9jeWgAMj8+lpH3SjPuiNio6frR2Y4vnVMe + Fv8989Bc3wBgkLa3sfgPRoO4hMkQbeahAWirOJ2aDP1+/2sWMB5rk7e3t/tLZ89e9mne+oFj/VsZD3Dk + lecQOPJrk4drAHI9PpaQh0chf5U5SqH68d+afxEyrm/GLcn3zfUNAAbJfivib/8XGoAFT4Ykj+WNNwCb + PHit5g0GgydZ/R5cwHhkn2cL/y9ffvnZz5infuDItzIe4MgrzyFw5NcqD98CsJeDc7bO63S8VeS92Xyz + OUpWK82X+fKw+B83H5rLBgD3oCg0MXjw1la/+O3/YgMwyHVylQ3AJg9eq3k333zT0eFw+MYFjUe2ebu7 + w987ffrSL523fuDItzIe4MgrzyFw5Ncxb+ZZAE1el+OtJu/V5gNzlFAn1itUv2SBI9+VPCz+J80nzGUD + gGsAcNfXQhMD2O/3i9/+ywYAznhyldcAaDJECNzBwbGXjtWv7fHILs8y3nnppSefd999z8pyPMgrzyFw + 5Nc1L6kBWIfjrSYP99PA3TOjhTqxXlX1SxI48l3KO20+ZS4bAFwDMFr8odEA9nq9iQYAznxyoQHQZIgQ + uCuvvOK81e2BsfrlPr7z5H3s2LH973jyk2+7pa36kW9tPMgrzyFw5Nc5L7oBWIPjrS7vHeY7zNFCnViv + uvpFCxz5LuWdNZ8xlw0ArgHo8S0jjQZwvAGAFzQZkl2TN3EnwFhZETo5ufb2dl+/4PEIvr/JLec9ZPP4 + +6+//tqns26t1Y85yksUOPLKm1RUA5D58daUh6/XnjBHC3VivZrqFyVw5LuWd85cNgC4BmBm8YeKgcLi + f7EB6C9qMiS7IS+5AbAidHIynDx54vlLGI9kt5j3kPnlw+HOtaxXq/VjjvISBY688mbV2ABkfLwVrsl7 + 0F6Pvsq/FOrEesXUr1HgyHcxr2wAcA1AccV/SMUgjjcAC5gMwfc3OSIvqQGwInRyMtx++1MfOxwO37WE + 8Uhyi3mvMd9a7q+51foxR3mJAkdeeWHVNgAZH2+Fa/L+2F5/ljlJqBPrFVu/WoEj39U8NAC4BqBy8YeK + gSwbAPzb4yVOrvH3RTcAVoTOTobDw4P/a0njEe2W8n7VfJe50+M7ZuVFChz5VeZVNgCZHm8jV+X1ekd+ + 1l6/zJwk1In1SqlfpcCR73IergGoXfyhYjC9EwFe1uQK5EU1AFaEzk6G66+/9i6r3wNLGo8ot5D32+b7 + zYXG93fMWY7HmJUXKXDkNy0v2ABkeLxNuCLvoX6/90J7feIK8xihTqxXav2CAkdeeRFyTwR4SZOrKq+x + AUARWAxXcaYFjvxa5O3v7/3IEsej0XPmfcD8AvPAXGh6f+lsx4NWXqTAkd/EvJkGILPjbcahvJ2do+/d + 2tr6FHs9WagT6+Wp34zAkVdepIIDHeMMJmttA4AisBju4owLHPm1yDt79rLPtvo9usTxqPUceRjnl5sn + riae3l862/GglRcpcOQ3NW+iAcjoeAs6lLe7O/xF+yXjrL2eLNSJ9fLWb0LgyCsvQcHBbnImk7WyAUAR + WIy5ilMKHPm1yMONb4bD4W8ueTwqPUfe75nvNU9oen/pbMeDVl6kwJHf5LxRA5DR8RZ0IO+RY8f2vw13 + FrXXk4U6sV7z1G8kcOSVl6jggNc5o8kabABQBBZj7uJA4MivTd6JE5f83RWMR9DOPIztd5uPmScU2l/+ + uzPjy38rL0LgyOeWVzQAmRxvlZ7OGw53PnTy5ImvcOxvIXCs17z1KwSOvPIcCg56lTObrDMNAIrAYrRS + HHDk1ybv6U9/8vVWP9x9K1SzWmcyvu82/zXzjEL7y393Znz5b+VFCBz5HPO2MzneKj2dt7s7fMs111x1 + l3N/NV8yy4OCAx9yhpN1ogFAEViMVooDjvxa5fV6vW+xl0P1qnUm44vP+md+64ds3zS+yosWOPJZ5uFp + gBkcb5Weynv04ODYd9999zOxzxrfCIEjn2VeqeDgT3vBk8ubN2oAUAQWo5XigCO/VnlWw1vsZdyFK1Sv + Smcwvrh5yHPMQdm+aXyVFy1w5LPNu/POO65JOD5qvcjjdzjc+eCpU5fiT/4bPR7ku5J3xFzcIyA4Aca9 + yMk1Z17RAKAILEZbxVnnPNx7O1SrSmcwvj9iPmUOCvvF/Qvtb7LAkVeeQ+DIK88hcODvuusZ16/oeKv1 + eN7u7vCt11579b1t7K+51foxR3mJMg6L/7a5uQG4MBkGC5lcLeQVTwM051zsZeZ9qjlUp0q3PB6pee81 + f465Utgv7l9of5MFjrzyHAJHXnkOgSN/ddkALPF4a/R43rFj+993xx1Pu6mt/R2z8iIFjnxbeT3zjnlg + rm8AMBkGg+2JCZbZZEUDkHOxl5mHm+P8rjlYq5AXMB4pea83X2+uFPaL+xfa32SBI688h8CRV55D4MgX + WWgAlni8NXos74FLLjn+T/hzZls/WnmRMg6L/555aK5vADAZtrex+A9GkyzDyYoGoK3irPtk+CfmYK1C + XtB4xOQ9YMbd/GpvGYr94v5V7W+SwJFXnkPgyCvPIXDkR3m4BmAJx1uUy7zd3eHbrrnmqvv4M2ZdP/5b + eREyrm8+MO+b6xsATIatrS3+9n+hAWhjcrU9WS1nvAHY5MFrysMd8j5kDtZr2gscj6Y83NTnaeZaYb+4 + f1X7myRw5JXnEDjyynMIHPmJPHwLwF6ePkYavajjd29v77W33faEJ5Y/n1njGyFw5HPNw+J/3HxoLhsA + 3IOi0MyE2NrqF7/9X2wABnNPrrYnK7PKBmCTBy8m7xvNwXpNe8HjUZX3iPnbzbvmWmG/uH91+xstcOSV + 5xA48spzCBz5UN7MswCavKDj96Hjxw//Oe4eOvXzJQsc+dD+JgsceeU5ZBwW/5PmE+ayAcA1AKO/wE5M + iH6/X/z2XzYA8JyTq+3JOp5XXgPQ5cmA3yL+3Bys2biXMB6hvLebZ27lGxL2i/tXt7/RAkdeeQ6BI688 + h8CRr8pLagAWcfxaxp+cPXvmsyt+viSBI1+1v0kCR155DoEznzafMpcNAK4BmPj4dTQher3eRAMAzzO5 + 2p6sgTw0AF2fDJ9tDtZs3Esaj/G88la+++ZGYb+4f037GyVw5JXnEDjyynMIHPm6vOgGYBHHLx7kc8st + Nz+55ueLFjjydfsbLXDklecQOPNZ8xlz2QDgGoAe3zLSaEKMNwDwPJOr7clakTdzK+AYWRE2aTK8whys + W+kljkf5HvzWf6c5Stgv7l/M/jYKHHnlOQSOvPIcAke+KS+qAVjA8fuJw8ODfzb2J/+qny9K4MgrzyFw + 5NvOO2cuGwBcAzCz+EPFRMLif7EB6M8zudqerHV5yQ2AFWHTJsOfmWfqVnrJ4wHjpj6XmqOE/eL+xe5v + rcCRV55D4MgrzyFw5GPyGhuABRy/f37q1KV/O/LnaxQ48spzCBz5ReSVDQCuASiu+A+pmEzjDcAck6vt + ydqUl9QAWBE2bTLgOdwTNRv3ksfjIfPzzdHCfnH/Yve3VuDIK88hcOSV5xA48rF5+O8zx1npto/fXu/I + L99ww3VPTfj5agWOvPIcAkd+UXloAHANQOXiDxUTqmwA8G+P256skXnRDYAVYRMnwyeZx+sx8pLH4y/M + d5mjhf3i/qXsb6XAkVeeQ+DIK88hcORT8/ANmdTjLdUP27n9G+6771lYEFJ/vqDAkVeeQ+DILzIP1wDU + Lv5QMamcE6twy5M1JS+qAbAibOpk+GLzdE2WPR5/YMYDiKKF/eL+pe5vUODIK88hcOSV5xA48p483Bgr + 5XhL9fu2tvqfxZ/H8/PNCBx55TkEjnwWee6FAW55sqbmNTYAKAKL4SrOtMCRzyHvS8wTNVnyePy8+aQ5 + Wtgv7p9nf2cEjrzyHAJHXnkOgSPvzXufOfZ4S/Ubjb+RP4/355sQOPLKcwgc+WzyQhMnyi1PVk9ebQOA + IrAY7uKMCxz5XPKeax7VY8nj8VJz45+XxoX94v5593dC4MgrzyFw5JXnEDjy8+S9zRxzvKUYHyu8+IYb + rsMNX3Lb35HAkVeeQ+DIz5UXmkCNbnGyFnbmVTYAKAKLMVdxSoEjn1Pep5iLWixxPHCx31ebk4T94v7N + s78jgSOvPIfAkVeeQ+DIz5v3K+Y2j98Pm3GVv8ZDeVEKTaJatzhZC8+RF2wAUAQWY+7iQODI55Z3lXmZ + 44GvHEZ/v78U9ov7N+/+FgJHXnkOgSOvPIfAkW8j73tbPH5/zXwVfg7+PG38fBrfDc8LTaRKtzhZC8+Z + N9MAoAgsRivFAUc+xzwr05H3Lmk88CCfG81Jwn5x/9rYX+UpL0ngyGeZ1+/3/mFLxy9uCLaLn4M/Tys/ + HzjyynMIHPks86DQZAq6ZnEIvr/JLeRNNAAoAovRSnHAkc82b29v7wfnqN+Eq8aj1+v9tL1+aE4Sfj7u + X2v7S155DoEjrzyHwJFvLe/cucvvnz7eEo/fj5m/wqzxUJ5LoUk14xYW6wm3lDdqAFAEFqOV4oAjn3Xe + 2bOXffYix8MW/5fZ60kX+0Hlz2dudX+Zo7xEgSOvPIfAkW89b3d3+D+dx+9bzbeaNR7KS5JxR8zFeT00 + sSbc0mI9cot5RQOAIrAYbRVnrfL29/f+S9vjsbNz9GP9fv/z7fVkTf98dLb1o5UXKXDklecQOPJF1unT + p56bePx+yPwCc7H96Tw62/2llRcpcOY264fFf9vc3ABcWBwGE4tD24vNHHnF0wDNbRZn7fKuv/7ap1v9 + Jr5PHOvQeJj/eHt7+x57PVmhn4//7sx48N/KixA48p3O6/V6eHJm8BgdM24a9D3ma82FjFX9lBct43pm + fD10YK5vALA4DAbbEwtERos/ODQAORd7mXm3mf/cHKxVyKHx2Nvb/dFjx/Yvs9eThZ+DP0/o50sWOPLK + cwgceeU5BI78svL+nhlP0hw/TvG1218wf535cvNI4MhX5SUJHHnlOQSOfK55WPz3zENzfQOAxcF+C7QF + YjBaJDJb/MGjAWirOJswGW4w/5I5WLNxT43Hw3t7ez955szpz5jKixY4/jx1P1+0wJFXnkPgyCvPIXDk + l52HkzIW+qeY8Zs+nhg4I3Dkm/KiBI688hwCRz7XvL75wLxvrm8AsDhsbW3xt/8LDUALi3Xbiz9yxhuA + TR68lDw88/lvm19vrqvfg/bb/hsODw++9frrr727Jq9R4MjH/HyNAkdeeQ6BI688h8CRV55D4MgrzyFw + 5NvKw+J/3HxoLhuAUWM5s0BsbfWL3/4vNgCDHBf/8QZgkwdvnjw8lx93C8SfFr/e/DX9fv9vnTlz2ac9 + /elPeawjb0bgyHt+vhmBI688h8CRV55D4MgrzyFw5JXnEDjybeVh8T9pPmEuGwBcA3CEb5lcYG2BKH77 + LxsAONPFHy6vAdBkiBA48spzCBx55TkEjrzyHAJHXnkOgSPfpbzT5lPmsgHANQCjxR8aLbC9Xm+iAYAz + XvzxbzQAmgwRAkdeeQ6BI688h8CRV55D4MgrzyFw5LuUd9Z8xlw2ALgGAB8RT2i0wI43AHDmiz/+e/BZ + AE2yImhyKS9a4MgrzyFw5JXnEDjyynMIHPmu5Z0zlw0ArgGYWfyhYoHF4n+xAegvYrEOvr/JDXnJDYAV + QZNLedECR155DoEjrzyHwJFXnkPgyHcxr2wAcA1AccV/SMViOt4ALGixTnZEXlIDYEXQ5FJetMCRV55D + 4MgrzyFw5JXnEDjyXc1DA4BrACoXf6hYUMsGAP/2eAWLPxzdAFgRNLmUFy1w5JXnEDjyynMIHHnlOQSO + fJfzcA1A7eIPFYuqd6GGIxfraCfkRTUAVgRNBuVFCxx55TkEjrzyHAJHXnkOgSOvvAit6+IPNzYAKAKL + 4SrOtMCRV55D4MgrzyFw5JXnEDjyynMIHHnlOQSOfDZ5oYU1yite/OHaBgBFYDHcxRkXOPLKcwgceeU5 + BI688hwCR155DoEjrzyHwJHPKi+0sDY6g8UfrmwAUAQWY67ilAJHXnkOgSOvPIfAkVeeQ+DIK88hcOSV + 5xA48tnlhRbWWmey+MPBBgBFYDHmLg4EjrzyHAJHXnkOgSOvPIfAkVeeQ+DIK88hcGbwyCmdTV5oYa10 + Ros/PNMAoAgsRivFAUdeeQ6BI688h8CRV55D4MgrzyFw5JXnEDjyWeZBoYU16MwWf3iiAUARWIxWigOO + vPIcAkdeeQ6BI688h8CRV55D4MgrzyFw5LPMKxVaWGec4eIPjxoAFIHFaKU44MgrzyFw5JXnEDjyynMI + HHnlOQSOvPIcAkc+17wj5uIeAaGFdcKZLv5w0QCgCCxGW8VRnvKiBY688hwCR155DoEjrzyHwJHvSh4W + /21zcwNwYbEetLFYF25x8YeLpwGacy628pQXLXDklecQOPLKcwgceeU5BI58rnk98455YK5vALAoDwbb + Ewt2Ros/ODQAORdbecqLFjjyynMIHHnlOQSO/CrysBhdZb7TfL/5XvNJ80jgyMfkNQoc+a7kYfHfMw/N + 9Q0AFuXtbSz+g9GindniDx4NQFvF0eRSXrTAkVeeQ+DIK88hcOTXOe9S81eZ/6v54+bQuf6t5pfs7u5e + Sb4uL1rgyHclr28+MO+b6xsALK5bW1v87f9CA5Dh4o+c8QZgkwdPecqLFjjyynMIHHnlOQSOfCjvlBmL + /uvMD5uD5/hx43y/s3P0wydOXPLCQF6ywJEP/XzJAkc+1zws/sfNh+ayAdjmy7MF39rqF7/9X2wABjku + /nDZAGzy4ClPedECR155DoEjrzyHwJEf5d1880239vv959nL0Yt+6en14+Dg2L9hvsYjQsZh8T9pPmEu + GwBcA3CEb5ksuA1U8dt/2QDAmS7+cHkNgCZDhMCRV55D4MgrzyFw5JXnEDjy2efdcsvNT77kkuPfsLs7 + /GU7byct+qWr1o9er/eP7fVkjf98Y86yfmOeN++0+ZS5bABwDcBo8YdGBbfCTjQAcIuLdduLP/6NBmCT + B095yosSOPLKcwgceeU5BA6/6WPR39vb/RU7Pz+8gPN9mfeg+QnmaOHn4/61tr/kc847az5jLhsAXAPQ + 41tGGhV8vAGAFzR4ya7JCz4LoElWhC5OBuUpL0rgyCvPIXDku5B32taMr8Zv+nZefnjq/Bw8nzc5cv14 + jTlK2C/uXxv7u05558xlA4BrAGYWf6goLBb/iw1Af9GDF+2GvOQGwIrQ1cmgPIfAkVeeQ+DIK88hcORz + ysN7P9f8M3YeLn7Trzg/J7vhfD/uR8zXmmuF/eL+zbO/I4Ejvw55ZQOAawCKK/5DKoo73gAsYfCiHJGX + 1ABYEbo8GZSXKHDklecQOPLKcwgc+Vzyds1fb36neRXn+2m/0Fwp7Bf3z7u/EwJHfl3y0ADgGoDKxR8q + Clw2APi3xyuaDNENgBWh65NBeQkCR155DoEjrzyHwJHPJe855j80p5yfo+3M+1FzUNgv7p93fycEjvw6 + 5eEagNrFHyqK7B042Dl4lU7Ii2oArAiaDMqLFjjyynMIHHnlOQSOfA55e+ZXmkfn3RWe76f9O+YZYb9Y + /00cjxmBI+/Kcw8cvOLJ0NgAoAgshqs40wJHXnkOgSOvPIfAkVeeQ+DIK69Z15jfYh6dc1d8vp/2X5on + hP3i/nn2d0bgyG9sXqiwUc5gMtQ2ACgCi+EuzrjAkVeeQ+DIK88hcOSV5xA48spr1hPN7zaPzrcZnO+n + jdsHj4T94v559ndG4MhvdF6osI3OZDJUNgAoAosxV3FKgSOvPIfAkVeeQ+DIK88hcOSV16ybzO8xj861 + mZzvp/2AuRD2i/vn2d8ZgSO/8XmhwtY6o8kQbABQBBZj7uJA4MgrzyFw5JXnEDjyynMIHHnlNesy89vN + o/NsRuf7aRcNAPaL++fZ3xmBI9+JvFBhK53ZZJhpAFAEFqOV4oAjrzyHwJFXnkPgyCvPIXDkldcs3CIW + 9+sfnWMzO99P+wHsF/fPs78zAke+E3lQqLBBZzgZJhoAFIHFaKU44MgrzyFw5JXnEDjyynMIHHnlxelr + zaPza4bn+wkbhwYgp/pNCBz5LPNKBYs77Uwnw6gBQBFYjFaKA4688hwCR155DoEjrzyHwJFXXpxuNH/U + XJxbMz3fj8y8B+fY3wmBI9+VvCPm4h4BwQKPO+PJUDQAKAKL0VZxlKe8aIEjrzyHwJFXnkPgyM+Th3vr + F+fVjM/3hcfyxhuATRuPkcCRbysPi/+2ubkBuFDswSIGr4284mmA5pyLrTzlRQsceeU5BI688uKFr/zh + l6m2z8+LzisbgE0bj5HAkW8rr2feMQ/M9Q0Aij0YbE8MYGaTAQ1AzsVWnvKiBY688hwCR155aXqFeRHn + 50XnoQHYxPEoBI58W3lY/PfMQ3N9A4Bib29j8R+Mip7hZEAD0FZxujYZlKe8aIEjrzyHwJHPLQ8P+Pn4 + gs7Pi85DA6DxjZBxffOBed9c3wCg2FtbW/zt/0IDsIDBayNvvAHY5MFTnvKiBY688hwCR74LeZ+6wPPz + ovNGNwJKEerEerVRv3XIw+J/3HxoLhuAbb48W/CtrX7x2//FBmCQ62QoG4BNHjzlKS9a4MgrzyFw5DuR + 1+v1vmuB5+dF5yU3AKgT69VK/cCRzzUPi/9J8wlz2QDgGgDc86HQRMH7/X7x23/ZAMAZT4byGoBNHTzl + KS9a4MgrzyFw5DuTNxzuvGnsfNr2+XnReUkNAPaX9WqtfuRzzjttPmUuGwBcAzBa/KFRwa0bnGgA4Mwn + AxqATR485SkvSuDIK88hcOQ7lWcNwHsXeH5edF50A1Dur7nV+jEn17yz5jPmsgHANQA9vmWkUcHHGwB4 + wYMX7Zq8mVsBx8iK0MXJoDzlRQkceeU5BI589nl2Ln1ogefn4PubnJAX1QCs03iMuY28c+ayAcA1ADOL + P1QUFov/xQagv4zBi3JDXnIDYEXo6mRQnkPgyCvPIXDklecQOPKt550/f881Cz4/Jzsxr7EBGN/fMWc5 + HmNuK69sAHANQHHFf0hFcccbgCUNXqMj8pIaACtClyeD8hIFjrzyHAJHXnkOgSO/kDw0AAs+PyfZkVfb + AEzvL53teNBt5qEBwDUAlYs/VBS4bADwb49XNBmiGwArQtcng/ISBI688hwCR155DoEjv7C88+fvvnLB + 5+doO/MqG4DQ/vLfXZovuAagdvGHiiJ7Bw52Dl6lE/KiGgArgiaD8qIFjrzyHAJHXnkOgSO/0LzbbnvC + wF6ePqc2eoXn+2kHGwDbN41vQp574OAVT4bGBgBFYDFcxZkWOPLKcwgceeU5BI688hwCR155j3kMLgoL + nVcrveLz/bRnGgDsF/cvtL/JAkd+Y/NChY1yBpOhtgFAEVgMd3HGBY688hwCR155DoEjrzyHwJFX3gUl + NQAZnO+nPdEAYL+4f1X7myRw5Dc6L1TYRmcyGSobABSBxZirOKXAkVeeQ+DIK88hcOSV5xA48sq7qOgG + IJPz/bRHDQD2i/tXt7/RAkd+4/NCha11RpMh2ACgCCzG3MWBwJFXnkPgyCvPIXDklecQOPLKm1RUA5DR + +X7aRQOA/eL+Ne1vlMCR70ReqLCVzmwyzDQAKAKL0UpxwJFXnkPgyCvPIXDklecQOPLKm1VjA5DZ+X7a + D2C/uH8x+9socOQ7kQeFCht0hpNhogFAEViMVooDjrzyHAJHXnkOgSOvPIfAkVdeWLUNQIbn+wkbhwZg + lfWrFTjyWeaVChZ32plOhlEDgCKwGK0UBxx55TkEjrzyHAJHXnkOgSOvvGpVNgCZnu9HZt6DiftbKXDk + u5J3xFzcIyBY4HFnPBmKBgBFYDHaKo7ylBctcOSV5xA48spzCBz51LxgA5Dx+b7wWN54A7AJ4xEUOPJt + 5WHx3zY3NwAXij1YxOC1kVc8DdCcc7GVp7xogSOvPIfAkVdes2YagJbPz4vOKxuATRmPGYEj31Zez7xj + HpjrGwAUezDYnhjAzCYDGoCci6085UULHHnlOQSOvPLiNNEALOD8vOg8NACbNB4TAke+rTws/nvmobm+ + AUCxt7ex+A9GRc9wMqABaKs4XZsMylNetMCRV55D4MjnlDdqABZ0fl50HhoAjW+EjOubD8z75voGAMXe + 2trib/8XGoAFDF4beeMNwCYPnvKUFy1w5JXnEDjym55XNAALPD8vOi/4LIAmoU7mLs0XLP7HzYfmsgHY + 5suzA7i11S9++7/YAAxynQxlA7DJg6c85UULHHnlOQSOfBfyegs+Py86L7kBQJ1Yrzbqtw55WPxPmk+Y + ywYA1wAc4VsmC97v94vf/ssGAM54MpTXAGzq4ClPedECR155DoEj34k8PA1wwefnReclNQCoE+vVSv3A + kc8577T5lLlsAHANwGjxh0YF7/V6Ew0AnPlkQAOwyYOnPOVFCRx55TkEjnxn8s6fv/vKqfNp7uf76bzo + BgD7y3q1Vj/yOeedNZ8xlw0ArgHAxz4TGhV8vAGAFzx40a7JCz4LoElWhC5OBuUpL0rgyCvPIXDks847 + f/6eaxZ8fg6+v8kJeVENQLm/5lbrx5yc886ZywYA1wDMLP5QUVgs/hcbgP4yBi/KDXnJDYAVoauTQXkO + gSOvPIfAkVeeQ+DIt55XNgALPD8nOzGvsQEY398xZzkeY24rr2wAcA1AccV/SEVxxxuAJQ1eoyPykhoA + K0KXJ4PyEgWOvPIcAkdeeQ6BI7+QPDQACz4/J9mRV9sATO8vne140G3moQHANQCViz9UFLhsAPBvj1c0 + GaIbACtC1yeD8hIEjrzyHAJHXnkOgSO/sDxcA7Dg83O0nXmVDUBof/nvLs0XXANQu/hDRZG9Awc7B6/S + CXlRDYAVQZNBedECR155DoEjrzyHwJFfaB6+BWAvT59TG73C8/20gw2A7ZvGNyHPPXDwiidDYwOAIrAY + ruJMCxx55TkEjrzyHAJHXnkOgSOvvMCzAJq84vP9tGcaAOwX9y+0v8kCR35j80KFjXIGk6G2AUARWAx3 + ccYFjrzyHAJHXnkOgSOvPIfAkVfeBSU1ABmc76c90QBgv7h/VfubJHDkNzovVNhGZzIZKhsAFIHFmKs4 + pcCRV55D4MgrzyFw5JXnEDjyyruo6AYgk/P9tEcNAPaL+1e3v9ECR37j80KFrXVGkyHYAKAILMbcxYHA + kVeeQ+DIK88hcOSV5xA48sqbVFQDkNH5ftpFA4D94v417W+UwJHvRF6osJXObDLMNAAoAovRSnHAkVee + Q+DIK88hcOSV5xA48sqbVWMDkNn5ftoPYL+4fzH72yhw5DuRB4UKG3SGk2GiAUARWIxWigOOvPIcAkde + eQ6BI688h8CRV15YtQ1Ahuf7CRuHBmCV9asVOPJZ5pUKFnfamU6GUQOAIrAYrRQHHHnlOQSOvPIcAkde + eQ6BI6+8alU2AJme70dm3oOJ+1spcOS7knfEXNwjIFjgcWc8GYoGAEVgMdoqjvKUFy1w5JXnEDjyynMI + HPnUvGADkPH5vvBY3ngDsAnjERQ48m3lYfHfNjc3ABeKPVjE4LWRVzwN0JxzsZWnvGiBI688h8CRV16z + ZhqAls/Pi84rG4BNGY8ZgSPfVl7PvGMemOsbABR7MNieGMDMJgMagJyLrTzlRQsceeU5BI688uI00QAs + 4Py86Dw0AJs0HhMCR76tPCz+e+ahub4BQLG3t7H4D0ZFz3AyoAFoqzhdmwzKU160wJFXnkPgyOeUN2oA + FnR+XnQeGgCNb4SM65sPzPvm+gYAxd7a2uJv/xcagAUMXht54w3AJg+e8pQXLXDklecQOPKbnlc0AAs8 + Py86L/gsgCahTqzXvPUrBI58rnlY/I+bD81lA7DNl2cLvrXVL377v9gADHKdDGUDsMmDpzzlRQsceeU5 + BI58F/J6Cz4/LzovuQFAnVivNuq3DnlY/E+aT5jLBgDXABzhWyYL3u/3i9/+ywYAzngylNcAbOrgKU95 + 0QJHXnkOgSPfiTw8DXDB5+dF5yU1AKgT69VK/cCRzznvtPmUuWwAcA3AaPGHRgXv9XoTDQCc+WRAA7DJ + g6c85UUJHHnlOQSOfGfyzp+/+8qp82nu5/vpvOgGAPvLerVWP/I55501nzGXDQCuAcDHPhMaFXy8AYAX + PHjRrskLPgugSVaELk4G5SkvSuDIK88hcOSzzjt//p5rFnx+Dr6/yQl5UQ1Aub/mVuvHnJzzzpnLBgDX + AMws/lBRWCz+FxuA/jIGL8oNeckNgBWhq5NBeQ6BI688h8CRV55D4Mi3nlc2AAs8Pyc7Ma+xARjf3zFn + OR5jbiuvbABwDUBxxX9IRXHHG4AlDV6jI/KSGgArQpcng/ISBY688hwCR155DoEjv5A8NAALPj8n2ZFX + 2wBM7y+d7XjQbeahAcA1AJWLP1QUuGwA8G+PVzQZohsAK0LXJ4PyEgSOvPIcAkdeeQ6BI7+wPFwDsODz + c7SdeZUNQGh/+e8uzRdcA1C7+ENFkb0DBzsHr9IJeVENgBVBk0F50QJHXnkOgSOvPIfAkV9oHr4FYC9P + n1MbvcLz/bSDDYDtm8Y3Ic89cPCKJ0NjA4AisBiu4kwLHHnlOQSOvPIcAkdeeQ6BI6+8wLMAmrzi8/20 + ZxoA7Bf3L7S/yQJHfmPzQoWNcgaTobYBQBFYDHdxxgWOvPIcAkdeeQ6BI688h8CRV94FJTUAGZzvpz3R + AGC/uH9V+5skcOQ3Oi9U2EZnMhkqGwAUgcWYqzilwJFXnkPgyCvPIXDklecQOPLKu6joBiCT8/20Rw0A + 9ov7V7e/0QJHfuPzQoWtdUaTIdgAoAgsxtzFgcCRV55D4MgrzyFw5JXnEDjyyptUVAOQ0fl+2kUDgP0y + Y/+wn6U1vpEKFbbSmU2GmQYARWAxWikOOPLKcwgceeU5BI688hwCR155s2psADI730/7AewX9y9mfxsF + jnwn8qBQYYPOcDJMNAAoAovRSnHAkVeeQ+DIK88hcOSV5xA48soLq7YByPB8P2Hj0ACssn61Akc+y7xS + weJOO9PJMGoAUAQWo5XigCOvPIfAkVeeQ+DIK88hcOSVV63KBiDT8/3IzHswcX8rBY58V/KOmIt7BAQL + PO6MJ0PRAKAILEZbxVGe8qIFjrzyHAJHXnkOgSOfmhdsADI+3xceyxtvADZhPIICR76tPCz+2+bmBuBC + sQeLGLw28oqnAZpzLrbylBctcOSV5xA48spr1kwD0PL5edF5ZQOwKeMxI3Dk28rrmXfMA3N9A4BiDwbb + EwOY2WRAA5BzsZWnvGiBI688h8CRV16cJhqABZyfF52HBmCTxmNC4Mi3lYfFf888NNc3ACj29jYW/8Go + 6BlOBjQAbRWna5NBecqLFjjyynMIHPmc8kYNwILOz4vOQwOg8Y2QcX3zgXnfXN8AoNhbW1v87f9CA7CA + wWsjb7wB2OTBU57yogWOvPIcAkd+0/OKBmCB5+dF5wWfBdAk1In1mrd+hcCRzzUPi/9x86G5bAC2+fJs + wbe2+sVv/xcbgEGuk6FsADZ58JSnvGiBI688h8CR70Jeb8Hn50XnJTcAqBPr1Ub91iEPi/9J8wlz2QDg + GoAjfMtkwfv9fvHbf9kAwBlPhvIagE0dPOUpL1rgyCvPIXDkO5GHpwEu+Py86LykBgB1Yr1aqR848jnn + nTafMpcNAK4BGC3+0KjgvV5vogGAM58MaAA2efCUp7wogSOvPIfAke9M3vnzd185dT7N/Xw/nRfdAGB/ + Wa/W6kc+57yz5jPmsgHANQD42GdCo4KPNwDwggcv2jV5wWcBNMmK0MXJoDzlRQkceeU5BI581nnnz99z + zYLPz8H3NzkhL6oBKPfX3Gr9mJNz3jlz2QDgGoCZxR8qCovF/2ID0F/G4EW5IS+5AbAidHUyKM8hcOSV + 5xA48spzCBz51vPKBmCB5+dkJ+Y1NgDj+zvmLMdjzG3llQ0ArgEorvgP6REUd7wBWNLgNToyL7pQVoQu + TwblJQoceeU5BI688hwCR34heXfc8bSblnB+jrYj76PmSk3vL53teNBt5qEBwDUAlYs/9HEUuGwA7N8u + r3AyHDc3yorQ9cmgvASBI688h8CRV55D4MgvLO/mm2+6dQnn5yg7895nDiq0v/x3l+YLrgGoXfyhD6LI + 3oGDnYNX6cS8x5lrZUXQZFBetMCRV55D4MgrzyFw5BeaNxhsP9VeDp1Ta73i8/24/8w8I9s3jW9C3l94 + Bw7OYDJ8prlSKAKL4SrOtMCRV55D4MgrzyFw5JXnEDjyynvMYz7XHDqnVjqD8/2432GeEPaL+xfa32SB + I7+xeb9nDhW30ZlMhpeag0IRWAx3ccYFjrzyHAJHXnkOgSOvPIfAkVfeBb3MHDqnBp3J+X7cv2keCfvF + /ava3ySBI7/Rea83h4pb64wmw6+bZ4QisBhzFacUOPLKcwgceeU5BI688hwCR155F/Umc+icOuOMzvfj + fp25EPaL+1e3v9ECR37j837cHCpupTObDPgq4PXmkVAEFmPu4kDgyCvPIXDklecQOPLKcwgceeVd1M3m + 0Pl0xpmd78f9H80a3znzvsccKm7QmU6Gf24uhCKwGK0UBxx55TkEjrzyHAJHXnkOgSOvvEn9S3PoXDrh + TM/3pb8N+8X9a9rfKIEj34k86OvNoeLOOOPJ8EEz7nSkyaC8aIEjrzyHwJFXnkPgyC8771LzR8yhc+nI + GZ/vC/f7/a/h/jXtb5TAke9EXqnPMwcLPO7cJ0Ov13sJi9FKccCRV55D4MgrzyFw5JXnEDjyypvVt5qD + 59HSuZ/vwV166YnnRu5vo8CR70reEXNxj4DG74Kuw2Qw/hNXXXXl/SxMbsVWnvKiBY688hwCR155s3qS + +SFz8FwKr8n5/q+uvvrKT47Y30aBIx9Tv0aBI59rHhb/bXPRAOyYKyfEhWIPWh+8ReQNh8M/fPKTb7tl + zuJ0bTIoT3nRAkdeeQ6BI7+KvAPzH5iD51J4kefnlvMeuOeeZ17XsL+NAkc+pn6NAkc+17yeecc8MI/u + Ehi8FwCKPRhsTwxgppNh5N3d3R/Hc67t9WShqOacB095yosWOPLKcwgc+U3Iw8n+R83Bcym8jPNzW3m7 + u8PfadjfRoEjH1O/RoEjn2seFv8989A80QC8yjxT7O1tLP6DUdFznQyBvH9rDj76sEpWjK5NBuUpL1rg + yCvPIXDkV5GHE/33mWfOo6WXfH5O9nTe/v7eq2v2t1HgyMfUr1HgyOea1zcfmPfNMw3APzJPFHtra4u/ + /V9oAHKeDBV5rzQfNTfKCtG1yaA85UULHHnlOQSO/Cry8BEvvi8/fm6c8IrOz9EO5R0eHnxDxf42Chzr + FVO/RoEjn2seFn98S+7QXDYA23y50B3mUcG3tvrFb/8XG4BB1pOhJu83zLjhRaWsEF2bDMpTXrTAkVee + Q+DIryLv8ebfNofOjYVXfH5udFXeYDB4sr2eLNSJ9YqpX6PAkc81D4v/SfMJc9kA4BqAI3xLIXQDeLYy + vltZ/PZfNgBw7pOhIe8B80vMh+YJWRG6NhmUp7xogSOvPIfAkV923iVm3OjnE+bQObFwJufnStfk4THA + SR/xQqgT69VUvyiBI59z3mnzKXPZAOAagInFv9RP9Xq9iQYAXoPJEHx/wO83f7P5WnNXJ4PylBclcOSV + 5xA48svMwy3R8XA03BgtdA4cOcPz84Qb8l5tThLqxHrV1S9a4MjnnHfWfMZcNgC4BiDcONnC/4/GGwB4 + TSZDqh8x7lePHdv/9lOnLv1yfJf01lsff+sTnvC4xx8cHDtlr6N7TjI48Mgprbx4K095KVbehbzBYHCr + vf4ZZtwK/VfNeC5K6Jw34czPzzF5X2GOli16XVz8wZ8zlw0ArgEIL/72Qn93d/i4iw1Af50mQ5KVp7wU + K095KVbewvPQ5FxhjpKtbV1d/JFTNgC4BmB0xf+M8KJ5YIv/76EBWKPJkGTlKS/FylNeipW3lDxc2B0l + W9O6vPjDaABwDUD14g/hDebB1tbWN9k/x4sd7RVNhmgrT3kpVp7yUqy8peXhK+uNsvWs64s/jGsA6hd/ + CG8yb/d6vRvsn9MFb/QKJ0OUlae8FCtPeSlW3tLyHjFfbq6VrWVa/FPy7I1oAMqvBvy6ebrwlV7hZIiy + 8pSXYuUpL8XKW2reL5hrhUWPi59vMZwSOPKdyINwhWWo+DNe8WRotPKUl2LlKS/Fylt63t8xVwqLHhe/ + VhZDcOQ7kVdq3/whc2gARs5gMtRaecpLsfKUl2LlLT3vvWbc1jgoLHpc/FpZDMGR70TetF5uDg1C4Qwm + Q62Vp7wUK095KVbeSvK+3RwUFj0ufq0shuDIdyIvpOvMD5tnBiKTyVBp5SkvxcpTXoqVt5K8B83B7/5j + 0ePi18piCI58J/LqhNstTgxEJpOh0spTXoqVp7wUK29lea8wzwiLHhe/VhZDcOQ7kdekZ5hHg5DRZAha + ecpLsfKUl2LlrSwPX/17onlCWPS4+LWyGIIj35W8I+bGewT8uDmnyRC08pSXYuUpL8XKW2neD5snhEWP + i19bi2EXF/9tc2MD8GQbpEePHh14B2/Gc06GGStPeSlWnvJSrLyV5uE6tBvNI2HRM+e8uOae1zPvmAfm + 5lsE24C9ZnwAVzgZZqw85aVYecpLsfJWnvd95pFsPdLiP18eFv8989Bc3wDgRfPJ66675sk7O0c/ksFk + mLDylJdi5Skvxcpbed5fmk+YC9lapMV/vjys5wfmfXN9A2AvoFPA84PxHOEzx44d+9YNm1wTVp7yUqw8 + 5aVYea68F5oL2RqkxX++PCz+WM8PzWUDsM2XJ2UvYPFHp3DCXDQAd931jHM2eG+yl0MDVeuOTNaRlae8 + FCtPeSnuSN4bzD1zFxfrRSz+J81Yz8sGANcAlM/+uSj8RzM+I8AbywYAzxPGxm83B28OVOVMJ9fIylNe + ipWnvBQrz5X3CXPxtT+sO+acF9d1yMP6jXW8bACwvlcu/ugM0CGUDQA6h/HPCb7LHBq0GWc6uUZWnvJS + rDzlpVh57rx/Ye7qYt123lnzGXPZAOAv+8VfVmZkL+B7gfhsoGwA8JnB9EUCR82NHwVkPLkKK095KVae + 8lKsPHce/vSPhauLi/Ui8s6ZywYA63nl4o/PCXBVYNkAoFOo+orALeaPmUMDmPPkKqw85aVYecpLsfLc + eR80X2frjhb/9vLKBmD6L/mTwovmsgHAZwThTuGivto8M4gZT67CylNeipWnvBQrb668L7J1R4t/u3lo + AHANQPXiD+ENZjQAuAagafEv9e/MowHMfHIpT3lJVp7yUqy8ufK+zdYdLf7t5+EagPrFH8KbzLgGYPbq + wGoNzb9pzn1yKU95SVae8lKsvLnyXn/llVfs2tqzbovr5uTZG9EApCz+pc7YoL8z48mlPOUlWXnKS7Hy + 5sp727Fjx/An6nwWwymBI9+JvCRhI9a9fdJwuPOhDCeX8pSXZOUpL8XKmyvvPTs7Rx/LxaqVxQsceeUt + WtgIN3b16dOnnmuT4RMbPFmVp7wkK095Ke5Y3se2tmz5yHgxBEe+E3lJwka4sdHGT506+QU2GR6wl0MD + XuvMJ6vylJdk5SkvxR3L+7gt/s+eXj/4by3WEQJHvpW8JGEj3Fho419g1u2Ca6w85aVYecpLceZ5n+j3 + +5/H9SK0fiQLHHnlLVrYCDdWt/FPMVfeKGjcmU9W5SkvycpTXoo7lvch+83/k7le1K0f0QJHXnmLFjbC + jcVs/Dnmj5hDE6Fw5pNVecpLsvKUl+KO5X1Ai392eXj2T/M9AiBshBtL2fjjzf/LPDMhMp+sylNekpWn + vBR3LO93dbV/dnlY/HHfn+ibBOGOQp6NX2H+DXNXJ7/ylJdk5SkvxZnnvWFvbxdrRZuLlxb/+fJ6Ztzx + F3f+jbpFMG7UgHsKezeOJwh+hzn3yao85SVZecpLccfyXnrDDddhocl5Mezi4o9n/eCZP/UNAF404ylC + eJpQ2QC4N97v915gk+nBliZX7pNfecpLsvKUl+KM83AB+JdjneB60dbipbz58rCe4ym/eNpvfQNgL6BT + wPOD8RzhsgGYe2euvvrKT97dHb4lo8laWHnKS7HylJfiDuX9ivma8nxvbmvxUt58eVj8sZ4fmssGYJsv + T8pewOKPTuGEuWwAcA1AKztz++1Pfez+/t732+R6xF4OTaJaZzz5CytPeSlWnvJSnGke7v3yr8xHp8/3 + dE6LYdfyyr/kYz0vGwB8NDP77B/8RzM+I8AbywYA1wAsYmeeZH6jOTShgs508o+sPOWlWHnKS3Gmeb9m + fqJ5HRbDLuZh/cY6XjYAWN8rF390BugQygYAnUPcdwWnZFzMzuACwX9q/rA5NLlGznTyj6w85aVYecpL + cYZ5HzB/rbn4UzLO6zy/153vowWOvPIcAmfGX+7xF/yyAcBf9nt8y6TsBXwvEJ8NlA0APjNY5OI/rsvN + 328OfiyQ4eSfsPKUl2LlKS/FmeXhz/3fYz5tLoTzOs/vsef7WoEjrzyHwJHHtXtlA4D1vHLxx+cEuCqw + bADQKSxr8R/XNeaXmx8yFxMus8k/Y+UpL8XKU16KM8rDORnn5qvMI+G8zvO753w/I3DklecQOPLIKRuA + +r/k40Vz2QDgM4Jwp9Ag49ramdvMr7JJ+Ugmkz9o5SkvxcpTXoozycPC/4PmW8wTwnmd5/d5z/eFwJFX + nkPgyJdZaABwDUD9L/N4gxkNAK4BWPXiXwjcVVddec/+/v5/sIn6sRVN/korT3kpVp7yUpxBHq7L+jfm + 68wzwvmZ5/fWzvfklecQOPLjebgGoPkv+XiTGdcAzF4dGCHjFrozT3rSrY8/fvzw62yy4numj5pDE7bS + GRxMtVae8lKsPOWlOCEP12D9nPm55n1zUNPnZ7q18z2tvEiBI+/LszeiAchy8afH8642v8g88YyBKq/w + YIqy8pSXYuUpL8WRef/N/EIznt1SK5yHeT6uOj8nCRx55TkEjnwreUnCRrixVjYOjnxsHpqBv2/+r+aP + mscn9aoOpmgrT3kpVp7yUlyThz/vv8b8VeZz5ijhPMzzcez5uVbgyCvPIXDkW8lLEjbCjbWycXDkvXn4 + PurTzV9j/mGb5G+1yf5QYPIHD5Ym1xxMwfc3WXnKS7HylJfisbyHdneHv7e/v/djh4cH37i9vY1zZPI5 + Gudhno+95+cJgSOvPIfAkW8lL0nYCDfWysbBkW817447nnbTuXOXf+qll5583sHBwTf1er3vtJdfbf4F + 8/8w/6n5fU22g+l9OztHPzAc7oyMf+O/h97fZOUpL8XKU16N/8T8ZvPPm19l/vZ+v/e1J05c8pXnzl3x + KXfeeccNbZ1PmdPa+Zk5yksUOPKt5CUJG+HGWtk4OPLKcwgceeU5BI688hwCR155DoEjrzyHwJFX3qKF + jXBjrWwcHHnlOQSOvPIcAkdeeQ6BI688h8CRV55D4Mgrb9HCRrixVjYOjrzyHAJHXnkOgSOvPIfAkVee + Q+DIK88hcOSV55BxePZP3N1+sRFurK2NK0950QJHXnkOgSOvPIfAkVeeQ+DIK88hcOTbysPij/v+RN8k + CHcUamvjGjzlRQsceeU5BI688hwCR155DoEjrzyHwJFvK69nxh1/ceffqFsE417CuKdwjjujPOVFCxx5 + 5TkEjrzyHAJHXnkOgSOvPIeMw+KPZ/3gmT/1DQBeNOMpQniaUNkAbHJxlKe8aIEjrzyHwJFXnkPgyCvP + IXDku5KH9RxP+cXTfusbAHsBnQKeH4znCJcNwCYXR3nKixY48spzCBx55TkEjrzyHAJHvit5WPyxnh+a + ywYAN86blb2AxR+dwglz2QDgGgAVO0LgyCvPIXDklecQOPLKcwgceeU5BI688hwCR76tvPIv+VjPywYA + 1wDMPvsH/9GMzwjwxrIBwDUAKnaEwJFXnkPgyCvPIXDklecQOPLKcwgceeU5BI58m3lYv7GOlw0A1vfK + xR+dATqEsgFA5xD3XcEpGafBU160wJFXnkPgyCvPIXDklecQOPLKcwgc+Tbz8Jd7/AW/bADwl/0e3zIp + ewHfC8RnA2UDgM8MtPhHCBx55TkEjrzyHAJHXnkOgSOvPIfAkVeeQ+DIt52Ha/fKBgDreeXij88JcFVg + 2QCgU9DiHyFw5JXnEDjyynMIHHnlOQSOvPIcAkdeeQ6BI7+IvLIBqP9LPl40lw0APiMIdwoNMk6Dp7xo + gSOvPIfAkVeeQ+DIK88hcOSV5xA48ovKQwOAawDqf5nHG8xoAHANgBb/CIEjrzyHwJFXnkPgyCvPIXDk + lecQOPLKcwgc+UXm4RqA5r/k401mXAMwe3VghIxTsZUXLXDklecQOPLKcwgceeU5BM4MHjmllRcpcOZ8 + 6mdvRAOgxT9C4MgrzyFw5JXnEDjyynMIHHnlOQSOvPIcAkc+y7wkYSPcWCsbB0deeQ6BI688h8CRV55D + 4MgrzyFw5JXnEDjyylu0sBFurJWNgyOvPIfAkVeeQ+DIK88hcOSV5xA48spzCBx55S1a2Ag31srGwZFX + nkPgyCvPIXDklecQOPLKcwgceeU5BI688hYtbIQba2Xj4MgrzyFw5JXnEDjyynMIHHnlOQSOvPIcAkde + eYsWNsKNtbJxcOSV5xA48spzCBx55TkEjrzyHAJHXnkOgSOvvEULG+HGWtk4OPLKcwgceeU5BI688hwC + R155DoEjrzyHwJFXnkPG4dk/cXf7xUa4sbY2rjzlRQsceeU5BI688hwCR155DoEjrzyHwJFvKw+LP+77 + E32TINxRqK2Na/CUFy1w5JXnEDjyynMIHHnlOQSOvPIcAke+rbyeGXf8xZ1/o24RjHsJ457COe6M8pQX + LXDklecQOPLKcwgceeU5BI688hwyDos/nvWDZ/7UNwB40YynCOFpQmUDsMnFUZ7yogWOvPIcAkdeeQ6B + I688h8CR70oe1nM85RdP+61vAOwFdAp4fjCeI1w2AJtcHOUpL1rgyCvPIXDklecQOPLKcwgc+a7kYfHH + en5oLhuAbb48KXsBiz86hRPmsgHANQAqdoTAkVeeQ+DIK88hcOSV5xA48spzCBx55TkEjnxbeeVf8rGe + lw0ArgGYffYP/qMZnxHgjWUDgGsAVOwIgSOvPIfAkVeeQ+DIK88hcOSV5xA48spzCBz5NvOwfmMdLxsA + rO+Viz86A3QIZQOAziHuu4JTMk6Dp7xogSOvPIfAkVeeQ+DIK88hcOSV5xA48m3m4S/3+At+2QDgL/s9 + vmVS9gK+F4jPBsoGAJ8ZaPGPEDjyynMIHHnlOQSOvPIcAkdeeQ6BM4NHTmnlRQqceRH1w7V7ZQOA9bxy + 8cfnBLgqsGwA0Clo8Y8QOPLKcwgceeU5BI688hwCR155DoEjrzyHwJFfRF7ZANT/JR8vmssGAJ8RhDuF + BhmnwVNetMCRV55D4MgrzyFw5JXnEDjyynMIHPlF5aEBwDUA9b/M4w1mNAC4BkCLf4TAkVeeQ+DIK88h + cOSV5xA48spzCBx55TkEjvwi83ANQPNf8vEmM64BmL06MELGqdjKixY48spzCBx55TkEjrzyHAJHXnkO + gSOfR569EQ2AFv8IgSOvPIfAkVeeQ+DIK88hcOSV5xA48spzCBz5LPOShI1wY61sHBx55TkEjrzyHAJH + XnkOgSOvPIfAkVeeQ+DIK2/Rwka4sVY2Do688hwCR155DoEjrzyHwJFXnkPgyCvPIXDklbdoYSNmXGCA + qwxLz3u7YOUpL0rgyCvPIXDklecQOPLKcwgceeU5BI58K3lJso3gegF8tQDfLyzd/FWDCoEjrzyHwJFX + nkPgyCvPIXDklecQOPLKcwgceeUtWtiIGTcVwJ2FSs9zu2DlKS9a4MgrzyFw5JXnEDjyynMIHHnlOQSO + fCt5ScJGzLidIO4pXHqe2wUrT3nRAkdeeQ6BI688h8CRV55D4MgrzyFw5NvKw7N/4lh7Y/mIYDwjoHT1 + gwUaBI688hwCR155DoEjrzyHwJFXnkPgyCvPIXDkleeQcVj8cd+f5gYAGzHj9sB4RkDpeW4XrDzlRQsc + eeU5BI688hwCR155DoEjrzyHwJFvMw93/MWdf+sbAHtD+YhgPCOgNP7tvWmQ8pQXLXDklecQOPLKcwgc + eeU5BI688hwCR34RefUNAN+MPxPgjaXnuV2w8pQXLXDklecQOPLKcwgceeU5BI688hwCR36RebUNAC46 + mDBfckl5ykuR8pSXIuUpL0VlzcbNl1xaz7zHPOb/B0OTbCtTdWcxAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAABsaSURBVHhe7d3xcevG1cbhlOASUkJKcAkuISW4hHTg + ElyCS0gJLiElpITvwzvXnMjykS4lgTzYs88z8/srk2Qp8hLLxQL4GwAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAnO4fRz8f/Xr076P/k94pn5F8VvKZyWcHgIX8dJQv8f8eVV/y0r3lM5TPUj5T + AFzQD0f/OvrPUfVFLn21fLbyGctnDYALyJeyX/t6Vvms5TMHQJMfj/ziV1f57OUzCMCTZAn2l6PqS1l6 + dvksOi0A8GB/P/r9qPoilrrKZzKfTQAeIJdlOdevq5bPpksHAU7m4K8VMgkAOJGDv1bKJADgBDmv6uCv + 1cpn1p4AgE/Kzmob/rRq+ey6OgDgE1zqp9XLZxiAD8gNVqovVGm13CwI4APc4U9TymcZgDvkPuvVF6m0 + ap4dAPAd2TRl17+mlc+0DYEA7/DrX1OzCgDwDuf+NTV7AQDe8NNR9cUpTSmfcQBe+fWo+tKUppTPOACv + 2Pyn6eUzDsALeXhK9YUpTcuDggBe+Pmo+rKUppXPOgB/cP5fu2QfAMAL/z6qviylaeWzDsAfqi9KaWoA + /KH6kpSmBsAfqi9JaWoAHP5+VH1JSlMD4PDjUfUlKU0tn3mA7XkGgHbLMwEADh4BrN3yaGCAwy9H1Zek + NLV85gG25yZA2i03AwI4/H5UfUlKU8tnHmB71RekND2Arf1wVH05StPLZx9gW+4BoF1zLwBga+4BoF1z + LwBga+4BoF1zLwBga78eVV+O0vTy2QfYlnsAaNfcCwDY2n+Oqi9HaXr57ANsq/pilHYJYEt/P6q+FKVd + yr8BgO24B4B2z70AgC3986j6UpR2Kf8GALbjHgDaPfcCALbkHgDaPfcCALbkHgDaPfcCALb036PqS1Ha + pfwbANhO9YUo7RbAVv5xVH0ZSruVfwsA23APAOlb7gUAbOXno+rLUNqt/FsA2IZ7AEjfci8AYCu/HVVf + htJu5d8CwDbcA0D6lnsBsI08/SrnvDLr9Sx4SdLO5TiY42GOi2OfDpmHXvx+VP0BJEnSt+PkmIdE5YX4 + pS9J0v3luLnsROCHI+d5JUn6fDmO5ni6jNzZyn3eJUn6ejmeLnHHyCxZVC9AkiR9vkufEnB7V0mSHtcl + bx2dyxcs+0uS9LhynL3c5YIu8ZMk6fHleHsZHuwiSdLzusRDpHJ5gqV/SZKeV4677ZcHeqqbJEnPr/1J + ku7yJ0nS88vxt01uTFANSpIkPb62GwRZ/pckqa+20wDu9S9JUl85Drew+1+SpL5yHG5RDUaSJD2vFtVA + JEnS83q63Iu4GogkSXpeLaqBSJKk59WiGogkSXpeLaqBSJKeG9dXvW9n1aIaiCTpuXF91ft2Vi2qgUiS + nhvXV71vZ9WiGoik65W7hX206n9H14zrq963s2pRDUTSc8odwHKg/vUo9wP/+ejHP8plumfKc8dv/9v/ + PMr/3y9H+f/3RND+uL7qfTurFtVAJJ1bDrA50Oag+9NRDsJXlKeSZXwZ529Hvx9Vr0fnx/VV79tZtagG + Iunz3X7V5yCaA31+ea8ur+M2KfD8kMfE9VXv21m1qAYi6f5yQMyBMcv3bc/1frKcnshphJy6MCE4J66v + et/OqkU1EEnvl6XxnD+/6lL+s2XikwmQjYefj+ur3rezalENRNJfy8EtB7mzN+dNk1MeWR3Iqkj1d1Qd + 11e9b2fVohqIpG/ll76D/ueZDNwf11e9b2fVohqItHPZsZ8Nbw7658pkIJMpVxbUcX3V+3ZWLaqBSDuW + X6m5BI7Hy54BGwj/HNdXvW9n1aIaiLRLOQD5td/ntirgRkSsoHrfzqpFNRBpejng5Nw015HVl52vIuD6 + qvftrFpUA5GmlgOMZf5ry6WVOT1QvX+T4/qq9+2sWlQDkaaVA79r9teS0zI7TQS4vup9O6sW1UCkKTnw + ry8TgR0uI+T6qvftrFpUA5FWL+f4LfXPkonc5D0CXF/1vp1Vi2og0qplV392lTNXJnYTrxrg+qr37axa + VAORViz35p/w5D3uk8s3J91HgOur3rezalENRFqpLAvv8hQ+/mzS/gCur3rfzqpFNRBphSz3c5P9Aauf + FuD6qvftrFpUA5GuXn71We7npXwechqo+rysENdXvW9n1aIaiHTV8qvf7n7es+pqANdXvW9n1aIaiHTF + /OrnXiuuBnB91ft2Vi2qgUhXyrl+PiurAatcKcD1Ve/bWbWoBiJdpTw73g5/viKrAStcKcD1Ve/bWbWo + BiJdodwH3pI/Z8kqUvU5u0pcX/W+nVWLaiBSZ1my9aheHuHKpwS4vup9O6sW1UCkrrJ725I/j5RVpZxa + qj5/nXF91ft2Vi2qgUgd5Y5+lvx5lp0eNazr16IaiPTs8mUMz3b1fQHapxbVQKRn5hI/OuXGUqtcKqi5 + tagGIj0rm/24guw7MQlQZy2qgUiPLl+2NvtxJfk8XnFzoPaoRTUQ6ZE5+HNVV71CQPNrUQ1EelQO/lyd + SYA6alENRHpE+VL9+xFcnUmAnl2LaiDS2eXL1DX+rMQkQM+sRTUQ6cwc/FmVSYCeVYtqINJZ5Zy/ZX9W + ZhKgZ9SiGoh0Rjb8MYVJgB5di2og0ldz8GcakwA9shbVQKSv5uDPRDmdlclt9ZmXvlKLaiDSV3J7XybL + 5NYkQGfXohqI9Nk82Icd5AFC1edf+mwtqoFIn8kjfdlJVrqqfwfSZ2pRDUT6aNkcBbvJpLf69yB9tBbV + QKSP9J8jN/phV/8+qv5dSB+pRTUQ6d5c7sfuMvnNJLj69yHdW4tqINK92fH/GD8eZaPZv45+OcqvzHTv + deiZmN3+O78d5X8n5X/XhO18+ZtW74N0by2qgUj3ZNPf1+XXYw7KOTjnYP3MX5KZTOQ9zJUbJgVfl79j + 9XeW7qlFNRDpe+Xg4bz/5+SXfX7VX/GucpmEmBB8XlZbqr+r9L1aVAOR3st5/4/JRCmnSlY7OGQ1IisE + mbBwH/sB9NlaVAOR3svNfu6z4kH/rTLpy6qFid/35ZRO9TeU3qtFNRDprXJA4225V3wOlJNvFZtTF5nc + OAX0tuzpqP520lu1qAYiVeWg5ku/ll99OX9e/d2mdlsVyKSHv7riHg9dtxbVQKQq54L/Kr+EnfP9tlfA + RODPXBqoj9SiGoj0Okv/f5bJkAP/XzMR+DOnAnRvLaqBSC+z9P8/Oy71f6acGvCZ+capAN1Ti2og0svs + +v92MMuv2+rvo7pMHH12XBWg+2pRDUS6lV+7u8tBbPKu/keXX8C7Xz6YFZHqbyPdalENRLq18xd3zmVb + 7j+vnA/fVVaQTCL1Xi2qgUgpv1p25Vf/Y9p5NSBXjFR/Eym1qAYi7brxL6/Z/dwf2857A2wI1Fu1qAYi + 7fgFnV+mLu17Xplo7TbJtCFQb9WiGoj2LgfB3Vie7WnHUwJWmFTVohqI9i4Hw524vK+3nBLIL+NdZHNp + 9XfQ3rWoBqJ92+myP+f7r9VOE0+TTr2uRTUQ7dsuv8Ry8Lch63rtcqmgVQC9rkU1EO3ZLr/+HfyvXX4d + 78AqgF7WohqI9myHX//ZcObgf/12mARYBdDLWlQD0X7t8Os/X7hu7rNOO0wCrALoVotqINqv6c/6t+y/ + ZtMnAVYBdKtFNRDt1fTr/h381276LamtAii1qAaivZp++ZWD//pN/oy6O6BSi2og2qecE5/Mr6s5TT5N + 5amTalENRPs0+brrvLbqNWvNMlmdettgt6JWi2og2qdsQpoovxar16u1y+mc7OmYyIOo9q5FNRDtUW6D + O5HL/WY39XNrxWrvWlQD0R5NPadq09/8Jj6u2iWBe9eiGojmN/XSv1wyVr1ezWvifgAPp9q3FtVANL+J + 11a7nGqvJu4HsBlw31pUA9H8pm3+y4HAJqr9mjiRtX9lz1pUA9Hs8stpGkv/+zbtIVbuXbFnLaqBaHbT + NlBZ+t+7aRNal7DuWYtqIJrdtOV/u/417YZWTmftV4tqIJrbtF9LWc2oXqf2KufNJ20IdEprv1pUA9Hc + Ji3/5wvfhindmvToYKcB9qtFNRDNbdLyvzun6XWTPt8mt3vVohqIZjZp+d9d01SVp+pN4WqAvWpRDUQz + m3TNtC9HvdWUywLdFGivWlQD0cymfDH69a/3mrIKkD0u1evTzFpUA9HMprBDWt9ryl4Al7juU4tqIJrX + lEeo2vmve5pyRYDJ7j61qAaieU25/M91/7q3CfcFcJfLfWpRDUTzmvLoVHdI071NuTtg9do0rxbVQDSv + Cfwa0kfKZHGCbGqsXp9m1aIaiGY1ZVe0S//00XJHvdXZB7BHLaqBaFYTlkJdEqXPNGEzoNsC71GLaiCa + 1YRfQW6Kos+2+mZA973YoxbVQDSrCddE5zLG6rVJ3yuTx9W59HV+LaqBaE754lid5X99pQn3wLARcH4t + qoFoThM2AFr+11eaMAn25Mv5tagGojlN2ABo97++2ur7YEyC59eiGojm5PyntP6TMHMjr+p1aU4tqoFo + Tqs/AdAXn84oD9VZXfW6NKcW1UA0p9W597/OavXLAd0Ge3YtqoFoRhM2P7n8T2e1+j4AVwLMrkU1EM1o + whUAfvXorFbfEOuWwLNrUQ1EM1r9+mfX/+vMVp8QuxRwdi2qgWhGq//i8fQ/ndnqp8Q8E2B2LaqBaEar + TwD84tHZrbwR0IR4di2qgWhGq18C6AZAOruV/014KNDsWlQD0YxWnwDY9ayzy2WlK6tek2bUohqIZpSb + 6KzMHQB1dqufFqtek2bUohqIZrS66jVJX2n1K2NcFju3FtVANKOVuQWwHtHqlwI6LTa3FtVANKOV2fGs + R7T6MwFMAObWohqI1i9LhSszAdCjWpkJwNxaVAPR+q2+1OkhQHpUKzMBmFuLaiBav9UnAG4CpEe1Mv8u + 5taiGojWzwRAqluZfxdza1ENROtnAiDVrXx/DP8u5taiGojWzwRAqlv5Dpn+XcytRTUQrZ8JgFRnAqAr + 1qIaiNbPBECqMwHQFWtRDUTrZwIg1eWpeqvy72JuLaqBaP1MAKS6lfl3MbcW1UC0fiYAUt3K/LuYW4tq + IFq/1ScAPx1Vr0v6aivL0wyr16T1a1ENROvnWQBS3coysa9ek9avRTUQzWhlJgB6RKuvjJkAzK1FNRDN + aGU/HFWvSfpKJgC6ai2qgWhGq6tek/SVfj1a2e9H1evS+rWoBqIZrXy9c2QfQ/W6pM+WXfQrq16TZtSi + GohmtPIdz8Jyp84uV5esrHpNmlGLaiCa0eoTgF+OqtclfbaV/01kRa96TZpRi2ogmtHPRyvL+KvXJX22 + lbkyZnYtqoFoRquf7/SFpzPLBrqV+fcwuxbVQDSj1Xc8R/W6pM+0+r8HtwGeXYtqIJrR6tc8h8uedFar + nxIzAZhdi2ogmtF/j1ZnI6DO6h9HK3NVzOxaVAPRnFb3z6PqdUkfacJk2GrY7FpUA9GcVr8U0KVPOqM8 + RW911evSnFpUA9GcVr/xSfjlo6+2+vn/nL6oXpfm1KIaiOa0+qWAYR+Avtrqt8XORL56XZpTi2ogmtOE + KwFc/6yvlGdKrM4VAPNrUQ1Ec5rw5RfZxFW9Pul7ZQVpddnDUL02zalFNRDNKs/WX11u4lK9Nul7rX75 + X3gy5vxaVAPRrFa/EiCcBtBnmrAClgl89do0qxbVQDSrCRsBw68gfbQJn30bAPeoRTUQzWrCRsCwEUof + bfXd/+Fzv0ctqoFoVhPughZuCqSPNGXi6xbAe9SiGojmNWEjVNgNrXvLbaQnqF6b5tWiGojmtfqd0G5s + BtQ9Tbn81ed9n1pUA9G8JtwL/cZmQH2vKRtfnf/fpxbVQDSvKfsAwhMC9V75rE+490U4/79PLaqBaGZT + 9gGEVQC91ZRf/67/36sW1UA0sylfjGEVQFWTfv27/n+vWlQD0czyWN1JrALodZMmuW5/vVctqoFobhNu + jHJjFUAvm/TrP0xw96pFNRDNbcq10Tc2SenWpM929utUr1Fza1ENRHObdDlguE5aadrprTzCuHqdmluL + aiCa3aRl0vBlqQlPvHzJ8v9+tagGotlNOw2QCU3O/1avVfPLBHASy/971qIaiGY35SEpL7lkas+mbfwL + K1p71qIaiOY36WqAGw8K2q9M/Kax/L9nLaqBaH5THg70klMBezVt6T+sZO1bi2ogml9+ZUzkqoA9yq7/ + aUv/4eY/+9aiGoj2aNrO6RvnUOc36bkWN5nQVK9Ve9SiGoj2KL82psovxOo1a/2mXcVyk9Ny1evVHrWo + BqJ9mriMGvYDzGzypNXmv71rUQ1E+zTp4SmvZZnYJGBO0+7295K9K2pRDUT7NHUz4I0HBs1o6qa/G5ew + qkU1EO3V1HOqNyYBa5dVnImb/m5yT47qdWuvWlQD0V5NvDPgay6vWrPpB//w2VRqUQ1E+zX1ksCXfNGu + 1Q4Hf7/+datFNRDt1w6rAGESsEY7HPwjm3Cr16/9alENRHu2wypAmARcu10O/i5V1ctaVAPRnu2yChAm + Addsl4N/+PWvl7WoBqJ922UVIFwdcK12Ovj79a/XtagGon3baRUgTAKu0fTr/F/z61+va1ENRHu30ypA + 5FenX2N95SY4Ox387fxXVYtqINq73VYBIgcgDxB6fpNvRf0W+09U1aIaiDT97oBv8Sjh55QVl5+OdpPV + purvIbWoBiLlGQE7Lcu+lAOTUwKPKytMu3628tqrv4nUohqIlHZcnr3JAcqX9fnlmfe7ysSy+ptIqUU1 + EOlWNiztLAcsqwFfL5OpXS7xq2RC6Xn/eq8W1UCkWztuCHwtX94e1/q5Mnna+Vf/jcv+9L1aVAORXrbj + Zq1KLo90pcD9Zbf7ruf6X3LZn+6pRTUQ6WU7bwis5AoJy7lvt/ty/2v2kuieWlQDkV6Xy+P4n0yIsqxr + f8D/yoFut5tIfU9Of1R/K+l1LaqBSFW+3P8qE4F8ye+8IuDAX8vSvwmi7q1FNRCpyqmA9+XUwE7LvTnH + v/tVIu+x9K+P1KIaiPRW+dLnfTn/nb/TxF9/2QSZFQ8TwfdZ+tdHa1ENRHovVwXcL3+r1S8hzMpP9oDY + 2Hef/J0s/eujtagGIr1Xvtz8AvyY/L0yGVhlZSC/9LPJ0UH/41wqqs/UohqI9L1yfpPPy4E1y8RZHbjC + hCAHrfzKzyTF5O7zPExKn61FNRDpnnZ+VsDZspkuB9/8TTMpeNSvyEw2MnnLSkQmIHbvnyfvX/U3l+6p + RTUQ6d4cQB4rv8bzN045YGeCcCu/NnMwf9nL/zzlyoT8dy3lP5bz/vpqLaqBSPeWLz2XgrGzTNKc99dX + a1ENRPpI+fJz3phd5XRK9e9C+kgtqoFIH839AdhRTrNU/x6kj9aiGoj0mfJlCLuw6U9n1qIaiPTZsukM + prPpT2fXohqI9JXsOGcyD/nRI2pRDUT6SvlyNAlgIjv+9ahaVAORvlomAa4MYBIHfz2yFtVApDNyeSCT + 5EZL1edcOqMW1UCkszIJYALX+uvRtagGIp2ZSQArc/DXM2pRDUQ6O5MAVuTgr2fVohqI9IhMAliJg7+e + WYtqINKjMglgBQ7+enYtqoFIj8wkgKvK59Juf3XUohqI9OjcLIirycE/k9Pq8yo9uhbVQKRnZBLAVeT2 + vg7+6qxFNRDpWWUS4AFCdPJgH12hFtVApGf38xE8WyafDv66Qi2qgUgdZee1zYE8y7+Oqs+h1FGLaiBS + V64Q4NHy+XKZn65Wi2ogUmdZkv3xCM6W8/02++mKtagGIl2hLNHCWX46cr5fV61FNRDpKuWmLE4J8FW/ + HFWfL+kqtagGIl0ppwT4LEv+WqUW1UCkK5ZfcVYDuFcuLbXkr1VqUQ1Eumr5Nefugbwnd/VzP3+tVotq + INLVywZBqwG85le/Vq1FNRBphf5zZG8AkVUhv/q1ci2qgUgr5Q6C+8r77o5+mlCLaiDSamXZ1/ME9pLr + +rMKVH0epNVqUQ1EWjWnBeaz3K+JtagGIq1eDhCuFpglu/vdw19Ta1ENRJpSDhg5cLAu5/m1Qy2qgUjT + MhFYz+3A77I+7VCLaiDS1EwEri/vjwO/dqtFNRBpetkjYLPgtTjHr51rUQ1E2qXcWvifR/TJ5Xx29Wv3 + WlQDkXYry8152JDTA8+R8/u5b4Pr+KVvtagGIu1cfo1mVcDdBc+XX/u/HVV/d2nnWlQDkfRtVSDnpHPQ + 4vNyP4asrtjUJ71di2ogkv6cycDH3A76lvil+2pRDUTS22UykGXsnCawZ+CbnC7J5CiTJL/0pY/XohqI + pPvLlQT5tZsD4E77BnIZZa7Xz+uv/i6S7q9FNRBJn+82IcgKwZTnEWSlIxOcvC6X7Enn16IaiKTzypJ4 + Dpq3ScHVb0CU8WWc+XWfcVvSlx5fi2ogkh7fbWKQ8+Y52N4mB4+eIGRVIv8f+UWf/9/br3ob9qS+WlQD + kXSdcnB+WTYg5sD9VplQvP7v+BUvXbsW1UAkSdLzalENRJIkPa8W1UAkSdLzalENRJIkPa8W1UAkSdLz + alENRJIkPa8W1UAkSdLzalENRJIkPa8WbhAiSVJfOQ63yF3CqgFJkqTHl+Nwi9w6tBqQJEl6fDkOt8hD + QaoBSZKkx/foB4C9yz4ASZKeX9v5/5s8DrQamCRJelw5/rb6+1E1MEmS9Lhy/G2XZ4hXg5MkSeeX4+4l + /HBkL4AkSY8vx9scdy/jp6NqoJIk6bxyvL0cpwIkSXpcl1n6r7g7oCRJ59d217975bzE70fV4CVJ0sfL + cfVS5/3f43SAJElf79LL/m/5+cjVAZIkfbwcP3McXVZuVPDbUfXiJEnSX8tx8xI3+jlDHljgtIAkSW+X + 42TrA34eKZsY/nmUF2mzoCRp53IczPEwx8VlNvkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACn+tvf/h9SBV6qBQpYmwAAAABJRU5ErkJggg== +>>>>>>> Stashed changes + + + + 132, 17 + + + + iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAAABGdBTUEAALGPC/xhBQAASiFJREFUeF7t + nQeY3NS5/uP1zvbibV5vs73e4vW67a67ve42YIyNDQZjDKYEsDFgCL0FggtgSgBfIEBCC6GFFJJLCjUJ + NwESEkICN9yQ3ARyU7n3Qsg/DS7J+X+v9jtjSXMkHWk0O5pdfc/ze+zZ0fvpHOl7z2hG0tGH4ogjjjgC + x4oVS0YQeSZG8FuBIs4X5/MTcb708qUVtPKRdvitQBHni/P5iThf2vmCDR4QEvlEwgReB0oIHevjfAEC + OtbH+QIEdKwfTvkwgOTxn/SDxWhAgQm8Tqcxcb44n1ZAx/o4X4CAjsDg4X8AYHEhUWQCr9NpTJwvzqcV + 0LE+zhcgoCMweAB/AwCL0YBiE3idTmPifHE+rYCO9XG+AAEdgcFDHkFgANDLRQvi18YSotQEXvv/DkEB + HevjfAECOtbH+QIEdKwfTvkweIDkAMBvuwctCDEaUGYCr9NpTJwvzqcV0LE+zhcgoCMweMgjCAwA+fy2 + e9CCsjEVJtCgdBoDfZwvQEDH+jhfgICO9cMpH/wL5ACg9wMiFiIwcsgGVfK/6TRG5pHE+TQDOtbH+QIE + dKwfTvngXSAHAL0fELEQgdECQvOIFG98jYCO9XG+AAEd6+N8AQI61gM5AMDP2ubHSIERQw4AIN74GgEd + 6+N8AQI61sf5AgR0rJd54F0cyWubH98RMFrIAQDEG18joGN9nC9AQMf6OF+AgI715lz6/qUFcYUQfiWU + A0C6px4y2bk4n4+AjvVxvgABHetzKZ/+kTstiAsD8OkvBwAQb3yNgI71cb4AAR3r43wBAjrWB8tHC+LQ + 3zwApHO5Ybzx43zaAR3r43wBAjrWB8+HhQk5AOidJ1QE54lW50wBHevjfAECOtbH+QIEdKyPVj4ICAwA + 6dxiGG/8OJ92QMf6OF+AgI716eeDiNC/OcAWrI9m5yigY32cL0BAx/o4X4CAjvWRzIeEgYyPwEp55aE0 + BjrWx/kCBHSsj/MFCOhYPyzypRVYKa88lMZAx/o4X4CAjvVxvgABHeuHRb60AivllYfSGOhYH+cLENCx + Ps4XIKBj/bDIhyBtsCN/rJRXHkpjoGN9nC9AQMf6OF+AgI71wyWfPO3vXw8REeXOxfnifNoBHeuHSz6Y + P/CcgPHGj/NpB3Ssj/MFCOhYH1Y+ea8P8DcAYGEiyp2L88X5tAM61g+XfDB/WnMCRrlzcb44n3ZAx/rh + lE/e35McAPht96AFIcZdRWE2JuobK84X59MK6Fgf5XyhzAkY1c7F+eJ8WgEd64dTPjmnhxwA9O71wUJE + PCdgnE8roGN9nC9AQMf6MPPBu0AOAPGcgKqAjvVxvgABHevjfAECOgJ65JGEkQ/IAQB+1jZ/PCdgnE8r + oGN9nC9AQMf6TOTDv/BuPCegKqBjfZwvQEDH+jhfgICO9ZnKh//r+5cWjOcEjPNpBXSsj/MFCOhYn8l8 + +kfutCAuDMCnvxwAQLzxNQI61sf5AgR0rI/zBQjoWB8sHy2IQ3/zABDPCagZ0LE+zhcgoGN9nC9AQMf6 + 4PmwMCEHAL3zhIrgPNHqnCmgY32cL0BAx/o4X4CAjvXRygcBgQEgnhNQM6BjfZwvQEDH+jhfgICO9enn + g4jQvznAFqyPZucooGN9nC9AQMf6OF+AgI71kcyHhIGMj8BKeeWhNAY61sf5AsT06VNG1tbWTC8rK91Y + XFx0fmFh4S2JROLRESNGPEtvv0r8lvgj8TfiHwz+j7/hvVeIbxKPENeT7ozS0pIjRo+um7ZkSf+odNsH + HetD6S90rI/zDXZgpbzyUBoDHevjfPrRTGwk9pFZn8/Pz/8zIfYzUtDfBb3vG+igN+X7f4lE/gv095vo + /SOIRkI70C/uXzr9TQZ0rI/zDXZgpbzyUBoDHevjfO5RRKwi9hE/I5zMarwO0fxO+f6DuIE4gCgglIF+ + cf/89lcZ0LE+zhcwSBvsyB8r5ZWH0hjoWB/nU0eCWEt8hvgTYTFhFs1vB18j7iUOJpK3nKJf3D/d/roG + dKyP8wUI0snT/v71EBFR7txQytdJXEu8RagMFyXz2/kdcRXpO7h/Ov31DOhYH+cLEKSD+eM5AXUCOtYP + dr6VxNcJlbGSRNj8BpzvnwUFia9XVJQf4tJfrYCO9V7bTyugY/1wySfv9QH+BgAsTES5c7meD9/HDide + JpSGMpMj5rfly/9hXl7eofS+78B24u3ltP18BXSsHy75YP54TkCdgI71g5VvNfFDQmkmO7lpfku+7xIr + CK3AduLt5bT9fAV0rB9O+eT9PckBgN92D1oQYtxVFGZjor6xBivfZOIJwmIgN3TMmqD/t5UWigPqKsSp + 42rFdd1N4pGZreLxue3iOws6xcuLJ4mfLZssfnfAVPGblVPFK8umiBcWd4un+rvEl+d1ivtntolrSLON + tCvqykVrSYHIN+V3Q6d9Jh4j8DuHY2A78fZSbT/fAR3rh1O+eE5AnYCO9RnNV1paWk5vf5z4gFAZQ4mT + uSoS+YbZr5jYIJ6a1yF+T8b+nwOnefLfxH8dOF38ygRe4+/2ZTFYYAC5vLNBrKgtF2X5edrtczC/5H3i + KgKnNy1B2yqul/TzyTk95ACgd68PFiLiOQFDzkffgQ+it39JqMzgiN1cEytKxHlkxqfJ8G8dkGpYL/yY + X8UfaEB4kgaE89rqjSOEgOY38zqxhDCCtlVcL+nng3eBHADiOQFVAR3rM5avu3viaDLDbfS2qvhdkeZq + LisW2yaMEV+bP9GXWe2ka3470D1GXx1Obq0XDaVFQcwv+Sfx8VGjKlGsObV/+XXU8gE5AMDP2uaP5wQM + MR8V9Hwyw2v0tqroXYGJ5tZUiLv6Jog3DgjHrGGb35zvl3Q0ckdvq+irLFH2x4uBwS7/lZqa6tmmbRjp + /cuvo5gP/8K78ZyAqoCO9RnLV1xcvJWK+q/0trLgnaC9JQ4aXSG+OLcjY2bNdL4vzZoglteWK/unYsD8 + ya8Rfy4tLdnC2zOuP42AjvXmXPr+pQXjOQFDyjdv3uzqgoKC21HU9LYv8IPetxd0DqpZ/eIn37fmd4ol + NWXKvkps5meMrxHX0Pu+94l9fzCRrRcm7Hz6R+60IC4MwKe/HADAcNpYoeWbOLGjKZFIPOHX/O2lheKh + Ga1ZNasOQfN9une8GFdckNJvF/PLZb5AFBNaYd8fTGTrhclePloQh/7mASCeE1AzoGO9kaupqbGTCvjH + fsxfTsW+c2KDcaotKmZ1It18v105VVzSMUaUjBw4jahhfgkuHqolXMO+P5jI1guT3XxYmJADgN55QkVw + nmh1zhTQsT4j+caMqZ9CBfyffsw/t6pU/HBRl2GOqJnVTpj5XlzYJXorS3TNL/l3wnEOAvv+YCJbL0z2 + 80FAYACI5wTUDOhYb+QaPbq2hwr4v3TNjyvrLmyvN86nwxBRNivIRD6cMdjR3iAKElrml/ycGEdYwr4/ + mMjWCxONfBAR+jcH2IL10ewcBXSsz0g+/uTXNj++B399TrvFDFE3aybzfW5Oh2gpLdIxvwSDQANhhH1/ + MJGtFyYy+ZAwkPERWCmvPJTGQMf6nMjX1NQwkcyvfdg/jw75cR2+kxnCNleu5HttabeY4e/aAXwdqLXv + Dyay9cJEJl9agZXyykNpDHSsz4l8nZ3tzWT+V3TNv6FhlPEjmJcZom7WTOX79YopYk19pXLbqaDt/gKu + sJT7g4lsvTCRyZdWYKW88lAaAx3rcyLfnDkzahKJxJO65j+nbbQvM/hlqOTD69PG1ym3oRlsd/xmUFBQ + 8OWFC+dV8X6JbL0wkcmHIG2wI3+slFceSmOgY33O5KPCu0PX/Lgd117k2TCXLlHIt7urUbktgTT/wA+H + +aKwsPAG3j/Dpv74ddB88rS/fz1ERJQ7l/F8xcVF23TNfyUVstkgQ9GsbqST77LOhpTtaTf/ACNFXl7e + Bnrfd6j2L78eqvUM88dzAuoEdKxP5hs1qnIBFSEepJFSnHZw77y5oKNkLhVRzIfbjeX2dDI/D8aYLbmL + 0A7V/uXXQ7We5b0+wN8AgIWJKHcu4/m6ujrrqdgwD36yKJ04v73eUshRNJeZKOc7vbXOy/wSTKvm+GwC + c6j2L78eqvUM88dzAuoEdKy35KNiu53eNheckmObqy0FHGVzgVzIt76pxsv8kusI16B9ORzrWd7fkxwA + +G33oAUhxl1FYTYm6hsrJR99x8TDLlQFZ2HmqJL4VF8G8v10xVQxdVSpl/kBJhVZRCiD9mVO1h+RTr54 + TkCdgI71lnwlJSUV9PYbhKrgkowuzBevLpmUUrxhm2G45ntu0SRRVzQw/Zhq+5vA17RCwhK0L3Oy/oh0 + 8sk5PeQAoHevDxYi4jkBB/LdSKgKLQlm4v3KnDbH4g3bDMM13+dmThAjvQcAsJtIBvYj70/V/vUd0LE+ + yvngXSAHgHhOQFVAx3pVvqmE5+y9OGXlVbxRN1eu5MNFVap9YOM9oo3I9frzHdCxHsgBAH7WNn88J+D+ + fE8RqgJLgttah/NdfYOdD7+xTCorUu4LG49iP/L+dNq/vgI61udCPvwL78ZzAqoCOtY75VtDqAorSUHe + CPFvCzq1i9cPcT7nfJiS3OurAH4rKCsrW+2yf30FdKzPlXz4v75/acF4TsD9+TBi/ohQFpcE9/T7LV4d + 4nze+c5odb5nAObH2YJEIvFdh/3rK6BjvVO9+AroWJ/JfPpH7rQgLgzAp78cAMBw2lj2fEcQyuKSTKTD + UDyFJwpmcGOo5sNjzXTmGKSjgA2K/asd0LHerV60AzrWRyMfLYhDf/MAEM8J+KEP/ZhIKS4z9/WOj4wZ + nBjq+W6bNtayT+zmB4lE/ouK/asV0HF9eNWLVkDH+ujkw8KEHAD0zhMqgvNEq3OmgI71XvkOJCyFZWfW + qJLImcHOcMiHZSeXD/wgqDK/6aKhfsJXoC64PrzqRSugY3208kFAYACI5wQcCM8n9n55dlvkzGBmOOV7 + qK/Vy/zgUUI7UBdcHzr14hnQsT56+SAi9G8OsAXro9k5CuhYr5MPd5RZzG4HT8eNqhnAcMw3v7bCzfzg + H8R4wjNQF1wfOvXiGdCxPpL5kDCQ8RFYKa88lMZAx/ps5bueMBeOBRRVLj+uyy+5ku/+WW1u5pfsIlwD + dcH1oVsvrgEd6yOZL63ASnnloTQGOtZnKx9uJf1vQlU8RlFNGVUaevHG+dTLe2HO9ybRXj7wnAEH84Nf + E453waEuuD5068U1oGN9JPOlFVgprzyUxkDH+mzmW0eoCscoKhTXtVPHhl68cT7/qPJd0d3sZn7JSiIl + UBdcH37qxTGgY30k8yFIG+zIHyvllYfSGOhYn+18DxIpRSPNX11UaNyWmonijfPp45Tv58sni2J+5JgL + nyIsgbrg+vBbL8qAjvVRzSdP+/vXQ0REuXNB8+Hhk38mLAUjzY/vlqe01meseON8enjlw2Qs9n1o43+J + BGEE6oLrw2+9KAM61kc1H8wfzwmoiJTr/s3mB4/NG3hkd66YwS9DId+jsyZY9qEDS4mhXs8pQTp5rw/w + NwBgYSLKnUs33y1Eskjs5m8uKzYKLpfM4Iehkg93ZVYlRprNrmIv6oLrI2i9WAI61kc1H8wfzwnoEr8g + jAKxmx8cN64u58ygy1DLd2Rjld3wFmj//pjrI516SQZ0rI9yPnl/T3IA4LfdgxaEGHcVhdmYqG0sXCAi + iyPF/Hj98IxWZbF5kW0zeDEU893TMy7F9BK5f8eObW5Lo16SAR3r06m/ZEDH+jDzxXMCesRmwtH85Yl8 + y0SfukTBDG4M1Xy/WjFFFOalng4079+ystKj06gXI6Bjfbr1ZwR0rA8zn5zTQw4Aevf6YCFiuMwJeIuT + +fH35bXlykJzIypmcGKo55tbVepoflBYWHhTGvUS9XqW+eBdIAeAeE5AVVBxfM/J/PS2OLfN+pAPL6Jm + BjvDId920wNGVYN7IpH/b0HrBTqut1DqDzrWh50PyAEAftY2/7CZE7CtrZXqIf+v5uIwmx880DdeWWQq + omgGM8Ml3yenD8wToDI/719cD+A7UGdcb6HUH3Ssz0Q+/AvvxnMCqgK6mprqPkVxJM0PXlvarSwyO1E1 + g2Q45fvBoi4388t920RoB+qF6y20+mN9pvLh//r+pQWH3ZyApaWlR7uZv6kooSwwO1E2AxiO+fAQERfz + gxWEVsh6IUKtP86TqXz6R+60IC4MwKe/HABAlDsXSr7i4qKLncwPVtR5/wCYC2YYjvn66yrdzA9OJjzD + XC8mIlnPJvTz0YI49DcPAMNmTsDCwoLbncwPttge9GnHXry4LRWPsHqwr1Xs6WoU28bVirX1lWLOqFLR + Xloo6gryRcnIPJHP66ONbDxVqCw/T9QXJkQHLTOvtkKsbaoW2yaMEbsmN4v7ZraJ79MhbRBDZMpcTvnw + 7/cXdhmz9KD/p1L/11D/8as8+oY+llL/0Wf0Hdu9MJEvKgoLRENpkZhYUWL0/9AxlYb2qkmN4qEZreIl + zf6b27ehpdbN/OBKwjXs9cJEtp4Zf/mwMCEHAL3zhIrgPNHqnCmgY30yXyKR+Fcn84MLbI/5NoNie3np + ZHF7b6thVhRuJRW4Wz43oEOx7v/UshYvBgkYCb9w39UzTvzU47cJsxlUZvWLKt9LSyYbP7hhoJs9qsQw + t71fTnj11045vTeP+n8a9R8X+9j7b2/f6W0NrvmI+wnHUNULvx465kdAQGAAGHZzAlJxfIfeVhWHwU1T + mi1FhmnAccMJTNhdKZ9W6128Xvg1A8AnaHd5kfH8/C/Paks+nUhlBhCG+X9xwDTx8Ox2Y8BD/wezv3bQ + f0wIiucDYI7GN6ht5v7u7m7xyoe5H5VBtZGT9Uz4zwcRoX9zgC1YH83OUUDHelU+PElWVRwGj8xsFW9R + YX1h5gSxmQ7LcaNJGMVrJqx8NfT1Al9ZvkSDgdkIIB3z/4H6/9CsdnF0S52oLS4M3D5Jprbf6JIicczY + OvFZGqDQ53t7xyuXN/ESkRKoC64PVb34DuhYH8l8SBjI+AislFceSmOgY/1g5XuLUBWHAW4saSxKJF9n + qnjDzjeuvFic19kgXlzSHdj8P1o8ybgIqpm+m4fdvkznaykuEBsaRik1Jt4kLIG64PpwqhdfAR3rI5kv + rcBKeeWhNAY61g9mvpRJQJwYrOINMx9+YFs/ZpR4Ym670uQqvjqn3fjhLj8vLyVf1PvrMx/mf0wG6oLr + w61etAM61kcyX1qBlfLKQ2kMdKwf7Hz/R6iKw0IEi9eCTr6F1WX09WCC0vQAz96X19Bno31+CCnfu4QR + qAuuD6960QroWB/JfAjSBjvyx0p55aE0BjrWD3Y+bABVYViIaPEm8ZtvUU2Z8XRdaXx84ptvnsl2+7wI + Md/fiaFUz1pBOnna378eIiLKnfOTbxyhKowkQYotf2S+aK0bLxZ39YvN844UZx94uthz+OXiE1tuEJ/Z + +knx0Gn3iM/veEA8etaDBl848wHxudM/Iz5zyqeMZbDsRw44TWyas0Es7JwvxtWMFSPz1LPcBDUDfkE/ + nL4j43y75e8B85lJJEaIKd1l4sj19eKSc8eLW2/oFl96qFc8/+Qc8dqLC8RvfrpI/OX3S8X//e8yg7/9 + Yal4+81F4o1XF4iXnp0tvvq5HnHHvi5De8S60UYu5ETuMNpn4v1EItHM9aFTL54BHeujmg/mH/ZzAmJC + hHMJ1+//usVWUVxuGPXUZSeJfcdcKx77yOfE18/5YgpfO+cL4stnPSy+dNZDSfAaf1ctb+bLZ35W3Hj0 + XnHKkhPEvPbZoqxw4BRciGYInK+6KiHWHVInPn5lh3jh6ZniL79bIj54e5l4n8z9p98sE+/+ej94jb/j + fT/89fdLxHNPzhR7d3aKQw8ZI2pr5A+T6fY3/0/FxUXnL1w4r8qlXrQCOtZ71Z9WQMf6sPLJe32AvwEA + CxNR7pxuvtnEy4SyKCReZhhb3SyOnnuk2Lf5WvG1s70NnI75VXzl7M+JvRt3iQ2z14mWmqaU9vnFq792 + JraXiAs/Mk5854mZ4v3/WZpi2DDND+z53vnVUvHMY7OMNnS2lSjb6Ia9v3Qk8FJlZWW/ol60AjquN6/6 + 0wroWB9WPph/WM8JiDnQLic+IJRFIXEyw6iSSrFh5jrjMF1lSifCNr8q38c3XyUO7V0tyovKlH1yQ9f8 + dbUJceapLeL735ylNKkk0+ZX5UOb0Lbamv2nbJ1w6e/79P4FhK86RJ1xvbnVn3ZAx/ow88n7e5IDAL/t + HrQgxLirKMzGDPbGwnf9bxPKgjCjKo7JzZPERYec43ho78ZgmN+cD18Vzl21Q7TXa02PrWX+WX0V4r47 + JhuH4WZjqsiG+c2gjZ++vdtos7mfEp3+Es8QWrcKo8643tzqTzugY32Y+Yb1nICriT8S5h2sRFUcp688 + JWNm9YvffFcfsVM0VNYr+wq8zIDD/G881qc0mopsm9/O9Xs6fPXXxv8QywnHQJ1xvbnVn3ZAx/ow88k5 + PeQAoHevDxYicn1OwAsJPBZatYMtOBXHWQdsV5rLi2ybH2xZsEmM+JCyuLXMkJc3Qlx9RbvSXHaiZn5w + w1WdvvqrAF8XzyRSAnXG9eZWf9oBHevDzAfvAjkADJs5AYuIBwjVTk3BrTg2zT1CaS43sm1+fA1YPLFf + 2Vfg1wxbNjUYp+pUJgNRND8469QWo/1++6vgLgJPjjYCdcb15lR/vgI61oedD8gBAH7WNn8uzwlYQXyT + UO3IFLyKY9mkRUqTOZFt83/+9PvF1ObJKf2UBDXDiiXV4o//tTjFZFE1Pzh0dV3g/ip4nIAfcsX8Mg+8 + O2zmBKwlvk+odmAKKIKy2lbX4sAFPSqjqci2+R889W6jveY+mknXDDN6y8Uffr4wabAomx+0tRa79reh + 3d8ZE9I9N25cy1iX+vMV0LE+U/nwf33/0oK5PCdgI/Eaodx5dkbmJ8S4OSeIniNvVxaHJD9vpNav/1k3 + /7a7RUt1k6XtZuzmLy4uFldffbXYs2eP8VqlUTFtSpkxCETd/G+/uVgkEs7mx+8bu55aKFaf3iZGJrwn + MZHbL5FI/LvpqUKZrGdfAR3rzfn0j9xpQVwYgE9/OQCAKHfOnA+f/D8hlDvPTnFFo+hes1fMOOYzBiUV + 9ZbisHOrx3n/XDN/e3u7+Pa3vy3+8Y9/CMR3vvMd0dIy8H1Zh6mTy8Qbry4MzayZGEye/NLMZH/t5gd1 + 40rE1d9eYrDj7pmiurHY0kcz9u1Hg8CPx48f22KqP18BHdevUz37CuhYHywfLYhDf/MAkEtzAlYSmNhB + ufPsVDb1ip6Nn0yaH1S3zHA0Pzh9+SlK44Fsmx/f+Sf4OOxfvny5+PWvf500v4y33npL9Pc7/3Aokfnm + zKwSv3t9cSTND/3OSzqSfbabH0xbNjo5AIDLvrpAtFOfzMsA+/Yz5Xue3i8jfAXqluvXqZ59BXSsD54P + CxNyANA7T6gIzjOYncOv/VoX+ID67jVixub7LOYHDdOOUC4vwS/qKvNl2/z4tX9Kc7eyzcBevKeeuk28 + ++67KeaX8d5774kTTzxRmQvY861cWif+942lkTM/8qxaOZrbqT6yO3h7m2UAAFc+u1jM37D/SMrF/HKZ + p4nk2QGvQN1y/TrVs6+AjvXp5YOAwACQa3MCPkgkd5gzI0TzzONSjA/6jn1YdKz8qEKzn+rSqhTzZdv8 + wM+pvp07d4q//OUvjuY3x6WXXuqZT5rhhM0NSjN6kUnzv/3mUlFdhZuF1OYH22/vSxkAJAdtm6Bjfsmd + hGegbrl+3epZO6Bjffr5ICL0bw6wBesHu3OXEfadkcKIESPF+AWnOZq/79jPip5N9xnLqfSSW479eNJ4 + UTD/MfOPUrYTmIu3oKBA3HLLLdrml3HjjTcmi93LDNfs0rtYSJJJ84PHvzDD0j47BUUjxZ5vLlaaH1z1 + b0vEYed10bZLKPur4BzCMVC3XL9u9awd0LE+lHxIGMj4CKyUVx5KY6BjvVu+DcQ/CdXO2A/tsNaFZ7qa + X1Jaa71s1M6x8zcZxouC+S8/9CKtK/wSiYS4/fbbfJtfBgYOL/MD/KL+9S/0KM1pJ9PmBx85bbybWY3v + +irjA5h/99PEU0vEhgsn0Tb0ND/A1aa45DwlULdcv271rB3QsT6UfGkFVsorD6Ux0LHeLd8E4k+EakeY + GCHGzd+uZX7QMN39d4CO+rZImP+ek24z5gJQtdFu/iCf/OaA7rrrrmPTq80vwZ2Cv/rJAqVJJYNhfrzG + PQz29pnBqT8v80vWnT3Ry/wSPGy0mUgG6pbr162etQM61oeSL63ASnnloTQGOta75UsQ3yNUO8BC86wT + tM0PulbvVeaRoAhuO/5GX2Z1I4j5cT1CZ327Y/vMn9S7du1K2/zQ//nPfxYXX3yRq/klC+aOEu/9t/qS + 4cEy//eemaVsm5nzHpqjZX68xt/xg6Eqj4JvEcZttqhbrl+3etYO6FgfSj4EaYMd+WOlvPJQGgMd673y + XUOoNryF0V2rfJlfkiipVuaT5jpq3oasmR8cNWeDa/uk+bdu3Rqa+SVbthzran7J7o+2aZs1bPPj7zu2 + uV/PYD7/r2N+ucycQxuV+RRcjrrl+vWqZ62AjvVh5ZOn/f3rISKy0bl+wvN7f2XzDOWpPi/zgzoaOOz5 + zOZqrGoQj575YFbMj+nA8kakXrFmN//KlSvFn/70p1DNj9d///vfxcKFC1PWb6egIM+Y10/HrGZT6+KW + Dzcsja4rULZLsnTLON/mB1d+a7HomK3+gDBD++ODysqKxRr1rBXQsT6sfDB/zs0JiHOtnlf6FZU3iJ6N + nwpkfjBx1ZWWfHZzgcvWXTjo5sehP6YgM7dN1b4JEyYoL/LRDSfzy3y///3vRVOT8xWHkt7p5cZXgcE0 + P97HpCWq9pg55/7Zvs0vufxr/aJqTJEyL5D7A1cKzpkzo8alnrUCOtZ7+UMrSCfv9QH+BgAsTITZGD/5 + PkYoN7oE1/Z3H3JVYPNLiioGDvVU5sfrvnHTlSb1Iqj5wfH9m1P6a29faWmJeP755zJmfhnPP/+8sT57 + e+xgMo7BND+YM1M9C5Ckuas8aWa/5pecdkef8t4B+/4oKiq6zKWePQM61uv4wzNIB/Pn5JyAncR7RMpG + l2Djj5/74bTNDxp7NzmaH3/H+m477ialUZ1Ix/z3nny7KMi3Htaq2rd3796Mm18GfmA0t8cO2jeqskD8 + 9AcLBs38mDFY1RYza8/qMEwc1PySNWdaf4hV10v+X4k2et93wAfsBx1/eAZ0hLy/JzkA8NvuQQtCjLuK + wmyMn849Slg2uBls/Krm3lDMD6YdcYdIFLg/C8/p0mAV6Zgf2K/2UxUbru//4IMP2J7+wq/5EVjXggUL + LO1StW/L0U2DYn6wamWNsj2SguKR4orH+9M2P8CyE3oHnjuoNn+yXnClqq+AD9gPuv5wDeiInJ0TcCFh + 2ZFmsJELisrEtMP2hWJ+6KCva1+s2pmW9d5xwr8oDWsmXfPjhz/7eu3FVlFRId544w22pr8IYn4Zr7/+ + Og5zXduHK+leeGpOxs2PZxGY26Fi/uFNoZhfcv4jc0Vh8UB9mPeHrV7wo/VMQivgA/aDrj9cAzpCzukh + BwC9e32wEJHtOQFfICw7UiKLzX7on675QffqgXvkbTvTQn/HPKVpJemaH5hn9lGZH6+vv/56tqS/SMf8 + Mnbv3u3ZvoNW1FjMqouu+cEBy9x/nR8x4kPi3Admh2Z+AN2aMzpT+quol28QngEfsB/8+MMxoCPgXSAH + gJyaE3AtYd+YBrLYyuvaLKf8wjC/pKppumpnWrhu4x6lccMw/94jdybX42Sunp6eQIf+YZgf8f7774vu + 7m7H9snth09ou2nd8GP+xz47PbmdnJiypC5080O/84nForGtIqW/ClYQjgEfsB/8+MMxoGM9kAMA/Kxt + /ijMCYj7rVM2prnYug68LGnYMM0PJh6034BOYO59+1OBwjA/mNYyxViHm7meeeYZtqJ+hGV+GY899phj + ++R2OvgA/aMAP+b/+1tLRfdE9WXREtynsONT9OkfsvllrhOv60npr4KnCGXAB+wHv/5QBnSsl3ng3Zyb + E3ARkbIhzWaoaZ2bNGvY5pf5KhqmpbTBzmmmyULCMv9Nm68xcruZf+3atWxB/Qjb/DLfihUrUtpn304/ + fm5OioHt+DE/uOpj7pfooh1Tl9RnzPwy36QF7j9AMim/BcAH7Ae//lAGdKw359L3Ly0YlTkBv0JYNqDF + DImEmMJTemXK/KDr4Kto3a4juyguKBb3nfLJ0MwPlnQtdDU/ePXVV9mGepEp8yMPphdzMz/48LGNShNL + /Jr/P74/TxQXOc/lh3YUFOSLM++ak1Hz4++YUgy/M6jaYeIRIhnwAfshiD9SAjrWm/PpH7nTgrgwAJ/+ + cgAA2TA/zp1aLvm1m6F2woIUs/rD2/yS6gmLzDtRyazWvtDMf//WO43HizuZH+vbsGED21AvMml+ycEH + r3I0PygqzBO//9n+GYXN+DU/Hka6cP7AaTgVsl4WHNaScfPLZSYvqlW2xQQeMmI8bgw+YD8E8UdKQMf6 + YPloQRz6mweAbM4JeCWR3HB28+fnJ8TkNdcqzaqHvvnB1MNvE3n5heYdaUG2b+uyE9M2Pziuf7Otv1bz + g5dffpmt6B2DYX68fu655yzbRQWuDkwxs0/zg12XOj/3UO6P8lFF4pIvLhgU84Mdd3mfiiQugQ/YD0H9 + YQnoWB88HxYm5ACgd55QEZwnncbg6qTfEsYGSzV/vqhq7iFjDo75JU19qZfi2ttXXFgs9h1zTVrmh645 + +ahvtfnxfVs3Bsv8Mt+8efMs28fO1MllFiMHMT+u+MvPVx9pmPfHoWd1DZr5Ja3TK5XtklD7/nPJkn6z + N/z6wxLQsT69fBAQGACyPSfgGkJurOTONJuhbdlFSpN6E8z8oPeYB0VJdat9Z6a0r6W2STxy+n1Kc3sB + 8+/duNOSz25+8Oijjxpm84rBNj/i/vvvt7RVxYvfGHi0eBDz//an/aKlSX0zjnl/tPVUi11PupvVC7/m + B5t3eT+Rqby8fE0a/kgGdKxPx28DARGhf3OALVgfRmPuJxzNX1RWT4YM8ukf3PySSauvoXYNzBvo1D78 + fcb43pRTg17A/DhyWNO3KiUf1icZN26cloGzYX4Erguor3d+GjE4b8e4QObHrb7989Tf+837o6ikQHzk + 3jmDbn6AWYUr6lK/LprbV1hYcE8a/jACOtan67eBIGEg4yOwUl55uo3BbD/vuJmrYdoGpTndSd/8Ekwb + 5tY+ar/B+hlrlEZXIc3/6FkPitGVdcp8kksuuYSt5hzZMr+Ms846K6XdZvC4Lr/mBziLoMpn3x+rt3dk + xfySRZusE5Io6uUP/f1zRwXwhxHQsb/S9Vv6gZXyysNozEovc01et09pTGfCMz/AV4HKhm7H9pk5adFx + SsObkebHD4fXHrXbNR947bXX2GbqyLb5ET/4wQ+UbQdy/z73xBxf5v/o+davX/Z8cl9MmlcndpFhs2V+ + cOa9+38MtLdP7t+8vDxMbuM74Cv2Vxh+Sy+wUl55KI2hjXWLamNJM5TWtitN6Uy45pf5cONRUWllSvvs + YNbecw7aoTQ+MJsfbJp3hGu+3t5etpg6omB+GV1dXSntN5sBT+3RNf/N101MyWXPB0aNLhYXf2FBVs0v + GdNWmtK+AZL7F1Pb+Qr4iv0Vit8QpA125I+V8spDaQx0tIF+7rCxDHCfvtqYKjJjfknn8gtEfiLf0j4V + eP+8VWd6mh90N7nPPnvFFVewvVIjSuZHnH/++Za2o19mMyxZWKtl/ls/jm1i3Q6qfIVFCXHyTX2RMD9Y + dtw4S/sGsNTzy4R2wB/sr7D8Jk/7+9dDRIRq/sbGMe0uG8sAP8KpzWkns+aXNPUdY2mfE+iH+UhAZf4H + t9+Dw0KlXvLSSy+xvawRNfMjnn322WS77WYFxcUJGgCWKE0v+Zdr9cwP1p/TFRnzQ7ftX/Bgkv3tU9Qz + niOAZ1p6BvzB/grLbzB/tOYELC0tOd5lY4lEcZXCmCoGx/wyX/UE70kyAb4O4DcBlfnxevfhlyl1koaG + BraWNaJofgTuUBw1apTSrHL/fuurfUrjg8su0PvOD+avb4mU+aHf9cRiUVFdzG1MrWdG+SARc0h/EGH5 + Td7rA/wNAFiYCN38yFNYWHCH28aqbl1oMqUTg2t+0Lv5AVHeMDWlvSrQr7UzDjZmFTabH4PCMfM2KjWS + jRs3srX2R1TNL2P16tXG/jSb1bx/cSOP3fi4u++kLXq/9oMpC0eLPd9yfsSXG5kyv8w1dfEYS38V7CUc + w+wPE+maP5pzAiYSiRfdNlbL7A8nTadm8M0v6dn0aVFS431XmizemRP6xAOn3pk0P74W4F4ClU5y8803 + s60GIurmh27PHjmpSqr5wfo1dRbz/+71hWJxf+rjuYF5+0nae2vErqcXKc3oRabND3A60qmemWcIZdj9 + waTrN3l/T3IA4LfdgxaEGHcVhdmYZOeWLOkfRTv0z24by/37f/bML5l25J2iaJT6gRSq4m2qaRS3btn/ + sNGaMvfbSX/4wx+ytXLD/NA//fTTpj6nDu7tE4qT5v/u07PE2GbvK/wkY7tHiY99vV9pRi8Gw/x4feqt + vcr+mHiLSAm7P5h0/RbdOQHr6mqnuJk/b2SB6D3mIaXxomB+CQaB4qpxlrarileaITEyIbYt/bB45LT7 + LBo7eLovrrAzmytss2YiH54hgOcTqswPMFHHu79eLK68vI2WU+9/1fYbP6XKmJ9fZUYvBsv8xt+/sYhq + 17mumdFEMlT+4Nfp+E3O6SEHAL17fbAQkfE5AfPy8hyn/gLF1eOVhouS+SXTjryLvg4M3KnmZn5z/8bX + jrW8tjNt2rQUc4Vt1kzl6+hwPwyePMl5Nh/V9mudVi0+9vhCpRm9GEzzy2VqW9wfUkosI4wgL2TC/PAu + kANAJOcEPJtQbRyDqvELFGaLnvkl04+615hJSMf8OmzevDknzY/X69evV/bJC5X5J/ePFjufzB3zg+5+ + zzkCTiUyZX7ogRwA4Gdt8w/mnIAfJ1Qbx6Bh+kabyaJr/gFIt/leMbpjqamAg5kffPSjlw6KWTOR7+yz + z1b2yQ2V+TGxB57NZzaXLtkyP1i82f3ojtgNH7AfnPzhK6BjvcwD70Z6TsCHCNXGMRg3/zSLucI2aybz + tfQdZXwPDmp+6D7xiU8ozRUkBtP8iH379in75YTd/LjCD1NvD4ZZdfCbb905ncp+Sqi/d7Mf3PyhHdCx + 3pxL37+0YDbmBHyWUG4g0L78EqW5JFE1v6RjxaUiv7Bc2Tc3pBluvPHGQTGr39DJd9111yn7psJuflzb + f8q+6FzeGyTfsVcOzOysAv2lD4enNPyhFdCx3pxP/8idFsSFAfj0lwMAyLT5Ea8Tyo0EJh0yMP2XylxR + N7/MN+WwW0XZaPVNLSrsZpg1a5a48847xV//+le2lr8YTPOjjWgrnlmg6psKe387ZtSICx+Zn9PmB9tv + V1/fIftLA8ArGv7wDOhYr+O31KAFcehvHgAGc07A5BRgKqZuuM3VXP7JzmCCU5nGg0fzBiYVccJuhgEG + fkOorq4WO3bsEC+++CJb0TsGy/x4avD27duNS4BV/XLC3N+i4gLjApps39JrJp185392jmt/E4n8X2j4 + wzWgY72u31IDCxNyANA7T6gIzuO3Me8QKRsKYGP1HHmHp7n0yf6RRNfqvcapTaf+OpnfvmxbW5tx1x2m + 5HZ6OlAmzf/HP/5RPPHE48YEIK2t6mv3vTD3d+zkUWLHnQOP7xoK5geXfGm+Y38BDQC/0/CHY0DHej9+ + Sw0ICAwA2ZgT8G+EZUMBubF6N92tbS53sm9+CY4GmmceJ/Ly91/95sf8dvCpu27dOnHDDTcYs/P+7W9/ + C9380OPqvquvvkoccsghoqqqSrt9KmR/yyqLxNqzJho30Awl8wNcsGTvr3X/5r+j4Q9lQMf+8uu31ICI + 0L85wBasD9IYrM9SGMC8sWYck5ln/0Uh39TDP+FSHMHNBf3kyZPF4YcfLi644AJx6623GpOJYraeN998 + U7zzzjvivffeE//85z+NAQH/f/vtt42nDGOZr3zlK+KOO+4QF110kTjssMOMCT5wRWJY7ZP9xa/8+K4f + BbOaCSvf7mcGninhsn/x4ec74Cv2l1+/qYOEgYyPwEp55UEakzIA2DeWfPjnUDP/AA+7FYdlu+iSS/nw + nT8qZpWEmW/nU+5PeKLt8XfCV8BX7K8gfgs3sFJeeTqN+T8ipTgkPRs/ZRhFbSAvomx+8LBIFBRa+huW + uXIhHw7/h6r5AX4D8Nh+7xLaAV+xv9LxWziBlfLK023MnwnHYsNhsto8XkTf/NAXFpdZ+huWuXIhX2Vd + 8ZA1P3QfuW+Opb+K7ae8I1AV8BX7K12/JYO0wY78sVJeeRiNecut2LrX3qAwjxe5YX5QVFZt6S9tDwuz + 1h8pqpvUtxpL3LafankvwshXM3a8mHnoEcb/nfJVjSlSmseLXDA/9KfdjqcYuW6/NwnPgK/YX2H4zTA+ + gd/8/OshIkJrDG2U/3ArNjyhV20iJ3LH/KCsqtmpOAy23vmQ2PvjN8Sp9z4i5m08VpTVWG8wcTKXUz4v + 0slXMbpeLDj6eHHaZ74ornnlTXHirfe45mvsLFMayI1cMT/ynHRDr6W/im32EuEa8BX7KxS/kQ7mj86c + gIlE/vOq4qC3DTpWXqYwkRO5ZX5QOabb1Vybr73ZMJNk749+KbZ/+vNi6UmniaZJU0SiAPfcO28/P0Dn + ZFbl8nl5omXKdLF86xni9PsfNQYqc1uP3HmNa77OOdVKEzmRS+YHx+4ZuCvUZX88QTgG/MH+Cstv8l4f + 4G8AwMJEqOaHvqAg8ZhbsY2bt01hJBW5Z34wamzq1WJm1l5wucVUEpjtyhf/Q1z61Atiy/W3iiXHbxUd + s+eK4vIKZR4vdMxfXFEp2ufMNwafE26+S1zx3CvKtgG0b9UZ57jm6ztojNJIKnLN/AA3MrmYH+BReMqQ + /iDC8hvMH705AQsLC25TFYekfvJahZns5Kb58fe6iQel9NkMDqlV5oL5r/zea/uh1/IT+OInnxcn3X6f + WH/JLrH4+FPE9IPWiAkz54r6tg7jML2orEyM5LsU8SmeT0cRpZWjRHVDIx2WdxkDSe+qNWLxCVvFYR/d + I07+5P3ikqe/m9IOJ2T7Zq/Dw07U5ge4XVZlJju5aH68nre+ydJfBXgUfkqY/WEiXb/J+3uSAwC/7R60 + IMS4qyjMxiQ7V1xcdLGT+UFl80ybmezkrvnxPq4IVPVb0rlgsdJcTub3SybzTZgx29H84LDzJyoNZSZX + zY+/t89QT3Jq4mTCEnZ/MOn6LbpzApaWlhzlZH5QWNFgMpOd3DY/wOPOVf2W4AyAylxhmzUT+SrpaMNt + cD/l5h6lqSSDaVbV8l545VM9KdjGCiIZKn/w63T8Juf0kAOA3r0+WIjI+JyAVCBd9LZq4xjgkdy9mx9M + GmY/uW9+gAeeqvotgXl2Pv9qzpn/4q9/29X8ABfK2E0lGWyz+sUrH6YvU/XZRiNhBHkhE+aHd4EcACI5 + JyD4C6HaQAYDcwL4N5c+2cuHG4Mw87Gq35JT6Dt4LpkfbLnhNlfzF5fnp5hKMthm9YtOvu23uT/rgfgf + wgj4gP2g8ofvgI71QA4A8LO2+QdzTkDE9wjVRjLA9+T9phk65peU1jlPFgITrdpxrsVcUTc/Xq/YukPZ + H0nHrCqLqSTZMKsfdPMdcLLnLdLfIDJpfpkH3o30nICImwnVRjKobJ7BZhl65gejJ61W9hvmx2F098Kl + GTVrJvK1zZqr7JNk6ZZxFsOAbJlVFz/52rx/ANwLH7AfvPyhFdCx3pxL37+0YDbmBEQcTag2ksHIRAkd + Kj8YyFzORGcwaV14ZkqfpfnxK3pJebnY9dwrOWP+3fR/nGa098nMsVdNsRgmm2bVwU8+PBQkv8D9ac95 + eXmHsh90/OEZ0LHenE//yJ0WxIUB+PSXAwAYDPMjxhHKDQVghkmrdgYyl5poHUlM3XB7Sn+l+SWn3HFf + Tpgf75/4iXst/bEzIm+EuOyrC5KGyaZZdfCb7+R97vMhYv+2tDS1+vCHa0DH+mD5aEEc+psHgMGcE1DG + fxLKjQUzYIrtIOZKJVrmlxRVDlw0ojI/XuOCHrsRdRhs84P5m7ak7EczzV3lSbNk26xeBMm37DjrI+LM + DOzffPNkoLr+UAZ0rA+eDwsTcgDQO0+oCM4TtDEpvwOYzVBeMz6wufYTTfOD0V2rHM2Pv1c1NluMqEM2 + zI97Fcpr6yz70c7SYweuAIyCWd0Imq+mqVjZb7l/CwsLbwjgj5SAjvVB/LY/ICAwAGRjTkAZq4mUjWU2 + Q/fqK8ksQ8/8oH3ZRSn9leaX22THQ/9qMaQb2TA/2HbPZ5PtdWLrLb2RMasTQfOd+gn1U4HN9VxRUb46 + gD8sAR3rg/ptf0BE6N8cYAvWp9uYIuL/EUrz4zV+LVeZx5tom9/QHX2vKCypsPTXbH7Qf8yJFrM5kS3z + gzkbNlnabKe8usB4zFcUzOpEOvnmHNqY0mdbPf/vnDkzagL4IxnQsT4dv+0PEgYyPgIr5ZWH0Zj7ncyP + vyeKKl0eFe5E9M0vc4zuWGzpL20PCyWVo8SV3389xXRmsmn+3d/9iSgocX7iL5h3WFNkzKoinXz49R8X + OJn7a6/nwsKCe9LwR/jmTyewUl55KI3BqREn89PbBrh2Xm0kFbljftCx7LyU/trZdPVNKcaTZNP8YMPH + 9irbLEG/TrqxN5C5VETJ/GDzrskp/bXXc1lZ6dqg/oCO/RWK39IKrJRXHkpjoOvpmVpDG+m/92+wVDOU + j5miMJKK3DK/kWvzvaKg2P3JOi1Te5Tmy7b5QUPnJGWbAfZjXXOZ2PVkMHPZiZr5wdjJ++diUJmf+E1L + S1OC3vcd8Af7KxS/IUgb7MgfK+WVh9IY6FhfWVhYuM/J/JKJq/YoDGUm98wv842Z4v1M/W13P2wxXhTM + /2GXc//SDAee3B4Zs5oJI99JN01P6a/V/EY976T3fYfZHybS8Zs87e9fDxGREfOD2tqamW7mB5VNfTZD + mcld8+P9yev/hfro3HfQ1b8kabwomB84XforzVBQOLQfAjKhd+DIzcX8/6D3ccGbr7D7g0nX/NGZE5D1 + lny0sTBXWkoxmZm0+hqTqfTM5Z/s5MMAp+qzGTkHXxTMv/Wuh5VtNJuhZ0VDZMwqCSufPPXnYn68/0XC + V5AXMmF+ea2PvwEACxMZNz+BfAcQlmKyg7n0zKbJlln10c/XecAVyj6bwRRfUTA/GDst9dy33QyYInso + mh9gclMP84MFhHbAB+wHlT98B+lg/ujNCWjCnu9lwlJUdvbPGDx0zC8pre1Q9hnIYjt+3yezbv4tN97h + 2D5phM6ZtUPW/MddM1XH/M8R2gEfsB/c/KEd0BHy/p7kAMBvuwctCDHuKgqzMTqdO5ywFJYdXD/fu/kB + 3+ZyJxqDSdvSC5R9NhdbfWub2PmdH2fN/Hu+/1PjEmWn9kk+fH3PkDT/rqcXieqGopT+2swPDiS0Aj5g + P3j5QyugI6I7JyC/VuXD4QkenGDekBawkZttNwnpmMuZaB1J2CcKUZnrwO0fyYr5wbKTT/ds38TZtUPS + /AA3/WiY/98IrYAP2A86/vAM6Ag5p4ccAPTu9cFCRMbnBCTc8h1MmDdmEllsBUUlYur6G32bK5VomR90 + Hrj/twCVuQb6XyTOe+wbSoO6ka75z/7iE5Z7/lXtSyRGijPunKE0jxdRN/+5D8ymba/1UJZFhGfAB+wH + P/5wDOgIeBfIASCScwJ6xeOEZaPai62qpZfMdR+ZZuiYX4LZkJzML4sNP8Jd/aNfKI2qIl3zX/XD/xSN + Xd2O+0O2b/qK0UrzeBF18+/51mLR3luT0l+F+T9PeAZ8wH4I4o+UgI71QA4A8LO2+Qd7TkC36CZcHyGO + 1019m5UG8ia65geYNbigAN8zrf21F9uBZ5yrNKuddM0Plp9yRnK9TvujqCRfXPzoPKWB3Ii6+aFbvqU1 + pb8K8+PZ/62Ea8AH7Ieg/rAEdKyXeeDdyM8J6BXXE47Fhr9j+vDOA3cpTeRMtM0v8zX3bEjpL7aHmbyR + +cYDRFWGlYRhfjwlCE8T8tofh5zRrjSQG7lg/hOv77E9j1G9P4iPEa4BH7Af0vWHEdCx3pxL37+0YLbm + BPSKEtrIv3AqNnrfoKC0Rkw78k6FkVTkhvmNHJvuFqVVTW7FZlBRN1pc9s0fKI0bhvkveeoFakeNsS60 + w2l/NLSXGbf8qkzkRC6Y/8LPzReVdcUp/bXvB+InRAHhGPAB+yEMfzjl0z9ypwVxYQA+/eUAAKJgfiNf + WVnpoapio7ctVDT1atwynDvml0w66GMiL29kSn/tTJgxR1z10s8txg3D/LgNWV7w42b+kYk8cea9M5Um + ciIXzL/z8cWiY4b5e7+j+XHJr+tFP6hn9kNo/mB9sHy0IA79zQNANuYEVAZ0rMeDRO/w2PgGtR3LFaaS + 5J75ZT6dG4VA35rDksYNw/xYduoBBxu53cyP9w/aNkFpIidywfy7KEffgQ3K/iq4mnAMcz2bCMUfJvzl + w8KEHAD0zhMqgvNkrHPTpk2upx3wmpv5JWOmHm4zlru5UpfVYXDz4aKnkmrPB04YrNh2ZijmB3hKMHJ6 + mb91eqW46ln9Q/9cMD/0CzfifL+W+b9PON7ua69nJjR/MP7zQUBgAMjmnICWgI71lnwjR46cTm+7PkpM + 0jL7RG1z+Sc7+XC34MgC91l3AIr0kLMvStv8OLsg87mZv6y6wNev/rli/lVb25X9VfAu0UEog2o3muZH + QETo3xxgC9YPZuc2E6qdYGOEGL/gDG1z6ZPdfAOXCTsfBZnNuu7CywOb/5BzL03JpzJDXt4IcfJN05VG + UpEr5j/svEkikdAy/z+JQwlloG65fp3q2VdAx/pQ8iFhIOMjsFJeeSiNgY71XvluJFQ7w8KIEXli3Ozj + tM3lTTQGk4ZpGxz6azVrIpEQa86+OGOf/ODg7W1KI6nIFfMfvK1D1/xgN6EM1C3Xr1c9awV0rA8lX1qB + lfLKQ2kMdKzXyYe7mR4jVDvEwFy8TVPXaZvLmWgdSVS3Wh9B7WZWXLyjMrqKRced7JlPrhOz4KqMpCIX + zI8f/Hx85wefJZQfoKhbrl+devYM6FgfSr60AivllYfSGOhY7ydfKaG8YUhVvPWdy41nDKrM5E20zA96 + j75flI0emIdPx6wzDt2QcorQDE719axaq50P98FfqfmjXy6YH6f6+g7Q/rUffIfAdPYpgbrl+vVTz44B + HetDyYcgbbAjf6yUVx5KY6BjfZB89cTrRHLHuBVvReN0HxcLSaJnfsn0jXcbZwa8zCoZ3ztTXP7sSynm + v/SZF0XLlIF57dy2n8wzbmql2PnkQqWZ7OSC+XGRj+Z5fskrRA2REqhbrt8g9ZwS0LE+rHzytL9/PURE + 1DrXQrxBaBVvoqRadB64U2moVKJr/gEeFtOPuE2U1egftlbWN1guGz7lUw8kH+els/2aJpaLj329X2km + O7lgflzeq3mFnwQfOGOIlEDdcv2mU8/JgI71YeWD+aM9JyARJN8E2mm/9CpeCX4cbOzdZBhIbSwQffPL + HNM23CrKqlt0itcAVxUeePq5YsXWHVrX9ktdY0eZ5cm+bkTd/LhceflxE3Sv7Zf8jBhLpATqlus3jHrO + lPnltT7+BgAsTES5c3n19aO7Eon8n/nYmaKiYZqYsv5mV3OZiaL5JTgSKKlpU/bTCx3zj59WOWQ++c99 + cI5o79O6pdcMDvtz+ZM/p+YE1A7oWF/Z3NzUkUgkfqhjfkneyALR2LPRuNLOyVwgyuaX+aYfda8oH2N9 + Qo0XOuafOLfamAJLZSY7UTb/7mcWieXHjxOFepN5mMG8frn6nR/55P09yQGA33YPWhBi3FUUZmMyurEm + TmwfQzvT9RShisKKBtGx4lJHc6nN6MXgDyYYyGraFiv7aEfH/DjVp3t3X5TNf/w1U0V1I77r631NNIFT + fTn5az90RE7OCegZ0LFelQ8j3McJ1Q5VIs1QPW626D54l9Jc/sjukURT3zHiQy6F7WV+XOG39qwOpZlU + RNX822/vExPn1Xj2VwGu8NtD5OR5fugIOaeHHAD07vXBQkS25wR0DOhY75XvKMLz3gFVcVQ19xjz8qnM + 5U12zQ/al18sCsvqtftrN0NtS4nxyCuVqexE0fwn7+sRbTOqtPtrA9f2ryOUgTrjevOqP62AjvVh5oN3 + gRwAcnJOwJSAjvW6+aYQ+AFHtaM9i6OsfpJoW3o+HVrrXkSUPfP3bLpPjJ27VRSPaknpp8SvGfDL/4aL + uhx/A4iS+fd8Y5E4Zs9k4zoF2X6//SV+QHQSykCdcb3p1p9rQMf6sPMBOQDAz9rmj9KcgJaAjvV+8+E7 + 3D7CsrP9FEd+UYWo61olug6+KsV4+8mG+R8WEw/aJWo7VoiRieKUdpsJYIYkxWX5Yu76RnHaHX1Jw0XF + /DjMR9tKKvbPVAx89heTeewlcu+WXg7oWC/zwLs5PyegEdCxPp18y4mfE2mZAQ8laZh+pDEP4f4jg8Ez + P9bZsfJyMXrSalFQWqtso510+msHD8RYeFSLOPnGXrHzicWDbn580m+9uUcsP2G8qG1WD3o++/sa0U84 + BuqM6y2d+ksGdKzPVD78X9+/tGBU5wQMO18xFcE1VAzvaxaHK3n5RaKisUe0zDja+PGwd9PdFrOqze2F + 1fy9R90pug68TDTNONZ4eKjXJ70dn2bwxJyvrLJITO4fLVZv7xDbP9GnfbrQjJf5kRNHHphxqGNWlUgU + uU+P5qO/mL0Xj+0uJBwDdcb1Fkb9DVY+/SN3WhAXBuDTXw4AIMqdSzsfHkVeUJB4PEwzGCQSoriy3rjv + YHTXwaJlzkmifdlFxtHCpEOuNS48wv0IOF2H+QtxU8+0I+8SUw67RXSt3ivaaNnx804SjVPXiprxcweu + 8Evkh9e+gf7+g/5+L71/P4Ffu5VaFQ75ku3D2YPR40vF1KV1YumxY8XhF0wUJ1w3Tey4a6a48PNzxeVf + 6xe76RMcswfh348+tkCcc/9ccfonZ4mt+/rEcVdPF2vP6hTzNzSJjtnVompMEeVWt0WFV/tMfIGYQLiG + rBci1PrjPNnPRwvi0N88AERyTkAToeYrKytdR8XxPXrbXiCe+Cg2LQYjXyKReHzkyJF99L6MWcSThDKH + mVzsryIf7uJbQniGql749dAwPwILE3IA0DtPqAjOE63OmQI61jvlW0vgF2BzsTiSpeLVxp6PjnaeqKgo + X2nqrz0WE44DQa71V5HvBWIVoRXYTlwfTvXiK6BjfbTyQUBgAIj8nIDEYORbRnyFcDw0zkLx+sKU772C + goIHqqpGLXDprz1mEvhq4PlEpgj2154P+/BLxEJCO7CdeHvp1ItnQMf66OWDiNC/OcAWrI9m5yigY73f + fO3EVcTvCZ1isxSlLpnJl//zoqKiy1tamtp99NceDcQllM/zoSx+yEx/7fnyf0N/x1Rd4wlfge3E28tv + vSgDOtZHMh8SBjI+AivllYfSGOhYH6V8OC+MJxXfQ0X1xwib4beku4UO81ek2d9kQLdkSX8l5VxVWFhw + J7XvrQj1157vbTra+TR+06GBz/Fcvlugv7y9Qtt+rI9kvrQCK+WVh9IY6Fgf2Xw9PVNrysvL1hUWFt6S + SCR+mmUz4MIVTImG69XntbW14itcRrdff//cUXl5efitAA/AeJnQPoMQQn8tDOTL/wnti33l5eVrZs7s + reX2Dtn6Y30o+dIKrJRXHkpjoGN9TuWjQaCJ3t5A3EB8m8A15MqCNRPQDG8TzxD4WoIfLKsII6gt2dp+ + tQSumccVdN8k/kiktD0k879DPEtcR4PQYY2NDW0a7dMK6Fg/LPIhSBvsyB8r5ZWH0hjoWD9U8o0j8Gvz + duIa4mECxv0xge+m75AB/kp8QPyD+DvxLv39v+j9V4lvEA8S0J5GrCQw7Zky0A5uj277XAM61gfNh/4f + QJxOXEv9epgGymeJ1xKJ/N9SX/+EPtPfcQTzAYGbtTC4/Zr4EYFt9RCBQWUbcSCR7D/awe0J2j5LQMf6 + 4ZJPnvb3r8+BzsX54nzaAR3rh0s+mH9IzgkY54vz+QroWD9c8sl7fYC/AQALE1HuXJwvzqcd0LF+uOSD + +Yf+nIAm4nyaAR3r43wBAjrWRzmfvL8nOQDw2+5BC0KMu4rCbEzUN1acL86nFdCxPsr5huWcgL4DOtbH + +QIEdKyP8wUI6FgfZj45p4ccAPTu9cFCxFCYE1AroGN9nC9AQMf6OF+AgI71YeaDd4EcAIbtnICuAR3r + 43wBAjrWx/kCBHSsDzsfkAMA/Kxt/qE4J6AyoGN9nC9AQMf6OF+AgI71mciHf+HdeE5AVUDH+jhfgICO + 9XG+AAEd6zOVD//X9y8tOFzmBIzzxfl8BXSsz6V8+kfutCAuDMCnvxwAQLzxNQI61sf5AgR0rI/zBQjo + WB8sHy2IQ3/zADCs5gTk13E+jYCO9XG+AAEd66OTDwsTcgDQO0+oCM4Trc6ZAjrWx/kCBHSsj/MFCOhY + H618EBAYAOI5ATUDOtbH+QIEdKyP8wUI6Fiffj6ICP2bA2zB+mh2jgI61sf5AgR0rI/zBQjoWB/JfEgY + yPgIrJRXHkpjoGN9nC9AQMf6OF+AgI71wyJfWoGV8spDaQx0rI/zBQjoWB/nCxDQsX5Y5EsrsFJeeSiN + gY71cb4AAR3r43wBAjrWD4t8CNIGO/LHSnnloTQGOtbH+QIEdKyP8wUI6Fg/XPLJ0/7+9RARUe5cnC/O + px3QsX645IP54zkBdQI61sf5AgR0rI/zBQjoWB9WPnmvD/A3AGBhIsqdi/PF+bQDOtYPl3wwf1pzAuLG + AjRAku4twnG+OJ9WQMf6OF+AgI6Q9/ckBwB+2z1oQYjN8wKAdG8RjvPF+bQCOtbH+QIEdERacwJCjAZI + 0r1FOM4X59MK6Fgf5wsQ0LEeeeQAoHevDxZiAYQSvA56uXCcL86nHdCxPs4XIKBjvTmfrzkBsTASSNK5 + RTjOF+fTDuhYH+cLENCx3n8+LETgMAHfFSR6hw2KgI71cb4AAR3r43wBAjrWx/m8AgsRuEgAAkk6twjH + +eJ82gEd6+N8AQI61gfLRwvi3KAFfitQxPnifH4izpfFfLQwRg/8aigJNArJiPPF+fwE9ITcdnE+nwE9 + IbedZr4Pfej/A2YhfszJF9lbAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAAABGdBTUEAALGPC/xhBQAAHzxJREFUeF7t + nX/kZ1X+x5MkychIMsYYI2OMJGNkZIyRkZGMkTGSJEkykiRrJZGVkbXWWslK1spIkqysZCXJylpfWWtl + Za211lpZX2t9feXra7/PR3Pe327vOff9uee+732/z4/nk8cfTZ973+ee87rnnvM6r/M6V1mWZVmV69+X + rjolXhjIqXCZZVk1SC/1y+LfA3k5XGZZVg3ipV56yVfhDsCyahIv9dJLvgp3AJZVk3ipl17yVbgDsKya + xEu99JKvwh2AZdUkXuqll3wV7gAsqybxUi+95KtwB2BZNYmXeuklX4U7AMuqSbzUSy/5KtwBWFZN4qVe + eslX4Q7AsmoSL/XSS74KdwCWpRfha2oQL3V4uYfgDsBqV3oBrhYHxIvi1vDPRYuXWsRe9hjuAKz2JMOH + mwQ74v4heBl+Lm4If1Ks9AxNdgB6llvFM2KvuDr8s2V9WzKOa8X94nPRfRn+VzwtipbK31wHoOfYJX4R + nulLcVG4I7C+kYwBMIpL4n/E8ssAfxdHwiVFSuVvqgPQMzCN48tPB959tr+KZ8VuYbUsGQBGcp/4o+ga + SYz3xa5waXFS2VvrAG4Xf+s80zK/Fw+I68MlVktSw/PyPyn+S8QMZJnFVKDI4aPK3UwHoPIznWNEF3u2 + LrTpB+IO4WlBS1KD7xF/EDHD6IOpwB3hFkVJ5W6pAzgthnbswAhwf7jcakFqcMDbvzxH3In3RHGrAipz + Ex2Ayn6j+KjzLEN4W1wTbmG1IjU6S36/CUYwFByFT4iihowqb/UdgMoNj4g+Z26Mf4mT4RZWa1Lj4wTE + CGLG0cdfxKFwiyKk8rbQAdwiftd5jiG8I64Nt7Bakxr/GvFaMIYUGDYW40FWWavuAFRmnLrPdZ5hCP76 + W18bD2G/Q5YCu3wlHhZFSOWsvQM4KBiZxZ6nD3/9rcuSITwueKljhtLHF+JAuEXWUjmr7QBUXkZxr3bK + P4T/FMfDLazWJWO4QSzCRlNg+pD9V0RlrLkDOCZ4oWPP0sfPhD3/1jeSQdwpWOuPGUwfrDefEVlL5auy + A1BZrxfvdso+BDZ6HQ23sKzLklEAW4BTYwM+E3vCbbKUyldrB0Dnmzp1+4lw5J91pWQYxAb8OhhKCt8X + 2Q4pVbbqOgCVk6CfTzrlHgL7A24Lt7CsKyUDuVekxgb8U5wIt8hOKltVHYDKCI+J1NHaD4S//la/ZCB4 + lV8Xqcb1sdgdbpOVVK7aOgD2crCjL1b+Pv4sqsjwZM0sDEWkxgbQYbAHPbsvjMpUTQeg8o0J+qFt2Pth + WcMkYyHmP9XBxBzz9nCLbKQy1dQBjAn6Yefn3nALy9pZMpixsQFEmGUVJqzyVNEBqGxMz37cKesQ2Bz0 + VLiFZQ2XDGdMbAAG95DIRipLLR0A7ZEa9MMy7U3hFpY1XDIcGBMbQJhwNkkmVJbiOwCVi6AfRlexMvfx + 9Z6NcAvLSpcMaGxsAPHpWYQJqxw1dABs3f7vTjmHwMpMsbkcrUwkIyLNFGv9MSPrgzBhYgq2LpWh6A5A + ZRoT9EP9nw23sKzxkiHhfCKENHUqQMahm8NttiaVodgOQOUBMv2k1j3p264Lt7Gs9SRj2i9SE4kCPoSt + xgbo90vuAMZk+mG05mQf1rSSUfElSp2Hbn33mX6/yA5AZSHo5zudsg3F232t6SWjwhPNeYExo1sF8QRb + yyas3y61AyBbEyG8sXL2UfxJTlbGwrjEqlNnYhAbwOhhK9LvXhA40YZwIVy2Vakc+F3YZRmrzz7wE/xI + eMOPNY9kXPC8SEk/Dewt2BduY+0g1RXHe3GoZ6wu+/iTOBhuYVnzSEbG4ZK/CkaXAl8nz013kOqI471+ + GupsKHz92SRkWfNLhna3SA1LxTvtZJQ7SHV0QqQc7wWsFNwSbmFZ80rGhof6hyJ1fZqThos7XmxTom5C + HcXqrg9Cfh8Lt7CszUhGR2KK1DVqfAdnwi2sjlQvcD7UUazu+sB56ZBfa/OS4Z0TKcNVpgH3hsutjlQv + +FZS9118nZk53MKyNisZHw6rN8SQqQCJLB4QdgRGpHoZE/LLDkGH/FrbkwyQLDUsQcUMFBjSfiCIIbB6 + pLohaWdKB8Ay4bFwuWVtTzLEJ0UshRiRbE8LO/52kOroZsFpS0OmVHQUZAdy0I+1fckQl73XpBYnJv2Q + sAZKdcWUCr8KOylXOQMZcTnLr5WPZJBHBU4sYv/JBeDTZ0dKdUcilqfE52J5WkDH8Ez4UysnqWFYHz8r + 7hLNObv0zLtafO65pLrcK9gR2O0IiMK8MfyJlZPUMIcFO7JY7mI+d5vwPM0aLdkPEHPxqHhb3B3+l5WT + 1DDM394U3eEaO+fYjkpCDWsGUa+CNXT8DcfFw4KvJrvpOOXoLUGGHFYiluHf+f9A/D2Zj2gvNjzh2CQw + h9Bc7o2TzqMb60rJMIDceX2HabAbjpNztp4iq3SpDplmMTRmmsU8mU6X9Ncsi6Wuow+BezKqI+qRTuOi + IEknJyh5DX5GqX7JiLRP5C0VkLnvTlFcGNJ/iAeFl8USRH0JtshyYhHBL6QeTz25aEpoy7+KjwTHbjHy + YIRgTaBQl+Rx4AzE34p8t5KrcMBprTFDiYHh/lKcEvaU90h1QwYiVhYYjn8qUncfbhJSpTFCYMrB6MAj + vRFSvfEhZQrHh7I7mrsk8nxXVDCWbPgidQ1iCKyV82BEyNlRKFEPgqE10yU2ueT80vdBB89XCx/EMZHV + UWk5SnWE/4wPIiOqWPwD/0YYeV5SgTDY74rlAqfA/JKttRh+k9Jz87U/KXDEMbSeYy6/DejkGe1hvD6i + a0mqE2DljHanrmJ1uAA/Wl6HnKpAOChSz8/rg+guOpNmEjvoWRnyEfn2oUhNglESfMEYFbA6QbLP5qU6 + YJ5PFqOU045fEXmsxKggwPw0VtCx8OXDUNgZVu0ebz0bp93gDGWYv01n3qahffmSYfhNHtmt52a0x/Lq + 8jx/CHwk8sgqpYIAO+FYhkrNl78TvBTMhwiprWapiWcRZwQv/qpY99rB8Inua2ZpWM/JdBmfCKnl13lf + mFLl806oMIsNHKxFxwq8DsyLCFLhaOhiHYWUXbBu/66oeaifCh0BG38IH682pkDPxlSZ7c6pmY5jUGf3 + hVvnIxWKoAXWhFPz5g+BiiOrLiOOoqTyUi9E13FKUOzZzOVOkZEksQ7VSM+Cj+dxwbFyqcP9VTAKyG9Z + UIXiS0cjkiVn6i8dFViMo1Bl5HALhvtj5nqtwgoI04KiA8VUfkbFRMZyRPnUUz0+sNRRvmHZKtyiAvrW + NdeBl4npRraOQpWLrz4e252WdsyVYC/sUShuNKDy8gG8Q/ABnLrt8RuwGYr7lzEdVkEZAhElSEhj7KHW + oesozGI4pHIAYbFE7vmrvx5kUyL0uQjfgMrJ/oyXBKOY2POsA6PI+0V5fhIVelE53xNz+AeycBTqt/Hw + k/5rqrgIc/mr96rINohIZVvM8/nITd3p874w5S1/n4UeYOEfIFXWHENjHIUMuzfuKNTvYQQ4KadeDjWX + XypGereH6s5CKg/TXEaflG3qWA78Z0wj6sunoQdaxD0T/TbHWjhDRwJNNuIo1O+QrIK5Wcvr+puA/Sa8 + cFsVvy/m+pDR2TF9ZENV3Rvl9IB8NXHkpZ6uMwQqkvuSRWY2R6HuTRw3nl7P9zcDQ+KHxFa+ivpdOvu5 + 5vmscJHfYXf4ufqlh11UKvEDc1TqwlHIisRkParuBTj75nBumtWwQ5JsRRv7Quq3CN9lmy4flak7e56H + FOfNboajgvEP8DUlJRX5BGMVtQ58OW4LP7eWdB8g8jFlE4eZFobebCyatRPQ/YnlICUaKd/nCHcnLJjw + YKdaQ1SE4MtKxUzpWCGV1dpLKLrH4uWfIqTTrAeOsmfFLC+P7ssXGafy1DkZGEGwrIcdOVdCTFSMID6c + FNDrDrn4WkxyIKfuc4+YY6pixsFokdRZk/kEdC98U0wx2LU49XCfUSMjF6dPGyJVEtluCQZh51isQoeA + h36Krz8jk1VnAJrtwBcaZ/La0j2IV+Fgl6mX9eiomN6SXbmuZb25pQpbNMyLIjWQiKH6neFWo6V7EH65 + Tidk5oWNVuyxX0u6nuW3KZdzuRf+A/wIdS/rzS1VYKqjkOEbWzDX6nF1PYFFzNliv2HygY/DWlM9Xc+K + FDv3YvdPhcQ2LFk6A/aUUoUSSITnlKH9Ks8sS3RrpVPW9Yw8SN4Ru7/JD4KFRq/26Fpgp906owA6Ipa1 + 6UysuaTKJfaeyLBYRCEdw8PhT0dJ15OLnz0GUzuCzLywV350MI2uJcs1SUpi914FqxIk9/RxeJuUKhuv + LVlnuysGZN4ZvcSia5lukO9wameQmR8+BuzLGD3n1rUs0Q3NZ8Hv0encLTzP35ZU+STaJFqLl3+toB9d + zxJkiTn5zWV4eQkDHyVdx+iSKWbs3l0W8/xqE9gWJTXEovFGS9cSADKVI8hsD+I1RmfQ1bWs/PStOnk9 + v0apMek8OK3I8/464LzKUVmHdR3TQHaVdv1LjAqZXvCR8Dy/JqlBgcQO3tNfD3Tk7N4b9bLqOqaVOJmx + CZKWcoyd4/ZrlBqWGANyCcQMyZQLwWDHQjMnS9fytSele7Vpy5uXGpfYAjKwxAzIlA/hvQ7IseKSceD1 + H7rsY8qD5dwnQnNb1jeSYeDJdahv/bC779bQ7JZ1WTIKQj/t9W+D14SdeNZlyRg4s81r/u2AQ/BoaH6r + ZckQgC3G/vq3xevCo4DWJSM4IJzgoz0YBdwRzMBqVTICTlzx179NOG3IkXytSo3PXm2n9G4Xjm/L6qQh + a4NS45Nn0F//tiHjr0cBrUmNTqIPcgfEjMK0A2Hf+4NZWK1IjX5SOOrPMAJ8NJiF1YLU4GzxJBgkZhCm + PSY5MMYqRGrs/cJLf2YB+/u9JNiK1NjkDrTzz3R5IZiHVbPU0Az/h+R5M23BRrAbg5lYtUqNzPDfCT/M + MmwVPhHMxKpVauT7hYf/JsbzwUysWqVGJvwz1vjGkNffG4RqlRqX5I5O+mH6cFBQzVLjkuN9yIGipk2Y + Gp4O5mLVJjUup8TEGt6YBReDuVi1SY3r6D+zEx8LRwXWJjXq9eLT0MjG9GE/QI1So3KwA+fExRrdmAWc + /nMkmI1Vi9SonOrSPd/NmD7OBbOxapEaleObY41tzDLPBbOxapEalcMhY41tzDJvBLOpX3rYo4LTcEvg + bCh2snTtWyLW2MYs84loYyVAD/qCIACiBD4JxU6SruPQT5Z3Yo1tzDIcErMnmE+SdB2h5p8XwoVFBxCr + hBwZ2wEQAvxZ5z7GrIIzAw4F80mSrnuvc5/ceaGVDmCv+KJzH2NW8S8xKl24rnMHMCNjO4CD4m+d+xiz + CnIDjDo7UNe5A5iRsR3AbYK8b7F7GhPjrmA+SdJ17gBmZGwHcEQ4BbhJYdSuQF3nDmBGxnYAdwpHAZoU + HgjmkyRd5w5gRsZ2AMeW7mPMTjwWzCdJus4dwIy4AzCb4olgPknSde4AZsQdgNkUzXQA58U7hfBSqOck + 6Tr7AEwqo84L1HV0ALEo1hxp4zAUPahXAUwqY52ALDmfKIR9odh1Sw9KozgZqEnhfDAfq3SpMQ8IZwMy + KZwM5mOVLjXmHsEOr1hDG7MMewF8WnAtUmP6QBCTAvtGbg3mY5UuNeY14sPQuMbsBHvlbwnmY9UgNajP + BDBDIX38DcF0rBqkBv1up4GNWcWbwWysWqRGPbfUyMb08WIwG6sWqVE5GBTvbqzBjeniGIDapEa9ReDc + iTW4MQs4GWhUNiArY6lRWQn4IDSyMX2MzghsZS417MVOQxsT431xTTAZqyapYc8IdkHFGt4YsAOwVqlx + fUKwWQUfh3uDuVi1SY3LCUEfhcY2Zpk/if3BXKwapQZ+sdPgxnT5ufD8v2apgUmEwFJPzABM21wIZmLV + KjXybuFzAs0yHBzjLcAtSA39g07DGwP4hq4PJmLVLDX0SeFpgOnyVDAPq3apsZkGOEGIWfB3cTiYh9WC + 1ODeHmwWkMr72mAaVgtSgx8WPjLccF7EuWAWVitSo18t3gxGYNqFFaHdwSyslqSGPy18YEi7EPr7bDAH + qzWp8a8X3iLcLn8WB4I5WC1KBnBWfBUMwrTFy8IqXWpENvlcHf4zSbpul/hYxAzE1MtfxMFgBlaJUgPi + yLtdXBKnwz8nS9dyQrJHAW3xQzHqo2FtWWo4uEmwlv+loEHx5o5K5aTrbhD2BbQDOSEc+FOi1HAM9+8R + HN7QbVQ8uvTqo7Zz6rpTwlmD6wc7YUt4srhG3CyuC/9kbUqh8veLV0Xf0h07uu4OlyRJ19GxMJWI3dfU + w+/EqGO/dB2p5cks/bY4Lhw9uAmpohmiPyL+KGKN2gWH3o3h0iTpOvwJOIdi9zXlg5/n4dDcSdJ1OIu7 + 00RGiz8TdApOIjKHVLE4+Y4KYrUJ2ew2Zh/83dMiWVwjng33iN3blM0vRPKZf7oGnhIxu/iH+JEg36Sd + ilNIFQkc5MFcjQpervSdYKQw6nhnXcdR4s4bWB84/kYd+KHreLl3Gn1y/xfEXmGNlSrvOkH67nWz9nxf + jI0NIF/AmI7H5Alf7mdEsnQNo9BXROy+Mb4QTwpWqayhUmVR0QfFT8UUyTqYy48dBVCW54WnAnXAYR+7 + QvMmSdfdJVI/Bqw0/EY8KEb9blOiksQTgtjsWIWOAYfPOsFBlAnDid3blAOpvkfl+tN1jEbfDfcZAx+Q + DwXL1l46XJYqhS/tMYF3lV4zVoljYD6GMy/Z4dOVrsfDiwHFfsPkD576B0NzJkvX3iem2C3KiPYtgUPb + KwaqBMDJ95Jg7T5WaWOgosntzou7triHeED8U8R+z+QLX1+Sv44NDCMuZOoRILaOP6HdFQM9OBU7hZOv + C6MHnC+Pikkzu+p+nCqMP8B7BcqCUeXoRB+6luE/q1CLUPMpwT9FGDsfwTbEg4oDYion3wKGedxzlMNv + iHRv8gbwG1NOU8x8/FasvdNP92CKSsQfnckcWaSJSnxYjApcK0Z6QF4gHnRIJN9QeBkZRbCff/aQTP0G + yzpML9wJ5A1f1+Oh2SaR7of9PiR4Yaduf6YqxJ3cK+pyFOqB6EFvE8ROT7mkxrCMZA6jYrrHSr+3R0zt + sDTTwRwbn80s0n0Zsn9PzHHCNCMM3pM7RfmOQj0Ey2gERExZWczDfykYlm3FiaLfpROgx3YnkBc4ah8X + s9qF7g981JgSzuEcXjgKiYkpz1FIoQXLHVN+KbkPy3EXxFpLe1NIZWBX4ifCnUAe4AfiY7OxLye/Je4W + c/kH+HDifOaDU4ZUUOLoWX+f0nPKOiy7rrJK36TysJTzaxErs9kcvPzfEVsZNut38Q8Q8cdJU3NEjv5e + sLqVr6NQhVt89RmeT/nVx5t7TmS571rlOiQI+YyV38wPw2W+/Fu3D5UBJzEfPxzdU48MuR8jTpbP83IU + qkBzfPWJvSaIY1SKr01KZWSuRg4CTwc2C+f54ZnPap6s8jAyJDMV5YuVex2YahCazP6E7ToKVYA5vvqL + JRF24xXjAFFZmafRMHMMAc2VsGeEr2GWUrl4N46IN8QcjkLu+RPBCHTz0o8Szcfmnam++nQgOPkYzhW5 + e0rlZiREurI5HELmMtgJfpc7Q7VnLZWz6yicI5IURyHRipvNQaAfY9g7laHjxHldFJ+jXc9A+CgrFT50 + dHoYXbFOvi9UdzFSmUlpx3SFwLU5poqj8xyOkn6MEQBpumKFGQoVgQONHVflBz4E6VnghMArPEdjtwjO + PjaOFb23XuUno/AcjkKmGpt9h/SD7LgbO7/BQcLQ5eZwu+qkZ2NY9prw4aPj4SXh61bbR4I9MTi5p3AU + co/Nn2+oH8XRcTEUYijMgxg54DysXnpGRkoM/dipGKsP0w9TTOI/9ofqrEp6Lt4fPqLrOgpJdbYdh7l+ + mLVPeuhYwbrQk5NPndTek27XLUF6Zry1JITwaGBnFl99gmuqz6KjZ8RRyKE0rKalOgqJk9legJB+HNjF + tMohyPyNtMnFOW+mlJ4fByFBTfYN9MNwlqHx3lBtzUjPjKOQTm+oo5C/wZ62KxWAHow1yeUC4rUlH1pR + a/pzS3WBI4j00axluyO4DB8JNtewdt60rej5hzoKebfyGE2rIATCMMRfFK7oNf25pXoBllKJGGt5yZAX + n6kRuzurcfJNIdXHKkchI+4T4U+3LxUGmMfwVWM0MFt2npqkesIRxNZStn/Oscc8Vwgg44tPQli/+D1S + 3SwchThDu45C6i6velOBKCy9lhs0UaHuGBEwNfiDqHFqwDMxSmTliDMYbScDRV0JptIcbTb6vAurAKlx + mU6x/ROv8Bxx5JuGYT6hsKSEy35zV85S/bH1+LCwT612hcYmPRRHnLHcU9IeA8qKN5v0WTj2fCiGZY2V + XiDiLQgvJg8iy4jsn4i9eNuEGAfKRhkp6+iU3JZl9UgvFrsO+aqyGxMPOvPqbQQYEbRChCOZkjmOnejO + utNbW9ayZPSs227lpBd+U5Cplg6BkGOWjfAdkEaK5cUpOgbiOfBFsLTLVlxCV1niJSkF+x228dyMiEgA + +lD4J8vavGSAfI35AuKZZflz64Es+n08xotOifIwHCd5BlFmjBr4WnMqTQxy6/E3OOzOCw61xA+B155E + qFuN69Dv4xch7Te7SOmY6JQOhf9tWZuTDA9YtutmASJog7BnlvSsiaS6ZFMVnVEsAy+5JLykaG1WMjoC + NPqi+AiIek5s9OCS2qT6Y4rD6INpR5/jk+nJ6GPgLStZMjiG2RhlzCAXEPiCV/x+kWVW45ylOiMegpwR + Q0KlyZhrB6S1GcnYCHseGqSDI45pQXPboMdKdcXLn7JrkmnYM+Fyy5pPMjS2bTIXjRliH/z91k80KkXU + VaizWF32we654vNKWplLRoaHPCUqj/Xy+8Ll1kCpzsimm7KMyWiBlRg7BK15JONieY2w3JgB9sG6vL/+ + iVKdkUBlJz/LMuw7OBVuYVnTSsbFOnl32W8n+PqfCZdbiVLdsdLCKVGxuu2DRBnucK1pJaNiqzPzzJjR + 9eG5/xpS3bHaQnRjrG77oNN9LNzCstaXDIr1aLL3pOzTx0/g9ek1pTokAjG142V/RNM5KK0JJWNio0tq + DnfOCvTS35pSHdL5PiVSOl/+ll2J3jdvrScZEWGob4qYofVB1NrxcAtrTaku2fyTegw7HfbRcAvLGicZ + 0WmRuv+eHG6O/ptIqksgojI1bz5nCToZiTVOMh4CUvAqx4yrD5ai7gi3yEIqD1uGWb7kwI2d+CxclpVU + LnYCMq2K1XkfxBGcC7ewrDTJeAj6Sf3qcER4VsEoKs8+MXT58qtwWXZS2cgiTAcbK3cfTB2qPYPSmkkY + jSCvXcyo+mDeeTjcIhupTLV0ACwLsq8iVu4+cAiyM9OyhksGQ9BPiucZOMI6O8+zylRFB4BUPhKdsN06 + VvY+SNiSXcdsZSoZy5igH/4+y5NsVa6aOgCWBTkRN7VzduIQa2fJSDAwos9SDYxUW1muO6tc1XQASGVk + epa6LMj2be8TsFZLRkIGmtTz+vAVZJv9R2WrrQMATsZNddCyouPzKq24ZBw4mTh3LWY8fTBSeERkK5Wt + qg4AqZwsC5KQNfYMfXifgNUvGQcZdFOXmbJPR6XyVdcBIJWV1OSp7eV9AtaVklGw//y9YCRDYcNP9tt9 + VcZaOwBGbD/ulH0IjNi8T8D6tmQQhJqmZPoBOozsN/yojFV2AEjlZcWG8wFiz9IH8RpHwi2s1iVj4ICP + XwXjGEoxG35Uzpo7gDG7BYENXt6vYX1tRBwzNfQFWYCzsAgDUjmr7QCQyrxbfNp5hiGwT8C5GluXjIAU + 1JylFzOSPhhC3h5ukb1U1qo7AKRyc/xZ6hSOUZ9PMW5Vanx4XqQOHzmzvxgnksraQgeAE/edznMMgTp5 + MtzCak1qfM7wS40rzzbkt08qb/UdAFLZOcg0NYko7Xkg3MJqRWp0nEevBCNIgTj0oqTyttIBjN0tSOi3 + lwVbkhqcPH+pXwtCfovbW64yN9EBIJV/zEauL4WXBVuRGpsvxaXQ+EPhBSJBSHFSmVvqAOBJ4WVBKy41 + 9Ekx9HDPBcVuJFG5m+kAkJ5h7LLgPeEWVq1SI7OJ5P3Q6EMp2jhU9qY6AKTnGLMs6N2CtUsNfFakbiNl + ulDs8FBlb7EDYFnwrc5zDQG7OBtuYdUmNe4u8XFo7KEU7yBS+ZvrAJCe5Yig/WLPGYO/9XkOtUqNS8w/ + J84OfRmgqKCfmFT+VjsAlnovdp5tFaRNZzu4lwNrlhqYoeF5QQ78mCF0+UIUv3ecZxDNdQBIz7NXkAMg + 9qyAf4dzH0kzZrUgGlrgKWYXWd+aMctIF0Tx0jO03AHAQzxXeL4FtC9OP5KKOFloi1LDA+fOsW68/JWo + ZqOInqPZDgDpmRj1sc6/eEaG+w8KH95q/X9HgIOQL8VHggjBao721rM03QEgPRfHjLNZiK3ftLVlfVsY + heA0YEYF1TiD9CzuAL5pW8tqSzL65jsAy2pWeqndAVhWq9JL7Q7AslqVXmp3AJbVqvRSuwOwrFall9od + gGW1Kr3U7gAsq1XppXYHYFmtSi+1OwDLalV6qd0BWFar0kvtDsCyWpVeancAltWq9FK7A7CsVqWX2h2A + ZVmW1dVVV/0fpEjmdGILDGsAAAAASUVORK5CYII= + + +<<<<<<< Updated upstream +======= + + + iVBORw0KGgoAAAANSUhEUgAAAMwAAADMCAMAAAAI/LzAAAAABGdBTUEAALGPC/xhBQAAAPNQTFRF//// + 85wS8cQPlaWm5n4ivcPHf4yN85kS8ccP5nwi8cIAkqOjl6eoztXV5n8h85kAt7/CqLS2ipma3+Lk1sNz + waJr7I0a6IMf7pEYxcvLg5CReYeI6ocd77oS54kf8pcA8PLy6pob66IY6ZQc7a4V//z377wR/vno7aoW + 7rAU/e7b/vrv+tKVvsTF9M1CupRy+MN69rZZ+9+3+uiv+MiJ/PLU/OjI++7A97xk9dVq7YYR6XsY9tl/ + 9Ko888o1+N6M9dJZ+OCa+dCf6d6y1LV20J961b10/PHOvpxt386y9a9P9KU0+MNy9tdn+dKm+OCV++y4 + e4q6ggAACXtJREFUeF7tnWlbFDkQgKUdnekGhlV25VY5RnBGkWXZEVcYgV338P7/v2Yr3dVXUpU+JOnM + bt4P2gRh8j5VnVTSh3c8Ho/H4/F4PB6Px0Mymkwmh4fjQ8FkhI1zyGQ8Pf1ydnL+4fLycjabHV+9ubj+ + 9vqvQ/z2HDG9Ofn5cndl5cmKoD8IooRgdnXx9fUchWh0+unjwsLKykIGyKQIoWD2+dtc+EymnyAcKJFS + kIkRMfrsfMKNbz6sPEGDArKMIIqOr//CH3OR8dllMblyKBmhM7twVWdyXjpPitAyQie4cjHZxmdUfiGc + DBBFF67pjG4umaDEaGRAZ3Y9wV/jBONzLsEStDIQnM/unDqjm12tSpUM6ATXjsw743P+ZEGqZEDHjYFg + +qHSpYZMEB2/xl/YIacfK1JMUEMGxoFf8Fd2xosaKvVkxCCNv7QbJifVKSaoJQM6Fx2O0ZOTWnGpLRNE + bzqzGZ1gXyupKwM2XQ3R1UNySm0ZGKLxl9tldFbbpYEMnDcdxGZ0gx2tQwOZIPpq3+YU+1mLRjLBN/wI + a0wXag5kMU1kYL6xXHZO9pq4NJOB2NgdoGtOlinNZCwP0I1OGKChTBBYLNPGdYrLIk1lopm102b0qVmS + tYiMvUQ7bRiXFjJBZCvRGo3KMc1lggg/zDANypiUNjJWFjfjj9jDBrSRsTIGnDVOslYyVirOxsOyoJXM + 7Ff8SGM0Kfxz2shYCM3hHvavEa1kgsD0VtqLNoFpKRO9ww81BfauIS0jY3iuOW0VmNYyZsuATy2GMqCt + zBv8WCOMtVdheNrKGB2dv2DnmtJSxui6ZlR3B1OmrYzJqaZtlrWXOTaXZ1PsW2Nap5nBjZqbdgPz98h8 + xY++dUY/t8yy75C5MrXrNGlVlwlaywTGttDGbbPsO2QiUyPAly5krvHDb5vmtUw//bu9zGf88Numapbp + b6edR7IGlBns7O/EBxk7u1KDTDTDD79tko6x9NfCtZJNf62HDYnMYOdx+LjY+cEzaHimj5qpZYD+lAGX + Xsmm0BDLCJdeqfPgIhrwK5rITEGjH8xE13tFm/4wbxAysYtoyGKDDaVgKRgazqY6mcSlYFNqABl0KXRe + aSCJzNyFottiTrue2cD5goiG/iBziTsvAiVyLG3QnDeGVps3vEzugjZSQ7/ggp3PXeIG7LqKoYmGv00m + S6nkT+i81LCepVTy59qO1MBnmqEtGlamvx33qDfcHsZ/h2tpXPAb4Vra9f14VIDOJw3hMG3Y52JjW2Zh + O+nQo/6jpM8pjxbShuSvcC/YC5N/mzUcxYfhLvZdwdDVAF5mPe7ZOhyVbB6JBjwGQuh6EOyhGAANMMod + iIbhETcEWJcRp8hQuEDnk0wTCJeCTTgULsEAYxM3CIPBwVro0Dkj8gxH5IJN4pIHK46LAGODcvF8w2eZ + qbWmZp6BPAuTyGShSF1Sm8wFbJLTJG14DmFls8zU0KypAPrDXriNx0nnc5dYL+zlLnFs4vMlYRfCiocE + kZk7aXS1GYxnQ8wz6PwwLLoImzSlEuC8KTTAKbOvqQAMLTX5NFtYh/I3zTPofNkFGkouwF7WMIAsC59r + ZAxtA+r2MyCTsjxT6WPPCAb7kJV4TIIfftuca0Ij8gwPCXClSTLUjWXmbnPU7QFCnsWzJg0vMziCmD7H + LwiM7QLqRgAo+TV5pokMjGW69YyxrSbtJiDkWTpvqvAysBLQZZm5TUDtFY31YVrRELAyg6NhqJkxTd7d + pF9ravKMj0xVlpm7+VR720yhPlNgZURdto/HFAavA+rzDIYlLs9YGZgxe9osM3jrqfaaZrE+k2Bl9HWZ + 2Xs1D3U7tJp5k5WBGVNXlxm8Cgho86xUn5VgZCrrMqP3Aeh3Nfk842Qq6jLTt57rrgQ+ZvOMS7OKuuwY + P9QUU32eMfUZLQMzZi88wC8IDO3M5ugu0vLzJhMZ/YwZXZm+eU5bBbD1GS2j38mwcWvzRLOqgfqMzjNS + pqIus/JMreahBpFn8oo5ho5MRV1mPjD6s4arz0gZfV1m4YwRaLacuPqMlNHXZcaHMkRz1jDzJimzH4ZD + PFSx9ojjeBf7qMLUZ6SMvi4zWpUV4a+hMfUZIRPXZQecjLm7mRQOP3A2pX3aHEpGl2XRscVXHfDDs8gz + dTyj0kxbl9kYljPYpwHp+kyVETMmW5dZflx7wuYZWZ8RkdHNmJHl92mwt56T86Yqo6vLjN2WxTHi7tci + 6zNFRleXdfBOAO62YLI+UyPDZ5mFh4BUuJ0aah2gyOjqMttJFsO8qEFcR5fzTJERMyadZV29qoF58pyY + NxUZdsa0/cR5BjN1EvWZIgPCdF1m7clZBfopR6I+k2T4uqyTN2gkHJLrNKI+k2Ugy8hd2U5fPzUlLwuo + 9Zkk82yNmzEtv3CiDHnfNoxn0nWnsgxbl1mf+iWo8Vmtz6TIMDOmpWU/D1kIKPVZWYapy6JZhydMwpRY + Qyv1WVmGrsuiwIG3tb3ADhdQ6rOyDJ1l0buOk0wwItbQcn1WkhFXy9UZMzp2wAUWatjjAvL+WUmGnDEj + 2wsyDqKskebNkgxZl3VXxkiM1LIG8qyHh4KSTI/Isg7LGBl160mqzwoyZF1mdWupCuUBTqk+K8qQdZkD + o3KO8s6Dcn1WkKHqMuNvMWiGMj6X15u5DFWXOTIq58iJVq7PCpEhZkzbL2erRt5ML82buQxRl3VdKxNM + pIVaqT7LZY56cl3myPuAy0iJVsqzXEZkmfR0ifX3GdZBWtoU8yyTUeuyjraWqpBqtOK8mckcKDNm1NHW + UhXSYxyFeTOVUa8wOTbF5MCqs8hvb9++xcMnA/EfTgDQtJ4ex3SxsVyPf34q8verV6/w8KcfE/58//79 + H3ic8Dv+qHssL96lWbzHsYo/6h5exlW8jKt4GVdZXlyiuYtdV3FXZmPrPs3W3UWGZfxR92Bl7i9hvsl4 + GTt4GVfxMq7y35LZfMjwgMNdGbYC8LVZx3gZV/EyrvLfknmIqxSFez8wuCuzcX+T5j7ONyq+nLGCl3EV + L+Mq/w+ZLey7gsMyy80XZy6XMzgVyvjarGO8jKt4GVdpLuPwemZ5CWcPYKkotohLsYR7Gznuytx5WuAu + t1Jbwn8Qgz/oOqtYyig4HAyeDey8xAZ+e854id0v8RK/OXcQNnPrAufNJjogm3N5vqQ8fbCZrXG2Nh/M + y+DFsfry4VbMw5dzHRbk6eryxsby6rxHxePxeDz/c+7c+RdrgDmlMtYOswAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAh4FJREFUeF7t + vQ/MLld932m/932e98/953uNieOLb+0acLFMcPjj2BENLSpdum7YsiUlISLLKikRLV0atnSdpKWblogW + SkRFl8gpuzR0nbKhpSVLA4IFERGxsuSuV1YtoaKgeMMuCGRkZOTIkqXs7zv3e+bOPHNm5pzznOd9zszz + /Upf2ffOfD/nzpnzO3Pe551n5hpJkiavI/PLevxm81sTjayPCaNNSZJ2WX/hL/y5a817DV/LTUkST7wY + zZR3uxkX2TeZcSF+t/kB88fMD1977TUP23+/av6TQvw1M/5N9m+79mPm3zD/A/PPm3/a/h7HgmOKVmL/ + 9Uo88WK0a7woWWOnVs1NSRJPvBhNmHfZjIsiLu6/bMbF/StmXEh9F9jKdjHt2LdfqLfEwzHiWHHMWNig + D9AX6JOWBvovSeKJF6Nd4wXLGsKqY9+8aBh/Tlp9IMe8eAlCjnnxEoQc89l4p0+f/sH9/f3XnDp16p17 + e3v/wi6GX7RNj5p9F8VRr15YYd9+oS6Yhz76AvoMfYc+PHPmzA+uez6Yz3Z+mRcvQcgxL16CkGM+Cy9K + aIQNLhvGn9c5GPHECxJyzJfEw0+wbzF/wPw5u3h9y/wnzmtcDCsjL9413zR/zow+/lkz+nz0Jx6cR57P + dc5vLeSYFy9ByDEvXoKQYz4LL0poxHxgPmwYf17nYMQTL0jIMb8t3kXz68z42P7j5s5P9M0Ll/PqPjEW + b5T3mBnnAucE5+YGcyWcR57P0PM7KOSYFy9ByDEvXoKQYz4LL0pohA0eNYw/r3Mw4okXJOSYP0ne8824 + E/6j5tGb7hIuXoMWL5n31Wuvvfajy+Xir589e/YlA+c3WMgxPzRegoUc8+IlCDnmxUtUcNZ2xN2Fx+bT + DePPe9wlSsgxL16CkGNevAQhx3zNe/nLf/iMXXD+rG1+l/lT5m+bfRcXr0+d2jOfani9i6F4WXnf2d8/ + 9WlbFPyibXuVOepmKd944Z9VbwFCjnnxEoQc87l4WEzgpsHxPHYyo8EzDePP6xyMeOIFCTnms/J+6Ifu + vHh8fPz65XL5gf39/S/bpmfN3ovJmBsXmtq+/UIt3sZ5ONc45+8zv9a8NHvlxos56/gjR7xIIce8eAmy + HC7+uGFwfAGAHcxo7FzD+AesczDIi5cg5JgXL0F2ob/l4ODgby8Wi8/a/z9tPxVWF4drr21dHIKNHPLg + OIsX7oJ4T5s/bX6H+VZzJYwzjrcs4w855sVLEHLMi5cgy+HijxsG4eEFAHfGxwzuH3Ce/13nYBzHWbxA + Ice8eOHCT3b4Ce9911577deuXBT2G8bFIe2OdeTEmy3v65b7Z6dPH//EnXe+6MY1xl8t5JhfZzzXQo55 + 8RKEHPO7wsP1HDcMum8NYAHgvwcAG8y4wcB99ICGSzoY8cTrE36Cw09y+IkOP9mVfrERr2zeM8vl4vOH + hwe/ZP9/m22PFsYtx2/KeO4IOebFSxByzO8SD9dzuF4AcHNbtsGtFHCXYfN3D+rsACHHvHgJQo75GB7u + 1sdT5fCVsKHJnNbFMNTidXh4kuF7zHeZR4Vxy/EbM557hRzz4iUIOeZ3iYdP8t23BrAA2OfmtmyD+x0B + dnQLgHVuONDJEy9YyDEfwsOjY/Hd70fMrUnceQsXhyiLN3ne4+b3mu81d4Rxy/EbMp5HhRzz4iUIOeZ3 + ieeu4W4BgOt770f/uDsQKwS3AFj3qwuld4540+Lhoo+v6T1k9k3ItQu4OAxavNnxvmHGJwMvNqt+xYsS + cszn5LlP790CoP+hQbYBNwVgdeAWALA6O0DIMS9egpBj3se7ZA666DsXeHFoWbzZ8x47ODj4hzfe+AN3 + esZztJBj3lcf0UKOefEShBzzpfNgtwDA9Xzwpr/mAiD58YKW08kTL1jIMV/z7rrrxdfv7e39hG3Gs9+9 + k2yfJ3BxEG+HeIvF4vePjo5+9uzZM6dte7R89cE/a34JEHLM7yIP/8UCAJ/k91/PbSNCbgHQ/zuCEZGz + qYMRL1LIMT8J3nOec/3Ll8vlh2wSjXoKn/OmJ3Px4ixei/eE+YPm6lcEIVqtD7rY+qXFCxRyzG+Kh/8f + v4cPO5ixAFjnFYW73tniRQg55PE96+Pj45/HT0oTmsyjLZ54DX/FjDcanjF75erDnLXeyBEvUsgxPyVe + 2Lf3sJO5/8EAI2J+ap0jXqCQYz4b78KF6+45OFg+YBPl90548h21eOLFeA3ek+YHzHi1cS3UB+srW70x + L16CkGN+njzbMenCD6ERNpbW+IqQY168BCHHfIm8pU2KP7dY7D+cMFl6vcbk67V44sU4Iw9fZ30b7hVg + feWoN81X4m1OaISNZWkcOebFSxByzJfGw3v077dJ8duFTr6VxRMvxpvh7X/38PDgn1y+/Lzb1qi3Ssgx + v279VkKOefEShBzzRfKihEbYWJbGkWNevAQhx3xJPDyh78Pmp6cx+YonXphPgIdHEP/mqVOn7rTt0UKd + sl7Xqd9ayDEvXoKQY75IXpTQCBvL0jhyzIuXIOSYL4WHJ6N9wtw3uVV/LnjyFS/C4m2ch/davMocJNQp + 6zW1fltCjnnxEoQc80XyooRG2FiWxpFjXrwEIcd8Cbw3mHGHc8zkFmXxxIvxzHgPm99s9r/IxYQ6Zb2m + 1G9HyDEvXoKQY75IXpTQCBvL0jhyzIuXIOSY3ybvyPw2M16S0pqwtjxZjlo88WJcEA+PHX6nufU1QtQp + 6zWmfnuFHPPiJQg55ovkRQmNsLEsjSPHvHgJQo75bfHwrv23mjEZdSapgiZLr8UTL8aF8vDALLz6Gs95 + 13wlXpQsG/btPzTCxrI0jhzz4iUIOea3wcPHj3iIydfNvkmp1MmytnjixXgCvG8eHh7+nZe+9CU3BNTv + qJBjPmQ+GBVyzIuXIOSYz8Vzj/4fz2MnM54olKtxnbzp8vD7x6+avRMRPIHJUjzxgj0l3mKx/0dHR0fv + uOeeV1zoqd9RIcf6D5kPRoUc8+IlCDnmc/Fw8ccTf8cXANjBvPpgipIORryT4b3R/JjZOwk5T2myFM+f + GbJ4k+Hh07m3mHtvFvQJdc/6H5sPgoQc8+IlCDnmc/Fw8Xfv+xleAHBnvEUIP/27f0RJByPe5nmvM+MJ + Zd4JqOkTnNy8+49ZPPFiPBMePq17k3lUqHvW/9B8ECzkmBcvQcgxn4uH6zne8ou3/boFgP8eAGww4/3B + +OnfLQBKOhjxNst7pRlfOWpOJr3e0uQWbPHEi/EMeY+aX2v2CnXP+u+bD6KEHPPiJQg5M/LgOK/Lw/Uc + rhcA3NyWbXArBdxZ6hYAYW8V8gg5c+6DEW8zvMvmB82+ScTrAia3QYsnXoxnzvuM+XZzLdQ96983H0QL + OebFSxByzOfk4ZN8XM/dAmCfm9uyDe53BNjRLQBgdXaAkGN+Urzj4+Nztvk95qfNvonD68Imt47FEy/G + O8J7xvwBM2pf89/8ee4a7hYAuL73fvSPuwOxQnALAKwc1NkBQo75SfH29vZ+2jY/bvZNFr0udHKrLZ54 + Md5B3hOHh4e/cO+9d19szgdmzacBQo75knnu03u3AMAn+70Xf9wUgNWBWwDA6uwAIcf8ZHjnzp378zYJ + PGSbvRPEkDcwGYknXrDFy8dbLBZfPXfu7H2cHzSfBgg55kvnwW4BgOv54E1/zQVA/0phRJbTySuYd+nS + TS9cLhf/usTJSDx/ZsjiiRfjAd6/s+14e2eUVucXutj5j94VHv6LBQA+ye+/nttGhNwCoP93BCMiZ1MH + I16kkGP+PJ4Sdnh4+D9awX9/ApORd/8xiydejMXr8HB/wPvMeL/HqJrzS8NFzn8N7xIP/z9+Dx92MGMB + gHsAdPEPEHLMF8+77rrzr14sFo9NbDKKsnjixVi8QR4eJPQac6+a80vDRc5/De8aL+zbe9jJ3P9ggBEx + P7XOmT3v9ttfcOng4OCfW7E/O+HJaNTiiRdj8YJ5HzOfN7fk5hdz1vmKHPEihRzzaTzbMenCD6ERNpbW + +IqQY168BCGH/NmzZ/7qYrH/h1ucPLwWT7wYi7d1Ht44iEeBV3LziznrfEWOeJFCjvksvCihETaWpXHk + mBcvQchdvnzzn1oul79dyOTRsnjixVi8onifth8obuH8lG2+Yl68BCHHfBZelNAIG8vSOHLMi5cg5I6O + jn7Wivw7GYq99MlIPPGiLF4O3v73j44O7881XzGfbf5jXrxNC42wsSyNI8e8eAmywrxtsVh8Pm+xa7IU + L8zi7RbP5pqHLly47hWp8xVynO+yzH/IMS/epoVG2FiWxpFjXrwEWXH+nBXl968Wet5iFy/O4okX4wnz + 8JXB+81RwjzH+S7L/Icc8+JtWmiEjWVpHDnmxYvXRSvCf3dCxe7df8ziiRdj8SbJ+5L5knlUmOc43+WY + /8RbkxclNMLGsjSOHPPixevVVoTf2EKxB1s88WIs3qR5T5rfYO4V5jnOdznmP/HW5EGWDfv2HxphY1ka + R4558eK0NL9vy8U+avHEi7F4s+HhuQFnzC1hnuN8t+78Vwk55sVLkOXco//H89jJjCcKoVFndXagkGN+ + XR7e4/1IQcXutXjixVi82fHwFMG7zZUwz3G+W3f+q4Qc8+IlyHK4+OOJv+MLAOxgxrOEm/+Akg5mV3hv + Mz9dYLG3LJ54MRZvtrxnze+++eZLeK9MifNpJeSY3xUeLv7ufT/DCwDujLcI4ad/948o6WB2gXeD+VPm + kou9snjixVi8+fMWi/2HnvvcG35ojfmvFnLMrzOf1kKO+V3h4XqOt/zibb9uAeC/BwAbzHh/MH76dwuA + kg5mF3ivNH/TPIliF2+yvAfoB80P+2y5h43xR4G8UUf++0YtXtG8758+ffqnE+a/Wsgxv858Wgs55neJ + h+s5XC8AuLkt2+BWCkdmtwAIe6uQR8iZS++c0njvMON7tlMrdvEiXQBvUBi3HL/1eL548cLLTp069Qrb + jEXqW+lfMbvFBBYOj5s77RVwvIMWb2O899t2/0VnQL7xxz/r+hEg5Mz4JB/Xc7cA2OfmtmyD+x0BdnQL + gPH3CfcIOXPpnVMSD+/hxk9iY8XUKbwQiyeex73CuOX4TR3P0IvNrza/1f4dv7ZcLv71YrF4xP5t393S + 8fZavI3zvmDGrzWDhHHG8bbO+KuFHPO7xHPXcLcAwPW996N/3B2IFYJbAGDloM4OEHLMp/Keb37UHFpM + URZPvB57hXHL8Zs6nltCjvmahxdX7e3t/Xnb/Haz++Sg+uRrzAX1n9fi9fLwyVD9LYE++cYL/6zrR4CQ + M7tP790CAJ/s9178cVMAVgduAQCrswOEHPOpvPvMeJhGbDEFWTzxBtwRxi3Hb+p4bgk55kN5+MorHiyD + Xyt80tz6dUJh/dexeKM8LPLwayOvMC44PkLHy6CQY37XeLBbAOB6PnjTX3MB0L9SGJHldPLieJjk6uIo + oDgHLd7seC1h3HL8po7nlpBjfl0eHjf7Rjuuf2bHiF8hpB5vyxn6r2XxongfMePXnrUwLjg+1h0vlZBj + fhd5+C8WAPgkv/96bhsRcguA/t8RjIicTR3M3HgXzZ8x1wVRWHF2LN4sebUwbjl+U8ZzR8gxn513++0v + uHT27Jm/cnBw8Kt2vJ+3zU+ZfcfX60LPR+0d4eHXPpfNkxp/DZfMw/+P38OHHcxYAOAeAF38A4Qc8yk8 + 3BiFJ2bVhVBocdYWb7a8Shi3HL8p47kj5Jg/SR6+lYBP1B4y+461dsHno/KO8Z7Y29v7L3g+h85vsJBj + fpd5Yd/ew07m/gcDjIj5qXXOtnivNbd+Wim8OMWbN2+u9Ya7zd9o/rj52+b6mAs/H7vKe/bo6OidEee3 + V8gxHzNeeoUc8/Pk2Y5JF34IjbCxtMZXhBzzc+Thbmc8JnN18DcKKUsxiSdekDFuOX5TxnNHyDFfGg93 + nr/b+ukrJZ+PXecdHBz8WuL5rYQc8+uOl0rIMb8TvCihETaWpXHkmJ8j733mwcGfu5jEi/Mu8jh+U8Zz + R8gxXzTvpptufNHh4eHfXywWD8/9/E6U929se+vmwBC582vOOl7ImT0vSmiEjWVpHDnm58bDQP6EOXTw + t/YLtXjixdjxEsazV8gxPyneYrF/i21+l3n0voGmp3J+J8zD+cCN0kGycznJ8WcughclNMLGsjSOHPNz + 42EAdyaWLRRTlMXbHV7kePYKOeZj68Mr5Jg/aR7uRv9l8yNmb9/BUzq/E+d9zYwHpA0K55Hnc+z8Bgk5 + 5neCFyU0YlZnj/MwcDGAW4N6i8UUZPF2ixcxnr1CjvnY+vAKOea3zcM3dT5kfsLc23+5z4d4HaP/X2X2 + CueR5zP2/HqFHPM7wYsSGmFjWRpHjvm58TBgWxMHXEAxDVq83eMFjmevkGM+tj68Qo75knj4Fd6bzF+a + 4vmdCQ9PDsQ3OlrCeeT5XOf81kKO+Z3gRQmNsLEsjSPH/Nx4eIRp53nmBRWT1+LtJi9gPHuFHOshtj68 + Qo75Ynl4C+LBwQGeRPidTZ0P8QZ9v7kSzgfPZ7bzy/xO8CDLhn37D42wsSyNI8f83Hh4vnVn4BZaTLXF + 22letFAHrIfY+vAKOeYnwXvpS19yw/Hx0Zut/75omzv9PeYTPr/RLpz3wdXzQRc7XuiSeO7R/+N57GTG + E4VyNT7XzsadxJ0BW3gxiSdelFAHrIfY+vAKOeanyrvDjGfaP21u9b3PWzi/UZ4Cb7lc/Oa99959sed8 + RAk55vvOb5SQY75UHi7+eOLv+AIAO5jxLOHmP6CkgymF13qhj/MUikm8necFC3XAeoitD6+QY34OPHzj + B98gaD11sOktnd9gT4m3XC5/G5/EDJyPUSHHfMj5HRVyzJfKw8Xfve9neAHAnfEWIfz07/4RJR1MKbwP + mAcHa+7BL54/M2TxenlBQh2wHmLrwyvkmJ8bDzcN4leBetfHhnmLxeI/XLx44dC2Rwvnkecz9vx6hRzz + pfJwPcdbfvG2X7cA8N8DgA1mvD8YP/27BUBJB1MK7wFz0GAtvZjEC/fMeKNCHbAeYuvDK+SYnzsP3x54 + eMvnd9QT533BHPXUQJxHns91z28l5JgvmYfrOVwvALi5LdvgVgpHZrcACHurkEfImUvvnFgeOu9Bc+xg + jbZ44sU4gTco1AHrIaY+eoUc8zvDww2D9tPqY1s6v4OeCe/L5vPmUeF88HxmO7/Ml8zDJ/m4nrsFwD43 + t2Ub3O8IsKNbAIy/T7hHyJlL75xY3tL8SXNzAFbe0uAPtnjiedwr1AHrIaY+eoUc8zvJOz4+/jk7J/95 + 4uOl11vmPWwefHTw6vmgix0v9Lo8dw13CwBc33s/+sfdgVghuAUAVg5z7pxYHj5q+oy5MwC3PPhHLZ54 + PfYKdcB6iKmPXiHHvHjXXPMWc+cpoUMuaLx4XQjvMfON5o7Q7+x/3/mIFnLMl8xzn967BQA+2e+9+OOm + AKwO3AIAnnPnxPJw8f+SuTPwChn8vRZPvAF3hDpgPcTUR6+QY168q8KvEXGz4ONm33mpXdh46bgwHhZW + l8y10O/s/6HzESzkmC+dB7sFAK7ngzf9NRcA/SuFEVlujp2Ni//nzJ0BV9jg71g88UbcEuqA9RBTH71C + jnnx/MKvFN9mftLcOT8FjpeWC+V91Vx9EoB+Z/+Hno9BIcf8FHj4LxYA+CS//3puGxFyC4D+3xGMiJxN + Hcy2eChQfexvFm+WvFqoA9ZDTH30CjnmxRsXfn/9YfOz5urcFDpeahfOe2y5XP4A+z/lfHSEHPNT4eH/ + x+/hww5mLABwD4Au/leFi/+nzZ0BVvjgF0+8UFdCHbAeYuqjV8gxL16c8GTBzxU8XipPg7f/ny5fft5t + a56PSsgxv+75rYQc85vkhX17DzuZ+x8MMCLmp9Y5Yzz8ju4T5p7BpeIUL8yF8+Zav71CjvliecfHx29a + LPb/oMDxMineYrF49Lbbbr153fPBfLbzy3wZPNsx6cIPoRHzHDvnY+bWwId3uZjE82eGXDoPdcB6iK0P + r5BjXrwEIcd89dKhw8PDv2/n+PtzHX8nwbOF1MNnz545bduj1TwfDRc5XhpO5kUJjbCxLI0jx/y2eR80 + Bw2u0ge/eOHeRR7rIbY+vEKOefEShBzzLd5yubjJNn/c7D2PfZ7C+DtBHm7ixq90g2V9v1PjL0pohI1l + aRw55rfNe7c5dnBFWzzxYrwpXkJ9eIUc8+IlCDnmh3j3mb9h9p7Tpqcy/k6Yh1/p+h+BuyL0O/t/6HwE + Cznmi+RFCY2wsSyNI8f8tnlvNzcHTOUtDdZgiydejJu8yPrwCjnmY+vNK+SYF6+rM+YPmb3nFp7S+NsC + 76PmQaHf2f8h52NUyDFfJC9KaISNZWkcOea3zcOLOzoDZsuDddTiiRfjVV5EfXiFHPOx9eYVcsyLN6x7 + zXjy3eD5zT1eZsJ7r9kr9Dv7P/Z8eIUc80XyooRG2FiWxpFjfts8FNMz5tZAKWSw9lo88WLs4wXWh1fI + MR9bb14hx7x4YcLvtH/FXM1dUxx/W+Th4Ustod/Z/6nnoyXkmC+SFyU0wsayNI4c89vmPd/8bXNrgBQ2 + WDsWT7wY9/EC6sMr5FhfsfXmFXLMixevO+z8PnQS42VGPDxw6XXmSuh39n+O81E8D7Js2Lf/0Agby9I4 + csxvm3eDufNSjgIHa8viiRfjEV60UFesr9h68wo55sVLEHL33POKCwcHB++3c/vshsdLtAvmPW2+F/3H + /s92Ppgvlece/T+ex05mPFEoV+OldA4+PnvI3BoUBQ/WyuKJF+MAXpRQV6yv2HrzCjnmxUsQcsxXrHPn + zt5n5/iPJjT+orwB3pMXLlx3j+s/utjzS6/Dw8UfT/wdXwBgBzOeJdz8B5R0MOvwHjSvDobcg0s88YK9 + JV6wUFesr5R66wg55sVLEHLMt3hHR4cXbLOeGzBix8MTFxuPDC7+/JpTebj4u/f9DC8AuDPeIoSf/t0/ + oqSDWYeHu0C9gyH34BJPvBBvkRck1BXrK6XeOkKOefEShBzzQ7w3m58yr57zjrc4/oK8ad5isXjorrte + fP1K/wULOfb/0PkIFnLM5+Lheo63/OJtv24B4L8HABvMeH8wfvp3C4CSDmYdHu7+HBwMuQeXeHEW70R5 + o0Jdsb5S6q0j5JgXL0HIMR/Cu9Xc+VVn01sef6M+Qd5v2fZood/Z/yHnY1TIMZ+Th+s5XC8AuLkt2+BW + CkdmtwAIe6uQR8iZS+mc15jr123CJzi4vPuPWTzxYpzAGxTqivWVUm8dIce8eAlCjvkYHib795g757+A + 8TfoLfB+2Rws9Dv7P+Z89Ao55nPy8Ek+ruduAbDPzW3ZBvc7AuzoFgDj7xPuEXLmUjoHr9l80hwzGKIs + nngxLoTXK9QV6yul3jpCjnnxEoQc86k8fO2t/pVAIeOv11vkvcE8KvQ7+z/1fLSEHPM5ee4a7hYAuL73 + fvSPuwOxQnALAKwc5jD4z5tbX/fb4uAKsnjixXgNnleoK9ZXSr11hBzz4iUIOebX5eG5J48VNP683jIP + iyT8wNgr9Dv7f93zUQk55nPy3Kf3bgGAT/Z7L/64KQCrA7cAgOcy+D9trk/wlgfXqMUTL8Zr8jpCXbG+ + UuutJeSYFy9ByDGfhXd8fHxusVj828Tx0nFh47njRN5XzfjBsSP0O/s/y/lAjvncPNgtAHA9H7zpr7kA + 6F8pjMhypXVO6+1+hQyuXosnXowz8FpCXbG+UuutJeSYFy9ByDGfnXd4ePhLNl6endl4bnlN3ifNLTX7 + r+Eizy//iwUAPsnvv57bRoTcAqD/dwQjImdTB5PCe625vumvsMHVsXjixTgTrxbqivWVWm8tIce8eAlC + jvmN8c6ePfOXbLx80zb7xsagCx3PtTPx8ANkJV//8c+lnl/8//g9fNjBjAUA7gGYy8UfX395wlydyEIH + V23xxItxRl4l1BXrK7XeWkKOefEShBzzJ8G7ZH7E7BsfXhc8nitn5OEHyNein9hfvv6LFnLMb5IX9u09 + 7GTufzDAiJgvqXOOzPWALnhwVRZPvBhn5pVYvy0hx7x4CUKO+SHeGfNnzL4x0nLh43kTvCduuOH6F4/0 + X7CQY74Mnu2YdOGH0AgbS2t8Rcgxvw7vo2Z38nIPBvHEC3bpPNQV62udequFHPPiJQg55rfBw/MCPmT2 + jhW49PG8Kd5isXj0zjtfdONI/40KOeZDzseokGM+Cy9KaISNZWkcOebX4dVP+pvK4BJPvBBvgsf6Wqfe + aiHHvHgJQo75bfPuN3vHS+njeZO85XL5YGD/eYUc87HnwyvkmM/CixIaYWNZGkeO+XV495qfMU9ucIkX + Z/Hy8Nast1rIMS9egpBjvhQeHoaD1+W2xkvu8TdB3t+w7dFCv7P/U89HS8gxn4UXJTTCxrI0jhzz6/Au + mh83n+Rg8O4/ZvHEi/EmeWvUWy3kmF+nfmshx7x4CUKO+XV5+IHqiSmN5xPg4QfMl5mDhX5n/697Pioh + x3wWXpTQCBvL0jhyzK/Lq15/ecKDIdriiRfjTfPWqLdKyDG/bv1WQo558RKEHPNZeDZGXmj+Azdernjn + 6w0PCcJNk6NCv7P/s5wP5JjPwosSGmFjWRpHjvl1eW8xb2swBFs88WJ8ErzEequEHPPr1m8l5JgXL0HI + MZ+Vd+nSTS9cLBaPbWL8TZj3gHlQrv/MWc8HOWvzooRG2FiWxpFjfl0enm391JYHw6jFEy/GJ8VLqLdK + yLFe163fSsgxL16CkGN+I7xbbrl8i42ZR0ofzyfMe73Zq9X+o4s5v5Blw779h0bYWJbGkWN+XR6+tvJQ + IYOh1+KJF+MT5kULdcp6Xbd+KyHHvHgJQo75jfLwDgHb/GVzZ4wN+YTHc7TX4OFBc3iIUkvWV6WfX/fo + //E8djLjiUK5Gs95MO8paDB4LZ54Md4CL0qoU9ZrjvoVb3o8PGTtc+bWOOvzFsZzlDPwvmCuhX5if/X1 + X5SQYz4XDxd/PPF3fAGAHcx4lnDzH1DKwbzSTlL1Ios1Tl7LGQZDy+KJF+Mt8YKFOmW95qhf8abLW5o/ + ZW6Oo463NJ6DnZH3LvMUzi8u/u59P8MLAO6Mtwjhp3/3jyjlYM7bSfp6oYOhsnjixXiLvCChTlmvOepX + vOnz8OvXB82r46nyFsdzkDPznjl16tRL2V+h/Tco5JjPxcP1HG/5xdt+3QLAfw8ANpjx/mD89O8WAMUc + jJ2k3yp4MIgnXpS3zBsV6pT1mqV+kWNevAQhx/y2eVgEfMTcGlNbHs+j3gxv/z83HhW8rfPhFXJmXM/h + egHAzW3ZBrdSODK7BUDYW4U8Qs6c7WD29q79md0bXOKJF+YE3qBQp6zXLPWLHPPiJQg55kvhtT4JKGA8 + D3qTvIOD5UcT+q8l5JhPPR8tIWfGJ/m4nrsFwD43t2Ub3O8IsKNbAIy/T7hHyJmzHcxisbjZOvp7mzh5 + 4vkzQxZvFrxeoU5Zr1nqFznmxUsQcsyXxsMi4JOFjOdenwTv9OnT/3VC/1VCjv2/7vmohJzZXcPdAgDX + 996P/nF3IFYIbgGAlUMxB2MLgN9pdnbpg0G8cIu3NZ5XqDfWa7b6ZV68BCHHfJG8ixcvHNr8/MWE8ed1 + QfXh9QDvG7b9vDlK6Hf2f5bzgZzZfXrvFgD4ZL/34o+bArA6cAsAuJjBenx8/CZPZ3tPzphPcDB49x+z + eOLFeE1eR6g31mu2+mVevAQhx3zRPPwO3BYB/+eWx3PHW+Dhvohguf4zZz0ftFsA4Ho+eNNfcwHQv1IY + keWyH8zlyzf/qcVi//87oZMXZfHEi3GBvJZQb6zXbPXLvHgJQo75SfBuu+3Wm22ufnhG9dFyBO/V5lGt + 9h+d63zgv1gA4JP8/uu5bUTILQD6f0cwInKyHwxurjjhkxdk8cSLcaG8Wq7ezFnrlxzxIoUc85PiHRwc + PMc2P2r2jbdeF1oftSN5XzcPvjDI+mrT5wP/P34PH3YwYwGAewCKuvifO3f2vi2cvFGLJ16MC+ZVcvVm + zlq/5IgXKeSYnyrvBvPXzL4x13HB9VE5kfchs1foJ/ZXX/9FCTnmm7ywb+9hJ3P/gwFGxHz2g3npS19y + w2LhXkU5+cHQa/HEi3Fm3klNRuIFCjnmp87Di9q+bfaNu9qF18c6vGfNd5tbQj+xv8b6L0jIMZ/Gsx2T + LvwQGmFjaY2vCDnmzx8cHPzaFk+e1+KJF+PSec16azhL/TYsXqCQY34uPFwAnzZ7x1/p9ZGB94i5fugO + +on9Fdp/g0KO+Sy8KKERNpalceSYP3/hwnWvtM5+ZmaDoWXxxIvxJniu3hrOUr8Nixco5JifG+8NZu/4 + K70+MvEm8a6AKKERNpalceSYP3/vvXdfXCwWj8x0MFQWT7wYb4qHems4S/02LF6gkGN+rrz7zZ3xl3s8 + F8p7arHYv4X9ldp/LSHHfBZelNAIG8vSOHLMV6zDw8NfmvFgEE+8KG+S52qO9VfEZIQc8+IlCDnmS+N9 + 2Dyp+sjFsx9oP5uh/yohx3wWXpTQCBvL0jhyzFesm2668UXW4d8v6eSJJ16op8Zj3WWrX1q8QCHH/C7w + Ttn4+50p1UdO3pkzp//amv2X/fxGCY2wsSyNI8d8zbOV0m+XePLE82eGLF75PNZfEZMRcsyLlyDkmC+W + d8cdtz/X5vjHNjWeS+bhG2133fXi69fpP/Z/lvMRJTTCxrI0jhzzNe/s2TN/sdSTJ16cxZsGD3Vo26OF + nHmj8wH/LF6AkGO+eB4/5f3OFOpjA7xftO3RavZfw8nnA7Js2Lf/0Agby9I4cszXvHvuecUF6xx8ZcLb + oUM+wZPn3X/M4okX4xPmRctXv/zz7C9eDYsXKOSYr3n2w95fsvGH78l3xuuYT7g+oj3Ce8p8yRwsX//x + z6nnwz36fzyPncx4olCuxr0HY53zN2xzpzPHfMInL9riiRfjLfCiZLW68YsD/yxegJBjfoq8d5pb43XM + W6iPKAfyHjQHCf3E/vL1X7Qsh4s/nvg7vgDADmY8S7j5D1ince/BHB8fn7PNT5ibnTTqLZ28YIsnXoy3 + xAuW1epJXhyihRzz4iUIOeZPkvcJc3M89npL9RHsSN4rzYNCP7G/hvovWJbDxd+972d4AcCd8RYh/PTv + /hHrND50MO81+zqp11s+eaMWT7wYb5EXJNQp69VXv9FCjnnxEoQc81Pn4YU5j5lXx2XLW6yPICfwHjL3 + Cv3E/hrrvyBZDtdzvOUXb/t1CwD/PQDYYMb7g/HTv1sArNP40MFcNj9j9nWS1wWcvEGLJ16Mt8wbFeqU + 9eqr32ghx7x4CUKO+bnwbjc/afaNz23Xx6jX4L3J3BH6if0V2n+DQs6M6zlcLwC4uS3b4FYKR2a3AAh7 + q5BHyJmHDga/D/F1jtcFnTyvxRMvxgXwBoU6Zb321W+UkGNevAQhx/zceK83d8ZnAfUx6DV53zAvzbXQ + T+yv2P7zCjkzPsnH9dwtAPa5uS3b4H5HgB3dAmD8fcI9Qs48dDB4UYSvY7wu7OR1LJ54MS6E1yvUKeu1 + r36jhBzz4iUIOebnynuPuR6bhdRHrzPx8IjkSugn9ldq/7WEnNldw90CANf33o/+cXcgVghuAYCVwyYH + w5fMvk7puNCTV1s88WJcEM8r1Cnrdah+g4Uc8+IlCDnm58zDx9JfMZdUH15n5OFrgRfRT+yvdfqvFnJm + 9+m9WwDgk/3eiz9uCsDqwC0A4E0OhteYfR3SccEnr7J44sW4MF5HqFPW61D9Bgs55sVLEHLM7wLvVhu3 + TxZUHx1vgPdr7K8c/dc8H7BbAOB6PnjTX3MB0L9SGJHlQgdDtdIb8wROnnjiBbtAXkuoU9brWP0GCTnm + xUsQcszvDO/o6Oita4znlgust5av8PafwdMRc/Uf846DBQA+ye+/nttGhNwCoP93BCMiJ2QwvNbs7ZCm + p3HyxBMvzIXyaqFOWa9j9Rsk5JgXL0HIMb9zvOVy+duF1EftTfLseD+G4+bx5zof+P/xe/iwgxkLANwD + sOmLP/Sw2dspzlM6eeL5M0MWrxheJdQp6zWkfkeFHPPiJQg55neSd9ttt95sY/qPZlhvlT28Zy9evPCy + XP1Hh317DzuZ+x8MMCLmQweD9+seTU/w5IkXYfGK4m18MqfFCxRyzO80b29v78dsc/T7AgqvtyHev7Ht + 0bK+Wu982I5JF34IjbCxkMZxl+ejZm/HwCfY2d79xyyeeDEunYc6Zb2G1O+okGNevAQhx7x4V9T6auCY + S6+3AN6LzcFCP7G/+vpvc0IjbCy08TeYWx3S9BY6O8riiRfjKfBYr6H1OyjkmBcvQcgxL95V4YdGPDbX + O4abnkK9BfDwboQgoZ/YX0P9txmhETYW2jhOZO8zn7fU2cEWT7wYT4UXUb+DQo558RKEHPPidXWHefBx + 8VOpt0De6KcA6Cf2V0j/5RUaYWMxjb/Z7DvYbXf2qMUTL8ZT4kXUb6+QYz5mPugVcsyLlyDkmJ8T793m + 0fGcuz62xBv8FAD9ZM42XqKERthYTOP46f9r5k5nzfDkDVo88WK8aV5g/fYKOeZj5oNeIce8eAlCjvm5 + 8fDM/M4nyFOrt0Aebnz0fgqAfmJ/xfbf+kIjbCy2ce9P/4V0dq/FEy/GU+QF1q9XyDEfOx94hRzz4iUI + OebnysM79OtvBUyx3iJ4Hze3hH5if6X2X7rQCBtLabxz539hnd2xeOLFeKq8wPrtCDnWf8p80BFyzIuX + IOSYnzvvQ+bJ1lsEDwsdvCq/EvqJ/bVu/9WybNi3/9AIG0tpvPPUvwI7u2XxxIvxxHnRQt2z/lPmg46Q + Y168BCHH/C7wzti4/cYJ1ke0M/I+YN7E+XCP/h/PYyczniiU2vhnzPVBFdzZlcUTL8Yz4EUJdc/6T50P + WkKOefEShBzzO8M7ffr4JwbGc5S3UG8xfuro6PAC+ytX/+Hijyf+ji8AsIMZzxJu/gNiGr/LXB9Q4Z0t + nnhRngkvWKh71n+uyUg88YKFHPM7866Ag4ODv4fjbXid/sPF373vZ3gBwJ3xFiH89O9OYmzjHzPXB1N6 + Z4snXqhnxAsS6r4xD+SYjMQTL1jIMV+x8PY8G9Pfn2C9BbnB+9ZLX/qSG3jc6/Qfrud4yy/e9usWAP57 + ALDBjPcH46d/twCIbfySuXp4w4Q6WzzP/mMWb9K8UaHuWf8bmcxp8QKFHPM7zbPx/Iu22TemB73lehv1 + Ku/4+Pjnefzr9B+u53C9AODmtmyDWykcmd0CIOytQm29zzy5zhYvzuJNnjco1L1545O5WbwAIce8eFee + DeB9vkyfC6i3Qft5+/+Jxxst5Mz4JB/Xc7cA2OfmtmyD+x0BdnQLgPH3CXd1xvzkNDtbvFCLNwter1D3 + 5pOazKOFHPPiJQg55qfMu8/sG9cdF1JvvR7h4dt0UUI/md013C0AcH3v/egfdwdiheAWAFg5pJy8d55w + 50RbPPFiPGOeV6h780lP5sFCjnnxEoQc83Pgtb5p5nNB9eZ1AO9z5mChn8zu03u3AMAn+70Xf9wUgNWB + WwDAKSfvlP2jHz/hzomyeOLFeOa8jlD35m1N5qNCjnnxEoQc83Ph4dtm9RMCV11YvXUcwcNxjgr9xP6C + 3QIA1/PBm/6aC4D+lcKI9vb2fnJLnRNk8cSL8Q7wWrK618VGvGAhx/y2eR82d8Z3gfXWciQP36obFPqJ + /eX6DQsAfJLffz23jQi5BUD/7whGBM5isfi9wIMZ9ZY7e9TiiRfjQnm1UL/mlMnXK+SYFy9ByDEv3rgu + mp8w12O70HqrncB72ozj9Ar9xP5q9t34PXzYwYwFAO4BSL74X3/9xbsiDmbQBXT2oMUTL8YF8ypxDkid + fDtCjnnxEoQc8+KF6+3malwXXG+V1+C9w9wR+on91ey/sG/vYSdz/4MBRsT8uYODg1/bcud4LZ54Md4x + XqmTeS3kmBcvQcgxP3cevhb49cLrbV0eXqzXEvrJnD5ebMekCz+ERtDYvffefdEO5Ftb7pyOxRMvxrvG + c/VrTps8VoQc8+IlCDnmxUvQ3t61P1NyvWXi3W2uhH5if2XpvyihETZ2/vTp0z9dSOfUFk+8GO8iz9Vv + w8mTB3LMi5cg5JgXL0HI3XPPKy4sFovHSq23TLyPmLP3X5TQCBurGl4uF5+daWdXFk+8GE+F5+qXXmvy + ZV68BCHHvHgJQo7582fOnP6pUustEy/7WwKjhEbYWNXwlRcznHp2pp0tnnhRnhLP1TDrWRebACHHvHgJ + Qo75jfEWi/2HS6y3XLzDw8NfaB6vObn/ooRG2Fjd+MHBwa+W1DniiRfqXeexhrNOvvyzeAFCjnnxEoQc + 8y3e3t7ej9tmbw0MeSr1u1gsHmkerzmp/6KERthY3dn4nYv9o75um73/4CFvqnPEEy/E4lULgOyTr1m8 + ACHHvHgJQo75Pt7DZm8t+Dy1+r3uuvOvWjnezQmNsLFWZ899pSWeeCGeKs9qeFcvDlFCjnnxEoQc8yfJ + m/WLgpbL5UdWjjdKlg379h8aYef6OvuTZu8/us9T7Gzxwi3epHjRQt2z/n3zQbSQY168BCHHvHhdPWLu + 1ETTJ1xv0R7gPWnbj8xRsn5yj/4f73/sZMYThXydjccS9r6EwecT7Bzv/mMWT7wYz4AXJdQ96983H0QL + OebFSxByzIvn1xvNrZpoegv1FuUA3pvNwbJ+wsUfT/wdXwBgBzOeJdzs8GZnv83c+gcPeQudE2XxxIvx + THjBQt2z/kMn30Ehx7x4CUKOefH6dcr8uLk55itvqd6CHcjDq5CDZP2Ei79738/wAoA74y1C+Onfdfpq + Z3/Z3PzH9HpLnRNs8cSL8Yx4QULdN+aB0Mm3V8gxL16CkGNevHG909wa91ustyBH8PAJ/A3mQVk/4XqO + t/zibb9uAeC/BwAbzHh/MH76dwuA1c6+bF79x3i9xc4JsnjixXhmvFGh7ln/KZNvR8gxL16CkGNevDCd + MeP35dWY33K9jTqBh5cg9Qr9ZMb1HK4XANzclm1wK4Ujs1sA+N4qdL/Z949puYDOGbR44sV4hrxBoe7N + JU3mLSHHvHgJQo75ufPeZy6h3gadyPuK2Sv0kxmf5ON67hYA+9zclm1wvyPAjm4B0Pc+YbyVyPePqV1I + 5/RaPPFiPFNer1D35hIn80rIMS9egpBjfhd4l6wOnimg3nq9Ju9Wc0voJ7O7hrsFAK7vvR/94+5ArBDc + AgArB19nv9js+0fULqxzOhZPvBjPmOcV6t5c6mQunnhRQm65XPzrhPrwuqD6dcYn8rVwvGb36b1bAOCT + /d6LP24KwOrALQDgvs4e/Pi/wM5pWTzxYjxzXkeoe3PRkznz4iUIOeZ3infx4oUfLaDeOs7Ew1MPKzXO + L+wWALieD97011wA9K8Urqj34/9CO6e2eOLFeAd4LVnd7+TFgRzxIoUc85PgLRaLL86sfpu+vHK8+C8W + APgkv/96bhsRcguA/t8RXBF+1+BrvPTOEU+8KO8IrxbngY1NvrR4gUKOefEShBzzNe/4+PhNM6vf2pb7 + uyvHi//vu4fvqrCDGQsA3AMwdPGHvB//T6BzxBMv2DvEq8Q5YKOTL/8sXoCQY168BCHHfIt3882XFrb5 + G2ZfLfS64PqtjNxisf+VleP1fXuvK+xk7n8wQFv4ykGn8dI7RzzxQr1jPF0cxIsScsxPlfdus68WvC68 + flu8G2/8gTs9xzss2zHkwg91Hv4zpc4Rz58Zsnjz5mGS4GTRN1lGCTnmxUsQcsyLlyDkmB/i3WgOeodN + 6fW7yjs6Onqn53izqfXs/6l1jnhxFm/+PE4WQ5NlsJBjXrwEIce8eAlCjvkQ3uhbbKdQv6u8xWLx2Z7j + zaJPm3sbL71zxAu3eLvBa0yUQ5PlqJBjXrwEIce8eAlCjvlQ3uvN3tqAp1K/Ht7Ttj36FcEhAhTwkzwY + 7/5jFk+8GO8yL3CyHBRyzIdOvoNCjnnxEoQc8+L1C8/C/6Z5sD5y19sJ8e4zZxeg2ziYKIsnXox3nRc4 + WfYKOeZjJt9eIce8eAlCjnnxxvUB82B95K63E+J92JxdH97SwQRbPPFiLF61AJjLZN4RcsyLlyDkmJ8r + 73bzYH2UXr89vMfNeWWNPL6lgwmyeOLFWLwrvIjJsiXkONmmTr4tIce8eAlCjnnx4oRH6E62fgd4eF/P + oKyvwr79Z43dsuWDGbR44sVYvBYvWphkOdmuO/lWQo558RKEHPPixeudJ1xv0U7ktV4O1JT1k3v0/3h/ + YaeDg4O/Hdl4rwvpnF6LJ16MZ8CLEuYDc6mTuXjiRWmxWNxs9fDsQH1EeQv12+fPmDuyfsLFH0/8HV8A + YAfzaeuk39nywXgtnngxFs/LCxbng2Inc+SYFy9ByDG/Uzy7vv3eCdZbsNfkdb4OaMeKi79738/wAoA7 + H//Ij7z8vDX83S0fTMfiiRdj8Xp5QcJkYS5+MidHvEghx/zO8Y6Ojt5xgvUW5Ey815or2XHieo63/OJt + v24B4L8HABvMeH/w6TNnTr/myj9kdp1TWzzxYjwz3qhsHtDFRrxgIcf8JHi33HIZ97g9O9H6HfJ7ze54 + cT2H6wUAtnVkG9xK4ch8+uBg+e5TpyY7uY1aPPFiPEPeoGwO2OmLAy1eoJBjflI8q48v2mZffQy6gPod + 8sN2bDjeYzOu524BsG/burIN7ncE2LFaANg/4HPXXuuFj7rwzhFPvCjPlNcrq39dHMQLFnLMT5HXes9N + iAup317bdfvZm29+3g/a8Z02uwUAru+9H/3j7kCsEKoFwMtf/sNn7K+fMnsbGHL5nSOeeOGeMc8rq39d + HMQLFnLMT5UX/IZAuKD69Ro5fHJ/fHz0BjtGtwDAJ/u9F3/cFIDVgVsAHO7t7f2IbfI2MOQpdI544oV6 + 5ryOrPZ1cRAvWMgxP3Xel82+Gmm5sPrt+Crv1J8sl8sP2HFiAYBr+uBNf80FgFspvMvsbaTP0+kc8Xz7 + j1m82fFasrrXxUG8YCHH/Bx4eHiOr0ZqF1i/Lbd51X8fsmPFPQD+iz+EzjC7BUDzdwT1639DPK3OES/W + 4s2SV4vzwLYm31Ehx7x4CUKOefH8wuNzfTVSudD6rd3lncKvAZ49Pj46tu39QoeYsQDAPQDNlcITZm9j + q55e54gXY/Fmy6vEOWCbk++gkGNevAQhx7x4w8KLdDp1UnD9VvbxcA8At7/G3C90inn1wQCtNyUNeYqd + I164xZs1TxcH8aKEHPNz5OFVuq0aKbx+B3j1Pu8298s6xvf7gbeYWw35PN3OES/E4s2bh0mRk2PKZNkR + csyLlyDkmBcvQcgxn8q7z1zXR+n1G8j7lDlaD5ibkI63dDDBFk+8GO8ij5Nj6mTZEnLMi5cg5JgXL0HI + Mb8OD8/Px3P0J1G/gbxvm6P1iHkVVHuLBxNk8cSL8a7y1pwsayHHvHgJQo558RKEHPM5eF+eSv1G8J5v + DhYeANT7UIQCDmbQ4okX413mZZgsdbERL0rIMV8kz+rjF6dSvxG8N5uD9UqzD1LKwfRaPPFivOu8dSdL + 5JjPMvkix7x4CUKOefEShNz58+d+bFP1tkXeB83Beoe5AynoYLwWT7wYi1ctAGY9mTMvXoKQY36nePfe + e/dFq425vQIfTzkM1kfNLUBhB9OxeOLFWLwrvHUnS3PWyZcc8SKFHPPiJQg55ivWcrn47BTqN4KHd/q0 + XgFsx9n7dMBHzXUY3ycs7GBaFk+8GIvX4kVrdbKki53MafEChRzzO8s7ODj4exOp3xjj2T44Xvfof29/ + 4WsQrRsA8UShDI1XLrhzKosnXoxnwIsSJg3zTl8c+GfxAoQc85PinTq1d49tbtVSiLdQvzF+kx0bLv54 + 4m/vAuBl5jp05eLf/AdManKLsnjixXgmvGBhwjBPbjI3ixcg5JgX78rH5VGvwt9S/Qbbcv/Yjs2976d3 + AfCz5ipgq6CVBcDkJrdgiydejGfECxImC/NJTb7RQo558RKEHPPiXdUXzKv14vUW6zfYe3t7/4cdH972 + 6xYA3nsA8HUB7Fxd/K8uACY5uQVZPPFiPDPeqDApmk968g0WcsyLlyDkmBevrfeYfTXT8pbrN8i4npv/ + XzvGegFgf+/V57hzvQCASzkY8cSLsXijvEFhUjRvY/INEnLMi5cg5JgXr6vXmX01U7uA+h01Psl31/SL + Fy/caMe6b3/flW24FquE1QVA461CUS69c8QTL8Yz5fUKkyInx5DJclTIMS9egpBjXrwEIcd8KO8Gs69m + KhdSv73Gddtdw901fblc/Dk7Xv/X/86ePfNct+OVBcCeFxzi8jtHPPHCPWOeV5gUOTmGTpaDQo558RKE + HPPiJQg55mN5XzN36qag+vUaOXfxby4A7O9/3rZ3ZR1xarFY/NnmAsD+OsmbOBjxxAu1eFG8jjApcnKM + nSy9Qo558RKEHPPiJQg55lN4nzC3aqaw+u34Kq+9AOD2D5nbso6oHgxgepsu/nEWT7wYF8hrCZMiJ8eU + ybIj5JgXL0HIMS9egpBjPpV3v7mulwLrt+U2zy0AWtfzz5nbQmeYT9mF/5+mNgxv9mDEi7V44gW4FueB + kibflpBjXrwEIce8eOF6jbmqlULrt3aXd2UBsLLfN8xtoUPMtgC49nfsj6uBIE+vc8SLsXiz5VXiHFDa + 5FsLOebFSxByzIsXp+pGwILrt7KP57n4Oy/NV4VOMeN7gY+ZfYFBT7FzxAu3eLPm6eIgXpSQY34neFZX + 3yy4fgd4/v3Nd5ivyjrGfS3gGbMv0OuTOxjxQiyeeDHGpMjJMctkiRzz4iUIOebFSxByzGfjLRaLz+eq + t0LmAzzfoKNLZt/OvS7kYHotnngx3kUeJ8dskyXz4iUIOebFSxByzGflHRwc/PNS6zeR9y5zR68y+3b2 + uqCD8Vo88WK8qzxOktkmS3LEixRyzIuXIOSYz847Pj56e6n1m8h7wNxR/RKgMRd2MB2LJ16Md5mHCY4u + cvJtWLxAIce8eAlCzow8OOfPnz/3mlLrN5H3GXNHv2L27dxygQfTsnjixXjXeZzkdHEIFHLMi5cg5Jif + DO8FL7jtB0ut30TeV80dfdTs27l2oQdTWzzxYixetQAoevLln8ULEHLMi5cg5Jj38fD9eW9d9bng+eBp + c0d4QpBv58oFH0xl8cSLsXhXeJzcooUcJ0ffZBkt5JgXL0HIMS9egpBjvo/3JbO3tnwufT7Y29u7aMfW + eikQPhbw7ozvE5Z8MOKJF2PxWrxoYVLk5Ng3WUYJOebFSxByzIuXIOSYH+J9zNypLZ9PuH6TbPmXrhxf + 9bGAd2c8UShX46V3jnjixXgGvChh0uDkODRZBgs55sVLEHLMi5cg5Jgf4/2yuVVbPm+hfqON7KlTe3+l + eYy97z2+cvFv/gMmNblFWTzxYjwTXrAwYXByHJssg4Qc8+IlCDnmxUsQcsyH8N5obtZNx1uq3ygjC+/t + 7f3N5nG+2NzZGW8Rai8AJje5BVs88WI8I16QMFlwcgyZLEeFHPPiJQg55sVLEHLMh/LuNq/WTu0t1m+w + 3Zt+wbD//iM71voegFebOzvj4n91ATDJyS3I4okX45nxRoVJkZNj6GQ5KOSYFy9ByDEvXoKQYz6Gd6PZ + Vz/brt8gu4u/WwCY/2f7+1pvMnd2dgsAuJSDEU+8GIs3yhsUJkVOjjGTZa+QY168BCHHvHgJQo75WB5e + ltd5V04B9TtqfJK/ugCwv/+kudY7zdXO2Li6ABh4q9Cgcx+MeOLFWLwgXq8wKXJyjJ0svUKOefEShBzz + 4iUIOeZTeV8317VTSP32Gtdtdw1fufjDD5lrvddcbXQ7XlkA7LWAMc5/MOKJF27xgnleYVLk5Jg6WbaE + HPPiJQg55sVLEHLMr8OrnwVQUP16jZy7+DcXAI19sJip9VEE4OYCwP4+yZs4GPHEC7V4UbyOMClyclxn + sqyFHPPiJQg55sVLEHLMr8t70Fxa/XZ8lddeAKzsd/VpgNdee82nEIJ18Y+zeOLFuEBeS5gUOTmuO1lW + Qo558RKEHPPiJQg55nPwPlhg/bbc5rkFQO/1/IwZC4Brv4ygMzdGu9147oMRL9biiRfgWpgUOTnmmCzF + Ey9KyDFfJM/q6hcLrN/aXd6VBYBvX/qSudJjCKc2DG/+YMSLsXjiBboSJkVOjlkmS+SYFy9ByDEvXoKQ + Yz4b7+jo8G9mqLfKJzEfjFz84TvMlb6R2jB8EgcjXrjFEy/CujiIFyXkmN8p3pkzp/9agfU7wPPv3/Ar + zZWeMvt2GPXJHYx4IRZPvBjv6mROjniRQo75neNdd935V5dWv2vyXme+Ztn4iygXdjAdiydejHeR5ya3 + houcfBsWL1DIMS9egpBjvmI95znXv3xm88Gbzf0vAhpygQfTsnjixXhXeW5yo4udfGnxAoUc8+IlCDnm + a97znnfTny6tftfkvd18za2NvwhyoQdTWzzxYrzLvMYEV/Tkyz+LFyDkmBcvQcgx3+JdvHjh0DZ7a2rI + Bc8H95v9bwLsc8EHU1k88WK86zw3uZl1cQgQcsyLlyDkmJ8qL+p+ucLng/eYr7m38ReDLvxgxBMvyuJV + C4ApTb5RQo558RKEHPPiXdU3zN76WnXp84H5febuq4B9Lv1gxBMvxuJd4a1MbsFCjpPj0GQZLOSYFy9B + yDEvXoKQY36M9zWzt8aaLn0+gC376/bfa+5r/qXP+D5hyQcjnngxFq/FixYmRU6OY5NlkJBjXrwEIce8 + eAlCjvkQ3qPmTo01fcL1m2Rkzf/K/v+aNzQ3+IwnCuVqPPfBiCdejMXr8KKESZGTY8hkOSrkmBcvQcgx + L16CkGM+lPdlc6vGmt5C/UYbWfp/sz9f86bmxlVfufg3/wGTmtyiLJ54MZ4JL1iYFDk5hk6Wg0KOefES + hBzz4iUIOeZjeF8wN+un9pbqN8rINvxp+7v+BQDeItReAExucgu2eOLFeEa8IGFS5OQYM1n2CjnmxUsQ + csyLlyDkmI/l4aK5WkPbrN9guzf9gnHF1bFUTwPy7oyL/9UFwCQntyCLJ16MZ8YbFSZFTo6xk6VXyDEv + XoKQY168BCHHfArvU+ZWDW25foPsLv7NBYD9fbUAeJvbydnt6BYAcCkHI554MRZvlDcoTIqcHFMmy46Q + Y168BCHHvHgJQo75VN6D5rp+CqjfUeOT/NUFALfh1xntBQA2ri4AAt4q5HXugxFPvBiLF8TrFSZFTo6p + k2VLyDEvXoKQY168BCHH/Dq8egFQSP32Gtdtdw33XPxh3NB4dQGAjW7HKwuAvebOUc5/MOKJF27xgnle + YVLk5LjOZFkLOebFSxByzIuXIOSYX5dXLQAKql+vkXMX/+YCYGW/qwsABODmAoA7RXsTByOeeKEWL4rX + ESZFTo7rTpaVkGNevAQhx7x4CULOjDw4zqm8Bwur346v8toLAM++/QsA7hDtzR2MeL79xyyeeCNuCZMi + J8cck6V44kUJOeaL5Fld/VZh9dtym+cWAL3X8+4CILVhuN147oMRL9biiRfgWpgUOTlmmSyRY168BCHH + vHgJQo75bLzFYvHba9Zb7c3PB1cWAL596e4CgBuivfmDES/G4okX6EqY3Dg5ZpssmRcvQcgxL16CkGM+ + K2+5XDYWAGXPByMXf7i9AOBfRvskDka8cIsnXoR1cRAvSsgxv3O8qwuAKcwH/v0brr4G6H0QUKhP7mDE + C7F44sW4Obk1XOTk27B4gUKOefEShBzzFWu5XPzujOaD4UcBj7mwg+lYPPFivIu85uRGFzv50uIFCjnm + xUsQcszXvMVi8dmS6ndNXvoCoMCDaVk88WK8q7zm5GYuevLln8ULEHLMi5cg5Jhv8axuvmibvTU15E3V + 75q8agEw+jrgVRd6MLXFEy/Gu8xrTm5mXRwChBzz4iUIOeanyMONc9666nPB88HHzdfc1/iLURd8MJXF + Ey/Gu85bmdyihRzzvskyWsgxL16CkGNevAQhx3wf71Gzt7Z8Lnw++Jj5mlc3/mLQhR+MeOJFWbxqATCl + yTdKyDEvXoKQY168q/qa2Vtfqy59PjB/2HzNvY2/6HXpByOeeDEW7wpvZXILFnKcHIcmy2Ahx7x4CUKO + efEShBzzY7xvmL011nTp8wFs2ffbf695cfMvfcb3CUs+GPHEi7F4LV60MClychybLIOEHPPiJQg55sVL + EHLMh/CeMndqrOkTrt8kI2v+Vfv/a25tbvAZTxTK1XjugxFPvBiL1+FFCZMiJ8eQyXJUyDEvXoKQY168 + BCHHfAhvaW7V16q3UL/RRpb+RfvzNTc0N676ysW/+Q+Y1OQWZfHEi/FMeMHCpMjJMWSyHBVyzIuXIOSY + Fy9ByDEfyhu8Vm6pfqOMbMN/y/6uf1WDtwi1FwCTm9yCLZ54MZ4RL0iYFDk5hk6Wg0KOefEShBzz4iUI + OeZjeM83r9ZP5S3Wb7Ddm37BoH/G/r5S5/ca2BEX/6sLgElObkEWT7wYz4w3KkyKnBxjJsteIce8eAlC + jnnxEoScGXlwnEN4d5s7NbTl+g2yu/g3FwD2968zV2rd2eh2dAsAuJSDEU+8GIs3yhsUJkVOjrGTpVfI + MS9egpBjXrwEIcd8Cq/zzJwC6nfU+CR/dQHAba80V3rMXP0lNq4uAALeKuR17oMRT7wYixfE6xUmRU6O + KZNlR8gxL16CkGNevAQhx3wq7y3munYKqd9e47rtruGeiz98h7lS9XhDbHQ7XlkA7DV3jnL+gxFPvHCL + F8zzCpMiJ8fUybIl5JgXL0HIMS9egpBjfh3e/eaqbgqqX6+Rcxf/5gJgZb9L5kqfQgBuLgDs75O8iYMR + T7xQixfF6wiTIifHdSbLWsgxL16CkGNevAQhx/y6vA+aS6vfjq/y2gsAz75nzNdcY4F/iRCsi3+cxRMv + xgXyWsKkyMlx3cmyEnLMi5cg5JgXL0HIMZ+D92CB9dtym+cWAN7r+dPmK7LQP0bQ2f4qye3Gcx+MeLEW + T7wA18KkyMkxx2QpnnhRQo75InlWV79XYP3W7vKuLAB8+5q/br4iC/73CKc2DHcbz30w4sVYPPECXQmT + IifHLJMlcsyLlyDkmBcvQcgxn41nNfaHGeqt8knMBwMXf/gh8xVZ+KdTG4ZP4mDEC7d44kVYFwfxooQc + 8zvFszp7JkO9neB84N+f/qT5igzwF+0/vp1GfXIHI16IxRMvxm5yM2edLMkRL1LIMS9egpBjPivv0qWb + Xlhi/a7B+4i51ugbAX0u6GC8Fk+8GO8ij5Nj1smSHPEihRzz4iUIOeaz86677vyrS6zfNXi/Yq41+JID + nws7mI7FEy/Gu8rD5NZwkZNvw+IFCjnmxUsQcsxXrNOnj//bEut3Dd7bzS3hawG+HTsu8GBaFk+8GO8y + z01wnOx0cQgQcsyLlyDkmJ8M7+Dg4B+WWL9r8Or3ADh91ezbseVCD6a2eOLFeNd5nOCKnnz5Z/EChBzz + 4iUIOeZbPKubf2mbvTU15E3X7xq8u8wtfc7s27F2wQdTWTzxYixetQAofvI1ixcg5JgXL0HIMe/jfcns + ras+Fz4fXDS39FGzb8fKhR+MeOJFWbwrPE5u0UKOk6NvsowWcsyLlyDkmBcvQcgx38drvTF3zIXPB9VT + AO3YrsV/nXBXoG9na+SanI3nPhjxxIuyeC1etDApcnLsmyyjhBzz4iUIOebFSxByZuTBcW7y8Mz8Tl31 + +YTrN8VftWM71Ti+Sj9r9u1cPVEoV+Old4544sV4BrwoYdLg5Ng3WUYJOebFSxByzIuXIOSYH+Lda27V + VZ+3UL/R3tu79rN2fJ0FwKvMnZ2vXPyb/4BJTW5RFk+8GM+EFyxMGJwchybLYCHHvHgJQo558RKEHPNj + vN4fjpveUv1GGdm9vb1/YcfYWQDg3cCtnfEWofYCYHKTW7DFEy/GM+IFCZMFJ8exyTJIyDEvXoKQY168 + BCHHfAjvfebVuml5i/UbbPemX7uu/w92nFgAtO4BgJ4x1zvj4n91ATDJyS3I4okX45nxRoVJkZNjyGQ5 + KuSYFy9ByDEvXoKQYz6U9xmzr3Yqb7l+g+wu/rDxXm/Hesr+vqPHzPWObgEAl3Iw4okXY/FGeYPCpMjJ + MXSyHBRyzIuXIOSYFy9ByDEfw3vc7KudEup31Pgkv7kAWC6XePS/V59CQ6sLgJG3CvW69M4RT7wYz5TX + K0yKnBxjJsteIce8eAlCjnnxEoQc8zG83sfkF1K/vcZ1213D3TUdrMVi/9i2d2U7/FO3I4yVg/11ksvv + HPHEC/eMeV5hUuTkGDNZ9go55sVLEHLMi5cg5JiP5b3G3KmbgurXa+Tcxb+5ALBteJ5BV9YRtt+ptzUX + APbXSZ5C54gnXqhnzusIkyInx9jJ0ivkmBcvQcgxL16CkGM+hXe/uVUzhdVvx1d57QUAt3/B3JZ1xLXm + U4vF4s/p4h9n8cSLcYG8ljApcnJMmSw7Qo558RKEHPPiJQg55lN5nzDX9VJg/bbc5rkFQOt6/iFzW+gM + 86lz584+N7VheLMHI16sxRMvwLU4D5Q0+baEHPPiJQg55sUL19fMVa0UWr+1u7wrC4CV/d5qbgsdYsb3 + Avftj1HPPHaeXueIF2PxZsurxDmgtMm3FnLMi5cg5JgXL1z1DYAF129lH89z8YdfaW4LnWJ2DwYYfSvg + qqfYOeKFW7xZ83RxEC9KyDE/dx7emV96/Q7wvPt33gKIDms+EQi/I/AFvZ5u54gXYvHmzcOkyMlx3cmy + EnLMi5cg5JgXL0HIMZ+D957S6zeS903zqIKeewxv+WBGLZ54Md5FHifHHJOlLjbiRQk55ovkWX18sfT6 + jeTh0/1RvczsC7dcwMEMWjzxYryrvFyTJXLMi5cg5JgXL0HIMZ+Fd/PNlxZWY9/PXW9b5uGdBqM6Mj9r + 9gEqF3IwvRZPvBjvMi/HZIkc81kmX+SYFy9ByDEvXoKQO3fu3J/fRL1tmfcmc5AeNfsAJR2M1+KJF+Nd + 59lkp4tDhJBjXrwEIcd80bzDw8Nf2kS9bZl3uzlIHzV3AIUdTMfiiRdj8aoFwOwnc3LEixRyzO8cb7lc + /O4m6m2LvKfM3jcA+vQOcwtQ2MF0LJ54MRbvCi/HZNlwkZN5w+IFCjnmd4537713X7T6+O4U6jeC92Vz + S3aszW//tfQqcx3G9wkLO5iWxRMvxuK1eNFqTpYNFzmZNyxeoJBjfid5Fy9e+NEJ1W+oP2iuZMdYPfrf + 3NtfZ8z1jYB4otCajdcutHNqiydejGfAixImDfNkJnNavEAhx/zO8g4ODv7BhOo31G8243hx8d83Dy4A + oEfMvPg3/wGTmtyiLJ54MZ4JL1iYMMyTmsz5Z/EChBzzO82z+viibW7WSJC3VL+hfr4dGy7+C3p4AWCN + /AbeItReAExucgu2eOLFeEa8IGGyME9uMjeLFyDkmN9p3tmzZ07b5qfNq3Uy6C3Wb4i/bceGi/+BeWl2 + CwD/PQDYsFwu/jou/lcXAJOc3IIsnngxnhlvVDYf6OIgXrCQY36KvPvMvjrp9Zbrd9SW+5Qd2yFdLwBs + W1e2oVopnD179iVuAQAXdDDiiRds8UZ5g7K5QBcH8YKFHPNT5X3Y7KsTrwuo31EvFot/ZMd3ZHYLALz1 + tyvb4H5HgB2P7ML/3SsXfz94zKV3jnjixXimvF7ZHKCLg3jBQo75KfMeN/vqpONC6rfXuG7j+n10dPTj + doxuAYDre+9H/7g7ECuEagFgjX/G/toLH3P5nSOeeOGeMc8rq39dHMQLFnLMT5n3YrOvRjouqH69Ro6f + 3j/7whfedr0dJxYAuAeg9+KPmwKwOnALgEOD/F3b5G1gyJs4GPHEC7V4UbyOrPZ1cRAvWMgxP3Xe/WZf + jbRcWP12fJVXMR+y4zxtxjW9/6Y/c3MB4FYKd5u9jfR5Op0jnm//MYs3O15LVve6OIgXLOSYnwMPT8vz + 1UjtAuu35Tbv1J8sl8sP2LEem/0XfwidYXYLgObvCHCnIJ4h7G1s1dPqHPFiLd4sebU4D2xr8h0VcsyL + lyDkmBevq0vmmb0FF7//P/yrPcd7VdjBjAUA7gFYXSkE3Qcwvc4RL8bizZZXiXPAtibfUSHHvHgJQo55 + 8fzqvP+m6YLrt7KPh9//HxwcXLDtw0KnmPseDDD6e5Epdo544RZv1jxdHMSLEnLMz4nX+/F/4fU7xHvY + to/LOqb/9wPXXPNKs7dh+AQPxrv/mMUTL8a7xsOkaNbFQbwgIcf8nHiXzd76KL1+R3jvNa8t3AfwhDm2 + 8WiLJ16MxVufx8kxZrLsFXLMi5cg5JgXL0HIMR/Le6fZWx+l1+8I77XmLPqkObbxKIsnXozFy8NLmCy9 + Qo558RKEHPPiJQg55lN4D5m99ZG73k6Qh/cZHJmz6G3mmMajLJ54MRYvHy9hsuwIOeZTJt+OkGNevAQh + x7x44+p8/D+l+h3g4eb9bKo7aUsHE2zxxIvxrvMiJ8uOkGM+ZfLtCDnmxUsQcsyLF6bWTe5Tq98BHo4r + qx7f4sEEWTzxYixetQCY02TeEnLMi5cg5JifM+8Rc299lF6/Azw81jifrJFf3+LBjFo88WIs3hVe5GRZ + CzlOtutMvrWQY168BCHHvHjhut08WB+l128PDy80GpX11dC3/64KnXr69PFPBDY+6i13zqjFEy/GE+dF + C/MBJ9t1Jt9ayDEvXoKQY168OH3AfNL1Fu0EHl5p3CvrJ/fo//H+wk7mM3fe+aIbreE/3sLBDFo88WIs + XocXJc4HJU7mlZBjXrwEIcf83HlL87e3UG9RTuTdZ/bK+gkXfzzxd3wBgB3MeJNQ1eHL5eKzM+icXosn + XoxnwgsW54MSJ/NKyDEvXoKQY34XeG/cUr0FO5HX+/U/6ydc/N37foYXANwZbxE6Y646/fDw8Bcm3jm9 + Fk+8GM+IFySrf11sxAsWcswXybM6+OKW6i3Ia/A+be7I+gnXc7zlF2/7dQsA/z0A2GDG+4Px079bAJxb + LPZvsc2+RgddUOd4LZ54MZ4Zb1RW+7rYiBcs5Jgvkmf18MIt1tuo1+ThmT0toZ/MuJ7D9QKAm9uyDW6l + cGR2CwDYdfZXzL6GvS6sczoWT7wYz5A3KNS9udjJHDnmxUsQcszvDO/gYPmBiPoYdAH12zReZ4xn9tTC + 8ZrxST6u524BsM/NbdkG9zsC7OgWAHCzs0ffDuhcWOd0LJ54MZ4pr1eoe3PRkznz4iUIOeZ3hnfPPa+4 + YHXxrYj66HUh9ds03mhYC8drdtdwtwDA9b33o3/cHYgVglsAYOWw2tm9b05qusDOaVk88WI8Y55XqHtz + 0ZM58+IlCDnmd4p3+vTpn95yvXmdiYeXGlXi8bpP790CAJ/s9178cVMAVgduAQD3dfajZt8/oHKhnVNb + PPFiPHNeR6h7c/GTOTniRQo55neOt1wuPr/leus4I6/6+N+O0x0v7BYAuJ4P3vTXXAD0rxSuqPfXAAV3 + TmXxxIvxDvBasrrf2YtDw+IFCjnmi+ddf/3FHymg3lrOyMMbDVf7D//FAgCf5Pdfz20jQm4B0P87gqu6 + w9z5RxTcOZXFEy/GO8KrxXlgI5Nvw+IFCjnmxUsQcsxXrOVy+eAM69f5/tXj5f+v3sPXFXYwYwGAewDG + Lv5O9UsU4MI7RzzxorxDvEqcAzY2+dLiBQo55sVLEHLMV6xLl256odXIMzOs38qWv615vHTz23v9wk7m + /gcD+PUuc9V46Z0jnngx3jHezl8caPEChRzzk+EdHCzfP9P6Re4rq8fLP4f1n+0Yc+F3wg0Hz06gc8QT + L9i7xsMkwckibfJYEXLMi5cg5JgXL0HIMV/zXvCC237Q6uNJ2+ytgSGXXr/IHR4e/p3m8ZqT+y9K1vjv + ld454okX6l3kcbLIMnkgx7x4CUKOefEShBzzLZ6N879lm701MORN1NsGeM9evvw8fPy/dv9FCY3YyuO/ + y3wwDZZ4MRZPvBg7XmPiWGvyQI558RKEHPPiJQg55lu8m2++tLDNXzd766DPU6lffK2xebzmpP6LEhpB + Y7fccvkWO5BnSu0c8cQL8S7zOHGsNXkgx7xjiRch5JgXL0HIMe/jvdHsrYM+T6l+j4+Pf37leDcrNMLG + qo5eLpf/vtTOEc+fGbJ4u8VjHW9q8o0WcsyLlyDkmBfvivD9eG8t+Dyx+v3enXe+6MaV492c0Agbqzv7 + zJnT/1WhnSNepMXbPR7reVcvDlFCjnnxEoQc8yfFe63ZWws+T61+Dw6WH1k53s0JjbCxVmfP/Xcs4okX + 4qnyrIZ39eIQJeSYFy9ByDF/krzgn/6nWL/nz5/7sZXjjZJlw779h0bYuX2d/W6z9x/u8xQ7W7xwizcp + XrRQ96z/vvkgSsgxL16CkGNevKt6jblTCz6fcL1F28dbLPYfXjneYFnOPfp/PI+dzHii0FBnXzLjXcTe + A2h6ip0tXrjFmxwvSqh71v/QfBAs5JgXL0HIMS9eW0E//W+h3qI8wPs52x4t6ydc/PHE3/EFAHYw41nC + zQ7vO3mfNnsPwvkEO8e7/5jFEy/GM+EFC3XP+h+bfIOEHPPiJQg55sVr6z5zc4x7vaV6C/YA7ynbfsYc + JesnXPzd+36GFwDcGW8Rwk//rtOHTt7rzd4DgU+wc7z7j1k88WI8I16QUPeNeWBo8g0ScsyLlyDkmBev + rVPm1ntqfN5ivQV5hPcRc5Ssn3A9x1t+8bZftwDw3wOADWa8Pxg//bsFwNjJQ8d/0xx7MNEWT7wYizfI + GxXqnvU/NvkGCTnmxUsQcsyL19WbzL5xXnvL9TbqAN7d5mChn8y4nsP1AoCb27INbqVwZHYLgLC3Cl1z + zXvNsQcTZfHEi7F4o7xBoe7NmGwx6TrrYhMo5JgXL0HIMR/CW5q/ZvaN88oF1NugA3iPmoOFfjLjk3xc + z90CYJ+b27IN7ncE2NEtAMbfJ3xVt5rrmwG30DlRFk+8GM+U1yvUvXlbk/mokGNevAQhx/xceG8z+8Z4 + 5ULqrdeBvLebg4R+MrtruFsA4Pre+9E/7g7ECsEtALByiD15nzNvq3OCLZ54MZ4xzyvUvXmbk/mgkGNe + vAQhx/xceBfNT5h9Y7ykevM6kPe0+bx5VOgns/v03i0A8Ml+78UfNwVgdeAWAHDKyXvDljon2OKJF+OZ + 8zpC3Zu3OZkPCjnmxUsQcszPifdhs298l1ZvHUfwPmoeFfqJ/QW7BQCu54M3/TUXAP0rhRHhyYB2AH8Y + cDBB3mJnB1k88WJcIK8lq3tdbMQLFnLMb5P3fPMz5s74LrDeWo7kvdg8KPQT+8v1GxYA+CS//3puGxFy + C4D+3xGMiJxzR0eH79pC54xaPPFivCO8Wq5+zTGTb6+QY168BCHHvHjD8j6DptB6qx3J+4x5UOgn9lez + 78bv4cMOZiwAcA/AWhd/8/nbb3/BJTuY7024s0ctnngxLphXqVm/DYdMvl4hx7x4CUKOefGG5X3oT8H1 + VjmBh0cb9wr9xP5q9l/Yt/ewk7n/wQAjYr7V+MHB8v0T7uxBiydejAvnlTSZe4Uc8+IlCDnm58bzfu2v + 8HpL4eHBRr1CP7G/YvvvimzHpAs/hEbYWKvx5XJxk232/l5myAV09qDFEy/GpfOsVud6cfAKOebFSxBy + zJfAu9/cGs+l11si781mr9BP7K+U/ltPaISN9TWOuxZ9B+R1IZ3da/HEi/EUeKzXvvqNEnLMi5cg5JgX + b1ydr/1Nod4SeI+b8UlHR+gn9ldK/60nNMLGhhq/w+w7qI4L6exeiydejKfCG6nfYCHHvHgJQo558cL0 + MXNnPOeujwJ47zJ3hH5if6X2X7rQCBsLaRx3L/oOrHZBne21eOLFeEq8gPodFXLMh8wHo0KOefEShBzz + c+W91uwdz7nrY8u8J82dB/+gn9hfqf2XLjTCxkIbf7XZd3CVC+psr8UTL8ZT4wXU76CQYz50PhgUcsyL + lyDkmJ8rD6/B/brZO55z18eWee8zt4R+Yn+l9l+60Agbi23c+3rGwjq7Y/HEi/EUeYH16xVyzMfOB14h + x7x4CUKO+TnzPmjuHc+l11sED+/UuWyuhX5if63Tf2lCI2wspXHcxdg6wMI6u2PxxIvxVHmB9dsRcqz/ + lPmgI+SYFy9ByDE/Zx5eg1u9bG6q9RbBwz0OtdBP7K91+q8ly4Z9+w+NsLHUxvHu4a+aq4MrsLNbFk+8 + GE+cFy3UPes/dT5oCTnmxUsQcszPmYc74atPkk+4PqKdgYdFDm6gr4R+MuccL+7R/+N57GTGE4XWbfyN + 5hI7u2XxxIvxDHhRQt2z/tedDyohx7x4CUKO+bnzftm8jfqIcibex82V0E/sr3X7r5LlcPHHE3/HFwDY + wYxnCTf/AamNn7JOeLTAzq4tnngxngkvWKh71n+uyUg88UJUvexnS/UR7Ey8+qd/9BP7a93+q2Q5XPzd + +36GFwDcGW8Rwk//7h+xTuN7x8dHb16zc2oXevJqiydejLfICxLql/WfazIST7wQ4dfHX9lifQQ5I6/6 + 6R/9xP5at/8qWQ7Xc7zlF2/7dQsA/z0A2GDG+4Px079bAKzTeH0wi8Xi0YI6u7J44sV4ZrxRNeu34Szz + QcPiBQo55neB9+4t18eoM/Kqn/7RT+yvHP3nzgeu53C9AODmtmyDWykcmd0CIOytQh4hZ64P5syZ0z81 + 05NXWTzxYlwAb1Cr9UuvOxmJJ16I7rVx++yW62PQmXkfRz+xv3L0nzsf+CQf13O3ANjn5rZsg/sdAXZ0 + C4Dx9wn3CDlz52Cscx6yzb4OGHThJ0888aJcCK9XVqslXxzEmzfvjI3brxdQH73OzLOFzv4L2V85+s+d + D3cNdwsAXN97P/rH3YFYIbgFAFYOmxgMeLexrxN6XfjJE0+8KBfE8wp1ynr11W+0kGNevAQhx/xO8Gzc + /qtC6sPrDfB+nf2Vpf+QM7tP790CAJ/s9178cVMAVgduAQBvcjB8yeztjFVP4OSJJ16wC+N1hDplvQ7V + b7CQY168BCHH/E7w9vb2frKg+uh4A7ynbrzxubfn6j/kmIfdAgDX88Gb/poLgP6VwogsFzoYXmX2dkjT + Ezh54okX7AJ5LaFOWa9j9Rsk5JgXL0HIMb8TvMVi/xYbw99bYzy3XGC9tYzcwcHyA7n6DznmHQcLAHyS + 3389t40IuQVA/+8IRkROzGD4nNnbMfAUTp544oW6UF4t1CnrNbR+B4Uc8+IlCDnmd4J3882XFrYA+PKa + 47l2ofVW+wpv/7u33HL5lhz9hxzzTdb4PXzYwYwFAO4BOKmLP3SXuXq286qncfLEEy/MBfMqoU5ZrzH1 + 2yvkmBcvQcgxvzO8g4ODX80wnisXXG+VHe/w8PCXcvUf883zEfbtPexk7n8wwIiYTx0MHzZ7Oyd3Z4sn + Xoh3jLeRyZx58RKEHPM7wzt9+vgnMo3n0uut5i0W+3/w0pe+5IYc/cd82vmwHZMu/BAaYWNpjV9zzUXz + k+ZW5+TubPHEC/Gu8VCnrNfU+m0JOebFSxByzO8M7/rrL95l47jxe//dqN8zZ07/tRz9x3yW8xElNMLG + 1m38fvOkTp54/syQxSuPx3pdt34rIce8eAlCjvmd4d1xx+3PXSwWj5VaH5viLZeLz+boP+aznI8ooRE2 + lqPxpXXO16Zy8sTzZ4YsXpm8TPU7iYsN8+IlCDnms/KWy+Vvl1wfG+I9c8MNz/nhHP1nznI+ooRG2FiW + xpHbxd8BiSdeiDfJy1W/zGebD5gXL0HIMV807+jo8P7c43kKvIODpXvoTxHnI0pohI1laRw55s/jY5Hc + nS1enMXbLR7qjvVX1MWBHPEihRzzRfPOnz/3Wht/z+QezxPgfffy5Zv/1Lr9Z85yPqKERthYlsaRY75i + Xbx44Uets54t+OSJF2Hxyuex/oq6OJAjXqSQY75o3qVLN73Qxt63NjGeS+cdHh7+wrr9Z85yPqKERthY + lsaRY77Fs077ddvs7dAhn8TJEy/c4k2DZzVX1MWBHPEihRzzRfPuvPNFNy4Wi4c3NZ7L5u0/iocd2fZo + uf4zZzkfkGXDvv2HRthYlsaRY97Hw9cCnzB7O9bnaQ4G8UIt3kZ50UKdsl599Rst5JgXL0HIMV807957 + 7764XC5+d8PjOdonxdvb2/sx2x4t13/mXOfDPfp/PI+dzHiiUK7GQw7mbWZv5656qoNBvDCLt3FelFCn + rNeh+g0WcsyLlyDkmC+ed3Cw/MgJjOconyDv39j2aDX7r+F1zgcu/nji7/gCADuY8Szh5j8gy2Bo2Mc7 + ZX7I7O1k5xM8ed79xyyeeDHeEi9YqFPW61j9Bgk55sVLEHLMF887Ojp81wmN52CfIO8p237JHKVm/zW8 + zvnAxd+972d4AcCd8RYh/PTv/hFZBkPDQ7ze9wTAJ3jyvPuPWTzxYrxFXpBQp6zX0PodFHLMi5cg5Jgv + nnfmzOmfsvH37ETrI8gjvLebo9Tsv4bXOR+4nuMtv3jbr1sA+O8BwAYz3h+Mn/7dAiDLYGg4hPc+c2xn + R1s88WI8M96oUKes19j69Qo55sVLEHLMF8+77rrzr7bx98cTro9Rj/AeNuMT7WA1+6/hdc8HrudwvQDg + 5rZsg1spHJndAiDsrUIeIWdOPZgz5m+YQzs72uKJF+MZ8gaFOmW9ptRvR8gxL16CkGO+eB6edmfj7zsT + r49Bj/DwCTY+yQ5Ws/8aXvd84JN8XM/dAmCfm9uyDe53BNjRLQDG3yfcI+TM6x7MfeaQzo62eOLFeKa8 + XqFOWa/r1G8t5JgXL0HIMV887/Ll5922WOz/5xnUR68DePgEO1jN/mt43fPhruFuAYDre+9H/7g7ECsE + twDAyqGEwfXxLZy8KIsnXowL4nmFOmW95qhf8XaId9ttt968WCwenUl9eB3A+5r5yBykZv81vO75cJ/e + uwUAPtnvvfjjpgCsDtwCAC5icB0cHDzHOvg7A50d5S0MhiiLJ16M1+R1hDplvWapX+SYFy9ByDFfPO/2 + 219w6cqDfna63vDR/yvNQWr2X8M5zgfsFgC4ng/e9NdcAPSvFEZkuY0czOnTxz9zQicvyuKJF+MCeS25 + ejNnrV9yxIsUcswXz+NT/n5/ZvXRciDvg+YgNfuv4VznF//FAgCf5Pdfz20jQm4B0P87ghGRs6mDOb9c + Lv/9BAdDsMUTL8aZeLVW643OVr+0eIFCjvnieS996UtuuPIyt52vN3z0j5vXR9Xsv4Zznl/8//g9fNjB + jAUA7gEo8uIPP+95N/1p6+yoxwQ7b2kwBFs88WKckVfJV2/8c3EXm4bFCxRyzGfnXXnEr344o19lHlWz + /xrOfX7Dvr2Hncz9DwYYEfObPhjHe515tdMHvcXBEGTxxItxZt5J12+0kGNevAQhx/xGeHbx//iM6yOG + F3TXv/VZWefXdky68ENohI2lNb4i5Jgf4j1gXu18r7c4GIIsnngxzs1DXbG+huotWMgxL16CkGN+Ejy7 + +H9szvURwXvEvDQParX/6GLOb5TQCBvL0jhyzI/x8DuWr5pXT0LLWxwMQRZPvBhvgsf6Gqu3ICHHvHgJ + Qo754nn82F8/+V/x0+Y7zINq9l/DxZzfKKERNpalceSYD+W9zPyMefVkVN7iYAiyeOLFeFO8iHobFHLM + i5cg5Jgvnnflhj/9zr9hvL12UM3+a7iY8xslNMLGsjSOHPOxvPvNnROy5cEwavHEi/EmeZH15hVyzMfW + r1fIMS9egpBjPjsPX/VbLhefL3U8b4H3KfOgmv3XcDHnN0pohI1laRw55lN4eKHBF8z1CdnyYBi1eOLF + eNO8yHrrCDnmU+q3I+SYFy9ByDGfnceH/PxeyeP5hHnfNN9g7lWz/xou5vxGCY2wsSyNI8f8OrzL5uqr + gVseDKMWT7wYnwQvod5qIcf8OvVbCznmxUsQcsxn5/Hxvg+VPp5PmPcac6+a/ddwMec3SmiEjWVpHDnm + c/DeWMBgGLR44sX4pHiJ9Vb85IYc8+IlCDnm+WKfnX+2/6oHn/bX7L+Gizm/kGXDvv2HRthYlsaRYz4b + b7lc/K8RJ2/QBQyuQYsnXoxHeNFCvbFes9Uv8+IlCDnms/NuvPEH7tRb/Tp+1Nz7lb9m/zVc0vl1j/4f + z2MnM54olKvxjXTOld9P7f/BFgbDoMUTL8Zb4EXJ1Zs5a/2SI16kkGM+O++6686/2sbLtyY2nqOcwBv8 + yl+z/xou6fzi4o8n/o4vALCDGc8Sbv4DSjqYFu/CheteaSfw6QkPrkGLJ16MA3nBWq03utj5gBYvUMgx + f54vX/vjCY7nYCfy3mL2qtl/DZd0fnHxd+/7GV4AcGe8RQg//bt/REkH4+Xt7V37M7bZd+IGXcjg6rV4 + 4sU4ghckq63SJzfxMvGOjg7fZePl2YmO5yAn8j5s9qrZfw2XdH5xPcdbfvG2X7cA8N8DgA1mvD8YP/27 + BUBJBzPGww0avhPodSGDq9fiiRfjSN6oUFesr756ixJyzIuXIOSYz8rD0/0ODpYPnPD4G3UhvC+bvb/3 + d/1nzno+yMnFw/UcrhcA3NyWbXArhSOzWwCEvVXII+TMJ905OFE4Yb4T2XIhg6vX4okX4wTeoFBXrK+h + egsWcsyLlyDkmM/Ku/qAnxMff4MuhIfv+99o7sj1nznr+SAnFw+f5ON67hYA+9zclm1wvyPAjm4BMP4+ + 4R4hZ95W5+CE4cT5TmjlQgZXr8UTL8aJvF6hrlhfIfU2KuSYFy9ByDGflXfTTTe+aLFYPLyl8dfrQnh4 + 3PwrzR25/jNnPR/k5OK5a7hbAOD63vvRP+4OxArBLQCwcpjy4MeJ874voJDB1WvxxIvxGjyvUFesr5h6 + 6xVyzIuXIOSYz8o7d+7sfTZWvrXF8ed1Qbx3mDty/WfOej7IycVzn967BQA+2e+9+OOmAKwO3AIAnsPg + xwlsndSCBpfX4okX4zV5HaGuWF8p9dYRcsyLlyDkmM/KOzo6vN/GyjNbHn8dF8T7mLkj13/mrOeDnJw8 + 2C0AcD0fvOmvuQDoXymMyHIlds6D5mqAzHiwei2eeCNuCXXF+lqn3mohx7x4CUKO+Wy8O+64/bnL5fK3 + Cxl/LRfEw/v9j8wtof/Y/9nOB/Ob4OG/WADgk/z+67ltRMgtAPp/RzAicjZ1MOvwcCIfLWhweS2eeDHO + xKuFumJ9rVtvlZBjXrwEIcd8Nt7111+8a7FYPFbQ+KtdEA/vlrnV3BL6j/2f7Xwwvyke/n/8Hj7sYMYC + APcAzO3iX8lO/gvN30kYDF4XNFi9Fk+8QFdCXbG+stQbcsyLlyDkmM/GO336+CdsnHxvzfFSueDxXHkN + 3rPm15pbQv+x/7OdD+Y3yQv79h52Mvc/GGBEzBffOXy05R9vcXB5LZ54Mc7Mm0z9kiNepG6++dLi4GD5 + jzONl9LH87q8t5lbQr+z/7OcD+SYL4NnOyZd+CE0wsbSGl8RcsxvhHd8fPxzMxqsHYsnXoxX64Mutn5p + 8QJl4+O2xWL/y7nGS+njeU3ee80tod/Z/1nOB3LMF8mLEhphY1kaR475jfJsMPyibfYNgEEXNlg7Fk+8 + GCPnqw/zLCc35JjfCd7e3t5P2hhpfOS//ngpfTyvwcON4i2h39n/Wc4HcswXyYsSGmFjWRpHjvmT4uG5 + zr6B4HVhg7Vj8cSLseMN1EeUkGNevAQhx3wO3hk7v781hfFXCO8r5tZjftHv7P8c56N4XpTQCBvL0jhy + zJ8kD89C/rTZNyBaLmywdiyeeDFu8gbqI1jIMT9Ub8FCjnnx4nWvnd+vT2X8FcD7mvkGcy30O/s/x/ko + nhclNMLGsjSOHPPb4J03P2r2DYzKhQ3WjsUTL8arvJH6GBVyzIfU26iQY168OOEHml+x81u9xW9T42Vm + vG+bn2+uhX5n/697Piohx3yRvCihETaWpXHkmN8m75L5G+bOAClssHYsnngx9vEC6qNXyDEfU2+9Qo55 + 8eJ0u/mhKY6/LfKeNt9troV+Z/+vez4qIcd8kbwooRE2lqVx5Jgvgfdi85PmeoAUNlg7Fk+8GPfxAuuj + I+RYXyn11hFyzIsXLvze+pfNz0x1/G2R93pzLfQ7+3+d81ELOeaL5EGWDfv2HxphY1kaR475knivNlcv + DipwsLYsnngxHuFFC3XF+lqn3mohx7x44cJPr9WvL094vES7QN795lrod/b/OuejFnLMl8pzj/4fz2Mn + M54olKvxkjvnjTaI9Ds08YI9A16UUFesrxz1Jl4874z5A2Y8sW4b4yXKBfLeY66Ffmf/p56PlpBjvlQe + Lv544u/4AgA7mPEs4eY/oKSDyc47Ojp82xqDq+UCB3/L4olnDhbqg/WVrd6YFy9MeETt180x5zfYO8D7 + oLkW+p39n3o+WkKO+VJ5uPi79/0MLwC4M94ihJ/+3T+ipIPZGM8WAe8qYLC2LJ54MY7gBalZHw0XWb8N + z4V30YxX09bnbYvjJcgF8j5iroV+Z/+nnI+OkGO+VB6u53jLL9726xYA/nsAsMGM9wfjp3+3ACjpYDbO + Ozg4+HszGvwtiydew6Py1Qf/vDPzAf980jzc5PdOs25QXo+Hp/zha5KV0O88n9s+v14hx3xOHq7ncL0A + 4Oa2bINbKRyZ3QIg7K1CHiFnLr1z+ni/YvYNqF4XOPhbFk+8FQ8KdcB68NVHtJBjXrxh4eP+x8yt81XA + eBl0gbxPmnf94o9P8nE9dwuAfW5uyza43xFgR7cAGH+fcI+QM5feOWM83HDjG1gdFzj4WxZPPI97hTpg + PQzVR7CQY168ft1h/oy5c64KGS+9LpCHfqwf8Yt+Z//HnI9eIcd8yTx3DXcLAFzfez/6x92BWCG4BQBW + DnPunFDeA2bfAKtd4OBvWTzxeuwV6oD1EFIfo0KOefH8wlNJ67v7V13QePG6QN6XzEfmSuh39n/o+RgU + csyXzHOf3rsFAD7Z773446YArA7cAgCec+fE8vB7JN9AK3HwtyyeeAPuCHXAeoipj14hx7x4XeEnVLyD + /gmz7/yUNl46LpCHl/vg65KV0O/s/5DzMSrkmC+dB7sFAK7ngzf9NRcA/SuFEVlurp2N3yN9wtwabAUO + /pbFE2/ELaEOWA+x9eEVcsyL1xbmk7eY66/1+VzgeGm5QN7DZnyaUgn9zv4fOx9BQo75KfDwXywA8El+ + //XcNiLkFgD9vyMYETmbOpgSeCja+us4BQ7+lsUTL8C1UAesh9T6aAk55sVr683mr5p956N2oeOldoG8 + L5t18W+zxu/hww5mLABwD4Au/uN6oMDB37J44gW6EuqA9ZCjPsTz895gHnz7qHPB46VygbwvmHf9d/6r + vLBv72Enc/+DAUbE/NQ6Zy3ecrn80BqDteUCi6ll8WbN28n6Zf6kePeZ8dG0r/87Lny8lMj7lHnX7/ZP + 59mOSRd+CI2wsbTGV4Qc88XzDg8P/kkBg79l8cSLcXM8N1xkvTU8Fd4bzcEXfrj08VIgDzdn6+KfiRcl + NMLGsjSOHPOT4emJgeEWrzze6njmn3emfvnnbLwXvOC2H7R+/Vu2efDmPp83cX5nzsPXs3f9IT/ZeFFC + I2wsS+PIMT9F3lvNvgHa6wKLqWXxdoPXM56jhRzzO8m7fPl5tx0cLD9g/dr7db4hb+r8zpi36y/2ycqL + EhphY1kaR475KfNwZ6/3IR6rLrCYWhZvd3gD4zlYyDE/VB/BQo754nkXL1740eVy+aD15TMlnt+Z8nb9 + lb5ZeVFCI2wsS+PIMT8HHu7yfcbsG7SVCyymlsXbLd7IeB4VcsyH1MeokGO+WN4997ziwunTp396sVh8 + Mff5EG/U7zLXwvng+cx2fpnfCV6U0Agby9I4cszPifcqc+vtXc4FFlPL4u0eL2A89wo55mPqo1fIMV8k + z/qr+pjf/vudq32o8RfqNXn4wQoPTqqF88jzmeX8Isf8TvCihEbYWJbGkWN+jrwXmx831wO4sGLqWLzd + 5AWO546QYz2k1EdHyDFfGg93mL/R+u/zJ3E+xPMaP1DhB6taOI88n+ue30rIMb8TPMiyYd/+QyNsLEvj + yDE/Z96N5ofMpRVTx+LtNC9aqAPWwzr1UQs55kvi3W7Gy3m+fcLnI9oz5+EHKfxAVQvnkeNtzuOvFnLM + 5+K5R/+P57GTGU8UytX4LnX2kQ3yf6diFy/UW+BFCXXAeshRH6XxLpnxO+Zq4Q5v4XxEeeY8nAf8IFUL + 55HnM+X8doQc87vCw8UfT/wdXwBgBzOeJdz8B5R0MMXzcMPQwcHygQKKqWPxxDMHC+OZ9ZCtPpjfJs9d + 9PEc+Wa/bOt8BHvmPLx4rX60L4TzyPMZc357hRzzu8LDxd+972d4AcCd8RYh/PTv/hElHcykeEdHh++y + wf/sTIqzY/EmywvS6nimi603uo+HnyrfYe5c9J23eD6CPHPeh8wt4TzyfIac31Ehx/yu8HA9x1t+8bZf + twDw3wOADWa8Pxg//bsFQEkHM0ne3t7ef2mbnzb7Bn2vCyvOjsWbNG9UNnbnUL93mX/Z/CWzrx9qb/l8 + jHrGPDxH5e3mlnAeeT6Hzm+wkGN+l3i4nsP1AoCb27INbqVwZHYLgLC3CnmEnLn0zjlJ3t3mb5p9BdBx + QcXptXiT5w0K45bjt288Rwk55jfKOzg4eI5txnM58Ppu1VuPC+I9ZX6tuSU7l5Mcf+aSePgkH9dztwDY + 5+a2bIP7HQF2dAuA8fcJ9wg5c+mdsw0efu/4FbOvEGoXVJxeizcLXq8wbjl+x8ZzkJBjfiO86647/2q7 + 8P+qHe/v22bfsQ66kPPR6xnzvmZu3ekPrZ5futjxR5fGc9dwtwDA9b33o3/cHYgVglsAYOWgzg4QcsyH + 8vD94g+bfQVRUnF6Ld5seF5h3HL8ho7nQSHHfBbe2bNnTp85c/ovHx4e/KPlcvF5O97vzeR8eD1j3qfN + 580tYVxwfGQZL8gxv0s89+m9WwDgk/3eiz9uCsDqwC0AYHV2gJBjPoWHp1u17gsoqDi9Fm9WvI4wbjl+ + U8ZzR8gxvw4PN+7hI328cOehgvqvY/GCePh9P+7J6AjjguNjnfFSCznmd40HuwUArueDN/01FwD9K4UR + WU4nL573MnP15MBCirPX4s2O1xLGLcfvOuO5FnLMx/BuNb/OjAvEx831q3UL7L+WxQvi4Y2JrzF3hHHB + 8REzXnqFHPO7yMN/sQDAJ/n913PbiJBbAPT/jmBE5GzqYObOu2hFo8eNihfsTLxaGLccvznGcwjvjPle + M16njXe7474Y3Azm+3eW2n+1xQviPWy+bO4I44Ljo2+8RAk55neVh/8fv4cPO5ixAMA9ALr4Bwg55rPx + rjw06OD9WyzOXos3W14ljD+O32zjGfnrr7/4I2fPnv3xo6OjdyyXyw/av+9f2mZcBILvzIcL7r/K4gXx + PmJuPdzHyY0Xc9bxR86u8sK+vYedzP0PBhgR81PrnGJ5Z86c/ikrqO9PvNh7LV5RvJTxjI/o8WsrfKUV + P73D7zbjp/gH7N/xsP2b/ijTv6/0/hNvnIc3+WGMeIVxxvEWOv4GhRzz4oXIdky68ENohI2lNb4i5Jjf + aZ4V1Qtt86NmX0H1uoBiH7R4xfF+w34y/18ODpYfXSwWv29+xJiP2N/jp/Smv4r9x7yBf5940+bh/g0s + FL2yuU7zfUG8KKERNpalceSYF++K8FVBvJHMV1gdF1DsgxZPvBiLN3neg+bOV/ycMM9xvuub/6KEHPPi + bVpohI1laRw55sXrCk/I+obZV2SVCyj2QYsnXozFmzQP7+9/k7lXmOc434XMf6NCjnnxNi00wsayNI4c + 8+L16wbzJ82dgttysY9aPPFiLB48WR7etYB7RHqFeY7zXcz81yvkmBdv00IjbCxL48gxL16YcDNN/VUp + FKEmI/FCLZ54MY7g4UY/PLfB/5IZCvMc57vU+a8l5JgXb9NCI2wsS+PIMS9enG43P7zFYg+yeOLFWLzJ + 8nCDaO+Nfk6Y5zjfrTv/VUKOefE2LTTCxrI0jhzz4iXo4sULhwcHy8YzA3qLM8hbnDyCLJ54MRbvxHj4 + bj8e6DQozHOc77LMf8gxL16iLBv27T80wsayNI4c8+IlCDnmz587d/a+xWL/Dyc6eQRZPPFiLN6J8L5t + fr15VM35quEi59OG58xzj/4fz2MnM54olKtxnbzMvBe84LYftOL8DdvcLNAgb2nyCLZ44sVYvBPhfcKM + m5JH5Zuv+GfN9wFCjvlcPFz88cTf8QUAdjDjWcLNf0BJByNem/cqc/3ilDFvafIItnjixVi8jfOCf+qH + MC9xfuqbr6KEHPPiJchyuPi79/0MLwC4M94ihJ/+3T+ipIMRz8/D7+NGHx60hckjyuKJF2PxNs4bfKjP + qjAvcX4am6+ChBzz4iXIcrie4y2/eNuvWwD47wHABjPeH4yf/t0CoKSDEW+ch7eseR8lvIXJI8riiRdj + 8TbKwyeK95mDhXmJ81PMfNUr5JgXL0HImXE9h+sFADe3ZRvcSuHI7BYAYW8V8gg5c+mdM1ceTvL95qfN + IcUebfHEi7F4k+Hhe/3vNXvf3tcnzEucn1Lmq46QY168BCFnxif5uJ67BcA+N7dlG9zvCLCjWwCMv0+4 + R8iZS++cXeDhyVyfPsHJw7v/mMUTL8bibYz3+7b9DnOUMC9xflp3vqqEHPPiJQg5s7uGuwUAru+9H/3j + 7kCsENwCACsHdXaAkGO+WN7x8dGbF4vma1o1WYZaPPFiPE3e/rfs73/OtkcL8wvnp2zzFfPiJQg5s/v0 + 3i0A8Ml+78UfNwVgdeAWALA6O0DIMV887847X3Tj4eHBP7Ji/37Zk5F4oRZPvBh7eM8sl8sPHR0dXrDt + 0WrOLw0XOf81vAs82C0AcD0fvOmvuQDoXymMyHI6eRPgLZeLm2zzx8zeSaLPE5zcxIuweLvFs3ngf7/+ + +ot32Zyg+TRAyDE/BR7+iwUAPsnvv57bRoTcAqD/dwQjImdTByNepJBjfoiHZ3g/ZPZOGE1PbXITL87i + 7Q5vsVg8hqeIeuaDYCHH/ND8EizkmBcvQcgx32SN38OHHcxYAOAeAF38A4Qc83Ph4f3dj5tHJ4/ck5F4 + /syQxRMvxg3ed4+Ojt557713XxyZDwaFHPOh88ugkGNevAQhx3yTF/btPexk7n8wwIiYn1rniNcVHiL0 + HnP9tUF4QpObeJ79xyzeLvD2nzk4OPjnt912680R84FXyDEfO794hRzz4iUIOebTeLZj0oUfQiNsLK3x + FSHHvHgJQo75dXiXzdX9Abs5WYonXpinwFssFr9zww3P+eE15oNayDG/zvxSCznmxUsQcsxn4UUJjbCx + LI0jx7x4CUKO+Sy8U6dO3WmTx7/NORmVPlmKJ16oJ8D7D+fPn/uxXPMBcsyLlyDkmC+SFyU0wsayNI4c + 8+IlCDnms/MuXrzwo7hbeOaTpXjiBbtw3udOndq7x9Vvw0XOLw2LFyjkmM/CixIaYWNZGkeOefEShBzz + G+WdOnXqFbb502bfpNPrwidL8cSLcsG8L5nvtVrVfCXeZoRG2FiWxpFjXrwEIcf8SfLw1cHPmX2TUMsF + T5aVxRMvxoXyvmLGq8A1X4m3OaERNpalceSYFy9ByDG/LR7eOIifOnyTUqmTZW3xxItxgTw8v+M15kqo + U9ZraP0OCjnmxUsQcswXyYsSGmFjWRpHjnnxEoQc8yXwXmn+lLmenAqcLFsWT7wYF8b7grm+8EOoU9Zr + Sv12hBzz4iUIOeaL5EGWDfv2HxphY1kaR4558RKEHPOl8W43P2CT2NMFTZYdiydejAvh4fW8HzW/2NwS + 6pT1um79VkKOefEShBzzpfLco//H89jJjCcK5WpcJ2/mvOc976Y/fXh48E9sYvvulibLXosnXowL4D1p + fp/5RnNHqDfWa7b6ZV68BCHHfKk8XPzxxN/xBQB2MONZws1/QEkHI17BvCtvHjz8BZvcvmqbfZPboAuY + fActnngxjuR93fwOM57O6dVqvdHFzge0eIFCjvlcPFz83ft+hhcA3BlvEcJP/+4fUdLBiDct3uvMXzb7 + JruOtzz5jlo88WIcwcONfW80Dwp1xfrqq7coIce8eAlCjvlSebie4y2/eNuvWwD47wHABjPeH4yf/t0C + oKSDEW+6PHyF8CPmp8yrk1/lLU6+QRZPvBgH8PDuDTx6GzfTjgp1xfoKqbdRIce8eAlCjvmSebiew/UC + gJvbsg1upXBkdguAsLcKeYScufTOEe/kefho863m1quItzD5Rlk88WI8wnvE/HbzeXOQUFesr9h68wo5 + 5sVLEHLMl8zDJ/m4nrsFwD43t2Ub3O8IsKNbAIy/T7hHyJlL7xzxts+7y/whmxSfPMHJN9riiRdjP2// + e/b3v2HbX2aOEuqK9bVuvVVCjnnxEoQc8yXz3DXcLQBwfe/96B93B2KF4BYAWDmoswOEHPPiJQi5O+64 + /bnHx8c/v1gsfn8zk694oRYvL8/G9ENHR4dvs/F9zrZHC/XB+spWb8yLlyDkmC+Z5z69dwsAfLLfe/HH + TQFYHbgFAKzODhByzIuXIOSYr3kXL154mU2i77fN3zR7J9k+b3oyFy/OO8z7zsHB8tevv/7ij3B8az4I + EHLMi5cg5JiH3QIA1/PBm/6aC4D+lcKILKeTJ16wkGN+iPdq84fN3zbXFxafd/hiI55n/zFvgPfEcrn4 + zbNnz/zVgfEcLOSYH6qPYCHHvHgJQo75KfDwXywA8El+//XcNiLkFgD9vyMYETmbOhjxIoUc83PivdaM + bxE8YV6dfHNP5uKJF2I8rOdje3t7P37PPa+4EDmee4Uc8+IlCDnmd5WH/x+/hw87mLEAwD0AuvgHCDnm + xUsQcsyn8vA1lvvM+PrUkwVfHCqLNzteddE3YwziU1PVr3jBQo75TfLCvr2Hncz9DwYYEfNT6xzxAoUc + 80XyLl68cHj69PFPLJfLj9tE/r0CLg4tizcbHi76HzfjoVZLcyWMW47fLOMZOebFSxByzIsXItsx6cIP + oRE2ltb4ipBjXrwEIcf8zvLOnDn9l20y/1XbjO9Z+ybyXhd0sfFavBPnYQy9x4z7UDryjT/+WfUbIOSY + Fy9ByDGfhRclNMLGsjSOHPPiJQg55sW7KrxE5c3mT5g79w00XcDFZtDinQgPYwRjBWPG+wIeJ4wzjreh + 8Rcs5JgXL0HIMS/epoVG2FiWxpFjXrwEIce8eMPC41Z/xawnEIrneBgLGBNBj+KFMM443mLHn1fIMS9e + gpBjXrxNC42YcYMBGnQOu+HAI+SYFy9ByDEvXpxuML/BLgK/ZheE/+vKBeKKT53CxcF/MRkzcsiL599/ + zJvmLRb7jyyXi//JzvtP2naMgShhnHG8rTv+KiHHvHgJQo558TYtNGLGVwvQoPP4Vw16hBzz4iUIOebF + SxByzJ/5M3/mhTecPn18n10c3mMXh8/YZtz05b2oDBkXm1X79gu1eGvxnrLF3eeWy+V77Ny+7rbbbr0x + 13hpWLxAIce8eAlCjvksvCihETMeKoAGndd9XLB44gUJOeZPkneHGS9sedCMd7T7LjK1T53aW7l47Xn3 + C7V40bzHzThXb9/b2/shns+h8xss5JgXL0HIMS9egpBjPgsvStaIe0Uwnins3P94wREhx7x4CUKOefES + hBzzsbxLZjyM6F3mj5ofNlcXH7vgdOy2pVi8UR7u0Md38XEucE5wbirhPPJ8xp5fr5BjXrwEIce8eAlC + jvksPCg4ix3NeDwwGnRe53HB4okXLOSYL5Z3dHT0ssVi8d/s7++/335y/V27eP0/tsl30Qry6oUQ9u0X + 6onz8FP9p83vNb/JjLdH9grng+cz2/llXrwEIce8eAlCjvmcPDz3Z/yTA+7s3hHgvM7jgsUTL1jIMT9F + Ht7zjjvL32rGxct9YjD4giPcmd68EPJO9WRPhPct8388dWrvN80fsL/7eduGvgt+Vz6Efmf/+85HtJBj + XrwEIce8eAlCjvmcPDzxd3wB0NgZDTqv87hg8cQLFnLMz5WHn2RfY8YC4YPmB+3C9x/NT+Ci6Gx/n+wm + Z8s8fL8eix/8fh7H+lbLvnaxWLxsjf5rCTnmxUsQcsyLlyDkmJ8CL2gBgJ1a5qYkiSdejHadZxfH2+wi + +TLbhN9vY5GAmxEfoPG7b1xQYe8TD5sXaWfffqFeYf3f5v9of4/28W9x/653mPFvxb8Z//ZbzV6tHi/M + TUkST7wYiTewkMBGM+46dE5adTiJJ16MxMvDs0XE9Xt7ey+H7a9xQY7xRXMlx2tY5yNC4okXo5PhXXPN + /w/ftvYeR2yrGAAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAF8 + XgABfF4B+uxDaQAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAACDiSURBVHhe7d1/ + 7GV5fdfxz73nfme2u+vyK/JLWShogbZ/oCXdiq3S1mo1barE1qaJUkSsMSs2RloFrAqk2paWavwZjUWC + hqTCotvEYKmIwYK1hvLDrmYFUspSgV1Y290t+6OjrzP3ALN3zvc7537vufeeH49n8gjbme987/me87nz + fs92Zqf00sXyzOWq3LqoyhsWq/KWZVXeHXfm2z4b9wIAW/vs5VmamVrP1nrG5tturWduM32P1Ko8Pxfz + ulzYh3JB/w8AOJDM3noG17O4mcoH6KQ8L5vIz7ZeEABwUPVMrmdzM6X30s15kTflxS5tvjgAcFSX6hld + z+r1yO6pqirfmU9+/8aLAQDDcn89s5vxvVOLRVVek0/oV/0AMA6X6tldz/D1KN++Gxar8raWTwwADFw9 + w+tZvh7p3VvmB97e9gkBgHGoZ3k909ejvUOLqvxY2ycCAMalnunNeD+75Ul5SdsnAABGKrO9GfOndKE8 + Nx/44FU/EAAYswfrGd9M+6tbrMrbW34QADBy9Yxvxv1Gq/KCth8AAExDPeubqf+lllV5T9sHAwATkVnf + jP2mVfmG1g8EACalnvnN9L/8x/7qv2Kw9QMBgOmoZ34z/i//6/+PtX0QADAxmfnr6X9Sntf6AQDAJF3+ + 64PzD6/a/A4AYNJeVf///3+q5TsAgImqZ3/9H/95R9t3AgDTVM/++jcAfrDtOwGAicrsr38PwN1XfQcA + MGV31wtA23cAABNmAQCAGbIAAMAMWQAAYIYsAAAwQxYAAJghCwAAzJAFAABmyAIAADNkAQCAGbIAAMAM + WQAAYIYsAAAwQxYAAJghCwAAzJAFAABmyAIAADNkAQCAGbIAAMAMWQAAYIYsAAAwQxYAAJghCwAAzNB4 + F4CqfHBRlZ8EgGPJPPrEVfNpJEa7AOTG/5MiSdKRyiz6a5uzaUwsAJIkbVnm0KiHf80CIEnSFmUGjX74 + 1ywAkiR1LPNnEsO/ZgGQJKlDmT2TGf41C4AkSdcoc2dSw79mAZAk6YwycyY3/GsWAEmSTinzZpLDv2YB + kCSppcyayQ7/mgVAkqSNMmcmPfxrFgBJkq4oM2byw79mAZAkqSnzZRbDv2YBkCQpZbbMZvjXLACSpNmX + uTKr4V+zAEiSZl1myuyGf80CIEmabZknsxz+NQuAJGmWZZbMdvjXLACSpNmVOTLr4V+zAEiSZlVmyOyH + f80CIEmaTZkfhn/DAiBJmkWZHYb/FSwAkqTJl7lh+G+wAGgIreJ3xlOjqr9BkvoqM8Pwb2EB0GG7UL4i + z+8Vi1X5mWVV3p9//lRc+sJzjd+KT+b7fjEfc1v++S/mR9XLgSRtXX4OMfxPYQHQ/rtQnp3n9SMZ6ne0 + PctOshDkf/9GPtuT159Uks4uP2cY/mewAGifPSnP6R/neT28+fx2cF8+59/O575x/RKSdHX5ucLwvwYL + gPbRdXlGPxS/ceUz69n/ib+Q11qsX1KS1uXnBsO/AwuA+u6py6r8Qtsz24fFqrw9r+nfBki6XH5eMPw7 + sgCov1bl+Xk2d20+q72rygfLxfKM5iokzbT8fGD4b8ECoF6qqvKiPJcHNp/TAX06C8gtzeVImln5OcDw + 35IFQLu3Kr8vz+Tzm8/oCD7t3wRI8yvvfcP/HCwA2rWn5XnUvyGv9TkdXP3/DvB7AqTZlPe94X9OFgDt + 0vUZuPV/zKf1GR1L8xsD/ekAaeLl/W7478ACoHOXZ/CTbc9mIOo/IihpouU9bvjvyAKg83WxfHmew4Ob + z2VAfi1XecP6YiVNqby/Df8eWAB0rhar8q/bnsvA/FBzuZImUt7Xhn9PLADavpPyNXkGV/4FPkP1G7na + J64vWtLYy3va8O+RBUBbl1/9v6ntmQzUK5vLljTi8l42/HtmAdC2Vbn/92w+j8Gqyn9trlvSSMt72fDf + AwuAtmtV/mDb8xiwS7nqp6wvXtLYynvY8N8TC4C2Kvf9J9qex6CdlD/fXL6kEZX3r+G/RxYAbdWyKh9u + ex5DtliVf9NcvqSRlPeu4b9nFgBtVe79Pv+O//2oyn9rLl/SCMr71vA/AAuAtunGtmcxAp9orl/SwMv7 + 1fA/EAuAunehfEXbsxiBh3P1y/UXIWmo5b1q+B+QBUCdq6rywrZnMQa5/CetvwpJQyzvU8P/wCwA6lwW + gO9oexZjUC6UZzdfhqSBlfeo4X8EFgB1LgvAH297FmOQBeA5zZchaUDl/Wn4H4kFQJ2zAEjqs7w3Df8j + sgCocxYASX2V96Xhf2QWAHXOAiCpj/KeNPwHwAKgzlkAJO1a3o+G/0BYANQ5C4CkXcp70fAfEAuAOmcB + kHTe8j40/AfGAqDOWQAknae8Bw3/AbIAqHMWAEnblvef4T9QFgB1zgIgaZvy3jP8B8wCoM5ZACR1Le87 + w3/gLADqnAVAUpfynjP8R8ACoM5ZACRdq7zfDP+RsACocxYASWeV95rhPyIWAHXOAiDptPI+M/xHxgKg + zlkAJLWV95jhP0IWAHXOAiBps7y/DP+RsgCocxYASVeW95bhP2IWAHXOAiDpC+V9ZfiPnAVAnbMASKrL + e8rwnwALgDpnAZCU95PhPxEWAHXOAiDNu7yXDP8JsQCocxYAab7lfWT4T4wFQJ2zAEjzLO8hw3+CLADq + nAVAml95/xj+E2UBUOcsANK8ynvH8J8wC4A6ZwGQ5lPeN4b/xFkA1DkLgDSP8p4x/GfAAqDOWQCk6Zf3 + i+E/ExYAdc4CIE27vFcM/xmxAKhzFgBpuuV9YvjPjAVAnbMASNMs7xHDf4YsAOqcBUCaXnl/GP4zZQFQ + 5ywA0rTKe8PwnzELgDpnAZCmU94Xhv/MWQDUOQuANI3ynjD8sQCoexYAafzl/WD4c5kFQJ2zAEjjLu8F + w58vsgCocxYAabzlfWD48ygWAHXOAiCNs7wHDH+uYgFQ5ywA0vjK+Tf8aWUBUOcsANK4ytk3/DmVBUCd + swBI4ynn3vDnTBYAdc4CII2jnHnDn2uyAKhzFgBp+OW8G/50YgE4TCfxtLIqt1weosvy4uVJ+d6xyT3/ + +23PYiT+etvXNHg5Kzkz35YT9DU5Q0+Jqj5QUls554Y/nVkA9tN1+Un723ON/yLXeldcuvLaYQePLKvy + kXoZyxn7ppy11frIae7lbBj+bMUC0Ger8oLFqvx0ru++zeuFPbknZ+6N5aR8dXMKNcNyDgx/tmYB6KML + 5bn5SfjtbdcJB/JblxeBUm5eH0rNpTx7w59zsQDs1k25jn+W63lk8/rgSD6fM/n6nM2L6yOqKZfnbfhz + bhaA83axPHNZlf/Rdm1wdFV5b07pk9eHVVMsz9nwZycWgHNUVeUbcw13b14TDMyvlpPye5tjqwmVZ2v4 + szMLwJYtl+W78/oPb14PDNT9WVj/cHN8NYHyTA1/emEB2KZV+dq89uc3rwUG7l7/IaRplGdp+NMbC0D3 + nprX/eTmdcAoVOXOnOHHrY+yxlieo+FPrywA3bouP4H+Qtt1wFgsVuWdOcv+S4IjLM/P8Kd3FoAO5fVe + ufn6MEon5WXNsdZIynMz/NkLC8C1e0Je797N14eRuitn+svWR1tDL8/L8GdvLADXKK/zE22vDyP2g83x + 1oDLczL82SsLwNndnNfyu/6Zms/lbD92fcQ1xPKMDH/2zgJwRnmdV2++LkzCSXlpc8w1sPJ8DH8OwgJw + Rsuq/Pe214axW6zKv2uOuQZUno3hz8FYAE6v/tf/ra8NE/BAzvj166OuIZRnYvhzUBaAU8prvHzzNWFK + qqp8R3PcdeTyPAx/Ds4CcEqLVXlr2+vCVOQ99OPNcdcRy7Mw/DkKC8ApLavyvrbXhanIkvuW5rjrSOU5 + GP4cjQXglPIaH998TZiUqvzn5rjrCOUZGP4clQWgvUVe46HN14RJWf8FQTpCuf+GP0dnAWjvt7e9JkzM + /c151wHLfTf8GQQLQHuPbXtNmJh7m/OuA5V7bvgzGBaAU8prPLD5mjApVbmjOe46QLnnhj+DYgE4pfzk + +JG214WpWKzKf2yOu/Zc7rfhz+BYAE4pC8B72l4XpiILwJub4649lntt+DNIFoBTyk+O/6rtdWEq8h76 + O81x157KfTb8GSwLwCktl+XFba8LU1FV5Zub4649lHts+DNoFoDTe3xe5+HN14WJ+FzO+Gp91NV3ub+G + P4NnATij+jdJtb02jF39/+Jqjrl6LvfX8GcULABnlNf5S5uvC5OwLH+qOebqsdxbw5/RsACcXf0fBPrs + 5mvDyP1KzvZ16yOuvsp9NfwZFQvANcpr/cDma8OoLcufbo63eir31fBndCwA1+66vN4nNl8fRqkq78+Z + XqyPtvoo99XwZ5QsAB1anpSXtl0DjE1VlW9pjrV6KPfU8Ge0LADdWixW5ba264CxyHvm7zXnWT2Ue2r4 + M2oWgO7dsKzKB9quBYYuC+w7c4b9uf+eyj01/Bk9C8B2PT2v/anNa4FBq8r/ztl9/PoIa9dyTw1/JsEC + sG2rckte/zOb1wMD9fFyoTynOb3asdxPw5/JsACcp4vlGflV1YfargsGoyo/n9P6pPWh1a7lnhr+TIoF + 4PzduFiVf9t2bXBsOZtvzBm9uD6q2rXcU8OfybEA7NYy13JrfPrKa4Mj+nj9N1k251M9lHtq+DNJFoB+ + uinX87pc1/2b1wkHck/81ZxF/4nfHss9NfyZLAtAv/2OXNdrl1X5cNs1Q88u5ay9N//7ipy9x6yPoPoq + 99XwZ9IsAPvqQvnduc4fWKzKz9V/DCv/7N8OsKt7c5buyJm6Pf/8fTllT1kfNvVd7q/hz+RZAA7bYy7/ + kaxVuSW+bmxy31+9+RzGoqrKn2j7mkbga8vF8rtydq5fHyHtu5wXw59ZsACoc8tl+e62ZzEG9R/dbL4M + 6dRyVgx/ZsMCoM5ZADTlck4Mf2bFAqDOWQA01XJGDH9mxwKgzlkANMVyPgx/ZskCoM5ZADS1cjYMf2bL + AqDOWQA0pXIuDH9mzQKgzlkANJVyJgx/Zs8CoM5ZADSFch4MfwgLgDpnAdDYy1kw/KFhAVDnLAAaczkH + hj9cwQKgzlkANNZyBgx/2GABUOcsABpjef6GP7SwAKhzFgCNrTx7wx9OYQFQ5ywAGlN57oY/nMECoM5Z + ADSW8swNf7gGC4A6ZwHQGMrzNvyhAwuAOmcB0NDLszb8oSMLgDpnAdCQy3M2/GELFgB1zgKgoZZnbPjD + liwA6pwFQEMsz9fwh3OwAKhzFgANrTxbwx/OyQKgzlkANKTyXA1/2IEFQJ2zAGgo5Zka/rAjC4A6ZwHQ + EMrzNPyhBxYAdc4CoGOXZ2n4Q08sAOqcBUDHLM/R8IceWQDUOQuAjlWeoeEPPbMAqHMWAB2jPD/DH/bA + AqDOWQB06PLsDH/YEwuAOmcB0CHLczP8YY8sAOqcBUCHKs/M8Ic9swCocxYAHaI8L8MfDsACoM5ZALTv + 8qwMfzgQC4A6ZwHQPstzMvzhgCwA6pwFQPsqz8jwhwOzAKhzFgDtozwfwx+OwAKgzlkA1Hd5NoY/HIkF + QJ2zAKjP8lwMfzgiC4A6ZwFQX+WZGP5wZBYAdc4CoD7K8zD8YQAsAOqcBUC7lmdh+MNAWADUOQuAdinP + wfCHAbEAqHMWAJ23PAPDHwbGAqDOWQB0nnL/DX8YIAuAOmcB0Lbl3hv+MFAWAHUuC8B3tT2LMcjl37z+ + KnSoct8NfxgwC4A6V1XlD7U9izHI5d+4/ip0iHLPDX8YOAuAunehfGXbsxiBX2++Ah2g3G/DH0bAAqBt + emzbsxi8qvzP5vq153K/DX8YCQuAtir3/oHNZzF0i1V5V3P52mO514Y/jIgFQFuVX01/qO15DFnOyj9v + Ll97KvfZ8IeRsQBoq3Lf/27b8xiyqiovai5feyj32PCHEbIAaLtW5Za25zFgv5mrvmF98eq73F/DH0bK + AqBtW+T+37X5PIZqsSo/01y3ei731/CHEbMAaOty7/9h2zMZpJPy55rLVo/l3hr+MHIWAG3fxfKsPIOH + Np/JAP1qrva69UWrr3JfDX+YAAuAzlXu/z9oey6DclK+t7lc9VTuq+EPE2EB0Hl7Up7DfZvPZTCq8qFc + 43J9qeqj3FfDHybEAqBzl+fwNzefy1BUVfnW5jLVQ7mnhj9MjAVAu7RarMo7257PMeVs/Ehzfeqh3FPD + HybIAqBde9yyKne2PaNjyEJye67Jv/rvqdxTwx8mygKg3btQnpNncu/mMzq4qnw4V/Pb1helXcs9Nfxh + wiwA6qdV+f15Lp/efE4HU5VfylU8bX0x2rXcU8MfJs4CoD57egbxB9qe1z4tVuVteW3/ud+eyj01/GEG + LADquxszkN/e9sz2IefgtXnNxfqltWu5p4Y/zIQFQPtosVyW71lW5aNtz64XVXlvWZWvb15PPZT7avjD + jFgAtM8u5Fl9f9x95bPbSVXurKryJ5vPr57KvTX8YWYsADpENy1PyksWq3Jbnt39m8+yg3vyY/9l8/f6 + n6w/pfoq99fwhxmyAOjQfVkG+bfn+b0+Q/0t+RX9u+tf1eeZ1v9Z4f+bf74j3/5z8eZ8zA/nY1+YH1Ot + f6j6Lvfc8IeZsgBIMy3vI8MfZswCIM2wvIcMf5g5C4A0s/L+MfwBC4A0p/LeMfyByywA0kzK+8bwB77I + AiDNoLxnDH/gUSwA0sTL+8XwB65iAZAmXN4rhj/QygIgTbS8Twx/4FQWAGmC5T1i+ANnsgBIEyvvD8Mf + uCYLgDSh8t4w/IFOLADSRMr7wvAHOrMASBMo7wnDH9iKBUAaeXk/GP7A1iwA0ojLe8HwB87FAiCNtLwP + DH/g3CwA0gjLe8DwB3ZiAZBGVs6/4Q/szAIgjaicfcMf6IUFQBpJOfeGP9AbC4A0gnLmDX+gVxYAaeDl + vBv+QO8sANKAy1k3/IG9sABIAy3n3PAH9sYCIA2wnHHDH9grC4A0sHK+DX9g7ywA0oDK2Tb8gYOwAEgD + Kefa8AcOxgIgDaCcacMfOCgLgHTkcp4Nf+DgLADSEctZNvyBo7AASEcq59jwB47GAiAdoZxhwx84KguA + dOByfg1/4OgsANIBy9k1/IFBsABIByrn1vAHBsMCIB2gnFnDHxgUC4C053JeDX9gcCwA0h7LWTX8gUGy + AEh7KufU8AcGywIg7aGcUcMfGDQLgNRzOZ+GPzB4FgCpx3I2DX9gFCwAUk/lXBr+wGhYAKQeypk0/IFR + sQBIO5bzaPgDo2MBkHYoZ9HwB0bJAiCds5xDwx8YLQuAdI5yBg1/YNQsANKW5fwZ/sDoWQCkLcrZM/yB + SbAASB3LuTP8gcmwAEgdypkz/IFJsQBI1yjnzfAHJscCIJ1RzprhD0ySBUA6pZwzwx+YLAuA1FLOmOEP + TJoFQNoo58vwBybPAiBdUc6W4Q/MggVAasq5MvyB2bAASClnyvAHZsUCoNmX82T4A7NjAdCsy1ky/IFZ + sgBotuUcGf7AbFkANMtyhgx/YNYsAJpdOT+GPzB7FgDNqpwdwx8gLACaTTk3hj9AwwKgWZQzY/gfzn3L + qtwZ74Mt3JGzc+/GWWKPLACafDkvhv/+3JX34j+qqvLHyoXynNzum9Z3XTp315eL5Vk5Uy/M2frhLAa/ + 3HLu6IEFQJMuZ8Xw79+9ef/9aFmVr8stXqzvtLTHLpRn59z9YJaBj26cRXZgAdBkyzkx/Pv1+bzvfjy3 + 9vHrOywdvAs5h385PnPFueScLACaZDkjhn+PFqvy5tzWp6/vrnT0bsoMeG3O5oObZ5XuLACaXDkfhn9/ + HlqelJc1t1YaVqvy9Tmjn9o4s3RkAdCkytkw/PvzmfwE+weaWysNtZuXVXl/y/nlGiwAmkw5F4Z/X6py + Z7lYvry5tdLQu36xKre3nmVOZQHQJMqZMPz7c2/9u66bWyuNpRuyuP5Sy3nmFBYAjb6cB8O/P49UVfkj + za2VxtXF8oycYX9CoCMLgEZdzoLh36/vb26tNMqywH5jzvHDG+eaFhYAjbacA8O/R4tVeVdza6VRl/nw + o21nnEezAGiU5QwY/j0rq3JLc3ulsffYnOl7Ns84j2YB0OjK8zf8e5Zf/b+1ub3SJMq5/iub55xHswBo + VOXZG/79e6T5i3ykKXVhWZWPtZx3GhYAjaY8d8N/D/Kr/3/f3GJpUuV8+znjDBYAjaI8c2/k/fm+5jZL + 0+pC+cqW807DAqDBl+dt+O/PpdziJ6/vtDS96v+qZcu5JywAGnR51ob/PlXl55tbLU2yzIrXt559LAAa + bnnOhv+e5X30t5rbLU2yqirf2nb2sQBooOUZG/6HcFJe2txyaZqdlK9qPftYADS88nwN/wPJr47+aHPb + pan2uLazjwVAAyvP1vA/oPzq6HnNrZcmW876b26efSwAGlB5rob/geW2P3F996XptqzKR9vO/9xZADSI + 8kwN/yPIrX/C+glI080fBWxnAdDRy/M0/I+knJSvbh6DNNly1u/bPPtYAHTk8iwN/yOqqvItzaOQptpN + bWcfC4COWJ6j4X9sy/Li5nFI0+xCeXbr2ccCoOOUZ2j4D8Mrm0ciTbKqKt/ccu4JC4AOXp6f4T8Qi1V5 + R/NYpEmWWfGatrOPBUAHLs/O8B+Wh/JYHrN+OtL0WlblAy3nnrAA6GDluRn+Q7Qs39M8ImlaXSzPaD3z + XGYB0EHKMzP8B2qxKj/dPCZpUuV8v3zzvPMlFgDtvTwvw3/YHshjesr6aUmTabmsygdbzjsNC4D2Wp6V + 4T8CeT/90+aRSZOo/iOubWedL7EAaG/lORn+4/Fw/eelm0cnjb3rcqY/vnHG2WAB0F7KMzL8R2axKm9t + Hp806nKeX7F5vrmaBUC9l+dj+I/VsnxX8xilcXZSvipn+devOttcxQKgXsuzMfzH7f78BPp7mscpja0n + LKvykZZzTQsLgHorz8Xwn4aP53E+cf1UpdF0kuH/n1rOM6ewAKiX8kwM/ympyn/JY71p/XSlwVctVuWN + rWeZU1kAtHN5Hob/FFXll8vF8qzmMUtD7bEZ/v+h9QxzJguAdirPwvCftnuqqnxT87ilYVX/Vb9V+V8t + 55YOLAA6d3kOhv88PByvziO/fv3kpaNXLU/KS3MuP3fFOWVLFgCdqzwDw39+7spPui/L46/Wp0A6fFVV + vi2/6v9wy/lkSxYAbV3uv+E/Z1W5I4vAn81ReML6REh77/oM/hfl7L279UxyLhYAbVXuveHPFzyyWJV3 + 5X9fXi6WZ+Z4+DcD6qtFPHm5LH8mZ+y2nLEHrjh39MQCoM7lvhv+nOWR+GR+lfaL+Un79vqPZcEWbsvZ + eV/O0K/EQ82ZYo8sAOpU7rnhDzAhFgBds9xvwx9gYiwAOrPca8MfYIIsADq13GfDH2CiLABqLffY8AeY + MAuArir31/AHmDgLgB5V7q3hDzADFgB9sdxXwx9gJiwAulzuqeEPMCMWABn+ADNkAZh5uZeGP8AMWQBm + XO6j4Q8wUxaAmZZ7aPgDzJgFYIbl/hn+ADNnAZhZuXeGPwAWgDmV+2b4A3CZBWAm5Z4Z/gB8kQVgBuV+ + Gf4APIoFYOLlXhn+AFzFAjDhcp8MfwBaWQAmWu6R4Q/AqSwAEyz3x/AH4EwWgImVe2P4A3BNFoAJlfti + +APQiQVgIuWeGP4AdGYBmEC5H4Y/AFuxAIy83AvDH4CtWQBGXO6D4Q/AuVgARlrugeEPwLlZAEZYvn7D + H4CdWABGVr52wx+AnVkARlS+bsMfgF5YAEZSvmbDH4DeWABGUL5ewx+AXlkABl6+VsMfgN5ZAAZcvk7D + H4C9sAAMtHyNhj8Ae2MBGGD5+gx/APbKAjCw8rUZ/gDsnQVgQOXrMvwBOAgLwEDK12T4A3AwFoABlK/H + 8AfgoCwARy5fi+EPwMFZAI5Yvg7DH4CjsAAcqXwNhj8AR2MBOEK5fsMfgKOyABy4XLvhD8DRWQAOWK7b + 8AdgECwAByrXbPgDMBgWgAOU6zX8ARgUC8Cey7Ua/gAMjgVgj+U6DX8ABskCsKdyjYY/AINlAdhDuT7D + H4BBswD0XK7N8Adg8CwAPZbrMvwBGAULQE/lmgx/AEbDAtBDuR7DH4BRsQDsWK7F8AdgdCwAO5TrMPwB + GCULwDnLNRj+AIyWBeAc5fUNfwBGzQKwZXltwx+A0bMAbFFe1/AHYBIsAB3Laxr+AEyGBaBDeT3DH4BJ + sQBco7yW4Q/A5FgAziivY/gDMEkWgFPKaxj+AEyWBaClfH7DH4BJswBslM9t+AMweRaAK8rnNfwBmAUL + QFM+p+EPwGxYAFI+n+EPwKzMfgHI5zL8AZidWS8A+TyGPwCzNNsFIJ/D8Adgtma5AOTHG/4AzNrsFoD8 + WMMfgNmb1QKQH2f4A0DMZgHIjzH8AaAxiwUgH2/4A8AVJr8A5GMNfwDYMOkFIB9n+ANAi8kuAPkYwx8A + TjHJBSDfb/gDwBkmtwDk+wx/ALiGSS0A+XbDHwA6mMwCkG8z/AGgo0ksAPm/DX8A2MLoF4D8s+EPAFsa + 9QKQ/zX8AeAcRrsAxK+1fBsA0MGYFwAA4JwsAAAwQxYAAJghCwAAzJAFAABmyAIAADNkAQCAGbIAAMAM + WQAAYIYsAAAwQxYAAJghCwAAzJAFAABmyAIAADNkAQCAGbIAAMAMWQAAYIYsAAAwQxYAAJghCwAAzJAF + AABmyAIAADNkAQCAGaoXgLs3vxEAmLS7y7IqH2z5DgBgqjL7y2JV3tH6nQDAJNWzvyyq8lNt3wkATFM9 + ++vfA/Cqze8AACbtVaWclOe1fAcAMFH17C91y6p8rO0DAICJycy/PPzrFlV5Q+sHAQCTUs/8ZvynVfmG + tg8CAKalnvnN9F+3rMp72j4QAJiIzPpm7F/Rqryg9YMBgEmoZ30z9R/dYlXe3vYDAIBxq2d8M+5bulCe + mw96cPMHAQCj9mA945tp397ypLyk5QcCAGOV2d6M+bNbVOXHWj8BADAq9UxvxnunlotVub3tEwEA41DP + 8nqmr0d7927ID3xb2ycEAIatnuH1LF+P9O1bLKrymnyiS5ufGAAYpEv17K5n+HqU71BVle/MJ7x/4wUA + gGG5v57ZzfjurZsXq/KmfHL/NgAAhuVSPaPrWb0e2fvopDwvL/KzLS8OABxYPZO/+Nf7HqRVef6iKq9b + VuVDbRcEAOxJZm89g+tZ3EzlI3WxPDMXdGsu5g3ZRN6SC3t33Jlv+2zcCwBs7bOXZ2lmaj1b6xmbb7u1 + nrnN9N2hUv4/EMWsacbspPkAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAABGdBTUEAALGPC/xhBQAADRhJREFUeF7t + nX+wVVUVx3kPBO578C7vPehFP51JR9Qpx8YCpR9iWjH+CGE0MxhtmKKxH2KZSugfOtMPajK1H0ZaGQbk + pKENVJoaMWLiAMHQFJSpjZWShTkRAuGrz+KtYe7bb91z9rnv3vvOvmd/Z75z4L691tl7rXX2Ofv3qIiI + iIjCol2vEQVBW1dX17snTpy4prOz859c/8f1xQkTJtwPL+DvMSBaFb29vfh74j3i9ASuJyD6VCSihVDC + sRsNhw8h6XZRG0xWuYhWAA692XJ2AteoaETo6O7ufh0OPeQ42IfTVUVEyMCRVzqO9aLUGqoiImTgyB9Y + DvbgBlURETJwZNqXv0kCZ7OqiAgZOPKrloM9eK+qiAgZOHK241hfXqEqIgLHaJz5W8e5iezs7NxLzTFF + 5SNCB06dDg9WOjmFn1TRiFYBT/QcHPuS4+ghJN2NJG8bkIpoKVC1n4iTH3SdLuRvT8ILNWlEKwOHH8uT + vhBeAy/j/6fycxwJbASkK7arq+s9UgV3dHSczE/R0FVQKpVeQzCeja0u0KAcN/CX8NBGAc6hIJu5utXt + XwmIj5NmzEDSCF49Z8Iho5X89gLX60kyfiBlGDiKTN9aWZAq/DFpg43wOqEdJ3/JsM0gkubRnp6eLpXJ + Ndp56ldZhajCHyJT1C9uqSW/5dgjiQ8hk+9aE+cvMjKeSF4HH1TxQoGn+kLLHin8tIrnEu1k8Bknw6nE + EDuRLVwtQNm3u7bw4POIjh3QkDPwhX+SkWEvEgQnqppCgK/9V1t28CG2epeqyReo/t9nZdiHUh2qmkIA + W8207ODJfHZT8y5/r5FZXy5QNYUAtnqrYQNffkbV5AvlcvloI7Ne5Il4u6opBLq7u8uU+2XXDj7EVrJ+ + IZ8gg9vcDKeR6n8PooXrD6Dsv3Bt4cGDBEB+p6yTublGphOJzFIVbyaOohrukW5q7arukd8G/tQcEPin + W/ZIIrb6mornFm0U7HtW5qtQOjca1qzR1UAyI+gGeBfcRv72crXyIrWR/E1qMUl7PZw9ZcqUCaqu7sCh + WaarbW1kXuqJcRRsnVGAQZRAmTp1aofK1A3jx49/Lfdfgn7pW/+ve98aKDoeQefV0nzT29QLMlvpGxX3 + Msm9t3DtVZkgMJpq9RM44SmnMPvgPRTobZquXhjNvaRnTcb6+/VejWA/eX8AzuOedRvVRO+5cGvFfQ5T + a6RljXhQmoU2eSKl2YPRpvH/elf3MvB0CYbaVWm4JvF3cD55qFv/PPpknsI8rgso06yQHd9wYCD5iBIn + WM5pJnc0oEaLqAaMPRneaThiREme7tDWRESjIE8axv6La/y8kPz9mesMzW5EHdGGca/CuLWs8m02pdUg + i0rizOI6QZpK36wwcBAkYG8h73H+4zAxDmP+yDVuQFxNGfI5fh8A5MkP2fmHSU2wirLEmiAjZL6cz8TS + IEgQ3CRlGihaRCr0g880ZsC8XIsXkQScL029EL72s/Kg9IhqMSMs4PzJGCq37fzhkvI9XS6Xu7W4ES4w + UO56+BrA27W4EZXQvn3LYK3I07TYEQoZ1cvDwE6zuJ0yjx4oeoQMg17iGKjlSY13kRa/8JDJHCMxnj/S + 3EHZYwcRH36yFt4yUMuTss9RMxQXGMLcsqUIJADWqRmKCZkuhiEaOYcv7zzU0dHxSjVH8cATsMQwStFY + 3A0p+fjzOsShxfmwmqNY0EUb9Zi3Hzr3Y47SgFVyBj1s4UqqatlyXebzy0qW2fxp2J0YogdaBikcqQnP + ULPUCpkyJ4NoX4Qyh2I1/78WHq9/z4wSwnLMSrVROdl7d1gnaiAvy7Us3YUjtq55fSTyx8FHKvVVEt0r + M81WlqqZiHzUUuZQVqrW3I5FXtbfWXoLR+y4Qs2SCcjOwFf/cvW5lI62Uqn0KhVLhMzEyXLAwksor2l7 + F2QzLyVvVRIAj6tZvEHzcSqyz7u6qhE/bUIseRUTVYUcqmgqSOCDKp4JZKjqKt2iEVvIHgmZgMx3LV1J + JNAWqbgNEq1xhTx5rKrwhYz+WXqKyn5s4j1nUHcYOeDo8OE2VWGDqDp8nGpWElkLVYUX5KPE0lNkZln7 + j/3OsnT4UIJH1QyB7PNnCqWRAFiiOrygzUtTV1Ep73Q1TyoIgA9YOjxZvbamBnjREEglGZLNn70RA2Ao + swQA6WvuQ0kce+BJvt8SSiNy71QVXvB5BRCM/4ZrW4HY5z9WGSuZ5RWAPpk8W8suY7LTaPVvDRTXMjb/ + d0SzbrDk8xH4rKYNHgTBP4zyVTLTR6AAmbsdHT78topXhXwHrHeE0rhYZTMBo6Q1A8Uowa+r6+vr6zTK + NojYInMzkFr0GA8bVnK/yKh4daC0D3pN0SLdfYjUNC6AfGpHEDXSCZo8WPDOPdkqWyWxo3TSZAaysreQ + 72loH1KxdOg7JqlP4GXSyOlaNT+h6PDpCr5UkwcL7PRRo1yDSJqauoIFyM4kgJ6w9Cp3k2auJs8GhKcj + LINCG7hugevgdVQlb9AkNQOdsg+fleFKpr6z8g7stcIo1yCSZribZY7FJxejZyV8nIB4jOsquDC3ewtS + cJ+mzN9IGvLM2TE4I+0DUF4Bwx0ODg8SmRTeZ0KInJ4VJHCsz2onmRAS1KFQdQOFrzqOXcHbNHlwoAr2 + Weso2+UWExjoasMgLvdJx5GKBAOe/leQd58Bm5qa0S0BPSjRZ1r4DSoSDMjzMqcMFg9JoKhIMUEt8IBh + mEHESHthn4rkHhrYqQdVU6a1KlJcEACyN65poEqS7vsqknuQX9/pbuepSKEh3c++S8PPVpncgkD1PTRD + lojHjaMEGGO+Y5xqfK4Be/bXDZMmTXo91Xpqu19IoOT37J8RwBiMssM1kkUM/Bjpc9dulq3dyd+QPf+r + cCsicYOISvBEyMIGy1gW70WkqWf8pGAs+U89JUUprZ5hraloWWDEOxxjJfEuRPIwXCzb2WaZSr9c5SJc + SIcPQSBbrluGs/hQuVyepOJNh+SXPPzKyVNV8vr600jmNwhgqFOh96JRjLpLxtxVvGnA+adw7z9aeapC + 2SjyFBWPSALG+pRjvDQeoOa4CtFmfBfI+/6z3DPTymaC5WMqH+EBWe16i2XIFP4eyurlRrSvZdncOVLj + VNzPi5Tly6ojIgOkg2i1a0wfYvDNOOr96KjHkbTjqbplHv5v3Pv4kLzIbJ+4G1iNkOp2lWVYHxIEL3C9 + DR3nyweb6kwFMr3IzEX+OzB19W01ouNO1OWpuRok2jGkTEszjZyB/ThzJ7wPfV+B1/Hb5UL5t/zG334C + pYof9sZV6JNqPz75dYK8f8VZIWwpc4Agih98jQDGlUmqTzsGzw1x/JOxqddgyH77GPt21/gjTHllLI+d + PE0EBj8NblcHjCRlACj27bugqp4Gb4Ry9PlzUE4CWc//l/ruV+MB2Wj6IvTKplWWcxrJ7ZRFhnTrMarX + RjlmofNWrrJ34laua7kuDrFWkfa77ACWtHp1vwQCaes1JCothTlQRuQaed6QzOETx8hMnrp84cscAvT9 + suIeg8j9ZNOOczV57iFf68srC5DCr6tc3SDr39F7BXwY7tf7DIeiQza0Xowz6jqBE31vRK/UjtZ9KylL + 8c5XsfyCjNZy8EMjo7uEkc+Q2gaugLJsag/3tNr50k+wB27StEtFFh0NmXyCbpk2/qyThyTuI0/TVDyX + aKdQTxkZT6PMjmk22mVlkuzKIdT1c03ttKHcmQ/GJAB+quL5A85/k5VpT2bdZSx0jMNeNW2TJ9vrqI58 + gej0nQ07hMjOUzWFALXOSZYdPDlf1eQLOHGOkVlfLlA1hQC2eodhAy8iK/Me8gcydoKVYR9SHc5SNYUA + ZZYNnk1bpBE7X6ZqcgfpzEjaqcKkvAtlSrXqKAqkr2S3awtPzlAd+QPR+WEjw2lcpuKFAuX+vGOHVPKw + 7EQ010PM0iP3cyvzFkm7pYBP/2Hofr/PuDZJYH9XV9dZKp5f9PT0dBGpvzYKMIg4/2dZZum0Isrl8pux + lc/+zP3Y6yMqFgRKZPpzFG7I1rP8tpHCSLMvLowEupRc5j6aYyfYaxc8U5MHh3E85W+hIOdRiNNx/BT9 + PcKBjJBip0vhF7DTTfAaKFvwxjWE9Ya8f+V9CmW272wMPVn/FNHKkH5/aiI5acPdu0eq37sJiPStVCPC + BA6eARPP2CE4pH8+mLH3CE/g1ONwru/8fjkNbaaKRrQAZJKKz36ER0iwPIFc8DuVRwCe5iwbTxwh3wMX + q4qIkIEz5ThV08lJJHBWqoqIkIEz5Sxd08lJJAAyH+YYkUPgzJpWGPMdsFFVRIQMnuRrLQd7MPizCiIA + AXC84dxUSk+hqogIHfJBZzk5gRsQi4NVrQKe5h7e6b5bu+wul8tHq2hEq0BG2wiCTYbDj1CChNoi14sv + IoaHMTh4Ec4edGQdjv8Dv8ts29JAsoiWhw4JH0MA9OpPERERERERxcGoUf8HO5JaWO28llwAAAAASUVO + RK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAmXJJREFUeF7t + /QeYbNlV3o1bMIQBhHJEQiMGARrEjDT3dt+u6r63WzMSGhNE0pBMEFgmI4IBm2QwYIIJHxiQwPaHSUaY + ZEDGiIz+gD7JmCgjQIBQAAVAOc1ImvF//Zp3t06dPmHv1buqTnWt93nWc6enzu/de699aq9dp6vP+Seh + UCgUCoVCxXrMY47uYvEOjbiLXnIp/MKvROEXfiUKv/Ar0bb5Fckae8d26CWXwi/8ShR+4Vei8Au/Em2b + X7asIXYdV1m8UyP42bX7gBMffg7BiQ8/h+DEh59DcOLDzyE48eHnEJz48Fu2aEQNvnMj+Pksgwm/8MsS + nPjwcwhOfPg5BCc+/ByCEx9+DsGJr+JXJBqxeBeLd20EP59lMOEXflmCEx9+DsGJDz+H4MSHn0Nw4sPP + ITjxVfyKRCNq8OpG8PNZBhN+4ZclOPHh5xCc+PBzCE58+DkEJz78HIITX8UPZbN2IN8ufDeLd28EP7+D + DikSnPjwcwhOfPg5BCc+/ByCEx9+DsGJDz+H4MSHn0PGsZngS4PjPAdZ0OB7NIKfzzKY8Au/LMGJDz+H + 4MSHn0Nw4sPPITjx4ecQnPhafhR/vjA4vgHgAAsae89G0IGzDAY+/ByCEx9+DsGJDz+H4MSHn0Nw4sPP + ITjx4eeQcRR/vjBIDG8AdDCXGVIH7qZ/zzKY5JMi/DIFJz78HIITH34OwYkPP4fgxIefQ3Diw88h46jn + fGEw/dUAG4Du7wDwggVfMEiXHmh4SoMJv/DLFpz48HMITnz4OQQnPvwcghMffg7BWVDPiZMNgF5elL2Q + dgp8y7D5u4dIdobgxIefQ3Diw88hOPHh5xCc+PBzCE58+DkEJ76mH1fy018NsAG4Si8vyl5IvyPgwLQB + OMsXDmLywi9bcOLDzyE48eHnEJz48HMITnz4OQQnvqZfquFpA0B97730z7cD2SGkDcBZ/3Rh6skJv/DL + Epz48HMITnz4OQQnPvwcghO/TX7p6n3aAPTfNMhe4EsB7A7SBoCIZGcITnz4OQQnPvwcghMffg7BiQ8/ + h+DEh59DcBbw+KSo4UekDQD1fPBLf80NgPv2gsbF5IVftuDEh59DcOLDzyE48eHnEJz48HMITvwy/PiX + DQBX8vvrub0IlDYA/b8jGJF8ljWY8CsUnPjwcwhOfPg5BCc+/ByCEx9+DsGJ31Y//nv8O3wcYMEG4CyP + KNz2ZIdfgeDEh59DcOLDzyE48eHnEJz48HMITvwy/fL+eo+DLPpvDDAi8ZuWnPDLFJz48HMITnz4OQQn + PvwcghMffg7BiT+ffnagq/AjGlFjvsZbghMffg7BiQ8/h+DEh59DcOLDzyE48eHnEJz48Fu2aESNVWkc + Tnz4OQQnPvwcghMffg7BiQ8/h+DEh59DcOLDb9miETVWpXE48eHnEJz48HMITnz4OQQnPvwcghMffg7B + iQ+/ZYtG1FiVxuHEh59DcOLDzyE48eHnEJz48HMITnz4OQQnPvyWLRpRY1UahxMffg7BiQ8/h+DEh59D + cOLDzyE48eHnEJz48Fu2aESNVWkcTnz4OQQnPvwcghMffg7BiQ8/h+DEh59DcOLDb9miETVWpXE48eHn + EJz48HMITnz4OQQnPvwcghMffg7BiQ8/p4zN++s/GlFjVRqHEx9+DsGJDz+H4MSHn0Nw4sPPITjx4ecQ + nPjwc8i4dOv/cZ6DLLijUK3GY/LCL1tw4sPPITjx4ecQnPjwcwhOfPg5BCe+lh/Fnzv+jm8AOMCCewk3 + OzClwYRf+GULTnz4OQQnPvwcghMffg7BiQ8/h4yj+Kfn/QxvAHQwTxHi03/qxJQGE37hly048eHnEJz4 + 8HMITnz4OQQnPvwcMo56zlN+edpv2gB0fweAFyx4fjCf/tMGYEqDCb/wyxac+PBzCE58+DkEJz78HIIT + H34OwVlQz4mTDYBeXpS9kHYKV1ukDUDeU4U6BGdB5xlEipi8TMGJDz+H4MSHn0Nw4sPPITjx4ecQnPjw + cwjOgiv51PO0AbhKLy/KXki/I+DAtAEYf55wj+Aspp6c8Au/LMGJDz+H4MSHn0Nw4sPPITjx2+SXanja + AFDfey/98+1AdghpA8DOIZKdITjx4ecQnPjwcwhOfPg5BCc+/ByCEx9+DsGJr+mXrt6nDQBX9nuLP18K + YHeQNgBEJDtDcOLDzyE48eHnEJz48HMITnz4OQQnPvwcghNf249IGwDq+eCX/pobgP6dwoiMi8kLv2zB + iQ8/h+DEh59DcOLDzyE48eHnEJz4ZfjxLxsAruT313N7EShtAPp/RzAi+SxrMOFXKDjx4ecQnPjwcwhO + fPg5BCc+/ByCE7+tfvz3+Hf4OMCCDQDfAYjinyE48eHnEJz48HMITnz4OQQnPvwcghMffg7BiV+mX95f + 73GQRf+NAUYkftOSE36ZghMffg7BiQ8/h+DEh59DcOLDzyE48efTzw50FX5EI2rM13hLcOLDzyE48eHn + EJz48HMITnz4OQQnPvwcghMffssWjaixKo3DiQ8/h+DEh59DcOLDzyE48eHnEJz48HMITnz4LVs0osaq + NA4nPvwcghMffg7BiQ8/h+DEh59DcOLDzyE48eG3bNGIGqvSOJz48HMITnz4OQQnPvwcghMffg7BiQ8/ + h+DEh9+yRSNqrErjcOLDzyE48eHnEJz48HMITnz4OQQnPvwcghMffssWjaixKo3DiQ8/h+DEh59DcOLD + zyE48eHnEJz48HMITnz4LVs0osaqNA4nPvwcghMffg7BiQ8/h+DEh59DcOLDzyE48eHnlLF5f/1HI2qs + SuNw4sPPITjx4ecQnPjwcwhOfPg5BCe+xO8ut956K89wP7Vow4kv8esVnPjwcwjOAh6fFFPyS7f+H+fV + OHcUmupgwi/8sgUnPvwcghMffg7BwR8dHdx9Ntt7xHw+/wj798mXLl36Rosftvil3d3d39/Z2XmhxSvt + v2+z/3enxf9txB0Wb7TXX2Hx/L29vedY/ILFD5jX18/nsyddurQ7Pzg4uIeazVbqn0XV8con/AoFJ76W + H8WfO/6ObwA4wIJ7CTc7MKXBhF/4ZQtOfPg5BCc+/Mr0DlacP8iK9mdQpK2o/679+0aL/7u3t1DYiwP+ + H31SnDrmZdber9i/32rxcRbXqE+nxLg0vrOO91hw4sPPITjxtfwo/ul5P8MbAB3MU4T49J86MaXBhF/4 + ZQtOfPg5BCc+/DJkn8w/0ArvF1rBfbrFayxyinVRnMHvpda3/2Z9/Czj3pf+Mi6NzzXetuDEh59DcOJr + +VHPecovT/tNG4Du7wDwggXPD+bTf9oATGkw4Rd+2YITH34OwYkPvx7x+3krqDdbYf1e+/eF7aI7oeJ/ + KqzPf2n/PnU22/vwm28+ulfOeIcEJz47f0OCEx9+DsFZUM+Jkw2AXl6UvZB2CldbpA1A3lOFOgRnMfXk + hF/4ZQlOfPg5BCf+XPjNZrM5xdPi71NBbceUiz/R8nulxQ/ZpuAxNrziHJIn5Ssrf2OCEx9+DsFZcCWf + ep42AFfp5UXZC+l3BByYNgDjzxPuEZzF1JMTfuGXJTjx4ecQnPiN9js4OLiPFcgv5Qt4XQW1GRtW/Nt+ + L7H4d/P5/FoNfVDkSfkazF+u4MSHn0NwFqmGpw0A9b330j/fDmSHkDYA7Bwi2RmCEx9+DsGJDz+H4MSH + n0Nw4nv97NP+o6wg/pDF7SqQg7HiYl0cBX532mbnl23T8xGWhs78kiflqzd/JYITH34OwVmkq/dpA8CV + /d7iz5cC2B2kDQARyc4QnPjwcwhOfPg5BCc+/ByCE9/pZ8XxMVYEf61VFAdjjcU6K87g9wKLL7j++uvf + /Th5JvKkfHXmr1Rw4sPPITjxRNoAUM8Hv/TX3AD07xRGZFxMXvhlC058+DkEJz78HIITf8rPPvF+sH3y + fXarAI7GhIp1Z9Tws7xwj4KvuXz5gC8NrmQ+dEiR4MRvox//sgHgSn5/PbcXgdIGoP93BCOSz7IGE36F + ghMffg7BiQ8/h+DEb5SfFbiZFbffbBe9nJhisW5Gfb+911p8y5Ur+w9K+bOI8y9DcOKX5cd/j3+HjwMs + 2ADwHYAo/hmCEx9+DsGJDz+H4MSHn0Nw4k/8ZrNL19kn2x+3wta+815WTL9YL9WPvx74ikc96pHvqhQX + qWs+9HOczxmCE9/0y/vrPQ6y6L8xwIjEb1pywi9TcOLDzyE48eHnEJz4pfg99rE33deK19db8X9TV6HL + iQ0r1sv0+yuLj1Gqs9SeD8VkzxfF+fGzA12FH9GIGvM13hKc+PBzCE58+DkEJz78HIITvxF+8/nsQ3f/ + 8UY4CwWuJFZYXF2xJr9fnc1mH6C096o9H4rJni+Kc+tXJBpRY1UahxMffg7BiQ8/h+DEh59DcOIn78fv + rK1I/aAVL9fl/hRrKq7ZsWa/221z9Q2Hh4edvxZozkcjJnm+NOLc+hWJRtRYlcbhxIefQ3Diw88hOPHh + 5xCc+Mn76VP/ize8uI7GhPz+3PJ9WVNxrOZ8NGKS50sjzq1fkWhEjVVpHE58+DkEJz78HIITH34OwYmf + tN/R0eV7W+H6Los7z1Fx7YwJ+nGl5XsODw+Pv5im+aw6v/IJv2WKRixojEZTRLIzBSc+/ByCEx9+DsGJ + 3yq//f35B9mnUB7D6yleCzHB4roQE/d7gfG3aF6rza98wm+ZohE1VqVxOPHh5xCc+PBzCE58+DkEJ37S + frPZ7AlW/F89wWK4rX532H9/N399UWN+LaqeL/I5935FohE1VqVxOPHh5xCc+PBzCE58+DkEJ36yfkdH + B3ezYvPvKDgVi1cjuo/LjW33s03Zcy9d2n2EpqxIzK/Oj2rni/it8EPG5v31H42osSqNw4kPP4fgxIef + Q3Diw88hOPGT9Ts8vHxfKzo/s6ziFX5l0efHvRcsPktTlyXmV+dHtfNF/Lb4pVv/j/McZMEXN2o1HpMX + ftmCEx9+DsGJ3xq/g4P5tVZkfq9dbLyxqmLojfPgt7u7++Pz+fyumsZeMb86P6qdL+K3xY/izx1/xzcA + HGDBvYSbHZjSYMIv/LIFJz78HIITP1m//f35o6zIvHCo2JTEOophSZwzvz+/ePFi768EmF+dH9XOF/Hb + 4kfxT8/7Gd4A6GCeIsSn/9SJKQ0m/MIvW3Diw88hOPGT9ZvPZ1esyPxDZrEZjTUXw9E4p35v2N3dvVXT + eiLmV+dHtfNF/Lb4Uc95yi9P+00bgO7vAPCCBc8P5tN/2gBMaTDhF37ZghMffg7BiZ+s32y29zgrMq8r + LDa9MZFi2Bvn3c82Ad9sU3t8PjC/Oj+qnS/it8mPek6cbAD08qLshbRTuNoibQCOb96gQ4oEZzH15IRf + +GUJTnz4OQQnvpqfFZcPtyLzJm+xacdZi1c7wq/7uIz42aOjQ86NSZ9/4qfsx5V86nnaAFyllxdlL6Tf + EXBg2gCMP0+4R3AWU09O+IVfluDEh59DcOKr+c3ns8fbp8U3T7B4HUf4dR+XG+bx3P39+XW1zhfx1c4/ + 8VP2SzU8bQCo772X/vl2IDuEtAFg5xDJzhCc+PBzCE58+DkEJ35r/GazPe7pH8XfGZviZ3P8UtsEzM96 + voivdv6Jn7JfunqfNgBc2e8t/nwpgN1B2gAQkewMwYkPP4fgxIefQ3Dit8bPPvnfZIXhDbWLTfj5Yvl+ + e6+1eLROgSJxvuh8q3b+iZ+6H5E2ANTzwS/9NTcA/TuFERm3rckOP4fgxIefQ3Dit8bPPvlb7U+39l1G + sek+LjfCr/u43Ojz29nZ4WrPh+tUyBLni863auef+E3w4182AFzJ76/n9iJQ2gD0/45gRPJZ1mDCr1Bw + 4sPPITjx4ecQnPhqfvv7sw+wIvC37eLgjVUVL2+E3+Lrtgl4q8Un6pQYFOeLzrdq55/4TfHjv8e/w8cB + FmwA+A5AFP8MwYkPP4fgxIefQ3Dit8bv8uX997Ki8Ly+4lAaqy5epRF+3cdZ3GGbgE/VqdEpzhedb9XO + P/Gb5Jf313scZNF/Y4ARid+05IRfpuDEh59DcOLDzyG4xz3uMfewhf9X1lBssiL8uo/LDYcfTxR8ok6R + BXG+6Hyrdv6JP59+dqCr8CMasYhkh1+W4MSHn0Nw4rfK79Kl3aeusdgMRvh1H5cbZ/C7Y3d39xN0qhwr + nS8WVc8/+Zx7vyLRiBqr0jic+PBzCE58+DkEJz78HIITX9VvNtv7nAkUm84Iv+7jcuOsfnwnwDYBH9E8 + Xyyqnn/yOfd+RaIRNValcTjx4ecQnPjwcwhOfPg5BCe+qp8V/yNb6G+bQrFpR/h1H5cbtfz464Dd3Z0j + nW9Vzz/5nHu/ItGIGqvSOJz48HMITnz4OQQnPvwcghNf1e/gYP5QKwx/M6VikyL8uo/Ljfp+e6/VzYIm + ez7LZ3J+RaIRNValcTjx4ecQnPjwcwhOfPg5BCe+qt/R0cHdbVF/Rp3iMPXiFX5dx+VGw+9vZrO9969x + /llUPZ/lMzm/ItGIGqvSOJz48HMITnz4OQQnPvwcghNf3c8W8q+sXBwU3cflRvh1H5cby/fb+4Pd3Z33 + 0ClVpOb514hJvj8a4fYrEo2osSqNw4kPP4fgxIefQ3Diw88hOPHV/Q4O9i/bQv6W6Reb7uNyI/y6j8uN + Pr+dnZ2n6bTKVvP8a8Qk3x+NcPshY/P++o9G1FiVxuHEh59DcOLDzyE48eHnEJz46n5HR5fvv7u7+2eb + Umy8EX7dx+XGmJ+dQ1+m02tUzfOvEZN8fzTiLH7p1v/jPAdZcEehWo1vW7LDL/yyBSd+K/3+8e/9Fxfz + 0lh1sSmN8Os+Ljdy/HZ2dt5mrx3qNOtV+/xTTPb9oTiLH8WfO/6ObwA4wIJ7CTc7MKXBhF/4ZQtOfPg5 + BCd+KX6z2d4/tcX8zvZiXhLrKDYlEX7dx+VGod/LLO6n0+2U2uefYrLvD8VZ/Cj+6Xk/wxsAHcxThPj0 + nzoxpcGEX/hlC058+DkEJ34pfrr0/1etBbwo1lxsRiP8uo/LDY+fnVO/aKfbqd91t88/xWTfH4qz+FHP + ecovT/tNG4Du7wDwggXPD+bTf9oATGkw4Rd+2YITH34OwYlfmp8t1t/dXrxLYgrFZijCr/u43Dij35N1 + 6h2r6/zTz+f5/UY9J042AHp5UfZC2ilcbZE2AHlPFeoQnMXUkxN+4ZclOPHh5xCc+BO//f35o/mdbcfC + nRUTKzanIvy6j8uNs/pxp8CLFy++f9/5p5/P8/uNK/nU87QBuEovL8peSL8j4MC0ARh/nnCP4Cymnpzw + C78swYkPP4fgxJ/4HR1dvqct0s9tL9q5MbVi047w6z4uN2r57e7u/s611z6UL79t1PtDP5/FL9XwtAGg + vvde+idB7BDSBoCdw3lOTviFX5bgxIefQ3DiF/xsYf7argU7J6ZabFKEX/dxuVHbbzbb+7L2+Wdxnt9v + 6ep92gBwZb+3+POlAHYHaQNAnOfkhF/4ZQlOfPg5BCd+wW9nZ+d6W5hvby/UOTH1YhN+3cflxpL8Xnfl + ysEHpPPP4ry/34i0AaCeD37pr7kB6N8pjMi4TUlO+DkEJz78HIITv9V+XI61T//PaS/8ObEhxSb8nLFM + Pzvnfkrn4za83/iXDQBX8vvrub0IlDYA/b8jGJF8ljWY8CsUnPjwcwhOfPg5BCf+lJ8tzF/cXqhzYpOK + TfiVxyr87N/LOkWLxHmr8/fU+axDigQnfll+/Pf4d/g4wIINAN8BiOKfITjx4ecQnPjwcwhO/Mb5zefz + a21xfmN7sR6LVRSHruNyI/y6j8uNFfr9rp2iRXWO81bn76nzWYcUCU78Mv3y/nqPgyz6bwwwIvGblpzw + yxSc+PBzCE58+JlsAf71tEjnxgqLgyvCr/u43Fi13+7u7q3HJ2uGOG91/naez6WCEz8NPzvQVfgRjagx + X+MtwYkPP4fgxIefQ3Diw88hOPGdfrb4/ovmQpwTqy4OpRF+3cflxpr8/uzWW2/tvhlOQ5y3On87z+dS + wYmfpF+RaESNVWkcTnz4OQQnPvwcghMffg7Bie/0m8/nD7SF9zWthXgw1lQcsiP8uo/LjTX7fdLxidsj + zludv53nc6ngxE/Sr0g0osaqNA4nPvwcghMffg7BiQ8/h+DE9/rt7Oz8XMci3BtrLg6jEX7dx+XGuv3s + fHyenZad5zvnrc7f3vO5RHDiJ+lXJBpRY1UahxMffg7BiQ8/h+DEh59DcOJ7/WzB/fj2AjwU6y4OYxF+ + 3cflxlT8dnd3P1Kn6Ik4b3X+9p7PJYITP0m/ItGIGqvSOJz48HMITnz4OQQnPvwcghPf62eftO5lC+3f + dS3AXTGV4tAX4dd9XG5MzO+ZOk2PxXmr87f3fC4RnPhJ+hWJRtRYlcbhxIefQ3Diw88hOPHh5xCc+EE/ + K/4/2rHwdsbEisOpCL/u43Jjin62QX0k5ynnrc7fwfM5V3DiJ+lXJBpRY1UahxMffg7BiQ8/h+DEh59D + cOIH/WyB/ZD2gtsXUywOzQi/7uNyY8J+T+W81fk7eD7nCk78JP2QsXl//UcjaqxK43Diw88hOPHh5xCc + +PBzCE78oN98Pr+rLa4vbi22nTHh4nAc4dd9XG5M3O+18/ne/cfO51zBiZ+qX7r1/zjPQRbcUahW41NP + TviFX7bgxIdfS7awPrW10HbGxItD+G2B32y29xlj53OO4MSPvj9yBCe+lh/Fnzv+jm8AOMCCewk3OzCl + wYRf+GULTnz4OQQnftRvZ2fnii2ud7YX23ZsQnEIP39skN+vDp3POYITP/r+yBGc+Fp+FP/0vJ/hDYAO + 5ilCfPpPnZjSYMIv/LIFJz78HIITP+p3eHj4rrYBeH7XgtuMDSoO4eeITfLb3d192/7+/Jqu8zlHcHo/ + jL4/cgQnvpYf9Zyn/PK037QB6P4OAC9Y8PxgPv2nDcCUBhN+4ZctOPHh5xCc+Cw/W1y/pb3YtmOTikP4 + lceG+n26TuEi8T7Q+yHr/TEmOPE1/ajnxMkGQC8vyl5IO4WrLdIGIO+pQh2Cs5h6csIv/LIEJz78OmSL + 6AX79P+2ocU5ik33cbkRft3H5Uafn523P6fTOFu8D/R+yHp/jAlOfE0/ruRTz9MG4Cq9vCh7If2OgAPT + BmD8ecI9grOYenLCL/yyBCc+/Dp04cKFd7JF9I/aC24zVrWYeyP8uo/LjU32s3P3dZzDOp1HxftA74es + 98eY4MTX9Es1PG0AqO+9l/75diA7hLQBYOewkYvRmODEh59DcOLDzyE48efGzxbRr0qLaVescjH3RPh1 + H5cb58HP/v+hTudB8T7Q+yH7/TEkOPE1/dLV+7QB4Mp+b/HnSwHsDtIGgNjYxWhIcOLDzyE48eHnEJz4 + c+Nni+fDd3d3b2svqCnWsZiXRPh1H5cb58XPzuGv0SndK94Hej9kvz+GBCe+th+RNgDU88Ev/TU3AP07 + hREZtynJCT+H4MSHn0Nw4s+T3zvY4vms9mKaYl2LeW6EX/dxuXHO/H5N53SneB/o/VDy/ugVnPhl+PEv + GwCu5PfXc3sRKG0A+n9HMCL5LGsw4VcoOPHh5xCc+PAbkC2aX9BaRE9izYv5aIRf93G5cQ793mCndOf5 + zvtA74ei90ef4MQvy4//Hv8OHwdYsAHgOwBR/DMEJz78HIITH34OwYlfq58tmNewaDYW0JOYwGI+GOHX + fVxunFe/3d3d63R6n4j3gd4PRe+PPsGJX6Zf3l/vcZBF/40BRiR+05ITfpmCEx9+DsGJP3d+Ozs7v9y1 + iE5lMe+L8Os+LjfOud8n6fQ+Fu8DvR+K3x9dghM/DT870FX4EY2oMV/jLcGJDz+H4MSHn0Nw4sNvRPZJ + 6dM7Fs+zLr6nIvy6j8uN8Os+ri/svP5mneJbtx4UiUbUWJXG4cSHn0Nw4sPPITjx4TeiG2+88QG2WL66 + vXhObTFvR/h1H5cb2+BnG4Cf5xznfaD3Q/H7o0tw4ifpVyQaUWNVGocTH34OwYkPP4fgxIdfhmyh/Jn2 + wjnFxbwZ4dd9XG5si9/Ozs7zeB/o/eB6f7QFJ36SfkWiETVWpXE48eHnEJz48HMITnz4Zcg+IT2hvWhO + dTFPEX7dx+XGlvm9Ue8H1/ujLTjxk/QrEo2osSqNw4kPP4fgxIefQ3Diwy9Dtrje0z4hvby5YE58MQ+/ + 8CsK+P392ft43h9twYl3vd/aghNfxa9INKLGqjQOJz78HIITH34OwYkPv0zZAvlD7cWy9uIbfv4Iv+7j + cuPtfpdmnvdHU3Di3e+3puDEV/ErEo2osSqNw4kPP4fgxIefQ3Diwy9T9sn/cd2LZe3Fd6V+v2rjGnx6 + YYo19S87wq/7uNxo+s1mex9e+v5oCk68+/3WFJz4Kn7I2Ly//qMRNValcTjx4ecQnPjwcwhOfPhl6vDw + 8D2sUL6wa7Gsvfiuys/G81s2tLvY67v283PbrzdjHf0rifDrPi432n62AfhnJe+PpuD0/nK/35qCE1/L + L936f5znIAvuKFSr8aknJ/zCL1tw4s+1ny2S3923WE59Me/ys+L/Zov30/COH2W8u7v7Nfba7e1j19G/ + kgi/7uNyo8vPzo0n6tQoEu8rvb/O9H5LghNfy4/izx1/xzcAHGDBvYSbHZjSYMIv/LIFJz78CmSL5IHF + nX2LZVpIPbFGv3+t4S3IFv4PtHh2Om6N/cuK8Os+LjcG/D5Hp0S2eF/p/XWm91sSnPhafhT/9Lyf4Q2A + DuYpQnz6T52Y0mDCL/yyBSc+/Ap0yy23vIsthn82sli6Yl1+VuB/7/Dw8CoNsUs83fBfmsebcvxyY13j + zY3wW3j9yToXssT7Su+vM73fkuDE1/KjnvOUX572mzYA3d8B4AULnh/Mp/+0AZjSYMIv/LIFJz78CmUL + 4TdmLJbFsS4/K/5vtXikhtcp8kS+ZrO9G8zrmavsX26EX/dxuZHh98U6HUaVzheLM7/fEJz4mn7Uc+Jk + A6CXF2UvpJ3C1RZpA5D3VKEOwVlMPTnhF35ZghN/7v1ms9mjKJhrWHyLotDvGzW8TpEn5eskf/P57POM + e03LJzvWPN7RCL/Tx+zu7n6RTolBdZ0v+nlK6wFX8qnnaQPQffXLXki/I+DAtAEYf55wj+Aspp6c8Au/ + LMGJP/d+XCK3RfD317H4lkSJn43nT/mVhoZ4SuRJ+TqVv/l8/kDz+Nm251isc7w5EX7dx9m58nk6LXrF + eaHz49T5okOKBCe+pl+q4WkDQH3vvfTPtwPZIaQNADuHc7e4ITjx4ecQnPjwcwhO/CT9bAH8inUtvrlR + 6HfHbDaba3inRJ6Ur8H8WTsfu7Oz84oO/1Ox5vGORvh1H0fY60/SlHeK80Lnx+D5kis48TX90tX7tAHg + yn5v8edLAewO0gaAmNJgwi/8sgQnPvwcsgL3cNsAvDl3scyJdS7miu/W8E6JPClfWfmz9u5pfj/c8l+I + CYx3MMKv+7gUdv5/gqb7lDgvdH5knS9jghNf249IGwDq+eCX/pobgP6dwoiM25TkhJ9DcOLDzyE48ZP0 + u+GGR7yjLX7PKlksx2Ldi7ltaF7IjYw0xAWRJ+WrOH/W9i3m/6J2e+se71iEX/dxrfgQTfOCOC90fhSf + L12CE78MP/5lA8CV/P56bi8CpQ1A/+8IRiSfZQ0m/AoFJz78HIITvzV+tjh+iWOx7A3n4tsbHj/b0Hyw + hrggxqt8ufM3n8/vav7fa+2ct/skZMV59bM53dMUn4jzQueH+3xpCk78svz47/Hv8HGABRsAvgMQxT9D + cOLDzyE48eHnEJz4an6z2aXrbOF7w7oX375w+v2ghrggxqt8VcmftXPF+vQXjv71xkTy1xvn2c82dtdq + ao/FeaHzo8r5Aid+mX58+h/34yCL/hsDjEj8piUn/DIFJz78HIITP2k/W/h+ZQqLb1c4/V52cHBwDw3z + RGm8FlXzd9NNR/ezfn2HbaKO/3Syoz/Z4Rxvb4Rf93F9ceHChXfT9G7M+1c+5X52oKvwIxpRY77GW4IT + H34OwYkPP4fgxG+Vny2QnzWVxbcdZ/D7GA3zRGm8FlXzJ5/jODjY59bJf9DqS3ZMKH+dcd79dnZ2XqXp + 3Zj3r3zO7FckGlFjVRqHEx9+DsGJDz+H4MRvlZ8VrIfZp9ZXTWHxbYfXz8bz0xrmidJ4LarmTz4LfrqP + wpdbMXlzV//6Yir564tt8LN5+/2x+T0+AQoFJ36SfkWiETVWpXE48eHnEJz48HMITvzW+dlC+bNTWXyb + 4fXjE5zF/TXUYzXH24ilz8fFixff3/ryW139bMdU8tcX2+Jn8/VTzKPmc3B+cwUnfpJ+RaIRNValcTjx + 4ecQnPjwcwhO/Nb52SL5z6a0+KY4o9/Co1yb423EKufjLvap8vOssLy+o6/HMbH8nYot8/smzWfu/A4K + Tvwk/YpEI0rGViQHTnz4OQQnPvwcghNf3W8+33tvWyxfds4W81/SUI/VHG8j1jIfs9nsIda/Z7T6e9bx + norw6z4uN4z/TM/8dglO/CT9ikQjaqxK43Diw88hOPHh5xCc+K30s8XyRya4+Lr9+IRNkdVwJzsf1s9P + tXgVfZ5S/rpiG/0ODvYvn2V+k+DEn+l8SYITX8WvSDSixqo0Dic+/ByCEx9+DsGJ30q/+Xz+EVNcfM/i + Z8zna7iTnw/r6wN2d3f13QvfeNsxtfloxyb42Zy8lT/nPOv8womvcr7Aia/ih4zN++s/GlFjVRqHEx9+ + DsGJDz+H4MRvpd/+/uyBtmC+sGsRzI2pLea2cP+2DfU4P+3xKiY5H7PZ3ifbeF++7vy1Y4v9nsu8aH4m + +f5VnMUv3fp/nOcgC+4oVKvxqScn/MIvW3DiN8bPiuVTuhbB3JjaYm7juW02m31A33j182Tn4+joynvb + GH6wa2w5MbX5aMcm+dnPP6T5Oa/rAcWfO/6ObwA4wIJ7CTc7MKXBhF/4ZQtO/Nb62WL3GFvk7mgugCWx + zMXX62fF8yv6xqufN2J+bRwfvLOzU3RlZorz0YwN9PucNB+lgtN8ds5vqeDE1/Kj+Kfn/QxvAHQwTxHi + 03/qxJQGE37hly048Vvr99jH3nxvKzDP61oIc2IFi2/ncSPxB9x0p2u8+nmj5penFtqYvtvi+OFCQzHR + +TiJTfSz98fDNRVFYh41n4Pzmys48bX8qOc85Zen/aYNQPd3AHjBgucH8+k/bQCmNJjwC79swYnfaj/7 + hPkNXQthTqxi8e06bihssX7rbDZ7lI3t3M2v5WTfxvhn7TGnmOJ8NGND/V6m9BeJedR8Zs/vkODE1/Sj + nhMnGwC9vCh7Ie0UrrZIGwBiY99MQ4ITH34OwYkPP4fgxC/Vzxa4R9oC95bmIpgbK1p8i8M2NNyw5dzO + 7y233PIuNs5vZKPTHPdU5yPFpvpZnp+m1GeLedR8Fs9vl+DE1/TjSj71PG0ArtLLi7IX0u8IODBtAMaf + J9wjOIupJyf8wi9LcOI3yu/xj/+wd7IF7nebi2BurGrxdcSfHR0dsrBt3HxYFPlxlcPGe/xwoQnPx3Fs + sp9tKP+5Up4l5lHzeab5TYITX9Mv1fC0AaC+917653dp7BDSBoA32Ll6MyXBiQ8/h+DEh59DcOKX7mcL + 25c1F8HcWOXiWxj8fvyKxndqvEpJkeDET9Lv0Y8+fGcb87+1uG2C83Ecm+5n75MHKd2jYh41n1XmF058 + Tb909T5tALiy31v8+VIAu4O0ASDO5ZsJTnz4OQQnPvwcghO/dD9b2B62s7PzpuZClxOrXnwL43s1vlPj + VUqKBCd+8n4HB/s7Nv5nT2w+Nt7P3iN/pHSPqjkfjZji+UKkDQD1fPBLf80NQP9OYUTGbUpyws8hOPHh + 5xCc+FX48RCa32wudDmx6sW3MF50001HD+gZb7HgxG+M38HB3t0tj0+2XLyhlZusmPj8rsXP3idfr5QP + qms+9PMUzxf+ZQPAlfz+em4vAqUNQP/vCEYkn2UNJvwKBSc+/ByCE7+Rfvap5rPaC91YrGPxLYn5fPbR + feMtFZz4jfSzfFxjc/zL7RwNxdTnd11+lseLx0kfEHlX/jvno1Rw4pflx3+Pf4ePAyzYAPAdgCj+GYIT + H34OwYkPP4fgxHf6Xbx48cG2qL2ua7Hri3UtvrlhHk/rG2+p4MRvvJ/l5tNsro8fLjQU05/f9fhZ7v5a + qewVeVf+R+cjR3Dil+mX99d7HGTRf2OAEYnftOSEX6bgxIefQ3DiV+Zni9ovdC12fbGuxTc3dnd3X3Hl + ysE1feMtEZz43vyVCE782vxsvu9vefqZdt5STH1+1+z3rUpjp8i78p89H0OCEz8NPzvQVfgRjVic3+S0 + BCc+/ByCEx9+DsGJ7/WzBe+fbdDiOxry+9S+8ZYITnxv/koEJ37tftdddx1/KfCinvw1YvH10jhvfnbM + jUrhKZF35b94ProEJ36SfkWiETVWpXE48eHnEJz48HMITvzG+h0cHNzHFrW/by9yfbHuxXcs5Pf0vvGW + CE58b/5KBCd+En6WL/5MsCt/jVh8vTTOm9/u7u6fKn2nRN6Vf9d8tAUnfpJ+RaIRNValcTjx4ecQnPjw + cwhO/Eb77ezsPK1roeuKdS++YyG/18xme+/fN95cwYk/yd9sdunBVgAOrQ2umHwOYfn7xNlsNjfdVWin + uvz081rOFxvDB1n/F+70uCHzu26/f60ULoi8K/+u+WgLTvwk/YpEI2qsSuNw4sPPITjx4ecQnPiN9rPF + 7PGtxa03JrL49sbb/S59bt94cwUn/m77+/MbzfNbrfD/H2tn6IE7PDHxf1t8pR27cIOYpl8jqvSvEdl+ + t9566ztaP/+X+n0cy5uP8+Nnm7232UbvgUrjici78u+aj7bgxE/Sr0g0osaqNA4nPvwcghMffg7Bid9o + vwsXLtzNFrS/6Vro2jGFxXcokp/992/0jTdXcPCzmTnu7f2CxZ2l/aNQ2L8/bMGXECd3vtgG5Uua/V3W + fJxDv6crhSci78q/ez6aghM/Sb8i0Ygaq9I4nPjwcwhOfPg5BCd+4/2sCPzHjgXuVExo8e2Mht8b7dP6 + B/WNN0dwR0eX72le3275eetZ+2cbgTcZ/5VHRwd3N++Vzm+fbEzvS79SH5c4H+fOz/L2YUrjsci78u+e + j6bgxE/Sr0g0osaqNA4nPvwcghMffg7Bid94Pytuj7YF7Vw9P94+sf/rvvHmCO7y5YP3Ma/nLKF/z7CN + xYPO2j/xo/M7oLtYEfuNjv4pTo+hJM6zn+XthZa/k1yTd+X/LPNxIjjxk/RDxub99R+NqLEqjcOJDz+H + 4MSHn0Nw4jfe78KFC+9mG4C/7FrkmjGlxbcrWn7P4Xa3XePNEdxsdulh5vMXb/fsbjc3To937/duvPFR + 91STRaJ/ms/R+R2Szftn9vfv9BhKYgv8/pXSeK7WgxwZl279P85zkAV3FKrV+LYlO/zCL1tw4rP8rAh8 + e8fithATXHwXoulnP982n88u9o13THCHh5cfaHn5k2X0r+X3TP72Xk1nif5pPrPmt082vgdZ+68d6Z8r + zrvfP/4qZ+9480belf8zzUcSnPip+lH8uePv+AaAAyy4l3CzA1MaTPiFX7bgxJ8LP1vEdm0x4wtqnQsd + MbXFtx2n/fa+vm+8Y4IjX1Ycf+rtft3t5sbYeK2t/6DmR5X6Z5E1v0Oytp+e07/S2BK/p5JD8q78n3k+ + EJz4qfpR/NPzfoY3ADqYpwjx6T91YkqDCb/wyxac+HPhp7u+Pbe1sC3ERBffkzjtt/dc+3/voiEWiTyR + r9ls75Pf7tfdbm4UjPdI3ehV6p9F1vwOyTZ9n0i7Bf3Lii3x4887H0belf8zzweCEz9VP+o5T/nlab9p + A9D9HQBesOD5wXz6TxuAKQ0m/MIvW3Diz42fLWJf21jUTsVEF9+TaPvZJ+m32f/b0fCKRJ7I12Mfe9N9 + zesly+jfiN8fWjd6v1CV+meRPb99unDhwr2tvb8v7N9obIufbZ5+irwr/2eeDwQnfsp+1HPiZAOglxdl + L6SdwtUWaQOQ91ShDsFZTD054Rd+WYITvza/ixcvPsIWs9vbi1uKqS6+KXr8/r2GVyTypHzd7dKl3S9a + Yv8GwzYwH6kuLajZv0a4zxdr62me/g3FNvnt7u7sKv9V5gNO/JT9uJJPPU8bgKv08qLshfQ7Ag5MG4Dx + 5wn3CM5i6skJv/DLEpz4dfq9gxWb53QtbsSUF1+iy88+lT3/8PDwXTW+bJEn5es4d+b3vDWO95fUrRO1 + +6dwny/Wn484Q/86Y8v8fkn5rzIfcOKn7JdqeNoAUN97L/3z7UB2CGkDwM7hPCcn/MIvS3Di1+pni9gX + txa1k5j44tvnd6dtAK5oeNkiT8rXce7Ma7ak/mUFX8a0uJe6V/18sb7c3TZ+f+vtX1ecZbxdMXW/+Xz+ + wbXmA078lP3S1fu0AeDKfm/x50sB7A7SBoA4z8kJv/DLEpz4tfrZAnatLWRvbC9sxNQX3z4/K2pP0fCy + RZ6Ur5P8md+Xt9ssiUrj/bi+/uln9/liefqBCv07iUrjPYmp+1mk20pXmQ/xU/cj0gaAej74pb/mBqB/ + pzAi4zYlOeHnEJz48HMITnyxny1iv67FbCE2eDF/8dhT99oiT8rXQv7MK/spiO2oON5vtb5UP19ms9mH + WL/urNC/46g43uPYDL9Lj601H+Krza/4ZfjxLxsAruT313N7EShtAPp/RzAi+SxrMOFXKDjx4ecQnPi1 + +9lC9i/aCxuxnMVyZX4fouFliTwpX6fyZ148ua/pnRU1x7uzs/Pz6s+p/mkIRYI7PLx8X/N+QY3+ETXH + S2yI3zNqzYf4avMrfll+/Pf4d/g4wIINAN8BiOKfITjx4ecQnPjwG5EtYO9li9lreha3Riy+Xhqr9Nvd + 3f0RDS9L5En56syfeb4oeedG/fHu/a++/pUKDt58v7te/2qPdyP87tjfn89rzYd8qs2vfJbll/fXexxk + 0X9jgBGJ37TkhF+m4MSHn0Nw4l1+Vix/vmdxa8Ti66WxSj/7pPyK5hfmxkSelK/e/Jnvy5J/TixjvPbv + H/X1r0Rw8Ob5aJv7t9XqX+3xbojfj9WaD/lUm1/5rN/PDnQVfkQjaszXeEtw4sPPITjx4ecQnPhJ+Nli + 9vEDi5ti8fXSWIPf8ZflckSelK/B/NmG4q9bbfTGEsf7nL7+5QoO/ujo8r2t+Ot5Bt3t5sYSxztpP8vf + m+fzvQ+sMR8Wg+dfruDET9KvSDSixqo0Dic+/ByCEx9+DsGJn4Qfn5JtEfu7rsWt9mK5Qr+f1fBGRZ6U + r9H8me+zWu10xpLH+/S+/uUITjx/1fBNS+jftvl9W635aMS59SsSjaixKo3DiQ8/h+DEh59DcOIn42fF + /0cHFrfjn5uvl8Ya/F4zn88fqOENijwpX1n5s83SD7TaOhXLHq/9v2/v69+Y4DS+u81m5ra3d3vt/m2Z + 38tvuunoATXmoxFF79+m4MRP0q9INKLGqjQOJz78HIITH34OwYmfjJ8taB8ysLgd/9x8vTTW4Wf//0ka + 3qDIk/KVnT/bLJ08G78rVjFe60Pn7YDHxLg0vrtdvjy7h/n87jL613Vcbmyan22iPnvofBlScz4aUfT+ + bQpO/CT9ikQjaqxK43Diw88hOPHh5xCc+Mn48bfxtqi9pG9xm/ri2+P3axreoMiT8lWUP/O/ptXeSaxo + vLeX3tMAMS6N73isVri+Ykn9c8em+bGBuuGGR3Q/7GZE7flQFL1/m4ITP0m/ItGIGqvSOJz48HMITnz4 + OQQnflJ+tqg9tW9xm/ri2+P3xosXL76Phtcr8qR8ufJn7Zz6HsCqxmtF56fVjWwxLo3veKxW/G8wzze1 + 2yyJVY3XGyvwu2Nn5+IlpbhI7flQFL9/k+DET9KvSDSixqo0Dic+/ByCEx9+DsGJn5Tfzs7OFVvY7uxZ + 3DoXwdxYl58Vxy/S8HpFnpQvd/6snU9otrvK8drPh+pGlhiXxncyXvN4ZrO90ljleD2xIr/vV4qL1DUf + +vlcrlfI2Ly//qMRNValcTjx4ecQnPjwcwhO/KT8bBG72jYAzx9Y3NyxLj8bz7NtaIN5IE/K15nyd+ut + t76jtfc82l3xeH9dXcgS49L4TsY7n88+r+FXHCseb3Gsws82gH93cHBwD6U5W13zoZ/P1fqSZFy69f84 + z0EW3FGoVuPbluzwC78s2cL27/sWt+biVxpr9LvdFuXrNLxOkSfl68z5Q9beY1Y83rdcvHjxEWp+VIxL + 4zsZ75UrB+9nPqfu9JgbKx5vcazKz+b+k5XmbHXNh34+r+sVxZ87/o5vADjAgnsJNzswpcGEX/hlC078 + 5PxsAbtgn17ftqrF0hslfrYg/xsNr1PkSfk6c/4QHLy1/X2rGq+N8UvV/KhS/ywWxmvzfupOj7lRMh85 + scF+v6o0Z8tyP9n1AMGJr+VH8U/P+xneAOhgniLEp//UiSkNJvzCL1tw4ifnd+HChXeyIvBHK1wsXVHi + Z+P5Y8alIZ4SeVK+zpw/BCf+btxFz/r3zBWM97+q+VE1+9cINiun7vSYGyXzkROb6mfn2pt4VLZSnSXL + /WTXAwQnvpYf9Zyn/PK037QB6P4OAC9Y8PxgPv2nDcCUBhN+4ZctOPGT9LNF7KtXtVh6o8SPKxkWFzW8 + UyJPyleV/MGJP/HjJjDWl99q9y03Msb7M0MbnKa6+sfPly7t3sfy9IqWb1aUzEdObLLf7u7ulyvVWbLc + T3o9gBNf0496TpxsAPTyouyFtFO42iJtAPKeKtQhOIupJyf8wi9LcOKr+NlC9oEWt799Id+sxbcnvlXD + OyXypHxVyR+c+FN+h4eH72p9+bFW30ZjbLxWtL+TLxyqC4OiH+rPqf5Z4Vq402NuOOZjMDbc73dz5wKR + d+X/1HzokCLBiZ+yH1fyqedpA3CVXl6UvZB+R8CBaQMw/jzhHsFZTD054Rd+WYITX8Xv2msfepUtaM8Z + WNyKY8WL76mw4vgXdtzVGuKCyJPyVSV/cOIH/azQfrr161Vd/W3H0HjN42/NK/tuf/RD/TnVP/NbuNNj + bpTOx1hssp/Nx5ttPga/ZNoUeVf+T82HDikSnPgp+6UanjYA1PfeS/98O5AdQtoAsHM4z8kJv/DLEpz4 + an62oP2rvsXNE6tcfHuC+xccaYgLYrzKV7X8ic/ys2LBg5W+zf59favPJzEw3n+w+OrDw8P3kN2o6If6 + c6p/utPji+WdHY75GIxN97P5/EKle1TkXfk/NR86pEhw4qfsl67epw0AV/Z7iz9fCmB3kDYAxHlOTviF + X5bgxFfzm89nH2SL2hv7FrfSWPXi2xPfpyEuiPEqX9XyJ77YT8X3iRb/3TYDr0x9Pz3evZfb6z9u/34s + v0oQniX6of509s8K11NSu7kxkfntjTX4PcNSmXUjG/Ku/HfOR6ngxE/dj0gbAOr54Jf+mhuA/p3CiIzb + 1mSHn0Nw4rfKzxaw31jhYlkUTr+XWGF7Tw3zRGm8FlXzJ58z+81mswfPZns32xg/2v79KPv30ZcvH7yP + 1w9O/ensn20qTu70mBvO+eiNTfezHL7c/r3fccJHRN6V/875KBWc+E3w4182AFzJ76/n9iJQ2gD0/45g + RPJZ1mDCr1Bw4sPPITjxVf1sQfvcVS2WpeH1s0X5wzTME6XxWlTNn3w2zo8rCZan4zs95sZU5rcv1uB3 + h200bzpO+IjIu/LfOR+lghO/KX789/h3+DjAgg0A3wGI4p8hOPHh5xCc+K3ys0+Z728L22tWtFgWxRn8 + nqVhniiN16Jq/uSzkX6Wp29p5W0wJjS/nbEmv69UOgdF3pX/3vkoEZz4TfLL++s9DrLovzHAiMRvWnLC + L1Nw4sPPITjxPPDl6StcLLOjgt8vzWazh7TH24hJzkcjlupn+Tm+02MrZ70xwfldiDX5/aylcrRGkXfl + v3c+SgQn/nz62YGuwo9oRI35Gm8JTnz4OQQnPvwcghNf3c8Wtk9Z4WKZHbX8rMC93vgnHxzs3Z3xNmKS + 89GIpfqlOz125awrpjq/Kdbk93/4AqdS2ivyrvz3zkeJ4MRvhV+RaESNVWkcTnz4OQQnPvwcghNf3e/K + lYNrdnd3X7Ghi292iH/2wcH+DuPW+Lf6fLF8fFUzR0OxCfO7Br+/z7nVL3lX/gfnI1dw4rfCr0g0osaq + NA4nPvwcghMffg7BiV+Kny1uT9vQxTc7mn72823279c9+tGH76yUFKmdP8Vk51dxys/y8HDb+N3WzFNf + bNL8rspPuTtQOntF3pX/wfnIFZz4rfArEo2osSqNw4kPP4fgxIefQ3Dil+JnC9tHr2KxLIkV+v2h/Xyj + UpOldv4Uk51fRZcfd/x7VsrRUKxwPlyxJj/+XPLjlMtekXflf2w+sgQnfiv8ikQjaqxK43Diw88hOPHh + 5xCc+KX43XTT0XvZp5jiu741Y02Lb3aM+e3s7LzV/v2WnBvqtPOnmOz8Kjr9bMxf0MxDX6x6PkpjXX72 + vhm90x95V/5H5yNHcOK3wq9INKLGqjQOJz78HIITH34OwYlfmp8tcP+xa3HLjXUtvrlR6PfntqhfVrpO + qSt/+nnjzhcb6zUWb2iMvTPWPB+jsS4/O0++QansFXlX/kfnI0dw4rfCr0g0osaqNA4nPvwcghMffg7B + iV+a33w++2BbzIru+taMdS2+ueH0u9MW96e0v9HdlT/9vJHny87Ozi93jH0hJjIfvbEuP8vddyqNvSLv + yn/WfIwJTvxW+CFj8/76j0bUWJXG4cSHn0Nw4sPPITjxS/N77GNvvrctZn/WXtxyY12Lb25U8OPXIv+0 + L3/6eSPPF9vgfHprrKdigvOxEOvyY3NoKRwsTORd+c+ajzHBid8Wv3Tr/3FejXNHoZTo856c8Au/bMGJ + X/CzxeybShfdFOdlMc8JW/B/dH9/fk07fxYbeb7ceOOND7Bxvbo9zmZMeT6INfo91VIYxb8hOPG1/Cj+ + 3PF3fAPAARbcS7jZgSkNJvzCL1tw4pfqN5vNuOsbX3zrWuQGY42Lb1Ysw882AX83m+19WsqfxcaeLzam + n2mPsRmbMB/r8LNz4LuUwl6Rd+U/ez6GBCd+W/wo/ul5P8MbAB3MU4T49J86MaXBhF/4ZQtO/FL9+Lt3 + W8x+v2uRG4t1Lb65sXy/vf+xvz9/kFJcJMv92s8Xm/cndI0zxebNR/dxuZHrZ3mLL/y1BCe+lh/1nKf8 + 8rTftAHovtrCCxY8P5hP/2kDMKXBhF/4ZQtO/NL9bDH78q5FbizWtfjmxgr9eFDSk5TqLJF35f/UfOiQ + IsGJz/azPt9z5x8fU7swzhQrzJ8r1uTHF0LjT/1aghNf0496TpxsAPTyouyFtFO42iJtAPKeKtQhOIup + Jyf8wi9LcOJP+V28ePH9rQi8uWOhG4w1Lb7ZsSa/X7N8vo/S3ivyrvyfmg8dUiQ48UV+1t8favX/JNaU + v+xYk9/t9l75RKWvV+Rd+S+ajz7Bid8mP67kU8/TBuAqvbwoeyH9joAD0wZg/HnCPYKzmHpywi/8sgQn + vsvvLvZp5rc7FrrBWNPimx1r9nujxRdbbjvni7wr/13zUSw48UV+No5bWv0+iTXnbzTW5Pcae6+MPtOf + vCv/RfPRJzjx2+SXanjaAFDfey/98+1AdghpA8DOIZKdITjx4ecQnPiN9LMF7fM6FrrBWNPimx1T8bNP + is+2+MDjiZDIu/LfOR+lghNf5Hd4ePge1scXtftMTCV/fbEmvxfYe+U6pa9X5F35L5qPPsGJ3ya/dPU+ + bQC4st9b/PlSALuDtAEgItkZghMffg7Bid9IvwsXLry3FajXdyx2vbGmxTc7Juh3u8XXXnfddaxPkzlf + rE/f0+jjSUwwfwuxDj8r/L9p75V7K3W9Iu/Kf/F8dAlO/Lb5EWkDQD0f/NJfcwPQv1MYkXExeeGXLTjx + G+tnC9svthe7oVjH4lsSE/d77v7+/NFD81EiOPHFftaXA4tTd3qceP7W4mfvke89PDzs/t1zQ+Rd+S+e + jy7Bid9GP/5lA8CV/P56bi8CpQ1A/+8IRiSfZQ0m/AoFJz78HIIT3+tnC9untBe7oVjH4lsSG+J3h8X3 + Xrmy/4D2fJQITnzv/PaJBxtZf07d6XFD8rcyP30p9tOUtkGRd+W/eD66BCd+W/347/Hv8HGABRsAvgMQ + xT9DcOLDzyE48RvrZwvb/WyBe2VzwRuKVS++pbF5fnt/bRuwx2g6isQ8aj5753dI1u6pOz1uXv66j8uN + MT97b/y1/XtBKRsUeVf+XfPRFpz4bfbL++s9DrLovzHAiMRvWnLCL1Nw4sOvIVvcfrK54A3Fqhff0pDf + a+2/b5tw//r8/vOFCxfupmkZFfOo+Ryc3z7NZrNHWXFbuNPjisdbHKv2sw3Szx8cHNxDKRsUeVf+XfPR + Fpz48MuRHegq/IhG1Jiv8ZbgxIefQ3Diw88hOPGDflYAPqq54A3Fqhff0kh+9t9P2t+f79p/P6d9TEms + Y7w2H39rRecjND29Yh41n4Pz2yd+j23tLNzpcR3jLYkV+73F8vMllqqsmkLelX/XfLQFJz78li0aUWNV + GocTH34OwYkPP4fgxA/63XDDDXe3he6ljUWvN1a8+BZHw+8ZabzXXvvQq+y1J1uMPs++HRMY70/YJ/T7 + aqoWxDxqPgfnd0hW3Bbu9DiB8Q7Giv1eYHFJqRoVeVf+3fPRFJz48Fu2aESNVWkcTnz4OQQnPvwcghM/ + 6mefNn+gsej1xooX3+Jo+L3OPvlf1x6vHXONxS81maGYynhtfl5phfpTNIxjMS6Nb3R++8SdHs33ttTO + VMbbF6v0s7z8t1X+GqYtOPHht2zRiBqr0jic+PBzCE58+DkEJ37Uzxa+xzQXxb5Y5eLriUW/S1/YN15k + xz/Riuqr2h7NWG7/3H7PmM1mD2FcGt/o/A5o4U6PEx3vSazKz84L7n/xROUoS+Rd+T/LfJwITnz4LVs0 + YkFjNJoikp0pOPHh5xCc+JX7XX/99e9uix2XOQcX001azK2o/dbR0QFjHsyfcfzFw0+1vYgpj5cCZZuA + L7Ux3n1sfodkeTq50+OUx0usys9y8pz5fH6tUpQl8q78p7lwzUcSnPjwW7ZoRI1VaRxOfPg5BCc+/ByC + E5/lZ8XkO9uLYztWtfh6o+lnC/ib9/fnj+wbb5fM46MtXtblV7t/Nf3sv599cLC/MzS/feIqgj7pnvjV + 7t8m+Vku3mbnztfl3NinKfKu/Ge938YEJz78li0aUWNVGocTH34OwYkPP4fgxGf52aI3swXxjvYC2YxV + LL5dx+VGh99X9Y13SPx5l+Xjv6ygf53H5Ubbz/4fv7//qtLCZcwzuvymPt4l+f2VbYjmSk22OM/0/sp6 + v40JTnz4OWVs3l//0Ygaq9I4nPjwcwhOfPg5BCc+y++WW255Fyt4z2svkM1Y0eLrjtN+e7//+Md/2Dtp + iEUiT+TLCsFHms8L/9Gvu93cWP54F17/Q/t/N2o4g7J5/9QMv+LYRD82ffP5/K5KTbbS+WKR9X4bE5z4 + 8HPIuHTr/3Gegyy4o1CtxmPywi9bcOLX5re7u/v1XYtkilUsvl3H5UaH31ssHqnhFYk8KV/Hudvfnz3Q + 8vMUa2fw6shQrGC8p46xYvY2+/dbuKWvhnZK9vrxnR7X0b+SWLafzS9fAH2C0lKk9vmiWOn7d0hw4rfF + j+LPHX/HNwAcYMG9hJsdmNJgwi/8sgUnPtvPFr7rLd6SFsd2bNpizs9saDS8IpEn5etU/sxzz9r7k3b7 + Y7GK8XYdl8IK/PMtrmiIC7L//9Pr7t9YLNvP/t9v7O/PH6SUFInzQufHqfNFhxQJTnz4OWQcxT8972d4 + A6CDeYoQn/5TJ6Y0mPALv2zBic/2u/XWW9/RFsD/3Vwgm7Fpi7n8/oRH6mqI2SJPyldv/vC1jcDXWRu9 + G6ZmrGi8OcET/Z5qfX9PDYWN38dMqH+dsWS/2+3nr7zhhke8o1JSJM4LnR+950uJ4MSHn0PGUc95yi9P + +00bgO7vAPCCBc8P5tN/2gBMaTDhF37ZghNf5GcF4cu6FkpiyYvvsvzu4JO6hpct8qR8ZeXP2vsga+t3 + m/1px4rGWxovsfx86I03Puqe5vHyCn4nMdHxnkTTz37+84OD/YO++R0TnM6PrPNlTHDiw88hOAvqOXGy + AdDLi7IX0k7haou0Ach7qlCH4CymnpzwC78F2SL4sJ2dnTc1F8kUm7SYN/1sPN+p4WWLPClfRfnj6okV + 0y/pyuGqxusN6/eLavpNfbwtvx++fHn/fmPz2yc4nR9F50uf4MSHn0NwFlzJp56nDUD3X8HYC+l3BByY + NgDjzxPuEZzF1JMTfuHX1l1sYXxme6EkNmwxb/q9gBsZaXxZIk/KV2n+TsSNYmwT8BsZ/XNF+HUflxsN + v9fNZnufVjq/TcGJd58vTcGJDz+H4CxSDU8bAOp776V/vh3IDiFtANg5RLIzBCc+/ByCE792P1sYP7u9 + UBIbtJif8rOfi56bT56Ur+L8dYgN1WdaH17X1z9PrDJ/ntggv9+34n/DGeY31pdp+qWr92kDwJX93uLP + lwLYHaQNABHJzhCc+PBzCE782v0uXrz4YPvE+rqBxVKx+HpprNLPxvMDGl6WyJPyVZy/LsHBX768/3Dr + zy8ue7ye2GK/7798eX6fGvNrUfV8kU/4FQpOPJE2ANTzwS/9NTcA/TuFERkXkxd+2YITPwk/K5a/MLBY + KhZfL40V+72UxxdreKMiT8qXK39twYk/8eNS8+7u7t81+lgUK85fcWyCn+X/DbrkX31+9XP4ZQhO/DL8 + +JcNAFfy++u5vQiUNgD9vyMYkXyWNZjwKxSc+PDLkC2u/6xrsay9+K7SzzY0H6XhjYo8KV+u/LUFJ/6U + n/XrXlaEfrTZ15xYdf5KY0P8nr+/P99tzoemrEhw4k/Nrw4pEpz48HMITnzTa/w7fBxgwQaA7wBE8c8Q + nPjwcwhO/CT8Dg4O7mML5N93LJaNWFxMS2MNfj+p4Y2KPClfrvy1BSd+0M82AR9q/XxJq9+dsYb8FcUm + +Fm+/+eVK/sP6puPXMGJH5zfXMGJDz+H4MQ3/fL+eo+DLPpvDDAi8ZuWnPDLFJz4c+tnC+OPtxfL2ovv + Kv3sE/Yr7d/7aXiDIk/Klzt/TcGJz/Kz3L+n9fWpFtyQZ2EcKVadv9LYAL87zeebG49FXtn8jglOfPg5 + BGcBj0+KfD870FX4EY2oMV/jLcGJDz+H4MSHX6ZsgXx8a7FsLLxVFt+V+9kG4FM1vEGRJ+XLnb+m4MQX + +1mfr1g8vz2WdeSvJKbvt/em2Wzvk0vno0tw4ovnt0tw4sPPITjxVfyKRCNqrErjcOLDzyE48eGXqQsX + LtzNis7fvH2xnPpinuX3DA1vUORJ+XLnryk48W4/G9PV1v9/b3PCw3pyx5sd2+a3u7v70v39+RXvfDQF + J949v03BiQ8/h+DEV/ErEo2osSqNw4kPP4fgxIdfgWyB/I9psZz6Yp7jZ4Xz9bPZ7CEaXq/Ik/J1pvwl + wYmv4mdj27G5ee7YeEsiJ38lMX2/vefyp5c15gNOfJX5hRMffg7Bia/iVyQaUWNVGocTH34OwYkPvwJZ + gbnp7Yvl1BfzPD977fM1vF6RJ+XrTPlLghNf1e/o6PK9Z7O9b7Bx3bap85Ebtf3s3P51y1/6st8k51c+ + 4VcoOPFV/IpEI2qsSuNw4sPPITjx4VegCxcuvJstkn/JYjn1xTzXz8bz2za0wTyQJ+XrTPlLghO/NL/5 + fHbRxves9nhzY13zkRv1/faexuapkcNJz69+Dr8MwYmv4lckGlFjVRqHEx9+DsGJD79CWbH89n9cLKe+ + mOf52Xhum81mH6DhdYo8KV9nzh+CE78Kv3ewcX6BxRua4x6Ldc1HbtT32/uexjf9lzkfxYITH34OwYmv + 4lckGlFjVRqHEx9+DsGJD79C2SK5y5fMpr+Y5/vZBuArNLxOkSfl68z5Q3DiV+pnY73G5u6X2+PvinXO + R07U99v7+rH85QpOfPg5BCd+kn7I2Ly//qMRNValcTjx4ecQnPjwK9Th4eFVVkD+ePqLeZHfHzAuDfGU + yJPydeb8ITjxa/OzMX+axasbOViINc/HaCzB71+X5G9IcOLDzyE48VP1S7f+H+c5yII7CtVqPCYv/LIF + J76Kn31S/qINWMyz/Wwz89bZbPYoDe+UyJPyVSV/cOLX7nfjjTc+wHLwM+2crHM+cqKy352z2d4XefLX + JTjx4ecQnPip+lH8uePv+AaAAyy4l3CzA1MaTPiFX7Z2di7e1xbc11ZcfI/5dfrZhuabNbxTIk/KV5X8 + wYmflJ/l4Am2EXo5+Vj3fIxFZT+K/+efNX9JcOLDzyE48VP1o/in5/0MbwB0ME8R4tN/6sSUBhN+4Zct + OCsUT6m4+B7za/b788PDw3fVEBfEeJWvavkTP0m/2Wx2b8vZfy3M32BMYH6HIop/+GXLOOo5T/nlab9p + A9D9HQBesOD5wXz6TxuAKQ0m/MIvW3D7+7MPsEXztoku5h6/O21Dc1lDXBDjVb6q5U/85P2sKH6U5eXF + 52B+B8P4f8l4GzHJ+WhE+GUKTnxNP+o5cbIB0MuLshfSTuFqi7QBICLZGYITH34OwYmv6meL5vdPeDEv + 9uNqhoa4oDRei6r5k89G+N100xHfDfgei96HCw3FFOZ3KIz/6uZ4LSY9H/o5/DIEJ76mH1fyqedpA9D9 + hWF7If2OgAPTBmD8ecI9grOYenLC75z7HRzMH2oF880TXcw9fi+az+d31TBPlMZrUTV/8tk4P5vzL+vI + 3WBMZH6H4tv7xlsqOPHh5xCc+Cn7pRqeNgDU995L/3w7kB1C2gCwc4hkZwhOfPg5BCe+up8tuv92iov5 + Gfz+qYZ5ouZ4GzHJ+WjE0vwODw/fw/L0olbeBmNC89sXP9g33lLBiQ8/h+DET9kvXb1PGwCu7PcWf74U + wO4gbQCISHaG4MSHn0Nw4qv7cVe08/Q7YRvLj2iYJ2qOtxGTnI9GLNXPcsWvADpz2BVTmd++MI//8bjH + 3XzPvvGWCE58b/5KBCc+/ByCs4DHJ0UNPyJtAKjng1/6a24A+ncKIzIuJi/8sgUnfil+s9neh09vMff5 + 7ezsvMLiXhrqsdrjVUx2PhRL9bNcHVhk//5/KvPbF+bxnKOjy/fvG2+J4MT35q9EcOLDzyE48cvw4182 + AFzJ76/n9iJQ2gD0/45gRPJZ1mDCr1Bw4rfWzxbQ/9JeUEtiYsXh4zTUY3WNVz9v7fnCn0Vanv68lbfe + mNj8nord3d2/2t+fvU/feEsEJ743fyWCEx9+DsGJX5Yf/z3+HT4OsGADwHcAovhnCE58+DkEJ35pfgcH + e1z+/7uuhTUnJlYcflZDPVbXePXzVp8vNt/f1JG7zpjY/J4KG8urZ7O9C0PjzRWc+MH85QpOfPg5BCd+ + mX55f73HQRb9NwYYkfhNS074ZQpO/Eb52SI6ay+quTGx4vCa+Xz+QA035rfHz/J6I7dG7sjfqZjY/J4K + K/5v5ddXQ+PNFZz4wfzlCk58+DkEJ34afnagq/AjGlFjvsZbghMffg7Bid96P1tEv6JrcR2LqRUHY56k + 4cb89vjxMCTL1R+0c9cVU5vfdsBb8W/e6Gfj5iNXcOLDzyE48VX8ikQjaqxK43Diw88hOPHhZ7INwP/s + WmCHYoLF4deOB2tiXBpf53hLBSd+4/1yN3sTnN+FgLex/Jex8eYITvxo/nIEJz78HIITP0m/ItGIGqvS + OJz48HMITnz4SXxrvmuR7YsJFoc3Xrx48X0YC+PS+HrHWyI48RvvN5vNPsCK5m0d+VuICc7vQoh/9tHR + 5XsPjTdHcOJH85cjOPHh5xCc+En6FYlG1FiVxuHEh59DcOLDTzo4OLhPe4EdiokWhy9mLIxL4+sdb4ng + xJ8HP37V8zsduVuIic7vScjvZfv7s/cbGe+o4MTn5G9UcOLDzyE48ZP0KxKNqLEqjcOJDz+H4MSHX0P2 + qXDetdB2xRSLw87OzrNtGIw15nfAz/L7+V35a8YU57cZ8LaJeet8PrtlbLxjghOflb8xwYkPP4fgxE/S + r0g0osaqNA4nPvwcghMffi3ZwvyxXYttOyZaHG63DcAHMi6Nb3S8OYITfy78bJP3EMvT6zvydxITnd+T + SH6z2d5XjI13THDis/I3Jjjx4ecQnPhJ+hWJRtRYlcbhxIefQ3Diw69D9onqc7sW3GZMuDh8LePS+LLG + OyY48efGz/L0S628LcSE5/c4Gn5PzxnvkODEZ+dvSHDiw88hOPGT9EPG5v31H42osSqNw4kPP4fgxIdf + j2yB/VftBbcZEy4Oz33Uox7JfbvXmr8hwYlfm5/l6YmtvC3EhOf3OJKfbVRfNJ/vvffYeIcEJz47f0OC + Ex9+DsGJn6pfuvX/OM9BFtxRqFbjMXnhly048UV+trD2/lnYVIvDzs7O24zf0/iKxtsnOPHnxs9ydT/L + 1ava+Usx1flNkfz0e/+bx8Y7JDjx2fkbEpz48HMITvxU/Sj+3PF3fAPAARbcS7jZgSkNJvzCr1O2wHZ+ + OWzKxcEKwndofMXj7RKc+HPlZ8X/p7ryR0x5fomm32y2x696Nn4++gQnPvwcghNfy4/in573M7wB0ME8 + RYhP/6kTUxpM+IVfr2yx/bihxbf2Yn5WPyv+f3n58v79vONtC078ufKzXH10O3cppjy/RMvvmTyrYmy8 + fYJTvory1yc48eHnEJz4qfpRz3nKL0/7TRuA7u8A8IIFv4fk03/aAExpMOEXfoOyBXZ/YPE9/rn5emnU + 9rNPgx96lvE2BSf+XPkdHBzcw3L1snbuiKnPb9PPNnuvPjjYf/+x8fYJTvkqyl+f4MSHn0NwFvD4pJia + H/WcONkA6OVF2Qtpp3C1RdoAEJHsDMGJDz+H4MSfye/GG298QNfiW3sxr+Fn8YNnHW8SnPhz52eFs/PR + zlOf37bffD771JzxdglO+SrOX5fgxIefQ3Dip+zHlXzqedoAXKWXF2UvpN8RcGDaAIw/T7hHcBZTT074 + nVM/vig29eJgRe2lBwfzB9cYL5z4KvmDE792P8vVY9u5I6Y+v6f99n4iZ7xdglO+ivPXJTjx4ecQnPgp + +6UanjYA1PfeS/98O5AdQtoAsHOIZGcITnz4OQQnvpqfLbbPXFx8uxfp3FhGcZjNZp9Qa7ziq+VP/Nr9 + rr/++ne3zdxfd+Wv9nws04/N3uXLB/fSsIpEnpSv4vx1CU58+DkEJ37KfunqfdoAcGW/t/jzpQB2B2kD + QESyMwQnPvwcghNf1c8W3W97+wLcvUjnxjKKg/37MxrrJPMnn7X7WeH8D135qz0fK/D7MA2pSORJ+XLl + ry048eHnEJz4qfsRaQNAPR/80l9zA9C/UxiRcTF54ZctOPHV/ezT9UcucTF3h/xeeeXKwfvST/U35rdD + eqbDHR35a8RifktjFX62iflBDalI5En5cuWvLTjx4ecQnPhN8ONfNgBcye+v5/YiUNoA9P+OYETyWdZg + wq9QcOK30u+mm47uZwvwm7oW6dxYVnGYzfY+Q/2cbP4Ua/O75ZZb3mVnZ+d5XfmrPR9L9nvpDTfccHcN + K1vkSfly5a8tOPHh5xCc+E3x47/Hv8PHARZsAPgOQBT/DMGJDz+H4MQv1c8W3//eXKBLYlnFwT4N/lLq + n0XMb48sT9/Qlb/a87FsPxvHR2hI2SJPypc7f03BiQ8/h+DEb5Jf3l/vcZBF/40BRiR+05ITfpmCE79x + frYAn7ohUE4sqzhYMXj9fL7Hk/42In86pEhw4t1+lqcb7NP/W9v5qz0fy/azMTxNQ8oWeVK+3PlrCk58 + +DkEJ/58+tmBrsKPaESN+RpvCU58+DkEJz78TIeHh+9qC/Grm4v1WCyzOMxme/+y2b9SwYnvHG+p4MRP + xu/WW299Ryucv9eVv9rzsWS/vz84OLiPhpUl8qR8ufPXFJz48HMITvxW+BWJRtRYlcbhxIefQ3Diw68h + Kybf2Vywh2LJxeFZR0cH9DHmd0CWt5MnOS55Ppbqt7u7+wkaUpbIk/J1pvwlwYkPP4fgxG+FX5FoRI1V + aRxOfPg5BCc+/Fq6ePHi+9gm4G3NhbsrllkcrBi82T7939jVvxzBaXyj480RnPhJ+dk8vZ/Fm9v5qz0f + y/az+f55DSlL5En5OlP+kuDEh59DcOK3wq9INKLGqjQOJz78HIITH349sgX5R5uLdzuWXxz2vmaof0OC + 0/iyxzskOPFT87uL5e7/152/7jznxor9XjOfzx+oMY2KPClfZ83fseDEh59DcOK3wq9INKLGqjQOJz78 + HIITH34D0ifLky+VNWPZxcE2H3/46EcfvrO6UiTGpfEVjbdPcOIn52e5+5yu/NWej2X72f97koY0KvKk + fJ05fwhOfPg5BCd+K/yKRCNqrErjcOLDzyE48eGXISvE/7O5UP/jYr3c4mBt2qZj91HqQpEYl8bnGm9b + cOIn53fx4sUH2wbtdcuejxX4/ZqGNCrypHydOX8ITnz4OQQnfiv8ikQjaqxK43Diw88hOPHhlyFbmC9Y + gVn4HsCKisM3qgtFYlwan2u8bcGJn6SfbZR+cUXz4Y4MvzfyfRMNaVDkSfmqkj848eHnEJz4rfBDxub9 + 9R+NqLEqjcOJDz+H4MSHX4YODw+vssX5D5uL9SqKgxW1P+VudupGthiXxucab1tw4ifpZ3n6lFXMR9dx + uZHjZ+P4Ig1pUORJ+aqSPzjx4ecQnAU8PinOs1+69f84r8a5o9C2JCf8zpmfLc5f2VyoV1Qc7uA+9upC + thiXxuceb1Nw4ifpN5/P7285e2VH/tyxovltx/9nwxnNAXlSvqrkD058+DkEJ35b/Cj+3PF3fAPAARbc + S7jZgSkNJvzCb1C2MD/cPpndlhbqFRaH71YXssW4ND73eJuCEz9ZP8vTz/TkzxUrnN9m3G7n2HUaVq8Y + r/JVLX/iw88hOPHb4kfxT8/7Gd4A6GCeIsSn/9SJKQ0m/MJvTO9gC/PvpIV6VcVhZ2fnhYeHh++hPmSJ + cWl8ZxnvieDET9bPcvbxXfnzxqrmtx12jv0bDatXjFf5qpY/8eHnEJz4bfGjnvOUX572mzYA3d8B4AUL + nh/Mp/+0AZjSYMIv/EZli/OT0yK9yuJgG4DHqQtZYlwa35nGmwQnfrJ+s9mlB1veXtaVP0+scn6bYXP9 + xxcuXHgnDa1TjFf5qpY/8eHnEJz4bfKjnhMnGwC9vCh7Ie0UrrZIG4C8pwp1CM5i6skJv3PmN5vNHmIL + 9BtYpFdcHIqe+864NL4zjTcJTvyk/SxvP9yTv+JY8fyeBH9VcvHixR0NrVNpvBZV8yef8CsUnPht8uNK + PvU8bQCu0suLshfS7wg4MG0Axp8n3CM4i6knJ/zOoZ8tzr/MIr3K4mBtvvzg4OAe6sKoGJfGd+bxIjjx + k/aznD1+FfPhiUK/f6+hdSqN16Jq/uQTfoWCE79NfqmGpw0A9b330j/fDmSHkDYA7Bwi2RmCEx9+DsGJ + P7OfLcyfxgK96uKwu7v7BHVhVIxL4zvzeBGc+En7Xbmy/wDL3QtXMR+lUeJnm73n2zFXa3inlMZrUTV/ + 8gm/QsGJ3ya/dPU+bQC4st9b/PlSALuDtAEgItkZghMffg7BiT+zny3M97d41aqLgxX/n1YXRsW4NL4z + jxfBiZ+8n+XuKauYj9Io9LvTzrErGt4pNcfbiEnORyPCL1Nw4qfuR6QNAPV88Et/zQ1A/05hRMbF5IVf + tuDEV/GzQvwzaygOr2bjoS4MinFpfFXGCyd+8n7z+exmy98dK5iPoij1s3PsKRreKTXH24hJzkcjwi9T + cOI3wY9/2QBwJb+/ntuLQGkD0P87ghHJZ1mDCb9CwYnfCj9bnJ+wjuJgBeHT1YVBMS6Nr8p44cRP3u/y + 5fl9LH9/tor5KAmH34vn8/ldNcQFNcfbiEnORyPCL1Nw4jfFj/8e/w4fB1iwAeA7AFH8MwQnPvwcghNf + xe/y5YN7WSF+ReFiPhg5xcHa/BV1YVCMS+OrMl448RvhZ7n7llXMR0k4/T5EQ1xQe7yKyc6HIvwyBSd+ + k/zy/nqPgyz6bwwwIvGblpzwyxSc+Mn62QL+Xx2LeW9kFgf+zPAadaNX9E/jqzZe8Rvht78/n1v+3tLK + XVFkzkd2ePxss/cjGuKC2uNVTHY+FOGXKTjx59PPDnQVfkQjaszXeEtw4sPPITjxW+NnC/hHli7mQ1FQ + HL5A3egV/dP4qo1X/Eb4Pe5xN9/Tcvh7HbnLDk+xHgqP387Oziss7qVhnqg9XsVk50MRfpmCE78VfkWi + ETVWpXE48eHnEJz4rfG76aajB9gnsxevoTg8y7ow2G/6p/FVG6/4jfGz/C08iKk0CuYjK7x+duzHapgn + 6hqvft6a+dXP4ZchOPGT9CsSjaixKo3DiQ8/h+DEb5WfLc7fX7qY90VucbANBw8Xeri60qnUP4uq45XP + Rvjt788faZ+a39TOX254i3VfnMHvv2uYJ+oar37emvnVz+GXITjxk/QrEo2osSqNw4kPP4fgxG+VnxWY + x9lCfscaisNXqyudSv2zqDpe+WyE39HRwd2s+P9mR+6y4gzFujPO4PeaG2+88QEa6rG6xquft2Z+9XP4 + ZQjOYrL5KxKNqLEqjcOJDz+H4MRvld9jH3vTfW1x/vNVFwcran809PCX1D+LquOVz8b47e7uflZX/nLi + DMW6M87iZ+P45xrqsWxsMb/hly048ZP0KxKNqLEqjcOJDz+H4MRvnZ8t5N+26uJgxf9tFhfVnVNq9q8R + k8xfI6r7Wa7e2+K1zdzlxlmKdVecxc+K/8KfeNrYYn7DL1tw4ifpVyQaUWNVGocTH34OwYnfOr/ZbO/A + Fue3rqE4fKu6c0rN/jVikvlrxFL8LE9Pb+UtK85SrLvijH5vsHPsoRpuzG/4FQlO/CT9kLF5f/1HI2qs + SuNw4sPPITjxW+d3881H97LF+Y9WXRzsk3/vw1+a/WvEJPPXiKX4WZ4+sSt/Y3HGYn0qKvg9WcON+Q2/ + IsGJn6pfuvX/OM9BFtxRqFbjMXnhly048cde9un/a9dQHO604w7VpQW1+6eYbP4US/G7cOHCvS1Xf9/K + 3WhUKNYLcVY/++T/OzbU4/wwLo3v1Hh5vVRw4sPPITjx4eeQcRR/7vg7vgHgAAvuJdzswJQGE35b5GfF + /4Itzm/uWrRzw1kcvk9dWlC7f4rJ5k+xND/L04+18jYaZy3W7Tirn51ft81msw/IGW+p4MSHn0Nw4sPP + IeMo/ul5P8MbAB3MU4T49J86MaXBhN8W+R0dHdzdFvTf6Vq0c8NZHF5iReE91a0TtfunmGz+FEvzs3x+ + eEfuBuOsxbodlfy+Mme8pYITH34OwYkPP4eMo57zlF+e9ps2AN3fAeAFC54fzKf/tAGY0mDCb8v87NP/ + F3cs1tnhLQ47Ozsfpm6dqKt/+nkr55cNkuXpb7ry1xeVivVJVPL7w8PDQy6PxvyGX7bgxE/Zj3pOnGwA + 9PKi7IW0U7jaIm0A8p4q1CE4i6knJ/wm7DebXbrOCszrOhbsrDhDcfgxdetEXf3Tz1s7vzY339+Ru96o + VKxPooafjeGtxt7IuDS+3vGWCE58+DkEJz78HIKz4Eo+9TxtAK7Sy4uyF9LvCDgwbQDGnyfcIziLqScn + /CbuZ58wf7Fr0c6JMxSHv+dLberasawvMR8tP8vTkcWdjbwNRo1i3YxafnaOfRPj0vh6x1siOPHh5xCc + +PBzCM4i1fC0AaC+91765/IXO4S0AWDnEMnOEJz48HMITvyCny3Mn9K1YOfEWYqDfSL8RHXtWNaXmI+W + n+X0apufv+zKX1fUKtYpKvr9+dHRIWvdSvNXIjjx4ecQnPht8ktX79MGgCv7vcWfLwWwO0gbACKSnSE4 + 8eHnEJz4Bb/5fH5/W5z/obVYZ8UZi8PT1bVjWV9iPjr8rPh/W0fuOqNisT6Oin5cvbii8Q2ON1dw4sPP + ITjx4ecQnHgibQCo54Nf+mtuAPp3CiMyLiYv/LIFJ/6Uny3MP9FYqLPjjMXhtca8l7oX89Hjd/HixR3T + 2zrydyoqFuvjqOz3vRrf4HhzBSc+/ByCEx9+DsGJTz5sALi61V/P7UWgtAHo/x3BiOSzrMGEX6HgxG+c + n326/MiOxXo0zlocrN3PVPdiPnr8eBiSFf8/7spfOyoX69p+L7rppqMHjI03V3Diw88hOPHh5xCc+KbX + +Hf4OMCCDQDfAYjinyE48eHnEJz4U3433HDD3W1xfmlrsR6NsxYHK2q/YV07Pv/ph/pzqn+8Xio48Rvv + Z5ukr+nKXzsqF+vqfrPZ3sfkjDdHcOLDzyE48eHnEJz4pl/eX+9xkEX/jQFGJH7TkhN+mYITvxI/W5z/ + c3uxHouzFgcr/m8y7n1z+lcqOPEb72d5+kDL1+3t/LWjdrGu77f3tJzx5ghOfPg5BGcBj0+K8MsUnIU/ + f3agq/AjGlFjvsZbghMffg7Bid9IPyswN3ct2ENRozjYp9ovzelfqeDEnwc/Hvbz7K78NaN+sa7rZ3P9 + iitXDq7JGO+o4MTn5G9UcOLDzyE48eG3bNGIGqvSOJz48HMITvxG+l24cOHdbIF+QXvBHopKxeF3b731 + Vq6AxXwM+Fnh/KKO3C1E7WK9JL9PyRnvmODEZ+VvTHDiw88hOPHht2zRiBqr0jic+PBzCE78xvrZAv3/ + tBfsoahUHN5icT39UH96+1ciOPHnwu/ixYvvY3l6YyNvp2JJxbq239NzxjsmOPFZ+RsTnPjwcwhOfPgt + WzSixqo0Dic+/ByCE7+xfrZAozssOhfvdtQqDvap9uvoh/rT278SwYk/N36Wq19r564ZSyrWVf1srl+9 + vz97v5zxDglOfHb+hgQnPvwcghMffssWjaixKo3DiQ8/h+DEb6zfdddd9862SP9Je9Hui4rF4U8e9ahH + coOMlY63RHDi1+ZnOX5SR+5OYhnFehl+s9ne5+SMd0hw4rPzNyQ48eHnEJz48Fu2aESNVWkcTnz4OQQn + fqP9+BTetXB3RcXicMelS7tz9Wewf7mCE39u/Obz+QMtV69p5e4kllWsa/vZOfbrOeMdEpz47PwNCU58 + +DkEJz78li0aUWNVGocTH34OwYnfaD9bnD/IFmp+D9+5gDejZnHY2dn5LvVnsH+5ghN/rvwsTz/XlT9i + WcW6tp8V/zfv788/KGe8fYITX5S/PsGJDz+H4MSHn1PG5v31H42osSqNw4kPP4fgxG+0H9+8t4X6f7UX + 7q6oXBxeMJ/v3X+sf7mCE3+u/CxPH9fK20ksq1gvx+/SV+WMt09w4ovy1yc48eHnEJz48HPIuHTr/3Ge + gyy4o1CtxmPywu9Y9snsS7oW73bULg7z+ezxOf3LEZz4c+Vnn/zvZfGKrvzVno8l+z3ncY97zD3Gxtsn + OOWrKH99ghMffg7BiQ8/h4yj+HPH3/ENAAdYcC/hZgemNJjw21A/W5jf1wrMm7oW8GbULg626fiRnP7l + CE78ufOzPP1oV/6WXKyr+tkYXj+b7R3/iaeGVSQ45as4f12CEx9+DsGJDz+HjKP4p+f9DG8AdDBPEeLT + f+rElAYTfpvrdxcr/r/RtYA3o35x2HvZfL733hn9GxWc+JzxjgpO/Nr9LFcf0s4dscxivQw/K/5PzBlv + l+CUr+L8dQlOfPg5BCc+/BwyjnrOU3552m/aAHR/B4AXLPjzKD79pw3AlAYTfhvsZ5/MPrNrAW/GkorD + J+b0b0xw4rPGOyY48Wv3m8/nd7V8vbgnf41YfL00lu+39z054+0SnPJVnL8uwYkPP4fgxIefQ3AW1HPi + ZAOglxdlL6SdwtUWaQOQ91ShDsFZTD054bdCP1uwn9tewJuxpOLws7n9GxKc+OzxDglO/CT8bHP2lJ78 + NWLx9dJYtp+N4Zce//gPeycNqUjkSfly5a8tOPHh5xCc+PBzCM6CK/nU87QBuEovL8peSL8j4MC0ARh/ + nnCP4CymnpzwW7GfLdqf3V7EUyyjOFhBeNXBwf7DcvvXJzjxRePtE5z4Sfjt7OxcsZzd2c5f7flYrt/e + 791446PuqiEViTwpX678tQUnPvwcghMffg7BWaQanjYA1PfeS/98O5AdQtoAsHOIZGcITnz4jUh3/lvZ + ZWbbALzssY+96b65/esSnPji8XYJTvwk/A4PD9/VNgDP78pf7flYnt/en1y6tHsfDalI5En5cuWvLTjx + 4ecQnPjwcwjOIl29TxsAruz3Fn++FMDuIG0AiEh2huDEh1+mbAH/nOHFfHGxL42232w2+9KS/jUFp/G5 + x9sUnPjJ+FnOvmUof7Xno77f3h/v7Fy8r4ZTJPKkfLnz1xSc+PBzCM4CHp8U4ZcpOAt4Im0AqOeDX/pr + bgD6dwojMi4mL/xGpasAL+lezLsX/dzo8rNPt39zyy23vIuazxbj0vjONN4kOPGT8bOcXbD8vG0of+k1 + Tyzfb++Z1v97aDhFIk/Klzt/TcGJDz+H4MSHn0Nw4pMPGwCu5PfXc3sRKG0A+n9HMCL5LGsw4VcoOPGT + 9Nvd3f28VRYb2lPTWWJcGl+V8cKJn4zfhQsX3smK5x/l5M8Ty/fb+2Ee6KThFIk8KV/u/DUFJz78HIIT + H34OwYlveo1/h48DLNgA8B2AKP4ZghMffg7BPfaxN9/bivJL376Ydy/6uTFWbEquAtA/ja/aeMVPys/y + 8lUpP2P5K41l+tl58+bZbO/JpeNNglO+zpS/JDjx4ecQnPjwcwhOfNMv76/3OMii/8YAIxK/ackJv0zB + ia/uZ4v6l9YuDkN+Vjg+V93oVbN/jZhk/hpR7Gf5eLjl4zbykpu/3Fiy3x9b8d8tHW8SnPJ1pvwlwYkP + P4fgxIefQ3DifX52oKvwIxpRY77GW4ITH34OwYnfCD++nW9F6G+7Fv3cKCw2L+H7B+rOKbX7p5hs/hQe + v3ewXDyLnCy5WNf0e6MV/q+5+eajuLd/puDEh59DcOK3wq9INKLGqjQOJz78HIITv1F+trA/uWvhzwln + sfkcdWlB1petmQ/LwReQiyUW62p+tkF8q/33D165cvAB3vEiOPFnzh+CEx9+DsGJDz+H4MRX8SsSjaix + Ko3DiQ8/h+DEb5wfv5ff2dkpvgpwhmJz6ioA/VB/TvVPhxQJTvzk/Gz811i8YRnFuqafFX7r49737+/P + eKDPZPKH4MSHn0Nw4sPPITjxVfyKRCNqrErjcOLDzyE48RvrZwv953cVgb6oUGw+W01v3XzYZutXahfr + Wn7WN/4c8deN/9ybbjp6rxrjhRNfJX9w4sPPITjx4ecQnPgqfkWiETVWpXE48eHnEJz4jfbTneiyrgJU + KjYv5ioA/VB/BvuXKzjxk/SzcX96rWKd4ix+Nuevs3//P/u0/x8snjCbze6t8VUZL5z48HMITnz4OQQn + fpJ+RaIRNValcTjx4ecQnPhz4WeFYPS7ADWLlxWfz1Z/svo3Jjjxk/S7cOHCe1nOXlMrf0TOfFief8r+ + RY+3//4wi5ut0D/KYuHOfYxL46syXjjx4ecQnPjwcwhO/CT9ikQjaqxK43Diw88hOPHnxo+rAFYkXmpx + qogQNYs/YR4vuXx5fp/c/g0JTnz2eIcEJ76an4335+vmL6v4v7Jd6LtE/zS+auMVH34OwYkPP4fgxE/S + Dxmb99d/NKLGqjQOJz78HIITf+78rGgcfzu9HfWLf/K79IUl/esSnPji8XYJTnw1PxvnJy8nf8N+u7u7 + n6Ju9Ir+aXzVxis+/ByCEx9+DsGJn6pfuvX/OM9BFtxRqFbjMXnh1ysrJldb4XhZs4jkFpvcaPm95Ojo + 8j1z+9cWnMbnGm9bcOKr+V2+fPAQK8SvWFL+ev2szV9UN3pF/zS+auMVH34OwYkPP4fgxE/Vj+LPHX/H + NwAcYMG9hJsdmNJgwu8c+lnh+MJURHKLTW50+Vl7n6Wmi8S4NL4zjTcJTnxVPxvn05rj7cpLbuTOx87O + zusuXLjw3upKp1L/LKqOVz7hVyg48eHnEJz4qfpR/NPzfoY3ADqYpwjx6T91YkqDCb9z6meF5fgqQG6x + yY0+PytWL+ShOGo+S4xL4zvzeBGc+Kp+NsaPXnb+usI2VYO3XE79s6g6XvmEX6HgxIefQ3Dip+pHPecp + v/zlU9oAdH8HgBcseH4wn/7TBmBKgwm/c+5nxeXLc4tNTmQUr89Q86OifxpftfGKr+rH39FbIX7xivJ3 + Erah+i3rRu8XjFL/LKqOVz7hVyg48eHnEJwFPD4ppuZHPSdONgB6eVH2QtopXG2RNgB5TxXqEJzF1JMT + fhPzOzq6fH8rXvq9dXehyY2c4pV7FSD1z6LqeOVT1c/G+v2ryl8Ky+ObLd5P3TmlZv8aMcn8NSL8MgUn + PvwcghNf048r+dTztAG4Si8vyl5IvyPgwLQBGH+ecI/gLKaenPCbqN9stvcVqyxeFv9CXelUu3+KSeZv + Pp/dYuO9c8X549L/l6s7p9TsXyMmmb9GhF+m4MSHn0Nw4mv6pRqeNgDU995L/3w7kB1C2gCwc4hkZwhO + fPg5BCf+xO/y5f372afJl3cVmpwoLV7W1l/3XQXo6p9+nlz+eMKijff5ayj+v394eNj56aLZv0ZMMn+N + CL9MwYkPP4fgxNf0S1fv0waAK/u9xZ8vBbA7SBsAIpKdITjx4ecQnPhTflZY/mW70OREafFKYcc+Sd06 + Ef1Qf071T4cUCU78UvxsDN++6uJvm6e3WjxSXVpQu3+KyeZPEX6ZghMffg7Bia/tR6QNAPV88Et/zQ1A + /05hRMbF5IVftuDEd/rZJ/J3s8Lyiq6i0xfe4q94QfNTLP1Qfzr7Vyo48UvxOzjYv2yfxHl8btfYssKZ + v29UlxbU7p9isvlThF+m4MSHn0Nw4pfhx79sALiS31/P7UWgtAHo/x3BiOSzrMGEX6HgxG+0nxW0L+ko + OJ1xxuJ/HNbeP6dd+qH+DPYvV3Dil+J3881H97L+/1F7PCXhzN+f8UhndetE7f4pJps/RfhlCk58+DkE + J35Zfvz3+Hf4OMCCDQDfAYjinyE48eHnEJz4Ub/cqwA1ir/iBY9+9CFXwtYy3hzBiT/xs35/bWscReHM + 35127L66daKu/unnjTv/cgQnPvwcghMffg7BiW/65f31HgdZ9N8YYETiNy054ZcpOPFr87NP5V/aUXxO + omLxPw7jP6ekf0OCE780P+vvBdskvblrLDlxhvx9t7p1oq7+6eeNPf+GBCc+/ByCEx9+DsGJ9/nZga7C + j2hEjfkabwlOfPg5BCf+XPlxFcA2AX/XUYDOUrw6Q35/zSX13P71CU580Xj7BCf+xO/o6OBulpvf7hpL + TnjzZxuOFx4eHr6Hunasrv7p540+//oEJz78HIITH34OwYmv4lckGlFjVRqHEx9+DsGJP5d+VuS+rF2E + llT8j2M22+MqwOTzZ3n5/K6x5MRZ8mcbgMepa8eyvpzr868tOPHh5xCc+PBzCE58Fb8i0Ygaq9I4nPjw + cwhO/Ln1u/7669+9eRVgmcWfsP93/F0ANV8kxqXxucfbFJz4Bb+LFy9eY4X49e2x5MQZ8/dD6tqxrC/n + /vxrCk58+DkEJz78HIITX8WvSDSixqo0Dic+/ByCE3/u/azw/CsK0LKLf8PviWo6W4xL4zvzeBGc+FN+ + 1r9npDGUxFnyZxuOlxtzT3Vvq84/BCc+/ByCEx9+DsGJr+JXJBpRY1UahxMffg7Bid8KvxtvfNRdrfj8 + g7d4dcVQMdzd3f3LvrvbdYlxaXxVxgsn/pSfFeJPbY4jN85S/AnLyRPUva07/+DEh59DcOLDzyE48VX8 + ikQjaqxK43Diw88hOPFb5Teb7X2tt3i1I7MYZl0FSP2zqDpe+Sz4WZ+4TfIrW/0cjQrF/6fVvY05X+QT + foWCEx9+DsGJn6RfkWhEjVVpHE58+DkEJ37r/HjMrRWvV66o+HPJ+y9uvfXW7sdnSs3+NWJp+bN+/WS7 + n2Nx1uJv8WrLxf1z+lcqOPHh5xCc+PBzCE78VvghY/P++o9G1FiVxuHEh59DcOK31s+K0UpvesPldnXn + lLr6p5+Xkj/ry0d19XEoKhR/Pv1/ek7/SgUnPvwcghMffg7BWcDjk+I8+6Vb/4/zHGTBHYVqNR6TF37Z + ghO/4Hd0dPieVpT+oV2kcsJTDPuuAlhfVpq/G2644e7Wn5e1+zcUNYq/jf+Xc/pXKjjx4ecQnPjwcwhO + /Lb4Ufy54+/4BoADLLiXcLMDUxpM+G2xn30i/YquYjUUZymG1t6nHHdMoh/qT2f/SgUnvtfPCvEPdPWt + L2oUf4s3WFxDP9Sf3v6VCE58+DkEJz78HIITvy1+FP/0vJ/hDYAO5ilCfPpPnZjSYMJvy/3m8/ldrTBl + XwU4azG04vv8dBWAfqg/vf0rEZz4Xj/r82O6+tUXlYo/8QX0Q/3p7V+J4MSHn0Nw4sPPITjx2+JHPecp + vzzjJG0Aur8DwAsWPD+YT/9pAzClwYRf+B0r9ypArWJo7X0y/VB/RvuXIzjxvX7cBMk2IH/d1aeuqFj8 + n3XttQ/lkuFKx1siOPHh5xCc+PBzCE78lP2o58TJBkAvL8peSDuFqy3SBoCIZGcITnz4OQQnPsuPqwBW + GAf/HK5iMST+/HGPe8w9cvs3Jjjxg3628fiujr50Rq3xWpu3GfuB6s9g/3IFJz78HIITH34OwYnfJj+u + 5FPP0wag+74m9kL6HQEHpg3A+POEewRnMfXkhN+G+1mx+sp28UpRufgf87PZ3meU9K9PcOIHx2sbnJm1 + fUe7L11Rebxfrf4M9i9XcOLDzyE48eHnEJz4bfJLNTxtAKjvvZf+udTHDiFtANg5RLIzBCc+/ByCE1/s + Z59U37PrKsAyir+8nv+4x918z9z+dQlO/OB4b7nllnexsT2vqz/tqDzePzw6uswYB/uXKzjx4ecQnPjw + cwhO/Db5pav3aQPAlf3e4s+XAtgdpA0AEcnOEJz48HMITrzbzwrWVzUL2BKL/3HM57MnlfSvKTiNb3S8 + trn5+q7+tKPmeG3D8TYb35Wc/uUITnz4OQQnPvwcghO/bX5E2gBQzwe/9NfcAPTvFEZkXExe+GULTvyZ + /HQV4FUUsGUXf/n9mTVbPGbGpfGNjtfGdIO185ZmX7qi/nj3vjOnfzmCEx9+DsGJDz+H4MRvox//sgHg + Sn5/PbcXgdIGoP93BCOSz7IGE36FghO/FX5WvP5N/WLY72cbjk9U01liXBrf6Hj5c0Nr43+ntvqi9nht + 0/GXR0eX7z/WvxzBiR8db47gxIefQ3Diw88hOPGb4sd/j3+HjwMs2ADwHYAo/hmCEx9+DsGJr+a3vz97 + kBWwV9cqhmPF1dr6U2s6q7/0T+PLGq95f1mzra6oXfyNv9PiQ3L6NyY48VnjHROc+PBzCE58+DkEJ36T + /PL+eo+DLPpvDDAi8ZuWnPDLFJz4yftZAfvGSsVQRXW4uFqh/gR1o1fN/jWid7zm+7CdnZ03tdtqRm7/ + ckN+/29O/8YEJz5rvGOCEx9+DsGJDz+H4MSfTz870FX4EY2oMV/jLcGJDz+H4MRvpd/BwfzBVshe01Xk + cqOkuPINfetGb9/b/VMMjfcu5vvMdjvNWFLx/5ujo8sPyujfoODE5453UHDiw88hOPHh5xCc+K3wKxKN + qLEqjcOJDz+H4MRvtZ99Knc/KdBTXPuuAlhfisdrfp/d9m/Gkor//53NZrfm9G9IcOKzxzskOPHh5xCc + +PBzCE78VvgViUbUWJXG4cSHn0Nw4rfeT0/MK74K4C2uXVcB6If6c6p/OuSULl68+GDzel1XG8Syir/9 + 93/L6d+Q4MRnj3dIcOLDzyE48eHnEJz4rfArEo2osSqNw4kPP4fgxIefZEWt6CpAheL68WraPV4r/r/Q + 4XscSyz+f39wMH9oTv/6BCe+aLx9ghMffg7BiQ8/h+As4PFJcW79ikQjaqxK43Diw88hOPHh11DJVYBK + xfVPrFn65hqv8Z/U8juJZRV/Yjbb+/Sc/vUJTnzRePsEJz78HIITH34OwYnfCr8i0Ygaq9I4nPjwcwhO + fPh1yIrdv20Xv3ZULq4fr/5k9S/p4ODgPsZ2PtZ4mcV/d3f3f+b0r09w4ovG2yc48eHnEJz48HMITvxW + +BWJRtRYlcbhxIefQ3Diw69HY1cB6hfXvecdHR3cPbd/SVaIf7zbr3b/Fvxee3Cw//45/esSnMaXPR9D + ghMffg7BiQ8/h+DEb4UfMjbvr/9oRI1VaRxOfPg5BCc+/EZkxfXrMorh8c9dx+VG8pvPZ08s7N9HDPnV + 7l+K2Wzv83P61yU4ja94ProEJz78HIITH34OwYnfFr906/9xnoMsuKNQrcZj8sIvW3DiXX4HBwf3sAL4 + 2qFiWLm4/unR0QF9HO3fhQsX7razs/O3I37HP7ePKYnTfnvPzM1fW3DKv2s+2oITH34OwYkPP4fgxG+L + H8WfO/6ObwA4wIJ7CTc7MKXBhF/4jco+ZZ88UW/5xfX4vgAfq6YHZcf9pxy/9jElcdpv7037+/OHqQtF + Iu/K/5nmIwlOfPg5BCc+/ByCE78tfhT/9Lyf4Q2ADuYpQnz6T52Y0mDCL/yylK4CLL+4nrz2XGt28Pdr + VvxvanoRK+rfl6gLRSLvyv+Z5wPBiQ8/h+DEh59DcOK3xY96zlN+edpv2gB0r1G8YMHzg/n0nzYAUxpM + +IVftuCs8H1rRzF0x1ixtgL/BDV/ShcuXHg3O+avmseP+ZVGl5/16Tk8ZVDdyBb5U/6rzYf48HMITnz4 + OQQnfpv8qOfEyQZALy/KXkg7hast0gYg76lCHYKzmHpywu+c+125cnCNFcDXL6u4to/Z2dn5Y2u+c4dt + r39H89gcv5Lo8bv94sWLj1AXspXyZ1F1PuQTfoWCEx9+DsGJ3yY/ruRTz9MG4Cq9vCh7If2OgAPTBmD8 + ecI9grOYenLCb0v8rBh+25KKa198jLpyIvt/6A6L42MK/UZjwO9r1YVstfOnmOz8KsIvU3Diw88hOPFT + 9ks1PG0AqO+9l/75diA7hLQBYOcQyc4QnPjwcwhO/NL8Ll8+eMjQvfbHorRYW1t/ZF05ebNdd91172z/ + //+k10v9xmLA77m0rW5kqSt/+jnOvwzBiQ8/h+DEh59DcBbp6n3aAHBlv7f486UAdgdpA0BEsjMEJz78 + HIITv3Q/K4bfmApmSZyhWH+0urVwZ8Iz+HXGgN8d9vOuupAl8qR8ncqfDikSnPjwcwhOfPg5BCd+2/yI + tAGgng9+6a+5AejfKYzIuJi88MsWnPiV+Nmn8ntZvL5ZPMfijMX6D63Zuxj3Qfbfb+H/ndHvVAz57e7u + fjvjzhV5Ur4681cqOPHh5xCc+PBzCE78NvrxLxsAruT313N7EShtAPp/RzAi+SxrMOFXKDjx4deQFcVv + ahbQoahRrK29W+3f/8V/1/BrxpCftfuX/MWBhj0q8qR8DeYvV3Diw88hOPHh5xCc+G3147/Hv8PHARZs + APgOQBT/DMGJDz+H4MSv3C/3KkDFYv1G/q3odxxjfrYBeLSGPCrypHyN5i9HcOLDzyE48eHnEJz4bfbL + ++s9DrLovzHAiMRvWnLCL1Nw4s+NnxXHb24Wy3asuliXxpifje8/aaijIk/KV3b+hgQnPvwcghMffg7B + WcDjkyL8+mQHugo/ohE15mu8JTjx4ecQnPjwG9CFCxfu3XcVYNXFujTG/Gxcf8tzBjTUQZEn5asof32C + Ex9+DsGJDz+H4MSH37JFI2qsSuNw4sPPITjx4ZehrqsAqy7WpZHp93gNcVDkSfly5a8tOPHh5xCc+PBz + CE58+C1bNKLGqjQOJz78HIITH36Z4iqAFcs3pMK5pmKdHTl+tqn5cQ1vUORJ+XLnryk48eHnEJz48HMI + Tnz4LVs0osaqNA4nPvwcghMffoWyovktFM51FOuSyPT7h4ODg/toaL0iT8rXmfOH4MSHn0Nw4sPPITjx + 4bds0Ygaq9I4nPjwcwhOfPg5dPnywf2soL4xo7hmx5qKP/FJGlavyJPyVSV/cOLDzyE48eHnEJz48Fu2 + aESNVWkcTnz4OQQnPvwcgoO3ovpdGcU1K9ZV/Hd2dn5Bw+pVGq9F1fzJJ/wKBSc+/ByCEx9+yxaNqLEq + jcOJDz+H4MSHn0Nw4u92eHjlWiuub9rg4v+6ixcvPlhD61RzvI2Y5Hw0IvwyBSc+/ByCE78VfsjYvL/+ + oxE1VqVxOPHh5xCc+PBzCE78iZ8V2O/qKq65sa7ir/hsDa1TXePVz3G+ZAhOfPg5BCc+/ByCE1/LL936 + f5znIAvuKFSr8Zi88MsWnPil+s3n8/tbIT2+Y19prLn4P9OG1buTt7HF/IZftuDEh59DcOKn6kfx546/ + 4xsADrDgXsLNDkxpMOEXftmCE9/pt7u7+20dBXYw1ln8d3Z23mz/Pux4cB1iXBpf53hLBSc+/ByCEx9+ + DsGJDz+HjKP4p+f9DG8AdDBPEeLTf+rElAYTfuGXLTjxvX5WTO9nkX0VYJ3Fn7ANy5ep66fEuDS+3vGW + CE58+DkEJz78HIITH34OGUc95ym/PO03bQC6rxzyggXPD+bTf9oATGkw4Rd+2YITP+pnRfXbu4ptO9Zd + /C3+96233vqO6vaCGJfGNzreHMGJDz+H4MSHn0Nw4sPPITgL6jlxsgHQy4uyF9JO4WqLtAHIe6pQh+As + pp6c8Au/Y1lhvd/Ozs6bWsV2ISZQ/N9icb26vCDGpfFljXdMcOLDzyE48eHnEJz48HMIzoIr+dTztAG4 + Si8vyl5IvyPgwLQBGH+ecI/gLKaenPALvwVZcf2ORrFdiAkUfy79f4O6uiDGpfEVjbdPcOLDzyE48eHn + EJz48HMIziLV8LQBoL73Xvrn24HsENIGgJ1DJDtDcOLDzyE48Wv3syLbeRVgCsXf+vW8W2655V3U1RMx + Lo2veLxdghMffg7BiQ8/h+DEh59DcBbp6n3aAHBlv7f486UAdgdpA0BEsjMEJz78HIITPxk/K7b/T7Pw + TqH4W9xhG4CZungixqXxucfbFJz48HMITnz4OQRnAY9PivDLFJwFPJE2ANTzwS/9NTcA/TuFERkXkxd+ + 2YITPyk/K7T3T1cBJlL8ufT/XereiRiXxnem8SbBiQ8/h+DEh59DcOLDzyE48cmHDQBX8vvrub0IlDYA + /b8jGJF8ljWY8CsUnPjwc8g2AN81leJvffnr66+//t3VtWMxLo2vynjhxIefQ3Diw88hOPHh5xCc+KbX + +Hf4OMCCDQDfAYjinyE48eHnEJz4yfrNZpceZp+637zu4q94rLp2LPqn8VUbr/jwcwhOfPg5BCc+/ByC + E9/0y/vrPQ6y6L8xwIjEb1pywi9TcOK3zs8K7/etu/jbJuS/qGvHavavEZPMXyPCL1Nw4sPPITjx4Zcj + O9BV+BGNqDFf4y3BiQ8/h+DEh59DcOKPvWazvffnKkBXYc6NM37yf9nBwcE91L2Y3/ArEpz48HMITvxW + +BWJRtRYlcbhxIefQ3Diw88hOPELfrYB+O6OwpwVZyz+/O7/o9S9mI/wKxKc+PBzCE78VvgViUbUWJXG + 4cSHn0Nw4sPPITjxp/zm8/kDbRNwW1eBHooKxf+n1L2Yj/ArEpz48HMITvxW+BWJRtRYlcbhxIefQ3Di + w88hOPG9flaQi64CVCj+r7J/70fb9EP96e1fieDEh59DcOLDzyE48eHnEJz4Kn5FohE1VqVxOPEb63d4 + ePiu9gnxQ23B/ncWP2GL9y/bv7/aE79mBeE328H/bx2XG+fSTzn8ScvrN9nxH37hwoV3I9fkXfnvnY8S + wYkf9LM+vFfuVYCzFn/Cxv+ptEs/1J/B/uUKTnz4OQQnPvwcghMffg7Bia/iVyQaUWNVGocTv5F+tlDz + +FjuG//atHCPRY3i0Ixt8bOC+Dp+F8+f5vXNR6ngxGf5WT++p92vdlQa7zNoj36oP1n9GxOc+PBzCE58 + +DkEJz78HIITX8WvSDSixqo0Did+I/2sGH26LdTZhZ+oVQxTbKOf5f31s9neF7Tno1Rw4jvnt0s2hsGr + ADXGaxsdG9/sIfRD/cnu35DgxIefQ3Diw88hOPHh5xCc+Cp+yNi8v/6jETVWpXE48ZvodxcrAv+ha/Ee + imUUw232szn4gWuvfWj3Yy1HxDxqPrvmd1DW7vfm9M87XmM/n36oP8X96xKc+PBzCE58+DkEJz78HIIT + X8sv3fp/nOcgC+4oVKvxjU62LdILD4nJiWUXwy32e+rxpBWIedR8ds7vmGwD8KD2VYBa4zXf32ZTo/64 + +tcWnPjwcwhOfPg5BCc+/ByCE1/Lj+LPGjO+AeAAC+4l3OzAlAazUj9bpD+pvWiPRa3ikCL8Fl+3ovnP + jycvQ8yj5rNzfnPVvApQa7xsKubz2XXqz5n6lwQnPvwcghMffg7BiQ8/h+DE1/Kj+Kfn/QxvAHQwTxHi + 03/qxJQGs1I/W9zvubOz88quxbsvahWHFOHXedxrZrPZfY8ncUDMo+azc35LZMX6Qdbu7TXHa55fqf6c + uX8ITnz4OQQnPvwcghMffg7Bia/lRz3nKb887TdtALq/A8ALFjw/mE//aQMwpcGs3M8W6K/vWrj7omZx + IMKv+zjC5ubbNE2dYh41n73zWyI4a/c/5/YvI/7g5puP7tHo25n7Jz78HIITH34OwVnA45Mi/DIFZ1E7 + f9Rz4mQDoJcXZS+kncLVFmkDkPdUoQ7BWdQezEr9br311ne0T/8v71i4O2OdxTAnzpufzc2rrrvuunfW + dC2IedR89s5vieDg5/O9D7S+3X7W8Vrf33pwsH+gflXrn3zCr1Bw4sPPITjx4ecQnPiaflzJp56nDUD3 + l6fthfQ7Ag5MG4Dx5wn3CM5i6skZ9bOF+qC9cPfFuovhWJxjv4XH5SLmUfM5OL+5ghN/7GX9+3/POl6L + 70h+imr9U4RfpuDEh59DcOLDzyE48TX9Ug1PGwDqe++lf74dyA4hbQDYOWx9snd3d7+0Y+E+FRMqhp1x + nv1sjv6NputYzKPmc3R+cwQn/sRvNrt0nbV9e7svuWFj/Iubbjq6X8Ozav/0c/hlCE58+DkEJz78HIIT + X9MvXb1PGwCu7PcWf74UwO4gbQCISLbJFuvvay/e7ZhSMeyKLfD7IU3XSs8Xa3f03OgKG9+d8/nslraf + miwSnPhT/dMhRYITH34OwYkPP4fgxIefQ3DiibQBoJ4PfumvuQHo3ymMyLhzl2xbsH+svYA3Y4LFcCG2 + wW9nZ+fnmCvmUfOZPb9DghPf6XfhwoX3tvbf0u7PUGh8/6nLr1Rw4jv7Vyo48eHnEJz48HMITnz4OQQn + PvmwAeBKfn89txeB0gag/3cEI5LPsgazNj9brH+ouYA3Y4rFsBlb5PeTzKPms2h++wQnftDPNh/f39Gf + ztB4X3J0dPlBfX65ghM/2L9cwYkPP4fgxIefQ3Diw88hOPFNr/Hv8HGABRsAvgMQxb8lW7i/sb2QExMu + hsexZX7fqfksnt8uwYkf9ePe/db+6FWANF47/glDfjmCEz/avxzBiQ8/h+DEh59DcOLDzyE48U2/vL/e + 4yCL/hsDjEj8piUn288W74/rW8wrFa/wO6PfbLb32d75bQtOfLbf7u7uf+zqV4rGeH88x29IcOKz+zck + OPHh5xCc+PBzCE58+DkEJ97nZwe6Cj+iETXma7wlOPGT8Ts4OLjPzs7O2zoWc8XpBb8kwq/7uNww/s7L + l/cf7p3fpuDEF50v1o9rLDqvAqTx2ibh765cObgmx69PcOKL+tcnOPHh5xCc+PBzCE58+DkEJ76KX5Fo + RI1VaRxO/OT8bCF/enMxr1i8wq/juNyQ32+edX4RnHjX+WIF/j/19O845vPZE0v82oIT7+pfW3Diw88h + OPHh5xCc+PBzCE58Fb8i0Ygaq9I4nPhJ+tkCfnlJxSv8nJH8ZrO9Dz/r/MKJd58vtgF4qPXr5CpAa7z/ + o9SvKTjx7v41BSc+/ByCEx9+DsGJDz+H4MRX8SsSjaixKo3DiZ+0ny3iP/H2Bf10QSqJZRXDbfOzovtz + teZXPmc6X6xv/7nZP8VrZrNLD/P4ITj158z9Q3Diw88hOPHh5xCc+PBzCE58Fb8i0Ygaq9I4nPjJ+83n + e+9tBeevploMt83P5uJFBwfzh9aa30a4/ax/11q/3toa7+d6/eDUnyr9gxMffg7BiQ8/h+DEh59DcOKr + +BWJRtRYlcbhxG+M3+XLBzfYIv+SZkEqiWUVwy30e/nBwf6O5mdS54v17UfePt7j7ydszftDP4dfhuDE + h59DcOLDb9miETVWpXE48RvnZ5/wHmTxnK4CNRQbVFwn7We5/8PLl/cfkeZDU1YkOPGn5leHFAlO/N32 + 92fX6yrAm6zf1+qQIjX9GjHJ8TYi/DIFJz78HIITH35OGZv31380osaqNA4nfmP9Dg8Pr7JF/kt4FG27 + UHXFphTXifu9djbb+9qjo8v3bs9HieDE985vieDEn/jZufEjFl+sQ4rU5aefN+b9USI48eHnEJwFPD4p + wi9TcBbblL906/9xnoMsuKNQrcbPVbJtI/AeVqD+hcUzLF6bClYzNqS4TtLPNlivt0L665cu7X7RlSv7 + G3P7XBv3A+zlYk9jz9X7Y0xw4sPPITjx4ecQnPht8aP4c8ff8Q0AB1hwL+FmB6Y0mMn5WdG6n8XDL168 + +AgrXtdb8btkMWvEJf4/r5fGNvmRQyv8Dzw6OmjORfF8NAUnPvwcghMffg7BiQ8/h+DEh59DxlH80/N+ + hjcAOpinCPHpP3ViSoMJv/DLFpz48HMITnz4OQQnPvwcghMffg4ZRz3nKb887TdtALq/A8ALFjw/mE// + aQMwpcGEX/hlC058+DkEJz78HIITH34OwYkPP4fgLKjnxMkGQC8vyl5IO4WrLdIGIO+pQh2Cs5h6csIv + /LIEJz78HIITH34OwYkPP4fgxG+TH1fyqedpA3CVXl6UvZB+R8CBaQMw/jzhHsFZTD054Rd+WYITH34O + wYkPP4fgxIefQ3Dit8kv1fC0AaC+917659uB7BDSBoCdQyQ7Q3Diw88hOPHh5xCc+PBzCE58+DkEJz78 + HIITX9MvXb1PGwCu7PcWf74UwO4gbQCISHaG4MSHn0Nw4sPPITjx4ecQnPjwcwhOfPg5BCe+th+RNgDU + 88Ev/TU3AP07hREZF5MXftmCEx9+DsGJDz+H4MSHn0Nw4sPPITjxy/DjXzYAXMnvr+f2IlDaAPT/jmBE + 8lnWYMKvUHDiw88hOPHh5xCc+PBzCE58+DkEJ35b/fjv8e/wcYAFGwC+AxDFP0Nw4sPPITjx4ecQnPjw + cwhOfPg5BCc+/ByCE79Mv7y/3uMgi/4bA4xI/KYlJ/wyBSc+/ByCEx9+DsGJDz+H4MSHn0Nw4s+nnx3o + KvyIRtSYr/GW4MSHn0Nw4sPPITjx4ecQnPjwcwhOfPg5BCc+/JYtGlFjVRqHEx9+DsGJDz+H4MSHn0Nw + 4sPPITjx4ecQnPjwW7ZoRI1VaRxOfPg5BCc+/ByCEx9+DsGJDz+H4MSHn0Nw4sNv2aIRNValcTjx4ecQ + nPjwcwhOfPg5BCc+/ByCEx9+DsFZwOOTIvyWIRpRY1UahxMffg7BiQ8/h+DEh59DcOLDzyE48eHnEJz4 + 8Fu2aESNVWkcTnz4OQQnPvwcghMffg7BiQ8/h+DEh59DcOLDb9miETVWpXE48eHnEJz48HMITnz4OQQn + PvwcghMffg7BiQ8/p4zN++s/GlFjVRqHEx9+DsGJDz+H4MSHn0Nw4sPPITjx4ecQnPjwc8i4dOv/cZ6D + LLijUK3GY/LCL1tw4sPPITjx4ecQnPjwcwhOfPg5BCe+lh/Fnzv+jm8AOMCCewk3OzClwYRf+GULTnz4 + OQQnPvwcghMffg7BiQ8/h4yj+Kfn/QxvAHQwTxHi03/qxJQGE37hly048eHnEJz48HMITnz4OQQnPvwc + Mo56zlN+edpv2gB0fweAFyx4fjCf/tMGYEqDCb/wyxac+PBzCE58+DkEJz78HIITH34OwVlQz4mTDYBe + XpS9kHYKV1ukDUDeU4U6BGcx9eSEX/hlCU58+DkEJz78HIITH34OwYnfJj+u5FPP0wbgKr28KHsh/Y6A + A9MGYPx5wj2Cs5h6csIv/LIEJz78HIITH34OwYkPP4fgxG+TX6rhaQNAfe+99M+3A9khpA0AO4dIdobg + xIefQ3Diw88hOPHh5xCc+PBzCE58+DkEJ76mX7p6nzYAXNnvLf58KYDdQdoAEJHsDMGJDz+H4MSHn0Nw + 4sPPITjx4ecQnPjwcwhOfG0/Im0AqOeDX/prbgD6dwojMi4mL/yyBSc+/ByCEx9+DsGJDz+H4MSHn0Nw + 4pfhx79sALiS31/P7UWgtAHo/x3BiOSzrMGEX6HgxIefQ3Diw88hOPHh5xCc+PBzCE78tvrx3+Pf4eMA + CzYAfAcgin+G4MSHn0Nw4sPPITjx4ecQnPjwcwhOfPg5BCd+mX55f73HQRb9NwYYkfhNS074ZQpOfPg5 + BCc+/ByCEx9+DsFZwOOTIvwyBWdxfvNnB7oKP6IRNeZrvCU48eHnEJz48HMITnz4OQQnPvwcghMffg7B + iQ+/ZYtG1FiVxuHEh59DcOLDzyE48eHnEJz48HMITnz4OQQnPvyWLRpRY1UahxMffg7BiQ8/h+DEh59D + cOLDzyE48eHnEJz48Fu2aESNVWkcTnz4OQQnPvwcghMffg7BiQ8/h+DEh59DcOLDb9miETVWpXE48eHn + EJz48HMITnz4OQQnPvwcghMffg7BiQ+/ZYtG1FiVxuHEh59DcOLDzyE48eHnEJz48HMITnz4OQQnPvyW + LRpRY1UahxMffg7BiQ8/h+DEh59DcOLDzyE48eHnEJz48HPK2Ly//qMRNValcTjx4ecQnPjwcwhOfPg5 + BCc+/ByCEx9+DsGJDz+HjEu3/h/nOciCOwrVajwmL/yyBSc+/ByCEx9+DsGJDz+H4MSHn0Nw4mv5Ufy5 + 4+/4BoADLLiXcLMDUxpM+IVftuDEh59DcOLDzyE48eHnEJz48HPIOIp/et7P8AZAB/MUIT79p05MaTDh + F37ZghMffg7BiQ8/h+DEh59DcOLDzyHjqOc85Zen/aYNQPd3AHjBgucH8+k/bQCmNJjwC79swYkPP4fg + xIefQ3Diw88hOPHh5xCcBfWcONkA6OVF2Qtpp3C1RdoA5D1VqENwFlNPTviFX5bgxIefQ3Diw88hOPHh + 5xCc+G3y40o+9TxtAK7Sy4uyF9LvCDgwbQDGnyfcIziLqScn/MIvS3Diw88hOPHh5xCc+PBzCE78Nvml + Gp42ANT33kv/fDuQHULaALBziGRnCE58+DkEJz78HIITH34OwYkPP4fgxIefQ3Dia/qlq/dpA8CV/d7i + z5cC2B2kDQARyc4QnPjwcwhOfPg5BCc+/ByCEx9+DsFZwOOTIvwyBWexjPwRaQNAPR/80l9zA9C/UxiR + cTF54ZctOPHh5xCc+PBzCE58+DkEJz78HIITvww//mUDwJX8/npuLwKlDUD/7whGJJ9lDSb8CgUnPvwc + ghMffg7BiQ8/h+DEh59DcOK31Y//Hv8OHwdYsAHgOwBR/DMEJz78HIITH34OwYkPP4fgxIefQ3Diw88h + OPHL9Mv76z0Osui/McCIxG9acsIvU3Diw88hOPHh5xCc+PBzCE58+DkEJ/58+tmBrsKPaESN+RpvCU58 + +DkEJz78HIITH34OwYkPP4fgxIefQ3Diw2/ZohE1VqVxOPHh5xCc+PBzCE58+DkEJz78HIITH34OwYkP + v2WLRtRYlcbhxIefQ3Diw88hOPHh5xCc+PBzCE58+DkEJz78li0aseALBjSYIu8LBx2CEx9+DsGJDz+H + 4MSHn0Nw4sPPITjx4ecQnPjwW7ZoxII/LaDBFON/atAjOPHh5xCc+PBzCE58+DkEJz78HIITH34OwYkP + v2WLRiy4qQANpjjr7YLDL/yyBCc+/ByCEx9+DsGJDz+H4MSHn0Nw4qv4FckaSY8I5p7CKfpvLzgiOPHh + 5xCc+PBzCE58+DkEJz78HIITH34OwYkPP6eyWQ604PbANJjiLLcLDr/wyxac+PBzCE58+DkEJz78HIIT + H34OwYmv6cd9f8avHOjg9IyAFGe5XXD4hV+24MSHn0Nw4sPPITjx4ecQnPjwcwhOfE0/7vg7vgFoHEyD + Kc5yu+DwC79swYkPP4fgxIefQ3Diw88hOPHh5xCc+GX4ZW0AOGgh9JJL4Rd+JQq/8CtR+IVficJvYCPB + ixZ86zCFa9eRFH7hV6LwC78ShV/4lQjeAp8UW+j3T/7J/x/n1a8iyXtpKAAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAo6tJREFUeF7t + vQmYLFlZ5t8XmqVxYVNQYURslqHpzsyqurf73ozIyoioe7tbxXbri7TYrd2Ojqgzjoq42wroKKIyuKEO + zjijjoyCCuOCG+q4byig4DLOoCAKsogKtEj//+fN+0b1qcgvIr7zZdS9mVXf+zzv0103z+8953wRGfFV + VVbmZS6Xy+VyuVzJOnu2OBF8r8gn+JBJnud5KfI8z0uR53leio5bXpLCZPdumg+Z5HmelyLP87wUeZ7n + pei45akVJkLXcXnwfSLja1P3AY685xkEjrznGQSOvOcZBI685xkEjrznGQSOvOcdtjAJJ7xvZHy9ymY8 + z/NUAkfe8wwCR97zDAJH3vMMAkfe8wwCR36QvCRhkuD7Bd8/Mr5eZTOe53kqgSPveQaBI+95BoEj73kG + gSPveQaBIz9IXpIwCSe8IjK+XmUznud5KoEj73kGgSPveQaBI+95BoEj73kGgSM/SB6kZsNAvLrwAcHv + Fxlf34tDkgSOvOcZBI685xkEjrznGQSOvOcZBI685xkEjrznGRQ4NBN40WA/j0HBmPD9I+PrVTbjeZ6n + EjjynmcQOPKeZxA48p5nEDjynmcQOPJD5eHmjxcM9jcAGBCMyT4wMhawymbAe55B4Mh7nkHgyHueQeDI + e55B4Mh7nkHgyHueQYHDzR8vGIS7GwAOxo8Z6gU8kP9dZTN1Tm3PUwocec8zCBx5zzMIHHnPMwgcec8z + CBx5zzMocLif4wWD9V8NoAGQXwOAB4LxAoP6Rw+YeJ0243mepxY48p5nEDjynmcQOPKeZxA48p5nELhg + 3M/h/QaADx9UeKDuFPAqw/h3D15shcCR9zyDwJH3PIPAkfc8g8CR9zyDwJH3PIPAkR8yDz/Jr/9qAA3A + 5Xz4oMID9e8IMLBuAFZ5wYEfPM9TCxx5zzMIHHnPMwgcec8zCBx5zzMIHPkh8+p7eN0A4P7e+qN/vDoQ + HULdAKz6pwvrXhzP8zyVwJH3PIPAkfc8g8CR9zyDwJE/Tnn1T+/rBqD9TYPCA3hRALqDugGAvdgKgSPv + eQaBI+95BoEj73kGgSPveQaBI+95BoELBo+c2kPkwXUDgPt554v+4gbA/PaCgfOD53lqgSPveQaBI+95 + BoEj73kGgSPveQaBI38YefgvGgD8JL/9fh4eBFQ3AO2/I+gRcw5rM56XKHDkPc8gcOQ9zyBw5D3PIHDk + Pc8gcOSPax7+v/81fBgQjAZglY8oPO7F9rwEgSPveQaBI+95BoEj73kGgSPveQaBI3+Yebq/3sOg4PY3 + BugR+U0rjucpBY685xkEjrznGQSOvOcZBI685xkEjvzRzAsDTTd+CJNwMtvkDYEj73kGgSPveQaBI+95 + BoEj73kGgSPveQaBI+95hy1MwskGmRwcec8zCBx5zzMIHHnPMwgcec8zCBx5zzMIHHnPO2xhEk42yOTg + yHueQeDIe55B4Mh7nkHgyHueQeDIe55B4Mh73mELk3CyQSYHR97zDAJH3vMMAkfe8wwCR97zDAJH3vMM + Akfe8w5bmISTDTI5OPKeZxA48p5nEDjynmcQOPKeZxA48p5nEDjynnfYwiScbJDJwZH3PIPAkfc8g8CR + 9zyDwJH3PIPAkfc8g8CR97zDFibhZINMDo685xkEjrznGQSOvOcZBI685xkEjrznGQSOvOcZFVjdX/9h + Ek42yOTgyHueQeDIe55B4Mh7nkHgyHueQeDIe55B4Mh7nkGBq9/6v5/HoGC8o9BQk/vB8zy1wJH3PIPA + kfc8g8CR9zyDwJH3PIPAkR8qDzd/vONvfwOAAcF4L+F4Aeu0Gc/zPLXAkfc8g8CR9zyDwJH3PIPAkfc8 + gwKHm3/9eT/dDQAH41OE8N1/vYh12ozneZ5a4Mh7nkHgyHueQeDIe55B4Mh7nkGBw/0cn/KLT/utGwD5 + NQB4IBifH4zv/usGYJ0243mepxY48p5nEDjynmcQOPKeZxA48p5nELhg3M/h/QaADx9UeKDuFK4IrhsA + 3acKCQIXjMVjE7X94CkFjrznGQSOvOcZBI685xkEjrznGQSOvOcZBC4YP8nH/bxuAC7nwwcVHqh/R4CB + dQPQ/3nCLQIXvO7F8TzPUwkcec8zCBx5zzMIHHnPMwgc+eOUV9/D6wYA9/fWH/3j1YHoEOoGAJ2DF1sh + cOQ9zyBw5D3PIHDkPc8gcOQ9zyBw5D3PIHDkh8yrf3pfNwD4yX7rzR8vCkB3UDcAsBdbIXDkPc8gcOQ9 + zyBw5D3PIHDkPc8gcOQ9zyBw5IfOg+sGAPfzzhf9xQ1Ae6fQo8D5wfM8tcCR9zyDwJH3PIPAkfc8g8CR + 9zyDwJE/jDz8Fw0AfpLffj8PDwKqG4D23xH0iDmHtRnPSxQ48p5nEDjynmcQOPKeZxA48p5nEDjyxzUP + /9//Gj4MCEYDgNcA+M1fIXDkPc8gcOQ9zyBw5D3PIHDkPc8gcOQ9zyBw5A8zT/fXexgU3P7GAD0iv2nF + 8TylwJH3PIPAkfc8g8CR9zyDwJH3PIPAkT+aeWGg6cYPYRJOZpu8IXDkPc8gcOQ9zyBw5D3PIHDkPc8g + cOQ9zyBw5D3vsIVJONkgk4Mj73kGgSPveQaBI+95BoEj73kGgSPveQaBI+95hy1MwskGmRwcec8zCBx5 + zzMIHHnPMwgcec8zCBx5zzMIHHnPO2xhEk42yOTgyHueQeDIe55B4Mh7nkHgyHueQeDIe55B4Mh73mEL + k3CyQSYHR97zDAJH3vMMAkfe8wwCR97zDAJH3vMMAkfe8w5bmISTDTI5OPKeZxA48p5nEDjynmcQOPKe + ZxA48p5nEDjynnfYwiScbJDJwZH3PIPAkfc8g8CR9zyDwJH3PIPAkfc8g8CR9zyjAqv76z9MwskGmRwc + ec8zCBx5zzMIHHnPMwgcec8zCBx5zzMIHHnPMyhw9Vv/9/MYFIx3FMKktb3YSoEj73kGgSPveQaBI+95 + BoEj73kGgSPveQaBIz9UHm7+eMff/gYAA4LxXsLxAtZpM57neWqBI+95BoEj73kGgSPveQaBI+95BgUO + N//68366GwAOxqcI4bv/ehHrtBnP8zy1wJH3PIPAkfc8g8CR9zyDwJH3PIMCh/s5PuUXn/ZbNwDyawDw + QDA+Pxjf/dcNwDptxvM8Ty1w5D3PIHDkPc8gcOQ9zyBw5D3PIHDBuJ/D+w0AHz6o8EDdKVwRXDcAuk8V + EgQueN2L43mepxI48p5nEDjynmcQOPKeZxA48scpDz/Jx/28bgAu58MHFR6of0eAgXUD0P95wi0CF7zu + xfE8z1MJHHnPMwgcec8zCBx5zzMIHPnjlFffw+sGAPf31h/949WB6BDqBgCdgxdbIXDkPc8gcOQ9zyBw + 5D3PIHDkPc8gcOQ9zyBw5IfMq396XzcA+Ml+680fLwpAd1A3ALAXWyFw5D3PIHDkPc8gcOQ9zyBw5D3P + IHDkPc8gcOSHzoPrBgD3884X/cUNQHun0KPA+cHzPLXAkfc8g8CR9zyDwJH3PIPAkfc8g8CRP4w8/BcN + AH6S334/Dw8CqhuA9t8R9Ig5h7UZz0sUOPKeZxA48p5nEDjynmcQOPKeZxA48sc1D//f/xo+DAhGA4DX + APjNXyFw5D3PIHDkPc8gcOQ9zyBw5D3PIHDkPc8gcOQPM0/313sYFNz+xgA9Ir9pxfE8pcCR9zyDwJH3 + PIPAkfc8g8CR9zyDwJE/mnlhoOnGD2ESTmabvCFw5D3PIHDkPc8gcOQ9zyBw5D3PIHDkPc8gcOQ977CF + STjZIJODI+95BoEj73kGgSPveQaBI+95BoEj73kGgSPveYctTMLJBpkcHHnPMwgcec8zCBx5zzMIHHnP + Mwgcec8zCBx5zztsYRJONsjk4Mh7nkHgyHueQeDIe55B4Mh7nkHgyHueQeDIe95hC5MEYzJMWnvlzeR5 + 9eidWfUx23n1xVuz4oWjafXLk7x69SgvXj/KineE/787+P/TeEuwNE5rz5PHae158jitPU8ep7XnyeO0 + 9jx5XKenxXsm0+pt4b9/Er7+1XBf+4HtvPya7d3iE7Os+ohV75fBg9x/k4RJONnKk8/n88vDTX6+lZfP + 3cqKP1ip2JHjHM9Lt+fJ47T2PHmc1p4nj9Pa8+RxWl/EvFeP8/J5W3mxt7Ozcx/eFjuF+yzvtyvff5OF + STjZSpOHjV81yYtvDX5rR3FM9jx5nNaeJ4/T2vPkcVp7njxOa8+Tx2l96fKKt4Zvhr9jazo/ydvkknCf + 5f12pftvrMDq/voPk3Ay0+Tnz5+/9yQvbxll1a/Vm9YXR2fPk8dp7XnyOK09Tx6ntefJ47T2PHmc1muT + lxW/hXslfkLO2+fgN//A1W/9389jUDDeUcgw+Z33Gmflk0dZ+cfxJs3FabHnyeO09jx5nNaeJ4/T2vPk + cVp7njxO63XMG+fVn0+yvU+76aYn4a35h7754x1/+xsADAjGewnHC1BNjt9thI28urmxIYoT2/PkcVp7 + njxOa8+Tx2ntefI4rT1PHqf1+ueVrzm1W9yUev+VFDjc/OvP++luADgYnyKE7/7rBqB38p35/INC9/L9 + 8maWLY3T2vPkcVp7njxOa8+Tx2ntefI4rT1PHqf1JuVtz8oXn8rLK/vuv20KHO7n+JRffNpv3QDIrwHA + A8H4/GB89183AL03/8Xv+afVW/o2U1sap7XnyeO09jx5nNaeJ4/T2vPkcVp7njxO603MG+XF342me5/M + 261auG8H434O7zcAfPigwgN1p3BFcN0AdH6q0Hw+v/8kq75H2ggsbUYap7XnyeO09jx5nNaeJ4/T2vPk + cVp7njxO643Py6rvu2o+f3/efjuF+3YwfpKP+3ndAOy/wPCAwgP17wgwsG4AOj9PeHtaXjnJyt8/sMDI + vZtJtOfJ47T2PHmc1p4nj9Pa8+RxWnuePE7rI5T3atx7eRsWhft2dA+vGwDc31t/9I9XB6JDqBsAdA6t + N/+tWbnLd+mTFpiyGZU9Tx6ntefJ47T2PHmc1p4nj9Pa8+RxWh+5vGn1NtyDeTs+INy3g+uf3tcNAH6y + 33rzx4sC0B3UDQDcfvOfljct3u5QWlhw8mZ67HnyOK09Tx6ntefJ47T2PHmc1p4nj9P66OYVd+FP7Xlb + Xgj37eD6dXt1A4D7eeeL/uIGoL1TCBrPqk8fTYt/kRe0ymZke548TmvPk8dp7XnyOK09Tx6ntefJ47Q+ + Bnl3j7LyDtybw327vvnXf7WHBgA/yW+9n9dQ3QC0/44gCDd/YQH7HmAzB+x58jitPU8ep7XnyeO09jx5 + nNaeJ4/T+jjlhSbgM8K9u7751w1A52v4FsKAYDQAeA1A680fP/b37/zvsefJ47T2PHmc1p4nj9Pa8+Rx + WnuePE7rQ8i7eyvfuz3cw+sGoPOv9/aFQcHtbwwQhBcb+O/877HnyeO09jx5nNaeJ4/T2vPkcVp73j21 + sLjOiC2N0/qenOKuk7vFx4R7Ob7777/5Q103fgh/buCv9r/HnieP09rz5HFae548TmvPk8dp7XnyOK0P + PS+r3r6TlY/l7Xs1nT59+oowySubk9ZemjxYGqe158njtPY8eZzWnieP09rz5HFae548TmvP42NZ+arR + uXPvx9u4Xf4Of/fY8+RxWnuePE5rz5PHae158jitPU8ep/VFz8uq7+Nt3Ca8t/+BwMi9kyfa8+RxWnue + PE5rz5PHae158jitPU8ep7XntY57Cm/nacKn+vkH+1yw58njtPY8eZzWnieP09rz5HFae548TutLm1e8 + 9errqofztq7XKC//qxSYNnm/m1njvPrnUV79Dj5SOPiZk7x82iTb+zS821EYf3OXA39+Z1bdGnxb5Fvx + 79L4Pnue56XY8zwvxZ53ZPPOT7LyU7am1dO2Z9XXb+flD27lxe9OsurdIUu8D2oNvmlp3EGXP8zbuk5h + sXtSkG3ydu/nZOUbQpG+/dRueePVN1x/BZeRJPzJA//0of4byPqNEHR/CtEQOPKeZxA48p5nEDjynmcQ + OPKeZxA48p5nEDjy+3nTc3sftD0ri9AIPCf4r6R7Ypfj+25taZxk3NO5tH2FNUl//XfnvQLw6uWAZTfH + pBj8dlb9TuiwPuWGG/YewmL5yaUQOPKeZxA48p5nEDjynmcQOPKeZxA48hubd/78+XtPZsXHTbLit6T7 + Y9PNey8sjWt1Vr4Kc2LusI76rf+X98cftR+AV5684dCN/O3JWXVHUeQPCos49GKnCBx5zzMIHHnPMwgc + ec8zCBx5zzMIHHnPMwgceW3eiXA/fcok3BOleyXcvPfC0rheZ+VtYR24+eMdf5cbAHQIo6z84xgabHJ6 + a1b87Jn57pVh8ktR7E6BI+95BoEj73kGgSPveQaBI+95BoEj73kGgSOfnIcX3Y+n5U8v3S8FN8doPcqr + P6uqxccC4/N+lhuA5p/9DTk5vD0rv48/7r+kxZYEjrznGQSOvOcZBI685xkEjrznGQSOvOcZBI68OQ/f + gI/z4rvq++XQ999Fxqy8NaypbgAOvgZglFW/dmBww3FYqnHzj37kf8mLHQscec8zCBx5zzMIHHnPMwgc + ec8zCBx5zzMIHPkh8k6Eb8S/e+j7b5Txm2FdiwaA813QOCuf2Bwcu37MYvzY37/z9zyNwJH3PIPAkfc8 + g8CR9zyDwJH3PIPA7e0VD96eVb8w2P03Mr7emZXXcrp7NMmLb5WAGrIaL/i7bnfvMUMVh/xgxSbveQaB + I+95BoEj73kGgSPveQaBI+95BoEjP3ge7pnjrHrL6vff5Xt5yH0+p7ygnZ2d++AdgySo/jeLwePV/tgQ + vZbFjux5SoEj73kGgSPveQaBI+95BoEj73kGgSN/aHnbs+ozpfuq1vF9vDb+He/wO5/PL+fUl112zbSa + SWD8b6kGj7/z9z/1Sxc48p5nEDjynmcQOPKeZxA48p5nEDjyxzrvyitvu3ySlb8v3V/7XN/DY8ePj7O9 + ArVeaJyVXx8/2Byc6npCvMlP2IifDAkCR97zDAJH3vMMAkfe8wwCR97zDAJH3vOCwv0Uby0s3mfbXN9/ + Yy+Ny6pvWSwAmkyL31saYPT+pFn5hr294qHxZlIFjrxYnFSBI+95BoEj73kGgSPveQaBI+95BoEj73kG + gSN/0fLwo/rRtPpr6V4rOb7p15bGjafFHy4mOHVq76HSAIvjSfHe/s3NpAgc+dbipAgcec8zCBx5zzMI + HHnPMwgcec8zCBx5zzMIHPmLnjfOy+dJ99um4/tvbWlc7atOX/+Qy/C7AOnBVDcnxgf7SJvRCByL0Vsc + jcCR9zyDwJH3PIPAkfc8g8CR9zyDwJH3PIPAkb8keW0fzhe7ef+FpXEHnFXnQgNQfZ74YIKbE+Mjff1T + /XQCR97zDAJH3vMMAkfe8wwCR97zDAJH3vNadPr06StG4Z4q3Xvh5v0XlsY1He7Tz7gsfutBi6XJ8Xn+ + XHuSUAQWQ12cLoEj73kGgSPveQaBI+95BoEj73kGgSPveQaBI3/J88K99pXNey8s3X+lcZLHefmfLxtN + q1+SHtS4bfLQWXw/160WisBiJBdHEjjynmcQOPKeZxA48p5nEDjynmcQOPKeZxA48muRF76p/kHt/Vdr + 3PvRWSx99r/GXZOHBuCZXLdKKAKLYSpOU+DIe55B4Mh7nkHgyHueQeDIe55B4Mh7nkHgyK9N3iQrn629 + /2od7tOvDZ1F8XrpwS73T14+jevuFYrAYpiLEwscec8zCBx5zzMIHHnPMwgcec8zCBx5zzMIHPm1ypvk + xb/X33+1Lt562Sgr3iE/KFs1ebb3aVx3p1AEFmOl4tQCR97zDAJH3vMMAkfe8wwCR97zDAJH3vMMAkd+ + 7fLGs+rT1fdfpcfT6t34FcDdzQfarJ18nJVP5rpbhSKwGCsXBwJH3vMMAkfe8wwCR97zDAJH3vMMAkfe + 8wwCR34t8yZZ+VTt/TfFaADEB5pOnPxmrlsUisBiDFIccOQ9zyBw5D3PIHDkPc8gcOQ9zyBw5D3PIHDk + 1zbv5Ky6PeH+q7aqAWhOrJi8tQHAZliMwYpD3vMMAkfe8wwCR97zDAJH3vMMAkfe8wwCR36t8/Cpugn3 + X7V7G4B40oTJxQag3kzwoMVhjuclChx5zzMIHHnPMwgcec8zCBx5zzMIHPm1z4sbAOF+a3ZnAxDf9BMn + X2oA4s1EXstiR/Y8pcCR9zyDwJH3PIPAkfc8g8CR9zyDwJE/lLy6ARDutWpLfGsDEN/0a0vjWnygAWhu + hl7bYtOepxQ48p5nEDjynmcQOPKeZxA48p5nELhg8MipPWgeXgMg3GfVbruHiw1AfNNvA3u83wBIm+HX + fjIoBI685xkEjrznGQSOvOcZBI685xkEjvyxzgv34FuE+6zKXfdxVQMgjenxogEIC/eD53lqgSPveQaB + I+95BoEj73kGgSPveQaBI7+UF+7DTxHus73uu5f3NgDS4wrfjEVz8Uub4X6TBI685xkEjrznGQSOvOcZ + BI685xkEjrznGQSO/EbmhXtxcgMQ38drN8d0NgDSYxoH9jwXL24mVeDIe55B4Mh7nkHgyHueQeDIe55B + 4Mh7nkHgyG9sXrinJjUA9T08tjSutQGQ/l3rnVl1a9dmUgSOvOcZBI685xkEjrznGQSOvOcZBI685xkE + jvxG54V7sroBiG/6taVxsNgArGJMFhqA27o2oxU48p3F0Qocec8zCBx5zzMIHHnPMwgcec8zCBx5zzMI + HPmLnhfuq6oGIL7p15bG1R60AagnjBqAjSy2RuDIe55B4Mh7nkHgyHueQeDIe55B4Mh7nkHgyKvywn21 + twGo77+xpXGxB2sA4knZAGxssfsEjrznGQSOvOcZBI685xkEjrznGQSOvOcZBI68Oi/cVzsbgPj+W1sa + 1/QgDUBzYr4GwA+eQuDIe55B4Mh7nkHgyHueQeDIe55B4Mh7XofCfbW1AWjef2FpnOSVGwBp8uDzXHeS + UAQWI6k4bQJH3vMMAkfe8wwCR97zDAJH3vMMAkfe8wwCR/6S54V7qtgANO67C0vj2rxSA9AxufhhQF1C + EViM5OJIAkfe8wwCR97zDAJH3vMMAkfe8wwCR97zDAJHfi3ywr11qQFo3nvh5pg+mxuAnsmTGgAUgcUw + FacpcOQ9zyBw5D3PIHDkPc8gcOQ9zyBw5D3PIHDk1yYv3F8PNADNey8cP661qQFQTK5uAFAEFsNcnFjg + yHueQeDIe55B4Mh7nkHgyHueQeDIe55B4MivVV64x+43AM17Lxzde5Oc3AAoJ1c1ACgCi7FScWqBI+95 + BoEj73kGgSPveQaBI+95BoEj73kGgSO/dnnhPrtoAJr3Xrhx701yUgOQMHlvA4AisBgrFwcCR97zDAJH + 3vMMAkfe8wwCR97zDAJH3vMMAkd+LfPCvfaW5r0XFu69SVY3AImTdzYAKAKLMUhxwJH3PIPAkfc8g8CR + 9zyDwJH3PIPAkfc8g8AFg0dO7bXKOzmrbk+4/6qtagCaEysmb20ANqHY5D3PIHDkPc8gcOQXWUWRPyg7 + Wz1ya/fs40fZ2XyUlZ8YfMckqz5/nJVfGf77nHFefNckL39gnFc/McmLXwz//d3g1wb/+Siv/t9WXrxx + a1a8Ofht41nxzvDv7wr//s/heXo3jP8PDv9W/H3g3xr8t8FvAIsMZIX//x1mv3R7Vr4oZL1wOy+ft5WX + z97Oqy8Ja/qMcVZ9QlhLNtk9+9ids2cfGLZz4sKu2tXcL722x4P2PKXAkfc8g8CBDw3AHQn3X7V7G4B4 + 0oTJxQag3kzwoMVhjuclChx5zzMIHHlT3ng+f9AkK8db0/KmcCP9d+Fm/k1bs+qHtrLy57ay4g/Cc+2N + 4eZ9l/D8Urv53IWlcVqn5YW1Z9VfTabF742n5U+H5uH70bBgr9hzaBwmaG6s9WsKHHnPMwgcec8zCBz5 + wfPiBkB+rtnc2QDET/LEyZcagHgzkdey2JE9Tylw5D2P2tnZuc810/Lxk1nxceFG//RwQ/y24JeOp8Uf + Xvhu++DzZoXnm+hNyRuHWoSG5zXbs+KnQn2+PTQJX4SaoXaoIcvZKdSd9W89HikCR97zDAJH3vMMAkd+ + kVU3ANLzSGuJb20A6idnbGlciw80AM3N0GtbbNrzlAJH/ljmnS52H3Uqr86OZ9Xtk7z8hlFW/Xh4Drxu + NK3e23hetHrF59uSj0oeaohfQUym5Y+htqHGn76dzU/jpyc8HH4+e16SwJHfmDy8BkB6fmjd9hwTG4D4 + SdkG9ni/AZA2w6/9ZFAIHHnPMwgc+SHyToxn567cysunbs+q52zn1c+MZ8WbDM+PA24+1zxP6+INoTH4 + X1uz6ht3ZtVTry3n1+A1EyscX39+eF6SwJE/1LzwHLlFfg70u+t5pmoApDE9XjQAYeF+8DxPLXDk1yHv + BH4EHW72t06y6lvCd5+vmEyrtzefG8bnx749Tx6n9VJeVr09NAavmGTlN4/z6lNxDHEsLxzSbuG84Plh + OV+WBI685xkEjvyxzwvntvhZAH1uPj+aj/c2ANLjCt+MRXPxS5vhfpMEjrznGQSOvOcJ2tl50gO2ZuVu + uHF8Wfiu8mXhJvLW5nkdPy9WfH4s7HnyOK21eaO8+LvFay+y6kuumVaz06dPX8HDvi+cFzw/VOdLn8CR + 9zyDwJH3vKBwbic3AM3nBtwc09kASI9pHNjzXLy4mVSBI+95BoEj73nU6My5h4Vz9Xy4MXzrJCt+q+/3 + 9fVzIrY0TmvPk8dpvUre4k8gp9VvXvjJTnXz9ix/OM+P1vMlReDIe55B4Mh7HhXO76QGoPncgKVxrQ2A + 9O9a78yqW7s2kyJw5D3PIHDkj3XeqJh/YLjgf9TiR8PT4g+l87bNzSfSqs8Pz5PHaX0YeZNZ9eqtWflt + p2bVJ03PVh8Szhl/vikEjrznGQSOfGdeOEfVDUD8vKgtjYPFBmAVY7LQANzWtRmtwJHvLI5W4Mh7nkHg + yK993t5e8dBTeXVuOy+fPc6qX1l819c4VzVuPpFgaZzWnieP0/pi5OFcGU2rX8IbLeEvDubz+eU8xToV + n3+R1/L5EdnzlAJH/qLnhfNS1QA0z2VYGld70AagnjBqADay2BqBI+95BoEjP1jetbO9R23Pqs8Kfgne + 8a7v5O9zfT7HlsZp7XnyOK0vVd4oK94xycsfnmTlp1yT5w/mKXdAOP94/g52PpP3PIPAkT8SeeHc7G0A + mucyLI2LPVgDEE/KBmBji90ncOQ9zyBw5FfOG+V7j5tk1dPDOfir46z4l/g8bJ6jKY5zPC/dRzVvNC3+ + BX8REs67L8RbHuMcxHnL83fl8xkCR97zDAJH/sjkhfOzswFonsuwNK7pQRqA5sR8DYAfPIXAkfc8nU5s + TffOjPPqm8K59zrp/IPj8zPVnieP0/o45eFNirbz6nk7u8Ue34PgUj8/Dggcec8zCBz5S5oXztHWBqB5 + LsPSOMkrNwDS5MHnue4koQgsRlJx2gSOvOcZBI78pc47cc2s2g7f6T8HH1DTd/7Fj6fa8+RxWh/zvNdv + z8pvmUzn2zhnL5y6euF5wOdD6vNDFDjynmcQOPKXPC+cW2ID0Dj/FpbGtXmlBqBjcvHDgLqEIrAYycWR + BI685xkEjvwlyxtn5RPDufSs0bT80/qci91x/pnsefI4rT3vwOOvC+fv127tnn0CT+dO4XnA54P6+dEl + cOQ9zyBw5NciL5xbSw1A89yDm2P6bG4AeiZPagBQBBbDVJymwJH3PIPAkb/oeePT1SMWb8aTV6+Ozqcl + 95x/yfY8eZzWniePg/Fnp3gTou3Z7EN5mh8Qngd8PvQ+PzQCR97zDAIXDB45tS9pXji/DjQAzXMPjh/X + 2tQAKCZXNwAoQvBaFTsWOPKeZxA48q15V111/r5bs+KTRnn1k5O8eF/jXFqy4vxLsufJ47T2PHlc04sX + EE7Ll4Vm4BNwzuPcx/OAz4fW50eKwJH3PIPAkV+rvHCO7TcAzXMPjs+zFCc3AMrJVQ0AisBirFScWuDI + e55B4MhflLzRmfnVeDe20bR6i3AOiVaef2p7njxOa8+Tx/U5nPNvHuflN5/aLU+1PT9SBY685xkEjvza + 5YXzbNEANM89uHlupTipAUiYvLcBQBFYjJWLA4Ej73kGgSN/qHnb585+QLjwfeYoL35bOG86nXD+qex5 + 8jitPU8ep/V+zqz67Z28+rzZ7BzektivLwqBI38s8sJ5csv++RJZOq9SrG4AEifvbABQBBZjkOKAI+95 + BoEjf2h5p+Z714zz6rn4RD3hfOl14vnXa8+Tx2ntefI4reW84q2TrPzGrTPlo/hUUkl6vvFrv14pBI78 + 2uadnFW3L58vq1vVADQnVkze2gBgMyzGYMUh73kGgSM/eB7+LvrUbnFTOB/+V/Dd0fmRZMP512nPk8dp + 7XnyOK378/A6mOIl42yvCE+pzj8njJ9vkdfyehDZ85QCBz40AHe0ny929zYA8aQJk4sNQL2Z4EGLwxzP + SxQ48oPmZWerDzuZVV+wNateqzxfWt089zyvuhuvmRjn1Z+H/3/lJC//93ha/vQ4K39klJf/NXz97cHf + EL6T/KrxrHzG1qz8sp3w3+Av3J6V/z74aVt5eVsYc0tgngzj/8O/3TrOy9vx65nwNcb8u/D/XxAyvhhZ + i8y8/I7JrPzBsKaf2MrKnwtZvxGO8auwlgsfuZve5DX3CkvjtD6Cea8Ox+Gz8HHVfJrtq36+BQ/6/GWO + 5yUKHPnB8+IGQDhHzO5sAOKTNHHypQYg3kzktSx2ZM9TChzfi//rx7PirYnni+j4vDvaecVdk2nxf8L/ + /+pkVv3PcFN9fqjjV4eb8OdsT8uPG+dFds20fPypU3sPPX/+/L1Z8k7hePB4DnZ8ybfmYW1YI9aKNU9m + xcdNsuozQoPwjOBvGuXVD46z6pcv7LW4a7j6XfBRzrvwosHqK8bz+YNQa9Sd9W89HikCR97zDAJH/lDy + 6gZAOje0lvjWBiA+SWtL41p8oAFoboZe22LTnqfUdnb2keE7zedvZdU/Gs+XJcc5G583Lf4x3Pz+INz8 + fhS/48V32KOs+tjR7t7WJM8/eDy++t6s/yDHAxz5tc0rivyB1+3uPWZnXu2ezMtbtmfFF4baPCfU68X4 + u/lRXvzTUh07nHQ8FF7jvHeiTmeK3cdGx2Ll40He8wwCR/7Q8vAaAOFcULvtnBMbgPgkbQN7vN8ASJvh + 134yKASO/Nrl4cNQwnd437slfDcnnBNqN7M2IQ9/4z3Kyj/GTT58p/b1+HH6NdNqxjd/af09LurO+q98 + PCBw5Dc978TW9OyHhcZyN9T1jkVNL9T2tRd+R959POLHU70ReVnxnu1Z+X0n59W4pX4qgSPfdzxUAkfe + 8wwCR/5AXjjmt0jngsZd552qAZDG9HjRAISF+8E7gnl4e9PwXewP40LcPFeM58u+NyTvjVuz4me38/J5 + 27PqM/He7/P5/P4sj1qoO+u/0vGoBY78kc5DrfHTE7yWAR/Eg9cjhOPx1wMe3wOWxml9+HnF+0Z59UP4 + tQvLoxbqzvqvdDxqgSPveQaBI7+UF461+FkAfW6eL83HexsA6XGFb8aiufilzXC/SQJH3vMMAkfenDea + nXv0hReaXfgOLD5PVjxfFl7LvKz6q7Dfl0yy8su2d8snnS52H2WtXyxw5M3HIxY48sc2b/EalLw4h2M1 + mZY/Fo7bG8Rj2uJBzpfIFzdv8Zx8ofZPCKX68Ws//xQCR/6i5IVjndwANM8VuDmmswGQHtM4sOe5eHEz + qQJH3vMMAkfelIcfY4+m1XeE7zT+OTrGS47PgVSvRd60+odRXvxsuIE8e2ta3lS/dzvqxHqZ6tcUOPKe + ZxA48r15+DUCXow4zsqvG03Ln8Mxlo696Xzp8KXLK+4aZ9XzT83nH8ISLAl1Yr1666cROPKeZxA48q15 + 4XgnNQDNcwWWxrU2ANK/a70zq27t2kyKwJH3PIPAkU/Owyu6+RG874qPb/PEWvV8uWR50+pt47z6ibDH + L9qazk/O5/PLufV9oU6sV3L9JIEj73kGgSNvysMxHs+qa0OT93S8L/8oK96hPl+UXoc8vIgynNv/8arT + 1z+EW18IdWK9TPVrChx5zzMIHPnOvHDM1Q1A81yBpXGw2ACsYkwWGoDbujajFTjyncXRChx5z+sQfsca + LpBfGo7nO6Xj23RzTIovZh4u9uG/L8bfuIf9jS+77M7OOqBOrFdS/doEjrznGQSO/GB5N9xw9sEnZ/N8 + Z1Z8yfaseNk4L5bO+RR3nX8Wr5qHcx7v5fCYG2+8H/bLeg1WP/KeZxA48r154birGoDmuQJL42oP2gDU + E0YNwEYWWyNw5I9S3olRVn5i+M7oL7qOb2xpnNYXIe9ufOZA+E7omZNZOZW+w28T6sR6pdSvVeDIe55B + 4Mgfat7p09fdb5SdzcP59KxRXv1O8xzrsnD+ieO0HjIvPAf+fGe3eArenTPeb7CfLwqBI39J8sKx720A + mucKLI2LPVgDEE/KBmBji90ncOSPTN54Op9M8vIV0rGF4+NbWxqn9WHljbPqLVuz6n/szMo7Ts3nD+P2 + koQ6sV7q+nUJHHnPMwgc+YueNzpz7mHj6d5Tx9Pqv3V9amV8HteWxml9aHlZ9Us7RTVt269G4Mj31k8j + cOQ9r0Xh2HU2APvHN7I0rulBGoDmxHwNgB88hcCRvyR5uMBNsup7wnFsfRvX5vGFpXFaD503zou/2p4V + 37mdVx91ww17D+nab5/AkVfVr0/gyHueQeDIX/I8/ARpkhfz0GT+pwt/HXLh/Bv6fD78vOJ94TnzArwJ + FbemFurEeiXXTxI48p7XoXDcWhuA5eMrj5O8cgMgTR58nutOEorAYiQVp03gyHteQ3jbVvwufJQXfy8d + 19rCsRXHaT1UHt50Z5KVX7c9r2b+Y03P0wgc+SHyTmxP59duzarnbmXFn616PteOcw4778JrYsqn9b0W + phbqxHoNUT/PS8gLx01sAJrHFpbGtXmlBqBjcvHDgLqEIrAYycWRBI685zUUjtNokhW/FR9Lyc1jC0vj + tF45b1r+BX6fjzciwr64v979agSOvOcZBI78sctbfOrlrDwdGurnjvLq/4nnrsIrPz8a1uaFbwJ+fXRm + fjW3Jireb+S1PB6Rj0xeOHZLDUDz2MLNMX02NwA9kyc1ACgCi2EqTlPgyHteJHyiWOj4v2E0rd4bHSvR + Pcc32da8cHH6O7wHAV7EF7aweEtd7Iv769yvVuDIe55B4Mh7XvhuGm8BHZ5nL8CfmUrntGTr86PNqXm4 + JuC9Ek6fPn0Ft7kv7Iv7E/abLnDkPU+pcPwONADNYwvHj2ttagAUk6sbABSBxTAXJxY48p4XaZJV5/iJ + c81jtWTF8U1yel5xV/jv/8QH5lx11fn7cgsLYV/cX+d+tQJH3vMMAkfe8xrCn96N8+rj8RkG8ZtoNZ3+ + /Oj2KnlhnX+2lRd73IIf3zXJC8dwvwFoHls4PoYpTm4AlJOrGgAUgcVYqTi1wJH3PApvBDLJyv8uHCPR + yuOrdkreaFr+6eINWlpenIR9cX+t+00ROPKeZxA48p7Xo6uvqx4eGoEvaTbhKc8PjYfKC43L909m+UO5 + v+T9SgJH3vMSFY7jogFoHlu4eexSnNQAJEze2wCgCCzGysWBwJH3PGo8La8f5cUbheMjOuH4qqzJ43dG + LxrNyios2T81jwJH3vMMAkd+zfLuvBd+GheagRcHv7fv+ZHiZtbqecUbT+5WH7fafi8IHPkV63dB4Mgf + i7xwLG9pHltYOm4pVjcAiZN3NgAoAosxSHHAkfe8IP6u/9uF49LqxOPb6948/BlVVn4p/gxxsakOYV/c + n7jfVIEj73kGgSPveQaBA5+V88dtzapnjWfFm5aeH4luPtcGzvvu2ezcw1fdb/Cg9WPOscg7OatubxwT + 8bilWtUANCdWTN7aAGAzLMZgxSHveUGL9zmfFn8iHJNWG45vp7vyxnn1u6E5uWVnZ+c+iw31CPvi/sT9 + pgocec8zCBx5zzMIHPn9vDy//qHheXFreH68sn6epLjr+WaxlBfW91p8Xga3oZa0X37t54tC4MCHBuCO + +HhIx83i3gYgnjRhcrEBqDcTPGhxmHOs83BDHWfl146mxb8Ix6PVxuPb6pa8u/HxrHh1dNhG64/5m8K+ + uL+l/XJIksCR9zyDwJH3PIPAkW/LOzHO9opJXry0+bxqc8vzzeyuPP710Fdr31Ib++L+2vabJHDkj11e + 3ADUx2MIdzYA8UmQOPlSAxBvJvJaFjvyRuQ9cXb9v8Lf8grHodMrHF/Ry3nFXXjHsa3T88dwG2phX9zf + 0n45JEngyHueQeDIe55B4Mir8q6Zlo/HO3Su518PFL8yPl09gksVhX1xf6r99gkc+WOZVzcA8vHQWeJb + G4D4JKgtjWvxgQaguRl6bYtNb0TeaFbcgL+VF45Bp1c8vks+kJUV79meFd89ns8/nFtIEvbF/S3tl0OS + BI685xkEjrznGQSOfHLe1pnyUeOs+k7+aaz8fKPjx1OdmjeaVm+e5HtnucwDwr64v+T9SgJH/tjm4TUA + 0nHQuu2Yig1AfBK0gT3ebwCkzfBrPxkUAkf+QN5NNz3pPqHOzwpufQ//Ng9wfA94PyOr3r01K7/r9O7e + 48Ia/fgqBI685xkEjvyRzsNP+S68sLe4K37e7j/3VvAKebj2fDXeVpzL9ON7SHnhmNzSqL3aXcdV1QBI + Y3q8aADCwv3gHULe6HT1oeFm+wtC3XvdPLbG47vvRQa+48+r78CrmrleP74KgSPveQaBI39s8q7Ny8eH + 59wL8Ou1wZ6/DUvjevxyvHcH1sf9DbZf8sc+LxwX8bMA+tx3bHsbAOlxhW/Gorn4pc1wv0kCR/5Y542z + s7ujafXXQs17HR/XFY/vwoG/Gx+9e2Z37+p6fcF+fBUCR97zDAJH/ljmnZrvjSaz6n9Kz0utm9cCWBqn + c/GGU3l1tl4fvbb1ozcmLxyb5AageWzh5pjOBkB6TOPAnufixc2kChz5Y503nlW3d70oqMv1MY0tjdM6 + 8D9/alZm8fqC/fgqBI685xkEjvyxz9vOyx3LTwOb1wJYGqf1hYziru1Z9Vnx+riFJIEjv7RfDkkSOPIb + mxfqm9QAxMe1tjSutQGQ/l3rnVl1a1h8feA2rtgpAkf+0PJuuOHsg8OT/JukWmvcPBFWPL6vDMc3fnew + wffLrz1PIXDkPc8gcOQ3Oe/EVr534yQrXyU8X5c88PVAyCufe+WVt6n+VLAp7Iv769qvWuDIb3ReqKu6 + AVg+HvI4WGwAVjEmCzeI27o2oxU48p3F0Qoc+Y3Ju3Y++7BJXrxMqrXGzRMBlsb1u3jrOC8/K89vjD97 + f/D98mvPUwgcec8zCBz5I5GHF+NN8vJpk2n1dvk5POT14II78l48Onfu/bg0lbAv7k+13z6BI7/xeaGu + qgageSxgaVztQRuAesKoAdjIYmsEjvyh5V2Xl0/UdvWS45OgtjSux3fj75FPzecPa66PX/vxVQgcec8z + CBx5z+sRXpAXnrcvbDyPh7oe7Ls3Lyt//5r5/JFcVqewL+4veb+SwJE/Enmhtr0NQPNYwNK42IM1APGk + bAA2tth9Akf+0PJOZhXeEexvpVprHB+P2tK4LuNte0d5cZ20Pn7tx1chcOQ9zyBw5D0vQZNZOQ3P48Xb + Cw9xPYitzRtPqzeNdve2uCRR2Bf3t9J+a4Ejf2TyQn07G4DmsYClcU0P0gA0J+ZrAPzgKQSO/H7eyVnx + sZNp8Y9SrTVuHg9YGtfhd4bm43PwI0Vpffzaj69C4Mh7nkHgyHueQWU5v+/OrPziraz4pxWuBwcc52jy + wjcRfx+uJ3Mu6YCwL+5vkP2CI3+k8kKNWxuA5rGApXGSV24ApMmDz3PdSUIRWIyk4rQJHPmNydvKy6eG + J8uBd/1KsXAsxHEdfvlOdnbxDn7S+vj1sTke/NrzFAJH3vMMAkd+8Lxry/k123n1y4brwQE3ry3qvGnx + nq1peROXtlC8vshrWb/IlyQv1FlsAJrHApbGtXmlBqBjcvHDgLqEIrAYycWRBI78xuTt7FafF27+74tr + nOKO49FrdOmjrLwjLG3xYT3S+vj1sTke/NrzFAJH3vMMAkf+0PKKIn/gOC//7WRa/YN0DejzKtcXePFB + ZVl5W9v6+LUfX0Gh1ksNQPNYwM0xfTY3AD2TJzUAKAKLYSpOU+DIb0ze1qz6qqh+ye45Hp0e5dVPxi/W + kdbHr4/N8eDXnqcQOPKeZxA48hclD58vEBr+n5WuBW1e5frSdGhCvpDrEdeXKnDkj2xeqPeBBqB5LOD4 + ca1NDYBicnUDgCKwGObixAJHfiPyQlf+oHDzf26jfklWHA/R4cb/rsms+jdhWfsf0dtcH7229aM9Tylw + 5D3PIHDkNz3vxNa0+uzxtHq3dG2Ibb2+tHmRMau+Ede+jvWpBI58335VAkd+rfJCzfYbgPg41I7rm+Lk + BkA5uaoBQBFYjJWKUwsc+Y3IwxNgOy/Nb/ADK4/HksfT4g+3ds8+gUtbqLk+em3rR3ueUuDIe55B4Mgf + mbzRmfnVo2nxR9I1ArZeX9oc52zPqq/vW1+XwJFX77dL4MivXV6o16IBiOtXu1njFCc1AAmT9zYAKAKL + sXJxIHDkNyYvPAG+Tqid2gnHo+Hy2+fz+f25tIWk9fHrY3M8+LXnKQSOvOcZBI78Jc/b2XnSAybT6rub + 1wn79UW2mJeVX85lJAn74v6S9ysJHPm1zAu1uqVZO1iqc4rVDUDi5J0NAIrAYgxSHHDkNyYvfOf/NULd + 1E48Hhc8rd42zquP57L2Ja2PXx+b48GvPU8hcOQ9zyBw5NcqL1wjzo+y4h24VpiuLx3uzMvKp3MJKmFf + 3N9K+60Fjvza5p2cVbe31m8FqxqA5sSKyVsbAGyGxRisOOQ3Ji/c/L9CqJnahuOxeFcuvPiHy9qXtD5+ + fWyOB7/2PIXAkfc8g8CRX8u8Ub73mK28fE3y9aXDzSwxL6s+n0voFPbF/Q2yX3Dk1zovNAB3dNbP6N4G + IJ40YXKxAag3EzxocZizEXnbs+IZQr3UthyP8bT6IfyYj8val7Q+fn1sjge/9jyFwJH3PIPAkV/rvDNV + 8YjQBPy49vrS5fg61Z9XPo1LEVWvL3jQ/TJnrfPiBkCunc2dDUB80BInX2oA4s1EXstiRx40D2+RLNRK + 7fTjUbyPP17bf5V/LWl9/PrYHA9+7XkKgSPveQaBI78RefzrpGeG68jdy9cVndOvV9Xd46z6BC7pgJrr + o9e2fvRgeXUDINRMbYlvbQDig1ZbGtfiAw1AczP02habHjRve7Z3Pd4NS6iVysnHY1q9fTQrbuCSDkha + H78+NseDX3ueQuDIe55B4MhvXN4o33tSuJ68c+n60uPk6xWNP0vczuanubSFsA6uZ2l9HJIkcOQ3Jg+v + AZDqpXXbMRAbgPigtYE93m8AwuKP/cE7nc9P4gV4Qp1UTj4e0/IvwhP3cVzSAUnr49fH5njwa89TCBx5 + zzMIHPmNzQvXlKvCNeUvl64zLU6+XjU8mlZv2To9fwzmxjq4ntb1pQgc+Y3KCzW8RaqVxl3HQdUASGN6 + vGgAwsKP/cE7lZdXTrLq/wo1Url5LHqPx7T4vauvqx7OJR2QtD5+fWyOB7/2PIXAkfc8g8CR3/i88enq + ERPFR5MnX69aPM6rP9+e5Q/nenrXpxE48huXF+oofhZAn/uORW8DID2u8M1YNBe/tBnuN0ngyG9M3vRs + 9SGjvPodoT4qx8dBczzw9p6Pn04/gEs6IGl9/PrYHA9+7XkKgSPveQaBI39k8sbz+YMmefkK6doDp16v + +ryVVb+zu3vuQ7Xr6xI48ur9dgkc+YuSF2qZ3AA0jwXcHNPZAEiPaRzY81y8uJlUgSO/MXmLD97Iyh+V + 6qNxfQxiS+P2nZX//aqrzt+XSzogaX38+tgcD37teQqBI+95BoEjf+TyHnPjjfcL15sXNa8/yderHu/n + ZNWP8C2Dj0T9JIEj35oXapHUAOzXL7I0rrUBkP5d651ZdWvXZlIEjvxG5U2y6ulSbTRuHri+4zHOy+dd + dtmd4vrDWjayfsGepxA48p5nEDjynqfWnfca58V31def1OtVn5tZ+NPptPXdI3Dc3wr7vUfgyF/UvFAH + dQPQrB8sjYPFBmAVYzL8uVvXZrQCR76zOFqBI3+oeZNsr1p89GWjNho3Dxwsjdt3Vn5zWMrSn/lBYS0b + Wb9gz1MIHHnPMwgcec9L14nRtPrO5OtVj6W8MM97R9nZnPOqhX1xf0Ps95LmhTqoGoBm7WBpXO1BG4B6 + wqgB2MhiawSO/IG88Xz+4eGEfbNUnz7HB622NK72OK++KSzFb/5B4Mh7nkHgyHueQeDIH5s8/JozfHf+ + 3drrVZ/jnGbeeFq9aXs2+1BO3yusj/sbbL/kL0leqEVvA9CsHSyNiz1YAxBPygZgY4vdJ3DkD+RdfcP1 + V0ym1W9K9elzXL/a0rh9Z9VzwlL85h8EjrznGQSOvOcZBI78sctbvGFQXi2aAPE6pXR83au9NG5a/erO + zs59uIxWxeuLvJb1i9yZF+rR2QA0awdL45oepAFoTszXAGxssbsEjvxS3iQvvk2qT5+b9YOlcfv2m/++ + wJH3PIPAkfc8g8CRP7Z5F17wXJmufXDa9a/4Vi5FlLQ+fr3RxyPUpLUBaNYOlsZJXrkBkCYPPs91JwlF + YDGSitMmcOQPPS/clD9Kqk+fhdqJ4yK/MCzFb/5B4Mh7nkHgyHueQeDIe95ld95rlFc/KFyvOm24/uEb + oHNc0gFhHVyPsL50gSN/yfNCXcQGoFk7WBrX5pUagI7JxQ8D6hKKwGIkF0cSOPKHnnfq1N5D8TuquDYa + d9RP9rR82Xw+v5xLOiCsg+tZWh+HJAkcec8zCBx5zzMIHHnPMwgc+YuWhz9DxnuRiNcuwcnXv30Xb7gm + zx/MaRfCOrie1vWlCBz5tcgLtVlqAJq1g5tj+mxuAHomT2oAUAQWw1ScpsCRvxh5J8J+/2e0d5V76rfk + cV79hvSJfhDWwfVI60sWOPKeZxA48p5nEDjynmcQOPIXPQ9vRIZ3I5WuYbFTr39N4xNOOeWxOB6hPgca + gGbt4PhxrU0NgGJydQOAIrAY5uLEAkf+ouSNp3tPbey914r6Nf06/JRhsaCGsA6uR1xfqsCR9zyDwJH3 + PIPAkfc8g8CRv2R5eCtyvJWvcB1b2HD9Ez2a7n0y1sH1qNfXJXDk1yov1Gi/AWjWDo7rkuLkBkA5uaoB + QBFYjJWKUwsc+YuS98TZ9f9qlBXvEPbfamX9IhdvvSbf+8jFghrCOrgecX2pAkfe8wwCR97zDAJH3vMM + Akf+kufhw8ika2P69a/D0+pt1+bl4y3rkwSO/NrlhTotGoBm7eCluiQ4qQFImLy3AUARWIyViwOBI3+x + 8k6M8+KnhL23OqF+dPG+Sb53lvMdENbB9bStL0ngyHueQeDIe55B4Mh7nkHgyK9N3nhWfEy4jt1dX8/S + r3/dBr+dlT9jXV8scOTN+40FjvwgeWGvt8R1qy3VJcXqBiBx8s4GAEVgMQYpDjjyFy1vlJWfKOy71Yn1 + u+CsfDqnOyCsg+tpXV+KwJH3PIPAkfc8g8CR9zyDwJFfu7xxVn4lrmWm61+H45yTeXnLUa0fBO7krLo9 + 3jMs1SXVqgagObFi8tYGAJthMQYrDvmLljc6d+79Dvvzsfkil6U/98M6uJ7W9aUIHHnPMwgcec8zCBx5 + zzMIHPm1zLvyytsu354VL029/nW5mTXOq7+89tqPfn9OmSTsi/sbZL/gyA+aFxqAO+I9S3WxuLcBiCdN + mFxsAOrNBA9aHOZctLxJXn6DsGfRlvqNp8UfSq/4xzq4ns71aQWOvOcZBI685xkEjrznGQSO/FrnXVfM + Hhmuma/TXv+6HF9HD+Rl5bM5rVr1+oIH3S9zBs2LG4BmTVZxZwMQFzlx8qUGIN5M5LUsduSlvK3ds0/A + h1MIe16ypX7hO/93Yw5Oty+sg+vpXJ9W4Mh7nkHgyHueQeDIe55B4MhvRN7J2TwP36n/s3TN07r7elrc + hRcecvpeNddHr3H9LjQAcT1SLfGtDUBc5NrSuBYfaACam6HXtti0lHcinGi/KOx3ydb6jbPqcznXvrAO + rqdvfSqBI+95BoEj73kGgSPveQaBI79ReeG79C+WrnkaK6+nLw/Ti++SGiusZePqh9cACPtVu61mYgMQ + F7kN7PF+AyBthl9v3Mm/NS1vEva6ZGv9xtPyp8M0B05grIPr6V2fRuDIe55B4Mh7nkHgyHueQeDIb2De + nXjL9F+Qrn1dTrqeZtVHcSmisA6uR1hfusCRP9S8sOdbxP0q3FU3VQMgjenxogEIC9/IYgcLeTh5y1cJ + ez3gZu209RtNq7ecms8/hJMthHVwPYr19Qscec8zCBx5zzMIHHnPMwgc+Y3Nu2Y+f+RkWr1dugZKTr6e + ZuXv41rN6Q4I6+B6WteXInDkDz0v7Fv8LIA+99WutwGQHlf4Ziyai1/aDPebJHDkL0neJC97O7C4bqn1 + 25oVn8SpFsI6uB7V+voEjrznGQSOvOcZBI685xkEjvzG52mupfAK19Mj9xq0sPfkBqBZO7g5prMBkB7T + OLDnuXhxM6kCR/6S5OEDeEbT8k+lvdauaxZbGie7eGmYZv9H/1gH16NaX5/Akfc8g8CR9zyDwJH3PIPA + kT8qeSf6PjRolevpKCv/+Pz58/fmXEeifmH/SQ1As3awNK61AZD+XeudWXVr12ZSBI78JcubZNVnSPus + 3Sx0Sv1GefWu8Xz+EZzqSJysKQJH3vMMAkfe8wwCR97zDAJHPilvsnv2sZNp8R7pmrjK9XTfWXkb5sE6 + uJ6k9bUJHPmLmhdqoG4AmrWDpXGw2ACsYkwWGoDbujajFTjyncXRChx5dd5jbrzxfqFbfb20V7hZaFga + 1+ZxVn0JpzoyJ6tW4Mh7nkHgyHueQeDIe55B4Mib8sL1787m9XDV6+m+p+VfbG193P25HtP6mgJH/qLn + hTqoGoBm7WBpXO1BG4B6wqgB2MhixxrnZeufX8RFri2Na/NoWvwRPkMb82AdXE/S+toEjrznGQSOvOcZ + BI685xkEjvyRzZvP5/cf5dWf1dfDVa+nTW/Pqs9cZX2xwJG/JHmhFr0NQLN2sDQu9mANQDwpG4CNLXak + E3hXvr791pbGdXkrL/YwCdbB9aSuTxQ48p5nEDjynmcQOPKeZxA48kc+L3yn/tEXroXLbl4vU7zIyIo/ + KIr8QausDwJHfuX9QuDIq/PCfjobgLhutaVxTQ/SADQn5msANrbYtcbTqtTsF5bGdXk0LX8Oc2AdXE/y + +iSBI+95BoEj73kGgSPveQaBI38s8sbjq++9NSt/fdXraew4Z2e2d+Mq6wNHfpD9giOflBf20toAxPut + LY2TvHIDIE0efJ7rThKKwGIkFadN4Mib8kZZ9eOa/TbHqHxm7xTWwfWY1tcUOPKeZxA48p5nEDjynmcQ + OPLHKg836ZWvp3Scc8Hlj6+6vuBB98ucpLywF7EBWN7v8pgur9QAdEy+9HeYfUIRWIzk4kgCR96Utz0t + rwz72P8sa7hjv6l+MdbB9ZjW1xQ48p5nEDjynmcQOPKeZxA48scybzKrXr7C9XTh5rX5Ql7xvq0z5aM4 + rVrN9dGXrH5hL0sNQHOvcHNMn80NQM/kSQ0AisBimIrTFDjy5rxxXj4v2k/ffhMcTsi8uprrMa8vFjjy + nmcQOPKeZxA48p5nEDjyxzbvZD7P5Oulzs1rM1w/Ns6rb0KdtQrrWbv6hf0caACae4Xjx7U2NQCKydUN + AIrAYpiLEwsceXPe4tWpWfGOej+K/ao9zsof5nrM64sFjrznGQSOvOcZBI685xkEjvyxzwvfHL1Eumb2 + uf/6XLy1/murPmEdXM/S+jgkSeDIr5QX9rTfADT3Ch/cr97JDYByclUDgCKwGCsVpxY48ivljbLyE+u9 + KPer9smsKlZdXy1w5D3PIHDkPc8gcOQ9zyBw5D0v6JppNZOumV3WXp9HWfWxi0V0COvgesT1pQoc+ZXz + wr4WDUBzr3BzrylOagASJu9tAFAEFmPl4kDgyK+cN86qH8U+Evar8lZW/cYQ64PAkfc8g8CR9zyDwJH3 + PIPAkfe8e3RinFe/K107Jaddn8sf5hyisA6up2t9aoEjP0he2Nstzb3C8l71VjcAiZN3NgAoAosxSHHA + kV85b+fs2QfiLSoT99tr8Cd3i/gtktdivxA48p5nEDjynmcQOPKeZxA48hufN57uPVW6fjbdvDbD0rja + 42n17muvvfEDOc0BYR1cT+/6NAJHfrC8k7Pq9pT9aq1qAJoTKyZvbQCwGRZjsOKQHyRvlJWfYdhvp5nx + +htu2HvIqusDR36Q/YIj73kGgSPveQaBI+95BoEjfyTy8Lv6UV68UbqO1o6vy7WlcUvO9j6N0+wL6+B6 + VOvrEzjyg+aFBuCO5P0q3NsAxJMmTC42APVmggctDnMGyQv7+2XDfltdZ2zPqq8eYn3kB9svec8zCBx5 + zzMIHHnPMwgc+SOVF66bX928jtaOr8u1pXGS8QmEnGIhrIPrSVpfm8CRHzwvbgCkvVnd2QDERU6cfKkB + iDcTea2KPS3njw57vNuwX9FRzt2nyvlVq66P/GD7Je95BoEj73kGgSPveQaBI3/k8q7J9z6y53q6b2lc + u4v3nTq191DMgXVwPcnrkwSO/KHk1Q2AvC+dJb61AYiLXFsa1+IDDUBzM/TaFXtndvDH/8K+1I5ztmfF + rwyxvuBB98scz0sUOPKeZxA48p5nEDjyRzZvlFW/1nY9rR0/rvU4K5+MdXA95vXFAkf+0PLwGgBpP1q3 + 1UxsAOIit4E93m8ApM3w67Ur9mRW/pBxvwcc1+2Cy88ZYn2R17J+kT1PKXDkPc8gcOQ9zyBw5NcqL3y3 + /jnt19Pla67W47x8Idez0vpqgSN/qHlhz7dI+9G4q26qBkAa0+NFAxAWvjEnKz41apxVbzLud9/N2m1l + xXtOnd17MKdMUry+yGtZv8iepxQ48p5nEDjynmcQOPJrl7czn3/QaFq9d+l6Gixdd7UO/BujTwhcm/1C + 4Mgv5YV1i58F0Oe4bnDz8d4GQHpc4ZuxaC5+aTPcb5LAkT+UvJ2imq6w34XjutWeTMsf55RJaq6PXtv6 + 0Z6nFDjynmcQOPKeZxA48mubV38+wIHr6QquM64t9q4dYn3kB9sveTEvrDu5Aaj3G7s5prMBkB7TOLDn + uXhxM6kCR/7Q8rbz8iukvWhd1yw2/n2cl5/JadWS1sevN+JkTRU48p5nEDjynmcQOPKeZxA48oPmbefV + Fzevp1bHOSH3y4ZYX/Cg+2WOmBfWndQAxPutLY1rbQCkf9d6Z1bFb3iztJkUgSN/qHmTrHq5tBeNm4WO + 67eTnf1wTq1SWMtFP7lSBI685xkEjrznGQSOvOcZBI782ueF79S3m9dTi+Pr8iJrVr18iPVFPvT6hXWr + G4DmfmFpHCw2AKsYk4UG4LauzWgFjnxncbQCR/5A3nh89b3xgRHSfvrcLDRcPzbOq9dyapXCWi7JyaUV + OPKeZxA48p5nEDjynmcQOPIbkYff1Yfr6evj622qm9dmeDSt3hymO3FhVr2a66MvSv3CulUNQHOvsDSu + 9qANQD1h1ABclOJoBI78Uh4+L1raT5/jIteOH8dHCnP6XmEdXM/S+jgkSeDIe55B4Mh7nkHgyHueQeDI + H+u8SV5+d3xNTXHX9Xl8unoEp1YprOWS1i+svbcBaO4VlsbFHqwBiCdlA3DRitMncOTFvHFWfYK0py7H + +629NG5afvRiAT3COrgecX2pAkfe8wwCR97zDAJH3vMMAkf+2OfFn8ya4r7r89a0vAm11gjrCMZ6sK7a + F7V+Yf2dDUBzr7A0rulBGoDmxHwNwMacrGEPz2ruqcvN/cLSuPpdp7qEdXA9retLETjynmcQOPKeZxA4 + 8p5nEDjynhe0NT37YdK1tcua6/M4K79msYAeYR1cj7i+VIEjn5QX9tDaADT3CkvjJK/cAEiTB5/nupOE + IrAYScVpEzjynXmjvPpJaW+Shb2K40Lm/2N8q7AOrqdzfVqBI+95BoEj73kGgSPveQaBI+959+jEJC/+ + RrrGStZen0PmS5nfKqyD6+lan1rgyCfnhX2IDUBzr7A0rs0rNQAdk4sfBtQlFIHFSC6OJHDke/PG0+pN + 8b7a3LFfwcVLGC8K6+B6etenETjynmcQOPKeZxA48p5nEDjynteQ9hu0lOszPnGQ8aKwDq6nd30agSNv + ygt7WWoAmnuFm2P6bG4AeiZPagBQBBbDVJymwJHvzds5e/aB0bpb3bPfJY+z8is5xZKwDq6nd30agSPv + eQaBI+95BoEj73kGgSPveYLC9bT3V7Sp12f4qvn8/TnFAWEdXI9qfX0CR96cF/ZzoAFo7hWOH9fa1AAo + Jlc3ACgCi2EuTixw5FV5ozPzqxtrX7Jiv8vOqo/iFAeEdXA9qvX1CRx5zzMIHHnPMwgcec8zCBx5z2tR + 34u0Tdfn4K3ds0/gFPvCOrge9fq6BI78SnlhT/sNQHOvcLyvFCc3AMrJVQ0AisBirFScWuDIq/PwSn1h + /ftW7nfJo9m5R3OKfWEdXI96fV0CR97zDAJH3vMMAkfe8wwCR97zOnTNtHy8dI2FrddneDQrbuAUC2Ed + XE/S+toEjvzKeWFfiwaguVe4ua8UJzUACZP3NgAoAouxcnEgcOST8ram1WcL6184Yb9N372zs3MfTrEQ + 1sH1JK2vTeDIe55B4Mh7nkHgyHueQeDIe16Pdnae9ADhGrvK9Xnh+G3asQ6uJ3l9ksCRHyQv7O2W5l5h + aV8pVjcAiZN3NgAoAosxSHHAkU/OG+fV1wvrT91vw8UbGL8Q1sH1JK9PEjjynmcQOPKeZxA48p5nEDjy + nqfUaFq9Jb7GrnZ93vezkI11cD3m9cUCR36wvJOz6vYB9rtkVQPQnFgxeWsDgM2wGIMVh7wpb5KXP9Bc + v2G/BzzKi19n/EacXOQ9zyBw5D3PIHDkPc8gcOSPdN5kWvxefX1d9fpcO3zz9/1YB9ez0vpqgSM/aF5o + AO5Ydb+SexuAeNKEycUGoN5M8KDFYY4pLzQAr4jXbtxvw+UPIxvr4HrM64sFjrznGQSOvOcZBI685xkE + jrznJWoyLX8M19Zhrs8XPJ5Wv8D1rLw+CBz5wfPiBkDai9WdDUBc5MTJlxqAeDORL3mxw3frv12ve4X9 + HnRWfjPWwfWstL5a4Mh7nkHgyHueQeDIe55B4Mh7nkGTvPj2wa7P9FZW/c5Q6wNH/lDy6gZA2ofWEt/a + AMRFri2Na/GBBqC5GXotih3W+hqsecX9HvA4K7+W61l5fRA48p5nEDjynmcQOPKeZxA48p5nELitWfXc + oa7P8IWM8o+GWh/5wfZLfj8PrwGQ9qF1W83EBqAeHFsa1+H9BkDaDL9ei2JPpuVfDLDfAw4n61cNtT5w + 5D3PIHDkPc8gcOQ9zyBw5D3PIHDgw8362YNdn+nJrPqLodbHnMH2y5z9vLDeW6S9aFzvd7HnhlUNgDSm + x4sGICx87U+urbz42wH2u2/w23n1xUOtj/xg+yXveQaBI+95BoEj73kGgSN/7PK2ZntfPtT1ufY4q940 + 1PoiH0peWK/4WQB9jvcLNx/vbQCkxxW+GYvm4pc2w/0mCRz5QfPCd+v/MMB+F74np/zcodbHnMH2yxzP + SxQ48p5nEDjynmcQOPLHMu9kVn3BcNfnCx7nxd8PtT760OoX1pvcADT3CzfHdDYA0mMaB/Y8Fy9uJlXg + yA+eN86Kf1l1v3CdAe/Mys8Yan2RPU8pcOQ9zyBw5D3PIHDkPc8gcMHgkbPwTl7+W+m6q3V8fa49mlbv + 5ZRJktbHrw+tfmG9SQ1Ac6+wNK61AZD+XeudWXVr12ZSBI78oeTVDYC0D63jIsOhAbhjqPXRa1s/2vOU + Akfe8wwCR97zDAJHfqPyJln5adK1V+Pm9RnGv1sagLCWS1K/sGZ1A9DcKyyNg8UGYBVjstAA3Na1Ga3A + ke8sjlbgyO/nhfX+g7QPreMi1x5l5WdwyiRJ6+PXa1s/fu15CoEj73kGgSPveQaBI79xeV1v2d5l6fpc + PzbKindwapWwDq5naX0ckiRw5HvzwrpVDUBzr7A0rvagDUA9YdQAXJTiaASO/IG8SV78jbQXjeMi18a/ + j7Pq8zitWmEtl+zk0ggcec8zCBx5zzMIHHnPMwgc+Y3MG+V7X9i8/va57fpcezSt/noxuUJYB9cjri9V + 4Mir8sLaexuA5l5haVzswRqAeFI2ABetOH0CR34pD38GKO2nz/F+a9ePjfPqGZxaJayD61laH4ckCRx5 + zzMIHHnPMwgcec8zCBx5z6PGWfmV8fW3z13X59rhOv3njO8U1sH1tK4vReDIq/PC+jsbgOZeYWlc04M0 + AM2J+RqAjTi5wvoXbwSU4uZ+4fjxcLJ+zWJyhbAOrkdcX6rAkfc8g8CR9zyDwJH3PIPAkfe8SG0f2ia5 + 7/q876x8FeNbhXVwPZ3r0woc+aS8sIfWBqC5V1gaJ3nlBkCaPPg8150kFIHFSCpOm8CRb82L3wpYY2Gv + y+Oy8psZ3ymsg+tpXV+KwJH3PIPAkfc8g8CR9zyDwJH3vIYmefFtS9dZwarrc+1p9ZuMF4V1cD2969MI + HPnkvLAPsQFo7hWWxrV5pQagY3Lxw4C6hCKwGMnFkQSOfGde88OAutyx34YvfBhQl7AOrqdzfVqBI+95 + BoEj73kGgSPveQaBI+95guoPA+qy/vp8weNp9fOMXxLWwfWo1tcncORNeWEvSw1Ac69wc0yfzQ1Az+RJ + DQCKwGKYitMUOPK9edLHAUvu2e8Bxx8HLAnr4Hp616cROPKeZxA48p5nEDjynmcQOPKe16L444Alp1yf + a+PjgBl/QFgH16NeX5fAkTfnhf0caACae4Xjx7U2NQCKydUNAIrAYpiLEwsceVWe5ndLiv02XLyB8UvC + Orge1fr6BI685xkEjrznGQSOvOcZBI6853VoNK3eIl9rLdfnfT+L8fvCOriepPW1CRz5lfLCnvYbgOZe + 4WhPSU5uAJSTqxoAFIHFWKk4tcCRV+f1/X2pcr9N372zs3MfTrEvrIPrUa+vS+DIe55B4Mh7nkHgyHue + QeDIe16Hdnae9ADhGruw8fq88DgvP5NTLIR1cD1J62sTOPIr54V9LRqA5l7h5r5SnNQAJEze2wCgCCzG + ysWBwJFPyptMy48W1r9wwn6XPJqdezSnWAjr4HqS1tcmcOQ9zyBw5D3PIHDkPc8gcOQ9r0fXTMvHS9fY + Va7P8GhW3MAp1r5+YW+3NPcKS/tKsboBSJy8swFAEViMQYoDjnxy3ujM/Gph/an7XXZoLDjF2p9c4Mh7 + nkHgyHueQeDIe55B4MgfybxxVn1C8/q68vU5eGv37BOQj3VwPab1NQWO/GB5J2fV7avuV7KqAWhOrJi8 + tQHAZliMwYpD3pR37bU3fmBz/Yb9LhlvXIF8rIPrMa2vKXDkPc8gcOQ9zyBw5D3PIHDkPU+pSVY+O762 + DnF9hkfnzr0f1sH1mNcXCxz5QfNCA3DHqvuV3NsAxJMmTC42APVmggctDnPMeeNp9aZ67cb9Ci5egnVw + PSutrxY48p5nEDjynmcQOPKeZxA48p6XoHFe/FR9XR3q+jzKizdiHVzPSuurBY784HlxAyDtx+rOBiAu + cuLkSw1AvJnIa1HsUV79JNa9wn6XHE6w13M9K68PAkfe8wwCR97zDAJH3vMMAkfe89J0Inwz9be4pg55 + fQ6ZL+N6Vl3fQuDIH0pe3QDIe9FZ4lsbgLjItaVxLT7QADQ3Q69Nscd59awV97tk8Fk5/8gh1geO/CD7 + BUfe8wwCR97zDAJH3vMMAkf+yOeNT1ePqK+nTTevuSnenlVfH9ZTH4u1rx9eAyDtQ+u2mokNQFzkNrDH + +w2AtBl+vTbFDifD0isshT2pXWfs7BZPHmJ95AfbL3nPMwgcec8zCBx5zzMIHPljkbc1K26Or8u1peuu + 1uDDNf8pQ6wPHPlB9guO/IG8sOZbpL1o3FU3VQMgjenxogEIC9+Ik/XM7t7VK+5333FO8AuGWF/woPtl + juclChx5zzMIHHnPMwgc+WOTt51V39e4porXXa3rjOtm5ROGWB/5wfZLfikvrFn8LIA+1/ut3Xy8twGQ + Hlf4Ziyai1/aDPebJHDkB88rivxB41nx1hX2u3Bct4Vn1Z8Osb7Ia1m/yJ6nFDjynmcQOPKeZxA48mub + F67LDxzPqr+Mr6nSdVfre67Lxd/imr/q+sgPtl/yYl5Yd3IDsL/fyM0xnQ2A9JjGgT3PxYubSRU48oeW + t5WVPyftReu6ZrEX/36mfBSnVUtaH7/eiJM1VeDIe55B4Mh7nkHgyHueQeDID5p3arfaaV5PrY5ztvPq + Z4ZYX/Cg+2WOmBfWndQAxPutLY1rbQCkf9d6Z1bd2rWZFIEjf6h5k6x6urQXjZuFjus3zsvP4tQqhbVc + 9JMrReDIe55B4Mh7nkHgyHueQeDIr33ezqx8RvN6anF8XYZDA/AlQ6wv8qHXL6xb3QA09wtL42CxAVjF + mCw0ALd1bUYrcOQ7i6MVOPJLeW3vCNjnZqHh+PFRVv04p+8V1sH1LK2PQ5IEjrznGQSOvOcZBI685xkE + jvyxzNuaFT/bvJ6munlthk9O51dxyiQ110dflPqFdasagOZeYWlc7UEbgHrCqAG4KMXRCBz5trwTeHMI + aV9tjotce3lccdd4Pn8Q52gV1sH1tK0vSeDIe55B4Mh7nkHgyHueQeDIH8u8M/PdK8dZ9d7l66ne4vV5 + Wv5lmO7EhVn1aq6Pvmj1C2vvbQCae4WlcbEHawDiSdkAXLTi9Akc+c68SVb+F2lvkuP91pbGLTyr/g2n + EIV1cD2d69MKHHnPMwgcec8zCBx5zzMIHPljmxeup18kXkuVbl6bYfz7OCu/l9OqJa2PX1+0+oX1dzYA + zb3C0rimB2kAmhPzNQAbd7KGtR/Kj1kmefkKTrEkrIPr6V2fRuDIe55B4Mh7nkHgyHueQeDIH+u8cV79 + hnwt7XfP9fk8p1YprGUt6hf20Hpvau4VlsZJXrkBkCYPTipyLRSBxUgqTpvAkVfl7cznHxT2dHdzj7GF + vYrjmt7Jzn44p9kX1sH1qNbXJ3DkPc8gcOQ9zyBw5D3PIHDkj3Xe9pn546RrqMbd1+fifVedvv4hnL5X + YS1rU7+wD7EBaO4Vlsa1eaUGoGNy8cOAuoQisBjJxZEEjnxS3nha/Xy8x9gd++13Vn4pp1gI6+B6ktbX + JnDkPc8gcOQ9zyBw5D3PIHDkj33eOCu/RryG9lhxfX45p+8V1sH1LK2PQ5IEjrwpL+xlqQFo7hVujumz + uQHomTypAUARWAxTcZoCRz45b5yX4nsu9+y31/hwoPl8fjnmwDq4nuT1SQJH3vMMAkfe8wwCR97zDAJH + /tjnXXXV+fuOptVfS9fQLmuuz1t5eSuX0Cmsg+tZWh+HJAkceXNe2M+BBqC5Vzh+XGtTA6CYXN0AoAgs + hrk4scCRN+XtnD37wMm0eE+8H8V+tcYbJK3dyRULHHnPMwgcec8zCBx5zzMIHPmNzMNNWrhudlpzfR7l + 1bseP51+wGIRHcI6uB5xfakCR36lvLCn/QaguVc43muKkxsA5eSqBgBFYDFWKk4tcORXyhtn5Y/Ue1Hu + V+VRXvw617PS+mqBI+95BoEj73kGgSPveQaBI+95F3RikpW/L10726y9Podr+v/gHK3COrietvUlCRz5 + lfPCvhYNQHOvcHOvKU5qABIm720AUAQWY+XiQODIr5w3zquPxz4S9qsy+J3dYm/V9UHgyK+8Xwgcec8z + CBx5zzMIHHnPMwgc+Y3Nm+TFXLputrl5bYalcfB4VnwMpxGFdXA9retLETjyg+SFvS19Yi0s7TXF6gYg + cfLOBgBFYDEGKQ448oPkXX3D9VdsZdXbE/bb6zpje1a9ZNX1gSM/yH7Bkfc8g8CR9zyDwJH3PIPAkd/o + vPCN109I107J8XW5tjQOHk2rt+zs7NynbclYR/BaH4+Ts+p27X5TrGoAmhMrJm9tALAZFmOw4pAfNG87 + r74jYb+djnOC797J59etur7gQffLHM9LFDjynmcQOPKeZxA48hudt52XO9K1U3LjerqwNG7fWfmNnGZJ + WAfX07k+rcCRHzQvNAB3qPeb4N4GIJ40YXKxAag3EzxocZgzaN6p+d5oKy/ep9xvq5u1g0dZ9ROcMknx + +iKvZf0ie55S4Mh7nkHgyHueQeDIX/S8SVb9jHT9bFq6nkrjao+mxb9I78ECYR1cT+/6NAJHfvC8uAGQ + 9ml1ZwMQFzlx8qUGIN5M5LUsdu3tWfFSYW9qd9VvO5uf5tQqSevj12tbP37teQqBI+95BoEj73kGgSN/ + 0fO0v/vvup52+EWc5oCwDq6nd30agSN/KHl1AyDsT22Jb20A4iLXlsa1+EAD0NwMvbbFpj9we1YWwt5U + 7q1fVv0Cp+9VWMtG1i/Y8xQCR97zDAJH3vMMAkf+UuSdGGXVrx24NgruvZ62eGu6d4bz7Avr4Ho06+sV + OPKHlofXAEj707qtZmIDEBe5DezxfgMgbYZfb8LJeiLs5ZWNvfVaXb+sOndhFe3COrgeaX3JAkfe8wwC + R97zDAJH3vMMAkf+SOSFm//HitfGyOrracOjvPjtMMWBT/7DOrge1fr6BI78oeaFPd8i7VHjrrqpGgBp + TI8XDUBY+EYWO3g/b5LtfZqwv1Y3a9dVv3FevRbvfMWploR1cD2t60sROPKeZxA48p5nEDjynmcQOPJH + Iu/06dNXTKbF/5GujbVTrqdLzspP4VQLYR1cj2p9fQJH/tDzwr7FzwLoc1/tehsA6XGFb8aiufilzXC/ + SQJH/qLm4QYdvlP/v8IelxzXLaF+X86pDgjr4Ho616cVOPKeZxA48p5nEDjynmcQOPJHJi98A/RM4Xq4 + b+P1dOGQ/efxn/5hHVyPen1dAkf+ouSFvSc3AM3awc0xnQ2A9JjGgcVb3l604qQKHHlV3nhWfbq0z9h1 + zWJL45oeT6t3X5PvfSSnWgjr4HpU6+sTOPKeZxA48p5nEDjynmcQOPJHJm+U7z1ukhd3SddE2Ho9rT2e + 7j2VUx2J+oX9JzUAzdrB0rjWBkD6d613ZtWtXZtJETjylywPH+IT9vW65j5rNwudWr9RXv1kmGbxuyqs + g+tRr69L4Mh7nkHgyHueQeDIe55B4MgfpbwTh/apqxf8mvPnz98bE2EdXE/K+loFjvxFzQs1UDcAzdrB + 0jhYbABWMSYLDcBtXZvRChz5zuJoBY58ct44K5/ctt+mpXEK+wcFeV6SwJH3PIPAkfc8g8CRT8ob59Wn + Cte/hYe4no6z6hMwD9bB9SStr03gyF/0vFAHVQPQrB0sjas9aANQTxg1ABtZbFl33it8p/4H0n5jx4+n + uXjr6d29x9nXd1DgyHueQeDIe55B4Mh7nkHgyB+pvK0z5aNGWfEO6Ro4xPU0XKN/J0xzAuvgepLW1yZw + 5C9JXqhFbwPQrB0sjYs9WAMQT8oGYGOL3aZRvvckab+143qkesHPil+czW54sHV9tcCRX2m/tcCR9zyD + wJH3PIPAkfc8g8CRv6R5+LF8+O78l9uuf01L4/o8mhU3YB1cT9L62gSO/CXLC/XobACatYOlcU0P0gA0 + J+ZrADa22B06MZqWP9/cLyzVRes4ZyevvnSF9a17/TzP85IEjrznGQSO/CXPm2Tll/Zd/2pL4/o8zouf + Go+vvjfXk7w+SeDIX9K8UJPWBqBZO1gaJ3nlBkCaPPg8150kFIHFSCpOm8CRHyxvZ1bujPPqn+P9SnXR + Os5ZOCveM9rdG3PKJGF93N9g+yXveQaBI+95BoEj73kGgSN/yfPwYT+jafXe3utfcHOMytPiPdtn5vgV + 6lrsVxI48sl5oS5iA9CsHSyNa/NKDUDH5OKHAXUJRWAxkosjCRz5wfO28vK5jf2aHNetkfeaq+bz9+fU + KsXri7yW9YvseUqBI+95BoEj73kGgSOfnLdz9uwDww36T+JrH9xx/Uv2OCufyfUkr08SOPJrkRdqs9QA + NGsHN8f02dwA9Eye1ACgCCyGqThNgSN/KHm7u+c+dJxXfxntN9k99cMJ/SNh6gNvY9mm5vrota0f7XlK + gSPveQaBI+95BoEjb8i7816Tafmy+NoG913/kjwt/2I+nz3Mtr5lgSO/NnmhPgcagGbt4PhxrU0NgGJy + dQOAIvBgbdTB25oVH9/Ys9qK+l1wVn4Zl9GqsJaNrF+w5ykEjrznGQSOvOcZBI68KS98I/O1zeua+vqn + 9PZs78nW9TUFjvxa5YUa7TcAzdrBcT1SnNwAKCdXNQAoAouxUnFqgSN/MfJOTLLqfwl777SyfrXvDnN8 + 1IXVLAvr4Hqk9SULHHnPMwgcec8zCBx5zzMIHPm1yBvn1dI3SYnXv15vzaqftK6vKXDk1y4v1GnRADRr + BzdrkuKkBiBh8t4GAEVgMVYuDgSO/EXLG5+uHjGZVm8T9i86oX73eFq9fbJ79rGccl9YB9fTur4UgSPv + eQaBI+95BoEj73kGgSO/Fnlbu2efEK5f74yvZabrX4e38uJtp3erf21ZX1PgyJv22xQ48oPkhVrd0qwd + LNUlxeoGIHHyzgYARWAxBikOOPIXPS/UQXx1ZtPN2sHSOMmjvPqz0ZlzD+OUR6p+GoEj73kGgSPveQaB + I+95Cm3PZh/a/AC1Va5/ksEfxXeclQTu5Ky6fcj61VY1AM2JFZO3NgDYDIsxWHHIX7K8cVb+D6EG+zbU + b8l4hyv8ZQDWwfWo19clcOQ9zyBw5D3PIHDkPc8gcOTXIg+v+D/cd0y9wG/n5Yss62sKHHnTfpsCR37Q + vNAA3DFU/WL3NgDxpAmTiw1AvZngQYvDnEuWd9Xp6x8yyos3CnWw1q/NP5vn1z80dX1tAkfe8wwCR97z + DAJH3vMMAkd+LfLm8/n9J3n5iviaNfD170JGVr5hWhUfnrq+psCRN+23KXDkB8+LGwCpLlZ3NgD1hLGl + cYKXGoB4M5HXstiR1XmTrDrXrMMK9RMNHp2vv11wusCR9zyDwJH3PIPAkT+SeRfe5rf8keb1qun48VTX + Gdu75cemrq8pcORN+20KHPlDyasbAKkuWkt8awNQFzu2NK7FBxqA5mbotS02nZw3yYtvrWuwYv2W3Mh6 + QVHkWOORql8tcOQ9zyBw5D3PIHDkPU+lO+8VvvN/Qcf1auH48VTv58yq56ev76DAkTfu96DAkT+0PLwG + QKqL1m3HQGwA9osdWRrX4f0GQNoMvz5yB++qq87fdzKtfnWA+h2wlDfOy/8UplS9UVAs7Iv7W3m/EDjy + nmcQOPKeZxA48p5nEDjyxryLd/OfZNWv7u0V+BXoEarfQYEjfyAv7P8WqTYa1/Vb1LBhVQMgjenxogEI + C9/IYgeb884Uu48NJ+rfrFi/fcc5zbxxVj0/TKtuArA+7m+w/ZL3PIPAkfc8g8CR9zyDwJE35oWbf1Z9 + j/Z6ZXGdMZ4Vb7o2Lx+btr6DAkfeuN+DAkf+0PNCDVR/bdZ0Xb/azcd7GwDpcYVvxqK5+KXNcL9JAkd+ + 7fO28+qjws35vSvUb+H4ONReHld8W5i+twmI1xd5LesX2fOUAkfe8wwCR97zVLrzXuOs/N74WqS7Xuld + Z+DD107l1bm09R0UOPLG/R4UOPIXJS/UIbkBqOsXuzmmswGQHtM4sOe5eHEzqQJHfmPyQhPwJVJttK6P + QWxpHByaje/EE5LLWZK0Pn59bI4Hv/Y8hcCR9zyDwJE/knl4wV+47rwwvgalXK80jnN2ZsUXpayvKXDk + TfttChz5i5YX6pDUAMT1qy2Na20ApH/XemdW3dq1mRSBI79Refhc6vG0+iGpPn1uHjjl8XjRY2688X5c + 1r7CWjayfsGepxA48p5nEDjynqfQ6dOnr5hMyx+Lrz3G61WrD2TNqv/hL3hOawAO1I+WxsFiA7CKMdlx + eocm8mLezs6THjDOq9+Q6tTm5oGDpXGyy1fgjTgWiwvCOrgecX2pAkfe8wwCR97zDAJH3vMMAkfelIf3 + O8GLnONrzmrXq2XHOdtZ9ZtVVXywdn1NgeP+TPttChz5i54X6nEo7zg7aANQTxg1ABtZbI3Ake/Mm+T5 + B+OtfKV6NR0ftNrSuE5n5avwGQVYB9fTuT6twJH3PIPAkfc8g8CR9zyDwJE35e1kZz98lJV/HF9rBrle + RT6QNav+NMuqj9Curylw3J9pv02BI39J8kJNehuAA/WjpXGxB2sA4knZAGxssfsEjrwqb+v0/DGjafUW + qW614/rVlsZpPMqL15/aLU9p19cncOQ9zyBw5D3PIHDkPc8gcORNeeFaNGq+02nzWgXHj6f6QNasePOp + +d412vU1BY77M+23KXDkL1leqEtnA3CgfrQ0rulBGoDmxHwNgB+8SNvZ/PQor96lqR8sjdMa/HhWvHN7 + Vn2ydn1tAkc+ab9tAkfe8wwCR97zDAJH3vMUCt/1f+JkWvxj8/rSdPx4quOccV6861Q+n2vX1xQ47s+0 + 36bAkb+keaE2rQ1AXL/a0jjJKzcA0uTB57nuJKEILEZScdoEjvxa5PHzse/uq1/8eKobWXdvzapn4gWJ + XEKSsC/uz7TfpsCR9zyDwJH3PIPAkfe8Xt15r3C9embP9WXh5pgUH8wq3rc923uybn3LAsf9Gfa7LHDk + L3leqI/YABys3wVL49q8UgPQMbn4YUBdQhFYjOTiSAJHfq3yxln1bxX1M7ktD+/RjU8S5BJUwr64v5X2 + Wwscec8zCBx5zzMIHHnP69G11974gZO8eKn2+mL1cl75OZr1SQLH/SXvVxI48muRF+qz1AAs1+/g4xqb + G4CeyZMaABSBxTAVpylw5NcyLzy5Pr+nfsnuzcvKV12T730kl9Ap7Iv7G2S/4Mh7nkHgyHueQeDIe16P + Rvne45ov9oN7ry+JbmbtZNV/0KxPEjjuL3m/ksCRX5u8UKMDDUCzfnD8uNamBkAxuboBQBFYDHNxYoEj + v9Z523n1FR31S3Kc05U3you/H2flk7kUUfX6ggfdL3M8L1HgyHueQeDIe16Pxnn1qZNp9Q/N64b2+qJ1 + M2t7VjxDsz5J4Li/5P1KAkd+rfJCnfYbgGb94Li+KU5uAJSTqxoAFIHFWKk4tcCR34i87bz8mpb6qd08 + Fqq8rPoevEcBl7Wv5vrota0f7XlKgSPveQaBI3+k8vDrwVFe/lfpWmG6vnS4mYVvhPrW1yZw3F/SftsE + jvza5YVaLRqAZv3gZo1TnNQAJEze2wCgCCzGysWBwJHfqLxQqzsbtVM74XgsGT/mu2Z37xouz4+H5yUJ + HHnPMwgc+UuaN9rd25pMiz+RrhGrXF8kN7PwDVDf+toEjvtL2m+bwJFfy7xQr1ua9YOlOqdY3QAkTt7Z + AKAILMYgxQFHfhPzToyz8muFGnY68XjInhbvmeTF5+CvBLgeaX3JAkfe8wwCR97zDAJH3vNatfgkv88P + z/+7pGvDINeXyMt55bO619cucNxfwn7bBY782uadnFW3N2so1TnVqgagObFi8tYGAJthMQYrDvmNzhtn + 1X8Q6ijacDy6nZWvOD0rr+5an1bgyHfuVytw5D3PIHDkPc8gcOSPTB5eDIy3DRevBcFDX1+EvKd3ra9L + 4Lg/9X67BI78WueFBuCOuIZSnS3ubQDiSRMmFxuAejPBgxaHORufF27Et42mxb8I9dy38Xi0ej8nq/7x + ZFZ9QZ7f+KC29fUJHPen2m+fwJH3PIPAkfc8g8CRPyJ5+Ajf6vNGefFP0rUAjq8rtaVxWsc5+Ij0nbz8 + jPb1dQsc96fcb7fAkV/7vLgBkOpsdWcDEB+8xMmXGoB4M5HXstiRL3re1rS86cKP5pfrusLxEC3mZdUv + jmbnHs3lqIV9cX9J+20TOPKeZxA48p5nEDjyRyJve1peGW7AvyxdB2qL14MVHOeM8+rdO3n1SW3r6xM4 + 7k+13z6BI78ReXUDINVZa4lvbQDig1dbGtfiAw1AczP02habvmR5k7yY40/24pqueDyW3JmHt/7Mqs+f + z+eXc0mdwr64P9N+mwJH3vMMAkfe8wwCR37j83Z2du4zyve+sOu7frjzemDwgaysesfObnG9tD6NwHF/ + vfvVCBz5jcnDawCkOmvddkzFBuDAwaOlcR3ebwCkzfBrPxk6hFfnjqbVX6OeAxyPA9bmjafFH46yszmX + JAr74v5W2m8tcOQ9zyBw5D3PIHDkNz5va1buhufxq5vP66a11wOtD2TNir++drc6I61PI3DcX+9+NQJH + fqPyQi1vkWqtcXw8mo+pGgBpTI8XDUBYuB+8FfLG8/mHb+XlHw5wPPbdzNLk4W+Er76uejiXtS/si/sb + ZL/gyHueQeDIe55B4MhvdN72bPahk7z8Aem53LTletDlg1nF754pdh/bXJ9W4Li/zv1qBY78xuWFeoqf + BdDng8dj+fHeBkB6XOGbsWgufmkz3G+SwJE/VnnZ2erDtmfVS1c8HgvHxzU1b5QV7wjNyL+rfy1Qry94 + 0P0yx/MSBY685xkEjvzG5uHH/eO8/ILwfH1n8/kreZXrgeQ4Z3tWvng+nz0sXl+KwHF/rftNETjyG5kX + aprcAMTHo3ZzTGcDID2mcWDPc/HiZlIFjvyxzJvNbnjwdl5+k1RrretjGlsa1+fRtPijcb53U1Hk8V4H + 3S/teUqBI+95BoEjv6l5J/hJo69rPl/bPNT1oHacE75h+Y+8PvjxVQgc+da8UNekBiA+HrWlca0NgPTv + Wu/Mqlu7NpMicOSPfd54uvfUtr8Q6HLzRFj1+C74rPrVk/OqitfHLSQJHPml/XJIksCR9zyDwJH3PIPA + kb8oeVvTvTOTafWr0vO0zc1rweL5vIL3M7Lq3Vv53u3x+lIFjry431SBI7/ReaG+6gagPh6xpXGw2ACs + YkwWGoDbujajFTjyncXRChz5jc3bzuanwxPtr6TaS26eCLA0TutmVuj2X7KTlY/l8pKEfXF/rftNETjy + nmcQOPKeZxA48oeeh0/tC8/HFzefn31uPn9haZzWdcZ4VvzVqbwq6/VxC0kCR35pvxySJHDkNz4v1FjV + ANTHI7Y0rvagDUA9YdQAbGSxNQJH/qLnTfL8g0MT8DPSMYgdnwS1pXFat+WN8uqfR9PqO544u/5fcYm9 + wr64v979agSOvOcZBI685xkEjvyh5k3m848M3/F/d98bhklue/5avZ8xq16e59WjuV4/vgqBI6/KC3Xu + bQDq4xFbGhd7sAYgnpQNwMYWu0/gyF/CPLyXd/lVofZ3N48FHB+P2tI4rTV5aAQmefmCrTPlo7hIUdgX + 95ew33aBI+95BoEj73kGgSN/aHknd6vROC9fGBrt9zafdxprnr8pvpBRvG87L78Wr1Hiev34KgSOvDov + 1LuzAYiPa21pXNODNADNifkaAD94CoEjb8oLT8K9SV78bdfxgOPHU52ah4vUOCu/F+85zmXuC/vi/kz7 + bQocec8zCBx5zzMIHPlDybu22NsON9kfsHzHXzv1+dvnBZ9VfxOu8x/Dda5t/eiNzws1b20A4uNaWxon + eeUGQJo8+DzXnSQUgcVIKk6bwJE/0nlb07MfFpqAX2k7Hs1jluJV8nDRwnsIhGbgiVgn9sX9rbTfWuDI + e55B4Mh7nkHgyA+ed+1umYUb/4vwXbb03NJ6leevZPDbs/J/Z+X8cVgn1+vHVyFw5JPzQt3FBiA+rrWl + cW1eqQHomFz8MKAuoQgsRnJxJIEjfyzyynJ+X3zEJj5wQzgeJsc5K+dl1ct38vLjiyLHhw2tXf3Akfc8 + g8CR9zyDwOGDuE7Oqpvx6ZwrP9+C4+ftEHm4tuBH/jfcsPeQIfZLfrD6kT+SeeHYLTUAzWMLN8f02dwA + 9Eye1ACgCCyGqThNgSN/7PLCdw7zyaz6k8bxSHbz2A6WN6v+OHwH8TnTc3sfNMR+I6/l8YjseUqBI38s + 8qbT6fvt7FafN8nL1w3+fIssjdN6nBWv3ZlXsyH2C478IPUDR/7I5oXjd6ABaB5bOH5ca1MDoJhc3QCg + CCyGuTixwJE/tnl4B65xXv6nxjFRW3F8kyznFX8THrvzmvn8kdyKStJ++bWfLwqBI+95BoEjv3LeTnb2 + w8d5hZ/avWX5+WF3M2vVvPBd/7dVVfHwVfcLgSO/cv0gcOSPdF44hvsNQPPYwvHxSnFyA6CcXNUAoAgs + xkrFqQWOvOcFTfK9synvGQArj6/a/XnF+8JF8CfGs+Jjzp8/f+/FxlqEfXF/4n5TBY685xkEjrznKYW3 + 0l585HdW/S+c+/3PjzQPmjct/3In33+hn2m/scCR97xEheO4aACaxxZeOm4JTmoAEibvbQBQBBZj5eJA + 4Mh7XqTxfP4gvBBPOEZLTji+KifnhQtO+O9Xj09Xj+Dy94V9cX+d+9UKHHnPMwgcec9TCO+RMc7Krw03 + /TfU53vy86PHg+Zl1X85U87/lXW/TYEj73kGhWN5S/PYwuKxS7C6AUicvLMBQBFYjEGKA46857UIfy44 + yqs/E47VwonHt9er5C3+5Glavmw03fvk06dPX4F9cX/q/XYJHHnPMwgcec/r0OjcufebZOWnjPPip/Dd + fnyOr/L8kDxU3mha/ulkWu1xf0n7bRM48p5nELiTs+r2IY5v06oGoDmxYvLWBgCbYTEGKw55z+sRbqbh + gvTs5puJGI5vpwfOeyf+DvrUbnGTv/o4XeDIe55B4Mir8vAj/vG0vH48rf7bZFr8o3A+D/38GCQPb+I1 + zqtnFsX8Adyfar99Akfe8wwCBz40AHescnzb3NsAxJMmTC42APVmggctDnM8Tyn8Xf4oq34Nx8p4fFt9 + mHnjWfGmrVn5/NGsOhm2ceLCbvRCnVivlepXCxx5zzMIHPlNzzuxNZ2fnGTVt4Qb/5uk87h2fD7XlsZp + PUxe+b/Df6/Cvri/vv2qBI685xkEjvwD4wZg+fjZ3dkAxCdV4uRLDUC8mchrWezIRzbvyitvu3wnq/7D + Vla9w3B8Rcc5h56XVf93kpXfPM6LDG+LzG21CnVivQapHzjynmcQOPIbmYcXrF4zrWaTvPjWUV68Pj5v + 29x5Phu8el7x1nFefiaeP9gX9yfuN1XgyHueQeDIL7LqBkA+jjpLfGsDEJ9UtaVxLT7QADQ3Q69tselj + kZeV848MN9PvXcd3HNPn4U8KyxfgR69XXXX+vtzmvuL9Rl7L4xHZ85QCR/5Q87a2Pu7+W/nejeH58j3h + nDvw9tt9Tjuf+71KHl5jM86q5191+vqHdO032M8XhcCRP7Q8vAZAOpZat50jYgMQn1RtYI/3GwBpM/za + TwaFwJE/1LzxdD4aTcufE45lrwc4Xw54lbxRVrwj/PdFo6y8A39NEPbmx9fz1AJHfpF1qpxftZNXnzvO + yh8N3+n/ffN803iV81nyKnmhSf7prd2zT+B2/XzZkLxwjG+RjqfGXeeJqgGQxvR40QCEhfvB26y8E6Os + +tiuvxZounmuGM+XfQ+fV75mO6/+U7iIP2k2u/6DG/tNEjjybfVLEjjynmcQOPKD5eEdKvGC061Z9Xy8 + a+Xq59+ypXFar5D3usm0/GhudSHsl/UarH7kPc8gcOSX8sJxFj8LoM9950pvAyA9rvDNWDQXv7QZ7jdJ + 4Mh7nkHgyPfm4cfok6z6osm0ertwbPcdnycrni8LH3peVvxT2NdPTrLy6eNZdS1esc0t9wp1Yr1666cR + OPKeZxA48ivl7ezs3Cd8Z3/deFY+A59rP86Ld8XnjHReaR3nXLK8afW2cVb9B+yTW14IdWK9VqpfLXDk + Pc8gcOTFvHCskxuA5rkCN8d0NgDSYxoH9jwXL24mVeDIe55B4Mgn5V2T5w8eZ+XXSX/OVJ8jsZtjUnxJ + 8qbVP4T/vjz4y0fZ2fwxN954P279gFAn1iupfm0CR97zDAJHPjkvNH33x4v3wnn9leHG/7P1ua06XxJ8 + yfPCuY0/69s5e/aB3Pq+UCfWK7l+ksCR9zyDwJFvzQvHO6kBaJ4rsDSutQGQ/l3rnVl1a9dmUgSOvOcZ + BI68Oe/q66qHj/PyeZO8uAvHt3lirXq+rEveeFq9O+zxV8Jen4s3IRrNzj16PL763qyXuX6xwJH3PIPA + kdfknbgm3/vIcPyfgr8YWfy527R4T/O4N88VuDkmxZc0D/tb7DX/YNbggFAn1ktTv16BI+95BoEj35kX + jrm6AWieK7A0DhYbgFWMyUIDcFvXZrQCR76zOFqBI+95Bp3Mz37E1uLz/Yt/0ZxcGsc565g3zqq/25oV + Pxv2/Y07u8WTzxS7j0VTwJIkCXVn/Qc5HuDIe97ib/HPftgo33sSvvPFi93Cd/h/Jx3T2EOfL5cq78Kb + e5Uv6PpwLdSJ9ZLqlyxw5D3PIHDke/PCcVc1AM1zBZbG1R60AagnjBqAjSy2RuDIH7u8a4u97e28fBEa + Aek80Do+SWtL47S+WHkXbizlK/CnVPg76u1sfvrx0+kHsFSi4vpFXsvjG3kt864rZo88lVfntmflv5/k + xbeHm98vaW72TbcdX6svRd7iT/ry6vu3p+WVLJWouH6R1/L4RvY8Khz73gagea7A0rjYgzUA8aRsADa2 + 2H0CR/5Y541n564MN8HvlH6s2uf4fKktjdN6LfKm5V/gMwwmWfUtoUF4WvjvOfwa4aabnnQfqX7Bfv61 + CG+0g9qhhuEm/7nbefXt21n5M+E4vF59PDpcZ8SWxml9sfP466pv2zpTPoolaxXqzvqbj0cscOQ9zyBw + 5NV54fh3NgDNcwWWxjU9SAPQnJivAfCDpxA48hubd2o+/5Bww/uGcC68s3luSG6eL7A0Tut1zwvfof3z + 1qz6U9zAtmfFd4a8Lw0+j58c4Ee2x/GvEbBnfELe1nTvTKjR+XFefsHidSaLj8mtXof3pq/rFx+H2vVj + Fm9yHt7nAi/MHZ059zCWslOoO+vfeTy0Akfe8wwCRz4pL5wDrQ1A81yBpXGSV24ApMmDz3PdSUIRWIyk + 4rQJHHnPMwgceVUePno4nBNfPppWb26eJ7WFc0Ucp/XRyCveN8qLN06y4rfC1y/Gd3bhv18d/vs54WL/ + 5NGsrAI32s7OPhJ/p649Hn0CR36QvKtvuP6Ka/Py8dfultn2bvmx23n56aHh+cKwlzu5pxdjj4u9Kt95 + slk7WBqn9ebmFX8zzqovkV7V3yYcRx7PQY4vOPKeZxA48sl54TwQG4DmuQJL49q8UgPQMbn4YUBdQhFY + jOTiSAJH3vMMAkc+OW/xqYOz6t+Mp8UfKs8Xk49t3qz6h62sfEP4jjl8p1z8drg5/GLwS8fT6ofCd9Df + g19B4IVwgfny8N9njPK9cBMu8PvyzwnMZ+FdEidZ+Wk7efkZwf8m+LO38vJz+Tv1z8VYMGCZ8UxkInsx + R5gr+Bcxd8j648m0/Ev82Vm8z9rx+lPteYt/fyWOF55TfHqphOcpn6/Jz19J4Mh7nkHgyJvywrmw1AA0 + zxW4OabP5gagZ/KkBgBFYDFMxWkKHHnPMwgc+VXzToQbxTx85/Li5l8ONM6XZDezPC/NnieP0/ow8/Bc + 2Z5VLxlnZ3fxHLrwVNILz1M+X1d9/i4EjrznGQSOvDkvnBcHGoD4fKkdP661qQFQTK5uAFAEFsNcnFjg + yHueQeDID5p3sjj7xPCd6zePZ8VbhfMlyc1zz/PS7HnyOK0PKy80ym/ZzstvOlXO//Wqz7fgQZ+/zPG8 + RIEjv1JeOD/2G4D6fIkdn08pTm4AlJOrGgAUgcVYqTi1wJH3PIPAkT+0vPl89rBxXt4xyqpfE86bXivP + P7U9Tx6ntefJ47QGvz0rf2Mn33taVRUP5/PFry8KgSN/5PPCebJoAOLzrnbznEpxUgOQMHlvA4AisBgr + FwcCR97zDAJH/qLl7ZyZ/+tJVn7jZPFxvuJ5dMAJ55/KnieP09rz5HEaj6bVX+MnYqd2q52250eKwJFv + fb6lCBx5zzMIHPlB8sK5dkvz3IOlcyvF6gYgcfLOBgBFYDEGKQ448p5nEDjylyQPH1SyNS1vGmXVj+ON + TYTzKfX867XnyeO09jx5XJcvvFtf8ZJxvnfT3l7xYO3zo0/gyHueQeCCwSOn9lrlnZxVt696/klWNQDN + iRWTtzYA2AyLMVhxyHueQeDIr0Ue3lNgPCu/eJKVv1+fT4bzr9OeJ4/T2vPkcW0e59XvTrLqi/C3+3ge + 8Plgen40BY685xkEjvxa54UG4A7r+dfl3gYgnjRhcrEBqDcTPGhxmON5iQJHfi3zRln5hO1Z9XWTvHxd + 4vnX6jjH89LtefI4wa/GJw5Ods8+lqezXw88L0ngyD8wbgCEc83szgYgPukTJ19qAOLNRF7LYkf2PKXA + kR88ryjyB+0U1RSvkA7fTf25cL6pvML5LNrz5HFaH7W8UV79Wfjvs0Zn5lfzNN5XfD5HXsvnW2TPUwoc + +UPJqxuA5jmXYolvbQDik762NK7FBxqA5mbotS027XlKgSN/MfJObE3nJ0Mj8PXhPHtN47xr9Yrn85I9 + Tx6n9ZHJy8pX4a15Q3O6g3NzcQI3hPOW5690PicLHHnPMwgc+Y3Jw2sAxPNP6bZzWGwA4pO+DezxfgMg + bYZf+8mgEDjynicIn/c+yarPD/6FCy+yWj4fBzifD9jz5HFab3IezrHRtPy5Cd4tcXbu0TwNW4Xzluev + 6nzuEzjynmcQOPIblRfOwVviczTF0nlcW9UASGN6vGgAwsL94HmeWuDIm/LwWQThfH3K4u1qp9XbcS42 + z2W4ca4m2fPkcVpvZN60etsor35wNN37ZH8v/naBI+95BoEjv5QXzkPxswD6vHQuN9zbAEiPK3wzFs3F + L22G+00SOPKeZxA48sciryzn993ZrcrtWfXM7VnxK1t5cdcK5/PC8fOitjROa8+Tx2l9aHlZ8Z7tvPrl + 7bz8mq0ze9fho4l5WqmF85bn7yDnMzjynmcQOPIbmRfOy+QGYP98jtwc09kASI9pHNjzXLy4mVSBI+95 + BoEjf2zzZrNzD59MyxsXbzw0LX4vnKd3N8/bLtfPidjSOK09Tx6n9cB5d09m1Su3Z+W3ntytPq4oZh/C + 88efbwqBI+95BoEj35oXzu+kBqD53IClca0NgPTvWu/Mqlu7NpMicOQ9zyBw5D0v0qlTew8dZ9UnjPPq + my68LXFxl3Quw80n0qrPD8+Tx2m9ct60eM9kWv3qJKueE77+hGtne4/qO1+0Akfe8wwCR97zIoVzXN0A + NJ8bsDQOFhuAVYzJQgNwW9dmtAJHvrM4WoEj73kGgSN/5PIec+ON95vMyukkK5+Od2sL/tv6fG66ec6n + 2PPkcVrb8hZvNf1ivBnP1nTvDI41jjnOC54fyeeLJHDkPc8gcOQ9r6FwnqsagOZzA5bG1R60AagnjBqA + jSy2RuDIe55B4MivZd54fPW9r5uVY/z97XZePm8yK35xnFV/J533WsdPytrSOK09b3nMaFq9Ofz35ZO8 + /Aa8aA9/JRIO59Kf5+G84PkxyPkCjrznGQSOvOcJCud6bwPQfG7A0rjYgzUA8aRsADa22H0CR97zDAJH + fqPy0BRcM58/cpRVHxvO+a+eTMsfG+XV/2s+FyTHz4/a0jitPW/xxjuh9sVLJln5VaN870nj09UjwuHr + /fz8cCz9fPY8tcCRv2R54XzvbACazw1YGtf0IA1Ac2K+BsAPnkLgyHueQeDIX7K8x0+nH8A3J/rUcDN6 + 9jirfjQ8L15Tv66g+fyA4+dPqo9XXnHX1qz6o628/PHtWfWc7XzvM6/dLXefmGXqP8eLhePI46k+vl0C + R97zDAJH3vM6FJ5DrQ1A87kGS+Mkr9wASJMHn+e6k4QisBhJxWkTOPKeZxA48p5nEP4U8dpsPgk3rk/e + npVfvjUrv2s7K18WmoTfDze2t0rPpz4LzzVxnNbrkRdqgZpMyx8b5+Xzgr8A39HvZOVjb7jhrH9qnuep + BI78kcsLzyOxAWg+12BpXJtXagA6Jhc/DKhLKAKLkVwcSeDIe55B4Mh7nkHgyLfm4ScH46x8YrjxffQk + L582zqv/GJ47Lwxfv2yUF7+NH3GPp9W7Fc83kw87L+znXZOs+r+TrPgt7CmMeeGFPZZPw56x96vm8/dn + OQ4IdWK9WuuXInDkPc8gcOQ9zyBw5E154fm01AA0n29wc0yfzQ1Az+RJDQCKwGKYitMUOPKeZxA48p5n + EDjyQ+SdGBXzDzy5W42unc3P7uwWn7KT7z0tPN+eHp5nX8Eb6reHRuG/Lb6DnlY/jxvuaFr80Wha/mn4 + t78IN+G/Cv/+ptBU/N0oK94R/vtPfGOkuy+4uGucF+/iY3+HsWDAIgNZyFxkL75Lr75/MSfmzsovG2fV + vwtr+mysDWs8Oa/Gp6viQ/GaCe4hSagT6zVE/TzvgvG15ykELnit6heepwcaANxvm44f19rUACgmVzcA + KAKLYS5OLHDkPc8gcOQ9zyBw5D3PIHDkPc8gcOQ9zyBw5NcqL9xj9xuA5r0Xju69SU5uAJSTqxoAFIHF + WKk4tcCR9zyDwJH3PIPAkfc8g8CR9zyDwJH3PIPAkV+7vHCfXTQAzXsv3Lj3JjmpAUiYvLcBQBFYjJWL + A4Ej73kGgSPveQaBI+95BoEj73kGgSPveQaBI7+WeeFee0vz3gsL994kqxuAxMk7GwAUgcUYpDjgyHue + QeDIe55B4Mh7nkHgyHueQeDIe55B4Mivbd7JWXV7wv1XbVUD0JxYMXlrA4DNsBiDFYe85xkEjrznGQSO + vOcZBI685xkEjrznGQSO/Frn4R1JE+6/avc2APGkCZOLDUC9meBBi8Mcz0sUOPKeZxA48p5nEDjynmcQ + OPKeZxA48mufFzcAwv3W7M4GIL7pJ06+1ADEm4m8lsWO7HlKgSPveQaBI+95BoEj73kGgSPveQaBI38o + eXUDINxr1Zb41gYgvunXlsa1+EAD0NwMvbbFpj1PKXDkPc8gcOQ9zyBw5D3PIHDkPc8gcOQPLQ+vARDu + s2q33cPFBiC+6beBPd5vAKTN8Gs/GRQCR97zDAJH3vMMAkfe8wwCR97zDAJH/ljnhXvwLcJ9VuWu+7iq + AZDG9HjRAISF+8HzPLXAkfc8g8CR9zyDwJH3PIPAkfc8g8CRX8oL92HxswD63Hcv720ApMcVvhmL5uKX + NsP9Jgkcec8zCBx5zzMIHHnPMwgcec8zCBx5zzMIHPmNzAv34uQGIL6P126O6WwApMc0Dux5Ll7cTKrA + kfc8g8CR9zyDwJH3PIPAkfc8g8CR9zyDwJHf2LxwT01qAOp7eGxpXGsDIP271juz6tauzaQIHHnPMwgc + ec8zCBx5zzMIHHnPMwgcec8zCBz5jc4L92R1AxDf9GtL42CxAVjFmCw0ALd1bUYrcOQ7i6MVOPKeZxA4 + 8p5nEDjynmcQOPKeZxA48p5nEDjyFz0v3FdVDUB8068tjas9aANQTxg1ABtZbI3Akfc8g8CR9zyDwJH3 + PIPAkfc8g8CR9zyDwJFX5YX7am8DUN9/Y0vjYg/WAMSTsgHY2GL3CRx5zzMIHHnPMwgcec8zCBx5zzMI + XDB45NT2PKXABSfVL9xXOxuA+P5bWxrX9CANQHNivgbAD55C4Mh7nkHgyHueQeDIe55B4Mh7nkHgyHte + h8J9tbUBaN5/YWmc5JUbAGny4PNcd5JQBBYjqThtAkfe8wwCR97zDAJH3vMMAkfe8wwCR97zDAJH/pLn + hXuq2AA07rsLS+PavFID0DG5+GFAXUIRWIzk4kgCR97zDAJH3vMMAkfe8wwCR97zDAJH3vMMAkd+LfLC + vXWpAWjee+HmmD6bG4CeyZMaABSBxTAVpylw5D3PIHDkPc8gcOQ9zyBw5D3PIHDkPc8gcOTXJi/cXw80 + AM17Lxw/rrWpAVBMrm4AUAQWw1ycWODIe55B4Mh7nkHgyHueQeDIe55B4Mh7nkHgyK9VXrjH7jcAzXsv + HN17k5zcACgnV70GAEVgMVYqTi1w5D3PIHDkPc8gcOQ9zyBw5D3PIHDkPc8gcOTXLm+SlZ+Ce6vy/qv1 + 3ZdNpsV7hAdEqycPi+W6W4UisBgrFwcCR97zDAJH3vMMAkfe8wwCR97zDAJH3vMMAkd+LfPGs+p29f1X + 6fG0endoAKq3SQ82nTL51rT6bK5bFIrAYgxSHHDkPc8gcOQ9zyBw5D3PIHDkPc8gcOQ9zyBw5Nc2b3tW + PEN7/9W7eCt+AvAn8oP3uDmxYvI7ufYlYTMsxmDFIe95BoEj73kGgSPveQaBI+95BoEj73kGgSO/1nlb + efnchPuvyuO8eu1l46z6ZenB2vGk6smz8r9w/QdUbyZ40OIwx/MSBY685xkEjrznGQSOvOcZBI685xkE + jvza521l1Y+o779ql6+4bJJV3yc/uHzjV0+eFb/FPewr3kzktSx2ZM9TChx5zzMIHHnPMwgcec8zCBx5 + zzMIHPlDyZvMqler778tbvLjrPzPeHXhl8b/WDu+6deWxknGiwsec+ON9+Ne/GTwvCSBI+95BoEj73kG + gSPveQaBI+95BoEjv8jKzlYfNs6q90r3Wq3Fe3hWPv2y0ay44cA/Bsc3fRFUeGtW7kqbode22LTnKQWO + vOcZBI685xkEjrznGQSOvOcZBI78oeXt5OXHS/dYrdvu41t5sXfZqVN7D43/8cID7ZDaWfUcaTP82k8G + hcCR9zyDwJH3PIPAkfc8g8CR9zyDwJE/1nnhu/9vE++xCnfcy+++Js8fvJg4fPHq6IE2IM1Z9Vc33HD2 + wc3NBPvJoBA48p5nEDjynmcQOPKeZxA48p5nEDjyxzrv9Onr7jfJi78R77E9ju/jwv38lZz6ssvGefm8 + 6AFpcLLB7+wWnxJvJthPBoXAkfc8g8CR9zyDwJH3PIPAkfc8g8AFg0dO7WOZF+6jrR8D3OX6Hh47fjzc + 85+LWi+0lRdn4webg1N9z6TF7xZF/qCwkWN58DgkSeDIe55B4Mh7nkHgyHueQeDIe55B4Mh73mV33muS + la+S7rFdvuf+e4+XxvA1egtdd92198W7AjUHWdyc+OSsuv3CZtIFjsUQipMucOQ9zyBw5D3PIHDkPc8g + cOQ9zyBw5D3PIHDkL0pe+C79duke2+Xm/RdujhlNqzfP5/PLF4uAMGH4x+9sDky1PHnxtzvz+QdxKrWw + JhZDLE6qwJH3PIPAkfc8g8CR9zyDwJH3PIPAkfc8g8CRvyh5p+bzD0n9ply+/y4bv/JfLKIWJt3O5tdK + g7Xumnw8LX/6/Pnz9+Z0vcJ6WAyxOKkCR97zDAJH3vMMAkfe8wwCR97zDAJH3vMMAkf+ouTt7OzcJ9z8 + fzG+v/a56/7b9Hg6nywWUitMfAL/xTv4SUCfNZOP8+K7whSLebqEIrAYYnFSBY685xkEjrznGQSOvOcZ + BI685xkEjrznGQSO/MXKOxHuly9s3j+7rLn/1h7lxa9znmXhY3wlqMspk0/y8gUHfvfQEIrAYrQVJ0ng + yHueQeDIe55B4Mh7nkHgyHueQeDIe55B4MhflLwL3/kf3s0fHk33PnmxGEm4OU+mxf+RQMmpk9MvH505 + 9zBOuS8UgcUQi5MqcOQ9zyBw5D3PIHDkPc8gcOQ9zyBw5D3PIHDkL0oef+d/aD/2X3ha/Envr+In2d6n + iXDDyZNHxqsQx3n1qfgzB8yJIrAYYnFSBY685xkEjrznGQSOvOcZBI685xkEjrznGQSO/EXIu/NeF17t + fzgv+Is9nu49lUtqFzqEvr89tEwuOit/P7Dn9/YKf8dAz1MJHHnPMwgcec8zCBx5zzMIHPljnYd3+Av3 + vqcc1t/5C35l/Q13r/AhAULAwsbJWw1+nFVv2pqV33Vqt7hpPp89LBTITy6FwJH3PIPAkfc8g8CR9zyD + wJH3PIPAkd+IPHyqHz7Y58J7+x/K2/t2uJhzWTpN8vKHmyH2yWVLeaO8+ufw2CvDf38wdEfPDgv/9+NZ + 9el4gWJ4/CkdvgVvOhR8R+Tb8e+NcVp7nuel2PM8L8Wed0TzcK8K96zbt2fFM7by8rlbWfUj+Dz/oT7S + N7Y0btnlD/C2fkChKWn/q7yrr6seHv9ewj65bM+Tx2ntefI4rT1PHqe158njtPY8eZzWniePaxqvt5vk + +Qfztr4QbvzB9w7u/skG/mQAIdbJ2+x58jitPU8ep7XnyeO09jx5nNaeJ4/T2vPkcS2+mbfzhXjzv1zV + AGDAVl7+9xUmX3Izy/PS7HnyOK09Tx6ntefJ47T2PHmc1p4njxOdVd/DW/lCvPnfh+5uADj4AddVxYds + zao/Sp5ccLwJz0u358njtPY8eZzWnieP09rz5HFae548rsWv3Nl50gN4O6/v5/cLvm9w3QDIrwHAA8H3 + D36/4Pe/blaOt7Lq7cIkaq+4mSV7njxOa8+Tx2ntefI4rT1PHqe1591TC4vrjNjSOK3XKW+UF383ns8/ + grfzxU/yeT+H9xsAPnxQ4YG6U7gieNEAwNuzspjkxV3ShH1eZTOSPU8ep7XnyeO09jx5nNaeJ4/T2vPk + cVof6bxp8Z5xXmS8ndc3/wcE435eNwDy2/GHB+rfEWBg3QDAi98V8EWBdy9N2uGVNiPY8+RxWnuePE5r + z5PHae158jitPU8ep/XRzivetzUrPmlxMw/CfTu6h9cNAO7vrT/6x6sD0SHUDQA6hwMvFBhl5R3y5Mte + bTPL9jx5nNaeJ4/T2vPkcVp7njxOa8+Tx2l95POyvU/jbbq++S9+eh9cNwD4yX7rzR8vCkB3UDcAsPgq + QTYBnT8JWHkzDXuePE5rz5PHae158jitPU8ep7XnyeO0Ptp5xfuEmz/egRCuGwDczztf9Bc3AO2dAnXh + 1wHyawJW28yyPU8ep7XnyeO09jx5nNaeJ4/T2vPkcVof6bxp8R7hx/712w/XDQB+kt9+Pw8PAqobgPbf + ETQUGoD5ZFq9LV7QSpsR7HnyOK09Tx6ntefJ47T2PHmc1p4nj9P6KOctXu2//IK//c8e4P/vv4avVRgQ + jAYArwFQ3fxrbU/LK8NiXo0FrbIZyZ4nj9Pa8+RxWnuePE5rz5PHae158jitj3jeK4U/9Ytv/jC+++++ + +UMYFNz+xgA92j539gO288rfMXAFe548TmvPk8dp7XnyOK09Tx6ntefJ40RPq+9uvMmPdPPH1/03fygM + NN34IUzCyR6IT1DamhVvS9qM4GZhPC/NnieP09rz5HFae548TmvPk8dpfVTzRtPqLeG/zff2X+3mv4ow + CSfbn/xUjl8JlC9qLl5ra3Ha7HnyOK09Tx6ntefJ47T2PHmc1p4nj9N6ffLKHxA+1W+9bv78ejH5Vl7s + TbLyVfJmZNuLI9vz5HFae548TmvPk8dp7XnyOK09Tx6n9ZrkvRIvtl/cdCPhPsv7rXj/PVRhEk7WOfn5 + 8+fvHZqA20Z59WfCxg7YWJxWe548TmvPk8dp7XnyOK09Tx6ntefJ47S+5HnT4k/G072nXnbZnUs3dNxn + eb/tvP8eijAJJ1NPPp/PL5/k5S3jvPoNabPJxemx58njtPY8eZzWnieP09rz5HFae548TutLmTfKi1/H + e+zgm2fePg8I91neb9X338GESTiZefLtvNwZZ9Xz+YKGpOJo7HnyOK09Tx6ntefJ47T2PHmc1p4nj9P6 + UuSFe+Gbx3n5vNHu3hZvk6Jwn+X91nz/NQuTcLJBJi/L+X13ZtVHb+fVd2xlxWvaipPiuMiel27Pk8dp + 7XnyOK09Tx6ntefJ47S+iHl4G/1Xhpv+c7dm5S5+Qs7bYqtwn+X9dpD7LxRY3V//YRJONsjk4Mjv5107 + 23vUVlbdMM6rZ4TC/OfQFf1S+P/XTvLireNp9e66qG3uKLbJnieP09rz5HFae548TmvPu6cWFtcZsaVx + Wh+zvLsnWfVu/En8ZFb9yfas/N9beflfJ1n5xXhx/DV5/mDeClWS7pf82nr/rd/6v5/HoGC8o9BQkx96 + M8GvPU8hcOQ9zyBw5D3PIHDkPc8gcOQ9zyBw5I9LHm7+eMff/gYAA4LxXsLxAtZpM57neWqBI+95BoEj + 73kGgSPveQaBI+95BgUON//68366GwAOxqcI4bv/ehHrtBnP8zy1wJH3PIPAkfc8g8CR9zyDwJH3PIMC + h/s5PuUXn/ZbNwDyawDwQDA+Pxjf/dcNwDptxvM8Ty1w5D3PIHDkPc8gcOQ9zyBw5D3PIHDBuJ/D+w0A + Hz6o8EDdKVwRXDcAuk8VEgQueN2L43mepxI48p5nEDjynmcQOPKeZxA48scpDz/Jx/28bgDkvzoID9S/ + I8DAugHo/zzhFoELXvfieJ7nqQSOvOcZBI685xkEjrznGQSO/HHKq+/hdQOA+3vrj/7x6kB0CHUDgM7B + i60QOPKeZxA48p5nEDjynmcQOPKeZxA48p5nEDjyQ+bVP72vGwD8ZL/15o8XBaA7qBsA2IutEDjynmcQ + OPKeZxA48p5nEDjynmcQOPKeZxA48kPnwXUDgPt554v+4gagvVPoUeD84HmeWuDIe55B4Mh7nkHgyHue + QeDIe55B4MgfRh7+iwYAP8lvv5+HBwHVDUD77wh6xJzD2oznJQocec8zCBx5zzMIHHnPMwgcec8zCBz5 + 45qH/+9/DR8GBKMBwGsA/OavEDjynmcQOPKeZxA48p5nEDjynmcQOPKeZxA48oeZp/vrPQwKbn9jgB6R + 37TieJ5S4Mh7nkHgyHueQeDIe55B4Mh7nkHgyB/NvDDQdOOHMAkns03eEDjynmcQOPKeZxA48p5nEDjy + nmcQOPKeZxA48p532MIknGyQycGR9zyDwJH3PIPAkfc8g8CR9zyDwJH3PIPAkfe8wxYm4WSDTA6OvOcZ + BI685xkEjrznGQSOvOcZBI685xkEjrznHbYwCScbZHJw5D3PIHDkPc8gcOQ9zyBw5D3PIHDkPc8gcMHg + kVPb8w5DmISTDTI5OPKeZxA48p5nEDjynmcQOPKeZxA48p5nEDjynnfYwiScbJDJwZH3PIPAkfc8g8CR + 9zyDwJH3PIPAkfc8g8CR97zDFibhZINMDo685xkEjrznGQSOvOcZBI685xkEjrznGQSOvOcZFVjdX/9h + Ek42yOTgyHueQeDIe55B4Mh7nkHgyHueQeDIe55B4Mh7nkGBq9/6v5/HoGC8o9BQk/vB8zy1wJH3PIPA + kfc8g8CR9zyDwJH3PIPAkR8qDzd/vONvfwOAAcF4L+F4Aeu0Gc/zPLXAkfc8g8CR9zyDwJH3PIPAkfc8 + gwKHm3/9eT/dDQAH41OE8N1/vYh12ozneZ5a4Mh7nkHgyHueQeDIe55B4Mh7nkGBw/0cn/KLT/utGwD5 + NQB4IBifH4zv/usGYJ0243mepxY48p5nEDjynmcQOPKeZxA48p5nELhg3M/h/QaADx9UeKDuFK4IrhsA + 3acKCQIXvO7F8TzPUwkcec8zCBx5zzMIHHnPMwgc+eOUh5/k435eNwCX8+GDCg/UvyPAwLoB6P884RaB + C1734nie56kEjrznGQSOvOcZBI685xkEjvxxyqvv4XUDgPt764/+8epAdAh1A4DOwYutEDjynmcQOPKe + ZxA48p5nEDjynmcQOPKeZxA48kPm1T+9rxsA/GS/9eaPFwWgO6gbANiLrRA48p5nEDjynmcQOPKeZxA4 + 8p5nEDjynmcQOPJD58F1A4D7eeeL/uIGoL1T6FHg/OB5nlrgyHueQeDIe55B4Mh7nkHgyHueQeDIH0Ye + /osGAD/Jb7+fhwcB1Q1A++8IesScw9qM5yUKHHnPMwgcec8zCBx5zzMIHHnPMwgc+eOah//vfw0fBgSj + AcBrAPzmrxA48p5nEDjynmcQOPKeZxA48p5nEDjynmcQOPKHmaf76z0MCm5/Y4Aekd+04nieUuDIe55B + 4Mh7nkHgyHueQeCCwSOntucpBS746NYvDDTd+CFMwslskzcEjrznGQSOvOcZBI685xkEjrznGQSOvOcZ + BI685x22MAknG2RycOQ9zyBw5D3PIHDkPc8gcOQ9zyBw5D3PIHDkPe+whUk42SCTgyPveQaBI+95BoEj + 73kGgSPveQaBI+95BoEj73mHLUzCyQaZHBx5zzMIHHnPMwgcec8zCBx5zzMIHHnPMwgcec87bGESTjbI + 5ODIe55B4Mh7nkHgyHueQeDIe55B4Mh7nkHgyHveYQuTcLJBJgdH3vMMAkfe8wwCR97zDAJH3vMMAkfe + 8wwCR97zDluYhJMNMjk48p5nEDjynmcQOPKeZxA48p5nEDjynmcQOPKeZ1RgdX/9h0k42SCTgyPveQaB + I+95BoEj73kGgSPveQaBI+95BoEj73kGBa5+6/9+HoOC8Y5CQ03uB8/z1AJH3vMMAkfe8wwCR97zDAJH + 3vMMAkd+qDzc/PGOv/0NAAYE472E4wWs02Y8z/PUAkfe8wwCR97zDAJH3vMMAkfe8wwKHG7+9ef9dDcA + HIxPEcJ3//Ui1mkznud5aoEj73kGgSPveQaBI+95BoEj73kGBQ73c3zKLz7tt24A5NcA4IFgfH4wvvuv + G4B12ozneZ5a4Mh7nkHgyHueQeDIe55B4Mh7nkHggnE/h/cbAD58UOGBulO4IrhuAHSfKiQIXPC6F8fz + PE8lcOQ9zyBw5D3PIHDkPc8gcOSPUx5+ko/7ed0AXM6HDyo8UP+OAAPrBqD/84RbBC543YvjeZ6nEjjy + nmcQOPKeZxA48p5nEDjyxymvvofXDQDu760/+serA9Eh1A0AOgcvtkLgyHueQeDIe55B4Mh7nkHgyHue + QeDIe55B4MgPmVf/9L5uAPCT/dabP14UgO6gbgBgL7ZC4Mh7nkHgyHueQeDIe55B4Mh7nkHggsEjp7bn + KQUu+DDqB9cNAO7nnS/6ixuA9k6hR4Hzg+d5aoEj73kGgSPveQaBI+95BoEj73kGgSN/GHn4LxoA/CS/ + /X4eHgRUNwDtvyPoEXMOazOelyhw5D3PIHDkPc8gcOQ9zyBw5D3PIHDkj2se/r//NXwYEIwGAK8B8Ju/ + QuDIe55B4Mh7nkHgyHueQeDIe55B4Mh7nkHgyB9mnu6v9zAouP2NAXpEftOK43lKgSPveQaBI+95BoEj + 73kGgSPveQaBI38088JA040fwiSczDZ5Q+DIe55B4Mh7nkHgyHueQeDIe55B4Mh7nkHgyHveYQuTcLJB + JgdH3vMMAkfe8wwCR97zDAJH3vMMAkfe8wwCR97zDluYhJMNMjk48p5nEDjynmcQOPKeZxA48p5nEDjy + nmcQOPKed9jCJMF4gQEmrK17wYEgcOQ9zyBw5D3PIHDkPc8gcOQ9zyBw5D3PIHDkPe+whUmC8acFmLB2 + /58atAgcec8zCBx5zzMIHHnPMwgcec8zCBx5zzMIHHnPO2xhkmC8qQAmrL3q2wV7nuepBI685xkEjrzn + GQSOvOcZBI685xkEjvwgeUkKk9QfEYz3FK7d/vaCPQJH3vMMAkfe8wwCR97zDAJH3vMMAkfe8wwCR97z + jFKzGBiMtwfGhLVXebtgz/M8tcCR9zyDwJH3PIPAkfc8g8CR9zyDwJEfMg/v+9P/kwMOrj8joPYqbxfs + eZ6nFjjynmcQOPKeZxA48p5nEDjynmcQOPJD5uEdf/sbgGgwJqy9ytsFe57nqQWOvOcZBI685xkEjrzn + GQSOvOcZBI78YeSpGgAMOmA+ZJLneV6KPM/zUuR5npciz+toJPBgMF51WNvUddTyPM9Lked5Xoo8z/NS + BD4YObWPYd5ll/3/150HTtldCaoAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAAOEAAADhCAMAAAAJbSJIAAAABGdBTUEAALGPC/xhBQAAAGBQTFRF//// + QsD7Ob77k9n8T8T79/3/Wcf7Y8r8+/7/bc781vD+dtD8rN/9Nr37itb8u+f9x+v+s+T9gNP8nt39yu3+ + 5fb+ueb97/r/s+L93fP+wer90/D+qOH97Pj/4/b+mNv8+AVANAAABilJREFUeF7t3etiojAQhmGgCKhF + Ra2HVuv93+UGOx6qgUwglfmyeX/tWuryLAFFECJ228livqmq3XvdTv1hM19MtvRDD1pkJZWco7+U2coP + ZLEs44bKdE8TIVdMG4FxnMQeEFctQEXMRjQdbEeiNFUeaELYDq2LUC3EnCYU0XqWZ9MF/YXZW0KUxgRt + T2elmtvEcvs3MwlLMdua2zYxmdBDnMzCT5py6Lbj66wmGT3GaWkUbmjKgdvmd3NazulRRmZhRVMO20d6 + P6PJlB5mNDUKRbxcfP8CxrHFFt4oTFY05ZDtH4DJmH7AyCw80ZQD9giMkzf6CSOz0OLJ/qi9en/8u9Li + 5QJAOElpVq7ZbGii24tMQ4MLv2hGbiWpxfusQrxQB/ygn3ESL3wGxnb7rNKFGqDVm1LxwjXNxF3Jmn7G + TLZQA4wt9w5lC3VL0HpPp8jpVxsbTqgDWuxTUIKFOmCH/Ry5QkdAuUJXQLFCDbDjrrhQ4YL+8bu6LUGp + QmdDVCVS6G6IqiQKHQ5RlUBhN2BRjH5Hj/OE9DsvqegA/NjNpnmeZVl6K77sgZiFcUy/86LoH73LACxO + cZk8vbu+fpLDEQ6cAbgda4+eXfci5QtNQ7ThEDaO0AScNxz/hBGagFFGEz6GIjQCj02HsK/CUdP/gYiM + wOgLW2gGRgtoIQPYuKHBEDKA0QZZmBY0j23toIWcs7GqIIQXvjd9oB2EEgrCc0GIL9x5Lwyvhx6MUu+F + 2O+8OULovSeWEHoPmCWceC/cei+MNEcBzvkjfGtYiP4It4+nD1P+CDUnEJ/zSBjtM91A9UkYjQ55XF6+ + /3rpevyQI6TfcRE9Iyu2ULWdfFar1dtds8t5xAxhfqJfsmn22PJc07Zdl42wJbPQ5fct5vScrF4ndHcu + hhUQUWgHBBTOrbYzgEJbIJzQcoiqwIQb2yWIJrQeoioo4Sc9l1VIQg0wMb+7cSQ0n0/TX/ipGaKV8Vvy + QEINMKnM1wHAEeqGaMW40gGMUL8EPRI2Ab0RNgxRlSfClnO2/RA2DlGVF8JFC5Bx5R/5Qs0QvfvmiwdC + w/cm8IVt62AdvLB1HaxDF7avg3XgQuMSRBcygNhCHfDpgmHIQg1Qc0U0YKHm/A/dlRBwhUwgrlA3RLXX + skAV6jYy+ot1gAq5Q1SFKeQvQVAhex2sQxRaDFEVoNAOCCi0GqIqOKEtEE5oOURVYEJ7IJjQeoiqoIQ2 + L/TXkIQdhqjqdcLeVxXsMkRVOMKOQByhboiyLt6IIuy2DtaBCHVDlHn5TQxh13WwDkLY6XXwEoKwFxBB + qDv4wgcCCHXHBy2A8oX9hqhKurDnEFUJF/YHChf2XQfrRAt7r4N1koWac9Vsh6hKsFB3Mp49ULDQxTpY + J1boCihW6GYdrBMqdLYEpQodAmUK3Q1RlUSh7mWi+50DBQpdDlGVPKFjoDyho3cyt6QJnQOlCTVDNO4H + FCZ0vwRlCU+6O4b0vsGsIGGs+5Zp3yUoS6ipP1C2sPc6WCdZ2H8drHuZ0Hyn1adcLEHJQidDVCVW6Aoo + V+gKKFboDChVaH2LzOZOZiFN2TcbYdblql/6TsZzseKYJr20qjscqs3n+tvins52y5CuuuYiesa2aMrf + lefSccUew5ZbGiklZc69szOoUBlTJhFWyL7DOq4wLulTQEPAQt6daKCF5ZEQrUELvwjRGrSQ9SYSWvj4 + BXFtyMJkR4jWoIXvhGgtCCUXhD8FoeSC8KcglFwQ/hSEkvsPhN6/8y79F/q/B7wmRGvQwsudVlpbAgt5 + nyZ+09SA8T6miaIKdSEmUxIYO2ASy5x/ELFiHRekJx40mpVzM5uD4Pvp2FxuLvuj6Onz/Dwj0+lyOVt9 + 07xzK5w0+qPo6X+iOQ6FQqFQyIc+JsbAX/pmD/cNfaqMHZ2bOFSvO/tyqIIwCOUXhEEovyDEF66CMAjF + Z/4cGl74fOXThzJw4cZ7oebqtQ/l4HvA3yZhMqYpUdsSpLFkRlPCZvoSeXKgCWGrDMO0nNCEsI3y1oUI + vxqq9mkLMUlZ51kIb582DtQysz0CKrPjW1p/5ZU+IKXOX4Jdgb/a3yqO63m1e79rt1lMjszX+ij6B2B1 + oKWK7CK1AAAAAElFTkSuQmCC + + + + + /9j/4AAQSkZJRgABAQEASABIAAD/2wBDAAUDBAQEAwUEBAQFBQUGBwwIBwcHBw8LCwkMEQ8SEhEPERET + FhwXExQaFRERGCEYGh0dHx8fExciJCIeJBweHx7/2wBDAQUFBQcGBw4ICA4eFBEUHh4eHh4eHh4eHh4e + Hh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh7/wAARCAC0ALQDASIAAhEBAxEB/8QA + HQAAAgIDAQEBAAAAAAAAAAAAAAgDBwQFBgIJAf/EAFQQAAAEAwIHBw4KCAUFAAAAAAABAgMEBQYREgcI + IVZhdLIVGDE1cXOzEyIjQVFVcnWSk5XR0tMUJCUmMjY3gaGxFidCQ1JklOIzNFNikURjosPh/8QAGgEA + AwEBAQEAAAAAAAAAAAAAAAQFBgMCAf/EADIRAAECAwQGCgMBAQAAAAAAAAABAgMEEQUSgaEVITEzUXET + FBYiMjRSU7HhI0FhwST/2gAMAwEAAhEDEQA/AF+wD4JX8KsVNmGJ41KjlyGlma4Y3eqXzUXaUVll38Ra + 29AmGfcL6NV7wGIDxrV/MQu06PycTSYpm8YkphFERRCyIieVk649Ick5NZlVRFpQnz8+kmjVVtan7vQJ + hn3C+jVe8BvQJhn3C+jVe8GHurMu+MX55XrBurMu+MX55XrD2hl9eRM7Qt9vP6MzegTDPuF9Gq94DegT + DPuF9Gq94MPdWZd8YvzyvWDdWZd8YvzyvWDQy+vIO0Lfbz+jM3oEwz7hfRqveA3oEwz7hfRqveDD3VmX + fGL88r1g3VmXfGL88r1g0MvryDtC328/ozN6BMM+4X0ar3gN6BMM+4X0ar3gw91Zl3xi/PK9YN1Zl3xi + /PK9YNDL68g7Qt9vP6MzegTDPuF9Gq94DegTDPuF9Gq94MPdWZd8YvzyvWDdWZd8YvzyvWDQy+vIO0Lf + bz+jM3oEwz7hfRqveA3oEwz7hfRqveDD3VmXfGL88r1g3VmXfGL88r1g0MvryDtC328/ozN6BMM+4X0a + r3gN6BMM+4X0ar3gw91Zl3xi/PK9YN1Zl3xi/PK9YNDL68g7Qt9vP6MzegTDPuF9Gq94DegTDPuF9Gq9 + 4MPdWZd8YvzyvWDdWZd8YvzyvWDQy+vIO0Lfbz+jM3oEwz7hfRqveA3oEwz7hfRqveDD3VmXfGL88r1g + 3VmXfGL88r1g0MvryDtC328/ozN6BMM+4X0ar3giisUaPYhXXzrmGUTaDXZucrLYVv8AqCDdWZd8Yvzy + vWLhwExURE0nUSoh9140nYRrWarOxn3RwmbNWBDV96uA1J2ukzFSGjKV/ohAAAEwsjRYgPGtX8xC7To1 + 87UW7MdrDm0Y2GIDxrV/MQu06NVO1fLMdrDm0YtWP4n4Get9KtZj/hDeIF4hDeBeF0zV0mvEC8QhvAvA + C6TXiBeIQ3gXgBdJrxAvEIbwLwAuk14gXiEN4F4AXSa8QLxCG8C8ALpNeIF4hDeBeAF0mvEC8QhvAvAC + 6TXiBeIQ3gXgBdJrxC6cX07aRqPl/wDWoUheF24vJ20jUnhF0aghafl1w+SpY6f9bcfgREAADLmyGixA + eNav5iF2nRpZ4r5ajtZc2jG6xAeNav5iF2nRz88V8tx2X/qXNoxZsfa/Ag24lWsx/wAIbwLwhvaQXtIu + mdunSQFH1XHwbUZBU/MYiHdTebcbYUaVF3SMTfoJWmbE1/plBqsDmXBdTuooHWiHEtV7Xq26mo0MOxYb + 2I5XLrQRidyCeSRDS5vKouBS6Zk2b7RpJRlw2W8o1d4OrhLpWGrGkouUPElLxlfhnT/dul9E+TtHoMJZ + M4SJlswiICNaUzEw7im3UKLKlRHYYfkpxJhq11KhNn5BZVyU1op5vAvCG9pBe0h0Quk14x0TVEVi60h1 + qmpmtC0kpKih1WGR8BjmEq64svbD409xBLtVa2CCE9NulkbRK1KNnyDZpXI5aUE3/QStM2Jr/TKGlmsB + HyqNVBTKEehIlBEamnUGlREZWlkMPiFJxmFWYWY0v5djYIcpOfdMRLipTUdp6zGS0O+1a6yurwLwhvaQ + XtIqEi6TXgXhDe0gvaQBdJrwLwhvaQXtIAuk14Xhi7HbSFS+EXRqFE3tIvPFxO2j6l8IujUELS8uuHyU + rJSk03H4EWAAAzBrhosQHjWr+Yhdp0c1PVfLkfrLm0Y6XEB41q/mIXadHKT5Xy5H5S/zLm0Ys2PtfgRL + aSqMx/wgvAvCG9pIF7SQuEC6O/gZy4LKc1FA64chgXy4Kqb1FA68Y+NvHc1NrA3TeSAFrxu6EdaU1X0o + QoiK61MkI4O4h38kn92kMoMWbS+DmssiZbHsIfhYltTTraiyKSZWGCDFWE9HIfI8FIzFap8/oaIS+ylx + Pb4S7hiS8MzCHS0Zg+ruMp6LNSoYzvwryv3jSvoq5e0ekhrb2khq4MRIjEchkI0BYT1apOlXXFyh96d+ + r8u1VrYIIElXXFlLhD+059XpbqjWwQl2xsZiVrFSivwM8JXjYuuIw0TBKVqIvg0PkI/+2QdQJLjbHZhq + mGqw/RkJ8jvMClPpWFiV5JXXFRKiUtSiu9sxtrw0MkV8ZV4I3F7SQ0cDwGYjt75NeBeEN7SQL2kh2ON0 + mvAvCG9pIF7SQAuk14Xvi2nbR9TeEXRqFBXtJC+sWk7aOqfwi6NQQtLy64fJQstKTLcfgRsAADMmqGix + AeNav5iF2nRx8/V8uzDWXNox2GIDxrV/MQu06OJqBXy9MNac2jFiyNr8CNa6VRmJBeBeEF4F4WyJdHpw + K5cFFNaggdgONwJfZNTWoIHZDIRt47mpr4O7byQACo8IWET9C8N8glkweuSaby4mnzUfWsudVWSHPxsP + QegW2RkZEZHaR8Bjy5itRFX9ntr0cqpwKpxl8HpVrRC42AZvTmVJU9DXS651Flq29NtlpaS0hOpdEm40 + ba8jiMiiPhH0bCZ40dAqoytU1HLGLsnm61LNKC61l7hWjQR/SL7+4KVnTNx1xSbaMrfbfTaV0lXXFyj6 + BU59XpbqjWwQ+ezTiV3VJO0jsMh9Cab+rst1RrYId7X2MxOFkJRX4GwCR43B2YbJhqsP0ZB3AkGN0dmG + 2Y6rD9GQQkt5gPzu7xK1kqvjKvBG3vDRydXxhXgjuZDQ1YT6XJmMnp6OjYRajSl5pu1JmR2GQ0EJyNZV + VoZ6LDVz6IlTRXgXh1TuDHCC02pxykpolCCNSjNrgIhq6OpOoqujjg6fljsYtP8AiKIyShsv9yjMiIdO + lZRVvJRDn0L6olFqam8C8LSfxfsIrcObqIeWvKIrepoiyvHoykRfiK7qWnp5Tcb8CnsriYB/tJdTYStJ + HwGXIY8sjw4i0a5FPT5eJDSrmqhg3hfmLKdtG1P4ZdGoL5eDA4sB20ZVHhl0agtaXl1w+RmzUpMJj8CQ + AAAZo0w0WIDxrV/MQu06ODqFXy/Mdad2zHeYgPGtX8xC7Tor6oVfL8x1p3bMWLI2uwJVqJVG4mNeBeEN + 4F4WyPdHywIZcElM6ggdmOLwHfZFTHi9A7QZCNvHc1NTB3beSCiY8p2V3IfFh9KoWpiq4RirCjikcyfv + TiUIS2o1H1zzHAheky4D+4+2Kpx5zsruQ+LD6VQqHBVVkdRlcQE+gDMzZUZPN22E62Zdcg+UvxsMUGwe + lgI1Noi6L0UZXfo+jY5zCRScBW1HR9OzAiJEQjsTlmVpwsqVlyH+FpDaU/NoGeyWEnEteJ6Ei2icaWXc + PtHpLgMZ4ma2r/UKOpyfw+cMfLo+nahjKemrRsxcG8ptST7pHwl3SPhLlH0Opr6uSzVGtghQWOJg7OOl + 7VfShgzi4IktTBKCyrZt61zlSeQ9B6BfdLnbTMrPuwbOwQemo/TQmYiUtA6KI42QR3G9Miw3THVYfoyD + xBGsb87MOEx1WG6Mh4kt5gdJzd4lYyhRfCFeCHfxVjtwOQB/zMR0hhG5Urs6vBDxYqR24GpfrMR0hh+e + 8snMRk0/6F5FoRrPwiDeh713qrakW9y0rBpqBpSV0bTUNJJW0RIaSRuumXXPL7a1H3T/AAG/FFYyOG2K + oKNZp2nGYd2buNE6+88V5MOk/old7ajynl4Cs4bRJho9/cb+yo9Ws77i9Qo+N3VLUwr5iQNvoNqUMESy + t/euESj/APG4NdSeNBWUBFIOoIWDnMMozvklsmHEl/tNJWf8kKXqicxNQVHMZ3GHa/HRC3125bLx22fd + wChKQHQYl5wjNRWxod1psSWRlaRkZaAwuK2dtF1T4ZdGoK/LjWcSRJUZEWUwzuKudtF1T4ZdGoOTz78s + q8hOTh3JhEEmAAAzxeGixAeNav5iF2nRW9RKL9IJjrTu2YsjEB41q/mIXadFZVGr5wzLW3dsxXsna7Am + 2ilUaY14gXiEN4F4WyVdH8wF/ZBS/i9sdqOJwE/Y9S3i9sdsMjG3juamkheBOQn+PWdleSDxWfSqC/S8 + /jafv/IX/j3HZXsg8Vn0qgvkAr40n7/yFiT8DSZMp3nDP4o2EMoKYroaaP2Q8Uo3JepR/Qd/ab5FcJaS + Puhph804OLfg4tmLhXVNPsOJcaWk7DSpJ2kZchkHzwJV0xX1DQ0zvJKYMETMe0X7LpFw8iiyl/8ABwtK + Wuu6Vuxdp2kY1U6Nf0dpFw7EXCuwsU0h5h5BocbWVqVJMrDIy7lgIRhqFhWoZhN1plCW0FbwJIrCISgE + ooAEXxwj/XjMdVhujIPQEUxxDsw5zHVYboyDclvMBaa8BVsrV2ZXgh5cU87cDEv1mI6QwissV2ZXgh6M + Us7cCsv1mI6QxQnfLJzE5RPzryLaHzxw/wAycmmGaqYhxZq6nMHIdGW2xLZ9TKzyR9Dh81cJrqnMI1SO + KsvKmkSZ2c4oJSKd5VGpvwoaJtKnFkhOUzGX8BVd/wAQre5YI5Z9Jaz7RWDPvC3ChIraqSojlRaIRwDR + sks1/SM7C5AymKkZHRVVWf6hdGoLfeDHYpx20TVfOJ6NQ4T7UbLKifz5OsnrjoqiVgAAZ0tjRYgPGtX8 + xC7Toq2o1fOGZa27tmLSxAeNav5iF2nRVFSH84plrbu2Yr2TtdgT59NTTEvAvCK8C8LJOofQXAP9jlLe + Lmx244fAL9jdK+Lmx3AycbeO5qXofgQTvHwOyvZB4rPpVBeoFXxlP3/kGDx8vr9IPFZ9KoLzBH8YT9/5 + CvJ+BohMJ3nG1vCxsX/CEugq5ZfiXFbkRpkxHotyEn9lzlSZ28lpCtLwLwpxGJEarXbFEmKrHI5D6csu + NvMoeaWlbbiSUhSTtJRHlIyHsUDihYRt3JAqjJo/emMtRehFKPK7D5Cs5UmdnIZdwX8MtGhLCerFLkN6 + PajkAIljjHZh0mWqw3RkHtCIY5H26zLVYboyHaS3mBzmPAVRLldlVyB68Ug7cCkvP+aiOkMIhLz7KfIH + txRTtwJS7WojpDD875dOYpLJ+ZeRbo+Z+Eg/1hVF4ziOkUPpgPmZhJP9YdReNIjpFBOR2qMTOxDBlqux + r5RlXhgy8+xq5Rk3hfh+FCU9O8pLeDI4pR20TVnOJ6JQWm8GUxRjtoirOcT0SgraHl1wO8on5UEwAAAz + hYGixAeNav5iF2nRUlSq+ccz1t3bMW3iA8a1fzELtOin6lP5xzPXHdsxXsra7ASnU1IYl4F4RWgtFkn0 + LapbD9X9N09AyKXLlnwSCaJpnqkLeVdLgtO3KMuKxnsJzd26uTZe7Bf3CmrRFENm7ZYoisCsSVhKiqjU + qd2RXou06LCfhEqLCLNYWZVGqFN+FY6g18HZ6mkk3jVlK07TtMcvBn8YT9/5A+DK/jSPbLJtuEo1Edg8 + w4StVKJqPrnIqLrM28C8IrQWhwXobmlKhmdMVBCT2Tv9RjYRd9tRlaR9oyMu2RlkMhZ8RjN4T0IvIXJs + nD8S/uFL2gM7SsyDjFgQ4viQ6Me5mxS3t9HhR/jkv9F/cKwwg1hOK5qd6op6pg415CEK6i3cRYlNhWFy + ENMqGO8diiIu0Pz4Mr+NIVbLXFq1p2WLe2qe4A+yq5BaNDYaK5oynmpDI4uDbgmlrWhLkKlaiNR2nlPS + Kwh2jbUZmojyCa0MthI5l16HJXKjqtUt+KxlcKbbZGmYS622z/IoFMzaYRE0mkVMotRKiIp5bzppKwjU + ozM7C7WUx7fR1RBJtIrDtEPwY/4y/wCBydLo13cae0iKqd5SaAV2NXKMm8MZhHUkmVpHaYktDLEVGoin + FyIqkt4MtihnbRFW84nolBZLQzOKAdtD1bzqeiUFbQ3C4HaVT8iCaAAAZwqjRYgPGtX8xC7Topypj+cc + z1x3bMXHiA8a1fzELtOimqm+skz1x3bMVrK2uwE5vYhg2gtHkAtCVD1aC0eQACh6tBaPIABQ9WgtHkAA + oerQWjyAAUPVoLR5AAKHq0Fo8gAFD1aC0eQACh6tBaPIABQ9WhmsT07aHq7nU9EoLGGcxPPqNV3Op6JQ + StDcLgd5ZPyIJsAABnCkNFiA8a1fzELtOimqm+skz1x3bMXBiERDDE0q4332miNiFsvrJNvXO90dnMcX + aloyYRMYqt3kKfdU4aSQ1YV4zOzh0ihITEOCrr67ReYhufSgrgAzm9tpXPl/yGvaBvbaVz5f8hr2hT0h + A45C3V4nAWMAZze20rny/wCQ17QN7bSufL/kNe0DSEDjkHV4nAWMAZze20rny/5DXtA3ttK58v8AkNe0 + DSEDjkHV4nAWMAZze20rny/5DXtA3ttK58v+Q17QNIQOOQdXicBYwBnN7bSufL/kNe0De20rny/5DXtA + 0hA45B1eJwFjAGc3ttK58v8AkNe0De20rny/5DXtA0hA45B1eJwFjAGc3ttK58v+Q17QN7bSufL/AJDX + tA0hA45B1eJwFjAGc3ttK58v+Q17QN7bSufL/kNe0DSEDjkHV4nAWMAZze20rny/5DXtA3ttK58v+Q17 + QNIQOOQdXicBYwzmJ59Rqu51PRKBvbaVz5f8hr2hYGDSh5Jg4pudQcHUKZgUaRuGbpoSaTJBlYVh6QrO + TkKLCVrV1nWDBe19VPnsAABGHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AD//2Q== + + + + + /9j/4AAQSkZJRgABAQEASABIAAD/4QC+RXhpZgAATU0AKgAAAAgABwESAAMAAAABAAEAAAEaAAUAAAAB + AAAAYgEbAAUAAAABAAAAagEoAAMAAAABAAIAAAExAAIAAAAPAAAAcgEyAAIAAAAUAAAAgodpAAQAAAAB + AAAAlgAAAAAAAABIAAAAAQAAAEgAAAABUGl4ZWxtYXRvciAzLjAAADIwMTM6MTE6MDkgMTU6MTE6MzAA + AAKgAgAEAAAAAQAAAyCgAwAEAAAAAQAAAlgAAAAAAAD/4gxYSUNDX1BST0ZJTEUAAQEAAAxITGlubwIQ + AABtbnRyUkdCIFhZWiAHzgACAAkABgAxAABhY3NwTVNGVAAAAABJRUMgc1JHQgAAAAAAAAAAAAAAAAAA + 9tYAAQAAAADTLUhQICAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + ABFjcHJ0AAABUAAAADNkZXNjAAABhAAAAGx3dHB0AAAB8AAAABRia3B0AAACBAAAABRyWFlaAAACGAAA + ABRnWFlaAAACLAAAABRiWFlaAAACQAAAABRkbW5kAAACVAAAAHBkbWRkAAACxAAAAIh2dWVkAAADTAAA + AIZ2aWV3AAAD1AAAACRsdW1pAAAD+AAAABRtZWFzAAAEDAAAACR0ZWNoAAAEMAAAAAxyVFJDAAAEPAAA + CAxnVFJDAAAEPAAACAxiVFJDAAAEPAAACAx0ZXh0AAAAAENvcHlyaWdodCAoYykgMTk5OCBIZXdsZXR0 + LVBhY2thcmQgQ29tcGFueQAAZGVzYwAAAAAAAAASc1JHQiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAAABJz + UkdCIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAWFlaIAAAAAAAAPNRAAEAAAABFsxYWVogAAAAAAAAAAAAAAAAAAAAAFhZWiAAAAAAAABvogAA + OPUAAAOQWFlaIAAAAAAAAGKZAAC3hQAAGNpYWVogAAAAAAAAJKAAAA+EAAC2z2Rlc2MAAAAAAAAAFklF + QyBodHRwOi8vd3d3LmllYy5jaAAAAAAAAAAAAAAAFklFQyBodHRwOi8vd3d3LmllYy5jaAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZXNjAAAAAAAAAC5JRUMgNjE5NjYt + Mi4xIERlZmF1bHQgUkdCIGNvbG91ciBzcGFjZSAtIHNSR0IAAAAAAAAAAAAAAC5JRUMgNjE5NjYtMi4x + IERlZmF1bHQgUkdCIGNvbG91ciBzcGFjZSAtIHNSR0IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGVzYwAA + AAAAAAAsUmVmZXJlbmNlIFZpZXdpbmcgQ29uZGl0aW9uIGluIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAA + LFJlZmVyZW5jZSBWaWV3aW5nIENvbmRpdGlvbiBpbiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAHZpZXcAAAAAABOk/gAUXy4AEM8UAAPtzAAEEwsAA1yeAAAAAVhZWiAAAAAAAEwJVgBQ + AAAAVx/nbWVhcwAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAo8AAAACc2lnIAAAAABDUlQgY3VydgAA + AAAAAAQAAAAABQAKAA8AFAAZAB4AIwAoAC0AMgA3ADsAQABFAEoATwBUAFkAXgBjAGgAbQByAHcAfACB + AIYAiwCQAJUAmgCfAKQAqQCuALIAtwC8AMEAxgDLANAA1QDbAOAA5QDrAPAA9gD7AQEBBwENARMBGQEf + ASUBKwEyATgBPgFFAUwBUgFZAWABZwFuAXUBfAGDAYsBkgGaAaEBqQGxAbkBwQHJAdEB2QHhAekB8gH6 + AgMCDAIUAh0CJgIvAjgCQQJLAlQCXQJnAnECegKEAo4CmAKiAqwCtgLBAssC1QLgAusC9QMAAwsDFgMh + Ay0DOANDA08DWgNmA3IDfgOKA5YDogOuA7oDxwPTA+AD7AP5BAYEEwQgBC0EOwRIBFUEYwRxBH4EjASa + BKgEtgTEBNME4QTwBP4FDQUcBSsFOgVJBVgFZwV3BYYFlgWmBbUFxQXVBeUF9gYGBhYGJwY3BkgGWQZq + BnsGjAadBq8GwAbRBuMG9QcHBxkHKwc9B08HYQd0B4YHmQesB78H0gflB/gICwgfCDIIRghaCG4IggiW + CKoIvgjSCOcI+wkQCSUJOglPCWQJeQmPCaQJugnPCeUJ+woRCicKPQpUCmoKgQqYCq4KxQrcCvMLCwsi + CzkLUQtpC4ALmAuwC8gL4Qv5DBIMKgxDDFwMdQyODKcMwAzZDPMNDQ0mDUANWg10DY4NqQ3DDd4N+A4T + Di4OSQ5kDn8Omw62DtIO7g8JDyUPQQ9eD3oPlg+zD88P7BAJECYQQxBhEH4QmxC5ENcQ9RETETERTxFt + EYwRqhHJEegSBxImEkUSZBKEEqMSwxLjEwMTIxNDE2MTgxOkE8UT5RQGFCcUSRRqFIsUrRTOFPAVEhU0 + FVYVeBWbFb0V4BYDFiYWSRZsFo8WshbWFvoXHRdBF2UXiReuF9IX9xgbGEAYZRiKGK8Y1Rj6GSAZRRlr + GZEZtxndGgQaKhpRGncanhrFGuwbFBs7G2MbihuyG9ocAhwqHFIcexyjHMwc9R0eHUcdcB2ZHcMd7B4W + HkAeah6UHr4e6R8THz4faR+UH78f6iAVIEEgbCCYIMQg8CEcIUghdSGhIc4h+yInIlUigiKvIt0jCiM4 + I2YjlCPCI/AkHyRNJHwkqyTaJQklOCVoJZclxyX3JicmVyaHJrcm6CcYJ0kneierJ9woDSg/KHEooijU + KQYpOClrKZ0p0CoCKjUqaCqbKs8rAis2K2krnSvRLAUsOSxuLKIs1y0MLUEtdi2rLeEuFi5MLoIuty7u + LyQvWi+RL8cv/jA1MGwwpDDbMRIxSjGCMbox8jIqMmMymzLUMw0zRjN/M7gz8TQrNGU0njTYNRM1TTWH + NcI1/TY3NnI2rjbpNyQ3YDecN9c4FDhQOIw4yDkFOUI5fzm8Ofk6Njp0OrI67zstO2s7qjvoPCc8ZTyk + POM9Ij1hPaE94D4gPmA+oD7gPyE/YT+iP+JAI0BkQKZA50EpQWpBrEHuQjBCckK1QvdDOkN9Q8BEA0RH + RIpEzkUSRVVFmkXeRiJGZ0arRvBHNUd7R8BIBUhLSJFI10kdSWNJqUnwSjdKfUrESwxLU0uaS+JMKkxy + TLpNAk1KTZNN3E4lTm5Ot08AT0lPk0/dUCdQcVC7UQZRUFGbUeZSMVJ8UsdTE1NfU6pT9lRCVI9U21Uo + VXVVwlYPVlxWqVb3V0RXklfgWC9YfVjLWRpZaVm4WgdaVlqmWvVbRVuVW+VcNVyGXNZdJ114XcleGl5s + Xr1fD19hX7NgBWBXYKpg/GFPYaJh9WJJYpxi8GNDY5dj62RAZJRk6WU9ZZJl52Y9ZpJm6Gc9Z5Nn6Wg/ + aJZo7GlDaZpp8WpIap9q92tPa6dr/2xXbK9tCG1gbbluEm5rbsRvHm94b9FwK3CGcOBxOnGVcfByS3Km + cwFzXXO4dBR0cHTMdSh1hXXhdj52m3b4d1Z3s3gReG54zHkqeYl553pGeqV7BHtje8J8IXyBfOF9QX2h + fgF+Yn7CfyN/hH/lgEeAqIEKgWuBzYIwgpKC9INXg7qEHYSAhOOFR4Wrhg6GcobXhzuHn4gEiGmIzokz + iZmJ/opkisqLMIuWi/yMY4zKjTGNmI3/jmaOzo82j56QBpBukNaRP5GokhGSepLjk02TtpQglIqU9JVf + lcmWNJaflwqXdZfgmEyYuJkkmZCZ/JpomtWbQpuvnByciZz3nWSd0p5Anq6fHZ+Ln/qgaaDYoUehtqIm + opajBqN2o+akVqTHpTilqaYapoum/adup+CoUqjEqTepqaocqo+rAqt1q+msXKzQrUStuK4trqGvFq+L + sACwdbDqsWCx1rJLssKzOLOutCW0nLUTtYq2AbZ5tvC3aLfguFm40blKucK6O7q1uy67p7whvJu9Fb2P + vgq+hL7/v3q/9cBwwOzBZ8Hjwl/C28NYw9TEUcTOxUvFyMZGxsPHQce/yD3IvMk6ybnKOMq3yzbLtsw1 + zLXNNc21zjbOts83z7jQOdC60TzRvtI/0sHTRNPG1EnUy9VO1dHWVdbY11zX4Nhk2OjZbNnx2nba+9uA + 3AXcit0Q3ZbeHN6i3ynfr+A24L3hROHM4lPi2+Nj4+vkc+T85YTmDeaW5x/nqegy6LzpRunQ6lvq5etw + 6/vshu0R7ZzuKO6070DvzPBY8OXxcvH/8ozzGfOn9DT0wvVQ9d72bfb794r4Gfio+Tj5x/pX+uf7d/wH + /Jj9Kf26/kv+3P9t////2wBDAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB + AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQH/2wBDAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB + AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQH/wAARCAJYAyADAREAAhEBAxEB/8QAHwAAAQUB + AQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1Fh + ByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNk + ZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT + 1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL + /8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYk + NOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImK + kpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3 + +Pn6/9oADAMBAAIRAxEAPwDXurq5vrm4vL24mu7y7mlubq6uZXnuLm4ndpJp55pGaSWaWRmkkkdmd3Ys + xJJNf7G06cKUIUqUI06dOMYU6cIqEIQglGMIRilGMYxSUYpJJKyP8SqlSpWqVK1apOrVqzlUq1akpTqV + Kk5OU5znJuUpzk3KUpNuTbbbbIKsgKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKA + CgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgA + oAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAK + ACgAoAKACgAoAKAJ7W6ubK5t7yzuJrS8tJorm1uraV4bi2uIXWSGeCaNlkimikVZI5EZXR1DKQQDUVKc + KsJ0qsI1KdSMoVKdSKnCcJpxlCcZJxlGUW1KLTTTaZdOpUo1IVqVSdKrSnGpTq05ShUp1ISUoThOLUoz + jJKUZRaaaTTuQVZAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAU + AFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFA + BQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQA + UAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAF + ABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQ + AUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUA + FABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFAB + QAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAU + AFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFA + BQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQA + UAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAF + ABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQ + AUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUA + FABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFAB + QAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAU + AFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFA + BQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQA + UAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAF + ABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQ + AUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUA + FABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFAB + QAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAU + AFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFA + BQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQA + UAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAF + ABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQ + AUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUA + FABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFAB + QAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAU + AFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFA + BQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQA + UAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAF + ABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQ + AUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUA + FABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFAB + QAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAU + AFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFA + BQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQA + UAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAF + ABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQ + AUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUA + FABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFAB + QAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAU + AFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFA + BQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQA + UAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAF + ABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQ + AUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQBueGfDPiHxnr+k+FfCei6l4i + 8Sa9exado+iaPaTX+palezkiO3tbW3V5ZXIDOxC7Y41eWRkjR3Xkx+PwWV4PE5jmWLoYHA4OlKvisXiq + saNChSh8U6lSbUYrZLW8pNRinJpPsy/L8dm2Nw2W5ZhMRj8fja0aGFweFpTrYjEVp/DCnTgnKT3b0tGK + cpNRTa/Zv4Jf8EY/HniLTrLW/jn8Q7P4fG5QTSeDPCdjbeKPEMEbgYg1LxBJexeH9NvUbcXj02DxNbbd + g+1rIzrF/LfFn0pcnwNethOEckq517NuKzXMa08vwU5Ju86GDjSnja9JrROvPL6l237NxSc/614P+iVn + ePoUcZxnn1LInUSnLKMso08yx8ItfBiMdKtHA4esnq1h4ZjTasvaKV0vrO2/4ItfsyrCi3nxD+O09wB+ + 8ltvEHw/tYWPqkEvw2vHQezXEh96/N6n0qOPnNulkvCEIfZjUwWdVJr1nHPqSl8oRP0+n9Ebw7UEque8 + aTn9qVPH5HSg35Qlw/Va+dSXqT/8OXP2XP8Aoffj7/4VPw7/APnWVH/E0/iD/wBCfg3/AMN+d/8A0RF/ + 8Sj+G/8A0O+N/wDw5ZD/APQ0H/Dlz9lz/offj7/4VPw7/wDnWUf8TT+IP/Qn4N/8N+d//REH/Eo/hv8A + 9Dvjf/w5ZD/9DQf8OXP2XP8Aoffj7/4VPw7/APnWUf8AE0/iD/0J+Df/AA353/8AREH/ABKP4b/9Dvjf + /wAOWQ//AENB/wAOXP2XP+h9+Pv/AIVPw7/+dZR/xNP4g/8AQn4N/wDDfnf/ANEQf8Sj+G//AEO+N/8A + w5ZD/wDQ0H/Dlz9lz/offj7/AOFT8O//AJ1lH/E0/iD/ANCfg3/w353/APREH/Eo/hv/ANDvjf8A8OWQ + /wD0NB/w5c/Zc/6H34+/+FT8O/8A51lH/E0/iD/0J+Df/Dfnf/0RB/xKP4b/APQ743/8OWQ//Q0H/Dlz + 9lz/AKH34+/+FT8O/wD51lH/ABNP4g/9Cfg3/wAN+d//AERB/wASj+G//Q743/8ADlkP/wBDQf8ADlz9 + lz/offj7/wCFT8O//nWUf8TT+IP/AEJ+Df8Aw353/wDREH/Eo/hv/wBDvjf/AMOWQ/8A0NB/w5c/Zc/6 + H34+/wDhU/Dv/wCdZR/xNP4g/wDQn4N/8N+d/wD0RB/xKP4b/wDQ743/APDlkP8A9DQf8OXP2XP+h9+P + v/hU/Dv/AOdZR/xNP4g/9Cfg3/w353/9EQf8Sj+G/wD0O+N//DlkP/0NB/w5c/Zc/wCh9+Pv/hU/Dv8A + +dZR/wATT+IP/Qn4N/8ADfnf/wBEQf8AEo/hv/0O+N//AA5ZD/8AQ0H/AA5c/Zc/6H34+/8AhU/Dv/51 + lH/E0/iD/wBCfg3/AMN+d/8A0RB/xKP4b/8AQ743/wDDlkP/ANDQf8OXP2XP+h9+Pv8A4VPw7/8AnWUf + 8TT+IP8A0J+Df/Dfnf8A9EQf8Sj+G/8A0O+N/wDw5ZD/APQ0H/Dlz9lz/offj7/4VPw7/wDnWUf8TT+I + P/Qn4N/8N+d//REH/Eo/hv8A9Dvjf/w5ZD/9DQf8OXP2XP8Aoffj7/4VPw7/APnWUf8AE0/iD/0J+Df/ + AA353/8AREH/ABKP4b/9Dvjf/wAOWQ//AENB/wAOXP2XP+h9+Pv/AIVPw7/+dZR/xNP4g/8AQn4N/wDD + fnf/ANEQf8Sj+G//AEO+N/8Aw5ZD/wDQ0H/Dlz9lz/offj7/AOFT8O//AJ1lH/E0/iD/ANCfg3/w353/ + APREH/Eo/hv/ANDvjf8A8OWQ/wD0NB/w5c/Zc/6H34+/+FT8O/8A51lH/E0/iD/0J+Df/Dfnf/0RB/xK + P4b/APQ743/8OWQ//Q0H/Dlz9lz/AKH34+/+FT8O/wD51lH/ABNP4g/9Cfg3/wAN+d//AERB/wASj+G/ + /Q743/8ADlkP/wBDQf8ADlz9lz/offj7/wCFT8O//nWUf8TT+IP/AEJ+Df8Aw353/wDREH/Eo/hv/wBD + vjf/AMOWQ/8A0NB/w5c/Zc/6H34+/wDhU/Dv/wCdZR/xNP4g/wDQn4N/8N+d/wD0RB/xKP4b/wDQ743/ + APDlkP8A9DQf8OXP2XP+h9+Pv/hU/Dv/AOdZR/xNP4g/9Cfg3/w353/9EQf8Sj+G/wD0O+N//DlkP/0N + B/w5c/Zc/wCh9+Pv/hU/Dv8A+dZR/wATT+IP/Qn4N/8ADfnf/wBEQf8AEo/hv/0O+N//AA5ZD/8AQ0H/ + AA5c/Zc/6H34+/8AhU/Dv/51lH/E0/iD/wBCfg3/AMN+d/8A0RB/xKP4b/8AQ743/wDDlkP/ANDQf8OX + P2XP+h9+Pv8A4VPw7/8AnWUf8TT+IP8A0J+Df/Dfnf8A9EQf8Sj+G/8A0O+N/wDw5ZD/APQ0H/Dlz9lz + /offj7/4VPw7/wDnWUf8TT+IP/Qn4N/8N+d//REH/Eo/hv8A9Dvjf/w5ZD/9DQf8OXP2XP8Aoffj7/4V + Pw7/APnWUf8AE0/iD/0J+Df/AA353/8AREH/ABKP4b/9Dvjf/wAOWQ//AENB/wAOXP2XP+h9+Pv/AIVP + w7/+dZR/xNP4g/8AQn4N/wDDfnf/ANEQf8Sj+G//AEO+N/8Aw5ZD/wDQ0H/Dlz9lz/offj7/AOFT8O// + AJ1lH/E0/iD/ANCfg3/w353/APREH/Eo/hv/ANDvjf8A8OWQ/wD0NB/w5c/Zc/6H34+/+FT8O/8A51lH + /E0/iD/0J+Df/Dfnf/0RB/xKP4b/APQ743/8OWQ//Q0H/Dlz9lz/AKH34+/+FT8O/wD51lH/ABNP4g/9 + Cfg3/wAN+d//AERB/wASj+G//Q743/8ADlkP/wBDQf8ADlz9lz/offj7/wCFT8O//nWUf8TT+IP/AEJ+ + Df8Aw353/wDREH/Eo/hv/wBDvjf/AMOWQ/8A0NB/w5c/Zc/6H34+/wDhU/Dv/wCdZR/xNP4g/wDQn4N/ + 8N+d/wD0RB/xKP4b/wDQ743/APDlkP8A9DQf8OXP2XP+h9+Pv/hU/Dv/AOdZR/xNP4g/9Cfg3/w353/9 + EQf8Sj+G/wD0O+N//DlkP/0NEFz/AMEWv2ZXhdbT4h/HaC4I/dy3PiD4f3UKn1eCL4bWbuPZbiM+9XT+ + lRx8pp1cl4QnD7UaeCzqnN+k5Z9VS+cJEVPojeHbg1Sz3jSE/syqY/I6sE/OEeH6Tl8qkfU+Pvjt/wAE + ZviX4Ztpdd+Anj7TPiRaW6SSXHgnxdaw+FPFsqADyxomvpeTeGNWug2TJa6tF4VhaJmaK+eeGO2vP0Ph + b6U2WY3FYfC8V5FLJ6VRuFbNMur1cfhqcpNctWpgpUY4ujRgrqoqM8fVd1KMdHF/mvFv0SM1wOExOL4P + 4gjndWmlUo5TmdCll+KqRipc9Kljo1p4OtXn7rputDAUlZxnN8ynH8cvEvhrxD4N17VvC3ivRdS8O+I9 + CvZdP1jRNYs5rDUtOvYDiS3u7S4RJYnGQy7l2yRsksbNG6s39UYDMMFmuCw2Y5bi6GOwOMpRr4XF4arG + tQr0p7Tp1INxkr3TV7xknGSUk0v5GzHLsflGOxWW5phMRgMwwVaVDF4PF0p0cRh60PihVpzSlF6pp2tK + LUotxkm8Ouw4goAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKA + CgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAP6o/8AgmV+ + x7o/wN+FWkfFjxZpCSfF/wCJ+jW+rTT30KNc+DvB+pKLvRvDunCRTLZXupWL2uq+JXxDcvdzQaPcJs0c + NN/nj4+eJ2K4u4ixPDmW4lrhnIMVPDRhSk1DNMzoN08VjqzT5a1KhWVTD4Be9TVOM8VB3xVo/wClH0d/ + CrC8G8NYXifNMLGXFXEWEhiZTrQTqZTlWIXtcJgKHMuajWxNF0sTmD92o6s4YWa5cKnP9Ra/n0/pAKAC + gAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAo + AKAPyw/4Kg/sjaL8ZfhFrnxj8LaNj4tfCnQ7rW2m023U3njHwTpam817Qb6OJfP1G+0fTkvNZ8NhFuL0 + 3Ntc6JZxOdZXyv37wI8UMTwbn9DIMzxEpcL57iYUKsKkpSjleY1v3eHx+HTuqdOrUcKGPhG0Z0pRxDvP + DRjP+dPpB+E2F434dxHEeVYaEOLMgws69KpTjGM82yyjepicuxLSvVq0aSqYjLpy5pQrRnho2hipSh/L + DBPDcwxXFvLHPBPGssM0Th45Y3AZHR1JVlZSCGBIIOa/0QjKM4xnCSlGSUoyi04yi1dSTV001qmnqf5q + ThKnKUJxlCcJOMoyTUoyTs009U090yWqJCgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoA + KACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAC + gAoAKAPS/gv4VtfHXxi+E/gi+i8+y8ZfEvwJ4VvIdxTzrXxD4p0rSLiLePmXzIrx03DkZyOa8HinMamT + 8McR5tSlyVcryHN8xpztflqYLL8RiYSs73tKknbW59DwlllPOuK+GcnrR56WbcQ5LllWN2uanj8yw2Fn + G61XNGq1da6n9zUcccUaRRIkcUaLHHHGoSOONAFRERQFVFUBVVQAoAAGBX+R0pSlJyk3KUm5SlJtylJu + 7bb1bb1bererP9lklFKMUoxikoxSSSSVkklokloktEh9IYUAFABQAUAFABQAUAFABQAUAFABQAUAFABQ + AUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAMlijnjkhmjSaGZHililRZI5Y5FKy + RyI4KujqSrowKspIIIJpptNNNppppp2aa1TT3TT1TE0pJxklJSTTTV009Gmno01unuf543j+/h+B/wC0 + F8bPhM6SDwh4H+MXxL8FafBueaXRLfwz411rQ7cwElpJbZIrFFuYOWJBuIczGRLj/TfgfiatUyPI8TjJ + urQzHKstxs5WvKjVxmDo151IJfYlOo5TprZtygubmU/8qOPuFqNPP8/wuCgqWIyzOM0wNON/drUsHja+ + HhTnJ/8ALyMaajCo97cs3y2lD0+CeG5hiuLeWOeCeNZYZonEkcscgDJIjqSrKykFWBIIOa/VozjUjGcJ + KcJpSjKLvGUXqmmtGmtbn5DOEqcpQnGUJwk4yjJNSjJOzTT1TT3TJaokKACgAoAKACgAoAKACgAoAKAC + gAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAo + AKACgAoAKACgAoAKACgAoAKACgD339lL/k6P9mz/ALL78Hf/AFYnh2vjfEX/AJN9x3/2RvE//qkxx9v4 + Z/8AJyPD7/st+FP/AFfYA/trr/KE/wBgQoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAC + gAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgD/Ot/bb/5PP8A2uv+znvj5/6tbxZX+hXBX/JG + 8Jf9kzkP/qrwp/mzx1/yW/GP/ZVcQ/8Aq3xh5t8O/iJP4YmTTNUeSfQZ5P8AaeTTJHbLTwDlmt2Ylri3 + UE5JmhHm+Yk/6Lk+cywMlQruU8JKXrKhKT1nDq4PecFd7zgubmjP80zvJI4+LxGHShjILyUcRFLSE3sq + iWkKj8oTfLyyh9XQTw3UMVzbyxzwTxrLDNE4eOWNwGR0dSVZWUgggkEGvv4TjUjGcJKcJpSjKLTjKLV1 + JNaNNapn51OEqcpQnGUJwk4yjJNSjJOzTT1TT3TJaokKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKA + CgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgA + oAKACgAoAKAPff2Uv+To/wBmz/svvwd/9WJ4dr43xF/5N9x3/wBkbxP/AOqTHH2/hn/ycjw+/wCy34U/ + 9X2AP7a6/wAoT/YEKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAK + ACgAoAKACgAoAKACgAoAKACgAoA/zrf22/8Ak8/9rr/s574+f+rW8WV/oVwV/wAkbwl/2TOQ/wDqrwp/ + mzx1/wAlvxj/ANlVxD/6t8YfMNfTHyp6p8PPiJP4YmTTNTeS40GeT3eXTJHPzT245ZrdmO64tlyTlpoR + 5u9J/eybOJYGaoV25YSb83KhJvWcOrg3rUguvvwXNzKfz2d5JHMIvEYdRhjIR8lHEJbQm9lNLSFR6bQm + +W0qf1db3EF1BFc20sc9vPGssM0Th45Y3AZHR1JDKwIIIPNfoEJxqRjOElOE0pRlFpxlFq6kmtGmtUz8 + 6nCdOcoVIyhOEnGcZJqUZJ2aknqmno09bk1USFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAF + ABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQ + AUAe+/spf8nR/s2f9l9+Dv8A6sTw7XxviL/yb7jv/sjeJ/8A1SY4+38M/wDk5Hh9/wBlvwp/6vsAf211 + /lCf7AhQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAU + AFABQAUAFABQAUAFAH+db+23/wAnn/tdf9nPfHz/ANWt4sr/AEK4K/5I3hL/ALJnIf8A1V4U/wA2eOv+ + S34x/wCyq4h/9W+MPmGvpj5UKAPU/h58RJ/C866bqTST6DPJyOXl02Vz81xbryWgZjuubZc5OZoR5u9J + /eybOZYCSoV3KeDnLzcqEpPWcFu4N61Ka85wXPzRqfP53kkMwi69BRhjYLd6RxEUtIVH0mlpTqPyhN8n + LKn9X29xBdwRXNtNHPbzxrLDNE4eOWNxuV0dSQysDkEGv0CE4VIxnCUZwmlKM4tSjKL1TTV00+5+czhO + nOVOpGUJwk4zhJNSjJOzTT1TT3JqokKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAK + ACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgD339lL/ + AJOj/Zs/7L78Hf8A1Ynh2vjfEX/k33Hf/ZG8T/8Aqkxx9v4Z/wDJyPD7/st+FP8A1fYA/trr/KE/2BCg + AoAKACgAoAKACgAoAKACgAoAKACgAoA5rxb4z8I+AtEuvEvjjxPoHhDw9ZY+1634l1ew0TS4GYMUSS+1 + Ge3txLLtYRQiQyysNsaO3Fd+W5Xmec4ungMpy/G5njat/Z4TAYati8RNK15KlQhUnyxuuaVuWKd5NLU8 + /NM2yvJMHUzDOMxwOVYGj/FxmY4qhg8NBu9lKtiJ06fNKz5Y83NJ6RTeh+Ynxj/4K+/s5eAJrjTPhzpn + iX4zavAXQ3WkRnwr4REseVaI+INdtH1Oc+ZgJcaZ4Z1KwljDSxXrr5fmfv3DH0Z+Oc5jCvnmIwHC2GnZ + 8mJl/aOZcstVJYLB1VQjpvDEZhQrRdoypJ83L/OnFn0qOAcjnUw+QYfMOLcVBte0wsf7NyvmV04vHY2m + 8RP3tp4fLsRRmryjWa5eb85viD/wWQ/aU8STyx+BPDnw9+G+nEt5Bj0u68Xa6m7p5+pa7cro8+wY2+V4 + ZtctuL71Kqn7hkv0X+BMDCLzjHZ3ntfTnviKeW4N/wCChhKbxULu9+bH1NLWtq3+CZ79LDxBzCc45LgM + i4foO/I44armmNjfbnxGNqLCTstuXLqet273SXyx4i/4KC/tleJ52uNR+PvjO0Zs/J4dTRPCcCg9lg8L + 6TpEXHQMVL9yxJJP6HgvBfwuy+ChR4Nyuql9rHPF5lNvu55hicTLXrZpeR+a4/xz8Wcxm51+N82pN393 + ARweWQXkoZdhcLH52b7u+pwMv7Xv7VU04uH/AGkPjgJASdsXxR8ZwQc882sOsR2zfRoiK9mPhp4dxhyL + gbhJp9ZcP5VOf/gyeFlU/wDJtep4kvFPxLlPnfH/ABkpdo8SZvCH/guGLjT++J1Ojft2/tg6FPHcWX7Q + nxHnkiIKrrOrp4jhOP8AnrbeIbfVLeYeomikB75ya87FeEHhljIShV4KyOClu8LhpYGf/btTBVMPUj/2 + 7JHpYTxp8VcFONSjx1n85Rd0sXilj4P/ABU8dTxNOfpOMkfSfgj/AIK8ftceGJ4D4lvPAfxGtEwtzF4j + 8IWuj3c0eRuaK68FzeGYYLjGQkr2VzCpO57aXpXwubfRp8NswhP6hSzjI6ju4SwOZ1MVTjLopU81jj5z + h3iq0JvpUifoGT/Sm8UcunD+0auSZ/SVlUjj8qp4WrOPVxq5RPLoQqdpOjUgnq6ctj9AvhN/wWf+EfiK + 4tdO+L/w68TfDaaXbHLr/h+9Txz4eifID3N5bRWWj+IrO3YbmENhpfiC4Q4jzKCZR+L8SfRZ4lwMKlfh + nPMvz2Mbyjg8bSllGOkulOlOVXFYGrPo51sTgoPWXu/CfuXDH0t+F8fUpUOKshzHh+U7RljsDVWc4CL+ + 1UrU40cJj6VPryUMNjqi2974j9U/hj8Z/hR8Z9IOufCz4geF/HOnxrG10dC1SC5vtNMwJii1jSXMeraL + cSAErbatZWdwRz5WDmv54z/hbiPhbE/VOIcmzDKK8nJU/rmHnTpV+X4pYbEpSw2Kgm9amGq1YX05rn9K + 8O8XcM8W4V4zhrPMuzmhFRdT6liYVK2H59YxxeFbjisJUktVTxNGlUtrynpteAfRBQAUAFABQAUAFABQ + AUAFABQAUAFABQAUAFAH+db+23/yef8Atdf9nPfHz/1a3iyv9CuCv+SN4S/7JnIf/VXhT/Nnjr/kt+Mf + +yq4h/8AVvjD5hr6Y+VCgAoA9S+HnxDn8LzrpupNJPoM8mSPmkl02Rz81xbryzQsTuuLdQc8zQjzd6Te + 7k+cTwE1RrOU8JOWq1cqEm9akFu4t6zgt9ZxXNdT+fzrJYZhB16CjDGQjo9o14paU6j2U0tKdR7aQm+S + 0ofWFvcwXcEN1azR3FvcRrLDPE4eOWNxuV0dSQysDkEGv0GE4VIRqU5KcJpSjOLvGUXqmmt0z85nCdOc + qdSMoThJxnCSalGSdmmnqmnuTVRIUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAF + ABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAe+/spf8nR/s + 2f8AZffg7/6sTw7XxviL/wAm+47/AOyN4n/9UmOPt/DP/k5Hh9/2W/Cn/q+wB/bXX+UJ/sCFABQAUAFA + BQAUAFABQAUAFABQAUARTTQ20M1xcTRQW8EUk0880ixQwwxKZJZppZCqRxRorPJI7BUUFmIAJqoQnUnG + EIynOclCEIJynOcnaMYxV3KUm0kkm23ZXZM5wpwlUqSjCEIynOc5KMIQinKUpSk0oxik3KTaSSbbsfjd + +1j/AMFa/A3w8bUvBP7OsGm/EnxjEZbS78d3nmy/D3Q5gSjtpIglgufGd7EQ2ya0ms/DqM0NzFqetRrP + Y1/UPhx9G7N879hmvG86+RZXJRqU8opcsc7xkXqvrPPGdPK6Urq8akauOaU6csPhZONY/k7xO+lBk2RP + EZRwFDD8Q5tFypVc6q80siwU02pPC8koVM3rRs+WdKdLAJuFSOIxcVOi/wABfi58c/i38dvEDeJfix47 + 17xlqStKbOLUbkR6TpKTEGSDQ9Cs0ttF0S2cgF4NLsLSOVh5kokkLOf7K4b4R4b4QwSwHDmUYPK6DUVV + lQp82JxLje08ZjKrnisXUV3aeIrVJRT5YtRsl/EPFHGfFHGmOeYcT51jc2xCcnSjiKnLhcKp6yhg8FSV + PCYOm7K8MNRpRk/ekpSbb8nr6M+YCgAoAKACgAoAKAOn8HeNvF/w98QWPirwL4n13wj4k0199lrfh3U7 + vSdSgBKl4hdWcsUj2820Lc2she3uY8xXEUsTMh8/NMqyzOsFWy7N8BhMzwNdWq4THYeliaE97SdOrGUV + ON24VI2nTl70JRkkz0cqzjNcix1HM8mzHG5XmGHd6OMwGJq4XEQu05R9pSlGTpzslUpybp1I3jUjKLaf + 7a/sq/8ABYDVLKew8HftTWQ1Swdora2+K/hrS44dSsvup5vi/wAL6bElvqNvyzy6p4ZtbW9hRFT/AIR/ + U5pXuU/lHxE+jNh6sa2aeHtX6vWSlOpw5j8RKVCru+XLMwxEnOhN7RoZhVqUpyk39dw8IqD/ALB8NPpU + 4mjOjlPiTR+sUG406fE+X4ZRxFLZc2a5bh4KGIhq3LE5dTp1oKKX1DEzlKov3p8JeL/C/j3w7pXi7wXr + +leKPDOuWy3mk65ol7BqGnX0DEqWhuIHdN8UivDcQvtntriOW3uI4p4pI1/jvMsszDJ8dictzXB4nL8f + hKjpYnCYulOjXpTWtpQmk7Si1OE1eFSEo1ISlCUZP+18rzXLc7wGGzTKMdhsyy7GU1VwuMwdaFfD1oNt + NwqQbXNGSlCpB2nTqRlTqRjOMoro64TvCgAoAKACgAoAKACgAoAKACgAoAKACgD/ADrf22/+Tz/2uv8A + s574+f8Aq1vFlf6FcFf8kbwl/wBkzkP/AKq8Kf5s8df8lvxj/wBlVxD/AOrfGHzDX0x8qFABQAUAeo/D + z4hz+Fp107UWkuNAuJMuvLyabI5+a5tl5LQsTuubZfvczQjzt6ze7k+cTwE1RrOU8JOWq1cqEm9akFu4 + t6zgt9ZxXNdT+fzrJYZhB16CjDGQjo9o14paU6j2U0tKdR7aQm+S0ofWNvcwXcEN1azR3FvcRrLDPE4e + OWNxuV0dSQysDkEGv0GE4VIRqU5KcJpSjOLvGUXqmmt0z85nCdOcqdSMoThJxnCSalGSdmmnqmnuTVRI + UAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAF + ABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQB77+yl/wAnR/s2f9l9+Dv/AKsTw7XxviL/AMm+47/7 + I3if/wBUmOPt/DP/AJOR4ff9lvwp/wCr7AH9tdf5Qn+wIUAFABQAUAFABQAUAFABQAUAFAHNeMfGXhb4 + feGNb8aeNdd07w14W8O2Mupa1reqzi3srG0iwCzscvLNLIyQWtrAkt1e3UsNpaQz3M8UT9+V5XmGdZhh + cqyrB18fmOOrRoYXCYeDnVrVJa2S0UYxSc6lSbjTpU4zqVZwpxlJefm2bZbkWXYzN83xtDL8twFGWIxe + MxM+SjRpR6t6uUpSahTpwUqtWpKFKlCdScYv+XT9t/8A4KNeOP2j77Vvh/8ADu41HwT8Do55Lb7BE7Wn + iH4gRRPhb7xbPDIWg0mYr51n4Vt5PsiqyTay+pXkdsNP/wBBPCbwOyjgalhs6zyFDNuLZQjU9tJKrgsl + lJXdLLYSVp4mN+WrmM17RtOOFVCnKo63+cHjF4+Zzx/WxWR5DOvk/BsZun7GLdLH55GLaVbNKkZXhhZ/ + HSyyEvZK6ni5YirGmqH5j1++n87BQAUAFABQAUAFABQAUAFABQB9dfso/tm/Fj9k/wASi78KXra94F1O + 8im8V/DjV7mb+wdZT5I5r3TnAlbw/wCIhbqqW+t2MTGQxW8Wq2mq2MC2VfmviN4W8OeI+A9nmNL6nm+H + pSjl2eYanH65hXrKNKunyrG4Fzbc8JWkrc1SWHq4etN1T9S8MvFrifwxzH2uWVnjslxNWM8zyDFVJ/Us + WtIzrYd+88Dj1BJU8ZRi+blpxxVLE0YKif1hfAL9oD4bftI/D7TviJ8NdYF9p9xtttY0i6MUOveFtZWJ + JLrQvENgkkps7+33ho3R5bO/tmiv9OubuxnhuH/zk4y4Mz3gXOq+SZ9hnRrwvUw2Jp80sHmGFcmqeMwV + Zxj7WjO1pJqNWjUUqNenTrQnBf6b8E8ccP8AiBkVDPuHsV7ahUtTxWFqcsMbluLUVKpgsfQUpOlXp3um + pSpV6bjXw9SrRnCpL2yvlD68KACgAoAKACgAoAKACgAoAKACgAoA/wA639tv/k8/9rr/ALOe+Pn/AKtb + xZX+hXBX/JG8Jf8AZM5D/wCqvCn+bPHX/Jb8Y/8AZVcQ/wDq3xh8w19MfKhQAUAFABQB6h8PfiFceFrh + dP1BpLjQbiTLpy8mnSOfmubZeSYiTuuLdfv8yxDztyze7k+cTwE1RrOU8JOWq1cqEm9akFu4t6zgt9Zx + XNdT+fzrJYZhB16CjDGQjo9o14paU6j2U0tKdR7aQm+S0ofWVtcwXkEN1azR3FtcRrLDPEweOWNxuV0Y + Eghgc5/Pmv0GE4VIRqU5RnCaUozi04yT1TTW6Z+dThOnOVOpGUJwk4zhJNSjJPVNPVNE1UQFABQAUAFA + BQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQA + UAFABQAUAFABQAUAFABQAUAFABQB77+yl/ydH+zZ/wBl9+Dv/qxPDtfG+Iv/ACb7jv8A7I3if/1SY4+3 + 8M/+TkeH3/Zb8Kf+r7AH9tdf5Qn+wIUAFABQAUAFABQAUAFABQAUAZ2saxpXh/SdT17XNQtNJ0XRdPvN + V1fVNQnjtbHTtN0+3ku76+vLmVligtbW2ilnnmkYJHEjOxABNb4XDYjG4nD4PCUauJxWKrUsPhsPRhKp + Wr1601TpUqUIpynUqVJRhCKTcpNJas58Xi8NgcLicbja9LC4TCUKuJxWJrzjTo4fD0ISq1q1WpJqMKdK + nGU5zk0oxTbZ/J5+39+3HrP7U/jRvDPhK5v9K+CHhC/lHhrSnMtrN4u1KEvA/jTX7U7W8yZC6eH9NuV3 + aPpsrPJFDqd/qKj/AEa8GvCTC+HuVrMMyp0cRxbmdGP1/ELlqRyyhO01lWCqK6tF8rxtem7YqvFKMp4e + jQb/AMyfHDxkxfiTm7y7K6lbDcHZVXn/AGfhnz0p5piI3g83x1N2fNNNxwOHqK+Fw8nKUYYivXS/Ouv2 + 8/BQoAKACgAoAKACgAoAKACgAoAKACgD6P8A2Xf2mvHn7LPxO0/x/wCDp5LzTJzDYeM/CE9zJDpPjDw9 + 5u6fT7wKJFt9Qtt0lzomrrDLPpV/+8CXFlPf2F78N4g8BZP4h5BWybNIKliIc1bK8zhCMsTlmN5bRr0r + 2c6NSyp4vDOUYYmjpzU60KNal9/4ceIed+G3EVDPMpnKrh5uFHN8qnUlDC5rgOa86FWykoV6d5VMHilC + U8NX961SjOvQrf2E/Br4weB/jx8OfDnxP+Hup/2l4c8R2pkRJQsWoaVqEB8rUtD1i1V5PseraVdB7a8g + 3yRMVS5tJrmxuLW6n/zI4o4Zzbg/PMdw/nVD2GOwNTlbjeVHE0Z+9QxeFqNL2uGxNNqpSnZSSbp1I060 + KlOH+q3CfFWTca5DgOI8ixH1jAY+nzJSSjXw1eHu4jB4umnL2WKw1S9OrC8otpVKU6lGdOpP1Cvnz6MK + ACgAoAKACgAoAKACgAoAKACgD/Ot/bb/AOTz/wBrr/s574+f+rW8WV/oVwV/yRvCX/ZM5D/6q8Kf5s8d + f8lvxj/2VXEP/q3xh8w19MfKhQAUAFABQAUAeofD34hXHha4XT9QaS40G4ky6cvJp0jn5rm2XkmIk7ri + 3X7/ADLEPO3LN7uT5xPATVGs3PCTlqtXKjJ71ILdxe84Lf4ormup+BnWSwzGDrUVGGMhHR7RrxW1Oo+k + ltCo9vhk+Wzh9Y21zb3lvDd2s0dxbXEaywzxMHjljcZV0YEggg/0POa/QYThVhGpTkpwmlKM4u8ZReqa + fW5+c1ITpTlTqRlCpCTjOEk1KMk7NNPW6ZPVEBQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFAB + QAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQB77+yl/yd + H+zZ/wBl9+Dv/qxPDtfG+Iv/ACb7jv8A7I3if/1SY4+38M/+TkeH3/Zb8Kf+r7AH9tdf5Qn+wIUAFABQ + AUAFABQAUAFABQAUAfz/AH/BW79sO4lvZf2Vvh9qRis7ZLDUfi/qtlP813cyCLUNH8BpJG3y29rGbTWv + EYUt59zLpemNJF9j1e0n/s36NvhjCNKPiJnVDmq1HWocM4erHSnCLlRxWcOMt51Je0wmBbtyQjicQlL2 + uFqw/h36UPitUlWl4a5HiHGlTVDEcVYqjPWrUko18LkqlF6U6cXSxmPSu51JYbDOUfZYqlU/Biv7DP4p + CgAoAKACgAoAKACgAoAKACgAoAKACgAoA/ST/gm7+2Fc/s3fFWHwb4t1Fl+DvxO1Kx07xItzMRa+EvEM + xjstJ8bwhz5dvBDmLT/E5Up5+ieXeyi4n0PT4D+FeOnhlDjrh2WaZbQT4nyChWr4FwjepmWCjzVcTlM7 + aznL3q+AvzcmL5qUeSOMrzP6B+j/AOKtTgDiWGU5piGuFOIsRRoZgqk/3WV4+bVHC5xDmfLThG8aGYtc + vPg+WtL2k8FQg/6wwQwBBBBAIIOQQeQQe4PUHvX+cnqf6b3vqndPVPe9+otABQAUAFABQAUAFABQAUAF + ABQB/nW/tt/8nn/tdf8AZz3x8/8AVreLK/0K4K/5I3hL/smch/8AVXhT/Nnjr/kt+Mf+yq4h/wDVvjD5 + hr6Y+VCgAoAKACgAoAKAPT/h78QrjwrcLYag0lxoFxJ+8jGXl0+Rz811ar1aMk5ubcffGZYh5wZZvdyf + OJ4Cao1nKeEnL3lq5UZN61ILqnvOHX4o+9dS8DOslhmMHWo2p4yEfdltGultTqP+bpCp0+GV425frK2u + re9t4bu0mjuLa4jWWCeJg8csbjKujDIII/EHg8g1+gwnCrCNSnJThNKUZxd4yi9U0+tz85qQnSnKnUjK + FSEnGcJJqUZJ2aaet0yeqICgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACg + AoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAPff2Uv+To/2bP+y+/B3/1Ynh2v + jfEX/k33Hf8A2RvE/wD6pMcfb+Gf/JyPD7/st+FP/V9gD+2uv8oT/YEKACgAoAKACgAoAKACgAoA+eP2 + qvjtp/7OHwJ8efFW6+zTanpGm/YPCenXRJj1fxjrDfYPDti0Ssks1sl9Kt/qaQsJU0ex1G4UqISw+28O + +EK/HPF+T8O0/aRw+Jr+2zKvT+LDZXhl7bHVlJqUYVHRi6OHc04yxVahB357P4TxL40ocAcF51xNV9nP + EYXD+xyzD1Hpis2xT9jgKDimpTpqtJV8SoPmjhKOIqL4Gz+LXxBr+s+Ktd1nxP4i1G51fX/EOqX+t63q + t4/mXeparql1Le6hfXL4Aaa6uppZpCAF3OdqgYA/1RweDwuXYTC4DBUKeGweCw9HCYTD0lanQw+HpxpU + aUFraFOnCMY3bdlq29T/ACMx2OxeZ43F5jj69TFY7H4mvjMZia0uariMTiakq1etUl1nUqTlOT7t2RkV + 0nKFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAf0kf8ABNv9t6XxT4A0r4afFbV/tF54RNl4ZsPE99Pv + ubaxEIj8Pf27PIS76fdWsL6fHqtzLJcQX+m3ct9J9guI5NP/AM6vpB8CQ4R4xeaZfQ9lk3FMa2Y0Iwja + lhsyhUX9qYSCWkYOpVpY2lFWjCOMdGlFQoaf6Y/Rv8QanGfBKynMa/ts84TlQyzETnLmrYrK503/AGTj + Kjb5pzVOlWwNWb5pTnglXqyc8Rr+z4IYBlIYMAQQcgg8ggjggjkHvX4If0OLQAUAFABQAUAFABQAUAFA + BQB/nW/tt/8AJ5/7XX/Zz3x8/wDVreLK/wBCuCv+SN4S/wCyZyH/ANVeFP8ANnjr/kt+Mf8AsquIf/Vv + jD5hr6Y+VCgAoAKACgAoAKACgD074e/EK48KXC2F+0lxoFxJmWMZeTT5HPzXVqvUoSd1xbj/AFnMsYEw + Il93J84ngJqjWcp4ScveWrlRk3rUguqe84dfij711Lwc6yWGYwdajywxkI+7LaNaK2p1H3/km/h+GXu/ + D9Z211b3tvDd2k0dxbXEaywTxMHjljcZV0YZBBH4g8HkGv0CnUhVhGpTkpwmlKM4u6kns0/689T84qU5 + 0pzp1IyhUhJxnCStKMlumn/XUnqyAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoA + KACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAPff2Uv+To/2bP+y+/B3/1Y + nh2vjfEX/k33Hf8A2RvE/wD6pMcfb+Gf/JyPD7/st+FP/V9gD+2uv8oT/YEKACgAoAKACgAoAKACgAoA + /nG/4LNfG6bXviT4G+A2lXxbSPAekR+M/FVrE/7uXxd4miki0a3vI8k/aNG8Lhby0bC/ufFs4O7I2/3J + 9FvhOODyLN+McRRtic4xMsry6pJe9HLcBKMsVOlL+TFZhelUWvv5bDbW/wDAv0teMJY3iDJeCsNWvhck + wqzfMqcXpLNcxjKOEhVX/PzCZavbUnp7maTvfp+KFf1YfyCFABQAUAFABQAUAFABQAUAFABQAUAFABQA + UAFAHvf7N3jaTwb8UtEjlnMeleJ3HhvU4zvaNm1B1XS5iisEEkGrC0Xz3VvJtZrsAqsrmvyHxx4TjxX4 + eZzCnS9pmOS0/wC3staV6iq5fCc8XShb3pvE5dLF0Y0k7TryoytKUIo/Z/APjGfB/iVkdSrWdPLc9qLh + 7NIt2pulmU4U8HWm2+WCw2ZrB151WrwoRrx5oxqTZ/SZ+zj+0k2gGx8A/EG+L6ETHa+H/EV1IWbRCcJD + puqTOSW0fOEtLtznSsiGYnTdj6f/AJmn+qJ+kCsrqrowdXAZWUhlZWGQysMggg5BBIIORQAtABQAUAFA + BQAUAFABQAUAf51v7bf/ACef+11/2c98fP8A1a3iyv8AQrgr/kjeEv8Asmch/wDVXhT/ADZ46/5LfjH/ + ALKriH/1b4w+Ya+mPlQoAKACgAoAKACgAoAKAPTfh98QbjwpcCxvmkuNBuJMyxDLyWEjn5rq1XqUJ5uL + ccSDMkYEwIl9zKM4nl81Sqtzwk5e9HeVFvepT8us4fa+KNpX5vBzrJYZjB1qPLDGQj7sto1oranUff8A + km/h+GXu/D9aWt1b31vDd2k8dzbXEaywTxMHjljcZVlYcEHv3ByCAQRX6DCpCrCNSnJThOKlGUXdSi9U + 0/M/OKlOpSnOnVhKFSEnGcJJqUZLdNP+nuT1ZAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQA + UAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAe+/spf8nR/s2f8A + Zffg7/6sTw7XxviL/wAm+47/AOyN4n/9UmOPt/DP/k5Hh9/2W/Cn/q+wB/bXX+UJ/sCFABQAUAFABQAU + AFABQA13SNHkkdY441Z5JHYKiIoLM7sxCqqqCzMxAABJOKaTk1GKcpSaSSTbbbskktW29lu2JtRTlJqM + YpuUm7JJattvRJLVt7bs/h7/AGg/iVcfGH44fFT4mT3ElzF4w8ca/qumNKWLQ6D9ultvDlkC3zeXp2gW + +m2EQbkRWyAgEV/rRwXkUOGOEuHchhCMJZZlODw+IUdpYz2MamOqu2nNXxs69aVtOaoz/HPjriCfFXGP + EvEM6kqkc1znHYnDuTbccF7aVPL6Kvry0MDDD0Y315aaPHa+nPlAoAKACgAoAKACgAoAKACgAoAKACgA + oAKACgAoAfHJJFIksTvFLE6yRyxsySRyIwZHR1IZHRgGVlIZWAIIIzSlGM4yjOKlGScZRklKMoyVnGSd + 0002mndNPUqMpQlGcJSjOMlKMotxlGUXdSjJaqSeqad09Vqft14F8Qf8JV4M8K+IyV8zWtA0vULhUYOI + 7u4s4nvIdwwCYbrzom4BDIQQCCK/ya44yL/VnjDiTIlFwpZbnGOw+GTvd4L20qmBk76+/g50J63+Ld7v + /YjgLiD/AFq4L4X4hlNTq5pkuAxGKatZY5UI0swhpp+7xtPEQ2Xw7LY/QL9nL9pF/DLWXgPx9etJ4cYp + baFr9y5eTQGYhYrDUJWJZ9EJIS3nYltJ4RydNwbD5U+uP0nR0kRZI3WSORVdHRgyOjAMrqykhlYEFWBI + IIIJBoAdQAUAFABQAUAFABQAUAf51v7bf/J5/wC11/2c98fP/VreLK/0K4K/5I3hL/smch/9VeFP82eO + v+S34x/7KriH/wBW+MPmGvpj5UKACgAoAKACgAoAKACgAoA9M+H3xBufClyLG+MlzoNzJmaIZeSwkc/N + dWq5yVJ5uLccSjLoBMP3nuZPnE8vn7Kq5Twk5e9HeVKT3qU/LrOH2t173xeDnWTQzGm6tLlhjIL3ZPRV + or/l3Uff+Sb+F6P3Xp9aWt3bX1tDeWc8dza3MaywTxMHjljcZVlYfqDyDkMAwIr9Bp1IVYRqU5KcJpSj + OLupJ7NP+vPU/OKlOpSqTpVYyhUhJxnCStKMlumv6vutCxVkBQAUAFABQAUAFABQAUAFABQAUAFABQAU + AFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFAHvv7KX/ + ACdH+zZ/2X34O/8AqxPDtfG+Iv8Ayb7jv/sjeJ//AFSY4+38M/8Ak5Hh9/2W/Cn/AKvsAf211/lCf7Ah + QAUAFABQAUAFABQAUAfPf7WXi+TwH+zL8ePFVvcNa3um/CvxnHplyrbWg1jU9Eu9J0aZT/ej1W+s3UAg + kgAEE5r7Xw4yyOccfcH5dOHtKVfiLKpYiDV1PDUMXTxOKi/KWHo1U30Tu7nwvidmssl8PONcyhN062H4 + azeOHqJ2cMViMHVw2Ekn3WJrUmurei1Z/E3X+rZ/kCFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFAB + QAUAfqp+ydq39pfBzTrYFj/YOva9ozlv77Txa6AM8lVi12EBumcoD8hA/wA8vpMZZHA+JU8XGCis5yLK + 8wnJLSdWi8Tlcm3/ADKGXU79bOLe+v8ApR9FjNZZh4Wxwc5uTyTiDNsuhFu7hSrLC5vGyevI6mZ1Wntz + c6WqZ9KV/Ph/SB9n/s5/tISeEns/Avjy8ebwtIyW+i63OzSS+HHYhY7S7c5aTQySBG5y+lE8ZsPltAD9 + Lo5I5o45oZElilRZIpY3WSOSN1DJJG6kq6OpDK6kqykEEg5oAfQAUAFABQAUAFABQB/nW/tt/wDJ5/7X + X/Zz3x8/9Wt4sr/Qrgr/AJI3hL/smch/9VeFP82eOv8Akt+Mf+yq4h/9W+MPmGvpj5UKACgAoAKACgAo + AKACgAoAKAPS/h98QbnwpciyvTJc6DcyZmhGXksZHPzXdqD1He4txxKMumJR8/uZPnE8vn7Kq5Twk5e9 + HeVKT3qU/LrOH2t173xeDnWTQzGDq0uWGMhH3Z7KsltTqP8A9InvF6O8Xp9a2t3bX1tDeWc8dza3Eayw + TwsHjljbkMrDr6EdVIKsAwIr9Bp1IVYRqU5xnCaUozi7qSfVP+tdHqfnFSnUpTnTqwlCpCTjOEk1KMlu + mn/T3LFWQFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAF + ABQAUAFABQAUAFABQAUAFABQAUAFABQB77+yl/ydH+zZ/wBl9+Dv/qxPDtfG+Iv/ACb7jv8A7I3if/1S + Y4+38M/+TkeH3/Zb8Kf+r7AH9tdf5Qn+wIUAFABQAUAFABQAUAFAH5+/8FRdTk039iL4wLFI0UmpXHw/ + 0wMpwxjn+I/hOa5j91mtbeeGQd43cV+z/R9oKv4scMuUVKNCGdYhp7c0MizKMJesak4SX95I/DvpH4iW + H8HuKlGTjLETyPD3W/LPiDLJ1I+kqcJxfk2fyM1/pSf5cBQAUAFABQAUAFABQAUAFABQAUAFABQAUAFA + BQAUAFAH6N/sW3jP4M8X6eXJW18Tw3gj7K19pVrAzj3cacoP/XMV/En0sMPGOccHYrlXNWyzNcO5dZRw + 2KwtSMW+0Xi5Nf433P7w+h7iJSyTjbCOTcaGaZRiFC+kZYrCYynKVu8lg4pvryLsfZtfyUf2QFAH2P8A + s6ftHTeC5LTwR44u5J/CMrrBpOrzFpZvDMjthYJidzy6GzHlRl9MJLxBrXdFEAfprDNFcRRXEEsc8E8a + TQzQussU0Uqh45YpELJJHIjB0dGKupDKSCDQBJQAUAFABQAUAFAH+db+23/yef8Atdf9nPfHz/1a3iyv + 9CuCv+SN4S/7JnIf/VXhT/Nnjr/kt+Mf+yq4h/8AVvjD5hr6Y+VCgAoAKACgAoAKACgAoAKACgAoA9L+ + H/xAufCdyLO9MlzoNzJmeAEtJZSOcNd2gP5zwDAmA3LiUAt7eUZvPL5+zqc08JOXvx3dJvepT/8Ab4fa + 3Xvb+FnOTU8xh7Wly08ZCPuz2jVS2p1H/wCkT1cdneO31raXdtf20F5Zzx3NrcxrLBPEweOSNuQysPyI + OGVgVYBgQP0KnUhVhGrTmp05pSjOLupJ9U/z6p6PU/N6lOpRqTpVYyhUpycZwkrOMlun/ns902mWKsgK + ACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACg + AoAKACgAoAKACgAoAKAPff2Uv+To/wBmz/svvwd/9WJ4dr43xF/5N9x3/wBkbxP/AOqTHH2/hn/ycjw+ + /wCy34U/9X2AP7a6/wAoT/YEKACgAoAKACgAoAKACgD83/8Agq9BLN+xb48kjYhLXxN8Pp5wOjRN4u0y + 2Ct7edcwt/vKtfuf0c5xj4qZOpJN1MBnUIX6SWW4io2vPlhJejZ+AfSahKfhHnUot2p5jkc5+cXmmHpp + P/t+pF+qR/JvX+jp/mMFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAfoF+xNDIumfEO4LEwy3 + 3hyFF/hEkFvrDysD3LLcQhvQKvrz/GP0tJxeI4Ep2XPGjxHOT6uNSeSRin5J0529Wf3H9DqElhvEGo2+ + SdfhiEV05qdPP5Tfq1Uhf0R9zV/Hp/aoUAFAH2B+zr+0bP4GmtfBfjW5lufBs8gi07UpC80/heWVuFP3 + pJtEd2zNAu6SwJae2Vo/NgcA/TuCeC6ghubaaK5triKOe3uIJEmgnhlQSRTQyxs0csUqMrxyIzI6MGUk + EGgCWgAoAKACgAoA/wA639tv/k8/9rr/ALOe+Pn/AKtbxZX+hXBX/JG8Jf8AZM5D/wCqvCn+bPHX/Jb8 + Y/8AZVcQ/wDq3xh8w19MfKhQAUAFABQAUAFABQAUAFABQAUAFAHpXw/+IFz4TuRZ3hkudBuZMzwAlpLK + RiAbu0B/OeAELMo3LiUAt7eUZvPL5+zqc08JOXvx3dJvepT/APb4fa3Xvb+FnOTU8xg6tLlp4yEfcnsq + qW1Op/7bPVxejvHQ+trS7tr+2gvLOeO5tbmNZYJ4mDRyRsMhlI/Ig4ZWBVgGBA/QqdSFWEatOanTmlKM + 4u6kn1T/AD6p6PU/N6tOpRqTpVYShUhJxnCStKMl0f5p7NaptO5YqyAoAKACgAoAKACgAoAKACgAoAKA + CgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgD339lL/k + 6P8AZs/7L78Hf/VieHa+N8Rf+Tfcd/8AZG8T/wDqkxx9v4Z/8nI8Pv8Ast+FP/V9gD+2uv8AKE/2BCgA + oAKACgAoAKACgAoA+Hv+CkPh2bxN+xV8dLK3UtPY6N4d8RKQNxWHwx418NeIL1sen9n6ddqzfwqzN2r9 + a8C8bHAeKvCNWb92tisdgnfrLMMqx+CpL/wdXptd3ofjnj/gJ5j4Q8Z0aavOjhMBj1pdqGXZxl+OrP8A + 8EYeqm+ibZ/HxX+mx/lUFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAfpH+xhZtH4C8UX7BgL + vxa1spKkBlstI01yyk/eG69ZSRwGVhnOQP4X+lZjo1OKeGcuTvPCZDWxktb2WPzCtRin2f8Awnt97NPZ + q/8Af/0QsBOnwlxVmbXuYziKjgo+by7LaFaTXVr/AIUkr7XTS1TPsWv5XP65CgAoAKAPrj9nf9ou58AT + 23g/xjcTXXgm4m2WV6++a48LTTPkvGBukm0aSRi91aIGktGZruzUkz21yAfqDbXNve28F5Zzw3VpdQx3 + Ftc28qTQXEEyCSGeGaNmjliljZXjkRmV1YMpIOaAJ6ACgAoAKAP8639tv/k8/wDa6/7Oe+Pn/q1vFlf6 + FcFf8kbwl/2TOQ/+qvCn+bPHX/Jb8Y/9lVxD/wCrfGHzDX0x8qFABQAUAFABQAUAFABQAUAFABQAUAFA + HpPgD4gXXhO6FpdmS50G5kzcW4JaSzkY4N3aAnr3ngBCzqMjEoVj7eUZvPL5+zqc08JOXvx3dJvepT/9 + vh9rde9v4Wc5NTzKn7Wny08ZCPuT2VVL/l3Uf/pE94PvFtH1taXltf20F7ZTx3NrcxrLBPE26OSNuQwP + 5hlOGVgVYBgQP0KnUp1oRq0pqdOaUozi7qSfX/NPVO6etz83q06lGpOlVhKFSEnGcJK0oyXR/mns1qm0 + 7lmrICgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoA + KACgAoAKACgAoAKACgAoA99/ZS/5Oj/Zs/7L78Hf/VieHa+N8Rf+Tfcd/wDZG8T/APqkxx9v4Z/8nI8P + v+y34U/9X2AP7a6/yhP9gQoAKACgAoAKACgAoAKAPOfjB4J/4WV8J/ib8PMoreOfAHi/wlFJJgLFceIN + A1DS7efceFNvPdRzK/BR4w4IIzXucM5t/YPEeQZ3q1lGc5ZmUkr3lDBY2jiJwstWpwpyi11Umup4HFWT + /wCsHDHEWRaJ5zkea5XGT2jPHYGvhqc7vZwnUjNPo0n0P4Y7i3ntZ57W5ikgubaaW3uIJVKSwzwu0csU + qMAySRyKyOrAFWBBGRX+uUJwqQhUpyU4VIxnCcXeM4SSlGUWtGpJpprdO5/jTUhOlOdOpGUKlOcoVITT + UoTg3GUZJ6qUZJpp6pppkNUQFAHbeNPhr8RPhvdwWPxB8C+L/BF5dRJPaW/ivw7q2gSXcMiLKk1oNUtL + b7TEyOrCSAyJg/ezmvKyrPskz2nOtkub5Zm1KnJwqTy7HYbGxpzTcXGq8PVqezkmmnGdnfoexm/D2fcP + 1YUc9yXNcnq1YqdKGZ4DFYGVWEkpKdL6zSp+0i00+aHMvM4mvVPHCgAoAKACgAoAKACgAoAKACgCxaWl + 3f3VvZWNtcXt7dzR29raWkMlzdXNxM4SKC3t4VeWaaV2CRxRozu5CqpJAqKlSnRpzq1qkKVKnGU6lWpO + MKdOEU3Kc5yajGMUm5Sk0krtsulSqVqkKNGnOrVqzjTp0qUJVKlSc3aMIQinKc5SaUYxTk27JNnqXxO+ + BfxY+DNl4Mvvih4L1XwUPH2lXuteGrHXBBa6vPYWF0lpcvqGjGY6ros6STQuLTWLSxu3hnilWEqxI+ey + Di/hzimtmtLh/NcPmv8AY2IpYXH1cJz1MNCtWpyqU1RxXL9XxcHGM06uFq1qalCUXO6PpeIuDOJ+EqOU + VuI8oxOUf25hq2Ly+jjOSnip0KFRUqjr4TneJwc1KcGqWLpUarhOMlCzPJa+kPlwoA/XH9mvQZtA+Dvh + VLhVWfVkvNecL3h1a7lnsWZuCzvpv2Nmz90nYCQgJ/zX+kBnMc48UM9VOXNRymngcmpyvf3sHhoTxcfL + kx9fFU7X+zd2baX+o30c8knkvhPw+6seSvnFTH53Vja3uY3FThg5X3ftMvw+EqXf89ldJN+71+Ln7kFA + BQAUAFAH1h+zz+0TdfDu5t/Cfi2ee88D3U223uDvnufC88zktPbqN0k2kySMXvbFAzwsz3lkpl+0W14A + fqRaXdrqFrbX1jcwXlneQRXNpd20qT29zbzoJIZ4Jo2aOWKWNleORGKurBgSDmgCxQAUAFAH+db+23/y + ef8Atdf9nPfHz/1a3iyv9CuCv+SN4S/7JnIf/VXhT/Nnjr/kt+Mf+yq4h/8AVvjD5hr6Y+VCgAoAKACg + AoAKACgAoAKACgAoAKACgAoA9I8AeP7rwldC0uzJc6FcyZuLcHdJaSMQDd2gJ4YdZ4chZ1GeJQrV7WUZ + vUy+p7OpzTwk5e/Dd0296lPz/mjtNdpWZ4ec5NTzKn7SnywxlNe5N6KrFXfsqj7fyT1cH/dbR9b2d5a6 + hawXtlPHc2tzGssE8TbkkRuhB6gg5VlYBkYMjhWUgfodOpTrQjVpTU6c0pRnF3Uk+v8AmnqndPW5+b1a + VSjUnSqwlTqU5OM4SVnFrv8AmmrpppptO5ZqzMKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoA + KACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAPff2Uv+To/wBmz/svvwd/9WJ4dr43 + xF/5N9x3/wBkbxP/AOqTHH2/hn/ycjw+/wCy34U/9X2AP7a6/wAoT/YEKACgAoAKACgAoAKACgAoA/jf + /b7+Ec3wa/au+LPh9IDDo3iPXpviF4ZYJ5cD6J44kl1zyLVcD/RtI1afVdAQnq2kPy33j/qB4N8Sx4o8 + OeG8a58+KwODhkuPTd5rF5TGOE56j/nxOGhh8a7dMSttl/k/438LT4S8TeJ8CoOOEzDGzz3Lna0JYPOZ + SxnJTX/PvC4qeJwK88K9Xu/jev1A/JwoA/s1/ZR+K3hX9qj9mbwF4q1ux0fxJNc6Lb+GPiDoesWNpqtn + H4z8O28Fhr0N9p99HcwGPUJBDrtjFcLI50rV7CRyWkav8t/EbhzMfDzj3OMuwlbE4GFPFTzDJcXhqtXD + 1ZZVjpzrYOVGvSlCd6Cc8HWlBxX1nDVorRH+tPhnxNlviV4eZJmWMo4XMJ1MHTy7PcHi6NLE0o5vgKcK + GNjXoVo1IcuIko42jGopP6tiqEpNuTOO+If/AATg/Y5+IzT3F58HtK8KajNuK6j8Pr7UvBfkM/LNDo+j + XUPhljnBHn6FOFI+UAFg3p5J45eJ+RqEKXE+JzGhG16GdUaGa89tubFYqnPMP/AMZG99b6HlZ74A+FGf + udSrwrhssxE72r5HXxGUcje7hhMJUhl2+vv4OaXS2t/jLxn/AMETvhVftM/gD4z+PPC5fLRQ+K9D0Hxr + DGxyfLDaW/gibygflUu8sqr995myzfqWV/St4ioqKznhbJ8wtpKWXYvGZVKXm/rCzaPN1doxi3soo/JM + 2+iDw1Xc3kfF2d5de7jDM8Hgs3jFvXlvhnk8+VbJuUpJfE5vV/MviX/gin8cLNpD4R+LPwt1+NclP7eh + 8V+F7iVR2EVjo3iuFJCOitdbNxw0qj5q++wH0q+Eqqj/AGlw5xDg5P4vqcsuzCEX/irYrLpuK6tU+a2q + i3ofnmYfRD4xpOX9l8T8N46Ku19ejmeWzl5ctHCZnBSfnUtfeSWp4rrH/BJL9sjTGYWXh3wN4hC5w2j+ + O9KgV/8Ad/t9NDYZ7b1X3xX1WG+kl4X11erjs3wV+mJyfEza9fqbxa+5s+Qxf0XvFjDtqjgMmx/nhc6w + 0E/NfXlg396W5wd3/wAExP24rQtn4IyToCQJLX4g/Cy4D+6onjczgH/biU+1exT8fvCWpb/jLFBvpUyX + iKFvWTynl+6T9Txav0dPGOk3fg+U0vtUs94aqX81FZxz/fFMz1/4Jq/tuswUfAnU8noW8Y/DhR+LN4xC + j6kit347+E61/wBb6HyyvPW/uWVtswX0fPGF2/4wvEa982yBfe3m2nz3NS3/AOCX/wC3HcEZ+CYgU/x3 + HxG+FKAf7yL45ebv2iP58Vzz+kB4SQv/AMZW5tfZhkfEbb9G8oUPvkdMPo5eMk3/AMkhyLvPP+GVb1Sz + ly/8lZ1mn/8ABJv9s+9ZRc+DfCWkhurah4/8NSqn+9/ZV3qbHHfYr+2a82v9I7wtpXcM0zLE+VHJsfFv + 0+s08OtfNo9Oh9GLxbrNe0ynK8LfrXzzL5W9fq1XEP7kz0nRv+CM37UN+yNq3i/4M6FCceYJfEfizULx + c9dkNj4JktZCO+6/jHTBOSR4WK+lJ4f0U1hss4pxkujjgcuo036zrZsqi+VGXW59BhPol+I9dp4rNeEs + FDrzZhmdeqvSFHJ5U3brevHyb1PbvDP/AARE1yUxyeMv2gtJsQCDNaeGfAF5qpkH8SR6jqvifRvJPpI2 + lzj1i5yPk8f9LHCR5llfBeJrN35auPzmlh+Xs5UMPl+K5/NLEQ/xaa/Y5d9DzGScZZtx1hqKTTnSy7I6 + uJcl1Ua+JzHCcj7SeGn/AIT6l8Df8Ec/2X/Djw3Pi7WviV8Q50Kma01HX7Lw7oswXkqtr4Z0vT9aiD8h + 8eInbbjYyMCzfnub/Se8Qccpwy3C5DkkHfkq0MHWxuLhfq6mPxFfCya6XwSV909j9Iyb6KPhxgJQqZpj + OIc+mrc9LEY6jgMHO29qeXYahjI36/7fJ7Wad2/vn4Wfs3/Aj4KIv/CrfhV4N8H3axmE6zY6TFc+JJoS + pUxXPijUjfeIruLBb93dapMuWc4y7lvxviHjnjDitv8A1h4izTM6blzLC1sTKngYyTvzU8voeywNOX96 + nh4vRa6K37dw3wBwXwgl/q3w1lOVVVHkeLo4WNTMJwtblqZliPbY+rG1/dq4ma1b3bv/ADJf8FOPjzZ/ + G/8Aad1610C7S88I/CuxX4caJcwOsltqGoaXe3l14p1WF03JIk+v3V3ptvcxSSQ3mnaPp93Eds3P98+A + XB9XhPgDB1MbTlSzLiGs88xdOaaqUKOIpUqeX4eadnGUcHTp4ipTklOlXxNanPWB/nb9InjWlxj4i42n + gaqq5Xw1RWQYOpCSlTr18NWq1MyxMGrqSnjqtXD06kZShVoYWhVi7TPzwr9sPwg2/DehXnijxDonhzTw + PtuuapY6XbsyuyRSX1zHb+fMEBYQW4cz3D9I4Y5JGIVSR52cZphckyrMs4xsuTCZXgcXmGJldJ+xwlCd + eoo33nKMHGC3lNqKu2kenkuU4vPs4yvJMBHnxub5hhMuwsXezr43EU8PTcrbQjKopTltGClJtJNn7faV + ptro2l6bpFjGIrLSrC0060iUBVjtrK3jtoEAHACxRKMD0r/JDNsxxGcZpmWbYp3xWaY/GZjiGm2vb43E + VMTVs3q17SrK19bH+ymT5Zh8lynK8mwithcpy7BZbhk0k/q+Bw1PC0bpaJ+zpRvbqX6889EKACgAoAKA + CgD6p/Z7/aHvPhvdQ+F/FM0994FvJ8Rv889z4YuJ3y93ZoN0kumSOxkv9PQFkYve2KfaDcW98AfqbZX1 + nqVna6hp91Be2N7BFdWl5aypPbXNvMgkingmjLJJFIjBkdWIYEEGgC1QAUAf51v7bf8Ayef+11/2c98f + P/VreLK/0K4K/wCSN4S/7JnIf/VXhT/Nnjr/AJLfjH/squIf/VvjD5hr6Y+VCgAoAKACgAoAKACgAoAK + ACgAoAKACgAoAKAPSPAHj+68JXQtboyXOhXMmbm2B3SWkjYBvLQE8OOPOhyFnUdpQjj2sozepl8/Z1Oa + phJu84bypt/8vKd+v80dprtKzPDznJqeZU/aU+WnjKcf3c9lUS19lVfb+Werg+8W0fW9ne2uo2sF9ZTx + 3NpcxrLBPE25JEbuD1BByrqwDo4ZHVXVgP0OnUp1oRq0pqdOaUozi7qSfX/NPVO6etz83q0qlGpOlVhK + nUpycZwkrOLXf801dNNNNp3LNWZhQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAU + AFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFAHvv7KX/J0f7Nn/AGX34O/+rE8O18b4i/8AJvuO/wDs + jeJ//VJjj7fwz/5OR4ff9lvwp/6vsAf211/lCf7AhQAUAFABQAUAFABQAUAFAH4r/wDBZD4AS+Kvh14S + /aA0K1aXVPhrOvhbxj5Ue55fBfiK/U6TqErAF/L0DxPcC2WNcDZ4purmQhLUmv6q+i/xnHLs8zLgzGVF + HD59B5hlnM7KOa4Ki/rNGKulzYzL4c7k7vmy+nCOtTX+RPpYcDyzPIcr44wVNyxPD0/7NzblV5SyjH11 + 9Vryer5cDmM/ZqK+zmVWpJ2pn839f3MfwEFAH6N/8E4f2wB+zL8VpPDvjG+eP4QfEy4sdN8VPLIzQeFN + ajYwaN41jjOQlvaec9h4jEQV5tGmF6wurjRbC1f8O8cvDJ8fcOrG5XSUuJshhWr5copKeY4WSU8VlUpd + Z1eVVsC5XUcVD2SdOGLrVF+++APir/xDviV4DNqzjwrxDUo4fM3KTcMsxkW4YTOIx1tClzuhj1GznhJ+ + 2ftamDoU5f1j29xBdwQXVrPDc2tzDHcW1zbypNBcQTIJIZ4Jo2aOWGWNlkjlRmSRGDKxUgn/ADinCdOc + 6dSEqdSnKUKkJxcZwnFuMoTjJKUZRkmpRkk0001c/wBOYVIVYQq05xqU6kY1KdSElOFSE0pRnCcW4yjK + LUoyi2pJpptMmqSgoA4f4k/EjwV8IvBOv/ET4h67beHPCPhq0W81bVblJphGsk0dtbW9va20c13e317d + zwWdjY2kE11eXc8UEETySAV6+RZFmvEubYPJMkwdTHZnj6jp4bD03GPM4xlUqTnUqShTpUqVOE6tatVn + GnTpwlOckk2eNxBxBlHC2T47Ps+xtPL8ry+kquKxNRTlyqU406cKdOnGdWtWrVZwpUaNKE6tWrOMIRcp + JH5r+E/+CxH7MHiPxjB4c1TQ/iX4O0S9u47O18aeING0OTRrdnZl+1a1Z6L4h1XVtOsGcIEuLaz1N41k + Et7DZQpNJH+7Zl9GPxAwOWTx2HxeQ5ni6VN1amVYLF4uOKqWSfs8LVxWCw2Gr1krtwqVaCbi40p1ZOMZ + fz7ln0rPDnH5rDAYnB8Q5Vg61WNKnm+OwmDlhKbba9pi6WDx+KxWHot2SqU6WJaTUq0KMVNx/Vq3ube8 + t4Lu0nhurW6hiuba6t5Unt7m3nRZYZ4JomaOaGaNlkiljZkkRldGKkE/zrUhOlOdOrCdOpTnKFSnUi4T + hODcZwnGSUozjJOMoySaaaauf0xTqU6tOFWlOFWlVhGpTqU5KdOpTmlKE4Ti3GcJxalGUW1JNNNpn5// + ALS3/BSX4B/s1eL5vh7q1v4p8d+ObBIJNc0XwXa6ZJa+GzcwwXUFtrmravqem2seo3FncJcx6fpyancQ + oyDURp5lh8z9m4D8CuMuPMsjneGnl+T5RWc44TF5rUxEamP9nKdOdTCYbDYevUlQhVg6cq9d0ISafsPb + 8s+X8P8AEL6QPBHh7mk8ixUMyzrOaKhLG4PKKWHlTy/2kYVIU8ZisViMPTjXnSmqkaFBYipBNfWPYc0O + b239mf8Aa0+EH7VvhzUtc+GOo6nDqGgS20PiXwl4ks4dN8T+H2vfP+wTXlta3eo2FzY6gLW4az1DTNRv + 7RzDLbzSQXsM9rF8nx74b8TeHWOoYTP6NCdHGxqTwGZYGrOvl+NVLk9tGlUqUqNanWoupBVaOIoUaq5o + zjGdKcKkvsPDzxP4V8TMBiMbw7XxEK+ClThmGV5hShh8xwLq8/sZ1adOrXoVKNdU5ulXw1etSk4yhOUK + 0J04/TNfBH6GFABQB+Zn/BSf9sq1/Z1+Gk/w+8FarGPjN8SNMubPShbTf6X4L8LXQms9S8ZT+W3mWt/L + ifTvCu9omfVBcapEZotDuLeb978CfC6pxvn0M6zXDy/1WyLEQq4l1I/u81zCm41aGVw5ly1KMbwr5jbm + th3DDy5ZYyFSH88fSB8WaXAXD08iyjExXFvEGGqUsL7Of73KMtqc1LEZtU5XzU60rTw+WXcXLE+0xMXO + OCqU5/ylkkkkkkk5JPJJPUk9ya/0VP8AM4SgD7O/Y8+Hr6t4k1T4i30bLp/hVH0rRmYOq3XiHVrSSO7e + MkGKePSdFmlF3EfnhuNb0i4TBUGv5n+kzxnHJ+FMNwphaiWP4nqqeKUX79HJ8BWp1qrdnzQeMxkcPQhf + 3atCnjYO9mf1R9FbgeWdcX4rjDF0m8v4VoyhhHJe5WzvMaNSjSS5k4zWCwUsTiJ296lXq4GppdM/Rqv4 + HP8ARAKACgAoAKACgAoAKAPqL9n39oS++GV5F4b8SS3F/wCBL2c5UB57nw3cTPl7+wQZeSxkdjJqGnJk + klryzX7V58N8Afqlp+oWOq2NpqWm3dvfaffW8V1Z3lrKk1vc28yB4poZUJV43UhlYE9fXNAFygD/ADrf + 22/+Tz/2uv8As574+f8Aq1vFlf6FcFf8kbwl/wBkzkP/AKq8Kf5s8df8lvxj/wBlVxD/AOrfGHzDX0x8 + qFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFAHo/gDx/deEroWt0ZLnQrmQG5tgdz2rtgG8swTgOBjz + ochLhBg7ZFR19rKM3qZfU5KjlUwk379Pd0296lO70f8ANHaa3tK0l4ec5NTzKn7Sny08ZTj+7nsqiWvs + qr7fyz1cH3i2j64s7211G1gvrKeO5tLmNZYJ4m3JIjdweoIOVdWAdHDI6q6sB+h06tOtTjVpTjUpzXNG + cXdST/qzT1TunZpn5vVpVKFSdKtCVOpTk4zhJWaa/NPdNXUk002mmWaszCgAoAKACgAoAKACgAoAKACg + AoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoA99/ZS/5Oj/AGbP + +y+/B3/1Ynh2vjfEX/k33Hf/AGRvE/8A6pMcfb+Gf/JyPD7/ALLfhT/1fYA/trr/AChP9gQoAKACgAoA + KACgAoAKAKOp6np2i6df6xrF/Z6XpOlWdzqOp6nqFzDZ2Gn2FlC9xeXt7d3DxwW1ra28ck1xcTSJFFEj + ySMqqTW1ChXxVejhcNRq4jE4irToYehRhKrWr1qs1ClSpU4KU6lSpOShCEU5Sk0km2Y4jEUMJh6+LxVe + lhsLhqVTEYjEV6kaVChQowdSrWrVajjCnSpwjKdSpOSjCKcpNJNn8tf/AAUM/b71H9pDXLn4Y/DO9vNN + +Bvh/UAWmXzrS8+JWrWMxMWu6rCwjmh8OWkyCbw5odwqu7rHrurwrqJ0+x0P/QfwU8G6HA2Ep8QZ9SpV + +LsbRdovlqU8hw1aPvYTDyTlGeOqwfLjsXBtRTlg8NJ0Pb1sX/m747eN+I4/xtThzh6tVw/BuBr6zXNS + q8Q4qjP3MbiYvlnDAUprny/B1EnJqONxUFiPYUcH+XNf0GfzeFABQB+3X/BN3/gopb+AYdG/Z9+POtLB + 4JUx6f8ADn4ganM2zwgZH22/hXxNdSE7PCrOwj0XV5mCeGSVsL518Om3n0D+TvHTwRnnMsVxpwdhHPNn + zV88yWhFXzOyvPMcvpxWuY2Tli8NHXH61qKeO54Y3+w/o/8AjzTySOE4G42xihk6caGQZ5iZvlyq7tDL + MxqybtljbUcHipvly6/sK0lgPZzwP9Fcckc0aTRSJLFKiyRSxsrxyRuoZJEdSVdHUhlZSVZSCCQc1/EM + oyjKUZJxlFuMoyTUoyTs1JPVNO6aeqe5/ekZRnGM4yUoySlGUWpRlGSupRaummndNNpp3Q+kM/LT/grz + 4L8ZeLf2VLa+8K215f6f4K+I2g+LfGVnZRmSRfDMGieJdHfVJkQ+dLaaVqms6bcXkaJJHBbPJqlz5cGm + vNH/AEJ9GnNcry3xFnSzGpSo1s1yPGZbldWq7ReYTxeAxSw8ZS92NXE4fC4iFKTalOpbDw5p4hRl/N30 + psozbNPDSFbLadWvQyjP8FmmbUqKcpLLoYPMMJLEyjH350sNicXh6lWKUo06blianLDDynH+Wi3t57ue + C1tYJrm6uZo7e2treN5p7ieZxHDBBDGGklmlkZY440VnkdgqgsQD/oVOcKcJ1Kk406dOMp1Kk5KMIQin + KU5yk1GMYxTlKUmkkm27H+bcITqzhTpwnUqVJxhTpwi5zqTm1GMIRinKU5SajGMU3JtJJtn9s37LPhPx + V4E/Zx+CXg7xus0Pivw78NvCul61Z3JU3GmXVvpcAXRpyjOjTaJAYtJlZHdC9kxVmUgn/KPxDzLLs445 + 4szPKXCWXY7PcxxGEq07qGIpzxE74qCaTUMXPmxMbpO1VXSd0f6/+G2WZnkvAHB+VZypxzPAcP5ZhsZS + qNOphqlPDQSwk2nJOeDhy4WTUmnKi7NrU/kj/a+8F+MvAn7TPxt0fxzbXkWt3vxH8XeI4by7QqNb0fxL + rt/rei69aPlkls9W069guozGzfZ3aWymEVzazwxf6SeGea5Xm/AXCeJyipSlhaWRZbgZUqTv9UxWAwdH + CYrB1FpKNXDV6U6cuZLnSjVjzQqQnL/L3xUyjNsl8Q+MMJnNOrDF1s/zTMIVasbLGYTMcbXxmExtJ3cZ + UsVh60KkeVv2cnKjPlqU5wj+g3/BF7wX4xu/jl8QfiBZ215B4G0b4b33hbWtSKEWF94g1zXvDepaPosb + OQs15Fa6Pf6rM8IkexhggjuPJXVbfz/xf6U+a5XT4SyXJqtSlPN8VntHMMJQ5k69HBYTB46hisXJK7jS + lUxNHDxU+VVpznKHM8NPk/c/okZRm1XjLPc8pU60MlwmQVstxmIcX7CtjsZjcvxGFwcW7KdaNLC18TNw + 5pUYQhGpyLFQ5/6Uq/hE/wBBQoA+I/2zf22vAH7JvhGVJJrLxN8WdbsZH8GeAI7jMpMheGLxD4nMD+dp + Xhm1mV23M0V5rc8EmnaTgpfX+m/rHhb4UZz4j5nFxjVwHDmErRWa5y4e6rWnLBZfzrlxGPqRa0SlSwkJ + xr4nSVGlX/HvFrxgyPwwyuSlKjmPE+MoyeUZHGp7z5rwjjsxcHz4bLqU03duNbGThKhhdVWr4f8Akr+J + PxH8ZfFzxv4i+Inj/WrjX/Fnii/fUNV1G4woLFVit7S0gTENlp1haxw2Wm2FukdtY2UEFrbxpFEqj/SL + IsjyvhrKcFkmTYSGCy3L6Ko4ehC70u5Tq1Zu86tetUlOtXrVHKpWrTnUnJyk2f5g8QZ/m3FGcY/Ps8xl + THZnmVeVfE4iportKMKVKC9yjh6FNRo4ehTUadGjCFOEVGKRw9eseMFAHs3wb+Muu/CfW1kie41DwtfT + qdd0AynypQwSNtRsFkbyrfVoI0TbL8i3kUSWl0/liKW3/LPFLwuynxIyd0qipYLiDBU5vJ845PfpS96f + 1LGOC9pWy6vNvnh708PUk8Th4uftKdb9b8JfFnOPC/OlWputjuHMdVgs7yT2nuVo6Q+vYJTap0Mzw8Ev + Z1Pdhiacfq2IkoOnVofrN4b8R6N4t0Ww8Q+H76LUdK1KET21zEfqskM0Zw8FzBIGhubeULLBMjxyKrqR + X+bOe5FmvDWbY3JM6wlTBZjgKrpYihUX/b0KtKavGtQrQcatCvTcqdalONSEnGSZ/qJw/wAQZRxTk+Bz + 7IsbSx+WZhRVbD4im3ftOlWpu06OIoTUqWIoVVGrRqxnTqRjKLRuV5B7IUAFABQAUAFABQAUAfTfwA/a + C1D4X30egeIJLjUfAl9cZlhG6a58PTzN+81HTEyWe1dj5moacnEvzXVqou/MS7AP1X03U9P1nT7PVdKv + LfUNN1C3jurK9tZVmt7m3mXdHLFIhIZWB+oOVYBgQAD/ADu/22/+Tz/2uv8As574+f8Aq1vFlf6FcFf8 + kbwl/wBkzkP/AKq8Kf5s8df8lvxj/wBlVxD/AOrfGHzDX0x8qFABQAUAFABQAUAFABQAUAFABQAUAFAB + QAUAFABQB6N4B8fXfhG6+zXJkutDupAbq1B3Pau2AbyzBIAkAx50WQlwgwcSLHIvtZRm9TLqnJPmnhak + v3lPdwb3qU7v4v5o7TSs7SSkvDznJqeZU/aU+WnjKa9yo9qiX/Luq1rb+Werg+8W0fXFle2mo2kF9Yzx + 3NpcxiWCeJtySI3f1DA5V0YB0cMjqrKQP0OlVp1qcKtKaqU6i5oTi7qSf69GnqndNJpn5vVpVKFSdKtC + VOpTk4zhJWaa/NPdNXUk002mmWqszCgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACg + AoAKACgAoAKACgAoAKACgAoAKACgAoAKACgD339lL/k6P9mz/svvwd/9WJ4dr43xF/5N9x3/ANkbxP8A + +qTHH2/hn/ycjw+/7LfhT/1fYA/trr/KE/2BCgAoAKACgAoAKACgCG5ubezt7i8vLiG0tLSGW5urq5lS + C3treBGlnuLieVlihhhiVpJZZGVI0VndgoJq6dOpVqQpUoTqVak406dOnFzqVKk2owhCEU5TnOTUYxim + 5NpJNsipUp0qc6tWcKVKlCVSpVqSUKdOnBOU5znJqMIQinKUpNKKTbaSufzH/wDBRn/goLc/HPUdQ+C/ + we1Wa2+DekXvleIfEFo8kE3xO1SymDKVYFXXwXYXMYl021bA1u6jj1e8VoYtMht/758D/BeHCNCjxVxP + h41OKMTS5sFgqiU45Bh6sdU07p5rWhJxxFRX+qU5PDUmpyxE5/52+PnjnU4zxFfhHhXEzp8J4Wty47HU + nKEuIsTRndNNWksoo1IqWHpu31yrGOKqpwjh4U/yNr+lD+XAoAKACgAoA/Ub9i//AIKYePf2d49L+H3x + Mi1L4jfBy2EdpY26zRy+MPA1sDhF8M3l7LFFqmjQr8i+GdUuoYLdFiGj6jpUMUtpefz74p+AuT8byxGd + ZDKhkfFE+apWm4Sjlmb1Hq3j6VKMpYfFTerzDD05zqNyeKoYmco1Kf8ASHhH9IbO+A44bIuIYYjP+E6f + LTowUoyzbJqa0Sy6rVlGOJwkFosuxNSEKaUfqmIw0YypVf6SPg98dPhT8e/C8Xi74UeM9J8WaURGt7Da + SmHWNFuZF3ix1/RLpYdU0a9AyVhv7WHz0AuLVp7Z453/AIV4n4R4j4OzCWW8R5XictxF5eynUjz4bFwi + 7e2weLpuWHxVLa86NSfI3yVFCopRX+gPCnGfDPG2XRzThnN8LmmGaiq0aU+TFYSpJX9jjsHUUMThK29o + V6cOeP7ym505RnL1eSOOWN4pUSWKVGjkjkUPHJG4KujowKujqSrKwIYEggg184pSjJSi3GUWpRkm1JST + ummtU09U1qnqfTSjGUZRklKMk4yjJJxlFqzUk7ppptNPRrc8V8N/s1fs9+DvFQ8b+FPgn8LvDvi2OY3F + tr+j+CPD1hqNhcsHWS50ya3sE/sq5lWWRZ7jTltZp1kcTSOGbP1eP4741zTL/wCycx4r4gx2WuKhPB4r + NsbWoVoJpqGIhOs/rEIuMXCFd1IwaTik0j5DL/D7gXKsyWcZZwhw3gM0jJ1KeOwmT4GhiKNRpqVTDzp0 + I/Vqk1KSnUoKnOalJTk7u/ttfJn2B5j8Rvgt8I/i9FZRfFD4beCvHv8AZm8aZP4o8O6Zq95pqyukk0en + 313byXtjFcPGhuYrW4iiudiidJAoFe/kfFXEvDUq0uH89zXJ/rFvrEMvx2Iw1Ku4pqEq9GnNUq0oKUlT + lUhKVO75Grs+dz/hHhfimNGPEfD+UZ39Xv8AV55lgMPiquHUmpTjQrVacqtGM2k6kKc4xqWXOpWR1nhX + wh4U8C6HZ+GfBPhnQPCPhzT/ADPsOheGdIsND0i0MzmWZrfTtNgtrSJ5pWaWeRIg80rNLKzyMzHzsxzP + Mc3xdXH5rj8ZmeOr29tjMfia2LxNTlXLFTr151KklGKUYJytGKUYpJJHp5ZlWWZLg6WXZRl+CyvAUOb2 + OCy7C0MHhaXPJym4YfDwp0oucm5zko3nJuUm5Nt6Gr6zpHh/TL7W9e1XTtE0bTLeS71LVtXvrbTdM0+1 + iG6W5vb+8lhtbW3jHMk08scaDlmFYYbDYnG4ilhcHh6+LxWImqdDDYalUr4itUk/dp0qNKM6lScntGEZ + Sb2RvisXhcDh62MxuJoYPCYenKriMViq1PD4ehSjrKpWrVZQp04R+1OclFdWfi9+1n/wVy8I+FrXU/BP + 7Maw+MfFTedZ3HxN1OyY+DtDb5opJvDWnXax3HirUYXDm3vby3t/DcbrBdRf8JHaSPAP6n8N/o2ZlmFT + D5tx855Zly5asMgoVV/amLXxRjj69Nyhl1CStz0qU54+Sc6cvqNWKmfyP4n/AEo8ry2nicn8O1DNsyfN + SqcRYii/7Jwb1jKWX4eqo1MzxEHfkrVoQy+MlCrD+0KUpQP57vF/jDxR4+8S6x4w8aa9qnifxRr9299r + Guazdy3uoX1y4VQ0s0pJWOKJI4La3jCW9pbRQ2ttFDbwxRJ/amW5Zl+TYHDZZlWDw+Ay/B01Sw2EwtON + KjSgru0YxWspSbnUnK86lSUqlSUpylJ/wvmua5lnmYYrNc3x2JzHMsdVdbFYzF1ZVq9ao7K8pybtGMUo + U6cbU6VOMKdOMKcIxXN13HnhQAUAFAHufwR+NWq/CfWvLm8/UPCGqTp/bekK2XibAjGraYHYJFqECBRJ + GSkWoQILa4ZHS1ubX8h8W/CnLvEjKeel7HBcTZfSn/ZOZyjaNWPvTeW5hKKc54KtNtwnadTBVpOvRjKM + 8RQxH7R4OeL+Z+GGcezre2x3CuZVof2xlUZc0qUmo0/7Uy5TahTx9CCiqlO8KePoQWHryhOGGxGG/WHR + Nb0rxHpVjrmiX0Go6VqUCXNneW7bo5YnyOQcPHLG4aOaGRUmgmSSGZElR1H+b2bZTmORZljMozbCVsDm + OArSoYrC148tSnUjrum4zpzi41KVWnKVKtSnCrSnOnOMn/p9k+cZZxBlmCznJsbRzDLMwoRxGExeHlzU + 6tOV1s0pU6lOalTrUakYVqFaE6NaEKsJwWpXnHpBQAUAFABQAUAFABQB9KfAL4/6l8LNQTRNbe41LwJf + 3G66swTLc6HPK3z6npSk5MZJ33+nqQlyN08IW7B88A/kM/bJ1Gx1j9r79qzVdMuor3TtS/aT+Ol9Y3kD + bobq0uvij4pnt5424JSWJ1dcgHBwQDkV/oVwU0+DeE7O/wDxjWRLTXVZXhU16p3T8z/NrjtNcb8Y3TX/ + ABlXED17PNsW0/mndd07nzdX0x8oFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAei+AvH134R + uxb3BkutDuZAbq1B3PbO2AbyzDEBZQP9bFkJcIMNtkWORPayjN6mXVOSfNPC1JfvKe7g3vUp3fxfzR2m + lZ2klJeJnOT08yp88OWni6cf3dR6Kolr7KrbeLfwy3g3dXi5Rf1zZX1pqVpBfWM8d1aXMYlgnibcjo36 + hlOVdGAdHDI6q6kD9DpVadanCrSmqlOouaE4u6kn+vRp6p3TSaZ+bVaVShUnSrQlTqU5OM4SVmmvzT3T + V1JNNNpplqrMwoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKA + CgAoAKACgAoAKACgD339lL/k6P8AZs/7L78Hf/VieHa+N8Rf+Tfcd/8AZG8T/wDqkxx9v4Z/8nI8Pv8A + st+FP/V9gD+2uv8AKE/2BCgAoAKACgAoAKACgD+cH/gph+3/AHXj7U9f/Z1+DWsGHwDpV1LpfxG8X6Zc + /N451K2fZeeGdJuoW48I6dcq9vqlzG+PE17DJBGx0CDfrn9zeAvgzTyfD4PjfinDc+c4mnHEZHlmIhpl + NCor0sfiac1/yM68Gp4eEl/sFKUZyX12dsJ/AX0hvHCrneJx3AXCeKcMkw1WWGz/ADXD1Nc5xFN2q5dh + qkH/AMiuhUThiakZf8KNaMoRf1GHNjfxVr+qj+RAoAKACgAoAKACgDqvBnjnxn8OtftPFPgPxTr/AIP8 + R2Bza614c1W80jUI1LKzwm5spoXltptircWkxktrmPMVxFLGSp87NMoyvPMHVy/OMvweZ4Gsv3mFx2Hp + YmjJ2aU1CrGSjUjduFSNqlOXvQlGSTPTynOc2yHHUszyXMsblWYUX+6xmAxNXC14ptOUHUpSi5U52SqU + p81OpH3ZxlFtP9UPhD/wWN+P3g1LbT/in4Y8K/F7TIVVH1Ef8UN4uk2jaGl1PR7K98OzBVAYg+Eo55nB + Ml5lyw/nnib6MHBuaOpX4ezDMeGa8m2qD/4V8tjd3tHD4qrSx0bu6v8A2lKEVblpaWf9J8LfSv43ylU6 + HEuXZbxTh4JJ11/wjZpLpeWJwlGtgJ2WrTyuM5u/NVu7n3l4Q/4LN/s4avAo8XeCfin4Pv8ACmRYNN0D + xLpQJ4ZYr+012w1CQqck+ZokAK4IJY7B+PZn9FvjnDTf9m5rw9mdHWzniMZgMR6yo1cHWoxT/u4ubvdN + W1f7Xlf0teAMVBf2pk/EuVV9OZQw+BzDDeajXpY2jXk1/ewcFbW7ei9RH/BWf9jM24nPizxiJT1tD4C1 + /wC0DjPLCE2ntxdHn25r5/8A4lw8UvaOH9m5W4/8/f7ZwXI/k5e189aa9T6T/iZ7wl9nz/2pm3M/+XX9 + iY72i9Xyey+6qzgvEv8AwWR/Zc0m3Y6B4e+LHiu8O7yorbw5oekWe4dDc3er+Jre4iRugaDT7twfvRgc + 17GA+i/4hYmaWMxvDmXUtOaVTHYvE1bPfkp4bAVISa6qdamn0kzxMw+lh4b4WDeCwPE+Z1XfljTy/B4W + lfp7Srisxpzin3hRqvvE+O/id/wWr+IWqRS2fwi+EfhrwgHVoxrfjXV73xhqGGzie10rTIfDWn2VwmRt + W7uNbt9wJeNwdo/T8g+irkuHlGrxLxLj8zaak8JlWGpZZRut4VMRiJY+vWg+rpwwk+ia3f5RxF9LzPcT + GdLhfhfL8qTTisZm+KrZrXs9qlPDYeOX0KNRdFVqY2F9XFp2Py0+Mn7Sfxx+P+ofb/iz8RvEPiqJJjPZ + 6JJcJp3hfTZOQr6b4X0qOy0GymVCI2u4tPF7Oiqbm5ncFz/QnC/AvCXBlD2PDmR4LLpOPLVxcYOvmFdb + tYjMMRKrjKsW/eVOVZ0oNv2cIJ2P5u4s8QeMuOK/t+J8/wAfmcVPnpYOVRUMtw8tUnh8tw0aOCozSfK6 + sKCrTSXtKk3qeHV9afGhQAUAFABQAUAFAH0J8CPjjqHws1YabqbT33gnVLhTqdiuZZdLnfah1fTEJ4lR + QovbVcLfQIBj7TFA6/ifjF4RYLxEy147L40cHxZl9FrAYyVoU8woxvL+zMwmlrTk3J4XESvLCVpN3dCp + WhL938FPGfHeGmZ/2fmMq+N4PzKunmGCi3Uq5bXnywea5dBvSrGKSxeGjaOMoxW1enRmv1W0zU9P1nT7 + PVdKvINQ03ULeO6sr21kEsFxbyqGjkjdeoIPIOGVgVcKykD/ADnx+AxuV43FZdmOGrYLHYKvUw+LwuIg + 6dahWpycZ05xeqaezV1JNSi3Fpv/AE0y7McDm+BwmZ5Zi6GOy/HUKeJwmLw1RVKOIoVY80KlOa3TT1Tt + KMrxklJNK9XGdoUAFABQAUAFABQAUAfyxfHb/kuvxy/7LT8Wf/Vg+I6/0G4F/wCSL4U/7J7J39+AoM/z + e8QP+S64w/7KXOv/AFYYg8sr6o+QCgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgD0XwD4+u + /CN39nuDJc6HdSA3VqDue3dsA3loCQBKBjzYshLhBhsSLHIns5Tm1TLqnJPmqYWpL95Tvdwb09rTu9JL + 7UdqiVnZqMo+JnGT08yp88OWni6cf3dV7TSu/ZVbauDd+WWsqcndXTlGX1zY31pqVpBf2NxHdWl1GJYJ + 4jlHRvyKspyrowV43DI6q6sB+h0qtOvThVpTVSnUXNCcXdNP8U07pp2aaaaTTR+bVqVWhVnRrQlTq05O + M4S3T/JprVSTakmpJtNMtVoZhQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFA + BQAUAFABQAUAFABQAUAFABQAUAe+/spf8nR/s2f9l9+Dv/qxPDtfG+Iv/JvuO/8AsjeJ/wD1SY4+38M/ + +TkeH3/Zb8Kf+r7AH9tdf5Qn+wIUAFABQAUAFABQB8Wf8FBvjNqPwP8A2VfiR4n0G8aw8U6/BY+BPDF2 + jMk1rqXi24Gn3t9ayoQ0N9pnh4a3qunzLkx39jbOQQDX6p4L8LUOLfETIsvxlNVsvwc6ucZhTaTjUoZb + D21KjUi7qdHEY14TD14v4qNaotz8i8c+LcRwd4acQZjgqroZljYUcly6qm1OniM0qewrVqUlrCthsB9c + xVCa+GtRpvuz+Oqv9PD/ACkCgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgD6j/Zv + +Nt14C1u28Ja/dPL4M1y7WFDK2R4e1S7kVEv4WY/u9PuJWC6pBkRpv8A7RjxLHcJd/zz47eE2H4xynEc + S5Nh4w4qyjDSqzVONnneX4aEpTwdVR+PG0KacsvrWlUny/UZ3p1KE8N/Sf0ffGLE8E5zh+Fs8xM6nCOc + 4qNGDqyushzHE1FCnjqMpO1PAYirJRzKjdQhzfX4WqU68MV+otf56n+koUAFABQAUAFABQAUAfyx/Hf/ + AJLr8cf+y0fFj/1YHiKv9BuBv+SL4U/7J3J//UCgf5veIH/JdcYf9lLnX/qwxB5XX1R8gFABQAUAFABQ + AUAFABQAUAFABQAUAFABQAUAFABQAUAFABQB6J4C8e3fhG78ifzLrQ7qQG7tAdz27tgG8swxAWZQB5sW + QlyihWKyLHIns5Tm1TLqnJPmqYWpL95Tvdwb09rTu9JL7UdqiVnZqMo+JnGT08yp88OWni6cf3dV7TSu + /ZVbauDd+WWsqcndXTlGX1zY31pqdpBf2FxHdWlzGJYZ4m3I6n8irKcq6MA8bhkdVdWA/Q6VWnXpwq0p + qpTqLmhOLumn+Kad007NNNNJpo/Nq1KrQqzo1oSp1acnGcJbp/k01qpJtSTUk2mmW60MwoAKACgAoAKA + CgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoA99/ZS/5Oj/Zs + /wCy+/B3/wBWJ4dr43xF/wCTfcd/9kbxP/6pMcfb+Gf/ACcjw+/7LfhT/wBX2AP7a6/yhP8AYEKACgAo + AKACgAoA/Kz/AILD6Pf6n+yTZ3tmJTb+Hfi14N1jVTGhZFsJ9K8VeH42nYZ8uL+1Nd01Q5wDO0MecyAH + +iPox4qjh/EmrSquPPjuG80wuH5nZutDE5fjZKH80vq+Drtpa8ik+jP5q+lZhK+I8L6VakpOGA4oynF4 + nlV0qE8NmWBi5vpH6zjcOk/53BdT+Wqv9CD/ADcCgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAK + ACgAoAKACgAoA/Z74O65c+I/hd4H1e8kM13ceH7OC6mZy7z3GnhtOmuJHPLS3Elo00pP/LR2Ff5XeKeT + UeH/ABD4uyvDRjTw1HOK+Iw9KMeWFGhmEYZjRoQj0hQp4uNKH92CP9c/CTPK/Efhrwbm2KnKpiq2S4fD + YmtOTnOviMtlUyyviKknq6mIq4Odao/56kj0qvgD9FCgAoAKACgAoAKAP5ZPjx/yXb44/wDZZ/iv+vj/ + AMQmv9BuBv8Aki+E/wDsncn/APUCgf5u8f8A/Jc8Yf8AZTZ3/wCrHEHlVfVHyIUAFABQAUAFABQAUAFA + BQAUAFABQAUAFABQAUAFABQAUAFABQB6H4C8e3nhG88mbzLrRLqQG7tActAxwpu7QMQFmUY8yPKpcIAr + lXWOSP2cpzapl1TknzVMLUl+8p3u4N6e1p3ekl9qO1RKzs1GUfEzjJ6eZU+eHLTxdOP7uq9ppXfsqttX + Bu/LLWVOTurpyjL66sb+01O0gv7C4jurS6jEsM8RyrqfyKspBV0YB43DI6q6kD9DpVadenCrSmqlOoua + E4u6af4pp3TTs0000mmj82rUqtCrOjWhKnVpycZwlun+TTWqkm1JNSTaaZbrQzCgAoAKACgAoAKACgAo + AKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAPff2Uv+To/wBmz/svvwd/ + 9WJ4dr43xF/5N9x3/wBkbxP/AOqTHH2/hn/ycjw+/wCy34U/9X2AP7a6/wAoT/YEKACgAoAKACgAoA8u + +Nnwp0L44fCjx58J/EjPDpXjfw/daQ95Gglm0y+DR3mj6xBExCS3Gi6za2GrW8Uh8uSezjSTKMwr6HhT + iLGcJcR5PxHgEpYnKcbTxKpSk4xxFFqVLFYWcldxhisLUrYapJLmUKsmtUj5vjDhnBcY8M51wxmDccNn + GBqYV1YpSlh6141cJi4RbSlUwmLp0MVTjJ8sp0oqWjZ/Ff8AFr4UeNvgl8QfEfw0+IWkyaP4n8NXrW1z + GdzWl9av+8sdX0q5Kqt7pGq2rR3un3iACW3lUSJFOssMf+qfDfEeU8WZLgc+yXExxOAx9JVKctFUo1F7 + tbDYindulicPUUqVem2+WcXZyg4yl/kVxRwznHB+eZhw9nuFlhcxy+s6dSLu6Vam/eo4rDVGkq2FxNNx + rUKqS54SXMozUox84r3DwAoA7b4dfDrxn8WPGmgfD/wBoV54j8WeJb5LHS9Ms1BZmbLTXV1O5WCy06xg + WS71HUbuSKzsLOGa6upo4YnceTnmeZXw5lWMzrOsZSwOXYCk62IxFV7JaRp04K861etNqnQoU1KrWqyj + TpxlOST9jIMgzfifN8FkeR4KrmGZ5hWVHDYektW3rOrVm7Qo4ejBSq4jEVZRpUKUZ1as4wi2UvHPhO/8 + A+NvGPgXVJ7W61PwX4p8Q+E9RurFpXsrm/8ADmrXej3k9m08UMzWs1xZySW7TQxSmJkMkUbkqNsozKjn + OVZZm+HhUp0M1y/BZlQp1lFVYUcdhqeKpwqqEpwVSMKsYzUZSjzJ8smtXjnOV18kzjNslxM6dTE5RmWO + yvEVKLk6NSvgMVVwlWdJzjCbpzqUpSg5wjJxacoxd0ctXoHmhQAUAFAHu37NfwJ1f9pP4y+Evg9out2P + hu78T/2xPLruo2017babZaHomoa7ez/YreSGa8ne3054LW2WeBZbmaITXFvD5k0fyHHnF+G4E4XzLifF + 4Stj6eA+qwjg6FSNKpXq4vF0cJSj7WcZRpQU66nUqOE3GnGXLCc+WMvtPD7gvFeIPFuWcKYTGUcvq5j9 + bnLG4inOtTw9HB4Ovja0/YwlGdWcoUHCnTU4KVSceepCHNOP6x/8OQfEf/RxWif+G1v/AP5tK/nH/ibL + A/8AREYv/wAP1H/51H9Of8Sd5h/0XmD/APEfr/8Az3D/AIcg+I/+jitE/wDDa3//AM2lH/E2WB/6IjF/ + +H6j/wDOoP8AiTvMP+i8wf8A4j9f/wCe4f8ADkHxH/0cVon/AIbW/wD/AJtKP+JssD/0RGL/APD9R/8A + nUH/ABJ3mH/ReYP/AMR+v/8APc/Nn9sP9lDXP2Q/iNovgPWPFum+NYfEPhO08WabrenabcaOfs8+p6pp + M9ld6bc3d+0Fxb3WlSurxXtzDPbzwOHjl86CL928MfEbCeJeR4vOMNltfKpYLMqmXV8LXrwxXvww+HxM + KtOvCnRU4Tp4iKalShKE4TVpR5Zy/n7xW8MsZ4W5/hMkxWaYfN447LKWZ4fGUMPUwvuTxOJws6VXD1Kt + ZwqQqYaTTjWqRnTnCV4y5oR+TK/Rz8wCgAoAKACgDs/G3gTxB4B1CzsNdhiK6npdjrOl39o0sthqNhf2 + 8dwkltNLFA5kt2kNreQyRJJBcxOMPC8E83z/AA9xPk3FGHxlfKMVGu8uzDGZVmFCVo4nBY/A150K1DEU + uZuHM4e0ozu4VqM4VacpKTt9HxJwpnfCmIwWHznCSoLM8twWb5biI3nhsdl+Pw9PEUK+GrWSnyqp7KvD + SdCvCdKpFSjd8ZX0B84FABQAUAftL8JfD8vhb4aeCNDuITb3dp4d0+W+t2BV7fUL+IajqFvID/y1gvbu + eKUglTKjlSVIJ/yy8WM4o594jcX5lh5+0oTzerhaNVNONWlltOlllOrBrenVjg1UpvdwlFtJto/1v8H8 + lr8P+GXBmV4mHs8RTyWji69J3UqVbNKlXNalKaeqqUp4106q2VSMkm1Zv0Ovzw/SQoAKACgAoAKACgD+ + WT48f8l2+OP/AGWf4rH8/H3iE1/oNwN/yRfCf/ZO5P8A+oFA/wA3eP8A/kueMP8Asps8/wDVliTyqvqj + 5EKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAPQvAfjy88IXnkzeZdaJdSA3lmDl + oWOFN5aBiAs6gDzI8qlygCOVdYpY/YynNqmXVOWXNUwtSX72lfWL29rSu7KaXxK6VRLllZqMo+LnGT0s + zpc0eWni6cX7Kq9pLV+yq2u3Bt6Ss5U5NyjdOcJ/Xdhf2ep2dvf2FxHdWl1GJYJ4jlXU9euGV1YFZI3A + eN1ZHVXVgP0SlVp16cK1GaqU6i5oTjs1+aad1JO0oyTjJJpo/Na1Grh6s6NaEqdWnJxnCW6f5NNWcZJu + MotSi2mm7daGYUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFA + BQAUAFAHvv7KX/J0f7Nn/Zffg7/6sTw7XxviL/yb7jv/ALI3if8A9UmOPt/DP/k5Hh9/2W/Cn/q+wB/b + XX+UJ/sCFABQAUAFABQAUAFAHy/+0x+yH8Gv2qtAt9M+I2jz2uv6XE6eHfHfh9rax8W6CHZ3NtDfTW11 + DqGkSyu8lxo2qW95YM7vc20drf8Al3sX6BwF4l8UeHeMniMjxUKmDxEk8dlGNVStluMasvaSoxqU50cT + GKUYYrDzpVkkoTlUo81KX5x4h+FnCfiXgYYfP8LOnjsNFrAZ1gXTo5pgk25OnGtOnUhXwspScp4TE06t + BybqU40q/LWj+Jvj7/gi58cdK1CY/Dn4k/DrxjopklMDeIzrng7XFi3EwrLZW+meJdLkbZ8skqazHmQb + lgVGIT+rcm+lRwliKEf7cyLPMsxfLHnWBWEzPCOVvecatTEYDEJN6xi8LKy0c21r/IOd/RH4yw1ebyDi + DIM2wnNLkePeNyrGKN24qVGnh8wwzdtJSWLjeWqgk9GeAv8Agi58ddXv4G+InxI+G/gvRmINw+gNr3jT + X0wQSiabNpvhnSDuXIWX/hIWKNyYXAw1Zz9KfhDDUZrJMiz3NcUvgWNWDyvBu/V144jH4nR7x+pK+3Or + 3U5J9EfjPFV4PPuIOH8owj/iPAvG5vjl3Sw88Pl2F1Wil9fdnq4PZ/tb+zJ+x58Gf2VNEubP4eaRcX3i + bVreGDxH498QvDfeKdbSMrJ9lFxHDBbaTpAnUSx6RpNva2rvHBNfG/vYVvD/ACnx94ncU+IuLhVzvEwp + YDDTlPA5PglOjl+Fcrr2jhKc6mJxXI3F4rEzqVEpTjR9jSm6R/Xvh34U8JeGmDqUshwtStmOKpxhmGd4 + +Ua2ZYxRal7PnjGFPC4XnSlHC4WnSptxhOt7etH2r/kp/aT/AOTi/j7/ANlq+Kf/AKnOu1/pHwL/AMkR + wd/2SvD3/qowZ/mB4g/8l7xv/wBlfxL/AOrrGnitfVHyAUAFABQB+iX/AASs/wCT2vhh/wBgf4i/+q/8 + SV+I/SI/5NRn/wD2FZJ/6ucCfvP0af8Ak8HDv/YJn3/qjx5/WtX+bp/p+FABQB/NV/wWq/5L/wDCz/sj + 1v8A+pr4tr+7/oq/8kZxD/2U8/8A1VZaf58fS8/5Ljhv/slKf/q3zQ/Gyv6hP5OCgAoAKACgD9fdb+Gu + gfFT4VeGtE1pPJuF8NaLc6PrEUaveaRqDaRahbiHJXzbeXiO9s2dY7uHjdFOlvcQf5mYHj7OvDzxM4lz + jKZ+1oVOJM6pZpllSco4XM8Gs1xTlRq25vZ1qd5TwuKjGVTDVXe1SjOvQrf6o4/w7yPxK8K+FskziHss + RT4XyKtlWa06cZ4vKsa8nwijXo3cXUoVLRhjMJKcaeKoqzlTrQoV6P5cePvh94m+HGuzaD4msmt5gXks + r2Pc+n6raBtqXun3JVRNE3G9CFnt3Pk3MUMwKD/Qfg3jXIOO8npZzkGLVam+WGLwlRxjjcuxLjzSwuNo + KUnSqrXkmnKjXgva0KlWm1N/5v8AHHAnEXh9ndbJOIsHKhVTlPB4ynzTwOZ4VStHF4HEOMVVpS054NRr + 0Jv2WIp0qqcTia+sPjgoA+rv2cfgVqHjPWtP8aeJrF7bwXpFzFe2cN5AD/wlV/ayh4bWGCdSsuiQTIG1 + O7kjkt7wodJtlmeS/n03+ffG7xewPBuU4vh7JcXTr8W5jQnh7YeopSyHD4im1PHYmcG/ZY105XwGGbVV + TlHGVIqjCnHEf0f4DeDGP43zjB8SZ7g6mH4OyzEQxPNiKbjHiHFYeqpQwGFjOzq4FVYWzHFRUqThGeCp + SdepUnh/06JJJJOSeSTyST3Nf5476s/0pCgAoAKACgAoAKACgD+Wb49f8l3+OP8A2Wb4qH8/HviA1/oP + wN/yRnCf/ZOZM/vy/Ds/zd4//wCS54w/7KbPP/VliTyivqT5EKACgAoAKACgAoAKACgAoAKACgAoAKAC + gAoAKACgAoAKACgAoAKACgD0HwJ48vPCF55UvmXWi3MgN5Zg5aJjhTd2gYhVnVQN6ZVLhFCOVZY5I/Yy + nNqmXVOWXNUwtSX72lfWL29rSu7KaXxK6VRLllZqMo+Nm+UUszpc0eWni6cf3VW2klq/ZVbXbg23Z6un + JuUbpyjL670/ULPVLO31CwuI7q0uoxJDNGcqynggg4ZHVgUkjcK8bqyOqspA/RKVWnXpwrUZqpTqLmhO + OzX5pp3Uk7SjJOMkmmj81rUauHqzo1oSp1acuWcZbp/k01rGSbUk002ncuVoZBQAUAFABQAUAFABQAUA + FABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQB77+yl/ydH+zZ/2X34O/wDqxPDt + fG+Iv/JvuO/+yN4n/wDVJjj7fwz/AOTkeH3/AGW/Cn/q+wB/bXX+UJ/sCFABQAUAFABQAUAFABQAUAFA + BQB/EH+0sjR/tG/H9HVkdPjZ8VUdGBDKy+O9eDKwPIZSCCDyD1r/AFl4EalwPwbJNNPhTh1prVNPKMG0 + 0+qe5/jv4hJx4/44Uk01xhxMmnums6xqafmnueJ19WfHhQAUAFAH0N+yv8eZP2afjl4O+MS+HF8Ww+Gl + 1y1vNAOpHSJL6y1/QNS0G4NtqX2PUFtbm1XUftkJksriKZ7f7NIIlmNxF8T4h8Hx484SzThh455bLHvC + VKWN9h9ZjRq4PGUMZDnoe1oupTqOh7KdqsJRU/aLmceSX3fhrxtLw94yyritYBZpDL1jKdbA/WPqsq1H + HYLEYKo6eI9lXVOpSVf20OajOM3T9nLlU+eP7Hf8PvfCv/RvPiD/AMOLp3/zI1/MH/Ep2Y/9Ftgv/DJX + /wDnkf1f/wATiZb/ANEJjv8Aw/UP/nWH/D73wr/0bz4g/wDDi6d/8yNH/Ep2Y/8ARbYL/wAMlf8A+eQf + 8TiZb/0QmO/8P1D/AOdYf8PvfCv/AEbz4g/8OLp3/wAyNH/Ep2Y/9Ftgv/DJX/8AnkH/ABOJlv8A0QmO + /wDD9Q/+dZ+W37bn7Wa/tffE3QPHVt4KbwLp3hvwdaeE7LS59bGvXt2YtX1fWLnUbq9j07SoYvMl1X7N + DZxW0nlR2vnvdStcmK3/AKE8J/Dh+GeQYzKJ5qs3r4/NKmZVsRDCvB0qfNhsNhYUKdKVfETlyxw3tJVZ + VFzSqcqpxUOaf83eMPievFPiLBZzTyh5NQy/KaWV0cNPGfXa1XlxWKxdSvVqrD4aEeaWK9nClGnLljT5 + 3Vk6nLD40r9RPyYKACgAoAKAP2/8DZ/4QnwfuBDf8It4f3A5BB/sm0yDnnIPXPPrX+SXGLUuLuKmndPi + PPGmtU08zxTTXqf7I8Epx4M4RjJNSjwxkCkno01lWETTT2ae5c8ReGPD3i3TpNJ8S6PYa1p0h3G2v4Fm + VJACBNBIcS206gkJcW8kUyAnbIMnPJkfEGd8NY+nmeQ5njMqx1PRV8HWlTc4N3dKtDWniKMmlz0K8KlG + dlzQkduf8OZFxTl9TKuIcqwWb4Co+Z4fG0Y1VCaTSrUJ6VcPXim+Svh5060LvkqRuz5z1X9j/wCFV/O0 + 1lc+KtERn3C1sNVtbi1RSeUQ6tpuo3f+60l3IR33dK/c8u+k94jYOjGji8Pw5m04xs8TjcuxNDEzl0lP + +zcfgcL/AIlDCwTtpy6s/AMz+ij4Z42vKtg8TxPk8JSusJgszwuIw0I9YweaZdj8X6SqYuo1rfm6dH4V + /Zf+Enhe4hu30m88S3cDs8cvii8TUIQWBGJNNtrax0m4VATsFzYT7Ww+TIquPF4g+kP4l59QqYanmGBy + ChVhyVFkGEnha8ovdwxuLxGOx+Hm/wCfC4qhPopJNp+5w39Gvwt4exFPFVcux/EWIozVSlLiLGwxdCMl + 0ngMHh8Bl+Jh/wBO8ZhcRB6NxbSZ9CIiRoscaqiIqoiIoVERRhVVRgKqgAKoAAAwOK/EqtWrXq1K1epU + rVqs5VKtWrOVSrVqTk5TqVKk25znOTcpTk3KUm2227n7zSpUsPSp0KFKnRo0YQpUaNKEadKlSpxUYU6d + OCUIQhFKMIRSjGKSSSQ6szQKACgAoAKACgAoAKAP5Zvj1/yXf44/9ll+Kn/qeeIK/wBB+B/+SM4T/wCy + cyX/ANV2HP8AN3j93454w/7KbPPwzLEnlFfUnyIUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQ + AUAFABQAUAFABQB6B4E8eXnhC88uXzLrRbqQG8sgctExwpu7QMQq3CqBvQlUuEASQqyxSx+xlObVcuqc + sr1MLUlerSvrF6L2tO7sppfEtqiVpaqMo+Nm+UUszpc0bU8VTT9lV6SW/sqtrtwb2erpt80bpyjL680/ + ULPVbO31DT7iO6tLqMSQzRnKsp4IIOGR0YFJI3CyRyKyOqupA/RKNaniKcK1GaqU6i5oyjs1+aaejTs0 + 000mmfmtajVw9WdGtCVOrTlyzjLdP8mmtYyTakmmm07lytDIKACgAoAKACgAoAKACgAoAKACgAoAKACg + AoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoA99/ZS/5Oj/AGbP+y+/B3/1Ynh2vjfEX/k33Hf/AGRv + E/8A6pMcfb+Gf/JyPD7/ALLfhT/1fYA/trr/AChP9gQoAKACgAoAKACgAoAKACgAoAKAP4tf21BCP2tf + 2ihbxRwp/wALc8alkiRUUztrNy1zKQoAMk9yZZ5nPzSSyPI5LMSf9UfCrn/4hvwRzyc3/q1lVnJuTUfq + sOSN30hDlhFbRjFRWiP8jPF3k/4ihx7yRjGP+tOcNqKSTm8ZUdSTS+1OpzTm95Sk5O7bZ8w19+fnQUAF + ABQAUAFABQAUAFABQAUAFABQAUAfub4ZTy/Dfh+P/nnomkp/3zYW6/0r/IXP58+e51PfnzbMp3782MrP + 9T/Z/h2Hs+H8ip/yZNlkP/AcFQX6G3XknshQAUAFABQAUAFABQAUAFABQAUAfyzfHv8A5Lv8cP8Assvx + TP5+PNfNf6D8D/8AJGcJ/wDZOZL/AOq7Dn+bnH3/ACXPGP8A2U+e/wDqzxJ5RX1J8kFABQAUAFABQAUA + FABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFAHoHgTx3eeELzy5PMutFupAb2yBy0bHCm8tNx + CpcIoG9CVS5RRHIVZYpYvXynNqmXVeWV6mGqP97SvrF7e0p30U0t1e01pKzUZR8bN8opZnS5o2p4qmn7 + Kr0kt/ZVbXbg3s9XTb5o3TlGX15p+oWeq2dvqGn3Ed1aXSCSGaM5VgeCCDhkdGBSSNwrxuGR1VlIH6JR + rUsRShWozVSnUXNGS2a8+qad1KLtKMk00mmj81rUauHqzo1oSp1acuWcZbp/k01rGSbUk002ncuVqZBQ + AUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAe+/spf8nR/s2f9 + l9+Dv/qxPDtfG+Iv/JvuO/8AsjeJ/wD1SY4+38M/+TkeH3/Zb8Kf+r7AH9tdf5Qn+wIUAFABQAUAFABQ + AUAFABQAUAFAH8Un7YM3n/tWftHv/d+NvxMh/wDAfxfq1v8A+0q/1X8Mo8nh1wMu/CmQy/8AA8tw0/8A + 24/yF8VZ8/iZx/LtxhxDD/wXmmJh/wC2nzlX3J8CFABQBv8AhSGG58U+G7e5ijnt59f0eG4gmRZIpoZd + Rt0liljcMskciMyOjAqykqwIJFeTn9ephsizrE0pypVcPlOZV6dWEnGdOpSwdapCcJJpxlCUVKMk7ppN + O57PDtCniuIMiwtWnCrSxOc5ZQqUqkVOnUp1sbQpzpzhJNThOMnGUWmpJtNNM/Yb/hUnws/6Jz4I/wDC + Y0b/AOQ6/wAvP+Il+In/AEXPFv8A4kGa/wDzUf6xf8Qs8NP+iA4O/wDEcyn/AOZQ/wCFSfCz/onPgj/w + mNG/+Q6P+Il+In/Rc8W/+JBmv/zUH/ELPDT/AKIDg7/xHMp/+ZQ/4VJ8LP8AonPgj/wmNG/+Q6P+Il+I + n/Rc8W/+JBmv/wA1B/xCzw0/6IDg7/xHMp/+ZQ/4VJ8LP+ic+CP/AAmNG/8AkOj/AIiX4if9Fzxb/wCJ + Bmv/AM1B/wAQs8NP+iA4O/8AEcyn/wCZQ/4VJ8LP+ic+CP8AwmNG/wDkOj/iJfiJ/wBFzxb/AOJBmv8A + 81B/xCzw0/6IDg7/AMRzKf8A5lPy/wD2gtL0vRfi/wCMdL0XTrHSdMtJdGS20/TrWGzsrff4d0iWbyba + 3SOGPzbiSWaTYg3yyPI2WYk/6DeCuY5jm3hjwvmGbY7F5lmGJp5rLEY3H4irisXX5c8zOnS9rXrznVqe + zowp0oc0ny04QgrRikv83/HXLcsyjxV4sy3J8vweV5dhamUQw+By/DUsJhKHPkGVVK3ssPQhClT9rXnV + rVOWK56tSc5XlJt+NV+pn5IFABQAUAfuvpCeXpOlx/3NOsk/75tol/pX+PuZy58yzCf8+Oxcv/Aq9R/q + f7U5VD2eV5bD+TAYOH/gOHpr9DRrhO8KACgAoAKACgAoAKACgAoAKACgD+Wj4+f8l4+OH/ZZPikfz8da + 8a/0H4H/AOSM4T/7JzJf/Vdhz/Nzj7/kueMf+ynz3/1Z4k8mr6k+SCgAoAKACgAoAKACgAoAKACgAoAK + ACgAoAKACgAoAKACgAoAKACgAoAKACgAoA7/AMCeO73whe+XJ5l1ot1IDe2QOWjY4X7XabiFS4RQN65V + LhAI5CGWKWL18pzapl1W0rzw1SX72nfVPRe0p3dlNLdbTS5ZWajKPjZvlFLM6V1y08VTT9lWto+vsqtk + 3Km3s9ZU5PmjdOcJ/Xmn6hZ6rZ2+oafcR3VpdRiSGaM5DA8EEHDI6MCkkbhXjcMjqrKRX6LRrU8RThWo + zVSnUV4zi9H38007qSdnFpppNM/Na9Grh6s6NeEqdWnLlnCW6e977NNNOMk3GUWpRbTTLtaGQUAFABQA + UAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAe+/spf8nR/s2f9l9+Dv/qx + PDtfG+Iv/JvuO/8AsjeJ/wD1SY4+38M/+TkeH3/Zb8Kf+r7AH9tdf5Qn+wIUAFABQAUAFABQAUAFABQA + UAFAH8SH7U832j9p39o2fqJfjv8AF2Qf7rfEDxCVH0AIAr/WDw8jycAcDw/l4P4aT9Vk2Cv+J/j54lS5 + /EXj6a2lxrxTJejz3HtHg1fYHxQUAFAHVeBk8zxt4Oj/AOenirw8n/fer2i/1r53jCfJwlxTP+Th3O53 + /wAOWYp/ofTcFw9pxjwnT35+Jshh/wCBZrhV+p+31f5In+yQUAFABQAUAfkF+0W+/wCNPjtvS/09P+/e + iaZH/wCy1/px4Gx5PCng9d8HjZf+B5vmE/8A27XzP8p/H2fP4vcayve2OwMP/BeT5dT/AA5bHilfrB+P + hQAUAFAH7xWyeXbwR/8APOGJP++UVf6V/jpXn7SvWqfz1ak//ApuX6n+2eHh7OhRp/yUqcP/AAGCX6E1 + ZGoUAFABQAUAFABQAUAFABQAUAFAH8tHx9/5Lx8cP+yx/FH/ANTnXq/0I4I/5IzhP/sm8k/HLcMz/Nzj + 7/kueMf+ynz3/wBWeJPJq+oPkgoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAC + gAoAKACgDv8AwL47vfCF5sfzLrRrmQG9sg2SjHCm6tNxCpcIoG5cqlwgCSEFY5I/XyrNauXVbO9TDVH+ + 9pX1T29pTu7KolurpVEuWVmozh4+b5RSzOldWp4qmn7Gt0a1fsqtk26bbdnrKnJuUbpzhP7Jr9JPy8KA + CgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAPff2Uv+To/wBmz/sv + vwd/9WJ4dr43xF/5N9x3/wBkbxP/AOqTHH2/hn/ycjw+/wCy34U/9X2AP7a6/wAoT/YEKACgAoAKACgA + oAKACgAoAKACgD+KL9rzQLzwz+1N+0NpN9DJBKPjH8QtRgSUYd9N1zxNqOuaROeTlbrStRs7lG/jSZWw + M4r/AFZ8NMZSx/h7wTiaM4zi+F8loTcdlXwmAoYTEw9aeJoVabXRxaP8hPFPBVsv8SeO8NWhKEv9bM9x + EFLd4fGZjiMZhZvv7XDYilUT6qaZ86V9ufBBQAUAegfCjT5dU+J3gCyiVmMni/w/LJtBYrb2up211dPg + A/6u2hlkOeAFJYgZNfF+I+MhgOAONMVUkoqHDGdwg5NJOtXy/EYfDwu2tZ16tOC6tySSbaT+58McFUzH + xG4GwlOMpOfFeQ1J8qcmqOHzLD4nETsulOhSq1G9kottpJs/aiv8oz/X8KACgAoAKAPyQ/aY0ybTfjP4 + vMqFYtQbStTtXPSaG50exWR19lu4rqE/7cTdua/0t8A8fSx/hVwyqc1KpglmWAxEVvSq0M0xkoQlbrLD + VcPWXVxqxb1bP8tPpE5dWy/xd4qdSDjTx7yzMcNJ7VaOIynBRnOPdRxVLE0X/epSPBq/Yz8SCgAoA3vC + 2jt4i8T+HdAUkNrmu6Ro6leWB1PULeyBHuDPke9cGa4+nleV5lmdaUY0suwGMx9WU3aEaeEw9TETlJva + KjTbk3srs9HKMvq5tm2V5VQjKdbM8xwWX0YQXNOVXG4mlhqcYx15pSnUSitbtpH7lV/j8f7ThQAUAFAB + QAUAFABQAUAFABQAUAFAH8tPx+/5Lz8cP+yxfFD/ANTjXa/0I4I/5IzhP/sm8k/9VuGP82+Pf+S44x/7 + KjPv/VpijyWvqD5MKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAK + AP0Ir9gPxcKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAPff2U + v+To/wBmz/svvwd/9WJ4dr43xF/5N9x3/wBkbxP/AOqTHH2/hn/ycjw+/wCy34U/9X2AP7a6/wAoT/YE + KACgAoAKACgAoAKACgAoAKACgD+ef/gsH+y/qNl4n0z9p3wlpktzo+u2eneG/ih9mRpDputaZDDp3hrx + JchQxW01TSY7XQLqXKQ2tzpGmbt0upsw/tP6M/iJhp4Kp4e5piI0sVQq4jG8OSqNRjiMPWlLEY/LYSbX + 7+hXdbHUYazrUq+KtZYZKX8L/So8NMVDHU/EjKcNKrhMRRw2B4njSTlLDYmhGGGy/M6iSb9hXw6o5fXq + aRo1cPhL3eKk4/hfX9en8XhQAUAfcP7Ifwwu5tVn+Jur2rRWFlBc6f4YMyAG8vrlXttR1GAOu7yLO2M1 + gky/LLPdXKKxa1kFfyV9JnxCw1DLKfh/lteFXHY6ph8ZxB7OXN9TwVCcMVgsFUcXZYjGYiNHFyg3z08P + h6bnDlxdOR/Y/wBFfw2xeIzWp4jZph50cBgKWJwXDntI8v13HYiFTCY/HUlLWWHwWHlWwcaiXJVxWJqq + E+fB1Yn6D1/Eh/eIUAFABQAUAfIf7VfwlvPGGj2fjfw9aNda54atZbbU7OCNpLrUtBMjXAaBFDNLPpE8 + lzcLCo3S213dlS8kMMT/ANNfRz8SsNwzmuJ4SzvExw+U5/iKdfL8VWmo4fA51yRoONaUmlTpZnShQoOr + JuNPEYfCp8tOrVqR/lb6TXhdiuKsowvGWRYV4nOeHcNVoZlhaMJTxOPyPnlXUqMYpyq1sqrTr4iNGKUq + mGxOLac6lKjSn+adf3sf54BQAUAfYv7J3wrvda8SR/EbVbaSLQvD7TporSKVXVNcZGt2khDDMlppcckz + yTL8v9oeREjs9vdJH/MX0jvEjC5NkNXgjLcRCpneeU4LNY03zPLsmk/aThVadoYjMuWNGFGV5fUZYirN + U1Vw0qv9W/Rj8McXnfENHj3NMNOnkWQVKjymVVOKzPO4r2cJ0U1eeGytSnWqV4tR+vxw9GDqOlioUv0j + r+DD/QsKACgAoAKACgAoAKACgAoAKACgAoA/lq+P/wDyXn43/wDZYfid/wCpvrlf6EcEf8kbwn/2TeRv + 78twzP8ANvj3/kuOMf8AsqM+/wDVpijySvqD5MKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoA + KACgAoAKACgAoAKACgAoAKAP0Ir9gPxcKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAo + AKACgAoAKACgAoAKAPff2Uv+To/2bP8Asvvwd/8AVieHa+N8Rf8Ak33Hf/ZG8T/+qTHH2/hn/wAnI8Pv + +y34U/8AV9gD+2uv8oT/AGBCgAoAKACgAoAKACgAoAKACgAoAzNZ0bSfEWk6joWvabY6zour2c+n6ppW + pW0V5YahZXUbRXFrd2s6vDPBNGxV45FZSD681rQr1sNWpYnDVquHxFCpCtQr0akqVajWpyU6dWlVg4zp + 1Kc0pwnCSlGSUotNXMq9ChiqFbDYqjSxGGxFKdHEYevThVo16NWLhUpVqVRShUp1IScZwnGUZxbUk02f + gp+2B/wSe0PR01D4h/s+aje6Ro6rd3mteBdV8/WbLSHZzKl1o2oITq9poECFlu4bmPXruwXbcK5sVmNp + /VvBH0oMwy/D0cBxtllTOYUlGCzrLJUaOZOnFWvi8DV9lhMZW/6fUsRgW0v3lOrUlKq/5B49+ifluZYm + vmPAebUskqVnOpLI81jXr5Wqsm5WwePoqrjMFR/6cVcNmCTl+7qUqcY0j8uT+yF8WhM0YfwqyAZFwNZu + PJY/3QG01Z93+9CF/wBqv11fSX8MnR9q6uexm7/7O8pftl6yjiJYfX/r+/Nrc/F39FnxVVd0lRyCUF/z + ErOV7F+ajLDRxOm7vh0+2p7R8P8A9jrTdOurfUviDraa20LQzDQtGWa30ySRMs8V9qFwkd7eWxbaPLt7 + fTmYKd8rI5jr8o41+lFi8bh62B4Iymrlftozg85zf2NXHUoyVlLCYChUr4WhWW8a2IxGMir6YdSSmv2D + gX6JuDwOKo4/j3OKObexlCoskyX29LAVZRd3HG5jiKdDGYihLaVHD4bBTdtcTKMnA+07OztNPtbexsba + CzsrSGO3tbS1iSC3t4IlCRwwwxqsccaKAqIihVAwBX8nYrFYnHYmvjMZiK2LxeKqzr4nE4irOtXr1qsn + OpVrVajlOpUnJuUpzk5SbbbP7DwmEwuAw2HwWCw9DCYPC0aeHw2Fw1KFHD4ehSioU6NGjTUadOnTglGE + IRUYpJJFmsDoCgAoAKACgAoA+cviN+zF8PvH91catZvdeDfEF1JJNc6lo1vDd6fezylWkuNR0Gea0imu + GZWJm06/0h5JZ57i9N9KV2/0FwD9IfivhHDUMqzahDijJ8PGFLDwxeIlhszwdGC5Y0qGYqnX9tRpx+Cl + jKFecYxhSpV6NKKiv5w8RPo18IcZ4qvm+T4ipwnnWJnUrYqeDw8MTlWNr1Hzyr4jLXVoexr1J61KuCxG + HhOU51q2Hr1pOb+arz9i/wAeJeeXp/inwldWHa6vG1ixusZ72UOmajECe2L5h1yRxu/cqP0qeB5Ueavk + XFdKv1pUsPlFelfyrTzehJr1oJ7WT1t+BVvoi8fRrcuH4g4Qq4e+latic5oVbedCGTYiKb7LESW95LS/ + p/gf9jjQdLuob/xxr8niMxFJBo2mQSabprOpBK3d480l9eQk5/dwppzHA3u6lo6/OuLvpR5vj6FXB8H5 + NDJVU5of2tmVWnjsfGEk0pYfBwprB4Wst+etUzCFm7U4ySmfpfBn0S8ny/EUcbxrnk89dNxn/Y+V0quA + y+U4u7jicdOo8di6D/koUstndLmqSi3B/ZNjY2emWdtp+nWtvY2NnClvaWdpDHb21tBGNscUMMSrHHGi + jCqigCv5ZxmMxeYYrEY3HYmvjMZiqs6+JxWJqzrYivWqNynVq1akpTqTlJtylKTbfU/rjBYLB5dhMPgM + vwtDBYLCUoUMLhMLShQw+Ho01ywpUaNNRhThFKyjGKSLVcx0hQAUAFABQAUAFABQAUAFABQAUAFAH8tf + 7QH/ACXr43/9lg+Jv/qba5X+hPBP/JG8J/8AZNZH/wCqzDH+bfHv/JccY/8AZUZ9/wCrTFHkdfTnyYUA + FABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAfoRX7Afi4UAFABQAU + AFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAe+/spf8nR/s2f8AZffg7/6s + Tw7XxviL/wAm+47/AOyN4n/9UmOPt/DP/k5Hh9/2W/Cn/q+wB/bXX+UJ/sCFABQAUAFABQAUAFABQAUA + FABQAUAIQCCCAQQQQeQQeoIPUHvQB+en7Rf7M5tPt/j34cWBNp+8u/EPhazjy1p1efVNDgQZNr96S80y + MZtfmmslNtut7UA+C6ACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAP5a/2 + gP8AkvXxv/7LB8Tf/U11uv8AQngn/kjeE/8Asmsj/wDVZhT/ADa48/5LjjH/ALKniD/1a4s8jr6c+UCg + AoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgD9CK/YD8XCgAoAKAC + gAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgD339lL/AJOj/Zs/7L78Hf8A + 1Ynh2vjfEX/k33Hf/ZG8T/8Aqkxx9v4Z/wDJyPD7/st+FP8A1fYA/trr/KE/2BCgAoAKACgAoAKACgAo + AKACgAoAKACgAoA+DP2i/wBmcXv2/wAffDiwxe/vLzxD4Ws4+Lw8yT6pokCD5bv70l5pka4u/mmslF3u + t7sA/PMggkEEEEggjBBHUEHkEHqDQAlABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAF + ABQB/LZ+0F/yXr43/wDZX/iX+vjTWzX+hPBP/JG8J/8AZNZH/wCqzCn+bXHn/Jb8Y/8AZU8Qf+rXFnkV + fTnygUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAfoRX7Afi4U + AFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAe+/spf8AJ0f7Nn/Z + ffg7/wCrE8O18b4i/wDJvuO/+yN4n/8AVJjj7fwz/wCTkeH3/Zb8Kf8Aq+wB/bXX+UJ/sCFABQAUAFAB + QAUAFABQAUAFABQAUAFABQAUAfEv7RP7NKeJBfeOvh9ZJF4hxJda54dt0VIte6vLf6bGuFj1k/M9xbKA + mqnMke3USwvwD83JI5IpHilR45Y3aOSORWSSORGKujowDK6sCrKwDKwIIyKAGUAFABQAUAFABQAUAFAB + QAUAFABQAUAFABQAUAFABQAUAFABQAUAfy2/tBf8l7+N/wD2V74lf+pnrVf6FcFf8kbwn/2TWRP78rwr + P82uO3fjfjH/ALKriD8M2xaPIa+mPlAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgA + oAKACgAoAKACgAoA/Qiv2A/FwoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACg + AoAKACgAoA9L+C/iq18C/GL4T+N76XyLLwd8S/Aniq8m2l/JtfD3inStXuJdo+ZvLis3faOWxgcmvB4p + y6pnHDHEeU0o89XNMhzfLqcb25qmNy/EYaEbvbmlVSvfS9z6HhLM6eS8V8M5xWlyUsp4hyXM6s7N8tPA + ZlhsVOVlq7RpN2WrP7mo5I5Y0lidJYpUWSOSNg8ckbgMjo6kq6OpDKykhgQQSDX+R0lKMnGScZRbUoyT + UlJOzTT1TT0aeqe5/sspKSUotSjJKUZJpqSaummtGmtU1o1qPpDCgAoAKACgAoAKACgAoAKACgAoAKAC + gAoAKAPj39of9m638bpd+NPA9tDa+MY0afU9LTZDbeJ1QZaRM7Y4NcwPlmYrFqBxHdMk5FzQB+Y9xb3F + pcT2l3BNbXVtNJb3NtcRvDPbzwuY5YZoZAskUsUiskkbqro4KsAQRQBDQAUAFABQAUAFABQAUAFABQAU + AFABQAUAFABQAUAFABQAUAISACWIAAJJJAAA5JJPAAHJJOB1NNJtpJNtuyS1bb2SW7bYm0k22kkm227J + JattvZLdtn8p/wAV9es/FPxS+JXifTpvtOn+I/H/AIx16xuMFfPs9X8RajqFrNtblfNguEfB5G7B5r/R + fh7B1MuyDI8vqx5auAyfLMHVje/LUwuCo0Jxv1tKDV+p/mVxJjqeZ8RZ/mVGXNSzDOs1x1KX81PF46vi + IS111jUT17nAV7B4oUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQA + UAfoRX7Afi4UAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFAH9 + UP8AwTI/bA0f43/CjSPhL4s1kL8X/hho9vpUkOoTp9r8Y+DtOAtdF8Q6e8jedf3ul2K2uk+JATNdrcwW + +sXUjDWP3X+eHj34Y4rhHiLE8R5bh5S4Zz/FVMTGdKLcMrzOu3VxWBr8q5aVKvWdTEYBvlg6UpYaN5YZ + yn/pT9HjxWwnGfDWF4YzPExhxVw7hKeGlTqzUZ5tlWHSpYTH4dN81Wth6KpYbMYpzmqsYYubUcWo0/1H + r+fj+jwoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoA+U/2gv2dLL4jwXHirwpFb2Hjm3h3TRZSC08T + xRJhbe8c7Y4NURFEdnqLkLKoS0v28kQXNkAfltf2F7pd7dadqVpcWN/Yzy215Z3cTwXNtcQuUlhnhkCv + HJG4KsrAEGgCpQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQB8G/tyftLaf8JfAd/wCAPDep + BviX4402aygS0lBn8MeHrwfZ9Q1y8eNxJZ3l3bPPZ6CuUma6eXUoyY9NZZf2Dwi4FxHEmd0M4xlBrIsn + xEK9SdSL5MdjaTVTD4OlzJqrGFRQrYvRxVKKoztKvA/FfGbxAw/C+Q4jJcDiE+IM6w88PShSknUwGBrX + p4nG1bPmpTqU3Uo4Pacq0nWheNCV/wAAa/tA/hkKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAo + AKACgAoAKACgAoAKACgAoAKACgD9CK/YD8XCgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgA + oAKACgAoAKACgAoAKACgAoA3PDPibxD4M1/SfFXhPWtS8O+JNCvYtR0fW9HvJrDUtOvYCTHcWt1buksT + gFkYBtskbvFIrxu6NyY/AYLNMHicuzLC0MdgcZSlQxWExVKNahXpT+KFSnNOMls1peMkpRakk12ZfmOO + ynG4bMssxeIwGPwVaNfC4zC1Z0cRQrQ+GdOrBqUXunraUW4yTjJp/rR8Of8Agt98TvhppNlbfHX4T2vx + Z0e1UQ3vjjwRqdt4T8YWsagbbrV/DU+n3HhrXHkYlHutMuvCMEC+X51pM4e4m/kjjr6M+XKrVzHhLM6u + XYabcpZZjoVMdh8NJv4aOLVRYunhl0deONqxek6jTTX9k+H/ANKjM3So5ZxllVHM8XBKMc1wFSngMTi4 + pfFWwbpvB1MU9eZUJ4GlJawpJpp/QNp/wcKfsePAjX3wr/aVt7oj97DaeFvhdewIfRLmb4u2Ekg92tYj + 7V+Sz+j/AMXqT5M04blHo54rNISfrFZTUS/8CZ+xw+kbwW4p1Mp4ojPqoYTKpxXpKWc02/nBFn/iIR/Y + x/6Jl+09/wCEZ8Kv/n01P/EAOMv+hlwz/wCFua//ADmK/wCJjeCP+hXxV/4Q5R/8/A/4iEf2Mf8AomX7 + T3/hGfCr/wCfTR/xADjL/oZcM/8Ahbmv/wA5g/4mN4I/6FfFX/hDlH/z8D/iIR/Yx/6Jl+09/wCEZ8Kv + /n00f8QA4y/6GXDP/hbmv/zmD/iY3gj/AKFfFX/hDlH/AM/A/wCIhH9jH/omX7T3/hGfCr/59NH/ABAD + jL/oZcM/+Fua/wDzmD/iY3gj/oV8Vf8AhDlH/wA/A/4iEf2Mf+iZftPf+EZ8Kv8A59NH/EAOMv8AoZcM + /wDhbmv/AM5g/wCJjeCP+hXxV/4Q5R/8/A/4iEf2Mf8AomX7T3/hGfCr/wCfTR/xADjL/oZcM/8Ahbmv + /wA5g/4mN4I/6FfFX/hDlH/z8D/iIR/Yx/6Jl+09/wCEZ8Kv/n00f8QA4y/6GXDP/hbmv/zmD/iY3gj/ + AKFfFX/hDlH/AM/A/wCIhH9jH/omX7T3/hGfCr/59NH/ABADjL/oZcM/+Fua/wDzmD/iY3gj/oV8Vf8A + hDlH/wA/A/4iEf2Mf+iZftPf+EZ8Kv8A59NH/EAOMv8AoZcM/wDhbmv/AM5g/wCJjeCP+hXxV/4Q5R/8 + /A/4iEf2Mf8AomX7T3/hGfCr/wCfTR/xADjL/oZcM/8Ahbmv/wA5g/4mN4I/6FfFX/hDlH/z8D/iIR/Y + x/6Jl+09/wCEZ8Kv/n00f8QA4y/6GXDP/hbmv/zmD/iY3gj/AKFfFX/hDlH/AM/A/wCIhH9jH/omX7T3 + /hGfCr/59NH/ABADjL/oZcM/+Fua/wDzmD/iY3gj/oV8Vf8AhDlH/wA/A/4iEf2Mf+iZftPf+EZ8Kv8A + 59NH/EAOMv8AoZcM/wDhbmv/AM5g/wCJjeCP+hXxV/4Q5R/8/A/4iEf2Mf8AomX7T3/hGfCr/wCfTR/x + ADjL/oZcM/8Ahbmv/wA5g/4mN4I/6FfFX/hDlH/z8D/iIR/Yx/6Jl+09/wCEZ8Kv/n00f8QA4y/6GXDP + /hbmv/zmD/iY3gj/AKFfFX/hDlH/AM/A/wCIhH9jH/omX7T3/hGfCr/59NH/ABADjL/oZcM/+Fua/wDz + mD/iY3gj/oV8Vf8AhDlH/wA/D5q+PH/BYz9hz4q2x1vRPhp+0no3jm1iVIr+XwV8LI7LWreMbUstYMPx + lkkEkSfLZ6ikUs8KgW8yTW3lC3T8AOMkm/7S4abs3ZY3NLvyV8nSu/Npd2NfSM4IbSeWcUq7SbeBymyv + 1ds7bst3ZN9k2fHv/D034I/9Ex+Ow+uj/C7/AOe2a5/+ID8b/wDP7Iv/AAvxP/zCdP8AxMLwF/z54g/8 + N2G18/8AkYC/8PTPggf+aZ/HQfXR/hf/AE+LJo/4gPxv/wA/si/8L8T/APMIf8TC8B/8+OIP/Dfhf/ng + L/w9L+B//RNfjn+OjfDH/wCeuaP+ID8bf8/8i/8AC/E/f/uH/BF/xMNwH/0D8Q/+G/Cf/PEd/wAPSvgf + /wBE3+OP/gm+Gf8A89an/wAQG42/5/5D/wCF+K/+d4f8TDcB/wDQPxD/AOG/Cf8AzyF/4ek/A7/onHxw + /wDBL8Nf/nq0/wDiA3G3/QRkH/hfi/8A53i/4mG4E/6BuIv/AA34P/55i/8AD0j4Hf8AROvjeProvw2/ + p8UzR/xAXjb/AKCcg/8AC/Gf/O4P+Jh+BP8AoF4if/dPwf8A88x3/D0f4G/9E8+No+ui/Dj+nxRNP/iA + vGv/AEFcP/8AhdjPv/5Fov8AiYfgT/oF4j/8N+C/+eYv/D0b4Gf9E++Nn/gk+HX/AM9Cj/iAnGv/AEFc + P/8Ahdjf/naH/ExHAn/QJxH/AOG/A/rmgv8Aw9F+Bf8A0IHxr/HRPh5/8840/wDiAnGv/QXw9/4XY7/5 + 2C/4mI4F/wCgPiT/AMIMB/8APUX/AIeifAv/AKEH41D66J8Pf6fE00f8QD40/wCgzh7/AMLsd/8AOwX/ + ABMTwL/0BcS/+EGX/wDz2Hf8PQ/gV/0IfxoH10P4f/0+JZp/8QD40/6DeHf/AAux/wD86w/4mJ4F/wCg + LiX/AMIMv/8AnsL/AMPQvgT/ANCL8Z//AAR+Af8A55NH/EA+NP8AoN4d/wDC7H//ADrF/wATFcDf9AHE + 3/hBl3/z3Hf8PQfgR/0JHxl/8EXgP/545p/8QC4z/wCg7hz/AMLcw/8AnSH/ABMVwN/0AcTf+EGW/wDz + 3FH/AAVA+BB/5kn4yD66F4E/p8RjR/xALjP/AKDuHP8AwtzH/wCdIv8AiYvgf/oX8T/+EOWf/PgX/h5/ + 8B/+hL+Mf/gi8Df/ADxaf/EAuM/+g/hv/wALcy/+dAf8TF8D/wDQu4n/APCHLP1zkd/w8++A3/Qm/GH8 + dB8Ef/PDNH/EAeM/+hhw3/4W5n/86Bf8TF8D/wDQt4o/8Icr/wDn0L/w89+Av/Qn/GD/AMEPgr/54NP/ + AIgDxl/0MeGv/C3M/wD5zg/pGcD/APQt4of/AHI5V+udEVx/wU9+Bqwu1r4M+LE04H7uO50jwfbQsf8A + bni8bXjoPcW8h9qqPgBxg5LnzLhuMerji8zk1/268pjf/wACREvpG8FKLcMr4olLopYPKopvzks5m168 + rPAPif8A8FOfFGr2F3pfwp8EW/hKWdfLj8UeJL2DXNUt1dG3y2WhxWsWk2t3G5Xypb+61u2KhvMsSzr5 + f23D3gDl+Fq08RxJms8yUHzPL8BCeEws2npGti5TeKq05K/NGjTwc72tVsmn8JxL9IvMsXSq4bhfKIZX + zrlWZZjUhjMXBNO8qODhBYSjVi7csq1TG02r3pXacfzF17Xta8UazqXiHxFql7rWuaxdSX2p6pqNxJdX + t7dSnLzTzSEsxwFRFyEjjVIo1SNEUfv2DwWEy7C0MFgcPRwmEw1NUqGHoQjTpUoR2jGEUkru7k9ZSk3K + Tcm2/wCdMdjsZmeLxGPzDFV8ZjcVUdXEYnEVJVa1WpLeU5ybbsrRitoxSjFKKSWTXScgUAFABQAUAFAB + QAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFAH6EV+wH4uFABQAUAFABQAUAFA + BQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUANdEkRo5FV0dWR0dQyOjAhlZWyG + VgSGUgggkHINJpSTTSaaaaaumnumnun1T3Gm4tSi2pJppptNNO6aa1TT1T3ufL3xI+G76G8uuaHE0mjS + MXurVAWfS3Y8svVmsWY/KxybYkI5MZVh8LnWSvCuWKwsW8M3epTWroN9V1dJvZ/Y2elmff5FnixajhMX + JLFRVqdRuyxCXR9FWS3/AOfi1XvXv41XzR9QFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFA + BQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQA + UAFABQAUAFABQAUAFABQAUAFABQAUAfoRX7Afi4UAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQ + AUAFABQAUAFABQAUAFABQAUAFABQAUANdEkR45FWSORWR0dQyOjAqyurAhlYEhlIIIJBBBpNKSaaTTTT + TV0090090+qe403FqUW1JNNNNppp3TTWqaeqe9z5e+JHw3fQ3l1zQ4mk0aRi91aoC76W7HJZerNYMT8r + HJtiQjnyyjV8LnWSvCuWKwsW8M3epTWroN9V1dJvZ/Y2elmfoGR54sWo4TFySxSVqdR6LEJdH0VZLdfb + +Ja3R41XzR9OFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQA + UAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAF + ABQB+hFfsB+LhQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUA + FABQAUANdEkR45EWSORWSRHUOjo4KsjqwKsrKSGVgQQSCCDSaUk00mmmmmrpp7pp7p9U9xpuLUotqSaa + abTTTummtU09U97ny78SPhu+hPLrmiRNJo0jF7q1UFn0t3P3h1ZrFmOFc5NuSI5CUKPXwud5K8K5YrCx + bwzd6lNJt0G+q70m9n9h6PRpn6BkeeLFqOExcksUlanUeixCXR9FWS3X2/iWt0eN180fThQAUAFABQAU + AFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFA + BQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQB+hFfsB+LhQAUAFABQAUAF + ABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFADXRJEeORFkjkVkkR + 1Do6OCrI6sCrKykhlYEEEggg0mlJOMkpKSaaaumno009Gmt09xpuLUotqSaaabTTTummtU09U97ny58S + Phu+hPLreiRNJosjFrm2XLvpbueo6s1izHCOcm3JEch2lHPwmdZK8I5YrCxbwzd5wV26Db+90m9nvB6S + 0s3+gZHnqxijhMXJRxSVoVHZRxCX4KtbdbT+KOt4rxyvmz6cKACgAoAKACgAoAKACgAoAKACgAoAKACg + AoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoA + KACgAoAKACgAoAKACgAoAKACgAoAKACgAoA/Qiv2A/FwoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAo + AKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAa6JKjxyIskciskkbqHR0cFXR1YFWVlJDKwIYE + ggg0mlJOMkpKSaaaumno009Gmt09xpuLUotqSaaabTTTummtU09U97ny38SPhw+gyS63okTSaLI5a5tl + BZ9Kdz+LNYsxxHIcmAkRSnbsdvhM6yV4RyxWFi3hm7zgrt0G397pN7PeD0lpZv8AQMjzxYxRwmKko4qK + tCo3ZYhJfhWS+Jfb+KOvMl47XzZ9OFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFA + BQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQA + UAFABQAUAFABQB+hFfsB+LhQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQ + AUAFABQAUAFABQAUAFABQAUANkRJUeOVFkjkVkkjkUOkiOCro6sCrKykqysCGBIIINJpSTjJKSkmmmrp + p6NNPRprdPcabi1KLcZRaakm0007pprVNPVNap6ny38SPhw+gvLreixPJosj7rm3XLvpUjt+LNYuxxHI + cmBiIpTgxu/wmdZLLCOWKwsXLCt3nBXbw7f4uk3tLeF+WWlpP9ByPPFjFHC4uSji4q0Kj0WIS/BVkviX + 2/ijrzJeO182fTBQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQA + UAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQB+hF + fsB+LhQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUA + FABQAUAFADJI0lR4pUSSORGjkjkUOkiOCro6MCro6kqysCGBIIINJpSTjJKSkmmmrpp6NNPRprdPcabi + 1KLcZRaakm0007pprVNPVNap6ny38SPhxJoEkutaLE8miSPuuLdcvJpUjn8WaxZjiOQkmAkRSkgxyP8A + B51krwjlisNFywsnecFdvDtv73Sb+GT1i3yy6Sl+g5HnixijhcXJRxcVaFR6LEJfgqyXxL7fxR15kvHq + +cPpgoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAC + gAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgD9CK/YD8XCgAoAKA + CgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgB + kkaSo8UqJJHIjRyRyKHSRHBV0dGBV0dSVZWBDAkEEGk0pJxklJSTTTV009Gmno01unuNSlGSlFuMotSj + JNqSkndNNapp6prVPU+W/iR8OJNAkl1rRYnk0SV91xbrud9Kkc9D1ZrF2OIpSSYWIhlPMcknwedZK8JK + WKw0XLCyd5wWrw7b+90m/hl9lvll0lL9ByPPVjFHC4uSji0rQm9FiEl9yrJayitJ6yilrFePV84fTBQA + UAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAF + ABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAfoRX7Afi4UAFABQAUAFABQAUA + FABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFADJI45o3i + lRJIpUaOSORQ6SRuCro6sCrI6kqysCGBIIINJpSTjJKUZJqSaumno009GmtGnv1Gm4tSi3GUWmpJtNNO + 6aa1TT1TWqep8tfEf4cSeH5Jda0aN5dElfdPAuXk0uRz0PVmsmY4ilOTCSIpT/q5H+DzrJXhHLFYaLlh + ZO84K7eHbf3uk38MnrFvll0lL9ByPPFjYxwuKko4uKtCb0WISW/ZVktZR+1rOP2ox8fr5w+mCgAoAKAC + gAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAo + AKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgD9CK/YD8XCgAoAKACgAoAKACgAoAKACgA + oAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAGSRxzRvFKiSxS + o0ckcih0kRwVdHRgVZWUkMrAggkEYNJpSTjJKUZJqSaumno009GmtGnv1GpSjJSi3GUWpRkm1JSTummt + U09U1qnqfLPxH+HEnh+STWdGjeXQ5X3TwDc8mlSO3CseWaydjiKUkmIkQzEkxySfB51krwjlisNFywsn + ecFdvDtv73Sb+GT1i3yy6Sl+g5HnixqjhcVJRxcVaE3ZLEJLddFVS1lFaSV5x+1GPkFfOH0wUAFABQAU + AFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFA + BQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQB+hFfsB+LhQAUAFABQAUAFABQAUAFABQAUAF + ABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAySOOaOSKZElil + Ro5Y5FDxyRuCro6MCrI6kqysCGBIIINJpSTjJKUZJqSaumno009GmtGnv1GpSjJSi3GUWpRkm1JSTumm + tU09U1qnqfLPxH+HEnh+STWdGjeXQ5X3TwDc8mlSO3CseWaydjiKUkmIkQzEkxySfBZ1kssHKWJw0XLC + yd5RV28PJvZ9XSbdoyesX7k9eWU/0LI88jjYxwuKko4uKtGT0WJiluuiqpK84faV5w05ow8gr50+lCgA + oAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAK + ACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoA/Qiv2A/FwoAKACgAoAKACgAoAKACgAoA + KACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAGSRxzRyR + TIksUqNHLHIoeOSNwVdHRgVZHUlWVgQwJBBBpSSknGSUoyTUoySakmrNNPRprRp6NbjjKUZKUZOMotSj + KLalGSd1JNapp6pp3T1Plj4j/DmTw9JJrOjRvLocr5mhXc8mlSO33WJyzWTscQzEkxMRDMcmOSX4LOsl + lg5SxOGi5YWTvKOrlh5N7Pq6TbtGbu4v3Zu/LKf6FkeeRxsY4XFSUcZFe7J2UcTFLVroqqWs4LSSvOCt + zRh5DXzp9KFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUA + FABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFAH6EV+wH4uFABQAUAFABQAU + AFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFA + BQAUAMljjmjkhmjSWKVGjlikUPHJG4KujowKujqSrKwIYEggg0pJSTjJKUZJqUZJNSTVmmno01o09Gtx + xlKMlKMnGUWpRlFtSjJO6kmtU09U07p6nyx8R/hxJ4ekk1nRo3l0OV8zQjc8mlSO3CuTlmsnY4hmYkxE + iGYkmOSX4LOsllg5SxOGi5YWTvKOrlh5N7Pq6TbtGbu4v3Zu/LKf6FkeeRxsY4XFSUcZFe7J2UcTFLVr + oqqWs4LSSvOCtzRh5DXzp9KFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAF + ABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAfoRX7Afi4UA + FABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFAB + QAUAFABQAUAFABQAUAMlijnjkhmjSWKVGjlikVXjkjdSrpIjAq6OpKsrAhgSCCDSklJOMkpRkmpRkk1J + NWaaejTWjT0a3HGUoyUoycZRalGUW1KMk7qSa1TT1TTunqfK3xG+HMvh2WTWNHjeXQ5XzLENzyaXI7cI + 5OWezdjthmbJjJEMzFjHJL8FnWSywcpYnDRcsLJ3lHVyw8m9n1dJt2jN3cX7s3fllP8AQsjzyONjHC4q + SjjIr3ZOyjiYpatdFVS1nBaSV5wVuaMPI6+dPpQoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACg + AoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoA + KAP0Ir9gPxcKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAo + AKACgAoAKACgAoAKACgAoAKACgAoAKACgCOWKOeOSGaNJYZUaOWKRQ8ckbgq6OjAq6OpKsrAggkEEUpJ + STjJKUZJqUZJNSTVmmno01o09GtxxlKMlKMnGUWpRlFtSjJO6kmtU09U07p6nyv8R/hzJ4dlk1jSI3l0 + KZ8yxDc8mlSO3CSE5ZrN2O2CZsmNiIZm3GOSb4LOsmeDk8ThouWEk/ejq3h5N6Jvd0pN2hN35XaE3dxl + P9DyPO1jorDYqSjjIr3ZaJYmKWsl0VWK1nBfErzgrc8YeR186fSBQAUAFABQAUAFABQAUAFABQAUAFAB + QAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAU + AFABQAUAFABQB+hFfsB+LhQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQA + UAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFAEcsUU8UkM8aTQzI0csUqh45I3Uq6SIwKuj + qSrKwIYEggg0pRjKMoySlGScZRkk4yi1ZqSd0002mno1uOMpQlGcZOMotSjKLalGSd1KLWqaeqad09Uf + K3xG+HMvhyWTV9IjebQpnzLGNzyaVI7cRyE5Z7N2O2CdiTGSIZ2LmOSb4HOsllgpPE4ZOWEk/ejq5YeT + ekZPd0m3aE3dptQm+bllP9DyPPI46Kw2Jko4yK92WijiYpayitlVS1nBaSV6kFy80afklfPH0gUAFABQ + AUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUAFABQAUA + FABQAUAFABQAUAFABQAUAFABQAUAFABQB+h91a3Nlc3Fne281peWk0ttdWtzE8NxbXELtHNBPDIqyRTR + SKySRuqujqVYAgiv12nUhVhCrSnGpTqRjUp1ISU4ThNKUZwlFuMoyi04yTaad0z8aqU6lGpUpVoTpVaU + 5U6tOpGUKlOpCTjOE4SSlGcZJxlGSTTTTVyCrICgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKA + CgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAI5Yop4pIZ40mhmRo5 + YpVDxyRupV0kRgVdHUlWVgQwJBBBpSjGUZRklKMk4yjJJxlFqzUk7ppptNPRrccZShKM4ycZRalGUW1K + Mk7qUWtU09U07p6o+VfiN8OpfDksmr6TG8uhTSZkjG55NLkkbiOQnLNaMx2wTsSUJEMzFzHJN8DnWSyw + UnicMnLCSfvR1csPJvSMnu6TbtCbu02oTfNyyn+iZJnccdFYbEyUcZFaS0SxEUtZRWyqpazgrJ6zguXm + jDyWvnj6MKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAK + ACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKAJre3nu54bW1hluLm4ljgt7eCNpZp5pWCRxRRo + GeSSR2CoigszEAAk1M5wpwnUqTjCnCMpznOSjGEYpuUpSbSjGKTbbdkrtl06c6s4UqUJVKlSUYQhCLlO + c5O0YxiruUpNpJJNts//2Q== + + +>>>>>>> Stashed changes + + 25 + + \ No newline at end of file diff --git a/imageEnhancer/imageEnhancer/imageEnhancer.vcxproj b/imageEnhancer/MyGUI/MyGUI.vcxproj similarity index 68% rename from imageEnhancer/imageEnhancer/imageEnhancer.vcxproj rename to imageEnhancer/MyGUI/MyGUI.vcxproj index 901e715..c5ef400 100644 --- a/imageEnhancer/imageEnhancer/imageEnhancer.vcxproj +++ b/imageEnhancer/MyGUI/MyGUI.vcxproj @@ -20,9 +20,10 @@ 15.0 - {5FB20AB1-EFD4-4FC0-9AD3-3E19366FC9AB} - Win32Proj - imageEnhancer + {DF1BCE6D-B074-4C0F-9339-2916E4225333} + v4.6.2 + ManagedCProj + MyGUI 10.0.14393.0 @@ -30,26 +31,28 @@ Application true v141 + true Unicode Application false v141 - true + true Unicode Application true v141 + true Unicode Application false v141 - true + true Unicode @@ -84,77 +87,67 @@ - Use Level3 Disabled - WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + WIN32;_DEBUG;%(PreprocessorDefinitions) C:\Program Files\opencv\build\install\include;%(AdditionalIncludeDirectories) - Console - C:\Program Files\opencv\build\install\bin;C:\Program Files\opencv\build\install\lib;%(AdditionalLibraryDirectories) - opencv_core310d.lib;opencv_highgui310d.lib;opencv_imgcodecs310d.lib;%(AdditionalDependencies) + - Use Level3 Disabled - _DEBUG;_CONSOLE;%(PreprocessorDefinitions) - C:\Program Files\opencv\build\install\include;%(AdditionalIncludeDirectories) + _DEBUG;%(PreprocessorDefinitions) + C:\Program Files\opencv\build\include;D:\University\Assignments\EN4553 - Machine Vision\Project 1\ImageEnhancing\imageEnhancer\MyGUI;%(AdditionalIncludeDirectories) - Console + opencv_core310d.lib;opencv_highgui310d.lib;opencv_imgcodecs310d.lib;opencv_imgproc310d.lib;%(AdditionalDependencies) C:\Program Files\opencv\build\install\bin;C:\Program Files\opencv\build\install\lib;%(AdditionalLibraryDirectories) - opencv_core310d.lib;opencv_highgui310d.lib;opencv_imgcodecs310d.lib;%(AdditionalDependencies) + Windows + main Level3 - Use - MaxSpeed - true - true - WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + WIN32;NDEBUG;%(PreprocessorDefinitions) - Console - true - true + Level3 - Use - MaxSpeed - true - true - NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + NDEBUG;%(PreprocessorDefinitions) - Console - true - true + - + + + + + - - + - - - Create - Create - Create - Create - + + CppForm + + + + + + MyForm.h + diff --git a/imageEnhancer/imageEnhancer/imageEnhancer.vcxproj.filters b/imageEnhancer/MyGUI/MyGUI.vcxproj.filters similarity index 81% rename from imageEnhancer/imageEnhancer/imageEnhancer.vcxproj.filters rename to imageEnhancer/MyGUI/MyGUI.vcxproj.filters index 6287b1f..cc6d14c 100644 --- a/imageEnhancer/imageEnhancer/imageEnhancer.vcxproj.filters +++ b/imageEnhancer/MyGUI/MyGUI.vcxproj.filters @@ -15,22 +15,21 @@ - + + Source Files + - + Header Files - + Header Files - - Source Files - - - Source Files - + + Resource Files + \ No newline at end of file diff --git a/imageEnhancer/MyGUI/MyGUI.vcxproj.user b/imageEnhancer/MyGUI/MyGUI.vcxproj.user new file mode 100644 index 0000000..be25078 --- /dev/null +++ b/imageEnhancer/MyGUI/MyGUI.vcxproj.user @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/imageEnhancer/MyGUI/cache.jpg b/imageEnhancer/MyGUI/cache.jpg new file mode 100644 index 0000000..efbb7e3 Binary files /dev/null and b/imageEnhancer/MyGUI/cache.jpg differ diff --git a/imageEnhancer/MyGUI/exif.cpp b/imageEnhancer/MyGUI/exif.cpp new file mode 100644 index 0000000..8d1431c --- /dev/null +++ b/imageEnhancer/MyGUI/exif.cpp @@ -0,0 +1,898 @@ +/************************************************************************** + exif.cpp -- A simple ISO C++ library to parse basic EXIF + information from a JPEG file. + + Copyright (c) 2010-2015 Mayank Lahiri + mlahiri@gmail.com + All rights reserved (BSD License). + + See exif.h for version history. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + -- Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + -- Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESS + OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN + NO EVENT SHALL THE FREEBSD PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +#include "exif.h" + +#include +#include +#include +#include + +using std::string; + +namespace { + +struct Rational { + uint32_t numerator, denominator; + operator double() const { + if (denominator < 1e-20) { + return 0; + } + return static_cast(numerator) / static_cast(denominator); + } +}; + +// IF Entry +class IFEntry { + public: + using byte_vector = std::vector; + using ascii_vector = std::string; + using short_vector = std::vector; + using long_vector = std::vector; + using rational_vector = std::vector; + + IFEntry() + : tag_(0xFF), format_(0xFF), data_(0), length_(0), val_byte_(nullptr) {} + IFEntry(const IFEntry &) = delete; + IFEntry &operator=(const IFEntry &) = delete; + IFEntry(IFEntry &&other) + : tag_(other.tag_), + format_(other.format_), + data_(other.data_), + length_(other.length_), + val_byte_(other.val_byte_) { + other.tag_ = 0xFF; + other.format_ = 0xFF; + other.data_ = 0; + other.length_ = 0; + other.val_byte_ = nullptr; + } + ~IFEntry() { delete_union(); } + unsigned short tag() const { return tag_; } + void tag(unsigned short tag) { tag_ = tag; } + unsigned short format() const { return format_; } + bool format(unsigned short format) { + switch (format) { + case 0x01: + case 0x02: + case 0x03: + case 0x04: + case 0x05: + case 0x07: + case 0x09: + case 0x0a: + case 0xff: + break; + default: + return false; + } + delete_union(); + format_ = format; + new_union(); + return true; + } + unsigned data() const { return data_; } + void data(unsigned data) { data_ = data; } + unsigned length() const { return length_; } + void length(unsigned length) { length_ = length; } + + // functions to access the data + // + // !! it's CALLER responsibility to check that format !! + // !! is correct before accessing it's field !! + // + // - getters are use here to allow future addition + // of checks if format is correct + byte_vector &val_byte() { return *val_byte_; } + ascii_vector &val_string() { return *val_string_; } + short_vector &val_short() { return *val_short_; } + long_vector &val_long() { return *val_long_; } + rational_vector &val_rational() { return *val_rational_; } + + private: + // Raw fields + unsigned short tag_; + unsigned short format_; + unsigned data_; + unsigned length_; + + // Parsed fields + union { + byte_vector *val_byte_; + ascii_vector *val_string_; + short_vector *val_short_; + long_vector *val_long_; + rational_vector *val_rational_; + }; + + void delete_union() { + switch (format_) { + case 0x1: + delete val_byte_; + val_byte_ = nullptr; + break; + case 0x2: + delete val_string_; + val_string_ = nullptr; + break; + case 0x3: + delete val_short_; + val_short_ = nullptr; + break; + case 0x4: + delete val_long_; + val_long_ = nullptr; + break; + case 0x5: + delete val_rational_; + val_rational_ = nullptr; + break; + case 0xff: + break; + default: + // should not get here + // should I throw an exception or ...? + break; + } + } + void new_union() { + switch (format_) { + case 0x1: + val_byte_ = new byte_vector(); + break; + case 0x2: + val_string_ = new ascii_vector(); + break; + case 0x3: + val_short_ = new short_vector(); + break; + case 0x4: + val_long_ = new long_vector(); + break; + case 0x5: + val_rational_ = new rational_vector(); + break; + case 0xff: + break; + default: + // should not get here + // should I throw an exception or ...? + break; + } + } +}; + +// Helper functions +template +T parse(const unsigned char *buf); + +template <> +uint8_t parse(const unsigned char *buf) { + return *buf; +} + +template <> +uint8_t parse(const unsigned char *buf) { + return *buf; +} + +template <> +uint16_t parse(const unsigned char *buf) { + return (static_cast(buf[0]) << 8) | buf[1]; +} + +template <> +uint16_t parse(const unsigned char *buf) { + return (static_cast(buf[1]) << 8) | buf[0]; +} + +template <> +uint32_t parse(const unsigned char *buf) { + return (static_cast(buf[0]) << 24) | + (static_cast(buf[1]) << 16) | + (static_cast(buf[2]) << 8) | buf[3]; +} + +template <> +uint32_t parse(const unsigned char *buf) { + return (static_cast(buf[3]) << 24) | + (static_cast(buf[2]) << 16) | + (static_cast(buf[1]) << 8) | buf[0]; +} + +template <> +Rational parse(const unsigned char *buf) { + Rational r; + r.numerator = parse(buf); + r.denominator = parse(buf + 4); + return r; +} + +template <> +Rational parse(const unsigned char *buf) { + Rational r; + r.numerator = parse(buf); + r.denominator = parse(buf + 4); + return r; +} + +/** + * Try to read entry.length() values for this entry. + * + * Returns: + * true - entry.length() values were read + * false - something went wrong, vec's content was not touched + */ +template +bool extract_values(C &container, const unsigned char *buf, const unsigned base, + const unsigned len, const IFEntry &entry) { + const unsigned char *data; + uint32_t reversed_data; + // if data fits into 4 bytes, they are stored directly in + // the data field in IFEntry + if (sizeof(T) * entry.length() <= 4) { + if (alignIntel) { + reversed_data = entry.data(); + } else { + reversed_data = entry.data(); + // this reversing works, but is ugly + unsigned char *data = reinterpret_cast(&reversed_data); + unsigned char tmp; + tmp = data[0]; + data[0] = data[3]; + data[3] = tmp; + tmp = data[1]; + data[1] = data[2]; + data[2] = tmp; + } + data = reinterpret_cast(&(reversed_data)); + } else { + data = buf + base + entry.data(); + if (data + sizeof(T) * entry.length() > buf + len) { + return false; + } + } + container.resize(entry.length()); + for (size_t i = 0; i < entry.length(); ++i) { + container[i] = parse(data + sizeof(T) * i); + } + return true; +} + +template +void parseIFEntryHeader(const unsigned char *buf, unsigned short &tag, + unsigned short &format, unsigned &length, + unsigned &data) { + // Each directory entry is composed of: + // 2 bytes: tag number (data field) + // 2 bytes: data format + // 4 bytes: number of components + // 4 bytes: data value or offset to data value + tag = parse(buf); + format = parse(buf + 2); + length = parse(buf + 4); + data = parse(buf + 8); +} + +template +void parseIFEntryHeader(const unsigned char *buf, IFEntry &result) { + unsigned short tag; + unsigned short format; + unsigned length; + unsigned data; + + parseIFEntryHeader(buf, tag, format, length, data); + + result.tag(tag); + result.format(format); + result.length(length); + result.data(data); +} + +template +IFEntry parseIFEntry_temp(const unsigned char *buf, const unsigned offs, + const unsigned base, const unsigned len) { + IFEntry result; + + // check if there even is enough data for IFEntry in the buffer + if (buf + offs + 12 > buf + len) { + result.tag(0xFF); + return result; + } + + parseIFEntryHeader(buf + offs, result); + + // Parse value in specified format + switch (result.format()) { + case 1: + if (!extract_values(result.val_byte(), buf, base, + len, result)) { + result.tag(0xFF); + } + break; + case 2: + // string is basically sequence of uint8_t (well, according to EXIF even + // uint7_t, but + // we don't have that), so just read it as bytes + if (!extract_values(result.val_string(), buf, base, + len, result)) { + result.tag(0xFF); + } + // and cut zero byte at the end, since we don't want that in the + // std::string + if (result.val_string()[result.val_string().length() - 1] == '\0') { + result.val_string().resize(result.val_string().length() - 1); + } + break; + case 3: + if (!extract_values(result.val_short(), buf, base, + len, result)) { + result.tag(0xFF); + } + break; + case 4: + if (!extract_values(result.val_long(), buf, base, + len, result)) { + result.tag(0xFF); + } + break; + case 5: + if (!extract_values(result.val_rational(), buf, + base, len, result)) { + result.tag(0xFF); + } + break; + case 7: + case 9: + case 10: + break; + default: + result.tag(0xFF); + } + return result; +} + +// helper functions for convinience +template +T parse_value(const unsigned char *buf, bool alignIntel) { + if (alignIntel) { + return parse(buf); + } else { + return parse(buf); + } +} + +void parseIFEntryHeader(const unsigned char *buf, bool alignIntel, + unsigned short &tag, unsigned short &format, + unsigned &length, unsigned &data) { + if (alignIntel) { + parseIFEntryHeader(buf, tag, format, length, data); + } else { + parseIFEntryHeader(buf, tag, format, length, data); + } +} + +IFEntry parseIFEntry(const unsigned char *buf, const unsigned offs, + const bool alignIntel, const unsigned base, + const unsigned len) { + if (alignIntel) { + return parseIFEntry_temp(buf, offs, base, len); + } else { + return parseIFEntry_temp(buf, offs, base, len); + } +} +} + +// +// Locates the EXIF segment and parses it using parseFromEXIFSegment +// +int easyexif::EXIFInfo::parseFrom(const unsigned char *buf, unsigned len) { + // Sanity check: all JPEG files start with 0xFFD8. + if (!buf || len < 4) return PARSE_EXIF_ERROR_NO_JPEG; + if (buf[0] != 0xFF || buf[1] != 0xD8) return PARSE_EXIF_ERROR_NO_JPEG; + + // Sanity check: some cameras pad the JPEG image with null bytes at the end. + // Normally, we should able to find the JPEG end marker 0xFFD9 at the end + // of the image, but not always. As long as there are null/0xFF bytes at the + // end of the image buffer, keep decrementing len until an 0xFFD9 is found, + // or some other bytes are. If the first non-zero/0xFF bytes from the end are + // not 0xFFD9, then we can be reasonably sure that the buffer is not a JPEG. + while (len > 2) { + if (buf[len - 1] == 0 || buf[len - 1] == 0xFF) { + len--; + } else { + if (buf[len - 1] != 0xD9 || buf[len - 2] != 0xFF) { + return PARSE_EXIF_ERROR_NO_JPEG; + } else { + break; + } + } + } + clear(); + + // Scan for EXIF header (bytes 0xFF 0xE1) and do a sanity check by + // looking for bytes "Exif\0\0". The marker length data is in Motorola + // byte order, which results in the 'false' parameter to parse16(). + // The marker has to contain at least the TIFF header, otherwise the + // EXIF data is corrupt. So the minimum length specified here has to be: + // 2 bytes: section size + // 6 bytes: "Exif\0\0" string + // 2 bytes: TIFF header (either "II" or "MM" string) + // 2 bytes: TIFF magic (short 0x2a00 in Motorola byte order) + // 4 bytes: Offset to first IFD + // ========= + // 16 bytes + unsigned offs = 0; // current offset into buffer + for (offs = 0; offs < len - 1; offs++) + if (buf[offs] == 0xFF && buf[offs + 1] == 0xE1) break; + if (offs + 4 > len) return PARSE_EXIF_ERROR_NO_EXIF; + offs += 2; + unsigned short section_length = parse_value(buf + offs, false); + if (offs + section_length > len || section_length < 16) + return PARSE_EXIF_ERROR_CORRUPT; + offs += 2; + + return parseFromEXIFSegment(buf + offs, len - offs); +} + +int easyexif::EXIFInfo::parseFrom(const string &data) { + return parseFrom( + reinterpret_cast(data.data()), static_cast(data.length())); +} + +// +// Main parsing function for an EXIF segment. +// +// PARAM: 'buf' start of the EXIF TIFF, which must be the bytes "Exif\0\0". +// PARAM: 'len' length of buffer +// +int easyexif::EXIFInfo::parseFromEXIFSegment(const unsigned char *buf, + unsigned len) { + bool alignIntel = true; // byte alignment (defined in EXIF header) + unsigned offs = 0; // current offset into buffer + if (!buf || len < 6) return PARSE_EXIF_ERROR_NO_EXIF; + + if (!std::equal(buf, buf + 6, "Exif\0\0")) return PARSE_EXIF_ERROR_NO_EXIF; + offs += 6; + + // Now parsing the TIFF header. The first two bytes are either "II" or + // "MM" for Intel or Motorola byte alignment. Sanity check by parsing + // the unsigned short that follows, making sure it equals 0x2a. The + // last 4 bytes are an offset into the first IFD, which are added to + // the global offset counter. For this block, we expect the following + // minimum size: + // 2 bytes: 'II' or 'MM' + // 2 bytes: 0x002a + // 4 bytes: offset to first IDF + // ----------------------------- + // 8 bytes + if (offs + 8 > len) return PARSE_EXIF_ERROR_CORRUPT; + unsigned tiff_header_start = offs; + if (buf[offs] == 'I' && buf[offs + 1] == 'I') + alignIntel = true; + else { + if (buf[offs] == 'M' && buf[offs + 1] == 'M') + alignIntel = false; + else + return PARSE_EXIF_ERROR_UNKNOWN_BYTEALIGN; + } + this->ByteAlign = alignIntel; + offs += 2; + if (0x2a != parse_value(buf + offs, alignIntel)) + return PARSE_EXIF_ERROR_CORRUPT; + offs += 2; + unsigned first_ifd_offset = parse_value(buf + offs, alignIntel); + offs += first_ifd_offset - 4; + if (offs >= len) return PARSE_EXIF_ERROR_CORRUPT; + + // Now parsing the first Image File Directory (IFD0, for the main image). + // An IFD consists of a variable number of 12-byte directory entries. The + // first two bytes of the IFD section contain the number of directory + // entries in the section. The last 4 bytes of the IFD contain an offset + // to the next IFD, which means this IFD must contain exactly 6 + 12 * num + // bytes of data. + if (offs + 2 > len) return PARSE_EXIF_ERROR_CORRUPT; + int num_entries = parse_value(buf + offs, alignIntel); + if (offs + 6 + 12 * num_entries > len) return PARSE_EXIF_ERROR_CORRUPT; + offs += 2; + unsigned exif_sub_ifd_offset = len; + unsigned gps_sub_ifd_offset = len; + while (--num_entries >= 0) { + IFEntry result = + parseIFEntry(buf, offs, alignIntel, tiff_header_start, len); + offs += 12; + switch (result.tag()) { + case 0x102: + // Bits per sample + if (result.format() == 3 && result.val_short().size()) + this->BitsPerSample = result.val_short().front(); + break; + + case 0x10E: + // Image description + if (result.format() == 2) this->ImageDescription = result.val_string(); + break; + + case 0x10F: + // Digicam make + if (result.format() == 2) this->Make = result.val_string(); + break; + + case 0x110: + // Digicam model + if (result.format() == 2) this->Model = result.val_string(); + break; + + case 0x112: + // Orientation of image + if (result.format() == 3 && result.val_short().size()) + this->Orientation = result.val_short().front(); + break; + + case 0x131: + // Software used for image + if (result.format() == 2) this->Software = result.val_string(); + break; + + case 0x132: + // EXIF/TIFF date/time of image modification + if (result.format() == 2) this->DateTime = result.val_string(); + break; + + case 0x8298: + // Copyright information + if (result.format() == 2) this->Copyright = result.val_string(); + break; + + case 0x8825: + // GPS IFS offset + gps_sub_ifd_offset = tiff_header_start + result.data(); + break; + + case 0x8769: + // EXIF SubIFD offset + exif_sub_ifd_offset = tiff_header_start + result.data(); + break; + } + } + + // Jump to the EXIF SubIFD if it exists and parse all the information + // there. Note that it's possible that the EXIF SubIFD doesn't exist. + // The EXIF SubIFD contains most of the interesting information that a + // typical user might want. + if (exif_sub_ifd_offset + 4 <= len) { + offs = exif_sub_ifd_offset; + int num_entries = parse_value(buf + offs, alignIntel); + if (offs + 6 + 12 * num_entries > len) return PARSE_EXIF_ERROR_CORRUPT; + offs += 2; + while (--num_entries >= 0) { + IFEntry result = + parseIFEntry(buf, offs, alignIntel, tiff_header_start, len); + switch (result.tag()) { + case 0x829a: + // Exposure time in seconds + if (result.format() == 5 && result.val_rational().size()) + this->ExposureTime = result.val_rational().front(); + break; + + case 0x829d: + // FNumber + if (result.format() == 5 && result.val_rational().size()) + this->FNumber = result.val_rational().front(); + break; + + case 0x8827: + // ISO Speed Rating + if (result.format() == 3 && result.val_short().size()) + this->ISOSpeedRatings = result.val_short().front(); + break; + + case 0x9003: + // Original date and time + if (result.format() == 2) + this->DateTimeOriginal = result.val_string(); + break; + + case 0x9004: + // Digitization date and time + if (result.format() == 2) + this->DateTimeDigitized = result.val_string(); + break; + + case 0x9201: + // Shutter speed value + if (result.format() == 5 && result.val_rational().size()) + this->ShutterSpeedValue = result.val_rational().front(); + break; + + case 0x9204: + // Exposure bias value + if (result.format() == 5 && result.val_rational().size()) + this->ExposureBiasValue = result.val_rational().front(); + break; + + case 0x9206: + // Subject distance + if (result.format() == 5 && result.val_rational().size()) + this->SubjectDistance = result.val_rational().front(); + break; + + case 0x9209: + // Flash used + if (result.format() == 3) this->Flash = result.data() ? 1 : 0; + break; + + case 0x920a: + // Focal length + if (result.format() == 5 && result.val_rational().size()) + this->FocalLength = result.val_rational().front(); + break; + + case 0x9207: + // Metering mode + if (result.format() == 3 && result.val_short().size()) + this->MeteringMode = result.val_short().front(); + break; + + case 0x9291: + // Subsecond original time + if (result.format() == 2) + this->SubSecTimeOriginal = result.val_string(); + break; + + case 0xa002: + // EXIF Image width + if (result.format() == 4 && result.val_long().size()) + this->ImageWidth = result.val_long().front(); + if (result.format() == 3 && result.val_short().size()) + this->ImageWidth = result.val_short().front(); + break; + + case 0xa003: + // EXIF Image height + if (result.format() == 4 && result.val_long().size()) + this->ImageHeight = result.val_long().front(); + if (result.format() == 3 && result.val_short().size()) + this->ImageHeight = result.val_short().front(); + break; + + case 0xa20e: + // EXIF Focal plane X-resolution + if (result.format() == 5) { + this->LensInfo.FocalPlaneXResolution = result.val_rational()[0]; + } + break; + + case 0xa20f: + // EXIF Focal plane Y-resolution + if (result.format() == 5) { + this->LensInfo.FocalPlaneYResolution = result.val_rational()[0]; + } + break; + + case 0xa405: + // Focal length in 35mm film + if (result.format() == 3 && result.val_short().size()) + this->FocalLengthIn35mm = result.val_short().front(); + break; + + case 0xa432: + // Focal length and FStop. + if (result.format() == 5) { + int sz = static_cast(result.val_rational().size()); + if (sz) + this->LensInfo.FocalLengthMin = result.val_rational()[0]; + if (sz > 1) + this->LensInfo.FocalLengthMax = result.val_rational()[1]; + if (sz > 2) + this->LensInfo.FStopMin = result.val_rational()[2]; + if (sz > 3) + this->LensInfo.FStopMax = result.val_rational()[3]; + } + break; + + case 0xa433: + // Lens make. + if (result.format() == 2) { + this->LensInfo.Make = result.val_string(); + } + break; + + case 0xa434: + // Lens model. + if (result.format() == 2) { + this->LensInfo.Model = result.val_string(); + } + break; + } + offs += 12; + } + } + + // Jump to the GPS SubIFD if it exists and parse all the information + // there. Note that it's possible that the GPS SubIFD doesn't exist. + if (gps_sub_ifd_offset + 4 <= len) { + offs = gps_sub_ifd_offset; + int num_entries = parse_value(buf + offs, alignIntel); + if (offs + 6 + 12 * num_entries > len) return PARSE_EXIF_ERROR_CORRUPT; + offs += 2; + while (--num_entries >= 0) { + unsigned short tag, format; + unsigned length, data; + parseIFEntryHeader(buf + offs, alignIntel, tag, format, length, data); + switch (tag) { + case 1: + // GPS north or south + this->GeoLocation.LatComponents.direction = *(buf + offs + 8); + if (this->GeoLocation.LatComponents.direction == 0) { + this->GeoLocation.LatComponents.direction = '?'; + } + if ('S' == this->GeoLocation.LatComponents.direction) { + this->GeoLocation.Latitude = -this->GeoLocation.Latitude; + } + break; + + case 2: + // GPS latitude + if ((format == 5 || format == 10) && length == 3) { + this->GeoLocation.LatComponents.degrees = parse_value( + buf + data + tiff_header_start, alignIntel); + this->GeoLocation.LatComponents.minutes = parse_value( + buf + data + tiff_header_start + 8, alignIntel); + this->GeoLocation.LatComponents.seconds = parse_value( + buf + data + tiff_header_start + 16, alignIntel); + this->GeoLocation.Latitude = + this->GeoLocation.LatComponents.degrees + + this->GeoLocation.LatComponents.minutes / 60 + + this->GeoLocation.LatComponents.seconds / 3600; + if ('S' == this->GeoLocation.LatComponents.direction) { + this->GeoLocation.Latitude = -this->GeoLocation.Latitude; + } + } + break; + + case 3: + // GPS east or west + this->GeoLocation.LonComponents.direction = *(buf + offs + 8); + if (this->GeoLocation.LonComponents.direction == 0) { + this->GeoLocation.LonComponents.direction = '?'; + } + if ('W' == this->GeoLocation.LonComponents.direction) { + this->GeoLocation.Longitude = -this->GeoLocation.Longitude; + } + break; + + case 4: + // GPS longitude + if ((format == 5 || format == 10) && length == 3) { + this->GeoLocation.LonComponents.degrees = parse_value( + buf + data + tiff_header_start, alignIntel); + this->GeoLocation.LonComponents.minutes = parse_value( + buf + data + tiff_header_start + 8, alignIntel); + this->GeoLocation.LonComponents.seconds = parse_value( + buf + data + tiff_header_start + 16, alignIntel); + this->GeoLocation.Longitude = + this->GeoLocation.LonComponents.degrees + + this->GeoLocation.LonComponents.minutes / 60 + + this->GeoLocation.LonComponents.seconds / 3600; + if ('W' == this->GeoLocation.LonComponents.direction) + this->GeoLocation.Longitude = -this->GeoLocation.Longitude; + } + break; + + case 5: + // GPS altitude reference (below or above sea level) + this->GeoLocation.AltitudeRef = *(buf + offs + 8); + if (1 == this->GeoLocation.AltitudeRef) { + this->GeoLocation.Altitude = -this->GeoLocation.Altitude; + } + break; + + case 6: + // GPS altitude + if ((format == 5 || format == 10)) { + this->GeoLocation.Altitude = parse_value( + buf + data + tiff_header_start, alignIntel); + if (1 == this->GeoLocation.AltitudeRef) { + this->GeoLocation.Altitude = -this->GeoLocation.Altitude; + } + } + break; + + case 11: + // GPS degree of precision (DOP) + if ((format == 5 || format == 10)) { + this->GeoLocation.DOP = parse_value( + buf + data + tiff_header_start, alignIntel); + } + break; + } + offs += 12; + } + } + + return PARSE_EXIF_SUCCESS; +} + +void easyexif::EXIFInfo::clear() { + // Strings + ImageDescription = ""; + Make = ""; + Model = ""; + Software = ""; + DateTime = ""; + DateTimeOriginal = ""; + DateTimeDigitized = ""; + SubSecTimeOriginal = ""; + Copyright = ""; + + // Shorts / unsigned / double + ByteAlign = 0; + Orientation = 0; + + BitsPerSample = 0; + ExposureTime = 0; + FNumber = 0; + ISOSpeedRatings = 0; + ShutterSpeedValue = 0; + ExposureBiasValue = 0; + SubjectDistance = 0; + FocalLength = 0; + FocalLengthIn35mm = 0; + Flash = 0; + MeteringMode = 0; + ImageWidth = 0; + ImageHeight = 0; + + // Geolocation + GeoLocation.Latitude = 0; + GeoLocation.Longitude = 0; + GeoLocation.Altitude = 0; + GeoLocation.AltitudeRef = 0; + GeoLocation.DOP = 0; + GeoLocation.LatComponents.degrees = 0; + GeoLocation.LatComponents.minutes = 0; + GeoLocation.LatComponents.seconds = 0; + GeoLocation.LatComponents.direction = '?'; + GeoLocation.LonComponents.degrees = 0; + GeoLocation.LonComponents.minutes = 0; + GeoLocation.LonComponents.seconds = 0; + GeoLocation.LonComponents.direction = '?'; + + // LensInfo + LensInfo.FocalLengthMax = 0; + LensInfo.FocalLengthMin = 0; + LensInfo.FStopMax = 0; + LensInfo.FStopMin = 0; + LensInfo.FocalPlaneYResolution = 0; + LensInfo.FocalPlaneXResolution = 0; + LensInfo.Make = ""; + LensInfo.Model = ""; +} diff --git a/imageEnhancer/MyGUI/exif.h b/imageEnhancer/MyGUI/exif.h new file mode 100644 index 0000000..e1c2a64 --- /dev/null +++ b/imageEnhancer/MyGUI/exif.h @@ -0,0 +1,142 @@ +/************************************************************************** + exif.h -- A simple ISO C++ library to parse basic EXIF + information from a JPEG file. + + Based on the description of the EXIF file format at: + -- http://park2.wakwak.com/~tsuruzoh/Computer/Digicams/exif-e.html + -- http://www.media.mit.edu/pia/Research/deepview/exif.html + -- http://www.exif.org/Exif2-2.PDF + + Copyright (c) 2010-2016 Mayank Lahiri + mlahiri@gmail.com + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + -- Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + -- Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESS + OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN + NO EVENT SHALL THE FREEBSD PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +#ifndef __EXIF_H +#define __EXIF_H + +#include + +namespace easyexif { + +// +// Class responsible for storing and parsing EXIF information from a JPEG blob +// +class EXIFInfo { + public: + // Parsing function for an entire JPEG image buffer. + // + // PARAM 'data': A pointer to a JPEG image. + // PARAM 'length': The length of the JPEG image. + // RETURN: PARSE_EXIF_SUCCESS (0) on succes with 'result' filled out + // error code otherwise, as defined by the PARSE_EXIF_ERROR_* macros + int parseFrom(const unsigned char *data, unsigned length); + int parseFrom(const std::string &data); + + // Parsing function for an EXIF segment. This is used internally by parseFrom() + // but can be called for special cases where only the EXIF section is + // available (i.e., a blob starting with the bytes "Exif\0\0"). + int parseFromEXIFSegment(const unsigned char *buf, unsigned len); + + // Set all data members to default values. + void clear(); + + // Data fields filled out by parseFrom() + char ByteAlign; // 0 = Motorola byte alignment, 1 = Intel + std::string ImageDescription; // Image description + std::string Make; // Camera manufacturer's name + std::string Model; // Camera model + unsigned short Orientation; // Image orientation, start of data corresponds to + // 0: unspecified in EXIF data + // 1: upper left of image + // 3: lower right of image + // 6: upper right of image + // 8: lower left of image + // 9: undefined + unsigned short BitsPerSample; // Number of bits per component + std::string Software; // Software used + std::string DateTime; // File change date and time + std::string DateTimeOriginal; // Original file date and time (may not exist) + std::string DateTimeDigitized; // Digitization date and time (may not exist) + std::string SubSecTimeOriginal; // Sub-second time that original picture was taken + std::string Copyright; // File copyright information + double ExposureTime; // Exposure time in seconds + double FNumber; // F/stop + unsigned short ISOSpeedRatings; // ISO speed + double ShutterSpeedValue; // Shutter speed (reciprocal of exposure time) + double ExposureBiasValue; // Exposure bias value in EV + double SubjectDistance; // Distance to focus point in meters + double FocalLength; // Focal length of lens in millimeters + unsigned short FocalLengthIn35mm; // Focal length in 35mm film + char Flash; // 0 = no flash, 1 = flash used + unsigned short MeteringMode; // Metering mode + // 1: average + // 2: center weighted average + // 3: spot + // 4: multi-spot + // 5: multi-segment + unsigned ImageWidth; // Image width reported in EXIF data + unsigned ImageHeight; // Image height reported in EXIF data + struct Geolocation_t { // GPS information embedded in file + double Latitude; // Image latitude expressed as decimal + double Longitude; // Image longitude expressed as decimal + double Altitude; // Altitude in meters, relative to sea level + char AltitudeRef; // 0 = above sea level, -1 = below sea level + double DOP; // GPS degree of precision (DOP) + struct Coord_t { + double degrees; + double minutes; + double seconds; + char direction; + } LatComponents, LonComponents; // Latitude, Longitude expressed in deg/min/sec + } GeoLocation; + struct LensInfo_t { // Lens information + double FStopMin; // Min aperture (f-stop) + double FStopMax; // Max aperture (f-stop) + double FocalLengthMin; // Min focal length (mm) + double FocalLengthMax; // Max focal length (mm) + double FocalPlaneXResolution; // Focal plane X-resolution + double FocalPlaneYResolution; // Focal plane Y-resolution + std::string Make; // Lens manufacturer + std::string Model; // Lens model + } LensInfo; + + + EXIFInfo() { + clear(); + } +}; + +} + +// Parse was successful +#define PARSE_EXIF_SUCCESS 0 +// No JPEG markers found in buffer, possibly invalid JPEG file +#define PARSE_EXIF_ERROR_NO_JPEG 1982 +// No EXIF header found in JPEG file. +#define PARSE_EXIF_ERROR_NO_EXIF 1983 +// Byte alignment specified in EXIF file was unknown (not Motorola or Intel). +#define PARSE_EXIF_ERROR_UNKNOWN_BYTEALIGN 1984 +// EXIF header was found, but data was corrupted. +#define PARSE_EXIF_ERROR_CORRUPT 1985 + +#endif diff --git a/imageEnhancer/MyGUI/spline.h b/imageEnhancer/MyGUI/spline.h new file mode 100644 index 0000000..28e3dea --- /dev/null +++ b/imageEnhancer/MyGUI/spline.h @@ -0,0 +1,404 @@ +/* + * spline.h + * + * simple cubic spline interpolation library without external + * dependencies + * + * --------------------------------------------------------------------- + * Copyright (C) 2011, 2014 Tino Kluge (ttk448 at gmail.com) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * --------------------------------------------------------------------- + * + */ + + +#ifndef TK_SPLINE_H +#define TK_SPLINE_H + +#include +#include +#include +#include + + +// unnamed namespace only because the implementation is in this +// header file and we don't want to export symbols to the obj files +namespace +{ + +namespace tk +{ + +// band matrix solver +class band_matrix +{ +private: + std::vector< std::vector > m_upper; // upper band + std::vector< std::vector > m_lower; // lower band +public: + band_matrix() {}; // constructor + band_matrix(int dim, int n_u, int n_l); // constructor + ~band_matrix() {}; // destructor + void resize(int dim, int n_u, int n_l); // init with dim,n_u,n_l + int dim() const; // matrix dimension + int num_upper() const + { + return m_upper.size()-1; + } + int num_lower() const + { + return m_lower.size()-1; + } + // access operator + double & operator () (int i, int j); // write + double operator () (int i, int j) const; // read + // we can store an additional diogonal (in m_lower) + double& saved_diag(int i); + double saved_diag(int i) const; + void lu_decompose(); + std::vector r_solve(const std::vector& b) const; + std::vector l_solve(const std::vector& b) const; + std::vector lu_solve(const std::vector& b, + bool is_lu_decomposed=false); + +}; + + +// spline interpolation +class spline +{ +public: + enum bd_type { + first_deriv = 1, + second_deriv = 2 + }; + +private: + std::vector m_x,m_y; // x,y coordinates of points + // interpolation parameters + // f(x) = a*(x-x_i)^3 + b*(x-x_i)^2 + c*(x-x_i) + y_i + std::vector m_a,m_b,m_c; // spline coefficients + double m_b0, m_c0; // for left extrapol + bd_type m_left, m_right; + double m_left_value, m_right_value; + bool m_force_linear_extrapolation; + +public: + // set default boundary condition to be zero curvature at both ends + spline(): m_left(second_deriv), m_right(second_deriv), + m_left_value(0.0), m_right_value(0.0), + m_force_linear_extrapolation(false) + { + ; + } + + // optional, but if called it has to come be before set_points() + void set_boundary(bd_type left, double left_value, + bd_type right, double right_value, + bool force_linear_extrapolation=false); + void set_points(const std::vector& x, + const std::vector& y, bool cubic_spline=true); + double operator() (double x) const; +}; + + + +// --------------------------------------------------------------------- +// implementation part, which could be separated into a cpp file +// --------------------------------------------------------------------- + + +// band_matrix implementation +// ------------------------- + +band_matrix::band_matrix(int dim, int n_u, int n_l) +{ + resize(dim, n_u, n_l); +} +void band_matrix::resize(int dim, int n_u, int n_l) +{ + assert(dim>0); + assert(n_u>=0); + assert(n_l>=0); + m_upper.resize(n_u+1); + m_lower.resize(n_l+1); + for(size_t i=0; i0) { + return m_upper[0].size(); + } else { + return 0; + } +} + + +// defines the new operator (), so that we can access the elements +// by A(i,j), index going from i=0,...,dim()-1 +double & band_matrix::operator () (int i, int j) +{ + int k=j-i; // what band is the entry + assert( (i>=0) && (i=0) && (j diogonal, k<0 lower left part, k>0 upper right part + if(k>=0) return m_upper[k][i]; + else return m_lower[-k][i]; +} +double band_matrix::operator () (int i, int j) const +{ + int k=j-i; // what band is the entry + assert( (i>=0) && (i=0) && (j diogonal, k<0 lower left part, k>0 upper right part + if(k>=0) return m_upper[k][i]; + else return m_lower[-k][i]; +} +// second diag (used in LU decomposition), saved in m_lower +double band_matrix::saved_diag(int i) const +{ + assert( (i>=0) && (i=0) && (idim(); i++) { + assert(this->operator()(i,i)!=0.0); + this->saved_diag(i)=1.0/this->operator()(i,i); + j_min=std::max(0,i-this->num_lower()); + j_max=std::min(this->dim()-1,i+this->num_upper()); + for(int j=j_min; j<=j_max; j++) { + this->operator()(i,j) *= this->saved_diag(i); + } + this->operator()(i,i)=1.0; // prevents rounding errors + } + + // Gauss LR-Decomposition + for(int k=0; kdim(); k++) { + i_max=std::min(this->dim()-1,k+this->num_lower()); // num_lower not a mistake! + for(int i=k+1; i<=i_max; i++) { + assert(this->operator()(k,k)!=0.0); + x=-this->operator()(i,k)/this->operator()(k,k); + this->operator()(i,k)=-x; // assembly part of L + j_max=std::min(this->dim()-1,k+this->num_upper()); + for(int j=k+1; j<=j_max; j++) { + // assembly part of R + this->operator()(i,j)=this->operator()(i,j)+x*this->operator()(k,j); + } + } + } +} +// solves Ly=b +std::vector band_matrix::l_solve(const std::vector& b) const +{ + assert( this->dim()==(int)b.size() ); + std::vector x(this->dim()); + int j_start; + double sum; + for(int i=0; idim(); i++) { + sum=0; + j_start=std::max(0,i-this->num_lower()); + for(int j=j_start; joperator()(i,j)*x[j]; + x[i]=(b[i]*this->saved_diag(i)) - sum; + } + return x; +} +// solves Rx=y +std::vector band_matrix::r_solve(const std::vector& b) const +{ + assert( this->dim()==(int)b.size() ); + std::vector x(this->dim()); + int j_stop; + double sum; + for(int i=this->dim()-1; i>=0; i--) { + sum=0; + j_stop=std::min(this->dim()-1,i+this->num_upper()); + for(int j=i+1; j<=j_stop; j++) sum += this->operator()(i,j)*x[j]; + x[i]=( b[i] - sum ) / this->operator()(i,i); + } + return x; +} + +std::vector band_matrix::lu_solve(const std::vector& b, + bool is_lu_decomposed) +{ + assert( this->dim()==(int)b.size() ); + std::vector x,y; + if(is_lu_decomposed==false) { + this->lu_decompose(); + } + y=this->l_solve(b); + x=this->r_solve(y); + return x; +} + + + + +// spline implementation +// ----------------------- + +void spline::set_boundary(spline::bd_type left, double left_value, + spline::bd_type right, double right_value, + bool force_linear_extrapolation) +{ + assert(m_x.size()==0); // set_points() must not have happened yet + m_left=left; + m_right=right; + m_left_value=left_value; + m_right_value=right_value; + m_force_linear_extrapolation=force_linear_extrapolation; +} + + +void spline::set_points(const std::vector& x, + const std::vector& y, bool cubic_spline) +{ + assert(x.size()==y.size()); + assert(x.size()>2); + m_x=x; + m_y=y; + int n=x.size(); + // TODO: maybe sort x and y, rather than returning an error + for(int i=0; i rhs(n); + for(int i=1; i::const_iterator it; + it=std::lower_bound(m_x.begin(),m_x.end(),x); + int idx=std::max( int(it-m_x.begin())-1, 0); + + double h=x-m_x[idx]; + double interpol; + if(xm_x[n-1]) { + // extrapolation to the right + interpol=(m_b[n-1]*h + m_c[n-1])*h + m_y[n-1]; + } else { + // interpolation + interpol=((m_a[idx]*h + m_b[idx])*h + m_c[idx])*h + m_y[idx]; + } + return interpol; +} + + +} // namespace tk + + +} // namespace + +#endif /* TK_SPLINE_H */ diff --git a/imageEnhancer/MyGUI/x64/Debug/.NETFramework,Version=v4.6.2.AssemblyAttributes.asm b/imageEnhancer/MyGUI/x64/Debug/.NETFramework,Version=v4.6.2.AssemblyAttributes.asm new file mode 100644 index 0000000..706c4a7 --- /dev/null +++ b/imageEnhancer/MyGUI/x64/Debug/.NETFramework,Version=v4.6.2.AssemblyAttributes.asm @@ -0,0 +1,4 @@ +; Listing generated by Microsoft (R) Optimizing Compiler Version 19.10.25017.0 + +; Generated by VC++ for Common Language Runtime +.file "C:\Users\Nipun Perera\AppData\Local\Temp\.NETFramework,Version=v4.6.2.AssemblyAttributes.cpp" diff --git a/imageEnhancer/MyGUI/x64/Debug/.NETFramework,Version=v4.6.2.AssemblyAttributes.obj b/imageEnhancer/MyGUI/x64/Debug/.NETFramework,Version=v4.6.2.AssemblyAttributes.obj new file mode 100644 index 0000000..701ce87 Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/.NETFramework,Version=v4.6.2.AssemblyAttributes.obj differ diff --git a/imageEnhancer/MyGUI/x64/Debug/ImageEnhancer.obj~Stashed changes b/imageEnhancer/MyGUI/x64/Debug/ImageEnhancer.obj~Stashed changes new file mode 100644 index 0000000..343b5a2 Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/ImageEnhancer.obj~Stashed changes differ diff --git a/imageEnhancer/MyGUI/x64/Debug/MyForm.obj~Stashed changes b/imageEnhancer/MyGUI/x64/Debug/MyForm.obj~Stashed changes new file mode 100644 index 0000000..db1100b Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyForm.obj~Stashed changes differ diff --git a/imageEnhancer/MyGUI/x64/Debug/MyForm.obj~Updated upstream b/imageEnhancer/MyGUI/x64/Debug/MyForm.obj~Updated upstream new file mode 100644 index 0000000..00bdde2 Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyForm.obj~Updated upstream differ diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.ImageEnhancer.resources b/imageEnhancer/MyGUI/x64/Debug/MyGUI.ImageEnhancer.resources new file mode 100644 index 0000000..e9aae1e Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyGUI.ImageEnhancer.resources differ diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.MyForm.resources b/imageEnhancer/MyGUI/x64/Debug/MyGUI.MyForm.resources new file mode 100644 index 0000000..cf194ce Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyGUI.MyForm.resources differ diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.log b/imageEnhancer/MyGUI/x64/Debug/MyGUI.log new file mode 100644 index 0000000..932505b --- /dev/null +++ b/imageEnhancer/MyGUI/x64/Debug/MyGUI.log @@ -0,0 +1,35 @@ +<<<<<<< Updated upstream + MyForm.cpp +d:\university\assignments\en4553 - machine vision\project 1\imageenhancing\imageenhancer\mygui\spline.h(58): warning C4267: 'return': conversion from 'size_t' to 'int', possible loss of data +d:\university\assignments\en4553 - machine vision\project 1\imageenhancing\imageenhancer\mygui\spline.h(62): warning C4267: 'return': conversion from 'size_t' to 'int', possible loss of data +d:\university\assignments\en4553 - machine vision\project 1\imageenhancing\imageenhancer\mygui\spline.h(147): warning C4267: 'return': conversion from 'size_t' to 'int', possible loss of data +d:\university\assignments\en4553 - machine vision\project 1\imageenhancing\imageenhancer\mygui\spline.h(291): warning C4267: 'initializing': conversion from 'size_t' to 'int', possible loss of data +d:\university\assignments\en4553 - machine vision\project 1\imageenhancing\imageenhancer\mygui\MyForm.h(495): warning C4244: 'initializing': conversion from 'double' to 'float', possible loss of data +d:\university\assignments\en4553 - machine vision\project 1\imageenhancing\imageenhancer\mygui\MyForm.h(530): warning C4244: 'initializing': conversion from 'double' to 'float', possible loss of data +d:\university\assignments\en4553 - machine vision\project 1\imageenhancing\imageenhancer\mygui\MyForm.h(563): warning C4244: 'initializing': conversion from 'double' to 'float', possible loss of data +d:\university\assignments\en4553 - machine vision\project 1\imageenhancing\imageenhancer\mygui\MyForm.h(717): warning C4267: 'argument': conversion from 'size_t' to 'int', possible loss of data +d:\university\assignments\en4553 - machine vision\project 1\imageenhancing\imageenhancer\mygui\MyForm.h(718): warning C4244: 'argument': conversion from 'int' to 'float', possible loss of data +c:\program files\opencv\build\include\opencv2\core\cvstd.hpp(599): warning C4793: 'cv::String::String': function compiled as native: + Found an intrinsic not supported in managed code +c:\program files\opencv\build\include\opencv2\core\mat.inl.hpp(392): warning C4793: 'cv::Mat::Mat': function compiled as native: + Found an intrinsic not supported in managed code +c:\program files\opencv\build\include\opencv2\core\fast_math.hpp(204): warning C4793: '`anonymous namespace'::cvRound': function compiled as native: + Found an intrinsic not supported in managed code +c:\program files\opencv\build\include\opencv2\core\fast_math.hpp(205): warning C4793: '`anonymous namespace'::cvRound': function compiled as native: + Found an intrinsic not supported in managed code +c:\program files\opencv\build\include\opencv2\core\mat.inl.hpp(681): warning C4793: 'cv::Mat::release': function compiled as native: + Found an intrinsic not supported in managed code +c:\program files\opencv\build\include\opencv2\core\mat.inl.hpp(1872): warning C4793: 'cv::SparseMat::addref': function compiled as native: + Found an intrinsic not supported in managed code +c:\program files\opencv\build\include\opencv2\core\mat.inl.hpp(3473): warning C4793: 'cv::UMat::addref': function compiled as native: + Found an intrinsic not supported in managed code +c:\program files\opencv\build\include\opencv2\core\ptr.inl.hpp(67): warning C4793: 'cv::detail::PtrOwner::incRef': function compiled as native: + Found an intrinsic not supported in managed code +c:\program files\opencv\build\include\opencv2\core\ptr.inl.hpp(72): warning C4793: 'cv::detail::PtrOwner::decRef': function compiled as native: + Found an intrinsic not supported in managed code +c:\program files\opencv\build\include\opencv2\core\mat.inl.hpp(580): warning C4793: 'cv::Mat::operator=': function compiled as native: + Found an intrinsic not supported in managed code + MyGUI.vcxproj -> D:\University\Assignments\EN4553 - Machine Vision\Project 1\ImageEnhancing\imageEnhancer\x64\Debug\MyGUI.exe +======= + MyGUI.vcxproj -> C:\Users\Nipun Perera\Desktop\imageEnhancer\x64\Debug\MyGUI.exe +>>>>>>> Stashed changes diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/CL.command.1.tlog~Updated upstream b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/CL.command.1.tlog~Updated upstream new file mode 100644 index 0000000..9bb6323 Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/CL.command.1.tlog~Updated upstream differ diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/CL.read.1.tlog~Stashed changes b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/CL.read.1.tlog~Stashed changes new file mode 100644 index 0000000..11480d1 Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/CL.read.1.tlog~Stashed changes differ diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/CL.read.1.tlog~Updated upstream b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/CL.read.1.tlog~Updated upstream new file mode 100644 index 0000000..cbbd5bd Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/CL.read.1.tlog~Updated upstream differ diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/CL.write.1.tlog~Stashed changes b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/CL.write.1.tlog~Stashed changes new file mode 100644 index 0000000..1102669 Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/CL.write.1.tlog~Stashed changes differ diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/CL.write.1.tlog~Updated upstream b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/CL.write.1.tlog~Updated upstream new file mode 100644 index 0000000..29580eb Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/CL.write.1.tlog~Updated upstream differ diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/MyGUI.lastbuildstate b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/MyGUI.lastbuildstate new file mode 100644 index 0000000..7c22c38 --- /dev/null +++ b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/MyGUI.lastbuildstate @@ -0,0 +1,6 @@ +#TargetFrameworkVersion=v4.6.2:PlatformToolSet=v141:EnableManagedIncrementalBuild=true:VCToolArchitecture=Native32Bit:WindowsTargetPlatformVersion=10.0.14393.0 +<<<<<<< Updated upstream +Debug|x64|D:\University\Assignments\EN4553 - Machine Vision\Project 1\ImageEnhancing\imageEnhancer\| +======= +Debug|x64|C:\Users\Nipun Perera\Desktop\imageEnhancer\| +>>>>>>> Stashed changes diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/MyGUI.write.1u.tlog~Stashed changes b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/MyGUI.write.1u.tlog~Stashed changes new file mode 100644 index 0000000..bac946d Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/MyGUI.write.1u.tlog~Stashed changes differ diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/MyGUI.write.1u.tlog~Updated upstream b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/MyGUI.write.1u.tlog~Updated upstream new file mode 100644 index 0000000..bfb2151 Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/MyGUI.write.1u.tlog~Updated upstream differ diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/link.command.1.tlog~Stashed changes b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/link.command.1.tlog~Stashed changes new file mode 100644 index 0000000..3c86670 Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/link.command.1.tlog~Stashed changes differ diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/link.command.1.tlog~Updated upstream b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/link.command.1.tlog~Updated upstream new file mode 100644 index 0000000..8562455 Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/link.command.1.tlog~Updated upstream differ diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/link.read.1.tlog~Stashed changes b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/link.read.1.tlog~Stashed changes new file mode 100644 index 0000000..b24a64c Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/link.read.1.tlog~Stashed changes differ diff --git a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/link.read.1.tlog b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/link.read.1.tlog~Updated upstream similarity index 57% rename from imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/link.read.1.tlog rename to imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/link.read.1.tlog~Updated upstream index 4963113..6c5a9dc 100644 Binary files a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/link.read.1.tlog and b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/link.read.1.tlog~Updated upstream differ diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/link.write.1.tlog~Stashed changes b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/link.write.1.tlog~Stashed changes new file mode 100644 index 0000000..2fd5d32 Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/link.write.1.tlog~Stashed changes differ diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/link.write.1.tlog~Updated upstream b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/link.write.1.tlog~Updated upstream new file mode 100644 index 0000000..9b0c034 Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/link.write.1.tlog~Updated upstream differ diff --git a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/link.command.1.tlog b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/metagen.read.1.tlog similarity index 100% rename from imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/link.command.1.tlog rename to imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/metagen.read.1.tlog diff --git a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/link.read.1.tlog b/imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/metagen.write.1.tlog similarity index 100% rename from imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/link.read.1.tlog rename to imageEnhancer/MyGUI/x64/Debug/MyGUI.tlog/metagen.write.1.tlog diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.vcxproj.GenerateResource.Cache~Stashed changes b/imageEnhancer/MyGUI/x64/Debug/MyGUI.vcxproj.GenerateResource.Cache~Stashed changes new file mode 100644 index 0000000..e340b37 Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyGUI.vcxproj.GenerateResource.Cache~Stashed changes differ diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.vcxproj.GenerateResource.Cache~Updated upstream b/imageEnhancer/MyGUI/x64/Debug/MyGUI.vcxproj.GenerateResource.Cache~Updated upstream new file mode 100644 index 0000000..83e9ccd Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyGUI.vcxproj.GenerateResource.Cache~Updated upstream differ diff --git a/imageEnhancer/MyGUI/x64/Debug/MyGUI.vcxprojResolveAssemblyReference.cache b/imageEnhancer/MyGUI/x64/Debug/MyGUI.vcxprojResolveAssemblyReference.cache new file mode 100644 index 0000000..8476bf9 Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/MyGUI.vcxprojResolveAssemblyReference.cache differ diff --git a/imageEnhancer/MyGUI/x64/Debug/exif.obj b/imageEnhancer/MyGUI/x64/Debug/exif.obj new file mode 100644 index 0000000..f7ef1d0 Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/exif.obj differ diff --git a/imageEnhancer/MyGUI/x64/Debug/vc141.pdb~Stashed changes b/imageEnhancer/MyGUI/x64/Debug/vc141.pdb~Stashed changes new file mode 100644 index 0000000..62bb127 Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/vc141.pdb~Stashed changes differ diff --git a/imageEnhancer/MyGUI/x64/Debug/vc141.pdb~Updated upstream b/imageEnhancer/MyGUI/x64/Debug/vc141.pdb~Updated upstream new file mode 100644 index 0000000..6822911 Binary files /dev/null and b/imageEnhancer/MyGUI/x64/Debug/vc141.pdb~Updated upstream differ diff --git a/imageEnhancer/imageEnhancer.sln b/imageEnhancer/imageEnhancer.sln deleted file mode 100644 index ce0a846..0000000 --- a/imageEnhancer/imageEnhancer.sln +++ /dev/null @@ -1,28 +0,0 @@ - -Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio 15 -VisualStudioVersion = 15.0.26228.4 -MinimumVisualStudioVersion = 10.0.40219.1 -Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "imageEnhancer", "imageEnhancer\imageEnhancer.vcxproj", "{5FB20AB1-EFD4-4FC0-9AD3-3E19366FC9AB}" -EndProject -Global - GlobalSection(SolutionConfigurationPlatforms) = preSolution - Debug|x64 = Debug|x64 - Debug|x86 = Debug|x86 - Release|x64 = Release|x64 - Release|x86 = Release|x86 - EndGlobalSection - GlobalSection(ProjectConfigurationPlatforms) = postSolution - {5FB20AB1-EFD4-4FC0-9AD3-3E19366FC9AB}.Debug|x64.ActiveCfg = Debug|x64 - {5FB20AB1-EFD4-4FC0-9AD3-3E19366FC9AB}.Debug|x64.Build.0 = Debug|x64 - {5FB20AB1-EFD4-4FC0-9AD3-3E19366FC9AB}.Debug|x86.ActiveCfg = Debug|Win32 - {5FB20AB1-EFD4-4FC0-9AD3-3E19366FC9AB}.Debug|x86.Build.0 = Debug|Win32 - {5FB20AB1-EFD4-4FC0-9AD3-3E19366FC9AB}.Release|x64.ActiveCfg = Release|x64 - {5FB20AB1-EFD4-4FC0-9AD3-3E19366FC9AB}.Release|x64.Build.0 = Release|x64 - {5FB20AB1-EFD4-4FC0-9AD3-3E19366FC9AB}.Release|x86.ActiveCfg = Release|Win32 - {5FB20AB1-EFD4-4FC0-9AD3-3E19366FC9AB}.Release|x86.Build.0 = Release|Win32 - EndGlobalSection - GlobalSection(SolutionProperties) = preSolution - HideSolutionNode = FALSE - EndGlobalSection -EndGlobal diff --git a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.log b/imageEnhancer/imageEnhancer/Debug/imageEnhancer.log deleted file mode 100644 index f8192f1..0000000 --- a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.log +++ /dev/null @@ -1 +0,0 @@ -opencv_highgui310d.lib(opencv_highgui310d.dll) : fatal error LNK1112: module machine type 'x64' conflicts with target machine type 'X86' diff --git a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.obj b/imageEnhancer/imageEnhancer/Debug/imageEnhancer.obj deleted file mode 100644 index d0c5773..0000000 Binary files a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.obj and /dev/null differ diff --git a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.pch b/imageEnhancer/imageEnhancer/Debug/imageEnhancer.pch deleted file mode 100644 index cb12427..0000000 Binary files a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.pch and /dev/null differ diff --git a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/CL.command.1.tlog b/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/CL.command.1.tlog deleted file mode 100644 index 367f714..0000000 Binary files a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/CL.command.1.tlog and /dev/null differ diff --git a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/CL.read.1.tlog b/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/CL.read.1.tlog deleted file mode 100644 index 63cfd48..0000000 Binary files a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/CL.read.1.tlog and /dev/null differ diff --git a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/CL.write.1.tlog b/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/CL.write.1.tlog deleted file mode 100644 index 935002d..0000000 Binary files a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/CL.write.1.tlog and /dev/null differ diff --git a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/imageEnhancer.lastbuildstate b/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/imageEnhancer.lastbuildstate deleted file mode 100644 index 7e65037..0000000 --- a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/imageEnhancer.lastbuildstate +++ /dev/null @@ -1,2 +0,0 @@ -#TargetFrameworkVersion=v4.0:PlatformToolSet=v141:EnableManagedIncrementalBuild=false:VCToolArchitecture=Native32Bit:WindowsTargetPlatformVersion=10.0.14393.0 -Debug|Win32|D:\University\Assignments\EN4553 - Machine Vision\Project 1\ImageEnhancing\imageEnhancer\| diff --git a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/link.write.1.tlog b/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/link.write.1.tlog deleted file mode 100644 index 46b134b..0000000 --- a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/link.write.1.tlog +++ /dev/null @@ -1 +0,0 @@ -ÿþ \ No newline at end of file diff --git a/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/unsuccessfulbuild b/imageEnhancer/imageEnhancer/Debug/imageEnhancer.tlog/unsuccessfulbuild deleted file mode 100644 index e69de29..0000000 diff --git a/imageEnhancer/imageEnhancer/Debug/stdafx.obj b/imageEnhancer/imageEnhancer/Debug/stdafx.obj deleted file mode 100644 index 074f315..0000000 Binary files a/imageEnhancer/imageEnhancer/Debug/stdafx.obj and /dev/null differ diff --git a/imageEnhancer/imageEnhancer/Debug/vc141.idb b/imageEnhancer/imageEnhancer/Debug/vc141.idb deleted file mode 100644 index 88a88cd..0000000 Binary files a/imageEnhancer/imageEnhancer/Debug/vc141.idb and /dev/null differ diff --git a/imageEnhancer/imageEnhancer/Debug/vc141.pdb b/imageEnhancer/imageEnhancer/Debug/vc141.pdb deleted file mode 100644 index 7d11bd0..0000000 Binary files a/imageEnhancer/imageEnhancer/Debug/vc141.pdb and /dev/null differ diff --git a/imageEnhancer/imageEnhancer/ReadMe.txt b/imageEnhancer/imageEnhancer/ReadMe.txt deleted file mode 100644 index 930635d..0000000 --- a/imageEnhancer/imageEnhancer/ReadMe.txt +++ /dev/null @@ -1,40 +0,0 @@ -======================================================================== - CONSOLE APPLICATION : imageEnhancer Project Overview -======================================================================== - -AppWizard has created this imageEnhancer application for you. - -This file contains a summary of what you will find in each of the files that -make up your imageEnhancer application. - - -imageEnhancer.vcxproj - This is the main project file for VC++ projects generated using an Application Wizard. - It contains information about the version of Visual C++ that generated the file, and - information about the platforms, configurations, and project features selected with the - Application Wizard. - -imageEnhancer.vcxproj.filters - This is the filters file for VC++ projects generated using an Application Wizard. - It contains information about the association between the files in your project - and the filters. This association is used in the IDE to show grouping of files with - similar extensions under a specific node (for e.g. ".cpp" files are associated with the - "Source Files" filter). - -imageEnhancer.cpp - This is the main application source file. - -///////////////////////////////////////////////////////////////////////////// -Other standard files: - -StdAfx.h, StdAfx.cpp - These files are used to build a precompiled header (PCH) file - named imageEnhancer.pch and a precompiled types file named StdAfx.obj. - -///////////////////////////////////////////////////////////////////////////// -Other notes: - -AppWizard uses "TODO:" comments to indicate parts of the source code you -should add to or customize. - -///////////////////////////////////////////////////////////////////////////// diff --git a/imageEnhancer/imageEnhancer/imageEnhancer.cpp b/imageEnhancer/imageEnhancer/imageEnhancer.cpp deleted file mode 100644 index a2a72a3..0000000 --- a/imageEnhancer/imageEnhancer/imageEnhancer.cpp +++ /dev/null @@ -1,38 +0,0 @@ -//-------------------------------DOCUMENTATION--------------------------------------- -// 13/03/2017 - Nipun - Opening an image within project folder and displaying - - -// Include header files -#include "stdafx.h" -#include -#include -#include -#include -#include - -using namespace cv; -using namespace std; - -// Image read function -int readImage(Mat *mainImage) -{ - string imageName("Images\\flower.jpg"); - *mainImage = imread(imageName.c_str(), IMREAD_COLOR); - return 0; -} - -// Main function -int main(int argc, char** argv) -{ - Mat mainImage; // Declaring the variable to store the image - readImage(&mainImage); // Function call to read the image - if (mainImage.empty()) // Check for invalid input - { - cout << "Could not open or find the image" << endl; - return -1; - } - namedWindow("Original Image", WINDOW_AUTOSIZE); // Create a window for display. - imshow("Original Image", mainImage); // Show our image inside it. - waitKey(0); // Wait for a keystroke in the window - return 0; -} \ No newline at end of file diff --git a/imageEnhancer/imageEnhancer/stdafx.cpp b/imageEnhancer/imageEnhancer/stdafx.cpp deleted file mode 100644 index 8912faa..0000000 --- a/imageEnhancer/imageEnhancer/stdafx.cpp +++ /dev/null @@ -1,8 +0,0 @@ -// stdafx.cpp : source file that includes just the standard includes -// imageEnhancer.pch will be the pre-compiled header -// stdafx.obj will contain the pre-compiled type information - -#include "stdafx.h" - -// TODO: reference any additional headers you need in STDAFX.H -// and not in this file diff --git a/imageEnhancer/imageEnhancer/stdafx.h b/imageEnhancer/imageEnhancer/stdafx.h deleted file mode 100644 index b005a83..0000000 --- a/imageEnhancer/imageEnhancer/stdafx.h +++ /dev/null @@ -1,15 +0,0 @@ -// stdafx.h : include file for standard system include files, -// or project specific include files that are used frequently, but -// are changed infrequently -// - -#pragma once - -#include "targetver.h" - -#include -#include - - - -// TODO: reference additional headers your program requires here diff --git a/imageEnhancer/imageEnhancer/targetver.h b/imageEnhancer/imageEnhancer/targetver.h deleted file mode 100644 index 87c0086..0000000 --- a/imageEnhancer/imageEnhancer/targetver.h +++ /dev/null @@ -1,8 +0,0 @@ -#pragma once - -// Including SDKDDKVer.h defines the highest available Windows platform. - -// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and -// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h. - -#include diff --git a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.log b/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.log deleted file mode 100644 index 79aa026..0000000 --- a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.log +++ /dev/null @@ -1,3 +0,0 @@ - imageEnhancer.cpp - imageEnhancer.vcxproj -> D:\University\Assignments\EN4553 - Machine Vision\Project 1\ImageEnhancing\imageEnhancer\x64\Debug\imageEnhancer.exe - imageEnhancer.vcxproj -> D:\University\Assignments\EN4553 - Machine Vision\Project 1\ImageEnhancing\imageEnhancer\x64\Debug\imageEnhancer.pdb (Partial PDB) diff --git a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.obj b/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.obj deleted file mode 100644 index 1184878..0000000 Binary files a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.obj and /dev/null differ diff --git a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.pch b/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.pch deleted file mode 100644 index f4cf260..0000000 Binary files a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.pch and /dev/null differ diff --git a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/CL.command.1.tlog b/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/CL.command.1.tlog deleted file mode 100644 index 8838d57..0000000 Binary files a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/CL.command.1.tlog and /dev/null differ diff --git a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/CL.read.1.tlog b/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/CL.read.1.tlog deleted file mode 100644 index e3bc009..0000000 Binary files a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/CL.read.1.tlog and /dev/null differ diff --git a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/CL.write.1.tlog b/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/CL.write.1.tlog deleted file mode 100644 index 304d2f2..0000000 Binary files a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/CL.write.1.tlog and /dev/null differ diff --git a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/imageEnhancer.lastbuildstate b/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/imageEnhancer.lastbuildstate deleted file mode 100644 index e960f4d..0000000 --- a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/imageEnhancer.lastbuildstate +++ /dev/null @@ -1,2 +0,0 @@ -#TargetFrameworkVersion=v4.0:PlatformToolSet=v141:EnableManagedIncrementalBuild=false:VCToolArchitecture=Native32Bit:WindowsTargetPlatformVersion=10.0.14393.0 -Debug|x64|D:\University\Assignments\EN4553 - Machine Vision\Project 1\ImageEnhancing\imageEnhancer\| diff --git a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/link.command.1.tlog b/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/link.command.1.tlog deleted file mode 100644 index 0d123d0..0000000 Binary files a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/link.command.1.tlog and /dev/null differ diff --git a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/link.write.1.tlog b/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/link.write.1.tlog deleted file mode 100644 index 6ccb426..0000000 Binary files a/imageEnhancer/imageEnhancer/x64/Debug/imageEnhancer.tlog/link.write.1.tlog and /dev/null differ diff --git a/imageEnhancer/imageEnhancer/x64/Debug/stdafx.obj b/imageEnhancer/imageEnhancer/x64/Debug/stdafx.obj deleted file mode 100644 index 1082015..0000000 Binary files a/imageEnhancer/imageEnhancer/x64/Debug/stdafx.obj and /dev/null differ diff --git a/imageEnhancer/imageEnhancer/x64/Debug/vc141.idb b/imageEnhancer/imageEnhancer/x64/Debug/vc141.idb deleted file mode 100644 index 343eb04..0000000 Binary files a/imageEnhancer/imageEnhancer/x64/Debug/vc141.idb and /dev/null differ diff --git a/imageEnhancer/imageEnhancer/x64/Debug/vc141.pdb b/imageEnhancer/imageEnhancer/x64/Debug/vc141.pdb deleted file mode 100644 index 6d4acc5..0000000 Binary files a/imageEnhancer/imageEnhancer/x64/Debug/vc141.pdb and /dev/null differ diff --git a/imageEnhancer/x64/Debug/MyGUI.exe b/imageEnhancer/x64/Debug/MyGUI.exe new file mode 100644 index 0000000..618a439 Binary files /dev/null and b/imageEnhancer/x64/Debug/MyGUI.exe differ diff --git a/imageEnhancer/x64/Debug/MyGUI.exe.metagen b/imageEnhancer/x64/Debug/MyGUI.exe.metagen new file mode 100644 index 0000000..b21fc87 --- /dev/null +++ b/imageEnhancer/x64/Debug/MyGUI.exe.metagen @@ -0,0 +1,16 @@ + MyGUI.MyForm.resources - Embedded, ContainedInManifestFile, +ImageRuntimeVersion: v4.0.30319 +Assembly MyGUI, Version=0.0.*, Culture=Invariant Language (Invariant Country): + hash=SHA1, flags=PublicKey +Assembly mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089: + hash=None, flags=None +Assembly System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089: + hash=None, flags=None +Assembly System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089: + hash=None, flags=None +Assembly System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a: + hash=None, flags=None +Assembly System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089: + hash=None, flags=None +Assembly System.Xml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089: + hash=None, flags=None diff --git a/imageEnhancer/x64/Debug/MyGUI.pdb~Stashed changes b/imageEnhancer/x64/Debug/MyGUI.pdb~Stashed changes new file mode 100644 index 0000000..00afc26 Binary files /dev/null and b/imageEnhancer/x64/Debug/MyGUI.pdb~Stashed changes differ diff --git a/imageEnhancer/x64/Debug/MyGUI.pdb~Updated upstream b/imageEnhancer/x64/Debug/MyGUI.pdb~Updated upstream new file mode 100644 index 0000000..4d9187f Binary files /dev/null and b/imageEnhancer/x64/Debug/MyGUI.pdb~Updated upstream differ diff --git a/imageEnhancer/x64/Debug/imageEnhancer.exe b/imageEnhancer/x64/Debug/imageEnhancer.exe deleted file mode 100644 index 25fd987..0000000 Binary files a/imageEnhancer/x64/Debug/imageEnhancer.exe and /dev/null differ diff --git a/imageEnhancer/x64/Debug/imageEnhancer.ilk b/imageEnhancer/x64/Debug/imageEnhancer.ilk deleted file mode 100644 index c743427..0000000 Binary files a/imageEnhancer/x64/Debug/imageEnhancer.ilk and /dev/null differ diff --git a/imageEnhancer/x64/Debug/imageEnhancer.pdb b/imageEnhancer/x64/Debug/imageEnhancer.pdb deleted file mode 100644 index 6cc41c0..0000000 Binary files a/imageEnhancer/x64/Debug/imageEnhancer.pdb and /dev/null differ