diff --git a/ESPressif.ico b/ESPressif.ico new file mode 100644 index 0000000..7594c5b Binary files /dev/null and b/ESPressif.ico differ diff --git a/InnoSetup.jpg b/InnoSetup.jpg new file mode 100644 index 0000000..482a3b0 Binary files /dev/null and b/InnoSetup.jpg differ diff --git a/Logo.png b/Logo.png new file mode 100644 index 0000000..b4656af Binary files /dev/null and b/Logo.png differ diff --git a/Presentation.png b/Presentation.png new file mode 100644 index 0000000..689a03e Binary files /dev/null and b/Presentation.png differ diff --git a/Queuebased.jpg b/Queuebased.jpg new file mode 100644 index 0000000..62c1f1a Binary files /dev/null and b/Queuebased.jpg differ diff --git a/Setup.iss b/Setup.iss new file mode 100644 index 0000000..7deede1 --- /dev/null +++ b/Setup.iss @@ -0,0 +1,222 @@ +; Script generated by the Inno Setup Script Wizard. +; SEE THE DOCUMENTATION FOR DETAILS ON CREATING INNO SETUP SCRIPT FILES! +#define ApplicationName 'ESP8266 Wizard' +#define ApplicationVersion '1.4.0' +#define OldAppId '{3793A16D-841C-4E6C-931B-9D5AD44410C9}' +#define Revision 'OpenSource (1.0)' + +[Setup] +; NOTE: The value of AppId uniquely identifies this application. +; Do not use the same AppId value in installers for other applications. +; (To generate a new GUID, click Tools | Generate GUID inside the IDE.) +AppId={#ApplicationName} +AppName={#ApplicationName} +AppVersion={#ApplicationVersion} +AppPublisher=Mathieu St-Laurent - Relentless research lab +DefaultDirName={pf}\Relentless.rad\ESP8266Wizard +DisableDirPage=no +DisableProgramGroupPage=yes +OutputDir=Release +OutputBaseFilename={#ApplicationName} {#ApplicationVersion} - {#Revision} +SetupIconFile=ESPressif.ico +UninstallDisplayIcon=ESPressif.ico +Compression=lzma +SolidCompression=yes +WizardImageFile=WIFI.bmp +WizardSmallImageFile=WIFISmall.bmp + +[Languages] +Name: english; MessagesFile: compiler:Default.isl + +[Files] +Source: _Distrib\*; DestDir: {app}; Flags: ignoreversion recursesubdirs createallsubdirs + +[Run] + +[UninstallRun] + +[Code] +var + LicenseLinkLabel: TLabel; + //VSOptionsPage: TInputOptionWizardPage; + VSIXInstallerPaths: TStrings; + VSVersions: TStrings; + +//procedure ClickVSVersions(Sender: TObject); +//var +// i: Integer; +// f: Boolean; +//begin +// f := False; +// for i := 0 to VSOptionsPage.CheckListBox.Items.Count - 1 do +// if (VSOptionsPage.Values[i]) then +// begin +// f := True; +// break; +// end; +// Wizardform.NextButton.Enabled := f; +//end; + +procedure FillVsVersions(); +var + sRegKey: String; + sRegValue: String; +begin + + //check vs2017 + sRegKey := 'VisualStudio.DTE.15.0'; + if (RegKeyExists(HKCR, sRegKey)) then + begin + sRegKey := 'SOFTWARE\Microsoft\VisualStudio\SxS\VS7'; + if (RegQueryStringValue(HKLM, sRegKey, '15.0', sRegValue)) then + begin + VSVersions.Add('VS2017'); + VSIXInstallerPaths.Add(sRegValue + 'Common7\IDE\'); + end; + end; +end; + +procedure OpenBrowser(Url: string); +var + ErrorCode: Integer; +begin + ShellExec('open', Url, '', '', SW_SHOWNORMAL, ewNoWait, ErrorCode); +end; + +procedure SourcesLinkClick(Sender: TObject); +begin + OpenBrowser('https://www.example.com/'); +end; + +procedure InitializeWizard; +var + //i,ind: Integer; + SourcesLink: TLabel; +begin + LicenseLinkLabel := TLabel.Create(WizardForm); + LicenseLinkLabel.Parent := WizardForm; + LicenseLinkLabel.Left := 8; + LicenseLinkLabel.Top := WizardForm.ClientHeight - LicenseLinkLabel.ClientHeight - 32; + LicenseLinkLabel.Caption := '{#SetupSetting("AppPublisher")}' + #13#10 + 'Revision by : {#Revision}'; + + SourcesLink := TLabel.Create(WizardForm); + SourcesLink.Parent := WizardForm; + SourcesLink.Left := LicenseLinkLabel.Left; + SourcesLink.Top := LicenseLinkLabel.Top + LicenseLinkLabel.Height; + SourcesLink.Caption := 'Get source code'; + SourcesLink.OnClick := @SourcesLinkClick; + SourcesLink.ParentFont := True; + SourcesLink.Font.Style := SourcesLink.Font.Style + [fsUnderline, fsBold]; + SourcesLink.Font.Color := clBlue; + SourcesLink.Cursor := crHand; + + + //VSOptionsPage := CreateInputOptionPage(wpSelectComponents, + // 'Visual Studio version', 'Select version of Visual Studio', 'Select version of Visual Studio', false, false); + //VSOptionsPage.CheckListBox.OnClickCheck := @ClickVSVersions; + + //VSOptionsPage.CheckListBox.Enabled := False; + //for i := 0 to VSVersions.Count - 1 do + //begin + // ind := VSOptionsPage.Add(VSVersions[i]); + // VSOptionsPage.Values[ind] := True; + //end; +end; + +function InitializeSetup: Boolean; +var + sRegKey: String; + sUnInstall: String; + sVersion: String; + Prompt: Integer; + //OLD Versions are deprecated + //VSIXBefore: Boolean; +begin + VSIXInstallerPaths := TStringList.Create(); + VSVersions := TStringList.Create(); + FillVsVersions(); + + sRegKey := 'Software\Microsoft\Windows\CurrentVersion\Uninstall\{#OldAppId}_is1'; + if (RegQueryStringValue(HKLM, sRegKey, 'UninstallString', sUnInstall)) then + RegQueryStringValue(HKLM, sRegKey, 'DisplayVersion', sVersion); + + sRegKey := ExpandConstant('Software\Microsoft\Windows\CurrentVersion\Uninstall\{#SetupSetting("AppId")}_is1'); + if (RegQueryStringValue(HKLM, sRegKey, 'UninstallString', sUnInstall)) then + RegQueryStringValue(HKLM, sRegKey, 'DisplayVersion', sVersion); + + if (sUnInstall <> '') then + begin + if (sVersion > '{#SetupSetting("AppVersion")}') then + begin + MsgBox('Current version of ESP8266 Wizard was newer.'#13'Install will be canceled', mbInformation, MB_OK); + Result:= False; + end else + begin + //OLD Versions are deprecated + //VSIXBefore:=False; + //if (sVersion < '1.2.3') then VSIXBefore:=True; + + if (sVersion = '{#SetupSetting("AppVersion")}') then + Prompt:= MsgBox(ExpandConstant('Same version was detected. Do you want to reinstall it?'), mbInformation, MB_YESNO) + else + Prompt:= MsgBox(ExpandConstant('An older version was detected. Do you want to uninstall it?'), mbInformation, MB_YESNO); + + if (Prompt = IDYES) then + begin + sUnInstall:= RemoveQuotes(sUnInstall); + Exec(ExpandConstant(sUnInstall), '/SILENT', '', SW_SHOW, ewWaitUntilTerminated, Prompt); + + //OLD Versions are deprecated + //if (VSIXBefore) then + //begin + // ExtractTemporaryFiles('{app}\VSIXInstaller.exe*'); + // ExtractTemporaryFiles('{app}\VSIXAssemblies\*'); + // ExtractTemporaryFiles('{app}\PkgdefMgmt.dll'); + // ExtractTemporaryFiles('{app}\VSHiveStub.exe'); + // Exec(ExpandConstant('{tmp}\')+'{app}\VSIXInstaller', '/uninstall:"ESP8266Wizard.Mathieu St-Laurent.2369a963-05dc-4156-8143-c93633763702"', '', SW_SHOW, ewWaitUntilTerminated, Prompt); + //end; + + Result:= True; + end else + Result:= False; + end + end else + Result:= True; +end; + +function PrepareToInstall(var NeedsRestart: Boolean): String; +var + Prompt: Integer; +begin + NeedsRestart := False; + if (VSIXInstallerPaths.Count > 0) then + begin + MsgBox(VSIXInstallerPaths[0], mbInformation, MB_OK); + ExtractTemporaryFiles('{app}\ESP8266Wizard.vsix'); + + MsgBox(ExpandConstant('{tmp}\')+'{app}\ESP8266Wizard.vsix', mbInformation, MB_OK); + + Exec(VSIXInstallerPaths[0] + 'VSIXInstaller', + ExpandConstant('{tmp}\')+'{app}\ESP8266Wizard.vsix', + '', SW_SHOW, ewWaitUntilTerminated, Prompt); + end; + Result:= ''; +end; + +function InitializeUninstall: Boolean; +var + Prompt: Integer; +begin + VSIXInstallerPaths := TStringList.Create(); + VSVersions := TStringList.Create(); + FillVsVersions(); + if (VSIXInstallerPaths.Count > 0) then + begin + Exec(VSIXInstallerPaths[0] + 'VSIXInstaller', + '/uninstall:"ESP8266Wizard.Mathieu St-Laurent.2369a963-05dc-4156-8143-c93633763702"', + '', SW_SHOW, ewWaitUntilTerminated, Prompt); + end; + Result:= True; +end; + + diff --git a/Sources/ESP8266Wizard/ESP8266ClassWizard/ESP8266ClassWizard.cpp b/Sources/ESP8266Wizard/ESP8266ClassWizard/ESP8266ClassWizard.cpp new file mode 100644 index 0000000..64a6c5c --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266ClassWizard/ESP8266ClassWizard.cpp @@ -0,0 +1,106 @@ +#include "stdafx.h" +#include "MyForm.h" + +namespace ESP8266ClassWizard +{ + public ref class ESP8266ClassWizard : public IWizard + { + private: + DTE^ m_dte; + + public: + MyForm MainDlg; + String^ Destination; + String^ ProjectName; + + void virtual BeforeOpeningFile(ProjectItem^ projectItem) { ; } + void virtual ProjectFinishedGenerating(Project^ project) { ; } + void virtual ProjectItemFinishedGenerating(ProjectItem^ projectItem) { ; } + void virtual RunFinished() + { + if (MainDlg.IsFromSdk == true) + { + String^ SDKExample = MainDlg.BaseFolder + MainDlg.SDKREL + "\\" + MainDlg.SDKVER + "\\Examples\\" + MainDlg.SDKEXAMPLE + "\\"; + String^ Filter = "*.c;*.h;*.cpp"; + List^ ExampleFileList = gcnew List(); + + for each (String^ FileFilter in Filter->Split(';')) + ExampleFileList->AddRange(System::IO::Directory::GetFiles(SDKExample, FileFilter, IO::SearchOption::AllDirectories)); + + int SelectItem = 1; + Project^ CurrentProj; + String^ SeekProj = Destination + "\\" + ProjectName + ".vcxproj"; + do + { + CurrentProj = m_dte->Solution->Projects->Item(SelectItem++); + } + while (String::Compare(CurrentProj->FileName, SeekProj, true)); + + CleanNonNeccessary(CurrentProj->ProjectItems); + + for each (String^ Source in ExampleFileList) + { + String^ Destination = Source->Replace(SDKExample, ""); + CurrentProj->ProjectItems->AddFromTemplate(Source, Destination); + } + } + } + + void CleanNonNeccessary(ProjectItems^ BaseItem) + { + for (int i = 1; i <= BaseItem->Count; i++) + { + ProjectItem^ Items = BaseItem->Item(i); + + for (int j = 0; j < Items->FileCount; j++) + if (Items->FileNames[j]->Contains("user_main.c") || Items->FileNames[j]->Contains("user_config.h")) + Items->Delete(); + + if (Items->ProjectItems != nullptr) + CleanNonNeccessary(Items->ProjectItems); + } + } + + void virtual RunStarted(Object^ automationObject, Dictionary^ replacementsDictionary, WizardRunKind runKind, array^ customParams) + { + m_dte = (DTE^)automationObject; + + Destination = replacementsDictionary["$destinationdirectory$"]; + ProjectName = replacementsDictionary["$projectname$"]; + + MainDlg.BaseFolder = (String^)Registry::GetValue("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\ESP8266 Wizard_is1", "InstallLocation", "") + "ESPressif\\"; + if (!IO::Directory::Exists(MainDlg.BaseFolder)) + { + MessageBox::Show("Some folder seem missing, please repair or reinstall"); + throw gcnew WizardBackoutException(""); + } + + /***Secure Tabale Value Between File/New & Recent ***/ + String^ SolutionName = replacementsDictionary["$specifiedsolutionname$"]; + + if (!SolutionName) + SolutionName = replacementsDictionary["$projectname$"]; + + if (!replacementsDictionary["$solutiondirectory$"]->Contains(SolutionName)) + replacementsDictionary["$solutiondirectory$"] += "\\" + SolutionName; + /*** End-Secure **************************************/ + + if (MainDlg.ShowDialog() == DialogResult::Cancel) + { + // Where I delete Project Folder + // After Secure It's gonna be more like this and secure gonna be removed. + // if (replacementsDictionary["$solutiondirectory$"]->Contains(SolutionName)) delete + System::IO::Directory::Delete(replacementsDictionary["$solutiondirectory$"], true); + throw gcnew WizardBackoutException(""); + } + + // add an entry to the dictionary to specify the string used for the $greeting$ token + replacementsDictionary->Add("$SDKREL$", MainDlg.SDKREL); + replacementsDictionary->Add("$SDKVER$", MainDlg.SDKVER); + replacementsDictionary->Add("$ProjectExt$", "vcxproj"); + } + + bool virtual ShouldAddProjectItem(String^ filePath) { return true; } + }; +} + diff --git a/Sources/ESP8266Wizard/ESP8266ClassWizard/ESP8266ClassWizard.snk b/Sources/ESP8266Wizard/ESP8266ClassWizard/ESP8266ClassWizard.snk new file mode 100644 index 0000000..b1f0e99 Binary files /dev/null and b/Sources/ESP8266Wizard/ESP8266ClassWizard/ESP8266ClassWizard.snk differ diff --git a/Sources/ESP8266Wizard/ESP8266ClassWizard/ESP8266ClassWizard.vcxproj b/Sources/ESP8266Wizard/ESP8266ClassWizard/ESP8266ClassWizard.vcxproj new file mode 100644 index 0000000..50563d6 --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266ClassWizard/ESP8266ClassWizard.vcxproj @@ -0,0 +1,187 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + {8DDF788F-D3D5-4E1A-B12F-EAA31859543B} + v4.7.2 + ManagedCProj + ESP8266ClassWizard + 10.0.17763.0 + + + + DynamicLibrary + true + v141 + true + Unicode + + + DynamicLibrary + false + v141 + true + Unicode + + + DynamicLibrary + true + v141 + true + Unicode + + + DynamicLibrary + false + v141 + true + Unicode + + + + + + + + + + + + + + + + + + + + + true + $(RootNamespace).snk + true + + + true + + + false + $(RootNamespace).snk + true + + + false + + + + Level3 + Full + WIN32;_DEBUG;%(PreprocessorDefinitions) + Use + + + + DebugFull + + + "$(TargetFrameworkSDKToolsDirectory)sn.exe" -Ra "$(TargetPath)" "$(LinkKeyFile)" + + + Reassing DLL Extension before VSIX Container + + + + + Level3 + Disabled + _DEBUG;%(PreprocessorDefinitions) + Use + + + + + + + + Level3 + WIN32;NDEBUG;%(PreprocessorDefinitions) + Use + + + + + + "$(TargetFrameworkSDKToolsDirectory)sn.exe" -Ra "$(TargetPath)" "$(LinkKeyFile)" + + + Reassing DLL Extension before VSIX Container + + + + + Level3 + NDEBUG;%(PreprocessorDefinitions) + Use + + + + + + + + false + + + + + + + + + + + + CppForm + + + + + + + + Create + Create + Create + Create + + + + + + + + + + MyForm.h + + + + + + \ No newline at end of file diff --git a/Sources/ESP8266Wizard/ESP8266ClassWizard/ESP8266ClassWizard.vcxproj.filters b/Sources/ESP8266Wizard/ESP8266ClassWizard/ESP8266ClassWizard.vcxproj.filters new file mode 100644 index 0000000..0e10bd2 --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266ClassWizard/ESP8266ClassWizard.vcxproj.filters @@ -0,0 +1,48 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Fichiers d%27en-tête + + + Fichiers d%27en-tête + + + + + Fichiers sources + + + Fichiers sources + + + Fichiers sources + + + + + + Fichiers de ressources + + + + + + Fichiers de ressources + + + \ No newline at end of file diff --git a/Sources/ESP8266Wizard/ESP8266ClassWizard/MyForm.cpp b/Sources/ESP8266Wizard/ESP8266ClassWizard/MyForm.cpp new file mode 100644 index 0000000..96173ad --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266ClassWizard/MyForm.cpp @@ -0,0 +1,2 @@ +#include "stdafx.h" +#include "MyForm.h" diff --git a/Sources/ESP8266Wizard/ESP8266ClassWizard/MyForm.h b/Sources/ESP8266Wizard/ESP8266ClassWizard/MyForm.h new file mode 100644 index 0000000..b4d2196 --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266ClassWizard/MyForm.h @@ -0,0 +1,320 @@ +#pragma once + +namespace ESP8266ClassWizard { + + //using namespace System; + //using namespace System::ComponentModel; + //using namespace System::Collections; + //using namespace System::Windows::Forms; + //using namespace System::Drawing; + + /// + /// Description résumée de MyForm + /// + public ref class MyForm : public Form + { + public: + MyForm(void) + { + InitializeComponent(); + } + + String^ SDKREL; + String^ SDKVER; + String^ SDKEXAMPLE; + String^ BaseFolder; + bool IsFromSdk; + + + protected: + ~MyForm() + { + if (components) delete components; + } + private: + + private: System::Windows::Forms::Label^ Caption; + private: System::Windows::Forms::Button^ BTN_OK; + private: System::Windows::Forms::Button^ BTN_CANCEL; + + private: System::Windows::Forms::GroupBox^ GRP_SDK; + private: System::Windows::Forms::Label^ LBL_SDKVER; + private: System::Windows::Forms::ComboBox^ CMB_SDKVER; + private: System::Windows::Forms::Label^ LBL_SDKREL; + private: System::Windows::Forms::ComboBox^ CMB_SDKREL; + private: System::Windows::Forms::PictureBox^ pictureBox1; + private: System::Windows::Forms::GroupBox^ GRP_PROJ; + private: System::Windows::Forms::Label^ LBL_EXAMPLE; + private: System::Windows::Forms::ComboBox^ CMB_EXAMPLE; + private: System::Windows::Forms::RadioButton^ RAD_PROJECT; + private: System::Windows::Forms::RadioButton^ RAD_EMPTY; + + + protected: + + private: + System::ComponentModel::Container ^components; + +#pragma region Windows Form Designer generated code + void InitializeComponent(void) + { + System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(MyForm::typeid)); + this->BTN_OK = (gcnew System::Windows::Forms::Button()); + this->Caption = (gcnew System::Windows::Forms::Label()); + this->GRP_SDK = (gcnew System::Windows::Forms::GroupBox()); + this->LBL_SDKVER = (gcnew System::Windows::Forms::Label()); + this->CMB_SDKVER = (gcnew System::Windows::Forms::ComboBox()); + this->LBL_SDKREL = (gcnew System::Windows::Forms::Label()); + this->CMB_SDKREL = (gcnew System::Windows::Forms::ComboBox()); + this->pictureBox1 = (gcnew System::Windows::Forms::PictureBox()); + this->GRP_PROJ = (gcnew System::Windows::Forms::GroupBox()); + this->RAD_PROJECT = (gcnew System::Windows::Forms::RadioButton()); + this->RAD_EMPTY = (gcnew System::Windows::Forms::RadioButton()); + this->LBL_EXAMPLE = (gcnew System::Windows::Forms::Label()); + this->CMB_EXAMPLE = (gcnew System::Windows::Forms::ComboBox()); + this->BTN_CANCEL = (gcnew System::Windows::Forms::Button()); + this->GRP_SDK->SuspendLayout(); + (cli::safe_cast(this->pictureBox1))->BeginInit(); + this->GRP_PROJ->SuspendLayout(); + this->SuspendLayout(); + // + // BTN_OK + // + this->BTN_OK->BackColor = System::Drawing::SystemColors::ControlDarkDark; + this->BTN_OK->DialogResult = System::Windows::Forms::DialogResult::OK; + this->BTN_OK->FlatAppearance->BorderColor = System::Drawing::SystemColors::ActiveCaption; + this->BTN_OK->FlatStyle = System::Windows::Forms::FlatStyle::System; + this->BTN_OK->Location = System::Drawing::Point(489, 473); + this->BTN_OK->Name = L"BTN_OK"; + this->BTN_OK->Size = System::Drawing::Size(75, 23); + this->BTN_OK->TabIndex = 6; + this->BTN_OK->Text = L"OK"; + this->BTN_OK->UseVisualStyleBackColor = false; + this->BTN_OK->Click += gcnew System::EventHandler(this, &MyForm::BTN_OK_Click); + // + // Caption + // + this->Caption->BackColor = System::Drawing::SystemColors::MenuHighlight; + this->Caption->BorderStyle = System::Windows::Forms::BorderStyle::FixedSingle; + this->Caption->Font = (gcnew System::Drawing::Font(L"Microsoft Sans Serif", 12, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, + static_cast(0))); + this->Caption->Location = System::Drawing::Point(-2, -2); + this->Caption->Name = L"Caption"; + this->Caption->Size = System::Drawing::Size(663, 28); + this->Caption->TabIndex = 5; + this->Caption->Text = L"Relentless - ESP Wizard"; + this->Caption->TextAlign = System::Drawing::ContentAlignment::MiddleCenter; + // + // GRP_SDK + // + this->GRP_SDK->Controls->Add(this->LBL_SDKVER); + this->GRP_SDK->Controls->Add(this->CMB_SDKVER); + this->GRP_SDK->Controls->Add(this->LBL_SDKREL); + this->GRP_SDK->Controls->Add(this->CMB_SDKREL); + this->GRP_SDK->Location = System::Drawing::Point(19, 34); + this->GRP_SDK->Name = L"GRP_SDK"; + this->GRP_SDK->Size = System::Drawing::Size(271, 78); + this->GRP_SDK->TabIndex = 20; + this->GRP_SDK->TabStop = false; + this->GRP_SDK->Text = L"SDK Selection"; + // + // LBL_SDKVER + // + this->LBL_SDKVER->AutoSize = true; + this->LBL_SDKVER->Location = System::Drawing::Point(11, 50); + this->LBL_SDKVER->Name = L"LBL_SDKVER"; + this->LBL_SDKVER->Size = System::Drawing::Size(67, 13); + this->LBL_SDKVER->TabIndex = 24; + this->LBL_SDKVER->Text = L"SDK Version"; + // + // CMB_SDKVER + // + this->CMB_SDKVER->DropDownStyle = System::Windows::Forms::ComboBoxStyle::DropDownList; + this->CMB_SDKVER->FormattingEnabled = true; + this->CMB_SDKVER->Location = System::Drawing::Point(80, 46); + this->CMB_SDKVER->Name = L"CMB_SDKVER"; + this->CMB_SDKVER->Size = System::Drawing::Size(185, 21); + this->CMB_SDKVER->TabIndex = 23; + this->CMB_SDKVER->SelectedIndexChanged += gcnew System::EventHandler(this, &MyForm::CMB_SDKVER_SelectedIndexChanged); + // + // LBL_SDKREL + // + this->LBL_SDKREL->AutoSize = true; + this->LBL_SDKREL->Location = System::Drawing::Point(7, 23); + this->LBL_SDKREL->Name = L"LBL_SDKREL"; + this->LBL_SDKREL->Size = System::Drawing::Size(71, 13); + this->LBL_SDKREL->TabIndex = 22; + this->LBL_SDKREL->Text = L"SDK Release"; + // + // CMB_SDKREL + // + this->CMB_SDKREL->DropDownStyle = System::Windows::Forms::ComboBoxStyle::DropDownList; + this->CMB_SDKREL->FormattingEnabled = true; + this->CMB_SDKREL->Location = System::Drawing::Point(80, 19); + this->CMB_SDKREL->Name = L"CMB_SDKREL"; + this->CMB_SDKREL->Size = System::Drawing::Size(185, 21); + this->CMB_SDKREL->TabIndex = 21; + this->CMB_SDKREL->SelectedIndexChanged += gcnew System::EventHandler(this, &MyForm::CMB_SDKREL_SelectedIndexChanged); + // + // pictureBox1 + // + this->pictureBox1->Image = (cli::safe_cast(resources->GetObject(L"pictureBox1.Image"))); + this->pictureBox1->Location = System::Drawing::Point(301, 38); + this->pictureBox1->Name = L"pictureBox1"; + this->pictureBox1->Size = System::Drawing::Size(344, 428); + this->pictureBox1->TabIndex = 34; + this->pictureBox1->TabStop = false; + // + // GRP_PROJ + // + this->GRP_PROJ->Controls->Add(this->RAD_PROJECT); + this->GRP_PROJ->Controls->Add(this->RAD_EMPTY); + this->GRP_PROJ->Controls->Add(this->LBL_EXAMPLE); + this->GRP_PROJ->Controls->Add(this->CMB_EXAMPLE); + this->GRP_PROJ->Enabled = false; + this->GRP_PROJ->Location = System::Drawing::Point(19, 118); + this->GRP_PROJ->Name = L"GRP_PROJ"; + this->GRP_PROJ->Size = System::Drawing::Size(271, 100); + this->GRP_PROJ->TabIndex = 25; + this->GRP_PROJ->TabStop = false; + this->GRP_PROJ->Text = L"Project"; + // + // RAD_PROJECT + // + this->RAD_PROJECT->AutoSize = true; + this->RAD_PROJECT->Location = System::Drawing::Point(14, 42); + this->RAD_PROJECT->Name = L"RAD_PROJECT"; + this->RAD_PROJECT->Size = System::Drawing::Size(116, 17); + this->RAD_PROJECT->TabIndex = 26; + this->RAD_PROJECT->Text = L"From SDK Example"; + this->RAD_PROJECT->UseVisualStyleBackColor = true; + // + // RAD_EMPTY + // + this->RAD_EMPTY->AutoSize = true; + this->RAD_EMPTY->Location = System::Drawing::Point(14, 19); + this->RAD_EMPTY->Name = L"RAD_EMPTY"; + this->RAD_EMPTY->Size = System::Drawing::Size(144, 17); + this->RAD_EMPTY->TabIndex = 25; + this->RAD_EMPTY->Text = L"Empty Project (NON-OS) "; + this->RAD_EMPTY->UseVisualStyleBackColor = true; + // + // LBL_EXAMPLE + // + this->LBL_EXAMPLE->AutoSize = true; + this->LBL_EXAMPLE->Location = System::Drawing::Point(42, 68); + this->LBL_EXAMPLE->Name = L"LBL_EXAMPLE"; + this->LBL_EXAMPLE->Size = System::Drawing::Size(59, 13); + this->LBL_EXAMPLE->TabIndex = 24; + this->LBL_EXAMPLE->Text = L"Project List"; + // + // CMB_EXAMPLE + // + this->CMB_EXAMPLE->DropDownStyle = System::Windows::Forms::ComboBoxStyle::DropDownList; + this->CMB_EXAMPLE->FormattingEnabled = true; + this->CMB_EXAMPLE->Location = System::Drawing::Point(102, 65); + this->CMB_EXAMPLE->Name = L"CMB_EXAMPLE"; + this->CMB_EXAMPLE->Size = System::Drawing::Size(150, 21); + this->CMB_EXAMPLE->TabIndex = 23; + this->CMB_EXAMPLE->SelectedIndexChanged += gcnew System::EventHandler(this, &MyForm::CMB_EXAMPLE_SelectedIndexChanged); + // + // BTN_CANCEL + // + this->BTN_CANCEL->BackColor = System::Drawing::SystemColors::ControlDarkDark; + this->BTN_CANCEL->DialogResult = System::Windows::Forms::DialogResult::Cancel; + this->BTN_CANCEL->FlatAppearance->BorderColor = System::Drawing::SystemColors::ActiveCaption; + this->BTN_CANCEL->FlatStyle = System::Windows::Forms::FlatStyle::System; + this->BTN_CANCEL->Location = System::Drawing::Point(570, 473); + this->BTN_CANCEL->Name = L"BTN_CANCEL"; + this->BTN_CANCEL->Size = System::Drawing::Size(75, 23); + this->BTN_CANCEL->TabIndex = 35; + this->BTN_CANCEL->Text = L"Cancel"; + this->BTN_CANCEL->UseVisualStyleBackColor = false; + // + // MyForm + // + this->BackColor = System::Drawing::SystemColors::ControlDarkDark; + this->ClientSize = System::Drawing::Size(658, 508); + this->Controls->Add(this->BTN_CANCEL); + this->Controls->Add(this->GRP_PROJ); + this->Controls->Add(this->pictureBox1); + this->Controls->Add(this->GRP_SDK); + this->Controls->Add(this->BTN_OK); + this->Controls->Add(this->Caption); + this->FormBorderStyle = System::Windows::Forms::FormBorderStyle::None; + this->Name = L"MyForm"; + this->StartPosition = System::Windows::Forms::FormStartPosition::CenterScreen; + this->Load += gcnew System::EventHandler(this, &MyForm::MyForm_Load); + this->GRP_SDK->ResumeLayout(false); + this->GRP_SDK->PerformLayout(); + (cli::safe_cast(this->pictureBox1))->EndInit(); + this->GRP_PROJ->ResumeLayout(false); + this->GRP_PROJ->PerformLayout(); + this->ResumeLayout(false); + + } +#pragma endregion + private: System::Void EDt_CIE_KeyDown(System::Object^ sender, System::Windows::Forms::KeyEventArgs^ e) + { + if (e->KeyCode == Keys::Space) + e->SuppressKeyPress = true; + } + private: System::Void MyForm_Load(System::Object^ sender, System::EventArgs^ e) + { + array^ ReleaseList = System::IO::Directory::GetDirectories(BaseFolder); + + for (int i = 0; i < ReleaseList->Length; i++) + ReleaseList[i] = ReleaseList[i]->Replace(BaseFolder, ""); + + this->CMB_SDKREL->Items->AddRange(ReleaseList); + } + + private: System::Void CMB_SDKREL_SelectedIndexChanged(System::Object^ sender, System::EventArgs^ e) + { + this->LBL_SDKVER->Enabled = true; + this->CMB_SDKVER->Enabled = true; + this->CMB_SDKVER->Items->Clear(); + this->CMB_SDKVER->SelectedIndex = -1; + this->GRP_PROJ->Enabled = false; + this->CMB_EXAMPLE->Items->Clear(); + this->CMB_EXAMPLE->SelectedIndex = -1; + this->RAD_EMPTY->Checked = true; + + array^ VersionList = System::IO::Directory::GetDirectories(BaseFolder + this->CMB_SDKREL->SelectedItem->ToString()); + + for (int i = 0; i < VersionList->Length; i++) + VersionList[i] = VersionList[i]->Replace(BaseFolder + this->CMB_SDKREL->SelectedItem->ToString() + "\\", ""); + + this->CMB_SDKVER->Items->AddRange(VersionList); + } + + private: System::Void CMB_SDKVER_SelectedIndexChanged(System::Object^ sender, System::EventArgs^ e) + { + this->GRP_PROJ->Enabled = true; + this->CMB_EXAMPLE->Items->Clear(); + this->CMB_EXAMPLE->SelectedIndex = -1; + this->RAD_EMPTY->Checked = true; + + String^ SDKExample = BaseFolder + this->CMB_SDKREL->SelectedItem->ToString() + "\\" + this->CMB_SDKVER->SelectedItem->ToString() + "\\Examples\\"; + array^ ExampleList = System::IO::Directory::GetDirectories(SDKExample); + + for (int i = 0; i < ExampleList->Length; i++) + ExampleList[i] = ExampleList[i]->Replace(SDKExample, ""); + + this->CMB_EXAMPLE->Items->AddRange(ExampleList); + } + + private: System::Void CMB_EXAMPLE_SelectedIndexChanged(System::Object^ sender, System::EventArgs^ e) + { + this->RAD_PROJECT->Checked = true; + } + + private: System::Void BTN_OK_Click(System::Object^ sender, System::EventArgs^ e) + { + SDKVER = this->CMB_SDKVER->SelectedItem->ToString(); + SDKREL = this->CMB_SDKREL->SelectedItem->ToString(); + SDKEXAMPLE = CMB_EXAMPLE->SelectedItem ? this->CMB_EXAMPLE->SelectedItem->ToString() : ""; + IsFromSdk = this->RAD_PROJECT->Checked; + } +}; +} diff --git a/Sources/ESP8266Wizard/ESP8266ClassWizard/MyForm.resx b/Sources/ESP8266Wizard/ESP8266ClassWizard/MyForm.resx new file mode 100644 index 0000000..67cdfee --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266ClassWizard/MyForm.resx @@ -0,0 +1,1074 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + /9j/4AAQSkZJRgABAQEASABIAAD/7gAOQWRvYmUAZAAAAAAB/+Ec0EV4aWYAAE1NACoAAAAIAAwBAAAD + AAAAAQK8AAABAQADAAAAAQINAAABAgADAAAAAwAAAJ4BBgADAAAAAQACAAABEgADAAAAAQABAAABFQAD + AAAAAQADAAABGgAFAAAAAQAAAKQBGwAFAAAAAQAAAKwBKAADAAAAAQACAAABMQACAAAAHgAAALQBMgAC + AAAAFAAAANKHaQAEAAAAAQAAAOYAAAESAAgACAAIAEgAAAABAAAASAAAAAEAAEFkb2JlIFBob3Rvc2hv + cCBDUzYgKFdpbmRvd3MpADIwMTY6MDM6MDQgMDA6MjU6MDYAAAOQAAAHAAAABDAyMjGgAgAEAAAAAQAA + AVigAwAEAAAAAQAAAawAAAAAAAAABgEDAAMAAAABAAYAAAEaAAUAAAABAAABYAEbAAUAAAABAAABaAEo + AAMAAAABAAIAAAIBAAQAAAABAAABcAICAAQAAAABAAAbWAAAAAAAAABIAAAAAQAAAEgAAAAB/9j/7QAM + QWRvYmVfQ00AAf/uAA5BZG9iZQBkgAAAAAH/2wCEAAwICAgJCAwJCQwRCwoLERUPDAwPFRgTExUTExgR + DAwMDAwMEQwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwBDQsLDQ4NEA4OEBQODg4UFA4ODg4UEQwM + DAwMEREMDAwMDAwRDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDP/AABEIAKAAgQMBIgACEQEDEQH/ + 3QAEAAn/xAE/AAABBQEBAQEBAQAAAAAAAAADAAECBAUGBwgJCgsBAAEFAQEBAQEBAAAAAAAAAAEAAgME + BQYHCAkKCxAAAQQBAwIEAgUHBggFAwwzAQACEQMEIRIxBUFRYRMicYEyBhSRobFCIyQVUsFiMzRygtFD + ByWSU/Dh8WNzNRaisoMmRJNUZEXCo3Q2F9JV4mXys4TD03Xj80YnlKSFtJXE1OT0pbXF1eX1VmZ2hpam + tsbW5vY3R1dnd4eXp7fH1+f3EQACAgECBAQDBAUGBwcGBTUBAAIRAyExEgRBUWFxIhMFMoGRFKGxQiPB + UtHwMyRi4XKCkkNTFWNzNPElBhaisoMHJjXC0kSTVKMXZEVVNnRl4vKzhMPTdePzRpSkhbSVxNTk9KW1 + xdXl9VZmdoaWprbG1ub2JzdHV2d3h5ent8f/2gAMAwEAAhEDEQA/AOt+sPWb68x/T6BlWW3sNVNWEWCx + rWiu/Jyd9jX/AKRzXsopY1ns9PIs/wAJWuaOda1zsi3KusZQRVbmOrNHUcFxdtr+2MYXfbsR30LK7HXf + 6P8AV7v5zpPrL03GtyqmZmEcunLvaGZIt9H7Pva2nIL7Z2u/maLceqz+fu9Sr+c9D1sHGxbnXYrskWPr + dbndOycq1rq/Uw2sb6F2a+z6Hovd+j9X/Q/8AquTi4jr10dzlPaGGJA14bn8vqqMpHhP+BwcPo/Wf57E + 9h03rLv2Nfl9SIFvThYM19erHek31/tFGjd9eRjOrya/+NQ8PE+sOXVXnZme/AvsLbP2dVXS+mtktd9l + vstqflZF2z9HkX05WN+k/mK6kHG+r9HUPqhV0jPczI9TH2C8sMNdtLKL62XBj92OzZ6L37P5tZ9GP9VK + BXXn9EZT1evbvx6cN7w61v8AhMK6ut9N2O57fUru9X9DX/S/s9nq+nYjfCL7OPn4fdmI6REjVbf4Lq9T + zcq3rdPR2Zn7LrfT67L2tYbsh+59bsXE+113YzfsrWMuy/0V1/6zj+n6PvetDAxc7GNrcnNdnVuINLra + 2Mtbp+kbZZitootZ/ov1Wl9f577lV61l9MYRi9XwX5GC9os9Z2P9pxw8Hb6drKm5FtNjf5z1bqGY/wDw + /qKl0KrFHVXWdDqtx+jmh32hjmPqodkF9f2d2DRkNZt9OluV9qtxmV41vqY389bV+gcxsekUdR6h0yvq + GR1vLofbve9tbcQVtDXvb7fVwrXbGNZ/hHpndU6lmdH6U9mQcazOzPs9mVQxg9Spv2kV5WOzLZkV115z + MenJq9lv6G79HZ/hE/1e+rfRbuj0W5/SsZ+U82OtdfjsNhJssO6z1a/U938pW/rLi15Z6XjW0DJpfnMN + tLmeowsbVkPJtYQ5nps2/wCESUjcc/pnVem0ftO3qDM+yyqzGyW0bwxlb7/teO/DoxHNbRZXXVf6vq1f + rLP5u70vVPl39Qzupv6Zg3nCpxa2WZmWxrX27rC70cXFGQy3HY7ZV6uTbdVd+jsorqr/AEvrUVcrpnT+ + i9T6bndMxW4Tb7/seaMarbW+q2u30DkV49Z27M9mIyrJ/wAF6vp+p6NqpdQ6D0Lp/WL83O6TXkdO6gGu + ffXR6xpyGep6rr6aWPtbRl1vY/7Qxmxl9Vv2r+eqSU6+Zb1Ho3Q83J9Z/VMjHa+yl1rGtdECBe3DZU21 + lPvsf6FDLfR/wfq/THhYfUbq6MzH6+/MDi17oqxn4tjf8K2luPVXksY5v8x/lC30/wDC/afz5dIu6Vj9 + Nybeh4FjcauxzhTVT6BuftZvsxmZX2Ztu5v6P1v5qz0/5xY3U7Pq3k1XWdKwLmdesDjjnHxbsXKF7tK7 + Mi91OO2uv1Hbrrc1/wBl2fzvqpKdfqGXk39aZ0huael1mlt9drG1m7Je51tdlGM7Lrvo24ja67MnbRZk + frNH9Hr/AJ/Q6fi52N6rMrNdnMLgaXW1sZa0R72Wvxm00Xe/+b241Oz/AIVUeqZfT66qsTr+GcmhzGvf + f9mOTjeqPa9rm1tyH47m/TY/Iprq9/6O71PUVXoFOMOqW3dFrto6M6ki2uxtldLsje30n9PxslrPSYyn + 1vtdtDa8bI9TG2erbTd6aUzq6znV/VZvUXFl2Y9/pNdYIYHWZH2OqyxlWzdXT6jHvrZ6fq7P5xn84rVH + TurY11Vjer2ZY3AZFOVXTtc3Te6g4dOJbRc3/B7330/v0/4dY2T01mR9TManKxPXsryanNqtq3ubOY1t + jhW9pc39XfZv/wCB/wCDW/j/AFf6Di3syMbpuJRfWZZbXRWx7SRtlj2MDm+0pKdBJJJJT//Q9Uc1r2lj + wHNcIc0iQQeQQq7Om9PY8PbjVBzYLTsGhH0dv7u1WUkqCRKQ0BIvspJJJJCkkkklKSSVTqXVen9Kxjld + QvbRUDALtS537lbGy+x/8hiQF6BWzbXLfWP6+dO6TvxsPbmZrJDwDFVRH+nt/eb/AKGv/rnoLm+q/W/r + n1lyj0roVNlVLx7q6yBa5s/zmVkA7MTH/qv/AOvW/wAygdM6Z0/Brtyq7cbMswnNGT1W/wD5Mw3GP0eL + X7LOq9QbP6Pb+i9Syj+Yt/R2TCEMeuTU/wCbj/3cv0WIylPSGg/fP/ch6r6t/WnOuqxq+v0OxTnOLcDM + LdlVzj7m0ObO7Hue3+jer/TGfzP6RdUvN8l3rYz6Mp+SzC6kSXuub6vVOpOYS5jcDp3810vCZ/g7PQp9 + Kv0P6N/PLc6X9Z6undQHQeqZXrwGCjMeQ59bnz6fT+rW17qG5zdv6O7f+tf4T9L774yeMmhUtTwxuuGP + X+X/AK7XgGIAJvxL1iSSSauUkkkkpSSSSSn/0fVUkkklKSSSSUpJU+p9W6f0nGOVn3CmvhoOrnO/cqrb + 77X/AMli8+6t9dr+r5BoIfidJDXl2PW8syMmATXjPyqW3fZvXdtb6df6L+cZfmfpFJDFOYMgPTHUlbKc + QQCdTsHovrH9fsHpnq4vTgM7PrkOg/oanD/T2N/nHtd/2np9/wDpPQXG52Xj9YGPldXc6nEY5leb1hx3 + 5Tb3g2/Ycfp1T7G4uLaxrqsb08W6r/tXb6l3rLByM5l5dbXjsxXWGRRTpTVrp9nbLnbtv7/s/ndn85T9 + lXT8t2HkG2ux2NY9prOUwFzmseNlrbK4f62PY136X02faq/57Ff6lfoZEnFiiAI8Ql1n/wCireGZJ4q4 + ekXft6wMB+R0W/pf2XozgaszpzDOYQdtgzLM5jv0+bt2WfZ93oel+q+9VHP6l9WHtzel5LMnpue2MXL2 + h9Fwb7q23UOhlOfhvb9B/p7Hsf8A4P16Kw03YdtzG9Rqe+8Plz67msZbWGNrw8WljKfsmHU+1vrftCvZ + R/O+pZ+l9TD6zH+qed03p2RZ6IzcPOi3qX1fa82taCP6R0vMs9Ox2fTt9Sv/AE39H+0230Y+WjOWPGB6 + dZfzkJeqGb+vGUjL1oiJSJ1FA+kj5of1SGs3JwLfSv6dn2WftIRdZSTd1vKs9zrcHVrK+k4mNs/SPp2Y + 9bK6/Tsq9T1FKl7q6r+jUYuPd+hNd3RaSDg4YcZfk9c6u9vqX51fp/4B/qfq9n5/6dc76ln1W6mzK6de + zqPTOoVuYJOx9tE7b8PMawNvws3Gc7+eYz+c/wAH/PYtdPqHWbszHbgUVMwOk1fzXTqCfT0P85lWu/SZ + t/tb+ku/7b/PTRyvGQYHixmpCcv0eHvGPDLjh/LLj/m1xyiIPF83Z9A+rnX7Ok42Pj9Rzq+p9HsIpxus + 1ztqtHsOHnbi5zK939Gyn/8AXPYu2XhXSOrZHS7nuYxuRi5DdmZhWfzV9fG1/wBLZa3/AAV/5n/Frufq + f9ZwOojouI3Iy+luAOG61s3YwiTj3O3P9XEp+hVc52+v+b/TVJ2XBMEk60OLj+WMh14h+hk/5mRbDLHT + WulPeJJJKsyqSSSSU//S9VSSSSUpcp9Y/r5hdNL8Xp23MzWy1xmaayP9K9v87Y13+Aq/69bQrf10wusZ + fSHDpdzmbAXX0Vna65kfzbXt/Sf9bZ/Pfza8y6dhjKbkPbiZGWylorZXjlrNuRa9tONXZ6of7dz93oV1 + v+h+k/QKfBHERKWSXyfoeezFklMERgPm/SVm5XVOp2WdRzXWZHubUckj9Gwvj08dp/mKN7v8G30/37f9 + IoXdH3Yrcy3Kr+zsvOJkeidzqLjuZScr1BXTkYT7WObZZi2el6n8xk2/4NV9Uxq8a7DycNhewOpfRY+y + uS/S++wRbuyGOZ6Vf/aiv1/Tp/Q0pU5mFRXUx4dntx6W005F9O8Yto9V+Xg0dOutbiZTt17P1rJf+rM/ + m6rPTU+XJKQ4AOCF0IjfJD+qtxwiDxE8Uu5/RLm21vpsNVgAeAHCDLXNP0Lan/4Sl/5j/wDP/SKPuLms + a1z7HmK62Aue8/u11t9z3K1e6u2g49Vbq6aiTjOvf6l1Uhhscbq2Y9V7Lff6tD6WV/8ADfo01AtrwBfh + ixtmS9mMNjX25GZZH6xXg31V1soxMR3v+yUfvs9e6+1mN9mr5MM4anbof/QWWM4y0H8vqwvxrabG4l91 + JA0sqJL20PLosZkWsa9rv9Jf9k/o767f8L/PdRX1rO6J03H6CerteMitj68zHPqtoruG+mp9237RjVMr + /o9LKfVyKfSspy+k11rkGxtGyNvDQONNIj+StPpvVW1Vfs7qDrbek2vrdZQLjUxpY91jd9jK77fsnqvd + ZfTR/LyqP1vYmiYIEZC4jb95NakjcoeqijMzLc3EqsqNzt1jbdm575P6aKBso9Zu2z0X/wA1dv8A0n+E + so1nx0jla1+FZXlsxq7Kst9oD2sxrPWLQ5zhXTe/06t2Ts2fmfpP9FU/9Gux+rf+Ltpc3O622HGCzEB1 + 8nZD/wB7+S33q8c2LHCNEmxpH9Kv+5avDknKQIG+/wCi839W/qj1Drjw9rfRwwYfe4fe2v8AecvUujdC + 6d0XHFGHWAT/ADlp+m4/y3K9XVXVW2uporraIaxoAAHk0KapZc88h10j0iGfHhjDXeXdSSSSiZFJJJJK + f//T9VSSSSUpeX/W+v0vrRk4+DbZ0nPvZW/FfW91NWYHN220PsY5jGZbLfU9C3/Der9n/R3+l9o9QWH9 + cOl9O6h0a37dQy4UQ+tz2yWElrX2M1b+Z+bu96BkY+sfo6/TsqgdD1fLOpW4DuhYPTmZFjcnp4LW4b62 + 1ubk3WvszXvfDbKaqJqprfdajZHUeoDq/pdSuw+pPwt5pDmi7BdbYG+oXMrbW6536TfkZNn6Su6n/R/z + h7MTq3T+o437RrA6thvrPTup2642YIc/HpyLbPT/AFv2O+zX2/8AhbI/SendaHpXSaOrvz7urvGJXg1s + xQx0UEX2veyq3KLWfRxn7vU9n6R76q/9IrMJxkCfPiJozjOf7qwgg19nYxDnvxC5mb6b/teDRa2l+bVo + xxsH6BzWOe65vq+n7P8AB/8AC/za18TqmV1KxtOS/wBTrbWOp6dl3WsxMHExxXtuzKGY/pWftJjfU+hW + /Z/PVf0f0llYPU8uvDswW41Lq3MuosFzPf8Ap/T9R5cz6dtDsav7N/o0Nte8txtrsiwwNoAcZ/N3bvar + XD7kCMmnD8uT96PiwmQhL06380Oy+d06rExbs7DrI6Vi+li49zardma5s15nVPWsfZXR+m2fQ/RP3049 + XvZ6il0D6q9a+s14FTDRiN/nLD7QAfH/AMi39IvQcD6pdT63dT1L62XG01AehhgBjGDx9JsNqe//AAln + 8/8A8R6da7LHx6MaltGOxtVTBDWNEAKgTGJ9NSPf9H/B/eZ9T4D8XJ+r31V6b0Koei31ck/zmS/VxJ+l + tndt/wCrW0kkmeJXKSSSSUpJJJJSkkkklP8A/9T1VJJJJSlC6mq+p9NzBZVYC17HCQQexU0kiL0Knm/r + N9WKeu214l1ZbjOqLW3MiaXs3+k9rf8Arnp+n/N21rznNwhTm19I6hY1+bW0fYOp3taxmSwBzfQyfWde + z1qbmvxsTL3/APdbI9P9BYvalz/WuiYDsBjMymrMYzLbZW26trg0XWj1GN3bvpersTQZQlxR8SUkCQo/ + R856b9W+r9Sy/sldZx4Ja99ksOmj53+72fyP/BF6V9Xfqn03oVYdW31cr87IcNdf9H+4r78Bj8nFyKtt + baA+WBo1Dwzjb/xTVdU2TPkyfNoOwY4Yow21KkkklGvUkkkkpSSSSSlJJJJKUkkkkp//1fVUkkklKVHP + 650bptja+oZtGLY9u5rLbGscWzt3Brj+97VeXmH+NoYf7Swjk2mr9XcRFfqaNfud39n7qMQCdTSJEjYW + 9xR9bfqzk5FWLj9Sx7b73bKq2PBLnHUNbC1X1ssaWWND2nlrhI014K8N+rFVLPrB0xtYLX15lO8y2DL6 + 2t+i1tjt38pz/wDSf4S5e4m+kCTY0AcmQjOIFa3aIkknQimaSw/rD9cOk/V9mM/MFlzct7q6zjhrwHND + XO37rK9v01S6J/jE6H1vqNfTsSrJbda9zGutra1ktZbefc21/wCZQ/8ANTVz1KSzf+cn1dif2rhx4/aK + u/8AbRrOs9IqDDbnY7BY1r2brWDc1w3Mezc73Me36DklWG4kqVHWej5JIx87GuLSxpFdrHQbDtpadjj7 + rXfzf+kV1JSkkkklKSSSSUpJJJJT/9b1VJJJJSl5v/jPsrb1vpNduKMxlrCx9UM3Oa62tjq6nWssdW+x + rtrXsXpC5v6yfV/H6pnU5VuFZlWY1R9F7LGsh27fDW2Nez1Guax/qIxNHa9Oq2QJqjWr5zX06vFyDb9n + tpab2V0OukEMeLf0b7WuZXk2Vsaz32f8IsLNbQbMSxzS11dbDaCxpEtduhgL27tzNu+z/wADXq+V9UmW + AVW499wG23c3IaB6gbb+cKcexza9/wDwf+DQMz6hY2cTflY911lWyqsPyGb3Mb33ei5uxv0vp+/9J7P9 + IyXEZRJr02NGfHMDHkx2R7hjLw9HF+j/AITxHV8h9fQ8C1pbU5+Z1DeNH7GvZjmxjXPLtr9rv0e2ul/+ + E9H8+wP+Leyfrr01oO3c+4uYCSCfs2T7y17n+/Vd8PqRjVY1FVOJbYKA+6ptltRiy8MrvrsFrH17GNw8 + T/Pv/SWK5gfVOnA6tjZVWKZxiXsvD6vpOpuoe1+yii57P0uz/wAFSgCAAQEZ5RnknKN0Tpb5Z06v1H0U + v9PG/RsLrr3NFVYLW7LLXNO70/f+b76/VVv61bXX9MsDNW9KwnHgOA9P2H6f71m32V/9e/0faUf4ucQS + 70cqo/Z2NP60wEua2vbTVspds2up2vs3M/r/AM4iZ/1DqzzV61OUxtGOzEZXXkVR6eOKfs9nvqP6e5vq + tss/4D/RvRAKwvE/VM2M6z0xjbGVVXZ1DjjEAueC17m5Ac0O2Na6hjP8Guqr+sfUaLarcyzKbjmg+o8v + LmeuHNsd9FmJ6bbceyt30/1b3/off6iudO/xeY3Tuo4GdUzIfbjemTN9bmN2u9zHsNFT37N3qeyz3/8A + gd0z9S7cstrvtztgNji+y+gxJj06/wBTs/nIY/0f6Iz33V+ncnxIF+K02W59SepZmbldTqyb33DHGPtD + y4gF7bXP9P1Wss9zW17v5a6tc99U+gDpLsy1wyRblGsO+02V2AisP9N1XoV1el/Oe+v/ANSLoUCbKQpJ + JJBSkkkklP8A/9f1VJJJJSln53XMDByRi3ud6xqdeGNaT+jYHusfP0fb6f8A57/0i0F5/wD4xWsdk5Ic + 0OB6dU0gidHZ2PuH9qEQg3Wj0NX126Ja5raxkuc5u9rRjXSWHQWR6f8AN/y0av62dIey+wm2uvErNt73 + 1PaGtBDP3dz37vzK1x9l+ZVZXfc91ja6XVlrgH7vSdu9Ru2v+d9VljP/AFGh9Qe5vSut1e4M/ZjrBvdu + JPqNb2+htT5QAiT2YxKRIF9Xqx/jB+qRMDOJPh6N0/8AnlHxfrn9Xcu+vGxsl9l1zgxjBTdMnuZq9jG/ + n2P9la8yc7LAxHkjbU11BBDWyHNY6zZZXtez03U1t9q0egXus+sHSrTvLMi/XfGg2PcGhv0/89yqjKSR + oGwcdAm9vB9XVfM6h0/AY1+dk04rHnax11jawTztabHN3OXjeT9YuuU5mS39qZA2XWta1+Q8abjt2sFr + fo/mLQ63muyvqdjWZORZlto6hkUsyHONj7A2ix1e+5+9jt3519G+n/RKeQq61pjgeIi9Ae276bR1/oWR + cyjH6ji3XWGK66763OcY3QxjX7ne1Yx/xg9Ha1jn0ZDRYdrSW1wXaewfpv5TV5j9QPZ9a+nE6ufbDokc + tsdu/lKx1a71K8XZsxa6GjQS99phnqbi8ez1H1+z8yv/AMDUUpHjjGx6uLz0bMMUTgy5DEng4KN+n1yl + H1PsXSup1dUxTlVMfU0WPqLLIDga3Gt/0HP/ADmq4uc+oTnP6BvcQ4vvufubwdzy/wBv+cujToG4gljz + REMk4jYHRSSSScxqSSSSU//Q9VSSSSUpcn9dPqld1p326vqT+n149BbfWys2eo1j/tTN7fXx2u9N9e6v + d+eusSSURb5W36h2NZc9v1hyhXQd1hbjOIlztroNeUfe6Pf/ACP0q1emf4v8gYWc+7rFuQzqGHZiA21S + WAuY9tu37Vax+30n7Gb/APC/4P3rv0krKKfLKPqLW8PLOs37Ws+0vLcQQNA5pf6eQ79K9n0f+urT6B9R + AMvG6pV1a20Yd7XbH44rJ2Ftj2Nd6u5jbW+1egJIcI7LrPd83/5m9Iy8m29mXkhj2PyLGeix4DX/AKY7 + nNc92631P/Pqt9W6Pj9Y6FVg3ZrqyMs3m/7JXXOykVuYaKrMdjv59tvr/pP9H/g13qScSTvqtiBE3HR8 + 26F9SMDo3Uen9Wdn3Wn1N1dJxtpdJFDeLrPb+sss9T9J/wBuK5i/VrBYacENxb7WF9ZtfhWvcdhfTdbc + 6vqX+E9L9J7Nn6Sv9F+kXepJvCOotlGaYFA8IO/COHb+7/ecT6qYVPT8K7EqtF36Z9x2V+kxnqkn0aqj + bkObXXt2t/SrbSSRAA0CyUjImUjZO5UkkkkhSSSSSn//2f/iDFhJQ0NfUFJPRklMRQABAQAADEhMaW5v + AhAAAG1udHJSR0IgWFlaIAfOAAIACQAGADEAAGFjc3BNU0ZUAAAAAElFQyBzUkdCAAAAAAAAAAAAAAAA + AAD21gABAAAAANMtSFAgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAEWNwcnQAAAFQAAAAM2Rlc2MAAAGEAAAAbHd0cHQAAAHwAAAAFGJrcHQAAAIEAAAAFHJYWVoAAAIY + AAAAFGdYWVoAAAIsAAAAFGJYWVoAAAJAAAAAFGRtbmQAAAJUAAAAcGRtZGQAAALEAAAAiHZ1ZWQAAANM + AAAAhnZpZXcAAAPUAAAAJGx1bWkAAAP4AAAAFG1lYXMAAAQMAAAAJHRlY2gAAAQwAAAADHJUUkMAAAQ8 + AAAIDGdUUkMAAAQ8AAAIDGJUUkMAAAQ8AAAIDHRleHQAAAAAQ29weXJpZ2h0IChjKSAxOTk4IEhld2xl + dHQtUGFja2FyZCBDb21wYW55AABkZXNjAAAAAAAAABJzUkdCIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAA + EnNSR0IgSUVDNjE5NjYtMi4xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABYWVogAAAAAAAA81EAAQAAAAEWzFhZWiAAAAAAAAAAAAAAAAAAAAAAWFlaIAAAAAAAAG+i + AAA49QAAA5BYWVogAAAAAAAAYpkAALeFAAAY2lhZWiAAAAAAAAAkoAAAD4QAALbPZGVzYwAAAAAAAAAW + SUVDIGh0dHA6Ly93d3cuaWVjLmNoAAAAAAAAAAAAAAAWSUVDIGh0dHA6Ly93d3cuaWVjLmNoAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRlc2MAAAAAAAAALklFQyA2MTk2 + Ni0yLjEgRGVmYXVsdCBSR0IgY29sb3VyIHNwYWNlIC0gc1JHQgAAAAAAAAAAAAAALklFQyA2MTk2Ni0y + LjEgRGVmYXVsdCBSR0IgY29sb3VyIHNwYWNlIC0gc1JHQgAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZXNj + AAAAAAAAACxSZWZlcmVuY2UgVmlld2luZyBDb25kaXRpb24gaW4gSUVDNjE5NjYtMi4xAAAAAAAAAAAA + AAAsUmVmZXJlbmNlIFZpZXdpbmcgQ29uZGl0aW9uIGluIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAdmlldwAAAAAAE6T+ABRfLgAQzxQAA+3MAAQTCwADXJ4AAAABWFlaIAAAAAAATAlW + AFAAAABXH+dtZWFzAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAACjwAAAAJzaWcgAAAAAENSVCBjdXJ2 + AAAAAAAABAAAAAAFAAoADwAUABkAHgAjACgALQAyADcAOwBAAEUASgBPAFQAWQBeAGMAaABtAHIAdwB8 + AIEAhgCLAJAAlQCaAJ8ApACpAK4AsgC3ALwAwQDGAMsA0ADVANsA4ADlAOsA8AD2APsBAQEHAQ0BEwEZ + AR8BJQErATIBOAE+AUUBTAFSAVkBYAFnAW4BdQF8AYMBiwGSAZoBoQGpAbEBuQHBAckB0QHZAeEB6QHy + AfoCAwIMAhQCHQImAi8COAJBAksCVAJdAmcCcQJ6AoQCjgKYAqICrAK2AsECywLVAuAC6wL1AwADCwMW + AyEDLQM4A0MDTwNaA2YDcgN+A4oDlgOiA64DugPHA9MD4APsA/kEBgQTBCAELQQ7BEgEVQRjBHEEfgSM + BJoEqAS2BMQE0wThBPAE/gUNBRwFKwU6BUkFWAVnBXcFhgWWBaYFtQXFBdUF5QX2BgYGFgYnBjcGSAZZ + BmoGewaMBp0GrwbABtEG4wb1BwcHGQcrBz0HTwdhB3QHhgeZB6wHvwfSB+UH+AgLCB8IMghGCFoIbgiC + CJYIqgi+CNII5wj7CRAJJQk6CU8JZAl5CY8JpAm6Cc8J5Qn7ChEKJwo9ClQKagqBCpgKrgrFCtwK8wsL + CyILOQtRC2kLgAuYC7ALyAvhC/kMEgwqDEMMXAx1DI4MpwzADNkM8w0NDSYNQA1aDXQNjg2pDcMN3g34 + DhMOLg5JDmQOfw6bDrYO0g7uDwkPJQ9BD14Peg+WD7MPzw/sEAkQJhBDEGEQfhCbELkQ1xD1ERMRMRFP + EW0RjBGqEckR6BIHEiYSRRJkEoQSoxLDEuMTAxMjE0MTYxODE6QTxRPlFAYUJxRJFGoUixStFM4U8BUS + FTQVVhV4FZsVvRXgFgMWJhZJFmwWjxayFtYW+hcdF0EXZReJF64X0hf3GBsYQBhlGIoYrxjVGPoZIBlF + GWsZkRm3Gd0aBBoqGlEadxqeGsUa7BsUGzsbYxuKG7Ib2hwCHCocUhx7HKMczBz1HR4dRx1wHZkdwx3s + HhYeQB5qHpQevh7pHxMfPh9pH5Qfvx/qIBUgQSBsIJggxCDwIRwhSCF1IaEhziH7IiciVSKCIq8i3SMK + IzgjZiOUI8Ij8CQfJE0kfCSrJNolCSU4JWgllyXHJfcmJyZXJocmtyboJxgnSSd6J6sn3CgNKD8ocSii + KNQpBik4KWspnSnQKgIqNSpoKpsqzysCKzYraSudK9EsBSw5LG4soizXLQwtQS12Last4S4WLkwugi63 + Lu4vJC9aL5Evxy/+MDUwbDCkMNsxEjFKMYIxujHyMioyYzKbMtQzDTNGM38zuDPxNCs0ZTSeNNg1EzVN + NYc1wjX9Njc2cjauNuk3JDdgN5w31zgUOFA4jDjIOQU5Qjl/Obw5+To2OnQ6sjrvOy07azuqO+g8Jzxl + PKQ84z0iPWE9oT3gPiA+YD6gPuA/IT9hP6I/4kAjQGRApkDnQSlBakGsQe5CMEJyQrVC90M6Q31DwEQD + REdEikTORRJFVUWaRd5GIkZnRqtG8Ec1R3tHwEgFSEtIkUjXSR1JY0mpSfBKN0p9SsRLDEtTS5pL4kwq + THJMuk0CTUpNk03cTiVObk63TwBPSU+TT91QJ1BxULtRBlFQUZtR5lIxUnxSx1MTU19TqlP2VEJUj1Tb + VShVdVXCVg9WXFapVvdXRFeSV+BYL1h9WMtZGllpWbhaB1pWWqZa9VtFW5Vb5Vw1XIZc1l0nXXhdyV4a + XmxevV8PX2Ffs2AFYFdgqmD8YU9homH1YklinGLwY0Njl2PrZEBklGTpZT1lkmXnZj1mkmboZz1nk2fp + aD9olmjsaUNpmmnxakhqn2r3a09rp2v/bFdsr20IbWBtuW4SbmtuxG8eb3hv0XArcIZw4HE6cZVx8HJL + cqZzAXNdc7h0FHRwdMx1KHWFdeF2Pnabdvh3VnezeBF4bnjMeSp5iXnnekZ6pXsEe2N7wnwhfIF84X1B + faF+AX5ifsJ/I3+Ef+WAR4CogQqBa4HNgjCCkoL0g1eDuoQdhICE44VHhauGDoZyhteHO4efiASIaYjO + iTOJmYn+imSKyoswi5aL/IxjjMqNMY2Yjf+OZo7OjzaPnpAGkG6Q1pE/kaiSEZJ6kuOTTZO2lCCUipT0 + lV+VyZY0lp+XCpd1l+CYTJi4mSSZkJn8mmia1ZtCm6+cHJyJnPedZJ3SnkCerp8dn4uf+qBpoNihR6G2 + oiailqMGo3aj5qRWpMelOKWpphqmi6b9p26n4KhSqMSpN6mpqhyqj6sCq3Wr6axcrNCtRK24ri2uoa8W + r4uwALB1sOqxYLHWskuywrM4s660JbSctRO1irYBtnm28Ldot+C4WbjRuUq5wro7urW7LrunvCG8m70V + vY++Cr6Evv+/er/1wHDA7MFnwePCX8Lbw1jD1MRRxM7FS8XIxkbGw8dBx7/IPci8yTrJuco4yrfLNsu2 + zDXMtc01zbXONs62zzfPuNA50LrRPNG+0j/SwdNE08bUSdTL1U7V0dZV1tjXXNfg2GTY6Nls2fHadtr7 + 24DcBdyK3RDdlt4c3qLfKd+v4DbgveFE4cziU+Lb42Pj6+Rz5PzlhOYN5pbnH+ep6DLovOlG6dDqW+rl + 63Dr++yG7RHtnO4o7rTvQO/M8Fjw5fFy8f/yjPMZ86f0NPTC9VD13vZt9vv3ivgZ+Kj5OPnH+lf65/t3 + /Af8mP0p/br+S/7c/23////bAEMABAMDAwMDBAMDBAYEAwQGBwUEBAUHCAYGBwYGCAoICQkJCQgKCgwM + DAwMCgwMDAwMDAwMDAwMDAwMDAwMDAwMDP/bAEMBBAUFCAcIDwoKDxQODg4UFA4ODg4UEQwMDAwMEREM + DAwMDAwRDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDP/AABEIAawBWAMBEQACEQEDEQH/xAAfAAAA + BwEBAQEBAAAAAAAAAAAEBQMCBgEABwgJCgv/xAC1EAACAQMDAgQCBgcDBAIGAnMBAgMRBAAFIRIxQVEG + E2EicYEUMpGhBxWxQiPBUtHhMxZi8CRygvElQzRTkqKyY3PCNUQnk6OzNhdUZHTD0uIIJoMJChgZhJRF + RqS0VtNVKBry4/PE1OT0ZXWFlaW1xdXl9WZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3OEhYaHiImKi4yNjo + +Ck5SVlpeYmZqbnJ2en5KjpKWmp6ipqqusra6vr/xAAfAQACAgMBAQEBAQAAAAAAAAABAAIDBAUGBwgJ + Cgv/xAC1EQACAgECAwUFBAUGBAgDA20BAAIRAwQhEjFBBVETYSIGcYGRMqGx8BTB0eEjQhVSYnLxMyQ0 + Q4IWklMlomOywgdz0jXiRIMXVJMICQoYGSY2RRonZHRVN/Kjs8MoKdPj84SUpLTE1OT0ZXWFlaW1xdXl + 9UZWZnaGlqa2xtbm9kdXZ3eHl6e3x9fn9zhIWGh4iJiouMjY6Pg5SVlpeYmZqbnJ2en5KjpKWmp6ipqq + usra6vr/3QAEACv/2gAMAwEAAhEDEQA/APf2KsK038wItY8y6rpWmWjT6JokbfpDVwf3YuEBJiQftEU3 + zFjqOKZAG0eZd5m7LOHBCczU8h9OPrw/zi+fdf8A+csNZl1tj5bsok0iFmQRXG8snBipPt0zST7VkZek + bPo2l9hsQxfvpHjP83kFt9+bX5b/AJoi3tfzHsrjRtSjHpWmqWrFkj5HuB0374y1eHPtkFHvTi7C1/Zl + y0khkjzlCXVAapZ/mv8AlA8XmLyxrZ8w+R2o0NxGRLAEO4EijcGnfISjn0/qieKLkYMnZvawOHNj8LN1 + HKXwe6/lH+dWjfmVA1jKBZeY7ZQ09ox+Fwf2oz3+WbfSa2ObblJ4Ht72dy9nHiHqxnlL/inqebF5J2Kp + J5q84eWvJOkza35p1KDTNNhBLSzuF5ECvFQd2J7AYq8Wb/nMj8pjIrQW2uz2BFWvk0q4MQ/CpGKvWvIf + 5jeTvzK0ga15P1KO/tAeMyD4JoW/lljPxI3scVZVirzP8wfz8/LH8tLxNM8x6sZNXf8A6VunxNe3Sjxe + OKpUfPFWDxf85kflPyY3lrrtnbjpPLpVxwp4kgbYq9j8oeefKfnzTV1bylq1vqlmQOTQOGZCf2XXqp9j + irIcVeD+Z/8AnK7yF5Z81at5QbTNX1LVNFlEF+dOs5LiNHKhgCUB7HFUs/6HD8k/9Sx5l/7hk/8AzTir + IPJ3/OUv5X+btbtvLkj32g6xelhaRazaSWccrLT4VkkAUsa7Lir2sEEVG4PQ4q8v/Nb89fKP5RXmlaf5 + hgvbq/1nn9RtrCBriV/T3aiqCdqYqwT/AKHG8if9S35k/wC4ZP8A804qmeh/85b/AJVapqFtpupjU/L8 + 15KIYJtXsZbW2LN05TMAq/Tir3WKWOeNJoXWSKQBkkQhlZTuCCOoOKr8VQOsa1pPl/T5tW1y9h0/Tbcc + prq5cRxqPctirw27/wCcw/ykiuGh09NY1WCN2SS8sdNnlt6KaFlcCjD3GKvRfy8/OHyB+aEUjeUdUE91 + BvPp86Nb3kY8WhejAYqzvFWBfmH+cv5eflfHH/i3V0hvZqehptupuL2QN0KwR1cj6MVear/zmR+WRnKy + aV5gSzrtdnSpypHjQCuKvUvIH5teQfzNtTc+UNYiu5UFZrJ/3V3F/wAZIXoy/dirNcVYn57/ADL8lflt + pv6T846tDp8Lf3MLHlPMf5Y4x8TH5DFXkjf85kflgZgINM8wTWfe7XSrjiPoIrirP/y9/Pb8svzNmez8 + s6wBqsZIbS75DZ3u3UiGWjEe4xV6RirFvNH5geXfKGteXNB1mWRNR803MlnpKIhcNLEnqMGI6CmKspxV + D319ZaZaS3+oXEdrZQKXmuJmCRoo3JLHYYq8I1H/AJy5/LlLyWz8u6frHmMQsySXenWMr2p4GhKS0IYe + 4xVkPkX/AJyT/K/z3qg0G2vLjSNeZQy2GsQPYu5JpxjMtA5Htir14Gu46Yq//9D2l+ZPmCfy35Qv76zH + K/lUW1oo6mWb4RT3AqcxtTkMMZI5u47I0sdRqYxl9I9UvdF4/rf5raB+SeiWvknTLQaz5oMQutUL/DEZ + 7gcnaZh3bwzWT1UdNHgAuXV7PTdh5u2cp1M5eHivhh38Mf5rzKH84vIutVtvN35e2UVpITzl0pj6or3q + aZgDWY5fXjH+a9TL2f1mHfT6qRP+2clW4/KXyh53tJ9U/KTWPWmRS0vlu9IEy9yEJ3bCdJjyi8R/zSwh + 27qtFIQ1+Oh/q0fpYz5G/MfzD+XGpTaHqcTXXl9nNtq+hXYJCpXixUHoRmPg1MsJ4Ty6xdr2n2Rg7Rxj + LA8OT6seSKf+eNEH5aa9o35o/l9KZvKmoyCe3IPwwuTV4Hp0By7PDwJDLj+kuu7N1P8AKOHJotWKywFH + +l3TD7E8ra9a+aPLum+YbM1ttRgSdP8AZDf8c6fFkGSAkOr4trdLLTZ54pc4GlbXta0/y5o1/r2qyCHT + tOge5uZD2SNeRy1w3zT+V/kS8/5yA1pvzs/NRXn8uvM48l+UpK/VIbWJiq3EqH7bPTkK4q+mY9G0iGAW + 0VhbpbqOIiESBaDalKYqlvl/yR5W8q3uoah5e0yHTrjVWEl99XUIsjr0YqNq74qwz/nIjz9qv5cflVq/ + mHQgo1mV4NOsZX+zFNfyCBZf9gW5YqgPyX/Izyt5B0KHVdQiXXfO2rIl5rXmC+UT3E08y8mCl68UFaBR + ir1WXR9IniaGawt5InHFkaJCpB7UpirD/LP5OeQvJvmy984+V9O/RepajF6N3b2zmO0cfzeiPhDe9MVZ + 7ir5z/IaOOT84fzs5orH9M2+7AH/AHQvjir6H+rW/wDvlP8AgR/TFWA/m5+WXlb8wvJWp6Xq9nGk8UEl + zY38ShJ7e4hUukkbgAggjFUm/wCcafN2q+cfyi0W+1yQ3GrWXq6ddXR/3c1q5QP9K0xViH5tKrf85Lfk + 0rqGUjU6hhUf7ztir6F+p2n++I/+AX+mKpB5x8h+VvPXl++8t+YdNgutPvYmiYNGvJCRsymlQyncYq8r + /wCcVdV1V/J2u+TtVu31A+Stau9CtL6XeSW1tyDGWPiAaYq93kkjhjeWVgkSAs7saAKBUknFXyppGjaj + /wA5S+f77zD5llaP8kvKt09poejRMVTVr2FuMk0/SsakUAxV9M6b5b8v6PZRadpemWtpYwrwigihRUVR + 2oBiqX2PkHyhpfmObzbpukW9pr9xH6M95AgjZ08G40BxVb+Ynmk+SfI+v+a1j9Z9JsprqOPryeNCVB9q + 4q8b/wCcd/yp0TUdCtPzg85IvmHz/wCaAdRfUL0CYWsUpJSGBWqFVV22xV9AHTdOK8DZwFP5fTSn3UxV + hQ/Jf8vIvOlp5/sNJXTvMtpy/wBIsmNuk3Pr6yJQP9OKs21G8Gn6fdX5XmLaGSYqO/pqWp+GKvmP8g/J + Fh+b91f/AJ8/mKq63qmpXk8GgabcfvLXTrW0kMahIzUcyV3OKvptdM01F4JZwKn8oiQD7qYqwrX/AMlv + y58x+YdM813mjR2/mLSZluLXUbL/AEaYsv7LtHTkv+ScVZ/irwD8+v8Ayav5I/8Abbvf+oUYq9/xV83f + 85BQ3fnn80Py6/Jy6vJbTyjrgudU12OAlHuUsmUJASP2WqeWKvftG8u6F5e0+DStF0+3sdPtkEUMEEao + qoooBsMVYj+Zn5M+RvzS0d9N16wWG8T47HVbUCG8tphurxyLQ7Ht3xVPfIPlrUPJ/lHTPLWqazP5gvdP + SSN9XulCTTK0runILt8CMqf7HFX/0fXX5ukmz8rRE/BN5gtI5PChguDv9IGYWr5R/rD9L0nYP1Zj3Ypf + 7qD49/MuOa1/M/Wk1tHIW85zqdne3JFOJPYjpnManbMeLvfaOxyJdn4zj/m7f1mbW2m/84/eblTT7G7u + /LWqSgLFPcmsBkp+0ewrmWI6XJsCYl0U83bWk9coxzRHSP1MJ81+UfN/5SeYbaeG5eJmAuNJ1u0J9CZQ + agchtU918Mw8uHJp5c/dJ3uh1+l7VwEEX0njl9UWf+bItO/N78vZfzB0y2SLzzoCKnmC1gUcrmMUHqcR + 18czcoGoxeIPrj9Tz2hlPsnWjSTN4Mv91I/wf0UD+SOow+ZtM178qtak9fTdWt3uNHRzX0bpFOyV6cjk + NFLjEsUuR5N/tJiOmyY9djFSgeHJ/Sh5voz8itN1fRfy7sdI1mCW2ubGSWBI5lKt6SN8JAPbN5oYyjiE + T0fNPabNjza6WTGQRIA7d7xD/nKb/nIDyBceRtb8g6XrLrr73trY6lCsTUFs0yi4HLofgrme8wzTy5/z + lB+Qvl/QNL0Oy1qRLTT7WG1hT6u4osSBR0+WKpn/ANDcfkd/1fZP+kd8VZx+Xv5u+RfzR+uf4N1A3psO + P1kNG0ZXn069cVR/5jeQ9G/MvydqXk7XFJsr9PgkX7UUyHlHKvujAMMVeD6X+Yv5z/kbDB5W/MXypd+c + vLVoDBpfmnQkNxcPbxD4frEK1KkDYk4qzLSf+csfydvzDHqOo3Gh3ElOceq272wjY9mZttsVeteXvNHl + zzZYjU/LOq2urWBPH6xZyrMlR2qpOKptir4x8n/nH5d/Kz86/wA37TXbHULx7/VIJom062a5VVWECj8e + hxV6b/0N3+X/AP1Zdf8A+4dLirHPMv55edPzetJPIf5OeVNUs7vVka3vfM+rW7WtnZW7bSMGbq/E/CMV + e7flj5D0/wDLPyLo3krTnMsOlwhJLh/tyysSzu3uWOKvBf8AnIzzbp3kX88vyl806tFPNp9l+kFljtYz + NMTLCyjig3NDirJP+hwfy4rT9F65/wBIEmKsW1//AJzAsvN10Py//J7R7q//ADD1ZTBYC/Q2sNuzChlc + v/J1xV7L+R/5ZSflZ5Gh0O/uzqHmG9mk1HXtQY1M9/cGsjV8B0GKsB/5yD/5yI8geT/K/nDyc2psvnIa + bPbRWyRseMtzEUX4xsDRq4qxX8kv+civyS8jflZ5Y8t3OrtDf2tlGb5Vgc1uXHKQkjqSe+Ks/wD+huPy + O/6vsn/SO+Ksm8ifn1+Wf5j603l/ypqpu9VWJp/QaJoyY06kE+GKs91nSbHXtJvdF1OMTaffwvb3MZ/a + jkUqf14q+Y9If85v+cao20BdDm/MD8qopmbTLmw+LVLGCRiREYhUuF8cVZfpX/OXP5V3IEevLqXly8BI + kt9Us5IeJGxqTtir1jyp5+8meeIGufKOu2esRoAZPqkySsnLpyUGo+nFWQyRpNG8Uqh45AVdTuCpFCDi + r5eHlj82f+cdtc1e9/L/AEoecPyn1O5e/fy9G3G/0+SQ1k9AdXUkn4RirJNL/wCcuPy8kJg806drHle9 + Q0eHU7KSMA/PFXqHk/8ANP8AL3z78HlLzFZapcBeT20EymdR/lR15DFWX4q8A/PkV/NX8kf+23e/9Qox + V7tqN9Fpthc6jOrvDaRPPIsa83KxqWIVR1O2KviDzp/zkZ5M1f8APz8vvOFvp2rLpukWF/BcxSWbrcM0 + zihSPqQKb4q9mP8Azl7+XQNP0Trv/cPkxVpv+cwPy6RSx0nXSBuQNPkJ+gYq920jU4Na0u01a1WRLe9i + WeJJlKSBXFQGU9Dir//S9hfm9ZXVz5Pe+sU9S80e4i1KFB3MIZT/AMK5zD1cScdjpu9B2DkjHVcMuWQG + H+m/sY75z/L38vfzS0Gx83avcDT5ZrdGXV42VG4kdG5bGhynNp8WeImdvN2XZ3aut7MzSwYxxAH+7eBf + mH+Qj+WdCbzT5V1ZfMXl2GhuWPFpkH8wK1WgzS6jQcEeKB4g+h9k+1A1ObwM8PCyHl/NTH8rNUH5heTN + a/K/X3N1LbQPf6BdS/E8RjFeAPXtlmll42M4pe+Ljdt4fyGqx63F6QTwZYj+LzY3+ROtS6J+ZVtodx8V + lrqzaTfxn7P2W3I8aimY+hnw5hE8pel2ntNpxm0ByjnjrJFLdPin8j/m/Bb2isBY6r6ccafaMDNsPxyE + QcWeh0Lk5ZDW9mEy/ih/sn39G3qRq9KcgDQ+4zs353Io08D/AOco/wAu9H1L8qNc1jSdEtTrOnS2+rzT + RwIJ5Y7KUSyLyAqSyimKGa+QdC/Lbzr5L0LzTY+XtMe31OyhnHG3ibizIOSkgdVaoOKsj/5V15C/6lvT + v+kWL/mnFUz0ny5oGgiQaJpltp/q09X6tEkXKnjxAriqZ4q7rsemKpBrHkbyb5ghaDWtBsL2J92E1vGx + NffjXFXzl+aXkaz/AOcfNZ0L80/yv56Xpl1qdvpvmfy7Ex+pT2103H1VQmislO2Kvqe2nW5t4blNkmRZ + FB8HAI/Xir51/Im2trj84fzs+sQRykazb0MiKxH7hfEYq+hf0Zpv/LHB/wAik/piqvFDDAvCCNY068UA + UV+QxVfir5z/ADciim/5yU/JuOaNZY2XU+SOAyn/AEduxxV7/wDofSP+WC2/5Ex/0xV5b+cX5G+WvPeg + Xd9o9vHonniwjNzouuWQ+rzRXMI5JyMdOSmlCDiqL/5x6/MDUPzE/LTT9T1wBfMtg8mma2i9ry1PBvvF + DiqI/Ob8uNA84eQPNkS6LbXOv3WmXP1W4EMf1hp0iZowHpWpIAxVhv8AzjbpHkDzl+Tnlq9fQdPl1Cyt + /wBH6mHt42kS7tf3cquSK1BGKvWP+VdeQv8AqW9O/wCkWL/mnFUbpflLyvolwbvR9Hs7G6K8DPbwRxyc + T1HJQDTFU5xV2KpTqflfy3rSPHq2kWd6smz+vBHITX3K1xV87fnf+TWhfl3oN7+cn5VKPK3mryqg1C4h + syY7S9tYjWWGWIfCSw6HFX0F5L18+avKWi+YzH6TapZw3TR9laRASPvxVPcVS+/0LRNVVl1PTra8Dijf + WIY5aj/ZA4q8S/Nj/nHHybqWj3XmfyNbL5T89aRG97pmqaX/AKODLCPU4yqlAymlKHFWbfkT5+u/zL/K + /QvNeopw1K4jaG98GngYozD2JFcVYR+e/wD5Nb8kf+21ff8AUKMVe+kBgQRUHYg9KYq+cPzGsbGP/nKT + 8q4ktYVifS9U5oI1Csea9RTfFX0J+idK/wCWG3/5FJ/TFXfonSv+WG3/AORSf0xVFqqqAqgBRsANgBir + /9P33NDFcQyQTKHhlUpIh3BVhQg4CLZRkYkEcw+Sfzo8veZ/K+mf4Gt2ZvJd9e/W9KumYhYnkNWtpGHR + a/Zzm9bjnAcH8JO36n2H2d1en1OT8yf76MeGcf53+2R8+9kfkry9qn5W/kt5on86yKltfRyfVLIN6qD1 + k4oARX7ROX4ccsGnlx9XWdo6vH2n2rhGmG8SOKXL6ebzP/nHCB5fPr3oqlpaWU01weyx8TscwOzh+9vy + ep9rpAaMR6ykAGNeQ2+u/nHpf1CpM2tTPDQH7PIt+rMfBvnFfznadqDg7LnxdMYt9Q3XkT8tNH/Nm31+ + /u5LjzbqrGS00yvNFYf7sKjpT3zoTgwxz8RPqPR8oh2nr8vZpxRAGKH1T/3r2bNo8SoXlpb6haT2N3GJ + bW5Ropo23DI4oR92KvljS77zL/zidrN7omoafdaz+RN/cPdaVqNqhmn0iW4YvJHKo39LkSQcVerW3/OS + 35IXWmvqkfnGyW2QVZXYrIP9iRXFW/yv/O2y/NrzBrEHlXSrl/JumKqQeZZkMcF1c/tpED1C+OKsp/Ms + +fk8n3sv5Zm2Pm+IxyWcV8oaGVEYGSM16FlqAfHFXlGh/wDOVvlnTmXRvzc0278jeaYgFmgvYmNtKw2L + wyAbrXvirMLz/nJP8kbKz+uzecbEwkVARizH6AMVeS6j5g13/nKfzlomleV7Gew/JXy7eR6pq+t3kRib + VLmA1hitw3VAa8sVfVsaJFGsUY4ogCqo7ACgGKvnf8g//Jxfnbsf+Ozb9QR/uhcVfRWKuxV2Kvmj8z9X + 028/5yp/KPR7S5SbU7KPUZby2SpaJHt34l9tq02xV9L4qsmBMUgAqSpFPoxV8wf84pebfLdhd+efJN1f + R2/mqbzVqdzHpL1WYwnhRgCOhxV9Rddjir5h1/SPNP8Azjh521Pzz5P0ubW/ym8xyG48x6DZDlPp10d2 + uoEHVT+0uKvQdC/5yd/JHXrL65D5rtbUqvKWC75QyoabgqR1xVD+Tv8AnIXQvzG/MGLyl5C0651jy/Fb + yzan5pVGSxglQDhErEfEzYq9R8xrrb6FqC+Wnii18wP+jpJxyiE9PhLDuK4q8D0X/nJ6byjcL5b/AD50 + G58qa5CTCdZSJpNKu2UfbikXpy607Yqz1P8AnI/8k3svr485WHoAV3c8qfKmKvIfzA/M/UP+cjlP5T/k + 7az3PljUJY4vNfm6WNo7OKxrWWKJj9p2GKvprSNEj8ueW7TQNG+GPTrRbWzL7isScVLfSN8VeCW3/OQ3 + mz8s76TQvz98vT2UYnZbTzdpkRl0yaB2PpmTj/dsBQEYqz2y/wCck/ySv7Q3sPnCxEKip5sVYfQRirzT + 8wf+cgm/M20n/Lf8gIpNe8xasn1a911EZbHT7aX4XkZyKFuNeIxV7j+V/kOy/LTyLo/kyxcyppsIWWc9 + ZJm+KRvpYnFXmX55n/kLP5Ijf/js3/QV/wCPUYq98xV87fmSf+sqfypH/aq1P/ia4q+icVdirsVf/9T3 + 9iqD1XSdO1uxl03VbZLqynUrJFIKgg+HgffIyiJCi34c88MxOB4SHl13+WnmrQLObTPKeox6p5cnqH0H + WR60axn9mN2O3sSc15004CoG4/zZPVw7Y0+eQnniYZB/lcXpP+clXlfy55p8kyXzaD+XMKS3w4XDpfWY + R18AGmqBleLHPFfDj5+YcvW6vT6wR8XVGo8vRP8A4l1j+X3nGbUjqGk6Fpnk6WYn17uMx3N2nLq0TRu6 + hsRp8hNgCH3oydq6UY+DJknqAOUd4w/zrAeheT/y50Pyi0t6nPUNdut7vVrs+pO7exP2R7Lmbh08ce/M + 97zmv7WzasCJ9MB9MI/T+1mGZLpnYqpzwQXMTQXMSTQOKPFIodGHgQag4qwq5/Jv8rLy9Oo3HlPTWuy3 + Mv6CqC1a14ii/hirMbKwsdNt1tNOtorS1T7EECLFGPkqgDFURiqW6t5e0HXYzFrWmWuoIV4UuYUl+E9g + WBIxVi9t+TH5V2dyt5b+UtNW4VuSsYFYA/Jqj8MVZpbWtrZQrbWcEdvbp9iKFVjQfJVAAxVWxVAWOiaT + pl1e32n2cVvd6i4lvpo1o8zgUDMe5piqPxV2KuxVKI/K/l2LXZfM0em248wTRiGTUeAM5jXooY7j6MVT + fFXYqkFt5I8o2nmKXzZa6Naw+Y519ObUkjCzMp61IxVP8VaZVdSjqGRhRlIqCD2IxVherflF+WOuXX13 + VPKunT3RpWT0FQmnjwoDirJtJ0TR9BtVsdFsINPtEACw20axLtsKhQK4qj8VQeo6TpWrw/V9VsYL6Df9 + 3cxJMu+xoHBxVhx/JP8AKdrj60fKOnevWtfRFK/LpirMdN0rTNHtls9Js4LG1WgENtGsSbCnRQMVRmKq + F5Y2WoQm2v7aK6t2+1DOiyofmrAjFWFXX5LflTeTtc3HlLTWmY8mIhCgk+y0GKsp0by7oPl23FroOmW2 + mwUoUtYkiqB48QCfpxVM8VQV7o+l6jc2l5fWkc91YOZLKaRatE7ChKHsSMVRuKpZdeXtEvdYs9furKKX + WdPR4rK9YVkiSWnMKfA0xVM8VdirsVf/1ff2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KpX5g8x6H5W02XV/MF/Dp+nQirTTsFBPgo6sT4DfJRiZGgLLCc4wFyNB8kfmh/zl + VqetGbR/Iavpeknkj6pJQXUy9KoP91g/8FnV6HsX+LN/pf1vK63teUvTi2/pfqTb8jv+cjWtpYPKvnu5 + L2UhEdjq8pq0ZPRJT3X/ACu2V9p9lCHrxDbrFv7N7QNCGQ/5z6zR0lRZI2DxuAyOpqpU7ggjqDnLPTLs + VdirsVdirsVdirsVdirsVdirsVdirsVdir//1vf2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV4z+av/ORPlX8vhNpWlFdb80KKfVIW/cQN/wAXSL3H8i/F/q5sdJoMmc7bR/nf + qdZqu0MeHbnLu/W+K/Pv5i+Z/P8Aqbaj5lv3uZTX6var8MEK/wAscY2A/E987LS6PFph6Rv39Xlc+fJq + D6/2MYsbS81C9hsLGGS7vrhgsFtCpd2Y+AFa5dn1McUOKRAiOpbMOlMpUNy+lfJ3/OKF9qej/W/OWpy6 + VqEq1hsLRUlaGo2MpJpX/JGcDq/bAwnWGII75dXpcXYsSLmaKc/l/wDmh5m/JLzGn5Y/mkzXHlwsU0bX + KFkWMn4SGO5T+ZD8UeZY8HX4zm0/1D+8x9Y+5mJT00hjybj+GT6ut7m3u7eO6tZVmtplDxSxkMjKwqCC + NiDmpdgDaril2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV//1/f2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxVJ/MvmnQPKGly6x5jv4tPsIgSZJWoWI/ZRerMfBRk4QlM1EWWE8kYC5Gg+O + /wA2/wDnKHXPNAm0XyOZNG0AhkmvT8N7cKduo/u1I7L8XvnTaPskD1Zf9L+t5nV9qGfox7D+c+dLi+ck + sfiZ92JJLHuTU50OwFB1McVndm35a/lL5t/NO8H6LhFjocZpda3cKRbqP5U7yN7L9OaHtLtnBohueKX8 + 0fpd1pez55umz6hgs/yg/wCcaNDF9fSLceYpojwlYLNqt3QdIk6RR1/aPFfc553LLrO1stC+H/Yxeohi + xaaLFPLHmb88/wA49ctPNdif8FeQbKb1bRCCfrCqSKFWAadiNix4xL2zI1WHQ6HEYH95lPdygxxTy5pW + Nopj/wA5IebPIVl5Uu/LnmF473zPPH6mlWEYDXUNzTadyP7pfHl9r7PHMb2e0+rnqY5MNxiD6pfw8PUe + bZ2lPCMJjPqNh5vPfyI/PzW/y+e10DznHcy+TrugtriaN1a2J/aiLgck8VGejdoaHHmJlgIMh9UQXmtL + qZ4qGQHh733Hp+oWWq2UGo6dOl1Y3SCW3uIjyR0boQRnJkEGi78EEWETgS7FXYq7FXYq7FXYq7FXYq7F + XYq7FX//0Pf2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KvF/zY/wCcivLH5epL + pmkcNb80D4Pq0TD6tbt4zyL3H8i/F/q5n6XRTznbYfznA1Othh25nufEnnn8xfMvn3VW1fzLfNeT7rDA + PhghSv2Yoxso/HxzrdNpceGNRG/f1eYzZMueVyPwYrDHeapexWGnwy3d3cMEtrWFC8rMewC75kZM0ccT + KZqI6sseAyNAF9O/lZ/zi4kESeZPzXf0IIl9ddEEqqiIg5c7uWoCqB1Sv+sc887U9ppZD4em2/p9f83u + en0nZgj6snyTrzp/zkNGbyL8ufyB0pNZ1un1eDUbaEGyt+zfVoQAHp3lekQ/y81+k7G9Pj6uXBHz+qTn + 5NVXoxCyifIv/OPVho01x+ZH56awmta8n+mXkd5NzsLYruGnlenqEdk2jXoqnIantkzj4OkHBD/Zy/Hz + WGmo8eQ2fsY3+Y//ADklrfmfUB5G/I6wnnupv3EOsLCTM6j4a2kLCkaAdJpB/qqvXMrR9h48cPH1suGP + Ph72vLrJE8GIWU3/ACx/5x28ueVYJ/P35yX0Wo63D/pl4l7NysbdjvzuJXP71wfE8a9K5Tru3p5v3GlH + Bj8vqmyx6ERPHkPFL7mYQ+bPyn/PfTNY8n6MBdWFi37UJgkAGyXNqWFQoOw+z/q0zS5cWs7KyRy7xkd/ + +knNicOpiYH1POPKfnfzT/zjZ5pi8o+aZn1byBqRaawuBuypy4l41P2XWo9SP7J653+mzYu18Jy4xw5Y + /XDvedmJ6LJwyNwP0vsLRta0vzBpltrGjXSXmm3aCSC4iNVYH9RHcHpmplExNHm7OMgRYR+Bk7FXYq7F + XYq7FXYq7FXYq7FXYq//0ff2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KpP5m81eX/J + +ly6z5jv4tPsIgaySndj/Kijdm9lGThCUzURZYymIiyaD4v/ADe/5yn13zV9Y0PyYZdE8unlHJdV431y + p23ZT+7Uj9lfi8Wzo9L2UB6sv+l/W6HU6+UvTj2He+d7nUXm5CU0kG/I78u+575vOWwDroYt7LMvy3/K + Dzr+aV8YtEtfqujxMBe61cArbRg9lP7bf5KfTmh7Q7Zw6QVfFP8Amj/ffzXb4NEcnkH1Lb6b+TP/ADjF + oq3l/c/XPNdzFRXAWXVrsjqIYq0hjr1YlVp1Y5wc8ut7XyV/D/sYu+hDFpo/rfNH5q/nj5v/ADUEmn3U + n6K8plybfQbRzwYA/C11Js0rbdD+7HZc7fs3sPFpAJH1T/nHl8HUajWyyHbk+uvyI0r8vtP/AC6g1T8s + rSG5v5rcDUZ5WCXc1+iVaG5kIZoxz2UU4BfiAOee9q5tRkzkZr5/L3fjd3WnjARHC8UuvJH5+fn55qnj + 8+hvKHk7Srj05LF0K2kTqaFbeOtbqSm/1hzw/l4/Zzf4tboNBiBw/vMhHM/w/jucaePLllUvpejap5g/ + J/8A5xk0htH0qL9JeZ5oyz2UTJJqdwxFeV1PSkMdeg/4BGzWY8Gs7WycUjt3n6I+5uOTFp40ObzTSvK3 + 5u/85H3MfmHzpMfLf5eh+VpYQKyKwrt9WgbdnI/3fLX/ACR2za5NVo+yYmOAeJm/il/DH8dzRHHl1J9f + pj3Mx8yfmD+U/wDzjro7eVfKllHe+ZVX49MtnD3BkI/vNQuqHh/qfb/lRc0un7P1vbGTjyEiP8+XIf1A + 5WTU4tLHhHPuDzPTvy9/Nn8/LwecPOF6miaSFK6SssLLGsTHlwtrcENwJ+1Ixq3jnRjtfQdix8LAPEl/ + Gb++X6HVy0mfWnjyekdEw8m+d/PX/ONnmw+XfM0bXvlW9b1AiE/V54q0M1szfZdf20P+y8c32LJp+2MP + i4jw5B9Uevx/4p1/7zQz4J7wP4/AfbflrzLovm7RrbX9Au0vNMu15RSp1B7qw6qw7g5zs4ShIxkKId1C + YkLBsJtkGbsVdirsVdirsVdirsVdirsVf//S9/Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + 7FXi35tf85FeWvy8MmjaOo13zafhWzhPKCFv+LXXqR/IvxfzcczdPpJZd/pj/OLi5tTHHtzPc8z0jRdJ + 8z6da/mr+feuxakbtWmsvK08ghs7SEcqK0CnnKxG6hB6dft88cuqGIcOHl/P/il+phDCZ+rJv/R/hfOv + 5k6d5PvtSt9X/LhZYLXVJpFXysySSXVkqkCJmPGlJjUpEpdkWnI5uuz82cYzLLvAC+M8/i4OfHh46j9R + /hey/lJ/zitK1unmb82X+qabGPrS+Xy4jb01HLneSEgRqBuUBr/MVzme1e38pl4eEGN/xfxH+r/Ndnpt + FGPql8mSebv+cr/JHku8sPLP5d6NFreh2Miw3l3bj6vYpApo8dmAAZH/AOLD+7/161zV6T2ez6iBnkPD + 3cXU/jvcuerhCXCOadfmT+Wfkr/nIzypb+fPIl3DH5nEAj0/VPsJMIqk2V8nVCpJCn7UZNfiQ5Rotbn7 + LzGEht/FHofNsy4o5483xNqej6poOqXWj6vaS2GsadKYbyznXjIkgFfkQRurD4WXdc9T0uqx6jGJwNxP + 4qXm87lxSxmiN2W/lv8AmZ5j/K7XF1rQW9a2momq6VJX0LmEHowHR1/ZcbrmF2l2Xj1saO0h9MmWDUSw + mxye6a//AM5K+fvzM9Lyf+Tvl+60zXL2MmW+kaK6ukjIofQp+7iUV+KaT4l/ZVTnJw7Aw6QeLqpAxH8P + e7Q6uWTaA3TryX+QPlf8tNPn8/fnLrFtqGrRk3l7JfS8tOtpT8XKRpKtcTE9K1qfsq2a/V9r5dV+40w4 + IcuGP1S/U34dNGB48h4iwvzn/wA5CedvzO1j/An5H2N1a2s4MMmrInp300VKFowdrSL/ACyfU/1M2Gm7 + EwaOHj6yQ8sf4+otWTWTyngwj4sk8ifkJ5K/KzTpPPX5p6lbXuoWw9e4ku2I0+1mb4ur1aeYnxryb7Kt + ms1/beo1p8DTRMYcuGP1S9/80N+DRww+vIbPmlt/+e/n/wDMvzHD5b/I7SHi0+2kQ3OrXkS+pLGh/aV/ + gt4COoP71h/L0y2HYOm0WDxNbL1EenHHn/x4/Yg6yeWfDiGw6vV/zWtfKVz+Xsn/ACtSe1tYo4hIJ4WP + JdRCbCy5D1GblsFA3H2vhzn+ypajHqgdKDxX/sf6fl3uXqxjlhIy1X45Plz8mvzs1z8sNYEkTm60S5Yf + pHSWYBXX+dRvxkA6EfI7Z7frNANVjB5TA+3u/qvC4NUcEz1i/Qryh5w0DzzoVv5h8u3S3NhcDcdJI3pv + HIv7LDuM4PLilikYyFEPUY8kZxEo8in2VNjsVdirsVdirsVdirsVdir/AP/T9/Yq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FUm8z+a/L/k3SZtb8yX8en6dCN5JD8TN2VFG7MeyqMnCEpmoiyxlIRFnk+O/ + zT/5yk8webZJdE8gh9G0T4vUvGYLeTxDqWYGkSU7A8v5m7Z0ml7KEfVk3Pd+t0Wq7RI+nYd751XzBqtp + q1trNjd87+CRbm0uk4zKz15Bh1V1P3HNrPBDJDgr0no4+GZB4jzeo+Ybnzp/zkTqdnFo/lWP/EtvZxWu + qXVjIo5IposjNKUS3Qn7SJy3zV/yfp9HHxMxJ/mRDmHU5M5EcXTmyL8trDS/+ccvPyWP53eXv3cyrceX + vNMaS3NvbSxr8YjCAh61HP4TJE1DTi1c1ubVT1Q4YEgD/J/77+l+h2EMEYHilV/zkt/O/wDM/wA7/ng1 + /f8Ak7TdY/5VF5eVP0jAsRRJ5Q55TTiKpYEFeMTF/TFXdV5bV6WWnw5AM1E/Pg9/m25BMx9OzxpZbIWL + XLvHHpypyaVqqkaj+b5Z6MJYzjvbhp4yYmMnD/FbJ/y4/NLzN+T3mBda0RjqHl6+KDVdIkbjDcxDoQaf + u5VBrHIB/kt8Ocp2x2Lj1EP9xPu9/wDRd9oe0DdS59Q+qvO/kbyN/wA5M+Srbzf5Mvo7XzPBEY9P1ORe + LxyqKtY6hGNwB4/aj+3HyQ/F5vptTn7KzmMht/FH+Gf7f5snosmOGoht+Px1D4i1rS9V8raveeWfNdrP + pmv6a3pXNq1PhDbqwI2dHG8br8LLnq2i1ePU4xkxG4/aD/Nk85mwzgaLKPyr/NXUvyt80J5j06JL63dP + qeo2c3wmWzcglUbqrgiqt9+2Y3avZY12LgOxG8T5stNn8IvsLzb5L/L/AP5yh8qaHr2mazcwxWEha0uL + X45IS9PWtrm2Y8BJt8Ln4l+0pKnfzHBn1PZOcxrf6fU9DOENREdzFvM/5hflJ/zjbpUnlDynZJqfm2gE + mk2sgeb1Tsr6jdAH06nf0l/eH9lF+1mZg7P1Xak/Eymo/wA6XT+oGuefHpxURuwny5+U/wCaX596rD5w + /N+8n0jywDz0rSIl9Fijbhba1NfTUjrNJWV8z83aWk7NicWjAlP+LKeX/HvuaYYMmoPFlND+ayzzp+dP + 5bfkbp7+Sfy5021v9ctgUltLZq2dtKP2r24UlpJa9YlJf+Ypmu0XY+q7Tn42YmMT/FLr/Vj+A35dXi04 + 4YbnuDzvyj+UX5lfntrMXnj8zdRuLLRJf95pJECTSQk19KxtvsxRnpzI3/yzm31fbOk7KicOjAnk/il/ + Df8ASl/F/V5OFHR5NURPKaj3Pd4vIX5I6paX/wCV1hb6bLqGlwB72ztnV9Tti3SZph8XqA7sOXw/tqBn + IHtDtHHMauUpiztL+D3cPKnbfl9POJx0Hidpdeff+cYvOaPHIdQ8pag9I5iCLa9iXqjgf3c6A/xWq56d + otbp+2sP83NHp+rvh9zyubFk7Pn/ADoH8fN9peRPPnl78w9Bh1/y9cCWF6LcW7UE0EtN45F7HwPRu2aL + PgnhnwyG7uMWWOSPFHkyfKG12KuxV2KuxV2KuxV2Kv8A/9T39irsVdirsVdirsVdirsVdirsVdirsVdi + rsVdirxH82/+ck/KX5dLNpWkFNe81r8H1SF/9Ggc/wC/5Vr8Vf8Ada/H/q5stJoMmfflHv8A1OJn1McX + me58dfmRrH5k+Ztah1D8ylvrO7uYhPY2l7E1ui20hqvoQnZFPuOf82dV2diw7jEQeH6j/E6HWTybGd78 + v5rDDOq8oLMI8ooZD1jX/W/mPt0zaCYJ4cfxLhyw7cU78lKW6gsiZ7g87twBxACkgdB8IARR/KBmNn1W + HSA2bk5GPTZc5FDhig7HzHrdhqtprOmXcllqGnyLcWctsxQwup2ZadT41zRx1UNZcZ7Hu/U7mOnOnHp5 + Pd/y5bSf+cjvNM9z+dvnyZLqxRnsNBXhYWskISjvby19KIqQDIqgyyfaZ+HTUajFk08qx7Dv5yk5sJCY + 9TOPLnm/zN5d8jeYfJvlXz7otr5E0i8nh078wL0W9hc6faUQ/VY7BAXfg5IN5MOUhkbgrtwyGbFHGBKc + alLfhG0Pn0vrFhhyGW0d4jq+YbvVdMvtYv007XR5hrO5/Sk0B0+W9ZvjadbWU8wjMSRy+Ij4mC8uOdp2 + XrMWXCI7Aj+F5/X6aUZmVbd7TtM0jmRkazKBfQKUbl+0S9dxTotNvHNtwE3fI9HVnhABHO/qTH8v/wAy + 9d/KLzRHrflq4F3p9zxXVtHZ6291CD/duRULIP8Adcn2k/1ajOV7W7KxaqPAefSX83y/qvTaHVZBGyP2 + vrnzN5Z/Lf8A5yt8hW3mDQrhbDzJZAxWepOq/XLC5A5NZXqjdoWP/VSI55phy6nsjUctuo/hnH8ci7+c + I6iD4b80eWPMHknX7zyz5osnsNZsmpNC+6OjfZlifo8b9Vdfl9quer6HX4tXjGTGfeOsT5vN5sMsRort + E82+a/K63K+Wdcv9FW9X07sadcSW3rKOzcCK0r165fm0eHOQZxEiO9rjmnDYF9d/84v/AJPeQW8sWH5k + 3Txa75kvZJDW4pLBps4chlMbVLTn7bSSVbf4f5s807f7S1BynT14eOPKI/iHn5eXJ6HR4IECfMliP5q/ + m3+b/wCY3m7UPym8iaHqHl9YJGtr+P7GrXUJNPUmnU8Le2YfEPTb4l+1L+zmR2dotDp8A1WeYl3R8+7h + 6y8mGfNnyT8OArzZZ5C/IT8v/wAm9GHnn80NQsri/sQHMtyeOmWcnUCJCKzzE/Z+E1b7Kd81mv7c1faM + /B04MYH+GP1yH9LuH9FyMWkx4BxTNl5z+a3/ADlLr3moXGhfl6J9A8uODFPq7Uj1a7TpSOlfq0Z8FPrM + P2o+mdD2P7J48FZNTUpfzP4Y/wBb+cfsdZqu1DLaGweHaBrGq+WdUttc0O7kstUtJPWguYieYfqS381f + 2w32v2s7fPpsWfGcU43E9HS485hLiB3fan5f/mN5S/Pry1ceV/M9pAnmBYf9yekN8KThNvrdoTupU7lV + +KM+KZ452n2VqOyMwy4ieG/TP+b/AEZPXafUY9XAxkN+55dPB52/5xt83w6votzJfeV7yT04rqQH0biK + tfq10g2WVR9lh9r7SZ3/AGb2lg7Zw8E/TmiPxKPf5h53UafJoJ8Ud4H8VJ9l/l1+Y/l38y9BTWtBm+NK + JfWLketbzEfZYdwf2W6N94zTanTTwT4Zf2u2w5o5Y8UWX5jNzsVdirsVdirsVdir/9X39irsVdirsVdi + rsVdirsVdirsVdirsVdiqS+aPNvl3yZpM2t+ZtQi07ToRvJK1C7dlRR8TseyqK5ZjxymaiLLGUhEWdnx + t+bH/OTnmLzp6+i+TDLoHlg8kluq8NQukO25BPpIR+ypr/M3bOq0XY4j6svPu6Oj1PaP8OP5pJ+UP/Ko + 9M0G682+dp2sPMtnNM+j3upqW025jh4h0tKA+pcqx+KtWFV9Pblmo7ezzyjw8M6A+oDmf2OZ2bhEP3kx + cj9nuY158/OzUPzf1DT/AC28s+k+UkM6eX7y3t4L/V73UkKrHbuGfkkcjOFJPFUB5c5OPw63seOeB47o + x69OHqJFz9cMeSNEXfTzYJPPYeWL6Sa+tYdQ8021zLbah5cnAutIRUSgeW6tplE7BztDCeHwlZn/AGc3 + mq7WlI1hHDfOXX/NH6XW6fQCIHGeIDkGIOzvJzYgsxLMFFFqTXYfsjsBmjsnnuXaAAclxFDWMlaHkCDu + D2pjaWZpaWX5kXvO2spf+ViTyRpaeWdAsLW1069gtYQXuI3eVBFdfCzPGFPrN/druabHSavwdifTfmZR + /q/0XHz4uIenYpXFfSaPq36Rtbi60HXwLq2eI21uk06leF3HNCQPUqopKJB8twM3uXDDURuXKW/v83UY + 5nETEVtz5+nuemeW9W/IeD8q/NGh6pp0UVzdoiabrcFpGnm+XUQ3qpII3kljjtomHBWSYIYx+8VWf4uY + /KZoZPTsRyl/D+O93fixMd0R+VNh+X2l6Avmz8ydSg0zzDGPrGkaNqkUix3NmjDje2+x9aQsKJEQE25f + FyqNlrO1c2QcEJbfxGPVxcGgxRlxEb/cjdTPk3/nJC91hvJ3l68X8yLaWK1099KiittPayiYK1/qxciN + PVLEKkf7wcFpUFqYmmzS0/qnKofzeZl/Ui35YiW0dz9iJv8A8qvzj/5xdNn+Zmi3ltremqqxeZ7axWU2 + 8cFQfTuo23eGp+G4UK0L/EQFyrJqsHaIOLNHg/mSvi38+77mcYTxbxN/jo9h1PSPy3/5yy8gRajp0psP + MGngpbXTBWv9JunFTDOAf3tvIRt+y4+JOLjOYhPU9j6ny/2M4/j5OZKMNRCnxH5w8n+Y/wAvvMN15V81 + 2htNWthyBHxQzwsaLNC/7cbdj2+y1Gz1TQdoYtZj48Z946xLzefBLFKin/5Wfmr5k/KnzANY0RhcafcU + TVdHlYi3uoh40+zIv7Eg3X3XbKu1Oy8eux1LaQ+mX81lptVLEduT6i8w/wDOXf5bWWhrqvlqyutW813s + QT9Fz25tPQZRULdXRX4o0J2WLnz/AGeOeeYfZTVzy1kqMR/Hz/0ru59pYxG47l8med/P3m78yNX/AEz5 + v1Br2WMn6nZxj0rK0U/s28INE26sayN+02ekaDszBoocOIe+X8Redz6meU3IpAigbVr4ZtHCtV8afdjT + HmjdL1G+0m9t9U0y5ks9RtXWW2uYWKSRuu4KkZVmwwzQMJi4nmC2Y8pxkEGiH2P+Wf5q6B+c2hS+TfN1 + tB/iSSEpe2MoCwahGo/vbcfsyDqyDdW+JM8a7Z7GzdlZfHwE8F+mX8WPyL2el1mPVQ4Jjfu73mWuaV5r + /wCcdfOtjrnljUGm0PUGcWEsn+7Ujo0lpcoDRioIo37Q+LZs77sXtTF21gOPKKywHqr/AHcf0vMa3TS7 + OyCcN4y/FF9kflf+aWg/mdoi3+nMINUhVRqOmOf3kLnuP5kJ+y2arWaOemnwy5dD3u20+phmjcWdZguU + 7FXYq7FXYq7FX//W9/Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXiX5s/wDOR3ljyEs+jeX2TXfN6jj9WhPO + 1tm/5eJEPUf77U8v5uObbR9m5M5s7R/HJwtTrIYRvzfFvnHzx5l89aq2r+bdTk1C639CFjxt4EJ+zFEK + Ko+j51zttNoseAVEPMZ9VPMdzQY1IElDm4ZRCRRyxovE7b5lTIjHfk1QiSdmR+bPPWuee/y90vyBrB0y + 00vyvyu9M1O7nNjdTxRgIlqlvFGVmemyV4PJSrn7TNw/aGk08cgygV/QHX/iXqNJlyShwnn/ADujy63t + bW0D/VouLSbSTt/ev2of5R/kjNXPLKW3IfzXMjABVC8V4CiqNgBsABlLa2vv41p44Cq8DiTQfCR8QGxH + 05G1KnIikFW3XpUbH6CNwflk4ypeTPn165/MOC1sb+WZvOttbafoehaLptmiJryRuY1a7uea8LiOOg5H + adVRF+PNnpdV4R3+jqP99H9IcXNgE/VXq72OuVguZNK1OGzh1a3le1ewW2djDPExV4pCJKCRWBDrQ/Fn + S4+GYBjVF0+UThZo7ebNdH8y3fnK6/Qn5pa9F/haF47vXNWu4WXX5rB3SIxWrCN5SISBII0jHoxepJ9i + ozndfghh9UI2Ty/mQ+DtdPkOUUdq/HN+gf5feS/I3kryta2f5aWdlb6Hdxx3KX9qyzi8V1BWd51LGYsD + UOWPtnHZTPi9e57y7KNJ8iQ3CzJ6Xrx3AaK4tZAGiZWqG5hq1BG1MpBpsL49/Nb8pfNP/OPXmb/lcP5N + cx5TVq6zoahpI7SORvjRkG72bH/ZW5+Jfh+z0WDPi1OMYNRy/gn/ADT3S/QfgXFMTA8UU683+c/yp/5y + E8g6fLqsUOmXFq051PVbi+tbS88tOkDOJ0SYq97BK4CelCD6g/lcbazDpdX2bqLx2T/DQuOQXyl+LDbO + UM8N3xJE9QKjfoWoQCPGh3FR2z1jHM0L2LzMxRICJWlBU702yxxpKoXYU2Hf+3CN2tUUAbV274WJN81R + QfnhYlUUff4YUWirS4urO4hvLOaS3u7dw8E8TFJI3U1DKVoQQcjPHGYMZAEHoscpibBpkuseavNXm+5h + vPNOsXOrT2yelA90wPpoTUhVUKorT4jSpzH0XZ+m0gIwQEL58LXqdZPL9Zt7V+QXk3zpJ5jsfMGl3Eul + W0TAtLT4p4id0KHbgw2q30Zqe2e0sEcZx1xy/wBy29n6fOcomDwj/dPupakAsKHuM4uJsPZt5JXYq7FX + Yq7FX//X9/Yq7FXYq7FXYq7FXYq7FXYq7FUn8zeadA8naRPrnmS/i0/TIBVppTuzdlRRuzHsqgnLMeOW + SXDEWUSkALL46/Nv/nJfzD5zWbQvJHq6F5ZcFJL3lx1G7Q7EfCf3SEfsg8z3b9nOt0PY8Y+rLue7+H9r + odX2l/Dj+b5+9RYYmWMEFtyTvU96nOpEABs6Gz/EhkCu4JNHrSrHJ7r0QOpTI9nFcsssBSfittcoEeTi + aEqoZqqeqtmpz5QYg9x5OfponiqwQRuR0Yvba215e3Nndgw30Mrj0mrunLbrvUDOG1FyySkepeowREYA + DuTIEKOm/VW60zGbl7UG/wC0dyPfIkoWA1G/TuowFNt0IcUJLGnI9qdBkVar1+f0YQqmxJI+0tCCCDQg + g1BBG4IO4Iy0EjcICd3PmK0uNMt7XUmtLS+022WDS4rexQSanynLyG8uFbn68asTHcMPiVeD/HxbNpoN + RKE+ECwee/3ONqMUZizt5peto99ILvT7+V76Ok1vDHJxv0kXoVeUqtR/Nz6Zv8mOMwb5Oq8XJDauvPp8 + g9o/5x3/AOcide/LzzJB5J1HTLnU/JF0lxPqEFjW5ksZoeUs99Y26DkICg53VnHzoyyT2q/aifkdboox + HP3O6w5jMb833zL5t8p2vlc+dZNXs4vKBthqH6b9ZBZtbOvISiUHiQwO1OvzznvBnxcNfqcm3zjff85O + 6X+ZjarbeTtb03yn+WulTx2Wv+b9fo1/fLOCWttL03d2aSMNxklFfCLlm0w6CczwwHFI/Ifj8FBkIiz0 + fGnnLQLDSPMd5Z2Gk6hpWh8zceX7TXYimorYN/cvIGVT8VNjStKBiXDZ22jn6AOITI2Ji6bMPVdUx0V6 + Db8c2YpwybVYzuPwyyJapBEIf9vLgXHKuu+/4nAWBVQtONBv4nJNZKskVT41P04WsypONK0W+1W6FtZw + tLKaE0+yo/mduij3OQnkjAcUuTVZPJ9I/lF/zj/Lq0keo3hWQIOQndSYUP8Akgjc+DHOR1/a8p+jHsPt + dtpOzzI2eT678u+V9L8tWi21ilXAHOZvtE/wzm66l6XHjEBsneSbHYq7FXYq7FXYq//Q9/Yq7FXYq7FX + Yq7FXYq7FXYq8Y/Nj/nIjyx+XrT6LpAXXPOCfD9Qjalvbsw2NxIOn+ovx/6ubbRdm5NRvyj+OTh6jVww + jfm+K/PHn3zJ581dtV816r9fvk2gtF+C3tkb9mKIbL8/tN3Odto9Liw+mI3+15fUarLnHERUWIM7vcrL + 67CAIQ1sFHFnJ2ctTlUDbrxzYeGeK72rk4omIxqr81dWM3w0p2AHXEimUV1rZXmqatbaFoFpLqvmG7PC + 1021UyOz0J3p0oASd+majWdqY9ODZBLsdNoZZjZ2D0Tzj/zjF+aHlby/dedLi4sNVls4Fk1bSdK5y3un + QunIyryHCURgVZU+LjVk55yUfaHHLLWQVE7cYPFwX9PFH+b/AEun8TvT2d+7AgfPhPKfxed2el+R/Onl + VdKa403yR5k8t2y3ureZby7e/vfMZduFtb6bAwXiCSOSB/haRK8kSuYmt088cjONyHVy8OQTFVXkw2VN + Z0q8XSfM9hLo+svGJorK4VoZWgevpuUYBl5gclr9pfi6ZiwmJiwzqkQSSeXVqdOhHbDSGuVNm+1/NXoR + ilrckVO4+jAhxBO4ArvU9gPeuEJS6G71LWr99E8m6fNruuJDNctBaIZmWG2jMsrhV3biqk7f8NjIiI3Q + LJTXzF+W2v8AkyLyV5zuNRt9d0rzppy6lpmpWzVVJlQC5sZomJYNCXAZ6BH/AGfiVlGfpDw5Lntw/wCl + k0548UeEdUw0zyhrnmXUYNF8u6PNe6veORaabbn1JpVjTnI/B+PBE/mZuNO+bqOuwG6J2df+XyxFHd63 + +Xn/ADj7+YQC+b9IubbSfOegXC3ehaVfAfW5by1Yniscg9NDsQom/vOnwL8eV5Nfpb4SPEifqI5D+r3l + MMOauIenuHemmp+ZvyVsbUeZtf8AL+pJ+YsV9LPL+Wd1dXMPlK01KLdrg2gUqsPrcp/q5BkM7yIVKUfM + Q9jAzsZB4J3B/iru9/8AsXLjrCYfT6+5fZWOjWWsav8Aml+bmlx6t5p16OKbylrflZLe+070UQRgR28J + VF5BShlkPqxcfj+L4mwdTOJPh4rxxA/i/jbsXEBczZ+5hnnL81rf8z9EOn6np817r1oyw6NfXzenHpFh + HJyIinQB72W5AHIz/uYU+GJWer5n9naLKZ8Q2Hl1/reTi6zU44x3eaX+iTRI9xbkzcBylAWh37imdhLA + Yi7t5/HqxKXDMVfJJ1O+33d8qcuQRER8fvywFokCi46E0y0AlxzsjIk6AjfrXCA0SkGb+UvIOq+Y5kMU + EiW5+yUUtJIf8hf4nNdqtfDB5n7kY8U8nJ9k/lR+Qlho1nDe+YLZVidVddMNSzHs052qfbOI1Wtnnld7 + PSaXQCG8vk96gt4LWFLe3jWKCMcUjQBVAHgBmEBTtgKVMKXYq7FXYq7FXYq7FX//0ff2KuxV2KuxV2Ku + xV2KpT5j8zaD5S0qbWvMd9Fp+mwD4ppjSp7KijdmPZVBOWY8UskuGIssZSERZ5Pjz82f+cnPMHmxJ9F8 + krNoXlt6xy6g3w6hcoeoFP7pCPA8/wDK7Z2Gh7GjD1ZNz3fw/tee1XawHpx83zu83JpUCSR8aMZG6Sch + WoapJp3rvnSQqyAOTo5En1SNk9O73oX115VA5P8AzU3OZPCOaCLDJPJ+j6d5i8wWulatqK6Jp0zj69qs + kRmFuh6fACN3PwrU8f2jsM1+s1IwQJFSl/DG+bmafAcsq5DvZd+eXkryH5PnNj+XWr3OpPZWnHWles/C + QH/ehbpaIS3IK0SLxj6jY5zmi7Wy5eOOahf0fw8P9F3Oo0EI8JgNwd/Nidt+YOva55S0f8ufy6uB5M1W + 9k9LzAls8Om22pOnER3H6TLG4hBUc7mJ2WPlVo24t6eaPVaSWOfEPVf+nv8A3wdvjygiqfTHkrzl5j/J + KDR/y4/OLzJba95c1GxF/pPmoBks1toI2F1p63ZLtcvEQgiVkEk0MgUMpUJmoOmjnkcfDwkb8I/iv8VN + uvgF2+R/8SWHl3z5NrfkILaWGlahPc+V724s42aCKZ3EXOCUOiji3BAQNgOjZ2ujjHwhhz8JNcI/3vxd + LngRM5cd3180Xd2WhfmDYajF5hu7Ly35ys/W17zp+ZXmC8mvLvU7dZOMNtplqoAD0YB4Eo/JY0RvT2zQ + azQZMEuKAJ/3Ls9PqYZhtz7mAcdY0mS0tNf0270yTUE+saUuoRtbz3FoGKpLwcA0amx+yf2a5gRmJjb4 + t0hwmkWzb70I2oB0FO5yVIQ95fWdjCbi9kCRDoe7HwUdScIQVvl/y9rvn2CXXZEm078s9I1OwsfN2p25 + D3djZ30lGuZIj8RjVQatTgjFefXAZDkOvX+G009bTVfLf5N/VdB8iyQ6h+Y3kXzBcXfl/wDMLTjDNpeq + aDqsKtJb3npsDK4U+k0QqsUi1imALcpRjw7y5/xR/nf8StvNmk9XULrU/Tjjur6ea7mEKiKJZLiRpXEa + D4Y0DMeMajiuQMrFDkOQVE6bq+qaLqVvrWj3s1jrNpIs9rf27lJo5FNag9x2KmqsNmFMkJUVt9PflF+c + 35o+a/Klz5Q8uuvmH81kvp9Wju9We3gtTYpGqkvUBpXVivpxxBW5byMsS5KIx3xS5dQOfwQb6PMofyL/ + ADf8+WGu/mDe2Vxc69czzXLWt5F6d3qssT8LloeFEjaPjRI2VfU48Yvs77YdqYoSEIR9Hf8Ajm4ZwSkL + PN55pt5q0uh3Plg6pdW/l43jXNzoIYxx/XUBjZ2UiqvSqsP+CXlnQ4NFizHxaB83VanVTxegBEokcKpA + qBIYgFjTcgKvQb+GbyGOMRUXSmZkbPNTuYYp5oZuciTwcuCBiIyGFN1BAb2r0ywQsg9zHiMYkfzkm1HS + /V5XdotJBvJEOh91yjNh6xcjBqa9MvgUsiQsa9CNjmIA58jSbafZXF5KlvbxtJM+yoN/v9smZxgOKRoO + DLc0HuX5YfknrHme+gpbGYfaeahFtD/rN0Y+2czru2P4ce33/scvT6EzNl9seRvy00LyVaQ+hEJtTROM + l21TuTXYHpTOXlIz+p6HDp44xtzZtgcl2KuxV2KuxV2KuxV2KuxV/9L39irsVdirsVdirsVYr+YnmfUf + KXla81XRrSO/1oDhp9nO5iiklO/xsN6AAmg+19nauROSEJDjNAlNEg0/Pjzt5282+etXbUfNd3Le3MZY + RWp/dwW5X7SRxVotO/7XjXPQtKMOOH7uqPXveS1M8uSXr2row+eJnna8WWVlCCMxFz6K715cOnL3zaYy + CbJcDh9NAdbTXyj5K8xee9Yj0Dy9ELzU5VaRbfmIwI0IDO7tsqioqcOp1ePT4zOfINuHTnLKhzT/APMj + 8pvM/wCVWsadpPmF4Bp+pvEsWuWYMkJQketxSQq3KIVNH4B9t6ZqNJ2rDWCXBfFH+E/YXOzaA4iCTcSn + flqDybptprnljS7w3zWyzXkl9qQFvLeGKH1ImRQTUFT8PFj3XOQ1U8mSJlL6gaNfw/qd/jjGJAHJkHlT + yvpWj+S5FvJopVAMZmm4jmt5GGYEHqQpp8swZAyLknZ8++ZfLVr5c8xR6Npmq2WuLKYprKTSZvrJV5Gq + ttJxApOtKPGvLan82dTpJyywrLGq/ncpD+cHBy1E3EvXPKnl2+/5yI/NOew86+ZYNFe3j/0HTFj9OMQQ + AhrXTbfl6SenxLSgn1Ny/wAfxcaNVCWniTp42P559RH7PsXTyOUXk59zLNZ87fl35F8u6j+RvkTylZ/m + FrNy8Wnv5oZYTZ32oXDsSsvoHm00NVjjRJKM/wDuxPizW/k4zrLmkYy51vx/1oObx8O0Q8x1z8nvzW/L + Gy0bzf5i0eCyjs54bjTb27ltLw22orVovWgZmRm2qE+Mbe2brR9o4dVeDJE/0eK9/wBrqNRp54iMuPn/ + ABAIDUk8qfmfNLb32sRaZ+Ymo2rav54/Mnz1c0jihtiqta6DbW1FaqgcU4iRYl9FO+avW9mZceX0esXs + I/wj+k7LT6mOWF8u/wB7xnUdcOhXN3p31eZ/RothNdcUeWE/YlcKSKMKMArNT7PLNcI/ztj1bfc9D0D8 + otP0+10jzL+fktxp3lTz5od63k3ULMvJcWWrDi9sZrOMeoyMu6Lx9N+a8mXBCE8sjCGx6d0vJBIiLPJW + 1v8ANXVvOV5MiRReXdQuNFsvL3m+z0qQrDra2C8Vnu1KgMafBxG6p+7Z2XbLckY4rERz+rujL+isZcQY + yEVUoCqqmyIo2p8h0pmISWR5ryOTbbgbnx+nFVoYBqda9AfDFVaMywFbu2mmt50DCOW2doZV5gq1JUKs + vJSRsemWQmY8le8+QPOX5n+fvJNz+Xfljzta+Wl8t2DXMVpdTva6pqoZnLLFelloFJ4tVh9tKjj8S5mH + JGB4jDi7/wDpFrnEkbGkQv8AzjB5zi/LOXz39bS281BTqM+k3M0CWc1gAWIM5O1wPtksfTP2eXL4szNP + 2vkjl2j6P5vX8eTjZdJGeOjzeLJfG5sGvrSEzuB8ELHgfUpUIWP2QfE53WLLxxsfJ5fLi8OfDLl3qyCV + hE0qAEgM0YPIKxG4r3zKidu4uOQLobhc8Mgl9RZT6bLtbcQEUj9vl1/GmR3Ju9msjaq370Tpfk+bX76K + S2BSBzxklC/beuwiHVq/zfZzQ6/tLDpya3Pd+OTtdLpcko0eT6w/Kn/nG2RbeDUNcj/R1k1GEH2rmZfF + mPSvhnE6jXZdQbJ2+x3mHRxjzfUGmaVYaNZxWGmwJb2sShVRABWgpU06nMUABzwKRmFLsVdirsVdirsV + dirsVdirsVf/0/f2KuxV2KuxV2KuxVA6vpFhrdjJp+oxCW2fcqdiCOhBHQ5j58Iyx4SyjKi+LPz9/Je4 + 8vu+rWUP1yyklEjRq1GkNfhDDb4h+y/7X2WyzsrtDJpp+DmPp6H8dGrUacZBxR+p89fWhFzctSBS1FbY + rTYhl8R3z0vHkFXz83k5wMDRZ9+VEXnmfXZNV8g6Vc6j9ThMs8lvJ9Wl9I/a4TNReQpyCdWAznO1e0oz + 9H8I6+fud1odJwDiPMsI1/zD5z84i585aveTX9lNMyCaVGeOE8iqrV/u5HrmPotaMBAAHq6uVqdP4oqX + RilrqJlNrYX0kkNrA5NtdxMfVgLGtVDGhT/itvh+WbLUaUZfUDUv91/WaYZOEeXcyzzNqFv5gvprnQr2 + 6j8tRRpDA2otHGiCNAryMsbMC7NXYFuK/CMx9L2fOO+QsdRqwKA593VkX5JfmL5e/KvzfFr8un2uo6aF + KXc93GPraqKnnZF1IidTvSo9UfDyw6+eOY8Pex3f778bLp4zj6pden46sZ/NDXrHzr5u1HzhoukJpNhq + UwaeK0BSH605Y+sTX4ZZQayEU5NX3rX2TKWKHhGW/wDD+oeXk5GpsniDLLP87tb8t/lpL+UGl+WtJfS5 + Lea3v9WmHxtJcMZGn40ADxg8UYtRacuwwZ+zDkz2SSefF1+bVh1o8O+TAvNXmPzR5pSyuPNuu3euTaZb + xQWIuy0kENulFARtlMhH2m4+pJ+07Zu46YYr6S+qTifmZTNHldfgKV/ZWesLCb2JVigHK3EfISSK4rSU + NULQ9OGZ8tNLKeImg6eGWWC4x59ZfqQV5pVrNaQJIiLa2hpDNNuIlP7MZO/+xXIZtNgB4pAWG3DmzS2i + SbX6bJDquv6OuqX91Lb2xtdIsHm9W8uodPWQ1isYgTSRQzNBH9hW3OavNkAuQof7GPvk7Tw8koxiSZfz + q/HLvZf/AM5Ky/kl5W1TQ/LP5M2Eqa1YwJJruum4adXlmBcQz+oWZ7oV5TPULFX0uNaiPjzhkJcZld9O + /wDpDu/S7oS2qnmukarFq0ZBUJdoSLiIbqWH7SHw9shKNITOlKsT8RHQDt75WdmS0Dt1B6DChelQTUml + OuFChcxR3SelPEjpyCrydC5YitRF9ug/ny0Ex3FhL2Xy/ax/m35Vu7Tzh+YC6V5o8swRW3lfy/q8i2+k + T2AVVIDnb1KjhsOQonLkG+HNx6vLAeiIPfX1NUsYPMlm/wCZf/OP3k/8ufy+t9Vk82Wlr+YNnH9Yntpp + z6erRSiv1eO2qzI69InFef8AuynVMjs/V6zxOKjIHp/N/wCkerVqMWIwovELaC6vTaPbVEcxJNmE9S4l + 7BU3FAD1c7Z2s9UIx4yQAOdvKDCeMwAJPST0fyR+VGvecNSSytLU3vxD1DFU2sHvLIaBz7fYziu0e355 + PRh28+p/U7/SdmiHqnuX2f8Alz+THlvyRaw3FzBHqGvijveSryEbeEYOwA8c5yOIk8UzZduKHJ6bmSh2 + KuxV2KuxV2KuxV2KuxV2KuxV2Kv/1Pf2KuxV2KuxV2KuxV2KpZrug6X5j0+TTdWt0uLZwaK4rxalARSm + UZsIyxo8+hZRkYl8L/nt+QWo+WL2bVNOAewuWIhmjB4NUf3ctfsuf2W/azL7L7TlgPg5eX45OJrNMMnr + jzd+VX58eVfLfkRfy/8AMllLperW0sscGs2448UkFKmgqHHdjmz1XZ5l6sZ5tWDUgbS6L/OH51fld5e/ + LafyF+X+mQa1qV8HhkvnjE1rFbyj947M3HlMxJ40+wfj+0uRwdlTySByekD8bNstTEcjul/5D/kJ5V/N + fyzqXmrzJdDSNOtbp9Os4bWbgTcJGpElyZySF5OoRF3lp9oZm9p6zLp6jjiCSL9TjYNOJbmRfP8A5t0j + UdB1vVtDuru21GbSLmaxN3YGti7QsV5xU2ofwO2bDFqTnxCRHDY+lqOnjhkRHfzep+V/IflTzv8AlvLL + Yajx8wUhSKKKFnnt5a8J2mUA1jHUMNqe+cvqYZMWTeq+92eIghmfnv8AL78s/wAtPyVuSdba883axGll + p2l/ZluLmKVSblo2AdUiUO3Mqq8eK/aZcOnGfLliY8rv+r8f0MjQBeW+Wfyx/MDzno8+uaN5duNS8tWd + pK+oag4QQyJFu8UYchpZF2+BFOddl12DBOIyyq/993uihgnkjMw79vgx/VXSCzEEY4wsREtuFAHNeh3F + Rx8M2+cekdzgae5ZDfNHCFGZXJLjbku1BmZW1OFOdbrPJvk/VPzQ872PlGwv7ayub6R0tJNQkMUCJHVm + VQN3eg+FF+N85bXZ5YwZVxPS6TFHhA5bPsrSvyv/ACu/5xZ8rv5w1WRdd8+XCvb2urXpiiuBI6EGPT4W + qIUWvxkEyFa+pK2y5zA8TUy3sgd3KP473a3GA7g+L/KXliDzt+dUWp3Xl6XzV5ZW6fWvMtnpsP1O1FhG + vNml7RjkKyhm/fmtP7zaU8GLCKnLhPd9TASlM30Uv+cgvzF8jedvzGLfldo9roHljSIY9O0y+sYPqw1B + 4KDnJEAFVAf3cIVeRX4n+3xTE8GGK6O/X+b/AGthkZc2PabeS3KNb3tu9nqcDFLm1lVo3Dr1+FgCP9U9 + MiaIsbryO6NeqfGoqpp06CvjkFaCtxL1pGKksx2A8a5JUuudTjijc29EVah7p6Clf5a5Mb+9A2U/L+u6 + PDrNyb7Sv0zbi2kSwheakIvpOPpTykDkyRfE3BeLM/H4gtczcOknk6mLRkziAeiadpuueb54pJJHWzio + kU0vJ+K9CIwSSx+nNxPUYtJH1Hil+PkHWevMduT6g/Kz/nHOa/hh1LUg2maS/AnkK3Nyg3INeg/4X55y + +p1ebVGyaj9nw/W7bDhjiHm+p9C8v6R5asE03RbVLW1T9lBuxpSrHucrhjERs3E2meWIdirsVdirsVdi + rsVdirsVdirsVdirsVf/1ff2KuxV2KuxV2KuxV2KuxV5p+f2pzaJ+VGva1Bbw3bWH1aaSzuaenPCbmJJ + Yieql0ZlVhurUzGzxgQOIbWPf8G3GLNXT4k85eRNI87aS35h/lx6j6MXMN5az0FzaXAAP1a7A6PQ/BJ9 + mRaZtNFrpaUjHkPFA/RP8fbF1mo0/ESRzHMPHTa3C3As2jMd1y9ExuODLJ4Eds6uWQCHGNxVuriLNF9W + 23kSLyd/zjtqNha6sLfzH5rntLqKKShDKWQCBWIoryAVO/w/POY1GpnkyQv1cJd9ihGINPCvPv5e3XlW + xt547h7m/kkaLUrLiv7uSoClCp3qT0+nMrTaoyyUfpLRkgKvqw3R/Nnmfy7btZ6LqMtkJJiFgjlMVZm7 + BlKk1I6Vpm/OOGSriD5uEMnBut+tl9Sm1TWbhtV1+6IFxPcsWjUj+dzUvx7KPhGWGUMMNhsO5queU90T + /pj/AMS9l0X83vP35UeVJ9J0S/AsNU5BOXBik/Hm0li4BClq8KFW/mpyzmdVmGeVyjuPs/rO1ww8ONB5 + Z5ltPNNn9Qm812Mmn3WoRjUo7e4h+ryulwxYSOp3PMbgtufDNtodcMkRAfwOLl03DIy6yVra4DKJ1NY2 + +0vgfDOtx5BkjYeZz4jCVEJfqNlJAVvtPLoInEytGzJNDIh5K6MpBBB3BBquYGbCYHii52k1Vekn3PRP + y30uX/nIP8ybTTPzN88XMOoyQcbKe7Cy3F0sPW0teVIYmIq5qhL7ni75oddkywxkYYiMR9XD/uq/FO+x + SjM+r5PpT81/On5c/wDOPXkY/ll5A+qReZr2MCazKNe3ipJSt3dlWXk/UqkrD1PsqBFmiwaOeQcch6T/ + ABH0g/jycuWQB84/kP5c1jSPPc/553XlSTVvIOiRzz31/eBZJZ9SuXCvcWMCAK9yCWPpovpRBuKsrcch + MYIjgviPePoh5b8wxxiZ3eYeffOvmP8APj817/XdH8vTLrmquo8t6RpMAeb0IWKr9ZEQrJIV3llbYNse + MaqBjT8LH9PK9/6XubBctkubUptOml03XrOWw1y1JjvLCSMxskkZ4sGDbqajp92RBjMXE2FIMTuk2p60 + q/FcEip/dWqHcjtXwHzy/HiMzQajIBKUsdT165QLESGNIbWEE/QB1J983WHRxgLk4OTUdz3b8rfyN1XV + LqItZte3TMoSzgHJFLD/AHY21adSB8K/tHMTVdoiI4cXz/UwhgOQ3J93flp+RmheUIIb7WIkvdZAB9Mg + NBERuABShI+7NFwykbm7SMREUHroAAoOgy5LsVdirsVdirsVdirsVdirsVdirsVdirsVdir/AP/W9/Yq + 7FXYq7FXYq7FXYq7FWBfnV5S1Tz3+Vvmfynoixvq+pWgWySZvTRpopElVSx2UkpQE98xtSJHGeEWf2t2 + EgTBPJ+bGjfmJ55/KK91SPTUELyyfVPMflvVYedvcNC1DHNE1Cki7hZFPJa7VGDTZseUcMhxYzv/AE8Z + 68Pn5NmfERt1HIs68w6H5c/MfRYPO/5ZSySxRiOS+t5CfrWl3dK/VbvboGH7if7DrTNrp9TLST8PKeLH + L6Zfzv8Aj386Lp8uAS5bS/H2JTbfmrqdvaWel+bDOlppMjGO0gjjdPVYksx9QhlIY8gq8lrm3l2b4hEs + chR5X+xqjqjEVIe9jPnv8y9c89yhAkdvpdvzECooE0rSUDSSsNyzUAoO2Zmm7Phh3O8vsHuYZM5nsNnt + v5fH8hPK35Sahe6ho/6S836rZmwvbi7nV7k3brvFAjbwcGoYxGvNupfNNrZ5Z5tpECJuPD9P9b9bsMQH + BuOb5puLdIJY56tc2ayUlP2ZKA0IoejU6e+dJlx+Jj2P1B1EJ8M+E8w9I0Dzcltqfly/vLSC60fyy0xh + vVeL1ZGkKt+9hcgrJRQK04985fJgkCRIHiPxj8HaxyRrYqv53fmza/mrqWm39rZzWq6dAYJ7i4ZXkn3J + SlB0QbVP2mzYaDRSxEykebVlycWwZNof/OPmsXf5O3X5q6Lr1tqV9CPrNxoMRCQJZQpymjklkofrSV5B + RRP2fiLDD/LE8GpEDD0cjLr7/wCr80S0sM2OjzeXQXKTxpcwtygYAq3RgCK0YfwzuITGQPKZsRxmil2o + 2Bjb67p9V4kORGSro6nkroy0KkEVqNxmBkxHGeKOzm6XVEeiXPver/8AOOegflF5085XFj+a17O2sXDC + 40qC7uClnqEoBaUXM7Hm0u3wozj1Fr9o/DnN9pYtTmHFE3GP8Mfq+X83+q9FglG7PN6X/wA5G/nr5Q1b + R3/KP8spxcaagFldvpkCpZh4HUpDZSxla0oyO0Ssg/Yq3TEj2bPBDiy1Da9/qiPMdP8AO3ZzzWeGO5KS + /kd+W35p/kJba5+cD+XkXT9Uhjso/K0y8tSWB2Lh2kFfQhR+Jbl8bKKui/DmuyajFKogbD+Pv/zWyMDE + bnd8y/nDZef7D8xdYl8+X9hqXnTUmF9qNzp12l6luJ/sW5ZNozGoCrF+wnH9mmX6fTHOeIQMI9Nq4v1+ + bTkyiA52lvlTyFqGsyC6kUx2xPx3cysVJJ/YHVz8s2kzi04o7n+aHWyyyybDl3vsD8mP+cZp9ViTVL+J + 7DSmoPrEwpNKD14e3su3+Vmg1GsyZjQ5fZ+1zMGm4dy+xPK/k/QfKFgtholqsIAAkmpWWQj+Zv4dMxox + pz0+ySuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV/9f39irsVdirsVdirsVdirsVdir59/5yM/5x + p0j837N9f0S5i0PzzbxgPfyRl7a9giHwx3KpRuSD+7lX41+weS046/LhOORyw/zo/wA79U/v697kwyWO + GXLp/RfEtnofnL8g7ux1mz1i1u5tYaSO6tbdJhZ3FtAEL290soX1EfltQfD9ob5HB2gMsQDD0S6fq7pM + 8mnAJF8urNPM+haH+ZXlSLzx5YeOC4iYw3+lFqzafMdhBO1KlHG8M56r8Lb5vdHrJaWQiSZY5fTL8fxD + qHS6nBxeUg828laPBN5ssNL1cG1tIpVa8UijCJHHqCh7la0zotXlvEDE+klwdMPXR5voj86V/Ly488eX + LeG1t9LtdKsS872wSrwv8ERJUULBQRz+1TOTx4pcUqvf73e8dxD51/MC2stH803UekSrNaTjm8Q+w61o + P+CHxAjOp7LyT4SD9IdXqcYlXf0KRXukXv6Kt9bht528u3UzRQXxjcW7XEa/vIRLTizKOtDmxM4xnwiQ + uuX8TjwM69cfj0KeeSdH0/VNZ021v50gsp5irgsGkAiALfB4b1HbNdqdVKNxjzrm5WLGDuX1Db2nlPSP + zK03yZFEW8uppEMmtWDS8bV7y4WkN00APH6wIgA0hB69M5eByGB9Rq9v1cX812JIAFPDfzm8pWn5fefL + m10ab61olyFmhY7VVxUo1O48c6fsrVz4alzi6/UYoyDGLWcTKJIW/dEHY9R7HOwhMZI28tnwmEqKlJpm + nTrIjRGknUfs1r4HtlR00bsbFnDU5I9bAfWH/OMGpfkZ5e8v3Wo6rb2uk+etGhNxqus6u6tzt16S2byf + DGoHwmKMB1P89Qc5TtTsnUSyCcbyRkaiB/BLulH/AH5ei0WthOJH0kf7JhX56f8AOSOofmRJJ5V/L83d + p5Tk4xyTsrRXV/IjhldUHxxxAjZW+J/tOq9MyMHZUdOP3piT1/mx/wA7kSw1GrvaDzXyF+RtzrF/D6lg + 2oX8zF4tNjUsnI7lpm2rTq29P5mzX6ztWvTjP+d/xLTi08p832n+WX/OPuieWY4dT8zxRX+sKo4WYAa0 + g9lXoT/wvzznJEz+r8e93GPEIPa0RI0WONQkaAKqqKAAbAADpkm1dirsVdirsVdirsVdirsVdirsVdir + sVdirsVdirsVdir/AP/Q9/Yq7FXYq7FXYq7FXYq7FXYqslQSxPGejqVP0imRkLFK+F/P35Xaj+Y1iNO0 + SWNPMelXLnTLWZhHFdGYcGhMjbIzcB6bH4eX2s5fRiRxAxF0ar9XudpkI49+RD5p0Tzbrn5See7XWJbC + UXWlzPZ6/wCXbusH1mAVSa0uUIIHWo5K1G4sudJopQyRMJ7wP+xl/OHnH5uFqMe+/wAPx3PU9Z0/yx+Y + ejf448gO1k8LtNPps7L9fsK/ZSUqfjiP+65R/qtmfp9TPSy8PIePHLbi6H/jzrcuHj3qpPMLzVfTd4dU + 05JdT3WW6kMqvuNqpzCEd/s50I0OKfqjKVe/b9bhfmckdpJ1+V/kC+/Mrzxp2gQygpIRc307biO0tyGe + u1BUDiFzI1GWGnxGVf2ssQ8SW77e/NsSedPK2q/lz5X8v2kVhpdql7S8RY4JFiq3o2aIKpKKfaFOP05x + mIY8eQZSTYP8P+6P43drkBlHhvm/PS7u9M9eY2mnS2cq/BAxn5PEw2bl8I5b52s8UZxBid3UAShKrvyT + m317zpaI/mWDUI5tRuZBG9yWL3UcUSBQSh6A9B8s1MMdy4JQP+9cuUwf4mmi1HWZvrurXEryGpBnYvKx + 6k79Ac6DS6OQ3PJ1Oq1gHphuUxtYeMbRIiJGu7M2yqPEnN2IxgO4OouU5d5LQvtMDtHWWTjv6karwJ9g + xB+nKvGLdLT0NyirHR9S8zTIsKGLTY25I8oqisO4oPif5ZrtTrY4d5Hc9A5GHFew+b6W/Kn/AJx8vr1I + 7mSD9H2UiKZtTnUNPJy6iNa+Hb7I75xOq188525d38P7XdYNJW5fVvlvyponlSyWy0e3EdFCyTtRppKf + zN/DpmAI1u7EChQTvJJdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVf//R9/Yq7FXYq7FX + Yq7FXYq7FXYq7FXzBavLp35i/U2PpxLel0U/aMiXQpQdwVOc72UaJjfKR+92GfeIPkmv/OTX5Ffl5530 + 0+d9V0+WPzLaGC3lvrGc2rTwF+CrOACr8a0ViOS9OXHbMzW8WEeJjPCSRxdYn/jzXgkJEQluHxp5hkH5 + PfmjN/gRTBaaXDbfVba9Y3SywXdpG8sU/Pd0Yu2x7Upk8WQkGM/UJc+n4KZYwRXJk+taV5Z/NHy9J5t8 + nRx2uoWrhNX0L1AbqwmI32PxSWr/AO6pP2PsNm90mrno5CJ9WOXKX6D/ADZx+102owcRP87/AHXmt/IL + zjp35VedX1vzDbzTQRpJaalb2685Y4pUDJOE6uqsKPx7b5t9dWUAiVQkPTI8uL+bL+bbVppcNx6sh1z/ + AJyOtpPPs3+FtUTUdPvqwLIInjaktSygSUNR0rmDg0chEiYHzv7nJy5K73h2u6U02r3k9qVMEszSEhqh + S5qRUdaZ02k0+SOMW6jJqsZmd0fp2nw2EQb1BLI1TWuy167ZuYYK5h1WfUGY7gmUscNtAlzezKsso5LD + XlKw8afsj54Z5aNAcvk148JnuOSWT3F1qMqwqg9ANRIYqkE/xOYxle5c3hjD6WfeR/ym1nzJfRW8do1x + OQXFmoNKjcCVh0/1Rmg1nascfpx/P/iXIxaeU32P+Wv5CaToEFtf+ZI1ub5UBSwoPRhJ34kKaGngNvHl + nLZMkshuRd3iwDGPN7WiJGixxqEjUBVVRQADoABkXIXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + 7FXYq7FXYq7FX//S9/Yq7FXYq7FXYq7FXYq7FXYq7FUmXypoCa43mNbKP9LshT1yK0JO7AHYMaU5dcwo + aPFHIcgG5+V/zq/nNhySMeHokv5r25n8g6wFFWjSOVQfFJUP6sp7TH+Dy8q+9s0/94Hyh57/ACTl/Na3 + tr3ywYoPPFnoyzpDIeMWorbOIxbu+wSQKf3ch2/Zf4fiFHBIDjh6thxR6/5v6ureJASMZcr5vjT9La55 + D89rc2zyaT5i02f0LuzuQY5FKtxlt542oeJpRlPXqM3OkzCWLvhIfj3SDi5se/CX0fqul+WPzO0Gbzl5 + QRtP1zTYwdc0hSfWspCac4yN5LWQn4T1j+y2X6TVS0hESePFP8cMu6QcLPpxLyl0LztdR1Kyt59OuLG1 + ijjHpzSQ20STkHuZQvI/fnZabBpRWSEft/Q6bLKcomJkQhIfqTO8U8/1QgVHqBiDXp9mudAMwIsC3UHD + LvC2S8iR1g0v97MKg3Dr8H+xVv1nKMmQnyDZHCImyV+maDqesXTCCsoBJmuXqYx7E9z7DMHPqMeIXM/B + vBJ2D6N/J/8A5x+vNakjvpkMem1pPfSjifErEB4+300zktZ2lPL6Y7D8fU7XBowfUX195U8l6B5Osxa6 + NbLG5ULLcED1Xpvuewr2GacDv5u2jERFBkOSZOxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV//0/f2KuxV2KuxV2KuxV2KuxV2KuxV2KpP5q0yXWfLeqaZb0Nxc27pEDsC9KqPpIzD1mM5 + MMojmQ2Y5CMgS8w/LXSNVttf08z2Tw/o20ubTUGIAWORmBVSe7nY0H7O+UaKYlEbdN/6Mv6TdmqzRU/z + l0DRJfMXl6/udNs3mvTJb3N1LbQPK4DRBQ0jIWNAfh32zC7Qww8WBrnbbgmeCXk/O7SNd8zfl15ouL3T + Wk07X9Lnntbq1uFNHCyFXt7iNuqtTdT882GDLGqPqhLmPx/FFhljex972Gx0zSfzS8ljz55XaG11SCR4 + dd0JHDTWUwO3w1qYH6xv26Z0On1M9HMRlcsUvpl+P4w8/qMIlf8AO+95zqun+hcGyuFeG5RqNC6HmxPQ + qO9e2dnhkMkeOJBHf3OgySMTwllHlb8t77UZ7d7yF19Q0WzjH70g9PUIHw/IfFmp1fa0MdjHv/S6fBy8 + WnlOvufXf5WfkDpum2tpq3maFWdQHttMQcY1B/35Tr8vv8M5XJqJ5TZPN3uLTRhueb3qCCG2iSC3jWKC + McY40AVVA7ADYZUBTlqmFXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX//U + 9/Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FWgoFSBQk1NO58cAACvJ/zwQiDy9c9oruSv0qrD/iOanX/AF4z + /SczTfxe55p+ev8AzjtF+a9pqHmvykiW35jWSx1jdhFb6nAENIZT0Wb/AH3MfZJPh+JZSwmEjOG+/qh+ + mP8AS/3SMeQEcMuXf/N/Y+L/ACX+W/59+T/OL6loHlDV4dR0+YJqFtwQq8TSBWjlUSUdDXfrT7WbHF2p + go45SscpRo7S/wB7JqnpjIb18w+7Lf8AJa/1S507UNS0a1sNYnt1luJEkFzHZlvtRLLQcyp+zxH+yyiM + 8gJhEnh+/wB7hS08TvsqzeXI/Jv5jaRpFjIZLZrb1JZ5AA7yyxzK5AXx4ig/ZzCnM/mOA8uG3Px44jGS + Bvb3Dy85k0a0Y9eJH3MRm1hyDQeaZ5NDsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVf/V9/Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYqw/8x/Kd15t0JbXT3RNRtJRcWwlJCOQpUoS + OlQdjmt1+CWSIMdzE8Vd7kYMghLfkUz8tafqNrDLc6iEimulhItE+Iw8EAIZ60Zia9NszYEneqv8btMq + 6PJIkMf5oeZoySOXqyUFKGqxMP15q8O2fIHLnvji9xszWztz4xp/xEZuA4RebeevL+qN540LzNbw+ppM + Si3vJV3aJwXCEr1Kt6lKjofnmpzwMdRGf8NcNuVjkPDMerPtCtprTS7eC4XhIoYlT1AZiQDTvvm0hdOM + UyyaHYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq//1vf2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KvD75Cn5ua5Ep4+pbBjtU/HBF0zSY/wDGcg9znE/uo+97LpZrptoev7lP + wUZug4RReFDsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVf/X9/Yq + 7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYqxnVvJOmapr0HmHnJb3yRmC5MVKTw0ICnwI/mG/HbMKWlH + i+IDRI4Zf0v2t0cpEeFkcUUcESQxKEijAVEXYADYAZmAU0r8KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV/9D39irsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir/9H39irsVdirsVdi + rsVdirsVdir4T/MP/nMD82PLH5geavL1lF5fsdC0K+1Oys7m/t7uZ5zYyyLFH+4kr6kvFYxtwDtyai1z + M/LEY+Pd1EdYZZfDvqendfN5xdf854fniNOju4zoS37TvFJpqabdM6RIissplM3plXZigAPIcCzfCRj4 + I22LmCZ/nBe3/Obn5znV9RtU8xaK2kW9vLNb6pDoc5jlmSHlHCkUkiyL6kp9Lk+y/b+xkfCPDtEpOQAj + 1c/x3Mg/Lb/nK789Nf8AOvlnTfMep2y6XqV/ZWt7bLp9vGWS6nijYBwCwAV/9YHM3JowMRlRBrq6yOvM + swgCCLrZ+iGah3rsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir + sVdirsVf/9L39irsVdirsVdirsVdirsVdir8p/zjggP5pefBd2B1BTrutmC3+JSJnmkWGb4SlfTko9K8 + Tx4vyXkudNHBOemAh9XpeNjqMeLVSM+Xq+8vKDpOsBE52gtGS6e4fV5ZZOTRFFVIDDyaOnIMwbjuz0Y8 + KYw0mpEgZSodXLnr9IYmMRxHuHP8D5p9b6VJY3Uurf4Ut77SZoEI0UtJ9VkYw/7rmWf1FljQ/WBV+XJ/ + scE45hTJiJRMxsR97s4eswkI8wfu/SnXkeHULHzf5a9a4l9Rtc00xhql4V/SEK+iXejHjTiWO5pm1yxP + 5Qky4rF289ilA60AQ4OGVcPn39z9d85F7V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2Kv/0/f2KuxV2KuxV2KuxV2KuxV2KvzJ/OrzD5MtvPPnHRtY0aLUtUh1 + XW5DdSJeCSOa71NRB8ULqrCGH1pU2IqWU/HxXNnLVSjUQTQEfu9Tp8GmHqmQLMp/Li2/S86vdY8nX96d + M8p6PBo8kg1i6JC3PKSGW6UafCxnZv3ccKFk25AufUavS3Sa4w4ibPp5ebLXaHxxECo1Liv+j1UtL8x6 + 7oF3aX2iXsml6jpymOwubeYRm3BhMDMgWMgPwJTl/Kcw56jjBEoR38j+tyY6Ygg8c/mP1Jz5KjnfzH5S + urtVRL3WdMltm5vL6oN7A7kSOBzerVkA+yTm8hqoZNLLGKEox+n+i87m0eTFrIZDcoyO8624u5+s+cu9 + e7FXYq7FXg/57f8AORrfknq9jYSeXRrNreW6TtMt8ltMjyStGFEJjdmX4alh0xgRKYh1Ivlt8+jVlmYR + 4gLHveVW/wDznzaXFpeXn+CzFHZqH4PqBZ5A1aAcLZgOm5amXZcfhmi1Ys0snIfalyf8/DbWRo1HkV0M + jBeT6gAq8iBViIDsO+U7N3q8nrX5Uf8AOTTfmb5/byOmhW9qkULSvqUF+ZwxEXrKEhkghc7bMSPhOCUg + CAL38lgZG7rbzfQmFsdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir/AP/U9/Yq + 7FXYq7FXYq7FXYq7FXYq/K389/Lfme4/N/zrqljY+vptzqN9cQuskYrHb3y2UrGtSpSWVeSn7MdZz+6+ + LLcgIl8I/aHDwTBiaPKU/wDdl5M2jeYfLfmKxn8x2/1VJFvLeRlMbGI2dxJbyB1BqvGRSu/2xRl+Fhks + UZTB4RezdOcY1Z6prd2GpPePMtjcNDvWNIZDwXqpbYAddj0OUCQttZV5K1aPUvMH5dadDel7W21zSPQs + inH0bs3Ua3nAsAT9mMMR8H8ub3TaeIwSmY1Mg7/0XSavUyOeMAfQBcv6x+l9Ga7/AM5i/mNaa/q+m6fZ + 6J9VsLue2jZorlyBFKyBWb1lqwC70Azz7P2llxyoAfa+69g+x+k7QwceSWSMh/N4alH+dy2SLVP+c0/z + b0eWaO80vTvUgjWVoV067JPqRsyB39ekamlasPs7rmXpNVlzCzQ3ed7b7O7N0c+DBKWb0/VxRoTujHaP + RAaH/wA5q/nN5g8w6bokVppMMWp3SWqvbafPeXCiRqAxQ/WUMreCVXlmyMZj+L7HloZcBIBx/wCz/wCO + s5tv+cnvzGs/zH03yr5n1C103Qbi4t0uruXy/cWl6sc4BA+rS3jsoZiE5ktQHnxNOOavJq8kZ8JO3fX+ + 9ewh2JpsuilmxiRyC6hxCUPT/F4gG9c+H/NSP/nN7S7rVvzJ8rWVrb2cMl1Z21smtXDFp4Ga5nPBYhUt + Ger/AA5tDlEMm8pfSfSPp/rX/OeBMOKPIcxuXzH5l0q48rxarZX+tW73UlvFNL6M9zYpIzh1MYiji4yM + KftcY25cMullGUAgHbvao4/DNEiy8/sb61W7tWE6JxljPJnaFVowNS6glKfzAHj1wNj6+/5xXurfVf8A + nI2XVLQRalA1k6/pZ9Ql1OaNvqVDFHcTRxvKpINaqOFFXfBLYwFkc/TW3vKIfxbdzJP+clPP/nLy5+cW + tafoeta1o9rDpllNapaXpW1muJAOTCGTkigLXkF4OzLy6fajCX1WQfV/pfT197GeMSkPqG3f9W/6HlP/ + ACtT81E1OR4vPsv1f0xFHczvNMrggc3Efw8WYj/Y/s4JmEo1vd9NvhbPFhyQlexHL1er/O96np/5hfmN + cSStd+c9ejtYzbwhINRuS3q3T+nHxZlfkg4lqnixX7PLpmXLKBEcMQf2OFDTEzInIge/+c+qPyq81ebE + /wCcZ/N3mS6u7xPMVja6pd2Gp3dwLydmjtBJDOrMzgbioRqcSN0GYmKfFKXq4vVXdw/0Pg584cMBQMfT + 1/i/pPlLVf8AnJn815LWxOiectUhljhVdQmllinWebgtXRHtISiliQoUt0b2zYYY2TxVX483AzTIA4Sb + P47ls35//nLcWiV8+6yms/3v7uWxh08oTspcoz8+P7PHY5Uc0BOgPT8eJujiycFk+r7Fuh/nV+dWu+bN + P8vz/mhqel2t1PHDdTtJFLxQkcjEywEMzCvCtBy+HDmyRjiM4i6HJjjjMzEZbPoC8/Njz9NqH5daZBf6 + joyf4n0fT9QkubuK5uNY0y6kMfObipRHcrWVIgi0b4c02g1p1GSQIHpieV/U7TWYBhjEg3ZD7Am1TT7e + Y289wqTKAWQ9QGrSvzpm1ESXEsLDrejqKvqFug/ypUX9ZGPBLuWwov5n8tR0Mms2KVXmOV1CPh8d26Y8 + Eu5bCGbzx5LRlR/Melq7U4qb63BNelBzx4T3I4h3p1BPBcwpcW0iTQSgNHLGwdGU9CGFQRkWSpirsVdi + rsVdirsVdirsVdir/9X39irsVdirsVdirsVdirsVdir8z/zw1Oez/NTzdaW+qPa2Ud/fp9VjufSjBv5w + 9ylAw/vWjRpR3oudjpNPgnijKYF0P9j9LwGp1mox5Zwxk1xS5C+fPoyv8uNI/IL8wPKFzL+dfnpJtX0/ + WbxrG61HXY7Sa5iuo45vWMR+Jf3jOu9fiTlnPZc2bFtCFe4X9JPD07nr8WKGQ8UpEmht3cQiZfPqfg8J + sr3yzpV7YJd6lb6zpcJt5tQjjuhMjfE5ltvRkKRyBKJ8biki7NQFs3GlhmzRJkRCulfXt1/m/e6nV+Hh + mBCEpXvxb+jevT399cmcoPLNhrH5RrpFgHPmPWNP1TS7tRbKLJLPW5ra5tUaBEMiyD0yZnqzNHTZcwBK + RM8fFvjJ4v5p4oCqdhKI4fF4aEwOY4Z3GUvqilN7f3+n/mP5gtbSGDTptV1C4sbYzW/1lJlkumbmQd1L + laeovxJ7559wiWTvG77Zg1Z03Zk5xkeIGPCR/k5Hnt/F7j3sZ/M7QmstR+tXckMt9qNvFObaKG6vGjkb + mColYpuWFRUNxqtNhmfpZCBMeW/K+jzfaYnrMMNRCB4alCc+GMI+JGW/pjyu+aSeTrHVh5g028u9Huv0 + fZzx3N7Jc2TXEP1dTV6wM0Xr/D/uoOpk/mGbKeSIvd5vFos8pCo/aHqfk2dNT/Nnyjc+QtPsNXreWws7 + GXTF0qxdgHD8rSS5mClAGkD+tvIobjyHHNDkleao0Ts+lxxcHZUjmMoDe5RPFIcR9A2A+qW3C9K/5zm+ + uW35n+WtU02046lb6ZCtpqpkFI5GuZ6R+k3wkEEku2y50G0p8EpUK+n/AH1+T5LIER4hGzfP9FPlHVtS + 1e7ll1TW3S81W2khhPqxxSQNHxYgOq1VqH6MyIgYhUOrSLnK5cwlUt+tyWVrGxj9VmBMVrHGQZDuVKja + n7NPs9sBmW4h9If84V2wi/PmFfq7TfVrO9jW8Len6f7kihjA350/2NMOWX07872aMMd5bcmR/wDOUk0V + v+euvxE3AkudOsSPUJEB/wBG4kIDsRt9oft8sxqPDLlV9OfIfV+OTlRIGSPO6+H+a8WZ7dFIm+IuPgYb + 0Ayjfo5dplDqr6X+i7tlmkg+qw+pHA6BjLFMzw1WTY8DU/zUJ4FcyY4zOFR524s5xhOzyp9TflYFi/5x + F8+o1tdWrix1eSX61I8gld7IMZoC5PGJz9lV+EfFkcO8pbxPq/h+H1/0+9GT6BV8v4v97/RfG3mCbzI9 + 95bTXtPt7CL9GmfT0t2Y+tA4YepJzJPKoP8Akn9nI6WOMQycEjLf1X3rnMzPHxgDuSiFbUlRNQIRVa9K + 03rTvib6Nivb3c9jLpd3Zit1FPcNBJx5UI4hGINK8WIYb/CRyzJx7wk4+SuKLLPyyvdW/wCVreQrC7vj + c2tx5j0e8cRuXgll+sqFlqQvJhVgW+eZGPBhETOAIoV+PJxMmbKZCE6PV9tfnamg6h+a/lzSfMkkstk2 + lanc2mlRXZtPrl1DGnFVHJVd0B5ojfa3PxcKZkaeREDXUtuUWXj/AJ00T8uLL8xPy90WV7ez8lanfr+l + 4Lm95tcWjIQJLogj0v33GBj8CMnIf5WT4pUd92AAt6xYaT5h0+K9ufM/k/ytaaTp8UwhNnaWDl4Y4bop + IEHNioMVuPSXd/Xp+w2N+Z+1r26PGbi+8v6hbpZNpd6FkstNuNau9WsBaaZJPM8LamqmREWFYI2nMRVY + isiosHNqVIBtmdn0j/zio7SflLbNzleI3c3oiYkusZjiIBB6eJA/aJzWT+o+9yo8ntuRZOxV2KuxV2Ku + xV2KuxV2Kv8A/9b39irsVdirsVdirsVdirsVdir8n/8AnIiws5fzf87SMo5nV7vcb/F6h6kjpnU4QPCj + 7nh/GnHPMDlxS+9W/Jjy9+Yx8v65rPkjzVpnl+wS6ktprC+ginu7+5tbCTUXjtvUtpwrC3gkKszItVzR + 9oy0oyQGWEpnncSRwRMhHf1R/ik9RopZjjJifu57+TPZtF/5yGgutPt/+VneXhbyW93Je3k8NqkOlJaQ + 2lxJFcFtPNX4XsFBEHHx9aZqgOztyMU7B23l67lKPp9ffA/U7IZNRt6h58u73JZ54k8zf45/IiHzteC/ + 846bqN1pesXUaRxxtNYeZjCDH6SRqUAAC/AvTxzY9mSx/vfDFR9Mh/nwcLXcXADLmSfsYf5jsv8Anftd + 1Czup55otVu5XnXkrRyJcOP3bEEAIo+E06nOJzZ/DmH3LsfsmWu0GSMhwiX93foGSQ3E+L6uG/T6Y+qT + DvMd7cao0erTXV3I6xRRQ3NxKhkjEEvp/wC6VjHduBpXifttm+wgWCOofNdYJYsJxXXDOUZVfDxR/HVJ + byW9syDHqF3M3KN6C4l5AcgDuH6EbZnDd0D1LyzaaDb+fEj1aaW38uprMayyafEDLGgm9RfRSTr8ZUH+ + VanrnJaivHo7C33PQjKexJSxVOcoD0zF+czvz2Jp6v8A85ywRzfmx5cDWc7vJo6Qi79ThbL6k1yoQgso + qSd2J2GdXZ4qsVXL+L3+58NI2ujzfJmt8rLhpgRaRpbC5aFhMpuY4uDsrKzBhvT4Tx9syOEyiCPP5NAm + IyIKUF0R3A5M0fxU4EA+A36VyHBLubfEj0L6d/5wxUt/zkBaySwTNIbC7cyj4IomktyxRl5ENtsre2Mz + 9Ivv+LHHHcsh/wCco9Lstc/PvzBbT6umnx22kWcsk15FctFG6QqRHC1rHIysQ3Lm44Bmocp4uEHbmenX + b+JsoSmN+Q+W/R89uCFiYXsqhuIrIgIXmw3NOVAoPxUDZAGPc31PoQ9r/KbzH5C/Lc61a+ZNbTUV1K3t + pdNvf0dcS0kVplK/6TCGAFQwZRw4t/MMwtfjnliDCJ2vr+pt0hGOR45Ak0Xq35TTk/8AOHv5kmG8lvWj + ttYX05U4iD/Q1PpRkgckANVap65n4oESNx4dx/ncvUfNxcsxKO0uLb/S/wBH3PjSXT9Dvp7aHSvMcbuu + mxPeX2qySpBbSKaCFHKM3wAglVXgvRa5finOMZeJCrP8P+6ackIyMeCV0OqXzNLV5EuI2iH2fSjYqwG3 + JatX4qVHzyu4+bf6vJkeg2dnoOq+W/NU/mC31WNLpJrm006G69W2Zh8MKPIqRtKCaOImb9quOQGeKUYj + eurGNRyRkS9G0bzFYa5+e/kq4n0+6F02q6FBZfW+UD2hW9V/7s1qpU7DbI6TDMYyQaFniH8/ZjqcsOMA + izW39Hd9Qfn75fk8z/mXplomlR6pFZ6fcS3Ek0VnMlkp9IpcA380EUTc6Is3PmvLiq/Fmyw1wE+bCZo/ + B4D5z8hal5s8tX+rQ+U9YddKE3o6pa2Gn29vdSw1jlMjW9xNLc20YVuMkSyA8f3bGPllnVqJpFxai9hF + 5fa90G6FlqcMVvpkkGn6RWW7S19Rl4vI5K+mnOMsU+18Q5GmRIBv9qhQ85anqcnlSaeDQZbVZFQSXN9b + 6I8ccE7hC7JaMZA7clEbr/dN9rLMVAoN9H1Z/wA4mVP5OWDNXkbmblUg7hYx1HyzX5PrPvcmHJ7jlbJ2 + KuxV2KuxV2KuxV2KuxV//9f39irsVdirsVdirsVdirsVdir8u/zo8s/p782vzCmuNe0/Qvq2sXHpDVkv + U+sq7HeFre2mB4kcTUjxzZy1csUIAY55LH+TAPDX865ReXx6aE8uQmcY+o/V7z5FNPy7m8p+QtIstB1f + zdo2qSalrd5ePdWK3729nBceW7/TVkuna1RkUzzxp8Kvs3LNLqvH1GTjjiyREYVUgLlLxIT9PqP8MS9B + glhxQ4eOJ36Hyl7u9lerecfJ1zovmuSz1zTnjtm1GFYD67SXrXmn6HbxyWkbRBpYjLZzgsvHZKkb5hQ0 + +ojkx3jnvwnl9PryS9XceGQcnx8RjL1Dl/vR+lj35patpusfm7+WB0S+t9VSHzJe3ssmllrmGKDVPMS3 + Vv6jhAFZozUod075n9jRyRhk44ShtCPqHDfDCpU0a+UZCIBB3J5pp5J8waBFr97p+szaJYz/AOK5prSb + Wo4vQu9N+tOl2sk7HkCP91oPtN0zm8/jjKPD+n+P9v6XrjKMuEzMjICsVE8Ua+jg/wA55f8AmDb6B5h1 + zU9Wa9msY3vLwRRQrA9vBGssrR2ksamsZqirDJECnFqGlM2GGcMYPDz5/j9Tm6rT6zV+EM8QBtC4R/ec + G15ZR/j+rfIfqYJb6PpktxLHFdtaQxRc5p7gPJGrvULVokYEUG4ycNaZRJoNeq9nY4MsMfFKfF9fCABj + 3/nn0nb1HuT/AEPUWmu7cz3jXc/6RtT6rH947NIrt23q3tmlykzmJEbl9K0csen088EZgxgKib8j378L + 6E/5zD0/Q9X/AD98vWPmieSHQBoVubh1lMKLzu7gVLUIH3Z1mTKcYsVb4Bw8cqPJ5hD+X/5PJb293a6h + dQXS3EsTWsWuafJJFDGSIplLRhTz2PDqvfNdLtDUEUQK/qlzo6HAJWJLpvyu/K27keZ9Y1eWd6cpUvtL + lMhGw68abeOQj2jmiKER8pMpaHFI3xs0/wCcbtC8t+V/+co9K0byvez3timlX7zSzzRTfG0FQv7lQnw/ + Tm2x5jlxgyFF13AIToG07/5yH1OCy/5yI8wGbX4bQjy7DHFG2ryeX/RZ41PoG5VJQ7S/b9JlVGWlTXMa + cRUvT/EP6XF6fspyoy9Q36Hb6a3fKq6vYf6Mou4Q6yQ7iVYePFl35VPp0p9ofY+1+zhAZ8Q8mf8AmTzP + ZpqNlNBc6ZrHC1eJkudSl8z26O8rk8pJ1h4v+0Fj+Cv739vjmTp8dwIsx36elwdVm4ckdhLbl9T6O/Ka + 9W6/5xB/MyN9QhuoLSy1OGMI1Wt0FgrCKSpoKE1HbicjCIGSVAj1cz/F/SDYZmWKNkH09P4f6JfJHl7z + Tp+papbyxfVdB+qabHZNLb6qulmV0cN6sk8iSVLHZUCcU69BgODw4HcyuV8rpMc3GRtw0GJXWqafwmU3 + cLvykDD1UkJJZqnkCA/+sPt/ayIDbbI/M2tQz+VtEgm1SK8khdT9WfXG1IooiUKPqiRxxQKNhUO0m3Bv + s1y/ABZ/V+lpy/Snv5LX/lj/AB55AtxdO3mZvM+kiO3jt4zbeg17GxdrppfU9UfZCCPhx/ay6QkJbfTX + 42cewRv9V9z7G/5yQ89+W/LOu+a9Gv2s7rzJq2hQW+kaTqNt9ftJ+U0cpNxDUD0x6TUZtuajLMMhwkef + 6GzICSHlOvfm55B80eTIP0rc+YNB8z2WkNpQ8ueXZfqeltLxQI8VD6IjBjURc6GCL93wfitcgzDVwG3m + 175i8i30ekSX73a3thbC3uEg0/ToY2/dryDAy0no1aNIA2V8Y/Fs6Wa/5+0D9GfVtDSxub6Th6n1vRtH + s1RArRMPUjmaTkVPNGXbls9WXnkRIJA/Fvtr/nDu6tbr8k9P+qzJN6F5cwTemyuFlj4BlJUkVHzzFn9R + bhye95BLsVdirsVdirsVdirsVdir/9D39irsVdirsVdirsVdirsVdiryNPNnn+41LzamnVuv0VeXFlpd + q9pDBbSAG14Il1JcLzuAJn4RuEjlZeJaP7WKpZJ+Yfn29v8ATbbytXVriSzaWWwn01rN/rcGpLbTQ3jP + L/ozRQt+8O6mRfUi5xsqFVmXmDzhrEkmkaRo9ncaNfazqK6cupapbK0cSi2uLpmjQSUdyLfgqsVHx8u1 + MVYtH+Z3mnVtAn1K2ht9OS48k3XmS1kWNpJotStzw/3YSjQ1+JFI5EfaOKoK+1TWdN063vL6NUs1jkvd + ZZrPSrjUbKFfRUXclpCR6tiR6ju0VLmPmv2lU4KCbKa+U7nzNd6xqMz6SNW8vW1zq1pKr2dhaH1bXUmg + sxaMDH6gECv9YaWnxKnD4iy4OEdzPxJd5Qus+bdVt/NsthBpdtp9nY3Wh6f+ibq3gka4bXmnRrhpIy1F + g9MMBG1KRzc/8g8IY8R72Tfl5Hql5Lqh12XTNStojaPpl3a28MErloALiQRpUrA0yv8AVWf94yBqs68H + YcIYndiNrrPnLUdIl1O4Zb+8fUJ7K3huo9KgN3bwancwMmnGTrcJDCvwXPwPy24thpUHo+p+Ydd8xWke + gWkOr6XHDpF1eLcaXZ2UX1ac3cd96vIiSO4DQARxKzKJV+L90xKFU3/MHWbnSTZW1hodpoMj2Wr6o897 + bWVyZf0ParOsCiNpFCyF/jNQ/BG4U+0qqL8l+Yri5852dvM1hDp2rWN5c2tjb28CSW11avb+pac4iZBN + brKwu/VorM8XoheMq4qoavfazceevNVvztf0bpUVo9rJfW9gunxyz2ErhLyeX/SOLyhOLR14fZ+ziimL + X2reY55LDSdFsSvmV21G1vNKudK0t5Y76Kxt57VZZk/cvbs7mT14inKFwpVZExWme+ZLy90vQbcN5att + L1G5utN02XVvSs57KB7+8gtJJo05lyq+ozR+oij7PqeGKWMSedNQX/CugNBbLp1/5nu/L3mCVtODW+q2 + 0R1G3jEYVGiBf6qkkxH2fsKApbiopd5q0fy3ZfmLFoqabpdnoMel2t9dRC30iCKFpLyaJpZEuLdpJVcK + sRRHX/Io5DY2tBin1ewUabpz6VYnWrrULCCQaXa6FJbXtpeW9+ySWFzJbjikskCsIJgs0Hp/adH5spZb + rOiXvlf8vb291DyBoNz5i03SmmutWtrSyNsbpIeUkotxEGKo1WZdq8T0XFFMc1C90XQ57u5iktxa+XNQ + nmivtLh0e11K/srYaeS6mSydJjDLdPFSAwO78V5epTFNM4/NqygfXPLkcGjWd9d6p9chup20a21e9K2s + HqwhPrDJRVYmoLftbceuG0UGG+ZrfS9Ij8xRyeVtBttQto2uNDjGgWl3bXdvBdwwvNbTRtR3VGb6xbyB + ZY3dPT5RoWc8R71oMq8t+XfL4sinmf8ALGykuTczpZXVtolkvq2KyFIZZ4jvFIyirR+FG+HlwV4j3rQY + Pa3GlXL6JpMXkzQLjVPNtjZaxptxY6HZSixhvYL24a34ytGkjItoAju8fItJUfAox4j3rQe8eQ/8PS+U + tKv/ACxBaQaTqNvHeobC0XT4JHnQFpPQWvAseqksw6FmyJKWR4q7FXYq7FXYq7FXYq7FXYq//9H39irs + VdirsVdirsVdirsVdirFpPy48jzXt5qE2iW8t1fvNLeM4ZlkluQokkKFioduC/GBy+Eb4qjtO8oeW9J1 + CPVdO06K31GO2exS5Xl6n1eSX13Ukk15SfGzH4mbqcVRes6HpPmGxbTdatEvLJmWT05K7OhqrKwIKsOz + Ka4ql1x5F8oXV/8ApK40e2ku/qDaPUp+7/Rrdbb068PSP8nHjircXkbydAiRxaFYqscgnSlulRIAoDVp + U7Ig/wBgv8oxVNdP0vTtKikg021itIZZZLiVIVCK00zcpJCB1ZmNWPc4qpXeh6Nf3keo3thb3F/FE9vF + cyxI8iwygh0DEVAYEgj3b+Y4qh/L/lPyx5TgmtvK+jWWjW9w4knisLeO2WR1UKGYRqKkAUFe2KoWPyH5 + LiE/p6BYL9ZqZqW8e5LmUnpseZ51H7fx/a3xVMrDQtG0u4lutNsLe0uJ44oJpYIljZorcERISoHwoCeI + /ZqcVX6lo+lazFHBq1lBfQwyLNFHcRrKqyp9lgGBoRiqy20LRrPUbjV7Swt4dTuxxubyONVmkFQTyYCp + qQK+NBXpiqEufJ3lW81Rtbu9Gs59WcgveSwI8rFYzEpYkGpCMUBPRSRiq+18q+W7GW0uLPSrSC4sGmay + ljhRXhNyoWUoQKjmqhWp+yAvQYqmN5ZWmo2stjfwR3NnOpjnt5lDxuh6hlNQRiqBk8s+X5YdOt5NMtXg + 0iRZtKjMScbWVBRXhFPgYAkBl33PjiqtdaHot9dx397ptrc38PD0rqaCOSZPTbmnF2UkcW+JaHZt8Vcm + haJGVMem2qFJxdoVgjFLkDiJRRdnptz+1iqOIDAgioOxB8MVQK6JoqQWtqmnWq21i4ksoRBGI4HBqGjX + jRDXeq4qgvMPk7y15rNs3mDT0vXsxMLV2Z0aMXKenKFaNlI5r8Le2KoO4/LnyPdQXVtPodq1veqqXMIU + qjKrpJsqkBatGhbjTnxXnyxVk9NsVY235feSjZ3VgNEtVtbydbydEQofXQkq6MpDJx5Nx4FQvN6fbaqr + ILW1trG2hs7OFLe0t0WKCCJQkccaCiqqrQAACgAxVVxV2KuxV2KuxV2KuxV2KuxV/9L39irsVdirsVdi + rsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdi + rsVdirsVdirsVdir/9P39irsVdirsVdirsVdirsVdirzDU/z68haQ+pLevdqml6lJotw6QF+V3ASJeAU + kmOOnxuQFXBkkMcRKR2LXCUpzMRE7e79azzP+fPlDyfqKab5gs9Rt5ZlWW2mWKGSGaJxUPGwmqV7dMyD + hIjxWHAj2hA5/BMZCXCZXXp2875pQv8AzlB+W7Kx9HUwUPxr9XiJA8dpt+vbJfl5WRtt+Nmodq4zCE+G + f7yXBXD6o/0pj+GHmqD/AJyc/LZmKqmok0qlLeOj702/e/rpiNPI1y3+z3pydqY4RyS4ZnwjW0d8n/Cv + 5wVV/wCck/y7JWsWpJGw/vGtlCg9eJ/eVrg/Lzq/Ovx5N35+HijHUt48fFXo/qX/AD/6K5f+cjfIkvor + a2eq3VzOSEtbe2jkn2Fd0WavQV2yf5WVkWHAn25ijijk4Mh4r9PB64cP88Xt82T+afzc8g+SdO0jVPNW + qfo231yP1dORoZZZHXgrmqwo9KB1rXxzDyEQlwnm7Q6zGMUcpNRlVf5w4mMj/nJ78jjGJR5rj48uEg+r + XfKM/wCWPRqo9zlPjwuv0N4yxMYSvbIeGH9I/jvVl/5yU/JRpXgXzVEZEX1BS3uaOtOVUPpUbbwyB1WM + AHv8i2WOKcb3xC5/0fx5NL/zkt+SjRxSjzTHwlbh/vPdVQ/5Y9Kq/Th/Mwsju8iw8SNYzf8Ae/3f9L9X + +cq/9DG/k1znj/xNHyt15v8A6Pc0Ipy+A+lRtvDI/m8e2/1ctiyMgDkF/wB1/ef0f1/BTm/5yT/Ji3MK + y+ZVDzgFEFrdlhypQECHY798nHUQldHk1Z9RjwxjKZ2mLj1sfB6srB1DrurAEH2OZDe3irsVdirsVdir + sVdirxj8yvzl1nyL5zXy9aWFndWH6PS8Mly8kLmaRpFCc15KBRKj4DU/D75pdT2j4GoGOVCJiZWf52+z + 2XZ3s9+d7Plnx8UssckYcEarwzw8U+/08XewWT/nK2+jvfqTabpon5JxiM9wJDG0LOWIEZIHIUOx4fZ+ + P7YMO1MUgDY6d/8ANs9OktmOT2X1cCQYS24ufD0nwx6/xQ9bo/8AnKjUyqSzabYQ2/qW0cksgvRxEynk + zcY248WAVx8Xp7U9Wu0h2lj2s1y6S/zunRpn7OagWBGz6uGpQN8J/d/xfxx3TPyf/wA5D+ZvNHnjy55b + bTLGLTdULRahKonWeKZUduIEjAKfhG3Fx/leGNDtTxM0IQoiX1c9pbuzy+zHgaLPmzcUZ4z+73jwzh6f + VLn/ADv6L6OzoHgnYq7FXYq7FXYq7FXYq7FXYq//1Pf2KuxV2KuxV2KuxV2KuxV2KvhHSLfzHrv50fmR + odtdW1t5bi1u7h1VLoFxLFeXszoix8W+PmDR1KsFbo3TLzgjliBM7Dp3uF+YkJS4RZBr3bMaufOWpfnB + +Yx0TzBZW2laNot/+ibOCycyFY7aOTnF9YYK0jMY/tUX4TTjXMqMrNdA4+I1CU+pZ35i/LzyjF5Wvrux + t00+ezga5ivldy3Jd6PUnkrdOlcvLGOWV7m7Q3l3y/5esPLOlXV1oY1K51S3N5cTTFyVYNQoAuwUBkp/ + Nv4ZNjKciefJPNS07RC0NvHZW9jWO8ea4lXkEFhxUqBK3HiSftnsMIkWuys8kWGmW/m3RdQsAiXSo8sV + 7aKsUckd4lzbGNwhKn7PJG69f2cEx6Tbb4ku9K/+cq7r07L8loeAMF5bTRzKKj4DBamgp03zQ6sXKR97 + l6XBDLgxRmLA4dvg8T8reWtc1zTrPVtR1v6vDerJLHb29tbmRU5lFLO60qeNTtmjzakQkYgbjzdzDQYp + AExj8kPf6D5ps/N2meV4taQ2uqK0lteyQQq6Rxk+oGQLTmCKCmzZZDURljM63j0QdFjEq4Y7+SeQ6Xoz + uyHzBqKsqs07SQWkYAjNH5H06bMQp8H+HrlBzz/mj7Wz8lg/mj5BWvNBntnvksr+7mttKl+r3UszQRn1 + hGszBFjtpCFCsPiJG+GOc7XW/wCO9H5LDv6R8gyDyRp9pLqnm2y1uNNZgstA1aa1hv0Xlaajppt3Esbx + BOQ4yVRtmG/LJiZkO7Zw9ZpcMcMqgNgenc+4tb/MLyX5KtdLTzdrltpUt/DztRdPxMoiVS5Wg3pyFc6L + Dhnk2iLpw8mpx4ogzlVpKn5+fky4qvnbSiAaV9cDf6RmR+SzfzS1HtDTj+MK7/nf+UcY5SectLQU5fHc + KpA8SDSgyP5TN/NLGPaellyyRVLb86fymvLqOytPOWkz3krrHHbx3UbSF3IAHEGu5OJ0mYfwln+f0+3r + G7x//nMDzX508sweQf8ABOtXmj3uoapdW8pspfS9alqWVZAaqwB6Bhmo1kzHGSHpuyMOHLqBHN9FSlKu + fpFvj+//ADl/NKxTUrPUPPfmR7KeRmZ7SV5mE3p0QByyPEtR8arTbcDlmNhjOYBJIIc3Wz0uKYOKHFA/ + TxHhPxilUf8AzkX+c36Rt9XPnDUGuYrY24jM7GBo5E4tyiFFLAfZcjmPtcq5l/l9vql83UfmYVXhh7H/ + AM49fmD+YmtebfJ9vqvm3Wr7RZtXSS4s7m3untWlu45laOS/eTiVHAGKKjIxqq8eOUGJjkAs1bk8UMmO + UuAA13j/AHPN6n/zkWwb8044iyq8mmWccXqMkacnluPtO7Kqjb7TEZzvbOKeXUxjEWTHk+m+x2rxabs7 + Jkyy4YDJvLfaxH+aC8j8y3er2HkvWrG3muGsUu4jcNZ/oyTT+cbRktLPzF6QOQ4mA+l/sOebPsSJji4T + 0lLu/tea9s8sMup8SPKePGQfXH07/wAP0fP1d7z/AELU76w1rTLy0vb1Jy0g9W0vILO4P+jtUi4viYEH + vIOnwp8bLnRTvhNfj5vn+ERjMEgfb/vfU9p8l6gt7+f/AJauyVczz2fKYX8GsM5+ryAF7q1Cxs1eq8eS + ft1zkp3+ehZJ99dx/mvrGDh/kPMIgAUfp4v50f8AVLl+jufdudY+UOxV2KuxV2KuxV2KuxV2KuxV/9X3 + 9irsVdirsVdirsVdirsVdir4d8pQ2Mv5y/mkL7Tl1Mt50tFtIHcxiO4juLiRZQelUHxUOzZkDkHHwWJT + INc3inkmxTVNb1dJJp4PrHmnUJIrmyXndiSOWRw0SllHIEDvl+Lm1E1B7drlh5l8waDcaSb3VpndQghm + 0+3hS4cNVRJLGxJDEdf5svBAcQEA2gvIt/ruk6ffaXJdX9uNKmW2FrFaR3cUUjA1Uux/d/F+zXj+10y0 + hE6JtlNxpM+uOLrVzfTsi+nAZdIhk4LyqRyElDU7HscjE1yr5tfJLLCW30nz75T0i2aS3IvvVu9Pe0Sy + jBkt5FikHpk8iQxpUnjlnOJZx70r/wCcsnI0/wDI9wOkEvw/88bUZoNT9Uvi7TQf3WP4fc8e8i6nqena + JbRnULCay5SNb21yl0J7cM5PAyRIQVJqyrvSuc/qYRlLkb+G7vsRIHNK/M2p+ZbDzXbebEnhuJreJFgm + tYZRaRhQyei4mUGr1NSac8uwRxnGce/6fsYZOIS4mbWvmESos3LQPVuUDSx+hfOeM5ErGSkZorOPiY7N + IBmCcddJbf1W4G+5A32jx6rNcS3upWs73Vz9ckt0l1aNTc8QnJUWIDlxovXplscvCNgdv6rExvr96ffl + 5fvN5z8xWUd5BfWi+UPMDeva+qQZ5IUkmaV5/jeWqKG5dKccvEfRdEG/s8vJwdbvimP6J+56B/zmhDPc + t5K4mUW0WmStcmCMzlEkkgX1DEKFwpp8INP5ts7bsrYzrnQ+/wC2nke1dxi+O52/hG3F/Bx8uL5PluC8 + eTTpEuIoLg3UH1GUyQxuWijYVK0A4FmHJioVv5sozarJOR3Ic7T6DDjAqIJvj+f/ABPJND5iv106O0Fv + ZpDFD6KyJaos5QLxBExq3OnR69cpGoyfzz82yWh05PEccb76ejflrqh/J7zhb6Dc6yi2F7eabLDeWiiD + 69a3ULi6iuU5PKR6ksVHqPsOV+Cq4c4nqIiYB5dPex00oYZTgTVS691bcP6nuf8Azm1p9xf6T5AtrUol + x+lrwq0hZEFLGQk1QV2ptTNXnjGUalyd/pNVk02TxMZqQ68+fk+F/PVhBozxLcXFs2oXyC7urQfWWa1O + 6cVnrR1kKmSvUV4nK8AAFDo2arNLMePv931fxVH+EeTDFvbVEUGShoAainbMxwKL6F/5xouNKb8xvI1r + 61jLqT6nbzRr/pzX0YVZuSgki2TahdSpqtPTblyzCyfWPe7HFGQwy2PLuH/ST6o/OPUPLek/nBNfeaXt + E0b/AA7FFcC+hS6hcyzzLQxOjg7D+XMKfhjXjjqvDPPv4noMAznsOXg8XF48fov6eD7nzr+a/nKbzRpX + mCz0B9Kv9OivZLpLk2MDTQxRhEWWCdQrRhVovAVHFj8OY+PLOGsljhAcJPEJV5D7HYZ9Jgy9jQ1GbLPx + YxEJY+LYy4j/AA/zuvm8f8t/p9dYsZbu+tU0y3lU3TTWUepxRxspQlrR9paA7Ie/E9s38uOjVPBwOESH + FxfDm92/KnVL/VPzg8mXepTJNNJd2foTQ2qWKy2yiSOGX0okjT4wtTQFq/azlDGY1cOMUb6U+qQngl2P + m8GRlExv1cXEJcQuJ4n6JZ1z5K7FXYq7FXYq7FXYq7FXYq7FX//W9/Yq7FXYq7FXYq7FXYq7FXYq+J/I + 7A/nL+ZfH/dnnqOJqmnwp67N865kx5ONhG8/i8W/J6ytr/XtTjv0E1tJrWrTrFISE5QeqwLEdq7nL8A3 + achrH8nrVlo+h/oiPzTrunJdtK4t4rLy9LPd2gUuY+YCuC8hO0hP2RRcyDzpxbN0PtQNlJ5WtjrrLpss + lrbyKEsb2+a1vDwXk/px9ZN6ceZ5j7NdsmCdt/sSQVvlT9H6hZGW7QSOhkL+vqxtTyMp4fDUkEAUHTl9 + rJk/imMgjILOPSfzG8q6hF6IhlvRCFhv11BjIEIJJPxIlDQV/axJsJjyLX/OWp46Z+SBpWkMnT/jFaZz + 2o+o/F2eh/uofB5L5dsbqPRNEtNMa5jbUopZJrv9IGAWshkerRW4NXp14r/ss0OYjiJlW3ld/F30eQpU + 83rodvpmo6VqGta1Le2aRs3rCS4tpJWFYy6lREVrT7LDj+xXIYOIyEhGIB+H7WU6qiSlmvah+i9O0+W2 + vdUg1Z44Y7adtTt7m2SNArSx8Yfij3YcFanH6Muxw45GxGv6pB/a1yNAUyu0Go3KtcC+1kmZmaGR9dso + hFGGHwvuTWoPxd9umYsiBtUf9JJtF+fzWflvaT6Z+YOv20vJFuPLXmCSIyzRXErxS2bMDJJCWQuSKtTM + 4yEsYP7HA1IPBL3H7nr/APzmGk8i+RPqxjEp0+4Der6YVlb0BwDSbAk02/a6Z2PZgFyJ7h97x3a8gIY7 + BPPlfd3R5vkuzMZslWadDcxtIso5jlzVqfECa123HXMCY9R95d7jkDGJHKh9yJldDbSKrq1Y/sBgajsN + j45UI7tlvS4fN2oWXnOaPQLhNX0S9n8uXD6hYtLBdW9/Y2y1it/RWRSyqzeqsi8GVPnmdDSSy44ni4aB + 2PvdRm1kdNOdxMrIlcfID+x79/znFeTab5Y8janatxkg1a44t6ayij6fMDVWZRT6c1GUgDd6bTYJZpER + F0DLu2jzfBfmvVtUvdYR7x1F1bcYhwiSKgUcgGClwdzUfEwyOKIsss3ohERO0t0Ba6tqthIZrW6MTsOL + MERqrvseSnbfLjEOHZ73sn/OPDH/AJWz+Wl0WaS6vNTlNxyClf3ZljVloBT4RmvnERzCg9LizSy6DJxy + sxIjHYcv63N9H/8AOSk93B+aAayvZLC5bRbZI7y3p68Iaa4DGMkGhI2rmg7Zzzw6mE4HcR/S957GaPFq + +zsuHNHihLIL34OUR1fPutQ6fFa67PDafU1k06NoI3uBdGecSxGT1JTHESXbkxBXipLIvILyzI0M4y1f + plxCvtIH6bdb25gyYuyayw8OQmIxFb8EZSEZHr9HDz72L6h5n026nV7QNB6SgSyUVCSDsi8eoXOtMnyg + QoPYPyZe0k85flq0TJNJGLFZHFS0c3qS80O5AI5DwzjdWSO0YV3xfYeyICXs5nJG4jk3+Mfxb9Cs658l + dirsVdirsVdirsVdirsVdir/AP/X9/Yq7FXYq7FXYq7FXYq7FXYq/OjUfzct/wArvzg/MqG70H9Lm682 + TajBIZ/q/ptA8kXw7Gp3rU7AZm45RA3FurGT1SAkI7l4z5W/MWfyos91a+lHdz31/OTMjzJwvSwKUQ1q + A2xpTIDIYchbkxjGcaJT7y1+eeo+VIZLPSp4jZSEubeaCZ0V2FCyig4lqfF/NhGoPcmeGEtyURF/zkBq + 0Et7cLJBNLqLK1yJrQyg8F4KsfJaooH7K4fzBv6ftY+BDvV7L/nIa9tDEWtrG4WA1jWex5AbceJIAJUU + Hw5L8yf5v2oOnh3lQtPzpSXzjpvmCGyg+v288ZtrJIJERyvwpGSg2qT9qn+tk/zMpEAR+1jKGOECTLYP + Zv8AnL2dLXQfyVvbgFY4bSWaUKeRFIbRqAj32rmt1APER72/QyHgwl0ofc+bZPMFtL+iJP01FbT6MhSx + kgtrj1Y6v6lS3GhIJpUdswhh57fU7Tx47bsivfzPvL+wk06TXbaGOZDHNcQ6bcCVlbY8a1VTTuF+WYsd + FGMrr7Ww6oEVf2IU+eLeSK3hOoWKi2CCGSLQ2RwY1KKWIHx7H9quSGkAJO+/9JH5gVz+xXTzrp/pspu7 + Ay1R0lGgMXDJsSN6EsNnqPiXD+V9/wDpl/MRP9iO8h69pPl3WbrWNPma+e4sb+xlgNnLaRomoQtE7o5J + UMtaqnTtk8kCRRcPU6nHDGeI8wQPk+j/APnL3S7rV08kabb2Mt8y2fKNYF5ssrPEqsFG+1K/CD9GdX2V + znfKh97y3a8zAYqNSPEB/S9P07Pka50fTZzbrfWfqSwRGJgxUyNNHVA8jUqStOJX9r9rKMuaBkfSD8S7 + HFp8kYACdE78hX9WvsRbeTdDm0+ZYtPt+dtpl1rVxMKmf0bIVkiCryDs54noOC9wlcnDweATMd74aaZj + U+IccZiqEuIijueEj0/Y+3NK/wCcdfyx0TTI/MfljWtc0vWlsI55ZLDXTA1zKkJkRZwlVfdivhTZfhzT + 5tYZjikQSB5O5w6QYgYwBAJ5Mf8A+c4Wjb8rvJd3eRkr+lUEsabGsunz1A8N8x9UCYennb0HYZhHMfEB + MeCUSBz9T4Ev7HUDJBdyIWhuQZYSzhnZWqAaD5b06YMeWIu2rPppZZcOMfTyHl0URZXziqQs1B8W4BFR + XoaHpmQMkSL6OvlpckZjGR6jyj135PaP+cdFvm/N78t7a4jEEdhqDqtDVn9X1ZCT8uVM15yxnmHC9JLQ + ZtLoJ+IKsjZ9Jf8AOR2jeZvMP536F5e8sGEXWo6LG8jXBVY1WG5mFSzVC1LBR4k5re0tIdRnEYizw9/D + 3u/9m+1IaDQTyZDUPE9Xp4z9I5Bgd/8AkB5t1fTby3v721OukoLJrTW7CGyjEbcj9YjMTPI4I+HiRTvk + NN2d4UenHfp32/Wz7S9oxqpgevwiKyDgqcvdvwf6ZAD/AJx587DTbw39/wCX7QWjNPe+Yn1mIm2iDDiJ + oVtxHQsGUsfHY5suLNHGb4TLv4uGIedMdBPPGhOEOXB4fHOZ8t/s6LPKXkrzD+VP5weQPLF6LNbW51i2 + LS2tx9cknaWQO0shKrwLArxA2p0zVnSTjqITy/USDt9L1eLtXBl7Pz4dJYxwhKJEx6z/AEvjXT6X6HZ1 + b5O7FXYq7FXYq7FXYq7FXYq7FX//0Pf2KuxV2KuxV2KuxV2KuxV2Kvkzz9/zhvqXnXzdr3mePzfb2Saz + ez3q2x09pWjE8hcKX+sLyIr1oMv8U1VOkl2ZczLjO5JYIv8Azg7DpmprZ3P5i6M2oTALFY3mnD1WMx4q + VjN4GJJBCbdcqlIl2OLTiBsm9ljf84Wafa2tuZ/zJ0BYbWdg08tgo9SVQWaKRjegGg349seIsxhFAXy+ + 33prJ/zgfqX1e+r5y0pI7z43m/QzD0QBWsR+t0QbVwcRScQN89/sQMv/ADiBYWN1pV7cfmR5ZgN3EbfS + o5dNiWK7HwryRWvR6zgkfEtd2+WPEaZeHHiB7gnmm/8AOEHmHSYoo7PznpayQPJLHcnRCZwZagj1PrVa + AGijtlkMsoSsU4Or7OxanD4UyeEm9jv/AGPU/wA1/wDnHKL8zPLnlHTb/wAy/ouXyjYtayXQtVlinrFC + rSEPIvpgejX7R2OUZLmb6uXi08IYo4tzGIAH+bs8jh/5w58qywvPF+Z1nLp0boglS2tmAnZSyhpBcU+I + b8e4ynwjd25Q4OERraJsJhY/84aaPNeSWtp+Y8U+rxApfQRWVtI6xpRSDEJyVPxDkT7ZA6exV8mwZAJG + Vby2KKk/5wq0G1kt7G689vGJWK6ZayWcCSPKikmhMoaSgqzAYfB3JvmwuPDGNbR+lVsv+cMvL927m08/ + S3N1bv6OoNBa27mqjj6bqsh4nrWu+D8vtTPxBcjW8uaa2v8AzhdocMqxz+bb2XTFYMLMW0S7AUI58idx + 1NMB09m73aZxxzgISjcY8h3PWvPXkD8vfOuo6dYeYdVktNXsoltrK2tNQWzuSkhqAFB5ktx2p/L8ObHF + lnjvhNW4ubTY83Dxi+E3H+iXml//AM4wfkHOz383mG+t/Xnk5zprMSK8/wBpxVlI5DqQMiZkt/CE3j/5 + xL/LCygk/wBP1UW/oyxStLdREehKKyAsYhsQPuyQzTAAB5G/i1HT4yTIjcjhP9XuS3Tv+cS/+cfLWSwl + haaZ7x/X0w/pED1uFGJhEfHmAKbrWnjkzqJnnX+lj+prOkxkVv8A6aX62Yfnv+Vnk/8ANLy3o/lTzN5m + PluCwuxf2sqS26zS+jC8BX/Sa1AEu5HemYk4iXN2enzywG491PEJf+cHPyrtGnFz+Y+pQPbMq3PKTToj + E0hooesfwlj0r1yvwYuWe0ct2KBTWx/5wP8Ay8mhju7bzprV3BMokiuV/R8odW3DLJ9Xao8KHIHTQPf8 + 2/H2zqYcjH3yiJS/00t2VeS/+cVfy6/LrzNpfnf/ABXqVzcaRcg2wvprOO2Nw37sI5SFCSSaBeVeWCGk + xwlxBOr7a1WpxHHkIMbvlTKPzV/Kf/EPm+w/MG28+yeSdVs7NdLtLhYbd0Y+o81GNw6q9f5CP2a4Z4Ly + DICQQKa8HaPBppaeUIzjKXHvfP4JE/5b/mFQE/n6FVoPrqEaJogrbMC3rD/IO55/Z98t4ZfzvsDh+Li/ + 1Mf6aX627b8nfzL1iCS5s/zylv7S4HozSQ6Bo08Uixk/A5UMrBST8Jx4D3/YEjPAcof7KX61Cw/5xr1H + /HOl+fvNX5lXnmLWtBu7e9K3Fla28fC3PJY2WFwEBHemUZNNxzEpSPpdhp+1PAw5MWPHEDICJHe30SrK + 6h0IZGAKsDUEHoQczHRt4q7FXYq7FXYq7FXYq7FXYq//0ff2KuxV2KuxV2KuxV2KuxV2KuxV5Z5o0bUp + vzBudTh0a7v7C40zT7OkMVl9WuZIZ75njmuJyZYVj9eOTnGA1fscmHHFWNWfkjzNJJpGmCwntdNttQhM + WoXtnp1zfWsA0m8s5Ip2BMd1FEZYo4Lh0MrB5Oauqeo6rMPNX5e6u35e3nlHyvqtw9vBp8Nhp2mXJhCP + DaiNfRef0xIfURChZnp8fxfDiqSaN5K1BtTsLq/8s2zWGo+YL7Uma7jtJLjSdJMAnghVWD8DNdxJJIkB + +Et8XTZV7HiqD1eNptKvoUjMzyW8qLCKEuWQgLuQN+nXFXhVl5R8w/4P0WxXQtSi1zSLWK3iu5rfSvSj + kOnpbNaSWYIjurRmDK7uRInPlHJxq4VZH5S/Lq/n8xan5m1f1tF1K11K5uNKitorYRh7zT7W2nlWQh2l + irHIkaShRQK5j5LGyqqXnjyN5r1HzCk9oX1WS7s7C0sdYm9CNtOubLVFvppXVBGFV4gAGjUuzxrG32lx + VH/ld5W1vQda1O41Cykg09rSG3tjdGES28qzzSyWkDQf31qhkrDNP+/34MzfsqvVMVeU+YNE1KT8wNVv + 10S71DTb+w0+0CQx2a2t08Avg6zXMp9aERevGwePi3L7PLfFWMW/kLzJfPo2kz2Fxa6TDeMi6jdWmnTX + 0Fo2j3Fk8d0VJjnEbPHFDcFGkdS3NGVfUdVmvmzyBqz+Qrjyv5d1G4ubW2tbS1sdIuTAEktrJ4SYGn9M + SEyRRGMs70bn8fw4qwK4/LXzPezyy2lpc6bca7fm4tyY7SSHTNNj1iK/WMv6vqW8xT1XKwrIjs6pyV4+ + WKs6/MbStSvPM/lzU7LTry8t7G01KK5lsbeyuXrcyWbLAy3p4hZlidWYD4R1ZcVYleeUPM4+uWtjoc0V + jNdWVyIrmKxv5rKaPW4L1haXPJGntmRZJ3in3hdY0jb4vTRV6d5d8myeWbS2sdO1m6FlFLLdXNuYrX05 + p7qd7mdqelWNXeRqJGVWNfhSmKvKbjyT5hudNDW3l2b9H22s+Z5P0DN9XjEqa4ky2d0i+oU4o0vx1KyR + iV24/BirLPN/ljXT5K8jaV6M+qarod7pkmo3dpHBczIbS0kiluUW7+FjyPcM3xfZxVj2reVfMd1DfPpv + l+6ji1LTLuK+0y/j0+aNuelNaxT2zRsPq12zcYZbdG+rMjO227lVmnk7yBdaFpn1m31e7sNX1VYLjVlj + gs0T1YraKBEEJjkSP00jCtwPxtVmZvhoqkWpeXb+af8ANuEeXria38wWUMdgeEHDULhbBrZuIMg35ld5 + Anjir0byolxF5Y0aG6t5LW6hsreKa3m4iSOSOJVZW4swqCOzHFU4xV2KuxV2KuxV2KuxV2KuxV//0vf2 + KuxV2KuxV2KuxV2KuxV2KuxV2KupirsVdTFXYq7FXYq7FXYq7FXYq6mKuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2KuxV//T9/Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY + q7FXYq7FXYq7FXYq7FXYq7FXYq7FXUxV1MVdTFXUxV2KuxV2KuxV2KuxV2KuxV2Kv//U9/Yq7FXYq7FX + Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX + Yq7FXYq7FXYq7FXYq//Z + + + + True + + \ No newline at end of file diff --git a/Sources/ESP8266Wizard/ESP8266ClassWizard/Stdafx.cpp b/Sources/ESP8266Wizard/ESP8266ClassWizard/Stdafx.cpp new file mode 100644 index 0000000..fd72d88 --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266ClassWizard/Stdafx.cpp @@ -0,0 +1,5 @@ +// stdafx.cpp : fichier source incluant simplement les fichiers Include standard +// ESP8266ClassWizard.pch représente l'en-tête précompilé +// stdafx.obj contient les informations de type précompilées + +#include "stdafx.h" diff --git a/Sources/ESP8266Wizard/ESP8266ClassWizard/Stdafx.h b/Sources/ESP8266Wizard/ESP8266ClassWizard/Stdafx.h new file mode 100644 index 0000000..5b2f342 --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266ClassWizard/Stdafx.h @@ -0,0 +1,33 @@ +// stdafx.h : fichier Include pour les fichiers Include système standard, +// ou les fichiers Include spécifiques aux projets qui sont utilisés fréquemment, +// et sont rarement modifiés + +using namespace System; +using namespace System::Reflection; +using namespace System::Windows::Forms; +using namespace System::Runtime::CompilerServices; +using namespace System::Runtime::InteropServices; +using namespace System::Security::Permissions; +using namespace System::Collections::Generic; +using namespace EnvDTE; +using namespace EnvDTE80; +using namespace Microsoft::VisualStudio::TemplateWizard; +using namespace Microsoft::Win32; + +[assembly:AssemblyTitleAttribute(L"ESP8266ClassWizard")]; +[assembly:AssemblyDescriptionAttribute(L"")]; +[assembly:AssemblyConfigurationAttribute(L"")]; +[assembly:AssemblyCompanyAttribute(L"")]; +[assembly:AssemblyProductAttribute(L"ESP8266ClassWizard")]; +[assembly:AssemblyCopyrightAttribute(L"Copyright (c) 2016")]; +[assembly:AssemblyTrademarkAttribute(L"")]; +[assembly:AssemblyCultureAttribute(L"")]; +[assembly:AssemblyKeyFileAttribute("ESP8266ClassWizard.snk")]; +[assembly:AssemblyDelaySignAttribute(true)]; +[assembly:AssemblyKeyNameAttribute("")]; + + +[assembly:AssemblyVersionAttribute("1.2.9.0")]; +[assembly:ComVisible(false)]; +[assembly:CLSCompliantAttribute(true)]; + diff --git a/Sources/ESP8266Wizard/ESP8266ClassWizard/WIFI.jpg b/Sources/ESP8266Wizard/ESP8266ClassWizard/WIFI.jpg new file mode 100644 index 0000000..1a6eb0a Binary files /dev/null and b/Sources/ESP8266Wizard/ESP8266ClassWizard/WIFI.jpg differ diff --git a/Sources/ESP8266Wizard/ESP8266ClassWizard/app.aps b/Sources/ESP8266Wizard/ESP8266ClassWizard/app.aps new file mode 100644 index 0000000..d261cf1 Binary files /dev/null and b/Sources/ESP8266Wizard/ESP8266ClassWizard/app.aps differ diff --git a/Sources/ESP8266Wizard/ESP8266Template/ESP8266.vcxproj b/Sources/ESP8266Wizard/ESP8266Template/ESP8266.vcxproj new file mode 100644 index 0000000..26a4e35 --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266Template/ESP8266.vcxproj @@ -0,0 +1,83 @@ + + + + + Debug + ARM + + + Release + ARM + + + + + {B6F35D7A-A6AB-4F29-ACEA-F9D910ECF3CD} + $(registry:HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\ESP8266 Wizard_is1@InstallLocation) + + + $SDKREL$ + $SDKVER$ + + + $SDKREL$ + $SDKVER$ + + + + + + + + + + + + + + + No Boot + + + No boot + + + + false + $(SolutionDir)$(Platform)\$(Configuration)\ + + + + + + + + + + + + + + + + 0 + 2 + + + + 1 + 2 + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Sources/ESP8266Wizard/ESP8266Template/ESP8266.vcxproj.filters b/Sources/ESP8266Wizard/ESP8266Template/ESP8266.vcxproj.filters new file mode 100644 index 0000000..ce31bfa --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266Template/ESP8266.vcxproj.filters @@ -0,0 +1,27 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Header files + + + + + Sources + + + \ No newline at end of file diff --git a/Sources/ESP8266Wizard/ESP8266Template/ESP8266ClassWizard.snk b/Sources/ESP8266Wizard/ESP8266Template/ESP8266ClassWizard.snk new file mode 100644 index 0000000..b1f0e99 Binary files /dev/null and b/Sources/ESP8266Wizard/ESP8266Template/ESP8266ClassWizard.snk differ diff --git a/Sources/ESP8266Wizard/ESP8266Template/ESP8266Template.csproj b/Sources/ESP8266Wizard/ESP8266Template/ESP8266Template.csproj new file mode 100644 index 0000000..52cc2c9 --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266Template/ESP8266Template.csproj @@ -0,0 +1,129 @@ + + + + 15.0 + $(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion) + + + 14.0 + + + publier\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + false + true + + + + true + + + ESP8266ClassWizard.snk + + + true + + + + Debug + AnyCPU + {82b43b9b-a64c-4715-b499-d71e9ca2bd60};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + {9B3C4F6A-8DB2-46D2-B7B8-EEC4C59DC4CB} + Library + Properties + ESP8266Template + ESP8266Template + v4.7.2 + 512 + false + false + false + false + false + false + false + false + false + false + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + x86 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + x86 + + + + False + + + + + + + + + False + Microsoft .NET Framework 4.6 %28x86 et x64%29 + true + + + False + .NET Framework 3.5 SP1 + false + + + + + Designer + + + + + + + + + Designer + + + + + + + + + + + + \ No newline at end of file diff --git a/Sources/ESP8266Wizard/ESP8266Template/ESP8266Template.vstemplate b/Sources/ESP8266Wizard/ESP8266Template/ESP8266Template.vstemplate new file mode 100644 index 0000000..7b7ae75 --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266Template/ESP8266Template.vstemplate @@ -0,0 +1,28 @@ + + + ESP8266Firmware + ESP 8266 SDK Visual Studio Template + VC + + + 1000 + true + ESP8266Firmware + true + Enabled + true + __TemplateIcon.png + __PreviewImage.png + + + + ESP8266.vcxproj.filters + USER\user_main.c + INCLUDE\user_config.h + + + + ESP8266ClassWizard, Version=1.2.9.0, culture=neutral, PublicKeyToken=7bbe0df5c1453a1c + ESP8266ClassWizard.ESP8266ClassWizard + + \ No newline at end of file diff --git a/Sources/ESP8266Wizard/ESP8266Template/INCLUDE/user_config.h b/Sources/ESP8266Wizard/ESP8266Template/INCLUDE/user_config.h new file mode 100644 index 0000000..b2b7324 --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266Template/INCLUDE/user_config.h @@ -0,0 +1,18 @@ +/* + * File : user_config.h + * This file is part of Espressif's AT+ command set program. + * Copyright (C) 2013 - 2016, Espressif Systems + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of version 3 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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 . + */ + diff --git a/Sources/ESP8266Wizard/ESP8266Template/Properties/AssemblyInfo.cs b/Sources/ESP8266Wizard/ESP8266Template/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..bb44562 --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266Template/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("ESP8266Template")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("Mathieu St-Laurent")] +[assembly: AssemblyProduct("ESP8266Template")] +[assembly: AssemblyCopyright("Copyright © Mathieu St-Laurent 2016")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("9b3c4f6a-8db2-46d2-b7b8-eec4c59dc4cb")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Sources/ESP8266Wizard/ESP8266Template/USER/user_main.c b/Sources/ESP8266Wizard/ESP8266Template/USER/user_main.c new file mode 100644 index 0000000..8eb3f24 --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266Template/USER/user_main.c @@ -0,0 +1,63 @@ +#include "ets_sys.h" +#include "osapi.h" +#include "gpio.h" +#include "os_type.h" +#include "user_config.h" + +#define led 2 +#define LOW 0 +#define HIGH 1 +static volatile os_timer_t some_timer; + + +void some_timer_func(void *arg) // in Arduino this is loop the main loop +{ + //Do blinky stuff + if GPIO_INPUT_GET(led) + { + //Set led to LOW + GPIO_OUTPUT_SET(led, LOW); // in Arduino this is digitalWrite(led, LOW) + os_printf("ON \n\r"); // In Arduino this is Serial.println("ON"); + + } + else + { + //Set led to HIGH + GPIO_OUTPUT_SET(led, HIGH); // in Arduino this is digitalWrite(led, HIGH) + os_printf("OFF \n\r"); // In Arduino this is Serial.println("OFF"); + + } +} + + +//Init function +void ICACHE_FLASH_ATTR +user_init() // in arduino this is setup() +{ + // Initialize the GPIO subsystem. + gpio_init(); + //Set GPIO2 to output mode, and to low + GPIO_OUTPUT_SET(led, LOW); // Compared with arduino pinMode(led, OUTPUT); + + // Initialize UART0 + uart_div_modify(0, UART_CLK_FREQ / 115200); // In Arduino this is Serial.begin(115200); + + os_printf("Hello World, Blinking\n\r"); // In Arduino this is Serial.println("Hello World, Blinking"); + + // In Arduino there is 1 loop, Under ESP8266 you can have several loops next to each other. + // To setup a loop use the 3 timer commands below. This will start the function called some_timer + // some_timer will be repeated every second. + + //Disarm timer + os_timer_disarm(&some_timer); + + //Setup timer + os_timer_setfn(&some_timer, (os_timer_func_t *)some_timer_func, NULL); + + //Arm the timer + //&some_timer is the pointer + //1000 is the fire time in ms + //0 for once and 1 for repeating + os_timer_arm(&some_timer, 1000, 1); + +} diff --git a/Sources/ESP8266Wizard/ESP8266Template/__PreviewImage.png b/Sources/ESP8266Wizard/ESP8266Template/__PreviewImage.png new file mode 100644 index 0000000..d30cd99 Binary files /dev/null and b/Sources/ESP8266Wizard/ESP8266Template/__PreviewImage.png differ diff --git a/Sources/ESP8266Wizard/ESP8266Template/__TemplateIcon.png b/Sources/ESP8266Wizard/ESP8266Template/__TemplateIcon.png new file mode 100644 index 0000000..9e3446a Binary files /dev/null and b/Sources/ESP8266Wizard/ESP8266Template/__TemplateIcon.png differ diff --git a/Sources/ESP8266Wizard/ESP8266Template/user_config.h b/Sources/ESP8266Wizard/ESP8266Template/user_config.h new file mode 100644 index 0000000..b2b7324 --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266Template/user_config.h @@ -0,0 +1,18 @@ +/* + * File : user_config.h + * This file is part of Espressif's AT+ command set program. + * Copyright (C) 2013 - 2016, Espressif Systems + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of version 3 of the GNU General Public License as + * published by the Free Software Foundation. + * + * 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 . + */ + diff --git a/Sources/ESP8266Wizard/ESP8266Template/user_main.c b/Sources/ESP8266Wizard/ESP8266Template/user_main.c new file mode 100644 index 0000000..8eb3f24 --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266Template/user_main.c @@ -0,0 +1,63 @@ +#include "ets_sys.h" +#include "osapi.h" +#include "gpio.h" +#include "os_type.h" +#include "user_config.h" + +#define led 2 +#define LOW 0 +#define HIGH 1 +static volatile os_timer_t some_timer; + + +void some_timer_func(void *arg) // in Arduino this is loop the main loop +{ + //Do blinky stuff + if GPIO_INPUT_GET(led) + { + //Set led to LOW + GPIO_OUTPUT_SET(led, LOW); // in Arduino this is digitalWrite(led, LOW) + os_printf("ON \n\r"); // In Arduino this is Serial.println("ON"); + + } + else + { + //Set led to HIGH + GPIO_OUTPUT_SET(led, HIGH); // in Arduino this is digitalWrite(led, HIGH) + os_printf("OFF \n\r"); // In Arduino this is Serial.println("OFF"); + + } +} + + +//Init function +void ICACHE_FLASH_ATTR +user_init() // in arduino this is setup() +{ + // Initialize the GPIO subsystem. + gpio_init(); + //Set GPIO2 to output mode, and to low + GPIO_OUTPUT_SET(led, LOW); // Compared with arduino pinMode(led, OUTPUT); + + // Initialize UART0 + uart_div_modify(0, UART_CLK_FREQ / 115200); // In Arduino this is Serial.begin(115200); + + os_printf("Hello World, Blinking\n\r"); // In Arduino this is Serial.println("Hello World, Blinking"); + + // In Arduino there is 1 loop, Under ESP8266 you can have several loops next to each other. + // To setup a loop use the 3 timer commands below. This will start the function called some_timer + // some_timer will be repeated every second. + + //Disarm timer + os_timer_disarm(&some_timer); + + //Setup timer + os_timer_setfn(&some_timer, (os_timer_func_t *)some_timer_func, NULL); + + //Arm the timer + //&some_timer is the pointer + //1000 is the fire time in ms + //0 for once and 1 for repeating + os_timer_arm(&some_timer, 1000, 1); + +} diff --git a/Sources/ESP8266Wizard/ESP8266Wizard.sln b/Sources/ESP8266Wizard/ESP8266Wizard.sln new file mode 100644 index 0000000..90ee274 --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266Wizard.sln @@ -0,0 +1,62 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 15 +VisualStudioVersion = 15.0.26206.0 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ESP8266Template", "ESP8266Template\ESP8266Template.csproj", "{9B3C4F6A-8DB2-46D2-B7B8-EEC4C59DC4CB}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ESP8266Wizard", "ESP8266Wizard\ESP8266Wizard.csproj", "{30047E6D-E7E9-44B7-A537-ADF57597ABFB}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ESP8266ClassWizard", "ESP8266ClassWizard\ESP8266ClassWizard.vcxproj", "{8DDF788F-D3D5-4E1A-B12F-EAA31859543B}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|Any CPU = Release|Any CPU + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {9B3C4F6A-8DB2-46D2-B7B8-EEC4C59DC4CB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {9B3C4F6A-8DB2-46D2-B7B8-EEC4C59DC4CB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {9B3C4F6A-8DB2-46D2-B7B8-EEC4C59DC4CB}.Debug|x64.ActiveCfg = Debug|Any CPU + {9B3C4F6A-8DB2-46D2-B7B8-EEC4C59DC4CB}.Debug|x64.Build.0 = Debug|Any CPU + {9B3C4F6A-8DB2-46D2-B7B8-EEC4C59DC4CB}.Debug|x86.ActiveCfg = Debug|Any CPU + {9B3C4F6A-8DB2-46D2-B7B8-EEC4C59DC4CB}.Debug|x86.Build.0 = Debug|Any CPU + {9B3C4F6A-8DB2-46D2-B7B8-EEC4C59DC4CB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {9B3C4F6A-8DB2-46D2-B7B8-EEC4C59DC4CB}.Release|Any CPU.Build.0 = Release|Any CPU + {9B3C4F6A-8DB2-46D2-B7B8-EEC4C59DC4CB}.Release|x64.ActiveCfg = Release|Any CPU + {9B3C4F6A-8DB2-46D2-B7B8-EEC4C59DC4CB}.Release|x64.Build.0 = Release|Any CPU + {9B3C4F6A-8DB2-46D2-B7B8-EEC4C59DC4CB}.Release|x86.ActiveCfg = Release|Any CPU + {9B3C4F6A-8DB2-46D2-B7B8-EEC4C59DC4CB}.Release|x86.Build.0 = Release|Any CPU + {30047E6D-E7E9-44B7-A537-ADF57597ABFB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {30047E6D-E7E9-44B7-A537-ADF57597ABFB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {30047E6D-E7E9-44B7-A537-ADF57597ABFB}.Debug|x64.ActiveCfg = Debug|Any CPU + {30047E6D-E7E9-44B7-A537-ADF57597ABFB}.Debug|x64.Build.0 = Debug|Any CPU + {30047E6D-E7E9-44B7-A537-ADF57597ABFB}.Debug|x86.ActiveCfg = Debug|Any CPU + {30047E6D-E7E9-44B7-A537-ADF57597ABFB}.Debug|x86.Build.0 = Debug|Any CPU + {30047E6D-E7E9-44B7-A537-ADF57597ABFB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {30047E6D-E7E9-44B7-A537-ADF57597ABFB}.Release|Any CPU.Build.0 = Release|Any CPU + {30047E6D-E7E9-44B7-A537-ADF57597ABFB}.Release|x64.ActiveCfg = Release|Any CPU + {30047E6D-E7E9-44B7-A537-ADF57597ABFB}.Release|x64.Build.0 = Release|Any CPU + {30047E6D-E7E9-44B7-A537-ADF57597ABFB}.Release|x86.ActiveCfg = Release|Any CPU + {30047E6D-E7E9-44B7-A537-ADF57597ABFB}.Release|x86.Build.0 = Release|Any CPU + {8DDF788F-D3D5-4E1A-B12F-EAA31859543B}.Debug|Any CPU.ActiveCfg = Debug|Win32 + {8DDF788F-D3D5-4E1A-B12F-EAA31859543B}.Debug|Any CPU.Build.0 = Debug|Win32 + {8DDF788F-D3D5-4E1A-B12F-EAA31859543B}.Debug|x64.ActiveCfg = Debug|x64 + {8DDF788F-D3D5-4E1A-B12F-EAA31859543B}.Debug|x64.Build.0 = Debug|x64 + {8DDF788F-D3D5-4E1A-B12F-EAA31859543B}.Debug|x86.ActiveCfg = Debug|Win32 + {8DDF788F-D3D5-4E1A-B12F-EAA31859543B}.Debug|x86.Build.0 = Debug|Win32 + {8DDF788F-D3D5-4E1A-B12F-EAA31859543B}.Release|Any CPU.ActiveCfg = Release|Win32 + {8DDF788F-D3D5-4E1A-B12F-EAA31859543B}.Release|Any CPU.Build.0 = Release|Win32 + {8DDF788F-D3D5-4E1A-B12F-EAA31859543B}.Release|x64.ActiveCfg = Release|x64 + {8DDF788F-D3D5-4E1A-B12F-EAA31859543B}.Release|x64.Build.0 = Release|x64 + {8DDF788F-D3D5-4E1A-B12F-EAA31859543B}.Release|x86.ActiveCfg = Release|Win32 + {8DDF788F-D3D5-4E1A-B12F-EAA31859543B}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/Sources/ESP8266Wizard/ESP8266Wizard/ESP8266ClassWizard.snk b/Sources/ESP8266Wizard/ESP8266Wizard/ESP8266ClassWizard.snk new file mode 100644 index 0000000..b1f0e99 Binary files /dev/null and b/Sources/ESP8266Wizard/ESP8266Wizard/ESP8266ClassWizard.snk differ diff --git a/Sources/ESP8266Wizard/ESP8266Wizard/ESP8266Wizard.csproj b/Sources/ESP8266Wizard/ESP8266Wizard/ESP8266Wizard.csproj new file mode 100644 index 0000000..e5dc2df --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266Wizard/ESP8266Wizard.csproj @@ -0,0 +1,97 @@ + + + + 15.0 + $(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion) + + + + + 14.0 + + + + true + + + ESP8266ClassWizard.snk + + + true + + + + Debug + AnyCPU + 2.0 + {82b43b9b-a64c-4715-b499-d71e9ca2bd60};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + {30047E6D-E7E9-44B7-A537-ADF57597ABFB} + Library + Properties + ESP8266Wizard + ESP8266Wizard + v4.7.2 + false + true + true + true + false + false + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + x86 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + x86 + + + + + + + + Designer + + + + + {8DDF788F-D3D5-4E1A-B12F-EAA31859543B} + ESP8266ClassWizard + BuiltProjectOutputGroup%3bBuiltProjectOutputGroupDependencies%3bGetCopyToOutputDirectoryItems%3bSatelliteDllsProjectOutputGroup%3b + DebugSymbolsProjectOutputGroup%3b + + + {9B3C4F6A-8DB2-46D2-B7B8-EEC4C59DC4CB} + ESP8266Template + ProjectTemplates + false + TemplateProjectOutputGroup%3b + + + + + + + + + + \ No newline at end of file diff --git a/Sources/ESP8266Wizard/ESP8266Wizard/Properties/AssemblyInfo.cs b/Sources/ESP8266Wizard/ESP8266Wizard/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..a322784 --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266Wizard/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("ESP8266Wizard")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("ESP8266Wizard")] +[assembly: AssemblyCopyright("")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Sources/ESP8266Wizard/ESP8266Wizard/source.extension.vsixmanifest b/Sources/ESP8266Wizard/ESP8266Wizard/source.extension.vsixmanifest new file mode 100644 index 0000000..d12b0e4 --- /dev/null +++ b/Sources/ESP8266Wizard/ESP8266Wizard/source.extension.vsixmanifest @@ -0,0 +1,21 @@ + + + + + ESP8266Wizard + Create an ESP8266 C Project from SDK/Example or Blank Project + + + + + + + + + + + + + + +