From 84ce967a265731496bd97da0bfd2a8801f1e7e58 Mon Sep 17 00:00:00 2001 From: baltasar Date: Sat, 21 Sep 2024 09:18:52 +0200 Subject: [PATCH] Aggiungere i file di progetto. --- segugio.sln | 33 + segugio/App.config | 6 + segugio/ClassDiagram1.cd | 601 +++++++ segugio/ConfigExtraction.cs | 203 +++ segugio/FormContextMenu.cs | 59 + segugio/FormContextMenu.resx | 1562 ++++++++++++++++ segugio/Gateway.cs | 151 ++ segugio/MainForm.Designer.cs | 328 ++++ segugio/MainForm.cs | 516 ++++++ segugio/MainForm.resx | 1568 +++++++++++++++++ segugio/ProcessInfo.cs | 109 ++ segugio/ProcessInfoTracked.cs | 476 +++++ segugio/ProcessLaunch.cs | 342 ++++ segugio/ProcessListManager.cs | 601 +++++++ segugio/ProcessMonitor.cs | 200 +++ segugio/ProcessScan.cs | 677 +++++++ segugio/ProcessTreeView.cs | 340 ++++ segugio/Program.cs | 34 + segugio/Properties/AssemblyInfo.cs | 36 + segugio/Properties/Resources.Designer.cs | 123 ++ segugio/Properties/Resources.resx | 139 ++ segugio/Properties/Settings.Designer.cs | 29 + segugio/Properties/Settings.settings | 7 + segugio/Resources/118801_refresh_icon.png | Bin 0 -> 67654 bytes segugio/Resources/39368_executable_icon.png | Bin 0 -> 8128 bytes segugio/Resources/85334_file_open_icon.png | Bin 0 -> 9760 bytes segugio/Resources/rocket-start-512.png | Bin 0 -> 66625 bytes segugio/Resources/segugio_main_logo.ico | Bin 0 -> 86219 bytes segugio/Resources/segugio_main_logo.png | Bin 0 -> 411193 bytes segugio/Resources/shell32_3.ico | Bin 0 -> 23558 bytes segugio/Resources/stop-sign-512.png | Bin 0 -> 33775 bytes segugio/SettingsManager.cs | 100 ++ segugio/UpdateSignal.cs | 30 + segugio/Utils.cs | 84 + segugio/Yara.cs | 54 + segugio/YaraRules.cs | 215 +++ segugio/libyara/Constants.cs | 45 + segugio/libyara/Delegates.cs | 12 + segugio/libyara/Enums/YR_CALLBACK_MESSAGE.cs | 12 + segugio/libyara/Enums/YR_CALLBACK_RESULT.cs | 10 + segugio/libyara/Enums/YR_SCAN_FLAGS.cs | 11 + segugio/libyara/Methods.cs | 437 +++++ segugio/libyara/ObjRefHelper.cs | 165 ++ segugio/libyara/Types/FILE.cs | 14 + segugio/libyara/Types/RE_AST.cs | 19 + segugio/libyara/Types/RE_CLASS.cs | 18 + segugio/libyara/Types/RE_NODE.cs | 41 + segugio/libyara/Types/RE_NODE_UNION1.cs | 23 + segugio/libyara/Types/RE_NODE_UNION2.cs | 19 + segugio/libyara/Types/SETJMP_FLOAT128.cs | 14 + segugio/libyara/Types/Types.cs | 67 + segugio/libyara/Types/YARA_ERROR.cs | 65 + segugio/libyara/Types/YR_AC_MATCH.cs | 27 + .../libyara/Types/YR_AC_MATCH_TABLE_ENTRY.cs | 16 + segugio/libyara/Types/YR_ARENA.cs | 21 + segugio/libyara/Types/YR_ARENA_PAGE.cs | 38 + segugio/libyara/Types/YR_ATOMS_CONFIG.cs | 28 + .../Types/YR_ATOM_QUALITY_TABLE_ENTRY.cs | 18 + segugio/libyara/Types/YR_COMPILER.cs | 116 ++ segugio/libyara/Types/YR_CONFIG_NAME.cs | 15 + segugio/libyara/Types/YR_MATCH.cs | 54 + segugio/libyara/Types/YR_MATCHES.cs | 22 + segugio/libyara/Types/YR_META.cs | 33 + segugio/libyara/Types/YR_OBJ_REF.cs | 20 + segugio/libyara/Types/YR_PROFILING_INFO.cs | 24 + segugio/libyara/Types/YR_RELOC.cs | 18 + segugio/libyara/Types/YR_RULE.cs | 26 + segugio/libyara/Types/YR_RULES.cs | 42 + segugio/libyara/Types/YR_SCAN_CONTEXT.cs | 241 +++ segugio/libyara/Types/YR_STOPWATCH.cs | 44 + segugio/libyara/Types/YR_STRING.cs | 68 + segugio/libyara/YaraWrapper.cs | 1110 ++++++++++++ segugio/packages.config | 4 + segugio/segugio2.csproj | 217 +++ 74 files changed, 11797 insertions(+) create mode 100644 segugio.sln create mode 100644 segugio/App.config create mode 100644 segugio/ClassDiagram1.cd create mode 100644 segugio/ConfigExtraction.cs create mode 100644 segugio/FormContextMenu.cs create mode 100644 segugio/FormContextMenu.resx create mode 100644 segugio/Gateway.cs create mode 100644 segugio/MainForm.Designer.cs create mode 100644 segugio/MainForm.cs create mode 100644 segugio/MainForm.resx create mode 100644 segugio/ProcessInfo.cs create mode 100644 segugio/ProcessInfoTracked.cs create mode 100644 segugio/ProcessLaunch.cs create mode 100644 segugio/ProcessListManager.cs create mode 100644 segugio/ProcessMonitor.cs create mode 100644 segugio/ProcessScan.cs create mode 100644 segugio/ProcessTreeView.cs create mode 100644 segugio/Program.cs create mode 100644 segugio/Properties/AssemblyInfo.cs create mode 100644 segugio/Properties/Resources.Designer.cs create mode 100644 segugio/Properties/Resources.resx create mode 100644 segugio/Properties/Settings.Designer.cs create mode 100644 segugio/Properties/Settings.settings create mode 100644 segugio/Resources/118801_refresh_icon.png create mode 100644 segugio/Resources/39368_executable_icon.png create mode 100644 segugio/Resources/85334_file_open_icon.png create mode 100644 segugio/Resources/rocket-start-512.png create mode 100644 segugio/Resources/segugio_main_logo.ico create mode 100644 segugio/Resources/segugio_main_logo.png create mode 100644 segugio/Resources/shell32_3.ico create mode 100644 segugio/Resources/stop-sign-512.png create mode 100644 segugio/SettingsManager.cs create mode 100644 segugio/UpdateSignal.cs create mode 100644 segugio/Utils.cs create mode 100644 segugio/Yara.cs create mode 100644 segugio/YaraRules.cs create mode 100644 segugio/libyara/Constants.cs create mode 100644 segugio/libyara/Delegates.cs create mode 100644 segugio/libyara/Enums/YR_CALLBACK_MESSAGE.cs create mode 100644 segugio/libyara/Enums/YR_CALLBACK_RESULT.cs create mode 100644 segugio/libyara/Enums/YR_SCAN_FLAGS.cs create mode 100644 segugio/libyara/Methods.cs create mode 100644 segugio/libyara/ObjRefHelper.cs create mode 100644 segugio/libyara/Types/FILE.cs create mode 100644 segugio/libyara/Types/RE_AST.cs create mode 100644 segugio/libyara/Types/RE_CLASS.cs create mode 100644 segugio/libyara/Types/RE_NODE.cs create mode 100644 segugio/libyara/Types/RE_NODE_UNION1.cs create mode 100644 segugio/libyara/Types/RE_NODE_UNION2.cs create mode 100644 segugio/libyara/Types/SETJMP_FLOAT128.cs create mode 100644 segugio/libyara/Types/Types.cs create mode 100644 segugio/libyara/Types/YARA_ERROR.cs create mode 100644 segugio/libyara/Types/YR_AC_MATCH.cs create mode 100644 segugio/libyara/Types/YR_AC_MATCH_TABLE_ENTRY.cs create mode 100644 segugio/libyara/Types/YR_ARENA.cs create mode 100644 segugio/libyara/Types/YR_ARENA_PAGE.cs create mode 100644 segugio/libyara/Types/YR_ATOMS_CONFIG.cs create mode 100644 segugio/libyara/Types/YR_ATOM_QUALITY_TABLE_ENTRY.cs create mode 100644 segugio/libyara/Types/YR_COMPILER.cs create mode 100644 segugio/libyara/Types/YR_CONFIG_NAME.cs create mode 100644 segugio/libyara/Types/YR_MATCH.cs create mode 100644 segugio/libyara/Types/YR_MATCHES.cs create mode 100644 segugio/libyara/Types/YR_META.cs create mode 100644 segugio/libyara/Types/YR_OBJ_REF.cs create mode 100644 segugio/libyara/Types/YR_PROFILING_INFO.cs create mode 100644 segugio/libyara/Types/YR_RELOC.cs create mode 100644 segugio/libyara/Types/YR_RULE.cs create mode 100644 segugio/libyara/Types/YR_RULES.cs create mode 100644 segugio/libyara/Types/YR_SCAN_CONTEXT.cs create mode 100644 segugio/libyara/Types/YR_STOPWATCH.cs create mode 100644 segugio/libyara/Types/YR_STRING.cs create mode 100644 segugio/libyara/YaraWrapper.cs create mode 100644 segugio/packages.config create mode 100644 segugio/segugio2.csproj diff --git a/segugio.sln b/segugio.sln new file mode 100644 index 0000000..a28b7f1 --- /dev/null +++ b/segugio.sln @@ -0,0 +1,33 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.33328.57 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "segugio2", "segugio\segugio2.csproj", "{92BE4C1E-CDE8-4F13-8FBB-E5B9445B5077}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{3B4C869D-CE20-45B9-A082-F7C99AD5250A}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|x64 = Debug|x64 + Release|Any CPU = Release|Any CPU + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {92BE4C1E-CDE8-4F13-8FBB-E5B9445B5077}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {92BE4C1E-CDE8-4F13-8FBB-E5B9445B5077}.Debug|Any CPU.Build.0 = Debug|Any CPU + {92BE4C1E-CDE8-4F13-8FBB-E5B9445B5077}.Debug|x64.ActiveCfg = Debug|x64 + {92BE4C1E-CDE8-4F13-8FBB-E5B9445B5077}.Debug|x64.Build.0 = Debug|x64 + {92BE4C1E-CDE8-4F13-8FBB-E5B9445B5077}.Release|Any CPU.ActiveCfg = Release|Any CPU + {92BE4C1E-CDE8-4F13-8FBB-E5B9445B5077}.Release|Any CPU.Build.0 = Release|Any CPU + {92BE4C1E-CDE8-4F13-8FBB-E5B9445B5077}.Release|x64.ActiveCfg = Release|x64 + {92BE4C1E-CDE8-4F13-8FBB-E5B9445B5077}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {1287E09F-B3B5-4CD2-A937-344329A4EDEE} + EndGlobalSection +EndGlobal diff --git a/segugio/App.config b/segugio/App.config new file mode 100644 index 0000000..56efbc7 --- /dev/null +++ b/segugio/App.config @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/segugio/ClassDiagram1.cd b/segugio/ClassDiagram1.cd new file mode 100644 index 0000000..3ad5e73 --- /dev/null +++ b/segugio/ClassDiagram1.cd @@ -0,0 +1,601 @@ + + + + + + AQDAAAAIAAAAAAAAAAgAAAAAABAEAEIAAEQAAAEAAAA= + ConfigExtraction.cs + + + + + + AAAAAAAAACAAAAAAAAAAAAACAAAAAgAAAAAAAAAAAAA= + FormContextMenu.cs + + + + + + AAEhAAAAQAQIgAAIAgAIAgIAQACAAAAoIAAAQAgAAAA= + Gateway.cs + + + + + + IgAQEiAAACAAABQAQAKAQgACUBwAQAAACLGgICAIAAA= + MainForm.cs + + + + + + IQAABEAACAAAAABQAIAAAAIQAAAAAAAAEAAAAABAAAA= + ProcessInfo.cs + + + + + + EDgAAEAAgQAAUAkBUIAAQGIAgDEAIggAIyAAEAAAAAA= + ProcessInfoTracked.cs + + + + + + AAAQAAAAABAEYAEQACBAECwIkBAAAAwAggAiAAByEAg= + ProcessLaunch.cs + + + + + + ABIAAEAAAgAAAEAAAggAQAEAABAgAEMEBABQAAAAAIA= + ProcessListManager.cs + + + + + + AQAAAQAACAAAAABAAAAAACIAABAAAAAAEAAAAAAAAAA= + ProcessMonitor.cs + + + + + + ABEAFAAAAAAAAAhQAAAAAGhgABAEADAGigIAAAAEAAA= + ProcessScan.cs + + + + + + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAA= + Program.cs + + + + + + AAAAAAAAAEAAAIAgAAAAAAAAABCAAEAAAAAEAAAAAAA= + SettingsManager.cs + + + + + + IogAAEAEAAAAAAAAQgAAAAAAAAAAIAAAAAAAAACgAAA= + ProcessTreeView.cs + + + + + + ABAggABAACEAAAAAAAAAAAEAAAAAAAIAAACAAAAAAQA= + ProcessTreeView.cs + + + + + + AAAAAQgAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAQ= + UpdateSignal.cs + + + + + + AAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAIAAAAAAAAA= + Utils.cs + + + + + + AAAAAAAAAAAgAAAEgAAAAAQAAAAAAIAAAABAAAAAIAA= + Yara.cs + + + + + + AABEAAIAAAAAAJQgAAAAAAAAABAQAEAEIAAAAAAAAAA= + YaraRules.cs + + + + + + EAAAACCCgBRAAACQAgaCAAAAAAAAAAARAQAAANBAgAA= + libyara\Constants.cs + + + + + + ACACAVACCArYAACAC1AIAAQAAAjBMEgAwIUIEApAEQA= + libyara\Methods.cs + + + + + + AAYIAIEAEAAQAgAQAAAAkAACwBEREAAIAAAAIAAAAAA= + libyara\ObjRefHelper.cs + + + + + + AAAAAAAAACAAAAAAAAAAAAAAAAAAAAIAAAgAAAAAAAA= + libyara\YaraWrapper.cs + + + + + + + AAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= + libyara\YaraWrapper.cs + + + + + + AAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= + libyara\YaraWrapper.cs + + + + + + AAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= + libyara\YaraWrapper.cs + + + + + + + ABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= + libyara\YaraWrapper.cs + + + + + + AAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= + libyara\YaraWrapper.cs + + + + + + AAAAAAAAAAAAAAAEAAAAAAAAAAAAABAAAAAAAAAAwAA= + libyara\YaraWrapper.cs + + + + + + AAAAAAAAAAAAAAAAABAAAAAAAAAAAABAAAAAAAAAAAQ= + libyara\YaraWrapper.cs + + + + + + AAAAAAABAAAAAAAIBAAAAAAAAAAAAEAAAAAAQAAAAAA= + libyara\YaraWrapper.cs + + + + + + BAAAAAAAAAAgAABAAAAAAAgAAAAgQAAAAAAAAAAAAAA= + libyara\YaraWrapper.cs + + + + + + AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= + libyara\YaraWrapper.cs + + + + + + AgAIAIAAACAAAAAAAAAAAAARAAAAAAAAAAAABBAAAgA= + libyara\YaraWrapper.cs + + + + + + + AAAEAAAIASAAAACAAAAQAAAAYAAAAAACAgQIAAAAAEE= + libyara\YaraWrapper.cs + + + + + + + AQAgAADAEAAAAAAAgAAAAAAAAAAAAAAACCCAABBABAI= + libyara\YaraWrapper.cs + + + + + + AQAAAABAAAAAAAAAgAAAAAAAAAEEAAAAACCAAAAABAA= + libyara\YaraWrapper.cs + + + + + + ABAAAAAAAAAAAAwAAQAAAAAAAAAAAAAAAABAAAAAAAA= + libyara\YaraWrapper.cs + + + + + + AAAAAACAAAAAAEAAgAABEAAAAQAAAABAAAAAAAAAAIA= + + + + + + AAAAAAAAAAAAAAAAAAAAIAAAAAABAAAAAAAAAAAAAAA= + + + + + + AAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= + libyara\Types\FILE.cs + + + + + + AAAAAAAAAAAAAAAAAAAAgAAAAAEAAAAAAAAAAAAAAAQ= + libyara\Types\RE_AST.cs + + + + + + AEAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAA= + libyara\Types\RE_CLASS.cs + + + + + + AAAAAAAAAAAAAABAAAAAAAAAAABJAAAAAAAAAQAAgwA= + libyara\Types\RE_NODE.cs + + + + + + AAAAAAAAAAAAAAAgBAAAAAAAAAAAACAAAAAAAAAAAAA= + libyara\Types\RE_NODE_UNION1.cs + + + + + + AAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAA= + libyara\Types\RE_NODE_UNION2.cs + + + + + + AAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= + libyara\Types\SETJMP_FLOAT128.cs + + + + + + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAQAAA= + libyara\Types\YR_AC_MATCH.cs + + + + + + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAA= + libyara\Types\YR_AC_MATCH_TABLE_ENTRY.cs + + + + + + AAAAAAQAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAQ= + libyara\Types\YR_ARENA.cs + + + + + + AAAAAAAAAAAAAAAAAIAIAAAAgAIAAAAACABAQAIAAAA= + libyara\Types\YR_ARENA_PAGE.cs + + + + + + AAAAAAAAAEAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAA= + libyara\Types\YR_ATOM_QUALITY_TABLE_ENTRY.cs + + + + + + AAAAAAAAAAAAAAAAAAAAAEAQAAIBAAAAEAAAAAAAAAA= + libyara\Types\YR_ATOMS_CONFIG.cs + + + + + + CQjCBEKIiBCAFSoAACEgAIAwNKAEBSAgAQAQAAAAAAw= + libyara\Types\YR_COMPILER.cs + + + + + + AACCAAQEAAAAAAAAAAAAAAEAAEEAAAAAAABAAAIAAAA= + libyara\Types\YR_MATCH.cs + + + + + + AAAAAAAAgAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAgA= + libyara\Types\YR_MATCHES.cs + + + + + + AAAAAAAAAAAAAAAAAAAAAAAAAAIBAABAAAIAAAAAAAQ= + libyara\Types\YR_META.cs + + + + + + ACAACAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAA= + libyara\Types\YR_PROFILING_INFO.cs + + + + + + AACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAA= + libyara\Types\YR_RELOC.cs + + + + + + AAAAAAAAAAAAAQAAAAAAAAAAAAIAAABAgABAAAAAAAQ= + libyara\Types\YR_RULE.cs + + + + + + QAAAAAAACAAEAAAAAAAAAAAAQAECAAACgAIACAAEAAA= + libyara\Types\YR_RULES.cs + + + + + + AAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgA= + libyara\Types\YR_SCAN_CONTEXT.cs + + + + + + AAAAABAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAA= + libyara\Types\YR_SCAN_CONTEXT.cs + + + + + + AAhAAAIQIAAgAAAAAQAAAAAQIAYABBEAAIAAgAAEACQ= + libyara\Types\YR_SCAN_CONTEXT.cs + + + + + + AAhAAAIQIAAgAAAAAQAAAAAQIAYABBEAAIAAgAAEACQ= + libyara\Types\YR_SCAN_CONTEXT.cs + + + + + + AAhAAAIQIAAgAAAAAQAAAAAQIAYABBEAAIAAgAAEACQ= + libyara\Types\YR_SCAN_CONTEXT.cs + + + + + + AAAAAAAAAAAAAAAgAAAAAAAAAAAAAACAAAAAAAAAAAA= + libyara\Types\YR_STOPWATCH.cs + + + + + + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIEAAAAAAAA= + libyara\Types\YR_STOPWATCH.cs + + + + + + AAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAABAAAAAAAAAA= + libyara\Types\YR_STOPWATCH.cs + + + + + + AAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAQA= + libyara\Types\YR_STOPWATCH.cs + + + + + + AAAAAAAAAAgAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAA= + libyara\Types\YR_STOPWATCH.cs + + + + + + AAAAAAAAAAAAAAAAAIAAAAAAAEAAAAAAAAAAAAAAAAA= + libyara\Types\YR_STOPWATCH.cs + + + + + + AAAAAAAAAAAAAAAAAECAAAAAAAAAABBQQIAAAAAAAwQ= + libyara\Types\YR_STRING.cs + + + + + + AAAAAAAAAAAAAACAAAAAAACAAAAAAAABAAACAAAAAAQ= + libyara\Enums\YR_CALLBACK_MESSAGE.cs + + + + + + AAAACAAAAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= + libyara\Enums\YR_CALLBACK_RESULT.cs + + + + + + AAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAEAAAA= + libyara\Enums\YR_SCAN_FLAGS.cs + + + + + + AAAAAAAAACAAAAAAAAAAAAAAAAAAEAAQAAAIAAAAAAA= + libyara\Types\Types.cs + + + + + + iMgAxECSDCUMIIAp4AAAwAAgQSAgBkAjIBIQAEwEBJE= + libyara\Types\YARA_ERROR.cs + + + + + + AAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAIAAg= + libyara\Types\YR_CONFIG_NAME.cs + + + + + + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAAAAAAAAAA= + libyara\Delegates.cs + + + + + + AAAAACABAAAAABAAAAAAAAAAAAAEAAAEAAAAAAAAAAA= + libyara\Types\Types.cs + + + + + + AAACAAAAAACAABAAAAAAAAAAAAAAAAAEAAAAAAAAAAA= + libyara\Types\Types.cs + + + + + + AAAAAAAAAACAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAA= + libyara\Types\Types.cs + + + + + + AABAAAAAAIAAABAAAAAAAAAAAAAAAAAEAAAAAAAAAAA= + libyara\Types\Types.cs + + + + + + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAAAAAAAAAA= + libyara\Types\Types.cs + + + + + + AAAAAAABAAAAAAAAAAAAAAAAAAAAEAAEAAAAAAAAAAA= + libyara\Types\Types.cs + + + + \ No newline at end of file diff --git a/segugio/ConfigExtraction.cs b/segugio/ConfigExtraction.cs new file mode 100644 index 0000000..1af4ca2 --- /dev/null +++ b/segugio/ConfigExtraction.cs @@ -0,0 +1,203 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace segugio +{ + public class ConfigExtraction + { + + public Dictionary dictConfigExtractors = new Dictionary(); + + MainForm form; + + string pyhtonExecutablePath; + string configExtractorsDirectory; + int numberOfConfigExtractors = 0; + int noOfScriptWithoutNameCounter = 0; //counter for rule without a name + + Gateway gw; + + public ConfigExtraction(Gateway gw) + { + this.gw = gw; + this.form = gw.mainForm; + + //define python.exe path + pyhtonExecutablePath = gw.settings.GetSetting("PythonExecutablePath"); + + //define config extractors dir + configExtractorsDirectory = gw.settings.GetSetting("ConfigExtractorsDirectory"); + + //check paths + gw.ut.CheckPaths("file",pyhtonExecutablePath); + gw.ut.CheckPaths("directory",configExtractorsDirectory); + + //load pyhton scripts + LoadConfigExtractorScripts(); + } + + + + public Boolean existsConfigExtractorByRule(string matchedYaraRule) + { + if (this.dictConfigExtractors.TryGetValue(matchedYaraRule, out string pythonScriptPath)) + { + return true; + } + else + { + return false; + } + } + + public string getConfigExtractorPathByRule(string matchedYaraRule) + { + if (this.dictConfigExtractors.TryGetValue(matchedYaraRule, out string pythonScriptPath)) + { + return pythonScriptPath; + } + else + { + return null; + } + + } + + private void LoadConfigExtractorScripts() + { + + + foreach (string pyFile in Directory.GetFiles(configExtractorsDirectory, "*.py")) + { + + String pyScriptName = ExtractScriptName(pyFile); + + //add to dict (NO DUPLICATES) + if (!dictConfigExtractors.ContainsKey(pyScriptName)) + { + dictConfigExtractors.Add(pyScriptName, pyFile); + } + + } + + numberOfConfigExtractors = dictConfigExtractors.Count; + string message = $"succesfully loaded {numberOfConfigExtractors} py scripts"; + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.NewLogMessage, + LogMessage = message + }); + + + + + } + + + + //method for launching a python script once the process has been tegged malicious to + //extract the configuration + public (bool, string) pyExecConfScript(string scriptPath, string dumpFileName) + { + Boolean configFound = false; + System.Diagnostics.Debug.WriteLine($"launching PYTHON SCRIPT at: {scriptPath}"); + string result = ""; + try + { + ProcessStartInfo start = new ProcessStartInfo(); + start.FileName = pyhtonExecutablePath; + start.Arguments = string.Format("\"{0}\" \"{1}\"", scriptPath, dumpFileName); + start.UseShellExecute = false; + start.CreateNoWindow = true; + start.RedirectStandardOutput = true; + start.RedirectStandardError = true; + + using (Process process = Process.Start(start)) + { + using (StreamReader reader = process.StandardOutput) + { + result = reader.ReadToEnd(); + + + System.Diagnostics.Debug.WriteLine($"output script {result}"); + + + } + //using (StreamReader reader = process.StandardError) + //{ + // result = reader.ReadToEnd(); + // //usa i segnali per comunicare le modifiche alla GUI + + // System.Diagnostics.Debug.WriteLine($"output script error: {result}"); + + + //} + } + } + catch (Exception ex) + { + System.Diagnostics.Debug.WriteLine("Error running Python script: " + ex.Message); + + return (configFound, ex.Message); + } + + if (result.Length > 0) + { + //update FLag + configFound = true; + + // Removes all non-printable characters except space, tab, newline, and carriage return. + result = Regex.Replace(result, "[^\\x20-\\x7E\\t\\n\\r]", string.Empty); + + return (configFound, result); + + } + else + { + //default false, empty + return (configFound, result); + } + + } + + + private string ExtractScriptName(string filePath) + { + //regex for finding __script_name__ + string pattern = @"^\s*__script_name__\s*=\s*""([^""]+)"""; + try + { + string fileContent = File.ReadAllText(filePath); + //use regex to repeat search at every line + Match match = Regex.Match(fileContent, pattern, RegexOptions.Multiline); + if (match.Success) + { + return match.Groups[1].Value; + } + else + { + noOfScriptWithoutNameCounter++; + return ($"NoScriptName{noOfScriptWithoutNameCounter}"); + } + } + catch (Exception ex) + { + Console.WriteLine($"An error occurred: {ex.Message}"); + return null; + } + + } + + } +} + + + + diff --git a/segugio/FormContextMenu.cs b/segugio/FormContextMenu.cs new file mode 100644 index 0000000..505e63a --- /dev/null +++ b/segugio/FormContextMenu.cs @@ -0,0 +1,59 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace segugio +{ + public class FormContextMenu:Form + { + public TextBox contenutoBox; + public Button closeButton; + + public FormContextMenu() + { + InitializeComponent(); + } + + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FormContextMenu)); + this.contenutoBox = new System.Windows.Forms.TextBox(); + this.closeButton = new System.Windows.Forms.Button(); + this.SuspendLayout(); + // + // contenutoBox + // + this.contenutoBox.Location = new System.Drawing.Point(12, 12); + this.contenutoBox.Multiline = true; + this.contenutoBox.Name = "contenutoBox"; + this.contenutoBox.ScrollBars = System.Windows.Forms.ScrollBars.Vertical; + this.contenutoBox.Size = new System.Drawing.Size(869, 432); + this.contenutoBox.TabIndex = 0; + // + // closeButton + // + this.closeButton.Location = new System.Drawing.Point(414, 450); + this.closeButton.Name = "closeButton"; + this.closeButton.Size = new System.Drawing.Size(75, 32); + this.closeButton.TabIndex = 1; + this.closeButton.Text = "Close"; + this.closeButton.UseVisualStyleBackColor = true; + // + // FormContextMenu + // + this.ClientSize = new System.Drawing.Size(893, 485); + this.Controls.Add(this.closeButton); + this.Controls.Add(this.contenutoBox); + this.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.Name = "FormContextMenu"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.ResumeLayout(false); + this.PerformLayout(); + + } + } +} diff --git a/segugio/FormContextMenu.resx b/segugio/FormContextMenu.resx new file mode 100644 index 0000000..34a5144 --- /dev/null +++ b/segugio/FormContextMenu.resx @@ -0,0 +1,1562 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + AAABAAEAAAAAAAEAIAC1UAEAFgAAAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAAAFv + ck5UAc+id5oAAIAASURBVHja7L0FYFVntj3O/72+93sjFSTu7u4GgQhJIIQEbwuFFuruU3c3SnG3ttSd + lrpQWqAtbvEECxJ3W/+9v++cc8+999wk0M5MZ6Z01pyb63L2+vbe395rDwLw//2B3x96enrUy4Ms/02Z + ceU5IbGjzvUOSXJzD4gPd/OLzXb1iZpOuM3FO+o5F+/oNYQPnb2ithD2OnlHlROOEeoILYROQg8BCnqc + faI7CS3KfY4pj+HHbiF8SFhDtz9HuI0w3dU3JtvNPy7cMyjBLTgm/dzJ0688x/J98nu3+Cx/4HeGQX98 + Cb8rmBnQA48++18h0aPO8wxM9nHzi08jo7vExTfmAcJqMsLPCXsIh8k4G5y9ItoJPWTw0MPJKxI6Q7cC + Pd4m9PdzpOdy8IykYyQTRzu/JoFfew+B3wu/J3pv0Ze4+sWmETH4BEenn3f/w0//lxEp/IE/COA/Fr29 + vYYGHxo78q8eAfG+ZOCjyZhuJix38Yn51tknpsLJO7rRYtWGs3e0gJNq6ARnM9D1wmgjBJy8I8+QAPi5 + o6Xx0/PZ03M5eCpkoIOjuE80XRboke+V33PMt06+scudfONudvGLH+0elOwbGp/9VyNC0H0nf+APAvg3 + /sJ1/4KiR5xHbnSoi2/UNGfvyGfIQD8joyTDiWqVBmq9EpuBV3kySidhmBKOnuH0N4OM3oMRTkYp4WhB + AJYGT8SjvZ4jPZe9u8Qw9wgMpecZRs9n7xEl4RlDiBZwUGDvJeHoFUPvLYZej+ATq6KViKCC8JmzX/wz + Lv7x09wCk0KDYjLOsyCEP86TPwjg33OVzxgz5X+9gpM8yUUuIEN7kgztS8JRWrm7nHiFFqu4XGHV1Zeh + ufMGBOAojD6CDFDC0SNMARm8uwJPxQNQwgFnvfH7suETvNlwI+ESEI+g+FFIyMxHev5kZI6/EJmFFyJ9 + 3CQkZI1DaGIGPEMTYUf3HeJK5ODKhBBDry2hGr947/wZyPidfOKIAOLg5BuvgC/HdRGOOvvGfenqG/+k + m19CgVdwsmcmfUd/eAd/EMC/TSwfnZzzZ8+gxHBa6a8kw3+VVtliQrveiJ2UVVy462IljxZG5OypwAYB + yLicV+VwDQ7uOsNXoD63lhvwNq34wkh9YxGenIvZN92FtW+/j5/270dZTSWO1B/F8cYTqGk4geP1x1F1 + ohr7yw/g222bsfqNDbjloceQM3UmAhMzYU8GPtSNyMCdVnvPaF2YEkuIJwJgw09QEGcGFx+BdhffWP5u + XqXv6UqPwITwqKTsP/+RO/iDAP5lVnv1ZI1LG/Nn7+DkSPeA+BvJ8D+gE/oooZdOcGF0qqst4nd2td3C + YOcaCgdetdlwfGJEPG1H7redK63s5II7ebLxKoblJQlCxN1nQADsAfBK78KuOV12C0xEWt40PPDCQmzd + fwCNnW3oQRd60Y5utNLlFg299DfoCHFktNF9mnG6uQY/HdyBFW+8gmvvugcjx06Bf3QqXPzYM+D3xqRG + pOBNhu+TqBCA9ARo9RdwIS+BScDZJ0Z6I74x9F3FHCV8QN/fjZ5BCZExKTl6MvjDK/iDAH5fRl80bc45 + PqGp/h6BiVe6ByS8RzhGJy9cA+gE948FEQBcBQHwCc4uOBmyexjc/SIxMr8IN9/3MF5avR4vv/chNnzw + MZa9+iYenbsQV996D3InzURIYg5cyWAFMXjoEm8DIgAJTgzyY7xCU1E08yqsePsdlB0/QubeQcbcIYy+ + u5cMXgORQG8beunY28NoE3/39LYroNuICEDPAHp8B93n+Onj2Lb7Z7zyzhu4/8lHcfGcyzE8uwD+EcPh + 7C/zAQ5edPSKE96Bi0+MOSkqnoke9N0dI7zHXhSFUP6FUy875w8y+IMA/ino7u4xM/zgmJF23iHJ48jw + V5DRlxN6CGD0RQCOXmEYNWY8GcpbOHL6MDp7m2ml5RWYDAud9BLd4H+8Ip9oOo0fD+zFyx99hNsffRaj + JsyCZ0iqcLU58dcXATgpeQF7txAy/ERMnHMdXv/sC5xsqVNer41ewdLwJUzG3a4ZuUSXDh3CYzCBb+8U + t/HjWzvqcfhEJb7/eQtWv/Uq7n7qKVx01TUYWTABYcmj4BZEhOAtthfNE5IEVx+NAFT0EOg7jl/hGZQ0 + jr97PRGov80f+IMA/l4rvjjZLr7sunN8w1JDaDW6g+L7LZ6BCa0e/vFwJ7jxMUBCEAAbP8HFT3H//Tg7 + HoGCadOxv2SPYljNZIAN6OqtJ/OpRUt3HcqPleHrH7/GhvdexaK1izFvxSI6LsczCxdh6pyb4Bcxgggg + ypgAOAlIRwdXDi2C4ROeSEZ3Ld76/GOcaD5N1MIkw4TTpLj4rcLF7+2VhMDufXtvB461tmP3qWZ8W92A + TSW1+ODQaby9vxYf7TuJzcVHcfBoDU421qO9u01QlQQbfqcgsR6FHKCQApNDJ71OU2cdjhLp7Ti4E+98 + 8iEeePo5Ch0miLCBtyo5ScmhiqtCBDpPQIC/VyLYVo/AhC2EO7xDUkKmzrr6HDVX8IdH8AcB/F227mLT + 8v7iE5o8igx/MRl+JQECtNp7+MXBjeFvgm7lEhBJN3L9Y0Zm4+d9u4Xx9/aQIfZKY+zuZWM6gdWvrEJ6 + zlj4h/NzsuseSkYRRkbBK3oYGTln+SN1BBChYRjdNtQtmG4LQ0xKFq6/6z58/uN3qGuvFTF7N78OGun1 + GsggGwnNhBbt2NTTgW1H6zH3u6O4+u1KTHulHIVrKzF2TSWyV5djxNJSpD35E4bfsAaZs+7GhDm34Kb7 + HsH8Vavw2bdfo/zIYbS1t0P+61U8mU5BCr29jA5BBAxJEJ30XwcqjlXi4aeegV8YhQbktbh6y50Jy7DA + RAA6og2Ir3QLjF/sGZw0Kjop5y9/bCn+QQC/aXwfGp81xCc0ZSIZ/rtk8HWq4ZPbD08GrfqSANjQY6wM + Xw8n/yg8OX++OOl7yPj1BMBG2dhyFNNnzoSDSwhcdRV9LpxR91J3C6IkPKJppY+GvWskhrrQak8rf1Ds + cEyZPRtLX1mNA+UH0dHdJJJ3bPTS8Pl1TAQg/24S5FDZ2IQXt1Rj2ssHkL+ynIy+GmNePoKxG45h3Osn + MGYdkcCLW5Fy02pEjL0OgbG58A5Kos8eQ4hCQFg80rLGYs5VN2DRslX4bsuPqDp8BM1tnFDsVghB/6+X + /uMgp0N4JS2dzZi3eCn8ghPos0eKz2xJAnovwAxMBIEJde6BCe96hiRNDInLGPJHnuAPAvhVhh8Uk2FP + sfZMz+CUL8n42wjQG78a67Pxu1N87yaMP1ojAf2qxXkAZzpGp2Vjf2mxiPW7yTh7e5rMjLK7txbvf/g2 + kpOz4ewWCgcCx/EuXvS8XBPACUD3CLFzYO8aDjefWMQm52LmFddhyaoV2LnvJzS21ZBhScPv7aXXoPBC + Bb+GCfVkeHWCCErqG3DfxgpMoFV+HK34BeuqMW79YYx/tQoTl+9E7v0bEDv5VngljIUjEZ4ThTEu5K67 + kpG6UazuRgbqTt6Nu08EIRxefhEIiUrGyOwCzJh9Ne555GEsWb0SH322CT/+tA179u/FgUMHcKjkAOqb + TxIJyPxHa2sLbrntXrgpz+9iUbCk9wLMES/zLoH0mwQlttFv9KVnUNLMgMgR9n8QwR8EMKDmG1OFXoa9 + d3DqbDL8zR7BKZ0EsPGfKQGoJCAJgPfcY3EtndytXWT8Pa3SA+g1J4AeMsj2rlPYuWsrHn/qaRRMvggx + ySOFMQVHJCE0MhkJwzMwfupFuOvBR/HmRx9gf+VeNHXUiMf2EnoolOjpaVSM35wALImgq/c0mruasGjL + YUxaU4HC1dXIp+PY1UQCq4qRdd9r8BlxMYZ6xWCYcyB5Gv6wcwukEISIyStCxOvsrksSIALwJSLwY8TI + y758XSQ8fCPg5R+JgOBYhEUmITJuOKLj0xEVl4rHnn6KPjN5Kb2tIlz4eedORCeMIo9HkoA+MThAAlB+ + o4ROum4zXZ4dFJ2uEUH3H81JfxCAiq6ubi25FxabNZgM/xIy/G/Z8D2DyPAJfPQg4/cwJACOQVXjl9CM + Xt3KEgQQR49JwoebvhLJsp4eXp2bRQKwt7fRzDi7e+rIGE4LIjhVW41DxTvxy+4fsH3X99i5fxvKq/aj + rv4IOrvl6i0NvlZ4Dz29TAANZs9pvupLyNvqiQBqsbumFle+UYYJ5PIXrarC+BVk/CvKMPymZXAOGUWe + RhgcyRNxdJW7CQ4eIdq2okjYccbeN0aQgCQ+zn/EK8dYERoxQTJ4J8TNlwlTIU16fEziKOzcvVckC3n3 + oZ1Cgetv/hu9TpgWBqhJQf3OgEEIIMOyICvQb5n4LRH4JaGxGYPVZKHy2/9BAP+Zht+luftxw8f8xSc0 + tZCM/VOvoNR2z+BUsc3mRUciBDoSCYQkSwKwIAEPXnEC+SQ0Gb8lnH1jRUlses4kHK05QW5/hyAANn4j + AuhhAug+hS5CT89p+TcZeBdqaX08LS53d0vwbXqwUdta7Q0JgDyFDb/Q6r+aCaCKCKASE4gAch/aCLeI + HGGEYjtRbCuGyZXfM8xUWairKnTVYvR4MwIQxuqjEAQZvqtPnAhd3H1iBAkwgTz29Ity56C3TRDBR5s+ + g09InLYjIAjA2wYBKMZP8b/4XfSemh70e7XT8VOvkOTC6NS8v6hhgXou/EEA/2Fx/vTLrj/HJzQljU6Y + DV5BSU1egcl0oqSSoafBIyQNgggEJAF4mhEAnWx8wgWy6xmrEICsq5cua4yCWFHwwhVx9z3yJBlvO3q6 + ydUV7q5tAhArek+tPJKhd3Wf1qAavzkByPsKbwANAwDF/+QtNHc24PHPSlC4qkKu/iurMGF5GaImP0jv + mZt91B4D2VjEW4yckzAiABNidVCIQQFX/TEBSMQKT8DZOwbpo4uIHI8pdRBtOFF7AuMnXSxeUyZBzQnA + KiHIOwL9E4A8BiU2EZlv8A5LTbvkspvO+U/OD/xHEUAnMb0aB/pHDPejE+VZOiFqxEnD0BOAAF9OgXEO + IB6eZPgeZsbPCatIWeXnHa00xRA8Y+AXmoTNP/4gi2V61JLavgjAHHqjN1z9hftfKwx7IATQDen+n2yp + xe3v7BEuf+GKKor7KzHupT3wTpml9v8rXYYKPCLMewt0SToj78cKStmvCuEpCCKIxlvvvU/fTxcRE5ci + d2LhkhXaTogkgBhBALZ2BDgc81BIoC9o4Vxwcg15eM/6h6f7qedF53+YN/AfQQDd3d3aqh8en3mBd0jy + FWTMe/UnBXkA/RKAyfg59qeYngzfw8z4JQGoffeyVJfgFokp0y9DA1ffcVltb4tSV88E0GRAAPWGJGAT + vTL5JxKAA1r9FZC3cLyxHre8sQ/jl5eT608eABFA/nM/wT2ySHYRepoIwMkCKgFYthcbhkFqJp+MWDYI + 6YkgVtQ2zLnmBrR2clFUp9g23Lt/P+ISsy08APNkoGUugPMy/RGAp4kARI7HKzh5L58TfG6Yqgq7/yCA + f6fs/gvzl/+Xb1hqqrKX32F9YtAJwQQQmKIZvQnJZis/x/zs9lsTgHnvvoMioOFEbvOq9etlhZyy528r + O38m6Om1jOkbzowA0Iia5kbc/sZeFCwrQ9HyKhRRCFBABOASWSgKiywNX9UdUAnAyWvgAiOWBKAnAvaY + wuOHY2/xPlEg1EMk0NregsuvvkkQEZOrK5Erbzdq+QQrAogfEAF4BSUryd1kzRug86KDzw0KCVOfm7dU + qBj9J0iZDfo3z+4L4w+JGeVAP+z9xPJHbcWHAoIA6KSgE8NdB/67TwLwtyYAqZrD1XkhiIobjpLSUpnl + 1oz/1xNAL86eAHoFmtBERvbIB+QBLC3DRCIA4QUs2AOPpJlKJ1+EQbuyOQE4ekUOnARsEACDxUyWr10r + qgd7emTPwcuvvwY338jfjABEKGdMAOp9+By5Pyg63eE/IUn4b0kAHR2dwvBvv+ex//YLS80kw/+C0ENA + nwSgeAJmhh+ov3+C4v7LEMAtIEbARADm+nmMIc5BmDX7KrR38L5/21kQQL3Ova+ziPHrDa7rf9WXlX+y + /qCT3tPq78n4lxVj0vJqQQCFy8sQXHC3lADziRDNOk4Gq738rJFnRgBWiNEIwMEzFDMuuxLNbVwW3SF2 + BcqqypA8cjScPcM14zffcRg4AXgIg1ehCwGCrM6LHvr7C9/QlMzb7n7kv/lc4nPqDwL4F1HSFeW7cRnD + aNW/j4y+hg1fRf8EkKicIHL/X54c6m3x8AiwIACLHIAlAdg5B2L5qlWiwEXu/Z8hAcCSAOoMCKDujAiA + jb9LoFk0An1ZXIMLVxwgD6BaJAILV1ZjxC2vwd5/uOzUEzkNReGnD4HRMzd+tcAnTgkDohAanYpde3eL + AuGuXtlifOe991MYFSJXfZ9Y412AfgkgSfym7rpV30QAKYbnBV1Xw+cQn0uqN/DvFhb82xBAe3vH/6eo + xgyiVT+RjH2juuoPhADUPX1xFC5/ioJkmR+w4QEI4/eL1oxfTwD27uEICY/H3gO7AO6dNyOAxrMggHoD + D6B+AB5AowWalKagZtEVWHy6Hle9fBBFy3j1r0QBEUD+vN3wGXEFhTFxpt0MofEXJUVLzGAihzNd/fUe + gBAF8QjHSwuXiB4B0S+BNnz82Sb4BKquf6zcTjQkARMBeOhg8gCSBMRvKvI6yUo4kKT7jc3DBeUc2ugX + npaonl/KufYHAfzeEn1JI8f9iRj7CvrBytVtOxUDIQCttJfcfg/OBQSa8gCW93ELiNOt/jHW8b8nN+gE + YeZlc9Da3iD2/nuV0l/ZeXfmBNBXSW/faOoDzajvbMXjG0tRuKSMCKAC41ZWEqqQdssbsA/MIuOPJ8Qq + BBBNXgGrFpmrE0mCiBqQxLhm/BY5AK4N4E7ACVNnoKGZPZUuQQDHaqqROXo8XDwjBQG4+VgJhujbhMXv + xIVBanGQZXWgKQfQvzeoO3fK+dzic+zfKUE46N/F5Q+KSnenH2gR/VCtqqHbgq0f211z75MkApOUXECS + 2e3C+M32/40IgJt2QvDyK6+IZBYTQE9Pkyj/PTsCqD9L42/shwBaaKVtxwf7ajB52X4ULS8nD4AIgIuC + lhUjfMojsPdJgTN7At6Kwq8Q+4w2rf6aCOivJwBuePIPi8MPP29VugU7xNbp3fc9DGd3zgPEKcIq1iSg + 3wrUCCDABFOyV9nxGSAB6Eiglc8xPtf+XUKCf1kC6OjsNLn84Wkp9ON8Y+nq/1oC8AhMsr49UDF+Xfxv + PUSDVkn3KMQmpKOsvFQo43SLtl9VaUchAQNDNhm+uuoPtLS3SddYNED0cpswow1VjS249fV9KFxaivFk + /IVrqlGwrhL5C35ByPg7Ye+bQobPXkBcn3Ll/bn9hvdRicCLEUOhUwienjdX0RFoF8dNn38Gn6A4s0pA + WySgN3pDAjgDWHqQCr7hc049/5Rz8Q8C+Eehrb1drPo5BRf/r29oyiX0g1QYxfpGP96ZEYD1bZrxKwSg + lv5aynXbOQXjqqtvQFdXm6Kt12JAAI0CxgRQr6z6AyGAxrMgAElIXWgRkmCdve14e+cRTFq+F4VEABPX + HEbhWiICIoGCxbsQOfNpOIVkCS0/IVV+lgRgvDWoJwAuCorE+GkzUNd8UpMaqzl5HNljJtBrhKvCoX0S + gJt/vE445OyJwAYBMCr43ONzkM9FPif/IIB/UBMPf+GRidkX+IalPkIuWSMBljD4wc6AABiJZgSgxv+W + q78kAEu9/kg4uoZgw2uviz1tIbelKOua1HdMMLUDNyrGrA8PGq2SeCpxmKCEFr2quIgC7bKl4TfrRD9Z + D7BNiIIea2nH3e/vw4RVJZi0tgIT1lYTqlBEJFC0qhjp974Dr1GXw47VfT2jTSrFNgkgSunmMyYGtcmH + VYpdRH2ABIcUgVGp2PbLVmX3RBYGPfzEU3RbaJ8egHWrsDUB2OgYtEoe2jB8AZ/QJEajb1jKI3wu8jn5 + r1gv8C9DAPomnqDokR5k5OsI3UbG3xcJWBKAKfuvtPZanDDqbWr2382i9p9hufXH2f/ImOEoLjmkuLGK + lHav1NuTJNBiYfy6zL4o8a2n+9ebrfi9CiDQqEOTUlbcYoBmU8+BJv8lZb1VsU8pA94h6vC/rzyFWesP + oYi1AdZVC4xfX4nxL1dg/CuVyFu8E9GXvwC3qPGw94iHg4dxDYAIE4SKEWsGRPZDABbyXz4xgkTnLVys + KwrqxJZtWxAYmSgakFx8BkYARh5AfwTgPnACgHIOruNz8l+xqWjQv1qyzz9ieLRPaOqXfRm+MH6CFxu8 + EQHwPrDK9FqiKN5i1Yg3iCP5Pqrsl/nqLyrkPCKEtv8w52DMuHQO2jrIUHvbFWPTo9XCOFUDlgbNbn+P + 0AVoQFd3PTq669DWWYuW9lNoajmJ+qbjOF1/FDWnDgvF3bJjZThQXYY95cX4pfgAfjq0Hz8fPIDdpaU4 + UFWBkmOVqDhejerjR3C45giqa6pRebxKQTU9x2EcPX0cpxpO4WhDHZ7/4iAKl+/GhNVl5AlUYtK6Ckxa + X46J6ysw8dVqTNlQiXHztyLuyhfhljQJ9mSMQohUmz+oQMwntCSAKA2qd2BEAPx9XjTzKrS0srfSIfIo + Dc2nMPHCi0V7svAazpIA+qwB0W0dWhKAjx7C+JMViHPuS//wtOh/teTgoN+/y28q6fULS82iL3qXfoXX + r/SWq79nqISXgQfgrsKQACzdR53Kr07pRz/cw4nr5hUpbjvXQCxYuliRx24TxTbtXU1obK3DybrjqDpW + joNl+7Fj7y/Y/ONmfPTpx3jtrTewbPUavLBwKR55Zi7uefRp3HrvI7j29vsw+4Y7MP3KGzHpkitRMPUy + 5BTNRGb+dIzImYrEUUWITstHeHI+QuJzERCbDf/YTATF5SA8cTxihhchLr0QcSPykThiDFJG5CF5RA5d + zkFSep5AyqgxSM8eh6wxRcgpmITh+dMQPGo6QnOuRsTY6xFRcAsiCu9A1MS7EHvRo0iYMw/Jd7yCrMc+ + wtiH3kbC5NvgGZaurPy64aSCCCQpmBNApBksCUD1DmISs7G/+KDwTHoVb+X5ec/DhUiWcwWuPjF97gb8 + 2hyAFQEEJ8M3WB5teAa7+Bw1lRB3/0EAv0Wm/8HHnv8virUm0xdcqTd0Y9dsYATgYUUACQYEYA2T0o8u + 9leMnzvaWKvPmVbD5xcswYb3PsSj85bghvsfwyXX3onCi69F1vjLkJRzESLSpyAo9SL4JEyFc8xk2EdN + wZCIyRgcMRUXMCKn4YKoi3BB9MUYHDsdQ+MvwdCEGYTpsKPL9vEzCBfBIXYKnKMnwSVmAh0L4RJXBLeE + InikTIbPiBkIyLwcfhmXwzW+UAz6dHAMgqNTKBxdaMV2CRdwoMsOLqGwcwnBMNdg2NORr7dzJW+GPs8w + PipgAdJh7tEY6hkHO99UOIfmwCMyn77nkfQdJgsREOGeCzfd1B5tmwCMPACl75+IY+W6dYqYaKfA199+ + Cd/AeLotzqrb8HdAAIxKPlf5nP1X2CH43RJAR4es7CuaNvt/lOKeE3186bC1C9B/DuDsCUC6uRFy+AYR + gL17qJDMciKjCY7OhFd4BpyCRsAhKAtOYflwj50mquv88m6DX9EjCLhwLkJmLUbY5SsRde16RN/0OmJu + fxfxd32I5Ps2Ie2hLzH80W+Q/uRmZDz7AzKf24qs537EaMazPyL72S10VPG9QM7zW5D3wo8Yu+gnjFu1 + C5NeOYSpr5Vi0uKf4REzEXYUnji4qYND6L17SHVhoTCsQP3bwdM2uDCIZ/65MHwS4eqbCDe/JAJfjlf6 + /q3LfQekGaCAQ4icgqn4addO1Jw4gvr6Guzc9QtiEzPIwzAJjvxaD0C/PTzQHEA/OMHnbNG0Of8jSKCj + 4w8CONOyXnajssdO/1+fkNRb6QttONMfYaDbgLYIQC/lbW38auEPT90N103iJQKgFdQtIguR+beS23w3 + Yi9+DKnXLkX2PW9i3DNfYPyCrShcsgNFy/dhwsqDKFpZjMJVxSig49gVhOUlGLOsFGOWMsqQt6QMuUvk + MW9pOV1XjrxlhOUVJqyoRN7KSoxZVY381YcxbvURFKw/gsLXjmHy2ycx5YPTuOStU/BNnSXyEyYCCNeM + 3Qi2jZ+NM04SgE+CBiYBhotPvGLwMVYNP0ZGa7mKm11HnsHN9z6Fb7dux5at32PNy+uQOHy03DpUtAT0 + zzmgJKCB8av4jQiA0UAkcGt2/oVim/D3Wj486Pdn/HKPP2Vk0Z98QtLu8Q5ObdWMN1TBAAlAlfAyKgU+ + sxBA5gAkAZgaf6Rajm4kt3sI7Mk40m5ZjnHLSpBPhjxuZTkKV1eiaB3vqVehYA2jUirvrKig+5QLg89d + WoKcJcXIWVyM0YyFEjkqFvFtJchlLFFRSqRARLGsTEEFxhAZjF1ZTa97BEVrj2PyK6cx5e16TN1wDF5J + FD44hxABhOkIQDdnQIGjCtUr8IwWY7/VeYSSANgDiIMTT/0l43f2TVAMX67+Jkk0S4m0GINmoGiTt6Db + 4+fGH04GZoybiU2bf8aOA4ew4+BB3PvYM+I3cdaRipab4SRtgA0CUEuDjVb/EPPksOevIABTGJrU6hOa + dE/yqPw//V5JYNDv0fgT0sf+mVb+h8j421iUU/1ixY+kkMBACMDU9WUiAX0S0M0sARg/QPc/WlP9kdt+ + JgKwcwuFa9IkjF24G3mrjtCqXIWxvCqvqqJVmQx+dYXAWCKF/OXlGMtGyys8GTUb+OiFh5C94CCyFx6U + Rz3oOr599CITmCxyCXlEBowxipeQt4y8geWH6XWPYvy6Gox/o5a8jEo4R00U8b0ZAVgIfjjqRT9Ub8Az + xqzcV639VwnAkTv5uI7fO04p6om2bhTifImPcb2APgdg5s6zcRPR+ISOwPzVb2FHCe9oHMWXW7ciNi1H + vB6HG1J8NK5fAlDLgy0JwFN/rvSRA+ijKMiAAPhyIqONLj+UNLLgz5IE2v8ggL7c/oQR+X+mL/AR75CU + dm9FlddsRQ8ZuAdgSQD6WM89UIG2+scbhgCGBOBt0soTclmKMQ3h2P/Cx5G3+hi55Ycxhgggn8B19fkr + KxTQir+8TLj4ebzqk/GPJuNnA89acACZ8/cLZOkg/qbbVGgkwaQgyEB6DTmLSwllyCESyFleiRzyBHLX + HEXehlPImbsLdgG5YtCIg3uomCHoIDyACDPj1xOAIw8h4RyBcPujdQRg8gK4P4AVj52E+KlSyGNGACaJ + NKuiIW+5i+JiOAZMFQ+NF+XHs667Gz/uK0YpEUBFzTHMuvom8VpufglmCsSCAGwUAmkEYNkgpJ4rfVQB + WpWU93EeSuNP0iG5nc9pPrd/b57AoN9Lwk+4/RnjuZvvIf7CiABgSQBn4pL1SwBqw09AotkWoK2RXhoB + sAuriGOYCEAmAYf4JCPt3g8wemUNcmkFZnc8XwXF6mPVVZ+Mn1340eTyswFnkSFnkGGPmr9PQ+ZLEhkv + 7TO7PmOBOTlkzZeEkElhAiN7UQmyKTTIotAik0ggkzyQ7FdO0vvahKGeaYIAOFlpxzsWHiYvQG/4lnDS + jSgzVTvGmMM7xlosRBBluKgPkFuDFgSgE/w03wbUtwgniFwDb3W+8/l3KK85jhPNdVi8Zr3QZnDzTzCT + Hx9oNaBa5DWQMmCrXhL1vOqjSEiu/mbXMwk8lJIhuwl/L4nBQb+XrT5OltAXdA99UW3yC1MJIKXfrP6v + JQD96t/XXD+pahstTlpzDyAC9q50kidejOyX9iB72WGK6atFgm4sYcxyTtqRq0/IoXh/9FI2UjbWQ2S0 + 0vjZsNnAR760V2DUvL3IIIxS/tauJ2QQVIIQICLIWHBQIHMBPSd5BJlEAqPIExhJ5JO55hgi5izHUDdu + Ugr5jQjAvAvQCOI7IgJgiIIgUSgUrtQGmEjBiABMnYIy0ehMq/xDzy9C2fEjON1yGlt37kRMch79LsYE + YEQGvzkB2Dj3bBAAo41zAnyu/162CAf9Dop8Bk288HLe6rtVbeU9k209q/uJXEGypvNmDqnqw+jL7e+L + APgElWW/EdrJzbp5wzwSEDLrRWSTweUsrSICqCKjrxQkkEur8WgigWwigCxa/bPI+DMXH0LGIjLahbTy + Wxg/I33ebsIu5bhHg7ydj7uJDPYI8N/p/PgF5CUIMjmIUeQJjFxShhH02iMJvvl3w84lVBAA5wAs8wAO + YrpwuPmocQsC0IuCOnpFaeiTANTHqFWCggzCFTJQioRUgjEgAXW70Z7CkIKLZmNP2UGcaj6B43U1mDbr + WpkHsJhE1BcJWFZ5qiTgESS1Hj2CEqzkw43OI6/gBHE0nXuq0Sf12YuitBTfytvbv4fpRIP+2eW9ssgn + 9Yr+tvrOiABCfx0B9LVNZTqxTQQg6v9Dx2HEE5uRueIIEUAlEUClSMblkPExsglZy6wJYJQggH0DJgCJ + XRbYjeF0/Qh+HHkDIyksGEkkMII8gVTyBNJe3A/HxOkY5hokcwBu4WdEAI4GCUJLWOoCWvZHCCIRnkOE + zhtQPYEoq/BAP1eBicCRQozQ+JH4bMvXONVyEo0dDZi3dJWcNKRNIoq3Iuy+PYJ4KwLQC4j0TwAJuvMy + caAEwPfnLcIrHnr8hf/6Z5cND/pnN/b4hadOpi/jhC+5/LYqrAwTMMp2oFeIgeqPboqPeQigl/WKN8zy + 2yIAfT+7mv1XCWCYexTcM69D9tIKZBABjF4ujT93WQUZv0Q2G/8yjs1LyD3XewD7FQJQXXy5qqvGPeKl + XRhOq70AGXrai7sIO+myHnQd30aPS6OQIJVIII0IIG1hMVIWlyL2gS8xNCgDw1wCKVRRPAB3JRnIhq70 + MIjEoBkJREhpcB3sDSC+Cx0JOFqESBqJCAFRWTshCqi85HW2NQbVpiI5YYmlwBasXIXTbafR0FGHX/bv + Rnxarm4XIM7m72eLCFQSkGrP8eYNQ30lAQUJJKpJPn3Cr9+OVLVYiCsG/9kNRP80D0AafxrX9lfyl+VH + BOA7YAJIMpX59iH9xcavL+owa+u1WeHXv/GLE9+TV8gwIWU9xCMOobNeQvbqE8hSCICRTe5/FmMFrf7L + S5G5nAx/WTEylpLxLyHjX3zARAAKCQgimM8u/S4FOwi/EDnswEgy9pEv7sCoudsJ25DxwnZkPE94TmLk + s1sx/KktSH1yM4Y/+R1GEIY/vRnhM57BELcoCgGCRbmvJIFgUbVo7x4GO8X4Hd3k0coTELeFGd5m8hYi + zCYJWeURVC/CSxKnaBzSrutHaFSREud6hKtvvgMnKASoJxKobTmFG+64R9xH/H5+A6swtPYG4rV+D31H + qH4r0FY+oL9y9H5Qqe8d+I8gALWfn4w/Wt/YY+wBpJhtAeoJQPMA9D9GsLkH4GFW2JFg1flnK8bXd6yZ + 3H7VpeUTPkwMzXTwCBUDM4f4pyP5oa+QvbYe2StrkLOSSGDlYUI1Rq8iMlhVgdwVpcgjAshddhB5Sw5g + zMJ9GPPSTuTN/Rm5z2xB9uNfIeOhjzHq7tcx/La1SL5xGRKvXYjEy59F4sxHEHPhvQifeDtCCm5C6Jir + EZR9GfxGzoDf8OnwTbuIMA3eyZPhmTAOnvFj4R2bB6+4PHjQ0TEgUegTDmMCcJUEwBWLfLRTE4JKH4Mg + BAvob+PPLhFuI2SIMg4R1BBCEECENnXIUfMO1BkDUQb5BaWWwDMGw7PzcaDyABraT6O5sxZvb/yQfvcE + rYvQRTma1Rn04w0Y1n2wZxCUaJVA/o0JQDQQ+UfILsJ/hp7AP5QAVCWfwKh0D/rgX+paKQ2+sBRtMq9R + Nt+w5DfYPAeg1/MXkt6B8TaNX08ATrouNvMpP7T6eyqGr8CBVlGvERcjZ+5WjHyGVuCHNmHEXW9jxG2v + YPhNa5B27WIkXvEi4mc+ibiLH0XMtPsRNeF2hOddj5BRs+CXMhVesePgGpYFx6A0OND7sKPXG0pGNpTi + 9aHOgRjm5EfwxVBHHwyx98YQBy+CJwbbe2CwnTsusHPD+YQLHNwx2NETQwhDHb1g5+QDe2d6rIu/cP+H + EQnYMcj4h5EnYOcaimFuoVYG3zdCNdLQCEIjgUilXDjyjODUR45BlVjjSkTWJfQlt/uVt15BcwcTwEns + OsS7AZni8UbaAn0RgeGYcR0BuCt5gL8zAYhW4mBFT+AfrSw06B+53ccfMCIhi2fzrVON3LaQh4kAPAdK + AAa7AJqct5Lk6cvlN7n6AyQA3lIjw3Kl13OLGg17/2QMYzkwMqphzkFkiAFkqL5kqD5kqCq8yWC9cR7h + fL7enm7n+7Bxk8EOdfYl4/QjQ/UnBMDOOYCeiy47kRE7MogInBTQY4Y6etPjvXCBowInIghHBt0miMOP + LvuJ9zKY349TIF1P702FczAhBENcjBCsYSj9LeAcKsGXBYEwCaj5ApUAojRPwPEMCcAK7Al4ynJk9gBc + 6bdIy8zEDbfdiJv/dgtmXXk1nSfxcmiprq7AuQ+JsjMigH62BW0RwJmWDvuGpa5TlYX+kduDg/6BGX+h + 4Ser/JK7jfb6jTwAb/1kXnVgR3A/DT8hyYbNPiYt/77jfCNobqwo+w2Fk4fcUrN3pRWVV1kyXjsySj4K + sAE6sIGSoTqwsZLxOQaaYTAf7elo709G7EcruB8d/Yk0mDjkkf8ebE+3CfjSdXQfIoLBZMg8dUi49q68 + IkfIRh2uyOOWXK5vYOXbEPoOQ9PgG5GOwOhRCI7NQGhCJiKSsxGdlouYUQWIzShCHCF2ZCGi0wsQNXwc + ItLGInz4GISl5SEsNQ+hKXkITspBYHw2fGNGwSt8ONzpt3Ch79XBNxb2ZHQ8TtzOPUa2C7tFE5FF0HfD + bcZqS3Ekga5T4UYE4EbfLd3fQdeNqBq8/JvVlSOFTqA4uoVLcqXvQZArkyLnNJgABqhLODAvwDRu/Cz0 + As+mf4CVhR5hG2Fb+UftDPwjQ4BBioBno/bBg82r/QZOACkDUv41N37F9fdXpbzOnADkShUu+v154KdK + APZipfZX3HRake09ySX3wPnDPGm19xKrPK/AvGqK4htOWvnHEusnIyxulMhkp4+egDETpmPSzCsx8+pb + cdUt9+KWex7FPY89jUeem4un5i/E3KXLsGD1Gqx89XWsf+tdvPHhRrz36Rf46Mtv8Ml3m/H5lh/w1dbt + +PanX7B5x05s2b0b2/buw8/795OrfAj7Skuwv6wEBypKUFxdhtKjlSirOYLyk8dQQSg/cRSl9HfpcRXV + KKH7HDpcIZSF9leUYS89fmfxAWzftxubf9mOz3/4Du9/sQmvfvAuVmx4HfNXraX3uhj3P/U8brvvYVx3 + 812Yc+2tmD7nekydeTUmXDQH4ybNwOhxU5GeXYikEWMQnpgJv4g0uPvHiTJrLlRiXQJBco50dAgS4MtD + nNgLCRZdjcOEfoGuqEnZURjwRKI+E4P6HQLbRUNnSwI2HtfINqKoDf97EIA6tEOR7q4wNPSQFIP9fDb8 + VGHsXsoEF6HjznF+cHK/ct8eVo0+kgBc/MnY/aKNR1dbynt7m6bgiJNLFf5w4/g5SMbRorkmRMyt8w1N + ArlxGD56EsZOuQwzrroZ1//tftz35PN4YfEKrHh5A1555328/fGn2PTtd/hx589klIdQfrQKx06dQG1j + LRrb6tDa0Yj2rmYxFquzt1mM8OrS5vk16wRGW8XgDFYc4ik/6qSfHuVyl4IeWAiFKujubbKC+vyabBkL + jvY0iZkGjO6eRkKT9ny9Os1B+ZyK2nAPvXZ3Ezo7G9DRUY/WNorZef++6TjqGo7i1OlqHD9RgarDxfQd + 7MbWnT9i09eb8Pq7b2LpmlV4+qUXcfejj+Ka2/+GaXOuQnbhNMSNyIVfZDKc/SMw1D2IQh72nALoGCBC + FjveqeBhpl6KwKgmPnJm3oDlDoEKKRSbpOhI9l8x2Bc59HF7hS/Zyj9q+Migf0SDT3DMSB7a8c0ZMSQR + ALuvHsFydps6yEHuv/av9W8k88VNIs608jpRCOBssPJbjfcmox/myfv8FO9T7O8dmoj4kWNQeNEsXHXr + nXjomblYuHo9Xnv/I3zx/Q/4hVba0qPVqKk/hcbWZrR3d4jxVt2sbCvEQFWjVdGiGW43a/QLA2tAd3c9 + GZCKOjN003XdvQp6VLB2YKOCBnP0SG3BAaPXYpAI/d2tgoyfn097zm6JHkIvo4veSyehywa66+i+tZro + aW8PayY2akKnPK1Yko+U/+ohdNLf7UQk9S11OHLyKA6UHcK327fgjY/exYtLFuGeRx7B1bfehgtnX4Gc + iVMQlZ4Fr9AErVhLzeOcDQFIEtCfQwlK70iilbjomZJAX7d7hSZ/4x8jh4/8vRuHBv294/7EdDGua9GZ + JkYEASjuvpjlpk1y0Yk3BCaaoEvYGBX6yH1iafyCACxFKpVpN2KgJ2e3yfB9o1KQOX4qbrzrfix7eT2+ + 2f4jyo5Voq71FNrYEITx6lZLM7Vflt1uk3MAei2kv9nIWPQT/BwS0sjYsMk4emvpWCsua8be22AyRIEG + 3W362y2vN0dPH7epz2M9S9AE/fP3qOhhNIgjG7k5VAJgsqDn6OHPbvIohFehvO8uhhheapIu7+1t0Xkk + KsxFVjvp+Vo661DbfBzFhw/gyy1fYi6Rw6VXX4vEkTkUy8eI7Vv+bZ01GXK9snC0DQKQRq/PC8i/jdWF + zoQE+qpfkYVuKYsSR4770987H/D3DgEGcckjofVMCEB+KabJraqAp4fFSCd9Y4fa6qn2+Nva6jMjAG+p + be/oIaW82d0PjhuBokvm4NnFy/A9xbgn6mroxGzWjFysUmzAulXTeihH4wAHdjScIQYy8MP2442HizT9 + JtA+Zz8eRs9ZTC8yh2nOgZi1qM1blDApLDejrfM0yqsO4J2N7+HWBx/EqMIpFEKkiSYkB5ZD85SaBi5W + E4dN5cWqB2A0hdiWvqDqkVoauWoDVo1FSmGbQc/AFX/vfMCgv097b6ca9/OU3vIz3RrRE4CnGM5pQQBK + HGZGAKzYExCniUEY7vMrBMATbu25EIXcQ9/wVIzIm0Cx5p1Y8foG/HRwN+pb6xUV2jZxInXrZuxpJ3qv + wclvRQAN/wQCaPynEMDfDX0SQItAT2+zzc8uCaFV5FCO1x3Gtz//gHmrluHS625EfHqu2BWy89B5B4IM + TAQgL5tUh8zlxoznDNgiAKPVvw8CEANJ2YZk+3DnvwYBcHeTiPvjM4ZRLLPRSyT4UokAUvs0el9FcdXb + KrZPolVdwryHX1nldUZvu7NP7eKLhBtdjhuei0uvvU3E79/99COOnT6M9p5GxdVsUabs6Md461ZybapO + s4HRne2J3mhgpI1WY8TP1PBtjxQzPbf6OPNJRL8fArCcotRrNemob9Lr0X1+oF7OXSC0dtaitJq8g0/f + wx2PPYScydMQFDtSJA95riMXHbEYibOFhmFfbca2Bo6YEYCa0xIFbilKUtsiR6Dujsnk+Maw+MxhslKw + +1/DA7jt3kf/2yss5T5itR5JAGlnTQAeQrrLiADi+5XvUpN6PMwjdvhoXH7jzVj/5us4VHFIDO0wjelq + 0mJzk+Ebw2glGvgk3jMhgKYzJICGsyCAJkPi+bciADMSUKct1YsJTOpUJc7BnGo8hu17tmPRy6sxk7yD + 6JTRcCPjd/aQ+aG+BpCo7cX9bxUqxW1B0vj7JQC53d3jG5Z63533PPbfv3sPQN3y8w1LyyTDr/HStvj6 + L430UfTW9Su/ABt+oJp57YsAZIKGNeJYpMKTfpCUzHG45rY7yehfw4GyfWgh1oc4qfhk4GRbnTw5lFXB + zNBhYPz62Xqw9AAs0Z/BN/ZDAA1aYq23R04KMn49SwKop5BFJufE41T0WqJBgenvXt3swbMns78XCchk + YI9NArBEH2RoRtjqINYG5dyoR1PHSewq3oXF61Zj2uyrERybJncVPCI1MjD2ABL6ERZJ1iW2FYjrZNLb + BgGw7dT4h6dl/j22Bn8zAujulq5/SMwoBzL4L0wFPilnXBwhv7gkJdZPMhvYaR4CEPOy4XOMRj+MO7v3 + qdm46oZb8cY7b6GsugRtXXXKTD0lw87GYbA66lddw+TWGa3kjQN01W0TgNwq06Ne25Yz9jjkdepOgvis + PbZhdR9t5R+ox/HPIAC5dXq2yVCjaczWv0WD+F7kOdOI2tYT2LLzBzwzfx4Kp89CYEwqkUCE1oFomRRU + 9Qb10JOAuvKrCW5PxRsQFZu2CYDxRWhshgPbGNva79IDeOGlZf9Fb/R+dlu0Sr4BEoCXRe2+vm/fcmqv + SgCcnGGjj4wbiWkzZmPpquU4ULwbHZ0NIpYXBTGiwKXBtG1lwz02i/P/IQTQeGYEIN57o8ykmxGA+Yp3 + 9gTQoJs+/M8ngG6t8MmcACRshQK2iLbRIuzpy2NrVL5H5fvUkUNty3Fs27UNLyxcgoJpl4kdBe4/4A5E + 84IhY+kxmfRTDD7IIhdABOBlWQUbYkYAHArc/8L85f/1u/MAOk0tvqn0ho/qx3JpMt79q6Qoxs/ll3FC + nMG8lDdB0+9j5vUNScLo/Ml44vkXsO2XH9DYfNK0Vadmhw1OCqN4eCArn54I9Cen0W19v87AcgCqgRrB + 9FwNploBrZCn3vbjNALgGoPTApaEYPw6v61RS5gbnlmc32sCem1NPdaPWW8aEMynJNuGsRei1iN0CJxu + PIUvtmzB3Y89gfS8QjLmBNG1yLsGlvkodRETNSyK4auegIeOAPQ2ox9pp2uUO+ofMTyVba3zN2odHvRb + qPuILr/EbO7ye1fT8D9LApDKLHGKOouJUcXeLMVe4fEjcPl1N+LtDz7E4ePVdCLpRm73mMPSjTSfxKui + 1WJir6noRK425kUovaL0ts1g4q/R9F/9BOCWPqC+ryZlOrAyJtwWNJJiA6ozxfQ9+iIgA4NW8wLCuGtF + wRHnQjgpJuPgem0Eea9IkDUbjho3jTc3rcrm35Ear7co1Y4SXQJN6OTEGxEmlwt3dDWhvYPQ3oS2tka0 + tjVItNajhUGXW8R1jXR7A92vUd6X0ELXNRGaWxvQzPdrbxDJ3c7uZnr+VqX6sl0zWnO069Cme/8tNkhC + PR/aBORjOkWlIk9bfvOjj3D5DbcjPC5T6UmIFOcrJxI5RBX6AhQOnBEBhFoPvSW8G5k4WnQN/hYqQoN+ + K3UfZX5fh5f6AZRSXj568Q5AP7sAJr1+lQBkcsVNSHFHID4tA/c/9ih+/GUrWjr45JQTY3v4h9ZBP/de + TuZtQXtnIxoaa3GMfqiS8oPYvfcX/LBtM7785nNs3PQR3nz7Tax7ZT1WrF6JRUuXYO78l/DMCy/giWee + w+NPE+j45PPP49mXXsJLS5ZiycrVWLF2Hda8/ArWvroB619/AxveeQdvvPce3vnwA7z/8Uf45PNN+Pyb + L/H199/iux+/xw/bf8C2n3/Ezzu20evvwP6De3CweC+KS/ejrOIQqg6X4fDRChwlHDtegZoTFThxsgKn + aqtQ23BE1M/XNx4VtfQNzTVoaDlBqEEjuaVNrTWEk2QEJ+m7OY32rjqJbkJnrUBr+ykylJNoaKqh56kR + I8Yb+XL9cZw6fQRHj5ej8nAJKqqLUVJ2AIdK9uEg4QC9x30Hd2Hnnp+x/Zdt+P7H7+h7+wKffPYJ3vvo + fbxB3936V1/G8jWrsGDZEjy/YAGemvsiHn32OTz4+FN48NEn8ADhwUfo+MiTuO/hx3H3A4/i9rsfwE23 + 3Y2rb7wNl19zEy678gbMuvx6zJxzPWZcdh0unnUN4WpceClBHOlvun7GHOU+c67FhZddg6l0+5RZV9Hx + KlxM11165Y248oY7cN1t9+LWex7G3Q8/g4efeglPz1uKl5avw7JXXserb7+H9z7ehE1ff4vN237Czr37 + cKj0EKqPVNH3Td9lS70gpl6zBaJDGVDaI9HbTcTJ52CnOBdBFNfa2Ypf9uzFY8/Ow4jsfLh4h4n+ER50 + yl6ru0ICXMviIepbJNQGNy8FniGqB6DfQk9VG+c6fELSrvitVIQG/RbqPgGRI/zIiPd66Vd+YfypSmyT + NmAC4L59FcycgeGJuPO++7H34D76mtvFj9Brxt6dynUdYuWoPlKKLWTcr775Bp6fNx933H0vLrviOhRO + nIFR2YWIT8lGePRwBIQmwCcwFp5+0XBleSr3MKHuw/P9uLlHqubwrD858YdFMOyFDkA43ZcYXgzWDIcz + i2pyHzr/yMz4frLdmFuPPenH5m1Nn+AUEbL4hyQiICwZQZGpCI0ZgYiEEYhKSkdsagYSRoxGysgcjBiZ + h/SMMcjIGovM0fnIGVuIseMno6BoKoomTsOkKRdj0rTpmHgh42LCReI4ZfpMXDjzUky/bDYZwVW4/Nrr + cMW112P21ddg5hVX4qJZszH54pmYMHUGCidNR/6EiwgXY8z4acjMnSBGhMcPH03vJQtRiemIjB8uEBGb + hrDoFARHJCIwNB7+QRR+BUTDxy8Knj6R8KDvzt0rHK6eoQIuHmFwER2TEfI7Ijir4Cy6Bx/l9+bsxkd+ + jIpwAhkM3c+Vjvy3sydPWw6V96Pfh+EqXiNMdmaKMeR0X+9w8Tu6icdGiudxYZEQTzp6Sbj6RNGKHAMP + /xh40ULjQ79JIMXx3JEZkzwaaSML6PueiskXzsEVV92Cv939MJ55bj6WrFghkspff/ctkeF+1Jw8Th5I + qzK1GAopqGTQQ8ceVB2pFuPes8dOoNcOExqI3AEqQoFAk/HrSUBLDFoRQJqpa1Zib0DESL/fQkXoV7PI + xZffeA6598/qFXnNCUB+CFsEoE5Y0ecAGG70I8XRqr/hnQ3ErE3CwLuF+9Upvvie3k5aweqxr/gg3tm4 + kVboubQqXIHhWbkIjqLnose7smF6yOk3zp7KhBvPKDlZVtGdF/CS8tOOylQbR00CjC9LqFNuuHTYmUdl + eUp5cCllFQMHBfbesRocvGLl9XRfe51ABsthqQKcLC0mdPrFwI4wMWJcHTOuyXAxAXHbK5GRICTXMNED + P1SAxTpU0Q5F3EMgWLTNDmXNAKcgDHPmNloTRCuts/q8CpShIfaqDJiYdizBasJObLQeEsLAhJFFmIyM + FX69WZknSsBZPXqpl6Vaj6t3jIBak+/GhikQLQyUE7tuwn2OEnD1JcMmsnFXIa6PVhCju6w83scENyET + JucMCnec4K6Ck8gco3OY6UfepphqzO8vWgiPuNBv5kq/lztd9qb7BXC3J5FiRk4+Zs25Ck+Qd/gWeX37 + Dx4gr6FJGL4khV6FCHopTD2GZ+cuQEh0quhM9PCPlztbZgTAuwPJsuclKNlM9FZuoafK7lh1W53Iwick + 5dlL5txwzj/NA1Ar/nwi0tLojdbYIgAvXSbTyvj18Y5evYfc/8ikUXh/04eyrbW3TRIAHSsOV+KtDzfi + 9vsfQf6kixGRlCUIw0W0+EaL1VdTfOVabl+ZO1AbPvRTZ5z1JCA06GOEEIUDdwKKVmCD4ReKVLWDlywn + tveSKjj2HlHSyLmSjCDIRJ2ao0zVtffi544WXYaqkKajUOSN0FR4pbhm/7DXyXibS3ZFWGGYW7hyOUxI + gOllwIZ5yMYnO1tin9oQUbmCW84SdBLtt+rgjygzONmYBOQqEK0jhGi5OqtQDV9/3QDhyrG3T5QC+dwu + gnBihSvOhOBO54QKDyIBD39Tvkm46n7K9QRP3WUPvo1JhgzZlTwOd99I4UXGk9d00awr8MJLi/DdD1tx + uqFehAS9Cgl0U7jwxnvvI5S8KUE6AUlmxu+ukyD3UJqBLBWDLBODhBq/8LS0X1sh+Gs8gEGxI/L/4hma + skF7U6G2CCClbwIwq4+W+urPzFuMrh5ZCceJnS3bf8Qd9z2IxPQccrOjRXcXJ1uceXIMz6T3T4QLg1ws + l4A4AVf/BJ1WvEzIuCqrgRg8qaz+EjECggT0BOCtO5nFCRwt7+epGLLQ1I8SRSJCBkt4DTG6aboxQtVG + 9QLsVVVh9zDNuBj2AmHazL4zgfpYCXpuN2NIz0Fd7aWHYaeoAqvGbglHd/0o8Qjp2nvqFH1ZiEMIpJju + Y0vjT72eV1YXvXyXchRG6y1xxobvw88RqUwbitSmDpmgkI1GAPHKUXoFZiW+BA8zw1eJIlaEDx7ClZfw + YI0A3uqjy15EBmExaRSSXYIFS5aipLycPNVeQQYd3Z244fZ75OsHJlsQgBwz5mlIANJ2vKwJgGcQbkgg + G/w1DUODfk3Fn3fY8EIy8iZP5Q16haaYxf4yu8mui5SlUmMZU4yjhgFJ5hNZ6XlWrH+TCKAVJ08fw90P + PEQxc7Ii9sD68GTk3KjhJ41fQn+dhGlYRJy18q+y4kv3XxqsHHcVJbTqnbUBFuYrnn51Y3VbO3fuJCTD + 5iN7AV6SBOzo+YYqR5NOXrTQzVNXXwfN+MPOUJiT8xK0arvpV/pw02U3eg2WAVeh8wSkNBcjTLts5DWo + YEKR4YpJCFXqIYb3C+Gd6LwJR4vvUA+9oKcMISIHAOX+amu3IGvplbB0GE9CYil0kUcQ+YIoEwkoIUFf + suFufjJUUAnAXdvaixVNRAL+0oPwJA/CixYdLyYP8hK8aJEanT8J3/7wg5IjAJ6au5A8ALo9MMUi/pdJ + c32DkGeIZRLQXCfDSxJDE3kBhb+mQnDQ2W77hSVkD6Y38qncvkixyPzrCSBVIwA1iSGlvcxFPs3FPOIx + 46pbcbS+AT/uO4CoEeOEy+0ipsWSoWsEkPDrCcBbmXCrkAC3BjsqJMNTZzim5WSTRgLKCiiUgkLS4RCW + A8ewMRLhY+AQnge7sNEYGjgKQ3zTMMQjFkPIUIcqbri94orb6eJ8Xo1V11yPoVqcr8AtxHS7zoCHuRkR + AME1UmjvCcOn1xjqKjHEhUDx/xDnMAwmDKHnsMRQAXl/mQTlGQIhwvh5noA6XswWhpHxDXYOxmBWIFaS + qOoUIiMCMIeegCX6JgBF3EX8VqHwC0tAXtE0zLzyWtz54MOYt3w5xk+bLrwVjQT0xGFDMdhFJHVNOQOx + nWe5x+8vQwP2Cjjv5Okn4cbvxS8MLy5bJnICzW0tYoeCw1KPwFTjJKDV7EFa5TmBHmKTABifRiRmDz7b + bcFBZ7/tl3YJGXM7y3aJNyVclBQz45fgv9PkToDWCGFS+TWqneZMqXfEcCx45R2UNndi8cbtiJ1wExwC + RpHrSIbpkwhnzfCNCCDBgBDiJHzMY349hMtOz5U+5xkUPfA+cq9dDNegEbrVj1xd91CRwfZMmYpRD7yL + kY99hlGPfomMxwlPEJ78AqOe2IS0hz9A0r1vIu76ZQi56BF4pM/G0IAsDHaJFsahGblAiJWx6xV5VQzm + I913iHiMQgAuEmywQ1wiCFG4wC0Gg72SMCxgpCAop9jxcEmeCvcRs+CRcTm8Rl8NnzHXwzf/ZviNvxMB + E+5G4MR7xNG36E54j78NnmPoZM2YDeeECbALSKfnj5ISaAoRyBFj0tjlbgmHFSESRDABSQVIn/0ggvOu + hEvceAz1SxZEyGTn6KHuCIQLMnXWzR500mkvyiy/ORGwketnNsh5AIoUOCds6TljkjLwzQ8/oq2nXdk5 + 6sKb774pVmWxy2A4kLQf0VDVI1COplCBriPDl4iTDUS0gPhGj8LNjz2Fo7WnRSZg7YbXERidJnaGPHQh + gIea+AsySd95KdeJrUF1AQ1O0UqEvbQye+EdtPuGDb/kbLcFB53N6h8Sk2lPb+Bb7yD5RvojAI/g4ZIE + 1CKIoCQryWW9+CITAM9555X/5U83Y09zD9bsq8XEp96BT+ZVcPAbRQZL9/HmGN+SAPRegblH4CKyvHG2 + CYBOPK/E8Zg2/2dMX3MUo65bjWGeCWKVdlBWPyc+0uofd8VcZC0pRcbiMmQTcpYSeALwynLkrSojlCJ3 + dblA3upS5C3ZS0SxCWGXPg+nxOkYTM87hA3dwPhtEcAFTAJ02wVEIIzzaHU+3ysOw0Iy4EqE5Jd/AyJn + PIqE6xYh7W+vIv3RDzHyGSKluVswat5PyJy/CxkLd2Pk4j1IX7ofo5YeFFOKeFpR1vJDyF5xCFkrDiBz + 5T467kX20p3Inv8j0onoomc8AZf4KRjqQWGMS5C2RSoMX8wY4PcdJDDMORDe8fm4esMuzHrnMApX7MKo + Rz5AxKzH4J1xGRwjx2CYb5LwhsQ2oeIVmCUWFQKwJoJIg8lBuvCBwzgi6OmXXYXTTfVk+rx71I4jxw8j + K2ccnOj9uXqadiZsy4XF6BSDFG9A9QR8zUME0XlK3qITndu+KRMx9rrH8dLGH1Hc1IGWrm5seOt9RBEp + uQXGK/0tOgIIlGpXqm2YIdhkTxbbgBp8ZGj9bWhclv3ZeAGDzm71T51NbNQpCxeULYpQk3tiTQBpCgFI + dlPluzysNPx0YAFPiqUiU8finvnr8PL+43ipvAdzPj+KlEeICArvgn3UBAzxSoadZ5xw44WB+yWRd5Ak + jkwGzkIHMM6QAPQk4Ky4/9ETb8X0lWW4aHE5grKvx1AXPsnDxYrHNQJO7gFwjcxA5hPfYNSyaiKASuQs + qUDe0kqMWV6N/BWHkb+yCmNXViJvZQVGM1ZVIndVFcbQccyqcmS9tBPxt6yDT+7VGErGewGtjIOdybDZ + ZXYOknAKwgWE85wCca5jIP5KOJfv4xmPYaHZtJpPR9iF9yHltlXIeuoT5C3aTq+7B/mrDxBKMGZ1MXLW + kFGvYsM+gAwy7lErSgTSVzJKMZI+56gV5QIZRFyZRFpZ9FhG9ipGMbLpci5dzl95CKNf/AHRc56HY0SO + IC97IYoaKrcUXVQCkNOHLiCvJP3q53DZe8cx6fWjGL+Bvht6PwVLdyHn2W+QcvvLiJhyH1yjx9Hvpxi/ + RgLWBKAnAWsCUCYLe8vkIicZ3bzDsG7DW2T8Peju7aD/78QL814i7y1EIxz9QFIrAvBWdoxUL0DJG7gr + iWRHOjpQ7O8ckQ3fzFmIn/Uo8h9/C1e8vQ9P/NSE1Qe6sG5zGW554HkEkTfLgiJuoi8gSSYBFQiRG23V + V7sETR6AFkL3SQCpnb5habPPxgsYdKbGHxqbYU+xyGZR7mux1WdEAJ4Kk6ny3rY01i3r/jmzyu6WkOzy + jkN49sUY//A6XPrRIczaXI/Jnzdg9LpDiLv/PfhMfgD2iVMxJDALw7xT4UAhgiOtMC4+ydIj6IMA9HD0 + TUTGzUsxY91RFD2+DU6Bo5VZeuo4bYJrIALGXI2MBWQ8i48hc1E1spfQKr+0FPnLKzFuRRXGkfEzAYxR + DD9n5WFCNUavqBbjwzPZ4JaXiNV4BHkFsVcvQFDRHfAaNQuuCRPhFJUP5/A8uESPhVvyRHhnzUbwxLsQ + d+U8jLznDYx+/iuMpdV5HBl3ARl6PhnqGLo8hox0zKqDdDwoLufR9bmE0XQ5eyWt8mT8mSvIa+E5hcvo + yCCvJXN5uXhPggDIe8kmkhq9ksEeTSm991IiMTquob/p9TIf3Ugr+WzySsJhp8pzuyg1Ca5SqptrEbzi + C3HZ+oOY/OpRjH2Zvoc15fSey1FEXtEEwsRl+zHmiS8QffEDcAnNIA8sShinLQKQsDVN2HyrkYe2jB47 + GUdP1CiVel04VFKMxLTRIqnZPwFIjUhH3yg6n8Llti+dT8NCsuCYPAXeBTch+pqXkPn0p5i4bj8uevco + Ltt4CnPeO4xLlv6IvOvmIYh+O7Ew8Takn6InGGCubaHvFjQtmslKmJxslT8zJgCRC9gcGpdhf6YkcMYE + 4BueNpNerHMgBKB2PPkw+iEAI0/ALUDZxvORwgyO3vFwTxiP6JkPYPRTG1H0SgmmfHgaEzaeRs6GUiQ/ + 9wXCb1mJoOmPwnvMdXAnt9glKg+OHMdTSOCkbv3ZgCutbOOe/gKXrD+BtGvWkrsdZZbYYgJw8QrH1AeX + 4aq3D+Om947g7k8q8cRXFViwpQrLth3Fkm3H8Pzmw7hrUyWufLscU14uJzIoR7YYFlolhoWy0aUvKUb6 + 4oPIJBc8d9kh5C+hlXvRbuRS+JH30k8YSy57/oJfMG7ZLlp992Ps2jKMXUeksrYCuWvLyZhKRZiRTwad + v5JRLFbpsUQA+UQAY2nFlziI8SsPYOKaA7jw5QO45LVDtEqV4Jp3D+G6d0tw7dtluOqNEkx/9QAmrKPH + 0WqfQ4afTRAzDclgc4kUGDmr6TryCPKIbHJf2IrA/NvJ0CPEzEGGGr6oCUr+/sY/+BqmbDiG3DVEfvR8 + Y4lsCokci8gzmkCvUUSfoWj5LmTd+wr8yH129DARgKMyfPVsCIDrDLiIZ+WadcL4e3o60NXTjnsefFQk + MZ21LV1TOCAnP0WTRxIDe99kOISSsccXwY3CFv9p9yLqpmVIeeITZCz5GfnrSzDxtcP02Q5jIpHs2Ge/ + w4gbliF0zLVwJZJgj5ILo1xFIVOs0KkQBBA4EAIwJQH7JABlh0AhAPICUmf+3QhArP4Jo4d4h6Z+qe7p + axl/ZReAtwG9DBRPvEU207Lrry8CkH3//EW5BigruK8c/CjiNv7BAulLSZyMsAm3I/mWxRTrfkSr10/I + 3kAn8eulKHh5HwqWbUfOM59hxN0bEDPnGQSNvR4eUQVEBPHCvdMnfXj8tF/GDFxIxnbpumMIzbtTZMkd + XPXJrhAkDs/CvvIy1Hd2orGrHS10YrH4dxf91ynQjdbeLtTRbUeaW7CjphFvHzyFx7+hleFNMlwy1Ixl + lRi5pIo8CHK/F9NqvIQMawmPEafbyaBzaTXOJQPJJUPJIaMZreQSZD6hnNx7ibGE/FVyVS1YTZ+ZT0R6 + /iJy+WfRqnTPR8VYvLUaHxw8iR+O1OPgqSZUNbbheFsHTrS341RHB07Rsaa1DeX1Lfj5WAM2FZ/Cql+O + 4b4vKjDjDfIo1lAoQcafzx4N5zfo+fOIWPJW0HHedvjn3CimHNlR3G9JADzII3riDRQCsPFXIXspkRh9 + ViaAQuEJEAEQkU1YV4JJZFATXvgGUWOvkxOBuCTbM0RLwOp3Yky7BUpI4GW9TevKoZ1bJHLHTUJN7TER + AvTQL/X9th/IJU+U9/WM1nYdnOgc8MuejfCLHkP0FfMQf+s6JD34AdKe30y/0U5krjmI3HX0/un9jlu+ + F2PI4DPveg1Js55A4Kg58AjPlXknUdkYreUGzEeRJ2i6lprOJRt/UKJZfYx+F8C2mI7hWL0vIxKyh5wJ + CQw6k+SfT9jwiUQAbX0RgMpORpJHxgM8Eq3+1hOAG/3tGhBvIe7Jwz3UUt8oURvgFJQK1/gx5C5fQu7y + rYiZ/SSSbluD9IffQ+azX2H0vC0Y/cJ3SL9uGd13pIwZdVlkdvcyLr8XD35+FHe/vh9+ceOVoR/6ra0g + XHn9jejoblY6EGW3GVcp9ionmAr9dZyJbuhtwZ76Riz95Tguf5NW76UUApAxZFL4kLWUjJxIIYdWx9wV + ZWRk5SJ/kEdGk7uarl/DoL8J7AGMXSORv7oC4xh0edzaUkwmd/v2D0vwyq7j2HeiCfUdrKvfrrzHNqC3 + ndChoFPpo+jQ+ilUV7mbe/a6unCgrgXrdx/HVW9SqEFeC3syY1aWkFdBRLP8AF3eh9ynvoF75DgM4elH + XGbsotuepMtukZm4463teJgI5fFPy3HfB6W4iLyZwrXkBdCRMWE9g97/y5WYvmw3hs98lFzvONGToY1i + 64sAPI0JwJVnCZLH9sa779Dv0CN+h6a2elwy+woxHp3zBa5KUZIDnU/J172Agg30G6wlD2fFHoxe+DMy + nvsOKQ+8i/gblyFyxuMIzr8ZASOmwzsyl87RVK1kmcuXtXoB39g+CCDZigA8bRJAUp+zBg0IoM0vPG3i + mSQDB8oUg2KGj/kLGfi7wshDpFiB2PcPTdHVKafqCEApcBAEkGI+6ruvMEBRAfIIlBlSdyYBRQfAJPbJ + MZUs+3UTlX2ydlvWm5On4CXlnh39U+AUlgF3ikV9M2ciZNKtiJ58J8X2w8ngY8zgHBiPJ9a9hp9olVzy + 9hdiy5BXf0dazRwV99/eLQjPzZunNST1at1h0LoT9YQgCaBdaYVtRGdvA5q6m1Da2IS39tTg6ncotqaQ + IGvZYVr5K+mk48Qhr7ScRCSsqiYCqMLoNZIE8tj4RRjAl6vIC6hCAa3Ql75ZjGc2V+OrilrUtLPGnakt + 2dTCqr9s/j7VbrZerdHKdF0PoYyIYO7mKkwiwxizvJSMn8KNZYwDIjxJJePgROYQp1Bh9HZcXOQqj8Pc + o/Dyex/Rs7ahracRte0NmPtNJYUkVbTyVxP4WEmoIC+ggkKmSsx4hb6X21fCKXikmGTMW69OHtYEYMoV + ROigVBt6yR0BHoM+47Kr0dTerPSStOPNd96Bh6/0AETSUIQCkQjNvgiZ96xG4tXPIWbanQjNuQLeSZPh + Fp5F516KKCuXOwGcEIyWR2788o+W8FP+VvoM3Pz0U6mkZ+upEIA+CW65QHppNTLJfQrq6ofp6tuF44eP + HXB14KD+pb56lJr/1FG0ytd5hZhWeVN9copVfKLFMSLDaZr/1z8BJJtBkIAggARzEvA39wi0bC1nW5Va + f5Hw85FJGCcuz+VEID2fE+sG0vUaKP6PTMnBz4cOiE2j+ateEXGioxkB8IkWgldef03r/tq7fy9Wrl2H + L77+FpWHq9De1aZrBOkS7aLd4hnV0V2sONwqhl1wT3xZUzOWbjuOmRvIsMnVz1ldTS7+YTJswpoj4pi7 + 5jARQDVyyOAFiAhyiQgmvlaFW784gpcPnMD+hiY09kiiUeWtZE9+u1j1TQZvDrn6d2vvuYs8g6bWBnKZ + T6L6+BFUH63CqbrT6KQwp6m7E+/uP4UZ6w6S93II48idz192SHgBBYt3wD/7agx2DBMEwLsm9krj0gUO + wbjv0WfFdCQ59KMB247Wic88Yd0RHQnw3+WYSCQw+dUKXPJ6Jcbe9zoR80g4uASblRibCMAoSWh5n0j4 + hyZhy7Ztsn2cSODo8WqMyi4QJdrOCgG4eUWLJiOxc8Sl4iwxx9fx0SfG1ECkgY092gAmT0AdIuLmn6jE + +7pz20Iz0HjWZbKpG7CPycIWBFDnH542SkqH9fw2HsCMy244h1b+xWqHkrri6wnAElLsUPkQZ+QBmBu/ + OQEYqf/GaZV+QrtdIE4oszBY1lkiTvQNOPty/C913iVpxApyyCuajpMN9cJ0H352gSghdVSKXURpK3e+ + eYfhvQ8/0Ajgy2++gptnIJFEECJjh4u245ffeAdlh4+QMXUrRNAhTjpJAqaRYKpCTgutirtO1VLcXYO7 + PzuCy9+vwsVvVmDqa7Qavsoox7TXynDJW2W49oNK3PvlUSzZcxqbTzbhWFcrPbuiaqzMEOw2k9BqU076 + DuGJ9Gp97V1ilW9urceh0hJs3LQJz8xfiNk33obcCRcjIX0MIpOyEBGfgbTMsfjyu28ESXBZzcbiGly8 + bg/GLSlGAREBhwL5Kw5i1N1vwd5vOIY6h4leA1EnQN8fjyCfeOEV5Ho3KbMK61BDl2/fWEHuPxHA2sOE + KjMSmPRyOaa8UolLXyfP6G+vwME/jeL5cLFL4ORpqha0TA7qvQB9D4CDSyjuuu8R8sBaJUnS8f6HHxET + nk0NSbqORFoQ3MmDdOcjlwwLxJjQl/H7K12GonQ4QVv5ZeyfZNriC0qykgy3miPQjwdggwB41PjiGbNv + POdXewBq7O8fMTyEXqTSquOvD/Qv/dU3AZiKJZI0AVBjAoi3AVPpr2rocgtQnQRj6h7kFuDLr78Frd3t + wlRuue8Jsa0lWnNFswudeB5RIqv7/saPhDGwu3yq7gSycwoweKg3zh/ihb8M9hDjqmOTRuP2ex7Ftz/+ + iNaOZmFsPQoBSLQowzsbhUF09daRe9yCEx1tKGluws7aRmw/2YhtJxqwnbCzrgEHmhtxtL2VVnpOObZK + WS2h6itltbrMpKuaFUWeVuH2dmuufidq60/gq+++xUNPPIOCSdMQFJFCnzUQfx3miz8P9aNjIM63C8J5 + diH469Bg2Lv44+vNXwsy6xaOfCve2XsUU1fuwfglh8gLOEhhARHBwp3wy7lalP+qBKBWCcYkZ6OiqoK+ + tjbxeZt6mvD8t4dRSB5O0eqjKCIPp4hJQIDCAwoJJpNnMO3lw+QpVGLENS/C3itRjhD3jLKqFjS5/hGa + F2CW5affMDElGyUVpYqaU7sQg/ELidUVEEnPUW/ssnvQ8nrZimxr5Xf3sx4cop8ZcCYDRC2NfAA5ABWV + AZEjQgaSCxg0QLWfO/T9+/8QAggyJwBta9CKCCTL6kc5yYku5sM/XXRtwHL1l2PCBQHQ5UeeeYE3i9BG + ru7sG/4m9rfVld9JEACfJJF47e23hdvcLfL97bj5lrtw3gWeGEwGdL4dwwfnERkwPOi5L7vyZnz34zZ0 + 9HYo+QA9ATRJt7hX6vl1KXP/rOWulfmB4jpF7NRCl7DbQrtOJQA2+o7uNuwvPoi58xchO2+iKIf96xAf + IiwvMnJfMnZ/nGcfQAjC+fY8jjuEXHcigGH+iE5MxeHjlZoXwa/d3N2CeV+Vkeu/G2M5D0ChwDhC0rXL + MYRifo7bpQcgex04X/PFls0iL9GFenqWZqzbcRyFq6oJNRjPx9VVRAREAAJEAkQEkwlTyRu4aM0BREy4 + A0PcokUDlqNm8JYEEGlMAGKyczBWrlsr8xv0W3CTWV7BRJkDMCAAlRiMCSDKgABiNQJwtxAG1YuC/oMI + gL2AOwayGzCo362/uAw7erEtRgSgjjSSmn/KG1V3CAyEDQdCAB66GmmTTmCCdaWgRggJZvkBs2GgFqO/ + tRJPfZ03uWwugfFY99Y7IhJuoVV4yuzrhAcgu9oihPEzeJ7cgqUrhQfQrawka9e9iiHDvHEBEcAFw/wE + ATARXGDvj/PJgM6jVdU/dDgee3Ypjpw4oYQEqoFK171bM+hGqelvKFvdaHNQhrV2XYscmtnThh+3b8f1 + N92NkMgUMnRvMnxv8b7OtfMj+OKvhHPt+TKTQCDOcyAPwIGIgAjgL+TZTJw2Da3t9dpOgqqRePBkPWav + JwJYcgBjlx4kIjiE7Me/hmNYrtgtkQQQLpqUuBFqybpXxOO6FSLbeOgUJqyqQuHKGiIB9gbIC1jFICJY + XUkkUEEkUE7eANdSVGHyvB/gmThZdF/a9gB08DKvDeDqxBmXXYW2Dv7O24W2xP2PPCKETExGHicWCn1/ + gZtPTB8dg2oyOlp2CCrnnlVRm43V35Yx20r02SaAJAuI27aExWfa9UcCg/pz/4lJxvGgQkMC0NoWdW/I + QhT0TAnA3YAAbBn/2RGARbMH3c8nKg3fbP9JGHYDueBjpswSbqxI/AkpKyaAWNi5RJBr/yCdPHJ7jwlg + 1+6d8A2IoRDAkgACCIG0mgbRMQhDHMOQWzgLH3/1Lbq7O3Xy1vphF439zgbsHYCqrTDQkv244+774Rcc + RyTkJYz/fDs/gfPY+ImwGHoCOFchAEECjkFEFl647+GHpOH3tup2ElrRTka0+LtK5C/ci7GLDyCPiCB3 + wT74ZF0v1IdEj4Cr7E4c7BqOux57WlNM5s/xXVUtJqyuQMEqJoAjKFhZjfGEwpVVujqBciKCMgoLyjF1 + fTkybl8LO58UReFJ3zdgIFRiUSDEnlx0YjpKyw9pux8ffPIxfIn8Oea3JABnRUykbwKINSAAI1lw42Tf + QFbz/uT0+yCAVr/wtHH9hQF9ssOki644h55shaWEl1z95Tafh16qSO0JCDVJfRmGAMrIL24K8ghK0iVF + 1ARJium6wKR+CCDeMD8wYAIg9z8+PQ/FFZUizj12+gRGkJvM21i8+jvyisME4BlLK1oUCiZfgsaWenES + cUKtsakW+UUX4i8XeOACNnwBP+EBqAQw2CFYZMPPtQsQW6IvLlqNTrFjoCrQNinTiUwS1mdHAC3kwdRj + 1fr1iEkaRS68N63qTEZ+SniiIwBl9dcIQIC8AIcAWv0D6f0GUQwfgI82fSCITm/8UgW4Hb8crcOFK/cg + d9FB5CzZj9FLSxA+/QUMc42U8b+bFBXh7cCrbr6bwqBmbbrSjuMNmErGnb/qGBn+YSIARhXGr6gkVBAJ + kPGvIuNfVSpQyHUOy/chOPc68dzO3JJtsP9vVeKr9QmQofqG4+0P3tU0JCuqKzB81Fi5HajKlPmY14cI + NSnOGfnEagNCLedOiu3oARKAWc+/TvzDlsH3O1GL3X0erScFQnTgMCBlxaSLrzznrDwAKfY53F+d7mtF + APopJ8GWXYF9D//gx8pCiCSTKqpBR5SaD+ibAGzPBhwIAXBb6bhJ01FXXy8IoLiqHDEjcoSCjqrk4+DJ + nYKxAhHxmSguK9GJQHZg/tIlFDt7amGANQGEaPjr0ABkjb8Ijc21JhlwDSbJcmNvoMnGii8n4J6sq8Ft + 99xLRhcgDJyNmcHv5TzF+DUCIIO3JIDzHCQBsPGfT59jdP44nKitVkKWVgu0oLatFbe/exCjF5YQAVAI + sLwUybe8DjvPRG0HRRCBSxhmXXEz2rvV/Ad5KKcbMWNtCcauPEaGfwTjVlTLPgoigILlFUQCZShaWSow + YWUJhQYlmLSmHGPueweOASPEiq7tCnhG9UkALoosGOcj7rj3fgoB5O5IR1czrr3hNqFyZKs9WFagytyR + qyEBxNocHd4XAXicYbFPXwTgFyLha+1BlAdGjvDvKwwY1E/y70oy+B4vmwSgFvtYdAXaJAAJQQDBqgeg + dEAZEQCXFPfpAcT/agJgoc/Lr7sV7Z0dIgT4cdcOBESniZXfQSOAWAGhRkQu4fsffyJKf2ThTCsqjpYj + O78I55KrLQnAXyMANiZe/Qc7hApw0m3ODbejs7tRmVirJ4BGbT5Ar00PQI8WhTSahLT3VdfdiMGOyopP + xnyuYtDncz7CgAD0UI3/PEfOAQSLnofX394gk47KROReTfNfHjvJkOZ/W448IoC8JWXIWlGO9Ie+JAPN + gKOrqYrSzjkUUy65Gq2dzRoBlDY04pL1B4gAjmKcQgD5y4kAlhMBLCsnEqBVn7GCQQTAIDKYvPQAQsfe + IlSYpMhrtK6k14gA1HieCTwGmXlFOHHymKYsvWrtWriyqKkiUmpMANID+OcSQIrhlC3pASiwJoAev9DU + K8+GAAYlpY/7s3do8nuWsbw5ASTpiCDVbMChUcLDNBRBXySUYgh1ZprlLsBAjF9PAEYkoI/juI78roce + FzVv/G/j19/Q6yaIhB/Ld0kdv1hBBNw2zIIWDzz6tLYVKLPybfhi89f0I1C8PUxd/f3J4ANELM24QBBA + CK2sPli4Yo0sJe6VK75+ArDtib4NZkRhGtzRgKaGY7jl1tsw1MFf5B4Gi1U8QPEAAoVxn2uvIwB7IwKQ + 7/U8wlCXENz70GMi+detjUNvsdhibBa7IG/uJgNeeBBjuaSZW4uf2QrXyHFEAMFm6kDjpl2GpvYGUQvA + 31lFYxMufeWQJIAVkgAKmACWVhBKUUDhxPhlZRi/vESgcEWxAIcFmXe9I0RKHJXfRN/UY9Tdp67ivAXs + E5KIbzZvVmoh2vHzzu0IiUiVmpDcFOYTY3Ox6N/4rQnAstTdJH+faEYA/e4ChKbplID63gGwqBB8L2nk + uD/bqgwcZHPvP3x4JD3BMUMCCDEgAC0XYEQAyRajkc0JQL3ejACC+yOAhAETgC24CoWgaLy4ZIUwZ/63 + 7q23hXyzRgDCC4jRCIDlt8YVzURDc4OyNSb32jd9/QWCIpOF66wa/2AlmSYJIIg8BG/EpWVhf8lBZQRW + Y78EYEkCliPEgDqsX7sc9g5eOHeIN/4y1AfnEsmIVd9Rff0AQQLnO0hiOl/E+npI4/8reS72HmG4894H + KCQ6KYdxauPQLQmgRWwLfl56EkXL9mMs9zKQ+541bwc84ifByTVY0wbk5qAxU2ehsb1e2wGpamrCnFe5 + g9GCAJYZE8D45UQAhPEUDhQs3AWfjCvF7+IkREUHQgCyDsTBMwzPvzhPCeHacLr2KEaPLRSirlIiLnpA + BGD73LNNAP15AGbuvqUxh6Yp6kApAzJ+HY5RKB9pKxk4yKb7H5J2I1fwmQggyYAAkrX+Zc9Q05v2Vu6j + r2fmuQDqdZ56YlAkjkz5hGTtNjFOmcOEPrYBzYkg3qxcmBuGnLhxyCzmj9aM381fziF864OP0KsUxT67 + cLnU63dThS0lETh4SoVfB484BNKP8cvOHcILqGusxfMvLYJ/WIIp+89JNDZ6J1rxCeyKu/mGY/ZV12D7 + jq1iYGmPMox0IARgE2T83T2nsWTRXMyaPgsPPvgYbvnb3Rg75UL4RiZgsLO/KPBhw5bbe4EKKcitvvME + AsXtF9B1yZljsOrV9WhsPWEwF9Byfl6zIIAt1acxedV+4b7nUQyfs+gAPFNmwMGKAGaSB1CnEcDh5mbR + hjxulZoDqCT3n4yfjH4cGb9KAAVLZcXh+GXFgggKGBQKJF+5FPY+3OIdpYh3RPcD+fvzrIMLZ12Olo4m + WdvY3YJrbrhJvE+uBbB8rt+aADz0CUAd9CGAl36aVliKgCkMSD5TAuCagBtthQFGVw5KTB//ZyKAD8zr + /WVpojkBmAQMPENM8//kfUyrvNq77KFc59UnAahlkJJw+qsDsOUJCPdeRwDWYUCcEAjxj0zBDz/9Ih36 + 3h7c8dCTUgJMLQFWpbcV2W8xN8A1FPMXL8cvu3fjokuuohg3TMb7ZPSDyZCkmk+IiP25mnDCRdPxyecf + oLXtlM7gm349AXDhUHcdGpsOo7WV4treWjH4s77lGH4+sB3LX16NOdffiIRRueRyskIwewNMBtLlZ+Uh + 94BoZI4rwgtL5qP8aIkytLPeYmS29QBP+XebqOuftuaQWMHHrqxG3pIS+KbPgb1rkPjsGgFMmSk68bgP + AoRjLS249i0y8FXHMZ48gAIl+TduORHAMj0BHNIgSaCUUIaxT34Dt6gCuHnFmG3d9QdHrwjywkah8ki5 + 1gk5b8Eisa3oKkIA2481J4KzJwCPYGuPwDzRrigBKWrbJgJIPisCIHyQmG4cBgwyWv39ItLDyd046hUi + V21R8KOTK9a2ALUkYJIgCC9ltrmW6BMfPNmkbxacrMkfCQSrSNHkkEweQJKuEMg0Etx8UrC+BsAE4dqL + +n9z4xfuIjO8d4wmAhKdmo3SqipRtd/a0YHZN9wmhC2F6KWmta8o+nJIwKq7FNNGxo9EaOwIsdoPdgwV + Rs+u9gVOgWI1PZ/i6pikdCxeuRinG45YGb46q14zfh7MyUM+tQm+9WYQAzw1w1evbyACqCUv4BThJHq6 + yW3vqVVCgyaxzdjZVY9jJyvw447v8OYHr2HpmsWYt3ge5i9dhJffeBXfb9+ME/XVSoFOg6jU6x4QAciW + 6O1H63HR2oNkxFXIX3UYY5aVwj/rajJ6JoBQ0UXJNRW5vH2qI4DjrS24/p1yIoCjKFx5WG7/EQEU0ONV + D6BAhAKK8S+l11h2yBQSLNmH4DG3wsXDInmnbf0Zi4VwgZBnQBS++v4brQ36sy+/gG9wvEjwagrDAyIB + 23kAlQgscwCeFlJ4eiLwVDQAPDUx3RTddrqNJKAC3xCT5oZBDoGnCocbeQGGBOAVmnYlMVCvVPZJMkj4 + 6WWLTO6M8BAUQ9b6nRUBBONkX7IYBOKlG5ssLlvoBqjqKSYSUPQC/BMMIUqBLYo6nJRxX6oUuJAAo9U8 + I38KTtTVin7xeopLJ8yg1cstWIiAipFdVhN3woVM9mA2dKdgRV47VFwWcTTF165+Ubj25lux58Auk+vM + q32PhCQAvStfL9x5uYKfVlBnBS0noB/z3X2acEqghyEIwEQW0Mig2QByG7KvwiNbJCAJoB2bK+tx4RrO + 0FeTO39YKP4E5F5PRk8E4CGFVPn7yiq6mDyTOq1MuaatFTe9W47xRAD82EJBAPT3slLF+FWYCKBwGZHA + cvp7Bf29qgQp1yyDg3eCmYzXQNSC+LddtGK5Ug/QifKqciSNyJETiizCRVsk0DcBxOn6/41JwNOABCxt + zFMXDquKwLJByBy+wRI+thOJvbyjNyACGDN+xv/Syv+qOtfPwyJhIVd200gjscrr3Xou4AlMskkA+i4/ + tSNKLfiR3VK2BEISzVZ/cw/A5Am4Kh6A6AD0MY30YuMXLrwqAsqz+zyiMHnmFWhubxW7AMdOnUT2+Kmi + h9yQANwihL6+1OyXhj/YSerrn+cYjAucA5E5foIYacbTjPhEF7X9Zit/k0EsrxKANGoT+icAE2Gc1h5j + 7i30nUzsG42GBKCWMDMBfHjwFCaLqr3DGLe6GvkryxE09mZBAI4e6hyBUPpeLkZdU63wABgniQBufY/l + wY5gAoUPhcuJAJaVy8SfGQkUWxGAwMoS5D36mZDtclIlwvUEwLqA6m+vqkgp4Fbva26+TcT/vb0daGlr + wozZ1wivwdXvtySAeKt+gLMjgCTFa07RaQWYwgaf/gmAvYBXxxRd8r99EgAzRGDUCE+KO4r15b76Vd4z + WGf4qpFa3ke53RYBuCvDEfX90ZbPaTJ+XawfaIIa+7NkmIC/bviHv4z/HX3lnD+h9282n48JIF4QwPW3 + 3YWunk7R61Z6uBIp2WNFAosJwE5HAKaJOiYMVQZscPzvERSDB558CodPVMlVrleu+j0WVX36eL8HdQK9 + Knr1Bm9u1OYEYGn4py2Iol68jtEKbo0zI4JeXfsxbwOu21FDqze78tUYu6pS6BMGjbtD1N6rU4SYADLG + XUgEcFrTQ6gj0v3be+TKrzhMBFAlCKCQQoBCxQswZf+VbUCK/4soBChkEAEULae/F+yCe8olgtQtCcBy + LJmjrlqQQ7pRY4pw4vQxLQzg4bKiZsA3zpwAvM3lw21OETIiAG3MffwZEoA1rIeG9L99aEEAxUHR6Z6W + XsAgg9r/Aoo52vsiAMs3JXT+z4QA9EMRjCSSdO6/ngTMCSC+fwLwUQZ9ekUrBT3mBMAx/aNPP68McezG + roP7EJ2cLgiAw4BhZpN4rEdqCeOneH9k9jh89OlH6OxpFHF3j261NzKyf30CkHv5LT3teP67Y2SghxUl + ZBb9LEXwuDtF/sRJGeHNSdVRRAC1jac0AmjoaMPd73ORDxEAhQBFOgIoXF4mCoCMCMCEYkyi60PG/U38 + rmdCADwCzj8iEdt/2apoO3Tjw08+hneg0kXqo9st8o2WvQdeuqKiARKAW4AcIcaj4n8NAXj+NgTQ7hee + VmC5HTjIoPrvSaPGH7NqwGA1qaeXMU42c1m063Qxv4e2t28iAHFdULJZgqTfmQFmhUAJmttvOf6LXUOT + +y+z+CYCiBPlpMvXrFWKerrx6Xdfwj9EykjZEQEMNSIAMZEnDIMp3vcNjcfdjzyKisNlohTX1L7bd1OP + cUa/3jDuN4ft8MCaAEw7Bb8dAchGIyE1Rh5ATVszbnu/DAXLuYy3HGMYy8go8+8QCUA9AYzMn0IEcFKT + KWvsJAL4oEQkD9kDMCcASQJ6T6CQnrdIoNhEACvLED/nJfpNY/sggAjZQqwOCxUyYFw8FIqVa9cqm7+d + KC47hIS00XKIKI+P95KTfq679T6MyiqSo9G9lJmFPIh0QAQQY0YAfTXCWZbKe1i4+mfSQtxHX8GTNj0A + 3iKITBp9Ht3xSzOBQisCsBb+tBQA1Usce1pU9ukJwF2/jah1AyZaTQ3qlwAUARAXiwSOGv87KBN5OYFn + rwzpdPaMFaKi73wgFX64Z/7eRx6hHzpIEMAwMwIIU0ZsR5LbHy6KZSbNmI2vf/ge7T1SHLRHa3Rp+jsS + gO0EoW0CaPjNCEDtNOxVJM52n2zAjPUHRQFPPsXuuQQWOxUEwEKeXmFCtJO3UUeOnYzTjSc0AmkgArjr + /WKR/TcmgHLzSkALAphAIcBEIoCMu96CvX+aHBVmRAD8+l7h4rIkADkEhhOUN97KJdly9Hxzay0unD6b + VnveDowT4JX/voefwY9bdyArZ4LQJnQRcwqjDHMBtgjATUwSju8zGehlY5X/LQmAbTs6Oec8/XbgILPt + v7DhoV7ByUfVTKO652/lAYToV389AaSYCniUv03TTkx/mzwA/X2SZNGPhQdgCgHidTB1AorV318v8aUn + gEix78sGGxCVirTsiSKZ56DUj/Mk1y+/+UZUAP6wdauQ9bJ3CRZqwOz+D1USfuok3sF0fXRqFhatWiFO + ZimSJY3BXMCjcYDGb9re6xGo72fVN1r9ra+zJoDGAWBgHoDaDNRJpPfOHnL/lx0Q1Xtjl5QgZ2kpchYX + I3jsHULT39lbTvPhwqpR+ZNwuqFGIwDhAbzLCb1Kmx5AodjzL7VJABNWcD3At3AKH6t1/Kmy8Y6eUjjE + QYEMASKVqkHp1mdyHqC2RkiG9/a24YFHHhPblmprMDcapWYU4PCxE/h5x27kkRfj5BGmzSe0nQyM1dx/ + OUE4VtsWHCgBeFp0DJ6RiIg6rdv6Nt4ODNV7AYPMq/9Sp9Fq3SVVfJNNlUsh5qXAakGPIQHYKOn10N2m + in54GnT+GU0MMlIBUrcBOd539jcXBjVt/UUK9nfzD8eilavxtwefEXG7EIMkBNKXtH3HTpw8fRoXEfs7 + OFPs7yyn3PB0m6Gq+09/u5DLeOlV12DH/t2a0Xf3qr38jf2uorYq+XpFHkAnAqLt/Rtl+o3IwVYOwCjn + 0NdWX+OACECVNWvs7sRjm0oxdvEhMv5SjFlcgtFEAtkLDyIw73Zh9E6KbLcDGc2o/IlWBHDvO5zUqxDG + b5QD0KNouUoAJRoBcJPQ+Pm/wCNlplbGq237acNFInQ5AN1QEfr9AyKTsXPfLiUM6MZrb75JK7/0AFy8 + ZQcghw6rXn5dLBI7du9DXsE0IVVumwAUw/fXI9asLkCFLQIw8wRU0Z0zUBLSh+4Wt3X5hqZMs0kA3sEp + z3gpxTh6AvCwKN/VdwIOlAA8DQnANBXVkgDkl5RggwDihVQ4r/6CAAzKfeX2DzN1OO55+FFh5AWTZmGo + U4js86dVPTIuA5988TUuv/YmOLgGiVl3JgKQYcAQ5wBEJg7HohVL0NB0SnH3TfXxv44AlO0/HQHY3uqr + 7YMALG+rlx4FpGehPWdvX8bdHwHIHgC1m2/3ySZcsv4QufwVGEMEkEcrfzaRQNb8/fDLvkEJAaQHwBN7 + R40twqmG4xoBNHW24/73iADo8UXLyAsgIihcVt4HAZSS0TNK5OovCIBzAfsQOPZWuROg3/c3IAAnMURE + VQuOFu/vrQ/eU1SRu/HLrh0IjkwlcogRE355q5gbo3IKpuDE6VqRKfpp5x7yHCaLRKJNAvA3KQWZxEJs + dwnqm4Q81SS4Vnh39gRg1JVLocEzRgQwKCYl96/0hJ9ZqpQaEYBVV59W868nDvMcgPkugLrlp2M7nV66 + mgNQ3X/LEl8hCR4QJ4zfVqOPk7cU/bz5rntR11yP7378kV4/TkhVi/Jecu8Dw4eTi1eIoc7+GOYcpM24 + kwgitz8Ak2dchO27toqhEkJhl/exe+Q2n3U83dhHxr+/HIDFnn2/+QBb+YHaAeUGzrwWoFmQH88cYOnU + FT9WYtzi/WT8FWL1z1t0CDmLyAN4cQe8h8+gsCtEIYAoQQAj8wpwqv6YNq+gqauNCGAfEQAbP3kAS8nw + RcxvvQWo5QEUL4CNf9IySQITVhYj9pJnYS8KgqLM8j62oJLAUJdQPPr8PK2zs+b0cWTkFcHBncMEOUOS + xWB4K3PN+jcVsfdubNn+C503RVJkxM92l6CVWlCAfmvQulVYnwjXpgb1kQOwKiEONTB8bYyYlhP4LDYt + 769qHmCQuvpTbOBLT1hhSQBWSUADAjBS/pFFRCYCUDv+zAgg+CwJQLfVZ1SmyY0f/MX/7YGHye08hc7u + dtx0x/30gwdrdf6yTTUEgx0DiAACFchBl3zZxSsYd953D2pOHVZi/TYhJMGS0nL1/08kAKkFcOh0Iy5f + vwu55P7nLabVf1GxUAXKXUgE8NRWuMQUEAGEKko9kZIARufjVN0xkwfQ1Yr7399Lhl+BiSoBLC0zrAEw + JwAyegoBmAAm8uWVpUi7eT3s/VJlIlDx/iyNnl15SwLg3ZxZ194o1Jk4EcgCIbOvvhF2rpxHiBdbxc50 + tHMJR+boKag+VqMMgevFex9/hZCYUVpjmX4XyrZcmBEBJAyIAAYCWwQg7U+7riIgcoSv6gVoBOAdmjKa + XqxV/4Ia04SYa5Xr6/U9jZhIS1wkaxVMpunApn5os9qCIBXmCUDziUCxNvv8ebQXq/s6CummONx2z/2o + E9tO7dj841YERaSJXn7TnL9QxdiDCUHS+J0p7ncMhk9QNOYtmYfGttNyplxvu9TV75WDJSRadQq8pgaZ + AW0DCte/foAE0F8S0JIATlvdr7u3VsAUHgyUCExbiF2K8jAb7rwvSoUWYN6SQ0QCxchZfJBwgFCKEXdt + hL3o1Q9TCCBCJNZGZOejpvaoIifWimZ6ngff34PCJWVk1OUCwgPozwvQJwG5GIiHmT60EU7Bo+g8iBCt + 3Ax11LhjHx4A93Wkj5mAk3WnlMagdjzzwlxaJPg+CYIAHD3jhJAIy5o98+IiZXBaB9p6uvDsgmXCiF18 + rJPQpm3CGLMdAi2RHWiCR1A8ne8Jhv0CXme43+/V/31YK3C0RgA9PXLyj2dI8s2eFp14puEExtJeA4Ku + GchyH9Srj+pCPQEYGb8VAbDxCwKIxqVX30Du3FFx4ja2nMLsq24SST3O5OuN30QAwWKizVDHUIRGJeGV + NzaISbKsp89HniyrKsjIQRvtFuO2Ws5A3LNeV/gzUAKwXfRjTACnLQjgtIDpuoEQgHn9ABNAO33Wj/ce + xbSFO4XLP2bxIeEFMAGMFsKgJYi59CUMc4/RKfaGiZqAEdnjcNyMAFrw8Pu7iQBKheGbEUCfXoCJALga + sJAIoOC57+AWM1bZnlOgLwn2MiYAJofA6OHYdWCvNifxg43vCzl39gAYjl6cCIwV28BhcXTf/QeUqpEu + nGqqxRU33inDTZ+4fsRDY81nBQTGmUGSgPHuwJkQwEDgG5Z6M9u8sH1mgYefeOG/aJVf7mm59xhiLO7p + FWKK+y2794zGG5m2BpNsdkKJasLAREMPYEAEQG4/z3DPLZyMg2X7Nbd17auvipFP3MEnZtaJQp5QudXH + oFVfwCkEyelZ2PTlx2KkF3q7aaXskArAvVJEkvXkpaKsSgBtFjp5zYaa/mflAZj1BViu7H1tB1rDnABq + xXOrW5DGht+ozRro1gigFT8fPoWrV/2MMS/t1wggTyWAJeQFLNgNn1FXiTyLnOWnEIAbEcBo1hc8pkwn + IgLobsWjH1IIQATA7v8EjQDI+JeVyNZfgRKLv1UC4HLgQyIROGHhz/AafpF5V6Bu7LcsBovU4KSrCOQi + sdfffUdRCOrAnv27EBE7Qug/OnkmKEQgvYChzgG4/ua/obWdz4kuIQRzqKoCY6fMFP0GZ0sAHoHWHoDl + 1KDfEj6hKcsffmLuf6khwKDIpOzz6IW+1bYdQpJsFgKJOCNEqfpTk3vBfXsI2vah1iJs4AVw/B+QZFYI + ZEkAll+uGQHQD8BKuN9s/lobj7X/0AEkpediiJhWEyagVvbZ60hgqFMwcsZNwvad22RZMI/16u1RssO9 + 2uw8uV3UpawWei+gTecJWApnDLQQyBzSbbe18psIobu3TqDvLUIL9NbqtiD7XvWl69+CAyca8LdX9qJg + /h4y+n208h8gAjiIMSIMoPh/STEyHvsSdkEZ2lRfdVQXE0B6zjicJA9AzQG0dLfhsY/2Cw/ARADKyr+s + WKcDYNkUpC8HPkAewQFMXLoXgWNukO3ePjIHpBYFOdnoDJR6gTGiyIurOXsUpWAeGJKTP5m8lihJAIIE + 4oQqNOtE8lDRt96VAjKdve1iIPzW3bsxIneCeM4zJ4D4PrcEf4WR21YRDkv9NjolVxQEDVISgD6cAFSL + fjRlH1FQkGKeBOTrwpSpwPoMY2g/Cqb8PCHWtc1eisiIZYJwIASggQjAMzASi5YtQk+3rMVvbK3F1Tfc + Tm59gNCpt3MxIgBe/QMwRngNh5Qpv73o7O5AXX0dqo9U41BZKfYc2I9d+/Zgz8H9qKiqwuna0+gQst56 + Mmi1Cgl6bWwR/n4IoN5wu08UNvXKYSU8hmzn8Qbc8foBFCzcRwZPRr+Us/8HhPHnkeHn8pEMNHLW8xji + Jg3ekbUAlIm+rK40Mjsfp2qPaN9Ra08bHt+4H0WLSzBhiSSAomWlouDHnACK+yYAwuTlBxE59SHYKW3e + DBeVAGwZv7JwcB6g6KJZaG5tFJ2BHZ3NuP6mO6QsvCet/p7SA3D2lCTgQNcPH5WPg6Vlck9AjDvrwqff + bkF44mgrEjAnAN1WoIj/JQH0NzJsoDMC+iMAnUJQRXD0SJ9B6j/vsJQ0MsxGrepPkSES4MmkeoSlaQKF + GlTlEr0kmEE5o2n+uXntgNQdUCsEzUuBzQlAjvNS4eorBzq6kqt5zQ3Xo77xJJ3gciruulffJLaOUZJ7 + IUoIEKoRgAgH6DoeFsGTYw8fP4qPPv0cTz0/D7MuvxYZowsQFT8C/mGJ8A2Og29QLPxDEhAZm46RmYW4 + 5LLr8OSz8/Dpl9+i5sRxLUfQrQz/VIlgIDsFhrsGfRb72M74q4TQ3ds3AZi/nq7Qp7dFG0F2orMFb+8/ + jStfKUU+r/ZkhGMV8OW8ZYxS5JLRZs39CS4JU8S+uYMyTt1RmejLBJCemUer62FZR6EQwFMf78OExSYP + gAmAt/kKzQjgkGb4hQIHCQcU7BPgpqCEOS9hmHei0P7TF4JJ2CYArh+IH5GDqqPVWmfggkXLpSQcG72X + BXhADJ1T11Hs39TaLCYqd1GIyIPilq5/g87nREPhELMEoEU9QF8EMFDxz74IwEIejNEYEDk8TSMAWoEv + IWPt8dRXECkE4CX0/PonAEtNQI8BEoBHHwRg7QFEmxk/w8k7DDljxqCkdI8SX7Zj7/4DSByeS4bPCT7p + 5rO7rycA2dwTirzCC3E1/ZixyZli7/qvdt5CvPN81vi3CxBTfQY7hmCIUwgGM1jyy56lv70xmOBCru4I + WhGefu4lHCguESeEPjfw2xFA7d+VAHq1Tj+Kz3ta8cOxBty1sRwF3HfPTT7LSzGWjDOfwMcxZHR5AqXI + W1mK2BtW4wLPGFFCba+bqKwSwAgigBOnq6UaMr1GW087ntl0EBOXlIkioF9DABPIA0i7cRWG+iaJSc8D + IQCJaCH17hOagG2/bNM8uk8++1yM/2Zjd7YgAc4N8JBSnge4+pXXxLZgZ2+nSBg3tjXhpjseEFufrj79 + eAADnBtoaeS/EQH0+IWnXTJo0H9rBPCAKvcl9xFThCChV2iqIkWcakgAlpqAXqEpNguIvHWjwz36IgDW + CgiUCUGt519HAMLweYQzD2kkFy8sOgGbvnhXduPRqtLQ1CCz/i5BZOAU3yvgy5rxqwTAmvV0+XzW82ND + F0M8AgW4zVdo+juGKKIfoRjMUDQABLE4EcGwBPcwH1ww1BeRMSPx6ONzcfjocXEy9Rh6AP0kCLUkYL0G + LWFn+beh4fdFAPK6XpwSSkAmNPPGFqpbW/FJRT0e/OKYmMuXw809KysJFaLTL395GYG8gRWl9LdE3uoK + ZM/dDufE6fSdBws5NTtLAqDLw7PyUHO6SiOAdiKAZz9jAijFxOUDJQBp/EVLGPtNBEBhwKg73oSd33CR + 2OPY3klfFmwLfF8e+kIk/tZ7aiKwjUK+HSIUBgAAgABJREFU3QiJThNFQM5iHoQFCRDs3CIRm5qLHQc4 + 4dyleH5t2F9agvTsCbJz0KhZKEDpE/CP61M6fKANPwMNDQyEQh8Qxn/xZdefQ3dY7WVBAF4Wq7yXzgvw + CrHsBFTnBCbZbGlUhQ49Qqy7CM26BM3kv+KtCUCd4U5HT99QPPPC4+jorhMxK8dwK9euJzcwTKr5KMY+ + VG/4ZgQQKgmCtwCdpLAHD/M8dygPzwgQAzKGOHMXYZToBBxC97vAMVSIfQ5xDBE7B8McgzCEtfhZWXeY + FwYTsnOm4utvZfVgjyag2WyxS9DUNwEY5AvMrzPvGRgYATBOoa75OPYfPYoDNaew7cgJvLX3GJ74vBSX + vHpIjPfKWFxGx0rkkmGK1X9FBcYS8unv/BVlGLeyHGMZq4gUyPgCJt4r5v/Z68aCGxNAtfDQ2Mg6iACe + ++yAJIAVZ0MA+zQCKFp2ENn3fQT7wAxN7akvAnD0UuThPOXUZ64Cfe7FuYpUeCuOnTqCtKxxIuknuwfj + REGQKAzyjtdIYCh95mtvvRNtHW1CIr5LVEp2YO2Gt+DNpeqiUtCSANQGIZNikKVWwJlMDf4VBLB6xuwb + zhkUlZxzLhnp555WBCAlwTQCUKS91ev1oqC2hAs8LT0AFjpUxUEN+gg8NAJINCMAN/7y1EmsvnI+u6tX + BC6+ZDq5lZVCyZZXsV27dyMxNQt2HsGiA1BT8zEiAKXNl2NW1slnBZuQ6EwUTJ6DG+98GE+9uBzLX3kX + r76/CW9+/AVe3/gZlr36Fh5+ZgEuueo2xAwfS68TLmTAhwzzp7DAl+BDZOBDJOKBoPBUvP72B+KEsJbU + HjgBGJNCvdwm7DV2/U2FP+bbiCwcytqBVScqce2Ti5B45XwMf+ArpD31M1Ke34sR8w8hfRERwJJijCbD + zOH4nl385ZIE8gls/ONW0eXVlUKeO272XAymVZJXfzPjtyCAtMxcHDtdpWyhthMBdOB58gAmLP2VBEDH + AiKh7Mc+g0NYjib6anvVl/v/YjuQJeKY2J0Ccf0tt9P3I/MTze2NmDJjDhzdIgQBuIiyYB0BeMv6ADuP + KKEJ8dV3W4SiVJdSKl3bVI/LrrhFjCxztSwGGgABDHQL8NcQgE9YyucxqXnnDvKPGuFGxrvHw4wAkpVM + f7KOAFLMyg09dMU77ropJ/piH3Mm0w0A0Ugi2axTUM4BTLTq+VdnsLupDRa0+kfFJ2HLj98q9fmtqG84 + hcsuv1FKeLMIhUe4Ts/PmAQucAqCZ0AcLrz0Gqx7810cqqhCQ1uT2NrpFVt+PTp0K6PAyFnuakHZkWqs + efMdjJk0E3bO5C3YeZJn4C1IgHH+UE/4kqv31nsfKgNEBkYAA8oPKEpCDMtdAHX3wFT5Z8oZsPF3dZ1E + R+cp7CzZj0seWYvwWz5B/CM7kDT3ANLmFyN9YTFGLi5GFnf3LZUtvrnLJAmw4g8b/7g1hNWlSLx2CRx8 + U0UDlYOLaRagSgBOOgJIycjB0VOVooiKv4/2nk48/zkRwLIzJwA1/hcksHgv8pfuR9ZT38AlerxJxsvL + GJZThPl9ciXohAtnkuHXiy1P3t67/Z77iQBCrAhAGL+PhIN3nGgvv+SKG1Df2ig8vi4RCrRj87ZtiIjL + FOpCZ0MAeqGQ32jv30QYMr+3Jyh2pNsgn/DUcDLew1YEoBi66gWoE0nkdl5yv9JFhk0LakegJQEEqUNA + kwxFP/QEwKu/u284nnzuCXT1cNzfKkp1Fy9fDXf/WFEMpFZ8WZKAngycvMmDmHMtvtiyBU3tLcLIe0RK + h35E3t/lIiCR1dejTQBKEVA33f943Sk8tWABfY5IIgEvIgFf4Q0MYY9gqDdiE0dh1759SmKw6TcigPp+ + CaDHggBU5WBBAO0n0NJ6At/uPoiMuz9AzH1bkfTCfqS+dAgjFpAXsPAQMhYRCZAXIDyBpWVEAGXkBZTR + yl8hBDkTrp4PB/9Eqf/Po9RdwwxXfwYPWk0elUsEUKWQaCd5AJ144bNfTwCMfLo8+pnv4BpXZJrsMwDj + F2ChGPIC0zIoRKk9JuJ4Jv+XFi+hzxGiqAPpCMDHRACOPgnkCZDxBsbj/U2bRCKwW3gBLWjvbsa9Dz2l + NAzFm7cK/z4I4LB/5PBwlgDLJmNssNlaaKlAGppiU6BAtCEGJdl0ZawkkdQwoS/VH/ri3IXRMwGwJFM4 + CqdMxdET1cqI7i7s3LUXCal5yqw4OTCS+72ZAPQkYK9o1PtHpGLBijWoa20Wrlu3YtA9WpmvEVq1+6hZ + fnW7j/fKV732Kr23MCIBH40EhjrwboEXrrn+DrS162sDzo4AzghmKkOm1b+z8wTa22vQ3HIUVcePYs6L + nxMB/Ijk5w8hjQhg+PyDggRGcihAXkAmEUA2EcDoZRXIXclDO/cj5cqX4OCXSAYfSKu7FFDlcl+VAMRk + Jd34bkkAeRRbHxbVdmoI8AJ5ABOXlWGCmgQUIiAlBsVA5rsAMgSQJDB+yV6MJRLIIQJwi59oEu/0NicB + J93CYOYB8OQnOidCo1NwqOyg0hPQg7c/+ECca5IAFCgaAS5k/M4+CQopJIhBpdNpMWlob1AWimYRSuwj + Lys5c5yoUHT3JeP3jTXoC+ibAM6o7H6A7cIKETT4hadlD6IrptMd2wdKAP31A/SrdmLjg6oKP0YTfoTx + +7AWWySCIxPwyZcfi9Wav+zm1hZcdf2d8gdVJb95ZpxHtDLWK9yMCFizf+nql8nNI+roJfOnlV52+bUZ + GH2bwVjsVsNR2S0dDZg84woxn48TgkPs/cSwTiYBL3IBv/7mB2Vn4B9EAGbJQnMCaCMCaGo5gqMnj+Ge + 9VsQ9/A2CgFKkPLSQQoDDmokIMIBQQSlyFpKsf/crUiefp9otmL9BEe3IB0BhGgEYG9EABljcPzUEa3p + RhJAsRUBjF9hqvsfOAHsRd6z38MjaapcAHhaUB8E4GhBAFy45BkQiR+2/6jUAnRjy7YfRXyvyoOxQpCr + j4kAXHwSBNSkoH94Krb8vF0sSj29UjeBF4Z5S1fQwhUnCMDd11g2/O9JAEb2q+QN2n1DU6YzAdxGd+jp + z9DPtCHI+IMkGtY8mwjAoKXSl9wlkfgLh6tnIO669060d7aS8XaJ1XvDWx/Bh8ITZ2H8sZIEeGtHqABL + UUhxQnrIrP/w7AIcO0nG0EuOXk+X7PRTCMDSA1C7/np0xt6jg0YAXDXX24Q5196Cc4f6iF2BoQyHAAxT + 6gZuueNBdHR3/kMJQPUE1AEiXV2ndARwFEeIAB5+Zwfin/oFiS+WImX+IaSS8aeR8Q9fUCyQRuFA1gJy + se9+C5EZM+BChu7oHKAQQLBwkx2VCUDaKDWPCDND42q7lKx81AgZbukBcB3A819wb/+ZE4AaBogcABPA + 4r0Y/dwWeKZcrCkDSQJQZcBMzT/yPUWY4CG7FZ3Je/vw000KAXShuPyQUIjmTL6bT6yAiQBUEmBPII7C + gjghNf7Is88Kb1IVi2ESOHLiCMYUThdjx9x94/smgMAkK6h2Y2xniX3cpthtkISBHfcQEdzGBPCcLbbo + U3zgjAmAj7L10XJaiode5tuCAHgvVaz+XsEYMXIkSkr3iXp9dtyPnTiJMeNnKu5ZrIkAvGIUGXCdMqxg + +nDEJGVj247dMrXXK1t9exXjV+N8k7E3a22wqtF2K/XxJoXcDvFYHjUVHp8uxnLzZOAhCuQ2oT+ShufR + yXBcqQ5sPAsCsKXf148akRIG8AgxEwEcR1PzEVSfOIoH3t2NxOf2IHleGRk/EcCCg8Lo08j4+e/h8w8g + 447XEBSVCVfXQDiT4Tu5BMKRIQaAmhu/IACLlZaTgKnZ4wQB9CrfVyt97899WaoQQPnZE8Bi6QGMfn4r + vFJnyi07nxhDAjC5/mqjUoSWB2D9grWvvy5rAei8OH7qKEbmjRUzA918YgRclQnDejj5Sjh6RiFjbCGd + k9XaVGU5Cr0DK9dtgIefSgCmAbbWBJBsBWlPCTaMP8HGbfpuXLLbwCSziVs6T+C5QXTFGlsug6323f4I + wNNA2ltd/UUNtK4KSm/8tj2ASHj6hWDl6mUigSQMl/5btf51eHPi0FsZAya2f2KULq9oqzZQR49IUf6b + TnHZpi++RmtHm9Lg02PR7GOq8YeS9DNBauJ1dDfjVO0x/Lj9Bzz0+NMIjR0uhm0OVgeEEoYQhtLfDA+f + KGz95RfxHNYFQX2JdDYaTOhptLi+0XDl7xawJICTaG07LgaKlh0/jLve2EHx/z5y/8vJ+IuV1f+QCAXS + 5h3A8Bf2IOnyJbSCkQG4+GkE4ERkwB6AE3kATu5h5iSgGL8ZAZAHcFwQgCTZNiKA579SjF/vAei0AIwJ + 4BCKtO1AGQLkE3Je2A7v4ZfJun2tFyBSgxN3AipCoXoPQL7PCFHBOG+pHBfGXZ9NLXWYcOF0cR9p/OqI + cXMScPZVwEKiFOq9IyTG1DBA5gIqj1RjBHmenEx080+0IgDe+eL5GSoG5gEkWngAasdtsvkWPC20AsZe + wJpBZJwf9hVzWLvrSQNa/Y3kvY2TfX0YvwJnzxBcPHOmnFkvSm27iKFPoWDCZVp85mLRGeikawM1hQLS + NWV3LSAsFTMvvxlPzV2I1a++jrc/3Ij3PvmE8DHe37gJb723ERvefBfrNryOlWtfxqIVqzB34VI89sxc + 3Hb3Q7hkzvUYlVMEX2JgUWKsTgkSJcPBGOIUZIahTgF4d+Mniscw0IEdAx3uoSeBJjGOrJsHh6rorUMn + hQFdFAZ0dp5CS2sNGhqP4uCRY7j+5d1ImXuQjL+cVn5y+xfyTsBBDH9pP9Je3I+U53ch7cGvETL6WjiT + sTMBOCvxv5O7SgChAtr2n0WiTdQBCAI4qvUCMAHM/boCE1dWmHYBhBS4aTKQEQEUESbwcYklAfwE7xGz + hRcoGoK81ByAFCXhFV/Ig3uZVn5HnafC4eGjTz+nhSidrA505bXifq5WDWjWngCTwDA6v6699Q56rKoX + aWqlfvCxp0WY6uaXqI2xkwSgm31pYDMDWnCtiuqsO29tPPZDJoAtlpn5vo371xGAadXvnwB4B4DLfsNi + EvD9D9/J1V+Ic/Rg3atvwzcojbyDeIUAYgwJwHw2oBwOwl6CI88G9JT7uq5+9D5YaZh/FFF4FC8Gh3Ch + iL0yDJQLhlhDboiLnAXIGOoaIUpCxcxA3aiwIc4hdL9gCYUAOA+w+pUNZ0AApgYdAV5RzIRIm7Treywq + DG0SQNdptLefREvLMTQ0HMPPJTWYsWofufplGLGwglBCKBYJwOHz9iFt7l4igB1IemY7Eq5ZCdeg4XB2 + CRwAAURYEECEQgBHtFLgDiKAed9UYeKqSkxaWSk8gbMlgHGE3Lm/EAHMGRABqJ6Jo04ujMuX77z3IU3n + gXNCN9121xkQAIWd5HWkZo7BsePVOk+vUXze77dvR0h0Op3P8WYTrVUC8Ag8OwLwVPQ33UOsCcCj/4Tg + lkEeQUl79Xp8VhV9fYwz8rDQ9jMND7U2fMvV3zLjb9nyKwiAt/8o9n/iqSdo9Wqjk1m6/kdrajCu6BK4 + esVriRnnfghAzQ5rOwXecWIrx8U3ES7Eys50dOJ9XfqBnHwTtEIPe5aD8oiWcGdCiBaikY7uPGWWvQla + PegEH9oPAVzg4IcV61YrJ4ZaFNRitpMg24o7lEx5h5KXaNV1FjYr9+vQBCzkkI4WZUuyWUcA9WalwUwA + nZ21aGs7SfH/cZyqP4p3dhxG3hJa7Wn1TycCSCcCEJl/IoARwgPYi9S5u5D0/M9IvfsD+MeNg6trAFzd + KATQEYA6A1CFZYwtcwD5osRWI4CeNsz/rgqTVjMJVKFohToXsG8CKFTagfVJQCaAvBd3wGvEpSIBbJMA + +hAKZQK44dY7dbtBHbjrvgfhTKu6q5oDMGxFp3PXVx1IGwdv8gi///EHs1CP80Y8Gn3mnBtFdaCbr+Uo + cYvht7xA6jQB+xoa4mUgz98fAeiwlwmg3EQA5jP++kvuufdBAJ79DfrsjwBY8MMjDDl5eTh8pEIosEhl + nl6sWvcKxf7x4kdRY7J+CcBbTwCxYvtGbOMQ2OAtoREA3dfeM1YQARu/ngC4jNSB8wqEIXQCca/AUOEd + mAiA25GHcCLQOQCvvvOGBQGoycZ2YcxlVdV4+IWFuPfJF7Dlp5/RyVuUmuBIiyh3bmtvxKdff4MFFJJ8 + /t1mtHa2KsUrJlmyPgmg9RQammpQdvI4Hv+sAqMWkdEvKhcYuagMI4kERi0gEph/gEiAvIAX91CIsBMj + H9iE0OSJGgE4KwSgTgC2JoEwKwI4rhAAFA/gpW8PY+Lq6t+AAPYRAfwMz+GX9O0B9EUARODX3Hib6O+X + rd2duO+hx+DCk4LELkB/BCDBu00rxbg5cwLg3+iNd96HF8+x9NE3CcVp0631MzAHQgCm4T2pFjAV6/Xj + AZQPcg9KOqYKcooinj4mkViSgId+mKfF4FDPfkkg3owEzFt+o4Xr7+UbhtffeE3un/fI8lxe/fPGXwQX + r2gl7o8xM34zKHXhWn04Gb+jRgBx0s3n4Q8C8WZg43egE8me7i+MX9QVRAnwVGG5+kcIcDnoULdwDOGR + 4QwXSwIIpLAiEt9u+15ZAfWrf5sw/sojR5A1/lL811998V9/8oAHfUevvfux6DRTaxLYQ1i8fJ0IRf77 + rx5idsHzC5eLxhr9zoUIH5gEOAnIREDo7KlDRxd7AKdR13AS35Uew8zXyjBqSTlGLWYioONC+lshgFEL + DiKdSWDeXqQRRj30BUKTJsLNNVASgHugGKNm2wuwIAAOAU6aCKCdCOBFIoAJqyQBTFhhmgo0fnmZVgyk + QUcAYieAuwEVAshnApi7HR4pFymCIKoikDoMZGAewLU33W5GAPc+9Ah5mZHCy7RJAEIMVBoyEwHng26/ + 6x5Rnt6tIwBOCB45fhjZeVNEQrIvAhCdsIpNSk1NE3iWhhzBJ4V2pdhuqjlCUrRyfUPDVx8bknyMCCC5 + TryYwcTRgW7xGZYF91Hw01f8r/b8i8TfJTMpVq0XGn29IivfQ270a/RFx4mtP2dv2zPcJQHEmsFEACY4 + cj6AGF5CZ/xecdL4WT2WcwEekWawUwxfQMkBDHELxWC3EAx2NScA3hpMGDEa1ScOa9qBJte/TXyuVeve + wDnnBeN/zgvB//uLHwb9ryvyCmeiubVZCwtq608hZcQ4/DcRxDl/9aGjK4Kj0lBWXaHM7LPIB/Q2aXmA + zu56QQCt7bU4evoUlnxfjTErS5FBBJCxmEDGn7GwVEAlAPYC0ufvw4j5+5H54OcIjBoDNzJ+V3drAhA5 + AFsEQG50CsfGJw5r6kkiCfiNOQEU6QeDGqgB67cBxzMBLN6r5AD2IfepLXCLm6wJgricIQFwY9hNd9yl + 1YHw8c577lNCgD48AA0yFLWnhWDSRZegpa3OavuYw7lHn3peEICbkuNy81MnXenyY+yJ66ZnWw7b0bT+ + bcCIALwNZnvS33WDKF5osZxD1i8B2CjpPTMCsOUBxAh118CwaHz+5aeyRr9HFmecrqvFuEkzxSqsbvcZ + G74EC4U6+cRoq4IMA6K1bUKVEBw0xAqIFZ9jfzJ8O14dPC0NP9wMrC8v4n82fCKAIRoBSNXh8+x8cPPf + 7pMKw5pcmJ4AuvHGuxvxp6Eh+N/zQvG/5AUM+n+uuPDS69DW2aqtSCdPnURMQi7++/888T9/8cI5/+cE + v+BoFFcUG7QaN0kvQEcA7YIATmPX4Rrc8E45spZVIIsIIFMx/Axa/bXjgkPkDRwkHBDIuus9eAcOJwII + 0hFA8IAJIDkjT+yR6wngRSKAogETgGr8ah2A9ACYAAro79EPfw3XiAJlr/4sCIB+s3seelQTfeVcwI23 + 3iHCUC0H0CcJyC1C3mrOyC2gc/W4VXKWP/fmrT8iKIq+R1+lPNgvTskBmKTx9dOz9dOzNCjTub25Q9cQ + UqHL01ZJsMkDaOFdgE4zww4xDRawnXU0TjB4DpAAjEp+3ZQBn+xuOdEJdPlVV6K1jXXaOoU6LxMB7917 + BsfL1btPlRdldVekwp2UGgGTMqwpKSgrBs1hrxi+vafRim/cXDRUJz5iQqggAFefEHwlhpAykbVYlRLz + 6l5TexoTpl+Fc84NxP/3Z1+Exmfhm63blNJSSRRcufjcC0uEEMl//8kJg+3d8cjjj9DK3mRcL2BJAN21 + aOqoxQf7azB5XRlyllZgNLn+mQsUo19UTMdiIgSJjEWHkLn4ELKXlGHkDavhRt+vq0cQXHTGP5AcAJfb + JmWMEf0bKgFwCDDvO4r9V1eKnYCBEYBi+EtNWgCCAJYTSd3zAVyCsuGuGKupFJhJQCYk+/YAgvD0C3PF + byQGwXS3Ys5V1wpPVOpPxOgKgoxJQEiM0XMlDs/C4aOVBpJwzahtrsXE6XNEgZEoD/bjnSdlK1Cdmq2D + 1i1rYaN61S4jDLBNuJMLgXq0oh8dAfS97fDrCMAoEaiu/q50kvkGRuHTzz6RAg0i8dclkoC33/u4FGnw + ih4YAfiYCIANPjgmHUHRI8hoQ5WpsWrXoISI7dn46fIwJbnHWX69uz/Mzbi12JgAyBNw8MFFsy5FU0sD + entk2bBxP0EbDtccwXMLVuCx55di18FiWZostv5atcx0a2czNn7xKZ6kk3XjZ59RiFAnXH3DrUQDAqhp + rcdz3x5B/soK5CypQDa5/llMAOT2Z5Dbzys/G3/2ohJkcVvwEpb/qkDyzGco9g+2SQBqP4AhAbBRjMqj + z1elEUAHHRf8cOQsCOCAGQEILD+EEbe8DGf/kUQAsaJ815wAImwSgFqwZEcEsHzNaq0AjBefKRfOJEMN + tUkAeu0/mRCMET0H8SkZqKgqlSpVVlWkbXhxyXLxHrk3gAnAQyEAN1UNq18CSLLW7jw7AugZdKYlvQOF + Rx+FQGrSw4oAWNufjGnKRdPR1FQnin5U9//YiRMYmTNZyjQNkACclMpADgG4CGjKJVdi/RtvIiQ2TSoD + 6xqFZOOQutqTW2+1yqsrvWrswTqo8wSDpRSZcnmoUyC8A0Lw+defKyt5k5U4iD4hKBNknVolomw5Vrf5 + 5ESibu0+PYqGcbttAlC2BLuIADq66ogA6rD/dAOufZs1/srFJJ/sBSWEUvICDinGTys+rfyjlxAJsDAI + GWPRyirEFP0NziL5Z+H2q41AOphvB0oPIDYtCxVHy7RtQG67XvXzMRSursAEhQAKV3ACsNzGZKBiwiFB + BKwAJCE9gvErDiHh6oVw8k2RbrWPZTOQRWGSQUOQs1co3tv4oba9eqq2Bll54+l5IsyM34wEuNXX4np+ + vUT6rFWHyw1FYXkn56cdWxERly7qV9z99PaQIIbeMhG46YhATwBm07p+gzbhvxsBuA+YAEyxv7OQ+wrB + G2+/oWT+O0StPp/wn3/9rWhqcPaIke2+AyEAL1P8z0Y9dcblaG5rwtrXXqPPFk8xepBUCFYN3S1CF+Ob + C4lYr+5s+EEKTARgJwhAEsFQZw/c+9A9FMdzEU+zWJH18mC9hvUAKkwNSepI7m5ly1DkBHo7xfASWRlp + NJ3I3AuQHgB5DwdPY/KaUuQtLZPDPGnlZxJQCSBLrP6SAFgQhPUAp66tRGTONXB2DdDF/aH9EoAqC84I + T0jHgfIDmgfAn+OdfTVELiWaB8AEULCc0QcBLDfJgk8QsuBEAMv3I2rGE3DyS7RBAFGaoTtaNCo5KT0i + XoEx+OGnrZoycGnFIcQlj1Ik6GIM4eIdbXUd7/On847HiSOGBNBLYVp94wlMvmgOXDzZC0g0JwBLEghU + Mv82Kvp+CwLosdza8/wV8LCAZRWgKfkXb+b6c/bf0YtVeotwkti3V2vTlTHyc/OWKiITUstN7vNG6ySg + og0JQPUE7OhHzp9wMRpbGtHW3YKXVqyCS0AkBjsFyCSem8QwtzBDN998xZcQRi4IIFgzejuXQNg5E1x9 + MPva2Th+ukIabm+TTnnXBGho11b+HouWZH33oakIqEsMMOlFhxlxWFUFQvEAeupR19GK5745grFkZLmL + S4gAyNh5xScSyCL3P5OQJTyAYkEALAk2dk0lLlpfgdBRl8HFRV35dUk/neHbK3DwCBNQCYAN0D88Edt3 + bdPNUGjDN5WnMGn1Qc0DKCICKFwh+wEKDAmgWJsNWKR4AuOJBMYv24fQorsoBIiXElw2CMBJIQBHC0EQ + 1gOITBiOkspi7fv9/sfvERAeL5J1Nj0An2gtMai+LocA4yZcJIzcdoVnC5585gUigChRGuxKRu8aYIJq + /G6KOK7oC+inPfisREKUEKCzv1X7TN3+vgqBjJJ/LJkkPYAwLFm1Quz3yzZdKbrR1tmES6+8VTA1J0+Y + ZYVYo1r1ZSYCaUAAXnIAxMicItTUnRRxGMfSi9ethndoPM538JdZe0vlYE1UNES32isQK32QRgLC+IkI + 2Pg5Q37LnbeiprZKc8N7FfcPVsbfIurOf/7lJ7z1znv4Yft2tHW1KTJiphFkfGI2NNbhI4r7X3/3XRRX + lPG3JFSJemwQgIw5G9HR28CPFu7/FRt4iEcpuf/FAtlk9Iys+QcEBCGQZzCaYn/W/M9fV42L15cjcPgM + OLmFmlZ+ZZXXr/x2CliPUbZgR2gE4O4fiY+/+FirXmQi2HO6ETNeNRHAhJXl5BHQ6r9CEkCBjenAYvVX + CoLGLT+IgiV7EJh3I5z9dPP5jAjABuzpd8ufMAX1zbWayMwrr20QLejutozfKAdA3oejVwQuu/Ia+g1r + bfRyNIrcwCefbYRPkFJAFJBgAdUDSBRVgV6BiX8XAvANTu4c5Bmc1GK0ev+Wcb9lz7919j9GbMslpueh + tKpM6fiTfdXsRnEb6ai8SWKLRQyAVOScB0oAvNXHW4fRyZkoP1IpmjO6yCXv6GnGO5s+RuzwbJw3zEuI + Q5okxEN0suI6d59W+CEEPuoJwE4p+/ULiccL8+aiqfmUmQuoX+1NBNCEzs5GPP38XDrZIvDXYT60qkTg + qbkvob2rTanwU4y/qQ5XXnczzncMxHkOIYhMzsHbH21ShFFsewBd5Hl09PJgz2a8ve8YipbuxRjF+Ecv + OmSDAOh28gDGEAEUrDuCGWsPwTehkAzaestPKAENgAD4sYtXLtERQAeOtXXgxvfIqCnMMBFA2cAIYJmc + DVhA8f+4+b/AZ8SlVtOi9NqAfRGAHYU2f7vvfiHr2atMg77nwQdFXsDdwPiNCUAW9Th7R+DhJx7VTYVq + MswDHCzdi4S0bFlAZEUAqieQKArCfg0B9CktHszbgMFJdWbxvkXsb+UVGJT7egzQc7BFAM4UBtjRyfK3 + Bx5HJ8f9PbJHX10h95UcRHhipnCvXESGN0aTabJFALyd5yi2+WJEKS/X8vuGJmHHnp2y26u3SfRrs/Hs + 3L8TF142h05angngK2SizZN6RmACCBDHIY4BsCfCyC6YgI++2EifoVFm+3taDOJ9cwLYt283PGl1/N/z + PfCnIX74nwu86PuNxZ79+7VpxJzq++qbr+l1vPHnIUH4k10kzhkahPj0fBw5dthsNJkqRiFBn6+HSIaO + NR0tuO/jEoxduB9jyMhzOM5feEgx/v0KmAAOCmJgghhLnkLh+iOYuXQbPENHkhFzfB+sQEcAbnIAqC0C + cGECoOtvvP0OM+WlVgph5n53mAy/jEAhABFA4aoyFCokINDPdODxK+l9vrAV7vFT4aKElOY1Ibr8kCEB + hMPVOwTvfPC++J55x+lU7SkKRaeSoUeYEYCLQc2JJJtYrSSYtSs3vPGqsgNgNHOxQeQB6hprMPniy4So + iGUOwDWAvQIWEI2HZ8DfzwMQhUBk0Mf0BNBXV5/XGRCAscafseqPE32RPmEJ+Or7LVI0UmyXtSpG0oJv + f9wCn/AkOWzhDAjAtK/PzTwyT7Bxk3RD2TB6euUMPF5lTzedxNrXX0XOuIl0QrD+vy+FBr4YSi69NXhm + gA/dx5t+wFBkjRmPeSuW4PBJZfCFmFHQpGz59UUAzdi27QdyQQPwf0wAg33x/waTF0Cu587dO5TVslNk + +z/Z9BnOH+ZHBBCKPw2Lwv+zC0FATDpKK0r6JwB6ne+razFt5R7k0uqeu4iMfOFBC+NXCIA9AoUEcpcW + Y+KGSlz4xOtC8MJRxPWWBBCmqQH3RQA8LThzdCFOnTqhy3N045Pi05i6ukSEAUWrKyQB6Eig0Aolwvj1 + 48Fzn+QioELR1ckrsfnU6L4JgAksJX00qg8fVr7rTny5+VsEhiUqUnR9E4BacSr6UbzjEBSRhm0/bxXn + rTUBmHQbOiksu+ehx8Vjfw0BnG3yT3n8Mc4BlPdFAIaTfHWiH+42k30DJwA+YcZPnU6sSDGYsvozAXDi + jL/I9zdtpMfG6AjABOsGIGMCYC9giGsYnntpgZzh19Mscwy9rUqoITPvHG5s/OJzPPL0s8TQsynMiKCV + 14/c+wDR0z/U0Z+MIRjjpkzHg08+jY+//Iwec1jr1FMNT+/69+UB8Ly87NwC/PefHPH//uqBc/7siMIL + L6Z49LSuO7ALx2qOIzN3Ev7nr57433N9iCx8cNs9j6C1o9EwB8C1512sStPbiIbuJjz3dSkZ/j4y7BIy + cLnSWxOASgLkHRBJ5FGcfc3bpRhz5d0U5vgLD0DL8isCIOYEoIivKlur+hCAScCPTrzNW7YqEuvyc1U0 + tuGqNymOX12mEAB7AaWCBIwIoGgFqwhJFDFWlyPr/g/hFDRaIQDrqdHaPEClKlCrDvTmEu5A3P/IY/Sb + yR2VDvrO7njwYVoEIjQC0Ap/+ig7FwRA59nIrLH0W1XJNmCDGQ8qQL/L+pdfFkrWrhaGL4+8G5DQbwhw + Fkavuy6pnAlgry0t/75ECs9M9MNU+GMk+OHgGYaFy5fLhBe5zeiV21pdigG9/u5bYj/27AlAhgEXOIdg + +pwryWjqpZfR06YRgIkEWpWMPJPBCeSMnUorrxeGOPgJ42exz+CoFOwrLVWy8e2mMtzeZp0QhCLMib69 + AE7UbduxFdMvvQLDR47BpVdcj1379+jGj5tIYDeFC9ywUjB1Jh59fh6O19UoYUyLMQEItGDniTrMWLcH + 2Rz3LzTF/RIHrElgwX4KEfZi9ppdmPfBVkSn52Komz8ZdyDs3YMkCajyX24DJAD+XejvZ+e+pJuxQO+c + DO+Zb3jYyCEUriYvgDwBvRfQNwGQN7C2Emk3rIGDXxoZabyuMcxgIKgFATh4hiIsLgW79+5RRsB3obiy + WOgXqkrUvK3oajCO3poAYoWXc8XV16Cts14oMVkTgKlDE3T7li3fICgqTSQC5eqvJMV1eQAPJQmoksBv + QQCmxyXt5RBgy5kq+Fp1A5rBXPZLnYiq3/bTd0KxlFJY3EjsPrBHEbhg91lpa1Um/rzxzptk1GEWBBAl + E4IWBCDGPpmV9kZJD8AjWrTsRqeMQnml4jYroYaabDTfS28WycJ7Hngc5w5VCMDBH8McAkT120dffitO + mC6zaq9mXRLOVJprvf2nXtcm6wPocnNHHU421NDJ06iUC7foCKBdmz7cSQTZ2inHdnOGv1ugWZMoNwmI + yDHfLeRNLf7hMHIX7xXJPbHyWyCLSUAhgsyX9tFxDyYu+RnLvtiLVW+8TQYQRitlgFgt7d1UAjB5ADwM + VMDdBAdFHlxsuXEizjtaXDe2cArqGk4rCsldQtvxq0oKA9buJwKoUkBeAHsEq8rErgC7/RoBKMY/kVDI + l9dUIGLaY3D0TabzIF6WffsYl4rrJcIYTGb3PvIwunqIyHukJNzSNStp1Y2Dh5+M5919dVoAfRIA3U4L + 2aKlS6TsmTp0tbfRRAK93JlZJ9Dbcxrl5fuQPGqMCFvMy+PjhRfgptiO51nMDuyPAORjE1kQxCQJ9uuL + gBKE8KeYe95P379KAFx+e/Hsa8U4pm7dyauuojy88t2P3hPz/vhHMxl/pIC58UvFHzPjt+jg422at997 + X8ahva26Ihrr8V1siG/SfYe5+EuFX/sAQQDnDfPG/U/OFSewXvrJtrRXg44EZDGISgC9vbLSj1fqbuhD + B1O7sEoAalWgqTBI3/nXYoYuZcx3cUMTrnj1EHLY2BcdFEU+AotNyFp0SNQBZMzbi5Ev7kbegl9w64at + +Ln6OO594mmR7LRzlducDm4hFgRgKprSewPqbaoMm/r7eAVE4/OvvhIrrtzC7ERtRxse2FSMgpUUAqyu + RiEZdeGacuHeTyACKFpZLEhAv/pPWsYEUIn8BbvhljpLiLk48SrsE2tzNqB+W5DDmMSRWThQdkik/vh/ + NSdqxHYgt6K7s4inOpCmvxyAj2xN9w+JxQ9btyhiLo1KHqhJI4FenT4jy7Sfrq1G0UWzxHuVTUFxUpHK + 31wwRB0hfjaJwL4L/RI/ZAJY89sTQPzACMA/VpwUi1etVRJDzRYFE+RGkfF89vWn8PCX9dzSC1AJIKoP + ArBu4eWtQJ70e82Nt6Orq1V4GqaV35oA2Ej3Fe9DYEQCBtv5CRJgxd/zhnojt2gG6hrr6cQZiLRXo27V + lwQAQTBtWqFPt6b4ox8m2qKEIx06AlArAlt124zNZlLUEk1oJXJZvvUIxiw6QARQrBn/6MWy0EcFhwaZ + 5AGkP78T6S/+jAtX/4D391Wi5OQJ5E64GMOcmQAC5RQgdwsCEO6+surrCMBBI4BwjQAY9q4huPLam4Qg + a7fwADoFvqk6iQtfPigIoIgIoEghgImryOBXlghPQE8AE4WacDVSb3sLwwIyZL8Hnw9cGOYVY4MATAKh + 7v7hWLF+rXgHUmimG0uWr4CnX4RY9d39os6IAPg58wrGC6FYSeyWBKAb5MoCrd0n0dJ2Etff9jcRJrn5 + Ku3B/0ACIA9gDecAnrPlWgyUBDyCydiD48VxoNJfogKQWC+QYqCfdipqub3mmvldHC8RCfxMMXJQeLyQ + oJbxW6QWCliLf6oNPhHWPfxuURjqEomopCyUVpQqPfTGiTq1kKah9RQmTJ0ujH6IIAB/nG/vK7ycrb/s + MFN+6SvWtxT6rK0/itMEk+KPXvqLPYY60b5bXH6AcFC4/b1Kp5rZfdUVX/EiOhUwCfx8rA4Xr96DrIWm + lV9U+ImZfyXIVcBFPyNf2IW0Z7cjb9FWLP1+P2q7OvDp5i3wDUsQbr+9mAIUZOr+02YAkPFTLC1gMIlJ + ywcooQDnAbwDovDJ558r8u6dgggaurvwwndk8KvJuNdUCteeMWlNmbiOtwplOKCiDIULD8A38xoM85Qj + 4XinQs6FiJavZRUGhAs4egXjtrvvFWXh3b1dwvXfsW8XkkZmw807Ah4U+3so8b+7b6xZt5+zja1Abn56 + 6oVntAau3l7T1p9KAHLlV2Y0EAF00PHpZ5+FO3cG+pgWxd+WAFT58EQDWfAkIQt+Gz1pz8AJIOksCcA6 + B8AsnTt+Ek7X1VBMJPfNLQmAUVF5CImpmcL9HDgBhBuIeERqLb1L161XymlbdSIdFgTQKxVdn37+JXL7 + fXCBvb+Gc+nvp+ctVTyXgRNAW2cdVq5diZHZozEiMxOLli1GE7c9m00iakJTyyk89PiTCIpMJSQKsYpj + J08qJNCqkFertpNhSQDHW1tw3/sHkbNgr9nKLwx/mRz4mUuraA6tpplkSAmPfo/kub/glrd/xrGmJrR3 + t+PuR55SjD5YHNXLAyUAOyMC4MIb52BMnHYJEeAphQT4/3ux73QTrnlrPxFAGSatrcREwuS15ToSKJWe + AJMBEUDm397GEI9E0cPBCk3cKcoj4QQEGURqo8JEUtCHzh2fcFx61dU4fuK4MHx+9fqmBsy++lqK4bnw + h1Z+eoz7QAhAEaThHY7ohOHYvX+nnDHR06yt/noCMLn/kgBYpm3dy+vgxR6Hj8UY8d+MABJsEUCPT2jy + bUwA0+lJ288mCWieEDRNN9GP+HbT9jStPQCu7Lv1b3ehi/fku01fmOr+dyladrX1x1Ew8UIRh6oEoFV4 + nQEBSK8gAoOdQ5FHru2pulNad5pRLqBHKRT69ofN5AJGiNj/Ans/QQB/HeqDMRNnoaG5UVPj6TvjL5N7 + Gz95D44uPvi/8zzxf+d7YaizP1auf1Xr/lO7Ate9/AqGOoUQ0UTgXLtQOnrj8Wde0NX+t5kUbHUNQ/ye + m7vbsGRzFcYs3C228/Ruf45i+LlkQNzok7OsHMlPbUfsY99h4rKt+KHquCDGg2WlSMkYoxT/hCqGH2Lg + ASghANf/u0tYaybI30LWEhDcIkXCbNnq1cIAe0QU3iNGa35afgKzX9uHKWuryPirMWWdOQlMXEWhwSoe + JFKC0LxbcP4wf6HYbO9KIYlbuASRvLNHpCgbZ29A5AQ4rifP4+a77kTNyaPS+Hnbj4juuRfnw9s/Ch7e + 3Pijwpbrr0rMxZqEZjxDcPeD96CD5cDFwNoWUQNi6QGYhQBdJ+m8P42Nn34I/5AEmWj8lQTQR6xvRBTa + aLBsetKGX0sAmnegTfmVcBPbGXESlluAZFTrXl0riybMCEBKWUsCOE2ucB3uuOc+0WhjmwAsSSDCgABM + yUBeHda98aaZ4VkTgFxVTzWewLhJ0/CXIW4aAZxn5y9+mK0/71Q6yPoiATWh2YInn3ocfznPlciEjTsE + fxrig1lXXY/O7hazQaQ33HQL/jokABc4xNDrRdNlX8y49HJaOVp03YIdmoJNt5JLaOltx+s7jmHikv0i + 6ccEYLbyC8MvF8bPSJ+3B/EPf42xL3yJN38uQTt7E3QCP/ncXPp9wuh7UhV+w8whRmqZ4nyxyltsB1oS + AOdgmACcWF2ZjDYueSR27NmlVOD1iDicfZlNpSdx9WslmLKGCaCKUEEoJyIow+TVdFxdgXFPf4mh3om4 + gIiYB6/YORMJuISKxh5+D04KCbAn4OARi5CYdDz94jwi7NPyN++VU4pfef11Ci9psfKOlKu/AQGY1xXo + pebixHmUOGIk9h7aqbj/Sgm7zps1JoBTYmbjD9u/RXhsmnw9ZYCoeS7gtyAAQ0+hwS8sNXuQb1hKOD3p + YSuRzwFt/0khUbMegkDT6i89AKXAwTL+J7cnLCYFO3dvFVt9PT2NZh4A76OqBMBjsN9+7236ccLEyWhp + /Nba/+ZCH0YY6hKBkWMnofr4YaUDTG/A6nZgi+gZYONatnY1LnDUhQEOgbQyB+KBR15Q3PKWPr2AHsUD + ePW1VzGEyON8WtXPHxqEP1/ggfu4EEWX7efE39r168QUo/OGhRGCaaXzxrNz5ykJwTYdAXTqxm114u09 + NZi8eA+y55uy/fqVP29FuZjym7uyEhnk+sc/vhmjn/scq77bheYu6fVs++UHJKSOohU0XCepFWEwU09H + ALrtQCPVJDUn4yAeJ+fxDXP0R9Gki1B97Ajkvx6xs8IDtjdX1eFvH5ThQjL8SeuICNZXEujy+gpMJUKI + m/oA/nSeG32HvhhsJycwDSMS4O+Mx5U7uISJcm4nOs8Kps3Gp998QSSraim0CS/n/Y8+RFRcGly9IiyM + XxKArPu3rDVRSYCTjbHCM1y4bJEQE+3u0RWW9Zq2g7WtwB4lDFCGtPAo9/3Fu5CQliXajkXykbcdz5oA + Egc2LzBE4LB/eGr4oIDI4W70pHsGWtNv1vGnlxPXPU6VNhYIMPX+m037oZgnv2gqTnPWlEOAngYdAei8 + AB5sSQRQWV1MMXOeqLkX8Z3h8I/IARIA6/vHiBPzSTKqbo0Ami0EO01VgvtKDyAgOoWMkT0AWpntA8mI + gxCTmIdD5RVK4U5fBCBxgj7vFdfcJMiM5x1eeOlslFWrQhkqAbSiqeUknnj2WUTGj0BwZDxuuv12HDt5 + xKJVuEMrX20nd/a93ScxdfE+ZL14kOL6/YqcVwlGk7ucQyt/rrLy566qQObSMsQ/+QNGPv4xFny+DfUd + DYLwTjUcxWVXXQk3b35/kWYel9lYbSUEsLchkabCdL3qkUnSkLsItGI7B+KyK69DTW2tRgFy8mMPKhtb + se7no7jhrWJcvL5EeAETXq5G0byfMcwnDf/3Vzv8dbAHziMv4Hzld+GpTI5ecQii32X8nOux+M03cOx0 + ja6suktsPb774Qf0240Qxu9mZvgSbJCWeSZ1kVHzChwezZg9W+QyhGx9T5soLhO7S7rFTC0I6lVGtcnz + Wia4Kw+XID0zX0y+1nYdzpAATANArRN+fcwU3BMYleY2KCpp9Ln0pJ///QlA1wgUIOe33XH3g8Kl7elu + tCIAOddO1bWvJfY+jQcfe0LsRXPuwMmrfwIw3go0kcAwiheDotPw7datSijQrGzFtVr02Lfg6KkjSMzI + JQLwFcZ/gT3PAAwWxzvveZTiv1azYiLbJNCCuqaT+H7rZvxAK21d8wmLPX81D9BMn7kZpZUlFI/vQ2tn + rdj3N4mCdIgTmZtX6jo6serHY5iwaD8Zfwky55cgi4t+lpSS8ZcJ48/hVX9VJcasrkLW8nIkPL0TaU98 + ghc3bUZtWy3n4dFBv8FLi+fDJyhCyGG76OS0hBaDsuqrxzMlADUB66AbJOooPIcQXHXj7Thy4piox1NJ + gL2BdjKsktoGvLP7KJ78vBS3vF2MWY+/i/jUfDLgLMQmjUH88EKk5FyIvAuvxpV3P465r72Lz/fsxpGm + WkElqs4fG39zaxOWrFxD3mcqfT5j49cTgLNBopmPnPNIycjC7gM7ZEemMmQWoolNznDQ1/9bVgWKmY10 + PHq8Epm5hWJbWyMA3U4A1wV4/KYEoA4bTfw8Ojn73EEXXXrdOXTl6jNV9um36y9Quv56FnNX6pu5zdGL + woOXNyiDMnoaTATQo+jY9dabEQAnBX/a+RP9cMNFA4daYmrb+AcWCrAOQO6EaSg7XClW8R4DvT5+j1t3 + bUcQnTQX2PHqz1Lf5JYzARA86CR5480PlRJXy10F01hxWfAjK/R6FX180zakgU5gr4mAupXH9SgEINuA + e1Bc24qHPyLjnr9P6PqNEmKeRABk/Nm0yo8ml5+NP4dW/Rwy/uwVlUh8didGPP4FFn/5Mxo6G5WS4Ua8 + 9+FbiIpNpJMxTAhpunhIOIkmoFDZDKQarkj6sQBIqE31JGMiCBPj1kSVoJ4EXAIxZfpM7Ny324wAJDro + /zvpvbahqvY0DlRVYdehA9i2fw++370L3+7Zhc2H9mNHdQWq60+jladIafmRDm3V371vD6654XZ4cz6K + zh03g5Jyoz4CKw1B+uyB4bF4f+OHcnqT4vr//+39B5hUZdI+Ds+7v/3v9b0blDQ555wzDDlPHnIGEQWz + izkBKi4qSM5hyJgDKmZBVBQUJOec8+Sc7q+qnnNOn+7pGdB1992gXnX1TM8w3X3OU3fluxrf+7Kmqdq0 + /o0TZ4+hY/cs2YLlHRQvwnMvniRe8n0CfLgbsNkQILkZxbf/MwoBVg67/b7fO/B/9MSkfwQA6B6AVVkw + WFEeJbTrjj3796gDbgIAy0476802/D0TgzwxcbI0pRhZXt/mAUDP/DedEIyS2f4x9z2CK0VFsiK83oai + i93H5etelddp5RJOEkHWP1xbBEqHnUKBxISe2Lptp5bQsgaAegMAKmyaeWy7/uyThdZrPPUNRlMQqWtt + DT49fAV3riPFZ/5+ive7kNXvsog8gCXH0Z0sf8+lJwkATqEnKX/PlafQfeVppM7bj94zNuK1Hw6ivK7c + aCr6fOMnaNe+E7x8I0ghVOKvMQBEmBp9+OswOHqGN0uQ2hwIuEjpTuUDXPjnbsFo26EHXn3jTZRWlGrX + sk6rD6hGqJp68owoZKysLUJ59XWU15DUFZKnUKolQms08FBJPv53J06fxLSZ85DUrifcfaJF+T184wzy + UHc7TUO2+STzxmMO3+bMm4vaWlb+Sm3EubLJrlJ7FHC6N/jhp+9LElApeqII95h4BicIEBjP/+oA0HaS + g/6fT1jqSG+tF+Dm+v1vDABK2ZNMW1CTrXafDR4+GsXFV2WNtRUANBRZW39ts42AAlmpwyeOoEP3DJnV + d9FLS76W7b9mUV2BjUWUX/b8xRogwAtAn3r+JZRWlRkHrt5wx6sxe+EyslrxaO0WJcLLQVtqewDbuNKh + p1CgU9c+ZGWOqP4CzbKz1a7RhnLqDCCo1KRc6wC0VfhKo9OvwaAA45aZWpwqq8R7B6/h8Q9PIH3pflL8 + w+hEcX7HJaT8iy3K32OZUv4ey5Xid1nJ239347bVW7H5+BnmF9b2Clbg488+RFtSfk+KaT28oyT5J5l/ + 70il/F56iS9CLL4Ik6qSgstmZFsWJZ0j0QYI9IqAVAW8ojTlt3gBkhNwD4VPQAxuu+MefL5po5oQ1T6/ + UuhKlXDjFuqGMhNY63mRWvEfmPpt247tmDD5JaR2zJSwRXWS6hWkeDVW3qifxNqY6OvD9TDI0z8KkyZP + Rll5ocFa1VQZuTHvY7mJALYKh08exeCRoxEczlN/FgBgkXkEec4WAMwKrcQvVEnTCcFGwFDvH952pAEA + vhFt25OVL/l7+QCtAcC6A5C/58km9TtJmDxlijT/sJKr7KgZAHTLX2S15baWKwN0Md/e8AF8whIszL4+ + UTYMv7rENuL8F/GONfb8qVVfMVJH5rLX7AVLybrUaCCg9u5xDPna2+/SzU+g3+NGlmi0dlWLQAUEGABE + wpDVZwQOHjmugUCZRsnFUimgom+dqTO19tbbkIHq7b/sxpZQDHy8vBofnyzCy9+cw5DXjpOVP45OJJ3J + xe+85LhIl6VKzMrfk2L+His45j+O7PwdmLpxD04XlRgxcVVtmTSixCekwsMrlJQ/Eu6kiG7aYk/bmX9W + erb4LFxuY3E0W33PcBNBqpKmAMDZ25JX0EU4BFn4vpI34BschYy8/nhh2gx88c1XOHPxNHkGvOaswgBJ + llo6R7yJ59ylk/j6h28xc8Fi9B96F0Ii2wuNHO9xtCKS9Y0zavjuMqjUdCipk4awh+IfHIupM6YTuBSq + 12+o/BnKX2HK71ShoPgaxj/5FMJj2iEoNMmi6E2JFQAkmSx7sikH0CjR11QeoCQgsl17AwACotr7k/Kf + 8vkVAcAe848OAP70AfJXLJNkSV29tQdQb2RKi7REYIlJiiVZVV5bjMmvTCfFD6ODFUZKHKE1ouiNKVGm + RiB7INAYAGSoxSOMDl0C5i9ZReFGpaGorIynzp1Cdv8hcKVDzG5kRFwnKXm1cA41AIDJRVl6ZQ7Fjz/8 + JIrGRa2yumqK1Uvx04VSnCyuRkENwVgDE2Or2FYX/r+8oQYXqqqx63o53jtSgGe+OY+Bb51Ct/wT6ECK + 3WHZWXTKP0vKforkpKH4XZedQDeSHhTz9ySr33P5GXRbfhqZKw7iyY/34vszF1DBGWrxKGpwvegyXpr6 + MkLCyBX2DFfKT+ImVl95ALasP06i7No11wCgjUdjxmTFpBRmAAB7AuwtSImQFZIUjxPHwqPPHpxRXozR + OB+jZSWXG3sF9Ddc6L4EhsWjXeee6D9sFO596CE8OWkSJrwwGU9Mmoh7Hn4Eg0bdjg49MhEU1U4j+oix + WHwfWyr5ONP+QEtJWdx+zZt08VHkofx+ONSJjE3F8tWrUFVTpil/4xbu5gHAUuWpqa3E9NlzER2fhmBS + 0oCQGwAA/1wa7dSsjVn5GwNAyk2UA1NOBUd38Bflp9PgEJ3S4xZSzG9+DeVX5J9JzQ41+BMQcA90XV2Z + lvgrtukDaIbnXsZfS4XB58EnJqANWS5HzzChpDKm0KwAoDEIqBDAAgB6l6BYJ/cI+ATG48Vps8j9LNRc + SpVxP3TyMBYTcOWvzseWH7/BhOdfkO6xFo5BBABch46QLbPOBALt0nphw8efkbWqlzx0MSn99yeuY9ZH + R/Hk64cx4YOTePmLc5j97QXM3nIB07ZcxKRN5/DgR6cx9O2TSF9zFJ2XH0dHUuQuKy6QnCc5h66k/CLL + TqMrgUBXAoVu+UrY3e9Bv9+V/l32qsN49MMj+PzoZRTV6GzCKrn20+4dGDH6dnj6hMKdrhsrGovtei+D + 7Vez+I5iyRUA8NeO7raKr4tOmxZmfM9MSrxtyTOmFyK7jUR8zxHSQyKegGmduHlij1lz3bURcA+/GCnZ + cYjiSe+VxYP7FHTA8lb/1sMvUfj23fUGniYSfU3G/L76+yHl58YlAp+OXXvhi01faF5blRUH480BQKVR + haitr8G6195AYnJnBFGsH0jK7Uf64duE8vvSz83CAOBjKL6Sxpb/hmXAb2JSu9/Cus8A8D/PTZnxO/rB + sl9H+e2z/qgwIFl+h0uHSe26Y8my5RRLFaj594YbAwB7AfWacAb9SsFV3PXXx+nwhQgfPzeAmAdQrJN/ + sTYAEGsDAKpD0MkjSgg+3UgBxtx1Pw4cPSiK0yBWuloRivKcAq6jvOoq3njjDSSldkXLNn5o4xKiGlE8 + lcsYEZOGmXMXkrtXDP2/C8WVWPf9Cdy5fCu6v7wFCX/bhugpexHz8mHETD+BhLlnkbLkAtovv4BOpPBd + Vp5Dt5UX0I0AoCsDwHJ6TgCAFH3pabL6JPmnRHrlH8OQtYcx6Ytj+PzkVVyrUkkxXfkvX76E2fMWIj65 + I1y5rZqrKZ46v39EI35/ZstV0hgA7Lr5dgCgtRt5SO7BiOmYga53PotOD85Hl/GL0WXMi7LDzkXmCyyb + hMwAYACBNgLuoZXozE07HiJm6i5rAND3BDYFALYuvw5GHPZ4+kVh9B3jcODQPslBcKmvrsHW9b8xAOiU + 72fOnsYLU15GTFxbUvo4kniSBAUAQTcPAL5/JwD4hacse+7F6b9j3Xeor6//H1UJSB5vO9arxFrBvZv4 + WdMAEC9i6wkwFVJQRAoeffI5XLx0QZtsu7EHYL1koRwXCy7hr08/QzcszFj0Yc44m8FAHxW2PyAUbVWr + lgNPhzetczrWvv46rhVd1WL2ElKpIslH1Avdd4VUM0bfeY9szWEQ4JZUF09yaT1jZLpsxG134sft2wng + Goxml4LKKmw/fQULNh/BuLX7kDFvHzrNPIIO806hw+Jz6LT0PHkApPAcw688S7H8OXTPPy8A0Cn/DP38 + NAlZ/WVHMGDtETz20Um8uusSDl8rpZCjViul1WiMwgV47/0PkJXTn6w+Kbe41ZGqY469JsnsmxXeWtpY + LUHRadDDmyBOVe5/KzfukwhCaHxbPDnlBWzacxB3LtqMHs99iN7Pvote982TTlEnz2CDZswCADGNhr7s + icHUqw3reARYL+2wVXrLc6z8MUIJ5kLi7KuHPJEiTmRQEggkFy5ajCJOVGuJx3qT2Cv5WfM9lGgM0CU4 + ceog5s4n4OueCW//KHgFRMM7MM4QHwIDn+B4SwIwRFUC+NHK8ocm2Q0Bmhr4aZwPIMDgkCM8dTzrvOi+ + oAD9R6jQk5S4ojkAsP2ZJal3YwCw9gi43VE1PXjTzRo+6m7sO7jfULCbBQB95XJB2XVMnjGTDkE0bnUO + 1uLOCAtLjY1HYG+1tyGeappN/i3HuHSQvfwjkNd/IJYsX4KDR3eivPqq0TAErU+grKoAq199FdFx7eHo + GiaehLOnanvlvXOxFO/NmDGDrPB5jX7KBAblVdh1thhv77yImV+ewmPvH8fYN49j+OvHMGDdMfRbdRR9 + WVYewaB1hzH6zcN4+KPjmLXlLD48dFmm6Aprq6WfHkZTbR0uXD6LN999A4OGj6A4M04Aij0bV0+l/Hrf + vHMTAOCoK7XtToRmAIAp01tQOOQXmYxxFJtv3bWdIKgSuy5cw6DZXyHjxS+RM2UDut8zQ0q4PODlxCGc + gIC+SMSy1deK/s2OZ/DLAEApvy4uvtpUI33mYHrf9z/0GHbu2Wkoeq2091aa2nwrbgoAzl08hvkL56JL + t97wCYgSj8IrgBt+LE0/zDvgzYNIQXFGye/XAIDGZUADACqCItr21MJ/CwAERaUF+DRKBDZWcH2HuU78 + af5ehK07s5sEaoMNARS/BWidVZq75qG5bp4B2tgloXGvrH74duu3WtOLcvPrjIYJE+VWg62ovXmlNcVY + /dabiErtjD87+ZMFCpGknpMOBCYQsFrt7RllDQA6CGjC+945pnd0DYE7HdLUtC6454H7sGLNUnz/w2Yc + PbEfJ84cxp4D27F4eT7ik7qRFxAhwynsMuu5CVfeEkxgkpXZB2vXrsG5c2dQX18H2/9q6+noVNfgUnk1 + ThZV4uDVcuy5WIrdF0uw73IpjhWV0s/o89bVSmFMV3dVJqPA5Po1fP3N13h28vPo1ossDoGiM3dPColH + uHL1NXCzlnBReEex+HoJz7wJSVf8MJPo9OghaO0ahFaugQhNao/7ySP7esc2lNeUGvmTD3adRf+ZW5Ez + 7WvkvvQJOo6aZIQXDD78vlztAIC9kMBC66WFB9q4r7tZ7HoNFjIZN5FYtRiU3kdYTFvcM/4RbP5uMyqq + iiUBrOZAKqTkaMUdaUUkY0v0Uo5rBWex5tUVyMkdAH9SeG96LR/hGIhtBgBipe7vxfV/EwAYSi/cgMla + FSClCbHT92+UCFN0ADgVGt0+wAoAOBkQ37b3n0nJv2huGlBXeru1fY3BlGmMvQkA9FlqNVUVK0kcncVH + p/MyYjpGcrqhaR1644133kYFkyrKVhslFtqrskbUV4ZIvb0U2/b/gEFjxpDiBqKVi78cajncmifQuG3V + DgAYQBAtG4XEkvNWIp4wo+fd6MD6+EciIioRyW07o237boiMS4W7T5gkxhzdIsUL4Ll3nnpz5pCAcwOu + pFiOwXAj5UlL64EHxj9GB+VV2VVwraiAlL8xINj/r15iyppaOmzXL2H3vp1449038dSzE9Arow8Cgzl5 + FSQJLHH1vVTXngIja8V31MSi0GHN7EG0xP6O2mq0lgS0LdyDEJvWFZNenoZdh/eior7UmKPgPgeuPsz+ + 7BAGzNmOfjO/R99pXyJlwMNwIkAU5fdUy0ZcjV2CZvLOGDvKbwEH3aVnq24Ws+J7yBLPONk8LclEjSCU + 19BHJ3XAg08+je93/KCRrlQoPkWhVavQXH8T23NDmdWCV0XeoqjrqmsK8cXGTyjkG42wCFI28kR8ydvl + eX8WBgDvZgDAU+8ADEmwAwBNE4M2KaH22oSTv0hM6/Vn1nkzAGh5gNRpzQNAionkI8ku86/uAXgFmDwA + o7c6xkp0AOC985LUIXcsPDYFL82YjuvFVzTSTBPZpg3nvZUXwIeNy4YUn18qOofpi+YiLCEFLZy9SBED + 1aYfu33rFoVvrYm1J6CWRzprs+ZuZD3dWRgMeKzYUx+DjZJeAlEoAQFuECIQYKXnbkE3TVwjpJOwlXOY + tBUzzVZwZBK6k2dw94OPYMbc+XjrvfX4YvNX2PrjD/hp9y7s2rubHn+SfXWffP4RVq9bhb9NnYLbx92B + rr16S1uqizfvKwgQa+woJbcwK6UXF99TNfA4Wim+rSsfZqP4tvsQtcQfKb6LXwTSemdj8uwZ2EOeUGWD + Iimt5XKttHOXikd3uqgYD7y2EwMWEgDMJgCY+iViM++SHIuh/F4a1bh3lDFxaHcK0QYcLOSwtgAQqym+ + Cglkyo4BgWJ9buZJ7dQLz0yegh17d8quSGgbgaS8V2+hV9ONi3XuqcyI7xugytN79v+ICZMmIim1EwJC + E+BPrrwfWXMBABHlAXgL1ZiFbswrSJPgOA0AdA+AQ2xL+c8MAE2BgF0WbysAkATgNN36NwIAv/DUwfSH + apv7gzoINCfWOQCmTIoVsdwcGwAQiZH1WHxz/EPice8Dj+DI0SNa40zjhReNcwJq+67iEShAdX0Bvtv1 + PQaPHk1WPIDi0gC0tmlHNdZ+awrfylOJ2Qvgsp4Rz3tES8LMEO5o4xyC/JsYBSJuESJtyAtobTQIRQi5 + B7cRqxbiCLSURiL6fdco1VrsFIaWBAitnIOkG47XUnkHxdDNi4N/aDz8QuLFnXfzCpUJOqYob+0SLDkK + R3ctSy/dd+rzcIOOk9arr7v8js207Nqz8obbr4UFTLzBy1TdyILlDhuJNevfwqkrJ+kOcWKUm52KZOFF + Dd0H2bykLV359NBFDMvfgf6Lt6PvnK3Ie/FzRHYdpUITMwBw+VGrBuiegKtRImwsKkcQY1fY0ntqm315 + qMmD4u/w6LboO2gE5i9bgsMnj6CmXmXnZRdFvc0Zs1rkUWJD8lkqnI4NZGzOnD2C2fPnoGOXnggixQ8K + V2Vuf/KQ/UkP/ALjJePvy4m+QD3Wj2/U968sf6ImyZaKWTNVt5sCAOvfqfWPaDu4SQAIiEyLoF+68HMB + wDYZaA0C8VYg4B4Qa6P4JgnguWwl3v7cUJOLjz77BBW1pUbnlYrFLK6YPRZefYCI0flqyUXMW7kMcR06 + 0+ENlOy03s2mFOHmAYCFrbxyn9na88x5pOY5RJOCRElTUCtd4Z1DZUT1VhkgIneZrL5MENLPbiWlb0Eg + 0NKFgEAkQpszoPflzI/qd/mxlWuYtBy31lqPW7lHGk1HjjaxvA4Abcyrukxde43d+8b7Dy1NPJaSH+9N + 9KTD23f47Xjr4w24WnpF62AsE0uvOjWLNQAoFeEwrqS6DC9/egQDl+xEv0U7kDt3K7Kf/xjh7YdKqbQR + AHhHGpZeDR1F2EhkkwBgPlfu8rNohMW2RWafAXj+5ZfxzbYtuEaepd5+XafthlBSbgcArCf4GhpKjCk/ + Hk9ftHQhemf1QXB4EgLJSgfxY1iCNPaw+JOXbAGA2EbZfr3ll11+s7tvm3v7OSBwA7kQGNU+wi4AcEwQ + k9LjFvqlTfYBINkqE2lPfE204I1JQFXmn8WjCSAQ1PZTpTMGAUbtCLqBk154HifPndDILyobxf5NUXHr + yF1DX+8+thcPPfscAqNTSDH9yXKGqNZVT4vS2AMAAwh0K0rKJ8Irxd1VO3AredRag0W5Q8mti8TocXfi + r48/TgdwqIDinxxD8Jc2BAROEbjVmQBAhH6fhKcLWzqHGtLChbPpIQJYrd3CROS1WJpUYvvbjc09+s0p + vuEBcAXAQ3kyDD7+ESkYftd9WP/5Jygouaa5y+XaerXGlRnO2wgQ8NKT84UYu3ofBizejb4LCQDmfI/0 + J99AUGKOHeW2iBN5Ary4oynltwIASfxp3Py+rGjx6NgzGxNf/Bs2fbcJlwrOC0+imn1QXI/q/NgYFZTa + ofIuNujp+SydvXAU8xbMRY/eudLCG0DGL5BcawaAgNBEcf/VYyJ5AgkUBsSL+IriNy716Qzakl9r5AEk + G73/9qtxzbb72uMK3BTbttctevxvCwBaGND2pV8KALrYAwDPwHgj7vHQREqBASbUlm4vAgCe02aWFuZo + o+e4dpqe21cSXUWlV1VuAObMbFnz/QIN6gZW1hVh847vMfzu+4UgsgW50K3dw7V2VrLinloewD3SWjxM + M+6m53WFNxTTLUKs+1+cAnDP+PtRXHke1SggpTmPLRS/P/LsC4hu20NGiP/YKhB/aqUA4VYBAR4tDhVh + ALiV3psCgLDGAMAW2W6yrnkgsP+71srPvRT8upwwTezYG4899zd8/cNWlFYWaeFYpUF7Zfe6i/uvVpIX + U2y94PvzGLT0AFn/3cibtwPZ079Fl3Fz4RPRUau7N1Z+Z+8Ig2j0RtafjYYsHqEQMjKpA4bfcQ9WvP4a + jpJrXlVfpHkoZVo+wl4yucLKkJgBAFotnxvQTp89jAVL5pPFz0MghWP+BDLcxSfKTxLAYGBSfF1E+emR + xdzu62UDAGpITnsuOMkEAEnNAEDSzwIA/4h2L5mtvxUANDQ0CABQjJDjG5ZSZR8Abk7kA3DnX6BFPDUQ + MCRA/zpOEoWeukfAyRtfDQiEpy1GvAFPf57BTsTYe+/Hdz98J6u9rbwBlDXLzd+gIThP5xWUX8Pa9e+g + W25/UnpSONcgzRIqb8BQcI8IQxgERNwtyt5SU3gLCESKcrv6huHzrz5XFrGuUOYb+DDV1Bbj4MmDWPra + Wox75Em07z0QXqGppOzhCgxaB+MWx2DpZWjhwrRjwRQGKBAQ19+k/E2JNQjoYh8MWrHC8+fmbL5LsMT3 + PhFJ6DtiDJatXoMTZ45LJlzYjmy9LoP1tsRqC5J4XA1qcOtIYREeeOswWf9D6LtgF7Lm/oCeE99DVK+x + cKX7zt1/TXkAzprYV361cJR7/AMjU5HefwhenDUTW3d8h6Kyy8aOBWkbb9C8lCabzPRtVHr9vthQ/HI6 + J9t+2IJnn5+Cbj2zSJlV4w4n9/xJUQNYRPEVACilp7hfE18WTgSap/pk4WeSCQA0EAhJsgIAc2ndR1vM + 6xvSGARuTP5hIgGNTMthHWddb9IDCI5J86E/evRGpKCqJyDFbqLCSysFmoVBQPcGjBJhQLzhDagFDJb2 + TlF+vxhLTiAwGj6BMRJLMUX4S9NfwdmLJ7UtLBU3AADLHIF08YkU49TVk3hl0XzEpHYiJQwQRRNvwAQA + LUmBWFqZrL4tALQQAFBJvVvJerfr0hvnL51DbS0dwFo16Vhfx1KkyCHpfbB1ulh0Ftv2/YTlr7+BBx57 + Bp1794UHWYxbyIP4cys/xT7EYODK5TYKEQgEWkpr7c0CgBbDNxES8N+6lay9I4Vc7brn4um/vYzNPzJL + UYHW4FTRROLVxHDToHbeqdVXqneDE4Ll9Pvv7ruAEcsPYODiA+izcDd6vbwRsf2eoEOeZpCNNhcG2FN+ + Htrisl98x164/6kJ+OirjbhYoPYrCMFKfYkVJ7+td2Ivuaf4GpXi8xDayTOHsebV1bhtzDhEx3eQeQ8u + 4/lxTB+srLooe7AKAVhY8cXii7XXmncatfaqbb8+YvETjXJfIxEAsOTbfDTl9w35ZTkADQCOhsR29GnS + A9ClV+7gPxAAvHYjAGicBEy2ThLaeADKC7A0CAkAaAlCTxsA8LTq+da8gAAFAt4EAlxO8Q+OQU7fQUIW + qpheq41NOXXNAAArPpcKZU8bOGtdhJ2HduFuitX5htzqFCRWXiy9h1L+lmwt3WzFFgAiBAD+TBb83vGP + y9RYLSl/XW2hKL4aeS4Sj6C2jslOuVpxXZSHM8o19NyFgjMSosxcshgjxtyH+HY9JRb+MwOCY6CAS0sB + g1Bx1Vu5q69b8iMpP0trDQTaGADAicAImb938lK5DAaKNqRUoUmdMfKe8Xh9w4c4c+U8E3CpzcmSwS/V + XGe91FpqzGHUa2uuBMysuBtUApDHn89VVuCZj45hYP5B9F+yF1kzvkV0/yfgTsrPrbcuVu23TSu/q96e + S5/Dl9zr7IEjMXtZPvYeP0ghXZlGjaZIV9X7tJ4pscTzqlxnUf4i49qzFJZcwNdbNuGZZ59Dx26Zoujs + jXrTOeXhMB/p209UvfvBqszHAOBnSKIov19I82O93qzcsvcvwabsl2iVA7A1sL8CALzWO2/4H2z1vREA + aP0A4+iPN9wsAEjNMjRR6pbmUqB1DsDSHGQvL2APAKwrBDEinDNgQPBmUKADFByWiNvvuAsbN25ERUWJ + HGB9K669UMDgGzBYh5T1Kqm6ig+/+gyZ/QeTEgWRYgVbAMCzsdvNFllX/hamEIC9iPy1a4Vau7a2wLQN + xlpqNTE/x4yxDVq2uaqyECfPn8CGjV9gwktT0T1vIF3fBPIIgsQz4A1FLSVPQOKmvAQW8WLcdQCI0Fqb + o8Sz4bHnkPhO6HfbXZi3YjV2HzmA8qoiY8OxuiYlIrXao5mPQY1uF1qJmbWJ/001s/WQIn51qgAj1hxC + n/wjFPtvR/ygCbK8k8t8zr6RpgnApoFAphC9whGe2A7jxj8ia9uvllzR2JFsw7+SJvI/jdd089YlkPJX + Vl/HwcP7sHjpMvQfMhLh0Wl0ttRWYG9Wek30kp2vNrhjFotyJ2hJvnib5yzibSi9rViDgHdoYw7An5v1 + t1kQ0kDx/zhb698kAFCswFThF34WAGhivxdAcZ3fCABuCAI2PQOSGxDuujCEUuw69u4HsGXrd6isLdEI + I0xru21IGo1DrdGPM/swK9/5qyfw/Csvwy8iEX/hOJyV3eMmAYAUzyc0Adt2bpcMOW+AaQoAmpN6kULt + oKr58+slV/Hdzh8xfeF8DLptLCISOtDrBeJPTj64xSVQwKCVq6oYSKcei9b34E9xYnq/wXh5wUIKOfag + sKJAGnTMDVb2lL2xFDUCAAME6JFJRSvqSnG9qgpzvj6DgcsOI2/hPiSMegnOfonSQemkx/Y+kXZr+y5C + MR4OV79wpHTuiklTX8T2/TtQxqGUwaJUZt0W3uzAmAYAYu1VLuha4Sl89sUHuP+v45Gc2h0+PE/gw9ae + w9UEQ+FtAYC/tgUBa2WPkzq/WPqgxmebOf5+KQD8At5/s1wIiu4QdVMAwCWCpI6Zf6Q/9GFzYYC9XgDv + UEsms5EHEJRgxPvWg0KWEODmAcACBB5+qmLgQQfKzTMU0bHt8NTEZ3GAkL1O2Hxsd+mVNUpaWbyCQtlB + UEkK+PHXn6NbXj/JDbBytXZTM+3scuvW1iys/AwEaV0zcOHSKbUG+hcCgO4hMH98Pb0vsWLiqpaJu1pe + XYyjp47izQ/ewx1/fUgNQVGIwItLdRBQEorR9zyEjd9tNkphChjLLe69adS6sbW3r/DWoijbaijM4SpL + OQHf/utlePC9Yxiw5BCSb5+JNv4pMvTjrI8cy3ahSIMDgMk3mISD24vdAyPRtW8e5ixfgKOn9xM4q9Fv + 65Xr9qS4kRfQYMT29L6qLuHAoR2Yv2gOcvoMEBouVnpPv3jDMJmVvynxCdIsepAKC+z9jkHqadB8Wypf + HkFaBaxZILDXBJRsk/RravS3rcb7n6I9CgB8mNwx64/m8l9zAKCXAx/8eQCQ8osBwEgCBjRB0ayVe+yJ + u/F1FDx8FasN01q17dAL02bMwckzp4ylmorjr1zb1FNqsR5WFORKanAdh8/tw90PPwxnTzXaKgDg2hQA + MEtwCEbcPg6VlVfFiv89AGCEBBJrm13YAs2aVeNawWVMmTaNrlEEWugA4BJiAAC/59z+I3Hw+FFxm2sk + Di6z0/DSFAAU3lhI6WtJqhkAyPMqqanE+iNXMGr1XrS7e74oP3cuOuqtyV764A9vHVItvVzu8wqOQb+R + I/DaB2/gfMFpgzVX9RqU2fR3NCelBi13celF7Ni1BQuXLsCYcfciuV03yR95+nJbbrwaRBMvVAlP490I + AG4kupVnRbcLAIHNAYDWDWinC7DxxF/TtF8WAEjRy38P2rP+dgFALwcGRqbF0B+7eDNVAD0J6K2XAO3s + AbQ/GhxvEZkatMwNePhbOruaave0DBfFSteXO4cDLNwvTnEvM8Z06ZmD5avW4tr1a9rEXKWx9kumvPQW + YlsW4gbmlC/AteLzeHHWDHiFxku5UObcNbEFgFsoHn9y4gRSiuuor73+swCgKQWzBgCtnEmK+wXFw+nZ + /dDGNQCtnLiFOET6B/SuQdU5SN87B6J35gDs2PmTtumo1OJCmysnWnLPWoqsVlo1Eo3PsU4DgHJy/89V + VmHad6fR5cEFcAxsJ++BCVZ48s8aADTarYBI9OjbD+vee5Xi+7OGpa+VtuIStTeywZy5tydFAop8baop + VNh/aBcWLFqEYSNuR1xiB/gEaPMm+hCOWHzrFeBWvfmBNxL+twkGcHCHpGeQpcTtEaSfae17K0nQeP81 + aZQX0AeB9FJgiqUMaBUO2AMA82Rgsg4AF4Oi28fYlv+a9QDYVUimMIBe+P2ba0m05ghgEGis/M2LvoHV + mBkw9XPfCAAaT4lxSMD0UdEyuONLwDJw8O348KNPUVauSDF1Zt56jYhE5xy08BEqQOCQoKz6CvJfW4OQ + 6LaqOcfIAVgDQAs67C/PmArUX0PDzwCA5iysGQDYeymvKMKs2fMQGM4Vi0CjfbilJpYyZbglFHAMQveu + 2dizd7faTaBn820SpLaKZQCPnVBA390owFlXLABQUVuGXcWVuHfJF3AP7ybdlvpcgRUAeCuG4aik9pgy + aypOXTlF/ky5VGRq7ZDBNvX+LJN4xSgvv4Cvv/kMjzzxFNq27wU/duf9KR4PsMTyN1bsm5V4Uz5Lt+rx + ds+zPWYsa0mw4wWYB4IsZcAbE3+mNJ7/D099P7Vztl33vzkAMFcD6m8eACyNQL8cACzjnR5+N/YA7I+J + agBgCPPdhUqf9h13348t235AJfO5M99fQ5WVK2x72FSSsIDc2wK89s5bCIltJ5l3swfQUgMAfnx64jOo + I8CobyLT/3MBoF4HAHovxaVXMWHSC0Ll1YobkJia3DXc2FGgmpKsAaANjySTV+DsGIy83KE4RSGRLBmp + /xUAgHfccTmTlL+qrhBFdRX48OBZpOTcofb0uYUaU4ZOkgMIVxTjPuHIHjQE32zbLKDLIRlz/dfUl9hl + g7aO83XFL5F8yMXLx/HmW+swevQYREQli9foHUhnkRN0pkz+rw0A+iJPPq9qxiXOUHjLWb4JAAj+OQCQ + 8nMBoJ4AYFxT7v8NASAwKi2IXvzkzfMCNjcLcLMAYNnG6iGML3E27n7TDDF2+eSkY0xx3AuBJClPdEJn + PDtlGo6fOanlByqsO8Ngvaa8ruE6qhuukYt7BWvefh2BUYnSqccJN0vSjQ68ayTate2OLV9/SYpdIq4x + rzevqbcGgpuKrU0AwP0KrGCTX5wi8bRMD3LXoakPwQAAzSPgUEDcb270IXEhcXamEOXJKaio0hOAZXYS + aCV2AKBQNtnW1xc08gC4f6GapIJA4kRpCcY+O1tYlyzcgCEaACgOAY6TH39uMs5cPWN9re1uhCoyKXyR + VhVRyn/q7BEsWLIAPTNyZI+AhHx+asOuaj6L/1kAIH0nTfzMiNsD4o0GNtuzarAOmX7WHADo7b68Ju9m + AMA+G3BTnICGnAyKTgv6RQDA0nfInb+nP5r/rw4A5qWV9kWNlTIQqNAgCl4+EeiRmYO316+XfXFqxbbW + G24DAtIwBA0Eaq9h+dpV0pHYyibrzuQfbG27dM/C3n17JIH19wFAgYAPH/xvtn6NgNBYSfS15ElCsfrW + pUhZVaYNE7VyCZWEYBuXYAEAZwIOJ3qvAcGp+OTzr7TuydJfDAC12ueqJs+I17cX1RRj7usb4BGSZk0O + 6hEsFQBOoIbHp2LZ2jUorSnTFoFbN+zYi+31r9na1xLIHDqyB9NmzECnbtkSw7txFchECuql0YJ5B8Td + HAAExFm6T/01hqqbBAB768R0ENAfm7L+luU5iU0kAxM0AEgxAMAWBG4EAH7hyfn9ht7x++Z0vEkA0JOB + fuFtsxVXoNnNv/lhIHOsYz8JqOKnxgAQ24jsQQcAWQfmG2usamJqaaYCVxJtbHSxzJNHG19zlYBDAi9f + evSNQGhkMsY/8hSOHD2q7dursGku0UIBIQK9LuEAr6Sas2A+AUmEJN+Y+EPIP9jicva9TQDGjhuPotIC + bcV5gQUI6gvsKrq1gunfk9DrlVVew+3j7setrf0VANBrtnBWg0M8efgXeu4W9yi09EtAG5IWLrxWnDwU + pwC0cQ5SbMU84MMhgXMYBg4eh+tFV7T5iGKb6cnimwKAGgKy6rrrqKoplOTfp9t2IqZdrgCho4kjkK1+ + a7dgpHbuic83b9R4H8tN3ZqNG3Usyl8gFr+KQGbHrm14etKzSEnrIau93H3jTPRyejVISyD7WZTZ+wbu + vMygmAyMpzQC6ZUBawBQE60Wg9UcANjzAOxR5VvpR5AqE5oTgt46H6DGD2ifFTjZnndQERCemt1U8u+m + PAD+x2HxnR0JAL6/2WlAb5syoDUANF0GtA8AWpyvM71oCT9Xm71t1tuAok1bXWwAQAsBmBjTnTwADwGB + KFnumZ4xGBs++ZwOdYWl9bWRgmirnckiF1dcxTPPPUeKFYTWpIBtXEIVDRgLKac3ucFvv/O+tB7/fADQ + lf+aNK98tvEL6XloKWvJg5Q4q8Eht9C26DzsIYyYtBT3zn0X9y94H8OeWYKYXrfhVs8o4SPgnQWOrqEC + AM5uDIAxePWtt7XW6aZLak0BQJ2h/NdkR9+BU+fRe+DdkpewZggmy+8eiE690rH1p22qFGunKcseAHAZ + r7LmOrZs24zxjz6GmKT2QpLiJuQedHb84hXjTxO5IU+Nc9LgnbS1+gEWliq9E5FzR7oHocAkRv2enUSf + LQCYdwzYA4OmPF+7+hFkEa9gjSsg2AwASTcDAN9HxHdybM79vyEAWJKBKY9ZT/xx66+l+08kVO8E1MqA + warM4aWtOPYyTQNacwSoyUCPAAu7q9kDUAlBTXxtASBa2wloDwBirRY6ygYab7WEUnHlhRIYhAsQMB+h + F1mUuMTOWJK/Qht9rbDbcGJ0DhIIXCm8gNvH3odWjmxpWdGUN+DI7jdZ4M5dc3Ds1FFFlFFfeAMAMIum + bBR2lJRfw7DRd+MWsv6s+DyrcAtZ9b+08UdwSiYemrce0z49gOmfHsbLnxzCix8fxJQNBzDxrZ+Q++gi + OIV0lik/5Z1QiMJkIhQqZPUdhssFlzRFLLJytxsBQEOhRfnriyScqaZQqLLmKq6VFOLhp2coYhUmB3UL + sQCAG12Dnj3x4+4fVAMSr4KvL28SAPRuPQbfHbt+wF8feQyRcWkE3OF0/6PpbMSoRyuSzxsxAplce5O7 + r3gBY4SHUDEmhdE5jcGDjz2OKa/8jR4fRt7goYhP60DnnTkHKHT0Z/c/mc4p7x1IsAYA+psuTDfejEfQ + HAg0KosbdPoJolP6FKHREBRqBgAbclDZvpXy2I2U/4YAoIcBAZFtw+lFT9vG+eZWYPNss8pu6iuOEywT + gbatwAGmyUATx3tTq5qtASC6iX2A0VaLHTkkcNR2CDrLGupwzRqGCCUVewTcNyAg4B9FIUE7THx+Gq5d + v2LqQDMvJ9G9gAJxY7kjr0dGH3LPfaXm3kbi7lARDgUeeWKCAIoZAPQkV1OeAMf9qgRZhs82fSXj0jIV + qFn/PxPgeEWk4dHFGzDzs+N4ZcNhkakfHsHf3j+IZ9/dh4lv78OTbx9C3tNr4RzcRfYWqhbhCDi7x0gX + 3Ovvvq/lAm4EAEVW2Xnu+quuvU6xfAnWvv2JZKiV8odqAMAswYFo27Eztm3fSteplkCjVGvqsR3dti7n + Xbh0DK9Mn46ktl2lds8uuRDIGLTe9ipB0Y3EaBAzN5RpFl/nE5QVYszlSNeE71t4fEds+PwTXC88jrLq + 8xQmncS+w99jzRv5uOv++5Gc1gve/rxaPMEOAJAExGkAEK9J8yHBzYieL9CnCH1MfQG2OQA/Cwno6cCI + tPAbuf835QGwDB19z++9Q5IXqYTEjQAg6eYBIDDBQh6q87nfBADoa5zsAoCPRv3NG298whGb3AEjx9yO + l6dPxj333wt3ryilqHRALSDAHYTR0jgkIQG5YWPveQgnTh2TrjJ7bEOSE0ChWLFN332NkJgUtGjjR+GA + 4upjt5v5/bz9IqT/QLYE1xdode4bAwB/X1VTgXvHP0lWP0CSegwC0vJLlnzMc0sw+4szmLrhFJ5/7xie + JmV/8q1DePSNg/jrq3tx75q9GLNyL+5YcwhdHlyOlj6p9JlD5bA7M30ZeQEDR9yF4vKCRgm3RgBghD9F + QvbJAMCP2w8dQ2q3geT6B5sAIFTowSPjUvDl5k8VvTbz7dWrDkQLnbbOrKvanLmS8OnGDcjrP0gINIUj + QmeP8jcngO0rvD0AsPUI9H9rtCAzS7SHIm/lMI7XlT/+9HMEAGel/0O1XpeLVFZfw96DuzBt5mx0S+8r + g1m8VUjtGNREP6+yeDShycrAjSoFdjdqaVOEPkZVIFlCAqskoA4AYamLho++7/c3o9s3BIC6Om1zUGhq + FwKAwuYAQI9VvE1DDzoAeAXeXA6gqcRKU6uczMrPY69M7MHsK3kDh2HxisXYf3Q7Kiov00cpwIG9G9Gx + c0/c2sZX0YLRQXV0V/sDmDWX12Sp/AAnC6OQ22c4tv2wXWsjtl8vryOppueXrFhB/z5MEm+tpEQYLMKg + 0CtjEC5cvqARVBQ1ajuWrkOx+pbwgF3h/YcOIyKhsxr0YQ+A5C9tApGaeSemf3yU3P2z+Otrx3DbsoMY + tngPhi7ajaGLd2PYkj0k+zFkyUEMyT+MocsPITL3CSErkUqFxnMYEJ6C77dvVxl2OwCgynBFVgAgVF+k + /AVlRRjzwAQhL+HPyZZfhLkD/cOwfE2+WuNdb+HSh8amqyuWzq5bVHQZ02dPR1R8mjD3KqOgzXr4W1eA + rPs9Ymx6QKJI8SKVNAEM5slDnjbkfoVWdH3dvINxx133Yd+h/YoKXMbLq4GGam2pZ4UQiNbR/6cvnEX+ + unXIHjCClC1JVtS7+ib8QwDAyBPYEId6W60Ls6rGFfpHtOvCOsu6+3cDgN4ZGNeu95/oj6//vwCAppRf + BwCdAisisSPue/hxfLH5SxSWXtYsjTa7zoe2gNzjZx6Ap6svWrb2IaXyE2sliytlt6ANS61HJNqm9can + n38uLbRN9aOzYpdUFJKH8agoPPfgs7DVbu2sMu/zFuSTJaxUdNn22o5tAIAP3CsLlsmMP5camb6sJbn/ + jmS97576HiZtOIc71xzHkKVHMHDRYZJDGEQycDHJksMYtOQIyVEMyCdZdRI5UzfDKaSr9Cu0cVd057zF + Z8or0yXmrm0iEWgGLKloCAiUYs1bG2Tjrg52OgC0cQ/G4888jfLqIuHWtyi/LQConv2jx/dj7N33wDco + WiXd/FVyr7GLb1F2y/RgjB324AhNopqYNow0Fp8ydToDVmR8EpYtX4iS0gJjGazqD6mRrlGY9ivyRqcG + 2cHUgCsF1/DOB+sx9M5xCI5rp72XeDqriVYgIFyF/ipv8PcDQIKdrUFWALA+Pq33n5rq/PtFAGApCab2 + 8w1LrmycBFTsprqb4mV6w3oisKkqwI0svz0AUBZfUXqzu9+uexamzJqFnQd3o6q2VLtZldqhKxUQUDzv + pbh4/iAefeA+tKaY/dY2PmhJIMDxahu3YG2JiPIGnI0tOmGITeiEN95eT5avvJmW1FIcOnKI4sTeMq/P + 5UG9TbeFYxhS2vbCkePHVQmswZqUol4j1mgwpBiXrl9C59xhuMVZNRtxIo9DgbC0/nj09cMYueY0Biw7 + iYFLj5PC8+Sdkv6LNSHl77/sKPrlH0OfFScwcOUJRPR9WrwAITXVAKBLRi4uXjsnnow5DDC3Q6vYv0h1 + /tF7O3L6NNK6D5QKgwEA7iHCupzdbwDOXjqtse5a3H5D8RuU9edGpE+//Bzde+VIWdbTT1l7D79Y03yH + 9Z5AvefDxSAUsQcAkZpYvtd3/pk5B/j+OnoEIyoxAZ98+a50hDY01NHn41JwjbZXsRbVNeXYsfNH5K9Y + SqHcBzh+4ig9V2m1pqWkohRfb/se45+aiOi07nDyVzsoGwNAotV5twWAxmCgJQLtNAnZB4DkSr/wlH43 + E/v/XA9AACAyqUsreoFNiqTQVP4LsVAe2SYB1dCDLQA0Vnx7JRR9vbP+c479WeHZ4ruQm9c1sy+5+atx + 7sIFY9deVV0lzlw6iy+3fosV736AdR9vxunrV8Wd42QUDwQVXLuCv/71cbKo3qRUPmjjwjmBEGlblcEV + fXLNWy2t5MUaYTGdsO6t9ajiARV77rJIGVa99oYkG1XDTpjWox8hybuJz78k769W46sz/n2DhTGovl4N + tXy0eSPc6Lqpjr4wWXV2i3Mgeo6ZgrvfOI8+y8+gb/5JUvAT6LfsOPpq0mfpMUP6kvL3XU7PL6ffWX0G + XSd8gBbeSYpOXHYWRsoo8fuffawGpBqKbOrwRSblL5a238qaEjz9wlyhM2/tqmr8LKz84fEp+HbbFon7 + DetvbMjVpZj+RgEW568il7+TLFfhsiQ3aLnb3Qaku+5K2WV0mHf5NQkANyYaUQDAJcVQzF44Q1tmwjsA + +d5UCjNSNX3PS0Mee3oiktp2E2Ja/+A4tOvUHQ889BA++HgDrhVcNc6dOns1ZIT2YsKLLyE+rQeFBTFy + ZhkILADQtBdgDwA8g34WAGyKSOzU6may/z8bAHQQ8I9IHeUbmlxjDQAa/5meBDT3NwclaISg5h0B8U3W + US1lP+u1znwxeYFjWFwaho25m1zQd8hyXZEL31BfixOnz2Dd2+9j3CMTkdC9H9xC09DCMxm3+qfj0Xkf + yi49EMLrG3qLi0vwyNMThFSjjatasGEZXAmX+NBZW5utFoBE0Wt3xGvvvK047xuseeUUHXYxiiquYvTd + 95N3ESB7AVrpAODMiyfT8N32nUpBzOFEg8kLEEUrwTMvvyJWv43Wz89JxdYELKOmfoih6y4gb8V59F1x + mh5PIm/5SeQSECg5jhwCglySPPo+j5Q/jzyAvFWnkL1wP5zj+8umIifPGFl7xiB1z/jHUF2rc+ZZU6rr + RCA1QvdVhm+27kJgVDf5XGrWIESJVxBemTebFMcU9xtxfqlBtMmh2fMvvQJfOieuXlGSb+EOTf3RorzW + 24HMJV1n32gRMwAww5CLXRCItE84SteyU88snD5/TMK7Gn2nAb3PiroSvLH+XbTrnC6t5B6+lrXjXApk + gPILiUF6bh5mz5uHA4cOoaa21rTfsQZ7Du7DpCkvI7FDL3qvcQQEHBKYvYC4GwOAMS1oEcUlqG0NCjEn + BVNqfMNSR/0c5f9FABAe19HJLzR5i+3ecl/tDUkTkBmxTJl+c8tvU26+m23ShxMsdFA4QfTXxx7B9z9+ + h4qqcrnQhaTEH2/8Cg8+/jQS2veGk08SWpLSt/Zpi9Z+JGTt/uSaiKA+z2HLmWI1DswAUK9A4Myli2jX + I1tcWEex/hFK9M25HpGW7bleChSiuFT08WdCja2SZCo3oPYYKiDYuf8nxFDY0KJNsBEGcP/+rRQK3HHP + 4yitLtWYaxt34oGUkKnPMweMEi+Cld9RstQh8I/vhvtf3Yd+ay6g78pzJGfJvScQWH6KFP9kI8njRwYH + AoBczgOsOo2AXg/T36LP584lsBjZYxiX3A1HTx7XynOWuXr5XBo9GI/mXi0pxIhxT+AWF8ukYRvJ+gdg + wPARuFRwSawoZ/wbWBp0q6+U/yqFNQ889qQk63hrsprPsPD+2Ypy5XXL3zj/4yLNXTGi+EwzxnIzHoCz + j9oT+diE51BdV4aaOqX81RoAHCdQ6DNkNLxIWb0DUuj8psAjINUQz0D+ngDMh1eNxSAuqTPG3ftXvPfB + h7hy9YoBBDUUTuw9ehDPTXsFyZ0yVKLQN6lJAGi+USjR7hYuU+y/JTSuk9M/FAAMLyAsZQwpfM3NAIC5 + 1Nd0vG/qotJAQMgi6AbGJ3fGI08+gW0/fk8oWyYu12Wy/KvfeBdZ/e+AC92MW9yZvTcWbbxT0ManHRz9 + 2qGNfxpa+aXiVvdYtOj5OP62+bTQRyqXQT2UV1dj0Oi7xbrq236cZNtPuAUETACgGomikNYxGz/u+FHj + FSixWoihpBxzFi6RXgDZ7KMBAHsCPoHJ+GrLVmEqalRZIEABxdx7yY0MI6DRW4wZBDjeTki/DY9uOIcB + ay+h/+oL5NafRd9VZwwQsAICUfxTyCHJpvg/mwFg7XmEDJiCFq5RUgqUbUe89Yiu36vkUanmJ2sAEILQ + eib6LMObH35JBz9FRqGZkFSFJqHkGaVgyw/f0jUwuf4a1bYCgApcvHwWd94z3sQJoJaCumj5FvvCChtt + AwCW/g9mCGbvTFZ7+0QYi0SaoxtnKjIXPlt+8Vi+9g1J+NXUlRjbjBgATl86iUcnvYjwuF5k8dtqit9W + PjsLA4BnIDcEJZORShZ6cs4beVBY2r13LmbOXoQDB4+irk6dt1r6/8DRI3h55lx0S+8vVlvKhqITuuVv + KheQ2GiAyA4AsPUf83OV/2cDgJ4MDIvr4ESu/zeN2oBD7QBAUILd9kml8Pqe9hjTgE+cIHQYxZOPT3gS + e/dtlyYStt5Xr1/DinWvoXvuCDgFdcZfPDrjFrdUxclHFqU1eQBtfNuijV8aHP07Chj8xTUWQSP+hlV7 + 2DrVa/lbJeXVVeg/fKzUx1kJxPX3CDdtwLWs3HLWdgHKgSOQyMgbjMMnDmvsQsWNNuMwBVdWnyHkBaiZ + fd4FyCzCvCZs3P2Po7LK3mozBQTLX3vNUp/WLC13ACZnj8XTX1zGkNcuYRB5AQNWnzNAIG/laVF2W8le + qSRr9Wlkv3oBIQNf1AAgUlt6GilDQ/c+8rQkORuM/Ib2eeoVQ/CZq5fRq+8dEjIY1p+7Ht1D8NLMmaiq + 5xjaQiFu2aFXiXMXz2DkmHu0BGukSq56hWvrwZsRWRuuK3lUE41fCgCa2y+gLxnRhY2LNynxh599JQk/ + HkWuq9c/a5l8jvNXzuNFUtjo5O50LhNF0d39kw0QYOHv2aV3pTPLK+Qk3+PMlaRoxCd1x1NPT8b+AweN + LAHT0Zy+cB75a9chd/BtCIhoK5UBD4NXwNYDYMVP1sQ+EAg5T2jKNyGa9b/Z5N8v9gAs7cHJI0npq24E + AB5BjSf+LCCgAMBNm+vnrj3v0AQMu+MOfPX9lxSXFsoBqq+vxObvv0fOkLvhFtwdLmG9ENahP7r1vxMD + 73gAXTIpriVXsLVPilJ+v/YkHdDaMwFBSelYt3Ebyhpq1Py/KL+6JbsPHkRi+56qRdZmx56jDgLa4k3D + ExBvIEp27g0efSfOXjpjwzGorzQvx/qPPpDhoxZOITKg01LbJOQXloxvtm03UVpbgKCiphi3kzvJJT8z + AHAvQEhqDp744ARGv3cNg9ddwECy6P3WnEMfOwDA1j+Xn1ulyZozyCbxTX9Y+ALMn4k9jHbdsnHxygVj + 953ZA6gmhZi7/HX6NzEqH6ELAUdW38E4f/WiJM/MNGNK+Stw4cpZjBhzB13LINlMrAAgXG0r/gcBgKO2 + 2oynEJ28QuHoHa4pf6T2+5xviMeMeUtRXlcpnovaEGTag0D3r7TyOt3D9UjPGySDR26+iWTlk0VY+d38 + ksSSe4XEoW33DAwYdSeG3HEXOqTn0Dmn++4cSB5sN8yYM5+uw2U5dbpcKbiMt9avR78ht8E3LFH0oPHw + EDfVMf1eSqMhItNOziqfsNSRv8T6/yIA0L2AyMQuLQkEPlcVAY0SzBwCmGmPtDfeaOBHc/m5I8uPLsLA + kbfj7Q/fQUHpBa10VIlrhZcwde4ihLXtC+egdGQOfhDLXnsPe44cwfWSIsm87j96FNEp3SnmT4WjbxqB + QXu0Ibet9+CR+GLL95L9r5e6rkrUlJaV4s1330OPjH6SDDIrtyi/2QtwtwYHBQARsnW3tWcIxtw3Hle1 + ybo6yZoXS4KQE4LFFdcw8vZ78Ree4pMln2rf3i3kzt9xz2Moryqz2lnA3sQR8ioiE9qrbkJOTLqFGnP1 + TO897MW3ce8nxRj86nkKBc6jL3kAeSvPIIeUXaz9CiX8fS4pfrYGANnrzqL77B/gGJ0jG46EMdjTsjnY + IzAGX373jQJcEwEnA8KhEyeR1KmPWlOmbw4mr8k3KJ6s6CdcLBPLWW9095WL8l8i5R95xxj6DH5SWbGA + jqqsME+gozwfLtdc5WEs24gdhRY8Uu00sFF6R3k+UrV3e+mbkNWux8COg9HxjmnwadcfrTzV+jNuEnP0 + jjTaxZ28ePNyEu5/+Els3fGTVtqrU6BsAEGFzDAcO3sYk6ZMQUhkmoARe6muPokUTiRIB+kzz07GJQpL + K2uqUU3n8eL1q/joy43omT1I6Nqc6TP1INf/jbc/QHFZmRaF1ktfwZWCK1j37lvod9soBMUkyXgz64et + stubJOTOXHL9P49I7Nryl1j/X+wB1NXXaxWBlDwCgFJjKYiQgmoVAJs3bI5t3ANVfZTjsYDwBAwZPQbr + P/4AhSWXJTaGxGXlFCtvQd+Rd8I9lC58SA/0H/EALly6BNv/uL4endSNbnI7tPRKRXhKL7w4fz7OXbuk + 1j+L8pP619diy9YfMGbs/fALjpXBIOkFZyXwjNS+jpDlGlwjb60dRAUKZhBQB66NF/3cKwSPT3oeheXX + NeUvNMpmrAgbv/lGGqNudeaV3mpVOIcEvoTsm775Tps3KBEA4K/XvfkmeSQhRmONGuIJFVe7tWsQQjsO + wj1vHcWQNy+hz9qzyKUwIJsAIHPFaSvJoueyVylh9z+LACDmzvmkEInG9uA2nhYvgD/v89Nn0vuo1ixg + iYQDVRQWPDN5tngvsnFYuxatXALx4CNPUBhVRrFzuXgKlnJfBarIk3nosYfo97wo3AjRwivL6zlp24vb + aMCgPK4wDezCrPYbirLbAQDjb3lpf4v+TWCHIch75SsMWHEYuTM2I2H4c3AM74yW2kZlBlFHBgAWXgRL + QBYalYr7HngC35CxqKiqFMVUk4vaHkT6urK2WDy69l0yZKDK2ZPjfvJa6TWnz54v57Beyy9rmSZs/HoL + /AKT4OqRCCe3aCEjHTrqbskB1dTVaK9TJ/9fLbuGTzd9KqvvQuNS4OofZQMEjYVCgVK/8LZ50vVXX/8/ + /xQPwNwdmJDW60+k/K9bAYAxCWg7CmwJA7ikFxLTFrffcw82fEGKX3ZBaw2tpANXhR937sJDTzyLgCiy + 5Iy2IW3hSig4eNQYnDp9kOLnq6isvoqikgvYufsnjBl3D1kCQk7/NAy87V58/9N2uah67MVu/5GTxzHp + by8iLLad6vrzVFlw/neyMUckFk6hneCfNhiesdloRS6v7gEYjx6RmisbIRaqhVsQPEPj8f6nn4rCW7bk + KG+gvKoY941/Are0CZSV4SxtmMmHAOG2sQ+irMqccS/DuPsekp4BfbCGld9JAEADAbLCyYMfxaDVB5BL + MX3OuvPIJNc+fZWS3mTtRUjp0+n5DAKJjFfPouPUb+EcSx6PW5RSYk+1N0AHP1571iNvKK4XFRiTkFy+ + +27XboQl9pSfO+pJUno/8akdsf/wAYmhVdnPnPVn7sKreP7F5xGT3F4BGlt37bopANUBQF3XNgYAhGl7 + Gq0BwBYE5Ht5/wqMW9PfC+w0DNkvfo4+Sw8jZ8kh5C09gP6Ld6PXpPcRkjEerQLS6J6y90OhDN33NlwK + 9YxW14NeNySyHcbe8zA++XwTikuLNONRTZ+vRvMiq7Hv4D6MHnuvlAdbu0VKA1Rihy749JvNqKirszJM + P+3eh+CI9vR5SaE9k8l7SKTfj0ZwdEdMeO4lnDp7RgxTHbcbN1RLx2FZZRE2bvkCDzz6EOLbdYRnYLQi + x7HLJ5D4elzbXjfd9ferAkBtbZ3mBbRrT8p/2bwWrBHpYZCq/7N7ExSVgtvuugtffP05iiuvSrwsq7ro + 4Bw4eggPP/MCQuO7kTufACeKs1wClbgFJsnfaN8tnYBgBIaMGo7e2Vl00xJlpJPLgNPnL8a1ogLjBjAS + Hzt5GlNnLUBKp1504xU9NXcROnsTgnvHk8SSRYiDU2AH+HQYgaSx05E+4Q10GTWFYsZErS/AlBuQTcHh + sjmIx1MzBg7HijfexJXrF+3Si7Nbv3PXTwiLSpNefsum3zDhj/9881dan3k5zl44haS0HtKbro/VCgBo + bcosTq4KFILb90XSkCeROuYlpN43Bx0eW4uuz25Azynker7yDXrM3IKeM7ag67SvkPb0W/DufIdsCbKN + s8U1ZgUja+YdlIpN336nVShKUFFTirsfeVYLGSKNFelOHkGYs2i+NMzU1av12g31lsy/TjRSXV+AfUd2 + 4bmpLyOybRdSPm3uQtx19bqs4DoANLXhWAcAMwio78MNEAnoNBwZL29G9tIjyFp8CFmLDiJ70X7kkOQt + OoDsuTuRNn4VPNoOQQvPJPIIYgg0FBBwUxTTmDnT9zwj4ReaiEHDbsf69z/Di9pKAABQV0lEQVREcfF1 + zYTUCwiw615YWoilK/KRwJ/Jlbc7B8AvIgF3PvgYXl+/Ad/+uB2fbPwKo+8eL7V/ZwpNnckzdfFmSSGh + M03nu3vmYHy08WvyLqq0jddqb4N4wLUlBDY7MX3uDHRn2rOQRuVC1rn2rIOsi/90ANBl+Jj7f09xyCv2 + AID3ATLXOpMw+IclYNiYMfj4q49RXH5V3MVabVEnL8p876NPkNq1L9r4pcKJkNo5oB2cA1NF+Z0DkuAS + QDGXP11Mn2S6WUl00+Po5sUgKqUbHpnwHLbv2611+nEjRgMOHj6GyS9NR2JaV0L5EC0ODFPCAOBDyu+b + BOfg9nCnQxE14kV0JEXp/uRaJPZ5gD5HB5mcs1h+dVAZ8Z19QpEzZBje/uQDXCu5YljMxj3+qo2Wy0zP + THpR7R3UE2juEULpNWz0OBSVqt2GX2z8QliKHLX6ul0AkJCAWX780MbJl8QPzq4BMojkylUUzlBTyOQW + 3gFuoR3JcyIL7KuAzFEHFa3lmcWiYFHinUyc/LIcRs4FfL75GwREthel0HMFrem1uvfOxvlL52XKT9p9 + WflNAGAZH1Y7DHgUesfBHXho0gSEJrQj8AsSS8+ehxFW/AIAUDF/GHxS+iDrxS9I+U+g15Lj6LX4KHqT + pC8+goxFh5GxkGTBQWQtOIDuL36DiOHT0Tq6L1pSOMQr4Z00AHAhY+BKxsDVm8PDSPgTQA8dMQYfkXdX + WqHF7g3Q5gFqsYfO3L3k3QVGpNL7j6XPlAAXPy7LtaPzk0qebiLcfOnRpx2Fu+TFitCZZqHnnegsR6Vm + keFahbN0PXW2pHrxhiuMpTZnzh/H4lXL0b57pvQPaN7AK8NG3/v7v1d//y4AqK2t1VeJBZLi7zeWhGiK + L8sSSPlDo1PJYixCAcU5QsXdoO2ha2C6pyLkv/E2QpLy4OzfFS5B3UjpO5HCEwDQYXb2ZyEAIOFHR78k + OdCRqT3oQD2PH/bslsSLNF7U1mLr9l14+ImJiEpoTwctUNpUHY0FmSqp1Josf+vQLnDvdDsibp+BlGfW + o+uUT5Aybia843uJwrm4KaUTKymJJFX7Tu7cC/lrVuN68WVN8S1LK1TvfIEmZi+ghABpP6KTOklzDycC + 22gxKe85fOud98TdnDz1JbR2CSIltzDr2AMAnltoQ5/N0SWAxB9OIup7Jyd/OJM4OfvT94FKeOqRlM5R + JwYxs/aYFIwTfF1698X169covCrCgOF3ydyAXi5UZTw/LF+9UvIqdXWa4mvKbx6ZNmjVjeGmYrJ017F1 + 93d44JnHEUhxrqIP0zovtXzLzQKAZPN55DuqB7pPfB+5+aeQvuwEei8lAFhyzCIEBL0WkSw4ItJz/mH0 + mHcAHZ7/EqFDpqJNXH/JG/GQlXgBdDZcSbgBjVuU3Tx5/2QSbr+TYneK6aur9Y4/FWCWVVVR7P4Vbr9r + PMJje8Ddr72Im28aATIpvi8rfzsBAQECX1b+tupnAe0R0a4/skY8gScmz8F3P25DReV1tXrdqoW6XEKR + /HWvK+KcwIT9ZHQDlfWv/b8DAHNZkKz/WFL+agsAKGJGHulM69Qbp86dVm5Ug55lVQs5rpdcwrgnnod7 + aC5dkExS+h6k6J1J0uBE3kAbstJtvOLhSBbbN6IteuYNwtQ5c7H38CHUNKiYq6yiEpvJdR334CPwj+K+ + gCBJahnlIFL+NnzA6RC39CPr2P4ORN65EEmTPkW7aVvQ4YWPENlnPKE3eRekXK4MAO5K4RSnXQihehzu + e/Jp7D95TE2JGZ/BDACFdgFAUWgXY9KUaWjJm3tcLQDACtl3wHCcOXcWuQOHComnk0GpHWrkAHQQUB5A + sIwy81IQBgAlgU1KGxMAMDGoo5s1AOhKxsNV7v6x+HLzFrz21rsy26FyJXq/QADSc7Nw+RqFO3XM8FNm + cfsbGnMm1NtZKsIeQXndNWzZ9R3GPvCQrNpuLXwCKvt/IwCwgAB9Td5hx4eWIW/NOWSsPIsMHQSWHRcg + ECEQ6L1IAwGSnuQN9Jh/ED0XHEIP8gg6TvkWkaPmwT1xKHmGaWT5yYp7cfdpNNwJEFg8vJl1OBKhkW1x + //jH8cP2HajWWn/rNCjggaBN32ym2P0JJHVIp9idLDy5+44ELs7epPzeOgAo5Xfzbw9PMkJxXYcj67YJ + GP3AZLw0Yw4OH95t4kqwzFBwaMA/d/eLq/YOShz7S8t+vzoA6GXB8MSuLbyCE9fz+K+XvnZJqJhi4BMY + iynTZpO1Zx5+knrFxV+nzZYfOnUU9z01Fb7RuWjt2xWtvMntpIvkRW5sfMcMDCU3eeqsOfhqyze4WnhZ + G88ECoqK8eb6jzD4trullspxuTo4kdYZa3JhW/ikwDV1MIJvn434575E0tStaPvyd0h6cDm5kHkq4+9u + GQt2lu+DhdW2R79BeO+LDSirKVI76A3Ft1lZ1WBm9CmwEj74B44eRlzbHlLTb+Ou8glsxZiJ6KHHJyIi + vr3GVmTNreeoiQ4ADFJKoQNNQp6Da5AGDMxMpH/tbwCA8hwaewBmJeP9BiPv/Ct6ZA8ihbCsFGdL7eEX + jHc+fFtKqrV17PqXGspvXsNtuR7FpglHyzpxtcmnFCVVBXj/84+QNWwkhWMRuNVFhUitTCAgZTwBcD1R + q6w/931EDnoaA9aeQubaC8hYrUAgfcVppC8/KUAgooPAYgYCkoXKG+g9n2TBYfqevz6ETs9/jfDB0+AS + Q2eBk8F0brjrk9vQ3TQw4BFxJzoPETHt8OAjT0sVp0Qr6+n/VddWSi5r1euv476HnkaX9MEIi+sF79BO + 8CLxi+6B0KRsxHQYhLTMO9BnDFn/F+fgvY/fx6kz+1Fdc02rwJi9gEps+prObLuuzJC0Pjy2U4tfWvb7 + h3gANTW1GmlIYhrF+xds13p78CRVRAIWrVxNB6eWDkKNeAFqD30JHadSXCaX+p1Pv8TElxdi8isLseK1 + t7B56zc4ee4YyqsKxQVSs9p1uFZ4BW++/S76Dh4tiUHZdy9Z+ShV4hKhw0xu3S1k1V3aj0T4OLL4U75C + 4uw9SJi1B4nsAg6YAGeK1RyZOptcam5WYYXnJRZslXyD4zDxpZdx5upZQ9nNB968O4AZZHQAsICAWYqk + oeaFabM0i6dajyUjzvyE3KTiqSt+Y3JNidvddW8gWLwADhdaCQNRiPoMDCwu6vnWLtyB6C+cBxYACLEG + FS0HYGtlXWSKLYa8Li3ZRj9vSSHF0NGjUFTO3kyVdM1ZK3+pXXJPg+/Pzs/qNLlYfB5LX12L5G6Zsl7t + Fm37UittMzOvZ2/jqUaYVRmP3iPdt8wpH6Df29eQsfYSMladJzmH3ivPEACcQu98BoGTBghkEACwpBMI + pBMI6NKbwYDDAwKBnnP2IO3pDQjMeRJtwnuSxxgnHZOungwCMQIGwhPhqaoh/sEpGDx8HN7f8AkBQalV + aKByUdXkLV3G9n178d6Xn2PFO+9i4bq3MWf1m5i/+h28+v4nFBLtwFX6/PX69uKGEgMAFBtVBT7f+Bk6 + dunB27Av+AYlprGusc79S3gAZpkxZ9HvvAPjJ5Li13ta7fjjbr8oBEYmYfHyNeQJVFs1XEgbZkOZtrK6 + 0siKQ3tUSak6IaB8+8MN6Dd4FHkVcSqb7xstB6KNuLBK8Vu7RYvFd0wbgdD7lqLdzJ/QkW58u0VH0Hb2 + bkTcuwKuyf3QQvrZg4Qyuw2z+zIAaPX2lE7peGfDBlTWqeWUDaZNOtbKX2Ka67cQfNp6ALL2inMBZB0S + 23aX7LEFACwlMCWNAcA6HAgWpYxs3wfhnYbBO6kvPGKz4RqdCafIdDhG9IZjZC84x2TQc+mqBOcWbCzp + ULv6tLZnKwCwtrKO3tr3BFD+oVHY+O1GVfarq7Rq99Utf4Nm8a2mG82rzRrsEY4UyrVjerWDp/fj4b9N + hk9MKv7kFCAbmHjdWkspDTLbU5Qk7Xgqkj0Az7gsJI2bgZyl+5G99jLSCQDSV7IHcJrCgFMiOghkMAgs + UUCQuVgDBAMMjiB9PnkDcw+ix7x96DJjB1Kf+AAhAybDNTaPgJnCAvdoAoJoAQNXLzXMxH0APDzGK8OH + k5f6yRdfoKi01Cg915uW0souSjrPbAS427OCvJ+a2gKrycsGjTxFEahUoaz8OlauWYmUtl3g4x9d70u6 + NXXmwt/9mjr7qwFAXZ0qCwZFpDqT8m+0T95InkBoMl54eQ6uFVxTddaGKm2yzsLH32Bs6FElkcLiq3jv + gw0YMOx2+IUkqWytr4UkRDV1RJO7SK6+L/08dRjC716C1Nk/od3yMySX0GXpJbT/2zfw7/0gWvrEUbgQ + KGxArdwsbDatXIOEJGL4mDux5/AeddO0HvHGu+dLmrRy5oWalhyAvh+gBM+/+Iq8FtNzMeuQs00bsg4A + Vgy7VkAQhIDYjpiwajPuXXMQA+btRs7MXciYtQvpM3fKY8bcXchadhCZs7bAMbijMPRaA4BW1jQsf5Ti + CNAy4izyNV9X1wA8+Oh4VFSXCqtRXb2t8je/RkykGepxM/8A5wc2/fQ1BtwzDq29Q/Hn1r6KEJWBgL0B + ul4txbtjsI8m4I9DYKeR6PL8R+QBUAhAYUAvuuc988+glwYCvbVwoLcOAiQCAmZvgAAgfd5B9Jy3n0Bg + vyQKu82i8zPhY4TkPY82ob3p2sUTEMRoABAlHIIu4hnQOaT3EhiSggGD78Bb736I4lJt+tTUUCSLaU2D + Ug3aWjTrmL9Cfm///r144MFHEBaRAl+/RHj7x28MiUx1VlRfdf96AMBSr3UIkhfQjRT+cpOUzf5xGDbq + bny39XvU1CiutXqt5NFgEDFWEkhcxBtvv4Z+g4bDLzRBerhdfeNl+EJ3UyUepJvRMqAtnDqMQvg9S9Fh + 5o/otOw0Kf45tF1xHu3nHUL02OVwIeso5B9ubO2DNTILNc/OtVz/8AS8OHMmrhVdkCYYNQv/awGA2gvA + Lu/egwcQk9xRSEiaA4CmhBmMOucMx4LPjuKeV09iIB34fvnnkLfiHHLIFc5ZfQG5ay4i741r6L/2LDwS + B1E44KdyGtqaLr2LzpJYs1Z8JTFSBYiMS8au/dvVQtX6Ms1alZgAQCMysdojcGMAsPYKzN5UAa6UU1jw + 1muI65aBP1H48RfHAAkNbnULJ8+Npz8JBPj9ecRIZ55bRBfEjX4Z3ef8gJ4rTmsAcEYBQP4JIyeQufSE + AQCZhhfAHsAhkd7zD4r0nH8APebuQ/e5e9Fl+nYkPPQmfHs+htYhWXTeEiQxqgBAlQ7dvBMoTCCAIGAi + N53O91347MvPUFJeKDkrxSuonXGz92QV61egtPwa8leuRFrHnvANjJXFtt5+sZd9AxO6sW7V/8KOv38K + AOjy0KMT/x+5/xNI2evNLK7yte4NUHwZFZuG8Y88ju+3fYdy2dpbK67PpSvnsZxcn+w+AyWByMM35j0A + nDByopDC0SdWsvqunccg8sEVSJu9E51IGTqTC9iJlL9z/mkkPfURvDrcJhajNSuBm+IA5CoBi2TdSaF6 + ZPfDRxu/JJdf8dLXmybE7AOAxQLaAwJbvr9aYzlIIaroNSY8P1lq+S6sjDYAICCgZ8LdG0tLArCxj0/B + 4i/PYNyakxhCMe/g/FPoT59bRoNXqRbhvq9expDXryA4YzxaOPlZPABpAAq3tv6s+HSNHU0AwH0WfK2e + eW4SqutVp2Jdg/LOmgM7817D5haPNCkSNhRKknj/2YN4etY0BCWl4Y9tfIWE9FYej2ZPgJSQvT4jQUiG + wa/9IKQ+uhI9Fh9Er/zzCgjyT4gXYPYA9HAgg8LC9IWHRTIWHDaAIJ2MRvrcA+g5Zx96zNmL7rP3oMvU + 7Uh+fD0C8ibBOaoPWkmWn5SeAMHVW5c44ShwJYAKjkjEyDHj8N77H+C6sAfVaOvpLTRpKtZX8f7hIwdw + 74MPISAsUUhRZasRhdPeAbETHnn8yf/3j9DVXx0A9N6AwIjUNqToHzdH2ezGhA50oUIjkjFs+G2YMWsm + Jj03GT0y+krOQLrEvLS+bb3+K/Ef3fiQ9vDofg/iHliHtBl70H7JSaQtPY32+WfRZeVFumH7EDV8GpyD + Okl8z5lySZqx9dcA4FZO9IXE4tkXpuD8xXPidRgbaRvKjNHW+gabsV3tOUsy0JZHv9hIDOpJQAsAqFzA + 7n07EB3fVpXm7AEAzyTYBQBuZIrA35a8i5c/PI07Vp7C8OUnMHQ5eQIrTqEfxcAyHchjwmsvYBB5AYmj + Z8oqcXsAoA/HcH98G+1RvAD+nt5DdFJ77Du4V+P408ARpTYuv7bQRIvnjfKfFQCU2N3ya0uIoocUFs+h + kO5KIbYd2o07HnoMLv7R+AtPV/JkJYcCGgi09lSgxRwH7sGpiOz/GLq98h16LjtJcpy8geMGAKRzMnDx + UQKAIwIAumQSABhCIJBBINCbwoLeFA5wWMDeQM+5DAa70W7iJwju/zwcCQhae5P36UleqVe80UjkzsLL + aLwixIj1HTgC7334PorLi7TiYZXGW0mfrugSVq9Zg87dslXiPDDeWGJC8nFwZLs2v0bN/5/mAVRXVwsI + eAXGp5DCn7RwsUdpNE8xFpJHduXZ9fRUPG1OkpQiJfdRyT2ZIvNSz8mNDu4Ez273IPK+1Wg37Qd0pBvV + YcFxpC06jY5Lz6InuXjtH3+bLMFIUqAYil9DJOvOwyutnBVlN6/x5pJTux5ZeO+Tj4QVRsKOemX5LY0Y + Zkqrci0haea1L9XyFSVaaatQ+90yjYi0wCopWKvnArR1409OnESg5G8Mylh7ABGNOuOkLEaxcEBUO8xb + /yOeePsUxhAAjFzBAHACg1acRH8Cgb4MAqvPoO+ac+hPHkDnp94VhZEyoAYAqodeTdTp8b/eFuvsrS9U + CcbkqS9rWX/Vt2Hl9ZjWhjUQyJWVn8OZ8wco/r1oXLcGo6RVrq0is965qH5eol1HHWBLLF6FiSexpPI6 + XvvwXbTPyKP7FyLLUHnIR7w7D9Xbz5UCHvJxJAX0bz8A7R9ejd4LDphyAEctYgKATBYKBbIMUUDA3kDG + AuUV9KLQgL2CXhweLKQwYfZepD3zBYIHvQyXuIHCP+HsESs5AQkLfHQa8yhZi86WffSdd+Pjzz7F1etX + cOHiWbz+xlsYNHgMAoOT1DqyAH3foewsPMk6xLrEOvVv4QHYDgyRpR9LAFBhTdUUY2z40Zl+ObHHfflO + 0psfo6wRH0rJ/MajZUQPeKc/iNgHXkXqlK1oN5NQeNY+pNEN6bjgKLpRTJc+7XskcGkvIFmy+3oijSm/ + WmoA0NLRj14jHHc9/DgOnzquuWSaO691tdWj1DTWWimEJKXl11FRWWQgtzUAqEpFUellfP3tJqx741Uc + PLrHeqWWTWMQK8GOPTsQTvE1txc3FQLYSgsCtNQe/bD482N48LWTGL3yJEaQ9VcAcAIDSPoRKPRdfZoA + gEBg3QWkz9yGNoHtDQCwlwMwJwFVT3wkOnTrieNnj9H7rdKqNCV2av0KAKqqz2Hq1KcRn5iE7H70/las + wPkrF7XrVWFYu3pt0YoCykrt5+XGngABiAa1P0Eah1jqClWooZUNT1w4jsef/Rs8gmLwJ8cARQjjHqWq + BDLpqH0WLt8FpyGm7+Po8eKXBADH0EtyAEeUmAAg6yZE9w4YEHpr0mvBQfSYuxsdXtiE6NGL4Jk6WnFS + UFjgwhThxt4CXlMfI/smQiKS0DNrMDr17Ae/kGQhwvFg5mDt0VMtPa0g6z/27xn0+T8FAC1Z4RCb0u1/ + CQQWWthdoxvzvHkrkSSUduPY2t/qTy5y8kAEDn4B8U+uR7upP6D9jF1oN52UfwYDwH50JDet+9z9aPvA + Cvin9FOTbZ6k9J7aZJkOAM6BuLWNHyIT22PRSt7/VyhVhjpzXd/k7vNhZIrxT7/8FPc88CCy+gzEgKG3 + YfHSpSgovKSBgCK9qKwuw4ZPPkFu/6Fw8QzF/6+FJx586imJYZUlUyVC2xmBSh6ZfeIJSeo5mcaOHU3W + Xy/T6dKCvJfc2x7GzI+P4+61xwkAThAAHCcAOIbBK44rECBQ6LeKZPUp5K05i9z8Y/BI7Cfej+4BNAcA + PCvPXH3LVi6Ta1Rbb6Eyb1TOYxoz8nzOn9+HDu1ScOut7vhjCxe0cPZC5/Q8rHzzfRSWlWtur1qycenq + Zaxc9w4mPD8Pi5e/hTNnz2sVIZ1UpKTx5qQGS6mVm6qYWfidj94XTse/0Oe6lXsH3MJlxkI6LDkk8IwV + b4DzRj7J2Ui5bzFZ8D1i/dOXkGVffNgOAByWx+zFLEetxAAC/jcLD2tewQEKEfah54J96E1fd3t5G+LH + LoVX2h0EBB3EqFmYjgkAfHXq8zihA2PWH+HIEPpwfc25bEZamNi2x/+yDv3aib9/mgdQVVWlGoRCEr3o + w39t7PYzOP5jRVQPtorveVyzVUB7eHYdh9i7lyDtb5vRaeZOdJpFKDtzF8lOdCAQaD9zHzrPPoguf/sa + YX2ehAsPDmn8chLfemrDLnTgW1L86+IdiqFj78HWvbtlis1Y+WVq6qnT11XzSurqQkyfMwuB4TEyz674 + 6SieC47HvX99FGfPnZMS5p49u3DfA4+QwoST4vvjf1uG439bR2L6omXKM7BTHtMBgN/Dd9u20GvEqQ1F + PBDjFm41GWcLAK0IHMY8uQDPvXcMY1cfw20rj2H48qMEAEcwZIUCgQEECgwAfVedQi55ArkEAoG9HyKl + DGqmDKhVAxgEyK1Oz+mDy1fPmfo0mmvwKUJp6Xk8cN99cGXXvLUPbmnthb8QELI3MfSuCfhm91FU1teh + oLgQDz46EX5hHejwt4NXSHtk5N2JH7bvl9l4BcDFdjwmG8pyfp63J508gLGPPELnianYQ2Vsmb1GvYoh + Z0sWxZJLHdQWcTnj0WvKV8oDWHTUBACHDMkmYLAHAGbhcCGDw4O5B5Ex7wDJfgKE/RJuZJD0nLYdCXev + hE/7O8kj7UDvQ621lyS4thNAKL8CEq12Y6r9mHFf+4Une7HusA79W3oAtqVBr8CEdoR6pxj5dABw0QHA + R7P6/qkU349G0sOr0GXGNnQh16orZ1/J3WfpPEuXPeg67Sek3UMXOHWgJKycdYJJE8kk5w+Yrz6hQ2fk + v75akXYIJXeFpfZqAwCKmKMcn37+CfxDuOkjTJaHumuLJj2CEmVB46gx4zHxuZcRHp2KW9r44M9OwfiD + cwxa+LfHbQ9OIveXvASmxaovaRIA6ulnZZVXcfvYuwmk/A0aMh0AbJWfm39c6ICMn/UuHnv9OMauOk4A + cJQA4IgAAHsBQ8gb4CUg/cULIA+AvIDctRcQOXS6kJI0BwDCsEP3gdu333znLbHWHPtz8q/OJqNvCwDs + ql+9cgwvT50Kv8AY/JmUvwUzIZGL3tIpFGFJuRj36BTcef9jCIpuD4+QtvAk8QppB7eAVPQZdBcBzjUJ + pXQPoGkAKLYiLy2suIola9cirl0vmbDkOQvuX3DSvBkOK3lRh6vW2x+cNgidn3yVrPg+AYFMEwAo5b8x + AHCeIHM+hQTkgWaS5WfJ0B5Z0jl/QH+32/TtiLt/Nby73QvnkG5w0WjuFQkoAYCAgGVJLskpn+Ckdv+I + kt//CQCY8wEeAQkj6cOXuGnkn5wkcSFp40sImDYYifcvQVdS/O7kpnWdsxfdpPyyFz0IBDjzytJjzh70 + nv4jYgdMhCvX/nlJiKdlm48inAgXN5d3xI257wHsOaKaepSLryeaGq+pNqbY6ovx+JPPkOUPFcpqzlsw + dZkwtAQmwJunHgOSpJf/VlL8PzuGyJRixoh7sHbDJ+TyXtdKiUXNeAAqwcXexgeffAAP33C1nEQb1LEF + AJnbp9fzjemCJ1dsxANrj2AMWf8RuvXPP4rBJIMIAAaQF9B/pcoF9GEQWHcBSfeuwi0ukcbQjQ4oTgbP + ofJwuFdg0IjbUFBCYCnjvvw57PU62JYBr9NnuYrquiv4/KtP0Tu7j2xeupVAoBWvNBP3PFIssisddLdA + in2ZXps8N48gXnSZivc+/FiFCabNSfbGq20rByxcWeHNUHeOfxw+9Pcc3aIU67FUkRQAOMt5ixWmYe+4 + Huj8+DpS/mOaa28LAM0IhwicKCQlz5IxY1s5pBKIJD3p97qTdCXvNfHh9xCUMwFu0Tz4lmKcJ9Oy3BLv + oKSR/+i4/58OAHo+oHN6/z/Qh55MXkCdYgCOh3NEd4QPm4yuUzdJ80X3eQcJAPahO9df6bEXxffpFGP1 + nruX4rd9hLgUZ/31DbIaHURBmZLJ2d1CMMk1dW6ZDY9Lxfxl+SgqK9YsWalWw74RABSiouIaRo2+U9aC + SdKS4zfNbWOOA5/gFCHPcPKOJ0WKRc8+w/HaBx/ieulVLbQoMbXCNgMA4sYWSeNRXv/BZC19pGIhbECN + ACBSeuKjuvbDM6/tIOt/BKNWKOs/hGSwBgADKd7vTyDQT08GMgC8ehYdnlqPWz3irQBApwRzEaJOxdbL + O/o2fPaJeEq1+jWz6faz3/mnVTt4FgKFuHjlOF6eNg3BYclo0SZAWJc5HHChe868Dq4ByXQPFbmmO3Ps + k5JOfmmaBgClVvejeQCwCFdfSqsK8O5Hn6N79nBtdsBS2jQLDzgFd78dvWdtR9binwsAhwUAlByyI+pn + HCb0IrDowY8LjqLnghNk2I6g/bObEDNqNvzaDYcbnSP3QAGCOq/gpMndMgf94R8d9/+feADV1TUSCoTE + dGzh4R+/RjKekZ2R+tBy9JjPSZQD9KikJyl5LxLuyEonMVwsAodskoSBL8KZGYM8VRedUHpLvzv3yYeg + Q5de+HzjlzJ6zBx33Gas01ZZlN4+JTcfssrKAoy+fZxwBkrixi/O4GcTKuYQXsecgl55Q7Bs7au4WHBB + +3uFqjRmrzfACgAsI8O14t6W4fW33iBlDNCWlYbKbL6jhxkAotCCvu8w8F5y/w9h9MojGLn8MIblHybF + P4xB+UdI+XkZKAPAMfTjdWArOA9wgjyA0+j+0ldoGdBe6yaMsAYAbmtlJSFg6D94OApLrqmmH63u39Ac + ADQU2Yz9MggoMKiuu45vt36NzJyBCgAIMJ18CAB8mQU3iUCVM+D8mCAAN+mFFxQJRkOpVbxv2VNYZBMK + lFiJXlLkhOPJCxcxctyjdB1j6HNGm7obo2VuhL0fr4RMdH/xS2RIgu/GAJCjCwFADil1zkLta/me5ZD2 + SD8Tr+KohBhqAOk4ei08gR6LTqDnkuPoSa/ZbfoOxN05Dx7xGQwAayLi1JQf68p/lAegS2Vllb5k1JsU + apNreCekPLoOXZccQw8pqajSSrrmQmVKLZZjLOVaMRhkzT2AiOynKbaL1Rh9NY579gLcwuDiFognnnwa + RcUF0nklK6obKm0on0ubEJ3UsxgTn31ecgqs/J7+arWZ8LGT8vtQ7NordwgOnzymrfkqU1ny+iKrcpVV + v7vJUlomBPX4tljannvn9MUt7AVoa8oUd5/qgeCD29I9Gjn3vYwHXj2KUcsPYUT+QQxddggDSQYsO0LK + fwT98tVC0H75xwUA+qwkWXMa2Qv2wCk2V/1tD0tOQQCAlJ9zMh7+vCDkdfWZNOvfcAMAaDC56uasfZ0s + Er0mn+3U2eMYPvpeumdxcPLVAIDZcoRWm6w/eQSOFAItWbFEq66U3GTXoPX9U+XEKrqWV/Dhx5+gz6A7 + LNOhnlEWj4C5Iei5oK6jkDVz6w09AP15VvTc5mSxLkfo+6MEFkfJWzhGcoJe4yQBDcmSk0hfego9lxMo + rzqHrNXknf11xSa34GRv1g3WkX+mTv5TAUBGh7VOQZ/Q5DhyA/d4pw5ClylfkKukYiamcMo0l2UWWuIs + zq5mzz+EhCHTyI1LkIksmcqSfno6yLLOKww+ZK1Hj30AO/fsFsrqelRZlF/v7rPb21+kMfgUY9PmjQiN + TFEAEKDTMJPlD2+PAJJps+ar3nhz6VDvYrspADAThxRIQnLlujWk+IEyKWgAgIcFANqQ9Rz+3DqMXX0E + I5YdwLBlBzFkKQHA0oPov/Qw+i87jH68EXiZAgBeCtqXQWDVadkf6NftPmkk4gqJHlaw9eeSLOdPcgcO + EL76Wsn8l1i1OzftARQbFGC2/f96GzRfz4MnDqF7ziA4chzOSu+bZACAM4FBeGIadu/fofUDWKx58wBQ + YpRsGTjOXzqLpSvXykIW38A4Sao6agDQ2j1Kqw4wl0A4WhMQdbh3DvouOUQKe0gsu33LbwGF5gAgj5Q+ + b4lJSPlzyLDlkLXPIaXPWUIgvPQMspedRtbys0hfdQE5a08jfdrGPaljZsY5OIQ51NTU/M8/Wx//6QBg + xSIUnNzdwz/hdHCPsehBSCyjmkuOimRJFlaPubQSzUIKAQgQuk34BO7RObLgUhI9IlGGOyv74siqpXTI + xKL8dSgouq76sHWaZ7sgUGIVZ5ZVXsdEckm9g1TC0tOf4/40BER2wMix9+LU+ROmxGJ5kzmF5qfkLOQh + /LtnL59Cx55ZuNUxSKPLilQHWKxXlLS43jX7C9xO7j9b/2Fk+Qcv0wCADnJfOnj9lioAMLYF88JQUv5s + sjThQ18RjgQnU+ZfBqzoWvlQ7K/IPqpsBn5K7Pb936zoIFBH4dHGrZuQ1CkDLj5JwovHIMDkrJ5BMXhp + xlSZlKy/aetfpHUSluHytfNYvmqtcO97sodBn5EZfVwMqvdoNTnoodx/HiSKyLofA+ZtJ2Ul5RUQONhI + chYzsegBI7a3AIDp95sCABIFACeQQxY/hxQ/b+lZ5OWfQe7Kc1Km7fzEmtM+nUd1dxj41f+dHv5fvKjO + ZKImB+MGuPonXYka+hy5R+TuLz2GLJLsJYygR0QMINCTLOQJtHtgFVyiMoXimVcxKW9AXzoZJ5tfuMWY + 6cmGjhqHr7/bQjFphbYjoNJo520MAEVa2asE14rOEoAswJARI5CV2w+jxozD4hX5uHj1rNbWakoo/p0A + oBKCpZixYJGRBzAAgA4u00n7xfbA+OU7cNuKIxier5R/ECn/gCUWAGDpQyAg68EZAEhyyBPIXH0G8fes + RkuvRCtuPW7E4lzKoOGjUFR6RXb7KbKPkmanHH+e8JzANQGBTd9+iQFDbkd0XDdEJ3REZl4/5K9eipKy + i+Ip2OMMaDRFqC0sKab3+/4HHyCn71B4+qn77873nsdztfPAAOCoEcRwXqUV/YyVv9+sbXR9jorym8UW + BP5eAMhdehK5y3hn4xkC47Ok/GfpdQ8i5fapV9qE9hjg0Ftl/H8Ndp9/Kw9Az3I+NmnW78jFHusR0bk4 + 7eFVyCGLlb2MXKalZLmW8gU8KiJgsEglWrLkhhxA12c/QlDPeyiuTFYegKyQijbYXbnpyF02D0UI3dYz + z0/B4eNHFaeftKfaSwSWaKSlJZKgqyElLSo7T2BwiryCS5rLWWq1CqxxUvHmAMCSCygwcgGHTx5BQlpX + tJSuvQgtho2W1WKhbXPwyOv7MXL5EUn+DeLYX7P+fTRRFo1kKQEBeQJ5JFnLjyNz5Skkj1mguuN4VRYp + vz5S7RcSjw2ffCijquL61//9lr8pYeKPS9dP46e9P5DLvw1XC05oyVOeJygwCETsW/wiuWcVVdfxxcZP + Mey2u+DP/BBekWrGxFtZflc2CvpKMS9FZ84NZs5h3dB2zCvoP/8n8ZRslb9JABBhZT+IPFL+PHnUhEIE + Q7Tr32epAmF1fukcLzspAJBLMX/O4j2IGvh4cSu/+LF3tQ39nVkX/qsAQJ8c5JLHwH5D/j9P/5iHfdv2 + r+j98jd0sc7JRcvLPy6Su0wDgiVHBG0ZCLL0jOzMH9Dh7kXwTRmE1t7JwtLiYh7G8FFAIPMHPlHo0C0L + y1avQYHwvVc1nRBsKBVvoLahsImmlJJmkok/DwCMeQHOnNcX45nJU9DCKdBgD2bG2lbO4fCL7oKH1u7A + SPIAhhIADKT4vz9Z/750UK0P8mG5VjkMnOxR0bXMnL8PQV3GyTZgtTQzWhvECifP5i6ywPT6wvNXrOr+ + 9SU3Jvn4JQCglT4l32KamFQDRQVAEwAAoRcvwI8/fYf7HhiPsMgUtR7c6LWPkV57VwGBWBUGCp8hXUO/ + JISl34uMyR8TYCrvSCnpYUNuDAAHNACwlj6k+H0WW1979bePqXNLHphsaybLn0shR1j2AxVtfGIezuqa + +v/x2f9HTPj92wCAXh7kC9ErI+cPHoGpT8f2f6qyD1swnm0n17VP/nERAQNB7SOSaVXlGC67kAVcQDfq + xa+QMHwK3CJ6SbaXa86u3vEaEMQawxhsLTwCYzFo1Fh89d23soJMus+MJZ22YUFxI2lcgrKlCDMDQFEz + FtQGANgToIP+4+7tCI5MJaUP1RiEyQtwC5cpxuF/exOj15zAkGVHCAAOEwAcJgAwWTBd+Umy6HplLaUQ + gA5h8l0L4OSXIuGSWEmZx4hGYEQsvvjqC20DTpki8jQAoOhXtf6NmZItJVG+BswBAP01tRgfUmEpw/6D + e4RDIS6poyLq9LYMlFlNl/qwxIm0oXvvnZiLzvcvwqDFezFgxVH0Xaor6BEDBPQ8gC0I6DmAHE2sAeCA + SNMAQAZrGQudYW7ImvcDojLHVTp7xz7dPa2b1Pr/meW+f1kAMI8PJ8Wm/K9PbMZzXR59taoP17BZOJOt + AwHHtAICGhBw/EUAkEfhQN+F+9Fv3k70fPodBHe9k25+ongDiuM9znQ4YuTQcMdgRHw7/G3qNFlyocga + Kmy4/ktvysrbf06TZpVCJxDVqwHXyUUuQFlNIe66/2Hc0sofrV24Q5CbmyJwS2t/xGXfi9tWsvt/REp/ + /ZaquN8MAJI34UQq51LoAPaa+g08E3KV9RdgjBVQ5Gsw+i6y/hVF0idRp9Xfm2X2+TuV3xYILE1EhRb+ + QBmtVgBw7MQhvDRthvAourKr7x1lDJMZos2XGLMm3F4e2A6RfR5B3+lfYeTK4xi8/CT6LyfrT2FTHwME + DjcbBugAkLvQIhbl3y/SNABo94XObv/5uxDfZ3yVi1/McykpHf9Xevz/QeO9/5YAoAaHFAj4e4T/MSJr + /OTcmd9W9Sfk7GcCgb5c2lp2THPhFAiYEbnPwn3ou2gfcqd/h/jhL8I1tDucPNWiB1cfCxBYDgpPaYUj + o88AfPTF56isKdFomywcbTcGgJK/AwAKbACAa+cFsh1m0zffMgssWjoFGyDQ2ikMzoHt0W/qRgzihp+l + KuvfxwQAKnGqSlBs/TkOjSXPqA33TXjqAKB64gNCE/HJF18KeWWdxoPwDweABnvXoMCY+INY/VKcvXQK + cxctRtuO6aL0Lt4WPglbABDr76cBOym/Z1RXtBs7A4OX7MKQlccwmM7NQOmN4LyIRUFtLX+jEEC3/GYA + WHjABgC0MED795KL0b0LAui+i/YgZeikKvfApMnJCSl//GcM+PxbAoAZBLx8Y/6YOfHN5wYsP17Zb8Vp + AoHjSpYfEwDg7K1xkXUEZhAgLyCXQCBv0V70WbQb3Z56Cz7tRqI1z2Z7K9fQTYAg3gQEMWIJgyNS8MSE + iTh+6pi0o9YbYYHNsosmGoialF/gGnPuobSiACPGWFaLt+TFom7MnR+OtNumYOhyAsOlCgzzlh4zKiYW + OS7lp95Tv4NbbI7WFx8rAOAmq6/CMXTUGNkAVKP1+9c3avPVac4LfrG1NxaCGI1DijjFIhqlOq5LnF9S + dgnr3ngd3TIGCJGGzCj4RJJECXW6EguvhPIAGATUurfQLrche/L7dH0Oq+lIbo8mReQeib4m17+58p+u + /HyWzJK3YB8Zmf2k1Bbpt/iASF/OxSw9JNKHZRl/vQ/tx82odI/o9FxERPy/nPL/ywGAgIDWMnz7C2/+ + 79D840/3XXmmQvraNQDgLjcGAB0EpOy12JyZ3a8J3bAl+5D50iaEZD6GNn5tCQRMAGAAQZxsenWTunEo + evTOxfoNH6OipkwLB0pvQn5tAFDtwR99/pkMITHzTSu3CBmmaekWDu+ELAycvZU+/0kty3zMSnKWsevP + OZNTiB81ncIhvWlKJ7CMhX9oNDZ8+gkpfY2qv9drsf+vCABWq8GaAQC2+OVV17Dp240Yecc4eAfFyI4E + F2+zstuKxQNwYlAITUXi0KcxZN42DF15VLVGL1MyYJlqklIl0r8TAAQE9t0QAPotPYiej62t8EvKezo4 + JELc/sp/MeX/lwQA1S2oRogf+fDsH/quOvFw/xUniwdyLMVDLiYAMDwBAQF2xczu2QHDG8idvR0pYxfA + PSpL5rJlNFTYhXUgUNUCjo1dPSIRFJaMJyc+i9NnT6hKQUNTIYBt44qd5262Tm52hUWJSsg6X0O/obfj + L05qzl11s0WjtWcMOt4zD33yT4mlVyBwXBTfECbCfHELXKNzNNdfNUjx5+WGqaGjRqGwVO/5L7aa+KvX + aLjM8fnPrvvbiK7suuKzxefHqprr2LxlI+66768IjWqnNvJ46YpvCwDRhnBCl5d1ONF9C+gwAOlPr8KI + lYcxeBVZfLL+rPT9lirpL4aCXH+9RLqk6ay/KP4i5UnmLtgrwoqvrP9eQ5oCgD4CAkeQ/fLm4oiMBx72 + /IvLH5Tlr/6ff0Vd+5cEAAGBOmmMcHh4w9n/b1D+ubGD8k9eGbDimBYG2ACAgMAhuQl9WBbbegMKGHpM + eF8lCH0TZURUKJtsPAJ3DRA86MBl5g7AF5u+JAtZrlFZlTUf7xv5gJJm9+M1lQuwBoBC6VV44731UqtX + RBcxJLHytW+7Qcidv1vrl7AGgGyu/1PcGztiGhw9442auEr+xcM3JB4ffvqB5BpquenJyv3/NbL+1xuJ + 2eoDiuPv0LH9ePSpCQiNTBJ2ZDfxUFQJTyl6lB0A0NikyKPxCG6PtsMnYOC8LRi0mhX/GAbkczs0W2Bl + jftKlURX/qbr/XrSL3ehrvwk8/eK5JH0MQBgT7MAwE0+/eZvv9Ll3iVjW7t6S6nvXyXh928FANInUK9A + YPW2ut/1X3l8QP8Vx073Ey+A212PiHCihbO5fXVhpNfzAoZHcFD2xOdSSJAzawsSRr0kTSG8VMJVeNsS + 6DHBEhLw9J8vewThCI9LwfS583Cl+IpWLvx5HoAxMddU4qsJiymlMfICrhRdRu6w29GCmYJI+VmYC7+1 + TzI6P7oOOcvPSKyvAwC7/lnLTyLzle/gEZctbbCqOzJG3H+2/gOHj0JByWU17muwINsDgAI7HkBzzxWY + wMwkMg9QoEkpCoovYtmqVWjbKV22HPHYNfcmWDL8jZXfzTtK+PTcNIafgLb9kP4kWf0VBzBwxRFJ8PWX + WF9zw+ne99EMQp70SRxsVvkFAHS3f4Fm/efrQkq/YK/JA7CEAH1Z+TUAYG9j4OK9p/u8+OGADh63/k5K + fTW1//OvrGP/0gAgG4fq9dmBhx0GrjzRnTyAPQwA/bW4rh8hft9lGtJzKGCD9OYEId84du/6LNqDro+v + gWdyHzh5KeV38TV5AQQIIsxeJGQgkRh5513Yf/iAWmmG8pvPATTyBApMDUCNPQHzlGCdUIiX442PPoZ7 + EHktHjHCOsvi6BaN4B53q5LfsrOq4YSVX7rOTqHt2PnkHqtNt5z7cNXCHL/gaKz/aL02769anmWS0S4A + XLfxTMzKXWjnucYin7NBJfhq6W9v/u5bCj/uhqdvtAxuMQeBMyk/dyc6CwjYj/uFQp5+1zWoLRIHPoYB + s7/GkFVHlLufTxZ/mbLA/STZpwEAG4DFBPwkeUsONAsAfEYk02+y/DkLlOQu2K0s/wLlCfQ1JQL112HX + v3/+wT2jlu7q7pCp2ntr6+r/519dv/7lAUBaJRu0N5u1yWHgiuNx/fOPbuLR1wH5RyxAoCUEzYkeqfNq + ANCHy4R6SLCYbuLS3cia8glC0+9Ha78UOPnGGA0k7r7xBgDIDgNfXhAZKl2Eb767HhVVam1ZneHy30T/ + uskT+HkAUEpewFXkDLgdbZjlRgMAJ/cYOAZ2QueJH5HFP2eEAtn5Z5A9ew/8242SWQhxqbVGKFau2+68 + A0XlXG6s0DgQS60mGRt7AL8UAPTYv0A8ohOnT+CFqTMREddRpja5bdeNl3x6KcV38lFA0Djuj5IqgJNf + LALb9UX64ysxnK0+KX9/Uvz+7HKz8i85YLH6cs+1XJAGAErsuf02pT47AKDcft0LsK4C9BUAoMelBzcN + XXkozqHtFw7qzDb8z7+Dbv1bAIAaltDe8LitDkNXHvUm5V9DUqcDgfIEVFunAQTmEqFVBxd7AfsodtuL + fvO2I2HMVLQJ6SAcA9IsxN6AH4sCAA8ST1YgzygEhSbhyQnP49zFsxISsILWakok1rReoxUzzfrb9wSa + ywVYAEAGk1CGhflrNJr0aBmA4p5+HhAKyXsKWUtPqvmJZdwzcRbt7l8FR//2QrfmotfKmQsvMl4WfErd + v0Gn5y6zGfk1JeqafH/XTY07tln9Qq2nX+1IKCi+jPw169CxWx9p03Ux9upFittvK9YAoCi9XCM7ou3t + z2Pggu8wbPUJcvmPGeAv1l5Tfj3cE2uuW/5FFjGAQE/y2WT4LS6/cvvZ8hvWn0QqS6a/10d1Atb1WbJ/ + zeDlB7wd7vjKwXxWfwOAf0hI0ECewOcOo9YcazEw/8hkkhJO/PTXQoEbA4ASheB70Z8e+xMQtH9wJVyj + MhUICGmFxuLqqyicPX05MRgLD2/eFR+J/oNHYduObaT8ZYYlNQCg/tcEgGLxNA4cO4yo5J5SDtQBgDv7 + nMN7oOsLG5G7/Ay5/qeRO3c3fNrfJqPS4gHoSTPPcNx5z70oqyon619tEKM0BQBqqclNAAAaAwC7+zzT + sHHrdxg4+h74BCUYvAPG+/GOsg8A3pYKgDM9Brbvj5zJb2LY2uMYsPoUBiw/aii/JPqW6NWf/c0CACt9 + Dilw9qJ9jZQ/xyretwYAw/rbAYC8xQdKcpcemTxs1fEWDj03OGg5q38r+bcDAGkdriMQcJjj8PC7J/8w + aPmhkQOWHTrFyZ9+Wumn7xKb9szFdoY46LAoENhHX5MnsHAvuj/zLjxTB8vOQTcfbQOxJu6GRBMQEAiQ + BUtN64q169agvFLV7VUsrUmTc+2NiS4bK1mhqTuwUGLnytoS3P/wBJkHkKWdXALjR1L0sP4TyfXnvYDn + kXLXErTiuj8zCLOSycBMFALCuOf/c63rr0KtNtM296jZfxuW3wZ75ckCqwGmhgZrxVf9+2U4d/k8nn15 + FsLiOkmTlZs2rWfdwWcfALj27+wdAseAOMT2fxgD53+HIWuY5PQY+q1Q3Xz9pAPysEX5rdz8AyJ65cfc + tZfDyq6LVuIzkn0L9tiIxfrn0dnIJdEBIJdCyNwl+0/lLT0w8r63j//BwWGmQ3Xtv5/y/9sCgLlCwDIo + /1A7igW/1kFATwI1BwAKBBQA9OWyDmd36cb2+ttnCOo2lhQnWVN+3kQca9VCzEDA3gCDQGBwDJ545ilc + ZA59lN9Ek9CNAMA8KVhgdAZyW/JnX30Fn5BkmW9XtNcx0inHXkCP6T9K/79n2gj5uQvvsdesqRMp1B33 + 3IXSyiKN5luRmKhx6KY2HBfbzQFYAEAb3zVZff68m7dtQ+aAO6TD0sXI3Ec27t+3AwDO3uHCfuwW1xVd + xi/A0BUHMYhc/v48xGMV4nGl57CK+RvF+brltw75DIu/wBLbW1l+TeHNkqdbfgaMRSqBrIUSX+ctO9hO + P3+1df+eyv9vDQBWycE7NjsMWXHIizyBhf2XHqpgD6CvlhAS5W8SANQBEpEDQoeCwoHM6d8gesBEOAep + OJpBwM0GBHRRrmwQht0+htz0A4qBWMKCsib6BW4WAAqsWoN5CvF6yVX0GXInWrnwei8L7XVLt1gkjZuP + Dk+8LglNiZtlcCZCXO+gqGh8/f1XFrYffUc9bMlLi34BABRI/35x2TUsXr4OMRSmOIvnwW58hJTv3OwM + 8LhIcs+i/E68zMU/ARFZdyH35Y8xeIW5z+OwUdIzeu8XWybydKtvFj0cMOr6mtU3hJN87OYbsluJrvwL + 9hhlPwYACR0W76ugs7JwwNKDXg6j9WTfv6/+/NsDgBkIHHp86DBu3dH/HbD00Nj+Sw6d7KeXgWxiQ1tR + Ax77rbO/i/iQbEcaKZV7eE/VP29H+VUsG60OsEcYeqT3wbfff08KVS1NNk15ATcHAPbosCuwYt0b4lbr + bEEcAnAy0CtxAAI73y7UYUaizTtK9iPcPf5elNeUaPyFptXUDaV2WnSLfgYAFIvLf/j0Cdw7foIsthDw + 8dEBwH7rLocD/HNn30jyriKEyMUztic63TcLA5bswMDlFOMzvdmiQ83mcYx7uMi6nGeU9EhyFtgoPsu8 + PZrsJtllJToICABorb8cMmQt3ncyd8nesXeuOfi/Dp3ec/h3yfL/VwCAuXNQCEaWHkohAPiY0LreAICF + 1lNdjWTBfg0A9mkgsAf9yP3r9sgqeCVkyUIJ1yZAQA448+uRsiWmdMW6199EeXWxKSSwbhT6pQDAXsXx + syeQ2iGdvIAwWeDpJDvwotHaKx6OzLFnZNmjBbgCIuKx+buvtHn/Um2t+c0AQFETAKATfRaipqYc6z/5 + Ep0yBin+BZN7b693X030RUtewoUHfXwIxHyjEdZ9DPq99AmGrTyI/hLjHxKOg74m9p3m7l2ORthhO7mX + Q/dUB4BssvKGkOJnz2XZRbLTkCYAoJ68h48p5k/Rz1dN3X+G8v9HAYBVSDBms8PQ5YfaEAhMIBC4zLXb + PtLPvd/+AZKDwgBgEfW7e+gQ7kKvZ9+DT/vBaKO3qTLrjHd0I6smh5uU0j8oAROem4LL1y6JteWtNXV2 + yUftDAE1aqQpsPo5Z9effWEqWjoHkeXXKb4jDZ4/Zy9L3z8vTrnjnnEorSpGrdCcWVafy+ruJjb9WMqA + 1g09hvUnMDt/5TwmvTAdQZHtxOVvBIh2RSk/Z/gl5g9KRsrISRiycCeGrDwu2X1m7OmrWXw1kKO78PuN + +6RLNkkWPy40sfbYsfyG4s+1r/i2AJC3cLck/sj1v0znZ8KgZQfaOIz+8j/C5f+PBgCzN+Dg8KLDgs0X + /1/fJfu79V20fyPF+PV5cij2NylmABAQIG+A+8A5Buw1+RMEdLpNlkyYl2k0mk1ngCBldKOYduTtd+PI + scPiutfpvIFSKixqAgAKbggATDe+c/8ehMW2U7yBJgCwWH/l/gdHxmHzlk30urUCAPpilJsBgHrTe7Eo + vmrq+X7XTuQNuVMqJe4+MXa8omi7AOCiNfVwpt8jpid6PbIEI5nchJWfp/Yo3u+/+Ij07ueJS3/AFL83 + vl9ZZlmoAMHyc1Z+pfhZLGT1s+bsItlJ8hPJDk1+sgMAe+op9t9Iyt9tztcX/p+Dw/P/UVb/Px4A9H4B + +YC3bXIYkn/Que+ifRPzFuy9oCxDE0Awb5+V5GqSreUGsl78EmG970Vrzzhxv3UQMIurd7TW5RYlAy6Z + 2f2xbcdWCQdUclC13eokl7ZJQdt+elmwIUs21M9ryBWvrCvDYxOfRwvnQMV1r1UF2OV3FqZf7hUIxv0P + P4CKau5PqJL4Xym+Un6gxCbpV2Qw8TS2/tfkOV6pvnLd20hon0mvEylz+CKNMvzRJlGlSLUKPhKtfeMQ + 1G00cl/8GMNWHZMBHt3t77dY8Rvqw1wWD6Cx5bcr89W9zZ5vSfKJu0+KnTVXV3yz8lsAQHIA83ex63+h + z8I9Ewcv3efscJtK9NXV/2cq/380AFglCH83z+H17Wd+13fR3jSyDOtJquUwzbcIH57sedaigMCSNOJs + cc4rWxCZ8zhaucfKYlJnbbmmi5X1VYefWXfcPCPQoXM6Pv7sU3Lf9aYh26RgkZ18gFK+WhImw6ypL9AA + oEAs+U8H9iMiuatMBuq7EXQAcCLlDI9PxbafvhcGZF6Npix/qab8ppi/iTl98QCko69AwOLcpTN4+Jm/ + wSc4WY0VCwlHtF2GHmsgiBLl5zFsx+D2SBzxPIYs2I7BmsuvN/RIhl8vsy3cbzdEM7v9WbbhgH7/5msu + v3bPlLtvT/EbAUA1xf7r+y7cm/bmD8W/49r+f5q7/18JAFbewKjPyRs40IJcyrFkKfbbU3pdsoyv92qH + SQMCngx7ZSti+zyDVl4JwjXvZCzZNAGAdAxGy2pxN/pZdGwaFi9bivKqgkbVAXsAUFdHlrfuGmrrLACg + S21dMYqqynDfhCniAVgAQL0uA9NDTzyFymryOurKtbi/RBRZLD8svHtGO69NU48+vce/v/fgfgwcebeR + zHMzEXGqkp4u0YZYgIEXc9J1iMlAx78ux6Dlh2SHocxumDr59IqNEe/bKL7Z8mfNV5JtBd57jXuVNU+P + 83c1o/gWACDl30+u/9hh+ftbOIz8/D/e6v/XAYC5eYjJGRwCVjpQSBBIyvwKHZrLtsqfOXdvI1EegSod + 5ZH0mb1deAdbeifICipnY822xRPQ+eq4aYgZhwJD4jF5you4XnRFrSszFpI2DQA6CFST4lfJYxGqyJO4 + Ul2B5+fnq7VenmrJhygcPUbGt8OPu39S5UiN499Q/ka7/SwWX9X1FUWXGuIpxsbvv0Hn9P4CLrrVV6L1 + QYhrrwln9k3CngJPJAZ1uQ0Zz34g7dr9ZF5f79ZUiq8P1uTp8T6X3WysvGH5WeEbAfZeifMztey+ivMb + K3v2bCWm5y6Td/BKnwW7Ah38lsrRqP0vUfz/SgCwGirq8q7DhA9O/D53wb72dIheJym1p/jWAKC8gFyO + FxfsQd7c7Ugc9oJQbskeOgIAJ69IIwmndhFwokzrHCRL6OUXibsf/CtOXzilbRcqMXbr2fcArqGGhJW/ + qq4AlfVk/esrsPX4CXTPGSIhhhqs0QgzvMLw9LOTUF1bpZh+NX5/K+tvBwAs7byqu6+ythCvvrsecWm9 + pCffYvV1AIixAYBok/KT1WfX3z8Jsf2fRN7sbULSkbt0P/qw6JN7WiefGQAkhl+gACDT5KFl0df8fdZ8 + e96aUv7MuSrJlzn7pxsBQCnJ6zlzf2o/4b2jv3do/9q/3RDPbwDwa4UFI790GLn80J8odswjRf+cpMou + AMxRYm4gyZ2/C33m/oikES+hpW8iWnuEyyIKJ33nnr6owkctrRDhZKFPCAYMH4lDRw9Zr8M2DQrVmt1+ + tvys/OT6F9SW4kxFCR6fOp3+Xrj02UvS0Ud1/8W3TcPew7tQy1uRuevPvOXHzuCOdR+/Uv6rhRcx5ZUF + CIrqoM0SNC7tcR3fxTfa1PBjyQU4cwkyrBPa3TEdA+fvRN7SA9I/nydiM6HHk3iaiOs/36LsGfPsgDE/ + Jwpvkay5enZfKb+SHSTbDREQmL29ih4/J8XPG75sz58chn74X+Xu/wYATQOBg8NtGx0GLN7fMmve3pGZ + c/d8kzFnTw0JWDJJdADInrvHqCPnzNuJ3AW7KCSgcGDo8xQOxKGNZ3jjmry5TOijMRF7hyI9rx927dmt + kY8WWS0S0RN+ulTXFaGktgLnqyrx2fbdiEnpKgQZiiknRgaUXL2D8fxLk1HdUCFcf/Ua268tABglPj3R + J4p/XbyR/ScO4ba7HyFPJUmVNI0GHus5fd3auzRq9omGZ1RPdB2/nNlx0G+x4mW0mqIzKb9Vm+58S/6F + lV9krroHxr0gF1+sPUkG3QeWTCvF12W7WWpI8b8hGTlg0c6WDiM2SEPPf7Pi/wYA9qoF/F+/Tx36LNjr + RAdtTMac3VtICAh2q4PHTSRz9piaSUgIBLIIBLJmb0XskElo7RMvXoC+fddcKlTeQKzQjrEb7ewVgq69 + c/Hdj1tVOGC1FssaBCrI+l+sKcfB4lKMe2QiKX84hRZRwl0o04nekUhs2wH7j+wVth/7O/6s6/sWPv5r + Evdv3LYVXbMHS6jioXsVMutgoeOWzD9bfhZeyMlhgEi0hAK+yXnIfPpNDF6yD32ZeGXRXmOgxt4Yrlk4 + g581T1n5jLma8mtKbiXztEdS/PQ5PyFjtkXSZ+0QyZilFJ9kCyn+mP4Ldzo55L0tt/g/pY33NwD4tfMD + xurycQQEHzn0XShAMIoAYFPG3J2VGVJLZhCwAEAmPZcxjw4fubqZs75H7MBn0MYrniTC8ASsy4OWLLqa + iAtHu8698eXmjVpOwLpEWFtfRHF/Ea7UlOFYZSXe2boTYQmdSDkj4OEbKeLpywM3wXh28mQCiyrF9Ksp + vTnx1xRfH68j+/ybr5HcNVcAxVMAxX43n54DcPVjIYvvFwtnEif6TEHtByGX9+8t2W8ovi65NwAAc8OO + WHix+LtFyZuSdFZ4k/QmxdekkgBgE7n8o/otIMXv8w6p/RAH8z3+TX4DgJsAgkF0bj5x6L9oT6vMeTv7 + EQCsz5qzq9CIN/XDOJeszpwdYo0yX/lWVlKxJ8C5ACevpgGAFYkZh7gtNiG1Cz74aIPRqae3DdeQC3+d + 4v7DZRXYWViJe5+bKgszdOUXITBISE7Fnn07NetfaifzX2QDANc0y1+ML7/9GqmdM+BGSu3hFyuly5sD + ACWs/L6p/ZH7/AYM4sSexpzL/fQiMk9vT+nNir/H5Nqz4u8SsVVye2JS/EKS9eQJ9CPFb+UwcD0pfo/f + FP83APg7LxL/d+dnDsOW7f1TztxdXUj5F2XM3nk6fbayQuJ6zqYDSI+9CAR6T/sWYVkPUygQZ9Uk5GoF + AAoEhHPQT831RyV0xOvvvI3aukpSWLWPoKCuDPvKyvFjYQU+PngGCd1zSUE162+4/2F4euKT9O/KJfNf + 31DaKNNvdv0bRPmvo4Ys/0dffomUTlmi9EzU6W5k+aObBQBd2PX3is9A1sR3MJAt/8K92tyFNcVWo758 + cfctJdcMw+LvblbxM0xxvun506T4dE9+6jJ4yZ4/OYz+WG7Zb2f3NwD4tcuHDg6jP3N4+t0jvyf3Pzx9 + 9q7H0mft/D5j5o4KtkC9NOlNYNDzxY0I6n637B9w9bbdZWciFxHeQT0xGIHg6GQsW7Uc1eTyV5M131dW + ic8uV2PjlSq8sOJteAbHk9KT2++tK38UYhM64KedP5JSW+r+jQDAyu2/hmp6/q0N6xGX2o3+TpzwHsrf + 87k55WfQ4kePmO7o8cRqUn5FrJJnh15LOvI0xTdcfLb4ovhK6elammTnzQBABX39PcljWXN3hj/5zpHf + O4z6WJJ7/43lvN8A4J+WLNTKhz0orvRf7tBn/m7HzFk7sjNm7chPn7njZPqsHfW9Z/2I3jN/QA+Kh/27 + jCbFjlcUY9oeO95kq2+zVQCghNeAccLNPywO02fPwaniAmy6VoHXTlfjtf2X0LnfbZLs4xjdkxN1rJhk + /R9+7HFUVZfLqvP6GwBAHUlVbSFWvf4mohI7i8X3ZE/ExrLbegHm5wQs/AmAIjuj68PLhFMxb0Fj5c8x + jeBmzttrEbH6exopf+9ZP5lkh5VoAFBPcjJjzo78rLk/ZfddsMvRwX+pg0P3N/+tmHh/A4D/pIYihySH + 393+qcMjrx/6fc7sn4IICMaR8r/fe8bWi71nbkWXZz+AT9pQYRbS99lbAQBTkPvFG56AuyQHI+EdFIW7 + Jz2P1w5dwOqTlXhm5SfwCE0yOAk9CEy4ChARlyTDRjzvX6uP+1oBQJFpC/E1lFVfx/ylKxEazYnEBAol + YpXlbwIAbK2+zpLsHtYOaXfPwoCFu62WaKhmKc3qz9tjdOilk8KnS1Z/j+HuWxR/pyYWxe81c7uI9v1F + Uvz3M+b8NC573s6gv7594Pe/p5DMwSHhv7aB5zcA+FdMGiatdXAY+ZHDsCU7/5g5e1tMr5lbH+w+84cP + Ozz86gXv2JwGfT25AICUAuO0/QMmABAlI2Xzj4RXSBzGPj8H6/ZeRfqIR7WmHOWmMwC4MNvPg/ehoppL + fmz9y4TqC2YAkB1/12UXX0nFVUybvQB+YW0170MBjodvMwDgFy2rt0Xx/emRJSgJSUOfRd6cHVK7z52n + Td+J0u+VhF6WVq/PmLdHknrpunB8rwsrP0kvcvl7zWL5SVP+HQ0kF0g+JI/qwcw5P8UMW7rnj+ziO7Rd + 91tS7zcA+JcXB4ec1xwc+r3h0HfJT3/sM2N7VHTvR8e5+Ca95uoXc5QAoEpfTKq2ENkCQAw8/WPF0oYn + 9sBdE+ciKLabtBRLN6EGAoGhcfhSmH4rUF+nKb/VuK9lvr+8uhAvzZwFv9AEq9cxSyP3n7P8/tGi9Px+ + PAPo9QPjEd3nYeS+shXZc/eJS8/NUVlz9xrxvarX75THdJPy9yaltycMAD1n76wiADjaa+ZPr5EnMC5j + 9s6owYv3/tFhwPsODnnvOWhsPL+drd8A4N/LKxAwSFsq7mr7zGF/8A5N8nEPiM9x80t4iQBgEwHABQKA + WlsA8GCF848jiYdXaCpcAxKt8gicMOwzYBAKi9WOPxX76+O+5pHfIlTUFmHWgmWk/In0t6OUJbcHADoI + 6N/7K3Gn9+IVEA+PwARE9ByDzJe/JoU+SHH8fqTP2yPKbVF6i6STNKX0JLUkF0g2kTfwEj3mZM7d5XPX + 6gN/cLid3Pssi9L/Zu1/A4D/gJxBg6WkqP0XFtP5Fq+g5AiPgITBHv7x09z9474ghTtFUuFO1tY9gECB + FM/dX20q0sduZZmpdzjmL5qnVpRx3V9q/6Va7b/Y6O8vrynA7IULERiWpNx9DVwsyUdrZVcSp4kGAPRe + PAiAAjsNR88XvkDm/MPk2u+XVt10ie+VspsVP90AAHLr55CFn7urguQUyRe95u6a1nvursHkLUQMWLL3 + Fr4Wv7vrSwcHl0W/ncffAOC/BwzEOzD9F5nY5c8+IYkBHoFxPUnpxhMALHMLiPvGzT/+FAFAibNPTL2z + gEAs4lM64MChPajnHX9a7K8DgJrtL0BFzXXMmDeblD9RJQ7Jw2Dlbw4AXP3MABAryu8WFAff5Ex0n7Qe + 6UuOIn3hQWNYJ13cfCsAqKevS0hOkXxDsoxkPAFFz4wFuwMGLNv3Z/6s/7/7N1GY9IHFyv+WyPsNAH4T + a0B45rmpvwuN63SLT0iKv0dAUntXv7iRLr5xk5w8I1beducdX5ZXFu0j5T9X31BWTMpf1dBQUq97AGUV + V/HKnFmk/Amy6lwPMTxIsT0MBbc87+Znqk7oP5O4n1z/iI7o8NAC5OUfRNaSg/VZi/dVZS7cW5y+YM85 + Uux9GfN2fUmyksKASZnzdo0kaZ+zYJf/wKV7b1my5dLvuInqd/dudHBIXPdbLP8bAPwmN9VvUF9vFxT4 + v45d03///kfv/AWo8qyvL4uqbyjvQQAwnADgEQKA6UDFqg0ff7AhNDrxe3ff6P0UXpwkRb9IUkhfl5PU + kILXWwCAvvaL4+fKSQpJLpL3cdIjIH6/R0Dy94HdRm/ov3jHqtwVR6bnLj3wSM7S/cOzl+zrkbVob1Tu + or2eg5ft/8tT75/6vcPwDx2cHtns8OcHSNl7vmUoe/1v1v1fVv7/go10uREXjmAAAAAASUVORK5CYII= + + + \ No newline at end of file diff --git a/segugio/Gateway.cs b/segugio/Gateway.cs new file mode 100644 index 0000000..213c65d --- /dev/null +++ b/segugio/Gateway.cs @@ -0,0 +1,151 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Threading; + +namespace segugio +{ + + public class Gateway + { + + public Thread threadProcessMonitor, threadProcessLaunch, threadProcessScan; + + public ManualResetEvent startThreadProcessLaunch = new ManualResetEvent(false); + public AutoResetEvent startThreadProcessScan = new AutoResetEvent(false); + public ManualResetEventSlim pauseEvent = new ManualResetEventSlim(true); + + public MainForm mainForm; + + //ProcessMonitor handle for starting process monitoring + public ProcessMonitor pm; + //ProcessListManager handle for updating views + public ProcessListManager plm; + //ProcessScan handle + public ProcessScan ps; + //process launcher handle + public ProcessLaunch pl; + //utility cross Class + public Utils ut; + + //Settings + public SettingsManager settings; + public YaraRules yaras; + public ConfigExtraction mlwConfigEx; + //Get Segugio process PID + public uint thisCurrentProcessPid; + public string applicationName; + + //current program directory + public string directoryPath; + public string desktopPath; + + + + public Gateway() + { + thisCurrentProcessPid = (uint) Process.GetCurrentProcess().Id; + string executablePath = Assembly.GetExecutingAssembly().Location; + //desktop path for dumps + desktopPath = Environment.GetFolderPath(Environment.SpecialFolder.Desktop); + directoryPath = Path.GetDirectoryName(executablePath); + applicationName = System.IO.Path.GetFileName(executablePath); + + + + this.ut = new Utils(this); + + this.settings = new SettingsManager(this); + + this.mainForm = new MainForm(this); + + this.yaras = new YaraRules(this); + + this.mlwConfigEx = new ConfigExtraction(this); + + this.ps = new ProcessScan(this); + + this.plm = new ProcessListManager(this); + + this.pm = new ProcessMonitor(this); + + this.pl = new ProcessLaunch(this); + + + //Thread for monitoring processes + threadProcessMonitor = new Thread(new ThreadStart(pm.ProcessMonitoringLoop)); + threadProcessMonitor.Name = "ProcessMonitor thread"; + + //Thread for launching new process + threadProcessLaunch = new Thread(new ThreadStart(pl.LaunchProcess)); + threadProcessLaunch.Name = "ProcessLaunch thread"; + + //THread for Scan Processes + threadProcessScan = new Thread(new ThreadStart(ps.ScanProcess)); + threadProcessScan.Name = "ProcessScan thread"; + + threadProcessMonitor.Start(); + threadProcessLaunch.Start(); + threadProcessScan.Start(); + + } + + + + public void TriggerProcessLaunchThread(string processToOpen, string additionalArguments) + { + //passing process to open path and arguments + pl.AddStartupInfo(processToOpen, additionalArguments); + + + + //sveglia il thread + startThreadProcessLaunch.Set(); + } + + public void Pause() + { + pauseEvent.Reset(); + } + + public void Resume() + { + pauseEvent.Set(); + } + + public void Stop() + { + + // set isRunning to stop thread loop + pm.isRunning = false; + ps.isRunning = false; + + + + //awake all thread waiting... + pauseEvent.Set(); + + startThreadProcessLaunch.Set(); + startThreadProcessScan.Set(); + if (threadProcessLaunch != null && threadProcessLaunch.IsAlive) + { + threadProcessLaunch.Join(); + } + if (threadProcessScan != null && threadProcessScan.IsAlive) + { + threadProcessScan.Join(); + } + + //join all threads to stop them + if (threadProcessMonitor != null && threadProcessMonitor.IsAlive) + { + threadProcessMonitor.Join(); + } + + + } + } +} \ No newline at end of file diff --git a/segugio/MainForm.Designer.cs b/segugio/MainForm.Designer.cs new file mode 100644 index 0000000..763a58c --- /dev/null +++ b/segugio/MainForm.Designer.cs @@ -0,0 +1,328 @@ + +using System.Windows.Forms; + +namespace segugio +{ + partial class MainForm + { + /// + /// Variabile di progettazione necessaria. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Pulire le risorse in uso. + /// + /// ha valore true se le risorse gestite devono essere eliminate, false in caso contrario. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Codice generato da Progettazione Windows Form + + /// + /// Metodo necessario per il supporto della finestra di progettazione. Non modificare + /// il contenuto del metodo con l'editor di codice. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(MainForm)); + this.label1 = new System.Windows.Forms.Label(); + this.logViewer = new System.Windows.Forms.RichTextBox(); + this.groupBox1 = new System.Windows.Forms.GroupBox(); + this.button_refresh = new System.Windows.Forms.Button(); + this.comboProcessList = new System.Windows.Forms.ComboBox(); + this.label6 = new System.Windows.Forms.Label(); + this.comboCommandLine = new System.Windows.Forms.ComboBox(); + this.button_Launch = new System.Windows.Forms.Button(); + this.fileChooser = new System.Windows.Forms.TextBox(); + this.label3 = new System.Windows.Forms.Label(); + this.button_chooseFile = new System.Windows.Forms.Button(); + this.label2 = new System.Windows.Forms.Label(); + this.groupBox3 = new System.Windows.Forms.GroupBox(); + this.treeView1 = new System.Windows.Forms.TreeView(); + this.openFileDialog1 = new System.Windows.Forms.OpenFileDialog(); + this.groupBox2 = new System.Windows.Forms.GroupBox(); + this.yarasMatchedBox = new System.Windows.Forms.TextBox(); + this.scannedProcessesBox = new System.Windows.Forms.TextBox(); + this.programStatusBox = new System.Windows.Forms.TextBox(); + this.label7 = new System.Windows.Forms.Label(); + this.label4 = new System.Windows.Forms.Label(); + this.label5 = new System.Windows.Forms.Label(); + this.groupBox1.SuspendLayout(); + this.groupBox3.SuspendLayout(); + this.groupBox2.SuspendLayout(); + this.SuspendLayout(); + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(9, 575); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(60, 13); + this.label1.TabIndex = 3; + this.label1.Text = "Log Viewer"; + // + // logViewer + // + this.logViewer.Location = new System.Drawing.Point(12, 591); + this.logViewer.Name = "logViewer"; + this.logViewer.Size = new System.Drawing.Size(913, 118); + this.logViewer.TabIndex = 4; + this.logViewer.Text = ""; + // + // groupBox1 + // + this.groupBox1.Controls.Add(this.button_refresh); + this.groupBox1.Controls.Add(this.comboProcessList); + this.groupBox1.Controls.Add(this.label6); + this.groupBox1.Controls.Add(this.comboCommandLine); + this.groupBox1.Controls.Add(this.button_Launch); + this.groupBox1.Controls.Add(this.fileChooser); + this.groupBox1.Controls.Add(this.label3); + this.groupBox1.Controls.Add(this.button_chooseFile); + this.groupBox1.Controls.Add(this.label2); + this.groupBox1.Location = new System.Drawing.Point(19, 12); + this.groupBox1.Name = "groupBox1"; + this.groupBox1.Size = new System.Drawing.Size(504, 127); + this.groupBox1.TabIndex = 8; + this.groupBox1.TabStop = false; + this.groupBox1.Text = "Start New Process"; + // + // button_refresh + // + this.button_refresh.BackgroundImage = global::segugio.Properties.Resources._118801_refresh_icon; + this.button_refresh.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Stretch; + this.button_refresh.Location = new System.Drawing.Point(359, 89); + this.button_refresh.Name = "button_refresh"; + this.button_refresh.Size = new System.Drawing.Size(35, 32); + this.button_refresh.TabIndex = 19; + this.button_refresh.UseVisualStyleBackColor = true; + this.button_refresh.Click += new System.EventHandler(this.button_refresh_Click); + // + // comboProcessList + // + this.comboProcessList.Enabled = false; + this.comboProcessList.FormattingEnabled = true; + this.comboProcessList.Location = new System.Drawing.Point(88, 94); + this.comboProcessList.Name = "comboProcessList"; + this.comboProcessList.Size = new System.Drawing.Size(265, 21); + this.comboProcessList.TabIndex = 18; + this.comboProcessList.SelectedIndexChanged += new System.EventHandler(this.comboProcessList_SelectedIndexChanged); + this.comboProcessList.Format += new System.Windows.Forms.ListControlConvertEventHandler(this.ComboBox_Format); + // + // label6 + // + this.label6.AutoSize = true; + this.label6.Location = new System.Drawing.Point(12, 97); + this.label6.Name = "label6"; + this.label6.Size = new System.Drawing.Size(78, 13); + this.label6.TabIndex = 17; + this.label6.Text = "Parent process"; + // + // comboCommandLine + // + this.comboCommandLine.FormattingEnabled = true; + this.comboCommandLine.Location = new System.Drawing.Point(88, 62); + this.comboCommandLine.Name = "comboCommandLine"; + this.comboCommandLine.Size = new System.Drawing.Size(306, 21); + this.comboCommandLine.TabIndex = 16; + this.comboCommandLine.TextChanged += new System.EventHandler(this.comboCommandLine_TextChanged); + this.comboCommandLine.SelectedIndexChanged += new System.EventHandler(this.comboCommandLine_SelectedIndexChanged); + // + // button_Launch + // + this.button_Launch.BackgroundImage = global::segugio.Properties.Resources.segugio_main_logo; + this.button_Launch.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Stretch; + this.button_Launch.Enabled = false; + this.button_Launch.Location = new System.Drawing.Point(400, 23); + this.button_Launch.Name = "button_Launch"; + this.button_Launch.Size = new System.Drawing.Size(98, 98); + this.button_Launch.TabIndex = 1; + this.button_Launch.UseVisualStyleBackColor = true; + this.button_Launch.Click += new System.EventHandler(this.button_Click_launchFileStartScan); + // + // fileChooser + // + this.fileChooser.Location = new System.Drawing.Point(88, 29); + this.fileChooser.Name = "fileChooser"; + this.fileChooser.ReadOnly = true; + this.fileChooser.Size = new System.Drawing.Size(265, 20); + this.fileChooser.TabIndex = 9; + // + // label3 + // + this.label3.AutoSize = true; + this.label3.Location = new System.Drawing.Point(12, 65); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(77, 13); + this.label3.TabIndex = 15; + this.label3.Text = "Command Line"; + // + // button_chooseFile + // + this.button_chooseFile.BackgroundImage = global::segugio.Properties.Resources._85334_file_open_icon; + this.button_chooseFile.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Stretch; + this.button_chooseFile.Location = new System.Drawing.Point(359, 24); + this.button_chooseFile.Name = "button_chooseFile"; + this.button_chooseFile.Size = new System.Drawing.Size(32, 32); + this.button_chooseFile.TabIndex = 11; + this.button_chooseFile.UseVisualStyleBackColor = true; + this.button_chooseFile.Click += new System.EventHandler(this.button_Click_chooseFile); + // + // label2 + // + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(12, 32); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(70, 13); + this.label2.TabIndex = 14; + this.label2.Text = "File to launch"; + // + // groupBox3 + // + this.groupBox3.Controls.Add(this.treeView1); + this.groupBox3.Location = new System.Drawing.Point(12, 145); + this.groupBox3.Name = "groupBox3"; + this.groupBox3.Size = new System.Drawing.Size(919, 427); + this.groupBox3.TabIndex = 12; + this.groupBox3.TabStop = false; + this.groupBox3.Text = "Process Info"; + // + // treeView1 + // + this.treeView1.Location = new System.Drawing.Point(7, 19); + this.treeView1.Name = "treeView1"; + this.treeView1.Size = new System.Drawing.Size(906, 402); + this.treeView1.TabIndex = 29; + // + // openFileDialog1 + // + this.openFileDialog1.FileName = "openFileDialog1"; + // + // groupBox2 + // + this.groupBox2.Controls.Add(this.yarasMatchedBox); + this.groupBox2.Controls.Add(this.scannedProcessesBox); + this.groupBox2.Controls.Add(this.programStatusBox); + this.groupBox2.Controls.Add(this.label7); + this.groupBox2.Controls.Add(this.label4); + this.groupBox2.Controls.Add(this.label5); + this.groupBox2.Location = new System.Drawing.Point(529, 12); + this.groupBox2.Name = "groupBox2"; + this.groupBox2.Size = new System.Drawing.Size(402, 127); + this.groupBox2.TabIndex = 14; + this.groupBox2.TabStop = false; + this.groupBox2.Text = "Overall Analysis"; + // + // yarasMatchedBox + // + this.yarasMatchedBox.ForeColor = System.Drawing.Color.Red; + this.yarasMatchedBox.Location = new System.Drawing.Point(69, 53); + this.yarasMatchedBox.Multiline = true; + this.yarasMatchedBox.Name = "yarasMatchedBox"; + this.yarasMatchedBox.ReadOnly = true; + this.yarasMatchedBox.Size = new System.Drawing.Size(327, 68); + this.yarasMatchedBox.TabIndex = 19; + // + // scannedProcessesBox + // + this.scannedProcessesBox.Location = new System.Drawing.Point(296, 25); + this.scannedProcessesBox.Name = "scannedProcessesBox"; + this.scannedProcessesBox.ReadOnly = true; + this.scannedProcessesBox.Size = new System.Drawing.Size(100, 20); + this.scannedProcessesBox.TabIndex = 18; + // + // programStatusBox + // + this.programStatusBox.Location = new System.Drawing.Point(58, 25); + this.programStatusBox.Name = "programStatusBox"; + this.programStatusBox.ReadOnly = true; + this.programStatusBox.Size = new System.Drawing.Size(122, 20); + this.programStatusBox.TabIndex = 17; + // + // label7 + // + this.label7.AutoSize = true; + this.label7.Location = new System.Drawing.Point(186, 28); + this.label7.Name = "label7"; + this.label7.Size = new System.Drawing.Size(104, 13); + this.label7.TabIndex = 16; + this.label7.Text = "Scanned processes:"; + // + // label4 + // + this.label4.AutoSize = true; + this.label4.Location = new System.Drawing.Point(12, 56); + this.label4.Name = "label4"; + this.label4.Size = new System.Drawing.Size(51, 13); + this.label4.TabIndex = 15; + this.label4.Text = "Matches:"; + // + // label5 + // + this.label5.AutoSize = true; + this.label5.Location = new System.Drawing.Point(12, 28); + this.label5.Name = "label5"; + this.label5.Size = new System.Drawing.Size(40, 13); + this.label5.TabIndex = 14; + this.label5.Text = "Status:"; + // + // MainForm + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(943, 721); + this.Controls.Add(this.groupBox2); + this.Controls.Add(this.groupBox1); + this.Controls.Add(this.logViewer); + this.Controls.Add(this.label1); + this.Controls.Add(this.groupBox3); + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MaximumSize = new System.Drawing.Size(959, 760); + this.MinimumSize = new System.Drawing.Size(959, 760); + this.Name = "MainForm"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Segugio"; + this.groupBox1.ResumeLayout(false); + this.groupBox1.PerformLayout(); + this.groupBox3.ResumeLayout(false); + this.groupBox2.ResumeLayout(false); + this.groupBox2.PerformLayout(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + private System.Windows.Forms.Button button_Launch; + private System.Windows.Forms.Label label1; + public System.Windows.Forms.RichTextBox logViewer; + //CustomTreeView treeView1; + private System.Windows.Forms.GroupBox groupBox1; + private System.Windows.Forms.TextBox fileChooser; + private System.Windows.Forms.GroupBox groupBox3; + private System.Windows.Forms.OpenFileDialog openFileDialog1; + private System.Windows.Forms.Button button_chooseFile; + private TreeView treeView1; + private Label label2; + private Label label3; + private ComboBox comboCommandLine; + private ComboBox comboProcessList; + private Label label6; + private GroupBox groupBox2; + private Label label4; + private Label label5; + private Label label7; + private TextBox scannedProcessesBox; + private TextBox programStatusBox; + private TextBox yarasMatchedBox; + private Button button_refresh; + } +} + diff --git a/segugio/MainForm.cs b/segugio/MainForm.cs new file mode 100644 index 0000000..4aa6717 --- /dev/null +++ b/segugio/MainForm.cs @@ -0,0 +1,516 @@ +using System; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Diagnostics; +using System.Drawing; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace segugio +{ + public partial class MainForm : Form + { + + Gateway gw; + string processToOpenPath = ""; + HashSet visitedProcesses; + + private ProcessTreeView _treeViewManager; + + //flag per determinare se è stata disegnata la prima lista processi + public volatile Boolean firstProcessTreeCreationIsMade = false; + + //flag per determinare se sto aggiornando la lista processi + public volatile Boolean processTreeIsUpdating = false; + + //signaling + public IProgress progress; + + public MainForm(Gateway gw) + { + this.gw = gw; + InitializeComponent(); + _treeViewManager = new ProcessTreeView(this.treeView1); + + visitedProcesses = new HashSet(); + + + progress = new Progress(updateSignal => + { + switch (updateSignal.Action) + { + case UpdateSignal.UpdateAction.Idle: //Idle when first process Monitor loop has completed + programStatusBox.Text = "Idle"; + scannedProcessesBox.Text = gw.plm.trackingProcessesList.Count().ToString(); + //update parent process combobox + updateParentProcessesComboList(); + + //update commandline combobox + updateCommandLineComboList(); + + //update log + writeMessageLog("Ready!"); + break; + + case UpdateSignal.UpdateAction.ProcessScanStarted: //initialize on process scan + programStatusBox.Text = "Running"; + scannedProcessesBox.Text = gw.plm.trackingProcessesList.Count().ToString(); + createProcessTreeView(); + break; + + case UpdateSignal.UpdateAction.CreatedProcesses: + scannedProcessesBox.Text = gw.plm.trackingProcessesList.Count().ToString(); + UpdateTreeViewNodes(updateSignal.NewProcessesList); + break; + + case UpdateSignal.UpdateAction.TerminatedProcesses: + // Gestisci l'aggiornamento di un processo esistente + // Ad esempio, potresti voler aggiornare il nodo esistente nel TreeView + updateProcessTreeView(); + break; + case UpdateSignal.UpdateAction.UpdatedProcess: + // Gestisci l'aggiornamento di un processo esistente + // Ad esempio, potresti voler aggiornare il nodo esistente nel TreeView + yarasMatchedBox.Text = gw.plm.getAllYarasDetected(); + updateProcessTreeView(); + break; + case UpdateSignal.UpdateAction.NewLogMessage: + writeMessageLog(updateSignal.LogMessage); + break; + + + } + + }); + + this.FormClosing += MainForm_FormClosing; + + } + + + private void MainForm_FormClosing(object sender, FormClosingEventArgs e) + { + + gw.Stop(); + } + + + + + + + + private void button_Click_launchFileStartScan(object sender, EventArgs e) + { + //if no scan is occurring + if (!gw.ps.scanHasStarted) + { + + button_chooseFile.Enabled = false; + button_Launch.Enabled = false; + button_refresh.Enabled = false; + + comboCommandLine.Enabled = false; + comboProcessList.Enabled = false; + + + + + //pass to process launch thread arguments + gw.TriggerProcessLaunchThread(processToOpenPath, ""); + } + + + } + + + public void updateCommandLineComboList() + { + + //disable object + this.comboCommandLine.Enabled = false; + + ////delete all combolist process + this.comboCommandLine.Items.Clear(); + + String[] commandLines = gw.settings.GetSetting("DefaultCommandlines").Split('|'); + foreach (string commandLine in commandLines) + { + comboCommandLine.Items.Add(commandLine); + } + + //enable object + this.comboCommandLine.Enabled = true; + + } + + + + + //ComboBox to populate the list of possible processes to use as parent of the process to launch + //(via pidSpoofing) + public void updateParentProcessesComboList() + { + //disable object + this.comboProcessList.Enabled = false; + + ////delete all combolist process + this.comboProcessList.Items.Clear(); + + //get processList + Dictionary onlyRunningProcessList = gw.plm.UpdateAndGetOnlyRunningProcessList(); + // System.Diagnostics.Debug.WriteLine($"onlyRunningProcessLists... {onlyRunningProcessList.Count()}"); + + + // Associate the dictionary with the ComboBox + this.comboProcessList.DataSource = new BindingSource(onlyRunningProcessList, null); + this.comboProcessList.DisplayMember = "Value"; + this.comboProcessList.ValueMember = "Key"; + + //find the preferred process index + String preferredParentProcess = gw.settings.GetSetting("PreferredParentProcess"); + int index = gw.ut.FindIndexWithText(this.comboProcessList, preferredParentProcess); + + + if (index != -1) + { + + + this.comboProcessList.SelectedIndex = index; + } + else + { + //failover to explorer.exe + index = gw.ut.FindIndexWithText(this.comboProcessList, "explorer.exe"); + this.comboProcessList.SelectedIndex = index; + } + + + //enable object + this.comboProcessList.Enabled = true; + + } + + public void writeMessageLog(string message) + { + DateTime now = DateTime.Now; + + // Convert to string including milliseconds + string formattedDate = now.ToString("HH:mm:ss.fff"); + this.logViewer.AppendText($"{formattedDate} {message} {Environment.NewLine}"); + this.logViewer.ScrollToCaret(); + + } + + private void button_Click_chooseFile(object sender, EventArgs e) + { + using (OpenFileDialog openFileDialog = new OpenFileDialog()) + { + openFileDialog.InitialDirectory = "c:\\"; + openFileDialog.Filter = "All files (*.*)|*.*"; + openFileDialog.FilterIndex = 2; + openFileDialog.RestoreDirectory = true; + + if (openFileDialog.ShowDialog() == DialogResult.OK) + { + + processToOpenPath = openFileDialog.FileName; + fileChooser.Text = processToOpenPath; + } + + if(processToOpenPath.Length>0) + { + //enable launch button + button_Launch.Enabled = true; + } + } + } + + + + + + public bool HasParentInDictionary(uint processId, + ConcurrentDictionary processDict, + HashSet visited) + { + // Avoid infinite loops by checking if we have already visited this process + if (visited.Contains(processId)) + return false; + + visited.Add(processId); + + // Find the current process in the dictionary + if (processDict.TryGetValue(processId, out ProcessInfoTracked currentProcess)) + { + // Check if the parent PID is present in the dictionary + if (processDict.ContainsKey(currentProcess.ParentPID)) + return true; // Il genitore è nel dizionario + + // Otherwise, recursively check if the parent has a parent in the dictionary + return HasParentInDictionary(currentProcess.ParentPID, processDict, visited); + } + + return false; // The process with this ID is not in the dictionary + } + + + + private void UpdateTreeViewNodes(ConcurrentDictionary processiNuoviDaAggiungere) + { + //aggiornamento flag lista processi iniziato + processTreeIsUpdating = true; + + //mi creo una lista di tutti i nodi disponibili + ConcurrentDictionary dictExistingNodes = new ConcurrentDictionary(); + foreach (ProcessTreeNode rootNode in treeView1.Nodes) + { + dictExistingNodes.TryAdd(rootNode.PID, rootNode); // Aggiunge il nodo radice + AddChildNodes(rootNode, dictExistingNodes); // Aggiunge tutti i nodi figli ricorsivamente + } + + + int countAddedProcessToDictionary = 0; + + //Preliminary check to add any root nodes + HashSet visitedProcesses = new HashSet(); + + //for all running processes, check they are root + foreach (var runningProcess in gw.plm.trackingProcessesList.Values) + { + //if the process has no parents + if (!(HasParentInDictionary(runningProcess.processID, + gw.plm.trackingProcessesList, + visitedProcesses))) + { + //if the process is not present in the current list of existing nodes + if (!(dictExistingNodes.ContainsKey(runningProcess.processID))) + { + //then add it as root node to the list of existing nodes + ProcessTreeNode newRootNode = new ProcessTreeNode(runningProcess); + runningProcess.treenode = newRootNode; + + //add it to the treeview + treeView1.Nodes.Add(runningProcess.treenode); + countAddedProcessToDictionary++; + + //update the node list + dictExistingNodes.TryAdd(runningProcess.processID, runningProcess.treenode); + } + } + } + + + //now add any root process nodes + while (countAddedProcessToDictionary < processiNuoviDaAggiungere.Count) + { + foreach (var existingNode in dictExistingNodes) + { + foreach (var process in processiNuoviDaAggiungere.Values) + { + //if the existing node is a parent node of some process + if (existingNode.Value.PID.Equals(process.ParentPID)) + { + //and if the child node (process) is not present inside dictNodiEsistenti + if (!dictExistingNodes.ContainsKey(process.processID)) + { + ProcessTreeNode newNode = new ProcessTreeNode(process); + + + //get the node from the process list + if (gw.plm.trackingProcessesList.TryGetValue(process.processID, out ProcessInfoTracked currentProcess)) + { + currentProcess.treenode = newNode; + //then insert the node + existingNode.Value.Nodes.Add(currentProcess.treenode); + + //update + dictExistingNodes.TryAdd(currentProcess.processID, currentProcess.treenode); + + //increment + countAddedProcessToDictionary++; + + } + } + } + } + } + } + + // expand all processes + this.treeView1.ExpandAll(); + + + //Process list flag update completed + processTreeIsUpdating = false; + + } + + + private void AddChildNodes(ProcessTreeNode parentNode, ConcurrentDictionary allNodes) + { + foreach (ProcessTreeNode childNode in parentNode.Nodes) + { + allNodes.TryAdd(childNode.PID, childNode); // Aggiunge il nodo figlio corrente + AddChildNodes(childNode, allNodes); // Ricorsione per aggiungere altri sottonodi + } + } + + + public void createProcessTreeView() + { + + + this.treeView1.Nodes.Clear(); + + //start iterating RootPids + foreach (var currentProcess in gw.plm.trackingProcessesList.Values) + { + //if the current process is the parent of the launched process + if (currentProcess.processID.Equals(gw.pl.launchedProcessParentProcessPid)) + { + + ProcessTreeNode newNode = new ProcessTreeNode(currentProcess); + + //add to list of currently tracked processes + currentProcess.treenode = newNode; + + //add to tree + this.treeView1.Nodes.Add(newNode); + + // Avoid passing the entire list to prevent redundant searches and potential circular references + AddChildProcessesRecursively(currentProcess.treenode, currentProcess.processID); + + } + + } + + // expand all processes + this.treeView1.ExpandAll(); + //empty visitedProcesses + visitedProcesses.Clear(); + + if (this.treeView1.Nodes.Count>0) + { + this.treeView1.SelectedNode = this.treeView1.Nodes[0]; + + } + + //update flag created process list + firstProcessTreeCreationIsMade = true; + + } + + + + + + + private void AddChildProcessesRecursively(TreeNode parentNode, uint currentProcess) + { + + // Avoid infinite recursion + if (visitedProcesses.Contains(currentProcess)) return; + + + visitedProcesses.Add(currentProcess); + + Dictionary childProcesses = gw.plm.getChildProcessesFromPID(currentProcess); + + foreach (var childProc in childProcesses.Values) + { + //create new treenode + ProcessTreeNode newNode = new ProcessTreeNode(childProc); + + //add to list of currently tracked processes + gw.plm.AddTreeNodeToProcess(childProc.processID, newNode); + + //add to tree + parentNode.Nodes.Add(childProc.treenode); + + + AddChildProcessesRecursively(childProc.treenode, childProc.processID); + } + } + + + + public void updateProcessTreeView() + { + //process list flag update started + processTreeIsUpdating = true; + + //now update the information for every node + foreach (var currentProcess in gw.plm.trackingProcessesList.Values) + { + if( currentProcess.treenode != null) + { + currentProcess.treenode.updateRunningStatus(currentProcess); + + Rectangle nodeRect = currentProcess.treenode.Bounds; + treeView1.Invalidate(nodeRect); + } + + } + + //process list flag update finished + processTreeIsUpdating = false; + + } + + private void button_refresh_Click(object sender, EventArgs e) + { + updateParentProcessesComboList(); + } + + private void comboProcessList_SelectedIndexChanged(object sender, EventArgs e) + { + // Get the selected item + if (this.comboProcessList.SelectedIndex != -1) + { + var selectedPair = (KeyValuePair)this.comboProcessList.SelectedItem; + + //set info to ProcessLaunch + gw.pl.launchedProcessParentProcessPid = selectedPair.Key; ; + gw.pl.launchedProcessParentProcessName = selectedPair.Value; + + } + } + + private void ComboBox_Format(object sender, ListControlConvertEventArgs e) + { + // Get the key-value pair + KeyValuePair kvp = (KeyValuePair)e.ListItem; + // Set the displayed text as "Key - Value" + e.Value = $"{kvp.Value} - ({kvp.Key})"; + } + + private void comboCommandLine_SelectedIndexChanged(object sender, EventArgs e) + { + // Get the selected item + if (this.comboCommandLine.SelectedIndex != -1) + { + + //set info to ProcessLaunch + gw.pl.customCommandLine = comboCommandLine.SelectedItem.ToString(); + + } + } + + private void comboCommandLine_TextChanged(object sender, EventArgs e) + { + // Get the current text of the ComboBox + gw.pl.customCommandLine = comboCommandLine.Text; + } + + } + +} diff --git a/segugio/MainForm.resx b/segugio/MainForm.resx new file mode 100644 index 0000000..83c606b --- /dev/null +++ b/segugio/MainForm.resx @@ -0,0 +1,1568 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + 56 + + + + + AAABAAEAAAAAAAEAIAC1UAEAFgAAAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAAAFv + ck5UAc+id5oAAIAASURBVHja7L0FYFVntj3O/72+93sjFSTu7u4GgQhJIIQEbwuFFuruU3c3SnG3ttSd + lrpQWqAtbvEECxJ3W/+9v++cc8+999wk0M5MZ6Z01pyb63L2+vbe395rDwLw//2B3x96enrUy4Ms/02Z + ceU5IbGjzvUOSXJzD4gPd/OLzXb1iZpOuM3FO+o5F+/oNYQPnb2ithD2OnlHlROOEeoILYROQg8BCnqc + faI7CS3KfY4pj+HHbiF8SFhDtz9HuI0w3dU3JtvNPy7cMyjBLTgm/dzJ0688x/J98nu3+Cx/4HeGQX98 + Cb8rmBnQA48++18h0aPO8wxM9nHzi08jo7vExTfmAcJqMsLPCXsIh8k4G5y9ItoJPWTw0MPJKxI6Q7cC + Pd4m9PdzpOdy8IykYyQTRzu/JoFfew+B3wu/J3pv0Ze4+sWmETH4BEenn3f/w0//lxEp/IE/COA/Fr29 + vYYGHxo78q8eAfG+ZOCjyZhuJix38Yn51tknpsLJO7rRYtWGs3e0gJNq6ARnM9D1wmgjBJy8I8+QAPi5 + o6Xx0/PZ03M5eCpkoIOjuE80XRboke+V33PMt06+scudfONudvGLH+0elOwbGp/9VyNC0H0nf+APAvg3 + /sJ1/4KiR5xHbnSoi2/UNGfvyGfIQD8joyTDiWqVBmq9EpuBV3kySidhmBKOnuH0N4OM3oMRTkYp4WhB + AJYGT8SjvZ4jPZe9u8Qw9wgMpecZRs9n7xEl4RlDiBZwUGDvJeHoFUPvLYZej+ATq6KViKCC8JmzX/wz + Lv7x09wCk0KDYjLOsyCEP86TPwjg33OVzxgz5X+9gpM8yUUuIEN7kgztS8JRWrm7nHiFFqu4XGHV1Zeh + ufMGBOAojD6CDFDC0SNMARm8uwJPxQNQwgFnvfH7suETvNlwI+ESEI+g+FFIyMxHev5kZI6/EJmFFyJ9 + 3CQkZI1DaGIGPEMTYUf3HeJK5ODKhBBDry2hGr947/wZyPidfOKIAOLg5BuvgC/HdRGOOvvGfenqG/+k + m19CgVdwsmcmfUd/eAd/EMC/TSwfnZzzZ8+gxHBa6a8kw3+VVtliQrveiJ2UVVy462IljxZG5OypwAYB + yLicV+VwDQ7uOsNXoD63lhvwNq34wkh9YxGenIvZN92FtW+/j5/270dZTSWO1B/F8cYTqGk4geP1x1F1 + ohr7yw/g222bsfqNDbjloceQM3UmAhMzYU8GPtSNyMCdVnvPaF2YEkuIJwJgw09QEGcGFx+BdhffWP5u + XqXv6UqPwITwqKTsP/+RO/iDAP5lVnv1ZI1LG/Nn7+DkSPeA+BvJ8D+gE/oooZdOcGF0qqst4nd2td3C + YOcaCgdetdlwfGJEPG1H7redK63s5II7ebLxKoblJQlCxN1nQADsAfBK78KuOV12C0xEWt40PPDCQmzd + fwCNnW3oQRd60Y5utNLlFg299DfoCHFktNF9mnG6uQY/HdyBFW+8gmvvugcjx06Bf3QqXPzYM+D3xqRG + pOBNhu+TqBCA9ARo9RdwIS+BScDZJ0Z6I74x9F3FHCV8QN/fjZ5BCZExKTl6MvjDK/iDAH5fRl80bc45 + PqGp/h6BiVe6ByS8RzhGJy9cA+gE948FEQBcBQHwCc4uOBmyexjc/SIxMr8IN9/3MF5avR4vv/chNnzw + MZa9+iYenbsQV996D3InzURIYg5cyWAFMXjoEm8DIgAJTgzyY7xCU1E08yqsePsdlB0/QubeQcbcIYy+ + u5cMXgORQG8beunY28NoE3/39LYroNuICEDPAHp8B93n+Onj2Lb7Z7zyzhu4/8lHcfGcyzE8uwD+EcPh + 7C/zAQ5edPSKE96Bi0+MOSkqnoke9N0dI7zHXhSFUP6FUy875w8y+IMA/ino7u4xM/zgmJF23iHJ48jw + V5DRlxN6CGD0RQCOXmEYNWY8GcpbOHL6MDp7m2ml5RWYDAud9BLd4H+8Ip9oOo0fD+zFyx99hNsffRaj + JsyCZ0iqcLU58dcXATgpeQF7txAy/ERMnHMdXv/sC5xsqVNer41ewdLwJUzG3a4ZuUSXDh3CYzCBb+8U + t/HjWzvqcfhEJb7/eQtWv/Uq7n7qKVx01TUYWTABYcmj4BZEhOAtthfNE5IEVx+NAFT0EOg7jl/hGZQ0 + jr97PRGov80f+IMA/l4rvjjZLr7sunN8w1JDaDW6g+L7LZ6BCa0e/vFwJ7jxMUBCEAAbP8HFT3H//Tg7 + HoGCadOxv2SPYljNZIAN6OqtJ/OpRUt3HcqPleHrH7/GhvdexaK1izFvxSI6LsczCxdh6pyb4Bcxgggg + ypgAOAlIRwdXDi2C4ROeSEZ3Ld76/GOcaD5N1MIkw4TTpLj4rcLF7+2VhMDufXtvB461tmP3qWZ8W92A + TSW1+ODQaby9vxYf7TuJzcVHcfBoDU421qO9u01QlQQbfqcgsR6FHKCQApNDJ71OU2cdjhLp7Ti4E+98 + 8iEeePo5Ch0miLCBtyo5ScmhiqtCBDpPQIC/VyLYVo/AhC2EO7xDUkKmzrr6HDVX8IdH8AcB/F227mLT + 8v7iE5o8igx/MRl+JQECtNp7+MXBjeFvgm7lEhBJN3L9Y0Zm4+d9u4Xx9/aQIfZKY+zuZWM6gdWvrEJ6 + zlj4h/NzsuseSkYRRkbBK3oYGTln+SN1BBChYRjdNtQtmG4LQ0xKFq6/6z58/uN3qGuvFTF7N78OGun1 + GsggGwnNhBbt2NTTgW1H6zH3u6O4+u1KTHulHIVrKzF2TSWyV5djxNJSpD35E4bfsAaZs+7GhDm34Kb7 + HsH8Vavw2bdfo/zIYbS1t0P+61U8mU5BCr29jA5BBAxJEJ30XwcqjlXi4aeegV8YhQbktbh6y50Jy7DA + RAA6og2Ir3QLjF/sGZw0Kjop5y9/bCn+QQC/aXwfGp81xCc0ZSIZ/rtk8HWq4ZPbD08GrfqSANjQY6wM + Xw8n/yg8OX++OOl7yPj1BMBG2dhyFNNnzoSDSwhcdRV9LpxR91J3C6IkPKJppY+GvWskhrrQak8rf1Ds + cEyZPRtLX1mNA+UH0dHdJJJ3bPTS8Pl1TAQg/24S5FDZ2IQXt1Rj2ssHkL+ynIy+GmNePoKxG45h3Osn + MGYdkcCLW5Fy02pEjL0OgbG58A5Kos8eQ4hCQFg80rLGYs5VN2DRslX4bsuPqDp8BM1tnFDsVghB/6+X + /uMgp0N4JS2dzZi3eCn8ghPos0eKz2xJAnovwAxMBIEJde6BCe96hiRNDInLGPJHnuAPAvhVhh8Uk2FP + sfZMz+CUL8n42wjQG78a67Pxu1N87yaMP1ojAf2qxXkAZzpGp2Vjf2mxiPW7yTh7e5rMjLK7txbvf/g2 + kpOz4ewWCgcCx/EuXvS8XBPACUD3CLFzYO8aDjefWMQm52LmFddhyaoV2LnvJzS21ZBhScPv7aXXoPBC + Bb+GCfVkeHWCCErqG3DfxgpMoFV+HK34BeuqMW79YYx/tQoTl+9E7v0bEDv5VngljIUjEZ4ThTEu5K67 + kpG6UazuRgbqTt6Nu08EIRxefhEIiUrGyOwCzJh9Ne555GEsWb0SH322CT/+tA179u/FgUMHcKjkAOqb + TxIJyPxHa2sLbrntXrgpz+9iUbCk9wLMES/zLoH0mwQlttFv9KVnUNLMgMgR9n8QwR8EMKDmG1OFXoa9 + d3DqbDL8zR7BKZ0EsPGfKQGoJCAJgPfcY3EtndytXWT8Pa3SA+g1J4AeMsj2rlPYuWsrHn/qaRRMvggx + ySOFMQVHJCE0MhkJwzMwfupFuOvBR/HmRx9gf+VeNHXUiMf2EnoolOjpaVSM35wALImgq/c0mruasGjL + YUxaU4HC1dXIp+PY1UQCq4qRdd9r8BlxMYZ6xWCYcyB5Gv6wcwukEISIyStCxOvsrksSIALwJSLwY8TI + y758XSQ8fCPg5R+JgOBYhEUmITJuOKLj0xEVl4rHnn6KPjN5Kb2tIlz4eedORCeMIo9HkoA+MThAAlB+ + o4ROum4zXZ4dFJ2uEUH3H81JfxCAiq6ubi25FxabNZgM/xIy/G/Z8D2DyPAJfPQg4/cwJACOQVXjl9CM + Xt3KEgQQR49JwoebvhLJsp4eXp2bRQKwt7fRzDi7e+rIGE4LIjhVW41DxTvxy+4fsH3X99i5fxvKq/aj + rv4IOrvl6i0NvlZ4Dz29TAANZs9pvupLyNvqiQBqsbumFle+UYYJ5PIXrarC+BVk/CvKMPymZXAOGUWe + RhgcyRNxdJW7CQ4eIdq2okjYccbeN0aQgCQ+zn/EK8dYERoxQTJ4J8TNlwlTIU16fEziKOzcvVckC3n3 + oZ1Cgetv/hu9TpgWBqhJQf3OgEEIIMOyICvQb5n4LRH4JaGxGYPVZKHy2/9BAP+Zht+luftxw8f8xSc0 + tZCM/VOvoNR2z+BUsc3mRUciBDoSCYQkSwKwIAEPXnEC+SQ0Gb8lnH1jRUlses4kHK05QW5/hyAANn4j + AuhhAug+hS5CT89p+TcZeBdqaX08LS53d0vwbXqwUdta7Q0JgDyFDb/Q6r+aCaCKCKASE4gAch/aCLeI + HGGEYjtRbCuGyZXfM8xUWairKnTVYvR4MwIQxuqjEAQZvqtPnAhd3H1iBAkwgTz29Ity56C3TRDBR5s+ + g09InLYjIAjA2wYBKMZP8b/4XfSemh70e7XT8VOvkOTC6NS8v6hhgXou/EEA/2Fx/vTLrj/HJzQljU6Y + DV5BSU1egcl0oqSSoafBIyQNgggEJAF4mhEAnWx8wgWy6xmrEICsq5cua4yCWFHwwhVx9z3yJBlvO3q6 + ydUV7q5tAhArek+tPJKhd3Wf1qAavzkByPsKbwANAwDF/+QtNHc24PHPSlC4qkKu/iurMGF5GaImP0jv + mZt91B4D2VjEW4yckzAiABNidVCIQQFX/TEBSMQKT8DZOwbpo4uIHI8pdRBtOFF7AuMnXSxeUyZBzQnA + KiHIOwL9E4A8BiU2EZlv8A5LTbvkspvO+U/OD/xHEUAnMb0aB/pHDPejE+VZOiFqxEnD0BOAAF9OgXEO + IB6eZPgeZsbPCatIWeXnHa00xRA8Y+AXmoTNP/4gi2V61JLavgjAHHqjN1z9hftfKwx7IATQDen+n2yp + xe3v7BEuf+GKKor7KzHupT3wTpml9v8rXYYKPCLMewt0SToj78cKStmvCuEpCCKIxlvvvU/fTxcRE5ci + d2LhkhXaTogkgBhBALZ2BDgc81BIoC9o4Vxwcg15eM/6h6f7qedF53+YN/AfQQDd3d3aqh8en3mBd0jy + FWTMe/UnBXkA/RKAyfg59qeYngzfw8z4JQGoffeyVJfgFokp0y9DA1ffcVltb4tSV88E0GRAAPWGJGAT + vTL5JxKAA1r9FZC3cLyxHre8sQ/jl5eT608eABFA/nM/wT2ySHYRepoIwMkCKgFYthcbhkFqJp+MWDYI + 6YkgVtQ2zLnmBrR2clFUp9g23Lt/P+ISsy08APNkoGUugPMy/RGAp4kARI7HKzh5L58TfG6Yqgq7/yCA + f6fs/gvzl/+Xb1hqqrKX32F9YtAJwQQQmKIZvQnJZis/x/zs9lsTgHnvvoMioOFEbvOq9etlhZyy528r + O38m6Om1jOkbzowA0Iia5kbc/sZeFCwrQ9HyKhRRCFBABOASWSgKiywNX9UdUAnAyWvgAiOWBKAnAvaY + wuOHY2/xPlEg1EMk0NregsuvvkkQEZOrK5Erbzdq+QQrAogfEAF4BSUryd1kzRug86KDzw0KCVOfm7dU + qBj9J0iZDfo3z+4L4w+JGeVAP+z9xPJHbcWHAoIA6KSgE8NdB/67TwLwtyYAqZrD1XkhiIobjpLSUpnl + 1oz/1xNAL86eAHoFmtBERvbIB+QBLC3DRCIA4QUs2AOPpJlKJ1+EQbuyOQE4ekUOnARsEACDxUyWr10r + qgd7emTPwcuvvwY338jfjABEKGdMAOp9+By5Pyg63eE/IUn4b0kAHR2dwvBvv+ex//YLS80kw/+C0ENA + nwSgeAJmhh+ov3+C4v7LEMAtIEbARADm+nmMIc5BmDX7KrR38L5/21kQQL3Ova+ziPHrDa7rf9WXlX+y + /qCT3tPq78n4lxVj0vJqQQCFy8sQXHC3lADziRDNOk4Gq738rJFnRgBWiNEIwMEzFDMuuxLNbVwW3SF2 + BcqqypA8cjScPcM14zffcRg4AXgIg1ehCwGCrM6LHvr7C9/QlMzb7n7kv/lc4nPqDwL4F1HSFeW7cRnD + aNW/j4y+hg1fRf8EkKicIHL/X54c6m3x8AiwIACLHIAlAdg5B2L5qlWiwEXu/Z8hAcCSAOoMCKDujAiA + jb9LoFk0An1ZXIMLVxwgD6BaJAILV1ZjxC2vwd5/uOzUEzkNReGnD4HRMzd+tcAnTgkDohAanYpde3eL + AuGuXtlifOe991MYFSJXfZ9Y412AfgkgSfym7rpV30QAKYbnBV1Xw+cQn0uqN/DvFhb82xBAe3vH/6eo + xgyiVT+RjH2juuoPhADUPX1xFC5/ioJkmR+w4QEI4/eL1oxfTwD27uEICY/H3gO7AO6dNyOAxrMggHoD + D6B+AB5AowWalKagZtEVWHy6Hle9fBBFy3j1r0QBEUD+vN3wGXEFhTFxpt0MofEXJUVLzGAihzNd/fUe + gBAF8QjHSwuXiB4B0S+BNnz82Sb4BKquf6zcTjQkARMBeOhg8gCSBMRvKvI6yUo4kKT7jc3DBeUc2ugX + npaonl/KufYHAfzeEn1JI8f9iRj7CvrBytVtOxUDIQCttJfcfg/OBQSa8gCW93ELiNOt/jHW8b8nN+gE + YeZlc9Da3iD2/nuV0l/ZeXfmBNBXSW/faOoDzajvbMXjG0tRuKSMCKAC41ZWEqqQdssbsA/MIuOPJ8Qq + BBBNXgGrFpmrE0mCiBqQxLhm/BY5AK4N4E7ACVNnoKGZPZUuQQDHaqqROXo8XDwjBQG4+VgJhujbhMXv + xIVBanGQZXWgKQfQvzeoO3fK+dzic+zfKUE46N/F5Q+KSnenH2gR/VCtqqHbgq0f211z75MkApOUXECS + 2e3C+M32/40IgJt2QvDyK6+IZBYTQE9Pkyj/PTsCqD9L42/shwBaaKVtxwf7ajB52X4ULS8nD4AIgIuC + lhUjfMojsPdJgTN7At6Kwq8Q+4w2rf6aCOivJwBuePIPi8MPP29VugU7xNbp3fc9DGd3zgPEKcIq1iSg + 3wrUCCDABFOyV9nxGSAB6Eiglc8xPtf+XUKCf1kC6OjsNLn84Wkp9ON8Y+nq/1oC8AhMsr49UDF+Xfxv + PUSDVkn3KMQmpKOsvFQo43SLtl9VaUchAQNDNhm+uuoPtLS3SddYNED0cpswow1VjS249fV9KFxaivFk + /IVrqlGwrhL5C35ByPg7Ye+bQobPXkBcn3Ll/bn9hvdRicCLEUOhUwienjdX0RFoF8dNn38Gn6A4s0pA + WySgN3pDAjgDWHqQCr7hc049/5Rz8Q8C+Eehrb1drPo5BRf/r29oyiX0g1QYxfpGP96ZEYD1bZrxKwSg + lv5aynXbOQXjqqtvQFdXm6Kt12JAAI0CxgRQr6z6AyGAxrMgAElIXWgRkmCdve14e+cRTFq+F4VEABPX + HEbhWiICIoGCxbsQOfNpOIVkCS0/IVV+lgRgvDWoJwAuCorE+GkzUNd8UpMaqzl5HNljJtBrhKvCoX0S + gJt/vE445OyJwAYBMCr43ONzkM9FPif/IIB/UBMPf+GRidkX+IalPkIuWSMBljD4wc6AABiJZgSgxv+W + q78kAEu9/kg4uoZgw2uviz1tIbelKOua1HdMMLUDNyrGrA8PGq2SeCpxmKCEFr2quIgC7bKl4TfrRD9Z + D7BNiIIea2nH3e/vw4RVJZi0tgIT1lYTqlBEJFC0qhjp974Dr1GXw47VfT2jTSrFNgkgSunmMyYGtcmH + VYpdRH2ABIcUgVGp2PbLVmX3RBYGPfzEU3RbaJ8egHWrsDUB2OgYtEoe2jB8AZ/QJEajb1jKI3wu8jn5 + r1gv8C9DAPomnqDokR5k5OsI3UbG3xcJWBKAKfuvtPZanDDqbWr2382i9p9hufXH2f/ImOEoLjmkuLGK + lHav1NuTJNBiYfy6zL4o8a2n+9ebrfi9CiDQqEOTUlbcYoBmU8+BJv8lZb1VsU8pA94h6vC/rzyFWesP + oYi1AdZVC4xfX4nxL1dg/CuVyFu8E9GXvwC3qPGw94iHg4dxDYAIE4SKEWsGRPZDABbyXz4xgkTnLVys + KwrqxJZtWxAYmSgakFx8BkYARh5AfwTgPnACgHIOruNz8l+xqWjQv1qyzz9ieLRPaOqXfRm+MH6CFxu8 + EQHwPrDK9FqiKN5i1Yg3iCP5Pqrsl/nqLyrkPCKEtv8w52DMuHQO2jrIUHvbFWPTo9XCOFUDlgbNbn+P + 0AVoQFd3PTq669DWWYuW9lNoajmJ+qbjOF1/FDWnDgvF3bJjZThQXYY95cX4pfgAfjq0Hz8fPIDdpaU4 + UFWBkmOVqDhejerjR3C45giqa6pRebxKQTU9x2EcPX0cpxpO4WhDHZ7/4iAKl+/GhNVl5AlUYtK6Ckxa + X46J6ysw8dVqTNlQiXHztyLuyhfhljQJ9mSMQohUmz+oQMwntCSAKA2qd2BEAPx9XjTzKrS0srfSIfIo + Dc2nMPHCi0V7svAazpIA+qwB0W0dWhKAjx7C+JMViHPuS//wtOh/teTgoN+/y28q6fULS82iL3qXfoXX + r/SWq79nqISXgQfgrsKQACzdR53Kr07pRz/cw4nr5hUpbjvXQCxYuliRx24TxTbtXU1obK3DybrjqDpW + joNl+7Fj7y/Y/ONmfPTpx3jtrTewbPUavLBwKR55Zi7uefRp3HrvI7j29vsw+4Y7MP3KGzHpkitRMPUy + 5BTNRGb+dIzImYrEUUWITstHeHI+QuJzERCbDf/YTATF5SA8cTxihhchLr0QcSPykThiDFJG5CF5RA5d + zkFSep5AyqgxSM8eh6wxRcgpmITh+dMQPGo6QnOuRsTY6xFRcAsiCu9A1MS7EHvRo0iYMw/Jd7yCrMc+ + wtiH3kbC5NvgGZaurPy64aSCCCQpmBNApBksCUD1DmISs7G/+KDwTHoVb+X5ec/DhUiWcwWuPjF97gb8 + 2hyAFQEEJ8M3WB5teAa7+Bw1lRB3/0EAv0Wm/8HHnv8virUm0xdcqTd0Y9dsYATgYUUACQYEYA2T0o8u + 9leMnzvaWKvPmVbD5xcswYb3PsSj85bghvsfwyXX3onCi69F1vjLkJRzESLSpyAo9SL4JEyFc8xk2EdN + wZCIyRgcMRUXMCKn4YKoi3BB9MUYHDsdQ+MvwdCEGYTpsKPL9vEzCBfBIXYKnKMnwSVmAh0L4RJXBLeE + InikTIbPiBkIyLwcfhmXwzW+UAz6dHAMgqNTKBxdaMV2CRdwoMsOLqGwcwnBMNdg2NORr7dzJW+GPs8w + PipgAdJh7tEY6hkHO99UOIfmwCMyn77nkfQdJgsREOGeCzfd1B5tmwCMPACl75+IY+W6dYqYaKfA199+ + Cd/AeLotzqrb8HdAAIxKPlf5nP1X2CH43RJAR4es7CuaNvt/lOKeE3186bC1C9B/DuDsCUC6uRFy+AYR + gL17qJDMciKjCY7OhFd4BpyCRsAhKAtOYflwj50mquv88m6DX9EjCLhwLkJmLUbY5SsRde16RN/0OmJu + fxfxd32I5Ps2Ie2hLzH80W+Q/uRmZDz7AzKf24qs537EaMazPyL72S10VPG9QM7zW5D3wo8Yu+gnjFu1 + C5NeOYSpr5Vi0uKf4REzEXYUnji4qYND6L17SHVhoTCsQP3bwdM2uDCIZ/65MHwS4eqbCDe/JAJfjlf6 + /q3LfQekGaCAQ4icgqn4addO1Jw4gvr6Guzc9QtiEzPIwzAJjvxaD0C/PTzQHEA/OMHnbNG0Of8jSKCj + 4w8CONOyXnajssdO/1+fkNRb6QttONMfYaDbgLYIQC/lbW38auEPT90N103iJQKgFdQtIguR+beS23w3 + Yi9+DKnXLkX2PW9i3DNfYPyCrShcsgNFy/dhwsqDKFpZjMJVxSig49gVhOUlGLOsFGOWMsqQt6QMuUvk + MW9pOV1XjrxlhOUVJqyoRN7KSoxZVY381YcxbvURFKw/gsLXjmHy2ycx5YPTuOStU/BNnSXyEyYCCNeM + 3Qi2jZ+NM04SgE+CBiYBhotPvGLwMVYNP0ZGa7mKm11HnsHN9z6Fb7dux5at32PNy+uQOHy03DpUtAT0 + zzmgJKCB8av4jQiA0UAkcGt2/oVim/D3Wj486Pdn/HKPP2Vk0Z98QtLu8Q5ObdWMN1TBAAlAlfAyKgU+ + sxBA5gAkAZgaf6Rajm4kt3sI7Mk40m5ZjnHLSpBPhjxuZTkKV1eiaB3vqVehYA2jUirvrKig+5QLg89d + WoKcJcXIWVyM0YyFEjkqFvFtJchlLFFRSqRARLGsTEEFxhAZjF1ZTa97BEVrj2PyK6cx5e16TN1wDF5J + FD44hxABhOkIQDdnQIGjCtUr8IwWY7/VeYSSANgDiIMTT/0l43f2TVAMX67+Jkk0S4m0GINmoGiTt6Db + 4+fGH04GZoybiU2bf8aOA4ew4+BB3PvYM+I3cdaRipab4SRtgA0CUEuDjVb/EPPksOevIABTGJrU6hOa + dE/yqPw//V5JYNDv0fgT0sf+mVb+h8j421iUU/1ixY+kkMBACMDU9WUiAX0S0M0sARg/QPc/WlP9kdt+ + JgKwcwuFa9IkjF24G3mrjtCqXIWxvCqvqqJVmQx+dYXAWCKF/OXlGMtGyys8GTUb+OiFh5C94CCyFx6U + Rz3oOr599CITmCxyCXlEBowxipeQt4y8geWH6XWPYvy6Gox/o5a8jEo4R00U8b0ZAVgIfjjqRT9Ub8Az + xqzcV639VwnAkTv5uI7fO04p6om2bhTifImPcb2APgdg5s6zcRPR+ISOwPzVb2FHCe9oHMWXW7ciNi1H + vB6HG1J8NK5fAlDLgy0JwFN/rvSRA+ijKMiAAPhyIqONLj+UNLLgz5IE2v8ggL7c/oQR+X+mL/AR75CU + dm9FlddsRQ8ZuAdgSQD6WM89UIG2+scbhgCGBOBt0soTclmKMQ3h2P/Cx5G3+hi55Ycxhgggn8B19fkr + KxTQir+8TLj4ebzqk/GPJuNnA89acACZ8/cLZOkg/qbbVGgkwaQgyEB6DTmLSwllyCESyFleiRzyBHLX + HEXehlPImbsLdgG5YtCIg3uomCHoIDyACDPj1xOAIw8h4RyBcPujdQRg8gK4P4AVj52E+KlSyGNGACaJ + NKuiIW+5i+JiOAZMFQ+NF+XHs667Gz/uK0YpEUBFzTHMuvom8VpufglmCsSCAGwUAmkEYNkgpJ4rfVQB + WpWU93EeSuNP0iG5nc9pPrd/b57AoN9Lwk+4/RnjuZvvIf7CiABgSQBn4pL1SwBqw09AotkWoK2RXhoB + sAuriGOYCEAmAYf4JCPt3g8wemUNcmkFZnc8XwXF6mPVVZ+Mn1340eTyswFnkSFnkGGPmr9PQ+ZLEhkv + 7TO7PmOBOTlkzZeEkElhAiN7UQmyKTTIotAik0ggkzyQ7FdO0vvahKGeaYIAOFlpxzsWHiYvQG/4lnDS + jSgzVTvGmMM7xlosRBBluKgPkFuDFgSgE/w03wbUtwgniFwDb3W+8/l3KK85jhPNdVi8Zr3QZnDzTzCT + Hx9oNaBa5DWQMmCrXhL1vOqjSEiu/mbXMwk8lJIhuwl/L4nBQb+XrT5OltAXdA99UW3yC1MJIKXfrP6v + JQD96t/XXD+pahstTlpzDyAC9q50kidejOyX9iB72WGK6atFgm4sYcxyTtqRq0/IoXh/9FI2UjbWQ2S0 + 0vjZsNnAR760V2DUvL3IIIxS/tauJ2QQVIIQICLIWHBQIHMBPSd5BJlEAqPIExhJ5JO55hgi5izHUDdu + Ugr5jQjAvAvQCOI7IgJgiIIgUSgUrtQGmEjBiABMnYIy0ehMq/xDzy9C2fEjON1yGlt37kRMch79LsYE + YEQGvzkB2Dj3bBAAo41zAnyu/162CAf9Dop8Bk288HLe6rtVbeU9k209q/uJXEGypvNmDqnqw+jL7e+L + APgElWW/EdrJzbp5wzwSEDLrRWSTweUsrSICqCKjrxQkkEur8WgigWwigCxa/bPI+DMXH0LGIjLahbTy + Wxg/I33ebsIu5bhHg7ydj7uJDPYI8N/p/PgF5CUIMjmIUeQJjFxShhH02iMJvvl3w84lVBAA5wAs8wAO + YrpwuPmocQsC0IuCOnpFaeiTANTHqFWCggzCFTJQioRUgjEgAXW70Z7CkIKLZmNP2UGcaj6B43U1mDbr + WpkHsJhE1BcJWFZ5qiTgESS1Hj2CEqzkw43OI6/gBHE0nXuq0Sf12YuitBTfytvbv4fpRIP+2eW9ssgn + 9Yr+tvrOiABCfx0B9LVNZTqxTQQg6v9Dx2HEE5uRueIIEUAlEUClSMblkPExsglZy6wJYJQggH0DJgCJ + XRbYjeF0/Qh+HHkDIyksGEkkMII8gVTyBNJe3A/HxOkY5hokcwBu4WdEAI4GCUJLWOoCWvZHCCIRnkOE + zhtQPYEoq/BAP1eBicCRQozQ+JH4bMvXONVyEo0dDZi3dJWcNKRNIoq3Iuy+PYJ4KwLQC4j0TwAJuvMy + caAEwPfnLcIrHnr8hf/6Z5cND/pnN/b4hadOpi/jhC+5/LYqrAwTMMp2oFeIgeqPboqPeQigl/WKN8zy + 2yIAfT+7mv1XCWCYexTcM69D9tIKZBABjF4ujT93WQUZv0Q2G/8yjs1LyD3XewD7FQJQXXy5qqvGPeKl + XRhOq70AGXrai7sIO+myHnQd30aPS6OQIJVIII0IIG1hMVIWlyL2gS8xNCgDw1wCKVRRPAB3JRnIhq70 + MIjEoBkJREhpcB3sDSC+Cx0JOFqESBqJCAFRWTshCqi85HW2NQbVpiI5YYmlwBasXIXTbafR0FGHX/bv + Rnxarm4XIM7m72eLCFQSkGrP8eYNQ30lAQUJJKpJPn3Cr9+OVLVYiCsG/9kNRP80D0AafxrX9lfyl+VH + BOA7YAJIMpX59iH9xcavL+owa+u1WeHXv/GLE9+TV8gwIWU9xCMOobNeQvbqE8hSCICRTe5/FmMFrf7L + S5G5nAx/WTEylpLxLyHjX3zARAAKCQgimM8u/S4FOwi/EDnswEgy9pEv7sCoudsJ25DxwnZkPE94TmLk + s1sx/KktSH1yM4Y/+R1GEIY/vRnhM57BELcoCgGCRbmvJIFgUbVo7x4GO8X4Hd3k0coTELeFGd5m8hYi + zCYJWeURVC/CSxKnaBzSrutHaFSREud6hKtvvgMnKASoJxKobTmFG+64R9xH/H5+A6swtPYG4rV+D31H + qH4r0FY+oL9y9H5Qqe8d+I8gALWfn4w/Wt/YY+wBpJhtAeoJQPMA9D9GsLkH4GFW2JFg1flnK8bXd6yZ + 3H7VpeUTPkwMzXTwCBUDM4f4pyP5oa+QvbYe2StrkLOSSGDlYUI1Rq8iMlhVgdwVpcgjAshddhB5Sw5g + zMJ9GPPSTuTN/Rm5z2xB9uNfIeOhjzHq7tcx/La1SL5xGRKvXYjEy59F4sxHEHPhvQifeDtCCm5C6Jir + EZR9GfxGzoDf8OnwTbuIMA3eyZPhmTAOnvFj4R2bB6+4PHjQ0TEgUegTDmMCcJUEwBWLfLRTE4JKH4Mg + BAvob+PPLhFuI2SIMg4R1BBCEECENnXIUfMO1BkDUQb5BaWWwDMGw7PzcaDyABraT6O5sxZvb/yQfvcE + rYvQRTma1Rn04w0Y1n2wZxCUaJVA/o0JQDQQ+UfILsJ/hp7AP5QAVCWfwKh0D/rgX+paKQ2+sBRtMq9R + Nt+w5DfYPAeg1/MXkt6B8TaNX08ATrouNvMpP7T6eyqGr8CBVlGvERcjZ+5WjHyGVuCHNmHEXW9jxG2v + YPhNa5B27WIkXvEi4mc+ibiLH0XMtPsRNeF2hOddj5BRs+CXMhVesePgGpYFx6A0OND7sKPXG0pGNpTi + 9aHOgRjm5EfwxVBHHwyx98YQBy+CJwbbe2CwnTsusHPD+YQLHNwx2NETQwhDHb1g5+QDe2d6rIu/cP+H + EQnYMcj4h5EnYOcaimFuoVYG3zdCNdLQCEIjgUilXDjyjODUR45BlVjjSkTWJfQlt/uVt15BcwcTwEns + OsS7AZni8UbaAn0RgeGYcR0BuCt5gL8zAYhW4mBFT+AfrSw06B+53ccfMCIhi2fzrVON3LaQh4kAPAdK + AAa7AJqct5Lk6cvlN7n6AyQA3lIjw3Kl13OLGg17/2QMYzkwMqphzkFkiAFkqL5kqD5kqCq8yWC9cR7h + fL7enm7n+7Bxk8EOdfYl4/QjQ/UnBMDOOYCeiy47kRE7MogInBTQY4Y6etPjvXCBowInIghHBt0miMOP + LvuJ9zKY349TIF1P702FczAhBENcjBCsYSj9LeAcKsGXBYEwCaj5ApUAojRPwPEMCcAK7Al4ynJk9gBc + 6bdIy8zEDbfdiJv/dgtmXXk1nSfxcmiprq7AuQ+JsjMigH62BW0RwJmWDvuGpa5TlYX+kduDg/6BGX+h + 4Ser/JK7jfb6jTwAb/1kXnVgR3A/DT8hyYbNPiYt/77jfCNobqwo+w2Fk4fcUrN3pRWVV1kyXjsySj4K + sAE6sIGSoTqwsZLxOQaaYTAf7elo709G7EcruB8d/Yk0mDjkkf8ebE+3CfjSdXQfIoLBZMg8dUi49q68 + IkfIRh2uyOOWXK5vYOXbEPoOQ9PgG5GOwOhRCI7NQGhCJiKSsxGdlouYUQWIzShCHCF2ZCGi0wsQNXwc + ItLGInz4GISl5SEsNQ+hKXkITspBYHw2fGNGwSt8ONzpt3Ch79XBNxb2ZHQ8TtzOPUa2C7tFE5FF0HfD + bcZqS3Ekga5T4UYE4EbfLd3fQdeNqBq8/JvVlSOFTqA4uoVLcqXvQZArkyLnNJgABqhLODAvwDRu/Cz0 + As+mf4CVhR5hG2Fb+UftDPwjQ4BBioBno/bBg82r/QZOACkDUv41N37F9fdXpbzOnADkShUu+v154KdK + APZipfZX3HRake09ySX3wPnDPGm19xKrPK/AvGqK4htOWvnHEusnIyxulMhkp4+egDETpmPSzCsx8+pb + cdUt9+KWex7FPY89jUeem4un5i/E3KXLsGD1Gqx89XWsf+tdvPHhRrz36Rf46Mtv8Ml3m/H5lh/w1dbt + +PanX7B5x05s2b0b2/buw8/795OrfAj7Skuwv6wEBypKUFxdhtKjlSirOYLyk8dQQSg/cRSl9HfpcRXV + KKH7HDpcIZSF9leUYS89fmfxAWzftxubf9mOz3/4Du9/sQmvfvAuVmx4HfNXraX3uhj3P/U8brvvYVx3 + 812Yc+2tmD7nekydeTUmXDQH4ybNwOhxU5GeXYikEWMQnpgJv4g0uPvHiTJrLlRiXQJBco50dAgS4MtD + nNgLCRZdjcOEfoGuqEnZURjwRKI+E4P6HQLbRUNnSwI2HtfINqKoDf97EIA6tEOR7q4wNPSQFIP9fDb8 + VGHsXsoEF6HjznF+cHK/ct8eVo0+kgBc/MnY/aKNR1dbynt7m6bgiJNLFf5w4/g5SMbRorkmRMyt8w1N + ArlxGD56EsZOuQwzrroZ1//tftz35PN4YfEKrHh5A1555328/fGn2PTtd/hx589klIdQfrQKx06dQG1j + LRrb6tDa0Yj2rmYxFquzt1mM8OrS5vk16wRGW8XgDFYc4ik/6qSfHuVyl4IeWAiFKujubbKC+vyabBkL + jvY0iZkGjO6eRkKT9ny9Os1B+ZyK2nAPvXZ3Ezo7G9DRUY/WNorZef++6TjqGo7i1OlqHD9RgarDxfQd + 7MbWnT9i09eb8Pq7b2LpmlV4+qUXcfejj+Ka2/+GaXOuQnbhNMSNyIVfZDKc/SMw1D2IQh72nALoGCBC + FjveqeBhpl6KwKgmPnJm3oDlDoEKKRSbpOhI9l8x2Bc59HF7hS/Zyj9q+Migf0SDT3DMSB7a8c0ZMSQR + ALuvHsFydps6yEHuv/av9W8k88VNIs608jpRCOBssPJbjfcmox/myfv8FO9T7O8dmoj4kWNQeNEsXHXr + nXjomblYuHo9Xnv/I3zx/Q/4hVba0qPVqKk/hcbWZrR3d4jxVt2sbCvEQFWjVdGiGW43a/QLA2tAd3c9 + GZCKOjN003XdvQp6VLB2YKOCBnP0SG3BAaPXYpAI/d2tgoyfn097zm6JHkIvo4veSyehywa66+i+tZro + aW8PayY2akKnPK1Yko+U/+ohdNLf7UQk9S11OHLyKA6UHcK327fgjY/exYtLFuGeRx7B1bfehgtnX4Gc + iVMQlZ4Fr9AErVhLzeOcDQFIEtCfQwlK70iilbjomZJAX7d7hSZ/4x8jh4/8vRuHBv294/7EdDGua9GZ + JkYEASjuvpjlpk1y0Yk3BCaaoEvYGBX6yH1iafyCACxFKpVpN2KgJ2e3yfB9o1KQOX4qbrzrfix7eT2+ + 2f4jyo5Voq71FNrYEITx6lZLM7Vflt1uk3MAei2kv9nIWPQT/BwS0sjYsMk4emvpWCsua8be22AyRIEG + 3W362y2vN0dPH7epz2M9S9AE/fP3qOhhNIgjG7k5VAJgsqDn6OHPbvIohFehvO8uhhheapIu7+1t0Xkk + KsxFVjvp+Vo661DbfBzFhw/gyy1fYi6Rw6VXX4vEkTkUy8eI7Vv+bZ01GXK9snC0DQKQRq/PC8i/jdWF + zoQE+qpfkYVuKYsSR4770987H/D3DgEGcckjofVMCEB+KabJraqAp4fFSCd9Y4fa6qn2+Nva6jMjAG+p + be/oIaW82d0PjhuBokvm4NnFy/A9xbgn6mroxGzWjFysUmzAulXTeihH4wAHdjScIQYy8MP2442HizT9 + JtA+Zz8eRs9ZTC8yh2nOgZi1qM1blDApLDejrfM0yqsO4J2N7+HWBx/EqMIpFEKkiSYkB5ZD85SaBi5W + E4dN5cWqB2A0hdiWvqDqkVoauWoDVo1FSmGbQc/AFX/vfMCgv097b6ca9/OU3vIz3RrRE4CnGM5pQQBK + HGZGAKzYExCniUEY7vMrBMATbu25EIXcQ9/wVIzIm0Cx5p1Y8foG/HRwN+pb6xUV2jZxInXrZuxpJ3qv + wclvRQAN/wQCaPynEMDfDX0SQItAT2+zzc8uCaFV5FCO1x3Gtz//gHmrluHS625EfHqu2BWy89B5B4IM + TAQgL5tUh8zlxoznDNgiAKPVvw8CEANJ2YZk+3DnvwYBcHeTiPvjM4ZRLLPRSyT4UokAUvs0el9FcdXb + KrZPolVdwryHX1nldUZvu7NP7eKLhBtdjhuei0uvvU3E79/99COOnT6M9p5GxdVsUabs6Md461ZybapO + s4HRne2J3mhgpI1WY8TP1PBtjxQzPbf6OPNJRL8fArCcotRrNemob9Lr0X1+oF7OXSC0dtaitJq8g0/f + wx2PPYScydMQFDtSJA95riMXHbEYibOFhmFfbca2Bo6YEYCa0xIFbilKUtsiR6Dujsnk+Maw+MxhslKw + +1/DA7jt3kf/2yss5T5itR5JAGlnTQAeQrrLiADi+5XvUpN6PMwjdvhoXH7jzVj/5us4VHFIDO0wjelq + 0mJzk+Ebw2glGvgk3jMhgKYzJICGsyCAJkPi+bciADMSUKct1YsJTOpUJc7BnGo8hu17tmPRy6sxk7yD + 6JTRcCPjd/aQ+aG+BpCo7cX9bxUqxW1B0vj7JQC53d3jG5Z63533PPbfv3sPQN3y8w1LyyTDr/HStvj6 + L430UfTW9Su/ABt+oJp57YsAZIKGNeJYpMKTfpCUzHG45rY7yehfw4GyfWgh1oc4qfhk4GRbnTw5lFXB + zNBhYPz62Xqw9AAs0Z/BN/ZDAA1aYq23R04KMn49SwKop5BFJufE41T0WqJBgenvXt3swbMns78XCchk + YI9NArBEH2RoRtjqINYG5dyoR1PHSewq3oXF61Zj2uyrERybJncVPCI1MjD2ABL6ERZJ1iW2FYjrZNLb + BgGw7dT4h6dl/j22Bn8zAujulq5/SMwoBzL4L0wFPilnXBwhv7gkJdZPMhvYaR4CEPOy4XOMRj+MO7v3 + qdm46oZb8cY7b6GsugRtXXXKTD0lw87GYbA66lddw+TWGa3kjQN01W0TgNwq06Ne25Yz9jjkdepOgvis + PbZhdR9t5R+ox/HPIAC5dXq2yVCjaczWv0WD+F7kOdOI2tYT2LLzBzwzfx4Kp89CYEwqkUCE1oFomRRU + 9Qb10JOAuvKrCW5PxRsQFZu2CYDxRWhshgPbGNva79IDeOGlZf9Fb/R+dlu0Sr4BEoCXRe2+vm/fcmqv + SgCcnGGjj4wbiWkzZmPpquU4ULwbHZ0NIpYXBTGiwKXBtG1lwz02i/P/IQTQeGYEIN57o8ykmxGA+Yp3 + 9gTQoJs+/M8ngG6t8MmcACRshQK2iLbRIuzpy2NrVL5H5fvUkUNty3Fs27UNLyxcgoJpl4kdBe4/4A5E + 84IhY+kxmfRTDD7IIhdABOBlWQUbYkYAHArc/8L85f/1u/MAOk0tvqn0ho/qx3JpMt79q6Qoxs/ll3FC + nMG8lDdB0+9j5vUNScLo/Ml44vkXsO2XH9DYfNK0Vadmhw1OCqN4eCArn54I9Cen0W19v87AcgCqgRrB + 9FwNploBrZCn3vbjNALgGoPTApaEYPw6v61RS5gbnlmc32sCem1NPdaPWW8aEMynJNuGsRei1iN0CJxu + PIUvtmzB3Y89gfS8QjLmBNG1yLsGlvkodRETNSyK4auegIeOAPQ2ox9pp2uUO+ofMTyVba3zN2odHvRb + qPuILr/EbO7ye1fT8D9LApDKLHGKOouJUcXeLMVe4fEjcPl1N+LtDz7E4ePVdCLpRm73mMPSjTSfxKui + 1WJir6noRK425kUovaL0ts1g4q/R9F/9BOCWPqC+ryZlOrAyJtwWNJJiA6ozxfQ9+iIgA4NW8wLCuGtF + wRHnQjgpJuPgem0Eea9IkDUbjho3jTc3rcrm35Ear7co1Y4SXQJN6OTEGxEmlwt3dDWhvYPQ3oS2tka0 + tjVItNajhUGXW8R1jXR7A92vUd6X0ELXNRGaWxvQzPdrbxDJ3c7uZnr+VqX6sl0zWnO069Cme/8tNkhC + PR/aBORjOkWlIk9bfvOjj3D5DbcjPC5T6UmIFOcrJxI5RBX6AhQOnBEBhFoPvSW8G5k4WnQN/hYqQoN+ + K3UfZX5fh5f6AZRSXj568Q5AP7sAJr1+lQBkcsVNSHFHID4tA/c/9ih+/GUrWjr45JQTY3v4h9ZBP/de + TuZtQXtnIxoaa3GMfqiS8oPYvfcX/LBtM7785nNs3PQR3nz7Tax7ZT1WrF6JRUuXYO78l/DMCy/giWee + w+NPE+j45PPP49mXXsJLS5ZiycrVWLF2Hda8/ArWvroB619/AxveeQdvvPce3vnwA7z/8Uf45PNN+Pyb + L/H199/iux+/xw/bf8C2n3/Ezzu20evvwP6De3CweC+KS/ejrOIQqg6X4fDRChwlHDtegZoTFThxsgKn + aqtQ23BE1M/XNx4VtfQNzTVoaDlBqEEjuaVNrTWEk2QEJ+m7OY32rjqJbkJnrUBr+ykylJNoaKqh56kR + I8Yb+XL9cZw6fQRHj5ej8nAJKqqLUVJ2AIdK9uEg4QC9x30Hd2Hnnp+x/Zdt+P7H7+h7+wKffPYJ3vvo + fbxB3936V1/G8jWrsGDZEjy/YAGemvsiHn32OTz4+FN48NEn8ADhwUfo+MiTuO/hx3H3A4/i9rsfwE23 + 3Y2rb7wNl19zEy678gbMuvx6zJxzPWZcdh0unnUN4WpceClBHOlvun7GHOU+c67FhZddg6l0+5RZV9Hx + KlxM11165Y248oY7cN1t9+LWex7G3Q8/g4efeglPz1uKl5avw7JXXserb7+H9z7ehE1ff4vN237Czr37 + cKj0EKqPVNH3Td9lS70gpl6zBaJDGVDaI9HbTcTJ52CnOBdBFNfa2Ypf9uzFY8/Ow4jsfLh4h4n+ER50 + yl6ru0ICXMviIepbJNQGNy8FniGqB6DfQk9VG+c6fELSrvitVIQG/RbqPgGRI/zIiPd66Vd+YfypSmyT + NmAC4L59FcycgeGJuPO++7H34D76mtvFj9Brxt6dynUdYuWoPlKKLWTcr775Bp6fNx933H0vLrviOhRO + nIFR2YWIT8lGePRwBIQmwCcwFp5+0XBleSr3MKHuw/P9uLlHqubwrD858YdFMOyFDkA43ZcYXgzWDIcz + i2pyHzr/yMz4frLdmFuPPenH5m1Nn+AUEbL4hyQiICwZQZGpCI0ZgYiEEYhKSkdsagYSRoxGysgcjBiZ + h/SMMcjIGovM0fnIGVuIseMno6BoKoomTsOkKRdj0rTpmHgh42LCReI4ZfpMXDjzUky/bDYZwVW4/Nrr + cMW112P21ddg5hVX4qJZszH54pmYMHUGCidNR/6EiwgXY8z4acjMnSBGhMcPH03vJQtRiemIjB8uEBGb + hrDoFARHJCIwNB7+QRR+BUTDxy8Knj6R8KDvzt0rHK6eoQIuHmFwER2TEfI7Ijir4Cy6Bx/l9+bsxkd+ + jIpwAhkM3c+Vjvy3sydPWw6V96Pfh+EqXiNMdmaKMeR0X+9w8Tu6icdGiudxYZEQTzp6Sbj6RNGKHAMP + /xh40ULjQ79JIMXx3JEZkzwaaSML6PueiskXzsEVV92Cv939MJ55bj6WrFghkspff/ctkeF+1Jw8Th5I + qzK1GAopqGTQQ8ceVB2pFuPes8dOoNcOExqI3AEqQoFAk/HrSUBLDFoRQJqpa1Zib0DESL/fQkXoV7PI + xZffeA6598/qFXnNCUB+CFsEoE5Y0ecAGG70I8XRqr/hnQ3ErE3CwLuF+9Upvvie3k5aweqxr/gg3tm4 + kVboubQqXIHhWbkIjqLnose7smF6yOk3zp7KhBvPKDlZVtGdF/CS8tOOylQbR00CjC9LqFNuuHTYmUdl + eUp5cCllFQMHBfbesRocvGLl9XRfe51ABsthqQKcLC0mdPrFwI4wMWJcHTOuyXAxAXHbK5GRICTXMNED + P1SAxTpU0Q5F3EMgWLTNDmXNAKcgDHPmNloTRCuts/q8CpShIfaqDJiYdizBasJObLQeEsLAhJFFmIyM + FX69WZknSsBZPXqpl6Vaj6t3jIBak+/GhikQLQyUE7tuwn2OEnD1JcMmsnFXIa6PVhCju6w83scENyET + JucMCnec4K6Ck8gco3OY6UfepphqzO8vWgiPuNBv5kq/lztd9qb7BXC3J5FiRk4+Zs25Ck+Qd/gWeX37 + Dx4gr6FJGL4khV6FCHopTD2GZ+cuQEh0quhM9PCPlztbZgTAuwPJsuclKNlM9FZuoafK7lh1W53Iwick + 5dlL5txwzj/NA1Ar/nwi0tLojdbYIgAvXSbTyvj18Y5evYfc/8ikUXh/04eyrbW3TRIAHSsOV+KtDzfi + 9vsfQf6kixGRlCUIw0W0+EaL1VdTfOVabl+ZO1AbPvRTZ5z1JCA06GOEEIUDdwKKVmCD4ReKVLWDlywn + tveSKjj2HlHSyLmSjCDIRJ2ao0zVtffi544WXYaqkKajUOSN0FR4pbhm/7DXyXibS3ZFWGGYW7hyOUxI + gOllwIZ5yMYnO1tin9oQUbmCW84SdBLtt+rgjygzONmYBOQqEK0jhGi5OqtQDV9/3QDhyrG3T5QC+dwu + gnBihSvOhOBO54QKDyIBD39Tvkm46n7K9QRP3WUPvo1JhgzZlTwOd99I4UXGk9d00awr8MJLi/DdD1tx + uqFehAS9Cgl0U7jwxnvvI5S8KUE6AUlmxu+ukyD3UJqBLBWDLBODhBq/8LS0X1sh+Gs8gEGxI/L/4hma + skF7U6G2CCClbwIwq4+W+urPzFuMrh5ZCceJnS3bf8Qd9z2IxPQccrOjRXcXJ1uceXIMz6T3T4QLg1ws + l4A4AVf/BJ1WvEzIuCqrgRg8qaz+EjECggT0BOCtO5nFCRwt7+epGLLQ1I8SRSJCBkt4DTG6aboxQtVG + 9QLsVVVh9zDNuBj2AmHazL4zgfpYCXpuN2NIz0Fd7aWHYaeoAqvGbglHd/0o8Qjp2nvqFH1ZiEMIpJju + Y0vjT72eV1YXvXyXchRG6y1xxobvw88RqUwbitSmDpmgkI1GAPHKUXoFZiW+BA8zw1eJIlaEDx7ClZfw + YI0A3uqjy15EBmExaRSSXYIFS5aipLycPNVeQQYd3Z244fZ75OsHJlsQgBwz5mlIANJ2vKwJgGcQbkgg + G/w1DUODfk3Fn3fY8EIy8iZP5Q16haaYxf4yu8mui5SlUmMZU4yjhgFJ5hNZ6XlWrH+TCKAVJ08fw90P + PEQxc7Ii9sD68GTk3KjhJ41fQn+dhGlYRJy18q+y4kv3XxqsHHcVJbTqnbUBFuYrnn51Y3VbO3fuJCTD + 5iN7AV6SBOzo+YYqR5NOXrTQzVNXXwfN+MPOUJiT8xK0arvpV/pw02U3eg2WAVeh8wSkNBcjTLts5DWo + YEKR4YpJCFXqIYb3C+Gd6LwJR4vvUA+9oKcMISIHAOX+amu3IGvplbB0GE9CYil0kUcQ+YIoEwkoIUFf + suFufjJUUAnAXdvaixVNRAL+0oPwJA/CixYdLyYP8hK8aJEanT8J3/7wg5IjAJ6au5A8ALo9MMUi/pdJ + c32DkGeIZRLQXCfDSxJDE3kBhb+mQnDQ2W77hSVkD6Y38qncvkixyPzrCSBVIwA1iSGlvcxFPs3FPOIx + 46pbcbS+AT/uO4CoEeOEy+0ipsWSoWsEkPDrCcBbmXCrkAC3BjsqJMNTZzim5WSTRgLKCiiUgkLS4RCW + A8ewMRLhY+AQnge7sNEYGjgKQ3zTMMQjFkPIUIcqbri94orb6eJ8Xo1V11yPoVqcr8AtxHS7zoCHuRkR + AME1UmjvCcOn1xjqKjHEhUDx/xDnMAwmDKHnsMRQAXl/mQTlGQIhwvh5noA6XswWhpHxDXYOxmBWIFaS + qOoUIiMCMIeegCX6JgBF3EX8VqHwC0tAXtE0zLzyWtz54MOYt3w5xk+bLrwVjQT0xGFDMdhFJHVNOQOx + nWe5x+8vQwP2Cjjv5Okn4cbvxS8MLy5bJnICzW0tYoeCw1KPwFTjJKDV7EFa5TmBHmKTABifRiRmDz7b + bcFBZ7/tl3YJGXM7y3aJNyVclBQz45fgv9PkToDWCGFS+TWqneZMqXfEcCx45R2UNndi8cbtiJ1wExwC + RpHrSIbpkwhnzfCNCCDBgBDiJHzMY349hMtOz5U+5xkUPfA+cq9dDNegEbrVj1xd91CRwfZMmYpRD7yL + kY99hlGPfomMxwlPEJ78AqOe2IS0hz9A0r1vIu76ZQi56BF4pM/G0IAsDHaJFsahGblAiJWx6xV5VQzm + I913iHiMQgAuEmywQ1wiCFG4wC0Gg72SMCxgpCAop9jxcEmeCvcRs+CRcTm8Rl8NnzHXwzf/ZviNvxMB + E+5G4MR7xNG36E54j78NnmPoZM2YDeeECbALSKfnj5ISaAoRyBFj0tjlbgmHFSESRDABSQVIn/0ggvOu + hEvceAz1SxZEyGTn6KHuCIQLMnXWzR500mkvyiy/ORGwketnNsh5AIoUOCds6TljkjLwzQ8/oq2nXdk5 + 6sKb774pVmWxy2A4kLQf0VDVI1COplCBriPDl4iTDUS0gPhGj8LNjz2Fo7WnRSZg7YbXERidJnaGPHQh + gIea+AsySd95KdeJrUF1AQ1O0UqEvbQye+EdtPuGDb/kbLcFB53N6h8Sk2lPb+Bb7yD5RvojAI/g4ZIE + 1CKIoCQryWW9+CITAM9555X/5U83Y09zD9bsq8XEp96BT+ZVcPAbRQZL9/HmGN+SAPRegblH4CKyvHG2 + CYBOPK/E8Zg2/2dMX3MUo65bjWGeCWKVdlBWPyc+0uofd8VcZC0pRcbiMmQTcpYSeALwynLkrSojlCJ3 + dblA3upS5C3ZS0SxCWGXPg+nxOkYTM87hA3dwPhtEcAFTAJ02wVEIIzzaHU+3ysOw0Iy4EqE5Jd/AyJn + PIqE6xYh7W+vIv3RDzHyGSKluVswat5PyJy/CxkLd2Pk4j1IX7ofo5YeFFOKeFpR1vJDyF5xCFkrDiBz + 5T467kX20p3Inv8j0onoomc8AZf4KRjqQWGMS5C2RSoMX8wY4PcdJDDMORDe8fm4esMuzHrnMApX7MKo + Rz5AxKzH4J1xGRwjx2CYb5LwhsQ2oeIVmCUWFQKwJoJIg8lBuvCBwzgi6OmXXYXTTfVk+rx71I4jxw8j + K2ccnOj9uXqadiZsy4XF6BSDFG9A9QR8zUME0XlK3qITndu+KRMx9rrH8dLGH1Hc1IGWrm5seOt9RBEp + uQXGK/0tOgIIlGpXqm2YIdhkTxbbgBp8ZGj9bWhclv3ZeAGDzm71T51NbNQpCxeULYpQk3tiTQBpCgFI + dlPluzysNPx0YAFPiqUiU8finvnr8PL+43ipvAdzPj+KlEeICArvgn3UBAzxSoadZ5xw44WB+yWRd5Ak + jkwGzkIHMM6QAPQk4Ky4/9ETb8X0lWW4aHE5grKvx1AXPsnDxYrHNQJO7gFwjcxA5hPfYNSyaiKASuQs + qUDe0kqMWV6N/BWHkb+yCmNXViJvZQVGM1ZVIndVFcbQccyqcmS9tBPxt6yDT+7VGErGewGtjIOdybDZ + ZXYOknAKwgWE85wCca5jIP5KOJfv4xmPYaHZtJpPR9iF9yHltlXIeuoT5C3aTq+7B/mrDxBKMGZ1MXLW + kFGvYsM+gAwy7lErSgTSVzJKMZI+56gV5QIZRFyZRFpZ9FhG9ipGMbLpci5dzl95CKNf/AHRc56HY0SO + IC97IYoaKrcUXVQCkNOHLiCvJP3q53DZe8cx6fWjGL+Bvht6PwVLdyHn2W+QcvvLiJhyH1yjx9Hvpxi/ + RgLWBKAnAWsCUCYLe8vkIicZ3bzDsG7DW2T8Peju7aD/78QL814i7y1EIxz9QFIrAvBWdoxUL0DJG7gr + iWRHOjpQ7O8ckQ3fzFmIn/Uo8h9/C1e8vQ9P/NSE1Qe6sG5zGW554HkEkTfLgiJuoi8gSSYBFQiRG23V + V7sETR6AFkL3SQCpnb5habPPxgsYdKbGHxqbYU+xyGZR7mux1WdEAJ4Kk6ny3rY01i3r/jmzyu6WkOzy + jkN49sUY//A6XPrRIczaXI/Jnzdg9LpDiLv/PfhMfgD2iVMxJDALw7xT4UAhgiOtMC4+ydIj6IMA9HD0 + TUTGzUsxY91RFD2+DU6Bo5VZeuo4bYJrIALGXI2MBWQ8i48hc1E1spfQKr+0FPnLKzFuRRXGkfEzAYxR + DD9n5WFCNUavqBbjwzPZ4JaXiNV4BHkFsVcvQFDRHfAaNQuuCRPhFJUP5/A8uESPhVvyRHhnzUbwxLsQ + d+U8jLznDYx+/iuMpdV5HBl3ARl6PhnqGLo8hox0zKqDdDwoLufR9bmE0XQ5eyWt8mT8mSvIa+E5hcvo + yCCvJXN5uXhPggDIe8kmkhq9ksEeTSm991IiMTquob/p9TIf3Ugr+WzySsJhp8pzuyg1Ca5SqptrEbzi + C3HZ+oOY/OpRjH2Zvoc15fSey1FEXtEEwsRl+zHmiS8QffEDcAnNIA8sShinLQKQsDVN2HyrkYe2jB47 + GUdP1CiVel04VFKMxLTRIqnZPwFIjUhH3yg6n8Llti+dT8NCsuCYPAXeBTch+pqXkPn0p5i4bj8uevco + Ltt4CnPeO4xLlv6IvOvmIYh+O7Ew8Takn6InGGCubaHvFjQtmslKmJxslT8zJgCRC9gcGpdhf6YkcMYE + 4BueNpNerHMgBKB2PPkw+iEAI0/ALUDZxvORwgyO3vFwTxiP6JkPYPRTG1H0SgmmfHgaEzaeRs6GUiQ/ + 9wXCb1mJoOmPwnvMdXAnt9glKg+OHMdTSOCkbv3ZgCutbOOe/gKXrD+BtGvWkrsdZZbYYgJw8QrH1AeX + 4aq3D+Om947g7k8q8cRXFViwpQrLth3Fkm3H8Pzmw7hrUyWufLscU14uJzIoR7YYFlolhoWy0aUvKUb6 + 4oPIJBc8d9kh5C+hlXvRbuRS+JH30k8YSy57/oJfMG7ZLlp992Ps2jKMXUeksrYCuWvLyZhKRZiRTwad + v5JRLFbpsUQA+UQAY2nFlziI8SsPYOKaA7jw5QO45LVDtEqV4Jp3D+G6d0tw7dtluOqNEkx/9QAmrKPH + 0WqfQ4afTRAzDclgc4kUGDmr6TryCPKIbHJf2IrA/NvJ0CPEzEGGGr6oCUr+/sY/+BqmbDiG3DVEfvR8 + Y4lsCokci8gzmkCvUUSfoWj5LmTd+wr8yH129DARgKMyfPVsCIDrDLiIZ+WadcL4e3o60NXTjnsefFQk + MZ21LV1TOCAnP0WTRxIDe99kOISSsccXwY3CFv9p9yLqpmVIeeITZCz5GfnrSzDxtcP02Q5jIpHs2Ge/ + w4gbliF0zLVwJZJgj5ILo1xFIVOs0KkQBBA4EAIwJQH7JABlh0AhAPICUmf+3QhArP4Jo4d4h6Z+qe7p + axl/ZReAtwG9DBRPvEU207Lrry8CkH3//EW5BigruK8c/CjiNv7BAulLSZyMsAm3I/mWxRTrfkSr10/I + 3kAn8eulKHh5HwqWbUfOM59hxN0bEDPnGQSNvR4eUQVEBPHCvdMnfXj8tF/GDFxIxnbpumMIzbtTZMkd + XPXJrhAkDs/CvvIy1Hd2orGrHS10YrH4dxf91ynQjdbeLtTRbUeaW7CjphFvHzyFx7+hleFNMlwy1Ixl + lRi5pIo8CHK/F9NqvIQMawmPEafbyaBzaTXOJQPJJUPJIaMZreQSZD6hnNx7ibGE/FVyVS1YTZ+ZT0R6 + /iJy+WfRqnTPR8VYvLUaHxw8iR+O1OPgqSZUNbbheFsHTrS341RHB07Rsaa1DeX1Lfj5WAM2FZ/Cql+O + 4b4vKjDjDfIo1lAoQcafzx4N5zfo+fOIWPJW0HHedvjn3CimHNlR3G9JADzII3riDRQCsPFXIXspkRh9 + ViaAQuEJEAEQkU1YV4JJZFATXvgGUWOvkxOBuCTbM0RLwOp3Yky7BUpI4GW9TevKoZ1bJHLHTUJN7TER + AvTQL/X9th/IJU+U9/WM1nYdnOgc8MuejfCLHkP0FfMQf+s6JD34AdKe30y/0U5krjmI3HX0/un9jlu+ + F2PI4DPveg1Js55A4Kg58AjPlXknUdkYreUGzEeRJ2i6lprOJRt/UKJZfYx+F8C2mI7hWL0vIxKyh5wJ + CQw6k+SfT9jwiUQAbX0RgMpORpJHxgM8Eq3+1hOAG/3tGhBvIe7Jwz3UUt8oURvgFJQK1/gx5C5fQu7y + rYiZ/SSSbluD9IffQ+azX2H0vC0Y/cJ3SL9uGd13pIwZdVlkdvcyLr8XD35+FHe/vh9+ceOVoR/6ra0g + XHn9jejoblY6EGW3GVcp9ionmAr9dZyJbuhtwZ76Riz95Tguf5NW76UUApAxZFL4kLWUjJxIIYdWx9wV + ZWRk5SJ/kEdGk7uarl/DoL8J7AGMXSORv7oC4xh0edzaUkwmd/v2D0vwyq7j2HeiCfUdrKvfrrzHNqC3 + ndChoFPpo+jQ+ilUV7mbe/a6unCgrgXrdx/HVW9SqEFeC3syY1aWkFdBRLP8AF3eh9ynvoF75DgM4elH + XGbsotuepMtukZm4463teJgI5fFPy3HfB6W4iLyZwrXkBdCRMWE9g97/y5WYvmw3hs98lFzvONGToY1i + 64sAPI0JwJVnCZLH9sa779Dv0CN+h6a2elwy+woxHp3zBa5KUZIDnU/J172Agg30G6wlD2fFHoxe+DMy + nvsOKQ+8i/gblyFyxuMIzr8ZASOmwzsyl87RVK1kmcuXtXoB39g+CCDZigA8bRJAUp+zBg0IoM0vPG3i + mSQDB8oUg2KGj/kLGfi7wshDpFiB2PcPTdHVKafqCEApcBAEkGI+6ruvMEBRAfIIlBlSdyYBRQfAJPbJ + MZUs+3UTlX2ydlvWm5On4CXlnh39U+AUlgF3ikV9M2ciZNKtiJ58J8X2w8ngY8zgHBiPJ9a9hp9olVzy + 9hdiy5BXf0dazRwV99/eLQjPzZunNST1at1h0LoT9YQgCaBdaYVtRGdvA5q6m1Da2IS39tTg6ncotqaQ + IGvZYVr5K+mk48Qhr7ScRCSsqiYCqMLoNZIE8tj4RRjAl6vIC6hCAa3Ql75ZjGc2V+OrilrUtLPGnakt + 2dTCqr9s/j7VbrZerdHKdF0PoYyIYO7mKkwiwxizvJSMn8KNZYwDIjxJJePgROYQp1Bh9HZcXOQqj8Pc + o/Dyex/Rs7ahracRte0NmPtNJYUkVbTyVxP4WEmoIC+ggkKmSsx4hb6X21fCKXikmGTMW69OHtYEYMoV + ROigVBt6yR0BHoM+47Kr0dTerPSStOPNd96Bh6/0AETSUIQCkQjNvgiZ96xG4tXPIWbanQjNuQLeSZPh + Fp5F516KKCuXOwGcEIyWR2788o+W8FP+VvoM3Pz0U6mkZ+upEIA+CW65QHppNTLJfQrq6ofp6tuF44eP + HXB14KD+pb56lJr/1FG0ytd5hZhWeVN9copVfKLFMSLDaZr/1z8BJJtBkIAggARzEvA39wi0bC1nW5Va + f5Hw85FJGCcuz+VEID2fE+sG0vUaKP6PTMnBz4cOiE2j+ateEXGioxkB8IkWgldef03r/tq7fy9Wrl2H + L77+FpWHq9De1aZrBOkS7aLd4hnV0V2sONwqhl1wT3xZUzOWbjuOmRvIsMnVz1ldTS7+YTJswpoj4pi7 + 5jARQDVyyOAFiAhyiQgmvlaFW784gpcPnMD+hiY09kiiUeWtZE9+u1j1TQZvDrn6d2vvuYs8g6bWBnKZ + T6L6+BFUH63CqbrT6KQwp6m7E+/uP4UZ6w6S93II48idz192SHgBBYt3wD/7agx2DBMEwLsm9krj0gUO + wbjv0WfFdCQ59KMB247Wic88Yd0RHQnw3+WYSCQw+dUKXPJ6Jcbe9zoR80g4uASblRibCMAoSWh5n0j4 + hyZhy7Ztsn2cSODo8WqMyi4QJdrOCgG4eUWLJiOxc8Sl4iwxx9fx0SfG1ECkgY092gAmT0AdIuLmn6jE + +7pz20Iz0HjWZbKpG7CPycIWBFDnH542SkqH9fw2HsCMy244h1b+xWqHkrri6wnAElLsUPkQZ+QBmBu/ + OQEYqf/GaZV+QrtdIE4oszBY1lkiTvQNOPty/C913iVpxApyyCuajpMN9cJ0H352gSghdVSKXURpK3e+ + eYfhvQ8/0Ajgy2++gptnIJFEECJjh4u245ffeAdlh4+QMXUrRNAhTjpJAqaRYKpCTgutirtO1VLcXYO7 + PzuCy9+vwsVvVmDqa7Qavsoox7TXynDJW2W49oNK3PvlUSzZcxqbTzbhWFcrPbuiaqzMEOw2k9BqU076 + DuGJ9Gp97V1ilW9urceh0hJs3LQJz8xfiNk33obcCRcjIX0MIpOyEBGfgbTMsfjyu28ESXBZzcbiGly8 + bg/GLSlGAREBhwL5Kw5i1N1vwd5vOIY6h4leA1EnQN8fjyCfeOEV5Ho3KbMK61BDl2/fWEHuPxHA2sOE + KjMSmPRyOaa8UolLXyfP6G+vwME/jeL5cLFL4ORpqha0TA7qvQB9D4CDSyjuuu8R8sBaJUnS8f6HHxET + nk0NSbqORFoQ3MmDdOcjlwwLxJjQl/H7K12GonQ4QVv5ZeyfZNriC0qykgy3miPQjwdggwB41PjiGbNv + POdXewBq7O8fMTyEXqTSquOvD/Qv/dU3AZiKJZI0AVBjAoi3AVPpr2rocgtQnQRj6h7kFuDLr78Frd3t + wlRuue8Jsa0lWnNFswudeB5RIqv7/saPhDGwu3yq7gSycwoweKg3zh/ihb8M9hDjqmOTRuP2ex7Ftz/+ + iNaOZmFsPQoBSLQowzsbhUF09daRe9yCEx1tKGluws7aRmw/2YhtJxqwnbCzrgEHmhtxtL2VVnpOObZK + WS2h6itltbrMpKuaFUWeVuH2dmuufidq60/gq+++xUNPPIOCSdMQFJFCnzUQfx3miz8P9aNjIM63C8J5 + diH469Bg2Lv44+vNXwsy6xaOfCve2XsUU1fuwfglh8gLOEhhARHBwp3wy7lalP+qBKBWCcYkZ6OiqoK+ + tjbxeZt6mvD8t4dRSB5O0eqjKCIPp4hJQIDCAwoJJpNnMO3lw+QpVGLENS/C3itRjhD3jLKqFjS5/hGa + F2CW5affMDElGyUVpYqaU7sQg/ELidUVEEnPUW/ssnvQ8nrZimxr5Xf3sx4cop8ZcCYDRC2NfAA5ABWV + AZEjQgaSCxg0QLWfO/T9+/8QAggyJwBta9CKCCTL6kc5yYku5sM/XXRtwHL1l2PCBQHQ5UeeeYE3i9BG + ru7sG/4m9rfVld9JEACfJJF47e23hdvcLfL97bj5lrtw3gWeGEwGdL4dwwfnERkwPOi5L7vyZnz34zZ0 + 9HYo+QA9ATRJt7hX6vl1KXP/rOWulfmB4jpF7NRCl7DbQrtOJQA2+o7uNuwvPoi58xchO2+iKIf96xAf + IiwvMnJfMnZ/nGcfQAjC+fY8jjuEXHcigGH+iE5MxeHjlZoXwa/d3N2CeV+Vkeu/G2M5D0ChwDhC0rXL + MYRifo7bpQcgex04X/PFls0iL9GFenqWZqzbcRyFq6oJNRjPx9VVRAREAAJEAkQEkwlTyRu4aM0BREy4 + A0PcokUDlqNm8JYEEGlMAGKyczBWrlsr8xv0W3CTWV7BRJkDMCAAlRiMCSDKgABiNQJwtxAG1YuC/oMI + gL2AOwayGzCo362/uAw7erEtRgSgjjSSmn/KG1V3CAyEDQdCAB66GmmTTmCCdaWgRggJZvkBs2GgFqO/ + tRJPfZ03uWwugfFY99Y7IhJuoVV4yuzrhAcgu9oihPEzeJ7cgqUrhQfQrawka9e9iiHDvHEBEcAFw/wE + ATARXGDvj/PJgM6jVdU/dDgee3Ypjpw4oYQEqoFK171bM+hGqelvKFvdaHNQhrV2XYscmtnThh+3b8f1 + N92NkMgUMnRvMnxv8b7OtfMj+OKvhHPt+TKTQCDOcyAPwIGIgAjgL+TZTJw2Da3t9dpOgqqRePBkPWav + JwJYcgBjlx4kIjiE7Me/hmNYrtgtkQQQLpqUuBFqybpXxOO6FSLbeOgUJqyqQuHKGiIB9gbIC1jFICJY + XUkkUEEkUE7eANdSVGHyvB/gmThZdF/a9gB08DKvDeDqxBmXXYW2Dv7O24W2xP2PPCKETExGHicWCn1/ + gZtPTB8dg2oyOlp2CCrnnlVRm43V35Yx20r02SaAJAuI27aExWfa9UcCg/pz/4lJxvGgQkMC0NoWdW/I + QhT0TAnA3YAAbBn/2RGARbMH3c8nKg3fbP9JGHYDueBjpswSbqxI/AkpKyaAWNi5RJBr/yCdPHJ7jwlg + 1+6d8A2IoRDAkgACCIG0mgbRMQhDHMOQWzgLH3/1Lbq7O3Xy1vphF439zgbsHYCqrTDQkv244+774Rcc + RyTkJYz/fDs/gfPY+ImwGHoCOFchAEECjkFEFl647+GHpOH3tup2ElrRTka0+LtK5C/ci7GLDyCPiCB3 + wT74ZF0v1IdEj4Cr7E4c7BqOux57WlNM5s/xXVUtJqyuQMEqJoAjKFhZjfGEwpVVujqBciKCMgoLyjF1 + fTkybl8LO58UReFJ3zdgIFRiUSDEnlx0YjpKyw9pux8ffPIxfIn8Oea3JABnRUykbwKINSAAI1lw42Tf + QFbz/uT0+yCAVr/wtHH9hQF9ssOki644h55shaWEl1z95Tafh16qSO0JCDVJfRmGAMrIL24K8ghK0iVF + 1ARJium6wKR+CCDeMD8wYAIg9z8+PQ/FFZUizj12+gRGkJvM21i8+jvyisME4BlLK1oUCiZfgsaWenES + cUKtsakW+UUX4i8XeOACNnwBP+EBqAQw2CFYZMPPtQsQW6IvLlqNTrFjoCrQNinTiUwS1mdHAC3kwdRj + 1fr1iEkaRS68N63qTEZ+SniiIwBl9dcIQIC8AIcAWv0D6f0GUQwfgI82fSCITm/8UgW4Hb8crcOFK/cg + d9FB5CzZj9FLSxA+/QUMc42U8b+bFBXh7cCrbr6bwqBmbbrSjuMNmErGnb/qGBn+YSIARhXGr6gkVBAJ + kPGvIuNfVSpQyHUOy/chOPc68dzO3JJtsP9vVeKr9QmQofqG4+0P3tU0JCuqKzB81Fi5HajKlPmY14cI + NSnOGfnEagNCLedOiu3oARKAWc+/TvzDlsH3O1GL3X0erScFQnTgMCBlxaSLrzznrDwAKfY53F+d7mtF + APopJ8GWXYF9D//gx8pCiCSTKqpBR5SaD+ibAGzPBhwIAXBb6bhJ01FXXy8IoLiqHDEjcoSCjqrk4+DJ + nYKxAhHxmSguK9GJQHZg/tIlFDt7amGANQGEaPjr0ABkjb8Ijc21JhlwDSbJcmNvoMnGii8n4J6sq8Ft + 99xLRhcgDJyNmcHv5TzF+DUCIIO3JIDzHCQBsPGfT59jdP44nKitVkKWVgu0oLatFbe/exCjF5YQAVAI + sLwUybe8DjvPRG0HRRCBSxhmXXEz2rvV/Ad5KKcbMWNtCcauPEaGfwTjVlTLPgoigILlFUQCZShaWSow + YWUJhQYlmLSmHGPueweOASPEiq7tCnhG9UkALoosGOcj7rj3fgoB5O5IR1czrr3hNqFyZKs9WFagytyR + qyEBxNocHd4XAXicYbFPXwTgFyLha+1BlAdGjvDvKwwY1E/y70oy+B4vmwSgFvtYdAXaJAAJQQDBqgeg + dEAZEQCXFPfpAcT/agJgoc/Lr7sV7Z0dIgT4cdcOBESniZXfQSOAWAGhRkQu4fsffyJKf2ThTCsqjpYj + O78I55KrLQnAXyMANiZe/Qc7hApw0m3ODbejs7tRmVirJ4BGbT5Ar00PQI8WhTSahLT3VdfdiMGOyopP + xnyuYtDncz7CgAD0UI3/PEfOAQSLnofX394gk47KROReTfNfHjvJkOZ/W448IoC8JWXIWlGO9Ie+JAPN + gKOrqYrSzjkUUy65Gq2dzRoBlDY04pL1B4gAjmKcQgD5y4kAlhMBLCsnEqBVn7GCQQTAIDKYvPQAQsfe + IlSYpMhrtK6k14gA1HieCTwGmXlFOHHymKYsvWrtWriyqKkiUmpMANID+OcSQIrhlC3pASiwJoAev9DU + K8+GAAYlpY/7s3do8nuWsbw5ASTpiCDVbMChUcLDNBRBXySUYgh1ZprlLsBAjF9PAEYkoI/juI78roce + FzVv/G/j19/Q6yaIhB/Ld0kdv1hBBNw2zIIWDzz6tLYVKLPybfhi89f0I1C8PUxd/f3J4ANELM24QBBA + CK2sPli4Yo0sJe6VK75+ArDtib4NZkRhGtzRgKaGY7jl1tsw1MFf5B4Gi1U8QPEAAoVxn2uvIwB7IwKQ + 7/U8wlCXENz70GMi+detjUNvsdhibBa7IG/uJgNeeBBjuaSZW4uf2QrXyHFEAMFm6kDjpl2GpvYGUQvA + 31lFYxMufeWQJIAVkgAKmACWVhBKUUDhxPhlZRi/vESgcEWxAIcFmXe9I0RKHJXfRN/UY9Tdp67ivAXs + E5KIbzZvVmoh2vHzzu0IiUiVmpDcFOYTY3Ox6N/4rQnAstTdJH+faEYA/e4ChKbplID63gGwqBB8L2nk + uD/bqgwcZHPvP3x4JD3BMUMCCDEgAC0XYEQAyRajkc0JQL3ejACC+yOAhAETgC24CoWgaLy4ZIUwZ/63 + 7q23hXyzRgDCC4jRCIDlt8YVzURDc4OyNSb32jd9/QWCIpOF66wa/2AlmSYJIIg8BG/EpWVhf8lBZQRW + Y78EYEkCliPEgDqsX7sc9g5eOHeIN/4y1AfnEsmIVd9Rff0AQQLnO0hiOl/E+npI4/8reS72HmG4894H + KCQ6KYdxauPQLQmgRWwLfl56EkXL9mMs9zKQ+541bwc84ifByTVY0wbk5qAxU2ehsb1e2wGpamrCnFe5 + g9GCAJYZE8D45UQAhPEUDhQs3AWfjCvF7+IkREUHQgCyDsTBMwzPvzhPCeHacLr2KEaPLRSirlIiLnpA + BGD73LNNAP15AGbuvqUxh6Yp6kApAzJ+HY5RKB9pKxk4yKb7H5J2I1fwmQggyYAAkrX+Zc9Q05v2Vu6j + r2fmuQDqdZ56YlAkjkz5hGTtNjFOmcOEPrYBzYkg3qxcmBuGnLhxyCzmj9aM381fziF864OP0KsUxT67 + cLnU63dThS0lETh4SoVfB484BNKP8cvOHcILqGusxfMvLYJ/WIIp+89JNDZ6J1rxCeyKu/mGY/ZV12D7 + jq1iYGmPMox0IARgE2T83T2nsWTRXMyaPgsPPvgYbvnb3Rg75UL4RiZgsLO/KPBhw5bbe4EKKcitvvME + AsXtF9B1yZljsOrV9WhsPWEwF9Byfl6zIIAt1acxedV+4b7nUQyfs+gAPFNmwMGKAGaSB1CnEcDh5mbR + hjxulZoDqCT3n4yfjH4cGb9KAAVLZcXh+GXFgggKGBQKJF+5FPY+3OIdpYh3RPcD+fvzrIMLZ12Olo4m + WdvY3YJrbrhJvE+uBbB8rt+aADz0CUAd9CGAl36aVliKgCkMSD5TAuCagBtthQFGVw5KTB//ZyKAD8zr + /WVpojkBmAQMPENM8//kfUyrvNq77KFc59UnAahlkJJw+qsDsOUJCPdeRwDWYUCcEAjxj0zBDz/9Ih36 + 3h7c8dCTUgJMLQFWpbcV2W8xN8A1FPMXL8cvu3fjokuuohg3TMb7ZPSDyZCkmk+IiP25mnDCRdPxyecf + oLXtlM7gm349AXDhUHcdGpsOo7WV4treWjH4s77lGH4+sB3LX16NOdffiIRRueRyskIwewNMBtLlZ+Uh + 94BoZI4rwgtL5qP8aIkytLPeYmS29QBP+XebqOuftuaQWMHHrqxG3pIS+KbPgb1rkPjsGgFMmSk68bgP + AoRjLS249i0y8FXHMZ48gAIl+TduORHAMj0BHNIgSaCUUIaxT34Dt6gCuHnFmG3d9QdHrwjywkah8ki5 + 1gk5b8Eisa3oKkIA2481J4KzJwCPYGuPwDzRrigBKWrbJgJIPisCIHyQmG4cBgwyWv39ItLDyd046hUi + V21R8KOTK9a2ALUkYJIgCC9ltrmW6BMfPNmkbxacrMkfCQSrSNHkkEweQJKuEMg0Etx8UrC+BsAE4dqL + +n9z4xfuIjO8d4wmAhKdmo3SqipRtd/a0YHZN9wmhC2F6KWmta8o+nJIwKq7FNNGxo9EaOwIsdoPdgwV + Rs+u9gVOgWI1PZ/i6pikdCxeuRinG45YGb46q14zfh7MyUM+tQm+9WYQAzw1w1evbyACqCUv4BThJHq6 + yW3vqVVCgyaxzdjZVY9jJyvw447v8OYHr2HpmsWYt3ge5i9dhJffeBXfb9+ME/XVSoFOg6jU6x4QAciW + 6O1H63HR2oNkxFXIX3UYY5aVwj/rajJ6JoBQ0UXJNRW5vH2qI4DjrS24/p1yIoCjKFx5WG7/EQEU0ONV + D6BAhAKK8S+l11h2yBQSLNmH4DG3wsXDInmnbf0Zi4VwgZBnQBS++v4brQ36sy+/gG9wvEjwagrDAyIB + 23kAlQgscwCeFlJ4eiLwVDQAPDUx3RTddrqNJKAC3xCT5oZBDoGnCocbeQGGBOAVmnYlMVCvVPZJMkj4 + 6WWLTO6M8BAUQ9b6nRUBBONkX7IYBOKlG5ssLlvoBqjqKSYSUPQC/BMMIUqBLYo6nJRxX6oUuJAAo9U8 + I38KTtTVin7xeopLJ8yg1cstWIiAipFdVhN3woVM9mA2dKdgRV47VFwWcTTF165+Ubj25lux58Auk+vM + q32PhCQAvStfL9x5uYKfVlBnBS0noB/z3X2acEqghyEIwEQW0Mig2QByG7KvwiNbJCAJoB2bK+tx4RrO + 0FeTO39YKP4E5F5PRk8E4CGFVPn7yiq6mDyTOq1MuaatFTe9W47xRAD82EJBAPT3slLF+FWYCKBwGZHA + cvp7Bf29qgQp1yyDg3eCmYzXQNSC+LddtGK5Ug/QifKqciSNyJETiizCRVsk0DcBxOn6/41JwNOABCxt + zFMXDquKwLJByBy+wRI+thOJvbyjNyACGDN+xv/Syv+qOtfPwyJhIVd200gjscrr3Xou4AlMskkA+i4/ + tSNKLfiR3VK2BEISzVZ/cw/A5Am4Kh6A6AD0MY30YuMXLrwqAsqz+zyiMHnmFWhubxW7AMdOnUT2+Kmi + h9yQANwihL6+1OyXhj/YSerrn+cYjAucA5E5foIYacbTjPhEF7X9Zit/k0EsrxKANGoT+icAE2Gc1h5j + 7i30nUzsG42GBKCWMDMBfHjwFCaLqr3DGLe6GvkryxE09mZBAI4e6hyBUPpeLkZdU63wABgniQBufY/l + wY5gAoUPhcuJAJaVy8SfGQkUWxGAwMoS5D36mZDtclIlwvUEwLqA6m+vqkgp4Fbva26+TcT/vb0daGlr + wozZ1wivwdXvtySAeKt+gLMjgCTFa07RaQWYwgaf/gmAvYBXxxRd8r99EgAzRGDUCE+KO4r15b76Vd4z + WGf4qpFa3ke53RYBuCvDEfX90ZbPaTJ+XawfaIIa+7NkmIC/bviHv4z/HX3lnD+h9282n48JIF4QwPW3 + 3YWunk7R61Z6uBIp2WNFAosJwE5HAKaJOiYMVQZscPzvERSDB558CodPVMlVrleu+j0WVX36eL8HdQK9 + Knr1Bm9u1OYEYGn4py2Iol68jtEKbo0zI4JeXfsxbwOu21FDqze78tUYu6pS6BMGjbtD1N6rU4SYADLG + XUgEcFrTQ6gj0v3be+TKrzhMBFAlCKCQQoBCxQswZf+VbUCK/4soBChkEAEULae/F+yCe8olgtQtCcBy + LJmjrlqQQ7pRY4pw4vQxLQzg4bKiZsA3zpwAvM3lw21OETIiAG3MffwZEoA1rIeG9L99aEEAxUHR6Z6W + XsAgg9r/Aoo52vsiAMs3JXT+z4QA9EMRjCSSdO6/ngTMCSC+fwLwUQZ9ekUrBT3mBMAx/aNPP68McezG + roP7EJ2cLgiAw4BhZpN4rEdqCeOneH9k9jh89OlH6OxpFHF3j261NzKyf30CkHv5LT3teP67Y2SghxUl + ZBb9LEXwuDtF/sRJGeHNSdVRRAC1jac0AmjoaMPd73ORDxEAhQBFOgIoXF4mCoCMCMCEYkyi60PG/U38 + rmdCADwCzj8iEdt/2apoO3Tjw08+hneg0kXqo9st8o2WvQdeuqKiARKAW4AcIcaj4n8NAXj+NgTQ7hee + VmC5HTjIoPrvSaPGH7NqwGA1qaeXMU42c1m063Qxv4e2t28iAHFdULJZgqTfmQFmhUAJmttvOf6LXUOT + +y+z+CYCiBPlpMvXrFWKerrx6Xdfwj9EykjZEQEMNSIAMZEnDIMp3vcNjcfdjzyKisNlohTX1L7bd1OP + cUa/3jDuN4ft8MCaAEw7Bb8dAchGIyE1Rh5ATVszbnu/DAXLuYy3HGMYy8go8+8QCUA9AYzMn0IEcFKT + KWvsJAL4oEQkD9kDMCcASQJ6T6CQnrdIoNhEACvLED/nJfpNY/sggAjZQqwOCxUyYFw8FIqVa9cqm7+d + KC47hIS00XKIKI+P95KTfq679T6MyiqSo9G9lJmFPIh0QAQQY0YAfTXCWZbKe1i4+mfSQtxHX8GTNj0A + 3iKITBp9Ht3xSzOBQisCsBb+tBQA1Usce1pU9ukJwF2/jah1AyZaTQ3qlwAUARAXiwSOGv87KBN5OYFn + rwzpdPaMFaKi73wgFX64Z/7eRx6hHzpIEMAwMwIIU0ZsR5LbHy6KZSbNmI2vf/ge7T1SHLRHa3Rp+jsS + gO0EoW0CaPjNCEDtNOxVJM52n2zAjPUHRQFPPsXuuQQWOxUEwEKeXmFCtJO3UUeOnYzTjSc0AmkgArjr + /WKR/TcmgHLzSkALAphAIcBEIoCMu96CvX+aHBVmRAD8+l7h4rIkADkEhhOUN97KJdly9Hxzay0unD6b + VnveDowT4JX/voefwY9bdyArZ4LQJnQRcwqjDHMBtgjATUwSju8zGehlY5X/LQmAbTs6Oec8/XbgILPt + v7DhoV7ByUfVTKO652/lAYToV389AaSYCniUv03TTkx/mzwA/X2SZNGPhQdgCgHidTB1AorV318v8aUn + gEix78sGGxCVirTsiSKZ56DUj/Mk1y+/+UZUAP6wdauQ9bJ3CRZqwOz+D1USfuok3sF0fXRqFhatWiFO + ZimSJY3BXMCjcYDGb9re6xGo72fVN1r9ra+zJoDGAWBgHoDaDNRJpPfOHnL/lx0Q1Xtjl5QgZ2kpchYX + I3jsHULT39lbTvPhwqpR+ZNwuqFGIwDhAbzLCb1Kmx5AodjzL7VJABNWcD3At3AKH6t1/Kmy8Y6eUjjE + QYEMASKVqkHp1mdyHqC2RkiG9/a24YFHHhPblmprMDcapWYU4PCxE/h5x27kkRfj5BGmzSe0nQyM1dx/ + OUE4VtsWHCgBeFp0DJ6RiIg6rdv6Nt4ODNV7AYPMq/9Sp9Fq3SVVfJNNlUsh5qXAakGPIQHYKOn10N2m + in54GnT+GU0MMlIBUrcBOd539jcXBjVt/UUK9nfzD8eilavxtwefEXG7EIMkBNKXtH3HTpw8fRoXEfs7 + OFPs7yyn3PB0m6Gq+09/u5DLeOlV12DH/t2a0Xf3qr38jf2uorYq+XpFHkAnAqLt/Rtl+o3IwVYOwCjn + 0NdWX+OACECVNWvs7sRjm0oxdvEhMv5SjFlcgtFEAtkLDyIw73Zh9E6KbLcDGc2o/IlWBHDvO5zUqxDG + b5QD0KNouUoAJRoBcJPQ+Pm/wCNlplbGq237acNFInQ5AN1QEfr9AyKTsXPfLiUM6MZrb75JK7/0AFy8 + ZQcghw6rXn5dLBI7du9DXsE0IVVumwAUw/fXI9asLkCFLQIw8wRU0Z0zUBLSh+4Wt3X5hqZMs0kA3sEp + z3gpxTh6AvCwKN/VdwIOlAA8DQnANBXVkgDkl5RggwDihVQ4r/6CAAzKfeX2DzN1OO55+FFh5AWTZmGo + U4js86dVPTIuA5988TUuv/YmOLgGiVl3JgKQYcAQ5wBEJg7HohVL0NB0SnH3TfXxv44AlO0/HQHY3uqr + 7YMALG+rlx4FpGehPWdvX8bdHwHIHgC1m2/3ySZcsv4QufwVGEMEkEcrfzaRQNb8/fDLvkEJAaQHwBN7 + R40twqmG4xoBNHW24/73iADo8UXLyAsgIihcVt4HAZSS0TNK5OovCIBzAfsQOPZWuROg3/c3IAAnMURE + VQuOFu/vrQ/eU1SRu/HLrh0IjkwlcogRE355q5gbo3IKpuDE6VqRKfpp5x7yHCaLRKJNAvA3KQWZxEJs + dwnqm4Q81SS4Vnh39gRg1JVLocEzRgQwKCYl96/0hJ9ZqpQaEYBVV59W868nDvMcgPkugLrlp2M7nV66 + mgNQ3X/LEl8hCR4QJ4zfVqOPk7cU/bz5rntR11yP7378kV4/TkhVi/Jecu8Dw4eTi1eIoc7+GOYcpM24 + kwgitz8Ak2dchO27toqhEkJhl/exe+Q2n3U83dhHxr+/HIDFnn2/+QBb+YHaAeUGzrwWoFmQH88cYOnU + FT9WYtzi/WT8FWL1z1t0CDmLyAN4cQe8h8+gsCtEIYAoQQAj8wpwqv6YNq+gqauNCGAfEQAbP3kAS8nw + RcxvvQWo5QEUL4CNf9IySQITVhYj9pJnYS8KgqLM8j62oJLAUJdQPPr8PK2zs+b0cWTkFcHBncMEOUOS + xWB4K3PN+jcVsfdubNn+C503RVJkxM92l6CVWlCAfmvQulVYnwjXpgb1kQOwKiEONTB8bYyYlhP4LDYt + 769qHmCQuvpTbOBLT1hhSQBWSUADAjBS/pFFRCYCUDv+zAgg+CwJQLfVZ1SmyY0f/MX/7YGHye08hc7u + dtx0x/30gwdrdf6yTTUEgx0DiAACFchBl3zZxSsYd953D2pOHVZi/TYhJMGS0nL1/08kAKkFcOh0Iy5f + vwu55P7nLabVf1GxUAXKXUgE8NRWuMQUEAGEKko9kZIARufjVN0xkwfQ1Yr7399Lhl+BiSoBLC0zrAEw + JwAyegoBmAAm8uWVpUi7eT3s/VJlIlDx/iyNnl15SwLg3ZxZ194o1Jk4EcgCIbOvvhF2rpxHiBdbxc50 + tHMJR+boKag+VqMMgevFex9/hZCYUVpjmX4XyrZcmBEBJAyIAAYCWwQg7U+7riIgcoSv6gVoBOAdmjKa + XqxV/4Ia04SYa5Xr6/U9jZhIS1wkaxVMpunApn5os9qCIBXmCUDziUCxNvv8ebQXq/s6CummONx2z/2o + E9tO7dj841YERaSJXn7TnL9QxdiDCUHS+J0p7ncMhk9QNOYtmYfGttNyplxvu9TV75WDJSRadQq8pgaZ + AW0DCte/foAE0F8S0JIATlvdr7u3VsAUHgyUCExbiF2K8jAb7rwvSoUWYN6SQ0QCxchZfJBwgFCKEXdt + hL3o1Q9TCCBCJNZGZOejpvaoIifWimZ6ngff34PCJWVk1OUCwgPozwvQJwG5GIiHmT60EU7Bo+g8iBCt + 3Ax11LhjHx4A93Wkj5mAk3WnlMagdjzzwlxaJPg+CYIAHD3jhJAIy5o98+IiZXBaB9p6uvDsgmXCiF18 + rJPQpm3CGLMdAi2RHWiCR1A8ne8Jhv0CXme43+/V/31YK3C0RgA9PXLyj2dI8s2eFp14puEExtJeA4Ku + GchyH9Srj+pCPQEYGb8VAbDxCwKIxqVX30Du3FFx4ja2nMLsq24SST3O5OuN30QAwWKizVDHUIRGJeGV + NzaISbKsp89HniyrKsjIQRvtFuO2Ws5A3LNeV/gzUAKwXfRjTACnLQjgtIDpuoEQgHn9ABNAO33Wj/ce + xbSFO4XLP2bxIeEFMAGMFsKgJYi59CUMc4/RKfaGiZqAEdnjcNyMAFrw8Pu7iQBKheGbEUCfXoCJALga + sJAIoOC57+AWM1bZnlOgLwn2MiYAJofA6OHYdWCvNifxg43vCzl39gAYjl6cCIwV28BhcXTf/QeUqpEu + nGqqxRU33inDTZ+4fsRDY81nBQTGmUGSgPHuwJkQwEDgG5Z6M9u8sH1mgYefeOG/aJVf7mm59xhiLO7p + FWKK+y2794zGG5m2BpNsdkKJasLAREMPYEAEQG4/z3DPLZyMg2X7Nbd17auvipFP3MEnZtaJQp5QudXH + oFVfwCkEyelZ2PTlx2KkF3q7aaXskArAvVJEkvXkpaKsSgBtFjp5zYaa/mflAZj1BViu7H1tB1rDnABq + xXOrW5DGht+ozRro1gigFT8fPoWrV/2MMS/t1wggTyWAJeQFLNgNn1FXiTyLnOWnEIAbEcBo1hc8pkwn + IgLobsWjH1IIQATA7v8EjQDI+JeVyNZfgRKLv1UC4HLgQyIROGHhz/AafpF5V6Bu7LcsBovU4KSrCOQi + sdfffUdRCOrAnv27EBE7Qug/OnkmKEQgvYChzgG4/ua/obWdz4kuIQRzqKoCY6fMFP0GZ0sAHoHWHoDl + 1KDfEj6hKcsffmLuf6khwKDIpOzz6IW+1bYdQpJsFgKJOCNEqfpTk3vBfXsI2vah1iJs4AVw/B+QZFYI + ZEkAll+uGQHQD8BKuN9s/lobj7X/0AEkpediiJhWEyagVvbZ60hgqFMwcsZNwvad22RZMI/16u1RssO9 + 2uw8uV3UpawWei+gTecJWApnDLQQyBzSbbe18psIobu3TqDvLUIL9NbqtiD7XvWl69+CAyca8LdX9qJg + /h4y+n208h8gAjiIMSIMoPh/STEyHvsSdkEZ2lRfdVQXE0B6zjicJA9AzQG0dLfhsY/2Cw/ARADKyr+s + WKcDYNkUpC8HPkAewQFMXLoXgWNukO3ePjIHpBYFOdnoDJR6gTGiyIurOXsUpWAeGJKTP5m8lihJAIIE + 4oQqNOtE8lDRt96VAjKdve1iIPzW3bsxIneCeM4zJ4D4PrcEf4WR21YRDkv9NjolVxQEDVISgD6cAFSL + fjRlH1FQkGKeBOTrwpSpwPoMY2g/Cqb8PCHWtc1eisiIZYJwIASggQjAMzASi5YtQk+3rMVvbK3F1Tfc + Tm59gNCpt3MxIgBe/QMwRngNh5Qpv73o7O5AXX0dqo9U41BZKfYc2I9d+/Zgz8H9qKiqwuna0+gQst56 + Mmi1Cgl6bWwR/n4IoN5wu08UNvXKYSU8hmzn8Qbc8foBFCzcRwZPRr+Us/8HhPHnkeHn8pEMNHLW8xji + Jg3ekbUAlIm+rK40Mjsfp2qPaN9Ra08bHt+4H0WLSzBhiSSAomWlouDHnACK+yYAwuTlBxE59SHYKW3e + DBeVAGwZv7JwcB6g6KJZaG5tFJ2BHZ3NuP6mO6QsvCet/p7SA3D2lCTgQNcPH5WPg6Vlck9AjDvrwqff + bkF44mgrEjAnAN1WoIj/JQH0NzJsoDMC+iMAnUJQRXD0SJ9B6j/vsJQ0MsxGrepPkSES4MmkeoSlaQKF + GlTlEr0kmEE5o2n+uXntgNQdUCsEzUuBzQlAjvNS4eorBzq6kqt5zQ3Xo77xJJ3gciruulffJLaOUZJ7 + IUoIEKoRgAgH6DoeFsGTYw8fP4qPPv0cTz0/D7MuvxYZowsQFT8C/mGJ8A2Og29QLPxDEhAZm46RmYW4 + 5LLr8OSz8/Dpl9+i5sRxLUfQrQz/VIlgIDsFhrsGfRb72M74q4TQ3ds3AZi/nq7Qp7dFG0F2orMFb+8/ + jStfKUU+r/ZkhGMV8OW8ZYxS5JLRZs39CS4JU8S+uYMyTt1RmejLBJCemUer62FZR6EQwFMf78OExSYP + gAmAt/kKzQjgkGb4hQIHCQcU7BPgpqCEOS9hmHei0P7TF4JJ2CYArh+IH5GDqqPVWmfggkXLpSQcG72X + BXhADJ1T11Hs39TaLCYqd1GIyIPilq5/g87nREPhELMEoEU9QF8EMFDxz74IwEIejNEYEDk8TSMAWoEv + IWPt8dRXECkE4CX0/PonAEtNQI8BEoBHHwRg7QFEmxk/w8k7DDljxqCkdI8SX7Zj7/4DSByeS4bPCT7p + 5rO7rycA2dwTirzCC3E1/ZixyZli7/qvdt5CvPN81vi3CxBTfQY7hmCIUwgGM1jyy56lv70xmOBCru4I + WhGefu4lHCguESeEPjfw2xFA7d+VAHq1Tj+Kz3ta8cOxBty1sRwF3HfPTT7LSzGWjDOfwMcxZHR5AqXI + W1mK2BtW4wLPGFFCba+bqKwSwAgigBOnq6UaMr1GW087ntl0EBOXlIkioF9DABPIA0i7cRWG+iaJSc8D + IQCJaCH17hOagG2/bNM8uk8++1yM/2Zjd7YgAc4N8JBSnge4+pXXxLZgZ2+nSBg3tjXhpjseEFufrj79 + eAADnBtoaeS/EQH0+IWnXTJo0H9rBPCAKvcl9xFThCChV2iqIkWcakgAlpqAXqEpNguIvHWjwz36IgDW + CgiUCUGt519HAMLweYQzD2kkFy8sOgGbvnhXduPRqtLQ1CCz/i5BZOAU3yvgy5rxqwTAmvV0+XzW82ND + F0M8AgW4zVdo+juGKKIfoRjMUDQABLE4EcGwBPcwH1ww1BeRMSPx6ONzcfjocXEy9Rh6AP0kCLUkYL0G + LWFn+beh4fdFAPK6XpwSSkAmNPPGFqpbW/FJRT0e/OKYmMuXw809KysJFaLTL395GYG8gRWl9LdE3uoK + ZM/dDufE6fSdBws5NTtLAqDLw7PyUHO6SiOAdiKAZz9jAijFxOUDJQBp/EVLGPtNBEBhwKg73oSd33CR + 2OPY3klfFmwLfF8e+kIk/tZ7aiKwjUK+HSIUBgAAgABJREFU3QiJThNFQM5iHoQFCRDs3CIRm5qLHQc4 + 4dyleH5t2F9agvTsCbJz0KhZKEDpE/CP61M6fKANPwMNDQyEQh8Qxn/xZdefQ3dY7WVBAF4Wq7yXzgvw + CrHsBFTnBCbZbGlUhQ49Qqy7CM26BM3kv+KtCUCd4U5HT99QPPPC4+jorhMxK8dwK9euJzcwTKr5KMY+ + VG/4ZgQQKgmCtwCdpLAHD/M8dygPzwgQAzKGOHMXYZToBBxC97vAMVSIfQ5xDBE7B8McgzCEtfhZWXeY + FwYTsnOm4utvZfVgjyag2WyxS9DUNwEY5AvMrzPvGRgYATBOoa75OPYfPYoDNaew7cgJvLX3GJ74vBSX + vHpIjPfKWFxGx0rkkmGK1X9FBcYS8unv/BVlGLeyHGMZq4gUyPgCJt4r5v/Z68aCGxNAtfDQ2Mg6iACe + ++yAJIAVZ0MA+zQCKFp2ENn3fQT7wAxN7akvAnD0UuThPOXUZ64Cfe7FuYpUeCuOnTqCtKxxIuknuwfj + REGQKAzyjtdIYCh95mtvvRNtHW1CIr5LVEp2YO2Gt+DNpeqiUtCSANQGIZNikKVWwJlMDf4VBLB6xuwb + zhkUlZxzLhnp555WBCAlwTQCUKS91ev1oqC2hAs8LT0AFjpUxUEN+gg8NAJINCMAN/7y1EmsvnI+u6tX + BC6+ZDq5lZVCyZZXsV27dyMxNQt2HsGiA1BT8zEiAKXNl2NW1slnBZuQ6EwUTJ6DG+98GE+9uBzLX3kX + r76/CW9+/AVe3/gZlr36Fh5+ZgEuueo2xAwfS68TLmTAhwzzp7DAl+BDZOBDJOKBoPBUvP72B+KEsJbU + HjgBGJNCvdwm7DV2/U2FP+bbiCwcytqBVScqce2Ti5B45XwMf+ArpD31M1Ke34sR8w8hfRERwJJijCbD + zOH4nl385ZIE8gls/ONW0eXVlUKeO272XAymVZJXfzPjtyCAtMxcHDtdpWyhthMBdOB58gAmLP2VBEDH + AiKh7Mc+g0NYjib6anvVl/v/YjuQJeKY2J0Ccf0tt9P3I/MTze2NmDJjDhzdIgQBuIiyYB0BeMv6ADuP + KKEJ8dV3W4SiVJdSKl3bVI/LrrhFjCxztSwGGgABDHQL8NcQgE9YyucxqXnnDvKPGuFGxrvHw4wAkpVM + f7KOAFLMyg09dMU77ropJ/piH3Mm0w0A0Ugi2axTUM4BTLTq+VdnsLupDRa0+kfFJ2HLj98q9fmtqG84 + hcsuv1FKeLMIhUe4Ts/PmAQucAqCZ0AcLrz0Gqx7810cqqhCQ1uT2NrpFVt+PTp0K6PAyFnuakHZkWqs + efMdjJk0E3bO5C3YeZJn4C1IgHH+UE/4kqv31nsfKgNEBkYAA8oPKEpCDMtdAHX3wFT5Z8oZsPF3dZ1E + R+cp7CzZj0seWYvwWz5B/CM7kDT3ANLmFyN9YTFGLi5GFnf3LZUtvrnLJAmw4g8b/7g1hNWlSLx2CRx8 + U0UDlYOLaRagSgBOOgJIycjB0VOVooiKv4/2nk48/zkRwLIzJwA1/hcksHgv8pfuR9ZT38AlerxJxsvL + GJZThPl9ciXohAtnkuHXiy1P3t67/Z77iQBCrAhAGL+PhIN3nGgvv+SKG1Df2ig8vi4RCrRj87ZtiIjL + FOpCZ0MAeqGQ32jv30QYMr+3Jyh2pNsgn/DUcDLew1YEoBi66gWoE0nkdl5yv9JFhk0LakegJQEEqUNA + kwxFP/QEwKu/u284nnzuCXT1cNzfKkp1Fy9fDXf/WFEMpFZ8WZKAngycvMmDmHMtvtiyBU3tLcLIe0RK + h35E3t/lIiCR1dejTQBKEVA33f943Sk8tWABfY5IIgEvIgFf4Q0MYY9gqDdiE0dh1759SmKw6TcigPp+ + CaDHggBU5WBBAO0n0NJ6At/uPoiMuz9AzH1bkfTCfqS+dAgjFpAXsPAQMhYRCZAXIDyBpWVEAGXkBZTR + yl8hBDkTrp4PB/9Eqf/Po9RdwwxXfwYPWk0elUsEUKWQaCd5AJ144bNfTwCMfLo8+pnv4BpXZJrsMwDj + F2ChGPIC0zIoRKk9JuJ4Jv+XFi+hzxGiqAPpCMDHRACOPgnkCZDxBsbj/U2bRCKwW3gBLWjvbsa9Dz2l + NAzFm7cK/z4I4LB/5PBwlgDLJmNssNlaaKlAGppiU6BAtCEGJdl0ZawkkdQwoS/VH/ri3IXRMwGwJFM4 + CqdMxdET1cqI7i7s3LUXCal5yqw4OTCS+72ZAPQkYK9o1PtHpGLBijWoa20Wrlu3YtA9WpmvEVq1+6hZ + fnW7j/fKV732Kr23MCIBH40EhjrwboEXrrn+DrS162sDzo4AzghmKkOm1b+z8wTa22vQ3HIUVcePYs6L + nxMB/Ijk5w8hjQhg+PyDggRGcihAXkAmEUA2EcDoZRXIXclDO/cj5cqX4OCXSAYfSKu7FFDlcl+VAMRk + Jd34bkkAeRRbHxbVdmoI8AJ5ABOXlWGCmgQUIiAlBsVA5rsAMgSQJDB+yV6MJRLIIQJwi59oEu/0NicB + J93CYOYB8OQnOidCo1NwqOyg0hPQg7c/+ECca5IAFCgaAS5k/M4+CQopJIhBpdNpMWlob1AWimYRSuwj + Lys5c5yoUHT3JeP3jTXoC+ibAM6o7H6A7cIKETT4hadlD6IrptMd2wdKAP31A/SrdmLjg6oKP0YTfoTx + +7AWWySCIxPwyZcfi9Wav+zm1hZcdf2d8gdVJb95ZpxHtDLWK9yMCFizf+nql8nNI+roJfOnlV52+bUZ + GH2bwVjsVsNR2S0dDZg84woxn48TgkPs/cSwTiYBL3IBv/7mB2Vn4B9EAGbJQnMCaCMCaGo5gqMnj+Ge + 9VsQ9/A2CgFKkPLSQQoDDmokIMIBQQSlyFpKsf/crUiefp9otmL9BEe3IB0BhGgEYG9EABljcPzUEa3p + RhJAsRUBjF9hqvsfOAHsRd6z38MjaapcAHhaUB8E4GhBAFy45BkQiR+2/6jUAnRjy7YfRXyvyoOxQpCr + j4kAXHwSBNSkoH94Krb8vF0sSj29UjeBF4Z5S1fQwhUnCMDd11g2/O9JAEb2q+QN2n1DU6YzAdxGd+jp + z9DPtCHI+IMkGtY8mwjAoKXSl9wlkfgLh6tnIO669060d7aS8XaJ1XvDWx/Bh8ITZ2H8sZIEeGtHqABL + UUhxQnrIrP/w7AIcO0nG0EuOXk+X7PRTCMDSA1C7/np0xt6jg0YAXDXX24Q5196Cc4f6iF2BoQyHAAxT + 6gZuueNBdHR3/kMJQPUE1AEiXV2ndARwFEeIAB5+Zwfin/oFiS+WImX+IaSS8aeR8Q9fUCyQRuFA1gJy + se9+C5EZM+BChu7oHKAQQLBwkx2VCUDaKDWPCDND42q7lKx81AgZbukBcB3A819wb/+ZE4AaBogcABPA + 4r0Y/dwWeKZcrCkDSQJQZcBMzT/yPUWY4CG7FZ3Je/vw000KAXShuPyQUIjmTL6bT6yAiQBUEmBPII7C + gjghNf7Is88Kb1IVi2ESOHLiCMYUThdjx9x94/smgMAkK6h2Y2xniX3cpthtkISBHfcQEdzGBPCcLbbo + U3zgjAmAj7L10XJaiode5tuCAHgvVaz+XsEYMXIkSkr3iXp9dtyPnTiJMeNnKu5ZrIkAvGIUGXCdMqxg + +nDEJGVj247dMrXXK1t9exXjV+N8k7E3a22wqtF2K/XxJoXcDvFYHjUVHp8uxnLzZOAhCuQ2oT+ShufR + yXBcqQ5sPAsCsKXf148akRIG8AgxEwEcR1PzEVSfOIoH3t2NxOf2IHleGRk/EcCCg8Lo08j4+e/h8w8g + 447XEBSVCVfXQDiT4Tu5BMKRIQaAmhu/IACLlZaTgKnZ4wQB9CrfVyt97899WaoQQPnZE8Bi6QGMfn4r + vFJnyi07nxhDAjC5/mqjUoSWB2D9grWvvy5rAei8OH7qKEbmjRUzA918YgRclQnDejj5Sjh6RiFjbCGd + k9XaVGU5Cr0DK9dtgIefSgCmAbbWBJBsBWlPCTaMP8HGbfpuXLLbwCSziVs6T+C5QXTFGlsug6323f4I + wNNA2ltd/UUNtK4KSm/8tj2ASHj6hWDl6mUigSQMl/5btf51eHPi0FsZAya2f2KULq9oqzZQR49IUf6b + TnHZpi++RmtHm9Lg02PR7GOq8YeS9DNBauJ1dDfjVO0x/Lj9Bzz0+NMIjR0uhm0OVgeEEoYQhtLfDA+f + KGz95RfxHNYFQX2JdDYaTOhptLi+0XDl7xawJICTaG07LgaKlh0/jLve2EHx/z5y/8vJ+IuV1f+QCAXS + 5h3A8Bf2IOnyJbSCkQG4+GkE4ERkwB6AE3kATu5h5iSgGL8ZAZAHcFwQgCTZNiKA579SjF/vAei0AIwJ + 4BCKtO1AGQLkE3Je2A7v4ZfJun2tFyBSgxN3AipCoXoPQL7PCFHBOG+pHBfGXZ9NLXWYcOF0cR9p/OqI + cXMScPZVwEKiFOq9IyTG1DBA5gIqj1RjBHmenEx080+0IgDe+eL5GSoG5gEkWngAasdtsvkWPC20AsZe + wJpBZJwf9hVzWLvrSQNa/Y3kvY2TfX0YvwJnzxBcPHOmnFkvSm27iKFPoWDCZVp85mLRGeikawM1hQLS + NWV3LSAsFTMvvxlPzV2I1a++jrc/3Ij3PvmE8DHe37gJb723ERvefBfrNryOlWtfxqIVqzB34VI89sxc + 3Hb3Q7hkzvUYlVMEX2JgUWKsTgkSJcPBGOIUZIahTgF4d+Mniscw0IEdAx3uoSeBJjGOrJsHh6rorUMn + hQFdFAZ0dp5CS2sNGhqP4uCRY7j+5d1ImXuQjL+cVn5y+xfyTsBBDH9pP9Je3I+U53ch7cGvETL6WjiT + sTMBOCvxv5O7SgChAtr2n0WiTdQBCAI4qvUCMAHM/boCE1dWmHYBhBS4aTKQEQEUESbwcYklAfwE7xGz + hRcoGoK81ByAFCXhFV/Ig3uZVn5HnafC4eGjTz+nhSidrA505bXifq5WDWjWngCTwDA6v6699Q56rKoX + aWqlfvCxp0WY6uaXqI2xkwSgm31pYDMDWnCtiuqsO29tPPZDJoAtlpn5vo371xGAadXvnwB4B4DLfsNi + EvD9D9/J1V+Ic/Rg3atvwzcojbyDeIUAYgwJwHw2oBwOwl6CI88G9JT7uq5+9D5YaZh/FFF4FC8Gh3Ch + iL0yDJQLhlhDboiLnAXIGOoaIUpCxcxA3aiwIc4hdL9gCYUAOA+w+pUNZ0AApgYdAV5RzIRIm7Treywq + DG0SQNdptLefREvLMTQ0HMPPJTWYsWofufplGLGwglBCKBYJwOHz9iFt7l4igB1IemY7Eq5ZCdeg4XB2 + CRwAAURYEECEQgBHtFLgDiKAed9UYeKqSkxaWSk8gbMlgHGE3Lm/EAHMGRABqJ6Jo04ujMuX77z3IU3n + gXNCN9121xkQAIWd5HWkZo7BsePVOk+vUXze77dvR0h0Op3P8WYTrVUC8Ag8OwLwVPQ33UOsCcCj/4Tg + lkEeQUl79Xp8VhV9fYwz8rDQ9jMND7U2fMvV3zLjb9nyKwiAt/8o9n/iqSdo9Wqjk1m6/kdrajCu6BK4 + esVriRnnfghAzQ5rOwXecWIrx8U3ES7Eys50dOJ9XfqBnHwTtEIPe5aD8oiWcGdCiBaikY7uPGWWvQla + PegEH9oPAVzg4IcV61YrJ4ZaFNRitpMg24o7lEx5h5KXaNV1FjYr9+vQBCzkkI4WZUuyWUcA9WalwUwA + nZ21aGs7SfH/cZyqP4p3dhxG3hJa7Wn1TycCSCcCEJl/IoARwgPYi9S5u5D0/M9IvfsD+MeNg6trAFzd + KATQEYA6A1CFZYwtcwD5osRWI4CeNsz/rgqTVjMJVKFohToXsG8CKFTagfVJQCaAvBd3wGvEpSIBbJMA + +hAKZQK44dY7dbtBHbjrvgfhTKu6q5oDMGxFp3PXVx1IGwdv8gi///EHs1CP80Y8Gn3mnBtFdaCbr+Uo + cYvht7xA6jQB+xoa4mUgz98fAeiwlwmg3EQA5jP++kvuufdBAJ79DfrsjwBY8MMjDDl5eTh8pEIosEhl + nl6sWvcKxf7x4kdRY7J+CcBbTwCxYvtGbOMQ2OAtoREA3dfeM1YQARu/ngC4jNSB8wqEIXQCca/AUOEd + mAiA25GHcCLQOQCvvvOGBQGoycZ2YcxlVdV4+IWFuPfJF7Dlp5/RyVuUmuBIiyh3bmtvxKdff4MFFJJ8 + /t1mtHa2KsUrJlmyPgmg9RQammpQdvI4Hv+sAqMWkdEvKhcYuagMI4kERi0gEph/gEiAvIAX91CIsBMj + H9iE0OSJGgE4KwSgTgC2JoEwKwI4rhAAFA/gpW8PY+Lq6t+AAPYRAfwMz+GX9O0B9EUARODX3Hib6O+X + rd2duO+hx+DCk4LELkB/BCDBu00rxbg5cwLg3+iNd96HF8+x9NE3CcVp0631MzAHQgCm4T2pFjAV6/Xj + AZQPcg9KOqYKcooinj4mkViSgId+mKfF4FDPfkkg3owEzFt+o4Xr7+UbhtffeE3un/fI8lxe/fPGXwQX + r2gl7o8xM34zKHXhWn04Gb+jRgBx0s3n4Q8C8WZg43egE8me7i+MX9QVRAnwVGG5+kcIcDnoULdwDOGR + 4QwXSwIIpLAiEt9u+15ZAfWrf5sw/sojR5A1/lL811998V9/8oAHfUevvfux6DRTaxLYQ1i8fJ0IRf77 + rx5idsHzC5eLxhr9zoUIH5gEOAnIREDo7KlDRxd7AKdR13AS35Uew8zXyjBqSTlGLWYioONC+lshgFEL + DiKdSWDeXqQRRj30BUKTJsLNNVASgHugGKNm2wuwIAAOAU6aCKCdCOBFIoAJqyQBTFhhmgo0fnmZVgyk + QUcAYieAuwEVAshnApi7HR4pFymCIKoikDoMZGAewLU33W5GAPc+9Ah5mZHCy7RJAEIMVBoyEwHng26/ + 6x5Rnt6tIwBOCB45fhjZeVNEQrIvAhCdsIpNSk1NE3iWhhzBJ4V2pdhuqjlCUrRyfUPDVx8bknyMCCC5 + TryYwcTRgW7xGZYF91Hw01f8r/b8i8TfJTMpVq0XGn29IivfQ270a/RFx4mtP2dv2zPcJQHEmsFEACY4 + cj6AGF5CZ/xecdL4WT2WcwEekWawUwxfQMkBDHELxWC3EAx2NScA3hpMGDEa1ScOa9qBJte/TXyuVeve + wDnnBeN/zgvB//uLHwb9ryvyCmeiubVZCwtq608hZcQ4/DcRxDl/9aGjK4Kj0lBWXaHM7LPIB/Q2aXmA + zu56QQCt7bU4evoUlnxfjTErS5FBBJCxmEDGn7GwVEAlAPYC0ufvw4j5+5H54OcIjBoDNzJ+V3drAhA5 + AFsEQG50CsfGJw5r6kkiCfiNOQEU6QeDGqgB67cBxzMBLN6r5AD2IfepLXCLm6wJgricIQFwY9hNd9yl + 1YHw8c577lNCgD48AA0yFLWnhWDSRZegpa3OavuYw7lHn3peEICbkuNy81MnXenyY+yJ66ZnWw7b0bT+ + bcCIALwNZnvS33WDKF5osZxD1i8B2CjpPTMCsOUBxAh118CwaHz+5aeyRr9HFmecrqvFuEkzxSqsbvcZ + G74EC4U6+cRoq4IMA6K1bUKVEBw0xAqIFZ9jfzJ8O14dPC0NP9wMrC8v4n82fCKAIRoBSNXh8+x8cPPf + 7pMKw5pcmJ4AuvHGuxvxp6Eh+N/zQvG/5AUM+n+uuPDS69DW2aqtSCdPnURMQi7++/888T9/8cI5/+cE + v+BoFFcUG7QaN0kvQEcA7YIATmPX4Rrc8E45spZVIIsIIFMx/Axa/bXjgkPkDRwkHBDIuus9eAcOJwII + 0hFA8IAJIDkjT+yR6wngRSKAogETgGr8ah2A9ACYAAro79EPfw3XiAJlr/4sCIB+s3seelQTfeVcwI23 + 3iHCUC0H0CcJyC1C3mrOyC2gc/W4VXKWP/fmrT8iKIq+R1+lPNgvTskBmKTx9dOz9dOzNCjTub25Q9cQ + UqHL01ZJsMkDaOFdgE4zww4xDRawnXU0TjB4DpAAjEp+3ZQBn+xuOdEJdPlVV6K1jXXaOoU6LxMB7917 + BsfL1btPlRdldVekwp2UGgGTMqwpKSgrBs1hrxi+vafRim/cXDRUJz5iQqggAFefEHwlhpAykbVYlRLz + 6l5TexoTpl+Fc84NxP/3Z1+Exmfhm63blNJSSRRcufjcC0uEEMl//8kJg+3d8cjjj9DK3mRcL2BJAN21 + aOqoxQf7azB5XRlyllZgNLn+mQsUo19UTMdiIgSJjEWHkLn4ELKXlGHkDavhRt+vq0cQXHTGP5AcAJfb + JmWMEf0bKgFwCDDvO4r9V1eKnYCBEYBi+EtNWgCCAJYTSd3zAVyCsuGuGKupFJhJQCYk+/YAgvD0C3PF + byQGwXS3Ys5V1wpPVOpPxOgKgoxJQEiM0XMlDs/C4aOVBpJwzahtrsXE6XNEgZEoD/bjnSdlK1Cdmq2D + 1i1rYaN61S4jDLBNuJMLgXq0oh8dAfS97fDrCMAoEaiu/q50kvkGRuHTzz6RAg0i8dclkoC33/u4FGnw + ih4YAfiYCIANPjgmHUHRI8hoQ5WpsWrXoISI7dn46fIwJbnHWX69uz/Mzbi12JgAyBNw8MFFsy5FU0sD + entk2bBxP0EbDtccwXMLVuCx55di18FiWZostv5atcx0a2czNn7xKZ6kk3XjZ59RiFAnXH3DrUQDAqhp + rcdz3x5B/soK5CypQDa5/llMAOT2Z5Dbzys/G3/2ohJkcVvwEpb/qkDyzGco9g+2SQBqP4AhAbBRjMqj + z1elEUAHHRf8cOQsCOCAGQEILD+EEbe8DGf/kUQAsaJ815wAImwSgFqwZEcEsHzNaq0AjBefKRfOJEMN + tUkAeu0/mRCMET0H8SkZqKgqlSpVVlWkbXhxyXLxHrk3gAnAQyEAN1UNq18CSLLW7jw7AugZdKYlvQOF + Rx+FQGrSw4oAWNufjGnKRdPR1FQnin5U9//YiRMYmTNZyjQNkACclMpADgG4CGjKJVdi/RtvIiQ2TSoD + 6xqFZOOQutqTW2+1yqsrvWrswTqo8wSDpRSZcnmoUyC8A0Lw+defKyt5k5U4iD4hKBNknVolomw5Vrf5 + 5ESibu0+PYqGcbttAlC2BLuIADq66ogA6rD/dAOufZs1/srFJJ/sBSWEUvICDinGTys+rfyjlxAJsDAI + GWPRyirEFP0NziL5Z+H2q41AOphvB0oPIDYtCxVHy7RtQG67XvXzMRSursAEhQAKV3ACsNzGZKBiwiFB + BKwAJCE9gvErDiHh6oVw8k2RbrWPZTOQRWGSQUOQs1co3tv4oba9eqq2Bll54+l5IsyM34wEuNXX4np+ + vUT6rFWHyw1FYXkn56cdWxERly7qV9z99PaQIIbeMhG46YhATwBm07p+gzbhvxsBuA+YAEyxv7OQ+wrB + G2+/oWT+O0StPp/wn3/9rWhqcPaIke2+AyEAL1P8z0Y9dcblaG5rwtrXXqPPFk8xepBUCFYN3S1CF+Ob + C4lYr+5s+EEKTARgJwhAEsFQZw/c+9A9FMdzEU+zWJH18mC9hvUAKkwNSepI7m5ly1DkBHo7xfASWRlp + NJ3I3AuQHgB5DwdPY/KaUuQtLZPDPGnlZxJQCSBLrP6SAFgQhPUAp66tRGTONXB2DdDF/aH9EoAqC84I + T0jHgfIDmgfAn+OdfTVELiWaB8AEULCc0QcBLDfJgk8QsuBEAMv3I2rGE3DyS7RBAFGaoTtaNCo5KT0i + XoEx+OGnrZoycGnFIcQlj1Ik6GIM4eIdbXUd7/On847HiSOGBNBLYVp94wlMvmgOXDzZC0g0JwBLEghU + Mv82Kvp+CwLosdza8/wV8LCAZRWgKfkXb+b6c/bf0YtVeotwkti3V2vTlTHyc/OWKiITUstN7vNG6ySg + og0JQPUE7OhHzp9wMRpbGtHW3YKXVqyCS0AkBjsFyCSem8QwtzBDN998xZcQRi4IIFgzejuXQNg5E1x9 + MPva2Th+ukIabm+TTnnXBGho11b+HouWZH33oakIqEsMMOlFhxlxWFUFQvEAeupR19GK5745grFkZLmL + S4gAyNh5xScSyCL3P5OQJTyAYkEALAk2dk0lLlpfgdBRl8HFRV35dUk/neHbK3DwCBNQCYAN0D88Edt3 + bdPNUGjDN5WnMGn1Qc0DKCICKFwh+wEKDAmgWJsNWKR4AuOJBMYv24fQorsoBIiXElw2CMBJIQBHC0EQ + 1gOITBiOkspi7fv9/sfvERAeL5J1Nj0An2gtMai+LocA4yZcJIzcdoVnC5585gUigChRGuxKRu8aYIJq + /G6KOK7oC+inPfisREKUEKCzv1X7TN3+vgqBjJJ/LJkkPYAwLFm1Quz3yzZdKbrR1tmES6+8VTA1J0+Y + ZYVYo1r1ZSYCaUAAXnIAxMicItTUnRRxGMfSi9ethndoPM538JdZe0vlYE1UNES32isQK32QRgLC+IkI + 2Pg5Q37LnbeiprZKc8N7FfcPVsbfIurOf/7lJ7z1znv4Yft2tHW1KTJiphFkfGI2NNbhI4r7X3/3XRRX + lPG3JFSJemwQgIw5G9HR28CPFu7/FRt4iEcpuf/FAtlk9Iys+QcEBCGQZzCaYn/W/M9fV42L15cjcPgM + OLmFmlZ+ZZXXr/x2CliPUbZgR2gE4O4fiY+/+FirXmQi2HO6ETNeNRHAhJXl5BHQ6r9CEkCBjenAYvVX + CoLGLT+IgiV7EJh3I5z9dPP5jAjABuzpd8ufMAX1zbWayMwrr20QLejutozfKAdA3oejVwQuu/Ia+g1r + bfRyNIrcwCefbYRPkFJAFJBgAdUDSBRVgV6BiX8XAvANTu4c5Bmc1GK0ev+Wcb9lz7919j9GbMslpueh + tKpM6fiTfdXsRnEb6ai8SWKLRQyAVOScB0oAvNXHW4fRyZkoP1IpmjO6yCXv6GnGO5s+RuzwbJw3zEuI + Q5okxEN0suI6d59W+CEEPuoJwE4p+/ULiccL8+aiqfmUmQuoX+1NBNCEzs5GPP38XDrZIvDXYT60qkTg + qbkvob2rTanwU4y/qQ5XXnczzncMxHkOIYhMzsHbH21ShFFsewBd5Hl09PJgz2a8ve8YipbuxRjF+Ecv + OmSDAOh28gDGEAEUrDuCGWsPwTehkAzaestPKAENgAD4sYtXLtERQAeOtXXgxvfIqCnMMBFA2cAIYJmc + DVhA8f+4+b/AZ8SlVtOi9NqAfRGAHYU2f7vvfiHr2atMg77nwQdFXsDdwPiNCUAW9Th7R+DhJx7VTYVq + MswDHCzdi4S0bFlAZEUAqieQKArCfg0B9CktHszbgMFJdWbxvkXsb+UVGJT7egzQc7BFAM4UBtjRyfK3 + Bx5HJ8f9PbJHX10h95UcRHhipnCvXESGN0aTabJFALyd5yi2+WJEKS/X8vuGJmHHnp2y26u3SfRrs/Hs + 3L8TF142h05angngK2SizZN6RmACCBDHIY4BsCfCyC6YgI++2EifoVFm+3taDOJ9cwLYt283PGl1/N/z + PfCnIX74nwu86PuNxZ79+7VpxJzq++qbr+l1vPHnIUH4k10kzhkahPj0fBw5dthsNJkqRiFBn6+HSIaO + NR0tuO/jEoxduB9jyMhzOM5feEgx/v0KmAAOCmJgghhLnkLh+iOYuXQbPENHkhFzfB+sQEcAbnIAqC0C + cGECoOtvvP0OM+WlVgph5n53mAy/jEAhABFA4aoyFCokINDPdODxK+l9vrAV7vFT4aKElOY1Ibr8kCEB + hMPVOwTvfPC++J55x+lU7SkKRaeSoUeYEYCLQc2JJJtYrSSYtSs3vPGqsgNgNHOxQeQB6hprMPniy4So + iGUOwDWAvQIWEI2HZ8DfzwMQhUBk0Mf0BNBXV5/XGRCAscafseqPE32RPmEJ+Or7LVI0UmyXtSpG0oJv + f9wCn/AkOWzhDAjAtK/PzTwyT7Bxk3RD2TB6euUMPF5lTzedxNrXX0XOuIl0QrD+vy+FBr4YSi69NXhm + gA/dx5t+wFBkjRmPeSuW4PBJZfCFmFHQpGz59UUAzdi27QdyQQPwf0wAg33x/waTF0Cu587dO5TVslNk + +z/Z9BnOH+ZHBBCKPw2Lwv+zC0FATDpKK0r6JwB6ne+razFt5R7k0uqeu4iMfOFBC+NXCIA9AoUEcpcW + Y+KGSlz4xOtC8MJRxPWWBBCmqQH3RQA8LThzdCFOnTqhy3N045Pi05i6ukSEAUWrKyQB6Eig0Aolwvj1 + 48Fzn+QioELR1ckrsfnU6L4JgAksJX00qg8fVr7rTny5+VsEhiUqUnR9E4BacSr6UbzjEBSRhm0/bxXn + rTUBmHQbOiksu+ehx8Vjfw0BnG3yT3n8Mc4BlPdFAIaTfHWiH+42k30DJwA+YcZPnU6sSDGYsvozAXDi + jL/I9zdtpMfG6AjABOsGIGMCYC9giGsYnntpgZzh19Mscwy9rUqoITPvHG5s/OJzPPL0s8TQsynMiKCV + 14/c+wDR0z/U0Z+MIRjjpkzHg08+jY+//Iwec1jr1FMNT+/69+UB8Ly87NwC/PefHPH//uqBc/7siMIL + L6Z49LSuO7ALx2qOIzN3Ev7nr57433N9iCx8cNs9j6C1o9EwB8C1512sStPbiIbuJjz3dSkZ/j4y7BIy + cLnSWxOASgLkHRBJ5FGcfc3bpRhz5d0U5vgLD0DL8isCIOYEoIivKlur+hCAScCPTrzNW7YqEuvyc1U0 + tuGqNymOX12mEAB7AaWCBIwIoGgFqwhJFDFWlyPr/g/hFDRaIQDrqdHaPEClKlCrDvTmEu5A3P/IY/Sb + yR2VDvrO7njwYVoEIjQC0Ap/+ig7FwRA59nIrLH0W1XJNmCDGQ8qQL/L+pdfFkrWrhaGL4+8G5DQbwhw + Fkavuy6pnAlgry0t/75ECs9M9MNU+GMk+OHgGYaFy5fLhBe5zeiV21pdigG9/u5bYj/27AlAhgEXOIdg + +pwryWjqpZfR06YRgIkEWpWMPJPBCeSMnUorrxeGOPgJ42exz+CoFOwrLVWy8e2mMtzeZp0QhCLMib69 + AE7UbduxFdMvvQLDR47BpVdcj1379+jGj5tIYDeFC9ywUjB1Jh59fh6O19UoYUyLMQEItGDniTrMWLcH + 2Rz3LzTF/RIHrElgwX4KEfZi9ppdmPfBVkSn52Komz8ZdyDs3YMkCajyX24DJAD+XejvZ+e+pJuxQO+c + DO+Zb3jYyCEUriYvgDwBvRfQNwGQN7C2Emk3rIGDXxoZabyuMcxgIKgFATh4hiIsLgW79+5RRsB3obiy + WOgXqkrUvK3oajCO3poAYoWXc8XV16Cts14oMVkTgKlDE3T7li3fICgqTSQC5eqvJMV1eQAPJQmoksBv + QQCmxyXt5RBgy5kq+Fp1A5rBXPZLnYiq3/bTd0KxlFJY3EjsPrBHEbhg91lpa1Um/rzxzptk1GEWBBAl + E4IWBCDGPpmV9kZJD8AjWrTsRqeMQnml4jYroYaabDTfS28WycJ7Hngc5w5VCMDBH8McAkT120dffitO + mC6zaq9mXRLOVJprvf2nXtcm6wPocnNHHU421NDJ06iUC7foCKBdmz7cSQTZ2inHdnOGv1ugWZMoNwmI + yDHfLeRNLf7hMHIX7xXJPbHyWyCLSUAhgsyX9tFxDyYu+RnLvtiLVW+8TQYQRitlgFgt7d1UAjB5ADwM + VMDdBAdFHlxsuXEizjtaXDe2cArqGk4rCsldQtvxq0oKA9buJwKoUkBeAHsEq8rErgC7/RoBKMY/kVDI + l9dUIGLaY3D0TabzIF6WffsYl4rrJcIYTGb3PvIwunqIyHukJNzSNStp1Y2Dh5+M5919dVoAfRIA3U4L + 2aKlS6TsmTp0tbfRRAK93JlZJ9Dbcxrl5fuQPGqMCFvMy+PjhRfgptiO51nMDuyPAORjE1kQxCQJ9uuL + gBKE8KeYe95P379KAFx+e/Hsa8U4pm7dyauuojy88t2P3hPz/vhHMxl/pIC58UvFHzPjt+jg422at997 + X8ahva26Ihrr8V1siG/SfYe5+EuFX/sAQQDnDfPG/U/OFSewXvrJtrRXg44EZDGISgC9vbLSj1fqbuhD + B1O7sEoAalWgqTBI3/nXYoYuZcx3cUMTrnj1EHLY2BcdFEU+AotNyFp0SNQBZMzbi5Ev7kbegl9w64at + +Ln6OO594mmR7LRzlducDm4hFgRgKprSewPqbaoMm/r7eAVE4/OvvhIrrtzC7ERtRxse2FSMgpUUAqyu + RiEZdeGacuHeTyACKFpZLEhAv/pPWsYEUIn8BbvhljpLiLk48SrsE2tzNqB+W5DDmMSRWThQdkik/vh/ + NSdqxHYgt6K7s4inOpCmvxyAj2xN9w+JxQ9btyhiLo1KHqhJI4FenT4jy7Sfrq1G0UWzxHuVTUFxUpHK + 31wwRB0hfjaJwL4L/RI/ZAJY89sTQPzACMA/VpwUi1etVRJDzRYFE+RGkfF89vWn8PCX9dzSC1AJIKoP + ArBu4eWtQJ70e82Nt6Orq1V4GqaV35oA2Ej3Fe9DYEQCBtv5CRJgxd/zhnojt2gG6hrr6cQZiLRXo27V + lwQAQTBtWqFPt6b4ox8m2qKEIx06AlArAlt124zNZlLUEk1oJXJZvvUIxiw6QARQrBn/6MWy0EcFhwaZ + 5AGkP78T6S/+jAtX/4D391Wi5OQJ5E64GMOcmQAC5RQgdwsCEO6+surrCMBBI4BwjQAY9q4huPLam4Qg + a7fwADoFvqk6iQtfPigIoIgIoEghgImryOBXlghPQE8AE4WacDVSb3sLwwIyZL8Hnw9cGOYVY4MATAKh + 7v7hWLF+rXgHUmimG0uWr4CnX4RY9d39os6IAPg58wrGC6FYSeyWBKAb5MoCrd0n0dJ2Etff9jcRJrn5 + Ku3B/0ACIA9gDecAnrPlWgyUBDyCydiD48VxoNJfogKQWC+QYqCfdipqub3mmvldHC8RCfxMMXJQeLyQ + oJbxW6QWCliLf6oNPhHWPfxuURjqEomopCyUVpQqPfTGiTq1kKah9RQmTJ0ujH6IIAB/nG/vK7ycrb/s + MFN+6SvWtxT6rK0/itMEk+KPXvqLPYY60b5bXH6AcFC4/b1Kp5rZfdUVX/EiOhUwCfx8rA4Xr96DrIWm + lV9U+ImZfyXIVcBFPyNf2IW0Z7cjb9FWLP1+P2q7OvDp5i3wDUsQbr+9mAIUZOr+02YAkPFTLC1gMIlJ + ywcooQDnAbwDovDJ558r8u6dgggaurvwwndk8KvJuNdUCteeMWlNmbiOtwplOKCiDIULD8A38xoM85Qj + 4XinQs6FiJavZRUGhAs4egXjtrvvFWXh3b1dwvXfsW8XkkZmw807Ah4U+3so8b+7b6xZt5+zja1Abn56 + 6oVntAau3l7T1p9KAHLlV2Y0EAF00PHpZ5+FO3cG+pgWxd+WAFT58EQDWfAkIQt+Gz1pz8AJIOksCcA6 + B8AsnTt+Ek7X1VBMJPfNLQmAUVF5CImpmcL9HDgBhBuIeERqLb1L161XymlbdSIdFgTQKxVdn37+JXL7 + fXCBvb+Gc+nvp+ctVTyXgRNAW2cdVq5diZHZozEiMxOLli1GE7c9m00iakJTyyk89PiTCIpMJSQKsYpj + J08qJNCqkFertpNhSQDHW1tw3/sHkbNgr9nKLwx/mRz4mUuraA6tpplkSAmPfo/kub/glrd/xrGmJrR3 + t+PuR55SjD5YHNXLAyUAOyMC4MIb52BMnHYJEeAphQT4/3ux73QTrnlrPxFAGSatrcREwuS15ToSKJWe + AJMBEUDm397GEI9E0cPBCk3cKcoj4QQEGURqo8JEUtCHzh2fcFx61dU4fuK4MHx+9fqmBsy++lqK4bnw + h1Z+eoz7QAhAEaThHY7ohOHYvX+nnDHR06yt/noCMLn/kgBYpm3dy+vgxR6Hj8UY8d+MABJsEUCPT2jy + bUwA0+lJ288mCWieEDRNN9GP+HbT9jStPQCu7Lv1b3ehi/fku01fmOr+dyladrX1x1Ew8UIRh6oEoFV4 + nQEBSK8gAoOdQ5FHru2pulNad5pRLqBHKRT69ofN5AJGiNj/Ans/QQB/HeqDMRNnoaG5UVPj6TvjL5N7 + Gz95D44uPvi/8zzxf+d7YaizP1auf1Xr/lO7Ate9/AqGOoUQ0UTgXLtQOnrj8Wde0NX+t5kUbHUNQ/ye + m7vbsGRzFcYs3C228/Ruf45i+LlkQNzok7OsHMlPbUfsY99h4rKt+KHquCDGg2WlSMkYoxT/hCqGH2Lg + ASghANf/u0tYaybI30LWEhDcIkXCbNnq1cIAe0QU3iNGa35afgKzX9uHKWuryPirMWWdOQlMXEWhwSoe + JFKC0LxbcP4wf6HYbO9KIYlbuASRvLNHpCgbZ29A5AQ4rifP4+a77kTNyaPS+Hnbj4juuRfnw9s/Ch7e + 3Pijwpbrr0rMxZqEZjxDcPeD96CD5cDFwNoWUQNi6QGYhQBdJ+m8P42Nn34I/5AEmWj8lQTQR6xvRBTa + aLBsetKGX0sAmnegTfmVcBPbGXESlluAZFTrXl0riybMCEBKWUsCOE2ucB3uuOc+0WhjmwAsSSDCgABM + yUBeHda98aaZ4VkTgFxVTzWewLhJ0/CXIW4aAZxn5y9+mK0/71Q6yPoiATWh2YInn3ocfznPlciEjTsE + fxrig1lXXY/O7hazQaQ33HQL/jokABc4xNDrRdNlX8y49HJaOVp03YIdmoJNt5JLaOltx+s7jmHikv0i + 6ccEYLbyC8MvF8bPSJ+3B/EPf42xL3yJN38uQTt7E3QCP/ncXPp9wuh7UhV+w8whRmqZ4nyxyltsB1oS + AOdgmACcWF2ZjDYueSR27NmlVOD1iDicfZlNpSdx9WslmLKGCaCKUEEoJyIow+TVdFxdgXFPf4mh3om4 + gIiYB6/YORMJuISKxh5+D04KCbAn4OARi5CYdDz94jwi7NPyN++VU4pfef11Ci9psfKOlKu/AQGY1xXo + pebixHmUOGIk9h7aqbj/Sgm7zps1JoBTYmbjD9u/RXhsmnw9ZYCoeS7gtyAAQ0+hwS8sNXuQb1hKOD3p + YSuRzwFt/0khUbMegkDT6i89AKXAwTL+J7cnLCYFO3dvFVt9PT2NZh4A76OqBMBjsN9+7236ccLEyWhp + /Nba/+ZCH0YY6hKBkWMnofr4YaUDTG/A6nZgi+gZYONatnY1LnDUhQEOgbQyB+KBR15Q3PKWPr2AHsUD + ePW1VzGEyON8WtXPHxqEP1/ggfu4EEWX7efE39r168QUo/OGhRGCaaXzxrNz5ykJwTYdAXTqxm114u09 + NZi8eA+y55uy/fqVP29FuZjym7uyEhnk+sc/vhmjn/scq77bheYu6fVs++UHJKSOohU0XCepFWEwU09H + ALrtQCPVJDUn4yAeJ+fxDXP0R9Gki1B97Ajkvx6xs8IDtjdX1eFvH5ThQjL8SeuICNZXEujy+gpMJUKI + m/oA/nSeG32HvhhsJycwDSMS4O+Mx5U7uISJcm4nOs8Kps3Gp998QSSraim0CS/n/Y8+RFRcGly9IiyM + XxKArPu3rDVRSYCTjbHCM1y4bJEQE+3u0RWW9Zq2g7WtwB4lDFCGtPAo9/3Fu5CQliXajkXykbcdz5oA + Egc2LzBE4LB/eGr4oIDI4W70pHsGWtNv1vGnlxPXPU6VNhYIMPX+m037oZgnv2gqTnPWlEOAngYdAei8 + AB5sSQRQWV1MMXOeqLkX8Z3h8I/IARIA6/vHiBPzSTKqbo0Ami0EO01VgvtKDyAgOoWMkT0AWpntA8mI + gxCTmIdD5RVK4U5fBCBxgj7vFdfcJMiM5x1eeOlslFWrQhkqAbSiqeUknnj2WUTGj0BwZDxuuv12HDt5 + xKJVuEMrX20nd/a93ScxdfE+ZL14kOL6/YqcVwlGk7ucQyt/rrLy566qQObSMsQ/+QNGPv4xFny+DfUd + DYLwTjUcxWVXXQk3b35/kWYel9lYbSUEsLchkabCdL3qkUnSkLsItGI7B+KyK69DTW2tRgFy8mMPKhtb + se7no7jhrWJcvL5EeAETXq5G0byfMcwnDf/3Vzv8dbAHziMv4Hzld+GpTI5ecQii32X8nOux+M03cOx0 + ja6suktsPb774Qf0240Qxu9mZvgSbJCWeSZ1kVHzChwezZg9W+QyhGx9T5soLhO7S7rFTC0I6lVGtcnz + Wia4Kw+XID0zX0y+1nYdzpAATANArRN+fcwU3BMYleY2KCpp9Ln0pJ///QlA1wgUIOe33XH3g8Kl7elu + tCIAOddO1bWvJfY+jQcfe0LsRXPuwMmrfwIw3go0kcAwiheDotPw7datSijQrGzFtVr02Lfg6KkjSMzI + JQLwFcZ/gT3PAAwWxzvveZTiv1azYiLbJNCCuqaT+H7rZvxAK21d8wmLPX81D9BMn7kZpZUlFI/vQ2tn + rdj3N4mCdIgTmZtX6jo6serHY5iwaD8Zfwky55cgi4t+lpSS8ZcJ48/hVX9VJcasrkLW8nIkPL0TaU98 + ghc3bUZtWy3n4dFBv8FLi+fDJyhCyGG76OS0hBaDsuqrxzMlADUB66AbJOooPIcQXHXj7Thy4piox1NJ + gL2BdjKsktoGvLP7KJ78vBS3vF2MWY+/i/jUfDLgLMQmjUH88EKk5FyIvAuvxpV3P465r72Lz/fsxpGm + WkElqs4fG39zaxOWrFxD3mcqfT5j49cTgLNBopmPnPNIycjC7gM7ZEemMmQWoolNznDQ1/9bVgWKmY10 + PHq8Epm5hWJbWyMA3U4A1wV4/KYEoA4bTfw8Ojn73EEXXXrdOXTl6jNV9um36y9Quv56FnNX6pu5zdGL + woOXNyiDMnoaTATQo+jY9dabEQAnBX/a+RP9cMNFA4daYmrb+AcWCrAOQO6EaSg7XClW8R4DvT5+j1t3 + bUcQnTQX2PHqz1Lf5JYzARA86CR5480PlRJXy10F01hxWfAjK/R6FX180zakgU5gr4mAupXH9SgEINuA + e1Bc24qHPyLjnr9P6PqNEmKeRABk/Nm0yo8ml5+NP4dW/Rwy/uwVlUh8didGPP4FFn/5Mxo6G5WS4Ua8 + 9+FbiIpNpJMxTAhpunhIOIkmoFDZDKQarkj6sQBIqE31JGMiCBPj1kSVoJ4EXAIxZfpM7Ny324wAJDro + /zvpvbahqvY0DlRVYdehA9i2fw++370L3+7Zhc2H9mNHdQWq60+jladIafmRDm3V371vD6654XZ4cz6K + zh03g5Jyoz4CKw1B+uyB4bF4f+OHcnqT4vr//+39B5hUZdI+Ds+7v/3v9b0blDQ555wzDDlPHnIGEQWz + izkBKi4qSM5hyJgDKmZBVBQUJOec8+Sc7q+qnnNOn+7pGdB1992gXnX1TM8w3X3OU3fluxrf+7Kmqdq0 + /o0TZ4+hY/cs2YLlHRQvwnMvniRe8n0CfLgbsNkQILkZxbf/MwoBVg67/b7fO/B/9MSkfwQA6B6AVVkw + WFEeJbTrjj3796gDbgIAy0476802/D0TgzwxcbI0pRhZXt/mAUDP/DedEIyS2f4x9z2CK0VFsiK83oai + i93H5etelddp5RJOEkHWP1xbBEqHnUKBxISe2Lptp5bQsgaAegMAKmyaeWy7/uyThdZrPPUNRlMQqWtt + DT49fAV3riPFZ/5+ive7kNXvsog8gCXH0Z0sf8+lJwkATqEnKX/PlafQfeVppM7bj94zNuK1Hw6ivK7c + aCr6fOMnaNe+E7x8I0ghVOKvMQBEmBp9+OswOHqGN0uQ2hwIuEjpTuUDXPjnbsFo26EHXn3jTZRWlGrX + sk6rD6hGqJp68owoZKysLUJ59XWU15DUFZKnUKolQms08FBJPv53J06fxLSZ85DUrifcfaJF+T184wzy + UHc7TUO2+STzxmMO3+bMm4vaWlb+Sm3EubLJrlJ7FHC6N/jhp+9LElApeqII95h4BicIEBjP/+oA0HaS + g/6fT1jqSG+tF+Dm+v1vDABK2ZNMW1CTrXafDR4+GsXFV2WNtRUANBRZW39ts42AAlmpwyeOoEP3DJnV + d9FLS76W7b9mUV2BjUWUX/b8xRogwAtAn3r+JZRWlRkHrt5wx6sxe+EyslrxaO0WJcLLQVtqewDbuNKh + p1CgU9c+ZGWOqP4CzbKz1a7RhnLqDCCo1KRc6wC0VfhKo9OvwaAA45aZWpwqq8R7B6/h8Q9PIH3pflL8 + w+hEcX7HJaT8iy3K32OZUv4ey5Xid1nJ239347bVW7H5+BnmF9b2Clbg488+RFtSfk+KaT28oyT5J5l/ + 70il/F56iS9CLL4Ik6qSgstmZFsWJZ0j0QYI9IqAVAW8ojTlt3gBkhNwD4VPQAxuu+MefL5po5oQ1T6/ + UuhKlXDjFuqGMhNY63mRWvEfmPpt247tmDD5JaR2zJSwRXWS6hWkeDVW3qifxNqY6OvD9TDI0z8KkyZP + Rll5ocFa1VQZuTHvY7mJALYKh08exeCRoxEczlN/FgBgkXkEec4WAMwKrcQvVEnTCcFGwFDvH952pAEA + vhFt25OVL/l7+QCtAcC6A5C/58km9TtJmDxlijT/sJKr7KgZAHTLX2S15baWKwN0Md/e8AF8whIszL4+ + UTYMv7rENuL8F/GONfb8qVVfMVJH5rLX7AVLybrUaCCg9u5xDPna2+/SzU+g3+NGlmi0dlWLQAUEGABE + wpDVZwQOHjmugUCZRsnFUimgom+dqTO19tbbkIHq7b/sxpZQDHy8vBofnyzCy9+cw5DXjpOVP45OJJ3J + xe+85LhIl6VKzMrfk2L+His45j+O7PwdmLpxD04XlRgxcVVtmTSixCekwsMrlJQ/Eu6kiG7aYk/bmX9W + erb4LFxuY3E0W33PcBNBqpKmAMDZ25JX0EU4BFn4vpI34BschYy8/nhh2gx88c1XOHPxNHkGvOaswgBJ + llo6R7yJ59ylk/j6h28xc8Fi9B96F0Ii2wuNHO9xtCKS9Y0zavjuMqjUdCipk4awh+IfHIupM6YTuBSq + 12+o/BnKX2HK71ShoPgaxj/5FMJj2iEoNMmi6E2JFQAkmSx7sikH0CjR11QeoCQgsl17AwACotr7k/Kf + 8vkVAcAe848OAP70AfJXLJNkSV29tQdQb2RKi7REYIlJiiVZVV5bjMmvTCfFD6ODFUZKHKE1ouiNKVGm + RiB7INAYAGSoxSOMDl0C5i9ZReFGpaGorIynzp1Cdv8hcKVDzG5kRFwnKXm1cA41AIDJRVl6ZQ7Fjz/8 + JIrGRa2yumqK1Uvx04VSnCyuRkENwVgDE2Or2FYX/r+8oQYXqqqx63o53jtSgGe+OY+Bb51Ct/wT6ECK + 3WHZWXTKP0vKforkpKH4XZedQDeSHhTz9ySr33P5GXRbfhqZKw7iyY/34vszF1DBGWrxKGpwvegyXpr6 + MkLCyBX2DFfKT+ImVl95ALasP06i7No11wCgjUdjxmTFpBRmAAB7AuwtSImQFZIUjxPHwqPPHpxRXozR + OB+jZSWXG3sF9Ddc6L4EhsWjXeee6D9sFO596CE8OWkSJrwwGU9Mmoh7Hn4Eg0bdjg49MhEU1U4j+oix + WHwfWyr5ONP+QEtJWdx+zZt08VHkofx+ONSJjE3F8tWrUFVTpil/4xbu5gHAUuWpqa3E9NlzER2fhmBS + 0oCQGwAA/1wa7dSsjVn5GwNAyk2UA1NOBUd38Bflp9PgEJ3S4xZSzG9+DeVX5J9JzQ41+BMQcA90XV2Z + lvgrtukDaIbnXsZfS4XB58EnJqANWS5HzzChpDKm0KwAoDEIqBDAAgB6l6BYJ/cI+ATG48Vps8j9LNRc + SpVxP3TyMBYTcOWvzseWH7/BhOdfkO6xFo5BBABch46QLbPOBALt0nphw8efkbWqlzx0MSn99yeuY9ZH + R/Hk64cx4YOTePmLc5j97QXM3nIB07ZcxKRN5/DgR6cx9O2TSF9zFJ2XH0dHUuQuKy6QnCc5h66k/CLL + TqMrgUBXAoVu+UrY3e9Bv9+V/l32qsN49MMj+PzoZRTV6GzCKrn20+4dGDH6dnj6hMKdrhsrGovtei+D + 7Vez+I5iyRUA8NeO7raKr4tOmxZmfM9MSrxtyTOmFyK7jUR8zxHSQyKegGmduHlij1lz3bURcA+/GCnZ + cYjiSe+VxYP7FHTA8lb/1sMvUfj23fUGniYSfU3G/L76+yHl58YlAp+OXXvhi01faF5blRUH480BQKVR + haitr8G6195AYnJnBFGsH0jK7Uf64duE8vvSz83CAOBjKL6Sxpb/hmXAb2JSu9/Cus8A8D/PTZnxO/rB + sl9H+e2z/qgwIFl+h0uHSe26Y8my5RRLFaj594YbAwB7AfWacAb9SsFV3PXXx+nwhQgfPzeAmAdQrJN/ + sTYAEGsDAKpD0MkjSgg+3UgBxtx1Pw4cPSiK0yBWuloRivKcAq6jvOoq3njjDSSldkXLNn5o4xKiGlE8 + lcsYEZOGmXMXkrtXDP2/C8WVWPf9Cdy5fCu6v7wFCX/bhugpexHz8mHETD+BhLlnkbLkAtovv4BOpPBd + Vp5Dt5UX0I0AoCsDwHJ6TgCAFH3pabL6JPmnRHrlH8OQtYcx6Ytj+PzkVVyrUkkxXfkvX76E2fMWIj65 + I1y5rZqrKZ46v39EI35/ZstV0hgA7Lr5dgCgtRt5SO7BiOmYga53PotOD85Hl/GL0WXMi7LDzkXmCyyb + hMwAYACBNgLuoZXozE07HiJm6i5rAND3BDYFALYuvw5GHPZ4+kVh9B3jcODQPslBcKmvrsHW9b8xAOiU + 72fOnsYLU15GTFxbUvo4kniSBAUAQTcPAL5/JwD4hacse+7F6b9j3Xeor6//H1UJSB5vO9arxFrBvZv4 + WdMAEC9i6wkwFVJQRAoeffI5XLx0QZtsu7EHYL1koRwXCy7hr08/QzcszFj0Yc44m8FAHxW2PyAUbVWr + lgNPhzetczrWvv46rhVd1WL2ElKpIslH1Avdd4VUM0bfeY9szWEQ4JZUF09yaT1jZLpsxG134sft2wng + Goxml4LKKmw/fQULNh/BuLX7kDFvHzrNPIIO806hw+Jz6LT0PHkApPAcw688S7H8OXTPPy8A0Cn/DP38 + NAlZ/WVHMGDtETz20Um8uusSDl8rpZCjViul1WiMwgV47/0PkJXTn6w+Kbe41ZGqY469JsnsmxXeWtpY + LUHRadDDmyBOVe5/KzfukwhCaHxbPDnlBWzacxB3LtqMHs99iN7Pvote982TTlEnz2CDZswCADGNhr7s + icHUqw3reARYL+2wVXrLc6z8MUIJ5kLi7KuHPJEiTmRQEggkFy5ajCJOVGuJx3qT2Cv5WfM9lGgM0CU4 + ceog5s4n4OueCW//KHgFRMM7MM4QHwIDn+B4SwIwRFUC+NHK8ocm2Q0Bmhr4aZwPIMDgkCM8dTzrvOi+ + oAD9R6jQk5S4ojkAsP2ZJal3YwCw9gi43VE1PXjTzRo+6m7sO7jfULCbBQB95XJB2XVMnjGTDkE0bnUO + 1uLOCAtLjY1HYG+1tyGeappN/i3HuHSQvfwjkNd/IJYsX4KDR3eivPqq0TAErU+grKoAq199FdFx7eHo + GiaehLOnanvlvXOxFO/NmDGDrPB5jX7KBAblVdh1thhv77yImV+ewmPvH8fYN49j+OvHMGDdMfRbdRR9 + WVYewaB1hzH6zcN4+KPjmLXlLD48dFmm6Aprq6WfHkZTbR0uXD6LN999A4OGj6A4M04Aij0bV0+l/Hrf + vHMTAOCoK7XtToRmAIAp01tQOOQXmYxxFJtv3bWdIKgSuy5cw6DZXyHjxS+RM2UDut8zQ0q4PODlxCGc + gIC+SMSy1deK/s2OZ/DLAEApvy4uvtpUI33mYHrf9z/0GHbu2Wkoeq2091aa2nwrbgoAzl08hvkL56JL + t97wCYgSj8IrgBt+LE0/zDvgzYNIQXFGye/XAIDGZUADACqCItr21MJ/CwAERaUF+DRKBDZWcH2HuU78 + af5ehK07s5sEaoMNARS/BWidVZq75qG5bp4B2tgloXGvrH74duu3WtOLcvPrjIYJE+VWg62ovXmlNcVY + /dabiErtjD87+ZMFCpGknpMOBCYQsFrt7RllDQA6CGjC+945pnd0DYE7HdLUtC6454H7sGLNUnz/w2Yc + PbEfJ84cxp4D27F4eT7ik7qRFxAhwynsMuu5CVfeEkxgkpXZB2vXrsG5c2dQX18H2/9q6+noVNfgUnk1 + ThZV4uDVcuy5WIrdF0uw73IpjhWV0s/o89bVSmFMV3dVJqPA5Po1fP3N13h28vPo1ossDoGiM3dPColH + uHL1NXCzlnBReEex+HoJz7wJSVf8MJPo9OghaO0ahFaugQhNao/7ySP7esc2lNeUGvmTD3adRf+ZW5Ez + 7WvkvvQJOo6aZIQXDD78vlztAIC9kMBC66WFB9q4r7tZ7HoNFjIZN5FYtRiU3kdYTFvcM/4RbP5uMyqq + iiUBrOZAKqTkaMUdaUUkY0v0Uo5rBWex5tUVyMkdAH9SeG96LR/hGIhtBgBipe7vxfV/EwAYSi/cgMla + FSClCbHT92+UCFN0ADgVGt0+wAoAOBkQ37b3n0nJv2huGlBXeru1fY3BlGmMvQkA9FlqNVUVK0kcncVH + p/MyYjpGcrqhaR1644133kYFkyrKVhslFtqrskbUV4ZIvb0U2/b/gEFjxpDiBqKVi78cajncmifQuG3V + DgAYQBAtG4XEkvNWIp4wo+fd6MD6+EciIioRyW07o237boiMS4W7T5gkxhzdIsUL4Ll3nnpz5pCAcwOu + pFiOwXAj5UlL64EHxj9GB+VV2VVwraiAlL8xINj/r15iyppaOmzXL2H3vp1449038dSzE9Arow8Cgzl5 + FSQJLHH1vVTXngIja8V31MSi0GHN7EG0xP6O2mq0lgS0LdyDEJvWFZNenoZdh/eior7UmKPgPgeuPsz+ + 7BAGzNmOfjO/R99pXyJlwMNwIkAU5fdUy0ZcjV2CZvLOGDvKbwEH3aVnq24Ws+J7yBLPONk8LclEjSCU + 19BHJ3XAg08+je93/KCRrlQoPkWhVavQXH8T23NDmdWCV0XeoqjrqmsK8cXGTyjkG42wCFI28kR8ydvl + eX8WBgDvZgDAU+8ADEmwAwBNE4M2KaH22oSTv0hM6/Vn1nkzAGh5gNRpzQNAionkI8ku86/uAXgFmDwA + o7c6xkp0AOC985LUIXcsPDYFL82YjuvFVzTSTBPZpg3nvZUXwIeNy4YUn18qOofpi+YiLCEFLZy9SBED + 1aYfu33rFoVvrYm1J6CWRzprs+ZuZD3dWRgMeKzYUx+DjZJeAlEoAQFuECIQYKXnbkE3TVwjpJOwlXOY + tBUzzVZwZBK6k2dw94OPYMbc+XjrvfX4YvNX2PrjD/hp9y7s2rubHn+SfXWffP4RVq9bhb9NnYLbx92B + rr16S1uqizfvKwgQa+woJbcwK6UXF99TNfA4Wim+rSsfZqP4tvsQtcQfKb6LXwTSemdj8uwZ2EOeUGWD + Iimt5XKttHOXikd3uqgYD7y2EwMWEgDMJgCY+iViM++SHIuh/F4a1bh3lDFxaHcK0QYcLOSwtgAQqym+ + Cglkyo4BgWJ9buZJ7dQLz0yegh17d8quSGgbgaS8V2+hV9ONi3XuqcyI7xugytN79v+ICZMmIim1EwJC + E+BPrrwfWXMBABHlAXgL1ZiFbswrSJPgOA0AdA+AQ2xL+c8MAE2BgF0WbysAkATgNN36NwIAv/DUwfSH + apv7gzoINCfWOQCmTIoVsdwcGwAQiZH1WHxz/EPice8Dj+DI0SNa40zjhReNcwJq+67iEShAdX0Bvtv1 + PQaPHk1WPIDi0gC0tmlHNdZ+awrfylOJ2Qvgsp4Rz3tES8LMEO5o4xyC/JsYBSJuESJtyAtobTQIRQi5 + B7cRqxbiCLSURiL6fdco1VrsFIaWBAitnIOkG47XUnkHxdDNi4N/aDz8QuLFnXfzCpUJOqYob+0SLDkK + R3ctSy/dd+rzcIOOk9arr7v8js207Nqz8obbr4UFTLzBy1TdyILlDhuJNevfwqkrJ+kOcWKUm52KZOFF + Dd0H2bykLV359NBFDMvfgf6Lt6PvnK3Ie/FzRHYdpUITMwBw+VGrBuiegKtRImwsKkcQY1fY0ntqm315 + qMmD4u/w6LboO2gE5i9bgsMnj6CmXmXnZRdFvc0Zs1rkUWJD8lkqnI4NZGzOnD2C2fPnoGOXnggixQ8K + V2Vuf/KQ/UkP/ALjJePvy4m+QD3Wj2/U968sf6ImyZaKWTNVt5sCAOvfqfWPaDu4SQAIiEyLoF+68HMB + wDYZaA0C8VYg4B4Qa6P4JgnguWwl3v7cUJOLjz77BBW1pUbnlYrFLK6YPRZefYCI0flqyUXMW7kMcR06 + 0+ENlOy03s2mFOHmAYCFrbxyn9na88x5pOY5RJOCRElTUCtd4Z1DZUT1VhkgIneZrL5MENLPbiWlb0Eg + 0NKFgEAkQpszoPflzI/qd/mxlWuYtBy31lqPW7lHGk1HjjaxvA4Abcyrukxde43d+8b7Dy1NPJaSH+9N + 9KTD23f47Xjr4w24WnpF62AsE0uvOjWLNQAoFeEwrqS6DC9/egQDl+xEv0U7kDt3K7Kf/xjh7YdKqbQR + AHhHGpZeDR1F2EhkkwBgPlfu8rNohMW2RWafAXj+5ZfxzbYtuEaepd5+XafthlBSbgcArCf4GhpKjCk/ + Hk9ftHQhemf1QXB4EgLJSgfxY1iCNPaw+JOXbAGA2EbZfr3ll11+s7tvm3v7OSBwA7kQGNU+wi4AcEwQ + k9LjFvqlTfYBINkqE2lPfE204I1JQFXmn8WjCSAQ1PZTpTMGAUbtCLqBk154HifPndDILyobxf5NUXHr + yF1DX+8+thcPPfscAqNTSDH9yXKGqNZVT4vS2AMAAwh0K0rKJ8Irxd1VO3AredRag0W5Q8mti8TocXfi + r48/TgdwqIDinxxD8Jc2BAROEbjVmQBAhH6fhKcLWzqHGtLChbPpIQJYrd3CROS1WJpUYvvbjc09+s0p + vuEBcAXAQ3kyDD7+ESkYftd9WP/5Jygouaa5y+XaerXGlRnO2wgQ8NKT84UYu3ofBizejb4LCQDmfI/0 + J99AUGKOHeW2iBN5Ary4oynltwIASfxp3Py+rGjx6NgzGxNf/Bs2fbcJlwrOC0+imn1QXI/q/NgYFZTa + ofIuNujp+SydvXAU8xbMRY/eudLCG0DGL5BcawaAgNBEcf/VYyJ5AgkUBsSL+IriNy716Qzakl9r5AEk + G73/9qtxzbb72uMK3BTbttctevxvCwBaGND2pV8KALrYAwDPwHgj7vHQREqBASbUlm4vAgCe02aWFuZo + o+e4dpqe21cSXUWlV1VuAObMbFnz/QIN6gZW1hVh847vMfzu+4UgsgW50K3dw7V2VrLinloewD3SWjxM + M+6m53WFNxTTLUKs+1+cAnDP+PtRXHke1SggpTmPLRS/P/LsC4hu20NGiP/YKhB/aqUA4VYBAR4tDhVh + ALiV3psCgLDGAMAW2W6yrnkgsP+71srPvRT8upwwTezYG4899zd8/cNWlFYWaeFYpUF7Zfe6i/uvVpIX + U2y94PvzGLT0AFn/3cibtwPZ079Fl3Fz4RPRUau7N1Z+Z+8Ig2j0RtafjYYsHqEQMjKpA4bfcQ9WvP4a + jpJrXlVfpHkoZVo+wl4yucLKkJgBAFotnxvQTp89jAVL5pPFz0MghWP+BDLcxSfKTxLAYGBSfF1E+emR + xdzu62UDAGpITnsuOMkEAEnNAEDSzwIA/4h2L5mtvxUANDQ0CABQjJDjG5ZSZR8Abk7kA3DnX6BFPDUQ + MCRA/zpOEoWeukfAyRtfDQiEpy1GvAFPf57BTsTYe+/Hdz98J6u9rbwBlDXLzd+gIThP5xWUX8Pa9e+g + W25/UnpSONcgzRIqb8BQcI8IQxgERNwtyt5SU3gLCESKcrv6huHzrz5XFrGuUOYb+DDV1Bbj4MmDWPra + Wox75Em07z0QXqGppOzhCgxaB+MWx2DpZWjhwrRjwRQGKBAQ19+k/E2JNQjoYh8MWrHC8+fmbL5LsMT3 + PhFJ6DtiDJatXoMTZ45LJlzYjmy9LoP1tsRqC5J4XA1qcOtIYREeeOswWf9D6LtgF7Lm/oCeE99DVK+x + cKX7zt1/TXkAzprYV361cJR7/AMjU5HefwhenDUTW3d8h6Kyy8aOBWkbb9C8lCabzPRtVHr9vthQ/HI6 + J9t+2IJnn5+Cbj2zSJlV4w4n9/xJUQNYRPEVACilp7hfE18WTgSap/pk4WeSCQA0EAhJsgIAc2ndR1vM + 6xvSGARuTP5hIgGNTMthHWddb9IDCI5J86E/evRGpKCqJyDFbqLCSysFmoVBQPcGjBJhQLzhDagFDJb2 + TlF+vxhLTiAwGj6BMRJLMUX4S9NfwdmLJ7UtLBU3AADLHIF08YkU49TVk3hl0XzEpHYiJQwQRRNvwAQA + LUmBWFqZrL4tALQQAFBJvVvJerfr0hvnL51DbS0dwFo16Vhfx1KkyCHpfbB1ulh0Ftv2/YTlr7+BBx57 + Bp1794UHWYxbyIP4cys/xT7EYODK5TYKEQgEWkpr7c0CgBbDNxES8N+6lay9I4Vc7brn4um/vYzNPzJL + UYHW4FTRROLVxHDToHbeqdVXqneDE4Ll9Pvv7ruAEcsPYODiA+izcDd6vbwRsf2eoEOeZpCNNhcG2FN+ + Htrisl98x164/6kJ+OirjbhYoPYrCMFKfYkVJ7+td2Ivuaf4GpXi8xDayTOHsebV1bhtzDhEx3eQeQ8u + 4/lxTB+srLooe7AKAVhY8cXii7XXmncatfaqbb8+YvETjXJfIxEAsOTbfDTl9w35ZTkADQCOhsR29GnS + A9ClV+7gPxAAvHYjAGicBEy2ThLaeADKC7A0CAkAaAlCTxsA8LTq+da8gAAFAt4EAlxO8Q+OQU7fQUIW + qpheq41NOXXNAAArPpcKZU8bOGtdhJ2HduFuitX5htzqFCRWXiy9h1L+lmwt3WzFFgAiBAD+TBb83vGP + y9RYLSl/XW2hKL4aeS4Sj6C2jslOuVpxXZSHM8o19NyFgjMSosxcshgjxtyH+HY9JRb+MwOCY6CAS0sB + g1Bx1Vu5q69b8iMpP0trDQTaGADAicAImb938lK5DAaKNqRUoUmdMfKe8Xh9w4c4c+U8E3CpzcmSwS/V + XGe91FpqzGHUa2uuBMysuBtUApDHn89VVuCZj45hYP5B9F+yF1kzvkV0/yfgTsrPrbcuVu23TSu/q96e + S5/Dl9zr7IEjMXtZPvYeP0ghXZlGjaZIV9X7tJ4pscTzqlxnUf4i49qzFJZcwNdbNuGZZ59Dx26Zoujs + jXrTOeXhMB/p209UvfvBqszHAOBnSKIov19I82O93qzcsvcvwabsl2iVA7A1sL8CALzWO2/4H2z1vREA + aP0A4+iPN9wsAEjNMjRR6pbmUqB1DsDSHGQvL2APAKwrBDEinDNgQPBmUKADFByWiNvvuAsbN25ERUWJ + HGB9K669UMDgGzBYh5T1Kqm6ig+/+gyZ/QeTEgWRYgVbAMCzsdvNFllX/hamEIC9iPy1a4Vau7a2wLQN + xlpqNTE/x4yxDVq2uaqyECfPn8CGjV9gwktT0T1vIF3fBPIIgsQz4A1FLSVPQOKmvAQW8WLcdQCI0Fqb + o8Sz4bHnkPhO6HfbXZi3YjV2HzmA8qoiY8OxuiYlIrXao5mPQY1uF1qJmbWJ/001s/WQIn51qgAj1hxC + n/wjFPtvR/ygCbK8k8t8zr6RpgnApoFAphC9whGe2A7jxj8ia9uvllzR2JFsw7+SJvI/jdd089YlkPJX + Vl/HwcP7sHjpMvQfMhLh0Wl0ttRWYG9Wek30kp2vNrhjFotyJ2hJvnib5yzibSi9rViDgHdoYw7An5v1 + t1kQ0kDx/zhb698kAFCswFThF34WAGhivxdAcZ3fCABuCAI2PQOSGxDuujCEUuw69u4HsGXrd6isLdEI + I0xru21IGo1DrdGPM/swK9/5qyfw/Csvwy8iEX/hOJyV3eMmAYAUzyc0Adt2bpcMOW+AaQoAmpN6kULt + oKr58+slV/Hdzh8xfeF8DLptLCISOtDrBeJPTj64xSVQwKCVq6oYSKcei9b34E9xYnq/wXh5wUIKOfag + sKJAGnTMDVb2lL2xFDUCAAME6JFJRSvqSnG9qgpzvj6DgcsOI2/hPiSMegnOfonSQemkx/Y+kXZr+y5C + MR4OV79wpHTuiklTX8T2/TtQxqGUwaJUZt0W3uzAmAYAYu1VLuha4Sl89sUHuP+v45Gc2h0+PE/gw9ae + w9UEQ+FtAYC/tgUBa2WPkzq/WPqgxmebOf5+KQD8At5/s1wIiu4QdVMAwCWCpI6Zf6Q/9GFzYYC9XgDv + UEsms5EHEJRgxPvWg0KWEODmAcACBB5+qmLgQQfKzTMU0bHt8NTEZ3GAkL1O2Hxsd+mVNUpaWbyCQtlB + UEkK+PHXn6NbXj/JDbBytXZTM+3scuvW1iys/AwEaV0zcOHSKbUG+hcCgO4hMH98Pb0vsWLiqpaJu1pe + XYyjp47izQ/ewx1/fUgNQVGIwItLdRBQEorR9zyEjd9tNkphChjLLe69adS6sbW3r/DWoijbaijM4SpL + OQHf/utlePC9Yxiw5BCSb5+JNv4pMvTjrI8cy3ahSIMDgMk3mISD24vdAyPRtW8e5ixfgKOn9xM4q9Fv + 65Xr9qS4kRfQYMT29L6qLuHAoR2Yv2gOcvoMEBouVnpPv3jDMJmVvynxCdIsepAKC+z9jkHqadB8Wypf + HkFaBaxZILDXBJRsk/RravS3rcb7n6I9CgB8mNwx64/m8l9zAKCXAx/8eQCQ8osBwEgCBjRB0ayVe+yJ + u/F1FDx8FasN01q17dAL02bMwckzp4ylmorjr1zb1FNqsR5WFORKanAdh8/tw90PPwxnTzXaKgDg2hQA + MEtwCEbcPg6VlVfFiv89AGCEBBJrm13YAs2aVeNawWVMmTaNrlEEWugA4BJiAAC/59z+I3Hw+FFxm2sk + Di6z0/DSFAAU3lhI6WtJqhkAyPMqqanE+iNXMGr1XrS7e74oP3cuOuqtyV764A9vHVItvVzu8wqOQb+R + I/DaB2/gfMFpgzVX9RqU2fR3NCelBi13celF7Ni1BQuXLsCYcfciuV03yR95+nJbbrwaRBMvVAlP490I + AG4kupVnRbcLAIHNAYDWDWinC7DxxF/TtF8WAEjRy38P2rP+dgFALwcGRqbF0B+7eDNVAD0J6K2XAO3s + AbQ/GhxvEZkatMwNePhbOruaave0DBfFSteXO4cDLNwvTnEvM8Z06ZmD5avW4tr1a9rEXKWx9kumvPQW + YlsW4gbmlC/AteLzeHHWDHiFxku5UObcNbEFgFsoHn9y4gRSiuuor73+swCgKQWzBgCtnEmK+wXFw+nZ + /dDGNQCtnLiFOET6B/SuQdU5SN87B6J35gDs2PmTtumo1OJCmysnWnLPWoqsVlo1Eo3PsU4DgHJy/89V + VmHad6fR5cEFcAxsJ++BCVZ48s8aADTarYBI9OjbD+vee5Xi+7OGpa+VtuIStTeywZy5tydFAop8baop + VNh/aBcWLFqEYSNuR1xiB/gEaPMm+hCOWHzrFeBWvfmBNxL+twkGcHCHpGeQpcTtEaSfae17K0nQeP81 + aZQX0AeB9FJgiqUMaBUO2AMA82Rgsg4AF4Oi28fYlv+a9QDYVUimMIBe+P2ba0m05ghgEGis/M2LvoHV + mBkw9XPfCAAaT4lxSMD0UdEyuONLwDJw8O348KNPUVauSDF1Zt56jYhE5xy08BEqQOCQoKz6CvJfW4OQ + 6LaqOcfIAVgDQAs67C/PmArUX0PDzwCA5iysGQDYeymvKMKs2fMQGM4Vi0CjfbilJpYyZbglFHAMQveu + 2dizd7faTaBn820SpLaKZQCPnVBA390owFlXLABQUVuGXcWVuHfJF3AP7ybdlvpcgRUAeCuG4aik9pgy + aypOXTlF/ky5VGRq7ZDBNvX+LJN4xSgvv4Cvv/kMjzzxFNq27wU/duf9KR4PsMTyN1bsm5V4Uz5Lt+rx + ds+zPWYsa0mw4wWYB4IsZcAbE3+mNJ7/D099P7Vztl33vzkAMFcD6m8eACyNQL8cACzjnR5+N/YA7I+J + agBgCPPdhUqf9h13348t235AJfO5M99fQ5WVK2x72FSSsIDc2wK89s5bCIltJ5l3swfQUgMAfnx64jOo + I8CobyLT/3MBoF4HAHovxaVXMWHSC0Ll1YobkJia3DXc2FGgmpKsAaANjySTV+DsGIy83KE4RSGRLBmp + /xUAgHfccTmTlL+qrhBFdRX48OBZpOTcofb0uYUaU4ZOkgMIVxTjPuHIHjQE32zbLKDLIRlz/dfUl9hl + g7aO83XFL5F8yMXLx/HmW+swevQYREQli9foHUhnkRN0pkz+rw0A+iJPPq9qxiXOUHjLWb4JAAj+OQCQ + 8nMBoJ4AYFxT7v8NASAwKi2IXvzkzfMCNjcLcLMAYNnG6iGML3E27n7TDDF2+eSkY0xx3AuBJClPdEJn + PDtlGo6fOanlByqsO8Ngvaa8ruE6qhuukYt7BWvefh2BUYnSqccJN0vSjQ68ayTate2OLV9/SYpdIq4x + rzevqbcGgpuKrU0AwP0KrGCTX5wi8bRMD3LXoakPwQAAzSPgUEDcb270IXEhcXamEOXJKaio0hOAZXYS + aCV2AKBQNtnW1xc08gC4f6GapIJA4kRpCcY+O1tYlyzcgCEaACgOAY6TH39uMs5cPWN9re1uhCoyKXyR + VhVRyn/q7BEsWLIAPTNyZI+AhHx+asOuaj6L/1kAIH0nTfzMiNsD4o0GNtuzarAOmX7WHADo7b68Ju9m + AMA+G3BTnICGnAyKTgv6RQDA0nfInb+nP5r/rw4A5qWV9kWNlTIQqNAgCl4+EeiRmYO316+XfXFqxbbW + G24DAtIwBA0Eaq9h+dpV0pHYyibrzuQfbG27dM/C3n17JIH19wFAgYAPH/xvtn6NgNBYSfS15ElCsfrW + pUhZVaYNE7VyCZWEYBuXYAEAZwIOJ3qvAcGp+OTzr7TuydJfDAC12ueqJs+I17cX1RRj7usb4BGSZk0O + 6hEsFQBOoIbHp2LZ2jUorSnTFoFbN+zYi+31r9na1xLIHDqyB9NmzECnbtkSw7txFchECuql0YJ5B8Td + HAAExFm6T/01hqqbBAB768R0ENAfm7L+luU5iU0kAxM0AEgxAMAWBG4EAH7hyfn9ht7x++Z0vEkA0JOB + fuFtsxVXoNnNv/lhIHOsYz8JqOKnxgAQ24jsQQcAWQfmG2usamJqaaYCVxJtbHSxzJNHG19zlYBDAi9f + evSNQGhkMsY/8hSOHD2q7dursGku0UIBIQK9LuEAr6Sas2A+AUmEJN+Y+EPIP9jicva9TQDGjhuPotIC + bcV5gQUI6gvsKrq1gunfk9DrlVVew+3j7setrf0VANBrtnBWg0M8efgXeu4W9yi09EtAG5IWLrxWnDwU + pwC0cQ5SbMU84MMhgXMYBg4eh+tFV7T5iGKb6cnimwKAGgKy6rrrqKoplOTfp9t2IqZdrgCho4kjkK1+ + a7dgpHbuic83b9R4H8tN3ZqNG3Usyl8gFr+KQGbHrm14etKzSEnrIau93H3jTPRyejVISyD7WZTZ+wbu + vMygmAyMpzQC6ZUBawBQE60Wg9UcANjzAOxR5VvpR5AqE5oTgt46H6DGD2ifFTjZnndQERCemt1U8u+m + PAD+x2HxnR0JAL6/2WlAb5syoDUANF0GtA8AWpyvM71oCT9Xm71t1tuAok1bXWwAQAsBmBjTnTwADwGB + KFnumZ4xGBs++ZwOdYWl9bWRgmirnckiF1dcxTPPPUeKFYTWpIBtXEIVDRgLKac3ucFvv/O+tB7/fADQ + lf+aNK98tvEL6XloKWvJg5Q4q8Eht9C26DzsIYyYtBT3zn0X9y94H8OeWYKYXrfhVs8o4SPgnQWOrqEC + AM5uDIAxePWtt7XW6aZLak0BQJ2h/NdkR9+BU+fRe+DdkpewZggmy+8eiE690rH1p22qFGunKcseAHAZ + r7LmOrZs24zxjz6GmKT2QpLiJuQedHb84hXjTxO5IU+Nc9LgnbS1+gEWliq9E5FzR7oHocAkRv2enUSf + LQCYdwzYA4OmPF+7+hFkEa9gjSsg2AwASTcDAN9HxHdybM79vyEAWJKBKY9ZT/xx66+l+08kVO8E1MqA + warM4aWtOPYyTQNacwSoyUCPAAu7q9kDUAlBTXxtASBa2wloDwBirRY6ygYab7WEUnHlhRIYhAsQMB+h + F1mUuMTOWJK/Qht9rbDbcGJ0DhIIXCm8gNvH3odWjmxpWdGUN+DI7jdZ4M5dc3Ds1FFFlFFfeAMAMIum + bBR2lJRfw7DRd+MWsv6s+DyrcAtZ9b+08UdwSiYemrce0z49gOmfHsbLnxzCix8fxJQNBzDxrZ+Q++gi + OIV0lik/5Z1QiMJkIhQqZPUdhssFlzRFLLJytxsBQEOhRfnriyScqaZQqLLmKq6VFOLhp2coYhUmB3UL + sQCAG12Dnj3x4+4fVAMSr4KvL28SAPRuPQbfHbt+wF8feQyRcWkE3OF0/6PpbMSoRyuSzxsxAplce5O7 + r3gBY4SHUDEmhdE5jcGDjz2OKa/8jR4fRt7goYhP60DnnTkHKHT0Z/c/mc4p7x1IsAYA+psuTDfejEfQ + HAg0KosbdPoJolP6FKHREBRqBgAbclDZvpXy2I2U/4YAoIcBAZFtw+lFT9vG+eZWYPNss8pu6iuOEywT + gbatwAGmyUATx3tTq5qtASC6iX2A0VaLHTkkcNR2CDrLGupwzRqGCCUVewTcNyAg4B9FIUE7THx+Gq5d + v2LqQDMvJ9G9gAJxY7kjr0dGH3LPfaXm3kbi7lARDgUeeWKCAIoZAPQkV1OeAMf9qgRZhs82fSXj0jIV + qFn/PxPgeEWk4dHFGzDzs+N4ZcNhkakfHsHf3j+IZ9/dh4lv78OTbx9C3tNr4RzcRfYWqhbhCDi7x0gX + 3Ovvvq/lAm4EAEVW2Xnu+quuvU6xfAnWvv2JZKiV8odqAMAswYFo27Eztm3fSteplkCjVGvqsR3dti7n + Xbh0DK9Mn46ktl2lds8uuRDIGLTe9ipB0Y3EaBAzN5RpFl/nE5QVYszlSNeE71t4fEds+PwTXC88jrLq + 8xQmncS+w99jzRv5uOv++5Gc1gve/rxaPMEOAJAExGkAEK9J8yHBzYieL9CnCH1MfQG2OQA/Cwno6cCI + tPAbuf835QGwDB19z++9Q5IXqYTEjQAg6eYBIDDBQh6q87nfBADoa5zsAoCPRv3NG298whGb3AEjx9yO + l6dPxj333wt3ryilqHRALSDAHYTR0jgkIQG5YWPveQgnTh2TrjJ7bEOSE0ChWLFN332NkJgUtGjjR+GA + 4upjt5v5/bz9IqT/QLYE1xdode4bAwB/X1VTgXvHP0lWP0CSegwC0vJLlnzMc0sw+4szmLrhFJ5/7xie + JmV/8q1DePSNg/jrq3tx75q9GLNyL+5YcwhdHlyOlj6p9JlD5bA7M30ZeQEDR9yF4vKCRgm3RgBghD9F + QvbJAMCP2w8dQ2q3geT6B5sAIFTowSPjUvDl5k8VvTbz7dWrDkQLnbbOrKvanLmS8OnGDcjrP0gINIUj + QmeP8jcngO0rvD0AsPUI9H9rtCAzS7SHIm/lMI7XlT/+9HMEAGel/0O1XpeLVFZfw96DuzBt5mx0S+8r + g1m8VUjtGNREP6+yeDShycrAjSoFdjdqaVOEPkZVIFlCAqskoA4AYamLho++7/c3o9s3BIC6Om1zUGhq + FwKAwuYAQI9VvE1DDzoAeAXeXA6gqcRKU6uczMrPY69M7MHsK3kDh2HxisXYf3Q7Kiov00cpwIG9G9Gx + c0/c2sZX0YLRQXV0V/sDmDWX12Sp/AAnC6OQ22c4tv2wXWsjtl8vryOppueXrFhB/z5MEm+tpEQYLMKg + 0CtjEC5cvqARVBQ1ajuWrkOx+pbwgF3h/YcOIyKhsxr0YQ+A5C9tApGaeSemf3yU3P2z+Otrx3DbsoMY + tngPhi7ajaGLd2PYkj0k+zFkyUEMyT+MocsPITL3CSErkUqFxnMYEJ6C77dvVxl2OwCgynBFVgAgVF+k + /AVlRRjzwAQhL+HPyZZfhLkD/cOwfE2+WuNdb+HSh8amqyuWzq5bVHQZ02dPR1R8mjD3KqOgzXr4W1eA + rPs9Ymx6QKJI8SKVNAEM5slDnjbkfoVWdH3dvINxx133Yd+h/YoKXMbLq4GGam2pZ4UQiNbR/6cvnEX+ + unXIHjCClC1JVtS7+ib8QwDAyBPYEId6W60Ls6rGFfpHtOvCOsu6+3cDgN4ZGNeu95/oj6//vwCAppRf + BwCdAisisSPue/hxfLH5SxSWXtYsjTa7zoe2gNzjZx6Ap6svWrb2IaXyE2sliytlt6ANS61HJNqm9can + n38uLbRN9aOzYpdUFJKH8agoPPfgs7DVbu2sMu/zFuSTJaxUdNn22o5tAIAP3CsLlsmMP5camb6sJbn/ + jmS97576HiZtOIc71xzHkKVHMHDRYZJDGEQycDHJksMYtOQIyVEMyCdZdRI5UzfDKaSr9Cu0cVd057zF + Z8or0yXmrm0iEWgGLKloCAiUYs1bG2Tjrg52OgC0cQ/G4888jfLqIuHWtyi/LQConv2jx/dj7N33wDco + WiXd/FVyr7GLb1F2y/RgjB324AhNopqYNow0Fp8ydToDVmR8EpYtX4iS0gJjGazqD6mRrlGY9ivyRqcG + 2cHUgCsF1/DOB+sx9M5xCI5rp72XeDqriVYgIFyF/ipv8PcDQIKdrUFWALA+Pq33n5rq/PtFAGApCab2 + 8w1LrmycBFTsprqb4mV6w3oisKkqwI0svz0AUBZfUXqzu9+uexamzJqFnQd3o6q2VLtZldqhKxUQUDzv + pbh4/iAefeA+tKaY/dY2PmhJIMDxahu3YG2JiPIGnI0tOmGITeiEN95eT5avvJmW1FIcOnKI4sTeMq/P + 5UG9TbeFYxhS2vbCkePHVQmswZqUol4j1mgwpBiXrl9C59xhuMVZNRtxIo9DgbC0/nj09cMYueY0Biw7 + iYFLj5PC8+Sdkv6LNSHl77/sKPrlH0OfFScwcOUJRPR9WrwAITXVAKBLRi4uXjsnnow5DDC3Q6vYv0h1 + /tF7O3L6NNK6D5QKgwEA7iHCupzdbwDOXjqtse5a3H5D8RuU9edGpE+//Bzde+VIWdbTT1l7D79Y03yH + 9Z5AvefDxSAUsQcAkZpYvtd3/pk5B/j+OnoEIyoxAZ98+a50hDY01NHn41JwjbZXsRbVNeXYsfNH5K9Y + SqHcBzh+4ig9V2m1pqWkohRfb/se45+aiOi07nDyVzsoGwNAotV5twWAxmCgJQLtNAnZB4DkSr/wlH43 + E/v/XA9AACAyqUsreoFNiqTQVP4LsVAe2SYB1dCDLQA0Vnx7JRR9vbP+c479WeHZ4ruQm9c1sy+5+atx + 7sIFY9deVV0lzlw6iy+3fosV736AdR9vxunrV8Wd42QUDwQVXLuCv/71cbKo3qRUPmjjwjmBEGlblcEV + fXLNWy2t5MUaYTGdsO6t9ajiARV77rJIGVa99oYkG1XDTpjWox8hybuJz78k769W46sz/n2DhTGovl4N + tXy0eSPc6Lqpjr4wWXV2i3Mgeo6ZgrvfOI8+y8+gb/5JUvAT6LfsOPpq0mfpMUP6kvL3XU7PL6ffWX0G + XSd8gBbeSYpOXHYWRsoo8fuffawGpBqKbOrwRSblL5a238qaEjz9wlyhM2/tqmr8LKz84fEp+HbbFon7 + DetvbMjVpZj+RgEW568il7+TLFfhsiQ3aLnb3Qaku+5K2WV0mHf5NQkANyYaUQDAJcVQzF44Q1tmwjsA + +d5UCjNSNX3PS0Mee3oiktp2E2Ja/+A4tOvUHQ889BA++HgDrhVcNc6dOns1ZIT2YsKLLyE+rQeFBTFy + ZhkILADQtBdgDwA8g34WAGyKSOzU6may/z8bAHQQ8I9IHeUbmlxjDQAa/5meBDT3NwclaISg5h0B8U3W + US1lP+u1znwxeYFjWFwaho25m1zQd8hyXZEL31BfixOnz2Dd2+9j3CMTkdC9H9xC09DCMxm3+qfj0Xkf + yi49EMLrG3qLi0vwyNMThFSjjatasGEZXAmX+NBZW5utFoBE0Wt3xGvvvK047xuseeUUHXYxiiquYvTd + 95N3ESB7AVrpAODMiyfT8N32nUpBzOFEg8kLEEUrwTMvvyJWv43Wz89JxdYELKOmfoih6y4gb8V59F1x + mh5PIm/5SeQSECg5jhwCglySPPo+j5Q/jzyAvFWnkL1wP5zj+8umIifPGFl7xiB1z/jHUF2rc+ZZU6rr + RCA1QvdVhm+27kJgVDf5XGrWIESJVxBemTebFMcU9xtxfqlBtMmh2fMvvQJfOieuXlGSb+EOTf3RorzW + 24HMJV1n32gRMwAww5CLXRCItE84SteyU88snD5/TMK7Gn2nAb3PiroSvLH+XbTrnC6t5B6+lrXjXApk + gPILiUF6bh5mz5uHA4cOoaa21rTfsQZ7Du7DpCkvI7FDL3qvcQQEHBKYvYC4GwOAMS1oEcUlqG0NCjEn + BVNqfMNSR/0c5f9FABAe19HJLzR5i+3ecl/tDUkTkBmxTJl+c8tvU26+m23ShxMsdFA4QfTXxx7B9z9+ + h4qqcrnQhaTEH2/8Cg8+/jQS2veGk08SWpLSt/Zpi9Z+JGTt/uSaiKA+z2HLmWI1DswAUK9A4Myli2jX + I1tcWEex/hFK9M25HpGW7bleChSiuFT08WdCja2SZCo3oPYYKiDYuf8nxFDY0KJNsBEGcP/+rRQK3HHP + 4yitLtWYaxt34oGUkKnPMweMEi+Cld9RstQh8I/vhvtf3Yd+ay6g78pzJGfJvScQWH6KFP9kI8njRwYH + AoBczgOsOo2AXg/T36LP584lsBjZYxiX3A1HTx7XynOWuXr5XBo9GI/mXi0pxIhxT+AWF8ukYRvJ+gdg + wPARuFRwSawoZ/wbWBp0q6+U/yqFNQ889qQk63hrsprPsPD+2Ypy5XXL3zj/4yLNXTGi+EwzxnIzHoCz + j9oT+diE51BdV4aaOqX81RoAHCdQ6DNkNLxIWb0DUuj8psAjINUQz0D+ngDMh1eNxSAuqTPG3ftXvPfB + h7hy9YoBBDUUTuw9ehDPTXsFyZ0yVKLQN6lJAGi+USjR7hYuU+y/JTSuk9M/FAAMLyAsZQwpfM3NAIC5 + 1Nd0vG/qotJAQMgi6AbGJ3fGI08+gW0/fk8oWyYu12Wy/KvfeBdZ/e+AC92MW9yZvTcWbbxT0ManHRz9 + 2qGNfxpa+aXiVvdYtOj5OP62+bTQRyqXQT2UV1dj0Oi7xbrq236cZNtPuAUETACgGomikNYxGz/u+FHj + FSixWoihpBxzFi6RXgDZ7KMBAHsCPoHJ+GrLVmEqalRZIEABxdx7yY0MI6DRW4wZBDjeTki/DY9uOIcB + ay+h/+oL5NafRd9VZwwQsAICUfxTyCHJpvg/mwFg7XmEDJiCFq5RUgqUbUe89Yiu36vkUanmJ2sAEILQ + eib6LMObH35JBz9FRqGZkFSFJqHkGaVgyw/f0jUwuf4a1bYCgApcvHwWd94z3sQJoJaCumj5FvvCChtt + AwCW/g9mCGbvTFZ7+0QYi0SaoxtnKjIXPlt+8Vi+9g1J+NXUlRjbjBgATl86iUcnvYjwuF5k8dtqit9W + PjsLA4BnIDcEJZORShZ6cs4beVBY2r13LmbOXoQDB4+irk6dt1r6/8DRI3h55lx0S+8vVlvKhqITuuVv + KheQ2GiAyA4AsPUf83OV/2cDgJ4MDIvr4ESu/zeN2oBD7QBAUILd9kml8Pqe9hjTgE+cIHQYxZOPT3gS + e/dtlyYStt5Xr1/DinWvoXvuCDgFdcZfPDrjFrdUxclHFqU1eQBtfNuijV8aHP07Chj8xTUWQSP+hlV7 + 2DrVa/lbJeXVVeg/fKzUx1kJxPX3CDdtwLWs3HLWdgHKgSOQyMgbjMMnDmvsQsWNNuMwBVdWnyHkBaiZ + fd4FyCzCvCZs3P2Po7LK3mozBQTLX3vNUp/WLC13ACZnj8XTX1zGkNcuYRB5AQNWnzNAIG/laVF2W8le + qSRr9Wlkv3oBIQNf1AAgUlt6GilDQ/c+8rQkORuM/Ib2eeoVQ/CZq5fRq+8dEjIY1p+7Ht1D8NLMmaiq + 5xjaQiFu2aFXiXMXz2DkmHu0BGukSq56hWvrwZsRWRuuK3lUE41fCgCa2y+gLxnRhY2LNynxh599JQk/ + HkWuq9c/a5l8jvNXzuNFUtjo5O50LhNF0d39kw0QYOHv2aV3pTPLK+Qk3+PMlaRoxCd1x1NPT8b+AweN + LAHT0Zy+cB75a9chd/BtCIhoK5UBD4NXwNYDYMVP1sQ+EAg5T2jKNyGa9b/Z5N8v9gAs7cHJI0npq24E + AB5BjSf+LCCgAMBNm+vnrj3v0AQMu+MOfPX9lxSXFsoBqq+vxObvv0fOkLvhFtwdLmG9ENahP7r1vxMD + 73gAXTIpriVXsLVPilJ+v/YkHdDaMwFBSelYt3Ebyhpq1Py/KL+6JbsPHkRi+56qRdZmx56jDgLa4k3D + ExBvIEp27g0efSfOXjpjwzGorzQvx/qPPpDhoxZOITKg01LbJOQXloxvtm03UVpbgKCiphi3kzvJJT8z + AHAvQEhqDp744ARGv3cNg9ddwECy6P3WnEMfOwDA1j+Xn1ulyZozyCbxTX9Y+ALMn4k9jHbdsnHxygVj + 953ZA6gmhZi7/HX6NzEqH6ELAUdW38E4f/WiJM/MNGNK+Stw4cpZjBhzB13LINlMrAAgXG0r/gcBgKO2 + 2oynEJ28QuHoHa4pf6T2+5xviMeMeUtRXlcpnovaEGTag0D3r7TyOt3D9UjPGySDR26+iWTlk0VY+d38 + ksSSe4XEoW33DAwYdSeG3HEXOqTn0Dmn++4cSB5sN8yYM5+uw2U5dbpcKbiMt9avR78ht8E3LFH0oPHw + EDfVMf1eSqMhItNOziqfsNSRv8T6/yIA0L2AyMQuLQkEPlcVAY0SzBwCmGmPtDfeaOBHc/m5I8uPLsLA + kbfj7Q/fQUHpBa10VIlrhZcwde4ihLXtC+egdGQOfhDLXnsPe44cwfWSIsm87j96FNEp3SnmT4WjbxqB + QXu0Ibet9+CR+GLL95L9r5e6rkrUlJaV4s1330OPjH6SDDIrtyi/2QtwtwYHBQARsnW3tWcIxtw3Hle1 + ybo6yZoXS4KQE4LFFdcw8vZ78Ree4pMln2rf3i3kzt9xz2Moryqz2lnA3sQR8ioiE9qrbkJOTLqFGnP1 + TO897MW3ce8nxRj86nkKBc6jL3kAeSvPIIeUXaz9CiX8fS4pfrYGANnrzqL77B/gGJ0jG46EMdjTsjnY + IzAGX373jQJcEwEnA8KhEyeR1KmPWlOmbw4mr8k3KJ6s6CdcLBPLWW9095WL8l8i5R95xxj6DH5SWbGA + jqqsME+gozwfLtdc5WEs24gdhRY8Uu00sFF6R3k+UrV3e+mbkNWux8COg9HxjmnwadcfrTzV+jNuEnP0 + jjTaxZ28ePNyEu5/+Els3fGTVtqrU6BsAEGFzDAcO3sYk6ZMQUhkmoARe6muPokUTiRIB+kzz07GJQpL + K2uqUU3n8eL1q/joy43omT1I6Nqc6TP1INf/jbc/QHFZmRaF1ktfwZWCK1j37lvod9soBMUkyXgz64et + stubJOTOXHL9P49I7Nryl1j/X+wB1NXXaxWBlDwCgFJjKYiQgmoVAJs3bI5t3ANVfZTjsYDwBAwZPQbr + P/4AhSWXJTaGxGXlFCtvQd+Rd8I9lC58SA/0H/EALly6BNv/uL4endSNbnI7tPRKRXhKL7w4fz7OXbuk + 1j+L8pP619diy9YfMGbs/fALjpXBIOkFZyXwjNS+jpDlGlwjb60dRAUKZhBQB66NF/3cKwSPT3oeheXX + NeUvNMpmrAgbv/lGGqNudeaV3mpVOIcEvoTsm775Tps3KBEA4K/XvfkmeSQhRmONGuIJFVe7tWsQQjsO + wj1vHcWQNy+hz9qzyKUwIJsAIHPFaSvJoueyVylh9z+LACDmzvmkEInG9uA2nhYvgD/v89Nn0vuo1ixg + iYQDVRQWPDN5tngvsnFYuxatXALx4CNPUBhVRrFzuXgKlnJfBarIk3nosYfo97wo3AjRwivL6zlp24vb + aMCgPK4wDezCrPYbirLbAQDjb3lpf4v+TWCHIch75SsMWHEYuTM2I2H4c3AM74yW2kZlBlFHBgAWXgRL + QBYalYr7HngC35CxqKiqFMVUk4vaHkT6urK2WDy69l0yZKDK2ZPjfvJa6TWnz54v57Beyy9rmSZs/HoL + /AKT4OqRCCe3aCEjHTrqbskB1dTVaK9TJ/9fLbuGTzd9KqvvQuNS4OofZQMEjYVCgVK/8LZ50vVXX/8/ + /xQPwNwdmJDW60+k/K9bAYAxCWg7CmwJA7ikFxLTFrffcw82fEGKX3ZBaw2tpANXhR937sJDTzyLgCiy + 5Iy2IW3hSig4eNQYnDp9kOLnq6isvoqikgvYufsnjBl3D1kCQk7/NAy87V58/9N2uah67MVu/5GTxzHp + by8iLLad6vrzVFlw/neyMUckFk6hneCfNhiesdloRS6v7gEYjx6RmisbIRaqhVsQPEPj8f6nn4rCW7bk + KG+gvKoY941/Are0CZSV4SxtmMmHAOG2sQ+irMqccS/DuPsekp4BfbCGld9JAEADAbLCyYMfxaDVB5BL + MX3OuvPIJNc+fZWS3mTtRUjp0+n5DAKJjFfPouPUb+EcSx6PW5RSYk+1N0AHP1571iNvKK4XFRiTkFy+ + +27XboQl9pSfO+pJUno/8akdsf/wAYmhVdnPnPVn7sKreP7F5xGT3F4BGlt37bopANUBQF3XNgYAhGl7 + Gq0BwBYE5Ht5/wqMW9PfC+w0DNkvfo4+Sw8jZ8kh5C09gP6Ld6PXpPcRkjEerQLS6J6y90OhDN33NlwK + 9YxW14NeNySyHcbe8zA++XwTikuLNONRTZ+vRvMiq7Hv4D6MHnuvlAdbu0VKA1Rihy749JvNqKirszJM + P+3eh+CI9vR5SaE9k8l7SKTfj0ZwdEdMeO4lnDp7RgxTHbcbN1RLx2FZZRE2bvkCDzz6EOLbdYRnYLQi + x7HLJ5D4elzbXjfd9ferAkBtbZ3mBbRrT8p/2bwWrBHpYZCq/7N7ExSVgtvuugtffP05iiuvSrwsq7ro + 4Bw4eggPP/MCQuO7kTufACeKs1wClbgFJsnfaN8tnYBgBIaMGo7e2Vl00xJlpJPLgNPnL8a1ogLjBjAS + Hzt5GlNnLUBKp1504xU9NXcROnsTgnvHk8SSRYiDU2AH+HQYgaSx05E+4Q10GTWFYsZErS/AlBuQTcHh + sjmIx1MzBg7HijfexJXrF+3Si7Nbv3PXTwiLSpNefsum3zDhj/9881dan3k5zl44haS0HtKbro/VCgBo + bcosTq4KFILb90XSkCeROuYlpN43Bx0eW4uuz25Azynker7yDXrM3IKeM7ag67SvkPb0W/DufIdsCbKN + s8U1ZgUja+YdlIpN336nVShKUFFTirsfeVYLGSKNFelOHkGYs2i+NMzU1av12g31lsy/TjRSXV+AfUd2 + 4bmpLyOybRdSPm3uQtx19bqs4DoANLXhWAcAMwio78MNEAnoNBwZL29G9tIjyFp8CFmLDiJ70X7kkOQt + OoDsuTuRNn4VPNoOQQvPJPIIYgg0FBBwUxTTmDnT9zwj4ReaiEHDbsf69z/Di9pKAABQV0lEQVREcfF1 + zYTUCwiw615YWoilK/KRwJ/Jlbc7B8AvIgF3PvgYXl+/Ad/+uB2fbPwKo+8eL7V/ZwpNnckzdfFmSSGh + M03nu3vmYHy08WvyLqq0jddqb4N4wLUlBDY7MX3uDHRn2rOQRuVC1rn2rIOsi/90ANBl+Jj7f09xyCv2 + AID3ATLXOpMw+IclYNiYMfj4q49RXH5V3MVabVEnL8p876NPkNq1L9r4pcKJkNo5oB2cA1NF+Z0DkuAS + QDGXP11Mn2S6WUl00+Po5sUgKqUbHpnwHLbv2611+nEjRgMOHj6GyS9NR2JaV0L5EC0ODFPCAOBDyu+b + BOfg9nCnQxE14kV0JEXp/uRaJPZ5gD5HB5mcs1h+dVAZ8Z19QpEzZBje/uQDXCu5YljMxj3+qo2Wy0zP + THpR7R3UE2juEULpNWz0OBSVqt2GX2z8QliKHLX6ul0AkJCAWX780MbJl8QPzq4BMojkylUUzlBTyOQW + 3gFuoR3JcyIL7KuAzFEHFa3lmcWiYFHinUyc/LIcRs4FfL75GwREthel0HMFrem1uvfOxvlL52XKT9p9 + WflNAGAZH1Y7DHgUesfBHXho0gSEJrQj8AsSS8+ehxFW/AIAUDF/GHxS+iDrxS9I+U+g15Lj6LX4KHqT + pC8+goxFh5GxkGTBQWQtOIDuL36DiOHT0Tq6L1pSOMQr4Z00AHAhY+BKxsDVm8PDSPgTQA8dMQYfkXdX + WqHF7g3Q5gFqsYfO3L3k3QVGpNL7j6XPlAAXPy7LtaPzk0qebiLcfOnRpx2Fu+TFitCZZqHnnegsR6Vm + keFahbN0PXW2pHrxhiuMpTZnzh/H4lXL0b57pvQPaN7AK8NG3/v7v1d//y4AqK2t1VeJBZLi7zeWhGiK + L8sSSPlDo1PJYixCAcU5QsXdoO2ha2C6pyLkv/E2QpLy4OzfFS5B3UjpO5HCEwDQYXb2ZyEAIOFHR78k + OdCRqT3oQD2PH/bslsSLNF7U1mLr9l14+ImJiEpoTwctUNpUHY0FmSqp1Josf+vQLnDvdDsibp+BlGfW + o+uUT5Aybia843uJwrm4KaUTKymJJFX7Tu7cC/lrVuN68WVN8S1LK1TvfIEmZi+ghABpP6KTOklzDycC + 22gxKe85fOud98TdnDz1JbR2CSIltzDr2AMAnltoQ5/N0SWAxB9OIup7Jyd/OJM4OfvT94FKeOqRlM5R + JwYxs/aYFIwTfF1698X169covCrCgOF3ydyAXi5UZTw/LF+9UvIqdXWa4mvKbx6ZNmjVjeGmYrJ017F1 + 93d44JnHEUhxrqIP0zovtXzLzQKAZPN55DuqB7pPfB+5+aeQvuwEei8lAFhyzCIEBL0WkSw4ItJz/mH0 + mHcAHZ7/EqFDpqJNXH/JG/GQlXgBdDZcSbgBjVuU3Tx5/2QSbr+TYneK6aur9Y4/FWCWVVVR7P4Vbr9r + PMJje8Ddr72Im28aATIpvi8rfzsBAQECX1b+tupnAe0R0a4/skY8gScmz8F3P25DReV1tXrdqoW6XEKR + /HWvK+KcwIT9ZHQDlfWv/b8DAHNZkKz/WFL+agsAKGJGHulM69Qbp86dVm5Ug55lVQs5rpdcwrgnnod7 + aC5dkExS+h6k6J1J0uBE3kAbstJtvOLhSBbbN6IteuYNwtQ5c7H38CHUNKiYq6yiEpvJdR334CPwj+K+ + gCBJahnlIFL+NnzA6RC39CPr2P4ORN65EEmTPkW7aVvQ4YWPENlnPKE3eRekXK4MAO5K4RSnXQihehzu + e/Jp7D95TE2JGZ/BDACFdgFAUWgXY9KUaWjJm3tcLQDACtl3wHCcOXcWuQOHComnk0GpHWrkAHQQUB5A + sIwy81IQBgAlgU1KGxMAMDGoo5s1AOhKxsNV7v6x+HLzFrz21rsy26FyJXq/QADSc7Nw+RqFO3XM8FNm + cfsbGnMm1NtZKsIeQXndNWzZ9R3GPvCQrNpuLXwCKvt/IwCwgAB9Td5hx4eWIW/NOWSsPIsMHQSWHRcg + ECEQ6L1IAwGSnuQN9Jh/ED0XHEIP8gg6TvkWkaPmwT1xKHmGaWT5yYp7cfdpNNwJEFg8vJl1OBKhkW1x + //jH8cP2HajWWn/rNCjggaBN32ym2P0JJHVIp9idLDy5+44ELs7epPzeOgAo5Xfzbw9PMkJxXYcj67YJ + GP3AZLw0Yw4OH95t4kqwzFBwaMA/d/eLq/YOShz7S8t+vzoA6GXB8MSuLbyCE9fz+K+XvnZJqJhi4BMY + iynTZpO1Zx5+knrFxV+nzZYfOnUU9z01Fb7RuWjt2xWtvMntpIvkRW5sfMcMDCU3eeqsOfhqyze4WnhZ + G88ECoqK8eb6jzD4trullspxuTo4kdYZa3JhW/ikwDV1MIJvn434575E0tStaPvyd0h6cDm5kHkq4+9u + GQt2lu+DhdW2R79BeO+LDSirKVI76A3Ft1lZ1WBm9CmwEj74B44eRlzbHlLTb+Ou8glsxZiJ6KHHJyIi + vr3GVmTNreeoiQ4ADFJKoQNNQp6Da5AGDMxMpH/tbwCA8hwaewBmJeP9BiPv/Ct6ZA8ihbCsFGdL7eEX + jHc+fFtKqrV17PqXGspvXsNtuR7FpglHyzpxtcmnFCVVBXj/84+QNWwkhWMRuNVFhUitTCAgZTwBcD1R + q6w/931EDnoaA9aeQubaC8hYrUAgfcVppC8/KUAgooPAYgYCkoXKG+g9n2TBYfqevz6ETs9/jfDB0+AS + Q2eBk8F0brjrk9vQ3TQw4BFxJzoPETHt8OAjT0sVp0Qr6+n/VddWSi5r1euv476HnkaX9MEIi+sF79BO + 8CLxi+6B0KRsxHQYhLTMO9BnDFn/F+fgvY/fx6kz+1Fdc02rwJi9gEps+prObLuuzJC0Pjy2U4tfWvb7 + h3gANTW1GmlIYhrF+xds13p78CRVRAIWrVxNB6eWDkKNeAFqD30JHadSXCaX+p1Pv8TElxdi8isLseK1 + t7B56zc4ee4YyqsKxQVSs9p1uFZ4BW++/S76Dh4tiUHZdy9Z+ShV4hKhw0xu3S1k1V3aj0T4OLL4U75C + 4uw9SJi1B4nsAg6YAGeK1RyZOptcam5WYYXnJRZslXyD4zDxpZdx5upZQ9nNB968O4AZZHQAsICAWYqk + oeaFabM0i6dajyUjzvyE3KTiqSt+Y3JNidvddW8gWLwADhdaCQNRiPoMDCwu6vnWLtyB6C+cBxYACLEG + FS0HYGtlXWSKLYa8Li3ZRj9vSSHF0NGjUFTO3kyVdM1ZK3+pXXJPg+/Pzs/qNLlYfB5LX12L5G6Zsl7t + Fm37UittMzOvZ2/jqUaYVRmP3iPdt8wpH6Df29eQsfYSMladJzmH3ivPEACcQu98BoGTBghkEACwpBMI + pBMI6NKbwYDDAwKBnnP2IO3pDQjMeRJtwnuSxxgnHZOungwCMQIGwhPhqaoh/sEpGDx8HN7f8AkBQalV + aKByUdXkLV3G9n178d6Xn2PFO+9i4bq3MWf1m5i/+h28+v4nFBLtwFX6/PX69uKGEgMAFBtVBT7f+Bk6 + dunB27Av+AYlprGusc79S3gAZpkxZ9HvvAPjJ5Li13ta7fjjbr8oBEYmYfHyNeQJVFs1XEgbZkOZtrK6 + 0siKQ3tUSak6IaB8+8MN6Dd4FHkVcSqb7xstB6KNuLBK8Vu7RYvFd0wbgdD7lqLdzJ/QkW58u0VH0Hb2 + bkTcuwKuyf3QQvrZg4Qyuw2z+zIAaPX2lE7peGfDBlTWqeWUDaZNOtbKX2Ka67cQfNp6ALL2inMBZB0S + 23aX7LEFACwlMCWNAcA6HAgWpYxs3wfhnYbBO6kvPGKz4RqdCafIdDhG9IZjZC84x2TQc+mqBOcWbCzp + ULv6tLZnKwCwtrKO3tr3BFD+oVHY+O1GVfarq7Rq99Utf4Nm8a2mG82rzRrsEY4UyrVjerWDp/fj4b9N + hk9MKv7kFCAbmHjdWkspDTLbU5Qk7Xgqkj0Az7gsJI2bgZyl+5G99jLSCQDSV7IHcJrCgFMiOghkMAgs + UUCQuVgDBAMMjiB9PnkDcw+ix7x96DJjB1Kf+AAhAybDNTaPgJnCAvdoAoJoAQNXLzXMxH0APDzGK8OH + k5f6yRdfoKi01Cg915uW0souSjrPbAS427OCvJ+a2gKrycsGjTxFEahUoaz8OlauWYmUtl3g4x9d70u6 + NXXmwt/9mjr7qwFAXZ0qCwZFpDqT8m+0T95InkBoMl54eQ6uFVxTddaGKm2yzsLH32Bs6FElkcLiq3jv + gw0YMOx2+IUkqWytr4UkRDV1RJO7SK6+L/08dRjC716C1Nk/od3yMySX0GXpJbT/2zfw7/0gWvrEUbgQ + KGxArdwsbDatXIOEJGL4mDux5/AeddO0HvHGu+dLmrRy5oWalhyAvh+gBM+/+Iq8FtNzMeuQs00bsg4A + Vgy7VkAQhIDYjpiwajPuXXMQA+btRs7MXciYtQvpM3fKY8bcXchadhCZs7bAMbijMPRaA4BW1jQsf5Ti + CNAy4izyNV9X1wA8+Oh4VFSXCqtRXb2t8je/RkykGepxM/8A5wc2/fQ1BtwzDq29Q/Hn1r6KEJWBgL0B + ul4txbtjsI8m4I9DYKeR6PL8R+QBUAhAYUAvuuc988+glwYCvbVwoLcOAiQCAmZvgAAgfd5B9Jy3n0Bg + vyQKu82i8zPhY4TkPY82ob3p2sUTEMRoABAlHIIu4hnQOaT3EhiSggGD78Bb736I4lJt+tTUUCSLaU2D + Ug3aWjTrmL9Cfm///r144MFHEBaRAl+/RHj7x28MiUx1VlRfdf96AMBSr3UIkhfQjRT+cpOUzf5xGDbq + bny39XvU1CiutXqt5NFgEDFWEkhcxBtvv4Z+g4bDLzRBerhdfeNl+EJ3UyUepJvRMqAtnDqMQvg9S9Fh + 5o/otOw0Kf45tF1xHu3nHUL02OVwIeso5B9ubO2DNTILNc/OtVz/8AS8OHMmrhVdkCYYNQv/awGA2gvA + Lu/egwcQk9xRSEiaA4CmhBmMOucMx4LPjuKeV09iIB34fvnnkLfiHHLIFc5ZfQG5ay4i741r6L/2LDwS + B1E44KdyGtqaLr2LzpJYs1Z8JTFSBYiMS8au/dvVQtX6Ms1alZgAQCMysdojcGMAsPYKzN5UAa6UU1jw + 1muI65aBP1H48RfHAAkNbnULJ8+Npz8JBPj9ecRIZ55bRBfEjX4Z3ef8gJ4rTmsAcEYBQP4JIyeQufSE + AQCZhhfAHsAhkd7zD4r0nH8APebuQ/e5e9Fl+nYkPPQmfHs+htYhWXTeEiQxqgBAlQ7dvBMoTCCAIGAi + N53O91347MvPUFJeKDkrxSuonXGz92QV61egtPwa8leuRFrHnvANjJXFtt5+sZd9AxO6sW7V/8KOv38K + AOjy0KMT/x+5/xNI2evNLK7yte4NUHwZFZuG8Y88ju+3fYdy2dpbK67PpSvnsZxcn+w+AyWByMM35j0A + nDByopDC0SdWsvqunccg8sEVSJu9E51IGTqTC9iJlL9z/mkkPfURvDrcJhajNSuBm+IA5CoBi2TdSaF6 + ZPfDRxu/JJdf8dLXmybE7AOAxQLaAwJbvr9aYzlIIaroNSY8P1lq+S6sjDYAICCgZ8LdG0tLArCxj0/B + 4i/PYNyakxhCMe/g/FPoT59bRoNXqRbhvq9expDXryA4YzxaOPlZPABpAAq3tv6s+HSNHU0AwH0WfK2e + eW4SqutVp2Jdg/LOmgM7817D5haPNCkSNhRKknj/2YN4etY0BCWl4Y9tfIWE9FYej2ZPgJSQvT4jQUiG + wa/9IKQ+uhI9Fh9Er/zzCgjyT4gXYPYA9HAgg8LC9IWHRTIWHDaAIJ2MRvrcA+g5Zx96zNmL7rP3oMvU + 7Uh+fD0C8ibBOaoPWkmWn5SeAMHVW5c44ShwJYAKjkjEyDHj8N77H+C6sAfVaOvpLTRpKtZX8f7hIwdw + 74MPISAsUUhRZasRhdPeAbETHnn8yf/3j9DVXx0A9N6AwIjUNqToHzdH2ezGhA50oUIjkjFs+G2YMWsm + Jj03GT0y+krOQLrEvLS+bb3+K/Ef3fiQ9vDofg/iHliHtBl70H7JSaQtPY32+WfRZeVFumH7EDV8GpyD + Okl8z5lySZqx9dcA4FZO9IXE4tkXpuD8xXPidRgbaRvKjNHW+gabsV3tOUsy0JZHv9hIDOpJQAsAqFzA + 7n07EB3fVpXm7AEAzyTYBQBuZIrA35a8i5c/PI07Vp7C8OUnMHQ5eQIrTqEfxcAyHchjwmsvYBB5AYmj + Z8oqcXsAoA/HcH98G+1RvAD+nt5DdFJ77Du4V+P408ARpTYuv7bQRIvnjfKfFQCU2N3ya0uIoocUFs+h + kO5KIbYd2o07HnoMLv7R+AtPV/JkJYcCGgi09lSgxRwH7sGpiOz/GLq98h16LjtJcpy8geMGAKRzMnDx + UQKAIwIAumQSABhCIJBBINCbwoLeFA5wWMDeQM+5DAa70W7iJwju/zwcCQhae5P36UleqVe80UjkzsLL + aLwixIj1HTgC7334PorLi7TiYZXGW0mfrugSVq9Zg87dslXiPDDeWGJC8nFwZLs2v0bN/5/mAVRXVwsI + eAXGp5DCn7RwsUdpNE8xFpJHduXZ9fRUPG1OkpQiJfdRyT2ZIvNSz8mNDu4Ez273IPK+1Wg37Qd0pBvV + YcFxpC06jY5Lz6InuXjtH3+bLMFIUqAYil9DJOvOwyutnBVlN6/x5pJTux5ZeO+Tj4QVRsKOemX5LY0Y + Zkqrci0haea1L9XyFSVaaatQ+90yjYi0wCopWKvnArR1409OnESg5G8Mylh7ABGNOuOkLEaxcEBUO8xb + /yOeePsUxhAAjFzBAHACg1acRH8Cgb4MAqvPoO+ac+hPHkDnp94VhZEyoAYAqodeTdTp8b/eFuvsrS9U + CcbkqS9rWX/Vt2Hl9ZjWhjUQyJWVn8OZ8wco/r1oXLcGo6RVrq0is965qH5eol1HHWBLLF6FiSexpPI6 + XvvwXbTPyKP7FyLLUHnIR7w7D9Xbz5UCHvJxJAX0bz8A7R9ejd4LDphyAEctYgKATBYKBbIMUUDA3kDG + AuUV9KLQgL2CXhweLKQwYfZepD3zBYIHvQyXuIHCP+HsESs5AQkLfHQa8yhZi86WffSdd+Pjzz7F1etX + cOHiWbz+xlsYNHgMAoOT1DqyAH3foewsPMk6xLrEOvVv4QHYDgyRpR9LAFBhTdUUY2z40Zl+ObHHfflO + 0psfo6wRH0rJ/MajZUQPeKc/iNgHXkXqlK1oN5NQeNY+pNEN6bjgKLpRTJc+7XskcGkvIFmy+3oijSm/ + WmoA0NLRj14jHHc9/DgOnzquuWSaO691tdWj1DTWWimEJKXl11FRWWQgtzUAqEpFUellfP3tJqx741Uc + PLrHeqWWTWMQK8GOPTsQTvE1txc3FQLYSgsCtNQe/bD482N48LWTGL3yJEaQ9VcAcAIDSPoRKPRdfZoA + gEBg3QWkz9yGNoHtDQCwlwMwJwFVT3wkOnTrieNnj9H7rdKqNCV2av0KAKqqz2Hq1KcRn5iE7H70/las + wPkrF7XrVWFYu3pt0YoCykrt5+XGngABiAa1P0Eah1jqClWooZUNT1w4jsef/Rs8gmLwJ8cARQjjHqWq + BDLpqH0WLt8FpyGm7+Po8eKXBADH0EtyAEeUmAAg6yZE9w4YEHpr0mvBQfSYuxsdXtiE6NGL4Jk6WnFS + UFjgwhThxt4CXlMfI/smQiKS0DNrMDr17Ae/kGQhwvFg5mDt0VMtPa0g6z/27xn0+T8FAC1Z4RCb0u1/ + CQQWWthdoxvzvHkrkSSUduPY2t/qTy5y8kAEDn4B8U+uR7upP6D9jF1oN52UfwYDwH50JDet+9z9aPvA + Cvin9FOTbZ6k9J7aZJkOAM6BuLWNHyIT22PRSt7/VyhVhjpzXd/k7vNhZIrxT7/8FPc88CCy+gzEgKG3 + YfHSpSgovKSBgCK9qKwuw4ZPPkFu/6Fw8QzF/6+FJx586imJYZUlUyVC2xmBSh6ZfeIJSeo5mcaOHU3W + Xy/T6dKCvJfc2x7GzI+P4+61xwkAThAAHCcAOIbBK44rECBQ6LeKZPUp5K05i9z8Y/BI7Cfej+4BNAcA + PCvPXH3LVi6Ta1Rbb6Eyb1TOYxoz8nzOn9+HDu1ScOut7vhjCxe0cPZC5/Q8rHzzfRSWlWtur1qycenq + Zaxc9w4mPD8Pi5e/hTNnz2sVIZ1UpKTx5qQGS6mVm6qYWfidj94XTse/0Oe6lXsH3MJlxkI6LDkk8IwV + b4DzRj7J2Ui5bzFZ8D1i/dOXkGVffNgOAByWx+zFLEetxAAC/jcLD2tewQEKEfah54J96E1fd3t5G+LH + LoVX2h0EBB3EqFmYjgkAfHXq8zihA2PWH+HIEPpwfc25bEZamNi2x/+yDv3aib9/mgdQVVWlGoRCEr3o + w39t7PYzOP5jRVQPtorveVyzVUB7eHYdh9i7lyDtb5vRaeZOdJpFKDtzF8lOdCAQaD9zHzrPPoguf/sa + YX2ehAsPDmn8chLfemrDLnTgW1L86+IdiqFj78HWvbtlis1Y+WVq6qnT11XzSurqQkyfMwuB4TEyz674 + 6SieC47HvX99FGfPnZMS5p49u3DfA4+QwoST4vvjf1uG439bR2L6omXKM7BTHtMBgN/Dd9u20GvEqQ1F + PBDjFm41GWcLAK0IHMY8uQDPvXcMY1cfw20rj2H48qMEAEcwZIUCgQEECgwAfVedQi55ArkEAoG9HyKl + DGqmDKhVAxgEyK1Oz+mDy1fPmfo0mmvwKUJp6Xk8cN99cGXXvLUPbmnthb8QELI3MfSuCfhm91FU1teh + oLgQDz46EX5hHejwt4NXSHtk5N2JH7bvl9l4BcDFdjwmG8pyfp63J508gLGPPELnianYQ2Vsmb1GvYoh + Z0sWxZJLHdQWcTnj0WvKV8oDWHTUBACHDMkmYLAHAGbhcCGDw4O5B5Ex7wDJfgKE/RJuZJD0nLYdCXev + hE/7O8kj7UDvQ621lyS4thNAKL8CEq12Y6r9mHFf+4Une7HusA79W3oAtqVBr8CEdoR6pxj5dABw0QHA + R7P6/qkU349G0sOr0GXGNnQh16orZ1/J3WfpPEuXPeg67Sek3UMXOHWgJKycdYJJE8kk5w+Yrz6hQ2fk + v75akXYIJXeFpfZqAwCKmKMcn37+CfxDuOkjTJaHumuLJj2CEmVB46gx4zHxuZcRHp2KW9r44M9OwfiD + cwxa+LfHbQ9OIveXvASmxaovaRIA6ulnZZVXcfvYuwmk/A0aMh0AbJWfm39c6ICMn/UuHnv9OMauOk4A + cJQA4IgAAHsBQ8gb4CUg/cULIA+AvIDctRcQOXS6kJI0BwDCsEP3gdu333znLbHWHPtz8q/OJqNvCwDs + ql+9cgwvT50Kv8AY/JmUvwUzIZGL3tIpFGFJuRj36BTcef9jCIpuD4+QtvAk8QppB7eAVPQZdBcBzjUJ + pXQPoGkAKLYiLy2suIola9cirl0vmbDkOQvuX3DSvBkOK3lRh6vW2x+cNgidn3yVrPg+AYFMEwAo5b8x + AHCeIHM+hQTkgWaS5WfJ0B5Z0jl/QH+32/TtiLt/Nby73QvnkG5w0WjuFQkoAYCAgGVJLskpn+Ckdv+I + kt//CQCY8wEeAQkj6cOXuGnkn5wkcSFp40sImDYYifcvQVdS/O7kpnWdsxfdpPyyFz0IBDjzytJjzh70 + nv4jYgdMhCvX/nlJiKdlm48inAgXN5d3xI257wHsOaKaepSLryeaGq+pNqbY6ovx+JPPkOUPFcpqzlsw + dZkwtAQmwJunHgOSpJf/VlL8PzuGyJRixoh7sHbDJ+TyXtdKiUXNeAAqwcXexgeffAAP33C1nEQb1LEF + AJnbp9fzjemCJ1dsxANrj2AMWf8RuvXPP4rBJIMIAAaQF9B/pcoF9GEQWHcBSfeuwi0ukcbQjQ4oTgbP + ofJwuFdg0IjbUFBCYCnjvvw57PU62JYBr9NnuYrquiv4/KtP0Tu7j2xeupVAoBWvNBP3PFIssisddLdA + in2ZXps8N48gXnSZivc+/FiFCabNSfbGq20rByxcWeHNUHeOfxw+9Pcc3aIU67FUkRQAOMt5ixWmYe+4 + Huj8+DpS/mOaa28LAM0IhwicKCQlz5IxY1s5pBKIJD3p97qTdCXvNfHh9xCUMwFu0Tz4lmKcJ9Oy3BLv + oKSR/+i4/58OAHo+oHN6/z/Qh55MXkCdYgCOh3NEd4QPm4yuUzdJ80X3eQcJAPahO9df6bEXxffpFGP1 + nruX4rd9hLgUZ/31DbIaHURBmZLJ2d1CMMk1dW6ZDY9Lxfxl+SgqK9YsWalWw74RABSiouIaRo2+U9aC + SdKS4zfNbWOOA5/gFCHPcPKOJ0WKRc8+w/HaBx/ieulVLbQoMbXCNgMA4sYWSeNRXv/BZC19pGIhbECN + ACBSeuKjuvbDM6/tIOt/BKNWKOs/hGSwBgADKd7vTyDQT08GMgC8ehYdnlqPWz3irQBApwRzEaJOxdbL + O/o2fPaJeEq1+jWz6faz3/mnVTt4FgKFuHjlOF6eNg3BYclo0SZAWJc5HHChe868Dq4ByXQPFbmmO3Ps + k5JOfmmaBgClVvejeQCwCFdfSqsK8O5Hn6N79nBtdsBS2jQLDzgFd78dvWdtR9binwsAhwUAlByyI+pn + HCb0IrDowY8LjqLnghNk2I6g/bObEDNqNvzaDYcbnSP3QAGCOq/gpMndMgf94R8d9/+feADV1TUSCoTE + dGzh4R+/RjKekZ2R+tBy9JjPSZQD9KikJyl5LxLuyEonMVwsAodskoSBL8KZGYM8VRedUHpLvzv3yYeg + Q5de+HzjlzJ6zBx33Gas01ZZlN4+JTcfssrKAoy+fZxwBkrixi/O4GcTKuYQXsecgl55Q7Bs7au4WHBB + +3uFqjRmrzfACgAsI8O14t6W4fW33iBlDNCWlYbKbL6jhxkAotCCvu8w8F5y/w9h9MojGLn8MIblHybF + P4xB+UdI+XkZKAPAMfTjdWArOA9wgjyA0+j+0ldoGdBe6yaMsAYAbmtlJSFg6D94OApLrqmmH63u39Ac + ADQU2Yz9MggoMKiuu45vt36NzJyBCgAIMJ18CAB8mQU3iUCVM+D8mCAAN+mFFxQJRkOpVbxv2VNYZBMK + lFiJXlLkhOPJCxcxctyjdB1j6HNGm7obo2VuhL0fr4RMdH/xS2RIgu/GAJCjCwFADil1zkLta/me5ZD2 + SD8Tr+KohBhqAOk4ei08gR6LTqDnkuPoSa/ZbfoOxN05Dx7xGQwAayLi1JQf68p/lAegS2Vllb5k1JsU + apNreCekPLoOXZccQw8pqajSSrrmQmVKLZZjLOVaMRhkzT2AiOynKbaL1Rh9NY579gLcwuDiFognnnwa + RcUF0nklK6obKm0on0ubEJ3UsxgTn31ecgqs/J7+arWZ8LGT8vtQ7NordwgOnzymrfkqU1ny+iKrcpVV + v7vJUlomBPX4tljannvn9MUt7AVoa8oUd5/qgeCD29I9Gjn3vYwHXj2KUcsPYUT+QQxddggDSQYsO0LK + fwT98tVC0H75xwUA+qwkWXMa2Qv2wCk2V/1tD0tOQQCAlJ9zMh7+vCDkdfWZNOvfcAMAaDC56uasfZ0s + Er0mn+3U2eMYPvpeumdxcPLVAIDZcoRWm6w/eQSOFAItWbFEq66U3GTXoPX9U+XEKrqWV/Dhx5+gz6A7 + LNOhnlEWj4C5Iei5oK6jkDVz6w09AP15VvTc5mSxLkfo+6MEFkfJWzhGcoJe4yQBDcmSk0hfego9lxMo + rzqHrNXknf11xSa34GRv1g3WkX+mTv5TAUBGh7VOQZ/Q5DhyA/d4pw5ClylfkKukYiamcMo0l2UWWuIs + zq5mzz+EhCHTyI1LkIksmcqSfno6yLLOKww+ZK1Hj30AO/fsFsrqelRZlF/v7rPb21+kMfgUY9PmjQiN + TFEAEKDTMJPlD2+PAJJps+ar3nhz6VDvYrspADAThxRIQnLlujWk+IEyKWgAgIcFANqQ9Rz+3DqMXX0E + I5YdwLBlBzFkKQHA0oPov/Qw+i87jH68EXiZAgBeCtqXQWDVadkf6NftPmkk4gqJHlaw9eeSLOdPcgcO + EL76Wsn8l1i1OzftARQbFGC2/f96GzRfz4MnDqF7ziA4chzOSu+bZACAM4FBeGIadu/fofUDWKx58wBQ + YpRsGTjOXzqLpSvXykIW38A4Sao6agDQ2j1Kqw4wl0A4WhMQdbh3DvouOUQKe0gsu33LbwGF5gAgj5Q+ + b4lJSPlzyLDlkLXPIaXPWUIgvPQMspedRtbys0hfdQE5a08jfdrGPaljZsY5OIQ51NTU/M8/Wx//6QBg + xSIUnNzdwz/hdHCPsehBSCyjmkuOimRJFlaPubQSzUIKAQgQuk34BO7RObLgUhI9IlGGOyv74siqpXTI + xKL8dSgouq76sHWaZ7sgUGIVZ5ZVXsdEckm9g1TC0tOf4/40BER2wMix9+LU+ROmxGJ5kzmF5qfkLOQh + /LtnL59Cx55ZuNUxSKPLilQHWKxXlLS43jX7C9xO7j9b/2Fk+Qcv0wCADnJfOnj9lioAMLYF88JQUv5s + sjThQ18RjgQnU+ZfBqzoWvlQ7K/IPqpsBn5K7Pb936zoIFBH4dHGrZuQ1CkDLj5JwovHIMDkrJ5BMXhp + xlSZlKy/aetfpHUSluHytfNYvmqtcO97sodBn5EZfVwMqvdoNTnoodx/HiSKyLofA+ZtJ2Ul5RUQONhI + chYzsegBI7a3AIDp95sCABIFACeQQxY/hxQ/b+lZ5OWfQe7Kc1Km7fzEmtM+nUd1dxj41f+dHv5fvKjO + ZKImB+MGuPonXYka+hy5R+TuLz2GLJLsJYygR0QMINCTLOQJtHtgFVyiMoXimVcxKW9AXzoZJ5tfuMWY + 6cmGjhqHr7/bQjFphbYjoNJo520MAEVa2asE14rOEoAswJARI5CV2w+jxozD4hX5uHj1rNbWakoo/p0A + oBKCpZixYJGRBzAAgA4u00n7xfbA+OU7cNuKIxier5R/ECn/gCUWAGDpQyAg68EZAEhyyBPIXH0G8fes + RkuvRCtuPW7E4lzKoOGjUFR6RXb7KbKPkmanHH+e8JzANQGBTd9+iQFDbkd0XDdEJ3REZl4/5K9eipKy + i+Ip2OMMaDRFqC0sKab3+/4HHyCn71B4+qn77873nsdztfPAAOCoEcRwXqUV/YyVv9+sbXR9jorym8UW + BP5eAMhdehK5y3hn4xkC47Ok/GfpdQ8i5fapV9qE9hjg0Ftl/H8Ndp9/Kw9Az3I+NmnW78jFHusR0bk4 + 7eFVyCGLlb2MXKalZLmW8gU8KiJgsEglWrLkhhxA12c/QlDPeyiuTFYegKyQijbYXbnpyF02D0UI3dYz + z0/B4eNHFaeftKfaSwSWaKSlJZKgqyElLSo7T2BwiryCS5rLWWq1CqxxUvHmAMCSCygwcgGHTx5BQlpX + tJSuvQgtho2W1WKhbXPwyOv7MXL5EUn+DeLYX7P+fTRRFo1kKQEBeQJ5JFnLjyNz5Skkj1mguuN4VRYp + vz5S7RcSjw2ffCijquL61//9lr8pYeKPS9dP46e9P5DLvw1XC05oyVOeJygwCETsW/wiuWcVVdfxxcZP + Mey2u+DP/BBekWrGxFtZflc2CvpKMS9FZ84NZs5h3dB2zCvoP/8n8ZRslb9JABBhZT+IPFL+PHnUhEIE + Q7Tr32epAmF1fukcLzspAJBLMX/O4j2IGvh4cSu/+LF3tQ39nVkX/qsAQJ8c5JLHwH5D/j9P/5iHfdv2 + r+j98jd0sc7JRcvLPy6Su0wDgiVHBG0ZCLL0jOzMH9Dh7kXwTRmE1t7JwtLiYh7G8FFAIPMHPlHo0C0L + y1avQYHwvVc1nRBsKBVvoLahsImmlJJmkok/DwCMeQHOnNcX45nJU9DCKdBgD2bG2lbO4fCL7oKH1u7A + SPIAhhIADKT4vz9Z/750UK0P8mG5VjkMnOxR0bXMnL8PQV3GyTZgtTQzWhvECifP5i6ywPT6wvNXrOr+ + 9SU3Jvn4JQCglT4l32KamFQDRQVAEwAAoRcvwI8/fYf7HhiPsMgUtR7c6LWPkV57VwGBWBUGCp8hXUO/ + JISl34uMyR8TYCrvSCnpYUNuDAAHNACwlj6k+H0WW1979bePqXNLHphsaybLn0shR1j2AxVtfGIezuqa + +v/x2f9HTPj92wCAXh7kC9ErI+cPHoGpT8f2f6qyD1swnm0n17VP/nERAQNB7SOSaVXlGC67kAVcQDfq + xa+QMHwK3CJ6SbaXa86u3vEaEMQawxhsLTwCYzFo1Fh89d23soJMus+MJZ22YUFxI2lcgrKlCDMDQFEz + FtQGANgToIP+4+7tCI5MJaUP1RiEyQtwC5cpxuF/exOj15zAkGVHCAAOEwAcJgAwWTBd+Umy6HplLaUQ + gA5h8l0L4OSXIuGSWEmZx4hGYEQsvvjqC20DTpki8jQAoOhXtf6NmZItJVG+BswBAP01tRgfUmEpw/6D + e4RDIS6poyLq9LYMlFlNl/qwxIm0oXvvnZiLzvcvwqDFezFgxVH0Xaor6BEDBPQ8gC0I6DmAHE2sAeCA + SNMAQAZrGQudYW7ImvcDojLHVTp7xz7dPa2b1Pr/meW+f1kAMI8PJ8Wm/K9PbMZzXR59taoP17BZOJOt + AwHHtAICGhBw/EUAkEfhQN+F+9Fv3k70fPodBHe9k25+ongDiuM9znQ4YuTQcMdgRHw7/G3qNFlyocga + Kmy4/ktvysrbf06TZpVCJxDVqwHXyUUuQFlNIe66/2Hc0sofrV24Q5CbmyJwS2t/xGXfi9tWsvt/REp/ + /ZaquN8MAJI34UQq51LoAPaa+g08E3KV9RdgjBVQ5Gsw+i6y/hVF0idRp9Xfm2X2+TuV3xYILE1EhRb+ + QBmtVgBw7MQhvDRthvAourKr7x1lDJMZos2XGLMm3F4e2A6RfR5B3+lfYeTK4xi8/CT6LyfrT2FTHwME + DjcbBugAkLvQIhbl3y/SNABo94XObv/5uxDfZ3yVi1/McykpHf9Xevz/QeO9/5YAoAaHFAj4e4T/MSJr + /OTcmd9W9Sfk7GcCgb5c2lp2THPhFAiYEbnPwn3ou2gfcqd/h/jhL8I1tDucPNWiB1cfCxBYDgpPaYUj + o88AfPTF56isKdFomywcbTcGgJK/AwAKbACAa+cFsh1m0zffMgssWjoFGyDQ2ikMzoHt0W/qRgzihp+l + KuvfxwQAKnGqSlBs/TkOjSXPqA33TXjqAKB64gNCE/HJF18KeWWdxoPwDweABnvXoMCY+INY/VKcvXQK + cxctRtuO6aL0Lt4WPglbABDr76cBOym/Z1RXtBs7A4OX7MKQlccwmM7NQOmN4LyIRUFtLX+jEEC3/GYA + WHjABgC0MED795KL0b0LAui+i/YgZeikKvfApMnJCSl//GcM+PxbAoAZBLx8Y/6YOfHN5wYsP17Zb8Vp + AoHjSpYfEwDg7K1xkXUEZhAgLyCXQCBv0V70WbQb3Z56Cz7tRqI1z2Z7K9fQTYAg3gQEMWIJgyNS8MSE + iTh+6pi0o9YbYYHNsosmGoialF/gGnPuobSiACPGWFaLt+TFom7MnR+OtNumYOhyAsOlCgzzlh4zKiYW + OS7lp95Tv4NbbI7WFx8rAOAmq6/CMXTUGNkAVKP1+9c3avPVac4LfrG1NxaCGI1DijjFIhqlOq5LnF9S + dgnr3ngd3TIGCJGGzCj4RJJECXW6EguvhPIAGATUurfQLrche/L7dH0Oq+lIbo8mReQeib4m17+58p+u + /HyWzJK3YB8Zmf2k1Bbpt/iASF/OxSw9JNKHZRl/vQ/tx82odI/o9FxERPy/nPL/ywGAgIDWMnz7C2/+ + 79D840/3XXmmQvraNQDgLjcGAB0EpOy12JyZ3a8J3bAl+5D50iaEZD6GNn5tCQRMAGAAQZxsenWTunEo + evTOxfoNH6OipkwLB0pvQn5tAFDtwR99/pkMITHzTSu3CBmmaekWDu+ELAycvZU+/0kty3zMSnKWsevP + OZNTiB81ncIhvWlKJ7CMhX9oNDZ8+gkpfY2qv9drsf+vCABWq8GaAQC2+OVV17Dp240Yecc4eAfFyI4E + F2+zstuKxQNwYlAITUXi0KcxZN42DF15VLVGL1MyYJlqklIl0r8TAAQE9t0QAPotPYiej62t8EvKezo4 + JELc/sp/MeX/lwQA1S2oRogf+fDsH/quOvFw/xUniwdyLMVDLiYAMDwBAQF2xczu2QHDG8idvR0pYxfA + PSpL5rJlNFTYhXUgUNUCjo1dPSIRFJaMJyc+i9NnT6hKQUNTIYBt44qd5262Tm52hUWJSsg6X0O/obfj + L05qzl11s0WjtWcMOt4zD33yT4mlVyBwXBTfECbCfHELXKNzNNdfNUjx5+WGqaGjRqGwVO/5L7aa+KvX + aLjM8fnPrvvbiK7suuKzxefHqprr2LxlI+66768IjWqnNvJ46YpvCwDRhnBCl5d1ONF9C+gwAOlPr8KI + lYcxeBVZfLL+rPT9lirpL4aCXH+9RLqk6ay/KP4i5UnmLtgrwoqvrP9eQ5oCgD4CAkeQ/fLm4oiMBx72 + /IvLH5Tlr/6ff0Vd+5cEAAGBOmmMcHh4w9n/b1D+ubGD8k9eGbDimBYG2ACAgMAhuQl9WBbbegMKGHpM + eF8lCH0TZURUKJtsPAJ3DRA86MBl5g7AF5u+JAtZrlFZlTUf7xv5gJJm9+M1lQuwBoBC6VV44731UqtX + RBcxJLHytW+7Qcidv1vrl7AGgGyu/1PcGztiGhw9442auEr+xcM3JB4ffvqB5BpquenJyv3/NbL+1xuJ + 2eoDiuPv0LH9ePSpCQiNTBJ2ZDfxUFQJTyl6lB0A0NikyKPxCG6PtsMnYOC8LRi0mhX/GAbkczs0W2Bl + jftKlURX/qbr/XrSL3ehrvwk8/eK5JH0MQBgT7MAwE0+/eZvv9Ll3iVjW7t6S6nvXyXh928FANInUK9A + YPW2ut/1X3l8QP8Vx073Ey+A212PiHCihbO5fXVhpNfzAoZHcFD2xOdSSJAzawsSRr0kTSG8VMJVeNsS + 6DHBEhLw9J8vewThCI9LwfS583Cl+IpWLvx5HoAxMddU4qsJiymlMfICrhRdRu6w29GCmYJI+VmYC7+1 + TzI6P7oOOcvPSKyvAwC7/lnLTyLzle/gEZctbbCqOzJG3H+2/gOHj0JByWU17muwINsDgAI7HkBzzxWY + wMwkMg9QoEkpCoovYtmqVWjbKV22HPHYNfcmWDL8jZXfzTtK+PTcNIafgLb9kP4kWf0VBzBwxRFJ8PWX + WF9zw+ne99EMQp70SRxsVvkFAHS3f4Fm/efrQkq/YK/JA7CEAH1Z+TUAYG9j4OK9p/u8+OGADh63/k5K + fTW1//OvrGP/0gAgG4fq9dmBhx0GrjzRnTyAPQwA/bW4rh8hft9lGtJzKGCD9OYEId84du/6LNqDro+v + gWdyHzh5KeV38TV5AQQIIsxeJGQgkRh5513Yf/iAWmmG8pvPATTyBApMDUCNPQHzlGCdUIiX442PPoZ7 + EHktHjHCOsvi6BaN4B53q5LfsrOq4YSVX7rOTqHt2PnkHqtNt5z7cNXCHL/gaKz/aL02769anmWS0S4A + XLfxTMzKXWjnucYin7NBJfhq6W9v/u5bCj/uhqdvtAxuMQeBMyk/dyc6CwjYj/uFQp5+1zWoLRIHPoYB + s7/GkFVHlLufTxZ/mbLA/STZpwEAG4DFBPwkeUsONAsAfEYk02+y/DkLlOQu2K0s/wLlCfQ1JQL112HX + v3/+wT2jlu7q7pCp2ntr6+r/519dv/7lAUBaJRu0N5u1yWHgiuNx/fOPbuLR1wH5RyxAoCUEzYkeqfNq + ANCHy4R6SLCYbuLS3cia8glC0+9Ha78UOPnGGA0k7r7xBgDIDgNfXhAZKl2Eb767HhVVam1ZneHy30T/ + uskT+HkAUEpewFXkDLgdbZjlRgMAJ/cYOAZ2QueJH5HFP2eEAtn5Z5A9ew/8242SWQhxqbVGKFau2+68 + A0XlXG6s0DgQS60mGRt7AL8UAPTYv0A8ohOnT+CFqTMREddRpja5bdeNl3x6KcV38lFA0Djuj5IqgJNf + LALb9UX64ysxnK0+KX9/Uvz+7HKz8i85YLH6cs+1XJAGAErsuf02pT47AKDcft0LsK4C9BUAoMelBzcN + XXkozqHtFw7qzDb8z7+Dbv1bAIAaltDe8LitDkNXHvUm5V9DUqcDgfIEVFunAQTmEqFVBxd7AfsodtuL + fvO2I2HMVLQJ6SAcA9IsxN6AH4sCAA8ST1YgzygEhSbhyQnP49zFsxISsILWakok1rReoxUzzfrb9wSa + ywVYAEAGk1CGhflrNJr0aBmA4p5+HhAKyXsKWUtPqvmJZdwzcRbt7l8FR//2QrfmotfKmQsvMl4WfErd + v0Gn5y6zGfk1JeqafH/XTY07tln9Qq2nX+1IKCi+jPw169CxWx9p03Ux9upFittvK9YAoCi9XCM7ou3t + z2Pggu8wbPUJcvmPGeAv1l5Tfj3cE2uuW/5FFjGAQE/y2WT4LS6/cvvZ8hvWn0QqS6a/10d1Atb1WbJ/ + zeDlB7wd7vjKwXxWfwOAf0hI0ECewOcOo9YcazEw/8hkkhJO/PTXQoEbA4ASheB70Z8e+xMQtH9wJVyj + MhUICGmFxuLqqyicPX05MRgLD2/eFR+J/oNHYduObaT8ZYYlNQCg/tcEgGLxNA4cO4yo5J5SDtQBgDv7 + nMN7oOsLG5G7/Ay5/qeRO3c3fNrfJqPS4gHoSTPPcNx5z70oqyon619tEKM0BQBqqclNAAAaAwC7+zzT + sHHrdxg4+h74BCUYvAPG+/GOsg8A3pYKgDM9Brbvj5zJb2LY2uMYsPoUBiw/aii/JPqW6NWf/c0CACt9 + Dilw9qJ9jZQ/xyretwYAw/rbAYC8xQdKcpcemTxs1fEWDj03OGg5q38r+bcDAGkdriMQcJjj8PC7J/8w + aPmhkQOWHTrFyZ9+Wumn7xKb9szFdoY46LAoENhHX5MnsHAvuj/zLjxTB8vOQTcfbQOxJu6GRBMQEAiQ + BUtN64q169agvFLV7VUsrUmTc+2NiS4bK1mhqTuwUGLnytoS3P/wBJkHkKWdXALjR1L0sP4TyfXnvYDn + kXLXErTiuj8zCLOSycBMFALCuOf/c63rr0KtNtM296jZfxuW3wZ75ckCqwGmhgZrxVf9+2U4d/k8nn15 + FsLiOkmTlZs2rWfdwWcfALj27+wdAseAOMT2fxgD53+HIWuY5PQY+q1Q3Xz9pAPysEX5rdz8AyJ65cfc + tZfDyq6LVuIzkn0L9tiIxfrn0dnIJdEBIJdCyNwl+0/lLT0w8r63j//BwWGmQ3Xtv5/y/9sCgLlCwDIo + /1A7igW/1kFATwI1BwAKBBQA9OWyDmd36cb2+ttnCOo2lhQnWVN+3kQca9VCzEDA3gCDQGBwDJ545ilc + ZA59lN9Ek9CNAMA8KVhgdAZyW/JnX30Fn5BkmW9XtNcx0inHXkCP6T9K/79n2gj5uQvvsdesqRMp1B33 + 3IXSyiKN5luRmKhx6KY2HBfbzQFYAEAb3zVZff68m7dtQ+aAO6TD0sXI3Ec27t+3AwDO3uHCfuwW1xVd + xi/A0BUHMYhc/v48xGMV4nGl57CK+RvF+brltw75DIu/wBLbW1l+TeHNkqdbfgaMRSqBrIUSX+ctO9hO + P3+1df+eyv9vDQBWycE7NjsMWXHIizyBhf2XHqpgD6CvlhAS5W8SANQBEpEDQoeCwoHM6d8gesBEOAep + OJpBwM0GBHRRrmwQht0+htz0A4qBWMKCsib6BW4WAAqsWoN5CvF6yVX0GXInWrnwei8L7XVLt1gkjZuP + Dk+8LglNiZtlcCZCXO+gqGh8/f1XFrYffUc9bMlLi34BABRI/35x2TUsXr4OMRSmOIvnwW58hJTv3OwM + 8LhIcs+i/E68zMU/ARFZdyH35Y8xeIW5z+OwUdIzeu8XWybydKtvFj0cMOr6mtU3hJN87OYbsluJrvwL + 9hhlPwYACR0W76ugs7JwwNKDXg6j9WTfv6/+/NsDgBkIHHp86DBu3dH/HbD00Nj+Sw6d7KeXgWxiQ1tR + Ax77rbO/i/iQbEcaKZV7eE/VP29H+VUsG60OsEcYeqT3wbfff08KVS1NNk15ATcHAPbosCuwYt0b4lbr + bEEcAnAy0CtxAAI73y7UYUaizTtK9iPcPf5elNeUaPyFptXUDaV2WnSLfgYAFIvLf/j0Cdw7foIsthDw + 8dEBwH7rLocD/HNn30jyriKEyMUztic63TcLA5bswMDlFOMzvdmiQ83mcYx7uMi6nGeU9EhyFtgoPsu8 + PZrsJtllJToICABorb8cMmQt3ncyd8nesXeuOfi/Dp3ec/h3yfL/VwCAuXNQCEaWHkohAPiY0LreAICF + 1lNdjWTBfg0A9mkgsAf9yP3r9sgqeCVkyUIJ1yZAQA448+uRsiWmdMW6199EeXWxKSSwbhT6pQDAXsXx + syeQ2iGdvIAwWeDpJDvwotHaKx6OzLFnZNmjBbgCIuKx+buvtHn/Um2t+c0AQFETAKATfRaipqYc6z/5 + Ep0yBin+BZN7b693X030RUtewoUHfXwIxHyjEdZ9DPq99AmGrTyI/hLjHxKOg74m9p3m7l2ORthhO7mX + Q/dUB4BssvKGkOJnz2XZRbLTkCYAoJ68h48p5k/Rz1dN3X+G8v9HAYBVSDBms8PQ5YfaEAhMIBC4zLXb + PtLPvd/+AZKDwgBgEfW7e+gQ7kKvZ9+DT/vBaKO3qTLrjHd0I6smh5uU0j8oAROem4LL1y6JteWtNXV2 + yUftDAE1aqQpsPo5Z9effWEqWjoHkeXXKb4jDZ4/Zy9L3z8vTrnjnnEorSpGrdCcWVafy+ruJjb9WMqA + 1g09hvUnMDt/5TwmvTAdQZHtxOVvBIh2RSk/Z/gl5g9KRsrISRiycCeGrDwu2X1m7OmrWXw1kKO78PuN + +6RLNkkWPy40sfbYsfyG4s+1r/i2AJC3cLck/sj1v0znZ8KgZQfaOIz+8j/C5f+PBgCzN+Dg8KLDgs0X + /1/fJfu79V20fyPF+PV5cij2NylmABAQIG+A+8A5Buw1+RMEdLpNlkyYl2k0mk1ngCBldKOYduTtd+PI + scPiutfpvIFSKixqAgAKbggATDe+c/8ehMW2U7yBJgCwWH/l/gdHxmHzlk30urUCAPpilJsBgHrTe7Eo + vmrq+X7XTuQNuVMqJe4+MXa8omi7AOCiNfVwpt8jpid6PbIEI5nchJWfp/Yo3u+/+Ij07ueJS3/AFL83 + vl9ZZlmoAMHyc1Z+pfhZLGT1s+bsItlJ8hPJDk1+sgMAe+op9t9Iyt9tztcX/p+Dw/P/UVb/Px4A9H4B + +YC3bXIYkn/Que+ifRPzFuy9oCxDE0Awb5+V5GqSreUGsl78EmG970Vrzzhxv3UQMIurd7TW5RYlAy6Z + 2f2xbcdWCQdUclC13eokl7ZJQdt+elmwIUs21M9ryBWvrCvDYxOfRwvnQMV1r1UF2OV3FqZf7hUIxv0P + P4CKau5PqJL4Xym+Un6gxCbpV2Qw8TS2/tfkOV6pvnLd20hon0mvEylz+CKNMvzRJlGlSLUKPhKtfeMQ + 1G00cl/8GMNWHZMBHt3t77dY8Rvqw1wWD6Cx5bcr89W9zZ5vSfKJu0+KnTVXV3yz8lsAQHIA83ex63+h + z8I9Ewcv3efscJtK9NXV/2cq/380AFglCH83z+H17Wd+13fR3jSyDOtJquUwzbcIH57sedaigMCSNOJs + cc4rWxCZ8zhaucfKYlJnbbmmi5X1VYefWXfcPCPQoXM6Pv7sU3Lf9aYh26RgkZ18gFK+WhImw6ypL9AA + oEAs+U8H9iMiuatMBuq7EXQAcCLlDI9PxbafvhcGZF6Npix/qab8ppi/iTl98QCko69AwOLcpTN4+Jm/ + wSc4WY0VCwlHtF2GHmsgiBLl5zFsx+D2SBzxPIYs2I7BmsuvN/RIhl8vsy3cbzdEM7v9WbbhgH7/5msu + v3bPlLtvT/EbAUA1xf7r+y7cm/bmD8W/49r+f5q7/18JAFbewKjPyRs40IJcyrFkKfbbU3pdsoyv92qH + SQMCngx7ZSti+zyDVl4JwjXvZCzZNAGAdAxGy2pxN/pZdGwaFi9bivKqgkbVAXsAUFdHlrfuGmrrLACg + S21dMYqqynDfhCniAVgAQL0uA9NDTzyFymryOurKtbi/RBRZLD8svHtGO69NU48+vce/v/fgfgwcebeR + zHMzEXGqkp4u0YZYgIEXc9J1iMlAx78ux6Dlh2SHocxumDr59IqNEe/bKL7Z8mfNV5JtBd57jXuVNU+P + 83c1o/gWACDl30+u/9hh+ftbOIz8/D/e6v/XAYC5eYjJGRwCVjpQSBBIyvwKHZrLtsqfOXdvI1EegSod + 5ZH0mb1deAdbeifICipnY822xRPQ+eq4aYgZhwJD4jF5you4XnRFrSszFpI2DQA6CFST4lfJYxGqyJO4 + Ul2B5+fnq7VenmrJhygcPUbGt8OPu39S5UiN499Q/ka7/SwWX9X1FUWXGuIpxsbvv0Hn9P4CLrrVV6L1 + QYhrrwln9k3CngJPJAZ1uQ0Zz34g7dr9ZF5f79ZUiq8P1uTp8T6X3WysvGH5WeEbAfZeifMztey+ivMb + K3v2bCWm5y6Td/BKnwW7Ah38lsrRqP0vUfz/SgCwGirq8q7DhA9O/D53wb72dIheJym1p/jWAKC8gFyO + FxfsQd7c7Ugc9oJQbskeOgIAJ69IIwmndhFwokzrHCRL6OUXibsf/CtOXzilbRcqMXbr2fcArqGGhJW/ + qq4AlfVk/esrsPX4CXTPGSIhhhqs0QgzvMLw9LOTUF1bpZh+NX5/K+tvBwAs7byqu6+ythCvvrsecWm9 + pCffYvV1AIixAYBok/KT1WfX3z8Jsf2fRN7sbULSkbt0P/qw6JN7WiefGQAkhl+gACDT5KFl0df8fdZ8 + e96aUv7MuSrJlzn7pxsBQCnJ6zlzf2o/4b2jv3do/9q/3RDPbwDwa4UFI790GLn80J8odswjRf+cpMou + AMxRYm4gyZ2/C33m/oikES+hpW8iWnuEyyIKJ33nnr6owkctrRDhZKFPCAYMH4lDRw9Zr8M2DQrVmt1+ + tvys/OT6F9SW4kxFCR6fOp3+Xrj02UvS0Ud1/8W3TcPew7tQy1uRuevPvOXHzuCOdR+/Uv6rhRcx5ZUF + CIrqoM0SNC7tcR3fxTfa1PBjyQU4cwkyrBPa3TEdA+fvRN7SA9I/nydiM6HHk3iaiOs/36LsGfPsgDE/ + Jwpvkay5enZfKb+SHSTbDREQmL29ih4/J8XPG75sz58chn74X+Xu/wYATQOBg8NtGx0GLN7fMmve3pGZ + c/d8kzFnTw0JWDJJdADInrvHqCPnzNuJ3AW7KCSgcGDo8xQOxKGNZ3jjmry5TOijMRF7hyI9rx927dmt + kY8WWS0S0RN+ulTXFaGktgLnqyrx2fbdiEnpKgQZiiknRgaUXL2D8fxLk1HdUCFcf/Ua268tABglPj3R + J4p/XbyR/ScO4ba7HyFPJUmVNI0GHus5fd3auzRq9omGZ1RPdB2/nNlx0G+x4mW0mqIzKb9Vm+58S/6F + lV9krroHxr0gF1+sPUkG3QeWTCvF12W7WWpI8b8hGTlg0c6WDiM2SEPPf7Pi/wYA9qoF/F+/Tx36LNjr + RAdtTMac3VtICAh2q4PHTSRz9piaSUgIBLIIBLJmb0XskElo7RMvXoC+fddcKlTeQKzQjrEb7ewVgq69 + c/Hdj1tVOGC1FssaBCrI+l+sKcfB4lKMe2QiKX84hRZRwl0o04nekUhs2wH7j+wVth/7O/6s6/sWPv5r + Evdv3LYVXbMHS6jioXsVMutgoeOWzD9bfhZeyMlhgEi0hAK+yXnIfPpNDF6yD32ZeGXRXmOgxt4Yrlk4 + g581T1n5jLma8mtKbiXztEdS/PQ5PyFjtkXSZ+0QyZilFJ9kCyn+mP4Ldzo55L0tt/g/pY33NwD4tfMD + xurycQQEHzn0XShAMIoAYFPG3J2VGVJLZhCwAEAmPZcxjw4fubqZs75H7MBn0MYrniTC8ASsy4OWLLqa + iAtHu8698eXmjVpOwLpEWFtfRHF/Ea7UlOFYZSXe2boTYQmdSDkj4OEbKeLpywM3wXh28mQCiyrF9Ksp + vTnx1xRfH68j+/ybr5HcNVcAxVMAxX43n54DcPVjIYvvFwtnEif6TEHtByGX9+8t2W8ovi65NwAAc8OO + WHix+LtFyZuSdFZ4k/QmxdekkgBgE7n8o/otIMXv8w6p/RAH8z3+TX4DgJsAgkF0bj5x6L9oT6vMeTv7 + EQCsz5qzq9CIN/XDOJeszpwdYo0yX/lWVlKxJ8C5ACevpgGAFYkZh7gtNiG1Cz74aIPRqae3DdeQC3+d + 4v7DZRXYWViJe5+bKgszdOUXITBISE7Fnn07NetfaifzX2QDANc0y1+ML7/9GqmdM+BGSu3hFyuly5sD + ACWs/L6p/ZH7/AYM4sSexpzL/fQiMk9vT+nNir/H5Nqz4u8SsVVye2JS/EKS9eQJ9CPFb+UwcD0pfo/f + FP83APg7LxL/d+dnDsOW7f1TztxdXUj5F2XM3nk6fbayQuJ6zqYDSI+9CAR6T/sWYVkPUygQZ9Uk5GoF + AAoEhHPQT831RyV0xOvvvI3aukpSWLWPoKCuDPvKyvFjYQU+PngGCd1zSUE162+4/2F4euKT9O/KJfNf + 31DaKNNvdv0bRPmvo4Ys/0dffomUTlmi9EzU6W5k+aObBQBd2PX3is9A1sR3MJAt/8K92tyFNcVWo758 + cfctJdcMw+LvblbxM0xxvun506T4dE9+6jJ4yZ4/OYz+WG7Zb2f3NwD4tcuHDg6jP3N4+t0jvyf3Pzx9 + 9q7H0mft/D5j5o4KtkC9NOlNYNDzxY0I6n637B9w9bbdZWciFxHeQT0xGIHg6GQsW7Uc1eTyV5M131dW + ic8uV2PjlSq8sOJteAbHk9KT2++tK38UYhM64KedP5JSW+r+jQDAyu2/hmp6/q0N6xGX2o3+TpzwHsrf + 87k55WfQ4kePmO7o8cRqUn5FrJJnh15LOvI0xTdcfLb4ovhK6elammTnzQBABX39PcljWXN3hj/5zpHf + O4z6WJJ7/43lvN8A4J+WLNTKhz0orvRf7tBn/m7HzFk7sjNm7chPn7njZPqsHfW9Z/2I3jN/QA+Kh/27 + jCbFjlcUY9oeO95kq2+zVQCghNeAccLNPywO02fPwaniAmy6VoHXTlfjtf2X0LnfbZLs4xjdkxN1rJhk + /R9+7HFUVZfLqvP6GwBAHUlVbSFWvf4mohI7i8X3ZE/ExrLbegHm5wQs/AmAIjuj68PLhFMxb0Fj5c8x + jeBmzttrEbH6exopf+9ZP5lkh5VoAFBPcjJjzo78rLk/ZfddsMvRwX+pg0P3N/+tmHh/A4D/pIYihySH + 393+qcMjrx/6fc7sn4IICMaR8r/fe8bWi71nbkWXZz+AT9pQYRbS99lbAQBTkPvFG56AuyQHI+EdFIW7 + Jz2P1w5dwOqTlXhm5SfwCE0yOAk9CEy4ChARlyTDRjzvX6uP+1oBQJFpC/E1lFVfx/ylKxEazYnEBAol + YpXlbwIAbK2+zpLsHtYOaXfPwoCFu62WaKhmKc3qz9tjdOilk8KnS1Z/j+HuWxR/pyYWxe81c7uI9v1F + Uvz3M+b8NC573s6gv7594Pe/p5DMwSHhv7aB5zcA+FdMGiatdXAY+ZHDsCU7/5g5e1tMr5lbH+w+84cP + Ozz86gXv2JwGfT25AICUAuO0/QMmABAlI2Xzj4RXSBzGPj8H6/ZeRfqIR7WmHOWmMwC4MNvPg/ehoppL + fmz9y4TqC2YAkB1/12UXX0nFVUybvQB+YW0170MBjodvMwDgFy2rt0Xx/emRJSgJSUOfRd6cHVK7z52n + Td+J0u+VhF6WVq/PmLdHknrpunB8rwsrP0kvcvl7zWL5SVP+HQ0kF0g+JI/qwcw5P8UMW7rnj+ziO7Rd + 91tS7zcA+JcXB4ec1xwc+r3h0HfJT3/sM2N7VHTvR8e5+Ca95uoXc5QAoEpfTKq2ENkCQAw8/WPF0oYn + 9sBdE+ciKLabtBRLN6EGAoGhcfhSmH4rUF+nKb/VuK9lvr+8uhAvzZwFv9AEq9cxSyP3n7P8/tGi9Px+ + PAPo9QPjEd3nYeS+shXZc/eJS8/NUVlz9xrxvarX75THdJPy9yaltycMAD1n76wiADjaa+ZPr5EnMC5j + 9s6owYv3/tFhwPsODnnvOWhsPL+drd8A4N/LKxAwSFsq7mr7zGF/8A5N8nEPiM9x80t4iQBgEwHABQKA + WlsA8GCF848jiYdXaCpcAxKt8gicMOwzYBAKi9WOPxX76+O+5pHfIlTUFmHWgmWk/In0t6OUJbcHADoI + 6N/7K3Gn9+IVEA+PwARE9ByDzJe/JoU+SHH8fqTP2yPKbVF6i6STNKX0JLUkF0g2kTfwEj3mZM7d5XPX + 6gN/cLid3Pssi9L/Zu1/A4D/gJxBg6WkqP0XFtP5Fq+g5AiPgITBHv7x09z9474ghTtFUuFO1tY9gECB + FM/dX20q0sduZZmpdzjmL5qnVpRx3V9q/6Va7b/Y6O8vrynA7IULERiWpNx9DVwsyUdrZVcSp4kGAPRe + PAiAAjsNR88XvkDm/MPk2u+XVt10ie+VspsVP90AAHLr55CFn7urguQUyRe95u6a1nvursHkLUQMWLL3 + Fr4Wv7vrSwcHl0W/ncffAOC/BwzEOzD9F5nY5c8+IYkBHoFxPUnpxhMALHMLiPvGzT/+FAFAibNPTL2z + gEAs4lM64MChPajnHX9a7K8DgJrtL0BFzXXMmDeblD9RJQ7Jw2Dlbw4AXP3MABAryu8WFAff5Ex0n7Qe + 6UuOIn3hQWNYJ13cfCsAqKevS0hOkXxDsoxkPAFFz4wFuwMGLNv3Z/6s/7/7N1GY9IHFyv+WyPsNAH4T + a0B45rmpvwuN63SLT0iKv0dAUntXv7iRLr5xk5w8I1beducdX5ZXFu0j5T9X31BWTMpf1dBQUq97AGUV + V/HKnFmk/Amy6lwPMTxIsT0MBbc87+Znqk7oP5O4n1z/iI7o8NAC5OUfRNaSg/VZi/dVZS7cW5y+YM85 + Uux9GfN2fUmyksKASZnzdo0kaZ+zYJf/wKV7b1my5dLvuInqd/dudHBIXPdbLP8bAPwmN9VvUF9vFxT4 + v45d03///kfv/AWo8qyvL4uqbyjvQQAwnADgEQKA6UDFqg0ff7AhNDrxe3ff6P0UXpwkRb9IUkhfl5PU + kILXWwCAvvaL4+fKSQpJLpL3cdIjIH6/R0Dy94HdRm/ov3jHqtwVR6bnLj3wSM7S/cOzl+zrkbVob1Tu + or2eg5ft/8tT75/6vcPwDx2cHtns8OcHSNl7vmUoe/1v1v1fVv7/go10uREXjmAAAAAASUVORK5CYII= + + + \ No newline at end of file diff --git a/segugio/ProcessInfo.cs b/segugio/ProcessInfo.cs new file mode 100644 index 0000000..2e1656e --- /dev/null +++ b/segugio/ProcessInfo.cs @@ -0,0 +1,109 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Drawing; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace segugio +{ + + public class ProcessInfo + { + + + [StructLayout(LayoutKind.Sequential)] + public struct PROCESSENTRY32 + { + public uint dwSize; + public uint cntUsage; + public uint th32ProcessID; + public IntPtr th32DefaultHeapID; + public uint th32ModuleID; + public uint cntThreads; + public uint th32ParentProcessID; + public int pcPriClassBase; + public uint dwFlags; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)] + public string szExeFile; + }; + + + [DllImport("kernel32.dll", SetLastError = true)] + public static extern IntPtr CreateToolhelp32Snapshot(uint dwFlags, uint th32ProcessID); + + [DllImport("kernel32.dll")] + public static extern bool Process32First(IntPtr hSnapshot, ref PROCESSENTRY32 lppe); + + [DllImport("kernel32.dll")] + public static extern bool Process32Next(IntPtr hSnapshot, + ref PROCESSENTRY32 lppe); + + + + + public Boolean isParentPidRunning { get; private set; } + public uint ParentPID { get; private set; } + public string ProcessName { get; private set; } + public uint processID { get; private set; } + public DateTime? startingProcessTime { get; set; } + + public string machineName = Environment.MachineName; + + private readonly object lockObject = new object(); + public Boolean isRunning { get; set; } + + + //New monitored process structure + public ProcessInfo(uint parentPID, string processName, uint processID) + { + this.ParentPID = parentPID; + this.ProcessName = processName; + this.processID = processID; + this.isParentPidRunning = this.IsProcessRunning(parentPID); + this.isRunning = this.IsProcessRunning(processID); + + } + + + + + public bool IsProcessRunning(uint pid) + { + lock (lockObject) + { + IntPtr hSnapshot = CreateToolhelp32Snapshot(0x00000002, 0); //0x00000002 TH32CS_SNAPPROCESS + + if (hSnapshot == IntPtr.Zero) + return false; + + PROCESSENTRY32 pe32 = new PROCESSENTRY32(); + pe32.dwSize = (uint)Marshal.SizeOf(typeof(PROCESSENTRY32)); + + if (Process32First(hSnapshot, ref pe32)) + { + do + { + if (pe32.th32ProcessID == pid) + { + //System.Diagnostics.Debug.WriteLine($"process: {pid} ESISTE! "); + + return true; + } + + } while (Process32Next(hSnapshot, ref pe32)); + } + //System.Diagnostics.Debug.WriteLine($"process: {pid} NON ESISTE! "); + return false; + } + + + } + + + + } +} diff --git a/segugio/ProcessInfoTracked.cs b/segugio/ProcessInfoTracked.cs new file mode 100644 index 0000000..f0f4f8d --- /dev/null +++ b/segugio/ProcessInfoTracked.cs @@ -0,0 +1,476 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Drawing; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace segugio +{ + + public class ProcessInfoTracked:ProcessInfo + { + [Flags] + private enum ProcessAccessFlags : uint + { + All = 0x001F0FFF, + Terminate = 0x00000001, + CreateThread = 0x00000002, + VirtualMemoryOperation = 0x00000008, + VirtualMemoryRead = 0x00000010, + VirtualMemoryWrite = 0x00000020, + DuplicateHandle = 0x00000040, + CreateProcess = 0x000000080, + SetQuota = 0x00000100, + SetInformation = 0x00000200, + QueryInformation = 0x00000400, + QueryLimitedInformation = 0x00001000, + Synchronize = 0x00100000 + } + + + + [StructLayout(LayoutKind.Sequential)] + public struct UNICODE_STRING + { + public ushort Length; + public ushort MaximumLength; + public IntPtr Buffer; + } + + [StructLayout(LayoutKind.Sequential)] + public struct RTL_USER_PROCESS_PARAMETERS + { + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] + public byte[] Reserved1; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)] + public IntPtr[] Reserved2; + public UNICODE_STRING ImagePathName; + public UNICODE_STRING CommandLine; + } + + [StructLayout(LayoutKind.Sequential)] + public struct PEB_32 + { + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] + public byte[] Reserved1; + public byte BeingDebugged; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] + public byte[] Reserved2; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] + public IntPtr[] Reserved3; + public IntPtr Ldr; + public IntPtr ProcessParameters; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] + public IntPtr[] Reserved4; + public IntPtr AtlThunkSListPtr; + public IntPtr Reserved5; + public uint Reserved6; + public IntPtr Reserved7; + public uint Reserved8; + public uint AtlThunkSListPtr32; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 45)] + public IntPtr[] Reserved9; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 96)] + public byte[] Reserved10; + public IntPtr PostProcessInitRoutine; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)] + public byte[] Reserved11; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] + public IntPtr[] Reserved12; + public uint SessionId; + } + + [StructLayout(LayoutKind.Sequential)] + public struct PEB_64 + { + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] + public byte[] Reserved1; + public byte BeingDebugged; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 21)] + public byte[] Reserved2; + public IntPtr LoaderData; + public IntPtr ProcessParameters; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 520)] + public byte[] Reserved3; + public IntPtr PostProcessInitRoutine; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 136)] + public byte[] Reserved4; + public uint SessionId; + } + + [StructLayout(LayoutKind.Sequential)] + public struct PROCESS_BASIC_INFORMATION + { + public IntPtr Reserved1; + public IntPtr PebBaseAddress; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] + public IntPtr[] Reserved2; + public IntPtr UniqueProcessID; + public IntPtr Reserved3; + } + + + // Definizione di OpenProcess da kernel32.dll + [DllImport("kernel32.dll")] + private static extern IntPtr OpenProcess(uint processAccess, bool bInheritHandle, int processId); + + // Definizione di CloseHandle da kernel32.dll + [DllImport("kernel32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + private static extern bool CloseHandle(IntPtr hObject); + + // Costanti per i diritti di accesso al processo + private const uint PROCESS_QUERY_INFORMATION = 0x0400; + private const uint PROCESS_VM_READ = 0x0010; + + + + [DllImport("ntdll.dll", SetLastError = true)] + public static extern int NtQueryInformationProcess(IntPtr processHandle, + int processInformationClass, + ref PROCESS_BASIC_INFORMATION processInformation, + int processInformationLength, + out int returnLength); + + + [DllImport("kernel32.dll")] + public static extern bool ReadProcessMemory(IntPtr hProcess, + IntPtr lpBaseAddress, + [Out] byte[] lpBuffer, + int dwSize, + out int lpNumberOfBytesRead); + + + [DllImport("kernel32.dll", SetLastError = true)] + public static extern bool IsWow64Process(IntPtr hProcess, + out Boolean Wow64Process); + + [DllImport("kernel32.dll")] + private static extern IntPtr GetModuleHandle(string lpModuleName); + + [DllImport("kernel32.dll")] + private static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName); + + [DllImport("shell32.dll", EntryPoint = "ExtractIcon")] + private static extern IntPtr ExtractIcon(IntPtr hInst, + string lpszExeFileName, + int nIconIndex); + + + + + + + public Boolean isStartingProcess { get; set; } + public Boolean canBeAttached { get; set; } + public string CommandLine { get; set; } + public Process process { get; set; } + public Icon processIcon { get; set; } + + public ProcessTreeNode treenode { get; set; } + + + //whitelist to avoid scanning certain processes + //HashSet whitelistProcessesNotToBeScanned = new HashSet { "Memory Compression", "ShellExperienceHost.exe", "dllhost.exe", "RuntimeBroker.exe", "TextInputHost.exe", "ServiceHub.Host.CLR.x86.exe", "[System Process]", "System", "devenv.exe", "segugio.exe", "ProcessHacker.exe", "svchost.exe", "wininit.exe", "services.exe", "spoolsv.exe", "SearchIndexer.exe", "lsass.exe", "winlogon.exe", "explorer.exe", "csrss.exe", "MSBuild.exe", "conhost.exe", "VBCSCompiler.exe", "IntelliTrace.exe", "PerfWatson2.exe", "Microsoft.ServiceHub.Controller.exe", "SearchFilterHost.exe", "ScriptedSandBox64.exe", "ScriptedSandbox64.exe", "SecurityHealthSystray.exe" }; + + //set for gettin' all matched yaraRule for a single process + public HashSet matchedYaraRules { get; set; } + + //config extractor dictionary + public Dictionary dictMalwareConfiguration { get; set; } + + //track number of dumps for a process + int numberoOfdumps = 0; + + //process ha parent process running or not + public Boolean isRootProcess; + + + // new tracked process structure + public ProcessInfoTracked(uint parentPID, string processName, uint processID) + : base(parentPID, processName, processID) + { + matchedYaraRules = new HashSet(); + + dictMalwareConfiguration = new Dictionary(); + } + + + + + + + public int getNumberOfDumps() + { + return this.numberoOfdumps; + } + + + public void setNumberOfDumps(int number) + { + this.numberoOfdumps = number; + } + + + // update malware configuration + public void addMalwareConfiguration(Yara YaraRule, string malConf) + { + if (!dictMalwareConfiguration.ContainsKey(YaraRule)) + { + dictMalwareConfiguration.Add(YaraRule, malConf); + } + } + + // update detection and its description + public void addYaraDetection(Yara matchYara) + { + bool added = matchedYaraRules.Add(matchYara); + + if (added) + { + Console.WriteLine("Yara Rule attribuita con successo a "+ this.ProcessName); + } + else + { + Console.WriteLine("Yara Rule esiste già per " + this.ProcessName); + } + + } + + + //method return true if yara has been already matched + public Boolean isProcessMatchedByYara(Yara matchedYara) + { + Boolean matched = false; + + if(this.matchedYaraRules.Contains(matchedYara)) + { + matched = true; + } + + return matched; + } + + //method return true if configuration has been already matched + public Boolean hasProcessGotConfigExtraction(Yara matchedYara) + { + Boolean gotConfig = false; + + if (dictMalwareConfiguration.ContainsKey(matchedYara)) + { + gotConfig = true; + } + + return gotConfig; + } + + + + public void getProcessIcon() + { + + try + { + if (!(this.process.HasExited)) + { + string filePath = this.process.MainModule.FileName; + IntPtr iconHandle = ExtractIcon(IntPtr.Zero, filePath, 0); + + if (iconHandle != IntPtr.Zero) + { + this.processIcon = Icon.FromHandle(iconHandle); + } + else + { + using (Bitmap bmp = new Bitmap(Properties.Resources._39368_executable_icon)) + { + IntPtr hIcon = bmp.GetHicon(); + this.processIcon = Icon.FromHandle(hIcon); + } + } + } + } + catch (System.ComponentModel.Win32Exception ex) + { + // Log the exception or handle it as necessary + Console.WriteLine($"Errore: {ex.Message}"); + + // Utilizza l'icona di riserva in caso di errore + using (Bitmap bmp = new Bitmap(Properties.Resources._39368_executable_icon)) + { + IntPtr hIcon = bmp.GetHicon(); + this.processIcon = Icon.FromHandle(hIcon); + } + } + catch (Exception ex) + { + // Gestisce altre eccezioni generiche + Console.WriteLine($"Errore inatteso: {ex.Message}"); + + // Utilizza l'icona di riserva in caso di errore + using (Bitmap bmp = new Bitmap(Properties.Resources._39368_executable_icon)) + { + IntPtr hIcon = bmp.GetHicon(); + this.processIcon = Icon.FromHandle(hIcon); + } + } + + + } + + + //method for setting Icon to process not running anymore + public void getDefaultIcon() + { + using (Bitmap bmp = new Bitmap(Properties.Resources._39368_executable_icon)) + { + IntPtr hIcon = bmp.GetHicon(); + this.processIcon = Icon.FromHandle(hIcon); + } + } + + //method for verify handle to process + public void CanAttachToProcess(uint processID) + { + + // try to opern process with QUERY_INFORMATION + IntPtr processHandle = OpenProcess(PROCESS_QUERY_INFORMATION, false, process.Id); + + if (processHandle != IntPtr.Zero) + { + + CloseHandle(processHandle); + canBeAttached = true; + } + else + { + + canBeAttached = false; + } + + + } + + //get process command line + public void GetCommandLine() + { + + + bool is64BitPeb = false; + if (Environment.Is64BitOperatingSystem) + { + if (!Is32BitProcessOn64BitOs(this.process)) + { + is64BitPeb = true; + } + + } + + //using (ProcessMemoryReader memoryReader = new ProcessMemoryReader(targetProcess)) + //{ + PROCESS_BASIC_INFORMATION processInfo = new PROCESS_BASIC_INFORMATION(); + int result = NtQueryInformationProcess(this.process.Handle, + 0, + ref processInfo, + Marshal.SizeOf(processInfo), out _); + if (result != 0) + { + throw new Exception("Unable to open process for reading"); + //throw new error + //throw new System.ComponentModel.Win32Exception(RtlNtStatusToDosError(result)); + } + + int pebLength = is64BitPeb ? Marshal.SizeOf(typeof( PEB_64)) : Marshal.SizeOf(typeof( PEB_32)); + + //read Related bytes + byte[] pebBytes = new byte[pebLength]; + bool resultReadPeb = ReadProcessMemory(this.process.Handle, processInfo.PebBaseAddress, pebBytes, pebLength, out _); + + GCHandle pebBytesPtr = GCHandle.Alloc(pebBytes, GCHandleType.Pinned); + try + { + IntPtr procParamsPtr; + if (is64BitPeb) + { + var PEB = (PEB_64)Marshal.PtrToStructure(pebBytesPtr.AddrOfPinnedObject(), typeof(PEB_64)); + procParamsPtr = PEB.ProcessParameters; + } + else + { + var PEB = (PEB_32)Marshal.PtrToStructure(pebBytesPtr.AddrOfPinnedObject(), typeof(PEB_32)); + procParamsPtr = PEB.ProcessParameters; + } + + + //read Related bytes + byte[] procParamsBytes = new byte[Marshal.SizeOf(typeof(RTL_USER_PROCESS_PARAMETERS))]; + bool resultProcParamsBytes = ReadProcessMemory(this.process.Handle, + procParamsPtr, + procParamsBytes, + Marshal.SizeOf(typeof(RTL_USER_PROCESS_PARAMETERS)), out _); + + + GCHandle procParamsBytesPtr = GCHandle.Alloc(procParamsBytes, GCHandleType.Pinned); + try + { + RTL_USER_PROCESS_PARAMETERS procParams = (RTL_USER_PROCESS_PARAMETERS)Marshal.PtrToStructure(procParamsBytesPtr.AddrOfPinnedObject(), typeof(RTL_USER_PROCESS_PARAMETERS)); + UNICODE_STRING cmdLineUnicodeString = procParams.CommandLine; + + //read Related bytes + byte[] cmdLineBytes = new byte[cmdLineUnicodeString.Length]; + bool resultCmdLineBytes = ReadProcessMemory(this.process.Handle, + cmdLineUnicodeString.Buffer, + cmdLineBytes, + cmdLineUnicodeString.Length, out _); + + + this.CommandLine = Encoding.Unicode.GetString(cmdLineBytes); + } + finally + { + if (procParamsBytesPtr.IsAllocated) + { + procParamsBytesPtr.Free(); + } + } + } + finally + { + if (pebBytesPtr.IsAllocated) + { + pebBytesPtr.Free(); + } + } + //} + } + + public bool Is32BitProcessOn64BitOs(Process targetProcess) + { + bool isWow64 = false; + if (MethodExistsInDll("kernel32.dll", "IsWow64Process")) + { + + IsWow64Process(targetProcess.Handle, out isWow64); + + + } + return isWow64; + } + public static bool MethodExistsInDll(string moduleName, string methodName) + { + IntPtr moduleHandle = GetModuleHandle(moduleName); + if (moduleHandle == IntPtr.Zero) + { + return false; + } + return GetProcAddress(moduleHandle, methodName) != IntPtr.Zero; + } + + + + } +} diff --git a/segugio/ProcessLaunch.cs b/segugio/ProcessLaunch.cs new file mode 100644 index 0000000..11412a4 --- /dev/null +++ b/segugio/ProcessLaunch.cs @@ -0,0 +1,342 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading; +using System.Windows.Forms; + +namespace segugio +{ + public class ProcessLaunch + { + + [DllImport("kernel32.dll")] + public static extern bool CreateProcess(string lpApplicationName, string lpCommandLine, IntPtr lpProcessAttributes, IntPtr lpThreadAttributes, bool bInheritHandles, uint dwCreationFlags, IntPtr lpEnvironment, string lpCurrentDirectory, [In] ref STARTUPINFOEX lpStartupInfo, ref PROCESS_INFORMATION lpProcessInformation); + [DllImport("kernel32.dll")] + public static extern IntPtr OpenProcess(ProcessAccessFlags processAccess, bool bInheritHandle, int processId); + [DllImport("kernel32.dll")] + public static extern bool UpdateProcThreadAttribute(IntPtr lpAttributeList, uint dwFlags, IntPtr Attribute, IntPtr lpValue, IntPtr cbSize, IntPtr lpPreviousValue, IntPtr lpReturnSize); + [DllImport("kernel32.dll")] + public static extern bool InitializeProcThreadAttributeList(IntPtr lpAttributeList, int dwAttributeCount, int dwFlags, ref IntPtr lpSize); + [DllImport("kernel32.dll")] + public static extern IntPtr QueueUserAPC(IntPtr pfnAPC, IntPtr hThread, IntPtr dwData); + [DllImport("kernel32.dll")] + public static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, Int32 dwSize, UInt32 flAllocationType, UInt32 flProtect); + [DllImport("kernel32.dll")] + public static extern bool VirtualProtectEx(IntPtr handle, IntPtr lpAddress, int dwSize, uint flNewProtect, out uint lpflOldProtect); + [DllImport("kernel32.dll")] + public static extern uint ResumeThread(IntPtr hThread); + [DllImport("kernel32.dll")] + public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, int nSize, ref IntPtr lpNumberOfBytesWritten); + [DllImport("kernel32.dll")] + public static extern IntPtr GetConsoleWindow(); + [DllImport("user32.dll")] + public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow); + + [DllImport("kernel32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + private static extern bool CloseHandle(IntPtr hObject); + + + [DllImport("Shlwapi.dll", CharSet = CharSet.Unicode)] + private static extern uint AssocQueryString(AssocF flags, AssocStr str, string pszAssoc, string pszExtra, [Out] StringBuilder pszOut, ref uint pcchOut); + + private enum AssocStr + { + Command = 1 + } + + [Flags] + private enum AssocF + { + None = 0, + Init_NoRemapCLSID = 0x1, + Init_ByExeName = 0x2, + Open_ByExeName = 0x2, + Init_DefaultToStar = 0x4, + Init_DefaultToFolder = 0x8, + NoUserSettings = 0x10, + NoTruncate = 0x20, + Verify = 0x40, + RemapRunDll = 0x80, + NoFixUps = 0x100, + IgnoreBaseClass = 0x200 + } + + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + public struct STARTUPINFOEX + { + public STARTUPINFO StartupInfo; + public IntPtr lpAttributeList; + } + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + public struct STARTUPINFO + { + public Int32 cb; + public string lpReserved; + public string lpDesktop; + public string lpTitle; + public Int32 dwX; + public Int32 dwY; + public Int32 dwXSize; + public Int32 dwYSize; + public Int32 dwXCountChars; + public Int32 dwYCountChars; + public Int32 dwFillAttribute; + public Int32 dwFlags; + public Int16 wShowWindow; + public Int16 cbReserved2; + public IntPtr lpReserved2; + public IntPtr hStdInput; + public IntPtr hStdOutput; + public IntPtr hStdError; + } + + [StructLayout(LayoutKind.Sequential)] + public struct PROCESS_INFORMATION + { + public IntPtr hProcess; + public IntPtr hThread; + public int dwProcessId; + public int dwThreadId; + } + + [Flags] + public enum ProcessAccessFlags : uint + { + All = 0x001F0FFF, + Terminate = 0x00000001, + CreateThread = 0x00000002, + VirtualMemoryOperation = 0x00000008, + VirtualMemoryRead = 0x00000010, + VirtualMemoryWrite = 0x00000020, + DuplicateHandle = 0x00000040, + CreateProcess = 0x000000080, + SetQuota = 0x00000100, + SetInformation = 0x00000200, + QueryInformation = 0x00000400, + QueryLimitedInformation = 0x00001000, + Synchronize = 0x00100000 + } + + public static class CreationFlags + { + public const uint SUSPENDED = 0x4; + public const uint EXTENDED_STARTUPINFO_PRESENT = 0x00080000; + public const uint CREATE_NO_WINDOW = 0x08000000; + } + + public static readonly UInt32 MEM_COMMIT = 0x1000; + public static readonly UInt32 MEM_RESERVE = 0x2000; + public static readonly UInt32 PAGE_EXECUTE_READ = 0x20; + public static readonly UInt32 PAGE_READWRITE = 0x04; + + public const int PROC_THREAD_ATTRIBUTE_PARENT_PROCESS = 0x00020000; + // public const long PROCESS_CREATION_MITIGATION_POLICY_BLOCK_NON_MICROSOFT_BINARIES_ALWAYS_ON = 0x100000000000; + public const int PROC_THREAD_ATTRIBUTE_MITIGATION_POLICY = 0x00020007; + + public const int SW_HIDE = 0; + public const int SW_SHOW = 5; + + + public uint launchedProcessPid { get; set; } + public uint launchedProcessParentProcessPid { get; set; } + public String launchedProcessParentProcessName { get; set; } + //custom command line set by GUI + public String customCommandLine { get; set; } + + private object lockObject = new object(); + + + + + Gateway gw; + public ProcessLaunch(Gateway gw) + { + this.gw = gw; + } + + + String fileToOpen; + String additionalArguments; + + + public void AddStartupInfo(string processToOpen, string additionalArguments) + { + lock (lockObject) + { + this.fileToOpen = processToOpen; + this.additionalArguments = additionalArguments; + } + } + + + public void LaunchProcess() + { + + try + { + + gw.startThreadProcessLaunch.WaitOne(); + + string extension = Path.GetExtension(fileToOpen); + string programPathTemplate = GetDefaultProgramPath(extension); + string cleanedCommand; + if(programPathTemplate!=null) + { + + if (programPathTemplate.Contains("%1")) + { + string commandToExecute = programPathTemplate.Replace("%1", fileToOpen).Replace(" %*", additionalArguments); + cleanedCommand = commandToExecute.Replace("\"", " ").Trim(); + } + else + { + + cleanedCommand = (programPathTemplate + " " + fileToOpen).Replace("\"", " ").Trim(); + } + + + //check for custom commandline + if (customCommandLine != null) + { + cleanedCommand = customCommandLine; + cleanedCommand = cleanedCommand.Replace("%FILENAME%", fileToOpen); + cleanedCommand = "cmd.exe /c " + cleanedCommand; + } + + + //if program for opening file exists + if (cleanedCommand.Length > 0) + { + + uint? parentProc = launchedProcessParentProcessPid; + + if (parentProc.HasValue) + { + + + Debug.WriteLine("tento lo spoof"); + + bool result = pidSpoof((int)parentProc, cleanedCommand); + + + if (result) + { + + //Debug.WriteLine($"PROCESS LAUNCHED {launchedProcessPid}"); + + // Signal Thread Process Scan to start alternating with Thread Process Monitor + gw.startThreadProcessScan.Set(); + + } + else + { + MessageBox.Show($"Unable to spawn process using {launchedProcessParentProcessName} ({launchedProcessParentProcessPid}) as parent process.", + "Failed to spawn process", MessageBoxButtons.OK, MessageBoxIcon.Error); + + Environment.Exit(0); + } + } + else + { + Debug.WriteLine("failed to spawn"); + } + + } + + + } + + + + } + catch (Exception ex) + { + System.Diagnostics.Debug.WriteLine("exception:" + ex); + + } + + + } + + + + public string GetDefaultProgramPath(string extension) + { + uint pcchOut = 0; + AssocQueryString(AssocF.None, AssocStr.Command, extension, null, null, ref pcchOut); + + if (pcchOut == 0) + { + return null; + } + + StringBuilder pszOut = new StringBuilder((int)pcchOut); + AssocQueryString(AssocF.None, AssocStr.Command, extension, null, pszOut, ref pcchOut); + + return pszOut.ToString(); + } + + + + + public bool pidSpoof(int parentProc, string commandLine) + { + bool result = false; + STARTUPINFOEX siex = new STARTUPINFOEX(); + PROCESS_INFORMATION pi = new PROCESS_INFORMATION(); + IntPtr procHandle = IntPtr.Zero, lpValueProc = IntPtr.Zero; + + try + { + procHandle = OpenProcess(ProcessAccessFlags.CreateProcess, false, parentProc); + if (procHandle == IntPtr.Zero) throw new Exception("Failed to open parent process"); + + IntPtr lpSize = IntPtr.Zero; + InitializeProcThreadAttributeList(IntPtr.Zero, 1, 0, ref lpSize); + if (lpSize == IntPtr.Zero) throw new Exception("Failed to initialize proc thread attribute list"); + + siex.lpAttributeList = Marshal.AllocHGlobal(lpSize); + if (!InitializeProcThreadAttributeList(siex.lpAttributeList, 1, 0, ref lpSize)) + throw new Exception("Failed to initialize proc thread attribute list second time"); + + lpValueProc = Marshal.AllocHGlobal(IntPtr.Size); + Marshal.WriteIntPtr(lpValueProc, procHandle); + if (!UpdateProcThreadAttribute(siex.lpAttributeList, 0, (IntPtr)PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, lpValueProc, (IntPtr)IntPtr.Size, IntPtr.Zero, IntPtr.Zero)) + throw new Exception("Failed to update proc thread attribute for parent process"); + + if (!CreateProcess(null, commandLine, IntPtr.Zero, IntPtr.Zero, false, CreationFlags.SUSPENDED | CreationFlags.EXTENDED_STARTUPINFO_PRESENT, IntPtr.Zero, null, ref siex, ref pi)) + throw new Exception("Failed to create process"); + + // Success + launchedProcessPid = (uint)pi.dwProcessId; + ResumeThread(pi.hThread); + System.Diagnostics.Debug.WriteLine($"Process {pi.dwProcessId} resumed and spoof completed"); + result = true; + } + catch (Exception ex) + { + System.Diagnostics.Debug.WriteLine($"Error: {ex.Message}"); + } + finally + { + if (siex.lpAttributeList != IntPtr.Zero) Marshal.FreeHGlobal(siex.lpAttributeList); + if (lpValueProc != IntPtr.Zero) Marshal.FreeHGlobal(lpValueProc); + if (pi.hProcess != IntPtr.Zero) CloseHandle(pi.hProcess); + if (pi.hThread != IntPtr.Zero) CloseHandle(pi.hThread); + if (procHandle != IntPtr.Zero) CloseHandle(procHandle); + } + + return result; + } + + + + + } +} diff --git a/segugio/ProcessListManager.cs b/segugio/ProcessListManager.cs new file mode 100644 index 0000000..c513e08 --- /dev/null +++ b/segugio/ProcessListManager.cs @@ -0,0 +1,601 @@ +using System; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace segugio +{ + public class ProcessListManager + { + // + public int numberRootProcesses = 0; + public int numberTerminatedProcesses = 0; + public int numberCreatedProcesses = 0; + + //contains all existing and existed processes + public ConcurrentDictionary mainProcessList; + + //process being part of SCAN analysis + public ConcurrentDictionary trackingProcessesList; + + + + Gateway gw; + + String messageToLog { get; set; } //handle to new message to log + + public volatile Boolean startingPidHasNotified = false; + + public ProcessListManager(Gateway gw) + { + this.gw = gw; + + mainProcessList = new ConcurrentDictionary(); + trackingProcessesList = new ConcurrentDictionary(); + + + + } + + //method for updating the list of only running processes + public Dictionary UpdateAndGetOnlyRunningProcessList() + { + //contains only running processes + Dictionary onlyRunningProcessList = new Dictionary(); ; + + //clear list + onlyRunningProcessList.Clear(); + + //for each listed process + foreach (var process in gw.plm.mainProcessList.Values) + { + //if process is running and is not the current process and has a valid handle + if (process.isRunning == process.IsProcessRunning(process.processID) + && !(process.ProcessName.Equals(gw.applicationName)) ) + { + //add to only running process + onlyRunningProcessList.Add(process.processID, process.ProcessName); + } + + } + + return onlyRunningProcessList; + } + + + //This method is used to keep track of all existing and past processes + public void AddRunningProcess(uint pid, ProcessInfo process) + { + + if (!(mainProcessList.ContainsKey(pid)) ) + { + + try + { + Process proc = Process.GetProcessById((int)pid, process.machineName); + process.startingProcessTime = proc.StartTime; + } + catch (Exception ex) + { + process.startingProcessTime = null; + } + + mainProcessList.TryAdd(pid, process); + + } + + + } + + + + + //method for finding changes in traced processes + public void updateTrackedProcessProperties() + { + + ConcurrentDictionary newProcesses = new ConcurrentDictionary(); + + foreach (var process in gw.plm.trackingProcessesList.Values) + { + //if process is running no more + if (process.isRunning != process.IsProcessRunning(process.processID)) + { + // + process.isRunning = process.IsProcessRunning(process.processID); + + //send update to GUI - logview + messageToLog = ($"process terminated: {process.ProcessName} ({process.processID})"); + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.NewLogMessage, + LogMessage = messageToLog + }); + + //send update to GUI - treeview + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.TerminatedProcesses, + LogMessage = messageToLog + }); + + + } + + //if process hasn't related treenode, it's a new process + if (process.treenode == null) + { + //invia l'aggiornamento alla GUI per aggiornare il LogView + messageToLog = ($"process added to tracking: {process.ProcessName} ({process.processID})"); + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.NewLogMessage, + LogMessage = messageToLog + }); + + + //add to temporary list + newProcesses.TryAdd(process.processID, process); + + + } + } + + //if new processes are present + if(newProcesses.Count>0) + { + //send update to GUI (logview) + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.CreatedProcesses, + NewProcessesList = newProcesses + }); + } + + } + + + //metodo usato dalla GUI per estrarre tutte le occorrenze dei TAG + public string getAllYarasDetected() + { + HashSet filteredYaras = new HashSet(); + + foreach (var process in trackingProcessesList.Values) + { + foreach (var yara in process.matchedYaraRules ) + { + filteredYaras.Add(yara); + } + + } + StringBuilder yaraTagList = new StringBuilder(); + //trasformo filteredYaras in stringa + foreach (Yara yara in filteredYaras) + { + if (yaraTagList.Length > 0) + { + yaraTagList.Append(", "); + } + yaraTagList.Append(yara.Name); + } + + return yaraTagList.ToString(); + } + + + + + //questo metodo serve per aggiungere i processi che sono in corso di Tracking + public void AddToTrackedProcess(uint pid, ProcessInfoTracked process) + { + //if i'm tracking this process, (Segugio) skip it + if (pid.Equals(gw.thisCurrentProcessPid)) + { + + } + else + { + //se il processo non è ancora presente nella lista + if (!(trackingProcessesList.ContainsKey(pid))) + { + + + + //CASO DEL PID INIZIALE + if (startingPidHasNotified && pid.Equals(gw.pl.launchedProcessPid)) + { + process.isStartingProcess = true; + + //add pid to trackedlist + //aggiungi il parent alla lista dei processi creati + if (mainProcessList.TryGetValue(process.ParentPID, out ProcessInfo parentProcess)) + { + ProcessInfoTracked trackedParentProcess = new ProcessInfoTracked( + parentProcess.ParentPID, + parentProcess.ProcessName, + parentProcess.processID); + + AddToTrackedProcess(process.ParentPID, trackedParentProcess); + + } + + //reset startingPidHasNotified + this.startingPidHasNotified = false; + } + + + //add more properties solo per i processi che dovranno essere ispezionati + //in questo modo la lista dei processi è più snella + try + { + process.process = Process.GetProcessById((int)pid, process.machineName); + process.isRunning = true; + } + catch (Exception ex) + { + //caso in cui il processo non è in esecuzione + process.isRunning = false; + } + + if (process.isRunning) + { + //check permissions + process.CanAttachToProcess(pid); + + if (process.canBeAttached) + { + System.Diagnostics.Debug.WriteLine(" asking commandline for " + process.ProcessName); + process.GetCommandLine(); + + process.getProcessIcon(); + } + + + + //se il processo parent non esiste nella lista di processi monitorati + if (!mainProcessList.ContainsKey(process.ParentPID)) + { + //allora è un root + process.isRootProcess = true; + } + else + { + //se esiste controlla che non sia terminato + if (process.isParentPidRunning) + { + // se è in esecuzione allora non è un root process + process.isRootProcess = false; + + ////aggiungi il processo + //AddToTrackedProcess(process.ParentPID, new ProcessInfoTracked( + // mainProcessList[process.ParentPID].ParentPID, + // mainProcessList[process.ParentPID].ProcessName, + // mainProcessList[process.ParentPID].processID)); + + } + else + { + //aggiungilo come root process + process.isRootProcess = true; + } + } + + //process.isRunning = true; + + //prepara le strutture per eventuali detection + process.matchedYaraRules = new HashSet(); + process.dictMalwareConfiguration = new Dictionary(); + + + trackingProcessesList.TryAdd(pid, process); + } + else + { + //se il processo non sta runnando + //metti un'icona vuota + process.getDefaultIcon(); + + //metti una commandline vuota + process.CommandLine = ""; + + //aggiungilo alla lista dei processi tracciati + trackingProcessesList.TryAdd(pid, process); + + + } + + + + } + else + { + //L'aggiornamento della proprietà dei processi deve avvenire dalla classe ProcessScan + } + } + + + } + + + //public void addAttributionToProcess(uint processID, Yara matchYara) + //{ + // if(TrackingProcessesList.ContainsKey(processID)) + // { + // TrackingProcessesList[processID].addYaraDetection(matchYara); + // } + //} + + //public void addConfigurationToProcess(uint processID, Yara matchYara, string configuration) + //{ + // if (TrackingProcessesList.ContainsKey(processID)) + // { + // TrackingProcessesList[processID].addMalwareConfiguration(matchYara.Name, configuration); + // } + //} + + + + + + + //Questo metodo avvia la ricerca e restituisce tutti i figli di un dato processo + //tutti i figli li mette in un dictionary TrackingProcessesList che è gestito da ProcessListManager + public void searchAllNewProcessesesByLaunchedProcess(uint startingPID) + { + //aggiunge il processo appena creato + //ottengo l'istanza del processo creato + if (mainProcessList.TryGetValue(startingPID, out ProcessInfo startingProcess)) + { + AddToTrackedProcess(startingPID, new ProcessInfoTracked( + startingProcess.ParentPID, + startingProcess.ProcessName, + startingProcess.processID)); + + findChildRecursiveOfStartingProcess(startingPID); + } + + //adesso controlla tutti i processi creati a partire dal parent del processo creato (explorer.exe) + //a partire dall'iniizo della scansione + //FindChildrenRecursive(gw.pl.parentPidLaunchedProcess, gw.ps.scanningStartTime); + + FindAllNewProcessesAfter(gw.ps.scanningStartTime); + + } + private void FindAllNewProcessesAfter(DateTime startTime) + { + foreach (var kvp in mainProcessList.Values) + { + + if(kvp.startingProcessTime.HasValue && kvp.startingProcessTime.Value > startTime) + { + AddToTrackedProcess(kvp.processID, new ProcessInfoTracked( + kvp.ParentPID, + kvp.ProcessName, + kvp.processID)); + + } + + } + } + + + + + private void FindChildrenRecursive(uint parentPid, DateTime startTime) + { + foreach (var kvp in mainProcessList.Values) + { + + if (kvp.ParentPID == parentPid && kvp.startingProcessTime.HasValue && kvp.startingProcessTime.Value > startTime) + { + AddToTrackedProcess(kvp.processID, new ProcessInfoTracked( + kvp.ParentPID, + kvp.ProcessName, + kvp.processID)); + FindChildrenRecursive(kvp.processID, startTime); // Ricorsivamente trova i figli + } + + } + } + + //Metodo ricorsivo privato per individuare solo i nodi figli del processo di partenza + private void findChildRecursiveOfStartingProcess(uint parentPid) + { + foreach (var process in gw.plm.mainProcessList.Values) + { + //se l'attuale processo è figlio del PID specificato allora aggiungilo + if (process.ParentPID.Equals(parentPid)) + { + // Aggiungi questo processo figlio se non è già presente + if (!trackingProcessesList.ContainsKey(process.processID)) + { + AddToTrackedProcess(process.processID, new ProcessInfoTracked( + process.ParentPID, + process.ProcessName, + process.processID)); + + // Ricorsivamente trova e aggiungi i discendenti di questo processo figlio + findChildRecursiveOfStartingProcess(process.processID); + } + } + } + } + + + + + + + //get Pid of a process + public uint? FindPidForProcessName(string processName) + { + foreach (var item in mainProcessList) + { + if (item.Value.ProcessName.Equals(processName, StringComparison.OrdinalIgnoreCase)) + { + return item.Key; // Restituisce il PID quando trova una corrispondenza + } + } + + return null; // Restituisce null se non trova corrispondenze + } + + + + + + public ProcessInfo getProcessByPID(uint pid) + { + if(mainProcessList.TryGetValue((uint)pid, out ProcessInfo pInfo) ) + { + return pInfo; + } + else + { + return null; + } + } + + + //public TreeNode createNewTreeNode(ProcessInfo newProcess) + //{ + // TreeNode newTreenode = new TreeNode($"{newProcess.ProcessName} (PID: {newProcess.processID}) - " + (newProcess.isRunning ? "active" : "terminated")); + + // if (mainProcessList.ContainsKey(newProcess.processID)) + // { + // // Modifica solo alcune proprietà dell'oggetto ProcessInfo esistente + // mainProcessList[newProcess.processID].treenode = newTreenode; + // } + + + // return newTreenode; + //} + + //public string updateTreeNode(ProcessInfo processInfo) + //{ + // string value = $"{processInfo.ProcessName} (PID: {processInfo.processID}) - " + (processInfo.isRunning ? "active" : "terminated"); + // return value; + //} + + //// Restituisce tutti gli oggetti ProcessInfo con un certo ParentPID da una lista currentList + public Dictionary getChildProcessesFromPID(uint parentPID) + { + Dictionary result = new Dictionary(); + + foreach (var process in trackingProcessesList) + { + if (process.Value.ParentPID == parentPID) + { + result.Add(process.Key, process.Value); + } + } + + return result; + } + + + // Restituisce tutti gli oggetti ProcessInfo che non hanno un pid esistente + //public void getRootProcesses() + //{ + // foreach (var item in mainProcessList) + // { + // // Controlla se il ParentPID di questo processo esiste come processID in dictProcPid + // if (!mainProcessList.ContainsKey(item.Value.ParentPID) || item.Value.ParentPID == 0) + // { + // if (!(dictRootPIDs.ContainsKey(item.Key))) + // { + // // Se non esiste, il processo è radice + // dictRootPIDs.TryAdd(item.Key, item.Value); + // } + + // } + // } + + // //update counter + // this.numberRootProcesses = dictRootPIDs.Count; + + //} + + + ////method for avoiding interference with processes that are spawned for + ////scanning purposes, like yara or python + //public List GetAllDescendantPIDs(uint parentPid) + //{ + // System.Diagnostics.Debug.WriteLine($"{numberRootProcesses} processes without parent "); + + // List descendantPIDs = new List(); + + // // Cerca tutti i processi che hanno parentPid come genitore + // foreach (var process in dictProcPid) + // { + // if (process.Value.ParentPID == parentPid) + // { + // // Aggiunge il PID del processo figlio alla lista + // descendantPIDs.Add(process.Key); + + // process.Value.isDescendantSegugio = true; + + // // Ricorsivamente trova e aggiunge tutti i discendenti del processo figlio + // descendantPIDs.AddRange(GetAllDescendantPIDs(process.Key)); + // } + // } + + // return descendantPIDs; + //} + + + //public void filterDescendantsOfSegugio() + //{ + // List childPIDofSegugio = GetAllDescendantPIDs((uint)thisPid); + + // System.Diagnostics.Debug.WriteLine($"processi da rimuovere :" + childPIDofSegugio.Count + 1); + + + // foreach (var child in childPIDofSegugio) + // { + // dictProcPid.TryRemove(child, out ProcessInfo removedProcess); + // dictCurrentProcPid.Remove(child); + // } + + // //rimuove segugio.exe + // dictProcPid.TryRemove((uint)thisPid, out ProcessInfo removed); + // dictCurrentProcPid.Remove((uint)thisPid); + //} + + //public void getTerminatedProcesses() + //{ + // foreach (var item in dictProcPid) + // { + // if (!item.Value.isRunning) + // { + // if (!dictNewTerminatedProcesses.ContainsKey(item.Key)) + // { + // dictRootPIDs.TryAdd(item.Key, item.Value); + // } + // elsec + // { + // //update the corresponding value to key + // dictRootPIDs[item.Key] = item.Value; + // } + // } + // } + //} + + + + public void AddTreeNodeToProcess(uint pid, ProcessTreeNode node) + { + if(this.trackingProcessesList.ContainsKey(pid) ) + { + this.trackingProcessesList[pid].treenode = node; + } + + } + + + } +} diff --git a/segugio/ProcessMonitor.cs b/segugio/ProcessMonitor.cs new file mode 100644 index 0000000..f8fe7bc --- /dev/null +++ b/segugio/ProcessMonitor.cs @@ -0,0 +1,200 @@ +using System; +using System.Diagnostics; +using System.IO; +using System.Runtime.InteropServices; +using System.Threading; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace segugio +{ + public class ProcessMonitor + { + + [StructLayout(LayoutKind.Sequential)] + public struct MEMORY_BASIC_INFORMATION + { + public IntPtr BaseAddress; + public IntPtr AllocationBase; + public uint AllocationProtect; + public IntPtr RegionSize; + public uint State; + public uint Protect; + public uint Type; + } + + [StructLayout(LayoutKind.Sequential)] + public struct SYSTEM_INFO + { + public ushort processorArchitecture; + ushort reserved; + public uint pageSize; + public IntPtr minimumApplicationAddress; + public IntPtr maximumApplicationAddress; + public IntPtr activeProcessorMask; + public uint numberOfProcessors; + public uint processorType; + public uint allocationGranularity; + public ushort processorLevel; + public ushort processorRevision; + } + + + [Flags] + private enum SnapshotFlags : uint + { + Process = 0x00000002, + Thread = 0x00000004 + } + + [Flags] + private enum ProcessAccessFlags : uint + { + All = 0x001F0FFF, + Terminate = 0x00000001, + CreateThread = 0x00000002, + VirtualMemoryOperation = 0x00000008, + VirtualMemoryRead = 0x00000010, + VirtualMemoryWrite = 0x00000020, + DuplicateHandle = 0x00000040, + CreateProcess = 0x000000080, + SetQuota = 0x00000100, + SetInformation = 0x00000200, + QueryInformation = 0x00000400, + QueryLimitedInformation = 0x00001000, + Synchronize = 0x00100000 + } + + [StructLayout(LayoutKind.Sequential)] + public struct PROCESSENTRY32 + { + public uint dwSize; + public uint cntUsage; + public uint th32ProcessID; + public IntPtr th32DefaultHeapID; + public uint th32ModuleID; + public uint cntThreads; + public uint th32ParentProcessID; + public int pcPriClassBase; + public uint dwFlags; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)] + public string szExeFile; + } + + private enum ThreadAccess : int + { + SUSPEND_RESUME = 0x0002 //THREAD_SUSPEND_RESUME + } + + [DllImport("kernel32.dll", SetLastError = true)] + public static extern IntPtr CreateToolhelp32Snapshot(uint dwFlags, uint th32ProcessID); + + [DllImport("kernel32.dll")] + public static extern bool Process32First(IntPtr hSnapshot, ref PROCESSENTRY32 lppe); + + [DllImport("kernel32.dll")] + public static extern bool Process32Next(IntPtr hSnapshot, ref PROCESSENTRY32 lppe); + + [DllImport("kernel32.dll")] + private static extern bool CloseHandle(IntPtr hObject); + + + private Gateway gw; + public Boolean isRunning = true; + + public Boolean firstIteration = true; + + //default value 100 + public int monitorInterval =100; + + + public ProcessMonitor(Gateway gw) + { + this.gw = gw; + + //get settings for Monitor time interval + String monitorIntervalOptionString = gw.settings.GetSetting("MonitorInterval"); + if(gw.ut.IsStringNumeric(monitorIntervalOptionString)) + { + monitorInterval = int.Parse(monitorIntervalOptionString); + } + else + { + MessageBox.Show($"Unable to read MonitorInterval option from {gw.settings.settingFileName}). Check the value out!", + "Failed to read settingFileName option", MessageBoxButtons.OK, MessageBoxIcon.Error); + + Environment.Exit(0); + } + + } + + //main process monitor Thread + public void ProcessMonitoringLoop() + { + try + { + while (isRunning) + { + gw.pauseEvent.Wait(); + //System.Diagnostics.Debug.WriteLine("New Thread updating processes"); + UpdateProcessList(); + + //if the scan is not running + if(gw.ps.scanHasStarted==false && firstIteration== true) + { + //send the signal to the GUI + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.Idle, + }); + + //reset firstIteration + firstIteration = false; + } + + // Codice di monitoraggio del processo + if (!isRunning) + { + break; + } + + Thread.Sleep(monitorInterval); // Sleep for a short time or adjust based on your requirement + } + } + catch(Exception ex) + { + System.Diagnostics.Debug.WriteLine("exception:" +ex); + + } + + } + + private void UpdateProcessList() + { + { + IntPtr snapshot = CreateToolhelp32Snapshot(0x00000002, 0); // TH32CS_SNAPPROCESS + if (snapshot == IntPtr.Zero) + return; + + PROCESSENTRY32 processEntry = new PROCESSENTRY32 { dwSize = (uint)Marshal.SizeOf(typeof(PROCESSENTRY32)) }; + if (Process32First(snapshot, ref processEntry)) + { + do + { + ProcessInfo newProcess = new ProcessInfo( + processEntry.th32ParentProcessID, // parent PID + processEntry.szExeFile, // Process name + processEntry.th32ProcessID); // process ID + + // Simply add to a light list + gw.plm.AddRunningProcess(processEntry.th32ProcessID, newProcess); + } + while (Process32Next(snapshot, ref processEntry)); + } + + CloseHandle(snapshot); + } + } + + } +} \ No newline at end of file diff --git a/segugio/ProcessScan.cs b/segugio/ProcessScan.cs new file mode 100644 index 0000000..0a40eda --- /dev/null +++ b/segugio/ProcessScan.cs @@ -0,0 +1,677 @@ +using System; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace segugio +{ + + + + + public class ProcessScan + { + [DllImport("kernel32.dll")] + private static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [Out] byte[] lpBuffer, IntPtr dwSize, out IntPtr lpNumberOfBytesRead); + + [DllImport("kernel32.dll")] + private static extern IntPtr OpenProcess(ProcessAccessFlags dwDesiredAccess, bool bInheritHandle, int dwProcessId); + + [DllImport("kernel32.dll")] + private static extern bool CloseHandle(IntPtr hObject); + + [DllImport("kernel32.dll")] + private static extern int VirtualQueryEx(IntPtr hProcess, IntPtr lpAddress, out MEMORY_BASIC_INFORMATION lpBuffer, uint dwLength); + + [DllImport("kernel32.dll")] + public static extern void GetNativeSystemInfo(out SYSTEM_INFO lpSystemInfo); + + [DllImport("kernel32.dll")] + private static extern IntPtr OpenThread(ThreadAccess dwDesiredAccess, bool bInheritHandle, uint dwThreadId); + + [DllImport("kernel32.dll")] + private static extern uint SuspendThread(IntPtr hThread); + + [DllImport("kernel32.dll")] + private static extern int ResumeThread(IntPtr hThread); + + [StructLayout(LayoutKind.Sequential)] + public struct MEMORY_BASIC_INFORMATION + { + public IntPtr BaseAddress; + public IntPtr AllocationBase; + public uint AllocationProtect; + public IntPtr RegionSize; // Usa IntPtr per gestire correttamente le dimensioni sia su 32 che su 64 bit + public uint State; + public uint Protect; + public uint Type; + } + + + + [StructLayout(LayoutKind.Sequential)] + public struct SYSTEM_INFO + { + public ushort processorArchitecture; + ushort reserved; + public uint pageSize; + public IntPtr minimumApplicationAddress; + public IntPtr maximumApplicationAddress; + public IntPtr activeProcessorMask; + public uint numberOfProcessors; + public uint processorType; + public uint allocationGranularity; + public ushort processorLevel; + public ushort processorRevision; + } + + + [Flags] + private enum SnapshotFlags : uint + { + Process = 0x00000002, + Thread = 0x00000004 + } + + [Flags] + private enum ProcessAccessFlags : uint + { + All = 0x001F0FFF, + Terminate = 0x00000001, + CreateThread = 0x00000002, + VirtualMemoryOperation = 0x00000008, + VirtualMemoryRead = 0x00000010, + VirtualMemoryWrite = 0x00000020, + DuplicateHandle = 0x00000040, + CreateProcess = 0x000000080, + SetQuota = 0x00000100, + SetInformation = 0x00000200, + QueryInformation = 0x00000400, + QueryLimitedInformation = 0x00001000, + Synchronize = 0x00100000 + } + + private enum ThreadAccess : int + { + SUSPEND_RESUME = 0x0002 //THREAD_SUSPEND_RESUME + } + + + + + + string dumpFolder { get; set; } // path for saving dumps + + string messageToLog { get; set; } + + public DateTime scanningStartTime { get; set; } + public volatile Boolean isRunning = true; + public volatile Boolean scanHasStarted = false; + public volatile Boolean firstIteration = true; + + + + Gateway gw; + + + private object lockObject = new object(); + private ConcurrentDictionary suspendedProcesses = new ConcurrentDictionary(); + + //default value 100 + public int scanInterval = 100; + + public bool isEnabledParentScan; + + public ProcessScan(Gateway gw) + { + this.gw = gw; + dumpFolder = gw.settings.GetSetting("DumpFolder"); // path for saving dumps + isEnabledParentScan = gw.settings.GetBooleanSetting("isEnabledParentScan"); // enabled parent process scan + gw.ut.CheckPaths("directory", dumpFolder); + + firstIteration = true; + + //get settings for ScanInterval + String scanIntervalOptionString = gw.settings.GetSetting("ScanInterval"); + if (gw.ut.IsStringNumeric(scanIntervalOptionString)) + { + scanInterval = int.Parse(scanIntervalOptionString); + } + else + { + MessageBox.Show($"Unable to read ScanInterval option from {gw.settings.settingFileName}). Check the value out!", + "Failed to read ScanInterval option", MessageBoxButtons.OK, MessageBoxIcon.Error); + + Environment.Exit(0); + } + } + + + public void ScanProcess() + { + gw.startThreadProcessScan.WaitOne(); + + + if(isRunning) + { + //update Status + scanHasStarted = true; + //flag per aggiornamento iniziale del processo genitore del processo lanciato + gw.plm.startingPidHasNotified = true; + + scanningStartTime = DateTime.Now; + //update logview + messageToLog = ($"process scan started at: {scanningStartTime}"); + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.NewLogMessage, + LogMessage = messageToLog + }); + } + + + + while (isRunning) + { + gw.pauseEvent.Wait(); + + + System.Diagnostics.Debug.WriteLine("New Thread for scanning processes"); + + + //identify processes created from the initial pid + // find processes created from the parent process of the launched process + //after the launched process has been executed + gw.plm.searchAllNewProcessesesByLaunchedProcess(gw.pl.launchedProcessParentProcessPid); + + + //if I am ready to perform the first iteration of creating the process list and TrackingProcessesList has at least one element + if (firstIteration && gw.plm.trackingProcessesList.Count > 0) + { + //update gui + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.ProcessScanStarted + }); + + //switch off flag + firstIteration = false; + } + else + { + //if the process list has been created, then I can modify it + if (gw.mainForm.firstProcessTreeCreationIsMade) + { + //if there are no changes in progress to the process list + if (!gw.mainForm.processTreeIsUpdating) + { + + gw.plm.updateTrackedProcessProperties(); + + } + + } + + } + + + + + //There is a part that scans the selected processes + ProcessCheck(); + + // Process monitoring code + if (!isRunning) + { + break; + } + + //delay + Thread.Sleep(scanInterval); + } + } + + + + + + + ////search for all processes that are child of starting process + public void ProcessCheck() + { + try + { + Parallel.ForEach(gw.plm.trackingProcessesList.Values, currentProcess => + { + if (currentProcess.isRunning) + { + if (currentProcess.canBeAttached) + { + + System.Diagnostics.Debug.WriteLine("Running YARA against: " + currentProcess.ProcessName + ", " + currentProcess.processID); + lock (lockObject) + { + // Sospendi il processo se non è il padre del processo lanciato + if (isEnabledParentScan) + { + + SuspendProcess(currentProcess); + } + } + + var (isMatching, matchedYaraRules) = gw.yaras.RunYaraScan((int)currentProcess.processID); + + if (isMatching) + { + foreach (var matchedYara in matchedYaraRules) + { + if (!currentProcess.isProcessMatchedByYara(matchedYara)) + { + currentProcess.addYaraDetection(matchedYara); + + string message = ($"process {currentProcess.ProcessName} ({currentProcess.processID}), got detection by YARA rule {matchedYara.Name} !"); + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.NewLogMessage, + LogMessage = message + }); + + //invia l'aggiornamento alla GUI per aggiornare il treeview + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.UpdatedProcess, + LogMessage = messageToLog + }); + } + + if (!currentProcess.hasProcessGotConfigExtraction(matchedYara)) + { + if (isEnabledParentScan) + { + tryProcessConfigExtration(currentProcess, matchedYara); + } + } + } + } + lock (lockObject) + { + // Riprendi il processo + if (isEnabledParentScan) + { + + ResumeProcess(currentProcess); + } + } + + } + } + }); + } + catch (Exception ex) + { + System.Diagnostics.Debug.WriteLine("Errore: " + ex.Message); + } + } + + + + //public void ProcessCheck() + //{ + // try + // { + // foreach (var currentProcess in gw.plm.trackingProcessesList.Values) + // { + // //se il processo è running e se non è il padre del processo lanciato + // if (currentProcess.isRunning ) + // { + // //se ho l'handle al processo + // if (currentProcess.canBeAttached) + // { + // System.Diagnostics.Debug.WriteLine(" Running yara against:" + currentProcess.ProcessName + ", " + currentProcess.processID); + + // //se il processo attuale non è il padre del processo lanciato + // if (currentProcess.processID != gw.pl.parentPidLaunchedProcess) + // { + // //sospendi il processo + // SuspendProcess(currentProcess); + // } + + // var (isMatching, matchedYaraRules) = gw.yaras.RunYaraScan((int)currentProcess.processID); + // //matchedYaraRule è un HAshset + + // //se trovo un match con le regole yara + // if (isMatching) + // { + // //for each matched yara, add attribution + // foreach (var matchedYara in matchedYaraRules) + // { + + // //se NON ho già il matching di una precisa yara per quel processo + // if (!currentProcess.isProcessMatchedByYara(matchedYara)) + // { + // //allora non fare nulla perchè è stato già segnalato + // //creo l'attribuzione per il processo + // currentProcess.addYaraDetection(matchedYara); + // //gw.plm.addAttributionToProcess(currentProcess.processID, matchedYara); + + // //segnalo l'attribuzione per il processo alla Gui + // string message = ($"process {currentProcess.ProcessName} ({currentProcess.processID}), got detection by YARA rule {matchedYara.Name} !"); + // gw.mainForm.progress.Report(new UpdateSignal + // { + // Action = UpdateSignal.UpdateAction.NewLogMessage, + // LogMessage = message + // }); + + // //invia l'aggiornamento alla GUI per aggiornare il treeview + // gw.mainForm.progress.Report(new UpdateSignal + // { + // Action = UpdateSignal.UpdateAction.UpdatedProcess, + // LogMessage = messageToLog + // }); + + // } + + + // //if current process has NOT yet a config extraction for that yara rule + // if (!currentProcess.hasProcessGotConfigExtraction(matchedYara)) + // { + // //se il processo attuale non è il padre del processo lanciato + // if (currentProcess.processID != gw.pl.parentPidLaunchedProcess) + // { + // //procedi all'estrazione di una eventuale configurazione per quella precisa regola yara + // tryProcessConfigExtration(currentProcess, matchedYara); + // } + + // } + + // } + // } + + // //se il processo attuale non è il padre del processo lanciato + // if (currentProcess.processID != gw.pl.parentPidLaunchedProcess) + // { + // //riprendi il processo + // ResumeProcess(currentProcess); + // } + + // } + + // } + + // } + // } + // catch (Exception ex) + // { + // System.Diagnostics.Debug.WriteLine("Errore: " + ex.Message); + // } + + + //} + + + //l'istanza di PRocessInfo è già dentro la lista dei processi tracciati + private void tryProcessConfigExtration(ProcessInfoTracked currentProcess, Yara matchedYara) + { + + //if exists a script file for the matched Yara Rule + if (gw.mlwConfigEx.existsConfigExtractorByRule(matchedYara.Name)) + { + + //segnala + String message = ($"Starting dumping process {currentProcess.ProcessName} ({currentProcess.processID}) in {dumpFolder}"); + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.NewLogMessage, + LogMessage = message + }); + + + //start dumping + DumpProcessMemory(currentProcess); + + message = ($"Process {currentProcess.ProcessName} ({currentProcess.processID}) dumped in {dumpFolder}. Now trying to extract configuration!"); + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.NewLogMessage, + LogMessage = message + }); + + //allora procedi con l'estrazione + string pythonScriptPath = gw.mlwConfigEx.getConfigExtractorPathByRule(matchedYara.Name); + + //enumerate all dumps in folder + string[] dmpFiles = Directory.GetFiles(dumpFolder, "*.dmp", SearchOption.AllDirectories); + + // Controlla se sono stati trovati dei file + if (dmpFiles.Length > 0) + { + string configOutput = ""; + + foreach (string file in dmpFiles) + { + System.Diagnostics.Debug.WriteLine("running config extractor for " + matchedYara.Name + " on file " + file); + + var (configFound, result) = gw.mlwConfigEx.pyExecConfScript(pythonScriptPath, file); + + if (configFound) + { + // add all results in one string + if (result.Length > 0) + { + configOutput = configOutput + result + "\r\n"; + } + } + + } + + //al termine dell'estrazione di tutti i dump di memoria relativamente ad un processo + + if (configOutput.Length > 0) + { + //creo la configurazione estratta per il processo + //gw.plm.addConfigurationToProcess(currentProcess.processID, matchedYara, configOutput); + currentProcess.addMalwareConfiguration(matchedYara, configOutput); + + + string messageLog = ($"process {currentProcess.ProcessName} ({currentProcess.processID}), got config extraction for {matchedYara.Name} !"); + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.NewLogMessage, + LogMessage = messageLog + }); + + //invia l'aggiornamento alla GUI per aggiornare il treeview + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.UpdatedProcess, + LogMessage = messageToLog + }); + + //System.Diagnostics.Debug.WriteLine(messageLog); + } + else + { + //vuol dire che esiste il config extractor ma che il dump non contiente informazioni succose + } + + } + } + else + { + string messageLog = ($"skipping process {currentProcess.ProcessName} ({currentProcess.processID}), because no config extractor for {matchedYara.Name} !"); + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.NewLogMessage, + LogMessage = messageLog + }); + System.Diagnostics.Debug.WriteLine(messageLog); + } + + + + } + + + + private void PrepareDumpFolder(ProcessInfo currentProcess) + { + dumpFolder = Path.Combine(gw.desktopPath, $"{currentProcess.ProcessName}_{currentProcess.processID}"); + if (!Directory.Exists(dumpFolder)) + { + Directory.CreateDirectory(dumpFolder); + System.Diagnostics.Debug.WriteLine("Subfolder created at: " + dumpFolder); + } + else + { + System.Diagnostics.Debug.WriteLine("Subfolder already exists: " + dumpFolder); + } + } + + + public void DumpProcessMemory(ProcessInfoTracked currentProcess) + { + + + int dumpCount = currentProcess.getNumberOfDumps(); + PrepareDumpFolder(currentProcess); //writes to dump_folder + + //segnalo l'attribuzione per il processo alla Gui + string message = ($"Dumping {currentProcess.ProcessName} ({currentProcess.processID}) private memory in {dumpFolder}"); + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.NewLogMessage, + LogMessage = message + }); + + SYSTEM_INFO systemInfo = new SYSTEM_INFO(); + GetNativeSystemInfo(out systemInfo); + + IntPtr minimumAddress = systemInfo.minimumApplicationAddress; + IntPtr maximumAddress = systemInfo.maximumApplicationAddress; + + IntPtr processHandle = OpenProcess(ProcessAccessFlags.VirtualMemoryRead | ProcessAccessFlags.QueryInformation, false, (int)currentProcess.processID); + if (processHandle == IntPtr.Zero) + { + throw new Exception("Unable to open process for reading"); + } + + try + { + IntPtr currentAddress = minimumAddress; + while (currentAddress.ToInt64() < maximumAddress.ToInt64()) + { + MEMORY_BASIC_INFORMATION mbi = new MEMORY_BASIC_INFORMATION(); + int mbiSize = Marshal.SizeOf(typeof(MEMORY_BASIC_INFORMATION)); + + //int queryResult = ; + if (VirtualQueryEx(processHandle, currentAddress, out mbi, (uint)mbiSize) != mbiSize) + { + break; + } + + if (mbi.State == (uint)0x1000) + { + byte[] buffer = new byte[(int)mbi.RegionSize]; + bool success = ReadProcessMemory(processHandle, mbi.BaseAddress, buffer, mbi.RegionSize, out IntPtr bytesRead); + + if (success && bytesRead.ToInt64() > 0) + { + string fileName = Path.Combine(dumpFolder, $"dump_{dumpCount}_{mbi.BaseAddress.ToString("x")}.dmp"); + File.WriteAllBytes(fileName, buffer); + } + } + + // Prepara per la prossima iterazione + long nextAddress = currentAddress.ToInt64() + (long)mbi.RegionSize; + if (nextAddress < 0) + { + break; // Previene overflow in caso di indirizzi a 64 bit + } + currentAddress = new IntPtr(nextAddress); + + + } + } + finally + { + CloseHandle(processHandle); + } + + currentProcess.setNumberOfDumps(dumpCount);// Aggiorna il conteggio dei dump per questo processo + + + } + + + + + + private void ResumeProcess(ProcessInfoTracked currentProcess) + { + if (suspendedProcesses.TryRemove(currentProcess.processID, out bool _)) + { + Process process = currentProcess.process; + foreach (ProcessThread thread in process.Threads) + { + IntPtr threadHandle = OpenThread(ThreadAccess.SUSPEND_RESUME, false, (uint)thread.Id); + + if (threadHandle != IntPtr.Zero) + { + ResumeThread(threadHandle); + CloseHandle(threadHandle); + } + } + + string messageLog = ($"Process {currentProcess.ProcessName} ({currentProcess.processID}), has been resumed!"); + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.NewLogMessage, + LogMessage = messageLog + }); + System.Diagnostics.Debug.WriteLine(messageLog); + } + + + } + + private void SuspendProcess(ProcessInfoTracked currentProcess) + { + + Process process = currentProcess.process; + + foreach (ProcessThread thread in process.Threads) + { + IntPtr threadHandle = OpenThread( + ThreadAccess.SUSPEND_RESUME, + false, + (uint)thread.Id); + + if (threadHandle != IntPtr.Zero) + { + SuspendThread(threadHandle); + CloseHandle(threadHandle); + suspendedProcesses[currentProcess.processID] = true; + } + } + + string messageLog = ($"Process {currentProcess.ProcessName} ({currentProcess.processID}), has been suspended!"); + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.NewLogMessage, + LogMessage = messageLog + }); + System.Diagnostics.Debug.WriteLine(messageLog); + } + + + + + } +} diff --git a/segugio/ProcessTreeView.cs b/segugio/ProcessTreeView.cs new file mode 100644 index 0000000..26aca98 --- /dev/null +++ b/segugio/ProcessTreeView.cs @@ -0,0 +1,340 @@ +using System; +using System.Collections.Generic; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace segugio +{ + + public class ProcessTreeNode : TreeNode + { + public Icon ProcessIcon { get; set; } + public string ProcessName { get; set; } + public uint PID { get; set; } + public uint parentPID { get; set; } + public string Status { get; set; } //process status, "Running" or "Terminated" + public string CommandLine { get; set; } + public int numberOfMatchedYaraRules { get; set; } + public int numberOfMatchedConfigExtracted { get; set; } + + public HashSet matchedYaraRules; + public Dictionary configurations; + + public ProcessTreeNode(ProcessInfoTracked trackedProcess) + { + ProcessName = trackedProcess.ProcessName; + PID = trackedProcess.processID; + CommandLine = trackedProcess.CommandLine; + Text = $"{ProcessName} [{PID}] - {Status}"; // Default text + parentPID = trackedProcess.ParentPID; + ProcessIcon = trackedProcess.processIcon; + updateRunningStatus(trackedProcess); + + } + + public void updateRunningStatus(ProcessInfoTracked trackedProcess) + { + if (trackedProcess.isRunning) + { + Status = "Running"; + } + else + { + Status = "Not Running"; + } + + if(trackedProcess.matchedYaraRules.Count>0) + { + //number of matched yara Rules + numberOfMatchedYaraRules = trackedProcess.matchedYaraRules.Count; + } + else + { + numberOfMatchedYaraRules = 0; + } + + + matchedYaraRules = trackedProcess.matchedYaraRules; + + //number of extracted Configus + numberOfMatchedConfigExtracted = trackedProcess.dictMalwareConfiguration.Count; + configurations = trackedProcess.dictMalwareConfiguration; + } + + } + + public class ProcessTreeView + { + private ContextMenuStrip treeContextMenu; + String div = "--------------------------------------------------\r\n"; + + TreeView tv; + public ProcessTreeView(TreeView treeView) + { + this.tv = treeView; + ConfigureTreeView(treeView); + + //contextual menu + CreateContextMenu(); + } + + private void ConfigureTreeView(TreeView treeView) + { + treeView.DrawMode = TreeViewDrawMode.OwnerDrawText; + treeView.DrawNode += OnDrawNode; + treeView.ItemHeight = 64; + treeView.NodeMouseClick += TreeView1_NodeMouseClick; + } + + private void CreateContextMenu() + { + treeContextMenu = new ContextMenuStrip(); + treeContextMenu.Items.Add("Show CommandLine", null, showCommandLine); + treeContextMenu.Items.Add("Show Detection Details", null, showYaraDetails); + treeContextMenu.Items.Add("Show Extracted Config", null, showExtractedConfig); + } + + private void TreeView1_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e) + { + if (e.Button == MouseButtons.Right) + { + tv.SelectedNode = e.Node; + treeContextMenu.Show(tv, e.Location); + } + } + + private void showCommandLine(object sender, EventArgs e) + { + if (tv.SelectedNode != null) + { + // Creazione del form + FormContextMenu commandLineForm = new FormContextMenu(); + commandLineForm.Text = "Show CommandLine"; + + ProcessTreeNode selectedNode = (ProcessTreeNode) tv.SelectedNode; + String content = $"Process: {selectedNode.ProcessName} [{selectedNode.PID}]\r\n"; + content = content + $"CommandLine: {selectedNode.CommandLine}"; + commandLineForm.contenutoBox.Text = content; + + + commandLineForm.closeButton.Click += (s, args) => { commandLineForm.Close(); }; + + + // show the form + commandLineForm.ShowDialog(); + } + } + + private void showYaraDetails(object sender, EventArgs e) + { + if (tv.SelectedNode != null) + { + ProcessTreeNode selectedNode = (ProcessTreeNode)tv.SelectedNode; + if (selectedNode.numberOfMatchedYaraRules>0) + { + // create form + FormContextMenu detectionDetailsForm = new FormContextMenu(); + detectionDetailsForm.Text = "Show CommandLine"; + + + String content = $"Process: {selectedNode.ProcessName} [{selectedNode.PID}]\r\n"; + content = content + $"Matched yara rule(s): {selectedNode.numberOfMatchedYaraRules}\r\n"; + content = content + div; + int countingYara = 0; + + foreach (Yara yaraMatched in selectedNode.matchedYaraRules) + { + content = content + $"Name: {yaraMatched.Name}\r\n"; + content = content + $"Description: {yaraMatched.Description}\r\n"; + content = content + $"Rule path: {yaraMatched.FilePath}\r\n"; + countingYara++; + + if(countingYara< selectedNode.numberOfMatchedYaraRules) + { + //insert div + content = content + div; + } + } + + detectionDetailsForm.contenutoBox.Text = content; + detectionDetailsForm.closeButton.Click += (s, args) => { detectionDetailsForm.Close(); }; + + + //show the form + detectionDetailsForm.ShowDialog(); + } + else + { + MessageBox.Show($"No Yara matched this process!"); + } + + } + } + + private void showExtractedConfig(object sender, EventArgs e) + { + ProcessTreeNode selectedNode = (ProcessTreeNode)tv.SelectedNode; + if (selectedNode.numberOfMatchedConfigExtracted > 0) + { + // create form + FormContextMenu configurationDetailsForm = new FormContextMenu(); + configurationDetailsForm.Text = "Show Extracted Config"; + + + String content = $"Process: {selectedNode.ProcessName} [{selectedNode.PID}]\r\n"; + content = content + $"Matched yara rule(s): {selectedNode.numberOfMatchedYaraRules}\r\n"; + content = content + div; + int countingYara = 0; + + foreach (var yaraMatched in selectedNode.configurations) + { + content = content + $"Name: {yaraMatched.Key.Name}\r\n"; + content = content + $"Description: {yaraMatched.Key.Description}\r\n"; + content = content + $"Config extracted: \r\n {yaraMatched.Value}\r\n"; + countingYara++; + + if (countingYara < selectedNode.numberOfMatchedYaraRules) + { + //insert div + content = content + div; + } + } + + configurationDetailsForm.contenutoBox.Text = content; // Preimposta il testo del nodo selezionato nella TextBox + configurationDetailsForm.closeButton.Click += (s, args) => { configurationDetailsForm.Close(); }; + + + // Mostra il form in modalità dialogo + configurationDetailsForm.ShowDialog(); + } + else + { + MessageBox.Show($"No configuration extracted for this process!"); + } + } + + private void OnDrawNode(object sender, DrawTreeNodeEventArgs e) + { + ProcessTreeNode processNode = e.Node as ProcessTreeNode; // Assicurati che il nodo sia del tipo corretto + + if (processNode != null) + { + + // Calcola l'area di selezione + Rectangle nodeBounds = new Rectangle(e.Bounds.X, e.Bounds.Y, tv.Width, 64); + + + // Evidenzia l'area di selezione + if ((e.State & TreeNodeStates.Selected) != 0) + { + e.Node.BackColor = Color.White; + e.Node.ForeColor = Color.White; + e.Graphics.FillRectangle(Brushes.LightBlue, nodeBounds); + } + else + { + e.Node.BackColor = Color.White; + e.Node.BackColor = Color.White; + e.Graphics.FillRectangle(Brushes.White, nodeBounds); + } + + // Definisci le metriche base per il disegno + Font font = e.Node.TreeView.Font; + int lineHeight = (int)font.GetHeight() + 2; // Altezza di una riga di testo + un piccolo spazio + int iconSize = 64; + Point drawPoint = new Point(e.Bounds.Left, e.Bounds.Top); + + // Disegna l'icona del processo (se disponibile) + if (processNode.ProcessIcon != null) + { + e.Graphics.DrawIcon(processNode.ProcessIcon, new Rectangle(drawPoint, new Size(iconSize, iconSize))); + } + + //draw informations + drawPoint.X += iconSize + 4; //shift right for Icon size + + // first row: process name - process status + String firstLine = $"{processNode.ProcessName} [{processNode.PID}] - {processNode.Status}"; + e.Graphics.DrawString(firstLine, font, Brushes.Black, drawPoint); + drawPoint.Y += lineHeight; // shift downwards for next line + + // second row: Command line + e.Graphics.DrawString(processNode.CommandLine, font, Brushes.Gray, new PointF(drawPoint.X, drawPoint.Y)); + drawPoint.Y += lineHeight; // shift downwards for next line + + // third row: YARA RULE + Brush square1Brush; + String matchedYaras; + if (processNode.numberOfMatchedYaraRules>0) + { + matchedYaras = "matched yara(s): "; + square1Brush = Brushes.Red; + foreach(var yara in processNode.matchedYaraRules) + { + matchedYaras = matchedYaras + yara.Name + ", "; + } + } + else + { + square1Brush = Brushes.Blue; + matchedYaras = "no matched yaras"; + } + + // first square - config found + e.Graphics.FillRectangle(square1Brush, drawPoint.X, drawPoint.Y, 10, 10); + e.Graphics.DrawString(matchedYaras, font, Brushes.Black, new PointF(drawPoint.X+15, drawPoint.Y)); + drawPoint.Y += lineHeight; // shift downwards for next line + + // fourth row: config extraction + Brush square2Brush; + String extractedConfigs; + if (processNode.numberOfMatchedConfigExtracted > 0) + { + extractedConfigs = "extracted config(s): "; + square2Brush = Brushes.Red; + foreach (var config in processNode.configurations) + { + extractedConfigs = extractedConfigs + config.Key.Name + ", "; + } + } + else + { + square2Brush = Brushes.Blue; + extractedConfigs = "no config extracted"; + } + + // second square - config found + e.Graphics.FillRectangle(square2Brush, drawPoint.X, drawPoint.Y, 10, 10); + e.Graphics.DrawString(extractedConfigs, font, Brushes.Black, new PointF(drawPoint.X + 15, drawPoint.Y)); + + + //compute dimensions of elements + SizeF firstLineSize = e.Graphics.MeasureString(firstLine, font); + SizeF commandLineSize = e.Graphics.MeasureString(processNode.CommandLine, font); + SizeF yaraSize = e.Graphics.MeasureString(extractedConfigs, font); + SizeF configSize = e.Graphics.MeasureString(extractedConfigs, font); + + + + + + + + + } + } + + + + + + + } +} + + + + diff --git a/segugio/Program.cs b/segugio/Program.cs new file mode 100644 index 0000000..f381fdb --- /dev/null +++ b/segugio/Program.cs @@ -0,0 +1,34 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; +using System.Windows.Forms; +using Microsoft.Win32.SafeHandles; + + + +namespace segugio +{ + static class Program + { + + + /// + /// Punto di ingresso principale dell'applicazione. + /// + [STAThread] + static void Main() + { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + + + Gateway gw = new Gateway(); + + Application.Run(gw.mainForm); + + + + + } + } +} diff --git a/segugio/Properties/AssemblyInfo.cs b/segugio/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..e179288 --- /dev/null +++ b/segugio/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// Le informazioni generali relative a un assembly sono controllate dal seguente +// set di attributi. Modificare i valori di questi attributi per modificare le informazioni +// associate a un assembly. +[assembly: AssemblyTitle("segugio")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("segugio")] +[assembly: AssemblyCopyright("Copyright © 2024")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Se si imposta ComVisible su false, i tipi in questo assembly non saranno visibili +// ai componenti COM. Se è necessario accedere a un tipo in questo assembly da +// COM, impostare su true l'attributo ComVisible per tale tipo. +[assembly: ComVisible(false)] + +// Se il progetto viene esposto a COM, il GUID seguente verrà utilizzato come ID della libreria dei tipi +[assembly: Guid("92be4c1e-cde8-4f13-8fbb-e5b9445b5077")] + +// Le informazioni sulla versione di un assembly sono costituite dai seguenti quattro valori: +// +// Versione principale +// Versione secondaria +// Numero di build +// Revisione +// +// È possibile specificare tutti i valori oppure impostare valori predefiniti per i numeri relativi alla revisione e alla build +// usando l'asterisco '*' come illustrato di seguito: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/segugio/Properties/Resources.Designer.cs b/segugio/Properties/Resources.Designer.cs new file mode 100644 index 0000000..62607aa --- /dev/null +++ b/segugio/Properties/Resources.Designer.cs @@ -0,0 +1,123 @@ +//------------------------------------------------------------------------------ +// +// Il codice è stato generato da uno strumento. +// Versione runtime:4.0.30319.42000 +// +// Le modifiche apportate a questo file possono provocare un comportamento non corretto e andranno perse se +// il codice viene rigenerato. +// +//------------------------------------------------------------------------------ + +namespace segugio.Properties { + using System; + + + /// + /// Classe di risorse fortemente tipizzata per la ricerca di stringhe localizzate e così via. + /// + // Questa classe è stata generata automaticamente dalla classe StronglyTypedResourceBuilder. + // tramite uno strumento quale ResGen o Visual Studio. + // Per aggiungere o rimuovere un membro, modificare il file con estensione ResX ed eseguire nuovamente ResGen + // con l'opzione /str oppure ricompilare il progetto VS. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Restituisce l'istanza di ResourceManager nella cache utilizzata da questa classe. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("segugio.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Esegue l'override della proprietà CurrentUICulture del thread corrente per tutte le + /// ricerche di risorse eseguite utilizzando questa classe di risorse fortemente tipizzata. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Cerca una risorsa localizzata di tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _118801_refresh_icon { + get { + object obj = ResourceManager.GetObject("118801_refresh_icon", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Cerca una risorsa localizzata di tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _39368_executable_icon { + get { + object obj = ResourceManager.GetObject("39368_executable_icon", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Cerca una risorsa localizzata di tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap _85334_file_open_icon { + get { + object obj = ResourceManager.GetObject("85334_file_open_icon", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Cerca una risorsa localizzata di tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap rocket_start_512 { + get { + object obj = ResourceManager.GetObject("rocket-start-512", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Cerca una risorsa localizzata di tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap segugio_main_logo { + get { + object obj = ResourceManager.GetObject("segugio_main_logo", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Cerca una risorsa localizzata di tipo System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap shell32_3 { + get { + object obj = ResourceManager.GetObject("shell32_3", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + } +} diff --git a/segugio/Properties/Resources.resx b/segugio/Properties/Resources.resx new file mode 100644 index 0000000..2f2f8b2 --- /dev/null +++ b/segugio/Properties/Resources.resx @@ -0,0 +1,139 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + ..\Resources\shell32_3.ico;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\118801_refresh_icon.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\rocket-start-512.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\39368_executable_icon.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\85334_file_open_icon.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\segugio_main_logo.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + \ No newline at end of file diff --git a/segugio/Properties/Settings.Designer.cs b/segugio/Properties/Settings.Designer.cs new file mode 100644 index 0000000..bd7fb8b --- /dev/null +++ b/segugio/Properties/Settings.Designer.cs @@ -0,0 +1,29 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + + +namespace segugio.Properties +{ + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase + { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default + { + get + { + return defaultInstance; + } + } + } +} diff --git a/segugio/Properties/Settings.settings b/segugio/Properties/Settings.settings new file mode 100644 index 0000000..3964565 --- /dev/null +++ b/segugio/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/segugio/Resources/118801_refresh_icon.png b/segugio/Resources/118801_refresh_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..3536c437220c610c616ac449ef405ecd77236e05 GIT binary patch literal 67654 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 E4}hK<>i_@% literal 0 HcmV?d00001 diff --git a/segugio/Resources/39368_executable_icon.png b/segugio/Resources/39368_executable_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..fa7013d0ad03cd97c99edb775cc8fcde5d7ab34a GIT binary patch literal 8128 zcmXY0byU>N*Z=OaOLrq(vPhQ-QWDY~0!m0DNH+^C9V&~`-5^LRAtmcnd_H>gGNG zKtl811OeH(i~zvyt)cSRI577xkHFV>HVgfE-Y-|@=fS+?qnzcpG&Jb@_wP2eCuBSv zzW)X92Q=!{n=VNs9fo$o1g>O&lj(P4a2>bHRLF4*dGWa;bA6s%f6IBe)6tI0nd6qu z%IKIp9#}5KjNvl zP2aLed!J0|DaakKgdB&?q=VtqjEw4KWo3ya)zxqAFf&(v{P-^!S?y3gr}Qk z$+vIM4UCPAVTl6+nyLmSCS@?}3KbQVq}yD5fZIJqLqqE2Ha{(|rEftgBe~MbPwTA8 zJUXvus#pDd;U~QersxdoFc%Z}@9C%X(3MAgd`{|s8ZicjQwEa)xRHCP#x4$oKt)&x zG4?Yj=sDia;bKc1gs~bM2l0G?Yi_%|MF8&fzyNx|+;k`wCrmGuTn>|Guo5HgH zPOd70zu?0|2(i}@FvQ0mc4}12+T!WaEskLG){Y+FTN5Vd&dufSm z!8@FnB#5tU%~DcQ<7+)}yWKG)%HW5T9XohuIRNk`$eDnGt#p63?vVqHXeMTT`_crU zdf>jab1LOTi5kaV8UZJt$*B~DS%gqFjK4J2UKgNSDTpwTfKG1A`g$Q9pghsmCNnT% zYT&Ca*!%s5(Mt>Z%itD+v7N6Enc>RdrB)v_49=`AGGRexPXFweUt8cN zzGYi*l(2QX#?#v6(#W6U=D6QvI=)dFzj`xTDlgBZHPv-*RYP#4((f)VcA_H;bA8B( z3jdV(a|nz%iUFAKw@qf9KHWKp`6x*9yzDfib{tB-J-5wY$z*J5HGYieG~=xd7+{MEVRL_5T{)`rgi*L#`xM=WnEqbKdxB8=WwAZf?x5) z3o70+dwt7L<$_}<0l_}RY_~Z!$**ABi^XeCHt%6*1iD{>A&Z5DoV~o| zMvGlEzStcX8DH)1Ofv8*Qda4(^rYN}T55XvC3b|IX#N_O3MubgnUHsbR5S(J%gY1V zAg4%V-_Q`tL$Gf^K+1W3sPQ5^e(xE%k@7y3@MG3XSs?*rH+Km?uUy6;2*=s&`895za3a2Jj3e1L~1^=nu`6QNM@< zV0SswxJqbXLJ}EH?~8xkdHF(NGRTZugCRwQyN_R3-A;?)kb<;`gh6;u817&q74t-8 za=b(>kNgHfUD#CfHeK+UE|YYbvBl&Qho(bgtJ%kNg7@|x@f!LXkbOs~^%c>TwiQJw zb=$dY9R!^%FndhwWULgy@sWWb|l|M>eYdpPCA0g7!5>4_Ob9*C4XU5-{7mQ!BYgfb+2-yV$kfs?=xqj}adbu^f0UM>Q z5zJ}yW1S@S&h0i|Ep2M5S;efkX?E@RsLeDs0sq!uApJ1}AmKPvxI3x9DdJ&$59aZc zi-TAo`|mc+%q*hrGjj87qyPH-JEyGEE?_Q@H!LHt9MAkH}`59y@&66Kl_|# zTC@E4<807LL7uden2=?2V)4)SLG+cc_H0AR>4gZ)6*f3r-N_BOU4ye1%o^DpslOYA zhPF?GGfAw8txzpZz`2YeaNx&HXS2}gve6uzNB;$1o~yI^-IU-bk}8*#V!E@7xfYk1 zib3a-Pj6Xv3{loDz|8_1&UNOvw29eYEaIEFBi6?J1*m3qN2BUWyz0ZNl7Tk=Dy69w zAF-Er9t9Q76Ozl>h{28ILVYmY;^N}Zt%2MPa*;ZDu%K1jbNY_9#)z3$3%WFXdJel` zbWxoe1mR4WufJoD?_%oq$--HqI^9z!YF5AH{0kp{FV*OIqM7(cqsTVhVT@BX)s)-f z!y8q2RibsE69P%phNpz^*&Z2>ean1Fh-nSYp#Mf6R*4_xZ7Qa7gR#qQ8Pg%@3>ZMO z3dMA4qO4b$Z-Rxc$c{psOD?Sz8hbN{KIOGi zI#vADnh2iiKO7+f!S#xStu25H>Dg&nmedfaF=ujl>yTOQUz&R^86K3OGT|ERI7G+1 z-GjpgRz}r_pvTu13c|Qm@Q6=@vxdO@Vu#s+H8b+5= zlxSQ%Z{9KFsQ)jKG55AQZG5fpx{G$sni$YlLOIKHZS=nzHKz|mrEw$iQ1D`z~ zRXnsEoAto~$DjFkX{yw5}5VaruKg^Djp%l-L{w!aj!iOTIKJCF;#adnnSTrKd@=+?r_Sk~P@odLyrhoq% zF;cg)9ObX8*& zaS$5m%$$N6Tts%;Nx)>xb;dP=#ASPYe|SwNFs>JmzuG9+rfvtb)#M;)LaYHPQ^f|kwQ&LMRZ zE5FU%NXcxIX)as|g zSGb72=gr>^wMb083fWcr9o$!@tL4jLewb_)*Sh!xiekK*B54347O*C6Incs)b-F$J zwH7dQAqB}_pBb&>UmlRyb4TLQ-bqstOPEj1wHzvXjlncwC#hQLXsJ@V`GU>B)(Zy8 ztV;J3&4YOHlD>8j+^}^r5)1LX$!SU!DQ)T% z9c6@P&;gYV_4WFEs9b3u=b3}~P|dE-+i=ZF=`sskngx!ongYdDk^5f!HB3-EUpKeW z-Qs~f`b~jVPtVzNeEGyb&TGfNk!9DM+9Rba{Onk-+0Ltlz+l{(n)94UxN5;r=DY~j z(hxAX?k;#D#*4bm6^4$wfq|LkYZ(yZm2q^{8;93|n#0C9O%rH+A_iU;7p8dyj-)>? z*Dk}@)Gnh^VD~kqQ+_pJqsU7qzYraJfo`y91+T0NJozUN`1$#3`2bxAL*RI^>Ro82 zlq-3Z_538$ls|Z~$sEwbw==V-t@UUo?ubuHBF}>~oVYn}v!gNS$&Tw2TE=W8v3}|H zg%A{lO!AXs?QBi%CvQqiH|%dc;^#J038Z6?h{JRjL!tE;Ve-*5ixyLYEEgy2T1c`L z+Qf3cXu2!loD*YgLd4sUx;(Yu(gYyx605fc^)@1V^f)>ZD#Q-;B{U`$xLuYojwp7< ztS9W+c{&{(9c>CbkcZ8TTTD?%b;s`3XkfxG7`C7Y1Ox=Af`_uDa=Pk@t|o%-+gDe} z#_L0vs#-}YIVD=&OnfG(>}c(=#c}BiAb@G9rfQ}!)H#KA@dun+qCHh9fdU6t+E(aR zc@%PsEbIFU){FI)^|_)DMFRZr;t@1DZmGqM^TC4$*$Uxd?4WY(tZpFM$N-wpBx(5A zJjyg$=9TG(HLef81k}rf9fltZgp7&^Mv8zp?bRv!C*&{$vE_zt-tMD$6j%$~rMcTF zQL$XewQu+ZnGeeWS?4NL(E!iGy%x9-@O$T2<_Ev-8y$6`);{J%eS^NnHCDeLaJ*OR zR?Kw+R7N<&;LE$l4eA>!2dPe%3Re|>dRdL%;X(z6Wb@1BCnXKq_88s2aazB@BdWU9 zU~v-?g_u8a6=U0L{f&Ga>9>)}(7&+aCObGUmdeJ#6||B<1ITUQ5s+gwm>GNU+NePr z=`Yv!e?Sxi0|R#;xQ!I1)Y^L+G*W}Ei;PRA!paS%u}XKrpTOnrn`t%|rb2Y-(}pe% zczFl%C5&w!RuU@wC^5kPi5l-l{Z|F#>UBHD2P@e9zMq{cTO~};wDz|RYnT5=Vp&bh zdiJ6Pf`F6=QKSBIeVt!K1ey5ybZhHlTj@2}t^{gYn0_v}e;}T~2$p zTkb(R0tFuu5^`h(j3xi{>6@ylI{Y>^w9+&2d*%D2&K8ztppe6vd^qrN55`}TJPIau z%Hkk3>D(c$ArGcKhCO zU!iKKfY*vTP9VK|u*&iu%{^0N-tm4|azjfahJtL%$+3P_Mbi%-_Jx!aO!4FOQ9Q6( z=fa7qyHy`tie{2}eE%##!-g)v&)b9FlC#S_PWvsCYNW5~Qe~*AF0zrLh~u`op@ijh ztJ3MuvX9y0#bX%Wt8{b`Z7`=QPCAY>30#HI0R$izEQd=jdk-&jA(JRa=T1~XP7eAA z^`t|lLiOtrg+PF>c%vv&CS@P#v>{Vt7Dz{>(#jEqey^#M`f0ZIgNx&QQQEbx1cQpD zp>ivudHo0vreq>Bv$h}bs{Biv@*ZuEf&;SDrUsBtVEcIb9wnXAdIc79&IEcPb9b)@ zH6r+#(S;7c?`D*z$ot4=?cCGLvwKHuJxHz;g(aGI47Y(XKmZJOnjmBL0p8u>< zr2tH#E_Y(So|?MUK0{yARE+miImcrGWw)wq+xKFRU>WBWGi}HAV>DT$S?$?`=R$0z zT^W%XQOA^^R8qW}TG}Pb@Zata{8*3Pf%eZVvPf(4vZdg|q2f{HS*XPP zz1S6TXYnXg{258w;w+mywI)-rJz(;Jj@i)E&@|sPmW5MUtWNf>i$lDfxZByBDpFP^ zH=pG%?QnieY9yCYU^pm6SxLF4n(hBwkhV698MrWN>+rDTBcA;x{n$8-*(CD!b;Vyp zcl%i31k&EkrsrTzyqOcJW=;Ds$Jo6K@)gc0NgBDVB9&~WQt|p1ycgj4sC+$p?Izk$`q-sQR_k) zo4qL)V?$FN^w)+(w0TDZ-u*xXX`VLFIU2QF)3Q?jmqec1?}c}tsXXju7yyUsgL!3MNdubj({B<5D2&)ReC3R=dCN7E-3kH7Um zGey^g?)=-zflHfP8pR1eYIMm-+#(meo;hQ_^Nix98f{+o!5GH{Sxt7i(qcq3X>awq z8H6d&x+s0BH=Ft_&d6yDi&pC+M$C1D5~QW2nLo!EfZ5+AC)*f-Zk7$e@h8%{>b118 zJ~M9e(T_s^aPgKoPLyh->@ElJ{h_j1`f_sMO0%n|%{5Btd=J~OKIWCry1;Xd@8bW# zgT6=W9cyV`pQDaZm&2GOOJ2tlc6QP^cHCJmCu zVU=ej1?}bbYuYTkNr|vO=Df}>m_5d-=Y5#^9A}>APWayC4UHq$@OK_}j4N+eUNBJ2 zC|^Nk6YKapmke0g$I+*=N-F;-#G09d((BB+*0{08)LfsGvq?8zk$Pe2;^$@V@9PyeB}awE;wljBT-tiN`XQhN4E|RIN z{*+IwRRvSCRN9^YTb#FvD#`s?_|`rL064idiDDz zz(|(BP+aExfj$VLq6HnR8(uGtS1k^#O(Np<23J4p%nzs+ZGzX;iHzdMLezB!f97Zw zd_}OTG^Fg5$twvy|Mn(7Ac#+Q%2wE)yt3S5jLM%NGm9?V;b9izx2tO~Su^C83 z!eFouv!fhX#LNEoWuL&Mjvsc!o8x-#H)J#vV5hB=a$hKE2VSy9fn`sJJotsQhA$}i z%>S)Lmn&E9E3g!Oi}b$1SrD_owgL^WU=Mjwi{+59IF}j#$5Qv&uwMT80oj`@rBen$ z470{=xb>Z)q9V922OWoyL|pCa_w-*aJ9~ZyWYzP0xCy$ql#C`eToq!VAK$L-F&na# zmE6kkNqmZ+1WQ@oN{AnJaBxsM^9F(Z)mj6^&E8Nd9v!I_QXnd#FKkX=cLLJHaD=2^ zu`Hk%9!|w4rfi{qr(bpGT-Atl6f?J&S+AEnqOq>C9tM1Pu9}F7{IJ*=ch3rUOLnEn zaCPne;-}W^Y9Z$r-Z<=^ z>^@DDTxmGDT-RCjD4?@^G2m$8Y0I%V=h05|hYz(+c~Bnt!P!$#hwA<>>i7J_+JBGm z$df+*>{vrCPhYvf+yRJy!v`ByA)*kIN+5P-cb9;z&_+IA3^Uhc6weidOj?_%S@Z>0 zukPrkN&WWSJCknn*>=6y%JJBBrB_N6yxaG_Y|wdA^MS>%O~;^2YAl3NZi_Bk+)w6h zpf``)&G!_^&w)N06>jSYN34HeX^4r(^pFX>XxLFn<+l^Pe^JVT!W^un_=VM~_ zhF6#Vc|hH_i#zRC0|I9gS|XE-^gi1{rJ*;V)Q`f&QE^EIN``kltSFs38#V{nZ?Jsk zAS`CP|6S)6_>DuJPPMzz@omIQi1VibBy?U0Att_B-}yplh=WyQ5=t7u35pF+iL_|o zL(d?QXz-BM+0WM{yDz;dHt27MI6+EGXE2O#|7)H<-28cW6a>o)@&WCgj& z|GW$povxJNMX+*0$uO;xJJo0tl&q&RoJD816CY+v;_O z0q92(E1K`iok)=%XSextkwHm5cZ}!2gw~5YizAA{83{!~lN> z5~b>K-PX1EWKY!oz{Ohx^aRP)^Prp_Gj3m))z#a3tSJzTNSdWC(CRA5LbxSGBiEaA z0L?XKYSbK9C!`B~iC1h^zy~g~P())X2ggbScB>;zGa4Tj{Z^c7$GLqlPP?jBd9L z63f=pv?F@qBuf^7Bog+MR$Tr~P+~z(Lu^b8E83RL$nEeR0&q(JYQd}T!N?_3nJw~& z-q!sdv=<)_&+`}6VdapHWk@pkJ`X|&jcZS8KI=vYCHV9W3|zeTx=1s` z`BN#ff64`7gKwI5b{Ai^=!D3j(X&D^BH2XJI8{~E)un*d&`vRej-LPeLaI)B?h<6Y zSg)IlYrI!pd;el7*l!|RvBPvW-}pfr3xT1aQr7Pg;MFBD`H^0FtQVV(j!t;US`5Qo z3-BrnD9lYAc&>P`L`O&0>$C%-D(w7$`?C~<&ITiItTfZRj}H#6F25(xFqjitR|5a+ zwSlP~5c?>)ftr9}BpFCTtgiOR@Bi%b^FKa24*#-$-m$L_s(*+l z;G?gGj-s^#e_0S6wVIY=`8@H+I`=EByj8&8Uz?nLBQvO$1mK~V7zsYXD>uf65Nn!; zrgmV)DCGHVvN>ua+i_dJ`Us^g1W}7>`+-?OtNDxdW-?LeOyB}r7Q@C;(b5tiW#?5O zgjv)E?2tiTATO>}_~|g>)^JZ**wHTTX%uJ{T3X*^FWiG?T`ih`5tfVylh`BsOz&s1 zd&S4b0kq7*He*!50(D0#_zfKx79kS+=}Vvzf)kfr5p+Qjt!?tx(8$Q+)BeBYnzbBm z6f%{NW7)#8(a9V9g&6M2=f#-aRnl41%mO#qH2OFlaNN3`k3Iyga)DC28TiUYP>RA> zSZI<6MAYP`kch~?{rVR@VICs5`*eyH8}I!8l!8gmz{m*=mWK>RCLI?S7oBhKNWH9< zTU%5Cq_JF{-b#qN&YNKUHz#S@tKEMYKmKZJYPt^XjwX^gBwPI{k62oN-YV8X3Gl%n zjDpy=!?QhqZyO+T&~lxe=2*+)a8DT!=^>@<2UJwb_g>one=X;sNb5azE1#2}y&VS@ z|Lns56T}ZkEQV(jQtuFfW{L~agd_``xX;ydMp$ki-@4R~P*IbaG#XS^Y)}$HBpYzK zW$n)9rpZw43B?6XhY1)~v#SMVjI7K0QDeP&etzy@ARe>m0@0U=A}HL1cuK-U=mJwA zR!@!pdLFE;tu1R-cs_~&wq%ECz?kS5V8j^HFe^H0h6(*H&3pH*m6Q{4OAi!Pz$vzE zAk1-lvwDxL7KYnX`(ehx!NKB|?wWropkRMe)dy&@Z)!rngq$B0#vxIzX{o93OB5c3 z?4~nL6N;-fjoemNQt}Nawp7^gUq$_EAZB0|0Kgr0TXx^SuX(Cs^FWwtF4^D?6bk(m zQDdWG6V6VR*#jeUqvQqCSZ;!iFoI-5IreoYvrhRzj*TT<0`!Vp-A3;2?v;WQf^X9V zo@TQOm{!-{OBb_X`#=`iIg2(pIPx>lK R`nDwxXsGI{)GFCT{ts;AVQByW literal 0 HcmV?d00001 diff --git a/segugio/Resources/85334_file_open_icon.png b/segugio/Resources/85334_file_open_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..1b6a9996fe4cca19e74a05899a4afe2e18968a65 GIT binary patch literal 9760 zcmZX4byO5@*!C<-ceiwRiip6{AdPe*(jYC(u5^PSB?w3eNGpisE?r8OAPtgIuCU~O z`+L8C-gDmhV`k3Gbzk@OTyx*gb7syY8t7?|5Hb=106?OpscHlOAj~NUz{kZLto^E- z0f2i~OI67@c_@~nqiKE5VQhXD)LWHXvaOeS1&0B7R?cl>f3=Gy z)655lPYN$1PTKrQFsc9VmUMQ!aj5Pq!TdREM@I?(HsYQ1BmBhL+Yc9D>kJRMou#_l=Hyr;}2-W-YOv%F#rk9 zn1PbgjJm*AJnFC_+h%t<1;`~ak|3ApKBs@N<IXbJ(CT%z*`EzUy>lWF7e+bk@9U;DlguSZ93{!RJ&N0nvo{s&}W zeGwyUJl>?5(Y z1G$B#!)Ma{z=@g%D{~<=tTwOrO#4izw>?58jPj7pt5%)q1Y?)4;;{t0QL6?EwZjzDLt1WDMpGr7<(+Na-^2G27NzZg?t+%Hlz6M0DB^@`h8Q)G! ziEpH*tte}g+6-0q<%yk&ikwx1C89nL7`C;DBcqyv$6C!*$R>ot<;iMP!t`v-$Due~QdE-kv6Vsq=r;l!IB zIV=p?kC{&Ir(W>`vq6m*o|22jv4}S|q{G|xWShBKw*!o{kpm+)wI+xO=gggk%5LyK z9y|<;XRqb9w&>{ZMiFz$mFee_q=x;igj*wQ1$ps&+6Ps+nCEZI%Ah-^qHv7*{Ohvr zg#-E8F{=4!IJMmBbr4yLfjd;b66Dwmsb0#oYwsFPueTFFJ2VLwOg;(^Iq>zMIbHcl zrxyA2kB3;;rSyMnJLk6QxwqjKWMOyi2@OB(8XgqS+a9sJBN<*(6H;`M8jMjI*qQj5 zd#NlwOeJ*2#I*XwV)$SoBxl*ICB5mFMp!7_liSge~dr!1j?XWqo*i| zq zh9&2UF}wTwrpHhvS^BCM4NRJ@y*f;vlULoQ!x2*jI~Erz_vZ;~yOhu=>7=zXhkdwg zR$~%km$#VuiW>vSP&~o}pFHs7eowNu97NS6DHiveECo{-^bBeFk;8U4XJHzAk*xt? za;$gP>ysJ@?+bMQ2Bp5q`}<1TL5Ds#NAZstDB735;nSvnYr5MI-Ble&lB+bN0WuXu@!s$s@;ZOokhi;0WRSB8nu@ zpFg=)R!1jx!)iGikqG(zb8Rsm;v`yFid{uYA*w?|sQXp;0aIt60Kg< z3opX~r@&8VyZu0P?SqWvx#@ib6kjhF=~8d|8v{^rDzgr1zj9dZb3 zDRf8j&Dy93)6mvuHokqWuWovsSXQJ#Q^Sj~y~vX;R3XP!dkdwaY$s~z%x(WZzRmliB&Ke^+i6pfkA&nn5qsdV@W>W z+0(Ux;jWGkF#I^&V>dXFUi?+@^`m2R>1{#Y$Y}Jynvrq1#li9e_}mf}l2qs8{#~6^ z#2q#@jIXb>oG{=Ha!l01*NEcJQ5gDcW_UYDk*L@Z`d?ArYmd2YAnv5R?y%o|CBrn)Bz*`a=9lY&2)xZJ?1RPtA5S0NVk z?<(MC=C}08#rFGuvnlLyuQGqXOAuX&bVhSohIk5eeLshHUf^a?RhN=6FUCiNSly5F z(E+?q5Hmf~F76!nrtzry=&qnCA6BdJ}5@Q!>2z z8)~L2S^wF5bET~Lg$6@JOlwc$?IUaf3R=a%O_#2g( zB#NqU8v3FUng1zy?Sv9)GqPDA6j=#^l|G9UQoMN039Fb`Funb1)L+?u!1Rn+=n}+7 zClpaTy*csi)!7$j>L6g0g!L%!6UzS+Pq${n=GbYPCWfblJF+Oc$rcd63A$;HC)=pX zL1l8~+yKV(v}n6m$KzeDR%|`A6@XZe6cS5}7?8U$}qtX+yXPI z)x>pNdkh3CQ8*X#NHA~BgG%&Aw-k2szy5mcLrpNrK4A3AM4lym-16{9G|c7xSAYI* z-#eU+)$cma5?NZ-a#mI?iozW&l3#wl*Dch+VrTDflVRr~ZIsm%2$rDoGX{7w$l3a1 zeC(pcm|w%h*Qq?OGDcf>z-#g0!;ixWtRCiZ{yn<%>S(fbuMP|-$ob_xS4rKKX+1r5 zbEhzI)2$x_7)0}%!))b}X5YZl0bgzh26urljEOK%D5C%QUZ+^L#Cy zXwpjxYv*&2&_Ab^*X%jb#r`5X^Wx3ivs-e7Xex#4QW82Swd|uudHBw2imvoOysR1V zG9ipUO88P%Jts2JT;w8!Q^LU7PqaiQ~4&CR0eT#MfA5ltv)wHnZ*MC6;MXAc8HCIlCdDNly;#Uugab*q7N@ww!DR#WpCp3H zVXEZ*8gE{1d7MESjNViiE?Bc&)NkZHcIU)}p9Ni=JIxVVIe_l}$fExkn!V77!+Cdo;;_v0^0uA3)q3f~?*(pR8!_2}h}+S$d`2T3RzNq{9`jS8%ZqeU98LZXd_kDd#*j{{}I{pvixnu4nq z3UqKIrX%%k&2g*LQ98(*=_I$YsZJ~A$7aeuKZbs)@^&072|(sb0p9iiF`XEUIs=H& z#@iVv#(OEQBq)NVUL!H!>k(mQ7mW+DoQW6)2T#Q?(CMD60q)FQ7>GJXJ7a#efC>Ah%!>D)NdhduWC}053Hf-bK}#{mkh9BQ3u@KioTy%k~C&A&k8Ec zXmHnc?d*z)=plrf&6agab&?v%v_q-1q7T7@aZR6P_AGA(EvR->c0LBm$fzr&RR%w# zQ&~8kctqY7@1t9|$F>L?!{LmHs4s~lkVjR3KPL$}KFDX1tEy?$A3?4$iJ#p7V0&{2 zqvrmfKf0$h=rLaeF%=vCVtMyVEfOvK6c6FzA!eEO)~WOh@ckE1-d6TfHkW+8=wTn- zc|9sP1K;SQCO8hZ-RWUkAJnn`?ES5nMz_8Cce^UZ*Nqjh5bQDutxwBfTjkyrL`XaYs8hNl9nDE}N_NM8K!D zrJvePfpx!DfgHx36W&5;LsMVj?D=K`Z4DXGdj@GB%t~o}#JcI1chZd`+ClYeI{96u zvEbk`J~lim^$mj0f%LTkRWPf){g6BXSni|+NP7DrjdCvO)kndrBXV;MGc&{`I=Vm5Zw4c!&`It1vV5n2rskqgA}xjuE&9Cx$5Zsk(uz9gU`1ZAXrjc_ zH%n{O#a+S$)Zt_*1K|~#otiroIb07p(I?=#=YlBtuCKYBZu?8U&DT+(Go3Q%;jt?Z zI(ISQZ}`Uds|@2&aj3$XFyrj3{N9FgTADk$i> zE+2%KF5w3|OxP=>uPq3#^hR;Lz_VukuMvEtV(wz1%^w$zG;ll%q>}z>*((8i{qB!Z zmIX*oUa?+f?@*eClpVPTa3IM<#yg3?5Vz#ErpBosVqkJLU{c~ z&)O^{WSZYp)WlOki!0L9ld_^H(f`JOe4=^QjCp?U5@qf;(>Kya(3aZ@3aGo##4nBQ|xOzh33udGKJq;RCst*~9tOJFQh* zdk|Ng;|YA_=?&f&)69q=Z*%A*u`vtVNzG;BRi!0+*^}Iwg+$YUcrG5>|X z6X7;cRb0fDYk!Pj@M^s8-{P3v*`0^3zBz?#ZssrjQFI$x-QpdUAZeHc*uS_>>lE7shWR5{i>`Bnvvu{I)T)RlG6@7ubth?=tR=})oS4OrL8@e3H z`7t3&T$Ua5;x0g!jj)vUXRNFv3sBjB=#=hq_r5fA<)+ro(HRlk5Can0Ev_UaE;%W% zYXcHN8~*!nuU&ZKt^>$dEfy5KI)FzLXiY)dKgs~k0a=&F=g~+IP?;T)Wvz=GY*n2o zbRpm;A{iq)?ltHX{b1J(Ab|DzFhk>T{ms<4BA1(Z<<-iTHd!Y;u0T*>s46e8h(~^_ zn~-a=;roV#?>S}F($>L^;bPw$s%$u3a3ANh?dqYfT^Kkbu0g~V%?m}O82X8jrv@(xCWz!vSOsH6n{`Et_o)#jT1>t5jTMheAo<=yz^lg)sJO^anVKrjXIqTA!O6%(~ zIa3h%JIF*Z?I&T1mf1B#q%0cnITWC~BT~0rZ zE0MQb%LX)4B3}T(Dfk+zOI2ckCz9YHFmU{PCfPMu0iNNPr1PS-_T%}x$H&)^Y=K&$ z@CJc7IvKjv$rC6nFv_*99h#R*LJ%_4m}_Ee+SL(U{Q4Ql9} zIeV?Tg1oy0K^gQHj{0AQ5`1$0q$e=~`k19tl?0XuJ-Mt@lg*BJ6_AB3;5ulp%Rt95->Y1fU>V0 zO?D*Can1C(v={K{=XC?z+OBktBJ=a|$msz+Ft*GZ{sNHk20td=hmBW;E6}?{KdP=oopjJeTluracn-UY{Pwfo5|)p)NDwyHjF<@rZ*u`1 z6!DLUvMlJ*`=_HSaWg|%DK3D!-er0jGVuoa-GCS&w-o0AtR9Bj-V!pvkQDY7x>V9G zqIBPfBMFGdj+o>teqF=E>=gX@r&r*Zfm9-flkTX`fT-~j$EhAiV zJ%+}0T04~YYmhnnbm{q10il}mOaaN#AVHN`z^9V6SO=>i-W4cu$K#n%W~~qOTpyUY zlev~Mjv2T6;u&S0%`T7(Vb=-} zCkW+~07d@5dDbFk*%q);pLT}#hKEA2J}zPxQ?$oPe1wk4NTgDmco zxdO5S+(LbCR)EfvKk;|KYf$0%2ob8Q-nMI$3Fz2L58`3x!xxZQFj8`pWf1&S)!oD( zMbLkO=+f`S))DnS{)%qP%lQ;aYfy}21d-b2^Ak*8X`9&YzV9Pc`2AY|Sh znq)73eAv-QMgD%nVOeabbwhN(A%NA}1}_J#%Lv$DZ+ihC_{@iy-Nj&kj+6bCBqz#n zq{eo`=}nN%uIU@W6JNvnpb9;@o94*DYpL0IZMv!!?{Ck@G+$o(DVodzMe?2>1BP@h zu{g~eCsh9i5s|Fl&+1&C{Mg;=PIcJ}I@F(1Q1QxBgG}Sv2R`yvp~ygXW9M*}N&~2l zOkAJSeqZ-t%j2NuHeT2LWs5Eamb`HF)h)NzBV@(#i2w|0*rDV1-joogbB-LKcxnp;figkK~jaiGI3!}iHcxyW>C?1 zHy`RKe`dM*q?ah~NqXX@2%YV=e;eDIe;!p?FKkNYzuvp>!?p)Q_@9Y``P{xt$uZP5 z!vh1RfeXfc!*Sr;0ifgCDDZ4Y9}?3eEUqU=vTz$049d(YCaad^G3msB5hsG~WK8!@ z0_L*~kKhvPF^s|%LVOoJ{w;dpB*5=Itd{wIin_R5GUKK@NwD*GwMavShbQj1t{eCK z;6)S7bTKgM)iiLwn*%DJ@?JnguKqm`H^DYGGT|%$F+a)HYumTuI8aO{kX&OWzZt_i zv#W*{WAxMI>V0a7Je$FWNR+u!O!j=%yY8G-_t36I_TN*6rbxoD#sQY+xQ$L2ZjYI_ zpzt0Bhzjwq35GXg9@Ck}g@W2Pr66eY_kn2K?>; zSe$Vi12IY)^BEwI@9xKDkgRrvDeW9=!*$S6q5=_rfJ2pjZ(Ed=D+2z;o_3S z9O?$N+pbbQYlBBsaj=b8UC4tNLCyzwzXdI@vB9p}BrrLwZDRY~a?q1K2jEhd0YTL9 z#o3D@W5!5b*5#pr#>H43xqr0tERr%Axw@%=PCg1G`R6!=v;2gv@fHuhR8*i3}Om=DK0d<@l~UZyfndY}EVcSmqO8;(z6= zL&=(M#B48%+~KY2Y%GZjILnL*9eseN$k9KBBw7%6vGg;I0rzau@Bp8-Q~vfP6a~k< zq2b2b(XuY*M>^x1J87)vQ?b*G3SIvN6$%d|%>m6{v!7XAd_lc|&f=3KC{Rq@d$mvf z6{c$A6T?=$Q>?y_am9|crF+_e+`r9Gnn=q*;9xb}3HTqZa)R+Jr3IizFs}_r=*9MJjoAQYXt<2TO@d=?;E+iao z5r_n6-JSo-S}|wFCZ%6qlCYevztsF#jP)p3oIfieVM0-QFk>X*BdgKf3%?!t(Lo)~ zS7L|CUV$E)nZStBSW(+K9Z32?FIkuYWzc}p!zL5K_GJ>ufyCc)QqRNFQghWkGa1uB zTtH^@_{_-pJkU6+c;b88hzMzZ1rOtB1VXg05EXQF?A+SGX|_RiB+tnBh2V?GFXy=69fYZ%BZa|;-)+^+-KOxp zM^5UtfH}f;W->3eJkA>^zI`zAx~omIh!Iwg#W>nld|&+jCL~cHX%mPHa&x>Rxg${d zIl&(stEoDfu2w+XhQFklXF1R30DYZp|Hs<2nNLXPCNN*hb2^`z7s}23Olz-T&`2ub z+xumer+N9|m)3cBf8|d%y2657SavaAv`^11@?9;S-D;0WhO(BtmF<HXx~ILmH+{fC$(IX6? z=y4?2m2i%H;LHuhUIY4euGyoStL{FR9%L4EO%5b+3w@*TCX`k6{hlTn2Xp4){#;YC zV;pU%Q#gMKtd9^fQNYRl5}w$SHWz*}vnw_`3;;T)8;^%zu~6wMRuRZ#AYsAOnt@27gm{SJ0UWe9 zgKjGOb^H`KZ5Z?e^JS^#2aC#uPXOPtT4%$9xPiQ%9G>cS5&2xB{X;Tj;WDr*mw3KJ zFJOHQ&q2<%aCuVwZQ_KZxSb?$96-n2M6(_wcX`fe#xUr6Ytdrq{yxvLZlUR)t?0AK zRJQlA$1dC=?RkN8jQh&QlVD{qA%nGf`vDsx-GxNgl6yvzQj=D+O0w5xoug3O4`LmJ z;`+az#9UGp{=enDuM3ek(G&NwWZN<-!Q&+|JLEXz{0q^G8j!l;BvU$~awWse@wV6h z-uTHU1YrkwS+m;n!d9KY)QI*{KVRLquLd4tx!VLUNbBzc$d4lI=UdB%=c5DC;>|TT zoFzZUOmhj#)kcg#w-^74>b(KW+&Co27JIToxe9BTpKf7$>atxBHrVV@6rsktjstX! zX;vYP04Vx2#7qXLt9Ga%!kI4RVSI*jdeXq#E&v-GKCJgW2m!hTV?|(J{lo(Tv1hLj z^GMOmfMV<? z6W}LT8jNvwHGqh>2z$MOqlV#xv*b$fF_H?%6lZ&HE&ywaXrsY!(ycbNYqF*KZBnGu zMQyTz?ph!1GOiuZeqhC0ZxCi72qg{QUq3#42`pvd)rwGRmL&!Ee*rK+>F%&OVdgbb zHU=;z7ApaY-Hh68B<&=DJpbx4z{#?UI7`R);{EMvYZ>4w6B%=C1!!Fc1J{QDu1X;m z0vliqdggK@{NNE0o2=Sd!UB;}6QTVEYYh?hw2&anStu*pIEBHNuMA#C2b&Zp zSPA~vQc(AJ(p!Ak_S*r@9y|O4W{@=Rm?<58xrO0Nr*?TPOZpJq_y~H)X9+*SnI9Ae zhX)olW8mpp9u|UoWrJPZlCv=u8M_dC$mgehdn)@m>UwX-1QdEef0JI$ZfKV^u3crrDwSgt8NGk7f!S76y8U zlV1lAviYz4Tl0Yz$oq-HfPTxI`?GXtbI;KxOu9sXg}@egb|Yy@hgXXOe$MwEt19UJ zN+#@uB+SR}x$t}c_2gpDSpBi$PtWc8-o{vhR*RBKvcGuv2KUj|O$j4#k zDYTG)oi7~$h%g`~i^^l48i6!pc+f}&p$}|&cSd%S;vAp}^t>H#cP4cq90lR?h?+|J z?;UH(0!oW_*ZLr!NA0<+Wc)+5QIMv!l~cc803vE?2jpf(c{s)XMIB>V{+&LWo7+IT zU6rlQ)AoL)1UOgE#VF;kvbpmRW<-I6S z&GgL(T$$j7aXtso{`_Wf=nH<*CuIg;tl7lEY3Eg`hO@Bja>i$ literal 0 HcmV?d00001 diff --git a/segugio/Resources/rocket-start-512.png b/segugio/Resources/rocket-start-512.png new file mode 100644 index 0000000000000000000000000000000000000000..e8baaad77266669040a217894f6a29964a15fe0a GIT binary patch literal 66625 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 z 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�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 KT-G@yGywn&fPxeN literal 0 HcmV?d00001 diff --git a/segugio/Resources/segugio_main_logo.ico b/segugio/Resources/segugio_main_logo.ico new file mode 100644 index 0000000000000000000000000000000000000000..34b90d95aa2e0a8e09ed1b6050dc68bc6dd0bba7 GIT binary patch literal 86219 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%0ALdVzy$(;T3Z0{ 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

&}MicQJL<#)h6oS9Gg7UGfiatcDr~ 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 cU^_>3unH~RZ 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%0A?a6+g##8kpTN+bO& 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

6K!K+tqF1-l}ZI6R0fh-&$w9sTodO~LO$o9 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 v@0zIZ`g+^z{!x@um96|>9{m3R08My1 literal 0 HcmV?d00001 diff --git a/segugio/Resources/shell32_3.ico b/segugio/Resources/shell32_3.ico new file mode 100644 index 0000000000000000000000000000000000000000..313606ab4abf51e62eb524df91961313472e52ac GIT binary patch literal 23558 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 literal 0 HcmV?d00001 diff --git a/segugio/Resources/stop-sign-512.png b/segugio/Resources/stop-sign-512.png new file mode 100644 index 0000000000000000000000000000000000000000..fd804607816103e9ebbe8d747219a2eb888ccc7a GIT binary patch literal 33775 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 literal 0 HcmV?d00001 diff --git a/segugio/SettingsManager.cs b/segugio/SettingsManager.cs new file mode 100644 index 0000000..3f3ac40 --- /dev/null +++ b/segugio/SettingsManager.cs @@ -0,0 +1,100 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace segugio +{ + public class SettingsManager + { + Gateway gw; + private string filePath; + private Dictionary settings; + public String settingFileName = "settings.ini"; + + + public SettingsManager(Gateway gw) + { + this.gw = gw; + this.filePath = gw.directoryPath + "\\"+settingFileName; + settings = new Dictionary(); + LoadSettings(); + } + + private void LoadSettings() + { + if (!File.Exists(filePath)) + { + + MessageBox.Show("File settings.ini not found. Make sure it is present within the same execution path as segugio.exe", + "Error while loading settings", MessageBoxButtons.OK, MessageBoxIcon.Error); + + Environment.Exit(0); + } + + foreach (var line in File.ReadAllLines(filePath)) + { + // ignore empty strings or starting with # + if (string.IsNullOrWhiteSpace(line) || line.TrimStart().StartsWith("#")) + { + continue; + } + + var parts = line.Split(new char[] { '=' }, 2); + if (parts.Length == 2) + { + settings.Add(parts[0].Trim(), parts[1].Trim()); + } + } + } + + public void SaveSettings() + { + using (var writer = new StreamWriter(filePath)) + { + foreach (var setting in settings) + { + writer.WriteLine($"{setting.Key}={setting.Value}"); + } + } + } + + public string GetSetting(string key) + { + string defaultValue = ""; + if (settings.ContainsKey(key)) + { + return settings[key]; + } + + return defaultValue; + } + + public bool GetBooleanSetting(string key) + { + if (settings.ContainsKey(key) && bool.TryParse(settings[key], out bool result)) + { + return result; + } + + return false; // Default value if not found or not parsable + } + + + + public void SetSetting(string key, string value) + { + if (settings.ContainsKey(key)) + { + settings[key] = value; + } + else + { + settings.Add(key, value); + } + } + } +} diff --git a/segugio/UpdateSignal.cs b/segugio/UpdateSignal.cs new file mode 100644 index 0000000..6c2c79e --- /dev/null +++ b/segugio/UpdateSignal.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace segugio +{ + public class UpdateSignal + { + public enum UpdateAction + { + Idle,//only first time, after first process monitoring loop + ProcessScanStarted, //when scan has started + CreatedProcesses, //when new process is created + TerminatedProcesses, //when process has terminated + UpdatedProcess, // when properties changes on yara or Config extraction + NewLogMessage //notify a new log message to the GUI + } + + public UpdateAction Action { get; set; } + + public string LogMessage { get; set; } + + public uint StartingPIDtoMonitor { get; set; } //ProcessToMonitorHasBeenStarted + + public ConcurrentDictionary NewProcessesList { get; set; } + } +} diff --git a/segugio/Utils.cs b/segugio/Utils.cs new file mode 100644 index 0000000..1798901 --- /dev/null +++ b/segugio/Utils.cs @@ -0,0 +1,84 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace segugio +{ + //file di utility multi-classe + public class Utils + { + Gateway gw; + public Utils(Gateway gw) + { + this.gw = gw; + } + + + public bool IsStringNumeric(string input) + { + foreach (char c in input) + { + if (!char.IsDigit(c)) + { + return false; + } + } + return true; + } + + + public void CheckPaths(String type, String path) + { + + if(type.Equals("file")) + { + if (!File.Exists(path)) + { + MessageBox.Show($"The specified file {path} doesn't exists.", + "Error while loading file", MessageBoxButtons.OK, MessageBoxIcon.Error); + + Environment.Exit(0); + } + } + + if(type.Equals("directory")) + { + if (!Directory.Exists(path)) + { + MessageBox.Show($"The specified directory {path} doesn't exists.", + "Error while loading directory", MessageBoxButtons.OK, MessageBoxIcon.Error); + + Environment.Exit(0); + } + } + + } + + + //method for finding the index of the preferred program for being the parent pid of new created process + public int FindIndexWithText(ComboBox comboBox, string preferredValue) + { + for (int i = 0; i < comboBox.Items.Count; i++) + { + var kvp = (KeyValuePair)comboBox.Items[i]; + if (kvp.Value == preferredValue) + { + return i; + } + } + return -1; + } + + + + + + } + + + +} diff --git a/segugio/Yara.cs b/segugio/Yara.cs new file mode 100644 index 0000000..319a0cb --- /dev/null +++ b/segugio/Yara.cs @@ -0,0 +1,54 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace segugio +{ + public class Yara + { + public string FilePath { get; set; } + public string Name { get; set; } + public string Description { get; set; } + + public Yara(string yaraPath, string yaraName, string yaraDescription) + { + this.FilePath = yaraPath; + this.Name = yaraName; + this.Description = yaraDescription; + } + + + public override bool Equals(object obj) + { + + if (obj == null || GetType() != obj.GetType()) + return false; + + var other = (Yara)obj; + + + return Name == other.Name && FilePath == other.FilePath && Description == other.Description; + } + + public override int GetHashCode() + { + unchecked + { + int hash = 17; + //23 as prime number + hash = hash * 23 + (Name != null ? Name.GetHashCode() : 0); + hash = hash * 23 + (FilePath != null ? FilePath.GetHashCode() : 0); + hash = hash * 23 + (Description != null ? Description.GetHashCode() : 0); + return hash; + } + } + + + + + + + } +} diff --git a/segugio/YaraRules.cs b/segugio/YaraRules.cs new file mode 100644 index 0000000..814a18a --- /dev/null +++ b/segugio/YaraRules.cs @@ -0,0 +1,215 @@ + +using libYaraWrapper.libyara; +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace segugio +{ + + + public class YaraRules + { + + private CompiledRules rules; + private Scanner scanner; + private YaraContext ctx; + + Gateway gw; + + // + HashSet LoadedYaraList = new HashSet(); + + + string yaraRulesDirectory; + + + int numberOfLoadedYaraRules = 0; + int noRuleNameCounter = 0; + + public YaraRules(Gateway gw) + { + this.gw = gw; + ctx = new YaraContext(); + scanner = new Scanner(); + + + + //define yara rule directory + yaraRulesDirectory = gw.settings.GetSetting("YaraRulesDirectory"); // Percorso della cartella con i file .yar + + gw.ut.CheckPaths("directory", yaraRulesDirectory); + + //load yaraRules + //LoadYaraRules(); + rules = CompileYaraRules(yaraRulesDirectory); + + } + + + + + + + + + public (bool, HashSet) RunYaraScan(int processId) + { + HashSet yaraResults = new HashSet(); + Boolean isMalicious = false; + + if (rules != null) + { + try + { + + List scanResults = scanner.ScanProcess(processId, rules); + + if (scanResults.Count > 0) + { + isMalicious = true; + } + + + foreach (var result in scanResults) + { + result.MatchingRule.Metas.TryGetValue("description", out object description); + + Yara matchedyara = getYaraRule(result.MatchingRule.Identifier.ToString()); + + yaraResults.Add(matchedyara); + } + } + catch(Exception ex) + { + System.Diagnostics.Debug.WriteLine("exxxception" + ex.Message); + } + + + + + } + + return (isMalicious, yaraResults); + } + + + private CompiledRules CompileYaraRules(string rulesPath) + { + var ruleFiles = Directory.GetFiles(rulesPath, "*.yar", SearchOption.AllDirectories).ToArray(); + + using (var compiler = new Compiler()) + { + foreach (var file in ruleFiles) + { + String yaraRuleName = ExtractYaraRuleName(file); + String yaraRuleDescription = ExtractYaraRuleDescription(file); + + + + //add + Yara newYara = new Yara(file, yaraRuleName, yaraRuleDescription); + LoadedYaraList.Add(newYara); + + + + //compile all rules + compiler.AddRuleFile(file); + } + + numberOfLoadedYaraRules = LoadedYaraList.Count; + string message = $"succesfully loaded {numberOfLoadedYaraRules} yara rules"; + gw.mainForm.progress.Report(new UpdateSignal + { + Action = UpdateSignal.UpdateAction.NewLogMessage, + LogMessage = message + }); + + + System.Diagnostics.Debug.WriteLine("Rules Compiled"); + return compiler.Compile(); + } + } + + + + public Yara getYaraRule(string identifier) + { + Yara output = null; + foreach(var rule in LoadedYaraList) + { + if(rule.Name.Equals(identifier)) + { + output = rule; + } + } + + + return output; + } + + + + private string ExtractYaraRuleName(string filePath) + { + + try + { + string fileContent = File.ReadAllText(filePath); + // regex for finding "name" or "nome" in tag "meta" + string pattern = @"meta:\s*[\r\n]+[\s\S]*?(name|nome)\s*=\s*""([^""]+)"""; + System.Text.RegularExpressions.Match match = Regex.Match(fileContent, pattern, RegexOptions.IgnoreCase); + + if (match.Success) + { + return match.Groups[2].Value; + } + else + { + noRuleNameCounter++; + return ($"NoRuleName{noRuleNameCounter}"); + } + } + catch (Exception ex) + { + Console.WriteLine($"An error occurred: {ex.Message}"); + return null; + } + + + } + + private string ExtractYaraRuleDescription(string filePath) + { + try + { + string fileContent = File.ReadAllText(filePath); + // regex for finding "description" or "descrizione" in tag "meta" + string pattern = @"meta:\s*[\r\n]+[\s\S]*?(description|descrizione)\s*=\s*""([^""]+)"""; + System.Text.RegularExpressions.Match match = Regex.Match(fileContent, pattern, RegexOptions.IgnoreCase); + + if (match.Success) + { + // Restituisce il valore associato alla chiave trovata + return match.Groups[2].Value; + } + else + { + return "Description not found."; + } + } + catch (Exception ex) + { + Console.WriteLine($"An error occurred: {ex.Message}"); + return null; + } + } + + } +} diff --git a/segugio/libyara/Constants.cs b/segugio/libyara/Constants.cs new file mode 100644 index 0000000..b558a67 --- /dev/null +++ b/segugio/libyara/Constants.cs @@ -0,0 +1,45 @@ +namespace dnYara.Interop +{ + public class Constants + { + public const int CHAR_BIT = 8; + + public const int YR_MAX_THREADS = 32; + public const int tidx_mask_size = (((YR_MAX_THREADS) + (CHAR_BIT - 1)) / CHAR_BIT); + + // This is a placeholder for the raw struct data of a YR_MUTEX, which is a HANDLE on windows and a pthread_mutex_t. + // These have varying sizes, and we don't actually care about the contents, so we block out the size to ensure + // bit offsets are maintained. + public const int yr_mutex_blob_size = 56; + + public const int YR_MAX_LOOP_NESTING = 4; + public const int YR_MAX_INCLUDE_DEPTH = 16; + + + public const int YR_MAX_COMPILER_ERROR_EXTRA_INFO = 256; + public const int YR_LEX_BUF_SIZE = 8192; + public const int MAX_PATH = 260; + + public const int CALLBACK_CONTINUE = 0; + public const int CALLBACK_ABORT = 1; + public const int CALLBACK_ERROR = 2; + + public const int SCAN_FLAGS_FAST_MODE = 1; + public const int SCAN_FLAGS_PROCESS_MEMORY = 2; + public const int SCAN_FLAGS_NO_TRYCATCH = 4; + + public const int CALLBACK_MSG_RULE_MATCHING = 1; + public const int CALLBACK_MSG_RULE_NOT_MATCHING = 2; + public const int CALLBACK_MSG_SCAN_FINISHED = 3; + public const int CALLBACK_MSG_IMPORT_MODULE = 4; + public const int CALLBACK_MSG_MODULE_IMPORTED = 5; + + public const int RULE_GFLAGS_NULL = 0x1000; + + public const int RULE_FLAGS_NULL = 0x04; + + public const int STRING_FLAGS_LAST_IN_RULE = 0x1000; + + public const int META_FLAGS_LAST_IN_RULE = 1; + } +} diff --git a/segugio/libyara/Delegates.cs b/segugio/libyara/Delegates.cs new file mode 100644 index 0000000..c399a86 --- /dev/null +++ b/segugio/libyara/Delegates.cs @@ -0,0 +1,12 @@ +using System; +using System.Runtime.InteropServices; + +namespace dnYara.Interop +{ + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public delegate int YaraScanCallback( + IntPtr context, + int message, + IntPtr message_data, + IntPtr user_data); +} diff --git a/segugio/libyara/Enums/YR_CALLBACK_MESSAGE.cs b/segugio/libyara/Enums/YR_CALLBACK_MESSAGE.cs new file mode 100644 index 0000000..082e529 --- /dev/null +++ b/segugio/libyara/Enums/YR_CALLBACK_MESSAGE.cs @@ -0,0 +1,12 @@ +namespace dnYara.Interop +{ + public enum YR_CALLBACK_MESSAGE + : int + { + RuleMatching = Constants.CALLBACK_MSG_RULE_MATCHING, + RuleNotMatching = Constants.CALLBACK_MSG_RULE_NOT_MATCHING, + ScanFinished = Constants.CALLBACK_MSG_SCAN_FINISHED, + ImportModule = Constants.CALLBACK_MSG_IMPORT_MODULE, + ModuleImported = Constants.CALLBACK_MSG_MODULE_IMPORTED + }; +} \ No newline at end of file diff --git a/segugio/libyara/Enums/YR_CALLBACK_RESULT.cs b/segugio/libyara/Enums/YR_CALLBACK_RESULT.cs new file mode 100644 index 0000000..1b7d708 --- /dev/null +++ b/segugio/libyara/Enums/YR_CALLBACK_RESULT.cs @@ -0,0 +1,10 @@ +namespace dnYara.Interop +{ + public enum YR_CALLBACK_RESULT + : int + { + Continue = Constants.CALLBACK_CONTINUE, + Abort = Constants.CALLBACK_ABORT, + Error = Constants.CALLBACK_ERROR + } +} \ No newline at end of file diff --git a/segugio/libyara/Enums/YR_SCAN_FLAGS.cs b/segugio/libyara/Enums/YR_SCAN_FLAGS.cs new file mode 100644 index 0000000..813f82d --- /dev/null +++ b/segugio/libyara/Enums/YR_SCAN_FLAGS.cs @@ -0,0 +1,11 @@ +using System; + +namespace dnYara.Interop +{ + [Flags] + public enum YR_SCAN_FLAGS + { + None = 0, + Fast = Constants.SCAN_FLAGS_FAST_MODE + }; +} \ No newline at end of file diff --git a/segugio/libyara/Methods.cs b/segugio/libyara/Methods.cs new file mode 100644 index 0000000..a1dcf60 --- /dev/null +++ b/segugio/libyara/Methods.cs @@ -0,0 +1,437 @@ +using System; +using System.Runtime.InteropServices; + +namespace dnYara.Interop +{ + public class Methods + { + public const string YaraLibName = "libyara.dll"; + + + /// Return Type: int + ///rules: YR_RULES* + [DllImport(YaraLibName, EntryPoint = "yr_rules_destroy")] + //public static extern int yr_rules_destroy(ref YR_RULES rules); + public static extern int yr_rules_destroy(IntPtr rules); + + /// Return Type: int + ///compiler: YR_COMPILER* + ///file_name: char* + [DllImport(YaraLibName, EntryPoint = "_yr_compiler_push_file_name")] + public static extern int _yr_compiler_push_file_name( + IntPtr compiler, + [In, MarshalAs(UnmanagedType.LPStr)] string file_name); + + + /// Return Type: void + ///compiler: YR_COMPILER* + [DllImport(YaraLibName, EntryPoint = "_yr_compiler_pop_file_name")] + public static extern void _yr_compiler_pop_file_name(IntPtr compiler); + + + /// Return Type: char* + ///include_name: char* + ///calling_rule_filename: char* + ///calling_rule_namespace: char* + ///user_data: void* + [DllImport(YaraLibName, EntryPoint = "_yr_compiler_default_include_callback")] + public static extern IntPtr _yr_compiler_default_include_callback( + [In, MarshalAs(UnmanagedType.LPStr)] string include_name, + [In, MarshalAs(UnmanagedType.LPStr)] string calling_rule_filename, + [In, MarshalAs(UnmanagedType.LPStr)] string calling_rule_namespace, + IntPtr user_data); + + + /// Return Type: int + ///compiler: YR_COMPILER** + [DllImport(YaraLibName, EntryPoint = "yr_compiler_create")] + public static extern YARA_ERROR yr_compiler_create(out IntPtr compiler); + + + /// Return Type: void + ///compiler: YR_COMPILER* + [DllImport(YaraLibName, EntryPoint = "yr_compiler_destroy")] + public static extern void yr_compiler_destroy(IntPtr compiler); + + + /// Return Type: void + ///compiler: YR_COMPILER* + ///callback: YR_COMPILER_CALLBACK_FUNC + ///user_data: void* + [DllImport(YaraLibName, EntryPoint = "yr_compiler_set_callback")] + public static extern void yr_compiler_set_callback( + IntPtr compiler, + YR_COMPILER_CALLBACK_FUNC callback, + IntPtr user_data); + + + /// Return Type: void + ///compiler: YR_COMPILER* + ///include_callback: YR_COMPILER_INCLUDE_CALLBACK_FUNC + ///include_free: YR_COMPILER_INCLUDE_FREE_FUNC + ///user_data: void* + [DllImport(YaraLibName, EntryPoint = "yr_compiler_set_include_callback")] + public static extern void yr_compiler_set_include_callback( + IntPtr compiler, + YR_COMPILER_INCLUDE_CALLBACK_FUNC include_callback, + YR_COMPILER_INCLUDE_FREE_FUNC include_free, + IntPtr user_data); + + + /// Return Type: void + ///compiler: YR_COMPILER* + ///re_ast_callback: YR_COMPILER_RE_AST_CALLBACK_FUNC + ///user_data: void* + [DllImport(YaraLibName, EntryPoint = "yr_compiler_set_re_ast_callback")] + public static extern void yr_compiler_set_re_ast_callback( + IntPtr compiler, + YR_COMPILER_RE_AST_CALLBACK_FUNC re_ast_callback, + IntPtr user_data); + + + /// Return Type: void + ///compiler: YR_COMPILER* + ///table: void* + ///entries: int + ///warning_threshold: unsigned char + [DllImport(YaraLibName, EntryPoint = "yr_compiler_set_atom_quality_table")] + public static extern void yr_compiler_set_atom_quality_table(IntPtr compiler, IntPtr table, int entries, byte warning_threshold); + + + /// Return Type: int + ///compiler: YR_COMPILER* + ///filename: char* + ///warning_threshold: unsigned char + [DllImport(YaraLibName, EntryPoint = "yr_compiler_load_atom_quality_table")] + public static extern int yr_compiler_load_atom_quality_table( + IntPtr compiler, + [In, MarshalAs(UnmanagedType.LPStr)] string filename, + byte warning_threshold); + + + /// Return Type: int + ///compiler: YR_COMPILER* + ///rules_file: FILE* + ///namespace_: char* + ///file_name: char* + [DllImport(YaraLibName, EntryPoint = "yr_compiler_add_file", SetLastError = false)] + public static extern int yr_compiler_add_file( + IntPtr compilerPtr, + IntPtr filePtr, + [In, MarshalAs(UnmanagedType.LPStr)] string namespace_, + [In, MarshalAs(UnmanagedType.LPStr)] string file_name); + + + /// Return Type: int + ///compiler: YR_COMPILER* + ///rules_fd: HANDLE->void* + ///namespace_: char* + ///file_name: char* + [DllImport(YaraLibName, EntryPoint = "yr_compiler_add_fd")] + public static extern int yr_compiler_add_fd( + IntPtr compiler, + IntPtr rules_fd, + [In, MarshalAs(UnmanagedType.LPStr)] string namespace_, + [In, MarshalAs(UnmanagedType.LPStr)] string file_name); + + + /// Return Type: int + ///compiler: YR_COMPILER* + ///rules_string: char* + ///namespace_: char* + [DllImport(YaraLibName, EntryPoint = "yr_compiler_add_string")] + public static extern int yr_compiler_add_string( + IntPtr compilerPtr, + [In, MarshalAs(UnmanagedType.LPStr)] string rules_string, + [In, MarshalAs(UnmanagedType.LPStr)] string namespace_); + + + /// Return Type: char* + ///compiler: YR_COMPILER* + ///buffer: char* + ///buffer_size: int + [DllImport(YaraLibName, EntryPoint = "yr_compiler_get_error_message")] + public static extern IntPtr yr_compiler_get_error_message(IntPtr compiler, IntPtr buffer, int buffer_size); + + + /// Return Type: char* + ///compiler: YR_COMPILER* + [DllImport(YaraLibName, EntryPoint = "yr_compiler_get_current_file_name")] + public static extern IntPtr yr_compiler_get_current_file_name(IntPtr compiler); + + + /// Return Type: int + ///compiler: YR_COMPILER* + ///identifier: char* + ///value: int64_t + [DllImport(YaraLibName, EntryPoint = "yr_compiler_define_integer_variable")] + public static extern YARA_ERROR yr_compiler_define_integer_variable( + IntPtr compiler, + [In, MarshalAs(UnmanagedType.LPStr)] string identifier, + long value); + + + /// Return Type: int + ///compiler: YR_COMPILER* + ///identifier: char* + ///value: int + [DllImport(YaraLibName, EntryPoint = "yr_compiler_define_boolean_variable")] + public static extern YARA_ERROR yr_compiler_define_boolean_variable( + IntPtr compiler, + [In, MarshalAs(UnmanagedType.LPStr)] string identifier, + int value); + + + /// Return Type: int + ///compiler: YR_COMPILER* + ///identifier: char* + ///value: double + [DllImport(YaraLibName, EntryPoint = "yr_compiler_define_float_variable")] + public static extern YARA_ERROR yr_compiler_define_float_variable( + IntPtr compiler, + [In, MarshalAs(UnmanagedType.LPStr)] string identifier, + double value); + + + /// Return Type: int + ///compiler: YR_COMPILER* + ///identifier: char* + ///value: char* + [DllImport(YaraLibName, EntryPoint = "yr_compiler_define_string_variable")] + public static extern YARA_ERROR yr_compiler_define_string_variable( + IntPtr compiler, + [In, MarshalAs(UnmanagedType.LPStr)] string identifier, + [In, MarshalAs(UnmanagedType.LPStr)] string value); + + + /// Return Type: int + ///compiler: YR_COMPILER* + ///rules: YR_RULES** + [DllImport(YaraLibName, EntryPoint = "yr_compiler_get_rules")] + public static extern YARA_ERROR yr_compiler_get_rules( + IntPtr compilerPtr, + ref IntPtr rules); + + + [DllImport(YaraLibName, CallingConvention = CallingConvention.Cdecl)] + public static extern string _yr_compiler_default_include_callback( + string include_name, + string calling_rule_filename, + string calling_rule_namespace, + uint user_data); + + [DllImport(YaraLibName, CallingConvention = CallingConvention.Cdecl)] + public static extern YARA_ERROR yr_initialize(); + + [DllImport(YaraLibName, CallingConvention = CallingConvention.Cdecl)] + public static extern void yr_finalize(); + + + /// Return Type: void + [DllImport(YaraLibName, EntryPoint = "yr_finalize_thread")] + public static extern void yr_finalize_thread(); + + + /// Return Type: int + [DllImport(YaraLibName, EntryPoint = "yr_get_tidx")] + public static extern int yr_get_tidx(); + + + /// Return Type: void + ///param0: int + [DllImport(YaraLibName, EntryPoint = "yr_set_tidx")] + public static extern void yr_set_tidx(int tidx); + + + /// Return Type: int + ///param0: YR_CONFIG_NAME->_YR_CONFIG_NAME + ///param1: void* + [DllImport(YaraLibName, EntryPoint = "yr_set_configuration")] + public static extern int yr_set_configuration(YR_CONFIG_NAME name, IntPtr src); + + + /// Return Type: int + ///param0: YR_CONFIG_NAME->_YR_CONFIG_NAME + ///param1: void* + [DllImport(YaraLibName, EntryPoint = "yr_get_configuration")] + public static extern int yr_get_configuration(YR_CONFIG_NAME name, IntPtr src); + + /// Return Type: int + ///rules: YR_RULES* + ///buffer: uint8_t* + ///buffer_size: size_t->unsigned __int64 + ///flags: int + ///callback: YR_CALLBACK_FUNC + ///user_data: void* + ///timeout: int + [DllImport(YaraLibName, EntryPoint = "yr_rules_scan_mem")] + public static extern YARA_ERROR yr_rules_scan_mem( + IntPtr rulesPtr, + IntPtr buffer, + ulong buffer_size, + int flags, + [MarshalAs(UnmanagedType.FunctionPtr)] + YR_CALLBACK_FUNC callback, + IntPtr user_data, + int timeout); + + /// int yr_rules_save(YR_RULES* rules, const char* filename) + ///timeout: int + [DllImport(YaraLibName, EntryPoint = "yr_rules_save")] + public static extern YARA_ERROR yr_rules_save( + IntPtr rulesPtr, + [In, MarshalAs(UnmanagedType.LPStr)] string filename); + + /// int yr_rules_save(YR_RULES* rules, const char* filename) + ///timeout: int + [DllImport(YaraLibName, EntryPoint = "yr_rules_load")] + public static extern YARA_ERROR yr_rules_load( + [In, MarshalAs(UnmanagedType.LPStr)] string filename, + ref IntPtr rulesPtr); + + /// Return Type: int + ///rules: YR_RULES* + ///pid: int + ///flags: int + ///callback: YR_CALLBACK_FUNC + ///user_data: void* + ///timeout: int + [DllImport(YaraLibName, EntryPoint = "yr_rules_scan_proc")] + public static extern YARA_ERROR yr_rules_scan_proc( + IntPtr rules, + int pid, int flags, + YR_CALLBACK_FUNC callback, + IntPtr user_data, + int timeout); + + + /// Return Type: int + ///rules: YR_RULES* + ///filename: char* + ///flags: int + ///callback: YR_CALLBACK_FUNC + ///user_data: void* + ///timeout: int + [DllImport(YaraLibName, EntryPoint = "yr_rules_scan_file")] + public static extern YARA_ERROR yr_rules_scan_file( + IntPtr rules, + [In, MarshalAs(UnmanagedType.LPStr)] string filename, + int flags, + YR_CALLBACK_FUNC callback, + IntPtr user_data, + int timeout); + + + + /// Return Type: int + ///rules: YR_RULES* + ///scanner: YR_SCAN_CONTEXT** + [DllImport(YaraLibName, EntryPoint = "yr_scanner_create")] + public static extern YARA_ERROR yr_scanner_create( + IntPtr rules, + out IntPtr scanner); + + + /// Return Type: int + ///scanner: YR_SCAN_CONTEXT* + [DllImport(YaraLibName, EntryPoint = "yr_scanner_destroy")] + public static extern YARA_ERROR yr_scanner_destroy( + IntPtr scanner); + + + /// Return Type: void + ///scanner: YR_SCAN_CONTEXT* + ///callback: YR_CALLBACK_FUNC + ///user_data: void* + [DllImport(YaraLibName, EntryPoint = "yr_scanner_set_callback")] + public static extern void yr_scanner_set_callback( + IntPtr scanner, + YR_CALLBACK_FUNC callback, + IntPtr user_data + ); + + + /// Return Type: int + ///scanner: YR_SCAN_CONTEXT* + ///timeout: int + [DllImport(YaraLibName, EntryPoint = "yr_scanner_set_timeout")] + public static extern void yr_scanner_set_timeout( + IntPtr scanner, + int timeout); + + + /// Return Type: void + ///scanner: YR_SCAN_CONTEXT* + ///flags: int + [DllImport(YaraLibName, EntryPoint = "yr_scanner_set_flags")] + public static extern void yr_scanner_set_flags( + IntPtr scanner, + int flags); + + + /// Return Type: int + ///scanner: YR_SCAN_CONTEXT* + ///identifier: char* + ///value: long + [DllImport(YaraLibName, EntryPoint = "yr_scanner_define_integer_variable")] + public static extern YARA_ERROR yr_scanner_define_integer_variable( + IntPtr scanner, + [In, MarshalAs(UnmanagedType.LPStr)] string identifier, + long value); + + + /// Return Type: int + ///scanner: YR_SCAN_CONTEXT* + ///identifier: char* + ///value: int + [DllImport(YaraLibName, EntryPoint = "yr_scanner_define_boolean_variable")] + public static extern YARA_ERROR yr_scanner_define_boolean_variable( + IntPtr scanner, + [In, MarshalAs(UnmanagedType.LPStr)] string identifier, + int value); + + + /// Return Type: int + ///scanner: YR_SCAN_CONTEXT* + ///identifier: char* + ///value: double + [DllImport(YaraLibName, EntryPoint = "yr_scanner_define_float_variable")] + public static extern YARA_ERROR yr_scanner_define_float_variable( + IntPtr scanner, + [In, MarshalAs(UnmanagedType.LPStr)] string identifier, + double value); + + + /// Return Type: int + ///scanner: YR_SCAN_CONTEXT* + ///identifier: char* + ///value: char* + [DllImport(YaraLibName, EntryPoint = "yr_scanner_define_string_variable")] + public static extern YARA_ERROR yr_scanner_define_string_variable( + IntPtr scanner, + [In, MarshalAs(UnmanagedType.LPStr)] string identifier, + [In, MarshalAs(UnmanagedType.LPStr)] string value + ); + + + /// Return Type: int + ///scanner: YR_SCAN_CONTEXT* + ///buffer: const uint8_t* + ///buffer_size: size_t + [DllImport(YaraLibName, EntryPoint = "yr_scanner_scan_mem")] + public static extern YARA_ERROR yr_scanner_scan_mem( + IntPtr scanner, + IntPtr buffer, + ulong buffer_size); + + + /// Return Type: int + ///scanner: YR_SCAN_CONTEXT* + ///filename: char* + [DllImport(YaraLibName, EntryPoint = "yr_scanner_scan_file")] + public static extern YARA_ERROR yr_scanner_scan_file( + IntPtr scanner, + [In, MarshalAs(UnmanagedType.LPStr)] string filename); + + } +} diff --git a/segugio/libyara/ObjRefHelper.cs b/segugio/libyara/ObjRefHelper.cs new file mode 100644 index 0000000..a96608d --- /dev/null +++ b/segugio/libyara/ObjRefHelper.cs @@ -0,0 +1,165 @@ +using System; +using System.Diagnostics; +using System.Collections.Generic; +using System.Runtime.InteropServices; +using System.Linq; + +namespace dnYara.Interop +{ + public static class ObjRefHelper + { + private static int POINTER_SIZE = Marshal.SizeOf(IntPtr.Zero); + + /// calculates the C-array offset for a struct of type `T` at index `index` + private static int OffsetFor(int index) => index * Marshal.SizeOf(typeof(T)); + + private static T IndexedGet(IntPtr array_start, int index) { + var array_offset = OffsetFor(index); + var struct_at_index = (T)Marshal.PtrToStructure(array_start + array_offset, typeof(T)); + return struct_at_index; + } + + private static bool IsNull(IntPtr p) => p == IntPtr.Zero; + + /// iterates over a linked-list of YR_STRINGs, starting from a given location. + /// performs the equivalent of `yr_rule_strings_foreach`. + public static IEnumerable GetYaraStrings(IntPtr ref_obj) => + EachStructOfTInObjRef( + ref_obj, + Yes, + ((ptr, yrString) => NullIfPredicateElseStructSize(StringIsLastInRule, ptr, yrString)) + ); + + private static bool MetaIsLastInRule(YR_META m) => (m.flags & Constants.META_FLAGS_LAST_IN_RULE) != 0; + + private static bool StringIsLastInRule(YR_STRING str) => (str.flags & Constants.STRING_FLAGS_LAST_IN_RULE) != 0; + + public static IEnumerable IterateCStrings(IntPtr ref_obj) + { + string currentString; + for ( + IntPtr stringPtr = ref_obj; + SafeMarshalString(stringPtr, out currentString); + stringPtr += currentString.Length + 1) + { + yield return currentString; + } + } + + /// Incrementer that bumps an IntPtr by the size of the struct it represents + private static IntPtr IncrementByStructSize(IntPtr prev, T instance) => prev + Marshal.SizeOf(typeof(T)); + + private static IntPtr NullIfPredicateElseStructSize(Func predicate, IntPtr basePtr, T instance) { + if(predicate(instance)){ + return IntPtr.Zero; + } + return IncrementByStructSize(basePtr, instance); + } + + /// helper function that is true for all input + private static bool Yes(T item) => true; + + /// walks a variable-sized array of pointers of type T, marshalling and running a custom validation function on each iteration of the pointer + /// This is an abstraction around specialized loops like `ForEachYaraMetaInObjRef` + public static IEnumerable EachStructOfTInObjRef(IntPtr ref_obj, Func validityChecker, Func incrementer) where T : struct + { + T structPtr; + for ( + IntPtr structArrayPtr = ref_obj; + MarshalAndValidate(structArrayPtr, validityChecker, out structPtr); + structArrayPtr = incrementer(structArrayPtr, structPtr) + ) + { + yield return structPtr; + } + } + + public static IEnumerable GetRules(IntPtr rulesPtr) => + EachStructOfTInObjRef( + rulesPtr, + (rule => !RuleIsNull(rule)), + IncrementByStructSize + ); + + + private static bool MetaIsNull(YR_META m) => m.type == (int)META_TYPE.META_TYPE_NULL; + + public static IEnumerable GetMetas(IntPtr yrMetasPtr) => + EachStructOfTInObjRef( + yrMetasPtr, + Yes, + (ptr, meta) => NullIfPredicateElseStructSize(MetaIsLastInRule, ptr, meta) + ); + + public static string ReadYaraString(YR_STRING s) + { + string outStr; + SafeMarshalString(s.identifier, out outStr); + return outStr; + } + + /// implements the header-only function`yr_string_matches_foreach` for iterating through + /// matches in a scan. + public static IEnumerable GetStringMatches(IntPtr matches, YR_STRING str) + { + var string_matches = IndexedGet(matches, (int)str.idx); + + return + EachStructOfTInObjRef(string_matches.head, + Yes, + ((ptr, m) => m.next) + ) + .Where(m => !m.is_private); + } + + private static YR_MATCH GetMatchFromObjRef(IntPtr objRef) + { + try + { + YR_MATCH yrMatch = (YR_MATCH)Marshal.PtrToStructure(objRef, typeof(YR_MATCH)); + return yrMatch; + } + catch + { + Debug.WriteLine($"Error for Match : {objRef}"); + return default; + } + } + + private static bool MarshalAndValidate(IntPtr struct_ptr, Func validityChecker, out T destination_ptr) where T : struct + { + destination_ptr = default(T); + if (IsNull(struct_ptr)) + { + return false; + } + + destination_ptr = (T)Marshal.PtrToStructure(struct_ptr, typeof(T)); + return validityChecker(destination_ptr); + } + + private static bool SafeMarshalString(IntPtr cstring_ptr, out string stringContent) + { + + stringContent = null; + if (IsNull(cstring_ptr)) + return false; + + stringContent = Marshal.PtrToStringAnsi(cstring_ptr); + if (string.IsNullOrEmpty(stringContent)) + return false; + + return true; + } + + // replicates the RULE_IS_NULL check from the types.h module of yara. + // used in rule iteration. + private static bool RuleIsNull(YR_RULE rule) => (rule.flags & Constants.RULE_FLAGS_NULL) != 0; + + public static Nullable TryGetProfilingInfoForRule(IntPtr profilingInfoPtr, int rule_index) { + if(IsNull(profilingInfoPtr)) return null; + + return IndexedGet(profilingInfoPtr, rule_index); + } + } +} diff --git a/segugio/libyara/Types/FILE.cs b/segugio/libyara/Types/FILE.cs new file mode 100644 index 0000000..280baf6 --- /dev/null +++ b/segugio/libyara/Types/FILE.cs @@ -0,0 +1,14 @@ +using System; +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential)] + public struct FILE + { + /// void* + public IntPtr _Placeholder; + } + +} diff --git a/segugio/libyara/Types/RE_AST.cs b/segugio/libyara/Types/RE_AST.cs new file mode 100644 index 0000000..7950ece --- /dev/null +++ b/segugio/libyara/Types/RE_AST.cs @@ -0,0 +1,19 @@ +using System; +using System.Runtime.InteropServices; + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential)] + public struct RE_AST + { + /// unsigned int + public uint flags; + + /// unsigned short + public ushort levels; + + /// RE_NODE* + public IntPtr root_node; + } + +} diff --git a/segugio/libyara/Types/RE_CLASS.cs b/segugio/libyara/Types/RE_CLASS.cs new file mode 100644 index 0000000..be8e4ae --- /dev/null +++ b/segugio/libyara/Types/RE_CLASS.cs @@ -0,0 +1,18 @@ +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public struct RE_CLASS + { + + /// unsigned char + public byte negated; + + /// unsigned char[32] + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)] + public string bitmap; + } + +} diff --git a/segugio/libyara/Types/RE_NODE.cs b/segugio/libyara/Types/RE_NODE.cs new file mode 100644 index 0000000..b635494 --- /dev/null +++ b/segugio/libyara/Types/RE_NODE.cs @@ -0,0 +1,41 @@ +using System; +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential)] + public struct RE_NODE + { + + /// int + public int type; + + /// Anonymous_04e35de7_8a47_45f8_a2a4_86258eafb8fd + public RE_NODE_UNION1 Union1; + + /// Anonymous_8068bfc1_65a4_42a4_aae3_8bdcc7b56eb9 + public RE_NODE_UNION2 Union2; + + /// int + public int greedy; + + /// RE_CLASS* + public IntPtr re_class; + + /// RE_NODE* + public IntPtr left; + + /// RE_NODE* + public IntPtr right; + + /// unsigned char* + [MarshalAs(UnmanagedType.LPStr)] + public string forward_code; + + /// unsigned char* + [MarshalAs(UnmanagedType.LPStr)] + public string backward_code; + } + +} diff --git a/segugio/libyara/Types/RE_NODE_UNION1.cs b/segugio/libyara/Types/RE_NODE_UNION1.cs new file mode 100644 index 0000000..4863b2d --- /dev/null +++ b/segugio/libyara/Types/RE_NODE_UNION1.cs @@ -0,0 +1,23 @@ +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Explicit)] + public struct RE_NODE_UNION1 + { + + /// int + [FieldOffset(0)] + public int value; + + /// int + [FieldOffset(0)] + public int count; + + /// int + [FieldOffset(0)] + public int start; + } + +} diff --git a/segugio/libyara/Types/RE_NODE_UNION2.cs b/segugio/libyara/Types/RE_NODE_UNION2.cs new file mode 100644 index 0000000..d79bc27 --- /dev/null +++ b/segugio/libyara/Types/RE_NODE_UNION2.cs @@ -0,0 +1,19 @@ +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Explicit)] + public struct RE_NODE_UNION2 + { + + /// int + [FieldOffset(0)] + public int mask; + + /// int + [FieldOffset(0)] + public int end; + } + +} diff --git a/segugio/libyara/Types/SETJMP_FLOAT128.cs b/segugio/libyara/Types/SETJMP_FLOAT128.cs new file mode 100644 index 0000000..b7a08da --- /dev/null +++ b/segugio/libyara/Types/SETJMP_FLOAT128.cs @@ -0,0 +1,14 @@ +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential)] + public struct SETJMP_FLOAT128 + { + /// unsigned __int64[2] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2, ArraySubType = UnmanagedType.U8)] + public ulong[] Part; + } + +} diff --git a/segugio/libyara/Types/Types.cs b/segugio/libyara/Types/Types.cs new file mode 100644 index 0000000..c2c7e23 --- /dev/null +++ b/segugio/libyara/Types/Types.cs @@ -0,0 +1,67 @@ +using System; +using System.Runtime.InteropServices; + +namespace dnYara.Interop +{ + public enum META_TYPE + { + META_TYPE_NULL = 0, + META_TYPE_INTEGER = 1, + META_TYPE_STRING = 2, + META_TYPE_BOOLEAN = 3 + } + + /// Return Type: void + ///error_level: int + ///file_name: char* + ///line_number: int + ///rule: YR_RULE* + ///message: char* + ///user_data: void* + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + public delegate void YR_COMPILER_CALLBACK_FUNC( + int error_level, + [In, MarshalAs(UnmanagedType.LPStr)] string file_name, + int line_number, + IntPtr rule, + [In()] [MarshalAs(UnmanagedType.LPStr)] string message, + IntPtr user_data + ); + + /// Return Type: char* + ///include_name: char* + ///calling_rule_filename: char* + ///calling_rule_namespace: char* + ///user_data: void* + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + public delegate IntPtr YR_COMPILER_INCLUDE_CALLBACK_FUNC([In, MarshalAs(UnmanagedType.LPStr)] string include_name, [In()] [MarshalAs(UnmanagedType.LPStr)] string calling_rule_filename, [In()] [MarshalAs(UnmanagedType.LPStr)] string calling_rule_namespace, IntPtr user_data); + + /// Return Type: void + ///callback_result_ptr: char* + ///user_data: void* + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + public delegate void YR_COMPILER_INCLUDE_FREE_FUNC([In, MarshalAs(UnmanagedType.LPStr)] string callback_result_ptr, IntPtr user_data); + + /// Return Type: void + ///rule: YR_RULE* + ///string_identifier: char* + ///re_ast: RE_AST* + ///user_data: void* + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + public delegate void YR_COMPILER_RE_AST_CALLBACK_FUNC(ref YR_RULE rule, [In, MarshalAs(UnmanagedType.LPStr)] string string_identifier, ref RE_AST re_ast, IntPtr user_data); + + /// Return Type: int + ///message: int + ///message_data: void* + ///user_data: void* + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + public delegate YR_CALLBACK_RESULT YR_CALLBACK_FUNC(System.IntPtr context, int message, System.IntPtr message_data, System.IntPtr user_data); + + /// Return Type: int + ///config: YR_ATOMS_CONFIG* + ///atom: unsigned char* + ///atom_length: int + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + public delegate int YR_ATOMS_QUALITY_FUNC(ref YR_ATOMS_CONFIG config, IntPtr atom, int atom_length); + +} diff --git a/segugio/libyara/Types/YARA_ERROR.cs b/segugio/libyara/Types/YARA_ERROR.cs new file mode 100644 index 0000000..3cb8eff --- /dev/null +++ b/segugio/libyara/Types/YARA_ERROR.cs @@ -0,0 +1,65 @@ +namespace dnYara.Interop +{ + public enum YARA_ERROR : int + { + SUCCESS = 0, + ERROR_INSUFFICIENT_MEMORY = 1, + ERROR_COULD_NOT_ATTACH_TO_PROCESS = 2, + ERROR_COULD_NOT_OPEN_FILE = 3, + ERROR_COULD_NOT_MAP_FILE = 4, + ERROR_INVALID_FILE = 6, + ERROR_CORRUPT_FILE = 7, + ERROR_UNSUPPORTED_FILE_VERSION = 8, + ERROR_INVALID_REGULAR_EXPRESSION = 9, + ERROR_INVALID_HEX_STRING = 10, + ERROR_SYNTAX_ERROR = 11, + ERROR_LOOP_NESTING_LIMIT_EXCEEDED = 12, + ERROR_DUPLICATED_LOOP_IDENTIFIER = 13, + ERROR_DUPLICATED_IDENTIFIER = 14, + ERROR_DUPLICATED_TAG_IDENTIFIER = 15, + ERROR_DUPLICATED_META_IDENTIFIER = 16, + ERROR_DUPLICATED_STRING_IDENTIFIER = 17, + ERROR_UNREFERENCED_STRING = 18, + ERROR_UNDEFINED_STRING = 19, + ERROR_UNDEFINED_IDENTIFIER = 20, + ERROR_MISPLACED_ANONYMOUS_STRING = 21, + ERROR_INCLUDES_CIRCULAR_REFERENCE = 22, + ERROR_INCLUDE_DEPTH_EXCEEDED = 23, + ERROR_WRONG_TYPE = 24, + ERROR_EXEC_STACK_OVERFLOW = 25, + ERROR_SCAN_TIMEOUT = 26, + ERROR_TOO_MANY_SCAN_THREADS = 27, + ERROR_CALLBACK_ERROR = 28, + ERROR_INVALID_ARGUMENT = 29, + ERROR_TOO_MANY_MATCHES = 30, + ERROR_INTERNAL_FATAL_ERROR = 31, + ERROR_NESTED_FOR_OF_LOOP = 32, + ERROR_INVALID_FIELD_NAME = 33, + ERROR_UNKNOWN_MODULE = 34, + ERROR_NOT_A_STRUCTURE = 35, + ERROR_NOT_INDEXABLE = 36, + ERROR_NOT_A_FUNCTION = 37, + ERROR_INVALID_FORMAT = 38, + ERROR_TOO_MANY_ARGUMENTS = 39, + ERROR_WRONG_ARGUMENTS = 40, + ERROR_WRONG_RETURN_TYPE = 41, + ERROR_DUPLICATED_STRUCTURE_MEMBER = 42, + ERROR_EMPTY_STRING = 43, + ERROR_DIVISION_BY_ZERO = 44, + ERROR_REGULAR_EXPRESSION_TOO_LARGE = 45, + ERROR_TOO_MANY_RE_FIBERS = 46, + ERROR_COULD_NOT_READ_PROCESS_MEMORY = 47, + ERROR_INVALID_EXTERNAL_VARIABLE_TYPE = 48, + ERROR_REGULAR_EXPRESSION_TOO_COMPLEX = 49, + ERROR_INVALID_MODULE_NAME = 50, + ERROR_TOO_MANY_STRINGS = 51, + ERROR_INTEGER_OVERFLOW = 52, + ERROR_CALLBACK_REQUIRED = 53, + ERROR_INVALID_OPERAND = 54, + ERROR_COULD_NOT_READ_FILE = 55, + ERROR_DUPLICATED_EXTERNAL_VARIABLE = 56, + ERROR_INVALID_MODULE_DATA = 57, + ERROR_WRITING_FILE = 58 + } + +} diff --git a/segugio/libyara/Types/YR_AC_MATCH.cs b/segugio/libyara/Types/YR_AC_MATCH.cs new file mode 100644 index 0000000..cfa7da5 --- /dev/null +++ b/segugio/libyara/Types/YR_AC_MATCH.cs @@ -0,0 +1,27 @@ +using System; +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential)] + public struct YR_AC_MATCH + { + + /// uint16_t->unsigned short + public ushort backtrack; + + /// Anonymous_322d3d81_44e2_4124_aab1_d6999178ed23 + public IntPtr Union1; + + /// Anonymous_bd9ed406_ce78_4bea_b418_cf28493d2328 + public IntPtr Union2; + + /// Anonymous_76fe19f7_2b22_4012_933d_b325bbddf15a + public IntPtr Union3; + + /// Anonymous_2b90270d_a194_4dd5_b795_9b8f91840a31 + public IntPtr Union4; + } + +} diff --git a/segugio/libyara/Types/YR_AC_MATCH_TABLE_ENTRY.cs b/segugio/libyara/Types/YR_AC_MATCH_TABLE_ENTRY.cs new file mode 100644 index 0000000..3b18495 --- /dev/null +++ b/segugio/libyara/Types/YR_AC_MATCH_TABLE_ENTRY.cs @@ -0,0 +1,16 @@ +using System; +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential)] + public struct YR_AC_MATCH_TABLE_ENTRY + { + + /// Anonymous_0834463e_e0f1_47aa_bb60_49885c0e00c3 + //public YR_OBJ_REF Union1; + public IntPtr Union1; + } + +} diff --git a/segugio/libyara/Types/YR_ARENA.cs b/segugio/libyara/Types/YR_ARENA.cs new file mode 100644 index 0000000..a0857df --- /dev/null +++ b/segugio/libyara/Types/YR_ARENA.cs @@ -0,0 +1,21 @@ +using System; +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential)] + public struct YR_ARENA + { + + /// int + public int flags; + + /// YR_ARENA_PAGE* + public IntPtr page_list_head; + + /// YR_ARENA_PAGE* + public IntPtr current_page; + } + +} diff --git a/segugio/libyara/Types/YR_ARENA_PAGE.cs b/segugio/libyara/Types/YR_ARENA_PAGE.cs new file mode 100644 index 0000000..c79c57b --- /dev/null +++ b/segugio/libyara/Types/YR_ARENA_PAGE.cs @@ -0,0 +1,38 @@ +using System; +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential)] + public struct YR_ARENA_PAGE + { + + /// uint8_t* + [MarshalAs(UnmanagedType.LPStr)] + public string new_address; + + /// uint8_t* + [MarshalAs(UnmanagedType.LPStr)] + public string address; + + /// size_t->unsigned __int64 + public ulong size; + + /// size_t->unsigned __int64 + public ulong used; + + /// YR_RELOC* + public IntPtr reloc_list_head; + + /// YR_RELOC* + public IntPtr reloc_list_tail; + + /// _YR_ARENA_PAGE* + public IntPtr next; + + /// _YR_ARENA_PAGE* + public IntPtr prev; + } + +} diff --git a/segugio/libyara/Types/YR_ATOMS_CONFIG.cs b/segugio/libyara/Types/YR_ATOMS_CONFIG.cs new file mode 100644 index 0000000..b85e6df --- /dev/null +++ b/segugio/libyara/Types/YR_ATOMS_CONFIG.cs @@ -0,0 +1,28 @@ +using System; +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential)] + public struct YR_ATOMS_CONFIG + { + + /// YR_ATOMS_QUALITY_FUNC + public YR_ATOMS_QUALITY_FUNC get_atom_quality; + + /// YR_ATOM_QUALITY_TABLE_ENTRY* + public IntPtr quality_table; + + /// int + public int quality_warning_threshold; + + /// int + public int quality_table_entries; + + /// boolean + [MarshalAs(UnmanagedType.I1)] + public bool free_quality_table; + } + +} diff --git a/segugio/libyara/Types/YR_ATOM_QUALITY_TABLE_ENTRY.cs b/segugio/libyara/Types/YR_ATOM_QUALITY_TABLE_ENTRY.cs new file mode 100644 index 0000000..267cbc1 --- /dev/null +++ b/segugio/libyara/Types/YR_ATOM_QUALITY_TABLE_ENTRY.cs @@ -0,0 +1,18 @@ +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public struct YR_ATOM_QUALITY_TABLE_ENTRY + { + + /// char[4] + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 4)] + public string atom; + + /// unsigned char + public byte quality; + } + +} diff --git a/segugio/libyara/Types/YR_COMPILER.cs b/segugio/libyara/Types/YR_COMPILER.cs new file mode 100644 index 0000000..92c3c05 --- /dev/null +++ b/segugio/libyara/Types/YR_COMPILER.cs @@ -0,0 +1,116 @@ +using System; +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public struct YR_COMPILER + { + public int errors; + public int current_line; + public int last_error; + public int last_error_line; + + /// _SETJMP_FLOAT128[16] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] + public SETJMP_FLOAT128[] error_recovery; + + public IntPtr sz_arena; + public IntPtr rules_arena; + public IntPtr strings_arena; + public IntPtr code_arena; + public IntPtr re_code_arena; + public IntPtr compiled_rules_arena; + public IntPtr externals_arena; + public IntPtr namespaces_arena; + public IntPtr metas_arena; + public IntPtr matches_arena; + public IntPtr automaton_arena; + + public IntPtr automaton; + public IntPtr rules_table; + public IntPtr objects_table; + public IntPtr strings_table; + public IntPtr current_namespace; + public IntPtr current_rule; + + public IntPtr fixup_stack_head; + + /// int + public int namespaces_count; + + /// unsigned char*[4] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.YR_MAX_LOOP_NESTING, ArraySubType = UnmanagedType.SysUInt)] + public IntPtr[] loop_address; + + /// char*[4] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.YR_MAX_LOOP_NESTING, ArraySubType = UnmanagedType.SysUInt)] + public IntPtr[] loop_identifier; + + /// int + public int loop_depth; + + /// int + public int loop_for_of_mem_offset; + + /// char*[16] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.YR_MAX_INCLUDE_DEPTH, ArraySubType = UnmanagedType.SysUInt)] + public IntPtr[] file_name_stack; + + /// int + public int file_name_stack_ptr; + + /// char[256] + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Constants.YR_MAX_COMPILER_ERROR_EXTRA_INFO)] + public string last_error_extra_info; + + /// char[8192] + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Constants.YR_LEX_BUF_SIZE)] + public string lex_buf; + + /// char* + public IntPtr lex_buf_ptr; + + /// unsigned short + public ushort lex_buf_len; + + /// char[260] + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Constants.MAX_PATH)] + public string include_base_dir; + + /// void* + public IntPtr user_data; + + /// void* + public IntPtr incl_clbk_user_data; + + /// void* + public IntPtr re_ast_clbk_user_data; + + + + + /// YR_COMPILER_CALLBACK_FUNC + [MarshalAs(UnmanagedType.FunctionPtr)] + public YR_COMPILER_CALLBACK_FUNC callback; + //public int func1; + + /// YR_COMPILER_INCLUDE_CALLBACK_FUNC + [MarshalAs(UnmanagedType.FunctionPtr)] + public YR_COMPILER_INCLUDE_CALLBACK_FUNC include_callback; + + /// YR_COMPILER_INCLUDE_FREE_FUNC + [MarshalAs(UnmanagedType.FunctionPtr)] + public YR_COMPILER_INCLUDE_FREE_FUNC include_free; + + /// YR_COMPILER_RE_AST_CALLBACK_FUNC + [MarshalAs(UnmanagedType.FunctionPtr)] + public YR_COMPILER_RE_AST_CALLBACK_FUNC re_ast_callback; + + /// YR_ATOMS_CONFIG + public YR_ATOMS_CONFIG atoms_config; + + } + +} diff --git a/segugio/libyara/Types/YR_CONFIG_NAME.cs b/segugio/libyara/Types/YR_CONFIG_NAME.cs new file mode 100644 index 0000000..d090cdb --- /dev/null +++ b/segugio/libyara/Types/YR_CONFIG_NAME.cs @@ -0,0 +1,15 @@ +namespace dnYara.Interop +{ + public enum YR_CONFIG_NAME + { + + YR_CONFIG_STACK_SIZE, + + YR_CONFIG_MAX_STRINGS_PER_RULE, + + YR_CONFIG_MAX_MATCH_DATA, + + YR_CONFIG_LAST, + } + +} diff --git a/segugio/libyara/Types/YR_MATCH.cs b/segugio/libyara/Types/YR_MATCH.cs new file mode 100644 index 0000000..f3cc11e --- /dev/null +++ b/segugio/libyara/Types/YR_MATCH.cs @@ -0,0 +1,54 @@ +using System; +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + ///

+ /// Data structure representing a metadata value. + /// + [StructLayout(LayoutKind.Sequential)] + public struct YR_MATCH + { + + /// + /// Base offset/address for the match. While scanning a file this field is usually zero, while scanning a + /// process memory space this field is the virtual address of the memory block where the match was found. + /// + public long @base; + + /// + /// Offset of the match relative to base. + /// + public long offset; + + /// + /// Length of the matching string + /// + public int match_length; + + /// + /// Length of data buffer. data_length is the minimum of match_length and MAX_MATCH_DATA. + /// + public int data_length; + + /// Pointer to a buffer containing a portion of the matched data. The size of + /// the buffer is data_length. data_length is always <= length and is limited + /// to YR_CONFIG_MAX_MATCH_DATA bytes. + public IntPtr dataPtr; + + /// YR_MATCH* + public IntPtr prev; + + /// YR_MATCH* + public IntPtr next; + + /// If the match belongs to a chained string chain_length contains the + /// length of the chain. This field is used only in unconfirmed matches. + public int chain_length; + + /// True if this is match for a private string. + public bool is_private; + } + +} diff --git a/segugio/libyara/Types/YR_MATCHES.cs b/segugio/libyara/Types/YR_MATCHES.cs new file mode 100644 index 0000000..348f965 --- /dev/null +++ b/segugio/libyara/Types/YR_MATCHES.cs @@ -0,0 +1,22 @@ +using System; +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential)] + public struct YR_MATCHES + { + + /// Anonymous_28ff42bc_8abe_4b79_9a59_b52bac15297f + public IntPtr head; + + /// Anonymous_215b690c_5de2_45cc_beb5_cde3daeb9b5b + public IntPtr tail; + + /// int + public int count; + + } + +} diff --git a/segugio/libyara/Types/YR_META.cs b/segugio/libyara/Types/YR_META.cs new file mode 100644 index 0000000..0b123f8 --- /dev/null +++ b/segugio/libyara/Types/YR_META.cs @@ -0,0 +1,33 @@ +using System; +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + + /// + /// Data structure representing a metadata value. Based on `type`, zero or one of `integer` or `strings` will be filled, + /// and if `type` is `META_TYPE_BOOLEAN` then `integer` should be parsed as a boolean + /// + [StructLayout(LayoutKind.Sequential)] + public struct YR_META + { + /// + /// Meta identifier. + /// + public IntPtr identifier; + + public IntPtr strings; + + public long integer; + + /// + /// One of the following metadata types: + /// META_TYPE_NULL META_TYPE_INTEGER META_TYPE_STRING META_TYPE_BOOLEAN + /// + public int type; + + public int flags; + } + +} diff --git a/segugio/libyara/Types/YR_OBJ_REF.cs b/segugio/libyara/Types/YR_OBJ_REF.cs new file mode 100644 index 0000000..b0bf546 --- /dev/null +++ b/segugio/libyara/Types/YR_OBJ_REF.cs @@ -0,0 +1,20 @@ +using System; +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + //[StructLayout(LayoutKind.Explicit)] + //public struct YR_OBJ_REF + //{ + + // /// char* + // [FieldOffset(0)] + // public IntPtr objRef; + + // /// int + // [FieldOffset(0)] + // public long objRef__; + //} + +} diff --git a/segugio/libyara/Types/YR_PROFILING_INFO.cs b/segugio/libyara/Types/YR_PROFILING_INFO.cs new file mode 100644 index 0000000..9dd6d43 --- /dev/null +++ b/segugio/libyara/Types/YR_PROFILING_INFO.cs @@ -0,0 +1,24 @@ + +using System; +using System.Runtime.InteropServices; + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential)] + public struct YR_PROFILING_INFO + { + /// Number of times that some atom belonging to the rule matched. Each + /// matching atom means a potential string match that needs to be verified. + public uint atom_matches; + + // Amount of time (in nanoseconds) spent verifying atom matches for + // determining if the corresponding string actually matched or not. This + // time is not measured for all atom matches, only 1 out of 1024 matches + // are actually measured. + public ulong match_time; + + // Amount of time (in nanoseconds) spent evaluating the rule condition. + public ulong exec_time; + + } +} \ No newline at end of file diff --git a/segugio/libyara/Types/YR_RELOC.cs b/segugio/libyara/Types/YR_RELOC.cs new file mode 100644 index 0000000..4f0b2b3 --- /dev/null +++ b/segugio/libyara/Types/YR_RELOC.cs @@ -0,0 +1,18 @@ +using System; +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential)] + public struct YR_RELOC + { + + /// uint32_t->unsigned int + public uint offset; + + /// _YR_RELOC* + public IntPtr next; + } + +} diff --git a/segugio/libyara/Types/YR_RULE.cs b/segugio/libyara/Types/YR_RULE.cs new file mode 100644 index 0000000..0fd2763 --- /dev/null +++ b/segugio/libyara/Types/YR_RULE.cs @@ -0,0 +1,26 @@ +using System; +using System.Runtime.InteropServices; + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential)] + public struct YR_RULE + { + // Global flags + public int flags; + + // Number of atoms generated for this rule. + public int num_atoms; + + public IntPtr identifier; + + public IntPtr tags; + + public IntPtr metas; + + public IntPtr strings; + + public IntPtr ns; + } + +} diff --git a/segugio/libyara/Types/YR_RULES.cs b/segugio/libyara/Types/YR_RULES.cs new file mode 100644 index 0000000..d31b22e --- /dev/null +++ b/segugio/libyara/Types/YR_RULES.cs @@ -0,0 +1,42 @@ +using System; +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential)] + public struct YR_RULES + { + /// YR_ARENA* + public IntPtr arena; + + /// YR_RULE* + public IntPtr rules_list_head; + + /// YR_STRING* + public IntPtr strings_list_head; + + /// YR_EXTERNAL_VARIABLE* + public IntPtr externals_list_head; + + /// YR_AC_TRANSITION_TABLE->YR_AC_TRANSITION* + public IntPtr ac_transition_table; + + /// YR_AR_MATCH* + public IntPtr ac_match_pool; + + /// YR_AC_MATCH_TABLE->YR_AC_MATCH_TABLE_ENTRY* + public IntPtr ac_match_table; + + public IntPtr code_start; + + // Total number of rules. + public uint num_rules; + + // Total number of strings. + public uint num_strings; + + // Total number of namespaces. + public uint num_namespaces; + } +} diff --git a/segugio/libyara/Types/YR_SCAN_CONTEXT.cs b/segugio/libyara/Types/YR_SCAN_CONTEXT.cs new file mode 100644 index 0000000..fa1cf96 --- /dev/null +++ b/segugio/libyara/Types/YR_SCAN_CONTEXT.cs @@ -0,0 +1,241 @@ +using System; +using System.Runtime.InteropServices; + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential)] + public struct RE_FIBER_LIST + { + public IntPtr head; + public IntPtr tail; + } + + [StructLayout(LayoutKind.Sequential)] + public struct RE_FIBER_POOL + { + public int fiber_count; + RE_FIBER_LIST fibers; + } + + + [StructLayout(LayoutKind.Sequential)] + public struct YR_SCAN_CONTEXT_WIN + { + /// File size of the file being scanned. + public ulong file_size_bytes; + /// Entry point of the file being scanned, if the file is PE or ELF. + public ulong entry_point; + /// Scanning flags. + public int flags; + /// Canary value used for preventing hand-crafted objects from being embedded + /// in compiled rules and used to exploit YARA. The canary value is initialized + /// to a random value and is subsequently set to all objects created by + /// yr_object_create. The canary is verified when objects are used by + /// yr_execute_code. + public int canary; + + /// Scan timeout in nanoseconds. + public ulong timeout_ns; + + /// Pointer to user-provided data passed to the callback function. + public IntPtr user_data; + + /// Pointer to the user-provided callback function that is called when an + /// event occurs during the scan (a rule matching, a module being loaded, etc) + public IntPtr callback; + + /// Pointer to the YR_RULES object associated to this scan context. + public IntPtr rules; + + /// Pointer to the YR_STRING causing the most recent scan error. + public IntPtr last_error_string; + + /// Pointer to the iterator used for scanning + public IntPtr iterator; + + /// Pointer to a table mapping identifiers to YR_OBJECT structures. This table + /// contains entries for external variables and modules. + public IntPtr objects_table; + + /// Notebook used for storing YR_MATCH structures associated to the matches found. + public IntPtr matches_notebook; + + /// Stopwatch used for measuring the time elapsed during the scan. + public YR_STOPWATCH_WIN stopwatch; + + /// Fiber pool used by yr_re_exec. + public RE_FIBER_POOL re_fiber_pool; + + /// A bitmap with one bit per rule, bit N is set when the rule with index N + /// has matched. + public IntPtr rule_matches_flags; + + /// A bitmap with one bit per namespace, bit N is set if the namespace with + /// index N has some global rule that is not satisfied. + public IntPtr ns_unsatisfied_flags; + + /// Array with pointers to lists of matches. Item N in the array has the + /// list of matches for string with index N. + public IntPtr matches; + + /// "unconfirmed_matches" is like "matches" but for strings that are part of + /// a chain. Let's suppose that the string S is split in two chained strings + /// S1 <- S2. When a match is found for S1, we can't be sure that S matches + /// until a match for S2 is found (within the range defined by chain_gap_min + /// and chain_gap_max), so the matches for S1 are put in "unconfirmed_matches" + /// until they can be confirmed or discarded. + public IntPtr unconfirmed_matches; + + /// profiling_info is a pointer to an array of YR_PROFILING_INFO structures, + /// one per rule. Entry N has the profiling information for rule with index N. + public IntPtr profiling_info; + } + + + [StructLayout(LayoutKind.Sequential)] + public struct YR_SCAN_CONTEXT_OSX + { + /// File size of the file being scanned. + public ulong file_size_bytes; + /// Entry point of the file being scanned, if the file is PE or ELF. + public ulong entry_point; + /// Scanning flags. + public int flags; + /// Canary value used for preventing hand-crafted objects from being embedded + /// in compiled rules and used to exploit YARA. The canary value is initialized + /// to a random value and is subsequently set to all objects created by + /// yr_object_create. The canary is verified when objects are used by + /// yr_execute_code. + public int canary; + + /// Scan timeout in nanoseconds. + public ulong timeout_ns; + + /// Pointer to user-provided data passed to the callback function. + public IntPtr user_data; + + /// Pointer to the user-provided callback function that is called when an + /// event occurs during the scan (a rule matching, a module being loaded, etc) + public IntPtr callback; + + /// Pointer to the YR_RULES object associated to this scan context. + public IntPtr rules; + + /// Pointer to the YR_STRING causing the most recent scan error. + public IntPtr last_error_string; + + /// Pointer to the iterator used for scanning + public IntPtr iterator; + + /// Pointer to a table mapping identifiers to YR_OBJECT structures. This table + /// contains entries for external variables and modules. + public IntPtr objects_table; + + /// Notebook used for storing YR_MATCH structures associated to the matches found. + public IntPtr matches_notebook; + + /// Stopwatch used for measuring the time elapsed during the scan. + public YR_STOPWATCH_OSX stopwatch; + + /// Fiber pool used by yr_re_exec. + public RE_FIBER_POOL re_fiber_pool; + + /// A bitmap with one bit per rule, bit N is set when the rule with index N + /// has matched. + public IntPtr rule_matches_flags; + + /// A bitmap with one bit per namespace, bit N is set if the namespace with + /// index N has some global rule that is not satisfied. + public IntPtr ns_unsatisfied_flags; + + /// Array with pointers to lists of matches. Item N in the array has the + /// list of matches for string with index N. + public IntPtr matches; + + /// "unconfirmed_matches" is like "matches" but for strings that are part of + /// a chain. Let's suppose that the string S is split in two chained strings + /// S1 <- S2. When a match is found for S1, we can't be sure that S matches + /// until a match for S2 is found (within the range defined by chain_gap_min + /// and chain_gap_max), so the matches for S1 are put in "unconfirmed_matches" + /// until they can be confirmed or discarded. + public IntPtr unconfirmed_matches; + + /// profiling_info is a pointer to an array of YR_PROFILING_INFO structures, + /// one per rule. Entry N has the profiling information for rule with index N. + public IntPtr profiling_info; + } + + + [StructLayout(LayoutKind.Sequential)] + public struct YR_SCAN_CONTEXT_LINUX + { + /// File size of the file being scanned. + public ulong file_size_bytes; + /// Entry point of the file being scanned, if the file is PE or ELF. + public ulong entry_point; + /// Scanning flags. + public int flags; + /// Canary value used for preventing hand-crafted objects from being embedded + /// in compiled rules and used to exploit YARA. The canary value is initialized + /// to a random value and is subsequently set to all objects created by + /// yr_object_create. The canary is verified when objects are used by + /// yr_execute_code. + public int canary; + + /// Scan timeout in nanoseconds. + public ulong timeout_ns; + + /// Pointer to user-provided data passed to the callback function. + public IntPtr user_data; + + /// Pointer to the user-provided callback function that is called when an + /// event occurs during the scan (a rule matching, a module being loaded, etc) + public IntPtr callback; + + /// Pointer to the YR_RULES object associated to this scan context. + public IntPtr rules; + + /// Pointer to the YR_STRING causing the most recent scan error. + public IntPtr last_error_string; + + /// Pointer to the iterator used for scanning + public IntPtr iterator; + + /// Pointer to a table mapping identifiers to YR_OBJECT structures. This table + /// contains entries for external variables and modules. + public IntPtr objects_table; + + /// Notebook used for storing YR_MATCH structures associated to the matches found. + public IntPtr matches_notebook; + + /// Stopwatch used for measuring the time elapsed during the scan. + public YR_STOPWATCH_LINUX stopwatch; + + /// Fiber pool used by yr_re_exec. + public RE_FIBER_POOL re_fiber_pool; + + /// A bitmap with one bit per rule, bit N is set when the rule with index N + /// has matched. + public IntPtr rule_matches_flags; + + /// A bitmap with one bit per namespace, bit N is set if the namespace with + /// index N has some global rule that is not satisfied. + public IntPtr ns_unsatisfied_flags; + + /// Array with pointers to lists of matches. Item N in the array has the + /// list of matches for string with index N. + public IntPtr matches; + + /// "unconfirmed_matches" is like "matches" but for strings that are part of + /// a chain. Let's suppose that the string S is split in two chained strings + /// S1 <- S2. When a match is found for S1, we can't be sure that S matches + /// until a match for S2 is found (within the range defined by chain_gap_min + /// and chain_gap_max), so the matches for S1 are put in "unconfirmed_matches" + /// until they can be confirmed or discarded. + public IntPtr unconfirmed_matches; + + /// profiling_info is a pointer to an array of YR_PROFILING_INFO structures, + /// one per rule. Entry N has the profiling information for rule with index N. + public IntPtr profiling_info; + } +} diff --git a/segugio/libyara/Types/YR_STOPWATCH.cs b/segugio/libyara/Types/YR_STOPWATCH.cs new file mode 100644 index 0000000..20ce62b --- /dev/null +++ b/segugio/libyara/Types/YR_STOPWATCH.cs @@ -0,0 +1,44 @@ +using System.Runtime.InteropServices; + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential)] + public struct YR_STOPWATCH_WIN + { + public ulong frequency; + public ulong start; + } + + [StructLayout(LayoutKind.Sequential)] + public struct mach_timebase_info + { + public uint numer; + public uint denom; + } + + [StructLayout(LayoutKind.Sequential)] + public struct YR_STOPWATCH_OSX + { + public mach_timebase_info timebase; + public ulong start; + } + + [StructLayout(LayoutKind.Sequential)] + public struct timeval { + public long tv_sec; + public int tc_usec; + } + + [StructLayout(LayoutKind.Sequential)] + public struct timespec { + public long tv_sec; + public int tc_nsec; + } + + [StructLayout(LayoutKind.Sequential)] + public struct YR_STOPWATCH_LINUX + { + public timeval tv_start; + public timespec ts_start; + } +} diff --git a/segugio/libyara/Types/YR_STRING.cs b/segugio/libyara/Types/YR_STRING.cs new file mode 100644 index 0000000..1d7e031 --- /dev/null +++ b/segugio/libyara/Types/YR_STRING.cs @@ -0,0 +1,68 @@ +using System; +using System.Runtime.InteropServices; + + +namespace dnYara.Interop +{ + [StructLayout(LayoutKind.Sequential)] + public struct YR_STRING + { + + /// Flags, see STRING_FLAGS_XXX macros defined above. + public uint flags; + + /// Index of this string in the array of YR_STRING structures stored in + /// YR_STRINGS_TABLE. + public uint idx; + + /// If the string can only match at a specific offset (for example if the + /// condition is "$a at 0" the string $a can only match at offset 0), the + /// fixed_offset field contains the offset, it have the YR_UNDEFINED value for + /// strings that can match anywhere. + public long fixed_offset; + + /// Index of the rule containing this string in the array of YR_RULE + /// structures stored in YR_RULES_TABLE. + public uint rule_idx; + + /// String's length. + public int length; + + /// Pointer to the string itself, the length is indicated by the "length" + /// field. + public IntPtr string_content; + + + /// Strings are splitted in two or more parts when they contain a "gap" that + /// is larger than YR_STRING_CHAINING_THRESHOLD. This happens in strings like + /// { 01 02 03 04 [X-Y] 05 06 07 08 } if Y >= X + YR_STRING_CHAINING_THRESHOLD + /// and also in { 01 02 03 04 [-] 05 06 07 08 }. In both cases the strings are + /// split in { 01 02 03 04 } and { 05 06 07 08 }, and the two smaller strings + /// are searched for independently. If some string S is splitted in S1 and S2, + /// S2 is chained to S1. In the example above { 05 06 07 08 } is chained to + /// { 01 02 03 04 }. The same applies when the string is splitted in more than + /// two parts, if S is split in S1, S2, and S3. S3 is chained to S2 and S2 is + /// chained to S1 (it can represented as: S1 <- S2 <- S3). + public IntPtr chained_to; + + /// When this string is chained to some other string, chain_gap_min and + /// chain_gap_max contain the minimum and maximum distance between the two + /// strings. For example in { 01 02 03 04 [X-Y] 05 06 07 08 }, the string + /// { 05 06 07 08 } is chained to { 01 02 03 04 } and chain_gap_min is X + /// and chain_gap_max is Y. These fields are ignored for strings that are not + /// part of a string chain. + public int chain_gap_min; + + /// When this string is chained to some other string, chain_gap_min and + /// chain_gap_max contain the minimum and maximum distance between the two + /// strings. For example in { 01 02 03 04 [X-Y] 05 06 07 08 }, the string + /// { 05 06 07 08 } is chained to { 01 02 03 04 } and chain_gap_min is X + /// and chain_gap_max is Y. These fields are ignored for strings that are not + /// part of a string chain. + public int chain_gap_max; + + /// Identifier of this string. + public IntPtr identifier; + } + +} diff --git a/segugio/libyara/YaraWrapper.cs b/segugio/libyara/YaraWrapper.cs new file mode 100644 index 0000000..63313f8 --- /dev/null +++ b/segugio/libyara/YaraWrapper.cs @@ -0,0 +1,1110 @@ +using dnYara.Interop; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.IO; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace libYaraWrapper.libyara +{ + + /// + /// RAII wrapper for GCHandle. + /// + public class GCHandleHandler + : IDisposable + { + public GCHandle Handle { get; } + + public GCHandleHandler(object value) + { + Handle = GCHandle.Alloc(value); + } + + public GCHandleHandler( + object value, + GCHandleType handleType) + { + Handle = GCHandle.Alloc(value, handleType); + } + + public void Dispose() + { + if (Handle != null) + Handle.Free(); + } + + public IntPtr GetPointer() + { + return GCHandle.ToIntPtr(Handle); + } + } + + public sealed class CompilationException + : Exception + { + public List Errors; + + public CompilationException(List errors) + : base(string.Format( + "Error compiling rules.\n{0}", string.Join("\n", errors))) + { + Errors = new List(errors); + } + } + + //[Serializable] + //internal class FileIOException + // : Exception + //{ + // public Errno Error { get; set; } + // public string Path { get; set; } + // public FileIOException() + // { + // } + + // public FileIOException(Errno error, string path) : base($"An error occured on file {path}: {error}.") + // { + // Error = error; + // Path = path; + // } + //} + + + public sealed class YaraException + : Exception + { + public YARA_ERROR YRError { get; set; } + public YaraException(YARA_ERROR error) + : base(string.Format("Yara error code {0}", Enum.GetName(typeof(YARA_ERROR), error))) + { + YRError = error; + } + } + + /// + /// RAII wrapper for Yara context, must be used with 'using' keyword. + /// + public sealed class YaraContext + : IDisposable + { + public YaraContext() + { + ErrorUtility.ThrowOnError(Methods.yr_initialize()); + } + + ~YaraContext() + { + Dispose(); + } + + public void Dispose() + { + Methods.yr_finalize(); + } + } + + + public static class DictionaryExtensions + { + public static IDictionary ToDictionary(this IEnumerable<(Key, Value)> values) + { + var dict = new Dictionary(); + foreach (var (key, value) in values) + { + dict[key] = value; + } + return dict; + } + } + + public class ScanHelper + { + public static YARA_ERROR CheckRule(string ruleFile) + { + YARA_ERROR error = YARA_ERROR.SUCCESS; + Compiler comp = new Compiler(); + + try + { + comp.AddRuleFile(ruleFile); + } + catch (YaraException e) + { + error = e.YRError; + } + catch + { + error = YARA_ERROR.ERROR_INVALID_FILE; + } + + comp.Dispose(); + return error; + } + } + + /// + /// Data structure representing a string match. + /// + public sealed class Match + { + /// + /// Base offset/address for the match. While scanning a file this field is usually zero, while + /// scanning a process memory space this field is the virtual address of the memory block where the match was found. + /// + public long Base { get; set; } + + /// + /// Offset of the match relative to base. + /// + public long Offset { get; set; } + + /// + /// Buffer containing a portion of the matching string. + /// + public byte[] Data { get; set; } + + + public Match(YR_MATCH match) + { + Base = match.@base; + Offset = match.offset; + + Data = new byte[match.data_length]; + Marshal.Copy(match.dataPtr, Data, 0, Data.Length); + } + + public override string ToString() + { + if (Data.Length == 0) + return string.Empty; + + if (Data.Length > 1) + { + if (Data[0] == 0) + return Encoding.BigEndianUnicode.GetString(Data); + + else if (Data[1] == 0) + return Encoding.Unicode.GetString(Data); + } + + return Encoding.ASCII.GetString(Data); + } + } + + + public class ProfilingInfo + { + public ProfilingInfo() + { + + } + + public ProfilingInfo(YR_PROFILING_INFO prof) + { + AtomMatches = prof.atom_matches; + MatchTimeNanos = prof.match_time; + ExecTimeNanos = prof.exec_time; + } + + /// Number of times that some atom belonging to the rule matched. Each + /// matching atom means a potential string match that needs to be verified. + public uint AtomMatches { get; private set; } + + // Amount of time (in nanoseconds) spent verifying atom matches for + // determining if the corresponding string actually matched or not. This + // time is not measured for all atom matches, only 1 out of 1024 matches + // are actually measured. + public ulong MatchTimeNanos { get; private set; } + + // Amount of time (in nanoseconds) spent evaluating the rule condition. + public ulong ExecTimeNanos { get; private set; } + } + + /// + /// Data structure representing a single rule. + /// + public sealed class Rule + { + /// + /// Rule identifier. + /// + public string Identifier { get; set; } + + /// + /// Pointer to a sequence of null terminated strings with tag names. An additional null character + /// marks the end of the sequence. Example: tag1\0tag2\0tag3\0\0. + /// To iterate over the tags you can use yr_rule_tags_foreach(). + /// + public List Tags { get; set; } + + /// + /// Key-Value pairs associated with the rule. The value portion can be one of + /// + /// string + /// long (int64) + /// boolean + /// null + /// + /// + public IDictionary Metas { get; private set; } + + public int AtomsCount { get; private set; } + + public Rule() + { + Identifier = string.Empty; + Tags = new List(); + Metas = new Dictionary(); + } + + private static (string name, object value) ExtractMetaValue(YR_META meta) + { + var name = Marshal.PtrToStringAnsi(meta.identifier); + object v = null; + switch ((META_TYPE)meta.type) + { + case META_TYPE.META_TYPE_NULL: + break; + case META_TYPE.META_TYPE_INTEGER: + v = meta.integer; + break; + case META_TYPE.META_TYPE_BOOLEAN: + v = meta.integer == 0 ? false : true; + break; + case META_TYPE.META_TYPE_STRING: + v = Marshal.PtrToStringAnsi(meta.strings); + break; + } + return (name, v); + } + + public Rule(YR_RULE rule) + { + IntPtr ptr = rule.identifier; + Identifier = Marshal.PtrToStringAnsi(ptr); + Tags = ObjRefHelper.IterateCStrings(rule.tags).ToList(); + Metas = ObjRefHelper.GetMetas(rule.metas).Select(ExtractMetaValue).ToDictionary(); + AtomsCount = rule.num_atoms; + } + } + + + /// + /// Data structure containing the different types of external variables passed to a custom scanner + /// + public class ExternalVariables + { + public Dictionary StringVariables = new Dictionary(); + + public Dictionary IntVariables = new Dictionary(); + + public Dictionary FloatVariables = new Dictionary(); + + public Dictionary BoolVariables = new Dictionary(); + + public void ClearAll() + { + StringVariables.Clear(); + IntVariables.Clear(); + FloatVariables.Clear(); + BoolVariables.Clear(); + } + + public int CountAll() + { + return StringVariables.Count + IntVariables.Count + FloatVariables.Count + BoolVariables.Count; + } + + } + + public abstract class ErrorUtility + { + public static void ThrowOnError(YARA_ERROR error) + { + switch (error) + { + case YARA_ERROR.SUCCESS: + break; + default: + throw new YaraException(error); + } + } + } + + + + /// + /// Yara compiled rules. + /// + public sealed class CompiledRules + : IDisposable + { + internal IntPtr BasePtr { get; set; } + + public List Rules { get; private set; } + + public uint RuleCount { get; private set; } + public uint StringsCount { get; private set; } + public uint NamespacesCount { get; private set; } + + public CompiledRules(IntPtr rulesPtr) + { + BasePtr = rulesPtr; + ExtractData(); + } + + private void ExtractData() + { + var ruleStruct = Marshal.PtrToStructure(BasePtr); + Rules = ObjRefHelper + .GetRules(ruleStruct.rules_list_head) + .Select(rule => new Rule(rule)) + .ToList(); + RuleCount = ruleStruct.num_rules; + StringsCount = ruleStruct.num_strings; + NamespacesCount = ruleStruct.num_namespaces; + } + public CompiledRules(string filename) + { + IntPtr ptr = IntPtr.Zero; + ErrorUtility.ThrowOnError(Methods.yr_rules_load(filename, ref ptr)); + BasePtr = ptr; + ExtractData(); + } + + ~CompiledRules() + { + if (BasePtr != default) + Release(); + Dispose(); + } + + public bool Save(string filename) + { + ErrorUtility.ThrowOnError(Methods.yr_rules_save(BasePtr, filename)); + return true; + } + + public void Dispose() + { + if (!BasePtr.Equals(IntPtr.Zero)) + { + IntPtr ptr = BasePtr; + BasePtr = IntPtr.Zero; + Methods.yr_rules_destroy(ptr); + } + } + + public IntPtr Release() + { + var temp = BasePtr; + BasePtr = default; + return temp; + } + } + + + public class Compiler + : IDisposable + { + private IntPtr compilerPtr; + + private List compilationErrors; + private YR_COMPILER_CALLBACK_FUNC compilerCallback; + + public Compiler() + { + ErrorUtility.ThrowOnError(Methods.yr_compiler_create(out compilerPtr)); + + compilationErrors = new List(); + + compilerCallback = new YR_COMPILER_CALLBACK_FUNC(this.HandleError); + + Methods.yr_compiler_set_callback(compilerPtr, compilerCallback, IntPtr.Zero); + + } + + ~Compiler() + { + Dispose(); + } + + public void Dispose() + { + if (!compilerPtr.Equals(IntPtr.Zero)) + { + var ptr = compilerPtr; + compilerPtr = IntPtr.Zero; + Methods.yr_compiler_destroy(ptr); + } + + } + + public void AddRuleFile(string path) + { + compilationErrors.Clear(); + + try + { + //PosixFileHandler fw = new PosixFileHandler(path, "r"); + + string nullstr = string.Empty; + + string rule = File.ReadAllText(path); + + //var errors = Methods.yr_compiler_add_file( + // compilerPtr, + // fw.FileHandle, + // null, + // path); + + var errors = Methods.yr_compiler_add_string( + compilerPtr, + rule, + nullstr); + + if (errors != 0) + throw new CompilationException(compilationErrors); + } + catch (Exception e) + { + + MessageBox.Show($"YARA file not matching formal requirements: {path} ", + "Error during YARA file compilation", MessageBoxButtons.OK, MessageBoxIcon.Error); + + Environment.Exit(0); + + //throw new Win32Exception(e.HResult, e.Message); + } + } + + public void AddRuleString(string rule) + { + compilationErrors.Clear(); + + var errors = Methods.yr_compiler_add_string( + compilerPtr, + rule, + string.Empty); + + if (errors != 0) + throw new CompilationException(compilationErrors); + } + + public void DeclareExternalStringVariable(string name, string defaultValue = "") + { + var errors = Methods.yr_compiler_define_string_variable( + compilerPtr, + name, + defaultValue); + + if (errors != 0) + throw new InvalidDataException($"Error {errors} in DeclareExternalStringVariable '{name}'='{defaultValue}'"); + } + + public void DeclareExternalIntVariable(string name, long defaultValue = 0) + { + var errors = Methods.yr_scanner_define_integer_variable( + compilerPtr, + name, + defaultValue); + + if (errors != 0) + throw new InvalidDataException($"Error {errors} in DeclareExternalIntVariable '{name}'={defaultValue}"); + } + + public void DeclareExternalFloatVariable(string name, double defaultValue = 0) + { + var errors = Methods.yr_scanner_define_float_variable( + compilerPtr, + name, + defaultValue); + + if (errors != 0) + throw new InvalidDataException($"Error {errors} in DeclareExternalFloatVariable setting '{name}'={defaultValue}"); + } + + public void DeclareExternalBooleanVariable(string name, bool defaultValue = false) + { + var errors = Methods.yr_compiler_define_boolean_variable( + compilerPtr, + name, + defaultValue == true ? 1 : 0); + + if (errors != 0) + throw new InvalidDataException($"Error {errors} in DeclareExternalBooleanVariable setting '{name}'={defaultValue}"); + } + + public CompiledRules Compile() + { + IntPtr rulesPtr = new IntPtr(); + + ErrorUtility.ThrowOnError( + Methods.yr_compiler_get_rules(compilerPtr, ref rulesPtr)); + + return new CompiledRules(rulesPtr); + } + + public static CompiledRules CompileRulesFile(string path) + { + Compiler yc = new Compiler(); + yc.AddRuleFile(path); + + return yc.Compile(); + } + + public static CompiledRules CompileRulesString(string rule) + { + Compiler yc = new Compiler(); + yc.AddRuleString(rule); + + return yc.Compile(); + } + + public void HandleError( + int errorLevel, + string fileName, + int lineNumber, + IntPtr rule, + string message, + IntPtr userData) + { + + var marshaledRule = rule == IntPtr.Zero + ? new System.Nullable() + : Marshal.PtrToStructure(rule); + var ruleName = marshaledRule.HasValue ? "No Rule" : Marshal.PtrToStringAnsi(marshaledRule.Value.identifier); + var msg = string.Format("rule {3}, Line {1}, file: {2}: {0}", + message, + lineNumber, + string.IsNullOrWhiteSpace(fileName) ? fileName : "[none]", + ruleName); + + compilationErrors.Add(msg); + } + } + + public class CustomScanner + { + private const int YR_TIMEOUT = 10000; + + private IntPtr customScannerPtr = IntPtr.Zero; + + public CustomScanner(CompiledRules rules, int flags = 0, int timeout = YR_TIMEOUT) + { + CreateNewScanner(rules, (YR_SCAN_FLAGS)flags, timeout); + } + + ~CustomScanner() + { + if (customScannerPtr != IntPtr.Zero) + { + Release(); + } + } + + //must be called before the context is destroyed (ie: falling out of a using()) + public void Release() + { + Methods.yr_scanner_destroy(customScannerPtr); + customScannerPtr = IntPtr.Zero; + } + + private void CreateNewScanner(CompiledRules rules, YR_SCAN_FLAGS flags, int timeout) + { + ErrorUtility.ThrowOnError( + Methods.yr_scanner_create(rules.BasePtr, out IntPtr newScanner)); + + customScannerPtr = newScanner; + + SetFlags(flags); + SetTimeout(timeout); + } + + public virtual void SetFlags(YR_SCAN_FLAGS flags) => Methods.yr_scanner_set_flags(customScannerPtr, (int)flags); + public virtual void SetTimeout(int timeout) => Methods.yr_scanner_set_timeout(customScannerPtr, timeout); + + private bool TestAllVariablesUnique(ExternalVariables externalVariables, out string duplicatesListString) + { + duplicatesListString = ""; + + List allKeys = externalVariables.StringVariables.Keys.ToList(); + allKeys.AddRange(externalVariables.IntVariables.Keys.ToList()); + allKeys.AddRange(externalVariables.FloatVariables.Keys.ToList()); + allKeys.AddRange(externalVariables.BoolVariables.Keys.ToList()); + + var duplicates = allKeys.GroupBy(_ => _).Where(_ => _.Count() > 1).ToList(); + + if (duplicates.Count == 0) return true; + + for (var i = 0; i < duplicates.Count; i++) + { + duplicatesListString += $"{duplicates[i].Key}"; + if (i < (duplicates.Count - 1)) + duplicatesListString += ", "; + } + + return false; + } + + private void SetExternalVariables(ExternalVariables externalVariables) + { + if (!TestAllVariablesUnique(externalVariables, out string duplicates)) + { + throw new InvalidDataException("Duplicate external variable names declared: " + duplicates); + } + + foreach (KeyValuePair variable in externalVariables.StringVariables) + ErrorUtility.ThrowOnError( + Methods.yr_scanner_define_string_variable(customScannerPtr, variable.Key, variable.Value)); + + foreach (KeyValuePair variable in externalVariables.IntVariables) + ErrorUtility.ThrowOnError( + Methods.yr_scanner_define_integer_variable(customScannerPtr, variable.Key, variable.Value)); + + foreach (KeyValuePair variable in externalVariables.FloatVariables) + ErrorUtility.ThrowOnError( + Methods.yr_scanner_define_float_variable(customScannerPtr, variable.Key, variable.Value)); + + foreach (KeyValuePair variable in externalVariables.BoolVariables) + ErrorUtility.ThrowOnError( + Methods.yr_scanner_define_boolean_variable(customScannerPtr, variable.Key, variable.Value == true ? 1 : 0)); + } + + //YARA doesnt allow deletion of variables, this cleans them us as much as practical but + //a new scanner should be created if it's imporant for them not to exist + private void ClearExternalVariables(ExternalVariables externalVariables) + { + foreach (KeyValuePair variable in externalVariables.StringVariables) + ErrorUtility.ThrowOnError( + Methods.yr_scanner_define_string_variable(customScannerPtr, variable.Key, String.Empty)); + + foreach (KeyValuePair variable in externalVariables.IntVariables) + ErrorUtility.ThrowOnError( + Methods.yr_scanner_define_integer_variable(customScannerPtr, variable.Key, long.MinValue)); + + foreach (KeyValuePair variable in externalVariables.FloatVariables) + ErrorUtility.ThrowOnError( + Methods.yr_scanner_define_float_variable(customScannerPtr, variable.Key, float.NegativeInfinity)); + + foreach (KeyValuePair variable in externalVariables.BoolVariables) + ErrorUtility.ThrowOnError( + Methods.yr_scanner_define_boolean_variable(customScannerPtr, variable.Key, 0)); + } + + + public virtual List ScanFile(string path, ExternalVariables externalVariables) + { + if (customScannerPtr == IntPtr.Zero) + throw new NullReferenceException("Custom Scanner has not been initialised"); + + if (!File.Exists(path)) + throw new FileNotFoundException(path); + + SetExternalVariables(externalVariables); + + YR_CALLBACK_FUNC scannerCallback = new YR_CALLBACK_FUNC(HandleMessage); + List scanResults = new List(); + GCHandleHandler resultsHandle = new GCHandleHandler(scanResults); + Methods.yr_scanner_set_callback(customScannerPtr, scannerCallback, resultsHandle.GetPointer()); + + ErrorUtility.ThrowOnError( + Methods.yr_scanner_scan_file( + customScannerPtr, + path + )); + + ClearExternalVariables(externalVariables); + + return scanResults; + } + + public virtual List ScanString( + string text, + ExternalVariables externalVariables, + Encoding encoding = null) + { + if (encoding == null) + encoding = Encoding.ASCII; + + byte[] buffer = encoding.GetBytes(text); + + return ScanMemory(ref buffer, externalVariables, YR_SCAN_FLAGS.None); + } + + public virtual List ScanStream( + Stream stream, + ExternalVariables externalVariables) + { + using (MemoryStream ms = new MemoryStream()) + { + stream.CopyTo(ms); + byte[] buffer = ms.ToArray(); + + return ScanMemory(ref buffer, externalVariables, YR_SCAN_FLAGS.None); + } + } + + public virtual List ScanMemory( + ref byte[] buffer, + ExternalVariables externalVariables) + { + return ScanMemory(ref buffer, externalVariables, YR_SCAN_FLAGS.None); + } + + public List ScanMemory( + ref byte[] buffer, + ExternalVariables externalVariables, + YR_SCAN_FLAGS flags) + { + if (buffer.Length == 0) + return new List(); + + return ScanMemory(ref buffer, buffer.Length, externalVariables, flags); + } + + internal List ScanMemory( + IntPtr buffer, + int length, + ExternalVariables externalVariables) + { + return ScanMemory(buffer, length, externalVariables, YR_SCAN_FLAGS.None); + } + + internal List ScanMemory( + IntPtr buffer, + int length, + ExternalVariables externalVariables, + YR_SCAN_FLAGS flags) + { + byte[] res = new byte[length - 1]; + Marshal.Copy(buffer, res, 0, length); + return ScanMemory(ref res, length, externalVariables, flags); + } + + public virtual List ScanMemory( + ref byte[] buffer, + int length, + ExternalVariables externalVariables, + YR_SCAN_FLAGS flags) + { + YR_CALLBACK_FUNC scannerCallback = new YR_CALLBACK_FUNC(HandleMessage); + List scanResults = new List(); + GCHandleHandler resultsHandle = new GCHandleHandler(scanResults); + Methods.yr_scanner_set_callback(customScannerPtr, scannerCallback, resultsHandle.GetPointer()); + + SetFlags(flags); + SetExternalVariables(externalVariables); + + IntPtr btCpy = Marshal.AllocHGlobal(buffer.Length); ; + Marshal.Copy(buffer, 0, btCpy, (int)buffer.Length); + + ErrorUtility.ThrowOnError( + Methods.yr_scanner_scan_mem( + customScannerPtr, + btCpy, + (ulong)length + )); + + ClearExternalVariables(externalVariables); + + return scanResults; + } + + private YR_CALLBACK_RESULT HandleMessage( + IntPtr context, + int message, + IntPtr message_data, + IntPtr user_data) + { + + if (message == Constants.CALLBACK_MSG_RULE_MATCHING) + { + var resultsHandle = GCHandle.FromIntPtr(user_data); + var results = (List)resultsHandle.Target; + + YR_RULE rule = Marshal.PtrToStructure(message_data); + results.Add(new ScanResult(context, rule)); + } + + return YR_CALLBACK_RESULT.Continue; + } + } + + public class Scanner + { + private const int YR_TIMEOUT = 10000; + + private YR_CALLBACK_FUNC callbackPtr; + + public Scanner() + { + callbackPtr = new YR_CALLBACK_FUNC(HandleMessage); + } + + public virtual List ScanFile(string path, CompiledRules rules) + { + return ScanFile(path, rules, YR_SCAN_FLAGS.None); + } + + public virtual List ScanFile( + string path, + CompiledRules rules, + YR_SCAN_FLAGS flags) + { + if (!File.Exists(path)) + throw new FileNotFoundException(path); + + var results = new List(); + var nativePath = path; + + GCHandleHandler resultsHandle = new GCHandleHandler(results); + + ErrorUtility.ThrowOnError( + Methods.yr_rules_scan_file( + rules.BasePtr, + nativePath, + (int)flags, + callbackPtr, + resultsHandle.GetPointer(), + YR_TIMEOUT)); + + resultsHandle.Dispose(); + + return results; + } + + public virtual List ScanProcess(int processId, CompiledRules rules) + { + return ScanProcess(processId, rules, YR_SCAN_FLAGS.None); + } + + public virtual List ScanProcess( + int processId, + CompiledRules rules, + YR_SCAN_FLAGS flags) + { + var results = new List(); + GCHandleHandler resultsHandle = new GCHandleHandler(results); + + ErrorUtility.ThrowOnError( + Methods.yr_rules_scan_proc( + rules.BasePtr, + processId, + (int)flags, + callbackPtr, + resultsHandle.GetPointer(), + YR_TIMEOUT)); + + return results; + } + + public virtual List ScanString( + string text, + CompiledRules rules, + Encoding encoding = null) + { + if (encoding == null) + encoding = Encoding.ASCII; + + byte[] buffer = encoding.GetBytes(text); + + return ScanMemory(ref buffer, rules, YR_SCAN_FLAGS.None); + } + + public virtual List ScanStream( + Stream stream, + CompiledRules rules) + { + using (MemoryStream ms = new MemoryStream()) + { + stream.CopyTo(ms); + byte[] buffer = ms.ToArray(); + + return ScanMemory(ref buffer, rules, YR_SCAN_FLAGS.None); + } + } + + public virtual List ScanMemory( + ref byte[] buffer, + CompiledRules rules) + { + return ScanMemory(ref buffer, rules, YR_SCAN_FLAGS.None); + } + + public List ScanMemory( + ref byte[] buffer, + CompiledRules rules, + YR_SCAN_FLAGS flags) + { + if (buffer.Length == 0) + return new List(); + + return ScanMemory(ref buffer, buffer.Length, rules, flags); + } + + internal List ScanMemory( + IntPtr buffer, + int length, + CompiledRules rules) + { + return ScanMemory(buffer, length, rules, YR_SCAN_FLAGS.None); + } + + internal List ScanMemory( + IntPtr buffer, + int length, + CompiledRules rules, + YR_SCAN_FLAGS flags) + { + byte[] res = new byte[length - 1]; + Marshal.Copy(buffer, res, 0, length); + return ScanMemory(ref res, length, rules, flags); + } + + public virtual List ScanMemory( + ref byte[] buffer, + int length, + CompiledRules rules, + YR_SCAN_FLAGS flags) + { + var results = new List(); + GCHandleHandler resultsHandle = new GCHandleHandler(results); + + IntPtr btCpy = Marshal.AllocHGlobal(buffer.Length); ; + Marshal.Copy(buffer, 0, btCpy, (int)buffer.Length); + + ErrorUtility.ThrowOnError( + Methods.yr_rules_scan_mem( + rules.BasePtr, + btCpy, + (ulong)length, + (int)flags, + callbackPtr, + resultsHandle.GetPointer(), + YR_TIMEOUT)); + + return results; + } + + private YR_CALLBACK_RESULT HandleMessage( + IntPtr context, + int message, + IntPtr message_data, + IntPtr user_data) + { + if (message == Constants.CALLBACK_MSG_RULE_MATCHING) + { + var resultsHandle = GCHandle.FromIntPtr(user_data); + var results = (List)resultsHandle.Target; + + YR_RULE rule = Marshal.PtrToStructure(message_data); + results.Add(new ScanResult(context, rule)); + } + + return YR_CALLBACK_RESULT.Continue; + } + } + + public class ScanResult + { + public Rule MatchingRule; + public Dictionary> Matches; + public ProfilingInfo ProfilingInfo; + + public ScanResult() + { + MatchingRule = null; + Matches = new Dictionary>(); + ProfilingInfo = null; + } + + public ScanResult(IntPtr scanContext, YR_RULE matchingRule) + { + IntPtr matchesPtr = GetMatchesPtr(scanContext); + IntPtr profilingInfoPtr = GetProfilingInfoPtr(scanContext); + + MatchingRule = new Rule(matchingRule); + Matches = new Dictionary>(); + + var matchingStrings = ObjRefHelper.GetYaraStrings(matchingRule.strings); + foreach (var str in matchingStrings) + { + var identifier = str.identifier; + + if (identifier == IntPtr.Zero) + return; + + var matches = ObjRefHelper.GetStringMatches(matchesPtr, str); + + foreach (var match in matches) + { + string matchText = ObjRefHelper.ReadYaraString(str); + + if (!Matches.ContainsKey(matchText)) + Matches.Add(matchText, new List()); + + Matches[matchText].Add(new Match(match)); + if (ProfilingInfo == null) + { + var profInfo = ObjRefHelper.TryGetProfilingInfoForRule(profilingInfoPtr, (int)str.rule_idx); + if (profInfo.HasValue) + { + ProfilingInfo = new ProfilingInfo(profInfo.Value); + } + } + } + } + } + + private IntPtr GetProfilingInfoPtr(IntPtr scanContext) + { + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + { + YR_SCAN_CONTEXT_WIN scan_context = Marshal.PtrToStructure(scanContext); + return scan_context.profiling_info; + } + + if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) + { + YR_SCAN_CONTEXT_LINUX scan_context = Marshal.PtrToStructure(scanContext); + return scan_context.profiling_info; + } + + if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) + { + YR_SCAN_CONTEXT_OSX scan_context = Marshal.PtrToStructure(scanContext); + return scan_context.profiling_info; + } + return IntPtr.Zero; + } + + private IntPtr GetMatchesPtr(IntPtr scanContext) + { + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + { + YR_SCAN_CONTEXT_WIN scan_context = Marshal.PtrToStructure(scanContext); + return scan_context.matches; + } + + if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) + { + YR_SCAN_CONTEXT_LINUX scan_context = Marshal.PtrToStructure(scanContext); + return scan_context.matches; + } + + if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) + { + YR_SCAN_CONTEXT_OSX scan_context = Marshal.PtrToStructure(scanContext); + return scan_context.matches; + } + return IntPtr.Zero; + } + } + +} diff --git a/segugio/packages.config b/segugio/packages.config new file mode 100644 index 0000000..2ba3a15 --- /dev/null +++ b/segugio/packages.config @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/segugio/segugio2.csproj b/segugio/segugio2.csproj new file mode 100644 index 0000000..681e8db --- /dev/null +++ b/segugio/segugio2.csproj @@ -0,0 +1,217 @@ + + + + + + Debug + AnyCPU + {92BE4C1E-CDE8-4F13-8FBB-E5B9445B5077} + WinExe + segugio + segugio + v4.7.2 + 512 + true + true + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + false + true + + + + + AnyCPU + false + portable + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + portable + true + bin\Release\ + TRACE + prompt + 4 + + + false + bin\x64\Debug\ + DEBUG;TRACE + portable + x64 + 7.3 + prompt + true + + + bin\x64\Release\ + + + true + portable + x64 + 7.3 + prompt + true + false + + + segugio.Program + + + + + + + + + + + + + + + + + Form + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Form + + + MainForm.cs + + + + + + + + + FormContextMenu.cs + Designer + + + MainForm.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + True + + + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + + + + + + False + Microsoft .NET Framework 4.7.2 %28x86 e x64%29 + true + + + False + .NET Framework 3.5 SP1 + false + + + + + + + + + + + + + + + + + + + Questo progetto fa riferimento a uno o più pacchetti NuGet che non sono presenti in questo computer. Usare lo strumento di ripristino dei pacchetti NuGet per scaricarli. Per altre informazioni, vedere http://go.microsoft.com/fwlink/?LinkID=322105. Il file mancante è {0}. + + + + \ No newline at end of file