From 2dc9995cc18cc0255e57a0e3e6226e23156220f3 Mon Sep 17 00:00:00 2001 From: wrongway88 Date: Thu, 13 Oct 2016 20:48:06 +0200 Subject: [PATCH] logic: vs plugin upgrade beta Added CDB creation --- bin/app/data/color_schemes/dark.xml | 413 ----- bin/test/data/log/test_log.txt | 114 +- ide_plugins/vs/BeforeDeployCheck.txt | 59 + ide_plugins/vs/TestSolutionEdgeCases.txt | 14 + .../CoatiPlugin/CoatiPlugin.csproj | 50 +- .../CoatiPlugin/CoatiPlugin.csproj.user | 4 +- .../CoatiPlugin/CoatiPlugin/CoatiPlugin.vsct | 9 + .../CoatiPlugin/CoatiPluginPackage.cs | 177 ++- .../CoatiPlugin/CoatiPlugin/PkgCmdID.cs | 1 + .../SolutionParser/CommandObject.cs | 41 + .../SolutionParser/CompilationDatabase.cs | 28 + .../SolutionParser/SolutionParser.cs | 502 ++++++ .../CoatiPlugin/SolutionUtility.cs | 104 -- .../CoatiPlugin/{ => Utility}/FileUtility.cs | 6 +- .../{ => Utility}/NetworkUtility.cs | 5 +- .../CoatiPlugin/Utility/ProjectUtility.cs | 61 + .../CoatiPlugin/Utility/SolutionUtility.cs | 433 ++++++ .../CoatiPlugin/Utility/StringUtility.cs | 61 + .../{ => Utility}/SystemUtility.cs | 6 +- .../Wizard/ProjectSetupWindow.Designer.cs | 277 ++++ .../CoatiPlugin/Wizard/ProjectSetupWindow.cs | 432 ++++++ .../Wizard/ProjectSetupWindow.resx | 1343 +++++++++++++++++ .../Wizard/WindowCreateCDB.Designer.cs | 84 ++ .../CoatiPlugin/Wizard/WindowCreateCDB.cs | 142 ++ .../CoatiPlugin/Wizard/WindowCreateCDB.resx | 1331 ++++++++++++++++ .../Wizard/WindowMessage.Designer.cs | 92 ++ .../CoatiPlugin/Wizard/WindowMessage.cs | 96 ++ .../CoatiPlugin/Wizard/WindowMessage.resx | 1328 ++++++++++++++++ .../vs2015/CoatiPlugin/CoatiPlugin/coati.ico | Bin 74802 -> 72168 bytes .../CoatiPlugin/source.extension.vsixmanifest | 3 +- src/lib_gui/platform_includes/deploy.h | 2 +- web/documentation/img/vs_plugin_cdb.png | Bin 0 -> 18591 bytes web/documentation/img/vs_plugin_menu.png | Bin 0 -> 14402 bytes web/documentation/index.html | 41 +- 34 files changed, 6608 insertions(+), 651 deletions(-) delete mode 100644 bin/app/data/color_schemes/dark.xml create mode 100644 ide_plugins/vs/BeforeDeployCheck.txt create mode 100644 ide_plugins/vs/TestSolutionEdgeCases.txt create mode 100644 ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SolutionParser/CommandObject.cs create mode 100644 ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SolutionParser/CompilationDatabase.cs create mode 100644 ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SolutionParser/SolutionParser.cs delete mode 100644 ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SolutionUtility.cs rename ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/{ => Utility}/FileUtility.cs (93%) rename ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/{ => Utility}/NetworkUtility.cs (98%) create mode 100644 ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/ProjectUtility.cs create mode 100644 ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/SolutionUtility.cs create mode 100644 ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/StringUtility.cs rename ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/{ => Utility}/SystemUtility.cs (83%) create mode 100644 ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/ProjectSetupWindow.Designer.cs create mode 100644 ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/ProjectSetupWindow.cs create mode 100644 ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/ProjectSetupWindow.resx create mode 100644 ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowCreateCDB.Designer.cs create mode 100644 ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowCreateCDB.cs create mode 100644 ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowCreateCDB.resx create mode 100644 ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowMessage.Designer.cs create mode 100644 ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowMessage.cs create mode 100644 ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowMessage.resx create mode 100644 web/documentation/img/vs_plugin_cdb.png create mode 100644 web/documentation/img/vs_plugin_menu.png diff --git a/bin/app/data/color_schemes/dark.xml b/bin/app/data/color_schemes/dark.xml deleted file mode 100644 index 3d59fbcc..00000000 --- a/bin/app/data/color_schemes/dark.xml +++ /dev/null @@ -1,413 +0,0 @@ - - - - - #272728 - - - - - #F7F7F7 - #777777 - #555555 - - - - #F7F7F7 - #A0A0A0 - #272728 - #555555 - - - - - - - - - - - - - - - - - - - - - - - - - #2F2F2F - #F7F7F7 - - - black - #F7F7F7 - - - - - #406D4D - #F7F7F7 - - - #4E855E - #F7F7F7 - - - - - #7D2724 - #F7F7F7 - - - #8C2B29 - #F7F7F7 - - - - - #207EA8 - #F7F7F7 - - - #006D93 - #F7F7F7 - - - - - - - #272728 - - - #777777 - - - <text>#F7F7F7</text> - <normal>#777777</normal> - <hover>#555555</hover> - <press>#444444</press> - <icon>white</icon> - - - - #F7F7F7 - #272728 - - - - - #272728 - - - <text>#A0A0A0</text> - <background>transparent</background> - <hover>#2F2F2F</hover> - - - - #F7F7F7 - #A0A0A0 - #272728 - #969696 - - - - #F7F7F7 - #1F9C62 - #1F9C62 - #D95233 - #A0A0A4 - #CC3463 - #9368AD - #D69C36 - - - - white - #777777 - - - - - - transparent - transparent - - - #F7F7F7 - transparent - - - transparent - #F7F7F7 - #272728 - - - - - transparent - transparent - - - #A0A0A0 - #969696 - #191919 - - - transparent - #969696 - #272728 - - - - - transparent - transparent - - - - - transparent - #A0FF0000 - #000000 - - - #FFFF0000 - - - - - #207EA8 - #F7F7F7 - - - #006D93 - #134B63 - - - - - - - - #272728 - - - - - #4D4D4D - - - #C3C3C3 - - - #F7F7F7 - - - #F7F7F7 - - - #272728 - - - - - - #20C3C3C3 - #C3C3C3 - - - - type - - - type - - - type - - - type - - - type - - - type - - - type - - - type - - - - - #7A681F - #9C8528 - - - transparent - #C3C3C3 - - - - function - - - - - #21516B - #2A6484 - - - transparent - #C3C3C3 - - - - global_variable - - - global_variable> - - - - type - - - - #78282D - - - #80C3C3C3 - #C3C3C3 - - - - namespace - - - - - #1B564E - #247368 - - - #20C3C3C3 - #C3C3C3 - - - - file - - - - - #272728 - - - - - #272728 - - - #80C3C3C3 - #C3C3C3 - - - - - #272728 - - - #C3C3C3 - - - #F7F7F7 - - - - - - #797979 - - - - #CC5E89 - - - - #9C8528 - - - - #2A6484 - - - - #C1305D - - - template_argument - - - template_argument - - - template_argument - - - template_argument - - - - #247368 - - - #247368 - - - - #3D3D3D - #4D4D4D - - - - - #272728 - white
- - white - black - - - darkgrey - #969696 - - - #343434 - #969696 - - - - #272728 - white - #878787 - #878787 - - diff --git a/bin/test/data/log/test_log.txt b/bin/test/data/log/test_log.txt index 5e4e1ebd..3aa9700a 100644 --- a/bin/test/data/log/test_log.txt +++ b/bin/test/data/log/test_log.txt @@ -1,57 +1,57 @@ -Token.cpp ERROR: Location Id was not referenced by this Token. -Node.cpp WARNING: Cannot change NodeType after it was already set from namespace to class -Edge.cpp ERROR: Nodes are not plain copies. - INFO: send TestMessage - INFO: handle TestMessage - INFO: send TestMessage - INFO: handle TestMessage - INFO: send TestMessage - INFO: handle TestMessage - INFO: send TestMessage2 - INFO: handle TestMessage2 - INFO: send TestMessage - INFO: handle TestMessage - INFO: send TestMessage2 - INFO: handle TestMessage2 - INFO: send TestMessage - INFO: handle TestMessage - INFO: send TestMessage - INFO: handle TestMessage - INFO: send TestMessage2 - INFO: handle TestMessage2 - INFO: send TestMessage - INFO: handle TestMessage - INFO: send TestMessage - INFO: handle TestMessage - INFO: handle TestMessage - INFO: send TestMessage - INFO: handle TestMessage - INFO: handle TestMessage - INFO: send TestMessage - INFO: handle TestMessage - INFO: send TestMessage - INFO: handle TestMessage - INFO: handle TestMessage - INFO: handle TestMessage - INFO: handle TestMessage - INFO: handle TestMessage - INFO: handle TestMessage - INFO: send TestMessage - INFO: handle TestMessage - INFO: handle TestMessage - INFO: handle TestMessage - INFO: handle TestMessage - INFO: handle TestMessage - INFO: handle TestMessage -NetworkProtocolHelper.cpp ERROR: Failed to parse message, invalid type token -NetworkProtocolHelper.cpp ERROR: Failed to parse setActiveToken message, invalid token count -Settings.cpp WARNING: File for Settings not found: data/SettingsTestSuite/wrong_settings.xml -Settings.cpp WARNING: File for Settings not found: data/SettingsTestSuite/wrong_settings.xml -TextAccess.cpp ERROR: Could not open file path/to/test.h -TextAccess.cpp WARNING: Index 'firstLine' has to be lower or equal index 'lastLine', is 3 > 2 -TextAccess.cpp WARNING: Tried to access index 10. Maximum index is 8 -TextAccess.cpp WARNING: Tried to access index 10. Maximum index is 8 -TextAccess.cpp WARNING: Line numbers start with one, is 0 -TextAccess.cpp WARNING: Line numbers start with one, is 0 -TokenLocationCollection.cpp ERROR: TokenLocation has wrong boundaries: file.c 2:3 2:1 -TokenLocationCollection.cpp ERROR: TokenLocation has wrong boundaries: file.c 4:1 1:10 +Token.cpp ERROR: Location Id was not referenced by this Token. +Node.cpp WARNING: Cannot change NodeType after it was already set from namespace to class +Edge.cpp ERROR: Nodes are not plain copies. + INFO: send TestMessage + INFO: handle TestMessage + INFO: send TestMessage + INFO: handle TestMessage + INFO: send TestMessage + INFO: handle TestMessage + INFO: send TestMessage2 + INFO: handle TestMessage2 + INFO: send TestMessage + INFO: handle TestMessage + INFO: send TestMessage2 + INFO: handle TestMessage2 + INFO: send TestMessage + INFO: handle TestMessage + INFO: send TestMessage + INFO: handle TestMessage + INFO: send TestMessage2 + INFO: handle TestMessage2 + INFO: send TestMessage + INFO: handle TestMessage + INFO: send TestMessage + INFO: handle TestMessage + INFO: handle TestMessage + INFO: send TestMessage + INFO: handle TestMessage + INFO: handle TestMessage + INFO: send TestMessage + INFO: handle TestMessage + INFO: send TestMessage + INFO: handle TestMessage + INFO: handle TestMessage + INFO: handle TestMessage + INFO: handle TestMessage + INFO: handle TestMessage + INFO: handle TestMessage + INFO: send TestMessage + INFO: handle TestMessage + INFO: handle TestMessage + INFO: handle TestMessage + INFO: handle TestMessage + INFO: handle TestMessage + INFO: handle TestMessage +NetworkProtocolHelper.cpp ERROR: Failed to parse message, invalid type token +NetworkProtocolHelper.cpp ERROR: Failed to parse setActiveToken message, invalid token count +Settings.cpp WARNING: File for Settings not found: data/SettingsTestSuite/wrong_settings.xml +Settings.cpp WARNING: File for Settings not found: data/SettingsTestSuite/wrong_settings.xml +TextAccess.cpp ERROR: Could not open file path/to/test.h +TextAccess.cpp WARNING: Index 'firstLine' has to be lower or equal index 'lastLine', is 3 > 2 +TextAccess.cpp WARNING: Tried to access index 10. Maximum index is 8 +TextAccess.cpp WARNING: Tried to access index 10. Maximum index is 8 +TextAccess.cpp WARNING: Line numbers start with one, is 0 +TextAccess.cpp WARNING: Line numbers start with one, is 0 +TokenLocationCollection.cpp ERROR: TokenLocation has wrong boundaries: file.c 2:3 2:1 +TokenLocationCollection.cpp ERROR: TokenLocation has wrong boundaries: file.c 4:1 1:10 diff --git a/ide_plugins/vs/BeforeDeployCheck.txt b/ide_plugins/vs/BeforeDeployCheck.txt new file mode 100644 index 00000000..e2936cdd --- /dev/null +++ b/ide_plugins/vs/BeforeDeployCheck.txt @@ -0,0 +1,59 @@ +-Check latest plugin version is installed +-Start VS and load a C/C++ solution (best mixed with multiple projects) + -Check all projects are loaded in Solution Explorer +-Create CDB from solution + -Check all C/C++ projects listed in CDB dialogue + -Check eventual non-C/C++ projects are not listed + -Check all projects unselected + -Check 'Create' Button is disabled + -Select one project + -Check 'Create' Button is enabled + -Click 'De/Select All' + -Check all projects selected + -Click 'De/Select All' + -Check no project selected + -Click 'De/Select All' + -Check all projects selected + -Check all Solution Configurations are listed in the Configuration dropdown + -Check all Solution Platforms are listed in the Platform dropdown + -Copy target location to clip board + -Click 'Browse' + -Check Folder Browser opens + -Select a different folder + -Check target folder field changed to selected folder + -Paste old target location + -Reopen Folder Browser and check it's set to old target location + -Click Create + -Wait for CDB to be finished + -check progress bar shows progress + -Check finished CDB + -check at correct location with correct name + -check CDB file is non-empty (at least estimate whether number of lines in CDB coincides with VS solution) +-Create CDB from solution again + -Check location and name is the same as last time + -Check dialogue asking whether to overwrite old file or not + -Click no + -Check number appended to file name + -Create CDB with the new name + -Check finished CDB + -check at correct location with correct name + -check CDB file is non-empty (at least estimate whether number of lines in CDB coincides with VS solution) +-Unload a project in the Solution Explorer +-Create CDB from solution again + -Check unloaded project is not in the listed projects in the dialogue + -Check location and name is the same as first time + -Check dialogue asking whether to overwrite old file or not + -Click yes + -Click Create + -Check finished CDB + -check at correct location with correct name + -check CDB file is smaller now (reduced size has to make sense considering the missing project) +-Create CDB from solution again + -Check location and name is the same as first time + -Check dialogue asking whether to overwrite old file or not + -Click no + -Check number appended to file name + -Check number is one higher than number from 2nd CDB + -Click Create + -Close Progress Bar before CDB is finished + -Check no new CDB was created diff --git a/ide_plugins/vs/TestSolutionEdgeCases.txt b/ide_plugins/vs/TestSolutionEdgeCases.txt new file mode 100644 index 00000000..2cfd83ba --- /dev/null +++ b/ide_plugins/vs/TestSolutionEdgeCases.txt @@ -0,0 +1,14 @@ +These Edge Cases should be considered in a dedicated Test Solution for the Plugin + +-Non C/C++ Projects + -include projects that are not C/C++ based + -those should be ignored by the plugin + -not show up in the project list when creating a CDB + -not show up in the resulting CDB + +-Solution Folders + -the solution should include Solution Folders with Projects inside + -at least two levels deep + +-Include Paths + -add at least one include path to Project->Properties->Configuration Properties->VC++ Directories->Include Directories \ No newline at end of file diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/CoatiPlugin.csproj b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/CoatiPlugin.csproj index 96a82c67..87289eca 100644 --- a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/CoatiPlugin.csproj +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/CoatiPlugin.csproj @@ -53,10 +53,16 @@ true + + + True + + + @@ -64,6 +70,7 @@ + @@ -122,10 +129,10 @@ - + - + True True @@ -137,8 +144,31 @@ - - + + + + + + + + + Form + + + WindowCreateCDB.cs + + + Form + + + ProjectSetupWindow.cs + + + Form + + + WindowMessage.cs + @@ -151,8 +181,20 @@ VSPackage Designer + + WindowCreateCDB.cs + + + ProjectSetupWindow.cs + ResXFileCodeGenerator + ProjectSetupWindow1.Designer.cs + + + WindowMessage.cs + + Designer diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/CoatiPlugin.csproj.user b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/CoatiPlugin.csproj.user index a3001f8a..81e23278 100644 --- a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/CoatiPlugin.csproj.user +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/CoatiPlugin.csproj.user @@ -2,12 +2,12 @@ Program - C:\Program Files %28x86%29\Microsoft Visual Studio 11.0\Common7\IDE\devenv.exe + C:\Program Files %28x86%29\Microsoft Visual Studio 14.0\Common7\IDE\devenv.exe /rootsuffix Exp Program - C:\Program Files %28x86%29\Microsoft Visual Studio 11.0\Common7\IDE\devenv.exe + C:\Program Files %28x86%29\Microsoft Visual Studio 14.0\Common7\IDE\devenv.exe /rootsuffix Exp \ No newline at end of file diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/CoatiPlugin.vsct b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/CoatiPlugin.vsct index d17da920..a8717fa8 100644 --- a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/CoatiPlugin.vsct +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/CoatiPlugin.vsct @@ -74,6 +74,14 @@ + + @@ -107,6 +115,7 @@ + diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/CoatiPluginPackage.cs b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/CoatiPluginPackage.cs index a426e585..95ae768b 100644 --- a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/CoatiPluginPackage.cs +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/CoatiPluginPackage.cs @@ -1,25 +1,14 @@ using System; -using System.Diagnostics; -using System.Globalization; using System.Runtime.InteropServices; using System.ComponentModel; using System.ComponentModel.Design; -using Microsoft.Win32; -using Microsoft.VisualStudio; using Microsoft.VisualStudio.Shell.Interop; -using Microsoft.VisualStudio.OLE.Interop; using Microsoft.VisualStudio.Shell; -using System.Net.Sockets; -using System.Net; -using System.Text; -using System.Threading; using System.Collections.Generic; +using System.IO; using EnvDTE; -using EnvDTE80; -using System.Windows.Forms; -// using System.Windows.Forms. namespace CoatiSoftware.CoatiPlugin { @@ -80,6 +69,7 @@ namespace CoatiSoftware.CoatiPlugin { private MenuCommand _menuItemSetActiveToken = null; private MenuCommand _menuItemCreateProject = null; + private MenuCommand _menuItemCreateCDB = null; private SolutionEvents _solutionEvents = null; @@ -112,7 +102,7 @@ namespace CoatiSoftware.CoatiPlugin InitNetwork(); - FileUtility._errorCallback = new FileUtility.ErrorCallback(OnFileUtilityError); + Utility.FileUtility._errorCallback = new Utility.FileUtility.ErrorCallback(OnFileUtilityError); OptionPageGrid._serverPortChangeCallback = new OptionPageGrid.Callback(OnServerPortChanged); OptionPageGrid._clientPortChangeCallback = new OptionPageGrid.Callback(OnClientPortChanged); @@ -122,15 +112,19 @@ namespace CoatiSoftware.CoatiPlugin { CommandID setActiveTokenCommandID = new CommandID(GuidList.guidCoatiPluginCmdSet, (int)PkgCmdIDList.cmdidCoatiSetActiveToken); CommandID createProjectID = new CommandID(GuidList.guidCoatiPluginCmdSet, (int)PkgCmdIDList.cmdidCoatiCreateProject); // cmdidCoatiCreateProject + CommandID createCDBID = new CommandID(GuidList.guidCoatiPluginCmdSet, (int)PkgCmdIDList.cmdidCoatiCreateCDB); _menuItemSetActiveToken = new MenuCommand(MenuItemCallback, setActiveTokenCommandID); _menuItemCreateProject = new MenuCommand(MenuItemCallback, createProjectID); + _menuItemCreateCDB = new MenuCommand(MenuItemCallback, createCDBID); _menuItemCreateProject.Enabled = false; _menuItemSetActiveToken.Enabled = false; + _menuItemCreateCDB.Enabled = false; mcs.AddCommand(_menuItemSetActiveToken); mcs.AddCommand(_menuItemCreateProject); + mcs.AddCommand(_menuItemCreateCDB); } DTE dte = (DTE)GetService(typeof(DTE)); @@ -146,7 +140,7 @@ namespace CoatiSoftware.CoatiPlugin try { DTE dte = (DTE)GetService(typeof(DTE)); - List languages = SolutionUtility.GetSolutionLanguages(dte); + List languages = Utility.SolutionUtility.GetSolutionLanguages(dte); bool enable = false; foreach (String language in languages) @@ -162,6 +156,7 @@ namespace CoatiSoftware.CoatiPlugin { _menuItemSetActiveToken.Enabled = true; _menuItemCreateProject.Enabled = true; + _menuItemCreateCDB.Enabled = true; } } catch(Exception e) @@ -174,22 +169,53 @@ namespace CoatiSoftware.CoatiPlugin { _menuItemSetActiveToken.Enabled = false; _menuItemCreateProject.Enabled = false; + _menuItemCreateCDB.Enabled = false; } private void InitNetwork() { - AsynchronousSocketListener._port = ServerPort; - AsynchronousSocketListener server = new AsynchronousSocketListener(); - AsynchronousSocketListener._onReadCallback = new AsynchronousSocketListener.OnReadCallback(OnNetworkReadCallback); - AsynchronousSocketListener._onErrorCallback = new AsynchronousSocketListener.OnReadCallback(OnNetworkErrorCallback); + Utility.AsynchronousSocketListener._port = ServerPort; + Utility.AsynchronousSocketListener server = new Utility.AsynchronousSocketListener(); + Utility.AsynchronousSocketListener._onReadCallback = new Utility.AsynchronousSocketListener.OnReadCallback(OnNetworkReadCallback); + Utility.AsynchronousSocketListener._onErrorCallback = new Utility.AsynchronousSocketListener.OnReadCallback(OnNetworkErrorCallback); _serverThread = new System.Threading.Thread(server.DoWork); _serverThread.Start(); - AsynchronousClient._port = ClientPort; - AsynchronousClient._onErrorCallback = new AsynchronousSocketListener.OnReadCallback(OnNetworkErrorCallback); + Utility.AsynchronousClient._port = ClientPort; + Utility.AsynchronousClient._onErrorCallback = new Utility.AsynchronousSocketListener.OnReadCallback(OnNetworkErrorCallback); } + private void OnCreateProject(List projects, string configurationName, string platformName, string targetDir, string fileName, string cStandard) + { + Wizard.WindowCreateCDB createCDB = new Wizard.WindowCreateCDB(); + createCDB.Projects = projects; + createCDB.ConfigurationName = configurationName; + createCDB.PlatformName = platformName; + createCDB.TargetDir = targetDir; + createCDB.FileName = fileName; + createCDB.CStandard = cStandard; + createCDB.CallbackOnFinishedCreatingCDB = WriteCDBToFile; + + createCDB.StartWorking(); + createCDB.ShowDialog(); + } + + private void WriteCDBToFile(SolutionParser.CompilationDatabase cdb, string directory, string fileName) + { + string content = cdb.SerializeJSON(); + File.WriteAllText(directory + "\\" + fileName + ".json", content); + + string title = "CDB finished"; + string message = "The CDB " + fileName + " was created at directory \"" + directory + "\"\n"; + message += "You can now use it in Coati."; + + Wizard.WindowMessage windowMessage = new Wizard.WindowMessage(); + windowMessage.Title = title; + windowMessage.Message = message; + windowMessage.RefreshWindow(); + windowMessage.ShowDialog(); + } private void MenuItemCallback(object sender, EventArgs e) { @@ -201,44 +227,62 @@ namespace CoatiSoftware.CoatiPlugin { if (menuCommand.CommandID.ID == (int)PkgCmdIDList.cmdidCoatiSetActiveToken) { - string fileName = FileUtility.GetActiveDocumentName(dte); - string filePath = FileUtility.GetActiveDocumentPath(dte); + string fileName = Utility.FileUtility.GetActiveDocumentName(dte); + string filePath = Utility.FileUtility.GetActiveDocumentPath(dte); - int lineNumber = FileUtility.GetActiveLineNumber(dte); - int columnNumber = FileUtility.GetActiveColumnNumber(dte); + int lineNumber = Utility.FileUtility.GetActiveLineNumber(dte); + int columnNumber = Utility.FileUtility.GetActiveColumnNumber(dte); string message = NetworkProtocolUtility.createActivateTokenMessage(filePath + fileName, lineNumber, columnNumber); - - AsynchronousClient.Send(message); + + Utility.AsynchronousClient.Send(message); + } + else if(menuCommand.CommandID.ID == (int)PkgCmdIDList.cmdidCoatiCreateCDB) + { + CreateCompilationDatabase(dte); } else if(menuCommand.CommandID.ID == (int)PkgCmdIDList.cmdidCoatiCreateProject) { - string solutionName = SolutionUtility.GetSolutionPath(dte); + // CreateCoatiProjectOld(); - if(solutionName == "") - { - List items = SolutionUtility.GetSolutionProjectsFullNames(dte); - - if(items.Count > 0) - { - solutionName = items[0]; - } - } - - if(solutionName.Length > 0) - { - string message = NetworkProtocolUtility.createCreateProjectMessage(solutionName); - - AsynchronousClient.Send(message); - } - else - { - DisplayMessage("Coati", "Can not create a Coati Project. Please check whether your VS solution is a valid C or C++ solution and is saved."); - } + Wizard.WindowMessage windowMessage = new Wizard.WindowMessage(); + windowMessage.Title = "Hint"; + windowMessage.Message = "Consider using 'Create CDB' if errors arise during Coati's indexing. This will become standard in the future."; + windowMessage.OnOK = CreateCoatiProjectOld; + windowMessage.RefreshWindow(); + windowMessage.ShowDialog(); } } } + private void CreateCoatiProjectOld() + { + DTE dte = (DTE)GetService(typeof(DTE)); + + string solutionName = Utility.SolutionUtility.GetSolutionPath(dte); + + if (solutionName == "") // TODO: make a better fallback for non-existant solution + { + List items = Utility.SolutionUtility.GetSolutionProjectsFullNames(dte); + + if (items.Count > 0) + { + solutionName = items[0]; + } + } + + if (solutionName.Length > 0) + { + string message = NetworkProtocolUtility.createCreateProjectMessage(solutionName); + + Utility.AsynchronousClient.Send(message); + } + else + { + DisplayMessage("Coati", "Can not create a Coati Project. Please check whether your VS solution is a valid C or C++ solution and is saved."); + } + } + private void OnNetworkReadCallback(string message) { NetworkProtocolUtility.CursorPosition cursorPosition = NetworkProtocolUtility.parseSetCursorMessage(message); @@ -246,11 +290,11 @@ namespace CoatiSoftware.CoatiPlugin { cursorPosition.ColumnNumber += 1; // VS counts columns starting at 1, coati starts at 0 DTE dte = (DTE)GetService(typeof(DTE)); - if (FileUtility.OpenSourceFile(dte, cursorPosition.FilePath)) + if (Utility.FileUtility.OpenSourceFile(dte, cursorPosition.FilePath)) { - FileUtility.GoToLine(dte, cursorPosition.LineNumber, cursorPosition.ColumnNumber); + Utility.FileUtility.GoToLine(dte, cursorPosition.LineNumber, cursorPosition.ColumnNumber); - SystemUtility.GetWindowFocus(); + Utility.SystemUtility.GetWindowFocus(); } } } @@ -267,17 +311,17 @@ namespace CoatiSoftware.CoatiPlugin private void OnServerPortChanged() { - AsynchronousSocketListener._port = ServerPort; + Utility.AsynchronousSocketListener._port = ServerPort; _serverThread.Abort(); - AsynchronousSocketListener server = new AsynchronousSocketListener(); + Utility.AsynchronousSocketListener server = new Utility.AsynchronousSocketListener(); _serverThread = new System.Threading.Thread(server.DoWork); _serverThread.Start(); } private void OnClientPortChanged() { - AsynchronousClient._port = ClientPort; + Utility.AsynchronousClient._port = ClientPort; } private void DisplayMessage(string title, string message) @@ -298,5 +342,32 @@ namespace CoatiSoftware.CoatiPlugin 0, // false out result)); } + + private void CreateCompilationDatabase(DTE dte) + { + Wizard.ProjectSetupWindow window = new Wizard.ProjectSetupWindow(); + + Utility.SolutionUtility.SolutionStructure projectStructure = Utility.SolutionUtility.GetSolutionVCProjects(dte); + List> configsAndPlatforms = Utility.SolutionUtility.GetConfigurationAndPlatformNames(dte); + + window.m_projectStructure = projectStructure; + + window.m_configurations = configsAndPlatforms[0]; + window.m_platforms = configsAndPlatforms[1]; + + string directory = System.IO.Path.GetDirectoryName(dte.Solution.FullName); + window.m_solutionDirectory = directory; + + string solutionName = System.IO.Path.GetFileNameWithoutExtension(dte.Solution.FullName); + window.m_solutionFileName = solutionName; + + bool containsCFiles = true; // Utility.SolutionUtility.ContainsCFiles(dte); // takes ridiculously long + window.m_containsCFiles = containsCFiles; + + window.UpdateGUI(); + window.m_onCreateProject = OnCreateProject; + + window.ShowDialog(); + } } } diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/PkgCmdID.cs b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/PkgCmdID.cs index f221df51..1e25780e 100644 --- a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/PkgCmdID.cs +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/PkgCmdID.cs @@ -8,5 +8,6 @@ namespace CoatiSoftware.CoatiPlugin { public const uint cmdidCoatiSetActiveToken = 0x104; public const uint cmdidCoatiCreateProject = 0x105; + public const uint cmdidCoatiCreateCDB = 0x106; }; } \ No newline at end of file diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SolutionParser/CommandObject.cs b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SolutionParser/CommandObject.cs new file mode 100644 index 00000000..1a4265f0 --- /dev/null +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SolutionParser/CommandObject.cs @@ -0,0 +1,41 @@ + +namespace CoatiSoftware.CoatiPlugin.SolutionParser +{ + public class CommandObject + { + private string _file = ""; + private string _directory = ""; + private string _command = ""; + + public string File + { + get { return _file; } + set { _file = value; } + } + + public string Directory + { + get { return _directory; } + set { _directory = value; } + } + + public string Command + { + get { return _command; } + set { _command = value; } + } + + public string SerializeJSON() + { + string result = "\t{\n"; + + result += "\t\t\"directory\": \"" + _directory + "\",\n"; + result += "\t\t\"command\": \"" + _command + "\",\n"; + result += "\t\t\"file\": \"" + _file + "\"\n"; + + result += "\t}"; + + return result; + } + } +} diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SolutionParser/CompilationDatabase.cs b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SolutionParser/CompilationDatabase.cs new file mode 100644 index 00000000..1bcf0910 --- /dev/null +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SolutionParser/CompilationDatabase.cs @@ -0,0 +1,28 @@ +using System.Collections.Generic; + +namespace CoatiSoftware.CoatiPlugin.SolutionParser +{ + public class CompilationDatabase + { + private List _commandObjects = new List(); + + public void AddCommandObject(CommandObject commandObject) + { + _commandObjects.Add(commandObject); + } + + public string SerializeJSON() + { + string result = "[\n"; + + foreach(CommandObject cm in _commandObjects) + { + result += cm.SerializeJSON() + ","; + } + + result += "\n]"; + + return result; + } + } +} diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SolutionParser/SolutionParser.cs b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SolutionParser/SolutionParser.cs new file mode 100644 index 00000000..739c0525 --- /dev/null +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SolutionParser/SolutionParser.cs @@ -0,0 +1,502 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using EnvDTE; + +using Microsoft.VisualStudio.VCProjectEngine; +using System.Collections; +using System.IO; +using System.Diagnostics; + +namespace CoatiSoftware.CoatiPlugin.SolutionParser +{ + class SolutionParser + { + static private List _reloadedProjectGuids = new List(); + static private List _compatibilityFlags = new List() { "-fms-extensions", "-fms-compatibility" }; + static private string _compatibilityVersionFlagBase = "-fms-compatibility-version="; // I want to get the exact version at runtime for this flag, therefore I keep it seperate from the others to make things a bit easier... + static private string _compatibilityVersionFlag = _compatibilityVersionFlagBase + "19"; // This default version would correspond to VS2015 + + static public List _additionalCompileFlags = new List(); + + // Creates a cdb from all projects in the solution + // For a more selective approach use 'CreateCommandObjects(...)' for per-project compile commands and assamble the cdb yourself + static public CompilationDatabase CreateCompilationDatabase(DTE dte, string configurationName, string platformName) + { + if(dte == null) + { + return null; + } + + ReloadAll(dte); + + CompilationDatabase compilationDatabase = new CompilationDatabase(); + + EnvDTE.Solution solution = dte.Solution; + + EnvDTE.Projects projects = solution.Projects; + + foreach (EnvDTE.Project project in projects) + { + List cmdObjts = CreateCommandObjects(project, configurationName, platformName, "c11"); // TODO: retrieve real config/platform + + foreach(CommandObject cmdObj in cmdObjts) + { + compilationDatabase.AddCommandObject(cmdObj); + } + } + + UnloadReloadedProjects(dte); + + return compilationDatabase; + } + + public static List CreateCommandObjects(Project project, string configurationName, string platformName, string cStandard) + { + List result = new List(); + + DTE dte = project.DTE; + Guid projectGuid = Utility.SolutionUtility.ReloadProject(project); + + string version = dte.Version; + + VCProject vcProject = project.Object as VCProject; + + if (vcProject == null) + { + return result; + } + + SetCompatibilityVersionFlag(vcProject, configurationName, platformName); + + // gather include paths and preprocessor definitions of the project + List includeDirectories = new List(); + List preprocessorDefinitions = new List(); + + Tuple, List> pathsAndFlags = GetProjectIncludeDirectoriesAndPreprocessorDefs(vcProject, configurationName, platformName); + + includeDirectories = pathsAndFlags.Item1; + preprocessorDefinitions = pathsAndFlags.Item2; + + // create command objects for all applicable project items + List projectItems = Utility.ProjectUtility.GetProjectItems(project); + + VCConfiguration vcProjectConfig = GetProjectConfiguration(vcProject, configurationName, platformName); + string cppStandard = GetCppStandardString(vcProjectConfig); + + foreach (EnvDTE.ProjectItem item in projectItems) + { + CommandObject cmdObj = CreateCommandObject(item, includeDirectories, preprocessorDefinitions, cppStandard, cStandard); + if (cmdObj != null) + { + result.Add(cmdObj); + } + } + + if(projectGuid != Guid.Empty) + { + Utility.SolutionUtility.UnloadProject(projectGuid, dte); + } + + return result; + } + + static private Tuple, List> GetProjectIncludeDirectoriesAndPreprocessorDefs(VCProject project, string configurationName, string platformName) + { + List includeDirectories = new List(); + List preprocessorDefinitions = new List(); + + IEnumerable configurations = project.Configurations as IEnumerable; + + VCConfiguration vcProjectConfig = GetProjectConfiguration(project, configurationName, platformName); + + if (vcProjectConfig != null) + { + // get additional include directories + // source: http://www.mztools.com/articles/2014/MZ2014005.aspx + IEnumerable projectTools = vcProjectConfig.Tools as IEnumerable; + foreach (Object tool in projectTools) + { + VCCLCompilerTool compilerTool = tool as VCCLCompilerTool; + + if (compilerTool != null) + { + string additionalIncludeDirs = compilerTool.FullIncludePath; + string preprocessorDefinition = compilerTool.PreprocessorDefinitions; + + string[] prepDefs = preprocessorDefinition.Split(';'); + + foreach (string prepDef in prepDefs) + { + preprocessorDefinitions.Add(prepDef); + } + + string[] directories = additionalIncludeDirs.Split(';'); + + foreach (string directory in directories) + { + if (directory.Length <= 0) + { + continue; + } + + includeDirectories.Add(directory); + } + + break; // TODO: find some documentation on why the break is needed + // Apparently only the first 'tool' is needed, but why? + } + } + + VCPlatform platform = vcProjectConfig.Platform as VCPlatform; + string platformIncludeDirectories = platform.IncludeDirectories; + string[] seperatedDirectories = platformIncludeDirectories.Split(';'); + + foreach (string directory in seperatedDirectories) + { + string resolvedDirectory = ResolveVSMacro(vcProjectConfig, directory); + string[] splitResolvedDirectory = resolvedDirectory.Split(';'); // resolved macros might result in concatenated paths + + foreach (string p in splitResolvedDirectory) + { + includeDirectories.Add(p); + } + } + } + + includeDirectories = includeDirectories.Distinct().ToList(); + + preprocessorDefinitions = preprocessorDefinitions.Distinct().ToList(); + + for (int i = 0; i < includeDirectories.Count; i++) + { + string path = includeDirectories.ElementAt(i).Replace("\\", "/"); // backslashes would cause some string-escaping hassles... + + bool exists = true; + if (System.IO.Directory.Exists(path) == false) + { + exists = false; + } + + // could be a relative path... + if(exists == false) + { + if (System.IO.Directory.Exists(project.ProjectDirectory + path) == false) + { + exists = false; + } + else + { + path = project.ProjectDirectory + path; + path = path.Replace("\\", "/"); + exists = true; + } + } + + if(exists == false) + { + includeDirectories.RemoveAt(i); + i--; + } + else + { + includeDirectories[i] = path; + } + } + + return new Tuple, List>(includeDirectories, preprocessorDefinitions); + } + + static private VCConfiguration GetProjectConfiguration(VCProject project, string configurationName, string platformName) + { + if(project == null) + { + return null; + } + + IEnumerable configurations = project.Configurations as IEnumerable; + foreach (Object configuration in configurations) + { + VCConfiguration vcProjectConfig = configuration as VCConfiguration; + + if (vcProjectConfig != null && + vcProjectConfig.ConfigurationName == configurationName && + vcProjectConfig.Platform.Name == platformName) + { + return vcProjectConfig; + } + } + + return null; + } + + static private CommandObject CreateCommandObject(EnvDTE.ProjectItem item, List includeDirectories, List preprocessorDefinitions, string vcStandard, string cStandard) + { + DTE dte = item.DTE; + + if (item.FileCodeModel != null && item.FileCodeModel.Language == CodeModelLanguageConstants.vsCMLanguageVC) + { + CommandObject commandObject = new CommandObject(); + commandObject.File = item.Name; + + // only write source files to cdb, headers are implicit + if (CheckIsHeader(item)) + { + return null; + } + + VCFile vcFile = item.Object as VCFile; + string subType = vcFile.SubType; + + VCProject project = vcFile.project; + VCConfiguration vcConfig = GetProjectConfiguration(project, "Release", "Win32"); + + VCFileConfiguration fc = vcFile.GetFileConfigurationForProjectConfiguration(vcConfig); + VCCLCompilerTool t = fc.Tool as VCCLCompilerTool; + + string additionalOptions = t.AdditionalOptions; + CompileAsOptions compileAs = t.CompileAs; // VCCLCompilerToolShim + + if(additionalOptions == "$(NOINHERIT)") + { + additionalOptions = ""; + } + + // check wheter it's a .c file, we don't want that... + // TODO: there is a property for comilation as .c or .cpp file (/TC and /TP), try to retrieve it + string extension = item.Properties.Item("Extension").Value.ToString(); + if (compileAs == CompileAsOptions.compileAsC) + { + vcStandard = "-std=" + cStandard; + } + + // if a language standard was defined in the additional options the 'vcStandard' string is not used + if(additionalOptions.Contains("-std=")) + { + vcStandard = ""; + } + + string directory = item.Properties.Item("FullPath").Value.ToString(); + + int idx = directory.LastIndexOf('\\'); + if (idx != -1) + { + directory = directory.Substring(0, idx + 1); + } + + directory = directory.Replace('\\', '/'); + commandObject.File = directory + item.Name; + + commandObject.Directory = System.IO.Path.GetDirectoryName(dte.Solution.FullName); // TODO: replace with actual cdb location + commandObject.Directory = commandObject.Directory.Replace('\\', '/'); + + commandObject.Command = "clang-tool "; + + foreach (string flag in _compatibilityFlags) + { + commandObject.Command += flag + " "; + } + + commandObject.Command += _compatibilityVersionFlag + " "; + + foreach (string dir in includeDirectories) + { + commandObject.Command += " -isystem '" + dir + "' "; // using '-isystem' because it allows for use of quotes and pointy brackets in source files. In other words it's more robust. It's slower than '-I' though + } + + foreach (string prepDef in preprocessorDefinitions) + { + commandObject.Command += " -D " + prepDef + " "; + } + + foreach(string flag in _additionalCompileFlags) + { + commandObject.Command += " -D " + flag + " "; + } + + commandObject.Command += vcStandard + " "; + + commandObject.Command += additionalOptions + " "; + + commandObject.Command += "'" + commandObject.File + "'"; + + return commandObject; + } + + return null; + } + + static private bool CheckIsHeader(EnvDTE.ProjectItem item) + { + Properties props = item.Properties; + + string propString = ""; + + foreach (Property prop in props) + { + string propName = prop.Name; + string propValue = prop.Value as String; + + propString += propName + " - " + propValue + "; "; + + if (propName == "ItemType") + { + if (propValue as String == "ClInclude") + { + return true; + } + } + } + + return false; + } + + static private string ResolveVSMacro(VCConfiguration vcProjectConfig, string path) + { + string result = path; + + Tuple potentialMacroPosition = Utility.StringUtility.FindFirstRange(path, "$(", ")"); + + if (potentialMacroPosition != null) + { + string potentialMacro = path.Substring(potentialMacroPosition.Item1, potentialMacroPosition.Item2 - potentialMacroPosition.Item1 + 1); + + string resolvedMacro = vcProjectConfig.Evaluate(potentialMacro); + + result = path.Substring(0, potentialMacroPosition.Item1) + resolvedMacro + path.Substring(potentialMacroPosition.Item2 + 1); + } + + return result; + } + + static private void ReloadAll(DTE dte) + { + if (dte == null) + { + return; + } + + EnvDTE.Solution solution = dte.Solution; + + EnvDTE.Projects projects = solution.Projects; + + foreach (EnvDTE.Project project in projects) + { + _reloadedProjectGuids.Add(Utility.SolutionUtility.ReloadProject(project)); + } + } + + static private void UnloadReloadedProjects(DTE dte) + { + foreach(Guid guid in _reloadedProjectGuids) + { + Utility.SolutionUtility.UnloadProject(guid, dte); + } + } + + static private void SetCompatibilityVersionFlag(VCProject project, string configurationName, string platformName) + { + VCConfiguration vcProjectConfig = GetProjectConfiguration(project, configurationName, platformName); + + if (vcProjectConfig != null) + { + IEnumerable projectTools = vcProjectConfig.Tools as IEnumerable; + foreach (Object tool in projectTools) + { + VCCLCompilerTool compilerTool = tool as VCCLCompilerTool; + + if (compilerTool != null) + { + int majorCompilerVersion = GetCLMajorVersion(compilerTool, vcProjectConfig); + + if (majorCompilerVersion > -1) + { + _compatibilityVersionFlag = _compatibilityVersionFlagBase + majorCompilerVersion.ToString(); + return; + } + } + } + } + } + + static private int GetCLMajorVersion(VCCLCompilerTool compilerTool, VCConfiguration vcProjectConfig) + { + if(compilerTool == null || vcProjectConfig == null) + { + return -1; + } + + VCPlatform platform = vcProjectConfig.Platform as VCPlatform; + string executableDirectories = platform.ExecutableDirectories; + string[] seperatedDirectories = executableDirectories.Split(';'); + + List finalDirectories = new List(); + foreach (string directory in seperatedDirectories) + { + string resolvedDirectory = ResolveVSMacro(vcProjectConfig, directory); + string[] splitResolvedDirectory = resolvedDirectory.Split(';'); // resolved macros might result in concatenated paths + + foreach(string d in splitResolvedDirectory) + { + finalDirectories.Add(d); + } + } + + string toolPath = compilerTool.ToolPath; + + foreach(string fd in finalDirectories) + { + string path = fd + "\\" + toolPath; + + if(File.Exists(path)) + { + FileVersionInfo info = FileVersionInfo.GetVersionInfo(path); + int version = info.FileMajorPart; + + return version; + } + } + + return -1; + } + + // AFAIK there is no way to programmatically get the c++ standard version supported by any given VS version + // instead I'm refearing to the VS docu for that information + // https://msdn.microsoft.com/en-us/library/hh567368.aspx + static private string GetCppStandardString(VCConfiguration vcProjectConfig) + { + if(vcProjectConfig == null) + { + return ""; + } + + string result = ""; + + IVCRulePropertyStorage rules = vcProjectConfig.Rules.Item("ConfigurationGeneral"); + + if (rules != null) + { + string toolset = rules.GetUnevaluatedPropertyValue("PlatformToolset"); + + string justNumbers = new String(toolset.Where(Char.IsDigit).ToArray()); + + int versionNumber = int.Parse(justNumbers); + + if (versionNumber < 120) // version 11 (2012) + { + result = "-std=c++11"; + } + else if (versionNumber < 130) // version 12 (2013) + { + result = "-std=c++14"; + } + else if (versionNumber < 150) // version 14 (2015) + { + result = "-std=c++14"; + } + } + + return result; + } + } +} diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SolutionUtility.cs b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SolutionUtility.cs deleted file mode 100644 index 4bbb7b59..00000000 --- a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SolutionUtility.cs +++ /dev/null @@ -1,104 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; -using EnvDTE; - -namespace CoatiSoftware.CoatiPlugin -{ - class SolutionUtility - { - public static String GetSolutionPath(DTE dte) - { - EnvDTE.Solution solution = dte.Solution; - - return solution.FullName; - } - - public static List GetSolutionProjects(DTE dte) - { - List projectNames = new List(); - - EnvDTE.Solution solution = dte.Solution; - EnvDTE.Projects projects = solution.Projects; - - foreach (EnvDTE.Project project in projects) - { - projectNames.Add(project.Name); - } - - return projectNames; - } - - public static List GetSolutionProjectsFullNames(DTE dte) - { - List projectNames = new List(); - - EnvDTE.Solution solution = dte.Solution; - EnvDTE.Projects projects = solution.Projects; - - foreach (EnvDTE.Project project in projects) - { - projectNames.Add(project.FullName); - } - - return projectNames; - } - - public static List> GetSolutionProjectItems(DTE dte) - { - List> projectItems = new List>(); - - EnvDTE.Solution solution = dte.Solution; - EnvDTE.Projects projects = solution.Projects; - - foreach (EnvDTE.Project project in projects) - { - EnvDTE.ProjectItems items = project.ProjectItems; - - List pItems = new List(); - - foreach(EnvDTE.ProjectItem item in items) - { - for (short i = 0; i < item.FileCount; i++) - { - pItems.Add(item.get_FileNames(i)); - } - } - - projectItems.Add(pItems); - } - - return projectItems; - } - - public static List GetSolutionLanguages(DTE dte) - { - List languages = new List(); - - EnvDTE.Solution solution = dte.Solution; - EnvDTE.Projects projects = solution.Projects; - - foreach (EnvDTE.Project project in projects) - { - if (project.CodeModel != null) - { - string language = project.CodeModel.Language; - languages.Add(language); - } - } - - languages = languages.Distinct().ToList(); - - return languages; - } - - public static bool GetSolutionIsSaved(DTE dte) - { - EnvDTE.Solution solution = dte.Solution; - - return solution.Saved; - } - } -} diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/FileUtility.cs b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/FileUtility.cs similarity index 93% rename from ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/FileUtility.cs rename to ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/FileUtility.cs index 959c6a24..09896265 100644 --- a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/FileUtility.cs +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/FileUtility.cs @@ -1,11 +1,7 @@ using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; using EnvDTE; -namespace CoatiSoftware.CoatiPlugin +namespace CoatiSoftware.CoatiPlugin.Utility { class FileUtility { diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/NetworkUtility.cs b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/NetworkUtility.cs similarity index 98% rename from ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/NetworkUtility.cs rename to ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/NetworkUtility.cs index c80f2f3e..46a77bde 100644 --- a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/NetworkUtility.cs +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/NetworkUtility.cs @@ -1,14 +1,11 @@ using System; -using System.Collections.Generic; -using System.Linq; using System.Text; using System.Threading; -using System.Threading.Tasks; using System.Net.Sockets; using System.Net; -namespace CoatiSoftware.CoatiPlugin +namespace CoatiSoftware.CoatiPlugin.Utility { public class StateObject { diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/ProjectUtility.cs b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/ProjectUtility.cs new file mode 100644 index 00000000..ef01b48a --- /dev/null +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/ProjectUtility.cs @@ -0,0 +1,61 @@ +using EnvDTE; +using System.Collections; +using System.Collections.Generic; + +namespace CoatiSoftware.CoatiPlugin.Utility +{ + public class ProjectUtility + { + public static bool ContainsCFiles(Project project) + { + List projectItems = GetProjectItems(project); + + foreach (EnvDTE.ProjectItem item in projectItems) + { + if (item.FileCodeModel != null && item.FileCodeModel.Language == CodeModelLanguageConstants.vsCMLanguageVC) + { + string extension = item.Properties.Item("Extension").Value.ToString(); + if (extension == ".c") + { + return true; + } + } + } + + return false; + } + + static public List GetProjectItems(Project project) + { + List items = new List(); + + IEnumerator itemEnumerator = project.ProjectItems.GetEnumerator(); + + while (itemEnumerator.MoveNext()) + { + ProjectItem currentItem = (ProjectItem)itemEnumerator.Current; + items.Add(GetProjectItemsRecursive(currentItem, ref items)); + } + + return items; + } + + static private ProjectItem GetProjectItemsRecursive(ProjectItem item, ref List projectItems) + { + if (item.ProjectItems == null) + { + return item; + } + + IEnumerator items = item.ProjectItems.GetEnumerator(); + + while (items.MoveNext()) + { + ProjectItem currentItem = (ProjectItem)items.Current; + projectItems.Add(GetProjectItemsRecursive(currentItem, ref projectItems)); + } + + return item; + } + } +} diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/SolutionUtility.cs b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/SolutionUtility.cs new file mode 100644 index 00000000..b5db62c1 --- /dev/null +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/SolutionUtility.cs @@ -0,0 +1,433 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using EnvDTE; +using EnvDTE80; +using System.Runtime.InteropServices; +using System.Runtime.InteropServices.ComTypes; +using Microsoft.VisualStudio.Shell; +using Microsoft.VisualStudio.Shell.Interop; +using Microsoft.VisualStudio; + +namespace CoatiSoftware.CoatiPlugin.Utility +{ + public class SolutionUtility + { + [DllImport("ole32.dll")] + private static extern void CreateBindCtx(int reserved, out IBindCtx bindCtx); + [DllImport("ole32.dll")] + private static extern void GetRunningObjectTable(int reserved, out IRunningObjectTable runningObjectTable); + + public class SolutionStructure + { + public class Node + { + public enum NodeType + { + UNKNOWN = 0, + PROJECT, + FOLDER + }; + + public string Name = ""; + public Project Project = null; + public Object Foo = null; + + public virtual NodeType GetNodeType() { throw (new NotImplementedException()); } + } + + public class FolderNode : Node + { + public List SubNodes = new List(); + + public override NodeType GetNodeType() { return NodeType.FOLDER; } + } + + public class ProjectNode : Node + { + public bool Include = false; + + public override NodeType GetNodeType() { return NodeType.PROJECT; } + } + + public List Nodes = new List(); + } + + public static String GetSolutionPath(DTE dte) + { + EnvDTE.Solution solution = dte.Solution; + + return solution.FullName; + } + + public static SolutionStructure GetSolutionVCProjects(DTE dte) + { + return GetProjectStructureRecursive(dte); ; + } + + public static SolutionStructure GetProjectStructureRecursive(DTE dte) + { + EnvDTE.Solution solution = dte.Solution; + EnvDTE.Projects solutionProjects = solution.Projects; + + List guids = new List(); + + SolutionStructure projectStructure = new SolutionStructure(); + + foreach(Project project in solutionProjects) + { + if(project.Kind == EnvDTE.Constants.vsProjectKindUnmodeled) // not loaded + { + continue; + } + + // check it's a c/c++ project + if(project.CodeModel != null) + { + if(project.CodeModel.Language != CodeModelLanguageConstants.vsCMLanguageVC) + { + continue; + } + } + + if(project.Kind == "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") + { + SolutionStructure.ProjectNode projectNode = new SolutionStructure.ProjectNode(); + projectNode.Name = project.Name; + projectNode.Project = project; + projectNode.Include = false; + + projectStructure.Nodes.Add(projectNode); + } + else + { + SolutionStructure.Node folderNode = GetSubProjects(project); + + projectStructure.Nodes.Add(folderNode); + } + } + + return projectStructure; + } + + private static SolutionStructure.Node GetSubProjects(EnvDTE.Project project) + { + ProjectItems projectItems = project.ProjectItems; + List items = new List(); + + foreach (ProjectItem item in projectItems) + { + Project p = item.Object as Project; + if(p != null) + { + items.Add(p); + } + } + + if(items.Count > 0) + { + SolutionStructure.FolderNode folderNode = new SolutionStructure.FolderNode(); + folderNode.Name = project.Name; + + for (int i = 0; i < items.Count; i++) + { + Project item = items[i]; + + SolutionStructure.Node subFolderNode = GetSubProjects(item); + folderNode.SubNodes.Add(subFolderNode); + } + + return folderNode; + } + else + { + SolutionStructure.ProjectNode projectNode = new SolutionStructure.ProjectNode(); + projectNode.Name = project.Name; + projectNode.Project = project; + projectNode.Include = false; + + return projectNode; + } + } + + public static List GetSolutionProjectsFullNames(DTE dte) + { + List projectNames = new List(); + + EnvDTE.Solution solution = dte.Solution; + EnvDTE.Projects projects = solution.Projects; + + List guids = new List(); + + foreach (EnvDTE.Project project in projects) + { + guids.Add(ReloadProject(project)); + } + + projects = solution.Projects; + + foreach (EnvDTE.Project project in projects) + { + projectNames.Add(project.FullName); + } + + foreach (Guid guid in guids) + { + UnloadProject(guid, dte); + } + + return projectNames; + } + + public static List> GetSolutionProjectItems(DTE dte) + { + List> projectItems = new List>(); + + EnvDTE.Solution solution = dte.Solution; + EnvDTE.Projects projects = solution.Projects; + + foreach (EnvDTE.Project project in projects) + { + EnvDTE.ProjectItems items = project.ProjectItems; + + List pItems = new List(); + + foreach(EnvDTE.ProjectItem item in items) + { + for (short i = 0; i < item.FileCount; i++) + { + pItems.Add(item.get_FileNames(i)); + } + } + + projectItems.Add(pItems); + } + + return projectItems; + } + + public static List GetSolutionLanguages(DTE dte) + { + List languages = new List(); + + EnvDTE.Solution solution = dte.Solution; + EnvDTE.Projects projects = solution.Projects; + + foreach (EnvDTE.Project project in projects) + { + if (project.CodeModel != null) + { + string language = project.CodeModel.Language; + languages.Add(language); + } + } + + languages = languages.Distinct().ToList(); + + return languages; + } + + public static bool GetSolutionIsSaved(DTE dte) + { + EnvDTE.Solution solution = dte.Solution; + + return solution.Saved; + } + + public static List> GetConfigurationAndPlatformNames(DTE dte) + { + List> result = new List>(); + List configNames = new List(); + List platformNames = new List(); + + DTE2 dte2 = SolutionUtility.GetDTE2(dte); + + if(dte2 == null) + { + return result; + } + + EnvDTE80.Solution2 solution = (EnvDTE80.Solution2)dte2.Solution; + if(solution == null) + { + return result; + } + + EnvDTE80.SolutionBuild2 solutionBuild = (EnvDTE80.SolutionBuild2)solution.SolutionBuild; + if(solutionBuild == null) + { + return result; + } + + foreach (SolutionConfiguration2 solutionConfiguration in solutionBuild.SolutionConfigurations) + { + foreach (SolutionContext context in solutionConfiguration.SolutionContexts) + { + string configurationName = context.ConfigurationName; + configNames.Add(configurationName); + + string platformName = context.PlatformName; + platformNames.Add(platformName); + } + } + + configNames = configNames.Distinct().ToList(); + platformNames = platformNames.Distinct().ToList(); + + result.Add(configNames); + result.Add(platformNames); + + return result; + } + + public static DTE2 GetDTE2(DTE dte) + { + List dte2List = new List(); + + IRunningObjectTable runningObjectTable = null; + GetRunningObjectTable(0, out runningObjectTable); + + IEnumMoniker enumMoniker = null; + runningObjectTable.EnumRunning(out enumMoniker); + + enumMoniker.Reset(); + IntPtr fetched = IntPtr.Zero; + IMoniker[] moniker = new IMoniker[1]; + + while (enumMoniker.Next(1, moniker, fetched) == 0) + { + IBindCtx bindCtx = null; + CreateBindCtx(0, out bindCtx); + + string displayName = ""; + moniker[0].GetDisplayName(bindCtx, null, out displayName); + // add all VisualStudio ROT entries to list + if (displayName.StartsWith("!VisualStudio")) + { + object comObject; + runningObjectTable.GetObject(moniker[0], out comObject); + dte2List.Add((DTE2)comObject); + } + } + + // find the correct dte2 instance (each running VS instance has one...) + KeyValuePair maxMatch = new KeyValuePair(null, 0); + foreach(DTE2 dte2 in dte2List) + { + int m = StringUtility.GetMatchingCharsFromStart(dte.Solution.FullName, dte2.Solution.FullName); + if(m > maxMatch.Value) + { + maxMatch = new KeyValuePair(dte2, m); + } + } + + return maxMatch.Key; + } + + // returns true if the project was reloaded, false if the project did not need to be reloaded + static public Guid ReloadProject(Project project) + { + if (project != null && project.Kind == EnvDTE.Constants.vsProjectKindUnmodeled) + { + DTE dte = project.DTE; + + ServiceProvider sp = new ServiceProvider(dte as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); + IVsSolution vsSolution = sp.GetService(typeof(SVsSolution)) as IVsSolution; + + IVsHierarchy hierarchy; + + string solutionDirectory = ""; + string solutionFile = ""; + string userOptions = ""; + vsSolution.GetSolutionInfo(out solutionDirectory, out solutionFile, out userOptions); + + vsSolution.GetProjectOfUniqueName(solutionDirectory + project.UniqueName, out hierarchy); + + if (hierarchy != null) + { + Guid projectGuid; + + hierarchy.GetGuidProperty( + VSConstants.VSITEMID_ROOT, + (int)__VSHPROPID.VSHPROPID_ProjectIDGuid, + out projectGuid); + + if (projectGuid != null) + { + (vsSolution as IVsSolution4).ReloadProject(projectGuid); + return projectGuid; + } + } + } + + return Guid.Empty; + } + + static public void UnloadProject(Guid guid, DTE dte) + { + if (dte == null) + { + return; + } + + EnvDTE.Solution solution = dte.Solution; + + EnvDTE.Projects projects = solution.Projects; + + ServiceProvider sp = new ServiceProvider(dte as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); + IVsSolution vsSolution = sp.GetService(typeof(SVsSolution)) as IVsSolution; + + (vsSolution as IVsSolution4).UnloadProject(guid, (uint)_VSProjectUnloadStatus.UNLOADSTATUS_UnloadedByUser); + } + + static public bool ContainsCFiles(DTE dte) + { + List projects = GetSolutionProjectList(dte); // dte.Solution.Projects; + + foreach (Project project in projects) + { + if(ProjectUtility.ContainsCFiles(project) == true) + { + return true; + } + } + + return false; + } + + static public List GetSolutionProjectList(DTE dte) + { + List solutionProjects = new List(); + + SolutionStructure solutionStructure = GetProjectStructureRecursive(dte); + + Stack nodeStack = new Stack(); + foreach (SolutionStructure.Node node in solutionStructure.Nodes) + { + nodeStack.Push(node); + } + + while (nodeStack.Count > 0) + { + Utility.SolutionUtility.SolutionStructure.Node node = nodeStack.Pop(); + + string name = node.Name; + + if (node.GetNodeType() == Utility.SolutionUtility.SolutionStructure.Node.NodeType.PROJECT) + { + solutionProjects.Add(node.Project); + } + else if (node.GetNodeType() == Utility.SolutionUtility.SolutionStructure.Node.NodeType.FOLDER) + { + Utility.SolutionUtility.SolutionStructure.FolderNode folderNode = node as Utility.SolutionUtility.SolutionStructure.FolderNode; + foreach (Utility.SolutionUtility.SolutionStructure.Node subNode in folderNode.SubNodes) + { + nodeStack.Push(subNode); + } + } + } + + return solutionProjects; + } + } +} diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/StringUtility.cs b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/StringUtility.cs new file mode 100644 index 00000000..bcc6830d --- /dev/null +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/StringUtility.cs @@ -0,0 +1,61 @@ +using System; + +namespace CoatiSoftware.CoatiPlugin.Utility +{ + class StringUtility + { + static public Tuple FindFirstRange(string text, string startTag, string endTag) + { + if(startTag.Length > 0 && endTag.Length > 0 && (startTag.Length + endTag.Length) < text.Length) + { + int start = text.IndexOf(startTag); + int end = text.IndexOf(endTag); + + // just check wheter both, start and end, are valid and the end tag occurs after the start tag + if(start > -1 && end > -1 && end > start) + { + return new Tuple(start, end); + } + } + + return null; + } + + static public int GetMatchingCharsFromStart(string a, string b) + { + int matchingChars = 0; + + if (a != string.Empty) + { + a = a.ToLower(); + } + else + { + return matchingChars; + } + + if (b != string.Empty) + { + b = b.ToLower(); + } + else + { + return matchingChars; + } + + for (int i = 0; i < Math.Min(a.Length, b.Length); i++) + { + if (!char.Equals(a[i], b[i])) + { + break; + } + else + { + matchingChars++; + } + } + + return matchingChars; + } + } +} diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SystemUtility.cs b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/SystemUtility.cs similarity index 83% rename from ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SystemUtility.cs rename to ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/SystemUtility.cs index dbe27e27..358b44e7 100644 --- a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/SystemUtility.cs +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Utility/SystemUtility.cs @@ -1,10 +1,6 @@ using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; -namespace CoatiSoftware.CoatiPlugin +namespace CoatiSoftware.CoatiPlugin.Utility { class SystemUtility { diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/ProjectSetupWindow.Designer.cs b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/ProjectSetupWindow.Designer.cs new file mode 100644 index 00000000..e5a45dec --- /dev/null +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/ProjectSetupWindow.Designer.cs @@ -0,0 +1,277 @@ +namespace CoatiSoftware.CoatiPlugin.Wizard +{ + partial class ProjectSetupWindow + { + private System.ComponentModel.IContainer components = null; + + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(ProjectSetupWindow)); + this.buttonCancel = new System.Windows.Forms.Button(); + this.buttonCreate = new System.Windows.Forms.Button(); + this.comboBoxConfiguration = new System.Windows.Forms.ComboBox(); + this.comboBoxPlatform = new System.Windows.Forms.ComboBox(); + this.labelConfiguration = new System.Windows.Forms.Label(); + this.labelPlatform = new System.Windows.Forms.Label(); + this.buttonSelectAll = new System.Windows.Forms.Button(); + this.labelSelectProject = new System.Windows.Forms.Label(); + this.folderBrowserTargetDirectory = new System.Windows.Forms.FolderBrowserDialog(); + this.textBoxTargetDirectory = new System.Windows.Forms.TextBox(); + this.buttonSelect = new System.Windows.Forms.Button(); + this.textBoxFileName = new System.Windows.Forms.TextBox(); + this.labelFileName = new System.Windows.Forms.Label(); + this.labelFileNameEnding = new System.Windows.Forms.Label(); + this.helpProvider1 = new System.Windows.Forms.HelpProvider(); + this.comboBoxCStandard = new System.Windows.Forms.ComboBox(); + this.toolTip1 = new System.Windows.Forms.ToolTip(this.components); + this.backgroundWorker1 = new System.ComponentModel.BackgroundWorker(); + this.labelCStandard = new System.Windows.Forms.Label(); + this.treeViewProjects = new System.Windows.Forms.TreeView(); + this.SuspendLayout(); + // + // buttonCancel + // + this.helpProvider1.SetHelpString(this.buttonCancel, "Abort creation of the CDB"); + this.buttonCancel.Location = new System.Drawing.Point(12, 413); + this.buttonCancel.Name = "buttonCancel"; + this.helpProvider1.SetShowHelp(this.buttonCancel, true); + this.buttonCancel.Size = new System.Drawing.Size(92, 23); + this.buttonCancel.TabIndex = 9; + this.buttonCancel.Text = "Cancel"; + this.toolTip1.SetToolTip(this.buttonCancel, "Abort creation of the CDB"); + this.buttonCancel.UseVisualStyleBackColor = true; + this.buttonCancel.Click += new System.EventHandler(this.buttonCancel_Click); + // + // buttonCreate + // + this.helpProvider1.SetHelpString(this.buttonCreate, "Start creation of the CDB"); + this.buttonCreate.Location = new System.Drawing.Point(178, 413); + this.buttonCreate.Name = "buttonCreate"; + this.helpProvider1.SetShowHelp(this.buttonCreate, true); + this.buttonCreate.Size = new System.Drawing.Size(92, 23); + this.buttonCreate.TabIndex = 8; + this.buttonCreate.Text = "Create"; + this.toolTip1.SetToolTip(this.buttonCreate, "Start creation of the CDB"); + this.buttonCreate.UseVisualStyleBackColor = true; + this.buttonCreate.Click += new System.EventHandler(this.buttonCreate_Click); + // + // comboBoxConfiguration + // + this.comboBoxConfiguration.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.comboBoxConfiguration.FormattingEnabled = true; + this.helpProvider1.SetHelpKeyword(this.comboBoxConfiguration, "Build configuration for CDB"); + this.helpProvider1.SetHelpString(this.comboBoxConfiguration, "The selected build configuration determines the compile flags for the CDB"); + this.comboBoxConfiguration.Location = new System.Drawing.Point(87, 277); + this.comboBoxConfiguration.Name = "comboBoxConfiguration"; + this.helpProvider1.SetShowHelp(this.comboBoxConfiguration, true); + this.comboBoxConfiguration.Size = new System.Drawing.Size(183, 21); + this.comboBoxConfiguration.TabIndex = 3; + this.toolTip1.SetToolTip(this.comboBoxConfiguration, "The selected build configuration determines the compile flags for the CDB"); + // + // comboBoxPlatform + // + this.comboBoxPlatform.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.comboBoxPlatform.FormattingEnabled = true; + this.helpProvider1.SetHelpString(this.comboBoxPlatform, "The target platform determines some compiler flags included in the CDB"); + this.comboBoxPlatform.Location = new System.Drawing.Point(87, 304); + this.comboBoxPlatform.Name = "comboBoxPlatform"; + this.helpProvider1.SetShowHelp(this.comboBoxPlatform, true); + this.comboBoxPlatform.Size = new System.Drawing.Size(183, 21); + this.comboBoxPlatform.TabIndex = 4; + this.toolTip1.SetToolTip(this.comboBoxPlatform, "The target platform determines some compiler flags included in the CDB"); + // + // labelConfiguration + // + this.labelConfiguration.AutoSize = true; + this.labelConfiguration.Location = new System.Drawing.Point(12, 280); + this.labelConfiguration.Name = "labelConfiguration"; + this.labelConfiguration.Size = new System.Drawing.Size(69, 13); + this.labelConfiguration.TabIndex = 6; + this.labelConfiguration.Text = "Configuration"; + // + // labelPlatform + // + this.labelPlatform.AutoSize = true; + this.labelPlatform.Location = new System.Drawing.Point(12, 307); + this.labelPlatform.Name = "labelPlatform"; + this.labelPlatform.Size = new System.Drawing.Size(45, 13); + this.labelPlatform.TabIndex = 7; + this.labelPlatform.Text = "Platform"; + // + // buttonSelectAll + // + this.helpProvider1.SetHelpString(this.buttonSelectAll, "Select all projects if not all are ticked. Deselect all otherwise"); + this.buttonSelectAll.Location = new System.Drawing.Point(178, 248); + this.buttonSelectAll.Name = "buttonSelectAll"; + this.helpProvider1.SetShowHelp(this.buttonSelectAll, true); + this.buttonSelectAll.Size = new System.Drawing.Size(92, 23); + this.buttonSelectAll.TabIndex = 2; + this.buttonSelectAll.Text = "De/Select All"; + this.toolTip1.SetToolTip(this.buttonSelectAll, "Select all projects if not all are ticked. Deselect all otherwise"); + this.buttonSelectAll.UseVisualStyleBackColor = true; + this.buttonSelectAll.Click += new System.EventHandler(this.buttonSelectAll_Click); + // + // labelSelectProject + // + this.labelSelectProject.AutoSize = true; + this.labelSelectProject.Location = new System.Drawing.Point(9, 9); + this.labelSelectProject.Name = "labelSelectProject"; + this.labelSelectProject.Size = new System.Drawing.Size(78, 13); + this.labelSelectProject.TabIndex = 9; + this.labelSelectProject.Text = "Select Projects"; + this.labelSelectProject.Click += new System.EventHandler(this.label1_Click); + // + // textBoxTargetDirectory + // + this.helpProvider1.SetHelpString(this.textBoxTargetDirectory, "Target directory where the CDB will be stored"); + this.textBoxTargetDirectory.Location = new System.Drawing.Point(12, 333); + this.textBoxTargetDirectory.Name = "textBoxTargetDirectory"; + this.helpProvider1.SetShowHelp(this.textBoxTargetDirectory, true); + this.textBoxTargetDirectory.Size = new System.Drawing.Size(177, 20); + this.textBoxTargetDirectory.TabIndex = 10; + this.toolTip1.SetToolTip(this.textBoxTargetDirectory, "Target directory where the CDB will be stored"); + // + // buttonSelect + // + this.helpProvider1.SetHelpString(this.buttonSelect, "Pick a target directory via folder browser"); + this.buttonSelect.Location = new System.Drawing.Point(195, 331); + this.buttonSelect.Name = "buttonSelect"; + this.helpProvider1.SetShowHelp(this.buttonSelect, true); + this.buttonSelect.Size = new System.Drawing.Size(75, 23); + this.buttonSelect.TabIndex = 5; + this.buttonSelect.Text = "Browse"; + this.toolTip1.SetToolTip(this.buttonSelect, "Pick a target directory via folder browser"); + this.buttonSelect.UseVisualStyleBackColor = true; + this.buttonSelect.Click += new System.EventHandler(this.buttonSelect_Click); + // + // textBoxFileName + // + this.textBoxFileName.Location = new System.Drawing.Point(87, 360); + this.textBoxFileName.Name = "textBoxFileName"; + this.textBoxFileName.Size = new System.Drawing.Size(148, 20); + this.textBoxFileName.TabIndex = 6; + this.textBoxFileName.TextChanged += new System.EventHandler(this.textBoxFileName_TextChanged); + this.textBoxFileName.Leave += new System.EventHandler(this.textBoxFileName_Leave); + // + // labelFileName + // + this.labelFileName.AutoSize = true; + this.labelFileName.Location = new System.Drawing.Point(12, 363); + this.labelFileName.Name = "labelFileName"; + this.labelFileName.Size = new System.Drawing.Size(60, 13); + this.labelFileName.TabIndex = 13; + this.labelFileName.Text = "CDB Name"; + // + // labelFileNameEnding + // + this.labelFileNameEnding.AutoSize = true; + this.labelFileNameEnding.Location = new System.Drawing.Point(241, 363); + this.labelFileNameEnding.Name = "labelFileNameEnding"; + this.labelFileNameEnding.Size = new System.Drawing.Size(29, 13); + this.labelFileNameEnding.TabIndex = 14; + this.labelFileNameEnding.Text = ".json"; + // + // comboBoxCStandard + // + this.comboBoxCStandard.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.comboBoxCStandard.FormattingEnabled = true; + this.helpProvider1.SetHelpString(this.comboBoxCStandard, "Your Solution contains C Files. Please specify which C standard is to be used for" + + " building."); + this.comboBoxCStandard.Location = new System.Drawing.Point(87, 386); + this.comboBoxCStandard.Name = "comboBoxCStandard"; + this.helpProvider1.SetShowHelp(this.comboBoxCStandard, true); + this.comboBoxCStandard.Size = new System.Drawing.Size(183, 21); + this.comboBoxCStandard.TabIndex = 7; + this.toolTip1.SetToolTip(this.comboBoxCStandard, "Your Solution contains C Files. Please specify which C standard is to be used for" + + " building."); + // + // labelCStandard + // + this.labelCStandard.AutoSize = true; + this.labelCStandard.Location = new System.Drawing.Point(12, 389); + this.labelCStandard.Name = "labelCStandard"; + this.labelCStandard.Size = new System.Drawing.Size(60, 13); + this.labelCStandard.TabIndex = 16; + this.labelCStandard.Text = "C Standard"; + // + // treeViewProjects + // + this.treeViewProjects.CheckBoxes = true; + this.treeViewProjects.Location = new System.Drawing.Point(12, 26); + this.treeViewProjects.Name = "treeViewProjects"; + this.treeViewProjects.Size = new System.Drawing.Size(258, 216); + this.treeViewProjects.TabIndex = 17; + this.treeViewProjects.MouseUp += new System.Windows.Forms.MouseEventHandler(this.ProjectCheckList_MouseUp); + this.treeViewProjects.AfterCheck += new System.Windows.Forms.TreeViewEventHandler(this.treeViewProjects_NodeCheckChanged); + // + // ProjectSetupWindow + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.AutoSize = true; + this.ClientSize = new System.Drawing.Size(282, 443); + this.Controls.Add(this.treeViewProjects); + this.Controls.Add(this.labelCStandard); + this.Controls.Add(this.comboBoxCStandard); + this.Controls.Add(this.labelFileNameEnding); + this.Controls.Add(this.labelFileName); + this.Controls.Add(this.textBoxFileName); + this.Controls.Add(this.buttonSelect); + this.Controls.Add(this.textBoxTargetDirectory); + this.Controls.Add(this.labelSelectProject); + this.Controls.Add(this.buttonSelectAll); + this.Controls.Add(this.labelPlatform); + this.Controls.Add(this.labelConfiguration); + this.Controls.Add(this.comboBoxPlatform); + this.Controls.Add(this.comboBoxConfiguration); + this.Controls.Add(this.buttonCreate); + this.Controls.Add(this.buttonCancel); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow; + this.helpProvider1.SetHelpString(this, "Create a CDB from the current C++ solution."); + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "ProjectSetupWindow"; + this.helpProvider1.SetShowHelp(this, true); + this.Text = "Create Compilation Database"; + this.toolTip1.SetToolTip(this, "Create a CDB from the current C++ solution."); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + private System.Windows.Forms.Button buttonCancel; + private System.Windows.Forms.Button buttonCreate; + private System.Windows.Forms.ComboBox comboBoxConfiguration; + private System.Windows.Forms.ComboBox comboBoxPlatform; + private System.Windows.Forms.Label labelConfiguration; + private System.Windows.Forms.Label labelPlatform; + private System.Windows.Forms.Button buttonSelectAll; + private System.Windows.Forms.Label labelSelectProject; + private System.Windows.Forms.FolderBrowserDialog folderBrowserTargetDirectory; + private System.Windows.Forms.TextBox textBoxTargetDirectory; + private System.Windows.Forms.Button buttonSelect; + private System.Windows.Forms.TextBox textBoxFileName; + private System.Windows.Forms.Label labelFileName; + private System.Windows.Forms.Label labelFileNameEnding; + private System.Windows.Forms.HelpProvider helpProvider1; + private System.Windows.Forms.ToolTip toolTip1; + private System.ComponentModel.BackgroundWorker backgroundWorker1; + private System.Windows.Forms.ComboBox comboBoxCStandard; + private System.Windows.Forms.Label labelCStandard; + private System.Windows.Forms.TreeView treeViewProjects; + } +} \ No newline at end of file diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/ProjectSetupWindow.cs b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/ProjectSetupWindow.cs new file mode 100644 index 00000000..6ca5ab73 --- /dev/null +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/ProjectSetupWindow.cs @@ -0,0 +1,432 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; +using System.IO; +using System.Text.RegularExpressions; + +namespace CoatiSoftware.CoatiPlugin.Wizard +{ + public partial class ProjectSetupWindow : Form + { + public class SolutionProject + { + public string m_name = ""; + public bool m_include = false; + + public SolutionProject(string name, bool include) + { + m_name = name; + m_include = include; + } + } + + public delegate void OnCreateProject(List projects, string configurationName, string platformName, string targetDir, string fileName, string cStandard); + + // public List m_projects = new List(); + public Utility.SolutionUtility.SolutionStructure m_projectStructure = new Utility.SolutionUtility.SolutionStructure(); + + public List m_configurations = new List(); + public List m_platforms = new List(); + + public OnCreateProject m_onCreateProject = null; + + public string m_solutionDirectory = ""; + public string m_solutionFileName = "foo"; + + public bool m_containsCFiles = false; + + private List m_cStandards = new List() { "c1x", "gnu1x", "iso9899:201x", "c11", "gnu11", "iso9899:2011", + "c9x", "gnu9x", "iso9899:199x", "c99", "gnu99", "iso9899:1999", "iso9899:199409", "c90", "gnu90", "iso9899:1990", + "c89", "gnu89" }; + + public ProjectSetupWindow() + { + InitializeComponent(); + + UpdateGUI(); + + buttonCreate.Enabled = false; + } + + public void UpdateGUI() + { + InitProjectCheckList(); + InitComboBoxConfigurations(); + InitComboBoxPlatforms(); + InitTextBoxTargetDirectory(); + InitTextBoxFileName(); + InitComboBoxCStandard(); + } + + private void InitComboBoxConfigurations() + { + foreach(string configuration in m_configurations) + { + comboBoxConfiguration.Items.Add(configuration); + } + + if(comboBoxConfiguration.Items.Count > 0) + { + comboBoxConfiguration.SelectedIndex = 0; + } + } + + private void InitComboBoxPlatforms() + { + foreach(string platform in m_platforms) + { + comboBoxPlatform.Items.Add(platform); + } + + if(comboBoxPlatform.Items.Count > 0) + { + comboBoxPlatform.SelectedIndex = 0; + } + } + + private void InitProjectCheckList() + { + //foreach (SolutionProject project in m_projects) + //{ + // treeViewProjects.Nodes.Add(new TreeNode(project.m_name)); + //} + + foreach(Utility.SolutionUtility.SolutionStructure.Node node in m_projectStructure.Nodes) + { + if(node.GetNodeType() == Utility.SolutionUtility.SolutionStructure.Node.NodeType.PROJECT) + { + TreeNode treeNode = new TreeNode(node.Name); + node.Foo = treeNode; + treeViewProjects.Nodes.Add(treeNode); + } + else if(node.GetNodeType() == Utility.SolutionUtility.SolutionStructure.Node.NodeType.FOLDER) + { + TreeNode[] subNodes = GetSubNodes(node as Utility.SolutionUtility.SolutionStructure.FolderNode); + TreeNode treeNode = new TreeNode(node.Name, subNodes); + node.Foo = treeNode; + treeViewProjects.Nodes.Add(treeNode); + } + } + } + + private TreeNode[] GetSubNodes(Utility.SolutionUtility.SolutionStructure.FolderNode folderNode) + { + List result = new List(); + + foreach(Utility.SolutionUtility.SolutionStructure.Node node in folderNode.SubNodes) + { + if(node.GetNodeType() == Utility.SolutionUtility.SolutionStructure.Node.NodeType.PROJECT) + { + TreeNode treeNode = new TreeNode(node.Name); + node.Foo = treeNode; + result.Add(treeNode); + } + else if(node.GetNodeType() == Utility.SolutionUtility.SolutionStructure.Node.NodeType.FOLDER) + { + TreeNode[] subNodes = GetSubNodes(node as Utility.SolutionUtility.SolutionStructure.FolderNode); + TreeNode treeNode = new TreeNode(node.Name, subNodes); + node.Foo = treeNode; + result.Add(treeNode); + } + } + + return result.ToArray(); + } + + private void InitTextBoxTargetDirectory() + { + folderBrowserTargetDirectory.SelectedPath = m_solutionDirectory; + string rootDirectory = folderBrowserTargetDirectory.SelectedPath.ToString(); + textBoxTargetDirectory.Text = rootDirectory; + } + + private void InitTextBoxFileName() + { + textBoxFileName.Text = m_solutionFileName; + + // MakeFileNameUnique(); + } + + private void InitComboBoxCStandard() + { + if(m_containsCFiles == false) + { + comboBoxCStandard.Hide(); + labelCStandard.Hide(); + } + else + { + comboBoxCStandard.Show(); + labelCStandard.Show(); + + foreach(string standard in m_cStandards) + { + comboBoxCStandard.Items.Add(standard); + } + + comboBoxCStandard.SelectedIndex = 3; + } + } + + private void buttonCancel_Click(object sender, EventArgs e) + { + Close(); + } + + private void buttonCreate_Click(object sender, EventArgs e) + { + OnCreate(); + } + + private void OnCreate() + { + if (m_onCreateProject != null) + { + string configurationName = ""; + string platformName = ""; + + configurationName = comboBoxConfiguration.SelectedItem as string; + platformName = comboBoxPlatform.SelectedItem as string; + + string targetDir = textBoxTargetDirectory.Text; + + if(Directory.Exists(targetDir) && CheckFileNameIsValid(textBoxFileName.Text)) + { + if (CheckFileExists()) + { + DialogResult result = MessageBox.Show("A file of the chosen name already exists. Do you want to replace it?", "Coati Plugin", MessageBoxButtons.YesNo, MessageBoxIcon.Warning); + + if(result == DialogResult.No) + { + MakeFileNameUnique(); + return; + } + } + + string cStandard = "c11"; + if(m_containsCFiles) + { + cStandard = comboBoxCStandard.SelectedItem as string; + } + + m_onCreateProject(GetTreeViewProjectItems(), configurationName, platformName, targetDir, textBoxFileName.Text, cStandard); + Close(); + } + else + { + if(Directory.Exists(targetDir) == false) + { + MessageBox.Show("The target directory does not exist.", "Coati Plugin", MessageBoxButtons.OK, MessageBoxIcon.Warning); + } + + if (CheckFileNameIsValid(textBoxFileName.Text) == false) + { + MessageBox.Show("The chosen file name is not valid.", "Coati Plugin", MessageBoxButtons.OK, MessageBoxIcon.Warning); + } + } + } + } + + private bool CheckFileNameIsValid(string fileName) + { + Regex badChars = new Regex("[" + Regex.Escape(new string(System.IO.Path.GetInvalidFileNameChars())) + "]"); + if(badChars.IsMatch(fileName)) + { + return false; + } + + return true; + } + + private bool CheckFileExists() + { + string fileName = textBoxFileName.Text; + string path = textBoxTargetDirectory.Text; + string extension = labelFileNameEnding.Text; + + return File.Exists(path + "\\" + fileName + extension); + } + + private List GetTreeViewProjectItems() + { + List solutionProjects = new List(); + + // Stack treeNodes = new Stack(); + Stack nodeStack = new Stack(); + foreach(Utility.SolutionUtility.SolutionStructure.Node node in m_projectStructure.Nodes) + { + nodeStack.Push(node); + } + + while(nodeStack.Count > 0) + { + Utility.SolutionUtility.SolutionStructure.Node node = nodeStack.Pop(); + + bool include = (node.Foo as TreeNode).Checked; + + string name = node.Name; + + if(node.GetNodeType() == Utility.SolutionUtility.SolutionStructure.Node.NodeType.PROJECT + && (node.Foo as TreeNode).Checked == true) + { + solutionProjects.Add(node.Project); + } + else if(node.GetNodeType() == Utility.SolutionUtility.SolutionStructure.Node.NodeType.FOLDER) + { + Utility.SolutionUtility.SolutionStructure.FolderNode folderNode = node as Utility.SolutionUtility.SolutionStructure.FolderNode; + foreach(Utility.SolutionUtility.SolutionStructure.Node subNode in folderNode.SubNodes) + { + nodeStack.Push(subNode); + } + } + } + + return solutionProjects; + } + + private void ProjectCheckList_SelectedIndexChanged(object sender, EventArgs e) + { + + } + + private void buttonSelectAll_Click(object sender, EventArgs e) + { + bool select = false; + + // if one or more items are unselected, select all + // otherwise deselect all + for (int i = 0; i < treeViewProjects.Nodes.Count; i++) + { + if (treeViewProjects.Nodes[i].Checked == false) + { + select = true; + } + } + + for (int i = 0; i < treeViewProjects.Nodes.Count; i++) + { + treeViewProjects.Nodes[i].Checked = select; + } + + UpdateCreateButtonEnabled(); + } + + private void label1_Click(object sender, EventArgs e) + { + + } + + private void buttonSelect_Click(object sender, EventArgs e) + { + if(Directory.Exists(textBoxTargetDirectory.Text)) + { + folderBrowserTargetDirectory.SelectedPath = textBoxTargetDirectory.Text; + } + + folderBrowserTargetDirectory.SelectedPath = textBoxTargetDirectory.Text; + + DialogResult result = folderBrowserTargetDirectory.ShowDialog(); + + string selectedPath = folderBrowserTargetDirectory.SelectedPath; + + textBoxTargetDirectory.Text = selectedPath; + } + + private void treeViewProjects_NodeCheckChanged(object sender, TreeViewEventArgs e) + { + // treeViewProjects.AfterCheck -= treeViewProjects_NodeCheckChanged; + + Stack nodeStack = new Stack(); + + foreach (TreeNode subNode in e.Node.Nodes) + { + nodeStack.Push(subNode); + } + + while (nodeStack.Count > 0) + { + var node = nodeStack.Pop(); + + node.Checked = e.Node.Checked; + + //foreach (TreeNode subNode in node.Nodes) + //{ + // nodeStack.Push(subNode); + //} + } + + // treeViewProjects.AfterCheck += treeViewProjects_NodeCheckChanged; + } + + private void textBoxFileName_TextChanged(object sender, EventArgs e) + { + + } + + private void textBoxFileName_Leave(object sender, EventArgs e) + { + // MakeFileNameUnique(); + } + + private void MakeFileNameUnique() + { + string fileName = textBoxFileName.Text; + + int i = 0; + while (CheckFileExists()) + { + ++i; + textBoxFileName.Text = fileName + i.ToString(); + } + } + + private void ProjectCheckList_ItemCheck(object sender, ItemCheckEventArgs e) + { + + } + + private void ProjectCheckList_Click(object sender, EventArgs e) + { + + } + + private void ProjectCheckList_MouseUp(object sender, MouseEventArgs e) + { + UpdateCreateButtonEnabled(); + } + + private void UpdateCreateButtonEnabled() + { + bool anythingChecked = false; + + Stack treeNodes = new Stack(); + foreach(TreeNode node in treeViewProjects.Nodes) + { + treeNodes.Push(node); + } + + while(treeNodes.Count > 0) + { + TreeNode node = treeNodes.Pop(); + + if(node.Nodes.Count <= 0 && node.Checked == true) + { + anythingChecked = true; + } + + foreach(TreeNode subNode in node.Nodes) + { + treeNodes.Push(subNode); + } + } + + buttonCreate.Enabled = anythingChecked; + } + } +} diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/ProjectSetupWindow.resx b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/ProjectSetupWindow.resx new file mode 100644 index 00000000..1e3f6ea2 --- /dev/null +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/ProjectSetupWindow.resx @@ -0,0 +1,1343 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + 229, 17 + + + 356, 17 + + + 17, 17 + + + 453, 17 + + + 37 + + + + + AAABAAgAEBAAAAEACABoBQAAhgAAABgYAAABAAgAyAYAAO4FAAAgIAAAAQAIAKgIAAC2DAAAKCgAAAEA + CACoCwAAXhUAADAwAAABAAgAqA4AAAYhAABAQAAAAQAIACgWAACuLwAAgIAAAAEACAAoTAAA1kUAAAAA + AAABACAA6ocAAP6RAAAoAAAAEAAAACAAAAABAAgAAAAAAAABAAAjLgAAIy4AAAABAAAAAQAA3sKfANG1 + rwDTtq0A1LavANS2swCHPCUAhz0mAIY7KwCGOywAhjwpAIY9LACHPSwAhz4tAIg9IQCIPSIAiD4iAIk/ + KACIPiwAiT8tAIg+LwCLQh8AjEMYAI1EGQCORhsAkUcTAJFHFACRSBQAlk4RAJZOEwCZVBoAikAkAIpA + JQCMQyAAjUQhAI1GIwCKQCkAjUcsAI5HLQCPSjwAkUsqAJFMMgCRTTMAkk41AJBLPQCQTDsAkU4/AJdV + LQCTUDsAnF0/AKVcAACmXQAAoVoJAKJbCwChXR8ArmUAAK5mAACvZwAAq2UMALhvAAC4cQIAvXoSAL16 + EwC4eB4AomAiAK5vKQCtcTsAtHYlALV5KQC4eSAAtn4/ALh+MQCVVEMAllZHAJdWRgCdYEIAnWFUAKZv + ZACpc2MAqnVlAKlzaQCla1EApm5UAKx1TgCocVgAuYRJALmFSgCpdGgAsX9iAMaknwDJqKAA2LyiANG1 + qgDQtK4A0LOoAM+zrQDXuaAA28CcAOTInwDjyaIAuYAzALqBNgC5gkYAvIlQAMqWRwDLmEcAsYJ4ALeI + ZgC1hWkAtohsALmKaQC8j28AsoJ4ALiLdgC6jnoAvZN/AMSbewC9lH8Av5aCALySigC7kokAw5t4AMmc + YQDKnmQA27JxANanWwDOpG0Ay6NzANSvfgDbsnAA2riKANm4iQDlypwA5cmbAMyqjQDFoZcAxqKXAMej + lgDHpZwAyKWdANKwhwDStqwA1ryuANi+sQDcwaMA38esAN7HtQDhy7cA4s24AOPOugDk0b4A5tfNAOja + 0wDq3NQA7N/TAO3g2ADt4tgA8OXXAPLo3wDy6uYA8+zlAPbw6wD59O8A+PTxAPn08AD69vUA+/jzAPv4 + 9QD9/PsA////APXq2QD16tkA7uPgAO7j4wDx5+AA7uDgAPLl2wDv4t4A///1AP///wD///8A////AP// + /wD///8A////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALi4 + uLiphIB8fICBq7i4uLi4uLQKZzw7Ozs7RGiBt7i4uLSBRDg4ODg4ODo8RIO4uLhgZH15QzJCf31kOTlj + YLivVUCcj0U0i6WQZjN+ZVWpXzU/maGSlKaoopWTnEE1WHgcHIWoqKioqKibn5EdHHhqGBlup6ioqKio + oJtSGBlrbBYulo2OoqiopJ6YaxcWbHQhSZhKIVBwcVNQcichIXRbLyeMiCgPDw8PHyUjHypbq1AGL4eH + IyMQECMfIxBPq7UDRyyJihERERERERFIA7W4tFhLVi0MDBEREQhIWLS4uLi0AUwmEwgIEytPA7S4uLi4 + uLWrW3ZpaXZbq7i4uLjwDwAAwAMAAIADAACAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAgAEAAMADAADgDwAAKAAAABgAAAAwAAAAAQAIAAAAAABAAgAAIy4AACMuAAAAAQAAAAEAAIg9 + GgCHPScAhz0tAIk/IwCIPyoAjUMcAI1DFwCWTQ8AmE8NAJBHFACQRxwAlEsUAJJLGgCbUw0Al1EaAJpR + EACKQSUAi0MrAI9IJQCPSS4AjEQ0AI9KOACRSyYAkE0+AJZRKACfXSUAlVM0AJZVPwCZWTsAoFcAAKVd + AgChWxcAoF8nAKVgDgCsZAEAqWMIAK9qDACqZxQAs2sAALJtDQCybxMAvXUCAL54BwCzcBUAqGcnAKZn + LAChYzkAr3Q5ALFzLAC2ei0AsnYwAJJOQACaXEwAnF1AAJteUgCfYkcAnWFPAJ9lVwCgZUkApWxcAKRr + VQCsdlsAsntFALJ7SgCyflgApW1gAKp0YACwfmQAsX9pALyFPgC7il4Au498AM6phQDCgRcAw4guAMKH + KwDMlT4Ayp9oAMicYgDCmXoA0qlvANCocgDMo3EAzKV7ANCqdwDeuoAA9e3lAPjx4gC8k4kAvpWAAL+X + igDEnpEAw56WAMyspADYu5QA4s69AN/LwADv3LwA4c/DAN/LyADCnI0Az6uIAMqliADJppsAy6qUAM2s + mQDTtqQAxaKXANKwjgDXt5IA0rOaANi6lwDgwZQA2LmQANa8pgDUuKoA6MyfAMqpogDRtK8A2b+sANS4 + qgDWvLMA3cOjANzFvQDZwbMA5MSPAODHpgDiyqoA4cu1AObSuwDhzskA6dvPAOTSxgDm19MA6tzUAO3h + 1ADt4doA8efeAPLo3gDw5NIA8OfhAPPq5QD38e4A+fbyAPv59wD///4A6tvUAOjY1ADv4M0A8ePNAPHn + 4gDy6egA+vXtAPbt6AD37+IA8ennAPbx7QD28fAA+vPsAP///wD///8A////AP///wDo6OgAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACjo6Ojo6OjopeVZX19cFuXoqOjo6Ojo6Ojo6Ojo5+SUUxJSUkpKkpMUZeho6Ojo6Ojo6OjmHFLJilJ + KSkmKSlJKUpxmKOjo6Ojo6OXUScmJikpJiYmJikpJiYnUZmjo6Ojo5lUJCcnJyIiIiIrJygkIiIiIlGY + o6Ojn3AkVH9NeiMeHkWLUn5OHh4eMihxoaOjlzIeb49SeiMNHm2RgW9SHQ0wfiUwkqOibB8NZZGLbC8s + ZY+RkIBTLD6BhB8NSKGXPg0NRpGRj4mNkZGRkZGOio+Rbg8PTpdiGQ8HIIaRkZGRkZGRkZGPg5CPQA8H + L5VrDgsLC0+RkZGRkZGRkZGMZpB3DgcOH3doDAwJDG6RkZGRkZGRkZGRkYYuCQwMDnhoCgUGQJCMfI6R + kZGRkZGRkYhkGAoKCmlrFgUFaZBDEj14iI6OjHtZhmk9FgUFEmtiGgUQZ441AAUQGjc6HBYAR0QABQUQ + GmKWPAMDQo5kEQMEAwMDAxAQERMQEBADO5efXBMTEWSNeRsEEAQEBBEREAQQBAQRWKGjlzwRBAM6gmsB + BAQEBAICBAQEBBE8l6OjoVgUBBdBgmcBBAQCAgICBAQEARtboaOjo51YFDuFezQCAgICAgICBAIEAlud + o6Ojo6OdWBQzFAIUAgICAgICAgIVWJejo6Ojo6OjnVg2AgICAgICAgICAjlYnaOjo6Ojo6Ojo6GXXEI2 + FAICFDNBWJefo6Ojo6Ojo6Ojo6Ojn5dcdnZ2dmOXoqOjo6Ojo6MAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAoAAAAIAAAAEAAAAABAAgAAAAAAAAEAAAjLgAAIy4AAAABAAAAAQAAiT8eAIc8 + JgCHPS0AiT8kAIg/KQCMQx0Aj0YVAJVMDwCYTw8AkUcUAJRMEwCRSRkAnlQHAJ1UDACZUhIAmVMYAIpB + JACMRCwAj0ksAI9IJACNRzkAj0k7AI5JNACSTScAkk00AJFMPQCWUiUAlVIuAJtXJwCcXDYAmVg2AKBX + AACkXAEAoFkPAKJdGACrYwAAq2UIAKhkEwCzawAAsW8WALpxAAC6dxEAv3wSALFwGACkYiMApWc3AK9z + MwC0dyYAt3wsALR6NACbXEEAmVtNAJhXQgCdYEEAnmRWAKJnSQCkak0Ao2lUAKFpWwCqc1gAs35TAKZv + YwCoc2cAqXRoAK15ZgCufXIAsH9qAMJ+DgC8gjQAvIM5AL+IOgC/i0oAv4lCAL6MVAC9jFsAtYJWAL2O + YwC4h2EAtoh2AL+QYwC9kXEAxIIVAMiLJwDBjEUAwo5IAMaSRgDRnkkAxZZZAMaZYwDInWoAyJ50ANGh + VgDLom0AzKN0AMymfgDWrnIA37uBALqPhAC8k4kAvpaIAPPr4AD17N4A7+bjAMOcjADDnZUAyaSGAMyr + nQDIpp4A0q+FANa1jADQsZsA1LWWAMytpgDUuKYA2L+yAOLPwQDbxL8A4s/KAN7JwwDjz7UA5tTEAOja + 1wDm19UA4s/JAN3CpQDcw6wA28S1ANzFvADfy74A69a3AO/dwQDu49gA4c2/AObSuwDw38MA7+HOAPDm + 3gD27dwA4tDJAOXUzgDt4dsA49DFAOTSxgDm1c0A6trIAOzf2wDo2dEA7uHUAO7j3ADx5twA7+ThAPTt + 6gDz6+YA9/HrAPjz7QD59fIA+/n3AP///wD38vAA7uPgAPny8gD59fIA+PPwAPv38wD59fMA+/n3APz4 + 9gD59vMA+vXyAPn18QD8+vgA/fr4AP///wD///8A////AP///wD///8A/v7+AP///wD///8A////AAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALS0 + tLS0tLS0tLSyrauHjYaGjYekrrO0tLS0tLS0tLS0tLS0tLS0tLSuq4JtVlJRUVFRUlaGkKuztLS0tLS0 + tLS0tLS0tLS0q4VbQ0MoKChDKCgoKFFSVoKrsrS0tLS0tLS0tLS0sWhfUSgoKCgoKCgoJigmUUNDQ2xo + rrS0tLS0tLS0tK6HVCYmJiYmJiYmJiYmJiYmJiYoJlV7rrS0tLS0tLSzh0UkIyAjIyMmIyMjICMjICYj + IyYmI1KHs7S0tLS0sp9VJ1JEJ1QvICMjICdUUidUMCMjICAgIFSrsrS0tLSrXyQwmYZUm1ggICAgV52R + VJltICAgIC9IIF2rtLS0s3AlHzGbmlSOWB8gHyB8nZxYhG0fHyAfbGwgJ36utLSkSh8MLpedhVpaDCEh + WZudnZBabyEMIUqeaR8hWau0sYIsDg4slZ2dkm9KWHGenZ2dnZVxWEpvnp1YDQ4sgrKrbA4ODg59nZ2d + nZydnZ2dnZ2dnZ2cnZ2dly4IDghprqtLCAoOCEycnZ2dnZ2dnZ2dnZ2dnZmbnZ1+DwoOCkqkgi0KCgoK + HI6dnZ2dnZ2dnZ2dnZ2cTW6dm0sHCgoKLYeMHAkJCQkJUJ2dnZ2dnZ2dnZ2dnZ2Ek51uCwoKCgkcjIQa + CwkLCS2PnZ2dnZ2dnZ2dnZ2dnZ2dfhwGCwsLCRqOjhwLCwsLbp2dkpidnZ2dnZ2dnZ2cnJyOaR0FCwUJ + HJCSHhMFBR2UnXEbOHKanZ2dnZ2dnJKRno1/OwUFCwUdjZ84BRMFN56eNwAFEzhnco2PhGpAGFqXNwsD + CwsTADifn1oAAwAymJcyABAFAAAQEhcTAwABGHA5AwADAxMDQKuuZwMQEBFynWcQAwMQEBAQAxEDAwMD + EhEEAwMDER5yq7RwGBEEAzmWm3A0AwMEEBADAwMDAwMDAwQTBAQSNI20tKtOGAQEAzl/m480AwQEBAQE + AwMEBAQEBAIEBANCq7S0ro8zBAQEARFBnGEBBAQEBAQEBAQEBAICAgQEHmu0tLS0q2ECAgIRGUGcYgQC + BAICAgICAgICAgICGTRwq7S0tLS0ez0CAj6UnpEzAgICAgIUAgICAgICAgICQZ+utLS0tLSzcD0CM3Br + NgICAgICAgICAgICAgICAj+isrS0tLS0tLSunz0CAgICAgICAgICAgICAgICAgJBdK60tLS0tLS0tLSx + ZGIUAQICFAICAgICAgICAgI0f5+ztLS0tLS0tLS0tLSzpXVBFQICAgICAgICAgI0QXCrtLS0tLS0tLS0 + tLS0tLS0saCMa0E6NDQVNDZBa6Crs7S0tLS0tLS0tLS0tLS0tLS0tLSwn4yMjY2fZmGxs7S0tLS0tLS0 + tLT/wAP//wAA//4AAD/4AAAf8AAAD+AAAAfAAAADwAAAA4AAAAGAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABgAAAAYAAAAPAAAAD4AAAA+AAAAfwAAAP+AAAH/wA + AH//AAD//+AD/ygAAAAoAAAAUAAAAAEACAAAAAAAQAYAACMuAAAjLgAAAAEAAAABAACJPx4AhjwmAIc9 + LQCIPiUAiD8qAIxDHACVSw8AmE8PAJBHFgCUTBMAkUkZAJ9WBgCcUw0AmlIRAJ5aHQCYUhsAikElAIxD + KgCOSDUAjko6AI1HNgCRSysAk00mAJJONACWUzMAnV01AJdWOwCfYj8ApFsBAKBYCQCkWwQAoFscAKxk + AACnYQoApmEWAK9vHACraBcAsGcAALNrAAC4bwAAsW4SALFvGQC6cgAAsXEbALd2GQCpaSkAoWQ7AKpu + OQCtcTUAtXcjALF2NQC2fDkAuX4wALN4OACVVEQAm11DAJlaTACbXlIAn2NIAKJlQwClakgApGtTAKVs + XQCtdkwAqnBDAKpzVwCsdlkAsntKAKVtYgCpdWoAqXVoAMB8DwC8h0UAt4RWALWEZgC0hW0AuYljALGB + cwC0hnsAuYx1ALaKfwC/kWoAvJJ6AMaJKADMkC8AzJU9AMGOSQDLlUIAypdJANCaQgDHmFkAyJ1oAMec + cADNo2sAy6V8AM2kcQDYrGIAvpWGAMSdhwDOqYYAzqyPAMejkgDHpZoAyKaVAM6unQDRro0A0K+SANi3 + iwDcvI8A1bGEANOzlQDWt5YAyaehAMqqowDPsaUA0bSkANG1rQDWu6oA2b2gANW7tADXvrkA3cGcAN3D + pQDcw6oA3MS0AN3IvgDiwo8A4sOSAOHHogDjzKsA48qlAODJswDl0LcA7NrBAP/+/ADgzccA5NLLAOPS + zQDv5d4A9e7pAPTt6gDiz8UA5dPEAOvbyQDq3NQA9uzeAPv38wDu490A7eDUAPHm2wDz6t4A+PPvAPHo + 5QD17+oA8OflAPTs5AD58+gA9e7pAPfx7QD48u0A+fXyAPz69wD///8A9/LwAPXw7gD79u8A9vHsAPjz + 6gD+/f0A/f37AP7++wD+/PsA/v79AP/+/gD//v4A////AP///wD///8A////AP///wD///8A////AP// + /wD///8A/f39APz8/AD19fUA////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu7u7u7u7 + u7u7u7u7u7uyr6illJaWlJeor7K7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7sq6og39gWVRTU1NgYH+E + qK+6u7u7u7u7u7u7u7u7u7u7u7u7u7u6r5R/VUcqR0dHR0dHR1MqR1mCja+6u7u7u7u7u7u7u7u7u7u7 + u7uylH9TKicnKkdHR0cnJ0dHKidHR1N+mbS7u7u7u7u7u7u7u7u7u7qvjlcnJycmJyclJyclJicmJyYm + JyZHR2Cfr7u7u7u7u7u7u7u7u7qolUclJiYlJSUlJSUlJSUlJSUmJiUlJyZHVYWst7u7u7u7u7u7u7qo + glMlJiUlJSUgICUlJSUgJSUlJSUlJSUlJSUsf6y7u7u7u7u7u7uvlFMnJiUgHiAgICAgICAgHCAgIBwc + JSUlJSAcHCmBr7u7u7u7u7uyhCscVmxaK21eKxwgICAcNGtrNEhsXSEgIBwgICAlNJayu7u7u7u3jVYc + HG+ihTGWliMcHBwcHF+iol9booEcHBwcHCFdKyVajbq7u7u7r3kcHBx6op8zeZMkHBwcHCGEoqKEM516 + HhwcHBwzlTMcHnmvu7u7uY01HR0ddqKiekiPNQsLCwtcoaKioVxejiILHQsie6A1HR0zkbK7u6xvHQwM + B2SioqJ7XEkLDCJen6KioqKfY2M1DA0weqKbLQwdHW+vu7eSSR8NDQdboqKiopqDbm+QoaKioqKioqGU + e2p7mqKijh8NDQ1DqLu3jh8NDQ0HL5uioqKioqKioqKioqKioqKioqKioqKiomoNDQ0NH4+yr28HBw0N + CQ98oqKioqKioqKioqKioqKioqKioaKioqBDCQkHCQl2r6hMBgYJCQkJSaCioqKioqKioqKioqKioqKi + e0maoqJ8DwkHBgkGXKiNPwkJCQkJCQ91oqKioqKioqKioqKioqKiomhAk6KePwkJCQkJBkKSmi4ICQkJ + CQoJYqKioqKioqKioqKioqKioqKhn6KhYwkJCgoKCghAmpUuCAgKCgoISp+ioqKioqKioqKioqKioqKi + oqKhaAoKCAgICgoILpqaLgUKCgoFGZCioqCboaKioaGhoaKioqKioqKioHVSGQoKCgUKCC6anTsFBQUF + BU+ioptGOnOgoqGhoaGioqKioqGeoqChoGgWBQUFCgA8mIw9BQUFBQVooqJPBQUWQXOToKGhoqKhoI1S + S6GNQT0YBRAFEAUFQZKoSwUFBRAFdaKdGwUFBQUQGEJiZWViSzwVABWNkxcABRAFBQUFBU+ur3wVFRYA + AGeinjoDAxAQBQUAAAAFAAAFEAUAPXwYEAUQEAUQEAB1r7KQGgQDAABCoKJiAwMDEBAQEBAQEBAQERAQ + EQAYERAQABYRABEYkLe6iD0DAwMEFXShnWIXAxADEREREREDERARAxEDAxEDEQMDAwMERY26u6xmBAQE + BAMad6Ghij4DEAMDAwMDAwMDAwMEAwMDAxEDAwMVEnWsu7u5kT0DAwQEBBNFjaGQNwQDEQMRBAQRAwIC + EQIDEQQEBAMEAz6Jubu7u6x1BAQEBAICAxKNoUUDBAQDAwMEAwMCAgICBAQEBAQEBAR8r7u7u7u5mT4D + AgICAgICeKJFAgICAgIRAgMCAgICAgIREQIEBANGmLq7u7u7u7KNNgMCAz53jaGaOAICEQICAgICAgIC + EQICAgICBAM4jba7u7u7u7u7r3cTAgFhoqKYRQICAgICAgICAgICAgICAgICAhI5kK+7u7u7u7u7u7ms + dBMBFERFOAICAgICAgICAgICAgICAgICAgI4eKi6u7u7u7u7u7u7t6x3NgECAgICAgICAgICAgICAgIC + AgIUAgI4kLC6u7u7u7u7u7u7u7u5rIhEAgICAgICAgICAgICAgICAgICExRFh6+6u7u7u7u7u7u7u7u7 + u7uyjXQ4NgICAgICAgICAgICExQCAkSHoLK6u7u7u7u7u7u7u7u7u7u7u7qvqHhFNgICAgICAgICAhM2 + RHGar7m6u7u7u7u7u7u7u7u7u7u7u7u7u7Kvi41xYkU5OTk5RVB4naOyubq7u7u7u7u7u7u7u7u7u7u7 + u7u7u7u7u7qyr62MoJ6amKOtr7a6u7u7u7u7u7u7u7u7u//8AD//AAAA/+AAB/8AAAD/gAAB/wAAAP8A + AAD/AAAA/AAAAH8AAAD4AAAAHwAAAPAAAAAfAAAA8AAAAA8AAADgAAAABwAAAMAAAAADAAAAwAAAAAMA + AACAAAAAAQAAAIAAAAABAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAIAAAAABAAAAgAAAAAEAAADAAAAAAwAAAMAAAAADAAAA4AAAAAcAAADwAAAADwAAAPAA + AAAPAAAA+AAAAB8AAAD8AAAAPwAAAP8AAAB/AAAA/4AAAP8AAAD/4AAD/wAAAP/4AB//AAAAKAAAADAA + AABgAAAAAQAIAAAAAAAACQAAIy4AACMuAAAAAQAAAAEAAIk/HgCGPCYAhz0tAIk+JQCIPykAiD4wAI1E + FgCNRBwAlUsPAJhPDgCQRxUAlEwTAJFIGQCdVAwAn1YDAJpTEQCYURcAi0EkAIxDKQCPSScAi0QzAI9K + OwCOSDcAkkwoAJFNPACRTDUAmVYpAJVSMgCbWzwAl1U3AKBXBQCkXAIAo1wNAKNeGQCgXSUApmAKAKxl + AACrZQsArmoOAKtkAgCraBgAs2sAALhvAAC1bwoAunIAALx4DgCxcR8ApGIjAKtsJwCucCoArXM7ALZ5 + JgCwdDUAkk9AAJVURQCYWEcAn2JFAKRpSQClbFIApWxdAK10RACrdFIAqnRbAKx3WgC1fUQAsntLALF8 + VgCmb2AAqXRlAKx6bQCoc2YArnxyALB/dQDAfRMAv4IlALmDPwC6hUsAuYVVALSDZAC5i2gAs4N0ALSF + fAC2iH0Au493AL6ScgDDgRQAzpc+AMCOUQDGllgA059JAMCRYwDHmmUAxJt5ANSjUwDTpFwAzaNvAM2i + ZADJo38AyqFyANerZADRq3kA1KxxANq1fAC6j4MAvJKEAL2TigC/mI8AwZuJAMOdlADMqYsAyqWHAMil + lgDRrogA1bSIAN+8gwDavZoAz7GrANK0owDVuq0A17ymANa9tADVurIA4b2CAN3BnQDexKUA28KtANzF + ugDex7UA4sacAOLKqADizLYA4Mq4AOrSqQDl0bcA5tO9AO3avADeycIA38zIAPz6+QDl1MwA69zMAOjW + xADm1tIA693XAOve2gDo2dYA/Pr5AODMxgDu4c0A7+LTAO7j3wDy48wA8+bUAPHm2wD69vIA+/j0APfy + 8QD59O8A9OzrAPHn4wDy6uQA9e/rAPjx6AD28ewA9/HqAP37+gD69vQA+/j2AP///wD+/f0A+vf1AP// + /gD7+fkA////AP///wD///8A////AP/+/gD///8A////AP///wD///8A////AP///wD///8A////AP7+ + /gD///8A////AP7+/gD///8A////AP7+/gD+/v4A////APz8/AD///8A////AP///wAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADGxsbGxsbGxsbGxsbGxsbGxcTAuLCJ + oaioqY6wtbjFwsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsW/r6iZh2VdXVlZXl5ml6ScsL/C + xsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbBuJSXgF1VSUlJSUlJSSlJVVVWZpeSuMXGxsbGxsbGxsbG + xsbGxsbGxsbGxsbGxbisl11JVUlJSUkpSUlJKipJSUlJSUleh5K4wcbGxsbGxsbGxsbGxsbGxsbGxsa/ + sJhgLSoqKSlJSUkpKioqKioqKioqSSoqVWOkt7/GxsbGxsbGxsbGxsbGxsbGxr2sgFUpKSkpKSlJSSkp + KSkqKikqKiopKiopSSozgaq/xsbGxsbGxsbGxsbGxsbGuKplKyopKSkpKSkpKSkpKSkpKSkpKSkpKSkp + KSopSWaowMbGxsbGxsbGxsbGxsa4qFgpKSkpJyknJCQpJCQpJCQkJCQkJCQkJCkkJCkpKS1mor3GxsbG + xsbGxsbGxr+kYCQkJCQkJCQkJCQnJCQkJCQfJCQkJCQkJCQkJCQkJCQkYKy9xsbGxsbGxsbGv6ZmKSQm + JiUnJiYmJycnJyQkJycmJiYkJiYmJCQkHyQkJB8kJGSsv8bGxsbGxsbBsIQlJy6FmGQmgZVxHx8fJx8n + H1eMjHMmc5iCKB8fHx8kHx8fHyaBsMbGxsbGxsa4mTMfHzSmqIImhahxHx8fHx8fH3CoqJkuc6iNJR8f + Hx8fH1dlHx8zmbjGxsbGxsWsWB8fH0umqKQ0W6hkHx8fHx8eKI2oqKZXWKiGHx8fHx8fH4GGIB8fW6zF + xsbGxriNIB4eHkCmqKhzMIx8Hh4eHh4eX6eoqKiGMYKYKB4eHh4eV6aFIB4eKJe3xsbGwqxYDSAJDTSm + qKinbkx3MA0NDQ1aoaioqKiod0GCTB4gDR5Alah9DyANDVqSwsbGuJcvCQkgCS+ZqKioqIFcQCEvQHWh + qKioqKioqI1hWi8iMm2gqKhwDQ8NDSKMu8bGsG4JDw8PDw+CqKioqKinloyVpaioqKioqKioqKinooyP + oaioqKhaCQ8PICFzsMW/njwJDw8PDw1hqKioqKioqKioqKioqKioqKioqKioqKioqKioqJ8yCBAJDyBB + qL+4iyEJDwsPCwsyoaioqKioqKioqKioqKioqKioqKioqKioqKioqHcQCBAIDxAij7+1dwsLCwsLDwsL + d6ioqKioqKioqKioqKioqKioqKioo22CqKiopkIICAgIEBAQfbiycAsQCwsLCwsLPKGoqKioqKioqKio + qKioqKioqKiofwhCpqiodhALEAgQChAIe6yqXAsLCwsMDAsLC22oqKioqKioqKioqKioqKioqKiooW5/ + qKifPAoMEAoKCgsKbpanQgsMDAwLDAoKGnaoqKioqKioqKioqKioqKioqKioqKioqKVPCgsMChAKCgwM + T6WnPQwMDAwMDAwXc6ioqKioqKioqKioqKioqKioqKioqKioplwMBwoMDAwMDAwMQqinPQYMBwwMCwZO + p6ioqKaoqKioqKioqKioqKioqKioqKiomW9OGgwMBwwMBwwGTqWnPwYHBwwHBxN+qKiofTprpKioqKio + qKioqKioqKioqKioqKioizkGBwcHBwcGTqmlUwcHBwcHBxygqKh+FwcHOnahqKioqKioqKioqKeVb5+o + f3Z1UxsHBwcHBwcHU6ysbgcRBwcHBzqnqKc+BwcHBxM5a4ifo6inpqOPdlAdE3iobwcHAAcHBwcHBwcH + b7C1fQcRBxERADqmqKAcBwcREQcABxMdOT4+OjgbEQAHBz6lfhMREQcREREHERsajbi4lhcRERERBxyf + qKk5BxERBxEHEREHAAADEQcRBxERERFTdhMREQcRBxERERMdp7/DmjoRERERERJ4qKhsABEREgMRERER + ERERERERERERERISHRERERERERERERE+rMHDsGkBERERAwM7oaijUBIDEgMSAwMRAxERAxERAxERBBER + ERIDAxERERERERJvs8PGuI8dAxIREgMEa6aopnk6AwQDAxIDEgMSAxIDAwQDAxIDEgMSAwMSAxIDAx2Z + uMbGwaxHAwQDBAMEElKWqKifRAMDBAQDBAQEAwQEBAQEBAQDBAQEAwQEBAQDAVCsxcbGxrWIFAQEBAQE + BAM3Z5GojhgCBAQEBAQEBAMEBAQEBAQEBAQEBAMEBAQDFpO3xsbGxsGsUAMEBAQEBAQCA0ampz4BBAQE + BAQEBAQEBAQEBAQEBAQEBAQEBAQBUq/CxsbGxsa3jjYBBAQEBAIBAUOmp0MCAwUDBAQDAwMDAwQEBAQE + BAQEBAQEAgQ3kLjGxsbGxsbCsHQUBAIEAjZnZ46oljYCAgQDBAQDBQUCBQUCAgICBAICAgICBRZ5sMLG + xsbGxsbGv6xsFAICAm+oqKimUgICAgIFBQQCAgIFAgICAgICAgICEgICFG+sxcbGxsbGxsbGxr+mUgIC + AkWOlohHBAICAgIFBQUCAgICAgICAgICAgICAgICZ5+9w8bGxsbGxsbGxsa/n0gCAgUWNQUCAgICAgIC + AgICAgICAgIFBQICAgICAgJSqLjGxsbGxsbGxsbGxsPGuKxpBQIFAgUCAgICAgICAgUCBQICBQUFBQUC + AgUFFmyewMPGxsbGxsbGxsbGxsbGxr2seTcCAgICBQUCAgICAgICAgUFBQUFBQUCAgI3fqzCxsbGxsbG + xsbGxsbGxsbGxsa/sJBIFAICBQUCAgICBQIFAgICBQUFBQICFlGfsL/DxsbGxsbGxsbGxsbGxsbGxsbG + xriokUg1BQUFBQICAgIFBQICBQUFBTVRjrG4wsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbFtayRbEM2BQIB + AgIFAgICBTVIdJGvt8LGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsO/saiWk2xRR0ZGR1Fsi5+osrjF + xsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxb+4tbCsqKenpa6wuMC/xsbGxsbGxsbGxsbGxsbG + xsb//wAA//8AAP/8AAA//wAA//AAAA//AAD/wAAAA/8AAP+AAAAB/wAA/wAAAAD/AAD+AAAAAH8AAPwA + AAAAPwAA+AAAAAAfAADwAAAAAA8AAOAAAAAADwAA4AAAAAAHAADAAAAAAAMAAMAAAAAAAwAAgAAAAAAB + AACAAAAAAAEAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAgAAAAAABAACAAAAAAAEAAMAAAAAAAwAAwAAAAAADAADgAAAAAAcAAOAA + AAAABwAA8AAAAAAPAAD4AAAAAA8AAPwAAAAAPwAA+gAAAAA/AAD/AAAAAP8AAP+AAAAA/wAA/+AAAAP/ + AAD/8AAAD/8AAP/8AAA//wAA//8AAf//AAAoAAAAQAAAAIAAAAABAAgAAAAAAAAQAAAjLgAAIy4AAAAB + AAAAAQAAiT8fAIY8JQCHPS0AiT4kAIg/KgCMQx0AjkUVAJVMDwCVSwwAkEcWAJBHGgCUSxQAkUkZAJhP + EQCfVgYAnVQOAJpSEQCcVhgAikEkAItDLACPSCwAi0Q0AI1HOACPSjoAj0k0AJNNKQCSSyMAkk0zAJFN + OwCeWyMAmlYkAJRSPACbWjUAm1w7AJdWNQCgVwEApFwBAKBYCQCoXwAAoFcIAKNeFwCrYwAAqmULAK1q + EgCpZxkAs2sAALBrDAC4bwAAu3IAALp2DgC5eBkAsG0TAKRkLACqaiYAqm01AK9xIwCucjcAtXgpALF3 + OACVUkQAl1dJAJJPQgCfYkMAnmJNAJ5jVgCmbE0AomdGAKNqWQCsdEoArXleAKhyXACzf1QAsXpIAKlz + ZgCtemoAq3hlAK99cwCxf2gApGtgAMF5AwDDfg4AwX4UALuEOwC6gTQAvYpMALqFRgC6hlQAuolaALWG + bAC6jGkAsoJ1ALKCeAC4i3cAvJJ8AMeHHQDNlDgAyJREAMSUWADAi0QAw5VkAMWYYwDEm3YA1KZcAM6l + bwDMpXkA0699ANy3fgC+lYcAt4qAAMOchgDCnJQAzaqMAMumggDGopMAzKqUAMuqnADHpJgA0K6NANCr + gQDVsoUA2rmKANKznADYuZQA0a+RAMysowDJp6AA07akANK1rgDVuqsA1rqiANe+uQDVu7QA3sGXANzD + rADdw6IA28OzANrDuwDfyr4A5MWRAOPMrADnzKIA4sy1AODMvgDr0qkA6da7ANzGwQDfy8YA4c7EAOHN + yQDl0sEA5NPMAOjXwwDs3MUA6tvLAOXW0QDn2NQA6tzUAOrd2ADt4dYA7uLbAPHjywDx4cYA8efcAPTq + 3gDz5tEA7uDNAO/k4QD07OQA9O7rAPDm4QD38ewA+fPtAPfy8QD59fMA/Pn1AP/+/gD///8A////AP// + /wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP// + /wD///8A/v7+AP7+/gD///8A/f39AP///wD///8A////AP///wD///8A////AP///wAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAM3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3NzcXCury1sq2vr62wsrS9xszLzc3Nzc3Nzc3N + zc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3FvrSor66jo6GPjIyPoaSvr6+ztr7Fy83N + zc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nyb62ra6jimZfXl5eT09PT09eXl9miqSv + rLa+x83Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3JvqivoIpfXjAwMDBPT09PT09PTzAw + MDBeX4qkr7K+zM3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzcu+ta6QZlEwMDAwMDAwMDAwMDAw + MDAwMDAwMDAwXmaYr7TAzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3NzcW8r6BmXlAwMDAvMDAwMDAw + MDAwMDAwMDAwMDAwMDAvMWakrbrFzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Ny8Csq3heTy8wLzAtLS8v + Ly8vLy8vLS0vLy8vLy8wMDAtMDAvUXiussLLzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nyb6voGAwLy0tLS0t + LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLy0xYKSuvsvNzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nx7qvjDItLS0t + LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS1Tj6+6y83Nzc3Nzc3Nzc3Nzc3Nzc3Nyb2veDMp + LS0pLS0pLS0tLS0tKS0tLSktLSktLSktLSktKS0tKS0pLS0pKTGErrrLzc3Nzc3Nzc3Nzc3Nzc3Nyb6u + dy4pKSktKSktKSktKSkpKSkpKS0pKSkpKS0pKS0pKSkpLSkpLSktKSkpLnivus3Nzc3Nzc3Nzc3Nzc3N + y7yveC4pKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkuhK+8y83Nzc3Nzc3N + zc3NzcCvhispKSYmKSkpKSkpJikpKSkpKSkpKSkpKSkkKSkpKSkmKSkpKSkpKSkpKSkpKTONscLNzc3N + zc3Nzc3NzcWymDIkJitnaWlSJGJpaWcrJiYpJCkmKSQpUmlpaWEpU2lpaVMkJCkpKSkkJCkpJikmOaCy + x83Nzc3Nzc3Nzcu2q1IkKSQ5q6+vdyRpr6+YKyYkJiYmJiQkJHivr6+QKmGvr65iJCQkJiYmKSQkKisk + JCRiq73Lzc3Nzc3Nzc2+r2kkJCQkVa6vr4skYa+viyQkJCQkJCQkJCmNr6+vojNSra+qOSQkJCcmJiQk + JGeQKyQkJHevwM3Nzc3Nzc3HspcrIyQkI1Sur6+nOSyir4YkJCQkJCQkJCQ5qq+vr69hKpevpzckJCQk + JCQkIyqXqjckJCQzpLTJzc3Nzc3Nvq5UIycnJw5Ur6+vr3cOdq+QJScnJyQlIyUleq+vr6+vkCVkr6s6 + DiMpJSUlJyNhrqc3IycnI2Svvs3Nzc3NybKNKCUOJycOVa6vr6+qViyQqTUODiUlJSUOV6uvr6+vr69w + KIavYw4OJSUODg44nq+iNQ4OJScsl7LJzc3Nzb6vVw8PDw8PDjqrr6+vr6JWNo1jDw8PDw4PV6evr6+v + r6+vrWg1hYURDw8PDw46l6+vnCwPEA8PD2OvwM3Nzcm0mSgPDw8PEA81n6+vr6+vqm9VVxAPDxE4equv + r6+vr6+vr6+uhVZlNg8PEDVooq+vr40RDxAPDw81pLbLzc3Cr3APEBAQEBAQEZCvr6+vr6+vp411cG+N + p6+vr6+vr6+vr6+vr6+qkHlwb4Wirq+vr697EBAQEBAQEHuvxc3NuqtIDxAQEBAQEBBvr6+vr6+vr6+v + r6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vVw8QEBAQEBBIrb7NzbaVERAQEBAQEBAQVqyvr6+v + r6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vojQQEBANDQ0NHZm2y8Wsbw0NDRANEA0NEB2Z + r6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr4EQEA0NDQ0QEBCBs8fAsFkHCw0NCw0L + EA0LZa+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+un7Cvr6+vr61HBw0NDQ0LDQ0NZa/Cvq82DQsL + EAsHCwsHCzSer6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vch5Xqq+vr6+HEQsLCwsNDQsNDUSuvLSn + NA0LCwsLCwsLCwsLXa6vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr1cIHp6vr6+qRAsLCwsLCwsLCw00 + qbaylQwLCwsLCwsLDAsLCx6Jr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+SR3Kur6+vbwsLDAsLCwsL + DAsMHaS1sIcLCwsLCwsJCwsLDAkLb6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr66vr6+vkx0JCwsL + CwsMCwsLDB6Osq+BDAwMDAwMCQwMDAwMcK6vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vnkIJ + DAwMDAwMDAwMDAwMh7CveQwMDAwMDAwMDAwGWK2vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+v + nkEGDAwMDAwMDAwMDAwMDICur3kKCgoKCgoKCgoGIJyvr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+v + r6+vrn5ZQRoJDAoKCgoKCgoKCgqAr69+CgoKCgoKCgoKBW2vr6+vr5xxlq+vr6+vr6+vr6+vr6+vr6+v + r6+vr6+vr6+vr62TRQwFCgoKCgoKCgoKja+vjQoFBQoFBQoKChmWr6+vr4cgBiByqq+vr6+vr6+vr6+v + r6+vr6+vr6+ur6+vr6+vr5YhBQUKCgoKChIKGpWss5YaEgUFBRIFBQVCqK+vr5YiBQUFBUGAqK+vr6+v + r6+vr6+vr6+vr6ZxXa6vm2VxcVghCgUFBQUFEgUaEhmbtrSdIgUFBQoFBQUARa6vr69YBQUFBQUGEkJt + laivr6+vr6+vr66piF0hBSCmr6g+BQUFBQUFBQUFChIKBQo2q7a6qEIFEgUSBQUFAEuvr6+oPgUFBRIF + EgUFBRlCTWtzgIB+c11FIRoABQUSc6+vTQAFEgUSEgUSBQoKEhISRq+6xa9NGgoSChIFBQVBra+vqCEF + EgUSEgoSChISBgUFBQUKEgUFAAUFBQUSBSGar1gAChIKBQoFBRISGgoSAFivxsWvcxQSEhISEhIFIaav + r61GAxISEhIFEhISEhISBRISEhISEhISEhISEhIFQZZYABISEhISEhISEhIDEgNzs8vJtJQZEhISEhIS + EhKAr6+vcxISEhISEhISEhISEhISEhISEhISEhISEhISEgMiGwMSEhISEhISEhISEhIbo7TNzbqoQgMS + EhISEhISRqyvr6pLAwMSEhISEhISEhISEhISEhISEhISEhISEhISAwMSEhISEhISEhISEhMDRq++zc3F + r2sDAwMSEhIEBBNzr6+vp2wcAxISEhISEgQEAxIDBBIEEhISEgQEEgQSEhISEgQSAxMDEgMTAxIEA3yv + xc3NybaWGwMDBBISEwQBH4ivr6+vlkoTBBICEhISEhIEEhIEEgQEEgQSEgQSBAESEgQDEhMDEgQTAxIE + AyKntsvNzc2+r0oDAwMSEgMSAwMcfK2vr6+taxISEhISAhISEhISEgQSEhISBBISBBISEgQSBBISAwMT + AxIDEgNar8XNzc3NzLCIGAQEBAQEBAQEAxNLgqivr61KAwIEBAQDBAQEBAMEBAMEAgQEAwQEEgQEBAQE + AwQEAwQEBAQblK/Mzc3Nzc26r1oEEwQEBAQEAwQSARM8ka+viBUSAgQEBAQEBAMEBAQEBAQEAwQEBAEE + BAQEBAQEBAQEBAQEWq6+zc3Nzc3Nx7OaHBMEBAQEBAQEBAQEAUmur6YfBAQEBAQEBAQEBAQEBAQEBAQE + BAQEBAQEBAMEBAQEBAMDH5u0yc3Nzc3Nzc3Fr2sEBAQEBAQEBAQEBAFDra+mOwQCAhIEBAQEAgICAgIC + EwIEBAQEBAQEBAQEBAQEBAQCAnSvxc3Nzc3Nzc3NybSoQwECBAICAgICFxc8iK+vkhgTAgICAgICAgIC + AhUCAgICAgICAhMCAgQCBAICAgICAkmstsnNzc3Nzc3Nzc3FrJo7BAIEAgICWp2bpq+vrmwBAgICAgQC + AgICAgICAhUCAgICAgICAgICAgITAgIEAjydssXNzc3Nzc3Nzc3Nzb6ufxUCAgICFZGvr6+vr38WAgIC + EwICAgICAgICAgICAhMCExMCAgICAgICAgICAhyCr8DNzc3Nzc3Nzc3Nzc3Nvq98FQICAgJrrK+upmsX + AgICEwICAhMCAgICAgITAgICAgITAgICEwICAgICAhx8rrzNzc3Nzc3Nzc3Nzc3Nzcm6r3QVAgICFUBJ + STsCAgICAgICAgICAhMCAgICAgICAgICAgICAgICAgIVAh98r7rJzc3Nzc3Nzc3Nzc3Nzc3NybiudBcC + AgICAgICAgICAgICAhMCAgICAgICAgICAgIVAgICEwICAgICAhyDr7jNzc3Nzc3Nzc3Nzc3Nzc3Nzc3J + uq+DOwICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjyCr77Nzc3Nzc3Nzc3Nzc3Nzc3N + zc3Nzcu6r5pOAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICFUqdsL7Nzc3Nzc3Nzc3Nzc3N + zc3Nzc3Nzc3NzcKyqm49AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICPXysssXLzc3Nzc3Nzc3N + zc3Nzc3Nzc3Nzc3Nzc3NxbavtEwWAgICAgICAgICAgICAgICAgICAgICAgICAgIWW5uvtsXNzc3Nzc3N + zc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3LwLSvkkw9AgICAgICAgICAgICAgICAgICAgICAj1blK+0vs3Nzc3N + zc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Juq+upn1DFwICAgICAgICAgICAgICAgIXTn2br7O+yc3N + zc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3LxbKvrpp8TE47PRUCAgICAj07Q2x8mrCwtr7J + zc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Hyb62r6+uqJqRgoN/g5GarK+vsLa+ + xczNzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3NzcXCura1sK+vr6+ytba+ + wsXNzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3///8AAH//////+AAAD//////AAAAD/////wAAAAD////8 + AAAAAH////gAAAAAH///4AAAAAAH///AAAAAAAP//4AAAAAAAf//AAAAAAAA//4AAAAAAAD//AAAAAAA + AD/8AAAAAAAAP/gAAAAAAAAf8AAAAAAAAA/wAAAAAAAAD+AAAAAAAAAH4AAAAAAAAAfAAAAAAAAAA8AA + AAAAAAADgAAAAAAAAAGAAAAAAAAAAYAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAA + AAGAAAAAAAAAAYAAAAAAAAABwAAAAAAAAAPAAAAAAAAAA+AAAAAAAAAH4AAAAAAAAAfwAAAAAAAAD/AA + AAAAAAAP+AAAAAAAAB/8AAAAAAAAP/4AAAAAAAB//gAAAAAAAH//AAAAAAAB//+AAAAAAAP//8AAAAAA + B///8AAAAAAH///4AAAAAB////wAAAAAf////wAAAAD/////wAAAA//////wAAAP//////8AAP///ygA + AACAAAAAAAEAAAEACAAAAAAAAEAAACMuAAAjLgAAAAEAAAABAACJPxwAhzwmAIc9LQCJPiQAiD8qAI5F + FgCNRB0AlUwOAJhPDgCQRxkAlEwUAJFJGQCTSRIAn1YGAJ5VDQCaUhEAmlQYAIpBJACMQysAj0glAItD + MwCOSToAjUc4AJJMJQCRSyoAkU07AJJNNACVUS0Am1cmAJxdPACWVDcAoFcCAKRcAQCgWAgAqF8AAKJd + GwCjXhQAoV0gAKtkAACqZQsAr2gAAKpkCwCqZxcAs2sAALhvAACxbAsAsW8VALtzAAC6dQwAsnIbALh2 + FAClYyQAqWkoAKdqNwCuczsArnEwALN1JAC0eCkAtHk3AK9xKQCVVEUAllZJAJpbSACcX1EAnmJHAJ5j + VQClbEwAomZGAKRqUwCkbFwAoGZYAKxzSQCqc1QArHdcALJ6RwCxfVUAqXNkAK57YgCseW4AqHNnAK99 + cwCwfmgAqHJnAMB3AADCewgAwX8UALuDOgC/gSYAt4JLALyLXAC4hVYAs4NpALeIZwC0hnwAtol5AL2T + fAC9knUAv5BjAMSBGADIiiUAxIs0AM2VOgDQmD0AxJRXAMeTSQDFmWcAxJp4ANamWADToE0Ay6FtAMuk + eQDXrGgA3LV1ANSudgC4jIQAvZOJAL6VhADDnIMAwpuMAMKclADEn5gAyKSJAMajmwDLq50AyaaUANGu + hwDXtYgA1beXAM+wmwDLq6MAzKymAM6xqQDStaMA1bqsANe7qADVu7QA2L6xAOG/iADdwZwA3cSsAN7D + oADawrwA3sm9AN3GswDiwYsA48eaAOLJpgDizLMA4s66AOnVuQDo0a4A3srDAN3JxQDhzcMA4c7KAOXT + wwDk08wA69rFAOvcywDo18MA5dXSAOrd1ADq3doA59nTAPDfwgDu490A7uHUAPLjzADw4McA8ebcAPPq + 3QDx5dQA7uDNAO7k4QDz6+QA9O7qAPLo5AD38esA+fTuAPjx5QD38vAA+fXzAPv59gD///8A////AP// + /wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP// + /wD+/v4A/v7+AP///wD///8A////AP7+/gD///8A////AP///wD///8A+/v7AP///wD///8AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dTNycbGvr66uLi3t7e2tri6vsDCxsnN0dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dPPycK8vri1t7e3t7e3t7e3t7e3t7e3 + t7e3tri8wMPJz9XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXT0cvGvLi3t7e3t7e3t7e3t7e3 + t7a2t7e3t7e3t7e3t7e3t7e6vMbL0dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXRyca6t7e3t7e3t7a2 + s6eVkZBwb2tra2tra29wkJKVq7O2t7e3t7e3t7e8wsnR1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dPNxry3t7e3 + t7e2s5WQb2ZjYlRTU1NTU1NTU1NTU1NTU1RiY2xvkaSztre3t7e3trzGzdXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dPJ + wLi3t7e3t7KokGxjVFNTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTVGNrkKe2t7a3t7e6xsvV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dPJvre3t7e3tZVwZVRTLy9TU1NTL1NTU1MvU1NTL1MvUy9TL1NTU1MvU1NTUy8vYmaJqLK3t7e3 + tr7L09XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dPJvLe3t7e3qpBmVC8vLy8vL1NTLy8vU1MvUy9TLy8vUy9TL1MvU1MvLy9TLy8vUy8v + Ly9ibJGzt7e3t7a+y9PV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXNwLa3t7e2nW9jLCwvLy8vLy8vLy8vLy8vLy8vL1MvLy8vLy8vUy9TLC8v + Ly8vLy8vLy8vLy8sL2Nwp7e3t7e4ws/V1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dPUxra3t7e2lWtVLy8sLy8vLy8sLy8vLCwvLy8vLy8sLy8vLy8v + LywvLC8vLy8vLy8sLy8vLy8vLy8vLyxVb563t7e3uMbT1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXTyby3t7e3qGswLCwvLy8vLy8vLy8vLy8vLC8vLy8v + Ly8vLy8vLy8vLy8vLywvLy8sLy8vLywvLy8vLy8vLy8sVW+rt7e3t77L1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV0cK5t7e3qnAyLysvLy8vLywsLywsLC8v + LC8sLywsLy8sLy8vLywsLCwsLywsLCwsLywvLC8sLC8sLCwsLywvLy8rL2J+s7e3t7jG0dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1cu8t7e3tZFjLCwvLCwvLy8s + Ly8sLCwsLC8sLCwsLCwsLywsLC8sKywsLCwsLCwsLCwsLC8sLC8sLCwsLywvLy8sLy8vKy9llra3t7e+ + zdXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dPJuLe3t6trLCsr + KysvKysrKyssKyssLCwvKyssLCwsKy8rKywvKyssLCwsLCwsLCwsKywrLCsvKyssLCssKysrKyssKysr + LCswb6q3t7e6ydXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXVwre3 + t7aSVysrKysvKysvKysvKysvKyssLCsvKyssKywrKy8rKysvKysrKysrKyssLCwsLCssKyssKysvKysv + KysvKysvLCsvKysrZJa2t7e3xtPV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV0b63t7ezbzArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr + KysrKysrKysrKysrKysrKysrKysrMn61t7e3wtHV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1c++t7e3p2goKygrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysoKysrKysr + KysrKysrKysrKygrKygrKCsrKysrKysrKysrKysrK2eqt7e3wtTV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXNvLe3t5U5KCsrKysrKCsoKysrKCsoKysrKysrKysoKygrKysoKysrKCsr + KysrKygrKCsrKygrKCsrKysoKysrKysrKysoKygrKysrKysoKygrK2Sot7e3vs/V1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXVzbq3t7aSMigoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgo + KCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCsrKCgoKCgoKzmWt7e3vs/V1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV0826t7e2fzAmKCgoKCgoKCgoKCgoKCgoKCgoKCgo + KCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKDKS + t7e3vM/V1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXTvLe3tn4tKCgmJigoKCgoKCIoKCgo + JigoKCgoJigoKCgmKCYoKCYoJigoKCYoJigoJigmJigmKCYoJigoJigmJigmKCgoKCgmKCYoKCYoJigm + KCYoKCgoJi6Kt7e3vtHV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXVzb63t7Z+LSgoKCgoKCYo + KCgoKCgoKCgoJigoKCYoJigmJigoKCgmKCgoJigoKCYoJigoJigoKCgoKCYoKCgoJigoJigoJigoKCgm + KCgoKCYoJigoKCgmKCgoKC6Rt7e3vtHV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dS+t7e3fi0m + JigmJiYmJiYmJigiKCYmKCgiJiYmJigmJiYmJiYmJiYmJiYmJigmJiYmJigmJiYmJiYmJiYmJigmJiYm + JiYmJiYmJiYmJiYoJiYmJiYmJiYoJiYmKC6St7e3wtPV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + wLe3t4otJiYmJiYmJiYmJiYmIiYmIiYmIiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYm + JiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYiJiYmJiYmIjGWt7e3xtXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1ca3t7eTLiYmJiYmJiYmJiYmJiYiJigmIigoIiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYm + JiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJjidt7e4ydXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXLuLe3njkmJiYiJiImIiIiJiIgJiYiIiIiIiIiJiImJiYmIiImIiImJiImIiIm + IiYmJiYiIiImIiIiIiImIiYmIiYiIiIiJiYiIiYiJiImJiImIiYmIiImJiImIiImIiYmIlaqt7e609XV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV0b63t7NWIiImJiYiJi4xMTExMS4mJiIpMTExMTExMSkiIiYmIiYm + IiImIiYmIiImIiIiJi4xMTExMTExJyYiJi4xMTExMTEuJiYiJiImIiImIiImJiYmIiImIiYmIiImJiYm + IGeyt7e809XV1dXV1dXV1dXV1dXV1dXV1dXV1dPAt7e2bSImIiIiIiAxn66qqaqqlS0iIjmnqqqqqqqd + OCIiIiIiIiIiIiYgJiAiIiIiIiIun6qqqqqqqqppIiIpkrCpqaqqqpInIiIiIiYgJiIiIiIiIiIiIiYi + IiIiIiIiIiImJn22t7fD1dXV1dXV1dXV1dXV1dXV1dXV1dXVybe3t38pIiIiIiIgIFa0t7e3t7eqMSAg + ObO3t7e3t58nIiAiIiIiIiIiJiIiIiIiIiIiIjmzt7e3t7e3t34iIimVt7e3t7e3fiAiIiAiIiIgIiIi + IiIgJiYgIiImIiAiIiAiIiYiLZO3t7jL1dXV1dXV1dXV1dXV1dXV1dXV1c+6t7eeOCAgICIiICAgaLa3 + t7e3t7E6ICAuq7e3t7e3fyAiICIiICIgIiAgICIiICAiIiIgOrW3t7e3t7e3iiIgIIq3t7e3t7dnICIi + ICIiIiAiIiIgIiYgICAgICAnOCkgICIgICAiOqq3t7zR1dXV1dXV1dXV1dXV1dXV1dXVwre3tGggICAg + ICAgICBpt7e3t7e3tmcgICKTt7e3t7dtICAgICIgICAgICAgICAgICAgICBpt7e3t7e3t7efJyIgbre3 + t7e3tVYgICAgICAgICAgIiAgICAgICAgJ4qzfikgICAgICIgaba3t8bV1dXV1dXV1dXV1dXV1dXV1cu2 + t7d/JiAgIiAiICAiIG23t7e3t7e3fiAgIHG3t7e3t2cfICAgICAgIiAgIiAiICAiICIgIIq3t7e3t7e3 + t7M5ICBYtbe3t7ezOSAgIiAgICIgICAgICAgICAgICA5sreuMR8gICAgICApkre3us3V1dXV1dXV1dXV + 1dXV1dXVvre3qzENDSYgICAgIB8fcbe3t7e3t7edKiAfVrS3t7e2Zx8gICAgICAgICAgICAgICAgICAq + q7e3t7e3t7e3t2kgHyqst7e3t644Hx8gICAmDSYNJiAgICAgICAgH223t644ICAgICAgICBWs7e3wNPV + 1dXV1dXV1dXV1dXV1cm2t7ZpDSAgICAgIB8gIB99t7e3t7e3t7VnHx8plbe3t7ZnDSAgICAgIA0NICAN + ICAfDSAgH2e2t7e3t7e3t7e3lSofH263t7e3szkfIB8gIA0NICAgDSAgIA0gIB8pn7e3sTgNICANICAg + ICB9t7e4ydXV1dXV1dXV1dXV1dXRvLe2lSoNDSANDSAgICAfH323t7e3t7e3t5MpHx9ntre3t20NHyEg + ICAfICAgICAgICAgICAqn7e3t7e3t7e3t7e2Zx8fO6m3t7e0Oh8gICAgKQ0NDQ0gDQ0gICAfIGG1t7ev + OQ0gIB8NISEgIDumt7e+09XV1dXV1dXV1dXV1ca3t7ZaDSkNKQ0NIA0NICAffbe3t7e3t7e3tmkNHyGS + t7e2fw0hISEhIQ0hIQ0NDQ0NIQ0hDW23t7e3t7e3t7e3t7edKiAgbre3t7dnDSAhDQ0pDSANIA0gDQ0g + IQ0qnre3t647DSENIA0hISEhH2m2t7fR1dXV1dXV1dXV1dXUvLe3kykNISENDQ4NDQ4NIQ1ut7e3t7e3 + t7e3qTcNDTapt7efJA0hISEhISENDSEhISENDQ06sLe3t7e3t7e3t7e3t7d+IQ0qk7e3t30NISENDSEh + ISEhISENDQ0NIX63t7e3rjQNISEhISEhISENKp63t8DT1dXV1dXV1dXV1c23t7VaDQ0hDg4ODg0NDiQO + DW23t7e3t7e3t7e3lTMNDVmzt7E6DQ4NDQ4ODQ4NDg4hDg0NNJ23t7e3t7e3t7e3t7e3t7RpDQ03nre3 + nSoODg4OIQ4kDg4hDQ0NDg1ptLe3t7emKg0NDg0OISEODiENabe3tsvV1dXV1dXV1dXTvre3lCQODg4O + Dg4ODg4ODg4NWba3t7e3t7e3t7e3izMNDmmxt24NDg4ODg4ODg4kDg4ODTSUt7e3t7e3t7e3t7e3t7e3 + t7FpDg1Kobe1WA0ODg4ODg4ODg4ODg4OabW3t7e3t50qDg4ODg4ODg4OIQ0zobe3wNXV1dXV1dXV1cu2 + t7ZhDg8ODg4ODg4ODg4ODg5YtLe3t7e3t7e3t7e3lDYODlmpoTMODg8ODg4ODg4ODg5Kn7e3t7e3t7e3 + t7e3t7e3t7e3t7FuEA02lLeGDg4ODg4ODg4ODiQOEG64t7e3t7e3jw4PDw4ODg4ODg4PDw5ut7e4z9XV + 1dXV1dXVwre3njMODg4ODg8ODg4ODg4OCDSut7e3t7e3t7e3t7e3pWkjCDaLag4PDg8OEA4PDggqbqq3 + t7e3t7e3t7e3t7e3t7e3t7e3t7aLNg4zfqlYDg4PDg4ODg4ODjaLtre3t7e3t7d/Dg4ODg4ODyEhECEQ + DzWwt7fG1dXV1dXV1c+6t7d5Dg8PDg4PDg8QDhAPDg4PJZ63t7e3t7e3t7e3t7e3tpRZKiQ2EA4ODw4O + CA4zYZu2t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7eufTYQSlkPDw4ICA4IEDZ/rre3t7e3t7e3t2oIDxAO + EA4PDw8PIQ8hJH+3t7zV1dXV1dXVybe3rzYODg4QDg8PDw8ODhAQCA4Qhre3t7e3t7e3t7e3t7e3t7ah + f1k2NDMzNDZhgKa2t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3sZNqWDUzMzQ3WG6Pube3t7e3t7e3 + t7e1WA4PDhAODg8PECEQIQ8IWLa3t8vV1dXV1dO+t7eSEA8QDw8PDw8PDw8PDg8PDg5ut7e3t7e3t7e3 + t7e3t7e3t7e3trGupaWuuLe3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e1r6mlpbG2t7e3 + t7e3t7e3t7e3t6k0Dw8QDhAPDw8PDw8PDw8lnre3wtXV1dXVz7i3t2kODw8PDw8PDw8PDw8PDw8PCEq1 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3jhAPDw8PDw8PDw8PDw8PDwh5t7e80dXV1dXJt7euNQgPDw8PDw8ODw8P + Dw8PDw8IJaa3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7duDw8PDw8PDw8PDw8PDw8PCEq1t7bL1dXV1cC3t48QDw8P + Dw8PDwoPDw8IDw8IDw8PhLe3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3skoHDw8IDw8PDw8PDw8PDw8IJZ63t8PV1dXR + ure3agcPCA8KDwoPCg4PDwoPDwoPDwdatre3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7ebEAgPDwoPDw8IDwoICAgPDw8K + gLe3vtPV1cu2t7JKBw8PDw8PDw8KDw8PDw8PDw8PCjOmt7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t3kIDw8IDwoPDw8P + Dw8KDw8PDwhht7e4z9XVxre3phwKDwoKCgoPCgoPDwoKCgoKDwoKCnm3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7euNQoK + CAoPCg8KCgoPCggKCAoKCjWut7fJ1dXCt7eLCgoPDwgOCggPCgoHDgoODwoKDw8HR6+3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t4YPDw8KDwoPDwoPDwgPCg8PCggPEJu3t8bV0b63t2oHCgoKCgoKCgoOCgoKCgoICg8KCg8KjLe3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7amlK23 + t7e3t7e3t7e3t7e0SwcICgoICg8KCgoKCgoKDwoKDwoKgLe3wNXPure2WgcICgoKCAcPCgoICAoICggK + CAoKDwdHsre3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e1eRwQNYu3t7e3t7e3t7e3t48QBwgKCAoKCAgKCAgKCAoICggKCgdqt7e+0cm3t7E1DAoKCAoKCgoK + BwoKCgcKCgoKDwoKCgqEt7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t48KCgoHNaW3t7e3t7e3t7eySwcKCgoPCgoKCgoKCgoKCggKCgoMDEq3t7vNxre3oRwK + CgoPCgoKCgoKCgoKCgoPCgoKDwoKCkevt7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3bgwKCgoKjre3t7e3t7e3t4YKCgoKCgoKCAoKCgoKDwoKCggKCgoMNbC3 + tsnCt7eUEAoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCnm3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7eADAoKChyjt7e3t7e3t7ewNQwKCgoKCgoKCgoKCgoKCgoK + CgoKCgwcobe3xr63t38KDAoKCgoMCgoKCgoKCgwKCgwKCgwKCgoKHJy3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7BHDAcKara3t7e3t7e3tmoMCgwKCgoLCwoK + CgoMCgoKCgoKCwoKCgqUt7fCvLe3eQwKCgwLCgoKCgoKCgsKCgoKCgsKCgsKCgoMS7G3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t6qAX4a1t7e3t7e3t7ePHAsK + CgoLCgoKCgoKCgoKCgsKCgoKCgoKCoa3t764t7dgDAoLDAwMCwwLCgwKDAwLDAsKDAoMCwwMCgwLhre3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3pTUMDAsMDAwLDAsKCgoKCgwKCgoKDAsKCgoLfLe3vLe3t1wMBQsLDAsLDAsLDAsMCwsMCwsMCwsL + DAsLCmCut7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7hbDAsMDAsLCwsMCwoFCgsMCwULCgULCwoFBQx1t7e6t7e2SwULCwsLCwsMCwsLCwsL + CwwLCwsLCwsLCwp1tLe3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e2eQsMCwsMCwsLCwwLCwsLCwwLCwsLBQwLCgsLDF+3t7i3t7ZLBQsLCwsL + CwsLCwsLCwsLCwsLCwsLCwsLX7W3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t4ALCwsLCwsLCwsLCwsKCwsLCwsLCwsLCwsLCwsMXLe3uLe3 + tUIFCwsLCwsLCwsLCwsLCwsLCwsLCwsJBVqxt7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7eGFwsLCwsLCwsLCwsKCwsLCwsLCwsLCwsKCwsL + CQVctre3t7e0RwwFCwsLBQsLCwULCwsFCwsLBQsLCQU1ore3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3hhsFCwsLCwsLCwUFCwUJCQkFCwsF + CwsFCwUJCQkJBVu3t7e3t7RCBQkJCQkJCQkJCQkJCwsJCQsLCQkLCYS3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3toQbCwsFBQkJCwkJCwsL + CwkJCwkJCQkJCwsLCwkJCQUFW7e3t7e3tEgFBgkJCQkJBgYJCQYJCQkGBgkJCQVJtLe3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e0mY6PhF9C + FwUJBgsFBQYGBQsJBgsJCQkGBgkJBgUJBQVbt7e3t7e2SAUJBgkGCQkJCQkJCQYJCQkJCQYJCYi3t7e3 + t7e3t7e3t7elmbW3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7SZXBcFBQkGCwsGBgYJBQkJCQYGBQUJCQUFBVy3t7a3t7ZLBQkJCQkJBgkJBgYJCwkFBgYJ + CQVCsbe3t7e3t7e3t7exfB0Xda+3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3jUIJCwsFBgsJCQkGCQYJCQkGCwYJBgUFX7e3uLe3t1sFBgYGCQkGBgYG + CQYGBgYGBgYGBXa3t7e3t7e3t7e3okkGBQUGQpe3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3rkkGBgkGBgYGBgkGCRMJBgYGBgYGBgV1t7e6uLe3XwUG + BhMGBgYJCRMGBgYGBgYGBgYYm7e3t7e3t7e3t6BDBQYGBgYFG2qlt7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3tbW3t7e3t7e3t7e3t7e3t7WOSAYGCQYGBgkGBgYGBgYGCQYJBgYGBXy3 + t7y6t7d5BgYGBgkGBgYGBgYGBgYGBgkGBkOvt7e3t7e3t7etQgUJBgYGBgYGBh18sLe3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3tpxbhbe3t7e3hYWir7GvpZd8RBcFBgYGBgYTCQkGBhMJBgYG + BhMGBgYGhbe3vr63t4QGBgYRBgYTBgYGBgYGBgYGBgYGTba3t7e3t7e3tmAFERMGBhMGBgYGBgZDfKW2 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3tZdbGwVft7e3t7eEExsdQ0AeFwYGBgYGEwYGBgYG + EwYGBgYGBgYGBgYGExeNt7fCwre3jRMGEQYGBgYGEQYTBgYGBgYGBgZft7e3t7e3t7ecGAYGBgYGBgYG + BgYRBgYGHV6Xsbe3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e2pYJIGAYGBkK0t7e3t7AdBgYABgYRBgYG + BgYGBhEGBgYGBgYGCQYGBgYGEQYGG6O3t8bGt7ejGwYGBhMGBgYGBgYGBgYGBgYGBna3t7e3t7e3t3UG + BgYRBgYGEQYGBgYGBgYGABdCdI6ttre3t7e3t7e3t7e3t7e3t7e3t7SihFseBgYGBgYGGJu3t7e3tk0G + BgYGBgYGBgYRBgYGBgYGBhEGBgYREQYRBgYGBgYdrre3ycm2t69ABgYGEQYRBgYRBgYREQYREQYGfLe3 + t7e3t7e1SAYREQYGBhERBhEGBhEGBhERBgYAER1NdoWcpbG1tre3tra1tK+ijnteRBsGAAYGEQYRBgYG + Xre3t7e3fAYGBhEGBgYGEQYREQYGBgYRBhEGBhEGBgYGEQYGBki2t7jNz7q3tkkABgYGBgYGBgYGEQYG + BgYGBgB2t7e3t7e3t68+BgYGBhEGBgYGBgYGBgYRBgYGBgYRBgYGERgeQERJTVFRTUlCHRsRBgYGBgYG + EQYGBgYGEQYbnLe3t7eFEwYGBgYGEQYRBgYGBgYRBhEGBgYRBgYGEQYRBhEGXre3vNHTvLe3dAAGBgYR + BhEGBgYGBgYGBgYRAF+3t7e3t7e3rx0AEREGBhEGBgYREQYGBgYGBgYGBhEGBgYRBgYGBgAAAAAAAAYG + BhMGEQYRBgYGEQYGEREGBgBNuLe3t44REREGBgYRBgYGEQYGBhEGBgYRCREJEREGBgYGBgZ7t7e+09XA + t7eFEREREREGEREREREREREREREATba3t7e3t7exQwAREREREQYREQYRAxEREREREREGEQYDEREGEREG + EQYREREJEQYREQYRBhERAxEGAxEGERERERF2tre3jREGEQYREREGERERBhEREQYREREREQkREQYRERER + GJm3t8bV1ca3t6IbBhERBhEGBgYGEQYRBhEGEQBAr7e3t7e3t7ZNABEGBhEGEREGEQYGBgYRBhEGEQYR + EQYRBhEGBgYGERERAwkGEQYREQYRBhEGBgYRBhEGBgYRBhF8treFExEGBhEGBgYRBgYGEQYGBhEGBhER + EREGEQYREQY+r7e3ydXVy7a3tEQGERERBhEREREREQYRERERBhict7e3t7e3t3wGEQYREREGEREGERER + ERERBhEREREGERERBhERERERERMDEQMREREGERERBhERERERBhEREREGERh0sXsGERERERERERERERER + ERERERERERERCREREREGAFG2t7rR1dXRure3dQMREREREREREREREREREREDA3y3t7e3t7e3nBoREQMT + EREREREREREREREREREREREREREREREREREDExERERERERMDAwMTAxMRERERERERERERERFFRBERERER + ERERERERERERERERERERERERERERERERgbe3vNPV1dXAt7eIEhEREREREREREREREREREREDRK+3t7e3 + t7e2XgMRERERERERERERERERERERERERERERERERERERERERERERERERAwMTAxMDAwMRERERERERERER + ERERERERERERERERERERERERERERERERERERERERERqjt7fG1dXV1cm3t7A+AxERAxERERERERERERER + ERERhbe3t7e3t7eiPhEDEhERERERERERERERERIDERERERERERIREREREREDEREREREREREREQMSERER + AxEREREREREREREREREREQQSERERERERAxIDEhEREREREhERERERRLS3t8vV1dXVzbi3t14AERESERES + EREREREREREREQNEr7e3t7e3t7eNHgMREREREREREREREREREREDEhERERERERERERERERIRERIDERES + AxERERERERESERESAxERERERERERERERERERERIDERERERERERERERERERERERF3t7e40dXV1dXVvre3 + hwQEEREEAxIDEQQRAwQSAxIDERF6t7e3t7e3t7eZRAQDAxERBAQEEREDEgMRAwMRAxIDERIDEQMDBBES + EgMRAxEDAwMSAwMRAxEDEQMSEQMRAxERAxEDERESEQISAhIDEQMREQMRAxIDAwMRAxIRAwMDGpy3t8DV + 1dXV1dXJt7evPgMDERERAwMREQMSAwMRAxEEBBqXt7e3t7e3t7ewdjwDARESEREEBBEDEQMSERIDAwMR + AxEDEhERAwMDEQMSAxIREgMSERIDEhESAwMDEgMSAxIEEhERAwMRERERAxEDEgQRAxESAwMSAxEDERER + EgNJtbe20dXV1dXV1c+6t7d2BBERBBEEEQQDEhEEEQQSBBERA0Cjt7e3t7e3t7e3onYeAREEEQQRBBID + AxIEAwMSEQQEBBEEEQQRBBEEEQQRBAMDBAMEAxIDBBEDEhEEEQQEBAQRBBERBBECEQISBBIEEQQRBAMS + EQQEEQMSAxIDA4G3t77T1dXV1dXV1cK3t5waBAQRBBEEERIDBBEEEQMEBBEEBESit7e3t7e3t7e3t5xM + BBEEEQQRAxIDBAQSBBEEEQQSBBEEERIDBBEEEQQREgMSEgMSAwQRBBIDBBEEEREEEQQRBAQREREREQQD + EQQEEQQRBBEEEQQSBAQEBAM+rbe3w9XV1dXV1dXVy7e3tlsEERERBBERBBERAxIRBBESAwMSBESat7e3 + t7e3t7e3t69eEhEREREDEgMEEhIRBBIDAxISBBIEEQMSEQMSAxIDEhESBBIDEQMSBBIDEgMSEQQDEgQR + EQQREREREREREQQSAxIDEhEEAxIDEgMDA3a3t7jP1dXV1dXV1dXTvLe3jRQEBAMEBAQEAwQEAwQEAwME + BAQDAxl7tLe3t7e3t7e3t7VyAgISAQQEBAQDAwQEAwQEBAMEAwQEBAQDBAQDBAMEAwMDBAQEBAQDBAQE + AwQDBAQDBAMEBBIBAgIRAhECBAQEBAQDBAQDBAQEAwQZo7e3wNXV1dXV1dXV1dXJt7e1TAMEEQIEBAQE + AwQEBAQEAwQEAwQDBARMjbS3t7e3t7e3t69SAQESBAMEAwMDBAQDBAQDBAMDBAQEBAQDBAQEBAMEBAQD + BAMEBAQDAwQEBAMEAwQEBAMEAhECEQERAhEDAwMEBAMDBAMDBAQEA163t7fL1dXV1dXV1dXV1dG8t7eI + EgQCEQQEAwQEBAQDAwQDBAQDAwMEBAESRYGitre3t7e3t5gVAhEEAwQDAwQEAwMEBAMDAwMDAwMDEgQE + AwMEBAQDBAMEBAMDAwMEBAMDBAMSBAMEBAQRAhECEQIRAgMDBAQDBAMDBAQDAwQanLe3vtPV1dXV1dXV + 1dXV1cm3t7VOARESAhEEAwQDAwMEBAQDBAMEAwQDBAQDAxlbore3t7e3tlsBEQMEBBIDAwMDBBIDAwQE + AwMEAwMEBAMEBAMEBAMEAwMEBAMEEgMDBAQEAwQEAwQEAxECEQICAhEBBAMEAwMEAwQDBAMEAV23t7fJ + 1dXV1dXV1dXV1dXV0by3t5cWAQIRAgQEBAQEEgQEBAQEBAQEBAQEBAQEBAFGsLe3t7e3hxIRBAQEBAQE + BAQEBAQEBAQEBAQEBAQEBAQEBAMEBAQEBAQEBAQEBAQEBAQEBAQDBAQEAhECEQQRBAQEBAQEBAQEBAQE + BAMZo7e3vtPV1dXV1dXV1dXV1dXVybe3tl4BEQIRBAQEBAQEBAQEBAQEBAQEBAQEBAMCEgF6t7e3t7ej + FQEEBAQEBAMEBAQEBAQDBAQEBAQEBAMEBAQEBAMEBAQEBAQDBAQDBAQEAwQEBAQEBAQRAhECBAQEBAQE + BAQEBAQEBAQEAne3t7nJ1dXV1dXV1dXV1dXV1dXRvLe3ojwBEQIDBAQEAwQDBAQEAwQDBAQEAwQEBAIR + AU+2t7e3t7A8AgQEAwQEBAQEBAQEBAQEBAMEAwQEBAQEAwQEBAQEAwQEBAQEBAQEBAMEBAQDBAQDBBER + AhEEBAQEAwQEBAMEAwQEBAREsLe3wNXV1dXV1dXV1dXV1dXV1dXLuLe3exIBAgICAhECEQERAgEBBAQE + BAQBAhICEQIBUra3t7e3rjwBAgEBBAQEBAQCBAQEBAQEBAICAgICAgICAgICAgQEBAQCBAQEBAQEBAQE + BAQEBAQEAgEEBAQEBAQEBAQEBAQEBAQEFIe3t7jN1dXV1dXV1dXV1dXV1dXV1dXCt7e0TwEREQICAgIR + AgICAgQEAQQEBAIBAgICAgFzt7e3t7eiGQECAgQEBAQEBAQCBAQEBAQEAgICAgICAgIRAhECBAQEBAQC + BAQSBAQEEgQEBBIEBAQCAgQBBAQEBAQEBAQEBAQEBARdtre3w9XV1dXV1dXV1dXV1dXV1dXV1c+6t7ec + PAICAgIRAgICAgICAgIEAgICEgICAgICPqK3t7e3t40SAgICAgICAgIEAgQCBAICAgICAgICAgICAgIC + AhIEBAIEAgQCAgIEAgICAgICAgICBAICBAICBAICAgQCAgICAgIEP623t7zR1dXV1dXV1dXV1dXV1dXV + 1dXV1cm3t7eBFAICAgICEgICAgICAgICBAQUGRQSFEWat7e3t7e3cwICAgICAgQEAgIEAgQCAgQEAgIC + AgICAgICEQICAgIEBAIEAgICBAIEAgICBAICBAQCAgICAgICAgQEAgICAgQCBBaHt7e4y9XV1dXV1dXV + 1dXV1dXV1dXV1dXV08C3t7ZeAhICAgICBAQEAgICAgQETI2il4eYsbe3t7e3t7A+AgICAgICAgIEBAIC + AgQCEgICAgICAgICAgICAgISAgQCAgICAgICEgICFAIEAgICBAICBAQCBAQCAgQCBAICAgIEd7e3t8bV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXVz7i3t69BAgISAhIEAhICBAQEBEG5t7e3t7e3t7e3t7e3eAICAgIC + EgICBAQEAgICAgIEBAICAhQCAgICAgICAgICBAIEBAIUAgQCAgQCBAIEBAICEgQCAgIEBBICAgQCBAIE + BE60t7e+09XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV0bi3t5w8AgICAhICAgICAgICc7e3t7e3t7e3t7e3 + t5gVAgICAhQCAgICFAICAgISAgICAgICAgICAgIUAgICAgICAgICAgICAgICAgICBAICAgICBBQCAgQC + AgIEAgQCAgRGrbe3us3V1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXVxre3t40VAgICAgICAgICFAJ6t7e3 + t7e3t7e3t7ecPgIRAgICAhQEBAICAgICAgQCAgISAgICAgICAgICAhQCAgICAgICAgICAgICAgQCBAIC + AgICAgICFAICAgIEAgICPZq3t7fJ1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXTwre3t4MWAgICAgIC + AgICAk62t7e3t7e3t7e4hz0CAgICAgIUAgIUAgICFAICAhICAgICAgICAgICFAIUAgICEgICAgICAgIC + AhQUAgQCBAICAgIUAgICEQICAgICAjyHt7e3w9XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXRvre3 + tnoUAgICBAQCAgICFHivt7e3t7e0mF0WAgICAgICAgICAgICAgICAgIUAgICAgICAgICAgICAgICAgIC + EgICAgICAgICAgICAgQCAgICAgICAgICAgICAgIVg7e3t8DT1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXPvLe3tngUAgIUAgICAgICFEFdc4F6XUEUAgICAgIUAgICAgIUAgICAgICAgICAgICAgICAgIC + AgICAgICAhICAgICAgICAgICAgIEAgICAgICAgIUAhICFAICFYO3t7e+0dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXNure3tngUBAICAhQCAgICBAEBAgICAgICAgICAgICAhQCAgICEgICAhQCAgIU + AgICAgICAgIUAhQCAgICAgICAgICAgICFAICBAIUAgICAhQCAgICAgICAhWDt7e3vtHV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXNure3tnoUAgICAgICAgIUAgICAgICAgIUAgICAgICAgICAgIC + FAICAgICAgIUAgICAgICFAICAgICFAICAgICAhQCAhQCAgICAgICAgICAgICAgICAgQVhbe3t7zP1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXLure3toM8AgICAgICAgICAgICAgICAgICAhQC + AgICAgICAgICAgICAgICAgQCAhQCAgICAgICAgIEAgICAgICAgICAgICAgICAgICAgICAgICAgICPI23 + t7e8z9XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXNvLe3t409AgICAgICAgICAgIC + AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAhQCAgIC + AgICAkGYt7e3vs/V1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXTure3t6NFAgIC + AgICAgICAgICAgICAgICFAICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC + AgICAgICAgICAgJOure3t77P1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXP + vre3t69yAgICAgICAgICAgICAgICAgICAgICAgICFAICAgICAgICAgICFAICAgICFAICAgICAgIUAgIC + AgICAgICAgICAgICAgICAgIWd7G3t7fA0dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXRwre3t7aDPAICAgICAgICAgICAgICAgICAgICAgICAgIUAgICFAICAgICAgIUAgICAgIU + AgICAgICAgICAgICAgICAgICAgICAgICP4e3t7e4xtPV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXVxri3t7eiThQCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC + AgICAgICAgICAgICAgICAhQCAgICAgICAgIUAgICFl2tt7e3usnV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXVzb63t7e1gz8CAgIUAgICAgICAgICAgICAgICAgICAgIC + AgICFAICAgICAgICAgICAgICAgICFAICAgICAgICAgICAgICAkGHtre3t77N1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV0cK3t7e3unIVAgICAgICAgICFAICAgIC + AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIUAgICAgICAgICAjxzube3t7jG0dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV08m8t7e4uLxQFgICAgIC + AgICAgICAgICAgICAhQCAgIUAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICARVyo7e3t7e8y9PV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dHCtre3 + t7eYUBYCAgICAgICAgICAgICAgICAgICAgICAgICAgIUAgICAgICAgICAgICAhQCAgICAgICAjxdoLe3 + t7e4w9HV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXLxLe3t7e2ml09AgICAhQCAgICAgICAgICAhQCAgICAhQCAgICAgICFAICAgICAgICAgICAgIC + Aj1yoLa3t7e3xs3V1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXRyby3t7e3t6J6RhYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC + AgICAgICFlKCure3t7e3vsnT1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1cm+t7e3t7e0mHM/FAICAgICAgICAgICAgICAgICAgICAgIC + AgICAgICAgICAgIWQXectba2t7e2vsnV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dPJvri3t7e3t6+Yd1I9AgICAQICAgICAgIC + AgICAgICAgICAgICAgICFDxOepq0t7e3t7e4wM3T1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXVzcK6t7e3t7e3tq2YeF1B + PBYWAgICAgICAgICAgICAgICFj1GXYGYsLe3t7e3t7e+xs3V1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dHJwLq3 + t7e3t7e3t7WwoL6CeHJdUE5PT05QXXN4go2ir7W3t7e3t7e3t77AydHV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXT0cnCvLa3t7e3t7e3tbW4uLe3t7a2t7e3t7e3t7e3t7e3t7e3vMbJ0dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXTzcnCvrq4t7e2tbe3t7e3t7e3t7e3t7e3t7e4ur7Gzc3T1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXT0c3Jxsa/ubm3t7e3t7e3uLq+vsDGzc3R1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1f////////AAAA////// + //////////4AAAAA///////////////gAAAAAA//////////////gAAAAAAB/////////////AAAAAAA + AH////////////AAAAAAAAAf///////////AAAAAAAAAA///////////AAAAAAAAAAD//////////gAA + AAAAAAAAf/////////AAAAAAAAAAAB/////////gAAAAAAAAAAAP////////wAAAAAAAAAAAA/////// + /4AAAAAAAAAAAAH///////4AAAAAAAAAAAAA///////+AAAAAAAAAAAAAD//////+AAAAAAAAAAAAAAf + //////AAAAAAAAAAAAAAD//////gAAAAAAAAAAAAAAf/////wAAAAAAAAAAAAAAD/////wAAAAAAAAAA + AAAAAf////8AAAAAAAAAAAAAAAD////+AAAAAAAAAAAAAAAAf////AAAAAAAAAAAAAAAAD////wAAAAA + AAAAAAAAAAA////4AAAAAAAAAAAAAAAAH///8AAAAAAAAAAAAAAAAA///+AAAAAAAAAAAAAAAAAH///A + AAAAAAAAAAAAAAAAB///wAAAAAAAAAAAAAAAAAP//4AAAAAAAAAAAAAAAAAB//+AAAAAAAAAAAAAAAAA + Af//AAAAAAAAAAAAAAAAAAD//wAAAAAAAAAAAAAAAAAAf/4AAAAAAAAAAAAAAAAAAH/8AAAAAAAAAAAA + AAAAAAA//AAAAAAAAAAAAAAAAAAAP/gAAAAAAAAAAAAAAAAAAB/4AAAAAAAAAAAAAAAAAAAf8AAAAAAA + AAAAAAAAAAAAH/AAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAP4AAAAAAAAAAAAAAAAAAAD+AA + AAAAAAAAAAAAAAAAAAfAAAAAAAAAAAAAAAAAAAAHwAAAAAAAAAAAAAAAAAAAA8AAAAAAAAAAAAAAAAAA + AAPAAAAAAAAAAAAAAAAAAAADgAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAA + AAAAAAABgAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAA + AAAAAAABgAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAAAAPAAAAAAAAAAAAAAAAAAAADwAAAAAAA + AAAAAAAAAAAAA+AAAAAAAAAAAAAAAAAAAAfgAAAAAAAAAAAAAAAAAAAH4AAAAAAAAAAAAAAAAAAAB/AA + AAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAH/gAAAAAAAAAAAAAAAAA + AB/4AAAAAAAAAAAAAAAAAAAf/AAAAAAAAAAAAAAAAAAAP/wAAAAAAAAAAAAAAAAAAD/+AAAAAAAAAAAA + AAAAAAB//gAAAAAAAAAAAAAAAAAA//8AAAAAAAAAAAAAAAAAAP//gAAAAAAAAAAAAAAAAAH//4AAAAAA + AAAAAAAAAAAB///AAAAAAAAAAAAAAAAAA///wAAAAAAAAAAAAAAAAAf//+AAAAAAAAAAAAAAAAAH///w + AAAAAAAAAAAAAAAAD///+AAAAAAAAAAAAAAAAB////gAAAAAAAAAAAAAAAA////8AAAAAAAAAAAAAAAA + P////gAAAAAAAAAAAAAAAH////8AAAAAAAAAAAAAAAD/////gAAAAAAAAAAAAAAB/////8AAAAAAAAAA + AAAAA//////gAAAAAAAAAAAAAAf/////8AAAAAAAAAAAAAAP//////gAAAAAAAAAAAAAH//////8AAAA + AAAAAAAAAD///////wAAAAAAAAAAAAD///////+AAAAAAAAAAAAB////////wAAAAAAAAAAAA/////// + /+AAAAAAAAAAAAf////////4AAAAAAAAAAAf/////////gAAAAAAAAAAf/////////8AAAAAAAAAAP// + ////////4AAAAAAAAAf///////////AAAAAAAAAP///////////+AAAAAAAAf////////////4AAAAAA + Af/////////////gAAAAAA///////////////gAAAAB////////////////gAAAP////////iVBORw0K + GgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAACAAElEQVR42u29d7jlRnkH/BtJp91e9m7vfddbve5e + l7XXgDFumBJKsI0hhA8IxaR8CQTzQUgoCZBAgGCwKYYEMLhQjNuu7XX3Nm/v9W67e/s991Rpvj+k0RnN + mZF0yt3m83ue8+hIGk15523zzmhEKKWo4axAO4BuALAsawYAaJp2jFJ6KSFkKqV0PyHkKgBLALQ4v1YA + GBhMT2hqjJdSVnJgMF3f1BjvBLDPubYdwDEuzQZKaT+ldJ+maX2sbjWcXSA1BXBGo92yrBZCyDQAIISk + KKUfJYRMATANwAQAnWUIeDVwcmAwPcpREr0A+gCsppT2E0L2Adjv/GqK4QxGTQGcQbAsa4ZjTW8FsBjA + VABLBwbTEyIxA4mocbqrWAqYYtgPYAOAAwDWo6YUzijUFMBphCPwS2C77UsATB0YTC84Ddb8VKETQC+l + dCNspbCBELIeNYVw2lBTAKcW7ZTSpXAE3nHllwKoLzfDVDbv8QwGBtPu/0zOREdb2VkHlgsg0Cth6RjE + ujY1xjdTSjcSQlaj5iGcctQUwMijHcDV7FdtCy8K4qlSAKzschWAQoGwoONqAN9yrtWUwQiipgBGAMy1 + p5TeSghZDDtgNyKSyAQpl7GPmZyJVCqLyRNaNz/30p4FADAwlMHgcBZ5J+1Q1oSZznnyaW6ylZLhCGRj + XRQtzQkkElE01kURixlIJKKIRXREYgZymTyaGuPJoHaJCkCESoE43sEa2IHFZ2pDhZFBTQFUEZTSlYSQ + m2Fb+6oL/VAqi1Qqh2MnBtDXN4zOE4M4cbQPh08MYiCZQX/3EDLZPPr7U+jpGy563rSC+1rXCEyLQtcI + jIiOfM5EW0sdAKC5OYFY1EBbRxPGjqpHc30Mo8e1YNqkNrQ1J9A2qgF18YhHqMtVADw4ZfAPlNJETRlU + DzUFUDmWAYgD+DcAy8vNROIqJ3ft7ao/dmIABw73Yt/Bbuzc04W+gRT6+1MYHEiVJNCl3PN7RpYWANpa + 6tDcnMDocS2YNakN48c2Y/r0Dkyf0o6GhpjYtkpp/h1K6cOEkCcrzeiNjpoCKBOU0pUA7hgcyryv0jF9 + KpvH0FAGh470YceOY9h94CS2bjuKE122Zc9k1FY0rLAyQWXwe4b3AsR04jU/JWJEdIwd24wJE1oxYXQj + zl80CbOnd2DW9I7AoUNI1IYIFaKmAEqAM7ZfAeB2AHMBjCo3r4HBNHYf6MaOHcewZu0BHO3swaEjfcjn + zNDWFwinAPwEuVQvIMij4CFL19JSh/HjW3De7DGuQpg4sbVSr+AkgPsppX+uKYLSUFMA4bAMwB2wp+/K + dvMPH+vH9j0nsHHDIby24SBOdA2iqyfpScOEqBQlEOY5XnDLGRaEKU+laFT10jWCtpY6jJ/QiuUXTsOS + xZMwfUp7pTMXawD8BMDvUFMEgagpAH8wwb8V9rLbknGwsxebth3FH5/ejqOdPdh3oLski81b1Uossp9g + hrH2YRWILP+w0DWCubPG4IIlk3HJRdMwe8boImXApjkDVkYmAeyjlP6EUvo7TdP2hK7EGww1BSBHRYLf + 1ZPEK+sO4Pl1B7Bp02EcPtRTJNBhxuClgHfpVfmXWnbQMKGUugfVS7weixmYNL4Fl180HSuumoPZMzrQ + kIh6FAAQKqC4uaYI1KgpAA7OGP9TKEPwh1JZbNl+DC+/sherX9ittPRh3e9Sxu2y62Hd8Upc/nLTlEqX + uoYYZk3rwJtXzMXF50/BmI5GACUvdNpMKf0JIeQ+1IYGLmoKAK7g3wHgTpQo+MzaP/rkVmzdegR9kvl3 + ETIXXyW4fkIdpBBk+fNpZNfFe0EKIqyrX60px7aWOixbNhU3XjcfUya1YfKE1lK6C6jFCDx4oyuAdtjW + /naEDO6x+frDh3vx9LM78edV2zzWvhrucpj0pbjaQVN3fgJfSsCwnNhAueWxeMFNb1mIlSvmlhM4rK0l + wBtbAdwG4FMDg+nlYefxU9k8tu08jj88vhmrn91ZFMHnIWN0HqXEBGR5B83P89fCDhHKqb8sr1LrJ6tr + UPtZHXSNYNqUdlx71Vy86eo5mDW9IzQdAXRSSlcTQr4JYG0pD54reMMpADbOHxhMf7wUwV+38RAefmwz + 1q7drxT8UpmYD9oBpSuBoGdUAsY/F0YIy1kQVKqyCVp4FKZOozsacf0183DT9QvLUQTfeiPGB95ICqAs + d3/dxkP4xe/WY+2GAxgeynjuV+K+luMBlBOICzNNGGaqrxrrCMLGAcpZuMSjo60eb73uvHIUwRpK6Rff + SMOCN4oCWAbgHgArICxBHRhMe6aUunqS7G26tR/7x98u27T5cFFgr5xpOhF+Y/VqLdopZT2BX/myZ/yu + h1VuYZccl7pOgaGjrR43X78Qt7xtcehgofPi0XcAfCJkV57VONcVQDul9E5CyKegiO6L88qHD/fifx9a + VzTGH0mhF6/Jygwzz+/3nF9dSpldCKprOZ5OOUOnsO0EgClT2nHD9Ytw21sWlBIsXAN7T4IHwz5wNuJc + VgDM6r/NLxFTAH0DKTz0+414+E+b0NM3XNZYvtJlseUG8fzG8eUG30qpf6meSDnBvmrgvDlj8f53X4Qb + Vs5nLyMFvZSUBHAfbD46J2MD56oC+BDsTguc02fz+D//v1ewfddx38BcGHe8FKspy7ecabygPGX5Vmr1 + g4YwYdtQbsxAVacwdLnssln47lfevhnh92w4Z2MD55QCKDXCv2n7USycO+7zS6/+6pfCjn15hLVmlQS5 + wizYkd0PG2MQ61PpOoKgtoe9p0pXrXUJLFD4F+++CBNGNQTWAfZ2ZffgHFtAdM4oAGc3ni8gRIS/qyeJ + Bx/bjN88+BpOdA0CCBc9lwlcpYqilBVy5a7Kq2TpcLnrCMLSppptLefdBTYsuObK2aFeSaaUPkAp/cK5 + 8l7BOaEAKKWf9Qv08Xh5/UF8595nsXlLZ8nMwqMcZmPPAeUpjGoKRZigYrnrCMqhWznBPT8aMATFQwD7 + xaObrl+I2999UdjZgs2U0k+fC0OCs10BtMN2y+5EwFiueyCF3/x2HX710Do3ul/OlJXf/zD5hEEp0XOG + oCFA2DG3mF8p6wjC0Eu8X438VTRjz4b1MGZOG4W7/vKysN4AGxLcG5TwTMbZrABCRfkBe6z/3fufx8sv + 7Sk7cFRqRJ+hlPLKGRPLrpViXVVtUOXjl76U51RpwtSnHM8obDuYN/D5z7z5JAJ2fOLWDNyDszQucFYq + AGe8/00AC/zSDQym8YfHt+Den70gXb47kmNaHmGVRLlLcUtZqhtGGZRKi1Ii/GGFN4xCK1VhlpJ+7qwx + +PhfXYXLL5wWmB7A7y3L+tTZGBc4GxVAqCm+w8f6cd8vXsJvH9kQyIylBMWA0rfXLsfr8MtXVgeV0il3 + 4VClnkqpgcZSr5UbgymlnI62erz3/Zfh3TcsREMiGpTdGgCfwln2UtHZpADaAdw6MJj+YdAU37rNnfj6 + t5/Alh3Hiu6FcUeD0gc9EyafUqccS6mbqo7lzNOr8gs7e1GK1Q1Dg3LzD5OXKv/rrp2Pj39weZgAYSeA + T+IsWj141igASunPCSHv80uTyubx8GOb8cMfPyfdbLOc+eNSGKzStDIBLSfPIKUl5s+nLYUW5dC01AVK + Yfup3PLD9t95c8bilz+8YzMChp0OPgw7ONiOMzw2cLYogC8B+JxfgoHBNO7/xUv42W9eK9pHv5yIdCWL + VMrxDiqJK5QbSS+1LeW0byTiGtUsP4wXxe53tNXjMx+/ll9K7IflALajpgDKh2VZMwghXwyy/Ac7e/HV + 767CCy/sKmmFmwzlCkypCDNNVwrDhwnyhbWApaTxGwqw9pXiDYTJO0xdSy0/rGcQixn4y3dcgL/5yNW+ + SsCZIVgO4PmyGOQU4YxVAM6y3m8hYJpv0/aj+Np/PYWNmw6XZcmrMf6vxty/LO9yFseEteKl1H2kp/FK + 6ZORKL9UOusawfVvXYSv/N31QVOFSQDfBPB5nKE4IxUAtzvvx/3SPffSHnzze6uwe99Jz3WZdWXnlVht + sYxSF+vwdfBLX4lyCRucKycPWZqwCjSIXn73K6GXSgmqyg+jnNizl102E//4iWvDBAfP2LUCZ5wCcIT/ + fgSs6f/Dk1vxH995Cl09yZIj0n5MwWBaFHldg2FaReNFdt/PCrE04vWwVstvGlKWd9gpzlKmN8Mq0rDP + y/oniJ5h6CWWY2oEUQQr/FKGCWLfsufmzx+Pf/rUdVg4dxwCcEZuMnJGKYAwbn8qm8dDj27Et3/0bNEW + XWEgY4i8rgEADNMq6blS01U6ty6mG8nZilLG45W0p1yw/JmwZwHoQnmmRoquVatc/v/MaaPw9596Ey5e + Ojno8TPOE9BOdwUYwo75f/qLl0MJf17XlFqbXWdHw7QQcxQhUwbsyNKprEBQ/rpGYDrnWS4df118zg8Z + QqT/wz7P6uGXthrCz9dtJOAKoUVhWtS2+Dw9R0D4Ge3E/7v3ncTnv/EYnnspcCHgx2EvFjpjcKZ4AO0A + 7keA5f/Jb9biR/c9h0wm77rnrKPFDufdwFMNP4FR1TcoD9Ze8b8f/MrQNeKxmkHDqEqVAl8nZrHhlK9z + ClLn3Hi9gnJU9S+lD1T0VD03uqMR//CZN2Hl5bP8sklSSm85U94kPBM8gHZK6bcRIPw/vG+NK/wA3LG5 + qkOYZfBcC2NhA+7znoEIlr+f9dM5t9UPoicR4xQ1+8+3h3kUpuN1APAtw7RokfCrPCbxKLrBeV1zPS52 + zo4imPCzuplOXuyaKdS9FM9Ghqxw5PP2o09RPEfgNdGDA4ATXYP4168/hief3+VXpXpCyBOU0s+W3agq + 4nR7AOx1XmW0fyiVxU9++Qru/+VLRQt8ALWlF5VCGEtS1xBDfdRAc3MCRkSHTggy2TwGhjIYSmV9hx1h + 56xlY9Wg/MQYBbvHewKlWrWwHkA5yOsaYpRK85N5AHx9mFB6lERAvfziAHwaviw+X9E78Asg8vUUPTTW + Rx1t9fh///Ytvp6As06ArRg8bTjdCuBLAD4NxYKKVDaPH//8Jdz70+c9nZUhxBOdl8FvPpwXoBkTW3HR + 0smYNXMMpk1qw8VLJ3d29SQndLTVJwcG0/WZnIlUKouTvcM4eqwf614/hE1bj2DfgW5XIcnyF+tYjoCp + gnyyIYCsDiqBqNSNl+XH2huUjtVJLFv0ikpd8hs05JMNAcLMApSLMEoAZ8C7A6dTAXzI78UeccwPFDN+ + XtdAKC0aNwLqDmR51DXE8N6bl5a0ZzxDV08S23cew6NPbFV+KYhZQZkQVrqCMEgBisJQ6XJeVT1kwwG+ + bmGUgirfsOXyrroYVwjrbZXT3jD062irxz3/8FZccckMv2SndXeh06IAnPf574fPK70//81r+PYPVkvd + fl4RiAzI3DO/zo/FDHzyI1fj/e+4oBpt2fPxf/rdDNmXg/j68UJZSvCJj6iLbnWYYCArP0U0JGgxzWRp + w9RJ9HRYfVSuPwNv6f2m7vwsumwNQilDBj4fsQ7sGuCNV7B0YerHY3RHI/7lczcGTRGusSzrjtOxn4B+ + zz33nOoylxFC/g0+b1X94cmt+MZ/P410Kie9r1GvwGtOH+RJoVMihECl2667Zh7u/uiKJBAYiwtEOme2 + 3fym85LjxjRHO4/24WS31xvIEwKNAhFSYFpNUi9dI8gT4tZb1+wjpXZ7NUqL2qOFUN4sL53aAqsRgiFK + oGnw0EjmAmsKGrJrrG58fYKqpDltsp+V32dHTagfXy5flzyxhZLlK6Y3NSIti9WBv8+uaVwd+bqyI9+f + nv7WNWiUusfkcBbbdhzF/HnjMGZUo4oskwkh0wE8DiAV2KlVxCmdBbAsawbsr60oV/k9+fwu/Md3nlIG + 3Pj5/QzxjhvDrP6qa4jh5rcsAMLtBx8IZ++4+htWzsev7r2z84rls73ReacernsqiR4Dhag8m6MXZwFY + kEn13w9DlHhokqBW0SyJbH1EGISpG/+fn6WQ0UG1bsLP0vKzB+x59ixvsVVl6YphFF9PN60QN2DwW0y2 + e99JfO2/nsKuvV1+pHwb7ID4KcWpVADthJAvwkf4N20/iq/99yoc477FJ3YE72IapuV2BJ/Gj5k72htw + +YXTTmJkMOGez74Zb79pSRHz65zLLHN7+aMI06IuY2VhDwX4RUy6grkZGggN5RaLU358XrwQ8NdYHcR6 + qv7zikd0v9y8JVOl4pQnXz5Tnian5MQ8dKt4OpGfCmXl63wduLz4oYDbfu5ZfkgKAERwhdZt6cS37n3O + 95PyAO6klK4M7Kgq4pQpAOcbfcrXevce6sVX/v3P6Ozs9cwRiwwjY2TPCjvOAzC5I2DP8bc0JQAgMVLt + 7Girx+c/8+bke25cbLeBY/4MIZ4Vh66S4OeXHWZj7RIFjhcK3lvwo0kWCssY0tK7AsYJjDiXXw6ywrkn + cOmUx+optkcUXpGOLD9x5aS40lNcNyHSh6c7v1bBVHgVzPi4iodTVKtf2IXv37/G/RydBPWEkF+eSiVw + ShSAE/T7lOp+V08S//69Ve4WXnwQBoDS7QKK55X5zmHKgDFEDEAmkwNGfpxV/9d3LMcVy2d7LjKPhf13 + I/mcm+qZyRCWuOqchZbNRfPwBLY44eXzDoI7nOIto+Cii4IYZkgiLlTi8xMXNEUlZfCzPn7IwuuS80u+ + xXZCKIenNb9wyAygoe+UpUXx20c24JcPrkUqm4cCowghX3CGyyOOEVcAzqYe34Qi4p/K5vH9+9fYm3lI + LBw7ui6ooARE94wXellnHDsxCEpp/0i3u6OtHnd/dAVmTiu8Ls6PhV0LxDFUFCgar/LWl52LSk8Gcdxq + KgRY+bwgFH4r6njEQgQm+TiNuICJV1QmOxfcf3G1IA8xJiTGIli7WD1FSy2jjx+dRIjPsPbwnsP371+D + p5/d6ZfNcme43F5C0WVhpGcB2gF8lRCidGl+89B63PuzF2Ba1I24sug0O7IoOov485FejRDAom4kmGcs + WIVoLEM6nUM+Z7ZdfMHUkaYtWpsTaGiMY81Le2CalidqLkbwTY1AR3F0nEWz2ZEJCmu3Cjwt+VkRNlMS + 9LxYPnueEq+7rAl9wRZYRQh8ZwTYPRaFj6IwY2Jq3tkQXomzessWEvG8wejJhl2UAjmtEKE3CfHMWrC2 + 6YCbP6OPOxPgM7PE050/8nVh+VEKbNp6BAvOm4Bxo5uk+RBCZlBK+wkhL5TOeeExoh5A0Lj/+Vf3ucLP + g1l8fpzlWcjCjWdFd1885+eomSV4+E+b8Pyr+0ay6S6uuXI2Vlw5x3NNdF1ZfT3DGM7jMSXWkqeNrhGk + iOY5sv+i58BbVlOwrDLwqwr5OIUn8KYV1vMD3qGOLqkj+8+3nc/PQwtHofC8wR/5oYInau/kKQ672JFf + Qs3AD6lMrm1un3AxCb6PeNqb3D1+SMfXF7DfG/jm91bh8DGlM1rvDJtvG0n+HDEPwBn3/xsAqYo72NmL + L33jMew70gdKvPO0mqONmbXROMuXJ4XxMEujcxbfM+0jLJ1lVnc4lcPmHccwekwTpk8eWS8romuoq4ti + 1Qu7kcuanvbw7RKPzOPh26dzlomPFQzDXuSjEYIoJ8dR4rWqLB/+vNBf6jYMQ0OUUvlcutMfEUJgotBv + lmNtNUIwDA06pYhr9pRklMBdlwBJnfijpdl9xzw5vs/zuoYYHGXgrAMQ28k8GHF+3uULLm3eyZuvSxGP + ATAZfTk6ZwEkSOEee1bnvAixbsdPDKC7L4VLL5qGaESXkb4JwHjLsp4lhPSOBH+OlAJod4RfutRuKJXF + 17+7Ci+9us9ddMHAiMPcftdtcjqGMRwjrp8QFfIq5tz+/hSee3kv1m85ClCK3v4UOo/1Y+OWTjz6p014 + 4KH1+ONT27B9+1H0DqRQVxdFU0PwJ8dl6OhoxObtx3HwYLenfYDXBeYXpuiA6zaKSo0/jzhCz4SMLfTJ + wlEGCrrw9AlCBPJ5ctYffDwi6tTZ0goudlwr1C/P1ZcpKCYkEULcc3eoQwsvPTGBdRftEJtGpuJZUyOO + AqQuD7B6sf+UQCiveDUiBMXMyjRZH3HnjAZ8XVR10yhwqLMXLU0JLJo/XkX+yYQQDcCfymK+AIzUUmDf + bbx/9Ju1+PZ/PuGey6K54htjKibmIUtDhaWqqqWzdQ0xmDkTmUy+KOrOXhp6981LcdObFyDowyQy/OHJ + rbjnq3/0LG12vRqewZ09DsK0W1yOyp5n7jWb/2dLdNmy3TA0FPumaL5cGELI3vCTPZ8iGhoIF2AUAm56 + gMJS5c/q4Pf+gWyxjkh7WZ1V9eGXEoeps6odLS11+PoXb1EuFx4YTKOxIXbdSLwvUHUPwHH9vw3FMtuX + 1x/E17/9BNLpHFJEQwTUtSTMbQIKml3F/MwKMCGXWVWds0RAQfvz7iAldvp03kLOoh4vo5AfRc9gGs+9 + uh/Hjg9gycKJqA/+VJQH9U0JrH5+F/r7CzOQzFUWGVDVlmLPxhvYcvdIcNxtwL5vcAHIoNeGebqyMlgd + RHeYWURmCVl/+T2fcOR1iBLENVsJUIlnJw51eAvN5888EGaBDUfhWRpxA5Gsv3lPgL8mvlsCoRylYCs8 + UJ6OYrvE/jU1gmwqh4Odvbj44uloqivmq1jMgLNU+L7qSCnX39XMzJny+wIUy2wPH+vHd+59Fn3OSr8o + KZ77BgpTe7IOAHfdE5TigjUsD1MjRfPA/JGHOLcsW2RimBYee2ILvv7dpzGUKmVyCGhrimPe7LFFG44w + oWVKwDMFyLdRYVnYc566avYwYIh6NxLhVyT6bhYi1EGcdhWDkYCwbFcILooBxiFK0EAohmghUAZ4p0FN + i/r2PU8Dd/rXEvZI4IJ/PI14qy9afn7xlZ/wi+s2VPzJ2iXSRuT7dVs68eOfPu+3PmA5gP8qielCoKoK + QNO0O+Cz1Pe+hzZg46bDHuLyi1NEYvIMIbqcvOAHubL8DAD/3zCt4i2ohPrI8Punt+HRP24qiTaJqIFF + 88YhxtXPravAuNI2Kqy2LiiCIWqfNxDqGQLwQpghJHBuWxQwka5F7rBFvUt3Fc/zaCD2M/zbgTKB8usP + vlyTU6Q8LVUzHGw2wLP/o8SgqBQwn1bFn6xdMoMitukPT24NWh9wa7VXCVZTAbTD3txDij88uRV/eGSd + e56lpMhq8wTnrYuMaLyG5a/JOoRQCkILHgEfE5DlUVQPsSzTwu/+9HrQuu4iTJnY6jIb7xKKEKeRZPcY + 2JiXMX3Ecasz3Jy8YVqe8T9bpy62XWy3bPWdTDj8FMUQJa4ij6Jg/YOgor2svqLVNoUxvuqtPXZk9BON + gacePuN7FX+K9dWF50QF0juUwY9+9oLf1OAEx8Ou2tRVtRRAO4B/gI/r/7PfvIbhoUzBLSJ241NE89Wo + 7D8/x+q3jJXdz3DnIpjgMw/Anaul/h1sasSdetq8pwsbtx0piUhjRzdhVGMcGdjWJwP/pbN5rp0ZyN+d + Z0E/XgmI52JwkKFoubBGPGX5KQgZrVyLx91jrj4rO0Etd3gC2EpDfJeD9TPffnYuo4OImNMGvv6M3oCt + wNm5SCeRf3ha8EfxOs+ffPt58B4OS8/nE4P95uB9v3jJdyhAKb2zJMbzQbUUwK0Dg2nlJof/+/vXsXWr + LSyiBYkS+bhJVAhMYcgIK8LUCAzFWF60gGJd/BQHUGAk07SwY8fxkoiUqIsiGtGh6xoysBmVZ8SisngG + llgVNuZNUC8TJ6hcKbANQXhaMPCxiRjUm6Py/SH2p6xPhyhBgloeRRAlFFHnXNZ3fD34/osp6CCC0Zb1 + F/88U+AsDeMHMRbAaG9oxZ4qu++ZLuTowf8XaSfSiM+H0fyRP23yHQo4C4SWoQqolgK4XTU19vL6g/i/ + Rza4jROtkHgtS73MxN9jWtMPeYnA561gl5OlMZz0fs8w5urpK20IMHFs80ktHoFpWtCdWERe1zz//doi + XuODnDkLrtDzwp6z4FESMjqLMDUCi2jKe/x/8Zzly1v8FNHs9zUI9SihKAlun5h/mL7khTbP0ZZ3+3WB + 3kwJyOrh91/kZ0YD1TBAlQ9TKhkAA5k8fvab1/yGmBMopcrhdimohgL4EhSBv+6BFO77v1cw0Jd0CZ6g + FvIW9az04xEl1MOc/Hk0YOyYpcRjNdlz7JqK6cXnLKK556yu7L9MUMOiqyfpvhnE4hL8Lyc4AYZE2Rmc + kAEFJcmsqhhljpJC/IPPn9GSpTMCFKuMZrJrrL/4/EUvz68vgvrK7z67xt+T0ZnRWnxn31SsHzC0Aq+y + /5TYNBP5NSytRO+OpTOcvli77Rh+9dB6ZZ6DQ5n3VSMgWKkCWAZAOR750+Nb8OzLez3EZdoXKLhnomDL + lICKqH7pwuQTlM7ghgzsP6EUMQDjJ/t9GLYYqVQWVtq7zdlItzNM+2UMqspDvC/LXyynkvxPRfkMTBAp + IdB1zRX0vEU9ysE0LY/yGAn+jRKKXz69Hes2d0KGpsY4CCGfRIUBwUoVwC1QvOa791Avfvq7dS7hdInV + VI0zeQuiIppoaVTwuy/mJ7sv81LyFkVdQwxL544tiVj9g2n0C2Y+qH5h2ulX/zDt5xlWJSyq+yOd/6ko + n7nj7GialivkTNB1bvaGpZXxRlB/8PeD+uf4oR786Bcv+605WQHgVlSAshUApXTlwGBaudz3gV+/ggOH + ehCDNyBjctNwuq6VpP1FDe9nJVTnQRZDvC+6hYxJliyahNkzOkqi2cHDvUgOplw3kh8HllO/sPQKyp9n + RNUzYesyEvmPdPl8wI8deYMlDo+Ym04oHTH+ZQHDVS/uxjPP74YC9QBuRwVeQCUewB2qwN+6zZ14ZPVO + V/BVwRfTtJREEMf9fuMsmSZVnYctj10TPZcYgNaGGP7ytmVoKHE58Lb93fa+AGzvfC7vUoRdJsyq+ofJ + X5Un/0yYoYjfNT9BOd3ly4K+7pBVCNYRSj3Wf6T4l8VOTNMKCghWNC1YlgKglK4cHMpI3/NPZfP40S9e + xkBf0p03ZwQVl+KKHoA4BuLh5yoFWTrVdb/y+Gu825dpiOOO91+Gyy+cVhLNBgbT2Lj+gKf9YeoXJDhh + 6l9K+/3iJLL7QfT2q1+Y/E9F+YYQBM1btDCN7PAvodTjIbChQbX5V6y/oRFs2n4Ujzy9Xfk8IeT2crcQ + K0sBEEKuUln/51/dh1de3eu5xk97mcJSzTABm1LuqxillACRCNO0Zy7GtNTh8x9cjtvfUfoU7O4D3di+ + 097zULYAKKje5dIjKP9KEWXLeSX1rpO8417xhxhGoHwxBsBfZ4IuegLMC6g2//L158t76OF1ONjZq0q+ + gBBSViygHAVwGxSv+g4MpvGbRzdigH3Kiy2ndASf/QeKA4Cq8Zyo4WXuoCxd0HUZxPxY/Sd1NOLm687D + t75yG97/jgvYtwBKwh8e34yBTB46Nwtimlao+gW1U5aulPbLngt7zDqr+rLcj6Eva3muZ6m9bFdMezrL + 5yP+qqPsvzg0HCn+ZTy480A3Hv3zFiV/EUJuLpkpAZTMyZTSW4ki+vncy3ux6vXDbpArZwFwrD9TAoxw + 7FyctxfdKLFTxYCO6hnV1IxGLUQ1+ZgZsJVWVAPGtTfg/CWTcdWlMzBvzjiMG9NYluAD9rLhJ1bvcNue + s4CIBs9iG9lYUayjbE2Eyo1XucCMNvm6GKxkVkmzsHGVLCXQ6qMwhjO+dFddV0XEq1m+SFfxGm+cTCE2 + I4MsjYwng2ZmQvUnKSiGh9fswpuunoNZ06XB5+UAPoQSvzZcEkc77/pfLbs3MJjGo09uBYbSoLrmMrlp + Fqc1OaWQteAhVlDgSkyncmnzdTEgmS3uECf6HuX6j+XVEtUwd/Z4vHnFXFx8+WzMGiffsLEUpLJ5/OLB + 13C8b9hVjBHNHlNGhLFkmKm+oPbz6fJ1MRjDtq+VbUggOpQqLEEdzgBEEqxqSACDaV+hFPsjOpzx7tuv + EADxukwAql2+7BkxX16Yee+MP88RggjbV8LQoVNnhqghDovjM1kZjBc97VQEbVVB2iih2LenCw8/vR2f + na6cfbrdsqxVpXxjsFSTdgcU8/7PvbwXz76817boDnPnLHtPPJ64TPiDNK2f9gyyFlFCkXU6RUzDAjz8 + mC6qAVdcMgM3vm0Jrlg8sawdf1R4+tmdeHr1drdMixTaECH+7eKtpFYfBZgwc+n85pQNLj0G0842YVT6 + DPMIokMpQHDwxGfE/pEJn8pTExX8qShfBKNllFDkTeoR+jC8GeEWARnDGWRR7BHzZfPKNuz6FbGPGR77 + 0+u4+Zq5Si9A07QVAKquANg84yWymwODaTzw5y0wTQuWsyyVeQCMsACkY6cgFy2Mmy/TqmL6fF0MGM4U + zekunT8ef/mOC3DFxdOrKvgAsGtvF779i5cxOGyzqF12oV7iUlS/dmSTWVeA/dxMv7lv32GBxCPws2o8 + /KbmZFYfgNsfI12+tO3JrKtkLKJBDBXKlAAT+iJe9lkR6DdDIFNoqn7l/x/qGgz0AlDCMCBsELAbwKcI + IdKphldeP4QNr+2DodnuLb9CKmfZRLaI5q5FZ9d4QrFGi2NDAL7vjwcxH7vPxrvsemtDDB/+wOX49y+/ + HTesnF914e/qSeLf/+cZ7NvTBUqKg15i54v3PMKJ4mGSzLvxG+fyEMvT6qOeeypLLcZkVNacL18sy53e + 4oR/JMsX2y3SJqLZ/JizvMFqBtO0XL7lh67sXAZV7EalnP36Vew/i2h4/IXdfjMCy1HCVuJhFEA77BVH + t8huDqWy+N0fNrkLXBiY9Y9o3h9/je+YfF3Mc84TZZi7xyKxLtM4gusRpoaEpwP4TshSgksWjMe3/+U2 + fPZDV2DCqIawtAqN7oEUvv7dp7Hqhd1FbWYxAHZk9WbtkXkBw3UxDzPwabINiUBLz9MAgEtrxnBMGBnE + vhDr0+D0l9SqO2B1Y1NlrL2y/Ea6fJ7mfFr2n+dHPkjNjuI9BnauGtfz9WF15umR1TTPc4wHVPEBhn17 + uvDHZ3x3DlqCkAijALoppR8FsEB2c8v2Y3hFeGEhRwhywkwBfy7ey1LiWugsJcjXxVziMQZhzMre5DKG + M3Ya2YcWJdcYAd95w0L8yz/eoNyBtVJ09STx1W8/id+t2u5hmJwzK5JTzKDwbWdWkQm9KCC8hxQdShUs + YkPC/t8YL1ICeU6JGM74l6UTLSpfHt8PbtmAp79EL8tl/MG0vVxWK8x+sHrwCnkky2e0Z3wj8whlvOrH + r+I1cTaDL4MZt6zTLkYPcSER6xfeI+L7VfRonnxpj9/qwNBfGQ41BCCE3K669/ATW9DXnyrSjhFhfMvO + +Wgqa2SUUJfho4TCSmY9HRwFPALBCG0JUf6ijnAIl6UELc0JfOr2y/APH12ByRNawzS7ZOza24VP/usf + 8bsnt8nbr5Oi66x+TChZm5gQ8MMgrT7qEYiiaTQW5XcYn3cpeYZ3y3bS8y63KKCqfuDpLl6zuABsVtMQ + oRQ5Qjzt49sxkuXnLCBqWa5gycbfrH5+/MruM+XAron9IdaH0d5Vdppm18c5inzAaOQZCnL9ybDt9UN4 + Zd0BFStOIIRcFYZnAxWA89KP1Prv2tuFJ9cehCbsNMOIw7/4lhPiAioBkAV6MoTASucQ0VA0XrS3BLcJ + KrrZkWQaeYuiJarhrz9wGT74/kuqPtYH7Km+J5/fhc984SG8+so+12VUMZXsHu8ueujvuIpZAFY657GO + UULtYYSmATpxYw1F016aHZiFXnCFPcG1hsLX0vn8eUsUJfZOzZZWvHbBEmZcPP1oUk9bWJ4eJVGF8mV8 + Ad15zmm/+Cp2lBQEmxd4vo+iluUqEULt9vDXWDtYeXD6iZXLl8XTI+J4AhENgE7c/6KiYnV307I+owSP + PrnV703BW8IsDw5UAH7Lfp96aS/6j/YWubouQXVSRGDxOq+N2bhMDJIwYucIKVq8AtjzsqJlBewoe1PM + wCc/cjXueseyshfy+OHwsX5884fP4v/96mPYeaDbZQLR0+Ehuo/8MEf0dFg+ruUQ6MXuRxwX13U5Kcf8 + jsVxFbMQf+DXB/C0d4cKPIThVTX6rxrlM/qxdhXRTUE/LW96+oPREgC0vBnYvlLLY/95L0LsP37Iy/cd + oxvD2q1HsVGxXwCABZqmLQni3yAFUA/Fhh9dPUmsfnZH0dZRPNPzDRPTsMbzwS9xNZeMkcXoOS9ofEea + poV8XQx33XkF3v8O6RfKKsLAYBr/+8gG3PXFR3Hfr17DgLM9mEfROWDtd6f9TOpxi3mBL2J60457uEzF + uc/GcMYVLEILrrTHmxKE36WVVbzSUhaBFyGmqbT/Ki1fpB+jqeteOxZXRT9d1zw04Y+WoQe2L6g81fMs + vaz/eLryQ4Wc4OH19afwh1Xql4Rgr9vxhZ9JbKeULiWESBf+vLLuAF7fccy2ePwYyqSuFXThfPea9wZy + ln3dcua3WaM12HPeANzVU1lKAJMiXx9z3b2sEMSJOO5Zzik7omt4z01Ly3pxxw9dPUm8su4AHvjzFqzd + 0gkMpRHRNeSIzrWruP05wF3W6Z47bYo6jMEzvthGtposC+KsfCuMPyHQMMtc4mTWdk1N6lX1JvUsLEJj + HOCCiaw8i8unSCgb48gOpovKLqf/Kilfq4966KfFI4W8OT2qop9nWMC+z+7wNBDMn562SMrzfZ4CWn1M + 2n/uNZMiyykpl54OXtt4CAc7e1VxraWwd+1aq+JnPw+gGz4a5JkX93gsu8zyRyj1aC9PYMUpmR+78cE/ + t4LOeAgojA/5MZ+WNwtBGifIpuVNrLh0Jv6f915UNbe/qyeJ/31kAz56z8O456t/xKuv7HPr6loOfrjj + WHktHnHPRVpFNG9wjrcW/BhZnBbjg0W8x6DVR13asOvMy7Lfy/Cm42cSxBgET+tYcwIiokOpqvRfpeXz + 5fF048v1o58IcegW1D4Z+EBk0POy/vPU3+FpMxEteBfc8OrwkT48+6Jy4d8ESukKv7r6KYBlqnf+d+3t + wurNR+zgn0k9kdGI5p3yYoEQ1zqa3mGBGO3mG89HRFlHsvvsOV3XPB6AaVqYMnMM7v7oCrQ3JVANPPfS + Hnz+a3/C//fNx7Fx42H0ZbmvzjjzxC7TMOvvxDmsZNZVeFGrQC92ZGN+nhZ8LIBdFwNt4uIanqENwaPg + aZwjBHoqW+SmszR8AIoxb6bfK+xafdSdYam0/yotn+XBH5kAMt7zo1/UsgoK2iwMBRhPBbWPv6/VRz2K + h2+X6nlZ/wGFmQNm3GQGIV8Xg2la+OPL+5TfEXDeElTuGKRUAJTSFarg37PrDqK3a8AOvnE5iIoAgCvw + hFJvgExRMus8fvzICMcYm92XoamlHp9878WYPqnyqb6BwTS+ce9z+MxX/oinXtzrrvxiHcgYkrf8TLkx + pmKRX14ZAoWFJ55oODeNxEfDeYUgLoCRLf7xLCThPA9Gs5xVmDkQp+V42opC41plTbPfLZCM1Uvtv2qU + bwxnPN4PbzmD6JfVtMKwjQ0f2SyOZKGf2D5xHp8vT7YaUUUffuzviXE5AVQefHt1XcOuHcewbaf8GxUD + g2nlp/oAHwWgmkccSmXx1Mt7PYEs5nbzwRTRI3A9AYG4orVjAsDP8fORcZaG3Rfnaa9bPhPXXDkbleLw + sX783XdX48cPvIi+/hQimm3teavmWndu2pMNRXLctBDgdfvFgBzreH4eW1wAw7vE4pw5/7xogURPImpZ + rnDwAsJbH9Fq8cwLFEftK+m/SstnYPnx9AlDP75PXA+A492g9on1FOsRhj58/8ksvVhfvhwA6OtP4emX + vJvwMDhG/FMqPpcqAGcVkfTFn517urBrxzEPoXKEwDLsVyq0eMQ95ix4xi7sGQDFgTLnWlbT7MAMNzfK + zovmTNkKM8elnjaxBR96zyUVj/v3HurF3/3743jqT6/b9UdhvXiWEtda8MLMGAmmPe7X4hE78CV4KuI8 + M2MOD+PqhXUPbH6ZtZl3g/mxNHN5rXTOte7QbXef/aeCF6JalchbNVER8ffD9B9rC29hxZV/lZQvroNw + +4ZyXhdXF56P+AAgr7DF6VKe/1xl5eTJL87ytEsn0j6QPQ/A029SunHnnnQOXnttHwZkq2JtXA3FMECq + ABzrL930/pXXD2OgLyld7MLP87pHjsi81WHnfFr+mmphhuw6Y4R337qsYte/8+QQvvbdp9wFPUVBOt1b + H9mSUT7Yw9qvWlpaav4ifT2dyQKOHC1V5bL/vELhx7DsuueV4sa4990L579f/4nXZeVVUn5Q+2R18Vv8 + 45cPP23N9x9rP98eVX6y+2IdRTmRXefrrlELm4/0Y9vuE9K8BwbTyymlS2X3VEOAJYqM8Oz6g8rPRhVl + 7jSWVxZ+TOgGyHygWl0347yJuOmauaHqpcJQKovv/vg5PPXKPteNF6O4oaALjKIX11kUiJLy5+jLewF6 + Khu4hl1kLD5wyGYVmJUSV9dhMO1diOP89+s/VXlMcKpRvl95fvfE2I0Hjicnwu0j5umpovzc83z+4n3m + DYj1Kuo7kyrfJbEMHZn+FJ5bK18a7AwDlsjuFUmys3xQqi0OdPZi145jnqW/HsKZXqZ2p8kCGJF1Nk9M + UUur/jOv4Jar56CjTfpx4tB49I+b8OvHNnuWa/LaXVaHojrpBS9A1V6+g0vJX0VfcTqyqF84iHSVvXjC + g527bndjvOCOcx6Aqv/EI8/s/DOVlO/XPlkdZIpAKljJbFF/yASen8aTKXQ+f6nCFxRnUZ+btMhzkKV/ + 6fVDymGAKqZXpACcHUXki382H0FffwpoiCNnOeN8ttBE6Fy3sUwTmt45cRXB+Ya7+XONlrltE8e34M3L + Z6IS7Nrbhft+u1bZDsbkrN0w7blZvv05Qtx7Yge6z7FrZeQvpa9w9KMvD1EBAZyV5epUZGUH0wUhFe5Z + yWxRf/Pt5QNtLP9qli+2z08Jyiy+2C88nVgfirQHvG8YypShLH/+vkdOUFDkvMIRPaKiOuoEB/Z344B6 + n4ClsncDZL78YtnTqWwer762z66MM661kllPJ7P/qjiAlcy6QTUPgzTGC5aQXROCNEUdwhH2iivmYOLY + ZlSCHz29E/sO90nL8muP2H6PEnMslKcTS6RXVejL01UCVj83YMn1B98O9+gIHm+JPXPYrD7pnKf+bt2E + 9BWXXwZEPuKHMR7XXjj30FznVviJngG7H+J5P3rxgUCZPPDoG0rj+XUHVbcnOMbd225JwiWyp48eH8Rm + JiBmsfvONw6NcU/Ul0dRep3YS1JZIx0rEgomRaw5gRsqtP6b93Th6Sc2qxOU0h7GpE67XEtWLXqVkx5Q + Mg9fPzc9b1kb44Vz4brrlsssMTcUKrJcg2m3/lUpXwZHgMaMb/WNC7hKlaOP6JmIgT4ZzSu5H0ivkMhY + FBteP6RcFASJcRcVwDLVwoFtB7pxvG/Y03F8Az2NG0wDTJvr6rGPtKG6v+sqYtGcsZg5paIPpOKZZ3bg + WE9SXXYp7WHKzKetFdOrEvoKkFlij8UVhTHoOk9D0xv48igw535VyhfhTAl/8a+vxj0fvQpao3pFaJHn + Ca9FF4/S2RcuvWwptO/zYegVEjGNYPPhPhw9PqhKsgTCdKA4Yb5Utfpv48aDyAylEdM4t0UQGM81YRcb + ZXoZQiqBTNTA+XPGVvSO/8BgGqs2HEQsm3cXLUnrUm579CrTqxr0VdDazYMpMUGZhbquyNsDlk7VvlLL + F3Dt9Ytw97uWYdb0Dhzs7EVLUwLHhxQKQ9I/Lt24uXcZfT1pFO0NfJ7taqXw6ErF8SO92HagWzUdPs2y + rBZN07rZBd4DaAcwRfbUwGAa63YcAyIFfZHRdWR0XXrud11MU04e7NiUiOCKZdIqh8buA93Yvr8bmaiB + HCEl16va7a80PzHvoOvJqNdL4M/5/5XWp1rt9WuXFo/gztuW4fv/8JYk2za7ra0ekxKGkg4lHZ2t5Mt+ + XnYcziDD5N6kldPfoti4UR0HIIRMA+cFuArAsqwW2CuGinC8axAH9nd7Co9xX/zI6LrnPOi6DGHyYP9Z + HcaPasDESW2h8ldh594u27Ph8g0q3+9/NdpfSX48jVR9FDNNN019KlOIuZgU9dniGEw16lMt+qnapcUj + +LsPXoFPf/hKwN7HAgDQkIiiecZYIJeX0qeko0Yqe15yBIB8PGYLfyKG+lSmSCmXSv91O4757RR0B+w3 + fQFwQwBHM0jH/+t3d6FvKA1+UWslDa7kWcbAGV3H9NGNaGuqbIuvTQd6bM0eMRDL5gGdBNadrwP/vxrt + r3Z+QflDJ0hGo6jPZm0G5I71qQwyUaNq9ak2/RiY8N+l2PuhTaMl0+lUHQHYSlcn3iNQFv0zEQMHjw/i + xMkkGiYVx4AIIYthewDdAOcBEEKmqoRk445jRe6PKIyiJhKvyyysKo3sXOb+TJ7UVtG6/1Q2j30Huwtl + CXmphEemjKrVfhHiPVUaWT5++RcxIOBan/pUYYyuap+sfn7tGwn6sfuffv+leO9N0tlrAEBDfUxJS5mC + CVJA1bwfM80i1x8ouP+l0j9mmugfTGHbgW4o0ApgKjvhYwBSCg6lsraQRIoFTTUW4TtHvC4+K0sT9Ax7 + bnqF7n8uk0c2kwtsm3hdVbdqtp+/Lv786iKmVeXPwBgtGY16PAD+XintPtX0e+dbFuCv33tx0s8QtLXW + u32soqVf3Uq9H9R2kf6M7jzN+X4olW6pnIVt24+qqjkBCgWwRJa6pyeJg0f7izpFdMeCtKp4j6+8mJdl + aErr4VY8HsGkcZUt/snkTAwMFSLXYVxZVRur1f5ERJNaDHYM61n4tYdHfTbrDgH4/+xYaftGgn4MF80b + i6/83fUnwY35ZegX1guEoSd/TMUinvvsnB1l9VTRRLzP052de3i0RPow7N593G89wNXsjwHY6/81TZsm + S3noSB+O9w17tHHQuK6c8S1/L5HJBY4tm+NRNLdV4as+mZxvG2R1LXfsHqb9KQAoMY9KymZMxysBUVgq + KWOk6DcmEcGn//JSQPHWKg+zb6iIf4LKTcUiLh+K/Ki6LuNTMX9ZPRjtAa8HwK6VQ5+9JwaRiBonFfTp + Y380ANA0rUVFvO0HepDJ5EO5Z0GV8+sEv3sy9ycR0VFX4Xv/mqEBMe8SWZmV5OvBWw3+XlD9VfnL8hTL + DCpHVkfVc8jlPfcYwxlpe/yf0e2pJCOdQcaiduwnly96zo/5pOUG0DaIN8R23vTWRbj8QqnNKkLSkpcn + ox07MuFW0VbWVhmfyvhYJvzJqP0+gGGaMCSG1a9vZR7ykZNDWLe5U6Ucr2Z/mAQtheIFoD17TwC5fNEU + iJ/GV1VORdAgxpURPRrRMX1Sq0rDhUKEEDQ1eANEfp0Yxlqp2u2Xv4op/VzpIjo501xsrNuUiKClKYG6 + qI5R7Q1ojehobkmgoT4GvaUBzWxf+6iBeF0U6eGC5e/tG0aGUgyn8+hOZjHQPYjuoQySg2n0D2eR7kuW + pABLoa2fAmGYO6kV77thUag+TmXz6DvaZ9PHoU0p/VhK/4ZJx1/L6PY0rDvW54Kuquf95MJDs6E0dh/p + x/kLpGI9Dc5uwUwBSFfTDKWy2N815KmIrEFih4rM4MfQso4OwxR1UXUwJiyaGuMYNb4N2HYstGXwC0wF + tV+Vv0pAZGUwKw7YSz9jDXGMH9WAUe0NmDa5HdPHNWPKuCaMaW9Aa0sdEnVRxCI6GhLlrS8HbCHKZfIY + SGbQ2zeMYwMZHD94EgePD2Dz/m6c7B7CkZNDyAylbY9BVwtwOfQT6fX2lfNDb/ySy+RxcCBdtIiNr4us + r8vhb9nzfgqFB/MCmPX3E27ZUKqITyyKY/tOAJgvI8sESmkrIcT2ACil04jk9dG+/pQdAOQ0p9ihKtez + VEKXYv0ZOk8Ojar0674zRxXiR7LOEtsmq5uy/Y4wBDGDJ89svmg6kqdJc2Mccya2YM6ssVg4pQ2zp3dg + 0vgWNDTERuTLRwCQiBpIRA00NcYxcWwzFgLARVMB2MphaCiDYycGsO1gLzbuOIYdu47h4PFB9HYNKOkl + U+5BwyAAmDymCW+6Ivyejyf7UjjeNeh6ADI+UykasQ5h+lf1vMqo5KN6IQaTyrjrUPxkQaZAimgLYGuv + z/sSdtD/SQNAOyFE6gGcODmEvoGU55qsYuI91fWg8ZHqmqwD+pJZ0Hy4VXa+VJg3FomIhlTO8nXNw7S3 + KA039eSX3tNmcS1CzMC00Y1YMm0UFi+bivdev2APIWQsAiLfpwqJqIFEm4GOtnosnDsO73rTfNtzPNKP + rXu6sHHHMby6/gAOHOsHz0lB9FTFFt566fSStn3be/AkersGivrCzyhZhoZMLg8rpkHLW25QMCM8J+Yp + y8uvvYDX8rO+94uRqfIruqcDnYd7MDCYlr4rQwhpBgDDeTlAWrmjfSnk8qa0EL9gjcqNCuvWqCDey8r2 + bS4RKy+fdXLK2OZR2w/1+tZZdU9Fl7DpZedM6C9cOgUrzp+ExfPG8xZ+RsWNHmE0JKJYMKMDC2Z04F1v + mo/ugRS27ziGZ17Zh2c2H8H+AyeRGs5K11/IaML+NyUiuPay0l793iAM78Q8+Yg/u66lsrASUTcQmNF1 + aHmrqF5+dZb1fSoWcRUKu8dPt4r5+OUXBse7BtE3kFK9LLcEAAxnBkA+BXiwGylByEoJUvi5e+w6O/cb + E8ruDaeySCZ9XZywGHX1silgCqCc9pSTXoaxbfVYuWwyLr9sFi6aP25E3fpTifamBC6/cBouv3AaPjKQ + wvpNh7Fq3SE88/JeHDw+UJRe1edzp7Zj3szRoct1X2LzyZ8Jt1ielsoi5SiBlDNTxM8MsHxYHmLesr6X + KRFx2lVFA5lR8TM2lqEhlTNxsndY9dmwFgDtBuxVQS2yFIe6k0XXgtz8Uu7xQQ8VAVTP5vIm+vqGUQ3c + eO08PPTsLntPgDLbU077kcsjURfFwpmjcf2Vc3DXO5Z1QjEbc66gvSmBlZfPwsrLZ+Hg25fihbUH8Mhz + u7B2S6drbFT0KvXV790HurFpT1fR9UBLGjFgGZor8CrrX86wUPSCmQzkdd3jCfjFmvi8VXKi5S2k+5I4 + 2ucdwnNosSyrxXACgNLxpDh9woNVWFw5xhokznHy0U1+sUMYhcI/w/K2TBMHe6qjAGZO78AtV87C9x/a + UHSPla2qv7iIQ0ynUnDNjXFcftF0vOOKGVh5+awk7DH9OS38IiZPaMXkCa1464q52Lb7BO7781asfWEX + juZMV+gYYqaJxYsnl5T/0y/tRb9k45AMIYhlnSXgCv6WeQUyhOEPXh5kaTK6DoOTFzdAKCgF8RyQKyFe + KRw71q+qequmaS2GKgA4MJgumj7hKyEKuHiMOQsaRAFh11UCwgJyfHn8M7zW3K/eALEkJKIGPnDbMqxe + ewDbD/XCMjSXAcPUnx356yydB7k8mtsacP3SSfiLW8/HvNljmIt/RgT0TheaGuO4eOlkLDpvPHbfshj/ + +8Q2PLFmFw70DiPmbOfV2tGEeSXs/NR5cghPrD1gL2CKRtAU1dGiEcSaEqhvjKMxoiEaiyCbyWEwZyE5 + mEbfgB3zSoWILfG86McfojyI/MwrglLPVd6F6y0QgiMnh6T1HxhMT2hqjE812HygiEzOxAmrEBxkgs8a + Kq5hZpUSrb64zpnXgqwRvNCnct4giSdKqhdWzQ0YBrbstNc7V2OcPHFsM/7uruX41Fcfw0CqsJOOqi2s + /uw/X0dPnQlBjFI0N8Zx4yXT8I63LuIFvwYOiaiBhXPHYeHccfiL6+bhf5/Yhsef2IKD6TzGdDRiVEv4 + j72ufmUfkoNpvPWS6ViyaBJmTmnD2LEtGNNaZ5eVsMf1DYloEkAKQGbznq4JB472Y+PGg9i83x4+9Cu2 + HhP5U/wf4/hFxkPMOPCGjT9nZajuhxl+xLI5dCqGAJGYAQCtSg9gMJkF7e53G5PXdWlDZed8o/mhgux5 + wyzWuHxDZN4Fq9PBo/3o7klWvCMww+UXTsPH/+Ii/PsvXkYmk5e2RdZel+CchmZoiuq4dvlsfOBti7B0 + 9uia4IcEUwS3rZiD//n9JrRplDFtKMyb3Iaf/uttGDemMYjm9c7Pnbm4YflM+y3YA914ZfMR/OnZHdi4 + 96TLEzx4/lDJh0oe8oJrz57JC4Isu68aWnoQMTDQPSg1komoAUrpfgOKAGBf/zBSOVvweevPGgSgyI1h + jefT8ASQPR8EvuGicB3vG8a2g71VUwCJqIHb37EM3ckMvvfbdUXjUIYM1wF8Z2SEjrlo3ljcedMSXHPl + 7Jrgl4nzF0zAN2ePQc9AuiQaKpbAhkZDIuoqoVuvX4i1W47goYfW4fHXDyNlWi5v8ENAfljA7jH5EBWF + yojwAUGgmOd5vmPn/JCVD15mCMFgKodcRu4lE0KuMmBvEFCE7uEc0tl8kXbjK8FXUFZh/prYEL8AIA9Z + UJFdz2RNbHz9EK5zVqVVA4mogU/8xUUAgPsf3oB8vrA9Fv92Fu8NsHNGl7Ft9fjgzUtw21sWVPy1ohrs + Pql0xWclaKuP4rqLpuLieWPx1o2H8e0fP+dOG/PgY0F+UAUHxbz4tAyMz1gZovBrectdbwDY73UMZvJo + apRWZYkBReQ5OzBsazqnwDx35CsDwB37imn4cUteyEcUGsuw4w1iYxj4SCnL0yQEz2w4hL9SrHYqF02N + cXzm9sswtrUe3/zpC+iyCktI+TbzHWVaFqDruPX8SfjgB6/AspkdVatPDWcGmhrjmOwsHef5VcbfAFzv + GSjICOCdLRL5mqXl5cRQKAlWPpMVJi/sGNEJsjkTmZRyd+gWpU91NGO5jVBpNVEh8NfZs+xc9TwjJAN/ + bhkajHxxXgwxSrHvYDc2H+jBZQvGV7WzE1EDd71jGSZPbsc37luDDXu6oGuap/wMcd7eIgSzRjfijvdc + gnddObOqyqiGMwdPPr8LX7x3DXZ29iHibOEdRj5kw0V2zqeV5Sfjez4dE37ZEQBSORPD6o1B1Aog359E + zqTQNeKpiKzy/DmLeouegsp70MB9Ly1vFaW1BC9CJEhfzsRTa3ZVXQEwXHfRVMyb3Irv/XotfvXnzUg5 + X0a2KEGEUOSphluXTMDH7rgcC+eOG5E61HB60T2Qwq9//zq++5u1ODGUQUQnjmxoRXzNn6uEWGY0RUXB + 0sv4nn/eosSWEWpv7sFkiIlVOpv3zGqJUCqA7mRhqyzL0ADquLkA4COUmqEhYwK6osHMVWbpeVfKMjSY + pgWTEOXzYpmmaeH3rx/Fncf6qxYMFDFxbDM+95Ercc3lM/GjX76MV7cdxUDWRH1Ux4fecwk+etOimtU/ + B5HK5rF+5wl85yfPY/WmIzAtC7qmwaKArpEiYQ/yhmV8LHtO5PEw+VuGZv+c7c9cj8Ew/LYGa1UqgEFS + PH6HrsO0LJiWhYhOkHEEVYTtHlFYhoacSW1LKSiBiE48wp8hBBHh+QwhRVqWKQld09wOObT3OJ5ZdxDv + e+vCEWOGRNTAtedPxoWzRuO5jYfx6JrduHH5zIq/S1jDmYdUNo/de7vwwJq9+O2TW9HfM4SITqDpBJbw + mUGNUJd/2XQ5uyYKpOgJ8MYQQFEcgc8rKH/ek+bLyuepZ7MXpgwSUQMDg+kJSgWgO1tDi1onwn2+KKIT + aHmvhuMrAsDVmKximqMUeGQIcfMV87coirQs076ms4ApD+B3j23Cmy6ZPuJR96bGOG6oCf45iYHBNF7d + dQJPP78bj6za7rr7PE8y4XMtNLWHqToAi9CC663rMGjBy7UMDRooLEpcIaaCtRatPlBw8VX5a8IXkjVC + kY8YMHJ55CMGijSWA6YIlAqApgpDADfYgOLMROG0KCkKaHhcHQpEuDbmTOohsHiN14R8HSxDQwR2+wwA + L+zswqrXDuBdb5LugFLDGxBBq0QHBtM42Wfvob9h2xE8v+skdm215/kBZuBsYWdeKwCXD3k+dQNwjkDG + HZlJ6zqiDs9qeQsa4FwrpHE9YUdBGKaJfMSARguzYKr8+YCfm063lYyRyyMWM5AczkqHAZGYoVYAPVZB + KJngyqL2AKQBPo1Qj8Jwg36CxopIPojIX2PxBxEy1+pnj2zAigum1ObeawAA7DnUi4ef3gYAMOrsGE1+ + OO3uddh5uAfHuwZxuD9dGJZSAoC4fMp4K0YpMqbMQ3WUgiAjTPB5AUvrOqKEugpBKUuc8AflzzyBPGyl + 4DHIEcOzjkUGqQJQBQ346GLRdQGeikuuM7DAIiNmXlEp9hwb98vKXru7Cw8+thl//d6Lw/JIDecwFszo + wNY9Xfjcj59Hf8+QMp2uaR5hBor5NM/ccH95QpoJKpeHa6xk+cLL75auAxaFBRIqf/asARQZYVbZnM/O + WdKtgE71slWe+EEl64rdixh+/sdN2Cx5B7yGNybe9ab5+ObHV2CK8xKQrmmgmgad+wHFglkuDATzsJh+ + RPM3TaR82iaVJuYB0ABhs3Mg3qP4X5XGgW7osIgGaAS5iGGnUfyk94X8d50YxHd+vRYDg1XZLaiGcwA3 + LJ+Jf/376zF7QgtMyyoWIAkfFR1V/8Ok54+ydBLeNtIZ+5oKIfNnXgHb2FX8+Up4PJ1BICxqF8iO/H9W + GT6NAGO4IKiJwaTnPMx9MX9d0/DIszvxq2d3B9e9hjcMrj1/Mr5695sxdea4wnoWBpGHZUeHdzVqARZF + jo3TA9L7yYfI2zzydXFE/N4pCJE/S5Mg6nFL8BCA12bSHIi3MqKw+wg/AKQaCwG7fF3cPWfECbovyz+n + 6/ifnz6PFzYfKZdfajgHcdmC8fjPD1+GWaMbURTlkvEtf13zjucjubz9PyC9NG+2utYJTMKiyMcLHwIt + MnI8/LwOUfE4iBjql+6UHgBpa0I6HrO1na4XuytipQS33OPSOOCvsTwipmnnzyrrnDNBD7ovU06RXB4H + eofx5Z++hL2St7ZqeOPi4qWT8YW/WYmpzfEiHnX53IF7n90DvO66c17kxsvSs7Qsb12HMZz2ypZznSkG + nu9ZHuxaThJ4L5I/oUwZlAqgta+wl1gkl3e1S07XEcnliyok/i9yXzRSEGaL2nmK+XPgXSKZK8TuSwkN + wIpFsXbDAXztgZdxtL8WD6ihgOsumoovfOJatNZHXX5k034atQozUxzfx/K5IqOlEeq1tKbppvfwt4R/ + I6aJVGO9e4/xMZ82YpqFMnNen4WXQQAe+fTAojDqYlDgpFIBWG1NdgyAE6xcxHArwirAN8AVWp+5EvY8 + X/lcxPCcM+K493W9SLm4HgIjjNNJgL3WIJLLQ9c0/Hb1DvzXD1ahe0C5O2oNb0DcsHwmvvCBS2wlEDGQ + MSKI5XOwKPHMNOUiBjRCkTEiRUJtUUc2+OEnJysq8MIuE3ye3/kyefnj//Ng+bj3NIIYlPKYUXsAiYg9 + LmHaTHCNWAV4wczXxYvjAew/13BZ5SO5PPKCBuMJkRhMFimCnLNCS6OWh+AZI+J2HI0YuP/pnfj6r9bV + ZgZq8ODtK+fhrhsXe4XP4RvmBWiZLCxKEMvnoBGbPzVqubzH+HhYNzyW3xVUNh9vUdfl5wWf8TW7x8b/ + LI2oSIrOufl+91zAqHr1dyGV04DNhLqCzms5Jry8C2IMp5EDQU7XMRyJuNeHI5FChSxqp4kYIM6zuYjh + eg65iAHK5ceIw468R8Dft2JRZAz7NSJ2BACSyyNLC+OhHz28AV+9/wV09SRRQw2AHez+2NuX4I6rZwGA + h4+sWBR52ENJ5iGwd1jcBT4xW7ByEQN1uZz7n/docyjw4EBjA3IgngA242vxyORCtPiu580Pw8Uyuf8N + TQmYam+kVzkLYDQXXGy+UN5yE+c81VjvEqAul0Mkl8dwJOL+54kUyeVBHSXA5yVOgzBisPz5slnElBEr + ls+5+TEFQyOFdc5axn4b6od/2ITP/89zOKzeK72GNxgaElF87INX4Lq5o6FlsgUX2jRhOF5vLO/wrbAu + hkhc8ByIR2bqTPuYGEwiAoo6M498POY+mwNBDsTlf96DyMdj7mwFL/CE43P2Y9cjpuleY882JSJQoE9T + ucXjmuNuoTJNk3MEzI0DaMSTvi6X89VMlNNKqcZ6j4X3jP+d/MV8gILSyBgRT34GvAEU3bDdLhox8Miz + O/FX//FUbbVgDS4mjGrA3R+5GlNnjity0YHCkNKAVxANoIjvI6DSITIL+DG3nnJyUmfmPQFBoCArNOKN + j+U4w2YAMDQC6siIodleOHWeYzJR57OyV2tqjHfKbsTrooBGXO0iWn5WGaAw/hmOFDSNJ6gn5CE+D8Cj + AV23CYWpEZm25RUF4ToGDiEAeaDltdcP4a5/f6rmCdTgYtnMDtx9yyIY9XHkLerlG45fPYFvZwjL+J73 + Uoui9ADyQnCc8PEDwM2Lz4eXFSIMvfPwTgvyfM68gNa2RjQqYgCU0gMagH2ymy1NCTQ0JVwtwk9HUN4V + AbHdf40gguIgCHuWDQv45/k0/Lw+y4cfQrBhA+AdLhDuPh94iZimpxMZgYZ1WzMundyClubwH5qo4dzH + jVfPxu0r57quP0OO4z3GU7xhrMvlkAPxxL9kxo1yyoPk8gUPmpcbzoNgz/A8zg8DqFAvt76OFwAA7Q1R + xCLyhUCEkF71LIDkIwzMyvJC6br6DlFyEcO13HzFePeIJ6wI1wUThg88AXnL71FGfN6cRuS9hwgozp/Y + jM/dcSkaEuroaA1nJoZSWeza24UXNh/Bi9uPVzWom4gauPvtS7BkwUSPtWbDR6DAnx7D6BitOlP+Fq04 + pc2eF70JAFIDyhs3BoO7x/IFiuMSdfGI8oMqlNIDBqX0ACFkuXizuTmO1rZG9PUddwsSvQFR6FzL7gh6 + wSI7Vt3RnkVHIbIpTmV4NKDCtZetLGT/eSXR0lKHv3nfJSO2f2ANI4NUNo81Gw7jvlW78Nr6/e711rZG + vHPFbNx+7Zyq7APR0VaPz33gEtzx5W70Ju3gcd6igM5NzYlz9859fmqPF3oRLD9AWDwnGjHYcgN4jaUo + dx55EozqqLqI8u1eQkifRgiRrpWNRXS0N9gWkkYUGsTvbSXAExjhG1t05IOEnPfA/vPKx73HuWGq1Yiy + OdG3r5xf287rLMQDT2zHx/7jCTy5ait6k1n3t2/vcXz1py/ikz98AZ2KD2GWissWjMddNy52z0Ury8CG + lHzsC4Cv8PP5MagWx/FDA7/nh3XDnYbnkY1EMKm9TlqHgcE0KKX7NUrpAVmChkQUk9vqkHUaRyRBQPG/ + Cnxgj/8vA5tOFP/LysxGIsiBeKZCVCC5PGbMn4RP3LIYNZxdeGrdQXztZy+ir2+4iPnZ+ZOrtuK/f/mK + 3w64JeGD15+HC+eNC8ff6pV2AORT3DxEBcIjF2BkASCay0nrEAFF++gm5XOU0n0aIWQfAGkNW0Y1uhlT + iasv/vdrBO/K+BFMFSOgiqFGBFTqIYjQWxrwubcvOq2fmKqhdKSyefz68a1S4edBIwZ+/fwe7N5bnend + jrZ63P0XF6Clpc43XZDwA8EeQZg8/OBHl0ntcn5vaoyvAeyVgPsB9MkSTe04d/bWu3nJBFxTxW8I1nBq + cLh7GM/v7XE9UT/0JrN4fsfxqpV97fmT8faVZ+cmszkQtNZHMc7nk+qapvVplmX1AZDGAVTaw+LeLzaj + 5UXSy32OPcs/b/m87wwAze2N+Pg7l9W+0HsWYiCZQWYg6bGSWV3dj/u7qrvU+64bFmL6pPaq5snzrx/v + WoZetpxEcznEmuoxWu3xrgYATdO0Pig8gLFjm9EqWUTAvgVgGTp07rPfYiNFGPWFr+eonpM9K57r2azn + eS1vepjCMnQPYT983VwsmFH7WOfZCNl0dNTMK5XAqCqv7Zg1rgl3vnluYDoZv4uGigfjXy1vFvEr+6/l + TamchFUKk1riaKpXvgrcAqBbA9CtCgRObqtDa1ujJ2jHCJ/VDVcR8J3B/vMVZxXOJ9Oe52WNyeoG9GzW + UybLy+8Znim0vOnWbfqkdrz/zWenG1cDMKolgWkzxxYFjqPCnHtWN2DUx7F4SlvV63DbFbNw4bxxyOqG + UvEwHuV5kxkq/pkcCEzTuyWZJuzam3deNpLJFZMPFdx0kQhapo3z+2TdRsB5G9AJBBahoSGGSaO8cQBG + +Khk0QMTRPafVwYi4Vg6Rgzxvhs0BHHvsWfE/Pg6ifnc+ea5tcDfWYymxjg+cNlU6Nwe+jxvsSMxTVw+ + ezQuXVj9j8R2tNXjjpVzYRDq4W+xLoDX8GUT3gAiz8fiEMDMF5QCz8+isRPLF/PmcZ6h/ChoklK6Hyi8 + DrxBlioRNTBzcptbUcvQpVZYVApMEfANkCkOXmHoulZ034xGXUUgUyBmNFrECPzzM2eNw21XzCqxu2s4 + 0/D2lfPw4Rvs7z7mQDx9HDXtaeU5k9rwhfdeMGKrO6+9ZBpWLJygNGSARAgdZcAMU9TMu/zMFAWz9tSZ + wy/ykB0DKZMbpnx4OWJHLRrBvHkTVM3po5TuAwoKYL/qrUA2E6DlTeQpcQtmVphXCLwQitafVxiiUuDz + Y+e8q8OUCX+P5c0TVyTeXdfOrn0l6BxAImrgb991Pj77Fxdi0rgWALbFB+y40luXz8J/f+baEf08e3tT + Au9903wYhBYJoMiDMjmQWXN2XTyX5QnIjaAoG+zY1hjDlLHKNQD7nNifvaTYsqy+psb4ZgALxJSzJrUh + UR/DcDrvVsbgthkWtTHgCDjn2kfNPGByVpob08ue5/9ndQO6rrkKwiUkN2ySEWvmrHG4+dJpI8YQNZxa + tDcl8PfvuwjvvHIWXtt2FAf702ipi2L+lDYsmjHqlLzXccX8sbh41mg8v9NeayB6vCI/szTidTMadY0b + GwIYjmdgRqMwLJu5dV0DzGL+5pUQXz7vBbTXRTG+o1HaDmf5f7ddLgBN0/bAXg9QpADmjG/GqKYEjiV7 + YRk6ovm8OxyI5gsV8wioaRWNY5i15gnA7kWzWTtialrQdc1zzpQHSwfYbpHu5MPSRM28WycAuO3SqTXr + fw5i+qRWTJ/UelrKZrGAV7cdBWALL+8V87zOwPMtC25HnKMWjXhkBQCsbGFVn5XNweSE2zJ0GKDQ8iaY + umM8z5ebA8GMKe1oSSinSzewP5rsIo+W5gTmjLU1SZ6SoukK1mgzGi0INDc+5yvG0vHnuiPsAFxFwp+L + zwC2ZnTdIc6topodo5g+qR1vv6Rm/WuoPlZcMAUzZ41zZ8EMQm3BdI4M4hQgO4+Aeq4zbzqrG7AM3b1v + Gbod+OTSankTVHNiBYk6ZBN17jmTG8vQQXUdiyc2+70E5Ab9AxVAQyKKmZPbPNMweUrcqQtXiE3LI9B6 + Nuu67nx8gJ0XpeViBeycEYq/J+YdTQ27BGFKYsX5k06blajh3EZHWz1uu3Sq8j7P0+xc5H1imdANzTMM + YIqA3Wfg+ZvxuBmNIpoaRjQ17BF89pxBKM6fNVpaPyfW9xg75xWAMhB40dyx0KIRRM28R+vxjWL/GUTr + XnTfURjsCMAz1lcpAtXCCEaoMXEN77pE3UE11FApbl42CZNHN0qn3pggsiPziK1sYUqOrVMxo1FQTXct + O9XshXVU0z3TgtlEnSvwTAmwKUZ2no/E3HzHdzRhxjj56+7OOwDu4gBeAaxlLwiImDOlDW2NMY8lZxDH + 87xHwCBdJOEIOzvy+fFDAd7iA/AoB9dV4ryMC5ZOxbzZY043j9RwDmPixFZcet54dyYiCGY0ao/3Hf7n + LTZv4JjC0LNZd92DZegwcplC3C01LD2yNFndwJyxjRilfgdgA4BudsIUAFvsvFr2xJRR9VgyuRWmaXlm + AACvS++5rmteN1/XilZAyaYGVfmxNJ6ZBvFZXcMtSyfU1vzXMKJIRA2889KpSNTH3Hn8IIjeK7PwvPCz + Ix9L4L0DqnnfDWDn7B4bls+c3Ba4AtDNn/2xLGsGuLEBDxYHkK3+k7nnYqCP3fdLz66Vmh8jmmlamDWm + ERcsnVzFrq6hBjnOnzsGSye3BnoBYgCcDQW0aMRznwXzRKiGvyo5qYsbuHaRfAGQM8Rfz19jCqBb07Q9 + lNIEgJOyh6+YOwZGfdyjbfKRmOvuMxdFz2ZhcquYiGUWghrc8IClZ/f5cRP7z2vCrG64+fHnPBbPGYvp + HbVlvzWMPNqbErhq8UR3BV+eEuQpceWDXeMtPAv+8TLBW3Te2vMRfwZmCMV3B9yhhWlhVFMC8ybLA+DO + EH8/f42PAbQTQp4EsF328Lw5YzGqKeEKnRmNQjfzdoDC8QzykVjJ1wF4XBwe7D5gRzYNQkE1W0kYhELX + Nfe5uriBm5dNPH0cUcMbDlcsnojGJnuszQ+N+Wg8g4zH+f/u0JeTL97A8fEDwFkLI3nHZuGMDrSr179s + ADf+B7wKoJtLVITpHQ1YKLxSy09XUE2H7gg2sUxEU8Pu+IS/LqZnAi0SJR+JwchlPPdkhGPEmDq+FUvm + jq2wS2uoITzmThuF8ya3upafBaqppktjAzI+B6CcLWP5iXBjas6RHxpcObdDFQNLQhLjk5WwGootwq5Z + MA66rrnRSyakYiAD8L4J5ZeeWF5Xh50buUwRoXhlwa6z84VT2mpv/dVwStFWH8UF8wrvHzB+ZitaZXwt + 8rs4rc0E2w/iM8xb6GhJ4PI5yhmwPsuyNogXixSAk6hPlsMlc8egrTHmjm2YBWdg/3mrz85V6UVrzueh + yltMr+sa3rJsUtkdWUMN5eKaeaNRF3c+4sHm8iWWW8W/fpuGqKBKP2NiK6ZNUe5etN5Z8u9BUU2dROtl + OUwd34yL5o3cG1flwDQtTGivx5IR2AiihhqCcO35k09OHd9aFJA+1dB1DdctnqB8KYpS+ozsuurLQA/L + LjYkojh/ertybHK6sHBGB0aPqr34U8OpRyqbH7XwNBsf07RQVx/DZfOUMbBOSunvZDdUkrwegPSjoW85 + f5K9KjBga6JTicUTm2uf+arhtCARNXD+vLGn3SieN7kVC9SKyH3/X4Sq1muhGAbMmNRqDwOEyCWAwvy/ + XtpKPNlz/H/ZTABDXdzAeSO4EUQNNQRh8eRW1NXHShoGVENGXESjuG7xBOXqP0rpwxCm/xiUtaCUPkMI + eZt4PRE1cM2CcfjD2sP8nhzQzbwb+NMlKwZlDRLT62YeWn0cVjLtySMVTyAuRj6d50c1JTB/8pn95t/A + YBqDmTwyqRx6M4V2xQgQq4uhoS6Kcc3xZCqbr68tY5ajJ5mFmcmhL2NiIJlxr8cIoNXFMH9c08meZHZU + IqKd8qXgs8c3YdKoBmwdSBXdY3zK+JqB5+90NOryd1B6/jmWtqMxghVL5UHwgcE0mhrjq1R1V1KKELIK + 9jCgaF3hNYsmYHLL6zjYlykSdl6wZecyAvDgG82Ik0in3Ogpy489P2dsI8Y1K9c9n3Kksnkc7h7Gzj0n + sO3oAHYeGcCBrkEcOTGIlGkBpgUtnYFVX3hZo6O5Di0dTfWT6gzMHt+ExVPaMH/6KLQ1xd+Q7zWksnl0 + 9ySxoXMA2/d2SWkIXSscAbTHjFFtk0aBp+GMaaMwrnnkaVgXj2Dx6Dps3Vt8j/Ep42uZPMSzWVcJiOkZ + ZM/pZh6mbuCi2WOURrCpMf4d2B69FH6UWUspXU0IeZ94Y/qkViy/YCp+8eQO1yXRzTxiEQ3Dll3ZOs3C + sKW5leQrrCIS03p8+ng2i2gsgkzOconE5zFzctsZISR7D/Xi8W3H8ez6Q9i0pwsnB1IYtlQjLAMYzLlt + 7OlLwdzbZc8BO7RrGdWEK2Z1YOW80bhg6eQ3xBLnXUcHsH7TYTy0vhPrD/Wh7+SATcNs1t4Yw3kr1O5/ + x//MpoBoFF3dSeBkwQLrZh5jxrVg6aQWXLNgHK5ZNGHE9ohIRA3MnDEaWHcUJiDleVF4GS+Llh6A9Fnm + FeTS+aL8r1kwzk8G+vzq7is5hJDVAN4nu3fDskl46OltAOAyOhN4ABhGYcyisvZ1muURbEYI0T2KUe/z + OV1zXaapk6v71ZZSkMrm8cLmI/jNa4ex5rX9ONiX4e5qqNPsMWEmZ7l04DuOwdQN6Ch09jAMDJ8Ywv+d + GMJvnt2FWWNex4rzJ+HGq+bg/CktZ4TCqyYN1+88gUde2oeHNxzB8aN9No0coZ8/sRnTxjTi8S3HYAlu + sKkb7o45uq4VCd+RE0M4crgHj72yH2PGteDmJeNx8/KZuHTumKoPt6aPa3aNHoPI91p9HHAMnGvIHJ6P + OPEDfjjA8mB8YSXTiNTHYSULHvCsMY1+n7zrBPCQX719KWBZ1ipN06SbhV46axQWzRyNV7cdgw5v8IN5 + AnxH8R4Cu55xlDhrcCyiIReNYjhnudfi2SyYWPHXAKCuPoZZo/w/3jgSYIL/oyd24NktRzGY9gYp6zQL + N146A231Edy39gjM7iEPM/B0sZVgvigmwiuM7Uf6sf1IP+5bewQ3z+3AnW+ehyXT289qRcAE//6nduKP + aw8WaOi0e9b4Zrz9uvm48ZKp+PJPX7Ytn/OsOAwEbN5hdPTQ2RkiHDncg++dGMLPn92Dty6bXF9tGs6Z + 0ob6eASZwUxRwM5VSo7ws/M6zXJlgLWlLqLByha8YaYQRCPJsOL8SUrv0PHg9/vV27f1zqKg1ZAogPam + BK5ZNgUv7Tzp0XymbmDYKnQUg+q6bubdxg1bGpDOI8KlicQNWMl00fDAyGXQGjcwbuKp9QD2HurF1/+0 + DY+u2V0k+AAwb/YYfOmm+bjuoqknr//XJ0elu4c8bRaHQcOW5jKpKjLMppjS3UP4yQtJPP36Ybz7mrn4 + l/ddcBLAqFNKgGrQsGsI//PwRvxmzR509aU8+941xnXcuHwOPnHjAswf14RfPb4Vj2855tKHCYo4HBy2 + 4NJRpKVu5t0yBtMm/m/VDpeGd71pblWGV2Ob4+hoa0DPYEaZRlQMw5aGXNSwhZ7xtiPgwzkLcRQ8A9FD + MHUDHXU6bvLZ+5JS+gW2+68KgeqPUvrw4FDm47IphndeMAn3P7UDR04MhSKSLAbAa7iIaRVZv1w6j1w0 + irigPfOUoHHKGExuDP5qbDWQyubx4KuH8N0H12Pr4f6i9jTGdbz/yhn4xC2LMWFUA77/8IZRL7+2DxAE + 3y8eooqR8M/UA+jpy+F7v12PVfv7R33p+lm49vyzYw+EVDaPP71yAF//7UaXhrzwz5/YjH9634W4dqE9 + pu08OYRvPrbdM+41dQORuAHdsY7NNI9hSytyv31pHo2iazCH7zy8CU+vPYi/fftiXH/RlIq8gbp4BC0d + TTBZu7g68K6/rI95q87u8VafPc9khOUzd9EMLJ09WlWlToRA4OoFQsiTTY3x38vuTZ/UipuX2J9iShP5 + ziiReKGxWn2xEmENipgWInHDdY14ItVFNM95Tteg6xqmGtYpWYBxtD+NL/70Zdz989c8ws8wfnQD/vOv + LscXPnAxJoxqwN6uIfzkmb3KdQ38eU5htVTn/G/7ur147w9fxjd+vQ6q/RzPFHQPpPCfv16Hjz6wriD8 + HN59+TQ88OkVeNuySa4g/nLVTjetp//TeZdnco4CkQVcRfrx/JfT7XjV1sP9+Nh3VuM/f70OPcnyF7Yl + ogamttvDUV4WmBFTzeNHTAuxiFYkG1p93JUNvr18vn9x8SQ/pXWfbO2/iLDS87Dqxs3LZ6KjMYI4td99 + 5gUesDuLYThXaECdZrlp2ZGlZZ0pXge8LlBza/2Ij4P3HurF3d9/Dt97fCeYO89g6gYumT0KD/z1ZXj7 + 8hluXR5/YbeUyWVwXTyBbnWahZyuIafb1o2d62YekbjhKsvciT586dcb8fe/XIfOk+E8sVONvV1D+MT3 + 1uArD28pomGdZuHjNy/Ev33oMk+UvvPkEB58cX9g3jxvyOjIX+PTMuECbH77ysNb8A/3voC9XeXTcGq9 + Y70pDUzLAsSsfLEd4rmIS2aPwvUL1Ut/ERD8YwilACzLWgVgs+zekuntuGZRYSMOXshF8BqMb7Sqsbl0 + 3mMhWR6s42a0juz8/9rdXXjvD17EH9YeLrpn6gYuWzoJ3/vIcpy/oLBUoieZxf2vHlF6REVt1DWkCXFp + wJh12NJsr8i0XVt2no5GYSXTRTT7xZM78Lc/erEiBh4JbDnUi4/d+5KUhvH2Bnzq3Rfic+9cgjbhM/SP + rjscWonydBPpyF9jQidTEgDwf8/vw8fufQl7D/WW1dbmjqZQ6SJxw2eKmGuLj3d765Wz0N4k3/iTUroa + PnP/PEIpAMeVeEh2LxE1cNPyGYjEDaQJKQQrHAFgR1Vjgq6z/Ng5L1iNY0ZuBeDa3V342P2vYtvO40X3 + 0oTgsqWT8N0PXVI0t/zi+oPYtvN4kRXg680zYMS0EKfUbZ/MovFtd91CSeDwwXWd+Ni9L50xnsCWQ734 + zA/W4OkNh6X3v/iWWfj7WxcVeXFDqSweXnvYV4mKQjyYMZEmpMBvzLhw/MWETmVw0oTghfWH8NEfrMGW + MpTAjJa4m48fRCNZJCtMiZnydPMnNuPG85W7XyUB3B+2zqUMoB+CIrDwtmWTkhcKrwkzAdA1gpzuWC9C + XLeW/SKm5WFw9uMF3xUOXXOFJRI3MKF+ZNz/LYd6XeHnO5PV7epZ7fjPOy6SRo9/v/WElxGduscpLbTf + 8WxERSBDLp137+maN0/mPTDoGsHTGw7jb3/0Irp6pHu6nDLs7RrCZ3++Fqt3dbttZ3XO6Rr+8T3LcPv1 + C6TPvr7nJNYd7PWk59sN2ELE39M14v7466ZFPfmwH89rDIy3Vu/qxmd/vrZkRVpfF0W8vcGj/D2eCFd/ + vi6szuw5WXvThLh0vOWKmX6b36wihKxHSJSiANYC+J3iXv3Hr5iKxpjua9FlYyOWfjAWha7ZjYw01Sm1 + qCtQoIjEq/8GYPdACp/9+VqP8PN1md5Rj6/ccQlmjSt29/Z2DWH167aOZJ3K6pwmBI0xvXBu2MEdlvdg + LOre45mUP+fbzyAyvK4RPLiuE//8m41IZYPfyRgJdA+k8Lkfv4inNxx268fT4/YVs/DRlbOV8ZvnNh5G + n6DA+PaLNPDjOb5ckW5MoYr5MkX6xQdeQ7dkfb8KsXhhRor1Zw/19pufW88rraKhryMT08a34MbLZ/hV + Q/nijwwlhdCdt4qkXsBVyybjwnnjYFrU1ayMCCJRPA1zxrmNmSzShjP2GRhGnFJpeh4T4tWdAUhl8/iP + R7fg6Q2H3bJ5pdXSVo9/es8FWDazQ/r81oO9ONA9bDOdJA40nLOQNgyYFkVjJovBWNTt2MZMtqBwGB2i + BYZi10TIytE1gp+s2oX//MPWqtKnFBo+uK7TK2DUZuyrFk3A//eOxco31wYG01h9cKCojbnguFpFSBuF + KHvaMBCnFD95YT/+49EtofNoqo+hTYenP91+Ni3XGwlCLhpx6+MahgH7y1d3XjAe80cr975YA7WRlqIk + CSKEPOkEGIrQkIjiw1dMQwu3I2ljxjutEs8XWyTWwMFY1CUWQ4T7nFIRkeoTIFWeAXh09U58e/Vet+68 + EkoTgg8tn4b3X65eePHi9uNuJ0ckDkzaMDz5NmayHmUXp9RNI9JLRrscLS6HMZppUfzH4zvw5y3FMYyR + xJ9eOYB71+wrEn6NUkzvqMc/37rQ96vNh/pS2N/pHX9HiJyelYL1lch78Xze/X/vmn347ZrA2TQA9nQ1 + jUTcPPl+DjJmDIOxKCLZnPsMbximjW/B26+Z6/f4T1CC9QdKVAAO7lfNOV9/0RRcO7XFPZe58aIl4xvK + 4I6FohGXoXnGNi2KNh1IxKu3CGjLoV788592IjOYguW43sOa5iqhpbNG4/95s5r4qWwe6w72AbAZi1l6 + 1l7ek/BjCp75ZODpoFFaRE/m9uoaQU/vML7wy7UlubGVYG/XEL722A709SRdi502DESI7ZXcccMiXDrX + /7Nt+04M4UD3sN0HUXX/qjyiUu4zOsXzdkwmns8X+M3p976eJL722I5QsytRTulFsjl73M4pbl0jHp5Q + wY0J5PMY1uz+tAjBnVdOlw49HWxGidYfKEMBEEKebGyIPSC7l4gaeO/KuYg01SEXjbiujNhgRoS0Ybga + bzAW9XgDvJDkohH3yJiiPxJDrEpWIZXN4zt/2oY9R73TTmbEWafQVIcv3TTfd9fh4XQOfV2265qLRhDJ + 5tyj2E7+mItGpLEGBkYnRkOeDowWvLClDcN1mc2IgbW7u3DvU7uqQ6gA/Ojx7Vi7u8tTLz2XR44CVy2a + gA9fGfzJ9i0He922smdZm/j2sXus3fyRWXZe2HgaiveD6Lt+1wn86PHtgXXXDA0tznQme5bve9OiHp7g + y+fryl9neSyb2YH3XzHdr/hvo0TrD5TnAQD2NIP0C0LXLhyHm86fhEg2h0g2Z2tVR5syzcqIwO4xYrF0 + zBtgCkHP5T33AaAJFrRIdYYAz+7qxm/X26EN3t1k2vum8ydh+RL/j44c609jb8r7bgBrm+vSc15AYyaL + SFOdp/0AN/53xsx6Lu+hoUiPeD7v1pelBWzhZ//ve3Yv1u7uqgqtVHhx+3Hcu2afWw+N0oICJcDH3jSn + aK5fhv1dQ4hkc+7zEWLnx9rD2u7J3xGoeD7vETLWh7xFF+8H0Zfh3jX78Pyuk751J7p3x1/Wr2zYJxqG + XDTi9pGukUKdKfWUHc/ncceV0/0MUMljf4ayFIATC/iz7F4iauDu62a6sYC0YbieANOq8Xzec40RmxGG + Cb7baRGjSFCqhVQ2j289sgk9vcMwIwbS0VjB2kRjaGmrxydWTA9ccXisaxDJPC1YP95CczMd7F6aEOQG + hovaD9gMY0Zs2pgRw0PDeD7voYdowZjLzf6bEQM7TyZx79Mj5wWksnn816q96Okddq+xvjQjBm65cjau + XRi8bVsqm8f+7mHP82J7mODz93lr606Vch4ozzfi/SD6sme7hrL47pO7fGdWqFlsAFi/i0Flvv7xfN5T + T3EIuGTBRLzzkil+pCt57M9QdhidEPJNKGYEls3swIeWT/MQgXkEADzRUHad18riczKiVgtPbTqK5/b2 + uJ0Oy3Qti57J4NpFEwPHrQBwNGW6kVqxzWnDKLrGmItd5/+zoUAkm3OtETsXvSg+TzNiAJpeNOSKZHP4 + 7frOEfMC1u88gUfWHYIZKQgoq2NdPIL3XjQx1JLtXCaPfot4LCRrj0gn0SCIvKXiE/F+EH35/4+sO4QN + e/3lTEvE3LxEz5bFBcT7fJ1EGYg1JvCPb5mtXPWHCqw/UIECgP+6ANxxzWxMn154U8ljEbmOE6+L/8Vn + vGPfyoIAqWwev3jlsCu4oocRa0zgvReF+95g0ix+Xqx/JJtDtrGhKA3P3OLR5IY5QTRhCkxELhpB11AW + v335QEX0UuFnL+zHcFrehiumt+HK2R2h8slRit6hjLcvnPaoeIa/JjsG3Q+iL/9/OJ3DT5/1nxHoMQse + hqxfVTIgu5+LRnDT+ZOCvKdvoUzrD1SmAGBZ1regeEdg1rgmfOr6eUq3XWXh/cA/MwANer4yb2Dv8UE8 + 9fphaR31XB4LxjTgshDWHwBoOlPU4SJy0QhIpvC+uJhe5gGpaKDK3y/NbzefqPoKwa0nkli17YSyjjcv + m+j3rXoPspSAprOheSKIh8LeD7rGY9W2E74zAiRVmCGT8UEp/N7REMXd1830856+DMn3/kpBRQrA+aT4 + T1T3P3LltOSb58sFSKWp/SCm7bcq8wB+v/kEuoYkr4BqOsxYDLcumxgqcAUA/SYJ3RaWTuYNqNoadD1M + mh2He7Fqb3kvuqjw7IZD2NmTBrhPXrHyOxqiuHLh+JLyI/FoyXQMolUptAwqe+fJJJ7YJh9KZUN4pKXw + +2feNEe56GxgMM2+9lO29QcqVAAAQAi5D/Y4RIb6z71jCToaHCESvotWLnLRCMx0BjRT/vvbqWweqzcc + kt+0TNRFNSxfEJ55m3Vacvt4b+BUYdW6g1XN79k9vbabLhl6XDhrDKa1h9+yLUpGeLlflfCMs0MRYPMR + +1m5PGg6W6TYy8Elc8f6Tvs1Nca/Qwh5stJyqrGWthv2OETqW14+axTuWuksoGFMIgoKf+53T7jWl1Z/ + MCQIe48PYt0xtTu8YEwD5o0P93onADTUxwp182tPUHtlKCW/gPSr9/VVbWFQ58khrNupXml4xbwxJe3X + ECEErQ2xYBrw50Ft93surMIW0q0/2CulIc2bGIBWumIX6lIXj+Af3zIbbU3KodNmZ/hdMaq1mP5BSulD + qpufXjEdl8zlNi/grYWme89FJSH7KpBlYigPDGXLVwBbjicxNKz2IJZObgnt/gNAR0sd6qJawRqq6h/U + XhFh0oehp4NDJ4ew/Xh14gDrD/Ri58mkVKjq4hEsn1nafo1NjXE0axIvQGwTfy7Sl6ePzDOxSuQZSdmH + Tg7hRcmagF/tGsTAUIk7Mwn1pLEYPnn19KDA37fD7PYTqvhqZAL4Twt2tNXjC7cs8A4FeK3Hn4vXHdBY + zHN/mBIke8t/733DgV6k0ll52ZqOxVNL++DjxKYo6utiwfUP0V4aE6xgEH3C0JPRLWth0z7/BS1hseUg + F08QLO+kUQ2Y1NFYcp5T2+u8dPCz6D7tDHVfliaI/gCGsxa+/LtN+POW48hl8shl8nj09WP4n9++huF0 + zn1ePHp4QZY/gEunteLjb5O/Ju3g96hg2k9ENd+mWUsp/RYh5Ouym28+bwzuWjkX//aI9+0qGjFsl4lp + Qv7IEchNw+HEcHmzAKlsHq8f6FVa3bqohmkTSttsZGxzHG11EXT1DEndTk/9LRM0FvO220kHAMSZm2aM + 4ksf3tPwc2m5Z7f0VuejrhtVQyjLxNSmKDrqSo/5TJ3UDlj7iujjnvNtVrWxVHDWl2RMtxwl/QG8cmgA + t33rGSwY04B+Ezh4MolUOuvWUzwW8s8UnQO2x1Rv6PjHt8xGS0Iplp2U0m8H7fRbCqr6Pq0TEPy96v7d + 183Em+d6d7H2CIZsXKcY65FMBgcHy1MAw+kcTvaovYemhjgmlbhVdHtTAlObJEMGRZuK2i2hAcnlg+kj + lqMC9+zuvScq3isglc1jf8+w/KamY2p7XVn7NZ43ug6JeLSo3SSXV3pXDEWWNSSYp+Epw4/+DoazFl45 + 0Isdh3sxTImnXz1HWRucc1bnJNVw18q5Qa7/fdUI/Hm6qpqZwQ4I3gPFUKC9KYF/vnUhxrZxkWHZWDnM + fwC93YNlVTKdNXEwqRaA5riBMWXsNbB09phixvSpfygE0acM9FsEqVz4L9nKMJzO2Yt2FIpnapl77U+f + 1IZmMRAYxA/OkeTKU2q+z4UM0pJcvtgDcTyXonrzZTsK4ob5o/GJlbP8SlkDO9heVYzEntprAdynunnp + 3DH45+tnIxHVQSOGTaSI4dHeNBYLdX1/93BZlqwvZS/5pIqXiVobYoiE3NSTx2VTW5CIehlGVX8AnvJl + 1wAE06HUF6IsE71DGaRSlQ0D+jMm+n12rm0uIYDKY1pLDItH13kEqYgfOBqKNC4XPC/yR7EsN62kbBnf + smGAp958/gDGjmrEP711jtL1d16//xYqnPOXYaQ21f8WfIYCt189Ex+4cILHBSKZjIco7niYXeeIzMZR + +wey7hLUUpDO5JEcdsZhEiFs1igisdLd10UzRmPyqPqCYLKxJf9fHCM6afl2yhRjEX0kUDGq57qm+wpu + WKTSOekON6w97rRoiUhEDVw9d7Sbj0sbQaBcwYoYNh+pBBhq5aoqw5M/Z8E99HfOxX7xxCqAonp7yo/F + kIhH8YVbF2LJ9Ha3/fwPAJoa418G8GDFnSbBSG2qz4YCSyH5vHgiauBvb12EjV0pvLT9mEtoWfBEFkxh + xOsZzuG1QwOY1GF5FgURQwfNm0X/AYDEoth2vDD+dwNuDiMBtou89/ig+7wMNG8W3aN5O/i143BvUZtk + wSDZNb59Yeggqz9jdHYuurimRbH5eNLeWJOru6q9Ii2jho4dB3qKlCgbM9NYDJ0DWew91AvT0FGSitZ1 + TBjdiHpiYThreRReUHCNP7rXc3kPHXg6uW57BfQPUx8xf/7/B9+2EO9Z6jvu/z1GwPV3aUpDfMSgAnxo + YDD9Q9Va8Od3ncQ7//sFHB30uqNFjCzRngyj6+2llfwWVAymRd1dWPj7pkVxIplzy+IZmEYM1BGKhrqo + NF+Z1WNlAEByOIMk1bz5CvWXtSdMGmk6Sf397rFjfSKGeu7jFCJ9ZOdmOgM9HiuioazPRkeo57NfIr1U + /cPoyOcdlibKo9B28VgR/SWKx+8ajxvmj8YP77rI4/oLgdNOADcj5B7/5WCkFUA7gE8B+JwqwQ+e3Ye7 + f/aqLTRO5FTJ0IoO9kvraSzreJ974rUgFDGSn0D6WDDfeodIJ5bL6uZpt2AB+TSquvspXz/aiTQUy5XR + TyaY0rZK6BFUN+UxpHIO00/S8hX5zZnYigf/ZnnRUmmmAFLZPOIR/W8JId8ILKQCjPSH9boty7of6ncF + 8JErp+Fv3jIPANwxHQOvnVVjNJfIXFo+DX9NNn5mLqLoGrJr4viRHzfy18Tln2KdgsaYsuWjMlfTzZtT + fCrB5t1fHmL9xTSy/Pj6iEex/X5LYWX0U0bIuSGFmKdIt6K+ltSDVyzusVL6S8oLStfR1oAv3rbII/z8 + mB8A4hH9gZEWfmDkPQCbeJSuJITcD0k8ALC/BPNX96/FL9eG+qBpDWcowlrFNzJGRyg+c9Mi/M213r39 + Bdd/jWVZd1Rrua8fRv7TunC3EPsWFC8MNSSi+Po7F+ItM1rKnsut4fSjJvzBeNfVc4qEHwA/nd1JKf3i + qRB+4BQpAABw3Bnl+oAJoxrwL++7AHNKeAOvhhrOJrxn2QT8y1tn+yXptCzrqlI+7VUpTpkCANwdhJTr + A86f3IJvvX8Z5naEf4e8hhrOBtwwfzS+duv8ovUlwpz/fY7lr/qCHxVOqQJwGncPFNuIAfZLQ1+8bZE7 + vecionuPKpR6P6545zrus40Vf09VXlB9g+oZVA/xeVl+/LV4yE+pn2r6jVT5KnqEpbsfSmzbxfPH42vv + WYJ2ny8iUUofwAjO96twSoKAksb6BgUB4AcvdeLuB9YhmRqhXXMiOpCrbE192XmHKTts/RhDs7TsuZFs + Xyn1O93ll0uPsOnjcSCt3gPg0mmt+M5fLsO8sfJ3IxzLf8qCfiJOqQfA4LzR9EnVJ8YA4COXTMA3bpyF + +gQXWOKtqp8ml1k+do2dM6ZQ5cvnobqmeo4XRr/7snrzAh2mfjmzWPhltJC1J4z1PBX0G8nyZbT2K1ek + f1DdmfBL6jy3ow5ff9dipfA72AzgU6dD+IHT5AEwUEo/OziU+brfrrHff3w7PvvoLiTZN9ZkDK6yfgHa + OZSWD5MHQxCz+Qlq2PyCUKrlEhmef/ZU0m+kypcpApavLH8Z/YPqIWlvR3sTfvaBxbhylndXJHGlH6X0 + jmq/4lsKTosHwEAI+UZTY/zLfm/03X71THz+rbNRzz52wbSvSjvzMHMFixGP2+lEi8Lu8en4a4xReGsp + pmXgrZTMusqsCKuXzCLK8hPrJ56LNPJrlwyidTuV9BuJ8mW0ZG1n+QfRX6yHeOSfT6cxt6MOP/vAYrz5 + PN8t5TsB3HM6hR84zR4Ahy+lsvnPqTaQSGXz+M+n9uBLf9xpxwRUAs+7haInAHgtHv+MCJmAqKwGfy4b + j8vOxfLjcVtZ8fUvpX6yc5Yff0/2XzbkYP/1iJf5R4J+I10+n6fYfpZnEP35tLK2cM/P7ajDt96/zBV+ + 0bglogYGBtNoaox/GMC9OM04UxRAO6X02+mc+T6/XWS++qcdpSsBkRlEYZQxGSBnWP4an5YfesjqIN6X + 1VlWP77+qvox8AItc11V/1VDlFNFv5EuX8xPdi8M/VV05o5zW2Ie4QeKFUAuk0djQ2zE1/iHxZmiABi+ + DuCzfgl+8Ow+3P3rzYWYgB/8hK4aqFb+KuURBnrEtj4jkf/ppt9Il18t+jiW/3/+6nJcMa3Z74kkgG8C + +PzINyocTmsMQIRlWd8H8B2/NB+5chp+fPtSdDQ5c6p6xO4IPVL4sevxeOEen0ZMH5TGL/+g9CqI+cjq + rGofX18GWfnsWGr+p5p+lZQf9D+I9uXSH3Cfu3j+eDzw0cvCCv+3Rkh8ysIZpQA0TdsTtFoQAN51wUT8 + 9/uXYm5LrNj9S6cLbiGgHnuKgSD+qIoQy/I3c/75M4jMyFttPk++PbyAq+rL0oljWrHeQfmfLvpVWj5P + TycIpyyf9QOjPTuWQn8WWHbyWXneOPz4PQtw/uQWBIBZ/lO2yi8MzrQhAEO7s/3x+/wSPb/rJO7+ySt4 + +ZizO62M8cOugAtKrxKsMPmbuQLj+XkFqufC1Jf/H7YcPl0l7SuHfmIdyy0/qK38fTFtKc9Krr/nvHZ8 + /Z0LMWGU7zw/b/nPKOEHzlwFANibidwP4G1+ibaeSOKTv9qEJ7f7fOwiDLP5pQ9CqfkHgQWZSmFWMU2Q + MIr5V7N9fnX1E8hyylflV2oflkCfekJx5/IpuOf6WWhvSvjllKSU3nOmBPxkOJMVABDSEzjYl8G/Pr4b + 3392X+GijAH8NDoQnJ6f8gmT3i9/0StQPauynKUKT5j01WyfH/2qXX7YNHy+ZdK/oz6Ku6+ego9dPQ0N + Cd+dj8+4gJ8MZ7oCAArbin0agPJtioHBNL635gC+9GIXkkeOFRjJx4ULfV2FcvKpxDKFqQ9QvfxHgn6l + tD9MOdXqyxCY26jhS++9EO9Y2BEm+Rkxzx+Es0EBMHxpYDD9Ob9lw6ms/Y22Lzz4OrYPVvbhixpq4LFy + 7ih89aa5YYJ97MWePpyBY34RZ5MCCPXuAACsO9iHv39ku39cgIcRAfK5wpG/Jv5XPQ/4p6k0fVD5YfNS + PVNKHkH1H2l6Vjt/n/RsvP+Pb5mNcc2BcZ3NlNJPn+7lvaXgrFIAAGBZ1gxN0+4HsNwv3dH+NL7y2E78 + +LXjGBZfKZYxkHgvCH7pZAwclK9qpV6pZYv3xbaGebGl1Pr7CexI0bOa+SvSdNRH8aVbz8MHzh8T5juH + a2APVUdsC++RwFmnABzcBntjkQVBCX/12mF8ftVh7DzAeQOGMDYMw+jlWpug9EHr+sVn+TrLLJnqfqmC + Uol1HUl6VpJ/WM/LiGDlzGb88w3zghb3AHak/yFCyCdxFrj8Is5WBQAAyxx3631BCbceHcCXH9qCX+4Y + CMd0PKPwAikTKD+BCZueQeUFBAlymPth6lpu/YPaVk16Vjt/wRh0xAjuuHIGPr18QqDL77zU82WcoXP8 + YXBGrQQsEWsdrftlv41FAGD+uCZ8//1L8e+3nYc5oyX7DbLPYbHpHkMvXMsLq+UYk4luNZ+HJ03AunL+ + tVLZSy0iE7P82PUw91WML0sjekdh6u8Kql6oSxA93TJPUf7sGbG/OFw8uRE/+8BifO2GGWHG+53OG31n + 3Oq+UnA2ewAunLjAM/DZYozhtcMD+Nzj+/HcNic24GeRGUShZNdUY2lZev4Zmduvyj9o+JA3g+8D6iGD + yurz6cLUn6+Hqv1h8hmp/H36q6M+ig9dNA6fWDkrjOADZ+l4X4ZzQQG0A+h29hn8AgKCgwDQk8zi15u6 + 8M3Hd2BHD2ddVEtrZevdZRZb9koq70Ew6wN4BdMvT9dK68V58cIq3i8VEndYmkasP6MbX88w9OEV3Ejm + z/pBkeaSqa24Z8XEoM07ALgu/3csy/rW6drCq9o4FxSAC8cTuCNovQDD1n+UEVEAAAelSURBVBNJ/Nfq + /XhwbSe6ktlgAQAqFzRZfiqBCPNc2PQjhUroEebZaufv0G3M2DZ8elk7PnzlNLTVR8PkthbA9wH8Dmex + yy/inFIAHD4E4JMIMUuQyubx7K5u3LPqMF7a3xtsiUWwsSRLXyqzMkEG5FZLlR9vLcVnKqlPuVBZZr4u + smMpCkzmpYShP1ME+RzqEjHcuHQC/nnFRMwfF/ojNL+HPet01rv8Is5VBQDLsmYQQr44OJR5XxhvoCeZ + xf3rTuAHLx3GzuND8kR5s8BM/FFkePG+eA0IDn7xecry46+Lz6jW3PNli/Xwq5/YDvE5Pk9Vu/zeAwjb + vjD0l9U/nUZdIobLpjTiI1fNwA1zWsPM6wP2vn334SyO8gfhnFUADtoB3ApbewcGCAFgb9cQvv/Kcdz/ + 7B50mZo/U6vgx8jlCoks/3LqxucB+OcTlH/YdpXalmq0j2vjxZMbcedlU/DOhR1h3X0AWEMp/eLZtKqv + HJzrCoChnlL6g6A9B3lsPTqA/3rukB0fyHA0kjG8THArZd5yoPJIysmDgXetS7HSMsiGKqXUR/Vf5oEB + mD2hGR9c0Ir3XDoVk1tCf7j0nLf6PN4oCoAhdGwAsOMDW04M40cvHMKDW7rtQGE5CKsMqiHAlZR7OhFm + aBSynnOaNNy0bAr++qIxmN7REJjeQRLAKuf183Pa6vN4oykAd6YAwJ0IOSwA7PUDHkVwJgjNuYRyXmhi + cPpiTpOGv1oxG+9Y2FGKxQfsr/N8G+dYhD8M3nAKgMFZN/BJACvgs8+AiK1HB3D/ui48vLXLDhaeKYrg + TKnHKa53HaFYOK4e77pwMt6zaBRaEkbYAB9S2TwSUeOcmtcvFW9YBcDhNtirugIXEPHY2zWEh7b34dcb + j+P1Az0YpqQqlWlurEP/4HD1n4tEgVy2+L8fRuI15KB8wqzMBFBfF8fyqU340IXjcM305lKCexgYTKOx + IfbA2foCTzVRUwA22imldxJCPoUShgWAPX349N5+/GZTF1bv7cPxPkcIZW/x5XNe4VMxuSigovACamH2 + E3RZPnxesnoE3Q/7rF9deFrwNJE8M7stipvnd+Dm2c04f0pLaGvPYQ3sAN+DpT54LqKmADiUGx9g2Hp0 + AA9t68WjW09i04kUksPh3ulXWu8gqy27HzadqiyV0Afdl5UVpp6ioiSk6PqYljpcPb0FK6Y34/q5o0od + 3zOsAfATvAHH+X6oKQAJKlUEPcksXt3fi6f2D+G5fX14qTNZLACC9fcoAV7IVIItXg9zZHnyCFIift4H + d99XifmVq/CC6uviWDg6gRvnj8KbZrfivNF15Vh7oCb4vqgpAB9wiuAWhJw6FCEqg00nUkjmLJf5mxMR + 9A8OFwRIJbhA8Tm7xi+PZRZUli4SME72K0+8x/iGkOD8/e5R6g6NmuMGLpnUgCunNuNNs1sxvTVe0tie + QxLAetQEPxA1BRACzrLiWwkhN6PEYCEPpgzWHk/j2f392HBkqBAzYAgSUhF8/7EYQxBUcQCZ0hGfY/c4 + wS0XzXEDY+o0LJ3QhIsmNeHKaU2VWHr2tt7vATyMmuCHQk0BlAa2tPjmgcH028K8Y6BCKpvHvr4Mth4f + xlPbTmDDiTT29WVwPCn56KlKKMux6tVGUP6Uul5JfV0cDVENS8Y3YNGYelw7tQGzRteXslhHhU4A91FK + nyGErEdN8EOjpgDKhLOO4GbYCqHkOAED+3y0aVo42JfG1pMZvHJwAK8fT2Jf9zCOD1voT/t8CZkJ2GlC + c9yw6ycZLvAWftHYeszuqMP8MXWY1hIr28pzSALYB+Ahy7Luf6PO41eKmgKoENzw4CoAS1GBMuCRyubR + NWzixFAGaw8PYk93Ggf7MzjQk8K+vgzSJmzBU/XfSCkFYezfHLcFOa4D01pimNKWwEWTmjC5JYaprTFM + aIyG3WUnLDoppasJIb8DsBo1a18RagqginC8gqsAXA1bGYReYRgWPcksjiVzONQ1hEFLw8G+DI4NZFzl + AAD7+uxt0NNs0yHTsgOPIVAfsbeJNPTCdpFxHWiOaWhLRNBcF0FL3MDk5hjGNsVcQW+LaRjdEA36XFa5 + YNb+ry3LOlaz9tVDTQGMDNoppUsdZXALypxBKBWpbB6pnIWhHMVQNo/hrIlUjmJ4OI1Byxbobu6FpmTO + 7vv6SMFbaHei7o2ahbq6ONrrbQs/tt6eaSgzKl8OOmEL/T9QShOU0n01wa8+agrg1OA2AEtgewbTUKVh + wjmITgDrnWDeKtg78LQ792qu/gigpgBOPZYBWEopvZoQsnhgML2gktmEsxydAHoBPARgA4D9OAe33TqT + UVMApxHOQqMWSmmrM1y4c2AwPSESC/9G21kG5tZvALAR9mIdZuVrFv40oKYAziAwhQBgKuwhA2DHEFoB + tGAEgoojhCSAPgD7KKUHYAv8hto4/sxDTQGc+WiHrRCmUkqnEUKmOOctADAwmF7e1Bg/CWDUKaxT0jn2 + wXbh+yilBwgh+wAcoJTud4S9DzXLfkajpgDOXrRbltXCeQytAKYAYEOKKbCVRCsAUErTg0OZGUHxBmc5 + 7UkAGdjuegsKAt7rHPsA9FqWtQEAaoJ+9uL/B8+D1JorvOplAAAAAElFTkSuQmCC + + + \ No newline at end of file diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowCreateCDB.Designer.cs b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowCreateCDB.Designer.cs new file mode 100644 index 00000000..f36af948 --- /dev/null +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowCreateCDB.Designer.cs @@ -0,0 +1,84 @@ +namespace CoatiSoftware.CoatiPlugin.Wizard +{ + partial class WindowCreateCDB + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(WindowCreateCDB)); + this.progressBar = new System.Windows.Forms.ProgressBar(); + this.labelStatus = new System.Windows.Forms.Label(); + this.backgroundWorker1 = new System.ComponentModel.BackgroundWorker(); + this.SuspendLayout(); + // + // progressBar + // + this.progressBar.Location = new System.Drawing.Point(12, 12); + this.progressBar.Name = "progressBar"; + this.progressBar.Size = new System.Drawing.Size(259, 23); + this.progressBar.Style = System.Windows.Forms.ProgressBarStyle.Continuous; + this.progressBar.TabIndex = 0; + // + // labelStatus + // + this.labelStatus.AutoSize = true; + this.labelStatus.Location = new System.Drawing.Point(13, 42); + this.labelStatus.Name = "labelStatus"; + this.labelStatus.Size = new System.Drawing.Size(52, 13); + this.labelStatus.TabIndex = 1; + this.labelStatus.Text = "Waiting..."; + // + // backgroundWorker1 + // + this.backgroundWorker1.DoWork += new System.ComponentModel.DoWorkEventHandler(this.backgroundWorker1_DoWork); + this.backgroundWorker1.ProgressChanged += new System.ComponentModel.ProgressChangedEventHandler(this.backgroundWorker1_ProgressChanged); + this.backgroundWorker1.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(this.backgroundWorker1_RunWorkerCompleted); + // + // WindowCreateCDB + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(284, 63); + this.Controls.Add(this.labelStatus); + this.Controls.Add(this.progressBar); + this.Cursor = System.Windows.Forms.Cursors.WaitCursor; + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.Name = "WindowCreateCDB"; + this.Text = "Creating Compilation Data Base"; + this.FormClosed += new System.Windows.Forms.FormClosedEventHandler(this.WindowCreateCDB_FormClosed); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.ProgressBar progressBar; + private System.Windows.Forms.Label labelStatus; + private System.ComponentModel.BackgroundWorker backgroundWorker1; + } +} \ No newline at end of file diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowCreateCDB.cs b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowCreateCDB.cs new file mode 100644 index 00000000..bb7fe1f6 --- /dev/null +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowCreateCDB.cs @@ -0,0 +1,142 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace CoatiSoftware.CoatiPlugin.Wizard +{ + public partial class WindowCreateCDB : Form + { + public delegate void OnFinishedCreatingCDB(SolutionParser.CompilationDatabase cdb, string directory, string fileName); + + private OnFinishedCreatingCDB m_onFinishedCreateCDB = null; + + private List m_projects = new List(); + + string m_configurationName = ""; + string m_platformName = ""; + string m_targetDir = ""; + string m_fileName = ""; + string m_cStandard = ""; + + SolutionParser.CompilationDatabase m_cdb = null; + + public OnFinishedCreatingCDB CallbackOnFinishedCreatingCDB + { + get { return m_onFinishedCreateCDB; } + set { m_onFinishedCreateCDB = value; } + } + + public List Projects + { + get { return m_projects; } + set { m_projects = value; } + } + + public string ConfigurationName + { + get { return m_configurationName; } + set { m_configurationName = value; } + } + + public string PlatformName + { + get { return m_platformName; } + set { m_platformName = value; } + } + + public string TargetDir + { + get { return m_targetDir; } + set { m_targetDir = value; } + } + + public string FileName + { + get { return m_fileName; } + set { m_fileName = value; } + } + + public string CStandard + { + get { return m_cStandard; } + set { m_cStandard = value; } + } + + public WindowCreateCDB() + { + InitializeComponent(); + + progressBar.Maximum = 100; + progressBar.Value = 0; + + backgroundWorker1.WorkerReportsProgress = true; + backgroundWorker1.WorkerSupportsCancellation = true; + } + + public void StartWorking() + { + // Show(); + + backgroundWorker1.RunWorkerAsync(); + } + + private SolutionParser.CompilationDatabase CreateCDB() + { + SolutionParser.CompilationDatabase cdb = new SolutionParser.CompilationDatabase(); + + int projectsProcessed = 0; + + foreach (EnvDTE.Project project in m_projects) + { + List commandObjects = SolutionParser.SolutionParser.CreateCommandObjects(project, m_configurationName, m_platformName, m_cStandard); + + projectsProcessed++; + float relativProgress = (float)projectsProcessed/(float)m_projects.Count; + backgroundWorker1.ReportProgress((int)(relativProgress * 100), "Processing project \"" + project.Name + "\""); + + foreach (SolutionParser.CommandObject obj in commandObjects) + { + cdb.AddCommandObject(obj); + } + } + + return cdb; + } + + private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) + { + m_cdb = CreateCDB(); + } + + private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e) + { + progressBar.Value = e.ProgressPercentage; + + labelStatus.Text = e.UserState as string; + } + + private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) + { + if(e.Cancelled == false && e.Error == null) + { + if (m_onFinishedCreateCDB != null) + { + m_onFinishedCreateCDB(m_cdb, m_targetDir, m_fileName); + } + } + + Close(); + } + + private void WindowCreateCDB_FormClosed(object sender, FormClosedEventArgs e) + { + backgroundWorker1.CancelAsync(); + } + } +} diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowCreateCDB.resx b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowCreateCDB.resx new file mode 100644 index 00000000..47b83bfc --- /dev/null +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowCreateCDB.resx @@ -0,0 +1,1331 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + + + + AAABAAgAEBAAAAEACABoBQAAhgAAABgYAAABAAgAyAYAAO4FAAAgIAAAAQAIAKgIAAC2DAAAKCgAAAEA + CACoCwAAXhUAADAwAAABAAgAqA4AAAYhAABAQAAAAQAIACgWAACuLwAAgIAAAAEACAAoTAAA1kUAAAAA + AAABACAA6ocAAP6RAAAoAAAAEAAAACAAAAABAAgAAAAAAAABAAAjLgAAIy4AAAABAAAAAQAA3sKfANG1 + rwDTtq0A1LavANS2swCHPCUAhz0mAIY7KwCGOywAhjwpAIY9LACHPSwAhz4tAIg9IQCIPSIAiD4iAIk/ + KACIPiwAiT8tAIg+LwCLQh8AjEMYAI1EGQCORhsAkUcTAJFHFACRSBQAlk4RAJZOEwCZVBoAikAkAIpA + JQCMQyAAjUQhAI1GIwCKQCkAjUcsAI5HLQCPSjwAkUsqAJFMMgCRTTMAkk41AJBLPQCQTDsAkU4/AJdV + LQCTUDsAnF0/AKVcAACmXQAAoVoJAKJbCwChXR8ArmUAAK5mAACvZwAAq2UMALhvAAC4cQIAvXoSAL16 + EwC4eB4AomAiAK5vKQCtcTsAtHYlALV5KQC4eSAAtn4/ALh+MQCVVEMAllZHAJdWRgCdYEIAnWFUAKZv + ZACpc2MAqnVlAKlzaQCla1EApm5UAKx1TgCocVgAuYRJALmFSgCpdGgAsX9iAMaknwDJqKAA2LyiANG1 + qgDQtK4A0LOoAM+zrQDXuaAA28CcAOTInwDjyaIAuYAzALqBNgC5gkYAvIlQAMqWRwDLmEcAsYJ4ALeI + ZgC1hWkAtohsALmKaQC8j28AsoJ4ALiLdgC6jnoAvZN/AMSbewC9lH8Av5aCALySigC7kokAw5t4AMmc + YQDKnmQA27JxANanWwDOpG0Ay6NzANSvfgDbsnAA2riKANm4iQDlypwA5cmbAMyqjQDFoZcAxqKXAMej + lgDHpZwAyKWdANKwhwDStqwA1ryuANi+sQDcwaMA38esAN7HtQDhy7cA4s24AOPOugDk0b4A5tfNAOja + 0wDq3NQA7N/TAO3g2ADt4tgA8OXXAPLo3wDy6uYA8+zlAPbw6wD59O8A+PTxAPn08AD69vUA+/jzAPv4 + 9QD9/PsA////APXq2QD16tkA7uPgAO7j4wDx5+AA7uDgAPLl2wDv4t4A///1AP///wD///8A////AP// + /wD///8A////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALi4 + uLiphIB8fICBq7i4uLi4uLQKZzw7Ozs7RGiBt7i4uLSBRDg4ODg4ODo8RIO4uLhgZH15QzJCf31kOTlj + YLivVUCcj0U0i6WQZjN+ZVWpXzU/maGSlKaoopWTnEE1WHgcHIWoqKioqKibn5EdHHhqGBlup6ioqKio + oJtSGBlrbBYulo2OoqiopJ6YaxcWbHQhSZhKIVBwcVNQcichIXRbLyeMiCgPDw8PHyUjHypbq1AGL4eH + IyMQECMfIxBPq7UDRyyJihERERERERFIA7W4tFhLVi0MDBEREQhIWLS4uLi0AUwmEwgIEytPA7S4uLi4 + uLWrW3ZpaXZbq7i4uLjwDwAAwAMAAIADAACAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAgAEAAMADAADgDwAAKAAAABgAAAAwAAAAAQAIAAAAAABAAgAAIy4AACMuAAAAAQAAAAEAAIg9 + GgCHPScAhz0tAIk/IwCIPyoAjUMcAI1DFwCWTQ8AmE8NAJBHFACQRxwAlEsUAJJLGgCbUw0Al1EaAJpR + EACKQSUAi0MrAI9IJQCPSS4AjEQ0AI9KOACRSyYAkE0+AJZRKACfXSUAlVM0AJZVPwCZWTsAoFcAAKVd + AgChWxcAoF8nAKVgDgCsZAEAqWMIAK9qDACqZxQAs2sAALJtDQCybxMAvXUCAL54BwCzcBUAqGcnAKZn + LAChYzkAr3Q5ALFzLAC2ei0AsnYwAJJOQACaXEwAnF1AAJteUgCfYkcAnWFPAJ9lVwCgZUkApWxcAKRr + VQCsdlsAsntFALJ7SgCyflgApW1gAKp0YACwfmQAsX9pALyFPgC7il4Au498AM6phQDCgRcAw4guAMKH + KwDMlT4Ayp9oAMicYgDCmXoA0qlvANCocgDMo3EAzKV7ANCqdwDeuoAA9e3lAPjx4gC8k4kAvpWAAL+X + igDEnpEAw56WAMyspADYu5QA4s69AN/LwADv3LwA4c/DAN/LyADCnI0Az6uIAMqliADJppsAy6qUAM2s + mQDTtqQAxaKXANKwjgDXt5IA0rOaANi6lwDgwZQA2LmQANa8pgDUuKoA6MyfAMqpogDRtK8A2b+sANS4 + qgDWvLMA3cOjANzFvQDZwbMA5MSPAODHpgDiyqoA4cu1AObSuwDhzskA6dvPAOTSxgDm19MA6tzUAO3h + 1ADt4doA8efeAPLo3gDw5NIA8OfhAPPq5QD38e4A+fbyAPv59wD///4A6tvUAOjY1ADv4M0A8ePNAPHn + 4gDy6egA+vXtAPbt6AD37+IA8ennAPbx7QD28fAA+vPsAP///wD///8A////AP///wDo6OgAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACjo6Ojo6OjopeVZX19cFuXoqOjo6Ojo6Ojo6Ojo5+SUUxJSUkpKkpMUZeho6Ojo6Ojo6OjmHFLJilJ + KSkmKSlJKUpxmKOjo6Ojo6OXUScmJikpJiYmJikpJiYnUZmjo6Ojo5lUJCcnJyIiIiIrJygkIiIiIlGY + o6Ojn3AkVH9NeiMeHkWLUn5OHh4eMihxoaOjlzIeb49SeiMNHm2RgW9SHQ0wfiUwkqOibB8NZZGLbC8s + ZY+RkIBTLD6BhB8NSKGXPg0NRpGRj4mNkZGRkZGOio+Rbg8PTpdiGQ8HIIaRkZGRkZGRkZGPg5CPQA8H + L5VrDgsLC0+RkZGRkZGRkZGMZpB3DgcOH3doDAwJDG6RkZGRkZGRkZGRkYYuCQwMDnhoCgUGQJCMfI6R + kZGRkZGRkYhkGAoKCmlrFgUFaZBDEj14iI6OjHtZhmk9FgUFEmtiGgUQZ441AAUQGjc6HBYAR0QABQUQ + GmKWPAMDQo5kEQMEAwMDAxAQERMQEBADO5efXBMTEWSNeRsEEAQEBBEREAQQBAQRWKGjlzwRBAM6gmsB + BAQEBAICBAQEBBE8l6OjoVgUBBdBgmcBBAQCAgICBAQEARtboaOjo51YFDuFezQCAgICAgICBAIEAlud + o6Ojo6OdWBQzFAIUAgICAgICAgIVWJejo6Ojo6OjnVg2AgICAgICAgICAjlYnaOjo6Ojo6Ojo6GXXEI2 + FAICFDNBWJefo6Ojo6Ojo6Ojo6Ojn5dcdnZ2dmOXoqOjo6Ojo6MAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAoAAAAIAAAAEAAAAABAAgAAAAAAAAEAAAjLgAAIy4AAAABAAAAAQAAiT8eAIc8 + JgCHPS0AiT8kAIg/KQCMQx0Aj0YVAJVMDwCYTw8AkUcUAJRMEwCRSRkAnlQHAJ1UDACZUhIAmVMYAIpB + JACMRCwAj0ksAI9IJACNRzkAj0k7AI5JNACSTScAkk00AJFMPQCWUiUAlVIuAJtXJwCcXDYAmVg2AKBX + AACkXAEAoFkPAKJdGACrYwAAq2UIAKhkEwCzawAAsW8WALpxAAC6dxEAv3wSALFwGACkYiMApWc3AK9z + MwC0dyYAt3wsALR6NACbXEEAmVtNAJhXQgCdYEEAnmRWAKJnSQCkak0Ao2lUAKFpWwCqc1gAs35TAKZv + YwCoc2cAqXRoAK15ZgCufXIAsH9qAMJ+DgC8gjQAvIM5AL+IOgC/i0oAv4lCAL6MVAC9jFsAtYJWAL2O + YwC4h2EAtoh2AL+QYwC9kXEAxIIVAMiLJwDBjEUAwo5IAMaSRgDRnkkAxZZZAMaZYwDInWoAyJ50ANGh + VgDLom0AzKN0AMymfgDWrnIA37uBALqPhAC8k4kAvpaIAPPr4AD17N4A7+bjAMOcjADDnZUAyaSGAMyr + nQDIpp4A0q+FANa1jADQsZsA1LWWAMytpgDUuKYA2L+yAOLPwQDbxL8A4s/KAN7JwwDjz7UA5tTEAOja + 1wDm19UA4s/JAN3CpQDcw6wA28S1ANzFvADfy74A69a3AO/dwQDu49gA4c2/AObSuwDw38MA7+HOAPDm + 3gD27dwA4tDJAOXUzgDt4dsA49DFAOTSxgDm1c0A6trIAOzf2wDo2dEA7uHUAO7j3ADx5twA7+ThAPTt + 6gDz6+YA9/HrAPjz7QD59fIA+/n3AP///wD38vAA7uPgAPny8gD59fIA+PPwAPv38wD59fMA+/n3APz4 + 9gD59vMA+vXyAPn18QD8+vgA/fr4AP///wD///8A////AP///wD///8A/v7+AP///wD///8A////AAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALS0 + tLS0tLS0tLSyrauHjYaGjYekrrO0tLS0tLS0tLS0tLS0tLS0tLSuq4JtVlJRUVFRUlaGkKuztLS0tLS0 + tLS0tLS0tLS0q4VbQ0MoKChDKCgoKFFSVoKrsrS0tLS0tLS0tLS0sWhfUSgoKCgoKCgoJigmUUNDQ2xo + rrS0tLS0tLS0tK6HVCYmJiYmJiYmJiYmJiYmJiYoJlV7rrS0tLS0tLSzh0UkIyAjIyMmIyMjICMjICYj + IyYmI1KHs7S0tLS0sp9VJ1JEJ1QvICMjICdUUidUMCMjICAgIFSrsrS0tLSrXyQwmYZUm1ggICAgV52R + VJltICAgIC9IIF2rtLS0s3AlHzGbmlSOWB8gHyB8nZxYhG0fHyAfbGwgJ36utLSkSh8MLpedhVpaDCEh + WZudnZBabyEMIUqeaR8hWau0sYIsDg4slZ2dkm9KWHGenZ2dnZVxWEpvnp1YDQ4sgrKrbA4ODg59nZ2d + nZydnZ2dnZ2dnZ2cnZ2dly4IDghprqtLCAoOCEycnZ2dnZ2dnZ2dnZ2dnZmbnZ1+DwoOCkqkgi0KCgoK + HI6dnZ2dnZ2dnZ2dnZ2cTW6dm0sHCgoKLYeMHAkJCQkJUJ2dnZ2dnZ2dnZ2dnZ2Ek51uCwoKCgkcjIQa + CwkLCS2PnZ2dnZ2dnZ2dnZ2dnZ2dfhwGCwsLCRqOjhwLCwsLbp2dkpidnZ2dnZ2dnZ2cnJyOaR0FCwUJ + HJCSHhMFBR2UnXEbOHKanZ2dnZ2dnJKRno1/OwUFCwUdjZ84BRMFN56eNwAFEzhnco2PhGpAGFqXNwsD + CwsTADifn1oAAwAymJcyABAFAAAQEhcTAwABGHA5AwADAxMDQKuuZwMQEBFynWcQAwMQEBAQAxEDAwMD + EhEEAwMDER5yq7RwGBEEAzmWm3A0AwMEEBADAwMDAwMDAwQTBAQSNI20tKtOGAQEAzl/m480AwQEBAQE + AwMEBAQEBAIEBANCq7S0ro8zBAQEARFBnGEBBAQEBAQEBAQEBAICAgQEHmu0tLS0q2ECAgIRGUGcYgQC + BAICAgICAgICAgICGTRwq7S0tLS0ez0CAj6UnpEzAgICAgIUAgICAgICAgICQZ+utLS0tLSzcD0CM3Br + NgICAgICAgICAgICAgICAj+isrS0tLS0tLSunz0CAgICAgICAgICAgICAgICAgJBdK60tLS0tLS0tLSx + ZGIUAQICFAICAgICAgICAgI0f5+ztLS0tLS0tLS0tLSzpXVBFQICAgICAgICAgI0QXCrtLS0tLS0tLS0 + tLS0tLS0saCMa0E6NDQVNDZBa6Crs7S0tLS0tLS0tLS0tLS0tLS0tLSwn4yMjY2fZmGxs7S0tLS0tLS0 + tLT/wAP//wAA//4AAD/4AAAf8AAAD+AAAAfAAAADwAAAA4AAAAGAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABgAAAAYAAAAPAAAAD4AAAA+AAAAfwAAAP+AAAH/wA + AH//AAD//+AD/ygAAAAoAAAAUAAAAAEACAAAAAAAQAYAACMuAAAjLgAAAAEAAAABAACJPx4AhjwmAIc9 + LQCIPiUAiD8qAIxDHACVSw8AmE8PAJBHFgCUTBMAkUkZAJ9WBgCcUw0AmlIRAJ5aHQCYUhsAikElAIxD + KgCOSDUAjko6AI1HNgCRSysAk00mAJJONACWUzMAnV01AJdWOwCfYj8ApFsBAKBYCQCkWwQAoFscAKxk + AACnYQoApmEWAK9vHACraBcAsGcAALNrAAC4bwAAsW4SALFvGQC6cgAAsXEbALd2GQCpaSkAoWQ7AKpu + OQCtcTUAtXcjALF2NQC2fDkAuX4wALN4OACVVEQAm11DAJlaTACbXlIAn2NIAKJlQwClakgApGtTAKVs + XQCtdkwAqnBDAKpzVwCsdlkAsntKAKVtYgCpdWoAqXVoAMB8DwC8h0UAt4RWALWEZgC0hW0AuYljALGB + cwC0hnsAuYx1ALaKfwC/kWoAvJJ6AMaJKADMkC8AzJU9AMGOSQDLlUIAypdJANCaQgDHmFkAyJ1oAMec + cADNo2sAy6V8AM2kcQDYrGIAvpWGAMSdhwDOqYYAzqyPAMejkgDHpZoAyKaVAM6unQDRro0A0K+SANi3 + iwDcvI8A1bGEANOzlQDWt5YAyaehAMqqowDPsaUA0bSkANG1rQDWu6oA2b2gANW7tADXvrkA3cGcAN3D + pQDcw6oA3MS0AN3IvgDiwo8A4sOSAOHHogDjzKsA48qlAODJswDl0LcA7NrBAP/+/ADgzccA5NLLAOPS + zQDv5d4A9e7pAPTt6gDiz8UA5dPEAOvbyQDq3NQA9uzeAPv38wDu490A7eDUAPHm2wDz6t4A+PPvAPHo + 5QD17+oA8OflAPTs5AD58+gA9e7pAPfx7QD48u0A+fXyAPz69wD///8A9/LwAPXw7gD79u8A9vHsAPjz + 6gD+/f0A/f37AP7++wD+/PsA/v79AP/+/gD//v4A////AP///wD///8A////AP///wD///8A////AP// + /wD///8A/f39APz8/AD19fUA////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu7u7u7u7 + u7u7u7u7u7uyr6illJaWlJeor7K7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7sq6og39gWVRTU1NgYH+E + qK+6u7u7u7u7u7u7u7u7u7u7u7u7u7u6r5R/VUcqR0dHR0dHR1MqR1mCja+6u7u7u7u7u7u7u7u7u7u7 + u7uylH9TKicnKkdHR0cnJ0dHKidHR1N+mbS7u7u7u7u7u7u7u7u7u7qvjlcnJycmJyclJyclJicmJyYm + JyZHR2Cfr7u7u7u7u7u7u7u7u7qolUclJiYlJSUlJSUlJSUlJSUmJiUlJyZHVYWst7u7u7u7u7u7u7qo + glMlJiUlJSUgICUlJSUgJSUlJSUlJSUlJSUsf6y7u7u7u7u7u7uvlFMnJiUgHiAgICAgICAgHCAgIBwc + JSUlJSAcHCmBr7u7u7u7u7uyhCscVmxaK21eKxwgICAcNGtrNEhsXSEgIBwgICAlNJayu7u7u7u3jVYc + HG+ihTGWliMcHBwcHF+iol9booEcHBwcHCFdKyVajbq7u7u7r3kcHBx6op8zeZMkHBwcHCGEoqKEM516 + HhwcHBwzlTMcHnmvu7u7uY01HR0ddqKiekiPNQsLCwtcoaKioVxejiILHQsie6A1HR0zkbK7u6xvHQwM + B2SioqJ7XEkLDCJen6KioqKfY2M1DA0weqKbLQwdHW+vu7eSSR8NDQdboqKiopqDbm+QoaKioqKioqGU + e2p7mqKijh8NDQ1DqLu3jh8NDQ0HL5uioqKioqKioqKioqKioqKioqKioqKiomoNDQ0NH4+yr28HBw0N + CQ98oqKioqKioqKioqKioqKioqKioaKioqBDCQkHCQl2r6hMBgYJCQkJSaCioqKioqKioqKioqKioqKi + e0maoqJ8DwkHBgkGXKiNPwkJCQkJCQ91oqKioqKioqKioqKioqKiomhAk6KePwkJCQkJBkKSmi4ICQkJ + CQoJYqKioqKioqKioqKioqKioqKhn6KhYwkJCgoKCghAmpUuCAgKCgoISp+ioqKioqKioqKioqKioqKi + oqKhaAoKCAgICgoILpqaLgUKCgoFGZCioqCboaKioaGhoaKioqKioqKioHVSGQoKCgUKCC6anTsFBQUF + BU+ioptGOnOgoqGhoaGioqKioqGeoqChoGgWBQUFCgA8mIw9BQUFBQVooqJPBQUWQXOToKGhoqKhoI1S + S6GNQT0YBRAFEAUFQZKoSwUFBRAFdaKdGwUFBQUQGEJiZWViSzwVABWNkxcABRAFBQUFBU+ur3wVFRYA + AGeinjoDAxAQBQUAAAAFAAAFEAUAPXwYEAUQEAUQEAB1r7KQGgQDAABCoKJiAwMDEBAQEBAQEBAQERAQ + EQAYERAQABYRABEYkLe6iD0DAwMEFXShnWIXAxADEREREREDERARAxEDAxEDEQMDAwMERY26u6xmBAQE + BAMad6Ghij4DEAMDAwMDAwMDAwMEAwMDAxEDAwMVEnWsu7u5kT0DAwQEBBNFjaGQNwQDEQMRBAQRAwIC + EQIDEQQEBAMEAz6Jubu7u6x1BAQEBAICAxKNoUUDBAQDAwMEAwMCAgICBAQEBAQEBAR8r7u7u7u5mT4D + AgICAgICeKJFAgICAgIRAgMCAgICAgIREQIEBANGmLq7u7u7u7KNNgMCAz53jaGaOAICEQICAgICAgIC + EQICAgICBAM4jba7u7u7u7u7r3cTAgFhoqKYRQICAgICAgICAgICAgICAgICAhI5kK+7u7u7u7u7u7ms + dBMBFERFOAICAgICAgICAgICAgICAgICAgI4eKi6u7u7u7u7u7u7t6x3NgECAgICAgICAgICAgICAgIC + AgIUAgI4kLC6u7u7u7u7u7u7u7u5rIhEAgICAgICAgICAgICAgICAgICExRFh6+6u7u7u7u7u7u7u7u7 + u7uyjXQ4NgICAgICAgICAgICExQCAkSHoLK6u7u7u7u7u7u7u7u7u7u7u7qvqHhFNgICAgICAgICAhM2 + RHGar7m6u7u7u7u7u7u7u7u7u7u7u7u7u7Kvi41xYkU5OTk5RVB4naOyubq7u7u7u7u7u7u7u7u7u7u7 + u7u7u7u7u7qyr62MoJ6amKOtr7a6u7u7u7u7u7u7u7u7u//8AD//AAAA/+AAB/8AAAD/gAAB/wAAAP8A + AAD/AAAA/AAAAH8AAAD4AAAAHwAAAPAAAAAfAAAA8AAAAA8AAADgAAAABwAAAMAAAAADAAAAwAAAAAMA + AACAAAAAAQAAAIAAAAABAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAIAAAAABAAAAgAAAAAEAAADAAAAAAwAAAMAAAAADAAAA4AAAAAcAAADwAAAADwAAAPAA + AAAPAAAA+AAAAB8AAAD8AAAAPwAAAP8AAAB/AAAA/4AAAP8AAAD/4AAD/wAAAP/4AB//AAAAKAAAADAA + AABgAAAAAQAIAAAAAAAACQAAIy4AACMuAAAAAQAAAAEAAIk/HgCGPCYAhz0tAIk+JQCIPykAiD4wAI1E + FgCNRBwAlUsPAJhPDgCQRxUAlEwTAJFIGQCdVAwAn1YDAJpTEQCYURcAi0EkAIxDKQCPSScAi0QzAI9K + OwCOSDcAkkwoAJFNPACRTDUAmVYpAJVSMgCbWzwAl1U3AKBXBQCkXAIAo1wNAKNeGQCgXSUApmAKAKxl + AACrZQsArmoOAKtkAgCraBgAs2sAALhvAAC1bwoAunIAALx4DgCxcR8ApGIjAKtsJwCucCoArXM7ALZ5 + JgCwdDUAkk9AAJVURQCYWEcAn2JFAKRpSQClbFIApWxdAK10RACrdFIAqnRbAKx3WgC1fUQAsntLALF8 + VgCmb2AAqXRlAKx6bQCoc2YArnxyALB/dQDAfRMAv4IlALmDPwC6hUsAuYVVALSDZAC5i2gAs4N0ALSF + fAC2iH0Au493AL6ScgDDgRQAzpc+AMCOUQDGllgA059JAMCRYwDHmmUAxJt5ANSjUwDTpFwAzaNvAM2i + ZADJo38AyqFyANerZADRq3kA1KxxANq1fAC6j4MAvJKEAL2TigC/mI8AwZuJAMOdlADMqYsAyqWHAMil + lgDRrogA1bSIAN+8gwDavZoAz7GrANK0owDVuq0A17ymANa9tADVurIA4b2CAN3BnQDexKUA28KtANzF + ugDex7UA4sacAOLKqADizLYA4Mq4AOrSqQDl0bcA5tO9AO3avADeycIA38zIAPz6+QDl1MwA69zMAOjW + xADm1tIA693XAOve2gDo2dYA/Pr5AODMxgDu4c0A7+LTAO7j3wDy48wA8+bUAPHm2wD69vIA+/j0APfy + 8QD59O8A9OzrAPHn4wDy6uQA9e/rAPjx6AD28ewA9/HqAP37+gD69vQA+/j2AP///wD+/f0A+vf1AP// + /gD7+fkA////AP///wD///8A////AP/+/gD///8A////AP///wD///8A////AP///wD///8A////AP7+ + /gD///8A////AP7+/gD///8A////AP7+/gD+/v4A////APz8/AD///8A////AP///wAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADGxsbGxsbGxsbGxsbGxsbGxcTAuLCJ + oaioqY6wtbjFwsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsW/r6iZh2VdXVlZXl5ml6ScsL/C + xsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbBuJSXgF1VSUlJSUlJSSlJVVVWZpeSuMXGxsbGxsbGxsbG + xsbGxsbGxsbGxsbGxbisl11JVUlJSUkpSUlJKipJSUlJSUleh5K4wcbGxsbGxsbGxsbGxsbGxsbGxsa/ + sJhgLSoqKSlJSUkpKioqKioqKioqSSoqVWOkt7/GxsbGxsbGxsbGxsbGxsbGxr2sgFUpKSkpKSlJSSkp + KSkqKikqKiopKiopSSozgaq/xsbGxsbGxsbGxsbGxsbGuKplKyopKSkpKSkpKSkpKSkpKSkpKSkpKSkp + KSopSWaowMbGxsbGxsbGxsbGxsa4qFgpKSkpJyknJCQpJCQpJCQkJCQkJCQkJCkkJCkpKS1mor3GxsbG + xsbGxsbGxr+kYCQkJCQkJCQkJCQnJCQkJCQfJCQkJCQkJCQkJCQkJCQkYKy9xsbGxsbGxsbGv6ZmKSQm + JiUnJiYmJycnJyQkJycmJiYkJiYmJCQkHyQkJB8kJGSsv8bGxsbGxsbBsIQlJy6FmGQmgZVxHx8fJx8n + H1eMjHMmc5iCKB8fHx8kHx8fHyaBsMbGxsbGxsa4mTMfHzSmqIImhahxHx8fHx8fH3CoqJkuc6iNJR8f + Hx8fH1dlHx8zmbjGxsbGxsWsWB8fH0umqKQ0W6hkHx8fHx8eKI2oqKZXWKiGHx8fHx8fH4GGIB8fW6zF + xsbGxriNIB4eHkCmqKhzMIx8Hh4eHh4eX6eoqKiGMYKYKB4eHh4eV6aFIB4eKJe3xsbGwqxYDSAJDTSm + qKinbkx3MA0NDQ1aoaioqKiod0GCTB4gDR5Alah9DyANDVqSwsbGuJcvCQkgCS+ZqKioqIFcQCEvQHWh + qKioqKioqI1hWi8iMm2gqKhwDQ8NDSKMu8bGsG4JDw8PDw+CqKioqKinloyVpaioqKioqKioqKinooyP + oaioqKhaCQ8PICFzsMW/njwJDw8PDw1hqKioqKioqKioqKioqKioqKioqKioqKioqKioqJ8yCBAJDyBB + qL+4iyEJDwsPCwsyoaioqKioqKioqKioqKioqKioqKioqKioqKioqHcQCBAIDxAij7+1dwsLCwsLDwsL + d6ioqKioqKioqKioqKioqKioqKioo22CqKiopkIICAgIEBAQfbiycAsQCwsLCwsLPKGoqKioqKioqKio + qKioqKioqKiofwhCpqiodhALEAgQChAIe6yqXAsLCwsMDAsLC22oqKioqKioqKioqKioqKioqKiooW5/ + qKifPAoMEAoKCgsKbpanQgsMDAwLDAoKGnaoqKioqKioqKioqKioqKioqKioqKioqKVPCgsMChAKCgwM + T6WnPQwMDAwMDAwXc6ioqKioqKioqKioqKioqKioqKioqKioplwMBwoMDAwMDAwMQqinPQYMBwwMCwZO + p6ioqKaoqKioqKioqKioqKioqKioqKiomW9OGgwMBwwMBwwGTqWnPwYHBwwHBxN+qKiofTprpKioqKio + qKioqKioqKioqKioqKioizkGBwcHBwcGTqmlUwcHBwcHBxygqKh+FwcHOnahqKioqKioqKioqKeVb5+o + f3Z1UxsHBwcHBwcHU6ysbgcRBwcHBzqnqKc+BwcHBxM5a4ifo6inpqOPdlAdE3iobwcHAAcHBwcHBwcH + b7C1fQcRBxERADqmqKAcBwcREQcABxMdOT4+OjgbEQAHBz6lfhMREQcREREHERsajbi4lhcRERERBxyf + qKk5BxERBxEHEREHAAADEQcRBxERERFTdhMREQcRBxERERMdp7/DmjoRERERERJ4qKhsABEREgMRERER + ERERERERERERERISHRERERERERERERE+rMHDsGkBERERAwM7oaijUBIDEgMSAwMRAxERAxERAxERBBER + ERIDAxERERERERJvs8PGuI8dAxIREgMEa6aopnk6AwQDAxIDEgMSAxIDAwQDAxIDEgMSAwMSAxIDAx2Z + uMbGwaxHAwQDBAMEElKWqKifRAMDBAQDBAQEAwQEBAQEBAQDBAQEAwQEBAQDAVCsxcbGxrWIFAQEBAQE + BAM3Z5GojhgCBAQEBAQEBAMEBAQEBAQEBAQEBAMEBAQDFpO3xsbGxsGsUAMEBAQEBAQCA0ampz4BBAQE + BAQEBAQEBAQEBAQEBAQEBAQEBAQBUq/CxsbGxsa3jjYBBAQEBAIBAUOmp0MCAwUDBAQDAwMDAwQEBAQE + BAQEBAQEAgQ3kLjGxsbGxsbCsHQUBAIEAjZnZ46oljYCAgQDBAQDBQUCBQUCAgICBAICAgICBRZ5sMLG + xsbGxsbGv6xsFAICAm+oqKimUgICAgIFBQQCAgIFAgICAgICAgICEgICFG+sxcbGxsbGxsbGxr+mUgIC + AkWOlohHBAICAgIFBQUCAgICAgICAgICAgICAgICZ5+9w8bGxsbGxsbGxsa/n0gCAgUWNQUCAgICAgIC + AgICAgICAgIFBQICAgICAgJSqLjGxsbGxsbGxsbGxsPGuKxpBQIFAgUCAgICAgICAgUCBQICBQUFBQUC + AgUFFmyewMPGxsbGxsbGxsbGxsbGxr2seTcCAgICBQUCAgICAgICAgUFBQUFBQUCAgI3fqzCxsbGxsbG + xsbGxsbGxsbGxsa/sJBIFAICBQUCAgICBQIFAgICBQUFBQICFlGfsL/DxsbGxsbGxsbGxsbGxsbGxsbG + xriokUg1BQUFBQICAgIFBQICBQUFBTVRjrG4wsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbFtayRbEM2BQIB + AgIFAgICBTVIdJGvt8LGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsO/saiWk2xRR0ZGR1Fsi5+osrjF + xsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxb+4tbCsqKenpa6wuMC/xsbGxsbGxsbGxsbGxsbG + xsb//wAA//8AAP/8AAA//wAA//AAAA//AAD/wAAAA/8AAP+AAAAB/wAA/wAAAAD/AAD+AAAAAH8AAPwA + AAAAPwAA+AAAAAAfAADwAAAAAA8AAOAAAAAADwAA4AAAAAAHAADAAAAAAAMAAMAAAAAAAwAAgAAAAAAB + AACAAAAAAAEAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAgAAAAAABAACAAAAAAAEAAMAAAAAAAwAAwAAAAAADAADgAAAAAAcAAOAA + AAAABwAA8AAAAAAPAAD4AAAAAA8AAPwAAAAAPwAA+gAAAAA/AAD/AAAAAP8AAP+AAAAA/wAA/+AAAAP/ + AAD/8AAAD/8AAP/8AAA//wAA//8AAf//AAAoAAAAQAAAAIAAAAABAAgAAAAAAAAQAAAjLgAAIy4AAAAB + AAAAAQAAiT8fAIY8JQCHPS0AiT4kAIg/KgCMQx0AjkUVAJVMDwCVSwwAkEcWAJBHGgCUSxQAkUkZAJhP + EQCfVgYAnVQOAJpSEQCcVhgAikEkAItDLACPSCwAi0Q0AI1HOACPSjoAj0k0AJNNKQCSSyMAkk0zAJFN + OwCeWyMAmlYkAJRSPACbWjUAm1w7AJdWNQCgVwEApFwBAKBYCQCoXwAAoFcIAKNeFwCrYwAAqmULAK1q + EgCpZxkAs2sAALBrDAC4bwAAu3IAALp2DgC5eBkAsG0TAKRkLACqaiYAqm01AK9xIwCucjcAtXgpALF3 + OACVUkQAl1dJAJJPQgCfYkMAnmJNAJ5jVgCmbE0AomdGAKNqWQCsdEoArXleAKhyXACzf1QAsXpIAKlz + ZgCtemoAq3hlAK99cwCxf2gApGtgAMF5AwDDfg4AwX4UALuEOwC6gTQAvYpMALqFRgC6hlQAuolaALWG + bAC6jGkAsoJ1ALKCeAC4i3cAvJJ8AMeHHQDNlDgAyJREAMSUWADAi0QAw5VkAMWYYwDEm3YA1KZcAM6l + bwDMpXkA0699ANy3fgC+lYcAt4qAAMOchgDCnJQAzaqMAMumggDGopMAzKqUAMuqnADHpJgA0K6NANCr + gQDVsoUA2rmKANKznADYuZQA0a+RAMysowDJp6AA07akANK1rgDVuqsA1rqiANe+uQDVu7QA3sGXANzD + rADdw6IA28OzANrDuwDfyr4A5MWRAOPMrADnzKIA4sy1AODMvgDr0qkA6da7ANzGwQDfy8YA4c7EAOHN + yQDl0sEA5NPMAOjXwwDs3MUA6tvLAOXW0QDn2NQA6tzUAOrd2ADt4dYA7uLbAPHjywDx4cYA8efcAPTq + 3gDz5tEA7uDNAO/k4QD07OQA9O7rAPDm4QD38ewA+fPtAPfy8QD59fMA/Pn1AP/+/gD///8A////AP// + /wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP// + /wD///8A/v7+AP7+/gD///8A/f39AP///wD///8A////AP///wD///8A////AP///wAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAM3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3NzcXCury1sq2vr62wsrS9xszLzc3Nzc3Nzc3N + zc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3FvrSor66jo6GPjIyPoaSvr6+ztr7Fy83N + zc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nyb62ra6jimZfXl5eT09PT09eXl9miqSv + rLa+x83Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3JvqivoIpfXjAwMDBPT09PT09PTzAw + MDBeX4qkr7K+zM3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzcu+ta6QZlEwMDAwMDAwMDAwMDAw + MDAwMDAwMDAwXmaYr7TAzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3NzcW8r6BmXlAwMDAvMDAwMDAw + MDAwMDAwMDAwMDAwMDAvMWakrbrFzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Ny8Csq3heTy8wLzAtLS8v + Ly8vLy8vLS0vLy8vLy8wMDAtMDAvUXiussLLzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nyb6voGAwLy0tLS0t + LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLy0xYKSuvsvNzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nx7qvjDItLS0t + LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS1Tj6+6y83Nzc3Nzc3Nzc3Nzc3Nzc3Nyb2veDMp + LS0pLS0pLS0tLS0tKS0tLSktLSktLSktLSktKS0tKS0pLS0pKTGErrrLzc3Nzc3Nzc3Nzc3Nzc3Nyb6u + dy4pKSktKSktKSktKSkpKSkpKS0pKSkpKS0pKS0pKSkpLSkpLSktKSkpLnivus3Nzc3Nzc3Nzc3Nzc3N + y7yveC4pKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkuhK+8y83Nzc3Nzc3N + zc3NzcCvhispKSYmKSkpKSkpJikpKSkpKSkpKSkpKSkkKSkpKSkmKSkpKSkpKSkpKSkpKTONscLNzc3N + zc3Nzc3NzcWymDIkJitnaWlSJGJpaWcrJiYpJCkmKSQpUmlpaWEpU2lpaVMkJCkpKSkkJCkpJikmOaCy + x83Nzc3Nzc3Nzcu2q1IkKSQ5q6+vdyRpr6+YKyYkJiYmJiQkJHivr6+QKmGvr65iJCQkJiYmKSQkKisk + JCRiq73Lzc3Nzc3Nzc2+r2kkJCQkVa6vr4skYa+viyQkJCQkJCQkJCmNr6+vojNSra+qOSQkJCcmJiQk + JGeQKyQkJHevwM3Nzc3Nzc3HspcrIyQkI1Sur6+nOSyir4YkJCQkJCQkJCQ5qq+vr69hKpevpzckJCQk + JCQkIyqXqjckJCQzpLTJzc3Nzc3Nvq5UIycnJw5Ur6+vr3cOdq+QJScnJyQlIyUleq+vr6+vkCVkr6s6 + DiMpJSUlJyNhrqc3IycnI2Svvs3Nzc3NybKNKCUOJycOVa6vr6+qViyQqTUODiUlJSUOV6uvr6+vr69w + KIavYw4OJSUODg44nq+iNQ4OJScsl7LJzc3Nzb6vVw8PDw8PDjqrr6+vr6JWNo1jDw8PDw4PV6evr6+v + r6+vrWg1hYURDw8PDw46l6+vnCwPEA8PD2OvwM3Nzcm0mSgPDw8PEA81n6+vr6+vqm9VVxAPDxE4equv + r6+vr6+vr6+uhVZlNg8PEDVooq+vr40RDxAPDw81pLbLzc3Cr3APEBAQEBAQEZCvr6+vr6+vp411cG+N + p6+vr6+vr6+vr6+vr6+qkHlwb4Wirq+vr697EBAQEBAQEHuvxc3NuqtIDxAQEBAQEBBvr6+vr6+vr6+v + r6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vVw8QEBAQEBBIrb7NzbaVERAQEBAQEBAQVqyvr6+v + r6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vojQQEBANDQ0NHZm2y8Wsbw0NDRANEA0NEB2Z + r6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr4EQEA0NDQ0QEBCBs8fAsFkHCw0NCw0L + EA0LZa+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+un7Cvr6+vr61HBw0NDQ0LDQ0NZa/Cvq82DQsL + EAsHCwsHCzSer6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vch5Xqq+vr6+HEQsLCwsNDQsNDUSuvLSn + NA0LCwsLCwsLCwsLXa6vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr1cIHp6vr6+qRAsLCwsLCwsLCw00 + qbaylQwLCwsLCwsLDAsLCx6Jr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+SR3Kur6+vbwsLDAsLCwsL + DAsMHaS1sIcLCwsLCwsJCwsLDAkLb6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr66vr6+vkx0JCwsL + CwsMCwsLDB6Osq+BDAwMDAwMCQwMDAwMcK6vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vnkIJ + DAwMDAwMDAwMDAwMh7CveQwMDAwMDAwMDAwGWK2vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+v + nkEGDAwMDAwMDAwMDAwMDICur3kKCgoKCgoKCgoGIJyvr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+v + r6+vrn5ZQRoJDAoKCgoKCgoKCgqAr69+CgoKCgoKCgoKBW2vr6+vr5xxlq+vr6+vr6+vr6+vr6+vr6+v + r6+vr6+vr6+vr62TRQwFCgoKCgoKCgoKja+vjQoFBQoFBQoKChmWr6+vr4cgBiByqq+vr6+vr6+vr6+v + r6+vr6+vr6+ur6+vr6+vr5YhBQUKCgoKChIKGpWss5YaEgUFBRIFBQVCqK+vr5YiBQUFBUGAqK+vr6+v + r6+vr6+vr6+vr6ZxXa6vm2VxcVghCgUFBQUFEgUaEhmbtrSdIgUFBQoFBQUARa6vr69YBQUFBQUGEkJt + laivr6+vr6+vr66piF0hBSCmr6g+BQUFBQUFBQUFChIKBQo2q7a6qEIFEgUSBQUFAEuvr6+oPgUFBRIF + EgUFBRlCTWtzgIB+c11FIRoABQUSc6+vTQAFEgUSEgUSBQoKEhISRq+6xa9NGgoSChIFBQVBra+vqCEF + EgUSEgoSChISBgUFBQUKEgUFAAUFBQUSBSGar1gAChIKBQoFBRISGgoSAFivxsWvcxQSEhISEhIFIaav + r61GAxISEhIFEhISEhISBRISEhISEhISEhISEhIFQZZYABISEhISEhISEhIDEgNzs8vJtJQZEhISEhIS + EhKAr6+vcxISEhISEhISEhISEhISEhISEhISEhISEhISEgMiGwMSEhISEhISEhISEhIbo7TNzbqoQgMS + EhISEhISRqyvr6pLAwMSEhISEhISEhISEhISEhISEhISEhISEhISAwMSEhISEhISEhISEhMDRq++zc3F + r2sDAwMSEhIEBBNzr6+vp2wcAxISEhISEgQEAxIDBBIEEhISEgQEEgQSEhISEgQSAxMDEgMTAxIEA3yv + xc3NybaWGwMDBBISEwQBH4ivr6+vlkoTBBICEhISEhIEEhIEEgQEEgQSEgQSBAESEgQDEhMDEgQTAxIE + AyKntsvNzc2+r0oDAwMSEgMSAwMcfK2vr6+taxISEhISAhISEhISEgQSEhISBBISBBISEgQSBBISAwMT + AxIDEgNar8XNzc3NzLCIGAQEBAQEBAQEAxNLgqivr61KAwIEBAQDBAQEBAMEBAMEAgQEAwQEEgQEBAQE + AwQEAwQEBAQblK/Mzc3Nzc26r1oEEwQEBAQEAwQSARM8ka+viBUSAgQEBAQEBAMEBAQEBAQEAwQEBAEE + BAQEBAQEBAQEBAQEWq6+zc3Nzc3Nx7OaHBMEBAQEBAQEBAQEAUmur6YfBAQEBAQEBAQEBAQEBAQEBAQE + BAQEBAQEBAMEBAQEBAMDH5u0yc3Nzc3Nzc3Fr2sEBAQEBAQEBAQEBAFDra+mOwQCAhIEBAQEAgICAgIC + EwIEBAQEBAQEBAQEBAQEBAQCAnSvxc3Nzc3Nzc3NybSoQwECBAICAgICFxc8iK+vkhgTAgICAgICAgIC + AhUCAgICAgICAhMCAgQCBAICAgICAkmstsnNzc3Nzc3Nzc3FrJo7BAIEAgICWp2bpq+vrmwBAgICAgQC + AgICAgICAhUCAgICAgICAgICAgITAgIEAjydssXNzc3Nzc3Nzc3Nzb6ufxUCAgICFZGvr6+vr38WAgIC + EwICAgICAgICAgICAhMCExMCAgICAgICAgICAhyCr8DNzc3Nzc3Nzc3Nzc3Nvq98FQICAgJrrK+upmsX + AgICEwICAhMCAgICAgITAgICAgITAgICEwICAgICAhx8rrzNzc3Nzc3Nzc3Nzc3Nzcm6r3QVAgICFUBJ + STsCAgICAgICAgICAhMCAgICAgICAgICAgICAgICAgIVAh98r7rJzc3Nzc3Nzc3Nzc3Nzc3NybiudBcC + AgICAgICAgICAgICAhMCAgICAgICAgICAgIVAgICEwICAgICAhyDr7jNzc3Nzc3Nzc3Nzc3Nzc3Nzc3J + uq+DOwICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjyCr77Nzc3Nzc3Nzc3Nzc3Nzc3N + zc3Nzcu6r5pOAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICFUqdsL7Nzc3Nzc3Nzc3Nzc3N + zc3Nzc3Nzc3NzcKyqm49AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICPXysssXLzc3Nzc3Nzc3N + zc3Nzc3Nzc3Nzc3Nzc3NxbavtEwWAgICAgICAgICAgICAgICAgICAgICAgICAgIWW5uvtsXNzc3Nzc3N + zc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3LwLSvkkw9AgICAgICAgICAgICAgICAgICAgICAj1blK+0vs3Nzc3N + zc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Juq+upn1DFwICAgICAgICAgICAgICAgIXTn2br7O+yc3N + zc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3LxbKvrpp8TE47PRUCAgICAj07Q2x8mrCwtr7J + zc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Hyb62r6+uqJqRgoN/g5GarK+vsLa+ + xczNzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3NzcXCura1sK+vr6+ytba+ + wsXNzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3///8AAH//////+AAAD//////AAAAD/////wAAAAD////8 + AAAAAH////gAAAAAH///4AAAAAAH///AAAAAAAP//4AAAAAAAf//AAAAAAAA//4AAAAAAAD//AAAAAAA + AD/8AAAAAAAAP/gAAAAAAAAf8AAAAAAAAA/wAAAAAAAAD+AAAAAAAAAH4AAAAAAAAAfAAAAAAAAAA8AA + AAAAAAADgAAAAAAAAAGAAAAAAAAAAYAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAA + AAGAAAAAAAAAAYAAAAAAAAABwAAAAAAAAAPAAAAAAAAAA+AAAAAAAAAH4AAAAAAAAAfwAAAAAAAAD/AA + AAAAAAAP+AAAAAAAAB/8AAAAAAAAP/4AAAAAAAB//gAAAAAAAH//AAAAAAAB//+AAAAAAAP//8AAAAAA + B///8AAAAAAH///4AAAAAB////wAAAAAf////wAAAAD/////wAAAA//////wAAAP//////8AAP///ygA + AACAAAAAAAEAAAEACAAAAAAAAEAAACMuAAAjLgAAAAEAAAABAACJPxwAhzwmAIc9LQCJPiQAiD8qAI5F + FgCNRB0AlUwOAJhPDgCQRxkAlEwUAJFJGQCTSRIAn1YGAJ5VDQCaUhEAmlQYAIpBJACMQysAj0glAItD + MwCOSToAjUc4AJJMJQCRSyoAkU07AJJNNACVUS0Am1cmAJxdPACWVDcAoFcCAKRcAQCgWAgAqF8AAKJd + GwCjXhQAoV0gAKtkAACqZQsAr2gAAKpkCwCqZxcAs2sAALhvAACxbAsAsW8VALtzAAC6dQwAsnIbALh2 + FAClYyQAqWkoAKdqNwCuczsArnEwALN1JAC0eCkAtHk3AK9xKQCVVEUAllZJAJpbSACcX1EAnmJHAJ5j + VQClbEwAomZGAKRqUwCkbFwAoGZYAKxzSQCqc1QArHdcALJ6RwCxfVUAqXNkAK57YgCseW4AqHNnAK99 + cwCwfmgAqHJnAMB3AADCewgAwX8UALuDOgC/gSYAt4JLALyLXAC4hVYAs4NpALeIZwC0hnwAtol5AL2T + fAC9knUAv5BjAMSBGADIiiUAxIs0AM2VOgDQmD0AxJRXAMeTSQDFmWcAxJp4ANamWADToE0Ay6FtAMuk + eQDXrGgA3LV1ANSudgC4jIQAvZOJAL6VhADDnIMAwpuMAMKclADEn5gAyKSJAMajmwDLq50AyaaUANGu + hwDXtYgA1beXAM+wmwDLq6MAzKymAM6xqQDStaMA1bqsANe7qADVu7QA2L6xAOG/iADdwZwA3cSsAN7D + oADawrwA3sm9AN3GswDiwYsA48eaAOLJpgDizLMA4s66AOnVuQDo0a4A3srDAN3JxQDhzcMA4c7KAOXT + wwDk08wA69rFAOvcywDo18MA5dXSAOrd1ADq3doA59nTAPDfwgDu490A7uHUAPLjzADw4McA8ebcAPPq + 3QDx5dQA7uDNAO7k4QDz6+QA9O7qAPLo5AD38esA+fTuAPjx5QD38vAA+fXzAPv59gD///8A////AP// + /wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP// + /wD+/v4A/v7+AP///wD///8A////AP7+/gD///8A////AP///wD///8A+/v7AP///wD///8AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dTNycbGvr66uLi3t7e2tri6vsDCxsnN0dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dPPycK8vri1t7e3t7e3t7e3t7e3t7e3 + t7e3tri8wMPJz9XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXT0cvGvLi3t7e3t7e3t7e3t7e3 + t7a2t7e3t7e3t7e3t7e3t7e6vMbL0dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXRyca6t7e3t7e3t7a2 + s6eVkZBwb2tra2tra29wkJKVq7O2t7e3t7e3t7e8wsnR1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dPNxry3t7e3 + t7e2s5WQb2ZjYlRTU1NTU1NTU1NTU1NTU1RiY2xvkaSztre3t7e3trzGzdXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dPJ + wLi3t7e3t7KokGxjVFNTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTVGNrkKe2t7a3t7e6xsvV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dPJvre3t7e3tZVwZVRTLy9TU1NTL1NTU1MvU1NTL1MvUy9TL1NTU1MvU1NTUy8vYmaJqLK3t7e3 + tr7L09XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dPJvLe3t7e3qpBmVC8vLy8vL1NTLy8vU1MvUy9TLy8vUy9TL1MvU1MvLy9TLy8vUy8v + Ly9ibJGzt7e3t7a+y9PV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXNwLa3t7e2nW9jLCwvLy8vLy8vLy8vLy8vLy8vL1MvLy8vLy8vUy9TLC8v + Ly8vLy8vLy8vLy8sL2Nwp7e3t7e4ws/V1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dPUxra3t7e2lWtVLy8sLy8vLy8sLy8vLCwvLy8vLy8sLy8vLy8v + LywvLC8vLy8vLy8sLy8vLy8vLy8vLyxVb563t7e3uMbT1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXTyby3t7e3qGswLCwvLy8vLy8vLy8vLy8vLC8vLy8v + Ly8vLy8vLy8vLy8vLywvLy8sLy8vLywvLy8vLy8vLy8sVW+rt7e3t77L1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV0cK5t7e3qnAyLysvLy8vLywsLywsLC8v + LC8sLywsLy8sLy8vLywsLCwsLywsLCwsLywvLC8sLC8sLCwsLywvLy8rL2J+s7e3t7jG0dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1cu8t7e3tZFjLCwvLCwvLy8s + Ly8sLCwsLC8sLCwsLCwsLywsLC8sKywsLCwsLCwsLCwsLC8sLC8sLCwsLywvLy8sLy8vKy9llra3t7e+ + zdXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dPJuLe3t6trLCsr + KysvKysrKyssKyssLCwvKyssLCwsKy8rKywvKyssLCwsLCwsLCwsKywrLCsvKyssLCssKysrKyssKysr + LCswb6q3t7e6ydXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXVwre3 + t7aSVysrKysvKysvKysvKysvKyssLCsvKyssKywrKy8rKysvKysrKysrKyssLCwsLCssKyssKysvKysv + KysvKysvLCsvKysrZJa2t7e3xtPV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV0b63t7ezbzArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr + KysrKysrKysrKysrKysrKysrKysrMn61t7e3wtHV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1c++t7e3p2goKygrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysoKysrKysr + KysrKysrKysrKygrKygrKCsrKysrKysrKysrKysrK2eqt7e3wtTV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXNvLe3t5U5KCsrKysrKCsoKysrKCsoKysrKysrKysoKygrKysoKysrKCsr + KysrKygrKCsrKygrKCsrKysoKysrKysrKysoKygrKysrKysoKygrK2Sot7e3vs/V1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXVzbq3t7aSMigoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgo + KCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCsrKCgoKCgoKzmWt7e3vs/V1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV0826t7e2fzAmKCgoKCgoKCgoKCgoKCgoKCgoKCgo + KCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKDKS + t7e3vM/V1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXTvLe3tn4tKCgmJigoKCgoKCIoKCgo + JigoKCgoJigoKCgmKCYoKCYoJigoKCYoJigoJigmJigmKCYoJigoJigmJigmKCgoKCgmKCYoKCYoJigm + KCYoKCgoJi6Kt7e3vtHV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXVzb63t7Z+LSgoKCgoKCYo + KCgoKCgoKCgoJigoKCYoJigmJigoKCgmKCgoJigoKCYoJigoJigoKCgoKCYoKCgoJigoJigoJigoKCgm + KCgoKCYoJigoKCgmKCgoKC6Rt7e3vtHV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dS+t7e3fi0m + JigmJiYmJiYmJigiKCYmKCgiJiYmJigmJiYmJiYmJiYmJiYmJigmJiYmJigmJiYmJiYmJiYmJigmJiYm + JiYmJiYmJiYmJiYoJiYmJiYmJiYoJiYmKC6St7e3wtPV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + wLe3t4otJiYmJiYmJiYmJiYmIiYmIiYmIiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYm + JiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYiJiYmJiYmIjGWt7e3xtXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1ca3t7eTLiYmJiYmJiYmJiYmJiYiJigmIigoIiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYm + JiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJjidt7e4ydXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXLuLe3njkmJiYiJiImIiIiJiIgJiYiIiIiIiIiJiImJiYmIiImIiImJiImIiIm + IiYmJiYiIiImIiIiIiImIiYmIiYiIiIiJiYiIiYiJiImJiImIiYmIiImJiImIiImIiYmIlaqt7e609XV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV0b63t7NWIiImJiYiJi4xMTExMS4mJiIpMTExMTExMSkiIiYmIiYm + IiImIiYmIiImIiIiJi4xMTExMTExJyYiJi4xMTExMTEuJiYiJiImIiImIiImJiYmIiImIiYmIiImJiYm + IGeyt7e809XV1dXV1dXV1dXV1dXV1dXV1dXV1dPAt7e2bSImIiIiIiAxn66qqaqqlS0iIjmnqqqqqqqd + OCIiIiIiIiIiIiYgJiAiIiIiIiIun6qqqqqqqqppIiIpkrCpqaqqqpInIiIiIiYgJiIiIiIiIiIiIiYi + IiIiIiIiIiImJn22t7fD1dXV1dXV1dXV1dXV1dXV1dXV1dXVybe3t38pIiIiIiIgIFa0t7e3t7eqMSAg + ObO3t7e3t58nIiAiIiIiIiIiJiIiIiIiIiIiIjmzt7e3t7e3t34iIimVt7e3t7e3fiAiIiAiIiIgIiIi + IiIgJiYgIiImIiAiIiAiIiYiLZO3t7jL1dXV1dXV1dXV1dXV1dXV1dXV1c+6t7eeOCAgICIiICAgaLa3 + t7e3t7E6ICAuq7e3t7e3fyAiICIiICIgIiAgICIiICAiIiIgOrW3t7e3t7e3iiIgIIq3t7e3t7dnICIi + ICIiIiAiIiIgIiYgICAgICAnOCkgICIgICAiOqq3t7zR1dXV1dXV1dXV1dXV1dXV1dXVwre3tGggICAg + ICAgICBpt7e3t7e3tmcgICKTt7e3t7dtICAgICIgICAgICAgICAgICAgICBpt7e3t7e3t7efJyIgbre3 + t7e3tVYgICAgICAgICAgIiAgICAgICAgJ4qzfikgICAgICIgaba3t8bV1dXV1dXV1dXV1dXV1dXV1cu2 + t7d/JiAgIiAiICAiIG23t7e3t7e3fiAgIHG3t7e3t2cfICAgICAgIiAgIiAiICAiICIgIIq3t7e3t7e3 + t7M5ICBYtbe3t7ezOSAgIiAgICIgICAgICAgICAgICA5sreuMR8gICAgICApkre3us3V1dXV1dXV1dXV + 1dXV1dXVvre3qzENDSYgICAgIB8fcbe3t7e3t7edKiAfVrS3t7e2Zx8gICAgICAgICAgICAgICAgICAq + q7e3t7e3t7e3t2kgHyqst7e3t644Hx8gICAmDSYNJiAgICAgICAgH223t644ICAgICAgICBWs7e3wNPV + 1dXV1dXV1dXV1dXV1cm2t7ZpDSAgICAgIB8gIB99t7e3t7e3t7VnHx8plbe3t7ZnDSAgICAgIA0NICAN + ICAfDSAgH2e2t7e3t7e3t7e3lSofH263t7e3szkfIB8gIA0NICAgDSAgIA0gIB8pn7e3sTgNICANICAg + ICB9t7e4ydXV1dXV1dXV1dXV1dXRvLe2lSoNDSANDSAgICAfH323t7e3t7e3t5MpHx9ntre3t20NHyEg + ICAfICAgICAgICAgICAqn7e3t7e3t7e3t7e2Zx8fO6m3t7e0Oh8gICAgKQ0NDQ0gDQ0gICAfIGG1t7ev + OQ0gIB8NISEgIDumt7e+09XV1dXV1dXV1dXV1ca3t7ZaDSkNKQ0NIA0NICAffbe3t7e3t7e3tmkNHyGS + t7e2fw0hISEhIQ0hIQ0NDQ0NIQ0hDW23t7e3t7e3t7e3t7edKiAgbre3t7dnDSAhDQ0pDSANIA0gDQ0g + IQ0qnre3t647DSENIA0hISEhH2m2t7fR1dXV1dXV1dXV1dXUvLe3kykNISENDQ4NDQ4NIQ1ut7e3t7e3 + t7e3qTcNDTapt7efJA0hISEhISENDSEhISENDQ06sLe3t7e3t7e3t7e3t7d+IQ0qk7e3t30NISENDSEh + ISEhISENDQ0NIX63t7e3rjQNISEhISEhISENKp63t8DT1dXV1dXV1dXV1c23t7VaDQ0hDg4ODg0NDiQO + DW23t7e3t7e3t7e3lTMNDVmzt7E6DQ4NDQ4ODQ4NDg4hDg0NNJ23t7e3t7e3t7e3t7e3t7RpDQ03nre3 + nSoODg4OIQ4kDg4hDQ0NDg1ptLe3t7emKg0NDg0OISEODiENabe3tsvV1dXV1dXV1dXTvre3lCQODg4O + Dg4ODg4ODg4NWba3t7e3t7e3t7e3izMNDmmxt24NDg4ODg4ODg4kDg4ODTSUt7e3t7e3t7e3t7e3t7e3 + t7FpDg1Kobe1WA0ODg4ODg4ODg4ODg4OabW3t7e3t50qDg4ODg4ODg4OIQ0zobe3wNXV1dXV1dXV1cu2 + t7ZhDg8ODg4ODg4ODg4ODg5YtLe3t7e3t7e3t7e3lDYODlmpoTMODg8ODg4ODg4ODg5Kn7e3t7e3t7e3 + t7e3t7e3t7e3t7FuEA02lLeGDg4ODg4ODg4ODiQOEG64t7e3t7e3jw4PDw4ODg4ODg4PDw5ut7e4z9XV + 1dXV1dXVwre3njMODg4ODg8ODg4ODg4OCDSut7e3t7e3t7e3t7e3pWkjCDaLag4PDg8OEA4PDggqbqq3 + t7e3t7e3t7e3t7e3t7e3t7e3t7aLNg4zfqlYDg4PDg4ODg4ODjaLtre3t7e3t7d/Dg4ODg4ODyEhECEQ + DzWwt7fG1dXV1dXV1c+6t7d5Dg8PDg4PDg8QDhAPDg4PJZ63t7e3t7e3t7e3t7e3tpRZKiQ2EA4ODw4O + CA4zYZu2t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7eufTYQSlkPDw4ICA4IEDZ/rre3t7e3t7e3t2oIDxAO + EA4PDw8PIQ8hJH+3t7zV1dXV1dXVybe3rzYODg4QDg8PDw8ODhAQCA4Qhre3t7e3t7e3t7e3t7e3t7ah + f1k2NDMzNDZhgKa2t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3sZNqWDUzMzQ3WG6Pube3t7e3t7e3 + t7e1WA4PDhAODg8PECEQIQ8IWLa3t8vV1dXV1dO+t7eSEA8QDw8PDw8PDw8PDg8PDg5ut7e3t7e3t7e3 + t7e3t7e3t7e3trGupaWuuLe3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e1r6mlpbG2t7e3 + t7e3t7e3t7e3t6k0Dw8QDhAPDw8PDw8PDw8lnre3wtXV1dXVz7i3t2kODw8PDw8PDw8PDw8PDw8PCEq1 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3jhAPDw8PDw8PDw8PDw8PDwh5t7e80dXV1dXJt7euNQgPDw8PDw8ODw8P + Dw8PDw8IJaa3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7duDw8PDw8PDw8PDw8PDw8PCEq1t7bL1dXV1cC3t48QDw8P + Dw8PDwoPDw8IDw8IDw8PhLe3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3skoHDw8IDw8PDw8PDw8PDw8IJZ63t8PV1dXR + ure3agcPCA8KDwoPCg4PDwoPDwoPDwdatre3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7ebEAgPDwoPDw8IDwoICAgPDw8K + gLe3vtPV1cu2t7JKBw8PDw8PDw8KDw8PDw8PDw8PCjOmt7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t3kIDw8IDwoPDw8P + Dw8KDw8PDwhht7e4z9XVxre3phwKDwoKCgoPCgoPDwoKCgoKDwoKCnm3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7euNQoK + CAoPCg8KCgoPCggKCAoKCjWut7fJ1dXCt7eLCgoPDwgOCggPCgoHDgoODwoKDw8HR6+3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t4YPDw8KDwoPDwoPDwgPCg8PCggPEJu3t8bV0b63t2oHCgoKCgoKCgoOCgoKCgoICg8KCg8KjLe3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7amlK23 + t7e3t7e3t7e3t7e0SwcICgoICg8KCgoKCgoKDwoKDwoKgLe3wNXPure2WgcICgoKCAcPCgoICAoICggK + CAoKDwdHsre3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e1eRwQNYu3t7e3t7e3t7e3t48QBwgKCAoKCAgKCAgKCAoICggKCgdqt7e+0cm3t7E1DAoKCAoKCgoK + BwoKCgcKCgoKDwoKCgqEt7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t48KCgoHNaW3t7e3t7e3t7eySwcKCgoPCgoKCgoKCgoKCggKCgoMDEq3t7vNxre3oRwK + CgoPCgoKCgoKCgoKCgoPCgoKDwoKCkevt7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3bgwKCgoKjre3t7e3t7e3t4YKCgoKCgoKCAoKCgoKDwoKCggKCgoMNbC3 + tsnCt7eUEAoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCnm3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7eADAoKChyjt7e3t7e3t7ewNQwKCgoKCgoKCgoKCgoKCgoK + CgoKCgwcobe3xr63t38KDAoKCgoMCgoKCgoKCgwKCgwKCgwKCgoKHJy3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7BHDAcKara3t7e3t7e3tmoMCgwKCgoLCwoK + CgoMCgoKCgoKCwoKCgqUt7fCvLe3eQwKCgwLCgoKCgoKCgsKCgoKCgsKCgsKCgoMS7G3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t6qAX4a1t7e3t7e3t7ePHAsK + CgoLCgoKCgoKCgoKCgsKCgoKCgoKCoa3t764t7dgDAoLDAwMCwwLCgwKDAwLDAsKDAoMCwwMCgwLhre3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3pTUMDAsMDAwLDAsKCgoKCgwKCgoKDAsKCgoLfLe3vLe3t1wMBQsLDAsLDAsLDAsMCwsMCwsMCwsL + DAsLCmCut7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7hbDAsMDAsLCwsMCwoFCgsMCwULCgULCwoFBQx1t7e6t7e2SwULCwsLCwsMCwsLCwsL + CwwLCwsLCwsLCwp1tLe3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e2eQsMCwsMCwsLCwwLCwsLCwwLCwsLBQwLCgsLDF+3t7i3t7ZLBQsLCwsL + CwsLCwsLCwsLCwsLCwsLCwsLX7W3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t4ALCwsLCwsLCwsLCwsKCwsLCwsLCwsLCwsLCwsMXLe3uLe3 + tUIFCwsLCwsLCwsLCwsLCwsLCwsLCwsJBVqxt7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7eGFwsLCwsLCwsLCwsKCwsLCwsLCwsLCwsKCwsL + CQVctre3t7e0RwwFCwsLBQsLCwULCwsFCwsLBQsLCQU1ore3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3hhsFCwsLCwsLCwUFCwUJCQkFCwsF + CwsFCwUJCQkJBVu3t7e3t7RCBQkJCQkJCQkJCQkJCwsJCQsLCQkLCYS3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3toQbCwsFBQkJCwkJCwsL + CwkJCwkJCQkJCwsLCwkJCQUFW7e3t7e3tEgFBgkJCQkJBgYJCQYJCQkGBgkJCQVJtLe3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e0mY6PhF9C + FwUJBgsFBQYGBQsJBgsJCQkGBgkJBgUJBQVbt7e3t7e2SAUJBgkGCQkJCQkJCQYJCQkJCQYJCYi3t7e3 + t7e3t7e3t7elmbW3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7SZXBcFBQkGCwsGBgYJBQkJCQYGBQUJCQUFBVy3t7a3t7ZLBQkJCQkJBgkJBgYJCwkFBgYJ + CQVCsbe3t7e3t7e3t7exfB0Xda+3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3jUIJCwsFBgsJCQkGCQYJCQkGCwYJBgUFX7e3uLe3t1sFBgYGCQkGBgYG + CQYGBgYGBgYGBXa3t7e3t7e3t7e3okkGBQUGQpe3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3rkkGBgkGBgYGBgkGCRMJBgYGBgYGBgV1t7e6uLe3XwUG + BhMGBgYJCRMGBgYGBgYGBgYYm7e3t7e3t7e3t6BDBQYGBgYFG2qlt7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3tbW3t7e3t7e3t7e3t7e3t7WOSAYGCQYGBgkGBgYGBgYGCQYJBgYGBXy3 + t7y6t7d5BgYGBgkGBgYGBgYGBgYGBgkGBkOvt7e3t7e3t7etQgUJBgYGBgYGBh18sLe3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3tpxbhbe3t7e3hYWir7GvpZd8RBcFBgYGBgYTCQkGBhMJBgYG + BhMGBgYGhbe3vr63t4QGBgYRBgYTBgYGBgYGBgYGBgYGTba3t7e3t7e3tmAFERMGBhMGBgYGBgZDfKW2 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3tZdbGwVft7e3t7eEExsdQ0AeFwYGBgYGEwYGBgYG + EwYGBgYGBgYGBgYGExeNt7fCwre3jRMGEQYGBgYGEQYTBgYGBgYGBgZft7e3t7e3t7ecGAYGBgYGBgYG + BgYRBgYGHV6Xsbe3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e2pYJIGAYGBkK0t7e3t7AdBgYABgYRBgYG + BgYGBhEGBgYGBgYGCQYGBgYGEQYGG6O3t8bGt7ejGwYGBhMGBgYGBgYGBgYGBgYGBna3t7e3t7e3t3UG + BgYRBgYGEQYGBgYGBgYGABdCdI6ttre3t7e3t7e3t7e3t7e3t7e3t7SihFseBgYGBgYGGJu3t7e3tk0G + BgYGBgYGBgYRBgYGBgYGBhEGBgYREQYRBgYGBgYdrre3ycm2t69ABgYGEQYRBgYRBgYREQYREQYGfLe3 + t7e3t7e1SAYREQYGBhERBhEGBhEGBhERBgYAER1NdoWcpbG1tre3tra1tK+ijnteRBsGAAYGEQYRBgYG + Xre3t7e3fAYGBhEGBgYGEQYREQYGBgYRBhEGBhEGBgYGEQYGBki2t7jNz7q3tkkABgYGBgYGBgYGEQYG + BgYGBgB2t7e3t7e3t68+BgYGBhEGBgYGBgYGBgYRBgYGBgYRBgYGERgeQERJTVFRTUlCHRsRBgYGBgYG + EQYGBgYGEQYbnLe3t7eFEwYGBgYGEQYRBgYGBgYRBhEGBgYRBgYGEQYRBhEGXre3vNHTvLe3dAAGBgYR + BhEGBgYGBgYGBgYRAF+3t7e3t7e3rx0AEREGBhEGBgYREQYGBgYGBgYGBhEGBgYRBgYGBgAAAAAAAAYG + BhMGEQYRBgYGEQYGEREGBgBNuLe3t44REREGBgYRBgYGEQYGBhEGBgYRCREJEREGBgYGBgZ7t7e+09XA + t7eFEREREREGEREREREREREREREATba3t7e3t7exQwAREREREQYREQYRAxEREREREREGEQYDEREGEREG + EQYREREJEQYREQYRBhERAxEGAxEGERERERF2tre3jREGEQYREREGERERBhEREQYREREREQkREQYRERER + GJm3t8bV1ca3t6IbBhERBhEGBgYGEQYRBhEGEQBAr7e3t7e3t7ZNABEGBhEGEREGEQYGBgYRBhEGEQYR + EQYRBhEGBgYGERERAwkGEQYREQYRBhEGBgYRBhEGBgYRBhF8treFExEGBhEGBgYRBgYGEQYGBhEGBhER + EREGEQYREQY+r7e3ydXVy7a3tEQGERERBhEREREREQYRERERBhict7e3t7e3t3wGEQYREREGEREGERER + ERERBhEREREGERERBhERERERERMDEQMREREGERERBhERERERBhEREREGERh0sXsGERERERERERERERER + ERERERERERERCREREREGAFG2t7rR1dXRure3dQMREREREREREREREREREREDA3y3t7e3t7e3nBoREQMT + EREREREREREREREREREREREREREREREREREDExERERERERMDAwMTAxMRERERERERERERERFFRBERERER + ERERERERERERERERERERERERERERERERgbe3vNPV1dXAt7eIEhEREREREREREREREREREREDRK+3t7e3 + t7e2XgMRERERERERERERERERERERERERERERERERERERERERERERERERAwMTAxMDAwMRERERERERERER + ERERERERERERERERERERERERERERERERERERERERERqjt7fG1dXV1cm3t7A+AxERAxERERERERERERER + ERERhbe3t7e3t7eiPhEDEhERERERERERERERERIDERERERERERIREREREREDEREREREREREREQMSERER + AxEREREREREREREREREREQQSERERERERAxIDEhEREREREhERERERRLS3t8vV1dXVzbi3t14AERESERES + EREREREREREREQNEr7e3t7e3t7eNHgMREREREREREREREREREREDEhERERERERERERERERIRERIDERES + AxERERERERESERESAxERERERERERERERERERERIDERERERERERERERERERERERF3t7e40dXV1dXVvre3 + hwQEEREEAxIDEQQRAwQSAxIDERF6t7e3t7e3t7eZRAQDAxERBAQEEREDEgMRAwMRAxIDERIDEQMDBBES + EgMRAxEDAwMSAwMRAxEDEQMSEQMRAxERAxEDERESEQISAhIDEQMREQMRAxIDAwMRAxIRAwMDGpy3t8DV + 1dXV1dXJt7evPgMDERERAwMREQMSAwMRAxEEBBqXt7e3t7e3t7ewdjwDARESEREEBBEDEQMSERIDAwMR + AxEDEhERAwMDEQMSAxIREgMSERIDEhESAwMDEgMSAxIEEhERAwMRERERAxEDEgQRAxESAwMSAxEDERER + EgNJtbe20dXV1dXV1c+6t7d2BBERBBEEEQQDEhEEEQQSBBERA0Cjt7e3t7e3t7e3onYeAREEEQQRBBID + AxIEAwMSEQQEBBEEEQQRBBEEEQQRBAMDBAMEAxIDBBEDEhEEEQQEBAQRBBERBBECEQISBBIEEQQRBAMS + EQQEEQMSAxIDA4G3t77T1dXV1dXV1cK3t5waBAQRBBEEERIDBBEEEQMEBBEEBESit7e3t7e3t7e3t5xM + BBEEEQQRAxIDBAQSBBEEEQQSBBEEERIDBBEEEQQREgMSEgMSAwQRBBIDBBEEEREEEQQRBAQREREREQQD + EQQEEQQRBBEEEQQSBAQEBAM+rbe3w9XV1dXV1dXVy7e3tlsEERERBBERBBERAxIRBBESAwMSBESat7e3 + t7e3t7e3t69eEhEREREDEgMEEhIRBBIDAxISBBIEEQMSEQMSAxIDEhESBBIDEQMSBBIDEgMSEQQDEgQR + EQQREREREREREQQSAxIDEhEEAxIDEgMDA3a3t7jP1dXV1dXV1dXTvLe3jRQEBAMEBAQEAwQEAwQEAwME + BAQDAxl7tLe3t7e3t7e3t7VyAgISAQQEBAQDAwQEAwQEBAMEAwQEBAQDBAQDBAMEAwMDBAQEBAQDBAQE + AwQDBAQDBAMEBBIBAgIRAhECBAQEBAQDBAQDBAQEAwQZo7e3wNXV1dXV1dXV1dXJt7e1TAMEEQIEBAQE + AwQEBAQEAwQEAwQDBARMjbS3t7e3t7e3t69SAQESBAMEAwMDBAQDBAQDBAMDBAQEBAQDBAQEBAMEBAQD + BAMEBAQDAwQEBAMEAwQEBAMEAhECEQERAhEDAwMEBAMDBAMDBAQEA163t7fL1dXV1dXV1dXV1dG8t7eI + EgQCEQQEAwQEBAQDAwQDBAQDAwMEBAESRYGitre3t7e3t5gVAhEEAwQDAwQEAwMEBAMDAwMDAwMDEgQE + AwMEBAQDBAMEBAMDAwMEBAMDBAMSBAMEBAQRAhECEQIRAgMDBAQDBAMDBAQDAwQanLe3vtPV1dXV1dXV + 1dXV1cm3t7VOARESAhEEAwQDAwMEBAQDBAMEAwQDBAQDAxlbore3t7e3tlsBEQMEBBIDAwMDBBIDAwQE + AwMEAwMEBAMEBAMEBAMEAwMEBAMEEgMDBAQEAwQEAwQEAxECEQICAhEBBAMEAwMEAwQDBAMEAV23t7fJ + 1dXV1dXV1dXV1dXV0by3t5cWAQIRAgQEBAQEEgQEBAQEBAQEBAQEBAQEBAFGsLe3t7e3hxIRBAQEBAQE + BAQEBAQEBAQEBAQEBAQEBAQEBAMEBAQEBAQEBAQEBAQEBAQEBAQDBAQEAhECEQQRBAQEBAQEBAQEBAQE + BAMZo7e3vtPV1dXV1dXV1dXV1dXVybe3tl4BEQIRBAQEBAQEBAQEBAQEBAQEBAQEBAMCEgF6t7e3t7ej + FQEEBAQEBAMEBAQEBAQDBAQEBAQEBAMEBAQEBAMEBAQEBAQDBAQDBAQEAwQEBAQEBAQRAhECBAQEBAQE + BAQEBAQEBAQEAne3t7nJ1dXV1dXV1dXV1dXV1dXRvLe3ojwBEQIDBAQEAwQDBAQEAwQDBAQEAwQEBAIR + AU+2t7e3t7A8AgQEAwQEBAQEBAQEBAQEBAMEAwQEBAQEAwQEBAQEAwQEBAQEBAQEBAMEBAQDBAQDBBER + AhEEBAQEAwQEBAMEAwQEBAREsLe3wNXV1dXV1dXV1dXV1dXV1dXLuLe3exIBAgICAhECEQERAgEBBAQE + BAQBAhICEQIBUra3t7e3rjwBAgEBBAQEBAQCBAQEBAQEBAICAgICAgICAgICAgQEBAQCBAQEBAQEBAQE + BAQEBAQEAgEEBAQEBAQEBAQEBAQEBAQEFIe3t7jN1dXV1dXV1dXV1dXV1dXV1dXCt7e0TwEREQICAgIR + AgICAgQEAQQEBAIBAgICAgFzt7e3t7eiGQECAgQEBAQEBAQCBAQEBAQEAgICAgICAgIRAhECBAQEBAQC + BAQSBAQEEgQEBBIEBAQCAgQBBAQEBAQEBAQEBAQEBARdtre3w9XV1dXV1dXV1dXV1dXV1dXV1c+6t7ec + PAICAgIRAgICAgICAgIEAgICEgICAgICPqK3t7e3t40SAgICAgICAgIEAgQCBAICAgICAgICAgICAgIC + AhIEBAIEAgQCAgIEAgICAgICAgICBAICBAICBAICAgQCAgICAgIEP623t7zR1dXV1dXV1dXV1dXV1dXV + 1dXV1cm3t7eBFAICAgICEgICAgICAgICBAQUGRQSFEWat7e3t7e3cwICAgICAgQEAgIEAgQCAgQEAgIC + AgICAgICEQICAgIEBAIEAgICBAIEAgICBAICBAQCAgICAgICAgQEAgICAgQCBBaHt7e4y9XV1dXV1dXV + 1dXV1dXV1dXV1dXV08C3t7ZeAhICAgICBAQEAgICAgQETI2il4eYsbe3t7e3t7A+AgICAgICAgIEBAIC + AgQCEgICAgICAgICAgICAgISAgQCAgICAgICEgICFAIEAgICBAICBAQCBAQCAgQCBAICAgIEd7e3t8bV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXVz7i3t69BAgISAhIEAhICBAQEBEG5t7e3t7e3t7e3t7e3eAICAgIC + EgICBAQEAgICAgIEBAICAhQCAgICAgICAgICBAIEBAIUAgQCAgQCBAIEBAICEgQCAgIEBBICAgQCBAIE + BE60t7e+09XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV0bi3t5w8AgICAhICAgICAgICc7e3t7e3t7e3t7e3 + t5gVAgICAhQCAgICFAICAgISAgICAgICAgICAgIUAgICAgICAgICAgICAgICAgICBAICAgICBBQCAgQC + AgIEAgQCAgRGrbe3us3V1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXVxre3t40VAgICAgICAgICFAJ6t7e3 + t7e3t7e3t7ecPgIRAgICAhQEBAICAgICAgQCAgISAgICAgICAgICAhQCAgICAgICAgICAgICAgQCBAIC + AgICAgICFAICAgIEAgICPZq3t7fJ1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXTwre3t4MWAgICAgIC + AgICAk62t7e3t7e3t7e4hz0CAgICAgIUAgIUAgICFAICAhICAgICAgICAgICFAIUAgICEgICAgICAgIC + AhQUAgQCBAICAgIUAgICEQICAgICAjyHt7e3w9XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXRvre3 + tnoUAgICBAQCAgICFHivt7e3t7e0mF0WAgICAgICAgICAgICAgICAgIUAgICAgICAgICAgICAgICAgIC + EgICAgICAgICAgICAgQCAgICAgICAgICAgICAgIVg7e3t8DT1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXPvLe3tngUAgIUAgICAgICFEFdc4F6XUEUAgICAgIUAgICAgIUAgICAgICAgICAgICAgICAgIC + AgICAgICAhICAgICAgICAgICAgIEAgICAgICAgIUAhICFAICFYO3t7e+0dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXNure3tngUBAICAhQCAgICBAEBAgICAgICAgICAgICAhQCAgICEgICAhQCAgIU + AgICAgICAgIUAhQCAgICAgICAgICAgICFAICBAIUAgICAhQCAgICAgICAhWDt7e3vtHV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXNure3tnoUAgICAgICAgIUAgICAgICAgIUAgICAgICAgICAgIC + FAICAgICAgIUAgICAgICFAICAgICFAICAgICAhQCAhQCAgICAgICAgICAgICAgICAgQVhbe3t7zP1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXLure3toM8AgICAgICAgICAgICAgICAgICAhQC + AgICAgICAgICAgICAgICAgQCAhQCAgICAgICAgIEAgICAgICAgICAgICAgICAgICAgICAgICAgICPI23 + t7e8z9XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXNvLe3t409AgICAgICAgICAgIC + AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAhQCAgIC + AgICAkGYt7e3vs/V1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXTure3t6NFAgIC + AgICAgICAgICAgICAgICFAICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC + AgICAgICAgICAgJOure3t77P1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXP + vre3t69yAgICAgICAgICAgICAgICAgICAgICAgICFAICAgICAgICAgICFAICAgICFAICAgICAgIUAgIC + AgICAgICAgICAgICAgICAgIWd7G3t7fA0dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXRwre3t7aDPAICAgICAgICAgICAgICAgICAgICAgICAgIUAgICFAICAgICAgIUAgICAgIU + AgICAgICAgICAgICAgICAgICAgICAgICP4e3t7e4xtPV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXVxri3t7eiThQCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC + AgICAgICAgICAgICAgICAhQCAgICAgICAgIUAgICFl2tt7e3usnV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXVzb63t7e1gz8CAgIUAgICAgICAgICAgICAgICAgICAgIC + AgICFAICAgICAgICAgICAgICAgICFAICAgICAgICAgICAgICAkGHtre3t77N1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV0cK3t7e3unIVAgICAgICAgICFAICAgIC + AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIUAgICAgICAgICAjxzube3t7jG0dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV08m8t7e4uLxQFgICAgIC + AgICAgICAgICAgICAhQCAgIUAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICARVyo7e3t7e8y9PV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dHCtre3 + t7eYUBYCAgICAgICAgICAgICAgICAgICAgICAgICAgIUAgICAgICAgICAgICAhQCAgICAgICAjxdoLe3 + t7e4w9HV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXLxLe3t7e2ml09AgICAhQCAgICAgICAgICAhQCAgICAhQCAgICAgICFAICAgICAgICAgICAgIC + Aj1yoLa3t7e3xs3V1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXRyby3t7e3t6J6RhYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC + AgICAgICFlKCure3t7e3vsnT1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1cm+t7e3t7e0mHM/FAICAgICAgICAgICAgICAgICAgICAgIC + AgICAgICAgICAgIWQXectba2t7e2vsnV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dPJvri3t7e3t6+Yd1I9AgICAQICAgICAgIC + AgICAgICAgICAgICAgICFDxOepq0t7e3t7e4wM3T1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXVzcK6t7e3t7e3tq2YeF1B + PBYWAgICAgICAgICAgICAgICFj1GXYGYsLe3t7e3t7e+xs3V1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dHJwLq3 + t7e3t7e3t7WwoL6CeHJdUE5PT05QXXN4go2ir7W3t7e3t7e3t77AydHV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXT0cnCvLa3t7e3t7e3tbW4uLe3t7a2t7e3t7e3t7e3t7e3t7e3vMbJ0dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXTzcnCvrq4t7e2tbe3t7e3t7e3t7e3t7e3t7e4ur7Gzc3T1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXT0c3Jxsa/ubm3t7e3t7e3uLq+vsDGzc3R1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1f////////AAAA////// + //////////4AAAAA///////////////gAAAAAA//////////////gAAAAAAB/////////////AAAAAAA + AH////////////AAAAAAAAAf///////////AAAAAAAAAA///////////AAAAAAAAAAD//////////gAA + AAAAAAAAf/////////AAAAAAAAAAAB/////////gAAAAAAAAAAAP////////wAAAAAAAAAAAA/////// + /4AAAAAAAAAAAAH///////4AAAAAAAAAAAAA///////+AAAAAAAAAAAAAD//////+AAAAAAAAAAAAAAf + //////AAAAAAAAAAAAAAD//////gAAAAAAAAAAAAAAf/////wAAAAAAAAAAAAAAD/////wAAAAAAAAAA + AAAAAf////8AAAAAAAAAAAAAAAD////+AAAAAAAAAAAAAAAAf////AAAAAAAAAAAAAAAAD////wAAAAA + AAAAAAAAAAA////4AAAAAAAAAAAAAAAAH///8AAAAAAAAAAAAAAAAA///+AAAAAAAAAAAAAAAAAH///A + AAAAAAAAAAAAAAAAB///wAAAAAAAAAAAAAAAAAP//4AAAAAAAAAAAAAAAAAB//+AAAAAAAAAAAAAAAAA + Af//AAAAAAAAAAAAAAAAAAD//wAAAAAAAAAAAAAAAAAAf/4AAAAAAAAAAAAAAAAAAH/8AAAAAAAAAAAA + AAAAAAA//AAAAAAAAAAAAAAAAAAAP/gAAAAAAAAAAAAAAAAAAB/4AAAAAAAAAAAAAAAAAAAf8AAAAAAA + AAAAAAAAAAAAH/AAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAP4AAAAAAAAAAAAAAAAAAAD+AA + AAAAAAAAAAAAAAAAAAfAAAAAAAAAAAAAAAAAAAAHwAAAAAAAAAAAAAAAAAAAA8AAAAAAAAAAAAAAAAAA + AAPAAAAAAAAAAAAAAAAAAAADgAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAA + AAAAAAABgAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAA + AAAAAAABgAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAAAAPAAAAAAAAAAAAAAAAAAAADwAAAAAAA + AAAAAAAAAAAAA+AAAAAAAAAAAAAAAAAAAAfgAAAAAAAAAAAAAAAAAAAH4AAAAAAAAAAAAAAAAAAAB/AA + AAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAH/gAAAAAAAAAAAAAAAAA + AB/4AAAAAAAAAAAAAAAAAAAf/AAAAAAAAAAAAAAAAAAAP/wAAAAAAAAAAAAAAAAAAD/+AAAAAAAAAAAA + AAAAAAB//gAAAAAAAAAAAAAAAAAA//8AAAAAAAAAAAAAAAAAAP//gAAAAAAAAAAAAAAAAAH//4AAAAAA + AAAAAAAAAAAB///AAAAAAAAAAAAAAAAAA///wAAAAAAAAAAAAAAAAAf//+AAAAAAAAAAAAAAAAAH///w + AAAAAAAAAAAAAAAAD///+AAAAAAAAAAAAAAAAB////gAAAAAAAAAAAAAAAA////8AAAAAAAAAAAAAAAA + P////gAAAAAAAAAAAAAAAH////8AAAAAAAAAAAAAAAD/////gAAAAAAAAAAAAAAB/////8AAAAAAAAAA + AAAAA//////gAAAAAAAAAAAAAAf/////8AAAAAAAAAAAAAAP//////gAAAAAAAAAAAAAH//////8AAAA + AAAAAAAAAD///////wAAAAAAAAAAAAD///////+AAAAAAAAAAAAB////////wAAAAAAAAAAAA/////// + /+AAAAAAAAAAAAf////////4AAAAAAAAAAAf/////////gAAAAAAAAAAf/////////8AAAAAAAAAAP// + ////////4AAAAAAAAAf///////////AAAAAAAAAP///////////+AAAAAAAAf////////////4AAAAAA + Af/////////////gAAAAAA///////////////gAAAAB////////////////gAAAP////////iVBORw0K + GgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAACAAElEQVR42u29d7jlRnkH/BtJp91e9m7vfddbve5e + l7XXgDFumBJKsI0hhA8IxaR8CQTzQUgoCZBAgGCwKYYEMLhQjNuu7XX3Nm/v9W67e/s991Rpvj+k0RnN + mZF0yt3m83ue8+hIGk15523zzmhEKKWo4axAO4BuALAsawYAaJp2jFJ6KSFkKqV0PyHkKgBLALQ4v1YA + GBhMT2hqjJdSVnJgMF3f1BjvBLDPubYdwDEuzQZKaT+ldJ+maX2sbjWcXSA1BXBGo92yrBZCyDQAIISk + KKUfJYRMATANwAQAnWUIeDVwcmAwPcpREr0A+gCsppT2E0L2Adjv/GqK4QxGTQGcQbAsa4ZjTW8FsBjA + VABLBwbTEyIxA4mocbqrWAqYYtgPYAOAAwDWo6YUzijUFMBphCPwS2C77UsATB0YTC84Ddb8VKETQC+l + dCNspbCBELIeNYVw2lBTAKcW7ZTSpXAE3nHllwKoLzfDVDbv8QwGBtPu/0zOREdb2VkHlgsg0Cth6RjE + ujY1xjdTSjcSQlaj5iGcctQUwMijHcDV7FdtCy8K4qlSAKzschWAQoGwoONqAN9yrtWUwQiipgBGAMy1 + p5TeSghZDDtgNyKSyAQpl7GPmZyJVCqLyRNaNz/30p4FADAwlMHgcBZ5J+1Q1oSZznnyaW6ylZLhCGRj + XRQtzQkkElE01kURixlIJKKIRXREYgZymTyaGuPJoHaJCkCESoE43sEa2IHFZ2pDhZFBTQFUEZTSlYSQ + m2Fb+6oL/VAqi1Qqh2MnBtDXN4zOE4M4cbQPh08MYiCZQX/3EDLZPPr7U+jpGy563rSC+1rXCEyLQtcI + jIiOfM5EW0sdAKC5OYFY1EBbRxPGjqpHc30Mo8e1YNqkNrQ1J9A2qgF18YhHqMtVADw4ZfAPlNJETRlU + DzUFUDmWAYgD+DcAy8vNROIqJ3ft7ao/dmIABw73Yt/Bbuzc04W+gRT6+1MYHEiVJNCl3PN7RpYWANpa + 6tDcnMDocS2YNakN48c2Y/r0Dkyf0o6GhpjYtkpp/h1K6cOEkCcrzeiNjpoCKBOU0pUA7hgcyryv0jF9 + KpvH0FAGh470YceOY9h94CS2bjuKE122Zc9k1FY0rLAyQWXwe4b3AsR04jU/JWJEdIwd24wJE1oxYXQj + zl80CbOnd2DW9I7AoUNI1IYIFaKmAEqAM7ZfAeB2AHMBjCo3r4HBNHYf6MaOHcewZu0BHO3swaEjfcjn + zNDWFwinAPwEuVQvIMij4CFL19JSh/HjW3De7DGuQpg4sbVSr+AkgPsppX+uKYLSUFMA4bAMwB2wp+/K + dvMPH+vH9j0nsHHDIby24SBOdA2iqyfpScOEqBQlEOY5XnDLGRaEKU+laFT10jWCtpY6jJ/QiuUXTsOS + xZMwfUp7pTMXawD8BMDvUFMEgagpAH8wwb8V9rLbknGwsxebth3FH5/ejqOdPdh3oLski81b1Uossp9g + hrH2YRWILP+w0DWCubPG4IIlk3HJRdMwe8boImXApjkDVkYmAeyjlP6EUvo7TdP2hK7EGww1BSBHRYLf + 1ZPEK+sO4Pl1B7Bp02EcPtRTJNBhxuClgHfpVfmXWnbQMKGUugfVS7weixmYNL4Fl180HSuumoPZMzrQ + kIh6FAAQKqC4uaYI1KgpAA7OGP9TKEPwh1JZbNl+DC+/sherX9ittPRh3e9Sxu2y62Hd8Upc/nLTlEqX + uoYYZk3rwJtXzMXF50/BmI5GACUvdNpMKf0JIeQ+1IYGLmoKAK7g3wHgTpQo+MzaP/rkVmzdegR9kvl3 + ETIXXyW4fkIdpBBk+fNpZNfFe0EKIqyrX60px7aWOixbNhU3XjcfUya1YfKE1lK6C6jFCDx4oyuAdtjW + /naEDO6x+frDh3vx9LM78edV2zzWvhrucpj0pbjaQVN3fgJfSsCwnNhAueWxeMFNb1mIlSvmlhM4rK0l + wBtbAdwG4FMDg+nlYefxU9k8tu08jj88vhmrn91ZFMHnIWN0HqXEBGR5B83P89fCDhHKqb8sr1LrJ6tr + UPtZHXSNYNqUdlx71Vy86eo5mDW9IzQdAXRSSlcTQr4JYG0pD54reMMpADbOHxhMf7wUwV+38RAefmwz + 1q7drxT8UpmYD9oBpSuBoGdUAsY/F0YIy1kQVKqyCVp4FKZOozsacf0183DT9QvLUQTfeiPGB95ICqAs + d3/dxkP4xe/WY+2GAxgeynjuV+K+luMBlBOICzNNGGaqrxrrCMLGAcpZuMSjo60eb73uvHIUwRpK6Rff + SMOCN4oCWAbgHgArICxBHRhMe6aUunqS7G26tR/7x98u27T5cFFgr5xpOhF+Y/VqLdopZT2BX/myZ/yu + h1VuYZccl7pOgaGjrR43X78Qt7xtcehgofPi0XcAfCJkV57VONcVQDul9E5CyKegiO6L88qHD/fifx9a + VzTGH0mhF6/Jygwzz+/3nF9dSpldCKprOZ5OOUOnsO0EgClT2nHD9Ytw21sWlBIsXAN7T4IHwz5wNuJc + VgDM6r/NLxFTAH0DKTz0+414+E+b0NM3XNZYvtJlseUG8fzG8eUG30qpf6meSDnBvmrgvDlj8f53X4Qb + Vs5nLyMFvZSUBHAfbD46J2MD56oC+BDsTguc02fz+D//v1ewfddx38BcGHe8FKspy7ecabygPGX5Vmr1 + g4YwYdtQbsxAVacwdLnssln47lfevhnh92w4Z2MD55QCKDXCv2n7USycO+7zS6/+6pfCjn15hLVmlQS5 + wizYkd0PG2MQ61PpOoKgtoe9p0pXrXUJLFD4F+++CBNGNQTWAfZ2ZffgHFtAdM4oAGc3ni8gRIS/qyeJ + Bx/bjN88+BpOdA0CCBc9lwlcpYqilBVy5a7Kq2TpcLnrCMLSppptLefdBTYsuObK2aFeSaaUPkAp/cK5 + 8l7BOaEAKKWf9Qv08Xh5/UF8595nsXlLZ8nMwqMcZmPPAeUpjGoKRZigYrnrCMqhWznBPT8aMATFQwD7 + xaObrl+I2999UdjZgs2U0k+fC0OCs10BtMN2y+5EwFiueyCF3/x2HX710Do3ul/OlJXf/zD5hEEp0XOG + oCFA2DG3mF8p6wjC0Eu8X438VTRjz4b1MGZOG4W7/vKysN4AGxLcG5TwTMbZrABCRfkBe6z/3fufx8sv + 7Sk7cFRqRJ+hlPLKGRPLrpViXVVtUOXjl76U51RpwtSnHM8obDuYN/D5z7z5JAJ2fOLWDNyDszQucFYq + AGe8/00AC/zSDQym8YfHt+Den70gXb47kmNaHmGVRLlLcUtZqhtGGZRKi1Ii/GGFN4xCK1VhlpJ+7qwx + +PhfXYXLL5wWmB7A7y3L+tTZGBc4GxVAqCm+w8f6cd8vXsJvH9kQyIylBMWA0rfXLsfr8MtXVgeV0il3 + 4VClnkqpgcZSr5UbgymlnI62erz3/Zfh3TcsREMiGpTdGgCfwln2UtHZpADaAdw6MJj+YdAU37rNnfj6 + t5/Alh3Hiu6FcUeD0gc9EyafUqccS6mbqo7lzNOr8gs7e1GK1Q1Dg3LzD5OXKv/rrp2Pj39weZgAYSeA + T+IsWj141igASunPCSHv80uTyubx8GOb8cMfPyfdbLOc+eNSGKzStDIBLSfPIKUl5s+nLYUW5dC01AVK + Yfup3PLD9t95c8bilz+8YzMChp0OPgw7ONiOMzw2cLYogC8B+JxfgoHBNO7/xUv42W9eK9pHv5yIdCWL + VMrxDiqJK5QbSS+1LeW0byTiGtUsP4wXxe53tNXjMx+/ll9K7IflALajpgDKh2VZMwghXwyy/Ac7e/HV + 767CCy/sKmmFmwzlCkypCDNNVwrDhwnyhbWApaTxGwqw9pXiDYTJO0xdSy0/rGcQixn4y3dcgL/5yNW+ + SsCZIVgO4PmyGOQU4YxVAM6y3m8hYJpv0/aj+Np/PYWNmw6XZcmrMf6vxty/LO9yFseEteKl1H2kp/FK + 6ZORKL9UOusawfVvXYSv/N31QVOFSQDfBPB5nKE4IxUAtzvvx/3SPffSHnzze6uwe99Jz3WZdWXnlVht + sYxSF+vwdfBLX4lyCRucKycPWZqwCjSIXn73K6GXSgmqyg+jnNizl102E//4iWvDBAfP2LUCZ5wCcIT/ + fgSs6f/Dk1vxH995Cl09yZIj0n5MwWBaFHldg2FaReNFdt/PCrE04vWwVstvGlKWd9gpzlKmN8Mq0rDP + y/oniJ5h6CWWY2oEUQQr/FKGCWLfsufmzx+Pf/rUdVg4dxwCcEZuMnJGKYAwbn8qm8dDj27Et3/0bNEW + XWEgY4i8rgEADNMq6blS01U6ty6mG8nZilLG45W0p1yw/JmwZwHoQnmmRoquVatc/v/MaaPw9596Ey5e + Ojno8TPOE9BOdwUYwo75f/qLl0MJf17XlFqbXWdHw7QQcxQhUwbsyNKprEBQ/rpGYDrnWS4df118zg8Z + QqT/wz7P6uGXthrCz9dtJOAKoUVhWtS2+Dw9R0D4Ge3E/7v3ncTnv/EYnnspcCHgx2EvFjpjcKZ4AO0A + 7keA5f/Jb9biR/c9h0wm77rnrKPFDufdwFMNP4FR1TcoD9Ze8b8f/MrQNeKxmkHDqEqVAl8nZrHhlK9z + ClLn3Hi9gnJU9S+lD1T0VD03uqMR//CZN2Hl5bP8sklSSm85U94kPBM8gHZK6bcRIPw/vG+NK/wA3LG5 + qkOYZfBcC2NhA+7znoEIlr+f9dM5t9UPoicR4xQ1+8+3h3kUpuN1APAtw7RokfCrPCbxKLrBeV1zPS52 + zo4imPCzuplOXuyaKdS9FM9Ghqxw5PP2o09RPEfgNdGDA4ATXYP4168/hief3+VXpXpCyBOU0s+W3agq + 4nR7AOx1XmW0fyiVxU9++Qru/+VLRQt8ALWlF5VCGEtS1xBDfdRAc3MCRkSHTggy2TwGhjIYSmV9hx1h + 56xlY9Wg/MQYBbvHewKlWrWwHkA5yOsaYpRK85N5AHx9mFB6lERAvfziAHwaviw+X9E78Asg8vUUPTTW + Rx1t9fh///Ytvp6As06ArRg8bTjdCuBLAD4NxYKKVDaPH//8Jdz70+c9nZUhxBOdl8FvPpwXoBkTW3HR + 0smYNXMMpk1qw8VLJ3d29SQndLTVJwcG0/WZnIlUKouTvcM4eqwf614/hE1bj2DfgW5XIcnyF+tYjoCp + gnyyIYCsDiqBqNSNl+XH2huUjtVJLFv0ikpd8hs05JMNAcLMApSLMEoAZ8C7A6dTAXzI78UeccwPFDN+ + XtdAKC0aNwLqDmR51DXE8N6bl5a0ZzxDV08S23cew6NPbFV+KYhZQZkQVrqCMEgBisJQ6XJeVT1kwwG+ + bmGUgirfsOXyrroYVwjrbZXT3jD062irxz3/8FZccckMv2SndXeh06IAnPf574fPK70//81r+PYPVkvd + fl4RiAzI3DO/zo/FDHzyI1fj/e+4oBpt2fPxf/rdDNmXg/j68UJZSvCJj6iLbnWYYCArP0U0JGgxzWRp + w9RJ9HRYfVSuPwNv6f2m7vwsumwNQilDBj4fsQ7sGuCNV7B0YerHY3RHI/7lczcGTRGusSzrjtOxn4B+ + zz33nOoylxFC/g0+b1X94cmt+MZ/P410Kie9r1GvwGtOH+RJoVMihECl2667Zh7u/uiKJBAYiwtEOme2 + 3fym85LjxjRHO4/24WS31xvIEwKNAhFSYFpNUi9dI8gT4tZb1+wjpXZ7NUqL2qOFUN4sL53aAqsRgiFK + oGnw0EjmAmsKGrJrrG58fYKqpDltsp+V32dHTagfXy5flzyxhZLlK6Y3NSIti9WBv8+uaVwd+bqyI9+f + nv7WNWiUusfkcBbbdhzF/HnjMGZUo4oskwkh0wE8DiAV2KlVxCmdBbAsawbsr60oV/k9+fwu/Md3nlIG + 3Pj5/QzxjhvDrP6qa4jh5rcsAMLtBx8IZ++4+htWzsev7r2z84rls73ReacernsqiR4Dhag8m6MXZwFY + kEn13w9DlHhokqBW0SyJbH1EGISpG/+fn6WQ0UG1bsLP0vKzB+x59ixvsVVl6YphFF9PN60QN2DwW0y2 + e99JfO2/nsKuvV1+pHwb7ID4KcWpVADthJAvwkf4N20/iq/99yoc477FJ3YE72IapuV2BJ/Gj5k72htw + +YXTTmJkMOGez74Zb79pSRHz65zLLHN7+aMI06IuY2VhDwX4RUy6grkZGggN5RaLU358XrwQ8NdYHcR6 + qv7zikd0v9y8JVOl4pQnXz5Tnian5MQ8dKt4OpGfCmXl63wduLz4oYDbfu5ZfkgKAERwhdZt6cS37n3O + 95PyAO6klK4M7Kgq4pQpAOcbfcrXevce6sVX/v3P6Ozs9cwRiwwjY2TPCjvOAzC5I2DP8bc0JQAgMVLt + 7Girx+c/8+bke25cbLeBY/4MIZ4Vh66S4OeXHWZj7RIFjhcK3lvwo0kWCssY0tK7AsYJjDiXXw6ywrkn + cOmUx+optkcUXpGOLD9x5aS40lNcNyHSh6c7v1bBVHgVzPi4iodTVKtf2IXv37/G/RydBPWEkF+eSiVw + ShSAE/T7lOp+V08S//69Ve4WXnwQBoDS7QKK55X5zmHKgDFEDEAmkwNGfpxV/9d3LMcVy2d7LjKPhf13 + I/mcm+qZyRCWuOqchZbNRfPwBLY44eXzDoI7nOIto+Cii4IYZkgiLlTi8xMXNEUlZfCzPn7IwuuS80u+ + xXZCKIenNb9wyAygoe+UpUXx20c24JcPrkUqm4cCowghX3CGyyOOEVcAzqYe34Qi4p/K5vH9+9fYm3lI + LBw7ui6ooARE94wXellnHDsxCEpp/0i3u6OtHnd/dAVmTiu8Ls6PhV0LxDFUFCgar/LWl52LSk8Gcdxq + KgRY+bwgFH4r6njEQgQm+TiNuICJV1QmOxfcf3G1IA8xJiTGIli7WD1FSy2jjx+dRIjPsPbwnsP371+D + p5/d6ZfNcme43F5C0WVhpGcB2gF8lRCidGl+89B63PuzF2Ba1I24sug0O7IoOov485FejRDAom4kmGcs + WIVoLEM6nUM+Z7ZdfMHUkaYtWpsTaGiMY81Le2CalidqLkbwTY1AR3F0nEWz2ZEJCmu3Cjwt+VkRNlMS + 9LxYPnueEq+7rAl9wRZYRQh8ZwTYPRaFj6IwY2Jq3tkQXomzessWEvG8wejJhl2UAjmtEKE3CfHMWrC2 + 6YCbP6OPOxPgM7PE050/8nVh+VEKbNp6BAvOm4Bxo5uk+RBCZlBK+wkhL5TOeeExoh5A0Lj/+Vf3ucLP + g1l8fpzlWcjCjWdFd1885+eomSV4+E+b8Pyr+0ay6S6uuXI2Vlw5x3NNdF1ZfT3DGM7jMSXWkqeNrhGk + iOY5sv+i58BbVlOwrDLwqwr5OIUn8KYV1vMD3qGOLqkj+8+3nc/PQwtHofC8wR/5oYInau/kKQ672JFf + Qs3AD6lMrm1un3AxCb6PeNqb3D1+SMfXF7DfG/jm91bh8DGlM1rvDJtvG0n+HDEPwBn3/xsAqYo72NmL + L33jMew70gdKvPO0mqONmbXROMuXJ4XxMEujcxbfM+0jLJ1lVnc4lcPmHccwekwTpk8eWS8romuoq4ti + 1Qu7kcuanvbw7RKPzOPh26dzlomPFQzDXuSjEYIoJ8dR4rWqLB/+vNBf6jYMQ0OUUvlcutMfEUJgotBv + lmNtNUIwDA06pYhr9pRklMBdlwBJnfijpdl9xzw5vs/zuoYYHGXgrAMQ28k8GHF+3uULLm3eyZuvSxGP + ATAZfTk6ZwEkSOEee1bnvAixbsdPDKC7L4VLL5qGaESXkb4JwHjLsp4lhPSOBH+OlAJod4RfutRuKJXF + 17+7Ci+9us9ddMHAiMPcftdtcjqGMRwjrp8QFfIq5tz+/hSee3kv1m85ClCK3v4UOo/1Y+OWTjz6p014 + 4KH1+ONT27B9+1H0DqRQVxdFU0PwJ8dl6OhoxObtx3HwYLenfYDXBeYXpuiA6zaKSo0/jzhCz4SMLfTJ + wlEGCrrw9AlCBPJ5ctYffDwi6tTZ0goudlwr1C/P1ZcpKCYkEULcc3eoQwsvPTGBdRftEJtGpuJZUyOO + AqQuD7B6sf+UQCiveDUiBMXMyjRZH3HnjAZ8XVR10yhwqLMXLU0JLJo/XkX+yYQQDcCfymK+AIzUUmDf + bbx/9Ju1+PZ/PuGey6K54htjKibmIUtDhaWqqqWzdQ0xmDkTmUy+KOrOXhp6981LcdObFyDowyQy/OHJ + rbjnq3/0LG12vRqewZ09DsK0W1yOyp5n7jWb/2dLdNmy3TA0FPumaL5cGELI3vCTPZ8iGhoIF2AUAm56 + gMJS5c/q4Pf+gWyxjkh7WZ1V9eGXEoeps6odLS11+PoXb1EuFx4YTKOxIXbdSLwvUHUPwHH9vw3FMtuX + 1x/E17/9BNLpHFJEQwTUtSTMbQIKml3F/MwKMCGXWVWds0RAQfvz7iAldvp03kLOoh4vo5AfRc9gGs+9 + uh/Hjg9gycKJqA/+VJQH9U0JrH5+F/r7CzOQzFUWGVDVlmLPxhvYcvdIcNxtwL5vcAHIoNeGebqyMlgd + RHeYWURmCVl/+T2fcOR1iBLENVsJUIlnJw51eAvN5888EGaBDUfhWRpxA5Gsv3lPgL8mvlsCoRylYCs8 + UJ6OYrvE/jU1gmwqh4Odvbj44uloqivmq1jMgLNU+L7qSCnX39XMzJny+wIUy2wPH+vHd+59Fn3OSr8o + KZ77BgpTe7IOAHfdE5TigjUsD1MjRfPA/JGHOLcsW2RimBYee2ILvv7dpzGUKmVyCGhrimPe7LFFG44w + oWVKwDMFyLdRYVnYc566avYwYIh6NxLhVyT6bhYi1EGcdhWDkYCwbFcILooBxiFK0EAohmghUAZ4p0FN + i/r2PU8Dd/rXEvZI4IJ/PI14qy9afn7xlZ/wi+s2VPzJ2iXSRuT7dVs68eOfPu+3PmA5gP8qielCoKoK + QNO0O+Cz1Pe+hzZg46bDHuLyi1NEYvIMIbqcvOAHubL8DAD/3zCt4i2ohPrI8Punt+HRP24qiTaJqIFF + 88YhxtXPravAuNI2Kqy2LiiCIWqfNxDqGQLwQpghJHBuWxQwka5F7rBFvUt3Fc/zaCD2M/zbgTKB8usP + vlyTU6Q8LVUzHGw2wLP/o8SgqBQwn1bFn6xdMoMitukPT24NWh9wa7VXCVZTAbTD3txDij88uRV/eGSd + e56lpMhq8wTnrYuMaLyG5a/JOoRQCkILHgEfE5DlUVQPsSzTwu/+9HrQuu4iTJnY6jIb7xKKEKeRZPcY + 2JiXMX3Ecasz3Jy8YVqe8T9bpy62XWy3bPWdTDj8FMUQJa4ij6Jg/YOgor2svqLVNoUxvuqtPXZk9BON + gacePuN7FX+K9dWF50QF0juUwY9+9oLf1OAEx8Ou2tRVtRRAO4B/gI/r/7PfvIbhoUzBLSJ241NE89Wo + 7D8/x+q3jJXdz3DnIpjgMw/Anaul/h1sasSdetq8pwsbtx0piUhjRzdhVGMcGdjWJwP/pbN5rp0ZyN+d + Z0E/XgmI52JwkKFoubBGPGX5KQgZrVyLx91jrj4rO0Etd3gC2EpDfJeD9TPffnYuo4OImNMGvv6M3oCt + wNm5SCeRf3ha8EfxOs+ffPt58B4OS8/nE4P95uB9v3jJdyhAKb2zJMbzQbUUwK0Dg2nlJof/+/vXsXWr + LSyiBYkS+bhJVAhMYcgIK8LUCAzFWF60gGJd/BQHUGAk07SwY8fxkoiUqIsiGtGh6xoysBmVZ8SisngG + llgVNuZNUC8TJ6hcKbANQXhaMPCxiRjUm6Py/SH2p6xPhyhBgloeRRAlFFHnXNZ3fD34/osp6CCC0Zb1 + F/88U+AsDeMHMRbAaG9oxZ4qu++ZLuTowf8XaSfSiM+H0fyRP23yHQo4C4SWoQqolgK4XTU19vL6g/i/ + Rza4jROtkHgtS73MxN9jWtMPeYnA561gl5OlMZz0fs8w5urpK20IMHFs80ktHoFpWtCdWERe1zz//doi + XuODnDkLrtDzwp6z4FESMjqLMDUCi2jKe/x/8Zzly1v8FNHs9zUI9SihKAlun5h/mL7khTbP0ZZ3+3WB + 3kwJyOrh91/kZ0YD1TBAlQ9TKhkAA5k8fvab1/yGmBMopcrhdimohgL4EhSBv+6BFO77v1cw0Jd0CZ6g + FvIW9az04xEl1MOc/Hk0YOyYpcRjNdlz7JqK6cXnLKK556yu7L9MUMOiqyfpvhnE4hL8Lyc4AYZE2Rmc + kAEFJcmsqhhljpJC/IPPn9GSpTMCFKuMZrJrrL/4/EUvz68vgvrK7z67xt+T0ZnRWnxn31SsHzC0Aq+y + /5TYNBP5NSytRO+OpTOcvli77Rh+9dB6ZZ6DQ5n3VSMgWKkCWAZAOR750+Nb8OzLez3EZdoXKLhnomDL + lICKqH7pwuQTlM7ghgzsP6EUMQDjJ/t9GLYYqVQWVtq7zdlItzNM+2UMqspDvC/LXyynkvxPRfkMTBAp + IdB1zRX0vEU9ysE0LY/yGAn+jRKKXz69Hes2d0KGpsY4CCGfRIUBwUoVwC1QvOa791Avfvq7dS7hdInV + VI0zeQuiIppoaVTwuy/mJ7sv81LyFkVdQwxL544tiVj9g2n0C2Y+qH5h2ulX/zDt5xlWJSyq+yOd/6ko + n7nj7GialivkTNB1bvaGpZXxRlB/8PeD+uf4oR786Bcv+605WQHgVlSAshUApXTlwGBaudz3gV+/ggOH + ehCDNyBjctNwuq6VpP1FDe9nJVTnQRZDvC+6hYxJliyahNkzOkqi2cHDvUgOplw3kh8HllO/sPQKyp9n + RNUzYesyEvmPdPl8wI8deYMlDo+Ym04oHTH+ZQHDVS/uxjPP74YC9QBuRwVeQCUewB2qwN+6zZ14ZPVO + V/BVwRfTtJREEMf9fuMsmSZVnYctj10TPZcYgNaGGP7ytmVoKHE58Lb93fa+AGzvfC7vUoRdJsyq+ofJ + X5Un/0yYoYjfNT9BOd3ly4K+7pBVCNYRSj3Wf6T4l8VOTNMKCghWNC1YlgKglK4cHMpI3/NPZfP40S9e + xkBf0p03ZwQVl+KKHoA4BuLh5yoFWTrVdb/y+Gu825dpiOOO91+Gyy+cVhLNBgbT2Lj+gKf9YeoXJDhh + 6l9K+/3iJLL7QfT2q1+Y/E9F+YYQBM1btDCN7PAvodTjIbChQbX5V6y/oRFs2n4Ujzy9Xfk8IeT2crcQ + K0sBEEKuUln/51/dh1de3eu5xk97mcJSzTABm1LuqxillACRCNO0Zy7GtNTh8x9cjtvfUfoU7O4D3di+ + 097zULYAKKje5dIjKP9KEWXLeSX1rpO8417xhxhGoHwxBsBfZ4IuegLMC6g2//L158t76OF1ONjZq0q+ + gBBSViygHAVwGxSv+g4MpvGbRzdigH3Kiy2ndASf/QeKA4Cq8Zyo4WXuoCxd0HUZxPxY/Sd1NOLm687D + t75yG97/jgvYtwBKwh8e34yBTB46Nwtimlao+gW1U5aulPbLngt7zDqr+rLcj6Eva3muZ6m9bFdMezrL + 5yP+qqPsvzg0HCn+ZTy480A3Hv3zFiV/EUJuLpkpAZTMyZTSW4ki+vncy3ux6vXDbpArZwFwrD9TAoxw + 7FyctxfdKLFTxYCO6hnV1IxGLUQ1+ZgZsJVWVAPGtTfg/CWTcdWlMzBvzjiMG9NYluAD9rLhJ1bvcNue + s4CIBs9iG9lYUayjbE2Eyo1XucCMNvm6GKxkVkmzsHGVLCXQ6qMwhjO+dFddV0XEq1m+SFfxGm+cTCE2 + I4MsjYwng2ZmQvUnKSiGh9fswpuunoNZ06XB5+UAPoQSvzZcEkc77/pfLbs3MJjGo09uBYbSoLrmMrlp + Fqc1OaWQteAhVlDgSkyncmnzdTEgmS3uECf6HuX6j+XVEtUwd/Z4vHnFXFx8+WzMGiffsLEUpLJ5/OLB + 13C8b9hVjBHNHlNGhLFkmKm+oPbz6fJ1MRjDtq+VbUggOpQqLEEdzgBEEqxqSACDaV+hFPsjOpzx7tuv + EADxukwAql2+7BkxX16Yee+MP88RggjbV8LQoVNnhqghDovjM1kZjBc97VQEbVVB2iih2LenCw8/vR2f + na6cfbrdsqxVpXxjsFSTdgcU8/7PvbwXz76817boDnPnLHtPPJ64TPiDNK2f9gyyFlFCkXU6RUzDAjz8 + mC6qAVdcMgM3vm0Jrlg8sawdf1R4+tmdeHr1drdMixTaECH+7eKtpFYfBZgwc+n85pQNLj0G0842YVT6 + DPMIokMpQHDwxGfE/pEJn8pTExX8qShfBKNllFDkTeoR+jC8GeEWARnDGWRR7BHzZfPKNuz6FbGPGR77 + 0+u4+Zq5Si9A07QVAKquANg84yWymwODaTzw5y0wTQuWsyyVeQCMsACkY6cgFy2Mmy/TqmL6fF0MGM4U + zekunT8ef/mOC3DFxdOrKvgAsGtvF779i5cxOGyzqF12oV7iUlS/dmSTWVeA/dxMv7lv32GBxCPws2o8 + /KbmZFYfgNsfI12+tO3JrKtkLKJBDBXKlAAT+iJe9lkR6DdDIFNoqn7l/x/qGgz0AlDCMCBsELAbwKcI + IdKphldeP4QNr+2DodnuLb9CKmfZRLaI5q5FZ9d4QrFGi2NDAL7vjwcxH7vPxrvsemtDDB/+wOX49y+/ + HTesnF914e/qSeLf/+cZ7NvTBUqKg15i54v3PMKJ4mGSzLvxG+fyEMvT6qOeeypLLcZkVNacL18sy53e + 4oR/JMsX2y3SJqLZ/JizvMFqBtO0XL7lh67sXAZV7EalnP36Vew/i2h4/IXdfjMCy1HCVuJhFEA77BVH + t8huDqWy+N0fNrkLXBiY9Y9o3h9/je+YfF3Mc84TZZi7xyKxLtM4gusRpoaEpwP4TshSgksWjMe3/+U2 + fPZDV2DCqIawtAqN7oEUvv7dp7Hqhd1FbWYxAHZk9WbtkXkBw3UxDzPwabINiUBLz9MAgEtrxnBMGBnE + vhDr0+D0l9SqO2B1Y1NlrL2y/Ea6fJ7mfFr2n+dHPkjNjuI9BnauGtfz9WF15umR1TTPc4wHVPEBhn17 + uvDHZ3x3DlqCkAijALoppR8FsEB2c8v2Y3hFeGEhRwhywkwBfy7ey1LiWugsJcjXxVziMQZhzMre5DKG + M3Ya2YcWJdcYAd95w0L8yz/eoNyBtVJ09STx1W8/id+t2u5hmJwzK5JTzKDwbWdWkQm9KCC8hxQdShUs + YkPC/t8YL1ICeU6JGM74l6UTLSpfHt8PbtmAp79EL8tl/MG0vVxWK8x+sHrwCnkky2e0Z3wj8whlvOrH + r+I1cTaDL4MZt6zTLkYPcSER6xfeI+L7VfRonnxpj9/qwNBfGQ41BCCE3K669/ATW9DXnyrSjhFhfMvO + +Wgqa2SUUJfho4TCSmY9HRwFPALBCG0JUf6ijnAIl6UELc0JfOr2y/APH12ByRNawzS7ZOza24VP/usf + 8bsnt8nbr5Oi66x+TChZm5gQ8MMgrT7qEYiiaTQW5XcYn3cpeYZ3y3bS8y63KKCqfuDpLl6zuABsVtMQ + oRQ5Qjzt49sxkuXnLCBqWa5gycbfrH5+/MruM+XAron9IdaH0d5Vdppm18c5inzAaOQZCnL9ybDt9UN4 + Zd0BFStOIIRcFYZnAxWA89KP1Prv2tuFJ9cehCbsNMOIw7/4lhPiAioBkAV6MoTASucQ0VA0XrS3BLcJ + KrrZkWQaeYuiJarhrz9wGT74/kuqPtYH7Km+J5/fhc984SG8+so+12VUMZXsHu8ueujvuIpZAFY657GO + UULtYYSmATpxYw1F016aHZiFXnCFPcG1hsLX0vn8eUsUJfZOzZZWvHbBEmZcPP1oUk9bWJ4eJVGF8mV8 + Ad15zmm/+Cp2lBQEmxd4vo+iluUqEULt9vDXWDtYeXD6iZXLl8XTI+J4AhENgE7c/6KiYnV307I+owSP + PrnV703BW8IsDw5UAH7Lfp96aS/6j/YWubouQXVSRGDxOq+N2bhMDJIwYucIKVq8AtjzsqJlBewoe1PM + wCc/cjXueseyshfy+OHwsX5884fP4v/96mPYeaDbZQLR0+Ehuo/8MEf0dFg+ruUQ6MXuRxwX13U5Kcf8 + jsVxFbMQf+DXB/C0d4cKPIThVTX6rxrlM/qxdhXRTUE/LW96+oPREgC0vBnYvlLLY/95L0LsP37Iy/cd + oxvD2q1HsVGxXwCABZqmLQni3yAFUA/Fhh9dPUmsfnZH0dZRPNPzDRPTsMbzwS9xNZeMkcXoOS9ofEea + poV8XQx33XkF3v8O6RfKKsLAYBr/+8gG3PXFR3Hfr17DgLM9mEfROWDtd6f9TOpxi3mBL2J60457uEzF + uc/GcMYVLEILrrTHmxKE36WVVbzSUhaBFyGmqbT/Ki1fpB+jqeteOxZXRT9d1zw04Y+WoQe2L6g81fMs + vaz/eLryQ4Wc4OH19afwh1Xql4Rgr9vxhZ9JbKeULiWESBf+vLLuAF7fccy2ePwYyqSuFXThfPea9wZy + ln3dcua3WaM12HPeANzVU1lKAJMiXx9z3b2sEMSJOO5Zzik7omt4z01Ly3pxxw9dPUm8su4AHvjzFqzd + 0gkMpRHRNeSIzrWruP05wF3W6Z47bYo6jMEzvthGtposC+KsfCuMPyHQMMtc4mTWdk1N6lX1JvUsLEJj + HOCCiaw8i8unSCgb48gOpovKLqf/Kilfq4966KfFI4W8OT2qop9nWMC+z+7wNBDMn562SMrzfZ4CWn1M + 2n/uNZMiyykpl54OXtt4CAc7e1VxraWwd+1aq+JnPw+gGz4a5JkX93gsu8zyRyj1aC9PYMUpmR+78cE/ + t4LOeAgojA/5MZ+WNwtBGifIpuVNrLh0Jv6f915UNbe/qyeJ/31kAz56z8O456t/xKuv7HPr6loOfrjj + WHktHnHPRVpFNG9wjrcW/BhZnBbjg0W8x6DVR13asOvMy7Lfy/Cm42cSxBgET+tYcwIiokOpqvRfpeXz + 5fF048v1o58IcegW1D4Z+EBk0POy/vPU3+FpMxEteBfc8OrwkT48+6Jy4d8ESukKv7r6KYBlqnf+d+3t + wurNR+zgn0k9kdGI5p3yYoEQ1zqa3mGBGO3mG89HRFlHsvvsOV3XPB6AaVqYMnMM7v7oCrQ3JVANPPfS + Hnz+a3/C//fNx7Fx42H0ZbmvzjjzxC7TMOvvxDmsZNZVeFGrQC92ZGN+nhZ8LIBdFwNt4uIanqENwaPg + aZwjBHoqW+SmszR8AIoxb6bfK+xafdSdYam0/yotn+XBH5kAMt7zo1/UsgoK2iwMBRhPBbWPv6/VRz2K + h2+X6nlZ/wGFmQNm3GQGIV8Xg2la+OPL+5TfEXDeElTuGKRUAJTSFarg37PrDqK3a8AOvnE5iIoAgCvw + hFJvgExRMus8fvzICMcYm92XoamlHp9878WYPqnyqb6BwTS+ce9z+MxX/oinXtzrrvxiHcgYkrf8TLkx + pmKRX14ZAoWFJ55oODeNxEfDeYUgLoCRLf7xLCThPA9Gs5xVmDkQp+V42opC41plTbPfLZCM1Uvtv2qU + bwxnPN4PbzmD6JfVtMKwjQ0f2SyOZKGf2D5xHp8vT7YaUUUffuzviXE5AVQefHt1XcOuHcewbaf8GxUD + g2nlp/oAHwWgmkccSmXx1Mt7PYEs5nbzwRTRI3A9AYG4orVjAsDP8fORcZaG3Rfnaa9bPhPXXDkbleLw + sX783XdX48cPvIi+/hQimm3teavmWndu2pMNRXLctBDgdfvFgBzreH4eW1wAw7vE4pw5/7xogURPImpZ + rnDwAsJbH9Fq8cwLFEftK+m/SstnYPnx9AlDP75PXA+A492g9on1FOsRhj58/8ksvVhfvhwA6OtP4emX + vJvwMDhG/FMqPpcqAGcVkfTFn517urBrxzEPoXKEwDLsVyq0eMQ95ix4xi7sGQDFgTLnWlbT7MAMNzfK + zovmTNkKM8elnjaxBR96zyUVj/v3HurF3/3743jqT6/b9UdhvXiWEtda8MLMGAmmPe7X4hE78CV4KuI8 + M2MOD+PqhXUPbH6ZtZl3g/mxNHN5rXTOte7QbXef/aeCF6JalchbNVER8ffD9B9rC29hxZV/lZQvroNw + +4ZyXhdXF56P+AAgr7DF6VKe/1xl5eTJL87ytEsn0j6QPQ/A029SunHnnnQOXnttHwZkq2JtXA3FMECq + ABzrL930/pXXD2OgLyld7MLP87pHjsi81WHnfFr+mmphhuw6Y4R337qsYte/8+QQvvbdp9wFPUVBOt1b + H9mSUT7Yw9qvWlpaav4ifT2dyQKOHC1V5bL/vELhx7DsuueV4sa4990L579f/4nXZeVVUn5Q+2R18Vv8 + 45cPP23N9x9rP98eVX6y+2IdRTmRXefrrlELm4/0Y9vuE9K8BwbTyymlS2X3VEOAJYqM8Oz6g8rPRhVl + 7jSWVxZ+TOgGyHygWl0347yJuOmauaHqpcJQKovv/vg5PPXKPteNF6O4oaALjKIX11kUiJLy5+jLewF6 + Khu4hl1kLD5wyGYVmJUSV9dhMO1diOP89+s/VXlMcKpRvl95fvfE2I0Hjicnwu0j5umpovzc83z+4n3m + DYj1Kuo7kyrfJbEMHZn+FJ5bK18a7AwDlsjuFUmys3xQqi0OdPZi145jnqW/HsKZXqZ2p8kCGJF1Nk9M + UUur/jOv4Jar56CjTfpx4tB49I+b8OvHNnuWa/LaXVaHojrpBS9A1V6+g0vJX0VfcTqyqF84iHSVvXjC + g527bndjvOCOcx6Aqv/EI8/s/DOVlO/XPlkdZIpAKljJbFF/yASen8aTKXQ+f6nCFxRnUZ+btMhzkKV/ + 6fVDymGAKqZXpACcHUXki382H0FffwpoiCNnOeN8ttBE6Fy3sUwTmt45cRXB+Ya7+XONlrltE8e34M3L + Z6IS7Nrbhft+u1bZDsbkrN0w7blZvv05Qtx7Yge6z7FrZeQvpa9w9KMvD1EBAZyV5epUZGUH0wUhFe5Z + yWxRf/Pt5QNtLP9qli+2z08Jyiy+2C88nVgfirQHvG8YypShLH/+vkdOUFDkvMIRPaKiOuoEB/Z344B6 + n4ClsncDZL78YtnTqWwer762z66MM661kllPJ7P/qjiAlcy6QTUPgzTGC5aQXROCNEUdwhH2iivmYOLY + ZlSCHz29E/sO90nL8muP2H6PEnMslKcTS6RXVejL01UCVj83YMn1B98O9+gIHm+JPXPYrD7pnKf+bt2E + 9BWXXwZEPuKHMR7XXjj30FznVviJngG7H+J5P3rxgUCZPPDoG0rj+XUHVbcnOMbd225JwiWyp48eH8Rm + JiBmsfvONw6NcU/Ul0dRep3YS1JZIx0rEgomRaw5gRsqtP6b93Th6Sc2qxOU0h7GpE67XEtWLXqVkx5Q + Mg9fPzc9b1kb44Vz4brrlsssMTcUKrJcg2m3/lUpXwZHgMaMb/WNC7hKlaOP6JmIgT4ZzSu5H0ivkMhY + FBteP6RcFASJcRcVwDLVwoFtB7pxvG/Y03F8Az2NG0wDTJvr6rGPtKG6v+sqYtGcsZg5paIPpOKZZ3bg + WE9SXXYp7WHKzKetFdOrEvoKkFlij8UVhTHoOk9D0xv48igw535VyhfhTAl/8a+vxj0fvQpao3pFaJHn + Ca9FF4/S2RcuvWwptO/zYegVEjGNYPPhPhw9PqhKsgTCdKA4Yb5Utfpv48aDyAylEdM4t0UQGM81YRcb + ZXoZQiqBTNTA+XPGVvSO/8BgGqs2HEQsm3cXLUnrUm579CrTqxr0VdDazYMpMUGZhbquyNsDlk7VvlLL + F3Dt9Ytw97uWYdb0Dhzs7EVLUwLHhxQKQ9I/Lt24uXcZfT1pFO0NfJ7taqXw6ErF8SO92HagWzUdPs2y + rBZN07rZBd4DaAcwRfbUwGAa63YcAyIFfZHRdWR0XXrud11MU04e7NiUiOCKZdIqh8buA93Yvr8bmaiB + HCEl16va7a80PzHvoOvJqNdL4M/5/5XWp1rt9WuXFo/gztuW4fv/8JYk2za7ra0ekxKGkg4lHZ2t5Mt+ + XnYcziDD5N6kldPfoti4UR0HIIRMA+cFuArAsqwW2CuGinC8axAH9nd7Co9xX/zI6LrnPOi6DGHyYP9Z + HcaPasDESW2h8ldh594u27Ph8g0q3+9/NdpfSX48jVR9FDNNN019KlOIuZgU9dniGEw16lMt+qnapcUj + +LsPXoFPf/hKwN7HAgDQkIiiecZYIJeX0qeko0Yqe15yBIB8PGYLfyKG+lSmSCmXSv91O4757RR0B+w3 + fQFwQwBHM0jH/+t3d6FvKA1+UWslDa7kWcbAGV3H9NGNaGuqbIuvTQd6bM0eMRDL5gGdBNadrwP/vxrt + r3Z+QflDJ0hGo6jPZm0G5I71qQwyUaNq9ak2/RiY8N+l2PuhTaMl0+lUHQHYSlcn3iNQFv0zEQMHjw/i + xMkkGiYVx4AIIYthewDdAOcBEEKmqoRk445jRe6PKIyiJhKvyyysKo3sXOb+TJ7UVtG6/1Q2j30Huwtl + CXmphEemjKrVfhHiPVUaWT5++RcxIOBan/pUYYyuap+sfn7tGwn6sfuffv+leO9N0tlrAEBDfUxJS5mC + CVJA1bwfM80i1x8ouP+l0j9mmugfTGHbgW4o0ApgKjvhYwBSCg6lsraQRIoFTTUW4TtHvC4+K0sT9Ax7 + bnqF7n8uk0c2kwtsm3hdVbdqtp+/Lv786iKmVeXPwBgtGY16PAD+XintPtX0e+dbFuCv33tx0s8QtLXW + u32soqVf3Uq9H9R2kf6M7jzN+X4olW6pnIVt24+qqjkBCgWwRJa6pyeJg0f7izpFdMeCtKp4j6+8mJdl + aErr4VY8HsGkcZUt/snkTAwMFSLXYVxZVRur1f5ERJNaDHYM61n4tYdHfTbrDgH4/+xYaftGgn4MF80b + i6/83fUnwY35ZegX1guEoSd/TMUinvvsnB1l9VTRRLzP052de3i0RPow7N593G89wNXsjwHY6/81TZsm + S3noSB+O9w17tHHQuK6c8S1/L5HJBY4tm+NRNLdV4as+mZxvG2R1LXfsHqb9KQAoMY9KymZMxysBUVgq + KWOk6DcmEcGn//JSQPHWKg+zb6iIf4LKTcUiLh+K/Ki6LuNTMX9ZPRjtAa8HwK6VQ5+9JwaRiBonFfTp + Y380ANA0rUVFvO0HepDJ5EO5Z0GV8+sEv3sy9ycR0VFX4Xv/mqEBMe8SWZmV5OvBWw3+XlD9VfnL8hTL + DCpHVkfVc8jlPfcYwxlpe/yf0e2pJCOdQcaiduwnly96zo/5pOUG0DaIN8R23vTWRbj8QqnNKkLSkpcn + ox07MuFW0VbWVhmfyvhYJvzJqP0+gGGaMCSG1a9vZR7ykZNDWLe5U6Ucr2Z/mAQtheIFoD17TwC5fNEU + iJ/GV1VORdAgxpURPRrRMX1Sq0rDhUKEEDQ1eANEfp0Yxlqp2u2Xv4op/VzpIjo501xsrNuUiKClKYG6 + qI5R7Q1ojehobkmgoT4GvaUBzWxf+6iBeF0U6eGC5e/tG0aGUgyn8+hOZjHQPYjuoQySg2n0D2eR7kuW + pABLoa2fAmGYO6kV77thUag+TmXz6DvaZ9PHoU0p/VhK/4ZJx1/L6PY0rDvW54Kuquf95MJDs6E0dh/p + x/kLpGI9Dc5uwUwBSFfTDKWy2N815KmIrEFih4rM4MfQso4OwxR1UXUwJiyaGuMYNb4N2HYstGXwC0wF + tV+Vv0pAZGUwKw7YSz9jDXGMH9WAUe0NmDa5HdPHNWPKuCaMaW9Aa0sdEnVRxCI6GhLlrS8HbCHKZfIY + SGbQ2zeMYwMZHD94EgePD2Dz/m6c7B7CkZNDyAylbY9BVwtwOfQT6fX2lfNDb/ySy+RxcCBdtIiNr4us + r8vhb9nzfgqFB/MCmPX3E27ZUKqITyyKY/tOAJgvI8sESmkrIcT2ACil04jk9dG+/pQdAOQ0p9ihKtez + VEKXYv0ZOk8Ojar0674zRxXiR7LOEtsmq5uy/Y4wBDGDJ89svmg6kqdJc2Mccya2YM6ssVg4pQ2zp3dg + 0vgWNDTERuTLRwCQiBpIRA00NcYxcWwzFgLARVMB2MphaCiDYycGsO1gLzbuOIYdu47h4PFB9HYNKOkl + U+5BwyAAmDymCW+6Ivyejyf7UjjeNeh6ADI+UykasQ5h+lf1vMqo5KN6IQaTyrjrUPxkQaZAimgLYGuv + z/sSdtD/SQNAOyFE6gGcODmEvoGU55qsYuI91fWg8ZHqmqwD+pJZ0Hy4VXa+VJg3FomIhlTO8nXNw7S3 + KA039eSX3tNmcS1CzMC00Y1YMm0UFi+bivdev2APIWQsAiLfpwqJqIFEm4GOtnosnDsO73rTfNtzPNKP + rXu6sHHHMby6/gAOHOsHz0lB9FTFFt566fSStn3be/AkersGivrCzyhZhoZMLg8rpkHLW25QMCM8J+Yp + y8uvvYDX8rO+94uRqfIruqcDnYd7MDCYlr4rQwhpBgDDeTlAWrmjfSnk8qa0EL9gjcqNCuvWqCDey8r2 + bS4RKy+fdXLK2OZR2w/1+tZZdU9Fl7DpZedM6C9cOgUrzp+ExfPG8xZ+RsWNHmE0JKJYMKMDC2Z04F1v + mo/ugRS27ziGZ17Zh2c2H8H+AyeRGs5K11/IaML+NyUiuPay0l793iAM78Q8+Yg/u66lsrASUTcQmNF1 + aHmrqF5+dZb1fSoWcRUKu8dPt4r5+OUXBse7BtE3kFK9LLcEAAxnBkA+BXiwGylByEoJUvi5e+w6O/cb + E8ruDaeySCZ9XZywGHX1silgCqCc9pSTXoaxbfVYuWwyLr9sFi6aP25E3fpTifamBC6/cBouv3AaPjKQ + wvpNh7Fq3SE88/JeHDw+UJRe1edzp7Zj3szRoct1X2LzyZ8Jt1ielsoi5SiBlDNTxM8MsHxYHmLesr6X + KRFx2lVFA5lR8TM2lqEhlTNxsndY9dmwFgDtBuxVQS2yFIe6k0XXgtz8Uu7xQQ8VAVTP5vIm+vqGUQ3c + eO08PPTsLntPgDLbU077kcsjURfFwpmjcf2Vc3DXO5Z1QjEbc66gvSmBlZfPwsrLZ+Hg25fihbUH8Mhz + u7B2S6drbFT0KvXV790HurFpT1fR9UBLGjFgGZor8CrrX86wUPSCmQzkdd3jCfjFmvi8VXKi5S2k+5I4 + 2ucdwnNosSyrxXACgNLxpDh9woNVWFw5xhokznHy0U1+sUMYhcI/w/K2TBMHe6qjAGZO78AtV87C9x/a + UHSPla2qv7iIQ0ynUnDNjXFcftF0vOOKGVh5+awk7DH9OS38IiZPaMXkCa1464q52Lb7BO7781asfWEX + juZMV+gYYqaJxYsnl5T/0y/tRb9k45AMIYhlnSXgCv6WeQUyhOEPXh5kaTK6DoOTFzdAKCgF8RyQKyFe + KRw71q+qequmaS2GKgA4MJgumj7hKyEKuHiMOQsaRAFh11UCwgJyfHn8M7zW3K/eALEkJKIGPnDbMqxe + ewDbD/XCMjSXAcPUnx356yydB7k8mtsacP3SSfiLW8/HvNljmIt/RgT0TheaGuO4eOlkLDpvPHbfshj/ + +8Q2PLFmFw70DiPmbOfV2tGEeSXs/NR5cghPrD1gL2CKRtAU1dGiEcSaEqhvjKMxoiEaiyCbyWEwZyE5 + mEbfgB3zSoWILfG86McfojyI/MwrglLPVd6F6y0QgiMnh6T1HxhMT2hqjE812HygiEzOxAmrEBxkgs8a + Kq5hZpUSrb64zpnXgqwRvNCnct4giSdKqhdWzQ0YBrbstNc7V2OcPHFsM/7uruX41Fcfw0CqsJOOqi2s + /uw/X0dPnQlBjFI0N8Zx4yXT8I63LuIFvwYOiaiBhXPHYeHccfiL6+bhf5/Yhsef2IKD6TzGdDRiVEv4 + j72ufmUfkoNpvPWS6ViyaBJmTmnD2LEtGNNaZ5eVsMf1DYloEkAKQGbznq4JB472Y+PGg9i83x4+9Cu2 + HhP5U/wf4/hFxkPMOPCGjT9nZajuhxl+xLI5dCqGAJGYAQCtSg9gMJkF7e53G5PXdWlDZed8o/mhgux5 + wyzWuHxDZN4Fq9PBo/3o7klWvCMww+UXTsPH/+Ii/PsvXkYmk5e2RdZel+CchmZoiuq4dvlsfOBti7B0 + 9uia4IcEUwS3rZiD//n9JrRplDFtKMyb3Iaf/uttGDemMYjm9c7Pnbm4YflM+y3YA914ZfMR/OnZHdi4 + 96TLEzx4/lDJh0oe8oJrz57JC4Isu68aWnoQMTDQPSg1komoAUrpfgOKAGBf/zBSOVvweevPGgSgyI1h + jefT8ASQPR8EvuGicB3vG8a2g71VUwCJqIHb37EM3ckMvvfbdUXjUIYM1wF8Z2SEjrlo3ljcedMSXHPl + 7Jrgl4nzF0zAN2ePQc9AuiQaKpbAhkZDIuoqoVuvX4i1W47goYfW4fHXDyNlWi5v8ENAfljA7jH5EBWF + yojwAUGgmOd5vmPn/JCVD15mCMFgKodcRu4lE0KuMmBvEFCE7uEc0tl8kXbjK8FXUFZh/prYEL8AIA9Z + UJFdz2RNbHz9EK5zVqVVA4mogU/8xUUAgPsf3oB8vrA9Fv92Fu8NsHNGl7Ft9fjgzUtw21sWVPy1ohrs + Pql0xWclaKuP4rqLpuLieWPx1o2H8e0fP+dOG/PgY0F+UAUHxbz4tAyMz1gZovBrectdbwDY73UMZvJo + apRWZYkBReQ5OzBsazqnwDx35CsDwB37imn4cUteyEcUGsuw4w1iYxj4SCnL0yQEz2w4hL9SrHYqF02N + cXzm9sswtrUe3/zpC+iyCktI+TbzHWVaFqDruPX8SfjgB6/AspkdVatPDWcGmhrjmOwsHef5VcbfAFzv + GSjICOCdLRL5mqXl5cRQKAlWPpMVJi/sGNEJsjkTmZRyd+gWpU91NGO5jVBpNVEh8NfZs+xc9TwjJAN/ + bhkajHxxXgwxSrHvYDc2H+jBZQvGV7WzE1EDd71jGSZPbsc37luDDXu6oGuap/wMcd7eIgSzRjfijvdc + gnddObOqyqiGMwdPPr8LX7x3DXZ29iHibOEdRj5kw0V2zqeV5Sfjez4dE37ZEQBSORPD6o1B1Aog359E + zqTQNeKpiKzy/DmLeouegsp70MB9Ly1vFaW1BC9CJEhfzsRTa3ZVXQEwXHfRVMyb3Irv/XotfvXnzUg5 + X0a2KEGEUOSphluXTMDH7rgcC+eOG5E61HB60T2Qwq9//zq++5u1ODGUQUQnjmxoRXzNn6uEWGY0RUXB + 0sv4nn/eosSWEWpv7sFkiIlVOpv3zGqJUCqA7mRhqyzL0ADquLkA4COUmqEhYwK6osHMVWbpeVfKMjSY + pgWTEOXzYpmmaeH3rx/Fncf6qxYMFDFxbDM+95Ercc3lM/GjX76MV7cdxUDWRH1Ux4fecwk+etOimtU/ + B5HK5rF+5wl85yfPY/WmIzAtC7qmwaKArpEiYQ/yhmV8LHtO5PEw+VuGZv+c7c9cj8Ew/LYGa1UqgEFS + PH6HrsO0LJiWhYhOkHEEVYTtHlFYhoacSW1LKSiBiE48wp8hBBHh+QwhRVqWKQld09wOObT3OJ5ZdxDv + e+vCEWOGRNTAtedPxoWzRuO5jYfx6JrduHH5zIq/S1jDmYdUNo/de7vwwJq9+O2TW9HfM4SITqDpBJbw + mUGNUJd/2XQ5uyYKpOgJ8MYQQFEcgc8rKH/ek+bLyuepZ7MXpgwSUQMDg+kJSgWgO1tDi1onwn2+KKIT + aHmvhuMrAsDVmKximqMUeGQIcfMV87coirQs076ms4ApD+B3j23Cmy6ZPuJR96bGOG6oCf45iYHBNF7d + dQJPP78bj6za7rr7PE8y4XMtNLWHqToAi9CC663rMGjBy7UMDRooLEpcIaaCtRatPlBw8VX5a8IXkjVC + kY8YMHJ55CMGijSWA6YIlAqApgpDADfYgOLMROG0KCkKaHhcHQpEuDbmTOohsHiN14R8HSxDQwR2+wwA + L+zswqrXDuBdb5LugFLDGxBBq0QHBtM42Wfvob9h2xE8v+skdm215/kBZuBsYWdeKwCXD3k+dQNwjkDG + HZlJ6zqiDs9qeQsa4FwrpHE9YUdBGKaJfMSARguzYKr8+YCfm063lYyRyyMWM5AczkqHAZGYoVYAPVZB + KJngyqL2AKQBPo1Qj8Jwg36CxopIPojIX2PxBxEy1+pnj2zAigum1ObeawAA7DnUi4ef3gYAMOrsGE1+ + OO3uddh5uAfHuwZxuD9dGJZSAoC4fMp4K0YpMqbMQ3WUgiAjTPB5AUvrOqKEugpBKUuc8AflzzyBPGyl + 4DHIEcOzjkUGqQJQBQ346GLRdQGeikuuM7DAIiNmXlEp9hwb98vKXru7Cw8+thl//d6Lw/JIDecwFszo + wNY9Xfjcj59Hf8+QMp2uaR5hBor5NM/ccH95QpoJKpeHa6xk+cLL75auAxaFBRIqf/asARQZYVbZnM/O + WdKtgE71slWe+EEl64rdixh+/sdN2Cx5B7yGNybe9ab5+ObHV2CK8xKQrmmgmgad+wHFglkuDATzsJh+ + RPM3TaR82iaVJuYB0ABhs3Mg3qP4X5XGgW7osIgGaAS5iGGnUfyk94X8d50YxHd+vRYDg1XZLaiGcwA3 + LJ+Jf/376zF7QgtMyyoWIAkfFR1V/8Ok54+ydBLeNtIZ+5oKIfNnXgHb2FX8+Up4PJ1BICxqF8iO/H9W + GT6NAGO4IKiJwaTnPMx9MX9d0/DIszvxq2d3B9e9hjcMrj1/Mr5695sxdea4wnoWBpGHZUeHdzVqARZF + jo3TA9L7yYfI2zzydXFE/N4pCJE/S5Mg6nFL8BCA12bSHIi3MqKw+wg/AKQaCwG7fF3cPWfECbovyz+n + 6/ifnz6PFzYfKZdfajgHcdmC8fjPD1+GWaMbURTlkvEtf13zjucjubz9PyC9NG+2utYJTMKiyMcLHwIt + MnI8/LwOUfE4iBjql+6UHgBpa0I6HrO1na4XuytipQS33OPSOOCvsTwipmnnzyrrnDNBD7ovU06RXB4H + eofx5Z++hL2St7ZqeOPi4qWT8YW/WYmpzfEiHnX53IF7n90DvO66c17kxsvSs7Qsb12HMZz2ypZznSkG + nu9ZHuxaThJ4L5I/oUwZlAqgta+wl1gkl3e1S07XEcnliyok/i9yXzRSEGaL2nmK+XPgXSKZK8TuSwkN + wIpFsXbDAXztgZdxtL8WD6ihgOsumoovfOJatNZHXX5k034atQozUxzfx/K5IqOlEeq1tKbppvfwt4R/ + I6aJVGO9e4/xMZ82YpqFMnNen4WXQQAe+fTAojDqYlDgpFIBWG1NdgyAE6xcxHArwirAN8AVWp+5EvY8 + X/lcxPCcM+K493W9SLm4HgIjjNNJgL3WIJLLQ9c0/Hb1DvzXD1ahe0C5O2oNb0DcsHwmvvCBS2wlEDGQ + MSKI5XOwKPHMNOUiBjRCkTEiRUJtUUc2+OEnJysq8MIuE3ye3/kyefnj//Ng+bj3NIIYlPKYUXsAiYg9 + LmHaTHCNWAV4wczXxYvjAew/13BZ5SO5PPKCBuMJkRhMFimCnLNCS6OWh+AZI+J2HI0YuP/pnfj6r9bV + ZgZq8ODtK+fhrhsXe4XP4RvmBWiZLCxKEMvnoBGbPzVqubzH+HhYNzyW3xVUNh9vUdfl5wWf8TW7x8b/ + LI2oSIrOufl+91zAqHr1dyGV04DNhLqCzms5Jry8C2IMp5EDQU7XMRyJuNeHI5FChSxqp4kYIM6zuYjh + eg65iAHK5ceIw468R8Dft2JRZAz7NSJ2BACSyyNLC+OhHz28AV+9/wV09SRRQw2AHez+2NuX4I6rZwGA + h4+sWBR52ENJ5iGwd1jcBT4xW7ByEQN1uZz7n/docyjw4EBjA3IgngA242vxyORCtPiu580Pw8Uyuf8N + TQmYam+kVzkLYDQXXGy+UN5yE+c81VjvEqAul0Mkl8dwJOL+54kUyeVBHSXA5yVOgzBisPz5slnElBEr + ls+5+TEFQyOFdc5axn4b6od/2ITP/89zOKzeK72GNxgaElF87INX4Lq5o6FlsgUX2jRhOF5vLO/wrbAu + hkhc8ByIR2bqTPuYGEwiAoo6M498POY+mwNBDsTlf96DyMdj7mwFL/CE43P2Y9cjpuleY882JSJQoE9T + ucXjmuNuoTJNk3MEzI0DaMSTvi6X89VMlNNKqcZ6j4X3jP+d/MV8gILSyBgRT34GvAEU3bDdLhox8Miz + O/FX//FUbbVgDS4mjGrA3R+5GlNnjity0YHCkNKAVxANoIjvI6DSITIL+DG3nnJyUmfmPQFBoCArNOKN + j+U4w2YAMDQC6siIodleOHWeYzJR57OyV2tqjHfKbsTrooBGXO0iWn5WGaAw/hmOFDSNJ6gn5CE+D8Cj + AV23CYWpEZm25RUF4ToGDiEAeaDltdcP4a5/f6rmCdTgYtnMDtx9yyIY9XHkLerlG45fPYFvZwjL+J73 + Uoui9ADyQnCc8PEDwM2Lz4eXFSIMvfPwTgvyfM68gNa2RjQqYgCU0gMagH2ymy1NCTQ0JVwtwk9HUN4V + AbHdf40gguIgCHuWDQv45/k0/Lw+y4cfQrBhA+AdLhDuPh94iZimpxMZgYZ1WzMundyClubwH5qo4dzH + jVfPxu0r57quP0OO4z3GU7xhrMvlkAPxxL9kxo1yyoPk8gUPmpcbzoNgz/A8zg8DqFAvt76OFwAA7Q1R + xCLyhUCEkF71LIDkIwzMyvJC6br6DlFyEcO13HzFePeIJ6wI1wUThg88AXnL71FGfN6cRuS9hwgozp/Y + jM/dcSkaEuroaA1nJoZSWeza24UXNh/Bi9uPVzWom4gauPvtS7BkwUSPtWbDR6DAnx7D6BitOlP+Fq04 + pc2eF70JAFIDyhs3BoO7x/IFiuMSdfGI8oMqlNIDBqX0ACFkuXizuTmO1rZG9PUddwsSvQFR6FzL7gh6 + wSI7Vt3RnkVHIbIpTmV4NKDCtZetLGT/eSXR0lKHv3nfJSO2f2ANI4NUNo81Gw7jvlW78Nr6/e711rZG + vHPFbNx+7Zyq7APR0VaPz33gEtzx5W70Ju3gcd6igM5NzYlz9859fmqPF3oRLD9AWDwnGjHYcgN4jaUo + dx55EozqqLqI8u1eQkifRgiRrpWNRXS0N9gWkkYUGsTvbSXAExjhG1t05IOEnPfA/vPKx73HuWGq1Yiy + OdG3r5xf287rLMQDT2zHx/7jCTy5ait6k1n3t2/vcXz1py/ikz98AZ2KD2GWissWjMddNy52z0Ury8CG + lHzsC4Cv8PP5MagWx/FDA7/nh3XDnYbnkY1EMKm9TlqHgcE0KKX7NUrpAVmChkQUk9vqkHUaRyRBQPG/ + Cnxgj/8vA5tOFP/LysxGIsiBeKZCVCC5PGbMn4RP3LIYNZxdeGrdQXztZy+ir2+4iPnZ+ZOrtuK/f/mK + 3w64JeGD15+HC+eNC8ff6pV2AORT3DxEBcIjF2BkASCay0nrEAFF++gm5XOU0n0aIWQfAGkNW0Y1uhlT + iasv/vdrBO/K+BFMFSOgiqFGBFTqIYjQWxrwubcvOq2fmKqhdKSyefz68a1S4edBIwZ+/fwe7N5bnend + jrZ63P0XF6Clpc43XZDwA8EeQZg8/OBHl0ntcn5vaoyvAeyVgPsB9MkSTe04d/bWu3nJBFxTxW8I1nBq + cLh7GM/v7XE9UT/0JrN4fsfxqpV97fmT8faVZ+cmszkQtNZHMc7nk+qapvVplmX1AZDGAVTaw+LeLzaj + 5UXSy32OPcs/b/m87wwAze2N+Pg7l9W+0HsWYiCZQWYg6bGSWV3dj/u7qrvU+64bFmL6pPaq5snzrx/v + WoZetpxEcznEmuoxWu3xrgYATdO0Pig8gLFjm9EqWUTAvgVgGTp07rPfYiNFGPWFr+eonpM9K57r2azn + eS1vepjCMnQPYT983VwsmFH7WOfZCNl0dNTMK5XAqCqv7Zg1rgl3vnluYDoZv4uGigfjXy1vFvEr+6/l + TamchFUKk1riaKpXvgrcAqBbA9CtCgRObqtDa1ujJ2jHCJ/VDVcR8J3B/vMVZxXOJ9Oe52WNyeoG9GzW + UybLy+8Znim0vOnWbfqkdrz/zWenG1cDMKolgWkzxxYFjqPCnHtWN2DUx7F4SlvV63DbFbNw4bxxyOqG + UvEwHuV5kxkq/pkcCEzTuyWZJuzam3deNpLJFZMPFdx0kQhapo3z+2TdRsB5G9AJBBahoSGGSaO8cQBG + +Khk0QMTRPafVwYi4Vg6Rgzxvhs0BHHvsWfE/Pg6ifnc+ea5tcDfWYymxjg+cNlU6Nwe+jxvsSMxTVw+ + ezQuXVj9j8R2tNXjjpVzYRDq4W+xLoDX8GUT3gAiz8fiEMDMF5QCz8+isRPLF/PmcZ6h/ChoklK6Hyi8 + DrxBlioRNTBzcptbUcvQpVZYVApMEfANkCkOXmHoulZ034xGXUUgUyBmNFrECPzzM2eNw21XzCqxu2s4 + 0/D2lfPw4Rvs7z7mQDx9HDXtaeU5k9rwhfdeMGKrO6+9ZBpWLJygNGSARAgdZcAMU9TMu/zMFAWz9tSZ + wy/ykB0DKZMbpnx4OWJHLRrBvHkTVM3po5TuAwoKYL/qrUA2E6DlTeQpcQtmVphXCLwQitafVxiiUuDz + Y+e8q8OUCX+P5c0TVyTeXdfOrn0l6BxAImrgb991Pj77Fxdi0rgWALbFB+y40luXz8J/f+baEf08e3tT + Au9903wYhBYJoMiDMjmQWXN2XTyX5QnIjaAoG+zY1hjDlLHKNQD7nNifvaTYsqy+psb4ZgALxJSzJrUh + UR/DcDrvVsbgthkWtTHgCDjn2kfNPGByVpob08ue5/9ndQO6rrkKwiUkN2ySEWvmrHG4+dJpI8YQNZxa + tDcl8PfvuwjvvHIWXtt2FAf702ipi2L+lDYsmjHqlLzXccX8sbh41mg8v9NeayB6vCI/szTidTMadY0b + GwIYjmdgRqMwLJu5dV0DzGL+5pUQXz7vBbTXRTG+o1HaDmf5f7ddLgBN0/bAXg9QpADmjG/GqKYEjiV7 + YRk6ovm8OxyI5gsV8wioaRWNY5i15gnA7kWzWTtialrQdc1zzpQHSwfYbpHu5MPSRM28WycAuO3SqTXr + fw5i+qRWTJ/UelrKZrGAV7cdBWALL+8V87zOwPMtC25HnKMWjXhkBQCsbGFVn5XNweSE2zJ0GKDQ8iaY + umM8z5ebA8GMKe1oSSinSzewP5rsIo+W5gTmjLU1SZ6SoukK1mgzGi0INDc+5yvG0vHnuiPsAFxFwp+L + zwC2ZnTdIc6topodo5g+qR1vv6Rm/WuoPlZcMAUzZ41zZ8EMQm3BdI4M4hQgO4+Aeq4zbzqrG7AM3b1v + Gbod+OTSankTVHNiBYk6ZBN17jmTG8vQQXUdiyc2+70E5Ab9AxVAQyKKmZPbPNMweUrcqQtXiE3LI9B6 + Nuu67nx8gJ0XpeViBeycEYq/J+YdTQ27BGFKYsX5k06blajh3EZHWz1uu3Sq8j7P0+xc5H1imdANzTMM + YIqA3Wfg+ZvxuBmNIpoaRjQ17BF89pxBKM6fNVpaPyfW9xg75xWAMhB40dyx0KIRRM28R+vxjWL/GUTr + XnTfURjsCMAz1lcpAtXCCEaoMXEN77pE3UE11FApbl42CZNHN0qn3pggsiPziK1sYUqOrVMxo1FQTXct + O9XshXVU0z3TgtlEnSvwTAmwKUZ2no/E3HzHdzRhxjj56+7OOwDu4gBeAaxlLwiImDOlDW2NMY8lZxDH + 87xHwCBdJOEIOzvy+fFDAd7iA/AoB9dV4ryMC5ZOxbzZY043j9RwDmPixFZcet54dyYiCGY0ao/3Hf7n + LTZv4JjC0LNZd92DZegwcplC3C01LD2yNFndwJyxjRilfgdgA4BudsIUAFvsvFr2xJRR9VgyuRWmaXlm + AACvS++5rmteN1/XilZAyaYGVfmxNJ6ZBvFZXcMtSyfU1vzXMKJIRA2889KpSNTH3Hn8IIjeK7PwvPCz + Ix9L4L0DqnnfDWDn7B4bls+c3Ba4AtDNn/2xLGsGuLEBDxYHkK3+k7nnYqCP3fdLz66Vmh8jmmlamDWm + ERcsnVzFrq6hBjnOnzsGSye3BnoBYgCcDQW0aMRznwXzRKiGvyo5qYsbuHaRfAGQM8Rfz19jCqBb07Q9 + lNIEgJOyh6+YOwZGfdyjbfKRmOvuMxdFz2ZhcquYiGUWghrc8IClZ/f5cRP7z2vCrG64+fHnPBbPGYvp + HbVlvzWMPNqbErhq8UR3BV+eEuQpceWDXeMtPAv+8TLBW3Te2vMRfwZmCMV3B9yhhWlhVFMC8ybLA+DO + EH8/f42PAbQTQp4EsF328Lw5YzGqKeEKnRmNQjfzdoDC8QzykVjJ1wF4XBwe7D5gRzYNQkE1W0kYhELX + Nfe5uriBm5dNPH0cUcMbDlcsnojGJnuszQ+N+Wg8g4zH+f/u0JeTL97A8fEDwFkLI3nHZuGMDrSr179s + ADf+B7wKoJtLVITpHQ1YKLxSy09XUE2H7gg2sUxEU8Pu+IS/LqZnAi0SJR+JwchlPPdkhGPEmDq+FUvm + jq2wS2uoITzmThuF8ya3upafBaqppktjAzI+B6CcLWP5iXBjas6RHxpcObdDFQNLQhLjk5WwGootwq5Z + MA66rrnRSyakYiAD8L4J5ZeeWF5Xh50buUwRoXhlwa6z84VT2mpv/dVwStFWH8UF8wrvHzB+ZitaZXwt + 8rs4rc0E2w/iM8xb6GhJ4PI5yhmwPsuyNogXixSAk6hPlsMlc8egrTHmjm2YBWdg/3mrz85V6UVrzueh + yltMr+sa3rJsUtkdWUMN5eKaeaNRF3c+4sHm8iWWW8W/fpuGqKBKP2NiK6ZNUe5etN5Z8u9BUU2dROtl + OUwd34yL5o3cG1flwDQtTGivx5IR2AiihhqCcO35k09OHd9aFJA+1dB1DdctnqB8KYpS+ozsuurLQA/L + LjYkojh/ertybHK6sHBGB0aPqr34U8OpRyqbH7XwNBsf07RQVx/DZfOUMbBOSunvZDdUkrwegPSjoW85 + f5K9KjBga6JTicUTm2uf+arhtCARNXD+vLGn3SieN7kVC9SKyH3/X4Sq1muhGAbMmNRqDwOEyCWAwvy/ + XtpKPNlz/H/ZTABDXdzAeSO4EUQNNQRh8eRW1NXHShoGVENGXESjuG7xBOXqP0rpwxCm/xiUtaCUPkMI + eZt4PRE1cM2CcfjD2sP8nhzQzbwb+NMlKwZlDRLT62YeWn0cVjLtySMVTyAuRj6d50c1JTB/8pn95t/A + YBqDmTwyqRx6M4V2xQgQq4uhoS6Kcc3xZCqbr68tY5ajJ5mFmcmhL2NiIJlxr8cIoNXFMH9c08meZHZU + IqKd8qXgs8c3YdKoBmwdSBXdY3zK+JqB5+90NOryd1B6/jmWtqMxghVL5UHwgcE0mhrjq1R1V1KKELIK + 9jCgaF3hNYsmYHLL6zjYlykSdl6wZecyAvDgG82Ik0in3Ogpy489P2dsI8Y1K9c9n3Kksnkc7h7Gzj0n + sO3oAHYeGcCBrkEcOTGIlGkBpgUtnYFVX3hZo6O5Di0dTfWT6gzMHt+ExVPaMH/6KLQ1xd+Q7zWksnl0 + 9ySxoXMA2/d2SWkIXSscAbTHjFFtk0aBp+GMaaMwrnnkaVgXj2Dx6Dps3Vt8j/Ep42uZPMSzWVcJiOkZ + ZM/pZh6mbuCi2WOURrCpMf4d2B69FH6UWUspXU0IeZ94Y/qkViy/YCp+8eQO1yXRzTxiEQ3Dll3ZOs3C + sKW5leQrrCIS03p8+ng2i2gsgkzOconE5zFzctsZISR7D/Xi8W3H8ez6Q9i0pwsnB1IYtlQjLAMYzLlt + 7OlLwdzbZc8BO7RrGdWEK2Z1YOW80bhg6eQ3xBLnXUcHsH7TYTy0vhPrD/Wh7+SATcNs1t4Yw3kr1O5/ + x//MpoBoFF3dSeBkwQLrZh5jxrVg6aQWXLNgHK5ZNGHE9ohIRA3MnDEaWHcUJiDleVF4GS+Llh6A9Fnm + FeTS+aL8r1kwzk8G+vzq7is5hJDVAN4nu3fDskl46OltAOAyOhN4ABhGYcyisvZ1muURbEYI0T2KUe/z + OV1zXaapk6v71ZZSkMrm8cLmI/jNa4ex5rX9ONiX4e5qqNPsMWEmZ7l04DuOwdQN6Ch09jAMDJ8Ywv+d + GMJvnt2FWWNex4rzJ+HGq+bg/CktZ4TCqyYN1+88gUde2oeHNxzB8aN9No0coZ8/sRnTxjTi8S3HYAlu + sKkb7o45uq4VCd+RE0M4crgHj72yH2PGteDmJeNx8/KZuHTumKoPt6aPa3aNHoPI91p9HHAMnGvIHJ6P + OPEDfjjA8mB8YSXTiNTHYSULHvCsMY1+n7zrBPCQX719KWBZ1ipN06SbhV46axQWzRyNV7cdgw5v8IN5 + AnxH8R4Cu55xlDhrcCyiIReNYjhnudfi2SyYWPHXAKCuPoZZo/w/3jgSYIL/oyd24NktRzGY9gYp6zQL + N146A231Edy39gjM7iEPM/B0sZVgvigmwiuM7Uf6sf1IP+5bewQ3z+3AnW+ehyXT289qRcAE//6nduKP + aw8WaOi0e9b4Zrz9uvm48ZKp+PJPX7Ytn/OsOAwEbN5hdPTQ2RkiHDncg++dGMLPn92Dty6bXF9tGs6Z + 0ob6eASZwUxRwM5VSo7ws/M6zXJlgLWlLqLByha8YaYQRCPJsOL8SUrv0PHg9/vV27f1zqKg1ZAogPam + BK5ZNgUv7Tzp0XymbmDYKnQUg+q6bubdxg1bGpDOI8KlicQNWMl00fDAyGXQGjcwbuKp9QD2HurF1/+0 + DY+u2V0k+AAwb/YYfOmm+bjuoqknr//XJ0elu4c8bRaHQcOW5jKpKjLMppjS3UP4yQtJPP36Ybz7mrn4 + l/ddcBLAqFNKgGrQsGsI//PwRvxmzR509aU8+941xnXcuHwOPnHjAswf14RfPb4Vj2855tKHCYo4HBy2 + 4NJRpKVu5t0yBtMm/m/VDpeGd71pblWGV2Ob4+hoa0DPYEaZRlQMw5aGXNSwhZ7xtiPgwzkLcRQ8A9FD + MHUDHXU6bvLZ+5JS+gW2+68KgeqPUvrw4FDm47IphndeMAn3P7UDR04MhSKSLAbAa7iIaRVZv1w6j1w0 + irigPfOUoHHKGExuDP5qbDWQyubx4KuH8N0H12Pr4f6i9jTGdbz/yhn4xC2LMWFUA77/8IZRL7+2DxAE + 3y8eooqR8M/UA+jpy+F7v12PVfv7R33p+lm49vyzYw+EVDaPP71yAF//7UaXhrzwz5/YjH9634W4dqE9 + pu08OYRvPrbdM+41dQORuAHdsY7NNI9hSytyv31pHo2iazCH7zy8CU+vPYi/fftiXH/RlIq8gbp4BC0d + TTBZu7g68K6/rI95q87u8VafPc9khOUzd9EMLJ09WlWlToRA4OoFQsiTTY3x38vuTZ/UipuX2J9iShP5 + ziiReKGxWn2xEmENipgWInHDdY14ItVFNM95Tteg6xqmGtYpWYBxtD+NL/70Zdz989c8ws8wfnQD/vOv + LscXPnAxJoxqwN6uIfzkmb3KdQ38eU5htVTn/G/7ur147w9fxjd+vQ6q/RzPFHQPpPCfv16Hjz6wriD8 + HN59+TQ88OkVeNuySa4g/nLVTjetp//TeZdnco4CkQVcRfrx/JfT7XjV1sP9+Nh3VuM/f70OPcnyF7Yl + ogamttvDUV4WmBFTzeNHTAuxiFYkG1p93JUNvr18vn9x8SQ/pXWfbO2/iLDS87Dqxs3LZ6KjMYI4td99 + 5gUesDuLYThXaECdZrlp2ZGlZZ0pXge8LlBza/2Ij4P3HurF3d9/Dt97fCeYO89g6gYumT0KD/z1ZXj7 + 8hluXR5/YbeUyWVwXTyBbnWahZyuIafb1o2d62YekbjhKsvciT586dcb8fe/XIfOk+E8sVONvV1D+MT3 + 1uArD28pomGdZuHjNy/Ev33oMk+UvvPkEB58cX9g3jxvyOjIX+PTMuECbH77ysNb8A/3voC9XeXTcGq9 + Y70pDUzLAsSsfLEd4rmIS2aPwvUL1Ut/ERD8YwilACzLWgVgs+zekuntuGZRYSMOXshF8BqMb7Sqsbl0 + 3mMhWR6s42a0juz8/9rdXXjvD17EH9YeLrpn6gYuWzoJ3/vIcpy/oLBUoieZxf2vHlF6REVt1DWkCXFp + wJh12NJsr8i0XVt2no5GYSXTRTT7xZM78Lc/erEiBh4JbDnUi4/d+5KUhvH2Bnzq3Rfic+9cgjbhM/SP + rjscWonydBPpyF9jQidTEgDwf8/vw8fufQl7D/WW1dbmjqZQ6SJxw2eKmGuLj3d765Wz0N4k3/iTUroa + PnP/PEIpAMeVeEh2LxE1cNPyGYjEDaQJKQQrHAFgR1Vjgq6z/Ng5L1iNY0ZuBeDa3V342P2vYtvO40X3 + 0oTgsqWT8N0PXVI0t/zi+oPYtvN4kRXg680zYMS0EKfUbZ/MovFtd91CSeDwwXWd+Ni9L50xnsCWQ734 + zA/W4OkNh6X3v/iWWfj7WxcVeXFDqSweXnvYV4mKQjyYMZEmpMBvzLhw/MWETmVw0oTghfWH8NEfrMGW + MpTAjJa4m48fRCNZJCtMiZnydPMnNuPG85W7XyUB3B+2zqUMoB+CIrDwtmWTkhcKrwkzAdA1gpzuWC9C + XLeW/SKm5WFw9uMF3xUOXXOFJRI3MKF+ZNz/LYd6XeHnO5PV7epZ7fjPOy6SRo9/v/WElxGduscpLbTf + 8WxERSBDLp137+maN0/mPTDoGsHTGw7jb3/0Irp6pHu6nDLs7RrCZ3++Fqt3dbttZ3XO6Rr+8T3LcPv1 + C6TPvr7nJNYd7PWk59sN2ELE39M14v7466ZFPfmwH89rDIy3Vu/qxmd/vrZkRVpfF0W8vcGj/D2eCFd/ + vi6szuw5WXvThLh0vOWKmX6b36wihKxHSJSiANYC+J3iXv3Hr5iKxpjua9FlYyOWfjAWha7ZjYw01Sm1 + qCtQoIjEq/8GYPdACp/9+VqP8PN1md5Rj6/ccQlmjSt29/Z2DWH167aOZJ3K6pwmBI0xvXBu2MEdlvdg + LOre45mUP+fbzyAyvK4RPLiuE//8m41IZYPfyRgJdA+k8Lkfv4inNxx268fT4/YVs/DRlbOV8ZvnNh5G + n6DA+PaLNPDjOb5ckW5MoYr5MkX6xQdeQ7dkfb8KsXhhRor1Zw/19pufW88rraKhryMT08a34MbLZ/hV + Q/nijwwlhdCdt4qkXsBVyybjwnnjYFrU1ayMCCJRPA1zxrmNmSzShjP2GRhGnFJpeh4T4tWdAUhl8/iP + R7fg6Q2H3bJ5pdXSVo9/es8FWDazQ/r81oO9ONA9bDOdJA40nLOQNgyYFkVjJovBWNTt2MZMtqBwGB2i + BYZi10TIytE1gp+s2oX//MPWqtKnFBo+uK7TK2DUZuyrFk3A//eOxco31wYG01h9cKCojbnguFpFSBuF + KHvaMBCnFD95YT/+49EtofNoqo+hTYenP91+Ni3XGwlCLhpx6+MahgH7y1d3XjAe80cr975YA7WRlqIk + CSKEPOkEGIrQkIjiw1dMQwu3I2ljxjutEs8XWyTWwMFY1CUWQ4T7nFIRkeoTIFWeAXh09U58e/Vet+68 + EkoTgg8tn4b3X65eePHi9uNuJ0ckDkzaMDz5NmayHmUXp9RNI9JLRrscLS6HMZppUfzH4zvw5y3FMYyR + xJ9eOYB71+wrEn6NUkzvqMc/37rQ96vNh/pS2N/pHX9HiJyelYL1lch78Xze/X/vmn347ZrA2TQA9nQ1 + jUTcPPl+DjJmDIOxKCLZnPsMbximjW/B26+Z6/f4T1CC9QdKVAAO7lfNOV9/0RRcO7XFPZe58aIl4xvK + 4I6FohGXoXnGNi2KNh1IxKu3CGjLoV788592IjOYguW43sOa5iqhpbNG4/95s5r4qWwe6w72AbAZi1l6 + 1l7ek/BjCp75ZODpoFFaRE/m9uoaQU/vML7wy7UlubGVYG/XEL722A709SRdi502DESI7ZXcccMiXDrX + /7Nt+04M4UD3sN0HUXX/qjyiUu4zOsXzdkwmns8X+M3p976eJL722I5QsytRTulFsjl73M4pbl0jHp5Q + wY0J5PMY1uz+tAjBnVdOlw49HWxGidYfKEMBEEKebGyIPSC7l4gaeO/KuYg01SEXjbiujNhgRoS0Ybga + bzAW9XgDvJDkohH3yJiiPxJDrEpWIZXN4zt/2oY9R73TTmbEWafQVIcv3TTfd9fh4XQOfV2265qLRhDJ + 5tyj2E7+mItGpLEGBkYnRkOeDowWvLClDcN1mc2IgbW7u3DvU7uqQ6gA/Ojx7Vi7u8tTLz2XR44CVy2a + gA9fGfzJ9i0He922smdZm/j2sXus3fyRWXZe2HgaiveD6Lt+1wn86PHtgXXXDA0tznQme5bve9OiHp7g + y+fryl9neSyb2YH3XzHdr/hvo0TrD5TnAQD2NIP0C0LXLhyHm86fhEg2h0g2Z2tVR5syzcqIwO4xYrF0 + zBtgCkHP5T33AaAJFrRIdYYAz+7qxm/X26EN3t1k2vum8ydh+RL/j44c609jb8r7bgBrm+vSc15AYyaL + SFOdp/0AN/53xsx6Lu+hoUiPeD7v1pelBWzhZ//ve3Yv1u7uqgqtVHhx+3Hcu2afWw+N0oICJcDH3jSn + aK5fhv1dQ4hkc+7zEWLnx9rD2u7J3xGoeD7vETLWh7xFF+8H0Zfh3jX78Pyuk751J7p3x1/Wr2zYJxqG + XDTi9pGukUKdKfWUHc/ncceV0/0MUMljf4ayFIATC/iz7F4iauDu62a6sYC0YbieANOq8Xzec40RmxGG + Cb7baRGjSFCqhVQ2j289sgk9vcMwIwbS0VjB2kRjaGmrxydWTA9ccXisaxDJPC1YP95CczMd7F6aEOQG + hovaD9gMY0Zs2pgRw0PDeD7voYdowZjLzf6bEQM7TyZx79Mj5wWksnn816q96Okddq+xvjQjBm65cjau + XRi8bVsqm8f+7mHP82J7mODz93lr606Vch4ozzfi/SD6sme7hrL47pO7fGdWqFlsAFi/i0Flvv7xfN5T + T3EIuGTBRLzzkil+pCt57M9QdhidEPJNKGYEls3swIeWT/MQgXkEADzRUHad18riczKiVgtPbTqK5/b2 + uJ0Oy3Qti57J4NpFEwPHrQBwNGW6kVqxzWnDKLrGmItd5/+zoUAkm3OtETsXvSg+TzNiAJpeNOSKZHP4 + 7frOEfMC1u88gUfWHYIZKQgoq2NdPIL3XjQx1JLtXCaPfot4LCRrj0gn0SCIvKXiE/F+EH35/4+sO4QN + e/3lTEvE3LxEz5bFBcT7fJ1EGYg1JvCPb5mtXPWHCqw/UIECgP+6ANxxzWxMn154U8ljEbmOE6+L/8Vn + vGPfyoIAqWwev3jlsCu4oocRa0zgvReF+95g0ix+Xqx/JJtDtrGhKA3P3OLR5IY5QTRhCkxELhpB11AW + v335QEX0UuFnL+zHcFrehiumt+HK2R2h8slRit6hjLcvnPaoeIa/JjsG3Q+iL/9/OJ3DT5/1nxHoMQse + hqxfVTIgu5+LRnDT+ZOCvKdvoUzrD1SmAGBZ1regeEdg1rgmfOr6eUq3XWXh/cA/MwANer4yb2Dv8UE8 + 9fphaR31XB4LxjTgshDWHwBoOlPU4SJy0QhIpvC+uJhe5gGpaKDK3y/NbzefqPoKwa0nkli17YSyjjcv + m+j3rXoPspSAprOheSKIh8LeD7rGY9W2E74zAiRVmCGT8UEp/N7REMXd1830856+DMn3/kpBRQrA+aT4 + T1T3P3LltOSb58sFSKWp/SCm7bcq8wB+v/kEuoYkr4BqOsxYDLcumxgqcAUA/SYJ3RaWTuYNqNoadD1M + mh2He7Fqb3kvuqjw7IZD2NmTBrhPXrHyOxqiuHLh+JLyI/FoyXQMolUptAwqe+fJJJ7YJh9KZUN4pKXw + +2feNEe56GxgMM2+9lO29QcqVAAAQAi5D/Y4RIb6z71jCToaHCESvotWLnLRCMx0BjRT/vvbqWweqzcc + kt+0TNRFNSxfEJ55m3Vacvt4b+BUYdW6g1XN79k9vbabLhl6XDhrDKa1h9+yLUpGeLlflfCMs0MRYPMR + +1m5PGg6W6TYy8Elc8f6Tvs1Nca/Qwh5stJyqrGWthv2OETqW14+axTuWuksoGFMIgoKf+53T7jWl1Z/ + MCQIe48PYt0xtTu8YEwD5o0P93onADTUxwp182tPUHtlKCW/gPSr9/VVbWFQ58khrNupXml4xbwxJe3X + ECEErQ2xYBrw50Ft93surMIW0q0/2CulIc2bGIBWumIX6lIXj+Af3zIbbU3KodNmZ/hdMaq1mP5BSulD + qpufXjEdl8zlNi/grYWme89FJSH7KpBlYigPDGXLVwBbjicxNKz2IJZObgnt/gNAR0sd6qJawRqq6h/U + XhFh0oehp4NDJ4ew/Xh14gDrD/Ri58mkVKjq4hEsn1nafo1NjXE0axIvQGwTfy7Sl6ePzDOxSuQZSdmH + Tg7hRcmagF/tGsTAUIk7Mwn1pLEYPnn19KDA37fD7PYTqvhqZAL4Twt2tNXjC7cs8A4FeK3Hn4vXHdBY + zHN/mBIke8t/733DgV6k0ll52ZqOxVNL++DjxKYo6utiwfUP0V4aE6xgEH3C0JPRLWth0z7/BS1hseUg + F08QLO+kUQ2Y1NFYcp5T2+u8dPCz6D7tDHVfliaI/gCGsxa+/LtN+POW48hl8shl8nj09WP4n9++huF0 + zn1ePHp4QZY/gEunteLjb5O/Ju3g96hg2k9ENd+mWUsp/RYh5Ouym28+bwzuWjkX//aI9+0qGjFsl4lp + Qv7IEchNw+HEcHmzAKlsHq8f6FVa3bqohmkTSttsZGxzHG11EXT1DEndTk/9LRM0FvO220kHAMSZm2aM + 4ksf3tPwc2m5Z7f0VuejrhtVQyjLxNSmKDrqSo/5TJ3UDlj7iujjnvNtVrWxVHDWl2RMtxwl/QG8cmgA + t33rGSwY04B+Ezh4MolUOuvWUzwW8s8UnQO2x1Rv6PjHt8xGS0Iplp2U0m8H7fRbCqr6Pq0TEPy96v7d + 183Em+d6d7H2CIZsXKcY65FMBgcHy1MAw+kcTvaovYemhjgmlbhVdHtTAlObJEMGRZuK2i2hAcnlg+kj + lqMC9+zuvScq3isglc1jf8+w/KamY2p7XVn7NZ43ug6JeLSo3SSXV3pXDEWWNSSYp+Epw4/+DoazFl45 + 0Isdh3sxTImnXz1HWRucc1bnJNVw18q5Qa7/fdUI/Hm6qpqZwQ4I3gPFUKC9KYF/vnUhxrZxkWHZWDnM + fwC93YNlVTKdNXEwqRaA5riBMWXsNbB09phixvSpfygE0acM9FsEqVz4L9nKMJzO2Yt2FIpnapl77U+f + 1IZmMRAYxA/OkeTKU2q+z4UM0pJcvtgDcTyXonrzZTsK4ob5o/GJlbP8SlkDO9heVYzEntprAdynunnp + 3DH45+tnIxHVQSOGTaSI4dHeNBYLdX1/93BZlqwvZS/5pIqXiVobYoiE3NSTx2VTW5CIehlGVX8AnvJl + 1wAE06HUF6IsE71DGaRSlQ0D+jMm+n12rm0uIYDKY1pLDItH13kEqYgfOBqKNC4XPC/yR7EsN62kbBnf + smGAp958/gDGjmrEP711jtL1d16//xYqnPOXYaQ21f8WfIYCt189Ex+4cILHBSKZjIco7niYXeeIzMZR + +wey7hLUUpDO5JEcdsZhEiFs1igisdLd10UzRmPyqPqCYLKxJf9fHCM6afl2yhRjEX0kUDGq57qm+wpu + WKTSOekON6w97rRoiUhEDVw9d7Sbj0sbQaBcwYoYNh+pBBhq5aoqw5M/Z8E99HfOxX7xxCqAonp7yo/F + kIhH8YVbF2LJ9Ha3/fwPAJoa418G8GDFnSbBSG2qz4YCSyH5vHgiauBvb12EjV0pvLT9mEtoWfBEFkxh + xOsZzuG1QwOY1GF5FgURQwfNm0X/AYDEoth2vDD+dwNuDiMBtou89/ig+7wMNG8W3aN5O/i143BvUZtk + wSDZNb59Yeggqz9jdHYuurimRbH5eNLeWJOru6q9Ii2jho4dB3qKlCgbM9NYDJ0DWew91AvT0FGSitZ1 + TBjdiHpiYThreRReUHCNP7rXc3kPHXg6uW57BfQPUx8xf/7/B9+2EO9Z6jvu/z1GwPV3aUpDfMSgAnxo + YDD9Q9Va8Od3ncQ7//sFHB30uqNFjCzRngyj6+2llfwWVAymRd1dWPj7pkVxIplzy+IZmEYM1BGKhrqo + NF+Z1WNlAEByOIMk1bz5CvWXtSdMGmk6Sf397rFjfSKGeu7jFCJ9ZOdmOgM9HiuioazPRkeo57NfIr1U + /cPoyOcdlibKo9B28VgR/SWKx+8ajxvmj8YP77rI4/oLgdNOADcj5B7/5WCkFUA7gE8B+JwqwQ+e3Ye7 + f/aqLTRO5FTJ0IoO9kvraSzreJ974rUgFDGSn0D6WDDfeodIJ5bL6uZpt2AB+TSquvspXz/aiTQUy5XR + TyaY0rZK6BFUN+UxpHIO00/S8hX5zZnYigf/ZnnRUmmmAFLZPOIR/W8JId8ILKQCjPSH9boty7of6ncF + 8JErp+Fv3jIPANwxHQOvnVVjNJfIXFo+DX9NNn5mLqLoGrJr4viRHzfy18Tln2KdgsaYsuWjMlfTzZtT + fCrB5t1fHmL9xTSy/Pj6iEex/X5LYWX0U0bIuSGFmKdIt6K+ltSDVyzusVL6S8oLStfR1oAv3rbII/z8 + mB8A4hH9gZEWfmDkPQCbeJSuJITcD0k8ALC/BPNX96/FL9eG+qBpDWcowlrFNzJGRyg+c9Mi/M213r39 + Bdd/jWVZd1Rrua8fRv7TunC3EPsWFC8MNSSi+Po7F+ItM1rKnsut4fSjJvzBeNfVc4qEHwA/nd1JKf3i + qRB+4BQpAABw3Bnl+oAJoxrwL++7AHNKeAOvhhrOJrxn2QT8y1tn+yXptCzrqlI+7VUpTpkCANwdhJTr + A86f3IJvvX8Z5naEf4e8hhrOBtwwfzS+duv8ovUlwpz/fY7lr/qCHxVOqQJwGncPFNuIAfZLQ1+8bZE7 + vecionuPKpR6P6545zrus40Vf09VXlB9g+oZVA/xeVl+/LV4yE+pn2r6jVT5KnqEpbsfSmzbxfPH42vv + WYJ2ny8iUUofwAjO96twSoKAksb6BgUB4AcvdeLuB9YhmRqhXXMiOpCrbE192XmHKTts/RhDs7TsuZFs + Xyn1O93ll0uPsOnjcSCt3gPg0mmt+M5fLsO8sfJ3IxzLf8qCfiJOqQfA4LzR9EnVJ8YA4COXTMA3bpyF + +gQXWOKtqp8ml1k+do2dM6ZQ5cvnobqmeo4XRr/7snrzAh2mfjmzWPhltJC1J4z1PBX0G8nyZbT2K1ek + f1DdmfBL6jy3ow5ff9dipfA72AzgU6dD+IHT5AEwUEo/OziU+brfrrHff3w7PvvoLiTZN9ZkDK6yfgHa + OZSWD5MHQxCz+Qlq2PyCUKrlEhmef/ZU0m+kypcpApavLH8Z/YPqIWlvR3sTfvaBxbhylndXJHGlH6X0 + jmq/4lsKTosHwEAI+UZTY/zLfm/03X71THz+rbNRzz52wbSvSjvzMHMFixGP2+lEi8Lu8en4a4xReGsp + pmXgrZTMusqsCKuXzCLK8hPrJ56LNPJrlwyidTuV9BuJ8mW0ZG1n+QfRX6yHeOSfT6cxt6MOP/vAYrz5 + PN8t5TsB3HM6hR84zR4Ahy+lsvnPqTaQSGXz+M+n9uBLf9xpxwRUAs+7haInAHgtHv+MCJmAqKwGfy4b + j8vOxfLjcVtZ8fUvpX6yc5Yff0/2XzbkYP/1iJf5R4J+I10+n6fYfpZnEP35tLK2cM/P7ajDt96/zBV+ + 0bglogYGBtNoaox/GMC9OM04UxRAO6X02+mc+T6/XWS++qcdpSsBkRlEYZQxGSBnWP4an5YfesjqIN6X + 1VlWP77+qvox8AItc11V/1VDlFNFv5EuX8xPdi8M/VV05o5zW2Ie4QeKFUAuk0djQ2zE1/iHxZmiABi+ + DuCzfgl+8Ow+3P3rzYWYgB/8hK4aqFb+KuURBnrEtj4jkf/ppt9Il18t+jiW/3/+6nJcMa3Z74kkgG8C + +PzINyocTmsMQIRlWd8H8B2/NB+5chp+fPtSdDQ5c6p6xO4IPVL4sevxeOEen0ZMH5TGL/+g9CqI+cjq + rGofX18GWfnsWGr+p5p+lZQf9D+I9uXSH3Cfu3j+eDzw0cvCCv+3Rkh8ysIZpQA0TdsTtFoQAN51wUT8 + 9/uXYm5LrNj9S6cLbiGgHnuKgSD+qIoQy/I3c/75M4jMyFttPk++PbyAq+rL0oljWrHeQfmfLvpVWj5P + TycIpyyf9QOjPTuWQn8WWHbyWXneOPz4PQtw/uQWBIBZ/lO2yi8MzrQhAEO7s/3x+/wSPb/rJO7+ySt4 + +ZizO62M8cOugAtKrxKsMPmbuQLj+XkFqufC1Jf/H7YcPl0l7SuHfmIdyy0/qK38fTFtKc9Krr/nvHZ8 + /Z0LMWGU7zw/b/nPKOEHzlwFANibidwP4G1+ibaeSOKTv9qEJ7f7fOwiDLP5pQ9CqfkHgQWZSmFWMU2Q + MIr5V7N9fnX1E8hyylflV2oflkCfekJx5/IpuOf6WWhvSvjllKSU3nOmBPxkOJMVABDSEzjYl8G/Pr4b + 3392X+GijAH8NDoQnJ6f8gmT3i9/0StQPauynKUKT5j01WyfH/2qXX7YNHy+ZdK/oz6Ku6+ego9dPQ0N + Cd+dj8+4gJ8MZ7oCAArbin0agPJtioHBNL635gC+9GIXkkeOFRjJx4ULfV2FcvKpxDKFqQ9QvfxHgn6l + tD9MOdXqyxCY26jhS++9EO9Y2BEm+Rkxzx+Es0EBMHxpYDD9Ob9lw6ms/Y22Lzz4OrYPVvbhixpq4LFy + 7ih89aa5YYJ97MWePpyBY34RZ5MCCPXuAACsO9iHv39ku39cgIcRAfK5wpG/Jv5XPQ/4p6k0fVD5YfNS + PVNKHkH1H2l6Vjt/n/RsvP+Pb5mNcc2BcZ3NlNJPn+7lvaXgrFIAAGBZ1gxN0+4HsNwv3dH+NL7y2E78 + +LXjGBZfKZYxkHgvCH7pZAwclK9qpV6pZYv3xbaGebGl1Pr7CexI0bOa+SvSdNRH8aVbz8MHzh8T5juH + a2APVUdsC++RwFmnABzcBntjkQVBCX/12mF8ftVh7DzAeQOGMDYMw+jlWpug9EHr+sVn+TrLLJnqfqmC + Uol1HUl6VpJ/WM/LiGDlzGb88w3zghb3AHak/yFCyCdxFrj8Is5WBQAAyxx3631BCbceHcCXH9qCX+4Y + CMd0PKPwAikTKD+BCZueQeUFBAlymPth6lpu/YPaVk16Vjt/wRh0xAjuuHIGPr18QqDL77zU82WcoXP8 + YXBGrQQsEWsdrftlv41FAGD+uCZ8//1L8e+3nYc5oyX7DbLPYbHpHkMvXMsLq+UYk4luNZ+HJ03AunL+ + tVLZSy0iE7P82PUw91WML0sjekdh6u8Kql6oSxA93TJPUf7sGbG/OFw8uRE/+8BifO2GGWHG+53OG31n + 3Oq+UnA2ewAunLjAM/DZYozhtcMD+Nzj+/HcNic24GeRGUShZNdUY2lZev4Zmduvyj9o+JA3g+8D6iGD + yurz6cLUn6+Hqv1h8hmp/H36q6M+ig9dNA6fWDkrjOADZ+l4X4ZzQQG0A+h29hn8AgKCgwDQk8zi15u6 + 8M3Hd2BHD2ddVEtrZevdZRZb9koq70Ew6wN4BdMvT9dK68V58cIq3i8VEndYmkasP6MbX88w9OEV3Ejm + z/pBkeaSqa24Z8XEoM07ALgu/3csy/rW6drCq9o4FxSAC8cTuCNovQDD1n+UEVEAAAelSURBVBNJ/Nfq + /XhwbSe6ktlgAQAqFzRZfiqBCPNc2PQjhUroEebZaufv0G3M2DZ8elk7PnzlNLTVR8PkthbA9wH8Dmex + yy/inFIAHD4E4JMIMUuQyubx7K5u3LPqMF7a3xtsiUWwsSRLXyqzMkEG5FZLlR9vLcVnKqlPuVBZZr4u + smMpCkzmpYShP1ME+RzqEjHcuHQC/nnFRMwfF/ojNL+HPet01rv8Is5VBQDLsmYQQr44OJR5XxhvoCeZ + xf3rTuAHLx3GzuND8kR5s8BM/FFkePG+eA0IDn7xecry46+Lz6jW3PNli/Xwq5/YDvE5Pk9Vu/zeAwjb + vjD0l9U/nUZdIobLpjTiI1fNwA1zWsPM6wP2vn334SyO8gfhnFUADtoB3ApbewcGCAFgb9cQvv/Kcdz/ + 7B50mZo/U6vgx8jlCoks/3LqxucB+OcTlH/YdpXalmq0j2vjxZMbcedlU/DOhR1h3X0AWEMp/eLZtKqv + HJzrCoChnlL6g6A9B3lsPTqA/3rukB0fyHA0kjG8THArZd5yoPJIysmDgXetS7HSMsiGKqXUR/Vf5oEB + mD2hGR9c0Ir3XDoVk1tCf7j0nLf6PN4oCoAhdGwAsOMDW04M40cvHMKDW7rtQGE5CKsMqiHAlZR7OhFm + aBSynnOaNNy0bAr++qIxmN7REJjeQRLAKuf183Pa6vN4oykAd6YAwJ0IOSwA7PUDHkVwJgjNuYRyXmhi + cPpiTpOGv1oxG+9Y2FGKxQfsr/N8G+dYhD8M3nAKgMFZN/BJACvgs8+AiK1HB3D/ui48vLXLDhaeKYrg + TKnHKa53HaFYOK4e77pwMt6zaBRaEkbYAB9S2TwSUeOcmtcvFW9YBcDhNtirugIXEPHY2zWEh7b34dcb + j+P1Az0YpqQqlWlurEP/4HD1n4tEgVy2+L8fRuI15KB8wqzMBFBfF8fyqU340IXjcM305lKCexgYTKOx + IfbA2foCTzVRUwA22imldxJCPoUShgWAPX349N5+/GZTF1bv7cPxPkcIZW/x5XNe4VMxuSigovACamH2 + E3RZPnxesnoE3Q/7rF9deFrwNJE8M7stipvnd+Dm2c04f0pLaGvPYQ3sAN+DpT54LqKmADiUGx9g2Hp0 + AA9t68WjW09i04kUksPh3ulXWu8gqy27HzadqiyV0Afdl5UVpp6ioiSk6PqYljpcPb0FK6Y34/q5o0od + 3zOsAfATvAHH+X6oKQAJKlUEPcksXt3fi6f2D+G5fX14qTNZLACC9fcoAV7IVIItXg9zZHnyCFIift4H + d99XifmVq/CC6uviWDg6gRvnj8KbZrfivNF15Vh7oCb4vqgpAB9wiuAWhJw6FCEqg00nUkjmLJf5mxMR + 9A8OFwRIJbhA8Tm7xi+PZRZUli4SME72K0+8x/iGkOD8/e5R6g6NmuMGLpnUgCunNuNNs1sxvTVe0tie + QxLAetQEPxA1BRACzrLiWwkhN6PEYCEPpgzWHk/j2f392HBkqBAzYAgSUhF8/7EYQxBUcQCZ0hGfY/c4 + wS0XzXEDY+o0LJ3QhIsmNeHKaU2VWHr2tt7vATyMmuCHQk0BlAa2tPjmgcH028K8Y6BCKpvHvr4Mth4f + xlPbTmDDiTT29WVwPCn56KlKKMux6tVGUP6Uul5JfV0cDVENS8Y3YNGYelw7tQGzRteXslhHhU4A91FK + nyGErEdN8EOjpgDKhLOO4GbYCqHkOAED+3y0aVo42JfG1pMZvHJwAK8fT2Jf9zCOD1voT/t8CZkJ2GlC + c9yw6ycZLvAWftHYeszuqMP8MXWY1hIr28pzSALYB+Ahy7Luf6PO41eKmgKoENzw4CoAS1GBMuCRyubR + NWzixFAGaw8PYk93Ggf7MzjQk8K+vgzSJmzBU/XfSCkFYezfHLcFOa4D01pimNKWwEWTmjC5JYaprTFM + aIyG3WUnLDoppasJIb8DsBo1a18RagqginC8gqsAXA1bGYReYRgWPcksjiVzONQ1hEFLw8G+DI4NZFzl + AAD7+uxt0NNs0yHTsgOPIVAfsbeJNPTCdpFxHWiOaWhLRNBcF0FL3MDk5hjGNsVcQW+LaRjdEA36XFa5 + YNb+ry3LOlaz9tVDTQGMDNoppUsdZXALypxBKBWpbB6pnIWhHMVQNo/hrIlUjmJ4OI1Byxbobu6FpmTO + 7vv6SMFbaHei7o2ahbq6ONrrbQs/tt6eaSgzKl8OOmEL/T9QShOU0n01wa8+agrg1OA2AEtgewbTUKVh + wjmITgDrnWDeKtg78LQ792qu/gigpgBOPZYBWEopvZoQsnhgML2gktmEsxydAHoBPARgA4D9OAe33TqT + UVMApxHOQqMWSmmrM1y4c2AwPSESC/9G21kG5tZvALAR9mIdZuVrFv40oKYAziAwhQBgKuwhA2DHEFoB + tGAEgoojhCSAPgD7KKUHYAv8hto4/sxDTQGc+WiHrRCmUkqnEUKmOOctADAwmF7e1Bg/CWDUKaxT0jn2 + wXbh+yilBwgh+wAcoJTud4S9DzXLfkajpgDOXrRbltXCeQytAKYAYEOKKbCVRCsAUErTg0OZGUHxBmc5 + 7UkAGdjuegsKAt7rHPsA9FqWtQEAaoJ+9uL/B8+D1JorvOplAAAAAElFTkSuQmCC + + + \ No newline at end of file diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowMessage.Designer.cs b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowMessage.Designer.cs new file mode 100644 index 00000000..ca4b5a7a --- /dev/null +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowMessage.Designer.cs @@ -0,0 +1,92 @@ +namespace CoatiSoftware.CoatiPlugin.Wizard +{ + partial class WindowMessage + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(WindowMessage)); + this.buttonCancel = new System.Windows.Forms.Button(); + this.buttonOK = new System.Windows.Forms.Button(); + this.labelContent = new System.Windows.Forms.Label(); + this.SuspendLayout(); + // + // buttonCancel + // + this.buttonCancel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left))); + this.buttonCancel.Location = new System.Drawing.Point(13, 78); + this.buttonCancel.Name = "buttonCancel"; + this.buttonCancel.Size = new System.Drawing.Size(75, 23); + this.buttonCancel.TabIndex = 0; + this.buttonCancel.Text = "Cancel"; + this.buttonCancel.UseVisualStyleBackColor = true; + this.buttonCancel.Click += new System.EventHandler(this.buttonCancel_Click); + // + // buttonOK + // + this.buttonOK.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.buttonOK.Location = new System.Drawing.Point(257, 78); + this.buttonOK.Name = "buttonOK"; + this.buttonOK.Size = new System.Drawing.Size(75, 23); + this.buttonOK.TabIndex = 1; + this.buttonOK.Text = "OK"; + this.buttonOK.UseVisualStyleBackColor = true; + this.buttonOK.Click += new System.EventHandler(this.buttonOK_Click); + // + // labelContent + // + this.labelContent.AutoSize = true; + this.labelContent.Location = new System.Drawing.Point(13, 13); + this.labelContent.MaximumSize = new System.Drawing.Size(300, 0); + this.labelContent.Name = "labelContent"; + this.labelContent.Size = new System.Drawing.Size(44, 13); + this.labelContent.TabIndex = 2; + this.labelContent.Text = "Content"; + // + // WindowMessage + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(344, 113); + this.Controls.Add(this.labelContent); + this.Controls.Add(this.buttonOK); + this.Controls.Add(this.buttonCancel); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.Name = "WindowMessage"; + this.Text = "Message"; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Button buttonCancel; + private System.Windows.Forms.Button buttonOK; + private System.Windows.Forms.Label labelContent; + } +} \ No newline at end of file diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowMessage.cs b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowMessage.cs new file mode 100644 index 00000000..4f453a49 --- /dev/null +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowMessage.cs @@ -0,0 +1,96 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace CoatiSoftware.CoatiPlugin.Wizard +{ + public partial class WindowMessage : Form + { + private string m_title = "Title"; + private string m_message = "Message"; + + public delegate void Callback(); + + private Callback m_onOK = null; + private Callback m_onCancel = null; + + public string Title + { + get { return m_title; } + set { m_title = value; } + } + + public string Message + { + get { return m_message; } + set { m_message = value; } + } + + public Callback OnOK + { + get { return m_onOK; } + set { m_onOK = value; } + } + + public Callback OnCancel + { + get { return m_onCancel; } + set { m_onCancel = value; } + } + + public WindowMessage() + { + InitializeComponent(); + } + + public void RefreshWindow() + { + Text = m_title; + labelContent.Text = m_message; + + //if(m_onOK != null) + //{ + // buttonOK.Show(); + //} + //else + //{ + // buttonOK.Hide(); + //} + + if(m_onCancel != null) + { + buttonCancel.Show(); + } + else + { + buttonCancel.Hide(); + } + } + + private void buttonCancel_Click(object sender, EventArgs e) + { + if(m_onCancel != null) + { + m_onCancel(); + } + + Close(); + } + + private void buttonOK_Click(object sender, EventArgs e) + { + if(m_onOK != null) + { + m_onOK(); + } + + Close(); + } + } +} diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowMessage.resx b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowMessage.resx new file mode 100644 index 00000000..b2ef6994 --- /dev/null +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/Wizard/WindowMessage.resx @@ -0,0 +1,1328 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + AAABAAgAEBAAAAEACABoBQAAhgAAABgYAAABAAgAyAYAAO4FAAAgIAAAAQAIAKgIAAC2DAAAKCgAAAEA + CACoCwAAXhUAADAwAAABAAgAqA4AAAYhAABAQAAAAQAIACgWAACuLwAAgIAAAAEACAAoTAAA1kUAAAAA + AAABACAA6ocAAP6RAAAoAAAAEAAAACAAAAABAAgAAAAAAAABAAAjLgAAIy4AAAABAAAAAQAA3sKfANG1 + rwDTtq0A1LavANS2swCHPCUAhz0mAIY7KwCGOywAhjwpAIY9LACHPSwAhz4tAIg9IQCIPSIAiD4iAIk/ + KACIPiwAiT8tAIg+LwCLQh8AjEMYAI1EGQCORhsAkUcTAJFHFACRSBQAlk4RAJZOEwCZVBoAikAkAIpA + JQCMQyAAjUQhAI1GIwCKQCkAjUcsAI5HLQCPSjwAkUsqAJFMMgCRTTMAkk41AJBLPQCQTDsAkU4/AJdV + LQCTUDsAnF0/AKVcAACmXQAAoVoJAKJbCwChXR8ArmUAAK5mAACvZwAAq2UMALhvAAC4cQIAvXoSAL16 + EwC4eB4AomAiAK5vKQCtcTsAtHYlALV5KQC4eSAAtn4/ALh+MQCVVEMAllZHAJdWRgCdYEIAnWFUAKZv + ZACpc2MAqnVlAKlzaQCla1EApm5UAKx1TgCocVgAuYRJALmFSgCpdGgAsX9iAMaknwDJqKAA2LyiANG1 + qgDQtK4A0LOoAM+zrQDXuaAA28CcAOTInwDjyaIAuYAzALqBNgC5gkYAvIlQAMqWRwDLmEcAsYJ4ALeI + ZgC1hWkAtohsALmKaQC8j28AsoJ4ALiLdgC6jnoAvZN/AMSbewC9lH8Av5aCALySigC7kokAw5t4AMmc + YQDKnmQA27JxANanWwDOpG0Ay6NzANSvfgDbsnAA2riKANm4iQDlypwA5cmbAMyqjQDFoZcAxqKXAMej + lgDHpZwAyKWdANKwhwDStqwA1ryuANi+sQDcwaMA38esAN7HtQDhy7cA4s24AOPOugDk0b4A5tfNAOja + 0wDq3NQA7N/TAO3g2ADt4tgA8OXXAPLo3wDy6uYA8+zlAPbw6wD59O8A+PTxAPn08AD69vUA+/jzAPv4 + 9QD9/PsA////APXq2QD16tkA7uPgAO7j4wDx5+AA7uDgAPLl2wDv4t4A///1AP///wD///8A////AP// + /wD///8A////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALi4 + uLiphIB8fICBq7i4uLi4uLQKZzw7Ozs7RGiBt7i4uLSBRDg4ODg4ODo8RIO4uLhgZH15QzJCf31kOTlj + YLivVUCcj0U0i6WQZjN+ZVWpXzU/maGSlKaoopWTnEE1WHgcHIWoqKioqKibn5EdHHhqGBlup6ioqKio + oJtSGBlrbBYulo2OoqiopJ6YaxcWbHQhSZhKIVBwcVNQcichIXRbLyeMiCgPDw8PHyUjHypbq1AGL4eH + IyMQECMfIxBPq7UDRyyJihERERERERFIA7W4tFhLVi0MDBEREQhIWLS4uLi0AUwmEwgIEytPA7S4uLi4 + uLWrW3ZpaXZbq7i4uLjwDwAAwAMAAIADAACAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAgAEAAMADAADgDwAAKAAAABgAAAAwAAAAAQAIAAAAAABAAgAAIy4AACMuAAAAAQAAAAEAAIg9 + GgCHPScAhz0tAIk/IwCIPyoAjUMcAI1DFwCWTQ8AmE8NAJBHFACQRxwAlEsUAJJLGgCbUw0Al1EaAJpR + EACKQSUAi0MrAI9IJQCPSS4AjEQ0AI9KOACRSyYAkE0+AJZRKACfXSUAlVM0AJZVPwCZWTsAoFcAAKVd + AgChWxcAoF8nAKVgDgCsZAEAqWMIAK9qDACqZxQAs2sAALJtDQCybxMAvXUCAL54BwCzcBUAqGcnAKZn + LAChYzkAr3Q5ALFzLAC2ei0AsnYwAJJOQACaXEwAnF1AAJteUgCfYkcAnWFPAJ9lVwCgZUkApWxcAKRr + VQCsdlsAsntFALJ7SgCyflgApW1gAKp0YACwfmQAsX9pALyFPgC7il4Au498AM6phQDCgRcAw4guAMKH + KwDMlT4Ayp9oAMicYgDCmXoA0qlvANCocgDMo3EAzKV7ANCqdwDeuoAA9e3lAPjx4gC8k4kAvpWAAL+X + igDEnpEAw56WAMyspADYu5QA4s69AN/LwADv3LwA4c/DAN/LyADCnI0Az6uIAMqliADJppsAy6qUAM2s + mQDTtqQAxaKXANKwjgDXt5IA0rOaANi6lwDgwZQA2LmQANa8pgDUuKoA6MyfAMqpogDRtK8A2b+sANS4 + qgDWvLMA3cOjANzFvQDZwbMA5MSPAODHpgDiyqoA4cu1AObSuwDhzskA6dvPAOTSxgDm19MA6tzUAO3h + 1ADt4doA8efeAPLo3gDw5NIA8OfhAPPq5QD38e4A+fbyAPv59wD///4A6tvUAOjY1ADv4M0A8ePNAPHn + 4gDy6egA+vXtAPbt6AD37+IA8ennAPbx7QD28fAA+vPsAP///wD///8A////AP///wDo6OgAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACjo6Ojo6OjopeVZX19cFuXoqOjo6Ojo6Ojo6Ojo5+SUUxJSUkpKkpMUZeho6Ojo6Ojo6OjmHFLJilJ + KSkmKSlJKUpxmKOjo6Ojo6OXUScmJikpJiYmJikpJiYnUZmjo6Ojo5lUJCcnJyIiIiIrJygkIiIiIlGY + o6Ojn3AkVH9NeiMeHkWLUn5OHh4eMihxoaOjlzIeb49SeiMNHm2RgW9SHQ0wfiUwkqOibB8NZZGLbC8s + ZY+RkIBTLD6BhB8NSKGXPg0NRpGRj4mNkZGRkZGOio+Rbg8PTpdiGQ8HIIaRkZGRkZGRkZGPg5CPQA8H + L5VrDgsLC0+RkZGRkZGRkZGMZpB3DgcOH3doDAwJDG6RkZGRkZGRkZGRkYYuCQwMDnhoCgUGQJCMfI6R + kZGRkZGRkYhkGAoKCmlrFgUFaZBDEj14iI6OjHtZhmk9FgUFEmtiGgUQZ441AAUQGjc6HBYAR0QABQUQ + GmKWPAMDQo5kEQMEAwMDAxAQERMQEBADO5efXBMTEWSNeRsEEAQEBBEREAQQBAQRWKGjlzwRBAM6gmsB + BAQEBAICBAQEBBE8l6OjoVgUBBdBgmcBBAQCAgICBAQEARtboaOjo51YFDuFezQCAgICAgICBAIEAlud + o6Ojo6OdWBQzFAIUAgICAgICAgIVWJejo6Ojo6OjnVg2AgICAgICAgICAjlYnaOjo6Ojo6Ojo6GXXEI2 + FAICFDNBWJefo6Ojo6Ojo6Ojo6Ojn5dcdnZ2dmOXoqOjo6Ojo6MAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAoAAAAIAAAAEAAAAABAAgAAAAAAAAEAAAjLgAAIy4AAAABAAAAAQAAiT8eAIc8 + JgCHPS0AiT8kAIg/KQCMQx0Aj0YVAJVMDwCYTw8AkUcUAJRMEwCRSRkAnlQHAJ1UDACZUhIAmVMYAIpB + JACMRCwAj0ksAI9IJACNRzkAj0k7AI5JNACSTScAkk00AJFMPQCWUiUAlVIuAJtXJwCcXDYAmVg2AKBX + AACkXAEAoFkPAKJdGACrYwAAq2UIAKhkEwCzawAAsW8WALpxAAC6dxEAv3wSALFwGACkYiMApWc3AK9z + MwC0dyYAt3wsALR6NACbXEEAmVtNAJhXQgCdYEEAnmRWAKJnSQCkak0Ao2lUAKFpWwCqc1gAs35TAKZv + YwCoc2cAqXRoAK15ZgCufXIAsH9qAMJ+DgC8gjQAvIM5AL+IOgC/i0oAv4lCAL6MVAC9jFsAtYJWAL2O + YwC4h2EAtoh2AL+QYwC9kXEAxIIVAMiLJwDBjEUAwo5IAMaSRgDRnkkAxZZZAMaZYwDInWoAyJ50ANGh + VgDLom0AzKN0AMymfgDWrnIA37uBALqPhAC8k4kAvpaIAPPr4AD17N4A7+bjAMOcjADDnZUAyaSGAMyr + nQDIpp4A0q+FANa1jADQsZsA1LWWAMytpgDUuKYA2L+yAOLPwQDbxL8A4s/KAN7JwwDjz7UA5tTEAOja + 1wDm19UA4s/JAN3CpQDcw6wA28S1ANzFvADfy74A69a3AO/dwQDu49gA4c2/AObSuwDw38MA7+HOAPDm + 3gD27dwA4tDJAOXUzgDt4dsA49DFAOTSxgDm1c0A6trIAOzf2wDo2dEA7uHUAO7j3ADx5twA7+ThAPTt + 6gDz6+YA9/HrAPjz7QD59fIA+/n3AP///wD38vAA7uPgAPny8gD59fIA+PPwAPv38wD59fMA+/n3APz4 + 9gD59vMA+vXyAPn18QD8+vgA/fr4AP///wD///8A////AP///wD///8A/v7+AP///wD///8A////AAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALS0 + tLS0tLS0tLSyrauHjYaGjYekrrO0tLS0tLS0tLS0tLS0tLS0tLSuq4JtVlJRUVFRUlaGkKuztLS0tLS0 + tLS0tLS0tLS0q4VbQ0MoKChDKCgoKFFSVoKrsrS0tLS0tLS0tLS0sWhfUSgoKCgoKCgoJigmUUNDQ2xo + rrS0tLS0tLS0tK6HVCYmJiYmJiYmJiYmJiYmJiYoJlV7rrS0tLS0tLSzh0UkIyAjIyMmIyMjICMjICYj + IyYmI1KHs7S0tLS0sp9VJ1JEJ1QvICMjICdUUidUMCMjICAgIFSrsrS0tLSrXyQwmYZUm1ggICAgV52R + VJltICAgIC9IIF2rtLS0s3AlHzGbmlSOWB8gHyB8nZxYhG0fHyAfbGwgJ36utLSkSh8MLpedhVpaDCEh + WZudnZBabyEMIUqeaR8hWau0sYIsDg4slZ2dkm9KWHGenZ2dnZVxWEpvnp1YDQ4sgrKrbA4ODg59nZ2d + nZydnZ2dnZ2dnZ2cnZ2dly4IDghprqtLCAoOCEycnZ2dnZ2dnZ2dnZ2dnZmbnZ1+DwoOCkqkgi0KCgoK + HI6dnZ2dnZ2dnZ2dnZ2cTW6dm0sHCgoKLYeMHAkJCQkJUJ2dnZ2dnZ2dnZ2dnZ2Ek51uCwoKCgkcjIQa + CwkLCS2PnZ2dnZ2dnZ2dnZ2dnZ2dfhwGCwsLCRqOjhwLCwsLbp2dkpidnZ2dnZ2dnZ2cnJyOaR0FCwUJ + HJCSHhMFBR2UnXEbOHKanZ2dnZ2dnJKRno1/OwUFCwUdjZ84BRMFN56eNwAFEzhnco2PhGpAGFqXNwsD + CwsTADifn1oAAwAymJcyABAFAAAQEhcTAwABGHA5AwADAxMDQKuuZwMQEBFynWcQAwMQEBAQAxEDAwMD + EhEEAwMDER5yq7RwGBEEAzmWm3A0AwMEEBADAwMDAwMDAwQTBAQSNI20tKtOGAQEAzl/m480AwQEBAQE + AwMEBAQEBAIEBANCq7S0ro8zBAQEARFBnGEBBAQEBAQEBAQEBAICAgQEHmu0tLS0q2ECAgIRGUGcYgQC + BAICAgICAgICAgICGTRwq7S0tLS0ez0CAj6UnpEzAgICAgIUAgICAgICAgICQZ+utLS0tLSzcD0CM3Br + NgICAgICAgICAgICAgICAj+isrS0tLS0tLSunz0CAgICAgICAgICAgICAgICAgJBdK60tLS0tLS0tLSx + ZGIUAQICFAICAgICAgICAgI0f5+ztLS0tLS0tLS0tLSzpXVBFQICAgICAgICAgI0QXCrtLS0tLS0tLS0 + tLS0tLS0saCMa0E6NDQVNDZBa6Crs7S0tLS0tLS0tLS0tLS0tLS0tLSwn4yMjY2fZmGxs7S0tLS0tLS0 + tLT/wAP//wAA//4AAD/4AAAf8AAAD+AAAAfAAAADwAAAA4AAAAGAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABgAAAAYAAAAPAAAAD4AAAA+AAAAfwAAAP+AAAH/wA + AH//AAD//+AD/ygAAAAoAAAAUAAAAAEACAAAAAAAQAYAACMuAAAjLgAAAAEAAAABAACJPx4AhjwmAIc9 + LQCIPiUAiD8qAIxDHACVSw8AmE8PAJBHFgCUTBMAkUkZAJ9WBgCcUw0AmlIRAJ5aHQCYUhsAikElAIxD + KgCOSDUAjko6AI1HNgCRSysAk00mAJJONACWUzMAnV01AJdWOwCfYj8ApFsBAKBYCQCkWwQAoFscAKxk + AACnYQoApmEWAK9vHACraBcAsGcAALNrAAC4bwAAsW4SALFvGQC6cgAAsXEbALd2GQCpaSkAoWQ7AKpu + OQCtcTUAtXcjALF2NQC2fDkAuX4wALN4OACVVEQAm11DAJlaTACbXlIAn2NIAKJlQwClakgApGtTAKVs + XQCtdkwAqnBDAKpzVwCsdlkAsntKAKVtYgCpdWoAqXVoAMB8DwC8h0UAt4RWALWEZgC0hW0AuYljALGB + cwC0hnsAuYx1ALaKfwC/kWoAvJJ6AMaJKADMkC8AzJU9AMGOSQDLlUIAypdJANCaQgDHmFkAyJ1oAMec + cADNo2sAy6V8AM2kcQDYrGIAvpWGAMSdhwDOqYYAzqyPAMejkgDHpZoAyKaVAM6unQDRro0A0K+SANi3 + iwDcvI8A1bGEANOzlQDWt5YAyaehAMqqowDPsaUA0bSkANG1rQDWu6oA2b2gANW7tADXvrkA3cGcAN3D + pQDcw6oA3MS0AN3IvgDiwo8A4sOSAOHHogDjzKsA48qlAODJswDl0LcA7NrBAP/+/ADgzccA5NLLAOPS + zQDv5d4A9e7pAPTt6gDiz8UA5dPEAOvbyQDq3NQA9uzeAPv38wDu490A7eDUAPHm2wDz6t4A+PPvAPHo + 5QD17+oA8OflAPTs5AD58+gA9e7pAPfx7QD48u0A+fXyAPz69wD///8A9/LwAPXw7gD79u8A9vHsAPjz + 6gD+/f0A/f37AP7++wD+/PsA/v79AP/+/gD//v4A////AP///wD///8A////AP///wD///8A////AP// + /wD///8A/f39APz8/AD19fUA////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu7u7u7u7 + u7u7u7u7u7uyr6illJaWlJeor7K7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7sq6og39gWVRTU1NgYH+E + qK+6u7u7u7u7u7u7u7u7u7u7u7u7u7u6r5R/VUcqR0dHR0dHR1MqR1mCja+6u7u7u7u7u7u7u7u7u7u7 + u7uylH9TKicnKkdHR0cnJ0dHKidHR1N+mbS7u7u7u7u7u7u7u7u7u7qvjlcnJycmJyclJyclJicmJyYm + JyZHR2Cfr7u7u7u7u7u7u7u7u7qolUclJiYlJSUlJSUlJSUlJSUmJiUlJyZHVYWst7u7u7u7u7u7u7qo + glMlJiUlJSUgICUlJSUgJSUlJSUlJSUlJSUsf6y7u7u7u7u7u7uvlFMnJiUgHiAgICAgICAgHCAgIBwc + JSUlJSAcHCmBr7u7u7u7u7uyhCscVmxaK21eKxwgICAcNGtrNEhsXSEgIBwgICAlNJayu7u7u7u3jVYc + HG+ihTGWliMcHBwcHF+iol9booEcHBwcHCFdKyVajbq7u7u7r3kcHBx6op8zeZMkHBwcHCGEoqKEM516 + HhwcHBwzlTMcHnmvu7u7uY01HR0ddqKiekiPNQsLCwtcoaKioVxejiILHQsie6A1HR0zkbK7u6xvHQwM + B2SioqJ7XEkLDCJen6KioqKfY2M1DA0weqKbLQwdHW+vu7eSSR8NDQdboqKiopqDbm+QoaKioqKioqGU + e2p7mqKijh8NDQ1DqLu3jh8NDQ0HL5uioqKioqKioqKioqKioqKioqKioqKiomoNDQ0NH4+yr28HBw0N + CQ98oqKioqKioqKioqKioqKioqKioaKioqBDCQkHCQl2r6hMBgYJCQkJSaCioqKioqKioqKioqKioqKi + e0maoqJ8DwkHBgkGXKiNPwkJCQkJCQ91oqKioqKioqKioqKioqKiomhAk6KePwkJCQkJBkKSmi4ICQkJ + CQoJYqKioqKioqKioqKioqKioqKhn6KhYwkJCgoKCghAmpUuCAgKCgoISp+ioqKioqKioqKioqKioqKi + oqKhaAoKCAgICgoILpqaLgUKCgoFGZCioqCboaKioaGhoaKioqKioqKioHVSGQoKCgUKCC6anTsFBQUF + BU+ioptGOnOgoqGhoaGioqKioqGeoqChoGgWBQUFCgA8mIw9BQUFBQVooqJPBQUWQXOToKGhoqKhoI1S + S6GNQT0YBRAFEAUFQZKoSwUFBRAFdaKdGwUFBQUQGEJiZWViSzwVABWNkxcABRAFBQUFBU+ur3wVFRYA + AGeinjoDAxAQBQUAAAAFAAAFEAUAPXwYEAUQEAUQEAB1r7KQGgQDAABCoKJiAwMDEBAQEBAQEBAQERAQ + EQAYERAQABYRABEYkLe6iD0DAwMEFXShnWIXAxADEREREREDERARAxEDAxEDEQMDAwMERY26u6xmBAQE + BAMad6Ghij4DEAMDAwMDAwMDAwMEAwMDAxEDAwMVEnWsu7u5kT0DAwQEBBNFjaGQNwQDEQMRBAQRAwIC + EQIDEQQEBAMEAz6Jubu7u6x1BAQEBAICAxKNoUUDBAQDAwMEAwMCAgICBAQEBAQEBAR8r7u7u7u5mT4D + AgICAgICeKJFAgICAgIRAgMCAgICAgIREQIEBANGmLq7u7u7u7KNNgMCAz53jaGaOAICEQICAgICAgIC + EQICAgICBAM4jba7u7u7u7u7r3cTAgFhoqKYRQICAgICAgICAgICAgICAgICAhI5kK+7u7u7u7u7u7ms + dBMBFERFOAICAgICAgICAgICAgICAgICAgI4eKi6u7u7u7u7u7u7t6x3NgECAgICAgICAgICAgICAgIC + AgIUAgI4kLC6u7u7u7u7u7u7u7u5rIhEAgICAgICAgICAgICAgICAgICExRFh6+6u7u7u7u7u7u7u7u7 + u7uyjXQ4NgICAgICAgICAgICExQCAkSHoLK6u7u7u7u7u7u7u7u7u7u7u7qvqHhFNgICAgICAgICAhM2 + RHGar7m6u7u7u7u7u7u7u7u7u7u7u7u7u7Kvi41xYkU5OTk5RVB4naOyubq7u7u7u7u7u7u7u7u7u7u7 + u7u7u7u7u7qyr62MoJ6amKOtr7a6u7u7u7u7u7u7u7u7u//8AD//AAAA/+AAB/8AAAD/gAAB/wAAAP8A + AAD/AAAA/AAAAH8AAAD4AAAAHwAAAPAAAAAfAAAA8AAAAA8AAADgAAAABwAAAMAAAAADAAAAwAAAAAMA + AACAAAAAAQAAAIAAAAABAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAIAAAAABAAAAgAAAAAEAAADAAAAAAwAAAMAAAAADAAAA4AAAAAcAAADwAAAADwAAAPAA + AAAPAAAA+AAAAB8AAAD8AAAAPwAAAP8AAAB/AAAA/4AAAP8AAAD/4AAD/wAAAP/4AB//AAAAKAAAADAA + AABgAAAAAQAIAAAAAAAACQAAIy4AACMuAAAAAQAAAAEAAIk/HgCGPCYAhz0tAIk+JQCIPykAiD4wAI1E + FgCNRBwAlUsPAJhPDgCQRxUAlEwTAJFIGQCdVAwAn1YDAJpTEQCYURcAi0EkAIxDKQCPSScAi0QzAI9K + OwCOSDcAkkwoAJFNPACRTDUAmVYpAJVSMgCbWzwAl1U3AKBXBQCkXAIAo1wNAKNeGQCgXSUApmAKAKxl + AACrZQsArmoOAKtkAgCraBgAs2sAALhvAAC1bwoAunIAALx4DgCxcR8ApGIjAKtsJwCucCoArXM7ALZ5 + JgCwdDUAkk9AAJVURQCYWEcAn2JFAKRpSQClbFIApWxdAK10RACrdFIAqnRbAKx3WgC1fUQAsntLALF8 + VgCmb2AAqXRlAKx6bQCoc2YArnxyALB/dQDAfRMAv4IlALmDPwC6hUsAuYVVALSDZAC5i2gAs4N0ALSF + fAC2iH0Au493AL6ScgDDgRQAzpc+AMCOUQDGllgA059JAMCRYwDHmmUAxJt5ANSjUwDTpFwAzaNvAM2i + ZADJo38AyqFyANerZADRq3kA1KxxANq1fAC6j4MAvJKEAL2TigC/mI8AwZuJAMOdlADMqYsAyqWHAMil + lgDRrogA1bSIAN+8gwDavZoAz7GrANK0owDVuq0A17ymANa9tADVurIA4b2CAN3BnQDexKUA28KtANzF + ugDex7UA4sacAOLKqADizLYA4Mq4AOrSqQDl0bcA5tO9AO3avADeycIA38zIAPz6+QDl1MwA69zMAOjW + xADm1tIA693XAOve2gDo2dYA/Pr5AODMxgDu4c0A7+LTAO7j3wDy48wA8+bUAPHm2wD69vIA+/j0APfy + 8QD59O8A9OzrAPHn4wDy6uQA9e/rAPjx6AD28ewA9/HqAP37+gD69vQA+/j2AP///wD+/f0A+vf1AP// + /gD7+fkA////AP///wD///8A////AP/+/gD///8A////AP///wD///8A////AP///wD///8A////AP7+ + /gD///8A////AP7+/gD///8A////AP7+/gD+/v4A////APz8/AD///8A////AP///wAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADGxsbGxsbGxsbGxsbGxsbGxcTAuLCJ + oaioqY6wtbjFwsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsW/r6iZh2VdXVlZXl5ml6ScsL/C + xsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbBuJSXgF1VSUlJSUlJSSlJVVVWZpeSuMXGxsbGxsbGxsbG + xsbGxsbGxsbGxsbGxbisl11JVUlJSUkpSUlJKipJSUlJSUleh5K4wcbGxsbGxsbGxsbGxsbGxsbGxsa/ + sJhgLSoqKSlJSUkpKioqKioqKioqSSoqVWOkt7/GxsbGxsbGxsbGxsbGxsbGxr2sgFUpKSkpKSlJSSkp + KSkqKikqKiopKiopSSozgaq/xsbGxsbGxsbGxsbGxsbGuKplKyopKSkpKSkpKSkpKSkpKSkpKSkpKSkp + KSopSWaowMbGxsbGxsbGxsbGxsa4qFgpKSkpJyknJCQpJCQpJCQkJCQkJCQkJCkkJCkpKS1mor3GxsbG + xsbGxsbGxr+kYCQkJCQkJCQkJCQnJCQkJCQfJCQkJCQkJCQkJCQkJCQkYKy9xsbGxsbGxsbGv6ZmKSQm + JiUnJiYmJycnJyQkJycmJiYkJiYmJCQkHyQkJB8kJGSsv8bGxsbGxsbBsIQlJy6FmGQmgZVxHx8fJx8n + H1eMjHMmc5iCKB8fHx8kHx8fHyaBsMbGxsbGxsa4mTMfHzSmqIImhahxHx8fHx8fH3CoqJkuc6iNJR8f + Hx8fH1dlHx8zmbjGxsbGxsWsWB8fH0umqKQ0W6hkHx8fHx8eKI2oqKZXWKiGHx8fHx8fH4GGIB8fW6zF + xsbGxriNIB4eHkCmqKhzMIx8Hh4eHh4eX6eoqKiGMYKYKB4eHh4eV6aFIB4eKJe3xsbGwqxYDSAJDTSm + qKinbkx3MA0NDQ1aoaioqKiod0GCTB4gDR5Alah9DyANDVqSwsbGuJcvCQkgCS+ZqKioqIFcQCEvQHWh + qKioqKioqI1hWi8iMm2gqKhwDQ8NDSKMu8bGsG4JDw8PDw+CqKioqKinloyVpaioqKioqKioqKinooyP + oaioqKhaCQ8PICFzsMW/njwJDw8PDw1hqKioqKioqKioqKioqKioqKioqKioqKioqKioqJ8yCBAJDyBB + qL+4iyEJDwsPCwsyoaioqKioqKioqKioqKioqKioqKioqKioqKioqHcQCBAIDxAij7+1dwsLCwsLDwsL + d6ioqKioqKioqKioqKioqKioqKioo22CqKiopkIICAgIEBAQfbiycAsQCwsLCwsLPKGoqKioqKioqKio + qKioqKioqKiofwhCpqiodhALEAgQChAIe6yqXAsLCwsMDAsLC22oqKioqKioqKioqKioqKioqKiooW5/ + qKifPAoMEAoKCgsKbpanQgsMDAwLDAoKGnaoqKioqKioqKioqKioqKioqKioqKioqKVPCgsMChAKCgwM + T6WnPQwMDAwMDAwXc6ioqKioqKioqKioqKioqKioqKioqKioplwMBwoMDAwMDAwMQqinPQYMBwwMCwZO + p6ioqKaoqKioqKioqKioqKioqKioqKiomW9OGgwMBwwMBwwGTqWnPwYHBwwHBxN+qKiofTprpKioqKio + qKioqKioqKioqKioqKioizkGBwcHBwcGTqmlUwcHBwcHBxygqKh+FwcHOnahqKioqKioqKioqKeVb5+o + f3Z1UxsHBwcHBwcHU6ysbgcRBwcHBzqnqKc+BwcHBxM5a4ifo6inpqOPdlAdE3iobwcHAAcHBwcHBwcH + b7C1fQcRBxERADqmqKAcBwcREQcABxMdOT4+OjgbEQAHBz6lfhMREQcREREHERsajbi4lhcRERERBxyf + qKk5BxERBxEHEREHAAADEQcRBxERERFTdhMREQcRBxERERMdp7/DmjoRERERERJ4qKhsABEREgMRERER + ERERERERERERERISHRERERERERERERE+rMHDsGkBERERAwM7oaijUBIDEgMSAwMRAxERAxERAxERBBER + ERIDAxERERERERJvs8PGuI8dAxIREgMEa6aopnk6AwQDAxIDEgMSAxIDAwQDAxIDEgMSAwMSAxIDAx2Z + uMbGwaxHAwQDBAMEElKWqKifRAMDBAQDBAQEAwQEBAQEBAQDBAQEAwQEBAQDAVCsxcbGxrWIFAQEBAQE + BAM3Z5GojhgCBAQEBAQEBAMEBAQEBAQEBAQEBAMEBAQDFpO3xsbGxsGsUAMEBAQEBAQCA0ampz4BBAQE + BAQEBAQEBAQEBAQEBAQEBAQEBAQBUq/CxsbGxsa3jjYBBAQEBAIBAUOmp0MCAwUDBAQDAwMDAwQEBAQE + BAQEBAQEAgQ3kLjGxsbGxsbCsHQUBAIEAjZnZ46oljYCAgQDBAQDBQUCBQUCAgICBAICAgICBRZ5sMLG + xsbGxsbGv6xsFAICAm+oqKimUgICAgIFBQQCAgIFAgICAgICAgICEgICFG+sxcbGxsbGxsbGxr+mUgIC + AkWOlohHBAICAgIFBQUCAgICAgICAgICAgICAgICZ5+9w8bGxsbGxsbGxsa/n0gCAgUWNQUCAgICAgIC + AgICAgICAgIFBQICAgICAgJSqLjGxsbGxsbGxsbGxsPGuKxpBQIFAgUCAgICAgICAgUCBQICBQUFBQUC + AgUFFmyewMPGxsbGxsbGxsbGxsbGxr2seTcCAgICBQUCAgICAgICAgUFBQUFBQUCAgI3fqzCxsbGxsbG + xsbGxsbGxsbGxsa/sJBIFAICBQUCAgICBQIFAgICBQUFBQICFlGfsL/DxsbGxsbGxsbGxsbGxsbGxsbG + xriokUg1BQUFBQICAgIFBQICBQUFBTVRjrG4wsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbFtayRbEM2BQIB + AgIFAgICBTVIdJGvt8LGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsO/saiWk2xRR0ZGR1Fsi5+osrjF + xsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxb+4tbCsqKenpa6wuMC/xsbGxsbGxsbGxsbGxsbG + xsb//wAA//8AAP/8AAA//wAA//AAAA//AAD/wAAAA/8AAP+AAAAB/wAA/wAAAAD/AAD+AAAAAH8AAPwA + AAAAPwAA+AAAAAAfAADwAAAAAA8AAOAAAAAADwAA4AAAAAAHAADAAAAAAAMAAMAAAAAAAwAAgAAAAAAB + AACAAAAAAAEAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAgAAAAAABAACAAAAAAAEAAMAAAAAAAwAAwAAAAAADAADgAAAAAAcAAOAA + AAAABwAA8AAAAAAPAAD4AAAAAA8AAPwAAAAAPwAA+gAAAAA/AAD/AAAAAP8AAP+AAAAA/wAA/+AAAAP/ + AAD/8AAAD/8AAP/8AAA//wAA//8AAf//AAAoAAAAQAAAAIAAAAABAAgAAAAAAAAQAAAjLgAAIy4AAAAB + AAAAAQAAiT8fAIY8JQCHPS0AiT4kAIg/KgCMQx0AjkUVAJVMDwCVSwwAkEcWAJBHGgCUSxQAkUkZAJhP + EQCfVgYAnVQOAJpSEQCcVhgAikEkAItDLACPSCwAi0Q0AI1HOACPSjoAj0k0AJNNKQCSSyMAkk0zAJFN + OwCeWyMAmlYkAJRSPACbWjUAm1w7AJdWNQCgVwEApFwBAKBYCQCoXwAAoFcIAKNeFwCrYwAAqmULAK1q + EgCpZxkAs2sAALBrDAC4bwAAu3IAALp2DgC5eBkAsG0TAKRkLACqaiYAqm01AK9xIwCucjcAtXgpALF3 + OACVUkQAl1dJAJJPQgCfYkMAnmJNAJ5jVgCmbE0AomdGAKNqWQCsdEoArXleAKhyXACzf1QAsXpIAKlz + ZgCtemoAq3hlAK99cwCxf2gApGtgAMF5AwDDfg4AwX4UALuEOwC6gTQAvYpMALqFRgC6hlQAuolaALWG + bAC6jGkAsoJ1ALKCeAC4i3cAvJJ8AMeHHQDNlDgAyJREAMSUWADAi0QAw5VkAMWYYwDEm3YA1KZcAM6l + bwDMpXkA0699ANy3fgC+lYcAt4qAAMOchgDCnJQAzaqMAMumggDGopMAzKqUAMuqnADHpJgA0K6NANCr + gQDVsoUA2rmKANKznADYuZQA0a+RAMysowDJp6AA07akANK1rgDVuqsA1rqiANe+uQDVu7QA3sGXANzD + rADdw6IA28OzANrDuwDfyr4A5MWRAOPMrADnzKIA4sy1AODMvgDr0qkA6da7ANzGwQDfy8YA4c7EAOHN + yQDl0sEA5NPMAOjXwwDs3MUA6tvLAOXW0QDn2NQA6tzUAOrd2ADt4dYA7uLbAPHjywDx4cYA8efcAPTq + 3gDz5tEA7uDNAO/k4QD07OQA9O7rAPDm4QD38ewA+fPtAPfy8QD59fMA/Pn1AP/+/gD///8A////AP// + /wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP// + /wD///8A/v7+AP7+/gD///8A/f39AP///wD///8A////AP///wD///8A////AP///wAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAM3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3NzcXCury1sq2vr62wsrS9xszLzc3Nzc3Nzc3N + zc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3FvrSor66jo6GPjIyPoaSvr6+ztr7Fy83N + zc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nyb62ra6jimZfXl5eT09PT09eXl9miqSv + rLa+x83Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3JvqivoIpfXjAwMDBPT09PT09PTzAw + MDBeX4qkr7K+zM3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzcu+ta6QZlEwMDAwMDAwMDAwMDAw + MDAwMDAwMDAwXmaYr7TAzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3NzcW8r6BmXlAwMDAvMDAwMDAw + MDAwMDAwMDAwMDAwMDAvMWakrbrFzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Ny8Csq3heTy8wLzAtLS8v + Ly8vLy8vLS0vLy8vLy8wMDAtMDAvUXiussLLzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nyb6voGAwLy0tLS0t + LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLy0xYKSuvsvNzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nx7qvjDItLS0t + LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS1Tj6+6y83Nzc3Nzc3Nzc3Nzc3Nzc3Nyb2veDMp + LS0pLS0pLS0tLS0tKS0tLSktLSktLSktLSktKS0tKS0pLS0pKTGErrrLzc3Nzc3Nzc3Nzc3Nzc3Nyb6u + dy4pKSktKSktKSktKSkpKSkpKS0pKSkpKS0pKS0pKSkpLSkpLSktKSkpLnivus3Nzc3Nzc3Nzc3Nzc3N + y7yveC4pKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkuhK+8y83Nzc3Nzc3N + zc3NzcCvhispKSYmKSkpKSkpJikpKSkpKSkpKSkpKSkkKSkpKSkmKSkpKSkpKSkpKSkpKTONscLNzc3N + zc3Nzc3NzcWymDIkJitnaWlSJGJpaWcrJiYpJCkmKSQpUmlpaWEpU2lpaVMkJCkpKSkkJCkpJikmOaCy + x83Nzc3Nzc3Nzcu2q1IkKSQ5q6+vdyRpr6+YKyYkJiYmJiQkJHivr6+QKmGvr65iJCQkJiYmKSQkKisk + JCRiq73Lzc3Nzc3Nzc2+r2kkJCQkVa6vr4skYa+viyQkJCQkJCQkJCmNr6+vojNSra+qOSQkJCcmJiQk + JGeQKyQkJHevwM3Nzc3Nzc3HspcrIyQkI1Sur6+nOSyir4YkJCQkJCQkJCQ5qq+vr69hKpevpzckJCQk + JCQkIyqXqjckJCQzpLTJzc3Nzc3Nvq5UIycnJw5Ur6+vr3cOdq+QJScnJyQlIyUleq+vr6+vkCVkr6s6 + DiMpJSUlJyNhrqc3IycnI2Svvs3Nzc3NybKNKCUOJycOVa6vr6+qViyQqTUODiUlJSUOV6uvr6+vr69w + KIavYw4OJSUODg44nq+iNQ4OJScsl7LJzc3Nzb6vVw8PDw8PDjqrr6+vr6JWNo1jDw8PDw4PV6evr6+v + r6+vrWg1hYURDw8PDw46l6+vnCwPEA8PD2OvwM3Nzcm0mSgPDw8PEA81n6+vr6+vqm9VVxAPDxE4equv + r6+vr6+vr6+uhVZlNg8PEDVooq+vr40RDxAPDw81pLbLzc3Cr3APEBAQEBAQEZCvr6+vr6+vp411cG+N + p6+vr6+vr6+vr6+vr6+qkHlwb4Wirq+vr697EBAQEBAQEHuvxc3NuqtIDxAQEBAQEBBvr6+vr6+vr6+v + r6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vVw8QEBAQEBBIrb7NzbaVERAQEBAQEBAQVqyvr6+v + r6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vojQQEBANDQ0NHZm2y8Wsbw0NDRANEA0NEB2Z + r6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr4EQEA0NDQ0QEBCBs8fAsFkHCw0NCw0L + EA0LZa+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+un7Cvr6+vr61HBw0NDQ0LDQ0NZa/Cvq82DQsL + EAsHCwsHCzSer6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vch5Xqq+vr6+HEQsLCwsNDQsNDUSuvLSn + NA0LCwsLCwsLCwsLXa6vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr1cIHp6vr6+qRAsLCwsLCwsLCw00 + qbaylQwLCwsLCwsLDAsLCx6Jr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+SR3Kur6+vbwsLDAsLCwsL + DAsMHaS1sIcLCwsLCwsJCwsLDAkLb6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr66vr6+vkx0JCwsL + CwsMCwsLDB6Osq+BDAwMDAwMCQwMDAwMcK6vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vnkIJ + DAwMDAwMDAwMDAwMh7CveQwMDAwMDAwMDAwGWK2vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+v + nkEGDAwMDAwMDAwMDAwMDICur3kKCgoKCgoKCgoGIJyvr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+vr6+v + r6+vrn5ZQRoJDAoKCgoKCgoKCgqAr69+CgoKCgoKCgoKBW2vr6+vr5xxlq+vr6+vr6+vr6+vr6+vr6+v + r6+vr6+vr6+vr62TRQwFCgoKCgoKCgoKja+vjQoFBQoFBQoKChmWr6+vr4cgBiByqq+vr6+vr6+vr6+v + r6+vr6+vr6+ur6+vr6+vr5YhBQUKCgoKChIKGpWss5YaEgUFBRIFBQVCqK+vr5YiBQUFBUGAqK+vr6+v + r6+vr6+vr6+vr6ZxXa6vm2VxcVghCgUFBQUFEgUaEhmbtrSdIgUFBQoFBQUARa6vr69YBQUFBQUGEkJt + laivr6+vr6+vr66piF0hBSCmr6g+BQUFBQUFBQUFChIKBQo2q7a6qEIFEgUSBQUFAEuvr6+oPgUFBRIF + EgUFBRlCTWtzgIB+c11FIRoABQUSc6+vTQAFEgUSEgUSBQoKEhISRq+6xa9NGgoSChIFBQVBra+vqCEF + EgUSEgoSChISBgUFBQUKEgUFAAUFBQUSBSGar1gAChIKBQoFBRISGgoSAFivxsWvcxQSEhISEhIFIaav + r61GAxISEhIFEhISEhISBRISEhISEhISEhISEhIFQZZYABISEhISEhISEhIDEgNzs8vJtJQZEhISEhIS + EhKAr6+vcxISEhISEhISEhISEhISEhISEhISEhISEhISEgMiGwMSEhISEhISEhISEhIbo7TNzbqoQgMS + EhISEhISRqyvr6pLAwMSEhISEhISEhISEhISEhISEhISEhISEhISAwMSEhISEhISEhISEhMDRq++zc3F + r2sDAwMSEhIEBBNzr6+vp2wcAxISEhISEgQEAxIDBBIEEhISEgQEEgQSEhISEgQSAxMDEgMTAxIEA3yv + xc3NybaWGwMDBBISEwQBH4ivr6+vlkoTBBICEhISEhIEEhIEEgQEEgQSEgQSBAESEgQDEhMDEgQTAxIE + AyKntsvNzc2+r0oDAwMSEgMSAwMcfK2vr6+taxISEhISAhISEhISEgQSEhISBBISBBISEgQSBBISAwMT + AxIDEgNar8XNzc3NzLCIGAQEBAQEBAQEAxNLgqivr61KAwIEBAQDBAQEBAMEBAMEAgQEAwQEEgQEBAQE + AwQEAwQEBAQblK/Mzc3Nzc26r1oEEwQEBAQEAwQSARM8ka+viBUSAgQEBAQEBAMEBAQEBAQEAwQEBAEE + BAQEBAQEBAQEBAQEWq6+zc3Nzc3Nx7OaHBMEBAQEBAQEBAQEAUmur6YfBAQEBAQEBAQEBAQEBAQEBAQE + BAQEBAQEBAMEBAQEBAMDH5u0yc3Nzc3Nzc3Fr2sEBAQEBAQEBAQEBAFDra+mOwQCAhIEBAQEAgICAgIC + EwIEBAQEBAQEBAQEBAQEBAQCAnSvxc3Nzc3Nzc3NybSoQwECBAICAgICFxc8iK+vkhgTAgICAgICAgIC + AhUCAgICAgICAhMCAgQCBAICAgICAkmstsnNzc3Nzc3Nzc3FrJo7BAIEAgICWp2bpq+vrmwBAgICAgQC + AgICAgICAhUCAgICAgICAgICAgITAgIEAjydssXNzc3Nzc3Nzc3Nzb6ufxUCAgICFZGvr6+vr38WAgIC + EwICAgICAgICAgICAhMCExMCAgICAgICAgICAhyCr8DNzc3Nzc3Nzc3Nzc3Nvq98FQICAgJrrK+upmsX + AgICEwICAhMCAgICAgITAgICAgITAgICEwICAgICAhx8rrzNzc3Nzc3Nzc3Nzc3Nzcm6r3QVAgICFUBJ + STsCAgICAgICAgICAhMCAgICAgICAgICAgICAgICAgIVAh98r7rJzc3Nzc3Nzc3Nzc3Nzc3NybiudBcC + AgICAgICAgICAgICAhMCAgICAgICAgICAgIVAgICEwICAgICAhyDr7jNzc3Nzc3Nzc3Nzc3Nzc3Nzc3J + uq+DOwICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjyCr77Nzc3Nzc3Nzc3Nzc3Nzc3N + zc3Nzcu6r5pOAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICFUqdsL7Nzc3Nzc3Nzc3Nzc3N + zc3Nzc3Nzc3NzcKyqm49AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICPXysssXLzc3Nzc3Nzc3N + zc3Nzc3Nzc3Nzc3Nzc3NxbavtEwWAgICAgICAgICAgICAgICAgICAgICAgICAgIWW5uvtsXNzc3Nzc3N + zc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3LwLSvkkw9AgICAgICAgICAgICAgICAgICAgICAj1blK+0vs3Nzc3N + zc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Juq+upn1DFwICAgICAgICAgICAgICAgIXTn2br7O+yc3N + zc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3LxbKvrpp8TE47PRUCAgICAj07Q2x8mrCwtr7J + zc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Hyb62r6+uqJqRgoN/g5GarK+vsLa+ + xczNzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3NzcXCura1sK+vr6+ytba+ + wsXNzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3///8AAH//////+AAAD//////AAAAD/////wAAAAD////8 + AAAAAH////gAAAAAH///4AAAAAAH///AAAAAAAP//4AAAAAAAf//AAAAAAAA//4AAAAAAAD//AAAAAAA + AD/8AAAAAAAAP/gAAAAAAAAf8AAAAAAAAA/wAAAAAAAAD+AAAAAAAAAH4AAAAAAAAAfAAAAAAAAAA8AA + AAAAAAADgAAAAAAAAAGAAAAAAAAAAYAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAA + AAGAAAAAAAAAAYAAAAAAAAABwAAAAAAAAAPAAAAAAAAAA+AAAAAAAAAH4AAAAAAAAAfwAAAAAAAAD/AA + AAAAAAAP+AAAAAAAAB/8AAAAAAAAP/4AAAAAAAB//gAAAAAAAH//AAAAAAAB//+AAAAAAAP//8AAAAAA + B///8AAAAAAH///4AAAAAB////wAAAAAf////wAAAAD/////wAAAA//////wAAAP//////8AAP///ygA + AACAAAAAAAEAAAEACAAAAAAAAEAAACMuAAAjLgAAAAEAAAABAACJPxwAhzwmAIc9LQCJPiQAiD8qAI5F + FgCNRB0AlUwOAJhPDgCQRxkAlEwUAJFJGQCTSRIAn1YGAJ5VDQCaUhEAmlQYAIpBJACMQysAj0glAItD + MwCOSToAjUc4AJJMJQCRSyoAkU07AJJNNACVUS0Am1cmAJxdPACWVDcAoFcCAKRcAQCgWAgAqF8AAKJd + GwCjXhQAoV0gAKtkAACqZQsAr2gAAKpkCwCqZxcAs2sAALhvAACxbAsAsW8VALtzAAC6dQwAsnIbALh2 + FAClYyQAqWkoAKdqNwCuczsArnEwALN1JAC0eCkAtHk3AK9xKQCVVEUAllZJAJpbSACcX1EAnmJHAJ5j + VQClbEwAomZGAKRqUwCkbFwAoGZYAKxzSQCqc1QArHdcALJ6RwCxfVUAqXNkAK57YgCseW4AqHNnAK99 + cwCwfmgAqHJnAMB3AADCewgAwX8UALuDOgC/gSYAt4JLALyLXAC4hVYAs4NpALeIZwC0hnwAtol5AL2T + fAC9knUAv5BjAMSBGADIiiUAxIs0AM2VOgDQmD0AxJRXAMeTSQDFmWcAxJp4ANamWADToE0Ay6FtAMuk + eQDXrGgA3LV1ANSudgC4jIQAvZOJAL6VhADDnIMAwpuMAMKclADEn5gAyKSJAMajmwDLq50AyaaUANGu + hwDXtYgA1beXAM+wmwDLq6MAzKymAM6xqQDStaMA1bqsANe7qADVu7QA2L6xAOG/iADdwZwA3cSsAN7D + oADawrwA3sm9AN3GswDiwYsA48eaAOLJpgDizLMA4s66AOnVuQDo0a4A3srDAN3JxQDhzcMA4c7KAOXT + wwDk08wA69rFAOvcywDo18MA5dXSAOrd1ADq3doA59nTAPDfwgDu490A7uHUAPLjzADw4McA8ebcAPPq + 3QDx5dQA7uDNAO7k4QDz6+QA9O7qAPLo5AD38esA+fTuAPjx5QD38vAA+fXzAPv59gD///8A////AP// + /wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP// + /wD+/v4A/v7+AP///wD///8A////AP7+/gD///8A////AP///wD///8A+/v7AP///wD///8AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dTNycbGvr66uLi3t7e2tri6vsDCxsnN0dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dPPycK8vri1t7e3t7e3t7e3t7e3t7e3 + t7e3tri8wMPJz9XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXT0cvGvLi3t7e3t7e3t7e3t7e3 + t7a2t7e3t7e3t7e3t7e3t7e6vMbL0dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXRyca6t7e3t7e3t7a2 + s6eVkZBwb2tra2tra29wkJKVq7O2t7e3t7e3t7e8wsnR1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dPNxry3t7e3 + t7e2s5WQb2ZjYlRTU1NTU1NTU1NTU1NTU1RiY2xvkaSztre3t7e3trzGzdXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dPJ + wLi3t7e3t7KokGxjVFNTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTVGNrkKe2t7a3t7e6xsvV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dPJvre3t7e3tZVwZVRTLy9TU1NTL1NTU1MvU1NTL1MvUy9TL1NTU1MvU1NTUy8vYmaJqLK3t7e3 + tr7L09XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dPJvLe3t7e3qpBmVC8vLy8vL1NTLy8vU1MvUy9TLy8vUy9TL1MvU1MvLy9TLy8vUy8v + Ly9ibJGzt7e3t7a+y9PV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXNwLa3t7e2nW9jLCwvLy8vLy8vLy8vLy8vLy8vL1MvLy8vLy8vUy9TLC8v + Ly8vLy8vLy8vLy8sL2Nwp7e3t7e4ws/V1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dPUxra3t7e2lWtVLy8sLy8vLy8sLy8vLCwvLy8vLy8sLy8vLy8v + LywvLC8vLy8vLy8sLy8vLy8vLy8vLyxVb563t7e3uMbT1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXTyby3t7e3qGswLCwvLy8vLy8vLy8vLy8vLC8vLy8v + Ly8vLy8vLy8vLy8vLywvLy8sLy8vLywvLy8vLy8vLy8sVW+rt7e3t77L1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV0cK5t7e3qnAyLysvLy8vLywsLywsLC8v + LC8sLywsLy8sLy8vLywsLCwsLywsLCwsLywvLC8sLC8sLCwsLywvLy8rL2J+s7e3t7jG0dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1cu8t7e3tZFjLCwvLCwvLy8s + Ly8sLCwsLC8sLCwsLCwsLywsLC8sKywsLCwsLCwsLCwsLC8sLC8sLCwsLywvLy8sLy8vKy9llra3t7e+ + zdXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dPJuLe3t6trLCsr + KysvKysrKyssKyssLCwvKyssLCwsKy8rKywvKyssLCwsLCwsLCwsKywrLCsvKyssLCssKysrKyssKysr + LCswb6q3t7e6ydXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXVwre3 + t7aSVysrKysvKysvKysvKysvKyssLCsvKyssKywrKy8rKysvKysrKysrKyssLCwsLCssKyssKysvKysv + KysvKysvLCsvKysrZJa2t7e3xtPV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV0b63t7ezbzArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr + KysrKysrKysrKysrKysrKysrKysrMn61t7e3wtHV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1c++t7e3p2goKygrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysoKysrKysr + KysrKysrKysrKygrKygrKCsrKysrKysrKysrKysrK2eqt7e3wtTV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXNvLe3t5U5KCsrKysrKCsoKysrKCsoKysrKysrKysoKygrKysoKysrKCsr + KysrKygrKCsrKygrKCsrKysoKysrKysrKysoKygrKysrKysoKygrK2Sot7e3vs/V1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXVzbq3t7aSMigoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgo + KCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCsrKCgoKCgoKzmWt7e3vs/V1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV0826t7e2fzAmKCgoKCgoKCgoKCgoKCgoKCgoKCgo + KCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKDKS + t7e3vM/V1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXTvLe3tn4tKCgmJigoKCgoKCIoKCgo + JigoKCgoJigoKCgmKCYoKCYoJigoKCYoJigoJigmJigmKCYoJigoJigmJigmKCgoKCgmKCYoKCYoJigm + KCYoKCgoJi6Kt7e3vtHV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXVzb63t7Z+LSgoKCgoKCYo + KCgoKCgoKCgoJigoKCYoJigmJigoKCgmKCgoJigoKCYoJigoJigoKCgoKCYoKCgoJigoJigoJigoKCgm + KCgoKCYoJigoKCgmKCgoKC6Rt7e3vtHV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dS+t7e3fi0m + JigmJiYmJiYmJigiKCYmKCgiJiYmJigmJiYmJiYmJiYmJiYmJigmJiYmJigmJiYmJiYmJiYmJigmJiYm + JiYmJiYmJiYmJiYoJiYmJiYmJiYoJiYmKC6St7e3wtPV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + wLe3t4otJiYmJiYmJiYmJiYmIiYmIiYmIiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYm + JiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYiJiYmJiYmIjGWt7e3xtXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1ca3t7eTLiYmJiYmJiYmJiYmJiYiJigmIigoIiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYm + JiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJjidt7e4ydXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXLuLe3njkmJiYiJiImIiIiJiIgJiYiIiIiIiIiJiImJiYmIiImIiImJiImIiIm + IiYmJiYiIiImIiIiIiImIiYmIiYiIiIiJiYiIiYiJiImJiImIiYmIiImJiImIiImIiYmIlaqt7e609XV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV0b63t7NWIiImJiYiJi4xMTExMS4mJiIpMTExMTExMSkiIiYmIiYm + IiImIiYmIiImIiIiJi4xMTExMTExJyYiJi4xMTExMTEuJiYiJiImIiImIiImJiYmIiImIiYmIiImJiYm + IGeyt7e809XV1dXV1dXV1dXV1dXV1dXV1dXV1dPAt7e2bSImIiIiIiAxn66qqaqqlS0iIjmnqqqqqqqd + OCIiIiIiIiIiIiYgJiAiIiIiIiIun6qqqqqqqqppIiIpkrCpqaqqqpInIiIiIiYgJiIiIiIiIiIiIiYi + IiIiIiIiIiImJn22t7fD1dXV1dXV1dXV1dXV1dXV1dXV1dXVybe3t38pIiIiIiIgIFa0t7e3t7eqMSAg + ObO3t7e3t58nIiAiIiIiIiIiJiIiIiIiIiIiIjmzt7e3t7e3t34iIimVt7e3t7e3fiAiIiAiIiIgIiIi + IiIgJiYgIiImIiAiIiAiIiYiLZO3t7jL1dXV1dXV1dXV1dXV1dXV1dXV1c+6t7eeOCAgICIiICAgaLa3 + t7e3t7E6ICAuq7e3t7e3fyAiICIiICIgIiAgICIiICAiIiIgOrW3t7e3t7e3iiIgIIq3t7e3t7dnICIi + ICIiIiAiIiIgIiYgICAgICAnOCkgICIgICAiOqq3t7zR1dXV1dXV1dXV1dXV1dXV1dXVwre3tGggICAg + ICAgICBpt7e3t7e3tmcgICKTt7e3t7dtICAgICIgICAgICAgICAgICAgICBpt7e3t7e3t7efJyIgbre3 + t7e3tVYgICAgICAgICAgIiAgICAgICAgJ4qzfikgICAgICIgaba3t8bV1dXV1dXV1dXV1dXV1dXV1cu2 + t7d/JiAgIiAiICAiIG23t7e3t7e3fiAgIHG3t7e3t2cfICAgICAgIiAgIiAiICAiICIgIIq3t7e3t7e3 + t7M5ICBYtbe3t7ezOSAgIiAgICIgICAgICAgICAgICA5sreuMR8gICAgICApkre3us3V1dXV1dXV1dXV + 1dXV1dXVvre3qzENDSYgICAgIB8fcbe3t7e3t7edKiAfVrS3t7e2Zx8gICAgICAgICAgICAgICAgICAq + q7e3t7e3t7e3t2kgHyqst7e3t644Hx8gICAmDSYNJiAgICAgICAgH223t644ICAgICAgICBWs7e3wNPV + 1dXV1dXV1dXV1dXV1cm2t7ZpDSAgICAgIB8gIB99t7e3t7e3t7VnHx8plbe3t7ZnDSAgICAgIA0NICAN + ICAfDSAgH2e2t7e3t7e3t7e3lSofH263t7e3szkfIB8gIA0NICAgDSAgIA0gIB8pn7e3sTgNICANICAg + ICB9t7e4ydXV1dXV1dXV1dXV1dXRvLe2lSoNDSANDSAgICAfH323t7e3t7e3t5MpHx9ntre3t20NHyEg + ICAfICAgICAgICAgICAqn7e3t7e3t7e3t7e2Zx8fO6m3t7e0Oh8gICAgKQ0NDQ0gDQ0gICAfIGG1t7ev + OQ0gIB8NISEgIDumt7e+09XV1dXV1dXV1dXV1ca3t7ZaDSkNKQ0NIA0NICAffbe3t7e3t7e3tmkNHyGS + t7e2fw0hISEhIQ0hIQ0NDQ0NIQ0hDW23t7e3t7e3t7e3t7edKiAgbre3t7dnDSAhDQ0pDSANIA0gDQ0g + IQ0qnre3t647DSENIA0hISEhH2m2t7fR1dXV1dXV1dXV1dXUvLe3kykNISENDQ4NDQ4NIQ1ut7e3t7e3 + t7e3qTcNDTapt7efJA0hISEhISENDSEhISENDQ06sLe3t7e3t7e3t7e3t7d+IQ0qk7e3t30NISENDSEh + ISEhISENDQ0NIX63t7e3rjQNISEhISEhISENKp63t8DT1dXV1dXV1dXV1c23t7VaDQ0hDg4ODg0NDiQO + DW23t7e3t7e3t7e3lTMNDVmzt7E6DQ4NDQ4ODQ4NDg4hDg0NNJ23t7e3t7e3t7e3t7e3t7RpDQ03nre3 + nSoODg4OIQ4kDg4hDQ0NDg1ptLe3t7emKg0NDg0OISEODiENabe3tsvV1dXV1dXV1dXTvre3lCQODg4O + Dg4ODg4ODg4NWba3t7e3t7e3t7e3izMNDmmxt24NDg4ODg4ODg4kDg4ODTSUt7e3t7e3t7e3t7e3t7e3 + t7FpDg1Kobe1WA0ODg4ODg4ODg4ODg4OabW3t7e3t50qDg4ODg4ODg4OIQ0zobe3wNXV1dXV1dXV1cu2 + t7ZhDg8ODg4ODg4ODg4ODg5YtLe3t7e3t7e3t7e3lDYODlmpoTMODg8ODg4ODg4ODg5Kn7e3t7e3t7e3 + t7e3t7e3t7e3t7FuEA02lLeGDg4ODg4ODg4ODiQOEG64t7e3t7e3jw4PDw4ODg4ODg4PDw5ut7e4z9XV + 1dXV1dXVwre3njMODg4ODg8ODg4ODg4OCDSut7e3t7e3t7e3t7e3pWkjCDaLag4PDg8OEA4PDggqbqq3 + t7e3t7e3t7e3t7e3t7e3t7e3t7aLNg4zfqlYDg4PDg4ODg4ODjaLtre3t7e3t7d/Dg4ODg4ODyEhECEQ + DzWwt7fG1dXV1dXV1c+6t7d5Dg8PDg4PDg8QDhAPDg4PJZ63t7e3t7e3t7e3t7e3tpRZKiQ2EA4ODw4O + CA4zYZu2t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7eufTYQSlkPDw4ICA4IEDZ/rre3t7e3t7e3t2oIDxAO + EA4PDw8PIQ8hJH+3t7zV1dXV1dXVybe3rzYODg4QDg8PDw8ODhAQCA4Qhre3t7e3t7e3t7e3t7e3t7ah + f1k2NDMzNDZhgKa2t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3sZNqWDUzMzQ3WG6Pube3t7e3t7e3 + t7e1WA4PDhAODg8PECEQIQ8IWLa3t8vV1dXV1dO+t7eSEA8QDw8PDw8PDw8PDg8PDg5ut7e3t7e3t7e3 + t7e3t7e3t7e3trGupaWuuLe3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e1r6mlpbG2t7e3 + t7e3t7e3t7e3t6k0Dw8QDhAPDw8PDw8PDw8lnre3wtXV1dXVz7i3t2kODw8PDw8PDw8PDw8PDw8PCEq1 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3jhAPDw8PDw8PDw8PDw8PDwh5t7e80dXV1dXJt7euNQgPDw8PDw8ODw8P + Dw8PDw8IJaa3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7duDw8PDw8PDw8PDw8PDw8PCEq1t7bL1dXV1cC3t48QDw8P + Dw8PDwoPDw8IDw8IDw8PhLe3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3skoHDw8IDw8PDw8PDw8PDw8IJZ63t8PV1dXR + ure3agcPCA8KDwoPCg4PDwoPDwoPDwdatre3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7ebEAgPDwoPDw8IDwoICAgPDw8K + gLe3vtPV1cu2t7JKBw8PDw8PDw8KDw8PDw8PDw8PCjOmt7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t3kIDw8IDwoPDw8P + Dw8KDw8PDwhht7e4z9XVxre3phwKDwoKCgoPCgoPDwoKCgoKDwoKCnm3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7euNQoK + CAoPCg8KCgoPCggKCAoKCjWut7fJ1dXCt7eLCgoPDwgOCggPCgoHDgoODwoKDw8HR6+3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t4YPDw8KDwoPDwoPDwgPCg8PCggPEJu3t8bV0b63t2oHCgoKCgoKCgoOCgoKCgoICg8KCg8KjLe3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7amlK23 + t7e3t7e3t7e3t7e0SwcICgoICg8KCgoKCgoKDwoKDwoKgLe3wNXPure2WgcICgoKCAcPCgoICAoICggK + CAoKDwdHsre3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e1eRwQNYu3t7e3t7e3t7e3t48QBwgKCAoKCAgKCAgKCAoICggKCgdqt7e+0cm3t7E1DAoKCAoKCgoK + BwoKCgcKCgoKDwoKCgqEt7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t48KCgoHNaW3t7e3t7e3t7eySwcKCgoPCgoKCgoKCgoKCggKCgoMDEq3t7vNxre3oRwK + CgoPCgoKCgoKCgoKCgoPCgoKDwoKCkevt7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3bgwKCgoKjre3t7e3t7e3t4YKCgoKCgoKCAoKCgoKDwoKCggKCgoMNbC3 + tsnCt7eUEAoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCnm3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7eADAoKChyjt7e3t7e3t7ewNQwKCgoKCgoKCgoKCgoKCgoK + CgoKCgwcobe3xr63t38KDAoKCgoMCgoKCgoKCgwKCgwKCgwKCgoKHJy3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7BHDAcKara3t7e3t7e3tmoMCgwKCgoLCwoK + CgoMCgoKCgoKCwoKCgqUt7fCvLe3eQwKCgwLCgoKCgoKCgsKCgoKCgsKCgsKCgoMS7G3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t6qAX4a1t7e3t7e3t7ePHAsK + CgoLCgoKCgoKCgoKCgsKCgoKCgoKCoa3t764t7dgDAoLDAwMCwwLCgwKDAwLDAsKDAoMCwwMCgwLhre3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3pTUMDAsMDAwLDAsKCgoKCgwKCgoKDAsKCgoLfLe3vLe3t1wMBQsLDAsLDAsLDAsMCwsMCwsMCwsL + DAsLCmCut7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7hbDAsMDAsLCwsMCwoFCgsMCwULCgULCwoFBQx1t7e6t7e2SwULCwsLCwsMCwsLCwsL + CwwLCwsLCwsLCwp1tLe3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e2eQsMCwsMCwsLCwwLCwsLCwwLCwsLBQwLCgsLDF+3t7i3t7ZLBQsLCwsL + CwsLCwsLCwsLCwsLCwsLCwsLX7W3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t4ALCwsLCwsLCwsLCwsKCwsLCwsLCwsLCwsLCwsMXLe3uLe3 + tUIFCwsLCwsLCwsLCwsLCwsLCwsLCwsJBVqxt7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7eGFwsLCwsLCwsLCwsKCwsLCwsLCwsLCwsKCwsL + CQVctre3t7e0RwwFCwsLBQsLCwULCwsFCwsLBQsLCQU1ore3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3hhsFCwsLCwsLCwUFCwUJCQkFCwsF + CwsFCwUJCQkJBVu3t7e3t7RCBQkJCQkJCQkJCQkJCwsJCQsLCQkLCYS3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3toQbCwsFBQkJCwkJCwsL + CwkJCwkJCQkJCwsLCwkJCQUFW7e3t7e3tEgFBgkJCQkJBgYJCQYJCQkGBgkJCQVJtLe3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e0mY6PhF9C + FwUJBgsFBQYGBQsJBgsJCQkGBgkJBgUJBQVbt7e3t7e2SAUJBgkGCQkJCQkJCQYJCQkJCQYJCYi3t7e3 + t7e3t7e3t7elmbW3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7SZXBcFBQkGCwsGBgYJBQkJCQYGBQUJCQUFBVy3t7a3t7ZLBQkJCQkJBgkJBgYJCwkFBgYJ + CQVCsbe3t7e3t7e3t7exfB0Xda+3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3jUIJCwsFBgsJCQkGCQYJCQkGCwYJBgUFX7e3uLe3t1sFBgYGCQkGBgYG + CQYGBgYGBgYGBXa3t7e3t7e3t7e3okkGBQUGQpe3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3rkkGBgkGBgYGBgkGCRMJBgYGBgYGBgV1t7e6uLe3XwUG + BhMGBgYJCRMGBgYGBgYGBgYYm7e3t7e3t7e3t6BDBQYGBgYFG2qlt7e3t7e3t7e3t7e3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3tbW3t7e3t7e3t7e3t7e3t7WOSAYGCQYGBgkGBgYGBgYGCQYJBgYGBXy3 + t7y6t7d5BgYGBgkGBgYGBgYGBgYGBgkGBkOvt7e3t7e3t7etQgUJBgYGBgYGBh18sLe3t7e3t7e3t7e3 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3tpxbhbe3t7e3hYWir7GvpZd8RBcFBgYGBgYTCQkGBhMJBgYG + BhMGBgYGhbe3vr63t4QGBgYRBgYTBgYGBgYGBgYGBgYGTba3t7e3t7e3tmAFERMGBhMGBgYGBgZDfKW2 + t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3tZdbGwVft7e3t7eEExsdQ0AeFwYGBgYGEwYGBgYG + EwYGBgYGBgYGBgYGExeNt7fCwre3jRMGEQYGBgYGEQYTBgYGBgYGBgZft7e3t7e3t7ecGAYGBgYGBgYG + BgYRBgYGHV6Xsbe3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e2pYJIGAYGBkK0t7e3t7AdBgYABgYRBgYG + BgYGBhEGBgYGBgYGCQYGBgYGEQYGG6O3t8bGt7ejGwYGBhMGBgYGBgYGBgYGBgYGBna3t7e3t7e3t3UG + BgYRBgYGEQYGBgYGBgYGABdCdI6ttre3t7e3t7e3t7e3t7e3t7e3t7SihFseBgYGBgYGGJu3t7e3tk0G + BgYGBgYGBgYRBgYGBgYGBhEGBgYREQYRBgYGBgYdrre3ycm2t69ABgYGEQYRBgYRBgYREQYREQYGfLe3 + t7e3t7e1SAYREQYGBhERBhEGBhEGBhERBgYAER1NdoWcpbG1tre3tra1tK+ijnteRBsGAAYGEQYRBgYG + Xre3t7e3fAYGBhEGBgYGEQYREQYGBgYRBhEGBhEGBgYGEQYGBki2t7jNz7q3tkkABgYGBgYGBgYGEQYG + BgYGBgB2t7e3t7e3t68+BgYGBhEGBgYGBgYGBgYRBgYGBgYRBgYGERgeQERJTVFRTUlCHRsRBgYGBgYG + EQYGBgYGEQYbnLe3t7eFEwYGBgYGEQYRBgYGBgYRBhEGBgYRBgYGEQYRBhEGXre3vNHTvLe3dAAGBgYR + BhEGBgYGBgYGBgYRAF+3t7e3t7e3rx0AEREGBhEGBgYREQYGBgYGBgYGBhEGBgYRBgYGBgAAAAAAAAYG + BhMGEQYRBgYGEQYGEREGBgBNuLe3t44REREGBgYRBgYGEQYGBhEGBgYRCREJEREGBgYGBgZ7t7e+09XA + t7eFEREREREGEREREREREREREREATba3t7e3t7exQwAREREREQYREQYRAxEREREREREGEQYDEREGEREG + EQYREREJEQYREQYRBhERAxEGAxEGERERERF2tre3jREGEQYREREGERERBhEREQYREREREQkREQYRERER + GJm3t8bV1ca3t6IbBhERBhEGBgYGEQYRBhEGEQBAr7e3t7e3t7ZNABEGBhEGEREGEQYGBgYRBhEGEQYR + EQYRBhEGBgYGERERAwkGEQYREQYRBhEGBgYRBhEGBgYRBhF8treFExEGBhEGBgYRBgYGEQYGBhEGBhER + EREGEQYREQY+r7e3ydXVy7a3tEQGERERBhEREREREQYRERERBhict7e3t7e3t3wGEQYREREGEREGERER + ERERBhEREREGERERBhERERERERMDEQMREREGERERBhERERERBhEREREGERh0sXsGERERERERERERERER + ERERERERERERCREREREGAFG2t7rR1dXRure3dQMREREREREREREREREREREDA3y3t7e3t7e3nBoREQMT + EREREREREREREREREREREREREREREREREREDExERERERERMDAwMTAxMRERERERERERERERFFRBERERER + ERERERERERERERERERERERERERERERERgbe3vNPV1dXAt7eIEhEREREREREREREREREREREDRK+3t7e3 + t7e2XgMRERERERERERERERERERERERERERERERERERERERERERERERERAwMTAxMDAwMRERERERERERER + ERERERERERERERERERERERERERERERERERERERERERqjt7fG1dXV1cm3t7A+AxERAxERERERERERERER + ERERhbe3t7e3t7eiPhEDEhERERERERERERERERIDERERERERERIREREREREDEREREREREREREQMSERER + AxEREREREREREREREREREQQSERERERERAxIDEhEREREREhERERERRLS3t8vV1dXVzbi3t14AERESERES + EREREREREREREQNEr7e3t7e3t7eNHgMREREREREREREREREREREDEhERERERERERERERERIRERIDERES + AxERERERERESERESAxERERERERERERERERERERIDERERERERERERERERERERERF3t7e40dXV1dXVvre3 + hwQEEREEAxIDEQQRAwQSAxIDERF6t7e3t7e3t7eZRAQDAxERBAQEEREDEgMRAwMRAxIDERIDEQMDBBES + EgMRAxEDAwMSAwMRAxEDEQMSEQMRAxERAxEDERESEQISAhIDEQMREQMRAxIDAwMRAxIRAwMDGpy3t8DV + 1dXV1dXJt7evPgMDERERAwMREQMSAwMRAxEEBBqXt7e3t7e3t7ewdjwDARESEREEBBEDEQMSERIDAwMR + AxEDEhERAwMDEQMSAxIREgMSERIDEhESAwMDEgMSAxIEEhERAwMRERERAxEDEgQRAxESAwMSAxEDERER + EgNJtbe20dXV1dXV1c+6t7d2BBERBBEEEQQDEhEEEQQSBBERA0Cjt7e3t7e3t7e3onYeAREEEQQRBBID + AxIEAwMSEQQEBBEEEQQRBBEEEQQRBAMDBAMEAxIDBBEDEhEEEQQEBAQRBBERBBECEQISBBIEEQQRBAMS + EQQEEQMSAxIDA4G3t77T1dXV1dXV1cK3t5waBAQRBBEEERIDBBEEEQMEBBEEBESit7e3t7e3t7e3t5xM + BBEEEQQRAxIDBAQSBBEEEQQSBBEEERIDBBEEEQQREgMSEgMSAwQRBBIDBBEEEREEEQQRBAQREREREQQD + EQQEEQQRBBEEEQQSBAQEBAM+rbe3w9XV1dXV1dXVy7e3tlsEERERBBERBBERAxIRBBESAwMSBESat7e3 + t7e3t7e3t69eEhEREREDEgMEEhIRBBIDAxISBBIEEQMSEQMSAxIDEhESBBIDEQMSBBIDEgMSEQQDEgQR + EQQREREREREREQQSAxIDEhEEAxIDEgMDA3a3t7jP1dXV1dXV1dXTvLe3jRQEBAMEBAQEAwQEAwQEAwME + BAQDAxl7tLe3t7e3t7e3t7VyAgISAQQEBAQDAwQEAwQEBAMEAwQEBAQDBAQDBAMEAwMDBAQEBAQDBAQE + AwQDBAQDBAMEBBIBAgIRAhECBAQEBAQDBAQDBAQEAwQZo7e3wNXV1dXV1dXV1dXJt7e1TAMEEQIEBAQE + AwQEBAQEAwQEAwQDBARMjbS3t7e3t7e3t69SAQESBAMEAwMDBAQDBAQDBAMDBAQEBAQDBAQEBAMEBAQD + BAMEBAQDAwQEBAMEAwQEBAMEAhECEQERAhEDAwMEBAMDBAMDBAQEA163t7fL1dXV1dXV1dXV1dG8t7eI + EgQCEQQEAwQEBAQDAwQDBAQDAwMEBAESRYGitre3t7e3t5gVAhEEAwQDAwQEAwMEBAMDAwMDAwMDEgQE + AwMEBAQDBAMEBAMDAwMEBAMDBAMSBAMEBAQRAhECEQIRAgMDBAQDBAMDBAQDAwQanLe3vtPV1dXV1dXV + 1dXV1cm3t7VOARESAhEEAwQDAwMEBAQDBAMEAwQDBAQDAxlbore3t7e3tlsBEQMEBBIDAwMDBBIDAwQE + AwMEAwMEBAMEBAMEBAMEAwMEBAMEEgMDBAQEAwQEAwQEAxECEQICAhEBBAMEAwMEAwQDBAMEAV23t7fJ + 1dXV1dXV1dXV1dXV0by3t5cWAQIRAgQEBAQEEgQEBAQEBAQEBAQEBAQEBAFGsLe3t7e3hxIRBAQEBAQE + BAQEBAQEBAQEBAQEBAQEBAQEBAMEBAQEBAQEBAQEBAQEBAQEBAQDBAQEAhECEQQRBAQEBAQEBAQEBAQE + BAMZo7e3vtPV1dXV1dXV1dXV1dXVybe3tl4BEQIRBAQEBAQEBAQEBAQEBAQEBAQEBAMCEgF6t7e3t7ej + FQEEBAQEBAMEBAQEBAQDBAQEBAQEBAMEBAQEBAMEBAQEBAQDBAQDBAQEAwQEBAQEBAQRAhECBAQEBAQE + BAQEBAQEBAQEAne3t7nJ1dXV1dXV1dXV1dXV1dXRvLe3ojwBEQIDBAQEAwQDBAQEAwQDBAQEAwQEBAIR + AU+2t7e3t7A8AgQEAwQEBAQEBAQEBAQEBAMEAwQEBAQEAwQEBAQEAwQEBAQEBAQEBAMEBAQDBAQDBBER + AhEEBAQEAwQEBAMEAwQEBAREsLe3wNXV1dXV1dXV1dXV1dXV1dXLuLe3exIBAgICAhECEQERAgEBBAQE + BAQBAhICEQIBUra3t7e3rjwBAgEBBAQEBAQCBAQEBAQEBAICAgICAgICAgICAgQEBAQCBAQEBAQEBAQE + BAQEBAQEAgEEBAQEBAQEBAQEBAQEBAQEFIe3t7jN1dXV1dXV1dXV1dXV1dXV1dXCt7e0TwEREQICAgIR + AgICAgQEAQQEBAIBAgICAgFzt7e3t7eiGQECAgQEBAQEBAQCBAQEBAQEAgICAgICAgIRAhECBAQEBAQC + BAQSBAQEEgQEBBIEBAQCAgQBBAQEBAQEBAQEBAQEBARdtre3w9XV1dXV1dXV1dXV1dXV1dXV1c+6t7ec + PAICAgIRAgICAgICAgIEAgICEgICAgICPqK3t7e3t40SAgICAgICAgIEAgQCBAICAgICAgICAgICAgIC + AhIEBAIEAgQCAgIEAgICAgICAgICBAICBAICBAICAgQCAgICAgIEP623t7zR1dXV1dXV1dXV1dXV1dXV + 1dXV1cm3t7eBFAICAgICEgICAgICAgICBAQUGRQSFEWat7e3t7e3cwICAgICAgQEAgIEAgQCAgQEAgIC + AgICAgICEQICAgIEBAIEAgICBAIEAgICBAICBAQCAgICAgICAgQEAgICAgQCBBaHt7e4y9XV1dXV1dXV + 1dXV1dXV1dXV1dXV08C3t7ZeAhICAgICBAQEAgICAgQETI2il4eYsbe3t7e3t7A+AgICAgICAgIEBAIC + AgQCEgICAgICAgICAgICAgISAgQCAgICAgICEgICFAIEAgICBAICBAQCBAQCAgQCBAICAgIEd7e3t8bV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXVz7i3t69BAgISAhIEAhICBAQEBEG5t7e3t7e3t7e3t7e3eAICAgIC + EgICBAQEAgICAgIEBAICAhQCAgICAgICAgICBAIEBAIUAgQCAgQCBAIEBAICEgQCAgIEBBICAgQCBAIE + BE60t7e+09XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV0bi3t5w8AgICAhICAgICAgICc7e3t7e3t7e3t7e3 + t5gVAgICAhQCAgICFAICAgISAgICAgICAgICAgIUAgICAgICAgICAgICAgICAgICBAICAgICBBQCAgQC + AgIEAgQCAgRGrbe3us3V1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXVxre3t40VAgICAgICAgICFAJ6t7e3 + t7e3t7e3t7ecPgIRAgICAhQEBAICAgICAgQCAgISAgICAgICAgICAhQCAgICAgICAgICAgICAgQCBAIC + AgICAgICFAICAgIEAgICPZq3t7fJ1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXTwre3t4MWAgICAgIC + AgICAk62t7e3t7e3t7e4hz0CAgICAgIUAgIUAgICFAICAhICAgICAgICAgICFAIUAgICEgICAgICAgIC + AhQUAgQCBAICAgIUAgICEQICAgICAjyHt7e3w9XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXRvre3 + tnoUAgICBAQCAgICFHivt7e3t7e0mF0WAgICAgICAgICAgICAgICAgIUAgICAgICAgICAgICAgICAgIC + EgICAgICAgICAgICAgQCAgICAgICAgICAgICAgIVg7e3t8DT1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXPvLe3tngUAgIUAgICAgICFEFdc4F6XUEUAgICAgIUAgICAgIUAgICAgICAgICAgICAgICAgIC + AgICAgICAhICAgICAgICAgICAgIEAgICAgICAgIUAhICFAICFYO3t7e+0dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXNure3tngUBAICAhQCAgICBAEBAgICAgICAgICAgICAhQCAgICEgICAhQCAgIU + AgICAgICAgIUAhQCAgICAgICAgICAgICFAICBAIUAgICAhQCAgICAgICAhWDt7e3vtHV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXNure3tnoUAgICAgICAgIUAgICAgICAgIUAgICAgICAgICAgIC + FAICAgICAgIUAgICAgICFAICAgICFAICAgICAhQCAhQCAgICAgICAgICAgICAgICAgQVhbe3t7zP1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXLure3toM8AgICAgICAgICAgICAgICAgICAhQC + AgICAgICAgICAgICAgICAgQCAhQCAgICAgICAgIEAgICAgICAgICAgICAgICAgICAgICAgICAgICPI23 + t7e8z9XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXNvLe3t409AgICAgICAgICAgIC + AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAhQCAgIC + AgICAkGYt7e3vs/V1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXTure3t6NFAgIC + AgICAgICAgICAgICAgICFAICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC + AgICAgICAgICAgJOure3t77P1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXP + vre3t69yAgICAgICAgICAgICAgICAgICAgICAgICFAICAgICAgICAgICFAICAgICFAICAgICAgIUAgIC + AgICAgICAgICAgICAgICAgIWd7G3t7fA0dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXRwre3t7aDPAICAgICAgICAgICAgICAgICAgICAgICAgIUAgICFAICAgICAgIUAgICAgIU + AgICAgICAgICAgICAgICAgICAgICAgICP4e3t7e4xtPV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXVxri3t7eiThQCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC + AgICAgICAgICAgICAgICAhQCAgICAgICAgIUAgICFl2tt7e3usnV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXVzb63t7e1gz8CAgIUAgICAgICAgICAgICAgICAgICAgIC + AgICFAICAgICAgICAgICAgICAgICFAICAgICAgICAgICAgICAkGHtre3t77N1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV0cK3t7e3unIVAgICAgICAgICFAICAgIC + AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIUAgICAgICAgICAjxzube3t7jG0dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV08m8t7e4uLxQFgICAgIC + AgICAgICAgICAgICAhQCAgIUAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICARVyo7e3t7e8y9PV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dHCtre3 + t7eYUBYCAgICAgICAgICAgICAgICAgICAgICAgICAgIUAgICAgICAgICAgICAhQCAgICAgICAjxdoLe3 + t7e4w9HV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXLxLe3t7e2ml09AgICAhQCAgICAgICAgICAhQCAgICAhQCAgICAgICFAICAgICAgICAgICAgIC + Aj1yoLa3t7e3xs3V1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXRyby3t7e3t6J6RhYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC + AgICAgICFlKCure3t7e3vsnT1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1cm+t7e3t7e0mHM/FAICAgICAgICAgICAgICAgICAgICAgIC + AgICAgICAgICAgIWQXectba2t7e2vsnV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dPJvri3t7e3t6+Yd1I9AgICAQICAgICAgIC + AgICAgICAgICAgICAgICFDxOepq0t7e3t7e4wM3T1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXVzcK6t7e3t7e3tq2YeF1B + PBYWAgICAgICAgICAgICAgICFj1GXYGYsLe3t7e3t7e+xs3V1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dHJwLq3 + t7e3t7e3t7WwoL6CeHJdUE5PT05QXXN4go2ir7W3t7e3t7e3t77AydHV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXT0cnCvLa3t7e3t7e3tbW4uLe3t7a2t7e3t7e3t7e3t7e3t7e3vMbJ0dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXTzcnCvrq4t7e2tbe3t7e3t7e3t7e3t7e3t7e4ur7Gzc3T1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXT0c3Jxsa/ubm3t7e3t7e3uLq+vsDGzc3R1dXV1dXV + 1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1f////////AAAA////// + //////////4AAAAA///////////////gAAAAAA//////////////gAAAAAAB/////////////AAAAAAA + AH////////////AAAAAAAAAf///////////AAAAAAAAAA///////////AAAAAAAAAAD//////////gAA + AAAAAAAAf/////////AAAAAAAAAAAB/////////gAAAAAAAAAAAP////////wAAAAAAAAAAAA/////// + /4AAAAAAAAAAAAH///////4AAAAAAAAAAAAA///////+AAAAAAAAAAAAAD//////+AAAAAAAAAAAAAAf + //////AAAAAAAAAAAAAAD//////gAAAAAAAAAAAAAAf/////wAAAAAAAAAAAAAAD/////wAAAAAAAAAA + AAAAAf////8AAAAAAAAAAAAAAAD////+AAAAAAAAAAAAAAAAf////AAAAAAAAAAAAAAAAD////wAAAAA + AAAAAAAAAAA////4AAAAAAAAAAAAAAAAH///8AAAAAAAAAAAAAAAAA///+AAAAAAAAAAAAAAAAAH///A + AAAAAAAAAAAAAAAAB///wAAAAAAAAAAAAAAAAAP//4AAAAAAAAAAAAAAAAAB//+AAAAAAAAAAAAAAAAA + Af//AAAAAAAAAAAAAAAAAAD//wAAAAAAAAAAAAAAAAAAf/4AAAAAAAAAAAAAAAAAAH/8AAAAAAAAAAAA + AAAAAAA//AAAAAAAAAAAAAAAAAAAP/gAAAAAAAAAAAAAAAAAAB/4AAAAAAAAAAAAAAAAAAAf8AAAAAAA + AAAAAAAAAAAAH/AAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAP4AAAAAAAAAAAAAAAAAAAD+AA + AAAAAAAAAAAAAAAAAAfAAAAAAAAAAAAAAAAAAAAHwAAAAAAAAAAAAAAAAAAAA8AAAAAAAAAAAAAAAAAA + AAPAAAAAAAAAAAAAAAAAAAADgAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAA + AAAAAAABgAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAA + AAAAAAABgAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAAAAPAAAAAAAAAAAAAAAAAAAADwAAAAAAA + AAAAAAAAAAAAA+AAAAAAAAAAAAAAAAAAAAfgAAAAAAAAAAAAAAAAAAAH4AAAAAAAAAAAAAAAAAAAB/AA + AAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAH/gAAAAAAAAAAAAAAAAA + AB/4AAAAAAAAAAAAAAAAAAAf/AAAAAAAAAAAAAAAAAAAP/wAAAAAAAAAAAAAAAAAAD/+AAAAAAAAAAAA + AAAAAAB//gAAAAAAAAAAAAAAAAAA//8AAAAAAAAAAAAAAAAAAP//gAAAAAAAAAAAAAAAAAH//4AAAAAA + AAAAAAAAAAAB///AAAAAAAAAAAAAAAAAA///wAAAAAAAAAAAAAAAAAf//+AAAAAAAAAAAAAAAAAH///w + AAAAAAAAAAAAAAAAD///+AAAAAAAAAAAAAAAAB////gAAAAAAAAAAAAAAAA////8AAAAAAAAAAAAAAAA + P////gAAAAAAAAAAAAAAAH////8AAAAAAAAAAAAAAAD/////gAAAAAAAAAAAAAAB/////8AAAAAAAAAA + AAAAA//////gAAAAAAAAAAAAAAf/////8AAAAAAAAAAAAAAP//////gAAAAAAAAAAAAAH//////8AAAA + AAAAAAAAAD///////wAAAAAAAAAAAAD///////+AAAAAAAAAAAAB////////wAAAAAAAAAAAA/////// + /+AAAAAAAAAAAAf////////4AAAAAAAAAAAf/////////gAAAAAAAAAAf/////////8AAAAAAAAAAP// + ////////4AAAAAAAAAf///////////AAAAAAAAAP///////////+AAAAAAAAf////////////4AAAAAA + Af/////////////gAAAAAA///////////////gAAAAB////////////////gAAAP////////iVBORw0K + GgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAACAAElEQVR42u29d7jlRnkH/BtJp91e9m7vfddbve5e + l7XXgDFumBJKsI0hhA8IxaR8CQTzQUgoCZBAgGCwKYYEMLhQjNuu7XX3Nm/v9W67e/s991Rpvj+k0RnN + mZF0yt3m83ue8+hIGk15523zzmhEKKWo4axAO4BuALAsawYAaJp2jFJ6KSFkKqV0PyHkKgBLALQ4v1YA + GBhMT2hqjJdSVnJgMF3f1BjvBLDPubYdwDEuzQZKaT+ldJ+maX2sbjWcXSA1BXBGo92yrBZCyDQAIISk + KKUfJYRMATANwAQAnWUIeDVwcmAwPcpREr0A+gCsppT2E0L2Adjv/GqK4QxGTQGcQbAsa4ZjTW8FsBjA + VABLBwbTEyIxA4mocbqrWAqYYtgPYAOAAwDWo6YUzijUFMBphCPwS2C77UsATB0YTC84Ddb8VKETQC+l + dCNspbCBELIeNYVw2lBTAKcW7ZTSpXAE3nHllwKoLzfDVDbv8QwGBtPu/0zOREdb2VkHlgsg0Cth6RjE + ujY1xjdTSjcSQlaj5iGcctQUwMijHcDV7FdtCy8K4qlSAKzschWAQoGwoONqAN9yrtWUwQiipgBGAMy1 + p5TeSghZDDtgNyKSyAQpl7GPmZyJVCqLyRNaNz/30p4FADAwlMHgcBZ5J+1Q1oSZznnyaW6ylZLhCGRj + XRQtzQkkElE01kURixlIJKKIRXREYgZymTyaGuPJoHaJCkCESoE43sEa2IHFZ2pDhZFBTQFUEZTSlYSQ + m2Fb+6oL/VAqi1Qqh2MnBtDXN4zOE4M4cbQPh08MYiCZQX/3EDLZPPr7U+jpGy563rSC+1rXCEyLQtcI + jIiOfM5EW0sdAKC5OYFY1EBbRxPGjqpHc30Mo8e1YNqkNrQ1J9A2qgF18YhHqMtVADw4ZfAPlNJETRlU + DzUFUDmWAYgD+DcAy8vNROIqJ3ft7ao/dmIABw73Yt/Bbuzc04W+gRT6+1MYHEiVJNCl3PN7RpYWANpa + 6tDcnMDocS2YNakN48c2Y/r0Dkyf0o6GhpjYtkpp/h1K6cOEkCcrzeiNjpoCKBOU0pUA7hgcyryv0jF9 + KpvH0FAGh470YceOY9h94CS2bjuKE122Zc9k1FY0rLAyQWXwe4b3AsR04jU/JWJEdIwd24wJE1oxYXQj + zl80CbOnd2DW9I7AoUNI1IYIFaKmAEqAM7ZfAeB2AHMBjCo3r4HBNHYf6MaOHcewZu0BHO3swaEjfcjn + zNDWFwinAPwEuVQvIMij4CFL19JSh/HjW3De7DGuQpg4sbVSr+AkgPsppX+uKYLSUFMA4bAMwB2wp+/K + dvMPH+vH9j0nsHHDIby24SBOdA2iqyfpScOEqBQlEOY5XnDLGRaEKU+laFT10jWCtpY6jJ/QiuUXTsOS + xZMwfUp7pTMXawD8BMDvUFMEgagpAH8wwb8V9rLbknGwsxebth3FH5/ejqOdPdh3oLski81b1Uossp9g + hrH2YRWILP+w0DWCubPG4IIlk3HJRdMwe8boImXApjkDVkYmAeyjlP6EUvo7TdP2hK7EGww1BSBHRYLf + 1ZPEK+sO4Pl1B7Bp02EcPtRTJNBhxuClgHfpVfmXWnbQMKGUugfVS7weixmYNL4Fl180HSuumoPZMzrQ + kIh6FAAQKqC4uaYI1KgpAA7OGP9TKEPwh1JZbNl+DC+/sherX9ittPRh3e9Sxu2y62Hd8Upc/nLTlEqX + uoYYZk3rwJtXzMXF50/BmI5GACUvdNpMKf0JIeQ+1IYGLmoKAK7g3wHgTpQo+MzaP/rkVmzdegR9kvl3 + ETIXXyW4fkIdpBBk+fNpZNfFe0EKIqyrX60px7aWOixbNhU3XjcfUya1YfKE1lK6C6jFCDx4oyuAdtjW + /naEDO6x+frDh3vx9LM78edV2zzWvhrucpj0pbjaQVN3fgJfSsCwnNhAueWxeMFNb1mIlSvmlhM4rK0l + wBtbAdwG4FMDg+nlYefxU9k8tu08jj88vhmrn91ZFMHnIWN0HqXEBGR5B83P89fCDhHKqb8sr1LrJ6tr + UPtZHXSNYNqUdlx71Vy86eo5mDW9IzQdAXRSSlcTQr4JYG0pD54reMMpADbOHxhMf7wUwV+38RAefmwz + 1q7drxT8UpmYD9oBpSuBoGdUAsY/F0YIy1kQVKqyCVp4FKZOozsacf0183DT9QvLUQTfeiPGB95ICqAs + d3/dxkP4xe/WY+2GAxgeynjuV+K+luMBlBOICzNNGGaqrxrrCMLGAcpZuMSjo60eb73uvHIUwRpK6Rff + SMOCN4oCWAbgHgArICxBHRhMe6aUunqS7G26tR/7x98u27T5cFFgr5xpOhF+Y/VqLdopZT2BX/myZ/yu + h1VuYZccl7pOgaGjrR43X78Qt7xtcehgofPi0XcAfCJkV57VONcVQDul9E5CyKegiO6L88qHD/fifx9a + VzTGH0mhF6/Jygwzz+/3nF9dSpldCKprOZ5OOUOnsO0EgClT2nHD9Ytw21sWlBIsXAN7T4IHwz5wNuJc + VgDM6r/NLxFTAH0DKTz0+414+E+b0NM3XNZYvtJlseUG8fzG8eUG30qpf6meSDnBvmrgvDlj8f53X4Qb + Vs5nLyMFvZSUBHAfbD46J2MD56oC+BDsTguc02fz+D//v1ewfddx38BcGHe8FKspy7ecabygPGX5Vmr1 + g4YwYdtQbsxAVacwdLnssln47lfevhnh92w4Z2MD55QCKDXCv2n7USycO+7zS6/+6pfCjn15hLVmlQS5 + wizYkd0PG2MQ61PpOoKgtoe9p0pXrXUJLFD4F+++CBNGNQTWAfZ2ZffgHFtAdM4oAGc3ni8gRIS/qyeJ + Bx/bjN88+BpOdA0CCBc9lwlcpYqilBVy5a7Kq2TpcLnrCMLSppptLefdBTYsuObK2aFeSaaUPkAp/cK5 + 8l7BOaEAKKWf9Qv08Xh5/UF8595nsXlLZ8nMwqMcZmPPAeUpjGoKRZigYrnrCMqhWznBPT8aMATFQwD7 + xaObrl+I2999UdjZgs2U0k+fC0OCs10BtMN2y+5EwFiueyCF3/x2HX710Do3ul/OlJXf/zD5hEEp0XOG + oCFA2DG3mF8p6wjC0Eu8X438VTRjz4b1MGZOG4W7/vKysN4AGxLcG5TwTMbZrABCRfkBe6z/3fufx8sv + 7Sk7cFRqRJ+hlPLKGRPLrpViXVVtUOXjl76U51RpwtSnHM8obDuYN/D5z7z5JAJ2fOLWDNyDszQucFYq + AGe8/00AC/zSDQym8YfHt+Den70gXb47kmNaHmGVRLlLcUtZqhtGGZRKi1Ii/GGFN4xCK1VhlpJ+7qwx + +PhfXYXLL5wWmB7A7y3L+tTZGBc4GxVAqCm+w8f6cd8vXsJvH9kQyIylBMWA0rfXLsfr8MtXVgeV0il3 + 4VClnkqpgcZSr5UbgymlnI62erz3/Zfh3TcsREMiGpTdGgCfwln2UtHZpADaAdw6MJj+YdAU37rNnfj6 + t5/Alh3Hiu6FcUeD0gc9EyafUqccS6mbqo7lzNOr8gs7e1GK1Q1Dg3LzD5OXKv/rrp2Pj39weZgAYSeA + T+IsWj141igASunPCSHv80uTyubx8GOb8cMfPyfdbLOc+eNSGKzStDIBLSfPIKUl5s+nLYUW5dC01AVK + Yfup3PLD9t95c8bilz+8YzMChp0OPgw7ONiOMzw2cLYogC8B+JxfgoHBNO7/xUv42W9eK9pHv5yIdCWL + VMrxDiqJK5QbSS+1LeW0byTiGtUsP4wXxe53tNXjMx+/ll9K7IflALajpgDKh2VZMwghXwyy/Ac7e/HV + 767CCy/sKmmFmwzlCkypCDNNVwrDhwnyhbWApaTxGwqw9pXiDYTJO0xdSy0/rGcQixn4y3dcgL/5yNW+ + SsCZIVgO4PmyGOQU4YxVAM6y3m8hYJpv0/aj+Np/PYWNmw6XZcmrMf6vxty/LO9yFseEteKl1H2kp/FK + 6ZORKL9UOusawfVvXYSv/N31QVOFSQDfBPB5nKE4IxUAtzvvx/3SPffSHnzze6uwe99Jz3WZdWXnlVht + sYxSF+vwdfBLX4lyCRucKycPWZqwCjSIXn73K6GXSgmqyg+jnNizl102E//4iWvDBAfP2LUCZ5wCcIT/ + fgSs6f/Dk1vxH995Cl09yZIj0n5MwWBaFHldg2FaReNFdt/PCrE04vWwVstvGlKWd9gpzlKmN8Mq0rDP + y/oniJ5h6CWWY2oEUQQr/FKGCWLfsufmzx+Pf/rUdVg4dxwCcEZuMnJGKYAwbn8qm8dDj27Et3/0bNEW + XWEgY4i8rgEADNMq6blS01U6ty6mG8nZilLG45W0p1yw/JmwZwHoQnmmRoquVatc/v/MaaPw9596Ey5e + Ojno8TPOE9BOdwUYwo75f/qLl0MJf17XlFqbXWdHw7QQcxQhUwbsyNKprEBQ/rpGYDrnWS4df118zg8Z + QqT/wz7P6uGXthrCz9dtJOAKoUVhWtS2+Dw9R0D4Ge3E/7v3ncTnv/EYnnspcCHgx2EvFjpjcKZ4AO0A + 7keA5f/Jb9biR/c9h0wm77rnrKPFDufdwFMNP4FR1TcoD9Ze8b8f/MrQNeKxmkHDqEqVAl8nZrHhlK9z + ClLn3Hi9gnJU9S+lD1T0VD03uqMR//CZN2Hl5bP8sklSSm85U94kPBM8gHZK6bcRIPw/vG+NK/wA3LG5 + qkOYZfBcC2NhA+7znoEIlr+f9dM5t9UPoicR4xQ1+8+3h3kUpuN1APAtw7RokfCrPCbxKLrBeV1zPS52 + zo4imPCzuplOXuyaKdS9FM9Ghqxw5PP2o09RPEfgNdGDA4ATXYP4168/hief3+VXpXpCyBOU0s+W3agq + 4nR7AOx1XmW0fyiVxU9++Qru/+VLRQt8ALWlF5VCGEtS1xBDfdRAc3MCRkSHTggy2TwGhjIYSmV9hx1h + 56xlY9Wg/MQYBbvHewKlWrWwHkA5yOsaYpRK85N5AHx9mFB6lERAvfziAHwaviw+X9E78Asg8vUUPTTW + Rx1t9fh///Ytvp6As06ArRg8bTjdCuBLAD4NxYKKVDaPH//8Jdz70+c9nZUhxBOdl8FvPpwXoBkTW3HR + 0smYNXMMpk1qw8VLJ3d29SQndLTVJwcG0/WZnIlUKouTvcM4eqwf614/hE1bj2DfgW5XIcnyF+tYjoCp + gnyyIYCsDiqBqNSNl+XH2huUjtVJLFv0ikpd8hs05JMNAcLMApSLMEoAZ8C7A6dTAXzI78UeccwPFDN+ + XtdAKC0aNwLqDmR51DXE8N6bl5a0ZzxDV08S23cew6NPbFV+KYhZQZkQVrqCMEgBisJQ6XJeVT1kwwG+ + bmGUgirfsOXyrroYVwjrbZXT3jD062irxz3/8FZccckMv2SndXeh06IAnPf574fPK70//81r+PYPVkvd + fl4RiAzI3DO/zo/FDHzyI1fj/e+4oBpt2fPxf/rdDNmXg/j68UJZSvCJj6iLbnWYYCArP0U0JGgxzWRp + w9RJ9HRYfVSuPwNv6f2m7vwsumwNQilDBj4fsQ7sGuCNV7B0YerHY3RHI/7lczcGTRGusSzrjtOxn4B+ + zz33nOoylxFC/g0+b1X94cmt+MZ/P410Kie9r1GvwGtOH+RJoVMihECl2667Zh7u/uiKJBAYiwtEOme2 + 3fym85LjxjRHO4/24WS31xvIEwKNAhFSYFpNUi9dI8gT4tZb1+wjpXZ7NUqL2qOFUN4sL53aAqsRgiFK + oGnw0EjmAmsKGrJrrG58fYKqpDltsp+V32dHTagfXy5flzyxhZLlK6Y3NSIti9WBv8+uaVwd+bqyI9+f + nv7WNWiUusfkcBbbdhzF/HnjMGZUo4oskwkh0wE8DiAV2KlVxCmdBbAsawbsr60oV/k9+fwu/Md3nlIG + 3Pj5/QzxjhvDrP6qa4jh5rcsAMLtBx8IZ++4+htWzsev7r2z84rls73ReacernsqiR4Dhag8m6MXZwFY + kEn13w9DlHhokqBW0SyJbH1EGISpG/+fn6WQ0UG1bsLP0vKzB+x59ixvsVVl6YphFF9PN60QN2DwW0y2 + e99JfO2/nsKuvV1+pHwb7ID4KcWpVADthJAvwkf4N20/iq/99yoc477FJ3YE72IapuV2BJ/Gj5k72htw + +YXTTmJkMOGez74Zb79pSRHz65zLLHN7+aMI06IuY2VhDwX4RUy6grkZGggN5RaLU358XrwQ8NdYHcR6 + qv7zikd0v9y8JVOl4pQnXz5Tnian5MQ8dKt4OpGfCmXl63wduLz4oYDbfu5ZfkgKAERwhdZt6cS37n3O + 95PyAO6klK4M7Kgq4pQpAOcbfcrXevce6sVX/v3P6Ozs9cwRiwwjY2TPCjvOAzC5I2DP8bc0JQAgMVLt + 7Girx+c/8+bke25cbLeBY/4MIZ4Vh66S4OeXHWZj7RIFjhcK3lvwo0kWCssY0tK7AsYJjDiXXw6ywrkn + cOmUx+optkcUXpGOLD9x5aS40lNcNyHSh6c7v1bBVHgVzPi4iodTVKtf2IXv37/G/RydBPWEkF+eSiVw + ShSAE/T7lOp+V08S//69Ve4WXnwQBoDS7QKK55X5zmHKgDFEDEAmkwNGfpxV/9d3LMcVy2d7LjKPhf13 + I/mcm+qZyRCWuOqchZbNRfPwBLY44eXzDoI7nOIto+Cii4IYZkgiLlTi8xMXNEUlZfCzPn7IwuuS80u+ + xXZCKIenNb9wyAygoe+UpUXx20c24JcPrkUqm4cCowghX3CGyyOOEVcAzqYe34Qi4p/K5vH9+9fYm3lI + LBw7ui6ooARE94wXellnHDsxCEpp/0i3u6OtHnd/dAVmTiu8Ls6PhV0LxDFUFCgar/LWl52LSk8Gcdxq + KgRY+bwgFH4r6njEQgQm+TiNuICJV1QmOxfcf3G1IA8xJiTGIli7WD1FSy2jjx+dRIjPsPbwnsP371+D + p5/d6ZfNcme43F5C0WVhpGcB2gF8lRCidGl+89B63PuzF2Ba1I24sug0O7IoOov485FejRDAom4kmGcs + WIVoLEM6nUM+Z7ZdfMHUkaYtWpsTaGiMY81Le2CalidqLkbwTY1AR3F0nEWz2ZEJCmu3Cjwt+VkRNlMS + 9LxYPnueEq+7rAl9wRZYRQh8ZwTYPRaFj6IwY2Jq3tkQXomzessWEvG8wejJhl2UAjmtEKE3CfHMWrC2 + 6YCbP6OPOxPgM7PE050/8nVh+VEKbNp6BAvOm4Bxo5uk+RBCZlBK+wkhL5TOeeExoh5A0Lj/+Vf3ucLP + g1l8fpzlWcjCjWdFd1885+eomSV4+E+b8Pyr+0ay6S6uuXI2Vlw5x3NNdF1ZfT3DGM7jMSXWkqeNrhGk + iOY5sv+i58BbVlOwrDLwqwr5OIUn8KYV1vMD3qGOLqkj+8+3nc/PQwtHofC8wR/5oYInau/kKQ672JFf + Qs3AD6lMrm1un3AxCb6PeNqb3D1+SMfXF7DfG/jm91bh8DGlM1rvDJtvG0n+HDEPwBn3/xsAqYo72NmL + L33jMew70gdKvPO0mqONmbXROMuXJ4XxMEujcxbfM+0jLJ1lVnc4lcPmHccwekwTpk8eWS8romuoq4ti + 1Qu7kcuanvbw7RKPzOPh26dzlomPFQzDXuSjEYIoJ8dR4rWqLB/+vNBf6jYMQ0OUUvlcutMfEUJgotBv + lmNtNUIwDA06pYhr9pRklMBdlwBJnfijpdl9xzw5vs/zuoYYHGXgrAMQ28k8GHF+3uULLm3eyZuvSxGP + ATAZfTk6ZwEkSOEee1bnvAixbsdPDKC7L4VLL5qGaESXkb4JwHjLsp4lhPSOBH+OlAJod4RfutRuKJXF + 17+7Ci+9us9ddMHAiMPcftdtcjqGMRwjrp8QFfIq5tz+/hSee3kv1m85ClCK3v4UOo/1Y+OWTjz6p014 + 4KH1+ONT27B9+1H0DqRQVxdFU0PwJ8dl6OhoxObtx3HwYLenfYDXBeYXpuiA6zaKSo0/jzhCz4SMLfTJ + wlEGCrrw9AlCBPJ5ctYffDwi6tTZ0goudlwr1C/P1ZcpKCYkEULcc3eoQwsvPTGBdRftEJtGpuJZUyOO + AqQuD7B6sf+UQCiveDUiBMXMyjRZH3HnjAZ8XVR10yhwqLMXLU0JLJo/XkX+yYQQDcCfymK+AIzUUmDf + bbx/9Ju1+PZ/PuGey6K54htjKibmIUtDhaWqqqWzdQ0xmDkTmUy+KOrOXhp6981LcdObFyDowyQy/OHJ + rbjnq3/0LG12vRqewZ09DsK0W1yOyp5n7jWb/2dLdNmy3TA0FPumaL5cGELI3vCTPZ8iGhoIF2AUAm56 + gMJS5c/q4Pf+gWyxjkh7WZ1V9eGXEoeps6odLS11+PoXb1EuFx4YTKOxIXbdSLwvUHUPwHH9vw3FMtuX + 1x/E17/9BNLpHFJEQwTUtSTMbQIKml3F/MwKMCGXWVWds0RAQfvz7iAldvp03kLOoh4vo5AfRc9gGs+9 + uh/Hjg9gycKJqA/+VJQH9U0JrH5+F/r7CzOQzFUWGVDVlmLPxhvYcvdIcNxtwL5vcAHIoNeGebqyMlgd + RHeYWURmCVl/+T2fcOR1iBLENVsJUIlnJw51eAvN5888EGaBDUfhWRpxA5Gsv3lPgL8mvlsCoRylYCs8 + UJ6OYrvE/jU1gmwqh4Odvbj44uloqivmq1jMgLNU+L7qSCnX39XMzJny+wIUy2wPH+vHd+59Fn3OSr8o + KZ77BgpTe7IOAHfdE5TigjUsD1MjRfPA/JGHOLcsW2RimBYee2ILvv7dpzGUKmVyCGhrimPe7LFFG44w + oWVKwDMFyLdRYVnYc566avYwYIh6NxLhVyT6bhYi1EGcdhWDkYCwbFcILooBxiFK0EAohmghUAZ4p0FN + i/r2PU8Dd/rXEvZI4IJ/PI14qy9afn7xlZ/wi+s2VPzJ2iXSRuT7dVs68eOfPu+3PmA5gP8qielCoKoK + QNO0O+Cz1Pe+hzZg46bDHuLyi1NEYvIMIbqcvOAHubL8DAD/3zCt4i2ohPrI8Punt+HRP24qiTaJqIFF + 88YhxtXPravAuNI2Kqy2LiiCIWqfNxDqGQLwQpghJHBuWxQwka5F7rBFvUt3Fc/zaCD2M/zbgTKB8usP + vlyTU6Q8LVUzHGw2wLP/o8SgqBQwn1bFn6xdMoMitukPT24NWh9wa7VXCVZTAbTD3txDij88uRV/eGSd + e56lpMhq8wTnrYuMaLyG5a/JOoRQCkILHgEfE5DlUVQPsSzTwu/+9HrQuu4iTJnY6jIb7xKKEKeRZPcY + 2JiXMX3Ecasz3Jy8YVqe8T9bpy62XWy3bPWdTDj8FMUQJa4ij6Jg/YOgor2svqLVNoUxvuqtPXZk9BON + gacePuN7FX+K9dWF50QF0juUwY9+9oLf1OAEx8Ou2tRVtRRAO4B/gI/r/7PfvIbhoUzBLSJ241NE89Wo + 7D8/x+q3jJXdz3DnIpjgMw/Anaul/h1sasSdetq8pwsbtx0piUhjRzdhVGMcGdjWJwP/pbN5rp0ZyN+d + Z0E/XgmI52JwkKFoubBGPGX5KQgZrVyLx91jrj4rO0Etd3gC2EpDfJeD9TPffnYuo4OImNMGvv6M3oCt + wNm5SCeRf3ha8EfxOs+ffPt58B4OS8/nE4P95uB9v3jJdyhAKb2zJMbzQbUUwK0Dg2nlJof/+/vXsXWr + LSyiBYkS+bhJVAhMYcgIK8LUCAzFWF60gGJd/BQHUGAk07SwY8fxkoiUqIsiGtGh6xoysBmVZ8SisngG + llgVNuZNUC8TJ6hcKbANQXhaMPCxiRjUm6Py/SH2p6xPhyhBgloeRRAlFFHnXNZ3fD34/osp6CCC0Zb1 + F/88U+AsDeMHMRbAaG9oxZ4qu++ZLuTowf8XaSfSiM+H0fyRP23yHQo4C4SWoQqolgK4XTU19vL6g/i/ + Rza4jROtkHgtS73MxN9jWtMPeYnA561gl5OlMZz0fs8w5urpK20IMHFs80ktHoFpWtCdWERe1zz//doi + XuODnDkLrtDzwp6z4FESMjqLMDUCi2jKe/x/8Zzly1v8FNHs9zUI9SihKAlun5h/mL7khTbP0ZZ3+3WB + 3kwJyOrh91/kZ0YD1TBAlQ9TKhkAA5k8fvab1/yGmBMopcrhdimohgL4EhSBv+6BFO77v1cw0Jd0CZ6g + FvIW9az04xEl1MOc/Hk0YOyYpcRjNdlz7JqK6cXnLKK556yu7L9MUMOiqyfpvhnE4hL8Lyc4AYZE2Rmc + kAEFJcmsqhhljpJC/IPPn9GSpTMCFKuMZrJrrL/4/EUvz68vgvrK7z67xt+T0ZnRWnxn31SsHzC0Aq+y + /5TYNBP5NSytRO+OpTOcvli77Rh+9dB6ZZ6DQ5n3VSMgWKkCWAZAOR750+Nb8OzLez3EZdoXKLhnomDL + lICKqH7pwuQTlM7ghgzsP6EUMQDjJ/t9GLYYqVQWVtq7zdlItzNM+2UMqspDvC/LXyynkvxPRfkMTBAp + IdB1zRX0vEU9ysE0LY/yGAn+jRKKXz69Hes2d0KGpsY4CCGfRIUBwUoVwC1QvOa791Avfvq7dS7hdInV + VI0zeQuiIppoaVTwuy/mJ7sv81LyFkVdQwxL544tiVj9g2n0C2Y+qH5h2ulX/zDt5xlWJSyq+yOd/6ko + n7nj7GialivkTNB1bvaGpZXxRlB/8PeD+uf4oR786Bcv+605WQHgVlSAshUApXTlwGBaudz3gV+/ggOH + ehCDNyBjctNwuq6VpP1FDe9nJVTnQRZDvC+6hYxJliyahNkzOkqi2cHDvUgOplw3kh8HllO/sPQKyp9n + RNUzYesyEvmPdPl8wI8deYMlDo+Ym04oHTH+ZQHDVS/uxjPP74YC9QBuRwVeQCUewB2qwN+6zZ14ZPVO + V/BVwRfTtJREEMf9fuMsmSZVnYctj10TPZcYgNaGGP7ytmVoKHE58Lb93fa+AGzvfC7vUoRdJsyq+ofJ + X5Un/0yYoYjfNT9BOd3ly4K+7pBVCNYRSj3Wf6T4l8VOTNMKCghWNC1YlgKglK4cHMpI3/NPZfP40S9e + xkBf0p03ZwQVl+KKHoA4BuLh5yoFWTrVdb/y+Gu825dpiOOO91+Gyy+cVhLNBgbT2Lj+gKf9YeoXJDhh + 6l9K+/3iJLL7QfT2q1+Y/E9F+YYQBM1btDCN7PAvodTjIbChQbX5V6y/oRFs2n4Ujzy9Xfk8IeT2crcQ + K0sBEEKuUln/51/dh1de3eu5xk97mcJSzTABm1LuqxillACRCNO0Zy7GtNTh8x9cjtvfUfoU7O4D3di+ + 097zULYAKKje5dIjKP9KEWXLeSX1rpO8417xhxhGoHwxBsBfZ4IuegLMC6g2//L158t76OF1ONjZq0q+ + gBBSViygHAVwGxSv+g4MpvGbRzdigH3Kiy2ndASf/QeKA4Cq8Zyo4WXuoCxd0HUZxPxY/Sd1NOLm687D + t75yG97/jgvYtwBKwh8e34yBTB46Nwtimlao+gW1U5aulPbLngt7zDqr+rLcj6Eva3muZ6m9bFdMezrL + 5yP+qqPsvzg0HCn+ZTy480A3Hv3zFiV/EUJuLpkpAZTMyZTSW4ki+vncy3ux6vXDbpArZwFwrD9TAoxw + 7FyctxfdKLFTxYCO6hnV1IxGLUQ1+ZgZsJVWVAPGtTfg/CWTcdWlMzBvzjiMG9NYluAD9rLhJ1bvcNue + s4CIBs9iG9lYUayjbE2Eyo1XucCMNvm6GKxkVkmzsHGVLCXQ6qMwhjO+dFddV0XEq1m+SFfxGm+cTCE2 + I4MsjYwng2ZmQvUnKSiGh9fswpuunoNZ06XB5+UAPoQSvzZcEkc77/pfLbs3MJjGo09uBYbSoLrmMrlp + Fqc1OaWQteAhVlDgSkyncmnzdTEgmS3uECf6HuX6j+XVEtUwd/Z4vHnFXFx8+WzMGiffsLEUpLJ5/OLB + 13C8b9hVjBHNHlNGhLFkmKm+oPbz6fJ1MRjDtq+VbUggOpQqLEEdzgBEEqxqSACDaV+hFPsjOpzx7tuv + EADxukwAql2+7BkxX16Yee+MP88RggjbV8LQoVNnhqghDovjM1kZjBc97VQEbVVB2iih2LenCw8/vR2f + na6cfbrdsqxVpXxjsFSTdgcU8/7PvbwXz76817boDnPnLHtPPJ64TPiDNK2f9gyyFlFCkXU6RUzDAjz8 + mC6qAVdcMgM3vm0Jrlg8sawdf1R4+tmdeHr1drdMixTaECH+7eKtpFYfBZgwc+n85pQNLj0G0842YVT6 + DPMIokMpQHDwxGfE/pEJn8pTExX8qShfBKNllFDkTeoR+jC8GeEWARnDGWRR7BHzZfPKNuz6FbGPGR77 + 0+u4+Zq5Si9A07QVAKquANg84yWymwODaTzw5y0wTQuWsyyVeQCMsACkY6cgFy2Mmy/TqmL6fF0MGM4U + zekunT8ef/mOC3DFxdOrKvgAsGtvF779i5cxOGyzqF12oV7iUlS/dmSTWVeA/dxMv7lv32GBxCPws2o8 + /KbmZFYfgNsfI12+tO3JrKtkLKJBDBXKlAAT+iJe9lkR6DdDIFNoqn7l/x/qGgz0AlDCMCBsELAbwKcI + IdKphldeP4QNr+2DodnuLb9CKmfZRLaI5q5FZ9d4QrFGi2NDAL7vjwcxH7vPxrvsemtDDB/+wOX49y+/ + HTesnF914e/qSeLf/+cZ7NvTBUqKg15i54v3PMKJ4mGSzLvxG+fyEMvT6qOeeypLLcZkVNacL18sy53e + 4oR/JMsX2y3SJqLZ/JizvMFqBtO0XL7lh67sXAZV7EalnP36Vew/i2h4/IXdfjMCy1HCVuJhFEA77BVH + t8huDqWy+N0fNrkLXBiY9Y9o3h9/je+YfF3Mc84TZZi7xyKxLtM4gusRpoaEpwP4TshSgksWjMe3/+U2 + fPZDV2DCqIawtAqN7oEUvv7dp7Hqhd1FbWYxAHZk9WbtkXkBw3UxDzPwabINiUBLz9MAgEtrxnBMGBnE + vhDr0+D0l9SqO2B1Y1NlrL2y/Ea6fJ7mfFr2n+dHPkjNjuI9BnauGtfz9WF15umR1TTPc4wHVPEBhn17 + uvDHZ3x3DlqCkAijALoppR8FsEB2c8v2Y3hFeGEhRwhywkwBfy7ey1LiWugsJcjXxVziMQZhzMre5DKG + M3Ya2YcWJdcYAd95w0L8yz/eoNyBtVJ09STx1W8/id+t2u5hmJwzK5JTzKDwbWdWkQm9KCC8hxQdShUs + YkPC/t8YL1ICeU6JGM74l6UTLSpfHt8PbtmAp79EL8tl/MG0vVxWK8x+sHrwCnkky2e0Z3wj8whlvOrH + r+I1cTaDL4MZt6zTLkYPcSER6xfeI+L7VfRonnxpj9/qwNBfGQ41BCCE3K669/ATW9DXnyrSjhFhfMvO + +Wgqa2SUUJfho4TCSmY9HRwFPALBCG0JUf6ijnAIl6UELc0JfOr2y/APH12ByRNawzS7ZOza24VP/usf + 8bsnt8nbr5Oi66x+TChZm5gQ8MMgrT7qEYiiaTQW5XcYn3cpeYZ3y3bS8y63KKCqfuDpLl6zuABsVtMQ + oRQ5Qjzt49sxkuXnLCBqWa5gycbfrH5+/MruM+XAron9IdaH0d5Vdppm18c5inzAaOQZCnL9ybDt9UN4 + Zd0BFStOIIRcFYZnAxWA89KP1Prv2tuFJ9cehCbsNMOIw7/4lhPiAioBkAV6MoTASucQ0VA0XrS3BLcJ + KrrZkWQaeYuiJarhrz9wGT74/kuqPtYH7Km+J5/fhc984SG8+so+12VUMZXsHu8ueujvuIpZAFY657GO + UULtYYSmATpxYw1F016aHZiFXnCFPcG1hsLX0vn8eUsUJfZOzZZWvHbBEmZcPP1oUk9bWJ4eJVGF8mV8 + Ad15zmm/+Cp2lBQEmxd4vo+iluUqEULt9vDXWDtYeXD6iZXLl8XTI+J4AhENgE7c/6KiYnV307I+owSP + PrnV703BW8IsDw5UAH7Lfp96aS/6j/YWubouQXVSRGDxOq+N2bhMDJIwYucIKVq8AtjzsqJlBewoe1PM + wCc/cjXueseyshfy+OHwsX5884fP4v/96mPYeaDbZQLR0+Ehuo/8MEf0dFg+ruUQ6MXuRxwX13U5Kcf8 + jsVxFbMQf+DXB/C0d4cKPIThVTX6rxrlM/qxdhXRTUE/LW96+oPREgC0vBnYvlLLY/95L0LsP37Iy/cd + oxvD2q1HsVGxXwCABZqmLQni3yAFUA/Fhh9dPUmsfnZH0dZRPNPzDRPTsMbzwS9xNZeMkcXoOS9ofEea + poV8XQx33XkF3v8O6RfKKsLAYBr/+8gG3PXFR3Hfr17DgLM9mEfROWDtd6f9TOpxi3mBL2J60457uEzF + uc/GcMYVLEILrrTHmxKE36WVVbzSUhaBFyGmqbT/Ki1fpB+jqeteOxZXRT9d1zw04Y+WoQe2L6g81fMs + vaz/eLryQ4Wc4OH19afwh1Xql4Rgr9vxhZ9JbKeULiWESBf+vLLuAF7fccy2ePwYyqSuFXThfPea9wZy + ln3dcua3WaM12HPeANzVU1lKAJMiXx9z3b2sEMSJOO5Zzik7omt4z01Ly3pxxw9dPUm8su4AHvjzFqzd + 0gkMpRHRNeSIzrWruP05wF3W6Z47bYo6jMEzvthGtposC+KsfCuMPyHQMMtc4mTWdk1N6lX1JvUsLEJj + HOCCiaw8i8unSCgb48gOpovKLqf/Kilfq4966KfFI4W8OT2qop9nWMC+z+7wNBDMn562SMrzfZ4CWn1M + 2n/uNZMiyykpl54OXtt4CAc7e1VxraWwd+1aq+JnPw+gGz4a5JkX93gsu8zyRyj1aC9PYMUpmR+78cE/ + t4LOeAgojA/5MZ+WNwtBGifIpuVNrLh0Jv6f915UNbe/qyeJ/31kAz56z8O456t/xKuv7HPr6loOfrjj + WHktHnHPRVpFNG9wjrcW/BhZnBbjg0W8x6DVR13asOvMy7Lfy/Cm42cSxBgET+tYcwIiokOpqvRfpeXz + 5fF048v1o58IcegW1D4Z+EBk0POy/vPU3+FpMxEteBfc8OrwkT48+6Jy4d8ESukKv7r6KYBlqnf+d+3t + wurNR+zgn0k9kdGI5p3yYoEQ1zqa3mGBGO3mG89HRFlHsvvsOV3XPB6AaVqYMnMM7v7oCrQ3JVANPPfS + Hnz+a3/C//fNx7Fx42H0ZbmvzjjzxC7TMOvvxDmsZNZVeFGrQC92ZGN+nhZ8LIBdFwNt4uIanqENwaPg + aZwjBHoqW+SmszR8AIoxb6bfK+xafdSdYam0/yotn+XBH5kAMt7zo1/UsgoK2iwMBRhPBbWPv6/VRz2K + h2+X6nlZ/wGFmQNm3GQGIV8Xg2la+OPL+5TfEXDeElTuGKRUAJTSFarg37PrDqK3a8AOvnE5iIoAgCvw + hFJvgExRMus8fvzICMcYm92XoamlHp9878WYPqnyqb6BwTS+ce9z+MxX/oinXtzrrvxiHcgYkrf8TLkx + pmKRX14ZAoWFJ55oODeNxEfDeYUgLoCRLf7xLCThPA9Gs5xVmDkQp+V42opC41plTbPfLZCM1Uvtv2qU + bwxnPN4PbzmD6JfVtMKwjQ0f2SyOZKGf2D5xHp8vT7YaUUUffuzviXE5AVQefHt1XcOuHcewbaf8GxUD + g2nlp/oAHwWgmkccSmXx1Mt7PYEs5nbzwRTRI3A9AYG4orVjAsDP8fORcZaG3Rfnaa9bPhPXXDkbleLw + sX783XdX48cPvIi+/hQimm3teavmWndu2pMNRXLctBDgdfvFgBzreH4eW1wAw7vE4pw5/7xogURPImpZ + rnDwAsJbH9Fq8cwLFEftK+m/SstnYPnx9AlDP75PXA+A492g9on1FOsRhj58/8ksvVhfvhwA6OtP4emX + vJvwMDhG/FMqPpcqAGcVkfTFn517urBrxzEPoXKEwDLsVyq0eMQ95ix4xi7sGQDFgTLnWlbT7MAMNzfK + zovmTNkKM8elnjaxBR96zyUVj/v3HurF3/3743jqT6/b9UdhvXiWEtda8MLMGAmmPe7X4hE78CV4KuI8 + M2MOD+PqhXUPbH6ZtZl3g/mxNHN5rXTOte7QbXef/aeCF6JalchbNVER8ffD9B9rC29hxZV/lZQvroNw + +4ZyXhdXF56P+AAgr7DF6VKe/1xl5eTJL87ytEsn0j6QPQ/A029SunHnnnQOXnttHwZkq2JtXA3FMECq + ABzrL930/pXXD2OgLyld7MLP87pHjsi81WHnfFr+mmphhuw6Y4R337qsYte/8+QQvvbdp9wFPUVBOt1b + H9mSUT7Yw9qvWlpaav4ifT2dyQKOHC1V5bL/vELhx7DsuueV4sa4990L579f/4nXZeVVUn5Q+2R18Vv8 + 45cPP23N9x9rP98eVX6y+2IdRTmRXefrrlELm4/0Y9vuE9K8BwbTyymlS2X3VEOAJYqM8Oz6g8rPRhVl + 7jSWVxZ+TOgGyHygWl0347yJuOmauaHqpcJQKovv/vg5PPXKPteNF6O4oaALjKIX11kUiJLy5+jLewF6 + Khu4hl1kLD5wyGYVmJUSV9dhMO1diOP89+s/VXlMcKpRvl95fvfE2I0Hjicnwu0j5umpovzc83z+4n3m + DYj1Kuo7kyrfJbEMHZn+FJ5bK18a7AwDlsjuFUmys3xQqi0OdPZi145jnqW/HsKZXqZ2p8kCGJF1Nk9M + UUur/jOv4Jar56CjTfpx4tB49I+b8OvHNnuWa/LaXVaHojrpBS9A1V6+g0vJX0VfcTqyqF84iHSVvXjC + g527bndjvOCOcx6Aqv/EI8/s/DOVlO/XPlkdZIpAKljJbFF/yASen8aTKXQ+f6nCFxRnUZ+btMhzkKV/ + 6fVDymGAKqZXpACcHUXki382H0FffwpoiCNnOeN8ttBE6Fy3sUwTmt45cRXB+Ya7+XONlrltE8e34M3L + Z6IS7Nrbhft+u1bZDsbkrN0w7blZvv05Qtx7Yge6z7FrZeQvpa9w9KMvD1EBAZyV5epUZGUH0wUhFe5Z + yWxRf/Pt5QNtLP9qli+2z08Jyiy+2C88nVgfirQHvG8YypShLH/+vkdOUFDkvMIRPaKiOuoEB/Z344B6 + n4ClsncDZL78YtnTqWwer762z66MM661kllPJ7P/qjiAlcy6QTUPgzTGC5aQXROCNEUdwhH2iivmYOLY + ZlSCHz29E/sO90nL8muP2H6PEnMslKcTS6RXVejL01UCVj83YMn1B98O9+gIHm+JPXPYrD7pnKf+bt2E + 9BWXXwZEPuKHMR7XXjj30FznVviJngG7H+J5P3rxgUCZPPDoG0rj+XUHVbcnOMbd225JwiWyp48eH8Rm + JiBmsfvONw6NcU/Ul0dRep3YS1JZIx0rEgomRaw5gRsqtP6b93Th6Sc2qxOU0h7GpE67XEtWLXqVkx5Q + Mg9fPzc9b1kb44Vz4brrlsssMTcUKrJcg2m3/lUpXwZHgMaMb/WNC7hKlaOP6JmIgT4ZzSu5H0ivkMhY + FBteP6RcFASJcRcVwDLVwoFtB7pxvG/Y03F8Az2NG0wDTJvr6rGPtKG6v+sqYtGcsZg5paIPpOKZZ3bg + WE9SXXYp7WHKzKetFdOrEvoKkFlij8UVhTHoOk9D0xv48igw535VyhfhTAl/8a+vxj0fvQpao3pFaJHn + Ca9FF4/S2RcuvWwptO/zYegVEjGNYPPhPhw9PqhKsgTCdKA4Yb5Utfpv48aDyAylEdM4t0UQGM81YRcb + ZXoZQiqBTNTA+XPGVvSO/8BgGqs2HEQsm3cXLUnrUm579CrTqxr0VdDazYMpMUGZhbquyNsDlk7VvlLL + F3Dt9Ytw97uWYdb0Dhzs7EVLUwLHhxQKQ9I/Lt24uXcZfT1pFO0NfJ7taqXw6ErF8SO92HagWzUdPs2y + rBZN07rZBd4DaAcwRfbUwGAa63YcAyIFfZHRdWR0XXrud11MU04e7NiUiOCKZdIqh8buA93Yvr8bmaiB + HCEl16va7a80PzHvoOvJqNdL4M/5/5XWp1rt9WuXFo/gztuW4fv/8JYk2za7ra0ekxKGkg4lHZ2t5Mt+ + XnYcziDD5N6kldPfoti4UR0HIIRMA+cFuArAsqwW2CuGinC8axAH9nd7Co9xX/zI6LrnPOi6DGHyYP9Z + HcaPasDESW2h8ldh594u27Ph8g0q3+9/NdpfSX48jVR9FDNNN019KlOIuZgU9dniGEw16lMt+qnapcUj + +LsPXoFPf/hKwN7HAgDQkIiiecZYIJeX0qeko0Yqe15yBIB8PGYLfyKG+lSmSCmXSv91O4757RR0B+w3 + fQFwQwBHM0jH/+t3d6FvKA1+UWslDa7kWcbAGV3H9NGNaGuqbIuvTQd6bM0eMRDL5gGdBNadrwP/vxrt + r3Z+QflDJ0hGo6jPZm0G5I71qQwyUaNq9ak2/RiY8N+l2PuhTaMl0+lUHQHYSlcn3iNQFv0zEQMHjw/i + xMkkGiYVx4AIIYthewDdAOcBEEKmqoRk445jRe6PKIyiJhKvyyysKo3sXOb+TJ7UVtG6/1Q2j30Huwtl + CXmphEemjKrVfhHiPVUaWT5++RcxIOBan/pUYYyuap+sfn7tGwn6sfuffv+leO9N0tlrAEBDfUxJS5mC + CVJA1bwfM80i1x8ouP+l0j9mmugfTGHbgW4o0ApgKjvhYwBSCg6lsraQRIoFTTUW4TtHvC4+K0sT9Ax7 + bnqF7n8uk0c2kwtsm3hdVbdqtp+/Lv786iKmVeXPwBgtGY16PAD+XintPtX0e+dbFuCv33tx0s8QtLXW + u32soqVf3Uq9H9R2kf6M7jzN+X4olW6pnIVt24+qqjkBCgWwRJa6pyeJg0f7izpFdMeCtKp4j6+8mJdl + aErr4VY8HsGkcZUt/snkTAwMFSLXYVxZVRur1f5ERJNaDHYM61n4tYdHfTbrDgH4/+xYaftGgn4MF80b + i6/83fUnwY35ZegX1guEoSd/TMUinvvsnB1l9VTRRLzP052de3i0RPow7N593G89wNXsjwHY6/81TZsm + S3noSB+O9w17tHHQuK6c8S1/L5HJBY4tm+NRNLdV4as+mZxvG2R1LXfsHqb9KQAoMY9KymZMxysBUVgq + KWOk6DcmEcGn//JSQPHWKg+zb6iIf4LKTcUiLh+K/Ki6LuNTMX9ZPRjtAa8HwK6VQ5+9JwaRiBonFfTp + Y380ANA0rUVFvO0HepDJ5EO5Z0GV8+sEv3sy9ycR0VFX4Xv/mqEBMe8SWZmV5OvBWw3+XlD9VfnL8hTL + DCpHVkfVc8jlPfcYwxlpe/yf0e2pJCOdQcaiduwnly96zo/5pOUG0DaIN8R23vTWRbj8QqnNKkLSkpcn + ox07MuFW0VbWVhmfyvhYJvzJqP0+gGGaMCSG1a9vZR7ykZNDWLe5U6Ucr2Z/mAQtheIFoD17TwC5fNEU + iJ/GV1VORdAgxpURPRrRMX1Sq0rDhUKEEDQ1eANEfp0Yxlqp2u2Xv4op/VzpIjo501xsrNuUiKClKYG6 + qI5R7Q1ojehobkmgoT4GvaUBzWxf+6iBeF0U6eGC5e/tG0aGUgyn8+hOZjHQPYjuoQySg2n0D2eR7kuW + pABLoa2fAmGYO6kV77thUag+TmXz6DvaZ9PHoU0p/VhK/4ZJx1/L6PY0rDvW54Kuquf95MJDs6E0dh/p + x/kLpGI9Dc5uwUwBSFfTDKWy2N815KmIrEFih4rM4MfQso4OwxR1UXUwJiyaGuMYNb4N2HYstGXwC0wF + tV+Vv0pAZGUwKw7YSz9jDXGMH9WAUe0NmDa5HdPHNWPKuCaMaW9Aa0sdEnVRxCI6GhLlrS8HbCHKZfIY + SGbQ2zeMYwMZHD94EgePD2Dz/m6c7B7CkZNDyAylbY9BVwtwOfQT6fX2lfNDb/ySy+RxcCBdtIiNr4us + r8vhb9nzfgqFB/MCmPX3E27ZUKqITyyKY/tOAJgvI8sESmkrIcT2ACil04jk9dG+/pQdAOQ0p9ihKtez + VEKXYv0ZOk8Ojar0674zRxXiR7LOEtsmq5uy/Y4wBDGDJ89svmg6kqdJc2Mccya2YM6ssVg4pQ2zp3dg + 0vgWNDTERuTLRwCQiBpIRA00NcYxcWwzFgLARVMB2MphaCiDYycGsO1gLzbuOIYdu47h4PFB9HYNKOkl + U+5BwyAAmDymCW+6Ivyejyf7UjjeNeh6ADI+UykasQ5h+lf1vMqo5KN6IQaTyrjrUPxkQaZAimgLYGuv + z/sSdtD/SQNAOyFE6gGcODmEvoGU55qsYuI91fWg8ZHqmqwD+pJZ0Hy4VXa+VJg3FomIhlTO8nXNw7S3 + KA039eSX3tNmcS1CzMC00Y1YMm0UFi+bivdev2APIWQsAiLfpwqJqIFEm4GOtnosnDsO73rTfNtzPNKP + rXu6sHHHMby6/gAOHOsHz0lB9FTFFt566fSStn3be/AkersGivrCzyhZhoZMLg8rpkHLW25QMCM8J+Yp + y8uvvYDX8rO+94uRqfIruqcDnYd7MDCYlr4rQwhpBgDDeTlAWrmjfSnk8qa0EL9gjcqNCuvWqCDey8r2 + bS4RKy+fdXLK2OZR2w/1+tZZdU9Fl7DpZedM6C9cOgUrzp+ExfPG8xZ+RsWNHmE0JKJYMKMDC2Z04F1v + mo/ugRS27ziGZ17Zh2c2H8H+AyeRGs5K11/IaML+NyUiuPay0l793iAM78Q8+Yg/u66lsrASUTcQmNF1 + aHmrqF5+dZb1fSoWcRUKu8dPt4r5+OUXBse7BtE3kFK9LLcEAAxnBkA+BXiwGylByEoJUvi5e+w6O/cb + E8ruDaeySCZ9XZywGHX1silgCqCc9pSTXoaxbfVYuWwyLr9sFi6aP25E3fpTifamBC6/cBouv3AaPjKQ + wvpNh7Fq3SE88/JeHDw+UJRe1edzp7Zj3szRoct1X2LzyZ8Jt1ielsoi5SiBlDNTxM8MsHxYHmLesr6X + KRFx2lVFA5lR8TM2lqEhlTNxsndY9dmwFgDtBuxVQS2yFIe6k0XXgtz8Uu7xQQ8VAVTP5vIm+vqGUQ3c + eO08PPTsLntPgDLbU077kcsjURfFwpmjcf2Vc3DXO5Z1QjEbc66gvSmBlZfPwsrLZ+Hg25fihbUH8Mhz + u7B2S6drbFT0KvXV790HurFpT1fR9UBLGjFgGZor8CrrX86wUPSCmQzkdd3jCfjFmvi8VXKi5S2k+5I4 + 2ucdwnNosSyrxXACgNLxpDh9woNVWFw5xhokznHy0U1+sUMYhcI/w/K2TBMHe6qjAGZO78AtV87C9x/a + UHSPla2qv7iIQ0ynUnDNjXFcftF0vOOKGVh5+awk7DH9OS38IiZPaMXkCa1464q52Lb7BO7781asfWEX + juZMV+gYYqaJxYsnl5T/0y/tRb9k45AMIYhlnSXgCv6WeQUyhOEPXh5kaTK6DoOTFzdAKCgF8RyQKyFe + KRw71q+qequmaS2GKgA4MJgumj7hKyEKuHiMOQsaRAFh11UCwgJyfHn8M7zW3K/eALEkJKIGPnDbMqxe + ewDbD/XCMjSXAcPUnx356yydB7k8mtsacP3SSfiLW8/HvNljmIt/RgT0TheaGuO4eOlkLDpvPHbfshj/ + +8Q2PLFmFw70DiPmbOfV2tGEeSXs/NR5cghPrD1gL2CKRtAU1dGiEcSaEqhvjKMxoiEaiyCbyWEwZyE5 + mEbfgB3zSoWILfG86McfojyI/MwrglLPVd6F6y0QgiMnh6T1HxhMT2hqjE812HygiEzOxAmrEBxkgs8a + Kq5hZpUSrb64zpnXgqwRvNCnct4giSdKqhdWzQ0YBrbstNc7V2OcPHFsM/7uruX41Fcfw0CqsJOOqi2s + /uw/X0dPnQlBjFI0N8Zx4yXT8I63LuIFvwYOiaiBhXPHYeHccfiL6+bhf5/Yhsef2IKD6TzGdDRiVEv4 + j72ufmUfkoNpvPWS6ViyaBJmTmnD2LEtGNNaZ5eVsMf1DYloEkAKQGbznq4JB472Y+PGg9i83x4+9Cu2 + HhP5U/wf4/hFxkPMOPCGjT9nZajuhxl+xLI5dCqGAJGYAQCtSg9gMJkF7e53G5PXdWlDZed8o/mhgux5 + wyzWuHxDZN4Fq9PBo/3o7klWvCMww+UXTsPH/+Ii/PsvXkYmk5e2RdZel+CchmZoiuq4dvlsfOBti7B0 + 9uia4IcEUwS3rZiD//n9JrRplDFtKMyb3Iaf/uttGDemMYjm9c7Pnbm4YflM+y3YA914ZfMR/OnZHdi4 + 96TLEzx4/lDJh0oe8oJrz57JC4Isu68aWnoQMTDQPSg1komoAUrpfgOKAGBf/zBSOVvweevPGgSgyI1h + jefT8ASQPR8EvuGicB3vG8a2g71VUwCJqIHb37EM3ckMvvfbdUXjUIYM1wF8Z2SEjrlo3ljcedMSXHPl + 7Jrgl4nzF0zAN2ePQc9AuiQaKpbAhkZDIuoqoVuvX4i1W47goYfW4fHXDyNlWi5v8ENAfljA7jH5EBWF + yojwAUGgmOd5vmPn/JCVD15mCMFgKodcRu4lE0KuMmBvEFCE7uEc0tl8kXbjK8FXUFZh/prYEL8AIA9Z + UJFdz2RNbHz9EK5zVqVVA4mogU/8xUUAgPsf3oB8vrA9Fv92Fu8NsHNGl7Ft9fjgzUtw21sWVPy1ohrs + Pql0xWclaKuP4rqLpuLieWPx1o2H8e0fP+dOG/PgY0F+UAUHxbz4tAyMz1gZovBrectdbwDY73UMZvJo + apRWZYkBReQ5OzBsazqnwDx35CsDwB37imn4cUteyEcUGsuw4w1iYxj4SCnL0yQEz2w4hL9SrHYqF02N + cXzm9sswtrUe3/zpC+iyCktI+TbzHWVaFqDruPX8SfjgB6/AspkdVatPDWcGmhrjmOwsHef5VcbfAFzv + GSjICOCdLRL5mqXl5cRQKAlWPpMVJi/sGNEJsjkTmZRyd+gWpU91NGO5jVBpNVEh8NfZs+xc9TwjJAN/ + bhkajHxxXgwxSrHvYDc2H+jBZQvGV7WzE1EDd71jGSZPbsc37luDDXu6oGuap/wMcd7eIgSzRjfijvdc + gnddObOqyqiGMwdPPr8LX7x3DXZ29iHibOEdRj5kw0V2zqeV5Sfjez4dE37ZEQBSORPD6o1B1Aog359E + zqTQNeKpiKzy/DmLeouegsp70MB9Ly1vFaW1BC9CJEhfzsRTa3ZVXQEwXHfRVMyb3Irv/XotfvXnzUg5 + X0a2KEGEUOSphluXTMDH7rgcC+eOG5E61HB60T2Qwq9//zq++5u1ODGUQUQnjmxoRXzNn6uEWGY0RUXB + 0sv4nn/eosSWEWpv7sFkiIlVOpv3zGqJUCqA7mRhqyzL0ADquLkA4COUmqEhYwK6osHMVWbpeVfKMjSY + pgWTEOXzYpmmaeH3rx/Fncf6qxYMFDFxbDM+95Ercc3lM/GjX76MV7cdxUDWRH1Ux4fecwk+etOimtU/ + B5HK5rF+5wl85yfPY/WmIzAtC7qmwaKArpEiYQ/yhmV8LHtO5PEw+VuGZv+c7c9cj8Ew/LYGa1UqgEFS + PH6HrsO0LJiWhYhOkHEEVYTtHlFYhoacSW1LKSiBiE48wp8hBBHh+QwhRVqWKQld09wOObT3OJ5ZdxDv + e+vCEWOGRNTAtedPxoWzRuO5jYfx6JrduHH5zIq/S1jDmYdUNo/de7vwwJq9+O2TW9HfM4SITqDpBJbw + mUGNUJd/2XQ5uyYKpOgJ8MYQQFEcgc8rKH/ek+bLyuepZ7MXpgwSUQMDg+kJSgWgO1tDi1onwn2+KKIT + aHmvhuMrAsDVmKximqMUeGQIcfMV87coirQs076ms4ApD+B3j23Cmy6ZPuJR96bGOG6oCf45iYHBNF7d + dQJPP78bj6za7rr7PE8y4XMtNLWHqToAi9CC663rMGjBy7UMDRooLEpcIaaCtRatPlBw8VX5a8IXkjVC + kY8YMHJ55CMGijSWA6YIlAqApgpDADfYgOLMROG0KCkKaHhcHQpEuDbmTOohsHiN14R8HSxDQwR2+wwA + L+zswqrXDuBdb5LugFLDGxBBq0QHBtM42Wfvob9h2xE8v+skdm215/kBZuBsYWdeKwCXD3k+dQNwjkDG + HZlJ6zqiDs9qeQsa4FwrpHE9YUdBGKaJfMSARguzYKr8+YCfm063lYyRyyMWM5AczkqHAZGYoVYAPVZB + KJngyqL2AKQBPo1Qj8Jwg36CxopIPojIX2PxBxEy1+pnj2zAigum1ObeawAA7DnUi4ef3gYAMOrsGE1+ + OO3uddh5uAfHuwZxuD9dGJZSAoC4fMp4K0YpMqbMQ3WUgiAjTPB5AUvrOqKEugpBKUuc8AflzzyBPGyl + 4DHIEcOzjkUGqQJQBQ346GLRdQGeikuuM7DAIiNmXlEp9hwb98vKXru7Cw8+thl//d6Lw/JIDecwFszo + wNY9Xfjcj59Hf8+QMp2uaR5hBor5NM/ccH95QpoJKpeHa6xk+cLL75auAxaFBRIqf/asARQZYVbZnM/O + WdKtgE71slWe+EEl64rdixh+/sdN2Cx5B7yGNybe9ab5+ObHV2CK8xKQrmmgmgad+wHFglkuDATzsJh+ + RPM3TaR82iaVJuYB0ABhs3Mg3qP4X5XGgW7osIgGaAS5iGGnUfyk94X8d50YxHd+vRYDg1XZLaiGcwA3 + LJ+Jf/376zF7QgtMyyoWIAkfFR1V/8Ok54+ydBLeNtIZ+5oKIfNnXgHb2FX8+Up4PJ1BICxqF8iO/H9W + GT6NAGO4IKiJwaTnPMx9MX9d0/DIszvxq2d3B9e9hjcMrj1/Mr5695sxdea4wnoWBpGHZUeHdzVqARZF + jo3TA9L7yYfI2zzydXFE/N4pCJE/S5Mg6nFL8BCA12bSHIi3MqKw+wg/AKQaCwG7fF3cPWfECbovyz+n + 6/ifnz6PFzYfKZdfajgHcdmC8fjPD1+GWaMbURTlkvEtf13zjucjubz9PyC9NG+2utYJTMKiyMcLHwIt + MnI8/LwOUfE4iBjql+6UHgBpa0I6HrO1na4XuytipQS33OPSOOCvsTwipmnnzyrrnDNBD7ovU06RXB4H + eofx5Z++hL2St7ZqeOPi4qWT8YW/WYmpzfEiHnX53IF7n90DvO66c17kxsvSs7Qsb12HMZz2ypZznSkG + nu9ZHuxaThJ4L5I/oUwZlAqgta+wl1gkl3e1S07XEcnliyok/i9yXzRSEGaL2nmK+XPgXSKZK8TuSwkN + wIpFsXbDAXztgZdxtL8WD6ihgOsumoovfOJatNZHXX5k034atQozUxzfx/K5IqOlEeq1tKbppvfwt4R/ + I6aJVGO9e4/xMZ82YpqFMnNen4WXQQAe+fTAojDqYlDgpFIBWG1NdgyAE6xcxHArwirAN8AVWp+5EvY8 + X/lcxPCcM+K493W9SLm4HgIjjNNJgL3WIJLLQ9c0/Hb1DvzXD1ahe0C5O2oNb0DcsHwmvvCBS2wlEDGQ + MSKI5XOwKPHMNOUiBjRCkTEiRUJtUUc2+OEnJysq8MIuE3ye3/kyefnj//Ng+bj3NIIYlPKYUXsAiYg9 + LmHaTHCNWAV4wczXxYvjAew/13BZ5SO5PPKCBuMJkRhMFimCnLNCS6OWh+AZI+J2HI0YuP/pnfj6r9bV + ZgZq8ODtK+fhrhsXe4XP4RvmBWiZLCxKEMvnoBGbPzVqubzH+HhYNzyW3xVUNh9vUdfl5wWf8TW7x8b/ + LI2oSIrOufl+91zAqHr1dyGV04DNhLqCzms5Jry8C2IMp5EDQU7XMRyJuNeHI5FChSxqp4kYIM6zuYjh + eg65iAHK5ceIw468R8Dft2JRZAz7NSJ2BACSyyNLC+OhHz28AV+9/wV09SRRQw2AHez+2NuX4I6rZwGA + h4+sWBR52ENJ5iGwd1jcBT4xW7ByEQN1uZz7n/docyjw4EBjA3IgngA242vxyORCtPiu580Pw8Uyuf8N + TQmYam+kVzkLYDQXXGy+UN5yE+c81VjvEqAul0Mkl8dwJOL+54kUyeVBHSXA5yVOgzBisPz5slnElBEr + ls+5+TEFQyOFdc5axn4b6od/2ITP/89zOKzeK72GNxgaElF87INX4Lq5o6FlsgUX2jRhOF5vLO/wrbAu + hkhc8ByIR2bqTPuYGEwiAoo6M498POY+mwNBDsTlf96DyMdj7mwFL/CE43P2Y9cjpuleY882JSJQoE9T + ucXjmuNuoTJNk3MEzI0DaMSTvi6X89VMlNNKqcZ6j4X3jP+d/MV8gILSyBgRT34GvAEU3bDdLhox8Miz + O/FX//FUbbVgDS4mjGrA3R+5GlNnjity0YHCkNKAVxANoIjvI6DSITIL+DG3nnJyUmfmPQFBoCArNOKN + j+U4w2YAMDQC6siIodleOHWeYzJR57OyV2tqjHfKbsTrooBGXO0iWn5WGaAw/hmOFDSNJ6gn5CE+D8Cj + AV23CYWpEZm25RUF4ToGDiEAeaDltdcP4a5/f6rmCdTgYtnMDtx9yyIY9XHkLerlG45fPYFvZwjL+J73 + Uoui9ADyQnCc8PEDwM2Lz4eXFSIMvfPwTgvyfM68gNa2RjQqYgCU0gMagH2ymy1NCTQ0JVwtwk9HUN4V + AbHdf40gguIgCHuWDQv45/k0/Lw+y4cfQrBhA+AdLhDuPh94iZimpxMZgYZ1WzMundyClubwH5qo4dzH + jVfPxu0r57quP0OO4z3GU7xhrMvlkAPxxL9kxo1yyoPk8gUPmpcbzoNgz/A8zg8DqFAvt76OFwAA7Q1R + xCLyhUCEkF71LIDkIwzMyvJC6br6DlFyEcO13HzFePeIJ6wI1wUThg88AXnL71FGfN6cRuS9hwgozp/Y + jM/dcSkaEuroaA1nJoZSWeza24UXNh/Bi9uPVzWom4gauPvtS7BkwUSPtWbDR6DAnx7D6BitOlP+Fq04 + pc2eF70JAFIDyhs3BoO7x/IFiuMSdfGI8oMqlNIDBqX0ACFkuXizuTmO1rZG9PUddwsSvQFR6FzL7gh6 + wSI7Vt3RnkVHIbIpTmV4NKDCtZetLGT/eSXR0lKHv3nfJSO2f2ANI4NUNo81Gw7jvlW78Nr6/e711rZG + vHPFbNx+7Zyq7APR0VaPz33gEtzx5W70Ju3gcd6igM5NzYlz9859fmqPF3oRLD9AWDwnGjHYcgN4jaUo + dx55EozqqLqI8u1eQkifRgiRrpWNRXS0N9gWkkYUGsTvbSXAExjhG1t05IOEnPfA/vPKx73HuWGq1Yiy + OdG3r5xf287rLMQDT2zHx/7jCTy5ait6k1n3t2/vcXz1py/ikz98AZ2KD2GWissWjMddNy52z0Ury8CG + lHzsC4Cv8PP5MagWx/FDA7/nh3XDnYbnkY1EMKm9TlqHgcE0KKX7NUrpAVmChkQUk9vqkHUaRyRBQPG/ + Cnxgj/8vA5tOFP/LysxGIsiBeKZCVCC5PGbMn4RP3LIYNZxdeGrdQXztZy+ir2+4iPnZ+ZOrtuK/f/mK + 3w64JeGD15+HC+eNC8ff6pV2AORT3DxEBcIjF2BkASCay0nrEAFF++gm5XOU0n0aIWQfAGkNW0Y1uhlT + iasv/vdrBO/K+BFMFSOgiqFGBFTqIYjQWxrwubcvOq2fmKqhdKSyefz68a1S4edBIwZ+/fwe7N5bnend + jrZ63P0XF6Clpc43XZDwA8EeQZg8/OBHl0ntcn5vaoyvAeyVgPsB9MkSTe04d/bWu3nJBFxTxW8I1nBq + cLh7GM/v7XE9UT/0JrN4fsfxqpV97fmT8faVZ+cmszkQtNZHMc7nk+qapvVplmX1AZDGAVTaw+LeLzaj + 5UXSy32OPcs/b/m87wwAze2N+Pg7l9W+0HsWYiCZQWYg6bGSWV3dj/u7qrvU+64bFmL6pPaq5snzrx/v + WoZetpxEcznEmuoxWu3xrgYATdO0Pig8gLFjm9EqWUTAvgVgGTp07rPfYiNFGPWFr+eonpM9K57r2azn + eS1vepjCMnQPYT983VwsmFH7WOfZCNl0dNTMK5XAqCqv7Zg1rgl3vnluYDoZv4uGigfjXy1vFvEr+6/l + TamchFUKk1riaKpXvgrcAqBbA9CtCgRObqtDa1ujJ2jHCJ/VDVcR8J3B/vMVZxXOJ9Oe52WNyeoG9GzW + UybLy+8Znim0vOnWbfqkdrz/zWenG1cDMKolgWkzxxYFjqPCnHtWN2DUx7F4SlvV63DbFbNw4bxxyOqG + UvEwHuV5kxkq/pkcCEzTuyWZJuzam3deNpLJFZMPFdx0kQhapo3z+2TdRsB5G9AJBBahoSGGSaO8cQBG + +Khk0QMTRPafVwYi4Vg6Rgzxvhs0BHHvsWfE/Pg6ifnc+ea5tcDfWYymxjg+cNlU6Nwe+jxvsSMxTVw+ + ezQuXVj9j8R2tNXjjpVzYRDq4W+xLoDX8GUT3gAiz8fiEMDMF5QCz8+isRPLF/PmcZ6h/ChoklK6Hyi8 + DrxBlioRNTBzcptbUcvQpVZYVApMEfANkCkOXmHoulZ034xGXUUgUyBmNFrECPzzM2eNw21XzCqxu2s4 + 0/D2lfPw4Rvs7z7mQDx9HDXtaeU5k9rwhfdeMGKrO6+9ZBpWLJygNGSARAgdZcAMU9TMu/zMFAWz9tSZ + wy/ykB0DKZMbpnx4OWJHLRrBvHkTVM3po5TuAwoKYL/qrUA2E6DlTeQpcQtmVphXCLwQitafVxiiUuDz + Y+e8q8OUCX+P5c0TVyTeXdfOrn0l6BxAImrgb991Pj77Fxdi0rgWALbFB+y40luXz8J/f+baEf08e3tT + Au9903wYhBYJoMiDMjmQWXN2XTyX5QnIjaAoG+zY1hjDlLHKNQD7nNifvaTYsqy+psb4ZgALxJSzJrUh + UR/DcDrvVsbgthkWtTHgCDjn2kfNPGByVpob08ue5/9ndQO6rrkKwiUkN2ySEWvmrHG4+dJpI8YQNZxa + tDcl8PfvuwjvvHIWXtt2FAf702ipi2L+lDYsmjHqlLzXccX8sbh41mg8v9NeayB6vCI/szTidTMadY0b + GwIYjmdgRqMwLJu5dV0DzGL+5pUQXz7vBbTXRTG+o1HaDmf5f7ddLgBN0/bAXg9QpADmjG/GqKYEjiV7 + YRk6ovm8OxyI5gsV8wioaRWNY5i15gnA7kWzWTtialrQdc1zzpQHSwfYbpHu5MPSRM28WycAuO3SqTXr + fw5i+qRWTJ/UelrKZrGAV7cdBWALL+8V87zOwPMtC25HnKMWjXhkBQCsbGFVn5XNweSE2zJ0GKDQ8iaY + umM8z5ebA8GMKe1oSSinSzewP5rsIo+W5gTmjLU1SZ6SoukK1mgzGi0INDc+5yvG0vHnuiPsAFxFwp+L + zwC2ZnTdIc6topodo5g+qR1vv6Rm/WuoPlZcMAUzZ41zZ8EMQm3BdI4M4hQgO4+Aeq4zbzqrG7AM3b1v + Gbod+OTSankTVHNiBYk6ZBN17jmTG8vQQXUdiyc2+70E5Ab9AxVAQyKKmZPbPNMweUrcqQtXiE3LI9B6 + Nuu67nx8gJ0XpeViBeycEYq/J+YdTQ27BGFKYsX5k06blajh3EZHWz1uu3Sq8j7P0+xc5H1imdANzTMM + YIqA3Wfg+ZvxuBmNIpoaRjQ17BF89pxBKM6fNVpaPyfW9xg75xWAMhB40dyx0KIRRM28R+vxjWL/GUTr + XnTfURjsCMAz1lcpAtXCCEaoMXEN77pE3UE11FApbl42CZNHN0qn3pggsiPziK1sYUqOrVMxo1FQTXct + O9XshXVU0z3TgtlEnSvwTAmwKUZ2no/E3HzHdzRhxjj56+7OOwDu4gBeAaxlLwiImDOlDW2NMY8lZxDH + 87xHwCBdJOEIOzvy+fFDAd7iA/AoB9dV4ryMC5ZOxbzZY043j9RwDmPixFZcet54dyYiCGY0ao/3Hf7n + LTZv4JjC0LNZd92DZegwcplC3C01LD2yNFndwJyxjRilfgdgA4BudsIUAFvsvFr2xJRR9VgyuRWmaXlm + AACvS++5rmteN1/XilZAyaYGVfmxNJ6ZBvFZXcMtSyfU1vzXMKJIRA2889KpSNTH3Hn8IIjeK7PwvPCz + Ix9L4L0DqnnfDWDn7B4bls+c3Ba4AtDNn/2xLGsGuLEBDxYHkK3+k7nnYqCP3fdLz66Vmh8jmmlamDWm + ERcsnVzFrq6hBjnOnzsGSye3BnoBYgCcDQW0aMRznwXzRKiGvyo5qYsbuHaRfAGQM8Rfz19jCqBb07Q9 + lNIEgJOyh6+YOwZGfdyjbfKRmOvuMxdFz2ZhcquYiGUWghrc8IClZ/f5cRP7z2vCrG64+fHnPBbPGYvp + HbVlvzWMPNqbErhq8UR3BV+eEuQpceWDXeMtPAv+8TLBW3Te2vMRfwZmCMV3B9yhhWlhVFMC8ybLA+DO + EH8/f42PAbQTQp4EsF328Lw5YzGqKeEKnRmNQjfzdoDC8QzykVjJ1wF4XBwe7D5gRzYNQkE1W0kYhELX + Nfe5uriBm5dNPH0cUcMbDlcsnojGJnuszQ+N+Wg8g4zH+f/u0JeTL97A8fEDwFkLI3nHZuGMDrSr179s + ADf+B7wKoJtLVITpHQ1YKLxSy09XUE2H7gg2sUxEU8Pu+IS/LqZnAi0SJR+JwchlPPdkhGPEmDq+FUvm + jq2wS2uoITzmThuF8ya3upafBaqppktjAzI+B6CcLWP5iXBjas6RHxpcObdDFQNLQhLjk5WwGootwq5Z + MA66rrnRSyakYiAD8L4J5ZeeWF5Xh50buUwRoXhlwa6z84VT2mpv/dVwStFWH8UF8wrvHzB+ZitaZXwt + 8rs4rc0E2w/iM8xb6GhJ4PI5yhmwPsuyNogXixSAk6hPlsMlc8egrTHmjm2YBWdg/3mrz85V6UVrzueh + yltMr+sa3rJsUtkdWUMN5eKaeaNRF3c+4sHm8iWWW8W/fpuGqKBKP2NiK6ZNUe5etN5Z8u9BUU2dROtl + OUwd34yL5o3cG1flwDQtTGivx5IR2AiihhqCcO35k09OHd9aFJA+1dB1DdctnqB8KYpS+ozsuurLQA/L + LjYkojh/ertybHK6sHBGB0aPqr34U8OpRyqbH7XwNBsf07RQVx/DZfOUMbBOSunvZDdUkrwegPSjoW85 + f5K9KjBga6JTicUTm2uf+arhtCARNXD+vLGn3SieN7kVC9SKyH3/X4Sq1muhGAbMmNRqDwOEyCWAwvy/ + XtpKPNlz/H/ZTABDXdzAeSO4EUQNNQRh8eRW1NXHShoGVENGXESjuG7xBOXqP0rpwxCm/xiUtaCUPkMI + eZt4PRE1cM2CcfjD2sP8nhzQzbwb+NMlKwZlDRLT62YeWn0cVjLtySMVTyAuRj6d50c1JTB/8pn95t/A + YBqDmTwyqRx6M4V2xQgQq4uhoS6Kcc3xZCqbr68tY5ajJ5mFmcmhL2NiIJlxr8cIoNXFMH9c08meZHZU + IqKd8qXgs8c3YdKoBmwdSBXdY3zK+JqB5+90NOryd1B6/jmWtqMxghVL5UHwgcE0mhrjq1R1V1KKELIK + 9jCgaF3hNYsmYHLL6zjYlykSdl6wZecyAvDgG82Ik0in3Ogpy489P2dsI8Y1K9c9n3Kksnkc7h7Gzj0n + sO3oAHYeGcCBrkEcOTGIlGkBpgUtnYFVX3hZo6O5Di0dTfWT6gzMHt+ExVPaMH/6KLQ1xd+Q7zWksnl0 + 9ySxoXMA2/d2SWkIXSscAbTHjFFtk0aBp+GMaaMwrnnkaVgXj2Dx6Dps3Vt8j/Ep42uZPMSzWVcJiOkZ + ZM/pZh6mbuCi2WOURrCpMf4d2B69FH6UWUspXU0IeZ94Y/qkViy/YCp+8eQO1yXRzTxiEQ3Dll3ZOs3C + sKW5leQrrCIS03p8+ng2i2gsgkzOconE5zFzctsZISR7D/Xi8W3H8ez6Q9i0pwsnB1IYtlQjLAMYzLlt + 7OlLwdzbZc8BO7RrGdWEK2Z1YOW80bhg6eQ3xBLnXUcHsH7TYTy0vhPrD/Wh7+SATcNs1t4Yw3kr1O5/ + x//MpoBoFF3dSeBkwQLrZh5jxrVg6aQWXLNgHK5ZNGHE9ohIRA3MnDEaWHcUJiDleVF4GS+Llh6A9Fnm + FeTS+aL8r1kwzk8G+vzq7is5hJDVAN4nu3fDskl46OltAOAyOhN4ABhGYcyisvZ1muURbEYI0T2KUe/z + OV1zXaapk6v71ZZSkMrm8cLmI/jNa4ex5rX9ONiX4e5qqNPsMWEmZ7l04DuOwdQN6Ch09jAMDJ8Ywv+d + GMJvnt2FWWNex4rzJ+HGq+bg/CktZ4TCqyYN1+88gUde2oeHNxzB8aN9No0coZ8/sRnTxjTi8S3HYAlu + sKkb7o45uq4VCd+RE0M4crgHj72yH2PGteDmJeNx8/KZuHTumKoPt6aPa3aNHoPI91p9HHAMnGvIHJ6P + OPEDfjjA8mB8YSXTiNTHYSULHvCsMY1+n7zrBPCQX719KWBZ1ipN06SbhV46axQWzRyNV7cdgw5v8IN5 + AnxH8R4Cu55xlDhrcCyiIReNYjhnudfi2SyYWPHXAKCuPoZZo/w/3jgSYIL/oyd24NktRzGY9gYp6zQL + N146A231Edy39gjM7iEPM/B0sZVgvigmwiuM7Uf6sf1IP+5bewQ3z+3AnW+ehyXT289qRcAE//6nduKP + aw8WaOi0e9b4Zrz9uvm48ZKp+PJPX7Ytn/OsOAwEbN5hdPTQ2RkiHDncg++dGMLPn92Dty6bXF9tGs6Z + 0ob6eASZwUxRwM5VSo7ws/M6zXJlgLWlLqLByha8YaYQRCPJsOL8SUrv0PHg9/vV27f1zqKg1ZAogPam + BK5ZNgUv7Tzp0XymbmDYKnQUg+q6bubdxg1bGpDOI8KlicQNWMl00fDAyGXQGjcwbuKp9QD2HurF1/+0 + DY+u2V0k+AAwb/YYfOmm+bjuoqknr//XJ0elu4c8bRaHQcOW5jKpKjLMppjS3UP4yQtJPP36Ybz7mrn4 + l/ddcBLAqFNKgGrQsGsI//PwRvxmzR509aU8+941xnXcuHwOPnHjAswf14RfPb4Vj2855tKHCYo4HBy2 + 4NJRpKVu5t0yBtMm/m/VDpeGd71pblWGV2Ob4+hoa0DPYEaZRlQMw5aGXNSwhZ7xtiPgwzkLcRQ8A9FD + MHUDHXU6bvLZ+5JS+gW2+68KgeqPUvrw4FDm47IphndeMAn3P7UDR04MhSKSLAbAa7iIaRVZv1w6j1w0 + irigPfOUoHHKGExuDP5qbDWQyubx4KuH8N0H12Pr4f6i9jTGdbz/yhn4xC2LMWFUA77/8IZRL7+2DxAE + 3y8eooqR8M/UA+jpy+F7v12PVfv7R33p+lm49vyzYw+EVDaPP71yAF//7UaXhrzwz5/YjH9634W4dqE9 + pu08OYRvPrbdM+41dQORuAHdsY7NNI9hSytyv31pHo2iazCH7zy8CU+vPYi/fftiXH/RlIq8gbp4BC0d + TTBZu7g68K6/rI95q87u8VafPc9khOUzd9EMLJ09WlWlToRA4OoFQsiTTY3x38vuTZ/UipuX2J9iShP5 + ziiReKGxWn2xEmENipgWInHDdY14ItVFNM95Tteg6xqmGtYpWYBxtD+NL/70Zdz989c8ws8wfnQD/vOv + LscXPnAxJoxqwN6uIfzkmb3KdQ38eU5htVTn/G/7ur147w9fxjd+vQ6q/RzPFHQPpPCfv16Hjz6wriD8 + HN59+TQ88OkVeNuySa4g/nLVTjetp//TeZdnco4CkQVcRfrx/JfT7XjV1sP9+Nh3VuM/f70OPcnyF7Yl + ogamttvDUV4WmBFTzeNHTAuxiFYkG1p93JUNvr18vn9x8SQ/pXWfbO2/iLDS87Dqxs3LZ6KjMYI4td99 + 5gUesDuLYThXaECdZrlp2ZGlZZ0pXge8LlBza/2Ij4P3HurF3d9/Dt97fCeYO89g6gYumT0KD/z1ZXj7 + 8hluXR5/YbeUyWVwXTyBbnWahZyuIafb1o2d62YekbjhKsvciT586dcb8fe/XIfOk+E8sVONvV1D+MT3 + 1uArD28pomGdZuHjNy/Ev33oMk+UvvPkEB58cX9g3jxvyOjIX+PTMuECbH77ysNb8A/3voC9XeXTcGq9 + Y70pDUzLAsSsfLEd4rmIS2aPwvUL1Ut/ERD8YwilACzLWgVgs+zekuntuGZRYSMOXshF8BqMb7Sqsbl0 + 3mMhWR6s42a0juz8/9rdXXjvD17EH9YeLrpn6gYuWzoJ3/vIcpy/oLBUoieZxf2vHlF6REVt1DWkCXFp + wJh12NJsr8i0XVt2no5GYSXTRTT7xZM78Lc/erEiBh4JbDnUi4/d+5KUhvH2Bnzq3Rfic+9cgjbhM/SP + rjscWonydBPpyF9jQidTEgDwf8/vw8fufQl7D/WW1dbmjqZQ6SJxw2eKmGuLj3d765Wz0N4k3/iTUroa + PnP/PEIpAMeVeEh2LxE1cNPyGYjEDaQJKQQrHAFgR1Vjgq6z/Ng5L1iNY0ZuBeDa3V342P2vYtvO40X3 + 0oTgsqWT8N0PXVI0t/zi+oPYtvN4kRXg680zYMS0EKfUbZ/MovFtd91CSeDwwXWd+Ni9L50xnsCWQ734 + zA/W4OkNh6X3v/iWWfj7WxcVeXFDqSweXnvYV4mKQjyYMZEmpMBvzLhw/MWETmVw0oTghfWH8NEfrMGW + MpTAjJa4m48fRCNZJCtMiZnydPMnNuPG85W7XyUB3B+2zqUMoB+CIrDwtmWTkhcKrwkzAdA1gpzuWC9C + XLeW/SKm5WFw9uMF3xUOXXOFJRI3MKF+ZNz/LYd6XeHnO5PV7epZ7fjPOy6SRo9/v/WElxGduscpLbTf + 8WxERSBDLp137+maN0/mPTDoGsHTGw7jb3/0Irp6pHu6nDLs7RrCZ3++Fqt3dbttZ3XO6Rr+8T3LcPv1 + C6TPvr7nJNYd7PWk59sN2ELE39M14v7466ZFPfmwH89rDIy3Vu/qxmd/vrZkRVpfF0W8vcGj/D2eCFd/ + vi6szuw5WXvThLh0vOWKmX6b36wihKxHSJSiANYC+J3iXv3Hr5iKxpjua9FlYyOWfjAWha7ZjYw01Sm1 + qCtQoIjEq/8GYPdACp/9+VqP8PN1md5Rj6/ccQlmjSt29/Z2DWH167aOZJ3K6pwmBI0xvXBu2MEdlvdg + LOre45mUP+fbzyAyvK4RPLiuE//8m41IZYPfyRgJdA+k8Lkfv4inNxx268fT4/YVs/DRlbOV8ZvnNh5G + n6DA+PaLNPDjOb5ckW5MoYr5MkX6xQdeQ7dkfb8KsXhhRor1Zw/19pufW88rraKhryMT08a34MbLZ/hV + Q/nijwwlhdCdt4qkXsBVyybjwnnjYFrU1ayMCCJRPA1zxrmNmSzShjP2GRhGnFJpeh4T4tWdAUhl8/iP + R7fg6Q2H3bJ5pdXSVo9/es8FWDazQ/r81oO9ONA9bDOdJA40nLOQNgyYFkVjJovBWNTt2MZMtqBwGB2i + BYZi10TIytE1gp+s2oX//MPWqtKnFBo+uK7TK2DUZuyrFk3A//eOxco31wYG01h9cKCojbnguFpFSBuF + KHvaMBCnFD95YT/+49EtofNoqo+hTYenP91+Ni3XGwlCLhpx6+MahgH7y1d3XjAe80cr975YA7WRlqIk + CSKEPOkEGIrQkIjiw1dMQwu3I2ljxjutEs8XWyTWwMFY1CUWQ4T7nFIRkeoTIFWeAXh09U58e/Vet+68 + EkoTgg8tn4b3X65eePHi9uNuJ0ckDkzaMDz5NmayHmUXp9RNI9JLRrscLS6HMZppUfzH4zvw5y3FMYyR + xJ9eOYB71+wrEn6NUkzvqMc/37rQ96vNh/pS2N/pHX9HiJyelYL1lch78Xze/X/vmn347ZrA2TQA9nQ1 + jUTcPPl+DjJmDIOxKCLZnPsMbximjW/B26+Z6/f4T1CC9QdKVAAO7lfNOV9/0RRcO7XFPZe58aIl4xvK + 4I6FohGXoXnGNi2KNh1IxKu3CGjLoV788592IjOYguW43sOa5iqhpbNG4/95s5r4qWwe6w72AbAZi1l6 + 1l7ek/BjCp75ZODpoFFaRE/m9uoaQU/vML7wy7UlubGVYG/XEL722A709SRdi502DESI7ZXcccMiXDrX + /7Nt+04M4UD3sN0HUXX/qjyiUu4zOsXzdkwmns8X+M3p976eJL722I5QsytRTulFsjl73M4pbl0jHp5Q + wY0J5PMY1uz+tAjBnVdOlw49HWxGidYfKEMBEEKebGyIPSC7l4gaeO/KuYg01SEXjbiujNhgRoS0Ybga + bzAW9XgDvJDkohH3yJiiPxJDrEpWIZXN4zt/2oY9R73TTmbEWafQVIcv3TTfd9fh4XQOfV2265qLRhDJ + 5tyj2E7+mItGpLEGBkYnRkOeDowWvLClDcN1mc2IgbW7u3DvU7uqQ6gA/Ojx7Vi7u8tTLz2XR44CVy2a + gA9fGfzJ9i0He922smdZm/j2sXus3fyRWXZe2HgaiveD6Lt+1wn86PHtgXXXDA0tznQme5bve9OiHp7g + y+fryl9neSyb2YH3XzHdr/hvo0TrD5TnAQD2NIP0C0LXLhyHm86fhEg2h0g2Z2tVR5syzcqIwO4xYrF0 + zBtgCkHP5T33AaAJFrRIdYYAz+7qxm/X26EN3t1k2vum8ydh+RL/j44c609jb8r7bgBrm+vSc15AYyaL + SFOdp/0AN/53xsx6Lu+hoUiPeD7v1pelBWzhZ//ve3Yv1u7uqgqtVHhx+3Hcu2afWw+N0oICJcDH3jSn + aK5fhv1dQ4hkc+7zEWLnx9rD2u7J3xGoeD7vETLWh7xFF+8H0Zfh3jX78Pyuk751J7p3x1/Wr2zYJxqG + XDTi9pGukUKdKfWUHc/ncceV0/0MUMljf4ayFIATC/iz7F4iauDu62a6sYC0YbieANOq8Xzec40RmxGG + Cb7baRGjSFCqhVQ2j289sgk9vcMwIwbS0VjB2kRjaGmrxydWTA9ccXisaxDJPC1YP95CczMd7F6aEOQG + hovaD9gMY0Zs2pgRw0PDeD7voYdowZjLzf6bEQM7TyZx79Mj5wWksnn816q96Okddq+xvjQjBm65cjau + XRi8bVsqm8f+7mHP82J7mODz93lr606Vch4ozzfi/SD6sme7hrL47pO7fGdWqFlsAFi/i0Flvv7xfN5T + T3EIuGTBRLzzkil+pCt57M9QdhidEPJNKGYEls3swIeWT/MQgXkEADzRUHad18riczKiVgtPbTqK5/b2 + uJ0Oy3Qti57J4NpFEwPHrQBwNGW6kVqxzWnDKLrGmItd5/+zoUAkm3OtETsXvSg+TzNiAJpeNOSKZHP4 + 7frOEfMC1u88gUfWHYIZKQgoq2NdPIL3XjQx1JLtXCaPfot4LCRrj0gn0SCIvKXiE/F+EH35/4+sO4QN + e/3lTEvE3LxEz5bFBcT7fJ1EGYg1JvCPb5mtXPWHCqw/UIECgP+6ANxxzWxMn154U8ljEbmOE6+L/8Vn + vGPfyoIAqWwev3jlsCu4oocRa0zgvReF+95g0ix+Xqx/JJtDtrGhKA3P3OLR5IY5QTRhCkxELhpB11AW + v335QEX0UuFnL+zHcFrehiumt+HK2R2h8slRit6hjLcvnPaoeIa/JjsG3Q+iL/9/OJ3DT5/1nxHoMQse + hqxfVTIgu5+LRnDT+ZOCvKdvoUzrD1SmAGBZ1regeEdg1rgmfOr6eUq3XWXh/cA/MwANer4yb2Dv8UE8 + 9fphaR31XB4LxjTgshDWHwBoOlPU4SJy0QhIpvC+uJhe5gGpaKDK3y/NbzefqPoKwa0nkli17YSyjjcv + m+j3rXoPspSAprOheSKIh8LeD7rGY9W2E74zAiRVmCGT8UEp/N7REMXd1830856+DMn3/kpBRQrA+aT4 + T1T3P3LltOSb58sFSKWp/SCm7bcq8wB+v/kEuoYkr4BqOsxYDLcumxgqcAUA/SYJ3RaWTuYNqNoadD1M + mh2He7Fqb3kvuqjw7IZD2NmTBrhPXrHyOxqiuHLh+JLyI/FoyXQMolUptAwqe+fJJJ7YJh9KZUN4pKXw + +2feNEe56GxgMM2+9lO29QcqVAAAQAi5D/Y4RIb6z71jCToaHCESvotWLnLRCMx0BjRT/vvbqWweqzcc + kt+0TNRFNSxfEJ55m3Vacvt4b+BUYdW6g1XN79k9vbabLhl6XDhrDKa1h9+yLUpGeLlflfCMs0MRYPMR + +1m5PGg6W6TYy8Elc8f6Tvs1Nca/Qwh5stJyqrGWthv2OETqW14+axTuWuksoGFMIgoKf+53T7jWl1Z/ + MCQIe48PYt0xtTu8YEwD5o0P93onADTUxwp182tPUHtlKCW/gPSr9/VVbWFQ58khrNupXml4xbwxJe3X + ECEErQ2xYBrw50Ft93surMIW0q0/2CulIc2bGIBWumIX6lIXj+Af3zIbbU3KodNmZ/hdMaq1mP5BSulD + qpufXjEdl8zlNi/grYWme89FJSH7KpBlYigPDGXLVwBbjicxNKz2IJZObgnt/gNAR0sd6qJawRqq6h/U + XhFh0oehp4NDJ4ew/Xh14gDrD/Ri58mkVKjq4hEsn1nafo1NjXE0axIvQGwTfy7Sl6ePzDOxSuQZSdmH + Tg7hRcmagF/tGsTAUIk7Mwn1pLEYPnn19KDA37fD7PYTqvhqZAL4Twt2tNXjC7cs8A4FeK3Hn4vXHdBY + zHN/mBIke8t/733DgV6k0ll52ZqOxVNL++DjxKYo6utiwfUP0V4aE6xgEH3C0JPRLWth0z7/BS1hseUg + F08QLO+kUQ2Y1NFYcp5T2+u8dPCz6D7tDHVfliaI/gCGsxa+/LtN+POW48hl8shl8nj09WP4n9++huF0 + zn1ePHp4QZY/gEunteLjb5O/Ju3g96hg2k9ENd+mWUsp/RYh5Ouym28+bwzuWjkX//aI9+0qGjFsl4lp + Qv7IEchNw+HEcHmzAKlsHq8f6FVa3bqohmkTSttsZGxzHG11EXT1DEndTk/9LRM0FvO220kHAMSZm2aM + 4ksf3tPwc2m5Z7f0VuejrhtVQyjLxNSmKDrqSo/5TJ3UDlj7iujjnvNtVrWxVHDWl2RMtxwl/QG8cmgA + t33rGSwY04B+Ezh4MolUOuvWUzwW8s8UnQO2x1Rv6PjHt8xGS0Iplp2U0m8H7fRbCqr6Pq0TEPy96v7d + 183Em+d6d7H2CIZsXKcY65FMBgcHy1MAw+kcTvaovYemhjgmlbhVdHtTAlObJEMGRZuK2i2hAcnlg+kj + lqMC9+zuvScq3isglc1jf8+w/KamY2p7XVn7NZ43ug6JeLSo3SSXV3pXDEWWNSSYp+Epw4/+DoazFl45 + 0Isdh3sxTImnXz1HWRucc1bnJNVw18q5Qa7/fdUI/Hm6qpqZwQ4I3gPFUKC9KYF/vnUhxrZxkWHZWDnM + fwC93YNlVTKdNXEwqRaA5riBMWXsNbB09phixvSpfygE0acM9FsEqVz4L9nKMJzO2Yt2FIpnapl77U+f + 1IZmMRAYxA/OkeTKU2q+z4UM0pJcvtgDcTyXonrzZTsK4ob5o/GJlbP8SlkDO9heVYzEntprAdynunnp + 3DH45+tnIxHVQSOGTaSI4dHeNBYLdX1/93BZlqwvZS/5pIqXiVobYoiE3NSTx2VTW5CIehlGVX8AnvJl + 1wAE06HUF6IsE71DGaRSlQ0D+jMm+n12rm0uIYDKY1pLDItH13kEqYgfOBqKNC4XPC/yR7EsN62kbBnf + smGAp958/gDGjmrEP711jtL1d16//xYqnPOXYaQ21f8WfIYCt189Ex+4cILHBSKZjIco7niYXeeIzMZR + +wey7hLUUpDO5JEcdsZhEiFs1igisdLd10UzRmPyqPqCYLKxJf9fHCM6afl2yhRjEX0kUDGq57qm+wpu + WKTSOekON6w97rRoiUhEDVw9d7Sbj0sbQaBcwYoYNh+pBBhq5aoqw5M/Z8E99HfOxX7xxCqAonp7yo/F + kIhH8YVbF2LJ9Ha3/fwPAJoa418G8GDFnSbBSG2qz4YCSyH5vHgiauBvb12EjV0pvLT9mEtoWfBEFkxh + xOsZzuG1QwOY1GF5FgURQwfNm0X/AYDEoth2vDD+dwNuDiMBtou89/ig+7wMNG8W3aN5O/i143BvUZtk + wSDZNb59Yeggqz9jdHYuurimRbH5eNLeWJOru6q9Ii2jho4dB3qKlCgbM9NYDJ0DWew91AvT0FGSitZ1 + TBjdiHpiYThreRReUHCNP7rXc3kPHXg6uW57BfQPUx8xf/7/B9+2EO9Z6jvu/z1GwPV3aUpDfMSgAnxo + YDD9Q9Va8Od3ncQ7//sFHB30uqNFjCzRngyj6+2llfwWVAymRd1dWPj7pkVxIplzy+IZmEYM1BGKhrqo + NF+Z1WNlAEByOIMk1bz5CvWXtSdMGmk6Sf397rFjfSKGeu7jFCJ9ZOdmOgM9HiuioazPRkeo57NfIr1U + /cPoyOcdlibKo9B28VgR/SWKx+8ajxvmj8YP77rI4/oLgdNOADcj5B7/5WCkFUA7gE8B+JwqwQ+e3Ye7 + f/aqLTRO5FTJ0IoO9kvraSzreJ974rUgFDGSn0D6WDDfeodIJ5bL6uZpt2AB+TSquvspXz/aiTQUy5XR + TyaY0rZK6BFUN+UxpHIO00/S8hX5zZnYigf/ZnnRUmmmAFLZPOIR/W8JId8ILKQCjPSH9boty7of6ncF + 8JErp+Fv3jIPANwxHQOvnVVjNJfIXFo+DX9NNn5mLqLoGrJr4viRHzfy18Tln2KdgsaYsuWjMlfTzZtT + fCrB5t1fHmL9xTSy/Pj6iEex/X5LYWX0U0bIuSGFmKdIt6K+ltSDVyzusVL6S8oLStfR1oAv3rbII/z8 + mB8A4hH9gZEWfmDkPQCbeJSuJITcD0k8ALC/BPNX96/FL9eG+qBpDWcowlrFNzJGRyg+c9Mi/M213r39 + Bdd/jWVZd1Rrua8fRv7TunC3EPsWFC8MNSSi+Po7F+ItM1rKnsut4fSjJvzBeNfVc4qEHwA/nd1JKf3i + qRB+4BQpAABw3Bnl+oAJoxrwL++7AHNKeAOvhhrOJrxn2QT8y1tn+yXptCzrqlI+7VUpTpkCANwdhJTr + A86f3IJvvX8Z5naEf4e8hhrOBtwwfzS+duv8ovUlwpz/fY7lr/qCHxVOqQJwGncPFNuIAfZLQ1+8bZE7 + vecionuPKpR6P6545zrus40Vf09VXlB9g+oZVA/xeVl+/LV4yE+pn2r6jVT5KnqEpbsfSmzbxfPH42vv + WYJ2ny8iUUofwAjO96twSoKAksb6BgUB4AcvdeLuB9YhmRqhXXMiOpCrbE192XmHKTts/RhDs7TsuZFs + Xyn1O93ll0uPsOnjcSCt3gPg0mmt+M5fLsO8sfJ3IxzLf8qCfiJOqQfA4LzR9EnVJ8YA4COXTMA3bpyF + +gQXWOKtqp8ml1k+do2dM6ZQ5cvnobqmeo4XRr/7snrzAh2mfjmzWPhltJC1J4z1PBX0G8nyZbT2K1ek + f1DdmfBL6jy3ow5ff9dipfA72AzgU6dD+IHT5AEwUEo/OziU+brfrrHff3w7PvvoLiTZN9ZkDK6yfgHa + OZSWD5MHQxCz+Qlq2PyCUKrlEhmef/ZU0m+kypcpApavLH8Z/YPqIWlvR3sTfvaBxbhylndXJHGlH6X0 + jmq/4lsKTosHwEAI+UZTY/zLfm/03X71THz+rbNRzz52wbSvSjvzMHMFixGP2+lEi8Lu8en4a4xReGsp + pmXgrZTMusqsCKuXzCLK8hPrJ56LNPJrlwyidTuV9BuJ8mW0ZG1n+QfRX6yHeOSfT6cxt6MOP/vAYrz5 + PN8t5TsB3HM6hR84zR4Ahy+lsvnPqTaQSGXz+M+n9uBLf9xpxwRUAs+7haInAHgtHv+MCJmAqKwGfy4b + j8vOxfLjcVtZ8fUvpX6yc5Yff0/2XzbkYP/1iJf5R4J+I10+n6fYfpZnEP35tLK2cM/P7ajDt96/zBV+ + 0bglogYGBtNoaox/GMC9OM04UxRAO6X02+mc+T6/XWS++qcdpSsBkRlEYZQxGSBnWP4an5YfesjqIN6X + 1VlWP77+qvox8AItc11V/1VDlFNFv5EuX8xPdi8M/VV05o5zW2Ie4QeKFUAuk0djQ2zE1/iHxZmiABi+ + DuCzfgl+8Ow+3P3rzYWYgB/8hK4aqFb+KuURBnrEtj4jkf/ppt9Il18t+jiW/3/+6nJcMa3Z74kkgG8C + +PzINyocTmsMQIRlWd8H8B2/NB+5chp+fPtSdDQ5c6p6xO4IPVL4sevxeOEen0ZMH5TGL/+g9CqI+cjq + rGofX18GWfnsWGr+p5p+lZQf9D+I9uXSH3Cfu3j+eDzw0cvCCv+3Rkh8ysIZpQA0TdsTtFoQAN51wUT8 + 9/uXYm5LrNj9S6cLbiGgHnuKgSD+qIoQy/I3c/75M4jMyFttPk++PbyAq+rL0oljWrHeQfmfLvpVWj5P + TycIpyyf9QOjPTuWQn8WWHbyWXneOPz4PQtw/uQWBIBZ/lO2yi8MzrQhAEO7s/3x+/wSPb/rJO7+ySt4 + +ZizO62M8cOugAtKrxKsMPmbuQLj+XkFqufC1Jf/H7YcPl0l7SuHfmIdyy0/qK38fTFtKc9Krr/nvHZ8 + /Z0LMWGU7zw/b/nPKOEHzlwFANibidwP4G1+ibaeSOKTv9qEJ7f7fOwiDLP5pQ9CqfkHgQWZSmFWMU2Q + MIr5V7N9fnX1E8hyylflV2oflkCfekJx5/IpuOf6WWhvSvjllKSU3nOmBPxkOJMVABDSEzjYl8G/Pr4b + 3392X+GijAH8NDoQnJ6f8gmT3i9/0StQPauynKUKT5j01WyfH/2qXX7YNHy+ZdK/oz6Ku6+ego9dPQ0N + Cd+dj8+4gJ8MZ7oCAArbin0agPJtioHBNL635gC+9GIXkkeOFRjJx4ULfV2FcvKpxDKFqQ9QvfxHgn6l + tD9MOdXqyxCY26jhS++9EO9Y2BEm+Rkxzx+Es0EBMHxpYDD9Ob9lw6ms/Y22Lzz4OrYPVvbhixpq4LFy + 7ih89aa5YYJ97MWePpyBY34RZ5MCCPXuAACsO9iHv39ku39cgIcRAfK5wpG/Jv5XPQ/4p6k0fVD5YfNS + PVNKHkH1H2l6Vjt/n/RsvP+Pb5mNcc2BcZ3NlNJPn+7lvaXgrFIAAGBZ1gxN0+4HsNwv3dH+NL7y2E78 + +LXjGBZfKZYxkHgvCH7pZAwclK9qpV6pZYv3xbaGebGl1Pr7CexI0bOa+SvSdNRH8aVbz8MHzh8T5juH + a2APVUdsC++RwFmnABzcBntjkQVBCX/12mF8ftVh7DzAeQOGMDYMw+jlWpug9EHr+sVn+TrLLJnqfqmC + Uol1HUl6VpJ/WM/LiGDlzGb88w3zghb3AHak/yFCyCdxFrj8Is5WBQAAyxx3631BCbceHcCXH9qCX+4Y + CMd0PKPwAikTKD+BCZueQeUFBAlymPth6lpu/YPaVk16Vjt/wRh0xAjuuHIGPr18QqDL77zU82WcoXP8 + YXBGrQQsEWsdrftlv41FAGD+uCZ8//1L8e+3nYc5oyX7DbLPYbHpHkMvXMsLq+UYk4luNZ+HJ03AunL+ + tVLZSy0iE7P82PUw91WML0sjekdh6u8Kql6oSxA93TJPUf7sGbG/OFw8uRE/+8BifO2GGWHG+53OG31n + 3Oq+UnA2ewAunLjAM/DZYozhtcMD+Nzj+/HcNic24GeRGUShZNdUY2lZev4Zmduvyj9o+JA3g+8D6iGD + yurz6cLUn6+Hqv1h8hmp/H36q6M+ig9dNA6fWDkrjOADZ+l4X4ZzQQG0A+h29hn8AgKCgwDQk8zi15u6 + 8M3Hd2BHD2ddVEtrZevdZRZb9koq70Ew6wN4BdMvT9dK68V58cIq3i8VEndYmkasP6MbX88w9OEV3Ejm + z/pBkeaSqa24Z8XEoM07ALgu/3csy/rW6drCq9o4FxSAC8cTuCNovQDD1n+UEVEAAAelSURBVBNJ/Nfq + /XhwbSe6ktlgAQAqFzRZfiqBCPNc2PQjhUroEebZaufv0G3M2DZ8elk7PnzlNLTVR8PkthbA9wH8Dmex + yy/inFIAHD4E4JMIMUuQyubx7K5u3LPqMF7a3xtsiUWwsSRLXyqzMkEG5FZLlR9vLcVnKqlPuVBZZr4u + smMpCkzmpYShP1ME+RzqEjHcuHQC/nnFRMwfF/ojNL+HPet01rv8Is5VBQDLsmYQQr44OJR5XxhvoCeZ + xf3rTuAHLx3GzuND8kR5s8BM/FFkePG+eA0IDn7xecry46+Lz6jW3PNli/Xwq5/YDvE5Pk9Vu/zeAwjb + vjD0l9U/nUZdIobLpjTiI1fNwA1zWsPM6wP2vn334SyO8gfhnFUADtoB3ApbewcGCAFgb9cQvv/Kcdz/ + 7B50mZo/U6vgx8jlCoks/3LqxucB+OcTlH/YdpXalmq0j2vjxZMbcedlU/DOhR1h3X0AWEMp/eLZtKqv + HJzrCoChnlL6g6A9B3lsPTqA/3rukB0fyHA0kjG8THArZd5yoPJIysmDgXetS7HSMsiGKqXUR/Vf5oEB + mD2hGR9c0Ir3XDoVk1tCf7j0nLf6PN4oCoAhdGwAsOMDW04M40cvHMKDW7rtQGE5CKsMqiHAlZR7OhFm + aBSynnOaNNy0bAr++qIxmN7REJjeQRLAKuf183Pa6vN4oykAd6YAwJ0IOSwA7PUDHkVwJgjNuYRyXmhi + cPpiTpOGv1oxG+9Y2FGKxQfsr/N8G+dYhD8M3nAKgMFZN/BJACvgs8+AiK1HB3D/ui48vLXLDhaeKYrg + TKnHKa53HaFYOK4e77pwMt6zaBRaEkbYAB9S2TwSUeOcmtcvFW9YBcDhNtirugIXEPHY2zWEh7b34dcb + j+P1Az0YpqQqlWlurEP/4HD1n4tEgVy2+L8fRuI15KB8wqzMBFBfF8fyqU340IXjcM305lKCexgYTKOx + IfbA2foCTzVRUwA22imldxJCPoUShgWAPX349N5+/GZTF1bv7cPxPkcIZW/x5XNe4VMxuSigovACamH2 + E3RZPnxesnoE3Q/7rF9deFrwNJE8M7stipvnd+Dm2c04f0pLaGvPYQ3sAN+DpT54LqKmADiUGx9g2Hp0 + AA9t68WjW09i04kUksPh3ulXWu8gqy27HzadqiyV0Afdl5UVpp6ioiSk6PqYljpcPb0FK6Y34/q5o0od + 3zOsAfATvAHH+X6oKQAJKlUEPcksXt3fi6f2D+G5fX14qTNZLACC9fcoAV7IVIItXg9zZHnyCFIift4H + d99XifmVq/CC6uviWDg6gRvnj8KbZrfivNF15Vh7oCb4vqgpAB9wiuAWhJw6FCEqg00nUkjmLJf5mxMR + 9A8OFwRIJbhA8Tm7xi+PZRZUli4SME72K0+8x/iGkOD8/e5R6g6NmuMGLpnUgCunNuNNs1sxvTVe0tie + QxLAetQEPxA1BRACzrLiWwkhN6PEYCEPpgzWHk/j2f392HBkqBAzYAgSUhF8/7EYQxBUcQCZ0hGfY/c4 + wS0XzXEDY+o0LJ3QhIsmNeHKaU2VWHr2tt7vATyMmuCHQk0BlAa2tPjmgcH028K8Y6BCKpvHvr4Mth4f + xlPbTmDDiTT29WVwPCn56KlKKMux6tVGUP6Uul5JfV0cDVENS8Y3YNGYelw7tQGzRteXslhHhU4A91FK + nyGErEdN8EOjpgDKhLOO4GbYCqHkOAED+3y0aVo42JfG1pMZvHJwAK8fT2Jf9zCOD1voT/t8CZkJ2GlC + c9yw6ycZLvAWftHYeszuqMP8MXWY1hIr28pzSALYB+Ahy7Luf6PO41eKmgKoENzw4CoAS1GBMuCRyubR + NWzixFAGaw8PYk93Ggf7MzjQk8K+vgzSJmzBU/XfSCkFYezfHLcFOa4D01pimNKWwEWTmjC5JYaprTFM + aIyG3WUnLDoppasJIb8DsBo1a18RagqginC8gqsAXA1bGYReYRgWPcksjiVzONQ1hEFLw8G+DI4NZFzl + AAD7+uxt0NNs0yHTsgOPIVAfsbeJNPTCdpFxHWiOaWhLRNBcF0FL3MDk5hjGNsVcQW+LaRjdEA36XFa5 + YNb+ry3LOlaz9tVDTQGMDNoppUsdZXALypxBKBWpbB6pnIWhHMVQNo/hrIlUjmJ4OI1Byxbobu6FpmTO + 7vv6SMFbaHei7o2ahbq6ONrrbQs/tt6eaSgzKl8OOmEL/T9QShOU0n01wa8+agrg1OA2AEtgewbTUKVh + wjmITgDrnWDeKtg78LQ792qu/gigpgBOPZYBWEopvZoQsnhgML2gktmEsxydAHoBPARgA4D9OAe33TqT + UVMApxHOQqMWSmmrM1y4c2AwPSESC/9G21kG5tZvALAR9mIdZuVrFv40oKYAziAwhQBgKuwhA2DHEFoB + tGAEgoojhCSAPgD7KKUHYAv8hto4/sxDTQGc+WiHrRCmUkqnEUKmOOctADAwmF7e1Bg/CWDUKaxT0jn2 + wXbh+yilBwgh+wAcoJTud4S9DzXLfkajpgDOXrRbltXCeQytAKYAYEOKKbCVRCsAUErTg0OZGUHxBmc5 + 7UkAGdjuegsKAt7rHPsA9FqWtQEAaoJ+9uL/B8+D1JorvOplAAAAAElFTkSuQmCC + + + \ No newline at end of file diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/coati.ico b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/coati.ico index 90ce2937aa6fad8c40be8b3404dd65b9ff01b5ce..afd304d8ad249240c88222090f17a74605d7c645 100644 GIT binary patch literal 72168 zcmeFa30zIv`#AhG&vOW+B26Mxh>*%q<_eJ_A(_flB9){Jm8p52J1U*VQ<6$4l6k(a zAzYVx&DS+u?)5%v?Xyp(qI0zF!W&y$8V1p?tq0fTS*fwKd~6>x4Ux7Q5M|dJ zq9^r*1C!P8QHKLl)FEz$3O;I(=-dbPSnJ_45OH-7R~Mot4M4vUL`^n<=*fd&pMw<~ zm}(3MrVWP!)6L-E3=7ylbu8?kHUKum&rr54?y)gQ8>Ou6(2RI-rNte7Wao@A0s%jZVXiT4TQ=7Bd8A0 z0bbB}s16zivCg&-H+M3`&z%IRi)|p)!x{2?mcro;o=~u98QR{EyJ|M%t#yW?O*4SA z&IOK!*~8JD4sdwm3MdU;0xdb|(8|exo3&Y(&joO?q8KigbKpYx5x8+Q1HNxafget% z!^74rI2vLGHQPtP(a=dyyL%R#iJJ^<36r5TbTd@#S`L*vy@9uDH5}dJ4Ym7xpbW#S z_xeFi^cFaNC>TyAZ-wJA!B8I;3bhCKz_Ek7p(%MYw5E8#nY5+wec3v=p6?3hbJjpx z_6E4h4Z<*AxK+IezN_91kItmPqt;|NTMz}!neot)6%VJfZ?Yv6}Vb@1bjbMWNW75Mq~Rd{yq3OsMW z3C|zggjbJlz%Nhk!7o4m2ydP}f_JZ;!pC1tUmkrAFCW}RoVOH@;C6jTwf|rEb`De{91aT!3=G*` zNZi%c6|!DdV-W0CY_B5T?RKLmjJC4df&Rryw*}Y^w+Y_1)Y8&(aW!|2b;`bp=6iGZ zFE2V?R$S+R#wCRn&^*3{g|p^%(@KudG;N{!xY^Qk{0*-@kSs?|M* z#6?ACaX2|?39EYbT)k1(KEXkEmhU>JS?djSbvL@28bt0gR6@`mI6&LjwQ!cCX+*?; z0m{k)v5?RCPEwwGSjaDM0+}K9Dq98TL#V z2zzY@!M-U2VW0gFh_o}uHgXiUk@~QI`Z$Q2Z3yXZ10mMQ9OCAThs60~AY&dtuA3-i zy7q#MMFx<&SP_briojt{Y2dDuhXOBkC|?CownhQUeAM9hCQ+!{ECuDhJ%Hn70C`>} zkm+d&+>Mq{y1@i^TLwd!-%xCets!aQG;DjVA=%v#(w9uews9t;FPjG$%j_X{^+L#5 zH3y3PT%m01M0^~eEXW0N*DQvDjfv5`0)Ax)E?Rm zb+I8(AHN4qrX7H$v^Y3hlmj=9#lVB}$KhUE1H8Ol3->QHq5Cv6rbNMo!d-ACcNetg zB|}?544f-U#C|Xbnz7xxToMg8st&^C@+7!f6A$etV&LY{{n+;9!PV*lcycx!&K$-z zy@Cth)fdsQ>$T-@rzsn5Hy?-ZPL#tBC-*`7sXTaarU2W=O8D{eF}Q!e6@L2u0{n2f z1=~obeSCiZDm=e`3){83*f!pUS3g{aSC8+*o1Y)S``0hvmy04yd@boPM`t_T**D+{DzkdCO z8?Hkc@x%N1>~q{QK%w871KWKZwG@U14IFwfJ8QMJ!mNTuZl)kS za`}FLMJYvX{}uA`GV*H$;Rg7p*)YeJ|OhKnL#ut;B5QZ}hB>SK0pH79`x;`ry9N(%rZ%+y8InQ&3j9xlj*A2EUr z6cx2}VX#R|X8b~%5lEnJHo+x6ok3>I^!SB-2%ds^@;_ZuNk688k2OAQKL+Ao_hY-q z_rv*tKEEH+!+y*N$M9OPZ&DA4oksdGB|6@ZnTF$j``(b|ECs2~@{s7L3W-h{*pKO9 z-(`Y*7(P?2-=_JEEIu^ z`AU%GrU8YXWNa@DoTX~CA1n3g2{r2gYW!88K2Q}(eKjCw$pFap8VTGDW>Dd;4^@FC zP_e}vk{3>ZMAzw%Fb~J|izh(Z(z%f3We+(kr$e^4Gh}+ZLcsP`qtDlmxGY#vnzg4K;__9hOkPYc$mFb%6TaHc%Jo496o~p)zzX9FO*d>Ie@U zxBEf;eor`lU>%$c?E$Cv8o-IjiO?851zHYHf=g-k&>S}(S`t0sbm~etowgA!WzL1R ztTou@ZG^LVL2$izJ={CC9cuQ4G5uZKE_m~_9o{~>3on0s2u&%G(3BbrtvTUvwlEb= z=cU1A?oPN~83`9lli_M5_K8PG|CI+f>&xK5g%j}o$$GTUz}?m+cz6N(sH-P&+1HNngK=i$|lcd;M3 z4G%81!lSF_v0wWh9$su_`nzlA;OASXaX#=pJo)Ytyug0%#lze1`p4Vw@`wBI>+_#6 zJwIZf_Y^+7c@7`nvi;r{c>l{Q#BGO9rlxNupcDx zui^7=AK-U;=<51a~)?R zIL-~)$#6-OTIs*m_(8mXD9kliJ2RKGBN|dF~F>tgqa5g1T2F{KK&O_0G;LPYy zxJYkkVz_g%3kjQ-dcZkx4RM)H(Qzw870P`FY7a|Ja*lS<*3s4pOighKTceH6)vI+3 zf>4DV2W|Nw@u@o(ERfgLou8bVx_^O>uDq^8nzy#@{KAUTP!mN(li1YMgFX%}>(WvY zV%NDi_@t$}C@7kQmKCm6MA$~cQ;0!U#EEF zt|^KAxlEtvXic=`)}sCi0+f`LlxS})2{{QF&HV@asYys^#iXw5J8FFrgOPIZKw4Dr z7zsqsib@|Pp(ZghEo~%7sEzVkAGI%RrM1R__>ppAa&l@gDm{Gxh{5oL_~D?8t7OWm zz0|}&M8nro48+9L#H}xJ2 zCXVrZ5LXiyS2d5Ss3@GFA&v;a$@|R3NN10P)WRNK%mxd%c%K>iMN}rFc+epMjU+<= zaq)huNEIyfK#xlA2`NiR-`@ef&3#GzsHoUFR#bFcOxgi68YdVJh)zgnYG}FdSWz?I zRYGF|ia0)teFciskwaIQu#v6b_B~Jzg;;-S5W^M}a3%udKLBXI0#IrPkZJ%B zBTonpAIJm$09YEdDUWuv@sT3DiHy$x!9?blcCjyHoI;*i_^{&?Yg|+9x~@saDdGHa z%C2z(>3lm9=i9MUnK8=#$vuG`qomK3gcO`>CpoG>+5#;|aO_Lx+mW`$5Iw~Lq8&!# zIAsLRwFkkW>H0YT#W}W<8Kk;d;M(9Aod1r899JBdxX7R_4jHbRIL`*i_mG7=kDkEw z(S*Vky`TiwBFTK4tVNct#qo(xZ>U+1?sa{k%C9#Z_BMjdrDLFAttGBWT0o`$04Vjd z0A8Ra91R)@<(o(0nxq{hyV*kGf@#d$+j9zJEwhE(l~Zue?Syl0H#p)q4GMg1ar`n5 z=iu|{{5yBe5;(kRB|a;lAy5fwBPK#s*j%U#TMiXF*TB);o>01d15|`>g`<(1fVT(N z5f7}yb;K>uvfB{O?l;9b`B*p+Z4Yg+HgG219xf)?z^R1!I9^!+r&4_3T=ptx%MFBc zIqTqN(Gr}Ghr`L#2%Ou8!}+3pxR!Vj*AkO(ToMcCi&NoJaTHwS9)z1!d*OENKDbsI z23N{s;d)gZwB~2RnSyM%P@0Q#>>OM>Jp$K{6~K4LGvL~>3b;{s6z-fz!TB~BpA^9D zlNE61bR9fs+y@Vu4#NFYS@7^|Av`>j3+=7t@aSR{JiB!QEAD4#KX(epBW>{T@;P|< z=q|i{@e>_;Jh;#dkFK1Ar{A~Ib<1}+t|DWM7Z2~?`sGy|r+kld^1C=Tc?qwdJc73` zf5v(GBlz{%5AgBL6Uyg3&bvSS!i-%$|3>EQ%-H4as~7O;-AkO4KSTPT;g8>chu?qy zgkuqWaGmpyKYmBua9q-5Y|`EMg@pZ%^q)U}hPQ8-wNHE<{uhLD;8-Up<8pFi;^JcB zIoz^N5yGCbV$P1>#q*t=oSYUf4i4jRYlLH2cMUftc+OkkwH z;zP_iJBz9Wm^GYGr-2kpM~9$NgHK};TqMBb#yA=157g;LhBX8<$)iarG&PO3v!ctw z25HV+y4(;j1AO4X5>7*l;ypHIrY`9vhQmezVk*k` z;J}d?MT$?vnp(7+jQGU*_-AJB8Hb1hpbJW5wAn*-6TVAF4O)kH-+va%8wb}S;b zRW0|k@A_^VdfO=vg?W^DypVF zF`{czSr)Z%l<-Jc4Vl?RWRwYWqsgh^ayC!wz*HMyw=Ri$^eZ&PE#vNuTDN4PCBnp6 zn^UvPy2T<)Ys$DsA~VvG60(nQd7W8(`3&Q6%n4uGL5kWTAVO^th7XQOAs8PVpMo|% zI93(d_*n?r@sYx(0UxZN0y_lVWN^&d==^7cWkT>DKnT(b%Wpuxuzv06Cwi0gkaVy% zn@*DM@%WHDAnE@S!niS?#7Nke51>tKGDaVY&tiPoaXQHS`8a(y9j6=NK7ygRC!i-j z?08)fzl-%?#_Lmh)Ahvkxnhvyqyh=Ed%<3^rf6$~>xc%h*Uk*Ti{X0Wl#y_7nj!8T zzTo`O95h7FhL$)NxRP!U4F^2oRMIlsBM<;rvz_2d&O#io`@p%ZrO=uk3}-Ue!;QkF zaH$aEi`K!d%0OIa+=1i&Fx*?P2kH~{!HHztPmme|XAkei?`9FWCm;^T@Vnqz#V)v4 zy8~_=Pr~tfAzZG=hHEvrzX89MT|Zud?lQQ4JQT<4sc`pXE_~m31lJO4=)QpmEh+eY zi~|qO@}T`pHT-<}Fg&_c1wURn4$p7Z;<{ub+&g<3*YiH&dg57ldiyLqxqcFUynY#; z-nju!@7}_-#OpM^{cH=aDdL#^!4({{;~s;DXW`9{%((qG@(u07uegp#_8GjyG5b^e zcJ>hWA^d>jcwBFM{e+Iq-@pDDe*g3v?nC$$@!!$$I~lA0_MVKh|G>4zk2I{)xcqO7 z*@f2}ySiCF8P5yz#aHM5dT8ka%_keGOLk{+IESN4Dyy3tyF_>KHrI1Gi4n`(+~&`B zcV8Z#lTuRuCln{DW8y>H=HQn$0!H?8=FD9lf3Ui_3sb(gxwxMR2?*WR4L9L`OhMq#>5QvDx;5t_0Nu z%LXCuZUIS_a~e8HsOGp3R0AUeJv}4()8hm285s>;o^@P^pgw0Y8?UE_Bna9a0o1j) zsDq$BZ@G~kPC#(7f-@HbB)}<*zCH%&^C^*fX%U--6D45-4TkJYSgOB0cAd7iwgLXl zi;Uc$zab&i5dGSE#L(Yf!q=!e(M((0JdYEqzmr4o3HWk2i9ps~nBK}SXb_2J~No#sE3%mWr+{Y3De5IU`&jzT}{ zSk5*j9SlB*m9IM9R7OTe#x#*&Y+q=tYihlTLFaIyJQkStAHF7o!|_#6Qc&n0d90MQ-poQn|ncZZn0hUl4RgVP9U9B6N=F7uUB zrWA5k-3bVmw!w_^Q{JH-EgOl$5-blv)rXZX3NS=PP^+*lUSM2$C}n=Q>fBlqME>P%kN| z(SAbNlppJp&I$J0~6s z;w^#!Vq#-5IoY#R#mFC-8}Wbmsn)57I@RWb2Zd7Qj}(PVDKP$8PY z&9KoTZ~Td($rz4*s*Z73RqV(ljLgHxLqOmb6PZO{_{v@C{Fsqm2RP9hs*_I#BfPw#IdM3pA*zT;NQmMOf%&E&(KDcg?aJzlR+FWEAFNqqeWzdWtqNI&Rlw$_?k#6i>+TNuMC=B9Cy5<`^Cx1HksuoQ-GxrP$UKZp#K^piOgzavjZE0u zg>8JV8;Bn#c&r^l{5S#ZWRtM}Ll8pb3hC28{6hM+6F;Vdwb^vibYptieE5yvVSZp1 zQG?_g@!-6a$wxL{*?j(j*^2RGo@$Lx2tI;&s&aSpRBim8ME1qw{>^b@--|Kb_Yysk z+4mAVRUYT4J@M&7_ivKDF9|bMfP7m@bylR`mQv<2`(O6jlD#h`I9D~t?@FU^zB(G` zuIBh{$q4s-4!}JyW;kyh18J@UAZe~1#5h_(@&XIovoZ$1H(B7^RRrg*%=aeFB0#@1 z&S87e{V)YMcRjLF6%Kp#rt{X4Rm|S^WB8q^#!nHBZte{wYt$fTsRlgOex5zfV{LH$Y71#grbC)1&QDiQ$2~HWAbaI}DB9=%M*`e| zvwk6z2RlRQmMOR&emNZ3vJwh6F9Ytj4Y z-!l#8vXh`D+!<+}BwU32k|yxS#zH z?ro33y`Cv>DklLhlJ8H2+u>T-PPlb+5AO9$!9AWaaEW^W_l{=cH>eD{AM|o%G0tHN z;d)IL{q97*KixeMPxr;#Y084{o66x<(=oVrrVf5+K7ikyis13tES%F;Li<_VFN1U1 zpRON++bt(>|4a++0X>QPW^jMZ)8gc@3-Kb^)~#9-=N<7i2G-74=CL?gWsQieeo3c-rUE%Gtcl_)N^K@ zi+f`}f5ds~- z?o_wZIt8}Yakv?K7P${apwws(xBDVwQC4@h6Y^J{wz|sV{mW+)g0I1Sc>=eh;VT-U zfaY3m#&Y*rNNV~uIR*|}o^zz8S%{#Mv#p`1aI^bNQzRZd*pv^f3;7L34zo8Gmo;{u zk*#&yjKxDu2mcwE4j#5Rr?{>=2B&Jck;DItmW^}T$F2FALF;kuW;3I~gP9+}MHk;k z!vu!Wu(0B<7_`O^A3VkDe%Z##)%G|~)bj0Nh%R(;KU(cJ%O&CPi9LS=>W_)+{8+&lM z#Y@nK3lYe`cn~_56do6(ppNT}A$oI)x!k>ah`X2gC>TW{eU_Qy5pIDc2HE5?@9YsN>F~3k`~+ zDR$P}5mBBbKv8L4K10quvch8LP8AwBI-bi-F;P-Rk0;H6)`~=W3`beXBAuca_{^Dy z(JG_1@TFsD@y@x+MkpyMTdc@JUz7@^x5(jP5j1jrmH6N0_VdN%M{V-;iDHE_fd%^m ze0_FiktA}rGWg0{x!4xe6i(sOEBi30e`(I+6HGaRImnB}uYnBAE&5ARf{LZgpN#t+Se zLP22}x3P{pLO~9fTBPLgXP)*a4A%FXM{8q*3R!8P4D5<)EAq{eo&`6WzuhyLC*6;* zFR){gF;ZV>C1l~_Z`Q`W`(37aE_Cd!j9^bBD06eWuv z+VLkV+ndrw=t%0Urv=@G3!61@x)fVhR#mo7Y*Be!A61+VlgEaG6mk8@?07;5aSKD< zI;Xw0l%4b_;KxNLwQ?kMNDrt3`>){f%SA_i}mkIxwBDyvn#Ou;@Gf(ld%0M zn2PIM--1q2YGRW}575kAg=0Wr0yp;&E>IEazeIJ(?M z*1&L8jCfEJCX`0>jo~t*(HiaovWu5Ssfwss9pG|z^-$$6=TTIKO1$%m-GXAK|2%i9 zJV}$Gr%Xibi@AB))Y+ZEFccHhPG zBnMh6IJP4E^}SxbtgsLcYN#=U#1w4U#W2CvV*4Tg==%^180Y#*zuyZOvue;-tW7GscXiRZ4X17~9o>NhKw` zze7zJox&+Fz66}41ED*DcN|E|6=Ycqyjo|{?4nU1Fo`4UR~oiGmWfq;4X9o zTzOO?b^}>hL?Fu>XwikpU>c1Jvba~BgiBF0iWoxtbjgu8$o_e1Q!-q+WNo^xi45pE zCrV=Nb_QRHwHp{e*)LB(EQDGh@(r7b{XcJhOFxkYMmIrv+8MtTYqR;l+H5|t`Nq%B zVAiI^Lh?I=Fv5arAU2iwifaS!N8(WToaz#X1&KQBkOV)`)2n$@R7OWFncehTg z*>OISzfK%Ik?dvC!t;@exF$^YGWEv2On4^>t`Q%ySEXyjX>*wK2T9KSGm`wX{(EiB z@N6VGe=rL7GYw?!M8UOTa!xXK_Fz08sgLLItsu^s>}e9^uM6Xu$VGr>B>UpJusYs{ zqJw*x0La=fcLmx@B~V zLNV@dDqe?Y5H{&S1+EiU1mKy=HQy~QYhZK1d0OI(leH1-MA!Z1+FW5 zL4!X)<5p=n5sd4`JMetvc09isIu&a7E`;ixb8+vJH{Oflg=ZFU|I_XO+@}->#}96z z=PXZd*MQS|2Exg`=5Q`{G+ay=i|fbp;M5^JXPM{)CzCeA^*r1gl`$RKGVwl?oB+5{ zv;uBdZi1`Deo!4r_C1k11;TJ0c?UEmN7A+Alj#X?I%hYuWaFIyc*e3d57&!}Bj83Q z?t`j|hYKYnJR8@K^Wc2xVYpmL_CgiGjbj{oZh_pJa=(5Tb9Uh*-ks8v0k;~-KBwbw zr==VooY)HwPbI;FR=hXhEc(yaz)#nX!jntIaQ93T+-Ysbwc{pSLq3CN6`JV!@zYz) zxG$=Wt|LFXb{W@=$=dNPc>LWJcy+Ilo?jqmEy;eUSM8_hdCNCH-+|YU@cbpNA-}-0 zmv5euHRPZ1{(&Fp`OA;LzQ8?Ec>e&NyJXH-GJB!$Rru5O-oFzsynf8$v+K#MpV*&1 zG55a^_y1qu+P{FS=UQ7@>gsB$tE;N2c)aSGx`xJ<)^nHs1*?Bba^*s6V{Kh^B?|5W zyz1J9rq&Dpl;J&ngN& zzWWcx7M2S%scmfiZ>wQ!&ib=+j8z7Wb9v| zUTJM$vb~J6f3;^9$wEpvIeV_!pUr*A&dpt|utc_FV{ZK2X*SIsdsWh4-j)r6I4 z!jEHds7@wxeA1`}E&sX@_*u_cHI$V|Id>An51|@ReORRsYmQGL(V*^MR>VtwCPkP|q6kSYV`DIepqpHS327FEDMarP@YIhmkP1re7^I|O- z)(kTtmTUl#LxByTUVfO65;S@#2U*try|(BacC);L!pfJcX?r$n^g^CXz zs{bEK?n*xVASzJ%*Ew(nGoKeU81J#*YtWx?V%*fk`z`1t7c`V{k{~vi+Cp(m1X2vy zLvrA+D&aY-dQ^OeRN^8s86kWfIzng^AA`7=9}`bW*tj7F{#t>nq~-?=#*^GN9*Vep`)m(U>$}BS_}>mF`AtS?!i#fz#w=rqWC)KBQ}D; zC?ljoNB_}S1!}u#hOo!4SV3`#;mz>kc_9UAj6g5dAsmE(k5)xi?sYqqh#51ln%`R%qT=L zLPq3|c#P8!qj(Hb=ujrwqzVeZ0#~uqKV(E%D=H``A|g|l3FE^f6%9+nP!SYI1WN}k5!~}t+K+1n5ys& zMtX|MYxyfy`xJ5O6a(nM@~svO2C?Z&L*@u9hO~Jx%aqu;-UFmZ>|Ke`N{Y((NE@%k zR`hG&?H!?L7IfI9gVBh+Y(@t2W$WrH>*Ag)tUGKYNLu~?svYuIR#ZkMlm=o!3IQ)> zzOmj2Wy)7t(aa;67kV_7Kk^}W$ivPf#*Y|3(Y%} zkIC0nl6FBJObsNp@1Qc>c}A2Y8{9AlI$l7QLlv*II5)SLUz~!_ZXA`|!@0Soos~Rn zj*>BNSs)qQNHgF9a`dM8!p5O3?ZEb|-SGc6LD3zesTk=1wj0LmFSd|oWDC@g9*Aw^ ze-qXUC5|{r0+}WNhh6(vFpVIY=>VSv90d0g!>%C9M4`rBJFY`NIrA z9q=c$pmX{ChuS3LaY@3K$ibtK=#ULzIw5R)sB%;>g28~S*?+YF0%)%C*;7l}gK2`W z>&w%`lp~;ldhuPdSV8`4P;4P9D@`+)NRh@rSy>Bg8*nayjo)4(S6WdP^F~%m5zB!1 zr6zO#YvQZIF;j_n@*^dUIw&b8lO~W%I#!aa4k;*7lW2;+$bT)LmltzHn7Cr96uCu* zu%$rRlM2vq4I5wH0un1LErr2&+Ya+5iy44(m45}50h-Dddxc2%DWe3U0h$5LFI1ROy%;>a_Ah@$}* z#@J{Qhy2vieH!2e)_&;LFF76n={7W^eU5RvNXEN?=MXnNZ zvM3LC#>#KPi69Pyr=piZ=xoc$ZW11a{woD|0c>)JjX+HaOg}moVGkfApOG$PE)taC zzmiReLWI~6nZh8ykjk&L;iq3XPEJlnV!^+we8Reh_v&COESR4~zwuZoP!ECht71js!d{pOcpb4MCX8e?YJwJS{l@x-H2~i~BA7@< z1gsV${Sr1pm9I2VtJkLgU^EhCgGDOAq@5;EQVtU=A;G+VRjw$J3P%%N6eRpQlAmRd zxRN&U9U=eJRcz0)M)7K_5DC)$U<0rS<*T7o85v?Spn-!UK4jPu{Ujy&uI%X1*|_fQ z$}WXf89jxO&q_uu2uITXlDQ{g&qndxwu0QCyyDTlbY6<Ex9DhWq5%CBrtQbj2h66H5(V$WMc+3O$c%hm} z<#ZUl+|Vfm--f=sC0de_K$9k*CJrVyQDR>lp|s%mE4wd-3TuX5LG{~&9--Q+?=R+wu)L_lC_4{ti-LzAVZoK*N;EiwVXg-5P6#lSf7!&tPiYEY=0LcKJY zjh6%!t?7O{Q*uiyQ4JoivVxlxz17{WFOym#!<`ZbvXU8|gq{&XIZ008RaKuO<8OP+ zB|Z>h1Ypz89Y?(UP=Sm1RW$lp+u2W_J$t&njaFYi24ks6_DvxQ>|`>PO)q0pTB->u zS$m0m@7qY^vsmbqQ~|d9xmtLK3ZnqA`M~f%53|b+9i$5JLkS*C$M?D_8ZS@5xK59Z ziVVwWE1iJi^m`}0kp=Tu0KnG&Qd^XdKnsAq$^|*1lPMF7lMy(@NCd;j4~r%W-NYyS z5OfAbBatpaVFk?U%kZMQQW~)4zyG}Hfa((hnhfG%eI!|gvzUx<2!n@aAP@7O(ss%L zB;a!xhazzPiSzFYJ61!!vMQ1qv;Z*=11WPPAwL4t62e!bx7E;K27`~Fv9WY36Tr}Q zn3w^`24?fBYH$<UqjGbCyLC6JuY1ls=e3ykX~Cz{aWJSsOLh!yr$z`xX%m-;ULf zEP`VN*rnPPQ_PMn0QauCbwy?TR66R=eQY+QA8m>r4ncH@N5wcU`#t~Bk2O*Ieb;z$xTJ{#|jc;Kvh(~t{l7Q!(4JC ztd_vda{DSkMa3TnzsxrP?1Cc5zZfFNvQ+R&SUieF@V8*?qmXEaw*z4`!67l^ek8Q0 zOI!udO<~rNlU5|0{HaolF;rFXvLA{;V@Ls!crmd)Si$)#;AH)E9Fagc6V`-_xOks< zzWk~ZKPxd2l0W3aT0)N~1c&4U!;yxOa3+o<0MB(X4ADePLWyLID(JGu5VHR4 zN77IJkOP{Ct|DeFm_b)%`SlZF;t3CO%@fTIO2Mb2mptLQHlh`VliZ>_@xohjR*i&F zDvT#d#M&?T1cZHXN*{`k*@+xT8K5a{Co}^{nMPR%=%lK`4dyCk*Z4ppVc-u9RXlN~f`6nym_TCn#-i=`{z967%4wMK6idK`(oc&LXux$8 z5y7%&1Tp*txRf`EqiR!8)G1Dci{L}GLk*dPk?}#t_or+4`4QVd#AVnJB*LHIil|Q9 zo`roGfrK82!LT4v7*7Gu^D$icL^O(IKRPf?%pWD7c<3T8pP=^f+rY{h_=@rQ6GEZ_ zUya_bOhx3mijbN~%8xV>d^yD8{}>@Oh7BXqu>?d2FP5c<8z!dHHV~2l@jXS@a$*it zq7r-%nZyjdBj{_#hIY15hps?^Nb<>xAOvEh^gAV=b^<(iQcgm6tWylD9n%HI@&4u*b8F@WLcpC46U$9(jYRER)G>L~pEKVk zu>=J9jNzpEun*#Q(ZCIpB53-U#1oVB0x4DuE6R}^YNc1zp*fCu0iy8YItIw8R>3h= zei(}6hjzrEi}|tG;^VR9?QZ`GX@sh_lY8@6q3FQe>aDJ-K9S!JZ=kUlO1KgOA3o50 zqYCijI>$4ZNYs<$zEIQCkpXo7kvqAYk1(d3#l@#ZWyMD%@MnA_<5+1lTAaaU!_dd7 zL+Kh4Vi(hd6!qeLyJqO08<5MCLkqK?f42{^NT>mQG-Pigc3&w5XmSO zQK=5Z6rY5J|MlJ*fd)7isfuC_ml9faQKs2pIO#TSR_t=5rg}0q_$Q8IQU^~p) zjGXz*)hD=Z*uKSW0^=1ng*mhC?!~KPMj<5?|JNH}u^B=INY+tl;v%$7W+gCzL=K5% z^q~%clVYNeya>W5e^30iYjpoHEdrJkwL4@9bLC5AtPT&~#Sl_cya$<2{f+&{*b|W) z*g;!jAqK)yJAyHrI%Lu6))CjqWrb^9e@{H-0M>!3sBauL@5J@5JObS&Bp}Pbx&Itr zL(GAy?1^7<7x4Q!>Q6&v5QcwSJobh78dh=Fe~YKE8jPC_VeL+oJ^e}l(IC9xOz^&a z!*Pi;MBP^chBXny3S(^6*GV+-j3=#5^*=g)fm*d-Ur?1bx!vvqVTxcZ!JgSWhSLwg3JY-lay`|0Q&%fk0$uH3U8@w+u{s zRdv%psrO&K4s9n16JC-VZH@%YQ8?pfLs*;DYV7(9s``I?4)YTK{9)FXN!=6!E3UKM z(=n7ZI9TsmJMD7)Ds_J^fPen7B4NY$uF32ym->26@K32E$8zynj=#tMFR}0hC}|C_ zNlfr}Bn8pAOYTrY-D<{`Bxb#!y5Zb^Bkini=Ng$Dt>PU?*z7jJs%O{2=s9+h+x7(Z z`&8Y3T<)x3fqkj9fv*BKOC=d~p_|vc&6+WD=8Rcx8#aeVWpM=`-Rc_t>*tTD7FRCe z*>75_u_!7l`KQlm!E_k4E&nsZ`T20=Tx%m9e8<`)NG>ZIkHNQ``>z(dAn!Xnu3RGL z@9U4Ub0ZX7*MOq`RYQY!6(9)i4q?3XQWC~V&35vghq+vY`a_5x?<(N~|4x%&*3ZB5 zM4ROrXha51`WhbfL>?AzcGdQ8I1(& z_yUCd;|V+dO)P{!oA~+K5ABhrt@p zzrTg0LBEhXR3RaCs6y>5F0oOehClP8f+523?0qt982VW!V|Vql_tCIe!JX9axc7&R zAKyuROh8wEr{rLK7e9Mn5X(=gopmvGSHDz4=lHIE_C6jK>nnc<8^hS_{XT5yU;0@@ zzKyr*{4e}}DF;G2EAyA-*%iN`GyPZfr)zwBXMCx@^8Z!+?-Kvj`_%RQ`m6V|Q*(q3 zQWt;M_y4ckj|Slcv-ec7Vc0%($^i6tN)R@%of4qk#otZ)*h%5wFP#-euW*A$+hZXG zX?rcC5N*$e6r%0DkV4vopHPmDCw`$8lX^P@QgK2pG8HG315}()3bh$}L5hMIzd!)r z%Vr^;T#$wQ?oZIgu;lzK;A=ye&?F1c`2-#46oDVTd)AD}3bK7<0YJfiik&0&qUgjM z!^qx_h3h%X$u(m3b`zX8-+F%BzxvUn0IAP??ep)rzgzoq+YQ&_FWloRZ-fk6o1p4Y z5~UlaB;A}7C?o!6!W2W9{njCiON_$BhgQ#u{J!}4ruQR!UcOy>Z0o17@14Et#^+q> zeJ=69#xr+*e6uy}&66p8rUyJ;^XB{tJHuSg{UYlzA#0(;WR)bWNb-wx++w7=)HrwJ zc-FrCYP=LLxp0)H)i7+xIY|fa@wpq*^Srke zt+hyT)3K27os@m2tf;5WX>-sC%Q4K=9vC)FWT--eIHWF<-fZEEJjR}xt$G}OgQC2c zcWO58L~g$PymHTd`AO47QYN4#;hxidBuX?IoMEbzfDm;%4Pj5cKY6$ zfAF-pQGDsX#FX96#(P`U7K|MK{&JcG3>_MCqTRP=fWh-w z*TWLe2mIo_wk-DGed(p1Zt8>2$>^!hHorbmWpD2(dRexjxY)ym(_|myp0{(Iss$NG zEw{T|wRWAX))HMXdBZmO>{FGCZ{>`rurRndqCjNR>s^yMZF9hC)UsDfF_-P8_jXpY zkeFo|C$dZI!$@drJ7@R6*uek!^MdhyOF&BT{gQhp);_y^WoO-Xbrh_jIVD!_V(#rX zTPMZ!gj)-KzIZ#O;mNwe2^NPH9-bQE`P;9G)6y?ThleNJU7RHu5&f&jsc6re+uHSbYsc(SbK@<$u=MI&^P-aB z6PCT&8vb7NoWGzxevE(G8ilQ?7EYHH7Hrvq+83ouQOw#LRO){Pxeh=9QA?9KU%u`w)O5AW;8Q*h4b6X7NNYj(UIvF z_dMz~qv>Gtp`qIxw&t4kT7|M3Ue0n7-_9|D;Grk#d%P?A{@}Wj@?Ob2t!C}?yV2RH zV{iIr9Mju-&h?suNm=^h@X~i4J$9LVDY6txGh=F`u1&4&x3_nKd7VW3B6F=l#YsE9GaG$z|E?|SplqB`eKb${ zDr&2EUgL|Cq3x>($N8(j3z9djFY8sf=;o1%Up?-;bZmKE_SECfYlnq@tiKZD5ML9n zv3&Z|hU9r?o0}icJdqGR2?m;Oyfw|}cNyIu#$64U9I{dtireprw9kk!{BZWx_}_k* zyZX)+@ofh``l}4@wP;{y9;YoMvgO&Dn!O{BB&J7xx4K@}=f(PjUvsN( zO>puL5?$obP?B=f`skz5%_pY&%-i5B(~$HM;?z~JAG%x zdu|my-m0#5Vfvl<>L(uSdT#8Ods2L9fYiAQZ*DXys+>7oZ^CtaYEZap)~ESe8>1HA zit$^x_1ePPpMJJXusA-zTuWr5qr*Hkn>v}rYmAiA25oLKf)VGnHKqmEs-IX?^;)@K z&}y^m#do;spB)nulx~US4%(jK8TGfe!0@3h!{XnuL!^LesKN1>8PQ zr5jsB&djeqnVo&4pU?3Zwd>VS^l|v9*S#rCp(FQ*x=6P7gF!kb6R-i^nio^E<>0e5 zHI>?*PTd>weZ@!L*^9X;-lJ85Jm0Pye9LIr*zJoxmU(?Hj+nF7BVIGUX2$kReCUnsrYWXTEuG$sYpyFP)cmZPbk()?;#iondo2KV#R6y>HG$D7}9Wti52Kd5gAv zW-o5*8F{k{FW;vua&t&@lP*|gnKr}HHoxS#c!-hHt#wUr_xgVC+A~JgWTDvBnW0im z<9tUvSU4BX{#<{~RK*Fli5Xe_`YCGjhndM2uZ&!H-KFmGveHMAuRpiEek6I%;c)Qb zv?-P+>Q=VbT6(_z!+%j&-?`_#Ob19DkBJfY)m}Yrw1KDC;{wqS%FkxVrCjlP^I`m# z`gtYWZmhf4uu#LlR=v=utt!R4Hp6P!$GI!t?g$_1@%^l|XRYVt58Zh5S=sy#FXr8? z>wW+I>QP?ECq~rJqOsol(`=KJF)!Xs<^J(=d}H*sfUwHtvEoM?O>Q2zqtw?^`Ki-S zqeC-z5y$f#<{jB2V>0VQua|YwYLhI)uZz6%TlT(P)75(8c|-6TnP#eE7gk?ruv<#| z`^bA%ANpWZBP!i%Y`o0E+&x(_J=Q-eK2x~#C*Px3xR>*i)(n1pM`DCY^^a%1%XGKT ziy3Ea^n2scU))bvW`bdE`dhhQUvCcheL~>lyI!RMQ@vWxHfC!s_q-tT$S889?8JnO zCCKMYrmN+NvE%y;6>qkMPtDoM#fx@*e{b9Do8N_=i@7{AUCuVN+)bpS$*=8&U4u*U zR-K*qKKp3}y}dYkWX+=UF|qf)4E-23!RXS4@C;q+o5QLS78#*(7pK-Piuydq-19>C z+o8*6^xb*vk6+44?m}PH+kInRO>6nC2y7;P6xmwz<<6({Q*EZtjmG#oue3|gjQQnE zZ?(4K*d=ar*35eJFupG4v9ovM)qKqhhO5UUjC}R+LhVOAQNO?k*X3{TC^sMCJJ%Sz zYQIbexzCps+C((6l`~_f1`9L-uTPY;?#Znf_(!Lz{4P9<^z)jV>e$n z1c#q4$mqU&GxgA!A78)nOn%*@J>KBX>hhG24;?j%E>{c}8EkMtCwJhF7xD-1?D^7?nb(TOy9dSewKuIC{HVf5??InyCgUS}HNWt$xc1OYyFPA_ z!?TD-z{}2qGZD+?n@Q^~k}vx#HD>GUYcGo%Fc{Ib@We)T?mi`o$P z(UwnMo1Is?IKy8;qcQqp@NawLZDoSpZ^SG}cJrFtRH3{zn;Q8Q`r z=*RPiXa&0ko>%H^lk=r%+=ZX-$MgC$UbwMFuU$5CqQ`=(ybo4mCtH8${ru#YWA9T> zKCXYQk+#*ySGWC?hiT8zp1ygT;W@mR9P;Q(tIzcZli!bxn5O@-=5bMWv*P1B4NeN< zx6i&d(opHT`|En`&u1=LJSa_?(8O_w6=3{6(ft!%mDeQBaDSF$boIFUg-PK>zCXNqmpyZ~)#P@IOFP6u)ZBJ_xWOGCZjgTO z(Y)L(Hm7kUd?D@*$N0gzhwAu4TojhBD6dn7cKL=mht(dhQzT`TSaphRF?F!wmki`&ypC2 zH-`csa9hHxEirc1$3H)Sz&>>*;}%^S^GZ(Vm$&L;&96_^TJ!cp@RxUk>(WBXXM`Nl zuv#7^l!2y2p9MKJ71`2j2d4%PVJwy&M1+xkndr!LVU zheHF)bVG_1jkj~IM#Vomb*pbo^fh}E*I)NIxc$=C{D(sdB8_K7WA+Yp0I!B)V);%Y zfu~mAcXyXacjM?%K;1>$#a3Ee=2h0}bL8ANt`^ z4Hvy&j#wkPY(o96aQ?SQ@k5%2pUw58Y=@EhK3S!Ob8a;3UDkC`8ekr~rq8YOUmZKv zj7z;h^-Vo~;r82BdifO3l>qW?@6ThvT)i?czn$-H2=vv~g3XCyaVJ)V`lnMyaRV<| z40fK*JBp}Xmthwn4{Nx~nGtsn7xG4`(72SUgil^smW*67O2V%k1%BH)4gY<2^~Eqq zw@wDd?eMAM49?x=8Fo;^PZ;|`g@|fM(*R}xyHiK zV6fC}-jQG?k^D2Bw42`3)~}y;V<9q0UpU!%>$U0!oIfz^zAM&Yj+8B5sq40@{fTJks(6$DzfPLE;6IOYXazqvK?z@^;HVO-#7epM>y2f|i$ydB-N8x@u{Pwz~@!a3B znC6gx_>5#rKlDa8^3nbyD^BWvvK!n>-NSj|<30u2=&N`4Pq-J!G{d#e)y}b7`|aF- zp;HV7Oo#K12Lx~%uRrT;hQ;qS_s;lL($@uW#?hlhRRMELDIAatzrMTPAW%s2b^KPO zKf@j85~N5O`Ge-Au(15=j9lxdA@J;FGscPE4YymPp50-*6{&@W*iS++OQ?x@8=}q! zp7s|E)%BVMmj%+Cgx+zC{?G-SMt-Z(Wt@m6Zqid zi(nOx?Fl zNG6@V%_%WjG6nX!3AFSbIW~xLcD5UN3@cGQ(*nO~sFTh8Fm3#ZqfLd>JT;kH#$&In zV^+shjA=He@=d?~psp|3)Lln>jE*j%DU3Sb=pTEc%}2eC{Ay94%IdC48cK5Yn06G5 z*sw3py?STl=7EIhp|hvR@sRZUX{*Ul0YzNd*WXc;gY)!W7JazK$v_SPyn-oFPd+U7 zdAUc~zX&rrj`E^1ek;MCsBPj~docX)H+kDUrJE%Q;gt4onR#`$VI&m7O00I!X6fLG zq2q5bwZ2hrdG?q}k$(3H+@j+1v~s136&2CVOoBQk&fFN}QUo$_j|QHM}@hCQE1=#`&WxY6=_Xi8& z_|6A|6>wCFp*@2P_r>9CAJ2C=@Vl2%E#!X>5d2WDbNy84E`ZgS;`=XmRVw)H_##Ea z2F>06t^O8Npj^oK95>gE=G`-`0Kov&?F$XyNBo3@@-8jF$I!T2Fy%8T*iE~v=g7rL3cPc2S;0Ah1 zoHDhuwNmMs5tl-SJ8ZsNN)*n{Hm5E}mq0tn*EpZQ6iYCg5HEU1|Ap&^S<{4-7*PFSK@>wJ3xuzkrk;!RvcCysqoN za_iNIQjqwmf+QpzkY2srq7TrA^k6oA8rQ%r>gJ15;oEP2#Rzt0N{fk5V?zss}O zyxyir*ZYbv zqmE8Z3L7zaKoZdd&2+uy*xjp|DR|yvap%aGD?R^;B*YsioV4x(B>vU5+;Hs)xyo(5 zy9trrDgc#qZqwLszTRh2Q-~_Bt}bu(!V}1nAjwwmV?UZUr}n@7t>!V8OTl8#*FyQgjk2fl~lDWt*ve^HGI(tZ~t*C(dxAoPOD>8PD*(iJpo1ZDuNH4!x zQC98|cE-r+{qSX7e!7I7ukpm0YV%l;`E}&*XvUT^!vxrEz z3ujD3es9O!_Mu}n*M5!RRA{sAUEk4Lj>V1nsj2MCM`Tiv%YOu{&sh+8(6nklJ4eAI zI<`(g6F$IajU;V5T!foIheZiC08fn(Z|63#way}^53t7RdtR#)NaM8ojOpkcZ?k^V zs6>;@Uu>s3AcQv2u4QGkJS-C5yxj~B0Ves@@EHdOU!)g86OKi7;lKW|&MNOd zdYMRG>=a6$w@X_}guZab9m*F~W6RF9yxDC2d)pTyYPnM}Ouv1ZprdGgiObZL*RzSy z*#yT0yln9Q+~%o@e3*bfR<>`=$b90A6OF41Q-X~#jm?99)(mvaigMPr@v?_AeJm6s zJfcE|%4adXa{pvP%AZ=Nbk?BMtL8%nhB-3c2*Fpv1j8y!a`^n_?#LFXd^p7m9Qco|?PS%|M~en3Ha*~CW} zD&%KEqGM0=Ui~l0NKI^c9C{=MlCOJOx&)2fb3^CPSN?yx&Y0D+myQH!&WYm*D^qQ6 zDVMS`1%gIAYJ^tvdaR5KE@Vt9dE3lf+Fh>m)y3hYqlBz=%qb<7PZ32Wy|sNM^P*7# zeMdi~ylt;YlENzKrFR0zLgKIIqaccCvv1M{Q-W{8H~wy-jt|%U`>WSViV(j-LQ{@k znm2l)w~EyVd6>O-bQEFpRVOks<45g@>1$wj2y@n^5WzrxP5CpO%g2#?|9?G|I5h2a z9C2@LRK%=wZD^^M7T8c;%A5V_@~I{^@*U)4%&}r2*6v@69XlJ85di1E+oN)fscMr zdVDo7ge2l=e>14x_m>a5EJttit1*~dE9t;blnAH2*D)`TkBg07H9XuUXmP~%9q)88 z)vYElxrY8?;*J`cw}e`o!AUVREnm&GG}w$^e2Y!1N?@j*DL$qaY@kYa7%6G;Mb9uK z6WxEW$w$IgWy;ZjC+BO-4{eO2{F_^P`NVWnS*sDlE*EZ0uSCd7ss%A!@ClTTGi3?O+Iy4>-CxjuvospJ( t^%vII+#ff@5ajsWPsYblBoJkr~C< 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 J>i6cs{{vN$v(f+n literal 74802 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 E14Euj)&Kwi diff --git a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/source.extension.vsixmanifest b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/source.extension.vsixmanifest index 67a0f69b..9ed6f464 100644 --- a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/source.extension.vsixmanifest +++ b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/source.extension.vsixmanifest @@ -1,10 +1,11 @@  - + CoatiPlugin This package allows Coati to communicate with Visual Studio and vice versa. https://www.coati.io/ + Creation of CDBs is in beta and may change in future versions coati.ico diff --git a/src/lib_gui/platform_includes/deploy.h b/src/lib_gui/platform_includes/deploy.h index 8b8c4369..00f85fcb 100644 --- a/src/lib_gui/platform_includes/deploy.h +++ b/src/lib_gui/platform_includes/deploy.h @@ -1 +1 @@ -// #define DEPLOY + // #define DEPLOY diff --git a/web/documentation/img/vs_plugin_cdb.png b/web/documentation/img/vs_plugin_cdb.png new file mode 100644 index 0000000000000000000000000000000000000000..9073a6a18eba68cebdec8827e5b07875727cb94f GIT binary patch literal 18591 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 literal 0 HcmV?d00001 diff --git a/web/documentation/img/vs_plugin_menu.png b/web/documentation/img/vs_plugin_menu.png new file mode 100644 index 0000000000000000000000000000000000000000..6a054f37e1c8ae56613ee55f240be5565d951928 GIT binary patch literal 14402 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 KaJ8Ub!2bho1JKX_ literal 0 HcmV?d00001 diff --git a/web/documentation/index.html b/web/documentation/index.html index 4eda0d71..5649e05d 100644 --- a/web/documentation/index.html +++ b/web/documentation/index.html @@ -1719,7 +1719,7 @@
  • Eclipse needs to restart and can now communicate with Eclipse.
    • -
  • Manuelly: +
  • Manually:
    1. Download this eCoati-gh-pages.zip @@ -1772,7 +1772,7 @@ Installation

        -
      • Manuelly
        • +
      • Manually
        1. To install the Coati plugin for Sublime Text copy the CoatiPlugin folder located in your ide_plugins/sublime_text to your SublimeText/Packages folder @@ -1819,7 +1819,44 @@ + + Create Compilation Database (Beta) +

          You can create a compilation database (CDB) from your VS solution. Coati projects can be created from CDBs. This feature will replace solution parsing as implemented in current Coati versions. The workflow from VS to Coati will be automated in the future. As of now CDBs have to be loaded manually in Coati.

          +

          The CDB wizard is located in the Coati section in the VS menu bar. Note that the option is only useable if a solution containing at least one C/C++ project is loaded.

          + +
          +
          + +
          +
          + +

          In the CDB wizard you can select projects you want to include in the CDB as well as the desired build target platform and configuration and a number of other options.

          + +
          +
          + +
          +
          + + + + + + + + + + + + + + + + +
          Option Description
          Select Projects The list of C/C++ projects in your solution. Check all projects you want to be included in the CDB.
          De/Select All Will select all projects if at least one project is not selected. If all projects are selected they will all be unselected.
          Configuration A dropdown list of the available build configurations. The selected configuration determines include paths and compile flags for the CDB.
          Platform A dropdown list of the available target platforms. The selected platform determines include paths and compile flags for the CDB.
          Browse Opens a folder browser to select the directory where the CDB will be created in. By default it is the directory of your solution. Instead of using the folder browser you can also paste a path into the adjacent text field.
          CDB Name This is the name for the CDB file. By default it is the same name as your solution.
          C Standard A dropdown list of all C standards supported by Coati. If your projects contain C files select the appropriate standard. Note that we aim to automate this selection in the future.
          Cancel Aborts the process and closes the wizard.
          Create Creates the CDB using the specified options. Note that at least one project has to be selected to start creating.
          +

          Once the CDB was successfully created it can be found in the specified target directory. From this CDB you can create a Coati project as described above.

          +