From 74ca7fe063865fa0202930a3a4de0c39a56124a7 Mon Sep 17 00:00:00 2001 From: Archie Date: Fri, 8 Oct 2021 13:00:05 +0200 Subject: [PATCH 1/3] Update SDK, add a few functions, fix launcher getting flagged by AVs --- ExamplePlugin/ExamplePlugin.vcxproj | 6 +++-- .../Src/Hello World/SDK/Enums/Enums.hpp | 9 +++++++ .../Src/Hello World/SDK/FwdDecls/FwdDecls.hpp | 2 +- .../Src/Hello World/SDK/Plugins/Plugins.hpp | 6 ++++- .../Documented/YYRValue/YYRValue.cpp | 2 +- ExamplePlugin/Src/Hello World/dllmain.cpp | 4 ++- Launcher/Launcher.csproj | 27 +++++++++++++++++++ Launcher/Properties/AssemblyInfo.cs | 18 +++++++------ YYToolkit/Src/Core/Features/API/API.cpp | 10 +++++-- .../Src/Core/Features/Console/Console.cpp | 20 +++++++++++++- YYToolkit/Src/Core/Hooks/Hooks.cpp | 2 +- YYToolkit/Src/Core/SDK/Enums/Enums.hpp | 9 +++++++ YYToolkit/Src/Core/SDK/FwdDecls/FwdDecls.hpp | 2 +- YYToolkit/Src/Core/SDK/Plugins/Plugins.hpp | 6 ++++- .../Documented/YYRValue/YYRValue.cpp | 2 +- YYToolkit/Src/Core/Utils/Error.cpp | 12 +++++++++ YYToolkit/Src/Core/Utils/Error.hpp | 2 ++ 17 files changed, 118 insertions(+), 21 deletions(-) diff --git a/ExamplePlugin/ExamplePlugin.vcxproj b/ExamplePlugin/ExamplePlugin.vcxproj index 42d3cb9..c082464 100644 --- a/ExamplePlugin/ExamplePlugin.vcxproj +++ b/ExamplePlugin/ExamplePlugin.vcxproj @@ -30,13 +30,13 @@ DynamicLibrary true - v142 + ClangCL Unicode DynamicLibrary false - v142 + ClangCL true Unicode @@ -95,6 +95,7 @@ true NotUsing pch.h + stdcpp17 Windows @@ -113,6 +114,7 @@ NotUsing pch.h MultiThreaded + stdcpp17 Windows diff --git a/ExamplePlugin/Src/Hello World/SDK/Enums/Enums.hpp b/ExamplePlugin/Src/Hello World/SDK/Enums/Enums.hpp index 3897080..27d5c00 100644 --- a/ExamplePlugin/Src/Hello World/SDK/Enums/Enums.hpp +++ b/ExamplePlugin/Src/Hello World/SDK/Enums/Enums.hpp @@ -57,14 +57,23 @@ enum Color : int { CLR_BLACK = 0, CLR_DARKBLUE = 1, + CLR_MATRIXGREEN = 2, + CLR_AQUA = 3, CLR_RED = 4, CLR_PURPLE = 5, + CLR_GOLD = 6, CLR_DEFAULT = 7, CLR_GRAY = 8, CLR_BLUE = 9, CLR_GREEN = 10, CLR_LIGHTBLUE = 11, + CLR_TANGERINE = 12, CLR_PINK = 13, CLR_YELLOW = 14, CLR_WHITE = 15 +}; + +enum EOpcode +{ + // todo }; \ No newline at end of file diff --git a/ExamplePlugin/Src/Hello World/SDK/FwdDecls/FwdDecls.hpp b/ExamplePlugin/Src/Hello World/SDK/FwdDecls/FwdDecls.hpp index 92e941a..15960c3 100644 --- a/ExamplePlugin/Src/Hello World/SDK/FwdDecls/FwdDecls.hpp +++ b/ExamplePlugin/Src/Hello World/SDK/FwdDecls/FwdDecls.hpp @@ -69,7 +69,7 @@ typedef bool (*FNCodeExecute)(YYObjectBase* Self, YYObjectBase* Other, CCode* co // Macros #define WIN32_LEAN_AND_MEAN 1 -#define YYSDK_VERSION "0.0.7-rc1" // YYToolkit version - don't change this! +#define YYSDK_VERSION "0.0.7-rc2" // YYToolkit version - don't change this! #define YYTK_MAGIC 'TFSI' // Macros, but complicated diff --git a/ExamplePlugin/Src/Hello World/SDK/Plugins/Plugins.hpp b/ExamplePlugin/Src/Hello World/SDK/Plugins/Plugins.hpp index c904136..97286ba 100644 --- a/ExamplePlugin/Src/Hello World/SDK/Plugins/Plugins.hpp +++ b/ExamplePlugin/Src/Hello World/SDK/Plugins/Plugins.hpp @@ -17,6 +17,8 @@ using FNPluginEntry = YYTKStatus(*)(YYTKPlugin* pPlugin); using FNPluginUnload = YYTKStatus(*)(YYTKPlugin* pPlugin); using FNTextRenderCallback = void(*)(float& x, float& y, const char*& str, int& linesep, int& linewidth); +#pragma pack(push, 1) + struct YYTKPlugin { FNPluginEntry PluginEntry; // Pointer to the entry function - set by the core. @@ -41,4 +43,6 @@ struct YYTKPlugin if (PluginStart) return reinterpret_cast(GetProcAddress(reinterpret_cast(PluginStart), Name)); return nullptr; } -}; \ No newline at end of file +}; + +#pragma pack(pop) \ No newline at end of file diff --git a/ExamplePlugin/Src/Hello World/SDK/Structures/Documented/YYRValue/YYRValue.cpp b/ExamplePlugin/Src/Hello World/SDK/Structures/Documented/YYRValue/YYRValue.cpp index 8b894bc..c762d2d 100644 --- a/ExamplePlugin/Src/Hello World/SDK/Structures/Documented/YYRValue/YYRValue.cpp +++ b/ExamplePlugin/Src/Hello World/SDK/Structures/Documented/YYRValue/YYRValue.cpp @@ -29,7 +29,7 @@ YYRValue::YYRValue(const bool& Value) noexcept(true) { this->Kind = VALUE_BOOL; this->Flags = 0; - this->I32 = Value; // A bool is really just a 0 or a 1, so I can freely cast it to an integer. + this->Real = static_cast(Value); // A bool is really just a 0 or a 1, so I can freely cast it to an integer. } YYRValue::YYRValue(const long long& Value) noexcept(true) diff --git a/ExamplePlugin/Src/Hello World/dllmain.cpp b/ExamplePlugin/Src/Hello World/dllmain.cpp index 4d6eb52..c7b1348 100644 --- a/ExamplePlugin/Src/Hello World/dllmain.cpp +++ b/ExamplePlugin/Src/Hello World/dllmain.cpp @@ -109,7 +109,7 @@ YYTKStatus PluginEventHandler(YYTKPlugin* pPlugin, YYTKEventBase* pEvent) // Go To Room port if (GetAsyncKeyState(VK_F3) & 1) { - YYRValue Result = EasyGMLCall(pPlugin, "get_integer", { "Go to room (ported by Archie from UMT to YYToolkit\nEnter the room ID you wish to teleport to.", 11.0 }); + YYRValue Result = EasyGMLCall(pPlugin, "get_integer", { "Go to room (ported by Archie from UMT to YYToolkit).\nEnter the room ID you wish to teleport to.", 11.0 }); EasyGMLCall(pPlugin, "room_goto", { Result }); } @@ -139,6 +139,8 @@ DllExport YYTKStatus PluginUnload(YYTKPlugin* pPlugin) Script->s_code->i_pVM = poscr_Dogcheck; } + EasyGMLCall(pPlugin, "variable_global_set", { "debug", 0.0 }); + return YYTK_OK; } diff --git a/Launcher/Launcher.csproj b/Launcher/Launcher.csproj index 6ac7c6b..bd03412 100644 --- a/Launcher/Launcher.csproj +++ b/Launcher/Launcher.csproj @@ -12,6 +12,21 @@ 512 true true + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + false + true AnyCPU @@ -81,5 +96,17 @@ + + + False + Microsoft .NET Framework 4.7.2 %28x86 and x64%29 + true + + + False + .NET Framework 3.5 SP1 + false + + \ No newline at end of file diff --git a/Launcher/Properties/AssemblyInfo.cs b/Launcher/Properties/AssemblyInfo.cs index 8e72c72..8f34c82 100644 --- a/Launcher/Properties/AssemblyInfo.cs +++ b/Launcher/Properties/AssemblyInfo.cs @@ -1,16 +1,17 @@ -using System.Reflection; +using System.Resources; +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("Launcher")] -[assembly: AssemblyDescription("")] +[assembly: AssemblyTitle("YYToolkit Launcher")] +[assembly: AssemblyDescription("Launcher for GameMaker games, allowing for modding")] [assembly: AssemblyConfiguration("")] [assembly: AssemblyCompany("")] -[assembly: AssemblyProduct("Launcher")] -[assembly: AssemblyCopyright("Copyright © 2021")] +[assembly: AssemblyProduct("YYLauncher")] +[assembly: AssemblyCopyright("GPL v3")] [assembly: AssemblyTrademark("")] [assembly: AssemblyCulture("")] @@ -20,7 +21,7 @@ [assembly: ComVisible(false)] // The following GUID is for the ID of the typelib if this project is exposed to COM -[assembly: Guid("6f7c254d-4c31-49eb-90ee-63003bd5ef6e")] +[assembly: Guid("ed5bb375-6ec7-46a4-b4d8-88135af7f764")] // Version information for an assembly consists of the following four values: // @@ -32,5 +33,6 @@ // 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")] +[assembly: AssemblyVersion("0.0.7.2")] +[assembly: AssemblyFileVersion("0.0.7.2")] +[assembly: NeutralResourcesLanguage("en")] diff --git a/YYToolkit/Src/Core/Features/API/API.cpp b/YYToolkit/Src/Core/Features/API/API.cpp index 743460f..b68dfe5 100644 --- a/YYToolkit/Src/Core/Features/API/API.cpp +++ b/YYToolkit/Src/Core/Features/API/API.cpp @@ -42,7 +42,12 @@ namespace API bool ErrorOccured = false; if (!gAPIVars.Code_Execute) { - ErrorOccured |= (GetCodeExecuteAddr(gAPIVars.Code_Execute) != YYTK_OK); + YYTKStatus Status; + ErrorOccured |= (Status = GetCodeExecuteAddr(gAPIVars.Code_Execute)); + + // This is crucial to the API workings, we have to crash the game if this is not found. + if (Status != YYTK_OK) + Utils::Error::Error(true, "GetCodeExecuteAddr() returned %s", Utils::Error::YYTKStatus_ToString(Status)); } if (!gAPIVars.Code_Function_GET_the_function) @@ -50,8 +55,9 @@ namespace API YYTKStatus Status; ErrorOccured |= (Status = GetCodeFunctionAddr(gAPIVars.Code_Function_GET_the_function)); + // This is crucial to the API workings, we have to crash the game if this is not found. if (Status != YYTK_OK) - Utils::Error::Error(false, "GetCodeFunctionAddr() returned %s", Utils::Error::YYTKStatus_ToString(Status)); + Utils::Error::Error(true, "GetCodeFunctionAddr() returned %s", Utils::Error::YYTKStatus_ToString(Status)); } if (!gAPIVars.g_pGlobal) diff --git a/YYToolkit/Src/Core/Features/Console/Console.cpp b/YYToolkit/Src/Core/Features/Console/Console.cpp index 0894255..c792662 100644 --- a/YYToolkit/Src/Core/Features/Console/Console.cpp +++ b/YYToolkit/Src/Core/Features/Console/Console.cpp @@ -11,6 +11,8 @@ using std::vector; using std::string; +static + static vector StripOutArguments(const string& ref) { vector vResults; @@ -82,7 +84,8 @@ void Console::DoCommand() if (TRoutine Routine = API::GetBuiltin(vecTokens[0].c_str())) { - RValue Result; + RValue Result; Result.Kind = VALUE_UNSET; Result.I64 = 0; + YYRValue* pArgs = new YYRValue[vecTokens.size()]; // REGEX MESS START @@ -118,6 +121,21 @@ void Console::DoCommand() Routine(&Result, pInstance, pInstance, vecTokens.size() - 1, reinterpret_cast(pArgs)); + Utils::Error::NoNewlineMessage(CLR_GOLD, "%s", Command.c_str()); + Utils::Error::NoNewlineMessage(CLR_DEFAULT, " -> "); + + if (Result.Kind == VALUE_REAL) + Utils::Error::Message(CLR_BLUE, "%.2f", Result.Real); + + else if (Result.Kind == VALUE_BOOL) + Utils::Error::Message(CLR_TANGERINE, "%s", (Result.Real > 0.5) ? "true" : "false"); + + else if (Result.Kind == VALUE_STRING) + Utils::Error::Message(CLR_YELLOW, "\"%s\"", Result.String->Get()); + + else + Utils::Error::Message(CLR_GRAY, "undefined"); + delete[] pArgs; return; } diff --git a/YYToolkit/Src/Core/Hooks/Hooks.cpp b/YYToolkit/Src/Core/Hooks/Hooks.cpp index 8cef42d..1fb0292 100644 --- a/YYToolkit/Src/Core/Hooks/Hooks.cpp +++ b/YYToolkit/Src/Core/Hooks/Hooks.cpp @@ -144,7 +144,7 @@ namespace Hooks ShowWindow(reinterpret_cast(gAPIVars.Window_Device), SW_SHOW); SetForegroundWindow(reinterpret_cast(gAPIVars.Window_Device)); Utils::Error::Message(CLR_LIGHTBLUE, "All hooks enabled - took %.3f seconds!", static_cast(std::chrono::duration_cast(TimeEnd - TimeStart).count()) / 1000.0f); - Utils::Error::Message(CLR_BLUE, "Hint: Press F10 to run GML functions!"); + Utils::Error::Message(CLR_LIGHTBLUE, "Hint: Press F10 to run GML functions!"); } } diff --git a/YYToolkit/Src/Core/SDK/Enums/Enums.hpp b/YYToolkit/Src/Core/SDK/Enums/Enums.hpp index 3897080..27d5c00 100644 --- a/YYToolkit/Src/Core/SDK/Enums/Enums.hpp +++ b/YYToolkit/Src/Core/SDK/Enums/Enums.hpp @@ -57,14 +57,23 @@ enum Color : int { CLR_BLACK = 0, CLR_DARKBLUE = 1, + CLR_MATRIXGREEN = 2, + CLR_AQUA = 3, CLR_RED = 4, CLR_PURPLE = 5, + CLR_GOLD = 6, CLR_DEFAULT = 7, CLR_GRAY = 8, CLR_BLUE = 9, CLR_GREEN = 10, CLR_LIGHTBLUE = 11, + CLR_TANGERINE = 12, CLR_PINK = 13, CLR_YELLOW = 14, CLR_WHITE = 15 +}; + +enum EOpcode +{ + // todo }; \ No newline at end of file diff --git a/YYToolkit/Src/Core/SDK/FwdDecls/FwdDecls.hpp b/YYToolkit/Src/Core/SDK/FwdDecls/FwdDecls.hpp index 92e941a..15960c3 100644 --- a/YYToolkit/Src/Core/SDK/FwdDecls/FwdDecls.hpp +++ b/YYToolkit/Src/Core/SDK/FwdDecls/FwdDecls.hpp @@ -69,7 +69,7 @@ typedef bool (*FNCodeExecute)(YYObjectBase* Self, YYObjectBase* Other, CCode* co // Macros #define WIN32_LEAN_AND_MEAN 1 -#define YYSDK_VERSION "0.0.7-rc1" // YYToolkit version - don't change this! +#define YYSDK_VERSION "0.0.7-rc2" // YYToolkit version - don't change this! #define YYTK_MAGIC 'TFSI' // Macros, but complicated diff --git a/YYToolkit/Src/Core/SDK/Plugins/Plugins.hpp b/YYToolkit/Src/Core/SDK/Plugins/Plugins.hpp index c904136..97286ba 100644 --- a/YYToolkit/Src/Core/SDK/Plugins/Plugins.hpp +++ b/YYToolkit/Src/Core/SDK/Plugins/Plugins.hpp @@ -17,6 +17,8 @@ using FNPluginEntry = YYTKStatus(*)(YYTKPlugin* pPlugin); using FNPluginUnload = YYTKStatus(*)(YYTKPlugin* pPlugin); using FNTextRenderCallback = void(*)(float& x, float& y, const char*& str, int& linesep, int& linewidth); +#pragma pack(push, 1) + struct YYTKPlugin { FNPluginEntry PluginEntry; // Pointer to the entry function - set by the core. @@ -41,4 +43,6 @@ struct YYTKPlugin if (PluginStart) return reinterpret_cast(GetProcAddress(reinterpret_cast(PluginStart), Name)); return nullptr; } -}; \ No newline at end of file +}; + +#pragma pack(pop) \ No newline at end of file diff --git a/YYToolkit/Src/Core/SDK/Structures/Documented/YYRValue/YYRValue.cpp b/YYToolkit/Src/Core/SDK/Structures/Documented/YYRValue/YYRValue.cpp index 8b894bc..c762d2d 100644 --- a/YYToolkit/Src/Core/SDK/Structures/Documented/YYRValue/YYRValue.cpp +++ b/YYToolkit/Src/Core/SDK/Structures/Documented/YYRValue/YYRValue.cpp @@ -29,7 +29,7 @@ YYRValue::YYRValue(const bool& Value) noexcept(true) { this->Kind = VALUE_BOOL; this->Flags = 0; - this->I32 = Value; // A bool is really just a 0 or a 1, so I can freely cast it to an integer. + this->Real = static_cast(Value); // A bool is really just a 0 or a 1, so I can freely cast it to an integer. } YYRValue::YYRValue(const long long& Value) noexcept(true) diff --git a/YYToolkit/Src/Core/Utils/Error.cpp b/YYToolkit/Src/Core/Utils/Error.cpp index 0352bf8..5055767 100644 --- a/YYToolkit/Src/Core/Utils/Error.cpp +++ b/YYToolkit/Src/Core/Utils/Error.cpp @@ -57,6 +57,18 @@ namespace Utils::Error SetPrintColor(CLR_DEFAULT); } + void NoNewlineMessage(Color C, const char* fmt, ...) + { + va_list vaArgs; + va_start(vaArgs, fmt); + auto String = ParseVA(fmt, vaArgs); + va_end(vaArgs); + + SetPrintColor(C); + printf("%s", String.c_str()); + SetPrintColor(CLR_DEFAULT); + } + const char* YYTKStatus_ToString(YYTKStatus Status) { switch (Status) diff --git a/YYToolkit/Src/Core/Utils/Error.hpp b/YYToolkit/Src/Core/Utils/Error.hpp index f0cbdc2..1082178 100644 --- a/YYToolkit/Src/Core/Utils/Error.hpp +++ b/YYToolkit/Src/Core/Utils/Error.hpp @@ -10,6 +10,8 @@ namespace Utils void Message(Color C, const char* fmt, ...); + void NoNewlineMessage(Color C, const char* fmt, ...); + // Apparently this has to be inline and here, or else you get link errors // I don't understand the linker const char* YYTKStatus_ToString(YYTKStatus Status); From ac3253311b2f231936664938d0a39c9f5edc6e3f Mon Sep 17 00:00:00 2001 From: Archie Date: Sat, 9 Oct 2021 19:54:37 +0200 Subject: [PATCH 2/3] Add identifier for debug builds, fix fullscreen issues Fixes fullscreen issues, also updated YYExplorer to 0.0.7rc-2's SDK, because I needed to test the RenderTarget with it. This commit completely changes how the render target initialization is done. --- Launcher/Form1.Designer.cs | 115 +- Launcher/Form1.cs | 64 +- Launcher/Form1.en.resx | 2578 +++++++++++++++++ YYExplorer/SDK/Enums/Enums.hpp | 9 + YYExplorer/SDK/FwdDecls/FwdDecls.hpp | 2 +- YYExplorer/SDK/Plugins/Plugins.hpp | 18 +- .../Structures/Documented/APIVars/APIVars.hpp | 1 + .../Documented/YYRValue/YYRValue.cpp | 2 +- YYToolkit/Src/Core/Features/API/API.cpp | 4 + YYToolkit/Src/Core/Hooks/Present/Present.cpp | 25 +- .../Hooks/ResizeBuffers/ResizeBuffers.cpp | 40 +- .../Structures/Documented/APIVars/APIVars.hpp | 1 + 12 files changed, 2684 insertions(+), 175 deletions(-) create mode 100644 Launcher/Form1.en.resx diff --git a/Launcher/Form1.Designer.cs b/Launcher/Form1.Designer.cs index 50875c1..22b9af5 100644 --- a/Launcher/Form1.Designer.cs +++ b/Launcher/Form1.Designer.cs @@ -40,22 +40,17 @@ private void InitializeComponent() this.lbRunner = new System.Windows.Forms.Label(); this.txtRunner = new System.Windows.Forms.TextBox(); this.gbMisc = new System.Windows.Forms.GroupBox(); + this.btOpenUMTGitHub = new System.Windows.Forms.Button(); this.btOpenGitHub = new System.Windows.Forms.Button(); - this.btOpenPluginFolder = new System.Windows.Forms.Button(); this.btYYTKLaunch = new System.Windows.Forms.Button(); this.gbInject = new System.Windows.Forms.GroupBox(); this.btOpenData = new System.Windows.Forms.Button(); this.btNoModLaunch = new System.Windows.Forms.Button(); - this.rbStable = new System.Windows.Forms.RadioButton(); - this.rbBeta = new System.Windows.Forms.RadioButton(); - this.gbSourceCode = new System.Windows.Forms.GroupBox(); - this.btDownloadSrc = new System.Windows.Forms.Button(); this.gbPlugins = new System.Windows.Forms.GroupBox(); this.listPlugins = new System.Windows.Forms.ListBox(); this.gbSelectFiles.SuspendLayout(); this.gbMisc.SuspendLayout(); this.gbInject.SuspendLayout(); - this.gbSourceCode.SuspendLayout(); this.gbPlugins.SuspendLayout(); this.SuspendLayout(); // @@ -169,39 +164,39 @@ private void InitializeComponent() // // gbMisc // + this.gbMisc.Controls.Add(this.btOpenUMTGitHub); this.gbMisc.Controls.Add(this.btOpenGitHub); - this.gbMisc.Controls.Add(this.btOpenPluginFolder); this.gbMisc.Font = new System.Drawing.Font("Segoe UI", 11.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); this.gbMisc.ForeColor = System.Drawing.Color.White; - this.gbMisc.Location = new System.Drawing.Point(12, 292); + this.gbMisc.Location = new System.Drawing.Point(384, 251); this.gbMisc.Name = "gbMisc"; - this.gbMisc.Size = new System.Drawing.Size(366, 69); + this.gbMisc.Size = new System.Drawing.Size(268, 96); this.gbMisc.TabIndex = 2; this.gbMisc.TabStop = false; - this.gbMisc.Text = "4 - Miscellaneous"; + this.gbMisc.Text = "4 - Quick Repo Access"; + // + // btOpenUMTGitHub + // + this.btOpenUMTGitHub.ForeColor = System.Drawing.Color.Black; + this.btOpenUMTGitHub.Location = new System.Drawing.Point(8, 60); + this.btOpenUMTGitHub.Name = "btOpenUMTGitHub"; + this.btOpenUMTGitHub.Size = new System.Drawing.Size(252, 28); + this.btOpenUMTGitHub.TabIndex = 2; + this.btOpenUMTGitHub.Text = "Open UndertaleModTool releases"; + this.btOpenUMTGitHub.UseVisualStyleBackColor = true; + this.btOpenUMTGitHub.Click += new System.EventHandler(this.btOpenUMTGitHub_Click); // // btOpenGitHub // this.btOpenGitHub.ForeColor = System.Drawing.Color.Black; - this.btOpenGitHub.Location = new System.Drawing.Point(186, 26); + this.btOpenGitHub.Location = new System.Drawing.Point(8, 26); this.btOpenGitHub.Name = "btOpenGitHub"; - this.btOpenGitHub.Size = new System.Drawing.Size(170, 28); + this.btOpenGitHub.Size = new System.Drawing.Size(252, 28); this.btOpenGitHub.TabIndex = 1; - this.btOpenGitHub.Text = "Open YYTK GitHub"; + this.btOpenGitHub.Text = "Open YYToolkit releases"; this.btOpenGitHub.UseVisualStyleBackColor = true; this.btOpenGitHub.Click += new System.EventHandler(this.btOpenGitHub_Click); // - // btOpenPluginFolder - // - this.btOpenPluginFolder.ForeColor = System.Drawing.Color.Black; - this.btOpenPluginFolder.Location = new System.Drawing.Point(10, 26); - this.btOpenPluginFolder.Name = "btOpenPluginFolder"; - this.btOpenPluginFolder.Size = new System.Drawing.Size(170, 28); - this.btOpenPluginFolder.TabIndex = 0; - this.btOpenPluginFolder.Text = "Open \'autoexec\' folder"; - this.btOpenPluginFolder.UseVisualStyleBackColor = true; - this.btOpenPluginFolder.Click += new System.EventHandler(this.btOpenPluginFolder_Click); - // // btYYTKLaunch // this.btYYTKLaunch.Font = new System.Drawing.Font("Segoe UI", 11.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); @@ -223,7 +218,7 @@ private void InitializeComponent() this.gbInject.ForeColor = System.Drawing.Color.White; this.gbInject.Location = new System.Drawing.Point(384, 109); this.gbInject.Name = "gbInject"; - this.gbInject.Size = new System.Drawing.Size(268, 144); + this.gbInject.Size = new System.Drawing.Size(268, 136); this.gbInject.TabIndex = 4; this.gbInject.TabStop = false; this.gbInject.Text = "3 - Launcher"; @@ -236,7 +231,7 @@ private void InitializeComponent() this.btOpenData.Name = "btOpenData"; this.btOpenData.Size = new System.Drawing.Size(254, 28); this.btOpenData.TabIndex = 6; - this.btOpenData.Text = "Open data.win in UTModTool"; + this.btOpenData.Text = "Open in UndertaleModTool"; this.btOpenData.UseVisualStyleBackColor = true; this.btOpenData.Click += new System.EventHandler(this.btOpenData_Click); // @@ -252,54 +247,6 @@ private void InitializeComponent() this.btNoModLaunch.UseVisualStyleBackColor = true; this.btNoModLaunch.Click += new System.EventHandler(this.btNoModLaunch_Click); // - // rbStable - // - this.rbStable.AutoSize = true; - this.rbStable.Checked = true; - this.rbStable.Location = new System.Drawing.Point(8, 33); - this.rbStable.Name = "rbStable"; - this.rbStable.Size = new System.Drawing.Size(122, 25); - this.rbStable.TabIndex = 2; - this.rbStable.TabStop = true; - this.rbStable.Text = "Stable Branch"; - this.rbStable.UseVisualStyleBackColor = true; - // - // rbBeta - // - this.rbBeta.AutoSize = true; - this.rbBeta.Location = new System.Drawing.Point(8, 64); - this.rbBeta.Name = "rbBeta"; - this.rbBeta.Size = new System.Drawing.Size(110, 25); - this.rbBeta.TabIndex = 3; - this.rbBeta.Text = "Beta Branch"; - this.rbBeta.UseVisualStyleBackColor = true; - // - // gbSourceCode - // - this.gbSourceCode.Controls.Add(this.btDownloadSrc); - this.gbSourceCode.Controls.Add(this.rbStable); - this.gbSourceCode.Controls.Add(this.rbBeta); - this.gbSourceCode.Font = new System.Drawing.Font("Segoe UI", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); - this.gbSourceCode.ForeColor = System.Drawing.Color.White; - this.gbSourceCode.Location = new System.Drawing.Point(384, 259); - this.gbSourceCode.Name = "gbSourceCode"; - this.gbSourceCode.Size = new System.Drawing.Size(268, 102); - this.gbSourceCode.TabIndex = 4; - this.gbSourceCode.TabStop = false; - this.gbSourceCode.Text = "5 - Source Code"; - // - // btDownloadSrc - // - this.btDownloadSrc.Font = new System.Drawing.Font("Segoe UI", 15.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); - this.btDownloadSrc.ForeColor = System.Drawing.Color.Black; - this.btDownloadSrc.Location = new System.Drawing.Point(136, 33); - this.btDownloadSrc.Name = "btDownloadSrc"; - this.btDownloadSrc.Size = new System.Drawing.Size(126, 56); - this.btDownloadSrc.TabIndex = 4; - this.btDownloadSrc.Text = "Download"; - this.btDownloadSrc.UseVisualStyleBackColor = true; - this.btDownloadSrc.Click += new System.EventHandler(this.btDownloadSrc_Click); - // // gbPlugins // this.gbPlugins.Controls.Add(this.listPlugins); @@ -307,7 +254,7 @@ private void InitializeComponent() this.gbPlugins.ForeColor = System.Drawing.Color.White; this.gbPlugins.Location = new System.Drawing.Point(12, 109); this.gbPlugins.Name = "gbPlugins"; - this.gbPlugins.Size = new System.Drawing.Size(366, 177); + this.gbPlugins.Size = new System.Drawing.Size(366, 238); this.gbPlugins.TabIndex = 5; this.gbPlugins.TabStop = false; this.gbPlugins.Text = "2 - Plugin Manager"; @@ -320,18 +267,17 @@ private void InitializeComponent() this.listPlugins.ItemHeight = 21; this.listPlugins.Location = new System.Drawing.Point(10, 31); this.listPlugins.Name = "listPlugins"; - this.listPlugins.Size = new System.Drawing.Size(346, 130); + this.listPlugins.Size = new System.Drawing.Size(346, 193); this.listPlugins.TabIndex = 0; // // MainWindow // this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; - this.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(50)))), ((int)(((byte)(50)))), ((int)(((byte)(70))))); - this.ClientSize = new System.Drawing.Size(664, 370); + this.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(30)))), ((int)(((byte)(30)))), ((int)(((byte)(45))))); + this.ClientSize = new System.Drawing.Size(664, 360); this.Controls.Add(this.gbMisc); this.Controls.Add(this.gbPlugins); - this.Controls.Add(this.gbSourceCode); this.Controls.Add(this.gbInject); this.Controls.Add(this.gbSelectFiles); this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle; @@ -339,13 +285,12 @@ private void InitializeComponent() this.MaximizeBox = false; this.MinimizeBox = false; this.Name = "MainWindow"; - this.Text = "YYLauncher 0.0.7-rc1"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "YYLauncher 0.0.7-rc2"; this.gbSelectFiles.ResumeLayout(false); this.gbSelectFiles.PerformLayout(); this.gbMisc.ResumeLayout(false); this.gbInject.ResumeLayout(false); - this.gbSourceCode.ResumeLayout(false); - this.gbSourceCode.PerformLayout(); this.gbPlugins.ResumeLayout(false); this.ResumeLayout(false); @@ -365,15 +310,11 @@ private void InitializeComponent() private System.Windows.Forms.Label lbDataFile; private System.Windows.Forms.Button btResetData; private System.Windows.Forms.Button btDataPick; - private System.Windows.Forms.Button btOpenPluginFolder; private System.Windows.Forms.Button btOpenGitHub; - private System.Windows.Forms.RadioButton rbStable; - private System.Windows.Forms.RadioButton rbBeta; - private System.Windows.Forms.GroupBox gbSourceCode; - private System.Windows.Forms.Button btDownloadSrc; private System.Windows.Forms.GroupBox gbPlugins; private System.Windows.Forms.ListBox listPlugins; private System.Windows.Forms.Button btOpenData; + private System.Windows.Forms.Button btOpenUMTGitHub; } } diff --git a/Launcher/Form1.cs b/Launcher/Form1.cs index 0488ffb..5a23c1f 100644 --- a/Launcher/Form1.cs +++ b/Launcher/Form1.cs @@ -152,6 +152,9 @@ private void btDataPick_Click(object sender, EventArgs e) return; } + if (MessageBox.Show("Please note this feature is designed for development purposes.\nProceed anyway?", "Warning", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.No) + return; + using (OpenFileDialog fileDialog = Utils.CreateFileDialog("%systemdrive%", "Find the data.win file", "GameMaker Data Files|*.win", 1)) { if (fileDialog.ShowDialog() == DialogResult.OK) @@ -172,51 +175,12 @@ private void btOpenPluginFolder_Click(object sender, EventArgs e) return; } - try - { - if (!Directory.Exists("autoexec")) - Directory.CreateDirectory("autoexec"); - } - catch (System.UnauthorizedAccessException Exception) - { - MessageBox.Show(Exception.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); - } - - - Process.Start("explorer", "\"" + Directory.GetCurrentDirectory() + "\\autoexec\""); + Process.Start("explorer", "\"" + Directory.GetCurrentDirectory()); } private void btOpenGitHub_Click(object sender, EventArgs e) { - Process.Start("explorer.exe", $"\"https://github.com/Archie-osu/YYToolkit\""); - } - - private void btDownloadSrc_Click(object sender, EventArgs e) - { - using (var FolderBrowser = new FolderBrowserDialog()) - { - FolderBrowser.Description = "Where do you want to save the source tree?"; - - if (FolderBrowser.ShowDialog() == DialogResult.OK) - { - using (var Browser = new WebClient()) - { - try - { - if (rbStable.Checked) - Browser.DownloadFile("https://github.com/Archie-osu/YYToolkit/archive/refs/heads/stable.zip", FolderBrowser.SelectedPath + "\\YYToolkit-stable.zip"); - else - Browser.DownloadFile("https://github.com/Archie-osu/YYToolkit/archive/refs/heads/beta.zip", FolderBrowser.SelectedPath + "\\YYToolkit-beta.zip"); - } - catch (System.Exception Exception) - { - MessageBox.Show(Exception.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); - return; - } - } - MessageBox.Show("Download complete.", "Source code download", MessageBoxButtons.OK, MessageBoxIcon.Information); - } - } + Process.Start("explorer.exe", $"\"https://github.com/Archie-osu/YYToolkit/releases\""); } private void PluginContextMenu_InstallPlugin(object sender, EventArgs e) @@ -231,12 +195,6 @@ private void PluginContextMenu_InstallPlugin(object sender, EventArgs e) { if (fileDialog.ShowDialog() == DialogResult.OK) { - if (fileDialog.SafeFileName.ToLower() == "yytoolkit.dll") - { - if (MessageBox.Show("YYToolkit.dll might be the core module, and not a plugin. Add it anyway?", "Warning", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.No) - return; - } - try { if (!Directory.Exists("autoexec")) @@ -361,7 +319,7 @@ private void btYYTKLaunchContextMenu_LaunchCustom(object sender, EventArgs e) return; } - if (MessageBox.Show("Please note this feature is designed for development purposes.\nTo launch with YYToolkit, use the other button.\nProceed anyway?", "Warning", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.No) + if (MessageBox.Show("Please note this feature is designed for development purposes.\nProceed anyway?", "Warning", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.No) return; using (OpenFileDialog fileDialog = Utils.CreateFileDialog("%systemdrive%", "Find the custom DLL", "DLL files|*.dll", 1)) @@ -385,5 +343,15 @@ private void btYYTKLaunchContextMenu_LaunchCustom(object sender, EventArgs e) } } } + + private void btOpenUMTGitHub_Click(object sender, EventArgs e) + { + Process.Start("explorer.exe", $"\"https://github.com/krzys-h/UndertaleModTool/releases\""); + } + + private void listPlugins_SelectedIndexChanged(object sender, EventArgs e) + { + + } } } \ No newline at end of file diff --git a/Launcher/Form1.en.resx b/Launcher/Form1.en.resx new file mode 100644 index 0000000..f98c553 --- /dev/null +++ b/Launcher/Form1.en.resx @@ -0,0 +1,2578 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + AAABAAYAAAAAAAEAIABSuQAAZgAAAICAAAABACAAKAgBALi5AABAQAAAAQAgAChCAADgwQEAMDAAAAEA + IACoJQAACAQCACAgAAABACAAqBAAALApAgAQEAAAAQAgAGgEAABYOgIAiVBORw0KGgoAAAANSUhEUgAA + AQAAAAEACAYAAABccqhmAACAAElEQVR42uy9d4AcaXkm/lSuzj15evKMsjSjHDZIm1e7hF3AZDAmOhtn + nO3znX02YN8dPifsw9jgdLYBY3z8YHeBhc2rnHOYnEPnWOH3x1dV/dXX1ROkkTTS6oXeUX+dq+p9vjc+ + L4e78kYWDoACQLX+KgBk6q8AQLT+8tbzOQCmdTMA6NatZN0KAIoActRNv9U/9K54C3erv8BduWkiAwgB + CADwUzfhBn+uCSAPIAMgBSBp/b0LCitA7mQAEEF2MhNkV3ojXXA8gCCACIjSh0B2+ZUiBggIzAGYBZAG + OU935SbLnQYAHIBmADEQBbB/nwEgDmAE5IK704QD2dmjAGoAhEEA8HaRAoBpAFMgFsJdMLhJcicBgA/A + BpDdbj6ZAXAR5KK7nUUAUfY6ALUgJv61Cme93ge3eyBbNwnEqqDdBdv/10COZQFlUz8Lsqtr1/BdcgAm + AIzj9j9HK17uFADwAdiKxStBCcAlAJO3+osvUQQADQDqQXb7pfrvHAhARkHcg4j17zCIki/n9WCAAEEc + xOqaAdnhs4t8vQliFQyDWAV35QbInQAAKoAtuDYfdxrABRBAWOnSAGA1lrbTqygDhn1TbuFvMEEshDEA + o9ZtMbt8AsAg7kz37ZbK7Q4AMsjO72PWg9Z6E4iZOgTgFLwvthIICEzf6h8zj3QC6Frk8WgCiYHEQHb3 + lXyODRBzfxDAVRAXYj5JWM9L3OovfqfISr44FhIJZOcPMOv1AB5H5U6XBfAqCBh4ySSIW7DSrIEmAOur + PMaBmPHt1q0exFe/ZhEEgVdVVQ6Gwj6f36fKsiJLsiQJgiDwvCA4RQCGYZgwdUWSS/lCvphJZwrx+Fw2 + lUwWSqWScQ0fbYAEaS9Yf+d7j2kAV0DiBXflOuR2BQARwGZUBvxqADyJ+c3ciwAOghSrsFKwHp+51T/Q + EgnALusvLbUAVoEofXipbyqKohCJ1gRr62oj4Ug0EgqHI36/Pywril+SJFUQhEVnEKKRKCKRMAReAC/w + AKAVC4VsOpVKxuPxxPj42NzgwMDMQH9/YgnAkAZwHgQMqrkIBgiYD2J+sLgr88jtCAACgD6QnY+WMIjy + +xfxHmkAr4D4oF4yDuAyri2KvZzSDqCHWdsFYCMWee54nudr6upCTU3N9bV1dfWRaLTeHwjULEXJF5La + mhqEQiEIguAAgSAIzn1B4KHrenF6enp6aHBg/NTJk6Pnzp6b1XVtIcUtgoDAKVR3D7LWc+66BdcgtxsA + 8AB6QXZ6WoIgyh+kF9/1rne2rV69OvC5z/3JxXw+z15sJsgucxjeZn8e5MKau4W/dzvcVs5qAHvnewHH + cVxdfUO4ta0tVt/YGIvW1DRJknTDi4DqausQDAYopWeBgPq3ICCfz2X7r/YPHzp4oP/QwYPjmjYvGJQA + nAEBAq9zZYJkC/px1xpYktxOAMCB7Hz1zLofRPldpvBb3/qW2O/93n97VJJk4eLFiyO//du/89qpU6fS + Hu+bBPAySDDKS0ZB/M2bXUnIA7gP7lTf0yDmv0sURZE6urtbWlrb2uvq6mKyogQW+yGLEU3TYJomTLNc + n8NxHDiOA8/z4HkeHMehvq4Ofr+/Yvfnmfv247zAQ+AF5PP57OlTJ69859lnL1y5cmW+lF8WwBEQ68yr + WCgN4CwWn2p8w8vtAgAcSCCskVlXQJTfZRE8/MjDDf/jj/9ov6KoEmDCBJDL5vJf+tKXD/zlX/7lVV3X + 2YvHBNlhjsBb0XMg1sLNNDMlEACwhQfwAVAVfu2dXU3rN27slWXZF5+bm0zE43OJRDyZy2bzhUKhxHEc + JwgC7/P5FZ/f7wuFw6FgKBQOh8O1wVColuf5RbkBhUIBMzOzSCSTLhAAbCAABEGAJMlob2tFNBqFqqrw + qT74fCpEQWSAwG0N8NZ9nufNoaHBseeeeebUSy++ODrPV5oEceHiHo9pIJbb1E08V7et3C4AsBYkrUWL + DGA/GIvg3nvvrf3TP/2TJ/x+v2IC1j5BQMA0TfPkyZP9v/kbv3Xg6tWrXhHkBICX4H3xmCDR6au4OWam + AOB+lM8RB+A9YFKegigKuqYt2TrhBYGPxVrqYq2tsYbGxtZwJNLIcdy810OpVMLMzCzm4vEKIHDel+fR + 2tKCgN8PQRQgihJ8PhUBfwCBgB8Bvx+iJHkCgcCXQWJ6amrm//vm/zv+3e98Z7DKZxkAjgM4WeV8DFnn + 6m5Z8TxyozvBlkNWAWhl1kQAj4GxCLZu3Rr587/4syeDwaAKcERzrP+QPxzX1NhY8/TTT/cUS6XUyZMn + E8zFpYL42QLILkM/yIG4GQ0gpuaNLlM1QUCP3qWjIKW/5ScZxjVd4KZpmqlkMjs6Mjxx6cL5S/1XrpzX + SqWkoiiyoigBLzAQBAHBYBDRSASGbqBQLHq9LzKZDHw+H0SBXF6GoaNQLCCbzSGVSqNQKMA0TQiCCJ6n + PobjnH7jQDDo375jZ/d999/fmkolU8NDQ6z7xlnHpwXEfWPPRwQkJjSDuyBQVVY6AHQB6PD4zo+AsQg2 + bFgf+uu//vwT0UjUTys+qH9bIABZlqT77ru3a8fOncGDBw5OpNNpegflQHLv7SD5ZtZSkEAajnjc+MaV + INyBzRkA3ahMC163lIpFbXJifObShfOXRodHroiiqAUCgbAgCBWfJQgCQqEQQsEgCsUiSiV3XM40TWSy + Wfj9PggCoRHgOOsMcICu68gX8kinMyiWigDHQRQlcBw5PzYQAEA4HA7ce+99qzf19kavXL4ynUwmWNQJ + gIB2CpUugR/EPZzBG6sbdNGykgGgHeRip4UH8JD1mCPd3V3+v/ni3zxZV19vKQu5fAzDQD5PskeCIKAM + CORSbGttrXvq6ae6Uslk4uzZcynms3wA1lj/nkKlNRAB2Y1T8K4pWA4pgYANfb/f+m5BuM9fESR9OWg9 + 56r171Hr+6es14tYoFMwn8sVh4cGxy5eOH9O1/VUKBQKS7JckUkQRRHRaASyLCOXy4I2RgzDQCaTQSAQ + AM9zjvKzf3VNRz6fRzabhWmakCQJHAUCBBM4NDY1RR959JE1qs+nnTl9eoax3ASQakkFpMyYflABcRNn + cevTuitOVioAtICgOi0cSArMBQqtrS3q3/3d3z3R3NwcsS8qADANE4UisQp1XYeu6+AFHjxnFcpZFq6q + qsoDDzzQvWnTJuX11w9M5nI5g/nMGIgLMonKXLQMoqAcbkzDSgFE0enahhKAAZCg5SBIXOIsSHHTJZQV + fta6TYOYyEPW46dBougzIKDhQxWLwjAMc2piYvbi+fPnC4XCXDgajcqyzJZdQ1UVRKNRaJqOQqFAvx7Z + bBaBgB8czzsWGOecJs46DRxMmCgUiwQIDIMAAc8754kDiXds3LixbfeePbELFy5MxONxGng5lPsehuHe + 8SWUQWClVXreUlmJAFAD0tbL+qD3orwjAwDq6uvkL//9l/d3tHfU0ta+YRqW8pONgOM4mKYJTdNIxJov + g4C1w3BdXV0Nb33rWzsnJydmL126lGE+2299toHKACEH4pvXgoDAcl9gcZCLl1VSE8Q9SYA02CzFFSmC + 1DcMgQDJiPW9gx6fA9M0MTM9nbh0/vwFXddT0dqaOlEUXU1JPM8jHApBURRkrN0cIOCbzeUQDPjBcbzL + FSj/JYeR4wDTJMHGbI54XmWLoGwNRKM1wQceeHC1ppUyF86fZ+s0wiAW4jDclpkIAhB3QYCSlQYAPEh9 + P2ui7gIBBUcikbD493//94+vWrWqAShfTKYJFIoF6wK0dxhy4QCAbhjQDYMEqBh/0x/wq4888siqVatX + i6++8upksVg0me/WgupBJwXEGjBBzO3lEht0IrhxnXxZEMvhrPVZNn2YC4RN08TU5OTc5YsXL6iqakSi + 0XqO41y9B4qiIBqJIJfPO7EBXdeRy+URDAQoZa78a1sDBAhMFEsl5PJ5CALJJoB6rSRJwpatWzu7urrU + Q4cOjTGpXRUkfjQKt9Vmt1PP4K47AGDlAUAMlbn+rSB1/44oiiL8xm/++qPbtm5tVhSlfJmapqP85SB2 + WcHtNdsa4K1CFhoEeJ7nVq9a1fSWt7ylfXBwaHpgYIANAgZArIESKnsGOBALpgZkZ16ui0wHAZ15TXZL + 8iAAlAZR7IL1PVhCDy8xQayYK9aNt36LS8kNXTdGhofGx0ZHrtbW1Ud9Pp+rJ4PneUQiYcCEs5NrmoZ8 + Po9AIGApPQXOjPLTwG2aJgr5PDRNgyzL4DieAgwOrW1t9bt374kdPXJkKJPJ0MdbAnEXx+EuDBJAYjfT + uBsYXHEA0AN3X38b3MUwkCSJ/5Vf/eWHuro622ZnZxGNRiHLMvEhC0Wi/NZzufL2X7kGQNN1GIYBQRBI + QYvzCIdQKOjbv//x1a2trdxrr70+pWkaaw20gWQLbMWkxbYGdBBFXC5JgexqE9a/cyAXdwIk+HUZJD4w + AbKTT4HELsZAzP1REJcib/0GGdVrQYogZvRF67m1YIAgl8sVL1+6eNk0zHR9Q0OM53nneuI4DoFAAIqi + IJ3JwDRNlDQNxWKRxAQoRZ/PJSgHCzXk8nmIoghRFMuxBI5DJBIJ7N23r+vChQtj09PT9I4vglgCLAiI + IMA2hTd46fBKAgAOJOdPX2T3g0qDCYLA/dIv/cK+devWdgEkyDQ3N4totAYGXarqpfAeaxzHwTAM6Lpu + lbUKrtoBnuf59RvWx554Yn/LpUuXp0ZGRtggYAjEGiigkqzCVpoIltcagPVeGRBlngHx5xdDwWWAgEYc + RClGQRSDBwFerspnjYBYBCo8OAamJidmx0ZG+hsaG+tUVXX1YyiKgkAwgHQ6DcMwUCyVUCpp8Pv9VZSf + dQmoc2gChUIepmlCUQh22SCgqqp87733dY+MjEyOjIzQMRwBZXeAtuZk67ew9R5vKFlJAGCjtS08gN30 + d/zkz/70PZs397kCgZqm4Wr/FdTV1ZUDRsDCIEA9ZpomdF2HYRoQeMHKR5NncQAikUjgyTc9ubqurk4/ + cODAtK67LEcB5V78CVQGmFQQ16aE5bUGlkMM6zvZVoIG4mJ4pQmLINbFGAiwubou87lc8erlS1eCwRAf + iUZdVYWSKCIUCiKdyUDXdRSLRei6Dr/PVz4nVbIDFSDAcdBKJRRLJSiKYgUWiTsgSZK4e/ee7pmZmZn+ + /n46DiOA1JMMwx27UUBAnE3zvmFkJQEAB6JI9O6yCdTFWFtbK23atLGTvrg4jkM+n8fo2BiaGpsgiiKo + B0E/z17j6L/UY6ZpQtc0cDxPMgUUCAiCwPf29rY++ugjzWfOnp2YnJhkzf4wSOoyh8oOQh7E7wyDWAMr + 0ffUre82CmJd2MNCWMmgTJzSCMpiM03THB4cHCsWinNNzc1ttEsgCALC4ZADAoVCAYZhwOcjhsdCrgD7 + HMN6D1mWrXNFQEAQBH779h1ds3Ozs/1Xr9KpWQkEBAbgBmkfSFxnJTNC3TBZSQAAkAg7/Z1s8ksAwKVL + l+I8x2XXrVvbToOAoigo5PMYnxhHc1MzBAoEuEWDQPlDdU2DYZikis0yB+zn19bUBN/y5jev8fsDxUOH + Ds0yBSkiSEFKLYiJzZrkPpDYQBFEkVaqZEF2+jTK7MC0mCBWwwBIVN1lDczOTCdmpqdHWlpaW+l0oZ0q + tEHALtJSVdVxvRbKDtDn0bRcAkmSnKyO1aHIb9u2vXNmepq1BGSQ2E0/c278IGD3huMcXGkAEIab4msO + 5dp8AMC5c+dnVVUtrlmzuo1+oaIoyGWzmJqeRFNTMwnsWY8tDgTKFxg4DqZhQNN1p92VBgFRkoStW7e0 + P/Tggw3Hjh2bmJ2dZc3+iPW906gsT+VBgC2IlWsN2JIDAbKcdW7Y66UAYg1wINaAc6Az6XRuZHiov629 + vUWiiodsEEilUtANA7lcDjzPE3PePh+LyA7YQVsTQL5QgCiKkESRblPmt23f3jk4MDg+OuqKCdguWT9z + 7O3KylvJ/3DTZaUBgA4SWbelABLk6gJlap4+dXo6EokY3d1drn4AVVWRTqcxMzuD5qZm8NVAwPnH/CAA + 04Sm6zBNw3ovt9tQX1cXfurpp1YLPJ87cuQoe+HYMY0ISGyAtQb8INZAHiu/f91m8uVRWR9gWo/NgFRM + Oi5bsVAoDQ4M9Le2tTUrFEcBz/MIBINIWu3F2WwWoihaab7yeViMK2B/kUKx6GQIOMod2LFzZ8fFC+dH + Jycn6QCgH8Ry6Yc7C2BzSrxh2IVWGgDkQEx+OhVoj5DqAnXhHT9+YqKhsYHv6GinAQOKoiCVTCKeiKOx + sYmQVViPeQUDUbHmBgEOgGGY0HWNWAOc+/1kSRJ37tzZed9999UcPnxkIpFIsIpeA5LdSKKyXNguTPGD + XHQrOSVlojzKK4xKtyAJkmpsBRU70EolfWigf6C1vd0FAqIgwO/zIZEkhySbzUKWJMiSVNUVqJYdsIG5 + UCxCEkWIUhkERFEUd+3a1XHi5Imhubk5OgAYBHHV+uEOAEZBwHo5i7lWrKw0AACIIjQy381Wng5QIHD0 + yLGxtrZWuaWlpcFes1JCiCfiSKdSaGxsKtehY4HagHlAwASg64QZh7YsbL+zsakp+tTTT60qFovpkydP + sTuIBFLjEAQxqVmzPwBi+djTdFey2E1HAiqtgQJIurAJlCunaZo+PDg40N7R0Ur3EkiSBIEXkM4QCz2T + yUCWZUgSmVGy1OyAAwKSTOJA1rmRZVnatWt325HDhwZSqRTtroWt3zDI/MZalKcc3dGyEgFAAwGBBrhr + AuIgprIrU3Do0OHR7p5uf1NTk9Mnb4PAzOwMcrkcGuobFgECFf+oAAGAg2EapIqQF8q97NbjsixL9953 + b/eOHTtCBw4cmMhkMqyi14IAQQKVO4wAAnwqbh9rIA1i4dDXkQ7SiWhnPQAAmlbSx8dGhzq6urvowKDP + 50OhWHSaiDLZLFRFhSgKqDT3qxcK0Y1ghWKRZAcEAZzViaiqqrJz567W11597Woul6XPS411zIeZ31iH + 8pizO1ZWIgAAZJdJohIEZq3HnACgaZo4cODg8Lp1a8P19fU19jrHcVAVFVPTUyiWiqivq58/GOi1q1QB + AYCUEsM0rTbj8us4jkNLa0vt008/1ZNKJpNnz55lzX4ZBAT8ILEBVtGDIDtoBgsPyrjVkgNJn0XhdgkM + kAyBCwQKhUJpbnZ2vKOzaxXP8855DQT8SCSSMAwDpmkincnAp/rKKd0luAK2uVYoFKEoMqnrsEDAHwio + 23dsb37l5Zf7C4UCfdzteQpj1BpnrSdvg/NwzbJSAQAg5mQKBARoM9Ou4W6xFywQGNq4aUNNbW2tQxdu + WwKTkxMwdAO1tbXXBgLlF5TXOKuxSCfWAGddz7bZqiiKvG/fvu7evl7/66+9PuHRZlwPUqtu76S0iCDW + gAxiDazkIhUNJCUYhJuuzAQBgSZQ1ZyZdDoHE5mmWKzTXuN5HrIiI2nFA2xWIb/fV3a35nUFvLMDxUIB + iqJA4HkHBEKhcGDLli0NL77wQj9T3t1E/Rb2PMVx4zgfbqmsZAAAyn4YCwKTIIjtBAB1XTcPvH5wcPOW + voZIJOI0p3BEGTE2PgaO5xCN1iwdBDx7Ccrtq5pWgmkCgihaj5DX8BzHtXd01D/11FPdk5OTc5cuXWIV + XQEJECqotAY4EP/0ZlGQXY8YIMBsF9XYYoL41+2gArtTk5NzdQ0NwVAo5DAcK7KMfKGAokUzRkAgi4Df + b7EOV3EFmPNGP2YCKBaLUFSVBG8tEIjW1IQ2btpU89KLLwwYbkq1FpDrja4HsNO2M7gD24hXOgAA5YaX + erhBYAxkh3QCgJqmmQcOHBrYtm1LUygUcnYdnuehKipGR0cgSRIi4cj8acElggDAwTB0aJrubiyy/vp8 + qvLIo4+sWrNmjfLKK69OFItFVtEbQAqIZlEZeJJAgK6AlVdKTIsJoiQq3DRmOoh/vQpUinBifGy8e9Xq + Hlc8QFUxF487LzQMA5lslrAKcVTXJlMgNJ9LYJomisUiVFUFz3FOLKi+vj6yavXqwEsvvsiOimsHsbri + 1JoAcv1N4w5rI74dAAAot7XWwQ0CIyC+tBMALJVKxsGDhwd37NweCwQCToUaz/NQZAXDI8NQVRXhcHj+ + tOCCIOC8gPprolQi14cTG6BIR7p7uhve+ta3dg4PDc/09/ezwSWbkFSENyFpHQgArPQswYx1TmhLoAii + UN32AdM0TddKWqqlrc2ZfCQIAjStXCEIuFmFSNDVOy4zX3bANAyUSiWoPtWK0xAQaG6O1ba2tcmvv/ba + CHOsO1CmUbNFtM7BFFZ28daS5HYBAKDc7cYOxhgGCTQ5AcBCoaAfOXJscOfO7a1+v99VhSZLMoaHh+H3 + +xEMhha5wy8taKjrpMNQsAZmUCAAf8Cv7t//+Or29jbhtVdfm2T8UA5kt+9AJSEpBxJsYznvVqLMoLKe + IwniIjg07rMzM8nW9vZGmk9AVRTMzcVdb0YIRXII+APgKBBYSnbAMAyUShp8KgEB3jpn7e0dDTU1tTh8 + 6NA4c6w7QNwy2iKTcIe1Ed9OAAAQRDZRORpsyFpzAoC5XE47fvzE4K5dOztUVXUKU8gACwlDw4MIBoMI + BILLBAJwPd+hIAPA2+xD9ntwHLd27dqmN735Te1XLl+ZGh4eZnd1m5BUg5uCTADxQ28E/+ByignizjTC + 3Vk4DpIBccz+bCYT7+rpWQtLfwVBQLFQdHELAoS7IV8oEBC4hkIh0kBEgFlVFTtGAwDoWbWqWVGU4okT + x9lj3QFiZdJZALuN+I7oILzdAAAg/pm9G9piB5vqQaWdMumMdvr06aFdu3Z2KKSBnPxoQYAoihgaHkIk + HLF60xcAAXZtHvOT/rdnpsCyCkKhkO/JJ59Y3dTYyL322utTDK0VB1JVNwd3aaoEd7pqpYoOAthNKPtJ + Bog712U/KZ1K5Vra2hp9fr9z3gSBRyJRiXGapqFYKCAQ8LvLuJeQHdB0HYZuWK3EnHM+161b16Jpeubc + 2bN0AFAEAYEhVLYRB0GstNsaBJYLAFSQQFYjyE7sBznZNypqGgc5OfQ8QBsEXGmnZDJZPH/u/PCu3Ts7 + JVJiRn64NatuaHgI0WgNfD7f4rkEKrb9+UHAzhQAnBMbcDIFPM9v3Lgxtn//463nz5+fHB8fZ3POYZBR + V7ZIIG7P7XDhFVB5nhIgwObECEzDLLS2t6+y78uyjLl4HIZRaWWXLC6AgN9PKX+lK8BacPRjmq4DpglF + lh0Q4DiO29Tb25ZMJuYuX77MAm4bvNuI/bjN24ivFwBUAOtAzNV6EBM8AuKnt1h/M7gxOdQ4yuSVthgg + IBAD1aI6NxcvXL58ZXTnrh1doig6JqndODI8MoS62jooirpkEOAWCQIAR0hHWAoy6wnRaNT/5re8eU04 + HNZff/31KarNWAWh8jacNyIWwO0SiEqCgDLtChRA0bsnEvH0mvXr19JDSIrFoisYSEuxWISma/D7fVVd + gfkCgxw4C5ABWZFh8wtyHMdt2bK1Y2JifGpwcJDOuCggoHWVOe4BkGtwBrepXA8A1IAw+AbhjszTYnPj + FXFjUlizqMw96yBo3QaqMGV6eiY/ODg0tmPn9m6BKt8TRREwgZHRYdTX1UOWlcWDAPvYAiDAcaSxSNM1 + gOPK9OT2yRAEvrunu+ZLX/ryGQoAdJD5d/SOP4TbBwBM67vSI82SIPMeJYDES+rq64PhSMRJ6ZqmiWSq + ej9OoVCEoRuW5cYe5/mzAzbwlkol8DwPSZYcEOB5nt++fUfn1atXxsbHxuhMjd1GzM6GDOE2biO+VgCo + AdC7yNfbKawbBQIzIABAk1Lo8ChAmZiYzI2Nj09s27a1iwYBSZJg6AZGR0fR0NAASZI9zHwPEJg3XuAF + AuXiIV3XYViZAvozLl64OPbVr37tKvVbEiB03fRv678Bx/FGShZEeejrxQeKAVpWFJ5NCc7Mzs/PkS8U + ANMkhCLU8V1cdgAAx6FYLEEUBIgSGU1mtRELO3ft7Dh79uwwQzJKtxHTgByx7idwm8m1AEAE3spvF0uE + QZTdqxHmRnVYzVifS5eiaiA7ZSeoqPPo6FhmdmZmeuvWLd10PbokSdA0DeMTY2iobyT8gtZji2cVqp4l + 8NqNTKuXgH7/F1544dKLL75Il6MOWTdb0rg9goC0mNY5iDBrzvSnQr5QXLt+/Sab6YnneczOzVWdQmxL + Lp8Hz3FQLXr4pTAK2Y85bcSi6ICAJEnirl27O44dOzaQcE8gCoFsgANwg0ANSIzgtmojXioABEE4+lnS + yA6QUd2bQE7qOhAFpAMktiVwIzqsTOuzInDnnksgAbNOUFz6Q0PD6XQqPdfb19vF82Xtk2UZxUIRk1MT + aGxw8wsumVpskSAgy+62+n/8x388cfGiq2T4PNw+5jRuT+oqHe6BrkWQ68UqDCrp6zZsWEfHAVKpNGm6 + WkCyuRwEQSgzBQMLZAcqz2GhUCDtyUK5jVhRFGnXrl1tBw8d7E+n0/QXiYBYnWwVYS1I7cZt00a8FAAI + gPj87FCKbgAPwt0NJoD44CZIMYUtHIiVcCMq2mwQqIGbzLIAksvtAgVcV6/2J0vFYpIlGZVlGflcHtPT + U2hoaKzOL+j8Y35WoflAgOd5UDFJGIZh/vff/4MD+Xye9jGPwJ2HHsFtdIFRUoK7lVsHiQM4103P6tVd + NGlIOpV2egMWkmwuZ7EKWVwCS8wOAMQSsJuHbJ4Hn8+n7Ny5s/XVV17pz+fztFVba313torQ3uRWesUm + gMUDgA9E+VkWmHYQ5eervM6mw6YLLGwQuBFtlnZTin1ybMmDmM3d9G++dOlynAOy69avqyAZzWQymJ2b + JSDgRS3mVT68BBAArFQk1U48Pj4+9zd/80Xa3y+BDP2k5Spuz3p0EyQzRFuPq0G5bavWrOlRqarAdDpd + URA0nxBWIbnsvi0xOwBrrJzTQWiBQCAQ9G3btr3p5Zdeusr0cdhBS7aKsA4kHrCSG7gALA4AFBDlZymi + YwAeXsR7tIAoIG3G2h1WcSx/itAGAXagZg7EGukCSzKqKJ4ko6lUColkAg31Dd78gov1/6uUDwuCACoM + gePHjg9+61vfookppkBIN20pgQDA7SptcAPAGlDB297NW3oUVQ3bfn9qiQAAEFYhVVEoLoGF+QXJ08pt + xIUC1Txk3cKRSKBv8+a6F37wg36mYMvOctGbnH19z2GFtxEvpLwyiPKzI6EbATwGxh147/veveGxxx5d + feD1g/RFzIGceJvbjz1IN2Jaq44yCNAXXMZa7wZNMnr6zHQ4EtG7u7ta6DdRVRWJeBzpTBoNDY1LYhVa + DAjYdQi2/H/f+tb5w4cO0/79VbgDfgm4+9VvJ+HAkLsC6AO1sWzZtn1DMBgK6LoO0zSRSCQW7QLQkslk + oKqqRQtmffQSsgMmTBQLBdI8xJdBoLa2Nrx+w4bIiy+8MMAEJ1tA3Fqv63tFDyKdDwAkEOUPMOt1IAE/ + lzvw9ne8bc1b3/rme2KxWEMs1iweOnh4lHqYA3EX4nCnSuzMwY0CgVkQM43+nWlrvQuUK3/8+InJaiSj + c3Oz8Kk+hEKh+dOCjMLDY638PM7l/wPAX/7FXx4ZG3NVAp5hjtcEbsNUkyUhkGIaW0QA20EBwq49e7ZI + siSLgghd1zEzM4vSIoKArJimiUw2C5+qlucFAFWyAvO3EftUNwg0NjZGu3t6/C+/9BIdALSvb7Zse8UP + IhXmWd8Md183QOrvnwDjDrzpTU90v/Od79hr+9Ftba2NtbW1OHr0mFeH1QzcqZIb2WutgZwUFgSSICfK + RTJ65PDRsba2Nrml1U0yGvAHkM/nwfM8/P7A/BkBL9/SAxjK8waI5HK5wmc/+0dHKPPSBPH/aWAcxO1L + T7UK7s2kASQICADwBwLyzt17tnGWLS4KIiYmJxaVBfAS0zSRtViFBMGa67BIV8D6B0zDQFHTrDqDMgi0 + tLTUNTfHxAMHXmc3ObuNmM7iiCBZgxU5g1CostYLd84WIHn2J8C4A48+9kj7pz71qQdz+RxP1253dnU2 + B4IB7eSJU7TJyoOk5CY9DtKNQsoSCAi4xliBWCMZeJCMbt22pSEajTr163Z+OJ1OQxIld98AlgAC1PNZ + ALhy5crkv/zLv9L+fhbAceq+CcK4ezu2oaogyk5XjPaCInNZs25d86o1a1bbR0o3dCSTSWia5tkTsBgx + TBPZTBZ+i1VoPleA7RwsdxDq0DTN6SC0WYU6Ozsbw+GwceTIETrLZV/fY3CnuhUQvVlxfQMsAPAgudka + Zj0A4Ekw7sDevfe3/N7v/d4jHR0dQjgUxvTMtKtwo6enOyaKYv7smbNsANDrIEkg0fsb0Ws9H8loCZRp + apom3vzmN22iyUQkSYIJcqEk0ykosuLsCrZUpAXnyTkDqCgAevWVV688//z3aYtpDO6Kvxwq8863i7TC + fU35AOwFdS7uve/+TTW1tfX2Qctms0ilM5CtAq1rBgGHUCTgUIsB82UHKvs8dKeNWCUuhAUCq1atjgmC + mD916iSt2HYbMdtBaOtO/FafDFpoAOAAbIS7ZhsgJ+sJuDu6sGv3rsbPfOYPH21vaxcBQFEVBANBzFAg + wHEct3btmjZD19MXLlycYz63E5Ujm28k4UI1klEVpEcdANDQ0KC+7W1P7bTdGY7jIJabCAkIpJLw+XxO + S6n1YyvTgvOAAJ3+A4B/+9d/O80wCF+CO+A3ixW4gyxSVsMdM+oFReqqKIr4yGOP3yeIgmgft3g8gUKB + eDvSdYKAPYIsEPCDTBOePyDolR3QdB2mYbUR2yDAcVi/fn1rsVhInT9/nr6+Rev3sc1DUawwVif6KlwH + qjbbPjcgyh+lFzdv7qv73P/6n/s7Ojpl5yACkGQZsqwgHi8fC47juPXr17Vns7n4lStX6ACJ3WvNjmy+ + kYQLeRAAoC/GDaBM0Qce3Nfe19fb7XxJUYQz5JaCjUQyiYDPb42zmict6LWz8JzL/AeAT3/6MweYarPj + cBf8jOE2KzO1xB6KQoPuvaAqNh9+9LFNre1tHfYxMk1gamrKUXgOywACuo5cPo+g1UZcrWx4vuxASSOD + YRS7g5DnwHM819vb1z47Oztz1T2NWAXZTK/CfR3XYgVxC9pXYStIPpM9cY+BcQfWb1gf/ZP//bnHO7u6 + ZIKOlq9kGNBKJdREo+jq6nZ/CM/z73v/ex544MF9rcxn+EAyCmywMQziilQrMLpWkTw+y5X627hxg+s+ + KQ21dwLOIfOAaWJgcAC5LPFilgICHOf+WTPTM6mxsTE6uGcTbNJyOyo/UNktGgBlTfI8z63fsHGtw9XH + ccjmsjBMw4mT8Na49mAwYA0MuTbJ5/MYGx+HpmnQNR2arlt/yX3d+Vu+abpm/SXPTaVSSCbJYFNDN2CC + dHF+4kd/7KFdu3azG2gLgN3MmghiaS/3tX1NwoMoRZfHl3wM1M4IAD093eG/+PM/29/Ts0p1kNGKlpa0 + koWsHOpq69DR0el6Q0EQhB/5kR9+eM+e3SzQBECsDD+zXmMdKA7LJ16xDVews6enmwEAe+w0qDQS+Z2G + aaB/oN/pW18yq5All69cnoJb5uDeIQysbEbg+YStIakBdU5bWlvDgWAwRBSdgEA8nnApfxkEBAQDwQr3 + aSmSzeUwPjFhKbZGFNtRdgICmkb/JUFA3X5M15FIJJBOpQkIGDpMAJIkiT/9yU8+3N7ezqbN14NqerIk + CJIVueXCg+z8dEKaA/AQ3FN60dHRHvzrv/6r/WvWrPXTJpNhErJFilQB4Dg0NjSitdVVXAdRFMWPf+Kj + j27btrWB+R4hEEtAZdbrQEz05QIBFgBcyr569apIMBh0TbElw0U5pzacBgGOI9Hq/v4rKFoVa4upEmQB + 4OyZsywAsPfTWIEppEUKW0FKE7ggFmuJ2orP8zw0rURGr3G8NwgIAkLB6wOBTCaDiclJR9FpK0BjwMCx + BlwWg465RByZTAa6bjhuSSAQ8P3qr//Go8FgiO2XuQeVZLYtqIy33XThPb7YWlCjtwCgubnJ94Uv/J/9 + 69dvCIIyh03TRKlUsvIoqACBWHMMTU3uDV+WZeknfvLHHtu4aSP7uVEAj6Oy38DOF18vCHBYAAB27Nju + ui+K5DzS5r8XCGi6jqv9V1GyqtYWRyNWlsOHj7DBPfb+SicBnU/YzlEXyEdrogGi7AQENE33VHwWBILX + CQKpVBpTU1OergANBo4V4LgClpugaZidm0Mul4Oh69AtEGhqaqr9lV/7VacmhjoGD6Hy2l7rsXZThUdl + pZ/LNKmvr1P/9m//dv+mTb1h2uc3YaKkleZVDHAc2tra0dDg3vAVRVF+5md+8vE1a1aztQZ18CgxBrFS + rtdk8sG9G3Fg4h7r1q1lAEB03Byu4rdZ90EeL2klXO2/6hSuVAMBdvcvFovakSNHWDYZ1gK4Xf3/BYXn + Bc4KplkggAUBYLlAIJFMYnpmpsIVcN9oV6AMBgQ0NMzOzqJQLMKw6N4AYMOGjZ0f+ejHNjEfFwawh1mT + Ueke3Nzjj0qEdgXJPv/5z+/dsnVrjSs3agKaZfaj2u5IrXV0dKG21r3h+/1+38/9/Cf3d3Z2sEG5RgCP + oLJGoRVUuu4ahN39a0H5p4qiCG3tbS63hzSUOJUiniBAm/XFUhH9/Veh63r5WJF/OO/JAsDIyMhcJpOh + /X27ZoGW29kCMOe7r2mabo/t4jneyrosDAAOCFj5/WuVuXgcM7NzjoJrVVwCFgzsx0qlEmZmZlCy4gQ2 + CDz55JPb77v/fjbetQoUF6IlDbiFrgCPynSEq9c8k8nG7QvcdfHaZj9XBQSYta6uHkQiUdcHBYPBwC/+ + 0s8/0dISYwOAMRCTiT2z7SD1A9ci85r/m7f01csUO4coiuUacCrwx4IAO/gjX8ijv/9qOYXFFJWwcuni + Jdbcn4G7BqKI26CtdB5hezxcZDDxudk0byk/x5M5josFAJ7nIYgiQsHgdYHA7Ows5uJxD1+/nB3Q5skO + FApFzM7OkscMAgK8IPA/+mM//mBDQwMb17oHlQHvNbhFFP08KsklrtB3PvWpTx2fmJgkHWqcQ5wI0WFO + sTY4jnPt/GxcgOd59PSsQjDkigEhEomEPvWpX9pfX1/PHqh2AA+g0vfvAhOjWIRwYGoZwADAls2bXfdt + BnFH0b1AAN4gkMvnMDDQD5PKY9vvxcrJkycXCgDaw1BuV2HBy+XODA0NzYHjTNsCkGUZiiJTSs5ZN/q+ + +9+CKCJ4nSAwPT2NRDJRzgQsMTuQzeWQSCZJ1aAFAsFg0Pdzv/AL9zHnXUFlalABud5vugggfgi9O85a + X8YHAJlMxpicnJx78sknCIeedaHzPF8uyrDrZKlUF1zGQtkqiEZrkEwmSfDQEp/Pp27bvjV26OAhlnUl + ChKjoNuLAWK+L5ZkNGj9nii1JoIgsXPFvOe9795BZwD8frdp6fwy9x9QlSPldY5DsVhELp9DJBJ1qsm8 + 5HOf+5NDMzMzdM/radw5HYAAOcY0FVgJFBVYJpMp7di1u0dVFdU5gqaJXD4HZxdxxL5vVhxPjuMhCgKK + pWtvKs1mc5AkiRCKLFAo5NU7UCyVIMkSREF0NoqG+oYIx3G506dO0XUdURA9o89rGKTy86YWCAkgZYkt + KCuDTa21xj76Z8+ezWzYsFFcu3Ztk32BcyAVbYZu2OfEAQFygrhKEAABjmi0BolEwtXpFQgE/Fu2bGl+ + /bUD/QzrSh0IQo4w370a/5oAAmhtIFHWdjBlzCAXpBN8iUaj8jvf9Y49TvkvOASDQeo3uX+DdWdhECgU + USgWnEGkrAWQTCbz/+OP/8cR5rsdgPsiGMLt2wEI67e0UUdSB6kAdczgxsZGNdbS2mwfHlmWkclk5q36 + Mz3u2C3WpesAgUw2C1mRIYlSOYA7bzuxGwxKxSJ8Pp81doyc8zVr1jQfOHDgSjKZpL9YPcjAF/uncCAb + 002dMSCA+JvsvL2c9ZgTFHv55ZenfuiH3tEaCoX89kHhOQ4mTJiGuQQQMMELAqKRKOKJuBMwA4BQKBjo + 29zb8Nprrw9oJY2lXhLgJsfgrIOYAbmoGkHcgzUg0f0QKgOctqwHVfa874G9bZs39znBGVlWoCiK+5PM + 8gVAry8EAoV8HiWtiFAoXAEA58+dH//6179Ou1xpACeY73oJt2cHoC1+kPPBe6wBAGZnppM7d+/ZwHG8 + PToRHMcjl1tEyTzjHPEcB1EQrgsEstksFEWxqg6X1kZsgvQN+FTVuRxEURJWreoJP/+979FsTgoIONL9 + HgHcZCvADjykQHZUOk02CYLUPgDI5XLG8PDI7Fve8pYenieDmmH59oZhlJXfa9f0AAFBFBGJRDE3N+tC + +kgkEtq0cUPtq6++xlIvNcGbZLQBZIepB7mwFnIEeQA7QWUAnn76rRubm5udqbU+nx+iJFYoezUQKP/x + dhPyuTx0Q0cwYHkY1sXygxd+cPmlF1+if88o3B2AWVS6P7eT+EB4Jdi0bhDk2iI/MpstNTQ2yk1NTY22 + Ugm8QAaDMNeTi4inil9lZwiuFQRM03RYhRzSlgVcARoodF0nQ2hl2XFa6uobIolEfJYZO2ZbAbrzJuT6 + vGlWAG32n4d7p9EBvAwKY7/5zW9Of+Mb3zhFH3+O4yCJojsTME9akE6dqaqKNWvWVTDjdPd0t/3SL//C + A6Iossq8DaQ8mBbWUfQSGST9sg/Ae0BZOxzHgaUCk2WZSv9RGQ2e816ng4Nsz4C1Pjszg/GJcRimCdM0 + ANPEsaPH2AwAGwC8ndN/Cojye3FJ3sM+ua93XbGpya4X4cALVqBP4EmNgFdlIFc9OyBLEvx+P65VDMPA + 2Pg48vm8Oxjoyg7oVbMD8TihM9MNKyio6/ihd71rpyzL9DUtg8RDaGnCTSwOolMPZHqlO1iWBTGjHVfg + pZdenn7729/REg6H/bBewPE8YJowTCY44+U/M5unJEkIBoOYnXUPgaivr4v2rOoJvPba60Me/Gs5LIyS + YZC863aQAoxuECvHhTbd3V2hJ57cv9W+z/M8giEqZOB8bQZj2PV5LAGAAEMySWrc/T4/NE0z//iP//hA + Npulg57HcWd0AC6JS/JXf/1TGz78kR/Z2dHehonJaWSzORQKBWQzleMjllIOKlhgcF2WQLZMKEKb/Qu5 + BABpQ/apKqzdAj7Vp4iSmD954gQN/DUgmy9tBei4SYFfNveYBAm60Qg0CeJbqwBQKBSMq1evTj/99NOr + 7Mk6dFaAqKrpqfDWIaoAAVmSEQgEMBd3g0BjY2Nte0e7euCAJ8loEm5yBR4EqNaDKPw2kOKhEOZxCx57 + 7JHutevWOikYVbX6/MF8IhYBAtaaZ1zANGEYBtLpNERRRCKRSH7hC188Rb2bDuAQ3FZYP1Y4q6yHiCA7 + /6K4JD/5cz+z5id/6ifu4TiOEwQeHe2tGB+fxPDwCHRdr1o/sRixOvXA8RxKpWtzqx1CEf98XAKVYMCB + g6ZrUGS5XK3IcWhra6v97neeO18qlezzLIAEeWnrzw/iDt7w9K9X8UEKxExzLl2QlMVqe+3KlSu5zs4O + 9Pb2OukdjuPA8TwMQ4crCOg8gf5nJQgoigLV53dxCQBALBarb25qEg4dOswGADus71oDwi57L8rBPbam + oEJisWb/4/sf69639/6NPp/PeX4wGLRKgF17+XWDgGEBAACkUimcO3d+5PvPf3+Qeqc5VM4AvILbqwbA + 5pIMMetReHBJfvwTH+v6xV/++X12SAkgCtvcXI+LF68gm815Zk8WCwl22IawL+Ga+QUNw0DWIhThOb4i + O+De/d2BQU3TCHhY7yUrimTCzJ4+dYq2AiJwn3s7O3fDB8B4AUARla5ABgS5ncj5iy++NP22t709Fo1G + yt1zHAcTID7uYkCAWrNjArIsIx6Pu75QW3tbU7Smxjx27DgbAOy0bjWoHvEnP1QQuN7eTXVvfeub173v + /e/d+fTbntq5fv26Dlr5ATh5e+sMsl+7MghYbZ1xCXRdc1k3r7z8yoXTp8/QF8EQ3AG/FG6vGYDVuCRD + IHRyLnfgAx98f/tv/vavPyQQxk5HSloJgInVq7vR3z+IXC5fAQLXgoiCIAKmCU2/NspJXdeRy+UtViE7 + xbewK2AYBiRJIsNHQZ7X1NQceubb3zpPXQ8yiDUbpz5ShnvgyA2RauWHSZAIpZcroABAqVQyL1y4MPWO + d7x9NT1kk+c4GIYJ+jQtBQT8Pj8EUUQy6XaBuro6Y36/v3Ty5Ck2UFZVAoGAuHfv/a1vf8fTmz74wfff + 89BDD/Z2dnU2B4MBP+dhW5J4BFMysCwgYJug5WPyn//5zaMTE5N0nusc3DP/pnH7jJxeEpfk29/xtth/ + +/3ffURk2D1IKzDx1yVJwo7t23Hp0lVkMhkHBKorP5Mu8BBRFGEahiv1vBTRdR35Qt7NDL2IQiFd10lA + 0goK+/w+dXZ2bqa/v4JBiCaFVUCuhxvqAlYDABNkB2qmjqoBxhUYGBjIx2IxY8uWchktZ9UHGIYxbxFN + xTq1FgwEAI5DipkP37Oqp0UQhNzZs+eqBgBbW1sDj+9/rPvd73nX1ve+9933bt+xbXVzc7Orzt9LeJ5H + OBxxqsBccj0gYK2VSuXzqOu6/nd/++UDBkFKWw7DXTY7jOUfonojhAPhbKhn1j25JJ980xONn/mjP3xM + lmWXxabpmrX7E4mEa9DV3o2+3k04fuIkcrlcOYvkGPf2v9mvUw0mSKEQ3b67VNE0DYVi0YoJUOY+AwKs + FaCoKtW5yKGuvk59/nvfu0y9dQCVtO88bjAP5HwNCEXrC9AmXQYEqZz+3hdffHH66aefaq6pqXG6+hyk + tk2cJUbSASAYDMEwDGQy5Wpfm2RU07TURYtkVBAErm9zX/1bn3rz2ve//327nnrqLTvWr1/XUVNTE2HN + S1ZEq4Y8Gq1BTW2tU//PRnOpL3BNwUHD0F3+58TE5PSzzz53gTnWh5lPu4wVOkyC+aXVuCT3g7EIHnhw + X93n/vf/3K+qqguMdV1zAWQoGEFrcxtRHEXGxo3rcfzESeTzBQoErl2ul1+wVCqhVCrC7/Oj0hXwdglg + Gq60ZCQSDZ4+fap/dnbWBn37V9FuYACk7uWGFQYt1IFkU2nTaZtJkJSaAgCapplnzpyZeuc7f2gNrXCu + XgHq5y0FBMLhMIqlosO7BxAQ2LBhfXs4EjYeffSR1R/84fff++CD+zZ1dnY0BwLepj0tsiwjFAqjrq4e + NTW1UFUf8Q/BXlfLBwJ204gt586dGzh44BBd2jwBovC2FOEuCFqpsgbuOn+AXCuPg7EIdu/ZFf2Lz//Z + E4FAwBUI1HUdRUr5g4EQ2lo6YBomdIPk1hVVwfp1a3Di5GkUi8VFgYBpwn3+GKOAgEAJbiNs8VIslqBr + Gvx+H1Ch/FT9i/UdNF1HwJ1O5Px+v3nwwAH6OoiiMiUo4AYWBi0EACZIeSrrCsRB1dIPDw8X6urqte3b + tzmkn7Yf5KoNWKxLQN2PRiLI5XMO7x45dBzX09Pd0tzcVCeTedDziqqqiESiaGhoRE1NLXw+H0MuSftz + qFj3cgkqrr95XIJSqeQCw5defPnMpUuX4tSzrqBywuxKHzHdg8quTJtL0sWr0Le5N/SFL/6fJ8PhkCsQ + qBs6iqWy1+P3BdDe0gXTLCu/YRXRqD4Va1b34OTJMyiVSou3BLjqy5IoOUy/1yIFq9DH5/O5sgJu5S// + 5TnOKjEn8Yz6+vrI959//hyVEuRBlJ++FoIgAHBDYgGL6UEuWM+jXYE0iI/noPxLL700/da3vqW5rq7O + 5QrANN3e2pJBgHQQZjKLnxTLcRz8/gBqa+vQ3NyMmppa+H0+CKJQ8WEci04Vhkh1EGC+tnPiTSr7wfEc + AoGgq6793/71K4cTiQR9QkdRWeJs9zmsRBCwsy+0CAAeBtNmvXbd2sCXvvzFJ2tqoq5AoGHoKBbL59On + +tHR1g0AlvJrMCwQsMHA51fR3d2J02fOQtO0ShCg4oCV56vyR9gzH0ql0rWDQKEAE7AGxZAPqpYd0HQd + wWDQ+SqiKAoCL+TPnD5NB7ZrUVkeHAS5PjgQkOWxTOnhxZIQJFDpCkyA7AIyQEy5Y8eOT7z73e9eI1A8 + TRzjCniBgIl5wIGD00acSqVcviItHMchFAqhvr4BLS0tzk7vcPqjHB7imA/jKrUYzNdBGckrPtjTJbB/ + gyiICPgDkCQJuVwOuVwu/8///C9HmQuuGZXTZW0QyGJlBQPbUclqwwN4EFR9PwB0dnb6/uGfvvRkfUO9 + qy7AMAwUqKm/qqKis60b4Ljyrm9F63UKBAxdhz/gQ0dHK86cPV8uFPI4L4vVDruD8FqmENuSz+cJmYms + zFsoZJomaTemjNampqbID77//Hmq70WwbrRroIAAa7d1jO1bM4jboIBU8i45VrBYADBBdqMmVLoCDlff + +Ph4MRwOl3bt2umYhrYrUK4NuHYQqKmpQSIRdwJqPM8jEomgsbEJbW3tlNJTffyssuPmgoAsKRAlEZIo + QZYlFItF0SOdyVknNAN3KnClgUALKjnsOJAxXy5QaGmJKf/4f7/8RCwWi9LrhmFYZj+53hVZQWd7DziO + t3j1qF3fMCzWXd2K3OvWiC4FTc2NuHjxCnTd8KwWXEqckOc4COL1dRDmcjkIggBFlgGOMv+tL2O7BLqu + IxgIwu6dkRVF5nk+d+7sWTraX4fKjIDA/CzbGvCDWA32+DUNS7Aal0JDVACxAOi0Tsr6Ag6n2csvvzzz + pjc92djQ0OCgPme1DdOpG6+4AH3AKlY5ovA1NTUwDAPNzTG0t3c4gTwX6QZbOcZ82M0EAUEQrN5y4nPK + ioxYS6w1EAhoJ0+cnGRe0Q5vEGiw1m8lCDTBm535XpBgoCN19XXSP/3ff9jf0dHu4rozTaL8tvUjSTI6 + 21dB4HmXgrv8f2atpJVQLBURDgcRizXiwoUrMAxvEFismIAzfOT6CEWykCQC9NWyA4auQ5Flq4GO6EZr + W2vdKy+/fLFYLNJmfz1IXcBSTH0VJCNTC3K9LOgzL5WHbEFXwDAMHD58ZOI973nPGrrQg7NqA1x5UudB + +iPmZxXieQGRSKQ8spmJ3C0WBNzrDiRUggBMj6AfWa+46DhrnUIOO/rvAgFZRizW3BIKBrUT3iCQhTcI + 3CpLoB7e8xl2gunOjEQi4j/9379/bNWqHldq0DRNFIpl5RdFCV3tPRAFwdrt3aa+o/i65jym6ZorbhCJ + hNHU1IBLl67AMEwIggDVp0KSJEJUs0i/3v5RvCCAAxkBdq2SzWYhyVI5pewBApqmlVvDAUiSLNXU1vJH + jxyhx437QazsiaV8viUKiHsgYIFhpEsFAC9XQAdJFzqMvZOTk0Wfz1e45549TpONXcllmG4QcP5b1sHK + dedEeW7JFevXBgLUuy1mh6d+V+WiO8Cp6eSCYkGgOdbUEgoF9RPHFw0Ct8IdqIX3KKutIHX/jvj9fuEf + //nvH1m/Yb0rEEiUP+8ovyCI6GrvgSTKbsVnTH3bDSDxALfy2xKNRlBfX4vx8Sk0NNQjFAoiGAggFA6T + z11k4NgWQRSd+MO1SiZjE4qIntkBw9CtWEC5HCLW0lI/ODAwMjU5SZ/bJpAMQB1IvcUG67YWxGWsBdHh + LCpJYziQwH0YlUSz5d97Db8vD7Lb04GdJEik0uH+fvXVV2cff3x/Q1NTo+MykFiAWY6SLwgC1VmFKpSb + WXeDQDk87AYBr3Xr3W4WCDQ3tYTDYf348RNeIMC2Pd9sEIiC1Pezyr8JwA56QVEU/sv/8HcPbtm62UVu + ye78Ai+gs70HsqRU7Pp6FTdA0zXXe7DS2NiAWKwZw8NjzrnkOA5+K91L+AUBtzXNobKakFwPkihCoyi+ + r0Uy2SxURYEgip7ZgWKpRIhMy9Rh3Oo1axpefunFi1RAkAPZWLtALMAwSHGQPdKuyXp8PYjFEEclC7MP + 80zcvlYq4gSIr0GXc06ABAQl+8QfPHhw4r3vfc8aSZIqXAHaJLJ/ayUIUI9cAwg4p5arfFOuyodVxAsW + k/6DHefwTgvawoKAKIpQZAVNzY0tkUjYOH7sBJsKbEN1ELjR3WJhkC5L9hpZB8Jq6/wwQRC4L37pC/t2 + 797lCgSapmn5/OS643kenW09UGS1Is/vuAEG6wZoKBaqK78oiJAkGdFIGMFgAMMjZRAACL2b3+dDoVDw + KP/lPP5F7kjXmR40TRPZbMbJRLHxAGIJU+lDAli+xqYm6eiRIyNL/DgBBCDWW/fZydoKCGBMMuvXDAAm + yA5EF3xUuALT09MlUZTy9913n5Meol2BqiDgcVaqEYrcWBCw3nEJ1sBClYKarsGE6YCAYINAU2MsGo14 + dTy2gVhdNxMEgiDmPdthuQrAfWCU//N//Rf37HtgrysQaIIof3k+Ao+O1i6oqo9RcKPS/6csgEKxQK4V + DxEEEbJUNqNraiJQfQpGRsZNoFwTKggCQqEQRFFASdOtlvWKEwfF4qUIh0MIh0Ooq62FLMtQVQUCz0PX + 9SUBgk0t5vf7IfB8RXagaBGIClbsgeM4xFpa6pOp5OzQ4OC1sEHZDMzNICXFdDBDtW6u3oLrGUaQB0EW + 1hUIg6oBf/311+ceffSR+ubmZk9X4MaAgPNBzPMq35Sr8mE3EgR0TfcAARWNTQ2xmmjUPH7c0xIowH3y + bhQI+OHN49cJQqnmuAMcx+Fz//t/7tr/xOMb2DcpFouu4SjtLZ0I+ANlxXeZ+lSqj1L+YrFQ1QwXBAGy + pFSs/79v/OfB737n+cvd3d1tHM/zdKZHURSEwyEEAwGoqg8+vw8BfwCRcAQN9XWI1kSdxxRFgaoo8PsD + kCUJkUgYdbW1UFUVmqYvOmXoZhWyzX3KFSgWEAwEaQ4Bbu3adW0Xzp0fSCTiBbLGc80tsbqeVas7Ort7 + 2lva2ppqampDpmnouVzOK8hhU+EPwe0SBEH01rlerncaSQLECpjXFThw4MDEe9/7Xm9XwDo/LAgslVXI + S0PZ9UWn/6qsLzsImDQICFAUFY2NDbGa2hocPXqMLQ1uBSkH9QIB10m9DlFBqLxYzWoF8BCo64XjOHz6 + s3+w7W1vf7qPfROiuOXxaK2xdgQDoUofn434Uy5AsVSAbngH4gRegCxXKv+//etXjv3Ob/3uycGBgbnJ + iYnx7lWrWmRZlunzzYEj4CFLUBUFiiJDkiSUOUk41/Uh8MS1s4uOFEVBNBqB6lMdvsCFxDAM5LJZ96wJ + 65q3g5w+v9/5TFEUhY2bNsWOHDp0ZfW6dd337t374Jp16zY3NDW119TWNtfW1cWamps7elav2dDVs6pD + EITSzPRU3ONctoKUmdNfMgJSamwA1w8ABipdAQ2kqs3xB2dnZ0s8z+X37t3r7QpQB8T+dwUIlM+JcyIX + lf7zWCsvLZwl8AIHz7iAiYXjBSwIWCalKJIpS4JggUBDQ3NtbS2OHTu+WBCow/WDgAKi/CybUjOAR8G4 + A7/7X3+n733vf+829k1YxW1pbkc4GKka4GPXdENHqVisqlg8L0DxUP7/95/fPPUrv/xrzoyF6ampzIlj + xy/XN9QrtXX1tTzVu1thcdIAwVWuCaIAjekZUGQZ0WgEmq4hn18406AbBnIWq5BNLea4AqUiZKdCkHym + z+dT+7ZuWSPJSo8kSVUZrmRZ9jXHYp1t7R1NkxMTY4VCgd7xVRCF76fWBBArbta+c72Ssz6IHvKZAIkg + R+2FAwcOzj388EP1sVjM2xVwjjddDLQIEKDW5gUBr/VrUvjrBAHrzvwgoKChob65rr6OO3LkqBcIlODm + kLNBoIDFTUtiRQJRfpZGtx6ks8/lDnzqV395/Uc/9uHdFZOOS27FbW5sRTRc4zDj0kG/cp7f7QZopZIT + LGWF53nIssI6ifjud7537md/5ucPsP55sVjQTx4/PtR/tX8wHIlIkUg4zHMC7+l2WtebrutaPD47Mz01 + PTk7OzOdz+ezPMdxiiwrrNlvl58LooBMZuGkjK7ryOcL8FNcAvb3yOfy8Pt9EAXBTmMgGAiIHM8hmSyH + A0RRJJwGjGuk+nyhzq7u7qnJqeFsNkMjUgSVxWVBECtA57A8IoIUhdDQrAJ4O6gdZfXq1YFvf/tbbwsE + Ak7kxjRNFxEEWYPVRGQSgDBNwITzb8912Pft51DPn2/deS94rJXXF16z3tuosk5/Bxv0qM8kwSbVOSaF + QgHT01N44YWXjv/NF7541CP4dADAGWbNBGkkWQqVlAii/OyU5lp48Pj9zCd/avXP/cLP3s+2XZdKRZfi + NjbEUBetdxp7dL2yqo9N/5W0UtVeDzI3UKlIub780iuXPv7RH31Z07QFo3OBQEDa2Nsba21tqw+FwyFB + EATDMJBJp7Nzc3OpwYH+yYH+/tlSqeQyPziOQ01tbWjt+g1r2zs71wuCUNGBmkymMDI6uqggoc/nQ6y5 + 2VJmAaIgQhAFqIqC1tZWyJIEQRDACwIEnsf5ixdRX1eHllgMgYAfkiiB53lMTU/j3IULmJ4uG4SFQiHz + 3We+/c1kIkEjUh7AV+GOBwwA6F+uiaQGiCVAV39pIMjTZS/Mzs6WAK6wb99eV4EQnF4Bew1wWwLW+iIt + Aeefi4gLsJ/puu/RoOAVF3DlEG6AJdDQUM8fPnyE5QdcDkugGolnBET5XabnRz/+ka5f/tQvukg8AcLj + Ryt/fV0j6msa5y3p1Zn0nzaP8nMcbzXauA/q4UNHBj7yIx970UP5Z1BpzaBUKhmjIyOJc2fPjp04dmzg + 2NEjV48fO3r17JnTw1evXJmanZ3NGlUIAnK5XHF4aHBssL//UrSmJhAIBmvoxxWFTJNKpRY+7JqmoVgq + IeD3WRYAuQoM00TBshB4jgdnXRex5mZIkoR8jrTF5wsFFItFhMMhbFy/HgG/H2Pj4/b1Izc2NdddvniB + 5pcQrWuFrjVRAYwu50jiHEjRAb2TxEEyAlF74eDBg7MPPvhAQ0tLi+MK8BZvgItHkAYB8k8wK97rKwEE + qHWvD6kWHPQCAVVRUF9f19TQ2CAcOXJ0OUGAB8nzsySeQRAeP5cCve8D7237rd/+DU8ST42y4Opq6tFY + 1+yd6mPy/K4S33m6PBVZrVD+kydODX/ogx/+QaFQYNMExwH8AKSzsh6VAc3rkmKxqF29fHmA47hcQ0Nj + K20J2dV/6fTCIEBYhTTLHbCuAA4wdEIdr2kaTMOEpmtWF2zJlcE3YQFJoYBYLIamxkYMDg3BNE2oqho0 + DTM9NTlBm/0hEN5JW0QA08s9k9zOCtDvOwHSLCICToHQ5Hve8+41siw7z3N4BCm5nUDA/rMcIGAYJiSp + EgSaGhuFKpYAO2POBoFqE5Q5kGq+WmbdD6L8Lnfg6bc/Ffv9//7fHqWzOICbxBMAaiK1aGpo8S7p1Um0 + m83zs3Rg7sPkrfznz18Y/+D7P/S9TCbDRgpPo0ytlgBh10mDVM4tdUxQEQREeXjMlZicGJ/JZjPTLS2t + nRzVfupTVRL1X8Rcw6IV7PRZzWzOmTEBXTdQLBatYiT3dUKbKKb1Pg319QgFgxgaJoxi4UgkevHcuXOU + S2IP2HW5BssNAAaIv8G6AjlQBBKzs7NFjkNx79697Q57qtXXzfpQ1UCAWV0wQ2DanwGPlyzUPcgBhkFG + etmU0JUvqw4CHh/hnT7kaBAgdNIcSKuqqiqoq6ttampqFA8fdjWNAKRN1wsEvMaoc/Am8VRBzH6XRbD/ + iccb/+iPP/OYrCxE4hlFrKmtHNmv2txDKz+hA/PymzmOgywrhIefkqtXrk594P0f+k4inmAjhedB4iK0 + 2DMtLoBEwlMoF8fYl4V9zc6BKMhZkAEtR0AA5Yx1XP1ggDE+N5fKZDLTLW1tXRxX/qKBgB/5XH5RnYWF + AqmU9Ckq6EIh79xyddF0HS0tMczOziGVSkGSJCWRSIwn4nH63Gfgbi7SlhsAAIIwfripoOdAdiTn4jp4 + 8NDsAw880NTa2ur4nzzHe1Z9LQcIlN9rYWuA5znouoFsNoNEIoHp6WlMTU0gmUwiEo6C4zl4WwNVshLz + ZQ6ACmvAnipjGmYZBAQBqqqirq62sbm5STx8yBMEdHiDQAnlEWPrwFB2gfR27AdjEezdt7f2T/70c/t9 + voVIPMNobW4nTTQeef7ymsbk+udRfklx8ToAwPDwyOwH3vfDz01PTbMmwxUAr2D+1ll7+k4/iCl8GsAp + 63YapPV2GORapd/fAClwuwyiQC2gLIL43FyqVColmltaupzx8hwZL59KpRdVJ2CnEVVFqaDUN5kLxPS4 + qE2QNmNZlhAOh3Dlaj/54oaRGx4cpC1GDQA9oXhZ0oBekkC5HdGWCRAyCccVOHTo0OS73vWutYqiUHMF + eM/qL3cxByqUfSFCEfd7lZ12jiMTjovFItKpJGZnZzE+PoaJiXEkkwnkclnHzDUMA9lMBpFI5KZwCei6 + 7gkCtbU1jbFYs3To0OHFgkAdCAg0gaHsQpnEs4Fe3LVrZ/Qv/+rPnwgGF0Pi2eki8XTt+lUq/kqloivw + S39dRa5U/vHxifgPv/9Hnh0dGc0zLxgA8CIqlX/hQQGAiflBg5VZkAxLB6i6iJnp6YTP5zdr6+ocglSe + 5+H3+xBPJBb1xvlCgUwT5tybi/s0zr9mE+RcunQZumHANE2dCQaacMcBuBsFALZZRV9UJRCfyikGIq4A + V9q7d2/bQq4Aeaz8o68FBGyfGgBy2SwS8TgmJ8cxPDyEyckJJJIJ5HK5eVHbnhATiUSxUA/BjQaBlpaY + fOjgYbZxpAXefeS9KHMK2CKAFPk0u57Yuyn0N3/7f54MR8LXTOJZveLPQJEhSaWFKL/7spyZmUn9yAc/ + /MzVq/2sYz0C4Puo7HIbAHDROoo+LDwyfimSAeFw7Aa1wY2Njkw2NjVHA8Fg1F4TRRGiICCdXrg+K+An + I+lpIRrgHe9yP4cIz/Pw+XwYGhkmroVh6OfPnj3HPP00/ZIbBQAAudDs1kVbZlFuawQAHDp0eGbfA3ub + W1tbHf+qmisAuM1tL5fAXuc4DgIvgBdIE0cqlcT09BSGh4cwMNCPqekpJJMJ5PP5Jbd9aloJpWIRoVAY + txgEGlpaWuSDBw+xlkDM+mI2CDRZtzCIhZAFUYqHQYKIjqxZuybwpb//4hM1tTUuf3chEk9jnjw/DQgl + rVilGYd07gnMJRmPxzMf+/Annjl37jyrReMAvofK2QnDIGZuCeR6GwGJgejWby6X23mcWhBzfwLlUW1F + 67jRr8mBWFk9oMBlZGhouKO7u12WZQc4fT4fisXivLwEdnHP4h1/b2uAFwT4fCquXLmKYqmEkqYVzp89 + QwOABjcA3DAXwJZqrsAae800TRw5fHjyne9855rFuALkp3LOVm8rO6F0IgpfyOcxNzeL0bER9PdfweDg + AKanp5FKpRZN/mgYhhGPx5NXr/aPHDl89FI2k8k0NTc5FFd2s0sgEEQZBJaLVQgV4OYFAopCQKC1rVVh + 5gwAZRAw4ObuD1tru8Aw+3Z0tPv+4Z++/ERDQ4Nrmg9L4qlQJJ7epn5lnt+m86pmXcmSQk3OIZJOpXM/ + +vEff+b48RNsZ9w0gOdQSYI5Bvd4LaDcuToDsnMPgVyDk9bfcRCQ6LduEyDp6xyI8idAgKQO7nJom7HZ + sWh1XTdmZ2bGO7u7V/OUGRMMBpBKp5ZEMmJ6rs1vDSiKDIEXcOHiRdKOnMnEL104Tx+PHJgBtDcaAHQQ + s9/LFXCKgWZmZgs8z+l79+5tXTgrUFZ2URBgmiaSqSQmJycwMDiAS5cuYHh4CDOzM8hkMouaCGsYhhGf + iydsZX/mmWdP/OM//NPBb/zH/zv98suvDJ46dXrqwIFDw+vXr4vU19c5BSD5fN4yu/xYfhCoLIGuBgI1 + NdGG1rZW5dDBw6PM8eoBifazzEL3WsffCVPHYs3KP/7ff9jf0hJzFbgYppvEU5YVdLX1kMEvHuw9XiSe + uqFD00vQq5T4ypLsDGexJZvNFn76pz757OuvHYgzT58F8CwqefInQKL9C4kJAhwF6lZEFcYcS4ogAFIP + NwjMgqTXnOs7m8kUTMPMNMdiDrhyHIeA349EIunp2pYrUJcinPsvB4TDIUxNTWFyipSFTE9ODg0O9NMb + wwzcA2jyS0w2XLNsQmXaaT+ogJQoitxXvvJvb9qzZ4+LS07Xdcd/58Ahn88jHp9DPB7HXHwO6XS6SjDJ + W8jOnkiOj4/PDA4OzVy+dHnm/PkLc8lkckHTQFVV4bd++zceb2trdfnMzc0xhEIhd/kvmY3GrJnOyDR2 + nSyzz/UugZYkiYylMu1S6iKmpqZw8OChc3/2p3/xulXNpqJcgHUJxCcGSArQvjhTALK1dbXSv/7bP+/v + 6u5yBQJN03Ax8UiSjK72Hgi8UL25h+Hx062xaJrmnRKTJBkio/yFfKH0cz/7C89+57nvsoNgEwC+jUrW + 22mQdN2NHqUeALANbouWB6mdcF23Dzz8yL0tbW3r6LW5uTjGxqtXaXMcYSMSJcIpKIki+SuJEEXJ+bdk + /Vt0/i0iEg6jrq4Oh48edWoQDrz6ynNXLl2iAeAk3CPoZm4WAMggJid9pkMAngbVaLJ+/brI17/+9acj + kYgAENMznU5hLh63lH7ONSFoIbkeZa8m0WhU/u3f/o031VGWAAC0tbVDVX2e/QWL6g2wlMxYoGfAhOlY + AX6/3+mHKGklTE1N4tChw+f+9H//+THDMKLMV78Esl300IuhcCj3L//6T/etXbfWBWosj1+ZxFN05fEr + Un12us+m89K0il4PWyRRgii6y+qLxaL2a7/yG9/5xn/8J6spKRDlZ2MBsyB+7bXzdy1N6kE4EmndCYBc + y07GRJIk4Ym3vPVNwVDI2fhM08SFi5fmdQXsOQW0souU0lcAgCQhFAyhubkRw8MjDsDkcrnkf37ta183 + DJ0+Ls/APXJ+2XoBFhIdxNykrYCitebMEJieninwPGfEYs0tl69cxvnzZy3/fcopj6wmhmEYc3NziatX + ro4cPnL00jPffvbEP/7DPx/8xjf+84xtxo+OjmYKhcJS2R7t4BEAIJ/P66dOnR7ec8/uLnricCqVIp1h + 9pxBj3Jhj7PtHfZZgEvAdgcMw4D9FQRegOrzQZLEekmSwufOnWenyq4CCfg5u6eqqvyXvvzFe3r7el11 + AddH4km+F+Hy06sqvyhKhAuBEk3TjP/y2//1+a999d/ZoGYW5OJlqxrjuLnKb38Xtvu1ZJ0lx6I1DMOc + mpwc6161ao0dD+A4Dul0ZkEykUp3gHP/myubOqqioqGhDtPTMxgZLR+240ePvMxwBGQAHITbSupnKZ9u + pIyD+Ep0scl5kGYhZ/f5i7/4/JnW1pbOpuamhmpvZJqmOTc3lxgbG58ZGhqauXTp8vT5cxfmUqnUtZO6 + E9FACkFmqFsSZPBFl/2k0dHRzJ/+6V8894u/+HNvUsiwN5imieHhIXR2dIEXBGY4pQnT9AAB04TpBQLs + uhVecMhUrfulUglZi23GhIlioYhMOosNGzZ0mAD39X//jzMmuZqioGY3AJiRZIn7P1/8qy3btm9jzH4T + RZbEs63bpfxe7D1eFX9aVeUXK5Tf0A3j03/42R/867/82zDz9DyIz59i1pMgyn+zJyjzYKYeg1izvewT + 2zs6W9jOwcX4+qZpOpudZeDBVRxkWZeKIqO2Norp6RmXazE0MHDm0vnzg8zbnoMbKAsAkjfLBbBFAWkb + poEnDGI+OWvr1q2N/sqv/vJTgiAIFcp+8fL0uXPn59Lp9PUquw5iPtLKHof3biKAFMu4zORdu3Y2/cRP + /th+ehSaJEno6OhyuA7YNuKlxAUq1p2WZ3e8wOagv3z5CnSN+ODxeBxnz50d/vev/ceQaZouJed5fu6v + v/D5loceftCVAjRhumi4eJ5HR1s3VNnHmPpapf/P1vdr3oSaNomn63NN0/yf/+NzL/3ln3/+MvP0IsjO + z07HzQA4hhs4NnseiYHQctvCgZRQu66NTZs3r+7dvMXVNq3rOi5cvLTogJ9dt+Jl+gcDAXS0tyOXz2Nm + pnx4JsbGLv/ge999ielqzAD4d+Z4DQK4erMBwOsAAsSn2k0v3Hf/vbFioaifPXtuNpPJXO+J9trZ41ia + 6SgDeBMY9H/88cc6P/DB9z3k7gpT0dHRcWO4BDxAIJ/PY2hoCKIoOY/puoaLFy/iBy+8mLxw/sKkfdHx + PI9Pf/YPGn7one9gugAJfTdL4unz+ZkAX9nH96TztnL9Xhc5S+IJ8tvMv/rLv37tj//of55nnl4CSfVN + MutZkI6/GzItdxGyA27zvxOknsKRtRs2dG3bsfNBljNhdGwM8fjiKgNtcYGAFSAM+P3o6uqEViohQZGF + TE9NDnzv2Wd/YLjz5yaA78A9a9AA8DqA4s2KAdCSBukJoKvMpkGAwTmwQ0PD6dHRsQw1OnmxooEo+BCI + i3EMxPe5AFLYMQviBy81Yqxbr++CNQUJAK5cuZKQZbmwdu0aJ5ah6xry+TzC4bKO3ShqsUKxgP7+fqcu + wbYGpqemce7ceciKrKg+VZydmc1wHIf/8l9/p/6973tPlP1xBYbEs40l8fRg7/FyA7QqO381Es8vf+kf + Dn36Dz5zllnWAXwXldWMedxa5fehcjDqPlCdhg2NjdF79+57jGfKGaempzE7O7eIj6gUWp9lSUJbWys0 + TXO1Hc/OzIw8/9xz39d1ndWXI6isjRiGRSt3KwAAIOmcGNwlmlMgBUJLKdu0q71sZT8KkuY4j+tTdrsi + rAA3KUYJ5TJQx2U5c/rMdENjI9/R0e4E00ol0iobCpW5NpabWqxUKqH/6gBKJc0ilCAtt4lEAseOHXe4 + BVRFVXw+VfzYJz6qfPRjH2b910oSz+Z2hJZI4mlYyu9VwVmNx+8r//rVY7/zW//lJLOsg5T3soVNBQAn + 4B6YebOlCe4YVg2A7fQT9j308AN+v99lXc3MzDq5+WsVwzAgiiI62tvAgfQO2JKIx8e/99yz39MYJiOQ + GMlRZi0PUgxkApW87zdL8iAdXDSXfAKkqeMBeANTCcRst034aRAlvd4gUAnER0qBWCcp6/uZIGC0Ge4W + 2ThICep++nv+zRe+eDQSDvl6+3qd35RMJiEIIhoaGmBQo+qILpNInh0sdAqKrYVSqYRcLo9isUgUy9oF + BFF0KKMGBgZQ0krloSQmMDMzg5MnT7qYZlRVxY985EPhd7/nXRU/niXxjDW1IhQMVw/weQ3w1HWUNM2z + cpPn+aoknr/+a795jFk2rWtgyOMcncASpt7eIAkz910xlKbm5pqa2lpXs9XcXBwTk5MLvvFCIooi2lrJ + W9Ntxqlkcur55579bqlY9GqPPsSsGSDK75zwWxEDoD97Myi2IEsiIMAQRHkqjh2Nv15ltxmLvZS9mtiE + mQFmvRPAQ/QxlCSJ/83f+rVHurq62ugnNjY0IhKtqcJFWA4O5vN5zMzMIpFIoJDPWyxJVAwAZjkqTK9Z + z0klkzh65BhKWgk8x0MURZgA9u27H+99/3sqKg4JiWf5umlubEFNpG5+Hj+X8msOo49Xbrsaief3vvu9 + 8z/xYz/9KgMYJoCXUWmuaiBm/7WQnS63sP7/w6DKqXffe9/WntWrtzrHt1jE5StXr3m6kC2CIKCzowOq + 6gbSTDo9+51nvv1MLptlGw0uA3gJldf1eTB8kbfKBbDF7hWgzf4CiJndD2IGzmJhJfUS24yfst7vqnUb + BwkIZrC4KLIBAkANcFtMCeu7OspuGIZ56NCRoR07d7QEgwHHL8xkM1BVtYLL3tbHQqGA4aFhjIyMIp3J + QLfrHWxfnzb/OfeL7buZTAZHjx6HVipZnZEEXO69dw/e/8H3VbTXlhjlb6xvRu1iSDyZzj7NAgVWqpJ4 + vvzK5R//xE++4vGa11FZyquDVK+lsDLE1QEIsjE4saxNmzf3+vx+x0qYmZlFNnt9Ixx5nkdnRzt8Pjcz + eC6bTXzvuWefzWYyi22PvgKiBy651QBg78j1uL6WzeVS9mqiW+/TyHzPaeu+4/sXi0Xj+LETg3v27OpQ + KchOp9Pw+/2QnJZPohhTU5MY6B9EPk9Ztx4KPx8I5LJZHDlyFMViyRUg3LZ9Kz768Y9UKj9L4lnbiPpa + msTTWJDE0yn59ajvr0riefjIwEc+9LEXPEg8D6OS4dgAIetYWtj8xgkHstvTB3MLqErWjX2b++hOwOmZ + 2UVPEPISnufR0d4Gv9/NZpbP59PPP/fsM6lkkkWXEQDPw7s9etDrM241AABlOqYIKsdReQmt7CMgin4F + JGK8HMpeTWxWnUa4XadxMJORs9msdv7chZHdu3d1Sc6geCCdtqsFBRiGiYGBAUxNTREXwGlwdDTeKsop + IZ/LIZfNEX/faoSyv0E+n8fhI0dRyBfKTAkc0Nu3CT/+kz9W0WHH8vjV1tSjsb553gCfZ7mvrnny91cl + 8Tx5avhDH6hK4nmcWTNBAOHawuY3RniQBioaAHpBl7Jv3LSRHuIRjyeuGQA4jkN7WxsCAbfnWSwUMt// + 7nefScTnWJdoDPO3R3vKrQoCspIC2QUarFsIBJx0EIWm/fZrcQeWS+IgFVUbUAYBE4SOygcqKHT16tXk + X33+r7/7M5/8qSdsEDAMA8NDQ2hv78DA4CCSiYSlKKRSEBxgaDrGJ8YxPj6Oubk5sqvbsQDrvX2qgpra + WjQ01OPC+YukP4LjAJM0jK5ZtxY//pM/ZvWYl4Xl8YtGatFUH1saiadN470E5b9w/sL4j3zwI9/P5XLs + xXkGlVFqEyRQNYOVJQYqr7sSKBdAK5VcvrgsSdc0w53jOLS1tiAYdCt/qVTKv/D888/Ozc6wLtEUiPKz + J2UU7u6/ClkJFoAtJoiyT4Kg1qD1197Zs7g1lV+s2N+DTgeZIJHrFlA54YmJiWwikZjdsmVzt10Uohs6 + zp0/D8MwrQ5HOO2/w8MjOHr0KEZHRpHJZOD0cTD+vlbSkUqlMDE+QawC+wM5Dt093fjkz/40FCZgpDE8 + fpFQFC1LJPGku/1YIcqvgPMg8fzg+z/0nXgliecFEL+fvQYuoLL4Z6VIDG4rtQPUTIVYa2tDKBx2Sq4N + w0QqtbTwBcdxaInFEA67Ew6aphVe/sEPnp2cGI8zL5kBKZjyao++iAVkJQHA7SQpkGNHpwcNEBDoANUV + NjAwmDJNZNZvWNcOgBsZGUUymUShULDMOw66puPosWO4evUqdM3Kx1umPK3cZN31H9fz2trb8HM//zMV + PqMniWesksSzWnOP/Zit/F4cDfOReE55k3i+jMod9RLc3WorTWrhLmCrA8UF4PP5xeaWli77vqLISMQT + S2KcisWaEY26izR1XS+9+tKLz42NjLBWURykT4LNAkyBWKoLWsp3AeDaJY7KrjANJC7RBWqnOH/+wmwk + HDZlWY7Z1Vu6TkZMy7KCgwcPYmZ6Zl7lJgvVQaA51oyf/4VPugqPAJvHr6x/AX+wgsTT8ArweTT+aB7K + Py+J5weWROJ5BZXFPytNAnCDvgCqMjCZSKTXbtiwge7+k2XZNdtvPmlqakRtjbtOyzAM7cCrr3x3aGCA + tYpSIMrP1kbMgir0WUjuAsD1yQxIcQi9KxRAzC86ZcSdOHGyGAoGfQ0NDVHniYUCjhw5gmwmC5bsVAw0 + wNe6Hf6Oe+Dv2INg5z3wxbZAqe0CLwdg5OMwDdKFWldfh5//xZ9FNBp1fTmWx8/vC6CjtQumiUqzfh4S + T5Lu0zzz2VVJPH/4w89cvbIkEk/PKPUKEw5uSvUMSDxIAAglWCQSlaM1Nc5zFEUGL/DIZOYnBm1oqEd9 + XZ1rzTQM49Drr3+v/8pl1irKoHp79CksocflLgBcv0yDlITSTncWBIm7QaLGEQDqxYuXZtra20LRaCSo + 6zpOnz6Dubk5AIQJBuDAiSqCqx9DsOdBSOEYBCUEXlTA8QJ4UYagRiDXdMAX2wyYBgJCDj//iz+LOubi + ITx+ZeVXVZ+bxNPq21+IxNMO+Hkp/xJJPCdA6vuXFKVeYVIEqfuwzR0DJAbgHPzpqamZntVrVtFtwH6f + D6qqIJfNeUy/4tDY2ICGejdhlmmaxtHDh39w6cJ5tioyB6L8rFmRBKmZWFLvzF0AuH4x4V0olAIBgj5Y + /QSmaeLC+QuTnV2dNQMDAz7bNNR1DTzPQ1JDiGz6IUiRtgU/lOMFyDWd2L5rN7ZviLnykoZhuHZ+RVHR + 1dbjJvGs0s9f6QZonpRrVUg888tA4rmSxUTl/MskyLAVDgA0TdNz2exsa3t7Dzs3sLa2BqqiQpQkKIqM + UCiEWHNzhdtmmqZ58tixl8+dOc0CYwHE7I8z62mQUuklV8reBYDlEbpQyDH7QS6UAKgdQtd17syZs3ww + GIjQs/ZMQUX91vdA9Nct+kNN08REgswS7GkmgT+bxNNcFIlnuejHM/ine9f3e5F4ZtKZ0k/++E+/eODA + Qbbr5XpJPFealOBmWbYbxpxgYJzk6DONTU3tNAhwHAdFURAMBhAKhRDw+ytAFIB59tSp106dOH7R43Of + Q2V6NAui/NdUcHAXAJZPSiBVazYIdID0OcyBtA9HQUzHmGEY6tzsXKa+oT4oCAIvyAE07/ogpIDbDDRM + E4lMEfF0AYlMEbk82UBlSSib5KaJwcksRIFDe4PiYvORJGmRJJ4eloBVEciKF4lnPpfXfuanf/bQyy+9 + Ys8bsJU9AaL8bCBwGouMUq9AKaCynX0SxN1z3MCpiYnZYqE419TU1Mq2BlcT0zTNc2dOv37i6FGWG0ED + cZ/YQGAORPmvuT36LgAsrxRAEHkH3MQh0yDBwjWwLhxN04xEIpltausMtez+YU4OuUhlUdQMDIynkMgU + kC/qKJR05IoakpkiCiUNAVW0HFFS8392IIlSqYiuZnJdVpB4zpvnNyoi/l7DOzxJPAtF/Rd/4ZePfO+7 + z9tVexIICMyC+KpsLcwsbg6D742ULEgPi727GyCpN9egkNmZ6cToyPDVSCTq9wcCEc5rMKUl+VwudeTg + gR+cO3OGNft1kPJeNhBYAKmgrD5xZBFyFwCWV+x68TAq00VtIBFkR4N4OYDNb/6FoL8m5joPJc3A4EQS + Ja1yBzZNE4WShkS6gGJJR76gYTaZw+RcBsevxFEfkdEdCy2RxLPSGmDFi8SzVCqZv/yLv3Ll2996hk3f + GSB5fvaiTeDmk3jeCCmCnEe6WscO/Lr6BfL5fPHq5cv946NjVwHkOZ4zOY7jDMPQC4VCZm5mZvTi+XMn + Xn355ddmZ2bY2IkB4AVUtkcXsUzt0beyHfhOEw7uybtNKE9F2g4SB7CBQFaDUeHxj326JdrY4SrZK2kG + Bijl5zjAr0gQBR75Ygn5omaVBpfbikFxDQo88Lsfuw9P7FlD+fELBP0Yqi9WCImnm8pL13XzVz/16xNf + //f/sMu0J2CNqwcZ050G8Vdtks8UyEW7Eqo5l0MEkBkBbJt4K4AHQbFGXaMYIPUSrEVgcyMsS3v0XQtg + eYRVfoDkahUA96NMh24CyKiBSPTxj3+6LdrYWVX5FVnApq56bF/ThFWtEbQ2BtHRFEJNUEEinQchf3Er + P6yZAS+dGMb6jlq01AXcqb75mnsM77beKiSe+J3f+t3Jr/zbV+2LUAHZEeMg9Gt2/avfWh/DnaX85KBX + Bn5h/fYBkHMeuIb3BUjM5HlU7vw6llH5gbsAsBzCgZCcNjPrAsgwlDZQ6UFfqFZ44hN/tC7S0O66OGjl + rwureHBLO+oiPnAAdMN0CnIkkUdd2IfZZBkEypYAcat13cD3jw5gU3cdGqO+BfP89jorVUg88ed/9hfF + L/7N300ztQESyG7PNp8IIFV+1Ufi3L6ioRz4ZTktLoFsArVYvDVgWK97HpWdkDY3wuLKChcpdwHg+mQ+ + 5X8ExBwsgFwAgi9YI+3/xGd2hevbXMXetM9fG1axt68VgsATxTdMi3TDdIDANE3UhLwsgTLjsKbp+MGx + QWxd04CakOJ09lUr9zWZmFw1Es9/+of/i2e+9YwQCPjVeDyRNm06I7LLCyC73iTK7sBlkDSZAveMwjtF + CiCWTz0q9WkWJNsxbR0P21KiXW+bnv4CSNzkMiotJR0kdhJf7i9/NwZw7TKf8j8MiikIAO8L1jQ+/vFP + 3xtpaPdQ/hSKmo6akIp9m1vB8xwMw4Rm7fq6bkA3DGg6udlR+0JRx8WhGWTzJVRaAoQ+LByQ8Jmf3IvO + poBnqk839IoqP4EXKtiLAOCrX/l3fO0rX4MJoFQsIpVK5a5cuTpqGMYo3CO7xkH46C7CHaUes9Zu5wxA + NfGB0NsHF3ieAgKIAog/n8P8rlERJGtyQ4hR7loA1yYcSEovxqwLIDyB7fSiL1Qr7f/RP9oXqW+jW4ih + 6QYGJ4nyR4MK9m1ugygQ5dcNw3VzFN8wYOgGdN2EAQMhn4xMroCSZlsCZeUnXP8aXjk5it0bGuFXhQo6 + b1b5CYmnClb+8xv/D//2r1+1BrUSC0GSZWnV6h5+fGx8UNd1+o38IH7qJbiVPYQ71xLQQAKhnPU7q22u + 9sRse/z4fBmROZDa/vkbCa5D7gLA0mU+5X8Q1Lx4APCFauT9H//s4+H6Vtd0Hk03MDCRQrGkIxyQsW9L + GyTRNvsN9+7v7PpE+QkY6I47EFAlZPNFaJo7MGiDQb6g4fUz49i9oRGqzDlugLfyK2Cv3eee+Q6+9Hdf + hmkYEHgBHDhwPI/Vq1ahOdakNjc31fT3D0xYnPQGyIUbACl+GoQbBIK4c0HABDHTp0DiPgFcm5WdBQHP + K7jBo8/uAsDSZQ2oIZCW8CA7v0v51UBUeuITn90frm+rqvwhv4wHtrRBlnjLz6eU31J6zSgDgcaAga4b + MEwTPllEvlAioEApP/m/iUyuhMPnJrFnYwMksXJGXTUSzxd+8CL+z1//jWuEOc8L6OrqQnNzE2RZhqIo + vubmpmh//8C4ruszKJelRkEKogbwxgEBgFgD0yCuUAlEz2TMDwYlkLTpFet2w3Z9Wu4CwNKkmvI/CIoe + GgDUQETa/4nPPh5paHeV+Gm65fOXdAR9Eh7c2g5ZEiyz33QU22CVn3YJLBdAo+8bBhRJRKGogWzEZeW3 + wSCVLeL4pWncs7EBcrkNoSqV14HXD+DP/+wvYRgGOIqXoKW1FW3trWTN6nlXVdXX27cpfO7c+cua5qpg + iqA6CKhYedRfyyk6iO8+jvKgmri1Frd++5h1bK6CWA43dfbBXQBYvKwGMwgCVZRf8YelJ370j6oqf6Gk + I6BKeHBrGxRZtJTdtHLytJIzlgB9n+rVt2+GQdKEhaIG0zArLAEASKSLONM/h3t7GyGJfFXlP3b0GD73 + v/4UuqYTkx8coatqaUGsJUYm1QgiOI4j1NWdnaitrQmsWtXTfPrUmYGSe0pNBCQd5uUO3OkgYIsJ4vtn + QFJ5SZQ7Rq930O01y10AWJxUU/4HQI0NB4jy7//EZx+LNnbQRUEu5fcpIh7c2g6fUlZ+105P7e6GwZj+ + LBgwj+ULGgEADzfAvj+bzOPCUAL39jYj4PNXKP+Z02fxx3/0vwijLcc5t6bmJrS1t5Hnm9a4KklCLBZD + KBSEqqhQVTWwetWq5lOnTi8FBHx4Y4DAipO7ALCwrII7pQdUVf6QtP8Tn3002tjpSg26lF8W8eDWNvhV + yVJa00nrERfAdPn8NigYRtnn12hLgbIG8oUS0rnCvMpv+/IziRzyJQ5b1zaA58sAcPHiJfzRp/8YhQKh + GbdvjY0N6OzsBMeXrQEAqK+vQ11tLXiOWBOqqkJRlcDqNauaz549218oFFl3wAsEArgLArdE7gLA/FJN + +feBmRKr+EPS/o9/5tFoU1el8k8S5VdkAQ9uaUfALzlFPmVFtwKALuWvDgasJVAoakhnC84YsfmUH6aJ + 2pAPms5hai6HTT214DkOA/0D+PQffhbZbM6189fV16O7u5soOawhJRyHhoYGhMMhUqEoSw44qKoKn08N + 3HvvPc0HDx7yAoE6VMYE7oLALZC7AFBdesDk80E2w33WY47IvqC4/+OffbSmucuVGtQNE0OTKRSKOhRJ + wANb2hAMyDB00+3nG4bH/UrlrwADnVgOxZKGVMaaJbgI5QdM1EcDkCUBk7M5xFN5ROQ8Pv0Hn0EqlSrr + PoDa2hqsXr0KPM9buz55oL6+HtFo1Bl0qusGJEkmIGBZAo2NjYG+vt7mQwcPDRQKBdodCOMuCKwIuQsA + 3lJN+feCWAWOyGpQ3P+Jzzxa09xdofyDE0nkizokkccDW9sRqab8TCCPVm6nEMig1qjXljQdqUxhScpv + miZqwj5IggDAxNhMBi98/wXMjV0uB/zAIRKJYO3aNY7y28BQW1uL2to6ovwc5wz/1HUdsiSD43jwHIem + xib4fL5Ab++m5gMHPEGgHt4g4Ic1v/6u3Fi5CwCVsmjllxS/sP8Tn3m0NtbjSg0S5U+VlX9LG6JBpezv + 26Y/nerzsAIM63lsUZAd9CuVNCTTeejO7PFK5S/rlruFWJVF+BTJWRcDDcjNDsLQcrA9/1A4jLq6essa + IP+rqYmivr7esQbsVKA941w3dMiSBJ7nEY6E4fP5oPrUQF/fpuaDBw9XA4FBuCvi7oLATZK7AOCWbjDF + PCDacD9IJsARSfGLRPlXVVF+DaLAY9+WVtSEVErpreYew9us14xKq4BO/dmPa5qOZKZAKT88ld/p1TFp + SwAoWb0HzihCcOAEEfnZfmenLxWLaGltsXZ/covFYhAE3rXmAgIQS0BVVIQjhC9DVX1QVTXQt7k3dvDA + of55LAEWBAK4CwI3VO4CQFmWoPw+Yf/HP/NIbctqV2qQVf69fa2oC6vlgJ/B5PoX8PE1Q3elAp11TUcy + k4emW6W/AIjq07u+W/lZS0DXSSlw0K84wCEoQaRHTzk/3TBMNDTUQ5YkYupzHILBAGRZtu6jnBGwxpw5 + U4x5HpFIxLlPQEDx923ujR0+dHggn8/TIBCCNwj4QUBgBm434a4sk9wFACJdYIp5QJT/PpDqP0ckxS88 + /rFPP1zXusaVHbADfvmiBoHncH9fKxqifhiG6ZjytvIbVPTfMBYHBmVXQEcqSzf/ANU6Aee/T3oE6iMB + 8ktNExzPIz/bD1PLO1ZATU0NVJ/P2e39/gBUVXWZ/pzLAiD/Vn0qeJ6HLEmeIHDIGwQacBcEbqrcBYDq + yn8vSLuvI6KsCvs/Xl35cwUNPM/hvt4WNNUGmDy/gXJ/P3WfzQQYHpYA1fyTyhZQLGm4XuUHSF1/KKBA + FHjn8fzcEPRC2kkBRqNRBAMBxwLw+33w+X3Ozk8HAp374BCJhIkboZWswGAZBBRFJZbA4aMDzMTguyBw + k+WNDgCdYIp5QJT/HhCKL0dEWRUe/9gfPlTfttYVIHQpP8fh3t4YYnVBSuHdDTy6rcx0gK9Keo99PJ0r + oFC0Wsc9lR+LVn77fjigQpZ45/X5uWHoubhTAFQTrUEoFHJ2eL8/AL/fX7Hj0/EAWZEJaICATCUIqFAV + 1d/b19ty+PARLxBoBNCPShAIokyucVeWQd7IALB45ZcU/vGPffrh+vZ1LuU3KOXnOA73bIyhpT5I7fxm + RSBPc+r+qwf87LFd5cd1ZHJF5ApWybgnKSgWYQlUpgPrIgHLAiDL+alL0ItlC6C+oYFMMbYKA4LBIPw+ + XzkGwJWrAu1/RyMR18AL0zTJIFSrTgCwQIC4Ay1HKkEgCAICXpbAXRBYRnmjAkAHmEo+EOXfA2A9vShK + Cv/Yx/7woYb29a4AoVv5gd0bYmhvDFn+PRPwq7AAPHz+qrX+OrL5IrJ5a/bDPIzAS1V+nuPQXEd2d/v5 + 2fEzMLVyGXBzrBl+x+QHIuEwVJ/K+P/lQKDf54M/4HdqA2wxQUBAkiXwHAEcGwQ29/W1Hj58pN8DBJrg + DQIh3AWBZZE3IgB4KT9AlH8DvSCIMv/4x/7woYaODZ7Kn7WUf+e6ZnQ2hZk8f5Vof4WCm8xzdJfy5wol + ZHLz7fzXpvwAUBfxI+hXnOcbehGZkaPktZZCd3Z0QhIlR8lramugKKS1nQ0EiqJAqgOdseYMCJgmtJIG + yaoTAGD1Dqi+zZt7W48cOTqQzeZoeqxqIODDXRBYFnmjAUA7mDJelHd+t/JLCv/YR//gwcbOja4AoWGY + GJoiyg8AO9Y1oTsWoYJ9bjovzWvXp+v5DbfC0z5/vqghky2iUpmvX/mDPhktDWHr55PHCnNDKMSHnAyA + LEvo6u4q5/zBobGxEYIgOClAxxXgedREo+5Zd9ZzTJgOGJimCU2zQMD6IFVVoSiqr29znwUCWRYEmlEZ + E7gLAssgbyQA8FJ+ANgNQuboiCDK/GMf/e8PNHZu6qLXDdNSfmtG37Y1jVjVGnXt/JphVJr+bEsv6/M7 + pJ/ljEGhVEIq6+7sWy7l9ykiOptrLN/dfsxAauA1mKW8U/XX0FCP+voGiweQgyRLaGioB6iIvw0OkUgE + skKIRF37/hJAQFUV3+bNva1Hjx4bzGZcIBAAAYEBuCmy7oLAdcobBQDawJTxWrILwCZ6QRBl/tGP/P6+ + pq5el5tgmCaGJtOO8m9Z3YA17TVMkY+t/Fa6zyMI6OnzO5YBAY5iUUMy4+7so6v4Fhf991Z+RRLQGau1 + TPBygVB2/AyKcwOuLsBVq1ZBVX2OskfCEVdGAODAcxxC4RBUlSIS5bgKECj/szoIKAoBgb6+vtZjR48N + ZipBwHYHWBAIg7Dp3AWBJcobAQCqKf9OAL30Ai9I/GMf+f19Td19Fco/PJm26LeBvp56rO+opQJ+7hZe + r4CfV1svneqze/xLJQ3JTL6K8i8l+o+K14sCh65YLUSrCciW/Gw/siNHwVm7NAcS7Ovu6gLHw8ntNzU1 + QVFkKv3HIRQKwu/3Vx7dZQCB48eOD2YymcVaAmHctQSWLHc6ALSCKeO1xFP5H/3w7+1t7tnschNs5c9Y + yr+pqw4bu+qcXd9gfPvKgJ/ppP3cqUC9wg2w6/uNRSv/4i0BgQO6YrWQJXq0t4licgzp/lfBOYE/4s/3 + btoERVEcd0BRFDQ1N1E9AFZK0O+Hrd0Vs2/t9KBzn3kYnFMnIElyJQhs7m07duz4wBJA4K47sES5kwGg + mvLvANBHL/C8wD36kd/b19yzxaX8JqP86ztr0dfT4Db5mc4+byDQPVN/5ZJfHSWd1PfTnX1LV37WEiDr + HICOWA18ij2hijxezMwgcen74DjTqfTjwGH1mlWob6h3Nfw0NzXB5/M55n8oFGJ2fhJPqJiAbcUZHHtg + CSCgKKrat7mv7fjx4wPp9F1L4EbInQoALWBq+C3ZDmAzvcALIvfIh39vb2zVVpebYJomhqbKyr+2vQZb + VjW6i3ycsV1VOvkM2gqo7PnXqOBgMl2Aprvbeq0vgutTfhNtTVEEffakH/K4lk8ifuG7MPSCNVVYIEDR + 0Y6uri6L2IO8g9/vQ3MsBt4i+wiFw8TnZ838xYKA/VTnn9VAQIGqKGrf5r7248c8QSAGkh2gQUDFXRBY + tNyJALB45ecF7pEf+W/3x1Zvc1kKjvJb+ffVrVFsW9NUpu52ynirFPpUNPO4awI0XXcRfDidfQsSegBL + UX6YJmL1YUSCPpTfwIRWzJrxC9/hjFKW/tFoaW3FurVrHUuAAwdB4NHR0Wnl7jmEw2GoCjU2jDXzneVr + BIFSCZLMgIBKQODE8ZOD6XSaZtD1g4AAawncBYFFyp0GADEwDTyWbAOwhV7gBZF7+EP/9f6WNdsrlH+Y + Uv6elgh2rGuGYZoukg5d15303YJVfh5rhqP8VmffEth8Fqv8DTUB1EXtUXXk8VIxb7z87382Kug5QfWp + ztTaaE0U69evs1p9y+m91tY2BINB8FZ7LxkewhzdeUDAhHdakL5f/uf8ILB5c2/b8RMnB9OpChBogTcI + RHA3OzCv3EkAEAPZ+dnrcKt1c4TjBe6RD/3ufS1rdrgsBVv505bydzWHsWt9MwwTruYeh8G36tAONuBH + p//Kkf90toBCSbsG5S9/32rR/5qwD011YXsBgAldL5mvf/ML41ND53MzM7PZmpqoT5ZlMRQKYuNGuxSC + syr/gObmZtTW1ULgeUSjEUiS5DynAgQAD5egyroXCJjldRoEbCBSFAWKQkDg5MlTQ6lU6i4ILIPcKQDQ + DLLzs9ffFpDd3xGeF7iHf/h37m1du9NlKRDlzzjK39EUxp6NlvJTbb2aZsDdyeeR62dKeyvcAsNAJldA + vnityj9/9D8UUNDaGLV/GQAThmGYR7/7TxMjF45krN9rzszMZtrb2wJbt24VRJFkB3RdB8/zaGpqQlNT + I0RBRCQahSCIjNJfPwhY78I8zw0CcgUIqOrmvt72kydPDnqAQCu8YwJ3QaCK3AkAsGjl5ziee+iHf+fe + tnW7GeUHRqYzSOdIw01bQwj3boqVlV83K6P9NLefbrqq/LSqAT/dUn6rs2+JPH6O8sP9PPq+X5XQUVHl + Z+L8gW+fu3Tku7MgCgEAMAyjlM1kL/f2bmqUpHJ+0O/3o729HT6fDxGms4/z0OLFugTV0oJeIGD/fNJF + KLlAQFUUpW9zb/upk6cGk0kXCPhAQGAA7pHbNghMY/5pvG84ud0BoAmkdZe91jaDBP0c4Tiee+iDv31P + 2/o9rlZfovxppLJE+Vvqg7ivrwWE4NKkGH10pmyXMfO9Cn2McvDPHuqRyxeRyRfnVf5KHj9G+au8VpHE + iio/Eyb6T7185cQLX7kMMoZKARlUaQAYzWaz2dHRsdkNG9bHBEHgA4EAWltbUCoVUVdXR2IC5AhSx9J1 + ZD3W4JCELrY2YCkgIJOYgNLX19dRBQRsd4AFgSjuWgIuuZ0BoJry94Hk+h3hOA4PfuC372nfcI+r1ZdV + /ubaAPb2EZo/p8hHN12TeGwz3tDnMfOZKj/7OWRyT9Ex2xen/FiU8ksCj84WusqPPH/00onhQ8/83Rnq + Z2dAlGQKQB4AkolkYW4unti8uS/W0dHO2Z166XQaoVDY3eDjqfDXCQLWHU/nwTJkSqUSJBsEAAcENm/u + 6zh16vRQMpksUq+qZgkoICBw1xKw5HYFgGrK3wtS5ecIx/HcA+//rT0dG+91dfuxyt9U48e+LW3gOLg6 + +2i/XZs34GdWRv9p5bcm99Dm/VJIPGl/n1V+gefQ2VIHWRRBK//cWP/wK//x56+bhiFRP90A8DqIFeBk + Aaanp1P+gH+qt3dTO2fl8EzTRDqdRjgccdp3raNKHV/32k0BAZ53QEBRVKVvc1/7qdOnh5KJuyCwVLkd + AaARhLRjEcrP4YH3/+aejo33VSj/KKX8DVEfHtjaTpRfp3L9lN/OdvLRYGCw5B9MbUChpFGdfUBlEG/x + PH4w3ZYAzwGdsVqocpnj34SJ1MzE5Atf/dx39VIhb51nGwTOgvDwT4FkTkQQRZi9dPHSTDAY0Fat6nHY + jg3DQCaTQTgcJTMEnbze/CDgTv8tIVZwTSCgKH19ve1nzpwZSiQSXiAwiLsg4Cm3GwBUU/5NIJ19jnAc + z+1776/v7tx0v6vV1zSB0Zk0kpby10d8eHBrG3ieYxTfzvVXlvp6gkGVLEBR05DKFGCaxrIrPwegvSmK + gE8Brfy5VDzxwlf+17OFrOMbF0AAYABkDj1ARlLPgARRE7AU5NTJ01MtLTGptbXVGW2u6zry+RzC4Qih + 9JoXBMh6JQiU1ytkCRkCJ0XoBQKbezvOnPYEgTZ4W49YpToAADkNSURBVAI1IED4hgWB2wkAqin/RhDl + d12ND7z313Z19u5ztfo6yp8h10dtWMVD29oh8Dzx+XWT4uDXQY/prpbvdxh7PVJ/dmcfae4BFkrfLaT8 + LvfABFoawggHfaCVv5jLZF7+2p8+k45P5pjjdArAZZQtAYDEAE6DgIBj4x8+fGRs3fp1kfr6+hp7rVQq + oVgsIhQKw0kwzGv+XycIWG/rZQ049GIMCKiqIvf19XacPXNuKB6P0yCg4i4IeMrtAgANIIw97NWwAYTN + p3wpchz2vedXd3b1PeDq9jMBjFHKXxNS8PC2DogCb0XpGWou13BO02n91aqY+TRvv66TmX3JTAGGwSrz + QoU8i6sFaKwNojYSAK38WrFQfO0//+rZ2fH+JHOchgC8CLLTR0DMfhPENB4FkAahSnN8/0OHDg9v2bql + MRIJh+w3KRYLMAwDgQCpLnQbAdWDgxZDWMX6UlwCmlAE1i8uFRkQkGSoqir3be7tPHPWEwTacRcEXHI7 + AMB8yr+bXd/7nl/d2b35wV72TcamM0hYyh8JKHh4ezskQXBz9xumVejj0c9Plf/aLcBebb12tZ93Z99S + YgDVlb824kdjbQi08huaph169u+/M371FDtKaxLA90CKYwwAKRD/dxzArPWcOetxZ8yZpmnmkcNHhnbt + 2tXq9/vtZgLk8znwPO90Aq4MEBBdIKCoqtzXt6nz7Lnzw/G5eIF6JxsEBkFcIFtsEHjDxQRWOgDUg5j4 + 7GWyHoS+22X27333p3Z0b3nI1eprwlZ+ch2E/TIe2dEBWRTcxTx2II8d2Ok1uMOp59ed/L5G8fslM+7O + vuWi8oIJhIMqWhoicBUCGaZ54gdf+cHgmVdHmeMUB/As3Be7DuCc9ZcO7U+CZAUa7IVCoaCfPHVqaM+e + XZ2K4vQSI5vNQJFlKBYLkBcIWKeEEs4DBMj6UuIC1iuo8+sFApIFAr0d586dG56rBIE23AUBACsbAOpB + dnmeWV8HVvnB4f53/dL2nq2PbGbfZGymrPxBn4xHd3RAkemdv5LC23NgZ5WAH5v3T2Xyruae5VN+EwGf + jPamqKUwdgzBwPmDz7x24dCzV5ifngHwDAA2FjAGkglIgyg7rWejIC6C4/unU+nSpUuXR3bv3tUj2vXC + ANKZNHw+n1Mo5IQFFggOetMCLBMIiAQEAAICljvQcf7c+eG5uTkvS2AAbhCQ8QYDgZUKAHUgOz+r/GtB + Rna5rrD73vmL21dte9Rb+dPkvAd8Eh7d3gFVER2fnp3Z56T16Iq/eXj82HhAKlNA8QYpv6qI6GyuBbm+ + beU30X/qlaMnfvCV08xPL4Aof4pZnwHZ/QECDAUQoKVlGCTg6vj+szOzhfGJ8cnt27d181RBQDqdQjAY + hCiSuOItB4FSCaIoOjULNgj09m3qPH/+wvDcrAsEFHi7A28oEFiJALB45Qdw3w/94rZV2x/bwr7J2EwG + cUv5/aqIR3d0wq+Ibu5+Ks9fjcLb8fmrMPraAJLOFl2dfctF4gnThCzx6IzVQRBsFSPKP3blxPmD3/q7 + Q8xP1wB8F0TZaUmARPzpizpjvWENtWaCBA1bQVJoAIDR0bFMJpuNb97c10UXCqVSXtWCNAiQPEBlXMC8 + dkIRD1Yh6yhXAwGpt3dT58ULF4dnZ2fvggAlKw0AakFy+qzyrwGZ1OvC/3vf8fNbV+94fCv7JrTy+xQR + j+7oQECVGOV35/erTuaxgEEz9IpAn/14OldEvljCYgJ4ZNnLEoDn60WBQ2esDpJYPiSmaWJm9PLAK//x + ly+bpkHXtRsAvg9iytOSAXAS7ui3LQmQ1GCYWtNBQKATVLXg1StXE5Io5teuK89HNE0D6XQakYpqQe+0 + YIUsI6uQfWy8QcAn9fZt6rzgDQId8AaBWtzh2YGVBABLUH7g3nf83NbVO57Yyr7J+GxZ+VVZwKM7OhH0 + SZTSl31+ze7kY+b4aR47vuMWMG5ANldEtrBY5V+aJcDzQEeszqryK78+OTM6/uJX/+R5XSvSF6YJ4DWU + C31sKQA4DqCI6jKH8gReW0ogQNINkjYEAJw5c3amvqGe6+joaLbXDENHNptBJBIBx/EVb76ocmFUBgiv + DwSKEMXyBCLJtgT6NnVevHhpZGZmNk+9sw0CQ8xxskFgGu4W4ztGVgoAVFP+1QDuB3Nt3PO2T25Zs/PJ + beybjM9mMJciyq9IAh7d0YFwQHb8fYMd26UzPr+H8ju5fY+AXy5fcnX2LReJJ0wTHAe0N9Ug4JNR7hUw + kU3OzL3wlc89V8xn2N38KIAzzJoG4AQqA4FeMgMSAKQI/pEH2QG76XNz9Oix8VU93YGmpqY654M0Dfl8 + nlQLVlYKXRcIeNQcLQIEgGKpCMkLBHptEJhhQaAdbzAQWAkAUANSx88q/yoAe8FcE3ue/pnNa3e/eTv7 + JuOzWUf5ZVHAIzs6EAnKVG2/Tc7pPbPPJvcw2Oh/lUGepLOv4KrMA7Asyg+YaG2MIhxQQSt/IZdKv/TV + P3kmm3RduAAJ7B1m1gwQs58NBFYTEwQE6kCZ/SDuQxxkkrJzLg4dOjzS17uprqamxnEdSqUStFIJoXAI + LpofS66VUGTR1GIms14FBHw+AgKXLl8emZl+Y4PArQaAasrfA2AfmHO++6mf7lu35y072Dchyk/OoyTy + eGR7B2pCqru23zAr/PrK8t55UoFUwK9gd/bdABJPwERTXRg1YT9o5S8Vc/lX/uMvn0lMDaeZn98P4GVm + zQSxBuaWeD4MEBBoAGX2g8QJCiD5c/JEwzAPHTo0uGPHjlgwGHRch0KBVD9SS1gOEPBcn6dxaD4QEEUJ + qk+Vens3dl2+dHlkuhIE7JgACwJ1uMNA4FYCQA2I2c9+hx6Qnd8FCruf+qm+dXveWqH8E5TyiwKPh7e3 + ozbsYwZ12gG/cqFPtYCfDRhlt4Aa3mno5c6+a+XxA6v8cD2/LhJAQw1V5WeaMPSSdvBbf/vc1NC5Webn + j4EE/dgg1UWQwp5rER0EOBqZczANosmO718qlYzjx48P7d69q12lZoPlcjkIggifz0e9fJ60IBbvEiyl + cchZN4FisQhJEsHz5HITRQmq6hM39W7svHLl6uj01DQNAjK8YwIS7jAQuFUAEAXZ+dnP7wbZ+V3Kv+st + P9G7/p6ndrJvMjGXxSyl/A9tbUNDxA/DbtGtmNlXrX7fcABD8xrsad1KJVLfbxoGlq78VCdflTqASNCH + GFXlZ5omTEM3jj3/L88Pnz80zvz8WQDfQWVkvx8kl389UgJxHRrh1sFxkECh4/tns1nt3LnzI7v37OqW + yqyhyGTSUBSVYRG+BhAwr59VyF4vFksQJRGCAwIiyQ70buy6cuXqyNQbEARuBQBEsQTl3/mWH9+04d6n + d7F7wcRcFrNJcr4EnsODW9vRWOOndny2s8/DnzfmswTcvP8lTUcik4exLMpfGf0P+hS0UVV+1uvNs69+ + 85VLR7/XzxyrFEiJLxsLGAXAVgReq+RBgodkHHBZRkAUwPH94/FEcWhoeHzHzu09AlUQkE6n4Pf7IUny + IhT+OkHAurOQS1AqkhShwJOhhwQEVHFT78auq1f7R6empuiAqQySCh0GcYFssUFgBrc5CNxsAIiAUHax + n9sF4AGwyv+mH9244b6372aVf5JR/n2b29BcF3CX9hpGeTrvPJN6DVcQUK8EA92a2ZfOw9C9lZ+KAGJe + 5beLeEC/zoSqSOigqvzsxy8ff+HI6Ze/fo45VnkQ5WdjAVMALizz+cqCWBi11JrdRdgCkjoEAExMTObm + 4vGZrVu3dHNU/i6VSiEUCnmyCjv/WkyGYDlBoFQJAj5VFTdu2th5tb9/dGqyAgQ6UB0EbmtL4GYCQDXl + 7wTwIBjl3/GmT2zceN87drHJ4Mm5LGYs5ec5Dns3t6KlIegu8rEj/5peEcF3t/lSqUCDAQOH08/q7NN1 + VFP+ayXxJFV+gqvKz358+OLRM0ee/YejzLEqAXgOlcG9OEjQz8TyS8o6NxFqzQABgQ6QoBkAYHBwKGUY + RnrDhvUdblqxlEUrJjBcAvODAJNDYJ7nfuGygIBPFTdu3NjZPzAwNjk5+YYAgZsFANWUvwPAQ2CUf/sT + H9uwae8791QofzznKD/Hcbi/rwXtjaFyTT+9+3t19tFWQMXY7krf3+ns06xzuyjlx6KVXxR4dLXUW1V+ + 5edPDV+88to3Pv8qo88GgOcBTDDHMA2S7ruRF2AcpCw4SK1pIArRDYpk5MKFi3PhcMjo6el2WosJrVga + kUgUHMcvAgTI+o1iFbKlGghs2rSha6DfEwQ6QWICdwwI3AwACIPQdC9W+ddv2vfOPezlMBXPYSZBzgfH + AfdtakFnU9i94y8Q8GPpvOjUng0GdI9/KptHSbNjbMtH4kmq/AiRpyIJoJU/Pjk8+tJX//f3DUOjtd8E + SfUNMMcwD1LlV8KNlxmQBiE6tF8ECQz20Of3xPGTk23tbUpLS4vTWqzrOnK5LCKRCBwl9qjwuSmsQi4Q + IBWDbExg46YNXYMDg2MTEy4QkDB/TOC2A4EbDQBhkJ1fZNbbATwMRvm3Pf6Rdb0PvOseL+WfppR/z8YY + umMR145vOEU81ZXfxdXPtvVSPf5E+QsolrQqufxr5/Gzq/w6mmvhVwmRp00WmolPz7zwlf/1Ha2YYy+i + QwDOM2slkCo/NhB4I2UGJH1LTQdFDiQj0Q1KtQ4fPjK6fv26aH19XdRe0zQNhUIB4XDYeaoXl8CNIhSp + EOvDvUHAJ27atKFrcHBofGJigpqiuiAIzMC752JFyo0EgPmU/yH2s7c+/uF1vQ+85x6Om0f5Aeza0IxV + rTVMQ49ZVmKv6j3XfZPJAOgVbb0Zp7kHWG7lB4C2xihCAULkaSt/PpNIvvi1P3k2n3aRVwCEy+84s6aD + KH/mBp4/L7GrBevh5hZMWd+lHTSt2MHDQ1u3bW0Kh8OO61AsFqHrGkKhcu/RzQQBllXIEwQAKjC4oXNo + aHh8fNwTBEbgBmDJOja3DQjcKAAIgZj9rPK3gez8rs/d8tiH1vY9+N57WeWfTpSVHwB2rmvCmvZaq1ff + q7OPGcbBDuek23/p5h7KFcjk7bFdwOKad9j77nQgq/zN9WFEQ4TI01b+UiGbe/nrf/5MamaMVejLIBz+ + tBggAb/EDTp3C4kOsuM3Mudx1vpublqxo0cHd+3c2eamFSM6EwiUqwUXBgFrvQIEyPr1cAlYtUIVICBY + ILBh4/quoeGRsfHx8cWAgIjbCARuBAAsTfkf/eG1fQ+931P5p+Jl5d++thHrO+vcyu/q7NOr7PiMmc8U + AdH1/tlCCdk829lHVfFdB48fANRHg6iPEiJPW/l1rVh8/f/7wnMzI5fizPEaAfADVEb2z4P4mrdSNJDA + IFstOAniHji+fz6f10+dPj28Z8/uLrk8ZwzZbNYKupVDCk5YYIHg4I0gFLFBoFgqWq3EAjg4ICBs2Li+ + a2RkdHxs7M4CgeUGgGrK3wrgEfbzNj/8gTWbH/7AfQsp/5bVDdjUVe/a8d0z+3S4sgBsDKDa2G6jzOnn + Htu1vCSegIloyIfm+jBo5TcNXT/ynX/63uilY2zZ7jQIqQcbC7iCyl7/WyVFkAwEWy04ClLsFbUXUqlU + 6cqVq6O7du/sdtGKpdNQVRWKUg4p3GoQAICiwyfgAQLDI3cUCCwnAARBlF9i1ltAlN8FCn0Pv3/1lkd+ + +H5W+WcSeZfy9/XUo6+nwb3jO2W79k7OKL6H8rvaehnTv1AsuZp7lpPEEzAR9CtobYqCKzcEwDQN89TL + //Hi1RMvDjHHKwlC58X27w+DlPmuJKlGKzYEMr7N8f2np2fyExMTUzt2bO+hacVSqRQCgQAkSa5481vB + KmT/KZVKEAURvFAGAdUCgdGR0YmxMZe7ZoPAKLxBYBYrFASWCwDmU/5HwSh/74PvW7X10Q/trVD+ZB6T + 8TK4buqqw5bVjRUVfuUmH2Ygh4eZ74r+G25/3zW26wbw+AEmfIqEjlgNeLs5zVq/eOR7B8699s2LzPHK + Afg2SAUeLRMgDT4rUdLkgFTQig2CuH1lWrGR0Uwul0v09fV20ec+nSbVgqIooGJPn7d78DpBwH5q+d1d + T7fLhlkQ2LhxQ9fo6NjE6GgFCHThNrMElgMAqil/DJ7K/95VWx/70F6O4yuVf6583W/orMW2tU1WUw+9 + +1OFPhXNPNXBwF3lR25Fa3IPYdVaXh4/wIQsiehqqYPA28tkffDcwZPHvvfPJ5jjVQQp8WWDe7Mg/f43 + ospvuSQBUigTotZ0EKulCxS/wJXLVxKyLBfWrl3jtBaXh5CGIQg8PMN8iykXdr1yGUCAc4MAYDcQqcL6 + Deu7xsfGJ0dHR2kQEK3fOwo3CcuKBYHrBYAAgC1YpPJveuDdPdse/5F9rPLPMsq/tr0GO9c1l5Xf8fs9 + mnu8Cns8fH8bDAzLGihpOpLZgofys5aArfysJTC/8pMqv1qIAud6/UT/mYsHvvk3Bxh91kGGd0wxxzEF + kga8HTjp5kCuBz+1VgJpWe6mr4Uzp89MNzY28u0d7U32mj2ENBKJkCGk8xKKLK2FuJJV6NpAQGBAYMOG + dV3j4xOTIyMVIGC7AyseBK4HAKopfzOI8rvWN+17V8+2xz+yl2OYI2eTeUxQyr+6LYrdG2Kudl57Zp9G + c/kZ1Xd+1wiviroAnTT3ZMrNPctJ4gmQKr+uljrIkuh6/dz4wNBL//5nL5qGzlb5vYDKFt4cSK5/xVws + i5AZkOCfF61YD1hasVWrgo1NjU6jEakWzCEcjlb4/7bcdFYha70aCKzfsK5rYmJyamRkhG7OskFgDN4g + MIubU725oFwrAARAzH42cuOp/Bv3/lD39ic+um8h5e9pieCejS0wTDeTj/NX06pX+M2z7m7rJfX9+qKU + f+luAMcBnbE6+BTJ9frU7MTki1/93Pe0UoGN7L8O4BKzVgQp/mGLgla62IVCtaikFUuCKIVTKHTw4KHh + zZv76qPRqItWrFgsWtyC9FtfPwhca+MQ/d08QWD9us6JyYmpkeEKEOjCCgeBawGAasrfBOAxMMq/4f53 + dO144uMPVCh/yq38Xc1h3NfbSpS/gsnHJuowKxl7Fwj40cqv6TpS2bzV3LO8JJ62udDeXIOgReRpPz+X + jide+Mrn6HHdtpwAaeShxSbyZAOBt4sYIBc3SysWBwE2N63Y4cNDO3bsaAkGA47rUCwWoOs6gsHQ8oOA + 1/pSQUAQXCDgU1Vh3fp1nVNTk1PDtxkILBUA/CBmP6v8jQAeB6P86+99W+fOJz/xIKv8c6k8JmbL13dH + Ywh7N7fBrNj5mbFdruIfN4OvZ/TfFfzTkcoUUCqV23oBLJvym6aJloYoIkHV9fpiPpN9+Wt/5jWu+wKA + g8yaAeLzs9N9bzepVig0DXLNOb5/sVg0jh87Mbhnz65OVVWdgoB8PgeO4+D3k2rBG8EqtJTuQXq9VCq6 + QEAgXYTCuvXruqYmpyaHh4cXCwINuMUgsBQA8AHYiqUo/5s+8SDHC4zyFzBOKX9bQxD7tpBNoczkU2Vs + l0vJzSrruqclkLabezxac6+XxNM0TTTWhlBnV/lZ61qpWHz1P//6mbnq47rZWMA5lCf23u5SRHVasSAo + kpFsNqudP39hZM+eXV00rVg2m7GovEkmcaWwCgEEBAQaBAQRqurj161f2zU9PT01NFQBAt0gIEBbdgJu + MQgsFgBkkJ1fZdYbAOwHo/zr7nmqY9ebf/Qhb+UvB0xb6oN4cCul/DR3P9WWS+/0zsw+3YO9x6D4+6no + fzpXQKG4kPJXCQCCVX5UPL82EkBTXcj1ekPXtEPPfvk7E5XjuidAIv5sZP8yiHLcSZK3biyt2LC1VqYV + m4sXhoeGJ3bu3NFN04plnCGkxDhYKaxCgAcI8DxUn49fv35t1/T0zPTQ0BBNyS6gbAl4gcAcbgEILAYA + eJCuviCz3gCy87ssgnV73tqx8y0//iDPu4fFxdNu5W+uDeChbe3gAFR29pnQNEb5Gbpuo2rAz6Ozr1DC + 0pV/YRJP0yREni2NYRJALq+bJ37wtWrjup/zONGD1u1OlAxImpOlFRtCBa3YRDaZSMxu2bK5my0UItWC + 1hBSV3JgfhBgcgjM89wvXDYQUH38unVrO2dmZ6cHBz1BYByVIFCPWwACiwGAbhAzjpY6kJ3fpfxrd7+5 + fddbf+IhL+Ufmykrf2ONH4/s6ADPcRXc/bTPXzGlxzPgZ4MB2+evk+aeXBHXr/ze0f+AT0F7M0lZmeVA + oHn+4LOvXTj0zFLGdV++mSf9FkgS5FqLUGsGyvMHHd9/YGAwZQKZ9evXtbuHkKasQiESV1wJrEIO23AV + S2DdujWds7NzM4ODgysWBBYCgDDIVF76CIQAPAHGHViz603tu9/6kw/xgjiv8jdEfXh0RwcEnmcaeGjl + 16HPG+3XXSSf7K6v6zpyhRIyuQK8lJ+KAGJe5beeV8kERIg8O2M14HmOehzoP/XK8Wsc132nSxzkmmFp + xUZAFMJxI8+fvzAbjUTM7u6umL1mcwuSQiFyia0EViE3CPAOQNmWwNp1azrn5uIzAwOeIDABN6fDTQeB + hQBgI9yKLgJ4Eu6ST6ze+WTbnqd+6mFW+ROM8teFVTy2oxOCwDs7vj2zj+7sc9h5WKJOh8ePme9HjfjW + DQP5olbu7PNQ/ush8TQtIk9S5cdTjwNjV06eP/jt6xrXfafLLMimQtOKFUAUwVUodOLEyYmOjnY1Fos5 + jUaGYSCbzVgEo+SplcmBKsHB6+kedN5ifpegWCp5gsC6tWu65uJzSwEBOyYw30DXZZH5AKAOhOGFll3s + Ws+2x1ruedvPPFKh/Bm38teEVDy+qxOiwFc29zhju/TypF6G0NPwSPG5B3Z6dPYtSvmxJOUnJb51kETB + pfwzo1cGXvn6X7xkmi59NuE9rjuL6uO672SpViiUBQGHLlA6eujQ4ZGNGzfU1NXVRu01MoQ0Z00iZrz7 + hUDA+lPZOHT9rEKcVUboDQIqv3btmq5EIj7b3z9AZ4RsEJjELQKB+QBgLdy7fx2YMd0ta3bU7X33px4X + RMlV85/IFDA6Xf490aCC/bu6IIk8Kjv6qHSfq6XXg76bifaz6xWdfRWmOwDGvKcfn4/E0wQcIk9VFl3K + n5wZG3/xK597XtdL7LjuV3Ft47rvZKk2fzAJogQd9oJNK7Zt29bmcDjkuA6kWrCEUCi8RBCw1itAgKxf + L5eAAwLFEniehygIAMc5ILBm7ZrORDyxokCgGgCoIKO5abkfVBBHDdbIj33k95+Q1QBtziGRKWKMUv5I + QMH+XZ1QZKFKkU85paexSs5G/xkSDzrvX9R0pCo6++aL4LP3y0FBL+XnAHQ01yDgk2ATegBANjk7e4PG + dd/JQs8f9KIVc3x/TdPMo0eODu3evavd5/M5GxIZQmogGAyisgfw1hKKcCAgxQuCBwis7kwlk3NXr/Yv + BQRuWJ1ANQBohjttEwJwD/2Eve/5lV11Latb6bVktoix6bSzt4b8Mvbv7oIqC7BHdRlWc09F4Y7t8zuc + /KbbzK9C7a0bZGxXKpOHcYOUH6aJtqYowgGFUn4ThVx6KeO6dZAqv8WO677TpQQSB2GrBSdANiDH98/n + 8/rp02eHdu/Z5aIVy+Vy4Hkefr8ftwMI8DwPn2UJJFOpaiAwBffUJwFlyvFldxmrAUA73G2d60CRPdbE + VgV3PvkJF6FHNl/C8FTGUf6gT8ITu7vgU0SPnd9ARYkvk8c3KlwCo6ITUDPKnX3u5p750nfsfaaen3k9 + TBPNdWHUhH0u5S8V8/lXv/H5Z+JTQ4sd130WSx/XfadLAWTHa4BbD0dACEai9kIymSxdvdo/tmvXzh5R + FKlCoQxkWQYZTlyNR6CcLriZrELVQEBVVX716tWdmXQ6fuXKVZr/QQBJi7IgIFrHYxLLHDSuBgA9cPtn + W0FF/rc9/uGNda2rHTPNMEwMTKSsHRhQJAFP7u6CX5W8B3dQnX1s1V45mm+6AMHVGWg/37Ozj6riu04S + T9M0UR8NoKE26FJ+Q9e0g9/62+cmB2/KuO47XXIgPm4dsz6MClqx6fz01PTUtu1bu2lasXQ6DZ/Pj7Jx + wKjzvI1D1wkCzMdVxgWqWAI+lV+9ZnVnOpOZ8wCBLpA6AdodkEEso2UlhPUCAB7MkAcAO0Dlabc/8dHt + aiDicDrPJPNI58ouyr2bWtBU4/cu8pmnyq9ybDfx9w3HOlios49K510nj59pEiLPWEPYvW4Yt2Jc950u + 9m4XpdbsQqF2UMHo4eGRdCFfSPb2bupkh5AGg0GIolRh+ttSvVy4DALuVy4/CAiCAM6xBHzc6tWrOjPZ + bPzK5Ss0CPAgwVCWVCQAYjWxVuc1i1BlrZO5vxWUn7Zt/0d20JH/ybkcNJ1sekGfhD0bYzBMk/L3mbFd + VhTfcO343lV+XiSe9uQeu7NvuXn8TJMQedrjuqkqP5x59ZsvX64c150G4fJj+/eXc1z3nS4JkIpAL1qx + TlBpw8uXL8d9qlpcvWY1QytGqgWdIaTLTC3mrjm6NhAQqoBANpuJX3aDgAjSOn0ZbnboKEicZFlGkFUD + gHbmfh8sAOA4nut76H2b6bz/TCoP3TL/O5sjaKkPePj7tg+vW518biZfd6EP1QjkMdCDbu65Ecrvo6v8 + KOW/fPyFQ1XGdX8blVN6bsS47jtdZkFMfjr+VARxrVzzB0+dOj39/7d3ZbFxndf5u/usHO6LNlKiJDqO + LdmWLcdOkyhA0DYtmgQomte2ado+pUDRFgjQh/QhRVHXiZulcdKmTZzEzQJbbozYcSTZVijZsmRrpVZq + 5TLch+Tsc/c+nHvv/PfOJUWRlCXR8wkCZu4MZ7lzz/nPOf93vtPR2SFs3LjBJytWKBSQakiB4/nlqwot + VVrMedJSVYUA6h3gBd7vBBSF29Lb253P52cDhUEZlPuzW8k8KBoPEsuWhTAHwIEZ8eR8nQ9Xn2uj7yN/ + tE1Soh5/u6waUHVySN0dDWhuiPjyfR9X33MKgb79kGaeMOmvYkX1mntWW8TTtm0okoDudc0QBN5n/DSu + +8cnA+fqTozrXutwZcXY+YOurNhmMJHoieMnx7dv25psa2/zyYqVyiVnEjEXTgbC8gVFFnUCHCDwAgRR + hMALHlvRu86c5xo68QRYJ6AoMtfbu6V7anJqKiAq0gBKA1iDT4BqASveGlyoCLg+8NhmMPTNDX272xJN + HU3ei3AcskXiKrQ3xcgBsJ19gU6+2r19tvpvwQrKfTvV/1JFQ7kSNP6wrb+wAuDNjV8UefSsd1h+jPFP + jwxee+fl791N47rXMly2YAv8beYFBGTFAODdd4+P7tjplxWjIaQVNDSkEF70c24t0wkEj5NmQQTRaBSK + okCRZMiSTLsTSgSyIkMQBFiWRTyVECcgUJGQ37pt64bTp85cz+VyrHG3g2Tj2PqSiFUoCC7kAFrh98DN + YPZl5WiCW79tV493XxJQVg3ohoWoIqKjmSkAmiZMg8n5Qwp+YSO8fKO7TQtlprNvtUU8bduGwHPo6WqB + Ios+45+fGh07/NI3f2uZRpDld6fHda9lLCYrpoMWKACAaZr28fdOjDz66K718TgrK6ZB13VnEjFhtVWF + RFFEPBaHIivgBd63Dcje5jkegihAURQIggDTMGHDrnEC1O5si9u3bW07ePDgFSZyEEG2mmbePgbaKVjR + QrOQA4iDEWtwzswW987cxPXctsf+YKsoK15hJhaRkC1pUDUDPV0pr7nHMMI7+6oGbtdKewWcRMXl9y+l + jXcZaQDHAZu6aFw3a/zF7Ezm0AvPHNDVcrCyfxx3x7jutYyFZMWmQQbhtahrmmadOTMwsnv3Y92RSHXO + mKpWANtGPFFtQFwtVSFFURCLxuAq3LspgHvbtExU1ArUSgWarjmLjABBFCDLclXYRtchioJTuOQgSTIE + UYhzHFe+cOEiG/Y3gWpKBvNBXTLVsrGQA+DA6LaBwq8+58TDtkybF0Stq3enx9sWeA4RWUAmV0EyKiMq + izVtvTU5vUVkHr9zMKs1AcOEqhue8SN0JV/M+G+eBnAANnTQuG7W+CvFXO7Qi9/YVw4f130qcOxOjete + 63DnDwaJQuOg3QIv9y8Wi8blwcvp3bt3b5ak6vzBUrkEURQQjVbriitVFYpGIlBkxZf7019xKJaKmJya + tKamJs1SqciVy2WuXC6hWCwgn8/DNE1KExTFS3V1XYcsyVQPcN60o7Ozrf+3hy5pmuZGnrxzPtiUU8YK + Z0Uu5AAqIOaf+7jt3PbIP9MjF+Y29D3eHk02e9s2sihAEniMTOXR2Rx1FH4X2OILiHaGiXwSv99p7gk0 + 6KyG8QNAV2sDGhuiPuPX1XL5rZeWPK7bBrX1rsgT17EgXFmxtsDxtHPMu/7m5ubUsfTY5K5dj2wRBMFH + FKIhpNXetuWqCsmyAkWRa8L9fD5fenHv3oHvffd7x374wx+99/LLvxo4sP/1c0M3hsZ4ntfb2tqaeJ7j + NU1DqVRCJBJBJBKFYehekdwdkipKEnRdE3mer5wdOMsOi4nCrx8hgwhmy6YIL9YNKMOfBsyBGoSoMGPb + mLh2emzzzk9uESXFK9ZEJAGmYWA8U0BrKlqt7ofu95uhW3+maUHXDWrusa0FjB8rNv62pjhamxI+4zcN + XT/6yvf3ZcbuqXHdax0LyYoNg+oB3vI+MTFRyudyszt27ugJEoViMZYteOuqQoIgIBqNek93nIB9+fKV + oS996W8OvPHGm2PT0zMVwzBsy7JsTdOsdDpdOHb03fTx945f6e3dkmpsamywbRvlcgnRaAyKokDTNFiW + BYHnIYgiOI6DZVlIpRqSr/36NxeYDxMBEcvYNLOIFRCDFnMAJVAU4J4OE7Qd4ZGEtHLemJ8amdz0wEe3 + 8LzAO0w5RBQR5YqOqbkimhIRWHa4rl/YsE63sy9XrMCyFjP+BQqACBo/Qp4PNDXQuG7W+G3LNI/vf/71 + sav35LjutY4cKAVlF6VQWbEbN4ZyHM+X+vq2bww6gWQyAZpQzoT5foZP9TiqxzgOiEaj3tgy52H70qXB + K1/5yj8dGx0dXXSISz5f0Pv7D1/fvLkn1tHZ0WLbNiqVijP7gINhGDAtCxFFoe5BgYdpmsrVq9dGpqZ8 + kvJZ+BccHSvgBCzmAEyERwGNYGe/Z9IltZSfW79tVw8sm3MNMBaRUCxrmMmWkIortbp+ln+4p5sK6Kbb + 2Xerxr80EU8ASMYVrG9vdH55L2qgcd0DNeO6s6ChnffCuO61jnlQGBxnjrmyYpvB7BhcvHhptqmpCT09 + 3T5ZsXy+gIaGlG8Iae3mQK0TEEURsqwwwQKH0dH06Isv7r1w5MiRJc1xoGlIx9MPPbyzLZVKJan71UQy + mfSiAEmWwTvcgHKljFKpXDh9+gy7IOnw7z7ZoJrIsnAzSbAcqDWYfd4YAvzsTPpyzrKsYnvPAxu97VEb + iEUl5Esq5nJlJGJyzXBPtsfflfrOFyowTXOFxr9w9T8WoXHd3od0cOXEG+9eqB3XXQIZ/700rnutY8my + YqdPn5ns6e6OdnZ1+mTFisUCGhoamSGkhMUERWRZ8ZwGB6BcLpfOn7tw7bnnnhutVCpuoc4GLQqnQbn6 + FMhO4sz721evXpv8+Cc+1sfzPK/rOqLRGDiOg2ma4DgOoiR51GFVVc3+3x5imYAc/HUAHhQFLQs3cwCW + c3LZAowJcgK+jsGpoXOzgiip7d0f2gCb8wwyEZWQK6rIFirUHbgAKUg3LeSLKowQ42fK/1jU+N3VHOzf + VY1fkQX0dDU7P3zV+NfguO61DJcoFCYrNodaWbGx+z98f1Nzc3PKPUZDSEuMrNjNnUBEiTCFPw7DwyPD + Z84MTPf397ssUBNEDDsDilQKzue8AjJSb1ctm81pW7f2Jjs6OloAwLYtxONxaLoGDhwUWQYch6BpKl57 + bV/Q4M8G7qexzDZhfgnPmUZtiJED5cS+6uOpAz++eOnoK+8FRTW6WhIwLRtj0zn/1iDD8isUK9CNcONf + qY4fAEgij+6uZvACh2phAJgcunD5+G9+dCLw/dwfM9jumwdRfD9IQp53IwyQEQQ5FyMA3gHjnA3DsL72 + 9DP942PjvrpOqVRCOk1NmhwHhzbMOQw/J893jrtEHTjPsW3LymRms4ODg2zx7QTCV2LbeczXEfrOkaNe + k5grbEKvbXssQ1EUEYvFooIgsBUJCX5yFIcVTPleigMAyIsF85wpkJH4jOG9V//r7NUTB055BugcX9+a + gGVZmJwtwDD9ar80tstEjSLPgsbvPLZE4xd4Dt1dzRBF3mf8cxNDo0de/u4R27bY1dwGje0KOr0y6KKr + U3zvDqggynWQdTmIAE+jXC4bTz/99ddnZ+fm2eP5fB4TE+Ngjd01dJ6rOgGXpEPRAYdKuVKybdsaGhpy + HZCGm8u7+4bADgycnbEsywKoNqCqKnieVKa9z8Dz4HlekCSJtVN/yEJYqh3XYKl/aIH2uoMe190a8zmB + oy9/+9TQubfOVa2K2Hbr26nqPpstef3+xbJW7eyrCd3pb5cr4gkAPAds6mqCLAs+48/PTU4dfunbBwMU + X4D2+W8Ejmmg0O6DKuR5t6KEcGn10wgwNTOZWfWZr//7gWKx6KvnzM3NYWZmGmFOwE0PeJ53wwRwADRd + 1ziO4yYnJ93rIQP/wmCitkdkhn1OPp/XVVX1dg50XaMowP3HVf+HIPTgcnArnkNDuMcdAvHifTnx2y8+ + 81568L1LrPHyHLDRcQLZQhnFihbo7Fusgh+8X40GaiMBOu6y/KIRyffpyoX57OG933pdV0tBAsUZ1Hpy + w/nedYrv3YksSG4tWJM5isC4tZGR0cJ3/uO7BzRN8zny6ekpzM/PoeoE4DNAziH7cYwTsG3bZop/wajQ + QG36yK5iAKgg6N52C4C8wFflx20buq4bqqqyr2+FvN+yo9JbDR1KoDA4aDhXEci9bNuyD/3iqXcmrp+5 + 6n1/2wbPc9jYQfUYf2ffahl/9X5XWwMSccWrFwCAVikW3/6/7+wv5+eC+7aDICVf328EWmFWTYGljtuC + GVCaysIC0I+AFNu5c+dnf/A/z71pmqbPaCYmxlEo5AEwRs+uwBznxd6SJIkcx3FMs05j4L0VAB8KHEuA + yd1lWeYVRQlO2qZ6g0MvNk0TpVKp7GsnpgWYtT8b76MDAKgWcC7kTS8B8E3FsS3T7v/Zv7w1PXJhiGXp + CTyHTR0pKJKAmzfvBO/76wCs8bP325uTaGyI+ozf0DXtnV99/0B2Jh006JrikXP7EqiiW8fdjzHUdme6 + U5nm2YNHjrwz/sILew/bjGXZto10ehTlcgkIFAFtG17+D45DNBaLSZLEK4rihuIJMKK5C2A7e6e3d0tK + FKs9CzzPAzYgCZJTb+Cg6zqmp6bnAq8TvHYNvM8OAKgKXgRzr3MIFGBMQ7cOPv/P/bPj19Ks8YoCOQFZ + 5KssvhWJeFbvNzfE0NoU9xm/ZRrGif0/eX1mdDB4QicRUscARTV1Ic97CzdQW7xVQVqNvtz/16++dn3f + vgPvsscsy8LIyDA0TfXyf5KEs6oRAMdBFEUxlUrFOzs72RX8CfiVjFh0gcbsefjIE49vYu+7k4QkSfLK + fKpawfDwSJBmHkwtghyVW8Kyq4fOBwnLvU7Bv08JQ1fNN5//6pvZqZGJoADHps5GiCK3TONHjfGn4hF0 + tjb4jN+2bftM/97+0cHjwcLMPIA3UJvSDMPfe13HvYPLqKXGFkBOwJf7//R/f3b+6NFjvmvVNE0MDw/B + MAwfR8C2/E6gs7OjfevWrSwjMQngDwH0ospPiIP0ND8Fxtai0aj46KO7+tj3lSSJ9AJFSgGIA6Dh+PET + Qap50CGsqAN12fuHDkqg4lgL/JXJMRBTy2NgmYZujVw8OrRh+6Pr5EhVuEEQOMSjcpX+e0vG748E4hEZ + G0JYfjSue99Sx3VPoDafrOPeQpisWBlkPLWyYn3bG9raWj2FK3cIaSrV6Ml6geMgCqIn8KkokYht28V9 + +/YH23O7ATwA0tF8ALT6+xbaL/zFnz3c27vFEzRVlIjTrajAzQry+RwmJiZzzz//02Bd6hj8jiyNFTiB + lUQALhaixb6DwNx7tZTT33j+q/uL2WknjKnq8G3qbITAc8s2/ogsYmOI8d84+/ap82+/HBTvUEFafsET + l0FdyHMtwJ3CFHTu4wjsWFmWZT/z9W8cHh4e8a20lUoFIyPDgLMvb5q0VU0FOkoN9uzZ88BDDz/UGPL+ + HKjgV7Nd93u//7s9TzzxkQfYY4lEAuA4p9eAbCCXy+HkiZNXAgXALGonS82v5EStNAJwUUBtuyZAxbUm + MFVSQyubY5dPDG+8b/dGUY5EXGMXBR6xiIxcsRyY74ebGr8sCuhZ1wKB59nflsZ1//oHYeO6D6A2THSL + m3WW39qAO4Q0OH9wDnQN+GXFjp8YfvQxv6wYDSFVPW1BSlsFuGGAwPPCk08+2T04ODiTTqcXXYV5nuf+ + 5PN/fN/nPveZJ9mhJoqiIB5PIBKJOINDgGx2HtnsvP7ss/95uFTybVWfh59fUMAK+gCA1XMAQJUp2Bg4 + PgJKEbyuQq1SNCauDYxs6HtskyjJCkA2LYk84hEZhZIK03Ls8CbGL/I8uh0hT9b4M2PXht7+5bPBcd0W + aHJPsFBUAnEAPmjjutc6DITPH5wGUWo9WTFVVa2BMwMjux/f3cNuz7lDSJPJBCzLBi8I1SYiDkjE49Lu + x3dv7ehsT2az2UImk6mwq7Ysy/xHf+fJ9X/111/86COPPHIf257McRxaWlo9UVEAMHQDk5MTOHbs3Qv9 + /YdYHoMFil5YHk4aKxSiWTVGEYMt8M8VACgc+hSos9BDU+fm5Cc+/w+fliLxGBv2G6aJ8Zkccvkybmr8 + 65qhyCJY489lxicO/vzp/YZWYbdHbNC47mCIr4IKl3Wiz9pFEygnZ693DsDHwGhdAsC2bVtTf/f3f/vp + iGuRDtrbO9DaSiUtRYmAd7YHXd7JTGYGo6MjyOfzxUxmNqtrmh6NxSKtrS1NC+33t7a2ecKigLMLMTqM + ubm58pe//I8v5bI5Nte/AuAwc98G1QNWdN2uZgTgYg5UDGEnvFigPdouMK2RlcK8NpO+kt6wfVePILB7 + ohxS8QgSMcXRTDM9o3d1/JIxBRs7myFL/pW/Pq67jhC4smLBYvUoKArwrtXZ2Vl1bHx8cteuR7awoXqx + WIQoyohGIzBNw9H9r0YCsWgMDalG2LYtx2LRZHNLc2NDQzLBDjJ1kUwm0d7eAZ4XEI/FPLLRxOQ4SqUS + Xnxh71vnzp1nU1SX1MSS12axCmI0t8MBAOQEImAGOzpfwpVw8nq5S7lMJTN+Nb1u60ObBFGS2H19UeCR + SkTQkoohGZMRjypoTMbQ0ZJEcypW09arlguFw3u/udRx3RaI4lsf1/3BQBH0mzcxx2xQiuq7JsfHJ0qF + YnHuwQcf8MmKFQp5SJLiaPkZJPnNMPckUURzUzMaUikIggiO48FxPERRRDQaRWOqER2dXYjF4gBsxGLO + NWwDE5MTyOdzGBg4e/nHP3p+IPDZLyJQUAdFsouqEC0Ft8sBAFSAicGv3mKCnIBPUKSUnamMXTl1vXXj + 9pZIrCERDPs5DhAFARFZgiILzm6Bn1qtlgvFt3/57L7s9Gh9XHcdCyEHyv1ZlSsTVVkxL1S/fv1GjheE + cl/f9g1+WTEqdcXjCUfYxvA691yegCRKSCSTaG5qQktrC1paWpFKpSBJMgzDgCDwiESi3u5CemwUhUIe + E+MT0//21NcOGobBlv7LoLoVm87Oo5b1uCzcTgcAkBNIwq/eYoCcwCYw+7RauaBfP91/leP5Sqp1Q6sg + SmKNrl9QEMRBYW4qc+SXz+6fnxoJruYTCGlZRn1c9wcZc6hdmHRQQc0ncnPxwsWMIAjl7du3+ZxAqVRE + qVhEItkAnudhGCYMQ6dp1jZN/7EcpStdN6BpKjSNFutIJAJJksEByOVzGB0dgaqqmJnJzD311Nf2ByYC + AcRSZRcqd/Falc7U2+0AbBD5IgVmxXdO+Aho+qnCPn1q+OLM9YFDgxzHa9FkY0KU3RmEtcavVUqVa6f7 + Tx979b/fDtHvnwXt9dfHddcRRAa116QKWhR8RKELFy5mdF3P9/X1bWBrArquY3Y2A9u2EYvGIIgiLMuC + ZZpeZGA6E7NFgaYCybICjuNQLBSQHksjk5khjYyJyemn/vXp/TMzM8HU9Sxqu1PHsQINwCBuxy5AGAQA + O+APveD8AHsQ2B1gP1/Lut7mju77OxJN7Y2SElUs07AqhfnizNi1qbErJ8dMQw/buptHOMtvDHUtvzoI + IoimGw8c3wS6Jn0kuZ07d7R+8S+/sCeZTCbCXiyRSKIxlUIsTqPCOEbhR9d1lMslFAoF5HJZsN3I589f + uPrtb33nSGC/H6AF8g34qfYVUC1r1bar3y8HAFDutQP+wiCcE/2g89hqRCTToBNXDjke1rtQxwcXCoCH + 4acMA+QEPoHA9djY2Cj/+Rf+9NEdOx7cxi2g1OHClfiyLAsBNh8AoFQql1/51avvvvLKq9dC/nwStdGr + jare4Krh/XQAwMJOAKCQbBf8o8lvBRbIwE+gtj1yHlTxr7P86ggiDmAn/JOIAUpP98CvvwcAePiRh9o+ + +9nPPNTdvWndzRxBEKqqaieOn7z0s5//YiA7nw3L48dBC1iwFnANK2T9heH9dgAAndD74d+OYdECElPo + Ru2PEgYLlNOfRHhVPwcy/jrLr46FkAJFocEItBnAJ+HntHi470P3Ne3Z8/He+/r6NqYaUw0LOQPDMIyx + sbGpUydP3zhw4I0buVxuoQLeZRBZLbhQTaB2GO2q4E44APd9e7D4ai+BagOdIGeRcI65UuXzoKLNMBbu + iZ5HXcizjqWhEdS9F3QCCoAnwUzECoLjOLS3t0V7e3sb29pa40pEEW0byGazlYnxifzg4OX5SqWy2DWo + g1h9YfWpGRCB7bakrnfKAbhIgZRSYit9oRCkQWFTPeyvY6lIgZyAGPJYD4DdWP1rdQRk/GGEtNtq/MCd + dwDuZ1gHKrzIK3wtgCqll1GrnFJHHUtBHMCH4eeuuBAB9IGcRPRWXjQE46Ci3kJbemkQ+++2Fq3vBgfg + wp2e0oUFcq6boAw6aeOor/p1rAwigPtA9agwCKD0tRd0vYpLfN0CiMF3FQsvUBao8WfV9voXw93kAFjE + QAWYRlDuL4d8Vnda8TyI2JFFfYuvjtUDBzJu39DREIiga7UVdK3GQA7CBrH1iqBrcxrkABa7RvOgYt+K + ZL5u9UveCxBBBUD3xBqgwkl9pa/jdkMBrfRtK32hReBO/B3D+7yI3SsOoI467jSSoDpVsKV4JdBARp/G + HdqmrjuAOuq4NURBGgLtWN6OgAXiq0w7/+9oFFt3AHXUsXxEQVuHDc7tCChVde3KBHFWVFD+nwPVA+4a + Xsr/A9poIoNAQdQ5AAAAAElFTkSuQmCCKAAAAIAAAAAAAQAAAQAgAAAAAAAAAAEAww4AAMMOAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAf + AAAALwAAADkAAAA+AAAAPQAAADcAAAAsAAAAGwAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB + AAAABQAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAuAAAAPwAAAD8AAAA/AAAAPwAAAD8AAAA/AAAAPwAAAD8AAAA/ + AAAAPgAAACcAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAfAAAAMgAAAD0AAAA/AAAAPwAAADsAAAAsAAAAFQAAAAEAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAiAAAAPgAAAD8AAABA + AAAAWAAAAHUAAACHAAAAkAAAAI8AAACEAAAAcAAAAFEAAAA/AAAAPwAAADwAAAAYAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAkAAAAPgAAAD8AAAA/ + AAAAPwAAAD8AAAA/AAAAPwAAAD8AAAA/AAAAMgAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAEAAAALwAAAD8AAAA/AAAAXgAAAJAAAACfAAAAnwAAAJ8AAACfAAAAnwAAAJ8AAACf + AAAAnwAAAIcAAABTAAAAPwAAAD8AAAAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAANAAAANwAAAD8AAAA/AAAAUwAAAHYAAACOAAAAmQAAAJgAAACJAAAAagAAAEMAAAA/ + AAAAOwAAAA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAADIAAAA/AAAARAAAAH4AAACf + AAAAnwsLC6NISkrAbXBv13x/fuJ6fXzhaGpq1Dw+ProEBAShAAAAnwAAAJ4AAABvAAAAQAAAAD8AAAAl + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAADwAAAA/AAAASwAAAIMAAACf + AAAAnwAAAJ8AAACfAAAAnwAAAJ8AAACfAAAAlAAAAFUAAAA/AAAAOwAAAAsAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAIAAAAvAAAAPwAAAEcAAACMAAAAnwQEBKFZXFvLlpmY+J2hoP+doaD/naGg/56iof+doaD/ + naGg/4+TkvJGR0e/AAAAnwAAAJ8AAAB8AAAAQAAAAD8AAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAA0AAAA8AAAAPwAAAFkAAACZAAAAnwMCAqFBMSS/cFM93oFhR+59XkXsYkk11hoTDqsAAACf + AAAAmwAAAFYAAAA/AAAAOQAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAKgAAAD8AAABFAAAAjQAAAJ8VFhWo + g4eG6J2hoP+doaD/rbCv/73Av//GyMj/yMvK/8jKyf/BxMP/srW1/6Cko/9xdHPaBQUFoQAAAJ8AAAB1 + AAAAPwAAAD0AAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAOwAAAD8AAABYAAAAnAAAAJ8wIxm0 + imZL75tzVP+ZclT/mXFT/5dxU/+VcFL/kGxP+josILsAAACfAAAAmQAAAFAAAAA/AAAANQAAAAUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAACQAAAA/AAAAQgAAAIYAAACfFxgYqY2Qj/CdoaD/o6al/7/Cwf/JzMv/zM7N/8zOzv/Lzs3/ + yMvK/8TGxf/Ex8b/xcfG/6qurf94e3rgAgICoAAAAJ8AAABeAAAAPwAAAC4AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAACgAAADkAAAA/AAAAVQAAAJsAAACfRDIkvZxzVP2ddVX/m3JS/5FkQv+JWzj/iVw5/5JpSv+VcFL/ + km5Q/DMmHLcAAACfAAAAlQAAAEsAAAA/AAAAMgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdAAAAPwAAAEAAAAB+AAAAnw0ODqSJjYzt + naGg/6Snpv/Fx8b/zc/P/9HS0v/Nz8//trm5/6aqqf+hpaT/pqmp/7K1tP+/wcD/xcfH/66xsP9fYWHO + AAAAnwAAAJQAAABDAAAAPwAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAA4AAAAPwAAAFIAAACZAAAAnz4uIbqedVT9 + oHZV/5drSP+HVS7/g1Eq/4JQKf+ATyn/f08p/49mRf+VcFL/j2xP+ScdFbAAAACfAAAAkAAAAEYAAAA/ + AAAALQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAFwAAAD8AAAA/AAAAdAAAAJ8GBgahgYSD5p2hoP+ipqX/w8bF/87Q0P/R0tL/yszL/4WIh+NSVFPG + SkxMwmlsa9WXm5r5naGg/6Sop/+7vr3/w8XF/6Wop/0iIyOuAAAAnwAAAGgAAAA/AAAAKQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG + AAAANgAAAD8AAABPAAAAlwAAAJ84KR23oHZV+6J4Vv+ZbEj/iFQs/4ZTK/+FUir/g1Eq/4JQKf+ATyn/ + f08q/5BoSP+VcFL/i2lM9RwVD6sAAACfAAAAigAAAEMAAAA/AAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEAAAA+AAAAPwAAAGoAAACfAgICoHV4eN2doaD/ + oKSj/8HDwv/Lzcz/0dLS/87Q0P5UVVS/AAAAnwAAAJ8AAACfAAAAnxkaGqmLjo3unaGg/6qurf+9wL// + vL++/3N2dtsAAACfAAAAjwAAAD8AAAA8AAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAADUAAAA/AAAATAAAAJUAAACfMiUas6B2VfqleVf/ + nW9K/4xXLf+JVSz/iFQr/4ZTK/+FUir/g1Eq/4JQKf+ATyn/gFAr/5JqS/+VcFL/hmVK8RINCqcAAACf + AAAAgwAAAEEAAAA/AAAAIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM + AAAAPAAAAD8AAABgAAAAngAAAJ9oa2rUnaGg/56iof++wL//x8nI/8/Q0P/P0dH/oKGh3AAAAJ8AAACc + AAAAeQAAAHEAAACSAAAAnyEhIa2anp39n6Oi/7W4t/+/wsH/pamo/AsLC6MAAACfAAAATAAAAD8AAAAP + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAz + AAAAPwAAAEoAAACTAAAAnywhF7GhdlX4qHtY/6FxTf+PWS//jVct/4tWLP+JVSz/iFQr/4ZTK/+FUir/ + g1Eq/4FQKf+ATyn/gVIt/5NtTf+VcFL/f19G6goIBaMAAACfAAAAewAAAEAAAAA/AAAAHAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAADkAAAA/AAAAWAAAAJ0AAACfWFpayp2hoP+eoqH/ + ur28/8fJyP/Hycj/z9HR/83Pzv5mZma8AAAAnwAAAF0AAAA/AAAAPwAAAEUAAACUAAAAn3h7et+doaD/ + r7Kx/7y+vv+ytbT/PD09ugAAAJ8AAABhAAAAPwAAABsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAMQAAAD8AAABIAAAAkAAAAJ8nHBSuoXZU9qp9Wf+kdE// + lV80/5BZLv+OWC3/jFct/4tWLP+JVSz/iFQr/4ZTK/+FUir/g1Ep/4FQKf+ATyj/glMv/5RuT/+VcFL/ + d1lB5AQDAqEAAACfAAAAcgAAAD8AAAA/AAAAFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAA2 + AAAAPwAAAFEAAACaAAAAn0hKScCcoJ/+naGg/7a5uP/Hysn/xsjH/8bJyP/O0ND/xsjH91ZWVrYAAACV + AAAAPwAAAD0AAAA1AAAAPwAAAHIAAACfXF9ezJ2hoP+tsa//t7q5/7e6uf9XWlnJAAAAnwAAAG4AAAA/ + AAAAIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAACsAAAA/ + AAAARgAAAI4AAACfIRgRq6F1U/Stfln/p3dR/5xoPv+fbEX/lmA3/5BZLv+OWC3/jFct/4tWLP+JVSz/ + iFQr/4ZTK/+FUir/g1Ep/4FQKf+ATyj/hFYy/5VvUf+VcFL/bVI83AEBAaAAAACfAAAAaQAAAD8AAAA+ + AAAAEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAMQAAAD8AAABLAAAAlQAAAJ84Ojm4mp6d/Z2hoP+ytbT/ + x8rJ/8bIx//ExsX/xcfG/83Pz//Fx8b4Xl5euQAAAJcAAABAAAAAPgAAADkAAAA/AAAAdQAAAJ9fYWDO + naGg/6+ysf+0t7b/t7q5/2FjYs8AAACfAAAAcgAAAD8AAAAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfAAAAPwAAAEMAAACKAAAAnxsUDqmhdVPyr39a/6p5U/+ibkX/ + p3dS/6NyS/+ebEX/lV81/5BYLv+OVy3/jFct/4tWLP+JVCv/iFMr/4ZTKv+EUir/g1Ep/4FQKf9/Tij/ + hlg1/5ZwUv+VcFL/YUk10wAAAJ8AAACeAAAAYAAAAD8AAAA8AAAADQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAACwAAAA/ + AAAARgAAAJAAAACfKisqsZebmvqdoaD/rbGw/8fKyf/GyMf/xMbG/8LFxP/CxMP/zM7N/8rMzP9/f3/G + AAAAnwAAAGgAAAA/AAAAPwAAAEwAAACYAAAAn36BgOSgpKP/sbWz/7S3tv+0t7b/WVtbygAAAJ8AAABv + AAAAPwAAACIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAD4AAAA/ + AAAAfQAAAJ8VDwumoHRS77GBW/+ufFX/qHRL/7CCX/+sfVj/p3dS/6NyS/+ea0T/lF40/5BYLv+OVy3/ + jFYs/4tVLP+JVCv/iFMr/4ZTKv+EUSr/g1Ap/4FPKf9/Tij/iFs4/5ZwUv+VcFL/Uz4uygAAAJ8AAACd + AAAAWQAAAD8AAAA5AAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmAAAAPwAAAEMAAACJAAAAnx0dHauTlpX1naGg/6qtrP/Hycj/ + xsjH/8TGxv/CxcT/wcPC/7/Cwf/Hysn/ycvL/7Kzs+gbGxumAAAAnwAAAIcAAAB/AAAAmgAAAJ8wMjG0 + nKCf/q2xsP+sr67/trm4/66xsf8/QD+7AAAAnwAAAGMAAAA/AAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqAAAAPwAAAF8AAACfBwUDoZlvTum2hF3/sX5Y/615Uf+4jWz/ + tIhl/7CCX/+sfFj/p3dS/6JxSv+ea0P/lF0z/5BYLv+OVy3/jFYs/4tVLP+JVCv/iFMr/4ZTKv+EUSr/ + g1Ap/4FPKf9/Tij/il88/5ZwUv+UcFL+RTQmwQAAAJ8AAACaAAAAUgAAAD8AAAA3AAAABgAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAD8AAABA + AAAAgQAAAJ8REhKmjJCP8J2hoP+mqqn/xsjH/8bIx//Ex8b/w8XE/8HDwv+/wsH/vsC//7/Cwf/Iysn/ + xsnI/5KTk9cGBgahAAAAnwAAAJ8AAACfLi8vs5OXlvalqaj/s7a1/6yvrv+4u7r/oqal/AwMDKQAAACf + AAAATQAAAD8AAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAD4AAABA + AAAAkQAAAJ90VDvStoRd/7WCWv+udkr/wJd4/7yScv+4jWz/tIdl/7CCXv+rfFf/p3ZR/6JxSv+dakP/ + k10y/5BYLv+OVy3/jFYs/4tVLP+JVCv/h1Mr/4ZSKv+EUSr/glAp/4FPKf9/Tij/jWJB/5ZwUv+TblH9 + OCoeuQAAAJ8AAACWAAAATAAAAD8AAAAzAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAABkAAAA/AAAAPwAAAHkAAACfCQkJo4WIh+mdoaD/o6em/8THxv/GyMf/ + xMfG/8PFxP/Bw8L/v8LB/77Av/+8v77/ur28/8DCwf/Fx8f/xMbG/6yurvBydHPUYWRj0HyAf+OdoJ/+ + qKuq/7a5uP+prav/tLe2/7O2tv9wc3LZAAAAnwAAAI8AAAA/AAAAPAAAAAIAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVAAAAPwAAAFUAAACfGBIMqLOBW/y2hF3/qm9B/7qLZv/Gnn// + wJh4/7yScv+4jGv/tIdk/6+BXv+re1f/p3ZQ/6JwSf+caUL/k1wx/49YLf+OVy3/jFYs/4tVLP+JVCv/ + h1Mr/4ZSKv+EUSr/glAp/4FPKf9/Tyn/j2VE/5ZwUv+QbE/6KyAXswAAAJ8AAACSAAAASAAAAD8AAAAv + AAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAAAAPgAAAD8AAABv + AAAAnwMDA6B7fX3hnaGg/6GlpP/CxMT/xsjH/8THxv/DxcT/wcTD/7/Cwf++wL//vL++/7q9vP+5vLr/ + t7q5/7y+vv/CxMT/wcTD/8DCwv+8vr7/t7q5/7q9vP+1uLf/qa2s/7C0s/+3urn/n6Ki+hgZGakAAACf + AAAAZgAAAD8AAAApAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8AAAA/ + AAAAaQAAAJ9ZQS3DtoRd/7J9VP+kZTT/wph3/8iihf/Fnn//wJd4/7yScf+4jGv/s4dk/6+BXf+re1f/ + pnZQ/6JwSf+caUH/klsw/49YLf+OVy3/jFYs/4pVLP+JVCv/h1Mr/4VSKv+EUSr/glAp/4FPKf+ATyn/ + kWhI/5ZwUv+Mak33HxcRrQAAAJ8AAACMAAAARAAAAD8AAAApAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAADgAAAD0AAAA/AAAAZAAAAJ8AAACfbnFw2J2hoP+fo6L/v8LB/8bJyP/Ex8b/ + w8XE/8HEw/+/wsH/vsHA/7y/vv+6vbz/uby7/7e6uf+2ubf/tLe2/7O3tf+3urn/uby7/7i6uv+0t7b/ + rbCv/6isqv+ws7L/t7q5/6uurf5ERUW+AAAAnwAAAI8AAABBAAAAPwAAAA0AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIgAAAD8AAABvAAAAn2pNNsy2hF3/r3dM/6RlNP++kW7/ + y6eL/8iihf/FnX7/wJd3/7yRcf+3jGr/s4Zj/6+BXf+qe1b/pnVP/6FvSf+caED/klsw/49YLf+OVy3/ + jFYs/4pVLP+JVCv/h1Mr/4VSKv+EUSr/glAp/4FPKf+BUCv/k2pL/5ZwUv+IZkvyFRALqAAAAJ8AAACG + AAAAQQAAAD8AAAAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAA6AAAAPwAAAFwAAACe + AAAAn19iYc6doaD/nqKh/7y/vv/Gycj/xcfG/8PFxP/BxMP/wMLB/77BwP+8v77/u768/7m8u/+3urn/ + trm4/7S3tv+ytrT/sbSz/6+ysf+tsa//rK+u/6qtrP+orKv/sLSz/7e6uf+usbD/UlRTxgAAAJ8AAACc + AAAAUgAAAD8AAAAqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAe + AAAAPwAAAGYAAACfTjgovraEXf+0gFj/pWY1/6xyRf/MqI3/y6eK/8iihP/FnX7/v5Z3/7uRcP+3i2r/ + s4Zj/6+AXP+qelb/pnVP/6FvSP+bZz7/klov/49YLf+OVy3/jFYs/4pVLP+JVCv/h1Mr/4VSKv+EUSr/ + glAp/4FPKf+CUiz/lGxN/5ZwUv+CYUftDQkHpAAAAJ8AAAB+AAAAQAAAAD8AAAAeAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAGAAAANwAAAD8AAABUAAAAmwAAAJ9PUVHEnaGg/52hoP+4vLv/xsnI/8XHxv/DxcT/ + wcTD/8DCwf++wcD/vb++/7u+vP+5vLv/uLq5/7a5uP+0t7b/s7a0/7G0s/+vsrH/rbGv/6yvrv+qraz/ + qKyr/7G0s/+3urn/rrGw/1NVVMYAAACfAAAAngAAAF8AAAA/AAAAOgAAAAYAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIAAAA/AAAATgAAAJ8JBwSiqXtW9baEXf+veE3/ + pGU0/7B6T//MqY3/yqaK/8iihP/EnH3/v5Z3/7uRcP+3i2n/s4Vi/66AXP+qelX/pXRO/6FvSP+aZj3/ + kVov/49YLf+NVy3/jFYs/4pVLP+JVCv/h1Mr/4VSKv+EUSr/glAp/4BPKf+DUy7/lW5P/5ZwUv96XEPm + BgQDogAAAJ8AAAB1AAAAPwAAAD8AAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAADMAAAA/AAAATQAAAJcAAACf + P0FAu5ufnv6doaD/tLe2/8fJyP/Fx8b/w8XE/8LEw//AwsH/vsHA/72/vv+7vrz/uby7/7i6uf+2ubj/ + tLe2/7O2tP+xtLP/r7Ox/62xr/+sr67/qq6s/6isq/+xtLP/t7q5/62xsP5SU1PFAAAAnwAAAJ4AAABi + AAAAPwAAAD0AAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAgAAADsAAAA/AAAAhQAAAJ9GMyS6tYNc/raEXf+ud0z/pGU0/7F7Uf/MqY3/yqaJ/8ihg//EnH3/ + v5Z2/7uQb/+2i2n/soVi/66AW/+pelX/pXRO/6BuR/+ZZTz/kVou/49YLf+NVy3/jFYs/4pVLP+JVCv/ + h1Mr/4VSKv+EUSr/glAp/4BPKf+EVTH/lm9R/5ZwUv9xVT7eAgEBoAAAAJ8AAABsAAAAPwAAAD4AAAAT + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAIAAAAvAAAAPwAAAEgAAACTAAAAnzAxMbSZnZz7naGg/7Czsv/Hycj/xcfG/8PGxf/CxMP/ + wMPC/77BwP+9v77/u769/7m8u/+4urn/trm4/7S3tv+ztrT/sbSz/6+zsf+tsa//rK+u/6qurP+orKv/ + sbSz/7e6uf+tsLD+UFJSxQAAAJ8AAACeAAAAYQAAAD8AAAA+AAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIQAAAD8AAABOAAAAmwAAAJ9bQi7E + tYNd/raEXf+ud0z/pGU0/7J8U//MqY7/yqaJ/8ehg//Dm3z/v5Z1/7qQb/+2i2j/soVh/65/W/+peVT/ + pXRN/6BuR/+ZZDr/kVku/49YLf+NVy3/jFYs/4pVLP+JVCv/h1Mr/4VSKv+EUSr/glAp/4BPKf+GWDT/ + lnBS/5VwUv9lTDjWAAAAnwAAAJ8AAABjAAAAPwAAAD0AAAAOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAKQAAAD8AAABEAAAAjQAAAJ8iIyOt + lZmY952hoP+sr67/x8nI/8XHx//DxsX/wsTD/8DDwv++wcD/vcC+/7u+vf+5vLv/uLu6/7a5uP+0t7b/ + s7a1/7G0s/+vs7H/rrGw/6yvrv+qrqz/qayr/7G1tP+3urn/rbCw/k9RUcQAAACfAAAAngAAAGEAAAA/ + AAAAPgAAABUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAEAAAAOAAAAD8AAABdAAAAngAAAJ9cQy/FtYRd/raEXf+udkv/pGU0/7N+Vf/MqY7/ + yqWI/8eggv/Dm3z/vpV1/7qQbv+2imj/soRh/61/Wv+peVT/pHNN/6BtRv+YYzn/kFku/49YLf+NVy3/ + jFYs/4pVLP+IVCv/h1Mr/4VSKv+EUSr/glAp/4BPKf+IWjf/l3FT/5VwUv9YQjDNAAAAnwAAAJ0AAABb + AAAAPwAAADoAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAACMAAAA/AAAAQQAAAIUAAACfFhcXqI+TkvKdoaD/qKyr/8bIx//FyMf/w8bF/8LEw//Aw8L/ + vsHA/73Av/+7vr3/uby7/7i7uv+2ubj/tLe2/7O2tf+xtLP/r7Ox/66xsP+sr67/qq6s/6msq/+xtbT/ + t7q5/62wr/5PUFDEAAAAnwAAAJ4AAABgAAAAPwAAAD4AAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAAAAPQAAAD8AAABg + AAAAngAAAJ9eRDDFtYRd/7aEXf+udkv/pGU0/7SAV//MqY3/yqWI/8eggv/Cmnv/vpV0/7qPbv+2imf/ + sYRg/61+Wv+peVP/pHNM/6BtRv+XYTf/kFku/49YLf+NVy3/jFYs/4pVLP+IVCv/h1Mr/4VSKv+DUSr/ + glAp/4BPKf+KXjv/l3FT/5VwUv9KNyjDAAAAnwAAAJsAAABUAAAAPwAAADgAAAAHAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAPwAAAEAAAAB9AAAAnw0NDaSIjIvs + naGg/6WpqP/Fx8b/xcjH/8PGxf/CxMP/wMPC/7/BwP+9wL//u769/7q8u/+4u7r/trm4/7W4tv+ztrX/ + sbSz/7Czsv+usbD/rK+u/6uurf+prKv/srW0/7e6uf+tsK/+Tk9PwwAAAJ8AAACeAAAAYAAAAD8AAAA+ + AAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAAAAPgAAAD8AAABhAAAAngAAAJ9fRTHGtoRd/7aEXf+udkr/ + pGU0/7SBWf/MqY7/yqSH/8eggf/Cmnv/vpR0/7qPbf+1iWf/sYRg/61+Wf+oeFP/pHNM/59sRv+WYDb/ + kFku/49YLf+NVy3/jFYs/4pVLP+IVCv/h1Mr/4VSKv+DUSr/glAp/4BPKf+NYT//l3FT/5RvUf48LSG8 + AAAAnwAAAJgAAABOAAAAPwAAADQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAFgAAAD8AAAA/AAAAcwAAAJ8FBQWhf4OC5Z2hoP+jpqX/w8XE/8XIx//ExsX/wsTD/8DDwv+/wcD/ + vcC//7u+vf+6vbv/uLu6/7a5uP+1uLb/s7a1/7G1s/+ws7L/rrGw/6ywrv+rrq3/qayr/7K1tP+3urn/ + rbCv/kxOTsIAAACfAAAAnQAAAF8AAAA/AAAAPgAAABMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAU + AAAAPgAAAD8AAABiAAAAngAAAJ9hRjHHtoRd/7aEXf+udkr/pGU0/7aDW//MqY3/yaSH/8afgf/Cmnr/ + vZRz/7mObf+1iWb/sYNg/61+Wf+oeFL/o3JL/59sRf+VXzX/kFku/49YLf+NVy3/i1Ys/4pVLP+IVCv/ + h1Mr/4VSKv+DUSr/glAp/4BPKf+PZEP/l3FT/5FtUPsvIxq0AAAAnwAAAJQAAABJAAAAPwAAADAAAAAC + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAA9AAAAPwAAAGkAAACfAQEBoHR3dt2doaD/ + oaSj/8HDwv/FyMf/xMbF/8LEw//Aw8L/v8HA/73Av/+7vr3/ur27/7i7uv+2ubj/tbi2/7O2tf+xtbP/ + sLOy/66xsP+ssK7/q66t/6msq/+ytbT/t7q5/6yvr/5LTU3CAAAAnwAAAJ0AAABfAAAAPwAAAD0AAAAT + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAPgAAAD8AAABiAAAAngAAAJ9iRzLI + toRd/7aEXf+udUr/pGU0/7eFXf/MqI3/yaSH/8afgf/BmXr/vZRz/7mObP+1iGb/sYNf/6x9WP+oeFL/ + o3JL/55sRP+VXjT/kFku/49YLf+NVy3/i1Ys/4pVLP+IVCv/hlMr/4VSKv+DUSr/glAp/4FQKv+RZ0f/ + l3FT/45rTvgjGhOvAAAAnwAAAI4AAABFAAAAPwAAACsAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM + AAAAOwAAAD8AAABfAAAAngAAAJ9maWjTnaGg/5+jov++wcD/xsjH/8TGxf/CxMP/wMPC/7/BwP+9wL// + u769/7q9u/+4u7r/trm4/7W4t/+ztrX/sbWz/7Czsv+usrD/rLCu/6uurf+prav/srW0/7e6uf+sr67+ + S0xMwgAAAJ8AAACdAAAAXgAAAD8AAAA9AAAAEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAVAAAAPgAAAD8AAABjAAAAngAAAJ9jSDLItoRd/7aEXf+udUn/pGU0/7iGYP/MqIz/ + yaOG/8afgP/BmXn/vZNy/7mObP+1iGX/sIJf/6x9WP+nd1H/o3FK/55rQ/+UXTL/kFku/49YLf+NVy3/ + i1Ys/4pVLP+IVCv/hlMr/4VSKv+DUSr/glAp/4FQK/+Takr/l3FT/4pnTPQYEg2pAAAAnwAAAIgAAABC + AAAAPwAAACYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAADkAAAA/AAAAVwAAAJwAAACfVllYyZ2hoP+eoqH/ + u769/8bIx//ExsX/wsXE/8DDwv+/wsH/vcC//7u+vf+6vbz/uLu6/7e5uP+1uLf/s7a1/7K1s/+ws7L/ + rrKw/6ywrv+rrq3/qa2r/7K1tP+3urr/rK+u/kpLS8EAAACfAAAAnQAAAF4AAAA/AAAAPQAAABMAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVAAAAPgAAAD8AAABj + AAAAngAAAJ9lSTPJtoRd/7aEXf+tdUn/pGU0/7mIYv/LqIz/yaOG/8aegP/BmHn/vZNy/7mNbP+0iGX/ + sIJe/6x8V/+nd1H/o3FK/51qQ/+UXDL/kFku/45YLf+NVy3/i1Ys/4lVLP+IVCv/hlMr/4VSKv+DUSr/ + glAp/4JSLP+UbEz/l3FT/4RjSO4PCwilAAAAnwAAAIEAAABAAAAAPwAAACAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAA1 + AAAAPwAAAFAAAACZAAAAn0ZIR7+coJ/+naGg/7e6uf/GyMf/xMbF/8LFxP/Bw8L/v8LB/73Av/+8v73/ + ur28/7i7uv+3urn/tbi3/7O2tf+ytbT/sLOy/66ysP+tsK//q66t/6mtq/+ytrT/t7q6/6uvrv5ISkrA + AAAAnwAAAJ0AAABdAAAAPwAAAD0AAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVAAAAPgAAAD8AAABkAAAAngAAAJ9mSjTKtoRd/7aEXf+tdUn/ + pGU0/7qKZP/Lp4z/yKOF/8aef//AmHj/vJJy/7iNa/+0h2T/sIJe/6t8V/+ndlH/onFJ/51pQf+TXDH/ + kFku/45YLf+NVy3/i1Ys/4lVLP+IVCv/hlMr/4VSKv+DUSr/gVAp/4NTLv+Vbk//lnFS/31eRegIBgSi + AAAAnwAAAHgAAAA/AAAAPwAAABoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAMQAAAD8AAABKAAAAlQAAAJ83ODe3mp6d/J2hoP+ztrX/ + xsjH/8TGxv/CxcT/wcPC/7/Cwf+9wL//vL+9/7q9vP+4u7r/t7q5/7W4t/+ztrX/srW0/7Czsv+usrD/ + rbCv/6uurf+praz/s7a1/7e6uv+rrq7+SElJwAAAAJ8AAACdAAAAXQAAAD8AAAA9AAAAEgAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAW + AAAAPgAAAD8AAABlAAAAnwAAAJ9oSzXKtoRd/7aEXf+tdEj/pGU0/7uMZv/Lp4v/yKKF/8Wdf//AmHj/ + vJJx/7iMa/+0h2T/r4Fd/6t8V/+mdlD/onBJ/5xpQf+SWzD/kFku/45YLf+MVy3/i1Ys/4lVLP+IVCv/ + hlMr/4VSKv+DUSn/gVAp/4RVMP+Wb1D/lnFS/3RXQOEDAgKgAAAAnwAAAG8AAAA/AAAAPgAAABQAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAACsAAAA/ + AAAARgAAAI8AAACfKCkpsJebmvmdoaD/r7Kx/8bIx//Exsb/wsXE/8HDwv+/wsH/vsC//7y/vf+6vbz/ + ubu6/7e6uf+1uLf/tLe1/7K1tP+ws7L/r7Kx/62wr/+rrq3/qq2s/7O2tf+4u7r/q66u/UdISL8AAACf + AAAAnQAAAFwAAAA/AAAAPQAAABIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWAAAAPgAAAD8AAABmAAAAnwAAAJ9pTDbL + toRd/7aEXf+tdEj/pGU0/7yNaf/Lp4v/yKKE/8Wdfv/Al3f/vJJx/7iMav+0hmP/r4Fd/6t7Vv+mdlD/ + onBI/5xoP/+SWy//kFku/45YLf+MVy3/i1Ys/4lVLP+IVCv/hlMr/4VSKv+DUSn/gVAp/4ZXM/+XcFL/ + lnFS/2pPOtkBAACfAAAAnwAAAGYAAAA/AAAAPQAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlAAAAPwAAAEIAAACIAAAAnxscHKqSlpX1naGg/6uurf/GyMf/ + xMfG/8PFxP/Bw8L/v8LB/77Av/+8v77/ur28/7m7uv+3urn/tbi3/7S3tf+ytbT/sLSy/6+ysf+tsK// + q6+t/6qtrP+ztrX/uLu6/6qurf1GR0e/AAAAnwAAAJ0AAABcAAAAPwAAAD0AAAARAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAXAAAAPgAAAD8AAABmAAAAnwAAAJ9qTTbMtoRd/7aEXf+tdEj/pGU1/72Oa//Lp4r/ + yKKE/8Wdfv/Al3f/vJFw/7eMav+zhmP/r4Bd/6t7Vv+mdU//oW9I/5tnPv+SWi//kFgu/45XLf+MVy3/ + i1Ys/4lUK/+IUyv/hlMq/4RSKv+DUSn/gVAp/4haNv+YcVP/lnFS/11GM9AAAACfAAAAngAAAF4AAAA/ + AAAAOwAAAAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHwAAAD8AAABA + AAAAgQAAAJ8QERGmjI+O752hoP+nq6r/xcfG/8THxv/DxcT/wcPC/7/Cwf++wL//vL++/7q9vP+5u7r/ + t7q5/7W4t/+0t7X/srW0/7C0sv+vsrH/rbCv/6uvrf+qraz/s7a1/7i7uv+qrq39RUZGvgAAAJ8AAACc + AAAAWwAAAD8AAAA9AAAAEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXAAAAPgAAAD8AAABn + AAAAnwAAAJ9sTjfNtoRd/7aEXf+tdEf/pGY1/76Qbf/Kpor/yKGE/8Scff+/lnf/u5Fw/7eLaf+zhmL/ + r4Bc/6p6Vf+mdU//oW9I/5pmPf+RWi//kFgu/45XLf+MViz/i1Us/4lUK/+IUyv/hlMq/4RRKv+DUCn/ + gU8p/4pdOv+YcVP/lnBS/087K8cAAACfAAAAnAAAAFcAAAA/AAAAOQAAAAgAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAABkAAAA/AAAAPwAAAHcAAACfCAgIooOHhuidoaD/pKin/8PGxf/Ex8b/ + w8XE/8HEw/+/wsH/vsC//7y/vv+6vbz/uby6/7e6uf+1uLf/tLe1/7K1tP+wtLL/r7Kx/62wr/+rr63/ + qq2s/7O3tf+4u7r/qq2s/URGRb4AAACfAAAAnAAAAFsAAAA/AAAAPQAAABEAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAPwAAAD8AAABoAAAAnwAAAJ9tTzjOtoRd/7aEXf+tc0f/ + pWY1/76Sbv/Kpon/x6GD/8Scff+/lnb/u5Fv/7eLaf+zhWL/roBc/6p6Vf+ldE7/oW5H/5lkO/+RWS7/ + kFgu/45XLf+MViz/i1Us/4lUK/+IUyv/hlMq/4RRKv+DUCn/gU8p/41gPv+YcVP/lXBS/kEwI74AAACf + AAAAmQAAAFAAAAA/AAAANQAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAAAAPgAAAD8AAABt + AAAAnwMDA6B5fHzgnaGg/6Kmpf/CxcT/xMfG/8PFxP/BxMP/v8LB/77BwP+8v77/ur28/7m8u/+3urn/ + tbi3/7S3tv+ytbT/sbSz/6+ysf+tsK//rK+u/6qurP+0t7b/uLu6/6qtrP1DRES9AAAAnwAAAJwAAABa + AAAAPwAAAD0AAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY + AAAAPwAAAD8AAABpAAAAnwAAAJ9uUDjOtoRd/7aEXf+sc0f/pWY2/7+TcP/KpYn/x6GD/8ObfP+/lnb/ + u5Bv/7eKaP+yhWH/rn9b/6p6VP+ldE7/oW5H/5ljOv+RWS7/kFgu/45XLf+MViz/i1Us/4lUK/+HUyv/ + hlIq/4RRKv+CUCn/gU8p/49jQv+YcVP/k25R/DMmHLcAAACfAAAAlQAAAEsAAAA/AAAAMgAAAAMAAAAA + AAAAAAAAAAAAAAAAAAAADQAAADwAAAA/AAAAYwAAAJ8AAACfbG9v152hoP+gpKP/wMLB/8XHxv/DxcT/ + wcTD/8DCwf++wcD/vL++/7u+vP+5vLv/t7q5/7a5uP+0t7b/sra0/7G0s/+vsrH/rbGv/6yvrv+qrqz/ + tLe2/7i7uv+praz9QkNDvQAAAJ8AAACcAAAAWgAAAD8AAAA8AAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAPwAAAD8AAABpAAAAnwAAAJ9wUTnP + toRd/7aEXf+sc0f/pWc2/8CUcv/KpYj/x6CC/8ObfP+/lXX/upBu/7aKaP+yhGH/rn9b/6l5VP+lc03/ + oG5G/5hiOP+RWS7/j1gt/45XLf+MViz/i1Us/4lUK/+HUyv/hlIq/4RRKv+CUCn/gVAq/5FmRv+YcVP/ + kGxP+ScdFbEAAACfAAAAkAAAAEYAAAA/AAAALQAAAAEAAAAAAAAAAAAAAAkAAAA6AAAAPwAAAFsAAACd + AAAAn11gX82doaD/n6Kh/72/v//Fx8b/w8XE/8HEw//AwsH/vsHA/7y/vv+7vrz/uby7/7e6uf+2ubj/ + tLe2/7O2tP+xtLP/r7Kx/62xr/+sr67/q66t/7S3tv+4u7r/qayr/UFDQrwAAACfAAAAnAAAAFoAAAA/ + AAAAPAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAZAAAAPwAAAD8AAABqAAAAnwAAAJ9xUjrQtoRd/7aEXf+sc0b/pWc3/8GVc//KpYj/ + x6CC/8Kae/++lXX/uo9u/7aKaP+yhGH/rn5a/6l5U/+lc03/oG1G/5dhN/+RWS7/j1gt/45XLf+MViz/ + ilUs/4lUK/+HUyv/hVIq/4RRKv+CUCn/glEr/5NpSf+XcVP/jGlN9RwVD6sAAACfAAAAigAAAEMAAAA/ + AAAAKAAAAAAAAAAGAAAANwAAAD8AAABTAAAAmwAAAJ9NT0/DnaGg/56iof+6vLv/xcfG/8PFxP/CxMP/ + wMLB/77BwP+9v77/u768/7m8u/+4urn/trm4/7S3tv+ztrT/sbSz/6+zsf+tsa//rK+u/6uurf+0t7b/ + uLu6/6isq/1AQkG8AAAAnwAAAJwAAABZAAAAPwAAADwAAAAPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAPwAAAD8AAABr + AAAAnwAAAJ9zUzrQtoRd/7aEXf+sc0b/pmc3/8GWdf/JpIf/x6CB/8Kae/++lHT/uo9t/7aJZ/+yhGD/ + rX5Z/6l4U/+kc0z/n21F/5ZgNv+RWS7/j1gt/45XLf+MViz/ilUs/4lUK/+HUyv/hVIq/4RRKv+CUCn/ + g1Is/5VrTP+XcVP/h2VK8RINCqcAAACfAAAAgwAAAEEAAAA/AAAAJAAAADMAAAA/AAAATQAAAJcAAACf + PT8+upufnv2doaD/trm4/8XHxv/DxsX/wsTD/8DCwf++wcD/vb++/7u+vf+5vLv/uLq5/7a5uP+0t7b/ + s7a0/7G0s/+vs7H/rbGv/6yvrv+rrq3/tLe3/7i7u/+oq6v8P0FAuwAAAJ8AAACbAAAAWQAAAD8AAAA8 + AAAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaAAAAPwAAAD8AAABrAAAAnwAAAJ90VDvRtoRd/7aEXf+sckb/ + pmg4/8KYd//JpIf/xp+B/8Kaev++lHT/uo9t/7aJZv+xg2D/rX5Z/6h4Uv+kckz/n2xF/5ZfNP+RWS7/ + j1gt/45XLf+MViz/ilUs/4lUK/+HUyv/hVIq/4RRKv+CUCn/hFMu/5ZtTv+XcVP/gGBG6goIBqMAAACf + AAAAewAAAEEAAABhAAAAVAAAAEgAAACSAAAAny4wL7OZnJv7naGg/7G0s//Fx8b/w8bF/8LEw//Aw8L/ + vsHA/72/vv+7vr3/uby7/7i6uf+2ubj/tLe2/7O2tP+xtLP/r7Ox/66xsP+sr67/q66t/7S4t/+4u7v/ + qKur/D5AP7sAAACfAAAAmwAAAFgAAAA/AAAAPAAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAb + AAAAPwAAAD8AAABsAAAAnwAAAJ91VTzStoRd/7aEXf+sckX/pmk5/8OZeP/JpIb/xp+A/8KZev++lHP/ + uY5s/7WJZv+xg1//rX1Y/6h4Uv+kckv/n2xE/5VeM/+RWS7/j1gt/41XLf+MViz/ilUs/4lUK/+HUyv/ + hVIq/4RRKv+CUCn/hVUw/5dvUP+XcVP/eFpB5AQDAqEAAACfAAAAiAAAAG4AAABxAAAAlQAAAJ8hIiGt + lJiX952hoP+tsK//xcjH/8PGxf/CxMP/wMPC/77BwP+9wL//u769/7m8u/+4u7r/trm4/7S3tv+ztrX/ + sbSz/6+zsf+usbD/rK+u/6uurf+1uLf/uLu7/6irqvw9Pz67AAAAnwAAAJsAAABYAAAAPwAAADwAAAAP + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbAAAAPwAAAD8AAABtAAAAnwAAAJ93VjzT + toRd/7aEXf+sckX/pmk5/8Oaef/Jo4b/xp+A/8GZef+9k3L/uY5s/7WIZf+xg1//rH1Y/6h3Uf+jcUv/ + nmtD/5RdMv+RWS7/j1gt/41XLf+MViz/ilUs/4lUK/+HUyv/hVIq/4RRKv+CUCn/hlcz/5hwUf+XcVP/ + blI83AEBAawAAAC2AAAAjwAAAKMAAAC3FBUUro+SkfKdoaD/qa2s/8XHxv/DxsX/wsTD/8DDwv+/wcD/ + vcC//7u+vf+6vLv/uLu6/7a5uP+1uLb/s7a1/7G0s/+ws7L/rrGw/6yvrv+rr63/tbi3/7i7u/+oq6r8 + PD49ugAAAJ8AAACbAAAAVwAAAD8AAAA8AAAADgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAbAAAAPwAAAD8AAABuAAAAnwAAAJ94Vz3UtoRd/7aEXf+sckX/p2o6/8Saev/Jo4b/ + xp6A/8GYef+9k3L/uY1r/7WIZf+wgl7/rH1X/6d3Uf+jcUr/nmpC/5NcMf+RWS7/j1gt/41XLf+MViz/ + ilUs/4lUK/+HUyv/hVIq/4RRKv+CUCn/iFo1/5hxUv+XcVP/XUUz3QAAALYAAADNAAAAxAgICLtmaGfw + lZmY/6apqP/Ex8b/xMbF/8LEw//Aw8L/v8HA/73Av/+7vr3/ur27/7i7uv+2ubj/tbi2/7O2tf+xtbP/ + sLOy/66xsP+ssK7/q6+t/7W4t/+5vLv/p6uq/Ds9PboAAACfAAAAmwAAAFcAAAA/AAAAPAAAAA4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAPwAAAD8AAABv + AAAAnwEAAJ95WD7UtoRd/7aEXf+rcUT/p2o7/8SbfP/Io4X/xZ5//8GYeP+9k3L/uY1r/7SHZP+wgl7/ + rHxX/6d2UP+jcUn/nWlB/5NcMP+QWS7/j1gt/41XLf+MViz/ilUs/4hUK/+HUyv/hVIq/4RRKv+CUCn/ + ilw5/5lxU/+XcVP/Szgp4gAAANsBAQHbT1FQ7XZ5eP98f37/qqyr/77AwP/CxMP/wMPC/7/BwP+9wL// + u769/7q9u/+4u7r/trm4/7W4tv+ztrX/sbWz/7Czsv+usbD/rLCu/6uvrf+1uLf/uby7/6eqqfw6PDy5 + AAAAnwAAAJsAAABWAAAAPwAAADsAAAAOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAPwAAAD8AAABvAAAAnwEBAJ97WT/VtoRd/7aEXf+rcUT/ + qGs8/8Wcff/IooX/xZ1//8CYeP+8knH/uI1r/7SHZP+wgV3/rHxW/6d2UP+icEn/nGhA/5NbMP+QWS7/ + j1gt/41XLf+MViz/ilUs/4hUK/+HUyv/hVIq/4NRKv+CUCn/jF89/5lxU/+WcFL/Oiwg6CcoKPI+QD// + bG5t/4KDg/+Iior/qqyr/7m8u/+/wcD/vcC//7u+vf+6vbv/uLu6/7a5uP+1uLb/s7a1/7G1s/+ws7L/ + rrKw/6ywrv+sr67/tbi4/7m8u/+mqqn7Ojs7uQAAAJ8AAACaAAAAVgAAAD8AAAA7AAAADgAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAd + AAAAPwAAAD8AAABwAAAAnwEBAZ98Wj/WtoRd/7aEXf+rcUT/qGw9/8Wdfv/IooT/xZ1+/8CXd/+8knH/ + uIxq/7SHY/+wgV3/q3tW/6d2UP+icEj/nGg//5NbL/+QWS7/j1gt/41XLf+MViz/ilUs/4hUK/+HUyv/ + hVIq/4NRKv+CUCn/j2NB/5lxU/+VcFL/VEtC/zs9PP9GR0b/eHl5/4CCgv+LjYz/qayr/7S3tv+7vr3/ + ur28/7i7uv+2ubj/tbi3/7O2tf+ytbP/sLOy/66ysP+ssK7/rK+u/7W4uP+5vLv/pqmp+zk6OrgAAACf + AAAAmgAAAFUAAAA/AAAAOwAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdAAAAPwAAAD8AAABxAAAAnwEBAZ99WkDX + toRd/7aEXf+rcUP/qW0+/8Wdf//IooT/xJ1+/8CXd/+8kXD/uIxq/7SGY/+vgVz/q3tW/6Z1T/+ib0j/ + m2c+/5JaL/+QWS7/j1gt/41XLf+LViz/ilUs/4hUK/+HUyv/hVIq/4NRKv+CUCn/kWZF/5lxU/+TblL/ + UElD/0BBQP9JSkn/e3x8/35/f/+am5v/pqin/7Czsv+4u7r/t7m4/7W4t/+ztrX/srWz/7Czsv+usrD/ + rLCu/6yvrv+1ubj/uby7/6WpqPs4OTm4AAAAnwAAAJoAAABVAAAAPwAAADsAAAANAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAeAAAAPwAAAD8AAABxAAAAnwEBAaB+W0DXtoRd/7aEXf+rcUP/qW4//8aef//IoYP/ + xJx9/8CWdv+8kXD/t4xp/7OGYv+vgFz/q3tV/6Z1T/+hb0f/mmU8/5JaLv+QWS7/j1gt/41XLf+LViz/ + ilUs/4hUK/+GUyv/hVIq/4NRKv+CUSr/k2lI/5hxU/+PbVH/SkZB/z4/P/9cXl3/e318/4aIh/+ipaT/ + oqSj/62wr/+1uLf/s7a1/7K1tP+ws7L/rrKw/62wr/+sr67/trm4/7m8u/+lqaj7Nzg4twAAAJ8AAACa + AAAAVQAAAD8AAAA7AAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAPwAAAD8AAABz + AAAAnwIBAaB/XEHYtoRd/7aEXf+qcEP/qm5A/8afgP/HoYP/xJx8/7+Wdv+7kW//t4tp/7OGYv+vgFz/ + qnpV/6Z0Tv+hb0f/mmQ7/5JaLv+QWS7/jlgt/41XLf+LViz/iVUs/4hUK/+GUyv/hVIq/4NRKv+DUiv/ + lGtL/5hxU/98Ykz/PT4+/0NFRf95e3r/enx7/5+hoP+foaH/nqGg/6uurf+ytbT/sLOy/6+ysf+tsK// + rK+u/7a5uP+5vLv/pain+zY4N7cAAACfAAAAmgAAAFQAAAA/AAAAOwAAAAwAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfAAAAPwAAAD8AAABzAAAAnwIBAaCAXULZtoRd/7aEXf+qcEP/ + qnBC/8efgf/HoYP/w5t8/7+Wdv+7kG//t4to/7OFYf+uf1v/qnpU/6V0Tv+hbkf/mWM5/5JaLv+QWS7/ + jlgt/41XLf+LViz/iVUs/4hUK/+GUyv/hVIq/4NRKv+FVC//mXJU/5dwU/9BPz3/PD08/3Bycf92eHj/ + lpmY/5yfnf+cnp3/nJ6d/6ywrv+vsrH/rbCv/6yvrv+2ubj/uby7/6Sop/s1Nza2AAAAnwAAAJkAAABU + AAAAPwAAADsAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf + AAAAPwAAAD8AAAB0AAAAnwIBAaCBXkLZtoRd/7aEXf+qcEL/q3BD/8eggf/HoIL/w5t8/7+Vdf+7kG7/ + t4po/7KFYf+uf1v/qnlU/6V0Tf+hbkb/mGI4/5JaLv+QWS7/jlgt/41XLf+LViz/iVUs/4hUK/+GUyv/ + hVIq/4NRKv+Yb0//mXJU/0lEP/87PDv/aWpq/3R2df+Rk5L/mZyb/5ibmv+Ym5r/naCf/62wr/+ssK7/ + trm4/7m8u/+kp6f6NDY2tgAAAJ8AAACZAAAAUwAAAD8AAAA6AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAPwAAAD8AAAB1AAAAnwICAaCDX0Pa + toRd/7aEXP+qcEL/q3JE/8eggv/HoIL/w5p7/7+Vdf+6j27/topo/7KFYf+uf1r/qnlT/6VzTf+gbUb/ + l2E2/5FaLv+QWS7/jlgt/4xXLf+LViz/iVUs/4hUK/+GUyv/hVIr/5tyUv+ac1T/REE9/zo7Ov9oamr/ + cnRz/4+RkP+WmZj/lpiX/5WYl/+Ul5b/qKuq/7a6uP+5vLv/pKem+jM1NbYAAACfAAAAmQAAAFMAAAA/ + AAAAOgAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAgAAAAPwAAAD8AAAB1AAAAnwICAaCDX0PbtoRd/7aEXP+qb0L/rHNG/8eggv/HoIH/ + wpp7/76VdP+6j23/toln/7KEYP+uflr/qXlT/6VzTP+gbUX/lmA1/5FaLv+QWS7/jlgt/4xXLf+LViz/ + iVUs/4hUK/+QYTz/nXVV/5JuUf85OTn/Ojo6/25wb/9wcnH/kJOS/5OWlf+TlZT/kpWU/5KVlP+srq3/ + uby7/6OnpvozNDS1AAAAnwAAAJkAAABTAAAAPwAAADoAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhAAAAPwAAAD8AAAB2 + AAAAnwMCAaCFYETbtoRd/7aEXP+qb0L/rXRH/8ehg//Gn4H/wpl6/76UdP+6j23/toln/7KEYP+tfln/ + qXhS/6RyTP+gbEX/ll80/5FZLv+QWC7/jlct/4xXLf+LViz/iVQr/5xwTv+edVX/Y1NF/zg4OP9AQUH/ + bW9u/21vb/9+gYD/kJOS/5CSkf+QkpH/mZyb/6qtrP+jpqb6MjMztQAAAJ8AAACYAAAAUgAAAD8AAAA6 + AAAACwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhAAAAPwAAAD8AAAB3AAAAnwMCAqCGYUTctoRd/7aEXP+qb0H/ + rXVJ/8ihg//Gn4D/wpl6/76Uc/+6jmz/tolm/7GDX/+tfVn/qXhS/6RyS/+fbEP/lV4z/5FZLv+QWC7/ + jlct/4xWLP+LVSz/nG9M/7iijv+mqqj/OTs6/zY3N/9MTk3/a21s/2ttbP99f37/jZCP/5eZmP+ZnJv/ + k5eW+jEzMrQAAACfAAAAmAAAAFIAAAA/AAAAOgAAAAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAi + AAAAPwAAAEAAAAB4AAAAnwMDAqCHYkXdtoRd/7aDXP+qb0H/rnZL/8ihg//Gn4D/wpl5/76Tc/+5jmz/ + tYhm/7GDX/+tfVj/qHdR/6RyS/+ea0P/lV0y/5FZLv+QWC7/jlct/4xWLP+ojHH/2N7b/9nf3P+fo6H/ + Nzg3/zU2Nv9NT07/aWtq/2lrav+Fh4b/l5mZ/4WIh/ooKSm1AAAAnwAAAJgAAABRAAAAPwAAADoAAAAL + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiAAAAPwAAAEAAAAB4AAAAnwQDAqCIY0Xd + toRd/7aDXP+qb0H/r3dM/8ihg//GnoD/wZh5/72Tc/+5jWv/tYhl/7GCXv+sfVj/qHdR/6NxSv+YYTb/ + k1ov/5FZLv+QWC7/o4Fk/87V0f/S2db/2d/c/9nf3P+YnJr/NDY1/zQ1Nf9OT0//bnBv/3Bycv92eHf6 + JicntAAAAJ8AAACYAAAAUQAAAD8AAAA5AAAACwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAADQAAAA4AAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAjAAAAPwAAAEAAAAB5AAAAnwQDAqCJY0betoRd/7aDXP+qb0D/sHlO/8ehg//Fnn// + wZh4/72Scv+5jWv/tYdk/7CCXv+sfFf/nWY8/5ZcMP+UWy//k1ov/6aAYP/S2NP/z9fT/8/X0//S2tb/ + 2d/c/9nf3P+Qk5L/MzQ0/zc3N/9WV1b/X2Jh+xkaGsYAAACnAAAAlwAAAFEAAAA/AAAAOQAAAAoAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAbAAAAMwAAAD8AAAA/ + AAAAPwAAAD8AAAA4AAAAIgAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjAAAAPwAAAEAAAAB6 + AAAAnwUDAqGHYkXktoRd/7aDXP+qbkD/sXpQ/8ihg//Fnn//wZh4/72Scf+5jWr/tIdj/6JrQP+ZXjD/ + l10w/5ZcL/+of13/3ODc/9ng3f/T2tf/z9fT/8/X0//T2tf/2d/c/9nf3P+JjYv/Njg3/y8wMP0TFBPS + AAAAtwAAALEAAABeAAAAPwAAADkAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAQAAAANwAAAD8AAAA/AAAAPwAAAEUAAABHAAAAQAAAAD8AAAA/AAAAOwAAABQAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkAAAAPwAAAEAAAAB6AAAArgQDAreGYUXntoRd/7aDXP+pbkD/ + sXtR/8ehgv/FnX7/wZd3/7yRcP+nb0X/nGAy/5tfMf+ZXjD/qn1Z/+fn4//l6uj/3+Xi/9nf3P/T2tb/ + z9fT/8/X0//T29f/2d/c/9nf3P9+gX/+CgsL4gAAANsAAAC+AAAAewAAAG0AAABFAAAACgAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFgAAAD4AAAA/AAAASQAAAHQAAACU + AAAAnwAAAJ8AAACZAAAAfgAAAFAAAAA/AAAAPgAAABcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAk + AAAAPwAAAFgAAACbAAAAtwQDAtGBXUHztoRd/7aDXP+pbkD/qm9B/7aEXf+2hF3/qG9D/59iM/+eYTL/ + nGAx/6p6VP/x7ur/8fTz/+vv7f/l6uf/3+Ti/9nf3P/T2tb/z9fT/8/X0//U29f/2d/c/9nf3P9jZmTq + AAAA2AAAALsAAACFAAAAaQAAAEMAAAAPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAABAAAAA+AAAAPwAAAGAAAACaAAAAnwAAAJ8AAACfAAAAnwAAAJ8AAACfAAAAnQAAAGUAAAA/ + AAAAPgAAABUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7AAAAbgAAAG8AAAC7AAAA2wcGBd2Na1D9 + toRd/7aDXP+pbkD/pGU0/6RlNP+lZzf/rXZM/614T/+pelP/y83F/+/x8P/3+fj/8fTy/+vu7f/l6ef/ + 3+Th/9jf3P/S2db/z9fT/8/X0//U29j/2d/c/9je2/9hZGPWAAAAtgAAALIAAABhAAAAPwAAADsAAAAN + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAOAAAAD8AAABiAAAAngAAAJ8aGhmy + R0ZC3lhXUvZaWVT5TU1J5yUlI7sAAACfAAAAnwAAAGUAAAA/AAAAPgAAABMAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAFQAAAD8AAABbAAAAlAAAALgBAQHPLC0s9T4/Pf+Qb1P/toRd/7aEXf+yfVP/sXtR/7WCWv+1g1z/ + uY5r/9TUzf/S2dX/0NjU//Dz8f/3+Pj/8fPy/+vu7P/l6ef/3uTh/9jf2//S2dX/z9fT/8/X0//V3Nj/ + 2d/c/9fd2v5bXVzMAAAAogAAAJsAAABXAAAAPwAAADoAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAB8AAAA/AAAATgAAAJwAAACfMjIvx11cV/5eXVj/Xl1Y/15dWP9eXVj/Xl1Y/zY1MssAAACf + AAAAngAAAGEAAAA/AAAAPQAAABEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAA9AAAAPwAAAGcAAACtAQEBt1FTUuNQUlH/ + PT8+/0tLSv+Pb1b/toRd/7aEXf+2hF3/toRd/6Z7Wv+sqaH/2d/c/9nf3P/R2dX/0dnV//H08v/3+Pj/ + 8fPy/+ru7P/k6eb/3uTh/9je2//S2dX/z9fT/8/X0//V3Nj/2d/c/9bc2f1XWVi7AAAAnwAAAJoAAABU + AAAAPwAAADkAAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAOAAAAD8AAACBAAAAnycmJLxeXVj/ + Xl1Y/1JQS/9BPzr/Pz03/05NR/9eXVj/Xl1Y/zIyL8cAAACfAAAAnQAAAF0AAAA/AAAAPAAAAA4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAL + AAAAOwAAAD8AAABdAAAAngAAAJ9RU1LXdnl4/3h7ev9hYmL/SUpK/0lKSf9cVE3/dWFR/3pkUf9oWU7/ + SUhH/0pLS/+yt7X/2d/c/9jf3P/R2dX/0tnW//P19P/3+Pf/8PPy/+ru7P/k6eb/3uPh/9je2//R2dX/ + z9fT/8/X0//W3Nn/2d/c/9Ta1/xOUE+4AAAAnwAAAJgAAABRAAAAPwAAADcAAAAHAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAA0AAAA/AAAASAAAAJ4CAgKgVlVR815dWP9NS0b/NjQu/zY0Lv82NC7/NjQu/0tJRP9eXVj/ + Xl1Y/y4uK8MAAACfAAAAnAAAAFoAAAA/AAAAOwAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAADgAAAA/AAAAVgAAAJwAAACfU1VUxp2hoP+Hion/ + jY+O/5KTk/9rbWz/SktL/0dJSP9HSEf/RkdH/0ZHRv9FRkb/REZF/0tMS/+3vLr/2d/c/9je2//R2NT/ + 09rW//T29f/2+Pf/8PPx/+rt7P/k6Ob/3ePg/9fe2//R2dX/z9fT/8/X0//W3dn/2d/c/9PY1ftFR0a1 + AAAAnwAAAJcAAABOAAAAPwAAADYAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGQAAAD8AAABeAAAAnx8fHbZeXVj/ + WllU/zc1L/82NC7/NjQu/zY0Lv82NC7/NjQu/01LRv9eXVj/XVxX/ioqJ78AAACfAAAAmwAAAFYAAAA/ + AAAAOgAAAAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAjAAAAOQAAAD0AAAA0AAAAJwAAABsAAAAO + AAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAA0 + AAAAPwAAAE8AAACYAAAAn0NEQ72coJ/+nqKh/7i7u/+mqKf/kZOS/5CSkf+Iion/cXNy/2VmZv9iY2L/ + aGpq/3l7ev9XWVj/Q0RE/0xOTf+8wb7/2d/c/9je2//Q2NT/1NvX//X39v/29/f/8PLx/+rt6//j6Ob/ + 3ePg/9fe2v/Q2NT/z9fT/8/X0//W3dr/2d/c/9DW0/k8Pj2yAAAAnwAAAJUAAABLAAAAPwAAADQAAAAF + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAeAAAAPwAAAGkAAACfMTAtxl5dWP9QT0r/NjQu/zY0Lv82NC7/NjQu/zY0Lv82NC7/ + NjQu/05NSP9eXVj/XVxX/SYlI7sAAACfAAAAmgAAAFMAAAA/AAAAOQAAAAkAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC + AAAAMgAAAD8AAAA/AAAAPwAAAD8AAAA/AAAAPwAAAD8AAAA+AAAANAAAACcAAAAbAAAADgAAAAMAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAALwAAAD8AAABJAAAAlAAAAJ8zNDS1mZ2c/J2hoP+1uLf/ + w8XE/8HDwv+tr67/k5WU/46Qjv+Mjo7/i42M/4qMi/+Ii4r/iIqI/4SGhf9TVVT/QkND/05QT//BxsT/ + 2d/c/9je2//Q2NT/1dzY//b39//29/b/7/Lx/+nt6//j6OX/3ePg/9fd2v/Q2NT/z9fT/9DX0//X3dr/ + 2d/c/87T0Pc0NjWvAAAAnwAAAJIAAABJAAAAPwAAADIAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAA/AAAAaAAAAJ8vLizE + Xl1Y/1JQS/82NC7/NjQu/zY0Lv82NC7/NjQu/zY0Lv82NC7/NzUv/1BPSf9eXVj/XFtW/CIhILgAAACf + AAAAmAAAAFAAAAA/AAAANwAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIAAAA/AAAARwAAAH8AAACNAAAAfAAAAGkAAABW + AAAARAAAAD8AAAA/AAAAPwAAAD8AAAA/AAAAPgAAADQAAAAnAAAAGwAAAA4AAAADAAAAAQAAACoAAAA/ + AAAARQAAAI4AAACfJSYmr5aamfidoaD/sbSz/8PFxP/Bw8L/v8LB/77Av/+6vbz/q62s/56gn/+XmZj/ + lJeW/5eZmP+RlJP/hYiG/4CDgv9QUlH/RkdH/1VXVv/Dycb/2d/c/9je2//Q2NT/1t3Z//f4+P/19/b/ + 7/Lx/+nt6//j5+X/3OLf/9bd2v/Q2NT/z9fT/9DY1P/X3tr/2d/c/8rQzfUsLS2sAAAAnwAAAJAAAABH + AAAAPwAAADAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAFwAAAD8AAABaAAAAnxcXFq9eXVj/XVxX/zw6Nf82NC7/NjQu/zY0Lv82NC7/ + NjQu/zY0Lv82NC7/NzUv/1JQS/9eXVj/W1pV+x4eHLUAAACfAAAAlgAAAE4AAAA/AAAANQAAAAQAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO + AAAAPgAAAD8AAACEAAAAnwAAAJ8AAACfAAAAnwAAAJ8AAACeAAAAkAAAAH0AAABqAAAAVgAAAEQAAAA/ + AAAAPwAAAD8AAAA/AAAAPwAAAD4AAAA3AAAAPwAAAEIAAACHAAAAnxkZGamRlJP0naGg/62wr//DxcT/ + wcTD/7/Cwf++wL//vL++/7q9vP+5vLr/t7q5/7W4t/+0t7X/srW0/6+ysf+PkpH/g4aF/4eJiP9TVFT/ + OTs6/CkqKuXEycb72d/c/9fe2//Q2NT/197b//f5+P/19/b/7/Lw/+ns6//i5+X/3OLf/9bd2f/Q19T/ + z9fT/9DY1P/X3tv/2d/c/8fNyvMlJiWqAAAAnwAAAI0AAABFAAAAPwAAAC4AAAACAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAAAAPwAAAEMAAACa + AAAAn0tKRuReXVj/WlhT/zs5M/82NC7/NjQu/zY0Lv82NC7/NjQu/zY0Lv82NC7/Ozkz/11bV/9hYFv/ + WllV+RoaGLIAAACfAAAAlAAAAEoAAAA/AAAAJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAADUAAAA/AAAAZAAAAJ8KCgqjcXRz2lxeXcw6Ozu5 + ERERpgAAAJ8AAACfAAAAnwAAAJ8AAACfAAAAngAAAJAAAAB9AAAAagAAAFYAAABEAAAAPwAAAD8AAABA + AAAAfgAAAJ8ODw+lio6N7p2hoP+qraz/w8XE/8HEw/+/wsH/vsHA/7y/vv+6vbz/uby7/7e6uf+1uLf/ + tLe2/7K1tP+wtLL/r7Kx/62wr/+WmZj/jI6N/25xcPgLCwvbAAAA2yYnJ9zL0M342d/c/9fe2v/Q2NT/ + 2d/c//j5+P/19/b/7/Hw/+js6v/i5+X/3OLf/9Xc2f/P19P/z9fT/9DY1P/Y3tv/2d/c/8PJxvAeHx6o + AAAAnwAAAIoAAABEAAAAPwAAACwAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzAAAAPwAAAHEAAACfDAwLp1RTTvBeXVj/V1ZR/zY0Lv82NC7/ + NjQu/zY0Lv82NC7/NjQu/zs5M/9DQjz/TkxH/21sZ/9jYl3/WVhT9xcWFa8AAACfAAAAiwAAAEAAAAA/ + AAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAh + AAAAPwAAAEkAAACZAAAAn3l7e9Wjp6b/naGg/52hoP+doaD/j5OS8nd7et9bXl3MOjs7uRISEqYAAACf + AAAAnwAAAJ8AAACfAAAAnwAAAJ4AAACQAAAAfQAAAH8AAACfBwcHooKFhOedoaD/pqqp/8LEw//BxMP/ + v8LB/77BwP+8v77/ur28/7m8u/+3urn/tbi3/7S3tv+ytbT/sLSy/6+ysf+vsrH/uby7/7e6uf98fn74 + GBgYwgAAALsAAADSAAAAuzM0M8PO09H62d/c/9fd2v/P19P/2uDd//n6+f/09vX/7vHw/+js6v/i5+T/ + 3OLf/9Xc2P/P19P/z9fT/9DY1P/Y3tv/2d/c/7/Ewu4YGRimAAAAnwAAAIcAAABCAAAAPwAAACkAAAAB + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAA/ + AAAAQgAAAJEAAACfExIRrF1cV/5eXVj/Ozkz/zY0Lv82NC7/NjQu/zY0Lv87OTP/REI8/01LRv9XVVD/ + YWBb/3x8eP9lZF//V1ZS9QsLCqcAAACfAAAAYAAAAD8AAAAiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAD4AAAA/AAAAgwAAAJ9CQ0O24uPj/ubn5//Z29r/ + yczL/7m8u/+orKv/nqGg/52hoP+doaD/naGg/4+TkvJ4e3rfXF5dzDo8O7kSEhKmAAAAnwAAAJ8AAACf + AAAAnwICAqB3eXnenaGg/6Onpv/Bw8L/wcTD/8DCwf++wcD/vL++/7u+vP+5vLv/t7q5/7a5uP+0t7b/ + srW0/7G0s/+vsrH/r7Kx/7q8vP+6vLz/mp6d9SIjI68AAACzAAAArgAAAIEAAACuAAAAs0BCQbbS19X6 + 2d/c/9bd2v/P19P/3OLe//n6+v/09vX/7vHv/+js6v/i5uT/2+He/9Tb1//P19P/z9fT/9DY1P/Y3tv/ + 2d/c/7q/vesSExOkAAAAnwAAAIMAAABBAAAAPwAAACYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAMwAAAD8AAABVAAAAnQAAAJ9DQj/ZXl1Y/1pZVP83NS// + NjQu/zY0Lv82NC7/Ozk0/0VDPf9OTEf/V1VQ/2BfWv9qaGT/dXNv/4mIhf9gX1r/PTw50wAAAJ8AAACC + AAAAPwAAADIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAA0 + AAAAPwAAAGIAAACfCgoKo8nKyvHm5+f/5OXl/+Di4f/g4uH/4ePi/+Hj4v/b3dz/y87N/7y/vv+tsK// + n6Oi/52hoP+doaD/naGg/52hoP+Pk5LyeHt631xeXsw6PDu5a21t1p2hoP+hpaT/v8LB/8LEw//AwsH/ + vsHA/72/vv+7vrz/uby7/7i6uf+2ubj/tLe2/7O2tP+xtLP/r7Ox/6+zsf+6vbz/ur28/5qdnPUiIyKt + AAAAnwAAAJUAAABxAAAAbgAAAHMAAACaAAAAn0pMS7fU2tf72d/c/9bd2f/P19P/3ePg//n6+v/09vX/ + 7vHv/+fr6f/h5uT/2+He/9Pb1//P19P/z9fT/9HY1f/Y3tv/2d/c/7W6uOgNDg6jAAAAnwAAAH8AAABA + AAAAPwAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAcAAAAHAAAAAQAAAAAAAAAAAAAAAwAAAC4AAAA/ + AAAASAAAAJUAAACfLS0qwl5dWP9eXVj/QD85/zY0Lv82NC7/NzUv/zw6NP9FQz7/Tk1H/1hWUf9hX1v/ + amlk/3Nybv98e3f/jIyI/3p5df9TUk7vAAAAnwAAAJUAAAA/AAAAPAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAD8AAABIAAAAmAAAAJ+PkZDU5ufn/+Xn5v/g4uH/ + 4OLh/+Di4f/g4eD/3t/f/9ze3f/b3Nv/2dra/9ja2f/W2Nf/yszL/7y/vv+vsrL/oqal/52hoP+doaD/ + naGg/52hoP+doaD/oKOi/73Av//CxMP/wMLB/77BwP+9v77/u768/7m8u/+4urn/trm4/7S3tv+ztrT/ + sbSz/6+zsf+vs7H/ur28/7q9vP+ZnZz1ISIirQAAAJ8AAACTAAAASwAAAEUAAABiAAAARAAAAFEAAACZ + AAAAn1NVVLrV29j92d/c/9Xc2f/P19P/3+Ti//r6+v/09fX/7fDv/+fr6f/h5uT/2+He/9Pa1v/P19P/ + z9fT/9HZ1f/Y39z/2d/c/6+0suQJCQmiAAAAnwAAAHsAAABAAAAAPwAAACEAAAAMAAAAJAAAADYAAAA/ + AAAAPwAAAD8AAAA+AAAAMwAAACcAAAA3AAAAPwAAAEQAAACLAAAAnxgYFrBbWlX7Xl1Y/0lIQ/82NC7/ + NjQu/zY0Lv83NS//REM9/09NSP9YV1L/YmBb/2tpZf90c27/fXx4/4aFgf+SkY7/i4uH/1lYU/cAAACf + AAAAmwAAAD8AAAA/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAA+ + AAAAPwAAAIEAAACfQUJCtOPk5P7m5+f/4uPj/+Di4f/g4uH/4OHg/97f3//c3t3/29zc/9na2v/X2dj/ + 1tfX/9TW1f/S1NP/0dPS/8/R0P/O0M//xsnI/7q9vP+vsrH/pain/56iof+6vb3/wsTD/8DCwf++wcD/ + vb++/7u+vP+5vLv/uLq5/7a5uP+0t7b/s7a0/7G0s/+vs7H/r7Ox/7q9vP+6vbz/mZyb9CAhIawAAACf + AAAAkgAAAEoAAAA/AAAANgAAABAAAAA5AAAAPwAAAFQAAACaAAAAn11fXr7X3dr+2d/c/9Xc2P/P19P/ + 4ebj//n6+v/z9fT/7fDv/+fr6f/h5uP/2uHe/9La1v/P19P/z9fT/9LZ1f/Z39z/2d/c/6mtq+EGBgah + AAAAnwAAAHcAAAA/AAAAPwAAAD8AAAA/AAAAPwAAAD8AAABAAAAAQAAAAD8AAAA/AAAAPwAAAD8AAABJ + AAAAigAAAJ8MCwunVlVQ8l5dWP9TUkz/NjQu/zY0Lv82NC7/NjQu/zY0Lv9JR0L/WVdS/2JhXP9ramX/ + dHNv/358eP+HhoL/kI+M/5+em/+Eg4D/UlFN7QAAAJ8AAACUAAAAPwAAADsAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAMwAAAD8AAABgAAAAnwoKCqLKy8vw5ufn/+Tl5f/g4uH/ + 4OLh/+Dh4P/e39//3N7d/9vc3P/Z2tr/19nY/9bX1//U1tX/0tTU/9HT0v/P0dD/zc/P/8zOzf/KzMv/ + yMvK/8fJyP/FyMf/w8XE/8LEw//Aw8L/vsHA/72/vv+7vr3/uby7/7i7uv+2ubj/tLe2/7O2tf+xtLP/ + r7Ox/7Czsv+6vbz/ury8/5icm/QgISCsAAAAnwAAAJIAAABKAAAAPwAAADUAAAAGAAAAAAAAAAsAAAA6 + AAAAPwAAAFgAAACcAAAAn2ZpaMLY3tv+2d/c/9Tb2P/P19P/4+jl//n6+v/z9fT/7fDu/+fr6f/g5eP/ + 2uDd/9HZ1f/P19P/z9fT/9LZ1f/Z39z/2d/c/6GmpN0DAwOgAAAAnwAAAHMAAAA/AAAAQAAAAFwAAAB+ + AAAAkwAAAJwAAACbAAAAkAAAAHsAAABrAAAAdgAAAJkAAACfCgoJplFQTOxeXVj/WFdS/zk3Mf82NC7/ + NjQu/zY0Lv82NC7/RkQ+/1xaVf9jYVz/bGpm/3V0cP9+fXn/h4aD/5GQjP+amZb/qKil/2VkX/89PDjS + AAAAnwAAAIAAAAA/AAAAMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8AAAA/ + AAAARwAAAJcAAACfkJGR0ubn5//m5+b/4eLh/+Di4f/g4eD/3uDf/9ze3f/b3Nz/2dva/9fZ2P/W19f/ + 1NbV/9LU1P/R09L/z9HQ/83Pz//Mzs3/yszL/8jLyv/Hycj/xcjH/8PGxf/CxMP/wMPC/77BwP+9wL// + u769/7q8u/+4u7r/trm4/7W4tv+ztrX/sbSz/7Czsv+ws7L/ur28/7q9vP+Ym5v0HyAfrAAAAJ8AAACS + AAAASgAAAD8AAAA1AAAABgAAAAAAAAAAAAAAAAAAAA0AAAA8AAAAPwAAAFsAAACdAAAAn3BzccbZ39z/ + 2d/c/9Tb1//P19P/5enn//n6+f/z9fT/7PDu/+br6P/g5eP/2uDd/9HY1f/P19P/z9fT/9LZ1v/Z39z/ + 2d/c/5qenNkBAQGfAAAAnwAAAHcAAACMAAAAnwAAAJ8AAACfAAAAnwAAAJ8AAACfAAAAnwAAAJ8AAACf + AAAAnxkZGLFUU0/wXl1Y/1taVf88OzX/NjQu/zY0Lv82NC7/NjQu/0RCPf9bWlX/YmFc/3JwbP+FhIH/ + iomG/4qJhv+RkI3/nJyY/6alo/9wb2r/WllV+Q4NDagAAACfAAAAXwAAAD8AAAAhAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAPQAAAD8AAAB/AAAAn0JCQrPj5OT+5ufn/+Lj4//g4uH/ + 4OHg/97g3//c3t3/29zc/9nb2v/X2dj/1tfX/9TW1f/S1NT/0dPS/8/R0P/Nz8//zM7N/8rMy//Iy8r/ + x8nI/8XIx//DxsX/wsTD/8DDwv+/wcD/vcC//7u+vf+6vbv/uLu6/7a5uP+1uLb/s7a1/7G0s/+ws7L/ + sLOy/7q9vP+6vbz/l5ua8x4fH6sAAACfAAAAkQAAAEoAAAA/AAAANQAAAAYAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAA8AAAA9AAAAPwAAAF8AAACeAAAAn3p+fMrZ39z/2d/c/9Tb1//P19P/5+vp//n6+f/y9PP/ + 7O/u/+bq6P/g5eP/2eDc/9DY1P/P19P/z9fT/9La1v/Z39z/2d/c/5GVk9QBAQGfAAAAnwAAAJ8JCQmj + RkZEx2hnZONycW7vbmxp7l1bWd9CQT/KMC8uvjg3NcRKSkbfXVxX/l5dWP9aWVT/PTs2/zY0Lv82NC7/ + NjQu/zY0Lv9CQDv/W1lU/2JgXP9wb2r/jIuH/5KRjf93dnL/dnVx/4WFgf+Af3z/Y2Jd/1xbV/0lJCK7 + AAAAnwAAAI4AAABAAAAAPwAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAADIAAAA/ + AAAAXwAAAJ8KCgqiy8zM7+bn5//k5eX/4OLh/+Dh4f/e4N//3d7d/9vc3P/Z29r/19nY/9bY1//U1tX/ + 09XU/9HT0v/P0dD/ztDP/8zOzf/KzMv/ycvK/8fJyP/FyMf/xMbF/8LEw//Aw8L/v8HA/73Av/+7vr3/ + ur27/7i7uv+2ubj/tbi2/7O2tf+xtbP/sLOy/7Czsv+6vbz/ur28/5eamfMeHh6rAAAAnwAAAJEAAABJ + AAAAPwAAADUAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEAAAA9AAAAPwAAAGMAAACe + AAAAn4SIhs/Z39z/2d/c/9Pa1//P19P/6e3r//j5+f/y9PP/7O/t/+bq6P/f5eL/2N/c/9DY1P/P19P/ + z9fT/9Pa1//Z39z/2d/c/4iMitAAAACfNTUzvH18ePWEg3//gX98/318eP96eXX/d3Zy/3Rybv9xb2v/ + bGpm/19eWf9eXVj/UlFL/zo4Mv82NC7/NjQu/zY0Lv82NC7/QT85/1pZVP9iYFv/a2pl/4qIhf+RkI3/ + cnJv41JRTOxeXVj/Xl1Y/15dWP9RUEvrHBwbtAAAAJ8AAACbAAAAUQAAAD8AAAApAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAPwAAAEYAAACXAAAAn5OTk9Lm5+f/5ufn/+Hi4v/g4eH/ + 3uDf/93e3v/b3Nz/2dva/9jZ2f/W2Nf/1NbV/9PV1P/R09L/z9HR/87Qz//Mzs3/ys3M/8nLyv/Hycj/ + xcjH/8TGxf/CxMP/wMPC/7/BwP+9wL//u769/7q9u/+4u7r/trm4/7W4tv+ztrX/sbWz/7Czsv+ws7L/ + u729/7m8vP+WmZnzHR0dqwAAAJ8AAACQAAAASQAAAD8AAAA0AAAABgAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAABQAAAA+AAAAPwAAAGcAAACfAAAAn46RkNPZ39z/2d/c/9Pa1v/P19P/ + 6+7t//j5+f/y9PP/7O/t/+Xq6P/f5OL/2N7b/9DY1P/P19P/z9fT/9Pb1//Z39z/2d/c/4KEgeKFhIH+ + hIN//318eP9tbGj/ZGJe/2FfW/9kYl7/Z2Zh/2dmYf9YV1L/TkxH/z8+OP82NC7/NjQu/zY0Lv82NC7/ + NjQu/z89N/9aWFP/YWBb/2hnYv+Egn//kZCN/4KBfu0JCAijAQAAnxUUE64gIB63EhIRrAAAAJ8AAACf + AAAAmQAAAFgAAAA/AAAAOQAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAD0AAAA/ + AAAAfQAAAJ9FRUWz5OXl/ubn5//i4+P/4OHh/9/g3//d3t7/293c/9nb2v/Y2dn/1tjX/9XW1v/T1dT/ + 0dPS/9DR0f/O0M//zM7O/8vNzP/Jy8r/x8rJ/8bIx//ExsX/wsXE/8DDwv+/wsH/vcC//7u+vf+6vbz/ + uLu6/7a5uP+1uLf/s7a1/7G1s/+ws7L/sLSy/7u9vf+6vLz/lpmY8hwdHasAAACfAAAAkAAAAEkAAAA/ + AAAANAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcAAAA/ + AAAAPwAAAGsAAACfAQEBn5ebmdfZ39z/2d/c/9La1v/Q2NT/7fDv//j5+P/x9PP/6+/t/+Xq5//f5OL/ + 197b/8/X0//P19P/z9fT/9Tb1/+2ubb/hoWB/4SDf/90c2//X11Z/1lYU/9WVE//UVBL/01MRv9JSEL/ + PDo0/zY0Lv82NC7/NjQu/zY0Lv82NC7/NjQu/zY0Lv8+PDb/WVdS/2FfW/9oZmL/enl0/5GQjf+SkY37 + ICAgrQAAAJ8AAACfAAAAnwAAAJ8AAACfAAAAngAAAH8AAABLAAAAPwAAADwAAAAOAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAxAAAAPwAAAF0AAACfDAwMos7Ozu/m5+f/5OXl/+Dh4f/f4N// + 3d7e/9vd3P/a29r/2NnZ/9bY1//V1tb/09XU/9HT0v/Q0dH/ztDP/8zOzv/Lzcz/ycvK/8fKyf/GyMf/ + xMbF/8LFxP/Aw8L/v8LB/73Av/+7vr3/ur28/7i7uv+2ubj/tbi3/7O2tf+xtbP/sLOy/7C0sv+7vb3/ + ury8/5WZmPIbHByqAAAAnwAAAJAAAABIAAAAPwAAADQAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkAAAA/AAAAPwAAAHAAAACfAwMDoJ+jodvZ39z/ + 2d/c/9LZ1v/Q2NT/7/Hw//f5+P/x9PL/6+7t/+Xp5//f5OH/1t3a/8/X0//P19P/p6un/3Nybv95eXT/ + bmxo/15cV/9aWFP/VlRP/1JQS/9OTEf/SkhC/z89N/82NC7/NjQu/zY0Lv82NC7/NjQu/zY0Lv82NC7/ + PDs1/1hWUf9hX1r/Z2Zh/3Buav+OjYr/lpWS/1RTUskAAACfAAAAkgAAAE4AAABeAAAAZQAAAF0AAABH + AAAAPwAAAD8AAAA4AAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAD8AAABG + AAAAlgAAAJ+XmJjT5ufn/+bn5//h4uH/3+Df/93f3v/b3dz/2tva/9ja2f/W2Nf/1dbW/9LU0/+xtLP/ + s7a1/8LEw//Mzs3/y83M/8nLyv/Hysn/xsjH/8TGxv/CxcT/wcPC/7/Cwf+9wL//vL+9/7q9vP+4u7r/ + t7q5/7W4t/+ztrX/srW0/7Czsv+usrD/ubu6/7q8vP+VmJfyGxsbqgAAAJ8AAACQAAAASAAAAD8AAAA0 + AAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAABwAAAA/AAAAPwAAAHUAAACfBQUFoKarqODZ39z/2d/c/9LZ1f/R2NT/8PPy//f4+P/x8/L/ + 6+7s/+Xp5//e5OH/1dzZ/6quqv9pZ2P/ZmRg/2JgXP9eXFj/WlhT/1ZUT/9SUEv/TkxH/0pIQ/9BPzn/ + NjQu/zY0Lv82NC7/NjQu/zY0Lv82NC7/NjQu/zs5M/9XVVD/YF9a/2dmYf9ubWj/goF9/5aVkv+JiIbv + AwMDoQAAAJ8AAABXAAAAPwAAAD8AAAA/AAAAPwAAAD8AAAA7AAAAIgAAAAQAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAkAAAA9AAAAPwAAAHwAAACfS0tLteXm5v7m5+f/4uPj/9/g3//d397/ + 293c/9rb2//Y2tn/1tjX/9XX1v/T1dT/sLSz/52hoP+doaD/naGg/6GlpP+usrH/u769/8XHxv/Exsb/ + wsXE/8HDwv+/wsH/vsC//7y/vf+6vbz/ubu6/7e6uf+1uLf/tLe1/7K1tP+ws7L/rrKw/62wr/+ztrX/ + o6em/2JlZNEAAACfAAAAkgAAAEgAAAA/AAAAMwAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8AAAA/AAAAQAAAAHkAAACf + CAgIoa2yr+PZ39z/2d/c/9HZ1f/R2dX/8vTz//f49//w8/L/6u7s/+Tp5v+3urf/amhk/2ZlYP9iYVz/ + Xl1Y/1pYU/9WVE//UlBL/05MR/9KSEP/QkA7/zY0Lv82NC7/NjQu/zY0Lv82NC7/NjQu/zY0Lv86ODL/ + VlRP/2BeWv9nZWH/bmxo/3V0cP+Tko7/m5qX/0ZGRb8AAACfAAAAfQAAAD8AAAA8AAAAHwAAACIAAAAe + AAAAEgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAMAAAAD8AAABb + AAAAnw8PD6PQ0dHx5ufn/+Tl5f/f4OD/3d/e/9zd3f/a29v/2NrZ/9fY2P/V19b/09XU/7O3tv+doaD/ + naGg/4SHhumanp39naGg/52hoP+doaD/n6Oi/6qtrP+1uLf/vsHA/77Av/+8v73/ur28/7m7uv+3urn/ + tbi3/7S3tf+ytbT/sLSy/6+ysf+tsK//q6+t/6aqqf+doaD/f4KB5QAAAJ8AAACNAAAAPwAAAD0AAAAF + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAACIAAAA/AAAAQAAAAH0AAACfDAwMorO4tefZ39z/2N/b/9HY1f/S2db/ + 8/X0//f49//w8/L/wsTC/2tpZf9mZWD/YmFc/15dWP9aWVT/VlRP/1JRS/9OTEf/SkhD/0NBPP83NS// + NjQu/zY0Lv82NC7/NjQu/zY0Lv82NC7/OTcy/1VTTv9gXln/ZmVg/21saP90c2//hIN//5ual/+Sko/z + AwMDoAAAAJ4AAABNAAAAPwAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAABsAAAA/AAAARQAAAJUAAACfnZ2d1ebn5//m5+f/4OHg/93f3v/c3d3/ + 2tvb/9ja2f/X2Nj/1dfW/9PV1P+3urn/naGg/52hoP9XWVjJAAAAnw0ODaRFRka+cnV025SYl/edoaD/ + naGg/52hoP+eoqH/p6qp/7G0s/+5u7r/t7q5/7W4t/+0t7X/srW0/7C0sv+vsrH/rbCv/6uvrf+qraz/ + p6uq/52hoP+Xmpn5AQEBoAAAAJ4AAABDAAAAPwAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUAAAA/ + AAAAQQAAAIEAAACfERERpLi+u+rZ39z/2N7b/9HY1P/T2tb/9Pb1/87Pzf9samb/ZmVg/2JhXP9fXVj/ + WllU/1ZVUP9SUUz/Tk1H/0pJQ/9EQj3/NzUv/zY0Lv82NC7/NjQu/zY0Lv82NC7/NjQu/zk3Mf9TUkz/ + X15Z/2ZlYP9tbGf/dHJu/3t5df+VlJH/oJ+c/2BfXcwAAACfAAAAgQAAAD8AAAA5AAAAAgAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAAAAPAAAAD8AAAB6 + AAAAn1FRUbbl5ub+5ufn/+Hj4v/d397/3N3d/9rb2//Y2tn/19jY/9XX1v/T1dX/ur28/52hoP+doaD/ + XmBgzgAAAJ8AAACfAAAAnwAAAJ8AAACfAwMDoDIzMrVkZ2bRio6N7p2hoP+doaD/nqKh/7e6uf+1uLf/ + tLe1/7K1tP+wtLL/r7Kx/62wr/+rr63/qq2s/6isqv+nqqn/nqKh/52hoP8kJCSuAAAAnwAAAFYAAAA/ + AAAAFQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAACgAAAA/AAAAQgAAAIUAAACfFhcWpb3DwO3Z39z/ + 2N7b/9DY1P+5vrr/bmxo/2dlYf9jYVz/X11Y/1tZVP9XVVD/U1FM/09NSP9LSUP/RUM9/zg2MP82NC7/ + NjQu/zY0Lv82NC7/NjQu/zY0Lv84NjD/UlBL/19dWP9mZGD/bWtn/3Nybv96eXX/h4WC/6CfnP+hoJ77 + ExMTpwAAAJ8AAABZAAAAPwAAAB8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC8AAAA/AAAAWgAAAJ8SEhKk09PT8ubn5//k5eT/3t/e/9zd3f/a3Nv/ + 2NrZ/9fY2P/V19b/09XV/77AwP+doaD/naGg/2VoZ9IAAACfAAAAnwAAAGcAAABXAAAAdAAAAJAAAACf + AAAAnwAAAJ8AAACfHR4eq4mMjO2doaD/sLOy/7S3tv+ytbT/sLSy/6+ysf+tsK//q6+t/6qtrP+orKr/ + pqqp/6Wpp/+gpKL/pKin/1tcXMMAAACfAAAAawAAAD8AAAAiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAQAAACoAAAA/AAAAQwAAAIgAAACfHB0cp8LHxfDZ39z/xMnF/29taf9nZWH/Y2Fd/19dWf9bWVT/ + V1VQ/1NRTP9PTUj/S0lE/0ZEPv84NjD/NjQu/zY0Lv82NC7/NjQu/zY0Lv82NC7/NzUv/1BPSf9fXVj/ + ZmRf/2xrZ/9zcm7/enl1/4GAfP+ZmJX/paSh/3V0ctgAAACfAAAAjwAAAD8AAAA+AAAABgAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaAAAAPwAAAEQAAACU + AAAAn6Kjo9fm5+f/5ebm/9/g3//c3d3/2tzb/9ja2f/X2Nj/1dfW/9PV1f/BxMP/nqKh/52hoP9rbm3X + AQEBnwAAAJ8AAABrAAAAPwAAAD8AAAA/AAAAPwAAAE0AAABqAAAAhwAAAJ0AAACfYWNjz52hoP+orKv/ + srW0/7C0sv+vsrH/rbCv/6uvrf+qraz/qKyq/6eqqf+lqaf/o6el/6apqP/Gycj/i42N1wAAAJ8AAAB/ + AAAAPwAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAC0AAAA/AAAARQAAAIsAAACf + IyQjqbS4tfOLiob/c3Jt/2NhXf9fXVn/W1lU/1dVUP9TUUz/T01I/0tJRP9GRD//OTcx/zY0Lv82NC7/ + NjQu/zY0Lv82NC7/NjQu/zc1L/9PTUj/Xl1Y/2VkX/9sa2b/c3Ft/3p4dP+Af3v/j46K/6Wkof+mpaP8 + HR0cqgAAAJ8AAABkAAAAPwAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAACAAAADwAAAA/AAAAeAAAAJ9YWFi45ebm/ubn5v/g4uH/3N7d/9rc2//Y2tn/ + 19nY/9XX1v/U1dX/xMbF/56iof+doaD/cXR02wICAqAAAACfAAAAcAAAAD8AAAA/AAAAJgAAADEAAAA+ + AAAAPwAAAD8AAAA/AAAAYQAAAJ8zNDS1naGg/6Kmpf+xtLP/r7Kx/62xr/+sr67/qq2s/6isq/+nqqn/ + pamn/6Onpv+mqqj/yMrJ/87Qz/+wsrHsAAAAnwAAAJQAAAA/AAAAPQAAAAEAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAgAAADAAAAA/AAAAVAAAAJ8FBQWie3p39IWFgf9vbWn/X15Z/1taVf9XVlH/ + U1JM/09NSP9LSUT/RkQ//zo4Mv82NC7/NjQu/zY0Lv82NC7/NjQu/zY0Lv83NS//TUtG/15cV/9lY1// + bGpm/3Jxbf95eHT/gH97/4mIhP+ioZ//qqmn/2pqaM8AAACfAAAAkQAAAEEAAAA/AAAADAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnAAAAPwAAAFgAAACf + FxcXpdXW1vPm5+b/4uTj/9ze3f/a3Nv/2dra/9fZ2P/V19b/1NbV/8bIx/+fo6L/naGg/3d6ed8DAwOg + AAAAnwAAAHQAAAA/AAAAPwAAABsAAAAAAAAAAAAAAAUAAAAXAAAAKwAAAD8AAABHAAAAngQEBKGXm5r6 + naGg/6+ysf+tsa//rK+u/6qurP+orKv/p6qp/6Wpp/+jp6b/pamn/8fJyP/P0dD/ztDP/8vNzP0KCgqi + AAAAnwAAAEkAAAA/AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIwAAAD8AAABs + AAAAnzw7Ob+FhYH/f315/2BfWv9bWlX/V1ZR/1NSTf9PTkj/S0pE/0dFQP86ODL/NjQu/zY0Lv82NC7/ + NjQu/zY0Lv82NC7/NjQu/0tJRP9eXFf/ZWNe/2tqZf9ycW3/eXh0/4B/e/+HhYL/nZyZ/6qppv+ampjw + CAgHogAAAJ8AAABcAAAAPwAAACsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAADoAAAA/AAAAjAAAAJ+oqKjZ5ufn/+Tl5f/d397/29zb/9na2v/X2dj/ + 1tfX/9TW1f/Iy8r/oKSj/52hoP98f37iBQUFoQAAAJ8AAAB4AAAAPwAAAD8AAAAfAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAOgAAAD8AAACMAAAAn3p9fOGdoaD/qKyr/6yvrv+qrqz/qKyr/6erqf+lqaf/ + o6em/6Wop//GyMf/z9HQ/87Qz//O0M//ztDP/0FBQbUAAACfAAAAXQAAAD8AAAAaAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtAAAAPwAAAH8AAACfXl1b2YOBfv9wbmr/XFpV/1hWUf9UUk3/ + UE5J/0xKRP9IRkD/Ozkz/zY0Lv82NC7/NjQu/zY0Lv82NC7/NjQu/zY0Lv9JSEL/XVxX/2RjXv9ramX/ + cnBs/3l3c/9/fnr/hoWC/5eWk/+pqab/q6qo/TAwL7IAAACfAAAAgAAAAD8AAAA9AAAACQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPgAAAD8AAACX + AAAAn6Kjo97k5eX/4+Tk/9ze3f/Z2tr/19nY/9bX1//U1tX/ys3M/6Kmpf+doaD/gISD5ggICKIAAACf + AAAAfQAAAEAAAAA/AAAAIQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApAAAAPwAAAHIAAACf + VFZVx52hoP+kp6b/qq6s/6isq/+nq6n/pamn/6Onpv+kqKb/xMbF/8/R0P/O0M//zc/O/87Qz//O0M// + c3RzygAAAJ8AAAByAAAAPwAAACcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIAAAA/ + AAAAhwAAAJ9oZ2TkgH57/2dlYf9YVlH/VFJN/1BOSf9MSkX/SEZA/zs5M/82NC7/NjQu/zY0Lv82NC7/ + NjQu/zY0Lv82NC7/R0ZA/11bVv9kYl7/a2ll/3JwbP94d3P/f356/4aFgf+Tko//qaim/66tq/9dXFzI + AAAAnwAAAJYAAABHAAAAPwAAAB8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzAAAAPwAAAHIAAACfBgYGoaepqeTi4+P/4OHh/9nb2v/W19f/ + 1NbV/8zOzv+jp6b/naGg/4WIh+kLDAukAAAAnwAAAIAAAABBAAAAPwAAACQAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAABgAAAA/AAAAWAAAAJ8hIiKtnaGg/5+jov+prKv/p6up/6Wpp/+kqKb/ + o6el/8LExP/P0dD/ztDP/83Pzv/Mzs3/zc/O/87Qz/+bnZzfAAAAnwAAAIcAAAA/AAAANQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMQAAAD8AAACGAAAAn2NiYOF9e3f/ZGNe/1RSTf9QTkn/ + TEpF/0hGQf87OTP/NjQu/zY0Lv82NC7/NjQu/zY0Lv82NC7/NjQu/0VEPv9dW1b/Y2Jd/2ppZP9xcGv/ + eHdz/39+ev+GhIH/kI+M/6inpP+urar/f3593AAAAJ8AAACeAAAAWgAAAD8AAAAzAAAAAgAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcAAAA/ + AAAAQAAAAH0AAACfCQkJo6qsq+ff4eD/3d/f/9bX1//O0M//pamo/52hoP+IjIvsDw8PpQAAAJ8AAACE + AAAAQgAAAD8AAAAnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAD8AAABC + AAAAmwAAAJ+QlJPznaGg/6eqqf+mqaj/pKim/6Onpf/AwsL/z9HQ/87Qz//Nz87/zM7N/8vOzf/Mzs3/ + ztDP/72/vvMAAACfAAAAmgAAAEAAAAA/AAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAq + AAAAPwAAAHkAAACfTk1K0Hl4dP9sa2b/UE9J/0xKRf9IRkH/Ozo0/zY0Lv82NC7/NjQu/zY0Lv82NC7/ + NjQu/zY0Lv9EQjz/XFtW/2NiXf9qaWT/cW9r/3h2cv9+fXn/hYSB/4+Oi/+npaP/ra2q/5KRkOkICAii + AAAAnwAAAG4AAAA/AAAAPAAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUAAAA/AAAAQQAAAIEAAACfDA0NpK2vrurd3t7/ + 1tjX/6erqv+doaD/jI+O7xMUFKcAAACfAAAAiAAAAEMAAAA/AAAAKgAAAAEAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAPAAAAD8AAACEAAAAn29ycdmdoaD/o6el/6Sopv+ipqX/ + vsC//8/R0P/O0M//zc/O/8zOzf/Lzs3/y83M/8rMy//O0M//ztDP/x0dHagAAACfAAAAUAAAAD8AAAAR + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAA/AAAAXwAAAJ8XFxardXRw/XNybv9RT0r/ + SEZB/zw6NP82NC7/NjQu/zY0Lv82NC7/NjQu/zY0Lv82NC7/QkA6/1xaVf9jYV3/amhk/3Fva/93dnL/ + fn15/4WEgP+OjYr/paSi/62sqv+ZmZfvExMTpgAAAJ8AAAB/AAAAQAAAAD8AAAAWAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAQAAACgAAAA/AAAAQgAAAIUAAACfEBERpq2vru2rrq3/naGg/46SkfIYGRipAAAAnwAAAIsAAABE + AAAAPwAAACwAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAADEAAAA/ + AAAASAAAAJEAAACfTlBQxJ2hoP+gpKP/oqal/7u+vf/P0dD/ztDP/83Pzv/Mzs7/y87N/8vNzP/KzMv/ + ycvK/83Pzv/O0M//VldXvQAAAJ8AAABlAAAAPwAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAACgAAAD8AAABBAAAAlAAAAJ9cW1jkcG9q/1dWUP88OjT/NjQu/zY0Lv82NC7/NjQu/zY0Lv82NC7/ + NjQu/0A+Of9bWVT/YmFc/2loY/9wb2r/d3Zy/359ef+FhID/jYyJ/6SjoP+trKr/np6c8xoaGqkAAACf + AAAAiQAAAEMAAAA/AAAAIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAACsAAAA/AAAAQwAAAIgAAACf + FBUVp42Qj/CRlZT0HR4eqwAAAJ8AAACOAAAARgAAAD8AAAAvAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAvAAAAPwAAAEYAAACOAAAAnx4fH6ySlZX1naGg/5mdnP+4u7r/ + z9HQ/87Qz//Nz87/zM7O/8vOzf/Lzcz/yszL/8nLyv/Iysr/zM7N/87Qz/+EhoXSAAAAnwAAAHkAAAA/ + AAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALQAAAD8AAAB1AAAAn0JBP81tbGf/ + UlFM/zY0Lv82NC7/NjQu/zY0Lv82NC7/NjQu/zY0Lv8/PTf/WllU/2JhXP9paGP/cG5q/3d1cf99fHj/ + hIN//4yLiP+jop//rayq/6OioPYjIyKsAAAAnwAAAI0AAABFAAAAPwAAACwAAAABAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAgAAAC0AAAA/AAAARQAAAIsAAACfGRoaqSIjI60AAACfAAAAkAAAAEgAAAA/ + AAAAMAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAALQAAAD8AAABF + AAAAiwAAAJ8ZGhqpkJOS8p2hoP+ZnZz/pamn/87Q0P/O0M//zc/O/8zOzv/Mzs3/y83M/8rMy//Jy8r/ + yMrK/8fKyf/KzMv/ztDP/6qsq+cAAACfAAAAjgAAAD8AAAA5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAdAAAAPwAAAGcAAACfNDQxw2NiXf9RUEr/NjQu/zY0Lv82NC7/NjQu/zY0Lv82NC7/ + PTs2/1lXU/9iYFv/aWdj/3Buav92dXH/fXx4/4SDf/+Miof/oaGe/62sqv+mpaP4LCsrsAAAAJ8AAACR + AAAASAAAAD8AAAAwAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAC8AAAA/ + AAAARgAAAI4AAACfAAAAnwAAAJMAAABKAAAAPwAAADMAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAQAAACsAAAA/AAAAQwAAAIgAAACfFBUVp4yQj/CdoaD/mp6d/6Kmpf/O0M// + ztDP/83Pzv/Mzs7/zM7N/8vNzP/KzMv/ycvK/8jKyv/Hysn/x8nI/8fJyP/O0M//yMrJ+gQEBKAAAACe + AAAARAAAAD8AAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAA/AAAAaAAAAJ8vLizE + Xl1Y/1FPSv82NC7/NjQu/zY0Lv82NC7/NjQu/zw6NP9YV1L/YWBb/2hnYv9vbmn/dnVx/318eP+Eg3// + i4qG/6CfnP+trKn/qaim+zU1NbQAAACfAAAAlQAAAEsAAAA/AAAAMwAAAAQAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAADEAAAA/AAAARwAAAHMAAAB1AAAASQAAAD8AAAA1 + AAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAoAAAAPwAAAEIAAACF + AAAAnxAQEKWJjYztnaGg/5qenf+fo6L/zc/O/87Qz//Nz87/zc/O/8zOzf/Lzcz/yszL/8nLyv/Iysr/ + x8rJ/8fJyP/GyMf/xcfG/87Qz//O0M//Njc3sAAAAJ8AAABXAAAAPwAAABUAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALAAAAD8AAAB2AAAAnzk5Ns9eXVj/TUxG/zY0Lv82NC7/NjQu/zY0Lv87OTP/ + V1ZR/2FfW/9oZ2L/b21p/3Z0cP98e3f/g4J+/4qJhv+enZr/rKyp/6uqqP1AQD+5AAAAnwAAAJgAAABP + AAAAPwAAADYAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAABAAAADIAAAA/AAAAPwAAAD8AAAA/AAAANQAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAJQAAAD8AAABBAAAAgQAAAJ8MDQ2khomI6p2hoP+bn57/naGg/8zPzv/O0M// + zc/P/83Pzv/Mzs3/y83M/8rMy//Jy8r/yMvK/8fKyf/Hycj/xsjH/8XIx//KzMv/ztDP/87Qz/9rbGvF + AAAAnwAAAGsAAAA/AAAAIQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAA+AAAAPwAAAJIAAACf + TEtH5F5dWP9GRD//NjQu/zY0Lv82NC7/Ojgy/1ZUT/9hX1r/aGZi/29taf91dHD/fHt3/4OCfv+KiYX/ + nZyZ/6yrqf+trKr+S0tJvgAAAJ8AAACaAAAAUwAAAD8AAAA4AAAACAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAABwAAAAuAAAALwAAAB8AAAAD + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIAAAA/AAAAQAAAAH4AAACf + CQkJo4KFhOedoaD/m5+e/5ufnf/Lzs3/ztDP/83Pz//Nz87/zM7N/8vNzP/KzMv/ycvK/8jLyv/Hysn/ + x8nI/8bIx//Hycj/zc/P/8/R0f/O0M//p6io5SIjI6oAAACfAAAAawAAAD8AAAAhAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAJwAAAD8AAABaAAAAnwsKCqZdXFf9Xl1Y/zs5M/82NC7/NjQu/zk3Mf9VU07/ + YF9a/2dmYf9ubWj/dXRw/3x7d/+Dgn7/ioiF/5ual/+sq6n/rq2r/1ZWVcQAAACfAAAAnAAAAFcAAAA/ + AAAAOgAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAfAAAAPwAAAEAAAAB6AAAAnwYGBqF9gIDknaGg/5ygn/+ZnZv/yszL/87Qz//Nz8// + zc/O/8zOzf/Lzcz/yszL/8nLy//Iy8r/x8rJ/8fJyP/GyMf/yszM/8/R0f/P0dH/yMrJ+21tbccCAgKg + AAAAnwAAAJEAAABHAAAAPwAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMAAAA/AAAAQAAAAIwAAACf + ODc0zV5dWP9VVE//NjQu/zY0Lv84NjD/U1JN/2BeWv9nZmH/bmxo/3Vzb/98enb/goF9/4mIhf+ZmJX/ + rKuo/66tq/9iYWDKAAAAnwAAAJ0AAABcAAAAPwAAADwAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAD8AAAA/AAAAdQAAAJ8EBASh + eHx74J2hoP+coJ//l5ua/8nLyv/O0M//zc/P/83Pzv/Mzs3/y83M/8rMy//Jy8v/yMvK/8jKyf/Hycj/ + x8rJ/87Qz//Q0tH/z9HQ/6yuregqKiqsAAAAnwAAAJ8AAAB4AAAARAAAAD8AAAAyAAAAAQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAALAAAAOwAAAD8AAABsAAAAnwsLCqZaWVT5Xl1Y/0NCPP82NC7/ODYw/1JQS/9gXln/ + Z2Vh/25saP90c2//e3p2/4KBff+JiIT/l5aT/6urqP+urav/bWxr0QAAAJ8AAACfAAAAYgAAAD8AAAA9 + AAAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAABoAAAA/AAAAPwAAAHEAAACfAgICoHN3dtydoaD/nKCf/5aamP/Hycj/ztDP/87Qz//Nz87/ + zM7N/8vNzP/KzMv/ycvL/8nLyv/Iysn/x8nI/8vNzP/Q0tL/0NLR/8rMy/x1dnbKAwMDoAAAAJ8AAACU + AAAAWgAAAD8AAAA/AAAAMQAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwAAADkAAAA/AAAAWAAAAJ0AAACf + RkVB3V5dWP9WVU//NjQu/zc1L/9RT0n/YF5Z/2ZlYP9tbGj/dHNu/3t6dv+CgX3/iYeE/5aVkv+rqqf/ + rq2r/3d3ddcAAACfAAAAnwAAAGgAAAA/AAAAPgAAABMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXAAAAPwAAAD8AAABtAAAAnwEBAZ9ucXDY + naGg/52hoP+VmZf/xcfG/87Qz//O0M//zc/O/8zOzf/Lzcz/yszL/8nMy//Jy8r/yMrJ/8jKyv/O0dD/ + 0NLS/9DS0f+ytLPrMTIyrwAAAJ8AAACfAAAAewAAAEUAAAA/AAAAPQAAAB0AAAABAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAABAAAAA7AAAAPwAAAFIAAACZAAAAny4uK8NeXVj/XVxX/z48Nv83NS//T01I/19dWf9mZWD/ + bWtn/3Rybv97eXX/gYB8/4iHhP+Vk5D/qqmn/66tq/+BgH/dAgICoAAAAJ8AAABvAAAAPwAAAD8AAAAW + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAFAAAAD4AAAA/AAAAaAAAAJ8AAACfZ2pp052hoP+doaD/lJiX/8PFxP/O0ND/ztDP/83Pzv/Mzs3/ + y83M/8rMzP/JzMv/ycvK/8jKyf/Lzcz/0dLS/9HT0v/Mzs79fn9/zgYGBqEAAACfAAAAlgAAAF0AAAA/ + AAAAPwAAADMAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAdAAAAPgAAAD8AAABUAAAAmAAAAJ8gIB63 + XFtW/F5dWP9JSEL/NjQu/01LRv9fXVj/ZmRg/21rZ/9zcm7/enl1/4GAfP+Ih4P/k5KP/6qppv+urav/ + iYiH4gUFBaEAAACfAAAAdQAAAD8AAAA/AAAAGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAA7AAAAPwAAAGQAAACfAAAAn2BjYs+doaD/ + naGg/5OXlv/Aw8L/ztDQ/87Qz//Nz87/zM7N/8vNzf/KzMz/yczL/8nLyv/Jy8r/z9HQ/9HT0//R09L/ + t7m57jo6OrIAAACfAAAAnwAAAH8AAABGAAAAPwAAAD4AAAAfAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK + AAAAMAAAAD8AAAA/AAAAYAAAAJwAAACfHh4ctVtaVfpeXVj/UVBK/zY0Lv9LSUT/Xl1Y/2VkX/9sa2b/ + c3Jt/3p5df+BgHz/iIaD/5KRjv+oqKX/rq2r/5CPjugJCQmjAAAAnwAAAHsAAABAAAAAPwAAAB4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAGQAAAD8AAABTAAAAngAAAJ9ZXFvKnaGg/52hoP+Tl5b/vsG//87Q0P/O0M//zc/O/8zOzf/Lzc3/ + yszM/8nMy//Jy8r/zM3N/9HT0v/R09P/z9HQ/oeIiNIJCQmiAAAAnwAAAJgAAABfAAAAPwAAAD8AAAA0 + AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAIwAAAD4AAAA/AAAAQwAAAHcAAACfAAAAnyUlI7tbWlb7 + Xl1Y/1RTTf83NTD/SUdC/15cWP9lZF//bGpm/3Nxbf96eHT/gH97/4eGg/+Tko7/qKel/66tq/+WlZTs + Dw8PpQAAAJ8AAACBAAAAQQAAAD8AAAAjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhAAAAPwAAAG0AAACfMzQ0tZ2hoP+doaD/ + l5ua/7u+vf/P0dD/ztDP/83Pzv/Mzs3/y83N/8rMzP/KzMv/yszL/8/R0f/S1NP/0dPT/72+vvFDRES1 + AAAAnwAAAJ8AAACBAAAASAAAAD8AAAA+AAAAIQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAAAAIwAAADwAAAA/ + AAAAPwAAAFgAAACRAAAAnwEBAaA2NTPLXVxX/l5dWP9TUk3/ODYw/0dFQP9eXFf/ZWNf/2xqZv9ycW3/ + eXh0/4B/e/+HhoL/lZSQ/6mopf+urav/lpWU7BMTEqYAAACfAAAAhgAAAEIAAAA/AAAAJwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAABsAAAA/AAAAWAAAAJ8BAQGfbXBv2J6iof/GyMj/0tTT/87Qz//Nz87/zM7N/8vNzf/Lzcz/ + yszL/8zOzf/S1NP/0tTT/9DS0v6QkZHWDg4OowAAAJ8AAACZAAAAYgAAAD8AAAA/AAAANQAAAA4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAADgAAABIAAAAIAAAAAAAAAAAAAAAA + AAAAAQAAAA0AAAAdAAAAMQAAAD8AAAA/AAAAPwAAAE8AAACBAAAAnwAAAJ8ODQyoS0pG415dWP9eXVj/ + T05I/zc1L/9FQz7/XVxX/2RjXv9ramX/cnFs/3l4dP+Af3v/h4aC/5mYlf+qqab/rq2r/46NjOcPDw+l + AAAAnwAAAIkAAABEAAAAPwAAACsAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAD0AAAA/AAAAcAAAAJ8CAgKg + j5GQ3Nja2f/X2dn/0NLR/8zOzf/Lzs3/y83M/8vNzP/Q0tH/09XU/9LU0//Cw8PzTU5OuAAAAJ8AAACf + AAAAhAAAAEoAAAA/AAAAPwAAACQAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC + AAAAIwAAAD0AAAA/AAAAPwAAAD8AAAA5AAAANQAAADcAAAA+AAAAPwAAAD8AAAA/AAAAQAAAAFcAAACA + AAAAngAAAJ8CAgGgMTAtxVpZVPleXVj/XVxX/0dFQP82NC7/Q0E8/11bV/9kY17/a2ll/3JwbP95d3P/ + f356/4uKhv+gn5z/qamm/66tq/95eHfYBgYGoQAAAJ8AAACHAAAARAAAAD8AAAAuAAAAAgAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAGgAAAD8AAAA/AAAAdQAAAJ8FBQWhpaam4NfY2P/W19f/ztDP/8vNzP/Nz87/ + 0tTU/9PV1P/S1NP/mZqa2hQUFKUAAACfAAAAmgAAAGUAAAA/AAAAPwAAADcAAAAQAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACkAAAA/AAAAPwAAAEUAAABMAAAAQAAAAD8AAAA/ + AAAAPwAAAD8AAABDAAAAVwAAAHIAAACSAAAAnwAAAJ8BAQGfJSUju1JRTe1eXVj/Xl1Y/1dWUf8+PDb/ + NjQu/0FAOv9cW1b/ZGJe/2tpZf9xcGz/eHdz/4KBff+VlJH/pKOg/6mopv+mpqT5UFBPwQAAAJ8AAACf + AAAAfgAAAEIAAAA/AAAALwAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHwAAAD8AAABA + AAAAegAAAJ8ICQmiq62s5NbX1//V1tb/0dPS/9TV1f/T1dT/xsjI9lhZWbwAAACfAAAAnwAAAIcAAABL + AAAAPwAAAD8AAAAlAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO + AAAAPwAAAEIAAAB/AAAAngAAAJ8AAACXAAAAhwAAAIEAAACFAAAAkAAAAJ0AAACfAAAAnwAAAJ8FBQWi + LS0qwlFRTOxeXVj/Xl1Y/1xbVv9JR0L/NzUv/zY0Lv9APjj/XFpV/2NiXf9qaWT/cXBr/359ef+Pjov/ + np2a/6OioP+pqKb/hYSC4RwcG6oAAACfAAAAngAAAGwAAABAAAAAPwAAACsAAAACAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIgAAAD8AAABAAAAAfgAAAJ8NDQ2jsbKy6NTW1v/U1dX/ + 09XU/6Kko98bGxunAAAAnwAAAJsAAABoAAAAQAAAAD8AAAA4AAAAEQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAA/AAAAZAAAAJ8AAACfAQEBoAAAAJ8AAACf + AAAAnwAAAJ8AAACfAAAAnwkICKUnJyW9REM/2lpZVPleXVj/Xl1Y/11cV/9NTEf/Ojgy/zY0Lv82NC7/ + Pjw3/1tZVP9lY17/cnFs/4B/e/+Pjor/mJeU/56dmv+joqD/jo2L6j08O7gAAACfAAAAnwAAAJIAAABW + AAAAPwAAAD8AAAAkAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAJQAAAD8AAABBAAAAggAAAJ8SEhKktbe368vMzPhmZmbBAQEBnwAAAJ8AAACJAAAATQAAAD8AAAA/ + AAAAJwAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAIQAAAD8AAABqAAAAnwkJCKUvLizENzYzzUA/PNY+PjrUQUA910lIROFUU07wXl1Y/l5dWP9eXVj/ + Xl1Y/15dWP9bWlX/S0pF/0dGQP9IRkH/SklD/1NSTP9wb2v/fnx4/4eGg/+NjIj/kpGO/5iXlP+bmpf9 + e3p43zk5OLcAAACfAAAAnwAAAJ0AAABzAAAAQwAAAD8AAAA8AAAAFwAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAKAAAAD8AAABCAAAAhQAAAJ8XGBim + JSUlqQAAAJ8AAACcAAAAawAAAEAAAAA/AAAAOQAAABMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAPwAAAEgAAACUAAAAnwAAAJ8AAACf + BgYGoyMjIbk8OzjRTUxI5lpZVPleXVj/Xl1Y/15dWP9eXVj/Xl1Y/15dWP9eXVj/Xl1Y/15dWP9iYV3/ + enl1/4KAff+HhoL/jYyI/4qJhvdzc3DgTExKxBEREaYAAACfAAAAnwAAAJ4AAAB9AAAATQAAAD8AAAA/ + AAAAMAAAAAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAABAAAAKwAAAD8AAABDAAAAiQAAAJ8AAACfAAAAjAAAAE8AAAA/AAAAPwAAACkAAAAF + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAEAAAA0AAAAPwAAAEQAAABhAAAAfgAAAJkAAACfAAAAnwAAAJ8AAACfAQEBoBAQD6okIyG5 + MjEuxzs6N9FDQz/aSEhE4EtKRuNLSkfkS0pG4llYVd5XVlTWTUxKyzs6Ob0dHRysAQEBoAAAAJ8AAACf + AAAAnwAAAJcAAAB0AAAATAAAAD8AAAA/AAAAOgAAABoAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAALQAAAD8AAABC + AAAAYwAAAGAAAABBAAAAPwAAADoAAAAVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAzAAAAPwAAAD8AAAA/ + AAAAQQAAAFQAAABtAAAAgwAAAJcAAACfAAAAnwAAAJ8AAACfAAAAnwAAAJ8AAACfAAAAnwAAAJ8AAACf + AAAAnwAAAJ8AAACfAAAAnwAAAJ8AAACfAAAAkwAAAHkAAABbAAAAQQAAAD8AAAA/AAAAOwAAACAAAAAE + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAALQAAAD8AAAA/AAAAPwAAAD8AAAArAAAABgAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAEAAAARAAAAJQAAADgAAAA/AAAAPwAAAD8AAAA/AAAAPwAAAEoAAABZ + AAAAaQAAAHUAAAB/AAAAiAAAAI0AAACQAAAAkQAAAI8AAACLAAAAhAAAAHoAAABtAAAAXQAAAEkAAAA/ + AAAAPwAAAD8AAAA/AAAANQAAABwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAEwAAACMAAAAiAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAoAAAAbAAAAKgAAADgAAAA/AAAAPwAAAD8AAAA/AAAAPwAAAD8AAAA/AAAAPwAAAD8AAAA/ + AAAAPwAAAD8AAAA/AAAAPwAAAD8AAAA/AAAAPwAAAD8AAAAzAAAAIQAAAA0AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAS + AAAAHAAAACYAAAAtAAAAMwAAADkAAAA8AAAAPgAAAD8AAAA+AAAAOwAAADYAAAAwAAAAKAAAAB4AAAAS + AAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAD////////////////8AP/////w////////////8AA/////gB////// + /////8AAH////gAP//////////+AAAf///wAB///////////AAAH///4AAP//////////gAAA///8AAB + //////////wAAAH//+AAAP/////////8AAAB///AAAB/////////+AAAAP//gAAAP/////////AAAAD/ + /wAAAB/////////gAAAAf/4AAAAf////////wAAAAH/8AAAAD////////4AAAAB/+AAAAAf///////8A + AAAAf/AAAAAD///////+AAAAAH/wAAAAAf///////AAAAAB/4AAAAAD///////gAAAAAf+AAAAAAf/// + ///4AAAAAH/AAAAAAD//////8AAAAAB/wAAAAAAf/////+AAAAAA/8AAAAAAD//////AAAAAAP/AAAAA + AA//////gAAAAAH/wAAAAAAH/////wAAAAAB/8AAAAAAA/////4AAAAAA//AAAAAAAH////8AAAAAAf/ + 4AAAAAAA////+AAAAAAP/+AAAAAAAH////gAAAAAH//wAAAAAAA////wAAAAAD//+AAAAAAAH///4AAA + AAB///wAAAAAAA///8AAAAAA///+AAAAAAAH//+AAAAAAf///wAAAAAAB///AAAAAAP///+AAAAAAAP/ + /gAAAAAH////wAAAAAAB//wAAAAAD////+AAAAAAAP/4AAAAAB/////wAAAAAAB/+AAAAAA/////+AAA + AAAAP/AAAAAAf/////wAAAAAAB/gAAAAAP/////+AAAAAAAPwAAAAAH//////wAAAAAAB4AAAAAD//// + //+AAAAAAAMAAAAAB///////wAAAAAAAAAAAAA///////+AAAAAAAAAAAAAf///////wAAAAAAAAAAAA + P///////+AAAAAAAAAAAAH////////wAAAAAAAAAAAD////////+AAAAAAAAAAAB/////////wAAAAAA + AAAAA/////////+AAAAAAAAAAAf/////////wAAAAAAAAAAP/////////+AAAAAAAAAAH//////////w + AAAAAAAAAD//////////+AAAAAAAAAB///////////wAAAAAAAAA///////////+AAAAAAAAAf////// + /////wAAAAAAAAP///////////+AAAAAAAAH////////////wAAAAAAAD////////////+AAAAAAAB// + ///////////wAAAAAAA/////////////+AAAAAAAf///+D////////wAAAAAAP///8AP///////8AAAA + AAH///+AB////////gAAAAAD////AAP///////8AAAAAA////gAB////////gAAAAAH///wAAP////// + /4AAAAAA///8AAB///////8AAAAAAH//+AAAP//////+AAAAAAA///gAAB///////AAAAAAAH//4AAAP + //8Af/gAAAAAAA//+AAAB//+AAPwAAAAAAAH//gAAAP//gAAAAAAAAAAA//4AAAB//wAAAAAAAAAAAH/ + +AAAAf/4AAAAAAAAAAAA//wAAAD/+AAAAAAAAAAAAH/8AAAA//AAAAAAAAAAAAA/+AAAAP/gAAAAAAAA + AAAAPDAAAAD/4AAAAAAAAAAAAAAAAAAA/8AAAAAAAAAAAAAAAAAAAP+AAAAAAAAEAAAAAAAAAAD/gAAA + AAAADgAAAAAAAAAA/wAAAAAAAB8AAAAAAAAAAP4AAAAAAAA/gAAAAAAAAAH+AAAAAAAAf8AAAAAAAAAB + /AAAAAAAAP/gAAAAAAAAA/gAAAAAAAH/8AAAAAAAAAf4AAAAAAAD//gAAAAAAAAP8AAAAAAAB//8AAAA + AAAAP+AAAAAAAA///gAAAAAAB//gAAAAAAAP//4AAAAAAAf/wAAAAAAAD///AAAAAAAP/4AAAAAAAA// + /4AAAAAAD/+AAAAAAAAP///AAAAAAB//AAAAAAAAB///4AAAAAAf/wAAAMAAAAf///AAAAAAP/8AAAHw + AAAH///wAAAAAD//AAAD+AAAB///8AAAAAB//wAAA/gAAAf///AAAAAAf/8AAAf4AAAD///wAAAAAP// + gAAP+AAAA///8AAAAAH//4AAH/AAAAP///AAAAAD///AAD/gAAAD///4AAAAA///4AB/wAAAA///+AAA + AAf///AA/4AAAAH///gAAAAP///4Af8AAAAB///4AAAAH////AP+AAAAAf//8AAAAD////4H/gAAAAH/ + //AAAAB///////wAAAAB///gAAAA///////4AAAAAf//wAAAAf//////8AAAAAP//4AAAAP//////+AA + AAAH//8AAAAH///////AAAAAH//8AAAAD///////gAAAAD//+AAAAB///////4AAAAD//+AAAAA///// + //+AAAAB//+AAAAAP///////gAAAB/w4AAAAAH///////4AAAA/wAAAAAAD////////AAAA/8AAAAAAB + ////////4AAAf+AAAAAAA/////////AAAf/gAAAAAAf////////wAAP/4AAAAAAf////////+AAP/+AA + AAAAP/////////wAH//gAAAAAH/////////+AH//8AAAAAH//////////wD///gAAAAH//////////+D + ////AAAAH/////////////////gAAf///////ygAAABAAAAAgAAAAAEAIAAAAAAAAEAAAMMOAADDDgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAEAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4AAAAqAAAAOgAAAD4AAAA4AAAAJwAAAAwAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAa + AAAANAAAAD8AAAA+AAAAMAAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAACQAAABGAAAAcgAAAI4AAACX + AAAAjAAAAG0AAABDAAAAHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAQAAAAwAAAAUwAAAIIAAACZAAAAmAAAAHgAAABDAAAAFQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACkAAABV + AQEBl0pMS8GAg4LljZGQ8H2Af+NAQkK8AAAAkwAAAE8AAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAxAAAAYw0KB6NlSzfTimZL84RjSfBDMiXAAAAAigAAAEIAAAAR + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAACMAAABTBgYGnXl8e+Cnq6r/wMLB/8nMy//FyMf/t7q5/3ByctYBAQGVAAAARgAAAA4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAuAAAAYBINCaWMZ0vtlWpH/4hYM/+GWTX/ + k21O/kQzJcAAAACEAAAAPQAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAABwAAABMAgICl3Z5eN2praz/zM7O/72/vviEh4bhk5eW86ywr/+8v77/ + VVdWxgAAAHgAAAAtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAsAAAAXA4KB6KNaEvr + mWpF/4hUK/+FUir/glAp/4RVMf+SbU/9NikeuAAAAHwAAAA6AAAACQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYAAABHAAAAkmhratSmqqn/yMrK/8XGxvYYGBim + AAAAigcHB56Ag4Pmr7Kx/6eqqfUDAwOcAAAAQgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAq + AAAAWAsIBaCNZ0rooHBK/45YLv+LViz/iFQr/4VSKv+BUCn/hlg0/5BsTvopHxeyAAAAcwAAADYAAAAF + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEAAABCAAAAi1hbWsqjp6b/ + w8bF/8vNzP+cnZ3aAAAAdAAAADwAAABiPT8+uqWpqP+3urn/KSoqsAAAAFMAAAAPAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAiAAAAVAcFBJ2NZkjkqHdR/6FvSP+WYTj/jlct/4tWLP+IUyv/hFIq/4FQKf+HWzj/ + jGlN9h4XEKwAAABqAAAAMgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAA9 + AAAAhEhKScCgpKP+wcTD/8TGxf/Iysn/oaKi3QAAAHgAAAA9AAAAZkBCQbynq6r/tbi3/zQ2NbYAAABY + AAAAEgAAAAAAAAAAAAAAAAAAAAAAAAANAAAARwIBAZeKZEffr31W/7GDX/+sfVj/onFL/5VgNv+OVy3/ + i1Us/4hTK/+EUSr/gU8p/4pePP+HZkrxFA8LpwAAAGEAAAAuAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAgAAAA5AAAAezg6ObidoaD9v8LB/8TGxv/Bw8L/wcTC/8PFxPk1NTWvAAAAkQ0NDaOHi4rq + rrGw/6+zsv4UFRWnAAAATAAAAAsAAAAAAAAAAAAAAAAAAAAAAAAAJgAAAHFdRC/Fs35V/7uNav+8knL/ + tIdl/6t8V/+icEn/lF41/45XLf+LVSz/h1Mr/4RRKv+BTyn/jGFA/4FhR+wMCQaiAAAAWQAAACkAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAUAAAA1AAAAcSorK7GYnJv6vL++/8THxv/BxMP/vsC//7q9vP++wMD/ + vb+/+5iamuikp6b4r7Kx/7G0s/+AgoLfAAAAjQAAADkAAAABAAAAAAAAAAAAAAAAAAAAAAAAADAAAACG + kWlK46pwQv/FnH3/xZ1+/7yScf+zhmT/q3tW/6FvSP+UXTP/jlct/4pVLP+HUyv/hFEq/4FQKf+OZUT/ + eVtD5QYEA50AAABSAAAAIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAxAAAAZx0eHauTl5b1uLu6/8XHxv/BxMP/ + vsHA/7u+vP+3urn/tLe2/7O2tf+ytbT/rbCv/7Czsv+cn5/wExQUpgAAAFgAAAAdAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAArAAAAfHpZPtWveE7/s35V/8qmif/EnH3/u5Fw/7OGY/+qelX/oG5H/5NcMv+OVy3/ + ilUs/4dTK/+EUSr/gVAq/5BnR/9wVD3dAgEBlwAAAE0AAAAdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAsAAAAXhISEqWNkI/w + tLe2/8XHxv/BxMP/vsHA/7u+vP+4urn/tLe2/7G0s/+tsa//qq6s/7Czsv+doJ/wGBkZqAAAAGgAAAAx + AAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFwAAAFQUDgqlo3ZT8K52Sv+1gVn/yqWJ/8ObfP+6kG// + soVi/6l6VP+gbUb/klwx/41XLf+KVSz/h1Mr/4RRKv+CUSv/kmpK/2RLN9UAAACSAAAASAAAABcAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAm + AAAAVgkKCp+FiIfpsLOy/8XHxv/CxMP/vsHA/7u+vf+4urn/tLe2/7G0s/+usbD/qq6s/7C0s/+cn5/w + FxgYqAAAAGgAAAA0AAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAwAAAAZhsUDqikd1Tw + rnVK/7aDW//KpYj/w5t7/7qPbv+yhGH/qXlT/59sRP+SWzD/jVct/4pVLP+HUyv/hFEq/4JSLP+TbE3/ + V0EvywAAAI0AAABDAAAAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAfAAAATwMDA5p7fn3hrK+u/8XHxv/CxMP/v8HA/7u+vf+4u7r/tbi2/7G0s/+usbD/ + q66t/7G0s/+cn57wFxcXqAAAAGcAAAAzAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAABQAAADMAAABoHBQOqKR3VPGtdUn/toRd/8mkh//Cmnv/uY5t/7GDYP+oeFP/nmtD/5FaL/+NVy3/ + ilUs/4dTK/+DUSr/hFQu/5RtTv9INijDAAAAhgAAAD8AAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAASQAAAJRvcXHYqKyr/8THxv/CxMP/v8HA/7u+vf+4u7r/ + tbi2/7G1s/+usbD/q66t/7G0s/+cn57vFhcXpwAAAGcAAAAzAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAANAAAAGgdFQ+ppXdU8a11Sf+4hl//yaSG/8GZev+5jmz/ + sIJf/6h3Uv+daUH/kVov/41XLf+KVSz/hlMr/4NRKv+FVjH/lG1P/TssILsAAAB/AAAAOwAAAAoAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAAAARAAAAI5gYmHOpamo/8PGxf/CxMP/ + v8HA/7u+vf+4u7r/tbi3/7K1s/+usrD/q66t/7G0s/+bnp3vFhYWpwAAAGYAAAAzAAAABQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAA0AAAAaR4WD6mleFTy + rXVJ/7iIYv/Jo4b/wZh5/7iNa/+wgl7/p3ZR/5xoQP+QWS7/jVct/4lVLP+GUyv/g1Eq/4dYNP+SbU/7 + LiIZtAAAAHYAAAA3AAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAAAAPwAAAIdPUVHE + oqal/8LEw//CxcT/v8LB/7y/vf+4u7r/tbi3/7K1tP+usrD/q66t/7G1tP+anZ3uFRUVpwAAAGUAAAAz + AAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAABQAAADQAAABqHxYQqqZ4VfKtdEj/uYlk/8iihf/Al3j/uIxq/6+BXf+mdlD/m2c+/5BZLv+MVy3/ + iVUs/4ZTK/+DUSn/iFs3/49rTvgiGRKuAAAAbQAAADQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK + AAAAOwAAAH8/QUC8n6Oi/sDCwf/CxcT/v8LB/7y/vf+5u7r/tbi3/7K1tP+vsrH/q6+t/7K1tP+anZzu + FBUVpgAAAGUAAAAyAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAANQAAAGsgFxCqpnlV8q10SP+6i2b/yKGE/8CXd/+3i2n/ + r4Bc/6Z1T/+aZTz/kFgu/4xXLf+JVCv/hlMq/4NRKf+LXjv/imdM8xcRDakAAABkAAAALwAAAAIAAAAA + AAAAAAAAAAAAAAAGAAAANwAAAHYwMTG0m5+e+73Av//DxcT/v8LB/7y/vv+5vLr/tbi3/7K1tP+vsrH/ + q6+t/7K1tP+ZnJzuFBQUpgAAAGQAAAAyAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAA1AAAAayEYEauneVXz + rXRI/7uMZ//HoYP/v5Z2/7eLaf+uf1v/pXRO/5lkOv+QWC7/jFYs/4lUK/+GUir/glAp/41hP/+EY0ju + DgsIowAAAFwAAAArAAAAAQAAAAAAAAADAAAAMwAAAGwiIyOtlpmY97q9vP/DxcT/v8LB/7y/vv+5vLv/ + trm3/7K1tP+vsrH/rK+u/7K2tP+ZnJvtExQTpgAAAGQAAAAyAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAABgAAADUAAABsIhkRq6d5VfOtdEj/vI1p/8eggv++lXX/topo/65/Wv+lc03/mGI5/49YLf+MViz/ + iVQr/4ZSKv+CUCr/j2RD/31dRecHBgSeAAAAVQAAACUAAAACAAAALgAAAGIWFxeokJOS8ra5uP/DxcT/ + wMLB/7y/vv+5vLv/trm4/7O2tP+vs7H/rK+u/7O2tf+Ym5rtEhMTpQAAAGMAAAAyAAAABAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAANgAAAG0jGRKrqHpW9K10SP+9jmv/xp+B/76UdP+2iWf/ + rX5Z/6RyTP+XYTf/j1gt/4xWLP+JVCv/hVIq/4NRKv+RZ0f/dFc/4AMCApkAAABPAAAAQwAAAFkNDQ2i + iIyL7LK1tP/DxsX/wMPC/72/vv+5vLv/trm4/7O2tP+vs7H/rK+u/7O2tf+YmprtEhISpQAAAGMAAAAx + AAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAA2AAAAbiQaEqyoelb0 + rXRI/72QbP/GnoD/vZNz/7WIZf+sfVj/o3FL/5ZgNv+PWC3/jFYs/4lUK/+FUir/g1Ir/5NqSv9pTznY + AAAAogAAAIQFBQWmf4OC5a6xsP/DxsX/wMPC/73Av/+6vLv/trm4/7O2tf+ws7L/rLCu/7O2tf+Xmpns + ERISpQAAAGIAAAAxAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAABwAAADYAAABvJRsTrKl6VvStdEj/vpFu/8Wef/+9k3L/tIhk/6x8V/+jcUr/lV40/49YLf+MViz/ + iFQr/4VSKv+EUyz/lGxM/1ZAL90AAADSUVNT5pibmv/CxMP/wMPC/73Av/+6vbv/trm4/7O2tf+ws7L/ + rLCu/7O3tv+WmZnsERERpQAAAGIAAAAxAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAANgAAAG8mHBOtqXtW9a10SP+/km//xJ1+/7yScf+0h2T/ + q3xW/6JvSP+UXTP/j1gt/4xWLP+IVCv/hVIq/4VULv+WbU7/VEQ49ktNTP+AgoL/pqin/7u+vf+6vbv/ + trm4/7O2tf+ws7L/rbCv/7S3tv+WmZjrEBERpAAAAGEAAAAxAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAA3AAAAcCccFK2qe1f1 + rXRI/7+TcP/EnH3/vJFw/7OGY/+re1X/oW5H/5RdMv+PWC3/i1Ys/4hUK/+FUir/hlYx/5ZuUP9aT0X/ + V1lY/4aIh/+mqaj/tLe2/7O2tf+ws7L/rbCv/7S3tv+VmJfrEBAQpAAAAGEAAAAwAAAAAwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAACAAAADcAAABxKB0Vrap7V/WtdEn/v5Rx/8ObfP+7kG//s4Vi/6p6VP+gbUb/k1wx/45YLf+LViz/ + iFQr/4VSKv+IWDT/kW1R/z9AP/92eHf/nJ6d/6Cjov+vsrH/rbCv/7S3tv+Ul5frDxAPpAAAAGAAAAAw + AAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAANwAAAHIpHhWuq3xX9q11Sf/AlHL/w5t7/7uQbv+yhWH/ + qnlT/59sRP+SWzD/jlgt/4tWLP+IVCv/hVIq/5lxUv9APzz/bm9v/5SWlf+XmZj/oqSj/7S4tv+Ul5bq + Dw8PowAAAGAAAAAwAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAA4AAAAciofFq6rfFf2 + rnVJ/8CVc//Cmnr/uo9t/7KEYP+peFL/nmtD/5JaL/+OVy3/i1Ys/49eOP+MalD/Ozs7/25wb/+Mj47/ + kZSS/6Cjov+TlpXqDg4OowAAAF8AAAAvAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAACAAAADgAAABzLCAWr6t8V/atdUr/wZZ0/8KZev+6jmz/sYNf/6h4Uf+daUH/klov/45XLf+XaUX/ + xMK7/1FTUv9OUE//bnBv/5CSkv98f37qDg4OowAAAF4AAAAvAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAAAAOAAAAHQtIBevrHxY9652Sv/BlnX/wZh5/7mNa/+xgl7/ + pXJL/5VdMf+WYzv/xcG3/9Pa1//Jzsv/S0xM/1JTU/9bXVzuCgsLpAAAAF4AAAAvAAAAAwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAeAAAAJgAAACAAAAAK + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkAAAA4AAAAdSsfFrurfFf5 + rnZL/8GWdf/Bl3j/tIVg/5xiNf+cZTr/1MzB/9nf3P/Q2NT/1NvX/8XKyP89Pj33BQUFyAAAAH0AAAAy + AAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkAAAA/ + AAAAYQAAAHIAAABlAAAAQgAAABoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAACQAAAFAAAACfJhwU36x9Wf+sc0f/rXRI/6ZsPv+kbUH/1cm9//H08//l6ef/2d/c/9DY1P/U29f/ + vcLA+hobGsgAAACAAAAAMwAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAABMAAABHAAAAjhwcG7Q2NjPLIiEguAAAAJAAAABIAAAAGQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAABgAAABQAAAArDU3NulWTkb/rH9b/7SAV/+xgVv/xLqt/9Pa1//q7uz/ + 8fPy/+Tp5//Y3tv/0NjU/9Tb2P+9wsDyGRkZpgAAAGEAAAAvAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1AAAAgjMzMMhbWlX/T05I/1pZVP83NjPMAAAAjwAAAEYAAAAX + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIAAABEAAAAjVlbW8+Ag4L/amtr/05MSv9fVUz/ + T0xI/2NlZP/Q1tP/09rW/+zv7f/w8/L/5Ojm/9fe2//P19P/1dzY/7vAvesTFBOjAAAAXQAAAC0AAAAC + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAAAASQkJCKVbWlX8PDo0/zY0Lv87OTP/ + WlhT/zMyMMgAAACMAAAARAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB + AAAAJgAAAD0AAAA2AAAAKgAAAB0AAAARAAAABAAAAAAAAAAAAAAAAAAAAA0AAAA/AAAAhk1PT8Ojp6b/ + uLu6/5iamf+Fh4b/d3l4/3x+ff9cXl3/Zmhn/9PZ1v/T2tf/7fDv//Dy8f/j6OX/193a/8/X0//V3Nn/ + tru46A4PDqAAAABZAAAAKgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAFQaGhmy + V1ZR/zY0Lv82NC7/NjQu/zw6Nf9aWVT/Ly4sxAAAAIkAAABCAAAAEgAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAHAAAAFIAAACSAAAAiQAAAHYAAABjAAAATwAAAEAAAAA2AAAAKgAAAB4AAAA6 + AAAAfj0/P7ufo6L9vsHA/7/Cwf+8vr3/rrGw/6Wop/+ipaT/homH/1xdXf9gY2L409nW/tPa1//v8fD/ + 7/Lw/+Pn5f/W3dn/z9fT/9bc2f+wtbLlCgoKngAAAFYAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAgAAABHBgYGollYVPhCQDr/NjQu/zY0Lv82NC7/Pj03/15dWP4qKijAAAAAhgAAAD8AAAAL + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQAAAD8AAACPbnFw1Hp9fOFeYWDNPT4+uhQVFacAAACb + AAAAiQAAAHYAAABjAAAAdy8wL7Obn577vL69/7/Cwf+8v77/uby7/7W4t/+ytbT/r7Kx/62wr/9oamrs + AwMD0VFTUtXW3Nn+09vX//Dy8f/u8fD/4ufk/9Xc2f/P19P/1t3Z/6qurOEGBwabAAAAUwAAACUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMgAAAHkiIiC4XFtW/zc1L/82NC7/NzUv/0RCPP9dW1b/ + Z2Zi/SQkIroAAAByAAAAKgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC8AAABxU1RUuuTl5f/Z29r/ + ycvK/7i7uv+orKv/kpWU9Hp9fOFeYWDOPT8+ui8wMLOVmZj3uby7/8DCwf+8v77/uby7/7a5uP+ytrT/ + r7Ox/7e6uf+Mj47lCQkJpgAAAIMAAACbZGdmwdfd2v7U29f/8fPy/+7x7//h5uT/1NvY/8/X0//W3dr/ + o6el3QQEBJkAAABQAAAAIgAAAAAAAAAAAAAAAwAAAAIAAAAAAAAADQAAAD4AAACJOTk2zlVUT/82NC7/ + ODYw/0VDPf9XVlH/amhk/4KBff9cW1fwAAAAlQAAADsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoAAABS + EhISo9LT0/Ti5OP/4OLh/97f3//b3Nv/19nY/9HT0//DxcT/tbi3/6msq/+fo6L/trm4/8DCwf+9v77/ + uby7/7a5uP+ztrT/sLOy/7e6uf+Ljo3lCQkJnwAAAFoAAAA7AAAAQwAAAIpucXDF197b/9Tb2P/y9PP/ + 7fDv/+Hm4//T29f/z9fT/9fd2v+bn53ZAgIClwAAAE0AAAArAAAANgAAAD8AAAA/AAAANgAAAD8AAAB+ + JCQiultZVP47OTP/NjQu/z89N/9ZV1L/a2pl/318eP+SkY3/b25q+QAAAJsAAAA+AAAAAAAAAAAAAAAA + AAAAAAAAAAgAAAA+AAAAjaChodnk5eX/4OLh/97f3//b3Nz/19nY/9TW1f/R09L/zc/P/8rMy//Hycj/ + w8bF/8DDwv+9wL7/uby7/7a5uP+ztrX/sLOy/7e6uf+LjY3lCQkJnwAAAFkAAAAsAAAAAgAAABUAAABE + AAAAjXh8esnY3tv/1dzZ//L09P/t8O7/4OXj/9Pa1v/Q2NT/193a/5KWlNUAAACUAAAAYAAAAIYAAACb + AAAAmgAAAIkAAACTIyMhulpZVPpBPzn/NjQu/zo4Mv9YVlH/cXBs/4KBff+RkI3/lpWS/0hHQ90AAACH + AAAANAAAAAAAAAAAAAAAAAAAAAAAAAAuAAAAb1RUVLnl5ub/4OLh/97g3//b3Nz/19nY/9TW1f/R09L/ + ztDP/8rMy//Hycj/xMbF/8DDwv+9wL//ur27/7a5uP+ztrX/sLOy/7e6uf+KjYzkCAgInwAAAFkAAAAs + AAAAAgAAAAAAAAAAAAAAFwAAAEcAAACPgoaEztje2//W3dn/8/X0/+zv7v/g5eL/0tnW/9DY1P/X3tv/ + iY2L0Q8PDqZcXFnYd3Vy9G9ua/NZWFXhVVRQ6FtaVf9CQDr/NjQu/zk3Mf9WVE//cnBs/4mIhfhoZ2L6 + cG9r/09OSucKCgqlAAAAWAAAABwAAAAAAAAAAAAAAAAAAAAZAAAAUBMTE6LT1NTz4uPj/97g3//b3Nz/ + 2NnZ/9TW1v/R09L/ztDP/8rNzP/Hycj/xMbF/8DDwv+9wL//ur27/7a5uP+ztrX/sLSy/7i7uv+JjIvk + CAgIngAAAFgAAAArAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAaAAAASQAAAJKMkI7S197a/9fe2v/09fX/ + 6+/t/9/k4f/R2dX/0NjU/8/U0f+EhID4dXRw/2BfWv9ZV1L/VVNO/0RDPf84NjD/NjQu/zg2MP9VU07/ + a2ll/46Niv40MzK3BgUFow4NDagAAACXAAAAXwAAADAAAAABAAAAAAAAAAAAAAAHAAAAPQAAAIyjpKTZ + 5OXl/9/g3//b3dz/2NrZ/9TW1f/CxMT/y83M/8vNzP/Hysn/xMbF/8HDwv+9wL//ur28/7e6uf+ztrX/ + sLOy/7e6uf+Ii4vjBwgIngAAAFgAAAArAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0AAABL + AQEBlZWZl9fX3dr/2N/b//T29f/r7u3/3uPh/8fOyv96enb/amhk/1pYU/9SUEv/SUdB/zg2MP82NC7/ + NjQu/zc1L/9TUUz/Z2Zh/4WEgf9nZ2XWAAAAigAAAEsAAABQAAAAQAAAACcAAAADAAAAAAAAAAAAAAAA + AAAALQAAAG1ZWVm65ebm/9/h4P/b3dz/2NrZ/9XX1v+1uLf/l5ua+Z2hoP6prKv/tLe3/77Av/++wL// + ur28/7e6uf+0t7X/sLOy/62wr/+mqqn/QkNDvQAAAGkAAAAtAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAIAAAAE4CAgKXnaKg29fd2v/Z4Nz/9Pb1/+Dj4f98fHj/YmFc/1pZVP9SUEv/ + SUdC/zk3Mf82NC7/NjQu/zc1L/9RT0r/Z2Vh/3d1cf+XlpP8FRUUpwAAAFIAAAAeAAAAEAAAAAUAAAAA + AAAAAAAAAAAAAAAAAAAAGAAAAE8XFxei1tfX9OHi4v/c3d3/2NrZ/9XX1v+4u7r/kJOS8xoaGqkXFxeo + T1FRxHp9feGZnZz7pain/7e6uf+0t7X/sLSy/62wr/+qraz/oqal/2RnZtEAAAB1AAAAJgAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjAAAAUQQFBJqlqqff1t3a/9TZ1v+Egn// + Y2Fc/1tZVP9TUUz/SklD/zo4Mv82NC7/NjQu/zY0Lv9PTUj/ZmRg/3Rybv+NjIn/d3Z02wAAAIYAAAA2 + AAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAADwAAACLqamp2+Pk5P/c3d3/2NrZ/9XX1v+8v77/ + kpaV9R8gIKwAAABsAAAAUgAAAG8AAACMCAgIoouOju6ws7H/sLSy/62wr/+qraz/p6qp/6Onpv+Ymprm + AAAAigAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYAAABU + BwgInKerqeOMjIj/Y2Fd/1tZVP9TUUz/S0lE/zs5M/82NC7/NjQu/zY0Lv9NS0b/ZWRf/3Nybf+CgX3/ + oqGe/isrKrAAAABcAAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoAAABrX2BgvOXm5v/d3t3/ + 2drZ/9XX1v+/wsH/lZmY9yUmJa4AAABwAAAANgAAABYAAAAmAAAAOgAAAHloamnUqKuq/62xr/+qraz/ + p6qp/6Sopv/Bw8L/xsjH+gMDA50AAABBAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAABAAAANAAAAH9aWVbVdXNv/1taVf9TUkz/S0lE/zw6NP82NC7/NjQu/zY0Lv9LSUT/ + ZWNe/3Jxbf+Af3v/nJuY/3h3dtgAAACLAAAAOgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9 + AAAAmMfIyO3g4eH/2dra/9bX1//CxcT/l5ua+SssK7EAAAB1AAAAOAAAAAgAAAAAAAAAAAAAABkAAABf + Oz09uqGlpP+qrqz/p6up/6Sopv+/wsH/ztDP/87Qz/8yMjKvAAAAUwAAABAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADcAAACRc3Jv72NhXP9UUk3/TEpE/z07Nf82NC7/ + NjQu/zY0Lv9JR0L/ZGJe/3JwbP9/fnr/lpWS/5uamPENDQ2hAAAAUQAAABkAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAMgAAAHQ5Ojqy1NXV+dja2f/Fx8b/mp2c+jEyMrQAAAB5AAAAOQAAAAkAAAAA + AAAAAAAAAAAAAAAIAAAARgkJCaKanp38p6up/6Sopv+9wL//ztDP/8zOzf/Nz87/Z2hnxAAAAGgAAAAe + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2AAAAj2tqZ+xdW1f/ + TEpF/z07Nf82NC7/NjQu/zY0Lv9HRT//Y2Jd/3Fwa/9/fXr/k5KP/6alovoqKimvAAAAaQAAAC4AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkAAAA6AAAAej4/P7XDxcT7nKCf/Dc5OLcAAAB9 + AAAAOwAAAAsAAAAAAAAAAAAAAAAAAAAAAAAADgAAAEAAAACVgYWE56Kmpf+6vbz/ztDP/8zOzv/Lzcz/ + y87N/5KTktkAAAB9AAAAKwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAKQAAAHVDQ0DLY2Fd/z48Nv82NC7/NjQu/zY0Lv9FQz3/YmFc/3Bva/9+fXn/kZCN/6enpPw8PDu3 + AAAAegAAADgAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwAAADsAAAB+ + ODo5uD5AP7sAAACBAAAAPQAAAA0AAAAAAAAAAAAAAAAAAAAAAAAADAAAADwAAACAPD09upmdnPyxtLP/ + ztDP/8zOzv/Lzcz/ycvK/8nLyv+1t7buAAAAkQAAADkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAABMAAABWISEftF1bVv82NC7/NjQu/zY0Lv9DQTv/YmBb/3Buav99fHj/ + j46L/6mopf1HR0a8AAAAgQAAAD0AAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAANAAAAPQAAAHoAAAB8AAAAPwAAAA8AAAAAAAAAAAAAAAAAAAAAAAAACgAAADsAAAB8 + NTY2tpicm/uqraz/ztDP/83Pzv/Lzcz/ycvK/8fKyf/GyMf/zM7N/hAQEKMAAABGAAAABwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASAAAAVx0dG7RWVVD/NjQu/zY0Lv9BPzr/ + YV9a/29uaf99e3f/jo2J/6mopv5SUlHCAAAAhgAAAEAAAAAPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4AAAAyAAAAMwAAABAAAAAAAAAAAAAAAAAAAAAA + AAAACQAAADkAAAB4LzAws5ebmvqnq6r/ztDP/83Pzv/Lzcz/ycvK/8fKyf/Gycj/y83M/8XHxvknKCir + AAAAVQAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKwAAAHI1NDHJ + T05I/zY0Lv8/PTj/YF5Z/25taf98e3f/jIuI/6iopf9eXVzIAAAAiwAAAEMAAAASAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAABwAAADcAAABzKCopsJWZmPilqaf/zc/O/83Pzv/Lzcz/ycvL/8jKyf/Iy8r/ + ztDP/6WmpuMgICCpAAAAewAAAD4AAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAFgAAAEoDAwOcVVRP8UE/Ov8+PDb/Xl1Y/25saP97enb/i4qG/6inpP9paWfOAAAAjwAAAEYAAAAW + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAADUAAABvIyQjrZSXlvajp6X/zM7N/83Pzv/Lzcz/ + ycvL/8jKyf/Mzs3/ycvK+mprasUBAQGWAAAAXQAAADYAAAAOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAFQAAAEIAAACLOjo20FRTTf89OzX/XVxX/21sZ/97eXX/iomF/6alo/90dHLV + AAAAkwAAAEkAAAAaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAADMAAABqHR4eq5GVlPShpaT/ + y83N/83Pzv/Lzcz/yczL/8rMy//P0dH/rK6t5ycoKKsAAAB+AAAARgAAACUAAAADAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAIwAAAEcAAACKLCspwVpZVP5APjn/XFpV/2xrZv96eXX/ + iYiE/6Wkof9+fXzbAQEBlgAAAE0AAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAABP + Dg4OpI+SkvKhpKP/yszL/83Pzv/Lzc3/yszL/83Pz//Mzs77dHV0yQMDA5gAAABfAAAANwAAABEAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAZAAAAOAAAAFsAAACVNDMwyVtaVf5CQTv/ + WllU/2xqZv95eHT/iYiE/6Sjof+EhILfBAQEmgAAAFAAAAAiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAIAAAARQAAAJNwc3LV0tTT/87Qz//Lzc3/zM7N/9HT0v+ztbTqMDAwrgAAAIEAAABI + AAAAJwAAAAQAAAAAAAAAAAAAAAAAAAAJAAAAIwAAACYAAAAbAAAAHgAAACoAAAA8AAAAVQAAAIMPDg6p + SUhE4VhXUv9APjj/WVdS/2tqZf95d3P/jIuI/6amo/95eHfYBAQEmgAAAFQAAAAmAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAABNAQEBlpiZmdnT1dX/z9HQ/9DR0f1+f3/N + BQUFmgAAAGIAAAA5AAAAEgAAAAAAAAAAAAAAAAAAAAAAAAADAAAAOgAAAGgAAABwAAAAYQAAAGUAAAB1 + AAAAkA4ODak8OzjRW1pV+k1MRv86ODP/V1VQ/2ppZP9+fHj/lpWS/5+fnPdQUE/BAAAAkgAAAFAAAAAn + AAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIgAAAE8DAwOZ + n6Cg3ru8vO46OjqxAAAAhAAAAEoAAAAoAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAFMCAgKg + HRwbtCQkIrooKCW+Nzc0zExMSOVdXFf+WFdS/0ZEPv9CQTv/YmBb/3t5df+OjYr/lJOQ9mZmZNARERGl + AAAAegAAAEQAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAlAAAAUgYGBpsKCgqdAAAAZQAAADoAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAUAAAA+AAAAdgAAAJULCwunKCclvTs6N9BIR0PfUE9L6lRUT/BVVFDxZGNf7GloZeJaWVfQ + Nzc2uAQEBJ8AAAB/AAAAUgAAADQAAAAOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACcAAABJAAAASAAAACoAAAAFAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAC0AAAA+AAAAUAAAAGYAAAB4AAAAhwAAAJEAAACX + AAAAmAAAAJMAAACJAAAAeQAAAGIAAABHAAAANAAAABgAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAA0AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAABEAAAAf + AAAAKwAAADQAAAA7AAAAPgAAAD8AAAA8AAAANQAAACwAAAAeAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAA/8//////wH/+A/////8AH/wB/////gAf+AD////+AA/wAH////wAD+AAP///+AAH + wAAf///wAAfAAA///+AAB4AAB///wAAHgAAD//+AAAeAAAP//wAAD4AAAf/+AAAPgAAA//wAAB+AAAB/ + /AAAP8AAAD/4AAB/4AAAH/AAAP/wAAAP4AAB//gAAAfAAAP//AAAA4AAB//+AAABAAAP//8AAAAAAB// + /4AAAAAAP///wAAAAAB////gAAAAAP////AAAAAB////+AAAAAP////8AAAAB/////4AAAAP/////wAA + AB//////gAAAP//////AAAB/+D///+AAAP/wH///8AAA/+AP///wAAB/wAf//+AAAD/AA/4BwAAAH8AB + /gAAAAAPwAD8AAAAAAfgAPgAAAAABkAA+AAAAAAAAADwAAAAAAAAAOAAAAMAAAAA4AAAB4AAAADAAAAP + wAAAAYAAAB/gAAAHgAAAP+AAAB8AAAA/8AAAPwAAAB/4AAA/AAwAH/wAAH8AHAAf/AAAfwA8AB/8AAD/ + gHgAH/wAAf/A8AAP/AAD/+HgAA/8AAf//8AAD/gAD///gAAf8AAf//8AAD/AAD///wAA/wAAf///AAHA + AAB///+AB4AAAP///8APgAAB////wD+AAAf////gf8AAD/////H/8AA///8oAAAAMAAAAGAAAAABACAA + AAAAAAAkAADDDgAAww4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAA0AAAAQ + AAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAt + AAAASQAAAEwAAAAyAAAAEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQ + AAAAPAAAAGMAAABqAAAASgAAABcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAGAAAAFUODg6TREVFvklKSsAXGBidAAAAYAAAACEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAABEAAABRGhMOn2VLN9RuUz3dKh8XrQAAAFkAAAAVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAUAAAAWTIzM7GXm5r0uby7/77AwP+tsK/6R0lJvQAAAGMAAAAVAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAADwAAAE4jGhOmkmpL9YxcN/+FVjH/i2ZI+CkfFqwAAABSAAAAEAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAA8AAABQKisqq52gn/jJy8r/mJqa4m1wb9WhpKP5s7a2/CcoKKgAAAA7 + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAASyAYEaGWbU3ykFw0/4hUK/+EUSr/g1Mu/4hkR/QeFxCj + AAAASQAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwAAAEgdHR2hlpmY9MLFxP+4urntAgICggAAAGlJS0vA + rrGw/3R2ddQAAABfAAAACAAAAAAAAAAAAAAAAAAAAAkAAABFGxQOnZpvTvChb0j/k10z/4xWLP+IVCv/ + g1Eq/4RVMf+EYkfwEw4KmQAAAEIAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAQBITE5eNkI/uvsHA/8XHx/+rrazk + AAAAZwAAAEMwMjGvqa2s/4iKiuAAAABpAAAADQAAAAAAAAAAAAAAAAAAAC4PCweQnXFP7bKDXv+vgF3/ + onBK/5JcMv+MViz/iFMr/4NRKv+GVzP/fl5E6g0KB5IAAAA8AAAABQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAA4CwsLjoSHhue7vr3/ + w8XF/7/Cwf/DxcT8Tk9PuB0eHqSChYTksLOy/2ttbNAAAABdAAAABgAAAAAAAAAAAAAAAwAAAFRmSjTK + sHpP/8Sdfv+5jm3/rn9b/6FvSP+SWzH/jFYs/4dTK/+DUSr/iFo3/3ZYQOIHBQSJAAAANAAAAAMAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAADEEBASE + eXx737i7uv/DxsX/v8LB/7q9vP+4u7r/ur28/7O2tf+vsrH/pKem9RkaGpwAAAA1AAAAAAAAAAAAAAAA + AAAAAwAAAFVoSzXKrXRI/8Sbe//EnH3/uI1s/61+Wv+gbkb/kVow/4tWLP+HUyv/g1Eq/4pdO/9sUTvb + AQEBfwAAAC4AAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAKgEBAXprbW3WtLe2/8TGxf+/wsH/u768/7a5uP+ytbT/rbGv/6uvrv+nqqn3KywsqwAAAFMAAAAO + AAAAAAAAAAAAAAAAAAAAAAAAAC8NCQePmW5N6a11Sf/EnHz/w5t8/7eMav+sfVn/n2xF/5BaL/+LViz/ + h1Mr/4NRKf+MYD7/YUg10gEBAXcAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAkAQEBcV1fXsyws7L/xMbF/7/Cwf+7vr3/t7m4/7K1tP+usbD/rK+u/6apqPYrLCuq + AAAAVAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAABBFA4KlpluTemudkr/xZx9/8Kae/+3i2n/ + q3xX/55rQ/+QWS//i1Us/4dTK/+CUCr/jmNC/1M/LskAAABuAAAAIgAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAB0AAABmTU9Ow6uurf7DxsX/wMLB/7u+vf+3urn/srW0/66xsP+sr67/ + pqmo9SssLKoAAABVAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAQxQPCpaab07q + rnZL/8Wdff/BmXr/topo/6p7Vv+daUH/j1ku/4tVLP+GUyv/g1Eq/49lRf5FNCbAAAAAZAAAABwAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFwAAAF09Pj64pqqp/cPFxP/AwsH/u769/7e6uf+ztrT/ + rrGw/6ywrv+mqaj2KSoqqQAAAFQAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAACgAAAEMTDgqWm3BO6653TP/FnX7/wZh4/7WJZ/+qelX/m2g//49YLv+KVSz/hlMr/4NSK/+PZ0f9 + OCoftwAAAFwAAAAXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARAAAAVTAxMa+gpKP6wsXE/8DDwv+8v73/ + t7q5/7O2tf+usrD/rbCv/6Wop/UoKSmpAAAAUwAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAsAAABDFhALmJtwTuuveE3/xZ1+/8CXd/+1iGX/qXlU/5pmPf+PWC3/ + ilUs/4ZTKv+EUyz/jWdI+S0iGa4AAABUAAAAEQAAAAAAAAAAAAAAAAAAAA0AAABLIyQjppmcnPbAw8L/ + wMPC/7y/vv+4urn/s7a1/6+ysf+tsK//pain9SgpKagAAABTAAAAEwAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAARRcRDJiccU/sr3hO/8Wdfv+/lnb/ + tIdk/6h4Uv+ZZDv/jlgt/4pVLP+GUir/hVQu/4tmSPYhGRKmAAAASwAAAA0AAAAAAAAACAAAAEMWFhab + kZWU8b7BwP/Bw8L/vL++/7i7uf+ztrX/r7Kx/62xr/+mqaj1JycnqAAAAFMAAAATAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwAAAEQVEAuY + nXFP7LB5T//FnX7/vpV1/7OGY/+od1H/mGM5/45YLf+KVSz/hVIq/4ZWMf+IZEjyFxEMnQAAAEUAAAAP + AAAAPA4PDpKIjIvqvL++/8HDwv+8v77/uLu6/7S3tf+vs7H/rrGw/6SnpvQmJyanAAAAUQAAABMAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAsAAABFGBIMmp1xT+ywelD/xZ1+/76Uc/+yhWL/p3ZQ/5dhOP+OWC3/ilUs/4VSKv+HWDP/ + gWBF6w8LCJUAAABlBwcHi32BgOK5vLv/wcTD/72/vv+4u7r/tLe2/6+zsf+usbD/pKem9CYnJ6cAAABS + AAAAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAARhkSDZueck/tsXtR/8Wdff+9k3L/soRg/6Z0Tv+WYDb/ + jlct/4pVLP+FUir/iVs2/3dZQeoGBAPFV1lY4q+ysf/BxMP/vcC//7i7uv+0t7b/sLOy/66xsP+lqKf0 + JCUlpgAAAFEAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAEYYEQyan3JQ7rF8Uv/EnH3/ + vJJx/7GDX/+lc03/lV80/45XLf+JVCv/hVIq/4tdOv9xWEP6UlNS/4yOjf+1uLf/uby6/7S3tv+ws7L/ + rrKw/6OmpvMjJCSlAAAAUAAAABIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAABH + GxQOnJ9yT+6yfFP/xJx9/7uRb/+wgl7/pHJL/5ReM/+NVy3/iVQr/4VSKv+NYD7/alhI/2NlZP+anJv/ + ra+u/7Czsv+vsrH/o6al8yQlJKUAAABQAAAAEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAMAAAASBwUDp2gc1Dusn1U/8SbfP+7kG7/r4Fc/6NxSf+TXTL/jVct/4lUK/+FUir/ + hmZO/1NVVP+Mj47/mZua/62wr/+kp6bzIiMipAAAAFAAAAARAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAEgbEw6coXNQ77N+Vf/Dm3v/uo9t/6+AW/+ib0j/ + k1wx/41XLf+PXTb/e2ZV/1FTUv+Ag4L/kpWU/5mcm/IhIiKkAAAATgAAABEAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAABJHhYPnqBzUO+zf1f/ + w5p7/7mObP+uf1r/oGxE/5FZLv+kg2b/zdLP/1xeXf9bXVz/d3l58xwdHaMAAABPAAAAEAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAMAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN + AAAASh4WD6Kfck/ztIBY/8Kaev+2iGX/nWQ3/66GZv/X29f/0djU/8zRz/9RU1L6DxAPwgAAAFwAAAAQ + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGQAAAEcAAABkAAAAVgAAACcAAAAB + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAFAAAAHYaFBDXondV/611Sf+qckb/sIhm/+rq5//p7ev/2d/c/9HY1f/Izsv8 + LzAwwwAAAF0AAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAAAAXhwbGrBAQDzW + LSwqwgEBAXYAAAAqAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAOAoKCpNZW1rtWVVQ/4psVf+GalP/qqyn/9bd2f/v8fD/ + 6Ozq/9je2//R2NX/yM7L9TAxMKUAAABOAAAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAy + ExMSpFRTTvpAPjn/T05I/zc2M8sAAABzAAAAJwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAIAAAACwAAAAhAAAAFAAAAAgAAAAAAAAAAAAAAAIAAAAvBAQEg3d6ed6sr67/jY+P/29wcP9tb27/ + V1lY/7C1s//W3dr/8PLx/+fr6f/X3tr/0dnV/8XKyPIoKSihAAAASgAAAA0AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABJLy8sxEZEP/82NC7/NzUv/1BOSf4yMi/HAAAAbgAAACQAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAaAAAAahISEpsDAwOEAAAAbwAAAFwAAABFAAAALwAAADABAQF5am1s1bO2tf+/wsH/ + uby7/6yurf+mqaj/h4mI/05PT/mssK73197a//Dy8f/n6+n/1t3a/9HZ1f/CyMXwISIhnQAAAEcAAAAL + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3GRgXrFNSTfw4NjD/NjQu/zg2MP9YV1L+Li4swwAAAGkAAAAb + AAAAAAAAAAAAAAAAAAAAAAAAAAgAAABMRkdHsr3Av/yjpqXzf4KB4V9hYc4+QD+6GhsbngECAopaXVzL + sLOy/7/Cwf+7vr3/t7q4/7K1tP+xtbP/mpyc8BMTE7gUFBS0u8C97Nje2//w8/L/5uro/9Xc2f/R2dX/ + vcLA7RwdHZkAAABEAAAACQAAAAAAAAAAAAAAAAAAAAAAAAApAQAAgklIROE/PTj/NzUv/0VDPf9eXFf/ + cXBr/R4eHLEAAABAAAAAAAAAAAAAAAAAAAAAAQAAAC8MDAyNy8zM7+Hj4v/f4OD/2dra/8vNzP+7vr3/ + rK+u/ZeamvWrrq3+wMLB/7u+vf+3urn/s7a0/7K1tP+go6LwGxwcnwAAAFMAAABPHyAfm7/Fwu7Y39v/ + 8fPy/+Xp5//U3Nj/0tnV/7i9u+oVFhWVAAAAPwAAACEAAAAwAAAALwAAACwAAABlLCwqwU9NSP42NC7/ + QkA6/15dWP93dXH/kI+M/zY2M8oAAABTAAAAAAAAAAAAAAAAAAAAGQAAAGyUlJTS4uTj/9/g4P/b3Nz/ + 1tjX/9LU0//Nz8//ycvK/8THxv/Aw8L/vL69/7e6uf+ztrX/srW0/5+ioe8bGxufAAAASgAAAA4AAAAM + AAAASCQlJZ7Dycbx2d/c//Hz8v/k6ef/1NvX/9LZ1v+0ubfoEBAQkQICAn0bGxqnGRgYpgkJCZQuLivD + U1JN/Dg2MP88OjT/YV9a/359ef+Pjor/fn15/BkZF6sAAAA6AAAAAAAAAAAAAAAHAAAAS0lJSbDh4uL9 + 3+Hg/9vc3P/W2Nf/0tTT/87Qz//Jy8v/xcfG/8DDwv+8v77/t7q5/7O2tf+ytrT/nqGg7xscG54AAABK + AAAADgAAAAAAAAAAAAAADgAAAEwrLCyjx83K9Nrh3f/x8/L/4+jm/9Pa1v/T2tb/qa2q5GloZeN0c2// + a2ll/19eWfxMSkX/ODYw/zs5M/9cW1b/g4J+/EhHRcxAPzzWIB8eswAAAGMAAAAXAAAAAAAAAAAAAAAt + EBAQjMvMzO7g4eH/293c/9fY2P/KzMv/zM7N/8nMy//Fx8b/wcPC/7y/vv+4u7r/s7a1/7K1tP+foqHv + GRoangAAAEoAAAAOAAAAAAAAAAAAAAAAAAAAAAAAABAAAABPMzU0qMrQzfbb4d7/8fTy/+Ln5f/N1ND/ + hoaC/2dlYf9VU07/R0ZA/zc1L/82NC7/Ojgy/1pZVP97enb/Xl1c0AAAAHIAAABjAAAASwAAABwAAAAA + AAAAAAAAABgAAABqmJiY0+Lj4//b3dz/19nY/8PFxP+NkI/vj5OS8aqtrP60t7b/ur28/7i7uv+0t7X/ + r7Kx/6qurP9iZWTQAAAAYAAAABEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASAAAAUzo8O6vM0s/3 + 3eLf/+rs6/+FhYL/X15Z/1VTTv9IR0H/ODYw/zY0Lv85NzH/WVdS/3Bvav+Pj4v5DQ0NkgAAAC8AAAAM + AAAAAwAAAAAAAAAAAAAABwAAAElNTU2w4uPj/tzd3f/X2dj/xcjH/4uOjewTFBSYAgICgiYnJ6lZW1vK + nqKh+rS3tf+vs7H/q66t/6aqqP+FiIfkAAAAcAAAABIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAFQAAAFdCREOvzNHO+YmJhf9gXlr/VlRP/0pIQv85NzH/NjQu/zg2MP9XVVD/b21p/4iHg/9tbGvU + AAAAZAAAAA8AAAAAAAAAAAAAAAAAAAAAAAAALBMTE4vOz8/w3d7e/9fZ2P/Iy8r/j5OS7xgYGJwAAABG + AAAAIgAAADgAAAB1fH9+4q6xsP+rrq3/p6qp/62wr//BxMP5AgIChQAAACAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAB0AAABzaGhl3WdmYf9WVE//SkhD/zk3Mf82NC7/ODYw/1VTTv9ubGj/ + gYB8/5ubmPgbGhqdAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATlpbW7vg4eH+2NnZ/8rNzP+Tl5by + GxsbnwAAAEkAAAANAAAAAAAAAAMAAABRVVdWyKaqqf+nq6n/q6+t/8vNzP/O0M//MDExpgAAAC8AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoAAAB9cnFt81dVUP9LSUT/Ojgy/zY0Lv83NS// + U1JM/21sZ/9/fnr/np2a/k1NTL4AAABbAAAADgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJgEBAXWAgYHO + 0NLR/5ebmvQhIiKlAAAATQAAAA8AAAAAAAAAAAAAAAAAAAA0JSYmqKGko/+qraz/yszL/8zOzf/Mzs3/ + ZGVkwgAAAEgAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAABzYV9c5VBOSP86ODL/ + NjQu/zc1L/9RT0r/bGtm/359ef+cm5j/a2ppzwAAAHIAAAAhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAQAAACwBAQF6YWNjzScoKKkAAABRAAAAEQAAAAAAAAAAAAAAAAAAAB4AAABlR0lIv6Cjov7Jy8r/ + zM7O/8rMy//Jy8v/j5CQ1wAAAGIAAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAABR + PDs5yUhGQP82NC7/NjQu/09NSP9ramX/fXx4/5qZlv93dnXXAgICfQAAAC0AAAABAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAuAAAAbgAAAFMAAAATAAAAAAAAAAAAAAAAAAAAHAAAAGJAQUG6 + nKCf/cPGxf/Nz87/yszM/8jKyf/Gycj/s7W07AAAAHcAAAAXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAMAAABRNDQxyURCPP82NC7/TUtG/2ppZP98e3f/mJeU/39+fdwEBASDAAAAMAAAAAIAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAFwAAAA0AAAAAAAAAAAAAAAAAAAAZ + AAAAXjo8O7aZnZz7wsTD/83Pzv/KzMz/yMrJ/8jKyf/Iysn7cXJyyAAAAHIAAAAZAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAB8AAAB3S0pG5Ts5M/9KSEP/aWhj/3x6dv+VlJH/h4aF4QgICIkAAAA2 + AAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAABYAAABZMzQ0spebmvq/wsH/zc/O/8rNzP/Iy8r/y87N/7GysuozNDOqAAAAZQAAACsAAAAD + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAFomJiS6T05I/0hGQf9oZ2L/e3l1/5OSj/+Ojozn + DAsLjwAAADsAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAADQAAAFUtLi6ulpqZ+b3Av//Nz87/y83M/8rMzP/Lzcz8fH19zQcHB4cAAABG + AAAAFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAlAAAAYB0cG7BUU075SUdC/2dmYf96eXX/ + kpGO/5OSkesRERGVAAAAPgAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGgAAAHl4e3rev8HA/83Pzv/Lzcz/zc/P/7e4uO08PDyt + AAAAaAAAAC0AAAAHAAAAAAAAAAAAAAAJAAAACwAAAAYAAAAOAAAAIgAAAEYBAQF8LSwqwVNSTfpJR0L/ + ZmVg/3l4dP+Tko//kpKQ6xgYGJoAAABEAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAD8SEhKTtre36s/R0P/P0dD+ + hoiH0Q0NDYwAAABKAAAAGAAAAAEAAAAAAAAAAAAAABgAAABVAAAAYQAAAFgAAABlAAAAgR4eHLFLSkbk + TkxH/0RDPf9lY1//fnx5/5mZlv54eHbYDQ0NkQAAAEUAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkAAABB + GRkZl6KkpN9FRUWxAAAAawAAAC8AAAAIAAAAAAAAAAAAAAAAAAAAAAAAACoBAQGUGBgWsCwrKcFAPzzW + VFNP8F1cV/9OTUf/UVBL/3Z1cf+Ih4P5dXVz3TAwL64AAAByAAAANQAAAAkAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAKAAAARgAAAHkAAABMAAAAGgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIAAABI + AAAAawICAoUSEhGiIyIhuC0tKsIwLy3FODc1wCoqKbALCwqQAAAAbwAAAEQAAAAdAAAAAgAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQAAABwAAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAADAAAAEgAAACIAAAAwAAAAQAAAAE0AAABRAAAASgAAADkAAAAoAAAAFgAAAAMAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + /D////APAAD4D///8AcAAPAP///gBwAA4Af//8ADAADAA///gAMAAIAB//8AAwAAAAD//gADAAAAAH/8 + AAcAAAAAP/gABwAAAAAf8AAPAACAAA/gAB8AAMAAD+AAPwAA4AAHwAB/AADwAAOAAP8AAPgAAQAB/wAA + /AAAAAP/AAD+AAAAB/8AAP8AAAAP/wAA/4AAAB//AAD/wAAAP/8AAP/gAAB//wAA//AAAP//AAD/+AAB + /w8AAP/8AAP+BwAA//4AA/wDAAD//AAB/AEAAPgIAAD4AAAA+AAAAHwAAADwAAAAOAAAAOAAAAAAAAAA + 4AAAAAAAAADAAAMAAAAAAIAAB4AAAAAAgAAPwAADAAAAAA/gAA8AAAAAD+AADwAAAEAP8AAfAAAAwAfw + AD8AAAGAB/AAPwAAgwAH8AB/AADHAAfgAP8AAP4AB+AB/wAA/AAPgAP/AAD8ACAAB/8AAPwAYAAP/wAA + /gHgAB//AAD/A+AAP/8AAP+P8AD//wAAKAAAACAAAABAAAAAAQAgAAAAAAAAEAAAww4AAMMOAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkAAAA8AAAAZwAAAFYAAAAb + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAMigeFpNTPi3FGRMOgQAAABoAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAwMDW2ZoaM6nqqn1 + lJeW5ykqKpMAAAAdAAAAAAAAAAAAAAAAAAAAAAAAAC46Kx+kkWRA+4VVL/9/Wz7uFA8LfQAAABQAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAFBsb27S + wcPC/WhpacJ8f3/enqCg7gEBAWEAAAABAAAAAAAAAAAAAAAoNygcnp5vS/mPWjD/iFQr/4NSLP95WD3o + DAkGcAAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAABF + XF5exbu+vf+1t7ftAAAAWSkqKpCusbD/HyAghAAAAAgAAAAAAAAADSMZEoWrfFf3s4Zj/6FvSP+PWS// + h1Mr/4RTLv9yUzvhBQQDYgAAAAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB + AAAAOkxOTbe3urn+wcPD/7/Bwf5ydHTJhIeG4aWop/cICAhuAAAAAwAAAAAAAAAXVD0rrrSBWP/EnH3/ + s4Zj/6BtRv+OWC7/h1Mr/4VVMP9pTTfXAQEAVgAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC89Pz6qsbSz/cHEw/+7vrz/tLe2/6+ysf+rrq37QkNDqgAAACoAAAAAAAAAAAAAAAYIBgRk + jWRE4riIYv/Cm3z/soRh/55rRP+OVy3/h1Mr/4ZXM/9eRTLMAAAATAAAAAUAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAlMDEwnKqtrPrCxMP/u769/7S3tv+usbD/qq2s+0NERKoAAAA1AAAAAQAAAAAAAAAA + AAAAAAAAAA8LCAZrjmRE4rmJY//BmXr/sYNf/51pQf+NVy3/hlMr/4haNv9RPCzAAAAAQQAAAAIAAAAA + AAAAAAAAAAAAAAAAAAAAHCMkI4+ipaT1wsTD/7u+vf+1uLf/rrGw/6qtrPtCQ0OpAAAANAAAAAEAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAABAMCAZsjmVE47qKZf/AmHj/sIFd/5tnP/+NVy3/hlMr/4lcOf5FMya0 + AAAANwAAAAEAAAAAAAAAAAAAABUXGBiAmJua8MHEw/+8v73/tbi3/66ysP+qrq37QUJCqAAAADQAAAAB + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAMCQZtj2VF5LqLZv+/lnb/roBc/5plPP+MViz/ + hlIq/4ldPPw4Kh+nAAAALgAAAAAAAAAPDQ0NcY2QkOnAw8L/vL++/7W4t/+vsrH/qq6t+0BBQacAAAAz + AAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABANCgdukGZF5LuMZ/++lXT/ + rX5a/5ljOv+MViz/hVIq/4hePvksIRibAAAALgUFBWOBhIPhv8LB/72/vv+2ubj/r7Ox/6qurfo/QECn + AAAAMwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEOCgdw + kWZF5buNaP+9k3L/rH1Y/5diOP+MViz/hlIr/4ZeP/UaFA61Y2Zl3L3Av/+9wL//trm4/7Czsv+rrq36 + PkA/pgAAADIAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAABEPCwdxkmdG5byNaf+8kXD/q3tW/5ZgNv+LViz/hlMr/4JeQv1fXlv/o6al/7a5uP+ws7L/ + q66t+j0/PqUAAAAxAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAABIPCwhyk2hH5ryOav+7kG//qXlU/5VfNP+LViz/hlQt/2pXSP+Fh4b/ + oqWk/6uurfo8Pj2kAAAAMQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIQDAhzlGlH57yOa/+6jm3/qHdR/5RdM/+QXTb/ + d29m/25wb/+QkpL6Oz08owAAADAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIRDAl0kmhH6ryPa/+4i2j/ + nWY7/8K0pP/Q19P/aGpp/SIiIrYAAAAwAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAEYAAAA0 + AAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAbGBbF + lm9Q/654Tv/Es6D/7O/u/9nf3P/N1NH+S01MuAAAADIAAAABAAAAAAAAAAAAAAAAAAAAAAAAABITExKI + QkI+3zMzMMUAAABOAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGQAAABgAAAALAAAAAQAAAAAAAAAY + HB0dh5CTkvN1dnX/aGZi/32Af//Z39z/7O/u/9jf2//N1NH6SUtKogAAAC0AAAAAAAAAAAAAAAAAAAAA + AAAALT08ONQ3NjD/QkA6/zU1MsUAAABJAAAABAAAAAAAAAAAAAAAAAAAABkoKSmSREZGqxwcHIUAAABn + AAAASBESEnmSlpXsvsHA/7a5uP+qraz/foCA+mdqaefb4d7/7O/u/9fe2v/L0s/4QUNCnAAAACgAAAAA + AAAAAAAAAAAAAAAgKSkns0NBO/82NC7/T01I/zY1M78AAAA6AAAAAAAAAAAAAAAHBwcHZcLDw+vY2tn/ + xcfG/6qsq/WFiIfhjZCQ6r3Av/+5vLv/s7a0/6uurfg2ODehAAAAZ3p+fMPc4t//6+/t/9bd2f/Jz8z3 + OTs6lgAAACcAAAAeAAAAHgAAAEI1NDHEPz04/0VDPf9qaWT/eHdz+gAAAGoAAAAAAAAAAAAAADmIiYnH + 4eLh/9vc3P/U1tX/zdDP/8fJyP/Aw8L/ury7/7O2tf+rrq34Njc3nwAAACwAAAAGAAAATISHhsnd4+D/ + 6+7t/9Xc2P/Gzcn1MjQzm0FBP7s+PTu+PDw5zUVDPf5APjj/cW9r/Xt6dv5VVFHaAAAATAAAAAAAAAAX + QEBAlt7f3/zb3dz/0dPS/83Pzv/Hycn/wcPC/7q9vP+ztrX/q66t+DU2Np4AAAAsAAAAAAAAAAAAAAAH + AAAAUY2Rj8/e5OH/6u7s/9LZ1f+Oj4v9YF9a/0xKRP86ODL/Pjw2/2tpZf9WVVPFBwYGeQAAAFcAAAAN + AAAABgkJCWPExcXr3N3d/8/R0P+GiYjldXh32qKmpfa1uLf/tLe1/62wr/+BhIPjAAAATQAAAAAAAAAA + AAAAAAAAAAAAAAAIAQEBVpWZl9Xe4+D/kZGN/1pZVP9IRkH/NzUv/z07Nf9kY17/hYSB9QgICG0AAAAL + AAAAAQAAAAAAAAA2jY6OyN3e3v/Q0tL/io2M5gwMDHAAAAA/AwMDeJSYl/Ctsa//p6qp/7G0s/cBAQFn + AAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAKAwMDaYGCfu1bWVX/SUdC/zc1L/87OTT/YmFc/4SDf/9fX13E + AAAALQAAAAAAAAAAAAAAAAAAAF+2t7fm09XU/5CTkuoQEBB2AAAAEgAAAAAAAAAxbG9u1qerqf+7vr3/ + zc/O/zQ0NIwAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABjZ2Zi9kpIQ/84NjD/Ojgy/2BfWv+Bf3z/ + h4aE5gUFBWIAAAAGAAAAAAAAAAAAAAAAAAAAFBcXF3p+gIDaFBUVfQAAABUAAAAAAAAAAwAAAENhZGPM + t7q5/8zOzv/KzMv/Z2hntQAAABkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEJNTEjfODYw/zk3Mf9eXVj/ + f316/4+Oi+0WFhZ8AAAAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFgAAAFcAAAAXAAAAAAAAAAIAAAA9 + TE5NuK6xsP7Mzs7/ycvK/8jKyf+EhYTRAAAALQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQkFAPN84NjD/ + XFpV/318eP+SkY/xHh4dhQAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB + AAAAOUZHR7Krrq39zM7O/8nMy//Jy8r+hoeHzwwNDG4AAAAUAAAAAAAAAAAAAAAAAAAAAAAAABwWFRSQ + SUhD+1pYU/97enb/lJSR9CYmJY4AAAAdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAACQ9Pz6rp6uq/MzOzf/Lzcz/ury78UhJSaIAAABDAAAACgAAAAAAAAAAAAAAAAAAAAcAAAAu + ExIRjEtJRe9YV1L/enl1/5aVkvcvLy6XAAAAIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAGykqKpPExsb2zc/P/pCRkNQSEhJzAAAAIAAAAAEAAAABAAAANAAAAEUAAABI + BQUFcjIxLr5KSUT3VlVQ/359ef+Mi4nuLS0slQAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJTw8PJlTVFSoAAAARwAAAAsAAAAAAAAAAAAAAAUBAQFq + FBQTqjEwLsZRUEzrUlFM+FxaVvNramfiT05NuQcHBmkAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHwAAACAAAAABAAAAAAAAAAAAAAAA + AAAAAAAAAA8AAAAoAAAASgAAAGIAAABrAAAAYwAAAEkAAAAhAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAADh//8DwP/+A4B//AGAP/gBAB/wAQAP4AMAB+ADgAPAB8ABgA/gAAAf + 8AAAP/gAAH/8AAD//gAB//8AA///gAfD/8AHgeCAA4DgAAGAwAAAAIAAAACAAQAAAAOAAQADwAcCA+AH + BAPgD4gD4B/wA8A/8AcAf/AAAH/4MAD/+HgD/ygAAAAQAAAAIAAAAAEAIAAAAAAAAAQAAMMOAADDDgAA + AAAAAAAAAAAAAAAAAAAADTgqH2MTDgorAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI6Oztc + cXNyph4eHjMAAAAAAAAACl1DLpqLWTL+b0wx1QkHBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE0NTRY + qqyr71NUVKJ3enm1AAAAAjkpHVa2iGT9oW9I/4hVLP9oSC/GAQAAGgAAAAAAAAAAAAAAAAAAAAAmJyZF + pKal7Ly+vf+WmZjpXV5ejgAAAAEHBQMeimNFzLyQbv+ebET/iFUt/19DLbYAAAASAAAAAAAAAAAYGBg0 + mZyb47u+vf+vsrH+ZmdnoQAAAA4AAAAAAAAAAAkHBSOLZEbNuo5s/5xpQf+IVi//Vj0ppAAAAAwKCgol + jpCQ1ry+vf+vsrH+ZWdmnwAAAA0AAAAAAAAAAAAAAAAAAAAACgcFJIxlR865jWr/mmY+/4hWMP5HMyOd + fX9+yLy+vf+ws7L+ZGZmngAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCAYljWZIz7eLaP+YYzv/ + hlcx/nx4c/+tsK7+ZGZlnQAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJBiaOZ0nR + tYhk/6F1Uv+HiIT+UFJRoQAAAAwAAAAAAAAAAAAAABcAAAAPAAAAAAAAAAAAAAAAAAAADAAAAAMAAAAG + R0dGnIhxXf/CwLr/2+De/3d7eaEAAAALAAAAAAAAABA2NTHPMzMvtgAAABUAAAAABgYGIZKUk8qChIO4 + ZGZlo7K1tPqvsrH9VlhXuszRzvDZ39z9c3d1lAAAABEAAAAgOTg03U1LRv9DQkCXAAAABo2OjaTa29v/ + zc/P/8DDwv+ztrX9YmNjmAAAAA1JS0pb0NXS89bc2fxfX1vVQD874ktKRP9eXVrOLy8tYlFSUlrU1dX6 + jY+PzmZoZ6Krrq37oqWk9gEBAS0AAAAAAAAAAk5QT2eTlJD7SUdB/0RCPf90c3DuBQUFKQAAAABgYGB0 + jY+P0AwMDCcAAAAej5KR6MjKyf9ISUlZAAAAAAAAAAAAAAApTUxH9UJAO/97enb7SUlHdgAAAAIAAAAA + AAAABgAAABwAAAAPZ2loqcTGxv+6vLzzS0xMYAAAAAAAAAAADQ0MO0dGQfZ6eXX8UlFQiQAAAAYAAAAA + AAAAAAAAAAAAAAAAKywsX8HEw/ydnp7OLS0tQgAAABAAAAAjHBwaWUVEQNx3dXL7V1ZVkwAAAAkAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAk8PT1gAAAAFQAAAAABAQEgGxsZeTk4NaxISEWgLi4tUgAAAAcAAAAA + AAAAAAAAAAAAAAAAj+EAAAfAAAADgAAAAYEAAIADAADABwAA4A8AAPAZAACAEAAAgAAAAAAAAAABAAAA + AYEAAAGDAADABwAAxA8AAA== + + + \ No newline at end of file diff --git a/YYExplorer/SDK/Enums/Enums.hpp b/YYExplorer/SDK/Enums/Enums.hpp index 3897080..27d5c00 100644 --- a/YYExplorer/SDK/Enums/Enums.hpp +++ b/YYExplorer/SDK/Enums/Enums.hpp @@ -57,14 +57,23 @@ enum Color : int { CLR_BLACK = 0, CLR_DARKBLUE = 1, + CLR_MATRIXGREEN = 2, + CLR_AQUA = 3, CLR_RED = 4, CLR_PURPLE = 5, + CLR_GOLD = 6, CLR_DEFAULT = 7, CLR_GRAY = 8, CLR_BLUE = 9, CLR_GREEN = 10, CLR_LIGHTBLUE = 11, + CLR_TANGERINE = 12, CLR_PINK = 13, CLR_YELLOW = 14, CLR_WHITE = 15 +}; + +enum EOpcode +{ + // todo }; \ No newline at end of file diff --git a/YYExplorer/SDK/FwdDecls/FwdDecls.hpp b/YYExplorer/SDK/FwdDecls/FwdDecls.hpp index c979976..15960c3 100644 --- a/YYExplorer/SDK/FwdDecls/FwdDecls.hpp +++ b/YYExplorer/SDK/FwdDecls/FwdDecls.hpp @@ -69,7 +69,7 @@ typedef bool (*FNCodeExecute)(YYObjectBase* Self, YYObjectBase* Other, CCode* co // Macros #define WIN32_LEAN_AND_MEAN 1 -#define YYSDK_VERSION "0.0.7" // YYToolkit version - don't change this! +#define YYSDK_VERSION "0.0.7-rc2" // YYToolkit version - don't change this! #define YYTK_MAGIC 'TFSI' // Macros, but complicated diff --git a/YYExplorer/SDK/Plugins/Plugins.hpp b/YYExplorer/SDK/Plugins/Plugins.hpp index 2bef318..97286ba 100644 --- a/YYExplorer/SDK/Plugins/Plugins.hpp +++ b/YYExplorer/SDK/Plugins/Plugins.hpp @@ -15,15 +15,19 @@ class YYTKEventBase; using FNEventHandler = YYTKStatus(*)(YYTKPlugin* pPlugin, YYTKEventBase* pEvent); using FNPluginEntry = YYTKStatus(*)(YYTKPlugin* pPlugin); using FNPluginUnload = YYTKStatus(*)(YYTKPlugin* pPlugin); +using FNTextRenderCallback = void(*)(float& x, float& y, const char*& str, int& linesep, int& linewidth); + +#pragma pack(push, 1) struct YYTKPlugin { - FNPluginEntry PluginEntry; // Pointer to the entry function - set by the core. - FNPluginUnload PluginUnload; // Pointer to the unload function - optional, set by the plugin. - FNEventHandler PluginHandler; // Pointer to an event handler function - optional, set by the plugin. + FNPluginEntry PluginEntry; // Pointer to the entry function - set by the core. + FNPluginUnload PluginUnload; // Pointer to the unload function - optional, set by the plugin. + FNEventHandler PluginHandler; // Pointer to an event handler function - optional, set by the plugin. + FNTextRenderCallback OnTextRender; // Pointer to a text render callback - optional, set by the plugin. - void* PluginStart; // The base address of the plugin (can be casted to a HMODULE). - void* CoreStart; // The base address of the core (can be casted to a HMODULE). + void* PluginStart; // The base address of the plugin (can be casted to a HMODULE). + void* CoreStart; // The base address of the core (can be casted to a HMODULE). template T GetCoreExport(const char* Name) @@ -39,4 +43,6 @@ struct YYTKPlugin if (PluginStart) return reinterpret_cast(GetProcAddress(reinterpret_cast(PluginStart), Name)); return nullptr; } -}; \ No newline at end of file +}; + +#pragma pack(pop) \ No newline at end of file diff --git a/YYExplorer/SDK/Structures/Documented/APIVars/APIVars.hpp b/YYExplorer/SDK/Structures/Documented/APIVars/APIVars.hpp index e6b4d72..4a602c0 100644 --- a/YYExplorer/SDK/Structures/Documented/APIVars/APIVars.hpp +++ b/YYExplorer/SDK/Structures/Documented/APIVars/APIVars.hpp @@ -15,4 +15,5 @@ struct APIVars_t void* MainModule = nullptr; // A pointer to the core module (can be casted to an HMODULE) void* RenderView = nullptr; // A pointer to an ID3D11RenderTargetView. Is nullptr in DX9! void* DeviceContext = nullptr; // A pointer to a D3D11DeviceContext object. Is nullptr in DX9! + void* pSwapChain = nullptr; // A pointer to a swapchain object - is nullptr in DX9! }; \ No newline at end of file diff --git a/YYExplorer/SDK/Structures/Documented/YYRValue/YYRValue.cpp b/YYExplorer/SDK/Structures/Documented/YYRValue/YYRValue.cpp index 8b894bc..c762d2d 100644 --- a/YYExplorer/SDK/Structures/Documented/YYRValue/YYRValue.cpp +++ b/YYExplorer/SDK/Structures/Documented/YYRValue/YYRValue.cpp @@ -29,7 +29,7 @@ YYRValue::YYRValue(const bool& Value) noexcept(true) { this->Kind = VALUE_BOOL; this->Flags = 0; - this->I32 = Value; // A bool is really just a 0 or a 1, so I can freely cast it to an integer. + this->Real = static_cast(Value); // A bool is really just a 0 or a 1, so I can freely cast it to an integer. } YYRValue::YYRValue(const long long& Value) noexcept(true) diff --git a/YYToolkit/Src/Core/Features/API/API.cpp b/YYToolkit/Src/Core/Features/API/API.cpp index b68dfe5..e23c4e5 100644 --- a/YYToolkit/Src/Core/Features/API/API.cpp +++ b/YYToolkit/Src/Core/Features/API/API.cpp @@ -37,7 +37,11 @@ namespace API SetConsoleTitleA("YYToolkit Log"); +#if _DEBUG + Utils::Error::Message(CLR_GREEN, "YYToolkit %s by Archie", YYSDK_VERSION); +#else Utils::Error::Message(CLR_LIGHTBLUE, "YYToolkit %s by Archie", YYSDK_VERSION); +#endif bool ErrorOccured = false; if (!gAPIVars.Code_Execute) diff --git a/YYToolkit/Src/Core/Hooks/Present/Present.cpp b/YYToolkit/Src/Core/Hooks/Present/Present.cpp index 790d788..432f091 100644 --- a/YYToolkit/Src/Core/Hooks/Present/Present.cpp +++ b/YYToolkit/Src/Core/Hooks/Present/Present.cpp @@ -56,25 +56,22 @@ namespace Hooks::Present { HRESULT __stdcall Function(IDXGISwapChain* _this, unsigned int Sync, unsigned int Flags) { - // Create renderview - std::call_once(g_CreatedRenderView, [&]() - { - ID3D11Texture2D* pBackBuffer = nullptr; - ID3D11Device* pDevice = reinterpret_cast(gAPIVars.Window_Device); + YYTKPresentEvent Event = YYTKPresentEvent(pfnOriginal, _this, Sync, Flags); - HRESULT Result = _this->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer)); + Plugins::RunHooks(&Event); - if (FAILED(Result)) - Utils::Error::Error(false, "Getting the back buffer failed."); + std::call_once(g_CreatedRenderView, [&]() + { + ID3D11Device* pDevice = static_cast(gAPIVars.Window_Device); + ID3D11RenderTargetView** ppRenderView = reinterpret_cast(&gAPIVars.RenderView); - pDevice->CreateRenderTargetView(pBackBuffer, NULL, reinterpret_cast(&gAPIVars.RenderView)); + ID3D11Texture2D* pBackBuffer; + _this->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer)); + pDevice->CreateRenderTargetView(pBackBuffer, NULL, ppRenderView); + pBackBuffer->Release(); } ); - YYTKPresentEvent Event = YYTKPresentEvent(pfnOriginal, _this, Sync, Flags); - - Plugins::RunHooks(&Event); - if (Event.CalledOriginal()) return Event.GetReturn(); @@ -129,8 +126,6 @@ namespace Hooks::Present //Throw these away, they're useless now. pSwapChain->Release(); - // Setup gAPIVars members - ID3D11Device* pDevice = static_cast(gAPIVars.Window_Device); if (pDevice) diff --git a/YYToolkit/Src/Core/Hooks/ResizeBuffers/ResizeBuffers.cpp b/YYToolkit/Src/Core/Hooks/ResizeBuffers/ResizeBuffers.cpp index 5b40251..fb3d45f 100644 --- a/YYToolkit/Src/Core/Hooks/ResizeBuffers/ResizeBuffers.cpp +++ b/YYToolkit/Src/Core/Hooks/ResizeBuffers/ResizeBuffers.cpp @@ -32,34 +32,40 @@ HRESULT __stdcall Hooks::ResizeBuffers::Function(IDXGISwapChain* _this, UINT Buf return Event.GetReturn(); } - // Refresh gAPIVars.RenderView scope - HRESULT _Result = S_OK; + // Release all needed resources + if (gAPIVars.RenderView) { - using namespace Hooks::Present; + ID3D11RenderTargetView* pRenderTarget = static_cast(gAPIVars.RenderView); + ID3D11DeviceContext* pContext = static_cast(gAPIVars.DeviceContext); - if (gAPIVars.RenderView) - reinterpret_cast(gAPIVars.RenderView)->Release(); + pContext->OMSetRenderTargets(0, 0, 0); + pRenderTarget->Release(); - _Result = pfnOriginal(_this, BufferCount, Width, Height, NewFormat, SwapChainFlags); + gAPIVars.RenderView = nullptr; + } - { - ID3D11Texture2D* pBackBuffer; - HRESULT ret = _this->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer)); + // Resize the game buffer + HRESULT hr = pfnOriginal(_this, BufferCount, Width, Height, NewFormat, SwapChainFlags); - if (FAILED(ret)) - Utils::Error::Error(1, "Getting the back buffer failed."); + // Recreate the buffer + { + ID3D11Device* pDevice = static_cast(gAPIVars.Window_Device); + ID3D11RenderTargetView** ppRenderTarget = reinterpret_cast(&gAPIVars.RenderView); + ID3D11DeviceContext* pContext = static_cast(gAPIVars.DeviceContext); - ret = static_cast(gAPIVars.Window_Device)->CreateRenderTargetView(pBackBuffer, NULL, reinterpret_cast(&gAPIVars.RenderView)); + ID3D11Texture2D* pBuffer; + _this->GetBuffer(0, IID_PPV_ARGS(&pBuffer)); + // TODO: Perform error handling here! - if (FAILED(ret)) - Utils::Error::Error(1, "Creating the target view failed."); + pDevice->CreateRenderTargetView(pBuffer, NULL, ppRenderTarget); + // TODO: Perform error handling here! + pBuffer->Release(); - pBackBuffer->Release(); - } + pContext->OMSetRenderTargets(1, ppRenderTarget, NULL); } - return _Result; + return hr; } void* Hooks::ResizeBuffers::GetTargetAddress() diff --git a/YYToolkit/Src/Core/SDK/Structures/Documented/APIVars/APIVars.hpp b/YYToolkit/Src/Core/SDK/Structures/Documented/APIVars/APIVars.hpp index e6b4d72..4a602c0 100644 --- a/YYToolkit/Src/Core/SDK/Structures/Documented/APIVars/APIVars.hpp +++ b/YYToolkit/Src/Core/SDK/Structures/Documented/APIVars/APIVars.hpp @@ -15,4 +15,5 @@ struct APIVars_t void* MainModule = nullptr; // A pointer to the core module (can be casted to an HMODULE) void* RenderView = nullptr; // A pointer to an ID3D11RenderTargetView. Is nullptr in DX9! void* DeviceContext = nullptr; // A pointer to a D3D11DeviceContext object. Is nullptr in DX9! + void* pSwapChain = nullptr; // A pointer to a swapchain object - is nullptr in DX9! }; \ No newline at end of file From 941a4471ad607ebe37e4aac63b16805d52d40ec0 Mon Sep 17 00:00:00 2001 From: Archie Date: Sat, 9 Oct 2021 20:10:27 +0200 Subject: [PATCH 3/3] Commit missing files --- .../Hello World/SDK/Structures/Documented/APIVars/APIVars.hpp | 1 + YYToolkit/Src/Core/Features/Console/Console.cpp | 2 -- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/ExamplePlugin/Src/Hello World/SDK/Structures/Documented/APIVars/APIVars.hpp b/ExamplePlugin/Src/Hello World/SDK/Structures/Documented/APIVars/APIVars.hpp index e6b4d72..4a602c0 100644 --- a/ExamplePlugin/Src/Hello World/SDK/Structures/Documented/APIVars/APIVars.hpp +++ b/ExamplePlugin/Src/Hello World/SDK/Structures/Documented/APIVars/APIVars.hpp @@ -15,4 +15,5 @@ struct APIVars_t void* MainModule = nullptr; // A pointer to the core module (can be casted to an HMODULE) void* RenderView = nullptr; // A pointer to an ID3D11RenderTargetView. Is nullptr in DX9! void* DeviceContext = nullptr; // A pointer to a D3D11DeviceContext object. Is nullptr in DX9! + void* pSwapChain = nullptr; // A pointer to a swapchain object - is nullptr in DX9! }; \ No newline at end of file diff --git a/YYToolkit/Src/Core/Features/Console/Console.cpp b/YYToolkit/Src/Core/Features/Console/Console.cpp index c792662..1f69bdd 100644 --- a/YYToolkit/Src/Core/Features/Console/Console.cpp +++ b/YYToolkit/Src/Core/Features/Console/Console.cpp @@ -11,8 +11,6 @@ using std::vector; using std::string; -static - static vector StripOutArguments(const string& ref) { vector vResults;