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 90ce2937..afd304d8 100644 Binary files a/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/coati.ico and b/ide_plugins/vs/vs2015/CoatiPlugin/CoatiPlugin/coati.ico differ 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 00000000..9073a6a1 Binary files /dev/null and b/web/documentation/img/vs_plugin_cdb.png differ diff --git a/web/documentation/img/vs_plugin_menu.png b/web/documentation/img/vs_plugin_menu.png new file mode 100644 index 00000000..6a054f37 Binary files /dev/null and b/web/documentation/img/vs_plugin_menu.png differ 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.

          +