From 201f5a7a527c10d10e2e8194c135202d70062556 Mon Sep 17 00:00:00 2001 From: PIBD14CHERTOVANDREY Date: Thu, 23 May 2024 09:48:17 +0400 Subject: [PATCH] =?UTF-8?q?=D0=BB=D0=B0=D0=B15?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- BinarySearch/BinarySearch.sln | 25 + BinarySearch/BinarySearch/BinarySearch.csproj | 26 + BinarySearch/BinarySearch/Program.cs | 17 + .../Properties/Resources.Designer.cs | 63 + .../BinarySearch/Properties/Resources.resx | 120 + .../BinarySearch/State/SearchState.cs | 22 + .../BinarySearch/State/StateStorage.cs | 101 + .../binsearch/BinarySearchRunner.cs | 73 + .../BinarySearch/binsearch/Condition.cs | 22 + .../binsearch/ConditionStorage.cs | 133 + .../BinarySearch/binsearch/Manager.cs | 31 + .../BinarySearch/binsearch/Parameters.cs | 23 + .../BinarySearch/binsearch/Visualizer.cs | 106 + .../forms/AddArrayForm.Designer.cs | 156 ++ .../BinarySearch/forms/AddArrayForm.cs | 46 + .../BinarySearch/forms/AddArrayForm.resx | 120 + .../BinarySearch/forms/InfoForm.Designer.cs | 64 + BinarySearch/BinarySearch/forms/InfoForm.cs | 20 + BinarySearch/BinarySearch/forms/InfoForm.resx | 153 ++ .../BinarySearch/forms/MainForm.Designer.cs | 260 ++ BinarySearch/BinarySearch/forms/MainForm.cs | 134 + BinarySearch/BinarySearch/forms/MainForm.resx | 2364 +++++++++++++++++ 22 files changed, 4079 insertions(+) create mode 100644 BinarySearch/BinarySearch.sln create mode 100644 BinarySearch/BinarySearch/BinarySearch.csproj create mode 100644 BinarySearch/BinarySearch/Program.cs create mode 100644 BinarySearch/BinarySearch/Properties/Resources.Designer.cs create mode 100644 BinarySearch/BinarySearch/Properties/Resources.resx create mode 100644 BinarySearch/BinarySearch/State/SearchState.cs create mode 100644 BinarySearch/BinarySearch/State/StateStorage.cs create mode 100644 BinarySearch/BinarySearch/binsearch/BinarySearchRunner.cs create mode 100644 BinarySearch/BinarySearch/binsearch/Condition.cs create mode 100644 BinarySearch/BinarySearch/binsearch/ConditionStorage.cs create mode 100644 BinarySearch/BinarySearch/binsearch/Manager.cs create mode 100644 BinarySearch/BinarySearch/binsearch/Parameters.cs create mode 100644 BinarySearch/BinarySearch/binsearch/Visualizer.cs create mode 100644 BinarySearch/BinarySearch/forms/AddArrayForm.Designer.cs create mode 100644 BinarySearch/BinarySearch/forms/AddArrayForm.cs create mode 100644 BinarySearch/BinarySearch/forms/AddArrayForm.resx create mode 100644 BinarySearch/BinarySearch/forms/InfoForm.Designer.cs create mode 100644 BinarySearch/BinarySearch/forms/InfoForm.cs create mode 100644 BinarySearch/BinarySearch/forms/InfoForm.resx create mode 100644 BinarySearch/BinarySearch/forms/MainForm.Designer.cs create mode 100644 BinarySearch/BinarySearch/forms/MainForm.cs create mode 100644 BinarySearch/BinarySearch/forms/MainForm.resx diff --git a/BinarySearch/BinarySearch.sln b/BinarySearch/BinarySearch.sln new file mode 100644 index 0000000..9151336 --- /dev/null +++ b/BinarySearch/BinarySearch.sln @@ -0,0 +1,25 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.8.34330.188 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BinarySearch", "BinarySearch\BinarySearch.csproj", "{D32DE24F-D9A3-411A-91C6-142A6FA1B7CF}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {D32DE24F-D9A3-411A-91C6-142A6FA1B7CF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D32DE24F-D9A3-411A-91C6-142A6FA1B7CF}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D32DE24F-D9A3-411A-91C6-142A6FA1B7CF}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D32DE24F-D9A3-411A-91C6-142A6FA1B7CF}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {6D9191C7-467F-4DA5-A5FB-D9795C6A8B77} + EndGlobalSection +EndGlobal diff --git a/BinarySearch/BinarySearch/BinarySearch.csproj b/BinarySearch/BinarySearch/BinarySearch.csproj new file mode 100644 index 0000000..244387d --- /dev/null +++ b/BinarySearch/BinarySearch/BinarySearch.csproj @@ -0,0 +1,26 @@ + + + + WinExe + net7.0-windows + enable + true + enable + + + + + True + True + Resources.resx + + + + + + ResXFileCodeGenerator + Resources.Designer.cs + + + + \ No newline at end of file diff --git a/BinarySearch/BinarySearch/Program.cs b/BinarySearch/BinarySearch/Program.cs new file mode 100644 index 0000000..4105b5a --- /dev/null +++ b/BinarySearch/BinarySearch/Program.cs @@ -0,0 +1,17 @@ +namespace BinarySearch +{ + internal static class Program + { + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + // To customize application configuration such as set high DPI settings or default font, + // see https://aka.ms/applicationconfiguration. + ApplicationConfiguration.Initialize(); + Application.Run(new MainForm()); + } + } +} \ No newline at end of file diff --git a/BinarySearch/BinarySearch/Properties/Resources.Designer.cs b/BinarySearch/BinarySearch/Properties/Resources.Designer.cs new file mode 100644 index 0000000..82b9587 --- /dev/null +++ b/BinarySearch/BinarySearch/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// Этот код создан программой. +// Исполняемая версия:4.0.30319.42000 +// +// Изменения в этом файле могут привести к неправильной работе и будут потеряны в случае +// повторной генерации кода. +// +//------------------------------------------------------------------------------ + +namespace BinarySearch.Properties { + using System; + + + /// + /// Класс ресурса со строгой типизацией для поиска локализованных строк и т.д. + /// + // Этот класс создан автоматически классом StronglyTypedResourceBuilder + // с помощью такого средства, как ResGen или Visual Studio. + // Чтобы добавить или удалить член, измените файл .ResX и снова запустите ResGen + // с параметром /str или перестройте свой проект VS. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.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() { + } + + /// + /// Возвращает кэшированный экземпляр ResourceManager, использованный этим классом. + /// + [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("BinarySearch.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Перезаписывает свойство CurrentUICulture текущего потока для всех + /// обращений к ресурсу с помощью этого класса ресурса со строгой типизацией. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + } +} diff --git a/BinarySearch/BinarySearch/Properties/Resources.resx b/BinarySearch/BinarySearch/Properties/Resources.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/BinarySearch/BinarySearch/Properties/Resources.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + \ No newline at end of file diff --git a/BinarySearch/BinarySearch/State/SearchState.cs b/BinarySearch/BinarySearch/State/SearchState.cs new file mode 100644 index 0000000..40f193b --- /dev/null +++ b/BinarySearch/BinarySearch/State/SearchState.cs @@ -0,0 +1,22 @@ +namespace BinarySearch.State; + +[Serializable] +public class SearchState +{ + public int Left { get; } + public int Right { get; } + public int Mid { get; } + public List array { get; } + public int target { get; } + public bool IsExist { get; } + + public SearchState(int left, int right, int mid, bool isExist, List array, int target) + { + Left = left; + Right = right; + Mid = mid; + IsExist = isExist; + this.array = array; + this.target = target; + } +} diff --git a/BinarySearch/BinarySearch/State/StateStorage.cs b/BinarySearch/BinarySearch/State/StateStorage.cs new file mode 100644 index 0000000..cd9fa5b --- /dev/null +++ b/BinarySearch/BinarySearch/State/StateStorage.cs @@ -0,0 +1,101 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Runtime.Serialization.Formatters.Binary; + +namespace BinarySearch.State; + +public class StateStorage +{ + private List states; + private int currentIndex; + + public StateStorage() + { + states = new List(); + currentIndex = -1; + } + + public void AddState(SearchState state) + { + states.Add(state); + } + + public void Clear() + { + states.Clear(); + currentIndex = -1; + } + + public void Reset() + { + currentIndex = -1; + } + + public SearchState? GetNextState() + { + currentIndex++; + if (currentIndex < states.Count) + { + return states[currentIndex]; + } + else + { + return null; + } + } + + public SearchState? GetPreviousState() + { + currentIndex--; + if (currentIndex >= 0 && currentIndex < states.Count) + { + return states[currentIndex]; + } + else + { + return null; + } + } + + public bool IsTraversalComplete() + { + return currentIndex >= states.Count - 1; + } + + public bool SaveToFile(string filename) + { + try + { + BinaryFormatter formatter = new BinaryFormatter(); + using FileStream fs = new FileStream(filename, FileMode.Create); + #pragma warning disable SYSLIB0011 + formatter.Serialize(fs, states); + #pragma warning restore SYSLIB0011 + return true; + } + catch (Exception ex) + { + Console.WriteLine($"Error saving file: {ex.Message}"); + return false; + } + } + + public bool LoadFromFile(string filename) + { + try + { + BinaryFormatter formatter = new BinaryFormatter(); + using FileStream fs = new FileStream(filename, FileMode.Open); + #pragma warning disable SYSLIB0011 + states = (List)formatter.Deserialize(fs); + #pragma warning restore SYSLIB0011 + return true; + } + catch (Exception ex) + { + Console.WriteLine($"Error loading file: {ex.Message}"); + return false; + } + } +} diff --git a/BinarySearch/BinarySearch/binsearch/BinarySearchRunner.cs b/BinarySearch/BinarySearch/binsearch/BinarySearchRunner.cs new file mode 100644 index 0000000..fe78c68 --- /dev/null +++ b/BinarySearch/BinarySearch/binsearch/BinarySearchRunner.cs @@ -0,0 +1,73 @@ +namespace BinarySearch.Algorithm; + +public class BinarySearchRunner +{ + private List sortedArray; + private int target; + private int left { get; set; } + private int right { get; set; } + private int mid { get; set; } + private int? targetIndex { get; set; } + + public BinarySearchRunner(List array, int target) + { + targetIndex = null; + sortedArray = array; + this.target = target; + left = 0; + right = array.Count - 1; + mid = left + (right - left) / 2; + SortArray(); + } + + private void SortArray() + { + sortedArray.Sort(); + } + + public void ExecuteStep() + { + if (left <= right) + { + if (sortedArray[mid] == target) + { + targetIndex = mid; + left = mid + 1; + right = mid - 1; + return; + } + if (left == right) + { + targetIndex = -1; + left = mid + 1; + right = mid - 1; + return; + } + if (sortedArray[mid] < target) + { + left = mid + 1; + } + else + { + right = mid - 1; + } + mid = left + (right - left) / 2; + } + else + { + targetIndex = -1; + } + } + + public Condition CreateState() + { + return new Condition(left, right, mid, targetIndex, sortedArray, target); + } + + public bool IsOver() + { + return left <= right; + } +} + + diff --git a/BinarySearch/BinarySearch/binsearch/Condition.cs b/BinarySearch/BinarySearch/binsearch/Condition.cs new file mode 100644 index 0000000..8f03e96 --- /dev/null +++ b/BinarySearch/BinarySearch/binsearch/Condition.cs @@ -0,0 +1,22 @@ +namespace BinarySearch.Algorithm; + +[Serializable] +public class Condition +{ + public int Left { get; } + public int Right { get; } + public int Mid { get; } + public List Array { get; } + public int Target { get; } + public int? TargetIndex { get; } + + public Condition(int left, int right, int mid, int? targetIndex, List array, int target) + { + Left = left; + Right = right; + Mid = mid; + TargetIndex = targetIndex; + Array = array; + Target = target; + } +} diff --git a/BinarySearch/BinarySearch/binsearch/ConditionStorage.cs b/BinarySearch/BinarySearch/binsearch/ConditionStorage.cs new file mode 100644 index 0000000..b8e6f4e --- /dev/null +++ b/BinarySearch/BinarySearch/binsearch/ConditionStorage.cs @@ -0,0 +1,133 @@ +using System.Runtime.Serialization.Formatters.Binary; +using System.Text.Json; + +namespace BinarySearch.Algorithm; + +public class ConditionStorage +{ + private List states; + private int currentIndex; + + public ConditionStorage() + { + states = new List(); + currentIndex = -1; + } + + public void AddState(Condition state) + { + states.Add(state); + } + + public void Clear() + { + states.Clear(); + currentIndex = -1; + } + + public void Reset() + { + currentIndex = -1; + } + + public Condition? GetNextState() + { + if (currentIndex + 1 < states.Count) + { + currentIndex++; + return states[currentIndex]; + } + else + { + return null; + } + } + + public Condition? GetPreviousState() + { + if (currentIndex > 0 && currentIndex < states.Count) + { + currentIndex--; + return states[currentIndex]; + } + else + { + return null; + } + } + + public bool SaveToFile(string filename) + { + try + { + string extension = Path.GetExtension(filename).ToLower(); + + if (extension == ".bin") + { + // Сохранение в бинарный формат + BinaryFormatter formatter = new BinaryFormatter(); + using FileStream fs = new FileStream(filename, FileMode.Create); +#pragma warning disable SYSLIB0011 + formatter.Serialize(fs, states); +#pragma warning restore SYSLIB0011 + } + else if (extension == ".json") + { + // Сохранение в формат JSON + string json = JsonSerializer.Serialize(states); + File.WriteAllText(filename, json); + } + + else + { + // Неподдерживаемое расширение файла + Console.WriteLine("Unsupported file extension"); + return false; + } + + return true; + } + catch (Exception ex) + { + Console.WriteLine($"Error saving file: {ex.Message}"); + return false; + } + } + + public bool LoadFromFile(string filename) + { + try + { + string extension = Path.GetExtension(filename).ToLower(); + + if (extension == ".bin") + { + // Загрузка из бинарного файла + BinaryFormatter formatter = new BinaryFormatter(); + using FileStream fs = new FileStream(filename, FileMode.Open); +#pragma warning disable SYSLIB0011 + states = (List)formatter.Deserialize(fs); +#pragma warning restore SYSLIB0011 + } + else if (extension == ".json") + { + // Загрузка из файла в формате JSON + string json = File.ReadAllText(filename); + states = JsonSerializer.Deserialize>(json); + } + else + { + // Неподдерживаемое расширение файла + Console.WriteLine("Unsupported file extension"); + return false; + } + + return true; + } + catch (Exception ex) + { + Console.WriteLine($"Error loading file: {ex.Message}"); + return false; + } + } +} diff --git a/BinarySearch/BinarySearch/binsearch/Manager.cs b/BinarySearch/BinarySearch/binsearch/Manager.cs new file mode 100644 index 0000000..6cf3594 --- /dev/null +++ b/BinarySearch/BinarySearch/binsearch/Manager.cs @@ -0,0 +1,31 @@ +namespace BinarySearch.Algorithm; + +public class Manager +{ + private readonly ConditionStorage _storage; + + public Manager(ConditionStorage storage) + { + _storage = storage; + } + + public void ExecuteBinarySearch(Parameters parameters) + { + if (parameters == null) + { + throw new ArgumentNullException(nameof(parameters)); + } + BinarySearchRunner algorithm = new(parameters.Array, parameters.Target); + Condition? state; + _storage.Clear(); + + while (algorithm.IsOver()) + { + state = algorithm.CreateState(); + _storage.AddState(state); + algorithm.ExecuteStep(); + } + state = algorithm.CreateState(); + _storage.AddState(state); + } +} diff --git a/BinarySearch/BinarySearch/binsearch/Parameters.cs b/BinarySearch/BinarySearch/binsearch/Parameters.cs new file mode 100644 index 0000000..645f9c7 --- /dev/null +++ b/BinarySearch/BinarySearch/binsearch/Parameters.cs @@ -0,0 +1,23 @@ +namespace BinarySearch.Algorithm; + +public class Parameters +{ + public List? Array { get; } + public int Target { get; } + + public Parameters() + { + Array = new List(); + Target = 0; + } + + public Parameters(List? array, int target) + { + Array = array; + if (Array != null) + { + Array.Sort(); + } + Target = target; + } +} diff --git a/BinarySearch/BinarySearch/binsearch/Visualizer.cs b/BinarySearch/BinarySearch/binsearch/Visualizer.cs new file mode 100644 index 0000000..bb835b1 --- /dev/null +++ b/BinarySearch/BinarySearch/binsearch/Visualizer.cs @@ -0,0 +1,106 @@ +namespace BinarySearch.Algorithm; + +public class Visualizer +{ + private readonly MainForm _mainForm; + private readonly List _array; + + public Visualizer(MainForm mainForm, List array) + { + _mainForm = mainForm; + _array = array; + } + + public void Visualize(Condition state) + { + Color color; + if (state.TargetIndex == null) + { + color = Color.Pink; + } else if (state.TargetIndex >= 0) + { + color = Color.LimeGreen; + } else + { + color = Color.IndianRed; + } + UpdatePanelByStep(state, color); + } + + public void UpdatePanel() + { + _mainForm.flowLayoutPanelArray.Controls.Clear(); + _mainForm.flowLayoutPanelIndex.Controls.Clear(); + + if (_array != null) + { + for (int i = 0; i < _array.Count; i++) + { + TextBox textBox = new() + { + Text = _array[i].ToString(), + Width = 40, + ReadOnly = false + }; + + TextBox textBoxIndex = new() + { + Text = i.ToString(), + Width = 40, + ReadOnly = true, + Enabled = false + }; + + _mainForm.flowLayoutPanelArray.Controls.Add(textBox); + _mainForm.flowLayoutPanelIndex.Controls.Add(textBoxIndex); + } + } + } + + private void UpdatePanelByStep(Condition state, Color color) + { + _mainForm.flowLayoutPanelArray.Controls.Clear(); + _mainForm.flowLayoutPanelIndex.Controls.Clear(); + if (state.Mid < state.Target) + { + _mainForm.labelMid.Text = ""; + } + if (_array != null) + { + for (int i = 0; i < _array.Count; i++) + { + TextBox textBox = new() + { + Text = _array[i].ToString(), + Width = 40, + ReadOnly = true + }; + + if ((i < state.Left || i > state.Right) && i != state.Mid) + { + textBox.BackColor = Color.Black; + textBox.ForeColor = Color.White; + textBox.Enabled = false; + continue; + } + if (i == state.Mid) + { + textBox.BackColor = color; + textBox.ForeColor = Color.White; + textBox.Enabled = true; + } + + TextBox textBoxIndex = new() + { + Text = i.ToString(), + Width = 40, + ReadOnly = true, + Enabled = false + }; + + _mainForm.flowLayoutPanelArray.Controls.Add(textBox); + _mainForm.flowLayoutPanelIndex.Controls.Add(textBoxIndex); + } + } + } +} diff --git a/BinarySearch/BinarySearch/forms/AddArrayForm.Designer.cs b/BinarySearch/BinarySearch/forms/AddArrayForm.Designer.cs new file mode 100644 index 0000000..84c84c5 --- /dev/null +++ b/BinarySearch/BinarySearch/forms/AddArrayForm.Designer.cs @@ -0,0 +1,156 @@ +namespace BinarySearch +{ + partial class AddArrayForm + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + numericUpDownSearchNumber = new NumericUpDown(); + labelAdd = new Label(); + buttonAdd = new Button(); + buttonSave = new Button(); + listBoxArray = new ListBox(); + label1 = new Label(); + numericUpDownAddNumber = new NumericUpDown(); + ((System.ComponentModel.ISupportInitialize)numericUpDownSearchNumber).BeginInit(); + ((System.ComponentModel.ISupportInitialize)numericUpDownAddNumber).BeginInit(); + SuspendLayout(); + // + // numericUpDownSearchNumber + // + numericUpDownSearchNumber.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right; + numericUpDownSearchNumber.Location = new Point(530, 63); + numericUpDownSearchNumber.Margin = new Padding(4); + numericUpDownSearchNumber.Maximum = new decimal(new int[] { 101, 0, 0, 0 }); + numericUpDownSearchNumber.Minimum = new decimal(new int[] { 101, 0, 0, int.MinValue }); + numericUpDownSearchNumber.Name = "numericUpDownSearchNumber"; + numericUpDownSearchNumber.Size = new Size(92, 26); + numericUpDownSearchNumber.TabIndex = 0; + // + // labelAdd + // + labelAdd.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right; + labelAdd.AutoSize = true; + labelAdd.Font = new Font("Montserrat", 10.8F, FontStyle.Regular, GraphicsUnit.Point); + labelAdd.Location = new Point(355, 65); + labelAdd.Margin = new Padding(4, 0, 4, 0); + labelAdd.Name = "labelAdd"; + labelAdd.Size = new Size(155, 25); + labelAdd.TabIndex = 1; + labelAdd.Text = "искомое число:"; + // + // buttonAdd + // + buttonAdd.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right; + buttonAdd.Location = new Point(355, 111); + buttonAdd.Margin = new Padding(4); + buttonAdd.Name = "buttonAdd"; + buttonAdd.Size = new Size(268, 33); + buttonAdd.TabIndex = 2; + buttonAdd.Text = "добавить"; + buttonAdd.UseVisualStyleBackColor = true; + buttonAdd.Click += buttonAdd_Click; + // + // buttonSave + // + buttonSave.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right; + buttonSave.Location = new Point(355, 152); + buttonSave.Margin = new Padding(4); + buttonSave.Name = "buttonSave"; + buttonSave.Size = new Size(268, 33); + buttonSave.TabIndex = 3; + buttonSave.Text = "сохранить"; + buttonSave.UseVisualStyleBackColor = true; + buttonSave.Click += buttonSave_Click; + // + // listBoxArray + // + listBoxArray.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right; + listBoxArray.FormattingEnabled = true; + listBoxArray.ItemHeight = 21; + listBoxArray.Items.AddRange(new object[] { "" }); + listBoxArray.Location = new Point(18, 18); + listBoxArray.Margin = new Padding(4); + listBoxArray.Name = "listBoxArray"; + listBoxArray.Size = new Size(280, 151); + listBoxArray.TabIndex = 4; + // + // label1 + // + label1.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right; + label1.AutoSize = true; + label1.Location = new Point(18, 182); + label1.Margin = new Padding(4, 0, 4, 0); + label1.Name = "label1"; + label1.Size = new Size(144, 21); + label1.TabIndex = 6; + label1.Text = "элемент массива"; + // + // numericUpDownAddNumber + // + numericUpDownAddNumber.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right; + numericUpDownAddNumber.Location = new Point(196, 180); + numericUpDownAddNumber.Margin = new Padding(4); + numericUpDownAddNumber.Maximum = new decimal(new int[] { 101, 0, 0, 0 }); + numericUpDownAddNumber.Minimum = new decimal(new int[] { 101, 0, 0, int.MinValue }); + numericUpDownAddNumber.Name = "numericUpDownAddNumber"; + numericUpDownAddNumber.Size = new Size(102, 26); + numericUpDownAddNumber.TabIndex = 5; + // + // AddArrayForm + // + AutoScaleDimensions = new SizeF(10F, 21F); + AutoScaleMode = AutoScaleMode.Font; + BackColor = Color.LightSkyBlue; + ClientSize = new Size(655, 224); + Controls.Add(label1); + Controls.Add(numericUpDownAddNumber); + Controls.Add(listBoxArray); + Controls.Add(buttonSave); + Controls.Add(buttonAdd); + Controls.Add(labelAdd); + Controls.Add(numericUpDownSearchNumber); + Font = new Font("Montserrat", 9F, FontStyle.Regular, GraphicsUnit.Point); + Margin = new Padding(4); + Name = "AddArrayForm"; + Text = "заполнение массива"; + ((System.ComponentModel.ISupportInitialize)numericUpDownSearchNumber).EndInit(); + ((System.ComponentModel.ISupportInitialize)numericUpDownAddNumber).EndInit(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private NumericUpDown numericUpDownSearchNumber; + private Label labelAdd; + private Button buttonAdd; + private Button buttonSave; + private ListBox listBoxArray; + private Label label1; + private NumericUpDown numericUpDownAddNumber; + } +} \ No newline at end of file diff --git a/BinarySearch/BinarySearch/forms/AddArrayForm.cs b/BinarySearch/BinarySearch/forms/AddArrayForm.cs new file mode 100644 index 0000000..5b42fb8 --- /dev/null +++ b/BinarySearch/BinarySearch/forms/AddArrayForm.cs @@ -0,0 +1,46 @@ +using BinarySearch.Algorithm; +namespace BinarySearch; + +public partial class AddArrayForm : Form +{ + public delegate void InitParametersDelegate(Parameters searchParameters); + + public event InitParametersDelegate? InitParametersEvent; + + private List _array; + + public AddArrayForm() + { + _array = new List(); + InitializeComponent(); + } + + private void UpdateListBox() + { + listBoxArray.Items.Clear(); + foreach (int number in _array) + { + listBoxArray.Items.Add(number); + } + } + + private void buttonAdd_Click(object sender, EventArgs e) + { + AddNumber((int)numericUpDownAddNumber.Value); + } + + private void AddNumber(int number) + { + _array.Add(number); + UpdateListBox(); + } + + private void buttonSave_Click(object sender, EventArgs e) + { + Parameters parameters = new Parameters(_array, (int)numericUpDownSearchNumber.Value); + InitParametersEvent?.Invoke(parameters); + + this.Close(); + } +} + diff --git a/BinarySearch/BinarySearch/forms/AddArrayForm.resx b/BinarySearch/BinarySearch/forms/AddArrayForm.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/BinarySearch/BinarySearch/forms/AddArrayForm.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + \ No newline at end of file diff --git a/BinarySearch/BinarySearch/forms/InfoForm.Designer.cs b/BinarySearch/BinarySearch/forms/InfoForm.Designer.cs new file mode 100644 index 0000000..cd44391 --- /dev/null +++ b/BinarySearch/BinarySearch/forms/InfoForm.Designer.cs @@ -0,0 +1,64 @@ +namespace BinarySearch +{ + partial class InfoForm + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(InfoForm)); + richTextBox1 = new RichTextBox(); + fontDialog1 = new FontDialog(); + SuspendLayout(); + // + // richTextBox1 + // + richTextBox1.Font = new Font("Montserrat", 12F, FontStyle.Regular, GraphicsUnit.Point); + richTextBox1.Location = new Point(13, 13); + richTextBox1.Margin = new Padding(4); + richTextBox1.Name = "richTextBox1"; + richTextBox1.Size = new Size(1014, 708); + richTextBox1.TabIndex = 0; + richTextBox1.Text = resources.GetString("richTextBox1.Text"); + // + // InfoForm + // + AutoScaleDimensions = new SizeF(11F, 28F); + AutoScaleMode = AutoScaleMode.Font; + BackColor = Color.DarkSlateBlue; + ClientSize = new Size(1040, 734); + Controls.Add(richTextBox1); + Font = new Font("Segoe UI", 12F, FontStyle.Regular, GraphicsUnit.Point); + Margin = new Padding(4); + Name = "InfoForm"; + Text = "информация об алгоритме"; + ResumeLayout(false); + } + + #endregion + private RichTextBox richTextBox1; + private FontDialog fontDialog1; + } +} \ No newline at end of file diff --git a/BinarySearch/BinarySearch/forms/InfoForm.cs b/BinarySearch/BinarySearch/forms/InfoForm.cs new file mode 100644 index 0000000..4b68d72 --- /dev/null +++ b/BinarySearch/BinarySearch/forms/InfoForm.cs @@ -0,0 +1,20 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace BinarySearch +{ + public partial class InfoForm : Form + { + public InfoForm() + { + InitializeComponent(); + } + } +} diff --git a/BinarySearch/BinarySearch/forms/InfoForm.resx b/BinarySearch/BinarySearch/forms/InfoForm.resx new file mode 100644 index 0000000..d3f11a6 --- /dev/null +++ b/BinarySearch/BinarySearch/forms/InfoForm.resx @@ -0,0 +1,153 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + Алгоритм бинарного поиска - это эффективный алгоритм поиска элемента в упорядоченном массиве или списке. Он работает следующим образом: + +1. Определяем начало и конец массива (начальный и конечный индексы). +2. Вычисляем середину массива, как среднее между началом и концом. +3. Сравниваем искомый элемент с элементом в середине массива. + - Если они равны, значит мы нашли искомый элемент и алгоритм завершается. + - Если искомый элемент меньше, чем элемент в середине, то ищем в левой половине массива (от начала до середины). + - Если искомый элемент больше, чем элемент в середине, то ищем в правой половине массива (от середины до конца). +4. Повторяем шаги 2 и 3, пока не найдем искомый элемент или пока не сузим диапазон поиска до 1 элемента. + +Преимущества бинарного поиска: +- Время работы алгоритма имеет логарифмическую сложность O(log n), что делает его очень эффективным для больших массивов. +- Алгоритм работает только с упорядоченными массивами, что позволяет быстро находить элементы. + +Недостатки бинарного поиска: +- Массив должен быть предварительно отсортирован, что требует дополнительных временных и вычислительных ресурсов. +- Алгоритм не может работать с неупорядоченными массивами. + +Бинарный поиск широко применяется в различных областях, таких как поиск в базах данных, в компьютерных алгоритмах, при решении задач с большими объемами информации. +1. После запуска приложения пользователю доступны опции ввода массива, загрузки/сохранения файла, а также пошаговое отслеживание хода алгоритма. + +2. Нажав кнопку "Об алгоритме" в правой части формы, пользователь может ознакомиться с информацией об алгоритме бинарного поиска и принципах его работы. + +3. После ввода массива пользователь нажимает кнопку "Начать бинарный поиск" в правой части формы, чтобы запустить алгоритм. + +4. В нижнем левом углу находятся кнопки, которые позволяют пользователю пошагово наблюдать за ходом выполнения алгоритма бинарного поиска. + + + + + 17, 17 + + \ No newline at end of file diff --git a/BinarySearch/BinarySearch/forms/MainForm.Designer.cs b/BinarySearch/BinarySearch/forms/MainForm.Designer.cs new file mode 100644 index 0000000..3710a4e --- /dev/null +++ b/BinarySearch/BinarySearch/forms/MainForm.Designer.cs @@ -0,0 +1,260 @@ +using System.Linq.Expressions; + +namespace BinarySearch +{ + partial class MainForm + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(MainForm)); + groupBoxTarget = new GroupBox(); + labelTarget = new Label(); + buttonStart = new Button(); + buttonInfo = new Button(); + buttonAddData = new Button(); + buttonStepBack = new Button(); + buttonStepForward = new Button(); + flowLayoutPanelArray = new FlowLayoutPanel(); + flowLayoutPanelIndex = new FlowLayoutPanel(); + menuStrip1 = new MenuStrip(); + файлToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuItemSave = new ToolStripMenuItem(); + toolStripMenuItemLoad = new ToolStripMenuItem(); + saveFileDialog = new SaveFileDialog(); + openFileDialog = new OpenFileDialog(); + labelMid = new Label(); + groupBoxTarget.SuspendLayout(); + menuStrip1.SuspendLayout(); + SuspendLayout(); + // + // groupBoxTarget + // + groupBoxTarget.BackColor = Color.SeaShell; + groupBoxTarget.Controls.Add(labelTarget); + groupBoxTarget.Location = new Point(14, 42); + groupBoxTarget.Margin = new Padding(3, 4, 3, 4); + groupBoxTarget.Name = "groupBoxTarget"; + groupBoxTarget.Padding = new Padding(3, 4, 3, 4); + groupBoxTarget.Size = new Size(236, 76); + groupBoxTarget.TabIndex = 12; + groupBoxTarget.TabStop = false; + groupBoxTarget.Text = "требуемое число"; + // + // labelTarget + // + labelTarget.AutoSize = true; + labelTarget.Location = new Point(20, 29); + labelTarget.Name = "labelTarget"; + labelTarget.Size = new Size(13, 18); + labelTarget.TabIndex = 5; + labelTarget.Text = "-"; + // + // buttonStart + // + buttonStart.Anchor = AnchorStyles.Bottom | AnchorStyles.Left; + buttonStart.Location = new Point(243, 150); + buttonStart.Margin = new Padding(3, 4, 3, 4); + buttonStart.Name = "buttonStart"; + buttonStart.Size = new Size(236, 28); + buttonStart.TabIndex = 3; + buttonStart.Text = "начать бинарный поиск"; + buttonStart.UseVisualStyleBackColor = true; + buttonStart.Click += buttonStart_Click; + // + // buttonInfo + // + buttonInfo.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonInfo.Location = new Point(1060, 150); + buttonInfo.Margin = new Padding(3, 4, 3, 4); + buttonInfo.Name = "buttonInfo"; + buttonInfo.Size = new Size(164, 28); + buttonInfo.TabIndex = 1; + buttonInfo.Text = "о приложении"; + buttonInfo.UseVisualStyleBackColor = true; + buttonInfo.Click += buttonInfo_Click; + // + // buttonAddData + // + buttonAddData.Anchor = AnchorStyles.Bottom | AnchorStyles.Left; + buttonAddData.Location = new Point(16, 150); + buttonAddData.Margin = new Padding(3, 4, 3, 4); + buttonAddData.Name = "buttonAddData"; + buttonAddData.Size = new Size(202, 28); + buttonAddData.TabIndex = 0; + buttonAddData.Text = "добавить данные"; + buttonAddData.UseVisualStyleBackColor = true; + buttonAddData.Click += buttonAddData_Click; + // + // buttonStepBack + // + buttonStepBack.Anchor = AnchorStyles.Left; + buttonStepBack.Location = new Point(731, 154); + buttonStepBack.Margin = new Padding(3, 4, 3, 4); + buttonStepBack.Name = "buttonStepBack"; + buttonStepBack.Size = new Size(84, 28); + buttonStepBack.TabIndex = 4; + buttonStepBack.Text = "назад"; + buttonStepBack.UseVisualStyleBackColor = true; + buttonStepBack.Click += buttonStepBack_Click; + // + // buttonStepForward + // + buttonStepForward.Anchor = AnchorStyles.None; + buttonStepForward.Location = new Point(822, 154); + buttonStepForward.Margin = new Padding(3, 4, 3, 4); + buttonStepForward.Name = "buttonStepForward"; + buttonStepForward.Size = new Size(84, 28); + buttonStepForward.TabIndex = 2; + buttonStepForward.Text = "вперед"; + buttonStepForward.UseVisualStyleBackColor = true; + buttonStepForward.Click += buttonStepForward_Click; + // + // flowLayoutPanelArray + // + flowLayoutPanelArray.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right; + flowLayoutPanelArray.BackColor = Color.Transparent; + flowLayoutPanelArray.Location = new Point(267, 90); + flowLayoutPanelArray.Margin = new Padding(3, 4, 3, 4); + flowLayoutPanelArray.Name = "flowLayoutPanelArray"; + flowLayoutPanelArray.Size = new Size(958, 43); + flowLayoutPanelArray.TabIndex = 3; + // + // flowLayoutPanelIndex + // + flowLayoutPanelIndex.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right; + flowLayoutPanelIndex.BackColor = Color.Transparent; + flowLayoutPanelIndex.Location = new Point(267, 42); + flowLayoutPanelIndex.Margin = new Padding(3, 4, 3, 4); + flowLayoutPanelIndex.Name = "flowLayoutPanelIndex"; + flowLayoutPanelIndex.Size = new Size(958, 43); + flowLayoutPanelIndex.TabIndex = 4; + // + // menuStrip1 + // + menuStrip1.ImageScalingSize = new Size(20, 20); + menuStrip1.Items.AddRange(new ToolStripItem[] { файлToolStripMenuItem }); + menuStrip1.Location = new Point(0, 0); + menuStrip1.Name = "menuStrip1"; + menuStrip1.Padding = new Padding(7, 3, 0, 3); + menuStrip1.Size = new Size(1239, 30); + menuStrip1.TabIndex = 6; + menuStrip1.Text = "menuStrip1"; + // + // файлToolStripMenuItem + // + файлToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { toolStripMenuItemSave, toolStripMenuItemLoad }); + файлToolStripMenuItem.Name = "файлToolStripMenuItem"; + файлToolStripMenuItem.Size = new Size(58, 24); + файлToolStripMenuItem.Text = "файл"; + // + // toolStripMenuItemSave + // + toolStripMenuItemSave.Enabled = false; + toolStripMenuItemSave.Name = "toolStripMenuItemSave"; + toolStripMenuItemSave.ShortcutKeys = Keys.Control | Keys.S; + toolStripMenuItemSave.Size = new Size(171, 26); + toolStripMenuItemSave.Text = "save"; + toolStripMenuItemSave.Click += toolStripMenuItemSave_Click; + // + // toolStripMenuItemLoad + // + toolStripMenuItemLoad.Name = "toolStripMenuItemLoad"; + toolStripMenuItemLoad.ShortcutKeys = Keys.Control | Keys.L; + toolStripMenuItemLoad.Size = new Size(171, 26); + toolStripMenuItemLoad.Text = "load"; + toolStripMenuItemLoad.Click += toolStripMenuItemLoad_Click; + // + // saveFileDialog + // + saveFileDialog.Filter = "bin file (*.bin)|*.bin|json file (*.json)|*.json"; + // + // openFileDialog + // + openFileDialog.Filter = "All files (*.bin, *.json)|*.bin;*.json|Binary files (*.bin)|*.bin|JSON files (*.json)|*.json"; + // + // labelMid + // + labelMid.AutoSize = true; + labelMid.Location = new Point(16, 168); + labelMid.Name = "labelMid"; + labelMid.Size = new Size(0, 18); + labelMid.TabIndex = 7; + // + // MainForm + // + AutoScaleDimensions = new SizeF(9F, 18F); + AutoScaleMode = AutoScaleMode.Font; + BackColor = Color.PeachPuff; + BackgroundImage = (Image)resources.GetObject("$this.BackgroundImage"); + ClientSize = new Size(1239, 201); + Controls.Add(groupBoxTarget); + Controls.Add(labelMid); + Controls.Add(buttonStart); + Controls.Add(buttonStepBack); + Controls.Add(buttonAddData); + Controls.Add(buttonInfo); + Controls.Add(flowLayoutPanelIndex); + Controls.Add(flowLayoutPanelArray); + Controls.Add(buttonStepForward); + Controls.Add(menuStrip1); + Font = new Font("Montserrat SemiBold", 7.79999971F, FontStyle.Bold, GraphicsUnit.Point); + Icon = (Icon)resources.GetObject("$this.Icon"); + MainMenuStrip = menuStrip1; + Margin = new Padding(3, 4, 3, 4); + Name = "MainForm"; + Text = "бинарный поиск"; + groupBoxTarget.ResumeLayout(false); + groupBoxTarget.PerformLayout(); + menuStrip1.ResumeLayout(false); + menuStrip1.PerformLayout(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private GroupBox groupBoxTools; + private Button buttonInfo; + private Button buttonAddData; + private Button buttonStepForward; + private Button buttonStart; + public FlowLayoutPanel flowLayoutPanelArray; + private Label labelTarget; + public FlowLayoutPanel flowLayoutPanelIndex; + private MenuStrip menuStrip1; + private ToolStripMenuItem файлToolStripMenuItem; + private ToolStripMenuItem toolStripMenuItemSave; + private ToolStripMenuItem toolStripMenuItemLoad; + private SaveFileDialog saveFileDialog; + private OpenFileDialog openFileDialog; + public Label labelMid; + private Button buttonStepBack; + private ProgressBar progressBarSteps; + private GroupBox groupBox2; + private GroupBox groupBoxTarget; + } +} \ No newline at end of file diff --git a/BinarySearch/BinarySearch/forms/MainForm.cs b/BinarySearch/BinarySearch/forms/MainForm.cs new file mode 100644 index 0000000..9909f9a --- /dev/null +++ b/BinarySearch/BinarySearch/forms/MainForm.cs @@ -0,0 +1,134 @@ +using BinarySearch.Algorithm; + +namespace BinarySearch; + +public partial class MainForm : Form +{ + private readonly ConditionStorage _stateStorage; + private readonly Manager _manager; + private Parameters _parameters; + private Visualizer _visualizer; + + public MainForm() + { + InitializeComponent(); + _stateStorage = new ConditionStorage(); + _manager = new Manager(_stateStorage); + _parameters = new Parameters(); + _visualizer = new Visualizer(this, _parameters.Array); + buttonStepForward.Enabled = false; + buttonStepBack.Enabled = false; + buttonStart.Enabled = false; + } + + private void buttonAddData_Click(object sender, EventArgs e) + { + AddArrayForm initDataForm = new(); + initDataForm.InitParametersEvent += InitParametersEventHandler; + initDataForm.ShowDialog(); + } + + private void InitParametersEventHandler(Parameters searchParameters) + { + _parameters = new Parameters(searchParameters.Array, searchParameters.Target); + _visualizer = new Visualizer(this, _parameters.Array); + _visualizer.UpdatePanel(); + labelTarget.Text = searchParameters.Target.ToString(); + buttonStart.Enabled = true; + } + + private void buttonStart_Click(object sender, EventArgs e) + { + _stateStorage.Reset(); + _visualizer.UpdatePanel(); + _manager.ExecuteBinarySearch(_parameters); + toolStripMenuItemSave.Enabled = true; + buttonStepForward.Enabled = true; + buttonStepBack.Enabled = false; + } + + private void buttonStepForward_Click(object sender, EventArgs e) + { + Condition? searchState = _stateStorage.GetNextState(); + Condition? searchStateCheck = _stateStorage.GetNextState(); + if (searchStateCheck == null && searchState != null) + { + buttonStepForward.Enabled = false; + if (searchState.TargetIndex != null && searchState.TargetIndex >= 0) + { + MessageBox.Show($"число {searchState.Target} найдено с индексом {searchState.TargetIndex}", "итог", MessageBoxButtons.OK, MessageBoxIcon.Information); + } else if (searchState.TargetIndex != null && searchState.TargetIndex < 0) + { + MessageBox.Show($"число {searchState.Target} не найдено", "итог", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + _visualizer.Visualize(searchState); + return; + } + searchState = _stateStorage.GetPreviousState(); + if (searchState == null) + { + return; + } + _visualizer.Visualize(searchState); + buttonStepForward.Enabled = true; + buttonStepBack.Enabled = true; + } + + private void buttonStepBack_Click(object sender, EventArgs e) + { + Condition? searchState = _stateStorage.GetPreviousState(); + if (searchState == null) + { + return; + } + _visualizer.Visualize(searchState); + buttonStepForward.Enabled = true; + buttonStepBack.Enabled = true; + } + + private void buttonInfo_Click(object sender, EventArgs e) + { + InfoForm infoForm = new(); + infoForm.ShowDialog(); + } + + private void toolStripMenuItemSave_Click(object sender, EventArgs e) + { + if (saveFileDialog.ShowDialog() == DialogResult.OK) + { + if (_stateStorage.SaveToFile(saveFileDialog.FileName)) + { + MessageBox.Show("Сохранение прошло успешно", "Результат", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + else + { + MessageBox.Show("Не сохранилось", "Результат", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + } + + private void toolStripMenuItemLoad_Click(object sender, EventArgs e) + { + if (openFileDialog.ShowDialog() == DialogResult.OK) + { + if (_stateStorage.LoadFromFile(openFileDialog.FileName)) + { + Condition? state = _stateStorage.GetNextState(); + if (state != null) + { + _parameters = new Parameters(state.Array, state.Target); + _visualizer = new Visualizer(this, _parameters.Array); + _visualizer.UpdatePanel(); + labelTarget.Text = state.Target.ToString(); + _stateStorage.GetPreviousState(); + } + buttonStart.Enabled = true; + MessageBox.Show("Загрузка прошла успешно", "Результат", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + else + { + MessageBox.Show("Не загрузилось", "Результат", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + } +} \ No newline at end of file diff --git a/BinarySearch/BinarySearch/forms/MainForm.resx b/BinarySearch/BinarySearch/forms/MainForm.resx new file mode 100644 index 0000000..72a3bae --- /dev/null +++ b/BinarySearch/BinarySearch/forms/MainForm.resx @@ -0,0 +1,2364 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + 132, 17 + + + 267, 17 + + + + + /9j/4AAQSkZJRgABAQEASABIAAD/7gAOQWRvYmUAZAAAAAAB/+EHPEV4aWYAAE1NACoAAAAIAAwBAAAD + AAAAAQUAAAABAQADAAAAAQLQAAABAgADAAAAAwAAAJ4BBgADAAAAAQACAAABEgADAAAAAQABAAABFQAD + AAAAAQADAAABGgAFAAAAAQAAAKQBGwAFAAAAAQAAAKwBKAADAAAAAQACAAABMQACAAAAHwAAALQBMgAC + AAAAFAAAANSHaQAEAAAAAQAAAOgAAAEUAAgACAAIAEgAAAABAAAASAAAAAEAAEFkb2JlIFBob3Rvc2hv + cCAyMy4zIChXaW5kb3dzKQAAMjAyNDowNToyMiAyMDoxODowMAAAA5AAAAcAAAAEMDIzMaACAAQAAAAB + AAAFe6ADAAQAAAABAAAA+QAAAAAAAAAGAQMAAwAAAAEABgAAARoABQAAAAEAAAFiARsABQAAAAEAAAFq + ASgAAwAAAAEAAgAAAgEABAAAAAEAAAFyAgIABAAAAAEAAAXBAAAAAAAAAEgAAAABAAAASAAAAAH/2P/t + AAxBZG9iZV9DTQAB/+4ADkFkb2JlAGSAAAAAAf/bAIQADAgICAkIDAkJDBELCgsRFQ8MDA8VGBMTFRMT + GBEMDAwMDAwRDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAENCwsNDg0QDg4QFA4ODhQUDg4ODhQR + DAwMDAwREQwMDAwMDBEMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwM/8AAEQgAHACeAwEiAAIRAQMR + Af/dAAQACv/EAT8AAAEFAQEBAQEBAAAAAAAAAAMAAQIEBQYHCAkKCwEAAQUBAQEBAQEAAAAAAAAAAQAC + AwQFBgcICQoLEAABBAEDAgQCBQcGCAUDDDMBAAIRAwQhEjEFQVFhEyJxgTIGFJGhsUIjJBVSwWIzNHKC + 0UMHJZJT8OHxY3M1FqKygyZEk1RkRcKjdDYX0lXiZfKzhMPTdePzRieUpIW0lcTU5PSltcXV5fVWZnaG + lqa2xtbm9jdHV2d3h5ent8fX5/cRAAICAQIEBAMEBQYHBwYFNQEAAhEDITESBEFRYXEiEwUygZEUobFC + I8FS0fAzJGLhcoKSQ1MVY3M08SUGFqKygwcmNcLSRJNUoxdkRVU2dGXi8rOEw9N14/NGlKSFtJXE1OT0 + pbXF1eX1VmZ2hpamtsbW5vYnN0dXZ3eHl6e3x//aAAwDAQACEQMRAD8A7DGxMfGxqsahpZTQxtdTNzjD + Gjaxu5ztyLsb4n7z/ehMshT9UFX6HZrghHaXNB2uI+arOvyP3yrLxuQnUnt9yGga+XiBsE0gOTkD88pv + tV/75TvYgOBBTxRWRyS6klOMu6fplTbkPPL3feVTmFIPQIZIzPVvtvdM7jPjJRBfZAAe6BwJMLP9Qwi1 + WEjVDgG9L/c6NsvJduJO495M6IWQ/NPojFMn1W+qC4g+mA4v2n+t6ag60xopNyzjsfeXtraxhLrHGA0D + 3epu/N2Js4+giI1P7umq/HP1xJNj+t6g2TR1FrH2OI9jdxrBMx9L3a7mJMsLho50jRwkyDztcqduNhdO + GLY/LZTLAa8p9grtsG5jsn1rHt35G/1K3/pbPV9T/rqp5HX2Y+bde/07cYXBtt1FjLJocBYzL9GpznM+ + xvc+q/2/pK/5aq4c2aUonhlKEyIbbH97/vm1kxYoxl6xGURxanh4v6nq/S/cdwOPiT8ypTPIn5qOnYgj + sRqD5hSCuUGBkAw9oUvTHYqIUmyE0+CWnc5zbXtBOhjkqjm2ON2DLyIypGp1/V8v2q3kn9Ys/rKjlMdZ + dhuaQBVkGx09x6OTVtb/AG7mIken7GIS9X1f/9DqQ7XyU2lC+CmyZWg0oW2WahSLZEKNfGimUGZq31ay + OypvZqtG3gqmY7pDwaeXh4vSWsWqCOYQjElPWxtTQisCg2EZkJJF2uGErHzPt/Vc+zpGBdVXSweneHOL + XXv1dkUU27LG+njMbsyW7v8ASLXyvtP2LI+x/wBL9J/2fx9TafT2/wAvd9D+WuY+qX237JmfZ/U+lXMT + PH6Dd+ds9b1Po/8ACqPJKcYk44e5k04Y2I9d7l+62cMYykBOYxx/SlUp6f1eH9J0b6cyjEs6V1GtzQId + TYI0LI2mq32+z2fzv9T1f5tF6b0TEyamZOcftljXO2scA2tuv57K/wCkOczY79J+h/4BY+T+1pr+2evv + 9H9b9T6Pretf/MR7f6P6O7/C/wA1/hFu/VLf+zLN8bftDvT2TEbKt/0/0u/1d/q+t+m9X6aPLkHDI4xw + yM/1scf82Mn6fB/6AxZYyjzcRlmJxEP6McsRHOcf737/AO//ANT/AJz/ACbttlGCg2FMQk2AyCmFEQpd + k0rtWjfUHW2Esu5mWtrIOg+hvuY7/oqFmJU3KqqNshzS4O00cAfb9LZ9H+UquZ9o+3XfzPpbjE7t/Aif + zUE79J2c6RMTH539lACW5ka7UGMmNgCIu97L/9kA/+ICQElDQ19QUk9GSUxFAAEBAAACMEFEQkUCEAAA + bW50clJHQiBYWVogB88ABgADAAAAAAAAYWNzcEFQUEwAAAAAbm9uZQAAAAAAAAAAAAAAAAAAAAAAAPbW + AAEAAAAA0y1BREJFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK + Y3BydAAAAPwAAAAyZGVzYwAAATAAAABrd3RwdAAAAZwAAAAUYmtwdAAAAbAAAAAUclRSQwAAAcQAAAAO + Z1RSQwAAAdQAAAAOYlRSQwAAAeQAAAAOclhZWgAAAfQAAAAUZ1hZWgAAAggAAAAUYlhZWgAAAhwAAAAU + dGV4dAAAAABDb3B5cmlnaHQgMTk5OSBBZG9iZSBTeXN0ZW1zIEluY29ycG9yYXRlZAAAAGRlc2MAAAAA + AAAAEUFkb2JlIFJHQiAoMTk5OCkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFhZWiAAAAAAAADzUQABAAAAARbM + WFlaIAAAAAAAAAAAAAAAAAAAAABjdXJ2AAAAAAAAAAECMwAAY3VydgAAAAAAAAABAjMAAGN1cnYAAAAA + AAAAAQIzAABYWVogAAAAAAAAnBgAAE+lAAAE/FhZWiAAAAAAAAA0jQAAoCwAAA+VWFlaIAAAAAAAACYx + AAAQLwAAvpz/2wBDAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQECAQEBAQEBAgICAgICAgICAgIC + AgIDAwMDAwMDAwMDAwMDAwP/2wBDAQEBAQEBAQIBAQIDAgICAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMD + AwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwP/wAARCAD5BXsDAREAAhEBAxEB/8QAHwAAAAYCAwEAAAAA + AAAAAAAABwgGBQQJAwoCAQAL/8QAtRAAAgEDBAEDAwIDAwMCBgl1AQIDBBEFEgYhBxMiAAgxFEEyIxUJ + UUIWYSQzF1JxgRhikSVDobHwJjRyChnB0TUn4VM2gvGSokRUc0VGN0djKFVWVxqywtLi8mSDdJOEZaOz + w9PjKThm83UqOTpISUpYWVpnaGlqdnd4eXqFhoeIiYqUlZaXmJmapKWmp6ipqrS1tre4ubrExcbHyMnK + 1NXW19jZ2uTl5ufo6er09fb3+Pn6/8QAHwEAAAYDAQEBAAAAAAAAAAAABgUEAwcCCAEJAAoL/8QAtREA + AgEDAgQEAwUEBAQGBgVtAQIDEQQhEgUxBgAiE0FRBzJhFHEIQoEjkRVSoWIWMwmxJMHRQ3LwF+GCNCWS + UxhjRPGisiY1GVQ2RWQnCnODk0Z0wtLi8lVldVY3hIWjs8PT4/MpGpSktMTU5PSVpbXF1eX1KEdXZjh2 + hpamtsbW5vZnd4eXp7fH1+f3SFhoeIiYqLjI2Oj4OUlZaXmJmam5ydnp+So6SlpqeoqaqrrK2ur6/90A + BACw/9oADAMBAAIRAxEAPwDTfqf823/BW9+6919DH+R/3Dv/AGr/ACwPjbgMHmIKTF0U3Zr00D4rHVLI + ansXIVE15p0Ltd2J5PH0HuVOWeWNj3HZIby8hLyOXqdbCtGIGAacB0Ct43jcbTcZLe3kCoumg0g8QCck + dWwDv/tZvpuKl4/6seJ/69+z7+pfLX/KOf8AnI/+fot/rDvH+/R/vC/5uu/9Pva3/PRUv/njxP8A179+ + /qXy15QN/wA5H/z9e/rDvH+/R/vC/wCbrkO/u1Lc7hpif+1Hif8Ar37r/Urlv/fB/wCcj/5+vf1h3f8A + 36P95X/N1lHfXahF/wC8NKOL84PFf7b/ADfv39S+W/8AfB/5yP8A5+qnmTdgaeKP95X/ADde/wBPXawI + I3FSC17/AO4PE/8AXv37+pfLf++D/wA5H/z9a/rJu3+/R/vC/wCbrl/p87X/AOeipP8Azx4n/r179/Uv + lv8A3wf+cj/5+vf1k3b/AH6P94Xrge++2b8bkpAP6fwHEn/rn79/Uvlv/fB/5yP/AJ+vf1k3b/fg/wB5 + X/N1m/099r/89DR/+eTF/wDXv37+pXLf++D/AM5H/wA/V/6w7v8A79H+8r/m65f6e+1f+ehpP/PHiv8A + r379/Urlv/fB/wCcj/5+vf1h3f8A36P94X/N1kTvrtNvruCluP8AqyYr/r373/Urls/6Af8AnI/+fr39 + Yd3/AN+j/eV/zdcj3z2kBf8AvBS/+eTFf9e/e/6k8uf74P8Azkf/AD9e/rDu/wDv0f7yv+brw757SIv/ + AHgpf/PJiv8Ar379/Unlz/fB/wCcj/5+vf1h3f8A36P95X/N13/p47S/56Cl/wDPJiv+vfvf9SeWv98H + /nI/+fr39Yd3/wB+j/eV/wA3XY747Q/O4Kb/AGGExX/Xv37+pPLX++D/AM5H/wA/Xv6xbv8A79H+8r/m + 67/08dn/APO/p/8Azy4r/r373/Unlr/fDf8AOR/8/Xv6xbv/AL8H+8r/AJuux3z2gDcZ+n/88mK/69+9 + f1J5a/3w3/OR/wDP17+sW7/78H+8r/m65jvrtJjYZ+m/88mK/wCvfv39SeWv98H/AJyP/n69/WHd/wDf + o/3lf83Xv9PXaX/O+p//ADx4r/r379/Unlr/AHwf+cj/AOfr39Yd3/36P95X/N12O9e1W5G4aVR+AcHi + r/8AWv37+pPLX++D/wA5H/z9a/rDvH+/R/vC/wCbrkO9O1R9dw0h/wDIJixz/wBS/bickcssTW3b/nI/ + +frY5h3f/fo/3lf83XId7dpfnP0n+wwuL/69+3P6jcr/APKO3/OR/wDP1v8ArDuwz4o/3lf83XL/AE69 + o/8APQUv/nlxf/Xv37+o3K//ACjt/wA5H/z9V/rJuv8Avz/jK/5uvf6de0f+egpf/PLi/wDr379/Ublf + /lHb/nI/+fr39ZN1/wB+f8ZX/N1wbvftFf8AmIKX6G3+4TF/9e/fv6jcr/8AKO3/ADkf/P1scxbsciQf + 7yv+brGO9+02/wCYipBxe5wmK/2H+6/ejyNywBX6dj/zcf8Az9bPMO7/AO/B/vK/5usg717T087io/8A + X/gmL/2H+6/dDyTyuONs3/OR/wDP1o8xbuP9EH+8r/m6xt3v2qLf7+KjH/kExX1P4/zfv39SeWCMWzf8 + 5H/z9e/rDu/lKP8AeV/zdYH777WFyNxUlh/1Y8Ufz9R+378vJPLBNDbt/wA5H/z9e/rDu/8Av0f7yv8A + m64L332uQSdx0nP0/wBwWJ4/r/uv26ORuVq5t2/5yP8A5+t/1h3f/fo/3lf83XNe+u1vzuKlP/kCxX/E + R+3V5D5Wbhbtn/hr/wCfptuYt5H+ij/eF/zdZG767T0ahuClB5/5cmKN7D6/5v3Ycg8rFqfTt/zkk/z9 + aHMe81/tR/vC/wCbqOO/e1yL/wB4qX/zxYn/AK9+9jkHlbUAbc/85JP8/VjzHu/+/R/vC/5uux372rcE + 7jpSD/1YsV/T/ll73/rf8r/8o5/5ySf5+vDmPd/OQf7yv+brv/T52qb23HSAfj/cFiv6/wDLL3VuQeVV + /wCI7f8AOST/AD9a/rJu3+/R/vK/5uuj352uPpuOkP8A5AsUP97j90/qHyt/yjt/zlf/AD9b/rJu3+/R + /vK/5uuv9PnbH/PRUn/njxP0/wCpXvx5D5W8rdv+ckn+fr39ZN2/36P94X/N1ib5AdsBtP8AeKk/rf8A + geJ4H+P7Xvx5D5Wpi3P/ADkk/wA/XhzHu3nKP94X/N11/swXa4aw3FS8f9WLE2/1+Ive/wCofK1P9x2/ + 5ySf5+rf1i3f/fg/3lf83XNfkF2zex3JScWv/uCxH0/6le9f1D5W/wCUc/8AOST/AD9UPMm8cRKP95X/ + ADdcm+Qfa4BtuKlJ/H+4LE/9evfhyFyvXNuf+cj/AOfpluZt6B/tBT/SL/m6x/7MJ21/z0dJ/wCeLEf9 + evdv6hcrf8o5/wCckn/QXXv6z7z/AL8H+8L/AJusqfIHtgn1bko7fX/ix4j/AHn9r37+oXKv/KO3/OWT + /oLqv9Zt7/36P94X/N15/kF2uACNyUlz9B/AsSRa/wBf8179/UPlX/lHb/nK/wDn69/Wbe/9+j/eF/zd + Yv8AZhO2r8bipOB9DgsRz/j/AJv3Uch8rKKtbsf+bkn+frX9Zt7/AN+j/eF/zddH5Cdtgr/v5KSx4NsD + iCfpcH/Ne/DkTlVuFsw/5uSf5+t/1n3v/fo/3hf83Xj8gu278bnogPwDgMRf/Y/te3k5A5UJzbN/zkk/ + z9ePM29AYmH+8L/m6xn5CduA2G5qQ/4jAYj/AImL3Y+3/KgNPpm/5yyf9BdbHNG9eco/3hf83XEfIftv + UAdyUv5vbAYe39P+OXujcg8qg4tm/wCckn/QXWv6z73/AL9H+8L/AJupn+zBdsWuNyUhIF+MFiD+L/iL + 3f8AqByn/wAozf8AOWT/AD9a/rPvnnKP94X/ADdeT5DdtH67kpD+RfA4gD/rV79/UDlP/lGb/nLJ/wBB + de/rPvf+/R/vC/5uuf8AswnbJ/5iSj/88WI/69+/f1A5T/5Rm/5yyf5+vf1n3v8A36P94X/N14/ITtoC + /wDeSl/88OH/AOvXv39QOVP+UZv+csn/AEF17+s+9/79H+8L/m64L8he22Y/7+SlsB/zocR/X/ll79/U + DlT/AJRm/wCcsn/QXXv6z73/AL9H+8L/AJusg+QfbX53JSf+eLEW/wCtXtxPb7lM8bZv+csn/QXTiczb + yR3TD/eF/wA3Xv8AZg+2f+ekpP8AzxYf/r17v/recpf8orf85ZP8/Vv6y7v/AL9H+8r1zX5Cdrj67jpS + f+1FiP8AiI/fv9bzlL/lFb/nLJ/0F1v+su7/AO/R/vK/5uuR+Qfao/5iKk/2GDxJ/wB7j9+/1vOUv+UV + v+csn/QXXv6y7v8A79H+8r/m66HyD7XI/wCPipf/ADx4j/eP2/ev9b3lL/lGb/nLJ/0F0w3M+9hjSUf7 + wv8Am67PyE7WtYZ+kB/r/BMV/vXj9+/1veUf+UZv+csn/QXWv6z73/v0f7wv+brtfkF2vYf7+Kj1f9qP + E/714/fv9b3lH/lGb/nLJ/0F17+s+9/79H+8L/m65t8hO2LencdIf/IHh/z9D/m/dx7eco1zat/zlk/6 + C68OZ99/36P94X/N1Hf5F9pRBVl3XjoZCobTLhsJGWU3F1Vox+Ra/ur8g8lRnTJBpPzmcf4W6v8A1l3w + 8JR/vC/5uuK/I7s82J3firc8DE4P/Yc6PdByLyMf9CH/ADnf/oLr39Zd8/36P94X/N1z/wBmO7Nv/wAf + di7cf8unB/7H+x73/UTkf/fP/Vd/+guvf1l3z/fo/wB4X/N1y/2Y3s7/AJ63Gf8Anpwn/Xv37+onI/8A + vn/qu/8A0F17+su+f79H+8L/AJuuh8jeziSP72Y3j/q0YT/r379/UTkf/fP/AFXf/oLrf9ZN9/34P94X + /N1y/wBmL7Q/56vHf+efCf8AXv37+onI/wDvn/qu/wD0F17+sm+/78/4wv8Am66/2YntIsLbrx1vyP4P + hL/6/wDm/fv6icj/AO+f+q7/APQXXv6yb7/vz/jC/wCbrm3yI7RHK7qx1vyP4PhSf8QP2/fv6ickf75/ + 6rv/ANBde/rJvv8Avz/jC/5uuk+RHabFb7poLX9VsLhv9hyY/ejyJyRTEX/Vd/8AoLrX9Zd8/wB+j/eF + /wA3UwfITs0jndGPvz/y6MN/vWj3T+onJX++v+qz/wDQXWv6yb9/vz/qmP8AN1zHyA7P/wCeox5B/ph8 + Nx/tk91HJXI0ciCWEkE0NJnx9tGx1b+se/aHfxR2itNC1P2Yyfl1ik+QvZsKTVEu5qZ4aeF53igwOJmn + lEa6/FBHHEWZ3I0qoBPPusnJPJQmYxwVQDH6z+nrq6UR8z7pG0ImbUHNGog7fmaDA+2nQWYL5LfI/IJW + ZDIZ6OhhrayeTGYl9o4aObGY0MVplqmlgEjSsLMwb6Xt7iHddmnF3JHt1lKqKSAdMjD8iRkdC60u1idp + Lu8jkVj2qCg0j5kf5elPF8ie9CAG3PAzH6t/dbDj8/QgQeyiPad3Rv17SVgPSN/83Rqm57Lbxsl7KrSM + OzQwYA+VSpIH59S4/kF3i3Lbmp7fUD+7GIF/8P8AM+3zs+4MxKWkwHkPDev+DpiLcrBIlFzLGZKZo6kf + yNOHQi9b9pdt723NS4vL9j7f2nhqZRU5XKZnFbcoEmgDf8BaJq1EVpW/AH0+p96/c25gZtJv+cb/AObp + 87htpHbIlf8ATj/P17sjv/fr9l5TDde5Onxux9qUdPjpsrUY3G143pm5I9dTkKCoqUYCni4AanOhiT/T + 26myblpq1rLX/mm/+bpG19CX7JkA/wBMv+fpgTvvtgtZtwU4CfqP8BxIDi30UNHc/wCw92Ox7jT/AHFl + /wCcb/5ut/W24+K4j/3pf8/UGs7m7pqgZaLsRMZ+VgG09sVCnnnWaiAsOP6e2v3Jun/KLN/zjf8Azda+ + vtj/AMSI/wDel/z9LDZHaPyGklNXX57qbc2NTV/k25sxi9l5GQ/i0cclPz/iBb347Luflazf843/AOge + vfvC2Va+PGx/0y/5+hrofkVh6SNKbfm0Z9u1DBYnyu0dw4jfdAs5NvJDS4SepmCfkmVLW90Ox7x5Ws3/ + ADif/oHpr982QNGdf96X/P0MeH7F6qnwzZKTfuFqI41kmf8AiNfSYvK6UXX4lw7GKYtbgKItRPAufev3 + JvH/ACizf84n/wCgen13OwfImQfawH+E9Fk3t8gstnsg1H12YtpYWjqjGdwZeCmq8rm1RrOaTE5HUkEL + D6PMisfqPbi7Hu3nazH/AJtSf9A9WO4WXlNH/va/5+mxe5d8A6W3Xi/T6S5ocONZAtr/AE25+vHvf7i3 + b/lEm/5xSf8AQPXhuFjTM8f+9r/n6mJ3DvFwtt2Yom3q/wAjw5N/9YD379xbv/yhzf8AOKT/AKB63+8L + H/f8f+9r/n6mf6Xd2WX/AH9OK/2q9NiRbn8XHvX7i3f/AJRJv+cT/wDQPXv3hY/7/j/3tf8AP1JHbe5f + TfdmHHP5iw41C/5/p7cXYN3JobOb/nFJ/wBA9eG42ANTNGR6a1/z9SU7a3E7BTunAre1yzYgKD/S5P8A + vPtqDl3fWuyslrN4eafpOB8s6a9UN9aTamhuI1A4Auo/ZU1PRJO0/k18psF3BvbBbRzU9TsWjosHUbbq + KDYWKy+PEtRDIclHBm0pZPuHVgmpTK2n+gv7hXn6L3kst3MPKVjdGAfw2Lyg/PUYm/w9ZDe2O2ezW78v + NJzheWy3uoU13ywUXzGnxVB+2nSQT5V/MAyRhstkCpYFv+MbYpVKhrlWZqPi68X9guXcPf0UhXbL8N5s + NrkI/wCrFOh+eW/u5y3i28N7Zqvmx3RafPJnp/Ppo67+YfzWjzu7INy4HIb1xskVVQ4WOq2dgtk/wCrf + /gBlqSvqoKaKuQEkSRuziwvbn2O+Wbj3UjbXzDtF7cKtKgWUsZPr8MQ/l1H3NXL3tJHcPbbJutpDx0ut + 7HMp9KnxGHQgDt/+YFnceMh/fHqbYq0NCzy0Pg2tnMtmJkGousf7scchHHjUAX4A9iPfNw56nQScu8s3 + iBfiDwT1P2al6Dmw7D7cxSNFv2+W0teDLPGoH+8tT9vXXWXzI+Sa5iLa3aeNycgqzKMbvrC7CC4tqhSV + +0zdJHS2plv+mcqqH66rexX7ZbhuW+z/AEXOXK99aPqoHeG6jQr66iqp/P7Oib3C5W5d2i0+v5T5gsp0 + pXQtxbySA+mgOW/l0ZM99dmA2/vJQ3vz/uHxBFvwAfH7yHm5A5UM6iG1YIf+GSf4a9QLb77ughJuJ1LD + +in+Drn/AKeOyrX/ALzUP+xw+H/6M97Pt9yrXFs3/OWT/P1dd/vyKmUf7yv+brl/p47HA/4+fHXt/wA6 + rEf0/wAE9+/1vuVf+UZv+ckn+frZ36/AxKv+8r1j/wBPnZN+dx48c/8AOpxPP+t6Pac8gctE4tnH/NyT + /P1r9/bh/v1f95X/ADdSF747E03bctAOL3OKxI/P+Ke9r7f8s6u62an/ADUk/wA/Wjv+4UxKv+8r1kXv + bsNgf9/Njr82/wBxmI/px/Y9u/63/Kv/ACjN/wA5ZP8AP1X9/wC5f79H+8r/AJuvN3p2MPpuWgP/AJCs + Tf8A3hPe/wDW/wCVf+UZv+ckn+fra7/uJOZR/vK9cf8ATt2P/wA9HQf+enFcf8me9j2+5WY6VtmJP/DJ + P8/Vjv8AfAVMygD5L17/AE7dj/8APR0P/npxP5+n9j3T+oPKRJUW7VXj+q+Pt7sdXk3zcYWVJZApYVAK + qCR6gEZH2dcT3x2KP+YkoP6/8WnFH/oj24fbzlcFQbVwW4fqSZ+zOfy6q+/X8aLJJKqq5opIUAn0BPE/ + IdZ1757EIBO5ccP9fF4gf72nup9veVgaG1eo/wCGSf5+tjfr4/6Kv7F65f6eew/+emx3/nrxH/Rnv3+t + 9yt/yjN/zkk/z9bO/wB6OMy/sXrA3fnY3FtyUNv+1TiD/wBEe1H+t1yn/wAozf8AOWT/AD9b/f16eEq/ + sXr3+nrsj8bmx4/8hOH/AKf8E97/ANbrlPztW/5yyf5+t/v29/36v7F64jvrsm/O58eR/hicP/1797/1 + u+Uf+UVv+csn/QXV03u8NdUq/sXrs989lf2dy0H+xxGI/wCvfvf+t1yj/wAorf8AOWT/AKC6f/fU/nMv + /Gesg737JKj/AH8tBf8AP+4nEf8AXv3r/W75QHG2b/nLJ/0F1v8AfU3+/l/4z1xbvfskWtuWh/x/3EYf + /bf5v37/AFvOT/8AlGb/AJyyf9Bde/fUv+/l/wCM9dr3x2TcX3LQ/X84jEDj+n+b96/1vOUPK2b/AJyy + f9BdNne7iuJl/wCM9Zv9OvY3/PTY7/z14j/oz37/AFuuUv8AlGb/AJyyf9Bde/fV1/v1f2L15u9+xQB/ + v5cffm5/heIt/h/Y97/1uuUv+UZv+csn/QXXv31df79X9i9cl737ENh/eOhvxe2KxNr/AJ/se/f63XKX + /KM3/OWT/P1799XX+/V/YvXL/Tp2J/z0lB/56sT/ANGe9f63XKX/ACjN/wA5ZP8AoLr376uv9+r+xevf + 6dOxP+ekoP8Az1Yn/oz37/W65S/5Rm/5yyf9Bdb/AHxef78H7F68e9ewx9dyUH/nrxP/AEZ79/rdcpf8 + ozf85ZP+guvfvi8/34v7F6yDvXsDj/fy4+9h/wAuzE/X/kn37/W65S/5Rm/5yyf5+vfvi8/34P2L13/p + z7B/G5Mf/wCezE/9Ge9/63XKX/KM3/OWT/oLq67vdnjIP2L17/Tn2H/z0dB/568V/wBGe/f63XKX/KM3 + /OWT/oLq/wC9rr/fg/YvXv8ATl2H/wA9HQf+evFf9Ge9/wCtzyl/yit/zlk/z9a/e9yOMi/sXrpe8uxP + o246Ef4nFYkC3/JHv3+tzyn/AMorf85ZP8/Xhu9x/v1f2L1lHeHYJFxuWgP/AJDMTb/eE96/1uuUv+UV + v+csn/QXVW3a9rQOP2DrJ/pu7A/56XHf+e3E/wDRnvR9u+URxtm/5yyf9Bda/e97/GP2DrIO7+wz9Nx4 + 8/62LxR/6I90/wBb3lH/AJRm/wCcsn/QXXv3vejjIP2L1z/039g/89HQ/wDnrxX/AEZ78Pb3lGv+4zf8 + 5ZP+guvfve8/34P2Drv/AE3dg2v/AHiobf1/heKt/wBCe7f63nKH/KM3/OWT/oLrY3a+PBx/vI68O7ew + z9Nw0R/1sViz/wBEe/H285R8rZv+csn/AEF17963/wDGP95HXv8ATb2H/wA9DRf+erF/9Ge6/wCt7yl/ + yjN/zlk/6C63+9b7+Mf7yOvf6bOw/wDnoKP/AM9WL/6M9+/1veUf+UZv+csn/QXXv3rf/wAQ/wB5HXId + 19icXz9JY/8AVpxY/wB7T37/AFveUf8AlGb/AJyyf9Bde/el/wDxD/eR1z/009hE/wDHw0YFvp/CsXe/ + /JHv3+t7yl/yjN/zlk/6C69+9L/+If7yOknurvbt+iGP/guaSXymoFSYNu4ys0hdPiL2ibT9Tb+vtJdc + gctR6fBtXPGtJJD6fPpLdbvuyafBbjWtEB/ydJQfIPvo/wDL3kH+vtHGf9ePaP8AqJsP/KI/+9yf5+kn + 7733+I/84x/m67/2YLvr/ncN/wCgljP+vHvR5G5fHG1f/e5P8/Xv33vv8R/5xj/N1kHyF76/tZhv8LbR + xn/Xj3UcjbD/AMoz/wC9yf5+vfvvff4j/wA4x/m65j5B98n/AJfDD/X2ljP+vHvf9Rdh/wCUV/8Ae5P8 + /Wjvm+DzP/OMf5uuR+QHff4zJ/1/7o43/rx71/UXYv8AlFf/AHuT/P1r9+776n/nGP8AN17/AGYHvr/n + cH/0EsZ/1496/qPsH/KM/wDvcn+fr379331P/OMf5uuj3/37+Mw1v/DRxv8A1496/qPsH/KM/wDvcn+f + r379331P/OMf5uuY7/77tzmP9f8A36WOH/XD3Ycj7B/yjP8A73J/n63+/N982P8AzjH+br3+zBd7D9Wa + AP8A4amM/wCJg97/AKjbB/yiv/vcn+frf7733+I/84x/m65r8ge9CbHM/X8/3Uxn/Xj37+omwn/iK/8A + vcn+fr37733+I/8AOMf5usn+n/vT/nc/+upjP+vHvf8AULYv+UV/97k/z9e/fe++p/5xj/N10O/+9D/y + +CP9famM/wCvHv39Qti/5RX/AN7k/wA/W/31v3qf+cY/zdcv9P3en/O4/wDXUxn/AF497HIWw+dq/wDv + cn+fr376371P/OMf5uua/IHvX85gkf4bUxn/AF49+/qHsH/KK/8Avcn+frX77371P/OMf5uuf+zA95/8 + 7dv/AEFMZ/149+/qHy//AMor/wC9yf5+vfvvff4j/wA4x/m69/swHen/ADtn/wDQTxv/AF49+/qJy/8A + 8or/AO9yf5+vfvvffU/84x/m69/p/wC9P+ds3/oJ43/rx79/UTl//lFf/e5P8/Xv33vvqf8AnGP83Xf+ + n/vS9v4sx/1tp40/9cPev6icvf8AKM/+9yf5+vfvvfvU/wDOMf5uux353u5sMuy2HN9pY3n/AKwe/f1E + 5e/5Rn/3uT/P1799796n/nGP83XL/Tx3wPrmb/4f3SxvP/WD3sci8u1Gq2an+nk/z9e/fe/ep/5xj/N1 + z/09d7f87Zvr/wA8njvp/wBSPbv9ROWf+UZv+ckn+frf7633+I/84x/m67/0897f87Zv/QTx3/Xj3o8j + crjjbt/zkf8Az9V/fm+ep/5xj/N17/Tx3t/ztm/9BPHf9ePev6jcr/8AKO3/ADkf/P1v99796t/zjH+b + rx7572H/AC9X/wBhtLHH/rh79/Ublf8A5R2/5yP/AJ+tjet+Pm3/ADjH+bqHUfIXu6mKCoz0dN5CRH9x + tfFQ6wpGsp5IRe1xe30v78eRuV/+Udv+cj/5+qvvu9R/G9K+qAf5OsS/I3uXn/f1UJH4/wB+9huP8OIv + dP6k8r+ds3/OR/8AP1T+sW7/AO/B/vK/5uuLfI7uXm26aH/X/u9hfpa9/wDNe9Dkrlc/8Rm/5yP/AJ+t + DmLdqf2g/wB5X/N1hb5I9zD6bpof/QewpH/Wr3r+pPLAObdv+cj/AOfr39Yt3/34P95X/N1iX5Kd0E/8 + fTRWH1H93cL+fp/ur27/AFG5X/5R2/5yP/n63/WHd/8Afo/3lf8AN1zHyT7n4/39NF/j/v3cL/169ujk + XlU8Ldv+cr/5+qnmHeR/oo/3hf8AN1lX5JdyEN/v5qPj8/3ewv8AsBbxe7nkHlYED6c5/wCGSf5+qf1j + 3k/6KP8AeF/zdRz8le57kDdFHwf+edwv/Xr3tuQeVh/xHb/nLJ/n6v8A1j3b/fo/3lf83XX+zLdzf89T + RXB+n93cL/1692Pt/wAreVuf+csn+fqv9Y93rmUf7yv+brl/syvctxbdNFb8/wC/dwv/AF691PIHKoFT + bn/nJJ/n63/WTdv9+D/eV/zdePyU7ntxumhJ/p/dzDf15/3V7p/UPlX/AJR2/wCcr/5+vf1k3b/fg/3l + f83XX+zL91f89TQ2/wDDdwn+w/3V70eQ+VqYt2/5yP8A5+t/1k3X/fo/3hf83XB/k13UlrbpoTfi393M + Je//AFK9+/qHytT/AHHb/nI/+frX9Y92r/ain+kX/N1SZ/Pc7k7d3f8AFfrOrWqp9w7l2r3LU7h2rT0+ + 28bLUUeUg6zzdBWZWmp6aEs0tJQVNZOjgXiKiYFWjDCPvcnY9t5b5eS92kPbF5kjklV3LLG3oSe3U1EJ + FKqxHA9Cvky7be9+jtd1YSRhXdUKrR5FUmMEU7u4AhTWpAFOtJr/AGY7uvTb/ZgO1rfY6/8AmaO6f+Ot + /L/wN/Vf8+wLp7fhFNFOH+h6uNf9NjXx/DXy6E/jbh/B/omr+zH9v/Bw/wCqXD+j1//Q036n/Nt/wVvf + uvdb8f8AJhNv5bPx4v8A6vsb/wB7+u9zlyZ/yrdv9sn/AB89RxzB/wAleX/a/wDHR1aOrCzWYXtcfT8e + xR0S9deQ3/UPr9OP9t7917rN79Q9e67uigDUL/kc8e9UPTTA169qX+o9+oetUPXZIH1I9+oetU67BHBB + H4Pv1D1scepYdDwGHvfT3XFmIPB4/wBh7917ryvyb3PA/A97Xj17rmHH0+l/re3+v7v17rMroAAWH++P + v3XuuQdT9GHv3XuuVx/Uf7ce/de69cH6EH37r3Xfv3XuuSGx+tuPr7917rP6P9WP9t7917rIpWwswI/1 + /fuvdeZlt9R/t/bkXE9eHXVx/Uf7ce3utngeuVx/Uf7ce9dMdeuP6j/bj37r3WCYk20ngfUgXtf3sdOp + w6joxYnm1gbGwt9fx791frtnGk3a1uD+L2F7+9EVPVamtKdcCbfUj/b+9j5dbFPLrprlSP8AW/3v34Kt + a9e68EH4v7cVfM9N4YVJp1xcFVJFyTx/t/r7dWgYHrRoBx66BYJY8ccr+f8AGw93AapI/wBWeq+vWIkE + WuARzY/6/F/ehr1aj1759dCS3BAt+Le7+GPU9ep10r/X6Ak3/PP9fdHFKAdaPp17Xb8qL8+6cMdWqKUI + 66aQ6TyD/rf6/wDX3rr1V9OsbNyb/kfX/X/p7916q+nWH/W+v+vb24FqterlqdZgbj6iwHNvrcf1PvWn + +fTBDE04dcQ6m/Nx/W/vZRq0HXtIGWPXfB+hHP8Aj73obpkkddMeDYr+fz/vXvwRj17r2sgKAeD+r/C/ + HvWk9VwoyesV+PST+L6eSD7uladaZqdedyHHNxxa4tb/AF/bvDiB1pWJ66aQ3BsCOf8AW/1gR7soJyAO + rdcfI1rcWP8Ah7vQA16912GFhcgE2+v1va/to8evdZEYAMbj8W966312GOpfwSQL/wBB/j7917qW1gLg + C/449+691xVySBx7917rJ7917rv27GaZ6116w9uam69U9esP6e96m69U9esPetTdeqesZcj6Di35HP8A + sPejWuevddl2NvoeB9AeP8D791rr2pvyOP62It/j72vHrY68DcNxe1iLG9x+bD271bpH7ia9bCP6Ui8/ + 9Pn9hje/9yl/0g/wt09H8PTNGfx/Qf8AE+ypOPTh6zRG5v8ATg/737c611L8i3tz/X37r3XaaePV9D/T + +pv7305r+XUtXX9N/oL3/wBf/D37q4NRXrKrC9xzb/YfX3vr3WZW1G1rf7H3rrTfD1IRgo5/re3vXTPW + dWv+Lf7H/C/u3SjrMrkC1vpx9f8AY+/eGGz1rrPHIAQD/W/1/p79p04691n8oLAgfi3/ABN/fuvdSEaz + Hj6W/wB5591b4T17qUHBFwSLA/T8+7w8B9nXusqyC3B5On+vt/p4SKBTrKZfoD9ePyffuveKvXYkt+Py + D9ffuqO4bh1nElwOPr/j78M9N9c9Q4ubXF/dtPXuuvJ/h/vPu3Xuu9YI+tj/ALe3v3XuuQlAABN/9v7d + i4Hrw64tKrC305/x9u9W6ywPYlhzxb+nv3XupHlJFiCef6+/de6xNIOB+bWt/re3xw6r1jLn8cf7z731 + 7r1z+Tf/AG/u8fHppOPXEsBf+v8AT27051iY6jf6e/de64H29F59bHXh7cPHppvi679+611jZr3Fvz9b + /wBD72OPXuuHu/WuuccZbkr9P+J/x9+691m0r9Cf9cW/p+PbZ49b65Dxgi3Fvx/sb3HHv3XuuWpf6/7w + ffgK9e66LXuFBPBtb63tf6H3p4wyFWJAIyRxp8vn1pmKAv6Z4V/l59Fy+S/yi6z+KuwafenYc9dksvn6 + uXC9eddYFY6jeXY+5li8n8IwVOTpipoQRJkclPaCkiDO7atKsDefvcbl/wBttik5h3VlKOmmGH8cjgcP + mT/KuePUseynsfzl7481Qco8nQtohcSXVy5rHaIT/aFz/DQto+R8upHxc3T3Dv8A6S2t2P3lSbXwu9+x + 5K/e9Ds7aVJLDithbHzs/wBxsjaMmQqSZslVQY/xTVuSlCmaWY6UVQo9rOSr3dN45Ysr+/BWe4ImRT8S + xyAOqn/SqQPy6K/dTauSuVvcPcOV+UjJew7cDGZclGuYiUmkXy0vKrMvyPQ+te1vp/sPz9T7GEpDSN6g + 0P2jj1G7SGisSKsAT9p49e5tY/i3ulOmmbUR14f77/be3xwHSiP4euSjUbfTj3vq/XAeni5Nz/xHtvxP + l1TxR8+pKC6j/Y/73714vy6sGrnrmBb3Rm1de6791611734YNetjj1xv7d8T5dPU68RcW/r7uMivWusq + D8/7D3vr3WT+n+J/4i/v3Xuve/dLB59YWNz/AK3H+2Pv3WuuSoeCeOR/xX37r3WdB6j/AK3uhk0mlOnV + OOswUk/1/wCI90aQ/Z1vrn4XP9n/AGIt7qJCPPr1K449ZftnNvrwP6f4k+/eMeraTXh1lSmNuVA/I+v/ + ABHtv6n7ena9ZVpeDc2H54+n+HtmS5HXupgpkS3N+B+Lf7f2mFyT1dUZhUdZVp0Ivcf7EX/P+J97+o+f + WnRloT1nSnUr9R/T9P8Axv3VrjGT07FXT1mWliaysCbfQg6f94Htr6pfXpzrIKRBbnj/ABH/ABPtObma + uD17rKKaNgQR/gSPzf8Ap739TP06vw9ZFpYUFgrf7FiffvqZv9Q6t1lWihkFiCAR+CfwffjdTDPXusoo + KcC1m/5KPuv1k/r1vrxoIPwGH/IXv31k/r17rIuOjKj9yYf4BxYf61x719cwwTnqvXbYpTa0zni/rCue + fwDx7cS9xnPW+uji2/Eyg/7Wth/twT7t9Z8uvddfYz/go45tpP1t+AD+fdherqAI691waknUXMT/AO2B + /wB6Pt/6qD0PWuu/Gyhbo445utgDb+vt0T25Fajr2euOkDggfW/4/PurSIT2ZHTbZPXXjsSVVRf6ggN7 + 2slOOOnadcxFGQdSgsbXsAOfzYe7+NTNetU668Kfhbf7D3r6k+vXuuH25/Bv/gPb31HW89e8Eg/HHvXi + hs9a68IW/PHvYYHr1OuvH/j/ALx7t1rrIOAB/T37r3XvfuvdclU3Btx/xr2weJ631nT6/wCw/wCJ9+69 + 1nC6he9uf6e2362OuajSLfXn211vrIPp7TS8T/q8uq+fXh9PdelY4dd+99e6DfsIkHCjmx+//wBbhofe + x0Tbtxj/ANt/k6DkuF/tf4g/7xbj3o1Ip0SkkcOsVxa+oEXP5/obc+98OHW8Vp14H+nvRUHJ691xVOPz + f8/8R7cCV49UrU0OKddlbC/PAv8A7b25Qdaovr1jRmFyePzz9D7dIqwI4dUHEdcSRdrm1/8Aef6+6nWf + Lh17j1jDleOCP6j8+3NIbuJ69Tr2u7X4Ata5/wCKe9MulcdaNAOvF+b8A/T21SnHqwNBQjrvyE/Qqfeu + vVX06wlrgE88/wC2t/j7916q+nVF/wDP43NuDZ3xe6L3LtXL1uCz2K+SdHUY/KUDqlRTyHrrLo/pkDRu + rKSrxyIyMpKspBI9gD3Gmkg2i3kiND41MgEUMbgghgQcHzGDkUIB6EvLMMU91IkgqNAPEggq6kEEEEEE + A4PWsT/s5PyY02/0nLbxav8AmX/VX18mr/nRf1/H09wdpHD5af8Aa8afZXNPXqRfGm/jPxauP4v4v9N8 + +PX/0bwz8CfgqxIPwt+JZB/B+OXTp/8AkN7ymbl7l+lRY2//ADhj/wCgeo7N9eeUz/723+fow2yOsOtu + uds47ZvXvXuyNh7Pw/nOJ2nszaeB2vtrFmsqGq6w4/BYSngpYPLKzSy+KJdTks1ySfay3s7K3QQW8SRo + OCqqqork0AAAqePSVyZpPElOpjxJyT+Z6WKYfEnn+F44Wt9KKm/3n0+1ngQcNC/sHTjRx/wj9g66fD4m + /GLxwP8AX7Gm+tvr+n3v6eDjoX9g6cjiiIyo/YOsAxWO1EfYUNuf+UOn/H/IPvXgw/wL+wdOeDD/AAD9 + g6xvicaWv/DqE24saOnsbH68r72IIa/Av7B1rwIf4F/YOsq4rFEG+NoL/wDUHTcf8m+7GGEfgX9g60YI + P4B+wddricYBY42gP1/5Q6c/72vuvgw/wL+wdNPFEBhR+wdZBisX/wA62g/846f/AKN968GH+AfsHVBF + FX4R+wdSosTivqcZjzf/AKY6bj/k322YYTjQv7B/m6sY4tWFH7B1zbE4vi2Nx4uQP+AdP/0b7uIIP4F/ + YOq+HH/CP2Drww+LBv8Aw6gP+H2VP/0b7usEH8C/sHTkcURrVR+wddPi8UoucdjwP6/ZUx/3jT7pLbxa + e1B+wdOeDFX4R+wdRmosOAR9hQMb/UUMAsP6cL7TJaivw/y6cMUIGEX9g6jNjMfclaKkA/6hYP8AiF9r + BBCBlF/YOqeDD/AP2DrsY6gt/wAAaM2tz9tD/wAU9tPDF5IP2D/N1VoYgPhH7B1FejogeKOkX/Wp4h/x + Ht1beH+EfsH+bpyOCEipQfsHXkoKMgn7Wn/1vBF/sfx788EIGEX9g69LDCowi5+Q6j1NHSBbrTU62P8A + ZhjH+9D2laKPgFH7B0XSIg4Afs6bRSwFf8zFc/1jT+v+t7oIoweA/YOmdK+g65NTwBbCGIE2FxGg/B/N + vdZI0pUKP2daKr6dMMsdmcXtyf8AWt9OB7RSDT8OOklzVUquPs66gUajq9XF7H/jfsruJZFGGI/M9BG5 + urlTRZGH+2P+fqJmBKIo2p9cdtQPh1Anj8lPbVvNISQ7k/meiq7vbwKNErj7Hb/P0kmnr1/VLWqP9UXm + A+n9bj2vDjyY/t6LDf7gP9Hk/wB7b/P1geqq78VNURb8zS/X/ko+7am9T1795bj/AL/k/wB7b/P01S1t + arkCsqhxzaolH5vzz7vqb168dy3Gv9vJ/vbf5+oclbkCT/l1Zb+n3U4v/sA3t1Wxk9a/eW4/8pEn+9t/ + n6htkclyP4hXcX/5S6g/i3F293B60Ny3H/lIk/3tv8/UWTJZUfTJZG30sKypH+9N7fUClerfvLcf9/yf + 723+frguVyoIvksiB/1G1IH/AEN7v1r94X/+/wCT/e2/z9ZP4pkz/wAvLIEf9RtSf+ive6H0/l1r94X/ + APv+T/nI/wDn64NkclYkZHIX/wCoyp/6O92q/Xvr7/8A5SJP+cjf5+orZPKc/wC5LIXuf+U2o+v/ACV7 + vxGemf3luP8AykSf723+frH/ABPLf87HIf8AnbUf9He99e/eW4/8pEn+9t/n6xyZTKhT/uSyAPH0rakf + m34b3dACe4V68Nx3CtfHk/3tv8/Uf+LZX/naZH/zuqv+j/bwVK5A/YOt/vLcf9/yf723+frv+K5X6fxT + I8gn/gdVfj/kP3YrH/CP2Dr37x3H/f8AJ/vbf5+sLZfLAn/cpkv/ADuqv+jvehGlPhH7B1795bj/AL/k + /wB7b/P1BfMZnWR/Fsp/UWr6v/o8e7hEHAD9nTq7juFP7eT/AHtv8/XB8xml/wCXvlP6c19X/r/6v3YK + nmB0rgvr05Mz/wC9t/n64/xjNgav4xkrc/8ALwq/9b6avdiIyMKP2DpYl3eFgDK5/wBs3+frpc5mLD/c + xk7/ANfvqv8A6P8AacqvCnS43Mwxqb9p6yjOZbm+XyRP15rqn/iX9sMFrw6Vx3EhXJP7T10c5l9Q/wBy + 2SFrX/y+qt9ef7fvxp1fx2PEn9vXL+N5ckactkQOAbV1V/xDe9cetrK1eJ65/wAay5NjlMiSPya2p/6O + 96oSAKnHV/EcEmpz8+vDN5ZuBk8iNNv+U2p/6P8AeyPn1oPIPxE/meuIzWWtq/imRsD9Pvann6fX1e/Z + rWp/b1vxHpTUf2nriMzlmcn+KZEcf8rtR/0d70RXzP7etiWQClT1k/jmXW3+5TIm44vW1J/6L9+pTqpe + Q/iI/M9Z1zeXHP8AE8jf6f8AA2p/6O90FajPker+K4xX+fXv43mP+dpkfp+K2p/Bt/qvdBqo2T+3q3it + UZ4/Prmmby3H+5bI3/xrqr+n9dXtpDIZdJJpnz6cLsPPqWubywX/AIuuQNxfmuqf6f8AB/aoAjqhkP8A + F/PrkM3lAARlMgb/ANa2pP8AtrN7vUjh014kn8R/b1lTNZWxY5PIEC3/ACmVP5/5C97qfXr3iP8AxH9v + XL+N5T/nY5D/AFvvKi3+v+v36rceteI/8R/b1xTNZW5vkq8j/qMqeL3/ANq901N69PB2pWp6zpmsgb/7 + kK9vpbVV1Bt/rer3slqcetCY18/29dfxjJ34yNcAf6VdR/0d7RNJIGPcf2npapqK9ZxlsnYXyFeb/Q/d + 1HP+3b200k1cM37T1brkuXyK/SvrebDmpn/P/IXuhmuP42/aet9cXrKqdw01RNK1tIaSR3IUc6QWP09t + OTIdUncfnn/D1upHA9SIpJOPU3N/yfdNCjgo/l1vU3r1NjkK6bk83Frnnn8+96V9B1eNuOo9ZfL6j/T/ + AGx5/p79oX06dDKcDqSGA0g/0B/w9+0L6Dq3WcSg8L9f8b/737qY6eXV1Ip1KiexOo/Uf7C9/wDH22AN + Rx1vqSrqSLE3/wALf197IHp02xNadZfJ+Prb68/n3UAVPVhQivUhWItbk3uR/h/Xn3WWgGPTq/UpTe/+ + v+Pxx7tF/ZjrXWQWuCfp72y6ut9c1c6hYf7z78qUOevdTPKtvxci1/p7tQenWusysNP1+gF/fgAOHXus + itYE3/pp+vvfXuuWt7j+ptb6/wCw9+691mV2tyOf8efe1691zErf7Af6/wCPdqde6ziW4+l/x9f94976 + 91yD3+vH+x9+691yuP6+7BGIqOvddH26ilePWx117v1vqUrhbCw5P4/PPvTcD1rrg8jBj/xX/iB7vHml + eveXXRbUFI+vN/8AX+h9rABQY6r10GYH+o/x/wCN+6spJx1vrsOebge9opHHrVB5dceTyfqf9b8cfj3f + r3XXv3Xuve1IAAx03U9dHgE/0HvfWuuGs/gD/Y8+9r1rrGfyfdj1Zfi68r2/F/8AX916ex1nWQtf06bf + 0P1/23v1D0n679+oet9e9+oevde/33++t72FwWPlnryq7TI0eWU1APA9pqCPMUqc+dOgy7l7e2N0J1Xv + juPsjInHbN2Dhpsvk2iK/fZKqJEGJ2/iY2/zlZkKpo6WlQfV2v8ARSfZVv2+bXyxtMu/7w+iOGN5KVOQ + orgDiTwA9cdC7285I3X3I5123kjlBWe83N/CiY1Kx6yQ0j/KMAkE8KY61e9m707J+Y27e7vmR2/eOaok + x/UPT+1vI0+3utttbk3FSYjOY/AJNwrUuPqhTVNWtnqKiWolkNygXkV7j+4t77o+6+x2G4OYrWe8hLLq + bTHD4yg6VrpDMuWoM4GadfQzy37R7B92v2Nm5P5YRWvI9vmury5AAe7nW3keniLRmTxRTSSVooGdNets + xaClxUdNiqGJYKHEUlJiaCFf0wUGMpUoKOBP8EijRR/gPfYyNI4ERLcaVQALTFBQUp6Y6+bWS8uLi5mv + XYiSd3dyCRUu5Yj7Kk46792+fr0xQenXf+v70TEBpkqCeFOtHBFOuwCwsqsxJt6VdrAfltINh/Q/T26r + eFEVLinqeIz8+nC2iItx/wCL6TmY3ps7b10zO5sNjp7gmnkrY5akC9rGmptcl/8ADT7QybxstqaXs1D8 + j05EGl4I38+kJVd5bAiutJLnsuyniTH4CshjmFuDHNWiNSt+L+w3d89bHbiusT/6TH+Doyh2DeJ/jUL+ + XUWPvrbbH07X3gV/CeHGa7fkBfuPr/sPZevuNy6V7wyH+E1JH+rj0q/q1uy9oA6fKLunYtVcVMmewrAX + P8WwlUIEW1yzVdGJEAH0N/a+z545evCVRiCDTPTEuzbvb0qgKnJNOHQh4nNYjPU33mEydDlqbjVLQVEV + R47/AJmjQ60/odaix9ieC+spk1iQFTwpx6LWQxvRwQ3506c+foRb2qdAgDKag9eHEdcfdOnuux7upNad + KQq6RjrOn6fbvTEgAbHXZBJFhe17/wC291ZtI6tEASa9cwjMQLWv7bL46f65LSG92J/2/umv59eqOs/g + X/VE/wCH/Ivbfin+LrWesiIi8WBNiAbXJJPHJ91aTFSenV4dSkRRf0r+PwPbAkLefVusw97JPVhx65i5 + 4F+f8fder9ZgOAPzYD37r3XLS39OPzz/AEP59tSU6dWMkVr1l5IB/oLH/b+0nTyLpFOs0d2FrW4vfj/b + ce/dWIB49Z1Gn6/QG/8AsPfuvAAcOpAIP0/H+HvVB6de6yJyeeePz7YJNePToAp1lHH04/1vfqn16313 + 71qI8+vdZ1PpFj+P9b/A+9FqilevdZEPHJ/P5PunW+snvdD1rrMl9I/2P+9+/eHXOOvdZVJ1AXP+3/w9 + 606cde6y+/db66sL/Qf7b3pvhPWupEV+QPzb6cX/AKe02o+vWupWhCtmVW4HBUHm/wBefftTevXusLUt + K5u8QvYD0hQLD/D+vuwuHjGkf4evU6xPi4DzG7R3/wBVd7g/QD+lvd13Bkyc9bz1HkxM4BKNG4AvZQyu + R/vvr7VpuIbBA611DakqIzZopP6/1/w93+tj+X8ut064DgWP9Cb/AF4v9b+342Tzbr3XINwOeDwPr787 + dx0nHWuu7A/UD/be6639T+3r3XEoCPoOCLmw97Ezp3VJ/Pr3XXhjP5sTYWAP/Ee7C9evD+Z69THXEUjs + TpcKP8QGv/T279ePMdU0t1yWmcXub6Ta9/rz+B7881V1DFer8B1lEQ/Bt/sP+J9spMQOJPXuuwpS3JP9 + fqfx7cWUHB/n1vrn/sP9493DKTTHXuux9fbUoHXj137Z6diJNa9d2I4Pv3V5MLj5dBl2GR5MGPzeu/6G + hPuy0rnoi3Ekla/P/J0HJAIPt7Svp0WdY1/zX4/Ub/8AJX4960rXpv8AH1zQekf7H/e/ftArXq9aDrtf + q1v6j/e/dloCK8Oma1NT12xspv8A0/3vj24UVsr16leorXa3A4PPP+9+3FXSKdb6xv8AqP8AsP8Aevez + w6914/61z/vftpdenFOqagDSvXAkD9QI4v8A7z9Pe21Be7rRUHJPWJn4J/APNv8AH3ShIA+3rfGlOuIk + FrjV/jb/AG3vWhvTq1D115V/xt71Q9U1L69UMf8AChVXn+I3TccYLsfkZRkKP/Ee5X6X9xt7qXFvacvQ + T3DBFE+Sf+abenQt5NjefcpI4Rqbw+A/0w61Gfsau3+Yf/MX/s/TXb+vuAP6wbN/ykL+xv8AN1Jf7sv/ + APfR/l/n6//S2bY5hrAtyb/n3lwwqKdRhx6dlf0j/G/+8i3uioQa9WAoa9ZojwR7VIT59OVr12/19u1x + Tp2NqcesQUXv+T/xPvQFenuuLKOTzf8A4qfexx691wB5ve/vfHrRHWYfS/uvTD9djgg+/dU6ziT6W4/2 + B90C0PWgPPrlckj/AF+P+Ne7jrfWYcKNX+x/PtzHl0qAA4dRp21jSP8Aff19668R1A8RBve9j/T36tcd + er5dchyR/r+6db6yMBbgW/1gPfqV60wr1BdASf6/43+vtwcOrqwAp1xRCG5tzxx702RjrTkNjqPUWF+P + zf8A23tEcHovkFCem0gnkD6H2yX9Ok5HWQIpA1Dn/Yj/AA91LMcHq2kdM1ZCvk4Gn63/AN8fae4Xtr0X + XtAvWBEROdIJtbn2RXAJPQOvEAq3WKZgwsBa309pwtOiWZgwpTpO5L/NN/rf7YW/p7VQIK9IHUBcDpMX + t/T/AGwP+9+19B0m6aqgDXcqSPxYf1/1vex1rqG63PHFvx7359bPUF47sbX/AN7/AB7eHDqvUZk+otfn + 8m3+29uK5HW69cDEp/5Ff/e/dvF+XXq9eER/H0/2H/FfahZO0Y6310YyBf8A3j3cNUdUJoadQXWxNv8A + Y/7Hn3XUfPqpXFR1w93rXqnWGUXH+2/3g+3Yznr3UfSCOOOf9f6ce3urddFbC9/oD+Pe+tdY3QEm31uP + 8fx79Ujr3UVoiHvY8f4e7BvXq4anWKVPyRY3/N/6e7A16W2zg46jkHSQfoASP6fX3v5dL0Oa9RDqv9LL + xa/+8+/MtOlQevn12Ln8j/Ye2io9OlCSUxnru5v9PdNC9KNZoOuwSD/T/ff4+9FBTHVgxJ65eQ2tfgfn + 3Twz1bUK068ZWP1Nv99/j794bdaDg8OveQ3vcf63+w9+8Nut6hSvXgzH8+9FCOtgg56yjX9QRz9ebf73 + 7qQOrDT1k1ML2tb8c/8AG/fsdXBXz695CLf1/Pv1B5dOAjieuSPfk8C/PP8Ajf8APttYyH1dWd9S0HUg + Si1hex4vx+f8fbvTXdXrkpN/SR/jz/tvp7voPXiwHUgzWXkji1+ef959+8Nuk5kWp66ee9ueLW+p/wB6 + 92CELTrautevCT03/wAP6/09slc9Kw4pTrsT3AH9P99xb3VzRevIKtTrMsx4Uf1tz/r+y9qk1r0YrXA6 + mam4+vA/F/8AeffhXz6vXrIpuL3AI/qfrb8+6stevdZBIbjkf7D6+6aD1uvUyNm9JJ4Nv9t/re/UUYbr + 3UtG0/pI5/xP4/1vdk05p1omnUhCeSSPweL+6Nx6tGe4E9SjKDb6/QDj3XpRrT165o4J45t/rf6349vk + A9M+K3U5NTKLccc/T8e0rgA9KVbFT1nUlf8AE2tf6f7H231Umpr1zSWxIPNz/wARbj3QkhsdOr8I6lqQ + puTf/XIHuzKG49aYkDHUhHNiQeCf6397UBQFHAdVViTTrNHI3P0/Hu3TnUhX54HI/r/tvfq9e6y6xbn6 + /wCvb3rPVCxBoOu9dxbm3+Df7H37PWtbdSAbKDc8AccG3vfTnWVZQR/j9OTz/tvewKjr3WUEcci5t+fd + gKde6yByBbj3vr3XJXJIHHv3Xusqpc2Y8W/smx/3g+/de6yAW45/2PJ9qE+Ade4Dru3vdeqaz1xDDVax + 4/2H+8+9n7adOeXWQuD+Dx/tX591IJFK/wAuvZ64/Uk3Jv8A1/4j27Grde65hwVK/kcf7z7WgYHTZY16 + 5I4A5/r/AI+9061qPXIOv9f94Pv3Wwa9cXN/oeLX9+UVIB6t10ouLn+vt7w163Trl4x+T7t0z1ic6f8A + kq3+w976911rH+P+8e7gU6111rH+P+8e/dbBoa9dizX+vFvfqdW1nrl5NBtb6ge99U6ypIG/1/fuvdZP + fuvde96I1/pj4mBC/wCmoSPyx1SQuEPhmjeR/wBXy61uP59vfGQGQ6Z+NGJrWixFLjK3ujf9NFI4+8y1 + TUvt/rqjrIR+qOnSKvrEBuNciNa6D3h796XmqVZrPlOFwGREkcUwanKnPCoGPl8+uv8A/dYe2O3X9/zB + 7uXltr+lZLK0dspG7Rh5Cq0+MOahge0YpnqH1hg6LYvQOA6bpYIBV4rpel35uCSNlaao3nnKtNyYmlWQ + cszywSari4URkG1/fKSbc5V5ysN5RjptdwidvTRFJWgH8PaKjzGOumHN+2ycw2t7WrW1wkttGK5VTG0d + FPkKu3l1sXbN3LBvXZu0N5U7wyw7s2ptvcazUzl6cvmMPFXVSxM31VZWkjB/qp9/QdtW72u6WVnfIpKX + cCyqV4VZAy09BQjHXyz8x7PLsW97hssqlJbO6u4GB8jDIwUU+Q4+vTtkK+gxFJPX5StpcfQwR65KqsqI + 6aBAPyZJSASfwi3Y/gH2skuYYAPq2EfaCSeBJ8h0WpEk7UtwacM9AZuXvjF05lpNpY1spOAQuYy7tj8G + Db0yUtOQKqpF7/2UB/Bt7AO8e4+3WJeHb4/FdeLEal+VBjz6N7Tlu6uSWc6QPXBNfToFcrvXeO7DIuS3 + DmJqaQkSYzb0FRiMWATcxmKEqZF+vLzNce41vOb973dWeWQIvoq6fP7ehJZbDYW8i+JG7OK5LVT8xTPy + /b0zUmEERLQYNowTy0j0kRYn8uyl5P8AE8+w9NLNcGszsfzPQhhihgFI4k/Na9P8WKyhCgUdCmni7V0s + t+foQIwT+OfbHhp+Aaf9LjpQZZCfT7B06RYbNEagmJW/0DfeFh+OSAPftMX4l1HzJyT9p8+mWeauOnml + xGdBW1PiGFw1xPWQFT9NX0IJ/wAfe9MYNUGn7MdaLzUoRj7OpCYHLx1kWRpcR9jlIzePKbe3AtDkxfnU + ZHijSQE+pkm1KfoePa613S9sJRcQStUYox1L+z/Aei682uG+i8J49OQarg4+f+EdCVt/svLYuoixfYuP + raGllkEVHvc0MUWMaeSTRHR7jWgMkVNIxuFq4yIWP69B9zDy5z3DdotpuLLqYgDSNOTgV4+fQMvtmntm + 1Qg6Bk1yaDjnobePoCSQqluAVuw1AowvdSCCD+fci9pj8RTXopaRGOmKoPz6yIoJ5v8AS/tsSHiOlS6t + IDcadZgoAsPdvFfrRUManqUOATYH6Dn/AB91aRnFD14KF4dZVNx+P6ce2yaCvVuvEn23rPTiqCKnrq/u + tOraB12PqD+feiKinTiqKdS1+tv6/wDFPelULw63pHWYDkf6/u3W6U6yhADfn3rrfXK9rH3ViRw691lB + uL8X9tPrPT0czgacU4cOua83X8Wv/sfaUV8+lBNeuTXULp/1QB/PB+vvfWwK9SVHpA/1x/vPv3l1o8ep + KqLfkXAv7r3ev8utgV49cw2jk/63Jt7a0NXh1frmJFIvcX/2JH+3Huwic+XW+u1Oq9/xb6f8b9+NvIeq + sSOswLKPobW+tv8AG/v3079V1nrrUb35/wCI9++nfr2tus6S3/UR9bf7x7t4Enp1evWcN/qTx/gb/wC9 + e2zG4NKdeqOuwWvfk/7z7owIPd1sfLrINR+o4/w/r/T3XHXusqvpIHHBBsfr9b+9EAjr3UkTciwH+wN/ + p7b8NevU6kieP8hr/n3TwZfKnWqdcwwcXU8fSx+vttg6Gh09b4dZhqGkGxH+F/wPbT1alafkOvdSEY2t + 9LWtbg+6munT5de65WuLEk/4/n3TQvXq9dOqTWEiIQWvbQosfpcW96E8q5B63TrC+MpXBsrox+hD2RT/ + AF0/0/r7UruBRdLHP2dV6hPh5P8AdcqG3+rOn/Wtb2oiv1auv/N16nURqKoiGooCv0JBLX/oQBzz7eF5 + GTQfz691hYFeGUg/1IYD/efb6zoRwHW+uwWUXtwfzY/j3ZNbcada67Q3Lf48/wDE+6OSCVPW+soa34B/ + 1x7qGI4Hr3XIPzyq2/1vfi7Dz69TrsxqxJAtf6c8c+9CVwajr1Ou/tR9den/AAIJ/wB592aeRuNP2de6 + 4mlce/B262GK8Osq08hANx/vH9ffjIR1YuzCh6CrsyJonwha1yMhYj6ixg9uQSeISPTon3KlUp8/8nQW + MWsbE/j8n+vtX0VEgdc24AA4GkG34v8A19+63QceugT/AFP+39+603w9euebE/X+vu6AE/l1QgUHXd78 + XJ/1/daMor1TqO1weeD+fxf/AG3tyOpyetjrGWHNzY/1sfdm1U7etmvXDXxb/ebG/wDvPtvTJ1WlcnrE + SbE3+n9ef9797yBpPn02FPWEsT9f9t9B/th7sEIFOtCSnl10b/i4/wABbn/b+7gUHTqmq16xXax5+hFu + b/1Pu3hn06bdgMAdUVf8KA7/AOym9MD8D5E0lv8AY9e5X3DHvopXk+H/AJ6B/wBW26HXt01d7kH/AAo/ + 8eHWpz/Z/wCqf/rr7w98/wA/8nU49f/T2XBrEiEE8v8A1/H595c9Rh0+RuSgufx/vNr+/Dq3UlGNv8Pb + qsOnAfTrPwQD7c6v1172DTq/ij064MOPr/j7sDnratXrCAByP+J974dOdZ1/SPdDk16Yk49cvfum+sha + 9vxz7ocdWwBnrIObW+t/dhXqnHh1zJIFjfn/ABv9Pd6npwSN506xMt/p/vP1916tr6wup+n++/r72Mdb + XjU+fXBVAsfz71ivTvXbGwP+HveOm3fTjqKw9duBz78G6ZDHWBnrvRb8/wC8e9sQBU9KSaCvUSotpF/9 + jf8A4j2iZgST0ic1z02kWtpH+88e2Dx6YPDrKFP5uP8AYe/Kuo06t0zVRPm/rx/sLe/SqmihPRdeUyD1 + iMetLfT2G7o6XNOglfjiOocsTJ9fp/tz7Sq2roPyoBkdNOQVTAxtc2PJHtQhKsKV6SvhT0iza5A/B9mI + AIr0gr1FkW5Jv/X8f7f3uvl1vptlFnPvfWuo5TgW+t+ef+K+/de6iSJa4H1IH9P68+31yOtdYtDf0/3k + e99e68Q9rW/2IPP+9+30ZaAefVuuDRE3N/z/AL6/tSpx02zEHHURlFrH8c+9Mo49b/D1Ebgni3+H/Ivf + gcY6bpU064Eahybc/wCw92BqK9bZaDrgIrX5/rb/AGJv7uWqKdVr14x3v9Ofr70DQ9er1hIAI4H1P+9e + 3wwbh1vrE3LH8f6/+A92691FnX+o/wB4+vHu68OlNuaN1Edbrb/ff092r0Yq9eo5S/Nj9f68fT3cMSKd + OqadYLhSBb6n3RkznpWG68pu3+sb/wC8+6AeXT4kxnrvgk35AH9frx70R5dOK/n116RcEf7D3o46urAs + adeuLcj349bT5deuP6c/19+8+tn4Ou9QH4PuhQE56svDHXeo82uP6+/eGp60WI67BJ/J/wBv7qUpw62G + J67uf6+6UbpzUfXrIJLCxHH5/wAT79RvTr2sjz65CUfQC34/2/8AsfewGrw614nz6yK31F/6ck+3wOmp + JCeHXIvxa4b6cC3I/wBh73011zLgAfgj+p/H+F/fuvZr8uvCRrXJ4/1h9PacgaqdLU00r1yDhrWH+H59 + tXGBjpRFxr1KjP0H0I/J+n19pA4ApTpWJKGtOpYc/QsD/jyffjR8jHWzIDQAdZBICbfT22aDpwE+fXMM + ARYi/wCPetQ9et1B6nRygEAkEf8AEf7D36itnrdadTNcdlKgX5+hPvwAXh1Umo6zIw4YEXH491BUt1bg + Os92PJZf+Tj/ALz7cp1TUfLqREWJHP55/wBgOfdHOkdOJQmp6c1lVQBcW/PtIak9KNQY0HXbTra6ct/j + 9PftJ6c0nr0cmsn+oP1/x4P0/wBj7bK1Yj0p04DjqYJyfpY/7Ef8U93PVH4dSFkAtflv6ce/dUBoa9SA + 66dRNvpwf8ffunQa9cPul1XU2JsPr7svHrfWUyEn9QN/9a/tzqh49ZVk+l/x/U/1FuPfutdS0kAH4NwP + z7qV6sG6yeT/AA/3n34CnXtQ65o1+bfQ+99bBr1IR+b2tb/H+vv3W+shniXhmsf8AW4/1x7uqahXr1Os + qvz6Tz/rf8V90691y8gB5tf/AFwP949q40qgPXvKnXflH45/2I9+ZSvVNB64hzqufpY8f4/j3tB3dOcB + TrKp/tW+pvb/AFuPbtB6da6zCT/D/efbsdOvHr2v/D/efbteqaeuvJ/QX/2Pv3WiKddiT/D/AHn349eX + j10z6hYCx+t/bqx5rXpynXSyMosSTz/Uj271vrP710x1ikP0H+IP+3Nvfhx691x4/Jt7cAr1Rm09e4/q + D73TrQeppTr3vXV+ve/de67X63/oSP8AePe6dUL0NOsur/D36nXtY68HI+g5/Hupbw6SUqRw+0ilfyr1 + oygZOB/q/wAPDrUi/nLUNVV/zCaKnrPIabJ9bdL/AGrj1AY6SvqqUwnjgCRZyR/j9PfPb710bRc7ju0y + GzqJM6apUkU45qPPr6Bv7r+5t4vu1bj9MlPD3W4aTIqGeOPwq/6vs6W1J2LGm9Oz5xNHGgr9o4OErchM + bh9tinp6eNf9R+6xY8D8++fU+1iO0tZpBTxPEJx8Z9RTh+fWcUVg30UNpARIVAFKUo5YEuSeAP7fn1dJ + 8Ru7pY/iT01S0+Pmz+7qDB57Bx0jCSkxOKxeF3XXYzBVGZrHW5DUawNHBFd5ByLDn32M9rueI9t9pdgN + 8NVzHEkeioDaRGoVqkegHz6+a370HLHhfeM5lj2llNsdykdmUduqRVEiY4lZA1W4HpVZKn3JuyrjyW8M + zPlahLGno6bVTYfHKxv48bSAkIF+mr9ZP1b2T7xzTuG9u8c7nwgxAANCKeVeo3s9ijtQBIACCfL+f59T + KTbVJCQY6VUK2KnSGcsTyzSvdm/2/skjldE8OCgHnqySOjloVYKBjT0oocRrABjY8CxtxwPwD7sXI7j0 + 6C6jTin8+nimwthbxn8NfSPyLe6+OPTrVenuHB3Yftn8H9P+Puvij063Xp4gwl7WjtyLErexvb8e22Yk + 1Fet1Hn09w4lFGl/GDa6hvTqt+Ln3QvprU0AFa1/l+fW6ijGhoor9prTT9vn0w783Ztrq/D0Ga3Z9/Tp + mKiSiwmPpMdU1GRzVXFH5po8dCQFdI1IaaYtojBBY3IHsPc1827JyXtf7032UIChYJUAt6AE4qfLHQx5 + G5D5o9xt5Ox8o23jzilSTRVPoxPDoGqD5RbFmqRRbh2buXE4KuRqWtyUsuLzkUFM/plGXw9GfI1Of92e + PWQtyR7h7aPvLe3l3ux28+NbMNLCR6aNRI0jAB4kZrTqct6+6B7q7dtX12mC5fQ5kgRtMiaFJKgsSHJp + QaR0ZTatXHhFwWOp8nHl9kbpiE/Xu4o6n7ykhdkM391pq8XLRMgaTGySG+lXp29Sr7zx9v8Am+HdoYrB + m1vMmsPqGnSRWvrw8usHuYdhm2i4eW4TwnjfQ8ZB1K3ofLoUFVjYEH6ctY2vb/G3uTGVR8B1DokPHrKI + ri+oD/X96611m8f+P+8e9de6yfQW/oPem+E9e64H2yOnk4dZBHcXDD62tz/T6+/V61rHXWkg2/3m3Hu4 + Sor04rVp1KiFgR/re2+nOpMf5/2Hv3Xusnv3Xuuwuq/Nre6surr3XNVsDze/vdBSnTixn4q9Zkt9CQOb + /wC8e0siENjpUBUdcwR/qh/tx79HE0raeH5dWAp13q0erULH8c8f4+3xZtX4h+zrxFT1xNQPwyH/AGNv + bv0reo/Z1tRTrgan+iKf9fkf6/tz6YU61r64/dyj9OlR/QA2/wB492Fuvn1Qmpr12KmZja4/2x/4r7us + Sr1rrkZZTcGWS35szW4/oCfd9K+nXuu7Sf8AHV/9v79pX06916z/APHWT/b+/aF9OtgVNOuau6iwlkv/ + AFv/AI+6mJCa06v4fWRZJjwJpBf/ABv7o0EJPctetgacdSI5qkWtM1x/qrkf7Af19ttbQEYWnWtXU1K+ + ZWswRiBckj6+6G0iKkAUJ8+vBs9SkyS8iVLf6nT+f63v7Stt0g/GP2H/AD9XPUqOsp3IGu1/6/Qf4E+0 + slpcR5qD+R691LWRB+hgwNhf6c+0mhiKyDPXupQkcfRj7bIBwe3/AC9a6zxSliL/AIte9uePbLo1CKY9 + evcOpiuhHLAc/S4/4r7b8P59er12NNxY3sb249p/D+fVq9ZwoYX+hN/+Ke22VAaHqwTUK9d2tYfX/YD3 + qi+XWitDTrIqA/2v63A4P+396+Ywer+ESK1p1yMKMbOiyIB6VcXIJ+tz7usrqOPXjFjj/LqI2NpGbVoZ + Dz+h20i/+pQ8f7f26t7Io9emeoz4nUSIpzcXKrIFC2/NyP8AD2pF+ukalP7R1dVLdRnxlUn0CSf4o3H+ + IN/byXSONVKdX8I0rXqG0MqfrRlH4Nr8/wBLe3VlRzQde8I+vXJVIH5+v5BH+8e3KgjHXvC+fWUOVFgf + 97/4j3Sh9OveGesi6mHJ/wB79t6z6da8M+vWaNbc/wBf+I91Z6ilOqNg06CXtT9WCufqMlb/AG8HtVYA + 1evy/wAvRTuXFPz/AMnQSDm4/F/9659mHROxzny64NIb2sOOP9t730512rE3Nvp9Le/daNOB68Gve9h9 + P8P9792Q0bqjUwB11r/p/rc+7uwGOqnqM0hJP5/1/r7c631iN9Qt/aP0P0B/w91bWTjh17PXZQC4/qbn + /jXvy1Bp5dVrQ6euLW5J/pxyOfeyASD6dbFfxdYCbAn+nu6kA56Tp8XWIkE3tz/vHvw+LqwkYmnWJ20/ + km1j+P8AYce3+rBtTFTw6or/AOFADlvid0xz9fkRS/0vx19lR7hX33/5U6H/AJ6B/wBW26HHt0Kb7L/z + SP8Ax4dan1xp+v8Aui3+x8l7e8OfP8/8nU5df//U2XVN5B/tJ4/29veXXUYdOUYk/wBhbj6f63vXWwR5 + 9TIyAtmP0+nvwqDjqwPp1I18cH6e71ccengwr3dcbk/8i9qFZadO0Xru/BB/3r3sEV63TOOsbE8WF7n/ + AHj34/LrfWVSbDg/7b3TPTTaa1PWYKbAke9V6p21x1njVT9fr/r/AI92IB6vor59ZOAeP6fT/Y+9AU60 + oAahz12dP5597r1t1Hl1gk06eD9f+K+/dNgV6xH6fX3alenQpHHrq3H+++nvWOPViwGOuBB96OeHVQNQ + 6jMrawf8R/vfvQIBz17SoNT12SR9B/t/epDUdeZsV6jTrqXnjn/Ye01BXpM1D1BC/wBR7acUOOmDUddv + fSbe6oaHq3TLM6pKA5sb/wDE+01zHM5qoqOia81l8cOuiUk5Rgf979klyrrgjoO3amnUSpXSOSfp+faS + PVq7eiOZR0z1RRoiurSSLEn6Xtf2rBkBqekUnDpGzRBHazBuf7It7Wq9RnovZaE9QXQm5B45vx/X3YU6 + r1CkQi5FuBf6/U/X3brXUQqRzb/evfut9cAo5vyb34v7uvWusRQElRYW5/p79rPXqdY5Y7D0/Ww/P5v7 + tE1Xz17rEGA9rw4XqrKSa9R5dJFhx9f6/n34SLWnVdPTa4+t+D/vHvxIPV1Wg64IODz+f+I/x9+Bp1Yi + vWQKD9Sf9493ViePTTgCnXTi1uSfr9Tf3bpvrGQDfi5/2HuwJHDrfUV1tfjmx/HP+w9uiQHHWwesEy/T + 26D1ZTnqAy2/x/3j250qicqesbLcfn/fD3sGnS0SV6hOpHAH9Re/9efdj3GvStZB59RzcE8n8f8AG/dl + VdWen1YUr1zF+Lcf1+vNvdGUVJ6tqwevXsxv+fbZHVkYDrnq/H++v9D7rTp0MOu/x/vvx79Tq+rFOurE + k2NrAe6nj04vw9esbjn8/wC297HVG8uuLD8396PV1I4dcbkfQn/b+/dW65gGwNz/AK3vw49Vf4euVhx6 + rHg/Q/6/u3TPXK9v7Z/2xP8Avfv3Xuueocernjmx9+r1QvQ0p10WJI5uLW+nvYyOveJ1x8hv9eLj/be2 + jHU1r0+JMcOpKSC4I9p5wdJ6W25r1IV2JBBIubcf6/tAQRx6VdZlmsbcn8A39+r1vrmZT/j/ALf34Z6d + U46zRtZlZibfX6/1+n1938Mnq68epqyL9f8ADnkcD6/T3VhoND1tuPUpJRZfp/txf3WobA69SnHqcskZ + U8Amw/J96CgGoHWyRTrl5R/h/wAle7E06qBXqSKmNBzY/wCANzc/ng+0xOps9OAUHXAVBdiSSQT9Ofp7 + 1QdbBoa9SUa9rfQ/X/iffq9OeKfTqfGzAEg25/2/tqncT9nT4dQoqepUcgt9B/T/AB97p1p5EIwesvlX + 6lrH/efeqHrQBIqOuLVRcgWtp4Fv7QHN/e9J69Rh1ITR/QX/ANb8e7KCDnqwJr3dZA7hh+Rcckj/AGPu + /Xjx6lq973txb6X961DrVR1nUsCOTb/X/wAPetS9eqOpCvYhf1Ej/e/8fdwCwqOvdZUYg83UXH5v/r/T + 3vQ3Vl6zea3AAt/rDn/ePetDenV6ddeUk8KP94/4p7dQECh62Osqsy+q5IPH1970L6de6yBw31PJ9qEp + QAde65q4BtcXP+B/HtwAfi611kD/ANbf7Y+90B+HPXusit/Qmw/HI960N17rn5QOCP8Aff7b3dARx611 + w8hLEc2ufz/T/D3fr3Wa4AH+sPp/xr3YKSMdUbj12pvyPe9DdeBA699PagGnV9QPXvfurdctR/qf9ufe + umtLdd8nk8/65/p72AePXtDenXBvx7cHTMgIpXrocH3s9UUgGp656h/X3Wh6c1r17UP6+/UPXta9cdVj + f8f0926aOTXrIp1C/wBOffutdZF+vHuwBbsHFsD7eP8Ak69pDKQxooFSfQAg16oL/nh9C5Cpx3SPyowF + EZabYGYh667QaFbtS4XK5iPJ7H3FWFLssEVY1RQu7elTLEOAb+8RPvUcnpuO22/MkaMzW4KTsBXRFgMT + TJpjhU+nXWP+6+924tm5l3X2b3yRY7feUS8tEZqGe4RypiQjtUsgVquUAC8ei+/Df4o5rvTcmV7a3wKi + i6hrpsX/AA2hUTw1++cpiEamqWppCQRjdAQSS6f3WBVOLn3iv7We06bnHBvnMSFoLYuUiYCjA5H7fs6y + T+9/97P+pNvP7Ve211FJuswIub6KtLZK0MdSAPEX1UkfPq8/GbSpcdSUuPxuOgoKGihjp6OipKaOnp6a + mhUJHDDBGAAAB+Bf3lPGkCJG8cWgQgBI/kBQfLAp1x3vbnct0uJbncZ/FmuO95SalpNRzU5qwo359KKH + ELGqs4KDVa7qVAN7aTq/23ujoNRaNaBjqI+ZyenZnVpSNQalAD6gcOnenxsLmy+Jrf7Uh4HJtz/h7qys + vEdVVGb4c9PtPhr6fQeVBA02sNN+f6f7H3Wp9OtmN1FSOnmnwpsLRk8A3K2v/rf8a4976p0p8Xtevytb + TY3F4+qyGRqzaloaGnaeqqDcA+OJL8C9yWsB/X37r3RqdtfFl8fipdzdtboxuxNvU0UdRV05rKT7uGJf + U6VuSqGFPTlxwAhke/FtXHuuryGevfb1Fqexusdq3pOjerMbuSoiYr/pE7DiqkxTsp0Gow2Mql++rbca + ZFjpYjyVkYfW6IsoMUzaVpXhUV8h/qx03K8nhssQrio+Z8h9vn6dE3782lnu6d9bEyPam46vOxxbe3Bg + tuQ4rHUOAw2L3FFWw5v+C4zH0hJjOSpIpE1ySSSyNTKgIvY4l/e85e3LcuQl3vbFJFm8YfiaKdZLUFSS + KClAcdZO/dn9wf6ib5eW0JRpdwjFSwzGqgaghphqmta+Z6CXKdPbLpHOESvg2nidwYykiyax7afMQUks + eQNDt7PZTdTsxw0Ule6Un3DBhKx0PpQF1wa9sti5/wDcDlHc9222MTRWowZE0lo4wWfw9VCGCg0wPl1l + VufvdHy3uljHuqma9RzIjayFWM/hdKfqVFaDOeoXxi61hzFF231BvGLKbf3Hs7cNDksc1BXVOPymKlrg + zLUUtIZGSaKGsgNVAPGU0OwBsT76Efdb593S+5MCXMx+osZAiu1QxUcIiDnhTPDrFv72/KmwR8423O3L + yh7HerbW6xiqrOw+OgFR68OOOjUbfrMjV4+SnzvjTceEr6vA7jSBTFTyZbHtZ6+mia5ENVG0dTFc20vY + Xt76Ycubkm5WQuH7SVBIocEjI4ZpnIqOsDPp3tmFq5qydtSQK0xX8+n5XUNZj/gOCfzx7NPEUDUxoCaD + qtO7QMkZxn+Yx1n/ABf/AFx/tvdyQOPXgC3DrwK35+n+t7qzAig63obrmyqefoB/T2306oIGesixkC35 + +tv8P6+9dM9dlfpc2J/Fr+3lYBRXp5OA65gWI5uPz+P9b2107UdZluCD+D/xP09669UdZvfut9dhip+l + wfr7917rmZVAuTz/AE/5F7uI3OQOlCEEADrEZ0uOef8AY/8AFPdhAT8Q6UJUDrE0xv6T/vf+9e3Y4gpr + 1f7eu1aRuWJsR9L/APEe3QFr1qoGOuVvd6J69e1jrIqkEXHH+w/p7p00ePWSw/oP9sPfutddheeAL/7A + e/de65lDa9+f6f8AG/futgVwOslx791vS3XR9+6soIOevAX4HvfTnUlQB+B/tvbb8eqMQD1lT6H/AF/e + uPTfXO35tz72AR1sceuKAgsT/Xj8/wC29+Y14dXLDrl/Xm1/etVcEde1DrKk8qGwdgByLHi/tqSGN806 + 9qHU+DJTXtIAwNgSARp/xPtE9grj063UdOkVVG5tGwJHDXNuR9b3t7L5IbiJqFDp9ajrfU1W1cfn/AHk + f1v7ZJC8T17rOj6Tcnj6e0YUHAHWupsUim5LcH6Dk/i3H+x9ppI31mg69UjFOs39D7bKMOI62DnPXK/5 + X/intvFaHpRrFCF49ZlYm3+wv78aU6ofE65+26HpvQ3p176e/VPTiKwOesqfQ/6//Ee/cePTvXZRD9VU + /wCuB794jx5TPXusRoqOQlnjIdj6mFrf0uB72l1cBwSDjr3UaTFQm3jdlsCSNCuW/wBYk8e1J3GUYI69 + 1hOKlXlJI2H9LEf7E+3RuFet9dfYzoD6dVgTdLEH88fn/ePfvq4m7mbPTDoxaoHQL9sI8b4DWjLcZMjU + Ct7Gn+l/ZttcsUmsKa/D/l6JtzUqUr8/8nQQhwP6/Un/AGFrezTw26JiKnHWK+pj/Xm/v2g9ODAoeugC + L3+pP49+8M9ax6dcdQH4It+B9D72qEGvVTTy64GQG45sObWH9PdnQsajqpHUdnufyL/i5/Hu4631yW91 + 5vx9L2H+x9tsxBwR1qvXJm+oJ5/xv+R7dGeqMyggnj1gZgP9797AqK9U8SqkHriSGBA/ra5+n+8e/BSe + HVFIBqeo7ng8jj6/63u4Qg1PWgaGvWBm4Gkg3v8A64/2B9uY6sHAfV1Wh/M1652f3L1/0d1RvbGzVuH3 + p2pvsU9dR1ctBkMBmNq9Cbm3ph8vR1cQJUCpx8UdQPo0LSKTZvcKe/8AbPL7dzXVvJ4ctq4mQ8VOhTrV + l4NrTUqg8HKkZHQ19vr1bPmONpE8SOZooXXg1J5o4gyEZDIzh8fEFKnBJ61af9HGG/0T/wAV+x2t/Ev9 + kc/i33/2NP8Ad/6RP9nV/uX/AKQvN9fN/Cf9xv3H1+2/a/T7x317R/V3x/oh4n9V/wB4atOfF/ffg6q/ + 7/8AB/R1cfD7eHU1fuW7/fXhfWS6P61furTQU8H91eJwrw8X9Twvh15r1//V2ZEVSbgAe8uh8+ovr04o + y2tx9Pe24Y6sMde1i4+v+8e9LxHXm6yBh/Uf7f2/inVQTXqTGVtY2v8A8a9smtcdP1NKg9czp+g/3r28 + vDPVlY+vXhb/AA938+nwQR1yBH0t70R6dV0gnPXIPxa1/wAe9U6roz14Eg3uf9b8e3KdO0pw653JF+ef + dcV6o1euPqYg/i//ABPuox0znrt/z/sPdvLq8fHrH9ffq46dY0HXVwPeqdJ6E9darkDi3PP+w9+8+nlw + h6xmRQxv9P8Affn3Vh0ySesTte9uPdQvr16hpXqM5uLc+6MB5dNt1gkICk/4fj22RU9NGnUXyfi9v9c+ + /aQBw6rk8OmGpQmUsTfm4/PF/eyO3pDKuc9cY3VSLsLeyS/hZwSoz0TX9uWQlOs1SokQlbE6T9fxf8+y + WOqtRug0UNaMOHScMJW+s6vr+OP959qndWwop0luAuigFOmGvp5SSUiNrnkFVBHu8TIPi6KHXpmdLcP6 + SP8AEf737UAg8OmOokg9Rtf/AF/rz9Pbg4da6hSIwY2JsbcX97691i0X+th/S5/4p7uvXqdde6de64OL + g3A/2/P197BoevdRmjH1H0/pc/70Pb+r1PWusDISSALe9gkcOvdQ3juPxxf8n62v7fVq8T1sdYNB/wAP + 9593631zXkWsRYD6+9gE8Ovdcre7aD1rHUaQaWN/zcj/AG/vYovHppxnrh7tXz6r1FmUG/8Arf8AG/b8 + bY49bHUCRBYkDnn/AG/49vLx6upznrAB6ef68e79KI2oesOkeq9voPx/h730vEgFOm2UWdrfT/jXuwJ6 + VxkMvWEuASCD7qT0514OTwv+vzb36letjHWW7E3Pu7qAlB04GHl1yDcG5H04tf6+2B1dmrw67TSdV+T/ + ALH3QjPShCNPXO3I/wB7J4926qTnr3HN+eP6+/daJoa9YZCL2HHv1OtltXDrgrsosfpf8/T37rVeshYa + Rci/+x+lvpz735dMsTq66R15ub/T+vvcaVx1qp65gsT9PT/xH492KgGnTZJr13zqv+Lf7zf37rVT1kH/ + ACB/sfr7oelKntr1zQ2NuP8AYfT6W9p5BXpZbuDgdSgVA4P+3/x9p2THS+vXICwBJvbm/wBf8fbbRile + t16yhhbkgH/ff19pyCMdb6yRyhSfz/Ti4PvXW+swctze3P8AxHtwKWFenV9T1NWRCAb/AE+nIH096KFe + PTrDHUmOZbEf1/x/1vdeqgV65GQfhvrz9PdGXV1cCnXJWN+Tbj/WHtorTrfUqN1AHP0v/sfeuvdTEmUB + f9f/AHv/AAHvRA691IE4sLE2JJ+p908+rn4R1jerFwsbfnm/JFh9Pd9I6p1zSW/IY3/1+P6H36nTqy0F + OpsLEsL88X/24976dVtYr1nErg/g/wCvf/ivuyipoet9Z43Zv6Dn8X/Av7sUFMde6lJIyXvc3t9bn6e6 + +GfTr2OpPlJAOo82P1Nuf6e9eGfTr2OsyS/43IH1+p9uqKCnWupUcikG5P8AtwPduqs2jrIDzcf7zz79 + nqvjdS0UfX8g/wCH9PfuveMeula3B+n+sPfuveN1y1/WwHA4vYfm3J93jqW694x64FiDc25/AcMP9bj2 + pYYH2de8XrNFKHNuQbH/AHj6+/IO7r3i06kLIFYgn+nt7r3jddllY3BP+P0/2H09+6943XEuNVrm5P8A + vNr+/de8brIHNv6/6/t5OHVg2oV65rKfoeBe9xe/u/VuubSAEWJP0+pv/vXv3WidIr135ox+o8/4D/iv + v3Tfjn59ckkVvrwf8B7917xj8+varlgPpbj6D24ox1vxSR10L83Fv9jf3bqjNq65e/dV697917r3v3Xu + uVtNm+otc39+691mi0v/AIC5HBH9L+6sxB60T1nWMqbk2t/sfdNURkQTNpGrH20NOvEsI3YcAM/YSB/l + 6CzuPH4Ldexs31tn8JitzUXZeOrtsZHA5ilTIY2bb8yD+M1+So3+sUC6TDyGM5j0kFfYJ55v7KLliaxv + IxKJmKAMAa6vt+zoV8oXG97Nv9vvXKd41tuG3vGyupK6UPzHoCcdB5tzq/D4DCYnb1DLlKfD4KgpMXic + bSVf8MoqGhoYBDTww0lAqBLBeeefqefcARXMcJ+nEQii9AKCn2DqQrnXeyy3u63TPLOxfU5LNPKTUqCT + XJ6VVPsDFEqVjyWssFBjy+XeV3c6VVQJr6mYgCw+v090MucHHl1UW9tTubSfMeh8x+XDobNxdU5DqGHa + WOg3HmqbsbcsK7my+DkfG7hwmztlwOYYEzEWcgqEnr8jUFYoY7qqJHOeSAfbiNqFek0sGmUeCarjy/y9 + KjH7/wB5wBkrNt9M7tpnATw7g6vx+IqGYABiuR2rJSsHsOXZH+v091kAHTipMvQjbVO298TfbVvxhy7N + AzfxHPdRbolngpi/1dsXnvtBqBvpQzN9bWNrlqpHn+3pwNIp1uKgemf5Z6UEvUPXVbkqGgpN85vr6trZ + EX+Bds7ZqMBkjCzBSMbX1Bp6WpkJbQixysCRwTe/vVTxp+zrf1cWrSTQ/MU6HSt3N1l0DRPtrYuJp90b + 9emQVjfdIZYZHQCKo3PnUWQUqNfXHRQAyOoGlAD5PdaFvs6cJp0WXc9XuTsLLpl98ZSTO1FNN5sfi7NT + 7Xwbp+kYfA6mi8iWsKqo8k5tfWPp7uABw69SuT1ygwtvVouT/qjdj/rk+/deAp13mNkY3cuJqsJlqSWe + jrBG7PTzTU1fSVVPIJ6TI42vp2SWnqqeUCSCoiYMjDi4JBQ7pt1ru23T7fexiWORCCpFR9tPl0ssb6Tb + bkXcLFXUGhGDU+X59Fg+RtLm+sOvsZjsTncxX1vbG8JNtb03dnYsXUZyrwFBtaoqKbCUaU8EdLDrWLwe + RIAw1SS8yyF/cS827Za+3nI8VtyxZohmk7woA1A8QaDzGOpi9t0k5+56i/rHIU+mi1xrWoZk7lWnzPH7 + eiA5SEbfpa7d2JnrKbeOCp4cxjN3TZPIT7ghr8OVlx81XmaiR5po006HjlZkaMshWze8eNq3C52rcY22 + seC/iCSSNcA5rQ0xTy6yy3HZLDcba4s5VFwEiPxCvh4zprw/Lo9+J7A33vOsO6tp9Edl57K7y2xtHIZ2 + kGKh2ttej3fQUDY/K1dFuHcBCy0VVAIKiCSCFtQIU6SPedHK/vjtuy7EZJ457jcCAREvwhaVoMUp6dYH + bz7O3G4cw/7l28W3OzVYnuBr8JzxHn1l2L29jN2Zur2hnsPV7I3zRmqH93cpURVcGTahl8dcMNlIAiTS + wc/cUrKssY9VmXn3LHtx70cn+5U77akL2d3HUNFJ8WoAVYH0J4fZToGe4Hs3zN7e2ybrC6XNjIQVkTIz + 5HjkefQyAFhYfUE/1v8A059y/ET4Gg8Axz1GhX9XV6qMdZitk9Q4AFyDz78xopPp1vrnGyN6SOCb/wCP + 9PbXiN1qvWcKTcj6iw/wt7d6Z64MvIv9R/T3vp5fh69731brMrA2HP4/3j3rrY49ZD9D78OPV+sJlNyB + +Pajw19Ot0HWI62bngc/Q/7b26BQU6ci+LriFGock825P9fdulw4DrmVI5Nvfut9ZoyWFv6WA966Zf4j + 1lsV5P8AUW9+6r1kDA/69uffuvdcvfuvdck/UP8AY/717917rKfp791Zfi64+99Pde9+691nWI3BH0/4 + 17102WINOsuhv6f7yPdG49VJrnrKotwPfl49a65e7Hh17rr3Tr3Xvfuvdc9F7Ef0H19+691lUAXsAPej + 1ZevP+n/AA4uBwD+OfdSARRuHVupsFVOlgsjECwANjYH8D2jkjg9OrdPMFXFLwzhCfoT9Cfx7JJrCSLP + WunNRpAFw35DL9Dfnj2lAKijcevdZVkYWHBuR9ffioYZ691JQk+0ciac9OJ8XXMXBJBPP+Ptnp7rIrWv + c/0/qffuvdZPdDx63165H0J96691lTnkk/0+vv3Xuufv3XuugwU8m5/xIHHtt+PWx1mDAj/H2317rv37 + r3QE91k6ttEfUrmPz/Rqb+vsQ7Dxk+1f+fuiLeiQY6f0v8nQE3f+v1/4Lz7FHRH15TZjc2ve1/8AX966 + 3U9cy39L/n8H/effutVPWA6tbXB03NiQbf7A+99e6w83Nri5I/417917rgQ30BsR9b29+6911rtfn6fS + x+oPvTIletfPrlq1er6/7ED3dFWlOk7EEV8/PrCWB5uP6fX24FA6p1x1Cx5t9D/j9Pe+tdR5DweSbm3+ + uPe+vdQmZlvzxbj8D/YH3YmvVS1T1TV/O37I3Z1j8Zurc9suuTE5/Jdz1W3FzCxJJW43H5rrbL0GWOOa + UEJJUUsk1K7jnxyOAQbe4M+8Fbrd8ix2crERSXKeIoNNYQF1UsKMAHVWOkitNJqpIMhe2Ung8xm5CgyR + xEoSK6GJA1AHBYAnSSDpNGWjAEa5f8Y2r/om/h/8bxH3/wDw3x/cf7H+KQ/d/wB5P9nX/vP/AHX8GvV/ + EP4b/uR+3t5ftv3raOfcKfvKz/q34HjR6/6veFp1Lq8f9++L4NOPieF+r4fHw+6lM9Dnw9y/fni0m0fv + z6itXpp/dHh+PWtP7Ts8Xjr7dVev/9bZap5C1r395agk56iwGh6cltYW+tv8fe9RJoOrg9c/bnz62T69 + ZF5I/wAAD/th9Pe1anWwK9ZfUbAA/wC+/wBb3sEV6uBQdSFJC88e/A569XHXAve3+ub+3hQ9OJhaHrLc + sPpb36hHTq4456yD/H/b+7g06upAPXG5vYX4/wBf3eo6vVfLrkGPNyePdGFc9VNOPXtfIH5/3n3X7Omt + FeuX1/r79nj1Uoeuuf8AfH3rquRx6wOhJuD7tUDp1WXrwOkAfW3ttmHDqrN6dY2t/sb3P+29skn16YNd + XWO3+w96DEjp0v206xtHweb+/cemeoMgsLXP0/P+9e9DHTZB6i+lb6je/wCOffiRXrYKgdMtW4Zjpbjn + 8+3k4dF1wQWx02SsVHAv/iLe23i1cekbYFCK9Y4qpwSGJseOT7Lbq0TTVBnoquIAQSB11Myn1Agi39fp + 7JzCw4johngK+XSbrpGc2VjYf0Nh/vHtxEAOeiOdSGI6aWF7g8/8j9vUp0kPHqO6c/TgEf1I92BoOtdR + 3VWPH4H1HHvYrTPXuo5Qgc/7ckE+7Dj1rqP7117r2lj+OP8AgpPv3XuuIWxNwP8AWta3vfXuo7xnUSOT + xf8A1re3FYcOvdRCtiV/xt7cBp1rrjptcHnn/ffT3bW3r1up66ESn/D/AG59uRu1Tnrw67ES/wBf97/4 + r7fDMT1psDHUWSMav624592K16pQkZ6jMluRze/AHuurTjrWnFeo0q3H0t/X/iPb0TVPVeojJYf15/p7 + U1631gZPob8D68e9gnqwNOm911G3P0P0+nHu46eDGvURk9Rvcm4+n59uih6MY3AXj1GdebsOP9e3urCn + SuOQHHXAFQwtb6fW97H3UGnT1fTrIH1GwNz+Pex8J691zUkXFvqL/wC+HvQXFT1cGnXAOVY/0Iv/AIf7 + f22aV6fUmnWQNcH8Wvbn8/63vw6q5I4dcVb1WLf1/PvQrXqmo066ks19IuPyR/W/PtxkI49aqVPUW3Ni + CPbZx05qqtR1lC3+t7AXHJtf8j3YdNkk565AL9R+f9j7fDqvDpvU3XLWPoSCP6f8i9tk1JPWuuOpT9LD + /Y/8V96691nDLpv9Sb2F/wA/j34LqqfTp0FgtOuwSeSLW/3m/tt0BHV4XIbrMGBt7TkEdGKyqeuer/H3 + WgPTviH16yq1xYfWw/2J/Nh7YkjByB06jV49Zl4Kk/7H/Yj2y0dOnK9ZQ6qwueP8OfbXW+pHm/oLf14t + 7sp8j1sfPrNE55tcg/U/093pH69PKy0oTTrOJBbnj20eNOrVHWYS3H4P+w9+I9etgjrsSEcf71f6+9aR + 6dbr1kEnH6iP9cX91KDr3XLyswte+k2B/wAPrz/sSfbZWh631IQgHn+nvXXupsbqDb62FuPftNc9e6mR + yfkcACxuPqbf4e7KhIx1dZNOOsgla/1H+xsPd1Ug1600hYUp1IRr2ueQRf8A3v3fqoNDXrOJQv5tf+oH + /FffunPFPp1IEgsCGF+D+f8AY+/de8U+nWZZTxzx+fr/AF5497CFsgV6cEo09SxKq/Tm/uyRH0p0nrqJ + 6kJICR/vvx+Pd/C6q2B1IWRQbkN9P6D37w+m69eMpI5v/vX+9e3Yo+veJ6HrryFWIP8Ah/vjf2oIoaHp + xTUVPXPyH/VD/ePfurdc0cNcC9wOTxY/61vfuvdZwxutjx6f6e/de6ks/wBNJ/1+P+K+/de65qbj6825 + /wBf37r3XLj24jaRSvWuvcc/Tj/kXu/iD169nr3+t9f9t79rBxXr2esYL3IuPr/yP3vrXXfq/JBHuyce + tjrkXsABb6AC/wBb/T251brpZGNxxx7917rP5bAeofQf09+Jpnr3WRXuL3v7rrHWq9cwQeb2+n14+vv2 + sder1kABH1X+ntouK8etZ6yKulla4I+vF/bbmpr04rlRTqSpZmURgai6C7W0qC4Bdh+QPrz7abBEn8B1 + fs6sJchT5mnQd4aikz+SyW65I2MeQklxWB1D0xYDDztAXhX6f5TUeSdm/I0/09wDzxuq7vvLIp/svT5d + SNy/ZmKISdLWnwzMVun9P9V/T2DehL0PfRmxsbkN4DcWdWODbOwaOXd+emlJ+3X+GxvUUIqUIswV0MpT + kFUP196JxjrR4dITIVuT35uTcW/sxCyZHeWSORippzr/AIZt6Afb7XxSn6A09HpLW4Mkjt9T73SgoOtD + J6FPq/qKv7ByxhTyUmAo3T+L5YLwiG5+zow3DTyAcf6gepvwDSTgOnPwjqxHDYbA7KwMeNxVPS4fCYqn + d5XkeOnhiihj8lVka2qksCbKXllc/wCJIA9tU1Y60TTJ6Kl2L2rke0YajZ3XdFLUbVr/AD0WU3M+MjyF + duCF7001NtLG1SOIqZlLBsrNHcg3plPEvt1aRkFuPVGXxAV8umbZ3xzz1PQUePp8Vidp4emQJBTVDmad + Y/8AVeCAtIZD/aaWQMT9T7sWA60kMcYx0LEPQ+18XGk2f3POBpsSGosTDpX9SJJUsxI/xPtotISdIJ6c + 1Rjj/h6kptDo6lvFNu/CeWM+oT7xxKSqR/qlEq2P+w9+o5+IHrWuP1H7enSn6560za2wGeWpkvcHF56h + yQFgSdUcTOSP6i/vVKEH59eDrrUrTBr/AIeiafPPp2vx/wActyboxs9PlF683DtbfMokpJlyEWIxuTWh + 3AtLFFqBb7Spdne4siMT7BfuJZHcuUp4EFfBPif7yCepG9pd2G0c82k7GgmDx/ZrxXqneTFNuCKpw9Ja + ZsnRVKI8arMBStB5Hq7rceIJ6y44t7xF2mCNtzA8M56zi3i7Sws7gNKB4kRAz8urpaTfFFtvL4vZ+4JI + cTTY/rDDbnxu4a6s8NFlKXb9MlFumh0zaQs2ORYZ5IgS7RyalX0m08RMFhAApRB/IdYg/Sm7jqM0kPD/ + AE2P9X59U1dkbwnqNw7n7G2nOYq2g3hVb725NXUc1PIj0uUNRHHW0U4WVIqinMkUqFQ+h+R9B7jDYOYN + w5X50g36x/V8KQkw+WPxfn/k6ybueWrXmLkmbYLsgCW3XJ+YOOjYbK+Qu2d0V+Kw+4MJlNl53My01Ljz + P4sntjI1tYvlpqHH5yls0bSj/MpWRRkmyAlre+gfIf3huVediu3TqLe9ZtLITQemPU16wT5z9ieY+SoP + qbWslstW4cPnX+XRgrMGsUIKkgji4P8AQ8+5tZqS+EeAyvUMs+lRT8eD1yAJ/B/33+t7v1Trmoup/wAb + W/2B9+p1bQeu/FcXtz/W3HH+Pt9Ph6uBQU68QDYEcqB/vI93HWm67Y2W4/Fv+Ke6P8PVh1ic6gLj+t/9 + j7fi8+tjrEOPop/24/4r7e631kVSRcW/2Pu2odOCQgUp1zVSDc2+nv2ode8U+nWQXP8Aj/sPewQerq+o + 065rcHkH+n0976v1zYXFh/X37r3XSKQfxzx/vPutR1vrKVIF+Pe+PWuuFrkD/X97HTidZQLX/wAST730 + 5137917rnH+of7H/AHr349Ufh1NVQLf1/rz71011z9+691xYXFh/X3VuHW+vf7A/6/HuvXuuQUt9Px79 + 17rMilfr+be9dODh1zHJt7bZ9Jp1vrlpP+H+8+6+J16nXTIxBFxz/iffi9RTr1OsyqTYf0HunXus/v3X + upcNXLCeDdbiwf1BR+SgP0P549oprXxGLDz6307QVEU/GoLIeLOyqXNr3W/+8+yya0KkE9a6kglTx9R/ + vvx7RsPwDr3WZJSCL354+v8AxX3QoQp62DnqQHB459oulPWQKSLi3vR4de6ze6db67BI+nv3Xuuw5/J4 + /wBYe/de6yg35Hv3XuuTMx+n+9n/AHv23obrdeuN3/r/AMnH/invWhuvV6Ajupz5tsA86hlufoBzTfX2 + IdiXSZK/0f8An7oO78SDFT+l/wA+9Aj9GX/Af8R7EvQdLMc9Ry/qa3IBIsf6j37ryu9OPWQOfw4A/H59 + +68zyHgeuEjlgAW1c344t791pWetT1i1WP5/Jvf+nPvXWmZq9YncEm9/8GP+9H37rVX66NrAi/0uf8ff + uq+I3XG4sSPwP+I9uoPxdWU1HWH251vrokD6m3v3Xq9YJJPxb8nn6/T3vqpPUGV7qNXH1Nv+R+/dV6oy + /n5EN8VOneDf/ZhaW/PH/Mv8r7hT34/5U+H/AJ6B/wBW26H/ALb1/f0n/NE/8eXrVP0ra+lb+HVewvq1 + 6dX+vbi/vDigr+f+TqeKnr//19lCJyqgg8+8tAQBTqK1zx6mw1RBOo/0t7stK46cGOpgkMn6fx7cxTrT + AnPXhIVKg8c/71719nVlqOnBHBAPF/fgp49OahpoeuRLWPPuygV68OuA4P8AvJ9qAOvIoLZ9epaG/wDr + e9nh0r0jrJYe9dWoCOult/hfm/8AX6+7jr1Kde/J9+bh1s00jrv3UZPWuuS/qt/vvp72ccOmZGINOsjA + W90wOmxx6jE829ss9eHTkYHXA+9DOD1tlFOutIPup68EU564OAB/T3rqjhQMdYHcBTyP9v73TpgkdNbn + Ubj6D3UmnVK+vUZhf6/X/jfupBOR1qhpUcOmSqGiQ3Bt/Xj24rNTovlFG6bJnU/S9x+Lce3vw56RuT1E + 90ZI24npkioz1wkLaf8AD/W59ltwkamg6KrxVAI6aKg6hyASDwSOR/rEe0RUefQbnROLDppb6n3Tomb4 + jTrg30PF/wDeffgQeq9RiLkhbfTn8fn251rrC6k+nj/H6/09+691g+psP96Pv3W+uyhI+hH+NvfuvVPW + JlI/qf8AWHI978+vdYmFwbDk/wDFfeutdYHiF725/wBYcm3t1SBjr3WAxG/555+l/wDevd+tdcNB/wBU + R/sP+N+7K4Q/b1sddgafrzzf2oVgc9eIqKddNGGBIHN/bwNemmqDTpukUjgWFh9eCf8AYe6Mc9WAJXqK + y3ve/wDgf+J92VumyKdR5ENr/wCt/re34z69eHUQ8g/n+n+v7e6t1FKFS3Fr3/p7cB6uGp1BdbsR9D/j + /wAb92r6dPCRh59YHQmwPNjz7cU149KoZK4J6jumkXt/tvemUU6WowU1PWIAqNR+hH4+vPtvp8MrcD13 + 5PwBx/jb37rfWMsb/U/7f3Q8elSGq9clvYC55Nvx/t/fl6bZq9ZAoFuTce3l0jPn03qIPXMNbgW9+dgx + x1oknj1hfT9QSf8AAkf0/wAPbZGOtg065D9H6gODxx/tvdAfLrRfrpGW1iLW/wAfrf3ejevWs9cQoYtz + bn+l/r731ug9evaQGAJ+v+Hvw+fXsDrKLL/jbnn/AF7+3tShaD063qPDrnr/AKm39LcX/wBf2z1oGh66 + Vxq+v9f629that07U+XWUG59P092eIDpxZSDQnrKrlSB/j7SspB6MIX6kGRjx/j/AIe22UEU6UCTPDrI + tyOb3v8Anj2laOnTgPWYuP8AH/ePbJxx6t1zSVrEcD/b/n37r3XYcBhqP+3+nvdT1vUes3nI+n0/oL+9 + UB6cDV65pNf1c3/3j3vSaY6t1IWS554H++/p71wGet1znrPHIOR9R/xX37iOrAjrIr8/0/2P+8e66F63 + 04RkCxXk2+gN7/1491OsYHDrfUoNyNSkXH+P+393SpHd1Rvl1lDKTwtj/X/fH3bqoxw6kBlF7Ef48/4e + /U9Ot1PXAsT9Lj/Y+7xoTx61U9ZUchl4P+vf/D274Q9OtVPU1JLLwOPr/sfz72FIFAOva6Yr1IjlBtcf + 8R7sAw4daDeh6mLKARxx/sADx/X3YF6562WJFOpKsDa9gL/1/Hu/VeuQLD6H/ePdRrGQeq0TrIW59Vye + Lm3+Hvx1nz6uHAFAeuSlTe6k/wCvx7eiFQdWetNI3keuavpJ0i3+xv8A737d0L6dXDGlSes6OWIuD/xH + +PtNIdJx69a8T59SVNr2F72+nvfXtTdSItNiW4PNrn8359+69qbrJ/rc/wCt791dWxnrldbcA8+7Clc9 + WqDw6693GiuOvdeCer6G9+f9j9fbtfl17rKyrb6f7yfegSOHXusBRTyR/Q/U/j6e96m69U9dWFxp/N9V + jf8A1vftTdeqeubKp/3g/U/W1/fqnz6914C30J96r8uvdchLYDg/7z+P9b2zrbr3WaIs31vYm/8ATi3H + uvHPW+pqE2/2P/Ee9dVIB49M+56ySg23maiAkVclJ9hRkcN93lpkxVKw/rpecPb/AA9od1ufpNruJgaE + RtQ+h8un7WES3cUdMFxXoQMTtiLFUOPxsMVosZSUuOS1yB9nEsDkXP1JUsx/JN/eL0kjTE3gPe7EM3mR + XPy6miKNIFESDSKYHSrp8PfTZQP6em/uvV+hhzFG+3uj8dtulUxZfuTdDU9dciOZtm4dTV5yMyuvpU08 + Jh0/W050n3ofF9nVJTpIA8yOoGz9iVu7M3T4jHqtOJCZqupMTtDjqGMgSysDYfT0wrxdiAOB72WULTz/ + ANVOnCAOHR43bafVu0JKmsrqDbG1duUUlXksjkJooII40UGasrKh/wBU0r/gEs7EKoJIHtgRTzyBIsk+ + nTcskcSGWQkBfIUz8uBP2U6rj7T+ZPUO4q9odzZrcW5NtUcpqcV1Z13SipnzbQyWpcn2buypkgoY4m4k + jwtNNIIwVepaVx40It15u5a2HUu4XAWSLLACp9KBRx+fDoRbHyXzdzOqy7bZSCFyKO4ogHqxoaVwBSvR + auwf5paddY+FcRt3pjofF12mDH5Lsjd9PX5SrenFpIIoEbHxyk8aLyMF/SLkewL/AK6X72djypt025Be + OkaB/gPn1KUHshd2ZQ8zbra7cjZoWqfsyf8AZ6Lnhf5i2/u1c1fbnyj2Rv6aLyTSbK2nmdtUFBLBLJpM + dRj9ozUuTkjUnTH/AJSSfqb+0E3uVzhtDCXdtgdI/wAYKuxQeusED9oPR9H7Hcpbpbsu38wK9x5ICoP5 + xHvX/ez0b/rb5d9EzyxUfdvQSUtR5NFTuzB1uW7DxvmZ9ImrMDuKV8hCtyPI0Rn5PAsL+xLsvu1yhvEq + 2cd0baZgAFlAKE/JxQflT8/SO+YvZLnDl6NrpbcXlrXskhfUzLT4mTiprXFerA9mD4m9h4efL7EqutMv + QQxeWePCNiUytEBeMiuwtTGKiB9QKgSwr/tvY+N0jDxDKG+wjT/tSPI8eJ6jB7JElMUsRR1xpKsrfnU5 + PzGOgC3rub4tUeVqKGmrNsNWwHwTR7bpZcjuKB1b/OTS9dRfcxC4udcgYED/AFvaJ97s7dg0j00nBxx8 + uje15U366/VtLQIlD3sxAp6UrxPl0g979i4bI9Mdq0nXXc67mwkuzM1tzN9cb1r59xzSpnaU4ODGY2PN + Cnz1DV1DTLFSLqmiLsvoP1CK/wB32i52+5i1Bmljf8yVIGPn0r2/adz2ndLaScMpikQ9oxTUCc5/M14d + Q9nfG6l23tqPZDVu3abaj4+mxtdU4zbTUvY+RwTFKo7ZzG56iaSKNYmH28lVSxLLLCAraWu3uGbXbrG2 + cTCFQ2M+f+Hqat05gv8AcR4c0zOoqAK0FDUUxSvHzr68elr3jjsbkMBsmsy+LoKylxnbfXlSkdRArpFJ + U5oY6nMTNyI5JXgilQnTJHdXDKbe1soaMNI5rUEjoo2lljmW3jY0LUK+meFeNR1TN2TWVD0e6jOWFbm8 + zV4+omWF6iSN8lmTFW1JijF2EMZctYcD1fQH3Blqs8+5y0FGDtQ/L06yxluLaDZ4UvIhFGUWslT5fh4+ + X+Xpw39hdw7Nx9bQV9DV4HO4KgxOcx9PlYzHUURx00OUw1XVQoQTGyRqzIbEg2+v0Xba02wb1BeWxKzw + SpLEoxrbUPEDHjQx144zihz1W7Sx5i2KXbxIHtpY2jZzQigBoK+WluNKGooej8dN9oP2lhcvLlMZTYfd + O3q+kpc9R0M0k+MnhyNGK3GZrFeZVkSnqx5NMUt2jZSpYix99Mvaz3LtPczZ5NxEPg3Vo5imjPBMAqyH + z9BWvz65te6Ptzde3O/Q7Zdyao50aWJhwkqaBfyFTj06FsowaxBt/rf8T7lDxPn1HWleuIjtwD/vHv3i + /Pq2Osi8D63Av/sfbqSMcA461TqO7gXsvP8Atz7VKTSvVSB1wX1EXH15I/2F/eyK8et9ZNC/W30+nJ92 + UkHHXh172p6t176fTi/P+x9+6qqhjn169c+/dOtCK9o65xk3P+t/xPva8erRx6DXrN7seHTvXXutT1vr + KqiwNufr+f68e9de67YXAH+I93HDr3XaxXP1+nvdadeBI4dZDGfxb/effqjq6sSc9deNv8P959+qOr9c + lRgQbXHP0v8A09768QDx6lqTYX+vuhJr00RQ9d+9VPTTEhgB1yCni4P1/ofp71Unp3y6ygD6fj/ivv3W + h1yCgfQfX/X96r1eg6yBPpc/7C3tks1erU65aV4IHNv6n+vujAManr3XdvddC9b6973pUZ6912CR9Pe+ + tdZlvYX+vv3Xuu7fXj6/X3vq4RmFR12DYWHH4vYE2+nB90eNX+IV6cWP+Lp0gr9NkkXXcACQ/wBkAWA4 + 9ks9mwNYxnrTqoXHTmrqwV0IZSeCDcAj6r/sPacwMBRumvn1lVmuOfyPx/j7TeFH6db1t69Sklb9P05+ + th/t/bEkIFSOlK/CD1nD24Nyf9h9PaUinXuudx/Uf7ce9deHXfvXTMjMpoOsqEWHIv8A6/v3VPEf165e + 99KQccOu1/VY/S/54/HtpmIOOt46Abu+2vbJW1wuXNwfob0tvYi2A6hLX+j/AM/dBzf+MX+2/wCfegJD + MSblj6Tzcm1j7EXQbfh1iZwGbg/Un8fn3vqw4Drkmlrekfq5uB711VjQdeYgWsoH9bf8TYe/deWvn1jL + rcD6nn8H+nH19+60wr3ddvp+lh/jxx71031hc2sB9f8AD8D37r3WE/6/+w559vx8OrAmnWMvwbc/j8i1 + /p7c631gY2t9efr/AMj9+60TTPWF+QeSB+Pr791RmxQdQ5GHNzfkW/NuPwfewR1Sp9eqN/5+BH+yp9OC + 9z/swlMfz/zwGV/B9wr78/8AKnQ/89A/6tt1IHtowO/yj/hJ/wCPL1qp/wBn/qn/AOuvvDfz/P8AydT5 + 1//Q2REm/Fj9PeWenqKEao6lIhf6E8/7x/sR798Jr1cN6dTI7xGy3/3k/wCx9ujIr06ues4YtYn6g/09 + 7+zq1OnGM8Aj+n+P9Pdw1BTrVOs172+o911UavVgesgjuL3/AB7c8Q8etqQD+fWZPSLf8U92V9XSgSDr + Je/u/Vi2KjriTp+n5P8AxPupah6qr1661EXv/X/kXvXiE9XLU65Bvpx/vI92DUPWtY6zRgagT/X/AGH0 + 9+ZvPplzU16ySFQPp/vJ901V6qD1CP8AX2z1ZXpjrr34GnVmfy64FrG319+PWhJTrFI91Nv99x791RpN + XTe9+VJB/wBb6e/BtQ6Zr1HJMYIJve5+p4v+PbbDV1rqI04B/Tc/gn/X91DGmetaqCnTVU3kYn/C35/2 + 3twPUU6SSLqap6ZpjpJBH+F/9h7UAVXHRdKBXqGzaRe9/wDW9tmN+Or+XTJagr1jbU6E34QWtz+OOPZX + cOCw6J7xtWR02SvpJW3+F7e0xAIr0QzU9Om9lH+H+29slSTx6KWjUknrFbn3smnTBx1g0G/+w+vP0921 + da6xOp+tj/j72D17rCFAN/qf8fduvdcvfutdcSq8kj/H8+/de6iso/A5+v59+8ur6cV6xEC4LcW92HHq + nXFvUPTzz/rf73729QevdeCKPoP9uB7oST17rEQLngfU/j/H26jnh17qOWs1v6/8U9rUchetFQeobqSS + bf6/09vAq3WqhePUSRfr9OD/AL7j3qoBx1ShNT1HYXX/AHn/AG3txTQ16qOojqADYD/A29qAQetjqOyc + m9wT7tU9b6gulpDYX/3r6+7g16cU9R5PqQR/sQf6e7A06cVtJqOo0o9Jtcf64921V49K4ptRoeoxFxa/ + +v78R6DpWraTXriAn5t/yV7qQR0qUgjh1GZiG4tb22elCHtr1Ijublbfj6/8a91BA6Z1jrsEBmBvcn8f + T3cavLqtSc9dOLsAP6fn3sV8+tgdcShAuSP9v7316nXWoWK35A+n+w9t6TXqtD1xH0F/rb251vrIqsfp + wD+QR7tpbj0w0jAkDrsqB9SSf8ffirdaEjk8euZsVP1+h/p7p3efT4r1jCEgG4sf8efrb3vq9OsgCj6f + Uf43/wAOfd1Krnz69Ug9cten6ED/AG3vztqPWqniesiOD/vj7SupPS2Fzw6zAkc/X2zpbpSrGo6kpKNP + P+t7rpr0rDinXLXcE2+hFr8+08kea9XDA8OuY+gP+HtopTq1eu7C315/pb/ifbeOvdZdS/19+6313rCk + c/n8e/de65mS9rAWt/T3vpxTjPWeN7AHVbj6W97OOHV+pSShmAA+nP5H0907vl1cEnqbHMwPA+n4v/X3 + sfPrRND1MMzG3+t+Cf629760TXrLGxJ+p/Tf6n3ZRU0611KQ/W/+vf3fQOtE0HXTva2m4+v+HtRHw6aL + /LrD9zb+1Y/65/2PHtyhPl1fjnrLHUsxA1cX5+v+29+0n06o9K56cEmtp9X9f9b3qhHVQwXqWkgb+1/r + cD/b8e/Z8ut+J1KWYAW1f71/xPvdG9OveIOswmuRyf8Abn/W/PtT1XUvr1IWS/H15te/v3W+PDrOrab8 + Xv7917rmjjVyBax+p9+6sWqKdZ1lUfQf61iOTb2jk+L8+qAZ6lK9lU3IuP8AH8f63u3T3WZXGn+pH+83 + Pv3XuuSuTe1x9Pz731dVqK9Zgy2tf6f4H3sJq86dWC6TXrkLcEEnn/evdvBp+I9Wr1y1gMSfyPp7t4fz + 69XrA9Rf0/054I/4j251rrC09ri5+n9T/T37r3XFZ7X5P+8j/eh791oGvWTy8fVv9v7o/wAPVuvCS/8A + aI/1z7a631kV1ty31/r7917rIs4B4a/+Fzf22Xoade6kRzaza9v95/3v2205U0p16h8usFdCMjV7WxrG + 8ddvXbMEiWv5ESraqCEH/ao1PsMc33LDl25YD4Vrx6NtjiEm7QI1QC3RlosaS1zGFJN2H9CTci5946xM + 0ViiKNRYFs+vp/s9S3IwIeZsaDTHmOnyDFoEBI0k2VbgfleCT/r+3nJ1xxxdzPSo9Ps/2etf6H4o+H54 + 6ELe9P8Aeb0weFVWek2D1zhKJkHIjzO6JjW5Jmj+gY01NTlSOfUw+nvzFUqSynJwDU4xwGek8z96nSSP + kP8APjowuzcbhuuNmZDcWfrKLC06Y2fcO5MxkpY6Okw+Ho6V6x5KypmISOKmhDSSsxsDqJtb2mYzO6+E + mrWwUDIp6k14fL1x0plkhjjaZyURQMtSv8q/yyetKP5/fzPuzP5pne+6vjV8bs/ufZvwq6wztHt3Obh2 + fWS4XeHyK7KyVVJjtr7cx+4Ih5MfiZZoqmqlniOqKhgkqD6mUkZbbBYbRtO4cz7zJ4dtYRsWIAOttNVR + SacWFGpkYNPLpFb2M3M282vK9lGz3dy66FDEDQeLMR6A4HD59Gq6Y6zpOlerdkdVUWd3Duml2jjVx5zW + eyNVmMvkKiqqWqqmGnqa9nlFMk0jRUULOxji0qST7568z75LzRvR3u2jEfjsSqq7Gi6vUiuVJ8uulXKe + yR8mbbFsEbGXwIwWL0oz6cqaVFF4g8agdKWq/kpUnyK3ll+1/k9mdlpmMy7Rbbx9FFujeeQwWy4UDbZx + ceLr6rH4fHTRRX+8giimMkpaRpdR4zA5H9xNk5J5Rj2flzbYJr2QAvLNXUDSpxpI/n1hRz7tO7c3c23k + m637i3t2OiJVXSRX1qCPUU49Ar3b/wAJ2dlR4ubO9A7oji3di0aswyYF8h15u+SsiTUsuHnesqsPNUal + H21LM9KGJ0+eNiD7G+0e8vL/ADF/uo5j2tY0kw7xltDA4NVICj9vQMuOUtz2p13TZ70yFM/qmrgj+EeR + +fRVvib8gu29kdr1Xw5+VVZVZHftLFkoeoOyMrQ1OIy+9Ydu1Bgy2wt1UdcqSx5uhsUEdR+96SpaRGik + eEffr2j2jbdqPPPttF/iFw4aVAgKRLTSfDYVI7lJzShJHWR3sf7q3G67ivKXODB3RCEdmIklNSRrJ4nN + BxNAOrwvi71j1P2Rv7dP+kzIYNMxt7H4et2htnOblpto43OwVSyLnM3kJzNTS5D7d1jpzRmQxoranjYk + ERpyAt1eW729rd6YQy0Mj5Pbmmo0oOFB0f8AuzIbF4Zo7EMjK+rRGZGU6u3upUAjNTiv29WYUmV6o2Y9 + Dtbb29OnsXUVMhhods7O3Ptenl1jgRCmx7xq8jcKFBL3Nzcm/saXdnPb3PgPPHMpH8ea+uKjqHNuS9ur + Z7hIJ1Rf4tQHnwXh+fSszHWlFlJcRu3K7Pwmdq8c6VGJ3BJiKPK5HD1cV1F6xkNRAYzc2a4VrEc2PtQd + uvEjDwxBxT1P+qvSRN9j8U2jyaGNVoVHn5VP+HpJ5zarbgrRVtvDeeIgjjWE4nb2XpsfQeVD+5UySCna + dpXP6ry2Fvp9fZfMi00tUSfw0x+3o1tpynwqrfaeg33/ANYbtyu1MliNqb93FkKiomoan+DbtrKHIU81 + Ri8hDlMXX4TNSwJJQ1tHURRzxGVpKeazRTKitrDQhe57oatpFGDCmfl8h0oEyK4kRFjINSQxOa1PHoA9 + x/HzE7NqhvSursNWbq3NkJNkbcwePochFtHH5vftJNRZ/deRhy008jNQ445Cop6aJvFHJyGIAsG4dms7 + SWW8XUWyaFQBXzFfToZ3XOG677brtY0mONVooY1YhgPLh5H8qdV8b5ro6mPIYjH1GWzRy33W3dvNn8jU + ZPLzY2mRqWPI5jI1ZLutPTDzSte2ohUHI9xxepPeXE1zUIKUqDUp/SWvEnh9nU+WEFvt+3Wm3RguuTIp + x8XYOHGh7uhi+Ou+9vbS7XrNj5rKCGr31tPbdFgaicpFSzZ7C1ssFJjq2YkCKarpy5pA/pdkZAdRF8mv + uw847XY7tc7Ju04ifcHVYAeDSIjHPmS4FKUOQAOPWOn3mOU9w3bYrffrGM3K7O+iYgGsUbfjWldQUHNc + AZPVhbRGxBUghmB1DTyrFSLfjkfn3m/BIZoyQKOmHB4BvIKeJB9esJ3SJA0mqqH4COLL5lh5Eeg6xMFB + tYf717VeEPXpqnUdwFB/1v8AW+vHtTCqjFevdYNIuSbG9vawAAU6112FF+AL/wCw9+691y0N/T/eR72M + Hr3XXjb/AH1vbnin063Xrplt+fx794h9OtIc/n12q3Nv999PfvEPp0t1fLrmqlTcj8f4e7o5J69WvXZ5 + BH0v+fbhNR17rtFP0LXsP6e9de6kAWAH+Hu2nr3Xvfq0x17rKg4v/X/iPeia9awOPXP3rrYIr1kUahf6 + c+9U6tq65BbC3u+rrevrv3ompr0w8p1HHXY5sP8AH/e/eum9WpgepH4/2PvXSny697314ceuY+o/1x7o + xoOr9ZfbPW+ve9de6yIAb3F/p7917rnYf0H+2Hv3XuvWH9B/th7917rv37r3Xfv3SqOmgde9+6t11Yn6 + GxHN/r731orqFOpENRJC3oPJsDc3BF+Rb/ifaaeBZAW4YPTDKFPT7T1Mchte0h/sDkC5/r7JGhKjHTdO + pl+bfQj/AB5B/PtOak6SOvdclYqf68fk+08kYrx6cRvw9Z09dvx+f6/4e2nQAdKKYJ6ke2DjpPL8XXhw + Qf6H37prrIHH54/3n37r3XPg8j3QpU1630AXdxtJtkf1XL/9DUvsRbCukS/7X/n7oi3njH/tv8nQF6tN + /pyD9f8AXHsQHoPufLrASWJP9f6e99OcMdZoioBJvwQfx9feum3JrTrgzX/4n37rWo0p1w+lv9cXPF7X + 59+61XrzOCbj9PF/6/097Wlc9a6xN9T+fdet9cW+l7fQf7c/4+3FYAUPXgRw6jsRa+n/AF/+NAe3Na8K + 9a48T1iZhx+Af1cW49249UFTjqNI3JAvbj/X5/Pv2PPqjdoPURmHN7fX8W/2HHu4I6ad1Ipnqjj+fhz8 + V+nW+l/kFSi1/wCmwMp9fcKe/P8Ayp0P/PQP+rbdSD7X/wDJfl/5on/j69aqv9n/AKp/+uvvDfz/AD/y + dZBdf//R2N1l/r/vHvLx6AY6h2NzXqdTzaTySo/x+h/23tghj0pUgdSxMdQsb/Xm1vx7uK0z0pHUpC1x + c35P+8D3vrdenOMkqPrb/X9+62ASK9SgLWuefp9fej1anU1Twf8AW/P+t+Pe6deAHWJWubH6e3BgVHWw + wB6zXAH0/wBb3bV04DXHWMk/n36oPHrYIHDr3+v9PdKgHqxJPXAvY/T34uCemy3l1kWQn6cH/H37WaUP + VVPr1yZmtzYj6/4/6/utanq9VPXA+69NGtcdeN7fX3vHV1UnJ6wH6n3rqp49R5JEHGoD3utOqGnTdIxI + BU/n3TUCadUPUckn6m9wPxb/AB92Cgdbp1HmICn+vvxHTcjBRXpneW5I59+CgdIixbqHOFZeBz9fbiHy + 6TyKSOm5lvwR/X6cA+7HVTpKQOvaVVGVb8/j2V3EdO7otuogFrTqE8Gon6n/AGHtFWnRFJHU1HTVPFIj + H0Np/BA4/wB496BBFT0R3AZXp1F5/wAfrbm45/1j7qaA9JaitD1171XrdR1wdbj8/wC8+9hh69e6jhLE + fkc3493qOvddstyLcfW/Hv1R1rrGVPIsT/sPr7317rGUB+nHv3W6nrAU9R1H/iP9b3ZePWusbLz6bkW+ + v1/3r35uPXuutLH+o/2w/wB79163Qnh1wZW+nP8Aj9CP9492UEZ60eokqm5F/wA3/wCI/Ht5W8x1rqOy + sL/kf6/t1ZadewePUORDzfgE/wBP8b/X26r6m68aU6isoW1r839v9MdYZEuDb8/X/bfX3dW0nrfUVluT + f8Di3/E+1Az1vqI49RuPdx1upHUZ4yeeb/7ew+vu3Vww6jTL6bWuf62H+9D34dXVqGo6b3Xn3YE+Z6Wx + vjJ6wNoH4F/8R78R8+lSEHqKzAueeP8AifbR6MI6BKDqRGwt9R9f6j3Sh6Y66/J/1zb/AFvbo4dWHDrk + L/UA/wCwHu1CeHTbuVNOuZVv7TC3+tb36h9OqeK3oOoz8Ne/9PfunQxK16yKQ17fj/H3rpN4x+fXMXAt + f6+3xwHWq1z1yAGknn629+bh1Zfi68EuL6vrz9PbHSug9evIT9NVv9h/xX3omnXqgddhgGIPNz9b2+nv + Qqc161k566azMLG3H+v72K+fWx8+uarY/W/+w91bpTCK9ZlFz7Zc0HSsceswNuB7ar1fWeuayWI/qT79 + k9OxuPPrOZSfx+fdWSop074g65i5II+luf6X/wBb2x4WeHTleuzx9fbTIVNAOt9dgDm5t/vP+9e6Upg9 + e6yagAPybDj3rrfXYYnkEj/C/vfVwwAp1MiY3uv+sb/0/wBj7crH5jq6yKOPUoSN+Px/tX/Ee9aCx7et + NItcdTULHlvpaw5v+fdvBk+X7evB1PUgah+T9PwT7ssTg5p+3qrEEYPWfyAXN2+n+Pu+huqfn1weQkXW + 54vz/t/d1UitetU6gPPa/wBbm/4HtYvAdU8UDHXUU/q5P5/3j3bptpGr2npyScEAX/33+w90cE8Om2Z2 + +fUyOew+v0A/1v6e6qrBqnqvd8up0cykc3uT+P6W/PtzHr17u+XU5JE4F+br/T8fX3rPWu/5dSlkAJAJ + /Nv6X+t/e+lCOAoB49Z43bm5v9Prf37q3iL1lD/1t/sL/wDE+/de8ReswI/23/FPaSTBr8+vCRa9TUJZ + Bf8AH/I/e69P6x1Kj025A/A+n5Hv1evax1kNiDaw4/1v9b3sHpxHFOuCs1/r/vNv9593Rgpz1YsD1yEp + B5+n+vce3xnrQx1xkn+lvr/tvfqdW1DptecqxF/x9Qf+J96p17UOo4qeG5JNj/vXv3VS6jHXNKnj1W/w + /P8Ar/T349VEijrMZtS/qFiB+SPdWBIoOrCRSadeWcqLXv8A7Ef8T7pobq+oddGckC/I/wAPx/r+6dW6 + 4+Yj1C1/x/X+nthuJ68M9SYqxlILWsP9v7TyZPSmMBRRus6ZaGiy20K6Y/sUW99rzVNx9Ipq77BWv+LS + Tpz7DPNqNJy7dKvHR0cbQVi3OGVuCtU/Z0eaOjjjbRJ/nEOlgV5LKbNf3j1GwS1hlBrSq/Op+Xp8+pUQ + aRrwQ7Ageo+fp0CvyF3juTZezsONoZX+AZPP52WmrtyLj6bKVO39v4XEzZ3N12Px1WCk9Q8cQhgiPLSM + FX1EeyneLmbbNpmv0/tFBIp/qx0v5fit923RLTdapC7aV0jVmvmMf4egKi7T+R+GmqdzT7plzjZuGgrM + jL2l0ZuXZ086Y3GiloDVZXCRyQwFYAutL/6pidXsBW3uDvOkG9s4mWgzGdLnGCSdWfM/PqSJvbfloOUs + b2SOQnBY+KoPlgaaAenlwz1TH/Po/mSfKDb/AMWNodAYnaeT2FtnuaetHZnbO09wyZjaue2pRQCpxWzt + rZcj7iGPMASvOsr8xxtGGLBlEh8l8z7bv1xLDCjx3YQ/pyUKrgkOslACWUE001XhU8egHzryLu+wRQve + TR3lk5zNCM6iQFVo8ldJoC2qh40x0Vv+WN0Xhtj9e4nMxRrP/dbDY5vuUDRrke0ex8FT7m3xnH1H1fw3 + D1GKwVBc/tp9yQA0rEhD7yfND7RY2HtxtrHTCi3Vx5LKZ1FFLfi00rTyPUw/dn5W+rN1zvuMY16vp4X4 + soiZgxApitRQ+Y6vA+Pm1IN4dwbRxlUNdDQ1M+4ayJ2UCeHCRffQwXc865VTj+gI94w8sWJ3LdBLhCz0 + C1ooRQTj5mnDrIznrcW27lu4ELHUoqJPxVZguflnJ8h1Zp2l2TR7Fxaikrtu1G8MrIYdt7XydVkJ8hlK + 0qHEcO3tuRVWTqVA50QU9rWJdQb+5qmZ5dENvGF0ChYHNf8AZ6xYs7OOUNd37kBGPiuMpQn8Lfi/lTou + dZvL5TwUZ3EcRvKGiQeVqFvjnXUu3XEakrEsuQ3BHknVbW1/ahwOdF+Pdv6v81eH4iN4MZ0UUZVtfw0a + lftxjoyl3jka0ItZHhl14Ems4/KnVPf82XpjJd+dH4f5lbA27Bszu7qHeGMbdB2/PPM827NsuH2bu1p6 + iOGppZJ1hbCZamro1n0SUfk8ixpI04ez293e4wX/ALVczKFjmicIrGoqamlfImpYfkfPqOud9qj2XcLP + nXl2VXSCVS7oeKjTXSPxDgPLzFMVL71N2FtLv7qnrzs6lhwmQh3btTFbhraGRKCtqsFma6nMeTpamEhp + KR1qI5ogHRNQXgFefeGHNOxblynzDPsrxvGLeVkQVILAmoYDzXyr646zj5f3rb+Ztqj3W1dZqxoWRgP4 + fPjQ/Lz6WeeXZO3Nv1ub3V/c/bu2aGITVmZ3B/CcLh6SMLczNkpxGqMACQ0ba+Lrzb2T28O831+LWyWZ + 5hikYZ2qfl6ep6NrubaLCx+tvzBAjA1WQqihfM1zkeQpnrH8df56PTvS/Z2z+mpd69gd5bP3pmKLa+3K + jC7D3Xnqujy1ZMlLQYXa+8aiNRuCORmCQ0yq86jlZygK+8l+VuVfdLZbNLi+sH8I0Olj+po4mqUrwzx6 + xG593P2r3rcGi2C8X6gmmoLphDnA/UrSleJpw62QcV8hPi3u/HVOart37PxNZRhjmMPuR227uLF1UYtU + UtdhK8Q1PlQjSwWJiT9L+xcH20yCS+t2ikP8UbAf5uown27eLRiIXDoP9EVwUP2MSOgA7E79p9yRTUnR + HV38eoaKOolg3huirk2HtPKPBEbpiKqujerrVNra0p0i+haa17OPydzDzIoutktPDRSaM58MOAKhuB7S + Mg+fSqDdNp2mVLXe7pnkmAIEQEqgnyJBGfXj0F+Xzfeff3U+0u0ti9cdXb+xGJyf96cfmtmbuym287Xw + 0mGrtrZ/bdbtDcELwjKwpWzFZDVLHI8aspCup9gK/F/u+zXE9tFFSEtE5V8lkw2AOIrxxjPQ02qXaeXt + +t5bmaUFqPoZMaHIZSrVFa0OCSARQGuOqrM7t+t2mm2s5XzUmY3puuiy2Pi68iqqdM51zT4HLPj6yj3w + 4Zko552Ty1EjD1cRwh1CuYLvthlsYfDuJKGXuYqarp8hXzYHivpmvWVOw802m+GeW0U6odWkMukkSHBp + U/DX8mHQRb7wE8FBjM3X1aTZmqzkdHlMlRxyQClWqiH8ITHvfUiUM8UTUxJ1atT3BYj2AuY7iezsP3ps + sjRS7dSZHWocMrChFOJ6k/k6C3fd4tj3KJZ7XdYmtZVbNS6kl2B4Upk+nVqPx27gHbmx3/is8R35s5aT + F73o10RtUSaPHj9z00XpJp8gq62t+icSIbcX6feyPuxtvutyNb7izlb+3VPqU00bxKdtc5HqaY65ke+f + s/uPs5zvc7LLGWsr1ma0cHUvhMSSQaCgFfn0ObqSfxf8/wCJ/Huco5klFRUfaKdQw0TKK1BA9DXrEVsb + EAkf7H24jH4hw6aBqK9dWWxFhyP6e1SzKB3dep1i8YX1X/2H+v7uJUOBXrVOvX921r17r3vYYHh17rqw + 5uL/AOw9260DQ9d2H9P94966f8Vfn16xa1v63P8ArW9uxfEfs6ujhjQdc9A/x/H09vdOddhQPp/vPvYF + evdcve60x034i9dgX+nupyeveIvWZRYAH/fc+/dNyNqpTrv34Z61HXWOpFre96T0p6971034i9dC97W+ + p+vFvfum6a2x1mVbfUC97g8H37qwjYEE9c/fun/KnXvfuvDj1kCMDckWuLc/0+vtlmBGOnOsntvr3WVV + te9j/vPv3XuudgPoLe/de679+68TQV69b36vVdY65hbHm1vdC46vTrsgW4Av70Hz08rqFoeuGk+7ax1v + xF670n37WOtiReuwv0N+b/7170XBFOmnIYinWTUV5F7/ANVvf/bj2lkWLgeqdONJWFSFl1Ov0DHlkFuB + b6n+h9pJrcmPUlKEV6909x6WFxpN/wDWNv8AX9k0h8N9L8ePTkaE93WVePpx/rce2XIK1HSg4HWVXI4P + 0/r9fbJHTDqWNR1zBv8AT3rSeqeG3XYFza4H+v7r1TrItwxH9B/sPe+vAEmg6ATvA2k2x/wXL/8AQ1L7 + EWwqWEtP6P8Az90R74CnhV89X/PvQDtIjHSLk8j6fm/s/KMoqeg6uDU9cL/g8c25/P8Are6kgCvV/EHX + vVawP9q4/wAPflowJ9OmmYVqeuwTc3+t7n/Y+/de8q9dMDpI/P8AxTn3tqVqOvEjj1jUM1rAen/H/G/v + WOtEgceumjZb3P0v9D/T3bWv8PWvEHWMva62NiPrf+o/p72aMKqOHVDQ56wn0/kC/wDW9vdqhqEDr1a9 + R5AW/I/2H04493rmnp14ccdRWYg/ix+h/wCK+7BTx6ZejZrgdRH9N/yCb8e9kenTPVHP8+03+K3Tp5/7 + KDpvr9P+PAyn09wt78j/AJBsB/5eB/1bbqR/a/8A5L8v/NE/8fXrVZ/s/wDVP/1194bef5/5Osguv//S + 2LVbmx/2/wDxr3mEKE06hBWavWdWNxzfkfX3plWmOlSu1enWFlvzb/Y/439sZPRkrinU9SLg345/3r37 + q9enGB2Ite6/0/qPqPdT1YHqYbsF+v1vYX+n497BHVhnqUp9Iv8A0P8AvfvYB63TrEzBeQT/ALfn3vrx + HXlkJ4J/3n3ony63wHWUMt/bikdUGqo68WHNvdW08enCTTrGUJNjb23UA16rnrkAVNzb/Ye9068BXrlr + Hv1OtdcVk/BH+x/HPv3Wxx68z3+hBt71w6uxocdQXqNNx/tuPfvs6ZJPUOQl/wDb+/ZPHqpDU6jMSBb/ + AB/23vVBXqg456wyMQpI+vHu/Xnagx01zSMxIJ9uqMdIZJCT1Bc8m31/rx/X/H3Vl6oMCp6wtfTz9f8A + Hjj/AGHvyqQc9aZh1BYMb/QWva1/diScdIm446jgTXGoi3svvDQUHRfduaaes6rwLjn/AGP9f8PZUeis + xjzPU5LaQLAfS/A9X+vf2XShy/H+fRZKY1ajCvUKfHwztqcNf/aGCn6/63vysyih6L5Y1kbUMdNlVQQx + KSnkFhca5FPP+w9vRsSemXh0jBx0yEG9vrb/AB9qcAZ6Tmg660j8gf7x78GBwOvdcNAv+f8AePdxx691 + xBW1iL8+79a6wshB/wCI4/3v3qo631jZOOQOeL2B97611i8YH0Nv9h7917rD6rkN72OnE68dJBH5/H+v + +PdqilOtPx6jOhYnj/kf0/r7sgNOqdRnUqDf+h93qD1rqFJ+kf64/wB69uRfF1sdYLe1Wg9ex1gePkn/ + AFzb68f09+0GvTb8eobIRz9f9Ye30amOqDqI6gm5H5Nvr7UVqOt9YWABt+Le9jh17qLIg/HtwevVl49N + ki2b/be9HPSkYPTbM2kk/wC++vv3DHS+Py6gBwzG35/4gX9tnoyUUHWdb2Ug2tf/AHv251TqSpuAL8+/ + dJ2m0sR1kW6m9/bqcOqF9eeuQu1wT9Bfn3frXUd+GB/33B9st8XW+uQcf4/7x7tH59aPXLUPqCB/sR7s + /wAPXusgNxYm55P+8fQ+2vl1YGmeuwjH6lh/gD73ob06t4jdcfSPz9fdHVqdWRmbj1j/ACf9fj/W9+HD + p4dch9frb/Y29+Jp04iE56zA2/x/3n3Q56Ur2DHWQEEXHuvTwNR1kVvwT/rf74e6la9W65XHFj+eP+Re + 2ypHWwxHDrmGP5596oet6265o7c8/wC9+9UHSgOadZVYE2Ynn/b8f6/ujICenFYnrI3qsFPP+249ttHU + 8Or167NgRf8AP09ssmk8Ot9cg4UEW/P9bfj22evdZEdvpf8Ax+g96OOPXupaH+h55/21+PamIVAPl1o9 + ThL+CNX9Lf7f8e1AFem2ah6z/df63+8e90614h9OuRlB54+n0vzwPfqda8Q+nXPzrp+n4+l/fqde8Q9N + c8v1FuLn/e/qPb60oKdNEivWGOQc/wC++nu1D1RmNcdTIpbEAX5Iv+f9gPe1BPl15WPn04JNx+fqPx+P + d9Hy6sTjqbHMLDnn8fQ+/aQOPVdR6dFcE8f8R9fbdD051PSQ/wCuR/aA45/Pv3XupCMCDcgm/wDUe/da + qBx6kRabm4vx791vqUpvz/r+0kvH8+tjiOpkTHgX/I/p9PfulHWfy6bgH6H/AA+vvdCeHXuPXJpQSLMB + x/Ue9hW9OnEwM9ZLj+o/24970t6dXqOsZYC3I+ovyL29qK0Un5dWqOsEj3/tAWNvx/T/AB9th2PBevV6 + aJWOtrn8Gx+n549u9aqOm8y6dQJ5tyOP6e9dNN8XXNZxbnn/AH3+Hv3Wus3ntbSebC9jf/eD791Zfi65 + rOxve/8Ar2HvZ4dPdZRNYfTj/ff4+01KcenK9cme4U3HI5+n9ePaduJ62v8Al6js5/rb/ePaSZiGFOlQ + 6b8nCMjja3HyzPSrVQGOOqVGaSlqkYTUVTEvGpopkjkC3/HtDdRi7tZbWT/RFK/melCSvE4dfI9Gw6q7 + Si3ziZaXIFKDem2oKOk3dhZCPRLo8cO4MdIfVLQVwQywTWsrFom0utjjvuOzS7JctbyAlKkgmtP29SZs + 16LuIamB0j1HTr2tHBPtrFbkqMbBmqfYu48ZuzIY+aBapKnAQlqHcZSne6u0FJK9YoP5hHsl3C3W92yW + 3IrXHrX7OjSxuWs7u2mT4hKD9lD5+nSY7g+RuL6qixVJioJN07kz1FDmMPT/AHhpMPT4eoCmhzGQqo9T + MswIaBYQdX1uAfeOnMe/R7NcfSlO9MFfMD1I4iv2dZI8oclSc2V3CwkMcNTUtgM1e7SeBNfTqi7+ZTik + +RHw5+QuKm27QUOWocnV7m25t3EKskaZetFBn/8AcZHU+qET133FgpCr55ALaj7Xch7+9zz1sskQKLfz + +C44dqqVrT0auPXy6FHOPK4seS9522AF1+m8RGYVKOhBdq+Qrmp4DPTB8K8PPhfjptCOqjEdXkcnuTIV + YDI1qilyZ28YC0ZKnwihEQIJ4HBt7Se+11Le+5d/HMe6Dw4dJ4hURaGhyAamhOMGnQk9h7Rrb2rsHoCH + aVtS5DN4jVoRg0oOB6ODt/cGZ2tmsbuHb9a+OzOJqUqqCrj0t45FPrSRH9LxuCVeNwVYGxHuKLW6n2yQ + S24NR/xXUmX+2Wm62MtruClo5AFYUzQkUp54ND+XRzekO+umtudo9jd59gbarqLtDf2L2XtmfI4OhbJw + UuE2zj5IMn/DZ6h1ei/iUhiaphgUArGgJJ9zLyd7gcv2IpvkWacTjNKVzTzz/LrHrn32h5mnZLDl24A2 + 6IlnGNbk5AAGTStP5nPRXOte1fkSv8xLB9o5zuvMU3xpq6LfuP7VpNx7rqp+ud3bYqKiql63xW1Opp0d + MLl8XG+PpjXUqoZ/DUSzu5k5Otv9xrQ7oI5JmRW1VkYVRvD+GinCV8uHQF3D2r5nsNlWli0snyKsR+wk + 9Hv3TgOvO0t97z66w1VT5/rnvzrLeWH38MXPDVQ0NLh6OE7S3dZDZK2nq5zSxO5VpFjjFmWO4F277vtU + G5WPMfLs6maCZHk0yKxdRQkYY1rw+WR69BW05f35rC72rfIXjQZUMrDSaAUrShwa8SK0Pl1Qv1J8LMz8 + EKDvPqWXP0OU7Y7P3FuHKbVz81PlsbtLLGow02L69o8dlMvGlPZZ6kSVQ1ARySNGSdIPuP8A3Z5x/wBc + D3Etb2K3FvCmkSORQMKgtQmgP+fqffaHZV5f5MvZpJfEaZCyqDVo2VSoBUZFeIx0ouj/AOU7k8Htylj+ + VO8+0e990dZ4ekG5dnbO3BFuLC9c1c1MK+n2/k98Zg/bU9YAwMtLtXFSzU8PjMla0vo9zdHznFt9o8ft + 1tkELooWS7lUNKTTu8NSCWJoOANCOsc/3VuG8SMOdN2mkLy6oYgSEKA/Cx4AHhnqwjrX4j/GzJdt/Gzt + PqDZ2Q6+peo8HujsXc22Fz+b3Zjdxb5rPLsfZDZWv3FVVBjrsRKchkYK2jSFp4nVJF03VRB7Vc38y81z + 3Ee+T/UrFUGQjSUPoUNCRxoKZ9D0Q+4vLPLmwW8bR23gtIRREYaXBA4MDSp+3j1Y5U42hqZVqqqgx1VV + xOHStqqGkqqxDfgpVVCNIP8ACzce5rRLOab/ABpUmr/FFT/COoujlurZfDtTJ4I/0IyY+ytegy7wyVfh + um+0srjmiOWh2RnKbEfdSDwvlsrTHEY+NjJxcyVA0gnlv8faHmXeYtn5Xvd0LiKO3huGoAFCCON9JNaA + KKChNARTox2Gztdy5jtNtIYPLIprxCVIOmvDt4dV/wDxB+bdJ8bPmdvjoPedfHQ9Db3zG1uvqATvHHj9 + i75wG2aLb9BmzLNYimyEqNR5Ek2v4ZTcqb8hPu1+6t5bXzbPzJN4tpu0s0oaXGh3amk6qY7eHoxxw66Z + e8XsT+9Pa6w532GovdtgQMqg1liXNVAySK1FB+YqeravkH0Vgt30W5drR0ONxuYqKn+PbazsdFTwVT5Q + RaKU5CqhVZJ4pEApZTIzEIAR+ke8k+buXTIZIocRK5ZPUgrinqM+XWNnIfN02zyx38lZNVBM1Oxe6mlj + wDVzQ5oeHVH++9t1cdNkNr5ulkx+RoM9iKLIUjkCWCqhzcNNLp12Fwjs6n6EWP0PvHve7c2W3XkEoP8A + ZSYIOaKT5/Z1mDt27aFg5ls3DVZSukhgprwxXJBIPyNekbgd35/pvs2Xc20vJV1O2cjk8TX4ad9FNujb + BqCtfga5DwZXiVZKWW/7c6p+C1wR7Be7W7e1nMcXMSuZLCZ41u4q/GgNKx+tK1qKjqY/fT2rs/fT23ks + KJFucUStZSgfDIQD4XqY28z5efn1cVtDdm3t/wC18HvLalaa/b25KGLIYyd1EdQge6z0VXAvMdRTyB4Z + 4iLqyke+4m07pa8wWKbvZuphkUOjBgVZSAaq1SCBwJBwQR1wx3vZr3Y9yfa7xGSeIlXjYFXUgle5SAwB + IwSKHy6fSh5BUg8jkEf7x7XiYuA64B4fZ6/YeI9R0Wse7H+r16jshX8f1+l+Lf19uIxatetDrha/B9vp + 8XW+uLKACQP97/r7d611wHtxAQc9a679udOiOorXr3v3W/CHr1yX6/7D25F8XV0TSa9c/b/TnXfvakde + oeuvejx6SnievAkfT37rXWZSSAT/AL7n37r3WdVUgf63PJ/p72Bnq6A6geufu/T54de9t9JesqfT/WPv + 3TkXxdcz+P8AW966UHr3vxIHHrXXYHI/1x70WFDnrY49SPafpzr1ifoD7917rP7917r3v3Xuux78etN8 + PXfutR69M9ZfbPSnr3v3Wqjr3v3Xqg8OuardT/W/v3W+vBDcfT/effuvdZAq/T8/0ufbEhBOOqnrkoC8 + r9f9v/vfuoclAvXupMNS8IPN0vcrb1X/AKg+0s9qjHVxNOrq5UU6e4JkmXUpA/2m/qAv+R7KZ4nXFDx9 + OnVctinWf6/Tn2lOOPVuuwxH0PvXXuuQYMbfkc3906TUNeHWZODzxx791ZAQwqOgC7zJD7YsfquY/wAf + zS+xLy7wm/2v/P3RHzD/AKD/ALf/AJ96AAMwcHj6f0H1v7EjgFOgySKceuTEkm/P0twf6+0TfD1VSKDr + LGeDf63/AD+ePx7qCdBp1V80p1xJOprX+v4/417c69xAFaddFjY/X37rRGOPXNCAGNx9OPp711Tjx69K + w1W4tc83/r791okgjqKw5v8AUf4f0BsPbqfAerdYmewuVI/1+B/t/fo/L8/8nXh1Hdze9gQRxY/S31v7 + cwCSfl1Qk+IPTqI7Xt/t/pb27UdUPwkfPqMWuoB+o/P+Hv3TXVCP/ChnJ1uI+HvUddQSJHUJ8hqNVaSJ + Jlsdg5S90fj3FXu/aQXvLlvBcAlTcDgSP9DbzHQ79vppIN3mkiND4XpX8a9afn+kTddrfeUf+at/xbqX + 6X1f0/r7xv8A6r7N/vtv97bqYf3vf/xD/eR1/9PYnFtV/eXykhs9QuNNajqSv+Htw8Onjw6zM5H0F/zx + f6/7D22i5J68rdOtGxZV/rb8/wC8/X3SQCtelcRqOneI6TYn6+2zwp0/w6npMoH1H1t9fekrXrYNOuZq + APr7dbjjq+v06wtJruQR+P8AfXPuvWtXWQX+o/2/09+69qHXJn5AW/8Ar/7D34db6yX45B/1hz70RXr1 + eveWy2X6/wCP+t7d0g8evDrgJWLAHgfT68+9sAq1HVjw69q+tvxc+2anps1HUbzMLgm/5+tv9h7saHrQ + anWVZVtzYE/i/wDT+l/ejnreqo6gz+u5H++t7pU6h1StT1x5HNr/AOx/r9Pd+rEnrA5Zh+n8/wCN/bRJ + Bx1Shr1Dk1AWI+v9b+3Fqw6ZcEcOm+VbAte309uKPI9JjjPUG9j9f9j7e8uqtlcdR5iT9Df/AG/vxFB0 + mcHqEha7X+n4/PtomnTJ68Wa49I/r/vh7R3KVQsekN2D4ZPWb6kWFv8AWHsn6IwSa16cIaYsoPksTxze + 3Pssn+I9IZ4yZMddunj9OoMf6j22OmqaRTpvqqM1K/q0Ecc3A/3j2/E4U9JpUJXplfFVER+iaTblXL2H + +N/arxh8uk3hH0PUaXHzxjUumS/4jBYj/XFvexIjfF1QxnqE0U9iPFMP8TGwHB/rb3dTCrV6oyY6xm62 + FiL/ANRyP9v7eWrVpTqtCvXiARz78BTrfXExg/8AG/p70T1vqOyG/Atx/re9jr3WIxAC55/2Jv78eI69 + ny646F/1v9b3vr3UWQFWNhfk/m3t9eHVesDx6+f8Pp/r+6jtBJ631FaMW+gt/X6WPuwfOOvdRvGpJ/1+ + fr7VRSMcHrRrTHUaRLNYH2+WHVNLNx6ishUXNre9ax1rQeociC/09vxyAjPWuo7qL/QfW39foPbwNRUd + e6jSgf0/HtxD1YHPTXUIPr/iPdjXgOlCZPTPUWF/eul8Rx03Lp1G34v+P8OPbR49LgTTj1njLFfULf0/ + 4n270n1N69SVKC30vb625+n9fdlyc9VOePWQEH6e3qAcOtdc1b8kAD6XH9fbFT69W6iytY8A8f719ffj + x691wUlr2B/3v34Ejh17rOFFhcfgf19+LE8etVHXIC3AuP8Aff4+9r8Q69Udcvb3XuubILfX/fD22/Ts + Qz1gZgPbRPStUrnrDqN7/wC8f8R7p0oAp1nWU/S3/E/j37rfWZW/px/gPp791atFx1kDfW/+wP8AX/Y+ + 9EdbVvXrmCPweb/8i96p1YMD1yDG/JNv9f3ogkUHVusgN/p/vr+2tDdb67HBB/p71Qjj1dWAHXMOdQt/ + jf3rB6dV/TrOrAkaibjn/kfujKCen1JIr12SGJW9uQb/APII/Hunh/Pq1esmoKbgi/8AsP8AX59tyRin + XupEbn8/61yLf4/j29EoEaj5dMtJRiOsplKtcW+n+PtzqpbVnrJG4f6t+Pzb3vqrGgr1n1gknURYXsP9 + b34ZNOqa/l1wMoA/Uf8Ab+3NA694ny6b5ZizcH+v+J/3n2+kY8ukxkNesJkKn+v++t7fMdPl1rxW6kRT + ni3N/wDH/C/varpPXvFbpxjkc6Taw4/3w9262rszAdOULn882v8A8U9tPx6eHTtHMPwL83+vtunV9XTl + E9+L2vxb/X9ttx61r+XUuMgE3P1t/vHvXVWbV1NQrqPI+h/pf6+99Ojh1LQi3Bv9f979pJeP59b6yK5B + +tr/AOH192oOr+L9nWTWObn8/wCPtyPj1aM1JPXYZT+R/seP979unp8+XWQyj8ED/Y39+611hLkt9eOP + wP6e6t8J69wz1jLg3BI4I54/p+Pfoz2jq+vHDppq5gDx/Ufn/X926p00tLck6rf4WH4H+PPu44da65K9 + v7X1/wAB+Pem631kEhB+t/8ADi/uvVk+LrmsxPBt/Xn3vp3qUkpNwfp/sPbEvH8urJx6zagbDVx/S9/9 + 49pOrrx/Prp2B4v/ALED/H2mlXU3SsdRpGP0J/J/r/re00kZAB40PSqMgVr5jqJLFlaXI4/cO3MicLur + DBxics0f3FM9LKQ1ZhcxRcCooKkDTNCeV/XGVcXJHvGy2u7wsknxEED7enLO5u9vfXHha16Nb1h2lRb7 + paulqKRMNu7EQLFunaNfIkxpI5Aac1uOa2mpxdVyYJ1H0Pjks17whu+0Xm0XmmQERDqStv3C0vLSqn9X + +fRQPlD11/djCtNi3eKnoMblpNh1oeWSbHYo6p8vsqseXUpGKnnSsw731GCRoCP2V9wJ7ucrQTGHmGxA + NP7c/wBHFK9ZG+xXOU1rfy8nX5NZBqgB/iOTTolOL25tvL7NkwtfiY8hht24KOLP0VdU1dUmdgyND4a1 + a+eWQyMJAzi6OhW/p0kC0Ex7hcWl6Nxs5PDNqRJE3DRp8/l69ZVxbfaX0DR3/cHSWKVD+PXih9ceXQ0d + PdIbg3JjqLafVO0KTHbW2rRwYamWmIxm2Nv0kI1wUCVlSW1MNRcqC8jXLMSSSVxtt85jvZNyu2NxPcAS + PMc61Y0UV+VDToOXG78r8m2cG0REwwRLpjgTGhgasaeWqo6NLQfCzfUyr/EN7bToXKjyLTQ5LIKj25XU + FivY8XA9rxyDdtEZzPQj8NePQXufd7YrZisUMjU86HpzPwi3Va6dh7dc/kfwjJrYf1/WT/vHvc/JCmEf + USD8+mI/dza5WqLeX9nSWzPw37Tx6ebFZHaucGlmSGOvqcZXSlVJ8cUNdH49Rtb1SW9svyVfRQFopfF/ + OvRhbe7PLVxcCC9SSKvrUdBTtbrnuDHb6gwm3NvbjwW8cXlaWOpqaemlp6XCyNplaoyNbF/k/iMR8hDF + g6/2SD7LbHa9+sbpYokIVTQ/4ehBvO98p3uwTTMyGNxVCfjI/pfOtfyp1Yp8k9n4XdvTG6huOmpcnWbX + wi5/G1tSkUrDKUaJHUvTs4/zdQGdXiUW5BWzAESRv9uj7Gs6/wBvGKfmcn/B1BPIm6C35uSOwLNaz1R0 + b8RJ7afYMV+fVTfxsq8N1V8j8v2fuvcO8svHSdX5rYW1tv09QJMVS4PfVXT1+Yy+5ZHkNRlaqGagiipF + mJ8JIk1liR7Sci8//uVlbdchSVA+34ehL7j+08vNPivsp+nlipRRg549HT+HGRyeaxnbWRzFJFR+HfVJ + jcFSRSrOMbtmOjmyuHxYeMBNcAq2EugEaieSRf3lN7GX1rf7Rue7wR4lnArT1OD+WrrHT3u2yXZd12jY + 7s6/Dtiz/wDNQLj86jo45RbHj8e5zNeoW6Lh8rCw6E3iE4157riJrMQPDL2LjEmDkf2dN9Q9gP3ejB9q + uZvntdxx/wCaR6EvJcZTm6xb1kU/z61cvlTli/fneYYsrjtPeEKSK7rJGtNl3ijljIIKsNIKkG4IFj74 + VcqmePbbWaD44wGX7a167t2txCnJtmtz3p9NGrR+gK0r+fWyX/LR+aI+V/x6x+zd4ZGOr7n6ISHa25qm + pmjNduLZEkKRbU3PMFILONIp6lh9JFBY3c+8+eSOc15m5btbXcTW8gPfXj4dKLX/AG2P2Dy65ue6HIEn + JfMlwbPs26/ZHCeQbVU48sf6uHSV+dOJoqDd2Ey9JSwU1XnNuUNRlJIUC/c1WJ3BHTQVMluDIUKoW+tl + H19hL3HtIkhm0/iik/443Uhe1l5LcbPfWj/2UEi+H9uP9nqvbextvPdPquP45XsLfjVLqNveFe2kQ7Ra + 6h5J/wAe66J8vmm32LDiFH+Dpv8AjZ8soPjv8kajpfsHIii6c7rOMyGCrqpxHQ9ddj1znHrkWmlPox2Z + dI4a0E6Y5/FMAAZPfb/7khvOdfu6jV+vecvXk0DAZMtuy+IPtC66D0zTj1xl++7sEXKHvrJPZ4TcLSK4 + Pz7yDX8x1e0yPG7xv+uN2jaxuCVNrqR9R/Qjg/Uce52QMFAcU9B6DyH5Cg6xZWRZR4qcGqf2nqJJ/a/5 + C9qIvPqw6jj2oT4ut9dMLg/776c+3hx611j9v9a669+6Up8I679+6t1yX6/7D25H8XWx1z9v9bJoK9d3 + /wAfeuqeMOuve+k5NTXr3v3Xus4Fhb37rXn1mSwH1BJsbf7D24OHSmP4OuQOoE/T37qx4dc1XUL3t/sP + bfSXrIo0i319+6ci+Lrkfx/re9dKD12PdJPh6qes2i3N/p/h7Y68OI67976e6zKLD/X5/wBuPfuvdcvf + uvde9+69173pvhPXiKinXKx4sL3F/bFOq6Pn1l9+6c67APv2OveHqz16xuB78OvadPWVRYW9+6912CNV + vyLf74e/Hh1rrsrdr3/p+P6e0vWuuYF+B7917rvQ39P95Hv3XussepbOpIN78fQ2/Df1HujprXT05FxP + TtT1mv0uLMRpuP7TH+i/j/b+ye5g01c+XT/29TePx7Qda69z+Db37r3XJSxIBP8AvH+x96Ir17oBu8OX + 2uP8Mx/vLUvsScvigm/2v/P3Qa5i/wBC/wBv/wA+9AMUv+fofxb/AG59iBvh6Cb/AAnrmf0r/sf979pH + +Hrw64i91/1uP9fUfeo/h6t5HrsEgk/4kH/X9uHrz8eumJIP+sf6/wCJ966r1iudIA/JP/FPfuvdcX+n + N9P4Nvx7917rEXtww/2x9+60SBx6wSyG3+HN/qf979uRju6rryNJ6jEi1x/j7dY0oeqOxJp1gZibk/Wx + 9+DAmnVTVj1HP0P+sfdgada6oG/4UV/9kY9S/wDixFD/AO8DlPcae6hrsVt/zX/6xt0NORP+StN/zR/5 + /XrTU/69+4I6lXr/1NiQEWv7y/Pdw6hNDnrkkpU8/T/D/invxBp06SepyTD6/wDFB/sPelcgZ60X6mQ1 + IX9P9PdHo3TsUhp1MSsQkamI4+gH590ofLpSJc9SkmX9Wo8n/EW97APn1cOD1IJLLcMeOfqffunseXXF + ZeLX5v8A8i96qOvV6zpIbWuf9v70W69XqQkgA5P/ABPv1a9XBA6zNMCLj/ePdut18+sKz8ke/dVqeunl + t6re/HPXqnrGKgm/+w+nvRzw62QSM9RpGLngn8/Un3rUKZ6pUdclBsObn6e7A0631jebQdPP9fr7959e + oOuBYgXuf9ufeiaDr3XSzE/2T/rn/e/bQY160T1gqSSNX9AfalT03KMV6apG1ix92OD0hJBHUN1uLf4+ + 7K9Wp1XQGHWErb88f48+9tJpGeqNGRkdYGS35H9Tb2nZtXDHSdwUyeuvqAv+8+6vlKHPTTqHSnr1liXS + fUL2t/vufZLPHk06JpLMhiR06aVYCwtx/rf717KGLKei5wY2z12tKDZiT/t/bTMGNek7IGOrruaAqvAB + /oP0391rQ0HTLgsMdQXUj6qw/Nzf3dSSc9MZTPWK3++ufbvXiQ/b142IsRf/AHj/AHr3rSOm/BHUCTGU + shJZGJ/4Ow/3r3cSyDA6ZMZ6TtZT+GW0avoJ+hBsP9diPa6KRNHec9JnSh6j/T62/wBuPd9anA611ic/ + T3sGnW+uJBAB45/4n34mvXuuB5BH+Hvw49e6jyJ+SAT/AL7+vt1WPDrXUE6r82tf/G/tx/h691jZQEYf + 7Hn/AG3ttePXuoBXn9dr8/77n2oV9J4cevDqPIvIPJv+bfX2rTSy1PXusTLxyD/UfX8e76V60TgjqLIo + Nrj/AGPN/ewAOHTPUR1W/AH+P+v7eVwBTr1eokoHP+vb/eB7dU1yOrg06bpkBUj/AH39fb1aivTqtnHT + BUr9f99/sfdel8TY6ZrFZByeTb6/g290PS1TUdS1awsfx9Le3OmuuYcE2F/ewaGo691mUXFzf6+7a269 + 1zAt+T/sfdOvdY5OT/rj3scetdcFX6Le315/3n274Y9eq6j1IHAAv9AB714Y61RTnrncWI/P496ChW62 + FAz10G5sGH+8e9Px6sOupJAFuP8Aff7b20T0ohQk9Nrygki7W/3j+vvR6XqKCnXESf01c/6x96631IWT + kfUH37r3WUOw/P8Avv8AYe/de6ziQA2JP+3/AOK+/dbrinXNWFza/P8ArWv/AF9+62OsgYg/1H9f6f6/ + vRHp1ZWPn1zuP6+9U6vqHXNTybc8fT+vvRAPHrdR1zDA/wCH+v7aKHy63XrkDY3P9PdenA4Az13f1X5A + /wCNe/Y6uJB69ZFIJHN7f71+ffjQ8eveJ8+swZgbAgL/AK9vx/S/v2OtFlOT1zEluP1f4/X/AIn26gFO + talAx1mEoB4AHH1/5F7uFHmOkzuTgHrsSMWNuQf9t9PyD73QDNOm9R9esMhYg/j/AFiP95t7eTJHVfE+ + fUZnIH0BI/P5t/r+1AAHDps8a9R5JCSLkj6cXP0vz9PdhlhXrXUmA2I5/PPP4t/T25IAEUj59eBz07RS + 2FuLcf8AGvbPVg1DXh04xTcXHvVAePV9Z9T05wuT+B/vj7o4AHXvEPr05Ix/qQ3144/Fvx7ZoD1sMTmv + U2MsQCSTwPqfdWA69qNePU1HUBbn+gPB90PT6sdPHqfE5F7fp5t/yL2mf4h9vT65Xrm0hA+gv+OPanSv + p1ug661Ws3+xP+xHv1B1sEjh135h/h/tj731vU3r1wMpJ/wuP98B7917U3r100x1AD6XFwDbi39D70RU + U62rHUM9YXnAuf8AEc/1t7b0OOB6Uax6j+XTRPKHFyRYH/Y/n28iE449JizV49Ncrgcgnlja3tWqAChH + W9TevXBJzqAuf999fp7ZmAFKfPr2pvXqWrsxUCwvz/Q2+v1v7Z6VjgepSccmx+v+P+wv72OrrkdZ1e6A + Hhr/ANP8P6j2xN/k6cTj1nV+ALXNv6L/AL2fbNBo6c8+sgNxyqk/4gE/7x7SSfF1YE6hnrvhiLqv9foP + 68/X2nlrox0sXh1lFjdfx/h/vHstkVlOpfLp9HOsajUVyPIjpurKKZquiy2LyVTgdx4pnfDbiogjVVAz + geSCaFxpqKWUjTU0k10kS49LAMEe6bVb7tbeHKoJ+YFenrYyw3fiRsVX5GnXPuXsnE7x6frcTv8AoIcL + uXbuSosnkaSgapixW4sCY3oNx5nYGYnsq1kNNKK1MbU2nDxeMCRSp9wPzhyduS7ZPtqRq6uCTUVqvlXG + cdSlypzULPmOyu1xKk0YDg0YCoFNXGh9Oi57Q6BxGKjhmxHyA2/v3+IzQJh9mYJpZdwZOqzNQkVFTUe3 + ZqVXoBH5DU1AlZViRXJ/HvEB+UXAe3lUfEysKYK1oFI9Plw6zeufcS1sme78Jndie78II8/t9SM16uS2 + btXC7G23i9oYKCODHYamSmDRgn76qt/lWSmc/rkncs7OebED8exzYWabdZR28IChRpouAAOAoPIenUL7 + tu1zvO5y7jPKH18ADUj7T/L8ulgp4Gm2pVsL/QcWt/yL289QNQpX5ivSBmZl0s7KPUVP8uiAfL/46/Iv + urc9LuDZnymXprqbau16YYzrvbmA3dQ7iy29/O8ua3HvHfu1auCpkoWiEUdNSwKq06CR31sRYX7JvfKm + wRiff9obcvlroPyBIGOiS7teat4b6XZdxW2/pFKEf5fLyHVW7fP35V/y7u1cRsH5XYjdXcfQOfoYshB2 + Bj8ZJvDfvXNI04ig3JI2Mhppd1bPnB1DKJTpkcfIGpq9CwR3P949v9r5i2z+untPLIwOZLOUntHnpXgD + 6fy6Ktv5qudm3Qcte48BBU/p3cf4j5am8x61PVs3xK+a/QHeO0cVQde7mXtSurqytrMtuHqbemz90xZO + pr6yarmzWW2pm6ikzdNMy6IvsZKUumhUVitvcZLLFaEQ7/Y3ltMcMwWqlq+ROSOh1cRS3Ya42a8tJo2B + PhsxDKKcCOA4Vx616Gr5Fwbn3V0wsnVeIy+7sRuerp0rK2gxtRFlKLC0E7LkqCrwrr5oq+Oqj+1raW3k + jKnUtiCS/nDbdyt9tWWyBdJVLLVQDQGmQPP7ej720vNoTmqOTe2EDw4ADdgPHUCTQZ4EdVadf9b7j7F7 + K/gOHkxdBUipqtk1iZA1QrsflMbRy7irZ6nF06GaKlpn8NLUVUoEaySBBdwyiMrDl/cLyzM1yoDBhin2 + 56nXe+dbHZZJZI6S1IOs5ag8qnPDo8XxXwWU2xhe1sRnYBS5jHdsZHDV0KMJIxU4zb1EryQSIACjatSM + ALg/g395r/d+sXsuRGRsVvJQfmAtQD60PD06wy+8FusO887pfwgBDBHQDhU/L16ND5DY2JP++/x9z7EA + Tn16g09Ad8kYqafoTtSarppaiLDbaG6PBTgmaebamSg3BDHGq/Ulqf2E/cbbn3vkPdtoiqGu7K5Q0/oI + 2PsIGR86dHvKl0LXmmyeTI8RetSj5kTSYz5I930zp42qt81ubWMm2mHclDBn6cL/AIeOpX3wq5OtJI9m + gSTEkepW9aqxH+b/ACddrdu3hLjly0lQ/wCgRr9ukef7eg9+IXy2zHxE+SOxu36aWWTbEdWNs9jYhDeP + M7Dz0gpszHJF9C9L6aqJvqHQEe5q5P3J9l3MXLE0k0qx+WoH/VXqH/cbboOZtknilo0sVGRjkjNKA+Q+ + zraO+a+4cRurM9dVm3K+DM4XcOzdq5TCV1HIJY63F7q3LDUY6picHlZI/UT/AFBvz7kX3ZuoreCe/ibs + Nq7AeQJUio8q9Rj7X2csOxXjtUVnCD5kU6r13c4m3ZueUHUHz2UUMBpDCGraG4X8fp94b7cQu0xBhUsi + Fflny9OujezKYtosj56F/wAHVYfzLEMu+9uwyr5CdqKHX+0FescR3b/Dm3PH1+oHvuP/AHW0cre2G+zG + qq+4KtOAoYTUfYSKkcCc9cj/AO8MdH92NoIAr+7iD86SMQP8v29Xe/yv/l3L3j1vL05vzIvWds9QYqjj + p8jVz+Ss311zCoo8bnPVYyVmMIWkrrclBHMw9R95ae4nKcmx3g3a3A8G6bKgUCGtPsAb/j3rXrBHZZ/q + ALSRqaBx9a56tFfnUbEA6iLi1x/Ue4/FNZCjGKdHxcFjGAO3z9eo49up8XWuvH6H/WPt3rXWKxH19uIS + ePWuuvbnSlPhHXfv3VuvA25/w9uR/F1Zeuam4B/3319v9MyE1p1y9+6a697917rIqm/I4t/gffuvdZPf + uvaSeHWULaxv/sOP6e/V63Rl9R+3rl9Pfqnr2pvXqRa309+61137905F8XXL8e2ZCQcdPt1722STx6r1 + lVgAdR/r/U/j37ra8R1yUauRz/vv8ffunus4+g/1h7917rkPfum3JBx173rqtT69cf7Q/wBf/ifbTE1p + 0+OA6zgkfQ2/1vdet9e9+691lUDT+b8/0t9ePeiOrq4Ap1z/AALCxsL/AOv/ALD37A49aZq9e/PursNO + D1TrvSL3sL/1sL+2dTevWuuQF+B7117rMAABwL29+69137917r30+nHujkgY62CRw66/II+o5B/IP9Qf + bVAfjFR1ss1OPUuGqeM2JLD6nUSfza3PtJPbq+UUD7B1eIk8fTp0SRHAKte/sta3dOPT3WUGxv8A776e + 2utdAF3g5Mm2LccZj8/7VS+xHsHCX/a/8/dBfmMmsP8At/8An3oC7kfng3vzb8ez9/hPQXOR1jMnIsb6 + fx+D/j/sfaV/h6113quykEjn6fS3Pv0fw063Xy6yEgAE8fS/+J/r7cb4j14mp64axewI5+n1vf8Arb3X + rXXDyXa35uQD+OPr7917rBIzGw1EWJv7eqnp1uo6i6mLC5v9L/7172uk1x16gPXTEBjf6C9uL/6/vagU + r1rSvp1gdv8AHj/W93oPPpt9AFAM9Ybp/h/T6H3YKATTpqvWOTgG45t/ZHHJ597AHVSadUB/8KLP+yMu + pRxb/Zh6L6f1/uFlPr7jL3VFNitv+ej/AKxt0NeQyDus3/NL/n9etNX/AK9+4H6lbr//1diH6fXke8v1 + cDqDAwPXtP8Are7aq+fV9J49cxx/X/E+7BPl17PWQTKvBN/8ePbDqQ3TiShcdZfMBZgbD6+91AFOlANR + XrOlQxtZj/xH+8e7AgjrYJHThHWhV0sTf6e6EeY6UrNQZ65GruePp7ZyevGXrl99b6Br/wCv7tp9eqm4 + 66WtYkFif9ifetPz68Jz1Mjqgwtc3/wPHvdacen0kDdSlmQAk2vb/Y/63v2odX1jrzVAIsCPqOPfq9eD + rXrwlU3HvdMY62ZR1i1KDyeL3uPbJjk416bJ65fdovpF+P8AiOPd0DDB6uK06xspkOof74H/AB936t12 + ykgjn/ff63vTcOvVHXBAV+v0tb6/09sgZ6bNa9Yp5EVSrcm3tSDTJ6rIwpQ9NEjAH0jj/H3fUDx6QNx6 + wWY/QX/2PuwpxHWs+XXFo2Iv9D/T3RhXrRY06jPGW/23tsinTcg1ig64rEy2v+kf630920VHTIi0mp6y + 3/I45+t/x7aeFWHDq5EZGR1LhmFgCT/r/wCw9kN1aEEkDojurarEqKdSxOicX+nssMDdFjQsMdZjMjgf + 77/H234L9MCE9YZFMqkRhWNrWP0960Mmem5rcqueoppph+qL/bWt/sPr70HFa16SaKZHWMoAbFbH/EW9 + uhx17v66Mf8Aj/tgP+K+7V9OqaR1iZEPDAMP8VBHP+v78VFc9NlFJqR0yVmNaQ60eNQL+lY7X/wuPaiO + bR2gdMOnoOmGWIoxVhcqbcX9qwaivTFc06xMtwAPx731vhx66ER/r791rUOsUqWHJv8A8b92U569UHh0 + 3tdrjTYE/W4P5/p7dZ6inXusMi2U8/04/wBj70oqevdNroSf6cfm/t7rXXHS350kfT/W/wB49vI6nt6t + 12UDLaw/P4HtSvDpl/i6bZktx/j/AMR70WI62FFK9RiD9GA/3g+/KxJz1TqNMoI+g49qUcAUPWx6dN0y + grwB/tvahOnE6YaqOxb/AHj3Y9LIm8umOVCGNh7qVr0vRgB1kjBAIP8Ah/h9PdutdcgLEm/1P+29uBCR + XqurqSlwOTc3/wAf+J9+MZ9eqmjGvDrlf3oxkda0j16wuQTx70KBqnq2jroKbXtce3PEHXtPXO7j8D/f + f7H37WOtgU67Ba/IFj+f6e2yatUdW64MUX/XH+PvRJ8+rohY9QpZSxtc29tnowjQKOsHvXTnXvfuvdcg + xH+P+v7917rMkhsBdf8AW/3n37r3WYMCPqAfz7917rL5CbEf8V/3n37r3WZH+hY/X/H/AB/p791sGnWT + ULgg/wCBHNjf37r3XLVYghh/jyP949+611yDX96oOr6iAOuaycf0sbfjj3UoD04GqK9c9Z/w/wB59thR + Ujq1euWtf8f94920Dr1eu9Z/BNve/DXpsuQadc1ksCDc+7KoXh1UuT1lEt+Bb+v0Pu3VKZr1yWQDUTe4 + /wBtcD37r2PPriZFa9ybH62v/sLe3B2mo6acKvDrGxtwPoR+frz7UA46a1nqLIOf+QfdlPcOtaz1mgJs + puef+K/X2pdQyLX59aJJ6dIzaxN/oD/sfbOgdaBoa9OkJBAt9D/X/b+237a9X1npyhckX4uBcW/xPtuT + 4R06tG49OsTLbk2P+8e2une0YHDqWsvFgTxb6XHurda+fWcSmy3ta4txz7pTq4YjHU9ZhYf1P+v9T7oY + 1Ofz6v4zgYp1z8tjZrf7Dj6e7nh1ZJXY566EpLW4tc2+v0/HvVenNZ64u/PP9Px/r+/dXU1FT1wD/wBf + 94/437915iQKjrpmsSQTb/ff09+r1UOSadRpHJBIN/p/xT3cUPV+mxySDyf98fbisV4de6hTH06f6av9 + f2+rFhU9bB6ixsUNwbn/AB/417amFadePU+NudRNrf04+vHtkig6dWU1o3DqUr3tY3HPP1Nx710qRgRj + qZGxN/px/wAU9p5uP5dXBocdZkJ/Vc3B+l+P9t7aqNHTwznqTGS3B/qPp/j7RyEFsdbHxDrk36rXI+v+ + vwbe22AK56Wr8PWWMWv9T9Pr7SMOrrkgdZiBoLfkA8fj629t6ADUE9K1OkUHXBoxV0s9BUaZaWupp6Sd + JUiePRUxNDrZWFvTquD9R7SzQiXxlbNUIz9nVraUwbjBcfwSK35gin+DozHx6zIz3UWzshVRU0G4cBS1 + myN0xRQwiaDPbPqWwdXDNUMomtJGkNSur9SSqQbe8GN0tRtG7XdldBqh2da/0yWH2j06yuS7kvLdJ4JK + xOoJHlqPx0/Py6HWkJVQv+x5+vHNj7J0cyJrf4qnHlTy69D4YJ0KFPmR5/b06xn6f7UBf/bX926fqwyp + IPqOuNbQ0eVoK7FZGL7jHZOhrcdkKb6CpochTtSVdOx+tmjdhx7qUjfEiB/trx/aOriRxkmv7K/y6Kbv + bZOxM1s7G9P/ACo66ye+dlbZmWHYXb2Gxdfk67C4mni+0xUmbrNrvHmMNlKSnEdNLkaAywVaRh54ddwV + 2x813nK194v1P0znFVB8I/avpT59b3jl+DmCxLWBW5t+Olz+qCcnS2AST6iv+DohfQP8rT4KdK/Nfa3z + b6u+XsUee29ity46m6w3LNt7bGMzuU3DimxMmQ3TkVx+Nq6t4IWJR5qRJHZUMjsQSRtvnPVvzZtbLuE9 + nO6fC6akZvmyZofKlfLoEbby5dbJMXs7e6iHoVDY+b1yK1pjAp6dLH5o9TfzP99d74zcX8vbs/b+H6Yy + OycbU7wotn7r2JXYPd2/Hkmpc3l9+01Rl6SsjmaEU0dLUwJ4pIgxktKtyo5U2fkubYpLjeryfxNWI4m1 + ArpyRxIz5fn1bfN13lLuAWlvHqUEa5loA1agcADUZweIp5HoCfj52J/Nu+IvbvW2F+aHWvWG/wD4gb/3 + Zt7rfIdjdKrga3cPSWc3dkf4dtncG8MTt2SSd8RPkZUpqyciXQ0nmkcXJ9kl7sHLrJPc8rzy+MiEhLgD + QVBGo4p3cKfn0bQ7xzDfE228eEdSkVjqM49Sf2+XVs2xYXp5eyshIV8mZ7h7DqowpDh4MflVwVPLqXgi + RKXUpBPH59z77U7d9FybBCTV5JHmenDUwoaDyWnAZ+3qL/cq8+r5hhgBGlIl1eupeAr5fPpeGo9F+Af9 + b/eLe5KUaeHQHLofPprydDBnMblMFUu8dNnsZkcHUPGqtIkGYo3x0rxKwILKJSVuLXHPu89sstrJ9T/Y + SKYzTiA+CB6EseqJK9vdJfw/HCVI9PzHn+3rTz/mHbVye1+wdmbvroJo13lsGmwGYkkn+7mj331NXS7B + 3bS19TENJqitPRVUifhZl98P9z5au+VueuZOULxdM+23kjrH+IwykMh+YK5BHEZ662e33MD7zyLY3ETK + T4YD44MAK0zgdVSbmygKSoWBV1KsDpIZNNipv+PYh2+2E8LKylXehUHiFGa/bXj0U71uDszLARUVp6E+ + YI8x/l6v7/lnd6Zrvrrvq3rvN5KbJ7h6OzqYmueqR5pI+uNsQS5fbYqCvCxmeoWliv8AVhwvF/aL3a3p + rL2+muZ2Bmnj8CIfMsoNRXPbU19c9I+UVSW2/d1rRRHOJpSf4uGD/Dnh6+fRkt8Ymrwe8dw42rSVX/id + XWQtKmn7imrqhqqnqIv6hg9v9ce4F2uaC62yFUb9SJVUD1C+o8/nw6zr2S/t7/aLZ7c6liUB6cQadVNf + LDJrkO2paVSPHicDjaMf6rWxaeUMb82Y6f8AD39Av925scuz/d0k3+UEDcL93x/CilEK+lSTXjXHXGv7 + +W9fvD30j2+AaobGySMH8WpmLOGPnSuMCnQY9Rdr7q6M7P2V23smd4dw7Ky0eQSmDEU+bxko+3zW369P + o0FdSs9O6ngEhvqoPvPfd7C33nbJtsulNZVGkeamlcYPnnrCVT4QEsNQ1eB9AaCv5dbmfWPZe1+4+udm + dqbKqlq9rb8wdNnMWbgy0ZnXTX4mrUE6KiiqBJSzJ+GT6c+8U7zb59puX2iUHVbkjOSa5Brj/Y4dDG2f + x4FYUqOP59Le3thKA0PHq5aMigrXrx459uda6xlg1rX9uR+fWj117c6fV1CgE9e0sfpa3+w/4r791VpK + Ht65FD/Ue3I/i68JW68txdT+Lf7zz7f6qzFjU9c/futde9+691I9+6912v6h/r+/dWVivDz6z/j37pSV + DLnrw9+6SP21p1mU3Fz/AF9+691yHujsVFR1eP4uuQ/3o+0+ssc9KG8vs67sTYD37qvWVYiTz9Lfj/jf + v3WxxHWZUCCwv/sfe+nuslvfumy5Bp119Pfutga8nr1/dWNOHW9A643tyfwb/wC8+2iamvVxgU6zAhhc + e9db65gX4Hv3Xusy3AA/3319+6qVBNesoC83JHtMzFuPWgKdeYWJHvXW+uPv3XuuQDfVfqPfuvdZVJI5 + +oNvfuvdd+6MxBoOvdde2yxPHrfXh9R7r17rnoP+H+8+7A062pK8OpCBorWNw1gQTf6m59tyIsuG6vHI + zHPThHODZWuW+l/9c8ey2W1CHs4dP46AfvA3fbP/AAXMf73S+zjYlK+LX+j/AM/dBbmXjD/t/wDn3oBl + HPJuD/h9B7Pn+E9Bfri1h+TcDi39PoB7SuagnqvXNOCoJH4/PN/dU+HreOsrm68EHkf717eemo9eFCc9 + YSfUF/H5t9efdOtde4uQL2+mki3H9QR7sq6j14dYmUWJBv8A7b/iPanrZGdXp1gCAH68/Uf7D3qmetJk + avXrFJe5vpBN73/x/p78BQU6t1HYi3PAH5AsT795g9JW4nrhdbf1P41C/tz59arinUWSS1xxb+v1/H+H + uw6o3p1WT/ND6D67+S3WXRnVnaO4N77Y2nke9TWVOW6+o8BX7kinpevcs0SU9NuR0pShIGos1/6ewB7i + bfLue12trEwUmfi1af2b+nQo5RvYtvvZ7qRSwEVKClfjX16q8/4ZI+COm/8Apz+YN/sPP/x6fSttfm8e + n/gX9Lf7G/uK/wCo+4f7/i/41/m6HH9b7H/fMn7V/wA/X//W2GFk5sL8/wCA95c06ggCvDqTH+b8fT/j + fvYJBr0pjOKHrnIq/g+3xIQM9eYenWPxA39R/H+PuhIfPWtCk1J67KkAAc2Fr/09s1AND1epGF68CR/U + c/42/wBj7cQgAnryufxdZ1N/z/vv9v7sSCvVw5Bz1nDFRe5N+PwfacDOOnhkZ65a2/r/ALwPbnVD17W3 + 9f8AeB7117rmk7Rm9/r/AL78e9MK9OI2nrkaiQn6j/be9060XJ6yxTHWGY/i3/FPfq0HTseTnqQ9TYcW + /wBjYe9KCx6vI1BjqP8AcSfg/wC+/wBh7VaB59JxKTivWaG8jEt/vj7YkULw6Vxy1FD06KSo5NhYf7Gw + 9p9Rrjp7V1wkmA+hA/239PbgUnPTbOAOoj1JPA5sf6+3Anr0wZCeobuXI1e3SgA6YMhJz1waO4ve1/x7 + Zxw69TrlGFXgn/e/fq04dbBoadY5Wt9P6+7AkjqjdRybAkc/77n3ok+fWqYJHWNG1mxBsf8AD/ivvYfp + nurnrtltcfT/AIp7cB6qwzjr0Q4B/wAef9v7RyrrJr054YK1689tRPN+P8faf6UEYHSCW2DcR1mBuBb6 + kD2XzRiM0PSKWDw+nCkB4JH++v7LLkaVpXotu2xQdOQFz9bf8a9l3SIAnh1wkhQ3VkRrg+oqSf8Ab392 + BzXqrRgcR1AkorG6SIB/SxH+2v7dWQ9NmIHOOm9l0kggXv8Ake1ClW4npOyGvWJrHiwt/rD340Bx02w8 + j0nchCAzEC3P1t7VxNUdIZRpavTKyMB/sf6j2/0yzVFOsdn/AMf9v79jqvXFluDq/wCR+9jHTigjj1FK + W/si3+sPd6g9X6jTBRY8D8W/HtxBnrXUR1BtYcH62+nvzMQevddNGoU8C9hz7qrENXr3URgy3/3i3tek + lRjr1AePUN0axJH1v/W/tSDUdUZgKr1GZWIsOP8AX49+JA6oFJ4dRmUcggE+6+IAevEEHPUCZR+APyf9 + 59rEavDra9MtUnHH4/4n2+elKGh6Yp0/3v8Ap710vjbHXC66f8b/AND9Le9dVLFeJ68FJ/wB/P8Axr2p + X4R1rxF9epKxEgEE/wC9/wC9+7dUaTPb1kMdkN1ANhzx/Tn2y7A4HWlkYt03ADUSb/0/3ge6UPSuo6kp + YqPr+fr/AK/vWeqksDQDrs2Hv2evAt6dYHltx78T04oJPUJ3JP1/HulejCJKCvWO3vXToIPDrr37rfXY + F/futEgdde/db697917rkGIFrD/be/de6ypJyfoB/ifr7917rKJB+f6XFvfuvdZL3tz9Pp7917rIGAXk + 3P8Axv8Ar7917rsSsP6f77/X9+691mWTmxP+9e/dWB7SOsitcnS3+8f4e6D4z+XTyCqA16yq4DC/++49 + 2p1TxB1lDC5sRc/Tke9jppj59dGVgbf8U9+ODTqmsdc9bDkkf7x73QnqruCOvGQ2PNxY/wBPftJ6b1Dr + je9v6W936qxJ4dc7W/I+h/3ke1A4dVPaM+XUd2F7/gD3dPiHTXiA9ejcBwfqOPof8fakjsHXvEHTpG5/ + qP8Aeb/63ts4FeveIOnKFrEX5sfx/vHthjWvz6cQ6qHpyhcKQQfxY8e22owpXq0ergenWNwVB/Njf8f4 + e2iKGnHpzqUhHHP4t/sePdT05H59TEP0P9Lf7x7r051I1AaT/Xkf8b9+69SuPXrkZObk6vr9Ba3vXT6x + FeLDrmDcA2PPvXV9PzHXB2IIsP8Ab39+6utAKE9cPKVFj/X88e98eqyMAOsbSA/kXIH09+p00rio6wsw + vyb8f097DUGentY6hTXP04PB5/1re96x1WvTfJdbK3J+tx9P959upIKUp17j1GX9f+xPvcmQD1Zepaf0 + I+vN/wAfT/D2wT5dWbAr1MQ6QORbj+v9ObW966firnqfFIALWP8AT/bD2nm4/l06ePUoEXY/65/2H09p + tDMooadKkYUC9ZFY24P1/wBb2neNozRjXp1fiHXMnUQF4IIPP9Pp+PdTwPS1Ph6mQ6bG/wCogjj6XP09 + pG6uvxDrIouGH+t/vB916V9ZAoFtIuRy2rkEW9Qt/j+PdFDFSGXJr+Y6al1mHQo7q1B8v8/TrtDtHC9H + biXKbsoclV9cdmVlNT7urMEj1GY2RuHC0X2uL3tQ41ATWQS0rfb5emUGR0jimiHkjIbGz30h2LYbix3f + cv0Yr4+EHwQjRUBLAZINRQDOM9T77TWW+c3bdc7ftZUy7erSsjVrIDUhUpXSccWx1Ypjdtfxnb+O3bsf + K4zf2z8vTrWYjcO2amKtp6ykdboTFGSyuvIlX6owKsAwI9xTc7LNIiXO2FbiGQYZPl8jnoRRbvDBcmzv + 4ntpPPX9v7fmDwI+deoSo6sFdSjr6XjkGiRGAsymNueP629h8NpkaK5Hgsvk2a/ZTo5EniGsA8Rf4gRT + +fUpBx/r3P8AxFvdj/Q7vs600mn4geueoKLsHZAyNIiSeNpFDAsit9Lkccgj25HHGIZY5IleKM0Ikyxr + 6EY/b1cSz/UsI3WIr/ACFP5f5+kZnNhbXy1dkGru6dqYT7hxJFtfd/V20ckaOCdddLSzZLXC9YLg/uat + TDiwI91S05JCyePdC1ZDpeHw17GIBoGC1IINa1PHy6sd55mVlEVqblG4SK70byrprQfZQDHn0iX+OfU8 + lRRZTM7Z6+zGdhnaY5vYOJzeysdXU0bh6JshjkmDnyAAyRLNJCT9CQSPaQ7JtMF9SyumZyNSUcohXz1a + qZr6eWOn03/d54ZLS4gESVGvUqswNMUOcU/n0st/b7x3W+2anP1cP3VdO0eF2tt6nVZq3dO5KtLYfb+L + pP8AdpZ1V5eNMUStI5AW/tfZW95u90tjYeJJM7BDR8BSe5qE1IXFSOkTSLBGXmbTBGdbEqorQGigihq3 + AeXr0Ee1sfPt/bmHxFVLFLXU1J5cnNHqaKbL18z5HKyxM3qKGolkCE86Qt+febWxbUdl2+22yKmtI+41 + FCaZp5/t6xr3m/j3Debq+B7XJ0DzA+dMfs6fvuW/qp/33+Ps8EEpFaU6KNZ9OuBlYsCCF5vfn6/1Gm3t + 8RloEtpcqsgcj1Azp+2v5U6eEy0cUPcoA+RHn1VV87viZt/t7Bbp2vnshHtjBdhbopN79cdmyxNJjepe + 9p8WuCyuI3egBEe3t108UKtPcLDVKdR1PGTzu+9/7ScwWXM8XvfyXB9WTGkO5W0YZpjHEGCTimNOmi5z + qWpBHHLP7v3ubZ2MJ5X3WQxMSxR2I0NqoAo89QpXOKH1p1q6dpfAn5pbH33N15mPjv2Dlc2KwU1Bktq4 + wZ7auXUvoirsduSmYU/gYestO0ZjX/OBfeK9pz5yjdW5vbncI7aVE7o5QUkQVrQpxqeApWvU+XFvul4y + xWaa21Fg4IKlDjyyM8QeBwc9bMf8r74DVvw+6Y3N2N2hFj5uy93rT5fd708v3NBQS0sYg2n13hK1QFqF + pZZWqcjVREpJOdKEogJhbnXmBucLq53ijQbNt8VYw4Ied601IBUHUWFK0oozwJ6XxTW9ncw7Dt0ga8u2 + CSgfhA7mr+QoPn8uhf7Y25gc1t7JZnOTwUNRgcdW5Zc/K4hFDFSxmonWsY/qgP6T/qSQV59xby5cXl/v + Nvt+2AvLetoiiAOrX5IPJmP9GvWQvLvM03KUX10rUsIADKxYZpxA9CPn1QNnup8x27tPePc+OE5zOY3H + ksjtzCgjxZbaWNP2V4Yn9YqJirT0zAgMo029Q9/WZ7H8uwe1ntNtHJMY1i3hiEhXCtMQrOwDUNKkjOeu + EnvT7wS83e928bg9TDNPIY3JUhYySFU08xitMdFB8jkn9QOpgwYFHUq2llYC2ll+hH4It+PeQnjmV3mY + guaaSOAxivn9v8uifxfEQSDvqBleBx8+rf8A+VN8uqXrPeknxu7Ayy0Wxey8wcj15k62QQ4/a/YlSmio + xFVUGwjps3pVUY2C1QX/AI68xPz1y808H74tqGWIESqAdUlTUFf9IK1DZNaDj0otbl4pBGDQPw+VPXrY + 8kJR3jKsjo7Iyta6lDZlYf1BFvcIh9UoK+fH5enQnVo9AXSdXr5f5+sRc/k/Xj8e3+vdeFvwQfbyrp61 + 17n/AA9361nrkrWbn88f7c+7KhbI62Pn1lJB/I/2493VdJr1TWB1xvyf8PbvVw1eu/furdc0+v8AsP8A + iffuvdZffuvddgkcA/W3v3Xus4+lvfun/GFKU68PqB/U/wC9+/dMP3k08+s6oQLXH19teKPTpzwz1y+h + 92I1rjqyoQa9drybf1PtrwitST06c06yqtwAfyQR/wARf23XNOq9S7C1h/T3vrYwa9dW97r05rHXMAn6 + fj3omnTZya9cSjf0/wB5Htpjnq6sAKdcPdeneuwpPIt7917rMqm4HH0A/wBt7917rOosLH+vv3XuuYUm + /wDgCf8Abe6Fwpp1qvXftjrXXNRc/wCA+vv3XusgVbjjm4/J90LAGnXuuzwbe9ax16nXr+/ax16nXXuj + Gpr1vrsKT711ZV1GnUpIgFuTe4/HvXTngmla9ZQAOB730y3Zx69711pO3j1xa5Xj6jn6n34hSOrsxJqO + gI7nLltt3Jsq5c/0uL01+PZjtqhddPOn+XoMcxOAYdX9L/n3oENX5Xm31/1rezFhVadBkzRjB6xl9X++ + /wBj7SuO3reteuy9yCvP0/w96QY68HVhXrMDcH8EcH24cmvVgRXPXD+0T/tveqdV1r14G9ze/wDvFv8A + D2+NKDrfiL1xYqAVHP492qKV694i9YWIAJ/wsCP969+GeqI6haHqJICeSSQeLf0976v4i9R+b2uRb6km + /wDrce9HIx0wTViesTB725Uf1/4p7cBHDqvUN7AHni5J/oPduqEU6Jf8ygJqXoBT9D3TUm/+t13luLew + tzYD9PaEf7//AOsb9G2ycbkf8L/5/XoO/sl0fj/i13/9WPYcqfTy6W0H8+v/19hQek8n/jXvMAAU6gsC + nDrk02j8k3/of+J90KgdXBp1xFQCbksOR7adqdWyTXrOJl/BP+PuqvXrR7es6tddX1/339fe2SpqOnoq + Hj12xFiRYf8AEe6ksMdXIUHh1FE2lgD+ffkY1z03qB49TxICAbnn/G3t7WlOnBwr12GJJ5Nv8T/xPvbU + YdvVQanrC0jXHJ/x/wBYG3u8cVBU9UZj1kQ6/wA82vz9fdmUDrasesmoj6/19pGfOOn1GOu1c3+v+392 + VdXW9VOsoc/6/wDjf/D2+qAdbBqOvaj7c8uvaR1LhnC8f776fT2xIKnqwOnrqSqYkhSwH4sbe/Rx462W + J4dRzK5+pv8A737eAAx1Ug+vXNLk3J/339PeiKDqoI65uygggDge2anzPVgBxHXrs49P/Ffeqr59eIJP + XGzDg3v/AK3vdV9OqEUPXXjufbUsuha9WVdR6zrThh9R/T6f8T7R/VM3Tvgjz6x/aADj/fH3ZZST14wr + 6dYTHyV0/wCx/wAP9b2qSSuOrLAp4jqZDRsQD/W344/2/tqV1r1oxAGnWOen0H9IIN+f+J97jJPn008Q + 49egjBYAgf717YukqhPSOeLUnDp4jiVCBYW/p7Ds6Fqk9EdxaEgnrM1PMeYgSp/r/X+nHtGKU4dFjpox + 11HGzsVe4I/23P8Ar+2mNOmdJPHqQaQgfg/iwv8A7f3XWOveEem6eiS/qUi97N+T+OR+PbqvjptkUcR0 + 3SUH10Nb/XF/969urJXpJImcdNVTSK3oksf8fof959vpIRw6TPDr6Z5sYp/zcoXm/qP+8ce1AmPSY25U + 9Qnx1YoNlDf4K4uf9YG3uyzoTxx1Xwxx6b5oJouJUZCbjmx/3r28siNwPWtJ6hOthYc/T/D8+3Bx611C + lTVYn/bnn/ePalBQdV6jEaSR/T/Ye22+I9b66sT9Bcf6xPuvXuokwIt9PqOQPxf2pgOade6xWDLY/wCP + +8+1ykU6bYHV1FkSxsOf9a/vfaetrgZ6isoB+n15Pv2lequanqDMoAIsP9t7ejNMdaHHpjnW4P8Are1Y + 4dPKemKUC/NveulqGo6w2HHA/wBsPe+rTcD1yCG/04/2H+w9qF+EdJ+s6MQdPFuP9fnj3vr3XqgkLz7S + 9ORca9Nwve4F+b/7z7VDh0/1IGq30P8Avv8AH3vrRkCmnXCU6R9b/wCw9syGnTiHVw6apne9xyP6fT/e + facnNOlqaQOsXlBtYfX6C/vQ6URNUUPXMt/UEf7f37ryEVp14utvr/vf9fe+rVIanXSuTyFv/iOfej1q + QgUr1zP4/wBb3sdbQ1HXXv3V+ve/de697914EHh12GI4/H9PfuvdZBJb+o/1v+K+/de65CT/ABP+xPv3 + XusgkP8Agf8AW9+691yDg/Xj/Y+/de6zo4Uf4/8AEe6gdxJ6sHIFOs/kDfi9j/Ujn3bqvXNJCDe3A/PB + /wB797HHqrEUp13qdrm1v9tz/j7uELGvTNQOPWW9z6zx/wAT/sPbrKFSg60xBFB1yvxwt155v/t/bXVO + u1N/xa1vz7917rzk8enixF/9j7UeXWn4H7P8nUZnFiBzcf737cjB1A+XSQdcY734/wBf/eePahmUKK9b + 6c4G4uQbj8/64+vtpmUqQOvHpzjl/wAPxf8AHtjp6NlAFT05xaBbn8/4/T8+0tT6dPKc56cIiPov0/33 + 9fftQ8+ragOp8QJA+v0I/wBueB70SD1dHXhXqSjlbgm30sLe9dPAg8OsyyX+rXAHA/x9+631lWQ/XTwf + 8b/7371QdX8RushlP0Fh/Tjmw97C9a1nrg8j2HP5/oPftPXtZ6wu91Go83/p/wAU97Aoc9aLE8esJINg + OTf3s0pjrQNDU9etzb8/09t06eDA8OsTkH/XBt+ffut9QJ/85z9ABf8A1vdlIBz1sdQwbMeOPrf26zAg + U6uvUjXcfgD2yerMKjrOlmIt/X/W59+6ejYCtenBCbA/n/jXPtPN/k6ePHqQJCbgN/vQ9trQKK9KEBwe + s6uVUD/C/wBP+Ke2J6s1Vzjp8fED12JWBBA/wvb2nPCnStHQilepcMn0ZjY3J/wFvp7SMDw6dUioPU+N + lf8ASQWNybX/ABc+6+dOlOtPXouvfXyu6U+OGOkfsLdMM+6KimNRhuvNu6ctvPLDT6NdChCUMRJGqetk + jUA3Ab2ebPyru29TB7cM0Y4kYA+2tOHy6SPej4VzT/J1WL1387u1/kl8h9t7UyNHitkdWT0G5nw2wcSE + rJ6ispcYamjyW4c/UL56qqSONwFi8UKEsFRvr7jr71nt/stv7KzbrIomubCZJNR+FUZgHP8AtTpDfMil + R1OH3aN43K092I7a1m8JLyF0cHgQik/4Kn8uroPh1W9k4bsTLU3Wm+8hsilTB1WczGJkpI87snP5CB1h + oRndqTPGLuZGV6qimgqLX/cJ4984eReYt6tLpv1SsYYHQcqYyBpKj0JqPI46zF92eXNhvNrim+nBmIYJ + ItBq4VoeOONDjq06j742+BDQ/ITr3+49SWNPH2NttKvcfWuQlYECo/jNEgyOILk38WVpRGh4+4cDUZ1j + 3XZt4BW/gCE/jxT148RwpwPWMs+w71t0KybXMZU/Ei5YeQBHn+X59C5D13gtxY2HM7F3bjsviqtA9JWQ + 1lNmsXOp5LRZLGMVcc24B/x91m5YhuaSbdIKccHpi35iubBvC3GElh6ih/Yf8nSa3Ds6XZmEzW69253b + eG2ltjGV24NyZ7IVs9LRYnBYambI5bI1jiM6I4YI3kcj8Cw9oJOSdwu5Ft0c6ppFwPPPy6cbm6xSKWdl + p2nPWjr8vvlv85+j+9euvmPF29v7L/HjfO/MFWdldL1UdJXbU2vtHJ7mlpqTbgxxp0lgo5MJ9o8Miusx + qL3cXYe56519iNnt+WreR7cJcyRamkI+OUAmn20oM9BDlf3N3Rd88KCZWtmNI19F9M0869bM/wAnP5i3 + xP8AiXsugbK70h7a7Iyu2MVk9rdR9a1tLXV8lLksbHXYabeW5gXo8XTyI8fkF3mYG8cZB1COfbz2U5n5 + 1uINotbYT62Kh2DLEhxRTJQANngPmCQR0Kd/56i255t3vpUiROIYirZpVUFSfkTjhgjHVcWM/mx/GsPg + Oxe1MpvjePb2T2/qqcTsTZtRWbC6ihyDl6jYezf4zPTXlWPQuQy7LJNVPqGtY9K+8teTPu73fKkbH/F5 + Z1qBMxJ08AY1ovmwI48Fr59Q/wAxe49/vmqG1jZYGAbTwrX4W+z/AAeg6Evbf83X4aZ2q+3yWd7H2cGU + s1duTr+rNCJG5KasJPVve44Pj/Psbye3PMkJM6xxTEilUOQPlWnQPhvljtQfCJcmp4VA8z9g6GrB/wAx + L4Ubg0pSfIfZ2PkOm38fgz+E4b/jotfSAi3+J49lM3IvNP8AoVvIf95/z9e/esPr/I/5uhi2r8n/AI17 + 4lam2h8gepM/UxsI2p4N5YyjmMn0CImVNOXP9NAN/wAeyuTYN8t6rNayArg9tcjHkT04L60bPiCv2H/N + 17sfv/457KwWRXtHt3qah2/XU8mPyWMzG5sPmBlKaojK1OLlweOapmm8qXCxmGxP5Bt73Hy7vt/EYbaz + aRWJDq6hUKkUOp2448gDTz49OLuCIVlguVUxnUqjUH1evDgaYz5HquDbP83H469L73g2DtuLfHcXQnjM + dBW5zb5p831pJrAp8ZsvN5iX7vL4QJ6YqTIRLPTWCRyyR2AxF94PuBX+9m45p5B26zLyktLZS/2mrj4k + BpQlm7ShIAGQep65Q957aVBt3MF1PZzEACda6GPAh6GuFAIYZxQ1HR+2/mG/Dvu7ZVXT4LO71zkUawSR + YzA7Tq2yOEyUUeumaSEEIhS+lvJ6DyNRPvCXmf7snvrfQR8t3HKN6HBKRaI4QqGmDXxdJUAfiIx8+pXs + PczkzlXcId2PMe3AxHU7TPN4jqcED9GmrPqMV6rJ763Tubu/HNsXGNUbI6sqKqN90STSod9b3x1PP5YM + PHFSExYyklsDMfI8hFwAOPeV/wBzj7iM3txvye5HvTClxuVsSbG3wY7SQ8JwBUFlqa16hP7w/wB9vlze + dsuuTPbFXuDItJJYq6Gbz06tJP7M9I+mxVLiqOjx+MpYKGgxsEFJQUdPHampKOnQRQQQxC3AVQv9fqfr + 76nqSy+CcKOB65ky3V1IZ471yHYgq5rVq5IBFfPqvH5S9MNtusl7L2vSBcFkZ/8Af2Y6nW8eFyNTJojy + 9PGgAFPUOVEp/wB1yG54a/sSbXuAUCOV88M+nl1M3t5zRFOU2y+kUaABVq58+iYuyyDQZHBjlV0eJ2jl + hnjYPFPDJHyrowDIym6kAjkD2cl1La2AZTgj7epQkt0kkZ4zwyo9etpn+Wp8va35IdU12zN+1/3nb3UF + NiMbnchKCs28tm1MRo9s7wdvo1TeFqTIHgtKqyW/cJ9whzhy4uyX5nhWsc5qT5Kxqafn5YxQ/Lo1sbti + RbSYahP5DqyFnRuf9b+v4N/YQ0r6dGdeuaOObc/T/D3vr3XLyf4f7z791rrwcE3PH0/3v2/Hw69Udcw6 + /wBfx/j7t0yfLrkrD+v1/wBf3YdOoPPrIDq+nPvRIHHq/WSMEtb82PvfW+s2lv6f7yPfuvdeUEkW/BF/ + fuvdZri9vyfeiQMnr3WVQByfrf3XWvr14EV6z+0/T+tfXriQb+31ZQoBPVwQR14XBB/4p78zKQRXr1es + wZuCq/QgfX2modf5da6k61+v0/w92603wnrsMD9D71qX16S1PWZWUfn/AF+CfdCa9Kl+EddmQf1H0/1I + /wCKe6Hj1YdRkKMSNX0t/h78SBxx0o6zaSF9P/Fb/wCPuutfXrXWZAP9j+P9t79rX169UdZACfoPe9S+ + vWtQ6zoAACRzz7Tuy6jnr3HrkQG+v4901L69e669Kj/e/ftS+vXusii/q/Frg/63ttiCajrfXWkkkgcE + n/e/devde0N/T/eR7917rvxn88H+lvfuvdZAoX6Nf/b/APFPfutEkcOs6Xt/hxb/AFre/dKEkxRuuXv3 + TMvcTTruw966Y1N16w9+69qboBO7TaTbIt9Vy/8AvdL7Mtv4P+X+XoM8xEkw1/pf8+9Abeyn/G3+9H2Y + 9BbDNny6xj6+0r/CenDw65L/AMSv+9+9R8OvJ8B6zr/b/PPuw6ebz/Lrr3cCpp011wT6f7H/AIj34Zx1 + 7rGfqf8AXP8Avfv1TSnXuo7sQPr+f+I/Ht5eHVF4dYGYm5P+vb8e99W6jkk83I/1v9e/v3Xuscp9N/8A + YfX+v597HHqo8x1EJIuP6/1N/wAe3B1VuiafMIaoPj+D/wA/pqvp/wCI8y3sL82f7jWf/Nc/9W36NNgN + WuSf99j/AI+vSM8a6Pz/AMWr/wCOPYb8vy/y9GVB/Pr/0Ng+VmALAXPHH095d6qCnUFFhTHUBnkJ5t9f + 8ffssemy/XLW39f969ugdN58uuSyMByT/vX5/qPbLoS1R09rp05U8tkswB/1z/xX344ND1dZSB10zOTx + 9P8Ab+9mlKdOBmPXIKeCQPbRwOtBu+nUhWAI/p+fbDhyO3paWUDrKXX8cf7Ae3IS4Hcf59NF08uuA/Vq + /qR/vHtYhqOmGyesiNY/g/1vyPez05H28eshkU/UD2zpoM9PeIvr17UoHGkm3A/P09uJ1osp4HrirsD9 + Pzxz/vY9udNlm1Y4dZtRvyPx+P8AH/X911KPPpwNpz139fp/xu/+w90Zq8Or6iw65aT/AEv7umBnqwIA + z17ST+PdmIGetihx1IWMqoNr+0fiqzEE9WZKfD1lRdZF149+d1/Ca9bQGuR04RxKLDSCDb8f7f3TUenw + o4065NR6jcJce7d3VvDHEjrCabQbhRb/AA59pJw5XrWgA468AQbaSP8Abe0q1ByOvU6yCIsL8jn6f8a9 + q0Fc9eGePXNKZSbkX/2A92ZX4p1cD06mxxixFv8AW/H+xt7ZIaueqEGvXGamVxa35v8A1/w/Pt1AQOt6 + a8eoy0JSxsRY/wBL+7MpKnz60Y18+s/jsDpY6vx+Of8AD2XvAa5HTbwxMCKA9cEM8ZN3JF/ofx7SSWms + dq0+zomu9vR8ovThG6t6msCf6f4D2VTW0ymlK9Ekm3TIcKT1J1L/AFHtL4Ug8j0wYJl4qR1DqUWS1mCl + bn/X/wAPbiq2nPTDxGlem4j3bI6ROmemesj5J/x/5F7URmuOk7Aqem76H2714Hrvg8/0966ZIpg9RKt4 + 1Q6wCbcal1f737cjUk46ZcLTpI1RQtdAAL/j/W9rlBAz0l8+mp4yxN7fX+p/HHt4cOtdcdBUG1uAfyff + uvdYdR/IsfdgCc9XDACnUWQayR/T/ff8T72jaDXqh6wMiqLlv949qfFPl16vUV5kX+hI/r/xX29HU5PV + WOKdQZJVJ/H+FtP9f6+3+mqdQJpBz7shFerBTx6aJj+f9f2tU+XTi9Msqhn/AN4/3n3vzr0pSTStKdeS + MfS31t9Rp/3r294q/PqtesoUA6f8bcf8b9tE1Nemzx6yhB/j/vHvR6svDqFULe/Nrf778e/dXDU4dRQv + 9AL/AOwHtSOHVtTevUxStrGxPN+P9j70xopPWsk56bqo3JsbWHA+nPtMSelkWF6bbsbiwI/N/bZ6Vrw6 + wGIp6hYAfj8e9dOKQOPXml8i8cfX6X9+HW0NDjrIuhksLXIt9Ob+/deZjrr1wR/H6GH1+hvb/ePfuvO2 + rz6yF1Ivf/ifex07CcU69qW31/3g+/dWLEN11rF/z731cmq165ag30/Hvw6qnXdvfurahWnXXv3W+ve/ + de697917rsEDm1/6c29+691ISUfQ8e/de6kLIBxf6/4G/v3XupSEH/WP5/3n34cemm+LrLe5AXkW/wB6 + 931U8+mWpXrzkqL/AONufe9VcV61jrFrb/jXv3XusiMTf8fT6XHv3Xuug5B5sfrwfagcOtScD9n+TrG3 + LfQC/wCB7fj+HpKOssSnVzxcf4f6/vUvAdePThHpBC88jk8fge2etdToiPx9ALe/de6dIv7P+x/4n2n6 + WdOMXpAYfU3/AN7t7ab4j1U8epqOwC2/Nv8AeT711tfi6y6rNcng/wDFfdh0rTh1kUqSxDH6Dj8Xt791 + brKjH6X/AB/jf6+/de6zAlioP4vyPr9PdtXXuuJBb6k/7f8A3j3sHp6NAwqeschH0F/r+f8AW96br0iB + RUDrF7r0zSuOuLNZhpP45P8Asf8AH3rj0qjjFOscrc8Hm9/yPeqdX0DqHLqIJ+vFv9h7902woadRfzb/ + AAHuy9XTz65pzzc8G1r8fT3o8enOsyfqH+Pv3XvPqdFJYEH2nm4/l0qPWYOLkA/X/Dnj/X9tj+z6Vx/C + Osvl+nLe2W+E9OdZkb6Fj9V/xPPtL+Lq0XxdZPIQfr6fz9fp+fbfGUDpWvDqVBUL5Es4UXQBySAGL/Vv + 9pt9f9h7ZZBrI4cc9XHHrUM7X23k8P3J23t7cmRq6ndeO7H3hT1uWzM0lRPmb5iWox8lRVzszkmneERE + kKE0gWHvI7a5bm3tIfDhCIY0qR59gz+fHoq/0Q/n/h6E/wCJdTPhvkt1QtXG1PLUZmtxqRPdG15LC1FK + rajww9R06eCPcPfebtYN09hOZZYvhitw3yqsiV/n1LXsbcmy91tmmH+i3Hg/k8Tg9bTPxT35sXYOc3bV + byzIwkmZxuMx2EqaijqJKTxU1bJU1b1FVCG8Qc6RZhyB7458q3u32YZtwNNUaKv2qzV/w9dA/cnZty3m + 1trXbYjJ4EkoankCiUr+derG8NvzYuZjE+G3ht3IpLFoMcGZo/I8co1FJaWVlYqR+GX6fUe5Ig3HbZkp + A5zw6gt+XN426oeCSM/xIKsKHFB5/wCo9M6dZbOjrZs1s6sy/XmaqtclTlust2VOzpMhK/LvW4jFOcdU + u3Hqmo2JtbV9fa2LdJLbNtKV+YJHSKS2D9u4o0v/ADWUV/mOkJ3f0du/u/p3fnTGW+TPdeEwm/cRHiqn + K09JsHM5OjMFdFkaYlcpjP8AKad5YUSso3dVqYGeFmCuT7FGw817ptF1FeITc+CQ2TXga+fRBd7Btu4r + Lb+EIqqeAp1rCfzEtvdqfF/ZHc/R3yH3v0l3ls3e3S2Yqdubv67xGY2R2Jht07imGL6y25vXryukq6OT + K5qsjvjP4VUBmCSTJCkCFjmDy57vT+4HKt8OYLD6e0CVW48hOmNI9AQPLqC915Es9r3K1jsZyLqVqRrX + iNVPX16Re0fgHitmdO9JUe+6Xd0vYG6MPS0+787UCWjpqLMU+00yLbVwUDL45DRM6+d2Z2kKcFVFveKv + Nn34Pcbk2wuI9mtYYLGydIVXSB4zBwTKT66QV9es0vbb7rHInN+72tlvl27301rNcSn8EPhqQEYf0mow + /Pqv7f20qvYW8M/tKtZ5Xwtc1MlU4RDU07oJqSbxqTyyH1W/Pvpf7Me4lh7re2G0c82n6LX8AZoFymtG + YSPX1DcM+fWFPulyNf8AtpzruHJtxOtwbedtLL5R6UZB+x+HTrsXqTsvs5aiTYuzcrn6Skm+3q8lEIab + FU8+kP8Abz11WyJrsQSiEkD6ge5MafwxTy6ifd+YNg2RA19KVfjjjX5fb5dC5H8NvkHJBrn2ngaf+kE+ + 7MK0rf19MTNp/wAQTf2wbuL59Bn/AF0OV6f2k37P9jpG7g+LXdGDHmr+tKiuihXU1Rh5cbm2iA4LoaZ2 + kv8A00i4+vtw7irjRqSgxwH8/n0ZWvPWx3tBDcgV9RkfI/P16ldSdJbR3rm5dvbw3VX9bbwErCh29lNs + /b5DMRqALU2TzGhJJhdv8nNmt6kvz7TSTzJV41Vx6gYr03vPM9zt9ubjb1Fwn8fofNfyFP29GVyHwl2y + KOpTG773BHkNDfbz1+MoJKLyD6CeKEK9r25V7j8D2jffZNQimDoPLQOJ+fy/y9A2290bhZQ9/a6lHCnE + H1/Z0VrcWzO2fjzuKmzJrK3b9SJQmJ3dgKiWTF1ixuLU1W6WF2+pp6xTe/Atf2ZxXEFzAUuJdUZwysgq + R6Vp69DmLduXucrYxX1u5DihWtKjjx/Kv5dG56r+bWKyC0uE7hoExNaAlMm8cHTM+Lne9hJm8VGWemLE + 3aWG6Dn0geyeewSJzKP7Py+zqPuYPbC6En1mw3H6fkj4nX5IPMDo6cOd29ksKNx47OYWv2+KdKmTN0Ff + BWYyKJjpDz1UJPiAJAbyAabgn/At0L69RU8G52M30t6tXOB69B/u7e+w8dRyY/cz1dXgMzjZPJkqbBZH + O7SrqKoUxTw1GaxUc9OjMLgrIQw4Yf193ht3EviKcf5uj3btp3ZLpL+DtntyCqj8dc0PVP8A2Vj9lYDe + +YxOwNxQ7k2oHSrxNegkWSlhq7yNiJfMkbyNSn9vyFfULck39iO3eRbZ2fyK0/n1khsV7ue4WS3e7R+F + MwFV+zqw/wDk/wCQr4Pl1kaOkMn2lf1DvZcrEHbwNTUc9LUUksiodOpJiAlwbFjbk+wzz+vibMLj0aP+ + Z6N7f/kpL9jf4OtnLzJ9RyDyD/gfcNno+Xh1zScXsLc/1v8A71711brMZD+LW/HvfWjw67V+Of8AePby + cOmz135F/wAf9492611zWUfT/bf8b92HHp5fh6yxzWNjb+v59ty/D1s9TFNjqH1I/r/X/H3YcOm9Z6yC + QHgk3PH1NvdunAaivXdyPoSPfut9ZVIJU3N7W/3j3R/hPWj1m9p+tdZPIv8Aj/vHv3XuuYNxf37pSnwj + rv37q3WVPof9f/iPfuqSMVWo65E8H3o8D00HYmlePXNLWJ/x9sdKPBHp1k9+63SmOve/de6xRqQST/QD + 8e6S8B0+epg+g/1h/vXtnrXXNP1D/Y/717917rMOPoT79XqukdZQQLC/PH1v+efbL/EerDA65e69b66N + zwBckj/e/fuvdSQjabW/Fvx7917rsIwFrf7yPfuvdclUG973Bt7917rJYH6ge/de68FH9B/th791VjQV + HXI/7b3rqock9de99OdcveumOve/de6AXuviTbRP+py/+903sy2/g/5f5egzzDxh/wBt/wA+9AZIwtex + 4v8A09mPQWTj1iB/P+H+9j2lf4T06eHXJfdU+Hq0Pn1xX+3/AFv7v04fPrIpspPP1/H193Boa9NdYC4B + /P8Atv8AivvXXuuLP/jYf7Y+7D4T17rA51EH/D+ntxPh60tKGvWPjVwB9D/vfu3XusPv3WuHWFudV/6+ + /DiOqtgg9RnUD/WN7+3eqGtMdE3+XSFl+PwH1/00VX0/8R3lv6ewpzaf8XtB/wAOP/VtujfYSzPcA/76 + /wCf16TX28vj+n/Lrv8An/lZ9hzUP5dGdDWvz6//0dgmSQqDc/71/sPeXOmo6gUnSteouskm5/rb/be6 + xtpz0x4mKnrFrJJF/wA+3HkIqR1TxSOHXYk5A5/HP9Pd1aoz1dWL9To3JsL/AF/r7bPShFI49TbkDji4 + 966erQY6jNMyMASSP+Ke9EV68KcT1PVlZQwH496WnDq5YHHXZPF7W4J+v9Pr7eRI2NKdb0EDryObA/4/ + 8T7UhEXgOtCo6yhwTYf0P9OfbUgA4dOI1cdYS3qH+I9+CBsnqrAA9ZoyL2I9+KhOHW1B6z2tySCB9AD7 + amaiVHTirVqHrkCGX/aiWFrfm/B/2PtECWyT0ooOHUqJAfwOfp/t/fi5U8etgDrKFt9b/m3/ABHvRuGH + A9X0KR17Taxtb24JXkUivWtKqes6EMNI+v8ATn2wEYGp6dUhj1JVNLAWt9Pbirnp3QOnWGLgcXte/H19 + qMdWFOHUkJf02t731enXF4eP999T7qQDx60RTqP4TySBYe2vDWvDqtM568EH9PboRRw6uFB65hf6C/8A + X3YDHXiAOHXK4U/Tn/iPdSlT1TTXqSihl1WHA/2PutAMdbA8uu9AcWH/ACL3ulB1YrivXvCLH/efz7ZK + gnqtAeopis3+BP8AxPvXhsOHVSoPXUgK/p44uePbTW6se4dUMaEcOsZka36vqB/Tj3sWUHEr0y1vE3Ed + RGkk5JvyB7Qy2sVcDpBNt8TcB1DM5Dckke00lmrA6cdE9ztVTVaDrp40mX6kH/Yf8T7LpImhah6Irm1a + I0PTZJEqtb/e/d1ao6LWqppSvWPSo/F/9ifdwtRWvTZq2emjIIXW4Nv8D/re3IzRqDpiQEcekpL/ALf1 + fX2u6S9R9IP497qevdY34vb8D/iPdxnrXUFoyTcE/wCwNh7f4DrXWO35/PtjrfUKo41f4f8AR3t9Mjr3 + TFOWufwP6/6/tYmOPXiMdQiSeSb+96j1unUaVif6/wDGvbig8etdRZASP+Ne1MTUND1U8emp1Gu5HIPH + tTx6uOvDUfp+PblI+nar1zVSSb8Hggnjn8+2zSuOmzx6zKrA2PN/zbj6cfT3rrwNOo00ZYn/AFz7uApx + 1YcesQiH4HNvxYe96yMde1nrp4wgvzc88kf63496LkjPTiGp6b5ELXPtvpZXSM9QmVl+i/1vwPr/AK/u + ukVqenlc0wesJ1k8fT/YW90NPLp0VIz1xCKhLHm4tYD/AHn37q3WEqVbUpaxNzf8D/D37r3WQr5ebAEc + X/Pv3XiKdYnjZQPr/sD78OnI2pw6zoYyo+n05459+60zHVXrGR45NRBt/gP+I9+8urayUpXrm0g4t+f9 + h72Otw8T1yDNb9JA+t/9hx791ao1de976dPCo65ED/eP+J966orGtD1x976c697917rkCR9D/j7917rP + E5Isf62FvfuvdT4jY3/w91PHpHJ8Z65u12AP9P8AifbicOtDrxYn+nu3WywXJ65l7gizci304/2/v2Ot + eKvr1wCsf8Lf149+x1rxVPn1nX1cDj8c/Tj6+3xwHSY8esmg/wCH+8+99a67VCCDx7917rPGXB+nF+Dz + 9PfuvdTEYta/4Nv95v7917qfCfUP+Df8R7Stw63FXHTnG5L2FgD/AF49t9Kep1wAOb2HNv8AAe/Dq6ef + XPWNIsPwPr/re99Oddq1yf6/X/Dj6e9jp1fh6kI7G304+v8AsffurdZvK39f979+6910ZGP5/wB9/sff + ut9cnItwR9fx72DTrXWP68e9kinW1+IdRJAA3F/9jx/vHtsdLE4ddNySffq9e1jqO4JBP4PH+8fn3vqw + NRXrBoP+H+8+/db67BEZBF9Vv8Lc+6P8PVW4dZFJNyfrx7ZPT8fn1nVzf8D/AH39Peh0+nn1n8rfT/Yf + Xjj3pvh6cp1zD/6r63/HPtg/Cenk+HrsObW44Fze9v6e0v4urq2k16x/cD/D/ff7H3ZRqYKfPpzxfl12 + k/kdYkAaR2VEjtd5Gb6BFH1/qf6e965jJ4MIqeveLTNP59a2v8wvMdXZ/wCTe48z1juCi3E9dh8VB2PP + jYfLiKPfmKU4ytpsZk19FWz08cRqni9Eci6AzG/ubeWJLqHZ9E9c04/Z0niTU5+ZPQJdW1FfKXroquqp + q/buToK3A5mll8GWw1dpZ4JsdXAM0bRlRo+o5II9scx21jPbSbbuQEtrdoFlhcfpSKRSg+dPixxp0zdb + hf7RuEO47e5tp4iGhmj/ALTWOII9FOAfTo/O3fmdvjZkOEot/bdpOwaSvytLhoMvQOmA3FFJVERQ1GTY + hqOfk3aTxxsbH6fX3hB7gfc35ImsNw5j5QuH21LGKS6W3ALxx6VLMwJ4BgPP8ussva/71PN1xu9ty/zl + ZR7jO5jiExbQ4LtpVn8jn/Z6sJpc/XtQUuTr+vuwMfR1sMU9NkYNtz5eiq4ZkDpUw12I1ho+f1fX8298 + uRzRyhfXM1qNyQXEZ7iZdJbS1MJ5/l5ddB5rS5tJWjvxF45jWRtMiv2tTStAOIJFelHtjd8E1WMjt+ur + XqsBlKGWqoqh8jjKmmrqR1r4qOrpKvxvGXQC2pbG/wBfYqg3T4Nxhk8WFKUINRg/z6Kntk3KJtouVUag + aHSK8DTNOr1dq7kx289t4PdeNmjqcfuDHUmUR0vdZ5I71NNK/wBdUUoaNwLEEe5wt7wbjbR3cZwD5dYi + XlhdbRfyWlwpBzx6pE+YP8qzujvfu0dy7T7E27mqrE9xzd77JpKnOLtDcuI33BjKPE7Xx2ZpM9jcrhsz + Fh0pAuG8hpYYQ37i6rschuW/dLlqx5XtOT+ZLRljR3Kyw/FLqpmTy86fkOoi3flHfZN9n3fZpAnix6an + NNI/COIP2Z6KB1n3H8sOwsv2H198lO2cj3HRdNdyjG9f7x3HgNtYLe+19w5PZNWd57MzeS2cgx2T+zq6 + GSSOsiJBiaMgBZLe8evvi7Fyry3yTZ32wW6xi4aFpADqaSKVlXU/oQzCny6yY+57uO73XO00N6aGOCSN + j/FoQkj+XVUPyG3ivYXYNbvKDBNhKOeWo27LYxCCsy+3JmpcnPSwxcRqWZWsfwb/AE99Gvuce2O6e0Ps + tYct7zL4stwXu0atQIrnTIijjSgPAdYyfeO9xtn9yPde/wBz2qPwn2tBastKFmUlS3zNV49GC+C/c1Pt + bc9d1NuGuFNgN91kdbtqonkCU+O3dFCIpaAliAq5CFdNz/uxV5595KXa62LDNOsJfdTliW+2qPerQEzK + wLgeSjiafYOrXqqjsXVhpZeGF7EEG1mH9fwfZZnrHoODIIZjSvTJLTWuQSGF+b/n88+/efTyuEbQvAYB + +zpKZzb+JzsK0+bxePy0aSLKi5CkgqmR0N0eKaZS8bA/Rla/+t73U0wejOG7ljTQpNKnzP8Ag6gVFKii + yppARFC3LABF0gA/4AAXtz7bkrQdPLdM5o3SWzeGx+axlbhs1QwZbE5COSGpx1bGstNMsyiMmRWvyPqr + fVSAR9PbWrT3+nS+C+lsnW7iJ1RkMKE8R1Tx3XsOk6v7By21cfVvV40wUuWxZlfyVFNQZIM8NFUSf2nj + IK6v7S2PsUW1wPp1r1k3y1vE+97ZHeyD+zHQfYTc+4tr1RrNsZzLbeqDpu+LrXpklVRbRPCv7cgIJusk + bKf6e7az8v2dGV7aWd6P8eQNX0Ar/g6VtB3F2Tia85PD7xyWCrZLtWT4URY5MnIf92ZOgpgKad/xraG9 + vdDHE51Oc9FZ5d2e5iW3htSVWtGrQn169unuPe28aYY/dVTt3MfceIR1C7PwSZed3OmNIcjj4hUGZmFh + ZmYn6Dn3SRra1QyytRT2/meHTtvy/YbZWe1QxuPIsTX+fV6v8pb4v706wx+9e+Ozdu1m1crvzD0G2Ouc + Fmo/ts7BtLzHJZncVdj2/dpVr5PDFTwz2kaNPIVHF465z3mKeKHZ7Y1SLuP2+Vej2xMtxKLmUU0gjhTj + 1cwJ1H9pbf70P6D2AujjrIs0ZNwfoR/T37r3XI1A554/2Hv3XuuYm4/V/vH/ABT24jADj1rrPHOzH1AW + INrfW/vztqFK9eGOs3kH9D7a6tXryy82X6/m9v8AjfvfWup6SMQLH8D+0f6e/VPXupKElefqP8b/AO8+ + 3k4deHHqQnIsPx9f9j7sWC8enesqA6h/sf8AevdHcFSK9e6kAXNvbHWuuagfQg/1va3+8+/de6yAAcD3 + 7pxZNIpTr1+bf4X9+6dVtQr123p+v+8e9E06uAWNB1kV1Y2AP+2HvWsHrfhkZ6ye7dV65BCeePfuvdc2 + +vtpuPT0fDroH/A8/wC8f6/tmXgOrHrOTwF+hIH1+n+x9s9a6zI4A/rz+Le/de6ym/4t/sffuvdcgjFb + 8fn+vv3Wjw6yILC3vZ6qvn1y9tv8PVq0z1KhB0/7b/eefbJOOtax1lt7br1vWOuXu44dNHJr173vr3Xv + fuvde9+691737r3XMJ/X/ePbfXuu9A/x/wB49+690AHeA0ybYsfquXv9P9VS+zTbfx/l/l6DPMXGH/bf + 8+9ARJ+n/Y+zPoLJx66X6D/W/wCI9p3/ALMnp08OuQ+v9P8AffT3RB21+fV4eB643sW/1zx/X+nu3VyC + SQOuYaykEf192+zpo46im97f1JI/PH9Pd1HdQ9NgnHz6xMbk/wCBPtzSB1frG7Ne2o2Ivb3YgKMdVJ0j + rGCSb3/Fvx78cdVLnrg1wODzY8/T8j3qo8x1XUT1Gdrekfn6m44/1/e1FTXqjsaV6jvqvyw/A/oPp7c6 + a1t69FJ+VMfmn+Pkf/f5qu3/AKLzLX9hLm7EFp/zW/6xv0e8vCslz/zS/wCf164fw/0fQ/8AFp/+OPYb + 14/L/L0caf8AD1//0tgppUcAFV/2PvLpM46gLUCtOo8mkAj0gkH/AH1/digUdNOaDHTXI5jfi/PJt7rh + hQ9ITL3U67jlBtckG/8AxPt4AAY6fjamR0+UwXTe17W9sMTXpYJD1JcgLf8A4n34CvT2rUvUPyaj9B9b + e6uoHWwMdOELDSL2H1/1re3EUU6sOPWfUAPrf/AW9vAU6tU9eUi+q4sSOL88e99a67+v0I/3v3ViOHVh + x65Ecc839+qB1dhjryH1AX4sfe6jj1qPj1IYWFzf21KAy06VKFBqOuAP0I9o9OnHTnWdJD/yI29tyISK + 9ernqVHJcG4ufx+T7YXjQ9Ojh1lX1n8j/b+1KCmR1oCpp1IhUK5PP9LW/r7cZqjPTka0PU2MFnPB5t/v + Xuq8enz07oFA/p/vHtUoFM9OIAOPWZCCfpbjn3onqxr1xcnVpFv9f3WtMnqrdeZfT/U2tx7pqBIp1T7O + o6pz/vQ/4n26M9WBIHXK1vxb/Ye99eNfPrzLcggA8e9deI9Os0YIU/0/3j/be9U6sB1yX6ni3vVPXrwz + 1mUX5v8A4fT3rSK163QddmMH/D/Ye9j59a0jrE0QvY2I91YDqpHUaZAt7cf63uoUHHVeBp011KFgLar8 + /S/PtuRQDjqjDPUERHm4uP6n6+66R1oopGeucaaDybf7Hj2hu7dXWvRLf2EcilvPrlJTxv8Artcjgj6f + 7H2RPGynoKXFkUJ6b5qXQCVa4N/ekY8Oi54wo6aZ4VdSG/H5+n09vgkZHSGUV6SFXD45dIFgGv8AUn2v + jbUvSIihp1Df6/7D/ifd+tdRpLg3H14/2H493Ukde6jt5GN7kcW/T7uXY9a64FABcqbD/X916903zre4 + /r/yP26nDrx6ZZk9RBvwfatTUdXXqGwsSPd+q9QZla/0/wBe30Ht1OHWuopH1HtwGhr1o9N8qXY8/wC8 + fT2sXPHrw66VADYcXI9vaB1uvWTSAwvyDf8A3ge2yKGnW+pJQH6ccf096691iaM/7H+o5/2/v3Xuo/iI + Nx/jce/de6jzg8e90J6ejPUMIx/3v/fX9ueF516deTUKU+XXGSD03/P+t7bZaY69E+dPTWw0k3vYfj8/ + X+vtojper0Gesf6uP+Kfj/X9+0U6trr142PFuPp+OPdadXDZ6jNqibi+k8nnj/YD37qxNePWVH1LZgef + p+SR9ffutdYCtpOCeT9D9QP6W9+62BXqQygjQRe4+v0/1/futdYPCwufwLab/wCH+Hv3VlbT1zWbULcX + HH5tce/dar3V64K3kf8AwvY/8T9fe69PCQaSOpGgAcX9+B6qjnVnrsfXn/D3vp5yRTrj791cZHXvfuvd + ZUNrc25N/wDbce9dNam6lJIwvY/S34H5+vu4UEVPTLZavUgNq5tz9P8AifdgAOHVCyrx65Ai/Iv/AL7/ + AA93UAnPTcjhloOsuoDhR/rc/wBf8Pd9C9M9ckub3B/w49+0L17rOLqpNiD/AIj8f7H3br3XFWYn/C4/ + H49+691IVdX5sPfuvdZ1tcKbaRx+P9hz7aZiCadaOBUdSET6WNhe/wDxu5961t15cjPU+ID/AFjwf9jb + n3UgHqw7eHU+McA/2v8Aefr/AE9tEUPT6mor1LRWIsDa45v/AMb9+8q9XBI4dZrAADUDwOP9h7pU66dP + Dh1wBIufp9f9t7c6dT4es6MdIN/r/rf19+6t1mV7kC3+x/2Hv3Xus17W0n8An88/n37r3XD37r3XrsLF + b35+gv8Ag/j37rYNDUdRm1O4vc2H9P8Ainv1OrCRxwPXH3Xp3rE4sLD+v/Ee/dPL8PWH3VyRSnW/MDri + NLGxXnkXufx/h7aLMcHp4IpXPXJL35va39PdOrgAcOuR97HTqefXa2vc/wC8/wBffqA4PTq5PXne30F/ + 8Rz+fbUgABp6dPAUGOunlCjgkX4/4n6+0JbSa8eqmtMdYA6lWcsI40V5ZJ3dY4YYolMks0skpCKiKCzs + xAA5JA59uK7N2xodRwD6Hy6bIcghePVJXzb+f9Vm6rL9NfHzcU1Pg4FrMTv3tfCuYptwysTBV7a2BkIi + DFQoA8VXlYiGqCSlOwj1M0j8ucsLHGL+9GqueNP8HT0ETHEueqosUMfHUUyV6zjHBkSeOgKLUeIXH7Ov + i4+vP+P9fY9jY/T+EuF8h/g6VOixxsyYI6MHtPbVTS+LPbEzVLlsbVhUqsXl08UlQIntLGlRDZYpo+Qr + OLX+v19lN3Ik48OajFeFQCB9gOAfnxPQY3K7iuP0brLITQg6SPT4acOhsoMNj5959VZjP0j5DaG3Owtu + ZzeeEaEVMtftqmropMrGtMLeVo0DEIP1XNufcZ+6VhzBvHtdzLsXKbFdyvduuYrYaioaQxMADQgGlcA1 + HR37aXu1bb7g7ddb4A9u8qB9XyNRniKHzB62VF7gxOHrshln3rsvIbD3BJtvE9Obaw+4ME2cz2Wy7LSx + YrD4ygfXHBpaNXatSMQvdXIAsfl5vPYL3I+lmXcNlmS528N9VIFYM/dSsbjOHocHNKGoND2Aj5y9tb+x + 22CxvooruZWE0pIOB8Ld3ofJR9uOgN+Qe3H2F2HjuxFiH90OyafH4PcsrSxVEGA3zim+0oKjIT0hMeiV + dVHJKp0qygk8e5e9kt6u/o5ORd6BF3U+Es3aWpUkNwIp5evQispo9wsjdQkNJaYLCo8SP8MoHlQcR+0d + GP8Ai13Om0cseut0VccG289Wl8PkJ2fw4LcNQ9jSzN9EgrCfqPSsli1g3vKDlLe2tZ/3VuLeHbvwNB+k + fSvE1+deow9zOVZNygO/7WPEePio4zDzb5U+VOrAN64rdGc2pn8Js3dp6+3TlMXPQYfe64Kk3JVbVkrY + vBLnMdg69hTT10EbNJRrUkwrKUeRXVSplOB1t5YriQ+JFQgfYT/l49Y8XKSXStFGpieM9uTg0yPn5jNe + qrfkd0N1t8Zupfjj1f1pQ5CLD4vsDd2Qr87ncnJl93b13lurb87Z/fO988wR6zKZCoJeeT0rHxHEqRoq + iLvf+/v995VuZpJNQjjUrUD4IcqnDyIBrxNM9Th9261s9m5ugZVKnxD4hqTUyKV9fMnh1rq5Drht4Y/u + /Z9BHG2b2v2xlspt9iVvNVVNOsr0zSsQFiqUugIYC+kn32A+79vj7z7L8o70ZC6z7bHUk1OtVCt/gpTg + PKnXOT7w5k5O+8JvSBfDjlncUAx3EEf4a16JvNDk8NXvT1UVdicrjqlHMc6PR11BVwy+aBwSAQ0bqGR1 + uLi4J9zariUU9eiL/E7/AFaqSo6EMmcqRQrjIqMVGRWo6u4+K/yPx/d214Ns7jyFLSdq7epRFlKWokWF + 92UNOgjj3JiEkt5ZSoAq4EuyuNQBDe2GiUGlOsWPcXku55a3Rb61j8W2nPagr+iPmeJp/SJ6FPuzsCm6 + i2BlN5y0KZGohyGExGLoJ3khhrMnnclHQ08M0kQ1ABWeQgC/pt7SFTXj0G+XdoG+boLaCSqxI7SLTjp+ + fEfl0s6ikZlRwCryQRTNGvq8ZeISOhIv9Lj/AGHvYwKdIDOIXKtwJIApwzg/n0nqinBLiwJHB5PpJ+g4 + 96YBuJ6VF44+wvqJzUAfsx0wVcLLFOy+CN44pGWSqutHCyj0S1T3ACA2LXYX+gIPPuhiUihyOjK1IaRQ + QzAngBk/Lqm75BptCj3VXvS73reyN/ZPIGp3Tn6OOmodp4cKviptv4emj1tK6AKpczFIxZblrn2thYhA + oOOsleRk3D90+HND9FEfwfE8gpxo1SK/Louk1XBAuuWWKMFio1uo1MPqqc8n/Ae3zN6LToaeKtv3MK9H + U+M3wT7w+SOWo5lwmT6463kT7rIdm7vw9VS440ijWKfbWLnMU+RqZQCIiiiFfrI9gLk+4b9Y7UDJdNrJ + 4IMU/Z69NiYTylogV1ehNP2dbAPx6+D3x1+OC0eV23tg7y39CqtP2Lv2Ogy+eSoC2aTC45UNHjVvfSKe + LyD/AI6H3G+5803+6KYUrHASDpoMkcDWlcfb0oi2+NWMktWJ9Scfz6OQ2UMhdi+t5CNbFyS5X0gt/Uj2 + Rh3klLsalgK/lw+zpcoCig4ddrWlvwPrb6E/8R7c6v1OjkLH62/r+P8AW9+6vQdSUvck3/w5Pv3VD1Pi + uQNV/r/Uj88/T3vr3UtCQAR9ef8Ae/eutEA8euZdiDz+D+B791rSB1ijd1c824B5A+v0/PvfVunaJvzc + XsPyPyPfuvdTEdgDzxb62Fvr7shOoL1ZQOPUlGNvSebC/wBPbj6aDV1frKpckXvbn8D+ntttFMcevY6m + gafpx+fbfWusofi55N/8PfuvdcxyLi9vfutddqBqF/8AH8+/dWDFeHXOTSRcWJuPofdX4Y6cSVg2T1wV + SPVe3+w/Htuh6WKwYdSE5vf3vU3XtC9Zh9B71rbpsgV699feiSePXgSOHXa3H0/3q/tqTgOrhiePWVtP + 1PPtrrdeuUek/wCAub3/ANb37rfUm4HJFx/sf+I9+691kVgQAAf+Kc/4+2mZg1B02xNadciQOL8/0911 + t69bTz65ILnnkfn34sSKHrUpKpUdS4yBccfgW9tEnpJrf16ye69e1v6/4P8AN1IW9hwbWH4492BPDpSc + RhvOnWJ/1H/Ye79NxksKnrj79051737r3XYYj6H37r3WW4/qP9v7b69137917ov3eX+c2v8A62Y/6Gpf + Zptv4/y/y9BnmLjD/tv+fegHktYDn+v09mXQWTj10v0H+sP969p3PYR04xoOvNwpN7f0/wBf36P4D1VW + IwOo7AtxyPyCP6Dg+7EgnqxJJp1yHAuGNuSQR+fzb3cKB3dUZj8PXRIJU3+t7D+vu34gevClQvp1hJvz + /Xn3fpzz6xl1sbC5P+8cWPu5HVG6w69N+Cbg/wDG/duq9YHf6H6fj6/1/wAffuvdYGtf/eT/ALH8A+/d + MuNb6eos1x+T9f8AW/rx79010Vv5KJ5cl8e1+pPclZ/vHXeW9hHm80t7Q/8ADj/1bfoQcvf2tx/zS/5/ + XpUfZjx/pH/Fp/8Ajn2GNZp+XRz3fz6//9O/aZiFJAII/J4/HvLpGWo6x4MsdO3pvMzm4a4t/ifz7fqD + 0yZPI9c47kktzx7RyE16LJfiqOsnF+Pr/X/jfvwd1GOrxzOuB1lWpkT03+n0+nt9RqFW6NYpNS1bj1mF + XK3BY293CgCg6UCUKKdSIyb3J/2/vRQEdKVbFT04ow08Am4/21/acNpNOt6j5dS7LoB/Nzf/AFh9Pdw3 + WwWPWPWoGkCxt9eLfX+vvwbp3PXNWJ+lv9h73U16rXOesuq4NiP9797Jrx6cDDz661Ec8f6/5/x96qQM + dW1IDUdchI17G1j/AK3ttmY4PWw4rRTXrtiv1Xn3pDTBp06ddMdcg54/2H0Pt/SrDhXprW4OepSSCw5/ + 1xb2mMQB6UKwIr1MibVax/P+t7cMaBa06sGJNOpsYck2va34/p/T21imOlcfDPThCrKbvYD/AGHva0HH + q549OYaK34P1/r7dDjpyo67DKtyP6e/HPDrdevNybj6/8V9+HoetcT1kUknS3H0/P4/PuukA9bA8+shj + /p/xT/e/dqdbx1x03NuP6e9+VetU65+MC3vWlj14g9cTx/vX/Ee95Az1YcOuwB/iL+9Hh1rhw65gWt/T + 3ocevfPrIpU/k/7D3vPVuuBt/vP9Pe8efTZ6jSrc3HtokBqDrVesPjW3qHtpgxOOtEHqI0YIPA5/4r7b + KsOqEEdNkqtqI+g5/H+PujgEdNMtcHriLnj8/T2jlgAFWHRddWsZUsR14pqUhrC//E/T2UzJpNV6Cl7b + AfAOmqaMqx/p7qrYoeiJ0INOmGuoxKCwYgj63W/+tyPaiOTQft6RyIeNOk1LHpZlPJW9j9Px7Wg1Fekx + x1Ccfn/Ye7r6de64AX4Hu3WuvMvFmHB9+69031EVr2/P+8D6j3dTTr3TTIgLXNx/vufbvWum6Y2T2r6t + 5dNxN73/AD72GI4de6iysL2H+xt7dUk560eoUqjVdvp/h7VxNXj1qoHHrgqr9Rz/AK/+HtVrXrWsdSNC + mxt/j+eL+2yamvW9Y6yELxb+g96r1ouKY66966b64lAfe+rBiOossd/xf3vPTgNeoZUKT9f9Y/T3sBzw + 6dBJ64yWN9Nrf7b37SSaHrww3TdLTFgTb/Yf8i96ZKdKVlzQ9QGj0i1rfj6c+6N6dKlYVx1HI1fTgf7D + /Ye6Hp5TXr3jFubEn/fW966v1hW4fR/vPHHv3z6cFNJPWV0BBuRq/F+PfuqBiOHWBGkB08X/AK/X/Ye/ + da6yCRi2g21f4D/ivv3W6DiOuzHpOvi454H+39+60OulRX9R4t/Tj/Y39+62RTrE4ZGNrFbcWN+ffuvV + zU9ZIl1Ak/1/H/G/fq9Ou/CnXLVyQATb+n/GvdunS1FB6xam16SCLn+v+H9PfuthxSvUkKR9WJ91r0m1 + /LqUhGpl/P8AxT26vDpppe4inUhQSLg25976Zc6zXh1n9uquk1r02ARxPXYtcc83HFv8f6+/F6GnVus4 + YKbn/iPevE+XXqdcjrYjjj/iPwffvE+XWjgV6yxxm5BNibfj+vv3ifLrwyK9SRGVFh6uf9b37xPl1unX + Lx3tzb6H6e6/E3XiMU6loPSv+At/vPu3h/PrSigp1NRfo1/68f7x7b6t1Mjfn6f2h+f9b22wz1cPQU6n + xkWuSBf+v+HvXlTq6vXrla7Xv+D/ALz7rp7tXSjVRR14gEH1WNj+CfdTJQ0p506eU4p12jWCrb/C/t7H + V+s8fJ/1r/7wbe9de6ze/de64t/Z/wCDD37r3XYfS4Fr82+v9R7914mgr1iKnWSD/sP9fn37HVlXV1xI + uC9/wDb/AGH9fbPiZpTpQq1NOojliSNPHFjzf6e/a/QdOgUFOugpIN+OR+PdGYnj1dU1Gvp14AD8C/8A + W3ttjTPTyigp16/+Huuv5dOKlRXriW/w90abSaU6cVKdcGkA4+p/p9PdVuKitOrDBr035LKY3EY3I5nM + 5PG4TD4iinyOUy2WrqfHYzHUNMuqprMhXVTLHFEgIJZmF/oLsQPdi4lXSmZDwX1HrXq48RjRFqOqx+4/ + 5p/T+0parC9P7fyPcmXjEkMm4p5qvafXtPMG0lqWrqoTksgq/qD09NFG30WQg39nlhy1NOomvGMI9KA5 + /Mjy6VQ200jaSKD16rK7r+cHyD78xNbt7ce6KPaew8i5iqNj7DopduYvIUxs60O4sk0klbkIzYFop51j + ewBjb6exzt+z7bAoFNZ8iRTP8+nZLdbeRatUk4BFK9FQsLhQqoAAqhUChVHAAA/A/A/Hs8BkiGhcr6dP + EgHuFPsz0JOwNiVu8KozOZaTA0UoSur1UM9RIjDVj6NBYl2H1ccKPrz7pJdiFKKtfz4dE+6bklkmlAHr + 6mn+fo5OHwVDjqGHHUFJHR0lMoihhhH6AjaiXf6sWJuxJuT+fZQ7tK5kOK+XQAurz6iUyldNfnXpW0lK + QSoQEOuhhb+yf6f059ttFFIVaQElGDAg0PzH2MMHovlYkA6jqVlZT6FTX+f8unmkomhmjqUeWGoQoyVU + bsk0LowYTRSDlCCLgrYg8jke0c22bNMmi6s4HShBHhLV6sGUMfPIA/OvT3773gXPix3MlQpVRqIANa1H + 7KdHu+G/yN2LvHJ7r+Efbiy/aZiner67yuWlikiqchmh97lNt4+oqWJ1vJJ91Qs7L+8ZPrf3yV+/t92e + baLmD3y9t7ZoQD/uwhgQKsVKEMjKa5Az2gAV4+fRH7rHu/fX+3/ubmK4Et5F2AOTSSHIEZ/LzFSeAFad + CxlcFuDqfcsfW29ppaugqJZItjbynLfa7ix8DWp8TXVTW0V1Oo0Iz28wUFbke8WORubIOf7IrBoW4Xud + C9DNT8UZIBp8gOs6ZIreFYry0YtbSgrSlTb4+Bx519SeHVifx2+R6OlD1/2PkG88fiodr7qq5ZAkqgkU + +Gzc8nGsAhYKhjYr6JLMAfc0cs80wgHb9wFFkxGxrgDHd/DQg/lnqC+f+Q5fF/fOyZDHUUVRT55BrmhP + Dzp0xfzChJDtXrDIxxRtNi94ir1TMPDHTa4oKidHjv6ljlJBBt+Pob+0fuhZTXnLw2vVp8VJtLL3Bwsb + HSOGCeJ8vTqvs/ciy3C7vZFJaGW11g4KKJV1EetFrXrXwn27uDC/JDt6CCjWTZmZo8Dk6nIeIQvFuCak + KUMcMakhxLDFPJPduAF+pNvfQL7jHOEG/wD3e9n2iVgJ7SS5iRQdX6cD9xJNKElx2+VME9Yc/wB4Lyyb + P3gu94p4Szi2mjxhhLEQCD8jGT86/Lpj716ej7K2tJW4mnRd7behkqsPU6USTJUkSFpMBVPYNIsg9dNc + 3SS301W95rWt0YiqEVz6+vWEvKfMr7TuIG5yEo5CAn8IJpUetONMfb1V/SVlfh66HIUdXXYjLYqpWaCs + pJ5MfkMVVU8mlpY6mFlkilRgQRcfQhv6ezZpFbFOp0a0sb22dLxFkRhqLEimj+Icc0zT+fRna35A9y9z + p1p1LvnI0mSoP9IO0Kv72XDSUe5M2afIxjHpmKoECdFVnZH8YLk6rn2nqK9AODlLlvY2v+YNiGtGt5AB + QAVIPmCf8HR1u4/klUP8lNi9PbN3HQ7f2ttvd9GvZu5GqqeKkr3p45J6zbz18xEcdNSoqJU6W/ckOm/p + t7af4sdRnynyQ9zyi++bhbPLcSK+mMAUABOltVak8fL8+hC7S+QvV+AoJoNv927AxuV9cmlcRX74JkN3 + jSKjw8kVnX/VSOQR7p4iowB4tgfb0G+VuTd/uoiZ9tJpIxJdioC+VMGvVTXZfcvZnZWXmwlXvvObvx9V + VCnwuKweMrMDSZgO37S02zceWqJWJICxsXbm4uPb0oeNNUwCr61zTrIjZOXdk2qBZrm3VJ0yK91DwrSm + ePRuei/5XfyE7Tio85v9KbozZsyQSJLuenSu3xkKOULIv8M2XBIGgLXBSSulisL3S/1I7zmCysxohIlb + 0rT/AAV6FKpLcfrWS1mX4XOAPsThw+fVyPR3wM+MvQj0mUxGy4t/b1pdEn9+OyUpNxZKGrC2NRh8O8f2 + NEB/ZWOJiOfWfYAv+atzvAVjPhfYa/5ulS2y1rIdXrX1/wCL6OHNWzSKoLFgiJHECQFiSP8ASkaoAAo+ + gUCw/wBb2Hnmkn7rs+I1ck4r+WenhHEo7VA64q8zC5Y/7f8A4r7dLEgL5Dh1apPHqfAGJW4/Aufr+L+9 + q2k16907Rx6SOf6H6f149vK2oV62D59OkfBJ/oR73071ORtQ+lrAe99Nnj04p+n/AFj/AMb97691mVgB + Y/7f/Y+/de6yX9Ooc/X/AHj3rrdMV6xqbsT/AIe99a6coPov+uP96Huyrq611PU8FP8AA8/6/wDh7cVA + rBq9OKMV6lILD6/Wx90myAAfX/J1Y9So1JA/p/X2wAa5PVScdSR7t14GvXfv3W+uaE3tfix9+691k9+6 + uqahWvXYBPA9+6t4Pz6yjhbH68+6M1DTpxFK8TjrtWK8Wve5+v8Are2+lOpes2pR+R7100aE9dgg/Tn3 + 7rXXi1vza/8Ar/8AEe6surrfXdz/AFJHvQiqaV62vHrLGbg/6/8AxHujpp6c6kqCPqb+2PE+XXqdZVa3 + 4+vttjU16ab4uvXuwP8Avv6e9deVtPUhDpvf8/8AEe9E9ec6108Osqm5uP63/wBsPdCemRFQg16yCQfk + W/3n36nSnR8+syMbi54/2A4tx79XqrZGnrt7auOb/wDIve9XTarpFB1xsf6H/bH3vV1br1j/AEP+2Pv2 + rr3XrH+h/wBsfftXXusgSxBv9D/T3Xr3XP37r3Re+9CRLtaxt6cyT/rA0v49mm2/j/L/AC9BnmIgGGv9 + L/n3oA3csLKbm/8AQD8f1Psy6CqkA565owIQfnSL/X/U/wBfadx2E9ONkVHXJgSP8P8AiLe/RAlDT16b + 6xMCQAPr/tvd9DdUbXmnWNmIX83vaw/N+PewrA9eFaZ49YWdRyQ3pv8AS3u4HDrerSeHWI/1+gP0/wBb + 25SoBHThcDJ4dcGYAH6j624493p1VpE4V6xaj/X6e99V8RPXrGzDm/J/1uL+/de8ResBY88cm9vpb/YD + 37pvUviavLqK5vxe5v8A77n37pokDj0EfYGExe4ewPjljMvTtVUb9uZF3hWaWAll66y9j5ISD/vPuOfc + y7ns9ntp7ZtLCelaA/6G3kehryJbwXm5TxTjUph4Vp+NfTPR1/8AQ7114/8AixS/8WS//F0yP1+6/wCW + nuG/6y71/v4f7wv+bqTP6v7R/vo/723+fr//1L9pgxS/Iv8A1t+PeWQOk9Y0sCpx03lGubk/n8f8T7tq + cdMu5p1yHA93GRU9JtRPXhcm1/6/717tQdOrwB6yArbn+n+PPt1Rjowhppr1jSQayLf73/X3fp8Vrnp3 + iNyOP9e4/NvbbNTHSpWqKV6nxqfp+n/ff4e0chYEkdK42Wmes5azW/H+x4uP8PbPiv0/qj6xMRf9X+3/ + ANv7Vx1IqeqMy16yI1hf6n/jX9fd9VOHVCR5dZEb6kW/p70GB6sBUV695OOf+I97JFOqnrrWW/te2tVD + npxKA46kRi/1B/1/bVfn0qUseswRb2t+P6f8T7UxsKUr03KvUlI1uLi3H19vUU56uoIXHUqOysBe/wDr + W/PH091cilOtqSD1OSUxn/X49s6R5dPq56nrUI9vobDn37RTj0+Hr1nEw/AA9+0Dp0UPDrKsl/yLf04/ + 4n3scKdODrMpDHn8fX/fD36jeXWqGuOpkag/X8Dj3anVupLKLcEX/wBf34g9b6xhRwSOeP8Ab+9dep1k + 0g8+7q5p07pGnrh4r3P/ABr3Vm8j031639OPeyOtddA24J/1j9Pdet9dgAfT3vr1a9eIH9PeiK9aIHXH + SLf8R+PbJB1U6b8+obk/j8j/AHv26AKZ62eox/1rD/Wt784FMdNHV59YniDfi/N/+R+0TL59eKjj1geA + ILgAcH8e9OmsU6Zlj8Qaem+UkLcA/X2mktQFqeia8s1WOpHWPT5Vs1r6fz/xr2TXEYjbt9egrdwhakDp + qmjKMQfp/vf+391U1HRS6A4PScyVOeGUD/YEf7zb2rhbND0XyLpPTCYj/Qf7EE+1ooOmuuBiIINv6/Tj + /e/fifTrfXEi55/F+PegevdRJl9JH9P96+vuynrXTNOtr/7A/wDEe3lNR1rpnmS4t+P9b2rVqjqw6gso + swsOL/j+nu3XusGhQLWN73/H9PbpYCg61x6iSot7Af7z7uj9aIr1iCKP9b26JT1rT1zHu4kr1rSOuwL/ + AE971daIA65aG/w/3n3vV1XrmI+OR/vYt/h7p4tevV6wOv49vKfPrYNOoUsVz9P+K+7hiOHTyt6dRmUD + +v8Avj733Majq4ya9dGxCgfW5v8Aj6/T3ohh8XWySOm6oh/w/wBf3QjpRHJUdNbgqbAWv/vh7qBnpYrY + x1j0sf6j/YH/AG/vTUGB06tTk9YpEIGtblh/Tgn3XpzUaU64JJc2e/A55/P9Offutdc5G0kMtrf4fi/v + 3W+uiPItwQX/AB9B/vXv3XsjrpH0HS45PF7/AI/PHv3XjTy66dSrApYg8mxuT/Tj37rxJPHrIjIQARz+ + b/48e/daOD1idSjaksV/PPP+HHv3WySePXaOUNyv6uRb8X/FvfutlqqB1ldNY1jhrfj68f4+/deDECnW + JJHuAwN/qQT+Pfuq9OMZBJNhduR/W3+v7dX4R0w3xHrNcj6E+99V6yKzX454/Pt7WvWuuYLX5A/1/wCn + ttjU1HW+pEdmsDza97i/+9+69e6kj6gf7D37rTCop1IA+lvrYD/Y+/daUEDPWdb2F/r791brKqg/Qm/+ + 8f4+7KQDU9aOB1KRQtri44P0v/r+7616rqHUqNSUtbm9+f6W9s6h1vUOpUSgck8jm1rgn8D3U5PVgaiv + UpQTyQALcfT8+9daJIIp1LBXR+L2/p/QfX3QkDpSlWHUc/Q/6x9sNk1Hr0rXB67WxAt9Ra/1+vu2tvXq + 9esiM17Accgnke3BItM9br1J1L/X/e/d1IYVHXuuwDYX+v8Ajz7tTr3WMA6xf63/ANf3VsAnrR4dZQvq + Jtwbe2NbevV0YA56wuVfgXA/1ivINvdeliqQa9YfG345H9Sfei6g0PVq9diM83AP+296qG4dOR+fXF1A + BuLfni1/bbsKU6eAJNB1EJUfk2v+b+2tY6eUECh66+lzcn/X59tsQTUdX6xEF2OkBi17A/m490P6aqG/ + Fwpnr1KY6oe/mj/IXL7h33F8b9vZPxbK2ZDi8v2PDSO6/wB49+TN99j8JldBAelwsBilFMLg1cjO1zEg + UbcvWQiiNzKgL6u044UH+Xo5soJFjJIHH16qfH1uLk2tf8+ngcnn/W9iVw0r63P5eXS5i6AaR59CBtXJ + Z7bWOnzcONiyu1cjWDGZimyFPDV4ioq4UEsVLVEBnp59DaoZGC6r+kvYgLYdKDUp7hw/zdFl9HHdnQrh + HOBU0yeFK9CxtjYGxN/yDNYaty2MoxOf4ntUtBJJjqq5Igp6trP4JBzG9ipF9JFre6y3U4z0Fb++vtiN + HGv7T/l8+jO4TCUeIo6bH46mjpaOli8EMMQKpGini97lnb6u5Nyfaernj59Ay8v5rly7edSflXpYU1Jc + gsDf8/kf4e98OkTTrxHTzBR6bHn8fT/X/FvewC3DpPLcqVwenuKi4H5uB9R9f6ix/r7sFZTUivyr/q4c + ei2SfB0kg/4P9Q6RWe6pxee3ViN6w0+Sqdx4amhSlp8Q8kVfNWUVatVRZTGLSSQyyVdPCsgp4UkBkcqo + P0BQb9Y/vfYLrZ7iFbmKZSDC9AkoKkEMWqBjGehVyvzbPsF4IopGiiahM61Lqa1HaO7j5+XHq7/AbgTs + bprH43t3A5HtbbWUoKNqLt7rqin3GDFHAFhq924GlQZjDZ2iZBTzxT08YEis9jyTwn93fuk81crc4Hm3 + 22XQg7lt3kFubYD/AEOPViatKDT11F9qvvH7SllBa8xy6ZVXRI4Uy29weGpnTEYPE1qa1oR0W9s/QbQy + UWAye66HdO3KrQMDvHmjyNPf0w4Te+LqFV4KuIekVgj0PazhW59ku02/OV80dlzVtNxt9xo1ODExilIJ + GpJgNNCADjzqOskLHmvlC5spL7btztpIGamlpVBavlECayL5VHA4OehV3vvLc29+u4Nj7gzUWYxGFo8p + NgZ8hMXqse9XReJKKTIltTU0bqjxaiSn9bWHsQC+3S5lisWidkjqsSuCNIY6XAr8R0kkUyekc1ny3tDS + 7xaTxRvNGyupYKlDkMzVoCOAr0S3uzsGr6/xHWOLo9g5Le2X7Neo3RvM7Igp8rkdpU/jXHYSHLzRLKUC + Uqy1k6M6H1qBY3HvO37mOx7N7U7de8hX0xFxErXZ1ggD6qSumMnD+WoL8Pn1gJ98K8vvew2HPO3MiWsJ + +jTU4jLC1T4mVsgFmfSTxHDj1Jp6fRp0tqtZhKABe9nDjSb/AEseTf30DCniormlRwqBXj9nXNSa5WMk + zjUEyp41zQfZn+Wegpl+NHVGX39H2BX4aomyklbFkavBh4htetyYcEZGsxRX903AZ47+Nm9TLcn3bxH9 + ej+15x3Y2H7pDfo8fEr3euinGnlXh1XhvI763X2L2z3Tip4dv4/rTd8SxZ6pkFEuKydDULjds4TCwMpE + ldpjWSOCNNCqCxt7sJB6dTRsl1t1vtNrslwxMl3H4jKqlgokFRVhgDI+zouNVWTVTVVXkJzWT1MstZkJ + 6hzPLNV1MpqamaokkJJdnYu7MfqSb29uL35H+x0L0hWyjitwh8OONU7XABAJNafnx6PH8Vv5fvc3yaWk + 3LHGnV/UfmtN2HuXHzrVZtA15ItkbcbxTZBtVx92+mmX8u9rey2936x2pWMvdIcKAK0PGvyFPPrazeIW + gsg0ajNSeJOKU8vWvWwb8f8A4fdB/GajifrraFPX7wKhMj2PuyKlzO9K9xGEaWirpU046O4JWCiWMC9i + x9x1f7/ue4SF2bTT4RXB+30x1eC2TMl13N5edejGytJI7s5Z5GYszsSzE83JY8k39kcihT45Y+JXh8/t + 6WKI1+A6B8h1HaHm4uf9t+fafV8j1frIIl+lv94Hvw8z17rMkHI4Nj/rf717Ugg8OtdOUMQAFh+PpYf0 + 97691OVTx6T9P6fm3Ht2NgBQ9bHU2MWPI+pH+8fX2705UdOMYUWNha39PfumiwB6mR/p/wBj7914MD1k + AJ9+6tQ9ZBHxckg/0uffur8B12FseL8g/wC9+99U6cYAbAf0sT/sBz7tGwPWuPDpwQAi/wCf6+9uzBqD + pxagUPUxB+mw/Av/AK3uhYtx631LQi1vzfge9daPDrmPfutAgdcveurddg2N/fuvdZhf8i3+xv7907Gw + GD59di5+l/8AeveiQMnp+hpXrN7aY1NR1o4U9e916Y8R/Xr3+x9+6bJavDrMosOf6+/dKIq6M9d2B+ov + 79051yFgR/QEe9jB691lBB/T/wAU90cauHW6nrI1zypNgOebe2KD0631xV+QLt9R/W3J9tMhLVHWqdS0 + K35+vFuPdCpXj1rrMBfge69e6zjgf04/4j34jrw49dLa4v8AT3XpR1nW9v8AXPH+sfp710weJ6zLHceo + 2N/999PfutdZPfuvde9+691737r3Xvfuvde9+690XvvUgSbYuVH7ebPLAfT7X+vsy24qNeogcOJA9fXo + Lcygkw0BPx8BX+HovupNN9aXvb9a/wBP9f2ZF0p8S/tH+foMaX/hP7D/AJuulmUEAvH9eDrX/ivth3Tw + z3L+0f5+nir6fhP7D/m6kiUWtrj5vzqX/ivu0Dx6D3Dj6j/P03oPmD+w9YmlANg8f0vw63HPA5Pt7XH/ + ABD9o/z9VKt5A/sPURphfhowLj6utyb8W59+1p/Ev7R/n69pf+E/sP8Am680kYFy6XOon1r79rT+IftH + +frRDDiD+w/5usBlWy+uLhb8MP8AeefbivHT4l/aP8/VSrmOpB/Yf83WNpQQTrTgX/Utr/7f3bWn8S/7 + 0P8AP0zpf+E/sP8Am6wGZf8AVx/8lL/xX3ovH/EP2j/P17S/8J/Yf83Udpl5s6cfnWvP+tz70GSvxD9o + /wA/XtL/AMJ/Yf8AN1jEmoj1cj6WIP8AsDb3bB4MD9hB/wAB69QjiCPtBHXT34v6bHn83A9+NfLplyCc + dBzua/8ApO+N/wDqT2zkyP63PXWXvf3GPup/yQrc/wDLx/1jbofe3X/JWn/5o/8AP69WH/7r/wDIH/8A + HXuCOpg6/9W/x1IXjnn6X95XBWGW6xsKuFqesDhwL6QP9v78DU9F7I1c9RLE/j2oDKMV6p1yEZ+v+BNv + 9ce7Bl6eBAp12q3I4Ptyop0qV1C065Kiqbn63t9PeiSfh6eUk9OMbDg3+n191II49LY1oQepZddN9Vj9 + ffiMcOlKj0668hPA54+v5/3n2m8LvqenQxAz1i9Rbkm3/G+T7VkAJRem2Y+nWQvpUC9/dFUmtevK1eu4 + 5vweL/6//E+6NFTPTgkYYPWRybXU8H3YcMdUYiteuEbHUB/j7bkVmFOtxvRq9OsbC1rXP190WOvHozV1 + p1nV/wDD/effmjI4de1K3WUycWF7/wCvb26rUwePVh1kiuCGJIP+3/1vd2GKnrwycdSi1xYn8/190Qit + Rnqxr1yjY/RW+p/r7fYg9aVvTpxiDGx/HF/969sFyMdKlrx6mWNhb3ZSKdOpUV6caZVv/sD/AF/4n3ut + OnajqVexI/H+8+3FwanrYPXMN9B7uSCOrUzXrMCBwQP9f/jfulB1WtOHXem4+gH+390NPLq/y6yAccf6 + 3vQB60VINOsZUWNvrb/H34ceq9RvGf6+9nrwr1zUEA/6/wDxHvwz1sddn8WP/I/bigAZ62eBA64E8EH/ + AHr3UgV61TA6jsoJ+v8AxPuv2dVx1jdFsLn3VuHWm+XXFVUf1P8Atr8e0zoxUjpsjHWCpW6aR/X3pEYd + br02OgCEN/rfT/Y+/SEaNLdJrmPxEI6ixqQSPZHdgdBC+g8MknqPVRC9/wDD/E+y5Xp0G5q1r0wV0ZMb + W5sDwFv7VRsK9IZlqK9JNgQxB/r7XggjHSM8euPvxanXuumICkkj6W9+VqmgB611Cbkn83/4p7cHDr3T + TUJY/Tgce3k6901yKDf/AAvb8/7D26poR1rqE6AjhR9DfgD2p6t1DaK3Jv8A7ce/VJ62QBw6juiE25/o + f8be7hwBTqvWIxqDwpP+39uA1FevdeEY/wBSf959+PTb+XWREHPp/P8AX3rpvrIFsbj6Wt/sb+/de68/ + C/7z/vHtxOtjqC/6v9b/AJH7VDA631wIuPdgadbBp1Dljufp/h9Ofe9RBx1fxCD1i8X5APHPvZYtx6t4 + mrj16SEleR+P6c/T/H3rq6PQ46ZainINwP6fj6e9U6WRyDz6b5Aw+n9fdDx6UhvTrFo/LHk/i4/2x91P + Hp8Upx6wSqFIIta/q/rb/G3vXTiZPWUFGAHBvb8fn37rRrXrDcwt+CGNh9f949+62TUdZGQyc2AP0B+h + 59+6r1wVxGdLAXP0N/r/AF49+62aeXXF0t+4oPJv/X37rXWRGQ/X68cG/v3WyKDrJoQ8/wC2/wAP9b37 + qvXvHz/tP9eP979+p16o69oX6/n+v/Ee/UPXqjrPGL2B+g4H+sB7dXh0w3xHrJp9QHNrfX3brXUmOxY/ + X6f8T/re9Z60SQKjrLYe/Z6pqb06kRJZuf8AeP8AW9+z17U3p1MEf0P+x+nv1er+VT1LVbD8/X37qjPQ + +XXNQLgH8/8AFPeuPTTy8PPqasQ+i2sf8Rf37qiyVNCOs6pYWIB/3n3qo6cqPXqbGAD/AIW906tQ9ZAA + WJJte35H4976dXh1nH0/23v3Xj8Q6kKg0X5/T/vf19tScOlMZoBTrGVXVpvwSB9f6+2ungzV6xOpRiFJ + Iv8Ajn/evfun+pkVgAbXsPx9Tzb37r3Wb688j/XHu6vpFOt164rqJ5/p/S3u3in063XrxjbVq/Fx+Df3 + oyEilOtp3MB1kABNjf8A3w9t9KvBHoOsZQH6D/bDn36tOPT3XIRG1xf8/wBP969sP8R6qePXAqV/2P8A + T3UMVGOnohWvUaXn/Yi3thmLNSh6UKKHPTfLxx9LH8/0+l/fqHp7rCZAgPF78ce9VHr17oHO/O68X8fu + oN59s5GGOqqdt0Cx7dxkzMFzG6slJ9lt2gsOSpnZZZlH+6439mG12/11zooSENMAkDrxI1BfM8PU/l59 + amub3Dl9057N7m3HXS5XcW4svkM5nsnKzu1flspVNWV1Qpa5CmR20L/ZFgOB7kmO2W2iVF4evlX06EER + 0pQ9P+x9rx7xzn8EasahaShqqmKoWIzaZYACoaIckG5vb3uRWRQ1DQnpHuV6bK2FyoqNQB/Yehaxuxt1 + da5CWpqcU289j5yBcVvXH4pS0lXg5iSXnx7XdaikdhUU1QgOl04tqI9uRvTJwPXoMT3u277E0iMYpowS + tTQahwrWnUzauOrOq+3KHD1c8tXgtypHRY/KFDHDlsJk31YWvdXAKywsVSZOCr3+gPv0roxopBwOBB6d + 3GSDmHYzLGRrtB3EEd1Bn7a9HcpqI6ijWOliNQWxexsD/sfr79Q04dRbK7Hy6foaVVtZbn6f1B92CSNk + Kf2HpI0yqKMR08U9GTYkDm3+tYe7opXiCPy6SvKDwz08U9ICfoQRx/h/sR7c6SO9Pn06wUjAqRwVIYMN + QKMv6WUqeCDYgj8gH8e99MmanED9vSgnyu/KKmzGT2duvM4Leb4upgw+ehy9fSzQ5EQFce9VNBIplVXs + AJCVH549oNw23bN7hm2zdFjutQNR4elo6jijkUqPKh6Vcv7vJy/usF5Zq0NupBKJIWSlfNWof5dGZ+OP + y77Cz2xINr/JjZOyty9i4zDHRuLPUG3vs8pjI3+1p6ndz5qhk0SwHQaiox0shfUA4Unjn/7ye0nu7yxz + PDf+1u7+LsrqXltru3MzwIPiZHAbAIYhBk4x1nfyX7h+zPNFi68zwy21yHUNLbTLG87UFEERYaKig1Cq + jiTXo4Of29lqLY0Of291X0Pu7dmQnSbHwYPZdLBtufAxUP39Y2KzVdVstdOIzpMogjiDDSVNveL3Mn3n + eUeVwmy3yDcdxjZwLxbZrdBIAa6o5VQjTkAkUNOp55d9lX5l3ZrxLlth2hggWKWc3dy8bEGuqMutWPzw + Oirbv3HvjdHX2Ynzm3Ito4rEdh0+Ize0P7r4/Z+Or9v5KBJsHVVlLgFhasSCpAjb954ZBfyqQQPZ/wDd + 59+Z+Z/vLbRY75uS7nsu7W0kYidBG8d0i6ou6vBWBAU/FUU6Y+8j7G7Ryv7A7q2ywMm67a/1CzK5lMlt + UCRqIWVQVYE1IKhST0EK05ld5CF/cdmICCMAs2oqsYA0gf6kDge+zKoksa3EkvhoWcqi5NalQGAyK/Mc + OuMgl/xVrd8lQgr641cfPPTpBTFNDW5X/DgH6gkD8g/T36h9OkgnMYoOiP8Azc2d/Aul6Cr2pio8dgF7 + Kfc2+jSRBBLWZmkkhhzOS08spqyBrb9JKjgWv6h6ln2t3j6nmeQbiwIeARRBiBRgoHbXzx5dDz8CP5Z2 + MyWNwfe/yZwv3NJkY6TO9edO1gK0tRSSRibG7p7FRSfKkoKyUWJPp0lZJz9E9hjet++kJtbcgmlSR5E8 + R/nPlw48JwiMkrVY/wBn2H/a+v7er0JjHHFHDDFDTQQRxw09NTQxU1LTQRJ44oKWlgCpFGosFRFAAHAH + sAObiRzPO+oNgAmpH+Xh69G48MKNHHps5Y3uTz/sPelI1DPW+ugACbgXNzza/wDsPbUxB4evWj1m8R/r + /vH/ABv3XQPXp6vXvF+Of+I91IoadeqOpUUV73/H4AuOfd0oOvVHU2KP/A/65HB/2/u9QetVHU1EHFxc + c3P+w/r731vrOqC4sOLj6f0938RuvV6mqoFrf4WHvetumzx6kj9I4twPd1NePXlw3WZFFgb8/wDFD7v0 + oBx1m0k/63+w9+62SKdcwg/AJ/3m3vfVOpUHP+2PukXHPr1tePTgq2Fhf24/xdX6lIbW/wBYA390691J + Xkgjkf1H09+60eHWT3vqlD1yBvwOT/hz71051kCg2uTf+n5/23v3XuswBuLg290ZqcOrKO4dZB/QD3Qs + SKHpZwTPr137r02xGk9e961L6j9o6Tde9+1L6j9o691mUki597GeGen4/h65e90PTlQOPXveutVHr1zQ + kG34/Pv3Wxnh1lDEAjjn2xQjj1ah65KFsCbX/wBf/H3rr3WZTyLc8j3VlByetdSkJ1Dj+v8AvXttlQCo + PWjQCvWY/Q/6x9tVHWgy149c4x6QfyQL+69P6l9eso4sf9b3rpkkVOes4N7f1t9PeutVHr13731sZ4de + 9+63Q+nXvfuvUPp1737r1D6de9+69Q+nUSp2ptbc+g7k29iM8aLUKM5SkSqNKKi33Ag1fp16E1f10j+n + uMfcWuqz/wCbv/WPo/2MYlqP4f8An7qL/oq6w/597tL/AM9EX/FfcZ59T+09H1B6D9nXv9FXWH/Pvdpf + +eiL/ivv2fU/tPW6D0H7Ovf6KusP+fe7S/8APRF/xX37Pqf2nrVB6D9nXv8ARV1h/wA+92l/56Iv+K+/ + Z9T+09eoPQfs69/oq6w/597tL/z0Rf8AFffs+p/aevUHoP2de/0VdYf8+92l/wCeiL/ivv2fU/tPXqD0 + H7Ovf6KusP8An3u0v/PRF/xX37Pqf2nr1B6D9nXv9FXWH/Pvdpf+eiL/AIr79n1P7T16g9B+zr3+irrD + /n3u0v8Az0Rf8V9+z6n9p69Qeg/Z17/RV1f/AM+92j/56If+K+/Z9T+09boPQfs6KZ3zt7b+2N64Wk25 + hMbg6Sq2iaqppsXTLSwz1K5yaETyon1fQAt/6D3K3tP/AMlG+z/oKf8AVzqPPcWn0Np/zVf/AI50Cxdj + 6RYW5/2/+HucM+nUSuPPoPtzG/Zvxv8Apf8A0s5In+v/ADLrL+4x91f+SDbf89H/AFjboee3Vf3vP/zR + /wCf16sO/wB1/wDkD/8Ajr3A/Uw9f//Wv68oa4H/ABX3l5Jo05HWPEzIE689yPUeLH2jBUHHRQzgmnUP + yIl+GP8AsPeijMajpKXUddieOx/x/wCR+9+G4PWyTXHXHyKx49qFwM9PK3r1mazqCo97QnV0rgapPXJS + VP1HtxqHoxRupAJYaRwf6+6gjT0picVz1IRWQAsfr/ibnn2y4J4dOEitesbSANYX/wBe31/1/b0Yopr0 + 2xqeuRVmAY8j3ZWFetjA65roH5/29vdJatw9Om9RJwespcEMAbn8f61re9Kp0ivV/wAPXGJSGv8A7H/e + fe2IUZ6tEvr04LKBwf8Ab+6eMnmOlNeuf3Cj68i/++491Mit8PV1YDrMkl7EW/3n/W9ugKe6nTqvjqbH + 9Ryb/m59+kIK0HV0YV6kSfp9sRinTr9cYgb3H9R/t/brOFGeqqpJqOniJ1RQGPJ/4rf2zUMajpUG0ih6 + kLMt/wAn/X+nuytkDp9SKVPThBJax/2Ngfdjx62DU46laww1AG1/d8kdXBr1mjALW/P9fewSMdXr1mZS + P8bH+nu6EUz17HWYDgD/AA9tmletjiOu/pf36uKdPsK5HXrH3ZUU9VKAceuJQ/4e7EBePVCR5ddaf9b2 + 2CB1rUOuFubH3sk0qOtUr1jZLng+9A461Q1p1iK2+vu2nFT1Zo6Cp6xOAw/x91p00SD1j0H37qvXpFLK + OOR/j/h9fdajqxI49N8kVwxtf6c/j2kkBdtI6ZfI6biuhuf6/j/X9obq3rHjj0S7hamRKgdZQEcEMoYf + Tmx9h+RGjbPQMuIGjah6b6qjiIJGoX4sLAe9xua9F8sY6S9Ti4nYlXdOT9F139rFkxTpG0JJwK9RGxBt + dZjx9dcRH+tbn24s+k0Hn1QxFeI6Y54irMhOqx/A/wCKe1inUK9MHj1FC21D+v8At/p7tWnXuoFSmoj/ + AGx/2F7e3Y+tHqDJEAD/AK1v94/x92LUNOvdN7xW/Asfrx/vXt7xG69XqHJEPob/ANQAR7cRtQqet1rx + 6gGMA83/AN493691yVOOBfn829uKwAoetdc/Ff8AFv8AWsPdqg8Om38uuvHp/LC/+I/4j37pvrrQD9Sf + 9v7917rjKtwf9Y+7px62OoLgAm4Bt/h7U8T1vrB7v17rE6/Sw/H4/wCNe/de66VCRzwb/T37r3WRluPe + wetg06gzwXufe+n43oemOogtcj3UjpdG4Oem1kOo/wCt/T/Ye9Dh0+DXrgxUemx/x/1/p7oelCkEY6ig + CNjqvYni5sb/ANLe9dWxTrPbyKeb2PH0/wB79+68MdYld14YNwbf14H9ffuvceuekS88XA+o+vv3XusY + Z0bSb2uAt+f9jx7914565SLqIZLgj8fi5+nv3XuskIP0JP0DG/8AXgEWPuycem3GK9SCt1IHH+w/ofez + x6Y1UNOulT8/W4+lvd+rdSo4xa/0IBP++Hv1eqF6GnXZ9ux8D1UmuesyarW0nj/iv9PbvWiwXJ6yqhb8 + 2/wtz9L+6t8J6r4w6nRJcEG62I+o+t/abrXjj16mqoK/Sx+n5Pv3TRlavWZP1D/Y/wC9e/dUZixqesoQ + FltYWufp/sPd14HrQ6mImkKb/wC8f19tN17rOgJYWF/+Re69e6kp+kf7H/e/e+jPrKEuAb/X/D37r3Uh + ELKbX4sPpf37qp+IdS4xYWIJFrfT/H68+25OHTwbSoPXTQg+oDgEH6X+ntnpVHJUdcWReLKT9f8Afce/ + U6c1dZYo2H4/3xN/furdZdDf0/3ke/de6yshYWsRz/Q+/de65FTYf1N+Lf09+6vH/aD7eseg6tVj/rWP + 9Le99GHWZY1B/H0/pb/evbcnw9aPWQIpIFvqf8fbHWusLRC97Xvf6X49+6cjcLWvUeaHi4Um9uP9f/W9 + +6dEgY0r1FahaU/o+otc3978un04deGKVfqAoP8Aa8ZIH9LgEn2z4Z9B1fHVE/8ANq7ZGR3jsfoDFVyv + RbNohvveccLlkbcubBg27jZLW5p6MSVBRuVMg4BvcfcsWhtrCS4OPE7unrSH6mf6kf6D29U/LDoPDLbm + /Fj9OLD/AB+nsTWkuqNoCUjUAuWfCj5fbjo2vlePw76HudjpCeZr5/zp1Yn8Xvgn8xd71mN7K2x8cuz6 + /Ys2NrTTZ6XAT0EeRhrKa9LU4ylyBimqI5OLPGtv6+4j3L3e5E2u8e3v7uRpEbRWMF4x+zA6Od25E5j3 + Xb4hZqqSNRzHIwTtocivE5FB6HowG6epuxet6hqPfnXW9tlzxK5cbj2xmMdFpibRI61MkXiZA3GoPpP9 + fZ7tXuNyduqqLTdI6uQBG6gMxP4c8Cfn1EO7cic5bNNrudvZkGS6sWQD1NOI9eg7zOyNu7rrtr5XIyK9 + VtTJHK0TQ+F/uF8elqKrI4EWsJLYcXHsbR3do0Pj28sf5GP/ADdBq1ud12mKa0NtTxfk/wDn6EWnajuS + 9TTq1tUgZgmgv6hc3tz+Le6fvHbfxXVuD51mXj8xXj0VGx3iYEeDcflE1Pyxw9Pl090xo3Fo6imOkrrI + mT06jxxe/uv7y2kv4a3sWv8AhWYU+R4+fTLbdviOYWtJWQZ1NEa54jh5dKGCkBAAF7Hm1iL3uLW/Fva1 + TXuBBB4ENq6Ip7h45TDICpXyK6f8menqno/0+n6j/iPdumGuQRSvTxDSWAGj8j6e/dI5JNR6c4KT/aP8 + fp/j/X37yoemHfzOT0/UyVEcLQLPOtPKQ0kGt/AwHIDRAgEXHIPB44v7dRmdGVQNKYYNgN8ukbN4yO8b + +C8Rw68cZ49CFsHfO+Otnm/uVuGXG4+q8n3m28hTpmNq13mQxzGbC1Z0wMysVMtG0MlvqxPvGv3c+6h7 + We7to17ue2LY3RBQXUVNJ1HUTIo+Jq8CeAx1PPtp9533D9uRFbi/N/YhgzQy5kquAImPwpQZA4tnoat0 + 98x7/wBj7k2hvDYNRjKnOUQp1zG0q6nyuOhlp4UWikgw2YMNXCEkigkLJUykerTe/vAncv7v73W9uubr + Dm720vbe+isLiKePAVzoaukCtamnWbm1/fP9qeeuXrnlvm+Ofbo7y3lhmJNahxQiooNJrQjzoOgIx9LL + JBTyVEYWoaJDULfUEmI/dUMPr6r++xG3XNzdWFpdX9uILt4U8VEH+iaQJCf5k9cnt7fbod2uoNkYvaRy + OELf77JOj+VOn2GjX/Ugc/kHn2ur0SeKvz6h7g2jhN37ezu09yUUVdgNx4yrw+WpZV1JLSVsRiZ01fSR + CRJEw5DqCPbcp0Cn8XV4Nzm22SPcIf7W3cMP9LXH8vPpZfy9e5Nxig3t8Re0MlLkOy/j5Eo2juGvl11e + +umKuVV25k4zKS002ODillcXOgp/qPYD5k2zwJDdUpVR/KvWY2x71a7vtkG42xqJlDN/zUIGr9mOrD6k + sA+ockE/XjgX9gTUG7uhQq0WvUeIFlvawPN/r731bqSkIPJI/p9P9j7117rNoX+n+8n36g691mSMEC39 + fp/sf6+/de6mwoBe6/S3597611KABv8A0H4/1/8AH3eP4utjj1lRRYj8cm31v/h7ePTi8Os6iwHFv+Ne + /dW6lRi4B/pb2oX4R00ePWb6kD/Af7yT7bfj14dSET0/X6H+n+x9v9P9ZvfuvdZYzzb+vvR6svUimUq3 + +F25/wBfn3rq3U8XuODa459760TTrOAWvYfT37rwNepkXCW/334PvXW+sg5IH9ffuvdZtIBBH++49+69 + 1zUDUDYX/wCNe6t8PXustvbPXtelh1737p5pNSU643N/px/W/wDxHvRFQR011kCEgG/19s+F8h1vHXeg + /wCq9+8I+g6fEQIBz1zX0i17+3Ebwxp4dXCacdZk5uf9h7vr1Y6alGB10/1/2H/E+/dM9dgaVJ+txf8A + 4n37pVDwH59eVrta34/r73NgHpR5dZgAb8cj8/6/+HtN02ePUiFbsOfpYf7cW91f4T1U9TQnPA5t7SNx + 6bddS0675/PH+HuvTPhEZoOs4+g/1h/vXvfVeu/fuvddg2N/fuvdZ+Pybe/dORvoNeuvR/qh7909449f + 5de9H+qHv3XvHHr/AC696P8AVD37r3jj1/l170f6oe/de8cev8uo9LujbFHuTGbNqtx4Km3juTG5rNbd + 2nUZSji3Jn8NtVYX3Rl8NhncVFTTY0VdKa+eJCkAmi8hXyLeOfcK0upYILyKJ2hg1eJIFJSPxGjVNbDC + 627VqRqOBno52a+tVmNrLKqyzf2aEgM+gMz6FrVtK9zUrQZOOk5j+9ujcvtveG8sT3P1XlNn9d56favY + W7MfvvblZtvYm6KWshx1VtveGagqGp8dXx1FRTwSUtU6SLJLGhUM6gxXb/45bWd5afqw7gStrInclyyi + rLbsKiUgAkhCaDoWCCdtym2ZUY3lvTxYAD40VVLjxI/iSqqzDUBVVJ4A9P8AUdl9b0nYOJ6kquwdlU3b + Gfwc+58D1hUblxMPYGb2zS1Jo6ncWJ2jJKK6ooY5gYnqooTGrjSWvx7tbK15LcwWYMr2QQ3Cp3NAJSBG + ZgKmPxCyhNdNRYUrUdJXngjt7a7kdVivdX07kgJcaQWbwW4SaVUs2gmigk4HSDwPye+M+6u0sl0Ztb5E + 9H7l7vwzV6ZjpvA9n7Qy3aOJfFQCqyiZLYtFVPkoTTRMJJxJTjQpDNYH23tzpu9o1/tJF1AgYtJF+pGo + VijEutVAVwUYk4YFTkdPX4O1Tra7p/i0rsqqkv6bMzgFFCtQlnBBUAVYEEcehOxW8doZ6s3NjsFuvbma + yOyqxsdvOgxWYoa+s2jkEiaoeg3LTUzs9FMI0dzHUBWCqxtYH3VZons23BGBt1eaNpQR4Ykt6fURl/hD + wVHjLWsdRqAr1so4uxYEHxysTiP/AEQpPXwX0cdM1D4RpR6HTWnTNRdqdXZPGbfzeN7J2JkMLu7NV+2t + p5ei3VhqnGbo3HiZXgyu39v1sUxjq62meN0qKaBmkjZWDKCD7d0t9RbWdP1ryPxrdPxzxeD9R4sK8ZI/ + p/19agr4P6ldGemRLEbee7DDwraTwpnr2RS+L4HhSNwSTx/0dDEN4v6dNWOnKffex6XelP1tU7z2tT9j + 1eBqd10nX8+dx0W9Kra1EWFbuWn208gq3oISjiWrWIxrpN2FvdIWW4E5tyJBaiMz6c+CJSwiMtPgEhRh + GWprKsFrQ9OSfomETdn1LSLDqx4rQhWmWOvxtEro0gWpQOpagYdQJu0OsqfY9f2dUdjbGg60xUEtVlOx + Jt0YePZGNpoKhKOeor9ztL9nEiTSRxMzygB2VTyQPbTXVslrb3zyKILtYngkLAJOk5CwPE3CRZmIERUk + OSAtT04kM0tzLZxoWmt2lSWMAl43hUtMkijKNCoLSBgCiglqAdK3H5DH5fH0GXxNdR5TE5ahpMnispj6 + iKrx+TxtfAtVQZGgq4CUlgnidJYpUJV1YMpII9rJ4J7Wd7W5Ro5Y2KOjAqyMpIZWU5DKQQQcgih6TQTw + XUCXVs6yRSqro6kMrowBVlYYKsCCCMEEEdTPbXTvXvfuvdEn+Sv/AB/u3v8Awym/96Cb3KvtOSNyvv8A + min/AFc6jr3HJFhaU/36/wDxzovhA1Hj6L/vP9fc4AkjPUSkk8eg/wBzADs/43/+JZyf/vu8v7jL3U/5 + INt/z0f9Y26H3t1/yV5/+aP/AD+vVh/+6/8AyB//AB17gfqYev/XvyA0HVf/AAt+Pp/T3lu9WOnrG2eo + Xrk0pa//ABQf0t7b8KmR0gK16bmuWP5/33+Ht0Cg6QtWtOuQiNxa5Atf6+6lwDQ9WBcjB6kxwX55F/8A + iB7o0oBp06tdOevXKMF/H9eePbkb1FelcLlDTrL+ADe/Pt7Scno2QjTU9SoWtb/ifbLNpFB14S0+HqaG + JH0Fh9R70prx6UIS/wCXXvt/JZr2/wB5P9PagcOnglesjpoS1+BcfQfke2XOg9W8Oop1Dt+PdllATpsR + acdZhDdb3N7fTj3oTFzQdWK0qeskaP8A0Itb88nn3R6tg9bj1V4dZ9DG9r/T6259shATnp4CnXJYWFiS + SPrbj2qRVHDrwr1LiRfz/vdv9h7YnleLA6eRAc9OERX6W/4n/b+0qzO3HpSqLXqZoGnn+n/Ivd1dtVOn + iop1yjVbcc8n/D/evbkjEdeTPWcLc83HH+NvdVaor0+EDDPUhLfn6g/k/X+vuwNDXpymKdONP6/p/Sws + fbqknj1tQOnOKI6QD/h/xT25WgPV6Z6nIgH/ACL3tBqNOrqCxp1m0j/b/wDEe3dA6uRp69b3UpTrwz14 + rf3sRilensBadcLEHm4/of8AiPdgKdVOcHrstxwL/wCt71IMdUK0HHrFqb/Un/efafPTeOuuSeRb/ff0 + 93FKdWUV656feq9PaAOuDoCORx78STnqj54nh1GWytZRweP9jf6+9dNdcHAXj/iL/wC9e3lUMOtAA9eV + +QLcf8FI91MSgdb0jrFMoYN9Pr+P969slAM9NuOmOZPVa35/3x9ppVBFOk7pXB6iszRkWFx/W/ssntQc + 9EO4WSkah13r1pY/6/8AvH19k0sehsdBa4gCt03TRryfe0JHHpA6aRUdNdSxjjJH59vpk9JJWx0kZXLS + MTbk/wBAfZguFp0hOT1iPP8Asf8Affj34sPM9a6bapDf0/14I59qY+q1B6glT9G5/P0t70/xdb6hSITc + AfQ3/wB49u9a6jSREi/HuysV4dbBp03yRLybm44+o/r7UDIB631wAtwPe+vdZlUWB55A97Bp1oqG49eK + Brcnj3vWeq+GOsBUgkDkD/W9+1nqjKAadYJDx7cQnz61TpvkNz/vv9b2rRhTq1D1i93qOq9e97691737 + r3XJVLfS39Pfqjz69100ZI/HuoY9WXB6a5oAb8e3OPShGI6Z54NNyB7qR5dLI3r02soBJt9Px/rn6+26 + dK1eg6jspkHKjj6H/H3rp3rGytGBbkHhv6W+vN/fut1xTrkCJEtp+vH5B/3n37r3XSRMD9DY8D/Af4+/ + da6z+NfzyR+bj6/W4t79Q9eqOu+F4A+n1P8AX3YLXqniD065AEkcf4/8T7sFoa9VZ6inWfSdIFjcn+h+ + n092oOmyBx6zpDYc8fj/AH1veuman165+O17Mfpb8/8AFffutt8IPXegD/H/AF/+N+3ouB6Shm9epMdl + /V+b2/Pt3rxJPE9SVCn6AX/1rfX6c+07k6iOqnqVGLWBH9b+6da6kql/wAL82t7916g6kiIAC1vp/T/i + ffuvdSEUXvYcfXge/VPXus4W/wDrf778e/dWUgGp6lxqABb6/wDE/T3Q8enNcfp1m8QH5/3v/ivvXSjU + esqobaRyR/vvz7314Ek9SYlKEhha44/Nzf8Aw9ptTevV+pSWJ/wt+fejqbFT1up4dZtJHFvxe3FrH3XQ + fU9Kk4D7OuOkcAKP9sPdh06hJrXrMsRI4/p9APp790+OHXYAHB5/5Bv7917rOsRuCLnkXvf6f8he/de6 + 5tEB6iPpz+CP9sPeurxmjg+nXHxarnm1/wAWH4961r0s8Qf6j12sLEW08/Xgrf6/19skk8eq1PWdadgB + cWP+Nif9v7r1ccOvfalvpxb+lh9f6+6OSKU62Osv2YP6hcf4gW/w5Huqk16upCmp6yCk+uk2sLm3H+9+ + 3aVx074o4CvSE7Y7F2t0p1nvDtHelSlPgdn4ibITQsyJPlsiT4cRgqAN+uatqDHAqLzYk/j2tsbZ767j + s0X4SNTev29VjeRn8LUa/wA+tO7sHfG4O0d+7w7I3VM9RuDfG4MjuHKuWLLDJWTk09DAPxFTRBIIlXgK + oAHuShHHar9JEexMUHA06E9pB9PABw1AavmfU+p6n9VbjwGyO0+t95bpwybj2xtPe23NxZ/AyRCZctic + Xko6quoVif0uXRSNLAg/09g/nzbbzeOUL/b9skaO4kiKxlCoINfKrA1+zHQj5fuLWPeojdiMxqBl01ac + 8RXh1uzddfzePh3vyWlw+ze9MzjPDRwTnE1W0M9jqLblMQsMdJXNTQNFCsZPiDLcHTdRYcYG3Ht/7r7H + aRxR2sssSqTI6KrOTx1NpJPDieHCvU0X268k3M6m+uotbGihgANXlnGaeXR4qTdmI7RwFBn6TcGJ7E2r + l4bUOWSqodx4WtgdvXCsjiSM8/qikGpT9VHuOL+6v/HNtcB1fgwkjof2+X2jh0KrO1WC38SONWjIqGQC + lD+I0/w9JVeluj6rKRZPM9Ndc5SQS6pT/dPC0kk9+CxlggFj/Q6f8D7c2/eby2kETyPp9NRp0zfWVpPF + 4vhIW8iUBI6GWgwPx6x0UcFP0PsuNVKoFfa+2ZwvFjZ54WNuP629nib3tZPdA5qfUmp/4voqfa930gpd + KBTyABp+XT7Ns74w7ipjR53pzrylgkujx1+wNveJgw0WaeigNuD+Tx/h7N7PfdnWQeGphf1yGHpnj9nR + XcWG+xggyGVTxzUH5d1eiL/Lv+W31XvPZdXv74zYjB7K3tgYnr6jamDmWn2nvShRdUtB9nqMdDWGx8FT + GoVnssikG4kHYPc3mDku+XedvuGvbYaRPbyuXXwwcFFNaMCTU/5B1HvMHtxsHOtsdo3WAWl0wYwXEaBG + EpGPEYU1RmmR8uBr1QkMbUUlVVUNdTVFBkMbWVONyeNrYXpq/G5GilMFXQV1LJ645Y3FmVh/Q8ggnOTY + OYNl5p2m23/aGMkV0tVCmoielWWQDywQAfOnWDnM3L+9cq7zcbBuqCKS1ajFhQyj8MkR/gPyx06w0i25 + /wCN/T2eaR6dB7xD69OcNGQbngf63F7/ANB7tpX06RSTGmT06Q0t/wAmxt+D/X3sxeJH4bCqnyPDpCZS + pNDSvH5/b07wUNxwOBbi35/w9uolEEbDtX4R5D7Pz6beUkBCcenTxDRWtpFvUxFvoCwsxAP9fbhJZ1lO + WQ1U+YPqOkshj8Mocg8R69O8FIQR6RYAAGy8AfgD/D35SVl8cGj0I1edGwRX0Pn0keZiCpOGpUetOH7P + Lp0ior24vb/iv9PfgKdJpZaCgPTglFfj8/j6f091IDfEK06TNM7Vqa1FD8x6H5dFf7unrOj+1+jPl1hl + kVOvt10PXvbUMQZEy/Uu+Zv4PVS10i/VaCeVJASDpFmHIHsv3K3F5A8bjVRcVzTj1NPtFzJ4Nw/L9w50 + yZjBOFJpXSDwr8urq6tImIMDx1FNIBNTTLY+ajlUPTTlj9Q6MrA/0PuFChjlaM+R6ygD0K24zoUVPqfm + eoSKQNNrWJsOPdur9SlQ2Fh/vX1/Pv3XuswW/Om/+w9+6ccADrOiCwtwwP05BuOffum+psY/qL2HN+ef + fuvdZgtwbAf7wPdk+Lra8es4ABHAHPPH49v9OdZeCVtyBf8AHH09+631JjU2Fh/vX+w92qaceqefUkKC + eFF/9Yfj3qpPHq1B1lAsB/rc/wCv7VdX65AE/T37r3UqNLAEqL2/w/oPeuvdS4kv/h+R/vh7916p6lgA + ED8A/wC++vvfXupCgAiwHJHttyRSnVl6kqLm30v/AMU90DGuT1frPZRa1j/jb/ivu+petdeLAfU+/a16 + 91yRhcG/HP8AvXu2COvdZdQJsD/vftpwAevUB49dsLgc25/HtommT1RCSesgZQLXv/sD78HBx051y1L/ + AF/3g+7de68CCTzxc82976MU+EfZ142H0N/8fp7Zf4umpHCtQ9Z1K82/3gW96UgHPTDsG4dYzyxH15Pu + +sdNU696v08/T6XH09+1jqwZhwPWVFt+Ob/4f737aLMeJ6X9Z1S3JNv6/wCw/wBb3rrRpTqSgA5H+Bv7 + bkJwOmz1MiNz9edPP19pjx6qSFFT1yKsW4H1t+R7102ZFIp1zHAA/oPe+meuQFzb37r3XIofxz/vHv3X + uuNyfqSfexx69173YgU61117p1vr3v3XuvWv/sBf37r3VY/8yKhw1RkvhFV7WhEnyRofm10c/UJxT1ce + 6RsJ9yxHvxUNGy3wX8HWjO4FnvCYREWGoL7jffJJl9zthQEi3bb9++rBJ8P6UWsHjFh/ZmRRQwFu4SZj + oa9Czb47J+Q+Y33ELRIYWszjxhu4aT91iAjv1tcVBA7GGJQV6qX/AJw75Cu7E+Tbfy8X2dJuPHdT7Fxv + 8zNp44D8dop/9J+Bk6Xp8vTYzx00vYyZAS6XpJFb7E1wqhK/haOH+Tn3k8xQQcuFE2Rd1P0plWqHf1t7 + nWu2mo0RLDrG70DRJcNYGMAB1aTLPO87CLzUvMskMxhcfGNnFpN9SdyHF1qV/d6MVlf9U6wFoTO/H7N7 + pwvQP8yxt001T/w9Hiet+z853BR5uWlrt2viDsmuXpzLfFuepjRk2OKI0f8AA4MfreKXwLVtUSh5GY5p + O3j2rjfk8yQbQ93Em9u4Z7pLrxlG8PuegrI6R2wuXsymhHsQrxhZCpAT9tX8fnHZRzMI6x2Nu2xnAs5L + FEQWYgDVGtrvwot4qdZvTMo0xGnQe/Gj4rb/AO5fjZ8Hd5r85v5fuF67wvYHTPY+0Ml1t8Sc/tH5K1/a + uHz81XmNg5Htao39WZSqy9bm/wCKY/MPkMU8FRMjlqeOHTGJCvANp9xLPdh+slooMcdkVhgvdse3iV4S + iiRBbXNqIjLX9QHu1iTUegvCLjcuUd62KdRbT3P1cd2LrVM9pc+O8gmDExt41szBrVkNEiZUUMvExfV2 + y/mxuD5M/wAzyr+MvyK+N3T+z6fuGpi3Xge4vjLuburcmcyke0MiKquxm5MDu/b0VHHIglCwyUkpVmU6 + iFIMUbQJR7S7nLckPZnfOcCsSDRItJLcz1lJIPiKUEfYPDKsW16qAfXRtz7n2kNqrJdrtPK4aVm1Rt2T + iArEAGXRRjJVz4lRTRTJVcZ3Ptv40fy2/wCX13P2yZ9w0fXfzI+QNZnKfZWCkWv3nux9zZSkpMHsrbpl + leOozOQK0uOpGnco80aNI1ixFu93htPcn20uNktmkeXYVgtIGYMTLdcni3tIpZQoAQyyxRzTBKKpaTRQ + U6CXL+3S7j7e892243McIi32Wa5uGGmNIrbmpprmYIW/BGjukZapoE1Dj0Zj419OdkYH+Y10/wDJf5CS + Tt8k/lb8dflJvTeWClqpJqDqvryDaNFU9ZdM4ClY6IKfFUcxrqpVXWK2tqkdmCqAu5e2+DlnZedeTIJl + u5LSz2Ce9uwKfV7lPdbilzMASdMaJFDaooOk/TeKKeIQK8w7vPzHv3JnMrQNZW01xvsFnak5jsbe2sWg + ebHdcTPNNO0lAfCmjjIPh6iRbaVRkPnZ8Ouw/j9iafPY74nfDvDdn7s+RGbWOfEYrunvmlEmR2X0xiqu + Ig1uIwbRy5DPlCojr6ahQ6lcgx/s8cg9peR/cK/oYbHauXLHareQdz3y3lvDe7k6+UVrFK1rArahcC7M + ylDFTobXs8ll7g84cl2Gbrcb7f7y/uEP+4li1rNNa20b+V3dyRJOzf6FFBJCyt4tRs5/F6Vp/jD8aZnI + LzfHvpWVioAUtJ1tjXJULwBzwB7lvn8aefd9X03G9/7SZeo05BOrkPYz67dZf9o0XQ5ewn0LOve/de6J + P8lf+P8Advf+GUf/AHoJvcq+0/8AyU73/min/VzqOfcj/cC0/wCar/8AHOi+M31Fv8L3/r9ePc3A06iX + oPt0Mo7P+OBZlRR2zkxqdlRf+Zd5f+0xA9xn7pqTsVtQV/xjyz/obdD725P+7ieuP0T/AMfXqwzyweP/ + AIEU3/Fj/wCVmD/la/4N7grRJ/C3+8n/ADdTDVfUdf/QvyIJAvb+v/Ee8tye6vWM0suoU6xn6e79Mnh1 + iCAk/i3+x+vtjU3Re3HrMgI4/wB8be9Flpnp6KnA9TowNH0F+faVjVsdX8+ocjer6Xt/h7UJUZ6UqorX + rr68kfT/AA9uiYnHTxmYddGUrYC4/wCRe3lUNx6fjkB4DrNHM5H1Nr+3AoHSuNiD1OScgC/9frz7o+Ol + 6fD1m1hgPrz/AI+2GOo568SvA9ZY0Vhc/g+9EUx1ZQDnrmSBcCwt/h7ui4r1ogHrpCAbsT/vPvzUHVlG + kdS1KEX5t/rn3VASermvHrn/AKkD6G/+vx7VBAOq1z10GKtYXP8AyL2zIofj1cSMOHWdJWDXt/vv6+2G + iVRUDp2OQlqHqcs7N6SBYf8AIvbWkDu6WAnh1Mp/Vqv+P+Ke9M2ogHpxFp1MUFvdgAMDp9cDpxgpL/qs + b/7G3t5UqOrAV6doKfx8gC/+393Ap04F6lgE/UWH0/p7sKdOKK46zxi3H++59uJUmvTmjTkdZbf4/wC2 + 9u9VpXj1zVOLn3QnNOq1oesRPNvx78pzTp7SCM9eIB9udNcD1wP5/wAP6/4+25OHV66qA+fXXtPUDj02 + y069a/vdadeFRw64E2NvdwtRXq+s0652v/T3XIPVCh4nrCyrqsPr/sfbgQ6a9eAx1wkQCzf1HIPvSuRj + rXDrG6jSbW+n9PfjJXrROOojkgc/77/b+2znqmSem2ZQzH3rSD1R1r02ynm3/I/bckdRTpBMgPa2esa/ + 0+o/1vZNc268T0VXVhGyavXqQEjYFWVSD9bj/ifZRLGUyOgzc2pSvy6ba2iUg6UGn/C3H+391jkoc9FE + sZ6R9RjJi5MSAg/W7ovtcsppx6QPGQc9Q3oapASYWsPyGUj6X+oPt1ZIjhqE9NladM9QjKLcX/oQb8e1 + Yk/hHTYAHUArq5b6/wCH0/3n34mpr1vrEQvI4/4nn27wXHWusDpqDcHi9v8AW90DGuet9NrQm5JB/qfa + pZBQder1wEYP9R/r2928RevV64iEj6Af7C59uRyLU9e49cvG39P979uhwTTrRwKnrDICDyPx/sP9v7t0 + 0xqcdNU5IHH+t/tvej6dXUdQDqJuQf8AbH3bh1frvS39D/tj7uHAFOqFhXrIIiRci/8At/8AiPe/EHVS + QeuYhBAP9f8AX9uLJqx1rrkIwv0Nub/T3br3XRAsP62BP1/1veut9RZUBH+8+7qa8erBqdM9RFyfdz0q + janTLPFY3t7oR0sQ+nUNrg2A4+v0/P8Ar+9AA8enw58j1jCcer8/i4v7pT06eqOuQCoOB9T9OeP9b3sD + 16qzUOOuwbke76QOqF6inXRUg2+v+w97B8uqVr1zVb245Ita3597Ap1rhx6kIliD/vFvfutE1GOpQUWv + Yfj/AHrn37qoYAUPWULcXH1v/vHvXTWpfXrkIyf9j/h/xPt5YwVB6o0h4Dh1kEQ/PP8Atv8AiR78f08D + pgmmB1l8F/68c/Uf63vXiN1oMT1Kjj0re36QTzzwPbZNTXrZrSvUmO1xwOR/T/D36nTep/l1mHF/8Tf3 + 6nVtR6kpyF/2A9662DXrOAF+n5/r70TTrfWdfSAfrex5/wAePetR631LB4U/4A/7z70TXrVPn1mU3APv + XTvit1LhUkXsLWJ/x+vPveOn0IIDHj1nHJF/6+2HUKcdKE0NxNOshQH8kc391UlTUdOKkdcHqQo9P15t + b3bWT06KDh1kSOxF/wA3/wB49062CRw6lIBzwPfunwxp1kWMEfRTz+QL+/U63qPWTQALL/X8+6udIx1s + GvXNYi31/wCR+6ai2D1brN4T/qR/tj/xT3vw1611ySEg/QDj+n/Gve9A6UI5bj5dZwpN7gW/wv8AS349 + tMKNTpTSmOuSxre1vr/gPx7Zk8utjrMUBGkAfj8X+nuqlVNW4depXrMkCKGZ5EiRY5JZJZXWOCCGJDJN + UTyNYLGiAu7k2Cgk8D2pTTKQIMkkD869apTPpnrWQ/mPfMhPkRviHrXr/JyS9L9b5WdYq2kcR0vYe7qd + 2pKndToh9VHTG8OKRtQIDTWBYH2O9tji2tJEcfrPj5D7PPo02u1SdheMrA+nl/g6JXtPA9XZCKCnyWV7 + Dzm4ZSXbCbT2rrp4VPCQvUyu8jc8GUIqj2Ywh/DVXyRx/wBnpRuF7uqa2t/BRFJp4gNSPyYdGvwHxv6z + qKKkr67B7pglqohN/Dc1mz9zTq49C1UVDZFcjkqGuv0PPtYsYMek4zWtBX+YOOo+uudN0SQpAyrTDUHE + +orXodNm9ebU2RT1EG1sFR4hawoa2WIyzVNcYv8ANfdVNQzOypc6VuFFzxz7chDxKyhyQwyDQAj0wAaH + 0r0ENy3e83Nw925fS2pRWgVhwYUoa/y6Mv1L3L270tLWN1dvzMbSpMjKs2Rw0Apa/b1fMt7VFTgsjHJT + +Qg6WljVHYcFj7i3mz2k5J5ndp72AwSMD3wnSwP8WdQqOOQehpy77uc68swi2sphcIOCTamUj+HBU0P2 + 9W8/Cn5d9kd37pzvXnaGL2/V5jH7eqNz4fde28bLhBVU9FWpR1WNzOIDSQq1pFeKphIDMGVl5BGHvvP7 + V23tvue3ptlwbqG+RmLEgmMjyagH59ZY+0vuV/rjbXeNewfSz2bqpUVo9eJWtfPhnq0nNda7ozG3p5tk + bpx8WQlSCalytFRUWUnoJo3WSSnq8NkyY5UcXjkXUr6blSGt7jKfl7cvDEu3TiSoBpUelcD06H0G+bYk + pjvoShBIBz5E8fn0B0kfe+Ekakq8f1buCeK6yed94bNq5PUSHaiePIRox+pAk0/kEDgB+dL2CXwruOsg + A7qHh5fs4dCOOXaLiHxYptC/wgVz6/n0/wC2chv+pq6in3VtrBbeoxAppp9vbtqM793UtJ6oJKKamptC + 6QW1szAkWt7skrQgu7EE4FDketfIg9J2tbSZwbVi+n4gwoCPKn+WnRdO9vgvTfI/cMu89g5nE7I7IhoV + XcE2ToZZtvb1pof2sdLm46MiWGth/QK2IMZI7JIGKgiX/af3C5p5GndNmVLi2mNXgkJCmlcoa9redaEG + mRnqJvdvkHlbnm3R95Lw3MACxzx0DBSa6GqDqj40HEetOq2+1/hz8iekYKnJb066rMjtymLmXdmyZf71 + 4Omp0NhVZKOjRaqkQ/U+aHSv5f8Aplvy5798rbnS25gil2qbzd18WIn5FdP+HrEvmD7vvNlmxn5ami3O + HNEWqXA+2Mk6h8xQdBdH1/uQ7V29uyNsQtNuta+s29j62WohyOSwmPqWoTn7QqyQU1TOrx0XkOqVVMhA + Qj3F3uF97rY+TuZjsu1bc+42wBrcRsAoNaCopw9R1LPtp9yfmPnzlH9/7xuI226qP8XaJqkEVNDq4+nT + HiDDkqKkyECMsNXEJQklta2Yo6kjg2ZTYj6+8r+XN8t+Y9hsd/s1Kw3sKSqG+IBxkH7DX8qdYXc2bFc8 + o8zbhyxesHm2+d4HYCgJQ4IFfMEefHpSwUYP0+n5/H+wt7Pegw05Pl08Q0hv+kf8T79Q+XSeS4NKHp1g + pbnSQL/j/G/vwBJA6QSSmv2f6sdOsNKR9FH+v/vXt/wW9emfFjP9oSv2qep6Uo+tgGH0v9D/AF491SIm + uv1x0y8iplmCg8CfT1p0g+39n4rd/UnaO2s4FGJy+wN1xVjEqppzS4iStpq2NnICvDLEkitcfTjn2y48 + KOSQ/ESq/LSa/wA+l2wX7WPMm33IcOTMoXRWhqQGDZJwP8PRkfh5u7JdgfEf4370y8nnyub6l2yK2dy7 + S1D4uFsNFUyMxuzypTLK5b1Xbk+4W36NLXeri2iyEbz+ees/4DIIGeSlS+P9LpBz869GKVCbEhefrb6+ + yrWelgA8+s6D6L+Of+K+/az17HUhFtwOf9f/AI17d68WJweswQKb/n/ePp791rqRELkj3rzp17qQBbge + 3kUU1dWXj1zAY8i1gebj/jftzq/UpLW+g4PHvdOq6j1JjDH8cEk/T/D+vv3Xhx6kAW5P193RAwqergdd + /wBP8T/xF/b/AFbrKg4v/X/iPfuvdS150j/W9+691Ki/H/BffuvdZwLkD+pA96JoK9e6lAcj/XH+9+0s + kjY68GI6ze2vEbreo9clve1z9L8H3sOerqajPWUi/B9u9b67UAC3vfi6cdNsxBp1lVRw3N+f+Ke23lJ4 + de1HrKBq4PtssWFOvJx6x/778+6gEGteneuajVe/4t7c1nr1OsnpUH6/W/4/Pv3iN0tVu0fZ14EHkf7z + 7qxJyem3QO2qp6zxgc/7D2nMjdN+GPU/6vy65MwXiwtb683/AN79+VmJoT1vwx1j1LcGxuPbun5nrfhL + 6nqSguf9bn/efbXiN07rPWTklhxYW/3ke/eIet6hTPWZCbfjiw90dyemZH0009Sac35/rcf7b2300zlh + TqV7103T59cQlz9W5Ivz731vrsFbstzdTb6j8Hm/v3Xuu/fuvde9+Bp17r3vdT17r3vXXuuyb/gD/WHv + 3XuucY5/2H/E+9dNsxBp1hg2ptau3LjN51u3MLV7w27is3gdv7oqaCGbO4PCbrNOdz4nFZFwXhp8j9lR + /eRoQJPBFq/QPcce4lzcfSRbaHP09yH8WOvZLoMbJrXg2kkla8D0f8v2trNcm9ljVpoP7NyO6PWGV9J8 + tYADeo6QOB+Mnxu2rsHdfVG2OhOptv8AV+/M5U7n3z15idmYuj2hvHclbkYMxV57cmGjXx1dXJV0tNUv + NLcmSKNvqo9xfA72sFjbWxMce2Zs1XC2powrAP8AQzRmFR5MfXoapc3CbrPvySML66/trgH9aXtZO9+L + djMufwsR59KfK9M9QZzs/aPd2a6v2Llu59gYmvwOxe16/b1FUb+2hgsozvk8Pt/cbjzU9NUGSQyxKbNq + P9fe7SR9vnurmxJhkvgi3LJg3CxlWjEp/GEKqVrwKj06RS21tNY222TRq1tZHVbxEVSBiugmJeCHT248 + sdBPgPg/8L9qdsv33tb4odBbc7xkylVnH7ewvXOFoOwWzVcLVuWO4oVEv3Ev+7JRyfbe0gbDbGz2P/E4 + WR4ykXYpjlqZIyB+B6nUOBqen9z/AN3c63W8/wCNSK6SB5e9hJEAI3BP4kAGk+VB0OuE2DsXbOQ3hltu + bO23gcr2HkHy2/8AJYrF09HW71yskD00mR3PURAGrmaOSSMySXOlmH59tpBBHYNtSIBavJPK0IH6bS3V + PqZCvAvcaV8ZuL0FeHVzJIb0bmSfqQkMYl/0QR29fp01cdMGpvCH4KmnHpFz/HnoKq21tTZdV0p1jU7O + 2Hu5+wdj7Vn2ljZMBtDfkmSOak3nt3Gsvjpck1YTVGqjGsy+u9/ahZJEvLTcEYi4sIvAtZPx28P0/wBJ + 4ULcUj+l/wAX0jHg9nDpP4EH0l1t+geBfSGW4jp2TytN9Q0kq8Hc3H6xY5Mvfx6Xlbs3aOS3Zit+5Ha+ + Crt84LF5rB4TeNVj4Ztx4jC7khWn3DicdlGHkip66NESqiU2kVQD9PdIf8X+p8Ds+sWJJ6Y8ZIGdoVk/ + jWJpJGjB+EuxHE9XkRJjbtKAxszI0Fc+C0yosxi/gMqxxq5HxBFB4dJnbfTHT2zdkZrrPaHVmwtr9cbk + rM/kdxbDwO3KHHbUzuQ3U4l3RXZbDwKIppciwDVjuLyH9Xtl7eCSwttqkQNa2UcMVvCR+nBFbsHt44l4 + IkDqrRAfAygjh06skiXtxuSMRc3jSPPKP7SZplKStI3FzIjMjk/ErEHj0usRiMVt/EYrb+BxtFhcDgcZ + QYXB4bGU6UmNw+GxVKlBi8VjqWP0xU9PBGkMMa8KihRwPay5ubi8uZLy8kaWaZmeR2NWd3JZnYnJZmJL + E8SSek1tbW9nbR2doixQwqqIiiioiAKqKBwVVACjyAA6cPbPT3XvfuvdEm+Srad+7e5tfZTfUXv/AL+C + bj3KvtOCdyvqf75T/q51G/uWabfaf81X/wCOdF9cg2J4+vJ/r+B7m/R8+oiJpxPRa/kMT/G/j4b8HuKt + t/r/AOj3LeyLfVAaz/5rH/q2/Qt5MIN5clfKH/n9ehEufH+o/wDFo/x/5Wfp71in5f5eh31//9G+wSG1 + rXt/S3595bNQDPWLpkUjrncH/jVv+I9sPIeHScyEnrCTY/Xk/wBPbiCo63pB67DEfn/ivu+gdOIoqAOs + 8JcfUm3tsxAnHS1LfUteshsxJt/vXt5U0jPTv07DrEw/pf3tQuerLGBx66EXIJIN/wDin+PveqnDq6Ba + 46kKgAtb/Hj3UOxJ6Up1PiQEC6jm3++4921dKlegoeubqBYf42+v4B9+AHHrRNTjrmDpAF/qR7oRVurK + Gr1zbn8j/W/Pu/DrZYjrl6SB9P8Aff4+68ethq46kRtYEWJv+PbbKagjrbgnh10JLsQot/re31Yhc9Wj + qRQ9SERbgsLm9/8Ab+9E1GOlAAHHqXoWxbgEfT2lZiDnh0pRRxHXUXL/AEuP99+fbRkBHT4RgeniGwsL + G5449+QVz0+B06RRhVuD/T/X/wBv7UKPPq1D09UqgLz+SBf2qjApXpwV4jqfpAHHH9PdC1ePTteuQVl/ + UeP9h711pT1yHP0492VWpWvT4JpXiOu/UPyf9v73Rq9XBU8Osobj27TptgAeuBIv7sF8+nVpTr1/p/tj + 7359aCCteuTW0+9Mor16gr1iA/2Ptoxg9aKg9eLAfj/ifdSmadeCDrEw1G49uIukZ6sFpxz12vH/ACM+ + 9tpGT1WSg64OpJHP9f8AjXtvxAPLpOMnrrSbc+6kj06tpPHrgy+m3+++vuleqOMdRXBUWX/ivuwNOmlr + TqHUqBcj/X/HvRNM9bPTDJEXe9yP8PadmYnpkr59cSDGPVzb3p4tYp0nmSo64rPz+b3/ANf2V3VmRU9E + F7CCpp13JMWGkH/ff7D2VNBpNT0QyW1M9M8gUMdWk3JtcA/7372ATw6LGjIPCvUaocLGV4FxwBYf7x7s + i1avSaRK1oOkjV3Zmtzyfa9cAdIGXSemxh9R9T7fTJ6r1FeMC54BAva1/wAf19uthT1rrF7Y631FkWxJ + 49vLw611EINzwfqfx7t17rw1D+yT/sD7cjIBNetjrmhP545P1/p7UKc1602V6wVKgi4/A/B/4j24WHl1 + RVNcjpkkBBv7bBNenKAdYvC3++t/xX2/17rox/i/P+2/3ke9dMniesoFh+r/AHv/AIp711XrtVvx9APf + uvdczGPwT9P6f7172OPW+oxUD+v1A/wIvb2p1A4631hkC3Nx/viPdhx62Om6ZPra1vx9f6e3Bw6dUg9M + tQnBH++v70elkR9OmlgQwH1sf97HvQFOlKinWN1P1PHH9P6c+/DB6sDU068oBuL/AOxtb35vXrTGmeu0 + T6EXvz/T/W926t1kKnUAObf8SPegKdU+DPHrMsZFja5H559+61qrjrKL+m6/S/8AX8/7D37ppm0dZ1Go + 2uB/t/pb37phmYnrMiNp/HJ/x/1ve6dNaj1mAAsbcgDn/YW92EZIr1YZFeuZOoqB/S3P+HvRUrx6q3WR + T9BYiw/I9660DTqSq2vf8+9dX4jrMi3Yf7768e/daoOpSIQbcc2t9fe69a09Z1ja45H1v+fx711sCnUl + VI445t7q3VupqxkhRcfQf191691KEdiC39Px/S/v3Xusi/UcEcj+n9f8PfuvdZuSbC/tpidXWwx4A9TE + jIUXIP8At/8AX9tkk9KUD5z1lRT9OP63/wB49+6dXUMk9ZlUre/+8e/dOBmrx6zKl7E/7D/iffulPUhE + Xk2/P+t7917rnYD6e/DpxOHWZVAFm/rfj3vpwGnWYJxcfT8f1966v1zABAuDcC3Nx9PfuvdclUX44Nv8 + fdNY6eiHHrOEFhcc2H5PtpjVqjpX13pA+nttlLcOvdclALAEgD/E2BP4F/fki1NRuGetih86dU5/zTPm + NJsfD1Pxg6yyzQbv3Tjlk7bzuOmH3G2tq1ljT7KppYTqircmo1VnOqKCyEDyEexbs21LZw/W3FGLfAg+ + JvmK4oOJrn06V2lpNdyaY/L18+qLureucn2XuiHbmMZcdQU0AqM1kzEJIMVi4yIxoj4DSOf24U/rcnge + z+OITyeNOat6jh9vR3vW+Q7DtxjJUS0wo49WdbF632z1/i4sXtnHR0tyxrMjNH5MtkWIsXq6xvUQSLiM + WVRwo9mYjzqHDy6gfcN8vt2ZpL5mRCSVCnOny1dCHBQ/i31Nyefz+L+3HVghkRS2niBxA/iz5fZ0To4l + kWNWABqAxwAQK9x8ienKClXWkYu8kvEcUaSSzyE/oWOniDOxNrAKp9ku+8ybByxD9TzBeQWkJQt4kssc + a4zpAdgxamaAE06V7DsHM/NRB5c265vQWKVhjZwGBpkqCAPmTT1PQ+bD+Nnd3YjwLtXrXc01NUadORyN + FJiKERuNSzeWuCsVI+ulCR9SB7xZ5q+/D7F8s3b2m3TXG93MVaRWcYIdxwQPJoj7j5lqfPrILY/uo+6e + 5QJd749ts0LkVN1L+oFPEhI9TV9BSvy6uZ/lm/FLJbMl7B7D32tHLXZeWDbOLhopvJR/wDDVUhqGhnAG + qOrrVY+RLa1pwRww9w3vXuXuHvlfW2/Xdk1hZ2qsEhOnxGB/j0nTwwaE/Lqb9i9vLH2T2y62q0vVv7q+ + ZXMvdoj0ilF1AHicY6Mv8lu8tp/G7fHXe38JTZOt3Nv7LY+nnxONyaQJgcPV5SLFPm6oz6i6l5VSnpip + 8jBgCAp9xxzTuMPLW621jYFtVwRQVFFyOOa0zjqUeUtivOatpudwvlQpbDLUPdiuMUrjzpnow1ZuaveC + nh3rtWLL0kihqbI+F6GrmUGySJNGNFiPoCwufx7OJdxcxA7hCWHAsoGaehP8q9BxNvjSZl2250Efh4iv + +f1x9nSG3huzqfa+28xujM0m58FjcNSmqqpKOVK+RmdxBSUdBQ3d6ionmZIYKeIa2dgqi59l08/LwhLp + HIpP8RWlfyPS61j5iklWJXWSnBQCD8zw6JxuP5iy9a5OWWt2ZW45IYPLmMVjt54uo39isdEPK4ymEo4X + pIqmKMmR8dLXGYG6Ehhb2D25ti2y70W0oBrQVoR+Y8/8/UkW/IN3utkb1tGkCoZlLKT5gAilaef5joYe + w+5Jq3aeGosHnNzbmyvZeFpqzaFHt+lnyeUpdsZQwplN619FFaOlpKGlqS0ktSQvltGmpxb2cz7peX0A + medmU5oDpH8ugzBtNpBeNZiJUYGhKlqkk0HfTUKnyH2dVOdw7ooc7uvd2VxkUFHt7B0U+B2zSwaVhpdv + 7ZonocWsKrYAOsRla31ZtR5N/cD7zeNue5TaUXW8oQEM1asw7aAUqPOmOsreU7Zti5eW0umZTHCzsGOC + FQksCc0PlWnQE7coGTCYdJEKOMdSM6sPUrPF5CGA+h5993+UNuba+VNr29sGC1gQg4NRGK/zPXzie4G7 + HeOeN53Vv9HvJ341oNZAyeOAM9KyGjA5tf6fT/efYkJoaUr0CTOBjgPUkY/Ktf2V+fTvDRg2CixJH1v/ + ALYAfU/8j9uKCTkdJTMjPRWr88ip9Kn/AIrpD9i9t9WdO49ch2XvbC7VMilqTHVNR58/XkcqMdgqbXVS + H62JiC8fX8e6vNHHXUKU8/8AV6dG+zcscx8xymLZbZ2cedML/S1fCacePRFt5/zSuqcKssOweud17yqU + d0p67cNXRbUxM0wIVQsAM9XIjH9JVAfr6b8eytt8iEnhrV/mOpb2v2B5juofH3+/8EfPA/b8P8+lx1J2 + /wDOn5FVVFX7Z626+6U67rXuN5bywGYy1XUU7vYvgMPkvHNkHsf2v8njivyX/Hu5muZ2BXsH9L/Y6I+Y + uV/a/k2Bra7upb+8NRSNkdA3A6nDFVz5Vr05fPT5NbN616i3d03id0U24+5t4be/u3WQYZKYR7aoayIL + mdwblaiYxUM08aslPRoxkBc3VUF/fr+6W2gKOfEasfw/Mn19Ok/tNyDcb5zEu87jEtvYWpcorVrI5A06 + SAVJBpWp6tI+GUW2l+IHxrj2k7vt2Pqjb6UHka8gqAHOXV0ubWrPOov9ALe4i5iNd/upa4ZhQfkM9ZZW + Yne3EcooVqP54/l0Y7xgHlTYfU8n/e/ZPqHRgxop6yhFH++t79qHSarep6ye7dKuuaqSBb3dXAFOtdSV + Dc24/wBce7Bgxx17rMoNwf6EX/4n2qT4B1YY6kgH6/Tgjn/Wt7tTq2odSY49V7j+lr3HvfVepSDSAP6e + /dbHHrnpLGw93Rwooerg9ZlUqLH/AH3PvzuGFB14nrOFFgbc2v8An/Ye6r8Q6912PqP9cf737U9W6mRp + qIJtb6/48H37r3UpRpJI/wALf7D3oiop1rrLqLFb/g/737SSRsKda4dZwuo2P0/PtooQK9b6yBQvA+nv + QNOrqwAoesiAE8/09u+IvW9Y6zDjj2yxJYkdUNCa9e96FfPrXXj731ZTQ1PXEqTx/Xj/AG/vfV9YOOsy + iwsf6+/dW68y6rfS3uxWgr1vU3r12kdjYWF/8Le2jIox04soAoc9Z1Bvf6W/r7Y6srhuHWQi4t791frt + I1vckfX8nn37r3WcKB9B79014q9d2sAbjn/kXv3TbOSag9dj6j/XH+9+6t1WpPHqSn1/2N/94PunW1BY + 0HUtP0j/AGP+9+/dX8Nhnrl73031xQEkrY8km9uP9v7917qUBwP8Bb3rqpYDj1xKEknj/effuqMwIx1z + 0qeTe/8Avv8AH3rqvXtCf4/7b/jfv3XuuD8af9e/+2976dDA4HXaMCT/AI8/8R7159Nt8R6CzszsfcOw + GwowVBg60ZUZA1X8ZFefH9iYBD9v9i6fXzPr1X+gt+fYe37lK55o8I286Q+BqrrVmrr00pp4U05r69PQ + 8xwbBUTQtL4vDSyimn1r66v5dBYPkV2CTb+BbI/5Jz3/AF+9h7/Wn3H/AJTof+ccn+fp/wD1xbL/AJRJ + f97T/N1xb5G9gKbHBbJ/5Jz3/X73v/Wm3Klfrof+ccn+frX+uLY/8okv+9p/m66/2Y7sAC5wWyP9tnr/ + APW73r/Wn3H/AJTof+ccn+fr3+uNY/8AKJL/AL2n+brr/ZkN/n6YLZJ/5Bz3/X/37/Wn3H/lOh/5xyf5 + +t/64tl/yiS/72n+br3+zH9gcAYHZJuQP0578/8AT737/Wn3H/lOh/5xyf5+tf641j/yiS/72n+brs/I + 7sEf8uHZN/8Ague/6/e/f60+40r9dD/zjk/z9aHuPYn/AIiS/wC9p/m64f7Mjv8A/wCdDsn/AJJz3/X7 + 37/Wn3D/AJTof+ccn+frX+uRYnhZy/72n+br3+zI7/tf+A7J+o40578m3/Hb37/Wn3L/AJTov+ccn+fr + 3+uRZf8AKHL/AL2n+brgfkpv8G38A2Sf8bZ7/r979/rT7j530X/OOT/P1r/XIsf+UOX/AHtP83XX+zK7 + /wD+ef2T/ts9/wBfvfv9afceP10P/OOT/P14+5NgONpL/vaf5ugn31vnNdhZmizebo8TQz0OJ/hEEOIF + Z4XhNc9aZZjWu51amIGk2t7GXJnJt1yvdXFzcXCTCaNUARWUghtVTq4jyx0Euaua7bmO1ghggeExSFiW + ZTWo00Gn9vSQN/z7H2oHh0BWDcT0W75Bj/c18ezySe4qzi/A/wCMeZbn2Qb9XVZ1/wB/H/q2/Qz5H/3N + uf8Amj/z+vQk86P0D/i0f1H/ACse2/L8v8vQ/wCv/9K+gc3sR/vj7yzkKkY6xTY+nXJeAbkfX+o9pqEn + qnXA/qX/AGP+9e1aEUp08pHXK1/p7c6dT4h1JV1C8/W3+Hvcag1J9ejaOmnj1iJueLgW/wBv/tvbtAB0 + 8XAHXMOOCfx/r+2fPph3XrLdeLf76/vQB6rEwrTrkXta3+HPvSjJr69K0dV49SoplC/Xm/8Ajx7uVPl0 + 7rUjj1k8qtz9f9ufp9ffqMOPVgw49dCRbrf/AGH+397XNerCU+fWRnQkgD6/7f3snSenQVYcesqqODY2 + 4/23vWrHXgFHUj1WNgfp71gjq+euMYIbUR/sT7q2Bjq0dNXTmpuBa1vbOsr0uEevIHWX9S2+n9Pz/h7a + dwelCIV49cokK/7c+2lFTnp018unWA3IJ4tb8Wv/AK/tWVRVx15Sa9O0bHkAX5H1P19t+JpFD05qp06U + 8hIAsbfX2picEcenVbGOnBXuRzfkcf4+7MPIdW4jqV9R/S/9fevLrygk467AsB/sfbqkhOlHAaT12Lc3 + /wB6/wB692qfMV60ARw64M4BGn6fn24BUVPV9JOT1jNyf6+7Dq4wOsij+vutR15mUU67Yn/Yf7x70adU + 1KTjrhqt71qXgOvE064En6fnj/bX59tg1ep62jA9eOkAXNj/AK3+PtzUOnOvXUfX204Ynpt1By3WFpF1 + fX3tYyRXpnSa1XrmrK3F7+/CM+fV8nHXn0/7H8e6FSvTLKRx6jEFr8f61xb/AGPumOqgYz1BnQ+oH/H8 + /wBfe2Hb001R00sh18AkcG/tNwPWq46wVAOn6W4P+9e1CAMQek0taU6amDKbgH6/4e3Jow8ZBHRfLFqU + jrkJVF9RAJHsPTWkrHA6JpYHOKdNMxu9xyP99b3pYyg0kdFjxFTQjqFWMdJsDwPbSoAeiqZQH6T0pvq/ + 2P8AvXt3z6K5uPTZICTx/vuPd16Z6xeLm/F/9c+99a64OGW1gDe/9T7917rAyFvqD/tvdw5HXjnrE8QH + 9k/61j/t+Pey/p16nXARf1JH9LC/+9e6lyeHXuuJi+vJ/wCSfb6S0FOvZ6jTJYEAm/8AxUX928RuvV6a + JUtc35/pb/H6+3wagHrfXHQP8fbms9ep1zCC35/3j3cGor0weJ64Hgkf4+/dV669+69161wf6fT/AG/v + 3XusbRqR+f6/X+nu6GjVPWx1DlS//E/n8e1Kkcet9Q5VsPrf/Ye7qSerp0zVC8/7f/e/ez0rjPTQ6+u/ + 9D9LE+9dLQajjnrqRVKiw55vwf6+9EV6pqpxPWBEP9Oefx/jx7t05qHDqWkIAF/eumjx65rGqkn63/r7 + 31dvhHWQgjj8+/AVNB1SoGT12Af6f8R/vfu2hvTpmVg3DrkI+fryOPp+LX91PHpnqSnIAHJ/p/sffum+ + sqoeCRx/T3ca6Y63qIx1k0W502/x596bV+LrVa9SfH6QTzz+Bb/evdevdZUAJs3B4+vHv3VwRTqSsaqR + yP8AY3tx/j7116o6zlbcg3t9OPde7rdR1KUCwI+v/E259+q3XusqqTz9LfTj3o18+t9TUB9IJ5t9bf0F + /p7117rODY2Zrjj68cX59+691nX1AX5N7/7b/W9+691NVFtwOfz9f6+2mBLHrw6zf0t7boRx6WRkGtOs + 6KxtzxYfgf7379071l8f+P8AvHv3Xhx6yAfgD37pTrX16yp9D/r+/dW656SeRb34dOJw6ze99X6zRng/ + 4e9HHVxw6yDn6c+66lPn1vrkgIJuD9P+J9snj0/F59Z/eqGlelXXNE1Hn3oZ4fZ+fWiQBU9Ff+YfyawP + xS6ayu/qgUtbvXMSSbc6y25JLH5czuyWPUMhNEST9njkIqqtiCCAI/q3s12iya7u6uKRQ5kY8BjCE+rn + tUeZ6vDEbtxDFkn0+XWohlc3uTfO6Mtn83WZPdO893ZmrymXyDLJW5bNZrKztUVE4ihDMSWYiNFFlUKO + APYplm8RxdoKEDTGn++xwNR8x0OrdIdptxJMQuK1Pl/q49Gk6u/vT07icom69ybE6whzU9FXVr7hjXcW + /wCalgg0Q0GM21RyERM1y96ixuTZfb0Eqqe406AXMclrzC3h2kDTyH/REFV/bjoUc78xNkYsCDa+3dw7 + qqIUAavyH2u36GpdQF8yI5klsxu2kKtvpz7fO4BCVGQOg3ae2G4Tv4t3MFRs6TxX5H5joOKD5Sdx793P + hdpbMx22tvV+4MlTY6hMVBLmain+5l0yVMk9edLLFHd2Jitx/T2FedefLDkflLceb90fRDt8DSmppqbg + q/m1MdSLyh7HWPNXMVjytHrnlv5ljjjWuktxdiRmoSpPoo9etvn4B/HHB7J6toN87mw9Jn94bmWGf+O5 + qggmrDBTxhTWRpMumEyPcqIlAA+n4PvgVvXOvMPvLzBuHOXOt3JOsk7G2gZ2FtBFU6QFDAeNSlAa41fL + rpZzbs/K/talt7YchJHaxWEafUNADWW40gMTIKMQPPPE9Gc+Su8azY3RnYmVwmRp8TkhhosXS1cNRDFP + jlzOQhxVVkKaNCNEkUE0hR1Hpazn6e1u1TbbBcRxxypGdQATSi6jXgOJNeHHoJbBtE+67vBb3ocrLIoZ + yWYAHFSSMUrXGcdFB2/8zOx9qHA0W0lxWxdv4LE0mKbDpi4tzYfKx0EAjpqnKiqMNVAnjSzy0cpILF9L + 8gzhsvuBfbX/AIipEYBC09DwHrx6Ge8eze03cEkkr63FdOckeQFP2Z4+fRddk9j5j5cfMfae9N0xJjaB + szDuipx81cJ6PBbJ6xpWrUhNVIsatFJVFJ5WZUvrGr9PsttN1uubebmvbwkR2x7WJwSDQgfmOjK+2i39 + v/apoLZdU1yxDgfEAeFeraPmf8k9uYL4t7/reluxttZjfEcm2tu4SfbWbxWTr8Bka3KwrJXPTI0unRDH + KBrSxvb8+5w5v5gsIeWwli6yS4GlSCRjP5149Y28jcp7lcc3RLfxyRxOdVWBppb5+hrUfZ0RLH9/0m76 + Lr7em5d35uursXQ5zd2Z2BM1BBs+bcW2tux/6PanGUMECyyPU5Gd6wNLUNolhZSukJ7iJeZLRtuY3Ljx + BXt8x+XU+XnI13BzE8VpGVhKpSTghB+NQeNSOidZ185lIsoaKkrdwbp3FLW09FQUcD1WQzu4c+7olPS0 + y8yzSzSFljvzY+45RI9xmF1pJjqSG8jpBJ8/Kh6l9ZLfZdraSUD6dF+CnwngzH0HS8xfZu8X2RQbRpcl + IIsbhcbsjK5inhkoNz1GH2v5I6bZ+cqTpligoqiSoZqUrG5drSM4C+zO+3y9NqtpExgQ6aMQaNqqFoQD + XUQafZ0T7byty7ezfvmBUk8TuFCP2itPmOgqzF8tWLt2PX9rCYavPvEAo+21A0eELLcK9RYPPY3EYKn9 + VveSf3VfZlPcLmhN+3mFhY7Y4uNTqQl3IDUCOvxUPEEDy6xd++b94G39puQRyls8yS71vUZtwI2BktYt + NC7gfCCOBrXp9io11XKhALALbgAcDhfwOPpwPoPfWiRwZCvmKCnpjA/IY64YeJLmOZ9cgrrPzJqT9p6h + bl3BiNl4SozuaTMS0kDRrHS4DC1+4MzkamW/goMbiserSSSvY2vZR/aZRz707vEmoLXrdlbtuN2trbtE + rH/RJW0qny+dePRHuxt9fOftMNiel+mqrobaWTm+wot6do5bb+G3vmI5FK+XEUVU8kdI8l9SxQxSzAD6 + 8H2Vyz3sq/pgqP4vL7Pz6lzZts9rth0z8z3TX1yAR4UALRVP8TUAAHrxFeiy0P8AK8+RG7dw02W7C7T2 + Cj5GRn3DuCozG4d3bljAb608dVDEs7m5OhZURT/Ue037nvroh5JceYr5eYp8+HQ8/wBf3k3aLRts2Kwp + 4anTGgAjqBgtJxpWmrjivR48N0Z8Mvg9tqj3p2FWYOo3NFGZ6Xde/wCOLP7yztXbSINlbOjLRxEsLIkM + HB+so+vsxjg2vak1OoLenn9nUUS8ze6fu3uBtNl1C0HGJCRH9mvBA/b0Qv5F/wAzXsLsRK/anSlJk+qt + mzo9JLuSWSln7By1J4yvhpZwGixEL/mOAvKP+Oi/goud9N4WSBKBTT7PLqZeSfYfaNkuUvObFM9wwDBN + RAUkVK+HnxKHGvUNVK0HRZPih8Zd2/K7teHbdFUV9FtLH1dHlO0t91S1FWcPjqmYO1OKqoLGoydeSVpo + pHLfqlb9tOUFjDNe3SsAXQatRHAMoqAfn6dDX3E562H232KSVkRZAFFtagBZXZjQsiCtRiuT5dbIX8tO + vp6foTfPVULTsnQnfna3WeOasqfuqz+70WdbLYISSfXSsMuhb/kNb2FebbaOG+WWIhg4oxHkwPA/Omfs + 6X8q38+5bRb390aSXMSysh4xlj8DDyI9Oj/hbnSef8fYV6Ej5U06yeP/AB/33+39+oek+lvTrmFt9Bz/ + ALE+91PSnrKi/wBQeLW+o92FT17rOhIP+uRf/b+3VVgakdaPWYAg+kck3/3jn2qRgFAJ635dSFvdbjnj + 8f8AFPdta+vXupyiwHB/x/1/ftS+vXuuS21C/wBOf96924jHWxx6zhV+o/3v3rq/WcIPzz/vHv3W+sgW + 9gBx9P8AYe9agM1691zCKP8AH/iPdvF+fXs9TolAHItwPrx/r+7/AKnXs9ZgATb/AH3+v7qXZTQmh69U + 9ZAgH+P/ABHtmRyaefW+sqfX/Yf8T7a1E+vXus4I/Iv/ALG3vfXuu0+t/wDD37rdD6dZT/h/Uf73z791 + rrmEv9eP9h7917rtwALj+vvRNOPXuuA+o/1x71qX162AajrLY/0PvepfXp7rnoYC5B/w9tvLXtB611zQ + fUkf63tip691kJ/3wA/4j3qp6cjIFa9dqNR/4n3up6eDKcA9c9H+P+8e/VPW+si/Tn6396qei/v65BQW + FxcD/inv1T04K0z1mAsePr/t/wDe/fq1631kQckng/gnj6/X3okDj16tM9SUP1F/9YX/ANv71qXrWo/P + rmCLgEjk/wDI/ftS+vW+s4C8EAf6/tsua46bJNeuYB/A92VqjPVSSePXvp9ePe9Q9etUJ4deuP6+/ah1 + vSfTr1x/X37UOvaT6dcWCn68+/ah1ZAQc9eUKPp9fp9fftQ60wOrotvyEBD7S/4Lnf8Ae6P2b7Wa66f0 + f8vQZ5hBBhr/AEv+fei3+zXoN9dKT5T/AKx/6FPuxJ9Om349ZXfSbWuCB+Lj3r59bUnT1g1/X/A8f8b9 + +Ar1sMcfPrIJLjnng/i3NvwffqdUZjWnXAsbC1hc888+7DHWtTdYXYj6C1/6f4e/dVqW49Yyxvf82A/2 + wt9Pe+PXi5A09YUYk+q5sDp/oOefdCvp1QsfLrmTdCf8Obf4jj3tVIOevVNKHqORb/e/duqmgGeve/dU + 1N/D0WL5JVxx+U+PUwxuUyd+38w/gxFKtXUf5J1dmq0R+Nnj9Uxj8EAv65nRDpDagHOYn0fRtpLfrHAF + TiJz/PgPmQOhnyTVr+4BGn9Hz/5qL0lv9mArNH/ZNvyu/wCLLr/5lLjf+Vj/ADf/ABe/1/7T/vPsj/fT + U/3AvOH++R6/6fqQ/ph/v2P/AHr/AGOv/9O+sKFBt/T3lUKk9YodR7Nf6m1z+T7VUAWvVWBGes4txb+v + tOWJag6bVqdcrge1SVp0YRtUDrrQTcg/Tn/fD3ddQPSmOR1PHHWO9uPz/sPbxOOlTSBhjrzPfT/hf3QC + temwpZSOsgY2FvfqgGp6qG8M1PWUcKSf96/NvbZcFsdbeXV8PXFSXI0G3/Ffz7dDDgelETau3qWv7Yux + JJFj/r+6NVjjpQQ68euDzA8fTj6n88/j24ENOqk1Ap1lhYseD/vR90ZPXpRCTSnTiCbWtzYW+n9PdMjp + 4Ag16lKTb8+91p0oGevW5uWt/sL8/wCw9svKB5V6cELnI6cI1BUabH/H2kZqmp6NIaKM9SbKADwDfj6/ + X8fT3rz6uXUtUdS4grG3+t7dVh5dXBHTmsaj/Dj3cVp1sY6lQlOPxb/W/B96MTNkdeKk9OUbqACB/h7c + VSgJPV17RnqZGdRJ/wBY+1SEEA9X49OIDMq88kD/AHn3pyK09OnYyFOevcqLH24hAXq7sDw68Trvbj/W + 97EgB60r0OesQjIvz/t/boYUr0oHDrKi2+oH1+vv1QetMaDrkR/T3Xz6YNTnrifpz7o/DrQBPDridAHH + +H+929sqCWp1sRk8esLEH/D/AJH7voPVlGjr2peL82AHI910N1fUOscilgObe1Onrzgnh1iWPTe9iOLE + /wC8/X37I6ZKt6dZVsvI/P8AQW91BNerrVfiHXiwPP8Aj+fx7pJUjr0obiOsLvYix/1/+I9piDqHTFeo + 8o8hNuOP+I9uE9oHWjQ56byh1WP/ABP09sMpGemSM9YKuO9gv9fe0emOm3TUOmeoVlXkWv8An2pVqgAd + I2QrWvTOysD9f9f/AA92NKZHSRojx6jEG/PspuVAJI6JbxCCadQax+CNX4/H9fZcqmuR0Gp6gmvTBMf9 + 7593PHopkPd1GIB+o9+qem+uiosePx/j79U9e6wkA/X3frXXEoPxwf8AY+/de6wsgvz9R/T/AI37917r + gAv45/17+99XUA8eu9IP4/3v37rZUAV6hToB9Bb8f19uqemumaQXLD/H/ib+1a/COrDrEFKkH6/63J+n + u3Xuso592CEivXuumW4I4970HrWOo5j/AKH/AG/uug9MV65MDbgH6/j8+7Kunj17PWI8fXj/AF/d6j16 + 9Q9YJV4JH9D7cRqmg68OoUiGx/H9OR+PakHPVwfLpnqU+v8Ahf3c5HShG4dNLKLngf7b3rpavEddWHHA + +n9B7903N/l66CAckc+7stOto1R1y906cpivXve6dJ2kPAY6kAAm3+++nvwJBr1TxGOK9Z0Tmx4vf6f6 + 3+Pu/it8utV6x6TqJAuNQ/P9APdOqjhTrNGn00j6E/71791TqToa9jx/j/xr2+vwjrXWUxllABH0/wB6 + Puj8etjrOqNpH++/x/Ptvr3WRI7k3H1/31/fuvdS0QX5/HP/ABBHv3XupNltax/H59+691zEduB9P6+6 + k0PV14dZgLC39Pevi6t1LUc3/pb/AHnj37T17qUiah9L3/PPHuvXus6RlbXI4v8A7z7917rMpIP0+pHt + h5QrUr17HUlUuL3/AN4911h8g16UwcD1LRdIHN7gf71790o65HgE/wBPfuvdZEHN/wCn/E+/de6kqBp+ + n1+v+wPtsuQadKlHaPs67sB9Pd0JYV6eTh1z0kgEc/4e7U6t1mjRrfT6/wC+/HurcD1deHWfRpN/pcfT + /Y+2OrdcgCfp7909F59ZVS554N/6X/F/bbyUFOlXXGvyGMw2NyWazFfTYvD4XH1eWy+SrJEhpaDF0EJq + K+uqJZCFVIo1LG5/oByR7pAk9zILe0FZXwB/R/E3+16rJwofPrUA+afyjyvyq7pym71kqabr3bIn211h + hJtapR7dp6hmkzE0IJAq8k96moY3Okol/T7HKfTWVsm3W5royX85G86/6XoV7NtoWMXI8vP7eit4rN5T + B1EtZhcpXYmrmppaOSqx070tSaaY/vRJUR2dNX0JQg2/PuviD16PLiL61FRsgf5P9jpsaQTyPLM7zTSF + jJUSuZZ5C5uxeVrsSfyb8+/eIPX+XV0S2tz+hCB9nXetf6/7xb/eAPbZkNenCdR1EUr5enR1/gVtakz/ + AHZPna9Eah2ft+SukdtZMUuUqRjvNGgsCyRmQ2+pBPvCT7+3Nl9sfsvHsu3HTLu90Lcn+iF1HrLr7mXL + C7/7n3F+0fiNttsZ4h/w0nSP+Mnralh7NwFFi6WkouwqWlw8FLCKOlh3D9tFBTLHpWFKWNwUUD6x2/1/ + fBIrzgJpLO2kbwI2oQpNdYx/gr1nJe8nX13uM13d7cJLgsdRK5Nc1OOPz6TFT2P11ljJQVm78HkkrA9H + PS18k89NVpU+h4qlqtDG6t9DqP0/P59ueDzNAhug8gkj7lJJoCOBP2dLF5P3iO3Zv3eI4wCSwX4R5n8u + io/I/wAnVkO1INmVtTRUe7RnUrcZVzLkaKCno6eNTHiXqQ0sGoTekLIVCkBbW95Fe2vP297zt15ZbtFm + F4/1KZ+2v8+g41isU/gTcOgt6J7Ll2Zn84i19JiYd1bSm2rPW10EM8Io6rIJW1dA8lQCsQq1RYnf8gWP + HuZdh3ckSCz+Kpz86nos5i2Ox3O8SLdlM1uqihX4VIApXyx59Dd2Juuur9sxLXZinrpYMzg58XE/2E0h + kpq9GaKiajA0I0JcECyaRyvA9m827bm9tpnPmf2eXRCNj2ZJoxblWnVqArT4B8A/Icei+djd9bP+N+xq + rc+95pKjbUVa8e3sdQzL/emqq6h2q0weNpZ/TUoGYmOUspjU2ayi/ti3Q3OfIK2r7D0t3bcE2hj4iaiR + T7Og8+Gf8wvCd8/MPrfY239gV+09v4yiyu7cJks7k4Jc7X7lwfhZFqKKh1QpFHSvUqAHJLMGBFvcd8/3 + d3tfLkd1YyGKOOVNRFcKWzn5gEfn0TWm4HmWOXbLlNMMsUwY/IRsw/mB0Bv85nObt6y/mJ9wR7N3fuXb + NBvXaPWm8azHYTN1tBRNX5XbKUFbUfawMEV5GpfIzAAliWJJN/fUv7rmy8rc4eztjeb9tqTOk7wGUitS + pDw5/wBK/WBPOvMPNO0blHZ2F80MIjIABpShpTos/wAU/m/k+i/4ztvsun3FvzY+arWzMU0FatdunbWb + cBKuehkysiielqUAaWB5QVkAdCBce8x+XJ9u5etTZW9kkUR/30Kf4OsVfdTkPdfcG8bmH6tlubbtMkpq + jeVFrivR38x/NJ6EoKR5MDsfs7O1igNHHWUmBwlF+Syz1U9RIVtxcqjD88+xCvMVtHGIrWIhFwurj65+ + df8AJ1Ddn93/AJou5Sbm5WOEZrTJByTX/Vjpq2B8mPmZ8rKt4Pj71xtXpzYxlaDIdrbngqc9S42K9nTH + 1uQQQVdUvP7VBBICbamT3pL3ctyfRbx9nBv9X2de3Xk32s9voTdcxXUu4XQylvB8TUwdXourBPRtsZsH + qT4wUH+lj5AdyZHee+xEZJOze2szJPWeZ4gaik622NCxipFK/tp9jStOwHrkHNjFIY9tXx7lqmlKfM/8 + V1Gl7u3MHPso2zl3bFtrUkMkcHeKLgGdxXSe7Irx6Ib3z/NVyVcK3b3xv28u36UNJGOyt50EM+al+say + 7d2tKXhpwQdUclYXcf6gH2T3e8tq02+K/wCHqZOUfu/QxwxXPPMlUJDeDHhAK1w3m3y8+qmN07w3HvXO + Ve6t7bmzG6tx1rF6zPbhr5sjXSBufHHJOdMKD+ykIVR+B7Jprudj/jHWRu17XtO22q7dZ2621tH8BApJ + IPLPE9Cp8efj52P8m98UezOtsYzUIZJtx75rqepO09oYtJNNVkclXxromlQXEFHExklksunTc+72Vub6 + UC2OPP7egzzdzxy/yNs02637FpxVY7Vv7Q+jCuadbNmGwfTXwM+OOSqaL/INl9e45szmMtXBRuDsDedQ + gip562ZeZa7JVQSGCFTaKM6VsiE+xqkMG12jkDJBJ/y/5B6Vp1gneX/M/uzzdawI3iVkVmTj4cOrtB9C + M56J3/JU7ayG+t+fLrE51I4cpvfJYbumWATFx/FcrmajHZOjo4jxphjmUs68EAX59xbzM8c9jDcpxaVh + /wAY66A2m0Jsix2FqdcKQoNX9PzX8ur4HiAJdQQCbi97i/4PsGHAqelvXEKSbe2/FHp16vWWwH0A9u9b + 65Wb6j6f6x/3v3tXoetdSYo/yf8AD/fX9qQ2oda6lLGDyLA3t9PduvdSUj02J+o/5H7914ZNOs6jVf8A + w9+p1fR1y8a/1978QjFeqGoNOpEYsth+D/xHt1G1CvTi8OsyjUbfTj3fq3WZUIt+R/Xj8/4e0zf5et9Z + 0iHBvf8A2H+PvfXupQW44H0Nrf7D+p9veKaefWuuSrbn/C1vbbNqNet9ZQpY2HuvXusirpP1/wAPp791 + 7rmASePpb6/4+/de6yhLC1/bXin06er1yA5t/vv6+9+J8um249SOT7o0n5dVwOuBBZR+Of8AX/w961Vx + XreOukW4Bv8A7x/Q+9dXHDrML3Fv68+/db65eotY3tf+nHBv9fbZ49b6ye/de68isb3I/Hv3XusoUre3 + J44+nv3Xq0z10Q5/BH+sfeureK3r1kHJA/qfe+q9ZlXTfm9/fuvdchwQf6H37r3WTVqIFrc/8QfdH+Hr + RNM9ZQhuGH04/p+PqfbNeq6/l1IUC4vz79Xr2v5dTEsRaw4A/wBj711Q5NeudrfT37r3XBk1G9/futg0 + NeuBjN+OR/sPe69W1/Lr2iwJP19+r17X8uuFvfq9e1/Lr1v8ffq9e1/LotXyFYhtpC/9nO2/29H7Odo/ + 0T/a/wCXoMcxsS0I/wBP/wA+9Ft1t/X/AHgeznoNddrILn/VfQkn/YfT3ckdNvx65u17XN7Wtb8j+nHv + Rzw60oGevaUe97fjj6W/2PvwA6rU9cLfgf631/4n3vrxzx64P6bDkG55uffutdeJAA1f7zzz72Oqt1wY + qLabXBvx791XrE3N/wAnSRb3oADh17rgbrGfxwb/AOPvfVKP5nrgGJAv+ACPp9fej5dM0qCx66v70K9b + 8Rui5fIE2zfx6/H/ABmKtP8AsP8AR5lr+yHf+Nn/AM1j/wBW26GfJLlr+4B/3z/z+vQnal8f1/5dP9D/ + AMrPtvy/L/L0Pev/1L8CuoXX88f095UDGesUKGnUdlNz/vX+Pu+pmFB02A7Gh66W4Iv9Le7eGxz1vTQ5 + 65nm5HNv+K+1KjSM9LI8U67RwODf34rXI6vjj1jYAn3vPAde8Wh6yBVA5/3oe6DX5de8U1oOvM6qLAD/ + AGFvbyrXj0tjGsd3n10Dq+p4H+I9+aP06fEQ6yWdCNIFv6j/AFvr72mkYPTy0QcOu3L2N7kj8X92DCvT + LymvUdWdjYqbj/ar+3K9WDE+XTjSIw5P9f8AifdGPS2JTSvT3GVFv6gD6j8/n210oofPrmWA5uP9tx7a + aQ/D0+oNK9cQQebki9vaZlPn0sR1pTpxhDWBBOkf6309+06h08rDj1OCqyBfyDf3UoxOOr6hx6yQoQ9h + c8i4+v097EbjJ6cFDw6ekWQqBb8D6/631HtSmB3dXX06zJC4P04t/j/X26CCMdOjqclwpU/63vZIAqet + 9OMH4B+lv8fr72hFerD16dFH0/H0596ZKsTTq3XGQr9AST+PduAoOvE9cVayj+vPH+x91APWganrv639 + qFIp0rVhTrkD/vh731V2Ddcb/X6W/H19+6pVeujz/h70wx1pqE9vWMEX+vttVOuvXo1IYE9Y5F1cqePb + 3A06fwcdY/G39L/61/fq9b0L6dSAt/r/AMU92J601eHXYVbfT+p91FeHW6Y6jubfQf196Za9aIDdYLMf + 9h/sL+6soA69IAE6xkf7f/intMa6h0ipjrEXCtf+vHPu3Xq0x1Glfm4t9P8AfD37Hn023HqMbkAn6839 + tOuajqhNeolaYxEwvybW/r9fd4a16TTEU6Tj25F7f7Dn2oavSM18+mmZwn9o/T/bc/n2ilOCCOii+bSD + jpplk1c/Un/X9lT8egdcyip6bpLn8fn/AIj3TorY1PWLS39Pfuq9e0N/T/eR72KefXuo5Ugng/7b3ccO + tdcilhe/+8e/de64e/de6j+M3uAeffq0x1ZWC8euQjP9R731YsCKdYaiM6eOfrfj/be9qaHpvpneO17H + 8/8AE+1AdqYPXq9YyoP1H+9+9629evV678S2ve3+3/4r7UK7aR1vrxhFuPrf/H26pJGem3JBx1G8dvre + 3+sR730112Rxx70Vr04hoadYXQE3PN/dTH8+tueHUaRfqAf9h/xHu61Th031FkjNuRxY/n8+342J49bB + 6Z6hf1cX9qV4dPoemhkBb/fH6f4e9ggNU9KBJ20p1zSIHi35/Nx+P8Pbvir8+qV67ZdQt/vuPbJz1VGK + NXrGIxxx+f6X/Nvr7cV1UUPTjNqNes2jSAf6/wCJ/HvTMG4dNt173pfiHVRx68CAb2v/ALH28QfXp3rs + C5t7YPTPUtY/Tx9SfdemOsigi9z/AE97qevdSFBAsf6+9de6zJyP+Qv+I9+6unHqSOAB/h73051nT9I/ + 2P8Avfv3XusqBx9baTz/AMU9+691JRSwNvx7bfj1o9SFQEc/63H9feh1ZOsiC/pH4JHPvY6c6mqCBf8A + rb20/l14dZU+v+w/4n231vqQijUrfm//ABr3U8enl+HqV711brLF9f8AYr7917rO63Fhb/fD3YdPp5dc + gh0j6fT/AHrj225OOlgA6yqLAD231vrMihhc/wBfbEhIbB60es4UkXFh7pU+vVk49ZALmw4492qfXpUv + wjrloPHI4H+P9b+/VPVus6i/H+t/vPu/iU8unI8V6yqLE3sPpc/gcfU+2ZG09xHHpX1Ut/OB7wq9gdCb + c6iwdZLS5buvNTRbgNO2iYbC2uVrclTlhY+Oqq2p4Xt+pVZTwfYm5fgS2SXcJMaaAfnWufn8ulljAZpw + f4f8vWs4QbkHjn6D6f42Ht8TsWdgO2Q1H5en+XoeopjjC/Lrq3+Pvfi/LrdacOvW/wAffvF+XXq9dfXi + 4/2/Pu7SgKOvV6sx/l0wRNL2tWiOM1EI25TrIdWswus0jwg/QC4DD/Hj3zQ/vC7gm05dtqnJmalcVqBW + nr8+PXRb7gFqklxzPcnDKluAfOncTnj+Xn1ZqY4/r405Jb9C/U/U/wCv75nqNHb5kKf5H/VXj10zMrGW + SMjg3Gny9euLKrKVKggggiwI+lvof9493QgMC3AevTkVWkVDkE0p5H8uHSo+STvVdefH+uALRJg81SyT + MS1pxFTIkeo3JNozfn8e7+3L/r7rt44pMr/kT/scOsXuYYv+RTcimNTdFKgmaNhe1jwQeQRf6EHg+5ZD + +GxdTQGvDH+DqhQOukD8ulL/AHvxO2MPk87mquDGYbC0M+QyVfOqpDS0sEZkdyQb3NtKqOSSAPr7X280 + t0wiBJHrU9Fe4S2+127TMqhs0wP83VFHyO733F3/ANgVO6ci9TT7Zxpmx+ysGzEU+NxCP4xVvBwPuqnS + JJnI4BCDgexbHGIVRFOaNX9g6gzcb977cfEYkipp0YX+Vok8vzq6YSBWDJBu120K1xTrg2NQxA+ouU49 + x37oAf1Iq5oolhJ/KUEA/s6MOT4Sd4LMe0LLXj/vturDv57fXW/o/mDke2pNp5Y9aVuxuvOvafetPTvV + YaLd23durWZLD5Oohv8AbShKuJojPpEgJ0kkH31k+51bzR+yFnNJiT6kyqvqpxWn2D/B1gJ7nXtt/WqW + LUP7NT+2SQ/4D1Sri8Zkc7lsXgsNSyZHNZvIUuKxNBCY/NXZGtlEFJSxNKyorO7KoZ2Cj6sQB7yhqfGA + Hp0BLqZbK2m3G674FBOgZ8vTq7roD+WjgthYOHs35GY7IdmbgoaZMhTdP7Ejl3DiqGrGlqakyTUbxvl6 + oG2qnilSmU31s4HsXbZttFF54QctmpP5Vp1ijzz70bxdTHYOVYpLS2kOlpiTgcDxUlf2+XQ7di9hfPPO + 41dqfHL4ny9PbZpYEpcbu3sCv2bS5KlpmTxD+BbUoqhqHHaRzH5UlZfytz7VTT7jJWOzAiA4gEZPrj5Y + 6Ceycv8AtraXP775y3mW+lUigRHk0g5ZCQFpVs0z0SKf+Wf8vu1c+26u6u1Ou8dmKx3lq8vvHsWTeGUV + Wa/jpKbHxJBAVH0ij0Io4/x9kj7TuVzIRLN9vxH/ACdShD72+23L8Bj5Z2uaWMduYGjr8ywyT8qZ/Loc + dpfyk+pcb4qntD5N0+TI9UlHtap2ft2lJIs8LV+Zq6iosv4dVH9QvtVHs1ii6bl+78x+zHQa3L7xfM0t + RsGzkL+EujsoPkSpXNPMClfXo1WyfiD/AC6+rXjqJoOtN0ZOnIb+K9l9m43c9QzpYgrQmqhpODz/AMB7 + j8X9mkVltdsMOD/M/nWvUcb17le8fMZ1C3lQ+X00LL+zUTToxWV+R/xU6o2xVVM3bPUW2duYiMSJg9n5 + DCSSs8SAR09BtzboMlRUEWCKilmv6iOT7Ure2FtGTDSueFP8Pl/qx0DE5P8AcXmPco1ksr28MpBd5gQI + yeOT6dUj9197bk/mDdl1eNg/iXXPxU6Mx9dvjd+SrxGlVS4bHoRUbp3AiXjkzmVOigwONDkQayxuQ7ew + neXsm4XDKSRFQZqaV8x1lTyxyXtHtJtEX1gE28blIRBGmWFQtCx4gIakjgSadSv5QnYFFivndR0OOxy4 + TB9n7I7GwFFiJahnOJo6emG48Fj3nYnyTxpTLEWuSzFv639kV6ifRTwpkItR55r/AKs9TLcrOsVsbg1k + 4ORwdqZcDgB+H7etreaNQwIv9QQDx+PyPccwK3hBifPpU3AdYwb3/wADb290312Et9eR/h/xPtV1frPo + 4/wt9DwePfuvDj1lVDwBf6fn6+7K1OPToIHU6IE3H0+n+8fj3YGvDpo8epGj8G5P+Frf7z7sDnrQweua + qwABFjz/AMV9u+IvTmodZ0Ujk2+nveDnpo8esypr/r/Ti3txX0ilOvV6lBdIH5N7cD+vvzPqFKdXQ56z + RoeW/FvdDwr051KUiw/1h7rrXr3XMKT/AIf6/u/Xuu/GPqfr7ZeurrfWRQBe3uydUfiOu/yPdn+A9PL8 + PWdBYc/1v7Yqet9ckQAhh/j9b+99U6y+/da65D3o9XXh1370TTrfXXvWode6zKWCjTb8/wBf6/4e/ah1 + 7rl/r/X8+69b6yqpBubfT37r3XP37r3Xvfuvdco+SePx+be/de68VIYH+rf8T7T1PW+siqSx/obf7xwf + fqnr3UhAFP5I/wBv79Xr3UhQOCAP9t/h78T1Vvh65e69NjiOskYPB/H/ABv3vrz+fUuP8/7D3XpN1k9+ + 691x9tx8enE49de3enOve/de64MpJuLfT37r3WM+ng/4f7z7917os3yHIEm0L/6nPf73R+znaP8ARP8A + a/5egzzD8UP+3/596LcBc/W3s7Ar0HOuKoQ7XYW+hFvp+eD7tjplmr1ycaCBcnj+v096GOvKaceuOv8A + w/3n3qnVesgNiD/Q+9VIPW+uEh1EG31v/wAR7uCD1rri4JUH+nP+3/Hv1c06q3r1w4t/j/X8f7b36uad + eFOuCKTyb/63P+39+63QddSD0n/Hj36vXtPWG1rA/wBBz/jb35uHSXPE8Ceve/Dps8ei5fIBded+PKgf + 81grbn/ynmW9h/mH/iH/AM1j/wBW36GfJJpfXB/4T/1kXoUPt38f0P8AxaP/AI59p9TU/L/L0PdfX//V + v7CKAB/iP95PPvKmnWKSnNOorgXaw/J+n9fboXSKnp0pTPUcAngD6e3Q56TkZ6yJYA/1vz/rg+7agRQ9 + OxsSdPp14R3N72H096DAdOkjz6xEkMRb6f4e9avPptlHEHrlY3GrgHj/AGJHuwfOemwxBqOos5s4/px+ + faqOhFejSMsEB65o6Xtf8E2sfezwPSqp9epyOwXkfn/X/HthADLn06fPWKWaxAsL3sePbxUU6qEVzny6 + yRqpN7f0/wB59tsxUY9OnCip8PUxGKcDj8f76/uqksKnp1Hp1k8rX+p/H1A5593VQy9KgwIyes/kdgPU + B/r2v7osQbu6cMoGOvJMy2BIPPH592MK+fXg9Djp9hb0qf8AWPtKV0mg6MENR1LVgf68e/A0PV+p9OLN + cX+n/E+/GQnp+IdPELFiAQfr/vH193ADZPT9KHpx/A/wAHtxV0inVx1zRddvx9D/AMT781KUPXunCA86 + f8LD+ntxAOr8B1OBsGA4J/4j29QdXHAdY+eSfqDb/XHtthQVHXiOsZ1fg2/33+HtvUR1UHPWeP6C/wDX + /ePftRHDq5JB65uFFrfnn/b+7qxJz1qvXD291vr3v3XusZXk2t/vPupbTw6c1mlOu7f159+Jqw60pOsd + c/dulHWNyQR/re9jj1ojriWa3192p6db6iyluePz/r/7H3oAHj1ZVHXBHN7H3SRQBXqkyjTXqNIx1n/e + P+N+0x6QkmnUORzqt/r/APEe6EmgI6bJIPWEkm/P9fdvLqwUNk9eYWFr/j/fce/D0PTZUZHTNVFnYq1/ + byAKK9IJQdVOmWQFSV5+vHtzpI7EY6g1EK6CbG4U8C97/X6eyu8Onol3Gnhn1p0wkE3sCR/Uf70fZbVG + 6A8wfXnh1Ee688c/191Py6SyGnDryk2v/U8c/wC9e/dUU92eu7t/U/7c+/dOVHr1wKBr8/7fn3uuKdb6 + 4FD/AK4/2Hv1T17riYybm3P+v/xHu/WuuOmwtaxta9v8Le66ut9eCD+lz/sfdutdcJI+Pp/sDf8A2/v3 + XumOeM6iAOD/AMV9vrw611G8ZH1J/wBt7317rrxn/VH/AFv98fbiSj4fTrdeuYNvagNp60y6jXro6T/Z + H+w4928QdV8P59e8Wr1AC3+w/H+PvRkHVCtDTqFUJpPAt9be7ggjrx+fUD3vqvXFgCPdgaHrfTROv19r + EOOnFOemVls5/qL2P/GvdxSuenQc9eGr6j/iPblI+nKr1zVSf8Dc/X+lv6H230110VYcDn3ZdH4urqRT + PXRDWAINh/h/t/p78wX8PXmI8uugpP0+n091HHHVOsypbj6+76X69XrvQAfpYj22ePTbMQaDqSkb2HPH + +w966p1lVBbnk3+v/IvfuvdZPfuvdZowSOOOb8/63vRJAx1sEjh1KC8j88i5H/FR7rqPW9TdZgAOB79q + PXtTdSEFwLj/AFv9a3vWo9XqepKqB9B+AT/r+/HIB691njUsDb8H/D+n+Ptgu1cHrRYqRTz6zqtgLfU/ + X/H3sO3TyEnj1IF7Af4D/eveiSePV+sq2AB+hP5v/j7117qXGFKqf95v/j7oSK9Pr8I6zAXI/IuL+/VB + 4db6zotjcDj/AGP4PvTEgVHToVSOs+kkX/5H7prbq4FOHWUWsOPeyyniOlEZJFT1z08Xsf8AX59pWdtR + p1c8epCqBYAG1+fr7oSTk9a6zWAHHvQ6unHrtVYEkmw/xsOP6c+7dKl+HrMlmP8AXj+v5976t1nVV/p/ + T3Qr9vTkfn1lRFa/BuxAHP1P0FvbculiiPwAP7ScZ6eDkGTV+ECn7M9atv8AN97Fl3d8tG2jFMf4f1ds + Pbu3UhSVWp48vlfJnMsUQE6ZFMscct+SVHH09iqLUuyQW8vxvqMnlUAjRT0oK8OPn0KuWIfEhknlGSRT + 7M9VZ6h/qh/t/eldhGIvwrw9f29CwgHrvVf6H36o+f7eq6F661f7UP8Abj3Wp9et6F9Ou1YXF2Fv9ce/ + ajSnWtC8erMv5clXAtR2tQ+S9RMu3apYgASYohNHI9xyOTb3zY/vDLK4a05bv4vhVplP7QeuiX937cwr + vPMW3PxljhanyFR/h6s/P+8X4/4175sTaTKCvDQn7addNK1Vmf4i5/YOHXG9uT+PegATRuHVCzp3x/EO + H29LjtKA574zbVySglth78mxtTZbyCmyKNTo50/RNUiMGP1t7Y5LkNhzvuFs2Fu4UK/81V4mv+lOBw6x + 257thYc5K8PbDMoJ86ufME/4OiZlWLWsdWo8fS5ufT+Pr/hz7l7UrssFKk0z0Wll0NNEaBa1r8uPVb/y + 17eO5K5+r9t1THBYSrV91VlPyMvmI/XHiUa9mp6U8yX/AFScc6fYktbb93qEPxfFXjg5HUWcz7jNud20 + an9IKopShqBnPHj0RuajBLGwBIH9bf7G/talyVlGriwIHQFu4BbwiZRhWp+b4B/l1c3/ACP+l6nd/wAl + s12RPTSS47aGMx20cU8g/b/jO7MlE2TaCRuF8VHE2pr8aiPcWe614Z7Kx5UB1S3MqagPOjArT0z6dDDY + 7JNv2PcuZJgQkMRWPJ/taUZqeYIwF9Twx1sq/JHYp726A+ReyzBHUv2VtnsKTCrLTqiLXYuOZtpz1EUg + JM0TUkKBx6rBSp5Hvtf7CWJ5U5J2O0usL4Q1LwqGGP8AJ9tPs65Xe4Vwl9zHd3i5dW0A+WlWJApw4k54 + 9aG6JNAniqVlgqoSaedX8kE0U8DmKa6nSyNqBBHBHI9znckxT9nTKxQzRC5UV14YE1B/2px0JGwMN2f2 + BnV2r1/mNy5HPvTNUU+Jh31U4SaoSJwkkVAMhXQRyykEaYojrYfQce7RPezPSOVlr6EgfkBw6Qbva7Fs + 0DTT2waKTLDwwVX1oacOhjq/jN8zIpmiquv+5DItwwfcWTmWQgWLMzVxDWH5HHtUbPc4TRXZ9eSa/lTo + Jx84e10QGiS2qmGHhgaSc0ag7j82yOAx03N8WfljVlFm6z7JlbkKmRzL2OoWZmkqKz/bXNvem23dZErG + WDfaeHTo585AT9VLi3C8KBCB8vLp2x/wS+TGZlH3/XFBjA5RRPuLdO3oQGPpu6pLUSg/kWXn25FtO5sd + DVNccT0nk90eRYQWS5jIFT2g1PyHzPl0MGG/lqbqp6ObL9h9n9a7Fw9HTmryM1FDU5o0FPEf3Z5MhURw + UoUf0Z73+g9rv3DPEaTyaPtPQf8A9eyxuZ/p9g257pvtZf8AAeiwYPo5Oye2K7r/AKOr6jeu2sfUhW7G + y2BiwmOpMdABHXbkroYSyRU2vUKddfknULZQT7K0tZLid0tiURCQxJrqpxI9K8ehzLzZJtHLZ37fka1k + kAKWyMWZiwqKmtfy6H75MdgdfdW9ZYf4m9K5FK3btNk6LcPcm8IXSSq3ruykUmlx2SroG0SLE/7skSMY + 47RRDkN7V3rRRQ/Q2RqvEnidR+LJ+zh0EuR9o3PfN2bnPfoyWI0QxP2+Ei5WSuDVtR1etM169/L02pvT + D/NT4lZ6bCZDHY7PdlEUU9ahpKjJ4aDCVT5itpaFrTPSInpep0CO/Aa/sqNu0O3XLSn4kH+HPQ5u7u3u + GSFZhLMshZtIAVVIoAKY4+Q+3rcyrwQ7kDnWf08ixPFj/S309x0kgEVAMV6VtwA6iohYC3F/r/Un6+3Y + yjceqfb1NSIEAixP+v8A8R7trbr1epKwA/j+n+P4/wAPbqklanq4pTrMsBJAHAFr3H49262T6dSli0nk + 3H5976r1nVf6EDn6E+91PWusix35Ivb6Wvxf6+/VPXusqxyfj6f0sOB+PbgZqde6zxqVIuP94/w492DV + 49XVQR1mWIgXYi9/z73rH4a9OlFGQOuYB+gZeeD+fei5pnrXUlY7DkX4H9fdKjr3WYKbDg/T+h921t69 + X0jrvQTz/vd/bbMxPXtI6yxxXPqsAbW5t/tr+9a2HDqjgY6keNR+Ppx9T734jnBPXlJrTrv3qp6d6zLG + lhx+P6n8+9am6YqeuLR25H0/I9+1N16p64Wt/re/aj04nDrr36pPV+uQUm9wfobXuOfejw691kjBBsxF + vbWtut9SAqn6cn/Ak+9a29emixr1kYAGw9uISRU9WU1GeuAAH0936t1n0gcj/e/dTgV691783/P09t62 + 63161/8AYG/uvXus4UDkD/e/eutVHXMKSPx/sfdHYjh1Vm9Osw4A/wAB7b1t69VJJweuQuTb6+/a261w + z1nGkcAjj/H3rW3TRZjx6zKbAkg/j3bX1SnXLyD+h/3j37WOvU65gqy8Cx/1/wDG3vWoD4cdbBI64Fhe + 3N/etbevVgxrnr3PvetvXpyq9cvetbevTWo9cCFJ5Unkc8297DtXr2o9EJ+a3ce1+qsh1fQbgxO7clNu + eLeTY07aw0WUhiOIbFipXITTzwLEW+5j8QudVn+mnlFuHOuxcolBvTOpuK6NK6q+HTVXIp8Y6snKW+c1 + VfaEVxbAl6tpoG4Uwa/Ca9V41Xzo6tpKSqrH2H3bNTUNdNj6poNj4qSSGrhYJo8RyochyQIyqnV7D1z7 + 9+3dodM8k4P/ADS/6H6N7P2P5/v4GuIIoSq0qfFpx4fh64H509bwIZazrD5AUHpDMmQ69xlLLGhTyK8q + SZa4BHI9st94P23UgNJcdwqP0Rw/3vpaPu7e5zKXFvDQefjY/wCOdQaT5+9UZCGaqpet+/5qanMgaZeu + saI5PFy5h1ZYFgB9Tb3V/vEe2cSanmuAP+aI/wCg+t/8Dr7n+GJjbw6SaD9X/oTqJjP5hPTWXrsZQUex + O9hLmKgUlA8/X+MhgkqGuEheY5WysbcX9tbT94/2t3rdBstjczG5JACtFpqT6HX0p3b7tPuzsm0Dfb6z + i+lI1a1l1Y9SNPQzv8j8cNSnp3vwEEj/AI8XEfW9uLZX8+5SPM9nTV4E5HGvhjh/vfUXf1O3QLqLwjy+ + M/8AQPWNfkniwLf6He/Pz/zAmJ/1/wDna+/f1ltaVWCen/NMf9B9VPJ26Mf7SH/ez/0D10fkni9On/Q9 + 35e1v+PExP8A9dffjzNZ1r4E/wDzjH/QfXm5O3Sn9pD/AM5D/wBA9cB8kcYP1dPd+D/W2JiT+f8Ata+/ + Dme0Jr4E/wDzjH/QfXhyfudP7SH/AJyH/oHrkPkljACP9D3fdz/2YuJ+n/n1+vu45ktj/wAR5/8AnGP+ + g+rHlHcuIkh/3s/9A9Yz8kMabj/Q/wB9W4/5gXFX/wDdr73/AFjt/wDlHn/5xj/oPqv9Udy/35D/AL2f + +gesZ+R2MAuOn+++D/zwuJtb8f8AL197PMdseNvP/wA4x/0H03/U7cqU8SH/AHs/9A9dp8jMe59PT3fT + c/QbFxP9f+1r78OY7b/lHn/5xj/oPpo8l7rX+0h/5yH/AKB6Se5t25TtjeXS1LiOru18BR7V7DrtyZ3N + bv2zjsRh6LFvsvI4mJvuqevqHaRqieJAoj/N7+y6/v8A95S2yxQyqI5CzF1CgDQw46jmpHR9y9sN3s9x + NPdPGQ8ekBGLGupTw0jFB0a3+EtotZv+LXp/2P3Gq3tVpxw8v8vQhr1//9a/7/ff7z7yqXj1imnxdQT+ + o/649vv8I6Ut8HWJP7X+w966RHj1k976cj4n7Ouh78etPx6xN9T/AK/vXWjw6yt9D72OPWhx6bJf1H/f + fn2uj+EdGyf2Y68v+cH/AAU+/HgelHU0fQf778e2U/tfy6UdY5PqPbz8OvDj1Oi/4p/vftqT/J1s9Z/+ + K/8AE+6x/D+XTg4ddf2/+Qf+J9vR/Aft6eXj1mT6f7H3tOHVm49c0/Wv+v7s3Dp7p/p/82P9j7RSfF0Y + RfCOpK/Uf64/3v3QdO9PVL9B/sP9792PSpOHTzT/AI/339Pdl4Dp0eXUv271frlH9B/vvx7bb4utefTh + T/r/ANj/AMV9vp1c8Op/5P8Asf8AevbvVhwHXBvp7q/w9bPDrH+T7Y6qOJ6yx/p/2J966u/HrlJ+P+Qf + +hfdl49U64j6e1PVhw679+6310fdW4de66/I91HxDp2Prl7c6e64P+P9j7svXusfu3Wuo7fVv+Df8R70 + vTq9R/y3+uf+J96fh1Wb4OsLfn/gx/3oe0nRb1Ek/V/vv6e6eXVG6w/1/wBc+99OLw65P+P9Y+7pw6bP + TXWfrP8Asfdhw6ST9ME36x/wb/iR783Ra3Udv1r/AMGHsvvPg/b0WXfwH7OmPIf59P8AkL2SJw6BNzwP + 2/5eoL/Q/wC+/r7f6LD8fWD3vrUv9meuXvXSDrj730ZDgOve/db6zn6H/WP+9e/de6iSfj/Y+/de66T9 + Q/2P+9e3Bw611zk/Q3+t70eI630zP+tv9f2+vDqvUF/p/sf+I97/ABde68f0/wCwHtsf2n7et+XWP2ob + gOtde90691Jj/QP9j/vfup49VPHpsrP1e1kHDqp4npq9v9U64t9D72OPW+m2f6f7b2sTj1YcemOX9Z/1 + vd+nuu0+n+x/4j37r3WQfUf64/3v37r3Xj9T/rn/AHv37r3XXv3XuuEf0/2P/Ee7D4uvdZ0/UP8AY/71 + 7e611yH6/wDff09pzx6bb4upSfpH+x/3v3rqvXL37r3XvfuvdSo/x/wUe9Nw691KT6f7H/iPdOt9c/fu + vdSk/s/8g+9dOdSV/Uf9Y/8AQvu3kOveXUmL6f8AII9peqtxHWVf1D/Y/wC9e/Dp5PPrOn6h/sf96976 + c6yJ+kf7H/e/fuvdS0/SP99+fad/iPShfhHWeP8AP+w92Th1s9SR+kf7H/e/dn+Hp5eA6zL+kf7H/e/b + J4dW6yL9P9j7aPTqcOsx/R/sF9tnj06ePUhPp/sf+I96611yPvw6unHrKfr7t0qX4euSfX/Yf8T731bq + Qv5/2Hup6cj8+pMX0T/g3/E+0txwH+mH+Tq0n4/y603/AOYj/wBlw/JX/wASE/8A7qKX2NLniv8ApR0P + OXP+Sev2D/L0TP2m6P8ArKn0/wBj/wAR7917rF7917r3v3XurF/5cf8Ax/HZv/hrYf8A92be8A/v/wD/ + ACpGy/8APTL/AMcHWd33B/8Ap4W7/wDPJH/1cPVsZ+g98qhxH+lXrqo/xt/pn/wjrofVf+DL/wBDe9nh + 1ocehQqf+yXu3v8AteYL/wBzYPaCy/6eFaf6f/J1A3un/wAlWy+0/wCFeiMf2Jf+WUn/AFrPubbP/cz8 + z/h6Bd1/uHL+f+Hqi3Kf8XPK/wDa1yn/ALnv7E91/bf7Uf4Oosk+E/6Y/wCHpml+v+3/AOI9o/8ARU/0 + w6Ktw/3Ak/0yf4T1ss/yKf8AjwN1/wDh/wCd/wDdFN7iXnD/AKevs/8AzXi6F++/9Oin/wBMf8PV9e0f + +Pf21/2qMX/7r09949l/5Je1f80Yv8C9chd8/wCStf8A/NR/8PXz+ey/+Zl9mf8AiR+wf/euq/crXv8A + uR0t2r/klxdJii/4umD/AO1nSf72fd7P+0H29Ob1/wAkyf7D/g62qurf+ZObD/7U9J/0IvsaWX9mftHW + BvMH+5l1/p/8nTvWf59v+oeT/oUezqHift6Dcf8AuL+f+XpIv/nKb/lq/wD0N78fjX/TD/D0qsv9yE/0 + 4/w9V9fzEv8AmUVH/wBR9J/0O3sh5i/z9ZBe2v8AyUh9v+XopfR//ZK3YH/hyN/1oHsjtP7A/Z1IfNn/ + ACWIv9OP8vRQutv+P92h/wBrmP8A9yj7Ktt4v/pz1Im7/wDJOb/nnX/A3V2nxt/7ezdAf+Iq3h/7x1d7 + Vbh/uFP/AKUf4eox5T/3FP8AzUP+DrZRyP6m/wCDf8T7iRf7L8z1IR+EdRofx/wUe1MfVD1MT6f7H/iP + bvWupqfVv9h7UJ8I6sOs8f5/2Hu/W+snv3XusqfT/Y/8R7917rPH+f8AYe/de6kx/n/Ye7jh1rrkfex0 + 4nDqSffh083Dry/qX/XH+9+/Hh1TqX+B/rn/AHoe2eq9ZR9PbvTw4de91PHrfWdf7P8AwX/inuvTcnl1 + zP09+6qvxdcfe+nupI+g/wBYf717r0x10/6T/sP979+691hP6f8AY/8AEe9jpxOHXH3vq/Uj3o8D17rj + 7T9WHHqYn1H++/HvXTB4nrz/AKv9t7ej+Hq68OuPtzq3WcfpH+sP9691b4T17rr2z1vr3v3XupQ+nvXT + TfF1kT8/7D21J5dVHXP231vrnH+r/Yf8T791o8D13/b/AOQv+J966Z6lH9H+wHts8evdYvfuvdZk/SP9 + j/vfva8evdcT+v8A2I93691l9+691737r3XvexxHXuqr/wCaF/x6vWv/AFF7p/3rHe4H97f9ydq/0t1/ + 2r9TT7QfBuf+kj/wS9UQn/mYD/8Ah07Y/wDcg+8YN5/tF6yO2D/kmzfYOjB/K7/i+bl/4Ljf+tKe2b7+ + 2g+z/J0N7P8A5Ikn+mH+AdI/bv8AxYKL/tTS/wDWj2Rbv8A+3ozuP9xYPy6APH/8WrG/+HXQf+7FfYN5 + W/6edZ/81E6HfMv/AE5yX/mk3V0kf+aov+oGl/60r7602v8AyTj/AKT/ACdcqb3/AHJP+n67f6/7E+2Y + PgH2DpGPP7T1hP0Ht1+HVfIdch78nw9X65D2pTgOq9Yn/Uf9h/vXt3r3XBvoffhx68OPUil+o/1/dh1s + 9CRgP1x/8g+34+HTZ6FP8f8AVF/0X7V9V8uv/9k= + + + + + AAABAAEAAAAAAAEAIACCFQAAFgAAAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgEAAAA9ntg7QAAAAFv + ck5UAc+id5oAABU8SURBVHja7V0JeFVFsv4JSwiBQFiSIEQQZBmW4IwKCvh48oBBNgURBGQdGMbH4oCC + LIKijuxDAEUwoGRc4Q0KLiiLLCqyiIBsIgIiq+yyQ0LIq8udAOFW9zn35ia553T95/Pz+/Q7N6er/q6u + qq6uBgQCgUAgEAgEAoFAIBAIBAKBIPdRAFGIQTyqoS6a4mG0xePojI54DK3RHA1wF+5AHKIRgTwiLLcg + HCVRldTbD2OQjCXYjH34DSdwBudwARdxGZfo3+dxFqdwFAexA19jDhIxGO1wN9EhUkToTESiPBpjEN7F + dzhE6r2KdD+fCziGbfiYiPMEapFdEKvgCORFLB7AEHyCPTjtt9L55zLZjK8xEe1REQVFxKGKPGSwm2MK + NuJkkBR/63MRu/EBniQfQmgQYihG5v6f2ECmPj3bnyv4lWjQBbcjTAQfCvO+Ejl4S/B7Dqg+87KwDeNR + T5zE3A3r7sU4/IS0HFb+jec45uFRFBdV5EZ49yBmkX+fnuvPOSxDNwo2BTk48+uT8o+FgPIznktYgc5i + CXJmza+F6TgSBKVdpaUjldbyFHLr0oISIyzCI4gQFWUn4vEcxfeBqfss0WYnVmIOEWgMhqI/BXQ90RU9 + 0Bt9MQgvYyr+RUrcjIM4RdQI5K+cRjJqS3SQPSiI9ljr91y9QEHbEryKv6MFaqL0tUx/XqV1Cb+2W1CJ + /IueRJJ52I6Tfv/FfRhJf0cQZPyB5u1pv8K0A1iIUeSjVyalBjYnC5Ei66EP3qKQz58MQxrZmebIL0oL + 3tzvjK1+qH4XZqMLUaZIkP5+fpQlhY7GGj8oeIIC1DKiumCgPBlwu/PvIN4h1VekOCE7UBKNMB5biGL2 + vI7laCBbSFn1+Rtjlc1AbC1G4E+0imf3F8UTxebTDLfzVQfI9ygsagwUEeSnH7Ah5jPku3fNUccrktzE + GdhvKzhMIsoIAkAsEnHeRh5uAVqhaC58X37cjcm2CLqUQkOBn6iMjyyLOC7RzH+MfPzcQz7cg9dt5CS3 + o6V4A/7gXnxl6WJtQu+QSL4WQEMi6wWL7z2EXhIY2kUTy6DvCAVlFbIwbyNp0ShJi0wcbiPfIRalEE3O + WuAOZBS6YaPFN/+OZyVRbAetsNuiIGMxhWP5/M4lxKAGGeK+eBkzacYuw3qi2Q76WzvJQG8ki/Mp3sYE + PIPHacUuE4DvXonCVX1VwnmMQiFRsD7Iaot9WiEexUiar/4ovhxaYDjeIyX/hrM2ErsXcZxI8RnG4gmi + jD8eRjh9/UaL3x4TtPSUK/EoDmoFuBbNlJn8W1EYCTTf55AyzwVc9XMQS8hiNCXrYRdVMZvUrPvN8ZIZ + UKElftWKLhkVbQZoldEHC8nxuhKU3f4zWEc+x3/ZnLuFMYBsjS52eUl8AQ5/1q79xzHUljkuSvN1JvYE + SfWZs/sL8ReUtfENYbTobNLuUA7PpmS1g1EH2zQi24P2Nkx/cXTE50E7DcA9KbTGjyAzbx3TJ+ALrU35 + X6kayJz2+Vojrg0UaVshGp2x1DIaD87zE17AnZZfFE9RxRVNINtW1H4j6fuRRtwrUMvS029BM/9ijlYB + bkF/S9ewOCZrdg53kVchgGfLZ7Im6buYDK4e1ZGU46cCPE8qlpPbqk8eFSHnUW2VvrVhRwyI/J/UbPl8 + ZiGiKPL2d+RiNfApTEMlC3qP1FDgHRQznQCNNftpiy3CvgS8R0GVfypLIwfsCJnfdRThz8dcvI8P8CEt + IKuwncLGUzaLPW5+vkdrbZY/Av9QfmUKuZT5TFZ/eTKD6rW/qjbW70Aq8+f4xh5S80SyNw+hJsqgBAWM + kaScgvQUIlNdHHHkijZAV4wiSmzBST8OlJ/EK9qDIYXp76Yow9uW5qq/IF7TzKtaWvfqRZqt9tRzDMvw + Mom5vO0kbEEiQ30MxP9hr1Jxt+5PfES00mUnZioJ9Z25nkBXZa3fHjyoee8OMv126vbP4hsMx30Br7MR + qIKemKfN6914NtJypkZpLFC+mWTmFlE1ZernONpr3vsjvrShjsNIpuCwRBC+sxDuoVV8q43c4q94QpOu + qoo1yuWpi4nBX5Iy5z9UI8b62GCjNvhV1A5qeWgesjoDsN6SBCfQT+MQPqjc6/iB/A/D0I68cV4Yb2ly + /g21CWOvCt6gGZs9nnU8nsGPlofDBmv6h/RULnqvZns9c0ghXmkOV2sqfe6zEH8K+flNslmQVZFoURJ+ + Dv2Vef5wTFI4gyfR3KTkz3OKwoyjFKSps2ofaQW/l4x0iRz4+vxohq+0QeKv+JPy7bJYqXhrUY58fUjg + j4oTvlcwUrP61yXnUB2GLaT/n3Mog/Ha9PNwzbsNFW0tLuNvZqi/AGYoM3+67ZUuyizdGYz1o2YnWKPo + iJ1KAszW7PeHYYTCmdxErqYBeIAMPb9B2kj73hOKhOp+9Mil8oo6WKEgwJva5HAclitK3YeZkP2brRj8 + aIuSj3tZ4mylFTn3UAFzWW9mkMV7Dykcye0WW0suQEPFSr7R0vwVwjs+b62jyCB3EYOZPgZ9J6pbLiDT + FNPgeXefICpAUT5fKNnLxts1sDbTWyvJncx9RGNKpsXpGLraeCsBu1hJ/Giz8NWhqI3D7LC/sHnIqzpm + 0Zp/lty+vST2UBFVYfTFBooKzpF1+xIP2yxcH8YuHml42r3qD8NExaZNG9u/EY5qaE5raOUQO2lXGv9N + qq/jx8ZTOUXl8Fr3dhiqjJ/ZIS8w9LTMADYcvOzeraH+rNE7g1YwE/GKja357uxAXAxL2eF+nivtHUID + z7Ip5aO4342DbcwmTy+ZuBd+06LIZxNfcV8wGIZEhcsTZzABwjBecRTGdVK5DT+wQx0Gs1GXbTBzzn2l + oo+w1f8HLE/9uB2RilrBye46O5gXUxUHI8JhOnqwlcc/kM10EWLZzhmX0AmCimx25KymNMaBaMhGAD+Z + sf9tgfyK/ZGX3DTI4ewQZ0njtGvoxFY6LMnVDohBdnQ+MSvl6fcisIftLJjglgHewQ5wn+XBb1MQgX+z + E6SzWwbYjK2G/0S6ZV3H02xKeLxbhjeE9QBGiN6voz573e1id3gB4XiXzXW1Er1fRxy2sCcdKrhhcCXx + HXt4Qtqj3DxJ3mOPmTVyw+CqsgchFrsnyMm2ZfKKO46KNGddwKnSJy8T2rB7JRPcMLR+jId7FU+JzjMh + gb0N9UM3tI4Yw2a6W4jOMyGG3S5f6/wDowWQzB4DqyE6z4TCbLZ0L253+sCKYgkzsJ1yueotyMsemT2G + e5xv2jYzA1spDRJ98Lw7l8p49gaQOdIx3we9mVMCLtgPqM42WXvd9r0f5qAd01L2Kvo6fVj12IPQY0Tf + Pvgze9PBc04fVlO2G9hQ0bcP6rAH58c6fVgPM1c2XUV/0bcParCpoESnHxFpy6xsV/Ck6NsHVdij8685 + PWXegbnJIxU9Rd8+qMBemZfk9HbynZmCxxR0E3374Hb25oS3nF4425ElQA/Rtw/KsxbA8ZXTj7E+QG/R + tw8qsXUT052eMWnN7HO7IL2RDajGpsxedboTyJeDDBJ9++Bu9pzwRKcPqwF7tcvLom8f8MfnXnD6sO5i + +3tOdXc7xKAtlukY6PRh3cEGN2/LsXAfdGeOibsgYxLHXuy4SGqCffAsI6fzfnRQDFFEs9dCb87x9u6h + jjyYzN4jUs/pA4vAXPZap0qic1tyutP5zE5k79x9UHSeCcWxmm2GH+v8oQ1mb96W7aDMqIT9jJwWuqGJ + bjv29mypCcqMJmw90DQ3nJ/iM1zzzLwuVYk+Ad084pBAcBt7OUoZ0fp15MXr7gwCPYjEx6wb2ED0fpML + uIrtElTdHcMbzd6M0U/0fh012XKw1TbvUQl5dGDboCXn0mVvoYhubLfQmU4vB8tADZbf2xEvmr+GfOy5 + QBfZSD4dfNak65It3ORN7D3orrk2Io/isqjRontNDmA9SrlniG3ZZNBaNw0xC9NjHDs9prvFA/CgAnaz + XbCaiP4Rw3ZRc1kn9YL4gGX5BKkMUlRN7nZbG71eSGWGucX5LVCyHAFMZ6fG+zRpXIUq+IVtiNzNcAJU + YRfHFPftlvK9MD2XJJrdMvop9vbQXW7so9qF5jtX9NTQYPWXwjfmXKURz7aL8px/NffeEO7stGt2AX3j + 3TEsAQ46vxVagIjCp6xEVrk1P1KPLQ1JxxQ3pTz8QBs2ALzq3oNzhTBHYQNqG6j+oviMlcYe/MG9g36E + 5bwn7Wne1nB79ihYOia5uYVeNNs41tMStZFh6o/FSlYSh1HH3QPvyhaHpGMBmUSTMJDNjHoCQJfbwpJY + xg78ArobpP7q7IlJTxf1B9w/+E7s1rDnuuTKhqi/IN5gJZCOGSb4QtFYpBj+a4YcGm/Hdk81KBpqxfbC + SKf/2taA0Vdg9/89zzhTWmhHYLZCBBtdf51shGL713MQ1JQlkFCbvUXAWyzu7t3BnoroP8WszmlhGMme + hUvHRQqQ3HuhXD129997DrgEjEJprFCI4ohrbxQrpxzzbyb2S3iI7Y/vDQgTXDjeKMxSjDcNL5l4g0p+ + jGUvTfc2kSrnstGG40W2IMbzLMNtMBKl8aVCJOl41y0HI//j8zyp2AbzRP8Gt8tpwDZG8TaUnuyG9ij/ + QQf2NhCv9z/Y5FuU8+AptijKWzE8FpGuGGVrJc3T8Z7pNyhGKhMjnpDwRRc0kmnBFsR7n3UmJX9UKIul + GgqMdnhiqLVG/QfkaJwXtbFdKaTL+KdjjWQYrf0HlCM7jZ5yMC4DzTWCSqH42YlhUjh5/kc0xH5BOqTc + jB6KHUJvnezHjtskisIoZeDneY6jqSg9c1posGKbxPuswf84aDTl8KYy7ZPxbHJ+I+jgoiAZxYsage3H + Xx1yYvZ+LLdQfkbK2x4FIhFLjwGNNQthjHbenEViyDeWKoReyh0/zgrUtfi9IuiK+diGrZiHji7Ji2iH + O05RNZzhDXxFS0HoZs4q4g3tQuYvBWIw4yareB5T3b9pHEnOk16Eh2ipCMWooCAeUxZ7BeYLxCD5lu2y + K5iJku73BYYpiiZvbJ+uRLMQKyCtRnP1dADq9/oCdRXqT2PGPsv9VqCANoLO6CswI2SqBmIxAD9afO9l + ZfUDTwFe/RlWwPUUCMOj2GU5c3ZhOMrn8pcWRXvy+VMtvvQ0LVtNsNE2BdTqN4YCwAOK7hmZDeImPJ1r + jaaK4GF8ZsPpO4Ce17J+ddmOoL6+gF79xvgCHp/6bct0ikcYGzAEVXM4NiiJx/Gpha/ifb6juZ+R86+r + tQJeClir30t9IyhQlIz8cRtCvkrLwUQSb07sHOZDZfQjN/SCje9KwbuockuSSG8FWmK2DfUb4w56xN3S + dnB1DAvwF7Ib2bfJUgrNMR272c5eXLHXYObMs34h+N3mb3ttX5IZxeSe9Mo5m0JJIVuQjE70TkRQaRhH + hnw01mo3eDLPz2VoqFiW9BTw5zHEHfQkWLv4JbRL2IN/YyDqo3SWiJAX0aiJbhRybvIryv8NL2mTVcGk + QJIpR0oqYSp7Fb3OMziJbZiDYWiDBIrWC9uqvs9DlClOf60J+uA1fIXD7G0eOhv0Oc19q7/kHwUuaLbJ + jLECnhKL5lik3StQPedxBJvxCc3k59Eb7Ui5dVCD3LMKiEd5UnY13E1Ka43ueBaJmIvV2E8zPi2Av7QV + fW2qwz4FTqE/ntFYIIOsgOd+rb+S4NKyZDQvkDCPEyUOk5t2gP45RCb7GLlf5/2c675O3zi/ijztUeAU + USof8mOAlgIzTTpbWJ7m6VblqaLceY6So3qf3we87scGi9/9/Zr6vQnyv2spMMuEvMDNkcEI/JglSxC8 + 5zDeRIMAg8+WmlI47+y/0UhXbwUMyQvc7KxVpDnxbUA+QbCeq/iFXNP7A848xOAtTdx/Y/ZnQKyAD+Io + QPyQDHDOK/88kW8wuY+Bt7nVJ31P+ajf2goYskdwKyJpDr6C720nabL6pGIXzbU2WWzpHIN/adXfR0Gt + /BioXQiSTGs1kbEgxFGQmIgfspUGngTT++hFvn5WW9wHMvtvtgJnJCLgEIbb0AwvYgmFdpeDqPg0nMB6 + vI5OuDMolcmBzv4bvsBALQWSzKWAF1FIQGeMxyLsJXN5JQvr/CGsphnVjxaZUkHr4pFV9QsF/CBCBTTC + 3zCBHMW1RIZjtEBc1mQQUknlJ0npW7EQ0zCI1vnqKB7k2wyCoX6hQADbSSVwO+5BC7IMffEcxpK/MI2E + NJvcuekUyk3ECyTQnngU9VAJsSiSTQUmRTBDQ0D76hcKBMFtDCNhFyCXKm8OVhN11Wzr+Kf+DArIHoGj + Atb5AXr+uohA9ggcg1hsU274PhWgk1lAKOAkAmxV9kIZFHBuQRLEDnJF5ykVdYbW80D3FGSbyDHooDlH + kBUKyELgGDdwiiYxJRQwAMUxQ0uBp7NAAfEFHEKB6dlEgfxaCqThTaGAUEAoIBQQ8QsFBEIBgVBAIBQQ + CAUEQgGBUEAgFBAIBQRCAYFQQCAUEAgFBEIBgVBAIBQQCAUEQgGBUEAgFBAIBQQ5ToE3suk0kdWZwpmI + FvGHBgVy5zRRKia5/7ZSd1Agu84UXiRyhYn4TV4IDqOxCN/shWBpFnuiChxuBVLRT0RvthX4HmVF9O6n + gDovkIpeIvjQQQkkZVtEMETRx3CBhINmUCASM9nfPIRaInYz3MHq+Im9DK+7CN0UK/AP9hcnXb8CW+By + K1AfJ5nfmy9egCkUiGEvuV8ne4OmUIBvab0DcSJuMygQjneYX9qLMiJsMygQgbnM7/yM0iJqMygQjW+Y + X9kkW0KmUKA6DjK/sQhRImYzKNAHqcwvJAX58ixBiFKgFFawtyQPEAGbQYGBSGFvNGog4nUCSmSRAk1x + gH3zW0kDOccK6PcIhqKw8t2HsEPx3vMiWLcsBBcxG3cxlb6lMVgx+9Oxj94QOGohSNLemPwLpqAFylPE + H4ViiENdDMEa1vf3PokSATiPAjMsLs0+iz1YhS+wHNtxQnOdbTp2ooYI1IkLwfQs3Jt+47kkNcHOpcCM + IFAgGUVElOZSYBkqiBidToHUgNW/RkpBnY9imKC5sl4/+xNEfG5AJAbikN+uX7IYf/cgDI2wiM3xqwK/ + fuL6uQ0l0QfrbfgD+zAZNUVc7kQZ9MQ8HGRtwVWcIqdvFO6SrJ+7UYhcu+6YhPlYhx3Yi5+xiZaHJAxA + A9nxMwd5yDUsgTiyCaVRClEy6wUCgUAgEAgEAoFAIBAIBAKBQCAQCAQCgUCgwP8DypPqTUXuN1EAAAAA + SUVORK5CYII= + + + \ No newline at end of file