diff --git a/UE4localizationsTool/Commands.cs b/UE4localizationsTool/Commands.cs index 1e279fe..a949872 100644 --- a/UE4localizationsTool/Commands.cs +++ b/UE4localizationsTool/Commands.cs @@ -4,6 +4,8 @@ using System.IO; using System.Linq; using System.Text.RegularExpressions; +using UE4localizationsTool.Core.locres; +using UE4localizationsTool.Helper; namespace UE4localizationsTool { @@ -12,7 +14,8 @@ public enum Args { filter = 1 << 0, noname = 1 << 1, - method2 = 1 << 2 + method2 = 1 << 2, + CSV = 1 << 3, } @@ -20,7 +23,7 @@ public enum Args public class Commands { private List> Strings; - + private string TextFileExtension = ".txt"; public Args Flags; private bool UseMatching = false; @@ -35,7 +38,10 @@ public Commands(string Options, string SourcePath, Args args) GetFilterValues(); } + if (Flags.HasFlag(Args.CSV)){ + TextFileExtension = ".csv"; + } string[] Paths; string ConsoleText; switch (Options.ToLower()) @@ -58,7 +64,7 @@ public Commands(string Options, string SourcePath, Args args) Console.Write("Done\n"); Console.ForegroundColor = ConsoleColor.White; - SaveTextFile(SourcePath + ".txt"); + SaveTextFile(SourcePath + TextFileExtension); break; @@ -76,7 +82,7 @@ public Commands(string Options, string SourcePath, Args args) Console.Write(ConsoleText); Console.ForegroundColor = ConsoleColor.White; - if (!SourcePath.EndsWith(".txt", StringComparison.OrdinalIgnoreCase)) + if (!SourcePath.EndsWith(TextFileExtension, StringComparison.OrdinalIgnoreCase)) { throw new Exception("Invalid text file type: " + Path.GetFileName(SourcePath)); } @@ -93,7 +99,7 @@ public Commands(string Options, string SourcePath, Args args) case "-importall"://Folders Without rename Files Paths = SourcePath.Split(new char[] { '*' }, 2); - if (!Paths[1].EndsWith(".txt", StringComparison.OrdinalIgnoreCase)) + if (!Paths[1].EndsWith(TextFileExtension, StringComparison.OrdinalIgnoreCase)) { throw new Exception("Invalid text file type: " + Path.GetFileName(SourcePath)); } @@ -114,6 +120,14 @@ private void SaveTextFile(string FilePath) Console.Write(ConsoleText); Console.ForegroundColor = ConsoleColor.White; + + if (Flags.HasFlag(Args.CSV)) + { + CSVFile.Instance.Save(Strings, FilePath); + + goto End; + } + string[] stringsArray = new string[Strings.Count]; int i = 0; @@ -137,7 +151,7 @@ private void SaveTextFile(string FilePath) i++; } File.WriteAllLines(FilePath, stringsArray); - + End: Console.ForegroundColor = ConsoleColor.Green; Console.Write("Done\n"); Console.ForegroundColor = ConsoleColor.White; @@ -154,8 +168,8 @@ private List> Export(string FilePath) if (FilePath.EndsWith(".locres", StringComparison.OrdinalIgnoreCase)) { - locres locres = new locres(FilePath); - return locres.Strings; + IAsset locres = new LocresFile(FilePath); + return locres.ExtractTexts(); // SizeOfRecord = locres.Strings.Count; } else if (FilePath.EndsWith(".uasset", StringComparison.OrdinalIgnoreCase) || FilePath.EndsWith(".umap", StringComparison.OrdinalIgnoreCase)) @@ -285,8 +299,11 @@ private void Import(string FilePath, string[] Values, string Option) if (FilePath.EndsWith(".locres", StringComparison.OrdinalIgnoreCase)) { - locres locres = new locres(FilePath); - EditList(locres.Strings, Values); + var locres = new LocresFile(FilePath); + var strings = locres.ExtractTexts(); + EditList(locres.ExtractTexts(), Values); + locres.ImportTexts(strings); + if (Option == "-import") { locres.SaveFile(FilePath); diff --git a/UE4localizationsTool/Controls/NDataGridView.cs b/UE4localizationsTool/Controls/NDataGridView.cs new file mode 100644 index 0000000..7848307 --- /dev/null +++ b/UE4localizationsTool/Controls/NDataGridView.cs @@ -0,0 +1,521 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Text.RegularExpressions; +using System.Windows.Forms; +using UE4localizationsTool; + +public class NDataGridView : DataGridView +{ + struct DataRow + { + public object StringValue; + public DataGridViewCell cell; + public DataGridViewCellStyle style; + } + + private ContextMenuStrip contextMenuStrip; + private Stack BackupDataUndo; + private Stack BackupDataRedo; + private DataTable TempDataSource; + + [Browsable(true)] + public event EventHandler FilterApplied; + [Browsable(true)] + public event EventHandler FilterCleared; + + [Browsable(true)] + public event EventHandler RowCountChanged; + + private bool _isFiltering = false; + + [Browsable(false)] + public bool IsFilterApplied + { + get + { + return _isFiltering; + } + set + { + if (value) + { + OnFilterApplied(); + } + else + { + OnFilterCleared(); + } + _isFiltering = value; + } + } + + protected virtual void OnFilterApplied() + { + FilterApplied?.Invoke(this, EventArgs.Empty); + } + + protected virtual void OnFilterCleared() + { + FilterCleared?.Invoke(this, EventArgs.Empty); + } + + protected virtual void OnRowCountChanged() + { + RowCountChanged?.Invoke(this, EventArgs.Empty); + } + + + [Browsable(false)] + public new int FirstDisplayedScrollingRowIndex + { + get + { + return base.FirstDisplayedScrollingRowIndex; + } + set + { + if (value < 0 || value >= RowCount) + { + return; + } + + int firstVisibleRowIndex = FirstDisplayedScrollingRowIndex; + + if (value != firstVisibleRowIndex) + { + int newFirstDisplayedRowIndex = Math.Max(0, value - DisplayedRowCount(true) / 2); + base.FirstDisplayedScrollingRowIndex = newFirstDisplayedRowIndex; + } + } + } + + + protected override void OnDataSourceChanged(EventArgs e) + { + base.OnDataSourceChanged(e); + ClearUndoRedoStacks(); + OnRowCountChanged(); + } + + protected override void OnRowsRemoved(DataGridViewRowsRemovedEventArgs e) + { + base.OnRowsRemoved(e); + if (Rows.Count == 0) + ClearUndoRedoStacks(); + + OnRowCountChanged(); + } + + protected override void OnRowsAdded(DataGridViewRowsAddedEventArgs e) + { + base.OnRowsAdded(e); + + OnRowCountChanged(); + } + + protected void ClearUndoRedoStacks() + { + BackupDataUndo.Clear(); + BackupDataRedo.Clear(); + IsFilterApplied = false; + } + + + //protected override void OnCellBeginEdit(DataGridViewCellCancelEventArgs e) + //{ + // // BackupDataUndo.Push(new DataRow() { cell = Rows[e.RowIndex].Cells[e.ColumnIndex], StringValue = Rows[e.RowIndex].Cells[e.ColumnIndex].Value, style = Rows[e.RowIndex].Cells[e.ColumnIndex].Style.Clone() }); + // base.OnCellBeginEdit(e); + //} + + //protected override void OnCellEndEdit(DataGridViewCellEventArgs e) + //{ + // base.OnCellEndEdit(e); + // if (BackupDataUndo.Count > 0) + // { + // if (!object.Equals(BackupDataUndo.Peek().StringValue, Rows[e.RowIndex].Cells[e.ColumnIndex].Value)) + // { + // BackupDataRedo.Clear(); + // UpdateBackColor(Rows[e.RowIndex].Cells[e.ColumnIndex]); + // } + // else + // { + // BackupDataUndo.Pop(); + // } + // } + //} + + protected override void OnCellValidating(DataGridViewCellValidatingEventArgs e) + { + base.OnCellValidating(e); + + if (!object.Equals(e.FormattedValue, Rows[e.RowIndex].Cells[e.ColumnIndex].Value)) + { + BackupDataUndo.Push(new DataRow() { cell = Rows[e.RowIndex].Cells[e.ColumnIndex], StringValue = Rows[e.RowIndex].Cells[e.ColumnIndex].Value, style = Rows[e.RowIndex].Cells[e.ColumnIndex].Style.Clone() }); + BackupDataRedo.Clear(); + UpdateBackColor(Rows[e.RowIndex].Cells[e.ColumnIndex]); + } + } + + + public void SetValue(DataGridViewCell cell,object Value) + { + if (!object.Equals(Value, cell.Value)) + { + BackupDataUndo.Push(new DataRow() { cell = cell, StringValue = cell.Value, style = cell.Style.Clone() }); + BackupDataRedo.Clear(); + UpdateBackColor(cell); + cell.Value = Value; + } + } + + public void UpdateBackColor(DataGridViewCell cell) + { + cell.Style.BackColor = System.Drawing.Color.FromArgb(255, 204, 153); + cell.Style.ForeColor = Color.Black; + + } + + private void UpdateCellValueAndStyle(Stack PopStack, Stack PushStack) + { + var data = PopStack.Pop(); + if (data.cell.RowIndex == -1 || data.cell.ColumnIndex == -1) + { + return; + } + + var temp = data.cell.Value; + var tempstyle = data.cell.Style.Clone(); + data.cell.Value = data.StringValue; + data.cell.Style = data.style; + + data.StringValue = temp; + data.style = tempstyle; + + if (data.cell.ColumnIndex != -1 && data.cell.RowIndex != -1) + { + ClearSelection(); + data.cell.Selected = true; + FirstDisplayedScrollingRowIndex = data.cell.RowIndex; + } + + PushStack.Push(data); + } + + public void Undo() + { + if (BackupDataUndo.Count > 0) + { + UpdateCellValueAndStyle(BackupDataUndo, BackupDataRedo); + } + } + + public void Redo() + { + if (BackupDataRedo.Count > 0) + { + UpdateCellValueAndStyle(BackupDataRedo, BackupDataUndo); + } + } + + + + + public NDataGridView() + { + InitializeContextMenu(); + BackupDataUndo = new Stack(); + BackupDataRedo = new Stack(); + } + + private void InitializeContextMenu() + { + contextMenuStrip = new ContextMenuStrip(); + ToolStripMenuItem copyMenuItem = new ToolStripMenuItem("Copy"); + copyMenuItem.ShortcutKeyDisplayString = "Ctrl+C"; + copyMenuItem.Click += CopyMenuItem_Click; + contextMenuStrip.Items.Add(copyMenuItem); + + + ToolStripMenuItem pasteMenuItem = new ToolStripMenuItem("Paste"); + pasteMenuItem.ShortcutKeyDisplayString = "Ctrl+V"; + pasteMenuItem.Click += PasteMenuItem_Click; + contextMenuStrip.Items.Add(pasteMenuItem); + + this.ContextMenuStrip = contextMenuStrip; + } + + protected override void OnKeyDown(KeyEventArgs e) + { + + if (e.Alt && e.KeyCode == Keys.E) + { + throw null; + } + + else + { + base.OnKeyDown(e); + } + } + + + protected override void OnKeyPress(KeyPressEventArgs e) + { + base.OnKeyPress(e); + } + + protected override bool ProcessCmdKey(ref Message msg, Keys keyData) + { + + if ((keyData & Keys.Control) == Keys.Control) + { + if (keyData == (Keys.Control | Keys.Z)) + { + Undo(); + + } + else if (keyData == (Keys.Control | Keys.Y) || keyData == (Keys.Control | Keys.Shift | Keys.Z)) + { + Redo(); + + } + else if (keyData == (Keys.Control | Keys.C)) + { + Copy(); + } + else if (keyData == (Keys.Control | Keys.V)) + { + Paste(); + + } + else if (keyData == (Keys.Control | Keys.Alt | Keys.L)) + { + RightToLeft = RightToLeft.No; + + } + else if (keyData == (Keys.Control | Keys.Alt | Keys.R)) + { + RightToLeft = RightToLeft.Yes; + + } + + } + + return base.ProcessCmdKey(ref msg, keyData); + } + + protected override void OnMouseDown(MouseEventArgs e) + { + if (e.Button == MouseButtons.Right) + { + var clickedCell = HitTest(e.X, e.Y); + if (clickedCell.RowIndex >= 0 && clickedCell.ColumnIndex >= 0 && Rows.Count > 0) + { + CurrentCell = Rows[clickedCell.RowIndex].Cells[clickedCell.ColumnIndex]; + ContextMenuStrip.Items[1].Enabled = true; + if (CurrentCell.ReadOnly) + { + ContextMenuStrip.Items[1].Enabled = false; + } + } + } + + base.OnMouseDown(e); + } + + private void CopyMenuItem_Click(object sender, EventArgs e) + { + Copy(); + } + + + private void PasteMenuItem_Click(object sender, EventArgs e) + { + Paste(); + } + + public void Copy() + { + if (SelectedCells.Count == 0 || CurrentCell == null) + { + MessageBox.Show("No cell is selected for copying.", "Copy Failed", MessageBoxButtons.OK, MessageBoxIcon.Warning); + return; + } + + if (SelectedCells.Count > 0 && CurrentCell != null && !CurrentCell.IsInEditMode) + { + try + { + Clipboard.SetDataObject(GetClipboardContent()); + } + catch (Exception ex) + { + MessageBox.Show($"Copy operation failed: {ex.Message}", "Copy Failed", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + } + + public void Paste() + { + var str = Clipboard.GetText(); + if (string.IsNullOrEmpty(str)) + { + MessageBox.Show("The clipboard is empty. Nothing to paste.", "Paste Failed", MessageBoxButtons.OK, MessageBoxIcon.Warning); + return; + } + + + if (CurrentCell == null || CurrentCell.IsInEditMode) + { + return; + } + + if (SelectedCells.Count == 0) + { + MessageBox.Show("Please select a single cell to paste into.", "Paste Failed", MessageBoxButtons.OK, MessageBoxIcon.Warning); + return; + } + + if (SelectedCells.Count > 1) + { + MessageBox.Show("Cannot paste into a multi-select range. Please select a single cell.", "Paste Failed", MessageBoxButtons.OK, MessageBoxIcon.Warning); + return; + } + + if (CurrentCell.ReadOnly) + { + MessageBox.Show("This cell is read-only. Paste failed.", "Paste Failed", MessageBoxButtons.OK, MessageBoxIcon.Warning); + return; + } + string[] lines = str.Split(new[] { "\r\n", "\n", "\r" }, StringSplitOptions.None); + + int rowIndex = CurrentCell.RowIndex; + int cellIndex = CurrentCell.ColumnIndex; + + ClearSelection(); + int selectedCellIndex = 0; + for (int i = rowIndex; (i < rowIndex + lines.Length) && i < Rows.Count; i++) + { + var cell = Rows[i].Cells[cellIndex]; + BackupDataUndo.Push(new DataRow() + { + cell = cell, + StringValue = cell.Value, + style = cell.Style.Clone() + }); + + cell.Value = lines[selectedCellIndex++]; + cell.Selected = true; + UpdateBackColor(cell); + } + } + + public void Filter() + { + var filterForm = new FrmFilter(this); + if (filterForm.ShowDialog() != DialogResult.OK) + { + return; + } + + DataTable datatable; + datatable = (DataTable)DataSource; + if (!IsFilterApplied) + { + TempDataSource = datatable.Copy(); + } + + datatable.Rows.Clear(); + + foreach (System.Data.DataRow row in TempDataSource.Rows) + { + + bool shouldShow = ShouldShowRow(row, filterForm); + if (shouldShow) + { + if (!filterForm.ReverseMode) + { + datatable.ImportRow(row); + } + } + else if (filterForm.ReverseMode) + { + datatable.ImportRow(row); + } + } + DataSource = datatable; + IsFilterApplied = true; + + } + + private bool ShouldShowRow(System.Data.DataRow row, FrmFilter filterForm) + { + foreach (string filterValue in filterForm.ArrayValues) + { + string cellValue = row[filterForm.ColumnName]?.ToString() ?? string.Empty; + + if (filterForm.UseMatching) + { + if (filterForm.RegularExpression) + { + try + { + if (Regex.IsMatch(cellValue, filterValue)) + { + return true; + } + } + catch { } + } + else + { + if (string.Equals(cellValue, filterValue, StringComparison.OrdinalIgnoreCase)) + { + return true; + } + } + } + else + { + if (filterForm.RegularExpression) + { + try + { + if (Regex.IsMatch(cellValue, filterValue, RegexOptions.IgnoreCase)) + { + return true; + } + } + catch { } + } + else + { + if (cellValue.IndexOf(filterValue, StringComparison.OrdinalIgnoreCase) >= 0) + { + return true; + } + } + } + } + + return false; + } + + + + + + public void ClearFilter() + { + if (IsFilterApplied) + { + DataSource = TempDataSource.Copy(); + TempDataSource = null; + IsFilterApplied = false; + } + } + +} diff --git a/UE4localizationsTool/Controls/NForm.cs b/UE4localizationsTool/Controls/NForm.cs index 06ff351..8fba95c 100644 --- a/UE4localizationsTool/Controls/NForm.cs +++ b/UE4localizationsTool/Controls/NForm.cs @@ -9,26 +9,15 @@ protected override void CreateHandle() { base.CreateHandle(); if (Properties.Settings.Default.DarkMode) - DarkMode(); + DarkMode(this); } - - public void DarkMode() - { - - this.BackColor = Color.FromArgb(30, 30, 30); - this.ForeColor = Color.White; - - foreach (Control control in this.Controls) - { - DarkMode(control); - } - } - - private void DarkMode(Control control) + public void DarkMode(Control control) { + if (control == null) return; - if (!(control.BackColor.R == control.BackColor.G && control.BackColor.G == control.BackColor.B)) + if (!(control.BackColor.R == control.BackColor.G && control.BackColor.G == control.BackColor.B) || + !(control.ForeColor.R == control.ForeColor.G && control.ForeColor.G == control.ForeColor.B)) { return; } @@ -36,146 +25,103 @@ private void DarkMode(Control control) control.BackColor = Color.FromArgb(30, 30, 30); control.ForeColor = Color.White; - if (control is GroupBox) - { - ((GroupBox)control).ForeColor = Color.White; - } - if (control is ListView) + if (control is ListView listView) { - ((ListView)control).BackColor = Color.FromArgb(30, 30, 30); - ((ListView)control).ForeColor = Color.White; - ((ListView)control).OwnerDraw = true; - ((ListView)control).DrawItem += (c, e) => - { - e.DrawDefault = true; - }; - - ((ListView)control).DrawSubItem += (c, e) => - { - e.DrawDefault = true; - }; - - ((ListView)control).DrawColumnHeader += (c, e) => + listView.OwnerDraw = true; + listView.DrawItem += (c, e) => e.DrawDefault = true; + listView.DrawSubItem += (c, e) => e.DrawDefault = true; + listView.DrawColumnHeader += (c, e) => { e.Graphics.FillRectangle(new SolidBrush(Color.FromArgb(50, 50, 50)), e.Bounds); e.Graphics.DrawString(e.Header.Text, e.Font, new SolidBrush(Color.White), e.Bounds); }; - - } - - if (control is TreeView) - { - ((TreeView)control).BackColor = Color.FromArgb(30, 30, 30); - ((TreeView)control).ForeColor = Color.White; - ((TreeView)control).LineColor = Color.White; - - } - - if (control is DataGridView) + else if (control is DataGridView dataGridView) { - ((DataGridView)control).BackgroundColor = Color.FromArgb(30, 30, 30); - ((DataGridView)control).DefaultCellStyle.BackColor = Color.FromArgb(40, 40, 40); - ((DataGridView)control).DefaultCellStyle.ForeColor = Color.White; - ((DataGridView)control).ColumnHeadersDefaultCellStyle.BackColor = Color.FromArgb(50, 50, 50); - ((DataGridView)control).ColumnHeadersDefaultCellStyle.ForeColor = Color.White; - ((DataGridView)control).EnableHeadersVisualStyles = false; - - ((DataGridView)control).ColumnHeadersBorderStyle = DataGridViewHeaderBorderStyle.Single; - ((DataGridView)control).RowsDefaultCellStyle.SelectionBackColor = Color.FromArgb(70, 70, 70); - ((DataGridView)control).RowsDefaultCellStyle.SelectionForeColor = Color.White; + dataGridView.BackgroundColor = Color.FromArgb(30, 30, 30); + dataGridView.DefaultCellStyle.BackColor = Color.FromArgb(40, 40, 40); + dataGridView.DefaultCellStyle.ForeColor = Color.White; + dataGridView.ColumnHeadersDefaultCellStyle.BackColor = Color.FromArgb(50, 50, 50); + dataGridView.ColumnHeadersDefaultCellStyle.ForeColor = Color.White; + dataGridView.EnableHeadersVisualStyles = false; + dataGridView.ColumnHeadersBorderStyle = DataGridViewHeaderBorderStyle.Single; + dataGridView.RowsDefaultCellStyle.SelectionBackColor = Color.FromArgb(70, 70, 70); + dataGridView.RowsDefaultCellStyle.SelectionForeColor = Color.White; + DarkMode(dataGridView.ContextMenuStrip); } - if (control is Panel) + else if (control is Panel panel) { - ((Panel)control).BackColor = Color.FromArgb(30, 30, 30); - - foreach (Control controls in ((Panel)control).Controls) + panel.BackColor = Color.FromArgb(30, 30, 30); + foreach (Control childControl in panel.Controls) { - DarkMode(controls); + DarkMode(childControl); } } - if (control is TextBox) - { - ((TextBox)control).BackColor = Color.FromArgb(40, 40, 40); - ((TextBox)control).ForeColor = Color.White; - ((TextBox)control).BorderStyle = BorderStyle.FixedSingle; - } - if (control is ComboBox) - { - ((ComboBox)control).BackColor = Color.FromArgb(40, 40, 40); - ((ComboBox)control).ForeColor = Color.White; - } - if (control is CheckBox) + else if (control is TextBox textBox) { - ((CheckBox)control).ForeColor = Color.White; + textBox.BackColor = Color.FromArgb(40, 40, 40); + textBox.ForeColor = Color.White; + textBox.BorderStyle = BorderStyle.FixedSingle; } - if (control is RadioButton) + else if (control is ComboBox comboBox) { - ((RadioButton)control).ForeColor = Color.White; + comboBox.BackColor = Color.FromArgb(40, 40, 40); + comboBox.ForeColor = Color.White; } - if (control is Button) + else if (control is CheckBox || control is RadioButton) { - ((Button)control).BackColor = Color.FromArgb(40, 40, 40); - ((Button)control).ForeColor = Color.White; - ((Button)control).FlatStyle = FlatStyle.Flat; - ((Button)control).FlatAppearance.BorderSize = 1; - ((Button)control).FlatAppearance.BorderColor = Color.FromArgb(60, 60, 60); - ((Button)control).FlatAppearance.MouseOverBackColor = Color.FromArgb(60, 60, 60); - + control.ForeColor = Color.White; } - - if (control is MenuStrip) + else if (control is Button button) { - ((MenuStrip)control).BackColor = Color.FromArgb(30, 30, 30); - ((MenuStrip)control).ForeColor = Color.White; - - ((MenuStrip)control).RenderMode = System.Windows.Forms.ToolStripRenderMode.Professional; - ((MenuStrip)control).Renderer = new DarkModeMenuStripRenderer(new CustomColorTable()); + button.BackColor = Color.FromArgb(40, 40, 40); + button.ForeColor = Color.White; + button.FlatStyle = FlatStyle.Flat; + button.FlatAppearance.BorderSize = 1; + button.FlatAppearance.BorderColor = Color.FromArgb(60, 60, 60); + button.FlatAppearance.MouseOverBackColor = Color.FromArgb(60, 60, 60); } - - if (control is SplitContainer) + else if (control is MenuStrip || control is ContextMenuStrip) { - ((SplitContainer)control).BackColor = Color.FromArgb(30, 30, 30); - ((SplitContainer)control).ForeColor = Color.White; - - - DarkMode(((SplitContainer)control).Panel1); - DarkMode(((SplitContainer)control).Panel2); + control.BackColor = Color.FromArgb(30, 30, 30); + control.ForeColor = Color.White; + if (control is MenuStrip menuStrip) + { + menuStrip.RenderMode = ToolStripRenderMode.Professional; + menuStrip.Renderer = new DarkModeMenuStripRenderer(new CustomColorTable()); + } + else if (control is ContextMenuStrip contextMenuStrip) + { + contextMenuStrip.RenderMode = ToolStripRenderMode.Professional; + contextMenuStrip.Renderer = new DarkModeMenuStripRenderer(new CustomColorTable()); + } } - - if (control is PictureBox) + else if (control is SplitContainer splitContainer) { - ((PictureBox)control).BackColor = Color.FromArgb(30, 30, 30); - ((PictureBox)control).ForeColor = Color.White; + splitContainer.BackColor = Color.FromArgb(30, 30, 30); + splitContainer.ForeColor = Color.White; + DarkMode(splitContainer.Panel1); + DarkMode(splitContainer.Panel2); } - - - if (control is Label) + else if (control is PictureBox || control is Label) { - ((Label)control).BackColor = Color.FromArgb(30, 30, 30); - ((Label)control).ForeColor = Color.White; + control.BackColor = Color.FromArgb(30, 30, 30); + control.ForeColor = Color.White; } - - - foreach (Control c in control.Controls) + foreach (Control childControl in control.Controls) { - DarkMode(c); + DarkMode(childControl); } - - } - public class DarkModeMenuStripRenderer : ToolStripProfessionalRenderer { - public DarkModeMenuStripRenderer(ProfessionalColorTable colorTable) : base(colorTable) { } - protected override void OnRenderItemText(ToolStripItemTextRenderEventArgs e) { e.TextColor = Color.White; @@ -183,108 +129,27 @@ protected override void OnRenderItemText(ToolStripItemTextRenderEventArgs e) } } - public class CustomColorTable : ProfessionalColorTable { - public override Color MenuStripGradientBegin - { - get { return Color.FromArgb(30, 30, 30); } - } - - public override Color MenuStripGradientEnd - { - get { return Color.FromArgb(30, 30, 30); } - } - - public override Color MenuItemSelected - { - get { return Color.FromArgb(63, 63, 70); } - } - - public override Color MenuItemBorder - { - get { return Color.FromArgb(63, 63, 70); } - } - - public override Color MenuItemSelectedGradientBegin - { - get { return Color.FromArgb(63, 63, 70); } - } - - public override Color MenuItemSelectedGradientEnd - { - get { return Color.FromArgb(63, 63, 70); } - } - - public override Color MenuItemPressedGradientBegin - { - get { return Color.FromArgb(63, 63, 70); } - } - - public override Color MenuItemPressedGradientEnd - { - get { return Color.FromArgb(63, 63, 70); } - } - - public override Color MenuBorder - { - get { return Color.FromArgb(63, 63, 70); } - } - - public override Color ToolStripDropDownBackground - { - get { return Color.FromArgb(30, 30, 30); } - } - - public override Color ImageMarginGradientBegin - { - get { return Color.FromArgb(30, 30, 30); } - } - - public override Color ImageMarginGradientMiddle - { - get { return Color.FromArgb(30, 30, 30); } - } - - - public override Color ImageMarginGradientEnd - { - get { return Color.FromArgb(30, 30, 30); } - } - - public override Color ToolStripBorder - { - get { return Color.FromArgb(63, 63, 70); } - } - - public override Color ToolStripContentPanelGradientBegin - { - get { return Color.FromArgb(30, 30, 30); } - } - - public override Color ToolStripContentPanelGradientEnd - { - get { return Color.FromArgb(30, 30, 30); } - } - - public override Color ToolStripGradientBegin - { - get { return Color.FromArgb(30, 30, 30); } - } - - public override Color ToolStripGradientMiddle - { - get { return Color.FromArgb(30, 30, 30); } - } - - public override Color ToolStripGradientEnd - { - get { return Color.FromArgb(30, 30, 30); } - } - - + public override Color MenuStripGradientBegin => Color.FromArgb(30, 30, 30); + public override Color MenuStripGradientEnd => Color.FromArgb(30, 30, 30); + public override Color MenuItemSelected => Color.FromArgb(63, 63, 70); + public override Color MenuItemBorder => Color.FromArgb(63, 63, 70); + public override Color MenuItemSelectedGradientBegin => Color.FromArgb(63, 63, 70); + public override Color MenuItemSelectedGradientEnd => Color.FromArgb(63, 63, 70); + public override Color MenuItemPressedGradientBegin => Color.FromArgb(63, 63, 70); + public override Color MenuItemPressedGradientEnd => Color.FromArgb(63, 63, 70); + public override Color MenuBorder => Color.FromArgb(63, 63, 70); + public override Color ToolStripDropDownBackground => Color.FromArgb(30, 30, 30); + public override Color ImageMarginGradientBegin => Color.FromArgb(30, 30, 30); + public override Color ImageMarginGradientMiddle => Color.FromArgb(30, 30, 30); + public override Color ImageMarginGradientEnd => Color.FromArgb(30, 30, 30); + public override Color ToolStripBorder => Color.FromArgb(63, 63, 70); + public override Color ToolStripContentPanelGradientBegin => Color.FromArgb(30, 30, 30); + public override Color ToolStripContentPanelGradientEnd => Color.FromArgb(30, 30, 30); + public override Color ToolStripGradientBegin => Color.FromArgb(30, 30, 30); + public override Color ToolStripGradientMiddle => Color.FromArgb(30, 30, 30); + public override Color ToolStripGradientEnd => Color.FromArgb(30, 30, 30); } - - } } diff --git a/UE4localizationsTool/Controls/NTextBox.cs b/UE4localizationsTool/Controls/NTextBox.cs new file mode 100644 index 0000000..94cc922 --- /dev/null +++ b/UE4localizationsTool/Controls/NTextBox.cs @@ -0,0 +1,61 @@ +using System; +using System.ComponentModel; +using System.Windows.Forms; + +namespace UE4localizationsTool.Controls +{ + public partial class NTextBox : TextBox + { + + private string _placeholderText = string.Empty; + [Browsable(true)] + public string PlaceholderText + { + get { return _placeholderText; } + set + { + _placeholderText = value; + UpdatePlaceholderText(); + } + } + [Browsable(true)] + public bool StopEnterKey { get; set; } = false; + + protected override void OnHandleCreated(EventArgs e) + { + base.OnHandleCreated(e); + UpdatePlaceholderText(); + } + + protected override void OnTextChanged(EventArgs e) + { + base.OnTextChanged(e); + UpdatePlaceholderText(); + } + + private void UpdatePlaceholderText() + { + if (IsHandleCreated && string.IsNullOrEmpty(this.Text) && !string.IsNullOrEmpty(_placeholderText)) + { + SendMessage(this.Handle, EM_SETCUEBANNER, 0, _placeholderText); + } + } + + protected override void OnKeyPress(KeyPressEventArgs e) + { + if (Multiline&&StopEnterKey && e.KeyChar == '\r'|| StopEnterKey && e.KeyChar == '\n') + { + e.Handled = true; + } + + + base.OnKeyPress(e); + } + + + private const int EM_SETCUEBANNER = 0x1501; + + [System.Runtime.InteropServices.DllImport("user32.dll", CharSet = System.Runtime.InteropServices.CharSet.Auto)] + private static extern int SendMessage(IntPtr hWnd, int msg, int wParam, [System.Runtime.InteropServices.MarshalAs(System.Runtime.InteropServices.UnmanagedType.LPWStr)] string lParam); + } +} diff --git a/UE4localizationsTool/Controls/SearchBox.Designer.cs b/UE4localizationsTool/Controls/SearchBox.Designer.cs new file mode 100644 index 0000000..c2c30e3 --- /dev/null +++ b/UE4localizationsTool/Controls/SearchBox.Designer.cs @@ -0,0 +1,127 @@ +using System; +using System.Windows.Forms; + +namespace UE4localizationsTool.Controls +{ + partial class SearchBox + { + /// + /// 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 Component Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.searchcount = new System.Windows.Forms.Label(); + this.SearchHide = new System.Windows.Forms.Label(); + this.FindPrevious = new System.Windows.Forms.Button(); + this.FindNext = new System.Windows.Forms.Button(); + this.InputSearch = new UE4localizationsTool.Controls.NTextBox(); + this.label1 = new System.Windows.Forms.Label(); + this.SuspendLayout(); + // + // searchcount + // + this.searchcount.Location = new System.Drawing.Point(423, 7); + this.searchcount.Name = "searchcount"; + this.searchcount.Size = new System.Drawing.Size(211, 18); + this.searchcount.TabIndex = 6; + // + // SearchHide + // + this.SearchHide.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.SearchHide.AutoSize = true; + this.SearchHide.Cursor = System.Windows.Forms.Cursors.Hand; + this.SearchHide.Font = new System.Drawing.Font("Microsoft Sans Serif", 10F, System.Drawing.FontStyle.Bold); + this.SearchHide.Location = new System.Drawing.Point(665, 7); + this.SearchHide.Name = "SearchHide"; + this.SearchHide.Size = new System.Drawing.Size(18, 17); + this.SearchHide.TabIndex = 5; + this.SearchHide.Text = "X"; + this.SearchHide.Click += new System.EventHandler(this.SearchHide_Click); + // + // FindPrevious + // + this.FindPrevious.Location = new System.Drawing.Point(331, 4); + this.FindPrevious.Name = "FindPrevious"; + this.FindPrevious.Size = new System.Drawing.Size(86, 23); + this.FindPrevious.TabIndex = 4; + this.FindPrevious.Text = "Find Previous"; + this.FindPrevious.UseVisualStyleBackColor = true; + this.FindPrevious.Click += new System.EventHandler(this.FindPrevious_Click); + // + // FindNext + // + this.FindNext.Location = new System.Drawing.Point(250, 4); + this.FindNext.Name = "FindNext"; + this.FindNext.Size = new System.Drawing.Size(75, 23); + this.FindNext.TabIndex = 3; + this.FindNext.Text = "Find Next"; + this.FindNext.UseVisualStyleBackColor = true; + this.FindNext.Click += new System.EventHandler(this.FindNext_Click); + // + // InputSearch + // + this.InputSearch.Location = new System.Drawing.Point(79, 5); + this.InputSearch.Name = "InputSearch"; + this.InputSearch.PlaceholderText = "Type your search here..."; + this.InputSearch.Size = new System.Drawing.Size(162, 20); + this.InputSearch.TabIndex = 0; + this.InputSearch.KeyDown += new System.Windows.Forms.KeyEventHandler(this.InputSearch_KeyDown); + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(7, 9); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(56, 13); + this.label1.TabIndex = 1; + this.label1.Text = "Find what:"; + // + // SearchBox + // + this.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; + this.Controls.Add(this.searchcount); + this.Controls.Add(this.SearchHide); + this.Controls.Add(this.FindPrevious); + this.Controls.Add(this.FindNext); + this.Controls.Add(this.label1); + this.Controls.Add(this.InputSearch); + this.Location = new System.Drawing.Point(155, 23); + this.Name = "SearchBox"; + this.Size = new System.Drawing.Size(689, 30); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Label searchcount; + private System.Windows.Forms.Label SearchHide; + private System.Windows.Forms.Button FindPrevious; + private System.Windows.Forms.Button FindNext; + + private System.Windows.Forms.Label label1; + public NTextBox InputSearch; + } +} diff --git a/UE4localizationsTool/Controls/SearchBox.cs b/UE4localizationsTool/Controls/SearchBox.cs new file mode 100644 index 0000000..70f85cf --- /dev/null +++ b/UE4localizationsTool/Controls/SearchBox.cs @@ -0,0 +1,221 @@ +using System; +using System.ComponentModel; +using System.Windows.Forms; + +namespace UE4localizationsTool.Controls +{ + public partial class SearchBox : UserControl + { + [Browsable(true)] + public NDataGridView DataGridView { get; set; } + int CurrentRowIndex = -1; + int CurrentColumnIndex = -1; + + public SearchBox() + { + InitializeComponent(); + Hide(); + } + public SearchBox(NDataGridView dataGrid) + { + DataGridView = dataGrid; + InitializeComponent(); + Hide(); + } + + private void SearchHide_Click(object sender, System.EventArgs e) + { + Hide(); + } + + private bool IsMatch(string value) + { + string searchText = InputSearch.Text; + + if (string.IsNullOrWhiteSpace(searchText)) + return false; + + return value.IndexOf(searchText, StringComparison.OrdinalIgnoreCase) > -1; + } + + private void FindNext_Click(object sender, EventArgs e) + { + bool found = false; + + for (int rowIndex = CurrentRowIndex; rowIndex < DataGridView.Rows.Count; rowIndex++) + { + for (int colIndex = CurrentColumnIndex + 1; colIndex < DataGridView.Columns.Count; colIndex++) + { + if (rowIndex >= 0 && rowIndex < DataGridView.Rows.Count && colIndex >= 0 && colIndex < DataGridView.Columns.Count) + { + DataGridViewCell cell = DataGridView.Rows[rowIndex].Cells[colIndex]; + if (cell.Value != null && IsMatch(cell.Value.ToString())) + { + SelectCell(rowIndex, colIndex); + found = true; + break; + } + } + } + + if (found) + break; + + + CurrentColumnIndex = -1; + } + + if (!found) + { + + for (int rowIndex = 0; rowIndex < DataGridView.Rows.Count; rowIndex++) + { + for (int colIndex = 0; colIndex < DataGridView.Columns.Count; colIndex++) + { + if (rowIndex >= 0 && rowIndex < DataGridView.Rows.Count && colIndex >= 0 && colIndex < DataGridView.Columns.Count) + { + DataGridViewCell cell = DataGridView.Rows[rowIndex].Cells[colIndex]; + if (cell.Value != null && IsMatch(cell.Value.ToString())) + { + SelectCell(rowIndex, colIndex); + found = true; + break; + } + } + } + + if (found) + break; + } + } + if (!found) + { + Failedmessage(); + } + } + + + private void FindPrevious_Click(object sender, EventArgs e) + { + bool found = false; + + for (int rowIndex = CurrentRowIndex; rowIndex >= 0; rowIndex--) + { + for (int colIndex = CurrentColumnIndex - 1; colIndex >= 0; colIndex--) + { + if (rowIndex >= 0 && rowIndex < DataGridView.Rows.Count && colIndex >= 0 && colIndex < DataGridView.Columns.Count) + { + DataGridViewCell cell = DataGridView.Rows[rowIndex].Cells[colIndex]; + if (cell.Value != null && IsMatch(cell.Value.ToString())) + { + SelectCell(rowIndex, colIndex); + found = true; + break; + } + } + } + + if (found) + break; + + + CurrentColumnIndex = DataGridView.Columns.Count; + } + + if (!found) + { + for (int rowIndex = DataGridView.Rows.Count - 1; rowIndex >= 0; rowIndex--) + { + for (int colIndex = DataGridView.Columns.Count - 1; colIndex >= 0; colIndex--) + { + if (rowIndex >= 0 && rowIndex < DataGridView.Rows.Count && colIndex >= 0 && colIndex < DataGridView.Columns.Count) + { + DataGridViewCell cell = DataGridView.Rows[rowIndex].Cells[colIndex]; + if (cell.Value != null && IsMatch(cell.Value.ToString())) + { + SelectCell(rowIndex, colIndex); + found = true; + break; + } + } + } + + if (found) + break; + } + } + + if (!found) + { + Failedmessage(); + } + } + + + private void Failedmessage() + { + MessageBox.Show( + text: $"The searched value '{InputSearch.Text}' not found.", + caption: "Search Result", + buttons: MessageBoxButtons.OK, + icon: MessageBoxIcon.Warning + ); + } + + private void SelectCell(int rowIndex, int colIndex) + { + DataGridView.ClearSelection(); + DataGridView.FirstDisplayedScrollingRowIndex = rowIndex; + DataGridView.Rows[rowIndex].Cells[colIndex].Selected = true; + + CurrentRowIndex = rowIndex; + CurrentColumnIndex = colIndex; + } + + private void InputSearch_KeyDown(object sender, KeyEventArgs e) + { + if (!InputSearch.Focused) + { + InputSearch.Focus(); + } + + if (e.KeyCode == Keys.Enter) + { + FindNext_Click(sender, e); + } + } + + public new void Show() + { + if (DataGridView.CurrentCell!=null) + { + InputSearch.Text = DataGridView.CurrentCell.Value.ToString(); + } + InputSearch.Focus(); + base.Show(); + } + + public int CountTotalMatches() + { + int totalMatches = 0; + + for (int rowIndex = 0; rowIndex < DataGridView.Rows.Count; rowIndex++) + { + for (int colIndex = 0; colIndex < DataGridView.Columns.Count; colIndex++) + { + if (rowIndex >= 0 && rowIndex < DataGridView.Rows.Count && colIndex >= 0 && colIndex < DataGridView.Columns.Count) + { + DataGridViewCell cell = DataGridView.Rows[rowIndex].Cells[colIndex]; + if (cell.Value != null && IsMatch(cell.Value.ToString())) + { + totalMatches++; + } + } + } + } + + return totalMatches; + } + + } +} diff --git a/UE4localizationsTool/Controls/SearchBox.resx b/UE4localizationsTool/Controls/SearchBox.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/UE4localizationsTool/Controls/SearchBox.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/UE4localizationsTool/Core/AssetHelper.cs b/UE4localizationsTool/Core/AssetHelper.cs index 0475b42..4f794ab 100644 --- a/UE4localizationsTool/Core/AssetHelper.cs +++ b/UE4localizationsTool/Core/AssetHelper.cs @@ -1,6 +1,7 @@ using Helper.MemoryList; using System; using System.Collections.Generic; +using System.Linq; using System.Text; namespace AssetParser @@ -132,7 +133,40 @@ public static void SetStringUE(this MemoryList memoryList, string str, Encoding memoryList.SetStringValueN(ReplaceBreaklines(str, true), true, -1, encoding); } + public static void SetStringUE(this MemoryList memoryList, string StringValue, bool UseUnicode = false) + { + + StringValue = ReplaceBreaklines(StringValue, true); + + if (string.IsNullOrEmpty(StringValue)) + { + memoryList.InsertIntValue(0); + return; + } + + StringValue += '\0'; + + Encoding encoding = Encoding.Unicode; + if (IsASCII(StringValue) && !UseUnicode) + { + encoding = Encoding.ASCII; + } + + byte[] TextBytes = encoding.GetBytes(StringValue); + + if (encoding == Encoding.ASCII) + { + memoryList.InsertIntValue(TextBytes.Length); + memoryList.InsertBytes(TextBytes); + } + else + { + memoryList.InsertIntValue(TextBytes.Length / -2); + memoryList.InsertBytes(TextBytes); + } + } + public static string GetStringUE(this MemoryList memoryList, int Lenght, bool SavePosition = true, int SeekAndRead = -1, Encoding encoding = null) { string Stringvalue = ReplaceBreaklines(memoryList.GetStringValue(Lenght, SavePosition, SeekAndRead, encoding)); @@ -331,6 +365,16 @@ public TextHistory(MemoryList memoryList, Uexp uexp, string PropertyName, bool M new ReadStringProperty(memoryList, uexp, PropertyName + "_1", Modify); new ReadStringProperty(memoryList, uexp, PropertyName + "_2", Modify); new ReadStringProperty(memoryList, uexp, PropertyName + "_3", Modify); + + if (uexp.DumpNameSpaces) + { + uexp.StringNodes.Add(new StringNode() { + NameSpace = uexp.Strings[uexp.Strings.Count - 3][1], + Key= uexp.Strings[uexp.Strings.Count - 2][1], + Value= uexp.Strings[uexp.Strings.Count - 1][1] + }); + } + break; case TextHistoryType.NamedFormat: case TextHistoryType.OrderedFormat: @@ -356,6 +400,16 @@ public TextHistory(MemoryList memoryList, Uexp uexp, string PropertyName, bool M case TextHistoryType.StringTableEntry: new FName(memoryList, uexp, PropertyName, Modify); new ReadStringProperty(memoryList, uexp, PropertyName + "_1", Modify); + + if (uexp.DumpNameSpaces) + { + uexp.StringNodes.Add(new StringNode() + { + Key = uexp.Strings[uexp.Strings.Count - 2][1], + Value = uexp.Strings[uexp.Strings.Count - 1][1] + }); + } + break; default: diff --git a/UE4localizationsTool/Core/Function.cs b/UE4localizationsTool/Core/Function.cs index 4f6898a..f9f386a 100644 --- a/UE4localizationsTool/Core/Function.cs +++ b/UE4localizationsTool/Core/Function.cs @@ -429,6 +429,16 @@ ExprToken ReadExpression() ReadExpression(); ReadExpression(); ReadExpression(); + + if (uexp.DumpNameSpaces) + { + uexp.StringNodes.Add(new StringNode() + { + NameSpace = uexp.Strings[uexp.Strings.Count - 3][1], + Key = uexp.Strings[uexp.Strings.Count - 2][1], + Value = uexp.Strings[uexp.Strings.Count - 1][1] + }); + } break; case 2: // InvariantText IsCultureInvariant ReadExpression(); @@ -440,6 +450,16 @@ ExprToken ReadExpression() FuncBlock.Skip(4); ReadExpression(); ReadExpression(); + + if (uexp.DumpNameSpaces) + { + uexp.StringNodes.Add(new StringNode() + { + // NameSpace = uexp.Strings[uexp.Strings.Count - 3][1], + Key = uexp.Strings[uexp.Strings.Count - 2][1], + Value = uexp.Strings[uexp.Strings.Count - 1][1] + }); + } break; } break; diff --git a/UE4localizationsTool/Core/Hash/CityHash64.cs b/UE4localizationsTool/Core/Hash/CityHash64.cs new file mode 100644 index 0000000..8e38ff4 --- /dev/null +++ b/UE4localizationsTool/Core/Hash/CityHash64.cs @@ -0,0 +1,479 @@ +using System; +using System.Text; +using uint32 = System.UInt32; +using uint64 = System.UInt64; +using uint8 = System.Byte; + +namespace UE4localizationsTool.Core.Hash +{ + + class CityHash + { + + public static CityHash Init + { + get + { + return new CityHash(); + } + } + + // Some primes between 2^63 and 2^64 for various uses. + static uint64 k0 = 0xc3a5c85c97cb3127UL; + static uint64 k1 = 0xb492b66fbe98f273UL; + static uint64 k2 = 0x9ae16a3b2f90404fUL; + + // Magic numbers for 32-bit hashing. Copied from Murmur3. + static uint32 c1 = 0xcc9e2d51; + static uint32 c2 = 0x1b873593; + public static bool IsBigEndian { get; set; } = false; + public class Uint128_64 + { + public Uint128_64(ulong InLo, ulong InHi) + { + lo = InLo; + hi = InHi; + } + public ulong lo; + public ulong hi; + }; + + // Hash 128 input bits down to 64 bits of output. + // This is intended to be a reasonably good hash function. + public ulong CityHash128to64(ref Uint128_64 x) + { + // Murmur-inspired hashing. + const ulong kMul = 0x9ddfea08eb382d69UL; + ulong a = (x.lo ^ x.hi) * kMul; + a ^= (a >> 47); + ulong b = (x.hi ^ a) * kMul; + b ^= (b >> 47); + b *= kMul; + return b; + } + + + unsafe uint64 UNALIGNED_LOAD64(byte* p) + { + + return *(uint64*)p; + } + + unsafe uint32 UNALIGNED_LOAD32(byte* p) + { + + return *(uint32*)p; + } + + protected uint32 _byteswap_ulong(uint32 value) + { + return ((value & 0xFFu) << 24) | + ((value & 0xFF00u) << 8) | + ((value & 0xFF0000u) >> 8) | + ((value >> 24) & 0xFFu); + } + + protected uint64 _byteswap_uint64(uint64 value) + { + return ((value & 0xFFUL) << 56) | + ((value & 0xFF00UL) << 40) | + ((value & 0xFF0000UL) << 24) | + ((value & 0xFF000000UL) << 8) | + ((value & 0xFF00000000UL) >> 8) | + ((value & 0xFF0000000000UL) >> 24) | + ((value & 0xFF000000000000UL) >> 40) | + ((value >> 56) & 0xFFUL); + } + + uint32 bswap_32(uint32 x) => _byteswap_ulong(x); + uint64 bswap_64(uint64 x) => _byteswap_uint64(x); + + uint32 uint32_in_expected_order(uint32 x) => bswap_32(x); + uint64 uint64_in_expected_order(uint64 x) => bswap_64(x); + + + + unsafe uint64 Fetch64(byte* p) + { + var val = IsBigEndian ? uint64_in_expected_order(UNALIGNED_LOAD64(p)) : UNALIGNED_LOAD64(p); + return val; + } + + unsafe uint32 Fetch32(byte* p) + { + var val = IsBigEndian ? uint32_in_expected_order(UNALIGNED_LOAD32(p)) : UNALIGNED_LOAD32(p); + return val; + } + + + + // A 32-bit to 32-bit integer hash copied from Murmur3. + static uint32 fmix(uint32 h) + { + h ^= h >> 16; + h *= 0x85ebca6b; + h ^= h >> 13; + h *= 0xc2b2ae35; + h ^= h >> 16; + return h; + } + + static uint32 Rotate32(uint32 val, int shift) + { + // Avoid shifting by 32: doing so yields an undefined result. + return shift == 0 ? val : ((val >> shift) | (val << (32 - shift))); + } + + + void SwapValues(ref T a, ref T b) + { + T c = a; + a = b; + b = c; + } + + void PERMUTE3(ref T a, ref T b, ref T c) + { + do + { + SwapValues(ref a, ref b); + SwapValues(ref a, ref c); + } while (true); + } + + uint32 Mur(uint32 a, uint32 h) + { + + // Helper from Murmur3 for combining two 32-bit values. + a *= c1; + a = Rotate32(a, 17); + a *= c2; + h ^= a; + h = Rotate32(h, 19); + return h * 5 + 0xe6546b64; + } + + unsafe uint32 Hash32Len13to24(byte* s, uint32 len) + { + uint32 a = Fetch32(s - 4 + (len >> 1)); + uint32 b = Fetch32(s + 4); + uint32 c = Fetch32(s + len - 8); + uint32 d = Fetch32(s + (len >> 1)); + uint32 e = Fetch32(s); + uint32 f = Fetch32(s + len - 4); + uint32 h = len; + + return fmix(Mur(f, Mur(e, Mur(d, Mur(c, Mur(b, Mur(a, h))))))); + } + + unsafe uint32 Hash32Len0to4(byte* s, uint32 len) + { + + uint32 b = 0; + uint32 c = 9; + byte* bytePtr = s; + for (uint32 i = 0; i < len; i++) + { + byte v = *bytePtr; + b = b * c1 + v; + c ^= b; + bytePtr++; + } + return fmix(Mur(b, Mur(len, c))); + } + + unsafe uint32 Hash32Len5to12(byte* s, uint32 len) + { + uint32 a = len, b = len * 5, c = 9, d = b; + a += Fetch32(s); + b += Fetch32(s + len - 4); + c += Fetch32(s + ((len >> 1) & 4)); + return fmix(Mur(c, Mur(b, Mur(a, d)))); + } + + unsafe uint32 CityHash32(byte* s, uint32 len) + { + + if (len <= 24) + { + return len <= 12 ? + (len <= 4 ? Hash32Len0to4(s, len) : Hash32Len5to12(s, len)) : + Hash32Len13to24(s, len); + } + + // len > 24 + uint32 h = len, g = c1 * len, f = g; + uint32 a0 = Rotate32(Fetch32(s + len - 4) * c1, 17) * c2; + uint32 a1 = Rotate32(Fetch32(s + len - 8) * c1, 17) * c2; + uint32 a2 = Rotate32(Fetch32(s + len - 16) * c1, 17) * c2; + uint32 a3 = Rotate32(Fetch32(s + len - 12) * c1, 17) * c2; + uint32 a4 = Rotate32(Fetch32(s + len - 20) * c1, 17) * c2; + h ^= a0; + h = Rotate32(h, 19); + h = h * 5 + 0xe6546b64; + h ^= a2; + h = Rotate32(h, 19); + h = h * 5 + 0xe6546b64; + g ^= a1; + g = Rotate32(g, 19); + g = g * 5 + 0xe6546b64; + g ^= a3; + g = Rotate32(g, 19); + g = g * 5 + 0xe6546b64; + f += a4; + f = Rotate32(f, 19); + f = f * 5 + 0xe6546b64; + uint32 iters = (len - 1) / 20; + do + { + uint32 _a0 = Rotate32(Fetch32(s) * c1, 17) * c2; + uint32 _a1 = Fetch32(s + 4); + uint32 _a2 = Rotate32(Fetch32(s + 8) * c1, 17) * c2; + uint32 _a3 = Rotate32(Fetch32(s + 12) * c1, 17) * c2; + uint32 _a4 = Fetch32(s + 16); + h ^= _a0; + h = Rotate32(h, 18); + h = h * 5 + 0xe6546b64; + f += _a1; + f = Rotate32(f, 19); + f = f * c1; + g += _a2; + g = Rotate32(g, 18); + g = g * 5 + 0xe6546b64; + h ^= _a3 + _a1; + h = Rotate32(h, 19); + h = h * 5 + 0xe6546b64; + g ^= _a4; + g = bswap_32(g) * 5; + h += _a4 * 5; + h = bswap_32(h); + f += _a0; + PERMUTE3(ref f, ref h, ref g); + s += 20; + } while (--iters != 0); + g = Rotate32(g, 11) * c1; + g = Rotate32(g, 17) * c1; + f = Rotate32(f, 11) * c1; + f = Rotate32(f, 17) * c1; + h = Rotate32(h + g, 19); + h = h * 5 + 0xe6546b64; + h = Rotate32(h, 17) * c1; + h = Rotate32(h + f, 19); + h = h * 5 + 0xe6546b64; + h = Rotate32(h, 17) * c1; + return h; + } + + // Bitwise right rotate. Normally this will compile to a single + // instruction, especially if the shift is a manifest constant. + static uint64 Rotate(uint64 val, int shift) + { + // Avoid shifting by 64: doing so yields an undefined result. + return shift == 0 ? val : ((val >> shift) | (val << (64 - shift))); + } + + static uint64 ShiftMix(uint64 val) + { + return val ^ (val >> 47); + } + + uint64 HashLen16(uint64 u, uint64 v) + { + var val = new Uint128_64(u, v); + return CityHash128to64(ref val); + } + + static uint64 HashLen16(uint64 u, uint64 v, uint64 mul) + { + // Murmur-inspired hashing. + uint64 a = (u ^ v) * mul; + a ^= (a >> 47); + uint64 b = (v ^ a) * mul; + b ^= (b >> 47); + b *= mul; + return b; + } + + unsafe uint64 HashLen0to16(byte* s, uint32 len) + { + + + if (len >= 8) + { + uint64 mul = k2 + len * 2; + uint64 a = Fetch64(s) + k2; + uint64 b = Fetch64(s + len - 8); + uint64 c = Rotate(b, 37) * mul + a; + uint64 d = (Rotate(a, 25) + b) * mul; + return HashLen16(c, d, mul); + } + if (len >= 4) + { + uint64 mul = k2 + len * 2; + uint64 a = Fetch32(s); + return HashLen16(len + (a << 3), Fetch32(s + len - 4), mul); + } + if (len > 0) + { + uint8 a = s[0]; + uint8 b = s[len >> 1]; + uint8 c = s[len - 1]; + uint32 y = a + ((uint32)b << 8); + uint32 z = len + ((uint32)(c) << 2); + return ShiftMix(y * k2 ^ z * k0) * k2; + } + return k2; + } + + // This probably works well for 16-byte strings as well, but it may be overkill + // in that case. + unsafe uint64 HashLen17to32(byte* s, uint32 len) + { + uint64 mul = k2 + len * 2; + uint64 a = Fetch64(s) * k1; + uint64 b = Fetch64(s + 8); + uint64 c = Fetch64(s + len - 8) * mul; + uint64 d = Fetch64(s + len - 16) * k2; + return HashLen16(Rotate(a + b, 43) + Rotate(c, 30) + d, + a + Rotate(b + k2, 18) + c, mul); + } + + // Return a 16-byte hash for 48 bytes. Quick and dirty. + // Callers do best to use "random-looking" values for a and b. + static Uint128_64 WeakHashLen32WithSeeds( + uint64 w, uint64 x, uint64 y, uint64 z, uint64 a, uint64 b) + { + a += w; + b = Rotate(b + a + z, 21); + uint64 c = a; + a += x; + a += y; + b += Rotate(a, 44); + return new Uint128_64((a + z), (b + c)); + } + + // Return a 16-byte hash for s[0] ... s[31], a, and b. Quick and dirty. + unsafe Uint128_64 WeakHashLen32WithSeeds( + byte* s, uint64 a, uint64 b) + { + return WeakHashLen32WithSeeds(Fetch64(s), + Fetch64(s + 8), + Fetch64(s + 16), + Fetch64(s + 24), + a, + b); + } + + // Return an 8-byte hash for 33 to 64 bytes. + unsafe uint64 HashLen33to64(byte* s, uint32 len) + { + + + uint64 mul = k2 + len * 2; + uint64 a = Fetch64(s) * k2; + uint64 b = Fetch64(s + 8); + uint64 c = Fetch64(s + len - 24); + uint64 d = Fetch64(s + len - 32); + uint64 e = Fetch64(s + 16) * k2; + uint64 f = Fetch64(s + 24) * 9; + uint64 g = Fetch64(s + len - 8); + uint64 h = Fetch64(s + len - 16) * mul; + uint64 u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9; + uint64 v = ((a + g) ^ d) + f + 1; + uint64 w = bswap_64((u + v) * mul) + h; + uint64 x = Rotate(e + f, 42) + c; + uint64 y = (bswap_64((v + w) * mul) + g) * mul; + uint64 z = e + f + c; + a = bswap_64((x + z) * mul + y) + b; + b = ShiftMix((z + a) * mul + d + h) * mul; + return b + x; + } + + unsafe uint64 CityHash64(byte* s, uint32 len) + { + if (len <= 32) + { + if (len <= 16) + { + return HashLen0to16(s, len); + } + + else + { + return HashLen17to32(s, len); + } + } + + else if (len <= 64) + { + return HashLen33to64(s, len); + } + + // For strings over 64 bytes we hash the end first, and then as we + // loop we keep 56 bytes of state: v, w, x, y, and z. + uint64 x = Fetch64(s + len - 40); + uint64 y = Fetch64(s + len - 16) + Fetch64(s + len - 56); + uint64 z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24)); + Uint128_64 v = WeakHashLen32WithSeeds(s + len - 64, len, z); + Uint128_64 w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x); + x = x * k1 + Fetch64(s); + + // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks. + len = (len - 1) & ~(uint32)(63); + do + { + x = Rotate(x + y + v.lo + Fetch64(s + 8), 37) * k1; + y = Rotate(y + v.hi + Fetch64(s + 48), 42) * k1; + x ^= w.hi; + y += v.lo + Fetch64(s + 40); + z = Rotate(z + w.lo, 33) * k1; + v = WeakHashLen32WithSeeds(s, v.hi * k1, x + w.lo); + w = WeakHashLen32WithSeeds(s + 32, z + w.hi, y + Fetch64(s + 16)); + SwapValues(ref z, ref x); + s += 64; + len -= 64; + } while (len != 0); + return HashLen16(HashLen16(v.lo, w.lo) + ShiftMix(y) * k1 + z, + HashLen16(v.hi, w.hi) + x); + } + + public ulong CityHash64(byte[] s) + { + unsafe + { + fixed (byte* ptr = s) + { + return CityHash64(ptr, (uint)s.Length); + } + } + } + + public ulong CityHash64(string s) + { + byte[] byteArray = Encoding.UTF8.GetBytes(s); + + unsafe + { + fixed (byte* ptr = byteArray) + { + return CityHash64(ptr, (uint)byteArray.Length); + } + } + } + + unsafe uint64 CityHash64WithSeed(byte* s, uint32 len, uint64 seed) + { + + + return CityHash64WithSeeds(s, len, k2, seed); + } + + unsafe uint64 CityHash64WithSeeds(byte* s, uint32 len, uint64 seed0, uint64 seed1) + { + + + return HashLen16(CityHash64(s, len) - seed0, seed1); + } + + } +} diff --git a/UE4localizationsTool/Core/Hash/Crc.cs b/UE4localizationsTool/Core/Hash/Crc.cs new file mode 100644 index 0000000..466bb7a --- /dev/null +++ b/UE4localizationsTool/Core/Hash/Crc.cs @@ -0,0 +1,178 @@ +namespace UE4localizationsTool.Core.Hash +{ + static class FCrc + { + private static uint[][] CRCTablesSB8 = new uint[8][] + { + new uint[]{ + 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, + 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, + 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, + 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, + 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, + 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, + 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, + 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, + 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, + 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, + 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, + 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, + 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, + 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, + 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, + 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d + + }, + new uint[]{ + 0x00000000, 0x191b3141, 0x32366282, 0x2b2d53c3, 0x646cc504, 0x7d77f445, 0x565aa786, 0x4f4196c7, 0xc8d98a08, 0xd1c2bb49, 0xfaefe88a, 0xe3f4d9cb, 0xacb54f0c, 0xb5ae7e4d, 0x9e832d8e, 0x87981ccf, + 0x4ac21251, 0x53d92310, 0x78f470d3, 0x61ef4192, 0x2eaed755, 0x37b5e614, 0x1c98b5d7, 0x05838496, 0x821b9859, 0x9b00a918, 0xb02dfadb, 0xa936cb9a, 0xe6775d5d, 0xff6c6c1c, 0xd4413fdf, 0xcd5a0e9e, + 0x958424a2, 0x8c9f15e3, 0xa7b24620, 0xbea97761, 0xf1e8e1a6, 0xe8f3d0e7, 0xc3de8324, 0xdac5b265, 0x5d5daeaa, 0x44469feb, 0x6f6bcc28, 0x7670fd69, 0x39316bae, 0x202a5aef, 0x0b07092c, 0x121c386d, + 0xdf4636f3, 0xc65d07b2, 0xed705471, 0xf46b6530, 0xbb2af3f7, 0xa231c2b6, 0x891c9175, 0x9007a034, 0x179fbcfb, 0x0e848dba, 0x25a9de79, 0x3cb2ef38, 0x73f379ff, 0x6ae848be, 0x41c51b7d, 0x58de2a3c, + 0xf0794f05, 0xe9627e44, 0xc24f2d87, 0xdb541cc6, 0x94158a01, 0x8d0ebb40, 0xa623e883, 0xbf38d9c2, 0x38a0c50d, 0x21bbf44c, 0x0a96a78f, 0x138d96ce, 0x5ccc0009, 0x45d73148, 0x6efa628b, 0x77e153ca, + 0xbabb5d54, 0xa3a06c15, 0x888d3fd6, 0x91960e97, 0xded79850, 0xc7cca911, 0xece1fad2, 0xf5facb93, 0x7262d75c, 0x6b79e61d, 0x4054b5de, 0x594f849f, 0x160e1258, 0x0f152319, 0x243870da, 0x3d23419b, + 0x65fd6ba7, 0x7ce65ae6, 0x57cb0925, 0x4ed03864, 0x0191aea3, 0x188a9fe2, 0x33a7cc21, 0x2abcfd60, 0xad24e1af, 0xb43fd0ee, 0x9f12832d, 0x8609b26c, 0xc94824ab, 0xd05315ea, 0xfb7e4629, 0xe2657768, + 0x2f3f79f6, 0x362448b7, 0x1d091b74, 0x04122a35, 0x4b53bcf2, 0x52488db3, 0x7965de70, 0x607eef31, 0xe7e6f3fe, 0xfefdc2bf, 0xd5d0917c, 0xcccba03d, 0x838a36fa, 0x9a9107bb, 0xb1bc5478, 0xa8a76539, + 0x3b83984b, 0x2298a90a, 0x09b5fac9, 0x10aecb88, 0x5fef5d4f, 0x46f46c0e, 0x6dd93fcd, 0x74c20e8c, 0xf35a1243, 0xea412302, 0xc16c70c1, 0xd8774180, 0x9736d747, 0x8e2de606, 0xa500b5c5, 0xbc1b8484, + 0x71418a1a, 0x685abb5b, 0x4377e898, 0x5a6cd9d9, 0x152d4f1e, 0x0c367e5f, 0x271b2d9c, 0x3e001cdd, 0xb9980012, 0xa0833153, 0x8bae6290, 0x92b553d1, 0xddf4c516, 0xc4eff457, 0xefc2a794, 0xf6d996d5, + 0xae07bce9, 0xb71c8da8, 0x9c31de6b, 0x852aef2a, 0xca6b79ed, 0xd37048ac, 0xf85d1b6f, 0xe1462a2e, 0x66de36e1, 0x7fc507a0, 0x54e85463, 0x4df36522, 0x02b2f3e5, 0x1ba9c2a4, 0x30849167, 0x299fa026, + 0xe4c5aeb8, 0xfdde9ff9, 0xd6f3cc3a, 0xcfe8fd7b, 0x80a96bbc, 0x99b25afd, 0xb29f093e, 0xab84387f, 0x2c1c24b0, 0x350715f1, 0x1e2a4632, 0x07317773, 0x4870e1b4, 0x516bd0f5, 0x7a468336, 0x635db277, + 0xcbfad74e, 0xd2e1e60f, 0xf9ccb5cc, 0xe0d7848d, 0xaf96124a, 0xb68d230b, 0x9da070c8, 0x84bb4189, 0x03235d46, 0x1a386c07, 0x31153fc4, 0x280e0e85, 0x674f9842, 0x7e54a903, 0x5579fac0, 0x4c62cb81, + 0x8138c51f, 0x9823f45e, 0xb30ea79d, 0xaa1596dc, 0xe554001b, 0xfc4f315a, 0xd7626299, 0xce7953d8, 0x49e14f17, 0x50fa7e56, 0x7bd72d95, 0x62cc1cd4, 0x2d8d8a13, 0x3496bb52, 0x1fbbe891, 0x06a0d9d0, + 0x5e7ef3ec, 0x4765c2ad, 0x6c48916e, 0x7553a02f, 0x3a1236e8, 0x230907a9, 0x0824546a, 0x113f652b, 0x96a779e4, 0x8fbc48a5, 0xa4911b66, 0xbd8a2a27, 0xf2cbbce0, 0xebd08da1, 0xc0fdde62, 0xd9e6ef23, + 0x14bce1bd, 0x0da7d0fc, 0x268a833f, 0x3f91b27e, 0x70d024b9, 0x69cb15f8, 0x42e6463b, 0x5bfd777a, 0xdc656bb5, 0xc57e5af4, 0xee530937, 0xf7483876, 0xb809aeb1, 0xa1129ff0, 0x8a3fcc33, 0x9324fd72 + + }, + new uint[]{ + 0x00000000, 0x01c26a37, 0x0384d46e, 0x0246be59, 0x0709a8dc, 0x06cbc2eb, 0x048d7cb2, 0x054f1685, 0x0e1351b8, 0x0fd13b8f, 0x0d9785d6, 0x0c55efe1, 0x091af964, 0x08d89353, 0x0a9e2d0a, 0x0b5c473d, + 0x1c26a370, 0x1de4c947, 0x1fa2771e, 0x1e601d29, 0x1b2f0bac, 0x1aed619b, 0x18abdfc2, 0x1969b5f5, 0x1235f2c8, 0x13f798ff, 0x11b126a6, 0x10734c91, 0x153c5a14, 0x14fe3023, 0x16b88e7a, 0x177ae44d, + 0x384d46e0, 0x398f2cd7, 0x3bc9928e, 0x3a0bf8b9, 0x3f44ee3c, 0x3e86840b, 0x3cc03a52, 0x3d025065, 0x365e1758, 0x379c7d6f, 0x35dac336, 0x3418a901, 0x3157bf84, 0x3095d5b3, 0x32d36bea, 0x331101dd, + 0x246be590, 0x25a98fa7, 0x27ef31fe, 0x262d5bc9, 0x23624d4c, 0x22a0277b, 0x20e69922, 0x2124f315, 0x2a78b428, 0x2bbade1f, 0x29fc6046, 0x283e0a71, 0x2d711cf4, 0x2cb376c3, 0x2ef5c89a, 0x2f37a2ad, + 0x709a8dc0, 0x7158e7f7, 0x731e59ae, 0x72dc3399, 0x7793251c, 0x76514f2b, 0x7417f172, 0x75d59b45, 0x7e89dc78, 0x7f4bb64f, 0x7d0d0816, 0x7ccf6221, 0x798074a4, 0x78421e93, 0x7a04a0ca, 0x7bc6cafd, + 0x6cbc2eb0, 0x6d7e4487, 0x6f38fade, 0x6efa90e9, 0x6bb5866c, 0x6a77ec5b, 0x68315202, 0x69f33835, 0x62af7f08, 0x636d153f, 0x612bab66, 0x60e9c151, 0x65a6d7d4, 0x6464bde3, 0x662203ba, 0x67e0698d, + 0x48d7cb20, 0x4915a117, 0x4b531f4e, 0x4a917579, 0x4fde63fc, 0x4e1c09cb, 0x4c5ab792, 0x4d98dda5, 0x46c49a98, 0x4706f0af, 0x45404ef6, 0x448224c1, 0x41cd3244, 0x400f5873, 0x4249e62a, 0x438b8c1d, + 0x54f16850, 0x55330267, 0x5775bc3e, 0x56b7d609, 0x53f8c08c, 0x523aaabb, 0x507c14e2, 0x51be7ed5, 0x5ae239e8, 0x5b2053df, 0x5966ed86, 0x58a487b1, 0x5deb9134, 0x5c29fb03, 0x5e6f455a, 0x5fad2f6d, + 0xe1351b80, 0xe0f771b7, 0xe2b1cfee, 0xe373a5d9, 0xe63cb35c, 0xe7fed96b, 0xe5b86732, 0xe47a0d05, 0xef264a38, 0xeee4200f, 0xeca29e56, 0xed60f461, 0xe82fe2e4, 0xe9ed88d3, 0xebab368a, 0xea695cbd, + 0xfd13b8f0, 0xfcd1d2c7, 0xfe976c9e, 0xff5506a9, 0xfa1a102c, 0xfbd87a1b, 0xf99ec442, 0xf85cae75, 0xf300e948, 0xf2c2837f, 0xf0843d26, 0xf1465711, 0xf4094194, 0xf5cb2ba3, 0xf78d95fa, 0xf64fffcd, + 0xd9785d60, 0xd8ba3757, 0xdafc890e, 0xdb3ee339, 0xde71f5bc, 0xdfb39f8b, 0xddf521d2, 0xdc374be5, 0xd76b0cd8, 0xd6a966ef, 0xd4efd8b6, 0xd52db281, 0xd062a404, 0xd1a0ce33, 0xd3e6706a, 0xd2241a5d, + 0xc55efe10, 0xc49c9427, 0xc6da2a7e, 0xc7184049, 0xc25756cc, 0xc3953cfb, 0xc1d382a2, 0xc011e895, 0xcb4dafa8, 0xca8fc59f, 0xc8c97bc6, 0xc90b11f1, 0xcc440774, 0xcd866d43, 0xcfc0d31a, 0xce02b92d, + 0x91af9640, 0x906dfc77, 0x922b422e, 0x93e92819, 0x96a63e9c, 0x976454ab, 0x9522eaf2, 0x94e080c5, 0x9fbcc7f8, 0x9e7eadcf, 0x9c381396, 0x9dfa79a1, 0x98b56f24, 0x99770513, 0x9b31bb4a, 0x9af3d17d, + 0x8d893530, 0x8c4b5f07, 0x8e0de15e, 0x8fcf8b69, 0x8a809dec, 0x8b42f7db, 0x89044982, 0x88c623b5, 0x839a6488, 0x82580ebf, 0x801eb0e6, 0x81dcdad1, 0x8493cc54, 0x8551a663, 0x8717183a, 0x86d5720d, + 0xa9e2d0a0, 0xa820ba97, 0xaa6604ce, 0xaba46ef9, 0xaeeb787c, 0xaf29124b, 0xad6fac12, 0xacadc625, 0xa7f18118, 0xa633eb2f, 0xa4755576, 0xa5b73f41, 0xa0f829c4, 0xa13a43f3, 0xa37cfdaa, 0xa2be979d, + 0xb5c473d0, 0xb40619e7, 0xb640a7be, 0xb782cd89, 0xb2cddb0c, 0xb30fb13b, 0xb1490f62, 0xb08b6555, 0xbbd72268, 0xba15485f, 0xb853f606, 0xb9919c31, 0xbcde8ab4, 0xbd1ce083, 0xbf5a5eda, 0xbe9834ed + + }, + new uint[]{ + 0x00000000, 0xb8bc6765, 0xaa09c88b, 0x12b5afee, 0x8f629757, 0x37def032, 0x256b5fdc, 0x9dd738b9, 0xc5b428ef, 0x7d084f8a, 0x6fbde064, 0xd7018701, 0x4ad6bfb8, 0xf26ad8dd, 0xe0df7733, 0x58631056, + 0x5019579f, 0xe8a530fa, 0xfa109f14, 0x42acf871, 0xdf7bc0c8, 0x67c7a7ad, 0x75720843, 0xcdce6f26, 0x95ad7f70, 0x2d111815, 0x3fa4b7fb, 0x8718d09e, 0x1acfe827, 0xa2738f42, 0xb0c620ac, 0x087a47c9, + 0xa032af3e, 0x188ec85b, 0x0a3b67b5, 0xb28700d0, 0x2f503869, 0x97ec5f0c, 0x8559f0e2, 0x3de59787, 0x658687d1, 0xdd3ae0b4, 0xcf8f4f5a, 0x7733283f, 0xeae41086, 0x525877e3, 0x40edd80d, 0xf851bf68, + 0xf02bf8a1, 0x48979fc4, 0x5a22302a, 0xe29e574f, 0x7f496ff6, 0xc7f50893, 0xd540a77d, 0x6dfcc018, 0x359fd04e, 0x8d23b72b, 0x9f9618c5, 0x272a7fa0, 0xbafd4719, 0x0241207c, 0x10f48f92, 0xa848e8f7, + 0x9b14583d, 0x23a83f58, 0x311d90b6, 0x89a1f7d3, 0x1476cf6a, 0xaccaa80f, 0xbe7f07e1, 0x06c36084, 0x5ea070d2, 0xe61c17b7, 0xf4a9b859, 0x4c15df3c, 0xd1c2e785, 0x697e80e0, 0x7bcb2f0e, 0xc377486b, + 0xcb0d0fa2, 0x73b168c7, 0x6104c729, 0xd9b8a04c, 0x446f98f5, 0xfcd3ff90, 0xee66507e, 0x56da371b, 0x0eb9274d, 0xb6054028, 0xa4b0efc6, 0x1c0c88a3, 0x81dbb01a, 0x3967d77f, 0x2bd27891, 0x936e1ff4, + 0x3b26f703, 0x839a9066, 0x912f3f88, 0x299358ed, 0xb4446054, 0x0cf80731, 0x1e4da8df, 0xa6f1cfba, 0xfe92dfec, 0x462eb889, 0x549b1767, 0xec277002, 0x71f048bb, 0xc94c2fde, 0xdbf98030, 0x6345e755, + 0x6b3fa09c, 0xd383c7f9, 0xc1366817, 0x798a0f72, 0xe45d37cb, 0x5ce150ae, 0x4e54ff40, 0xf6e89825, 0xae8b8873, 0x1637ef16, 0x048240f8, 0xbc3e279d, 0x21e91f24, 0x99557841, 0x8be0d7af, 0x335cb0ca, + 0xed59b63b, 0x55e5d15e, 0x47507eb0, 0xffec19d5, 0x623b216c, 0xda874609, 0xc832e9e7, 0x708e8e82, 0x28ed9ed4, 0x9051f9b1, 0x82e4565f, 0x3a58313a, 0xa78f0983, 0x1f336ee6, 0x0d86c108, 0xb53aa66d, + 0xbd40e1a4, 0x05fc86c1, 0x1749292f, 0xaff54e4a, 0x322276f3, 0x8a9e1196, 0x982bbe78, 0x2097d91d, 0x78f4c94b, 0xc048ae2e, 0xd2fd01c0, 0x6a4166a5, 0xf7965e1c, 0x4f2a3979, 0x5d9f9697, 0xe523f1f2, + 0x4d6b1905, 0xf5d77e60, 0xe762d18e, 0x5fdeb6eb, 0xc2098e52, 0x7ab5e937, 0x680046d9, 0xd0bc21bc, 0x88df31ea, 0x3063568f, 0x22d6f961, 0x9a6a9e04, 0x07bda6bd, 0xbf01c1d8, 0xadb46e36, 0x15080953, + 0x1d724e9a, 0xa5ce29ff, 0xb77b8611, 0x0fc7e174, 0x9210d9cd, 0x2aacbea8, 0x38191146, 0x80a57623, 0xd8c66675, 0x607a0110, 0x72cfaefe, 0xca73c99b, 0x57a4f122, 0xef189647, 0xfdad39a9, 0x45115ecc, + 0x764dee06, 0xcef18963, 0xdc44268d, 0x64f841e8, 0xf92f7951, 0x41931e34, 0x5326b1da, 0xeb9ad6bf, 0xb3f9c6e9, 0x0b45a18c, 0x19f00e62, 0xa14c6907, 0x3c9b51be, 0x842736db, 0x96929935, 0x2e2efe50, + 0x2654b999, 0x9ee8defc, 0x8c5d7112, 0x34e11677, 0xa9362ece, 0x118a49ab, 0x033fe645, 0xbb838120, 0xe3e09176, 0x5b5cf613, 0x49e959fd, 0xf1553e98, 0x6c820621, 0xd43e6144, 0xc68bceaa, 0x7e37a9cf, + 0xd67f4138, 0x6ec3265d, 0x7c7689b3, 0xc4caeed6, 0x591dd66f, 0xe1a1b10a, 0xf3141ee4, 0x4ba87981, 0x13cb69d7, 0xab770eb2, 0xb9c2a15c, 0x017ec639, 0x9ca9fe80, 0x241599e5, 0x36a0360b, 0x8e1c516e, + 0x866616a7, 0x3eda71c2, 0x2c6fde2c, 0x94d3b949, 0x090481f0, 0xb1b8e695, 0xa30d497b, 0x1bb12e1e, 0x43d23e48, 0xfb6e592d, 0xe9dbf6c3, 0x516791a6, 0xccb0a91f, 0x740cce7a, 0x66b96194, 0xde0506f1 + + }, + new uint[]{ + 0x00000000, 0x3d6029b0, 0x7ac05360, 0x47a07ad0, 0xf580a6c0, 0xc8e08f70, 0x8f40f5a0, 0xb220dc10, 0x30704bc1, 0x0d106271, 0x4ab018a1, 0x77d03111, 0xc5f0ed01, 0xf890c4b1, 0xbf30be61, 0x825097d1, + 0x60e09782, 0x5d80be32, 0x1a20c4e2, 0x2740ed52, 0x95603142, 0xa80018f2, 0xefa06222, 0xd2c04b92, 0x5090dc43, 0x6df0f5f3, 0x2a508f23, 0x1730a693, 0xa5107a83, 0x98705333, 0xdfd029e3, 0xe2b00053, + 0xc1c12f04, 0xfca106b4, 0xbb017c64, 0x866155d4, 0x344189c4, 0x0921a074, 0x4e81daa4, 0x73e1f314, 0xf1b164c5, 0xccd14d75, 0x8b7137a5, 0xb6111e15, 0x0431c205, 0x3951ebb5, 0x7ef19165, 0x4391b8d5, + 0xa121b886, 0x9c419136, 0xdbe1ebe6, 0xe681c256, 0x54a11e46, 0x69c137f6, 0x2e614d26, 0x13016496, 0x9151f347, 0xac31daf7, 0xeb91a027, 0xd6f18997, 0x64d15587, 0x59b17c37, 0x1e1106e7, 0x23712f57, + 0x58f35849, 0x659371f9, 0x22330b29, 0x1f532299, 0xad73fe89, 0x9013d739, 0xd7b3ade9, 0xead38459, 0x68831388, 0x55e33a38, 0x124340e8, 0x2f236958, 0x9d03b548, 0xa0639cf8, 0xe7c3e628, 0xdaa3cf98, + 0x3813cfcb, 0x0573e67b, 0x42d39cab, 0x7fb3b51b, 0xcd93690b, 0xf0f340bb, 0xb7533a6b, 0x8a3313db, 0x0863840a, 0x3503adba, 0x72a3d76a, 0x4fc3feda, 0xfde322ca, 0xc0830b7a, 0x872371aa, 0xba43581a, + 0x9932774d, 0xa4525efd, 0xe3f2242d, 0xde920d9d, 0x6cb2d18d, 0x51d2f83d, 0x167282ed, 0x2b12ab5d, 0xa9423c8c, 0x9422153c, 0xd3826fec, 0xeee2465c, 0x5cc29a4c, 0x61a2b3fc, 0x2602c92c, 0x1b62e09c, + 0xf9d2e0cf, 0xc4b2c97f, 0x8312b3af, 0xbe729a1f, 0x0c52460f, 0x31326fbf, 0x7692156f, 0x4bf23cdf, 0xc9a2ab0e, 0xf4c282be, 0xb362f86e, 0x8e02d1de, 0x3c220dce, 0x0142247e, 0x46e25eae, 0x7b82771e, + 0xb1e6b092, 0x8c869922, 0xcb26e3f2, 0xf646ca42, 0x44661652, 0x79063fe2, 0x3ea64532, 0x03c66c82, 0x8196fb53, 0xbcf6d2e3, 0xfb56a833, 0xc6368183, 0x74165d93, 0x49767423, 0x0ed60ef3, 0x33b62743, + 0xd1062710, 0xec660ea0, 0xabc67470, 0x96a65dc0, 0x248681d0, 0x19e6a860, 0x5e46d2b0, 0x6326fb00, 0xe1766cd1, 0xdc164561, 0x9bb63fb1, 0xa6d61601, 0x14f6ca11, 0x2996e3a1, 0x6e369971, 0x5356b0c1, + 0x70279f96, 0x4d47b626, 0x0ae7ccf6, 0x3787e546, 0x85a73956, 0xb8c710e6, 0xff676a36, 0xc2074386, 0x4057d457, 0x7d37fde7, 0x3a978737, 0x07f7ae87, 0xb5d77297, 0x88b75b27, 0xcf1721f7, 0xf2770847, + 0x10c70814, 0x2da721a4, 0x6a075b74, 0x576772c4, 0xe547aed4, 0xd8278764, 0x9f87fdb4, 0xa2e7d404, 0x20b743d5, 0x1dd76a65, 0x5a7710b5, 0x67173905, 0xd537e515, 0xe857cca5, 0xaff7b675, 0x92979fc5, + 0xe915e8db, 0xd475c16b, 0x93d5bbbb, 0xaeb5920b, 0x1c954e1b, 0x21f567ab, 0x66551d7b, 0x5b3534cb, 0xd965a31a, 0xe4058aaa, 0xa3a5f07a, 0x9ec5d9ca, 0x2ce505da, 0x11852c6a, 0x562556ba, 0x6b457f0a, + 0x89f57f59, 0xb49556e9, 0xf3352c39, 0xce550589, 0x7c75d999, 0x4115f029, 0x06b58af9, 0x3bd5a349, 0xb9853498, 0x84e51d28, 0xc34567f8, 0xfe254e48, 0x4c059258, 0x7165bbe8, 0x36c5c138, 0x0ba5e888, + 0x28d4c7df, 0x15b4ee6f, 0x521494bf, 0x6f74bd0f, 0xdd54611f, 0xe03448af, 0xa794327f, 0x9af41bcf, 0x18a48c1e, 0x25c4a5ae, 0x6264df7e, 0x5f04f6ce, 0xed242ade, 0xd044036e, 0x97e479be, 0xaa84500e, + 0x4834505d, 0x755479ed, 0x32f4033d, 0x0f942a8d, 0xbdb4f69d, 0x80d4df2d, 0xc774a5fd, 0xfa148c4d, 0x78441b9c, 0x4524322c, 0x028448fc, 0x3fe4614c, 0x8dc4bd5c, 0xb0a494ec, 0xf704ee3c, 0xca64c78c + + }, + new uint[]{ + 0x00000000, 0xcb5cd3a5, 0x4dc8a10b, 0x869472ae, 0x9b914216, 0x50cd91b3, 0xd659e31d, 0x1d0530b8, 0xec53826d, 0x270f51c8, 0xa19b2366, 0x6ac7f0c3, 0x77c2c07b, 0xbc9e13de, 0x3a0a6170, 0xf156b2d5, + 0x03d6029b, 0xc88ad13e, 0x4e1ea390, 0x85427035, 0x9847408d, 0x531b9328, 0xd58fe186, 0x1ed33223, 0xef8580f6, 0x24d95353, 0xa24d21fd, 0x6911f258, 0x7414c2e0, 0xbf481145, 0x39dc63eb, 0xf280b04e, + 0x07ac0536, 0xccf0d693, 0x4a64a43d, 0x81387798, 0x9c3d4720, 0x57619485, 0xd1f5e62b, 0x1aa9358e, 0xebff875b, 0x20a354fe, 0xa6372650, 0x6d6bf5f5, 0x706ec54d, 0xbb3216e8, 0x3da66446, 0xf6fab7e3, + 0x047a07ad, 0xcf26d408, 0x49b2a6a6, 0x82ee7503, 0x9feb45bb, 0x54b7961e, 0xd223e4b0, 0x197f3715, 0xe82985c0, 0x23755665, 0xa5e124cb, 0x6ebdf76e, 0x73b8c7d6, 0xb8e41473, 0x3e7066dd, 0xf52cb578, + 0x0f580a6c, 0xc404d9c9, 0x4290ab67, 0x89cc78c2, 0x94c9487a, 0x5f959bdf, 0xd901e971, 0x125d3ad4, 0xe30b8801, 0x28575ba4, 0xaec3290a, 0x659ffaaf, 0x789aca17, 0xb3c619b2, 0x35526b1c, 0xfe0eb8b9, + 0x0c8e08f7, 0xc7d2db52, 0x4146a9fc, 0x8a1a7a59, 0x971f4ae1, 0x5c439944, 0xdad7ebea, 0x118b384f, 0xe0dd8a9a, 0x2b81593f, 0xad152b91, 0x6649f834, 0x7b4cc88c, 0xb0101b29, 0x36846987, 0xfdd8ba22, + 0x08f40f5a, 0xc3a8dcff, 0x453cae51, 0x8e607df4, 0x93654d4c, 0x58399ee9, 0xdeadec47, 0x15f13fe2, 0xe4a78d37, 0x2ffb5e92, 0xa96f2c3c, 0x6233ff99, 0x7f36cf21, 0xb46a1c84, 0x32fe6e2a, 0xf9a2bd8f, + 0x0b220dc1, 0xc07ede64, 0x46eaacca, 0x8db67f6f, 0x90b34fd7, 0x5bef9c72, 0xdd7beedc, 0x16273d79, 0xe7718fac, 0x2c2d5c09, 0xaab92ea7, 0x61e5fd02, 0x7ce0cdba, 0xb7bc1e1f, 0x31286cb1, 0xfa74bf14, + 0x1eb014d8, 0xd5ecc77d, 0x5378b5d3, 0x98246676, 0x852156ce, 0x4e7d856b, 0xc8e9f7c5, 0x03b52460, 0xf2e396b5, 0x39bf4510, 0xbf2b37be, 0x7477e41b, 0x6972d4a3, 0xa22e0706, 0x24ba75a8, 0xefe6a60d, + 0x1d661643, 0xd63ac5e6, 0x50aeb748, 0x9bf264ed, 0x86f75455, 0x4dab87f0, 0xcb3ff55e, 0x006326fb, 0xf135942e, 0x3a69478b, 0xbcfd3525, 0x77a1e680, 0x6aa4d638, 0xa1f8059d, 0x276c7733, 0xec30a496, + 0x191c11ee, 0xd240c24b, 0x54d4b0e5, 0x9f886340, 0x828d53f8, 0x49d1805d, 0xcf45f2f3, 0x04192156, 0xf54f9383, 0x3e134026, 0xb8873288, 0x73dbe12d, 0x6eded195, 0xa5820230, 0x2316709e, 0xe84aa33b, + 0x1aca1375, 0xd196c0d0, 0x5702b27e, 0x9c5e61db, 0x815b5163, 0x4a0782c6, 0xcc93f068, 0x07cf23cd, 0xf6999118, 0x3dc542bd, 0xbb513013, 0x700de3b6, 0x6d08d30e, 0xa65400ab, 0x20c07205, 0xeb9ca1a0, + 0x11e81eb4, 0xdab4cd11, 0x5c20bfbf, 0x977c6c1a, 0x8a795ca2, 0x41258f07, 0xc7b1fda9, 0x0ced2e0c, 0xfdbb9cd9, 0x36e74f7c, 0xb0733dd2, 0x7b2fee77, 0x662adecf, 0xad760d6a, 0x2be27fc4, 0xe0beac61, + 0x123e1c2f, 0xd962cf8a, 0x5ff6bd24, 0x94aa6e81, 0x89af5e39, 0x42f38d9c, 0xc467ff32, 0x0f3b2c97, 0xfe6d9e42, 0x35314de7, 0xb3a53f49, 0x78f9ecec, 0x65fcdc54, 0xaea00ff1, 0x28347d5f, 0xe368aefa, + 0x16441b82, 0xdd18c827, 0x5b8cba89, 0x90d0692c, 0x8dd55994, 0x46898a31, 0xc01df89f, 0x0b412b3a, 0xfa1799ef, 0x314b4a4a, 0xb7df38e4, 0x7c83eb41, 0x6186dbf9, 0xaada085c, 0x2c4e7af2, 0xe712a957, + 0x15921919, 0xdececabc, 0x585ab812, 0x93066bb7, 0x8e035b0f, 0x455f88aa, 0xc3cbfa04, 0x089729a1, 0xf9c19b74, 0x329d48d1, 0xb4093a7f, 0x7f55e9da, 0x6250d962, 0xa90c0ac7, 0x2f987869, 0xe4c4abcc + + }, +new uint[] { + 0x00000000, 0xa6770bb4, 0x979f1129, 0x31e81a9d, 0xf44f2413, 0x52382fa7, 0x63d0353a, 0xc5a73e8e, 0x33ef4e67, 0x959845d3, 0xa4705f4e, 0x020754fa, 0xc7a06a74, 0x61d761c0, 0x503f7b5d, 0xf64870e9, + 0x67de9cce, 0xc1a9977a, 0xf0418de7, 0x56368653, 0x9391b8dd, 0x35e6b369, 0x040ea9f4, 0xa279a240, 0x5431d2a9, 0xf246d91d, 0xc3aec380, 0x65d9c834, 0xa07ef6ba, 0x0609fd0e, 0x37e1e793, 0x9196ec27, + 0xcfbd399c, 0x69ca3228, 0x582228b5, 0xfe552301, 0x3bf21d8f, 0x9d85163b, 0xac6d0ca6, 0x0a1a0712, 0xfc5277fb, 0x5a257c4f, 0x6bcd66d2, 0xcdba6d66, 0x081d53e8, 0xae6a585c, 0x9f8242c1, 0x39f54975, + 0xa863a552, 0x0e14aee6, 0x3ffcb47b, 0x998bbfcf, 0x5c2c8141, 0xfa5b8af5, 0xcbb39068, 0x6dc49bdc, 0x9b8ceb35, 0x3dfbe081, 0x0c13fa1c, 0xaa64f1a8, 0x6fc3cf26, 0xc9b4c492, 0xf85cde0f, 0x5e2bd5bb, + 0x440b7579, 0xe27c7ecd, 0xd3946450, 0x75e36fe4, 0xb044516a, 0x16335ade, 0x27db4043, 0x81ac4bf7, 0x77e43b1e, 0xd19330aa, 0xe07b2a37, 0x460c2183, 0x83ab1f0d, 0x25dc14b9, 0x14340e24, 0xb2430590, + 0x23d5e9b7, 0x85a2e203, 0xb44af89e, 0x123df32a, 0xd79acda4, 0x71edc610, 0x4005dc8d, 0xe672d739, 0x103aa7d0, 0xb64dac64, 0x87a5b6f9, 0x21d2bd4d, 0xe47583c3, 0x42028877, 0x73ea92ea, 0xd59d995e, + 0x8bb64ce5, 0x2dc14751, 0x1c295dcc, 0xba5e5678, 0x7ff968f6, 0xd98e6342, 0xe86679df, 0x4e11726b, 0xb8590282, 0x1e2e0936, 0x2fc613ab, 0x89b1181f, 0x4c162691, 0xea612d25, 0xdb8937b8, 0x7dfe3c0c, + 0xec68d02b, 0x4a1fdb9f, 0x7bf7c102, 0xdd80cab6, 0x1827f438, 0xbe50ff8c, 0x8fb8e511, 0x29cfeea5, 0xdf879e4c, 0x79f095f8, 0x48188f65, 0xee6f84d1, 0x2bc8ba5f, 0x8dbfb1eb, 0xbc57ab76, 0x1a20a0c2, + 0x8816eaf2, 0x2e61e146, 0x1f89fbdb, 0xb9fef06f, 0x7c59cee1, 0xda2ec555, 0xebc6dfc8, 0x4db1d47c, 0xbbf9a495, 0x1d8eaf21, 0x2c66b5bc, 0x8a11be08, 0x4fb68086, 0xe9c18b32, 0xd82991af, 0x7e5e9a1b, + 0xefc8763c, 0x49bf7d88, 0x78576715, 0xde206ca1, 0x1b87522f, 0xbdf0599b, 0x8c184306, 0x2a6f48b2, 0xdc27385b, 0x7a5033ef, 0x4bb82972, 0xedcf22c6, 0x28681c48, 0x8e1f17fc, 0xbff70d61, 0x198006d5, + 0x47abd36e, 0xe1dcd8da, 0xd034c247, 0x7643c9f3, 0xb3e4f77d, 0x1593fcc9, 0x247be654, 0x820cede0, 0x74449d09, 0xd23396bd, 0xe3db8c20, 0x45ac8794, 0x800bb91a, 0x267cb2ae, 0x1794a833, 0xb1e3a387, + 0x20754fa0, 0x86024414, 0xb7ea5e89, 0x119d553d, 0xd43a6bb3, 0x724d6007, 0x43a57a9a, 0xe5d2712e, 0x139a01c7, 0xb5ed0a73, 0x840510ee, 0x22721b5a, 0xe7d525d4, 0x41a22e60, 0x704a34fd, 0xd63d3f49, + 0xcc1d9f8b, 0x6a6a943f, 0x5b828ea2, 0xfdf58516, 0x3852bb98, 0x9e25b02c, 0xafcdaab1, 0x09baa105, 0xfff2d1ec, 0x5985da58, 0x686dc0c5, 0xce1acb71, 0x0bbdf5ff, 0xadcafe4b, 0x9c22e4d6, 0x3a55ef62, + 0xabc30345, 0x0db408f1, 0x3c5c126c, 0x9a2b19d8, 0x5f8c2756, 0xf9fb2ce2, 0xc813367f, 0x6e643dcb, 0x982c4d22, 0x3e5b4696, 0x0fb35c0b, 0xa9c457bf, 0x6c636931, 0xca146285, 0xfbfc7818, 0x5d8b73ac, + 0x03a0a617, 0xa5d7ada3, 0x943fb73e, 0x3248bc8a, 0xf7ef8204, 0x519889b0, 0x6070932d, 0xc6079899, 0x304fe870, 0x9638e3c4, 0xa7d0f959, 0x01a7f2ed, 0xc400cc63, 0x6277c7d7, 0x539fdd4a, 0xf5e8d6fe, + 0x647e3ad9, 0xc209316d, 0xf3e12bf0, 0x55962044, 0x90311eca, 0x3646157e, 0x07ae0fe3, 0xa1d90457, 0x579174be, 0xf1e67f0a, 0xc00e6597, 0x66796e23, 0xa3de50ad, 0x05a95b19, 0x34414184, 0x92364a30 + + }, + new uint[]{ + 0x00000000, 0xccaa009e, 0x4225077d, 0x8e8f07e3, 0x844a0efa, 0x48e00e64, 0xc66f0987, 0x0ac50919, 0xd3e51bb5, 0x1f4f1b2b, 0x91c01cc8, 0x5d6a1c56, 0x57af154f, 0x9b0515d1, 0x158a1232, 0xd92012ac, + 0x7cbb312b, 0xb01131b5, 0x3e9e3656, 0xf23436c8, 0xf8f13fd1, 0x345b3f4f, 0xbad438ac, 0x767e3832, 0xaf5e2a9e, 0x63f42a00, 0xed7b2de3, 0x21d12d7d, 0x2b142464, 0xe7be24fa, 0x69312319, 0xa59b2387, + 0xf9766256, 0x35dc62c8, 0xbb53652b, 0x77f965b5, 0x7d3c6cac, 0xb1966c32, 0x3f196bd1, 0xf3b36b4f, 0x2a9379e3, 0xe639797d, 0x68b67e9e, 0xa41c7e00, 0xaed97719, 0x62737787, 0xecfc7064, 0x205670fa, + 0x85cd537d, 0x496753e3, 0xc7e85400, 0x0b42549e, 0x01875d87, 0xcd2d5d19, 0x43a25afa, 0x8f085a64, 0x562848c8, 0x9a824856, 0x140d4fb5, 0xd8a74f2b, 0xd2624632, 0x1ec846ac, 0x9047414f, 0x5ced41d1, + 0x299dc2ed, 0xe537c273, 0x6bb8c590, 0xa712c50e, 0xadd7cc17, 0x617dcc89, 0xeff2cb6a, 0x2358cbf4, 0xfa78d958, 0x36d2d9c6, 0xb85dde25, 0x74f7debb, 0x7e32d7a2, 0xb298d73c, 0x3c17d0df, 0xf0bdd041, + 0x5526f3c6, 0x998cf358, 0x1703f4bb, 0xdba9f425, 0xd16cfd3c, 0x1dc6fda2, 0x9349fa41, 0x5fe3fadf, 0x86c3e873, 0x4a69e8ed, 0xc4e6ef0e, 0x084cef90, 0x0289e689, 0xce23e617, 0x40ace1f4, 0x8c06e16a, + 0xd0eba0bb, 0x1c41a025, 0x92cea7c6, 0x5e64a758, 0x54a1ae41, 0x980baedf, 0x1684a93c, 0xda2ea9a2, 0x030ebb0e, 0xcfa4bb90, 0x412bbc73, 0x8d81bced, 0x8744b5f4, 0x4beeb56a, 0xc561b289, 0x09cbb217, + 0xac509190, 0x60fa910e, 0xee7596ed, 0x22df9673, 0x281a9f6a, 0xe4b09ff4, 0x6a3f9817, 0xa6959889, 0x7fb58a25, 0xb31f8abb, 0x3d908d58, 0xf13a8dc6, 0xfbff84df, 0x37558441, 0xb9da83a2, 0x7570833c, + 0x533b85da, 0x9f918544, 0x111e82a7, 0xddb48239, 0xd7718b20, 0x1bdb8bbe, 0x95548c5d, 0x59fe8cc3, 0x80de9e6f, 0x4c749ef1, 0xc2fb9912, 0x0e51998c, 0x04949095, 0xc83e900b, 0x46b197e8, 0x8a1b9776, + 0x2f80b4f1, 0xe32ab46f, 0x6da5b38c, 0xa10fb312, 0xabcaba0b, 0x6760ba95, 0xe9efbd76, 0x2545bde8, 0xfc65af44, 0x30cfafda, 0xbe40a839, 0x72eaa8a7, 0x782fa1be, 0xb485a120, 0x3a0aa6c3, 0xf6a0a65d, + 0xaa4de78c, 0x66e7e712, 0xe868e0f1, 0x24c2e06f, 0x2e07e976, 0xe2ade9e8, 0x6c22ee0b, 0xa088ee95, 0x79a8fc39, 0xb502fca7, 0x3b8dfb44, 0xf727fbda, 0xfde2f2c3, 0x3148f25d, 0xbfc7f5be, 0x736df520, + 0xd6f6d6a7, 0x1a5cd639, 0x94d3d1da, 0x5879d144, 0x52bcd85d, 0x9e16d8c3, 0x1099df20, 0xdc33dfbe, 0x0513cd12, 0xc9b9cd8c, 0x4736ca6f, 0x8b9ccaf1, 0x8159c3e8, 0x4df3c376, 0xc37cc495, 0x0fd6c40b, + 0x7aa64737, 0xb60c47a9, 0x3883404a, 0xf42940d4, 0xfeec49cd, 0x32464953, 0xbcc94eb0, 0x70634e2e, 0xa9435c82, 0x65e95c1c, 0xeb665bff, 0x27cc5b61, 0x2d095278, 0xe1a352e6, 0x6f2c5505, 0xa386559b, + 0x061d761c, 0xcab77682, 0x44387161, 0x889271ff, 0x825778e6, 0x4efd7878, 0xc0727f9b, 0x0cd87f05, 0xd5f86da9, 0x19526d37, 0x97dd6ad4, 0x5b776a4a, 0x51b26353, 0x9d1863cd, 0x1397642e, 0xdf3d64b0, + 0x83d02561, 0x4f7a25ff, 0xc1f5221c, 0x0d5f2282, 0x079a2b9b, 0xcb302b05, 0x45bf2ce6, 0x89152c78, 0x50353ed4, 0x9c9f3e4a, 0x121039a9, 0xdeba3937, 0xd47f302e, 0x18d530b0, 0x965a3753, 0x5af037cd, + 0xff6b144a, 0x33c114d4, 0xbd4e1337, 0x71e413a9, 0x7b211ab0, 0xb78b1a2e, 0x39041dcd, 0xf5ae1d53, 0x2c8e0fff, 0xe0240f61, 0x6eab0882, 0xa201081c, 0xa8c40105, 0x646e019b, 0xeae10678, 0x264b06e6 + + } + }; + + public static uint StrCrc32(this string Data, uint CRC = 0) + { + CRC = ~CRC; + foreach (uint value in Data) + { + var Ch = value; + CRC = (CRC >> 8) ^ CRCTablesSB8[0][(CRC ^ Ch) & 0xFF]; + Ch >>= 8; + CRC = (CRC >> 8) ^ CRCTablesSB8[0][(CRC ^ Ch) & 0xFF]; + Ch >>= 8; + CRC = (CRC >> 8) ^ CRCTablesSB8[0][(CRC ^ Ch) & 0xFF]; + Ch >>= 8; + CRC = (CRC >> 8) ^ CRCTablesSB8[0][(CRC ^ Ch) & 0xFF]; + } + return ~CRC; + } + } +} diff --git a/UE4localizationsTool/Core/IAsset.cs b/UE4localizationsTool/Core/IAsset.cs index f1704af..02ba46e 100644 --- a/UE4localizationsTool/Core/IAsset.cs +++ b/UE4localizationsTool/Core/IAsset.cs @@ -1,11 +1,18 @@ using System.Collections.Generic; +using System.Windows.Forms; namespace AssetParser { public interface IAsset { bool IsGood { get; } - List> Strings { get; } + // List> Strings { get; } + void AddItemsToDataGridView(DataGridView dataGrid); + void LoadFromDataGridView(DataGridView dataGrid); void SaveFile(string FilPath); + List> ExtractTexts(); + void ImportTexts(List> strings); + + } } diff --git a/UE4localizationsTool/Core/IoPackage.cs b/UE4localizationsTool/Core/IoPackage.cs index 1a3e953..acbac08 100644 --- a/UE4localizationsTool/Core/IoPackage.cs +++ b/UE4localizationsTool/Core/IoPackage.cs @@ -189,7 +189,7 @@ public void ExportReadOrEdit(bool Modify = false) UassetFile.Skip(8); //Wrong way - ulong Class = UassetFile.GetUInt64Value(); + ulong Class = UassetFile.GetUInt64Value();//CityHash64 ?! switch (Class) { diff --git a/UE4localizationsTool/Core/Uasset.cs b/UE4localizationsTool/Core/Uasset.cs index 301739d..7202c4d 100644 --- a/UE4localizationsTool/Core/Uasset.cs +++ b/UE4localizationsTool/Core/Uasset.cs @@ -129,6 +129,7 @@ public Uasset(string FilePath) private void ReadHeader(bool saveoffsets = true) { + UassetFile.Seek(0); UassetFile.Skip(4);//Unreal Signature LegacyFileVersion = UassetFile.GetIntValue(); @@ -357,6 +358,7 @@ private void ReadHeader(bool saveoffsets = true) OffsetsList.Add(UassetFile.GetPosition()); PreloadDependencyOffset = UassetFile.GetIntValue(); } + } public void EditName(string NewStr, int Index) @@ -390,12 +392,12 @@ public void EditName(string NewStr, int Index) NewSize = UassetFile.GetSize() - OldSize; - foreach (int offset in OffsetsList) { - if (UassetFile.GetIntValue(false, offset) > Name_Directory_Offset) + var OldOffsetValue = UassetFile.GetIntValue(false, offset); + if (OldOffsetValue > Name_Directory_Offset) { - int NewOffsetValue = UassetFile.GetIntValue(false, offset) + NewSize; + int NewOffsetValue = OldOffsetValue + NewSize; UassetFile.SetIntValue(NewOffsetValue, false, offset); } } diff --git a/UE4localizationsTool/Core/Uexp.cs b/UE4localizationsTool/Core/Uexp.cs index 4a6fb37..d4c9c74 100644 --- a/UE4localizationsTool/Core/Uexp.cs +++ b/UE4localizationsTool/Core/Uexp.cs @@ -1,11 +1,26 @@ using Helper.MemoryList; using System; using System.Collections.Generic; +using System.Drawing; using System.IO; +using System.Windows.Forms; namespace AssetParser { + public class StringNode + { + public string NameSpace { get; set; } + public string Key { get; set; } + public string Value { get; set; } + + + public string GetName() + { + return string.IsNullOrEmpty(NameSpace)?Key: NameSpace+ "::" + Key; + } + } + public class Uexp : IAsset { @@ -29,13 +44,22 @@ public int CurrentIndex } + + public List StringNodes { get; set; } + public bool DumpNameSpaces { get; set; } = false; - - public Uexp(IUasset UassetObject) + public Uexp(IUasset UassetObject,bool dumpnamespaces=false) { UassetData = UassetObject; Strings = new List>(); CurrentIndex = 0; + + if (dumpnamespaces) + { + StringNodes = new List(); + this.DumpNameSpaces = dumpnamespaces; + } + ReadOrEdit(); } @@ -65,100 +89,96 @@ private void ReadOrEdit(bool Modify = false) for (int n = 0; n < UassetData.Exports_Directory.Count; n++) { ExportIndex = n; - using (MemoryList memoryList = new MemoryList(UassetData.Exports_Directory[n].ExportData)) + MemoryList memoryList = new MemoryList(UassetData.Exports_Directory[n].ExportData); + try { - try - { - ConsoleMode.Print("Block Start offset: " + UassetData.Exports_Directory[n].ExportStart.ToString(), ConsoleColor.DarkRed); - ConsoleMode.Print("Block Size: " + UassetData.Exports_Directory[n].ExportLength.ToString(), ConsoleColor.DarkRed); + ConsoleMode.Print("Block Start offset: " + UassetData.Exports_Directory[n].ExportStart.ToString(), ConsoleColor.DarkRed); + ConsoleMode.Print("Block Size: " + UassetData.Exports_Directory[n].ExportLength.ToString(), ConsoleColor.DarkRed); - memoryList.Seek(0); //Seek to beginning of Block + memoryList.Seek(0); //Seek to beginning of Block - if (UassetData.UseMethod2) - { - new UDataTable(memoryList, this, Modify); - continue; - } + if (UassetData.UseMethod2) + { + new UDataTable(memoryList, this, Modify); + continue; + } - ConsoleMode.Print(UassetData.GetExportPropertyName(UassetData.Exports_Directory[n].ExportClass), ConsoleColor.DarkRed); + ConsoleMode.Print(UassetData.GetExportPropertyName(UassetData.Exports_Directory[n].ExportClass), ConsoleColor.DarkRed); - if (memoryList.GetByteValue(false) == 0 && UassetData.GetExportPropertyName(UassetData.Exports_Directory[n].ExportClass) != "MovieSceneCompiledData" && memoryList.GetIntValue(false) > UassetData.NAMES_DIRECTORY.Count) - { - memoryList.Skip(2); - goto Start; - } + if (memoryList.GetByteValue(false) == 0 && UassetData.GetExportPropertyName(UassetData.Exports_Directory[n].ExportClass) != "MovieSceneCompiledData" && memoryList.GetIntValue(false) > UassetData.NAMES_DIRECTORY.Count) + { + memoryList.Skip(2); + goto Start; + } - ConsoleMode.Print($"-----------{n}------------", ConsoleColor.Red); - _ = new StructProperty(memoryList, this, UassetData.UseFromStruct, false, Modify); - ConsoleMode.Print($"-----------End------------", ConsoleColor.Red); + ConsoleMode.Print($"-----------{n}------------", ConsoleColor.Red); + _ = new StructProperty(memoryList, this, UassetData.UseFromStruct, false, Modify); + ConsoleMode.Print($"-----------End------------", ConsoleColor.Red); - if (memoryList.EndofFile()) - { - continue; - } - Start: - ConsoleMode.Print($"-----------{n}------------", ConsoleColor.DarkRed); - switch (UassetData.GetExportPropertyName(UassetData.Exports_Directory[n].ExportClass)) - { - case "StringTable": - new StringTable(memoryList, this, Modify); - break; - case "CompositeDataTable": - case "DataTable": + if (memoryList.EndofFile()) + { + continue; + } + Start: + ConsoleMode.Print($"-----------{n}------------", ConsoleColor.DarkRed); + switch (UassetData.GetExportPropertyName(UassetData.Exports_Directory[n].ExportClass)) + { + case "StringTable": + new StringTable(memoryList, this, Modify); + break; + case "CompositeDataTable": + case "DataTable": + if (memoryList.GetIntValue(false) != -5) + { + new DataTable(memoryList, this, Modify); + } + else + { + //For not effect in original file structure if (memoryList.GetIntValue(false) != -5) { new DataTable(memoryList, this, Modify); } else { - //For not effect in original file structure - if (memoryList.GetIntValue(false) != -5) - { - new DataTable(memoryList, this, Modify); - } - else - { - new UDataTable(memoryList, this, Modify); - } + new UDataTable(memoryList, this, Modify); } - break; - case "Spreadsheet": - - new Spreadsheet(memoryList, this, Modify); - break; - case "Function": - new Function(memoryList, this, Modify); - break; - case "REDLocalizeTextData": - new REDLocalizeTextData(memoryList, this, Modify); - break; - case "REDLibraryTextData": - new REDLibraryTextData(memoryList, this, Modify); - break; - case "REDAdvTextData": - new REDAdvTextData(memoryList, this, Modify); - break; - case "MuseStringTable": - new MuseStringTable(memoryList, this, Modify); - break; - case "SubtitlesText": - new MuseStringTable(memoryList, this, Modify); - break; - } - ConsoleMode.Print($"-----------End------------", ConsoleColor.DarkRed); - } - catch (Exception ex) - { - ConsoleMode.Print("Skip this export:\n" + ex.ToString(), ConsoleColor.Red, ConsoleMode.ConsoleModeType.Error); - // Skip this export + } + break; + case "Spreadsheet": + + new Spreadsheet(memoryList, this, Modify); + break; + case "Function": + new Function(memoryList, this, Modify); + break; + case "REDLocalizeTextData": + new REDLocalizeTextData(memoryList, this, Modify); + break; + case "REDLibraryTextData": + new REDLibraryTextData(memoryList, this, Modify); + break; + case "REDAdvTextData": + new REDAdvTextData(memoryList, this, Modify); + break; + case "MuseStringTable": + new MuseStringTable(memoryList, this, Modify); + break; + case "SubtitlesText": + new MuseStringTable(memoryList, this, Modify); + break; } + ConsoleMode.Print($"-----------End------------", ConsoleColor.DarkRed); + } + catch (Exception ex) + { + ConsoleMode.Print("Skip this export:\n" + ex.ToString(), ConsoleColor.Red, ConsoleMode.ConsoleModeType.Error); + // Skip this export } - } - } @@ -216,6 +236,136 @@ private MemoryList MakeBlocks() } } + public void AddItemsToDataGridView(DataGridView dataGrid) + { + dataGrid.DataSource = null; + dataGrid.Rows.Clear(); + dataGrid.Columns.Clear(); + + var dataTable = new System.Data.DataTable(); + dataTable.Columns.Add("Name"); + dataTable.Columns["Name"].ReadOnly = true; + dataTable.Columns.Add("Text value"); + dataTable.Columns.Add("index",typeof(int)); + + int i = 0; + foreach (var item in Strings) + { + dataTable.Rows.Add(item[0], item[1], i++); + } + + dataGrid.DataSource = dataTable; + + dataGrid.Columns["Text value"].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill; + dataGrid.Columns["index"].Visible = false; + + + // You can remove these event handlers if not needed. + dataGrid.CellFormatting += DataGrid_CellFormatting; + dataGrid.CellToolTipTextNeeded += DataGrid_CellToolTipTextNeeded; + } + + private void DataGrid_CellToolTipTextNeeded(object sender, DataGridViewCellToolTipTextNeededEventArgs e) + { + if (e.RowIndex >= 0) + { + var dataGridView = (DataGridView)sender; + + bool isFound = false; + foreach (DataGridViewColumn column in dataGridView.Columns) + { + if (column.Name == "index") + { + isFound = true; + } + } + if (!isFound) return; + + + if (dataGridView.Columns[e.ColumnIndex].Name == "Name") + { + var rowIndexCell = dataGridView.Rows[e.RowIndex].Cells["index"]; + + if (rowIndexCell != null && rowIndexCell.Value != null) + { + var rowIndex = Convert.ToInt32(rowIndexCell.Value); + + if (rowIndex >= 0 && rowIndex < Strings.Count) + { + var item = Strings[rowIndex]; + + if (item.Count > 2) + { + e.ToolTipText = item[2]; + } + } + } + } + } + } + + private void DataGrid_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e) + { + if (e.RowIndex >= 0) + { + var dataGridView = (DataGridView)sender; + + bool isFound = false; + foreach (DataGridViewColumn column in dataGridView.Columns) + { + if (column.Name == "index") + { + isFound = true; + } + } + if (!isFound) return; + + if (dataGridView.Columns[e.ColumnIndex].Name == "Name") + { + var rowIndexCell = dataGridView.Rows[e.RowIndex].Cells["index"]; + if (rowIndexCell != null && rowIndexCell.Value != null) + { + var rowIndex = Convert.ToInt32(rowIndexCell.Value); + + if (rowIndex >= 0 && rowIndex < Strings.Count) + { + var item = Strings[rowIndex]; + + if (item.Count > 3) + { + e.CellStyle.BackColor = ColorTranslator.FromHtml(item[3]); + } + if (item.Count > 4) + { + e.CellStyle.ForeColor = ColorTranslator.FromHtml(item[4]); + } + } + } + } + } + } + + public void LoadFromDataGridView(DataGridView dataGrid) + { + foreach (DataGridViewRow row in dataGrid.Rows) + { + if (row.Cells["index"].Value is int itemIndex && + row.Cells["Text value"].Value != null) + { + Strings[itemIndex][1] = row.Cells["Text value"].Value.ToString(); + } + } + } + + public List> ExtractTexts() + { + return Strings; + } + + public void ImportTexts(List> strings) + { + Strings = strings; + } } } diff --git a/UE4localizationsTool/Core/locres.cs b/UE4localizationsTool/Core/locres.cs index c9fcc52..88df93d 100644 --- a/UE4localizationsTool/Core/locres.cs +++ b/UE4localizationsTool/Core/locres.cs @@ -2,6 +2,7 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Windows.Forms; namespace AssetParser { @@ -207,9 +208,24 @@ public void SaveFile(string FilPath) locresData.WriteFile(FilPath); } + public void AddItemsToDataGridView(DataGridView dataGrid) + { + throw new NotImplementedException(); + } + public void LoadFromDataGridView(DataGridView dataGrid) + { + throw new NotImplementedException(); + } + public List> ExtractTexts() + { + throw new NotImplementedException(); + } - + public void ImportTexts(List> strings) + { + throw new NotImplementedException(); + } } } diff --git a/UE4localizationsTool/Core/locres/LocresNamespace.cs b/UE4localizationsTool/Core/locres/LocresNamespace.cs new file mode 100644 index 0000000..cf63fbe --- /dev/null +++ b/UE4localizationsTool/Core/locres/LocresNamespace.cs @@ -0,0 +1,528 @@ +using AssetParser; +using Helper.MemoryList; +using System; +using System.Collections.Generic; +using System.Data; +using System.Linq; +using System.Text; +using System.Windows.Forms; +using UE4localizationsTool.Core.Hash; + +namespace UE4localizationsTool.Core.locres +{ + public class NameSpaceTable : List + { + public uint NameHash { get; set; } + public string Name { get; set; } + public NameSpaceTable(string TableName, uint NameHash = 0) + { + this.Name = TableName; + this.NameHash = NameHash; + } + + public StringTable this[string key] + { + get + { + int index = FindIndex(x => x.key == key); + if (index >= 0) + { + return this[index]; + } + throw new KeyNotFoundException($"key '{key}' not found."); + } + set + { + int index = FindIndex(x => x.key == key); + if (index >= 0) + { + this[index] = value; + } + else + { + throw new KeyNotFoundException($"key '{key}' not found."); + } + } + } + + public bool ContainsKey(string key) + { + return FindIndex(x => x.key == key) >= 0; + } + + public void RemoveKey(string key) + { + int index = FindIndex(x => x.key == key); + if (index >= 0) + { + RemoveAt(index); + } + } + + //why?! i don't know but it's work :D + public new void Add(StringTable table) + { + table.root = this; + base.Add(table); + } + } + + public class StringTable + { + public uint keyHash { get; set; } + public string key { get; set; } + + public uint ValueHash { get; set; } + public string Value { get; set; } + + public NameSpaceTable root; + public StringTable() + { + + } + public StringTable(string TableKey, string TableValue, uint keyHash = 0, uint ValueHash = 0) + { + this.key = TableKey; + this.Value = TableValue; + this.keyHash = keyHash; + this.ValueHash = ValueHash; + } + } + + public enum LocresVersion : byte + { + Legacy = 0, + Compact, + Optimized, + Optimized_CityHash64_UTF16, + } + + public class LocresFile : List, IAsset + { + + public NameSpaceTable this[string Name] + { + get + { + int index = FindIndex(x => x.Name == Name); + if (index >= 0) + { + return this[index]; + } + throw new KeyNotFoundException($"key '{Name}' not found."); + } + set + { + int index = FindIndex(x => x.Name == Name); + if (index >= 0) + { + this[index] = value; + } + else + { + throw new KeyNotFoundException($"key '{Name}' not found."); + } + } + } + + bool ContainsKey(string key) + { + return FindIndex(x => x.Name == key) >= 0; + } + + + + + //{7574140E-4A67-FC03-4A15-909DC3377F1B} + private readonly byte[] MagicGUID = { 0x0E, 0x14, 0x74, 0x75, 0x67, 0x4A, 0x03, 0xFC, 0x4A, 0x15, 0x90, 0x9D, 0xC3, 0x37, 0x7F, 0x1B }; + public bool IsGood { get; set; } = true; + MemoryList locresData; + public LocresVersion Version; + public LocresFile(string FilePath) + { + locresData = new MemoryList(FilePath); + Load(); + } + + + void Load() + { + locresData.Seek(0); + byte[] FileGUID = locresData.GetBytes(16); + if (FileGUID.SequenceEqual(MagicGUID)) + { + Version = (LocresVersion)locresData.GetByteValue(); + } + else + { + Version = LocresVersion.Legacy; + locresData.Seek(0); + } + + if (Version > LocresVersion.Optimized_CityHash64_UTF16) + { + throw new Exception("Unsupported locres version"); + } + + + string[] Strings = new string[0]; + + if (Version >= LocresVersion.Compact) + { + + int localizedStringOffset = (int)locresData.GetInt64Value(); + int currentFileOffset = locresData.GetPosition(); + + + + locresData.Seek(localizedStringOffset); + + int localizedStringCount = locresData.GetIntValue(); + + Strings = new string[localizedStringCount]; + + if (Version >= LocresVersion.Optimized) + { + for (int i = 0; i < localizedStringCount; i++) + { + Strings[i] = locresData.GetStringUE(); + locresData.Skip(4);//ref count + } + } + else + { + for (int i = 0; i < localizedStringCount; i++) + { + Strings[i] = locresData.GetStringUE(); + } + } + locresData.Seek(currentFileOffset); + + } + else if (Version == LocresVersion.Legacy) + { + int HashTablesCount = locresData.GetIntValue(); + + + for (int i = 0; i < HashTablesCount; i++) + { + var NameSpaceHash = locresData.GetStringUE(); //hash namespace + + int localizedStringCount = locresData.GetIntValue(); + + + for (int n = 0; n < localizedStringCount; n++) + { + + string KeyHash = locresData.GetStringUE(); //string hash + uint SourceStringHash = locresData.GetUIntValue(); + AddString(NameSpaceHash, KeyHash, locresData.GetStringUE(), ValueHash: SourceStringHash); + } + + } + return; + } + + + if (Version >= LocresVersion.Optimized) + { + locresData.Skip(4);//keys Count + } + + + int namespaceCount = locresData.GetIntValue(); + + for (int n = 0; n < namespaceCount; n++) + { + string nameSpaceStr; + uint nameSpaceStrHash; + ReadTextKey(locresData, Version, out nameSpaceStrHash, out nameSpaceStr); + uint keyCount = locresData.GetUIntValue(); + for (int k = 0; k < keyCount; k++) + { + string KeyStr; + uint KeyStrHash; + ReadTextKey(locresData, Version, out KeyStrHash, out KeyStr); + uint SourceStringHash = locresData.GetUIntValue(); + if (Version >= LocresVersion.Compact) + { + int localizedStringIndex = locresData.GetIntValue(); + AddString(nameSpaceStr, KeyStr, Strings[localizedStringIndex], nameSpaceStrHash, KeyStrHash, SourceStringHash); + } + + } + + } + } + void ReadTextKey(MemoryList memoryList, LocresVersion locresVersion, out uint StrHash, out string Str) + { + StrHash = 0; + Str = ""; + if (locresVersion >= LocresVersion.Optimized) + { + StrHash = memoryList.GetUIntValue();//crc32 + } + + Str = memoryList.GetStringUE(); + } + + //build + private void Save() + { + locresData.Clear(); + + if (Version == LocresVersion.Legacy) + { + buildLegacyFile(); + return; + } + + locresData.SetBytes(MagicGUID); + locresData.SetByteValue((byte)Version); + locresData.SetInt64Value(0);//localizedStringOffset + + if (Version >= LocresVersion.Optimized) + { + var Keyscount = 0; + foreach (var Table in this) + { + Keyscount += Table.Count; + } + locresData.SetIntValue(Keyscount); + } + + + locresData.SetIntValue(Count);//namespaceCount + var stringTable = new List(); + + foreach (var NameSpace in this) + { + locresData.SetUIntValue(CalcHash(NameSpace.Name)); + + locresData.SetStringUE(NameSpace.Name); + locresData.SetIntValue(NameSpace.Count); + + foreach (var Table in NameSpace) + { + + locresData.SetUIntValue(CalcHash(Table.key)); + + locresData.SetStringUE(Table.key); + locresData.SetUIntValue(Table.Value.StrCrc32()); + + int stringTableIndex = stringTable.FindIndex(x => x.Text == Table.Value); + + if (stringTableIndex == -1) + { + stringTableIndex = stringTable.Count; + stringTable.Add(new StringEntry() { Text = Table.Value, refCount = 1 }); + } + else + { + stringTable[stringTableIndex].refCount += 1; + } + + locresData.SetIntValue(stringTableIndex); + + } + + + + } + + + int localizedStringOffset = locresData.GetPosition(); + + locresData.SetIntValue(stringTable.Count); + + if (Version >= LocresVersion.Optimized) + { + foreach (var entry in stringTable) + { + locresData.SetStringUE(entry.Text); + locresData.SetIntValue(entry.refCount); + } + } + else + { + foreach (var entry in stringTable) + { + locresData.SetStringUE(entry.Text); + } + } + + locresData.Seek(17); + locresData.SetInt64Value(localizedStringOffset); + } + + public void SaveFile(string FilPath) + { + Save(); + locresData.WriteFile(FilPath); + } + + + + private void buildLegacyFile() + { + locresData.SetIntValue(Count); + + + foreach (var names in this) + { + locresData.SetStringUE(names.Name, true); + locresData.SetIntValue(names.Count); + foreach (var table in names) + { + locresData.SetStringUE(table.key, true); + locresData.SetUIntValue(table.Value.StrCrc32()); + locresData.SetStringUE(table.Value, true); + } + } + + + } + + public void AddString(string NameSpace, string key, string value, uint NameSpaceHash = 0, uint keyHash = 0, uint ValueHash = 0) + { + if (!ContainsKey(NameSpace)) + { + Add(new NameSpaceTable(NameSpace, NameSpaceHash)); + } + + if (!this[NameSpace].ContainsKey(key)) + this[NameSpace].Add(new StringTable(key, value, keyHash, ValueHash)); + else + this[NameSpace][key].Value = value; + } + + public void RemoveString(string NameSpace, string key) + { + this[NameSpace].RemoveKey(key); + } + + public void RemoveNameSpace(string NameSpace) + { + int index = FindIndex(x => x.Name == NameSpace); + if (index >= 0) + { + RemoveAt(index); + } + } + public uint Optimized_CityHash64_UTF16Hash(string value) + { + var Hash = CityHash.Init.CityHash64(Encoding.Unicode.GetBytes(value)); + return (uint)Hash + ((uint)(Hash >> 32) * 23); + } + + + public void AddItemsToDataGridView(DataGridView dataGrid) + { + dataGrid.DataSource = null; + dataGrid.Rows.Clear(); + dataGrid.Columns.Clear(); + + var dataTable = new System.Data.DataTable(); + dataTable.Columns.Add("Name", typeof(string)); + dataTable.Columns.Add("Text value", typeof(string)); + + foreach (var names in this) + { + foreach (var table in names) + { + string name = string.IsNullOrEmpty(names.Name) ? table.key : names.Name + "::" + table.key; + string textValue = table.Value; + dataTable.Rows.Add(name, textValue); + } + } + + dataGrid.DataSource = dataTable; + dataGrid.Columns["Text value"].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill; + } + + public void LoadFromDataGridView(DataGridView dataGrid) + { + Clear(); + foreach (DataGridViewRow row in dataGrid.Rows) + { + //0-> NameSpace + //1-> Key + var items = row.Cells["Name"].Value.ToString().Split(new string[] { "::" }, StringSplitOptions.None); + + string NameSpaceStr=""; + string KeyStr=""; + + if (items.Length == 2) + { + NameSpaceStr = items[0]; + KeyStr = items[1]; + + } + else + { + KeyStr = items[0]; + } + + + AddString(NameSpaceStr, KeyStr, row.Cells["Text value"].Value.ToString()); + } + } + + + public List> ExtractTexts() + { + var strings = new List>(); + + foreach (var names in this) + { + foreach (var table in names) + { + if (!string.IsNullOrEmpty(names.Name)) + strings.Add(new List() { names.Name + "::" + table.key, table.Value }); + else + strings.Add(new List() { names.Name, table.Value }); + + } + } + return strings; + } + + + public void ImportTexts(List> strings) + { + int i = 0; + foreach (var names in this) + { + foreach (var table in names) + { + table.Value = strings[i++][1]; + } + } + + } + + public uint CalcHash(string Str) + { + if (string.IsNullOrEmpty(Str)) + { + return 0; + } + + + if (Version == LocresVersion.Optimized_CityHash64_UTF16) + return Optimized_CityHash64_UTF16Hash(Str); + else if (Version >= LocresVersion.Optimized) + return Str.StrCrc32(); + else + return 0; + } + + public class StringEntry + { + public string Text { get; set; } + public int refCount { get; set; } + } + + } + +} \ No newline at end of file diff --git a/UE4localizationsTool/Forms/FrmAbout.Designer.cs b/UE4localizationsTool/Forms/FrmAbout.Designer.cs index 3588f0c..0cc3bb7 100644 --- a/UE4localizationsTool/Forms/FrmAbout.Designer.cs +++ b/UE4localizationsTool/Forms/FrmAbout.Designer.cs @@ -84,7 +84,6 @@ private void InitializeComponent() this.MinimumSize = new System.Drawing.Size(412, 206); this.Name = "FrmAbout"; this.ShowIcon = false; - this.ShowInTaskbar = false; this.StartPosition = System.Windows.Forms.FormStartPosition.Manual; this.Text = "About"; this.ResumeLayout(false); diff --git a/UE4localizationsTool/Forms/FrmFilter.Designer.cs b/UE4localizationsTool/Forms/FrmFilter.Designer.cs index 32d3fb3..3c518be 100644 --- a/UE4localizationsTool/Forms/FrmFilter.Designer.cs +++ b/UE4localizationsTool/Forms/FrmFilter.Designer.cs @@ -41,6 +41,10 @@ private void InitializeComponent() this.BtnClose = new System.Windows.Forms.Button(); this.regularexpression = new System.Windows.Forms.CheckBox(); this.reversemode = new System.Windows.Forms.CheckBox(); + this.Columns = new System.Windows.Forms.ComboBox(); + this.label2 = new System.Windows.Forms.Label(); + this.ColumnPanel = new System.Windows.Forms.Panel(); + this.ColumnPanel.SuspendLayout(); this.SuspendLayout(); // // button1 @@ -134,12 +138,12 @@ private void InitializeComponent() this.matchcase.Text = "Match case"; this.matchcase.UseVisualStyleBackColor = true; // - // Close + // BtnClose // this.BtnClose.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); this.BtnClose.DialogResult = System.Windows.Forms.DialogResult.Cancel; this.BtnClose.Location = new System.Drawing.Point(441, 110); - this.BtnClose.Name = "Close"; + this.BtnClose.Name = "BtnClose"; this.BtnClose.Size = new System.Drawing.Size(113, 23); this.BtnClose.TabIndex = 10; this.BtnClose.Text = "Close"; @@ -167,6 +171,33 @@ private void InitializeComponent() this.reversemode.Text = "Reverse mode"; this.reversemode.UseVisualStyleBackColor = true; // + // Columns + // + this.Columns.FormattingEnabled = true; + this.Columns.Location = new System.Drawing.Point(58, 3); + this.Columns.Name = "Columns"; + this.Columns.Size = new System.Drawing.Size(156, 21); + this.Columns.TabIndex = 13; + // + // label2 + // + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(10, 6); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(45, 13); + this.label2.TabIndex = 14; + this.label2.Text = "Column:"; + // + // ColumnPanel + // + this.ColumnPanel.Controls.Add(this.Columns); + this.ColumnPanel.Controls.Add(this.label2); + this.ColumnPanel.Location = new System.Drawing.Point(211, 126); + this.ColumnPanel.Name = "ColumnPanel"; + this.ColumnPanel.Size = new System.Drawing.Size(224, 27); + this.ColumnPanel.TabIndex = 15; + this.ColumnPanel.Visible = false; + // // FrmFilter // this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); @@ -174,6 +205,7 @@ private void InitializeComponent() this.AutoSize = true; this.BackgroundImageLayout = System.Windows.Forms.ImageLayout.None; this.ClientSize = new System.Drawing.Size(584, 261); + this.Controls.Add(this.ColumnPanel); this.Controls.Add(this.reversemode); this.Controls.Add(this.regularexpression); this.Controls.Add(this.BtnClose); @@ -195,10 +227,11 @@ private void InitializeComponent() this.MinimumSize = new System.Drawing.Size(600, 300); this.Name = "FrmFilter"; this.ShowIcon = false; - this.ShowInTaskbar = false; this.StartPosition = System.Windows.Forms.FormStartPosition.Manual; this.Text = "Filter"; this.Load += new System.EventHandler(this.FrmFilter_Load); + this.ColumnPanel.ResumeLayout(false); + this.ColumnPanel.PerformLayout(); this.ResumeLayout(false); this.PerformLayout(); @@ -217,5 +250,8 @@ private void InitializeComponent() private System.Windows.Forms.Button BtnClose; private System.Windows.Forms.CheckBox regularexpression; private System.Windows.Forms.CheckBox reversemode; + private System.Windows.Forms.ComboBox Columns; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Panel ColumnPanel; } } \ No newline at end of file diff --git a/UE4localizationsTool/Forms/FrmFilter.cs b/UE4localizationsTool/Forms/FrmFilter.cs index 61be3fe..dc3e028 100644 --- a/UE4localizationsTool/Forms/FrmFilter.cs +++ b/UE4localizationsTool/Forms/FrmFilter.cs @@ -12,17 +12,43 @@ public partial class FrmFilter : NForm public bool UseMatching; public bool RegularExpression; public bool ReverseMode; + public string ColumnName; public List ArrayValues; + public FrmFilter(Form form) { InitializeComponent(); this.Location = new Point(form.Location.X + (form.Width - this.Width) / 2, form.Location.Y + (form.Height - this.Height) / 2); + ColumnPanel.Visible = false; + } + + public FrmFilter(NDataGridView dataGridView) + { + InitializeComponent(); + Location = new Point( + dataGridView.PointToScreen(Point.Empty).X + (dataGridView.Width - this.Width) / 2, + dataGridView.PointToScreen(Point.Empty).Y + (dataGridView.Height - this.Height) / 2 + ); + ColumnPanel.Visible = true; + + foreach (DataGridViewColumn HeaderText in dataGridView.Columns) + { + if (HeaderText.Visible) + { + Columns.Items.Add(HeaderText.Name); + } + } + + Columns.SelectedIndex = 0; } + + private void button1_Click(object sender, EventArgs e) { ArrayValues = new List(); - ArrayValues.Add(matchcase.Checked + "|" + regularexpression.Checked + "|" + reversemode.Checked); + + ArrayValues.Add(matchcase.Checked + "|" + regularexpression.Checked + "|" + reversemode.Checked+"|"+Columns.Text); foreach (string val in listBox1.Items) { ArrayValues.Add(val); @@ -33,6 +59,7 @@ private void button1_Click(object sender, EventArgs e) UseMatching = matchcase.Checked; RegularExpression = regularexpression.Checked; ReverseMode = reversemode.Checked; + ColumnName = Columns.Text; this.Close(); } @@ -78,11 +105,16 @@ private void FrmFilter_Load(object sender, EventArgs e) FV.AddRange(File.ReadAllLines("FilterValues.txt")); string[] Controls = FV[0].Split(new char[] { '|' }); - if (Controls.Length == 3) + if (Controls.Length >0) { + if(Controls.Length > 0) matchcase.Checked = Convert.ToBoolean(Controls[0]); - regularexpression.Checked = Convert.ToBoolean(Controls[1]); - reversemode.Checked = Convert.ToBoolean(Controls[2]); + if (Controls.Length > 1) + regularexpression.Checked = Convert.ToBoolean(Controls[1]); + if (Controls.Length > 2) + reversemode.Checked = Convert.ToBoolean(Controls[2]); + if (Controls.Length > 3) + Columns.Text = Controls[3]; FV.RemoveAt(0); } listBox1.Items.AddRange(FV.ToArray()); diff --git a/UE4localizationsTool/Forms/FrmLocresEntryEditor.Designer.cs b/UE4localizationsTool/Forms/FrmLocresEntryEditor.Designer.cs new file mode 100644 index 0000000..b4c22c6 --- /dev/null +++ b/UE4localizationsTool/Forms/FrmLocresEntryEditor.Designer.cs @@ -0,0 +1,167 @@ +namespace UE4localizationsTool.Forms +{ + partial class FrmLocresEntryEditor + { + /// + /// 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() + { + this.components = new System.ComponentModel.Container(); + this.label3 = new System.Windows.Forms.Label(); + this.label2 = new System.Windows.Forms.Label(); + this.label1 = new System.Windows.Forms.Label(); + this.button2 = new System.Windows.Forms.Button(); + this.Apply = new System.Windows.Forms.Button(); + this.txtValue = new UE4localizationsTool.Controls.NTextBox(); + this.txtKey = new UE4localizationsTool.Controls.NTextBox(); + this.txtNameSpace = new UE4localizationsTool.Controls.NTextBox(); + this.toolTip1 = new System.Windows.Forms.ToolTip(this.components); + this.SuspendLayout(); + // + // label3 + // + this.label3.AutoSize = true; + this.label3.Location = new System.Drawing.Point(12, 155); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(34, 13); + this.label3.TabIndex = 8; + this.label3.Text = "Value"; + // + // label2 + // + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(12, 79); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(25, 13); + this.label2.TabIndex = 7; + this.label2.Text = "Key"; + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(12, 17); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(66, 13); + this.label1.TabIndex = 6; + this.label1.Text = "NameSpace"; + // + // button2 + // + this.button2.Anchor = System.Windows.Forms.AnchorStyles.Bottom; + this.button2.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.button2.Location = new System.Drawing.Point(315, 297); + this.button2.Name = "button2"; + this.button2.Size = new System.Drawing.Size(75, 23); + this.button2.TabIndex = 5; + this.button2.Text = "Cancel"; + this.button2.UseVisualStyleBackColor = true; + // + // Apply + // + this.Apply.Anchor = System.Windows.Forms.AnchorStyles.Bottom; + this.Apply.DialogResult = System.Windows.Forms.DialogResult.OK; + this.Apply.Location = new System.Drawing.Point(210, 297); + this.Apply.Name = "Apply"; + this.Apply.Size = new System.Drawing.Size(75, 23); + this.Apply.TabIndex = 4; + this.Apply.Text = "Apply"; + this.Apply.UseVisualStyleBackColor = true; + // + // txtValue + // + this.txtValue.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.txtValue.Location = new System.Drawing.Point(12, 171); + this.txtValue.Multiline = true; + this.txtValue.Name = "txtValue"; + this.txtValue.PlaceholderText = ""; + this.txtValue.Size = new System.Drawing.Size(588, 97); + this.txtValue.StopEnterKey = true; + this.txtValue.TabIndex = 3; + this.txtValue.TextChanged += new System.EventHandler(this.txtValue_TextChanged); + // + // txtKey + // + this.txtKey.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.txtKey.Location = new System.Drawing.Point(12, 95); + this.txtKey.Multiline = true; + this.txtKey.Name = "txtKey"; + this.txtKey.PlaceholderText = ""; + this.txtKey.Size = new System.Drawing.Size(588, 36); + this.txtKey.StopEnterKey = true; + this.txtKey.TabIndex = 1; + this.txtKey.TextChanged += new System.EventHandler(this.txtKey_TextChanged); + // + // txtNameSpace + // + this.txtNameSpace.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.txtNameSpace.Location = new System.Drawing.Point(12, 33); + this.txtNameSpace.Multiline = true; + this.txtNameSpace.Name = "txtNameSpace"; + this.txtNameSpace.PlaceholderText = ""; + this.txtNameSpace.Size = new System.Drawing.Size(588, 34); + this.txtNameSpace.StopEnterKey = true; + this.txtNameSpace.TabIndex = 0; + this.txtNameSpace.TextChanged += new System.EventHandler(this.txtNameSpace_TextChanged); + // + // FrmLocresEntryEditor + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(612, 339); + this.Controls.Add(this.label3); + this.Controls.Add(this.label2); + this.Controls.Add(this.label1); + this.Controls.Add(this.button2); + this.Controls.Add(this.Apply); + this.Controls.Add(this.txtValue); + this.Controls.Add(this.txtKey); + this.Controls.Add(this.txtNameSpace); + this.MaximumSize = new System.Drawing.Size(778, 378); + this.MinimumSize = new System.Drawing.Size(519, 378); + this.Name = "FrmLocresEntryEditor"; + this.ShowIcon = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.Manual; + this.Text = "Row Editor"; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private Controls.NTextBox txtNameSpace; + private Controls.NTextBox txtKey; + private Controls.NTextBox txtValue; + private System.Windows.Forms.Button Apply; + private System.Windows.Forms.Button button2; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.ToolTip toolTip1; + } +} \ No newline at end of file diff --git a/UE4localizationsTool/Forms/FrmLocresEntryEditor.cs b/UE4localizationsTool/Forms/FrmLocresEntryEditor.cs new file mode 100644 index 0000000..10f7d45 --- /dev/null +++ b/UE4localizationsTool/Forms/FrmLocresEntryEditor.cs @@ -0,0 +1,121 @@ +using System; +using System.Data; +using System.Drawing; +using System.Text; +using System.Windows.Forms; +using UE4localizationsTool.Controls; +using UE4localizationsTool.Core.Hash; +using UE4localizationsTool.Core.locres; + +namespace UE4localizationsTool.Forms +{ + public partial class FrmLocresEntryEditor : NForm + { + public string NameSpace { get; set; } + public string Key { get; set; } + public string Value { get; set; } + public LocresFile asset { get; set; } + + public FrmLocresEntryEditor() + { + InitializeComponent(); + } + + + public FrmLocresEntryEditor(NDataGridView gridView, LocresFile asset) + { + InitializeComponent(); + Location = new Point( + gridView.PointToScreen(Point.Empty).X + (gridView.Width - this.Width) / 2, + gridView.PointToScreen(Point.Empty).Y + (gridView.Height - this.Height) / 2 + ); + + this.asset = asset; + var items = gridView.CurrentCell.OwningRow.Cells["Name"].Value.ToString().Split(new string[] { "::" }, StringSplitOptions.None); + + if (items.Length == 2) + { + NameSpace = items[0]; + Key = items[1]; + Value = gridView.CurrentCell.OwningRow.Cells["Text value"].Value.ToString(); + } + else + { + Key = items[0]; + Value = gridView.CurrentCell.OwningRow.Cells["Text value"].Value.ToString(); + } + Print(); + } + + public FrmLocresEntryEditor(Form form) + { + InitializeComponent(); + this.Location = new Point(form.Location.X + (form.Width - this.Width) / 2, form.Location.Y + (form.Height - this.Height) / 2); + Apply.Text = "Add"; + } + + private void Print() + { + txtNameSpace.Text = NameSpace; + txtKey.Text = Key; + txtValue.Text = Value; + } + + public void AddRow(NDataGridView gridView) + { + DataTable dt = (DataTable)gridView.DataSource; + + string RowName = GetName(); + + //bool rowExists = false; + //foreach (DataRow row in dt.Rows) + //{ + // if (string.Equals(row["Name"].ToString(), RowName, StringComparison.OrdinalIgnoreCase)) + // { + // rowExists = true; + // break; + // } + //} + + //if (rowExists) + //{ + // throw new Exception("this NameSpace and Key already exists in the table."); + //} + + dt.Rows.Add(RowName, Value); + + } + + private string GetName() + { + string RowName; + if (!string.IsNullOrEmpty(NameSpace)) + RowName = NameSpace + "::" + Key; + else + RowName = Key; + return RowName; + } + + public void EditRow(NDataGridView DGV) + { + DGV.SetValue(DGV.CurrentCell.OwningRow.Cells["Name"], GetName()); + DGV.SetValue(DGV.CurrentCell.OwningRow.Cells["Text value"], txtValue.Text); + } + + private void txtNameSpace_TextChanged(object sender, EventArgs e) + { + NameSpace = txtNameSpace.Text; + } + + private void txtKey_TextChanged(object sender, EventArgs e) + { + Key = txtKey.Text; + } + + private void txtValue_TextChanged(object sender, EventArgs e) + { + Value = AssetParser.AssetHelper.ReplaceBreaklines(txtValue.Text); + } + + } +} diff --git a/UE4localizationsTool/Forms/FrmLocresEntryEditor.resx b/UE4localizationsTool/Forms/FrmLocresEntryEditor.resx new file mode 100644 index 0000000..df8339b --- /dev/null +++ b/UE4localizationsTool/Forms/FrmLocresEntryEditor.resx @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + \ No newline at end of file diff --git a/UE4localizationsTool/Forms/FrmMain.Designer.cs b/UE4localizationsTool/Forms/FrmMain.Designer.cs index 568c743..5a2319f 100644 --- a/UE4localizationsTool/Forms/FrmMain.Designer.cs +++ b/UE4localizationsTool/Forms/FrmMain.Designer.cs @@ -1,4 +1,6 @@ using System; +using System.Windows.Forms; +using UE4localizationsTool.Controls; namespace UE4localizationsTool { @@ -46,8 +48,6 @@ private void InitializeComponent() this.toolStripSeparator1 = new System.Windows.Forms.ToolStripSeparator(); this.find = new System.Windows.Forms.ToolStripMenuItem(); this.filterToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.byNameToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.byValueToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.clearFilterToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.sortToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.nameToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); @@ -73,28 +73,29 @@ private void InitializeComponent() this.commandLinesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.donateToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.aboutToolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem(); - this.dataGridView1 = new System.Windows.Forms.DataGridView(); + this.DataCount = new System.Windows.Forms.ToolStripLabel(); + this.locresOprationsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.editSelectedRowToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.removeSelectedRowToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.addNewRowToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.mergeLocresFileToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.mergeUassetFileToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.StateLabel = new System.Windows.Forms.ToolStripLabel(); + this.dataGridView1 = new NDataGridView(); this.TextName = new System.Windows.Forms.DataGridViewTextBoxColumn(); this.TextValue = new System.Windows.Forms.DataGridViewTextBoxColumn(); this.Index = new System.Windows.Forms.DataGridViewTextBoxColumn(); - this.SearchPanal = new System.Windows.Forms.Panel(); - this.searchcount = new System.Windows.Forms.Label(); - this.SearchHide = new System.Windows.Forms.Label(); - this.FindPrevious = new System.Windows.Forms.Button(); - this.FindNext = new System.Windows.Forms.Button(); - this.label1 = new System.Windows.Forms.Label(); - this.InputSearch = new System.Windows.Forms.TextBox(); - this.contextMenuStrip1 = new System.Windows.Forms.ContextMenuStrip(this.components); - this.copyToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.pasteToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.StateLabel = new System.Windows.Forms.Label(); - this.DataCount = new System.Windows.Forms.Label(); this.pictureBox1 = new System.Windows.Forms.PictureBox(); + this.searchBox = new UE4localizationsTool.Controls.SearchBox(); + this.StatusBlock = new System.Windows.Forms.Panel(); + this.StatusText = new System.Windows.Forms.Label(); + this.StatusTitle = new System.Windows.Forms.Label(); + this.pictureBox2 = new System.Windows.Forms.PictureBox(); this.menuStrip1.SuspendLayout(); ((System.ComponentModel.ISupportInitialize)(this.dataGridView1)).BeginInit(); - this.SearchPanal.SuspendLayout(); - this.contextMenuStrip1.SuspendLayout(); ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit(); + this.StatusBlock.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox2)).BeginInit(); this.SuspendLayout(); // // menuStrip1 @@ -104,7 +105,10 @@ private void InitializeComponent() this.menuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { this.fileToolStripMenuItem, this.editToolStripMenuItem, - this.aboutToolStripMenuItem}); + this.aboutToolStripMenuItem, + this.DataCount, + this.locresOprationsToolStripMenuItem, + this.StateLabel}); this.menuStrip1.Location = new System.Drawing.Point(0, 0); this.menuStrip1.Name = "menuStrip1"; this.menuStrip1.Padding = new System.Windows.Forms.Padding(0); @@ -155,6 +159,7 @@ private void InitializeComponent() this.toolStripSeparator1, this.find, this.filterToolStripMenuItem, + this.clearFilterToolStripMenuItem, this.sortToolStripMenuItem, this.toolStripSeparator2, this.undoToolStripMenuItem, @@ -189,7 +194,7 @@ private void InitializeComponent() this.noNamesToolStripMenuItem.Enabled = false; this.noNamesToolStripMenuItem.Name = "noNamesToolStripMenuItem"; this.noNamesToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.E))); - this.noNamesToolStripMenuItem.Size = new System.Drawing.Size(180, 22); + this.noNamesToolStripMenuItem.Size = new System.Drawing.Size(178, 22); this.noNamesToolStripMenuItem.Text = "No names"; this.noNamesToolStripMenuItem.Click += new System.EventHandler(this.noNamesToolStripMenuItem_Click); // @@ -198,14 +203,14 @@ private void InitializeComponent() this.withNamesToolStripMenuItem.Enabled = false; this.withNamesToolStripMenuItem.Name = "withNamesToolStripMenuItem"; this.withNamesToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.R))); - this.withNamesToolStripMenuItem.Size = new System.Drawing.Size(180, 22); + this.withNamesToolStripMenuItem.Size = new System.Drawing.Size(178, 22); this.withNamesToolStripMenuItem.Text = "With names"; this.withNamesToolStripMenuItem.Click += new System.EventHandler(this.withNamesToolStripMenuItem_Click); // // csvFileToolStripMenuItem // this.csvFileToolStripMenuItem.Name = "csvFileToolStripMenuItem"; - this.csvFileToolStripMenuItem.Size = new System.Drawing.Size(180, 22); + this.csvFileToolStripMenuItem.Size = new System.Drawing.Size(178, 22); this.csvFileToolStripMenuItem.Text = "CSV file"; this.csvFileToolStripMenuItem.Click += new System.EventHandler(this.csvFileToolStripMenuItem_Click); // @@ -229,42 +234,23 @@ private void InitializeComponent() this.find.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.F))); this.find.Size = new System.Drawing.Size(229, 22); this.find.Text = "Find"; - this.find.Click += new System.EventHandler(this.search_Click); + this.find.Click += new System.EventHandler(this.find_Click); // // filterToolStripMenuItem // - this.filterToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { - this.byNameToolStripMenuItem, - this.byValueToolStripMenuItem, - this.clearFilterToolStripMenuItem}); this.filterToolStripMenuItem.Enabled = false; this.filterToolStripMenuItem.Name = "filterToolStripMenuItem"; this.filterToolStripMenuItem.Size = new System.Drawing.Size(229, 22); this.filterToolStripMenuItem.Text = "Filter"; - // - // byNameToolStripMenuItem - // - this.byNameToolStripMenuItem.Name = "byNameToolStripMenuItem"; - this.byNameToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.Q))); - this.byNameToolStripMenuItem.Size = new System.Drawing.Size(170, 22); - this.byNameToolStripMenuItem.Text = "By Name"; - this.byNameToolStripMenuItem.Click += new System.EventHandler(this.byNameToolStripMenuItem_Click); - // - // byValueToolStripMenuItem - // - this.byValueToolStripMenuItem.Name = "byValueToolStripMenuItem"; - this.byValueToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.W))); - this.byValueToolStripMenuItem.Size = new System.Drawing.Size(170, 22); - this.byValueToolStripMenuItem.Text = "By Value"; - this.byValueToolStripMenuItem.Click += new System.EventHandler(this.byValueToolStripMenuItem_Click); + this.filterToolStripMenuItem.Click += new System.EventHandler(this.filterToolStripMenuItem_Click); // // clearFilterToolStripMenuItem // this.clearFilterToolStripMenuItem.Enabled = false; this.clearFilterToolStripMenuItem.Name = "clearFilterToolStripMenuItem"; - this.clearFilterToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.D))); - this.clearFilterToolStripMenuItem.Size = new System.Drawing.Size(170, 22); + this.clearFilterToolStripMenuItem.Size = new System.Drawing.Size(229, 22); this.clearFilterToolStripMenuItem.Text = "Clear filter"; + this.clearFilterToolStripMenuItem.Visible = false; this.clearFilterToolStripMenuItem.Click += new System.EventHandler(this.clearFilterToolStripMenuItem_Click); // // sortToolStripMenuItem @@ -459,15 +445,76 @@ private void InitializeComponent() this.aboutToolStripMenuItem1.Text = "About"; this.aboutToolStripMenuItem1.Click += new System.EventHandler(this.aboutToolStripMenuItem1_Click); // + // DataCount + // + this.DataCount.Alignment = System.Windows.Forms.ToolStripItemAlignment.Right; + this.DataCount.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Text; + this.DataCount.Name = "DataCount"; + this.DataCount.Size = new System.Drawing.Size(57, 21); + this.DataCount.Text = "----------"; + // + // locresOprationsToolStripMenuItem + // + this.locresOprationsToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.editSelectedRowToolStripMenuItem, + this.removeSelectedRowToolStripMenuItem, + this.addNewRowToolStripMenuItem, + this.mergeLocresFileToolStripMenuItem, + this.mergeUassetFileToolStripMenuItem}); + this.locresOprationsToolStripMenuItem.Name = "locresOprationsToolStripMenuItem"; + this.locresOprationsToolStripMenuItem.Size = new System.Drawing.Size(112, 24); + this.locresOprationsToolStripMenuItem.Text = "Locres operations"; + // + // editSelectedRowToolStripMenuItem + // + this.editSelectedRowToolStripMenuItem.Name = "editSelectedRowToolStripMenuItem"; + this.editSelectedRowToolStripMenuItem.Size = new System.Drawing.Size(203, 22); + this.editSelectedRowToolStripMenuItem.Text = "Edit Selected Row"; + this.editSelectedRowToolStripMenuItem.Click += new System.EventHandler(this.editSelectedRowToolStripMenuItem_Click); + // + // removeSelectedRowToolStripMenuItem + // + this.removeSelectedRowToolStripMenuItem.Name = "removeSelectedRowToolStripMenuItem"; + this.removeSelectedRowToolStripMenuItem.Size = new System.Drawing.Size(203, 22); + this.removeSelectedRowToolStripMenuItem.Text = "Remove Selected Row(s)"; + this.removeSelectedRowToolStripMenuItem.Click += new System.EventHandler(this.removeSelectedRowToolStripMenuItem_Click); + // + // addNewRowToolStripMenuItem + // + this.addNewRowToolStripMenuItem.Name = "addNewRowToolStripMenuItem"; + this.addNewRowToolStripMenuItem.Size = new System.Drawing.Size(203, 22); + this.addNewRowToolStripMenuItem.Text = "Add New Row"; + this.addNewRowToolStripMenuItem.Click += new System.EventHandler(this.addNewRowToolStripMenuItem_Click); + // + // mergeLocresFileToolStripMenuItem + // + this.mergeLocresFileToolStripMenuItem.Name = "mergeLocresFileToolStripMenuItem"; + this.mergeLocresFileToolStripMenuItem.Size = new System.Drawing.Size(203, 22); + this.mergeLocresFileToolStripMenuItem.Text = "Merge Locres File"; + this.mergeLocresFileToolStripMenuItem.Click += new System.EventHandler(this.mergeLocresFileToolStripMenuItem_Click); + // + // mergeUassetFileToolStripMenuItem + // + this.mergeUassetFileToolStripMenuItem.Name = "mergeUassetFileToolStripMenuItem"; + this.mergeUassetFileToolStripMenuItem.Size = new System.Drawing.Size(203, 22); + this.mergeUassetFileToolStripMenuItem.Text = "Merge Uasset File (Beta)"; + this.mergeUassetFileToolStripMenuItem.Click += new System.EventHandler(this.mergeUassetFileToolStripMenuItem_Click); + // + // StateLabel + // + this.StateLabel.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Text; + this.StateLabel.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Bold); + this.StateLabel.ForeColor = System.Drawing.Color.Maroon; + this.StateLabel.Name = "StateLabel"; + this.StateLabel.Size = new System.Drawing.Size(57, 21); + this.StateLabel.Text = "----------"; + // // dataGridView1 // this.dataGridView1.AllowUserToAddRows = false; this.dataGridView1.AllowUserToDeleteRows = false; this.dataGridView1.AllowUserToOrderColumns = true; this.dataGridView1.AllowUserToResizeRows = false; - this.dataGridView1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) - | System.Windows.Forms.AnchorStyles.Left) - | System.Windows.Forms.AnchorStyles.Right))); this.dataGridView1.BackgroundColor = System.Drawing.SystemColors.Window; this.dataGridView1.BorderStyle = System.Windows.Forms.BorderStyle.None; this.dataGridView1.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize; @@ -475,23 +522,24 @@ private void InitializeComponent() this.TextName, this.TextValue, this.Index}); + this.dataGridView1.Dock = System.Windows.Forms.DockStyle.Fill; this.dataGridView1.ImeMode = System.Windows.Forms.ImeMode.Disable; - this.dataGridView1.Location = new System.Drawing.Point(0, 23); - this.dataGridView1.MultiSelect = false; + this.dataGridView1.IsFilterApplied = false; + this.dataGridView1.Location = new System.Drawing.Point(0, 24); this.dataGridView1.Name = "dataGridView1"; this.dataGridView1.RowHeadersVisible = false; this.dataGridView1.RowHeadersWidth = 51; this.dataGridView1.ScrollBars = System.Windows.Forms.ScrollBars.Vertical; - this.dataGridView1.Size = new System.Drawing.Size(689, 427); + this.dataGridView1.Size = new System.Drawing.Size(689, 396); this.dataGridView1.TabIndex = 1; - this.dataGridView1.CellBeginEdit += new System.Windows.Forms.DataGridViewCellCancelEventHandler(this.dataGridView1_CellBeginEdit); - this.dataGridView1.CellEndEdit += new System.Windows.Forms.DataGridViewCellEventHandler(this.dataGridView1_CellEndEdit); + this.dataGridView1.FilterApplied += new System.EventHandler(this.dataGridView1_FilterApplied); + this.dataGridView1.FilterCleared += new System.EventHandler(this.dataGridView1_FilterCleared); + this.dataGridView1.CellFormatting += new System.Windows.Forms.DataGridViewCellFormattingEventHandler(this.dataGridView1_CellFormatting); this.dataGridView1.CellValidated += new System.Windows.Forms.DataGridViewCellEventHandler(this.dataGridView1_CellValidated); this.dataGridView1.CellValidating += new System.Windows.Forms.DataGridViewCellValidatingEventHandler(this.dataGridView1_CellValidating); this.dataGridView1.CellValueChanged += new System.Windows.Forms.DataGridViewCellEventHandler(this.dataGridView1_CellValueChanged); + this.dataGridView1.CellValuePushed += new System.Windows.Forms.DataGridViewCellValueEventHandler(this.dataGridView1_CellValuePushed); this.dataGridView1.Sorted += new System.EventHandler(this.dataGridView1_Sorted); - this.dataGridView1.KeyDown += new System.Windows.Forms.KeyEventHandler(this.dataGridView1_KeyDown); - this.dataGridView1.MouseDown += new System.Windows.Forms.MouseEventHandler(this.dataGridView1_MouseDown); // // TextName // @@ -518,130 +566,6 @@ private void InitializeComponent() this.Index.Visible = false; this.Index.Width = 125; // - // SearchPanal - // - this.SearchPanal.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left) - | System.Windows.Forms.AnchorStyles.Right))); - this.SearchPanal.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; - this.SearchPanal.Controls.Add(this.searchcount); - this.SearchPanal.Controls.Add(this.SearchHide); - this.SearchPanal.Controls.Add(this.FindPrevious); - this.SearchPanal.Controls.Add(this.FindNext); - this.SearchPanal.Controls.Add(this.label1); - this.SearchPanal.Controls.Add(this.InputSearch); - this.SearchPanal.Location = new System.Drawing.Point(0, 420); - this.SearchPanal.Name = "SearchPanal"; - this.SearchPanal.Size = new System.Drawing.Size(689, 30); - this.SearchPanal.TabIndex = 2; - this.SearchPanal.Visible = false; - // - // searchcount - // - this.searchcount.Location = new System.Drawing.Point(423, 7); - this.searchcount.Name = "searchcount"; - this.searchcount.Size = new System.Drawing.Size(211, 18); - this.searchcount.TabIndex = 6; - this.searchcount.Click += new System.EventHandler(this.label2_Click); - // - // SearchHide - // - this.SearchHide.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) - | System.Windows.Forms.AnchorStyles.Right))); - this.SearchHide.AutoSize = true; - this.SearchHide.Cursor = System.Windows.Forms.Cursors.Hand; - this.SearchHide.Font = new System.Drawing.Font("Microsoft Sans Serif", 10F, System.Drawing.FontStyle.Bold); - this.SearchHide.Location = new System.Drawing.Point(664, 6); - this.SearchHide.Name = "SearchHide"; - this.SearchHide.Size = new System.Drawing.Size(18, 17); - this.SearchHide.TabIndex = 5; - this.SearchHide.Text = "X"; - this.SearchHide.Click += new System.EventHandler(this.SearchHide_Click); - // - // FindPrevious - // - this.FindPrevious.Location = new System.Drawing.Point(331, 4); - this.FindPrevious.Name = "FindPrevious"; - this.FindPrevious.Size = new System.Drawing.Size(86, 23); - this.FindPrevious.TabIndex = 4; - this.FindPrevious.Text = "Find Previous"; - this.FindPrevious.UseVisualStyleBackColor = true; - this.FindPrevious.Click += new System.EventHandler(this.FindPrevious_Click); - // - // FindNext - // - this.FindNext.Location = new System.Drawing.Point(250, 4); - this.FindNext.Name = "FindNext"; - this.FindNext.Size = new System.Drawing.Size(75, 23); - this.FindNext.TabIndex = 3; - this.FindNext.Text = "Find Next"; - this.FindNext.UseVisualStyleBackColor = true; - this.FindNext.Click += new System.EventHandler(this.FindNext_Click); - // - // label1 - // - this.label1.AutoSize = true; - this.label1.Location = new System.Drawing.Point(7, 9); - this.label1.Name = "label1"; - this.label1.Size = new System.Drawing.Size(56, 13); - this.label1.TabIndex = 1; - this.label1.Text = "Find what:"; - // - // InputSearch - // - this.InputSearch.Location = new System.Drawing.Point(79, 5); - this.InputSearch.Name = "InputSearch"; - this.InputSearch.Size = new System.Drawing.Size(162, 20); - this.InputSearch.TabIndex = 0; - this.InputSearch.KeyDown += new System.Windows.Forms.KeyEventHandler(this.InputSearch_KeyDown); - // - // contextMenuStrip1 - // - this.contextMenuStrip1.ImageScalingSize = new System.Drawing.Size(20, 20); - this.contextMenuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { - this.copyToolStripMenuItem, - this.pasteToolStripMenuItem}); - this.contextMenuStrip1.Name = "contextMenuStrip1"; - this.contextMenuStrip1.Size = new System.Drawing.Size(145, 48); - // - // copyToolStripMenuItem - // - this.copyToolStripMenuItem.Name = "copyToolStripMenuItem"; - this.copyToolStripMenuItem.ShortcutKeyDisplayString = "Ctrl+C"; - this.copyToolStripMenuItem.Size = new System.Drawing.Size(144, 22); - this.copyToolStripMenuItem.Text = "Copy"; - this.copyToolStripMenuItem.Click += new System.EventHandler(this.copyToolStripMenuItem_Click); - // - // pasteToolStripMenuItem - // - this.pasteToolStripMenuItem.Name = "pasteToolStripMenuItem"; - this.pasteToolStripMenuItem.ShortcutKeyDisplayString = "Ctrl+V"; - this.pasteToolStripMenuItem.Size = new System.Drawing.Size(144, 22); - this.pasteToolStripMenuItem.Text = "Paste"; - this.pasteToolStripMenuItem.Click += new System.EventHandler(this.pasteToolStripMenuItem_Click); - // - // StateLabel - // - this.StateLabel.AutoSize = true; - this.StateLabel.Location = new System.Drawing.Point(143, 5); - this.StateLabel.Name = "StateLabel"; - this.StateLabel.Size = new System.Drawing.Size(64, 13); - this.StateLabel.TabIndex = 3; - this.StateLabel.Tag = ""; - this.StateLabel.Text = "-------------------"; - // - // DataCount - // - this.DataCount.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); - this.DataCount.AutoSize = true; - this.DataCount.ImageAlign = System.Drawing.ContentAlignment.BottomCenter; - this.DataCount.Location = new System.Drawing.Point(658, 5); - this.DataCount.Name = "DataCount"; - this.DataCount.Size = new System.Drawing.Size(25, 13); - this.DataCount.TabIndex = 5; - this.DataCount.Text = "------"; - this.DataCount.TextAlign = System.Drawing.ContentAlignment.TopRight; - this.DataCount.TextChanged += new System.EventHandler(this.DataCount_TextChanged); - // // pictureBox1 // this.pictureBox1.BackColor = System.Drawing.Color.Green; @@ -652,18 +576,73 @@ private void InitializeComponent() this.pictureBox1.TabStop = false; this.pictureBox1.Visible = false; // + // searchBox + // + this.searchBox.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; + this.searchBox.DataGridView = this.dataGridView1; + this.searchBox.Dock = System.Windows.Forms.DockStyle.Bottom; + this.searchBox.Location = new System.Drawing.Point(0, 420); + this.searchBox.Name = "searchBox"; + this.searchBox.Size = new System.Drawing.Size(689, 30); + this.searchBox.TabIndex = 2; + this.searchBox.Visible = false; + // + // StatusBlock + // + this.StatusBlock.Anchor = System.Windows.Forms.AnchorStyles.None; + this.StatusBlock.AutoSize = true; + this.StatusBlock.BackColor = System.Drawing.Color.White; + this.StatusBlock.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; + this.StatusBlock.Controls.Add(this.StatusText); + this.StatusBlock.Controls.Add(this.StatusTitle); + this.StatusBlock.Controls.Add(this.pictureBox2); + this.StatusBlock.Location = new System.Drawing.Point(189, 174); + this.StatusBlock.Name = "StatusBlock"; + this.StatusBlock.Size = new System.Drawing.Size(310, 103); + this.StatusBlock.TabIndex = 8; + this.StatusBlock.Visible = false; + // + // StatusText + // + this.StatusText.AutoSize = true; + this.StatusText.Location = new System.Drawing.Point(106, 65); + this.StatusText.Name = "StatusText"; + this.StatusText.Size = new System.Drawing.Size(28, 13); + this.StatusText.TabIndex = 2; + this.StatusText.Text = "-------"; + // + // StatusTitle + // + this.StatusTitle.AutoSize = true; + this.StatusTitle.Font = new System.Drawing.Font("Microsoft Sans Serif", 20F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.StatusTitle.Location = new System.Drawing.Point(103, 22); + this.StatusTitle.Name = "StatusTitle"; + this.StatusTitle.Size = new System.Drawing.Size(114, 31); + this.StatusTitle.TabIndex = 0; + this.StatusTitle.Text = "----------"; + // + // pictureBox2 + // + this.pictureBox2.BackColor = System.Drawing.Color.Transparent; + this.pictureBox2.Image = ((System.Drawing.Image)(resources.GetObject("pictureBox2.Image"))); + this.pictureBox2.Location = new System.Drawing.Point(9, 12); + this.pictureBox2.Name = "pictureBox2"; + this.pictureBox2.Size = new System.Drawing.Size(82, 78); + this.pictureBox2.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.pictureBox2.TabIndex = 1; + this.pictureBox2.TabStop = false; + // // FrmMain // this.AllowDrop = true; this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.ClientSize = new System.Drawing.Size(689, 450); - this.Controls.Add(this.DataCount); - this.Controls.Add(this.StateLabel); - this.Controls.Add(this.SearchPanal); - this.Controls.Add(this.dataGridView1); + this.Controls.Add(this.StatusBlock); this.Controls.Add(this.pictureBox1); + this.Controls.Add(this.dataGridView1); this.Controls.Add(this.menuStrip1); + this.Controls.Add(this.searchBox); this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); this.MainMenuStrip = this.menuStrip1; this.MinimumSize = new System.Drawing.Size(704, 487); @@ -676,10 +655,10 @@ private void InitializeComponent() this.menuStrip1.ResumeLayout(false); this.menuStrip1.PerformLayout(); ((System.ComponentModel.ISupportInitialize)(this.dataGridView1)).EndInit(); - this.SearchPanal.ResumeLayout(false); - this.SearchPanal.PerformLayout(); - this.contextMenuStrip1.ResumeLayout(false); ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit(); + this.StatusBlock.ResumeLayout(false); + this.StatusBlock.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox2)).EndInit(); this.ResumeLayout(false); this.PerformLayout(); @@ -695,35 +674,20 @@ private void InitializeComponent() private System.Windows.Forms.ToolStripMenuItem exportAllTextToolStripMenuItem; private System.Windows.Forms.ToolStripMenuItem importAllTextToolStripMenuItem; private System.Windows.Forms.ToolStripMenuItem aboutToolStripMenuItem; - private System.Windows.Forms.DataGridView dataGridView1; + private NDataGridView dataGridView1; private System.Windows.Forms.ToolStripSeparator toolStripSeparator1; private System.Windows.Forms.ToolStripMenuItem find; - private System.Windows.Forms.Panel SearchPanal; - private System.Windows.Forms.Label SearchHide; - private System.Windows.Forms.Button FindPrevious; - private System.Windows.Forms.Button FindNext; - private System.Windows.Forms.Label label1; - private System.Windows.Forms.TextBox InputSearch; - private System.Windows.Forms.ContextMenuStrip contextMenuStrip1; - private System.Windows.Forms.ToolStripMenuItem copyToolStripMenuItem; - private System.Windows.Forms.ToolStripMenuItem pasteToolStripMenuItem; private System.Windows.Forms.ToolStripSeparator toolStripSeparator2; private System.Windows.Forms.ToolStripMenuItem copyToolStripMenuItem1; private System.Windows.Forms.ToolStripMenuItem pasteToolStripMenuItem1; private System.Windows.Forms.ToolStripSeparator toolStripSeparator3; private System.Windows.Forms.ToolStripMenuItem fontToolStripMenuItem; private System.Windows.Forms.ToolStripMenuItem rightToLeftToolStripMenuItem; - private System.Windows.Forms.Label StateLabel; private System.Windows.Forms.ToolStripMenuItem undoToolStripMenuItem; private System.Windows.Forms.ToolStripMenuItem redoToolStripMenuItem; private System.Windows.Forms.ToolStripMenuItem commandLinesToolStripMenuItem; private System.Windows.Forms.ToolStripMenuItem aboutToolStripMenuItem1; private System.Windows.Forms.ToolStripMenuItem filterToolStripMenuItem; - private System.Windows.Forms.ToolStripMenuItem byValueToolStripMenuItem; - private System.Windows.Forms.ToolStripMenuItem byNameToolStripMenuItem; - private System.Windows.Forms.ToolStripMenuItem clearFilterToolStripMenuItem; - private System.Windows.Forms.Label DataCount; - private System.Windows.Forms.Label searchcount; private System.Windows.Forms.ToolStripMenuItem noNamesToolStripMenuItem; private System.Windows.Forms.ToolStripMenuItem withNamesToolStripMenuItem; private System.Windows.Forms.ToolStripMenuItem sortToolStripMenuItem; @@ -744,6 +708,20 @@ private void InitializeComponent() private System.Windows.Forms.DataGridViewTextBoxColumn Index; private System.Windows.Forms.ToolStripMenuItem Checkforupdates; private System.Windows.Forms.ToolStripMenuItem csvFileToolStripMenuItem; + private Controls.SearchBox searchBox; + private System.Windows.Forms.ToolStripMenuItem clearFilterToolStripMenuItem; + private ToolStripLabel StateLabel; + private ToolStripLabel DataCount; + private ToolStripMenuItem locresOprationsToolStripMenuItem; + private ToolStripMenuItem editSelectedRowToolStripMenuItem; + private ToolStripMenuItem removeSelectedRowToolStripMenuItem; + private ToolStripMenuItem addNewRowToolStripMenuItem; + private ToolStripMenuItem mergeLocresFileToolStripMenuItem; + private Label StatusText; + private Label StatusTitle; + private PictureBox pictureBox2; + private Panel StatusBlock; + private ToolStripMenuItem mergeUassetFileToolStripMenuItem; } } diff --git a/UE4localizationsTool/Forms/FrmMain.cs b/UE4localizationsTool/Forms/FrmMain.cs index e6121b4..a52e401 100644 --- a/UE4localizationsTool/Forms/FrmMain.cs +++ b/UE4localizationsTool/Forms/FrmMain.cs @@ -1,94 +1,37 @@ using AssetParser; using System; -using System.Collections.Generic; +using System.Data; using System.Diagnostics; -using System.Drawing; using System.Globalization; using System.IO; using System.Linq; using System.Net; -using System.Text; using System.Text.RegularExpressions; using System.Threading.Tasks; using System.Windows.Forms; using UE4localizationsTool.Controls; +using UE4localizationsTool.Core.locres; +using UE4localizationsTool.Forms; using UE4localizationsTool.Helper; namespace UE4localizationsTool { - - - public partial class FrmMain : NForm { - struct DataRow - { - public int Index; - public string StringValue; - } - IAsset Asset; String ToolName = Application.ProductName + " v" + Application.ProductVersion; string FilePath = ""; - FrmState state; - Stack BackupDataUndo; - Stack BackupDataRedo; - List> ListrefValues; - List ListBackupValues; - bool Filter = false; bool SortApply = false; - bool ClearTemp = true; - List FindArray; - int FindIndex; - string OldFind; public FrmMain() { InitializeComponent(); - dataGridView1.RowsAdded += (x, y) => this.UpdateCounter(); - dataGridView1.RowsRemoved += (x, y) => this.UpdateCounter(); + dataGridView1.RowCountChanged += (x, y) => this.UpdateCounter(); ResetControls(); pictureBox1.Height = menuStrip1.Height; darkModeToolStripMenuItem.Checked = Properties.Settings.Default.DarkMode; Checkforupdates.Checked = Properties.Settings.Default.CheckForUpdates; } - - - private void AddToDataView() - { - - if (ListrefValues == null) return; - int Index = 0; - List rows = new List(); - foreach (var item in ListrefValues) - { - var newRow = new DataGridViewRow(); - newRow.CreateCells(dataGridView1); - newRow.Cells[0].Value = item[0]; - newRow.Cells[1].Value = item[1]; - newRow.Cells[2].Value = Index; - - if (item.Count > 2) - { - newRow.Cells[1].ToolTipText = item[2]; - if (item.Count > 3) - { - newRow.Cells[0].Style.BackColor = System.Drawing.ColorTranslator.FromHtml(item[3]); - } - if (item.Count > 4) - { - newRow.Cells[0].Style.ForeColor = System.Drawing.ColorTranslator.FromHtml(item[4]); - } - } - - rows.Add(newRow); - Index++; - } - - dataGridView1.Rows.AddRange(rows.ToArray()); - - dataGridView1.AutoResizeRows(); - } private void OpenFile_Click(object sender, EventArgs e) { OpenFileDialog ofd = new OpenFileDialog(); @@ -111,19 +54,18 @@ public async void LoadFile(string filePath) try { - state = new FrmState(this, "loading File", "loading File please wait..."); - this.BeginInvoke(new Action(() => state.ShowDialog())); - + StatusMessage("loading File...", "loading File, please wait."); if (filePath.ToLower().EndsWith(".locres")) { - Asset = await Task.Run(() => new locres(filePath)); + Asset = await Task.Run(() => new LocresFile(filePath)); + locresOprationsToolStripMenuItem.Visible = true; CreateBackupList(); } else if (filePath.ToLower().EndsWith(".uasset") || filePath.ToLower().EndsWith(".umap")) { IUasset Uasset = await Task.Run(() => Uexp.GetUasset(filePath)); - Uasset.UseMethod2 = Uasset.UseMethod2? Uasset.UseMethod2 : Method2.Checked; + Uasset.UseMethod2 = Uasset.UseMethod2 ? Uasset.UseMethod2 : Method2.Checked; Asset = await Task.Run(() => new Uexp(Uasset)); CreateBackupList(); if (!Asset.IsGood) @@ -135,11 +77,11 @@ public async void LoadFile(string filePath) this.FilePath = filePath; this.Text = ToolName + " - " + Path.GetFileName(FilePath); ControlsMode(true); - state.Close(); + CloseFromState(); } catch (Exception ex) { - state.Close(); + CloseFromState(); MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } @@ -147,28 +89,17 @@ public async void LoadFile(string filePath) private void CreateBackupList() { - ListBackupValues = new List(); - ListrefValues = Asset.Strings; - ListrefValues.ForEach(Text => ListBackupValues.Add(Text[1])); - AddToDataView(); + Asset.AddItemsToDataGridView(dataGridView1); } private void ResetControls() { - dataGridView1.Rows.Clear(); FilePath = ""; StateLabel.Text = ""; DataCount.Text = ""; Text = ToolName; - BackupDataUndo = new Stack(); - BackupDataRedo = new Stack(); - Filter = false; SortApply = false; - FindArray = new List(); - ClearTemp = true; - FindIndex = 0; - OldFind = ""; - searchcount.Text = ""; + locresOprationsToolStripMenuItem.Visible = false; } private void ControlsMode(bool Enabled) @@ -193,23 +124,8 @@ enum ExportType private void ExportAll(ExportType exportType) { - List DataGridStrings = new List(); - if (this.SortApply) SortDataGrid(2, true); - if (exportType == ExportType.WithNames) - { - DataGridStrings.Add(@"[~NAMES-INCLUDED~]//Don't edit or remove this line."); - } - for (int i = 0; i < dataGridView1.Rows.Count; i++) - { - if (exportType == ExportType.WithNames) - { - DataGridStrings.Add(ObjectToString(dataGridView1.Rows[i].Cells[0].Value) + "=" + ObjectToString(dataGridView1.Rows[i].Cells[1].Value)); - continue; - } - DataGridStrings.Add(ObjectToString(dataGridView1.Rows[i].Cells[1].Value)); - } SaveFileDialog sfd = new SaveFileDialog(); sfd.Filter = "Text File|*.txt"; sfd.Title = "Export All Text"; @@ -220,9 +136,26 @@ private void ExportAll(ExportType exportType) { try { - System.IO.File.WriteAllLines(sfd.FileName, DataGridStrings); - if (Filter) + using (var stream = new StreamWriter(sfd.FileName)) + { + if (exportType == ExportType.WithNames) + { + stream.WriteLine(@"[~NAMES-INCLUDED~]//Don't edit or remove this line."); + } + + for (int i = 0; i < dataGridView1.Rows.Count; i++) + { + if (exportType == ExportType.WithNames) + { + stream.WriteLine(dataGridView1.Rows[i].Cells["Name"].Value.ToString() + "=" + dataGridView1.Rows[i].Cells["Text value"].Value.ToString()); + continue; + } + stream.WriteLine(dataGridView1.Rows[i].Cells["Text value"].Value.ToString()); + } + + } + if (dataGridView1.IsFilterApplied) { MessageBox.Show("Successful export!\n Remember to apply the same filter you using right now before 'import'.", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information); } @@ -240,7 +173,7 @@ private void ExportAll(ExportType exportType) private void importAllTextToolStripMenuItem_Click(object sender, EventArgs e) { - + OpenFileDialog ofd = new OpenFileDialog(); ofd.Filter = "Text File|*.txt;*.csv"; ofd.Title = "Import All Text"; @@ -249,7 +182,7 @@ private void importAllTextToolStripMenuItem_Click(object sender, EventArgs e) { if (this.SortApply) SortDataGrid(2, true); - if (ofd.FileName.EndsWith(".csv",StringComparison.InvariantCulture)) + if (ofd.FileName.EndsWith(".csv", StringComparison.InvariantCulture)) { try { @@ -265,7 +198,7 @@ private void importAllTextToolStripMenuItem_Click(object sender, EventArgs e) } - + string[] DataGridStrings; try { @@ -305,7 +238,7 @@ private void importAllTextToolStripMenuItem_Click(object sender, EventArgs e) for (int n = 0; n < dataGridView1.Rows.Count; n++) { - dataGridView1.Rows[n].Cells[1].Value = DataGridStrings[n]; + dataGridView1.SetValue(dataGridView1.Rows[n].Cells["Text value"], DataGridStrings[n]); } MessageBox.Show("Successful import!", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information); @@ -339,146 +272,29 @@ private async void SaveFile(object sender, EventArgs e) { try { - state = new FrmState(this, "Saving File", "Saving File please wait..."); - this.BeginInvoke(new Action(() => state.ShowDialog())); + StatusMessage("Saving File...", "Saving File ,please wait."); + Asset.LoadFromDataGridView(dataGridView1); await Task.Run(() => Asset.SaveFile(sfd.FileName)); + MessageBox.Show("Saved Successful.", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information); } catch (Exception ex) { + MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } - state.Close(); - } - } - - private void SearchHide_Click(object sender, EventArgs e) - { - SearchPanal.Visible = false; - dataGridView1.Height += SearchPanal.Height; - } - - private void search_Click(object sender, EventArgs e) - { - SearchPanal.Visible = !SearchPanal.Visible; - if (SearchPanal.Visible) - { - - dataGridView1.Height -= SearchPanal.Height; - if (dataGridView1.SelectedCells.Count > 0) - { - InputSearch.Text = ObjectToString(dataGridView1.SelectedCells[0].Value); - } - InputSearch.Focus(); - InputSearch.SelectAll(); - } - else - { - dataGridView1.Height += SearchPanal.Height; - } - - - } - - - private void Find_Click(object sender, EventArgs e) - { - FindArray.Clear(); - OldFind = InputSearch.Text; - for (int i = 0; i < dataGridView1.Rows.Count; i++) - { - if (ObjectToString(dataGridView1.Rows[i].Cells[1].Value).ToLower().Contains(InputSearch.Text.ToLower())) - { - FindArray.Add(i); - } - } - - if (FindArray.Count == 0 || InputSearch.Text == "") - { - MessageBox.Show($"can't find '{InputSearch.Text}'", "No results", MessageBoxButtons.OK, MessageBoxIcon.Information); - FindArray.Clear(); - searchcount.Text = "found: " + FindArray.Count; - return; - } - dataGridView1.ClearSelection(); - dataGridView1.Rows[FindArray[0]].Selected = true; - dataGridView1.FirstDisplayedScrollingRowIndex = FindArray[0]; - FindIndex = 0; - searchcount.Text = "found: " + FindArray.Count; - } - - private void FindNext_Click(object sender, EventArgs e) - { - if (FindArray.Count == 0 || OldFind != InputSearch.Text) - { - Find_Click(sender, e); - return; - } - FindIndex++; - if (FindIndex < FindArray.Count) - { - dataGridView1.ClearSelection(); - dataGridView1.Rows[FindArray[FindIndex]].Selected = true; - dataGridView1.FirstDisplayedScrollingRowIndex = FindArray[FindIndex]; - } - else - { - FindIndex = 0; - dataGridView1.ClearSelection(); - dataGridView1.Rows[FindArray[FindIndex]].Selected = true; - dataGridView1.FirstDisplayedScrollingRowIndex = FindArray[FindIndex]; - } - } - - private void FindPrevious_Click(object sender, EventArgs e) - { - if (FindArray.Count == 0 || OldFind != InputSearch.Text) - { - Find_Click(sender, e); - return; - } - FindIndex--; - if (FindIndex > -1) - { - dataGridView1.ClearSelection(); - dataGridView1.Rows[FindArray[FindIndex]].Selected = true; - dataGridView1.FirstDisplayedScrollingRowIndex = FindArray[FindIndex]; - } - else - { - FindIndex = FindArray.Count - 1; - dataGridView1.ClearSelection(); - dataGridView1.Rows[FindArray[FindIndex]].Selected = true; - dataGridView1.FirstDisplayedScrollingRowIndex = FindArray[FindIndex]; - } - } - - private void dataGridView1_MouseDown(object sender, MouseEventArgs e) - { - if (e.Button == MouseButtons.Right) - { - contextMenuStrip1.Show(this, new Point(e.X + ((Control)sender).Left, e.Y + ((Control)sender).Top)); - + CloseFromState(); } } private void copyToolStripMenuItem_Click(object sender, EventArgs e) { - if (dataGridView1.SelectedCells.Count > 0) - Clipboard.SetText(dataGridView1.SelectedCells[0].Value.ToString()); + dataGridView1.Copy(); } private void pasteToolStripMenuItem_Click(object sender, EventArgs e) { - if (dataGridView1.SelectedCells.Count > 0) - { - if (BackupDataUndo.Count == 0) - { - BackupDataRedo.Clear(); - } - BackupDataUndo.Push(new DataRow() { Index = dataGridView1.SelectedCells[0].RowIndex, StringValue = ObjectToString(dataGridView1.Rows[dataGridView1.SelectedCells[0].RowIndex].Cells[1].Value) }); - dataGridView1.Rows[dataGridView1.SelectedCells[0].RowIndex].Cells[1].Value = Clipboard.GetText(); - } + dataGridView1.Paste(); } private void exitToolStripMenuItem_Click(object sender, EventArgs e) @@ -486,27 +302,6 @@ private void exitToolStripMenuItem_Click(object sender, EventArgs e) Application.Exit(); } - private void InputSearch_KeyDown(object sender, KeyEventArgs e) - { - if (!InputSearch.Focused) - { - InputSearch.Focus(); - } - - if (e.KeyCode == Keys.Enter) - { - FindNext_Click(sender, e); - } - - } - - private void dataGridView1_Scroll(object sender, ScrollEventArgs e) - { - dataGridView1.ClearSelection(); - dataGridView1.Rows[dataGridView1.FirstDisplayedScrollingRowIndex].Selected = true; - } - - private void fontToolStripMenuItem_Click(object sender, EventArgs e) { @@ -520,141 +315,21 @@ private void fontToolStripMenuItem_Click(object sender, EventArgs e) } } - private void dataGridView1_KeyDown(object sender, KeyEventArgs e) - { - - if (dataGridView1.CancelEdit() && dataGridView1.Focused) - { - if (e.KeyCode == Keys.V && e.Control) - { - pasteToolStripMenuItem_Click(sender, e); - } - else if (e.KeyCode == Keys.Z && e.Control) - { - undoToolStripMenuItem_Click(sender, e); - - } - else if ((e.KeyCode == Keys.Y && e.Control) || (e.KeyCode == Keys.Z && e.Control && e.Shift)) - { - redoToolStripMenuItem_Click(sender, e); - } - - - else if (e.KeyCode == Keys.L && e.Control && e.Alt) - { - dataGridView1.RightToLeft = RightToLeft.No; - } - else if (e.KeyCode == Keys.R && e.Control && e.Alt) - { - dataGridView1.RightToLeft = RightToLeft.Yes; - } - - - } - } - private void rightToLeftToolStripMenuItem_Click(object sender, EventArgs e) { dataGridView1.RightToLeft = dataGridView1.RightToLeft == RightToLeft.Yes ? RightToLeft.No : RightToLeft.Yes; } - private void dataGridView1_CellBeginEdit(object sender, DataGridViewCellCancelEventArgs e) - { - BackupDataUndo.Push(new DataRow() { Index = e.RowIndex, StringValue = ObjectToString(dataGridView1.Rows[e.RowIndex].Cells[1].Value) }); - } - - private void dataGridView1_CellEndEdit(object sender, DataGridViewCellEventArgs e) - { - - if (BackupDataUndo.Peek().StringValue == ObjectToString(dataGridView1.Rows[e.RowIndex].Cells[1].Value)) - { - BackupDataUndo.Pop(); - return; - } - - if (BackupDataUndo.Count == 0) - { - BackupDataRedo.Clear(); - } - } - - private void dataGridView1_CellValueChanged(object sender, DataGridViewCellEventArgs e) - { - if (dataGridView1.Created) - { - ListrefValues[int.Parse(dataGridView1.Rows[e.RowIndex].Cells[2].Value.ToString())][1] = ObjectToString(dataGridView1.Rows[e.RowIndex].Cells[1].Value); - if (ListrefValues[int.Parse(dataGridView1.Rows[e.RowIndex].Cells[2].Value.ToString())][1] != ListBackupValues[int.Parse(dataGridView1.Rows[e.RowIndex].Cells[2].Value.ToString())]) - { - dataGridView1.Rows[e.RowIndex].Cells[1].Style.BackColor = System.Drawing.Color.FromArgb(255, 204, 153); - dataGridView1.Rows[e.RowIndex].Cells[1].Style.ForeColor = Color.Black; - } - else - { - dataGridView1.Rows[e.RowIndex].Cells[1].Style.BackColor = dataGridView1.DefaultCellStyle.BackColor; - dataGridView1.Rows[e.RowIndex].Cells[1].Style.ForeColor = dataGridView1.DefaultCellStyle.ForeColor; - - } - this.Text = ToolName + " - " + Path.GetFileName(FilePath) + "*"; - if (ClearTemp) - { - BackupDataRedo.Clear(); - ClearTemp = false; - } - } - } - private void undoToolStripMenuItem_Click(object sender, EventArgs e) { - - if (BackupDataUndo.Count > 0) - { - - DataRow dataRow = BackupDataUndo.Pop(); - BackupDataRedo.Push(new DataRow() { Index = dataRow.Index, StringValue = ObjectToString(dataGridView1.Rows[dataRow.Index].Cells[1].Value) }); - ClearTemp = false; - //MessageBox.Show(dataRow.StringValue); - dataGridView1.Rows[dataRow.Index].Cells[1].Value = dataRow.StringValue; - ClearTemp = true; - if (dataRow.StringValue == ListBackupValues[dataRow.Index]) - { - dataGridView1.Rows[dataRow.Index].Cells[1].Style.BackColor = dataGridView1.DefaultCellStyle.BackColor; - dataGridView1.Rows[dataRow.Index].Cells[1].Style.ForeColor = dataGridView1.DefaultCellStyle.ForeColor; - } - else - { - dataGridView1.Rows[dataRow.Index].Cells[1].Style.BackColor = System.Drawing.Color.FromArgb(255, 204, 153); - dataGridView1.Rows[dataRow.Index].Cells[1].Style.ForeColor = Color.Black; - } - dataGridView1.ClearSelection(); - dataGridView1.Rows[dataRow.Index].Selected = true; - if (BackupDataUndo.Count == 0) - { - this.Text = ToolName + " - " + Path.GetFileName(FilePath); - } - } - + dataGridView1.Undo(); } private void redoToolStripMenuItem_Click(object sender, EventArgs e) { - if (BackupDataRedo.Count > 0) - { - //MessageBox.Show(BackupDataRedo.Peek().StringValue); - - DataRow dataRow = BackupDataRedo.Pop(); - - BackupDataUndo.Push(new DataRow() { Index = dataRow.Index, StringValue = ObjectToString(dataGridView1.Rows[dataRow.Index].Cells[1].Value) }); - ClearTemp = false; - dataGridView1.Rows[dataRow.Index].Cells[1].Value = dataRow.StringValue; - ClearTemp = true; - dataGridView1.Rows[dataRow.Index].Cells[1].Style.BackColor = System.Drawing.Color.FromArgb(255, 204, 153); - dataGridView1.Rows[dataRow.Index].Cells[1].Style.ForeColor = Color.Black; - - dataGridView1.ClearSelection(); - dataGridView1.Rows[dataRow.Index].Selected = true; - } + dataGridView1.Redo(); } private void commandLinesToolStripMenuItem_Click(object sender, EventArgs e) @@ -667,148 +342,16 @@ private void aboutToolStripMenuItem1_Click(object sender, EventArgs e) new FrmAbout(this).ShowDialog(); } - - - - private void FilterApply(int Cel) - { - - - if (ListrefValues == null) - { - return; - } - - FrmFilter frmFilter = new FrmFilter(this); - if (Cel == 0) - frmFilter.Text = "Filter by name"; - else - frmFilter.Text = "Filter by value"; - - if (frmFilter.ShowDialog() == DialogResult.OK) - { - Filter = true; - clearFilterToolStripMenuItem.Enabled = true; - dataGridView1.Rows.Clear(); - for (int x = 0; x < ListrefValues.Count; x++) - { - - bool CanAdd = false; - - - frmFilter.ArrayValues.ForEach(Value => - { - - if (frmFilter.UseMatching) - { - if (frmFilter.RegularExpression) - { - try - { - if (Regex.IsMatch(ListrefValues[x][Cel], Value)) - { - CanAdd = true; - } - - } - catch { } - } - else - { - if (ListrefValues[x][Cel] == Value) - { - CanAdd = true; - } - } - } - else - { - if (frmFilter.RegularExpression) - { - try - { - if (Regex.IsMatch(ListrefValues[x][Cel], Value, RegexOptions.IgnoreCase)) - { - CanAdd = true; - } - } - catch { } - } - else - { - if (ListrefValues[x][Cel].IndexOf(Value, StringComparison.OrdinalIgnoreCase) >= 0) - { - CanAdd = true; - } - } - } - }); - - if (CanAdd) - { - if (!frmFilter.ReverseMode) - dataGridView1.Rows.Add(ListrefValues[x][0], ListrefValues[x][1], x); - } - else if (frmFilter.ReverseMode) - { - dataGridView1.Rows.Add(ListrefValues[x][0], ListrefValues[x][1], x); - } - - - - } - } - } - - - - - - - - - - - - private void byNameToolStripMenuItem_Click(object sender, EventArgs e) - { - FilterApply(0); - } - private void byValueToolStripMenuItem_Click(object sender, EventArgs e) - { - FilterApply(1); - } - private void clearFilterToolStripMenuItem_Click(object sender, EventArgs e) { - if (Filter) - { - dataGridView1.Rows.Clear(); - AddToDataView(); - Filter = false; - clearFilterToolStripMenuItem.Enabled = false; - } + dataGridView1.ClearFilter(); } private void UpdateCounter() { DataCount.Text = "Text count: " + dataGridView1.Rows.Count; - DataCount_TextChanged(null, null); - } - - private void label2_Click(object sender, EventArgs e) - { - } - private string ObjectToString(object Value) - { - if (!(Value is null)) - { - return Value.ToString(); - } - return ""; - } private void FrmMain_Load(object sender, EventArgs e) { @@ -884,7 +427,6 @@ private void valueToolStripMenuItem_Click(object sender, EventArgs e) } - void SortDataGrid(int Cel, bool Ascending) { this.SortApply = true; @@ -896,8 +438,6 @@ void SortDataGrid(int Cel, bool Ascending) dataGridView1.Sort(dataGridView1.Columns[Cel], System.ComponentModel.ListSortDirection.Descending); } - - private void ascendingToolStripMenuItem_Click(object sender, EventArgs e) { SortDataGrid(0, true); @@ -940,11 +480,6 @@ private void FrmMain_DragDrop(object sender, DragEventArgs e) } } - private void DataCount_TextChanged(object sender, EventArgs e) - { - DataCount.Location = new Point(Width - DataCount.Width - 22 /*padding*/ , DataCount.Location.Y); - } - private void donateToolStripMenuItem_Click(object sender, EventArgs e) { Process.Start("https://www.paypal.me/amrshaheen60"); @@ -967,94 +502,275 @@ private void Method2_CheckedChanged(object sender, EventArgs e) } - private void dataGridView1_CellValidated(object sender, DataGridViewCellEventArgs e) + private void darkModeToolStripMenuItem_CheckedChanged(object sender, EventArgs e) { + bool IsDark = Properties.Settings.Default.DarkMode; + Properties.Settings.Default.DarkMode = darkModeToolStripMenuItem.Checked; + Properties.Settings.Default.Save(); + if (IsDark != darkModeToolStripMenuItem.Checked) + Application.Restart(); } - private void dataGridView1_CellValidating(object sender, DataGridViewCellValidatingEventArgs e) + private void Checkforupdates_CheckedChanged(object sender, EventArgs e) { + Properties.Settings.Default.CheckForUpdates = Checkforupdates.Checked; + Properties.Settings.Default.Save(); + } - if (e.ColumnIndex != 1) + private void csvFileToolStripMenuItem_Click(object sender, EventArgs e) + { + SaveFileDialog sfd = new SaveFileDialog(); + sfd.Filter = "CSV File|*.csv"; + sfd.Title = "Export All Text"; + sfd.FileName = Path.GetFileName(FilePath) + ".csv"; + + + if (sfd.ShowDialog() == DialogResult.OK) { + try + { + CSVFile.Instance.Save(this.dataGridView1, sfd.FileName); - return; + if (dataGridView1.IsFilterApplied) + { + MessageBox.Show("Successful export!\n Remember to apply the same filter you using right now before 'import'.", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + else + { + MessageBox.Show("Successful export!", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + } + catch + { + MessageBox.Show("Can't write export file!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Stop); + } } + } + + private void find_Click(object sender, EventArgs e) + { + searchBox.Show(); + + } - DataGridView dataGridView = sender as DataGridView; - if (!UseFixedSize.Checked) + private void filterToolStripMenuItem_Click(object sender, EventArgs e) + { + dataGridView1.Filter(); + } + + private void dataGridView1_FilterApplied(object sender, EventArgs e) + { + filterToolStripMenuItem.Visible = false; + clearFilterToolStripMenuItem.Visible = true; + } + + private void dataGridView1_FilterCleared(object sender, EventArgs e) + { + filterToolStripMenuItem.Visible = true; + clearFilterToolStripMenuItem.Visible = false; + } + + private void removeSelectedRowToolStripMenuItem_Click(object sender, EventArgs e) + { + if (dataGridView1.SelectedCells.Count == 0) { - dataGridView.Rows[e.RowIndex].Cells[e.ColumnIndex].ErrorText = null; + MessageBox.Show("No row(s) selected to remove.", "Remove Failed", MessageBoxButtons.OK, MessageBoxIcon.Warning); return; } - Encoding encoding = Encoding.ASCII; - if (!AssetHelper.IsASCII(ListBackupValues[int.Parse(dataGridView1.Rows[e.RowIndex].Cells[2].Value.ToString())])) - { - encoding = Encoding.Unicode; - } - Encoding encoding1 = Encoding.ASCII; - if (!AssetHelper.IsASCII(e.FormattedValue.ToString())) + + DialogResult result = MessageBox.Show("Are you sure you want to remove the selected row(s)?", "Confirmation", MessageBoxButtons.YesNo, MessageBoxIcon.Question); + + if (result == DialogResult.Yes) { - encoding1 = Encoding.Unicode; + dataGridView1.BeginEdit(false); + foreach (DataGridViewCell cell in dataGridView1.SelectedCells) + { + if (cell.RowIndex >= 0 && cell.RowIndex < dataGridView1.Rows.Count) + { + dataGridView1.Rows.Remove(cell.OwningRow); + } + } + dataGridView1.EndEdit(); } + } + private void editSelectedRowToolStripMenuItem_Click(object sender, EventArgs e) + { - if (encoding.GetBytes(ListBackupValues[int.Parse(dataGridView1.Rows[e.RowIndex].Cells[2].Value.ToString())]).Length < encoding1.GetBytes(e.FormattedValue.ToString()).Length) + if (dataGridView1.SelectedCells.Count > 1 || dataGridView1.SelectedCells.Count == 0) { - dataGridView.Rows[e.RowIndex].Cells[e.ColumnIndex].ErrorText = "The value is too long"; + + MessageBox.Show("Please select a single cell to edit.", "Edit Failed", MessageBoxButtons.OK, MessageBoxIcon.Warning); + return; + } - else + + var EntryEditor = new FrmLocresEntryEditor(dataGridView1, (LocresFile)Asset); + if (EntryEditor.ShowDialog() == DialogResult.OK) { - dataGridView.Rows[e.RowIndex].Cells[e.ColumnIndex].ErrorText = null; + try + { + EntryEditor.EditRow(dataGridView1); + MessageBox.Show("The row edited successfully.", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + catch (Exception ex) + { + MessageBox.Show("An error occurred while editing the row:\n " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + } } - } - private void darkModeToolStripMenuItem_CheckedChanged(object sender, EventArgs e) + private void addNewRowToolStripMenuItem_Click(object sender, EventArgs e) { - bool IsDark = Properties.Settings.Default.DarkMode; - Properties.Settings.Default.DarkMode = darkModeToolStripMenuItem.Checked; - Properties.Settings.Default.Save(); + var EntryEditor = new FrmLocresEntryEditor(this); - if (IsDark != darkModeToolStripMenuItem.Checked) - Application.Restart(); + if (EntryEditor.ShowDialog() == DialogResult.OK) + { + try + { + dataGridView1.BeginEdit(false); + EntryEditor.AddRow(dataGridView1); + dataGridView1.EndEdit(); + MessageBox.Show("New row added successfully.", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + catch (Exception ex) + { + MessageBox.Show("An error occurred while adding the row:\n " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + + } } - private void Checkforupdates_CheckedChanged(object sender, EventArgs e) + private void mergeLocresFileToolStripMenuItem_Click(object sender, EventArgs e) { - Properties.Settings.Default.CheckForUpdates = Checkforupdates.Checked; - Properties.Settings.Default.Save(); + OpenFileDialog ofd = new OpenFileDialog(); + ofd.Filter = "Locres File(s)|*.locres"; + ofd.Title = "Select localization file(s)"; + ofd.Multiselect = true; + + if (ofd.ShowDialog() == DialogResult.OK) + { + StatusMessage("Merging locres files...", "Merging locres files, please wait."); + var dataTable = new System.Data.DataTable(); + + if (dataGridView1.DataSource is System.Data.DataTable sourceDataTable) + { + foreach (DataColumn col in sourceDataTable.Columns) + { + dataTable.Columns.Add(col.ColumnName, col.DataType); + } + } + + + try + { + foreach (string fileName in ofd.FileNames) + { + foreach (var names in new LocresFile(fileName)) + { + foreach (var table in names) + { + string name = string.IsNullOrEmpty(names.Name) ? table.key : names.Name + "::" + table.key; + string textValue = table.Value; + dataTable.Rows.Add(name, textValue); + } + } + } + + ((System.Data.DataTable)dataGridView1.DataSource).Merge(dataTable); + + + MessageBox.Show("Locres file(s) merged successfully.", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + catch (Exception ex) + { + MessageBox.Show("An error occurred while merging locres file(s):\n" + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + CloseFromState(); + } + } + private void StatusMessage(string title, string message) + { + StatusTitle.Text = title; + StatusText.Text = message; + StatusBlock.Visible = true; } - private void csvFileToolStripMenuItem_Click(object sender, EventArgs e) + private void CloseFromState() { - SaveFileDialog sfd = new SaveFileDialog(); - sfd.Filter = "CSV File|*.csv"; - sfd.Title = "Export All Text"; - sfd.FileName = Path.GetFileName(FilePath) + ".csv"; + StatusBlock.Visible = false; + } + private void mergeUassetFileToolStripMenuItem_Click(object sender, EventArgs e) + { + OpenFileDialog ofd = new OpenFileDialog(); + ofd.Filter = "All localizations files|*.uasset;*.umap|Uasset File|*.uasset|Umap File|*.umap"; + ofd.Title = "Open localizations File"; + ofd.Multiselect = true; - if (sfd.ShowDialog() == DialogResult.OK) + if (ofd.ShowDialog() == DialogResult.OK) { - try - { - CSVFile.Instance.Save(this.dataGridView1, sfd.FileName); + StatusMessage("Merging uasset files...", "Merging uasset files, please wait."); + + var dataTable = new System.Data.DataTable(); - if (Filter) + if (dataGridView1.DataSource is System.Data.DataTable sourceDataTable) + { + foreach (DataColumn col in sourceDataTable.Columns) { - MessageBox.Show("Successful export!\n Remember to apply the same filter you using right now before 'import'.", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information); + dataTable.Columns.Add(col.ColumnName, col.DataType); } - else + } + + + try + { + foreach (string fileName in ofd.FileNames) { - MessageBox.Show("Successful export!", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information); + foreach (var Strings in new Uexp(Uexp.GetUasset(fileName), true).StringNodes) + { + dataTable.Rows.Add(Strings.GetName(), Strings.Value); + } } + + ((System.Data.DataTable)dataGridView1.DataSource).Merge(dataTable); + + + MessageBox.Show("Uasset file(s) merged successfully.", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information); } - catch + catch (Exception ex) { - MessageBox.Show("Can't write export file!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Stop); + MessageBox.Show("An error occurred while merging uasset file(s):\n" + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } + CloseFromState(); + } } + + private void dataGridView1_CellValidating(object sender, DataGridViewCellValidatingEventArgs e) + { + + } + + private void dataGridView1_CellValueChanged(object sender, DataGridViewCellEventArgs e) + { + + } + + private void dataGridView1_CellValidated(object sender, DataGridViewCellEventArgs e) + { + + } + + private void dataGridView1_CellValuePushed(object sender, DataGridViewCellValueEventArgs e) + { + + } + + private void dataGridView1_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e) + { + } } } diff --git a/UE4localizationsTool/Forms/FrmMain.resx b/UE4localizationsTool/Forms/FrmMain.resx index 39eee4d..c77ba08 100644 --- a/UE4localizationsTool/Forms/FrmMain.resx +++ b/UE4localizationsTool/Forms/FrmMain.resx @@ -129,10 +129,5900 @@ True - - 132, 17 - + + + R0lGODlh8gHyAdUAAAAAAP///wQCBAwKDBQSFBwaHCQiJCwqLDQyNDw6PERCRFRSVExKTGRiZFxaXHx6 + fHRydGxqbKSipJyanJSSlIyKjISChOTi5Nza3NTS1MzKzMTCxLy6vLSytKyqrAQGBAwODBQWFBweHCQm + JCwuLDQ2NDw+PERGRExOTGRmZFxeXFRWVHx+fHR2dGxubKSmpJyenJSWlIyOjISGhOTm5Nze3NTW1MzO + zMTGxLy+vLS2tKyurP///wAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJBQA8ACwAAAAA8gHy + AQAG/0CecEgsGo/IpHLJbDqf0Kh0Sq1ar9isdsvter/gsHhMLpvP6LR6zW673/C4fE6v2+/4vH7P7/v/ + gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp+goaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7 + vL2+v8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4+Tl5ufo6err7O3u7/Dx8vP09fb3 + +Pn6+/z9/v8AAwocSLCgwYMIEyrkhgGHjh0SKFCoUEGiBA8ccGBYyFFRBg8zIDhQgODACAMHSJxw4GKG + hwwdYw7SsIMChBUmSBQA8UGAgP8PAwqQMOEAgowdGmQq5cOhggoFJUgY2DngQ0+gIAqIOFBCgYoKHJaK + rYNBx4wFIgaAAKEWBAG1bdnC/WAAxYwOY/O+wREDAooRA3wCHaCWgFu3hK0KHsEAwoQNeiOj2WBhQQkD + hquyXct5M+HEhAmIKLFgRg7JqMVkoLBgBIGfhdcSXvu2s22rBAwsiGEjtW8uGmA0OMATq+HacDnXPi7b + KggSDSTA/E29io0JKRKEwBo3ruy3bZN7/lAgQQQJG6urh5IDQgIRPGMzP778MP3Ds0WYaHF6vX8mEqAQ + wmeH0UZbW4YhdlxhAyRIWAEoSPDfhEjgYAECPsWVIGL2NWj/4IHKqeUTAhbgQOGJQmQgQQoHWIUgiAsq + d2CCMfIkwAEpvIQihTpUZoCLIRa43Fu1dVZkgkCN4IBpO04IgwolpLUZjQrGJiORBoInlwgJpCBhk/5R + gMIBIWxW5Yc01lijZwOEcMACFIC5HgYWlBBCZjIKCaKCHJ45ZQEmzCCneja4YMBsMdbnYYdZ9slWfQg8 + MGh1GEQgwk8F5rkcg2rK590AB7SQ3qSpZZBCCJguuKmemr7YHVt0udAbqanZ0ACqHxxoZX2MUqnocT0V + EMGstEqGwa0/Fdlrlrsy6CdbAoSQArHF6mUrrowyi1yiHG54YE/STlftMhhgYEO5hVyb/2yDL/JK46Lu + zghuA+KOa8wNOXSwww4e7NsBB0kFYkME2Br54oxGorkntNJS+0e5NmRwQwbn2pvHDR3AUMEDLqSQQgMg + exxBCxbEsANkfZiKK3MeUglvt40eWZUABaRQ7x4ZaJADB/ru63MH/26ggcMWt6GBBC04kAAJCJBAwgFQ + p8Q0aS5QgPIeA2PL7apUninzo+BO68cGHbwwgUQSyUCB2mjH8ALARbtRFgUuMEDmnQTkTQDeeh/g1VE3 + 22FqAQIg+Kqjqyp8JMM282EDDh7AQIEFM1BuweWYzzBDBTHA0IGJcauxQQUNMJDAASKIEMLqBaweQuuu + b1UCAw6wgP9XHgO/luviW8PLLn4LB9sA0XRgkANEa1eg+fLMM692DBJ0cHXoZODAGgmpZ29A9iJsn/r2 + 3nc/wgkscDBqHSqv++53e3aN5YZEBhZuHsZPIIPym+evPEX7658/BS8AHfXEwIEZQAl2BdBK9xb4Pe6J + AIFvYoEHiAeHrGGqfd1q1sIapKywURAOGciBBGRAOfztr38U2ZwJlwdADnxwgFfIwQMUQIIRPDCB2Uug + VqbyvQLwUCs+JIECXHA79KWAcB/oXaaYY59GGe4tNBveHTCQsYn4L4VYVKEKT8i/GBQRhluw3glEQAAd + as+HPeyeAht4Q9GcwALTk0PuUiUbmC3/8XfL6mC0GmeHHGishFpEYSD1l0UWWAAGAQNjFjZAgQPuTYHh + Y6AaF+g9HqouBAhYAViMuLJF2WZGL1ucszKzxxeuwXgemNwWA5lF5d3vipujXAw8kEhFWkECKkjAVF63 + QzVWcpI8BB8kE2gAEuzmfBUk2AX5lDfEYfB9nGmQ8EypBhxEZIVYRKErT7hKE1ZgAju4gS2tYIMZKACH + ONReDi1ZyTVa8oGYhEBY5jC4ZPWpPtzK1tdks8fAya0DFPDfKwWpTYF2cwYwmOc4p5ADFyDgdeoEHyV7 + CcyKqtFNK6CAOOUYAd3d00owy4z7hCTNUtJBAy8gYTddqcWBtpSb/yj0IjIX2gQNTMABI1gdAyXKTja2 + s50PFM0QXzBTNqQviR7SoLc+6i1lBaYAUpQDxiYgyFfeD6YzGCg3tao5AG6Upk7AwA5YcALXuBONDfxp + Gs+YutZt5QQP6E8yC/Yul6lqlC17Ytj8eUodwOCVhMyq5rApUJhu0wIygEEOqAlWIdyAAg5AwFQU6M5J + WhaYO+zl9oAoAhTAQA71TOLCEqehD/GpOyaNAw40tsUUXpWLWd3qIPunObV5II6NRcIGyCqVEPRQmFPh + 6U7TCNS2hiABFpCrG+a4uyllsIlcey6RphkHDHCAAixYaWBh2UrBWnV/MpCAcnOr2xaY4ADeW/8jGy0b + 3Ae+M3wSLQABoDOBWhr1VOqb0ihDtD58onZ+cIBcBQDJVRlckaCC5d9sOadQ8iKBAxHQyQN9yV6K/pK4 + lGxr60aggAhMYK7LhN+u7mnappa0YXDQQOReu8KrHtSl3cUqYj1QVAcLQQcNMIBv1RtMC0+4x8LE7A1F + wOEW2FcNoc2nrw62qfg5NYqMHQMHJOdNbyY4fzDun0sNnMLBTtDGSNiBA1jnY+75ULNoha+F01mAEajg + i2tgboH2yzs82mZxe32DDTxQ5cK+dJDfDWz/KPdlMBuhAyso01mBm2Yea3an6pUvoGSAWzQcFUtBAmWd + mXgkD75hAxMYLJb/Dctd7rK0Ai6uQHZfEGWaIlq+vhWuA38J3LVGVI17K0EKHtMGC+YKlMtqVbY49NSo + sgFyARU0grdZ6m0yW3mUk46hjYBjHf8Yze0F8jCB2VOt+PYAJoiAB9qQZMSMuK4wQlin+9mGqRp4tn7m + qoLlrULAZlcCrV4oB1IgYZ+q97LqHC6ac9i9AzBABvnmgpwX99Egra99hEntGjbwV4KS2uK1vbiWByyD + DiTcljI0wUmGWeu0di/bmQ1yhm9YgBLI876dFLGeMB2/YReGun2NQam5bNCq9tzP39TBtI1wgwosAAE3 + DCb3gpvZtbITkr/1NgFGkFEBosHXmXb4wdCU/1fksHsNOHiBKre68dauFLauZWlWKSCBShvaBjCIgMjN + OFH3prXRdS9uDkNgAF1PgK+qOaI9Nw2zlo1WQ55WA02oWkJS8xzBj2+2CcF55KGb5S+8JC7U2YpySC8Q + rRMeQQJa4HYxLJy/Dpeup0BU7I9ngQP22242swn0eZe6conNQY3f7gEHHKBNAW/0O5e+Zl+iuXUGWMFn + 03Dp36EbeCN9rlvynAaUFri7hS3osv2Hew98dehF2EAEAPO6zlcUfEz3/IUt27oCKKB8acA69F+mMJLe + kXGut4LxJKDNZ8fW/wp2agC4P5fTcbs3bTZgAQmwN2xlUQAXSZ5HYeDzOv8I4AAVUHpfUG52pHrSZSAI + gnNngAM7oHNVtX3cdGCxVW8nWDINBn5FIAENUAIjR1Hnh0bCZQBKV3dpREwloHxX11F0lG6s4ivQxXpf + ZwYoRVWSF4Al+H8pmEUwRgFI4YJIkAONFCWx1nTF1WNtpX53t1nZUwIW8H1j0HyEpyrDJn0EkHhmcF2N + B2+C9oTwtnEnaDJWR4VFkAMVwAA6RlnEl3cmN1wRmF6i0QDjZgby13Df4R3QVHPEBmVn8BEzYEgHxmw8 + d31xGGObAwMbcIBU2AE4lU481XSah3I/RYObJRoMYAFCVwblFl1KBGzAM31HOAY2MGWVM4dYtYurBGP/ + f0YBhYaHSGADD6BLP9RTK7eF2+ZTluVbJbAkGLgFp5cwMycfMXMm8iM2ZZADHhADVqZxsORS8fZsidWC + wmgEMJACc+dbzMiFajZRo6h0k0VkCdAAO+CK+IVU8eI7HYInyqIcIKgaI2hF2hd5aGd2BqlFgwUDOwB4 + 58gDGxADDUACeWODZ8aM8EhwXDiIWnECH0YGiSgzMrdUveN1ADYG1tRKy+Zso6Z9XERbM1Z5D0kElGEC + onhWNXhGEiWBWhhUIIAALdCKgYdEiVJa7uKIasiGYUBF2HVQLBl5CcllkNdlEzBeM3kEErACqDNkQRZf + EbVtwwdfGuYmpWGOXTCN/zGjQUVYYjYCVfn3BDYgQip1kM9mWFoWWL5IETLgfVe5BBzgAgqAXhBFYedn + d4Ioa0pnRs9IAQ6JBWYYHmvSNaj3NdnYmFgQdt7Ii5C3YLTni8tTjp54lRmQju/BZk5HikCljJAWa333 + cmEQkp6UR+yyT+uGYkupA0oIhWTnf1albISEQhPQAWTYl0eQAROAFiBQfsOlVl2JYe3FXvBEdTEQmlXw + iu2CVxmUT4/olmIgYIB0l6f2m9pXW3FoYBZQAS8wnMR5BDoQAQdQRuuEYZxHipcVSZnlWwoAATvwlkuA + lnUUfZmiMB9Yi2fZAUp4doH0WigogOGIPxTQAdRJnP82UAFl9T3u+GheKJZMZ5+vY0wXCAaP6RZFKVJX + gk99ko38uQQbEBGiRlv0tn1ZNmr6k3vr6QQvAAGB6VYX1pwqx5N/mH7dQwIOsHxeAJtXwmSPcjB4ZBgB + yQU3kFJMKKOyNYB4CYAyMAE6YJk1ygM3QJpuZVGJaVE92ZVnlUAmUCIZKHii5V8lZnjZqVcEugU5EGpY + loktmWDhmXaspDklQ0tb6gQaYE7tt5xlRmtsdJE7CkSYtGvqeQXTiJ1FuYFzxk+22QU0MTnfuaAq+Zsp + GKPmyQIxYJV/mgQesAI2NI+VRZj1CZaal0NTdwIQQFRdYIYYhDD2x2kt06RZgDH/f5WpLKmJJyhvu3ie + EtCoo2oEFsIA2INDZCpkxidJT3d3EIUAb3SHWGCk2tmPXIcnlMpHXOBHVrSgtXdqXFWlWAYDQnms/fkC + LcCHg/mc7gid8Ppjk8RZWoEj6ZoF1smWkcqBCqKUWbBn70aXPdd/lVinXZZYHaCl6soDKtIAOfVv0aqh + P0qYOwlPEPJ3CgeEu8OI/Lhk/got3AkcMHA5e1p2UYpx+OOZM/CgxtqwRqABdcKsFXZ3zrlGeEeYe5MA + ECBtWkCrdraPD7et1PezHaBzvtpS8NabTQiAM1CVMAsFASIVxOR0S9dWPJqDKrdZQoECLXCPWoCtQ6hU + IrpB/xLnmFU0WD6nYHiKVcKqbF4VtU/AAS0wJqyDjPF4tWBafMF0ACggAxHKBOqypk+EpJzCdTIyLwzb + BBvwAjHweKR2srX3hILUshJglnI7jB5gXpKmk583Yc+KtynXS37octH4BMeiNZmGhnklhA5CiyeJBTrg + jfkDS9plicDKqZUTAzrwsplbBHDnAH2Itb91ctBpkTnIed1zJ8kHA4urBINbc617JcyidV5XM4G7BCg1 + YK2FajtHuS0KnldGQnspk7/7YBAgWViLmpWVvM5psVohGibQsynKA6l7QZJ5H/1FG5JpbjQzLLtqoMuD + YDIalQH4f3W5Obybvb/7WCtwGf+mSWsXWZg3yLc+dABwJapREFqTKn12NJJJWhWxwsAPVnEraWp5KqNx + qMABdL5RwAEWMCbJCZ3QCr+GSa+tmjoHsAIfSU4RQDiI4rofXL0xEh6hQsIxO0Kz12ziSnuAlkKIdblI + nLkY8AIuQAJusXkSrLc36KPwhZ8soMGoCwGAoSHnRn/O50nI0RYk8ABTPARlEWqOp6dM+2dSyYsFKJwu + LAVFZ5PpJKaUxGg5LJYM1DoIoAIUYK1RYAEmUCbs8z5mrIjP4hbHZQFYQBMxkLR5qV0JOZ7vBrV7LAW4 + hHTXlpNcjJpR12Orw2Hn8cY8IAMLQCZBzFR0tnoh0iZ+Gyf/VpABGQO5C4anuuiEvsw/wOi7oXwEOSAD + DnAZEJWD2GZyhipJkLZDZ2rMSrAiJpAWs6wmigMjmfEZXBIBLxBDFXey4ym+UsmpPJdVs3S6x3wEMMwA + I6BDj/ZDOpmq2jaKOTQCEZCvL3wWPyIAWTcfZPtRVkF1m2QdAJW0UyqlkuuSCynG7wy9HjCREDVw92xy + iKq324Z8PGzNw7gD4+cTM2cwt1p40HIjLrCfVrC9v+yS6Fyn6ZxFM1a/LqwBLKAAYOhj75WRhRnIZ+Rb + DPAAEFoFRZcAQLIsIMWPQSLCCVABz2sEt/hHT+yECctKTFi5WjYBmNskOYMDG8ABOqAD/xyQAxuAAzfg + ymqAzaiaYehna+/YeWfGQ6+TAF+hyE9QqvBBII/yKM9HhOamFiLgAONsBZBDuy+5tJtqZUqbajIwS+a7 + BxBTMeOQAbNrYBwDMiPzABYAQO4sB3qoAiTAOsS7kz1liu8rSQlEAgzQAl3dBDmQ0wYQH3qyX36CJYEB + AgbwfngdVlMWULRlggjrXbBVYJvj2TZtBhhwA2GtA/riAS+wAx2QA2Yd1c0AOTMQAQ6AAidQAiaBACbA + ACjQAC3gsn7QIwnArCQnptF6mJ63QyWgAmBLBVUMAdmMFSRmf6YVTR+gH7F6BRnguJuKiUts3DG2P1yd + 3GVgA2TzAv8wcDbmKREwcBEckNbZgGwPkAIroAAmkAAlsT0pgQAlYAIowBIsIIWRLQdZOY9w7bmCCI+b + Z1mM8SVWsAPuAUWDwUzcihxyERhJVAIuEIxUYFP4s6dSmqe7GNwClZ4pkwPOLQEQLgP3Y7IVIeH9kgMp + vgwaEAMusAAK4OEl0DRO8zRSwzQingAKsAAtAAO9LQc64AIyyHKHurU3S6jCpEO7TaRWAAO+NyDGAVI8 + Hk1vARRT5wCMeclIO5VJTlhkV7uuRAFYqtZlsAEDKeVSzj8viWqoBuknQw0RCZgIcBIGMAJRU+ZRMwKo + joMkgAIQwLvWHYky8MCY0b45SaaJulb/sGMCPdzSMvAUrlEVs2ElyfEZzhECHIbIn70E1mNIB559d7qb + 4ThLbV5dh20BlIhNtMWnJdTO0tAjI+HdpD4CTzPuY54SpU7qJIDmKxABLgHSomN0mBFrpax39LmRkbQ9 + d4IAuowFYuUUJBAYPzEYzkLsAD8AFTgDOyDpQmA9JptqKCtqgLVlGFc5FSBeeqABHAARmWk5vrnOJtQ5 + C/sMGyADdoPuY37y5u40UgM15T41rI5IeNABEZZ5zUmvOOjWVtt5eVMCMcAFEYlThnEnc6YhzCGkMZDs + TcDwGQfM6bzJrqWpteVxeSCCkmOnTlu5JaN7zWCF2SE+KR81427u/2Cv8jWE6iOAAChQNS+wWHVQdCdw + 77T+gHW+tYaRAD3v8xPgAivQ3aizhj4hGGU0AiVwAivgArwGHIk+gCb48FCoQpw4RTqzA7EHSI4+SM1m + 7TLwAkjPCxnQ6yQx9kxT5qF/8mSv8mBfAgnAAClgAaxWBy8QAQlgQ2Zk6wOntWjlhzik60XauBbQAN09 + 2z2BKQZArQ1gAW2n4ENgUwO8+JL7oi362A1pBxqgA2aTPJh+/QebsioEQNMODO3p3aSf8k9TElJTEuR+ + /uU+6gmwABCQUK8OBlseg4Nas8T3SxOcjArkt4X9BX4EBBaICqVIJEwMFWQ2yfGgUemUWp3eJP+ySmXG + 5Wq7Ye9MJjaPwdxZzKOxvuFxeRSD203KFst5xlePAbu21jow5g4RExUXGRunNGBWSAwODkguLTNJKjcr + NT83N0cMRkgSlFoodAwdW6lwLBQKCAoMRERsDWpxcQtue3Nvc2t9C4xFRhAcPFzjMnA4OjxgqCU8OnI2 + MprhbDxiZNLIxL7Kvc7PydL3YDa433kwNjok8P4EBbXSt/YB/WFwwBM4kGCrDB5YMCAxghMCS5hCPYw4 + UZPDUCQQXEqwwoKHbQUXSVghIgSvYr+A8dLFqxdLYAVCFDigAIIOkDcVYegAg0IffoMCBfVzhkWFFx9x + IsrAAUaMn4LukcP/JzQQmCY7AibVuvVdjhkOEhxgeNGhxUsXz5616PBhW4YFRmx8oEoDK65VNjxQcGCl + r2ArX6r0K8wlyQIlVMhwc5dxlA3fovLDpw+qusljumiZwKHxGxvzeM7Y4xOd5TIVyug77a8cuQkdkHaW + PRuKhxQm2Kpti+mAxUxsOXHCqKmTJxMnFkSosCN2ZwwSXCgYUVKEX1+EWdrC3vJlzBMPdtC+m0EHDNH7 + wog7LVUcmgk6boiHsvTFhBgU1gO9F5RqGDNWuQBIvgHvogCF4CAia7fh0EorN4gk8uSAEjh6IT7acICh + ARJiumUw7VYCkRiX+qqOAAMWiGExAnHC4YUK//agDIz8gJpKKjXWaGNADXSYAMY9atTPMqFWS08yoVig + gDMWmSzIhlhGKOUiSx586MFO1kKwt90sYYghE1aAwKgNbJgNBxYSiGkXXUK0jruWAKvuFgJGaCC8Jm+y + oQN9WkOvv/YEcUI8DG7YYAcYZLCAhaGKTIcy/vpITypFZbAJz0u5waEFE0ixMpMIh/uES4kmYvAsBBM4 + QYWOypQNhgVG8BAlEH8BUcTA/EqAhQsxJWgDe/xh1FEbv7CQths4qI+CICurapD8LjOyz3ssoKCQXrFl + RAcISiClkwQ3AQ6tLSH89lSKMqrES1McYOEFbTrL4QGFZlnTTe3gHOwXY/9CGEGBFJjJdqAMdirDRj6J + vRFHCmB4QjZCdZBg2Uh/QsPPIf8UtgsWZNihVYFBhgODHSJIwFuIsiQ1FLOoJI4ts6Y8VSxLTknhAUEb + 64AFWUAoSd+/fsbFgL5AIACBFI4KWaAbdqBAD6kkFVI9LvTY7GPGePRgAvxIGwqNqIN9tjQhF2ZO6bOp + sOGFFLothdxPZQ4XQXN9g5BlcE9NxgQVKujg6q06cAEBD4/BV1/ujil8hBTtQrsZHCTwyb+LhfJPBr87 + yyCH+mCUXNpxanz0Rq8TlswCGTzg1fGzM5AgBZOTmRvllhf0FNRSyV15y1GSUcCBVLC6S+0ITjiAADX/ + VfJQO3v59SUBBypweHVuHvOx6z8DsaCCCXZYkasM5pH4R9IcPZI/Z6FiNuwuTk99erQzWLvttH6DWzjd + iis391C/HfWhEkyAggioQngegIAJZoG8NsGJcD5DgAomkJX3cUMDkLEcai7DLBYkyWx3kcc38JOG8/FB + dKwxw/Uqsx6rdKw5E8SWDUgGO3PBLS28MVcNsxSR+4WrXKeyxUxScDnV4URtEDhBCRaiCzUZg4kwcSIp + SnCCBlDAey50hR2aEo7JnVAMMqAABbg3xKRo7hszYMFo+mExI5HPNGc4UmXUgZ4ZUKCDVhRY4GSYw0v4 + hlxmyaGW8Cc33ekvSqVQ/0ByWCABd2gFAzqIQQtWwKkQEIAARaPk8ShZNBEg4ATK6Z4d4QG+DuBBUYoS + jWj0UMpFxeAFHCDTXTTAgWk4JVJD8YOfxmYj0K0xbNWqIyh7tQEIwE5LW2qZDilCHPr1D1x1UyZxUuUC + CkhvjDuwQANwMzR8qSRKCVgABNoBzIHcYCc9+YkIvzABD+TgbziRxw7AEaT+zPM/ozMH9kCXJEuJs1c3 + sIAJGKKymC0oZvTLzd0EGaHcNERdoyDBCVJQAQ9soHEgsQEHJmABF6RABStAAQNOcAIULMABDYhAC2Tw + girysxk3wIEOduCBF7xAAtSAwUxfsIMdcAAHFcUJef8sCKTRiRBjuxQb2KIWLfTBSEksxZYMiteWupXK + NwcFRVue+a0/Tik4M0NAEhrwABistCAYeEYOdpAFM+6BDdjIQDudCg+z4iAHHNBBNjQAV3figB5bM1jY + gkVUsoHOHEn9WmD9swZqxpVJL1ABEieix/oN1FSDFOTdANkgmTEkiimIAQfESMRYdgAbZGXsTTBgA59u + 5YNcS6MbLwYtQKnnYKXDhyAo8AIJnpZFHHjAAkrgCfp5Cm9vi0iVFtpDHEqVfzObkBTn0oHQ8pa6WxHl + C+JJunkW9o2Nsu1gAUUGGMCmuiyChBFnJkj+6ca4okrQ/VxWTLQgdI8ZAVMLJGD/2vLuVyAaKOdU1Kef + 8tXWhPJMYT2D1QUKTJS/BMIBBSRBCQjBN7kS0WNlLyvcPSpUQmoZTpSGhgAGuKBjdWnwiblxgxxorQ/a + uyWRjArgyUhuu2pU3x4ksFsUz6YDKUCAlGqoO5XRbobIZFntKtLVJPMmSiQoAQNW4AKj6HjHVY5DLF/Q + lIltUTLsWZ9375nBIUkOUK0pw4JXa2WuaIAFC0gAlirBx3NtmFRStV2QN3wurAKZSsMVjjfBqV81q5mv + TtEeLnlJLNYgNmMDVl8+ZNCwQdNGBxZwQNsyqyDhxLerBrWf/mpYP2WKIkoTQkEKZuABKk96x1nz0Rk9 + 9+hn/xmWy+OY7bQQvD7RFEUCHNArq7XCgRkUL6DEoV2dGbRDu2nYmSlTkKb5mIkSKIABKZgmsKt8UWWF + A0cBVnSzClvCXELqUetTVAx08GtsJ2UHLUABbkRx7PfaENnylpl7AbnpItuwkAcwQQMqwIE0rzuuF83C + fu4hOhoZtTUnfKONEybmL2QmBr8kuAd1UAFsikXCt9uqDeW8TAsL9Jia1TNvPPFVFLTAA+q+OCg1cIeJ + 0dONpPsurSn3tcT2IbccaOHL1xyDBpzgzcJVMlUZWju5yZvIybVqWQgqMwMkAALXArpTYei0663vy30q + qmRWg+ijokPAqMntIq8umw3A4P8BDWBACWJlALyxF29+zOoy5x6h+C4zXdNZHAv2mXZQGtyMt3T4wdAz + 28/tcuGP3rkMJvACHfRU8LPBQA5gAAEGjKAWxk4uZUGR50G+7BNTpXOexRXvjcwA7ZWfIAaYYk4Za3fi + BZ6xs+4568DiyJTjNbHraRM/Fry7BCVIl3AzkmH1Ml3Oxl4vnPVOQxs6uQESGDjwQaaBgwNW0RYb1phD + RzkaJxVA4fgiDDggaOxvxQY5kIBGUZCAuI+l05ueLLLxzNXI6pu+vbn3CVgAc9YPfnqkWQyv8WSMqMLu + AKMFzE4JjDxAB/JqAB1MAiAABYJrLOZM+p4pZUjPuMYFyZb/LQQPIAESY0koEGQu7wVkT2psTPcwg2y8 + zcC4rsvIgHtWLQVnAwssIAWKIAHERWVgBs7ozX4mC3dEL89shy1GIIpcQAJ0MPvuQIV46ctgy7Yaxcwk + bufmKAa4J/2ikEkIBaNcgAF+rFOOKTicTaDwbEFSpvTup0qKAwFQQAbCMFs4gJbIDvcUZuLIT+wSTYUw + Q3tkoOIo6g4vRQMmwAVWQAGML39MZdQYxJkwwe46TcjsT+lEIQEe4OcQcUB2IFHGz9EM0ISIij1w7uHI + wYtgIHg+MRGbpgVU4AR+rNiK66rgcIbY8PmSkBJHAQFcYLFeUT4wwANQycwQrQoTbVj6/wFquCgzIs+t + hrFXLi8GyrDvHCTOiCsbdygNl66gnI/pNslOppFFbuBFFkUVoQXsGhAVn6I9am/szoF7XqkcsUX7WIAI + HLE4RNCYGuRtRu7OvrGPNEwsSsEBYGC67PEuIKdzmlH3aAxSBMzwvA4zfCIGbkoCF1Jg6uD9VEABJqFT + MCISKULIQg2+QGUbh0wUEGAFKCAHN1IramADJMAhYXDMZmQZ04GEDMsL0qCUWAkMYzJkOEAGIuDtjC4O + SSXk1AvktvFKSnIT5G4FZKD1hpIrVpDM3pH7Hm7AEAadzMdzeO5dru8qm4QmK8AFHOCIDFJCkrID1fDO + 3HJccsg3DP8AARYgesySMeShJoGk2yjSCoUEqRJuciBPneBjL+EnFFPgBEIS7+6m/7Bq7pJJ/ziOBFYg + 4BQTKzfgBSLyIWFMbCRSngJBNAqxlRRyM7GFAyjABRbABIyvw5ZS3/5xCO2smVJyKq9NNZOiBjanc9bx + Pw5rMCFyEEaHYraAYdbJ5XgTU/wrBh4gkmpRA/2xEicLZrQx2UwyEh3KAV6yOZOiIbtmqKSFD59i3BJL + ezBSB+AFPKdHJ2agARxRQmAGoa5KOykMJadE7hwgadwTJDQAHdeo8YyzKm4pJwuUHHqOOf8TD6GzAd4t + 3krOG+kuyAjK/+jsF1OgAxoUJOLHJt3/UTAhLswwgxVfoAPqsUPfp/1ggAUc4AwDanY2LfUmURMTKhMM + oARcACZVtBWMcVFuLgvViAqnxjAlbwJ71Ip0QgaGDgj5sRv/8RJzJzvH5aEqoCyTdBF0oAWHqgZfCx3y + 44vYgJ2ydPDWbgZcMyxwQUqO8AhPpW6g8lO+qgEmoEwFgibB8vZqD+cSLQxiZLxyIDXtdHUCtM0GJ0Yn + bL3k1NhGLlSacAXAY1DfgZyApQ8EqxTLx+uswjRhIDEllZ8OAk0XwBGB48hG0PlQ7lOihCbG6lMpqAMo + IB1HaDgJbHIq4Pw8wOdc1aluwJFa4DUPABmEg2WwUwkxSyoN4AS+/3NXmyEPYU0LuZLxoAY1xgsHGJRZ + pyd+opMWseo+5XKghKsEGiBgsLUVIOGU0BPMxiZ0MFK6yvW0CAY6VQApSy2+ks9KmgsTviQxePRd58D9 + ekIr4wjAkLGWwkGdUFRQ/VVJ187d0uVk8mdUuNEWSKABVGRhXQEt/7K2ZoQf/moMGEYjMba6AtTSGAA2 + gQMUoO5JOcGbKsAqRzYnMI/bXqw4I8WLIg+0Yra8PsM8jjKJSs1tutUgbSEZIKqpdtYRPsOCamnsEuuM + FkWddDZp+WvtNG8k7Q+ZUOYEXAAGPJFqEcEO7OG2Eu4peE7VwPbEKqgCIKABVuAEcKPvvKX4TP/gkFRA + yvwzbR0BWdJKy2jWUr/ACyXgBXJVYfUW6zozLdcSCIOVEhJAAZCjASzgPQz3cOXgGWQJBuyjBQtxAiRg + B3Lg9yx3xzBKoxzAoxQAclUgBU6Kjip3dOfgGWBKpprCcwl3p6wVdtWsUHRAprIMBj6XtAJVdwcitWwg + AzQABzTgBt7qWon3eaE3eqV3eqm3eq33erE3e7V3e7m3e733e8E3fMV3fMm3fM33fNE3fdV3fdm3fd33 + feE3fuV3fum3fu33fvE3f/V3f/m3f+/QEAA4HgQ4gAl4gA24gBH4gBU4gbHUf70XA3gky3oilSi4gi34 + gjE4gzV4g/XgVmH/oHAd2BmSt650oANK+IRNOIVReIVVuIVZ+IVdOIZh2IRdaXldjzxgQAjclgFSVwHq + 1odT94eFOIiJGIiNeIiPuIiReImVmNpWIAVaoAIkQBhDmAdsgEfSyj62QAu4GDW8uIvB+IvFOIzJeIzN + uIy9iJWuAQe+dtKWAgYqoAV22Enzr47t+I7xOI+dLAme+AHGpI3x94phqh4mRlGg9pANOZE3SJEReZEd + uZEhmZEleYM2iOJakT2dt2phoAUcYAFAyocToPgQoPhIuZRN+ZRROZVVeZVPGQFcGYAglwEYAAUawF3U + j34heCdi4D42lWJi7Ze3KJgjA5iHWZht9Yso/8ALdyBFJy0PjSgjQhkJTMAEkKCaqfkIqDmbsbmauVmb + t/kIwDmcr3mcwdmbyVmawzmUkagEFuABcsx/VywGUmnRQFNhZEwG77me8dk4/bRa3iWTGauCZiACXvOV + o3mbp9kIprmaFbpusXmhG7qhH3eaKbqikUChJRqjH3qitZmaSyCUXVkBosxaXnd9VUxrqCYi7bns8rml + 91mf0+g8gSQGek10USwDMu9tj+CjPxqhudmnf7qjvxmoz9mcxfmbhdqay/mgH1cJ3CV/+YonuPKlvezr + YLqoFBDX+gMaGWzHMOAFLlCdrXmh0/mnh7qszfqaz9qsjxqt3dqnK9r4AP+onVGQfjMAnhxypQmrjQTr + qrNaqbQaWg1sLG8Z6zrAAiKJp5daqdXam+E6rZe6sYNaqR87qR2bsXc6lBVgiqjYfS8KjhFuFPlgtIu5 + tIn5tI05Bh1ueyyuunQgPt+upye7o8mZors5stF5sikbs3nbqGkbockaARIABVwgBmC2fS9PYlDIBRkO + /Aq2Y02jYI+qr6ObYMGPU9ONv25gAppUtoU6m78bt397vMN7oYUagMqbstO7mumWuCUAoMO3M7eMnsCr + VpsRuqkan6k7dJwRNaaYvzhgZ3oagHbavG87vCebwIcaNj3asiP7uwncqAlcwR3cmyygsMm3keTZfHb/ + z76dW7tA/CbLLNesG0YuB76z1XXWmawNfKwx25wj3LzLe8Z/G7gr26LTO7hMoOrit4JkAEiNMzXE71KJ + JB4HtmMFmyq80vHUAMcw3IoyTgWA8MBf/LHRW5qTmr0RPMvHeaEp3KcVHKgj2/hMIAUm4MnBN7lFkVaL + /NsecvYGS/zifFo//A/QD8XhZwIgwM2Kj8oZW5tjPJ0lW8YtO71Z3MARncX/nMGxmcxXZQcaOHz9Cw/I + Jyz/+gX3Wp9rLuxySchJCJ/Us6tPyyvmVbYLPLcFHZ1ru8u5+crHW717e7bF2ag3GjbLeQFSICHd1/1o + dj+QCh7tKfF+3fCWe9MD/9vIvSBkI/19OOBX4ZanLXqsrzzWGXzVt3zBIzyUCx2hXV3LDXzaAegEoKdf + xbeRxtZARzz8JKVI75vsCHZP1dWlwc0n2QDPlWYHhs6hj5qsXf2ckeDL/73BXxzGOzrbxRu9bbvGWV3b + pZkBHqCzyxeGxK3mmGXhSkg4M91AyzaOBDsBYyyx/LukV+cFVmDKr5zCZ1zVaz3brx28Vb7FGb3aB73K + aVubRzkCAi99P1SovM/YDZBAMZXEpbvW+FseG7DJL/a0JGABXLnmHdvlBb7aH3q9azvWu1nRWV2tGf6n + UZ69S2BD27d1noZ0ZCS2KB7jSbHcVhrTa/AM9CDpGf8LBlAAIxD+wQeevInaxaueyp/et8c62isavL+9 + BCKAQ9kXC9KRHOJc2CeSCity0yE/QWnw6zJdHc6N3F1IAhjAEqie2tV7vb1d1af91V+erR180G0d59uX + B3l+FJG9Ijtcv7+NRoKcza+byMegWjB/giQABVxZzJ/exeEawRm+7vnemr8c4MUb1oWfmyGgrnU+ctCI + wNq8K+Wdu6I18RhfT2NMDVggBnb/fV4AuKC9twE+4St76mH+sf/c27+76hsb6tE5wlsA4sk3fs4DtoY0 + wRwQCCqzilAoKw6Tx5lsWDQmiUSncmpFXqlCS0zD+4LD4jG5bD6j0+Fd6mQyJeL/8Dn9nZjL73r8Pp63 + A/bBJZTgvQ3yGd4V3ik66jG05KhRVlpeYmZqbnJ2ltl4LGFFaT2RWpE2NRmZTolisWrNnNIiHZmuRslI + eHn6/o5xtCwoECbm+ekJ/jUq2zEjGx4mNyPuMQZaw2H7mZysVOAAj5OXm5+TY+jEyOSOvjMxwbtKyc5H + CcXTy1OJ9s+/kxHDQwZ0BittsOCAgYkScrQ1staH2aBqixBhnLjnGR1ljJZdfCjyDoMUE3odTKlyJUtN + OSRQ8FdvyatS/GgCrHLqCiybNd35tFmBAowONloi5XFjgosFDbvh+ehMmjOLirqFfCRR0CGtG6OVKKHA + wQMP/xiSok2rFt2NDhPyoWoVK0vcoK7+2Zq16t67J6NuUZlVIcaODWtX6pjhoAQCqSLtFKoIseG2qBgn + V518tSJWjRPDKkgRQ9zh0qZPq8HwUoYFwaNq6U2Cb/ZeJ3T11YOCU2de3UhSVWgtQcdR1OdsSEhRgsTG + yFNFOs+YjQ80y1+vNtvolfI1Egog7DAufjzqGx6CA+fXE3Ddmq/h2sNdi25PWL2FkyZPjsODEwiwUqcZ + RBRxZcwygRhoyEcIVvVcMmEtUMEN+lFYYUs6UOBaXTPZMxd8ft10F4f0xbcPUH8FJsMOBVn4yw0UNHAC + Idx0NAeNBU7kCHZ8RKddg9xNJ/9IWAkwEIEEZ7WYpJLAbPBChrPAdptctsnT22y2WKmKTieKWF8Ru3Cw + pC8dzKACAw7laKAyyTxyDWdbITiNZJlV9siCHhEZgQyTiNmnn5ZgwIGTXspHDzy0/MRXXFJAsSE+uMhC + lA4s/pmJDR1YsIICDqGpY0TZHOgjVVQVWOOnB2bDqVgq7Fmpq6+SYQMHMDQB5T5/rVfllX2FeKVsjvoD + FHtQyjDBpLBmgsELEKCQQGN31iFqV3ICMm1E113rKah1zLlNYyYs8IAOyJILawY7xBCcBXJJccQrqjBa + JbxVzmRoBTjdci+999bLKJeCyeBBfuVWkgEMEKzgRmVoZgb/DZsNAkjgMduGOuBDCjCgwgMvENzxnxrs + ANNvv0EJGymCnWwrLSrng3LLJZ8MFxQoF/uCYR5booEHMzRlAgKNqRkkt1rJWTG224UaR1jLIaDAChBQ + sCLOUyt5AwceTNBEa1W4y2i/RHTt771he002v/m62zXaYJsyy7oxvKADSlRTkkMMEDBAAgmdUkyd0UYj + HfiaPDYWLgwD0524fhugO0NrqMgUmz8r36NPzJc72goVFlggg83FKU7JBjA84MACKJxwQjFLs96666/D + Hrvss4f1rTcMoLBCAyy8MGHov5OHQwcwUBBDTEvAnLzyyzPfvPPOt1N88YWBDnwaGegA/0MFLTSwAkMI + kHCA+OOLH7755KOfvvrrs79++AfsrUDuKTxQwefW428cBjhwELLxwbHAAgEUIOcGaMACIpCACjzgAhPI + wAciMIAsCOAMKECBCexABxuoXv7SICsYzKAFKfCeAkpowhKaAIUqVEAKWbjCFsLwhTJ0IQ1beMIVMmAF + EaifBPjUwR+axgY40EHIJkABtrUjiWcbWzuY2ES1OTFtUZwiFJPYxHtNAAYe2AEOKAXE1GhAB1jLkAAd + xwLHtYZzaHSc29rIxjduLY5ulCMc23jGMqaRBUPRIgd898U/riUDGsBBDjiggw4c8pAdQCQjE7lIRz6y + kZKMpCMVCf9JSVZykY3kAAdwoAE/AhITSKIEkkr5BVPyAJWqPCUrUxnKV8IylrKcJS1ractb4jKXutwl + L3vpy18CM5jCHCYxi2nMYyIzmcpcJjOb6cxnQjOa0pwmNatpzWtiM5va3CY3u+nNb4IznOIcJznLac5z + ojOd6lwnO9vpznfCM57ynCc962nPe+JTDBjQQCEP6YEt6oADOdiAF/M5DgzYIAOC9OQNFFpQgwIRBx6I + AQtaAIEUqEAFDYDAA/TYw1FCtBMZ2IAYPfCCCcQgBhKQwBY5oAGQhvR3+8zeDCDQvQUwgIUnWIADVBAB + FkRtgzHVRAaGuAMYGI+MTBDIBCSwgxz/3ACmQ8XZByvwABc0wHQoYEDqUoe7BazApy3gQgceOtUyWG0H + L0Dq8VrWrgtqUYNmPau5dlCBFOCUAVzFnV63utW9chUFKNCYBzhIVzHoLGv0yQ3XYKADUB62UvvcwQQs + kAIUuNCret3sXrtqwoyxQAKIiywGNjBR1qgRZb7aWgUx6NLIVupSFLioA/56Ar6iLrB95ateb4s7B0AA + BnM7bKBotSgqeckIMZjAC/oIWzGBjAJNASxvN/tX1P1Vt71VQLg8ANmzNomNjM0Ce0bRmmJ1YLjPHU+g + JCCDB4yQq10NrGCvW9/77rarJ1BBCyRg2Jiu5o1SstxrHCeEC3pA/67rZW8HZACB2nLWuhE+wVZ9G2H6 + WncFDwgTXTUgATXmZkokihcSVPrYBZ/mBk2qgAu8l8Lb+nW3uKMwbiPsV9vKNwUS+C5EOUABCqZCCT7R + HCrWRQEJdECoKE5LcS0AARWYbq/ZpfGMY9zbCmNXwqi7rQNmILWh4mAHP96JrxRFivMKBAZPneuS0aGO + 2XrvtlSusW6zm+XdXpfCvk3dAlJQgXHFtC1Zcw1tHlUoAoNIXRWAgXPbnBINuIVntVWdhfWcW8Fad85z + rjJnfZs7CEhgqKNzD5lv9Y8orfHIHcgBmx3tiRzAgHsryGulr8tXGt8Z14HdNK5pfAIHxGCoHf/IUKI7 + 9Cgi42JkFUSwkl3ti/15YLbEmC/u6nvlC9vZzvmNsa1Vh4IZ8LieGNgBGj9UBSy5zNiJ+pXn5CZVZ18C + By+QgQhXkFs5Y1rCu851li+t6373liHhuplBM/CCCpyxQ1hCUS5oUmjyEuUFHcDBu+GdBhxMoAUqyOtm + Ldxpbsu4237VdLa3i4IWdCCkN5j342DDpcyd+kRaEMgLcvBfi5PhBjmI9oOJUcJrXzu7mbatrfUNcl+j + Tn4QeEGr47kBCaAHHpH7l3vYhVxbNXXiTbf402cQgVnbmcowxjd958xtGGvX0n29sV6VDoNwy7O02tMj + cjdkJb7oCnLHJor/B5qNczDYANYPaABDFJC6KQPdvhTOM9Fxi2Ur49jkLjiJQeXOmihNieqNwsItalNk + FgjEA6z++xewN4Gabny+Y8fyrSss47Tne99CrzKmK0zhCExgtPRUzcEfF4upq0fE6B4ZkW2V5gSrt80e + ZkEDaN1xG2sbt56uMdGt3Fddd7zC8pu87udZg67TLMi8wjuKFPWE1lDgBRR3NaQpmoLCezXGZF999mcM + 9BqbXddIvzWFgwv3eH4frfhestmHrzTckM1FibjNA1gABXjAa6EYyDhYBDQf63GWtdEZnmnZle3f9U2Z + rU0ZxkAAQUCUvKFHqV0d5IjYoUEKT5DMYMBA/3N1H5hJAPO5Xq3pGQdem9qJnX29HvbJ36XZnwmggLio + 3HmckYgYoPgJman1Rk+gIBFg0AZUXD5lAAe4l01hlmZtWv1Rn9A9XshdWexlGcndmvxYwAzOEwbszNYc + l4ekYBRuXgu+4RsVC5JtwP/Rk3mw2MYJHQ7emW6RnNpxYBmyntkFHI4l3QLIwM3VUwcgXAE6HED4xead + 23xIzvjdC1FMHESN1At43QJQmiDyVtGNHKb9m42VYrVVF+PdmiD+lUkMFQekC5WoB5U43AEmYCxgYogJ + xcvIQFGsnz2dC0VFgAPYm5xJWAdyWiuqIjPen6WZodh9QwrMQMrFlAaclP87DN+uMGGjCAWBhSPYBAbY + IJjc7CGZRIAoelzisWIzNt6+YRjRmSEIwmNn/doDHM5QqUa0IUpOOCEr2F3MfWOZCQYG6aE5QVpldY/q + GF51Pd+eGeL00dnsgRyn9aAG7pp8qQAFEFxM2cA6hB9PNCEKRg5jeV6yIcopqNEFPVXymZM6xIALqADY + ARbjLV7trWIQ+loh5iAsLiMqGmLH3RZ4HJaHVaIseB5v7CJwMJb4gSMqyIYTyEDxDEdCepPOyEAEbKHH + UVnRmeHH7ST1jWXQgeEOetUKpIAMwGTl6cCgEZrwRWWZ8eLCxUN5AeQUDAEBFUVbetMN7IAMsMDXjaL/ + RhJi49Fj7AEltiHd4gXcDroeV8lPBFAAhx3WDbzlGsnEboyYhiigLvZifWwO59RMklWhNmWABAyevVVb + EK4db+Ea6+nkGIYcNBYdWYrlXqlABVhmZJ3LmL2CQBLKgBGgoamkTNChbdwL3HykN3FAxpmJ4XnlB2ak + lEXjWYYlDx7iDWKXnO2UCrhADPQmbEEa8ahgegSk5ZAacnZme8YDGzXgcGzdNOnAXUGYhf2h9cFmvjkm + IuZWKfaaYmrkO/ZWWuojVsZUaTmJytRKbgjLcQmLQYrjcFYOFnlXN20ABbyfMtaZZtUfvsXjfkJm0L3e + UF6fDqIAT2mMcDlbDpxU/0yY20/8inqSJEomYG0An0oigQCJpyNKEy0iTGFemOzdGBlmn/7lmz1KpHYl + aa/JF3elAAvEQHpZXBhhDWqRGXJeHaplzj0E5y3uaOdIAAf46DNlAIxwnA4eJmC14/RZGa9t5FeKXGe5 + HpbtlJ7sgF8uWZidnht2KaIpJTgGH3kZilKiJ1UyWjbpwAPcG9tZH8BB3uLxWuzlJNs1o38W6OHpzk/F + wLGQ3heE0VqxA3zsxVzeaClkQXqU47ktCl0ETJkykwbAgAvIl06CoH6uaes55oBeICzOqXeWEArsDqPN + p6up2ERtga6gKpjCnEAiGohE6IiMzD5W0w182KQN6f/sFeIHaheBEuL+IWIitmaKCpYDREAFfNmnloHw + EI+unGQLBt9dDl9eFlt5ycZANCc05cBWcue+/duu0qaIkl3rgZwr7qrZNcADgEmx/p2K6cA2/gocJmcd + dolJFiTy3ItjwSoydcADsCbazSaJDh1k+qAzXthXvqPY4c7u3E9LYIAg3YANnOYuYUBDZcDMmoMNNMkR + +WIB1kU/AO15guatFB8RpJ+eJlNyDOmSAqzsydg02mnU9iCH1qlaKuyFrsTLklQHvMAL/NOqaQDDvhJC + 6RwHdEAG5UAX4exBCc8LGE+tMGGpyoOWVKyNwmHVnZrbTIAPQVMGxIAKcOFFNmn/kk4Y4d6mPd6fbaWO + dCZspyLtL1ipEQHQAzxAC3QUE6jUqq0tEGnA1UgADEyAEVVl8YRuDCbZxv7CFbqtW3WJ1BEnb6xke3RI + A46nM+FABTjAQ6Jit6JsRjatyg5lB+ZqimrM3rLE070XBWbU8vaURjXARs2AY20u/kBbDFiA5VYu5Wov + 5baAHjEagvqCzk4Uz+qFss2hU8arXDYhsrmNDOjA9A5TDliAU0ika0atKSJmGFbk004ZpQ2WCwAVF60E + Zp6erM3aAiBwAiMw8QIwvsqSzoWCBbjABLsABFiUC7TABEPABNePmo2eSuzT1SBVPvhp3qEv3q2n8M1G + A+4A/+oOUw1wAAtoCsZkp7bm4MDK44jSX6VulU6pAAsQK0vkwASwgAukQFYh4wqsADIysRIzcQOkQARA + QAUUViiphns5juVasOW2ABd38Rd3L+dUgATkq0EE3kStkbMW57Gxakni7W7kQuekqzNhQAfIsO4a3Vje + 6hhC3ipCZER+lVpaABm3xBC3gOkkcfM6wCIvclgp8hIvsTWW1R+pBgxYwANscfZuL/Zub+VusAvMwAs8 + LjCU1pVe0SWy56HihTe+axJ0DtY+06XcMcYsZmNqa8AW4nXS3uLKjwpAwAxcZSFPwOCZzhIzMpTVZEYt + MpQxchL71CCDr8eEpPZ4siZbc//2Yq8XQwBH2Y8amoPODU8tpls3khqw3B1Uti8s07EOsIAD3E7v2urQ + YVeT0tnBNp6vYYwvGwv8+oLBPBkTH/MxMzMz91RBG3NYPUB4/BAtYnM2swDlPnRFPXTlTnTlfjEE8I7Y + uoigpIuOTmyQ4S2hzsMrR3MwBcosiyi31tm2YVi4Sp/tHZ4DRGn6ebM56AwL1CRAIyOUOfJOh5Uj97QS + n04D8GYH4UANbnM2YzNFcy8nc7H2ZjAEyEAHlPSzkdQYNShdrrK9kgh7/oYca3Qwya+muGmHgqVsmqzv + yt98Pc1UD2NLGJwFHKMT7/RO87QyF3QzB3VYtQAF8G3oaKP/VVlUF3Ov9j40Fx/2UhP2YHPB+6LFTBnX + ABrk0JZkVI7fLFCAUUiTBshA7i6pH0tZbD4j2zkmf9beAmxUZaoFB1gWQfs0I/d0Xf90XQO0RoEaP79K + gx22Uis2U1uuRF8z9rJA7qmF1UgAO2S1lnL13dLhzMQxBQBaNGFADHj2yMkjkn4ciD6faReo/DiAC1jA + BFBpWhiMCyRyXkPyQCsyMud18yqzWspATZeLtToZJ3MvcB92Yvt2YXtx/XQAbpMyPx0VBZQR7AJklh54 + cPg1NSXHnrWmvmGfGPardepgDkENVQeSDmylMRc0QSMze4N4Xau3EquABTh26BhyJndv/yf/tiavOFRH + dGFDgAVQ61qUZ9TNKKEieDhy9SzEQBk30w54bGRmWgaCa/SlnXzdlu6kQHif+GrHgAH31E8TNFDDtnrf + tUHzlD7KN6xE12B3FDYD91NDtZgvtUWDnsCUhuqi1BGxzISC6aoq4cikX1UL0wY4mCjSKZLuajybqJ6l + jjc8TShzQFiXg8Fwz5Uvs4gvejI3cyNnuROfq1kozqxsjwVvb0W/+H2/uH6vOJlPtQub8QYMj9a4jGgm + ZzlPJZgAeDBdSgU0gBB+YKRaoJyS5VZ9d2WKukGwdjEHdDMzM1ArMzKHFV5XuUy3QBckTgZE2yUTNkUj + tmJrum9P9P+nY3ILEPdpZMBLwKiXPmFl4+JeDgY6VpPBMQvTKiYQ1iYrsvVGLVoOtPqhv0AL2BuHU/ls + tzeky3aW83RPRcAMAPk4JBQO4MAGeNIn7Xom3AAIJba1J3Z+m/mne7pFY3AFYONp6OzDZg3cauK88gNL + AvMoK1MOKEYrhh2lRm23SuZONbn6xXs51LGk8ZQi5zWxO3pPq3ejP/oP1y4w6GwHeADx5AvfnS46aEBl + FTZTuzi137c1b7pSAzO864/wDBqI6V0+KHccVpBCY5MEaNy95TKJujR2gRX9RM3Lm0MOSFdWUTltx3aH + 63vcL3GwM3EL9Lwn7E+pz8BVHbEKpID/CzBgME4c2q8rBSx90z99tRe2RDs04reGKI9HqBqRmzNlV189 + 5qqfNi2fZ3erBUJk7ekXagNxJ46HkBs73Lf3zed8set8UC9ABHD9LwTK6l7yBh/x80JxBY/VUNgM4YtB + DlRAUnfUixP/fgM3ize8fivs3R9GCFMW3M5G+gKH1gCVmm+TrE5XYu4k2UVmijaABaizcRz913E4ejt6 + zS9zegf7+UP66bjAxYfvEF9VBExwBERAFEex/es/BT8AEEw4GF7ReEQmlbkZpPV4QqEsKatFvU6nz6z2 + IYVCLJ6M0nxGp9W43YQyq8DjcrqMHsfDZ5ZYTv0HDBQcJCw03Ihp/1FZOGk8YWB4jESBnHRkQFlRcWGJ + 0bkxDA3E2KlQQVnQdNBUVXFwUGF1XXVVmX29lX1dWYjYEUW60ZlgSVFpSEFOSYmIcIlYjm5QSbGY+AQ+ + YoLg1ML66voCA6eSyro6b3GC8ct2N9PQ2YGhiLOYwc+Tqcjrr5ChMKGDjXcFDR5EiCSDBxYOGilQ0CgS + JkwnKD1y1GuGhA1EEr7rUMGFqxWvdt2adQuWSli6bMGCWbKFDncYOEyo0OLZMmjNmP3sCY2niwczYAxx + l8OCCycPvpEDN84cVHFQuVyRwfFjQQxsYlhgcQ/fHT12xt6L4QHHVrZt3aK5IaFYrAULUFCK9P+I0l1U + sFxU8ADqbagME1w0WGVS0yxVrGKSjBUZZizFtGA94OBuAzEXPJt9bvZMNOjPy4hO2KC5QtMoW7CUs6Ll + 3Gsu5cS1uGKhwg6Pgwt13RFDxvB6cfbh2zd8H4UYMHas9R1d+sEMOug9GLmK0QmIeqlBmEFBAgfB0wXl + qNCgZGKVKGFafs/ycctX1dqJ0vBixuEGDXqmeAaanXbyqaf+AJzhhfJCwYGCKGqrypzXZJvwi2+4mIoF + GBY0D5AMNuBgBwkmGO6fsf6hgDkYXuiAvA5fhLGQeCawQKcUHGDABEyoeaACCXLgMEY0NIChBfgiU8Wy + JJdESZclaWngr9T/RMEBhiaQEeo/oAAMzRnSmmkAAsA0ACauGZ7awqnbngqHnNayiK01GTooQ0hAMNig + gxcmcGMfCwCaAAYPgOzNTkMPPQLPFySgZ4YpdBNPB+gQPeMGDyqIoKT2cGnFpFqSlCw+kxLTJAUNgxTE + hkshiADLLf/rKUBZuewsyhbmJCgUG4KzAIonbLuKzXJq6+LXNC3ErQIhcqXUDAw0yCEHHTrY4QUPdtAh + WhzqbLZbQzHIIAMNcNgghw1wuOEGZr1NQgcZIEgJvk6VPFIxyZjcxYG/PFiXEA0SgfVL0kQj2IXRPGth + AlTPk8BR3NK0As1zqIIwnIpZ8HFKds/AAAMb/2zoeGORRybZCAwMewmXye5NqRZ7F3vPsk9LegAGjQ3h + YIZknAnQp9FG81nAz0RbpoEZMsNvBwoeYE1Y19aMSjY3gRVnhg5KxjprrUlGTz1OT0rya3xXyncymR1I + hQXe8JPggQMDBLBnLmn1sufORuuPhcCA2cyKB51qc+KJI7ZqWC/UOXVrxRdn3DwNJFBkhfVqaQ9UT0/y + FLJROc1khpsJqc5Bz3gOLe7ShRaQGS8BTCaFB2JAirAXWHDibwlvwz02ip0OlgIduG08eOGHFyWDHfbz + WvOSwsa8McYoU1mXmCKYAHhCqmwiKNTl/rluLwWEO4IWKniBTFF0qACLX/9nu93Y3SMsFnejYie+fvvv + T4IDGSJgKV7ln4+eyygzL8lp4i80EQUHljag7wntbqRhnay+BzcIPMB3wMhP+h72PjdJyFgYih+aiiKB + SeHPhCdsnAcgILmXPAlzLnNezEaVsslILgIVGAgwdNAEAjnQGabz3gS5NLTQMMVq2diABCzQtKncThxU + gxP7qvAwdcgAaSjEYhZJtgEKpKAuZoNZqGQRLyfZYmyJgYAE+lUID7RgdAcD2n8eSDcfzk1v2bBBSDb4 + oAnFyVcUAsPfJvYFbiRoYVpEZCI7lIEXWKABqVDZfD7lMntRsn+cigwLEAgMCUBAGakD2hAN9r0hOpD/ + bst4wAuSEgOJTag13ggkB2eDmxbwQQdrVGQudemWDsyAf+uRpL1iFipPuaQVkWlAzQ4pCAkcRnU9C1rp + 7Aa3UZpObi1QJR47IINeocM2uBMc4KwCSDDobgZC2GU61fmRGxgGMWerDPNiOJ9iUhKNfXhHM6kRlLuN + Mpo/lJUES7OTMEngHRmMZbCgVriqfDMKugPDGHC5TopWNBDoWQTMgqm5FsKwo/AhGy8ccLRCiaKZ/QFN + KenGQKEN8ZTQ2IRB34GDCTDtb1S4UE7B6cf4yeZhMCihRYU6VDNsZoULiKQ9OzXP92gUgC10QfUKok+e + WBN1dIwj+FLnkyjJ9B3H/wNhE3l3OFfilH3qGN8OzEdUtrI1AzAoRmJOwlFhxkx6mDMbLiKgNoNQtUs+ + Y6nqgAJQCQ4oGS7walImcCYIddBCUPvgmi4GDtzwIYdtxaxFOWAB/rGHebQgYF6fB8DlSc5UqOkrf54J + RLt1iWj+bKBgVZBGgyzkK+pgaFjh99g2jSMcYYlBUDM7XEXa4AUukKsknTpXsEHGf5G0IQWumE/+CRa2 + czOswLb6QGh09SA48MASmyI1wnlQp7OM07AeNoNNEte9iFRgCiQHUry+kLmbm6dk6tKCtaUWpSodpUBf + u9IuyRaxCNEfN/a42yuU1Yl8jJDfaimBtb7XwibcAP8MHqC5lizmqaDNhXM3d69VNKACws2GXwfKvZY+ + kEAuNax3D3IDuFI2KsUaKyADF8gKykCtFway/Wwgl5FoKpKVrBctyNg8xpSqBTCwnjv8SsftAc3K/gwf + TGl7EAxss0YQSm9uqXY4NUXsKg+wAAX6G2Q2M24DvqwMaFvinjlDl3JkY0xiGpCwz+VTtdQkJTUBrDpQ + pk7GB9GA0r7s2wpFzYmMthgtnRDcNld6a6raMDBTFplJgtRycl0eXk0r3Y9IoLpELKwPXbu67vkkph/J + zxL3OKwL3Vh3IQxrsZhSgfZa2tfssgkFkAtMYcbLrs9bqi2cG2rETjTFzrwqSwP/XegG+uQnh0aIu97U + aHJKFnAQ7S1aN4LiX5fbThl+gHxBHOL/mU2pKZPnMdi7FX36B7ANdPFficjq0sw2sd+l0YLNiyxflfes + 3r5KmjuwTHM3XDptVI8965xUYYbNnrlITDXIQO+RDCVoEQRNYSP40s68+iMY0MFtqfhNR8cPwoE03Dg6 + MV2H13w6/8oUfonJkmTLeXmU4TQLn0xuP6NU30GcI0uhid3+HHgrC5GBTW2NG9o0GsdiNkctPVBSm3fd + LTqwwCnW82mWSYbDlKNzno3Wa4SYep/YRZ1WkU4rILJutjBoSw6IscGFesHW4/w2xcLwOqJ73fAF0Z8i + mAvA/yPTE79ie2EEYlDhhJzU3qy9N0CDJtAfctXpTy+F4Swmetj43e89xZAMXlD4w7feEBqYgBtFLa+U + MI9lTPKoAcfgFqqW0oGA/idAXerqLbNlMw6T2iBnudMMwdxXtcSV66XvDrC/k93GFqPZ8azkUaliAaYq + H+87jupowpiBdMTuYf+dkOqwcrxPXGhPzaqmgYsVBpSffv4DkQHIsVBlpKWrd5uh7muh75sA/Ks81Wox + auI8BpomoZmGz2MLRlqKCvKmiqkKQUooh7qQh+E1rtO/EDSDDNimCPiiD3O3uuq5JlE2k3iAq3kLtyO0 + Ugql8/MnuPMZ9RsMBaqCWPKpCv85q1qbojAQA60QwSM8AwWKHCODN5IgQMc7ts+ChQjwnMGwPGbAMhwk + HSwLoqvyt8EgkjNxPr9zGh2jtYTCCgpDwjVEAsgxBp2rFw+zL1AJIyUxoARxtoNQMRj7q84oP0CLG8HC + NrZAOZxYueS7NSDEnWNJRAtRMzaERA2QgRuxr2HyNHarL+bihRV4ABLyjSucIODzHgArooGKwPXbihvo + AAdxghxTPsIZvah5EyiwhjyExMO7gR1gAa95mdqjpDrExDkToBXonPuIwfEbKKzCrlQrkM7rLgl0Cxpr + AfGBLFl0pXE6uPaxIPq5xekzHkwhFZ4jJo0CsSP7rNKiHlv/1MPxI7CB0reRq8HU+cLo6ABZayxIo4qo + gMXYMDP1aoGNyAEQ7Eav05/DmC8QI0dOQ7LmwhfGiBILYLu2sDx33LxmxKqKFERodAtEcBjdWh9sNMN8 + nEWMAaqBnL5mOshLysQ6Y0JLhAwWosKNiw4ZfCZVIz9pw0EAOUXpwIAcsBKpA7xwYznbuZgsgAAxgUGT + PDwboIAGyITHyC+E3LRwLEc6dIAWUEPpmEgqo7ul4544mptBfIvqkAHcmizaoBB0gJ/Soz9f4YQXEEil + NDeMgqQBbMi8gqcjc8Kfg0jzUDF3HBBAY7EWE5CmQ0W3oKkxbCLeihDXEJwww40Kshm5//S6/NjFsSOm + xiu2JwybxsAFCFAYv2RHgsk8noG77qkm4sO76cAAD4i6qegCtFy+qzM92YAAFqAAOqFMm1MgeGGPXpTK + ppqki1sSTYAAGYjIY3ybihyamgTLHooxjRwMHGgYiEqT33osNcHA9CoWD1y93XQ4DNCPXwqgJwTO2WMq + kmgAtYkyKzy1d6ymrPq9v3KpeWRNn7RHMrzO67TOhwKnqLAGYwRPX7OBCfAk9xgtX1SJeZlKltSXGGhP + K4Q2kOPCzaO7jzOYjDzMt1CVGeC7/Xyi3tLHqRNCjFmzAbU0Sby43zwjAXqZObO4y/AAGKm3fTvNZUQ1 + 0iwQY5BO3//Qnxp5NNjsoAs8PWy8AjVC0V/DgRlwABQIKQ7jPucZm7RbnhQ4TgHVyo4jNCvzIbvxvRz0 + vA19ixt4AW7CQCnKxshyuahwgtBMUkvbAAuwC7KBQyj1KCbDzFVYgQiIvhfZSu6iFWiyyXbUSfvskCRa + NPi7Oux8RTJDB26IAYZ70+HCARYQKahkPGRbUBq6HLpYAQjYGxp9T4q0yBo0nZ84P7HkSW1jDanRTiF0 + vlm0zYSR1EnFrCXdRBeVJ1zIPQB0jJYwGtZTTlfJwp9prTjqnp8wORiJC9toxHsUp1jstsiUKltlMxyo + gLMBJpegF4y7nO5bAWSombj8RGScFdj/AkRoEtQZVNXp8LJYxamBO8PcyjoNiVBrHS4NSA9RucSFxJef + 65QUaIELEpIpC0wMDTAbXCks1EEhSSIzvTVH+8/HJK8/qqUXUEd8JaobiIGR2EsFxaQXch60I4k9RU5y + LVeji62EjTukKzRlLb4YoU4WYIopkk1gOUOiPJbdQFmNJaohSzfGize7dMIA1FOsvFetrC5U1Tzm9D0H + TMZ2Zc3jYYpX8gb0IqvT+wYWmBOfDbJeapVQg0oC/LnuG0AnbIC+NJSTqsl2vEkKDTnZgoDVPLd3aRrU + 2y0dQ8RzojmvJS50y6h8YZI6DKCX3IWScB0JSNosfTv5hCPmpM/o/xRT6dgVDQKhb6o6hspAw1GzWvVb + i8qjGVCPluzUePpF5UmMFsCnQ9nDArsbLDzYFoNdCDRUIcmPqOMjYtFaR31VxJkALP1cSu2isZPKPNVU + zgzXI0IUUGTAVotPl3Xdhj2UDKMdRsvA2pzNYZkBmQxeC+uk5NJLOhUVwx27CKAAz/3EUQUiCJI2G31d + V+vRFxHPnLjcRyMWEWoT5OxeIEMPg3SSusrMGNIUKkxK1lXA63JAGoy2lTXMZtG7bnIfQQLCzC041UPA + /cWsyiXPERPOxYsJPdU49C3XfVqxUmSthfXS0pDaF7EBDmAlsyQnDXwlLnCCjegzDB6uXWEBjv8yXHqS + 0nx5ssXtEIMVRdiqNszrvMOo3W/ZJsSRuW67RtxgChm4YRwerrd6gM4qW7xqN/bYswkQ1iHmj5S6QRuc + Twz9jxWGkYWoAAimJb09UwsBjJ614o0dT1KpSm+dL8lZTyPsFpqUO36Tphzk0hy8O3bRgA54YSqSRUeN + zH+EAWyo4yAjBQu4kV8sz1B7iT1TkI1hW/icoEB2XX7S0I2xAXfpFYuN1bAKi9+l40lmK4QqOT0toNKa + r2MQH6MIYxodzVNiwEFeKYVVYyEhwUZxY1pSh9r5Fd2IgRfgRlgOsg0IjnTTjrqwZms2rfHxgA3I2Bj5 + y5ALqJA7Ohslvsn/NZQWlgBuIsKjZOejvIIZaGZuhuZfq46G0YlWKZpoYAYxmIAdEGFePhB3HDkMZVgz + NrT4bZYQIZE2ZoGGdmgL0A0ZgIEOqOJ5puR4EBHhOA5+kIHmeAEd2AAhZt33tCrUXLUuBMRhRpQMwIFp + eYFFgQEYkAAJeOls0QCRtmggAxdyiRZzQZdXppQ/JdW4FejXWh2YQuiNwYB00YCmvoEMAOqcluo/6L3W + kiPC8h5RjJUGnuquZqu/hFucTLppk1u69eqzpqg/FVTu6idxvjfJReu4XicZJOOmbetBDmSXUmm55mv7 + +eS4K2TmLOMfuraY7evDRqFPDjCQY2wjVuDS/+gubELsyUahF2gBLOEnfCtFjAwsoXCdbKLs0K6fepSb + aPO9uPnlFA4NCyhg0XZtxmFV1inhc/3KocbCB9Df19btxekbVgGKpZO79bUm2Y4bFkCt3UburCFB0cHC + ilTX5lxrwnad3Ozm5LZuIamSdLM3x21azEu//hi66xZvkekyR0KGBIZa0gGspUMG1h7v92aXBlHX2UVg + UrUuAaGAXYbv/fYNRmqCaEhXuUtWosFCC3gBnObvBN9IK4EA67qyolbvAQlQBadwIfFJFvBsonat4dNn + ZtAQ4K3wEPeNHHCQLLFr2Y6mZ0CphOlbEXdxDl1FK9iJn2BaWOlw8fmTy+x68R0fjJ70gKUxBmTAbIOB + G2ngEdXrCB5X8v7epgafQZO2tuPUzSWn8rG0DoZWh85Ihk9yAohWlt+p8jB/i3jwgBhInwafhmOwUhaA + Zw9wETGH82jkgBcwcypw56KYAGe+4Djnc4MAFw0AER3QAQ7gAHN56j5H9ERX9EVn9EZ39EeH9EiX9Emn + 9Eq39EvH9EzX9E3n9E739E8H9VAX9VEn9VI39VNH9VRX9VVn9VZ39VeH9ViX9Vmn9Vq39VvH9VzX9V3n + 9V739V8H9mAX9mEn9mI39mNH9mRX9mVn9mZ39meH9miX9mmndgsLAgAh+QQJBQA8ACwAAAAA8gHyAQAG + /0CecEgsGo/IpHLJbDqf0Kh0Sq1ar9isdsvter/gsHhMLpvP6LR6zW673/C4fE6v2+/4vH7P7/v/gIGC + g4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp+goaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2+ + v8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4+Tl5ufo6err7O3u7/Dx8vP09fb3+Pn6 + +/z9/v8AAwocSLCgwYMIEyrkhgEHhw4vJsSgQCEGDAkdOODAsLCjogweKrRogMJEAhIkEphA0aBFhR0Z + PMocpKFDjAcqUCQ4EILAAP8QBAqMSMBARYsJHW7MXMpnQwwXKxSUQDDCQIieBEIUEDECQYkTK1zE2MC0 + bB0MOmQ4QLB1q4i3BUK8FWGgbYECJBxU0GG27xscEx6sKFEAqNa7cw3Q1doTBIgCCFY8mIDDr2U0OCo4 + MIFA8VW3bxXTvWsXMQkFK2SQvcw6TIYYK0jE1Sqibe26o+fqnl3ggIMJNloL53IDRgTCWd3iFp2bLl3F + iu9mLZFCQszh2KtgkADhxAjSW6GLd24AOnnnBQiMOOFCAsfs8KHkYHGChAjacGvXRmxXP2i4QR1wAgur + xWfgEi84UBdi5Znn4HkPRndfAQas4MGBGCKRmQlA/Rf/2oehKfdheLoRAIICM1SW4Yo8ZCCBCwl0CCFo + 0JGYW401mlgCBB5cx+KBOljgAAlXgShajbohWRduuV2FQAMz5PAjhi+4cAJPNBpJopJawhWXgO1NeWAM + ay14Y3g2LiniciHu15UDMYhpYAUnRNfWkWlmySRzTCI2AopywodBCwjgl9iWFFJIHqLOHeqWCRYEmh0G + EIyQ1XMhMpfYjbo1Wl5pBZRgwXuStoaBCyMMIBeemTZq5HMkgnZXTyS0QGqpl51qgKqNKtrmaKyyuaho + IYBwAATB4cqarqoGy+lyNjZ33mIgjICsssu6sOuq+nH6bKaMklestT5iq0wNGKR7/2sguoIQgqbwdtom + vFvCNYC1yQqCgQ0Z9LuuuXrYsIEOHXSwww466LBBuX4wSwB6wD7L5sSIemasC/k2rIEOHrwgwccv7MCB + UgDbkQEHL8hgwQMuQBBBBC60DAELFcDQgYp8MPtuboquGSuI0SYWwr0QMJxHDh7EwAIEDajgwApQq6BC + Ci1YMMEOGpQchwYvWKACAyaYVMLYJSRQQtgnOPAADDjr0e6qIi5624dHnlkeegMcm3EeHFSQAgMHVOVl + aAZ0tQAEExSotRo2cBDYCglUJZ6D5ZWAglhJ7aGzs95yObfnBQxgQNF7cD0D5CJ8IMDqqq/uugD3KqDC + S0YvPv/GBhSksMIJJwU+wgGFFz7C77+TUAJqKVjAVx46Qzwv3Xnyiei41+KBgQcuLGDCAYUN8MH34If/ + wQAPk2CCAzNwYLsZOFDgwFSBH3AASvLXLz8J89dPAgILWCCl9dpq1lwS1Zw9tUpufOrJ6PY2BwzsAAJs + IYCJBvATE1kQKBj8CVAedoIKKG59X+ibChRwAK4MD3/5wx8K7Se5oTjAAh34Vxza9TAlMQpJmyJg3Qxg + InLdwQYvaIEChjY+CmLwgkgEwU+8RwADoIAFOwAhGHBgARRMhXj2Cxz+RoBCLsaPeAhAwAla0IE7bC4/ + XeITrDwFvdoQjYFxeEEDECACnxT/0TFJTKJj8PiwBEDgg1LEwg0msIIS/q5+XkShIlOIki5yBQUzACQc + 3na3JT1vRHtCk6sshi87cIBQIPiAYzS4RxMBpYKlNKIpBUAAE1Aga4HMggZeRELi0e+WKlRhCufXSBIY + 4AAJaIBqzgKBbbnqTMOCXt0gpMDqzSFIJ0gd7DBIzVNS0yc+ueYABPCBEaRGkrGMwgMZUIL4NXKXuExn + IxGQPwSYIAUTkGEbTpWqd+HIV4ca0auAFZ4eOnOGFUDBAXyiQQni0ZoXLOVBHSNKAuQlTuGsgg1kwIDh + xY+X6Mzf/XbJTl52VAEtUF8DteWuu3XKkhSz4Unt1clnRmAE/6NUoilNiUo8ks+UCD0l+RDwADhGtAk5 + eIACLGo/XRoVo7m8H/3kN4ISNGACJJthMUs6I4hFR3oSE1e1/vkGDVAABQUY3wVRaUHymXWUZV1oKLvZ + gOX9FAoaME5nDsnFXvJSnbdEAErYqUIuogACL/CpGujZLOntUE9p6laf3iiHDEwgBSUggABims0JZnOP + 2jwi+UYpABGgYCxvfYIDq1jCXyL1rkrV5V1z2VEScJEoDwDnYIspQAnNK1zL5BIPLybYNHQAAibY1WQT + qta05rSaBGWlCR4Qw9A24QYxaEB9fnnLXWKUkSnkq0bzZ4C8vEAOhLUn3X6FzALWa0GMjf8DBRRQWVXK + 9KCVPaJ8qblEAYTgAAuoQNuciwQNzGABO6nrCo96VOvuNYvDM8AJZLBfNlBqW+aR2yaDZsA9Ua92avgk + Cca3x5oitKAVJGV8s8lEESSgBbLlrxBwwAIGLNWuBVatUV+sRaYawAQQkECDB4uqwiYpsWt6VpCLdQCM + wQEwKjAAhy2b0/heM6caJCVQRhABt6r4CDmAQAlUW9SNVvfL+OPrXpfalctJYJJT5RaTIqaoNVsyYjga + WkvnSYHYDI2+GaymNff85MtulnwriOKVkcCBFPhyu9f1skaN2trVMlV+CGAAC6Lq4ACKN2KbOpSE1vy8 + 0B0Lw2fAgZb/06NEm4YYvvDdbHxBXMoPEGABgh60ETqQZOpid4UZ5XIv2and/HGxAWV0w4NLalgI7VDI + Ed7tAt/ggQXceaFSpqlmNTvTDC4RKKJcwIVkbQQdJLl4p4Vxrnu5P0U3cgRcYcAEYFlpY+IQjXfSJALj + Fro5ryEHM0DANkFc7fk6+bIzJWuHQaBtbhuBAw2wKLnPCWNyjzupvPylAlwAA0qn4Yz6Qel4PIXPY3OS + q5ihQJK/J2XMpvXfHpagwLPJSlgbvAg5iABVGn5OR+fywDNeePwsR8Z5kpRbGbcNtL715gQ2EeRneEEE + ElCYO1rQuAE/rh6RSD5Xu/zlQ+CAC7Z8/z++tpbheS1qUjuqXUWWwAEUkCcZziisT7GxVwWEnpyRXgYb + VEAB6cEpiT9c1vZqk9VLXKIIVGDllwf1BPC7Ls4P0OibL1KREP+iAh7wPx7XszkdT+a0kq0c6vVWDIU+ + gELJymrMLhSbpvewEe8bAZFinQc3UAtnUlv2rzPeo+2cX9mr6zsRIEAFMdjx2i1NL5XelmKLqjfdb0en + AkxTxDatLOqjnurN6lSJ71IAgV4vBBtIIAInmLnjIY9U8qdTux2dX1VOk2O1h4GGEsa050D0ufAQ2chp + eI0DLCXKJVIfuWhVUNgUbajERCSgAhRgcS/XAf9FFbp3e2GGWq0lZv9itmi45kW/I0YsIHxigHG4pVho + giObxFKkkwZahwATZHKnlFCo12fRhkQqt00hsFyxxn0YoHSRg11iFoEMt2gQiH5K5Wvd1QDfdXE9BnSa + JIL5xCoQch9b9XlegAExwAAhwGGldlbRJ2KnVm0pqGoYpDohsAISoIBYtwEtEFx31WsPx4MyZl0bVUIH + wADpY4QQhkyaIn9zMyyxQjSg9gUY0AEtUAKhVGp6x2cseHohNlYmt00GkAIpxm0YQAELUHPjx2heNn6O + 5oPDYwINQAGP2AXwhxvRE3ch+CtHYiJFBoVckAMVUEje43+lplDt5Xd6V4A0VVMJYAGqOGge0B3/O5Fa + PNhri9doFahIXhQ/YkSEaIBxHNcrIohVD+JG9kYGMGBnUUZfKkd1qLaCp2dTozQAeKECZ8Z9RoADMZAC + QwVuPph75gdmELhaW4Q/HUSGYBBe6NFmmyIsCMRxH9eHXaABDzBQMkVKWJiCiNhkKxdiPzEC6FN55EgE + rBgbptVlSTV27BiBq7WD7NQVLlB4HUh8E4ZDh5Vpx2QVeYN/aycBDhAC3FRKBgWAA8iNihhwT4dtBJAA + M6AD7vd6HSBzhWNOt8Za+qNLtodLvcZFK7AXZhCK/lFhx8dGKLUY6TUG1wMBCaA6DVVQ0beIyKWV3qhH + qnJ1D3kEGTAD4bdI/xmJezZ3c2lYbmMWP5yoX2XAjMjnLWzUcYniaSU4Bp/kHUpkRPIFcMf1ZKnGhXgU + AjvCbmNpBL0YfkRlYAPGjrs3YxCIP4VDAuwRbFR5hPc4gkW3j5gmldMIBhKwAuhWGLHob1vZldSmlWXl + agjgADCwmEkAGCmQAHRRV7i3cLzHll7HeOv0aL+0ABMwlyDpZtIyLeECPYXhQ2NQliZQGFexlTQJfSto + fdaHkKpTAPn1iQ+5ATNQUYckY4s0mdmlPxi1g4GjGAnwAK73fiRVQ8qhJyE5Lw6yFZ5HBjrgAgcgVj0B + fZeVanw2bf/2jSTAAg5Jm0cgASqwE66VWg8Ief87WG6MNKFuyU4G8HsVkKBRCJJwEY12c0mkeJK7WAUd + YAEn4Hyu9pcFCnUJCYA6pUEFgALxpKBKoAMsoBO+c542t1GNZ5QRSqFcJDsxsJNXYI/vZklJaIpEN3f+ + eAUZ0Io8oUoAuppOJnV7tneh0pE2qgQZ8ALd8aDlRz8T+nXn9JtuyZYocWIcygUe6DyeMzGtwhzKV6JT + 0AEpgIJ/2WEjpoWsGXV+x6K/B1VdqgQ2AAMqIBsCRpTmhlpsGJwXqlFDCANGqh3xCXfmgU9vJ2EOgop7 + 6QUZIANglZoxRaD99mFYOlaTxQAU8KRdugFWqY7mSWBueZ6Ot4NVMQIM8AD/O1CpU8B2FaNMPjNeIVKn + YPClx0FQ1rSFBzmAhUigBPkBjeiRhWoEkbgAXIdLFRqhZppdwemowONCkVSPnLlmpdh2czqsFwYGQRJc + JDdwrvmV7yWgAOeaQZEALOCqhboDD6Cj4MZliiaBiretF+gVKlCEHapkO/OhJ5WEOhQ3bGKsX0ABKZpH + 3XhyF8usB0VB41MAJuACNVitSXADvZiOFKmtdvWjKiSMiPY7KKKYW0BJ5qVSWIUebXd/dvoEZngALZma + gcp33tiN1KZEsDMCKrBuItsEGfBV4Xpajaqy78hI1cVFw5MALvAC+goFzYMnouEhHgdnETN3Oau0ZBJW + /ytKiNaHsakUmKMXoK9YAiwAs0mbBDowR8d4SD5IoV9GsBTarRmKAg/gHqB4hF2bjxtnfDVrFUc3tkvg + fbdZhV4ZqH1HmHwHfRREQSKwAOM4t0zgXyuwPXhLYJfocDTWqF00FJAkt0d6nPXisJnWtc8ojZ+aBRvA + AkNFAHc0mNQXk7zLtqPkaiIAUt7JuTzgASywAnOVt0GqWmiqcznnOwiQApqpBUwZdG8XpyUZGv7EuEpA + a5YCmAHarFn6lQRIU672sdZBvEqrdCXwk294iZVZfu9YgevIFcTJvUhAl3nCT/xYL70ylVmwtOzVUIF5 + VgWaWVyoctb2ASLwG6qrvv9HcAN3N56mW54ZZW5lJ6l/0gI9ErPluh/BkljmNadOOJpVUByG9opcKa9Z + GmX9NnVGdACUB8FPkCABxkvHiFe2SrrKu0VNtQIsML2rW4eZtKm6JaKKu2xaoHQKIAJ7irF9aqrku0En + 9zAMAFE03AQbYAGDMTw5LGBFaYnB2MP3kwAOIAO+ygShOJ/OUsRyuihiqwV2pwC7ZYVoq1Z6VouEKW2Y + ewIQ8J5ZrAR/WEXoxlSUmFH0q7cXvF0u2wIcGAXMSCP7y4QGBCz5mQUxJ3qBF7kymYhZCKimtk0fQAIR + ILiB7AQekKeXOZTOK7UV2YPh9h15QahYgKRwVopNGCH/BESC+EsE7XMCkiVKsbiF/LaIAYpy3+hqn9XL + nDsfvVNjHNV16XlrGSy6jewBzMwDD/YBCzuf9TnCcRcdxrJ8T+BYcxRKFLS7Auq7h9jJFTQCXHrK5Uwm + nEFUdRXG76it8Ah2KVQCCzCuq3t5lRQtIQyV0dIWBHAAtoIF+4mbMKqNffqzs3hQohQCuloBDyzPSIBv + 70MXaAmuM2amZDe6udQVKjCbRwoBoicrSfKhidUn/dsWPJXGSTABDBA6xeWnepyxqGpB3+OxLUCtGq0E + 2MN0IsDKO9yDB/aGduWov8QA/oMFD1Aoc8q1SFxV/lEb+IoFHABBgzi5agvWfYal/46xOoNnykPtBKGK + Aj+ZSGqJkcW4z5DmqFt0YxEAAxntBBZgAlUBHmxMf0M3dAi0HjJwBRsgAyugZMIctC24u2ZFU8+6d+ND + AhaQ12l9BNgze+NJY2i51CsboZI5P+URaYB1BWpRAuiGH24WgpJs0P7hQsWpHROgAoVCenmsaqWXSqca + k+TDkCh92U8AGA0AurppobtGe0wtbhhVV/NoBVUCOHFBn3a4T5xyFyTAABAQslFghoUSi42NhbIIXyxo + i5Q1AigQ1cANBX2DAr7ERbZHjAELj7unlvKToX9sBRwwA0MiQcdHYQzbMxIyGxoKyOK0AlVIWSysjfNl + wPLq0/+txFzZHMgOBFkTibK3l5aly62LRjy/dNL02ARVWQI/EX/H1oTNWEcDUAItsAP461XAzGGsBqg6 + fWoIDGIfwJ0SEOGnfAMo2nBxzdm1esiZiD9HDUnNRQU3QLH83dKFG9ixoimkxqpZi9ln+IrEPMXG1WRB + i8fH8sgrYgM3oAE4gAM5wAE5sAE4oAE6fgbfxwAUSNJqqlQj7XCKx0UMEAExYNlLsAMqUEKkYUO5lUb9 + cQAqoN1QsMULoMmU+8INnrYMnkR48RuEkC42YAM0TQ0ZoAMSQAEq8wARQDUPwAIUIAE68OF2kAPnaAI5 + B4S1msgCi3NddAAmAMRtGtxVREf/+JF5gt056dFdKCCXJnqbTlxT3z20Cc7JAGcAUC3UZnQDG8ABBLMD + HbMDHZADZz7lzoADHjADTOMAKIB47sQARQEBFiABOXDpbcCKLpaG6Am/kEqmueZruqcAESDEUrADOYol + 5eXNapJPX/JE9h4FL7AAI3BnWU6Lrnnlq7a2CJDdfyAwEAEDE8DpM2ABFHERHjAy6H4MN2ATFcA0KPDt + JrE/XmECJ4ACK9AAD2A1HaDncPACtG1gFXzhvLeWKVRXZ4ewVcCv0dkTqs0giNGw+8HfIIXNVzABJjBB + 1xbW4vtkS/+X6VwA6tYHGZADBCMBEy8DWl8BFmABM1ABFEEB/zDgATuQAy6fDLPUAt5+AgqgAGGTAHCv + EibR9m3PACigAuXu5XAAq7zTjlJL85993IuHniSwADpPBdvRAL4U3aNRGm0idIzvVLRsBTEg4iUnubbN + 6ANHYjI6AinA7HOwATswEVq/9RVw+l9/+qcvAxUgAxRwNcNrDBsAAxBATltmPGWT+2GT+2OjV8ejAmtz + 7nlgA9EVfraGThgplCAtdl33OyewuVagATEQAeT0HdENHvuhSbMiFCXAACkQfFlAATzbUIIJdQqVQdVZ + fT9xAL9u6pOk7TFgASzg9RUwA1+f+vdv/xVP/zEABJ4Nj1g0HpFJ5ZLZdD6hUSlzU0ktTv+JUgKR0HrB + YXDJpEClWpTdbdp2EzcUB0I0OpAOdz3+TvLv/xD68PwI+w5GDEwk3pAwdmQiFEQICEIuQ0Q0DUQKPAtC + KgtMIip2MBqPZEYEPgZACGBfZUFoaQleY3VnQXJnPwRATixyUo2dNDh2JGIqKixmoCtmnKmnZahnsqlj + YDoyjsPFx8mf4la+TL6+tsi83N1N1L0UVlgkNMrHdVpMDOzyGCqk54CgP4cC3TGYR88IEQpgkMMBw4WJ + RJo2FeikUQQnTiNITRgyrgKrD7BQ7rpVKxZLXyxlzdr1wUADD/rG4dgBg0K2atOAzpARlOg2CzFyoMK5 + lGlTKjFcnED/QGLLmDHq3HmZp6UEgq4KHLSI4SGHDadtbMRYwGdPQECE8BhciHDgn0QQy+F4YaEBCgUl + DogIxTKEARIJTCxo8EACjnKrBAgYUCnlZJgtcWHOJQtXrcm8QJSwkO/sFAwacuyYgE2atmk+g/qU/YyF + jBcjS+fWfSxDjAYMsL7TmlXrcKxbS5BRwGBFqR1mdzvx4ILB1BF8/vgR1Gd79kGHDLK1s+CFPgw4PMy4 + YoIOrskiDiSOMMMDDujkKCAYsN9zLf+dM5NJJv9usawXEAo4wAFGokNGhxcmoGAoZyiscLafMISNghcc + a9DDD5fgwAUFxIBnHjKyykoeq7yYqgSw/+7ZQCkQjdAghghMIOE677AjobtCtNNjLh+/K0GFHZjiAIYK + HohgBQYYOIG5FB6oAAbc9JnAhAL6GxCm//4zUKXL9iOAhAVk6JBGI85TjbXWYivqNTlhmyaGDmZcU0/d + NIDBgRKoqmqddpBD7h11TECxK69OWCACFibQIU8acagAhQMM626QH+Nyi67ssENAgQg6aCqDDXLgoIMX + WPWgAx02wAEcpl5AYQQuQZsMQDENLBAlmAZwxQQWsFwTgw06kGC1Oa2xZsJmKYSWqGlhUHPPa03dYYYF + khMUsUPZWVGeccUtEVF1GEihAjyv3SEFBAyri8jvegRPSIICSmCBB/84wBanHSJIwAAQXLEMQDJ97Swl + WoItYAUG98xAyWaijXYboDCeTeNrXptgB2v9DVmcHKzIogtCtdgqZcTEPffEc7ly8YQGWICBg1lp1GBb + QN3Cbo/w5GoLLj7sOCGFGNgQOacKViCBYP6+jGWzgzGzpbNXRmmhXz1tQJanaLSRlmOhqMFmQmx+smZs + jCf4Rum3jZnOr3XmebkqMlxmWe+6V6S7UQdcoOBmGjHwoIUF4B0ELoIO8nloQxI5k4UO7oM7lQxecKGE + AVqZmrNfQV/pV1w+KACBCGCo3EOJIYxBQtia3Rha2WUbyrUZqrVc9ykmQEe44r5FNPhvh68beJX/sdrC + aBl2wNnDPgMeASCh6UKoLYbyiNyBGEjbPRUNKmAABMn8+8ylynpxb+HMPDNghQlAblADHSZ4Rpppm7Wd + TrSDmpDOaVggOO8NkAkYsJRXwIWYeIBBeMIrjgMdSDz2IMArDFiMGrrXoEopwA47op7jruczgIjgdKUi + YCo84IAQBAN9LTlfTA6ki9G9AgEQKMaHMHCDDexEBhZggez4B7tnyek12UBbs3woAx2ckIk1soBUEPjA + lkkwDH1roALPtcB2eKFRgduah16gggRgr2chZIghGIcIH51gBklrYhtw0AISXC1qK+HPgGSImQKcYAIg + ugEHIESBtGFsf9U4/2LG9CcUQ2YsGxagALveeEIOtOAEPgoX8ai4QOMNb2+dZAcFEWACFLiAeRtwXm42 + MIMVlCARHsRXGnsmHumV4AQQuEkk3QADFSAgBFAznwxDR8dX7Gc/D9Gah3KoAwkIMmwV6l/Gnjm7ohyy + dkCpzXNwOUAMdKAFCqAKuOqGN5YZL4Kb3CQm25EcxDAAcLgrVmk6YAEUGCAEI5jK4wKyuKHdIREGGNUL + TpnNJ2hgAiowADAONMz1MUxhV4sMCR5wCvnpwAMRwoY0gWhEaSKSkNLaxgzUEFCBiswG04GiirAYQUya + M3gQJB48wNWVxKRAcJM6iw4gUAIDkJEtaPQZQ/+kd4cEqAAGNh2pEzIgAwZQoj+XWRjoiNmLYh6pQRnI + AYSecTsjGnJ2Q4Td/75ap2jIwANuPKrSMAcBb24xHldsmVs5CVdEVcWBU0HMGY7SAbM6BQOZq44B/pFP + 7PU0e4iInAKO9s6zOiEHqtQPMaGmMDtKdT8hQABRRcqUUyVLkBaAhtryVzEiTpOQg7yQTyxA1r0uFlsl + HZElGRhX4B3vgcRJFDnvlrJ0smw5DngADG5YmsJFpZXTQyMgDNvKBDQAfqxtwwbUEoIPnARhkYWF1KY7 + ABJEAKC6OZYHXCcD/Y1WY16dVlFcc16yjU0ozXOuyB4BgUoSSpMPbKkE28r/MnFeUW9XGUNcUACBGOgg + s/oo6QPmZh3pLZjBCxaqKAOXwfdCoVIoQEAiKrEfVxQMsmUqzAgSgLoC68Oq4J0BCz4LzbQl0nagtR01 + LdRRRUJTGyGdcMgmqQAKrqyBLn1Z3nps3+NsIVHAawcoTWBBCFRAAoo1cA5gYAEVVNIAGgHslTnREfgk + BgIU0MFqb+yEDcDgAQ0QGOci04rpAiPNHwgBCRgQASWqjinJ8AAMmhE22hFxo6Cl8Xq3etpn2DjM18IB + C066FR9L0aX2LV5/U3pf4SjnBCtowQSC6xQbdEAGKfDmGe+pHR+B5QEvAHOhzXEjBpBgMLqgTCwykYAV + /5R6xOQ41g5iYF6w7rp2YeWYaaOJtgAuEdURCx8CUQazK2pSrlQ0jm3xO9fkhHIFECilUcuBgRxIgAUQ + SEEKGuCAFaBgAStwQAMiAIG8nrrYTtDLDFyggnGfgESUXoADqEQBD9R6HBmgaJ7h1FWO5k+I/etqwcsL + FEd+sd00Uos6HW3f/RZngbGNNvLE+VKuvEM5zKEZDCSsWRxs4EG59qwMYrADDtin4cawQTKS1cMHtIAF + FYjBC2CVAWxnGwfJsujtVIzwDK04tAaf5mmPqA2ktHxNEogAvYuMN0WXi4rlGpdxPKnoR1+9v4hSwAIg + cCU6N+XlqtJBDkLO9GOgRv8HHOCAKaPz3depmLympWYi17Zeo/9vThXYUPzUrhsOSPkvdOXkS/nr7CnS + 9razXSk53/H1+diM3+YJ/FIwgIGxmwpZL8g1r3f9az/r3ddfjWZsZOCNyl9eH31iAQq6UvFOQnC/kG9g + fane+EZDUB4WZIGpWR/873Xgaxiqe4bGq1H1DrKjdz8tNfTtZOE3xUYNiH0VXzb73PO4pXC9b+59PO1R + z/pOaZ/++Y9wgxxUVBsW4Pv+AB10rspu+YrEaFYbg/7o6EASht864rfOilbq/xSvAJMnZRpFBVzAFMxP + /4IvGV4Az5jpYkBL6A7O7kRrxuyPWfAu0LBB33bOAUn/bAYc4ASOA9LGiVyqTit2z8gS7/bmSuv6pitk + 7bcaUASZrueawf1obMXwpwcrhuDA6pDWhu/EC7hwUPCsIEe6YOrE4PDOaQW7b6X2a+KEx1sWxSvAgpQ6 + 4AaTMMzmp6IqAMW0CtiEMP4o8Bo20AN7kPT+zIeYjAM27wv1gWQQxytOUB5QJPz0cEVMxNlq6+qUTch0 + a9K0QAG6KAYAjw4nzAYAyaJa7P6A0M9ET9dGj8+G6AejgQUGbA4ZsRx0gAUcgAFIRNl4bwVNMbYmLuPE + APJiamXuBpRGJQak7xOPyhEloMUYSfTUEJEQTjYuMdDasOiUD+XcyxZLQwcowAVg/w+UpDCBFk2/BJEF + g+y2yKmcDLFbyOAMKoDYkJG1NEA1mInXBG3PeA3GJFGjPqrGXmBwvrE0bgAq/KLxpG4QkUfxVEa2+Ibq + zCWBVkYMFsACvPEdBcoGdoACUmwS+WxsWIzu9E4h886Z1KYCZGBDapEgy6FPLCDesmCcimcfVQQb+ZG/ + ZHBccC9FviU5SEABVKAbMTKbcPHENga9aCz5IhLQngUnTU9j1lEGJgDncCAEX9LWrsoCHKDxLO5QBMXq + MOlQxCVFmFKCCoXxxoAMTqAlvXAolQYDlKQngo7+zrCjfJG0fi1aYIy9NhF3ulAotbIcDNIKxo1E0oGT + UGT2dP+L644nKo/jGl/wHw+Ru9ryhDQgF5nPo8RSA+cP706PTsor0MqmIinAZrIyMHnOAyjgAUoQUNSp + Lm1LBWFGirpueKSOBVHRD2eQCxAABbqRLSlzTfxtAoIRf4hwJ5OPf/iO9F4Mo6CBAibAA3RAAzyxNZni + Bl6ABVRAxyAOplDm8P5RJKeQAKGyv+5GeVyAFoXzbbTtBbzSoxrSxWbHMIFNIX3NYoTCYxbxOktDAzyg + AlzgSRQgUbaIgcjF+/6wD5uSJFPwM09QOOohotBTZMJxNZRvAzXxLNuwFwcuiMxLz0AqBjyGAybzP4dz + zB5gARLFkpLDraZyNE2zGimOpWT/yx/LYHsk1F84IM9KiyxNTw0H1CYxisWEsf0oMuVkpET15AYkoAVU + gBSDI7auMTSBTB890gATaA+1gAFmIDhtNDcgIcWQrv7UK/mEaEBLayYrEgY+Zkn3JEBZIAVQIFG8wlv4 + 5tHuUyrJ9CmZskOvTlQeIEK1FPPSw7MYchKF8fSmVP5iBxhdwydfoANyYPXetDQodAG4Yjk9tNEsDint + 0fuYM0NdYCADdTeIcwyD0UBxsxeF0Cxl08VUzGM2QEkjdTcGky9WYAHkMj6f0NGmMU3PtOrqEnhCKQXK + KlSjAwckIKvkD1NLb+jM0Ad50jW6AefclFZz4zxegD2/VBuV/1L3wAnrVHGTKs4aNU63SMAEUgDkiDU3 + amADbvV+EHQNczMid7HXMPUn9MeHjqIdhzVbdyMHJgAC3LNQDSVluE5a7XNVV1U0l1ULQom5Mo1dMe+q + bsd/xFVsaLMsCTTGmCVsLJI1AfZ5cK3MgCP2kg3j+kbSXJGB6os43iGUVIACLvJhjeFYujVPb7Mwv7Ua + lC9OAK1sJqA3v0xkLScDOI0ZE8BHiOxEJk1n/6/HWPUKT9BjQVZmMW8DXgDoePX+LnUhmQ+9UuvmOIDd + iBZbThQz6a0fURKlCrCKyNQF1aFaG0ARp1YfauCqsgod7dQ2Y4erxjVtmskZIpMsQHVs1//kj6LsN+Dz + bvazWb9PWrU2BomDBhsAH+g2L241vZC2RYOQFxfXDGW0G3KucLVJByLBL9RpGrFI4n70Z/W1HaiiAbpL + csVBA471hxhyRYGOSmEjXJkFYzZEDkX3hMZsI3c0OIgMpngMTaUwBp/QcxPABRgudi/nWO/nTgtU4KrJ + tIQiMvv0U4X3hGwAPUpmUfyPXllqTH0McE+ElixAap83CtLjh5Q2ZX31iMzGTstGWOf2e/1lm2TABbCg + 3vRWVb+PEBsNptCEfY9BGWcyRpvWYAnpkCiAAsaiLPT3jbrGMh9gylCzPlNSAF21XEwkQ0epPA64Ebh1 + vJAvLNEQfaf/ARpSz0+994J15wZ2oAJUIEfm10z3ZlHRSQ+VR87+lYSj4AY6YFlew0Ublxi7s/1SL2Zp + OJtolgIgQAWwoEcXLYkD8AsYwAL2LYjdQAM6gAJMt+5W9gIvxu/i1h2hWIiVxDizwEe8DwZfMHARwAEm + AFC72AhOlAxP9weNLv7mJIRZbo2P6hEswEu5r2e3b4q2ABEhwITsWAr6BGwOM2UBeMW6Qa8GebFoNgZY + IAKwoCsCZR1I0zPp0kfOAGkaeQq2rScGlnE51f7CRrx6swM2YIQ7+YTOg9uOkl8nmDl7l2cS4FrXdZW5 + FVdr0v7856LSJjJ/c5VvLAMgwUnmZjOb/xOL9nApPzZkhfkItA0GxOv92PajKvIno/aZb6yVZaAFjpKC + AgVV/fDIXmQBqnOGtbkJEjjP9GyR9BTFfqg3szmdC009WWAF8tEkFdXrFqAFQpeepUAnlmVtQ5k89e08 + AdqRp7jb5O1q0+lFEJEBFkAF0OCR1jehi+CPlkECp7mUr8FBJeAFPGCeMRrVXs4yW+AK6I16zcABVAAC + ZkACSLqkpyADcIAD7mwCXMcnUG4CJGAH0M5hafqstq0CWsAFwo3cFiAFIOABcGemh7oNbFoHdsADIhCk + RVrl6jiqW86mOYCqlyGkO6AD3k6NuVoJNM8GMkADcEADbiADbOCiz/96rum6ru36rvE6r/V6r/m6r/36 + rwE7sAV7sAm7sA37sBE7sRV7sRm7sR37sSE7siV7sim7si37sjE7szV7szm7sz37s0E7tEVbZEuMGQSp + Qs7GGVKbIlW7tVn7tVc7tl1btmGbInlTAlBZrjF7rXEgVXTgVYD7t4U7uIl7uI27uJH7uJU7uce67TbA + rb/xWLSTBeJtAVCA3LA7u61bu697u727u8Gbu8X7u8c7vMmtAVyAE3fglin75ahaWShmKOSbtee7vun7 + vu07v/F7v/VbvglYpDtAVhhRumPAAiCgAeJyPt+zDORhwR28wSGcwSX8wSc8win8whucHlDg3Fr/IK/Y + +7Hdexki5INZAJ5N3IdOvMRRfMVVvMVT/MVZHMZdvMTLpht2AFZ0u9jUE94Q3LqhhN5OIMiBfMgRkciD + vMiR/MiV3MiZPMmb/MiL/LrJbQVeWgbcprNPg/hiILyKqJnK8MspMMwXdszBnMyBEW4H2EF3wHn1b9tE + 0QQVoMh/HErovM7t/M7xPM/1fM/xHAWiBEriPM5FKQXoA6Ene/0KXE7rJGlRNlfB89EZ/SsbyZFuI8ed + i5hloMz8PNCDnM6vmwGkPNRFfdRJvdRN/dRFHdTpXMgFXaIb4CgILLPVTwzBZjzBM9Ih3dFx3fhiTBpi + QKY1QKjfC3MWeN6i/6TTpUTV/dzP+bzZnf3Z63zZl/3HhTzINzwFnBize44n4JgSDTO0CDTXwd2d3VmH + eZIie9OZJ6yvKpTTQd3Pkx0FToDZPV3ZoYTZp93e793ep73f+T3a9f3Ok33VSRERHUAgLZuYd1DQ9o6X + w33XizDcazPoWBd/2PHDswkDdKACGmDI+/zO5Z3eQX3eowTeRV7kB/7HUd7k933l+X3eWf7PgzzJqlPd + DdsRl6R1W3fPzrzMfV7Mf57MWTZOKsBjzHqkcmAZV6DT653knT7kVX3k6R3fPX3eSX7arf7TSz7qVb7k + s57Zn57qpUTkDT7sML6vtW2ZEJfiy7VgX2xOef8Z7sud7R+e3Bvphy39jTKAIhYgSsxA6pWd6qce5u+d + 5Avf36Xk6rX+3bc+3/191R//6rseyJnDn4U9sI12AkFvl4mu299e3JPWJjnfZGVAAtD5xuwwopPd8Fl/ + 8PPd8Btf1SUf7On96SE/6wce6mkf9ll+2VndAWTg7PVa4wtctGRz9AsW9MCSbW/y6HhV4aw8708orUgk + 9+v93mOe5Wdf9kW+8W1/6+td8AEf8us866Me9kkEBVgAUhdbPWVAfFX2fJXW3ElraeP+jXs1QR33NaAB + CCQaHrFoPCKTyiWz6UzqKKmT6cSwnlBXBirL+H692us46+Viu1o1eDxGs8H/ci58TUeV7dvTKYGCwAw9 + DRIWGh4iJiouMi5h5EjIWMxUUM7IUFZqWlbKaG5WgH5yjmaainKSnqaGzlh6qlZSwnDYNN7iKmVMtDQw + KFjRfel5ZWmJ2REnv7mROYu1FbMZgwUH20GbKTBEzHRg5IaLj5OXj2t0TGBmhra2wr6DXo5iup+Oyr+z + f25iwqf+kwfLQoUYHjaYS1gIR4UUK/iEWWMmDp45zi5SG4YxjrAzaC5WvEhmzbFmIreoAJRBIcuWLl8u + giTjH6tLpgKiwtfv1c2arVzZy9dp6L1OqypQgKEDHMymOVo4WLCFzplmXYZRMykMZBs50u50bQZtZESN + /87EbkGRgoKgpm7fwk2IQYe6fDYDxprH8x/Om/x06jMaVOdRd+5kGLQVl2WHFBWxmD2TLaQVNZKVwalj + tmy1knL0bB2LFWuwFRYQLk6tejUhGzs85YwlUBVsn3rr4eMpiyhs3vd61rMknJIMCTdYl2s8lTOziG/I + eg2ZmWs0z2Q8YjvGOeNEydWAPciBfDx51hleVJgkMKhfdrp/t8sruB/RTax2xvsNC9YMCzHalnfLDg0o + sI0ZzE3khjF5TJfgMM99JUwyWJVklUbN6SHRFlW0IF6AH4LYUgYSWDCJbUPVN1ts9NFGX26GrQKPUPJR + UuJ/ITbigQMmKEBZHqJldP8WWdJtlBGDIo3VnDTdUTSVZXy0wAGOU1KJyw0SsHAfjITN515wX9pFz302 + /fQii/bg9kp6LMSAQ5WJeLBCAlUsB1oYW0GH5zMYKggWFxZ6lNmEE1L12FTAQCDlm4sy+sSVJaYyZpr5 + manXll2K+ZcrfMW4XmGWWECBm40SEiePe1jG4I/STQSdgmVIuGdZk3EU3RwVzgpZh6Ty2isRI/YHVIxH + qekely/OUyl7aOYWXGCCRcrmqL4yMSAW1mSYh51Z/RmdkUeKVdEbRkbkoKxK7sFFeNSy++Z5/QnFrKWm + kBnmmQBhCm07zV4q2yr+AdjuER24AOtWV22mUZC3cjv/q48jPafGuBZqq2cckJ3gwAwBC9zxeDZ4gNeM + W9JoFJj6VSqjcGHWVFtgnBTHscccsOBAF8EUCocYEZ5V1RzkPohnqxhu1NU1rd65xwIp3Oix0+PNFcNM + J7Y8Lyq9EcvyT2nuR8/V9rKCmAcrPV0EDhRE4MAvhTbHWUePefbVkYGygY3DEr4aa8XXMqBCCy+QXbbg + i0FCAU68HXtbfWMuzo+x8KVIpr+TapJUB4oJPuIDKvCxYDSx+qxVtkKCJY11hE7sNoVtuHFMFhFY0MHg + s8d1Qzq7jRw5yYRx7ddO9VKdE3suy0JJDDugNvsGMUyxTeqqlpvhZZ91JqR0RzLH//bqzEzfRQInuGAc + 7eM39UgkJrJnm+Ty5UsybmgqXix+d9lH3yQS6ID54K5BoEAVJvGsYdCQGILgtp25kcRh0NtZxcKQAAaw + QFHkm2BLbuCB9ODLar4jlsrksTIOZs1YyiIFfu43LdptYAYLAAb1EpjAqpzOaBx52NusEyEieQZcsOKD + AlRAgcBRMIjmiAJQ4iMKTLWnTCRU3HzyBZ8WSc4uabrEDoA4OxtIwAULQAEwpvGzq+TNJHXTClhyaJZB + fURQRIvYFU6wgBWwwANCnKM5NvACCrhCWLljnONcFkUOzs8fxXKWlz51GAlIkHzLc4EDTuC8biFDQoFi + Utwqif8tCDEIZ5PJmUe68wVgOOABQqAjKcWBAQ7cUXjAi4ddWua1Ew0mPpPyCYxmmRQdWJF2p5RBCn7R + uTQkLUkNE10Z/US6MU6ndGjpZBtNgAIXwCB5pZxmI2zAARiso4gabJzJBpM1xNEohJxy0XBkMAFc0vEF + LViAI+kkpEmCxjuRcZvp9vS8nBXtQHy42akcYIFEUjOgisjADmKQHoIUJRSekJE/9pWshiZLlqysQNd6 + 09B2YK03Ch0TcTxwwiBqrgEr0I417sTMol0nYXSzFT3vNqt0QYYLDkjBDHYg0JsyQgM7kAAF6jecPLbS + PjXJo/r0SFShEjVSuLOJsMz5Amn/zlGnMmCBYwpUhWuV9DKa7AiqigFTlAJTVpXBSBvbyYAFRIBN+cMp + WxNxAw54QB3BUtNC9yVRjFLUrgutq13zqlG++rWuFlVoKeAVgxfoQGZzhIQFGskjYEAEmNY5YMIYloxO + pu6LZMWq/9QyA4+2NbSJ2EBBgyUv+0B0N0pVHyFV69Nlsa8/FpDBU/VHTQ1c0AUqWMEWteC/zgEDsr8c + LmSFy8PjHre4vzSucoGb3M7h4Y0OaEALKNCB44g2u4bAQQdgQIEYGI4/SR0vectr3vOi97wz+e53kWfb + gGIABx6IgQUgIFIuJmBOczKBfvmr3/7u978m4O+AAUxgAQ/Y/78FXnB+GUxgBbyRuhaYwA4Uq90LOwIH + HNgpeNdkARaUCMQfDjGJR2xiEaO4xCk+sYpbPGIQswDEM6AABSisgw28F6cYsCMFWACB3UYXBVscspCL + TOTe9rbIQTYyk4/c5CA7OckraAAE/FNhDGPZEDbAgQ52OoGeBnYmgqWomMlc5jGLeSZkNrOa04xmNsPG + nDDwwA5wkEvRZiAHXtZoXwGL1zX7NdD78nOfCdtXhX73BR2wc5YbXYgMaAAHOeCADjpQ6Up3wNKavnSm + Od3pTYP605zGtKdBPepMb5oDHMCBBrDr6FfDOtaynjWta23rW+M617reNa977etfAzvYwv8eNrGLbexj + IzvZyl42s5vt7GdDO9rSnja1q23ta2M729reNre77e1vgzvc4h43uctt7nOjO93qXje72+3ud8M73vJ2 + NgbyvAFVd3oDOWD1neddCAzYIAOQZvUNBN5vfwsOHTCoQIwf4AIXVNl4L8ABUxBOiAxsQAce8MALJhCD + GEhAAnTmgAYqbnGnYeCtkWBBBFLQAJG+MQURgPgMYLBok588CRng8g5gAF48TmImMZiABHaQgxvgPOe9 + Mh8eWwABlztABQ5YAdVf/nIXPIAgtFA6Et66gxf4PLzFw2iN53zjg3N9SjeIggsa4ICpU33qb5e63Fcg + dxW4oALfSDv/D3BbF8AMj6JKcTXfp4QBdETix7xFAdXtPnW6230FUl8A5fH+WQvDe8fzlQSkhJUXE82Y + wiQvPI6sCQMfRwDyb5d71Ffv+NevXgUsGKXFT4lNbxpRNp0Y+gs4QHjSI0enFHhA3ecO99U/vvjJpzoK + /Ak4i9vRtLhHEbGCPoEOYB74MHnEHR2ugjdGnvVzVwH5oy518qMf7kJOgShz3G6ZzHV3fxQqQmvsgbNr + n3ATsEDqkZ98qUue+MGe64lf1FUAVLmbBpCIevRLA2rKJoCcDvxe/rGEDZBWDPRCVLwe3SWf8Z2f+XWg + 5EUeb7XA2MgbB/QY+rwH5VhKbBAEBUhA/wfgGAWyhPlUwANEQAMA4ONBXvktXw+2XtQ53ttR3dJYl/uh + Gw7sQI8xTgiNDKhcAmLAgNGhHQ0yQg5MwObwFtVxIOtxIN2Vn+QBYQAu35S5QAwAlLrZjlx9irM8y3sY + hiaUSAXQwgRa4SJoACoNXwpEBeO5XvoB4G4JYgcS4QcGIew1wAO8wLttwO054StBom1ACgx2QA5U4R0+ + QQ7AgAW0ndsd3xD+oQcWYij2IBnW3dJMwLt1AB45zgg51PTNiyXQ2AQcBBJiIhNogA6cnkg1HgEGIvKZ + YjD6IBkGYvjxlgrIwCWGGwbsgGy5lpqwSBNSyuIQB2KV3C0OAm7hkf997aAxtl4gGmIQfiPy/aLqESEK + qMAMfBS6nQfDaVMrJgtASM5+0IZ+JIWiURw24iKJpMBuDWH4FWAY/qIwPp7jjWFBLoADRFC73cALSALV + tFbuzQg9jgxivEAO2KIVblkH0FfqbeEoDuQgBqEggqMoHqTxHSMLVBG7bYAEYJAUqQgUOSA8AgXRLZoy + kp42toDLdSEwEqHxjSIPxt4PFmQ3/p/NKKQHZB+47djCsUArLsv8aE08ws9fJEUt3mJ8ScAMMJKQ2d0H + ciEI/mLriWEokmMAgqEXvt4CqIAiLuW3NeVDgk0tSQoS5RVFPdGHiY0lauQ1MZwL8CE5pmUIAqH//5Vl + AJqiYZbjbiVkC0jAOpYb970kOO1EB3GJBj3R2Enh/b2lv1nQDDjEP6YfSI5jSAqhD35gWoqgD4qj1DWf + IkImudVASwLVH7WWE0Jk8BjGJFDAxCXdyWWADmxlBAyZQfqfObJeWZplchZjOBblafJWKHmAHcpmI8pl + LcVSXnwJynDTUFlA1lGAB4ye0uXi/kGAR3qhDqJf+QmkOM6dcoIgOQLjWI4fEbLlA6zkuuEAeqigmcSG + ZerGRCbUcBQEDPRebL6bBqCH4gFk8QHkBpYjWgblcyImahYlWLLlDKThuVmQO75Ms8gjfjROgKqCNFYA + hW3Ab66bBc6X972R/3S5p2ICZWv+YTmOozhKqHHaJzJ2Jlx6QPz9J2DAUj0aURN93qbY5AZQ57nZQBTg + IGt6owg+J1FG3g6O5A9+ZZWSZSgiJlqlort1AMMd0W3AkqbMkh+hAv3wkQxYDoKO246tYi/04gAeJwFe + qRiqJn1eaXxW6Cg2nuzJkbtxgEG5h9XkhyBBC17wR+4kzk9sis3l47llAAdMwAy0QA76o1AW4mpqaZ8K + IxkSI6iKpISOKtylhAzoQIJ2nBvKj79IZRSBqCp9whQhGi0mVrllQAfIQC+An/8tp3wSoygGK1CKKko6 + 53uyXgPIwHS+2yN4ACtm0B71BdaoEkXCYTid6P8OLGm2TapD7iRv9Wrc5WjdPSghSmjsrSZZgmVPUigA + 2l349Ki4NWkMNFVRXCu/aAmJYmfVgMIkUlgOxOuzYSELAKYn/iNQfuGNJqamZmlqHiUhlqRqFuIDpKq8 + KeADimi0jqiL2EOI6otPFRGbRuC2RpvtYOD3hR8HNmhBOmgpsmZpEqZgIuswEmHkNR/7wQBORiZdZBMs + yhItQRG+dBM8Cs9ujJjNBeyx5WpPZaB0ieYhiiR7FuYfSmlQfiqX+ukO4sEKQMAEIOC7rV2lQkpAdA3k + rIz8JeqQ4p4plMhsTYCipSi1ZYAH8J8OEutXmuZP1t35nV+fruuNDuJgKmz/wo7UWnwtvBEUE8oIisgq + snjNmL5SX7zhoB3W4S5bI4Lm4r2RUQallfIt1CLsfJrlwp6ruZpqCkAABWyoxXYXmLVq5Eyr/NzLKyoL + sqzDJIQK/uhssG0ABVyq5/oqQQpiWa5n8RJlD5bklKbrbhVk46WABcAAyWYej9XmOhgRIaGpvsBqpNxm + ow4VRdGi9AobDsAABIhrIZLfnwIiabJnaRpiSCZs6Mbn/wliA8gc9CYtu+VAxxnOM6pMcKxgHD5O2XaJ + osokqLBJLTAbFm4O44GirzrsqEYwzA5lzEppqCIv3EVYC8zAOYnvvOViXHFeXereB82lNGrsxspWcShw + /7JhQPnaLdVa6cGCqt4WoOim64ymZeCa3z9S3gq4AAVcGQ0qodgWEdiwqrwA8OI+LlW+Kk7IwNYlWwqJ + VOytp/mNJigOYKcqn0kK4ZSeJQFyoQpEQJXRwu5aXC6CndSo1vvM37xQDoxkEL1w7BHhw7JmZK9ZUAt8 + JCB+bhca4/AK7rr26cNuKg+PoJDhXQVcZB6T3g1swHxVQtCVSR9Brm3Uhhv2kcci0Sy4aa8RVAWkja+S + srr2bU8Wcn3mKSmWMsRGwAPIwOXo4xFwl3fFo8hkSguqqe7wETwSj3AYhOX2Gg5MAIMeL7GG4XwSZA5P + 6Hu6rN8+ngtY2QzO8hFAsv8OrOrZ6nKmuKJdDssT70YUrxWx6YAFBOZXzuhqJqxI7i1rAmF7nmv7gqGU + LvIQbx+k3YANqKijpZzA7bM5WGAqFWm+ps8bnmnaQqLjIsUL5K+seQAEFCA0E+77nmuxpuZEb6lBxp0K + oC4s56dLHF4OdMAO7ECmAWwG/HN2pdy9cQDA5nNKmxJ3vQB49ewKegle9o4AU9//Jo54TZiHCJsNTEAE + iKs743A4lu5hQikhCyZYNl5CukDN3WoFbZgEfJksjO1mjmd2YVymcZwEwMAEwIAEvMDGlfSqOTIudCuh + HnG9wKTjvq7HyvUnhMrq8poGMI90leKUquxRVmn8Bmv/Mi9v515dBSjlSyhoj52nzEVAyzl2Y2MdbQnz + NAVnJLwkUFCrQfClS7Boh8kCTYjoevDypWSsN/UHqsL0reVABTSAH54mzFZo+5Iquh4nYmJxFsPdMUYA + B8fAorlEnt0RwaonR9tvcZNfCrAfI2+1QO2cHsbYc+MuiYFYQcBtWjfC4cGVz2G1NqEpNAbPNm9zpYTK + Dlj3rNXAajcAjNrphOat3pJqDgc26I4UWs2ABFBzS2DuA0CAC7Qccsvcf/t3A7QcxD1ABy+FQOnUl3mC + iaiHCRMHjR1PQyeCDeTAfMmWdzcxCXFsAKMMmU6yDHz0r81FBaCsM9voayOzWKqs/yGKqtRasf1CwLJ+ + sjhQ6gNY3csxdmMPuI4ztn+nQHWNMynFV1wB1aGFEG8e9ktonjqoGTkdTrRyNyziMqgs6wfT2oi3tpai + K32m8sGW6vLVaW6TcahcJBozAvlyosv5d3//N487tszZbwq4AAscoZBXOBt7nja/DFAdj5VbiUhrd216 + ymjD5L2S6Gkza7CdEmhubtamc/t68RcS7zg+qOMJOAs8lVuADA6+eae/eZuDeo67gAwAtRDRZgi50j5M + st6ltji81UzvK13CVmr1NGylR5UL23nPQHrrKCovNXQOYmwf8t2N4Ns1QFRTmJ+r9Q40hAoIeGODeqdH + O3I3dv9xt4DXzlFDThWkOFSqd2wlPAALTABGusWOaZyCG5WUs5LZUso+CMdshfivMUQKNLqn/q266jDD + QrrKRqfsnZOELwLIVMBO4ri0GzyA6zibd/QEzLjHrOFB9Wd/fnfQSUCpb18u3h4Drsg88iscPuGMybKw + ZYAUNPr7frFZql4XTi0pkt/V/XRcbEAF8LeaH3zN53iPO7YiBhEW1oPEf7cHKdTzwYXKSY31GqoTJxHs + FpLkhErFDhsMEGcN53BqbiC+szOwC2HcpQAL0JbvxcV5tICzTztg2vxjk32b413TjA9BEZK7P47WFM8E + 2HVLhHTPUcCHNdVU2roKB0WoWDz/sHmAC0DojSqvURNmRVvp1tNCeY8DhRdzwZs9tJc9ZD92ywk4qU/Q + xTY43Duge8yWb6eGwl22a0ViQndKbsxADEy2rpUzH8ad6M7z+7r4A7/enx57C1SAfbe6OeAAiSj8zFE+ + fws/8PM38O948SP3y1lAvJfNKRmxRJ4wyxDEOZn5OHSrx/WUoL/xlBOpUvWmstOaBsCAjXfqr3ej1K74 + uG4hdQnxfccFyHAlzee48Sd8whf/zN0/2ce5uB84EPCEQ2LReEQmlUsmceORzSyzSmUmq1Kt2e1V691i + Z+MKLIdpptVH26YDi06p3223DraKuXPrWCbhQFsbJCw0PETE/9CJcXFYcVRRcYB0kJy0XImUxNycvKRM + YZngQCw12oiBaGiISEmJaHWJkJVNcXGxhc3dxa11jYCYkcgwLTZm04EboxLjc87CutvLmmGpeCE+Ls3I + kaCIfp7TwxN/hqayqIjR0dB2f4cntNl5cFh4dPyEzKTc9J98FBDFihUNXLCg4OFMPEIYdlhIoWJXLF20 + ZMGyOAuWRl2tGqSA8IBCO4ZCMNi4oWEDDg0abAgqmeHFN2l2uOSxQ6cPGSkWRpWUt0HHiwkyovC0qaWL + HpxI0QkjCVTqVG04KqQIWMlTpk4AK2mKRCngAhQLVLSQsSMq1SUYOMRoserVXIyzLlLEm/8rb6tXs2bg + KKkhR4cXMChUoBBDwosOOda+uwFj2p1xeZxFSdrFggUZHh6zTYIBR4eiPZWW61PZcpWcMyjsAB1b9iAP + EFUEvB3WE6Xd+gI+kgjBAoxAs5XgmPCg1sa+r2jFosVLY/TlrlxZyBHvBgcPyh7EgsCC84QXHG7E0zBh + 82U6V3DWqWmOzOtsxpFoGDqBwmGeTG9+AWe1K2J4ATD7DkSQhxtqU2EgfSrh5x9+PLlthQXMaqECCTow + MMEidJgBAr5aGfGijPC6C0W7dEmhgRayc0cD0mLAwoIHWoAAAhdaeOABa2SYAIYdOjwGOZ74yCynpVa7 + CRoYiPTQJA3/ONihtGXucK+9JeNAyAMoowRTqhskgICg3SbM7aveIrwEAhk6qC9MHjKQIK5f7iQRuopS + nMWWWvh8RRIISDlGtBdmuJGFHnmEoAVHHfWRhZCu0QCmYnCQYbNpwklKDMwoa40CHSyVE4cqKUCSDMq0 + dMaCGGCUM1agNqCghQgk4ScTNLXK6hJW0ALEBll5sIEDGSJw4KOO+jrxlo2ou8vEiSKBQIdjbsjBg1pd + COnRHBlt9FFYginvPGM2kIGFL1L11D1pdMoSmgossOaFz8LEbwfDrJDjsk3rkIGCCToQdliD4Vlwhggs + vOceFRzGrUKCCoLgmi/lXMS2vpalyFm9/6SraM+OGlDhAUJN2UCCCSpQVMdvH330xgdy3NFHxF7YwBgc + YlhPyXe7kM+LOa6UYoYJhjyYB9F24Fm8ZVg9aowpYvAyaavdyWCHCmyNSJN8IlZBrhTQ2sFcgyNTjq+J + fkkxWhM5+vNtXK47GREcDr0x3Bt55FtmHCH1ttEZ7C1GAwrEU1LLJU9jbejWKgByB1JjXZpGow5ryj2j + sEhMyIuvBt2QDDh4IYatPQIIn7AbEE4dheIcNocKIlAWo4voeo4ikHNxVve5XKgA1kNu2KHWHMOFtNG9 + Z/abbxy5zbBsU9I7Ej5yfvbi06GdKboMsw/OYAMqVTYK8isD7pwx8/9CZ//aZCq40YUGCJJoFs4kyAH2 + s19gYSP/6/If73LXO48961muCMlItkEaC+iobzJbVAQlyKMezSw8MIBTKWzgAdMlrjLy0V5mtDSBDUzO + YBhwA1H0U6OABUkhNzBh+2RYCBTuwAPk01QLPcCO0GWgAzIQEe84Egshoqg5vdDI7kAyOP0NQgcUsACO + ugVBwFGxghR0ngseYLS60ZAD3lAV4wAEBnYJ6F9WeM3nhoUBweRABx3YwQs8sAMd5CAHOGjiDPVoiJOk + BAcsuUEGYNi+tzzATxURYBJPdEhnua0uuPiIKLpICDqx4G8UlOAVJ6jJRUGKBRIo2CE0wLQ+UOP/ZzlR + jeLaAyTP6BEDJ3lJDPc4S1qa4gXf8V8jQ1YXZg3xf0hkDiRTUAEPfK8Qhrvk3vr2wERZcVGWtGALYqDG + NBRLAkg5R+Iax5r4nJIKZqhlOMU5zkPggALyc8WfnsWn5+iFOniBji0i0oDglQIDHZjBLZiJRb8pipN8 + UxSjbjGDDCJCJt3zw6rkxT2fyYdf1wglOSU6UYpmwAMKk8gio6UXI0qLgBz1SAomYExC3M0C0PPbMyvo + T4AmqgUB7WSOLCCBDdSgFD9MB7y090FwhDBeObHGBBZCUaIWdZY2+OF3emk73UELbh0L5nSsE4EHvGCB + PPtbSpfZzCv6k6t8/8sRC2JQ0EPkYGVP61Q4MOOu7L1LD9Z4zb2MOle6ygoVQcxTn+QWraj6cjrBbJEL + hpMzRJi1Gsvjp0qf+dJ+RtB5Ly0DYQ+RAR0URVNNwd5/rLeHte5kBjHYQR7rOlrSzgYDHnhAJELGUdZ6 + 9HbUkc7tUvCAn5TCWDZi1ANbmiiWepWxPtKqBSggPEMQD4phROVkUsUe681hCjCQbGmlO122IAcClchT + 7w6pJ+6uiJEc4d1HLOCBiBoCRMrcajN/+1VLBhSaiN1iB4rBgQk4JbP/WaunmrsHG1GAYNQFcIDhcVD5 + KYujvRvidvUKwFwmGALDLYYHJKU85e0WuDyCaf8FNfzSZeKIBR4oxg1mAi/MDi0KPvVgUqyBP1kK2MUv + ZgI+RfSRjcETiblbMC/fyQvgkTfCytEbpLrao966FJrr7VtYQTxfyQAorf5xcjetlw4CyRXGV8byEDIA + A0OqDap6fW1fkTgR3fGFBQUyxi1Rys/fchi4RF5vSpeXowcs2RQ36ACqprCqdp3RX8w1pahanGVCB5hW + Xq5xjv/aXbjNBU+tUIELZFCcCLOgZol1r0sX61hFtdexB7GzKXAgGXXJy9TJFQdmu8kHwhXa1TBeEAvC + 1hwithOYCnanozn2iwdIYNBr4B+3MsnMITO2zb71W3hCbYo8E21xQfvgv+L/tYyjkfTV1x6tQyigConU + eICN5qtTSeTodCJEvsdALUoV615HFRmLMGUzjqqqjRwQBUkB4iYZa4LqzkqNAoD4NbYFPk5zKnXcCW4b + AMecOzzNZRVuUos2+EdnY7f33YpNLJKPDGptjO4FmdqzFtb6022yhylIqgMFsDFwlhv1nhYYEV3AjBF5 + LtyARSR311ogAWoWIt1TjHPF5Sx0mb3XUcp2hw2eSK9VSjvVeNDmaagg1JZXfaIbmMDc6MIs1z7VownO + 6ytWMYNJ2tLSmOS0eoms3gxzGN4hWXaIr+m4bTYUxSh/RjPSIlqr9z10GzgUOg+eFz79EqSH3LpHXBAD + /ysf4ucAZSy7L8zVCbJUZjr68Ds2GLXFmTpVlukzW3eSBwzy3e+nX+MLKgCBFm3dOY+k+Ts3imDXA2O8 + AR/ExLvVW7SzvbFrjzfS36EDMKoKVJzarCqVlJhRod75V9OADND5aGZJJ7ZNvYs8Bz84a5vi55nkdO8x + 3Mn3alrecS9GsSQjB86qFUvx6ff7YdD459f/QA75Dit+OaKbPyduK9ITi2gRgyCheAg2IXOzNzO2r6I8 + t/Mbjhuw4mE/86m7x+EUEMqcV7G/DQQTDDCrFmi9pRq3G2On/2EqA1KbOmOI79O48WszKso0TQKrzIsH + VMCmJNEJVZs2yPE814g4Dv8EQvvAAQk4qaliLXj6GI+BrTCTp19Ai+hyB91bLMkTOqL7vcuDwAHTFqDZ + lBNbpTGKOs6aAB0wvSA0w3fYgXzyNpGRG+4KM0VapCUqphUEMrTrPWd6wWPjsKOjwRqEg54BNM5qKOvp + rKWgqTNERKnIgAlQhV8IIFw4oLeJKl1SMOZ4hZnquVI4QCPrp4vLwyJTQMxDv2MolvrSKWlbCpRbktaQ + gjfBvUSERSe6irCBqrdpLUXrq9jrk1mYNKBALYpLu91qO3fTKg8bxWPQACg4vlTUL3cxJdRINX5Zse6L + xWocBBSCAZhzRESqRQD0v+9yKkfcuTLURCBTLMrjxGP/U6lOOzrhY4h7Mh1o9DzNMj6oEyN++SwytMZ9 + NAQNeIEGMkKLwDHCU5FaYzASQYtzKwkJ2xE28xHIGzIGdKxOykKGMJV43KwwXJeTQ8UxoADi4MeQXANj + yT4Dmr3X+ra/UqddMIi0oMZjkEJ1bEDJU7vIuzx3fEfAmxdAK6Ms4alyiLbOeEmRJMoNYgG5OLjEIyBf + sj5JlKqzkAD6MwbUioAqWsDGssNMq8LnGS+q4IDD+bymYxURoseiwR+iRMsjcItambXBS0Ik7IWMKEmQ + 8ouyg4dgCwmVaqkEdMCMQzY6O8YYgQH7+rNSUr4LfCvhkp60ZEweQAVLQ8qtW8mP/7qFwlswJeyFB2A8 + qvjFCvOqc9RLvXQ3R6nImCgeVMOvTknFxom/zQASfWxMtKwNX0jKR7TNSRQiEmy9B+iM8mKITVxAviw6 + TAq6zwSXPpSKeouBehxEEiuxEOLCPyCu2LRGDWAEA0s8GztBW1TCg4yIFJiBquFMc0w79iK6vlQv0kRO + oHALUkM+vCsln2lOf/Mx6txH4sGohhMZIxIzvnInXTAICshEiZuwdlO79zI6rVzHCFIy0JAJ+CnMLHk6 + m4hPfQOaKeA5+7RGt+CZFqlN5gBAcMwx7Ru3O5mtF3jFHxM2CGLRoQO/T/SW9ZQKHciUz2OSU0Q+eqyC + dEiIAf/VUOfbAC5jPRozwY44QSICIMSLubnRIhmAQqkAzrZLx9EsTyyCu9gQsW9YBv1azQvcgzA6OWYY + q6H8UecDEb5ghW28NcpMUhxLvN2sgP8Cjc7svRhUR5mUUlGUjQ2oEilIPoXiSXCwx/KhF1Ep0zPEADJx + gBpzDsQzEafExeoo0Qj4JDJ9BzUDOqwERQmCN3jjw8BkCMMSS45cqGwiMbZClLQ4VDPMgXOqn3ALIIK8 + MUSSVF2rALv0xbOLSNGsUvaiIpxki4QJuZ6K0NXsPIaqhs4gx1VlOX+sAPlpMNt8PVuD1ejIk774JN+c + Ct3bS0/jJN8rNngrTapQhJVZxWX/dMa0CsP7mU5mPb23gMzfCcAkYrDsm8xdswXNbNepoEoLm8J1fDe3 + C868UcHZwLPB3DPDvNGjUE2NJIOBsVR3xbakoh3csdeQaaRE0iXfUbw41dZttbS8hDxku0qZ1LAHlFG2 + cNZhVS5u6lKH3VHEyFCJRT0M+Me5yavpkJbbVCeMTcqxgYFlhQc6XTutwrhO7cQjM0b7cAiGHYcP6g9V + ij+6AxJcpVmBswFG1DUheks/4U6fLbNfsACFnA281CqvosLPjMENI1irEkJvoNAycquOhD8PSNGrvbIM + oADa4ZjtXI42NUldFLt81UD7SDcE5D10hMiu2qoWGFcHJQ2E/zJWh3KojHwaFMXbvrsBGUiBRR3BRqNV + /xvRb5snaWo++4jJcJXBN/vXmlzaAxklkEONVbye2WWrZtyMF/jYzH21G6AAkqE1n61E7DvBj2kRFWCB + Drjbd6BKoCNG9MQwk022gj2QUavHncI7Lp3Q2t0MUOLdqrOKVSgza6U9uRRd8+ULF1AgBDlA4jQ61l27 + 8gvOgFJPUJ2K09rJdL1d1GzYdaEX7/3eZuXc2qE5EO2uA1u0b+QWC8BcBDlcThTNxb1CBbSglJWNympG + HnRZn0yuEruDKWjgABa4G9DazzXIIWLChEuRJYIuD5HCky3ODbPTdKxfD0nG0mBNoFy1qf/dFM6ADREe + uC1zXMIDGb36T3KzC19QAQiIAQ7Y3TmtQ007W03lVU1qUA/BASjYs2jQYA9mnHnUnCqQAWsBYoFziNW7 + 1sIDJgUeX5ojmToTWqCI0ipeKSvKsOHcG8GyX7b4ylLzws7LHGpohi6s2jIeuByIAUtbKl7YnXai1SR6 + hXqKEqIF18X1NMTVy6Oj3gTRgMFkBlPjYpITvYU6ChkgEB815AAzqYp1xOv7P9i7nREJDwmI2G01xzv1 + vWPz1vFbFD2Nknn4hoQ11ZPrKTAOg2BJZWzzQOkzsCLdpUd+KrGjVKoDE4Ykzoi8U+O8ZPp93Si54f54 + D887sTBoCs7/UzmpTGYXW0SuuZNeSKSZO98RWeIxXt6S4NZK3lQ2+0wr1mM5AbxMEef9zWFBHJqxSueB + m01GnT1Gq73l2LlaHs+qhEErMjZP7NSK7mYwabZ8C+VyVgqcINUmPmiBQ2SYq9iLdVNH3gXnaAFDlROz + Hba1Dc2J5mcLPhDAi8dp4+L3aKvmSocJaKWRvjal27aIWK0Ufi1aCxSIi+Px/Ba1C02Tld+H3Btg9RAU + mgn4aL9TK+cdFasfFOprcwiIINLWyk5JDakze2LUDdlc1ubhlN9tFiibRhBRNTExljYsENRqGA50Dmt1 + lgBJwVm22TWOdY4L8mvZeGAWxaK+tNN9/yZOx6XrAylF/nAccLbdOzDovx444pEBQ6KxVk5K2Wo9skls + 2bhnxmbdjGO7a34pHdlkOVE/VKme0wiQpxkDxciBtebsK1OEEJE5JH3TjRGs0DqYfs1lCD5P3mu7x+1A + DlCG/FXY7bEDGcCZeu5t6soaKLI0tWk9GiPSWWiBK4jKpIHp5QZNX604b4ntWCkWD1ghtMJtxzFlCfCA + Espuq7sB4judAYwEklmdjwiGgdkA3k4QStbnmqzJqb4iq5YVG8gBfYGizaDwCl+Pf+sA/M7vvvNALbYk + muEWlGKBP4BNqzHbKnxrqo7h5pE3t70aN5CAGPiGb7icGY8B8tABVP/e8ELjhg7oDv3Yj8SIARhQH5cI + nQe+w9+zMPSUoCu+Ggy4ARzIAQ54IxvygBegIx3ggDsy8B0fOBvQgD/agJXQgAzAbvYtUItTcxQ/R/dV + pvBwcRmC8hsIJDP38jsvBeTOypNlbHgrNpTdYzwXdKOCaaxMqUsuWoFVKV8e9EaXLqKNPDfnpyNDR6qe + Ged29EynKDVLrymFakTfy/hpb00ndYm6JWCIGQPl8wi6Y5k8Oi2K81KX9XF6PEN3MybXOBlk9Fnn9VrC + J8DB5GayPDgzTxawJEghqF5Xdlqi0eWBYbZdbxmEbCIb42W39hl6C9xKLwfcZ05kN/pVl9q69nH/v5oF + ORwhe0gFHVkYNk5HEa45JPd4T5ogbSC9mel0Z1zXlaKZelJ593cwQSqFuTTxk0hhVzsdcQGC6vJ/Z3jQ + yAEgqrDfa3Vkm8i/oYB+b/iMN470SKZ0X6bHvnWW+hYYgGiNN/l4wKmsUsdt5vOKbhSEIOOTl/nZSMZE + pjMIGsZOlGIPA62Sn/mfLwbAC5EdQZ5rruM2e/WKaTWgZ3qqoPfnycr08qeWgZ5Pwvimx3p3cIvSmBkp + wmh2gxkeGY99zfqy1wahyEaEP7pURy+XyRAMunqzl/v0ywEYKFCYmchwkSnoWvi59/trBDyaOKzneRlr + GJD7/vvEjwdu2IEYoYcf5aCFB5gCDMeBvlf8y1cDbiA+GpECdQESxhgqzBd9rfejDbCjlQikMx/91Wf9 + 1nf914f92Jf92af92rf928f93Nf93ef93vf93wf+4Bf+4Sf+4jf+40f+5Ff+5Wf+5nf+54f+6Jf+6af+ + 6rf+68f+7Nf+7ef+7vf+7wf/8Bf/8Sf/8jf/80f/9Ff/9Wf/9nf/94f/+Jf/+af/+rf/7w0CACH5BAkF + ADwALAAAAADyAfIBAAb/QJ5wSCwaj8ikcslsOp/QqHRKrVqv2Kx2y+16v+CweEwum8/otHrNbrvf8Lh8 + Tq/b7/i8fs/v+/+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+w + sbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs + 7e7v8PHy8/T19vf4+fr7/P3+/wADChxIsKDBgwgTKuSGAQeHDi8mxKBAIcYEDx044MCwsKOiDB4qtGiA + wkQCEghKKFiQooWMDhk8yhx0o0OMBypQJDgQgsAA/xAhChxIgKLBgwk6Ys5cumdDDAgLFJRAMMJAiJ4E + gooYkfLECggUNjAdWweDDgoOSIgoIKJt2wIh2hp4u1YEAhUydJDd+wbHhAcrShQgkLWAYbki5hoOSrhA + CQdHcfCdjAZHBQcmECjW6rbzWsNw2do14UCGWMqow2SIsYIE3LieC8w1IFt059dCV0ywkbo3lxswIggu + nHi2aNuziyseHKJEBBhKfUungkEChBMjQIuebaC798Tg54a/euAEBAkcp6uHkoPFCbWc69bVzra+fLdw + RZRncXq9/yUerEDbYd8l11lyCIKXGFwGrODBfxAioUEFJoBAgG1ybRceYuGxRf9bXYSZUEF/EUZogwcQ + lEAACHKJp6CB4n0oo2wLElYCBC9EV+J/OVSgAgJX0diheEIKKeOBbF11VwU57BjhCy5gd9iCVFKJoIcv + VglXeRFI4CSEEzigWXxW0jijlRnGVsAIJawQw5f/VaDACPMZF+Nbd77oIY21sTXCCRXAuR4GLQC5HYYu + xoglmlV+1pYJFgiqHgYQjJBVonoOCZ6QWX4IWgksSDodBi6MMEBc3a1F25GNdsppfXARQMID6Ymamg0Q + GHBqozN+uGFtVSYoQgggHAABb7amRqqpIWCqIGJEKhqskcSOAIGOyfJFqgEWGsdnplei6ets1R6brTM1 + YKD/bq2C4Motqge65auqdeV5JJEDWIvtHxjYkMG/7J7Lhw0b6NBBBzvsoIMOG+zLx7anElnmhqwmiuWq + wxbrArL8aqCDBy9IIPILO3Bwg8B4ZMDBCzJY8IALEEQQgQswQ8BCBTB0IFkfy0YcbJoY26uhZ1bla24f + OXgQAwsQNKCCAytErYIKLVkQgwc7owyHBi9Y0AADJphUwtglJFBC2CdABkPWerhr4bR5Ag2sxakqNoCx + DtvRYwQMHFDVW9sZwNUCEMRAotZq2MDBBCysYEJV3CHYXQkouBBDByfrsS1Q0nIIY7wUL1rAAAYcnQcO + HszggGAfCOB6667HLgDpCqQg/8MOeSMuxgYUpLACAwkg4LffVY1Q/PAkqLRCChbolcfmBBiHGJ8YL6jo + vIqWy7EdGKCo0wEFgDDAB+SXb/4Hux5gwgozNKm7GTigVQIJJBxwAP3153///fTbfz8CC7CA++7gNlTZ + Z1Musp7nWnSxtRgtd2+wwQ4KNRgQWPCCK8qghS74EwsVAFCHe98XOOAjBRxAcCPoH/5WuEK/dWcECXCA + BToQMDlAL4H3MtOhsnQxDxHrABu7Qwasc4LRCQB9PyHMBjVImAE4cXykYwALdiDCMODAAiiYygj8xz/h + 7U9/9bPfFv93ghZ04A6ba9bPOLUhcP3Mgdba3hxe0AAEiP/AJz9x4hL3uKINbnAAF7pRCKuIhQxMYAEH + 2MoW9ec/MH7RfvXb4lZQMCI74IpZbuxQmiZ2p9msSF96ewACQDA7DJrSQkkEpAX7KD5SgsAEMtAAIbeg + ARi4YE4GgGQjHclLFuYyASowXFlKdSk0zU2HdlrgjH4YRDrkYAYnEAH5krhKVPrRJ6uk5ooGMLsGyYBt + s6yCB1zAgBKIsYW8FF791MnOMJ4tAhMoS6VAYBgcbpIu9tyU54hVOjm+AQMUYIABfPKBVWrwmtRE6AUL + KisHeCmcVrCBDFDgt/7x75EWxehF1xnGEzyAA3RYFmGgtSeSXs96DSRX9EwXBx2kwFT/4ksoNq3JxFRW + s4+ABBUEIbqEHDxAAbncny57idH84Q+SXGnABHaKBlIdYABYKqn07EWXTC0oBEbzZxs0QAEUFAB91ewg + K7dpyj5i0ycE/cABGnBGnkqhlg0owVZUyD+jqpCF/1vnRVOIgha8QKtrWBZQNCmtVS0qQfdKDDMBqwZD + piABrjyrKpeozTzyMZXcDAEKKABOty4BAzuwwAJIIDijbjSMR0WtOlHyyBQSxQKDDGylLsSpqRJNqvaJ + 2+hA2VIXJEAEUAzrHyXbygzalJWtC4EJWrCDGnoWCTeIQQNOQJWLDnWjQ0WtdvEnPK444AU2LNVgpafM + Minmc+MB/0Ec5TABBeBRrNb0I035WM34CiAEB1hABWT5XCZoYAYLmB8kvfhIjYLRqAQOY1UYsN84OBWq + wTpTbpGEJwW+5YFx4EALDgDW4p7SuArNph/zCMgCmOABA+xvEnDgngRjl5EwfqQX8Wo8E7hAAvx1g0iD + Qt57YWpcjPJksVjKBt45wACtiy9ZzSrTyjLZgmIdQQqcp+Ik5CBF2C2wabf8P0jST3gEPgACUAABGMCB + UtxaFLhKWhsDuQqO1/pnDNJCLLE2eabEnamIL7jKDxBgBW2tMhI4kALN1PWoXHRkgevqZV1uEQFSzDEb + dkzYw9LLM5zEkvb6kqI7JlSPej7oWf+zaVZUAtKyC6CioJHQARXMhdEbTaGBD21XMCPPbwiY8j9d8FQC + 7Ymq4TFskDeFYTd4wKtIxCA1VYnn+jJZspYlgJ9REOhVF6HVxuviaXm5aNay9otHneQEOttU8aoR03jC + LbTkZSS4aIyxZciBBRDQuoLG19nHlSmft3lQEBR0AQ+ythF00ICK1prWdmUhahvtyFyaoMyZk62lUBU0 + 2QD7vFG116bZED8HmKqUaFWys0XMbwuV+poCIADABW4EDghnkd9O7aH3p04xz1zhkTwA5czYhh1jb270 + AjoClYlVvLXhBcIBLkPLCuWx5rvUY/2jv1WuapYPIQctMMGB72r/0S9/ccZhZKeBU+IACji3DCIlQKXl + RTGgacpTWWWDDeTk7lZKnbLDTWh97dxKJ/pEBCqgstV5wGIGIGC1Nv92zXfZ6Bd3+dv2UwCKJ50rerY7 + dNOyqjGLrQaXPlWPI2/2vfcY3yb/BL8RAOnghXADGWDGi2AHt7f7h3iuCzW1dCpBMMlNBko7C8huB3IO + N56GDciAASE44nFpynfS59mmeoyYCfizeiHYQALkNDR3YW3a2ot99uA+pwLOc3YxONXyCgJ6MoOvIRn1 + pJ+NnbOlwErcfaMSxPOVesjx+AH8BjPiq0dCK2BHekV7j3d7ByZU2oZOZMQCvGd+5rZ+nXMm/yjVY4oV + d2nAAS6AAHhkfxmEVh00XyF3aniHXPcledW2et3jWzDndbI3e6mlcDNmP4iXSAjQAOCVBpQycc/iImrG + dhyiQD6IgWeAATHAANJmdzYFZfQlXyPHdAQlAAWwAtBRfUSgAQ9gAqVVczKnXYlXc4tHVwVmPCgwA6pX + hMQUPT+TKhVIUq5CLupFZGTQAS1QAv7mYdokX/UnaswWgpQlACMQAbE1eBQwWmB3V7GXUVpGVwvXP1tU + O5xVbpaidoVVTyVFJZY2LbsVZ2fwTAtgKtHHSsq2ZDe1bM9maqlEACUwA+VndRNUTo2UeI32fV53VIg3 + g9aFACcQAQFnBv9oRk89uEBv5zkNlDFABG9ecEgHgFNhZVxQR2rQeE2l50QhcBcPZYVE4BQRMCeLlF1c + eF0XBXZcqGj0w2BMtQU7pkPGVIlTZSQZQoRkoAEsQAJ6FoKpSHIeJnogyGfiU1AHsAKmgY1GkAMy0BqC + w0UKiE6zl4iMtnUndCMpCIEHAIzmRYxZUi/rdlVxeI5ZUB0OkHx+x2z4N2p9WIr35oziQwDTd4YCSQQd + EAHVVVHZZXOnFX5iyGWOSAIrUAGCB4EjwDnoVjHlVVhy8X5y+AXdAwEVckT2d1NPOGp4xmxMyH8hsHIt + aQQ2MAMMkFEJN3OrhYi0Jnu3dwJ48YBcsIP/hVE37hg0KDUxFPNJnDgGPnUCE5lsSxSVz+eEJ7d/elSN + LQCAVzkEKFJO2TZUi4eLYheOB/iV9lMC5hGRSElM54aRrQIsF9lj7naMZfACK8ATUSmNUaeHechv8OVv + /XcXZhaYRqABExABv1VaMBZzsDaL2WVXsIYC8dR7adhG4vJm5NVGm4iMWTB3JkAs2wRfz3ZnyrZnN7Ui + rdMgFWCWLYkDx5dtXbldCZeAjPh190MbCcACLAkGv1hPQXcnZuJ262aenCeeLzkCYEUsImh/JDhqJSiV + fzQACPAAg6iadHQSjVh7i3lzC+htjGYAulcB4ekFvsdumlcxbTY0VhGH/8J5BR3gHiJwRMdZiqKGjyGH + d6TWQQWAAjHQioHZHjpBAjDHnV03g2B4e+EXhgoQTBNaBedHIBYmfJf3hhfGW2AgUYg0On62nE5HmiNG + n1AZbQWAAC7Qk6pZBCfSAoY3Rtu3gF7mhTh3gFw5fvuJBYKlRvMihO1XjDj6Q0e5BS/JgVMJeho0n/WV + f6Jnan5GAiowAYDZpE4qASqgFo2HaLa5fQZYgA25PwZAAg0gATM6BWgJL5okN0BYPT3GT3HpBauBfPbW + gWxqpMvGfKGXR7PDADHAkSXaAgnQjXQ1jrokjgyHUTVXFQcgRR1wqFGQdhb4m7blhr8Cj1wAEsLhb/+T + ZVlP6Wz6SFkzNT4ikAIJaqdGAFALgACl+oK1yH22B3n6IzgmoAIzsKU0upuVmJ6WJnzyQnxdoAMsoIXB + hU0hyIea6nxLWF8FkAAWAKqquQMP8D2ytmi1Cai1OI6KyBUlUKjiWXlR1ZvYw0kZ4i24ugUUUERMxI8L + 62TRSJ+UhT4m5gJVh6xKkAEv0ALcmGhe6T/fSI4qKlRbBCiSho6SqY6bdJ5tuagxslhfsAEbxpR2V1NN + h3/3h483i01HdABzWrIWiwQZ0FUnlKJhNJNbRqB4pUvnVGM3VqdcymsUmUO8Ypmzmn6kU6ZWYEgO8FVB + 2oGhdncempdRiT4I4ID/P+sEBEcVOReLWxd2bAt7YXlUBroAD+ABJCoFXZpPndQpYHo9cAmrTWADL5AC + xdlhm5qzIveUmJVHIrAAOXi2/jUDjjM8bDtzsihzSkugrUUCRNFgZzlbPPZj5wl8P4cmLssFLAZUvGqK + TTmkOTtZJ9ePardc2Aq5QuABjaMZRCtjYlmLSftiRescTHoFPlewVQVkUnWZRXmwFOpqpAi7qnSpzbdv + JDhiAvBKNwa4FouxG2g8jbhtC+llLcqnj7QVC7AbZ6mt8iGBPdSDKWUYQwavTBC0CuBh8oWcCtVsSqS/ + p0Y+BuAAE+CztpsEGSAne+p44MhtgFpg1Fq38qsE/+M5ujvkqJaWo0WzXloAHCnwVPQHjUSauEx2ajRL + VgfQArU7wEPwAqtzVw0Jg1+ZPwCKk8TTJiwAmdQhmfq0qG74e2C6iQ+cBBKwjcAFX0sIsSiZf045VgbA + ALmJwk6AA6ozqik6a5U7gwp3XSh6PzH0JlpQo+0bI25mMW4pHuCatTMAVFgFatXLlzbrplJ5nOhjAArQ + AsfqxEhgFljEqjipnW17uQm5VwrAAgKMqBEYZMihfu7YdqOjmVngchPpRAUVbU4opG78ZFA2Ph+AABHw + uHbsBIN7QsCbmPnKnQfoeNlBqFXIpaD7LOIiphB6iReMtVAQPwxASkHqh4hrs//7CLF7BMkggAIwcLed + TAQ+ZQJUvF1Gm6rbOa2t2gIeoL3J6gK6QolrRMGd9GtsRxtDBs1FkAEwkAIkcIdSx6Yn6XwcykHFZQAR + MLzDTMBzlhkpxHUtxJgsrJAxWFclEEApdsO64qWZyLLKm36GQQAlLMxLoAO+FT4b2qFHWoLMuY9P1CwK + MANO285WpjolAJs0ibQ0R4Mv2mUveFGPkZpWQCkTiSGM2qjqViZJUgK0ggVHCJ+hSckpCcKjaWfJNcfs + bNFJME4mIBsb3YgxiGDhZ7m416oChAUPIBjsJpSGdSY55Clu8Z1YwAEQgADjk2dNOJLM53R71jqAZ7c8 + DQX/GXB8B1lUqWWqfWpRotxdI6AAzzHIT2ABjwM4GWe86Nk5VjICDHYFxrcC7qnGyWmS+VtWekdQ+CnI + Yx0FPs2stCmLislItIiA+/NoDIAjV+B65rQYlPmlQvlGdaFzAFzSMFBHacyw55q4bjp6IJhEDXKNi+0E + GhADhIs8pqWqG/WxBRiD1UU/gFLRnkxOPDElwnYlYhzVoNHMFSsFMAsk+UhT5lqfCyuCy/YTB4ACSR3b + UEBCKEBa8XxoMcyItpiqYXZOdGwFHOB6rqGoxIi8l3kcSqICFLDPUbADH1lKHIqcdmbJDc1kfnZiNKTd + UABaMFlaWOrRkc3WVXq5FsWq/yoAA8DNBKAlqh60dkHIvp6xIglgRtzMAzeQsNK2fNSbrkpWWfg4PlVp + qAIeBfK4lbFZe8sc1HvMRcUTQAFOBUF7AkGCTwXbvo2KiYRxAhTww4IJAQkARaXJ0KOIxKL4ptbtAnK9 + IxhwAzeAAxvAARyQAziAAxpA5G0QxNTFgIz2wmrtu396PynEABEQA1HOBDvQAKRlo7wSfG55GIS63FGw + AQBWl3YXnx66qSAW6EDxj00cCOpiAzZg0NaQATkAAxNhAS1AMw/wABYgAznT5s4UA65ZgLf42ApJ2WJY + UevDAvQ9y1hkR1qRWK3c2WsRPWM2A5iuBC8pVzF14iTXh/8068b3ZwDYvdPccwNXbjA7ADI70AE5kAMN + 4w2oIwMQkAIq8DvBYwIMgAIq4AIWAAM50OFp0CNbicW4TZvPGu6O+D9wbcNOAFoP0DdaUVsWXOf4hQIP + gOdRIAELEKG+2t9NWVxFPFn8iAAtoAOKHkEbABEwMAEUIAMzYAEUAQMS4AEmE/DJUBMxUAFNswAMcAJm + gxJlYwIngAIOYBQzMAEdEOtv8AI/glffK5bWpW0snz+y9hicTAUT9NNXkerYnCZ7Uh+XslzyHgUTYAIZ + Ko1dDZpIfK5P9BMFwMR9wOgGIwEGLwNQXwEWYAEzUAEUQQEw4AE7kAMkjwzeDAEOgAL/CmACYx82CXD2 + CWASZE/2064CFiAB0gkHWHcCU+Htaz2gXVe0ipg/jpsFElBHn+FrDMpu8C0b/bpUMF0Cappve7bLSR5t + 0Yv0a+XrcrABOzARUB/1FbD5Vb/5my8DFSADFDABO3DCxqABEjCvZpMSY2M2Zx82ZWM2U3F4ZPkAMMAB + EI8GNjAB02VoBgZG+pp4vmtdKDGysF0Fsx0BOjEgU1IfUg0rcQFDDJACMRD3TUABB8CUTd6m/QaVI36/ + fnbdFRDhZ4Y6MWABLED1FTADVd/57c/+Ca/+V2P6w9AjKRAVZx/7aL//rg8ECWFJqEClWpTdjdd0PqFR + 6ZRa5eUo/w6EaHTwHkhgMSlMJiG85fPXjB4fRgaTxFp32naylEIEIoT+CkQGDUQMCgpCAEEMFFJkOjDs + 7GRGBD4G/PwyCUA2Oz0JBkRBRf1MPTn9PgQITixyJmVn6zQ4diRiKiosZnorZnaDgWWCZ4yDY2A6Mmid + n6GjpaedcLISiExMhLYTtrdLurm9u00UVh5eNKjZpThaTAwM0srAyA7cwsbc7MPy2eCIUACjXRMcMFwo + iGNI0CERiAgV6pIgAgwcBXlUsPRBU6dSmUKp8qSJpCZOqgZ8EJHCA0aXOHbAoGBMGDCbM2Tc1InMQowc + klwGFTrU2QYKEU6cyVZOyLghJohgw/+GgKoCBy1ieMhhgyg0GxQW3HsjJh8ZNGLN+KN3716cgS41SGDR + YAHUAyIWnZpXwkgDFhLWYawkQACnUqE6jvQYsuPJUSBAEihhIXBXZxg05NgxodivY8Bo3qQ5mhcLGS82 + WFa9emiGGA1QgJPqjbY2buG+0ZZaIpwCBisiVNjBlfUkDy5OlICjj609MWTt/TNDT0wXFC+CYsDxYkaK + ultMETBA4lyEGR5wEMdIAcEA96kQQ0ZFKjLKjyPdEyhwwAHB4pM00OGFCSjIaZcDESStpgVDo+CFi/6L + UEJZdIBAgaYwxMa23MTBMLdwEkCABL4c+GsDoCaM4oYJkCNhhOn/1ADjLBjriXGNs8QowYGWhsphggoe + iGAFBhg44bcUTJMgtaEmMGERkFIBpTHF7GMssUwOWEAGCFOMQrvNOvNMtJ1AIzM0YGKIpMs117xBggZK + QIC3p0DEMBwQ74RKw6Z4o6qEExaIgIUJdECRTWvCGk+6NaJzbsY1GE1LRkc66CqDDXK4xYMXJHihAw42 + 0IAJol5A4YAQIEs1vE0QC0+kVRvjKAEWuGSTBww26EACzsocZhgDfT0wWJ2ItcjWY4uzoYMZFuAtqg69 + wY0ccja0bc89bWMghQrUPLaDCErogsa16MFRn+em++KABBZ4IBZkhfo2AQNAwCQyVj0a5TGS/+bTNxX3 + RFjAv2Mz4AAGXYQVFhmbGCbNYWJAm2CHWuGtGKMN9Dhhtjw11IbDaj22lhtw4hzxBL9g4KAZNm+ooFnm + nGMLxzHSkvTcF09IYYJRLS4IhwpWIKHe/Bg7TLH4Fms1kxBMaGFJNm3IVSZfjhkWYpyCKcbAYmoa5mqG + J2Cm57HZOQ6FC6cVJ7dxPK6NbRA/lMoEQB1wgQKV18TAgwcWQGAetsxio2a11MKnunkWYEEHsguy4bgS + Brjk1aL5PYlfVj8oAIGK1Eux4AFjKDA0Xx8OtvTRcvpsBmMZb92ZCRxwiqmP3XZ7Q9s9jJaInGXYYeUU + NYAhggS6cE7w5/8AQj5GL0QgQYWdXWdHgwoYAKEwKvP9ZJNM7nUVMpUWiOFp4HX40YJfiPU1dTO5vslA + M4Fh4e7o6a8DgwpQePbttXFXu/ZvROYNqiAgAQxowANisIPKSAgHMzhB8ZpzLjXArEboIoEBNreD+lHj + BQ4IgQCohC/GgIR7iQGFewZAAgiML0IYuMEGYiIDC7CgdO0bHbDIBBpjcM1XM5TB4jYYRChogAUMkBPb + qJU2p4wMifwDIJ+aYoLfREAGHDDUfzwQO7S8oR5p8CIFmYOAE8zgd0J0Bg5aQAJUiJCNUCJFY0BSgBNM + oEs34MCAKNA1hrFPGDxs2Ppw0seGGcMCFOj/lhmD+I4THLFOutENODgku0fWblrYcBYRtFUBrZSRNRuY + wQqIZ4AXwUxdY7FRGEYwghIwwAU8QuQzYKCFELxnJGy8D5TwgwmBtOBdLbyBDiSQx6ohyH0NK6bpduJH + 1NnENMN55QYx0IEWLFJa1rLmE3EnyUlCpRwk4wYD6rY6Fq5GBxZYgERENMEIcrE58lCAC15wxWdOYkUr + EAErUoXCxWSPJPriHmEQAAENSihAHiBQMZBZwx0i8497HBYyZqAETs6TbI5DzhG7CTfaaFSbtOOmEqFl + m3Ac4W7ytIwOWhCuUp6Li14sJRhK0ICBUZQWGJABA+iVqlru8xP+hFJK/0SggoH+JwM5GBAvVLfDPpoO + h6ODn1PP5AsZeIBnNCVbBl5gIYzWJpJt82r/2BbJceDJknLyDZLStEDLWNSIcYBgBW0Eh1TiLAXis+oz + cgC0A0AGha/CJX76SgAEPG+ilspVMHnRC6+pL2E5TOYe9aggmlhgqlW9q8UsmhSO/m+Jj6zTR7EV1mnV + aU7eMJIDHgCDXqomAx6AwAO78CKaDU4ssU1AAyZAsctOwhooKAAruJev+hCAuNvDBAlSIIHCDgVXHgid + DNbnWIc1lVg7+Ux1sXY1nPhut2PDwA5eK6ductajj/zY7WY3VmjFCR8ogEAMdLDcoNjgBXy7EBrmWv88 + /cIBDmbVFgXU2l0AmdNvieBrShBsL0z4IQRcoIhyi1NU586ABYo1ZtcAmbrFpk6ZCXJoII15DIkKuGeK + POI2QerIJ4o1iiBdr2xKNtIGtKACD1oNBnzEAhUwIA4NkUcc5GGI5p0DKzqwLIl5C4O5mGAE1iPMJT6A + iScThgAkYAAVC8UaW3jgYDo8XQ4ZutgQZ1epkuXFiJEMLxwUcatd7d+H1gZApiAxWiGjVtuKcAJ0TGCc + Q1GWDCKggJqlU0QiWqUK0hHgNMsCBxNIAQNO5RHi7rPBOkpH57qCqx3EgLpP9TTqoAqxyB6Ta/ID4qIJ + hr8TNxGsHbMmZ+ucTVj/d6NPJlgABKbaZ6HkAAYWcEEEGtAABywABQtYgQoaEAEIzCCB8kV1HbZTAReo + YAUoOAEkFUC3FDxACZgmSgZ04FxgiImpDVXfDd3HVHRP1yaF5MCzkTWBBYyMxfzDDf8c6dlX60Zak7wW + EXyzAiTBQNFCyQAOctCBF3BaxBLjQHrgTQ0b2FFXMnxACx4wgwm8QAcbyIBJs4MDXR1UdRdeN4MwzNh0 + J1OyPDyGTyJuqxcg5dXfuHe933ybr7qYq0xcsTfOAQEYnOg/2uFAB3SQg4LHXBqYOTrSPd7CDXhAdBeW + bmSVCcivZXfl8CtTBRykW6b/hwMzUMGFskHJjYo1/84+95/N/dfiJfIPUC6wAAx04G3VgHzs7MAA37+d + q4VrvXReB7GYuR5qpx5TNDJYhrP73pUb1BcFIeLoz3VuXp/3vKtt/yg2V6wAKTbAAh6AfORRbwcNdGBq + C7o6g6K7UOzq0aFZl2wwKOABXafeMhqYQAMSQIIMBdDO1dI3WNnOc3+XgzdnOAcCO7B03k8fCjfIgUGP + YQGvs4/MJl9q4aP6NTL1QgJip/5JkfOsanIs7p1ntVg/2zEVP2VtvJnbsV0gnNOfv++2eMHBhGlhFuvk + 1A3rGuvwAKnMHgtrcg/w+C8oMkAGduxavipkkm+85uzzbi6JmujnsOmI2kUdHv+Q/0ROF7QvxDAsfVAw + Yc7tqfxI/B6mAqBLtUaQ7CogBRZJvFospOYv39KLxYYPCLeJ1grNBFbABaZK+mpw0QrqRyosqUatBbtP + AIkhkJbJCrEuzEBjhipAAjhA75awR2RgBebk7YYv8+oMkkKLvOaP+bxqdqDFNxbAbnYvDAXMBu7ooDQs + oVDOalTu8Kyu8ERNC32BBeALDO1QKMrJARgAvaxJo6yl34xP/rAJbhrpdnxQxbThkhQgAmLA/BLxsvBQ + AjRskAaxCv9o3UYD8Rgvof4QFWWg2UKRNTCAAyjABfKHKkjgdjTqs9DLvNiumtxskhopm4hgpLYly2ax + uzT/YDOE6dPM7Ms+rcP4MN0gSsReAG+WkTVWBBdFjweTCN/MkE8gyfNwB27UcE/IKkMWwAJObRtpCg8o + wMJWMAbLLMMCsX3qUZDOxPVk0EHqEB6DAgckwNccQGOOMflyDg4n0c3KERMzEFosiTxUgFsEkqJGkcLs + cUzKrSNX7vDI7AX5MKmOQQY2TgdwwAEvEiNswKgswAH0JCFVrN+WDxIpqf1qLoouMdbwZG5UQAaUcCXJ + phZb76HAb6lmTwqLSdSEpcO0qxBXJ/pUUihdAg8qQEjORqTgTs5ijZtwTg1xTt+MTwi9IQI8YCqpEl7i + otMeyqFOsQqx0CPNZLrKLGtk/4ACKCBlgjItQ24HKOABVGCRRiQqMoT+PJADufLz6GwSu1InRQoBUGAG + 3o0vowfcJoAVWy7UzA0po5AzrdCGbqIXKGACPEAHNAARKbP3XkDHFODEenEY227WMsohd9Bt+u0YWcmu + UnMojWomTA4fN8x02nLU9lEzhaEkJQYUd3M1bsADpK3ars2S4AzF5qw2JPECZYftAigqnm+olrNimpEz + ZA8LVXAKD5DlYA8VT/EaIyoGHG4vv9NSckACHgAmS2BEnuL93G4xZ40C3Y/e1i4BrCIG4tNiOEAX+vGx + VPD7UJE8FS/DFDD7ZDCBiK5AbSUD6FMFFkD0CpM2PdR2yv8RMUmLxdARGxhgBtDSQlUjDyys5ZISu2Lv + hsYTsmLwLmFgYlQUWW6gAyaABbwDKgbzJpEvdxiy1Ypv7eqPL1oAPnOUKPTGF7TvM+tRAVsxFb2PdFbx + M0zSU3Jg/5q0ODZgAlpg3o6RP4NxE9VmJ90vvXpwGxDgnd7xSyNk8iqAhliwQWuPsbpPPfnRSvsUbHZg + A1BTTidkOywgBRwgKxMSIkWL537RHNnUDePEBFLgBbyUUDGCIJHK+xpU8VCuM6v0GitAGTiOSTG1OLTD + A2TABeqitJRotDJwDSmQ32I1baTlPilVSU61OGpgAyRgUz0TOHlI60wR1PDUJtZnhnr/IhtNdVcjxEda + YEjwDIBKFAOLtPMelRL5BAFMoAF001ktA8e4Q6mackFZ0dzehzw9rFeqBiBTFFwJiuoewDsUwFnkLztD + y4lQTL2ENFq4VQVgDl4zzVeBdZg2sjxBs1dAU3VcTgYngDSNTGBdBw9vcd6oIm1iNVs/lCsDNBKJoAEo + ICAltuk2YFzd8kq7DhAX70WzLxaz8chGdmxyIAZaIDCvrUNC1CbnDzcuj4kkcU8ICGCbNWYnoQaMCqmo + sRX1kXSQkmmF87rADga0YlCJVkcN5lBjw16n9QexZSxntZLQcRt2sQEAo2oH8levq+Q+Ml2X0mtYVoe0 + Txk67lLN/9ZWoukoNnQ2ptM2dw4OwZZNh4BbWQJm6zYaNOAF6vQeV7bkZjQ0OMxpGcZBvrBwhWgDem3a + GtGS+PUwN68NO+Q23xQCJpNy2QGrCtZPoWphCY9tkcFGPUVQSVeIUrU7kiNO9Ceb3FCS0HRNweEEWGBo + Y3cKPEAjR1I9Ee9xqxA4y+Q0TJNqg9e7dKBiTwDt9KeadtBr3Sz+omIFKOB52SF6NzIuaS8Q98iP8DIr + tsJ7n0kD5DUwg68MIZIm2xBEx2qkXIAO1FcafDW6YE8pzTNCCQknliEHCDd/N+gGdqACVMAELtZvgZHz + zpEccHNbRteAnWFHeQU0Ys8tHwpYgP+zZfGugC14gzKgAyigZhfg2kqLdnKn1ZBUTlCABZxphJ9h9SjA + Tq9O9kJMmYYBL6VWG2mYoopKLtx3RDLWVjU2iahiBSaAboP4CQ70Ca/GKQtwT7V0GSDuie8KDywANsYL + +RgVm7jhBFygUrTYGYKHajjYeMkXw5ShA0T4jM1IWWKABSIghS2vTH3xzoxxRFDAE+NYjqVgPmeCYd9y + w54SJ0zSAzpgAwJZkGXXVy1ggaHC/oZAVsnxNtDABCrCiSGZBwgWfdSNww4EobomL03zk5EsA/IgAhKV + Q+eEMK1THBZVAYRWlWuK16Br+5pWh+5y4zjgkXH5lQ5XBlrAAQT/zU9iOYoq+ZL44tYmYLWG2Q6iRtyq + Jm0J7xgqjIZIM5inGdXYlwVWAO3kRqTS5kLMAR1ewHm/GQpgglecllyPM6LQo52frYTr2AXoggHQxpJ6 + w0gWQAUiIAm4y55pwY5wAQB3uWo4zD07xQO82aCf7UtOOAWsDSrk5JkdQAWWzQvZWaKj4OA4gMsmIHRo + IhYnQAJ2QOneFaQpCsdIsQVcAFGLbQFSwAUyLmU+2qWl4OB0YAc25WBS+gU8YAcebqd52qpEWgc6wAMk + oFOQDlQ8Oam9xAZsIAM0AAdEJQOsmqq9+qvBOqzFeqzJuqzN+qzROq3Veq3Zuq3d+q3hOq7l/3qu6bqu + 7fqu8Tqv9Xqv+bqv/fqvATuwBXuwCbuwDfuwETuxFXuxGbuxDVjCciGPEGRrdoGyZbCyMfuyNduyOTuz + O3uzK3vjGnmqAxurEY4DmDq1kW61Vbu1Wfu1XTu2YXu2ZZupozpUhHn6cOUFbnjaiK3YgDu4f3u4UUC4 + i5u4jTu5kXu5j7u5i03gIMAQ69mxm8AGAgQXShqzc2K7L5u7vbu7wfu7xTu8yXu87zIGiLoDcIC04W23 + Y8DX9hmdPeYb6Vsb6tsc7Du/8Xu/77u/9du/N8QIVmDGNE4qGdu6f3pXhGmGtrnBGfzBWcDBIxzCJbzC + KfzCJzzDI9xOY//xRjsOqeGNfWdAn1eA2Ihkek8gxVF8xbONxVO8xWH8xWXcxWk8xmtcxRUg22o6oBsA + 1+A4sTGD9WLgubwMCo1cAJGcXZX8yJecCq8LLynAPQMVxNNsPlngIM3BSIykSIiky738y8E8zMV8zMl8 + zLc8x1/8CGZAgRD7+t77fKrrU7WQU4ezzuVczlXnfACSyruLlWXgAWCDn9G8SIobBRjA0As90RV90Rm9 + 0R390Ru9SHBcimy6J8RmsK3PoMZNbRfPauj8zj891N02YX4hBrxQA1p6t7AKMKFT0r0c0Q891st81mm9 + 1sO8uGNdywndAVLAArzzr0VOJsz1POuRlO3//Dc3c4pR0GGyhjRFFskwoL42dNBxXdZvPdYNXdZhHdu7 + HNa9ndu/PduJJNyt/dVxfXpz3AHcsbQ3bVM73Xgfd4NFPfboPdn1dGkHKaJEcOwwQAducMW7/cTPXdxP + QNwPveAJPeEDvsu3nOENHuERntsd/tXHfdtPvEhMAAVc4Fv5Gg9h4DiL9amYvclJnslNPslX0bp2QWLY + +5WwwAUOsuEd3tAjvuDF3dpufty7veARHtZ5vtp73sshHudtXuATvuEjvst9QwVagOD6GqYLmfbunQD5 + 0ditXtnvHdkdtFxHg7Lwjs8RKQMQYkhSPNcLXeclHue1PenV3ucT/uwr//7ttV3ijT7cex7iyx61zpKv + SzYAP60PVdfMsB7U61zeq3ieZVACpHnRPGlDvzzpFX7ns/3nJ97nvz3yh97hf77h217geT7yJT7FVQDA + 9rrf37ux0meDp5BYj7L1g3Uah7PdIAHsg0hvLGRuaB7oq53ot73aD173Hx/RMx/0ex/bIT/is734kf/a + YjhO7Zp9ZYCGSEdrlh0GXRDeq77qMVPrqQvJyQ94zWhmcVDHZb3mLV7tkf78CZ3y1R7tb57yxVz4cT3n + zX/yrc03IGACwL+sYRoIZJZZhTiTEYtKY1GmXFagT+Y0aZUyqddsdGZ0aotEGMfGO6PT6jW77X7D4//q + jISlYihOKAZ/z9jv6TEI9gH+8fHpCRr6NQ4GQh72CSpC+j1WIl6i6HEqMKTMdJjJlZqeoqaqrrK2urZp + dEwgJUV1dYHhQh1NId1eTe3i1j4tIeVmIe+CWVTEeGy8Sk+34chErAwiPiYaSnIiZnKieIf7nXD3dWui + E5Kvd3ufAxImMqhASGRQ8/f7/wP0l0OCDGRcjlhRhiWYsS8JD3bx8ktYk4rAmmypQAGGDgwBP5rK8UDF + Am2L1KHjdrJcp20r1c3jVk6ezHjwWl4Kp21BChk3QAINKnQoKww6ZglDqCwML4fIFCYsxnAYxokMM966 + JeMZKaJEO0R4l1LloXH/6rqhm3lS5aWWkuCtq1d2W6OY4wi1W2Ehmte+fv+CtLHDycIwy7QQhtjUVzCH + YiwShgzsoS8jlonIkPATMNAdEU6kbOfoUU63MeX+Obl2UiRMmw5RugmOraR2eBi04Mt5N+/epTK8qDBk + 2cSotRxPtsW0qjGLS7g01DUZDJgZFmJo8A1wR4M8OlG+Y+3opWu33xa5g3neknqzjOayPZEHQg7t9u/7 + pmNhiOKKzg8X1hxizTWW1Ra5ULQcEfthhx8/HjhgwifzpHRaI6iR9l46ql0Y0zqjwcZebHRpkkgeLdTn + oIorBnVDHdAZeBVzx1VWY1K9QIdQRAUK+AtjXwjH/0IMOLD4igcrJGDCXIakVWI6qQGSE1xMepOeI62x + Bt83jKA3mwknQMBBkWOSOY2L+2WR44/S8dhUjDPiKJUXTx1IHFZGWEABkWWqcmQC3tXTEiVqMfmhO4PW + Fh5ekViCYSSLhqgTOijyWamlv0lgnUQHZgTkcTIWyEubxfnYWGVUVZWmkHteWgp3eYw1zmuJPokTe+lU + Gd56b5mGFjivmfceJCyI2aqxx/IAnHUUleqmFTre2GMycKZqi6lvGrbFddkhC0cHLgRSU5btqWfOWyCS + xs437OhqJa3noiaaAxWw2q29Y9rgwVIJxqggRjZO1yaClt14UGJUMZEZt/eywf8BCw5gaZavtA0qpcSV + 6CprXBKrh5e5FaaLcR88NciwySoaFUNB/RnsLBaRdVpwRD9S18vL0XKxlQf7nKwGDhRgo81oOMFzpV31 + lPOhuYSK+w4j8+TUlh4qtPBCVz1j3dtAFCgEGaiLOZdj2MV8mtx/Oma7phIbjZI1GjbUcQdoYpFTWniP + eshrh39EHSmU68oWaLsdphXBDMW6nThgN8jyGL9n93sVzVE1BC3LCxV3sBhExLCDbonjEEMECiiZa7ki + z4p30YMi2nfRIdrdIdSDKJnPZorj7hUGAwkh0S6Kob0ctf0y5iPYnkan1HPNDSGBDle7na8LpNPl8VpR + Cy7/rIfksZYWThWXmOvsqZmAArG5o+/VDR4IN63LlHc68O+PxR/zp6NSEV3z9SqewwwLAEoedVPX367k + Eragq3vjaQuIWMeSdqFDAQ6gwMLSZ0GQ6IACviMVqgb0LCl4jTnUSo4HT9Wyme2AZ7nLAAwgkI2xwKZ6 + 9MgY0oj2rhnCR2M5XISGxOOSuTmgBR64IBFBsoEXaNAL/QnVm/yDnFDR6V+eMqFy1pSczCAOfRuggAsW + IJqQzWRpCPwOGJtkrrNoY3UuwSEDU8OAFbQABhUsIh2pgQEOIBFzltNFUgxmsyWCsIPRitMSNqIDFaaP + AzJIgUlecysd9opcBrwLlWTS/0O/nQVYoFEACiIwgc/VMZTSsAEHYEAL371vbP+ySsy8piD7RRFIzznC + BA5JRw+0IBsKCGA8GOUkTLgmLmssVA9btxJExQcP6HCABbIoyme6IgM7iIFwmnGRKDgBQcewlqi2Kaoq + 8rECNYvMNm0Bs8hgM0eY8QD/LEgHFjRgBWYxY4lE88Vy0eZJaQxXIz92jg3R7Sx6cEAKLLADaCJUGhrY + gQQosLzLKLGPs/xdRA9S0c2lSYkX3dRDNiWDCbwAlERknAwe0ABPwKo820AJMDMBKduMSET6vOeTAgEa + CZ1gBQWNwfMS6tNW3IADHpiFpoCUTWuB05ziRGo2j4rUpf+i06lQPSo5sVmFZcXgBTqYYx03AIMHOOAE + X6JpeTiGRkiRaEPgMUd6ahUu0NwUBQ2wwAu4+tO7nmID09RUs57jTfo9tI9U3FRgZYaF/cggpNATpQZe + MIMIqMABCxAL6eAK1zzASj6ahVVmM7vZTVoWs5q97Gg7G9o8kGMBDnBAAyBAgRTiNbarwEEHYECBGHCt + OhrdLW9769vfAje4vC3IbW/rucU+EwMb8EAMWACBBkxWAUkyQZISUF0TUDe72J1udq273etut7vaxS51 + uavd66JXQqpt7QwmsIPbyTa+p8AADjjAUNwGyQIs2M9+9cvf//o3wP0dMIAJLOACI9j/v/tlwX5nQAEK + uFcHG0CuT49IARa4ALqpRcFkO9zhuk2WwyL+cIhBvGESjzjFIV5xislBUAgIaQd2lS+N42ADHOiAoRNw + 6FQLQlVx+hjIQf6xjwsCZCEbuchERjJhPgoDD+wAB4iMbwZy0AEJqCyqT/3xU80ZZKgutctbtio6sfnR + F3RgA1OuMZvlkAEN4CAHHNBBB+hM5w7UOc92xvOe+aznP/t5z3fu858FjWc9c4ADONAAfNvs6EdDOtKS + njSlK23pS2M605reNKc77elPgzrUoh41qUtt6lOjOtWqXjWrW+3qV8M61rKeNa1rbetb4zrXut41r3vt + 618DO9jC/x42sYtt7GMjO9nKXjazm+3sZ0M72tL+BwaqvIFE83kDOVj0mqeNCgzYIANvXvQNxN1tbycu + FjCoAIMf4AIXQGA4WcWBR9B9igxsQAce8MALJhCDGEhAAlDmgAbqbe+sBZUgLIhAChoQzwXoNALwngEM + OkDvg8MhAzjeAQxwq8EhFCQGE5DADnJwA4NjvFvKRaIFWgCBhjsgsiuYucMd7oIHNIMMFLZ3UHfwgo7n + dnPmhPCTJXzulJcpAxlsgQpkPnMHrGC1kYU61aOuAhdUQAdIR4MGhqo5YhBHBhxp9NbHdAMdEKQF0F0A + xJ8O9alHfQWRZfsCrl4BdqZcucwVAv+aONoY/jjYvQQv+5juCIOWQ3a1cV8t4xkfdapDPuYP0MzBDX+w + i4gNFyJ/AQfITvj86CAGI1G81Ksudbmb/u1Ql6cKDLrzZh+Rr6zkY6dAPoEOzPjzf1nuBCwAARWsoO1V + n3rTmx7zyBbf+DOHeApY8AKUQ5t3RY0c2ihqTQh7wOi6300OJrDwqTe+9Kp/POTJ/3jyp6ACIm22BiSA + JuVgK/7wNwLAdeD57QdGrxR4QAogRv7Tx1wABiDyCSDcVd3MQcALHF2yccCF8UfyqI2bFEYzUIAEpNnr + 4R8/bEDaRUADGKDcod4Hwh34AV/MkR/wzVwEUEBHQBsO7MCFiY3//fALnhzBVsBAyS1gBr4CB0yASbkd + CSqezBkf8QlhCAYg6ilea1GAMykb4xDVnZyKIFUf2VRTBZDB/ekgK9xADiBRC/Qf27kdEhpf41nd+Y0h + Eppg5KnAA7zAs3mV/GSey4zNQaBJBXZADuRgFpYCDgSHC3Sg4j0e8I3g+I3h2w3i26Fh3OnUBDxbB2gQ + Fd6JnMxe2BjBg00ANGCgHrrB2fUgdM2c+Z1hIQog6iUiAY4i8QWfA/hEs2HADliHNfmRgMQgm1CiOGlV + wWmiKXRd76ldCT5d3BGf4zWdEZaeEAYh46Ei1KnWDLTTsQEHu6ESJF6eFEkGISXERqDZxeXi/xvgQB0k + nvk5njCKXxCCoMyNIzKSItzVXTM12w28QO8UDBXNX4JQB0QowVa8QA5kYgbemCxYAGR9YvghYSmaIAES + oTgKIjIeIwqoAAvA1rJtYPskxVLIowSaDSRKxMhZXB7qXteVVAqkgCgiojmOoDEKZEmqni8KodO1ngfk + nrAp17qxABVy0BOxzNdViy1sBCbmIn1ligtIFsSJnxgOIvihoyCapNyRYDCWnmpNXjMSW0zCoz1Oh5rA + CWakU7/ol87gYRaSkky6QP+d4BBS3UoOXzqOo0mq3viRo2q1gAS8ZLDtTnAMhys1hPzIyPuQkNDZYPbF + Jc95wAykgNsZov8BDuA5BqNBHmMBFiRjFh/EBNELYKGw1cAGVpQJDRapXE712eMTDAEFvIA2bl1QwcBj + ddjMPWYxAiMhsiU5nuJIkmFCkqJqOSRH+lplmlJd2gwIMUWNBIwqWZQF4BwFeMDgpVws8GKGLV7MNcDx + PSYQKmRiKmVjmqIxouEZ1t0D7MA+/hofts8szp5FGk9Nqs0vSEQMwADnQeWz4UBgMh3pCSR8giJsomX4 + HaFaBqPVgV/wqcDhtCP7sMBDFAZmJoNxAAgWgKd7bQD0NZsNLFdzuQBJBF8gruX/NeZhMiZ1lmVsriXk + DSF/ysBfymVgPuCATsUSIcb9QMsEzolGbsD/ZBabDWTQA0CWUaZehSbkIaYjMJIkQp4kIm7oCnhSI7Ib + b9bjIBHDHokKVSpP5skA26znsCmXI6pdQC7nhQ4kfBplYgrg6eUn8g2kjT5eA7DAEDkbB1DTccihZPjm + HFbH43xNRMxJxYlmsWUAD85AC3QgChYjjopj6e2oOcrnlhqhGAojMMod1mmdszUWUV1LHCZPTnKKHj3B + jyTBk17iVtlpB8iA2glfOB5joJJjdTaeYt4nGq5lCeao6TVABSjgs+2OBzyi+zyOHH5THB6pTYYKEbgX + jN7anabdYILh6gWhoJ7foB6ll45qn3YoMQ5i3LkA5UGbjMaAR2FetfQm/7M4huRMJBfUoXvlgIjKWg7A + AIY1nKAOn9Q9636SYJgS5X2yplKya2vKHQssarS1nyRGh52wSSya575OIcFElDjdlvP46qtx4kgs537a + J6qqpcNiaEKmpLoeH4ea3oRGwFvaZrEZxRNGItlk5s0Q1pKWU9lgzmP4V8WJq6plgCNWgNpJVuq5a7ye + 6giWY1mGqTiSYro2qzzB0SehGye+osvUjNkQDPWlSmbu5WEhFkilGYO6Wr78Y3NaKMVeJ0Ey5nRuaWwe + YnRWrLsCH09QwPpBmzTBIIL4B6UyEfxAonRAhSCZU1aR7aq1nwUIKxj6YofK5kp2rVHu6MRO7M1a7P/O + qkDGTgATTpu68RjyIA9wAkxfJWnk5CVGaEqeOM/GhtoW6anTOediXicyGmTyEaChKiYxOms5WucnzhVc + bt3KJZFDfApmshKB7qrSxp9FidMlHmyoaUAL8SyYFmYyfu5zdi7w/h+qdumFJqUKNEAKuIAFyNHnceGO + vWnjBk/SZoU0hg3NAIiB4omQlAGrdZ9JfWrkbWjFDiVZIp+pKqQheunNrqrVrR7NtUAF1NLuSpsG6Nss + vJ8HnShgUeUM8mu/LgFiSUD4phoGwEAvzudihiMIIuqN/qiq5ixTXmdSQpxr4V4WuuAETJ9mIgzxpIoE + Gkhi4CRnKoTYIe6obcD/DMSTuoouWe6sQlqoOV6p+8IrhY4jKf5gBMTbFWqi/v6cytBP8XDm9l7TB3mK + EqdtIF2BDHgAd2ra+rSAZGlt6HYuD+MskB6mIE7nMeYnkH5x3HGY3V3uNp7BDTxoEYDcjoAsb8ZjCGcv + CtPIFoxBlHaaNFVABJivffqxoQ5v+Jlih5afKLJrIEbAA8hA26BxGtCWbZFsrT7uKlkvnJbNCc/AM8xt + p+HABDDd4q1qSgouCB6qDUssliomSaKlED5v5+hjI6+BGutAv1WGgb7M0qZoTWKr7EqE2PUUqemA3Wop + GG/tKQsuxR4il64mEIYpPlSAjPVFtTGaDUDto4Fb/wZUc/7lEfxpa3EI6FXmahSKJ0WA5spamgdAQCG7 + L1oaKoaio4+ObgliKCkTbgpAgCLvDFHYgAZY2Q7sAJ6FKzZHWrhpWw68aAZI8TTQVwe8AG6dEgTSiDhZ + TnnKkkXipXF4gQVMQIqImg1MADZQKHSeI2sSolkScyknH+kt3wq4AMVpaovYlwTsmBigScg9mXHKFr7l + GL+9gATAAAxIwAvsmz8rWjb7w502tNChykQiLeMeaIFaRZ6sMKdpQAykgFDu7MyC6SDnKHSSLrq2r/ip + gPPenTm7QmNdGAT4YQSwdQowHFtLnCKHlGydXUNtEFKdpwe8slA4KHMtrrNAdf/m0GK2zF8EVoEFyAAL + iloOVMBJBfIXm/Qxe2gNOyzxzu9kXd0D2O8GBwVSywCGORzz1lzzeuBYp4BmOw8eE1E/EoR+LZiAvWIz + PMMFCgUGaIBQdRxNo9I0VrTMiOc430mebKeo1QBjeyIANuspd+lWO+Yo43ARyhwKCOkM5KNR98MGePAD + QEBbgyRIMpxbNxx4w1sLXEcHWHf6LBT10vRwVFREPelHQfNQ2EAOMNfQOtFuElZhF3Ylu1JlIPZDgppR + VICEem2xxqao/qnpLuX6EmHzQgAUm7Ur8CD/Na93S9yFr/Vbg/dbt8ASJnTWdJ1D5c89zrFuvxbmvoLe + zYL/kRHImtLqbk9iKhUwFOPvpAm4Y7MlMS7mwxpkluY4DQdkBORJPqK4K3iVuW64W8P1hmd4WzevC7AA + BTByEc2lykRjJGYUfBe5K2xhbaXpyEoLHGpmLD21ddC4qN2RYAol6B4yWe5wMlesqS7e4jVABDjfJgNE + vtBoW781W/vhu104w/lhkvu5DEw17kQke1/Of3QBYis2UQRVUv9RCcMScJcwCCO2B9S4pBW3C0Mcj88z + bIZyDlunGK8We7nXlkfTDuzxWC+5eCu5oGd4kzdcA7QA0BJRY7Gbbi7xCDHBfh3uh0uDcu0v14C5Hpmw + /HkvN9G0DAA4qOFABVy1fhp4/0kf5hdraIaO8YSS6eFu+jRkAPvoaYVrOIbLup87r59ztz0/AK6njxNm + 9AYFsGJ8pgRwtO7orylJZHgm7Qk90Qw62JSDWgZQwLSLNPLa57weaqqyuc2xwEYDhv8MOqELup9neLpj + /ForefOZafqQ65vuq2+DUGKpujQkXJZ51M1wqy2vKEKgTZ7cq6jBQAR8ukpXp6jCr5eu76gGZPNBcecB + BnCYlFsPuoav9aybu8Qd/XfX+ZCkj9nWpYrOYYKc56EDhW3nAMdRgH6l/KJT5b5kRJ7ce6h5gAuYIVe3 + MzL/aSGHMUGxgPMIOz/M9wS8nIUr+dJnPFzrvcSlO8MVrv8MjD3oSMC+W+9Fa6uDxTdnqJtECuylWyUJ + YXIM4LmmBbNYgmKhejFSDqEph2rPu0D9SsCC7kY3WkBYxjrSO++fa/y7Zfyfs3XzUneEX8qdenCJ+u+j + erMvf/tR45G/ifjIDta+ABa2PgZo7r6k9a4PTuy8bm3n0rABTpZOPQBxThhv5MsMbLd4V3y607rrYzit + N1wi11LuLBcS8LrhS0uLixMZ+IaD1pb557e/zIiYXwYWnXempQxQHq9JFyQQrFRDh8rhEAqJxKIq8ohx + eFNq1XrFZrVXXMzViLgi43BZHEmJ0+T1uK1ORVqzV2Z7x+f1e6xNB5OpsJipkCE8rED/PAxETKxIZHRk + qajjs7zMyJGgCHRUhPQ0fFz8HBW1qIjR0bhsdX2Fjc2z2XlwWFhZOdo1OhLyLWoSPupdwXVocLGI8ciR + fZ6y6bCIaIhDO2MT2zYzSztbi0t7oGCF1sKwudHQwGG3wTjXsvGIGX28J4TUnxH1zP83Y9AEZ/Ji2dig + 48UEGYZmfOKHb5EjUA//DZJgzuBGjh314KiQQlcSIyp+Fes1RCVKJEhQCGkho8MNj60w5IjxIIU1ND1d + fCODzQ04F9my9QxTAUdNDRx2eIARgwKFGBJedMihoYbHDIACmuoX8V/ASP0SWbBAwQPNmpcw4OjAUOAg + ifsSmW0U/7buoRkUdrQFHLijBwspTO76hbjYLl6IiVmDYGGCFMF7cExgASHFtaJDhb7RRlTots0pWBTc + 2FTChEQPWoiBwMKCjAkvOGg0qGGCQEX+xuoLhZciRUIymLGtnEeDwglT71bER9xUPlH9YrxYmlz7dj43 + CKt4GQzJkMQqGTPOtQCFCgiUdCDnrkVHBTWex3DDH+dn5/vdwKFp4AHK5NFgBxjksoCFByCAwAUIWpCt + nwkm2EGDeOTpwiLo8rJLOOIMqc4fGWDILj50mtpBrofy8hCiQAxJUK0STaSxRh5ukACCXMbrhZhgiPhF + F/OKgEAmG2zMIoMXHrDmmnCCugabM/+yaSMcNcRogD0dDNrgBQtceyBMMFsgM0wIwZxBghmfwYECtMai + DjrpQImOEUZm6+BCJLlIkQIW77Hrq0OWQW1PQ5PbgIIWIkApifHEa6klFZKJSYIc7DiUCgx0oIBRMMoA + dT/8yCDqym24iaMBByDYEppMPKigwQfJbME1BV2r9UFZKbn0nDZZ4Kc6sADtjR++hhMIWOwytWI5Ayk4 + a8VQAGpEBgom6OBIZrdty7sZIjAGF1xMUqKlXM5dIYUHZPBgTWZ1iIEFT63kjMop0wCqP22gVEFAaLrc + TUEyHzSz4FpphSBMVJjZ4F83B+mkN2p/q6gsfgZql1tNcdghhgT/B5GWrBV5Y8ZdjU8+J4MdKljUsCF1 + 4TFLa1yAYiaUM8AMAjQ4g3LKMtbg5j7O2gjjpzhOe0YDCWZgoUwxwXw6ajNpneQF3F7pAtjfGJmoazoj + MsuT4ijUk9u3Om7I2ukeerGhCqiCYQeTUaZblgw4eMGellVND2ZrILx2hw0wPTmHWKMEVT/PgLZvvzDy + /SkoF2RoOBaVK1iwTM3NbNrWg6FmMGGZCH/lBhi2RnZaDkuxKCxEYIBP4ww2cGo1tx0qbqoYYLiKg9jr + Bh6aG/6oQMFqclFBv2U82EBbujPwgIWj+oscqKOCrvKoKtNgIYarMYmr6VqhFvPWB8y3dUzX/2LDlvRW + lLQnuDhZnxZO4fSZYIOyUcZggw4Wak4gZnMtGDTjBvsLXgKf0b//5U0Gb5rKBDzgu+BloAMyeACprFQ0 + NwjtSozLF+MeJwc6/M4SnJrBgqB2sM5tjkwC49znZqCKWGxqExqizuoCJahAIYJdhaIbBjSQgxzooAM7 + eIEHdqADIuLAfQqEIjTSsQ4cuEMDN8iA84DHgXiVioOk+llnxAhG6pHKaKaZgA4QyIcMSEBgTjuTmCDU + NAXBMH1Te6EEnmgJju3mWGB7TiMEZSdAHkKC3wMeBtIBjzVG0ZGP5MiSyOiZ/YgwKB7E5OMqaQ0LrCUW + bWIQHGF4pvGxMP+Gd8QVBea2Bwxw4HQ41Iv8ADKd1AEnIjSEZC51uUsMUeALmyENf4I2FFMBRYTG/EkD + GiADIF5CGt9yweeg1sJb3cqU6YNQC3Q2g2zFwlsS85qg8EI/iFRtj7xEZzrVWQXofSt5UxKNB4XpM1CN + Rl87iUAMzrmHDUjAAg6S5jVHeSY73lGbkZFA5WBxQR7OSS8tmqXXBDKiHDRynRfFKBQtiEGk2AeT2rsS + JcPIhp48wAMWzcMNOjYDp6XPmmCio8EE9tKDdq8D+9RDDljDG+JAJHUfwktZ7jEbhmXUqEdV4AZi8Bqk + BM1x9grVJImmyc3EBgYKdcUGAlYwOcKUlDP/xeYocQWhClzVcnF5IMSCJScX2ZJYPX2EX0yIVLrW1UY7 + YIEyO5g9o4TwXj77axmsAYUBvYIDD1Tf+F4qNVRG7WAHS0thXaFSN7mVnGubWOuEepf82dWznzXRZVqg + THEIU3JEy09g7UnSTmrRFTpIIflaeD6DXZOF2RRrrbj5DA748SuyFAs4N6uItHQTtMdFLldWBgHSCmU0 + qN1g4ry4ODlQ7hnRm9WYaFrH85XSmuYr5cFi8xdZ3OAFfqqYREOUF38Ea60TtRRKkztf+uqhAyw7Y8+k + lMnAmlaeRXPBDDyA0z144AHRROVXtcs5g3oOVwuKjQeg4UqKESsSQI3Y/1vDZhHjWK2+HwaxHtp44J6U + VoxQ1aRzs5finjiBBQmFxpIcJFMGx9GgYH1aeF3AAgk/4wYd8JNmwdlQnwLywhRQY4iVvOQqKLV6JZ7e + N6YXVVNRFw1OkAEH5Ftg6TkNx6S8MfmySdtSJqzHbDqd1mi5NUBi+L136YeHmTznD3snr03qaHQ1GFLQ + mHGvYXiABFwLixdIL2EB7dzTOldQG+MWQg3isTyA3Lo4yS+cwLG0PwZiMzp3+rgY8IAMNMMTKN8HVSGl + p4r7eo0WIFkeBmZQmE8JZpgumKuvifQ5cnDe5xSi0pa19Jzy8RAKWMrTx/YsDmTwmtLUa6Qc5M8brP8X + qnCkoEgeQOQrZJwwBnsOrN61dUBds+MzP+NuEggknXp96YiOgtKIoMAL5opsevMSAzugBlLEITmSdrAb + +foMlbLUArO+usumbLRjv13jRI871ykDcoIsK1QdBjWW9YNEZ+u9cXUqddT7VtxfRxUaMJ5qhDtJgQUk + +4xCxzrhcfwceMnc7ceaeSM4gAFvNHThWJKiLBmm313YlW2OFz2B/ZyB0S6pjalaCXt81h42vLcRA8uh + lA0m6GMXC/OZQrrc0KCH2ID724p36I9lvanR1Q5FDLxgBjr71EhNK6ovijDV+EpDZDwwaFkUesbl67Yd + uR7m8Tn869D4A7QmUhf/ibR3Lx+KTimo0qq1V55uyq7GzqjkUaI5nYwi13wJOQLrQ9/2jY1V8OBrblKO + 2FAQbaUY7B/Kw4fAgOiWx32N7q0TJ5R8v/ulez0d53Q4NKAFGt+I3x/EXRuDN6a1anijBUbujqjsgTt3 + L8WJXGGJzIAguQe/oW4ygdF+CrX8TvXi6Hm9agTopIM58NW7+rmv0hrm2NQm6zuiVEpjVnUV07CvARFi + 86TwM0AT6RIL0AyeqSSqqqRgMoPrASFxiIlmOoeWIxgH6y7nyzGZwyYzob7q2wHFK7Jh6aHYCw6uuZb3 + OMAW1I4OeDvEWbFRMYpTw4ap+hlrEzACgwUDm7H7/4M5MEO4sMqx/Ds8edgAQACZiOoE6bisDYmOQoAx + F6TCboGB0SqtZ1s6TLIkp3qSOLAANakJvyu81CMz9Am3b8uMEOwIG+itdyOk33LCOHTC58CTKsTDjjis + akCcn9Gkp+qz33uDU9GPLGsL0qO/+TMoBftA9NGmh+sIDQi1xlud4WIroBq2qrm9POREPtAqecEzxyEm + fRmm4JO2+hCHB4ABvpOHbWsw2goTsFJDhjsTr2sLDOgAe8C0nnO8iosYS+SNNOLBTiTGJPGSBRzF4NPC + pyojUqyPdekAwIgeBLs1agI3WiPCqYkwwOAYXcQhKPya/xOkOhyRlSvGc9yCw//SmVLrhv5ApnYcPqi7 + svbYgXm7wMwgGEZUPa76QDmaPkjsiP55gddrqDmEwocqQXaxR3RkSFoojH0rsYiUMjDCl5D6PXfcCQiA + ncCoOkRboa4ivG7TRoD0CA6gAK2RKLLbvvkhhEEoOIaESStww6VqLohcMfXDD6NQvw6aAXOMJEOjuQ/E + rQUbM6/6xyPkCA3IuRIMqnTjELLoqRjBtpikyin4ROYCuTwDvXq6pHj0w6Lonk08B0T0x66KKdT7rkW0 + ucBQGcUTmTqMPO0rJHejjbSrSpjEroiUyKJwkngCGrujtjgghx3YshgDSoRLS6xbrA5cEDYEjF2LAVjq + xYD/aBE7UUmKgAELvMs81ABfwjN3hEf/MLX9wkHHSYYKKECOjL9+HMIVEjxqIrNHRMrWozCURJ19kMt2 + KyQZIMzNLEaVmYHN2Bl23Bf9AkwH/JlkiIFV+slQYrhqfE4bC6sG6aTkUBLMEQu4fEs20zBCmELfzMNN + wQyU8wmSAsycXDpmRMUn2Lvk6Ejy4UchxDFbyzHHDIzDApn7oUxaKrKf00+/YE7wzD0ccCMsgcj8IM3h + 8yA9u0FrYwEK0EyPUL5Z067CEzwx87bGrM7k8I4Y4Br+PEjI009fKw4Oi4F6FNAqnAbhhMgbrI+RgxzR + TDGUa4EYMK7KIMs7Yr6Zgr6y/yQoWBwY/UOUehAITNTNOvQpULiTGIjQFK08G8iRSUkcaNsXwOI81RpO + HlvIn/xBg4FP6eM6xGxMkgyMHDgdVBgO2gNHYGsRppEJJ23BHPCl3uO3oUAci/QrksvKCvDJQ1zNoQyr + +hslNAzCbdyOb0rBxQtHYwkRNV2XSoBT8NOAgfwlepo2xfkinQwmqDoaQeMODCw8WQvVBINNUrJPwRBP + ONmQzUIWYYGIQSk2LYvU3MMJ6Yk7KfFLCNwgPQMH7vk+7nhP6Rw8DRTTWBzJ2eyWuHg9nqO9sBCWzLqI + CqAQsZzVY7ugDBLOUpxSGT0xUgQaZXKBCtABVgSMCa3QtP+UvrLM0Ec71crAgRe4PqCzsBBNyXcjhHjD + qmoturb7p6YazezpPBQLODtVFxgYRvhzTli8tRj6Lmx0LEPlDlwMMkwMOluS14TEJX01OhuYAM0YTr60 + 0hqkNi8KLDCMRhOZ0ESMo+cbVFqMKVtEQAn4OWFDUjUtBUggL40tugygABb9POpasTw1TgedgAD102gS + KPqbT3Vd2WOlEQt6pYqbPYhavA1zN1R4P53luBuQgRRwAP2ALv5oqjEqo00dg79RhcKUUHx0TcV6OVKF + TlxD1sDoRp5iLxN0r1kClH0YhBdQW60FsRvoWSeYwX2Jrpt0LjdwAgu40fioOm5Lve3/MlbbIlTZtBGl + kcwRJQUmLBaJQIsXIFfAZTKuxacogTptjcBuRcXSkgFqbQsyBLd+9MeEkylTJVPtaDuCjMtHEIUmbNWJ + C4jPDV3RVbLO5EMrS1yvRL9/w4bI8Fsb8UFxi8+zZFiXAlIjRBIdYAioDBuxE0cQERRgaU/iRbYbmIDq + 8ZmAnbaLXDpx0MGXpBEMpLmGzS10TbRabNftkES58LXIA8DNDS7MYpusJV9Pg1IS60uSGiZ7ct+KrLYG + gIAoGF7B8MEMFMrEZNmPvF6IrREcCDW6aFTLzM6ee6v+tdECRrZ7Y6nEVZyw1ckquacsMamDLdcuI8rF + fEXo69H6/1OGuU0Ok9SaF9nbAJ64V20IGOhTFA4xLsqMLHzAgWUxKKOXOJiBJtWOHJ1FQJW/MoRFBYFZ + JFFKEFYdnhvA/wMLECkqJfa0SS2Mz2xhGJ07VBlO56Xhcj2wQ0NLpq0ml7q6gbndiIWX66Ml8C2E7hXi + /x2FYhtXNfa0VpKBXxqa9r279XOSCGAB+IVeG1bElu1RolQ0Msvf+Pgx1kCFDHu8DlG3Xow312Xk5DLf + lrlTsI229WPenXABCkjiT8VHzamj2JVPlx0z7D2ULhHk+znk6QDfp3wIbGllZMM3fQs4kf2MvSypjTyU + 95y5G3bNbf7RMPliQ5m0ukhm3FybTv+YzF9t5k6rVWScshFiMfR1gzSICcozlJRdsIISSUfz0abpYWbp + Em8U4V8UQHWTlhOt43QGLT/ICZ4orQ2iuwYczowcHWbJ0ZkrQ9pVuFANUh/eDoF0yygEQHW7BwFKiwpB + 6GPDxTbOQkyVZH8DkAZgAUjNFHu+Jlvh0Q00vdldwz+uETNtHb4AOhdxN6a5ZFY+aVf2J76MaFRrx2YL + A6syavdcTR8lQkb0QBv75kNxQ4aQyybcsIZgG33I2KP2NMpalOQRTg5aaTgojSIxaW4B1ZqO3I+kXBZq + ECFlFjeU2ZERaqckGUuZYLL+MFykj6w0MX9L6zCwgB046CvOILf/5UfHUjiuoim5PZlW2l6xUYTN3rkX + 0B/BrjfKSiGdaeBmK437aIG0yAiUsecLti3XrtD14Wkk8QOo4ATN5ouQMQ4JEJzABu0QG56l2RtlIm7i + rirv64DmoRuytL+G7UfqFUJhRhmESJG0Qovrxu5BKLbk/tvfDrGb8AA3WR8HKYoGgT4ZkAAdaOz4MNe4 + RUNvA7MLfcQXCB64yBtO4IS0mQrjqA0OMFrv7rRM+J8DkQrdmQDe6YDb8G0kid6kpd+aLsLcCuVtsYEh + 4gAjegoPUCId0AEOyIoFB3ADbgcc2IAq0oAM6O56ZttfHtVA1a6Fs1xHwoAMWAcsSvEQx/Er/+jIq9su + ylVXRbTsHBfy+TLXX97n6tW69Llrjh7yJl8n0oNbMX1thSWlIHfyK6erbetjdC2Y+501O1pyLBfzo9Ly + zYHP55tsptUmmqHvMXfzJ7/jxKrfQKXfImSQ2X7zPE8gGKSVB5smIP2yG6ty19gtPTd0SDosL+XiKZ9r + yX7QXD70SOcWnfqSlqq1bNzAjBYfskJnSfd0uplUGRCfGhPVHjefN1qeLf30Vdc9DvAn8+bmq0a9MTko + C8jMG2f1XBcMlfqWfEwwTC/WpmkQblpvXTf2tsgBUUOwMnTExCR18YIACD32aTcU3YAwpU1DB4s+ajJY + avd23duBB9KmhP9r2fLZclpJC3r+9nXXDkmMF5cjwkH1rvt70Klk93vXDg9mqeySbEAXynGnhKjG94GP + hSQc7Vk5yzE79e7q8zTJV4KHeI/QBFGn9V8P5s9Ji8yM+I2/Rf/JOVnRHDhCmAZxkBmAgQ74b45X+Vew + AZ3a5cSi9VxJ7cws9pW3eTy4ifO6k1wxb+gjtmKrqJsXeo7IhB2QgMgU9m04n7c5+RwA8aGH+j3IBB04 + ekNgAWChCt52+qjn+tbLgHbYgBzYgLG/oqfv+rNH+7RX+7Vn+7Z3+7eH+7iX+7mn+7q3+7vH+7zX+73n + +773+78H/MAX/MEn/MI3/MNH/MRX/MVn/MY7d/zHh/zIl/zJp/zKt/zLx/zM1/zN5/zO9/zPB/3QF/3R + J/3SN/3TR/3UV/3VZ/3Wd/3Xh/3Yl30UDgIAIfkECQUAPAAsAAAAAPIB8gEABv9AnnBILBqPyKRyyWw6 + n9CodEqtWq/YrHbL7Xq/4LB4TC6bz+i0es1uu9/wuHxOr9vv+Lx+z+/7/4CBgoOEhYaHiImKi4yNjo+Q + kZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvM + zc7P0NHS09TV1tfY2drb3N3e3+Dh4uPk5ebn6Onq6+zt7u/w8fLz9PX29/j5+vv8/f7/AAMKHEiwoMGD + CBMq7KYhB4cdEibEmDBBwg4OGzQs3LjIRocYFiCoYHAiQQIFJ1RAsEBBRwaOMAdl6ADDQoQVDBKMMFCg + gIj/AwkYOEhhAYbLmEj5bJggEsUJBSVIHDAgwsCIESRKnDiBQmWMDUnD2uEQo0GJEQcOoD0glQRWtlLV + GijRIAYHsXjfaJDAooEJngWsriVBmG3anSICm2hgQcKNvJDRaKCQAoUJqVfXpt2MWa1atAhMoEgRQ2Pk + 02EwwEiRgIRVzp7bwt58GGuCFBIwoN7NJcOLFgqmDja89u1bwm0xo1XQ4oUN3tCt2JDQYgGCq8gLZ9+u + PflhBCtYdNAdvTyUDRZQlJhq2HBy2drdw1VLIsGCCqbN61+yo8H12O7Bh1yA8cVlFQIN6LDfgkjcQAEK + PmUXIALtsUVhgfPJJQIDMTzH/+CHPHj0wF8GWBhgWtuhaCJhFLZHlQIs6EAeiPttIEMKJlw134AXrihb + hvHtlEAEMeBA44IeVKcTbFJd+GNhTu5IHFolrPDADkfuB0MDClA4XFyy9QhfiyT0SFtoKUyQpX4yMFAY + fXClSGB7bxaGFVZlolDBmuZZkCOKYDbpY1xRvlchXCfMwGd5DyQgAlrw0aniAWS25WSLh8WlgKKL8obB + AwgEVqGEKXZH5mydjWCCBZ1C10KoBpAqJZizxlknYSOIUMIDM7YaGaiP1irmhU4aaihbOyHAQq++5gUs + npFGCiil8p0qW667MtssMjV0i8EFhjxLrXfkehdnpfJJpf/rsoVgkIENNmi7bR4Y4MABBzpw0EG+G7wk + iLgCwiVmmRlOO2BbyfIaCAYaPOSBBC+84EEHHPg7bx0ZcPBCDBWw8MADLUDQwscszBCDBBw85oe4A5t5 + q49xUtteASWw20cOHsQwQwsuNNCACg6o0EAKLrBQAQwd5HexGzfsMEMKCzBA0lYobSU1Cg2wIIGRfQAc + rXdi2kqoipjpqjAfOVDgAgoJIBCXZhaaYCUMYC3dxgY1cel2mW73zSIJCqjwwAQ6eKiH1+mySLaJMqMr + mwjKykuHBh5UwOUIBGQOQggEgJD55yGQwEAEFHRguN1mLAVBAwucYEIJsCMAewmyx17/ggknLKCCCzLc + dTgCwQ4sM4GYRiufXJHTu8MDKpxwXQEhRA99CNNHT70IWZ3QQO+om3HDBBEoYFIJJpVvfvkmmG+CAg5U + kMPvwcbn+JsGC/getmffocMDwYmQmE/+C6AA/dcTAB4ABTLgWvfCsIEYuGABtMvK+RJwuwlSEAGyY0AK + ZKAgPLBsVIGyVczKVSHI2awOGPBAekgAvRb65IWJISABqUe9AoCnAh1coBdwIAMHMAAqFAwi+So4xNdR + MH1DVIACFmAB39kBcQfrTuLegyG3GCB5dvCAC3IEmAEmhicxBCMMfWIVEzygbjrcQga2FBXYpQ99FTTJ + G+WYgPS9/66NK6CA0ubwwYBBCVB/FBTBBnQAmuVvDhtggQI4F4IvVoWMMOyiF3sCgg3pMY1a2Et1aCdH + O9bRk6BE4hyDeIIITECBfAQepIwXMExNiknIgtwh42CjBZBAegCkyiOrskuq8MSXLySADeuCSkxSYQcQ + QAFUENDJOn7SmSaIJjSlGccSoCQCMHiiKncEtnQBkoqKi4vZJMcGDFBgBW7pSSN7ScYA6hKMu/RfI0eA + ABVIwJhWwEAMHAC78UmTjtCkoyef+UbyoYAFaJRDHwEVtkG+LC4nShg516ADF4SqgD3x3zs1mst2vhOG + iTHBDCyGzyjkID2ym2AR1afSI9aRfP8UPIELckMHKD70RA1NkZdMONE04GACDhhB9MLoUV7y8pdHfSQw + oYcAF3SgpFK4wQtcoAAJVlCadswqQbXK1dA4QDw9RcNCWWkYdPWIWO2RZVjNkAEJRMAEIhBmRjkqQDDC + c6NGTUz0DuAACiQUqkzgQAUcYAIMom98AgXo60YZzTnWJyX4SWX8jDVCScUncWoZpxxyAIETFBIEGaWK + RwMTT7xuFDAhGMEJWrCDtQLWBhNwwQqgAtOs/tOlL8VqY6dJTQWk4KkK3ab8gDQn+5FKXViEAwwWYIBG + AtCooi0tdEmLVHgWgJ593SNgG0QBH86RiG/U6hEZG9CB0i6P2mX/w1jdMzBylTUtaEXeLNlw0hJcz529 + zCsvA/PcotZVdCwo5naPoIEZLICa4RUveMt31fI+k3YMaE561QDF4yluXIN03LQMeTo2NLABJCBAI+8a + Q+jm15dJFW0XKQWB9w1YCRt4QEnMF8cE2/aTt8WxSgNnAQ/EYawHO1Gd6iehXCW3nBPwCzzzS9pdNrmj + AaTuc3lygBQ48cVHyEELCrvSZ+IWlAJtsCeHWMfAVUBlbqhwpVhpvMalRa16Ac4B/vfLnkTXrilm50cf + 6ZMQGEAFOcSyEXQQgfWQT5RgDi/6Eu1lUfoTAoFWr3Dtt6IoFWqQO8Kfa8PQgRUYQMRThrIu/0uby7q2 + k88iXgFwBT3oCLgNq4ltJkGd6c+BermNDpjAhM+wXuJaimwEI5A4j6yGHMjABCEALV01yuwTQ1Kpp/7o + 5laAJVYbgQMQWKz4aB1QZ8Yxsbe141VpV4IIvwDNa6iwQ4N8IkCuKLMImO8ZcFAWBHBuyiZ29nTxW1RK + FsABq7b2ELQ84/OFUsezHiijTSK7E3w10mkA8nuTc+kgR0qzbHhB+Ao5YlLnF78nZnZ11flniFs7kQxw + 9GIdnNgFM1qUh9ZeNtug7sS5MpwTD7ZE2WCDB825rs02LX9NjOI6D7AnI2jAlQXOAxzMYAWui7WtVQ5r + C3abgga1wF/Fuv9N4RXKYCqy1oZ31eEz5MCiAHy20feMZ3eqnaNdvKILXMx0IXyvMkCEI6yv+vLGLnbM + RlyPArCJbq5PduJCjmJxB2TkE6IBBw/69IihjF+kBj3kdO0zVhhgAQFb2wYveMACxHe7vx8czIet9cGx + HhoreWDTXFhvFY3LTUzPOVtqgK1//gdyFMczqXRle6mRfpsJFJ7pgm1eP//5cr2LG9ZjpvFJVhBZCk96 + hNlBa7AvRaeyxRv2WtDyX8Iocsr7PvjRFnlV9sqAGNW9CBhA5gnq4+A5grL0qgd3eG9XxAhUO+JdRzze + 1H02lyEYhwYTwFz3FVqldlSjZXlsB3eJAQL/B6ACL0BS78cDGsACnsVMqJdo0KdbtFZQ4iU7DiADW0cG + ajYtxRJFP3Iu8gV+WKADigQ95Ud05tdREPh2zUWBEeB5dYcBMmAdoWF/jNZg3KZwzaRosoMCEAADxzcG + vSYtECVILdgejSeDVpADgxUq10Nd6IeDwGRqH2cAgJEAFqCFUJUkBxZEihZKH/iGzxdrsKMAKwABPmZ4 + q1Rc3IdpVTguPQJnZyAB1nF5bndavxdywPRRPjECCdAA95SBRoADMJBMQkReinZ1tlZ6mYhEcrQAMYCB + Unh9ZLU43dFmmnYGG2hvzyZlbidDRzVqsvhceUUAuqICKCiJR/BTOMJM/0eEhOE2TQLFfN2GVeX2ACYX + BkAWJZUlKLUnITx1Bh6QAiKgbL6HZ9SFYkN3V/zlS0VXALbIADNAd7pYBBzQAifgRgRVYw7GjgA1ggHl + Rg1AAeQ4iof3hy54YchxVlh4RfL2BR3AAgxQAKBlhpd3ftWFg2QYQ5T0ZwFXjkRgTrNlfzr2hhU5h9A3 + XiO4AKQDhF4AZPq4fWCXLj3CYWWAAxawAo4iTAqJZ9wYhgipdgnAAqIIkUIQkA7QJTB1WDk2SkuoWI3m + TwqAAi2wdMpIin4YbLQiNuMyH1lYBh2gAiVghjWkfsJXhiCXeQREAI5oTzaJBHuRTGWCf3IoZhlpkf+7 + hXAJ4ACRqIKTBlHHk3jOSHFphXtjYE4MIEC0WHSvOIZ2VWojlxiZQwIqQAEeaZOQtwLqCHidyGCM5WgG + 90xukyhG+QV9xB2l4l7ZNy1G9o9coAOvsjmipYPQ1nb75pfLJgLUowCd95VK8AKdhViyVnWm90l8J4wr + 91KAQyQp2AWIIyXF41Dokni355lawAEWsACYE22n1pfBF3RNZl0ANAIrEANqKHBc2Dxc5lJyiHAJBo/f + +U+3gwLYdJ1OcJnDMx+nsjjW0iI7FwY20ENTeV/N5oB4ZZ8O+JwYpSqQ5ppKgAEdkJJcFowLBpQLl5u0 + BlMo0JpioG6yIjZfo5T/UmGSnFZoBARJiyhlp0WLbzddQ+VbMFCT/jkEGKBxCUApW+V3fleM5cVVBxca + EfB6DUqKiweX7VWFdhKNYIABE+BpcmWI55dXRTeGz0lAoIUCujaiS4ADHJhS72h1JMhy7ghHsLMCMyAj + Rxk87IV4+whIZFIshiGIXmADy6MAcdVx3phiLjlaVrlfvrRXLlCZSloESUabKQqH4LZVFclwWpEChpml + e+hHjPOC3eeMqfgFXIgCt/Sjp2liDXiDS/aXJcIAFSCiczoEO2ABDpCOYsZtmkiR9ac+FXRNeWiZAVgu + LiNs5iJFOuoFMOAAU9F7eaaQVWFdsviX0aNaEPB//5eKBBmwPAvQNuA5rDYmR8BorOZlHzIQhVmgbsEJ + TmsGg5jhj+aZBOiBbNTTdi9pdPkJfKipVzSDTbvWq0JgA686OwmXW7HGW+14W/yHACdwJWXXrDQaQlLC + GRkGbGlBob2RZLc0V6L2ivnpe8+mn9RjAtVHrkrAAVTlbbhFltypd6kHsQmKAIEzAw+pBbKHmdq3lBKy + U8SGBSXqAp5lg9PFl8B3si3JeyFwACtQqgqbBA7SAGxTWzhWrFlFloimhIvVTylxSb5Zr/xIKy7YHmZS + nNU6iRzIcXO1ZBL4UUQKbUoVZdQjOmcUs0zQARWAI8vHkyz1d4rlk8SIWNYEAf9yagW9ZllfA18F4n3G + OQUd0ACAwabeWLCmeY3N+abh2BzzirVEkAFJko5hRnUs6mXCqK7ihkEOAANJWwQrKCtJ2ZS/VhgHmAU2 + EAMM0DnrVJ93q18vuV+ZBz0HAInj6rd2RwEQNGs2m3qZCJQs50xZsaCmE3tIuaX6+G5d6h3vablThQCd + U0Bwl34ktqZE2oA+UQIMarr8EQEpl5HDWIwZSbHPZ0Tag0O0q6WBQrQi5F7SWkhktwUeAAEMIFQLWGJQ + K2pPJrBqZ4YIsABtqbxKoAE3wgD95Jh01GDfdnoayYnjc01qsgU2BaZD5l78SBytegVCqKhzW3ndirJP + q37/VFsAAFaP8IsEHDADDoBBRcSYi4ZgCNpoORZECzADzDoFC8UkYzKo7UZIlWsFGwABJWCDm7tk27hs + fom+SyViCoCHFewEWjSgYXu4S6ii38lbr0MCJhCjfSsFNkVItpe9FWfA35cFNxADC1CNpPVC/pWhA1t+ + o8ZRQ2VPjTunOTADOSGb7KhwqKc+aElHzBQe4yGyLcBCsdJKhVoqEwemNtQClisBLuAo9HnDiSh8JJaf + oVUCRdnDTnB3KbdSU6eJuBmqFJkSCdSsLDQcs/IjxbOecIkshpS0HCBjc7ahjfqN+bZnHIV0JbAAFGCp + ilwENpIC8wdTNRalCEqRSrho/3Q0eDBbBY3yE6gyK5XyrMSVFgYwk1mQgD/XxWWIbzs4tUbHOQdkAcn4 + ykfAAQLJFl57sxcZj+FJjJ64AjJQuk1gAcFxGPiar+4ml/TzGYmCBaGcANFjq5cXnez0nKhMFZ1DAjFq + zU8AWyugwaubyzy7oo2ZoOUGAY5xBTKgmG9zWSEU0YzjSnhSAn11BRtwTr67Tmb4gNDJuR8dpCK2KiXs + z0bQAS2QcpdIrPD4bdAEjPhHO3LDArw6BavRJdByXOAkRbWiFlqBTfkkAazRXH4GctvIg+101EIaSQjy + Aib9BGFpGbKjvyCoonkKtp4YTaxc0lmrqesBKe/lTdpLRf/EARQLcCVWwKQlcKG/Z1pZqWKp2dY+AR65 + +NROkDYqUFhXnaeeStXDGhosQMFQoAGVyEWY9TVfB05XYQJ+KthP0AEp8GmAiZVdHJ06yIB0xnkZa9dK + oAMQoJOjhISfetCrNz7MFAES4MpMUMYK4BOmeIoEiGlo9SJgVQXfswJxBdKoObyG7GRR9kgt6wAvMMbK + ewMVsAJnuY6tm6B22kwVlBUqYL1VwKPKqSNClnNdOpJTYQCgqNpL4AEyBo7OHElfpHZ7GddrZwAm0ALe + vSDucgM3gAMbkAMbgAM4cANLjAehN1ssbdBYDc7eKZ4JMDftnQQV1RqeMSFzMjw8vRb/JRAB1dwE8usA + gEyG1wikgbFnrVhXdPG/fmADDYEvO7ADE8MB9M3V1YABOfACElEBIVE0FmAyL5A0f/BT4jusXybJ3jyb + iMUADTADvekE8qsCVQXWcKnJYOcdsTLgCTsF2OY85sucembecg2dseIA4+gHGMABElABEJACK7AAC7AC + KhABLWA0NM4NGrADMfAALhABKtA6JsAAY54CDzADEpADxD0GNoLc/tRJaxyqLdpyh+aEEd4EyMlP2IF9 + Yg2DmzEXK2ABNS0FO6AC1/HbEdjWRcqtYlRiq3K2dbDmM8C88+k5tpgVS/QAMaDn2DATMEABbt4ADrAA + KNC8KEHn/0MBATNAARKgAygOBx3wVi6Vv9NE7CrHcvaHEr81gyu0EyVCG9IC7cRBFSRwUJsdBTDAAKOp + SzWsb4XscXyWrSjAuHuwASrUM/Q7AgQ5AALQ7gPAkqqyACnQAqteDW3VF7Mu5iiw71IjNVyBAmI+5g7g + AhXgAb/uBkw6kbWFYB0cggQ9godWRyrQy1QwVVUlHAVDG3AiMMJhsS7gHFgwAa09V6ccsClLww5YQFcU + AaAeBxxAGTqhV5wDAiAwADXvOZ5zPVd0H0GuDBrwAizgQ0r0FCdAEldj9FMz9PLeGKyeBxIAAQdWO/ln + a0kYybWG0C+bBWsEAZuqHGiByaniGf/0dAJ3mNpZEAMlsDkD26FXGZh/qVeQTgH5rRdOk8Eg0O4fMAA2 + X/N7z/d6j/cDYAB51PPH0EAi0TpbYTVF7+8kUeu1bjUoQOZFQzgFrga8WFV894GDDo/czITV/r5X0AFq + M76BoSPZiytqAT0jwAAQYBdbEAMbjelFZcr5bLcvxDkiMMKEfzcwUB0mcADJNgB5r/c03zmdQ/PCn/wf + IJom4AIUnwwakGRG//iMzwD8fjXXb/2MjzUzsAOVnwYo56TbDLHNJ4ee5DbuywU44MdVVSaM900sYrEK + Tc5QQAEh1nFZeXSl3GQyBAQGkagAIrk6POWS2XQ+oVEpL0dpIAr/BNAA1O1qtV9veNsdEBCP3JTddr/h + cfncmZu0FiYFg3Hq//n+TlAYCA35ThQUFlIsJHZwMOgm2WwmHExMEhIyOTkzNUM9RTVLQkk/ExBIUF4o + nzQkLCIcGBRKDkaGhkYOEhRQHCJYXm5enWIQQEIKRAwKnp2lnw2Eoq93h7CjC5oVZDKOxZluOCYeVhBC + Bj4EPri4QMgIzuQH4OMHBARCUGZ0xgUUOHBghgkRVvTxE0gQikGHCkVkuHCBgxQPZAAk+GrHAxS3SiQw + 5WkTqZGkQG0iuSlkiZAOPBDEgGOHDBe1EpB4Bo1EAhQqIFSAJGnghAQFmDVr5mwptCFLhUib/8aUardu + Bko0cLVxkoYYLhggIOJljDwx9MyGIeOFi4EEDzRwlTuXLhMOLRwuHDQIESFAEvkY4utHgYkTjCp4iFT3 + TQYYEBaIVHlqVCpUkymbCOlJQYMdcnG8kMECgooVKBasaODCAoUXOORKOKGr265rQqA5pdbsWm7bSpll + jRGXcRsNHWQ4wNLuHdky+cqYYfsc3pZ+MYtn1z7nxosIiRYG8jN+PKHye/uYN2+YwQoVDypI4EB0O6wY + KkyQMIVKU0n/J1MhaaSQ9EDBBQ7mmmmDHDrwwIMddtCBgw1usGEuD5QbgZlscJOKKmu0WWqqp7II4YQK + YKsPlh1YaOAEEv9EIOCD5uyhB4x60uJCrXim+4CABGZYQ8UhiVQCAx0oUMGW8tIT5C/AApvoyT5WcCGj + IpvQoYUT9lOpsk7A7KSyk8AMiQEVgsSSrg5cUADGpLDRhqmoQpyGt9qAG8GBrdTUAIYWEhAhx3vsIYtH + tHT8orp78OGCBBVkSFHNSenCgQIXFjjBD79Q8GuwP/yKyFOHOkVEoRMSOMyFCl7IIRwsM7AiEQREAnCy + W1fKTMAEVmgBhlcpJUiD5I5KSqrdOJxqGxKXOkABFiQd0oYNPLCgAQUKYI7QtMAAo1Bvvz2r0LYSSAG7 + YNEdqIMWTgtsVFPDG0w9wORFRFM+VIvggQn/dAB2yA5mUOEWL3UFcxTN+FPJJRUq0IG+dMfBwIMWFAiB + gNo+nKa3OqNhSqkCRjjBBQmw1OCFBxYoAcYtGIUuDEKrey66RluGGYQCFIgB4p3FgSEFJ/sKWuhS+UoP + IvFC1dSPFSCgoAMLiczghRbCaqk/kURZ6WD/StEMARNSkMBfno8ZdgURNjz2Nw87zkZEpEJ4dIJo69sA + hjbXic45s9IS19sbCQDXOXg+IMGCh8lOvA0bKHBAEVND5bTooiUiet6jC1FEUwdcYIFfY4YcNjKXDBYz + k/0QvrVMkb5uQSPFxdkhAgM2jGpjO20j8SmPC3hrgyExMOcB/AxgTgBw/2/ku9C+z4gH0b7R2qIdAyAg + Dvbro9BghhX0uHeveSknlcmFOAWkXvNRcK8FChD89zsvc8W6vzBVl4yTFSgYG/s5NLDABF3WJqeOceNO + IcKYARYAA2m9AAIMgNGNePQtHU2Qb4lCi1r4Fr0KCqAAKWjf/kC4hBxYYAGPC4+oJEI5FM4LVChEWnoS + sQemOW0x27FUCk6wCgJ1TUxaS0mZSqCAFbAgCSGkhAciYAIDXAwqTeGYU4hABKsgpQAHOAELhKQdDejg + ICcwwBbcUYbkXbAsOxqjGGpURjO0owB7MmIIazDCPAzmfHx5V18mZ7kmkcoQ5rlX+vTlGutlhwMVSP/H + ATYTIJSYzmAlWAUDHvCZN07CBhJQQfEGQJUPYSx3HevGOkz0gCJm50gViAAKxLKOdzgPjWQR3AUPhSMN + Jq8e9xCACFYgAahNEnYY6AALMjWeQIzqjqQaptGixJAU3nE8e3AABCbwu+1wgAUDcwmZuAY/+01GZHzi + 5RwwQAEUoK2JuiMCsgpIxQIcYZTF6c6WDgCCVcoMlt3CkfLmsbx6UtBb7PiACBYQA/19E2I26ADKFKCX + JoUvMHUsVZMKUS8VeioRBVJBC2TwAg6AjjEY6MgKbkGryigsFKZoyTWFCAEJDJKgccjB9hCwE6vsQkS2 + Y1YIQmAABUTgBbukCwb/ciCBGXxnBDJijnRaqcEcaaEeNmKlotCIQXroowABpVtL0+VLYCa0IYVgZuQg + qkxjejWFwjRfelIjjBm8QJqMscEOLLCCa2IGaywR01xLgAKVchSrctjAJUhAxdp5UoBEwCkBQpAAF7xg + oBvx5QwckADcsIyC0DtLZc1yz3ncE59Q1UcIAsrXvqKrBjpgAUg/NTR3LfShdgwreujV2mESojAnaMC+ + OODTBO0gYOa55m9/iwCUDuK2vxptV2RwLQSMQKZJmeIURTACEiCAARDoaUdxIAEWoOCLzQFXPpravDQu + NVzktVEaBacPXMJAt8ellBzZQ75lRvQQYDUPWQEz/yrKTU4Q4AlGClhAAcUUZwNCpYUJVpFgBCx4FSSY + rk8isFYONNa9bbiBB2ySwyLII3CItdgYRJCABbQgBhtAnGN1EAMIoMAEBwjBjAg1j1mWZQwWfKpTnZO8 + cb2MgzCpMMQ2sD3NdRWFeWRtRPJYL6JBtI6QW4AKWCCBq3LFoBRoQS0KU5hPnOIEwqjA0378ChxMYMUl + YG42OHYAEzTAAh5oL4rjegCkSCeCLDMUP5uqT1keqkbVwaA92HFLFbwuzJPKQHLie2RkVi6ZjS5V+fgL + PngJQhEmYMBt+cVSueQAwxZoAQQi0AAVOMABDUgBBFpgARlIQAdvLjQccIDhFv+koAErWEAfuFqRFHRu + AmCmSwa4iAcSyNO7sXzZFp735+gpW0dm9FtlAy0CCEz51UOagAruFVYXSlQ98lKoQ1IIOfE4SZjCDEYD + ILBWTXMFAzfY4g5gQIEKyCAGEdqABk5cbTq0m0EvoMAMLMACVcNgBxzAQQbyTRAOzOBnJVgiO/wsQUO5 + Es8ZRLYYMJujiU91RiRgQcL1vR0PYIrce8Sva11YPsy59nL49RRDRsVmKW/HBhrggA5ycPCQy8XmHeiA + Djbgaq7coAMVQIGLXWnxzXI4vBlMlMTJCMuL29MMMS4AA3S2cywVMgV50cujo3RCcCv6e9o2OWzlJTlR + DeL/oqzKrdYrjAGhc8VkDD/6Ov5W48syFarK7nuNmboWM+S96ozqnQvOBXcVXdgCjuPqMfF75PrOdttH + QznmTO4kQjCtzRRW/OflgIMYNECygUv635V6RvIuD6pRzex5/7YoEIxgBRXIIui3o4EJgIWr36tv0TBP + 33j1kezFRGZ4PKUATiyAzTCYMO6hD4cMbOAFjVfHPj5w8b+r8bzjjSXzwK93VkJwjQQwge2jryJqZkqs + 226IHS8/3yixMMmhQvJ9lbaHJ7vgATHoV/oB8An+Ch3yI0ZgzHlubM+cTunEa9mWramiZ/yUB9n+aQG8 + KQDdavfapeyIT1QOYb9eLmnG/87kWq6hgua+7EVpLi0x1g0DQa8KGqAEYmRRtmW8HlDilkqWLkvjogPH + 8uzYzqAASmDaXFA7OEDFUKvcyM3+5A/+Uu4h8Mj+xgoKF8p8YggFLsL/PK8IX40DKKDMREAfaITZwqX7 + lk1vdmR5FNCepAoeIMgdQkABWkCSuJDARs97Ji2sxOcDl0zRXkgEjax8uipeGCA1GsBXWrAOw+ygXoR2 + poqyoEezcmzvNI6MIrFvkk7wauweDgACdgDkFFHhKiAFTsOsxifz5Gv+mEw9Xo7lwg6GJG22lOYEemWl + QrHajoQFGKAAbKk5Igh5+InpcHCMni71FAVwbKxRlkEEEP9ABWAAFG9xIOwAAhIioUwxmc5nFe9vtZAJ + EFkRSvhrvwqBc9gnGn9MaiBAAb7In2pQecRrAbcvs1zvGCsRASMQAQ9QBBTgAdzMHLPjBiSAGhcA/6JQ + ClEutfSr0VQR8qIQ5pRQPBTAAWbgg/yxpTDgBVJAGciAz57HgvTJEvMuDbuvDBOFz9yQZQLHABiABQit + Iuui7h6AFGHomIwMoiDCmCRHv3CSoW5SheRLU1IlBWSAIl3yjS4SAhLgxWJsW8gIAdXII28w6sZvDX+Q + zmYEBJgRCyuAKIuyLqjPlLwOD4VG7LKxod6FCXMSBO+PvxBB/4QyEbtScXQgAsTi2Gj/rA15sB4rcQF1 + DNBayc8YZR/iMAXYZ+7iciOqrAUawAFuDQ+X7DzAqizVEv/sjwq1DQrpyA+Q4DBDiHFMwM7ERekwkRgt + rrzKcAd78M4YBbGkSwFUCi45k91wgItYgBQLwzAUqtwEY6xycoUuRwTXsrVuMmk0RQXKMTZ7yQMg4ACY + o5/IKxilki9tzAwbsLKcE4zcQQRKwAEegAL+DzlVJAM8YBQ/4vHqD/KAUxvZctFcCBsJstxW4AFgADbB + E0t+aZwgLjTPsClZTyTRyDr5zB1h5kZm5ANCYDtj4Pbqsz5uYAcoICYZMy+40SyRZvKSSeUWLRtdsVOY + RCGY78sW/5RnYiAdVAlALzH2zGs0SfJEkW1RYCynEGABmoY+Q/TXQsMCVKCE4qs3jSY9vY2FiCm/tnFK + CBELFahG0SUDHqAEsiCpnk6fWo809c4Sp3QqXfQdCOAAFsACdkADDBNJGUNqZiFCWSjzXksQDZL+uo2P + jm/syo0WZQAawTQ7NqABwtBlfrEBXe8MI9Hv1kLq9MbqRgABVmAi55RSiA4GZqA08oKrgJQy17SFgO8P + lck9E7Itt1S0DlVFdmAFQiCMkEr7yqjiAo8tonKC8CFQqw7GCCBkLmICFHRTsSS7rGUJGa0y0VI9IYLb + LHO/xsMEUOABuFJWsyMDJIABPjXPUv8Tx+ppHmGvvGYpZhCwZUIAARxAKLaQWOuDJmQAAlIgR2eRQsvO + LHlS8o5JEJlsoRKBARBPU7X1JWVAAQhAACZI6p51ApfOEsPrDG0G0BhlGUagBBggAo7zXdOlQWNgeE5A + Dxy1Lx6KNym0Uvfo65rsUxwCGEbGXQ1WLjjAf+Y1+0Q1JLklDU+vL6MKOsBrH0DgAPTKO7N1Y4ekwFpA + SfSCfHjUR43JMunrJsXVfPYgAmCA2mB2IHLRBF6MwyhRZM1LsySQZGPmEW+GBLa0H4eWZxp0AljgJvxo + +MYNBPlwmHwSBT8lN4EhAqKpaunCoABlXhOwNMkQSkHSHtMoMAf/IATUDMpg9UvRtkgywBxm1hYsbXwE + d0rWbld7UgqtsGxhoK32ViYOKgFAAFQHz+nw0kn51F4l0J9aFQW4VGMbN11yAAYsgBQHsr/waCYh8yen + EE1fCxEsDWiF9nNfQQc8ll5RT89I0hiZdR7/9WIMwARUwAJaUnbJxgY4rVtrIYZO6C82pT31EGzLFD2a + iV27lHgJIgcqQAEi10esdPsAFUXvsu/uYUYI4HdTgFVi13oh5giv7GI35SDd1GELFxYvFDMFAViR4GXV + 9w1uIAZOYHvjUfZAUnxHs9lqRh7sFpJ2QG/3F11CowJiMiFUMGhUF0hXyxsBEXAhaVgbeBJe/2AB2DbH + 7JLO0BA69xUf3sFARyABGCAFZqAD5LSDIeY4LkVHHfU9H5aCgdPyWjEROJdGZbgNdMABPpV7cXeqUs8j + 8Slm1gjiTCQCZGAH9DeIIcYOZtbW8HBc6VcQa3IKyc0Bso6KX+EGIGAE7uw5QrLDeDDqzlhHhoAEFJiB + xXhnNGAHYmAWJFgs6UuZAhFK3NOHmeYC51gOMKACZoMX+/U09fP0JGhG6DXEHGB93m6QealBLyUJ4QXs + HoJTvkp8BiOhFsBKYpWS4UACUiBQ2EFmirEqAQcHYUYwEyACSoyUW6pvJ8ACXKDWFAIt36V55VccwaP2 + pJiW6UD0GgCT8v/BqfCSZPeTUEIgukRsr4gZq6ZlPBGCAdhjN22y5XbVZztDAjx3mqdgA1gAAWBsOsrC + KQeY78AokxIATVpFjsUZdnSgW1UgPf14GyfVdONzeOfZDWAABdaBs1p5gMXLxrpgBDpjAoD4n7HnSGCg + AiCgAba2q3CyUzD6dMHjoozLoeNgAyzAiw6wL591xmSEXgegAKgrworBoytMA8az63CNEMuSXipqAR7g + ulzapWaAASLXdkNT/J7KiUuAMHMghnfaiDKgA2Jg1hygos2Kj5eQacA5qeWAAx4gKZmqZmDmSVsGsbDi + BKApfa36m2A6YbtOEazRezB6FjUlE87kAWb/rqzjQAdmAAVIYF73wR262s4CU2UJdX06YIrp+o3qeAYo + +i8yOqo3JRhYgGoLGw40oHGQDp3/FRPlgQQagH2QOrJ5Cdgi+gFcgHQpapPzJdV6TZ49Wwlw4DFqARdi + RAsKVEd4wtIieXFXO+Qw4DhiYFFHrVM0xz0aIJDYSrVzewk2oCZWLAFoY69vxgCchTtjoANq6LhDjlpG + 4wFATQVUAN0ewAJmQAJywLitmwlMxlpurcVGYIUTqkqimLDLm5o1IAd0QAca5EE4IAdyYAPgO76dYFp2 + 4AUkIN5kgAImAAZewAN0oKH9u8Ed/MEhPMIlfMIpvMIt/MIxPMM1fMM5/7zDPfzDQTzERXzESbzETfzE + UTzFVXzFWbzFXfzFYTzGZXzGabzGbfzGcTzHdXzHeZzCp69BYGACKCAGhrzIifzIjTzJkXzJlbzJmfzJ + m3zIDzxCNCCcdTwDNAAHcuDmfq7L7fvLvTzMwXzMxbzMyfzMzdznJOTerBwDMaDAYgCCc7m76VzU7LzO + 8fzO9TzP+XzP/bzPudvUIMACKgAGPIDBY7zmdGAHJGAC4nzeIF0GIn3SJb3SKf3SLT3TMX3TM33IE5y6 + +1vrbCDWejtrF/PWUCPVB3LVVb3VWf3VXT3WYX3WZZ0PnuzUCB0GqLuzW1zRGV3IKwDgWEDghj3giP/9 + 2I092Yt92ZGd2ZW92aH92Yd9BuYtBggO6Mi72uq4AlogAmht1BzA1lJj3G2t3Mn93M093dF93dW93dl9 + AQyxu00tAtbnO298tzsABmKAyCV9Bvz934Od2v094Al+4A1e4BG+4BP+4BW+4Q2e4CuAAiQ+BiZgB4LO + BW80RwtxBUiN1Nyj40E+5EV+5Em+5E3+5MN9BVT+NFYgAoSizVmc0+7YAghd4Cvg5m+e2oM953le532e + 53c+6H9e6IF+6I2+6A2e5l3j4tPPlnE5Qlee47nbAaa+6rm76ql+1LT+6rM+669e66k+7Le+67+e67Ee + 3MOdMeGd461EvHmdxG//gNMmINjB2+Z3/uiDvuj1nuj5Hu/9HuhxnufBuwJiQD7wDfokZgZGmzE7nuNJ + bepRPvIlf/JHnuvTnuOlnt5loJ1eHAfyXd7sfuj7vudzvt/7fe/9/vSDXfVnwPSJ3uZhn9plYAI8gHEV + D65SQO3dw+wb3zRGDfN/3+N/3zQu3+OFP+3DnfiR3z0+nvmXX/id//Eff+pX3stsn8UzwI4rYPBDv+dl + wOdNv/VHf/zFH/yFnvVZv/RXX+fvPuf9XZBe8AtTHvmlH+x7//6bH9zBPv+PHwhWKodDWBwSj0Sk0Zh0 + qIRDFbK4WjhaLw2v6/2Cw+IxuWw+o9PqNbvtfn9t/xxYpTKb2ev3PL7P9/cF2gnuFRIeDiYaKv7xJVZM + 7GTAUVZWbkw8pKysPDkRdSpNfVY9KUENkS6tijKlToG+OoUWJXWmzHjcWPL2+v4CB1di5EhQ7Dnm2cks + +y0nzzBHP09XS18rW2frYeMpU/NZyMDo2AifW2a8PDSAro5STVVJLTXBw4pC2SvR56MmRcFXBdY8KBFm + 6ECncCHDhg03vKDACBA0Pc0sRqOYrZvFbR69VesI8iLIPTIk5HCosgwOCioW0DrlyV1AW0ju8aMSy5QR + fJ9kCpnlyt2+TgsiTDC3cinTpk0x6Ihhoc43ZyH5yAAkbRvFro40ZuT29WtWkf9U8YjroNSpSgwdWKxA + AeWIq56shsocyOpJzVK15gbV2UmnKZ46/RZBoULGBraOH0O2pMGDDBbI7mTdOvaq1z7XQDKjFtqat80i + sW0OZGGGBC6RF+aY0MKB3LkA573y96lorMBCA+uTZzv4KntSctuLItfCDgyvn0OP3oWYBBmrsY7sqtnq + x48jx5rmCs1zxT0wOKyV3suGBAsRHMC8qUqgp8OAb77LD5DVz95MltzkF374YdECBSmpl6CCKmnQwQRZ + lXaWWKCRtVF2ZoUXloQYZbbZVtrZMVUMHjS2oCU3xNBCCn+dwltOpXRil3850WhXbvgVl1uNqfDTiQvM + OWf/opBD9lKMDB9qRyF3F3JVloZhgXVZhhxVVZYjFJATJJFtbFBBBO3EiNc+h904F24D7pfmcKLMcgpy + BOUHowoNuADDJFvimScaUD3oYUhggZPRhx+e9o1H3HjG5HdMVlWBDCOmp+cZOrQgmE1m4thfToPtA5BQ + R4ypIz3/qTmjTUEV0YAMrknaqqs27DCaeItitxFGFT55K5TkTTOhlYtmBkggeJy0i6tndADBX5kOBYtv + zdr4opt8EaWXmzXVI9xOMNZiAYLHgrulOhVcp5WuE0oIJYblXYRVoBNxqGSh1cxgQQyshitGBy4ssIA8 + g9lmnLVmlvppfS3iQ6Mszg4U/9PCoVyBwgMl5luxghm0t1pnz4BDFqDmWjWoWbS6e6GijlhgL74We9FB + Cij4SxiNaxLnmz7b0mWqXmMOJ2OcAvcXygIotPAty0e/doMEliUz8si/nuWk1KaBBtavS3LYZHbMWMBC + DDgg/YXLMJNpWynwpEnffQHjKO2anMq8toxwEkxFxA9wELbejymdsrDQQP0u4N21G7IzevwJ9Z8dL2kB + BWDv7XK/1NLy7H0QDwUczn/19GlgiKEqGI+doupOYixQvLfqK2FcbyHxnntVRd2RJ96sWW9tOKJfzeA1 + 5HrrAAEnO5nZD00FW7ubQG1rqvDN077pKWGdeLu69SqpU/8veLgTOoji5RHKa+Dqblg7rST3obLqHDyA + ZiwNy1yTz/olLH+ZcAY4rdlOCCSjEaqu7HoCDIYNKEM1wn0MO1MDlu04A6+N9apqjjhJAFm2gRlEgEf2 + OVVd8BKcoiyMWn6x2cxKRzygeHAFKaiTsQboQmBAJQZHgqDHwmcrp9HQe0raTvcWhzVijehOetNADDTx + ps+ZAn76S+JegONE+5QpZ++ziZjkIwQIsMADWnohF3lRDAp0TzQI7IYNt7a90nDHVhJMY67ygCW1qM4G + L3DP8PAnPbfpKCBNOBheGDbFWkwvkP94Rz80CIEKJKSLijyRgx4BKMbh8DQS5FiickX/w+9UKBt7iMEO + Uqc3HMimX83TH274Yx8pzG+DCBPhpe7iH4eh4gorYMELhLjIW7aBOtaREiF45ySsFY4qWhNmojjiQ6n9 + yVyrkUA5rAerBwxtf2hrJdsAxhduPRFnSqRiPUBlx7MlxgEVyBsuy9mGG3iAXCCzISV1tR3eMcJjsSvf + rc54kWX+bnVdesnwDJYPy1UzCtpEjE9CSBw54ScmgEQVJxaQggm00JwSRYMOjhEhjQRTXvDy1e46ir7B + qStJiJOBJASojhY04CXclGK0coQ/HX0wegPro9kAFBzCMEEIEWDORHuKBohY9HWPHGrUYPfDQRVTfBi1 + pFlOQk4B/2JCRWFyxcA+VRBb5CgvLLXfVL1pnBP+xgEpYEFrfGpWMmCAAxGZXRsjCE+Qocsr9YyayZo2 + yT5gSQe2vF4OYqCsftKPOCgMyDe1JcWDunI/1qrf5Yb3AAnk86yS9YIcYAChy5Sxhx1iK0h72AgP1cp8 + g4jGBPTaxQ7MYEWyBCQUmbW2WjDUdP6DKQhXmRxvAgYmDoiADIw22d/yIAM7iAG5poLJOjBDM5sVi6O0 + QczRhMZRz4jucqXLXKo4SZOO8kBkB2iDDlTABSkoZZjKW0riubY3TJSJYdir1f01IAIQkEEigWtfHmhg + B8ZoxLDu0BlhdcW//xWqf/8gYAI78v+yy5jACzz5QhvoYAIWcEERYIK5JmJLeTHK2U9s1iaAcpBaVojY + FSsAgw1s8b6/vQEHPPAg15EnucIsKnatW+Mj2ViYMr7xjWVMXeRqUnsxeIEOKshFHHjAAi9BwYZbuc35 + 1PS2gVWlP5DDD/gwOQIV2EFEVXzfDQzXdbj7Q4d6aWZfBvit81RUymTQ4EjdcjIygEAEUpBSu1mYE3re + M5/77Oc/99nCeQZ0n5eQghRE4AExgKOXG80DHHQABhSIARilceBLYzrTmt40pzl9pElPupNwxqUNcLAD + OrDgSy9hAMxa3ep+vdrVQ5s1CmI9a1rTOta21jWuGcAAIaxwKjD/6ECXHa1iDOCAA/qlNLlY0LWUOfvZ + 0o42taFt7Wlfu9rY3na1nc0CZ8+AAhSIhA42MGqJYmADHpBKC1xw55TCe05UiDe86T0ne79b3vjWN7/r + zW8qpAACD4DEDoxsbBWXWgf6nYBEpHukhzvcURB/OI59LPGJJ5fiF694xCkeGhlMAAYe2AEO9irZG2xA + Bx6QQAwo3fIYMLzlMX85zWs+aZnffAI1f/nMd+5znLt8AhIgcskPbvQvZEADOMgBB3TQAac7vQNPnzrU + pV51q1M961ivetSvnnWuS53qHOAADjRQ7KOjPe1qXzvb2+72t8M97nKfO93rbve74z3vet87/9/77ve/ + Az7wgh884Qtv+MMjPvGKXzzjG+/4x0M+8pKfPOUrb/nLYz7zmt885zvv+c+DPvSiHz3pS2/606M+9bfE + QNJxsAGm6yAHGyi7BlKs+jRgwAYZaL3Zd2/y2yNNDusOzQMewAJHvbG7wB9DBlLuAQ+8QOcxkIAERs6B + 2i//aM0/dQUeAAEIiLcBAW+B8SkgAbJnn/k4UDgMKH2M1RwJ5hLYQQ5uYPv058nUkq4AC1pQ5wjU2aG5 + wAAKHAuAHIngXxew2A68QPtV2mhh17iJXLn9XgIuCHVYAAQg2pcg2qEB4Ad+IKK5gNc81fJNRp8cijs5 + CjmcnQVKR7q52P+E2dm9eWAHHtoNHtqcJBoFcBnwwaAMpYzG9FI4+Ne47cD1uaCCAFX/aeAN/l8HgmAU + OqELVIAuqF5aWVY9odHsLAPMvQAHtGASOkVavUAFqIgTPmEadqALqOGXiFUFMNrpQYSYaSFzmQz8TUAH + GJwYqsQGRJoMPIB4eWAARuEHsuEARgAbAuChpVTA5cL9gZ6RwBgOZReAGde4eQAF8mFTIBkg/l8hguAK + JSIAKuIiluIGrtCqmJ4GZMwWItC6fMX06UAYbiIMJVt1+J8KiGAIsuEKHWKd9eIv9qIaNgALdAAkdh4H + UAC4aUWizEsdao/5dYC51aJC3EAHHEO7LaL/IYriKPKiMALjNvoiI0LAeZzb5pnaMibQAf0Q/D0KDNBf + BVYjJSDZDISfBwbjKJaieJ1iMCriMIZgsJ2Y6F3jiylKdnkUSXREHqSMiYHhPPJCqTnIDKgIDRqiN4aj + IoriL3IjIW5jIvJU6G1AFtYVA4UMO/qNNOaAPELkGSAZuy2i+HGjRg4gTf5iN26kGvainZWj6GHj4QDT + 4TRQXOEVJlJjS6pBBqiVGWZQDZriPm4jR5LiVPojIdpgI8YAMl4eBuxAvRgXiJTMOnIGkjgKkWEfUpZB + g1hWBgJgfG3g/90kR67QRopiNyJiGyJaSvHWHlreuFgGo4hWUomG7mwE/5a8QAfggFZCZD22QBPupE5m + JFWOol2Sol1CoQ2Ol5b51ubdwAvsEtVUIjFNiUJyx6O8QA6cYy1igAbogAQwZQPApi9e5Eea4ltKpiny + ojh+4pccBHp83ga4ZrngSmipEYa4ooFBggQgJksmYQZMJPgFoG1OpiAGoDDS5T8mIk3WZhqG30F0AHNO + XrqhWqOcC3FCkKwQJ1VgCYmkZgLmV2XM4CfWJVxOJm7KJk7mozfeZxoCoAr8SA92nnh+plwBi9VklHWN + T4gY4Iis5Cb+IP+xoUzq41RSaFRmp2Qi4j7mZEeiYnxZAHd5HjGU4XWIUTO+E+2Ez/lA4DtmIl+mXv8G + VJQ26uMh1iRu/mM3gmI4ziRGAqNGhqN/zgCAcl4NAGeBhVRoliQ7Iqld1cFqUMALJCb+sVhEpJpF/mON + TqeOHuJ13iU/YiQ4JiIUdidCgKfkEelauqJbbWHuBBMleZawWMADOI4HICHw3UAOeGac+uiFluJt3mVk + yqaN7qhl7qmd9WaZSh4OjKhQzdWSnKgzgkcbYcQmwcAXKt/oXaNURKeYTugT3mhk9mg/5qZs3mVOzmV3 + MgbooRP/rdEwOSOk+tCBbpQzRAKKlV66cZ8mwGZs4mZHzqRU4mhObqlcamcIwqWduUAMIKrkYYAHTCL4 + HMrGAE6aWkl5aAzIKef/BtBi5nFADMzAAyziZe7mfK4hRpoqsOZnfvIpfsZkC0iAT/KfXX1GeBiKJclK + lJTZ7MhA8n0e63UrC7ibLkLhbHZpp/aooNZlhk4lZeLolRLif4pet1bF4vgKlCxQWEYqPXkHZgxblGqe + iC5jIHKgoYJgfrLrhgaqXYoqhZ4rTsbkDm4m52lA9CEkr3DWqyqkq9IOcpUEcmFikWGeHEiYu8kkKnpq + oHYpjQqqwX5jZUplp9akDSZrSYUeMXjAMQznUGlWunzEvOLsD+FBJGyr4mVADqwbC0DAu3mkbuKlp/Ko + lyYsjwYrIrLrZB7aA2wB6UGYt8JquixpyTBpW8WV/3kWV7hFQg64qOHlAAxQJHTiYMkC4waCI5iiopdq + aeRGJkfapBQC4AyUoOixYr3CznC+i7mkSzPuTnYMi8/K4tgKHotNQJUOYijq6G72aq+CKbF6Y6mKV+QC + 6+NCgAW8QHtuHp8oGGelLrtQg+kKykIS6FmghbMNW+L6HVQYA8Dyam4urHXyLruaLHZi50WKa0Zipvix + xqWqaoR55eJQyfmkqTyF1M1qYRCC3GHaquG5BSD66FveKOXSLfhe6MHubtyeqrFKrYYGYAM8FvqGnnCp + o2ZwDPImaTutKUexUeAg15A5GOB1ogbCpi5C5twirdNGoVTyI2VC7VwOrAEj6/8D5AIDg26kNZzN2qzg + WGyTNM3O7mxGuI7jMNOy0p0GxG672ZnRiq/C8mhl6ucAziUJmzD/puz24qD4HVJzZF+6RYSRQoiEVOK9 + Ji/5CMuSflSaHaDr0l1nsoOh5mW4DmKfeumwfikA4yj5ZmgU8299ylcLVCEQhx6eMpylAS5JvCp6Noo2 + wGr41Gz4dE0M+KbfzayXWOTj7u7SAmo+FnDtrmzt1mdd3mADQMAMTF+DWiBruph1CKe8YNKZJdAPBXLp + hog4nB/xyt0cOa4NPqET+mK6nnD49umFxi34WvJN1qAAsgYH8LHpmdoEPOuUsNFgeo/ouunTwJU3jMPn + 4p3/BlBA74rrCu8ihVru21JlwwbwJZesRjKiCLaAvSCmYmYfazagDClCtcZv4hxXz/KKPUdwDo+EDHiA + LLvdd2GQ+O3pLUthsULlLmPy3Oqu5XYgvI0gBawzUqLcuoVIBKVyGJ1n8jpvF6OR4uABDMDw2+0tuBrt + +HIqHGOnOAfwNwfqU2Iy3SYaJOQAO4shpElaBLHTGvFQ4txOKvvtyIAyAl4zDMgg5m6z2wowqDL05kIt + 1PYvMBog0aFlGKCcDtCsIEDSXUFjQjoq6t7zCjbT3XFAeH2kLTulACa1L4fvSq+sNq+1jiLaA1CAaS0F + 65mdDdD0b+VeBuQ1MNgAUImm/z3BU+Eojtcm8g7XwZNSr9rtQKqJn3Tm6Gza51NbrjZnKdxOIQ66ABZB + Qlg7BAagXNNZnbYesznp3uvJ3g1kgD/7ArJ1wAtQmoINckc3169gsPnw0BiNlgVMQMzCHQa8AEoNc6H2 + Lu6SKglX6H62tHyycWw+AD+LMkNsnwTAwAT88afFQHVX30NOVvMpHPS9AHXDwNA93w4cocc2hFLCNgR2 + FGj1tCv3bXw3KQVYc9xlAAxAwJwM7AjPqEuHo7AmLE0S6jbTqAsoGrGpxA20Zvc9APkVX/E5OAS0AAvw + 4Aabk4IbAzLMWCIwKGtbwl+v2wwnU62oYFavS9+OhzjoQP9fHx0O+BUIr+Gnfi9Usuw+QuVbtnRDC7QL + P6kxO0TzlXIg1iQBbnZNgp/jfKEZC5BEVkfXeNu0eaWIeMA0ejglrGaLtd8gaIwdZtIlvZMDNZDj7ECV + G9sFbAAFpO34VjIprqywgiK5rvRlzpuBFNxKjGSz9V9jSngL8Hmf7zn5Ods4+DYX5dcfa3m5GIJJgFEk + LHZEmq23+g0F26FQ1k5oPSoZpQ9JlXaj1YAyuttlomuxIu33jqPC4rh2rtD3eQ2CqwQOtMdm83mDy7qs + OziEN3hjpnNvs3jYTIZEULp1ranr8OCmvwEMPgiOuYvgZC2FsFVOhwg/K7nREQOaw7j/fOauf2syZf6p + 926qC7TAOIjaSmgA4wo5+Zn7rcv6ns+6hGPRDExAI3ORiMoQL231sIAc1SZ4DkQacRlp1n557CCVnyCO + OFgh3RHpnEmo5Ir608blcZcs0u43Om9ZSAdDs2bgn9v6uUs4rd96rPd5DFi49QCnOj0QSBGTiu86L0wp + cRWnhQA8mDOQaRB8tB+cmWdz0Y5r0n5jgOtnmDIx74pjqlP4DzOFc87ZZj+4ufe59yn90m98g9MZC0xA + o1fMI4PbTxfC+PiBs707mVtCuqncHzNqs3O5bv/6HYgDvs8dEeU3gWsoHDNtU3+pGiLaIZ0fzfeCW3gr + +J27g5Pf/8Z7PNSfO9QLXAXk7QAVJNpr+PN2hpOixBiyZhaSKLtYrEjhbMbeAUR7vaPdd9s/bChqbhLz + Y2XP8QkLIAG2wAxAKVuAEgt0/KwrPdPLvsD9fcfH+vF1gAstLiCTODs2jZsR+4lwAMvNEA2XvUaNZUdj + RvrMNd4Fd/ZW7pc27C87bTDvpPilfq0GfyUANK7DvuvHvsebO+DPOtQ/AAzgfas4MIm+b6xGCR4wsmOs + Zg6cGgV0Tdb7/mgyPrkcCBDwhENi0XhEJpVLZtP5dHZYjVQkVU25ItptNvLNerfcLvnr0mKvKYhFkrNB + 5U1MTmJpQVoPfovFf9gL7CMkFOzTm//ImWNsdETCkaiwmKmoqJyRubTM3PTE3KzknKHY0XhEHdLogJkE + nQH91HzlnOW87fy8nInZSP0FDhYm4qhAi6ACOxuzasZqZuYK22qmYntgqXjBwRie03iRYdHr+xsEPDxX + P99zaZHxOPWef8zgmJihFI3t3Me1DbVLBgwdN+hBsfdiQgwKu17JoNUv4C5ZEStReGHw4EaO8268mAHB + 2jMtJdOkcVaSmkqUVxw0aBOjw4Y4HZdg6CDuAbk/h/YI+mkoEAs/QwPtqUDQ5tIkGzxApGTpEkB/oWw9 + vDWQA9MlNjawggpLlz9+EGuNDQVLhgQO3bi+hbskB4wHV5yt/GL/xUUVvdC8iFkprcWMN3GRaJiQB0Kh + QUV7misKiF2fFntYwMtgeKkNHTA0RTUb0erEfVcrZHuRWXORDHYoaAqIFZNZq7RqVbJQIYYOeat9v8VZ + IUUyLCWLH2N514rdNVkuS9Cxwe1vDDpk5PkZ1Fzjx439FAV/FFuFCb03Ysig4caNDBlqcrThIcYtqWVL + k8UVm5Ki30S86lBIBojEsk2U0UqjCBRKJDCvPwc50oACCJ6pQiXAuLCwpeVSUKEKCybgQKMH7cDDBUOC + isyodCCTLCg+WKAAh40ywIGDHV6QAAYJJPCggxxwUI2eDDyL7Tba8IvtqlkssIACD0R0EAMc/zqYAKqo + /sFEovvqS6uUB7+0yboHNlyGL+SoUYZCvfSwQIZtwORBg1Z6Qgeox+wc6jt0iDqxMhkaDMarHSRgKB9s + KKEAhhd2oIkexPJ5yEB+uMxESy43kSGGJ+HUAMAJKGiIQIDoQ7C2qWJ4E05VvclABwpceKk5NPFarlY1 + rnChSQ94U9W6niqrjDvJjFrnu+30RKQCX4a5wcYcGbrEAhZYEEWGCSaAwYMQvcEhBrGmKtJUiSoKjbaB + ZIQTAw1srBIWAkehKskKoILRA3RXxTcYnFiwS5loTEqzQiwWm0CH98CMzwIIyEHREKIggyzFn+j8CQIX + WFhEGA12iOHIBP9fUSuGHaD8BQcKmJzoH3CrKlWqWZaUoYPp4MRhh0/5YdnjiCyIIeN8f/4lA5Ae0HAZ + MmS1Sw9eGJ35yzpiUCw78VIU1rGJ9xRvp1y3Aqa1DmJg8gF3q3LIgkNlyiHIVEym9raKSDX1Y0+ipTbV + VTvdAYZQ9cGqyGopmKCDg4EmvJEbOqCgruEWJ+muKxpQIQKeO9CgaTBzCIfohodVkc51hPUujwgwBqZm + QutDGS1XbolBgh3uRWWDkymBrW/RyHo5LU72s/dnKTmWlm/8KnWXEk1hLzx5RloFW2sXLE6Dryyed6cF + C2DgQG1V46vgKKDsvBq8O/m0WsWjIJhhWVT/bpAv2m91ubRsSzQluZFu2y4rQSVHG6t2iqzdgeXA9LuO + CaghK+uEgDRBgRjA4HXKg6AjvOIBz8zgKFpIBhpM1CZseSAHAgTT/dLBmHJ0jliWGRbFgPUAGSBveTrA + B5Oikj9JzS14vMheKm7QChpSamVowdlU3gWD+qkqAxtwVpU0MaBKyABUDXxBB7YVQSo2wgY4aJ/Z9pIF + y1jLA40inA060D128ClPEPtceCb2vUPMgIiosAEHJCADfZCGKpVKkEMqAJ1UCG0+cZtNuGw3N0uRRzrJ + w8BXFPKpzzixgzm4AQirOMkmrGsHHniB3jJ1LQn4qIirwgAHYGA2PBHL/5RCSRGL8uQ9nnlgcHPYwAvm + czuPnYU0iHqB+hpRHQlQ4H3iyg8egwlITHlQeerKQQ500IEbeWAHOkgmkCg5TUdgwJoZuIEG2mMD7RFu + A3Mq4QlZFL5xVg2Va9ElIzDwlNWRqnZZMk1sROFKVNQMH1kCom389rLhXWIC8aiiNW1gA2tS06AHRcUO + yBgZoKxSfOYzljh9srBSfPIJkSBQgWThN6nsYkGAkkMoeSgpndEmZbmoYQ03sRuEttSlL02CnCzgjkJQ + rUXhPCHW9tSC5/UCFaEE2wzhNylgSopnHHilHNj3Li3FC2Sz0GhEUNNNmFbVqlTMwA5ksBOfUIw7VP+7 + WovGCRl3wICqUNgYBVgg1B+SJpC4y0ebTJGKnHB0qOUaav9C0SYYfPCqfwVs4URqwVKe0ZTkXCXFvJoH + CwTwEZyZI6QE6bb88M9dazEYKnIwAfd94naXuk/uJtUmTaUzsKdF7W8iYbaprRIQXnWtOoKFDXYEa4+m + lYMGPFCluyIIn0JEYLRyM4G51oNKdKSdb50at7zuQxQVTW10pRuXMdK0WHcS504fg90XBQJ9MMCtHDYb + GpWFK56xSEsmwKvDHZwspaTZaD9F5dYJhHe698XvLzRwh+eh6FjhVON2bmrGyhBFDxVwLCo44K0esuxA + w3xXDLim4HtOVpgOfuv/efdKAcHl18MfrocOYsCC6mHDv9l9aMOQdVgW1PcXrnLXD30rY/o0twId+MVH + fLkyvM7Gx28Dcj/a9AZJgtjIRx7Cgi3IsGEx9JQm7m6KH3ZGJyV1Djl5wJXk6z/g/ph47sPxL0QJX3f2 + lsu4G8W8UAVSJLcZxPEh7GzNKbGjEBiik7Ft736B5SsR0m0XpqyW8nFjYBzOl6KSjV0/GxCAUEAHRXZz + pKOLg8Qs5sSHfS3nnBwsFwXCRDFwoSN8RUuVetl/KW1TmEs2J5L6ELhkrtSRrqKWF7BZ0rc+7SoqYLGG + Vs0y2SFKRBuaHU4fpQIeEIYOJiFUPIqGx0kCWaqF/4G4d1m2y201kLhos58OWBTX34YpBtob7MbsFB3d + nbKe0t1aTvNMB8kWR6uDbBr0skzawcBcqKpV3vd6GX64gAUFCgNugv+V0tJiN21LqKcR1vRX5a4Mz4oL + DGUziZZF9WGsyxYzYdhDEkyFDUUerDrnigYj3i54yiep7KyhCLEKV7HnpEYOi83gi8MYNXNnLMhaRovj + HUectFJKbyDy06SBrIWLVb50g0aC3MTOdFevth0zopKreqCAz4JR8dzI18Lk9azPVR0MHMAAUt+iSkmb + CmFSZQKgTIc7FdPK1T7VGXQMr5oKr04wlDPCV10n+XK3NJZ7C4N7+PyxooHYZf/EJ6UDZ4175NM1buws + 9tzmy24ZvacHPVxmB/PgOpqv/Vb4aqnwydYb/2r86n7bcpgVYOC7JT97fJkMO8POg93DA9HubNq7fpCJ + rR+Rc9LrE9DWxsRlxq4vHUiC2aNne7PJezs3Cp/216duSCKwQu+YEFnp6PWw+bAwN9gXFVynMbis/TbT + /5xVWq3jvELL0aj+exT8wX7+fbNai1l9MU1WJcRCITXKgxlYPnhbq5OqrH1CKYA7vWHYAAYjJKfanwaU + FyEaECfpO/3jQG+4AcrTAxUrNicjn94rBPL5ieuxvuFbtgZsNn6Dm+F5wI5rrzwqEFnrJwaEKsApiA70 + QZv/WDBSujzZGkI82T3aAoqF8QMOs7I9ize4gTYbBDuyyAf3m4dvoqNvyZ8YLL2zQC9LQKcfFEN6WKeQ + 2JxeWzjDmoysQUGkGJmNyIk+e8G2+jNX2ytCO4g4qrAMcza9Oj6QmQQrHMNBXJvEiABL06m7645BEDDx + AY88YAEYCLVpOw2kcy6dAa2iqsIDHAbdCrk5LD6VQRJAgwXUWEFCREUlYJ+tsq6Yg7LdC5+8E4oHOLYm + pLgsrA+8qo3pEy3QmsFhwIlZ6qgLw8ThqR0Ng5SCgbxUZMYjEKOTAZZfM0EnwzTXgkU/IA+to4cxwh8N + 8zNQhJeN48RhqJlZ+qVCckEa/8s2/NCKZnRHJqA0y8sumVOsU1Ij7/oQOOgI65DDM1vAUqMUqBDEeUik + F1idPkQzS2m2z4KHDXxHQgylreo0E/oqehSr3ZsWrbGA1LAJbsyKjNpFpmK8U/vFeeAAtUo0Z1u0oaMI + Slivh4TJISARJQSdRATAcpAYmRuEFloKfswNP2Mu1uNCWChJb5ATkZQNqJoseXEuaXGSU4xJHwQHcSCH + NCQnYwkwh2FE7XCjZaREaknHcblBaAuNohyGrAqVKESSXFQ8nLGWx4vKd3SVabk0YQOwKUtEnxAPXpCZ + nsTFZys6PxxGsWMKzJHAQPMbsexFohKFvorLZrwBCdiJc/9Ao5siIa2MRfDAuk1ZCm4stUiZPvpLC7ME + xjHDHzsykrasrIdIsMccxFCiAOzQPIjrvRJ8shdhKBOZgEmkB34kvdT8xrSTMdI8S4MUmxpby0hZzVrC + JwkwP9e8vjqYoxF0GIZaxBQLHZfbCRbwAEgbhpxoG70SuXqDwlcgzmHggCxUC/orlYvzMdMoBd6ETtqL + zBn4AyYrMNm6ToeLMnbzgxnYzbeIQ2YLDWNEygfbxLdgn44Zz1MjOuWaCFsYEDV7w/nsQGUzEe0Ev+us + TZx8umA5MOzxTpyrxOXswtHTmQR9C6fwFsB7tS70uvxZkp6x0A70ABbYAiSkzZrKqcv/lBpgWYyY8UrQ + Qy6V/Mce6zHChIu5mITV+yx0zLg7Ur4a1T850RyI07z9RMI7wb3JXAyfggtlO01s4yf1Iyr9GEibWCrQ + RDoz9awkFQ0W4kgqpT3OUCuadMVO+7WthLI8AdJgkYHW5Aqf9MJgIjq2LL4phYvq4KwvXDvyrEOLiBaB + aws6nb0NmCPvwtJSeigTU6U76zxtgEpvEFMtOxDhVM6UUlG4OBzOop3Fe6o5FE3cII+Js1S426zuicap + ycxzy0o6W4yFaTG/igtCrb9JMdJmO096wIFweFVYW0ym1B18wojnvNVbE7fTWKHwu0k6EysV4bTBoCfD + ENNEUzQu/0PQVV1UarOPpZS3J8UUlrpWpssACTgWEVREw3KR8AsKDlsNn7y4fBJFM11WesDUCnTS6JvV + XPy8eV26DIAa/Ew4rGm4hwkPOhHWPRpV0CtRHvutlik+pVRXuMgAVsgjeeLFwHRTjzq2EXXYI4NYNGCj + clNDD9VTVHqe69HGMC1SBZxV4cSFgmVWjpGsLfxDTIyfSqGEF3DZlwWxG4iB/lOxrKlOX53GX3meGajU + f+1YKMVABH1QoXUUCXgfjUNWpH1BYRKuF7BFp0WyDJgAqV1DrVy4eoS4yliYB5gAh4RDXIxRf1zH4suN + ceQKDDDIPrMlswi5CWRJ89zItnVbI/+zgUoTv4mURRLsvsXwvP6ouGzLRX/rB6WMwSqUPd+AIXrLHYAb + WLONDWoZ18jFNRt4AYWh2WEjMJ2MRe+AABjJpf7wzNv4Q8QMR9PDQ9/QrXaZl446VWC6q7SAh6aF3fsq + Q6vrVJsCq3LAWhZgC+g9CN9UP/r7RJ8dzTSNCyzCRbzqRcYtTzCcH8KN3iPjx9rlz68CsMNqAcnZAcjt + zI4FpPA1NbXwMrHdiJNsmyVCTi7EEpRtx/fFtc2SFkTc17ssIdjKE4qyVqbw3tAdSmyLn1BQ1P6QqSZa + 3tAyVwzMhNJiYFxbRaqVsjXivaqlxTn13a71H4gIOQNWPxv+XI//It+4qI6O0TLY0GH5u+HkfbZ9ELjM + SmFJq4ENmICns0icMsJpmbIglQD55FnEzYUEXkcd1mBMEOCNaNUmRVc76hv5wwWM2Nglli6hMcPLs11G + xEmKHYqXfJDfDVn2Dd0tbs9N+GAHiSW/3Z/FTSCvhYXAYeNvw7J99ZyrNbc6sbkhfQvv/SHULdQ+3qse + 1gxq4xIv/lrAxET8S2RJWy0oBh/JWLdy8oN8hJPfRVTldT0bVswsCWOOiCVzFK1jNNPU1SORkeRRlt7O + wIP/q97LXazJ+eVB9dvvlb4L9EKS1GTDKMi0hGUN/t6sWLZSWGNgjq7g0AK93Faoo848cIFa/1QVV147 + XTbiejs1JYWTuQDJ9ZxWyyrFSNxmbo6uj7Ag79lUfF2hy3g7OMlgXrZETDni4YxmzdBDAdkntpyKAaEN + ecVnXCtZb4nGcA1XrsJbxfiQHlwVVx7MTKhAWcNm80xohZYjJkLKdxpNXngD/Z3oDwvCmdPLhPMDGXi0 + fKFkpAOIG/7i5G0iWj5pzQgl3kqveR4bMMwl7o3p+4qj1Bs/xQhBvF0YYW2SwOFbw8DjdlbIxQ1Isqhl + puAMCnqN9MqSGFMz1wGjpiY4e2ivYUaDql4Y6tkDzOIGoNnpXQYXB21TShnZVRGUKpGhwSZsUuikQ2Jr + lZOS48qHtaJiJv9pGyfJIcIBaYfGkk9UEnsb6v6YEll6jddQIFDZpBfgACxO7FvzChvBkR3RER3xgF2B + JOXJ4K/VOOWtbUQty83uDxvQgBzggGW6pNd+Jh3ggBzQAJg+bVzDgGzCAQ3AgfVgagdBZ6/mYv/14qv4 + YwhCj2xij+hO7u8WAkp+0NzR5S0O6b8G7/RGLXR2GSLWY71OyUB0X/Wmb5jaaV0ELpJ2aC3J7vr276rC + 40uOwVnL7Duc7/9GcErixudLvBxM19PIhgNP8AmHIOuIZ1tSLngVagmn8A4HGiWDVbuibQijgAnz8BOP + oFxdvxlD1oStBMdE8RhXnv0SRkPNmdUEpjX/k/EdJ5ysmiOLO+g8NlqxgA7v5vEjX4qaQUmFBMpjFS54 + uGAkl/JFJeCfZOdkJenGdjTknvIut4mDC2LUTMgjyZLy8PIz7w+h8aixzJnGzQS2RfM4X43xQmsN5+pR + oFQ51/O4KNmPIyYElSfDVuI9J/Qkb6+zs6wlajValrh7LvRHZ4Rm3bE6EmIMZ+g1nxc9g/RN34hY0puM + SkqHiDHAWWpON/WDqJEX8CUZQsoYC54mIW3TPvVZt6JYWnUGTy8mcZO7pvVeN8oOUIgYYFBMv4iF6CRZ + 9/Vk/4Ykggo+oJ0G0hZeV/Zp15cN0IFBYSRemAAe4YC1pvZvBwYM4CYcfSB3cmePZAb3dFf3dWf3dnf3 + d4f3eJf3eaf3erf3e8f3fNf3fef3fvf3fwf4gBf4gSf4gjf4g0f4hFf4hWf4hnf4h4f4iJf4iaf4irf4 + i8f4jNf4jef4jvf4jwf5kBf5kSf5kjf5k0f5lFf5lWf5lnf5l4f5mJf5maf51AoCACH5BAkFADwALAAA + AADyAfIBAAb/QJ5wSCwaj8ikcslsOp/QqHRKrVqv2Kx2y+16v+CweEwum8/otHrNbrvf8Lh8Tq/b7/i8 + fs/v+/+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2 + t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy + 8/T19vf4+fr7/P3+/wADChxIsKDBgwgTKuymYYOOHRImxKAAQ8IOHRtuLNy4yEYHChYgNEChIEECBSga + QLBAoYMNjjAHZegAw0IKBydMHDAQooCI/wMJGKxIYQGGjgwxk/LZMAGCAxQ5EyAYMcKACKoIEpg4wcAB + hBg4lIq1wyFGgxIjDhwgQWKt2rds21ItkWICh7F432iQwKKBiREirqodETfugbRVC4xQ0MCCBI15I5/R + QCEFChNt36413DbzYLUITKBIQUGD5NNiMMBIkYCEgbRuM5NAsLmwYaokEqR4gQG1by4ZXrRQcDht4c1q + 2R6g3Zn5YbUnWrx4+bt6FQwvHiwoAbe28ri0aydXfrjEAhYdrKuXgsMCitYGYrd17jk2crc7c6+oYHq9 + fyY7pMDdYZ1pthlznC0n32cINLDDfxAicQMFKFh1nG2y1RZegcdZhf9CDEhFKCIPHj2ggAgGzMahWwjO + N554sVmlAAs6jCgiBxRE8JdxLrJF332cIcjcayZEEMMGNkLoQQvvGbhiZz0q5xx+ch1g3gMeJPkfDA0o + kBlhyH0XZnL2cUZeaA3EoKV/MjBAHpnfJeijd7FtCBcKMqy5HgsK8ChbjwqSV6B4UI5HAgMz6GkdBg8k + 8JOYg2Y424HItQijAokqWl0LCBSQYnh02nZfmSzGVpUJFmha3QOdEgZpmHbaZmmhbYlQwgO9qYoaq4JB + Oumfc3qW4Y+AlcBCrrpKxiuP9sHZnXdzOlsrAscm20wN2GJwgSHLBhqmmb96C6WYhxlALbKCYJD/gQ02 + oGvtHhjgwAEHOnDQQb0bhBhIt6/GSSWHP457QAG3ussHBhpwsIMHErzwggcdcKDvu3TYkIMHMVTAwgMP + tABBCxyzMEMMEnAAWR/d0vcrgoQKGupgtuLqxwYYz9CCCw00oIIDKjSQggssVABDB/1R/MYNHcwQwQIM + MHDC0yco8HTTKbEgQVgoI9Drk90x55ylAR9ga7Xw5kCBC9shoBxsyYW2wgMwIGk0GxjkUFOXas+m9t4+ + kqCACg9MoAN1evD7ZIJUigfqoFUhILMeGnggQ5cjhEDA5ZeDgPnlBRzAgAstTTx3GRpM0EIDK5yQQAms + I8D6662XsNUCKrgg/8NdhWudlsrivuxiqMoRTPYdGOzwgAoMTFVATyE0z7zzPV2VwAkNyJDD6GbcAEME + UZlkglYmhe89+N7/XYHceBheKpwuk8v1YTEbPIcOfIpdwP2BBWaV/vmLgP9rC5AB1rAXhhzEAALvQYDr + wGeCBjLwgSVQYAkY0IAK1Ch9uvPWiwr0I95FKzMiOBfxPMCCBQysectDEYp8sj+rGGB5zAuhA2ZwQQJ6 + QQMywElJSiC+743vez4MHw+1coIVWAB3dlCfnMLFoSZ2Ry7mGh4dduACBVgFf/rziQpV+MLA+OR/B1DA + AwZoQy1kQAKsIQHrwCe7BwLRjSbhoRodQIGT0f/BcE0U1LjyyDLyEOxxdNiAiQpAAC26kIssNOQKveg/ + EBTgBBMoWhmvcAMJtCBtP/ThG+HovTby8AQRiGQSMxg2cf0uXOxbW/zqkIMKoIAEKOTfImfZQhbmj5Ah + aBAFyDhJKuwAgaobogM1Sb5NDlOIWmFACiQwyq19i1QZSuXK1BJCQMYBAxRYAQlGsDxbtnCRLvSULLsY + gqsgQAUv6KUVsOmANYYviCZo4zHf2EbyrS4B50GfHJRIKYCNiVxkWkvjpAgHHbigU1/s3xYX6ilbzjKL + IjDBDESnzifkwD1Z+V49hQlPTsqugRotwQkgwJs7krJOG5QPy1R2HMA4Tn7/bKCMA3iiRS6ucH823eIh + w9k8BLgAiRV9wg1eUEU1auWN8USqMX84vjgqwIgdgOka+CmtZpWpRyyrplTTkAEYVFEEhbxpQ7PYxbLm + tIv+W94BHBADSQaVCRyogANM4DpivrOpxqwnSLWyxhOogD9zSJl89njV41x1MFHcKhpyMJyBhbWmiJQl + LcWJyOaF8QE7UOxbhWCDCaBNAUPMZDEfeFSQKtWHsktBevaZQX+9yYmJE5hz/ki4N0igQglFJE53q1P+ + HfKWBiiBA2RA0c0aYUI40aj4yPdRN3YUqUddnXlKw1pnLlFIlVLcmFxKUDZctATNUyhlwwnORKJVtywk + /8EJLMBL4xpBAxZYgAKC2FzTcnKv0N1kBBkgHbeyQbCZiRV+SkWrfk7LmmzYgFlIQIAQ1JKsDjWrb20K + WaC0QJ/uNcIGWBAVIG5yuRoN8XJLO+IS/M0CWYKDEseF3SUG6k/wK9gbMDABv6D1ir2lpRdfiFbzQpgE + EbhehpGQAwjEk6kOlOdHPZxf6N5TK+az439PWuAB0ypSGnJLCLubBg00Nq0QHes3JWxWMuPPwQ2o4ZCL + YFC1Idme82TqOx3IXI0q4Kcqbi0HoXWhPHKtcQhWQwdWYIAGm1eREB2nQxP5UFyuYLVrZnMEIhhdJMvz + zXy1KwT1I0o38HPPChJXH/+9hh/aumEDMjBBCBypUHC6+ps6RfQhC+DIR0faCByAgFTwe9djNpWNex2f + XqVSAhQ84DGepjKdoFmfST1RLlvWbBhwQIEGIMBy3iyvoh/s6mz7r8EOeNCticDYEzQ3jvmNbn2DrdTo + HrmINEq2dQkcp+YASVThWSUbiKqTFEL0t+G8sbd3ikhCGkAFah73hhlQEjk72cO/TremTUBBGMh7dyj9 + Z2zHJC6XBtoMNmiT2PL3W1crlMyxPu8XQzCCCAB13DiYgQPmy0NNXnq0Sx2x9yB+TxRYAMNooGp2f7XH + rxmKmjJeQ5ERSvJD99YAZm56yrU4ghJAAOiRzkAMUsD/8Jqvbp4iTveSk0rMkCLgzjDwrxlWLCdDDapl + BeKutL2wgWyOoMFQN6TexTph31I20f5LEQpm0N5I28ADD1jBDit9WtLKk86M3/n3QrMALNX2DAAmE0tR + 6qt+iu2larABl0rAE79HtswRfrWOlzcC3UyguJHGkV9YF+cPa7L2cPyw7J46A7WTYcUbitOUsKrxgc6d + C0VOwG69LdmzilnqO+3JCBhgAUiPewjFG05uel1MpIaW+w/fK+sUEAFxpyHztBo+0RNnqYHd6vJlgMEC + Sr9CRp++rLLmX4TFSesDoBP2t6YBHLYccTZaDGRaYtdkfJUAw4V1Y/Bpp6RxbScl//AjQmigAxZgAt3k + PyfHaCjHYz52RWUWAgNwAC7ggNdHAdtRTzsHRyyIbs6FV8KWACgAAWl3fnpGKW7XO0RnGBsCaMeXBRsg + V1rzP1BncrCGf9vmTSz0QgWQABYQhMa1Ay2gePd0aac1TDyXc2THXCewAC5gfmunbDt4ONG0ee73cWEg + ASuAADjFgSQ3YTw2TqcnWTjWeg3ATNeHBHuBQMQWRA4nZ5n2dfdVTE8FIkGXg4VCb+HCMpwXY2r4BQJ4 + bR44WQ9lcjumeuRkKyogQHuYBKUze0JEZx/mXAhYdpGnUQzwAAn3gIoILQFVVd8RfNPCZWAQICLAatCn + bbO2U/9/l3LAdQIV8HKfWAQc0ALmdoCDmHuECGLNCGfSZQINQAHEGAboByosBS6bB22gVwYc4B60Vk68 + dVOm92Co91BOSAAHJ4bFaAQYkEPz1Yy8ZorMyGu+dhJg2FZjOG8tsxZG12wEhnSRyAXtsQIJsIEBp2NI + OF4+NktNaAIsAIDtyAMd8AAz505JdYBKBog2R4pwFmIowYr7iHFQ0kcr4nbBch9/JIW+ZG2A8T/ZRl5K + eF6AJ3CENAImsEwTqQR7gYxutoWMx2Tu9lyklWQJoAJ6+HuvyD7+2JQ+qBngIVDmMpBaQGMnEHgcSHBv + iHKRdVZgdjm6VHg7OQQ4EAPt5HX/HNlJpdhDHTWK6nYAJzADQuaK1lUYpCYte+RspfZ+ZKADEIAAICCO + dOiLCyWT4nSO+dMTEoWCYykEHuACOXFkyuhkDFRf9OiRUgFKR6KUgmF0z1Jv/jRY3GiLW/CNC3B35bR3 + y1eY/XNecxiHIDgCK2BxjakEGzADyJOW9TiZlYmK9CQ7YAgDLBkF6nN0rhWBZZJV3QgGGZBNJQBmWEmO + M1mOCxVZ9+MTONkC1VibRNABFjBXdSVid7WMS2VfLwh5JpBPdOknZqJSG2eXL1IsVHkFHeACpHedjLSa + YyZWvDVrW5RCCrBMEsmd2OECmDFnJNZu8HRupvh4UnFnHjCc/08gWHBhb691IepXINEWBp21AndXUy6k + leRof+QVeB54P460AIjInUvQHskzbGE3Wo/HczJIXzxkRK3IBXiUkscZKLFCgdS0nF3gERCgABv4bzGp + SHOIYwAnWYRkgtvJokRAYyoQmXaVbu4GfliaZBOUAvoIBhRKJXYyJf/ilMhhfGCQAzOAAtcWPTdmU7Bm + ibWUhCsElxUgZVJ6BB0gV+aGhVfqmzXKSYRIcS6QYl+AR6Pydj1oVahkal8gAQ6wTXGYY0mIaLEGfffT + YHDZAuyYp0dgAztQQlKBc0CEhYGIioIqXHUEpq8oKi4Gmgsid1/QHhr4RYf5d/iHeoZ5ev8N1RMlEAE3 + 6KlLkAET0E4LhHtlZ5kZWV+epFyss4qZdajKFilRsmc9mm9JBxwTkAKUWJ3lqJqVWJ1vKAKKCVjCCldV + xEbPSEw3l2k0envChgDUMwPWtwWfRmqFYpL46hweJ6FJgB0QcAIHED1wioTOd6kyCWadswKGeq5KkAEy + YBlPBnEKOpTQmJH6tWsMoAKr2gXoB03bGIuLqG9b0B4CS64weXJwqppIKp3342Ce8wCM6bBDsKcpEE9e + 11QwCoMWG35XeBLa6QVsV2Urso1xt6Fc0AEqQFMOhSKvSZMJabBStzwGEB3TQbNMkAHGE0zwil8KWJRg + W2lzJAH+igT//LQhJolKPGoYnzefUIABMcAAIKCL+ldeCamkDMl3XhQCB9AAMICnWHsEWrcALXhzbalp + PKuWo+U6Phet9jqtQJJdgzUeRoemWmADL/CXlwOdT1u3Ltua4bo/PgGFYhm4RrADEXAZCdp9X9d4+DV2 + 5Ok61GNBOtqq6VehTykoP6hVW7AkKDCwqQmH/9Z3YzZedLhCI4AAK5CUprsEOMR17lRMM5q4WailratM + E1C7ncl5emlYoWah90GyV/COC+AacBi13Pa0kMWVL1RIJFB5c9m8SxBXK0BpgNprmAmNb4ZaKzBRj8uP + ZRqaiygqsiqEf9kTWASih1aiZUaO5YWi/wVgAi3QsPK7BL/0h4NaWqWohbkncSVAAkXiAfBHBRCYR00J + PIfFu1hwAxOwAmDlYMLLlaondce7tyKAlGV7rrd5GULpjA/HfYOYbllxHlGFBRjAKYphpj1oby2zr27B + TY4zwlFgAxKga2AFunQYurd6sF3kKcEVtBXsBF0VAV33Q+eWrBTbguV5V37lieOLxLAxgQH1KlAJMFDc + AlnAAQ9wsjBcvNLZdw7Mdz3mKdM1oGFMBKiWAidQVy2obhIXiEfloOBDfhRMwo5CKI/oqhjCYm8hAlCY + wzwQAybESHo7riBoeqxZXpYzAj6Xo4ecBBzAAgywHKx7gFfKrF1LlP83KgO+BwUWILBgAifBtzgf9GKh + 9hx2igV6rIHllGhaOVZd+cxJuGpAVsmvrARw24bChKBdC7a8tmSON0EQgGxWoIIf/ESxyHGHBSoEoh9q + YgUK1obNc8oAp6SFSVnQ/Jq9GgIJMAOAe81JUJGqW3MZSVou6JE517oRZAIrwAKdGgWrschxvMkl2Y8S + aCUMEAHMOwUSEAEJUDkOhmj5bKnT2XxdjCINkk4A/QQaAANM8mRZ+sjz2G4aPLEr0LFUgIHt1M5hIyxF + uyBykRvn8dBPgAMsYAJbSamBHLW8WKI+obzns9JQYDbgubPQpaxqXIhvdHYPEL/s4Vl9wixMlK//Omhg + 2wQUXlq6TdABKVA5+zepbwrNi3SiOJZWBkB9OgDK8uuXi8ygBh1sjYyxoiU+C70bZRvLJxIf7hNgpHJ0 + lCIj8VYFLExoYdW59ExWXomOc61WKiDCUh0FGSBz84SFZxzEMviRhAjCfxWlTdBVKEAVz8aDeYnJOyEC + K/B6VoB4V4nAk9q0DNyQe/efTguRhgwhGGADN3ADGpADG5ADOJDcUpwHwmGFq2tfYOfNJJagPLQALfC3 + VmBQrfEc/RIsTBQe4eEqCRABruwEOCADKnCQzZyQIqhjEsZFISq899N6KUCbfhAvOaADOtABHrADEcPc + N6DXxlA3HjABEyAD/xYAMixgARUQAxDTy3aAA03BALQniAa9m3plVzxEQVFdBRogV5gRx9BkZYnjFili + AsNl4XAFAW4CnXjbmujIhNIMQwjgAMPY3xwAAzMgEk+BAiugAhHQAiwgA0TDEDsQAywAARGgAqmjAELh + ACnwADMAAzmA4GRQdyvQQCUBqKWKe+CMmTxUcwsAAevtBBwgcwlAIJjMR880GAyIHlewAyrghglFmCEK + ogs5dRx4PwnAAqxNBxqwAxXAdXo+twQgAmqkANwNAxwQ3c8wEzBAAQ+AMyuwAijAAGB+AkRu5S1QATJQ + MsX9BqjbcFnqp+WJ1Y23eyegWliAgbNMFbAhYP8fNCnnHR8oYOdXcFtXpMCo7LT5Z0skep2eggL8nQcb + 8AIz4AI4QXqrNgACIAAfMABhtRijYTUzqwxnxAI3sQALgAJM0+lOQzXkLu5FDgEy4AH/PAftsQA5sc33 + KFppjHMsCESdnQVE5SXi/SaxbR/GcWdXewUwYKSKxISY7Xd+nJVzfRW/WuhwYDaskY4EoDkDAAIZrzma + g3fmsgCENw0a8ALfyXBSwxXn3jTn/jQK0PJfGAFFseV6YEnyteH7a4AVi/OywzoMmwVd1QIOkDzIzDaS + 4hmEIa8O0ALkfAUTAF6CibCwCVm8yH9eRLXCJQOUrhceQIQgUO0fcO0DMAD/HzC3GR/2Yf8B1j4Asmk9 + 0aBgEKAC8j41Kc8AUDH3U8MVtOMCFhADg4MHZZkCXpKz3ne/OKfGW40ADKDSWdABMuACDMBNV4EYhFUc + /jN9LhADEv8EFIAADdayfuyLl23jL2Q5IgDy3Z5gTbEAf1EAYn/trs/osC/2rX/tDlYkRH0MpZO6KN80 + oE41dK/yvg/8U5MSFbADp64GF/Wi+0tPWsiFCqg2KKD4WYADElBFfHMbsLI3IyUBMB4Fmx+Ymj31nq9t + /0kAJOAC9ToHqJbnliP2c/v+F3/xjL7x7x/2Go/t1JL5wKBgVQgEitOJwUAVGadjMokiGplDhQKVskh0 + /xreltv1fsFhsdg2UZlMiUQ6vXaj0e53mz2XI0goyZgf1rxYIlYYFEpIDEQSDUYO1hgcIlhebvoqu2IQ + CEIKEkUMOD89RQoQFUFBOz05VVNFGCoyLGVnw244JlgcEEI+BAQ+QAiCQYiJhY8HiJOVfUNQLDpopaep + q62tMyYEmZqKjpa+v72hjohQFhxSHih0MK7fvzoeFgpL6Oro1PD13+Ta1kokcOABnhcMOHZQgKACRYJD + iAw0QqECQgUPONwV5BLDRIFNiE6JElkK4ipRpVgVUEmqRIMXGgtqmOCCAQIRIYQVGzbsGE+fOwckE5Hg + gRaYR5EmncahhRMiT5ooKf8iFYkRqlORKDBxYkGKGR40ZFRKKwOMFisS2Nu3tl8cE/b05YOroMGOsRte + xLAAocEKvw4aQLBA4QWOsRIYjBjVKhTIxiEhjvr0WOWmlhOMjp2loYMMByUKDPAVtFgy06RNg0gdFHVp + AiheapY9O+mNFxFOCEEilfcSJb99OynndAqDFQ1aVJCQQyztMRpiNDCBYA1bfm7gstF+/a0JKi44aMag + YQOHDjs8eNihg8MGHDY0v9ClWDIpUyPt4xe5f5QmBjMyc04MDTxgoYETSBABhA8YXIaAAZDJScJkJNRJ + mQUHSGCGHATs0ENZMNCBAhUIYaKcqqZaYjcVUYzCtxX/IGDnQzF0gOAEtfjBZzs4clQDoDjSMoEBFTac + UUAOXEBwpVUau0+R+0hipRSPRhjIyC9ukMAFExQU5jQLVSvmwWAoNOZL1AYA5gAVKNjgyjdnxIECFxYY + AsVvpEIBTz2hgAI4rJLIzbsFXFBuA/jgzECGFBjwcR9HIZWjLXwCWqAFGGKBUzMNZGgANE1KIgmVKEeS + 7D5SRlCABcPetGEDDyxIQYECevmlzGB66mmnCXfdSbWgCighgtg0LVa2Ds5SUbgU/fQmuCb47Kabp4g4 + LgUWJuAg0ys7qMCBQnp0q7pJIa1DjRJKUKGCdoxVCoMdHpiVAE5MkrKTJu1lZZQC/0Y4AQIJmvtQAwnm + KeEABdNcTZkzw1R4mdNYMzOZAhSgoN2Lk5KggRX5VOLZ3vpkMVoWobITxhh02HbGDF5ogQF08wnSHx/t + 6McedBWIAFOMa6NghZuYLPXJKR+ztzISVJiAVSNxgGFLWm81xsxceTrmwVx1JbO0NEmwgOev38EgBgfs + FDlFcPpkFuS1VcyNCAdcsABlSozUgIIFAsJxu+rU6q7cfRAw4QEdwEZqhwhGUAlK+yYLySR8P9mEKA5n + tCEHXFRIwIBagaF6TK3NDD301JABqhcRIKC78NVl0aCCFaag6qqPl83TWY+7ifY3boxAjoLwjNwhSSAl + TQPHcf/jyK4NtVaQQWXWr9HAAgVG+CSkVESVEhVVVhlhARiMxOAFCBg4WGrRP8+JJwfLrFDXMa82TQAR + UgAe+vvFyMGCFbZidlplq9KxE6VNZLYLlG5W0AIKdAAjAqMAoxCAgIAkj0fXiYu43pIABayABdHAHzyE + pwADaOJepGDS9YqWiALMiwQMeADlOqQBHWjDBAZYkABSM7VblW59E4IfhCAEJi/1ogArIMgHkciFGnBg + fwoYB7RC9r8ASlF24kCCb+y0gBWogwISWNqRXoeAEQQkSEDS0T3qUIIIoqCDiEpiNWygsREIJRSnIFUK + GweCEJzgAR4UEAY6MIMIoMAmIUj/mIN+KCat8VB0u3IQrigkPxGsQAJufOP9AMkC2EFFd8/635+iaBXa + iXIcQ5jIpb7oHA6w4EZpyc7M/uE3mq3hBMO6ZNgowICbLCYUJdRXCVcSAhEgAAJ+dM4NPPCAExxANR94 + WCR7lZOorc8niSQT/IaRpg8UAAUxCNAtV2eDHbCAHryRFjmgeMUWVREcaFNnoHKjgAWo4AEyeAEHVDcb + G3igBd9SIxl3hDzjubIEG4QADL4JTmnkYAafsd5KuLcYVYCEXiEIQaqGZUnNuOoFMzjQCHhhqzDppEJS + 82Ek1Zc+aJZUmgLgJgVSqdCvZbKczirlsjwpxeGsSKf+s5MR/xyggggoB4b67IAm0YWucNUsLa5EAQRe + kFCZ0gIHY0NAZT6ynyZNCSchMAEEPKDRsQByBmgByYMi9jACnBSb6TufW3sVVzIJIAQL8OZUVxeiJprT + CWmbIrTE0U7/vfOcUJlK7Og5AR2I1V078NYRtJLUvBE0qd7higMu9Ty8SuMGIypE9fa1JNEqbgQkKAED + oMrYpAysBQuY4y8s9DmTLsORP2lrD6f21jGJpgDf0+xm26W/TT4RbXtKZ1V2h05SitKTT4EnUK9FgYs4 + BwcSEKQD3oKHCP5TjSSQoAlQ0AALwIADqgVu63YggyTZREJr1UR7DZCABMaAAwFLSohiAP+BBZhgBARg + kDFK56XQvW+lUQNimKyZ4DTR1Yj2PW+xcFBWIVSRbWkDDu58Kg4D9ukJHrOiEebJAi86xwYdoEA/CeEd + HmnnBJCowA7M++DNzGQBYgTtvQyQ49KaQLw7cDBSbKCDhiZOfb9q2IWOrNK43vYnJC0wWhkkggYQTsYY + swEFvvWEZT2RgEYI7NkEu2FSJtewB3SiCrDVAakiBQM5eAEFWPAAF0QgBQ1QgQoakAIItMACMsBCjKss + Cxx4QAYtiEBfymHKFaggBXGDAbtkk4EZPgAFzLRVEFMa24fhNpvuu6aYIBTg8ymjFwZwQUwDDScJqICT + PB1zX6Vlu6f/9LVtwsHwx6IwFSJoMTAziKpzMJABHHBgBxKIgQwoEAMP6GADYUk1TGyQgRzowAMxqAAL + LNBnGHggBxqwwY+PsoEZQPAmzdS0+oDIviJ3+q20vaZaa6uaIX7gACwA97M/tAP9YgU4gTWbO8/GYeEA + HGTj4BPaZi3eEXcIAzcoDwdw8Ft8a2Q85llPxDuUgUBW2pDO3CHoRJ3ICIF6ke8Wom0hBgJXWGzixcpB + BVIwwL9isXY7ZdFxS6ZhXEelr25Tggpa4OccALrl4HTHvZHyB0GWr+POJPnVSk7S2bqvwFKPH6Yh+TBn + FiABKbBL0eGETBaQSAi2/nIU3YnTW9vu/1k79bJfT8TJFRTKAxIH+92vUVXpjDCbCJ5mpqG+SPaBKZqg + fmRJN12lCrgJ71fSAAwggALdqDMczo01wjvpJ7fnbrkFR65W5NmAGWDB7o03PR+E/QIL6CIEvmjQgGdL + TcFnumpBRLAyGIl1Ac+VACWYgf1O/6FV1slFoex8tN5pQHduuIrozBNvFN0AFzxgAh3IZ/CxD4YNTOAB + /EuQfz0+amkGPsGghvqBq1l1t1oth9uETfZXFgMXOGDLb9cTVcKRouS2Tf/Od/tVtCzg3g5QUsAi1gz+ + Ti8HRiQBVoi2SOetQAfkoq7IqE7wou72EC8YQqAEIADVEFA2FFC/Jv/M8lYEAM/uTz4M1igPw3Cn31rk + sLaiK7AlZT4Q+y4n8kCDQZxurXooiGhr5ODqh3gF9pZsfdonKJpBAcCqBj9kA6LDTpwLlDiGp0iG567I + 8wSQ+eoPudChAR4AoZiw8eRhmQwAJ1gjYrLGpMhPkUSNmtpw5C5wpLbmAFygA5AuDJGCA2DOAbhB1jiv + sHLn5q5iWv7wBfNkTzwMnlbgC68PDwMtRFiAAWilQXLIpKhJ3R5JAmVLV2xPwdQQTUJNBEigAQDGET3k + BldgCH5q59pOgP5nOPDPwmBxOAQR+XINBRwgRoDPFB9MfFxAhH7F6UZtpG5r/TpxpUwODlMKpc7/MBic + qUFEQAFa4AVKjxdrwywcYAHiTlp2ypyeyPNqjVlGJpR6wzdyjd9W4Pes8cFs4AVSgARKo8lKJxPjR66w + CSgs8OlkT4iCQhNGgAFYYBfXkTaU7gFSYBB+yrCKKxyXz+aIS3a8YRAJiAR9A7wiQAYEciAvCQMkAAIS + gABwyPYs0chmDwI5jcncR+QOz0uCAhoRILwwUiNnBC8qIALqZNZeTf8+rBxDZndozeAur+a+0daYoCtk + 4ABl8n44IAKuKh6HMFegSSd88Clx6x6x6Qcb5lYWLAS6TgYWKykrhwNOLAWyUeYAiCEH65zgbv+OS/MK + cRsh4OvAMomuzATS/yQeo2nwsKYTidCaqkl0jnBrnMkfSUAJJQAp51I8ZGgCYgV2LGvWck7zMAznaJHt + 1NIn1WnDEo1NiioxWQcDPAACRqBBsobJxI8ZLZCl8lHJjlB+fCFYMEuxqtEzZQOZBMkpZofMPiwigyPM + SObfXNEPzalaHmDhaHN1jgoFRCBh3NBXAi8OVVPJYO8eL4Q05u0DNpBNMvI4PSQDEoIFyFIbV3GK8M8c + gDK5JjI4/gT/etMtd80rjIk7MQYDsGwXws80KJAvS5MvmxPqeMXTdovUgiIEDAABFiBGPFA+uxMvLEAF + 6KF/ePOmju882y6dAIiAwpFjdEZBv8YGHoAEzP9wh4BoE5kx5DBNRHWo3SQmK3EIBA5gBSxgB7yNQ42F + ZSwgAujPIWNRQpdL4P5KivoQ1lhQT8rBAWTgDmm0QzagAZYTGIiRHuNNAk9OShVpwNyNNfyxBNKxM5M0 + 7HQABmZgISCrbLixG2vNBWtuRy0z/2ItCeQJQLrUWDpgBVpv0zYtGQ9vOj9tJD8nrey0mQbzAE5AHSaA + S+NUUzZAAhq057hh8yLTr5DLbMpzsAzLdkxgAQbnUBMFBhigTvdx3awSpXBP/UTVB6VyawaUBBxgBjpg + NjV1RjQgISAgBRz0uQ7upsyU8/7Pk3SOHCYzN56q7l6VaWRAAUDS3eTtRFn/6u9QLkrR6sggZgAu6rQi + 4HeGtXBuoANi4AFYLXbM8xBdLf86jFd9FLkyzE0ZwAUO81qFzwJMACQ/wEvWavBg7xiVbBnjygHl7Vd8 + wUWfyitdlV2vpLpagCF245xoUW2AUhyp0ArF1RwtEgYSVGCT4qhMgBcAbOpKDiorcE9ZSrbYZxkK4ACe + IawolnVilTHFNFBuUfMILmEDDgtnR5SANQKU5mRp410e4CNb1Epzy+981lQDLCp/CAml9QBMAM2yBWfv + R9pggFslD0Ihk/8Ay6+aj8uu9iqcyAVggPGYdqyQJQFA4Bc2UR6dUy9jr7buVTQEAARGgI12oBG/tnA2 + /wAGGlMbi2+KrGhq0ckcq7ZCf0MIuHZi5/YdVkkBMMT8pvNEfcXJYu+2WgNUBAIaCheJpM0DKgAC+DCe + IrQ3LPNgddVvWxAcTMkFPEBuKxceXg5xYWtj9XUClVVES2pfa4UADEABvOIFvDZ1PygHYqCfeg53bnVv + aXE3x5VNBQ5Yi4noeJezYuAExrYS0S0C/XJ285NMmlGP/rGNmveScOAFKuABBAE3HxVhM+zgZC5rqeAB + drd7C8IDUABefUhr0GSkYjf9lvUZCWAoGKAAfcx9bylW84seYkcWfbQ8M/TLbo0QFsACUBeAqUEHHMBT + 3U22AFPqgIJEsbdBtilnZP/A+iBYoTjgd1VgBeJuEGeWYdkmAJGrxVguhOHhBiCAmaqTNHDlht2LB6+S + /KKVQhKBBPhIWGFYoW5gB/RiG1SRN0l3TxyyIfVPCXKRWIbYGjCgAk4ApEgyh6gz/TSxNBgEh4YCs+iL + eaeYdYp4TobLHJZYAA34G73MZCAgJsv4GmAgAhJgOVvDJK0G5D4uh9iWKyMgBtp3jsEpA27BAlyghJ1i + sMyGkc0TioRgVWGMkK1B7zZHGA/MPzO5WYt2ADhhjA50Zyh5s1wFc+ePAbYC4LbMgGRtJ+kCBh54lCsh + B1gAAUjzSRtJDuNQNXCI69TlBZhDls8rRObEYEtwIQP/0X9g0TgeYDuF2RIQw5BeV14/TYeJFnRSpQFu + 9pl7MQckoAJaoAFuEgp1yt8AyG2ATpS5WRo2IBIvuR89VkRL1VYKoIUiwNcQc53BqYhrUjzLDlB4Z50S + TZ4eQIj1eaFmgAHGdgenaXSe1OO4MgV+h4wP+pI0Lr8agP5Y1vI8t3a8LJRjuaLHIAceoARw4ldasjW0 + EqW1twROwAUwQ6TxTYANRPK8VRXZVAoEZUiKk3BlWgwCaQEOACR94dJYmjWcqagJAAFg5HcC9qcVKlY9 + qmOcRXRNZCJYwGShehrsZgUOIASIcWGss3FH0Vq3uuUMGQbC1wUyWnd0Q0+OwwX4/ywGWvWsqeEGII8P + DeEmHkQHKYRASSABhuRSBtmuU208tHUG2FqjY6cLI4Ewhs6wqwEDNiC9Ii8BFIOoBWBeIsIEHOAB6LqB + JPvu8ALOHgACIuDOAqMFZqACgBlJR5sPvtcCxBmVSWAERkCDTgBGZGAHnjq2z8sGNCAHOEAHdgA9doAD + ciAHMA6438FVduAFJAAGKADZJgAGJGDZ8tm5ubu7vfu7wTu8xXu8ybu8zfu80Tu91Xu92bu93fu94Tu+ + 5Xu+6bu+7fu+8Tu/9Xu/+bu//fu/ATzABXzACbzADfzAETzBFXzBGRx/HK4DPAAGJiDZKDwGKvzCLTzD + MXzDNf+8wzn8wzU82a57PTTgtws8AzQAB4hbBzqAxV28xWH8xWU8xml8xm28xnH8xlu8PTQgpD/wIKpt + re1syPGsyIn8yI08yZF8yZW8yZnczvBMzyxAOdSswb1AuI1bAibA2ipABrr8y708zMF8zMW8zMn8zM08 + zdE82V7AAxjIxO+OsiP82g6tVs/hzrUxz/F8z/W8z/n8z/080AEdxPAsbmQABhjIyrG82Ca8AmbAAlgA + 2yId0iW90in90ic90y1d0zF90z290yO9tWUgBmBgPQ4FD4s4TCOAzlTAARxgBRZAi2Qd1ml91m291nH9 + 1nU913l912k9qBqgAVa9BVCGovf/G7FhIAYs3MtnoNmd3dFbu9mhfdqlvdqj/dqpHdutPdu5vdqnvQIo + INxjYAJ24NQ/kCbFGQX+wtVXwNXd/d3hPd7lfd7pvd7tnd39woRXoFrjNsFzoNqybcqjvQIInuBb29EN + PuEPfuETHuEdnuEfvuEhfuIlvtqzjTDMHfskjTEFgdbzPaha/c5AHuTvLORHPuRL/uRLXuRNvuVRnuRX + /uRH/tVfPdYXrVCWA7bv+wb+fQIc3QK8HeEp3uElvugj/uiHPukbvuATHugrIAYkgAOc7fRAswJcgFZp + Ht5F/t65vuu9Pt5NHt7bPagiIOji879xoAOoW+iNHukV3uCZ/53ZjT7p5d7R634G4j7iB37vRX0CPKCw + i24HGpPWtz6o3H3REJ/mF+3VW33xE7/dE5/xsz7yxx7xG7+EJ5/dMd/dRX7ROl+LIEEGAF+/vdPanH7g + 9V4GFj7u8d7tXb/1V//h7/7u4d7uD57toX0GCGO7ZSwEFf/dX77Vgd/wJd/xhT/sJb/4hd/4333xiZ/5 + NZ/zhZ/dX73di9PH6dsGOECtqd3g957ttV3otX38u538t/38wz/9v53c4Vymts8g1/3wN7/yS/jynZ/4 + xV7yL5/zXR0IVA6H0LESqopHI3K4VK2YUebQuYpYXjcet+v9gsPiMblsPqPT6jW77eZicv8SymxWqdjt + +PtMhpfl8fkF/hX2GQ4mGgou7iE66i3mWcjA6Ni8ZWq+Zbw8KFU1EY0mhY5WLT0dlZoKpbrCKomyEi0N + sc46MaXM6Gz+AgcLDxNrbrxQ4AUu7+k5/z33MUMqPkPyYVNfX0tD1lXISOQUk2/iUKgsRCHZGjm51sIy + FUGJ3qaevpPqoxZJyfI7IhCeERcTMJVLqHAhw4QYdMSwcMdRM0bRADUbxK0is44VoVnkmNFaJDuUOiBs + qBIMhh0WFqDIJ8+evyq3+OmbIo9KTXejBsKj1a8fPZtGFqiosGEl06ZOn2rwIIPFN2WANIo8FC1rImd+ + HiEqKVLboaz/eWZYmCFBw1OmGyZAWDHlpz9br/4N1Odv5jy87JDQtMV3VU+eKxY4YOEhZdvGjh+3iSNB + RtqR2DpiJaT5craqWz9v86hM0mU7MDgwhkzMhocZLowIvllqFZV9p5rYZXerZtHaNvP6nG3vLr3DDiBQ + 4KB6OfPmXDR0mAAo0kSvZDNS2xp6bLfq3qVpXBae4yCJMTwsdS5MQ4wWEeSiqqW3LxSjutbdi+WT+BO6 + t031x09RwB0RAQs7pKaeggsmJIcM4WFm3WbaXZQHRiBNUwdomlWTDUgVUWAJBgxukkMFETSw32D1GTUT + bXX1Rkps7ehlV21B9ZdXTVFE0QAEMGRA/6KQQwLzkHRcacWdJFdht1kjnU2E4YVOkkSRWDKclyCRaHDw + iXCy3bTPXjzpUg9A9dDmWz1E7PRimaaAWZuNK6RAAVtb4pnnGTbs8NWE21nIIWfiffgZRt9o9VVYUEJz + 6GgagiPBFnqmoUMLwRl1FxUDzfllmGQGJMtcYQq25pq5tSKFOzOkR6mrr3ZSQWWEcoeVZVVyRt5FpCHK + zZSZWTQIWjHc+WoZOkCwAGJ0udnXf87CeSotAdIi6ortzAgjj6DAxEKrxoJLZAYSWJCWRxaGpOtHmK0b + np+5VpmkkqCVS2y4ZHSQAgpIVXsfjJvuiGbAQwH8z6f/7pWjLDFOIf8XCg+Mc6/EDN4gAVUfQRnvlNUd + 2nFW2bXrzJ9NXrbxIRawEAMOE4exQwT7lvJlE6JkK+Z8OPU2iyrx8JZmmELxPApMELNcdHMVl7tMhhuT + 1u52hYJMXR3u7koohXhYQMHKRnfRQQTq2FSYQGDGtmko29I2dl7Y8vXbmm5v+w6NPB7mLdd3OzYuWr1a + xpWVTxuaseBVl8yhVx3NkPLWd3fgAnwAA3WPb8AZlotM9oA6VIAG9ybYOjk6wCreozvVCVpjldz01Bum + zm53h1PkK6NUXmaBvXjnwEKKpMzs9sw+25YPwWLHPJ9+/Q2cD/LuJFHn4qRDvxBr44kW70aBekz/ErAS + lvYxu1HvEU6xXONwYlBuy7mTwXe9AlD76BPkc32es/I+plGk8OOk0fNfzkMxPOhcSKKeNgbnPT68rkOq + IyBosOSBIOFNAxNwD/P8U7yctSNGA/rLbipHprlNi2bFu199VOACxWipfyr8hRwoMJ5gAa4aDGwdxsSC + K3l1g0pMs0OIUDI61swgArDBhX0aVsKzuchgRUwfnNIUIIUJz1mEMYKPKuCLFWJRGDeIzmiU1AjraQ92 + hRjJ6w7oJPJ05hsx2MG37oYDGLTAOLqJh5tws5NYDAx59HAfb3wXqn8s7CcxYcELIJjFQ2pCMpTxTDPO + lcORldE7fStch5IU/6hGNRI7aZHAJaLXARY4AAVlK4yK/thHEWpqefnJTyCXN6YBMSApykEkLTNxAw/I + ymoEHGPgNnSW65mshoJD3SU3+bzRbUAG6fhJPPySi6LMT1rbIiUo5IbEtp0ibuub3wIiMIH91TKca9AB + HaRWw2B+cRpg6Q7UAEUWR0UIgTLYgSFJ14kHNIBFgRRhTngzJjZp63wcxByNbmTHf8pFBSmwwA7E6dA1 + HKOcvcrQoBjFSwwB81ZXQVcOrYTOZ4RjlvzbQHtSFDfitYmD+FEiqJJAnPhEji7V1EmoohCBB0jqoTo9 + AwY4gIx1CUJ7FZ3oF2dowyhBTTQga0aIdFBP6P/FIQYQcADYTgoYABGRVECTWdmMmNUnnIlNxtvWA2Bw + zJ2iFQw24AAMpuMZBr4QPPCq6CP+xEirYbQsZ+nDBJyaxQ7MIAVyUccef7ZSyOGEU+gDGM3kkylSyQgX + coFPBGQQsbRiNgwZ2EEMZCURa0zED1hhEsfuwKSylHaM4CiEokhr2tSGNkN2kIEHzso/PlXABRFQAj4c + y9KwEQx+THQHqigXNxCGLQIQkMEVM+vcL2hgB3PI5F4hhbhGIs66HNGuhpTW3Yn+EhqIksEEXtDGFRrJ + Ao47zONQBTc0fVBgqsLJTaDIuU8R12FHgIBacjCi5wK4CzfggAekszd0iRb/qYwI7WqjJNoEKxjCr20t + OBJM4dWK7HQxeIEOxodIHLzAAg2ACY+Issre+SdV/6lLM1MsJgLp5jD7ikAFdgDOAON4A5zdGw3PctpH + Udcs8ATyL1lHoXLJwLwpzGJ0KwCBCKQgn64Y7GSrPFl1WDnLWM4yl7vs5S43D8oPiIEPcWzmLuCgAzCg + QAxcKKzvwjnOcp4znetM5wexmc1sXPIhMYCDHcCgAixAUSj3ZWiYIBoFhj40oxMNE0Uv2tGNZrSiHZ1o + SCOlAS6QCAw64OEzm9nPHJBum2XFApSV69SoXrWqW53qV7Ma1q6ONa1dfWoWnHoGFKDABHaggw3wuZYY + /9iAByLSAhekIAn5XLYKmN0AZzc72tB+trSrPW1pX3vZKWo2BB5QARjs4NOgBrUNcKAD6U4gGat9ELvX + XeEHvRveFo73g+lt73mzG97gmAAMPLADHDwVszfYgA48IIE2xyDhCl94uhXe8IVD/OEQnzjFGc7mibN5 + AhLwgA5w8N9xg9wLGdAADnLAAR10AOUo70DKW65ylr8c5i6fucxfvvKYz9zmLHc5BziAAw3cOORCHzrR + i270oyM96UpfOtOb7vSnQz3qUp861atu9atjPeta3zrXu+71r4M97GIfO9nLbvazoz3tal8729vu9rfD + Pe5ynzvd6273u+M973rfO//f++73vwM+8IIf/NsxMHIcbMDkOsjBBn6ugY8Tfg0YsEEGDg/0ygc88lzL + gE8BeIcHPIAF4OihbTUvhgwQ3AMeeMEEEi6Bje+AA483vdFsoONAswACEEB2A/LXgtBTQAKyhzztRW5u + QLeZDml5UAw0voMc3ID4xaeUjueQuAfoNgJQTkEKXOD9blPiPJed/oB38AIYtBnekDItr/v968xPX0g2 + kIMFnqzbFGxf+/rXP/cjcMIYiBTtRcWRbMN3sJYlBF38LYjtFRgLIFu04V8E9h/3UWCUNcBNUYCnmd6w + FRtlJA2iTIi56FqvyZ4CkkhEscADPBmUaV8EsuAL7h//9+mWC8wAPUVeT7XVXNFVSWBJeXFAApqgY/TU + C8wABHBf7/lfC7KgCyYhE3KfA6RABXSA9PndMfCYDurVoCzfBGhgEEJGmrVV7k3gEu6f/s2g/53h9j0b + f3nA4DnIgQ3OkO3VZ/Eax20A/HkhQ0TUA5ShEiYhst1f9rVg9nXf9s2gDJRe3mkAuVTG7Dhi7CxDDHAS + EOYhOdiABuiABDhZsl2gGTbhGXqf9gFi9iHbCx4hC0wh4HEABeSaeFzSdQDV6QRfBwBbJS5EdBnb7hmi + /xVi9wliL6YhlN2fKG7fj3AAFd7dn7EiRRlZLGJNH2AJuOUAHtqiMRAhBDSbDPIf/ynGoCAKIi8Sogty + HwRYAAyMX95tkYFRiKMEVeEUoElw2g9WYzDY3g5MwCZmI/7N4DcGYiAO4ijyIgt6Iw12QN9tQA6yznVw + z7kkzSxO4zxqQnSx4u7dH/71ITiiITEOYhKWYQQOY5T9SN91AB38zdWYE1BJQh7s2gSgR7BBpGbpwAtU + gHsoVP/9ozDiJDASIyGCokUS4xOmwEHsXUugxWd9D0cxY7pY0mxx2Oy9pBlAR1vVX/6JoyeCYhkC4k3i + 5Bl2H/7lU2WJG93FClVoB3boSvawYyT1QYi8QAd43FOOgQbIZAsYIUcyYU5+400WYjCG4kaGowrQ2Dna + 3Q28wP8iec+QGeDS5NU1YMkL5IBL5iEGYOJcqmEheiIZbqQv7mRm8mRetuAFWhFktt0GaOKsoJErOs0N + SRJ2VYDGuSU1emEGREcRDmNHBqIEiiJAYqQwcqNl7qUv6lbvzUAHwKbbDRvu/c0OLua5vMutREmItORL + SuQDRBlgWqROciQZWuZuaiZWbuV2QpmmzYAHUCLcHadhVk9nIGaibMVX7BDWsIADPWQlDps9ziTv2aQ3 + CiRW9iU3ZiRGZqV+YuQF1mB5Fl4OyGQjJspZAk6PddFnfEM0clxYml4GkNOx/ST/4aU3YidOZidveuhm + kiLvRUANFmfb1QBpWhc8yeFQmVH/ixKCI6QFBbzAW05fBuSAB7CiBdqkRwooOPKlXfajGZIidu7lbvFC + md1dikqlWFzUUWmUUKnOdlnAA2SNB5RghXKABNQB9uVfbvbldnblN/rmPv7nh2pmf/4iaOoAMsodiOVS + Us4VDrljrYAWa8YADLyAz0XeFsWAA95lmjbhTXJoKHJlbeLlmSbq/V2gDJxX3d2SoMHOhLAoavJKUiGQ + M7YmG7kp3t2eoLlA7/WeR/ahj9qmXWrliAqpX2okL15gDJyocbaGucwpsLjoOjopO4Xg1LjmBhjo3HFA + DMwA9iHqdXKmbXYniIYpT16nmm6kMEZgA7QADIikoJ3TciZn/zuaZfXIFUWNXqclotxZ6ARg37PZZIim + 4Ude5VZ6aHcaqodmpbv64Qk1FN8Fq5VYUmmBxyXlq1ak5yNmWB+Aa6eyXU/pqAXQJVX+Z14G6LLu5JEm + 63Y6bKuOaZS5wJgJ5t3JpYHJjreiJr9mzHrmypTogQzUYYfNXU9NgAOO6kX65ZH2IU+2azBmZFduJkZ2 + p0dSgA3yXRzoqOt4Ub6qlsd2hXPalR302q+SHY5yVv0t2wTabCl6ZFWSakb2J1aO6R9ibWc2Ifc9wAtQ + qN3ZAESMF2iBLKUSUzstpNF61gg+X9iOHWlWwANgqE++4FXiraGGos2aoj+Cp2UCophebf/+zUAA9t0i + QmKd4tWlost3WGpHUVdVmKwk6oDSct2AwYAFRNkY5uSpbmM33my6XmXOqqrWLmH/tUAWiGbK6oA6Xo1H + paeE0IpclSRKjgaqdRrcbt1aTUb9nauZ/mR/km6Zfi7FDqnWymyIRisvSEC4omPrFmW+KlC85Kq6dJTH + bgTWIFl50SLBXh0GdIAMeKmxeieIAim8hu4fVmzpzmx2Cm9F4pTz6t1mLaOtoBbtXE8BxaigCK0YUUdj + PqrW4YBUuMez9Z66jmlfoqsogic4Au7NPjDwZu3pdt8DjKf87l1UqhtHkcwCcTDJnOTrGkodpEXWcFKs + Qh0OrKx7VKD/gNKsvAZkZ4JnVu5fuhKv9zErBfqIDCip5g0bMqxoVYTP7IIP5CoNjDridZEXeV6uxWwu + kXofBc6sAmftQGrkAyfqA5Ou1vpit9UYCvcdgqabsHTwI0mJh9hQJf2K9YbEJKQMagiwTIaquSqhT6Yr + 6AajTkJsgGoks5JpOB5hC8xAeT1mEGJigXmgYp5RkX1MIzOnR2UFkgnf6iqdB+ReRZpiHXPmFivrH/un + HivwH2LyErrAt3EAGAven00AHLooRnXsociLei5YhYCwaZ0G1mkABXwkuyKvKHOk6NrmHStrbhavBD7x + xV5pLVbjZKIfGeuqHFKNh3hDk4iMWeYK/5TQFiUbnQ0AForYrS+jaaE+KzDK7F72pn6OLqF1Hwv0mgZo + s+kNXLE9o5+Y7Qu9aDs6aV5dSFKZBgYj3djGAB8a6wwz8Pv+8pAqcOnqpN/KbBTjXwu0ZiHDJZqpGR34 + yS5Namb8GJ16a0k251mcRwAznQZkbila7bPqJg3f8DYCI+D6Zy9zpTCyAI123ESDwcDFJMe+VfaqJU8H + Ey2fLRlXQidJHQfklh9u4wwK7kG3KoASc5H+omeSs/Y9AAX4FVMYHtDZgPc+1+RlAFevRkRFCWgMjv+a + TNEasa1OA43q7tG5xBiaM0qfaZn+ZkJraNUGriH6Yv+5QAtQhYisBP8GDNzJwdwGaAAqOxTlJR7j3UAG + vHMipdkLpB93dQwPgkMCmS0vaXQMKQNaTEDGLh0GvEAL5GdDrypv+ufxqrQ/Ji9wtiCPVrUHzKf0bEAH + SAAMtF76TW6ebhzKZhbqndvqvcBtw4AEvIDq7UDs2ShDcJ5kdzbHHFXjGplR/TQ6ZY3hNl0GwAAEPJv7 + lvPgamgpFqqq8m1MhygaQsBM25hKWCiX0i3ovXd8t4Bf76xI19INZGI5KVim7uxs03axbfBSTtLsbo9F + vSKFoAVzgfXQ4YBUKZQZYrELo3Yfw+xuDqKYbh8FXuwMbJh/JwSOekBbYR9FQgBd6p7uuYDupYz/Y1ru + baVZ7+IaqrVaUUpEef3agieSBhAY+ikDrT7ptt4z4bgT1uzsY5/ZBWwABXC3HX9uXfPysbYvL1pkke7n + srXAzrZ1MOBAaaIM3c737315mJe4lUqE8DlUdI1xj88KCGqIyfJauK3E/BVb9P44L8WoNfOrWsvQJMwT + YoNaDaxiqOrjVgap+h5vha8rUk+xisdA5a7EIqpXX4M5fFN66IEemNNl6sKAffNPVCTDnc8WGvd4yvBs + Q3CgdOibdNszXu00SvZr7dBWi4dcVC35Zhopa9fsu2ZxOfPmEVbwt/0bjpuDe6f4pF863abg7yE76JW4 + Xw8yUWPRELrQXc0p/zZURtIyxQ3kgJp1FneBcIH7zdn2DQnHOtSlqJI/OPqCYqJfJqHesVKbdDFCNJxj + tQeo13yPeXxTul/v+3uHOQVwOt4cZC4RWa2sCyW0aVMMmHPDov8yqGr+eCBQAhM/3QU0eAsc8CeCLuiC + cihD+DgbIn2fcFOMrZL39bGDOQv4Nb8jO8sruwoaCAxkOcts1lT4OFKqbTOc2gTAMVan3hgTlatfNMC2 + 8Vj3eJ9HHXvU+hUDLx/renaS6pHu8uZCwLd5uEq0LsI2+7HDt7KvfAr6O9ibuLethQrJ5j0mjdEnZXYF + H2gvhGTqQA42ojPmEDR/rHLWQQYa+ZlVDDYO+v/DFvSh1rBf6i2Ek+rJq0XAl4MEJbvXo/ylgz3Xd33j + g16NqVAO6LSP1a4ARUKSyfowDNjBBRAHW0dobLYYidehZE1zQZ0nIOGFG3pU+7Giviyjcp8g99rVq0RL + OJnjL3voubzKi73wV/qxsUBORU/NqxPhCFBF8HxjSGYOABoFoMx4mVErv/pWZI3bK90nNSvTmzb64qUW + K/U4qkXPtwVpqvx8T/7vu/+y8/vvib1fT4Di38uWE/y35++BTw0Q7DQ8YtF4RCaVy6KmA6tYZpXprFqh + Ymey7JXKnWa7XHF1Ftsw1Wt22/2Gx5U5GSSSSt31Llek38/D08v7+4s4TOn/QxSEaGGh8EiTm1TSeJFh + aXnYfHDsZOn8/PT05NTMfGiU2bmhdH2Ny+CYmJHa6tIC+9q9DQvLkoHpaIV9lX2ZiKGgshq7qtL1avaV + eWauoHghLubu9ua+ebEATNTzOwdEVE80ROS7w0txaHCxmNjBwfiWw9jBTNX0ANWmgARNHSQlsFOjCjBy + 7IP4asMLCrV+9dL1xZcWXL6myJDAIWIcGxueVLNVRqW0arlWdrECkoO+kTVtQsSQAwaLQeYO/Qyk7o6i + Qy7YoVOUAsIMCQ9vttEwoUUjgqBEVXWU8FSoUJpanMqW4enYJDZ0wKjWrKU1aRyhjWEm5YVYsmoy5JBA + /4EMW14a3a4V49dChRg6htRFnHgNhg4zIjTIcy7RZD983lkeFDQQo0fCcChWgkFHBQhUDRokZbWgV4Ge + QBVkwfRwTQw2bGS4gTsDTZs2PMTgiAWX35fEpUmZ4BQ0kpI6kMlIyzfwW2rXrkiRMHv5dtAaKJAr+icQ + 0aI/hy6K14CevRx0uRvZAGNGCxdcvVpF9fp1a9WotLKwgALt9rmLgx12kAAGCSTwYIccNNgGogzQ6iiX + toa76KXYIInwPR4wwKGDCVCSQjhozIjGQhNhomAHD19ETAcZHjDKnHIiK6Q8zYKKoDQWQFIORg0kqGA/ + /LKy76CrSlnSvwo+g6ikHf9egGEZC1iIDZsJXthhAxsiisoiZ0xsybgKVRIjBg869FAD5yagYJlpMgqu + ujG3iOEFKGHkszcOKIBABcjK6ck8QNLZDDIIWIihS/f4lNEq1KqiNCv9kiyFNYBmkMSbGzjwAAYYRqTi + SgCpoCAGBT3ggE1YcIihmb7aYsm4vcoUDoY9+cRAAwNHtGIaLXpxCy6UHvFg1z6XxWkHCwSBJ7KhjLrs + vHcIYWECDr5kNgMPZmhEU9a2ukpJJu9jDQIXZgiyGA12iGEvmISFptEBX6XAgsG8KHa6jKq7xcJaKOiA + W2Zx2AFOaTYyky0LYmiXWYk9lWA+OwQRRJGkksr4gTP/IjG4Tww4iIFGCEzBsslJU6NUoa5SqUckbu5K + WN/Ygg2MGSv0PaODDR59BQcKslyRmo22YBjpM6e4cgY9eVvWzR2qLBXntyoMQwYKJih4Yq/3uaGDofEY + NNobzVYvgmw7uLfPHC6ZyquvNulvFE5a1qorr/hgIeJJEM4Ll8GKkyIlCjzjZoN89z1xlzGt6xfDZiaI + 5GsQ4b3SFlmfic4iNZX9OnRYzJrAAphz3Kyo0hqxAIZtv7bhhSI7CWjcurH6726Fxp2qAr/juMEDOUsc + jiNcq5BC6zWLgRXAgI2Gi1bhsB62AhkahZrZy+OFbhleboGOi1RhwEd087vBYIOp/ysiqA/1Mm5hsBgk + 6DL7gyfwzz7VRAkok0v/uw/t5iYD0MVCBxOIQkoy9IvI1UIKhQnZJG4ABc4drWGzigYY1hIGGLhqWRnY + gIEkMCIuRMd6cVLVCzrQqvO1sBt3eQFwZsACCOChPvFriBAiODEbdKACp+HKVfYTxHPpLiGhiI0EPOgG + G3BAAia0xqxeopaQ7BAOGYghncogL+kpLUNYg8EG7Dex9HUAGXDiggW0NgEYeCAHNxijC+U4CV/twAMe + QGMMJiABFbbnfE2EgQVqx7/9rKaQQ9RP7VSjiRm0KI5umIgM0UQdv3ixevPr1CREkxd6AeaLAItG44qV + DTGer/9XOciBDjowpQbpAJU4ANocZemK2txGAxDKwG3kGJ8iXeo0rgkgk16WKf2A4mQyeSQbbLCDikTh + QpZkoAWztgMrvgFhtHimzpZWJw1akBlbapvoMFDLcc7SnOeMyA5+SET/8a9Sh3TnEb3SiBYtESrySUmx + vog1MmCBZzAIpxtGRkFacfFOZ6JeFmIgM3Q21KEPlYMGAumCIxoRZXc7YjuHmKkItAANrxjZ4szAC09W + 0pNmeNhMXhE8eknRJSfSIIbIVAUWVGAuEMVpTnVahAx0ABOmsdtXbhdMX7KTIJqgKAxiCQcNCM95M50e + X5JWwmC1qIBw8Cn1jgaYhJ7Igmr/dEg1dzpWsobOBjr5oSLpRsx3BrEr8KzdVyywg2SuIQM6eKLV6sQw + mXpxLTIRaxtyQAtnFk0jKXqeJ//lFjVCIpNlhWxkmSVR042rXAAEYgC5sr+vOKICEnhsHCxBKo8EZyXy + muLgKBfQNvQUgQqMKYZS5JJJFktrrJBsbnXrodFQ9JevGeRlLzVUIU6ldaGNw2Bn25G/Iq2CLwVGGF/1 + G+J1VauQQ5E0J4Dc3XbXuxEJxziootm2unWQbEWSJlTRgbqygWS1mGQ1/tXP58lUoQx1BQfkc90LHfYi + MRXllVoU2O8W2MAGjIEFgJq71bRGf0EtV2scsd1i6KAiDCyO/zf55UUzUEAH7rqEfYvW3Drpc0U6o0BT + DrxiFsuBZFeS2+0eTK5SSKqIsIEEgdvg01PB1K9d5Op01NiBYoxMYdCNSV/6GmSYpukFrG1xlFu8zBkc + 1VwqY/DLRsHZFswgWdzwaYmItWH5cm6v1ZuhDIhcjLDFSszQ3eZWEUosbOigvVLGs3clChDUtPNlkhLF + QCy1pKPWJwZXlcNoTrVFEyMZyWCohZq7gYMnEi1gZtoiKL0JE5tCOc+fzm0GmFmauRXEqKU+ZBGHqRov + 37kNMuIZkJP2lw1nYcjeEJteryZNWuuTxDubgA6WCmpiR7YfCe5sn1njnyPh7cGo+coMgv/tDUX/18y1 + pTMzonHrbrxNTlk7MdIQ26/GjdkKKcZvsdUNWRyUbmW6izCS3EnIt9LuYUKgtgx4puReSPW0boHvh1/o + REhH799K83Wjv5Ane67b4Q31oVDjii5mn2t/l6XbJ0rjZURPotr8tHbDFIs8SXuqAwkmnrhlK83jaZgj + yXl4zHNKaRqet2Xwpp2S5h1PF0BABr9zBaz3hW3T9peSkV6zNyTqPFk5ungLNHG/1YhbmVf9nE3FxNx0 + zjtmExK9ibyPUveh6KFnuK/D6mYXuO0N3/Az01oVdxfHIAFhW93ucuzH0FLxy935Up6VunkoFjVkV79B + 6AVdMkyWS/L/pHtDv98Od4mdQV+/jPsjXCv83TW/HaHRByDN/rvFiRhPvT2C6t/4OLmZO3lGP2MwjX8h + Xq22WOaaezpdlQJAN7/7iTVGXTk/hSFvfNEaZ0rjELDAC7gLi8MfnbZ8ZXkXfiRwsDFz3xjBdBT9jSYA + QYz33+cTpRU83vISv+s2x8pRl0L9sRcpmiR9nPYNivSR5CBWLJEzkF360nPjG/z/X44bYKZMCK53QheM + ErREQgivmAHdiwihg4uDs5Ux27aSg4hwkJPbqy/Zirqu2hodaDgAFMF9IJmUWZkhEi610rItE6CHYa+R + 8CExKzjpcDmpWjuI2IAnuj6tmj9KOiw0/7Ee0BrBIbwJDPAABQOieTM+46s3JMKoUKiA5RmJ1DMslzs7 + gHu9mmgibHo6/su+EnuumIA9IiTDSZuAB+iR9HKw/wE9P/sfFhQqCquJMGOL2UK4O/Q1xrMJS2imEYM+ + 1Io+g5uhTivDQuQGS6gA+hC+PsMUi7KsJRSICqAmm0g9O5QvQZyvornBiDi52juz1aOOv9qrweCaYTPE + U1yDHtK3ZKuo3bk5S1HBtRoFz3KIm6BDDVyuDLO8TYQIHMCjOUm4WRMlqHuGRoIB9kPFZFyDqCikepO3 + ZhSmjDtASlkUbTHFbvi4bmKyzeE3YEApCxyJ9LmENwOY+KO9luqIRv+6KWVkxyUQjRnRFJxLL9ALKkCz + lExQFwvwgGvshluUIi+ANK6KIrUDx5r4kyyBHn45KPyLOitQsXaEyCPQifF7RD/LOOHihP5gGYMgoLH4 + uFnjNDort5PiRTAhLBrErpGrpAhkGmTpuIgsxIkokgXjrHp0RptcklNoQH7sR33DsKmyL+hjLBlAxpHw + FknSsLQruvhKxyi4nmGASYgMs2EKPBXcSOJbQI/BPI90P//6wue6hkoqyYjAi/vTQDD8izwEQw4Cuqgk + whuQABoKInukN0PCCosMJnqCyrHwR6JTOZCcFfobi7OCgprCrrMbM8dBqGHJMbdExZCaCmfMj0H/W6v8 + wbiN9LwJCEFq60qRJKlaMbOjGcuI8JYZSjLsu8OS8gh/GykhdMxCzImKYcXRGz4jgie8US8WcJG68Eej + ob1tSq2CvAkLezOz60Yy+8xh+ZzXLENKm6G94zpCaydUi7d4cgRpW74HxARyDErWFMTRBK/fMKEpEjle + 60YsaBSeZM67G42T0ZtnCz5fGogtY8LOqgBtSYxbvLbQhKpdkz7hvIkN+I0oYLS0HEi5u7To8L71HEEP + MJlHtMsCJCp4OyJ6mkTE4LGys6SV7K+w/MaifIrB2hwuKjNac76zpKkKGEMG3T1m7DnLakK8AYW6KTXr + 1IQJeEnt1JegzEQ8/0wsglzRmwgeUMSV6KGvT7JBGVhHFuU9s6AAPntEhNifBDQqG7OKVcg8bOzM+ZIe + I6UVwUQM0UDK5zM41YOmClGjpshSJv00mcRHCEUiedLItkIXz3oy0Di82uIm6AHFUgHQpwib1yJGyfFE + /oq0e/A0NlU3EaVNcfkttzo1/qnGHFhTbkg97fMrtCzHnfnTp/DFtPjHtCRPrLGGFMtORVW3fpidYGJE + Z2vVqxQgp6lUS9W34kS463KcM400EB2LvCsRJsvVMg1Va7iedEPVmMuAuJRQuWFBdsKs9OMED9uOj+TQ + czROIN2OHIQOXETJH8PVL9jNY626DIiByLS5eP8EPEDDOIzyrOyY1lpdSg8VxAmMi059ip5Ci076r0LN + P0BsBg+YVXEtsBuIAXXpH3mjuOKbRbgahUZgirZ8CrLTvl5LzcjBVs5jphEFS2EsnudDCS/TMYGVMnLl + A9rMuSecRtoUtJ6TAZV6V1sVRdTcP4ex17FwzpQjE25qPcvjBbkIWZFtsQyYAFIDPr4bNIVlGd7Zuw56 + Dx+yNECUPMmLiTEDz16VneoKVn47x+NRu+T7WaBdMaGNG77bLKzMHUHTuqr1SJ+MKoDT1C6ECbWNWNKC + v1wtkzqcM4vYR7B1uNiRS9s511d8VK4jJQ9x2k2twrtVkb/00yBFjKYCFo//dTrGDTmkGQy64luH+5aa + vMu+k1EFXKRFkS7eYlsKbDIvNa24rVmywLpf/Uw6eSYAU8wYcNzMlTKxgcbLfENVk0Z1mYGuMdyuVJEL + MlNtu9j3CKks6aesZdwpKlHocB3bXTdGtZ1Vk9KMfM9ZbAEKgNi6gLWrMTv/VEzXU1EhkY+PMF74C0My + 5Qg1OVXpXbHgedIFa0LNglHPPZma2tsXOVwDLSGXoLxL1MBdhRExRQnrUUza+l8E/lHkaQjghV9Qq4EN + wJ9wkbH4TEFCc4EfuVMY+V7hiC3/VDmPfR65JQsBfC0Mqq/GuZXT+rIILjYsAhe1EpfdRSRos4ccxdDO + //SXqFpgMznSxu0TXyRQAf5R61nhc+yZgIVhybIwGuvcCJXG4opCJoaID/avDBJVHy2aH6ldxWAMUJXc + XUs7xZ0CmGviYqO0ItE6GmZDOCRAR2CPZenfBD5i7FNgDjPhusABiuDawNDi6fmeLbiHzUxjA5tIosWy + onKZuHoYO1uWD6bAR+uLtKPa1U2M9MmrUCQOEr20BGqRRD1kAwtjPjhAU2swwE0FCJDEr+VN4c1ZYqEq + QQbfOtljxECrwbGTkUJfBg4WLHHAUY5h2ZEw/VGkgwU+AJEBDxDlxJBkuzUsFfnfMPRiiRENEtI1R/NM + wvhiYQ7aA6qycBEqwZWbuP+xh71kljre0LeQ3QpaYE7t5uVook3WJgzboLg4g6ZwZW9GZPyJxwhl1k8g + mH2OEbadnn6iPOMB4Us7jgrg1RcxslAKFl2baFR5ge7l5yjbJOA4qs7y6LjRya3ZAfXcjv6Fppi9RPAV + 4Wr2miYKlXghVb1KFQYppYxG1hygrq8ojZ5bHXUpjQdIMcOw4og16IC5WwE+aFwg0VIpX7MSULTQl6iW + 6qhuJPrJB5u2u2tKI5vJHAB5IDci6aaF5R9kaBKzECOmApYWnQ3AK2XQmvCJE63RoxfggGbG6jwrCQN5 + gRdIEFHhIy5xJUN+kWduYGj+QVrei1t+DxvQgBBSJTv/8gAu6QAd4IAN0ACCvutPw4AbuIFbuiU4kiV1 + ji0sgF3EjrsNUms5ug3OvgEbGOrMzmwsfrTqUEraspDBeGjY1m3dMmnFPJ6MuBWGLoMs3O3i/i4snuQv + CO7xZe40i2fjhm6IMunFSkznFVV9weTo1m50clruXGfF+kfUzu7tJu85khF0jKYejVqOwO7nLu/3Pp/3 + gjtPLLc7sYKFgu/8bqjBSl1OVrI9bVssGF39JvA5GpIMjLsy4Fj/jA6t6eACh/DzEbV85av4M6naiwkJ + 6ICwjvAO5w5fFKmE67VGQ55GciMPR3HY0YEYWDRvdT6o0wJ98bDXTvEax0FawNlo/+Y127uSAbfxH38R + LOocyBFxXQUGD8BsIFdyiHi8wgrGoKzkkFjyKeeOGzgLUOXPGlQ8uuNwKvdypctYzfHhpE7pZuAZe/ny + NE8MPqzomNDG9NYZddRhNadzbsgJKkFwINQIXt4a5aPxOgd0NfAV4enqacDUzIEEwwj0Rb8JG+jjC+Ov + a1DSq2b0Sq+JEEkQNBqWlJDrPeqAObf0UNckN/GAETqWU7ke+tEBShf1Vo8StkYQODmhLdmBVf9zV8f1 + ssgAHOB1XselW8/1YBf2YSf2Yjf2Y0f2ZFf2ZWf2Znf2Z4f2aJf2aaf2arf2a8f2bNf2bef2bvf2bwf3 + cBf3cUEn93I393NH93RX93Vn93Z393eH93iX93mn93q393vH93zX933n9373938H+IAX+IEn+II3+INH + +IRX+IVn+GAPAgAh+QQJBQA8ACwAAAAA8gHyAQAG/0CecEgsGo/IpHLJbDqf0Kh0Sq1ar9isdsvter/g + sHhMLpvP6LR6zW673/C4fE6v2+/4vH7P7/v/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp+g + oaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2+v8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc + 3d7f4OHi4+Tl5ufo6err7O3u7/Dx8vP09fb3+Pn6+/z9/v8AAwocSLCgwYMIEyrslgEHhw4eJMCQIMFD + Bw4bbizcuAjDBhgyHqRwgOLECRQrUjyYISEHBo4wB9nY8IJCiwYOTiRAcOAAgv8SDFI+kPEiR4aYSPlo + kMAigooFJU0kKEGCRIkSCk4ucBCBhQQcScPa2TDBxYkSCKQmMME2wVq3cNGegABjg9i7b254qOACRYID + JH5OddvWxNWdVUsscFHBgwa8kNFoKOuAgYLDJQjD3Tw1c2YTKBy4mPA4sukwGF5AYGBYsGbNUg23jYsg + wdwXp3N3wbDDwoKrn2O/LSGV+Fu2bYEnWMCigw3d0K90mKHi7NvXhWerhbu9xIkGM3REHy9FgwwVDDoL + X6t2e+zZ7KemZdBARmny+Jd0gGB48PHr7a0X33pXneCCePkleMQNE6yAFnf/HSfcewAOhwAJDsBwlIIc + 8oD/gQ4zLBCYce1FWOKJryG2QHgdcojDBBCgcBhhJf4Hn2w2dlYCCnTd1yJ5HbDQgE40wqYWcQEiWaGS + JnxnQQc/5veCCwso4N9672UXn43JuaUAjzBEid8EKliZGZcRoikgYZ8poEIMYpJXgV/DoRhgjjYSZxxh + K1AQ53gWnCAYfNcViqKR1+m5XAV/RseCAgd8JuGA2pHI1p5HHokAA4w2qtujkd7IHaYUwsYdgSScMIOn + uWFggQmDulfqhAOaeBxVqrKa26NWFZbjdrZOSKJbVClgga7OXKDsBYdYoAAJKQ6bpbS//lfssYVgYIMN + GLyErB8Y4JBDDhzoMG4OG3gb/wivwbFH61TIBYtnsasKckMOHeywgwce7IDRc9/aMdMOMMRQwQwzWGAB + CxbMUIEMMOxg1B/OWmVohb7aWS29f2jQgQQyWPAABC5EkEIELkCwEgUvcKBRwHBkoINNODmwwgI4r3Dz + Cg6oAIEMjvnBa5GTVlgrjr+iZawfZLWA3myexfYleEHD3AZNMriwggJsce21CV4rsEAELE28R8WSrllc + jcQipzHHe3hMQYwJGGC3CAbgrfcIBoxgggMPTMCBulabcQNTEDSwAAMMnJCVSZA7nhUDC6jgAgsT2KXH + 0BevhSStpZraHQkK1JtHBxakUFICJIwwwgGuxx57T9CesP9CBDLkULgZGbzQAkkmMS788MQ3zgAKY8cA + Vh5obzmhxs+LXhzppt+RwwwyktATYNpvTztP3Y9QVQIqULD87mHgwNSQCkx+AuMnEX/S/O2f4EALE+iO + B7u+1il65zgSFumwZQfezMABCeCb62hXlQYChnY9eV3fFJCC3KEPDDeIQQQcsLj3vQ9+JTFe/IT3weOt + oAEV0JwdKoYdd2GpWi/UVOnwoIMWMOBC3uOeDqvCPQe+LjAJQIEFfHTBLNjAAzF6HAmPNzwUgHCE8zNe + Cibwsjqwy3kQutjaMGatAd4BBzNgwAH6pr0GOhB8Pexh9w4gAhKsYAIbKiIWMuABFlT/Z3LGE2FJnHgS + JzqRiR80yf1eQMQ4NE84SvJcvLJ0J1NNhXp2wEEMGpBAA6hRe2gso08AA74yksCSCqBLFeVYhSA9xYNM + bBwKVplKPoJQlY1731YesIMVPgs7oIOQewD0LlwRcA4TaACsFvhANKaRhw8MTDJf5x0IeICUVsDABFJg + mTy+Eop/zGYqAXk8FcjgfHI45C5pxSTQUcswkKQDBx4AKfExMJmaxKQa4anMqqBABoSDJhRwUAEHNAl+ + HvwjCbMZv4KGEKDM8UA+38A/6E2qRhQSkNJ+GTMYNKAEr4OgGXfIEx1mspPaG4ECWsABfUohAzt4wAL+ + Wbz37fGP/yMUKCzj96UIVABB4bxloYw2zjoBS4AzlAMGPNACFHwSnsVM5ju7F896shEBDYDBKE3KBA7I + IAIlUYDx9ghCmBL0qwPV6gpcEINCtkGc1TIavLLTSy/KYQMs+M0Y3YnUpDLVjODrKA8NgAAhdmChVD2C + DSRwEz6ycqBNZFwIvcpEgXpwASSdAwu1CK/KWoptbQ1qHF6ggvDx0IFIdaA8OcnAjo4gLSmIQRwDm4QM + RmBxw5sfYw0KyMP6MaDGawAV5dDQcWZMO2rq4gko2gbznKBvSvWkRpvKwHgeczkzACdrj6CBfrpyhF3d + pkwZ68fjOTErK2BB1d4wWXLmkrIbQ//A0uCgARhEwAR2+6wOQ7tJp9azjBfCrwJYoMLpHgEHFliBSWCq + SoPKVo+KFZ5MC7yABliglnA45KlyeadhzSudb1ANCvSKzHnSV754hWAES+CCkvoXCTiIqwleueBWKtiw + CW5sdxu3gNSulg2v+km8uIgiJsHwWnC4gQX8Ajv57tCM93UuczVpABJEwMQnNsIGHrBVxB54pjA+Xvxs + K0LGrcAC+nODhNd2ojJz5rxwc4MOGoCAJmv0zUbmYSbxW9+qIECBDcBplIkwZccFUqCO5TJ25QdjPmo1 + AhKYqhpynMh3HSqiPAayGzRAARSMQATbE20y8zrf5j5QqRAUwQj/GgClPRchByxAweRYyUra5hHQW+4j + LGd6AhWw4AU3TkPzrLSZWSkSej5WWvXUcAMY8GeMx0w2Uy85WiV3r8kp0LOpeQBXy5Qwwd31oyu1zFjF + ahN+QQEPlNfAaDxZC0uIhDSx3MqGDrRAruJTLojl/b1PL1uT2zvtk6dNBDCuoJWufqViXeptLD9RoIuR + gJiflUj2SOuFEirz9DSrBgxQYAWso3c89QrPjh45uT5MAATCzO8bUCAFUFGltgfuVewetLYq56ZJVFAB + s5qh3MDtH0QtzLZHUjwNOWBnRu9qX5Cvcd7JLS0DWCBdUw/2dwsYNLezrGBZb/nbtBZbC16g/+ibMxxs + cenpQykcH0mr4UUqKEF86U1ajjI7k0b3SQIcIIOuRxkD01FdCVcpa+0KfJuBxDYJv6SCJ+EYVmeKaGws + zNPKCku9wzYDBiTgAgZ8Mt52TuMxN/5p7sF9rwiYiwQAxm8h4MDYVRrwNmd9ZW7H/LBR9KBL62P3MaBN + VEVLjnayFCGzoyHoN8z0m0FKWud+2JPPLsEKKjDu0n9oyKturNVnfGXYGxbQh9VqC0qta8TvWOe8dDSa + 0oyGFzigdfPdqEczXU+Qfja/xedbCSIA4dITwTz+3HuME7zlVMb02y8nQieQAhTQX15nMbwWXDDERZ6D + YWfAAUM2V6JFfP8cpkzDl1Se9z2XlgAPUHvTNk2xlWWL1VKBdk2GVUJZATiJ1n2u0XOP5ki/5XPENQY4 + cHIK4Dp3JXwch0wgFlobp0wjcAIyYH9HACKKo3rWV2iv510x538t100PwH0H6GNuczQPZYUyFHlj4AEp + oAA7mIPIJ0/Ip0YUyIO24UxEaAQZwBToEXguB24yFXDYdE3CowITQHplwGiE0kIOlVa+RwbmYXkiBoYg + 54M5hIE8SEET0HRp2F4RYG3aZFCtJoJVp00zBkigYQHNZ3sMlwBWAjp38oLj54BksAMQoHbxNk9hKIZ2 + 5X709EDiswAyYIBpOARw9XJv+Hcw1nrXVmD/8KNVZEWLYYBzo7J7bHIjvrZ4pCgGHHBAR9dUFthsopWD + nWRvgMFXESCFtUgE0tQArGaCrLdyl/hSMtZYqqQCgZNrYHB7ZBc9WJgmfxgGGjADDfAsSwVaGbhDhahx + 9rYpM4CH20gEqINykKNg5niQf1Zlfyd9LmVrm7iOiLdTL2QpAGIcDycfPxcGHfBePIF5SoVDhJh5SkZP + z9ZXLvBMAbkgdbQ1gTdrXNV/gMZy2ZRtSxQBKEkGt/eJjkdmOVdOJhKPYDABIoJ5nxWNm4dvHfeRPcET + eWMCEVBWKYkEGQADKRA8rjdrAOeLWAmOqcQ1KzCLeRiRoUgjEFUraOJz/1roBRzQAgmAN061XJo2kplX + Wkv1OihQAYwYlULgbin3QeRIW/0XY4v1bbJlElr3FTj5deI3lqD4P75EBhxQAWlnSXSmXHaVlPimfqCl + PSXQALihlyhGARGwAqrml/t3ib7Yf33Xd03UAA/wmWJAjLqUVjzWe8vYBTZAJvaobEiWXB6nbPXVeVYh + RMIImkKgAxXgje4DbgcmiUxokILHbVeHQja3BTnpP8AScS3UNoikXjPIBeu0m0i2bHNWgXG5SUiFgwzQ + AgplnEgwVEX1TzM5Yy0GS1x1n9q2Sn8kNs1he2JZJIy0JwD6OTpHfl8gAWxGRp1XjcYXZ8EZhqZVAP8H + oAKj555JUF0s+UTgZnDY1aGWWHCxNIAU8JDWqZjnNpui8lNbYqBcgHepxkavyFRz9n7pp4pIZQAcSHIW + WgSTRyVNiG00qYTm+KH6eTzgBQEx4IFXIJvu4lMt9DlmOXFpmQU5IAMOgFFD50nGJF9bWmf3Joac2ScA + uaNEgJwEiU2oFI4lOIdSt1WQpY1ccJ0q+n0+VZZQw25egKBoUWQN9IXql3T2VpmwGCkLEIVkmgQ2oAMW + 0Ia6OIfZFY7RCXi1BkcQOSinQjQS9z8EAnlgMI8nUGRwhlTud1+YyX4hdQChxHWHmgSTFwF+RmCOSo5N + GIm7eFv86RxfwI6KpEX/i1mbQDlHMOACCfRO5imcDxqNXypnyIYCFDCmq0oEQfdv17Vtt2V9sVVgMQlj + 7TM2I5qr/4lumFI0fJgot4kFKeUgyFWUGzWexxeGncaZ0fasSpABZcGoV4lbiNVVtIqtAhgULgADzrqk + X5eAGYNFvEd2j9kFN2ClrAM7S7U9nAamxTexFohDr2MCy1ed8soDHEABfTFg3cZdCzlojipCX1acVkCM + mCUv49oeLIoFHAABDUuUm6aPn0eXiAiE4vNlcLqxRGADqPNvLXlgIet6J3hYS8RHJuEC9VeivWIn6IYn + W0QhE5WnKuCwF8JxHreu62dkhQiLIodrPqsENmBR/zFHsq7nnC4ZglHEOFmBQhwQsFSAcydCLeH6a++C + li3qAQ/wqRnlaWNIfPcWo3+KqhWgpGNbQyRxrX7Zd1jnoVtJaysAARSgowLbKwkIpc9TKQULVN9JBTvA + AlfaXN0juDpos0eJgWnhALA5thc6NwJmlSy2oTEla151gqxnQhCgcNYZkeI6mxNmsOSakVYQAyoAK3ya + dMq6mcqLuiHlNw4QXa7LBDlwcqzxd/o3UJALawQ2a96kjnNroihaWTD0Nnh6BRrATg47iEX5eb0ZuEv5 + Tn2zdD07vUagA1SGRwGVZTD5YpUocFCUAOv5V1qgh+CnnRqTXsQ7BVOpAgggav84JJwWWKr52IPKakkp + cJP2qwT4t7YgWq0GSVv823Lvg0LSVgVX1GuL17nn1Va5ggWpob4/BI1EF5dbCqZxRgIm8ACWu8FGYAO+ + Azyo9JJUF1PP6Xc/ejxkpbFPgFYBFEPyQiDFwSlUGlfwp4+sqEkMCpzGd1p/EwNy68ND8CJas2q5+KEF + JXAhFJivBFlNWwVhBC2yoku92ktQI4tZIAEOILhFCXJbK6qECxjytwIz0MNibATXg0D6i7sGB4BGy11p + nFpM3AQysACbcSbvKLyH8jkO4CdXsAFhhINHJm8OqlwcVmc6tIEQUL+HXARlOyT4OqT7l7ZchVjXB1AO + IF7/4PsEZHICUyu15BuuZAYg3wEnVtBeXYiDlimSNaulzUtnn2YAQrjLrVymAbahRMxi1eeEgAdrYmPC + V6AaUQe82MlImgGl/vElENC6U0BUNzR0EYuzg1tvfVqjtOOUGlzNFyoBD5ATqneas7t6q1nEB4UCuhXG + VWUBQzIYB7tIALRIyHEVDJACzGcFQiYolkmSfipnPHh0dXUAJkCAeanPRfARWJW9e8SatUuf/vujAzYD + KNsEp1dUmKGiUWzTxLIjLbCCVcABLvDAo4yBgBp3RWeBO8t8gEXSRsABqbactSyykEpwibVtA/aaSe0E + kWlUtdG5tZl7b1EVC1ABhuwE/w18eX2MrKQ8lzT6cYJsACWQAriq1EyQATLQANKXr3NIdbUKmN/FABHQ + rVUwWFfagomSbmtV2MOxEwigAi9w1U3QGyiwvmf0sGzXQ1vrbNzDABZAzR2iLRmgATiAAxpwAxlwA459 + B6ZUEqbpyLcrnTN5kK70tl7B2UuwlkRyFQESPQ79fcCxYpFVBRqgQX77ZsrLzPn1jPLmcafl17wLLjiw + AeSiA/liLhuAA4hbDQ4hERMQMg4jAxMQMWbTB+rTz1YJRfe6YNybiwI4VvZh0RSw0LWRIuaWKf8xHzZm + BaiGcehHkiOJxTaamREU0jEw1nWAARwgARXQAiTTADzTAP8usBIT0AG0HQ0ZkAMIzgILfjMqcDItYAEU + IDGnPQeTMSRnq9dGG6sDN1PGM0sE3gSRWZW4jShQvGPEYhsVRKJPsJFn4T2TDb9nbZSVyUOvwyktLuI7 + MANU0hojUAAhwFdT4xUugQ0G7gEG0wIl0wAqcDPI0zMNEAEtwAIUMAEesAET/gY6ECNSl8YkG5N5va8o + AQEnLAU6YKWtkTaHvUXDAhzEEb04/gQeMNjJO8ozymGnnJkTyNh8sAE7EBIoN0wGwOQhQAAhAMFA4TMz + 8AIxvQx4JwMtEAFYrgIOEOqhzjOgrgJY3gAnwwIx0AHXPWn02EH4iqZIW8uP2nrelY3/WZBSqjYjoVN2 + u5QZX8KeCN0EErAA7JdsPJ50xUq6meYdLZDpcLABMWAWHZk3eiMCBVAAeGM3C6Re5QPtx3ADiw4BO7MA + OsMzKwDq6G4zNqMzDdACQDPScvACD6ACpXmV9mllt9ttdDiArAwFdCQSVaIcZ2KRl6znYpMCXtHqSwAD + x6XMMqqKRb2PxaQ9fOXXd5gHGdABV6UAIkAAIB8C2T7y2F7y2Q4Cki4C5FO50UAWD+AU7c4zoj7zM68z + on4yD1ABmD7sbHA4SaRVzHmJjgupIWxbXKMC+WwFHAADD+Agdhbjvp4Z+bUcLAADfR4FE+DxP7TFRMd+ + o/rHym1J/3QH7mugAS9gR+lxaSGw9kzO5CLw9tb+9iIg8iJ/Wiewfc9wOFhl8z3T9+neM3//9zRP6g1A + uXEdSf3UJHtXQoF5dQDtUqzmQX+T9BbNtyu1FlyT2Gy1FoXqAQzfBFkvahK81sRnjcsWqPL3AFd/NRMQ + ATf46Np+7XAv+3mTN9n+9rdvAmDWDGZvR8gj86Ku7lkO6oCvAsZv/DF/QhCg8zowyWowWFjFyI1PfWs6 + 67FlAkivsOM+Ek7UGU/fJFuRAvC+A2X+BA6frnBXgV1bzxoXTwvQrHWQAUtPjyZwAGu/9iVf+7Mv+7QP + BCEC6LCa6XhJ5ZLZdD6hUemUWrVelf8YDyviWK28DtVKJVad0WKzuexVNVKtyiSHwd7vuplqwTgx/FAC + AU8EBw1RChlQEAf/Tv4advCmbnRguBwYTBAOSBBMGFQiWGB0biilJBhIDlw9W1thYWM9Z20/cV1bRxBO + XCZThaFuJFoWFEhGDEQKRESYowuYoaENrqsNnJmnSRhmMobFx8nLqXIq2sLcHNTays7Y4tvBHBYWVhog + ZDpQzYczbFHBQIEiQIAEJVx0MBEjQoYKKVS0wAWSf0oCwqDAwkWKMykgsKAAo99FJR4clKhFi8TKTrha + dmpZK5asEQdORIChwSSlDDpiNFBgQEiIAkefQXOWNKm2ZkqfOU3/WuCACg89sWbVinHHAy/11IAB204N + WbNnv9xbkcKFBQoeNmy1ogGGi00LC+UV9OehQYQMDQWKqOIBh6wYMuDYoENHhw46OGzAkcFG1g4pFCCQ + 1fKATJm7ZtIUHbqVgSIUeMqt5GGGiwUmDjQjYHSp02jWoGarlu1oCBHfcqgWPvwOBg4xIHxhZ3bMmOXw + 3MUjs056ilJxiUPh8CDRQobfGzLM+9CP90AOUlTAnl11Du4JlNXcBfpWLlufX9o6MKJEhGDsmchAAghY + sYabqaJaahpnttmNGqmaKcCoElKIITUAMWQPBxgeSOEr5qaD5x02yIIOOrFW6GOBBh54awM7/zLkIYMY + IlgAhYLKWyg8RBRR6C+ExiNMAn9ixEqDGDBThiX5OPuMFvpu8aSEBWQgEkAMNvCgArsOKGqpqHjDTbcx + bdstwhEUcOGqItncigMLPApDOnimWy5EMchoY7o6xWqHLTkkwKFIHbZcAJK9ED1oEb/6ggiiP1yIIbg2 + serAAhRIMKCVz2rJj7NPm9SPlykf+A9ADV5gYYUTVHoGqQSZgjW3Mm1TUBtttmEgBkp5NcmDFs4Ktqw7 + 1anTHbL4LAMs62DgAEYAM9iBBQcUGERRva5t5KHu/qgWAg/C6fWiGyZQ4QDTNuOUJV02BY2z/RJIQYIL + NTQGhREkVFDWZv9ura1BMHMLEyoJE6hA3IPHgSEC5dxoDs8R6VF2xHruDHYM5VJ4QIYXOLCSOHJVgIQQ + wSCy9hFrD3qkEAsmRdgcHSAo4aaV2qVJl1dk0W+EEU6wQFD2sJQATlYKmG2bo3OrDaoyZ5VKmqlAIOGB + cF2u2ooZU8CnLD25Xq6dE+MBm5095VSBLQvowLADCPZyJNHyFDHokbYjSmGCyqwm54YZGNAMZ3Y/Bbym + nD9R4YUrPXhghQRii5BBV5mq9UBaF6ymQactjxqClvPu/IkNKGgABeXIAGPOd/bs2izTv4buazy9WAA9 + FibQQYNnhcMhBhdW8OOPkudW1NpEIVmxAov/PBdn7b53noVJdTe7xYAREjBiPeE04ACGFlBAQIQQwP9y + 6cqfAthMBx1UWkEhDkihg+ThZwKdBrR+nTlk1ZGY6zzHVp2eDx0QAQhUIAY7oFd7KBCBE+CIPCkjmdt8 + pwATGMEw8RuGDTzgAhMsY2bzERXg5tMKZ6DAAsgTDqEg4AATKCNf6kPQ5Sr3NGlQY1az6g0BquIBvFnQ + cxgglOjGQifUDbEsx3Jd/tjhujB8YRQseMHPhrOBCmjiZCkLj2AWlaO9LOBbPExYA+DDLufFZIyv2A/1 + WlBB4djAUt07ClIexy+lPOgp4psGmJBGOfPdsCowoJoXrWYDPQCxfyWq/1jXjBUx/CVRLPOgh3JIEYMX + 5OCPWvHhDLImweApSlsqOxSLYOAxQN5Bdwo849/0Y8Z3nbEXDHDBC3CnlSxVIALdEwEBZuMb89XwX2Nq + ytJ2c0du3MpVBBiBCiYAxVG6zIcVoB9YuqYON9ypTg6TmBEX+bVEvkGAMvDAAbXCgXQooCBxa8jvArEX + SPzBAU6s5DLvUAwVJGBnzWsSaehzk52doAU7iCVWfEgBFSRDGc3wzdGQdrn0ueo2/UrfbXzpKiI4YCfw + rNoFxElI5zgsiVtrmCJBOk1EdnQdDmDECiJgAQnUQTgdwOQXVkA333nyD/do4gveaVEs3CCBN4IPL//M + +Iqb7OcTCVDAAljgT9Vk4AUWUEEJhEAAf8mxKXe0oW76RceAEROYuDJmA16wQ52KawMySMHo7Dcijl7z + HWw91taQKNJpfihjMyCJKHuCAw9QoEOGkuBfC/JXE/xBBQN84j/HulMdTMArK6ThzqLxoAMwIAUWgMGL + 5LKBCQCrb0QxCqwgiitZcXWOAKsVmJw2VYkeQBKITWyReJo1hjmsmoWc67D2d03bnsWRX9NHBTyA157k + QAIzWJiNHLKIhNyjAS2gQAfE+tpUMNWpDCgBAjST3ZhgtwQMiAA/VGMcGcxzBLEqH+S2iloXgvZfEEXt + VQsQNReoUbqUsoHCZJf/TYklC5u1XYMhX0e20ukJWWlZgQtmwDHhXgQHHZhABSzwgBZAIAIpiIAAW8CC + GUxgktGtLyXYOIEZtCACDbAHCrQGBxc8wK4s1UoGtGeBlBTNaKUlZmrVy5vItjePwkyvNCSEgAeA88Mx + ymA9lPhWJUITf8ayZsN0m00mfuUNIBHJDnLakwxkbwcvmAAFYgADD3AABwsuciowwGUYyGAGM5CBJHVQ + ZtdeJAcyqJFj84UgOeL4tE8DrWlH+zg/P+4oJjDYmSmlAzgpq3VpwO3D8se/iKXOfs+hZm8ZTQYXAJfI + h7nBBjiQAw1kGdHluEEOHhOZOZvkJxVYQQkipMsE/z3tS1JBGnqdoq8b/7Kh7OVGCDRF0VK3CQebbUAj + wyad/z7akUlWZMUo7dFiiaUBKS0gZof94VWz2gMygMACEECUPOca1wil6tForUcbYzWG+pIQTiBgqmwD + yAY7oCWVlfzoPPmP0ocEi3+TFe3WZYwCOtj2vBFOCbrYhQTni9z4RltVpqgWcxInbWgVdJQSNIAC10t4 + dm7wAq+MhTlomIc0T5fWrRFLm8eSNFrGYKMFFNabLv74zYuj1wqkYIMEGABtdKw0QD9ImD5mGg1lWBs/ + p1ZCIjjBDOiLc+JswKl9EqIRnaNNjtqJtmDrt26vPiw3gKQFduWAh6WediZsQP8CXjkB4zz7qhqGqc+3 + lpx6HYp0QMNKQQdwgLzVvtTtNSCa8gjbw1ZXrMMvEuUqD6k1pZkiB7jguaQO/M1BF4ENvoqG6CO6jv9M + d6VBCONYnXWCpoETFnT68lnRLAuOLeAjlkiRJ99mxbTO9Y96jfaxY0RhW2z51pd6Q15RwAjAB/TOk/7W + 5pW4xcvN5/O2Wym4HAEKSjX87OBgQKt73eJJajonU/PZSxYRSMNOp0YK0AIvYL32i/ymBaikvG/sDUOn + Kr4bL2j5zU/o0ffMqj6vaEIgAR7AhOBPNUCnBeKkbJRM8cAu2s5P8cjPWAZs0iLPHhygAVTq/RJwrDAg + B2b/YAEOgADl7ilwDOLqaOICxl+ogXxy7HyIyf40xQRSYE0+cDi476VgCgxMLMD0q4jOD/EozXVwz0Ra + J5u+ggziQFJysMi0oAUKxCg+y+GuanyILu/4L1Yw5/PMBBtwxSiMhgQWwAJ2AO2eMCuYyrgIT1gaRtKg + qXT+x8m8Bvdajr8qjeTAYEVkwOPSEJ4wYAdcoATsD/ocCn1My+5Cb/8sJ9Dm6ASR4gBKYAUqgHP+cKk6 + IAYsgAE/5JAixn8gBnYiDZGQkPYukH/4pHdWoAXS5hItKnFOQAQGYDYWMY66Ko92SY9miN0Q0dYkxCgO + QAEmzwldcft2IAYeQFlYp/bC/wIJv07xhDD3MPABy+9DmmsCzKwY82YDWuAEMkX5YCjoHorHfImO9C5p + VDCYaMzpIsVZtBFoYswFIkDZkHAI7XAeTIfREA+3nI33Ku1/2gkB39Fz7msByO3h8MiGuhDdTm/Xei2y + ZCWhkEJTEgD7cGogMeQGOOAFKoABZa5PyOYfL62IPIoZLa05Cg/avkAn/BAjmSlxEuB7fmlMiu7Ham2q + vPAheXFfigYEQiAYVYAFJODsXDJDBImvLsYC5xDxoqwaBwwfxSbyCOzRwiAFEswDi5JNOGAGHIAE3qgR + FQqYBKa00EcAIU6GykfQGAR8DEABKqQls5I4bEB7KoDCCP+PYTxxH5+sGYvFfkbykLpuv/JhHwQyLnll + AoQi7s6roczy85ZuESHHHNvrEQ3qKDpDGB/gsgyTTWxAA3bA22JOa/AwWfaL91AxFJEI7AKsLwnjcDZT + XGzAAjYoMvklHBeKqxix9EJrX2wtLX1SBBJABQouG19zODCgA2TgAeYxNSFm9uxx9kQqdaJNOlVnJSeg + OHsFB1ygSxjEjsTyLOdOLHcxN6vqBY9iehBAAThOmbCzSGwgB/aKBSAgKW1L4Kjj2RzvrWgvFBPPHoRT + +NpTODhABQxAqrgwhhxx+XqxNg+01wYmQozGACZx0wIlQMVFA7TEBZSx905uNfXHFFH/rpFyzwKFCA1S + RAVmAC4tVDiYygFuCYZq7RZNb5jWjRd1EoaALl4ogChXVFwsYQI2cR47MQKXTa3W4AJtD4n2rQ7LAAWC + Erp69FRiAAUMAATEZyryDr3wiM9GbwuHzlV6owB64aggoBWj9GB+AkizZhHy0a2ks3+WcTVBZGKKiE9m + rlQA9EwvoqwY4EUHhvR4DTcaMxErLktvQ0KGoABKwAEeIAZ0AA31lNiaKgWQ7H6eo0Sg82H8jYhSc5pk + 5wHcL1KHYyv71ECngkEY80G9cKFy7BzjaBuoxwigVFSr5idgoCM1FKZAqrYoBhrrlKNItBpjRwVaIFRp + dSt8yAJi/9FUIWToYEgyJ4dMIu6NpIp6KEulLPFYEQYD9MoCXMAe8IFrCg8C+0eJ5qQkz/VOjVVbs0LR + lhXYvoT/FJH5PC9yegkXe1IEEEBWiZNdKQVVZKAFGqANgxX9Eunlym9/5EpZPjW4/DUrxKlUb3Ixx/Ic + 7w4AyW0iR4AETqABKiDqHtZquPUYWcAjUiRcxTX8ME0v9zPJSmfm+glSQ3YYcIACShXYsJQsl8YxKY4c + a4XGCsAb9qED2HNmO4ftuMA5kKxDpUyIyK8ZDZZhg9IdjfYfMmACUMBPHxQ8IfPiQi9CZNIAEACpZrVq + 40evKMACIMBkGQYD6xH3UJHZdo+J1P/DbC9iBwh0Nuj1vcgSN7uUoRzn/oLxwPjh4Oz2YDDgBjoAE+hH + LUiqkKSyrVQWRBYgBShAZg/3DjggBUbAVBVyJk9r7o6uO6NqBBigBWKAA/I0c12mWzuiARsJ4Iy0P2kX + SSEABljX1B4A1hxnBXnW82rS1siNGTwhAZDqDHN3mSxBApLz2PChUh+vV5lSrpLQdDbtfZJXHDBABsBN + G2SNcg4kEb+Tho6CFr0hYyaAarN3lARps/ggXPFHdaIyCd32K1gkmdZXHDwAAk6AO1XQ6OiOUPmOffhJ + M/NXp9huxCrsYn510hqYGfuyQtT3gPGALiKABMKnhgo1LJPGe7v/obs4EFwoGAQ3YAcoQGBjqlLrUevc + VHLxAQLCaoSFAQcqwARwSf/MknzMUb16UkxzggJ2oGhlGJ6OIxOmcfzi6lIbqQFSdIiF4QVWINfUsm9L + y+jiSGxdaUicWLqw5AU2oiOWMNNEJNlM7kTwIaUucovxgIYxxUsWtFnJVzaMgnoowpuwUo296CeQ8dg+ + hFxNUpv6wAHMEHPxGArQYQFkUarIceLuzgRFIE0ui5ALGZCMA0hJzMRQpKT0cIngoVj7dZKdgOpOoLwC + 91UqpzvDVExBgYtCCZQRzRJutQVCk3QoZom+QmsQ7JtcmRLEKSVEAARAAJdoYyJJNwSCmQBE/8AECENS + VneXR0mPBVbsVBgqq60CsNeZ8eAGgiLcTjAtA9UAEiACYkBFsfm1bCBLKGAGHkAe0wCm0KDaWsACKgAG + bK6csYAuHoB+WKU0KhPYroEEEoAB1sKJyNmepSsDcuAFZMBbSyzm1uLCIGAGJCCIDdegoQAHTBhYTOC6 + SjCYRcATEIABGqAUOOB2LDrhcOASFpoFWsAFXAACLGAGKuAtcKCiTzoKbsDeGnoFOCE9UcwBnKsDmvmm + EytxcSAHQM0xdGADJEMDJJmop4BbdWAHOsDLYiDMXuAFdqCkobqrvfqrwTqsxXqsybqszfqs0Tqt1Xqt + 2bqt3fqt4Tqu5f96rum6ru36rvE6r/V6r/m6r/36rwE7sAV7sAm7sA37sBE7sRV7sRk7KzEAMWwAsjHA + BiKbMia7siObsiVbsy2bszMbsy97s0Hbs0M7AywbI20ABzigqiUABlr7tV07tmF7tmW7tmn7tm07t3H7 + tala1Gy6sEPQA2KgIysMDirMwlIAuZX7uJk7uZt7uZ07uqF7up+bueF5BihgKIca5zRSIyIMAuTRpcV7 + vMm7vM37vNE7vc07AlwgnmWAwyipsQPkM1MoGTyrKGYjv/F7v/W7v/n7v/07wAHcS4IRBazSYXMwe7x4 + Bjiioc/AxCB8AyU8wil8wi28wjH8wjW8wsv/AKJlOgY8IL4bWwM6YEtUKFMIQABUfMVZvMVd/MVhPMZl + fMYFYABEAKAXIAISrKA/TnEngAUkDLyPe2CJHA6IPAWOPMmLfMmVfMmRfGCf3Mih3MmV/MJeugUkzLJ4 + NLHLiry4YQgG4APEfMzJvMzN/MzRPM3VPM0F4AOC2SimZ1GPYPgw1NugvMLY+8LyXB6tXM/5PM/7PLz3 + HNAH/c8N3c8R/dDzfLkJj0VS96n3upcP4APafAAsfQCAOdM1fdM5vdM9/dNB/dMxXdPDfABUXARISKnS + bi6ZlwEbHcktrMIEfdYB3aUL/dYFHddpfdd1/cKke2BVwAVYAMRrurA3/2B7FgCDKf0DSl3TfW4IoH0W + g3naoZ3arb3anz2YZ1Has73buX3bsZ3aL53SBYAIciJ1pe44+YrCkNvX8fzP9Tze2Zst5L3e670j4N3e + 5Z3e9R3Q2325Ybp2CBsDKMCXwRzTR93atX3hfU7bnx3cIf7hh4Dhgbnho53hMX3io73bSR0ERr0AxnYG + hHjYdMDbkju6EV25p/t18Ty5X5ctTr66Wx7mlZvlXX7mT97m6T3WfT3mWXHk9RoDJKArU7zNN33UG37U + lR6YEd7jnb7pof7pnV7qnz7hp37pLX3qF37px9zGqWS7LerYG9y4Y73s4X3n5ZHnZX3t2R7t8Xzt3f8+ + 7tde0N2+z9u95TcNwf06IFogAULAzTP+2ite8MO92qf98A+/8Alf3BVf4xPf6pk+zAkAAVLAjxBuB9f2 + 7mF+0Xl9z+mdzw+dLXKd1ge91gPd10Ofz/md0C8MDlqAH8C+rbuiTz0+8Cfe4Ree6S1e2p198BVe4zP+ + 230/93cf9x3/2nmf2ZMZhn97lLRgBti92t7e3c2e7RPdyt0+3zvC+rkf9FGfvUH/8/t83tNe9V2+RUAW + rzNABhhgBDzezW//4jMd2o9f4i3e44H/8Y8f8S8eCAggkJA4PBIHRoJyKBQOPoSCibXhYbPaLbfr/YLD + Yq8mBmmkIpH02qVOueP/EZe77YK/63O1+u7f1/kF4hHKtfUdFsoZrjW0vGCMSU5SVlpeYmZqborluIxE + KT0lMT2Vgog6NSUZsTI5DYkOFJ1CvY7C1ro24SoN+H4UOHhwFhuHcVSkqKQ16xHm5QVG/83h0en14fHB + TdNxfx8aPtfBpTSruMRoHLe7v8PHx9vALIQISB29Iu3XpuKqaoWLQJGAqmjlYhXw1JJZS5Z8EDDghAx2 + 8i5S0vDCQgNm0dK42RZuG7hp4g7lIXmNHB870tYkslbuW8gIKiJU0BEJI8+ePn9q4sBCAQF8RhyOuqUv + laxcDh/O8vXkn1OFrnbBUti0yAB8JSB42AkUKIYO/xRawEwbE2W3lzMR8ZlJE1E2QNTiuoWrJ1uzBhEs + wMAxdjDhwj1vTFCBgMAHXkeQUlVacOpkVJIXVs16SpZSgY77OYxC4MCKGRYNY8wAw0KLcyBRhty7Z07s + azJv026J24+52HtF6iapLc61cxFayNCJejnz5pQ2sDAxgomvh/0w62slELvmhf+ekkLi+Sqqhqp+GTDh + goPzeDhiPKgZ7Q3e3ieDyx2uf7jJ2fZxtyWTbbPRlwIELLyQQXsLMuicDhGQUEB5BzkW3naXYYUQZd5Z + ZZ6FHW6I3S8gFECCAzs02E4OFZSjlh32jQPTHwGylB+Asd3GiI2CELgNNGlAMP/BaSkSWSRGHqxQABSx + 8JPKUrtwNZWFrzRFnoYKAbShlBp+NmIIBpwggZGcCGUcG84wgh9dfQwik2yDEDdXf/uNxMiZvnEDkww3 + jNmnn8ZIcEIU5SXV0JZPeniLk1pal5VUsEB24VOHFgQMAQlM8CcmOjyABkzOxFWcnIUkEs5bos4Zql0i + iVTXIrkBGEFFmtJaqyQSmBBRl1gSWhVXjY7XWYZLIGQVLVVuuSuTCMRgKyU6tNCAp3e1FKBw/b1lV7Z3 + /SFXnPMBIlyo5aSAxqzOopsuDzAkIAA+x04WmZXmKfqQZ8e2EpWh3xWbpa8TfvABCc2qGwanKvhVqjaw + YgP/F4HdglMqnG+9qVsgcLIqh48wmTtkwR+PCYMJ7n7wWEL4WsnLogZ11jK9W7Ec6VWS8cKYwBSA/AWn + 0po5bjUskTogj3Pp9ZLC4pAKG1441tRMGufmHHWKEigQkYjC9pvZUVkzVBChKwc7Xsq8NvFLCZlKvQUH + FhiXlm3kxPjquLrhhdLDgFysNJstVRNgIttQIFjagzv3gqCNTWivPwhFeuh2WP5TqHXyzjz541QSgSnh + WWwwA47gQvxRtkLnuJJ+Pys8Dkl4wurSG+cEyefmsxe2wwoiuKIo4+FNiqxmoSmOldgoZz0sQL8QJEKY + tONwFh2ggrv3NDSeqjHQsh1d/5dtMEZsVxtsQPCABArSXj5QD5JgC6JLel08o5NC3uTWVM07rHZVKRGC + icTMfoMErK1BEd9a3YByFDdvaOs1aToJxfhmrfyUywUtmMEOxGK+C15kAw8wgQEmRLNC4atYTQrhyggC + NnidjDPdsVx5fiGCBLhAB7TDgA4owAK3WcwleBIV3XBztJdca3sIpMtr4OI347BgAlfAIBPloQEKrCB9 + iAPe7wx1FGBpaVHVCaFBjKcy4V1mUAdYgGnKdwMPsE1aorNb3PTCQ6P5Bji7cd0dIlZA3pgqJA1wQQV2 + YIMmAhIeHNhgUUqWQpStkDqkWMV1MNSv76RMclw6CCokgv8ACEDCfByYwTJARTTvVQtOcHxYW1iSm9C9 + DW9rtN73VACBwAUylu2gxwJA8K4vrs8fvJKUdpICGcc5kpHZqZeUkoAPinhscxqYwBk+9RuKlRKOpkSl + 3OS4pujp0FV5SkMLJPBHWYKTEzmIwAgaM6LLFDNe+wpbOnHZNSd1Z5K9s9cvgqEC/pkPAztgm4uqQZvP + mW4+hvDbAmeEo4wxjUBLY8MdwJeccEJUExmowAlEUM/JNTI8xEukRuP5RRDOE5hZScIvBhCCBLBAcBfU + yAwg4JqLkWoRNZpJQH3IPQTGySRBO+g3CIGcHZAvokKtxA5acIIOlkxfM1vFMJFiv+v/kEdxH8VO1zBD + pQ+8MAIvAGQOJnBD13zKYaH0nulGB7dw1G2spxsHj6ARQAjMwAPJHCpdwZABD0CgBAUo6Qmd4MuRNhJ+ + ukuIVUPaRSmVDRWhAAECGgAD2TWxAzJwabl8VBNByOmfs4kDTbDhWW/I6bMNIxpn89Q0sD5AiXVdrSRU + 44ADMOZdF7rXLzXKVGI2FYsV4lqjroqPARgABRQIahNt0AH4QCCA1ghrXXqITefSbacuopv2wmpdCFgg + BjJkLXfDcAMZOCABIvBaSQMyosS2kEnmVW9iz+uL6qwCvumtDknLOwsCiIAEZFxiLDGQAwnI4AERQENl + e7aIbkRT/25yI2JnNxuubz04rOfoiF9YQIEd8Le7Gu4CDmDAAhQg4B7uoq+wLkchp1zpSpIC6UDgG4WI + CAAEBziBOnIQUQ3sgAJn8MiZHtzgHX6LaZxFq7aK7Fk3tchpzEitDr654Sd3YUUrOEBEzLlFYvXWOiDM + 8pa7zOX4NsZdIkCBBTpgwXBm4LgsaMEDIFAOArsmznKeM53rbOc7yzmAYHUBBFrAZsDk4MxQHjQWNhCD + BiTgAAYQQQigUGV8kAzSkH40pSMdMElPOtOPzrSkN+3pWYSgAAYYAQJWkBPW4kAHL4jBDFgQEhUgTFqy + njWta23rWMda1riWVq5tPetYO8ABcP9ogQUqMIEXcACyhF52FjQgWQis4AQIGC+M3WXta2M729reNre7 + 3e0BiOAAJVhBBOKqUtZqQAcSoMAM2sxnOrj53fKON73h7dl6uzne7873vkUrWn67gdgyOHaymW1wLhh3 + stGedgga7vCHQzziEp84xStOcfweQAELSEFc57paG+AgBx3wAAxKLgEYnDzlKF+5yluOcpe3HOYsf7kE + am7zms/c5B7owAZu4OSDA50HNsiBB1gdHzM5TblIV3rSl+70pkOd6colMLEpAAMOEDfoWt96ujBggwyA + /esZEDvZw272sZ+97Ghfu9rbnnaz2+DrNhA01+tu97vjPe963zv/3/vu978DPvCCHzzhC2/4wyM+8Ypf + POMb7/jHQz7ykp885Stv+ctjPvOa3zznO+/5z4M+9KIfPelLb/rToz71ql8961vv+tfDPvayn70lbHAD + DWgABxvgwAZwoIEbZJ32lPA62HP/e7AHX/iEy4DIYTCBGLB7BhWIAcqRrWzlhyEDG9CBBzzwgufHoOYe + 2AEHNEB37BcMA6ledQVYYAEW5NsC0pcBDDyQg+ujXwsZSPUOYAB9dsufDMhADEyABOzA/Z1f/tGKBnCA + B6xbBbzfAzyAn0HAgTyA+1XAwBmgxwnfDXDADryA/1GAAFbADJhgBaCgDFDABNSfDmxA8ilg/59gwAZ4 + gAywwAT6GQ5K4ARKIJvxIAtUAAxkGPZpgAdMgAygoPSVIAoyofQ5IRLSnw7gXwwWiQ1sQP/ZYHz4WQ5u + IQ6yGQVW4AMEIdZh3wwWnQxYQBqaoBM6YRKWoPyZ4AqSHwdSoXPgwA5MwBt+oQ9+IQ/2IA924QVeWAKy + HgZwAAwg4RIqoRIq4hI6YgkOIMFNYR0uhxnaIAX64B/+YR/64Re6WQvEAHvQ3ga8wAzIXxM64iIm4iIq + YgBOQAfQISUChQd+XxZWYJ+1QJ/tYCbu4g3uIhiygAxUkOz9lwyY4gmmoiIaYyOyoSmW4Ap6gAvCoCz2 + BA4UXbvx4Q5q4/8E3mAfrtkm+iImUkAsmp4G/M8pumEyqiMroqIThp8UUiNZ3ADRUQBrVGAm8uENduMO + fqMf9mMPJtcMbNfrcYANwaEyPiE7zgASsmJDFhsFSADP/Vw8xkOaHWEE5mIXtsCaheM3bmQ+cmM2buGB + vMAQqt4d2lAbNqQbqiQzsuQbLuQAwsABTiNFbgKO2dA9+mEP+uIPbiM37iQghuOBQOS5pd4NdMARImMb + QiJTNiVLLiM7LmEajmFN2mQl2EC6rZoF5FsuAuIuhiRPfuE+hqRHfqWFDaTqbQAiJmNLpiJDvqVLqqQa + QmQH5IBVXqUYZIAOICJGaqQEmqU2biRQdmL/T4qkJ7IAPqmeWTglUzrmI7ZlOi6kIjohBRCgB2zARObl + GMxgjtkjF/IkYXKkD3KkUIblYHLiF0qQBBBi6OmTKRbbCarkKkJiCbqlY8JlbbJhBiIbDrTmZmKBFRph + FnplH3KiT4bmT/IiavYiDvbZBODl52XAC7TfUj7iE77kQmqnbkZlEi7jI6pg/XWAbwLnF2QAB0xAq+lg + aoLmRwJlabonag7mafqhmz1ADBil6d3AC6BhS86mW2ZnI3Knf9omCsbAC+SAZgIn8+0Aq8GfTgomWM7n + T2pjN/YkUI4lIHplDASaWkoABBLoZP6ngIqoZKZjXB5k+I1ndFLhXgJY/xr2oHHKaGoK5Ud6ZEcyJ32u + WZ9RgHKg3gzCQPtdZzu2ZXeGaG2+5W4qYXhiGIui3w3wZQW0GS5q4nFWKYb6ooUW5k7Op3GGjwx0gJNq + HpD2p1ya6FPi5lM2YiKiYiqm4QB6ABlSJA50gPO13xbm4JXGZ3LiI2HaaISGY2h6ZXJMomvmAHWio4jC + ZULmpkJCJTM+JmUqIfVFIznO3tBNAFfyomB2pHI253smZ43uY6dOYPj0qJhmXg1sgASsIZq66mMeqX9G + pZGuYxy+AHkqoPqp2wygBZ9tKmoGag6SZY1+5a/+YWmO6qA2Weqpal8yoiq+ZLQmpJpCq256J4lC4P8D + WAAFxKmlrp4ZHmH7recFbmSnTmg/wueFkquF/mmOFmYusgCH/qbn4QCiymZkSqu1FulKOqq1rqH0Ud8L + 6IC3nh7zfeia5elXKmw+xmc/Aqt7bumVYim5HsgE5GfpnVF1eudtvqqRfmeJjmissuT8TQCGzSvpeeAZ + ImybHefDaumEgqWWRuyNTqy59hkMoOqYesAxrqQyqqOZ9ux2QqXQ8qszDqAEuGChlh4Nsts+GqegGqYm + FqvTyuwmgqXUYihAPkAmrV4HCGljMiStNiYTUiuSjq2JwmoKWt14rp4VAtiOSpAuBiVzgmTdfqNhUu3E + tmu69uEMdEDrcUAMXCf/yDZh2G7n4S6qboaox/6sbZLsDuBq6dEpDAAgwsotPpIqfEKthOotlmZjqDJn + Bdxq62mEUhapS0bm4brqvn5s4hbt/EHjwI7eDL4ABXghPn4uYequoF4tYJLrp/5q1cJnxS5rIdKjrJpp + XKZpgA5p0PprOy5kySqt5Vlh/9VjV8ao1dJtsE7o3o4lSOotjuruFvaRgqKeDegAq01r84rtowLotD7r + 0BqjY87lDMhhDhCs41mjMb5fIH5uJvakzOojcmbo70YoxIpkp/5jEpnk6pkjZDbkx/ostC5um95r/Aao + Si6pZUbk9Dre0HlABWAv1j5tCXejcdKs1YalzDJs/97uocANI+zRkFJaZ7++Kr6K6Gy6L/O+r/S9H2Cw + beX5F8ldogTRaIWuKz9KLcy6MAtHaLFCsWoiRwd48OlBaXqqYeKG7TqOrAVjK7/qa7U6ZhpawMDtXOQ+ + 3gy329z+YAn3IheOJruKJpv94/fe6BEXK7x6QBWjXgbkGAuU6LXmKxffpgT3bK0mL1MOYElGHo7FAFfe + 4h4u7IU27Kf66QmT5Z8CL33uYRiWsVwRYZ1SwA5jJwUnqb5eq9AmYSCXsiCXsvxtK9LmLN9pwGqccMJu + 4/bC7Phu6XKm6wp34hMjLLxql/nGHu1GX0LGL+OSqNgasm0y5Pqasn+24QACFf/j2QAa8ZncbuIWjirv + ZqiV0u3uwiwCg6MXSqD8xUAHGPPsHeoEjGCBtjKawi9tPq+iDinQCiikpmGPtjPgpZntbrOGzm3ebrLn + bqPD1jE50+xIuoCF1V9mUmK6DacaNjO2dvGRyuUiauesYifQvqkEcMA/+51kWQA6c+ELJ7RYmiveai+p + di85jyuPIugsv94dYjEyJnJ3nu6zKmRu5rPyNu/8XR3i3QAM6KDE9qmflWbWxvT2cio4v6x8jmUZl6z5 + XaVW+l80q+kNg6whNyratm/Q2vMzegBJ6x0NnYUu2m1Z+q5pXrIBL2eXunDvDuYniiHSYjVw3gANCu4x + rqL/VBIu2g4tMzbqoi7jKiI2ZQqh4f3XSefp/x5wLzenL3ujaVq2WUqytlrdxW7m5LKbYqOuKhbydRrj + Fvdr/L5vI15YA/fdXQVYe0ZxOMd1jhZwWPJpCv8iBQJhDMxheXZBX6ua6S5lWE/zaKcu0M5qvppgFKK1 + 3W1Apia1G0O1Ac9sdcdxUGr2BX5lVRKG12HAyW4Y8Yn3LJHiKHvx2ZpyV180bj6rR3+sElLAC+Tv1umA + DMj27lI2n54zsMK19nLiMF/g9Il0eXNCeN+A7nEA72nAc7MWBmhfDuTABmhABhj4gdPpqo1gq9Zzamf0 + af800ZqtZEalCU6AjQleB7TU/xF/b2W7tX9z6bACr8M6p1fOAAyMp4NvAgYw4A543wucHAvCwAt03w5I + 44Zpnw74+AsAeckN+QvswA50QPldeCacJ/u16sYSKWmPOBifLnKPMQWIIuBls6uFTzhTsrrmcpbSsZ/+ + YlM/rMK6340XnE9UbwywKdmmowxEpGdHFFKypVRmIBJuq/3Z9CUIJ/St8qK6t2h/9KOPtmAP6BsmR5Ub + nP88aJ+KahQ7tZ5yd7lWqG2Xqp/NQPg1qU/MoKoJLguwuvsBMhm7+kLiuETTVfW+aKuT8fvB5pwfmw6g + 8UXweAP6n20e5Ma2L5qCdSqn9+r68IXpONDRAA5IgKuh8P9Bf7ocV7b4vqu256IE0TkfG4MjjyBcnqKS + 6jT1YdhQ4diwE/sxynM1U4Bl7kB9bwIIs5pFQ7qyO2orwyozt+UnHzqhXcBaWgCfcem1i6WLu/WxZjs/ + jvNGFptIB7wl3ECDvh8EQiZ3jqwK0veNecAoO6We8+sPX9jEVwK4CuAW76uW57N7h3HipqIpysAeA14N + dFjBVzuaAyYdYy6nNqx7avY+6uIM9HqDzyIeth++X3TjHmiH9teh4nmWR3DqnmLJmnwlzGOd/nUNNy7H + ijFyg/TMg3vQXYC0P+jMHrBCt3Bc23Umb2Spw+Ng1BC+UzMPU6YEuLb5rCXGb3SBnrL/41b6YNAinht2 + 2ioqvwu113fnJ489tNeymWvvpltyTPM3XWsoINOf/Vm6JviXV2F+BoP5VD6ADLxA44OMHweYRZ+odT4v + Crrf1W1+JqS6EYL8ektzOy72e1Mrbcr8NQOe/0DywvMybZtrMHM3ZnuhBZQsDjz7MXDAurk7/U5wM7v7 + K169plgkTEom4V7wyNqvBKD4YPB4nUYzl0dqyLquzyb3tsbw32Uzzse4hGapw0+sXMP1WM65b9P7MWgE + EMgqlRnRWEQijUThTHisyCY5XtV6xWa1W27X++3mJs2Z0gw9n4eyVwb8hltvHEmMMlQy8XiZszhE23MS + XDKzkNGJ/1NcZGx0fOTpmIFoeXiobGG5vNTcxMS03PS0rOQkvYRwgWChkNDRwIB8xNCZsCgDTCP840U7 + 3HGTFR7uytjp643S4wtMw43hIGbEmNuBkbFgwU1rwtsO3PUuLIuhkj5HT4fjkGkBJdXsLIV/0MRkyfQE + xTd1d3mQsQOWOjg4dlDAVSiXwj1QmJSxUOGFBoIVGeGQUOGWwkFI+jB72JDIDAoCLYK50QGGRl1+RC7r + GDLZwyQTNpzEmRMSDluX3PXrh08eUKL33P3UNiOGSZ1bbujIOGOjLoe8mnzMdQsGBxtNvVrJwGGC1F4x + BzXM01IGjA43vmYJ+2KCnZF5Rt51mf92CccnuChMfBtYcBUbHWLgm2dKVL5M+RQv5nQ0FYRDEjoMHFxF + rJo/IZthPYKMnIebmU9ueEHBwkZmnVtyVGZEhoRopnnY2KAS4S3OfPSazUuGZSsdsWwft7jBQ4UWEDx1 + MiU01CZ7iuUNtVASB/IMEshWperySNklUoojT2dDx7UyVl/D/Gh25Oo23HNIuBPO465uZzk/uww9AdPB + IAcKHqCklHseW/Adfj5BqoIJXuCAIuQ4gCEbvcAhTz5e/qDAg64swsAGGzK4AcUMRrTIBg9i6EYm31qD + LY3VtkIPNx3kkkG0Zvb6ra+7WJJguwGPlOaGCR5UzLEFF6tOn+b/VmklBxaPw8GD3arq4yqPXMPKwz9g + CEadGzbQoQMPJIBBAgl26CCHDdwiKIOVqloomQ1jKuSWGDwwEjkMDGJvNdfQCJJDIkpCslFiapmBBedE + eRA6Ba8DJRMWDpmAKfRu2AFG8AipUcjQciljAgvRySCHDnjUiAVtKqAAhhc62KDMczQYizXy0CrVKoVk + WIpO9DTQwYMJKOjxG0ByCTO+GZ2I4YVAHcW2kQJheCACFxpjsChLj2IFBh02uBI5jKQNz7O8OIyPnFWJ + eWrNue6QatONpJgAhh0qRAeHGL75Eq/Q3BOkvxhhuFZQDTiwxhsz/DDVjL6ykQHQbDd+RIcK/7795BTH + giqFH0sqoM24AQtTLQk0woQWSPigWI2ChmXR4EUh+tomodiWmlcYHFSLSA9hje6rvxkrzq4DlQc0aIwf + C+mSVIjK4ThrRjJ4ARufmoOMMXvcoeSWWjvA4Wn0Bn2hglldTqhg8eL+ESJWbnak1VDzbS8hnm/ZVKkd + rCRm6LcZKvizvfAk64XSkHzYAxjw7fvU12SgYIIO0tW6cy8ygBRBCBL8qbGjyHbhW5Rz0PVIDUJl6VnO + KjZavyU2tXkYg+rAlwhfEa08hjcfh2QDomVHS8hf/Wip7wlIw3bQULPhrb0aIZrhebw9534LWgqVNZTS + qVtN1tXVHhCDDv+kTsLZ195Nq7/2LIhhe0Vu0NJ3u8BEXn9adzDWIwQWuIOxSyYwy9NVGkKsDmRLejDq + UX6UgYsePYECMfCX/bq3wSsMSk0wiEGsNDG6kpFEeLfSIHJu0LaZcINqiFPg/soAg6BtrRYsWZ7yFvcd + aLSOETdYyZ7CoShhwW0JLwhgo87EgQ7wbg3WiyAGbwUwDlbxCx5cVh8QVAltZI5CGuAckgo0AUQRsW5K + mxiIPOBDRdiADshQ3H48NJLZcAUSXBNV4vjkkNbArENFmAL6GpWB3LwAhDAqA+ba9IIc3ECQVoRkFm6Q + Ax3swANyOSGccpC2rA3KAzHqEAwZ97JerOX/PI+4TwipYjmrQUF4xJsGVBDSmdr9Z5R6KkSINvBIyOWA + A0y05K3itEk2RtKYWsAABlaUgRUl03NZUiXiSrVDLglCKhVYSgqveAyDhbI3vwpIGOMQtdi9j45ydBcr + //AnbYrRBsoU5zHlOc8rcCCaZoRfXaI1MVRVYCu8fANGvnMomfElLWShISTcCAP3GTRGL4RoWVKVCHpW + 1KKRzMBypsIXkFiMITAswqaKBAlaxEBDn/nmQz9EPzs+IqMvoxFaLOZRgl2MDcW8aE51KsYcMNRXBvxV + Og9GI7KIaBYGIdrsEva+LrVHOyQ9xkGHOlMZ3dJlW4nnTrW6VcEgFS9K/6vq/mAqt5FQgKKOUI8E4PjN + 5B2Klh6hDU7fIIb55AlY/FMUNQ/BTq721a+ByWjvQNpWA+ZVCVIAICQ0IBdgMU5apNxG0SZUQ0VkYH04 + rGV80AgkBG4DNCFK4l9FO9pz5MCkQhRrhzQbyuFoDBJiACvC4CNbuzpBAuYQ4Is2is5Wkmo8tUwCDGBJ + WuIWd2sdoEDggMqux/rnrjEsAtZkwYFZIq8sYEVcIh0CDWFgyK1Tuy5MmyrT7Owgq8ZFb3qtUCC1soaV + Mf1SEWuXS8DIQgfV/U1YFQcFZJhVGIt97F1JabnmVuUQjgOoehVMXGgihI+s7cgTOKoLUw6jAzLYlP91 + VdrHdE7sEA2UBQbE4uA9xbCtAvYPVoRH2QW3eLTqy49U8dnNfNYuBjqQaxwubCh1vrCF770miGWRElXO + FJTgPRVMl2DWBLvYyTpd7G9rOeH+FdQ/LJAIixnhscPhqW4+RpVUZCBkWWDEbUcrwmqphublGeEWHtDy + k+VsUdDZIm6g9JKMyNq86JLZvtiYStWMTNRR+q4CZxXGhUssTYL6jLftu3GO5zzpSGJoN3QLq4QjLN+5 + pblK0uDydzltNeX158PSuA+Ji9jZwoI3XiShDaVlXVE8ojG2X37POGrFAUnHQQeA3p+gz6iG8UTEz3eE + isI0nFkkbygK1er1rKX/zTHTdrNGXpamN+C4qRuHFhKhBodjG11gMSNaGE8x6e/m6NZ9woYQU5h2vDkI + qpaNo4CZNedZ3GyBhJ7j16v5ckRxaaMxo0MDEgicZ6dsMHUudz4BibO8JT6gp2RE3UnW02aRZs32GNXf + bosIwvJ7XTQ//NiycNFY1zxUPoLZYpaJ9sRlLhixCKefuxj5GcdTq+EK498bxfjCU+rmgqPD0kNyLrRI + LuVNO8Q8M4f6gDSwEvdOOX7tmluxUaaD8zYC3FZD7bW1bu5hgC6Ijh7iozXLaP1JIOJRh3tOqJsNGvcG + 161Ewi/e7nVg85bAMEGaWU6djpQAe6l+1Lhq3bUa/+nG3fFfwd9hbqHsIKEWNHhRQgx6Poyv80eoVOWI + mE8+DNN+w1RiFyJIZEcSTz3e9RYxe3VxHeAvHdm5SPiLtzkPaC7tx91JF3zRCZ8/tQR+5b/HfBQmgOPX + N58gqOnRg/ebOA4fLM23bbIjOlDOzapFTOwavDru0weguzDfekbabDbvfPY3gmW/+6iow80M+UmI+QTp + fLZ9v0rBV2D0w3CjsdAjExO5mJqvzjiEU2q/BXQEHGibB6Cb85uWPNuDbogIa7GIHau8oMs6OvIFRLCI + LBEJu5svq7O19sCy+mLAFYwDyxqLWUGpGTmnKjM+v9iB7OuYMwOE5mIuCKul8P9TB/UJoeSRKdvjwZIz + NM2JORZkwO8hg4zrMZmKAjnStOi6rZPQQM84wCGCL5M7CWhSuDNYrviJwiSoFbJjwjS8gpyhHT1aM7PA + CgUaBzbIARzMQRjUtquzri08AiAMwhzomt3iQ33rwLtzAg/QPTVkwp6KQC+jvtQrj/mgAKfBiSy0OiBJ + JIqJQdHLCQP5KXEYuNBDvvaRgPVTRAbMkqSKv95quo3zEmTot5MAt7DzO/PzQpzgFethuPfYk/Caj0Nw + rVNMQw1YH8ObPdbauA7EHI/DQmz4gyN7iDasLUHwwzrJH6TzsTH8u3fxHQZKRGFsvppLPjL0kFtbBppQ + iiv/zIlZXAhqGrkNgwjhOwlAHBiXEyUwQ70hgAHcAscFzChnHKzfs72CaoKIwCqdsMQDIph25Ea5qUaC + EDHvEMQ2QzqgyrlfsMN+nDj2sp5GHDA+GcBp0QZEbIpZjBalYzmlyjt5PImMipRGm8B8KqVqUoJS1Mj2 + S0X3iSETe66G4y80rAhL1MSaSrtotKaHrIgc8BE9dEQTlI1xUIpgvMnHex1Ecpn440lC1DSYWCc484pf + I6AHszWa5AikJIjIg6MpxLugC7hSKpapdL0NGJiiUTxa4jCt1I+oNEV1yMKDGsgCDCUWYEmcUI65hCh7 + 5IZV20GNoB9+hMuo274MA8Vz/6w92aHAlCyCg/SKC8swb9rC/MoTs4RIMRDDlOywv2yuSPG/x4y7f+Sx + NquaBLLM/fstJHqLn+PGaSHCYOnG/6sI/NGI3pM+2UJClwC4+mDNmVsogKSK2NTEhLFMd1u+wPi6pZvG + Aew/34TIWgANkFQ2oRMOuUkk7EtOmSNGqZlImUmxQRgvrfSDiIiBALlNYxxKUNxJ2Sy2wcyJ1yGjffGm + wlo0t+KU1ivPaduAOrC2Ddkwyly7D8mYdlIHdlRJtoPDldTOinDAtES+GZMql2mFvSzQJ7shdKKp7pzC + 72weJhOMn5sx2/kmThQM5Ao0KpMPofutZ+SuEJ02DNiBVf8kQ6M8MX3jL5tcUZATyMTkLIwTzdNQq9q6 + tYYkpVJjgh3Q0Wlzkdd0LNXbPwmbljTrlK6rCNyswcMzKKPJu9UUDMtiDxJlSJRUzB0SMw/IyCotLhtA + uDtjOMDDy3vbt5LYuzDVQYzzo2x8iZUESp1AKo/cMxRr0454MzClU/TiGoADyani0hq9vTLQBoYxDTEt + Qdqs1JZYUpwQqKpDM4Vxw6GMj1t4AUiN1OLCgBcYKEFNoAgzyoU0AmaM0XKyHQ6M0j7UT69IOaLcIyG9 + vcSTCgto1VedNBe5plD9zmpST9nAkU4NVEYVyI4C1gvFCe6cmZhhupREozdbQmYVLR7/BUiVm6DYdM68 + RKw/zcB0xVRW+88jEExuPQn+XLtbJTdt9TFgnFNz/Svkaqw1I8CeZJ7swEDb+Lp2e1OFzBMYNY1U9M9L + tdhRg0JswleBJS0MaZYB6x/3rCoiYIEbC1i+ZM6izMf8GtWcoIXkSjPf0KGpKSMmWIva4Fgng6Y8O1Zj + jY3r1AhOPY7OE7ZQ9E6iulfkmLqnrL4tldbQ0KWcfbKFip12TJqpulFxIBYFNI2+PMcnUKCduUtQkljT + UI88Whz666id6dnM3BypfbIscUYqjNlPPVgjiE947dZARdWP4NmNi5kzPdS3SAkyciHofKur7QiSWFi4 + dTEh9JvE/7XLZOQPxxEQr12D2ZRDnwW+pEUPud2PtbtaBj3A+DxZx90quqpIzh1d3SQJrmXYQIWf09PT + zAWTIBOQl/VF5qkYQSNbCXFM1FWwqmw5fuVKQfM0FUQOoSTApDkaAuMFz0UP1BAsv61bW31e6+mUchXe + vsrJkDvHZBTbo2QDEL1NHbRV230iExNbQuzNIzlQDb29HRTSvagZAu3eBeupk4LD8DWiItCK4D2OhPS8 + 8I1YKb2mwR0MRkyUuqCapiqDeojF/HUyw9Ah8dAvj7jZ05VF9F2c0a099nQ56c3dWmCWjoyR2DqyG6Pg + OYuLudRFPQBb5umbv2ipI2FeKMVexP9VXGMbpFSrHKJcSuyplhtu4SeDPkJ4tbdaAuHCFqINXC6tPtvt + DxJOH3vimfN7Rss94knDAOVgkyfsyL7xNBjwACPGYeZsUOcFXBIs2yNxI8nJIzIO4iK4oOHh4C72KxvA + Ad1I1tUA5EA+BH+Zk42pTsU90fWlv1CNlGDNXeW4BkGWZLNhC07SY2l7CkxilgqKIGKplsvI46Yg4KN1 + FxR13ohQ4M9toiyigE1uZczxole4ZHnDAA3YAA5Ikx2wJA+AEx3ggA0AI62RUDlMW6tdWzzw4ayxAQ3w + pUra5Rfo5RxoJFed5ScrkRtIkRXZIOaNzqZChq3ctHixYq1Rphv/0IAbeKdqVmdHaFggexYgLeb3dOR1 + pmed8toUmy1N810MTuB69ue+AjchkeI9xeeIHed/Rmh64szmQb9Hkw1HRdOElmiFNtLbxTOyIkuM2diJ + 5miOua+paKhPVTlDSMCONmlIoi6fuWB4mcAwUwqcPemY9hzYQrLWwFToBASbkOmd7pyDY5ba9UCYvC7R + wJzG5emjdhRjWFMSNcK61J+1aAuklmpHodii6bE9O0GzIY1QnuquTo/7Uq7wOD1n8x364TqvRuvP7ZVT + 9UybTgIL0Om0lmvT4JqPAGn96z6F0dW55uuvsLQYdugyXJR97OvCJtz1wK8yZVOXmY37M+zH/95Pgn1N + Ec7cdx6P9shbyNbsnJBbBxa58YLgawoRCN3s0kYlyaGcIfFfZ/Ei8zXt13YEZEkNvlnITPSdLvIAHfhG + 2ObtR8CNrqltxmFcS+7t4j6HPmaTLHKzpIiCC5oAyyBt45ZuOKjlZKmDJpAVL32TV6Dm6fZuMMANiGET + GGnlCfkX4v7u9B6GEskADbDlDcCBc+5u9abv+rbv+8bv/Nbv/ebv/vbv/wbwABfwASfwAjfwA0fwBFfw + BWfwBnfwB4fwCJfwCafwCrfwC8fwDNfwDefwDvfwDwfxEBfxESfxEjfxE0fxFFfxFWfxFnfxF4fxGJfx + GafxGrfxG8fxHA3X8R3n8R738R/XqiAAACH5BAkFADwALAAAAADyAfIBAAb/QJ5wSCwaj8ikcslsOp/Q + qHRKrVqv2Kx2y+16v+CweEwum8/otHrNbrvf8Lh8Tq/b7/i8fs/v+/+AgYKDhIWGh4iJiouMjY6PkJGS + k5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3O + z9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/wADChxIsKDBgwgT + KuyWAccGHR08vPDQoYOOHBoyLNy4CMMGGBRmQEihwoEDFRFaWIjhQQPHl4Q87ojBwkWDBSdMJDChYMGC + /wYQWEzY4RKmUT4aXlRoYdPBAgYnFJg4cYIBAxQnU8rYceOoVzsbXrBwQBUqVBRW055ASxVFAwsvcHyd + +yaDBwoPyPJUQLWq2bVQo/I8oeJBjA4a6So+o0FCixQr2Fb1axUtismBoS5w0KCFhK6LQ4vZ8SCyAr5p + zaaunLrqaQYLWHgQTbsLBh0VVDDgWxUFWqu91/72/bfviQYzOtiozfwKBwoucFJW+xvw1em/ofZ0IYND + 8+9SbsSIsGK3X7bDr163vNa6dgYrXEwADb7+Eg4PpCugbvnsasDZAVYWCi14Z9+BR2QggQqnTUZcatX1 + F+CDbEmVwgvLIaihEBzI4P+ACSa0ht5ZEabVn39W8eQABQZueGBSeUXVlnrDTViZg1elR5UDD0ggl4v2 + dVABeZRlp55ZEgp3on9+xdcdkPa90IIDbAF3FoDAZWcklleesEBhL0BZ3wQpVEfiiVxehp6Z/Z3nAgxi + gjeBbgKuRiOTWmY5omoMqDBBnN9RsMJ+6p0n4InDtSdhloGdsCKgzcmwwlRHpvmfmkdCWChUJiwgA6TM + VbBAAr3ZeSiWW6ppnWSdfgoqbaJSih6AqzJ6aKbunZDAAhW8SpsMC8iqo5Eomlipb2bm5KmvztBAwwU0 + HBJrqf5FKNyNqYp4ma68GoKBDd/WwCwgGji0QQ4bpKv/QYaBABtipsYiiuq162Un1bKC3PCQDjvsUBEH + OLA7Lh0YaKDDCzDEQIEMMlTAMAUUTCDBDhsIvMe0hWJq5XrUWYlpsp326scNB1NQAQsPPADByi2wMEMF + MbzAQWID18XBBBa4EEEDKTTgs88pBB0BCxR0QN8e7pbaJnF7YkrvhNu26gcOEljQgG+T8abaChFUQFTN + buDgQQyPrbAACj6hjXbaX7ZQwQsbYMAHxiXauGaOjJKo1q6u6kHyBKUpgAAJgxdOeOEIHGcBDDmArcYN + HszwgAspmLTC5Ss4gDnmJjWQ0gww/JhH0vBe+SBrjEaYKKfd6qGDDBBQmVMJtNOe/0DtuJO6QmcTFOU4 + GRmI1YDlJhVv/PGYqwDUfHrEivrTWdYKNbaB8a1HDrlJdXsC3HfvvfclcD9VBDAc/fsXVFtAnk+ZZ048 + 8iWZvcDuLPg4erD7pYcilorqyZ9aIcuDDijQAAaUAAG12wn3SmCC8H2PdghAwK4gMIENnA8MN5hABEqi + uQ5aLn6aU8EKOEi83QGFAha8A93+QqEjISpTS3KN1O7AAQsMCkTbu51OdKJABjaQhw6cigNkQLMLagED + O2iBZdwXwg+epHgjZGL7LtcCGBRxDqRjmo02Zp1TqY4qAbTDDTwUwSCKr3s8xKECeahAEpjgQhYzYhVs + MMAInP+tfSL8IAdH+MQPtq+DKYCL+eKwQjypDoYvdA/r+jYHDWjQgLYTHwN3ssNJsnGHCpTgAno0SDlK + IQfQacDlTLJHEjYxhHwsHggdkILk2MFdqDNWZYzktBGx50phpIMEUsAAnThQh2jUIQ53WElfhq9TLeiA + J62AgRdAgHNMfCIfVVCSakJRhNj0YARiIDo5FLJ/+9NYnlBUHQWggJFxyAELUPDLY6Zxje+8JDGNuSK5 + LXMKGhjPKPHYwWm6L5XZNKXmVtDKDthTDllkTY1mmbG8ra49uYyDgiCggGN2b5LAfCc8vZfG8DGABSm8 + JxRs0AGrza+EpyRlH6dpPD5GsTP/MWjcHFZYJAf5hVq1JCdwZhgHDHRgLCZAoC/jickzBnOYPSzBCSAg + gSuKdAkbiMEDVICCaEJRmtns4xOt+cTNpOABE3BqGxLKnkVdS5HpqVLWWhcHHORGVxYFIlEvCiJM2tWX + ClBBBXTw1CfsYAYu8OA/rTlCEmazsNRM7FVPYgGZEjJYz2tTLBtq00VBZVcii8MOIsBGBYpvqHStq12N + elFzMjWOfTWCgh4zUFWexH2GBahKqxk/arbvtAgdFbU0NSuN6W1LuMQXHDRAgQXYDpMMtORGPXvGeXo2 + RCqgQCdTSwTxROB9Li1lE2urysRSc6uaW0AK9opaNdC0rDr9/5+JULXIOMAIBREcZlGbS0n6zteSO1zB + DHxH3SNooAKV8+ApZQtbVabStXs8SQtYFIeE5k2Rt6IeC9eaWTeQxgEVfWAwJ4nRdyrXh5ck1QNC2l8j + aGAGKjgpP1MZxe828cDGc/EfOwODg7bhm/qrl0JzdbqdsrUNGagAWW7H4Y7edbTE3GgldQgBx5a4CDiY + AZU6KFCWkhLGr+Wui/vZgAp0kw2wvNN1XDhOF+JKVTxtAwdc0MB2ypWj9l2jUe+LwAg4+clDiLJTVvpd + 7ar0ylwV6IvnB4EdlPcMscqfQ3F0quhdplisq/AaNACDFZTgADmkb5GfK2f5NheHdW4Rnv+HcOIpk5Cl + p+ZgVjMHQhaDcH4RkIFB3eBg/uRpUbTMWFUi+jjHwFeoPQRtktXoWeV2+qIJcMGdR60BGYiyn9bkbnav + qWVVS3OgKYAABZaNhvPirWPg5hiklYXONPx0yBYFMXM1qty6StK5yVVAC0g8ah7cgAIBPrC1T0JY2s72 + mi0lYQNYsANaB6s3iUp4xuoWWYj+OA0YmFNUcjjfnah7ufGUM2lPwIIvjzoDMICAbYnH1T9uVYql/C6q + p+iCGPA3Dc47FrbKDK8I+1jSaMCBBVCQ6Q5bnNgZ/TRpkc3AE6ygAtMtsQ08wIKewRbVMrZ2YUOo3Wlf + 7icW2IFYy+D/YJp/7FCWVVRUhJsGSkdAASSwqH2PjOTPwvOHeGVABMJa7yI8R+RUBi9AU95HU0Zbq6Pk + jqi7ffBN3WpV7ikRlyK9Bgx4ID8NfDddOf29jIY4yeErgQJW0AIM1Z0IlGbBs8Hbbycez8CCZjXJ5bP1 + MZBVzMThsULPPBlem8GtgyLyUY8tWhBd/OfzbbPm9crtemPvJqrnKrWx2mJXY7Pqe2YBX81b+BKlV0l4 + krCPy12GF7ggwwtMtxqLmkakJnn3RGZAMm38eR7YIAYFnGaqp67HrUabu1SHIqHLp4YwE8tu//MgXaQq + 5sR9Y5ADHkJk7qZxREVs5Md7Fkc7CzAD/0lXbxIQHfr2d6bXUtgFfSzGNXDRemCQaDKnKFXiW+q1JbY3 + BjgwAS7AThJUX8CkZOOXcQ8YfA3wJ+1nBBwwJMPDRFXmYgH1d9aWRyBkhEMzeGTQddcyTtZyOqqCZmRX + Bh4QHeAXbG7nXPXVdsOGbJvHAsq0g0WQAX9FHpeDTS0GeAnGYk40bS+mOSkAA4f2Bd52KYbUMYp0c2gg + HsGyPcamUTZIeXK2aRLoGRVYdzcgFq0VTWmIVUJoZX8HY+VxdMUHBll0a/QyWR+DLe3RS1M4BjrAAieA + QFsIgcGnZJyGeeHTADFAb2KYZ862GYMFXh5kSpBocizlUj7hGS8nBv8x94QwhHgxtCSMZwYbgG9+mHHP + 5XOBOIi+RFcF8opJ4Ex+FmMnV1upRnp8RzwusDhzyAW1Zn30Qit342jkZgb3Zkchxns+VIoM2GmgVXQr + 8o072CEiNz94ZHXYCHCMuG9Xxm9d44ojWH3klGOZyFBKA0APFwYcAAGXUXm8d4N/uIwehgAm4ADJJI1J + QFIzEAFoY4195lqAxm9ZNpItlmAZyXUEaSu2tF7/dyVX0hM49wUYsCCXlFwVV35vN2fAV2yDgwJMdYiv + OFEqlkcDZpRZtXzPR4sq9xPcVAY4BkOmIyL9oz/nSAY1dAIH8HuoCIjBJIMa1UMJMES9qJFFoAP/FpBY + BVZtKdWIKRVwUDRCM/ACZdkF/idmU+lCTVhzwTWTXRBVZxdEbxaIlweWD+hOCuACs2GWSuBIrDVK22WN + kXl/qHdg2RUBWUcGJKh4xAggBsk0CmmAW4ABMPCCkVeKN2h579h2uucoMuBxjFkEoOQCKZZ/L4Z//IiG + +2ZlpOQC0uV6KylLM6caDBc92rGQf2kBfWhsQbeTb9aOo+VDCbQCYBibTKADUlZVSll/Jdl3IkmSI/kl + M6CEXXBeVYlW2Zc3CumXR1SFQQWWqYhRZwSdRUWflbSVisl+1qla+HZSA0aLubiBzedHe3Q5FCSQW3CJ + sxdZDHUnAiiFookF/7chZQkgVMOEk29XgzfobtGZOBYAm/tZBI/nj9XkhlCXf0TonV5VP0JZBb+onpvI + MQNoc8rCnlgQVbx0XBpHX2jEhXD2PTykADmonyEqmxMgcvtEW1umfFjmam24SshBnlpQa3mZOqyxl8cy + djZ6BR4AATmxPalJfl5pV8xIZMM3A9NXpEmAAQj4TCgnhKjUnbY5dbIVl/EhAfRIBedllT22eFMpINbz + BcRlaQsUZ6kodKO1RpuGQJukdWq6BI43JXikpH+mVfmnen8GUIVlNl2jA0SKBa93K4d0gn5aHWm2BWT4 + AKMYg835Q88lbO02g2QaPg4QA3mqplGWb6cnbf8oKpJRlKmr9iVgJaVXEJWpYktpxYlmsYJY0AEz0AAV + ZUamWH5jKoMcpkNKBQHE+qhE0EzqI0LJ92fedU1uKG3zlzk0dqtQcJeoE6M9xpI1x6xWcG+64YcLFKaH + Cp/3Sky2wwANQETc2gQfMRabcXqWqYEqdbBY1VJyCaJWsJkwCmlRaGaHd6pZwAEtEK3qVpg8moUUKU8H + ZAL/mqYBqwQ20CGQwWpWlovmSpJTl2CCJT8pCY7B6WgK93+WAkafeAXNpAJlxBNw1m5IBojnN4MHpH6O + WrJMYAPOZHorm3ota6LchTYRwCKfqqcEaSk6RY54eCMyyQU+tXMHBD6uilT/RoVREylXz3g7C0ABIqi0 + RFBDJLGbTruPhvVvuDlQu1NFlTgFCsokxsIliaeXbCGvU4CdKXACIcujhbmxHOqq9zqf5hQBBQe3TXAD + EsACZhiuL1upCetnCutBKSAbXPCi1YJet7YeNOqJESoFj6QAYDp5Prqj57eAZsoAKSADdWm5RpADR2o2 + t2mLutmIzvef/eQALXe1UtB1XGRLN6U/4mi4UXBixpV5+1qYcLdu2ttZOJR2DlAB28q7Z5kbkKlVS0lK + gUZ6HLhKmoMVFkCyxZq1DjosLwSTanWVWLB0EZAAJBBsN2lk3BtP7VZktlNo4vsEjnRduamGR/k+C+tP + /wkmH+H7BBWAAsLSW9qCh5Z1JxY7BWFrab/EuInKoah5V+uGAhaAoAd8BDtgASSBcgAnvKrGlnKaSjT2 + tk5QwQlgTmVmgv9zkF10nK3rBBuAYrqikzo5Z8oIWjxJZPsRh+p6wJjbdPgYW3dbcgFletv4Uu+bBZLC + F2biP6uxRWpiLcDhJ1nwAhHwpZRXtrXLhV1ISQ2EAAqQAii0wlCAA/j2kdBWdXe7sIB8xQMFAVaEBfCn + Gux1IzIKmmY2ZmuRAjpoBRuQgNLqaYN5qCOscQgwAhwHv3jMBF3KOeK6sEnJZ8AKeAMVa556BTDgkVzk + aOLWY07zF+qxAC4gAVeQFP8OGV/v+Gnc28Y8+UO1U6tR/MnYo6v6eMXTVnpaNnU/0QIxxaVTVSWwR041 + lbonGEhhWAU7wAKDQorrOH6d1mEmnHHHxAAPsM2f7AR20ZF5Z38j6YhX5XdZVqAnwVTKywSgBAE4kRnp + KUvCCJN9gZEVNK/uclTmLM5b2HbtWGwJAJT8t8557Bgpxk9aTHIxPFtuyYH/6rCX6wE2NCDfpnB6UyyW + USEOYAEeUMyy+QCC80tG1stla4qaNnzRLNFRkAPPihWq5mrheqmtxqS6OWVdbAU4EAMMAsYavHBijIIg + UqsezQTBw2b9G6tqRJ8d+3PrZkkHtFTqjNNO8H6xE8//ALqPJKlYRWipo9QCBW0FHrDG+4EjlXJmWzQZ + fREBL5DPS4AbDlChIdyAZEtUGxuRCXB0LN0cGPAtGXADjJ0B4CIIzmoT+la86XubAPeGThEfXqPXSpAD + FkAWxDmA1tfU/rwCKTyvMNAC1ZtRzNl7S0zTabQCDxAmf4ABN4ADDpEDOqADHLABOJAR4aABHLADLyAB + CiMDMQADEiABOoADODwHkANg2lWN5Kp89Yy+15Y5XwUDu9sEIDcl5nEs1rfBMNknVfTcSVDEV6N7n5XE + P1q7q2lxpELIKgwWLxADM8ACELAzKPEAMyADE6AD6P0MGZAD910BFjA5EZBtEKAS/xQgARzQonKQiFPi + sm15vqY82VU3Qp4zA1HNBC2o2mXBP1e6J+BEFQtwoM7BzxkWVx1rwj36lQGsEytwx32QAR0gAy1QQL20 + yWlnTgRlAT7C2cywAR1g3PkNAS5AOcqTAhEQAS7QMhUAAy/QAThA5G6gTqPnT9vlx97ZnfKnaoHUt06Q + AzFQJn3BQsQ50rEnI7grA2TeBB2QuDLtv6uZxEMlnztBuXyAAx1AEyLX4yRwACNgACJwAGm3wwT1ADLQ + EtWAARxAEyrz5JS+4JXuAkre4A9gAROgHHuQAaFklK41i4J2WJU93Q8wwXL+2ZIRS4w2Zq2OFdWJBTug + AtzbYf9WDdtBZ0xTERsf/gYbcKQWPMeDTgLGTuiIXjjHZMvcPQ10JFU9E+1BIzRPLjRO3jM8Yxgd0N2a + JQO0qWK1KIlD7Y+/ilgmQWiePAVkKBJXsxu8gRnnURxWMUIQMAMeMOBK4AErEEFx5oDAzIBsJJ0MxHm4 + nAc47u0MQAIGsPAjMAIH8PAOP+jITugGgOgMIB/1fQyYKzk6M+3XbukLrjPVDvIusOkUQDFYngaQ89k+ + UZKy9XylB4nwbDkLEAHpTgUcIAEzwEuD0ReS1RdSYU7jJQFx/gQSAF9qF8z9LkyYLEkWOXfc3gZJ0ZE4 + gQAHYAAN7/ANj+gSX+yE3vA/rl//RS8MJPUAQAPyln7tS17pIH/tKeACQrHKd5BPZVK+AoZlp6Ry3alY + loMCLvDVV0CGQxIZyKIWmOEbTyFeW4HvTHD0id6TONTQWLiAZutzJMAAjYUHlAYBDDA4EY/oD8/1oG/s + pC/xDy/xDCADGS8MkAM7TT7yHx/7lr72Hc8z2WYBJ58DEp4GI3rZLMuUl03D4RUBgH8FdIQzLbAzZyMY + g1FVKFHvEzAzXXD0vCzOwwZ3Zju0gOgnKV8GbCoBCF8CDY/1p0/6XH/spl/sx77wJaACT6IMSLQUO/Px + UM72T64za2//1B7lFgAEMsmGVzQekUnlksnkyFyN1cpBXakc/1kslupQXasqbNibNVsdLV2T3czkXpVW + xMFQJEoKhiP1mL1yMtoGk15WSkoSFBNMGBUbHRshFyUd8RoTERNOFlo6CEFDlzJeLFRQTBBISA5YV1db + XRFiX18PZl0TVipsRH1/gYOFg3FkIlJSjiNcIpqTU1ygm6elo12YnxtUklkmdHqHw49sOioipsqywMC2 + wLzG0smuuhwaWHLERzkkYmYerF34ieGBg6B8STqkUICpEqMSJipNiniJEaRJiRZAeGHwoLA3EyCgSDDC + gIEDJ12hbLWSZcqWsQyQSLGmY02bN33Z0DEjRYNky5ZBe3bsmTVnzJQN9bmMhQwYHTTg/P91Q0LIBeu2 + lOky5suZL1vgqRPjogIRqTZsaMCRQweHtjlwaOCIswOEBQsTRYJoKZIlSRYdSipBwoSKGDekisrQgQKE + OglIGBBhklatVbgsZ7ZF8sACCmYThxZdE4cEFhEaJFU9VNpR185UT4sAocKQ0YRyWFixIJ67dPO0igke + Zt6VCC1iRL29/EhuFQzwPKT4qGJfhtQnXUJ0ogUH5m48PFgxspZKVifRpz9/Xj3LAyNGHFAAAQbi7/fx + KyE1A0JPZceQ+qm1aoAK8D9pehKjAQhmgGEHHDDIbxwYIMDiqq/kES4r4cgQy4wqHCBrB3AkDC0DClHJ + a68VscOORcH/IHlIgQYomAs/DG5grIXxRhAhPvM0w+wVXIhsRcj3DihhARY+KdFJ5nJo7D9sVotGGaQA + PIrKAZHxyQUIWmjKAxye5ICCFroyg6sPvdJCiyu4smKFB2LA58nQOKhAhQQQUNE6vfoKdK9MZrSgSQlv + 2GGGBlC4g5X44nNpJfYkbc89V9YrYQUJ7uw0NB1YEDBL2UjNcsBrSm0GS6B6SqY2OyXUqYIUrgIRuHkw + VIe4MYCrYgEVWNjBRk87OjECyBxaRNllH2roEekwKYE7D+zLT4NSHEAAvhFScgkWTL8lQUhbyvu2FZJO + oIDYdWsKr4GlfgKoGgJRbS0oowJctdUU/1qoYIIONhh2uQwkOIcKDt30yjddP5RTBRlAY7cmDlpQoE/A + mn0o44iuowSPBDxTDr8N4nCBx5K4nTQWlc2FxbyXV+72ABESmEFgiXEm5MQK4Z2GGSzt/alAAH9OCtV7 + hT4GAjHJzI8DFriw1dZcdXUH1yrghECCCHPu6AYKVoAok+r+5Ksi6aA14YQIdsgPgx1MOQEy9FIGl2VZ + Jg3XyEln4fukHhN4IOKuCWdDgxgqZA2bxYEi2tTGtSS1tQBbdaEFIXKolrkTH5DiKqt5nZoMeByGAOLC + O+qABQcsRgST6ah71gQ/G+lzbRlEHjgHCcRL4ACUuZWZZZVX6rt4lP8wXdn49wwowQWaUI8+CRpwQHwb + 2BovWtXFf2YcGiwBahzBKR9ggQIJOtD8tg1gaGEBFOiJumHSuWhnAQYaqMA76cV5uwUGENCnRUiHImhj + USIwIS4HyABWy+FADEIFnVnARyXEk1m3KNWyvNlCJfChWQQ8wDX+8a8GG6BAFBQ3KqEwTjaTa6H2HAc5 + ZBDlODLwQO5ugwMKfEFOGQJd1WxFhQd4YIQHeUEETtAxBP7FbAgcWx5YsL/lkKMCDjDB39JTt7wN74IY + tBsr+uayvxkAAQ2QgPqKSDgMmCkKqZmSa8BHDe3N62jVoFKWDLSUB1TAQRsg0WieAAEpoANE80v/mJyM + Y4EXoDGNv8ABhRYwO018TBF50VglMpGHFbRgByIUDQ50ZEUETMYAkHJZFzMTizDCAhfHW4/MPFiCBtSn + kdGrQZRQKCCkHO1eeJRjHGNIL+/dcRkQoJMObnYTDOQgBi1wwAJqtSs3iYELU5hCBCwwolqK4wYvgAB0 + EIHAS+xlgINCBAJWYKg/4okCEQCnKijIxcpwMYMnMZ63YjaumZUgBRvZJuqql7gD5YtApDKKHEelqte4 + cDXaaEALKLADHOKpmaiJGiKxZs16pIY2HljnP4FxIjQtQG7RsWQ4M5kABZwABSqYQQc+ipMMeKACDTCB + ZCjzreABaYuX2duQ/zYILp+uhyUkKQEIPQlSiR2OZ0bz2QuRhqph+myFrNrlf5KCDP+0YAbnK8htNNAB + GFQgClN4HzTRelYqRIAFMXiQUvNhg92dBjq16FMAVXEeTUVgBrYZDfss0IBIkmBbFfTp3W6BkuUdb4sq + W17yXFYA5x0KrhK7AUjelbSDDq2gV7oqC+PIQmSsKjYuaCsyl0MyGTwgAtR8B1e24QILwIADSa2sRzzA + E5LeoSIQIacJFuACCujAtjhhJhIHI8aevsxbrywPPcWFHsia6z00g8DgbuspDHigBZl9o6oYqlBenkqh + ptKelcCL3mQ4tA8RzUFMb3IDDrwgBjKoAAse8P+AFuyXBRaoAAX6CN/s/kInErjvHBJUj2RYbo+AGA0G + SDarE/yulMiLGVG9OFTIzvOwlUleYl1mABNYgJEDfpLqvAQgBBVtcit+4/ei2r2EOjWrz1hwmPzVgWTa + BANq4cAOXjABGLxAB5nbsYmFgaMN6MADMaAABWIAAw/oQAMlvkkOJoAmCSLJsLSQJyuRVyQORhd5GgQj + 8eLDABkgmV15qpcvn3qv8/ZyVaRdcHqHVjQ9lwo5qP1OBjQAlwwUl802scFaOLCBGxAaJ2ukQApO0Eq9 + kStm9LSgYSVNXXOFcSWRSoAKOFVoTz3SAtjQbC+DBlqqhjZ7BbVGUQzKKmj/PEAIOmiaqHG9uSY/QAWR + rtsXvfxFYXfxnhcEcWJhBh8lPQB6uS4RBnQQgwe0yqp4/Kz4pmoUe5XXxUfTNguVwSC/OpvcONFAVcIW + wJaFy4ti9tuZN0zp6K7bw7CIjwJcEINblzs/i+GJT+48tNc89bOh3aULZVxnyM1RGylYmjcGzW+JJ1kD + HoBCpEXgox+Ra93Cs4yFySXpSjMXM8lGgGewO3Hm6BA1SZOct12M0BmH76BA+1nMqXqMpYBpBm7dAKNV + HvQjXGtRjRoMlyu9ynkrvSXr4TTJy/xTw354BPykrNC/8wIWQGBK9MLzeWG8jHzN3Lxjb/VBhaIaF/T1 + /71YdzsSHvm/3/3oJWcmnnpO2cpWBhVvw2v6hlGSABRYYKJvF825S62CnlVVhowbuzDx7MLO0nmhRHEo + BCwgA0AA3fC4vpYFUoCCUVZ4bz0F6sfhvbJ6G++epr/wvB/VPAcYqvP3ocq0ZziUo9ixheWlhgpZHXY6 + wpGGrLmSMWfggSPX3sQ5qKLcjEd3DBM16l50JWODze5jP9fpSFJAFJl/nw1AkOspZPHihg+QOd/8qnE+ + 1TB1T42G89Wj4c81hKuoLdK7QouvVz2YN63MmA72Lg3e9g49ECABGICT7O8+cCAO+oPaYA3hEmrbXKOg + 6GjB2s/3YCP31utdjiP5Cv+vAeHqbXTDBAjrdzYo2KAr0yyouQrQ9SgFnrbl02agk0jwz3ZADt7M5Url + 4OqF/RQKA/fMvIxmhg6EKGwMNVoABvYtB5UKAzqgBSYM7zBIut5t7wJQqI5E5Nit41TvFhDABBYo5aDQ + RHRgAiiABVpAq8TrexiPoYTv/LZN8rqnB7En/pBBBbBp3M5wm7aLBVYgMkyC3syM+jCl5ORJlcJseDgt + 9UiiefAHOczwD0PjBtLQAlBj8dRL1QQOcvIMzsInVXqpArNhNhRJwCwRdTaABUQiBS/sy1DPEYOt5JwL + 5Oru7gqgAAzgBCAgBmprFfNjAyTAHyDgGnJv4KrKXvD/pQ6FkAhXyBkvMKsioAIaSBilBwNgwAGQ7tc0 + I+mqzwvxiQAXkVLoxp4eYgEeYJGwUULeYAdiwAL6Q/GSMRndb84iJ85s7trYr/0GhCjW8QnbsWuk0AIU + QPryzpWuMCVar1zKZbkOy+NIogCqDgXWTgI4QBUHUjTWCAZKzbuSMPdq7v0WzsVcTebCjttqDAIogFo2 + snByQAZSYCQi5ZRiUN5WkCErSNJE7umkKyVKAgFQgD4E8iXvQ65egAIsoAWO0amKAgjxTI6YUewQ6iQJ + akuSogFMawKkyCglRgJcQPRKie42qOQybSFxMvVOad7kCVKSxARQIAX6agS98jt6/yzaWCAarkeXEMrs + aG7g4IzbHO+qjG+GgqUuJQYDKkD06ikRWRAAxaxvMu0sw9DM3oOwSgkBTsAFuDLiEPNO1mgC/KEH82Xs + StOghunbYogURYU1HA4GPnNdNKAFaPJvNC1vRO4ldNPugO1INEixxjC4JoAuYxM/bGADdmACVsvy4s9A + xM4040XgCo748OXV8jA1aqQ4OyUHImCUKiioXtD/vhHYyOwKkY0k4EMz08CGilI7nSSsIEgJh8I6t83s + 6pMvxYv4/lH3UkAFXEAG2tM9p8gDVCAygofS6k2odHJBc1KolEdlKIgENpMCMlJAJSYD9kEGLOAflBC8 + nmqFwP+He7yuFOdQKlVM5/gqGC0UPzRgGw1UjMBFMhmrSB7TMXnTsbIoPsYQBRzgASTgGleUWGxgvlar + JwBOVGRMNmrO93COJFklD6MhNSrgG4LUAcHmRXHRPf6v6VhiMrHw3V6pukJAxFLAAiag7ao0Z3KEAv5B + QJozvaRxNfnx7DrwQHziBpcvTTsiShbAOy/lC+Ft0hyyPGfxwvZuBBKARohLT9UoBzxANFnLDY3v5UjS + JM2uAtErS/zzBomTUTuCA2ZALPuvW7wQPDGsPW4UAFUQARRgAfjqBSrRU9clR4rUu1xzNb5LOvMzz8aH + P7XSAlxSVvFkMQ306dByqEBMzGD/D5/uhiREgAQUwKXSR1ilRwOSUx6xslczlS/Jq1sJE1f946WsjFrF + wYRWwE8tDVktTEtPdbrcg1sCCGSEC0jJlSA1QAcMbA62oWc6ENbQzh/jKGhOtEv4ys/q1SYOZxBLaRyZ + yyFNNUYrLfZMIgHSIAag4mCLCAd2sAWwElPJjs6g8uB+7xn40Bo5D2N/gRRUYO6SxxsfdPswqFQDNW+i + dQYWFWWLKEeUkw07tDDBp0npbAKTUOdSgAICFGeDgQNSAF1NrzxzUREZkbqQZAQSEAUeChhPFmlx5g1e + gD8ya8HGR8V2aU7Hlg4PxD8nQCO1VhQ2AAK8cxzNMZVaBmpj/2ZbgjKdYABN17aRcMDiHqAp67G8REtf + wG1SkdBH9/YgMIAFqjBCUQnZbNQmf9NIEvAEVGBKszZxu+Y4H9VrxcAeNxDmQvdJO9RyZKDZNFcYYkCU + kGT6ZvYAA1V4IrHqgquvfi51leoBZ8AF6PEI0U/VoDLt7sxLaqNTcXcQdkA8SiBCv4yevPDpIvHkWEAC + jvZ4R6ji4pEpdW8DV21U9qw1F+RMrXcYzg0CRmJhZQYzbPERtzQ9GSEu8XR8b+tePXIe3ciX8EUwqxIb + xOABhEV+hUEDKOAEJiMXK2Uth00ykmQoY4DKAHjAiJEH4YwI81H4sMoaH1gYdqABFsv6Tv9Pb0rPFRRg + Tl5AbTM4jZBzrLaOaK3kzoqwRPtzQZLPhE9YCTRABlTABHqkzNitIRWxwjYhDSogWGt4wIa0GCMQ4AZq + GoUGGxqAD043c4s4CcZvZSkyeHIzPdh17loBBXz0dqcYyZYpKZeyP4pv91ZDq+LlBmk4jJMAByqgT12G + LJnVLXVUD1RAkcbVjZXqDZrsNBzqSCXHAxvuAShgWvn4F8wE0hAApypM+qYWPnCKBBhALmHAjxIZ1+QK + BvKyNYNCA38vIIAxk4PhBmDABSLtJ22TsMbsFnzxkknZ2SAsOWVgBvDLGdT4Of1ABgaCXmOZEGzAAxIv + kvjE3hY2gEz/gAFWQCuH2Hh/+bYyYAOaTA6YchMXpAXKhwJeACqk+JltuAMmAPRQ4ATugMJuQZPIAhD2 + 2JtN7F7piwJmYEPDRAag7Ck0oJvZeQkw8UyO4RTI+QSooEy9AZ/zubIyAAc2YANygAM4AC7iYtEKun8w + UQc6YAckAAZgQAJeYMoCIaI9+qNBOqRFeqRJuqRN+qRROqVVeqVZuqVd+qVhOqZleqZpuqZt+qZxOqd1 + eqd5uqd9+qeBOqiFeqiJuqiN+qiROqmVeqmZuqlfEgOgGgNsAKqnWqqpOqqxOqu1equ5uqu9eqoHEkdw + gAM64AXM2gM2Gq09QK3ZOq3deq3fuq3h/3qu5bqu4/qtd6ADckDRnHoJMACUlHNDryHhCHuwDfuwETux + FXuxFXtp/OUFvgoKb8BR1fC+8osFMDuzNXuzObuzPfuzQZuz82sGZGAC0AeT+9oIoG0COucuCLGUUCa2 + YRs9Z7u2afu2bTu3cXu3YbuUFNA/ZUDHSHCyO0ACKMCyj5GxlXu5mbu5pYrnePm02xioMXQCWIBRUHAE + QgAEBgAEvPu7wdu7u3u8ubu8yfu8zTu90Xu91Zu7B6C7C4AEgpglJYr5lsnA4hmz94spIaC//fu/ATzA + BXzACbzACRybw8QCZqCrPCBWh7pFQ6KYnbUAQiAEKPzCLTzDL5wANv+8wy2cwz/cwwsAxEdcxEn8xDfc + wgvAR1phE1JABroS6zIAX7eOwbA5v3A8x3V8x3m8x338x38cwff7b4+xX36UoHH6gWZSBAhAxXdxMjLO + AFZcyidjylc8465cBLJ8yzNOy7ucy7H8y8U8zLu8zLH8wwmABC4XB4Xur5OzAo4xzplyyMNEv/ArTPCc + DfU8z+s8z+28z+9cz/98z9lw0O380PNrzvv7S2gNBhzYqFv0unV4xCv8wq/cyqs806scp3hx0z1dyjk9 + 1D+900F91EHdyndxxEFgTDUFAsRX5ToSuRFcv2j9xusc0YE80fEL1w/91svHx3cd0Xcdz3N8vxP/XPMc + XKcxIAYaQAEiA8uzvMtLYsqjvNqpXNOvPduvXNujfNu9vdvBHcqv3cyn/AAoFndULgdgYAb4e78Svdbh + fdaFXL/kHcEL3db3+97fnc6F3N39vdbtHcex+c792w8kwJlv2gMaoAQovMmpvcpX/NupPNvLnNux/dsv + PtwtXjLI3MyxvMlD4ABWIDv57VpWa7/AhNZVftZ7HdH7vOVtXeXfvdYFvdfxK9Bb3uXvvN75y2LXuaal + kAUUwACcvOIffuLBPdQ7Hcqt/ejF3dqrnemRXtxJvdtP3cspPAREwAQiwJ/ILQN2QClTft9nnuVt/c5X + Hu3/XNfNXtf3vdDj/x3m0Z7YyT6/eI4rpxumdUA3EIDCrZ3iOZ7jM13wCZ/aSz3wjX7wPV3xpd7bcSrp + md7CD2AB2TzXdGAN6T3tY17gyz7nz57zV37t433Y3f7l1970256/H8BMq5emM4ACFoAEtHxMzZzTo972 + Eb/qJz7aJYPUnT7jpx7pCx/xEb/JfYQBZqD14YoU5JHO497YM//f6z36/V3enz/erT/7r1/7hRzz2san + c6AFEMD4oX7cd9/LNV3To93wMT3p2z/wj779w139pT3VCWAEUuDq2Kx65hwIHsJHayhssVhC5ZKoLDof + ShbyyIxioVRsFAo1Eq3VYbXYcrEkNx677X7D4//yOb1uv+Pz+j2/38e8qIgMFIgYiBQcGhQuLoo8MkIa + Fk5OOh4iSlY+cnI6ZnYWUDImUm5eFlKGDIQsxGT4xcrG2uhQQLh4iWU5mT1ZHYUFh5VJAQsXlz0tI32N + +RYTQbRMcGDMYmdrb3N3a3PMMIgQhKAiYqJvJkoumj5+HpZmNpbSe76TWprKj6a+cxYAEUJBix3XvCGM + lUNChRbTiP2K5uUXsi4VewXT1WyYxItmhvEiBuGBDAk4EqJMqXIlywwwGpgwEMIdpkqfLOGzqS/nJXWd + PFEydxPnv0aGfBYgUCCBgwoaWEKNk8EDBQstHO6yONGjRYxauyYDm1WZxi3/vo5MmxGDQ9S2bt/CZYOj + AgoEoHr2PJou79F86dbd1WvIqKJ1fo8iNod4naMCMw+ccME2LssbMGZQeeiMIlmOy7paZCLxs2gyn0GH + FHP1qhQZHWxQji17th8OLUwcEBHi3jmbjNlFylv41GCdiuElJiVUbyR1jkeUUNGBNkoNFJ48PKbdiLIm + prmYvdKl9DPx5XtRPM2dtQU11N/Dj9+hQW5E8oYjBj7Urym+/nLSFBRAQ/20CVDOMTICAy/E100OMrC2 + 2jO8NCMeM1x0Zgx6YFQhmofnebdEhRs6AwEEE6zRoIortvXCAiHMlMlhgsXTCWHuyGPjbzcVdtMoNfpm + /89OAAkmSjknSMBiNjlUYCJrxOxSnhkfVQRNRhBltBGUZ2m0JRG6CEPMRy5AQMFJSqKZJjcvoECAUgem + g5NR/4nCHFCNSaLcf/j02F8+7ujoGyj2mTCBmrFwwEIEmkXoJZVffRQpRF1yueUWjpqFZaSZJoOLDGce + GqqoebxwwgAg9CMnYKesWlNQ/90IZFE5DlpJPswJedw/MCYQw6h75GABmU8OcUVpWZzWoYYgIatdsh42 + oewxY0TBGS4UPPWrttu6IYGpqBr1j7jCzapIYvnViBdxcvaI7jkCJocrJW4mYCi3djDZqKUfUXHsZo5K + qWlEYVw64kbJXDEhwl+aaP/mvQ+PyqabAdoZrlD8mVvxuPXoFK9xgJnbJzo08WovxHJs0BBWWoBUMInN + UnvWdyCNxt13YR1MnmhToniyz2h6gIJjcPLE28jnwhlcc8iNW3TIAtZ0YNPtiFKAAib/7MYNFECJpcAa + dkftMToHAy21zJg9TL9GqBdpEWnAkrXc8HWgwgi28kYjyEu/evHGGj9tJ5/EWdwXfpQcgEKSc7dhGWYO + xdyspsYsbKXCaJPRtRicJetVpayxUMEOsDFeemwcuJDA3X7idKtwSosb73JEBra3jTzpmRNQokDXwA6m + 82ADVVaNBEx3BIf5BfJvzxx5lVMcbLNYIUkEeQVrAZ///VsbWHACCe3ME1hvFS+N9HAZ40UYXyF/fG67 + BoD/2AkQ6AA8BjnA0NA00JvH6aX9RiM8W6FS2CgSLcnBTAodkQZJXpAt7UFwJZZpQAJ00zf3JWcv9yHK + +v7Go1npLk66YxVAdsOUCoCqdDbogAxwkTyvUI5sqZEeiMAwHpZpYYAhAlEzzvCAGGwggkJcCQcsIA5y + fPA4rCsa60amrlP4jVwdzAtjRCEQgvxOexuIgQ83JaLleUd5ZFnbwMYos8vR7EJnhNY0zpCGBw4xjt0A + hAMMwApxwWsvNhEh+47WFxp1rCZ6DF/rMJiJVRTAFSnKXgZeYIEI8As8LzTY8cJi/x5JOoNCnxEjtDR1 + FRPNoAMHkSMpt7GBFiAARnXqI+5mR76mvZJoVYTEJUQoGBKKggAGSMF0IsiB60AOUtDqn2cyIsCEkehS + xsPc1zLZNQtMIIilnGY2MkABFJAgl3x6lewGxzQnhrAo48MP+oiGF6XJxDGQmUEKs6eBHQBTecnEyBrH + wyFkKutR6KmhtO7ZnWlYIAY6IB01CxoLHbBgAdncTcf0ZjSoGe4w5yvXuzJIUaLwDRIhOAADChJHDbyg + Al+SkA1jljBjmaaey/qCerjTyZyNiCP7o4AO4mbQm/JBeC04wQhmMjQQii9Hn+CmgShWq6EgFVZNxFFS + RJCACP+8wKZC5MAEiNdGKK2tWUwoWBKkMAWweeirYwDgV52wjK+i1BnBnMELFonTt+bBBhJogF3ctBse + zRKvgyNqrC6YRG6eE0A6yiWMDrCCV5ASAxzInwUyU5Zlco56xqyW2rhQWe1YLglTuooFKiCBHMA1tHqw + ZgMU8L2q+SO1gwKfjOZRp9buKbWjsI+MUmFb2BKpapIgAVM+RU0c7CB/DnFSo8aKhWeNbaXCMOCGIkLM + mw03FySRQAfaKdrrzgEHMLCAA1RHAIHotkClWOIkACVexQjKQAX6yXiNZFcDMIUaoC1oBhYrLCdp7jRk + NAZaFRjWsiKBfwBOwlaPS7kvPcD/RLnwbA5Gid0H0+FBKUhACMgxkxjRg7UVxZM+Mkwrvvajrx6mh5Ec + Qw4EqMA1Dqbm/RjCAsw8wSG5mAaNa2yiG+NiuDb+JI4hd2MeO8nGOaaxjH3M0hnMgAIesC6EmwwHDUzA + BShIAAJIMIJ4WBhGF05KUmCklJlkOcta1jKXwaxKC5dZy2JW85jJYYgRHIAEJThBBCgwX7jegAPBnUAF + lIALFwA60IIeNKD/TOhDIzrRhSb0nyMgXRbIIAYS2EEOpOrkS8OhvjB4gApQYILvEWAApxpAqEUNglOB + INWnXnWoQdBqUpt61KeWtalnvepTtTrXqC71qQkgggOUAAUN/3gABXbg1tDeIAfBpQBmmtBfAiehsdGe + dmOrzQJpWzvb16b2trkt7WsjwQKRpu4GLI3pc79hhRBqwAIS8D0DjODK8Z43vA1wAHjHG35Xhve98X1v + OOMb4PH+97z7XW9541vf+z6ACYQNAdcc+7oY0MAG9OyBF7zAAxrfOMc77vGLbzzjHRf5yD9uco5nfAcd + 4AAOzI3ul7fBBhvwwARkYBUy4RwXOsd5znv+Z507+udkCvrQdQ4Bou886T0nE6Qn4IENEBTmUp+63DBg + A6tf3QZXz0DWMcB1q4M9A2Hv+taxDvatZ13rZ++62MtedgzAnepynzvd6273u+M973rfO//f++73vwM+ + 8IIfPOELb/jDIz7xil884xvv+MdDPvKSnzzlK2/5y2M+85rfPOc77/nPgz70oh896Utv+tOjPvWqXz3r + W+/618O+8jbIwA00gAMcaOAGX499LDCwgR3sAOMUGP4EJCABD+hAAyvmPeMwkOwOYFwCE4gBDDyg8g5U + mvl6wIEjG+CABTAAAXBOwAkYsIKH11T7zc9ADjoggRgMXwYzsECSYxCDCbxABxuIuPrbgAHg3gIKlMAB + jEABDIAACAAIGAIJmIADsMAEdIDy9R/EsB/0SZ8MyEAFaCCSzUAFYCAFSNrx5QD/aR+UQYADMEAJ3E2F + nZoAfECq+Zr/ATAgCqjAA7wAk03goWiADtRcBXSgDwLhD2rgEP5gDOwAHKmfdTgACbDgqqUaqtVaq4lC + CTSAneWgqExcDtCcD2KGBdBfB4IhB3JhY3Wg00Gd+mHADlgAChwACHwAArqgqNWaHJ7aG7pgAZSAAxBb + +l2hktyADrwADMRABoYhkm0gEB4iGAKhDMDABiyf69kGhZWaHNLhE6oaDMohOYwAAjDAiSBhH1LHxOmA + BDAbFwbhKYZhIgIhGX7WI65esCgACLjgJX6XE16iq1miGw7AB7BCAqRADGQfKNIG++3A+/mgF86fIQqh + ByIiIv7g/F2bDExA/cAe9zCAHc3id9Wi/yVqo6uRGi4+oamJACdGQAV4AAkKI1TkmTEqYjMqohiiYiJy + IJK5x+vBAAqsAgy6ya7hYi3qGgyCY0AynAv0TDq6hcyNovwhozMyJBFuYAYGIURqoBJYoettAAuQwAe8 + 4C36o6p1ZD8C5DYeIAgYgAk0QAW8gDQZpEr4XiBSQAZ+YTw6ozLK3ymq4vx11hG2Hg5QQAPY0Qe0Gjjq + mj/i2q4Z5XeZmlJAxwLYoMutpDZkgA4wFjI+I0S24zLOACHepFWaIgzwoepNQAOUwCAkZT9+4z9+pFkG + 5BMiYAg8FRA9JTd4HQ64H7NFmzLaJBjW5DOqog/u5SmWhEqing1YgP8JJEUUYmJidqM3miVRmqUdDoAI + mIAKtMBaRF1c9gH7eYAg7uU7OmRERqRnyqQiNpYMUGPqaUAKiMAsCmVIAmRjJiZjLuY2ulohcBQLdIBT + YmYd2AAOLFYMVABVJqJWxqNeeiZNHqcPho4HrJ4OrAABZCNIaiOuCaVRwuZHbuMbaqTVRADE7SYeyFzw + 9WAyyiQqEiJx8mVWHqJNjiFbXWbpSQAKyOJGgiOsveZ0tmZQyuY34iIlnooBIMAJpIDouOJ3soFiwQAF + BGdn4eUG4qVxjqZfhuZDvmNnScAnjl4GxMAJQOc3Umc34mevvWZI8qNiolo4CgRHPYBBGCgc2MD/DpIi + TsYkEaZnTTbkO2rlVQ6hM4YODGCo6DFJLArAh1ZirgUkUQblbIKkR46aRgJlSZZjSrYoD9wPzWEgFxqi + KRaiO65nVqYnQz7jcXYWDOBAgX5eopgAdL4gr+Uibe7jflYnUiYpY3pkr82EAeShBfTSbrLfC0wATmJl + X77jl6qnXprnQ/qlECYjDDTY6WFABzxAAsjiJcaadMKpkYZoR4ZaN8oaDGonAYwACrDAOcZlnm0mnxXn + X4rmobZjQxang8pfBzbie4ZeGj5ACXToWm5qUcImnWIqf+oniYajRrICw6kACzRiOv4fQ8xfXjokX5qn + olKos1Yle2rgmDqi/6MiVJoOqWvq6onG5jYG65zuqiWCq0cSwAEsQCiZKexpAAdQRRfSX5dKaHnWqI6y + Kr0OagU0Yg2gXrBw64fmp8CmJbmeZWuqpXTaYQKSwAJUJgfoZuvt4AvYX3tqYI7maKJy4XlKKI566Xkm + p8aKIZmmHg7IgJB6667ip8r2qq9aJ37SmrnyIqqMAPlFADAyn8x1AJ8h2bwGYXIaqrSCKaICrcgOZ7O2 + VephAAwwQAh0K5IyaXVGrT4S6ZIa6RPqGrgmJQKswAzsQMSW3g1sgPsBpxfGJLSiLXq+KtHSK9uKLEwu + J62OXgc8Z7eqZYgeaZ0iZX0mrH6+2qidqKlpZ/+xKkADtAcOkh5wJSghzuOrPii1qmrIFi2OBqG4ZVHq + bYBqzqy4KibCbmrKfuvnyimwYqJj4loIjIBJUoBglt7/7QDPkuFxTi6YcmW9queEBq2+OuME3BnqZUAL + lEAI0OLdRm2S2ud05lqwymadLi+d1uGQ4qEDeG2Zkt7EJugGeqHjru3kquqEdqz2buwE6KTqYUAMOEAq + xRqIjuivAuTLEil2eiN2EqkcAmUBbOL5xQDiZt478WzP3qSrtmpV1qgzEie1aqztciEFSEC2rh6kigMv + 2ifzsmz8Sid1wunA3q0F9+ct7mL04mznTRwH+KnNUSU8Eqo7GifG5mur5iX/V8ruNMpt6U2FCxwAsara + 8UbwkR7lLXqurw4v1FrqLt5hHv4QxGreDXTA4jKu7nIp5d4uvs7u4x7nXu6lSbyeDVBAAtBh+oLrmyop + iZbrbJ7lweJw6XKwqd0pCSgABJCs5fneDsRAtZ0w2rrjX2rvE4NmvR4w0P7gNLZr6elABCBAQFSit8Yp + SI7xkjqvfpIuf1qquO7iGxKACaQATf0x4tFlIAbntUHx0HaylxJh90rrg4Ly0FZuQH2l6y2tC3Drmt6a + 1UrnYlow/GIqBWNw/FIn/fLiOKJAOU4G5M0c/AWn5P5vhNouHb8ttE4rAb8jpOVmzkpACrRhLpbuwWrj + /zXD8nVKLZNmapvysLjaLwOwQO8uXp69gM2RJzG3rQB/b6FuL2iycAr3bAdSwDSiI+tlgAS4gAIYwCQm + 5YlqavuubAT7bUj+492q72K2YBwawAmMKtgG3g14gDAr4xxvbLQWsI5W60a7cKK6MxF+YUnowCU3Z/cU + ALHWWpvOckAC60oP9H2GaxdbM+Ceym6gmASQNN9hgC3IcROvqsfecVATasYapxiOW6NeYQfs1PcILxQO + 5YharUv3GsFWbUIfL8JC4ZCSAARcruFFZf682ChjKRNDcfe2cx6LZrViabXxK/L9qPrlQAAOciQXsste + rRjftftCNUCXaF5rpACEwP8JPABzHh5VXSn4DvCXfq+grufaEjCNticMVFdOx15cU1CF+Sfyuuwi8+rn + Em/eusnyvlp/0iYMFgACtID+8l0jGbAnGy0eDypRGy3kpic8UgAMSAAH3PMV5sAEtMAK4IbwonS4crMi + u2nzsi8FlzarCXSstQJhD979XIbPBupi0zFNNvFi33HGeiA0ipvTjWCLytymrcABQGccinYOTzCI9vV9 + JrJyT/VAUydQmsAMkPPfAWBa7/E6265Zg7Jif3SAd+9tj++UssGDqEBMhPatFanzurdrOqbfarAtQ3Jr + nsoINAXr9l0G7KwpFnNtv7bQfjIVu/YoR1r+tZyBv8H/BkiABaQAGza1E0p1aIcx39bySy+4kur4rIUA + FUI3fkvAlgawqnKsobKqjar1FKNtVTod9b4F2FE2dlmd2L0FEtMFE85ap+6t8b4mwUrt1WLtrtViUarv + zBbACVCA4PV2lta2Ct+oKNtxgz4oURdiVtazZDMwVMDdDeBAxXHABmhADDeZ121ADuQAoFN5W6RMCoSf + TOiirWnqwboaWnY2TOe4aA9vYu7iAbBAlE+dDsQxdbstMou4dXfpR9/oGIpbDHjACHq6H4TwDlzcC0gA + DEwADMCAyO2A/kE0NWXABuiArEcfruf6CwDfykmgBHFADEAAG7ohBEe4Xstp515q/2d7eUCn2huOgAu8 + Nd51QFVIsVBrKQLrt2zL7kOC96v7QXgO4o66+w+WRHVhFxLDgNoO4ZVagJIFI0vsQEIdQFLYmohGdQ9/ + Nvxus2eX6wHu0p72nQ3A04yWsjL/t0T+95vrt6kj423ndrKvhO8BInBCGxma7bZlJZ4LuhyFpwTYHIGZ + rcjLMf7pgJOrRC1QgAu02wGEwHBHeGw274MbfKRTuxCLgAO8gLqf2w3sQKzS7kwyM4S6dqqmLTTOgPjm + wMl3wzvB35V24LymIjxeDwzsgIaX0jsJooPSH9d3vQcOnxF2+9VLQAugADYm4KRrsPqmN3Jb+wYLdGK+ + oQgsAP8M9LrcSTS4N/Zju7OimjuSE60KV6UM1HPYG30fIH0chw6DvjvH/qzjO5BBaQBVWOuOEmq1FVvg + Z0MtWMAK2EVSsGnCWmrBr/Qjj7FIHmABoMAEqDbddX6sxnZaQ+jFA7XkNm5JhP1uewPS89m1cX0Lt60G + xsALILUc3Q/F6r6+qi0Yzqv4kj42SDcLlNYIEMDgkitnz6kEm6gi16mo9T0KxEDb093gU3ftojoeM3Z/ + N+PaUsALcIDVIwRPoz0QVGZC4ZA4NCKLkg3P+YRGpVNq1XrFZnkbWMVSOR6RSfBMlpyZdRhtG6uRtE4j + wmcwAOXvBDyI4Mf788vz4xvk+xP/VBxIZDy8EyhYiNFws7zEzNTMzNiRsUgLIxpVKh0lPSMtE0oNnaGI + eenAYdvExMiZYGExWzU1DRuyeJB5ubFFTr7slHmwAAU7DUUVrWCxgOGoVc7C6JhJQUEQCbkzHwRMfPwL + BERHN0zPM8T7EBBZkcjg5u/3t8SwgwI0VkdaFUQio0yrVKqAmRkjQ4IODdv+WeEggcIMaEqKGAy2kOOQ + CR32XUS5KUOHCUIIolFY6mGRVxJypKyioUOMCApEgBjw4QOheEUDtXOnKJ0jQUn1DLjn4AVOqlWT6Yjx + jEyvX6S2xtyKahoYGRQmHrMqRcMLhSFliuLaVomMCTfT3qWS/wtsV75uoxU7iZdHBhgQTpAoIOicUnXw + kBqKB09eI3sGUnAQnFkzFA5ZXUVLEtPX6FWkIfqywELijhwVN2PQMQGUEb8hHR6xIGNH4M1WmU0zErMt + Qr9jhsTArNkGBxgPHCQwAFUooqPz5j2u3pgeIUD1PoyAgLb3eKsbYnxGLzqh2OIV1J8ZCYMieRwCgZeG + C9o0/C8vKpGvCgcJvPBovYRCEwm/NCjY4b/NcJjABRMKOAco7iDDTrLGDqGOuztIsABAEXGCgwKQiDNw + IRXdS9G4Ciig6wUObCDvBh0GHKm2AlU8DTRQsqFxxIsy4GCCHEFar7Qdf5EBhg7E0wyOB/8WKGEEEfiw + wxGiDrnOses2xMMcAggQAYUYhESzH9gkgM+2A1fsBSHRcOOlyR02CJK8ImdK0K2GDEojjRg8aCLNfjZ4 + YSCCiButqzDkck+C5HqzAYcXLFBhQnuE2sOdpSRbp48xwwQqKBEUgKADQ1dF5oad7jtRSVbepGaus0bM + QIIcC3S0xzEaJWuCNVhNxgYdYIAvtL4KmhXFIp55gbfeIIwggZ8iszAypbQs6hEPQSAhhRhwILZcTAQk + 8KFfIVJPv1mhaVKCDjaQdjzmUtvRzUbbRQMMCjzIEyUMbLAhgxsMziBglGzwIIY5T1OWx9t+eSabEdey + oIETDrgSqjv/sp1MHlAVc+QDAhSooFBzV9aC4YfnrBWudTn6YoIdcFCYPg82+qLAM4SjtVlnp4GhXn5u + 2ECHDjyQAAYJJNihgxw2gNIfwkzTj4z8GE0ClEHJHbG+ChwogUIBBOijS0+3ZCyeMAtYYQeW59YCh50J + LA5mrkhzD4YXdKgawBt2cFhmrIOBNNZAJ3Cwnwxy6OCFCRRKjZcX/Z7X6GQ0MPIlvsNCHEEyZIhhh8DH + 0yAGF1AggRwLGalusjAxfIqREU6wQHO6d3cCA0RnuAY9id/kKo3cJvCAA1oMFfCgXoWG2M1WBG1cGRuZ + niAGEzm6Bt4JJoBhBw6qTwaH85hcF9A+/1ucEwawhcwgtikRCEEotNMulZCP97cuqEgWmMGkeDdAKXQm + eIiThoIaQrqbscoGHRhI+mhFm735Qi7tegYF3qcMDTRMIXJxxVjaUjry2QIHipIYs+IyvAQljiMU6IBF + RoQBDshABfTjQzu01RT9eQoPJXiAAAk4RCc8cHI6cosSKAADD+TgdCLCgKWs8Zb7QKwhVUxiajTIjccR + jnuBmgYIQRG80uUgZ5o4oeXyNUEE0iY/I3mBytKUCwiswAQHKECp7JA/UvUxSyEwgAlcIDciFvIJNshB + okYSijYdKFCpsUAszFguDRAOb1mjhkMeVptrbLF8O5CA9nATFuMEqv8CMYCaHDexARS6C0FvFAlfwIg8 + VaLpBh6wANnqJ4Asheko5oDK2QYwggXIoJaGJOIGPJA9GMnAmTQJjjNhBAtCmcsbRyzlxEInPTEYb1zJ + uOX2OuIuZikJGgx6oiXMd8ADOa9ZvooGkhJHOlWVq4YpMIGVElOIUumQACEogAFIsICUIdOgT9AA5F4A + AwrACAxakSYFJgA1qaVTSDd4gSqAVUGO8qhdZUgDDEpoifi1ZDb7AZaPjsMB3bXhBl1YY0pnIrqPeMQY + 5hKQBSLgAAUgYASJ8R8vCVAAEYzABChIAQtgcMyDGvIGHMBeDIpQlhhM9GZnXBUuWkJFWPKFX93/9JcH + WpqF5bBJeOwb2lQlhdU2ZOAFhZug3k4hJ9C9pS4yzKrdLJACBlSpYyAowAFMoIAFPABITUUsFKKYAw7o + YAceeEHUdMABqtVgblH0wCaR6Ky8jU4+eLVEDkJZGyRhTQmoZGob1rQRN+5NXV2VVRL+tQHQGmo5MJhB + CyKgggWggAErcEELVNOgxBZ3ChgYWG1XZjepxpSUMOOmGL5Qug3ewhM11eZMSaMbttZtBybti0wYor42 + juJrdLOBBjbQWA94IGqUpZpyjTtfAnZGm9uUia+cR8EhZEO+WRDQrlw5YPWh4UcjbcNtP/PGnyVQhXDy + RRqERV8KV5h3GfAA/96WdMF9aVSjp7mGBKp7CdhkRY341aSDvTkjW2AYgYzySoERUgq55CZaFsZxjg2F + C9y+xJ2gg54FaToSgG0iigLRClwgFT30JYtBIwaIJ3glY+IdpKu/OqyOtbxlzdRney1KEJCZROVX6MAW + xjLr87TWo2oYRFJjxUIunoXJ20A4pvrJzXm5vGc+pwTD25NVkGflTn09ymYWzcJaWvJhTS5pVq74QgUm + 4J8WsyRdKBqvowTtij/9C9F9BnWotZADzzDaI11lCCkf+goPQDm02PzwFS8YsXjS2CbIYO44U3S4aqxL + PWNYqqiFPey2QjB4P3aeleO0Zjl9JAZ2sQUHWP9b6xSfes1p+ChyksEcCran2iD52bUtwKDuEtvcocYF + mxa1a649eniafQWlkaGDaTs6enkbDXwoYGZkrMXKsUVxXOxdBhvT9twHNzdzN9JrmQpnwK59lHyU0QEZ + XIPaFawV0DbKERnU0xY0nMDC1+jwNV+xw0JDJYIRvvIce8NEhtMXV7H9ENHEQAdw1gLFkwxmmiZw1xyp + gMdt4arm0rijan5wkoyw7/+y3OnGXYsYWPiVuXZbSXJhQQXkfZUp1lnVNJeG8TrODXRZ7sGpZo8K60oE + UHhA5U+He1NLelKuaZzJ7yxOKGIg9Hl/oiMNNjqHke6SCvB74spOoZhBmrX/TQbK5jiPe+Try9BFXt1n + oNE4pvtVlltzQwddbzgsk66e3PDdFqIVuehMjvdu09w4ZhGi5GVfSLfCtbRfb4+1QbpElvJDB363NuA7 + y3DjBZ0f8WNTrOR5e9iegnQ3nn30iUhq7A48X4wGaZuuYfNPW+LzJ9b9V6x+byTkxvDWw0qSmR9+WTt6 + NHWRfvx5N7gIxridms/9cISBjbdj4vfP8LZXghW+KD1/gIPg4TTOWjD2GTOxIy75g8BysZEB8RwaCzSI + U70IC5Qi64fv65kwu6+4irAC7AeGKa+IYaPWmjpWkBfIi8AXxIsiAYtaaz3syr3be4Vg84f/G6cTAbOY + /xMNEuwH5vgyCMM88ZM6uhIFujg/GHTC3tCALliUtEJBBiMloJuIcsuE76tBG1S1mAO6JlSG+IGpsfjC + n8s0gBsJCei/J3RDlJC21Kg+4cku0SuF3HjAHQQ+djMQh5Mn1xLCfnAV4BMyk8NANcw8mnm2N2TEu7il + GDg25pOxRqNB7IqB1Jo30OsweNomh+A40+MGUvuMxAlB7Csn0HiFPGzEVfwHMpy2/GO/o1syIaCAm7oI + HlQypUOpmPlElAgnfBO4tFu7EHIPYXFBVkRGLUCUZwq/FwuaZgOUIZCIHGg6TegADfsqr8JAJgtEfxCt + M+jBBrzBu4sLicDEZETHlv+BIM/xsBrUNBX5NUm7uZTgQmoztVkMPtwwvoXZExGEOLyDsY56KBkYlnQ0 + yEuQogfAovA6QiVchSDUOlfjBp3bMAskL5gIBvPDCbtRkK0JSH4ByUDJuq07yJK8gpUwErNDn/Vhs6qz + uyFgkGrchHokC58xOplCkW70B2+QqqtTElm0SSMEupI4RpNERthAFprwyR+MsUzTv+PovJSgSKFpN9tI + vGcZu41smAQ0BWS7vB8cgyUSQ6Mkyw5yoYsUC9daoAebqhegRqqgyewLSkwSyPLLypTABbbQtaqME0Eb + RxnwgO4jS2TMAdzCPUo8HKsDi3GLoaqYSipERXY5RIj/0cmLyIH6UztT80Sv6yYmGMzPtBtFub61c8gV + Ahr4ECmrqEfnKq2N+rXK/AfOMSUvRKJrsyCQegbAlMjPZEWdmBz1Cy9DlAaSW72y4ECqeEx4a7A6iznY + tJq7+QglYz3WI84CybMn4c2SlMGaAjsM/KhXerQZQCVog8uuG7+Lmxi5EjtQtMy3+sqtWbarLDQYIM/s + REYM+4SRY7aeA4ZRiIkvyDLHzM+GhIj+rMICc86dzAgBc79+mc4FDAM8lEn7lL90MyUswq/Gk7Uw44XA + vIvV3FAQhKf37MW0wDDgOc93Cjd9+c528UwKZcXQXEDiDMjbRKu5GEupHNBBqz58/yzEEbxLq8iBZMnF + xBwa0XgYQWk1GG3ESnIYYmxHkluRclI6IxiUNvS9iqtAzDtBFsKNIK2KR2wTFjEtH9woRmMgwWRSyTMP + oEvPufIoKvVRJT3Hf5hKXmk89hg41WDPlFCm8/hAKl3Bm4RG9/CCSKrPNY3Aa7S4xUsSQBkOh7zI/mIx + vKA4i8O9o2POL+1TgcmFrkTLEc1T8gOefVTUF8TPncOa5bxNAsXHIbBFvODBewPBTHouu+xUX8ywD6zC + LuTE+GwWAIS+U5W/2xpQR1lOdmG8WstTedQMmkRCurxI4QO6XL0I2JgcCnoZH2zRHjWOaZxQYj0436Sc + ZeHWXv9Y0b6UzOnqACzVQ+AUvpqi0VYdgwRNiUoCLzL1E+2KGdSgC1UUV9nbgNE6K42SKzn9OTNY0mc1 + T25iTbXE1QdhCzM0Uuuzv48wizoNWISLjfWTVGlUyzNdkILMDFzULneszRLVjHX8OUyTTnvzCNKJvY19 + uoBoR+nkUcs7RVvRWJTwQK/zyuH0QXvFiYHVP0kkHteMz7ggJJqNPIZR1Q2bUqWL1HeSRpvRQnokxGAU + Pw01kPIz1cxYCWThShUj0DitOo7zgHB1WlCzAQngBdHJR8VZsmQ9VAZx11sEPao9Qz9UQY7L0bTwMgxN + 2v00W65ou6xtW1FzKwDUVCtiVpz/NQ5ecB/ymNUUMtPHzUgwzYwAm0IBfI8UBLxWAIUXUNzFBTUMeAEG + VaGjVVaBm8EdOc7NuMZwBEKRpVaipQoTTI+PjFyPfRYLMF3UfTqGATpZVBxbldYmmVnBiMtSlFx81F24 + xCYO49IkJFQMbLuiJN4tC4gdtcDgyFm7TaJ/zVuUeMx//FXhbBE+BRB8HS8eJT/lrZXcWNvudToICjSx + kNL9BJoXeoHd/FDQa7+Mc9XWU9nxCE146cud3VA+iZO9w1+nYw5nWkl7VFe0oyAWsDm2Rd9jxclSdLTp + pQrYoADLmbVZJK23YAXmnWCWYy67q9sGlsZ48gtsEOABNjsW//nOTYQT9XBfEYlCItA/v21dnDWI2Xrh + lbutSyoNwXvQKSMdkiWPOy2ntnC4D4pTjkrg8TAW23MjePxhHhay/uqA013iLbOb/OzDGvZd9T2ldhUS + mgzdVLC7Qs3JwrsoSxszG/3dFVqQAE7jlePJMGqtP+HSxy2Gnk0LKyYLZl2hnWVL4OFcBc6s9Rgv681g + rtk7Dx7kHJOz6FTWZXXgUmA6NIHWZMOPpHtkba1WNDFhqns0FxrdGIO/T0Y4J20z+fXb15XGWjxfAfUx + l4Ue103EIBYSRAE0MrXjLZ7aULAZ7sXlHJNRXo1UQNZiII0jQwHRK/ZPQDZUP+RUQzFaM/9UYTK2x7sF + 2Gk2t8LEF5el4eojEPpclcekS+u14Yiw0S8I3PEoTAhdthkNtzR4AKUKZnbWsp3Axz+Z34RgXk+uitWc + K00eNHTlRWSG5diAkQudk24lA5tDaKcjEvecDW01VB4Go0CuVENJ33S1UQ094ldelcfRCDDqURYJoZGI + hZUO6ZVbxnzLJjrTQVaJyyI+RbRtZSCu5BnqDBBiyJjd5p6uWWVqmr240JR2jyVKHjTOjDt1yjAz4tEk + YeWAKhiAq5S26VCAhVSCaKneskrpAMp7hrmm67m2E6pZmVSWmOVM1g86Okq2VgDxHQ9Alro2bFBYollo + a7feMxuRHO3/cabILgvSiYV2Xey7sOe6W5/3+OEwnBsc6AAJCLmyaKaGIu1Jmw/Gnj0MUK/G6oAdeCz3 + 6oDJ2gAN4OrxkOhIhlN30eQaC1tzSS/GcqzYjqzZzgEnum3VPreBuYGDSZghaunIDTf4MOaKLgKM3h0M + MBgNuAEbuGzldms6bs0wHuXdhoixBu/0RiwrXja/ZdXXXVGC02P1pm8dq0dIqdpNPuKsAez69m8Lu1RZ + etB2A9n//O3/RvCmYtRAlV+wbtAgxO4El3BDoreOgNAaDd+M1MgJ53BDkjYREllbjV9o0rYON3EC0ovN + mrEeVr4JYOQTh3Eh1oiwzr7DtaBkKQtB/47xHTeXTiDbsgVKHx6JJsFOHjdyVlngSPNYJgtJxCaU7z7y + KPcHYzlhUPgxI/RIl4gkHUhuKfdylICQI2nvw5yxenXxL0dzAHGrVLBw7JvM95jdNJdzwSDC2RxvP96K + JUrUOefzMD2WeqNEnvsIiZjHPjf0tNAJE9k5i35kG+4mQZHjQ5f0AMkspUTBFR1ooPuXHJ70TkeGHCDs + IjRnGvQIiYpqT0f1i9AAHVAkfDkryuSFfwGcVKf1i7CBZSzYJYm35an1XvcH0G6a0Wa7uM3qqpIXTvf1 + ZAeIVWcauNqFq4UaiuhyZaf2Krh1DgAlsz7tyFIeKK/2b1esgtEA9X3aABzg7mkH93RX93Vn93Z393eH + 93iX93mn93q393vH93zX933n9373938H+IAX+IEn+II3+INH+IRX+IVn+IZ3+IeH+IiX+Imn+Iq3+IvH + +IzX+I3n+I73+I8H+ZAX+ZEn+ZI3+ZNH+ZRX+ZVn+ZZ3+ZeH+ZiX+ZmnefoKAgAh+QQJBQA8ACwAAAAA + 8gHyAQAG/0CecEgsGo/IpHLJbDqf0Kh0Sq1ar9isdsvter/gsHhMLpvP6LR6zW673/C4fE6v2+/4vH7P + 7/v/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp+goaKjpKWmp6ipqqusra6vsLGys7S1tre4 + ubq7vL2+v8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4+Tl5ufo6err7O3u7/Dx8vP0 + 9fb3+Pn6+/z9/v8AAwocSLCgwYMIEyrsZiMDjg06dHTooIMDBxwabCzcyEjDDhgUWDxwESGFixYWZMDw + oIGjy0IadMCo8ABCAwcLUCxYoKIBhP8HM2B0wIHhpVE+NzqEbOEixU0VK1YsWOHAQYMUEFqwoODhxtGv + djR4mNFgZ1UHK1RUpYpWLc4VDWZ4wAG27hsMHSbMiJBTZ9SzbdG+9ZtixgQdGewqRpNhbIsUUKmylbwW + rWS2KiJAmLEj8eLPYjrMSGEZsAO1aSercGt5qoMUFTqAnt0Fg44YLnC6Xr0WauWqq3n/dkGBA+3jWDbE + eFCWbe/T0NMGBiw9aoMHMDYg3y4lA4wWDaRSVetWuuny00unYCFBI/f3TDjMcLvgrPTyqKGSP+0WPdwZ + 2sEn4BE2eABBTuOZ11t/0D0nmGDiQbBDUQNWKIRyEegEXH77pZf/Fn4c4oRCBDC0ZOGAN4wVwV/m4Qdc + W8I1KCNaC8C2g3snvscBBeD9xRp0+b0omW8gogYXCxPkkCN8O7AQwW9tDXkWkUCGSF1aLsS25HsSQBAZ + hMEBGZiCL06XWlXXvbAldxKQRhmZDkYXZIMdSuYCDGtuF0MDKKTX24dyijlmkKmtkMIEeSJHgQooTBZY + jPc5GOmL5fFEQaLH7cmAc8496mB/Lt4nGQMNxIApbXv2yal+z4XqopDloVDqqbOlmiCDHgpnZWp1ymoq + rc3QICwNh6Q6ZpT7dejpeIK2psKvhNSAgQ011AAsIA5p8NAGGN1AYSC2UlenmbzBCRygK/g6/4hDOXAQ + UUU5ZHTtHRhokEMHL8AwQQz7TrAvDBLscBEgxkJJKYNzIstqrLP6kUEOH1FQwQwWsMCCBRbMIEMMMOyw + AY7zuoFBDhLIwEILEKTsAgQrZ5VVBRLkALIe4Z7GrGpRyggoa6xFxROifYhVgU2WSbWTcz7FoINXIbdx + g0wW2NRATz1NbXUDDbhgwQQdmLhHwfadG2PP+5258FqyXrrHwy9YkMIKCpigwNx0xy23Agu4IIMEATaN + hg1K0eQCSSkUXlLhKRyeuAtAycDS13wOqRrPvLr4I9lSPbtHDhM4qcICDJwg+uiih36CAifo5JMFL3jt + 9xh4VdBUSRHUbv97BCSRVHtThkfAwgsz12GseYAiW6ay0+mnVk4N46EBBXyhYDoD1FdvPQPSh079Ag9I + 4NnrYWSwAwUQOKVC4rinf7v6JWHtUwWP4wG2nz8OGufOzgJ9BwcxQLDC6ag7wfWklzrrjQ51KmhBdsAH + hgy0bXCJi2DtTII7Cu4ugogbHAtKJL/IPac65IkUiGw2NrQ1QG122IAMykLA6hUQBS+knvRQQEABqi4G + TGPgFmygg9GcD30X1J0QLQjExF3ld9+jw/BQM6VQAcZyU6pO5qBFhwzEIAKnE2ABsSdD6tkwdQK83gnk + 5gIPBE+HVLDNcrBGuzZesCS5sx3h0lc4CMj/oANJlMP87Nch/YiwVQ1KV/Pm4MAWOCCLLgwdAWk4QC4q + kgEKYIADLOCBPKJxCsoZyeF2N8E4Ds52FtTdBHH3ABkYR3geTN4HcUWu+knmZ3bwwAMcAMPSFTCMjoRh + 9h65S9HxxAI6uOQVZIk1CXqyk6D8ZFNyZxLdpQA7lnzDEiEEI/spqHiPQk3a6rCBCqgAl2HE5SNfuEUv + LhJ7KEgBDL4lzCh4BzzoKyLhPglHZ9rTmXCkQDCVyCdxxWhKZWqWqBhGRThgoEkLQJ32tKdFRnIxddmL + 4QxN54AK0KWdURgZBVxwlVESkZ5xZB8942mSrfUtDjXzTRTnxCsw8Sw6/1OkAwcqkAIUKHShj5RhDGU4 + wy3WcAUPqCRGoaCBtjkFiPZUnzwpaMEKjlIr3pvD8OwzJ4QBdGwtQss25aCBK64Akg0dZ04NGNHsTRSS + C4iADJQ0VCfsiAVNuYoE53pMIapvmUpNHICkmkriocc3qqkOCYH0ShXoDw46aMECRufCFm7xljQ0ay8d + 26cHAK+tTMDAWCCwSdrR9XZMFSVe5TjB69xIj/08V5kUxJsfsXawWj2hHG4wgQbcNKfi5OJEb2nOXCqy + RjjE7BK88wCPetaNdZ1nM4NIOKe0IAYcOKMaagamnZ1Jcq5arbrg0BgLwC2cLWQoDHFqVkVOVnvSc/+A + DFwnXCPQdnZI/WQE59jUkCJzriVdIBymOSlKVUlOQSpbTOGwg9GMd6HgDeNEdclLc5bXnBa4aHuPcAPo + nQ+O8XQj7kRZ3/TNU8NakwA72QA2EJLQXORaqc2264YMUCAFoAtnY8dZ1i560cZlFR0KWHDSCRNBAyvM + zOI2PMH5JtOuoaXvJhugVgm3gbqdwpUfhcPaSWXusGzIwQNs2lswmlPB6GwsRLGnxbEK8AE99rEQcLDC + jja1mYO7ZyeXK0rQEu58LOjAiKfbT78KhlVZrSYgjbRVp7XpBAnI7YwRXONG6xadolNAC9KsZiAfFZTs + O3In7VvBZS7XiM9U2p7/0VBiqh4PkFc99YDZ0BgWfDOSkDUveh/rUBv3NqeRfABb1UyEG+BGrveNM5F3 + V2c41pPThvtJDCh9BigHkonXJCyYpsO8gqahh28j71ltPUOz+hS3jJSeAnbsZF7zwDucPW5T7RzKTg/7 + drPz7GZk8+Q+28xTzwYhs5IFU1i2oUugu3X1GPzFGjsSogs24AlWMINy89oGL4ArfI0d2kybZLnGxjAz + aXcVBUbTDNS1pqDq9CohFVoNOKjAIcs8cIkyGNw8JatOI3vCHJqbB7FDWYaNjc+6ctKudb544VSgNx2M + ugwllrJrAwyqZa06DUVVrNweGlmqfzvhYDznjFPn/wAIwEC6Ps5BDODau3WH9KPIdDcF492+CDwgSST2 + ILSZqDBx8fFPLE5DByygArCSWYy7vPGtz1rW3Z6AJzPQ881//IIZ2CTt8hXihznZ6WMel3aMg8HHxzDV + 5JGH5IEmOWr8DfUVhreLuuxpTl/+bYQP3HR5mwCzea0cmyB1cZGvZzIpb2fkbtKUawAbS+0Oqzh1iHko + RMMOIOB3Lcb69eeU7KJ7S0AFrIAFp1w8EWwgAXj6Hpl1jmMo177x0F6FdZsPQ82iPNiSp+dssbU2GZST + gtM12Lfl1Dpkw436h1pfBunHaztgAccVbxindsskZxnHc7XTcRRwWqTWZ3OHGf/G4ykBRlWCJH9icAMS + MEulQ1a7xEj710VjNn0KJkDqpH1HgANjVz6FM09I5nPEJkdD9GEZ9AAUsGsgl0rVdIH8BkKUwzDJVwYd + YEiLJV66pXXbdn8NRk4C9EvZp4JDgBc84hRtJE9JtXsVl3F21UYtYEYR2CdC8kRhYxoAZTwExRgx0HcM + dWPf9mU9JYKLZHC3dAIqwB42J4VCID4EKFeGM2RaaF9nR0+8N0FEt2xh6CjWVC6AplL8ZiQ8oYFgkAMW + YFPgVHUzVl75F3PgVkMMcCfspYdC0FUcJUFthFdBx0wfZk8Xh4pHJRehqH6pNWj84V+1+CqUk3djsAET + wHz/jLVTDOZthHdr5HQ9kLRjUSiKRNAkSsaA8SRsPwd5lMdhifMA8AN2XRAuJkYd54EzjGgmpDcGVgQe + L/d6O1VOXSaHgVdmEFUqRyeKysECtpd2RMZhnhaNo6VU+BQBLTABDgcGBUN37VeBjZhVgHVyYkCJnyNj + b0iMCReCmXhL45YCFkBvymgENrAjLXBhHpZxrdiRyiVammZcM7BPZLB+U0ZVYWKBZBhIuhgGHpAh7Ohg + 1PdoYQVzOcYAcnN9XXGRSFAgLNA7aXeAoFWIrfhmzjQ1XvePXjBNpoFNZ9gpJMQq8VcGGzADK2ACNrRo + u6VLL6SO/Sdr03MoeeiTRJAD/9CDQZEnWh9JRzAYjUR0OFlzR2XZlDwYFZ8nKWfzIQbpLJK4BRoAAw+Q + UJwoZsMocwK3W+a1AC2wA2aZBBkgAVEzcSOFipwUSl1IeUy1SaVkkbIohh7SSs9WPzICFS/pBS/wAIyC + Xos0ZudFZsPobbJWOjVCAbH4mGvWOaVIRx0pR2vnluBHfsZVjZrHeakEWK3VLAEVKFR5ZWOQcmXRWHF4 + cGc1ZlsZa9Vpf7Bhkrh5BDkgAxFwPpnpYeume0RWnrmTlHqjg1/glH42KIGGLgKGkF7QAVumULVmPdu2 + U1RnY+BFPXFzAhLyjt2JbkIJnBgnnG9Uma0ofkxmARLAlP9asH6pVjxlozxWFUKRmJAU0ACI9GDllHWT + 1ZCuGVGnswIVUJfduYyy45shJVqT95s/R4j4dBVZAoHtOYvIGVDb6EqvUm1hoAET4AL/g5/96ZqO9GiB + l3qNJD15I2IrqgQ4IAFkl2GbaWRAt3boqZmG0wIVMHtYAGXZ1Y1QFCk+Y1hhsAMtkC6sGZaJpEhZ13LV + SUNghDrpVAHJGKVGwIuP4WZDaY8M2HvBhl8PMCEAKYH3gx9kUjz9ZZqy9QW+5gAKdYlwOoe+Jaerp4mo + 0wAWgKN6igR7Z4WddYUyyFybxj5F5BOyd6igGWWvxZx+MiZPtwUZsHcJZaRKWphv6FP/NZZ1WRQB7fGp + S8Bm4dlZf7g+gfhRk3dMLzgDEnCbV5BSUtIfJvZShNUrg7QFO+IClrhotNZ/wThzMedYoQNU7CmsRqBZ + M/AYf6hclddulqeZNviCm+EBOaoqTEQorARbQCgk4agFVuQ/0xOiCQdziAmb4yRADuACE4CN6MoDOPAC + stNRl4dxZ9d7npaZ8kQBKmoFITcpS9ecyRlFIvKoXLABLPBVpQORgZerC1aCLzdRcYMCLhAD5/qwRYAB + tYc4V+iRq6h7ljlKMYo1JWmXrbpKYsMgjIpqGegFO+ACcwN4tDZetEaiS+h8C1CRBIqzONcBTuJRRkZn + 8JaFMzqD/4bYAC0Qodkod7EKso36X1GyoVuAATP1aqaDpDDrUJo4XvvJegxgWAHItTywARSgSWWXjz/3 + jEmFdr95FRBQAS8goVMwP9P6bDOSM4OyPKdZBTogAwJrp1wpcNhpjpYaUVTRAp4puEhwUDIAHnJVbDYY + r8pEWha3OC1wR1ygjYSikiv1WvxWlVvQJVIBTjI3nfyHqXrbcqKzAhBgm6rLBDcwgFODX7NTbBTHdgio + cc70TOu0BQG5LMqyMCFEdz3jnAArA99EOrBJsG9KTr2UjlwkNymQg8/bBCpkrOZpmUDnbl04iFa4Vt7b + V4BUrWa4WskiSENYBYDDfCZAgq+nW/9fGWZT222rZ38PwJ31mwQcWFybBES6Z2R2loVmpztHpLZZEAO0 + NB6kqZyP0pf39lWakwUd4E2QBHihO7q2tnqC1yfrlcFNoAMVwBQR4KciNWwJqIC5h3aPC4ZYsCibwh8c + om8LY6ZnI4RZ8DzZRmP617IPtb6WynI61nUvsLU+zAMpIjsXNl9XOmfL+kYdZnb0G6YwZrmnRse2eF2W + EQFYRgXLF3AgKodwaF4P1ok1hDc1K7llPAQ4MAGGRLEgObsiqY93FaidRkkO2wQSkBs4M1g9irSvZSd4 + cgVd5aFgJpYum6RN+mgGlAAMd7OJfARNwkZoh6yomoC7l2lOlTj/z8UBZLwEqUmaLaIslSvMRmIVQXUF + rSapYbWJxniCcRinYnS3DdCwr9wEi8wynpWKFSe2MopXH9lcWrOqVgDEQ+wj1OqDdgwjdOcCRTvONGWJ + 4TanvgrITLqOqWdLDsACGFzNSFCrhXs4Nfii73aZbXxfbcQCjmkFvBiU1LScxkOB6nwlFCnOVGBFNSV4 + A4SkIcjFpFtrCssCPcnPTCA+o4GF9Iil8Bp+k4w4WDEBgasEKbIXU6GoF0gpLWVNaSUXHWu/WHlT04mO + mIqdI6hwNKtfIs0Ei8xRNnrLR+xuTnWK28xhVwHAVpDURzOyLJUwqqQWOnEnYMoEBSJ1Nxl9/xAcm76V + nxLJPXl61EkQcYB4V3Eprx2JmajaPrAR0mm0A4PpGp9SVf5VJ6+EupesBBwAnowFv5nokIjtvqGTAjHQ + ywOCARiQAQ1B2ZItCDvCwRrHhcAJqOPZblbIAtB1Bd30NpZBrQBlYlIpWHAhA189XBHnoUgYZtNJkzhJ + kz5VGAntBxhwA9ryEDqQA/FyAzcw2NRwAxvQATvgARIQAxzzAh4gMBrw0nIgPjxSj3KNduLHiiBFUpoh + F9T9k6npJqp003QyUKftOy8Q3isIPV91WwYLmxvNia6HY/kcP32wAR8hAzNwMqSkMTEgAdHFEDiwAxJA + ATJQASfTAg+QMf8yMAEvgBh/ID5Ospmn6pYhieG1rFS4I9rQ6gQLbdqoRsfjix4NgCSvvQQcwAK0xI6v + uasER4e9ygCHgsiExAGd8ySgYwIlkAB48xpZMheQvQwawAHMneAVUxMtw+AXszES4AE68OFzkAN7od27 + t7+3TFocdopfigU4AAMQQCOY0VLJ8rvisbBwdwUd4D8tG8HCiGMkaHBhpkgQkLp3EBMl4zkwlAAJUAII + QAIJ0MAMwBMQYAExsANSvgwbMBNJ/gAiweAM/gAPoBUW4+gsADM5MOSsppsdHETrg5QiCV8wiEERYAGu + HAWFHZ5RgZfRgW9RtOpEpyVY0AEuEHBx2qv/Ici+l9qaqYN4if4GEWsBZQFAJmACfN7ngV7sdMN1XrfT + yZCRErCuLJMVLVDtkD7pDO4ynOWlMcPea6AD/0yxtqyKWB67IEWDhfMAay0FtiEDI1HMlFEZhQIhTIaD + HWDcS7ADKWDKtv3m8k1jty5ufwvSepCRjKwCJvDnft7jDF/sxt7nfo4APQ5UzxoNjcHfIkHtkj7pHB/p + kO4yDD4DAR7leZAU4NkT6OPZTJ2/1/thU9MC+1wFOOABMlDrOuEXBwMh6dInajUXW7ADDSDogRy6gzzI + Mzaz3fPra5AUPDLsEF8CUM/nJfDwx17sUA/1eNMArv0MeOF4KePxHS/p/2Av9htf7Y7uOCnOBjfwAuzq + s6uopZk2WpHsFNex7hXdATX/FNBGTTujN/fOBR6A8B/oUzEUp4Y/omI5Riia9mqwwZIq9cke6HxO9Q1P + 9VTPyjGg9L+gRsW1MhxP9tZO9p9/7SkDASywN1GO72jQQ+k2X5Es0ORJiL0ZVyqg7l1g8ArOWTcRFTSE + l0ymFTAz4FywAyoQtQbLn3P676hcQMCq+mWgsy+wHHAj8VfP5woQ+X1u+ZFv7FBPAp9I0cnAPxaAMqE/ + 6SKx8ehv/qOP7ZLOAjNAAVyj+WfAi4ZLqtfLcyDs6aRuOKYOBDzhkFg0HoeZ3IvCgqRUCxQD5UhBWP8V + Ty6D9H6Ju8iJQWZQ0egp9bRWn9NteZmxULFyYP2en9zNIhwYFExKEg4RE0wQTRobFSEXFw9NGBpiMPo0 + Nzk7PT/1NGIeWkofTltQWVpYSFdbT1FlUyFqIR5kPDZsQHuROGJYUhpSIiJcjI+NkZVTXJ6TXZyVkYtT + io9lNny9bDg8YGQqSFlnKGA8OLq4j3QgFtjIUNrKpsjo6/PZ3NbIFE7u7FjHrheGDRJaOFBQggQCQ4kg + Jnj4MCIlRYVMtOBAkGNHj728UWjhIlVJUidRmixVUiW5lRZkxNii4aMnGzssRFARwdm0ZT2RQYs2jdm0 + azyPPYhBs6YQGzc04Mj/sYHDhg0abvBqyoPDgxXw6Lk5MwXFGrJw9M2zV/bEvwgwBm7dg0HHBGErTphA + 0PBQiUZ+JUqSdNFRYUgSHTaAwVRuY8fscLyo0AKCqVipUj6ApbkVq5MsU6aaEWMH48dfNlBwQcwaT2bU + sPn0qWxZNWctZry4cZr3kA0VUqyYB2etPrT02vA7g+9EmwcbeyPB0KFCgxOH+1oEDMnQxEkVFRlCkGAB + Cw9xo6dXzyPDjhgWKGPG3LkVfc2YNcfKvPIBMggwX9BBg0zWc+oPCJC6pihpkqHNmQWNqsY1pTggsMCt + MniBBRXowIesftgqiwoQ8emQihRiQC86DDLgAAYW/6wr4QCH/Bqsxr4GyzGSSGwsoQSAZsjjwiEfwwGG + GTJzxTNyYGGlPpU6Q8mlyjSboQIZShvyoBlWa+2YoJoJ6jVmwDTmmgYisEACHIiUiwMKIhgkDbXCMmu5 + ekQkcRAUIqhAhwsz6EAGCKK4zkeJEtkusOwW3U5RiAo55IQUPGjT0qY4kOEz/VzpFKUoVYlSPk5NgsCF + B7Rgs0AMcqAAAtbMbNAnBl3riaeeWmvAhQo6sPDSjmx4oYVB7jFuORDj4KcfBco7r8AbdgDuhEOx2xHH + SR7BlhJHCMOIOx8XmODXcQnqYAbLoNQvlVX2s0+VTket5RkWZJBAh13WC/aBYf+wCerBBsEks18zkdE1 + BlXJ7SiHGRZorrg3Hi4WjrDKaEuFpdbTwINROCyBxh11zPawkBNdpMbvEGNABl8TbrkPDF6woBYpN2MF + P89wtm/dJENDyYIKSDOttxwqsM2a11xLGikz+z06ghYqdZkjGyZIASwzkFMrDTXk6CcfFCDoYD0OgGtY + gUQesYhk7kK+sbDv/PJrLwYsQFjqu7+4QQILSJrFZnXhfVeWz3SGpeZSKrNApg1UdMwGD2Z4lZhlkpbm + NaLCZNoFFibYBm92yE4BhX/MMHaf0omTo7kVIKBAaMc3+KMBBhDzMe3BrLVRZB6tHfkwj0947vPhj9AA + Bpn/K3NXyfoGX/LmJi8TNbRSWLBgBhh24GC33m6IWQUViCmTcmoIvnyYBlronHh2dLDAARP+MXEsiuuZ + Q0RCGIggBiF52wCGCiDggLZIxBDfwZ3acoQ7SQBGgdtCRNwQcIIWdKAG67OgkfhWkprVjHCBO0mToKeu + EPZsBhPYwfZ4cwMYvMooP6GVbCRUFGfIADoW9IUHWtAwE3XtWGM51j3s4QBtROdNKaCdQ7TlO8GATG3a + 4RaOHBieSQAPAi/Qig0/h0EqyUJUIAQcvF7xweU174tUUtwLOjCg/r1HGrDCRm0od5RrKOgBFOjAFbH4 + ie49QAWja85x3MDDDv3DARGY/0GFToODDtglAijQC18Y0USSLZGS2uLW2roTQRe8oHF5JJeRnLBFdjnv + FKMMY87epcFZFO4yJqne9dTBG1A2gJbWOIrlwjTHo7SAAhzAoyc90Z4HCJBYySnLMZXTnLZMioa8yQEM + EtKcs3XHbYsCGQMfOEmLZFNtjiKBAqrYSWBeSgN765sqU8kuwZGKiziLBStLSQtSPOM/E+gACh2zAbtQ + RkJzvJUuk5E4E46TG4/LiQNEJLFiKZMMC1jBTnp5Ght0IAYQQAECDkCCiHjHZJa8nWGYGLJLYsdHCADn + DlhG0F8ZD3k50yB+BJcuMDZPnTsLnCkoc4sZyAAGHWDcY/8yoAMJNKGN4GuAUWkJPhWkABcS0J5KCxqZ + yAmHEFVVwFXhtwgFoICpQXvMBiTzKhQkAAEfg2IDdZS7ba6VbQpkYNxIIMEaQnVcj3MC9Z4XvVHNFJV8 + 1Vl+YAo4VvwMBjn45VZwsDGZLYhMy8DFC+xGV5AIqgVWE5EaLruCFKjJc/mEJl6mWDKR/k6bgrndRVAb + ybRxJ4IW6KxkfxWtLXZwSel8p5IG58FRqdJmXURcZSoAAx3g4LA1aZEHJhADccxgBtazUgUoMIEAvQ62 + n/DGCyYwg1UgaI59+5k9qfuRxKpmAbV7iMhKO1K0MuJG2BwpJRxVAhRUAJ/VbZMOJtP/W8BeRrejFKGn + UgKq6H1RJbeoHnSdWtyasEgqOujACzygAw7g4AYptS87MrABHWwsBtFF4waykkhzrmAQiEKbakOa4tGC + 7ICBWaI1VyCuC19KnyyAnvOYJ5/NdFGwqdyv89AppczAUsFbwQBUNCDOGXMkA1KZSnibYgP/JeRsDkxg + Ei3ZROwkEbUGrKRHEXGCCLxgyZbKgAdksIqWAFbHqkCnSe7zV9q6goPudCcWKjCBLdS3zH2WCwZcxKUV + nO20a82yJHm3wEdgc5tpnSLcfqSCQ/qZSFuKDwjn09eZAtaLba7pjZWHSldSALKUNrVxZVfetCnKWy9W + tBIRva2O/3aZxVEshCEW8AAJ8PnUvPHGKKgk6s2MUa+bFnWcBRfGMdoZQayogFMr3GtpfyKoExjmCTCK + RPUW+qNahvVqad3qbTrq0ReL7LRTaO3ZxtSvOKbpO/fKW5dysJXxqZIMTLgBC6Ob30S4QQdEEhzaeayA + J4ab7krrtu282tse1VEJGACBP/U7PTtIsyndyWl25/amttU4THm7qZvZ4tmGpfjJh4CDvXGIUQ1UIrZ2 + F9IE1nrWM/dWyRigAhkoGeUfaU8wTBVvdXoq43+b987sTMY2I/3G8tocTztw7p6b+gZoJhQDPOYQwhj8 + 5ruDeYqrleX3iv0vwEtBM6fua5y4oP8ye12lkGvrQf4e/T7pZDrcXXIK601AB/tO+4VTEwESE8KaXHdx + ahWYI8AwsKNfd3SiN1qCBQzx77wppwUsQA43h7rjtZVpYAO88Zv17AG2aIHi+l75PuMgBikwlNZXPeve + rbfm2To0RsTOTdwfyi9VsIDYVC9LxVZmtrsNHPPso2zj89Zd67Jzp6eUCgtQwANQDv44yTY7AnrMxLZH + tCXduzb0bn20l1z0ofgUg4lfX6J1QRJOpTfgNcP5pfS5u24H99f5I44FumG/ZDnAAhZgInyn8L6v1pho + 9iJJrbIJZQLjHxYgAiaA1/5vK65rAtIMcZgPlU4phEiJwNhpSeL/j5T4gxSajfoosALXB78awARIwHZ0 + D23e6nbC7/BejvyY6GS6zGQMgQEcwAUsAAakTgXlokUkIHKSwjJGqM2IznCIbd5KCbc845QArMCwgAJ2 + gAg9CQdmgENuLQdfzdF00OZwkAEfLfZ+p6RM4A4kgH+0sDciQwYswMbyzt3+a/nqTMA+Tw9vrHlMAmPe + cH1gpgEQpTsgpfEMTsUa7duuKeZuZPvgBwVWoE86gOcCsSkybAdggAIWK9ikEMA6JceUjZXgCbc6SEpw + hjJ4pcgu8VcArQJQgFoO7sSkCOwcT5se8RERri88piEAoo48AAf8rhXz6QU0xRY+8aVuigo3/8XHio5U + 8rAKKYMFYMCXiFFqNiAGXADrDBH8sOURD7DQIonxuiW1tOwvykoBHMACXsD6rtExMEADdmACKmAO1Yxw + 8srzoBEUOSWVeivI9oNJgmsI35FIXmCYFoIiGiVbdFEXFTHxuAyt4ssvtuoHsSQFCzKFdOB/nIDtLCOm + eEy/llEZNS0K60/+SoJXMpJcKEAhHo3WFnBRxs/lYI72DKgAv1ABVqAFCssSV/I0loACkOTtTOm2mjC3 + PG8JTTHuSLD0boHMftJSbsACpqUbdW/hEpDRvO4m2QbyXrIRtkoFdA0jo7I34nHDYqAC1Owjk+7umG/O + QBIkjc8lSAIGWP+xLE9jA1pAATQqPFxs/MDRtKwFm9zrZLwuDQnuBBZgs2LgnvDyV7xBAvKLP5gyJOXv + DvcrJO1PzkyljtzxMRtDDPSimgqQ/NbrL2tSihwQtcjxUEzAAdInB4YRNNUDA3DAPTgRPnBK7lBx2PTr + +eCMZ5KkJE6FAvSNNtOje1JAL6oFUh4FbRzuIa2MdwqxDQppBoIRORPGIOaxEzPNMo1uH53PCU9S05yn + MijA5LTT8iagBV+wo+JG9uCr62QSxRZwbdjGY0xgASAgN/BlPRPmBnTgPSjjFDcN3l4h7mZhnfgKjApU + BnTgLgGUI1ivBcfjicQOK3kkNW0u90xLEhT/EwImAJEmtGW4Mxy0C6fmrxn10ZWc0QPXabtwQQd8skR9 + 4U3e50K3bPHSygBvrmQSEXfEIwGYpQGUIupsFG8CJbtySkVtyw5JkPM+jrZugQIEJEnlolVUIAHe04m8 + D8wWzaMUTvaWyEc0Kv1iCUvxJjLHoTPgTPn0L0o6sAlHj79kFEJrVE07QRQstAbVquYOL/EYAVCzA37I + ADb3R0+JRwmYoBVMpRZIqab4y8eW0c1oS0atVEIVtRNUqE9pj8VOUwyn89YYwgS46np0gCw3dVw0gKLm + kC17c9n4MC7lr0lO5WBW1SMeZzmRCPFsMXe+EVAXb+uIdBJjgERzdVF1/+AF0jLzVuIk/8vYYHQKb+pU + YEBVk3UTcgAC+JIWE1AREegrC7GATuAHZ6ANZzNbEyYTCdT0BGuEGlRB34wcrDVd1bUPNOABsK0wS8uJ + zJCkfCTrJqUCXuA47xWLNGAjm8u3pLAo+/HoJBWw/iNqDpYbZKC8GKU0afIwzbEWIzEC09NeK9ZEW1UC + CNQjYWqDRK4KPRBUqudYR5YbJKCRvpBHWXMXb/DRxOMFT8BIc4EgY5Z4xqs/gs2/Mi4/ovEZyWH6sjNo + QYEFq3JQR8b2bhLLBtNjFEDnTshpVUoeMXAOTdCmTFLzRNJOP+MlSo1rqU1DxkrbUOxTSStRFIEKVP+g + dVJPbQnqyIJyFfqmYam1Uj8FFUxlBu4Ib/VoAhagrFLLvSLi5gzzIhgi0tQkB7DVcIXWA4QSKVUW9ObV + ZtDTDS13EzpgDFiNITuUWLtyPxuABbIwdGELBzgAu1KUMoPzH3MMXmqBBbBQZF23CERBdCJXO8LtOXkR + iU5AsxSncHsXtgzCGMnBE5mk86jHBJ+G73h3eYnASCIgAWakgCiJpDBi8WCvASyg+rB3xhKLHt/PJVpC + JZ7VJCD0es93CDSAAlSA0AJWIeezEAkoEgupAnZAU+c3j6RsByRzJDyy7eivVCCVp9J0gLUVBlxgrBrC + IbQuPgtxLyrYBHbyZ+X/F4ItiFX2JqdYdDhFQwJeC4Q1IVgsqnENLxLKQwI+U4VVKnY2UQaYy035w8Z+ + hgJiQAKQlIY7oT0mwwVUAC8I4dZgTwEY4KE2x45mWIhVqoCHirky71Gd6xyyp3KlGAmCCs2GqSwWggTe + 80TqaAeIq4tPTQO+QQKSa7nwbQJg4AU4IIrV+Au84XhGIgUQqgrQpD9fAHTvmNKeQgOiYiqu4gYyIE8H + GQxuIAccbAdeQALQYQc6YLgYuZE1eZM5uZM9+ZNBOZRFeZRJuZRN+ZRROZVVeZVZuZVd+ZVhOZZleZZp + uZZt+ZZxOZd1eZd5uZd9+ZeBOZiFeZiJuZiN+ZiR/zmZySUTmJkHmvmZnTmaoXmapbmaqfmapRkDPhjl + MkADqKIDwDmcxXmcybmczfmc0fmcLVkHnkyAiVnD3FgOhawf6bme7fme8flhRWMCJGAH/vP6pOzBYAAD + r0QGDPqgETqhFXqhGbqhHVqhK+BK+Dl7hFGZiYAu7MKIj6isOLqjPfqjQTqkRXqkRxridoJeKjH4pOwb + Bloc7LF6eDimYXqm7bGmZdqmafqmdTqnZ9rGrATfsKeOt/mWW+R4XEAQ9EIERKAAlLqpnfqpoTqqpXqq + qVqqC8AANOp4uyqN0o47MZACDLoemau5rAfzzPqs0Tqt1Xqt2bqtzbq5KoC5rv+EAui6MYHWl40khwiP + IUhgBEbAAPw6sAV7sAm7sA37sBH7sDPqBQ9hq/RHkNFNCdBsDn/GSsY6rjHbsjN7szW7szn7sz07tEF7 + s51rYUejNIY6lnNgAlxAAUZABEbgAGI7oxabjG37tnE7t3V7t3m7t8kYoxriABZbuAHbAESgBBoA7fjt + LJmArOX6uTF7syN6pzgbh6dbHDJ7uab7uqP7uUSbu737sssa84AmHbh4lquuAuKEBIz7AAxAtoWbjDMK + o2ZEuOkbuO97vvU7uIN7v/Hbv2n7v/ubBGibwGU7to37vXuWBdaE34JSKC/bu7v7ui3buqmbuif8ubpb + uzf/PK7h2MOzW8KlO64v24fRGJgxQAImmEtpW7hd3LbpW75lnMANXMbj+8ZbXL5zHMdrnMYLPL5x+8dd + PL4hDkUyGaoiIzet5GdGHMMxHLsjGryvBMNBHMR/+sI/3MmhHMqtfMJJvLmYCwV/2QMg4AQIHLBpewR0 + /MWF3MdtnMbhfLhn/Mfn/M3pvMWHnM79Gs1NIAUm4MjH6d+yK8K/u8pDHIe5PMqrnMqvRNEb3dEX3cIR + nbtHe8mJjJenQwARYLZre7flPMhB3bZru7YFfNTfHLjrXMDhvMcRHAEYAGrcOW/rAsK3W7Mr/bMz+7l3 + KrQJ3bJ9ncRxfdc5W7Q1u4cL/za1TVkHutAE4FvH3bzTQX2x6bu+CbzUp73HgZvasz3A9/vTeXuxATsB + VuD3TO0gXNqzgd3DsRzLax3KnbzLG13LvTvLpVvDK9zLJXysSc2OV5lqCLGv1Ty3Td2+Cb7aX/zZ13zG + ZTzGaxza27zTbxzhRT22JU8G+N2TMGCywTzYM7zWQfvC772zRf7WbV3kJ53Yp9uyp2+ubHkDWEAB0FzI + AdzZ5XzgbxvaY3zbFV6+/xvnCzzbd76+hfuvEUDi/EzlNj7fs7veM5zDo5vpLxzfKbzLhf3dS17q5xCA + Ad2UPSACSAC2Rf3mnx3VV52/UV3b6bzH57zne1zo4xvof/9bv4XexwtgBFRAAraeeLwhu1hA6a8e5f1+ + 14Wd6dW91v2+8HEd6us9Cxr8ljdABhzg6yOexsmev4d72/F8wH++wMMe4SffxyGe89s8zgn8tUegPNYP + 8DYGrp/e3js+ypXe0Dne1hG/yRX970Obw6PeSrDnvE3ZBiTAotg7tin/x68dxjd/1T+f4ZMf7cNe1Qdc + 1OGe9H08tifFdWaMLoYq3aE75Cm8+7G76oF990Hbwnm9uglf/NEdrn84hWNZAyBfL9Q87aOf5t/823M8 + 7tt+7WUeCEgH4ZBEQhSLyCTSODxAE4tWjme9YrPaLbfr/YKxGU+sIpvNKml1hZ2endv/8rfMzb7b4es3 + fn/+z9W5xen1qcXNoclM6IQ5PkJGSk5SVlpeduU8nCAQCRl5Pjk1NYEOLS2dqjpBGZV+fooWgTY9tSa1 + CtWyQh0gmER0YA4Tb2nA2LX58Smr0eUJ8q0p1z0fSgveoTXDaXNrR7vxedgUm5+jp6uf60Q0jcjuOsHe + +tqyHt3imzLNgro+WTJv3qt8sOjNQrDixbqGjzRMQDPDArRp1rphc0ZNj7RvHTHuySNyULJt0tBQfJHB + IcuWLl9W6qBixIh/+UQJtGezl0F6/xLqy6mrl9BZAZMMjfXp1QF4NVFIgCmVB44Ye0ImIiTS4pxv10gy + 29qnWjRE/9iYdTukxoIFGCunwo0rN90OBwYMHM3laV48pABvJhVoUBRgvqaSAh34N9c9eAyiznWoIYYF + FiHfnAWr7KNWtCU1qjXk+TLZQVcJVW57IzLr1q7BeFgQQsQ9UwX/Ch5V7/De3rhsKzmKsHdRWoTvnoDx + Ol1VC2mc4/GmtuPGZtKxav6op9pW7sk+76nsdjn58pF3LChQYEQtWbp56rWn7zDTwYZVGT2cn55gUrV7 + jWDACZCZN0xzJonDHXUWYTSdaV8hGFYhXflR3UcV5TGRBRKsVqCHHza0wwoG0MbYP+3Z9N5Og9mSW1JD + IVULU/7d5J6JOQWYHIiXQHQhN9515//ZV9JRo02Do23mzTNHKtjHDB68taOUU8akQlO25OWPcIIh1VdP + LeKkV2FG5VRbin/FAgVNUFE5SQbIYAbeZmY5CM5nmom2UZNEelTnVXTsgEGbgxL6BQcRlECYUrHQyJNN + Mna5lzy+5QaplivKx+UnNZGQwAoeFPrIGBRUwxlopnl32YPboVWqWXsWctKdIyW5SAeChpprqBuwcEIJ + i+o23E8w+nVpb4r9xguwOslXI3FYHlDCCRE0ousXGOgAQxnQPTgnhH02KKcziIhVJB3bfdtqghNVEIME + G1gbb5saULCCAiTAY9xBl0Ya7GC36eQfmf4MpOk+mMYCjwkLsFD/hbxdaODBBGxN4xGsJWmVp3XQOLhg + OGNdV2QbFMHQQYcPo1xgBi9EwAC+yRoEaczBGVUsi6EM3M/NiMXIUylPwKNAAzJokPIWGHAAA8UaLRNa + WESeu9G54WLH5EgRrmpHZTO8AK/RX5OngQxWrsfUbsP91rOiudzm72KU+iOwfjcFOAIDLNwKdhYaSDCD + Zd3GKlbgrIZMdYap0oknRq86g5IMHpyst+Rz7eDOem4rRfC+AInZnz6Z9qVosLKYqdNeI6znwHiTW2HD + DjI4h6SSdHKFZNQZXZRdx+Ve9oYFMXDAuvBx4cCCAgbAY6LpiMnsKOc0M2oi5z+h8t+KqezU/5QBCLhQ + 7fAbSHAGgkNWaGf5uH9MGoZVW5fWkX1QJMMLRQ9f/0sYTNCACQjQBJTOawfnefwQXX7mg7aDRO9sRJAP + PEqwAKLZLwM6CN+C1tcdpnnlQrfbnQY7EyQ+UOAFOcCV/UrokByMzQRNgZG+Amg6xgwsRT9D09yW9z8x + IUsINJHCA3Zgwht0ICIViB3GVDWdxC2OfU6rzliiZqE7SaQCMOBAlExoxXRgywIr4F8vcPG5ue1iF4lx + T+aqhyxLIVA+pLvSARjggheUw4QbeAEFNGQSQPAugxPa2OLAUhaRmSEQaWmiMyhGgR1E7oqKNAcGPOCC + e9UtgPuqD2/etv+KmfkEFvLwC/X+A6D+mSAFMCChCXNAx1IxSIPayVCcJtRHww3OT40zCWZkQIEY7AAH + i9wlOmwAgwigIAELZGMX71GPNX6umMXMXJpsBC1jDvMWCEjAtChAP0VqQAceqCPFiBhFrIFTcBnaigbF + QavnOIctFZiAB3KQSF7C8xI38MAMWkYCAxQAeV+00X36uTlm8pOM/EqTU0hkABIIjQUS0CUvM2BKCmwN + M+VU1UTFWdGLTgcllgkhDkgZz49eYgMxeCQ+aUITYDFvFZrjTdxUqh8aTYovNWnKCERggASkQAbB+ygG + NkCGGJBqLUOMnUSKatSjIjWpSl0qUolqBlL/UaBk1wQpVXkEAwjYywQlKAESaII8fSLPq2Lt31cPcBez + wiOsX63bXUyKF7COda1mfatYT1ECEyiAARGIgdeoagMccMADMJjAGVLDlsMiNrGKXSxjG+vYxbIAOouQ + wA50oAGPVjWzbkqaBVywAgb8Cp+zUQ9pCyAC06K2tKdNbWlRe9rXvlY9q5UtbV1bW9VGSwEriAALYmAy + zbZuA9rUVjaoVppAyiG5dVhuIJmbDTkIgrnNna50FwEDD1g2jsDdbiV0QJkIOIABJjgCAhDAVa6WN73m + Xa96y3te9rZXveiF73zj6971kqAEDFhACh5Agd9y1woZ0MAGONCBDlT2/8AJPjCCdcDgDjg4whB+MIUp + LGEHVxjDFX5wZTnAARxoQLsBHnEkcNABbfmtBS14wANW7GIWr7jFMo4xjWfM4hvjGMc1frGMe7zjFcMB + BrnELImLbGQrYiDJgloyD3DFZCdb4clNbnI5MFDlKzeZyVOG8pS3rOQjgznMYh4zmcts5jOjOc1qXjOb + 2+zmN8M5znKeM53rbOc74znPet4zn/vs5z8DOtCCHjShC23oQyM60YpeNKMb7ehHQzrSkp40pStt6Utj + OtOa3jSnO+3pT4MazVbOwA00gAMQ3yADNiByqCOBARMjWGK3lMALPLADd7a6hBjQAAd24AFaTyAG1//d + wYFzUMVcP4SeEVCBA1CwPwTkdQENeAAjWI3sh2HAoR2QAFBtacgYxICdOsCBiK8NsR3EoAUOMEECkFCA + AYBABDVJAApSMAMYWNbcKdP2r2EQ1M2kQQa2dBdlqahvY0iABSlYACe0d9oQzKat02TAbi0wv4NbK5uE + neV3vBIDyGH8CjeAQQMSUFPXiiDlKZftbOWtABfAoK8hn9Kuc7ADOKUzQkUtJHQ+vgFrfxpbFHBAAkRA + gKNDvLQkSi3EQUCAEBjABA1gwQQMPnMQZfMFg43G+LCTpDVMEeid5sAMGGBWEYSgtSqH7WzTHvFfTEEC + U7162CbIzYnYbpxusIz/BByG7A3IYERPZzmJVm5Tm5p2tbF9eghGgAIXxGCEdH9NBjawA27DDu9YSy5X + tHFYGUwR2RqwAAoQUICnq7zwKS+8aVmvcvUknTaeckEFQD75udzA7hvrCjco2vshpgEG7+y0B0Y0m9S3 + HvGIL7zq8bn656e8BChogQTKfXuX2GAD267j3yoouz1uhgUsoIDMPb2BGSTg6IpPvOGVv3SDJv/wNiUA + CApAAgZAwLcMvT5Lsi+xGKCSkgggSVjMWsjADszdpuHABKQACYQAAcTW88Gf/DmfBLZfah2UfjWABezA + sfHfOdhA0gzV01QQ+XAMSLRByQwfpv2SAqBO2rFf/wXGn/NNID4Z1OElnnocnd20AAwk4AdiQuVtX0SF + E+BwUMiYQcx5GgZYwAkcwPrF1g2eFvOt3AS6n/IVwANCIAIwQApsCAeIHRCGgUPdHKls3vdlzR5hheN4 + z6bdAAQgQNqxnfu1Xh0eXgVS4OrRFtv5ggk4AAd6oBg6gg3wGh2thff1yRFS1EmwQO15Ggc0gAiAwPHd + YQwmHg1SIPzZYAyu3WkN3gFMHyMEoiByQfbtwAtsHN7NioRkzBpijBs4B5R0Wl0YQP0h3iXK3xXS4CWy + 3x2m3i26XU3oVgRUQBuSIhcgjb9hkJNgECLm0eA04sVt2pssQC2m1hQiXydCH/8OGpQmVqI2wt5BMYwO + hOEHEqLdaYg37UkR0U7HAML7sIsPchrgoYABpN1drF0F2qBNbeLyQV8+5SDbsZ9pQRwBFAACoED+dcD+ + HSMG5IDECNwyaoe61M47CuCCkMzPbVoOVAADGF0vAqTyzSEF1mENvl4dAiQ+kVbKsYfQFOMx8oBDoaId + ZRAbkMtFypKQLKIU5YD1URrSNKHRRdwe+mIlup7q5eEUXuMcotYDxlsJ/GEHiuENBNZgFeA2yEnXmWCe + +EhG+uSkYcsMnMBH5qNIhuQ+3iBa2qE+6mEurlwWGqQBSN8GvgBDXl1PvUDmQVH7pIq5iEwHHZHTBJ9G + ahr/2Xkk6hkeJu5iNi4mHTom8+WTSLacXKoABezU1WXTNvnN0lxHk+gkuPyIKyVi8OFADWykDKAAWfaj + SUqgHTLmNkph80mgSjadCCSAClhA1Y0iqO2aDqAiAI5gGwBJrPSlaIaL4lxNIUmRXV7aDcQAA1hjQC6d + Lv6iBdbgDJakLoKkemyPAiSkEl5b5aGb+ECHKlHId6DhBuEOhKTECv6kBAgeJWIi9C1mY8KWYrZlWyIl + Hq7c8SXA0JBjq92A9r1AGaDE963j+1wDWZzLxYiL31TAC5QjpEGiNd4iSYrkPuZhWnaihnqjP7YlQR5d + PkkfMUpjp5kYcXGlRZXTXian/4LCYgX4EIq6gAOy3GvNpxRiaH1+o37m53U6341uTxfGAHNa2qtJzFpY + xiq1KPlcDCI2jTntQdV5WgZYwPGgnGtR4QxiY2xaImsqJi5eYX9O4ggoQAr81w9GWtYp44GOpuDEknoS + wpz+SPtkBS6p6aXBQAqYgD1KZ3VC5pie5Zg2X/KFaaHiYBbmU245ALUZqaNpwA5MQJKc54suKF92piFY + kAaFUPltGtmtgAMeH1tuIhViqC8iqnaeapjC1kCOQCjxVaTtGgegIuxEFrtgpYSYz5vuaqu4InqKDyN8 + JabZQAc8QAIo6i7y52MaqnTiooc+K5e6pfyd3tMdwAlsoP8EWN2iAZG/RWTn6apF9KWRkJNFPaNGyGOo + YQAMeOSNIp+XJiVasmqg6ugNRma0YqFsDQG99eCjCpopTswDcIuPpOcqlob6hMYRweM2LEKAttoGbMIT + GmRIWicn9mOGtiYVsio3YmFSvp7TiYACRIBlTmieaUAH1GpqnOFfDmDt5JGUNuN5cgRbTEAH7CaneUAL + mEABfIBB4qhrZuiz0qdr4iG9GmVRhinspR0J+CHkeeqfzRFwamV2NA0s/YFoQkhxOY1n5oEFHODNchoG + vEAKHADqEV5rYixbPiaq+qhjkqSOdmLisccCzMDT7hlV0lHOfd0A+qVxjqsijEa4tiL/eaYBBTCCe35a + BkgABDgh2tFW0fJiPq7lNr5rs/Ko26Ll60Hc0jJMoPzZPEltVpqguqxKZ6TPwZ6TYB5C35Usp+XADCzA + AbgdyqkthxaqYlohUtJn23rsPirdAQADqPSZ0N0qOX3mRD2pOLHj7USRDLgLBwwrsnEACyzAr5zcHuYo + xeZuFTarHuLjh2osx6qtTW1uCbCAw+ZZCCJD8bqsx2StEZFuRrziGqJEZUiRB3zY9W0ADDyAAxwPCEyi + luZn0G5oQC6fszKmHUbm2i7dA9pND+1Z0lBAuVJHyxZRTbYvcppBeDhHzXYUEHIABUTAzsLgNXZv7mov + Py4wqiaf/7TC69By4wEoAAsg7putjPjYqbmupzta6gVvhXPYEgxIgA7U8Mzt7wOsgK+cXOwRavyhLQzX + LgvvqBQHKdqNgAoIw531lAQAH+/ZJIXQKSyda0WtiiqyE67B5F+9gAU0QAnUItLhZxxTJ6Gqan1K65iq + HNSdQAX4HZ3hALoJDqyEA8EmbIW8EqZag0ZElQfkqSBCRAqYXaK+Xtwq5YZW7NCaaiYP8JaengggAJr6 + K5tlwImBRtV6hO+hZ65aqnH2nvO+wLiBraJ92UvggAdUgGe5cXb6Y+3qMqlKptH26Gq2sHpcKwRk8Zzh + QPg0DgYToCFnTZ3Cr2f2pfN6wAdPhf+VJZmZZROE6UBPwkTuVYADuPF9sly0wm0cC+0CpyW+eq8eyiEJ + rACByJlIqXLgXGopIw44EHJmnIREOO8EUJY1u0SS3QAOFBgHbECIHVnNbRvssFgjxsArb8ANtG4lAJ4L + LMB4idZKRmECr/Mv8qg+lmTkVmdsFUACVECdeRdniusSGQ5O6jPgIE79UsTHccBlDTSv+doLvIAEDBYM + wECt2ZoObEAsLxLfVEALqMACMMAJKEAJJEACmAADoIADpEAL/JdRX4L6soA4VysM/ugmp/NrnnBZsm2Q + wiUCPEARo1kHQFTeQak5XSTjIOcafpzkYZ/lAWdycZ5wSsBCatb/BjCgy1Tr0R2d0zkd1CnEA8BRS2BA + B8yAONfUbMnW9mYvFUemSLMt5uYgCJCAC1wmnGXADrx1GmrMIS+JpoarOKiTsLUTTju2cBVoBYif+G3N + YUWWZYBeB2xA9JqQBrzADOjPCBCAABj3cX/AcRv3B4QAF7oABeiAbw8D0sRA/zIAAhhd/dVWYkruFJu1 + JtuxZGYhCBxAA3hunI0BDnce51HkVSoipboS3lFAO7F1MURqt3FHeTINVraLkNntb1fAAiCAaIHAAHyA + gYPAgX9Agh84vM3GCJRAClSfS8yTBThAHMJbh2ZneL8f0qqz9qqzBVbrFTd2nEWMXipvEl0Q/0UpCLlY + jS1NQC5JtzncALrZL0VUTGAmSAg18vdQwAKIgIIPALwBcJEbuZEbuAAMAAJEwOq0hA6kkBAs3UqKqSa7 + 5Wpu8rR+9A6qgNzJWcS8Nfosicf4nsteQz+jQVR1ABq/RI1PamTpd/zuXkTjtRW97gKQAIMPec86Hf35 + Of0V+Z5/AHMjgAPEgFZjAl7WU+kZAP1Vdr5m8kgDqqFSp2ajHQEcgANMQI+f2TypN+8ZEecJsgW7D8A9 + 1QtAL1zoAESV5yqt8gy8yxXZAAWMpdMR+ZEjNqAfNgHAG68D8AAUABZLRY1bQPWinRyiXAJ/Y2zyrrK2 + 7eldsfDJ2WijeP89u/Tt/K35cK0ZTMALLGRFT3cOTID4lToZd4QFPID81DfKvIkKGEByw9utG3aB9/qv + Fzi907txlwAEnPdLcIAMqJsCPKHarWULLzuXgmkvw+UBqAA5yFmxik9LK2gf4aQT0a8/DzFsTwUHSMDd + lcR6+ip01Cyiy4sEtDHP9qyfA7CvA/rKx7vKO92gf0DItkBou4RDSUALmN0DJh1Jy2aO6ifCEy1tkXcK + zKicubU6xTVarCGdKu9TuYsOkPw5APcgU7C2f8Mi9DHr4MCxPuCQF3nL37utiz1ij/29FwADxEBciK3O + l8DJKd7RZu7a5mGV52sIeDYE2PybcQBl3NH/Ccr1DlNkqUSWDFBWDmj8NevAxPD3PhcOLH5t/eyACgT5 + yru8rRe4r7s82GN+r+85CbRAKDeEQypNA6AACZyeHOouAYcvlnPo2sEeAZDAA0z9mAn2GQ4yHjkzKvez + c+Abp7PEH9fRr65iBpFnhAJ/vNALA4CAkue65xs5zLP85fu6gRvAAsRA8qtDMuv8CLjdasHflzLr8zmr + vSptAsxAnfHNt9qp4Or4IS8z1Gtr7aND7nGxKjq+tlcM3k0RENh4Q2LReEQmlUtm04jxQEoDwQAEIlyz + WKyVMPhyu+IsNVRKSYROdpt48zwcitJBVAgVCqL7fc832DMQGQQ0DAzk/yMkxNsjWZlwk5ykrLS85MHQ + kZCxmJmpABWtCC2dkQlFTV0FLQ39tGCxkJnY2cjAzCXimBhtbU39NQ0mNZX5/Izx2NBtdjbCqVgYofLS + sv7a0vYC0+oasCpIeGB+nsTYeJFJORnJzvvTAxRUHET861u018s7YHjoYE7gQIJObuiIMcqVq1OkhDX8 + heoUKFWkZEjQgaugpAwSZnga9mpYxIcPXdHSgWHjSicdUiQQAeIDNmsguGm7kpNLN5tXPohYAIMlmxsw + IjCwoygfnwL25iU61JSp0zt5EriAcWPoVq6XcHj09EvUMZEMRy78SDHGiw45NHZdwgFGLIUmhY2UGP/y + EykKHtZsxGDDRoYbhDP83fhigYEQNq1c4cYlDBnJ3iwP+EBgXA64SjS8qBABRYID/PTse0oPtT2oe/iJ + QEEBR2fatZPY8EDBl8OFeM2+QmZhVi0cKm0jwZH7o95jEslOLAadlalWMN4OvLFBRwcPEmBIkLCj7Qat + BWGYaPwFXOUuWdyDifz+PWQBIEgskFHu+BsdFFIoGKEAAghwbZ566lGNkUUY0YOEBgLaL0LaNvAghgos + MOYs6O66SwYKJnhBBw0kNOKGHWLISyzeOMzQrIYc+mSCEQfKIIcOXpgAlVhYAIUCGNi6hSAKEADHisfC + 2EInnXB6LCf3bPoAhAL/SFBBAhKJyACGFhYwgYQRWtPHkEMMnAcPA0rAD7Er1yQIHQkqkGWvsVZBq7mJ + kKHlhRw0UJPEr57TcEWyiNmNJOBimPGZg7qbIAYKQolFOIommACGHThI1BkZRhCgvp6SfDIbLELtxj0k + rfEiAQvKuzKDDiZgQQUTGAuBQNXiyScQevzI4oAVZOCATWFX4iCGsKJz8bm8eCOFuGGHsKEDCkCS05i7 + phPUoRQvtEA2czSoEBVVkAGuGFVi2CFTXSgwQIAolxyD1GucnBcnyD4QQIQUdhgWHQoaMOFLeRRkxCmo + UsvDhAo4e7Zhcw6agAJA69pWlE88hMGDHFgVFgMc/0DjkbqyxiIZxhU1/IgFb5up8cSUkdmrgnHTihPd + HPq0RIZ2PYWvPciQjPdUyiTDTAACUKhAPzZzmOCBBk5AQGB4+iiwqXjyCGGEEk4AyGGvn0HnBQvDoqha + i2ERjgI9cV5TgxMvBOYsOh9atlBXZFk5Fxx2kMBRU0BCGeYKYghP6UsoIMFdI8W4xl7GfeZpsi4+COE+ + GdiW8IYOKvjPgAEJmFoP11yrdUARSmiAAoa/Zl2XvRuVWAbZgaNIdg9lV2Y2rzF4NUVy7cLL7ulgtiAG + 3TGB49G00IquIoZAomAHji2hoISejhwVXqKzqWmLUrsBhwAREIggWIc3iMEFBf9I8JI1P/AxIP4REDAh + 9eNbx/+SG2x8AQYKYufWKTz0ofDogDysuwForlWoutVNW8OLzidgoC5KZEAHE4CbSeYWEoeAJAYcuE4l + JmCC9xyJJvFq0tDmMwZvAEUoXvtYBSCQAhSsbwRVGVAIDDC/EjBABRCYwQsMlz8iVuIGHPAADBr1Cg/F + YALhwQHmOsa0kQjPbr6oGHVa0ZcQTsIGHOCE2TI0J4hU8SIckKITJICCABXpU42bV2VExb2dOAk+A0AA + BCDkNRskZwYR4FLUGjE/BaBABRaAwQbSWERGOiEDGsgBB3SwAw9UsgM64MAB8ecxDzgwUAzZVqCkQxEY + pAT/Ezno2yfHeLKzEG6IktDBS2ISJWz0hIWgSiFO5rMemXxgBChggfm+hgG5VKAFLmiAClawgga4gEcx + 6MD0GjnNSwTGBsZhZHIsVBdWYrE3u9kgLAa3g/tRAgM7kAg4r+giVspgB4tcAg4ssIADOEZJT2pPfIjm + jTLY0kgDCMEBFkABbH7NBhrYQCS3c8kNbAAHGSgoNSU6UUsUi512mRhwBrWhsogEBhyI6CS+sjxgLJBZ + JROLJyZYzRdIAQRVsIl8elYvO8pxDIuz5wBGEAEKUtSnPwXqEjLgAbjpZW7jWiXzQAkKWUignOdACF00 + lNGkMuQjH4SnEjJAAQbIpEmS/2OPLiNXk5+5sWghQMELgrpWtrIVAzmAwfIIZdSSblRQEfnbDPxSzb1N + i1qgvKso7fSJ6D1VEjtQQQGiJDl8iuqm25DjHSEDjg9kxgQsMGVbNbvZbO5AeWRcKjtPBlqOElYHmLDB + Jo5hxd9Ih4PGkAAIL6GBB5CgVuuZD2OxFy9+QkZJObHCCBZgAWFy1rjHHdZQlXdSbXHITnRtbSloIT1M + fAaD0aUbN0kmJwxVAEQ9bQMGYNAABBCgsisklUxVWEtShc8AC4gEcuU73wjlwFjclBt0N2RXhXiiL4aV + BNNCaaijEhhZY5HA6iqBAwqswACYARoKbxnZCOfTty/9QP8JWCBN+nbYwwRxFQXilNHSAmqDyWIFKGKg + 4IrqJm7aDWVrLxaSD+aCAy0ggUzIoE/LTMbH/MQektxlgAa8IKQfRnKSLfFWTgCuqmW0Fl5ByxC1gReW + Ltavia+I1LLNgAKnzQUFTlCA3ZZBrLqkac8cB6UCmECPSoZznEVaId1wEHisqAjdAiWDUjajAzKQRTGe + /ECI8Jc6s9jjJTjgggQUILI9ziW95ANk3xaJAAY4QQWsLGdOy5l3j9LLnQvli9ISenAZ8XMn/lpGiv3G + N7/AUKItkYEJpCDH62FvruvIWJqClQA7BXOnhS3sz4gMgnp+MbJOOi4WVOAFm4YlnLT/y9x1Ygs4iG4G + DmLQVZi+0bG8zi0+92nCKME3q8NGN2ctOIFjYavQKLWWKMsFzWfoQNUkq1hzTK3O51Ug2LnIQQSogWtx + i3XCcPTxY4xUBQS4QA3phviH5aKbdhsKr4TeaIo2ShEKJLje0j4wYKcdzhRhuxk2sIACRNBPyswxcj5L + +C25UVkRKAACLI54zjebAbHlW7/yBqdVfSRbZ9hbUnVi9VSDbrFYP+MFLjCBYjPTW19POMJoTpIVQiAC + BrxQ51/XrH1Fwm/WMhctd4JT8XTA4UvoAORLT1ZJm+uiWfw7FzeoNadgevV99l1ec6zMekjAAgCD3fDT + NNG06oLF/0LHe50vKoVwVmoOo2Oo2hePGfBEYXJn3KACCejUVyXc9x1bhl4zBUcBHDD5w7ce8Zso6lTN + nnQpcxlme6V82kM77ew+8NAykLUuPLAA8wK3t6VXb6iyJ9l7EcAEDj+366V/JV6kU9Axq+JFBUsdH70y + F5WHcbZ4L/4LAV8gOWiBCVaOW9FP+uD9rPA11mMABTyg8NPHf9tgEPt9M4e1ozy0CsCI6GsDtwuZbsIv + snOR5bA7XRAvqAuBKriJCewxFMotnuAlXiqAFbCS/PPAZ+GAaWk2sxEj7VPAkZiFdCEI8JuyMXIO8dO3 + zTM/gaA1BxCBmQiD7tkn3dKexiGrKP8pAQu4vw8kQriAgxgYsVXqPRZxrbEbhRjwPl0wwGQjI7sKHmr7 + iBk8PxzDjHviiZazKazLwDKYiRFQgQkYwiJUw42wIP/JPMFSCGtxoBfxBbVhOylUNf87sVYTOUjRQoHg + qtuKqVwiK5/xQRail8kZAHGIAH5Zw0fsinSYnTjcssBqHpLbi4vIgSPzs6KiPTismNLiPIHggJQTgQy8 + I5rgu0R0OVDRghBQlTuExFk8OWkBHBZhFqATtFXwHe9CtYKYwuubvXCys5KrgOBzBtyIAOvBQXuKowgr + FXmxwJ7BDH1pQFrERtcBjQd4w8dDOjyTu7zAkBdIQ0z4s79yPEz/PCnaq7uNsIFA5KXJiqmWA59nHBqi + wRcCYAAK6KJs9McKepUZOEAGIrCLSbZL3JAe2QFOLDqQswiKYbzRIr8sRMZ6iwDbcozvWS9KmzSDow/7 + aIAJ6Md/JMkm0AQYSCfnUkJly8QqjKDB8biVOMeSMTXtQ8gVociVyAAZWAASUA/jq5cgO0RcApoysILT + iYBrLMmlTAJwQaor9D9WG5QXtCoZ0BOGbMgDhBEtG5TR8iQZrMhn6AAWGDN3eawK7EjTqzAmwYICQAGv + Y8q4TAK46kajirduysVWSKdu6QCsdIaZ7D9KNMgYvMKcXAlNiIAbXCzRG71eQ0Te0glwQIAH/8A5uZTL + 5PAr/BKt2qs9mQmG1WK9lQjGBHy1kCMtwzzMz8vBQYTMv2uSaFTFbsAXEfiVKLTMf9SA3jk6oDO0ugJH + ZvEQ3GMJwPRM56JDVpIbsNwKxXCH69FByHLFAYmMx3GSygoBBKiS27zN6nNC5ji2AfO9YEiGmByK0WRJ + YeS9Zfm9sDSHDWiBdsCMr5opJkm+46MjgiuAPII27YTEoeqEBLTCVruzk4CUCvgoArwE4iSU1bKzuVvC + UQQMD0g/Aui2oGxNxsSlJflCgFoAD+DPpWSy39GgiIQymqTD5+ARD5BFgRjNjGueiEzOkvvDw5QAB6DQ + mWhNmgorsnoSXv/KhsxIgGD6UJLEzGrBsyOVOyXUuGGQAaUsCOKcCOubk+T8TJyE0JWgLZ+cLHvhUgrc + Bu6RxjJ0gIUZ0mx0GxSRE1xE0vCEvCmNGWXYT8oDtFusk9KUMrqbUZaYgBU4gBDwUVQRGl9TM+3BhpmY + EhWAyzJ9RPRZjotST4SkSmK0GGWwTYIAzMWbw93TPhbI05XIgRlgI6/yhpcDQ1csFTj6Bi0IUkWlxc0J + NJOZUjm8PueQu1EChQPtjD8LNM1zN+g6sCsdTghIgC7k0jTjrS69R/oYgRSoVFZ1Pf88uhGVGchrEQfl + MpF4gRVdwXszMQddNmojFGBliW3zUx+1x9z/0tFvg7mioc2scNYi/CKUXLWQ0LcqzZabDIkJcFLRdMje + M827jNK/OUba4ICLdDQ3Kkp9oiPI2sHFqawCqL+FfNcPzM0c8cT8clN9e642tRMMgaY4HQjwa666cck2 + DSfU7IoMiAEHqCcc9TvTS8Rj5TFLIwEHiAFtndic24BUEiP8Us+LW9Cq9IByXMG3i1G79CaUEleW2IAZ + YIAC2Lsgezl1raXuWZz5u6xmzdmIu6CVrMJwlEqJtJgv88uNqDwqpURdXE/bcImBo7SaOqFiZdgcBB0S + cIHi2trDOydXU6dxqdfdc55RuAitBUbdG1ES69aw9UP2XAkbmAH0SBJ+/0pYC3xboBE9ItvXvIU43IhW + uvLbA/vcWbUYmakFBK23e/vN7JpDZRm7prON8SKBgz2hfOrSQEXLndhAxtVcdLMBCeARKaNELssz4T3O + tFHB4wjGFgFAAX3KFWlH29iACnCwatBReCm4CjxWKAGBBXDE3TU8nhOOXkWpwB0w2xPIGYABojVb1LU2 + NxVfDVnarcgBCyABKsgMoXRN5DPEXaoCFPBQ7zU8DHgBklLePKvSd5NSsxBOtr3YT3JfgpRR3WWJHVgA + MvMt6NzB7aE63rJfBvhfAP463FiOEh0eA8a8f+UzvK2N5AVXJvS941TO/cABFyiB9Suz/T1XSJuX+P9E + ge4F4Zw7p//0SgIN2Gl9ylGbLpCVSSGGIGIILdkTBU6V4MOkAAcogRDAUWmsz4RD18minAWY4h+GM2kx + u6V6QdJ8t49QG/Xl1wPMOOZ9USde2whhMBUYARw1odLT3y+9qZw4gPIR46+TC9khyF0E2v2iRBaIgcyK + kEuVSOyyyVGI367IgQdAgMrK4KK0uvmsNDAQhxYg3EBOMm2iVUwMXM9Ez2FAJDZuY2AgTBcu0c+N4k6t + jW0jMwiTz8idXKqbjMw4ABSQASUW5Q+LV/4j0BIeNauSmUUuW65wZMhThRcUF4xzN5TdjxtTP1F9HHRF + MyMBFet0sxcw3WGer+T/+M+vRWUoW1Nh+Ng1SV6Ng45SdsmbZMBWgYEUKC+YikaYY8WZ2mEBKAAGkAFW + JucO452E0MsX60pIdVQhYhNHtgjRpUpqdd9QkOK2oQAUgNr7veDn/EJ78rGZMAAVCOOCRjIqGpm/LWDR + NQWyZZPkLbFcJMbifFHXvZJYGrh4DNRcZhxuWI/JxFmTTrIzfa0DnuiAzcQqExYoPeMCY9PftGhatg0M + kAEUYIwuxC1IE5pxA4fKWYFEFWp0K1LLoxNqbggTzkKHFpYWLetlicG8mGaTtWYJKcUTUEyr4+e+Wzid + coC8CWuIgyupCluKHrvIQ9/KlBAFHeKyRk8YlggM/8nc2qhkBJCJH1tNW1K+AbGJ+jABv/5riOsAFPHK + ukrPFG5m2jDPuAldfDvrPhRIqd4Pl0AAAQHpHe2tfwKdEri5z/66DOAAsUkL7GttI4YZwnoBNGoYpuYo + F0SxEy3Qku6K3lUfMqusrJbZIpmJMgQm6ObtJJPEk3kOcgk5Aw3lFXZIVD5SQ47U4kyRi07uB7jin5S/ + TjY+8WEAMu1usEOH7kBJ2klTwcEYD0Buh7lU1j3Reea3DoJtCYkCLgmQL8jumVAcxQEDESABBVgB4srv + 1uujDnBD4QDxEAdxPrOFoN4PmJZlI37IzyVM6nBvhzFnK1asTqHxGu8UEDAAE/9IAeAbyQ3PuYPAEUex + HduRmBhYiw7QgNNuZCauyQPft9U+BshunRzgHAC5IdF5DRHQGhSAACj0cfzDAISSpA7YAUryAPHApA3g + k/xJ7UiNG2FM59W26a/JgdxgAWRygGVaJgdwgBSAAAuYgA4g6C9Pt8C4gcI4jGli6lkl7tUyYVoN7xff + JBzQAf72jhcQcBMn9E1PgndOqjcv4t5orkl2mMAgjGvi9FRPUCHO2AIbXgQuKSlX9Vn/sGBEKucpa+dm + bIuRdFr39ePS1SuCt6QFb4iY819Hds1yVbIeWcAduTKKhQVP9mmnpv6gFiO9U7HNoo94Xmr39p8KQey7 + Viv/8ttYhZka+/Z0nygBc2CETDoUK4YJKG91p3c20QAJkJiZnrEkhbHVOoU1rveAJ6IM2AGU/J0l9Vdi + Tws+iyaBd/jWwczwnch0pL0o97JlUPKH13jaSC0R8wQSe+HxfjHhWORx3viTZwkc6IVbLHexdXemk3eU + l3k24TmyuPboOrYSXuCZ5/njmDjx/vSJb2kYQOyeN3quOAg3JLuJ2XaKwIgeP/qox1IyjtbhRu/GRoZ2 + lvqthwtzLheLe67BWo7/4vqyp+Qk+qyOomgj/RC1Nvu3ZwkN0IEXoLjfReLN45G+WDu453uWsAFJ7Fm6 + 8jJyzPi+N3xKwIEO8I6IEcff2ZUZCnAiCRD0w6d8wJD77hBtgQwZWiigNa/8zyeIv+cAvoEBFPkfELmU + 4gD91S8IU9cAhHIoDbgBk2f92rf928f93Nf93ef93vf93wf+4Bf+4Sf+4jf+40f+5Ff+5Wf+5nf+54f+ + 6Jf+6af+6rf+68f+7Nf+7ef+7vf+7wf/8Bf/8Sf/8jf/80f/9Ff/9Wf/9nf/94f/+Jf/+af/+rf/+8f/ + /Nf//ed/IOAJh8Si8YhMKpfMpvMJjUqn1Kr1is1qt9yu9wsOi8fksvmMTqvX7Lb7DY/L5/T6MggAIfkE + CQUAPAAsAAAAAPIB8gEABv9AnnBILBqPyKRyyWw6n9CodEqtWq/YrHbL7Xq/4LB4TC6bz+i0es1uu9/w + uHxOr9vv+Lx+z+/7/4CBgoOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2u + r7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3+Dh4uPk5ebn6Onq + 6+zt7u/w8fLz9PX29/j5+vv8/f7/AAMKHEiwoMGDCBMq7GbjBo4cHDp02NGBQw4NGmws3MhIww4JFCy0 + cBEhgosHFmTA8KCBo8tCGnTAqPAAQgMVKxYsWKEiBQT/FhVgdNCA4aVRPjc6UGDxIEKKFA4crMi5ImqD + FCdZUNiR4ahXOxo8zGgwVYUKqWejRuUZdWeKGSy/yn2DocOEGSlWoNC5U+rav1P3rogwY4IOjXMTn8kg + FkIKnFWrqlUrmXLVnhBmcFXMeUwHvJAno418lidbyw5SVOjQuXUXDDpiuHDQN+rZtLZP/y1N24ELChxc + C8eSY8IDspTTSsaZPPfkyw9gbBhOXUoGGC3ITn1++/RtB8zBs82pIsIDCYirq1+SY+zftd+TS2aLG7WK + GdPX6z/CGMICFLaBJyBaA95WmnK8UQXBDkXt56AQG8QQgWACjpcWTgdeBt+BZ/0X/wEMLT24n0czRLAd + feB1F9+KatWXk2qbibgeBxQct119osFHoGkImuVXCg/EkJ+M1e1gwWPvmSYehge2WKCL4LlQgQ5EqvdC + Cz6SpuJ3umEIX2UWNvDAC1VWB4OJ84mG44VdCvidlyu4AEOZ1MXQAIAVVohgcxnipptUK6QwAZ3DUaAC + AzspNyBPWzq5qIqALtAABYQKZycK8+EW32kW6njhoiioEEOlrl2642h+vRmgmzu6uIAKg5Lamancsdop + qrp5x9N/k8rqDA3A0nDIpZk2x2qAm6qqHAoNjFpIDRjYUEMNvgKSAQ4a4LDBBtje0GAgpo6H1p6dclqf + l1Ix6/9sINdCpMO7FmVU7R0YaJBDBy/AMEEM+06wLwwS7MABUX/QuqGjquqJLIpTvbouHxnksAMMFFQw + gwUssGCBBTPIEEPAOHw7rxsY5CCBDCy0AMHKLkDQMgQqPxBUDuntQaxzOpbbZILxiaeuH2FVYJNfOelU + WQMtUNDBDSO7cYNMFth009RTqzC1C4UN1Yedtem85qooEsgcebHqYYPJRy5gggJrK+C22ybEfcICv72w + gchNl2GDUjS5QNJTKTgFuOAlndTxCyHmcfN7PWPIqZs8fkobs5TqESELLuDEwAmcd9755icwwMAKDfz0 + AtN5l1FXBS4EHnhJsJskO+yA+23/wQs12xGuoq2G7WOOuZVG3sNgSfjf5qInr/zyoTOA6ZhdpS5GBjtQ + 4NhNr5NEUuyy/93A91LGhYfBmUrO3WWdSq5Xs3lwEEMLDpzgNufLO38CCspzrkDoKkSXuPRdyMALLOA3 + 1zmlJFgxSQKd0jrBZY8FIBrfncDkJzYxCWEKWwvZ8LCBCjTgeM1LHgrutzn8mdB5yHOepCgQPQBuwQY6 + 8GBPXle4BW5PewjcXuCuwoIXtJAOXAOT2HQ0IPEQaFwLo9wdMhCDFDBgf8w7If5Edz8SIi90JjiBCzyQ + OxdWAQM0akEKrkK72DUQKzak3d98IoMO/FAOi7sgh3JmIPOh/2t9xIuDAB8QPyja74QoJCEgp4i//anA + AjvoohelsAEKjOSAgdMhDv0muzRur3APkEFw6kArcR3xiLyjY3fSxb46eOABOaGf6PAXuioCMnlWZGXo + JGUBKi3SCh5gARmzpz1JmrGGrbshAqODujkszi9OYhSfhtgmUlZuDjiowKGaR01CwvKPsRQkClGQAhjg + 7ZZPuE52XEfD12FFmAlM4CUNiBUK6OCbbggin8JmKy6tiFM/mwMGcokCBVBxiv9cJQqdh4IpWjGFnFNB + BXAATimA0XpkVGMOY3fO2anxbwe0gHSAOEHn5OpUFlQYl4anTx3IIAJPDGEJ8zdCVgK0oP8lNCjnVvAA + D7yxoUvQwAtm0DpzSvKGFT3g33DIwKdEoAUWkMBN2xAuTy3pQk2q1apKk8843EBCK2CACQI6wpUO1KAu + HSgJ5beAFMggBzh9gvuaYlSfHpCB67zhULsHuwZEoAJoheOdjPUnZCoMRXeUyqvKBocOtGABVwxrIMN6 + PykqD6BPBNCY4JnWIuxzBi14a+EoSsnN4lCdE11jA1jgAcqqwU6jw5njLpi+Vh1rfc98ww0m0AAoKtaV + XGXpKscqy72kIAbFrCwSrtMUwqUzmBZdIAN/KUynIC0GHFDkaff6OBa5FpSPipSo9OgBC6xAlbyFJSC1 + 6VLybpMBDpD/wf+Ea4TZntEkk3wraM8JVOSyk4EazesbyHdEc0mOTZN5Ex7jYKQULKB5kG2pbsHqVfEi + dAEWYCh7kXADChBOom4dalzpat+3uiCppj3DMZ3aM3Mth0eg6tUbMkABA3cVoWDV5j+tad78MYAFQ5pw + ETQgg5ssl6jKDSpcOYtA+UagAS5QLxzkORo/Bdg7x1qVBgcLhxw8QMG8VbCDz9vKE7ZytyMM3QP0q2Mi + 4KDHu5yrMDs7ZGBeUo1P6QkipSvijvLmYOhakoXSZ5pXxXYNN5BACk6QgMdGMZu5FeEgUbi/B0i4zETg + 8RgXeFxfgtbNF730VYIU3Xju1bV7WtJU/wvkpg5VdQ0CtEAfq4nbBZ/3j1u2YuhwDOkiXNUFdqWhRTu7 + YeW2eZ1CZcEEcjxdTFEGMFnK83MYh89SsiGGZEmhY7d5UK/KWNYwDTMKWPDoWvPgOhCAZAOXu1l19hLT + m1UgRiOQGdYw9YPFem0FScOqPDcMVm6QgAuOl8LHdhmbL33pea25uQXMoNu1tsELWBDuSJK7qDqcaJuL + ulw0Co6Y7zY2z4joJXtyPMV/RsOZ4/dlLptQ4IREMG7DG7qCTiq4tV7dIy0u1M9SkteXjO+bXYdkGbyT + DU3leI+WqUzsDngNOj3s2hY78C3DWsEEl+L9VtACpXqbCDmIAeZ0/f/mX0/0uBXXnjmPbJ4YkBkN5AMw + Pf9UwUWRMo9m6ICqU2q/WFtbsQOtu5Y7R8sdXD3SO7WJw+FK1NDa8Nw7h2Qkz0NnMdxs4y6a96cqSFUV + p0ED0mSloWFKUKebMJuv5LwC6BYDhF89QoIfss3pmkbu/djDa0zy2c3A5CHaHrBNts2mTn2GHUDAoIld + KbYDKlBYC9/LClgBCzb59yEofJxETi5RfYncubruklexgAdgXobF5SrZKfKkpjQ05e2mIUJO9KPAD5rt + r4Z3kDQ2QXqXenW5K37Dq3+9r29O7p4CqY2N9wUGMzbn4ldSNkdic3RnEGh8JD/I41KOhWW3xXn/sQZ8 + 3dR8RhAhBGRU+jdXE8drYAd2ggMBDwAcaXBMGhJVAgYpmrIoVIYGhuUAXfV+YrVowydenDdWJ0A6tYSB + lhUbD9BW4nZu8CVRr9dcQAVJk4V21MVX9sQwCIJiY6NEixEDh4JQVLR5JWReUkeBjQU6DKACLGB1PkgE + 1FMBxkVuPpU9lcRmDwdMtINkQsKEePJJv/Mn5Id7u+dsZZADFoACWyVtKQd1URRFYMV5hcQAcrJeZcgD + GkAB78U9wQRsEwdawXRpf9MTcMF9YRBHpJGCyaEpOCJqb3cGGzABLkB3XtVSkDVj7ldQCYaF8rNtzNeI + RLADDAdnhWeJOadu/68ncRglMwxCe5+2G0UUOV/SIlBWfnD3BUyUHTOIdyLkSsBXbSwHUI3VLCGGgcXB + cD2Bf20YdpZoRhWVTq8TJKYHBjfjSUhURAKWXSnWjF7ghyqAWNQkQls4bY0FUzL2alWkANyESLZ4BHXh + SBGVf0iYbmo4fekGODNgS2RQe+XDceaSQXf0gmTgARMSQllmcvhoaAEVXpvjNspnUwN5BDbQXW3VdccV + gg/XWSEoWhAgAYwogB3lVEgEhQFGasJDhWPQQSuwNl72kdcWVlAnSCm3WycQARPAiSfJAxwgA++FRrxm + UbDjN/U1ceXmXEm2A07JBQNIQS2ok7eijA5DBv8agB0LYFufd4iu6GUMho1wiSgt4HdPeQQ3MEANp5D2 + NUmUxpDARGkHlEnu5ngd1Voo5o6OEiDjoYBh8ALHEXAOxmAhiYiulliDQQE1eZc8gAMTgDlXIYINyZC9 + RoRjFzjRQX9bIJHL1F8qiIzKgZFgEE13ko9xSZSWCWYxtVJh5k9vAZGcaQRRGQHfaJU/dZWctWbIiZUH + pAIQoEljgFoUVET1BErKFGqw5RmH5U+5iWB6V4P/xooNRkVbVZfBmQQ2AAM2QY6XCJMYNYkSR5UPt0Mp + kFSbqQVh6SkW0jPUOS6xaX5gkAMtJj8tJ1AvVW272ZZfZaD/uAIVcJ/n+Rn/jpFDzZVu8cVhGNqGk5YZ + idSJhzlHy+ha9FF04uGYXaABEwAB3+VP7seb0/hKH0l8SIkocrKNnIkDEhA1T1GhNAeMa+hL8ek6STN7 + qwlveUJEueckUUWKGwQGO3BYmkeBTJePd3eg/MiPMxUB0HmeSnCKYjR2auiL6nahQVWORfYUDzCMNlmH + Uhg8O6kke7KHIacFTKQCBApjAvdq1BZjlnlC+9MAM+BGXLoEcjdpDYRR8tl1wJhzOXd9Y9QCw6aON9kc + YVOW9qYoJkqncreW3imXIlmDERiSsBQ6HxKAg3pm43ZfuqZul6ZZ41Z9s+MT9rmmuMKfTyJl9RaPXxCV + //s2P8TXfq84nstDY1uofMQ2qATZGBdWTpg2VPS1kGWEQGPEbjPwAjYqBQZjh7lnYk1yK9kZQLKRVaqU + lLi5oE8XSzFFPw4AARNgqsiKowS0S2koZFaJnOXInKkaTJrpBXGUKthFeaNmKyTVBRvAAlnVVZqHj1An + l+eabTPqgL9Ri8iaBBgQIV/Khq2KXL4Iq9yzf48BqMCJn9QVHrbHHTjCI12SqVjgAS7ggMNKgyp3pTFq + jSO5ArXkrhPLAx3AArooX0CWf5Y0OxprNeeRjlaQrXm4WimijI3jUbKJBWAkA3bqT58jUNg2gVNalLDU + ADCAsznbSDNXRkHGnEcoSf9jm0NPkRkvYLRU4IlI9CkVGWqkyCtzWgVRqaIpRZnAaqCdt4p594UF5wAt + ELI5qwQYUD3Xs6p0dYQL+bPNdRUukDSFmQVMlpiMCX5O+Fq8dwUSAAEy2G832GqTWYEOO1MQAFyF+wQ3 + 0F3fU2mOCqQXxVzxqUPRca1OMGKUKoq5Co/aJY9ScAMyQHIwdne6BbittncotFW/RaSpmwQR0lNil6Hg + eJVU6WuUVh5nVaRs6q9G161w8jvdsblUsDctAIhfiK6D9IVe2IXWVFAO+ACE27xKkAESkFnr5mto656w + +mbwWVcpMIZsGwUxIIOJAn6RN2pQtTBSwQCWdwUc4EH/T1Q/x/d0hijBdeed6RXA8msEJpVZ10e9F7qx + sbp6WcluFcBFWWAoo2MWySJq3oszpLbAAGoFjxgBiOVvsWiNEFiZWqZ5C7Cu1rrB4bQDQtMTZxq92YO/ + z9qBFmoSFMC8Amxgx/goS0qdfRIZgMKUWeABh3WNujl8J7dlrVhCbkM3E6DBQrxj6mnEH7hrILxzvRh2 + B0RaXpsE+oZMRUeidHQrYykVLiABWIADTfSAYey3xVelNOa+fmoCKzADUJzGSLCzhmqEICxxsQt2QBY4 + LQBdtpsEkHmyS4tn/4psROMAYuIBV0A9quZHubV+hAi4rVxe8tNNdQzJnukyQxiY/8qJbhiaRmP0YZFq + BTF0ZDdyLnjocUtrIGWBNfELBdDWTzX2ouhKfC66iiFks80MyeipFB7csfznoxsWWj5aEixgl1VwiiwA + FVi8MzhZGZ8kLvUZzOM7ASkAWcMXzdUMy8areWLoQ9ocBdRTImTUv4d3fbu8i+65Qy4wAarZBGeYFxXp + VL7jXxVSVjLglVawATPAqat0m1r2R3IZ0or2gEx5rP/MBBogG2xshK/qnkL1wY4rrVr6yE3gmftWwItZ + qXf0O+LxH39s0k+QkldmWzNazeLJt0jNcju4fCc9BQsnUTy6bkJbiVF9QHABoUxwuKj0w7nbdop5bFWx + E2nayf9HQCPpp1IdSaXihW2fKm2/RdbqgQHRkgE3kAFyDddxEEaE05durE4Z2z0fjEB2xQIxkM1OQJtT + sR26Z3s7/VQn0gAVANROIEC6RD/96NEgvVjTJsu0NLl8gAEZkC3aogPxcgM3UMvQcAMboAM74AH6EgMw + 8AIeIDAa0NB1kAHcbEA/q0AjzL+YfHPm2AIV4M9VsEfqrFrJaCzUyRMR0EOobWYWJq752NY4CJKkCzrK + hzh/sAE7MAEyMAMM5zcP0DEf02nccC0dQDEyUAEp0wIakxIT8AI6YNt0cAO4aFTv+Zc193W7/EuuQ4Ix + gNVM4JnpTDRZwpP1tmeBImyS7QT/HMACnxtC7cubWitI1ZaDmyMoAi4HGcABMGABETA5JlACCTB6qRE+ + IZMNGsABrr3eGFMTKwMzD6AxHiMBHqADGw4HHRSmytl18XW2GutTeIUFG6CegLIcxjhEXEIbPMGuNN0E + HaCimndQ2lTlPVyZK8dKCwABnn0HMQEDKGMiI2QCCYAAJIAAJRCIrwIBFhADO5DjyGAyFsMUD1DnLfAA + LXDneJ4xTJExFSABOYDXaXADMJCLESWa1od/9/p1GfXkTTCckFEZPDOKwsMTUmLYT9AB+zazOSiz43XU + HxmlCoXGb4ADA1SbbKMACUDmCZAAaR43b3M/6woDX6kMYCQB/zMA45F753nO67yu6yvz5zlA32+gAzVy + ZPjtWeZWhL8Wx5R0TmPE1FBrUk3RIYn9zmMTGZZegh3w3EawA04EXn2bd2MMy9PtZfcjJmSSBzbAARMA + PyaAAPJeAvTu6q/e6vY+7wlAUzQZDYxhMXgOM79e5wSP5wYPMzCjMR+D43lwhsQZUf1nyUKWxB6oQzfR + AhKb0R4glYiFKYqdx4ktGM/pAaTuBDugAm4jfP8kY6wIy4XsYLNYdXA+6Nz8QYRWAmhe767O6vgeN/RO + 76PXADLQ4MVQFzOwMnqu5wbP60yR9AaP53fOAjLgAUTvNFfCgcx+aUvMes2VRt+D8VyA2/9SycI5wzi3 + kWTdzgUnn0WTmcjny7Arn6AnIH+RjQf0y0ds4+qrTuaszvNxs/c93/MOQAEl/wtgpHUmkecE7/R23vhP + f+dIL/USgOPePgY6cPRpGORu6Iv0appjJIYZfwXtPgEVIBJHBigFlSh25d5/bt5b4AEoT7XAJ8a4SXCH + LEIfIuhiULHVA+84T+Ikvvd8v+rEz/d/T+Y4jwBaJM/IABsxkOu7/vQp0/R07t523vRQr+caQwEToDV1 + QOATyoaFg075B4f31+jOmAMvEBKtgxOI9So+oRVUX/lKsAModY8K+ukxKoH/BgSn00Jl4fCQSeWS2XQ+ + nZndLOJgKEz/Ca02y91mwYkueMxoxDBQ9Zrddr/h8TVu8mi17I98i6V/sPD67ATx/PAgEPFkXjZs5B7b + OGIeIlIqXSIiXCwvMzFTXDA/N0M9K08tXWQ2INcyOF5gKCz6+GYoYDw4MlrVOiBQUBhOGBiEi4VPUJSL + h5OfkZGThxlUWDwce7WTbDZgHhwUSkhKEkqyzrfUy9W92k1MShRccrbt7/HzkWxyKFogCgXcI5APHoN2 + 7iC8A9CCjAm6buiDZGOHhRQNQHUSlSljqUyaNnIsZSnVgxgaJCrBcEPDhhw5OOTYgCNDtpQ8OIBbQI3Z + MmM/fwpbJvRYT2fCTDCIMCHizTcYdEyw/xBhxYksCMqF4ZJODBl4YeB1NYdVhQQcTtGmlajhhYwHAAvl + kSuXjx5AeurS1Wshxg6UatlsoLDpVGGRozRmNDUqRWMXLWZIaAqYcpINFVKs8HksGjNnR5uB/lxMCIoH + OipDwdChQoMTYr5oSXeOK21z7XDLToAgwYprvFIHF95Eyqw7AQnVUp4cb609AzFBYEHhhQ4NaYZz8zCj + RSWSpDR97DQe1PfwHCOY5IA9O9oMEliooGZMmVGgwUgLDf2MGIMFKWIArr0MomIhBQbGwWqrsGCLDTYy + uvpKQtlKMGOGI9rLsDIcYJhhLrzsqisvu/4YUa+BEmJhhgr6+qs9b/9mIIwTTEQCyRMaNxrpk4sisMAs + DdPigIIIhumpqCOb8YyZ+jhzJgIZUBuwAwogUGEBq24rhytz0EFHN9m65PK2L9g5IQUPgEwTLQ7cOiiv + N50bJK6CDAHRj+cgeEwGD85qj58JIEBFI8Y+QQ8VGkmKoIEIKuiAPTX1seGFFq6oL79j9FMS06CSEcK3 + HQQU7oYdMBOHHXXCGsOLVMESCywwaithgRggrTWfDmYA6E6DlKNLEDmTK0i5g/DKUzpcOsDh0dQyeOGB + xm4cLyRRNprRO+9ciKFPW/XZYIYr92sGmp809cyYZYRQgYLJgsPBAwoekK8ErLJ68MFzuohN1Xz/9Y1Q + jHkZkGFZbgl+6gULdOX1j0EMIUTEXne9E0SDEnrAAhb9ym4DGSAgydqMQEa0E8VqfMCDgQvuxYYJUghG + iPxGGyrJJi1lZgEXOsiOTaqwHCPfVn0OM6x0vGpwS3NIQGGGbVNueo0bJLDgsebmIrbqX/e4qzlh7TyO + oRg80MCmypqtoGOMPqZRPFDUvsRj6WBgxel7dkZBAWLwW5Izc5lE5gQF/HOBAhcp62a7A+MpgZ19V+Wi + C3x/ZvBnfxmc94QHMJxb8yY0gAFhgIK9ExBCFnZT4kCqPl0hiyvIhQN2AbvhYBUcWBTHjzo6z0bcG1Ch + hQnk3nwbDlgI5+7+/8TldDSY7TbhhAhiqCc1bxC2QoExUW1w1Vd9bjBVLlXdCuAWOqhB+POR4FBqgerk + 1X3UH67rrocHci4gPGaIwbrgboChY489oZiQJao8JIGADDKHvl54ABg84YlPRlOzaRjDAasIjpCIZI6j + ee9BQHNHvvC1ju81Lh4IOAEEXjA2BTpNfXDZWh9gKLrSSax9zAlRnCaGiAfkrzrKqswGYoCwxiRqFIgR + 1BBd8AAKgGqF2pBdfOz2Ms7IzChL8lQEZhAlwOAgKhZhgAkQQA5UzeZ7QGPcV7a3L63QxoQueEGompgy + DrFAhyZy0/zygEeuTWx+WGOYIY7zh4vBYBc/hP+BgTByqI+orTzXikALKKADlMURDhnwQPGIIcWhBAM/ + 0qDG3VIgA+kBxhstcIAQsKCbEZbxX1rh4Bn7Za+hIUABKIQjJbmlgahNrY9woloeS0Q6+rWPYTG031tc + AIEZwEAHt3TKBibQh1BsYohD9I41k9kCvuQMl9qwgQem4oCdFCk0PBEC3hyggghQIIFoscGUgIGAAygo + VVwRGgldpUZZ6jN84zjhDibZzTR17nPI4eMfRQTMEb0JmL2UE4p0aAFc7KARsdOBBODlggZslKMY8ehG + U9CCCkhgfwL1Jg5eUAEXOKB58MCCAmBqgpeiIAUs6AvTnplSCDQABSVU3Dv/thDCVtmLgw4Skyzv9TgT + nsakBfsmHROS0BhOrGFZQ4gN+1jVDxHzD7go5BbfhbBCGVETD1hE8JrqzQ7IoAUpWAAKdsJJucI1BT5C + K1pKWZXKgZB7rnTcKyOkxseNgWhhGAcDWHDXtKqJVFPr2nNGB0wS/TKhBiXWMBW2EIC0Tgc+VMsNOOAB + GMSAAjMwrQVWVAEZxGAC1SHcYlUGixjMABCBmhEEWDeBDrz2Ju4azALG8lMPDheNw83eKtEYQqIqDgUV + cCZsM6SDCgTCsjBkn/sQUqfUdS2y2p0fxQoxg9W+YD1kw0EOdLADD3hABxzAwQ0CCl2VbUAHHpgAaVvb + /4ENiI0yONjllbBwKqIad3IEvqdQHedKfq1gAvKtFTRZgENfxqW7kfUlw9z3K8vScFcLeUAFJqADFarF + Bhm4wQ1G7GCJZOC8L4FvZbrhv3BoCalaCd+riuq9wnaQlZFrpfMi8AIVq8mSMgBEVKk2p/glGcP2w1qG + m5xZFOHvITmA3ZCx7B4OdMgFKxCHBrUHywJvz1UIzrGrGme0EpygCKPM8osk4CHQ/bFhfqRz6SDWyzjN + iTlxoSH+qIPTNw/6HjfYDk+vhwUb2/iVREvzYPnV41eucWgJWMADJENoPwnpH35WWNb2iN1daS2YWuUz + k910h8ewYKSvi6+mYa0G0P9GMxzyxMqN/9o9sRA1qBOClWH5iSoQykMFMVBsrCnTv+wWwsILq6qJHvpk + rUk5q6de6Fv8IN4JUPTVyPb2DabU1islrl6Mi6Wkf61gNH/PngtaUBZOqEVvB2etFjgRhoEVsVBXe9TP + nnazHwref0BgpDno9rwJ7V8LyAc25f5gmkO4JTNKDqnvoDir9sVmGVwZ4WopDgtCQadh1pCyfR6Wkz90 + bTr7GRHJZIEMYLDbjiPc0Bw75bwUlIBU6ktoxe3eUB9N5ovzGh3zUkAKIjlz4VBEagnbc74xe8zrcpeq + zyGR1UReMdTq7+BKX6xgqHKFMAkYQjyusb3wZeazM9r/g1sxxwIq4GavU6ZztD1oQhH62MlGPeAQe85C + n2yIRFggxF2fezdxEIMUvEZxyv01+FqJT7T7msxETyo+Gy8GFDiABfI+PN09EESA6Irqme0VnezUZH+b + /u563IOuJBq2z6uYA61hAJgFvM8OAnbRvP+ro3u+7niAGQXrLO/sU4MBDkzAQ1hHvVZRfXKC4PCGVk25 + MAcinRdwHPm45MC32NFu7R0XnzYGPmAhn+4xi/BuC1gK97vvzhzY18idph/XoByiOxv0hQLRcIkQCuX+ + 4ZFkYAfgL/7QR7pSAIwUx5Vo4/HOz4z8xfd8rWi+orCKLgEYwAFcgAV+BAGFIwNy/0ACzCbkKobk8O3a + LuzU8m6Y7sKGKOYxJAqgQJCScKAC5IMBByypIIRf2u3GevDs3AGohkZxEMAEiiBuarA9UKq0/o/ZoC/g + ImZ0kKO6KsvJLivl8mBwlnCFMOAFFhBMsmcMj8sr2o7RKq7sxASEbkMBUGAFQqkDUqwLC2cDOgAGZECs + HsN07qhh8E/aotAPuqvfAO9+RGoH5pAOCUb5ZGAB5mUCwSQeCMu4xjAIgc3c0IxLyoEESMCEVECJ/MLw + FDElMGAD2gKq+LDa7OwKr/DvQs2qqvDJAoGQEnEUIQWIIABBxgTHjIZB0oxygE17hAoNf/BfFEcBOO8F + eMsWh/8DBzpgAirA7pDMz/jo0/ZuYbBmEK3v/qQOIS5GAo6NGSHFA0zJVBzkaMxvaMpOsL6guB4NLGzj + HIaAA2WgAw5QHFMDtEiwtlxIWKCtsrQQu45J9Qiy+qKqAnYAHwuGAlTgNcRw8o5qx9yx7Xbt4TCRaOZF + HlYAAmAgB55LIYcDA0ZwFqquGrtLfvzRuoQJBvdM6o4pT1hAyECyVm7AAhBES9SQwMZPlopxBzsIchou + C2AKBT4x02ayVjSgvmKgAo4sqmAw70rv6gIwj+wI+/AiiWBAFI8Sr1qAAR9n97xAuWqMjIIx3XKN1zJP + Af6DBXTrHrdyOGyAA/aRYk6v5ED/BOCsBupQDfpi8AEmYBnfMjh2IALAKBOLBihXSfeC5sd2DR0jTwxW + wCQ2QCsDkzIwAAd2IAZkwO4Shsmq8XRUco9M7eRgcSEgaTIrMzuaZQFvrddEiF+EzSLXbQclBI1uAx42 + D4v4JDVTxgacUSryJInkB99A09M0bCW3K/Uo7B+UiANqkTdvQgMmoAG80h0cTV8eMCgfbjsnJ3vYyARu + ZhFw4DmhU0MyoAOCiDmtLsoCsBXloiVfqD2lyaxErDxTI/GokzfUUTu1UwLZTjFxzB1PYAV+x+Ds02lK + cQdkgbam0S65sepMD36mbeVwC0o+8kD1oR8cYDfkYfwmcSc5/wgjYRM3wgfM1DIFTCJZMHRzbiAqPCSb + PC0F/SgvtFHfjvO6cCuS3HJFt6EfVKA69wnBLpDd0C3t4AH4io4EEqD42OlCedRW4lIC8rAWAmmGiAkg + QY3UtMsKK7SZnhQt6CA/r1MiP+gSHaRLVEUsG/BuNrAFoudLz2cl5o8CqNSFDoo4feVqng/1mI05I4k8 + 4RQSoIY1JVIndw/dHjJN58UEaMoCmGlHA9VWnHG2sgsAJ4w0qzLvTs9+kkhbIjUlvolQcU0nuxM2gbKo + ykEBVgB6ju9T0adFQy8PFeKO2OfZVG/6OEzVHgAGINVV4YADIEABlNTy1M3A3BFMtKQBGf9gBVwgMuTO + V8+nG3bAOBBhzkyNOCGGRvGMVrGSMqFVDTSABRSgNR9vqH7m/Maon35qzULJA1DzW+MoKTuEFo6MySyM + dKyUD/kSAiwATeAVH2RgBYLKJ9dNSCUvIp1nWbOlVf+1iTBAAzrgBei0BWD0VvdSG6mw2fiAL9qpYVtB + AiLAbnBSDPeTYCURHtEhjBLgBBpgOnbTYwXKXSYhT/TiOItJL0SzCi2GAl4WZntBB2bgQITLMNGNVcKy + coxOBRASMH12hTRgByZgM2nh7/qsIO+UYvj1BQStaePAklgABYa2X1plgyCt6JKCKCFJkri2qVYCFibW + saAy+gBP8Jr/FRHXthduYAIWAAF44/IccCJ3TDaUtBp8xMruFrZk1kNwFlOxMd+2ptMoIBwP1w06wAV2 + LnARkxJtDAUawALsdnJhKylDjymPY263RnVE5A4a4nNBVw5uIAaIZBwWB3xKtOIyb0B7RH8AtXW90BRJ + d+AuCyD7cADdlGF5Fw46JwUSoBOzooyCcVVutwi09niHTANGlxZKt0FTjWIGgQLkkHohQQMYEkvWNTdm + A/dkKjfr0UnBt5u64Q6ny1jgAsmWbeA2i5DYt32fIAdgwAWAqxPpZWS9pPHC6AgdoAX2xLP0d8g2IGo6 + zeouy34iY2sX2A2aJRe9pNcwcAzU8hqY/7aCYWsDdkACNLMCpjZ7/4AFUIsCYkACVBSEIcGSuEOjqkLR + gksMiGEFGiCJvPeDYRi2WOwOKcCE7c1YUOsWYICievWHn+AV2kInliFBzsE/UHSJKoqJNe0VRni0SqsC + WAQGJIC8fBiL3SAuPecfUoClFqB2QqrgyNjbTEwDcAAHXGIDWMLE3hgfboC+OkC9JAAGXqAD2suO87iQ + DfmQETmRFXmRGbmRHfmRITmSJXmSKbmSLfmSMTmTNXmTObmTPfmTQTmURXmUSbmUTfmUUTmVVXmVWbmV + XfmVYTmWZXmWaRmE0+CWeQCXdTmXeXmXfbmXgfmXhbmXMcBbOy4DWv+CAzpgmZm5mZ35maE5mqV5mqV5 + B3RAB2SCv2r5CewwFmSVGjksnMV5nMmZnBNiBiZAAihqd73tfWMhalVLBuR5num5nu35nvE5n/XZnlWL + AtJ5B9zLmE9Z+aRCo26PbxE6oRV6oRm6oR36oSG6QtRpOjogf2OtG0KLi2eAXlU4wuj1oz06pDt6pEGa + pEW6pFH6pENavBwiiTngOraZB17Bc1wgBxHAAESgAERgp3m6p336p4E6qIV6qIG6AAxASXHXpmTO6xI0 + aimAAmQgGk1ro1HLAqz6qrE6q7V6q7m6q70aq1dkRWTgqf15Byi4lTunBRZApsaCBEbgreE6ruX/eq7p + uq7t+q7x+gA4cU2V4k1nTgQ9YEpRKxq92ItTK6wJG7EVO7EZe7Edu7Eh+7HD+og3WkVuSqA7OQcmIAIU + YAREYAQO4ABGgBNJQK9J+7RRO7VVe7VZu7VPW546MbQ5MbTfGqdLoAEQCLO76WF1QGI3+rTCWrINO6oX + m7CjkbiHe7gPG7mN+7GP+7mDe0Wq2qpBDCJe2dAwgwFIAKdFG7Rlu7Rhe55CW57EO7bLG7bRW6/JO7bZ + O73Z+7zVW7b1er5FW7QNAKdJQAFa9gNjzRRJy7QMu7ARu7k3k7nFK7kPfLkTO6qbO8ChezOVG8IbfMAZ + 2yEyhpUxQAJcAAWW/7e0Q/vDTTu8Z3vES9vDR1y+6dvETRzFV9y057vEv/u0XRzEZbtCAGSMocsUS2uw + D/vBBZzBExzIidvAmdvBC9zHD7ywGbywH3zAo9uq88cAWZmBTqC0DQC0VZzGYXzFS3zLXZzEv9zLwfzE + xZy+tXy+R3sErvwATCAFJoCdTQrcmA/Ag5uxjzvJmVy1njvPvXjJh1y18JzJl/zOIVy8Ah3IHTyxARx/ + U3k1LGBvvdu0uxy1w1zGKd3SSby9X3zM45u0v9y9J32263sEEIABWoB1scyMkdvJA7zHo3uqG7vOYZ3O + FVvW6xyyDTu6I3vAVxgcdTuSgfZHRdvTLX3T3f8bvsd7vo+dvFP8vY9d2Tu90ovd09+6NyyAm7LMG6Ka + xx3c1VudwQc9rP88yYP8zpW726E715O71RP9sAE80E55ZRpged/6yze9xNdbtvPd3rv8wzMd379bvi89 + xSWdywu+30FbVtYlyygiD4E7stPd1WV9wRW70Ce8sQt91aFb13c91vOnY0N5A8R1zQte0kM8xkW95EP9 + 4Nc7vKUdvOOb5V9cxGE8vT/cAEoAAjxPvnRpoy9euO083fcc4p3b0BGcwJG+wY1b6GmrAjzAojHZAyKA + BD6b2Emc2UUd5om9vLVexGcc05E9y5k92knb5lXcrT/bAWAAzr1w+WiB1eH/nuKlmt2NvsftnNwtXrj1 + HuPpvLl9HhxLeWMcgOoFvt9RvuwD3rwB/sXJ3uoZn8tPvOQ3nfEP3sWvfAEsYOe/7gVma7CTXsGNnslZ + HeLNncIjHt0T/OjrXvQFXN2TeIkn2QYkABi2G8uhnb21/t6bPeslfb23PLxBHeBxX/E9neZh3N4N4ACe + JwZgP04vaoglHuN/XtyZXu7hvuj5nu6Vvu8BPLEvpoUlV5M1QAYcAIxG+/aNPeBhW/i33NN33+XHPPc9 + nPIR/+q/G9Q/fEkf4FmbCggynlilMpsZi0YZsllEPpMzmbS6lFKd0yTXif02s+ArlImUTXS8NbvtfsPj + //I5vW6/4/P6PV+fe5wgkBwcDBoeEhaSLBYWIjQukjwOOlYyEi5OMm5CKkZONmIqJnIiUkoqpHT0sbby + acCMQWlVzTJxkd12iW3V7trOdllN2S7RTnnYuC4zNzs/Qy/rREyOQCJqKj6GRh5sD34jep6Cj0dKNoZ7 + Wn6yV3oirHhE07NqTDR56VM98Ub5+tpHS1hAXMFkETTi5EWGeg4fQowYsYOKESPOGep0iNylUefMwROF + rtM2byLXleME6pTJjNYIoXghcSYcHDGO6ApjTGGtW2Gg9NxCTNhQKfqUaMnpLxjTJxYsSLhBcyrVqlZ5 + 7HBgwEA6SJrQpQybrVtKk//aNI4ki7JlyE0f3W60hkLC1ZkaYjztqbfowaRChwFO2u9vsWM5gZE5YoEF + DKl1H0OOzMfDghAiNH4NZ8pj2bGaMbkFLbarOI7bvlpSZJEBXcn1bFo4YvCfF4KFozQ1mBP3Up9gdv/F + AnTGYhgNXSNPnnzHggIFRnw7OeosWI9ozcLdbOizWrLYQGNa2XGEAQUwlEOzKfsY7vaGbRdcv/e3zoLx + lVR5GhU9//5Ud6xgwGUiYaSdadeIx1lLoGTjEYPrTBIhKSiplAh5J5zn3zL3EIfUL7z55Z5vueAnlD/C + /cMTX4Hxos8RHhynoYwzOkPRAdZQQlJqX7H0TlvtTFf/SkuXwIWdKOaAFVYiNx4wF42sZABDFrL1A9Bw + 7nmIolFiEHUFlik2BdQuSJWxAwZPopmmHhxEUMI14lyzzpBFZlSOaNSxM5qdb72lo1oXkVCCA/OomYcQ + FGAZJojuAbOUhwMRM2WV+QRVC2HGyCZDDDqcWainn7axAQsnlLBRJig96NU7pwq53Zsl1Unkm2x9g9p3 + oZRwQgRqgFoHBjrAQAGVl+40lLFZnMiUGVYUq9tPj4LJBC+7VRBbDC9s0Ku2hWpAwQoKkIAjN2XFKutZ + o4xFjkYgzXmIOt2gG1Io1piwAAs5bEvHBkNUm1twX+z04VFVAtwLe7whxKylFcDQ/4Fj+UKsYQYvuIAC + AjgmyaOtSIrG45wSqpWuJuqAYl2d1lmjQAMyaBBxHL/CQNxRKxpLFLV9CeWiiCVqGeJwwypkQQXYulx0 + fzhQ4MABIkAHHjfggUwIakemdTJmoJVMZFiseobSCEwzwEIHnRrdhgYSyNxzs7bxoyzNg7XHKME6rViw + byzIAGPZeyPnQQoIPJddd9G5KgqPB5qatdbxtkogW+oe8JwDjfHdhg07yBDbzPA9u/DMjl7q9jC+sbf5 + EZtWnvpjODygAFdOq8oRvN1t/fTJrG6tGckKklMyeQi4wKvqPGwggUL7jOHle3ADxnykxdgc7aS0dZh3 + y8NjT/8TBhOkYEK4OEooWoXeMbLSkJY0SN2eGa11cvqMWFPCAixnnwGwwsrS2/LrTavzlz/56z7HcMK1 + ckC27CHwITmogAoUcCNTACl87upKvEjztKmVwlXdeFd1cMck+T1gBwnMQAfwoTkV6WV0zkrR9KDXueQN + Z1pBkQ0MOBCjBOKQHr+awQLctCROPA1CE5IVn/qUkXSdixIcJBycDEACBkDgBcpIIA48IKyneEEGbSNd + QAaWD2Tloj5/kRaJDJaQ9QiNAjt4WA7bGA0PuOAE4TIAoDRTIOy0AyMWPM04ujaSHxnoLI8gD71SMIEp + 4jAHQ5iSFkonQBR6kWfwmeTBhnX/hgnsAAdu3GQ0bCABFywgATla0g/XxT5TSueUpaSaKk9itVKSIAEM + SEEMrpdDDGigAy+4IguOQKVHli6Yx3MkMSGlIuIILQYeyAEbOenMZdzAAxVIAQNIYIACMG0cqLzdNtHi + HZO5snGjtIiAnHiCBrDgBbZ0YwZysMunxAaY9xFg2+RJTDD60loeyNYz++kMHEzABa5j2ksMlyeOgeyb + RzSZ4Mi3IOvcSAQiSEAKKCA8Z2JgAzuYAAUooMV++VJmIR0pSUtq0pOiFKVJkEFHKdAwTfozpsyARQsW + oAATJEAQg9gKOelIR4sQkis+JSR5DkBHowIVqUMF6k/JGVSg/xb1p1LFWAJMoAAGRCAGHJApD2ywAR3s + AAYTMAI8WQDPs6I1rWpdK1vbytZeVoACMZDADnSggQNyNa97sB8MLOCCFTBAlAYIgXMkis3DHlYEzkks + YxeL2MIyVrGKhaxkETvZyy72MiVQwAoiwIIYOEyvXd1ABzwAgxjwI0sHKQIVUluB1r42tq6FLT9SS1vZ + 4ra2Ln3BDjiAA7yKNrh4sAEHJuBXBzDAewhYLnOXW4LmIuC50GXuc6Xr3Ok217rT1W50oZurzj6AAqEV + bldxsAEOdKADda1retnbAR2oF77pfS973Tvf9MIXrPC173vv69//4ncH7+XABjSASPIi+P8OGMBBB047 + Axa0oAUPkLCEH2DhC0/YwhXesIYz7GEOYzjEIu7whzNsAZdmErgJXjGLs4eBTp3pxcrAwIx58GIbrwHG + OI6xjXmM4xkD2cZBvjGRfdziIyM5yUpeMpOb7OQnQznKUp4ylats5StjOcta3jKXu+zlL4M5zGIeM5nL + bOYzoznNal4zm9vs5jfDOc5ynjOd62znO+M5z3reM5/77Oc/AzrQgh40oQtt6EOjh8YZuIEGcIADDdwg + AzZQMaLzsOD2DkGuMHiBB3bAzEq7WAMc2IEHJPCCCcQABp1Obw5uCOo7aMADM4iAChyAAgVEVwEoWEAD + HpAGSr86Xxj/aGcHJBADj1IAi3KNwQQ8oAMcHDjYcdDADmLQAgfg9BEhAAEBBpQAFKRgBjCwq7QjRuxS + Byu1vnwtS+dKVxuW+w03kAALUrCAQNxIQAUIAWGziQBZdtYC6ox3rzSggwkwciDQqoAymyntG8AgBQn4 + WmJFcE3DYhPjTFOAC2DAT4KjCZc5CCtZRWqUdSsmnsrcALAL/SsZOCABBiAAzfm978Jec7H8rrkBTIDO + CcAb5DIy+AvE2jb5JOQJXqhhywedAx4a9eaOlSjVq37YfkOHsy2AwTqFrhyDS+CKaVNUI3HTSwng69Ub + kMECZt5viQqI6uXEZtytTgDCjoABLojB/wai7fXHZECjxs6cSBUOJtrAUwY1BDUOLLAAEojg7nCv+sUr + D3e66xybB0jAAlxQAQ84/O9UuYEOws7CwwNtZkiIJ+UQTZkRJFbfc7f45GlvcbpXXbIiKAEKWiABv4te + Il4ttrDgaszNBYxMLGABBT5e6A3MIAHczmzuK4/7AsT94rTPOQFAUIAnQgC0XQ++Q7zqAVQzsksB7MVe + LCCDHYwf0HeJAAn4XVm6a1+x+pY77i+e8X1bXCydkwXsgKuRHzQQVyxgES5YifPshaQwzHgNmgREgANJ + Hf9dXt3NXvbh3vYZFs01ie/F3wG6QuAR32KEVAPSDOjQBmt5HKFhQP8FMAB5FJZh1Z7c3d7kYR8O5p9i + hQDNicATpQBUGBAJLkM7hZVHycf6iUiItGDQyMBFAdoNtAAC9Nv/5eA1aV//deD+lVMOWpY3mIADzEAH + GKAR3oENiNoulVxg/A8Leo5CsMDnERoHNIAIgIBlTJ728WEW2p4W7iAY1t0H8hsJ9F4anCEaxoFX7cCp + ZUE8DQyz1AznjEkTxIbeCFpWGID35eAeZpzl8SHmXZ4HWlzcSZ0TKcACRIAMrIIi0gEGcECwoJBBUEol + qZ/NaMEcDlygRUmAcOJl5V8o3mD2kaIWYuD9Bc4CWMDYuCIcqGHpXREW0c1sNEqY9A8+SYHQcJ3/oK0d + CgxWKVKe7fmhMQIi5WHfJ1Zc1e3c96FA+HUATDUjBigSwkkK2SHdv/xEsthHh3hc09nZAjFA5GFhzo3i + 9eXeHg7i7YniQuLcRZxTBUghCbbTqSETE+pCCwqGolAiDeUA8OUZLFrACUSeZRDkKM6eBxqjDc6dMNqg + DWLTD3aboBBgIgrdDXCAaY3VXjDhPQbMahFTEWhj3wHar4TkJh6k5WUcSu4gOWKeMDJl3TmHzRkA7zWA + wMGj12XUCxBe8/QFl9yG8gQEPoERT/RjoHHADJzAzC3kH96eF6KjH4bjMCZlQmbWVKoABaSd0BmcFT3Y + ArLNPmIki9SNMcEA/w7UQKDlgAwEJAHMZRZ2oWNWX1MWY1tS5hf6YPdNlApYwAS0Wrnhkg6cGmpVSzzF + VgxNo9rgIxkkCm7w41X62V0sJknWoPVRJlta5h9K5jmKo1Ji3HMggK5BwAS45qEFXrWZASR2EbTUBvL5 + zHwYi9C8QOjtmQ28wAqMAGPqHgfiZm2OoyjyYGNq50FOFvYlwMpwgEdOIWm9ABEoBnOeiGo2SrGQUST5 + iy76453Z4SYmZRd6ZyjSpkmypVJaXlv+392FwAjIj+d5wHD+GYOdFpfYEyS54UYizHKSVQWI0KDhgAvU + n3fqJjFqJygG6En+J2Ty334yTQnMknAK2oKdH/9Z9dIAzVNP6uPxfYhRdAHQEVoGWMBAUVYfemHtEWNt + 9uFjDmk59aBh/WAIHIAJVNQ73iecEZ0stuf/xEfNNOexiBFY0qKmwF+hcY8JwN7/veX2SaY49qGZrmQG + ZuAnKiVhhQBXbJYKsACL6hm15eQvuaE1mpFqVqJqoQgxUQDRFJoOVMAKHID9ieIXDqiQfuhuRmYwLqpk + zR4WGtYBqAzf3RkucYAjLkZsCE3qLVxwGNOfCsQTLqcZpAF69pkNdMADJAAAuuUo8maa6t85bkUnmqlt + BmIPmuKSNukQwkBHztkNNJhHQWhuSKJXUk9y/qQtUso2HhoGwIA31mUHeuD/Y9qmHy4lSu6qBropbdZg + IXDeA0jACKIZIxrXA5AmtMaNLU4KsxqMuiFL6GTKr1XaH5zA0hDWXAYipHKrBjoqbaYpiDYmKe7bD4oA + x2mVm+WSp5rVEtJGPQXQatJn2VkoAD3FBJjhq3lAC5hACAwAdgajYwIio1amtgopkUpmiDKWzZHAGEIA + Xq7ZBqxnPWJki8ANqRqDtHRlfdiNALlfAQYbBrxABBwAJ+Lcv/pfOO4gtnrityalicreUvInpULHClSA + 85GZTb5T2kiowhAGcDCrQoxILT7K2R4nElBAGkinoWWABECAHI3nMZKjrqLp0/LfgFqmwYbnkF7d3bEj + /wuYSZlFk2jaaOdACsX6BOnUUxkBRMGEAdpFqdNBHb9dYX8u6ga2bKOao8sOow5apmOhYgoQipj9CgVE + bBfRZ3zU6DwJROPmQ6bM1Xl6HQewQA9Z09QBaCByocAa6a56K6/KHoBS3c2VwAO0IpglYAWs7pVUUr32 + ZJeA5ZZ+5Syk3Byqmm8FXw7AwANg28zlIWT9Ld6KaCfqZq9aKrj2Lg/6IJMyQAiFWSwiiowq3E46oLKW + TtnmBBZx7G+RYA7EQASYgNRFlvD2bSeeb94KKFxuq65qngKwwNta2cQsC4Xek6k6yoS+jSVOgUtJgA5Q + sNBtwPeuAKl8jc35q+3hav+4Wm1KbiCAiijBdqcIMKkKZCiXZZTxkOZsqJt8+ulPRmigpk2zfVo84sAL + WIAKyFz3Sd4M8+p2Cu92DmL54qYpUl2cnoAMcC2W4UC1ua4Kwa6XVCI2ajCZxJWqoSsa3kMK7OvcpaPu + 7a0Mu+/Jbh/fFqO/6lsBdBsCNAAFMCiVkVAsAM3alJ0KkgnZNeG7mu21PBtNyhmNVe5MSdNflcA19eth + reTUHqknem7BLuoK4yZhHcAJQMDyerEEpN+ecmnojAgMmWoQv5YyAXBVSPIk55XBzRex0oT9VIADXPLN + 0R6KxjBkFqwC3+qaIjCtFhYJrECGZNkG3IToxCdPBLH/V3IR2WVzSGnKBNBVLc/Ei92AeXEAgRkYi4nc + CUbYHE7ACzwyLvfB2lWM92ByXRoWo36otpYsDHNyZRkzGBaACVTAlukAXrQrUozlafYFVzru9R5nXigT + B9xVOIsaqb3AC0iAWMHApnlAp+nABkAyJ51NBbSACiwAA5wATlWVApzAAjhACrSAeLFqM9iA91rACpQA + Hwuu5hovKHIhMnfr3Zbj6CoWASTvCD9ZBySb6SDyIfPp3MhyXyhTEc4EI4omfkiSDEjAO+bVBnBPNfFx + HtIczYEAt8UpAjgACySDRGBAB/xyCXxNzr2lwEZt3tK1FZfsMW4bCbjAVmFZBuzA/1IHqiSWsXMCKvQa + BUSrWg5MNFt/1Xo67/KZVS+VFQoqXgcIZT/FmgU0gJgSgACAdmiLNmh/AAEgAAq4gExHxK/EAPiSymBJ + 3kAa5E9XMWX26j+f7EISwAE0QOFemRAsy5Vg9T3KK3zC4bAcRmxQwDIh9TNQ27F91Oph7C+l2g50cQ5p + QAU8Huxt2wB8wAB4Nwh893iHt2UgaAr83kxE0ww4QP1NX0HWsZuS4ojqc/XhJs2NgApIEZbF2lbCrvS+ + hzVqiXG/Vttm0kxDww1U22JUCwOSyJYM6hoPD9IsgAh4N3gPQFlr+IaXdYaDgHcLwAAgAHo3dzNwQAV0 + 9k7Vrf/+6SrnEmzLnik+3+AP5ve58rcVnRDdNG7YdjA1DkYj+ZJLdcAR04SCj5VZISfyJF0BwTPEPN3j + iTd5azhZU7mGg/cHfIAAhABaT0BIP4PNzprFiC9hbWHKVvGkDrNctjiB/uABOMAESHiTRVNwA6rCtND0 + sAj1nMGg2m5V6ECyQaKMNvUMSMB1q44NUAADFAC3gfeUb3j3cVukE0CGT3qHhwAOj94OOF4J2PBsemcd + s+kDKzOJFmh+t14FY067CjiOHgslQm4WtTOU2nIOTMDymZEQ04IFPIAMRGcCQZwDiECWe3iHO/GkU7qV + d7iHDwBolwAE+HY4c4AMXJsD+SD/9W1yqIsum+4zbe/bbqvAWl+Zq5pBDMFnvAamE+KML2m1XTU5M3BA + 2I1dF2Tk6BRxx2aPBKRATmN5sZc1pHN4pY9spHMblg/AwraAX09FO8ntvi5pDeomC+8hi/tq/+EgZLZ5 + CuTwlSl1XiTuMPxs9UZuu4WwlzuEBmilxfJ4Qq8UZ2YP6yTADw67wBM7o/t7v3c4shcAA8TAVdjAx6KA + mxyvfJu5Ma9p8cJw0IMACUAAwl8ZB+AF/xi2qPJsYUyJWWm1pzW2VfyKcf2Suy60FgwtyeeLB6hAAXy3 + pH84o6e92n94o6s9pXv3ByAABBj6aucAvTUAWAtu1J45fVPx/+9K1g8iQAuIPZN5tcRWLxnF8qDLzLjF + eUR8sbAsNCMHJqZA5+NvS7ecwGcfu8zT/LE7ccBPubJ/gAgsQAwE8kzggAS0wAz2a0tyoK3KcD9DcFQm + wEBr2dlE97mn7YObiLyXgVxJQNA9BukZT7zbaBmLSeP3Od9ggAdAQAkse2lHesBX+vWPfr8H/MgauwAU + wIind11EEws4AK5BHh87fFziMxaTOjhmljNPwJb9iirn+J4mtBljL3FYPSaBNBDwhENi0XhEJoucyazi + dD4r05ksCpVWo1nrzBvzbJRjctl8RuIqixFIMACBCHL6nF6H2+f2+ABeSHgQQyMsw8DxqP9IOTkgGCAI + KRAxkKykFJmUxDSYxNS85OwsKAg5YHjoKFRdZW11JbvRicGSoqKSseWqrXqyqsCd+pXQyXg1FsqQmLHA + umre9c26ypqSmdDBONbe5ulISRAB+XiMc4yTI7+7m8t7NAcZ+BBZgOFmvYGBYMTclOQEzfQvU6dQBQBm + CiEigQsYN+w9hBhRCQ5lzJz1gjKN2jMqzH7FeNEhRzGJhDjAsMCC1rSVtqDg4uhlCgUPNkrywGDDRoYb + PDPYvPligYEQ8PygQ/cOqZ48SM/1+QDCxIMcN81o8DAjwoIEB0ZB+hR209hQBsryo0TKAAoKOKy+hevK + hgcKMWu57LX/i4oXLxYsWNuBI1tcMojqWqCGEaYvLcEa520WBQZJiDc26OjgQQIMCRJ2iNzgMCIME0Ud + wSmXGs9qpnXQxQNxYIWMQYSRxKKQwsSIAmAvDew0kJLAspo0kWiQyvZy5kk2eIhRAfHLjRj1XpdBYcIL + HRqaJ7mxIwbMXSxzNQPGEtgTLxO8P8yQo8OLCbhSqqxAAUbIDZS5UUDADzhQM6e1ddJ5x0BxBijgABUk + +O6IGyRoYQETSBhBBOMI8qfDfoLLZBQDSlhABqAiRNE2DDaQoAIWLNKFl7u0sKILL6x5IQcNTkxxCIoY + q069K4CMibEv3tsmFs0miIGCJ1Lyywlr/yaAYQcOkNRGhhEEEKAPdZZK6ik9XHOtwARmwDLFDJhgQQUF + iOptFH7m1BBED7+KzQEZquqxz7g4iAFGvLigbostJgjMzyJs6IACj2RCTyPIHMtrUif8aosbrMb7Za+M + tgAmhh3SfIUCAwSISsx1nCLTkQSXGvADAQxIYQdFh9iAggYS4ETOgAwyCK1gO6QkEhNmqO1WZR+KZQIK + iIQmyBv18yAH0ZQ95AUXI2PPJcaikSlIaVLK9Jj4xFtGJb6iSG+ZGV6cQdQceHRFhlO7hKdAVvcA85w9 + CCwHDlkJYKACPm/dYII2GSjhAA0jkbOSgYyLJIQRSjgBlWU3hmjFF/+is0hKSKXpC9Mc6b1VA/Gk26K6 + StXT65koXiz3FRx2kKDJLDySdt0KYvAs2VYoIAHVAVkrs6kw9S0QtQG6JGG2wZTNYAcZUniTAK0h1nAU + iUnRmgARSmiAgoM5Rnubm5l8Vga32ZPJbbfbBsMttDHooD6SW5LZuiL3tiAGu125ga4naZlxvV08omCH + a4cuAR7J+4V1NcpXdeQDAgpAIAIO0E7YhRMQwFCgrj8xy4AREDCh7MHThv2YG+R7AQYK2paOmbm180yH + 0GC/QVtJZSZv0mh5QZwvGEgtJAMdJmDZvJcT68iJGDjwb5UJTPgXYNaaaorp758CoQAUIEQbkRn/IEgB + BRMQyBDs8kUYgYQSGFABghleEDp2/1+5AQc8AAMmsSc7MZiAZ3CAso1hIAfQ45Zd+laons3EA9krhA04 + IIEuBIk8yPugNGQgAQ4wEA0SQAFvBJQvMCnlQOpwVTpUMw4EtAAbaTtEIrbyPt5E4mIKQEEDWCCBef3P + iNvIgAZywAEd7MADT+yADjjwO//lsHjmaYml8BIpW8gABjdsRQ5yJi5vxWyLP5NA/wihg2+EIyoEIgfA + /tUvfvlrNVwSAQos8DnYYUAHMKhAC1zQABWsYAUNgMAD4tWBxx3RkdrIiQ2mdkRERCeLfDPeGafXl58l + qhUYsFq3MNm3xNBC/wY7MKEZcGCBBRzAKAFLjQspZw5y1JGW4yjFAijwPxtoYANLxEwUc7ABHGRgko9E + ZjK1ASgzYhFafAEXkQzlBBhw4JiFoIi7ZpSL67xkJe5a3idfAIHIvUFyrfnXq1roL6XxwQ8jSAHzlDlP + etaTEBlIxKNilp70xIibGmnMiyTwOlX4MVD4IZ4Ei1eewJWwFRmgAAMWxE59tcOWL2QHOuUgqxAs4AWp + tGdIRWpPB8JAm34rZeIAah1LMaMmn7yZo/Q5JG9NUDF8aRxBC7EDFRQgKrJ0FQxRczmNBqxLJmBBB645 + UqY29ZExFWUIUUo94hFKGhTQgVx0wMGRYRIahv+6CxdIiEE0aOABJAjBacgUsDmmM5ZLY6E5NLeWGZzN + qXfFa9rw6aSVsnRIjRnleaQAmEYWQgP0EWxKAbtFGz1pCtuRpxkwAIMGIIAAH9AcXMlnIH4ppWkBQ80I + 6JFX0pZWWTkI1CWp2sxvYXEKzKCJTgvxQKn+9Ra3sG0wNjJCu2KTAiswQDzQWUs+BPWzdewXamjIArKa + 1rnPtUoGGgWvZxIJSNPbJ2Ss11tVcKAuLeObVLt5o8Rc7xUcaAEJxCFUWB53VUsLHwu5ZAAVvAC698Wv + RBzIQZ7587ZCoikFd0GBF0QWDTr4rmKnOsF+imwGWDUGBU5QgAG1lZ1hunD/UFlFB6cJIAQKgIBy8jti + EreiknVZrctASCl/PsOLWTVGB2TwIt0K+HiLcW1fZCDiVnDABQkowCuLu9ZyjKlyWmNVPAYQAgOcAE0l + hnKUDdGoQYVLgtIQ4d+sR4xjyDhKLT7eP/27jArwmBUZmEAKSKDkWD4ivq+Sob7s6GZ/jSACMJZynvUs + hMNiWYswAy+Lo/UEFlSgwNrQwbbM2EwVL5QvfzEzK3AQgxMQwJxHMXIM3YqHMQX1KOjo0gImANI9l9q0 + zpuAoJD339bu1qaf+lmkW6EDGXyZRq7mJxlXghg8vyIHERjBp2vZ3s22472f9dLTBoAAF0iA1KaGtlNP + /3IYK+N20JCJplW7lR0ibiPR+NHkqqUnIwouY8fasIEFFCACtZYJc6opKtPagVkRgJi70cZ3UzPwsRCK + +4yvTrEX9IM9b9dan7jtt6tXy0lZs+IFLjCBTzML3wMxJdPtVAccEsKAeuTb43dFrSgVbJfETrODL4qB + Dgrrim+TUrHR+GrM/tJrAKZ5S+aUc7y9l/O3sgMOJGCBGj8+9GSGx1HfJNRirPrq9VzKAuHkBq39Ii6A + tkuwMoM0N25QgQRwaahtVRodhw2rdwyIQQ5wD9HVrsxYtIhnVe1mwrHtknW9NOoumo61A6ttcrMn69zw + AApC4LTJXfy47Qwf4bWGWf8CmMAFH1175I/IBJiAF6wZYTSDrwoDobPc4OEt494p+Pdt5KAFJmD3ODi9 + +ooTO+fCBoEBFCAIydcedhoAZH//HHOFYpHMw3i2KlpOqYusVPR+rwDNjYEBCUSgNKofqlPATnZiS47w + 8JiHfW2//WV5NyUi50tKqb7oZvxlVBCROoxWHXqlx6hGOzu3PTIQAwecKh0IYm9xd97mNkelBBboPO4T + QNsonBigLjBbuquDOVHCghgIQJZTNOLDNuPzK7ojPW4wPRKAPvFxt1ZpL2OLPiUbARVIuwE0QeZwHtup + NgZLHsXIro0gsJU7hvQrpW+5utsKM3NruAhjgCA7msL/M7Z1kjcOeyslA4QI0L4TVEK42IAXeJsWhDtv + qrH28yYpIaKl6jKW2T0W7LfF0sGI4AAWWDfh6gO1Qjw72DljS6f4KoASmAEZXMI4RLdGebvE2iabmsJO + wbxraK4ZjMCSKyMyaqkyi4i5iAAEWBBaOidYYqukwLh96YN4MIAGUD45tERjwAFtUaQcE0TAwjFKIQ/E + eAHZ2gYvCy/0qKnz8Ddzq0RtgCjBU72nqLCkYcRM6zk3kxUQYIAY6MNL9EU0kK4mALeEsjYDCjTH+ESZ + aBwsRLQ/vC4vBJeXg78dnMEIIAEf9AM+OLJ36zQEURrhIgES7MVfJMck8CMYqLyq/0PA8viFQmk66+m2 + kjBFljIe10LGmPlCicgAGWildjsNObscR8So1IANhbizckTIM8CKflK4GiQvKdRDhryRHGHGZgS3vXjG + BURF47tA9GOBCUOVZMOcNxtCniPCzUGBCUjIlRyDHDApTtyny7NDdvE7ClAqq5jHLXSMG7k1YsxH/dKB + CBCBkNRGImSvL7k46RMQBGCBe2PJhDQMWxMz8QOhAMMFHOsCqLuJ4VOtjZTAcvtJibCBCigBWspGN7uo + 1zu8D4wDWRGBFaiAB3zKS9SAvPm8f+M7qlK6x2AXmgi+GKs1mqy6vls4mYu/oGADdvASO9Kw1uM594qH + EEAAFf/ouLlkScpjwBr8s9rCQYz4gni0Cq5ksUAbJUfzu8MsiRx4AAUItg28A2+MIRhiS3cyCkhAAAiA + Q8uUQ3wKzLijwHpMMZhAjGr6S8DsL0/sqtF8Rr/pyIgApdOztK9TQxaCt9aDJe8RhwJYAA/QTYTcr/Bb + QcYSMIgkN8ZQCQ/ITXvgymzTuwpciQ9qTud8AQewNOhbFfwru9n0Hos6Kgtoxe5UQsMYmblbMbBqsQ8K + IRn4T4jIyZ5ERRVzwXFBzZswKxJAQ9fwxqXpxg6cIzcYgBFwAIMBULoUjw6qtsSpx6ZrupeJAjAwsIeg + NXgZlM3UTL6JT+ecgBU4gKIQts7/iiO2LDa2giM/kMwHGVFL3IBZQAzWCitWq5RNkgYwkEt7mMdvuiKH + HDkXmdCbyAELSCHY6FDPcqHOEjsMLYf/O1I57AC820ldqCnFqUriAxdqcijCkDEa48T1uzLiu1GJ6IAW + SICJ4qwW0rR1QrxziAd4mtI0JTrelMqUej85nULq2AgneIH0RL/Pu672HDRngoI+lYgYYAAzfK+xC7vH + rE54cEu0w1RG/TgNQseZSoxIvbVA/K9BuQbmGL6YrDEP+iv4JETb4ABrxMY3e7danE4NoyUBKICp2IGK + dNWPq0u9kVUo5CdeqBFKvSnEiIEOeNGISL9fZccCXdG+0zFq/4yI+XMAV4pFZDu8i3rNCzMKzQnHGGjV + aI02FrEkPBRM5UTG8awCDyDF0FQ0UvI3JpXCsIyLDZiBHiTKY8uwiNWssoMDA0CqRcVXU3seMHNHsHo/ + Sp2gBwOj5aDBK5NJfj1NdPXTFBiBWGxEtDxD6hNIRdQaEnABPsrYtQOl62g0hFNObaWGEcJYGGXTcauu + 5EHQjthSuEi3iNtGgOxQjNpPpZjEBc1ZaJsLqQS9JwVZxfEbKUGU4oTRu4xTIblSTxQlxFBZiYABFUCA + wVuhIbOc6YNY/SuAFVjbq9UzG5AAdfkvpLVVc6XV3Gmcby2JXe1ae1yxsPpUBf2ODagA4P9StrfaRg/k + wKZ5GhBYAFvR20Z9ganT06WD09pqMC9QCRgYWLgI11sNxPGkOlC1ii5FAFmZOKR5ITpixNd8AxTgzs4d + Ogx4AW16UBlJugmsvJSyu+9Y04MzWCiNFPhcWsLYARTwKSHbv05LVTJtGlRhAM71XY+bCzILXXErVxw8 + 2V+ophTZ1Rv8zfLcIti1ChwgJ2xsM+yFK+M6Mj8YBxTw3u/FN1Dqzd2qBaysBsKUmSpAFMO9iQYl3cH8 + tw9igeiNCwygvxKAW3jDuARJwy+Z1xDAW//9OCrjWXE9WEDrAgsgsNSNi12Npvfk2lazQAle2N8yAMyy + o/t0r9jcg4z/+rQDSAGcBeFoOwm3IcZefeGEdQwWSDlohYsqDTf2feJLkeE/OSvhSjxbvF0LMzsQUAiq + COJ8q6RkbLBI7SLdEpenU+EVdsYSZqxOheApjosJOAG4vb6BHLI7lkUCOIASUeAvzi9Y1UIWyzUkxryL + kIEl7hMnJl5gULqrdFI9Vdjv0AEIQD0PLTLbJVOkqKVH4CjHS14/NjVECMyO7ZRMKlC96NY+JlhwQ9DG + SMa5u8dPTb4+yQAYOERLrrD9g1lNJh8/YFYGoIChBeX7wptZYBfwWsBHZiz+URQnroZJpUI4xa53geO4 + uAEZoN52rV/V4GY54uQPGMH+HWZTe6C9//BZSX1SlBJZJiYMxLUuboJSPfxXtW1mYDuKe1ZKy32NHwQB + BHiAex3n/FIZS2rSnqRCB/0FAlPlt2BgS7nWziRlQqvmCZYBBiAK2Kg+iwtCRPWDBlkB9AnoaBPQvCNe + AnXkGGbmW1nPJy2ejyUPRybexs3bP7GAExABxsM0TpPOMHEzVAFRGUjjkC4xl0yJcms/uqMGZoABp4yQ + nPzKXDNjEQo9XjutB0DEN9hpL0kQH42HLlEAGVhoocavDuCUhlwwLvAia1oW0WwZqPam97uiN55p6U0B + BOgNo3gzOeIwAmlDCBBmscavNfkYdwmXvGBkLViXB3uBOlUWBl4s9//LLvcls7mOi2QQHRGIh3GIL6cQ + ECUbhxFAARYQZ8DOVyfECyMp7MTgPLRZXxVNZycNhr2UaMq20xYoAR90WX7+tHMSAQaoK9L+3efYjHQE + z8ROaBjwAMZeliq1wfJ0xydWWtomDA+oEBPwCrweB8xSNs0WGxIwAQfYI+BWOxvAgQ5QQb9A7/RGby/a + ASpi7QiU7HY87Fz7WLqLYOkmDKyoABW4bVnhkv8G8C6x2AY4pXEUb1OLBfpoErmRm2eJAZDwVnZOEadO + 0WIkX/O1AqqGnRyQgQhgzYIYhYSQhNVBAReYgKA+cFPDAF9iog7YASfygM+Qog3Ykf9h66NuGSP/duv0 + oOfYaUIKeAAXSAFDIvIVcIAU0B8Y8NYUH8CcuIGe+Alkauh7zNYuKFeszIj7PqJD0AEPeIHNkIAXSG6A + ZvIyRwIWHjMzrtUmxQj4baCd6AkJN/M5RwJFHuRrVdGqhDkys1o69/O7Gr5+8tqY3vFeNd2J/vNEt6c7 + DVl1TnOREc5gVfRJx6s1xdN/jWskrlHp0HJK9/SmQrBHGdAA+8ot9AvH/fRUDynvKuwG07WHjmm+MC9V + p/V5oi1di2U2dtPH+uta9/U+0QAJeJZ4fsjR3CcbyY5R/PVlN6KqQUfwTFohaeNPrQIlJ3Nmx/bviMol + 5Vh17rcMf7AwkPNs/yf35bABBKMug2VI8euIwNEBsS33eI8LHGiCt3voTkxHv5uAXpf3ftdHJ7yUQi65 + hCPfT/b3g/+OaQu/0FNAxdIPpkb4iLeKWFDB3uv2uBkGA5f4jYeIunQSW8PW2I7qvVmksOb4k7cZD8h3 + 26IRSH+0/BBYlJf5uMiBAeIrzOtMuKkF7Ujpmfd5CtWBFzgMdTlgxihqmlC5n1f6m7CBJjRRXBe4URz3 + pad6VSjvzXCWUPTbA0qgDkDxqgf7VVjxLs8ZmGAB/LCG3qnxsGd7iGh6DsAZGBiP29kOKxGMtsd759wJ + DfAlYtKAG4D3vBf8wSf8wjf8w0f8xFf8xWf8xmR3/MeH/MiX/Mmn/Mq3/MvH/MzX/M3n/M73/M8H/dAX + /dEn/dI3/dNH/dRX/dVn/dZ3/deH/diX/dmn/dq3/dvH/dzX/d3n/d73/d8H/uAX/uEn/uI3/uNH/uRX + /uVn/uZ3/CAAACH5BAkFADwALAAAAADyAfIBAAb/QJ5wSCwaj8ikcslsOp/QqHRKrVqv2Kx2y+16v+Cw + eEwum8/otHrNbrvf8Lh8Tq/b7/i8fs/v+/+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6Ch + oqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd + 3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/wADChxIsKDBgwgTKuyGIQOODTk46NDBgQOO + GxkwLNzIKIOOFxMqWHjQAsIDCzImvNCRgaPLQhly7IhRgQWEFCkaqGgQoQWL/woxPORo+bIoH48SRNp0 + EQFngwY4XUDwaaECDA42jGq1c6ODjJtQmTaNMJYs2ZwpIMhgubXtGwwcXsho0cDBTqhmXTDF6VSFihQt + KLzIodGt4TMZOlBg0aIpTsdlm4pNAbmnBQodsh7eLIbDXMiUz0ZgSnpsaKc81XLgzLoLhhwTHjgNLda0 + WBeUH5/F2wLGhtbAsWyAMQN3XrMpSks2y3y0YwgzXuAITl2KDQ8WIETASxa3cufdl9fO3aLCjsLV0y/Z + IMMFVMq3mScPP39y6dwuKGhQzx8Jhg4W6FSWd6MlR1p9yOmFXFNPsaBDfxASgYMEdKkQXoK11Vagghcy + qP/CAx7cECGEiVHQwmMIckjgfAbmBZ+BULUQAwdEjZheDjBkF9lyZ9323Ybx8QWBVdPZmB4HJu4V3l73 + aUjgePeN9oAMqxlZ3Q7FnXVaacqx2GSLpnVnwQ5WVveCbFs6x2R9XXK5YG5kPfBCmdRJ4B5PaSLYHHh7 + sugYTi3MSSdwE7jgQFTMffckfBsaaB9ZUEEgwaCE3vkmlN2B2SKmfzbgwqSUsiZBBH+pOZ94eo72aIun + 6vRpqKwVWmqiqi7pYny1ysdgBKDCehgMEBzqHH49Fnsqj8exmIIKr/qqTEM3aCCtBhloJkihT5nqI48q + amvcZLv2CggGD0VUUQ4biOj/LB4OcbCDBy+8IAEMEsT7Qgc6pAvIqKU6SRufG/YYZIFNMSvuHhls0AFI + FMggQwUPOzwBDB7ooIG167pB7g4wPGzBxyxYELLIM1QwwQ4boLeHrKHZBvCBtx1bn7I8HZyHBjsshhtf + T/EFnwUT6IBxxmrE5IEMFrTQgl4QSMX0VC2gJAFbfNj5lIIEZsokn25+l5vBR+UgFwQNrLDA2WinvcAK + DTwQww44qEx0GXDBQEFND5AEAdRKlwT1AyzMQMEEHdSIBwwuzHqcd25m2qOXPObE6x7DzfDAdiqs4MAK + nHfuuQOHmlTBC/vNbQYHMbBAktJ5k9R63i28zjoLMmSm/wewwiqpJ+SbNi4ZZa7aTMcNMLSgAuiabw76 + 8swjn7wKFnhguOlfJDZB0ntP5brrsXMPe/YsEF76HfwymjW3aiZI63g5NXtHDhKwULbZnIN+vF3226+5 + 5y7M4MH41OtCBl4wA9WtLnYI9B4CGQM7koRMBi9Qlx0Ql62tNQ5y59vaqZblvjrgYAJkO17ymLcCEZrQ + LiJcHmAkMLQAZoEDFWCK9hrowBr6ZHs+QeBUzNPCOJSPPo8Cj3Ji1qbc8AQGd8hA8Ta3v+M5EX9QTOHy + 6reABrCgA3JzoRU2IIEZNK1v3oOdARt4QzJCJ2g9fIPVeKIhrsmMiPJhH9jqkIEdWP8gBfUj4eYyhzwT + 3i9/ysuP7bR4BQ10kTEm6V4Cb7jIMXZPdbEL3ARyYIcfimZFQ9TWrbbGoA7KAUA5UR4g/1hC+92vlMnj + 3E7yQ0lCWkEHc1ld3iCJQ0fSEnAL5J7/pgeHHyroWJhEn3guBLw5zkEDMYjA/kRZwibij497fGYJ/6iC + FgjPlU7IgAe8mMju1bKBBszh9l7nwEnWgYJsjFwmOcQmZNEsAkicw38qoIIFMO+P+EPl/fwyRX46bwUR + 0A82pYCBDUzAJt37G+vEyL0xAk6BDJTB/+jAMiAOS0nqEyYnOXhNNuQgBi1wwNqYmbmSArKZ+julP6t4 + xTQOFAn/N9iBDB6gPUWS8Za0FOcNwxm7qrzApWoYVQX3lCwLqi85G3SKJ92gxAfML5X+LGU/nwjFKHJu + ASpgQQx+81InwKYCssShGCPZyNYxsoZ525sMihSHil7SQEj1XYosWrCltiEHFjjl8lTaz6rapZQmZSZP + ZoDFrjLhP0gLqw0diktHNnaWC1Ra/wobB9zBh5O+A1JGN7ireMLBBnbKI0pJqdc9SjWafVTeX6zJS8MW + AQMvSNo3barTnDLGtuTcmwVgQJi2Jq5lnE1UOzVbK2UZU2NeUSZW8WlSwI4StX/Fp+aYNQEJuvYINogt + AhcZRm9685Zl1KnSWEABD7DVDUL1/xTM0se4YuUqYKKRXEfR4Bm66FGq+DXhCE27T2lurgEysO51iwDa + WiryljZ04HdzydBZyoBMcHBrn3DFpQ22yTHHZQMGJlChET6RtB+Wpj+pSdoKAHDARLgBh/+mQHAy0rbe + bCj3lAY0Aa/BssOSDDuDyKnIhQsOOJhB2VKrT9Setpn45K80OWeB86J4CDeggF5oGN7bvhitY4UkAxeo + Vg5kMQ1u3WiufmlU0mw0w0XbAQQWgAJR+rXI0Y1i/kg5RXs2+clGuEEMvjhLs9pynApGaxnHuTQI7Jar + bUjvRY/jXlwZazw/boMNkku/qiJ5r6nlazQvHU2szuDEeM4Ah/9d8E0tUxnLNEy1eFFCOjeEGVVmRhZx + MYUTNKPhozeBbojzm88Q75G0pgWwjZ+cAQkQGsFVDnQOtXzlnDqQAlViA441NLMgPanRv4s0GzogG9I6 + M3/TTG0fnXtPD6dAoHgmgg1k6mfI4nbQsnOsjLkHnR0AdQwSviyjs2ZUgsnRrmZApjKV97zoOlfT5D4h + NKerAghUN91F4MAECpjsGjJQwVZ+t6nL2DQW+CbR21Evwbg1V3+ByzjyZUMd83q2vt7TyPykqpKhO90U + sMAD93YtF2XAmEcKmrFU/nMk4720B4zOyWeQ8DDP97t+r7eu8xUDLBM3UubC+ciZlnN/Ndf/ALU8COJE + 8MhiFBrOstfWz4Pe8sVjZxLaUTYN02Z0ijZFTE6apmZrULF7mEjk/s45mlQ97ab9wjkrwgDUEJ8QTWP8 + 0AQvNsZnv6n3JoBoNIQZP9TmkDpjne3grUEHeRUtpk8IZ+mOWKpPNFsDKtBKsBfhBSyQiuvU/nNyLtv2 + ym7gVGrX2jEomsfw3XxzOMtRNWhgifacrpL9zlckA1vhmWOACijQe4h3wIsHdneDIx9Z1fF0xkqbAW/V + 8GrwMEpgHWq6BtsXdS9ocwbK9DAKX45afwLymX2Uotlc4FnXE4GLlrNQg1ZxZ5VqDWVTadVTE4B0YxB3 + /3JtbUR3EQh1/2kAeqSCPKa1V/pEek5UZOSWTw7gKRUQbf43BK+RI6zDXYSGZWR1W5BFRgoUNRCWdL8F + RLtTZqLxaI6Bd4gxASmQfOIWZ+Dmd4D3d0emOSlgHtUHdnBhIjWFcbV3YN51cdvjgqvTE4eHBunVYzpm + fnBUYZNha2GwARWwAgwQbiTUfHQmcwTXX83lAHIybCXIA0pkE4CWYOLEguDlgrSFSBCAGUvYBRWlKO/F + XseyWdpGBobUAmYzRfO3T4HnF3zlR/2EXyVUAZU3h0XgFSzQczIGbwm2caIoOw00AzPyZV/ggE13K6uo + NV74NQDnfgRkKM50WtCUf1NVhEKIgSEoKf+amAQaIBfZkUt9OHRnl31mJWgOZBWI9wWvdoj8ZohkxidO + MTllgAPtoRMfGFgdqGmYVn/8ZTYNJwOt94uvBT/ZYRKlBoPttn0WN2+xQwHlKAZbuD7DdIhgwk4EU3xl + oAMPQH/OhVJoWIlt2FenZDYpQFg5V4IYAEslAUYwWGXhFWgMxWCwszRjspBYMIiRASZj5pEYskGe0n5Z + gEw/yHBVFWJqiH9RFVX4szaBopEliAMwEE7vmGwFOIAPNZHGCAHhIzRkgGMXpXkW9ortBS6eNwaGxHIF + Z2RB+GH49Y0wZxczQILmeAT/sRirg1PehXY2mYfwqHYzIAGZ6Iw1GET/mpQhtgIlsEiSV4AlEXBPqSeJ + UMRpvMaBGFhCaTEBzXiVQ4ADL1ABDzlWksd4PodL2ydvP/ECqLgFv9cc3gGNhyhc7MODYSBwC2d/zXNw + 98dcvwZu9gQBM+KXTGBQS2OYBsSHVLhsV4aHtmVOYsCRcSVEAbNecDWNFCh1QmZPdKk/j2h6yjd4AclH + K4ACK2ABX0eaSnAdM8BdZ5VArtmOrRlZU0EBOyCHWiCUdmcfUMJ5Eyg5/ecFBhUsa0NNHphpc0mEo/dX + C5ACMRCIyskDqLOHaFV2yoiT9mlWUwE0b+cFHLkkmMeKy3Eq6yeGJQl7eFRw2zh44JhScSZ/NjeD//GZ + BDfgAVppmPNGQ3+WjISpNz0FAwyoBY9JLHqRIRJYd28ykmEAeqGEksA2f73Gi9w4Yky0AinwAJQ3oUww + IemYhz5XW2UVaFR4gH1TAcnpnzW4aFwImUtnXLF4BcVGi0FoafpFVZrmRL2JgfmBFTrKBDpQHKTWeClo + k60zigN4cQ5VEmMZolgQdyjqipHJdMRnmVzQkDJwkp15aUR4ZC2JQnXxV8rTAh7QpU2gARSweGMKUYoK + ncS4ZWBUEuQVImY5Kyg3RPnYOFmzQQZqBbDhVC1nkCmpfCoFYs3DRCKUhPNIqFgpU50ogPZ5plV4au14 + kT6BGV9Qj3Z3g5vVLf93Z41cAFp00Tk0Z572N5AlBWzTpEouYAEspKpMoAEWqlgqOHuztXF46D0mAQMy + +QT/yV600iH4uCL8yAUbMAOjOqXbiHrkdnAr5QDhU5bOegQ8ujfjxYKq9qr5+ZyrIxUyAK9XoJ3EUm1w + KkQeaUS+ugVqxmYwanBzia7numlTxDbkGK9OcH0CWJgZJ6uN2mJ6Ax0TxQX/2U4E+kbDBF/jqgU5QAF4 + ZE8uB6owOpzUNErJ4wKMSbFNgAMxUEDdNaTJWHGz1V0+8TbYOQWKRptduJa0maudRa4HlQIiJaoMyqDh + JnhKhnp/YQFWabP+0QExkDQpaHsZR4CvyqFslzf/MzABWWsFsol+jtNoXrIqJ4sFHsACFzhCBcdPtqhr + Ubt1SMgCEjC0WgtlHlABfIN2pLiCrXmRMeg6/sMF2nm06AeG4Aou7LcFGZBMy2SXAHmsDoqlDypCMJmj + gXuzMEBTsmRLV7ZT8MZg0BlOLhAY/joFIauWtEaI01hrTwoFDWkBDtBm0jV/qId/U/qUgKo5Izi6ToAB + 2+Sc+Op4YYRbQPsA/sOmUTAqwpI+2TZrtzKZu3GwVoA6UgqoVFql60m+vilKFsKXyOsEqBOAPTu2GZqh + FllG5GVvWYAtnuIyQ6SWtekioNF1brkETVVaKQSzVkWcfueB0xUBV7S+2cS1/8NIjBxquN23lS/Ik1oV + u1AgAWSTJnHUMsE0FhY0GTcqKFfAAQHycuEmRff1YeZLcyhgRX/rwE5wA7ElFdBJkbc3qxhckQ1kHo35 + BGeSG//ircI0ZrrTMjeHBUoEAfVzQllnUr62nruYOWzmntRLw0WgA4LpqmCbZTvpWBvKSDRGllgAICfn + XsViohpEjZIxAxI6BfO0sp/5ZnUZWL7Ja+K7OQsAAYOqxU7AowdEmLTHjhK8sQnlkxLVl+yrM/q7dGuM + LCQswg8AbVfwUXRRnmnImR8YXVYao6p0KKwHyE5gAxJnOTWVn4VMv/VJiuHVPTNwpFMwIc1ZFnP1tmzL + nf9a0gLRkcVLgAEUAoKQCIIL+oEotZ4lFAEPBp+kLARiF1bGOKRDJ6SNNM04hJE/ZQU2oAMg9R6axy0Z + gilsCRhoZAXY2AAsS2S4yIFTS4nk20SBwsjNXAQ3ED8zBI/3SaY4KVZs1wKiWwX1/AA7QZltFHy1G3LW + JM+/DCC9G5y9Znpvpp5Uy8cNMAMaPM9GwG4HuHYw9k3U2oJk9JDWqdBLgMJoUbJAQrJGvCwpgLVXMBwh + 9cTiq1dsiMfg2I3h5gITEMQ2ohEY8NM8nQcA6Inxhmp9BqR91m7bZXTjZ84cVhnq4yaakqlCEgMknQTX + EUNPm3Un1Y1UesfiVnguYKT/gZAB0VIuOXARGZAR4WADGhARHbAD8uIB+MIBG6ABQT0HNoAjI5HKnxi2 + Y4S6UKhINGad23oEOyCYjnFB4SzC/kIZ5XEeVkA8dFs/vDZaUNxExfqwypOQkuoHONABEnA3I9FTFBAD + MIAy33ADHOABMDABE4A0EEMBgyMBKMPMcjBpXVzUHp19G2uvCyR+V50EgBlDpyEeMUOZWkMZQ9JqWyQD + dft3Rvh8VkeJefwpgDsHGcABMEC4CYoCCnACKGAhLqBVFqMNGqAwrh0DDeMxgVMBEJMSqU0R2R0HH+SJ + ZCytGruaXwlelXzRNxs/28EXbaIXxJKiycECzs2pLLAs/3nZXDErvHbrmQ7KNiyQtnSUAx6QsyfSuyjA + ACdgAgrAAMZpFwwsAzDQAfWNDOTSARPQMPAd4zMw4xUwAxEjAw1D2x4A4HAAWxfqwweImKg2kYTJdtDB + 40zQqSiH0sbyOwSOo6k6BRzwj+KWwCq1gXFGnGG9Su+5B9DaHsfDZijw4SBe5h+OAmzGdQqO28VQUBs+ + AyRjATNO4yVT53MuMhYQFDlw2GowHGD1unsIqy+mk/hcEv0T5QSlAyFBUygCGkuOIj9jFRguBTpAnso3 + 4Q+9ueKbcPUz1nFcB69BQBGwAAoQ3ifAAKhe5qle5qUe3g5gAREUDdYTAzIw53Qu4/8xDt8lI+c2HgMS + IBQrvgZ7PWrqKFZBbuyR9VBWuDqGhuhToAEu3uB24TMBS8Q6YXPiswUd4AKa/Ii76KB1bGmAJ467xC46 + kCPusQAncAKmXuanTuIkfurrbur2pNNILgxI8t65Xuc1juv8LuMlg+Id4MuShh0PmZNG3WBWyLoG1DSj + vAV7XZPEZMuOHSeTlNdPsO2f6tWVSKxJluXShAIpsIDsktijjgLrjupkDu8oD+Iov/LvTuIoEAEkzwwF + JQE8FzI0rus8z+82XuO1/jBwXjIT4AEccDF3kO+PasFqt8NEToAP8LoPT64SQOt9jWE7kRwmIecUIAHO + XgUaj1X/+IflLwxYUclpH+IBGI8GOJMjo37qpf7uZ77qYz7mqv7h687uK9Ab994LXEQTH1My/e7zQF/4 + +17jgl8BFAADKzHcZxCMeJPDMUaffy1oL0YBBE9QChPbNuEUIRgBihw0G8DnTcABMV2Q6vnxl+2GXOcC + /QrqXiEbHo7q7y7eqU7mc6/yLg/vZQ5QO60M2lTrt/7vxN/zg8/zcv7eKR43HtRFi/fXU9hgQ75lDpTn + jh8FBfURLw7nVZESKzH6YYDCf4qSwgnhMEqjRrYAEVABgxQH5DK3Pxji4Q3vMW/78q7qd7/7qT7iLQAE + Od6QWDQekUnlktl0PqFRHmYDq1hm/5VshTvLfsFa8Xfs9VZkE8luk5G+pToZxNV6tFj3/F3/6Nvx+AL9 + BPFmJG7gojBsbjQ2IHFwMmwUozZmIlRUHFYcOD9DRR1IVTxXOE9BU01RFlpe3CxnjzA4rCAaFhhOFBR4 + UXiBGRiCUYyLk4GDiU8YTE4iYDRoq62vsZludGLMtMLGxMLJyMS3sigkdCqzZzUmWiDs+PwC9wLt8gDv + WQDv7CxQiNWOIC0c8DR5CoWqEyiGpjg53ESqU0NSC1awEFLwDQYdFFysKMbMGTFiKE6QbNYM5TCVwJyp + mLGDHUebN216lCDjCrlw5rpokTFj6LhvXliwsCADRoccsnA2wf+wQ0YeCPX89OOjT19WrA/6dW0xtgIM + DlHRLrGxo4KLTgpXkUIFiiJFunMXzoUAA2paJBlySGi7QEGCEyWDpWS2GFljZSmTHeN1YkEEChv9Ztbc + RMMLCuKM+jTHE2i5Lt5kUIihLtFmIxo8yPhXL6yeQWDx7KOH74E8GTtau/abA96KBRZRPZTLymLDVMgb + tKBwVviQDBwmPEg4WZgzyN5hshQ2DDJ5ZQwWQNhRnb1r4li+Bf1SdFzRc0Lxn+EyxgKLGRM6oKa9KiyQ + Z54DsfKnD0Jq+yeeBybArD2cbPCAhbfioquUUCIqha5NUlmhgQrWYS+DDuZYADyWJDtpJGX/kInMxWVm + 9O6EBiSYUEe0OIjBAix4KmeLn3yaT7T4wOhvKRh2yCE41zDoYAYI5AHrK94W1I1BQK5CZMeoNpBBF4oY + UqVM5pobZYU1XZCgps000GECC0LqZUVmxBsmmfLKc8mkPUkywQEKMPjSUII+gu++ReszKqij9hNSKBnS + kICDJzXDIQatxkLQn09p+6OfeWbQ4dCbbJCghU0U2rBDhsic6JSGPFGhARaoc63HVVeI8aSS9FTMJD5b + RAlPYyBTSdAZMD3V2TdOHIrRIuUDDRz9HB0yCwsqSEcHDQrdLEoKLIhHQd4GyW0PBu+4SoYXmn32mhwo + gECFBTBiTjmL/z4UZU0RH5Cgr7QwwKGDeh1gwBfEki2mYZIcw1NYY/UMVoEVLJBQ3o2duGEHcvUjarRH + ySFK22ol9QlICiZ4QQccws0sWhfqCPXcBQvhg2YWJBCQ43Y4mCGFYlSpKNZP5mJlVlf2wmEzHGJjIYVe + JwN2JRnzDJaxP41ZbE9eTMgo15/JTgI2+0ILLcggkcyvNJTlkyEGDzZ4M60MXii30z8Eucc2sfy4rGyC + dnjAlLpgTbzDuCoSMQanNauihQYULslyihOD2DGTIB4285VS+q6XBVjowO7BB4cN5EhJFsrI1rtgewy2 + zyHtnDME0qENzTSwojcD6RE1y7H8+K9E1P+xwTsTBzBqdXGjS5lVRAhkGDuqGzjY6QEHUFAAmhVdRIxG + zx2mmMUZTzq2mbBZoAn59zWgCovX87Od9SLpe93kbEGjlGU2YoaWztDJBVX6Sh8ARzwWwCAHAXxfNWwg + pan9i0MRAdFEQoQKCMRAYzjZQN7cQrU7/QpiwnLJ52AEKJeUh2KHUcACLNABBz6QYx5bHdyKJCnXwQ0o + +CHSN/ozAwp4IAenuwkOBPMjB3WKeEwkHhYoYBYatmMqFYBAChrQAFOcYk2Nq8gmUuACCHXQJjbADgsa + 0AsFWO0wKWzY+Th3nu9sTmt/OoEJSNeBGkyxbGuR1uxEZppA5o92brv/jyFjJ6QfzSAGMPAAB3wWFRvk + YAcTqEALCkgzKtFhkwWEAAsEcik+UhEHH5NaJ46BEVXiq3kNgIAFJrCDgdlEdZjknp3AA6wRkk88c5wY + L00oscSEzQLWG6W8DgYfH6asdcys3bRmd79HiWFuG5ihTbbhOwRZqR4tsMDcIHfMdthATnTCoqsumIII + PKAsZOSIBiTAgnsN6092RMYcXyQj9V0tmH3SU0t6sYIKhFOc8urRIoOUskLOp1GIDOR+AGk/IMInBk26 + wTULYoNSSgAGMJhADFIjt0bCQAKPjGRBsUGFHUjgM/2ZjVLQ0LJvpUUDHZiAPJ/hPcvB5J72hBGx/8qn + T2FqLk8udIAMjIjSL+XAR4ckB9oY+sMzUOt2tUNZVbnAsjXULTM2yAAOcqCDHXRABznQQAYwqtRs2EAD + OejACyQggReQtQ1pJUhnLtkAEZ6naypBYee8VtQSxqhPJmyGAlQAA7XKC56yO2Q0ETkyhuKPZI992xdi + 8AKYQekGlFisZjBwAxxoAAdJzQkOXvAAyjnjF3EMXRwD25J84rNYWyOf10pYjPSs57OnOpElvfHUMlQr + bfw7TXzSRlU0rKYDk+jtcydkC89MrnuH8U7mCLsY2gqjMS8xH7Hw1B2vHWYBKaiAO6FbnVJ2A0jZKqRk + HRs3bD1UoZMFTbeYdP/S9O4XJxlgi1vqWc8WxdFPyLrndyXTp9qKp2t2PIwKWOCBWfJXOBgITE96+NAd + 7o9aIzvuU+2rNi0oKQ1NmjCFUUyL68BgBrowwfeAZazLiQ+FNZJMjX/6kvANdjKVmUaKdYS3P152mfQh + Lv0E+V6FWguIXpAbSUUJZCnD4UQxeIALdMGL1qpwa5lzxrFYGF7NXRdQBn5MbE+wggcYc8qbucVnGLVM + p06LdvYRzf42vFAmHzcGzbVrmwHNA9hUIAUq6s6OuSZgXym4sIFNH4FtPFvuriACEzhxoNFiRisoRX9E + BiT/nvk2HAKSDD8ydQUm4AEdxAvTU75BBzYVgRX/+GKNX46RjFvYOWGxsGK4ZnT5/OnLXuBxg+htdVQ8 + Qq75JZc0G46do4hkZOEKKb5gOAOlVtPAYwP6BjBQ7V6vRuB9Yhd9JMzxeRj8yzeyxIUqkAFBt62ZDHgA + pLZbW2k4DOofDteZ+xYZF4K0bAloO94pvoGqVuDCL9MTn740ljDJI+Y3bs6fMsIn0RowAzYX/G4c8IwZ + FNW2O8fNbQ2FZr/znSR0NIXVHFfrRwDMWvBEDLYB7rWLzHzmXuqapwmutQOK/WeX3+SDFGj2knnozKHY + meQaVu6RTrMUWQ79uTqoQMLYmGAv4zrdEA/qwi8eab4GGDELUAEEvER19erA/wMTkBa1R47nDjPzsmuT + u71V5h+zmFbtNOQABSKgxorrE9LjfpH5Btzgr7coWV9+bRtXkIIWVABefTcR1HzEaTHYD8n7Ho2Q7py/ + SCUUhzPgVjo2bvn33YACU+PO1gWL6IaTO+KNduOBCTsZFESA8htQ/YReDYPPcF5bEp1W5+2b7+TCTjQy + SPvvp9gBF9hJwJzjtcMIjzX17dNP37ntsA7jCgdIPgY6EDr0kY0DtsNABj9iAaTC8Mx701ea/zbk/Osz + JHMwkuDoR56mVKAXuIvM3ih0DixrMMcAGUyODlDXBDDyYGkHwMX/dsRg3M4MTs69iGRRSG/uPq0MFkWI + 6P+G7yjwUJBoe3YKtxItu8zNfHAua8CLa8DH+yjNAl5Av0qQPeLkBYSPJ5Yt9EDN3kruAznwJ+rs2ioK + B3PwVHbAAhoAJS4n4oKq5hxNu7ZP+3TOhKwrJVDBBQICOJbwUFQqBq5gkUImz6TK3zIMsp4J6rZlAlIv + DHdkAlIgvBBwRmQs9rbr4oDK4l7CTlCgAWywtOTQWeJH+PaPuO6LvvRsh9LQNMYhuEyvAnirEH1rBgjj + uvoJhRTj1lIIWcoMDyODzFTiy44jAmzw0iyxPQDjrUDKC5btw5Ar1HQIDOxDyaJpquTDPzzg/FYxM3DA + Ap4BfLjrBVkwxsZDwXyK4gD/ajJMoBhUoAUOQQdU8RfbQ6Pa7ihq8TSgKhGdCmWgSs9K7f2ezxonhANa + AAWecRQ/57X+CbZojB2nsMCCbTxUwAIkwPfMkWPiRAImAM6CqwzE8RYbJc6SLzRgsQJ6Zh8nZN4goHLu + 8AoVUAE75+Zoj0+qphjGrwVkwAPgjSGfBXs+TingQ9pIRnaWr9NSEqJMbwZgAAf2CCSF4wZewAWegQFl + 8HPETOd0smKASnQU5hkhDJx8USbbw8JeoP24hapu8XYki+Ry8b7kw2S4BQasyShdo3dcoHseDbAejYW2 + C3127Rh0LTFcQgUCRh+xsmw0gAM8AAZeUbicTf6gzQOt/82HRuwQimgtNYM4IqByQLHx/gqOhGmOAisK + V2KNzO6TAKTl+DIkc+AFyNAMq824QpDJipD+JpGBivIxq2ED6BAwEy3M/qkif0nnUNM7vCcQH4CBSNAz + ncXC2o5SkASaplK+lIyQTg4LBq4zYdMSOsMm18jL6onX3DGFgEnrgoW7MAIVX/I3aeirOmAn8nKqSgYz + Re8bn04MqlItoRObPGArh9NzDFBzDpAiQ/H2XMgEUMABOPIF9vI7aQh74LIofvApTcb4mO4knWooluIG + 5fMmpiIdxzMsDUsUVSifWKSwoHGDvDNAH8gGNmA63U4bt/NIREZaNLS4TK8jqxFCZ/9hA1hgAdYxQccH + I12wpxbQRhQABSKPI/MRRI8ptN7M9O4TvgzSqtbwHLBgB3xTRp/gBipg1rxvJYbqBUkoWRKwO9SI2Prs + I4E0Oj3uHwOOyOBOvjaMw75gKUwlSgkiBigHdFgQzKwQ4jiRGdYkGifgQb10lLBnB4RPScygMulvRxvx + Xdi0TWnhBVqAe8aDp8gHLK/QJ4PSRV3gPyRQT9UKeywpiIhQP+mMqogCBqhRUbGBA2TABVSkjZDzxsxN + hbSQJA7DASwjQCx1sUSyPktDHMHRWmzHCyjAVE/VGtZiBhwAEP9UAd9RGWuECxvACyfA/Gb1szCgpqhT + mVa16fL/JwT7YzqG9RoyQAJSQAClUAX9ZPGckTJ4zyNf81mnKAN0QALIUBcjFTObzgtgwDG9FQo44AFE + Any8zp8Q79EYQAVcoAJkaF2hqxX90c4Gyf7wEuAC6UeYIg71NUhhoE8h0vv28Na2kDKisSw4oFsPdpTU + j/20Ed8sNGRMjxzztGKlAG8eQB2Hc3PMEvYmQzEj4DeUEGRRdUpBykJFbirnw/kM1mWdIANgAAJ6JTGs + 69AG8NDELzoo4Hhwlr/akt46dpEUBQOtsz9QzSN/9GhfI54oxwRoLZfCw7poDQVSgAWScGqpdopKiQLI + VSrvS27AcGxpYS1w6k+FVkFdwbw8/0Bd2faz4sQD4CoGjC5SOjSkGmkNOOBD77YJIohcWiAhelbhdOsT + 6kBiCbdwF6tYKUlc+dY/hSgGGknVuEpyreEGcoDeLOCcVOTFNNJeYam5PDfQilWs9NZyW2asOmB3Vjel + PqgCkuKKNiEC5CEgiKh2j82rbsARcKCzbIARgJcgRCsHOMB1PUDVOCAHCDF5qbd6rfd6sTd7tXd7ubd7 + vfd7wTd8xXd8ybd8zfd80Td91Xd92bd93fd94Td+5Xd+6bd+7fd+8Td/9Xd/+bd//fd/ATiABXiACfgo + p+CACyWBEXiBFbiBGfiBHTiCD7gQM+AROKADMDiDNXiDObiDPf/4g0H4g3dAB8pqAzSAYgU4b4VvBpLC + 1Fz4hWE4hmV4hml4hkkyDVStZQtOQt/Ko3iCUoA4iIV4iIm4iI34iIsYDbRqBzhgswq4FiLzkmQtKL2n + irH2iq04i7F4i7W4i7n4i7u4MCgjOixg79ROQt0SLs22P1q4jZXCjdk4juF4jt+4juXYjulYjokiDZgE + ksSWfiU0NrRjF0wAAUjgAA6ABBR5kRm5kR35kSE5kiXZkQ8AAaBBRCZv4CIXxVTK7SigbzGQaWt4lEm5 + lGWYDFLjk2MJSv+XJuVpF4LSBEoAAUqglksgAW45l3F5l3W5l3n5l305mIF5mHMZAWg5AbD/diRWoAWs + Mt4AIzbkdBFH7UJXkpovdH46lpF2wIkDGJ5aYAEQ4ABqOQHI2QSQ+cWQuZzTmZzZ2ZzXmZ3V2ZzluZ3T + 2Z3rmZ7n2Z3nmZ3HmQQQgAFcAA5brXU/bn6alkMb0ap09O52NNoM6Qyw4NRSLcr899XqZQUKWZx1eZ3z + uZ5fDJ1B+pw/+p7lOaRLOp9N2qNJOpdn2ZAToDJmwAN0eL8+iG/P8MgSybGE0OnqjPme7e7kjofCocRm + en4xgE9V4Blw+Zbj+ZxJ+p2f2p6jmqPv+amn2qrhOZefcQVcIF3brOhaMlnt798G6ad1WprRoKzLej+a + bfScDQQXqaLs/zZ+O+ABFgCXjRmZb1mq4bmvq9qv99mv1bmv+Rqq4bmwP1qfyfmYGQDtUBilXm0CAvJs + Xaet2TpgIarZ7m3pIOqyR4/DONuzH+suzWKT19fCZEAFFGCjPVqWR/qkOzqx0ZmkS9qpZbuca7u1aTul + PVqrMUZYUUzTEhqnrW2yaxP+4u+4rVOorVNSxQGK8vGPyXcDAI8BdrmjVVqxm7qwrTq2CXu7q9q7aZuq + d5kBRqRLKawKfHAbpYo02nqy7q1+HDGoo3IWj66H9g8dNCt/YWD6VnuvsxufsRuleVu7CXyfvTvBqVqx + 83mcb2QC5lqc/Mignw4XlxvEPg3l0HDa7v8SISORkW6WfTUAE4+5qcebwbH6nRF8wQ/btk28u1U8xZda + AXCFwuBpEjMw7txaR6v58376KZcJdkqOhStAwu63AyDABEiAqcV7wMP7yWFcwfWZwAcbxQu8qpc8Atxk + v2xhTvzD0/DnWjK8mZ5tLnu8wik7IWO0fnsnBRJgyZ1cwck7tp2cnqfawKtcyvH5nktgyVWgAkJ8lGo6 + rD1MoY0MpxHaDXGxvhkREk8mPpgkws0XAzxgewoZwOW5BKQ8t1PaylEaq/Gco7V7z9FZ03G5tm85PfgC + unQCzm5z2q5Kvss1ZeySCC3zOvmjAlbjY0U8BgrNnE3908WbxQPbnTX/PbaPvZ2tHMqn3LX5HKT3manr + dQZYuaDmjQzbJpE8D9aB8CCdjrh72tvDXWCzIA3QO35xYEhPwM7tud11u55NPapnm8GnnN3n/NTxPdjJ + Wd/3fN/NOSVaINBpqHeiMsd9vPjm+8fJ2r1C7RG1vX7wxwMee3xz4AEK47qX3d3Bu6OTPcb1vNRX/LZN + eqRFmsVNXQEaoBLxVrKzndp2vKEN3sxh/ifs1LjaZiDkVwci4NSZGrflXZ3j3dNP/M7Hu5w73sQRvNjn + Od6RWQU8ALo0xckyk+kwnH7yz+5W9TJH+1H1jUh+pBzftwMaIK/9ndS3+7Wv2sCT/eNte96HXs6T//6W + nR66NMBHlrLgId6njWS4UQ7vclNtnHLDYXGBJJ18O0AFRgDO553eo3zjhR3PkZ3tM/7Jl/7FatkBXgDq + m0qQyNynh1zUik87F6ob/7XpsLQL+mPV5XcHGuCQiT3kA9zZq3z2YbzxwdvFKZ/Y8XoBMv+5ol65HB7W + rZTfCjIXCZJDi6tavr7wx7cDUsClQ1rfYf/tXdzdhd3sT3rBP33j9drtDXkFcuS53mESjyw7w3HWzZol + 8Y8DRxv5xLrlvcDIc94F8F3ZMx32NR7/cT/k9RwIEibhsJgQHo1K5BB5LCVWOx61ar1is9ott+u1ZmCy + yqxcOc/GMzK73V7Dz/9vsmzNLqvRevh477bPxcnZpQ3ayexgfC0yNjo+QkZKTlJq5TycCJUYMZksOXkS + gTJpfjYtoZKinqq2hj55nqR0VNbaZmV4UPgJxhHS/cIR1uUJ3h0Dqw3f+QIf4z3XmcnE6CjeYmdrb3Nj + b8wsZB4lbI4mlZqTbiqdrqOfN5Gas7LCj48XDW2eLLRwdANkhEEHDApm6CBLw2chwkK99khD5syYQmd+ + /hC7U0dPBQszYrzYEHAkyZImJ92Y0ICBiRLu2MEUla8TJ3aubJ6a2SnJTJihjLg0waDBDJEnj/LY4CFG + x2Bo8kB8+mvinKdRET7703Cr00HMKsDocAMp2bL/ZrtleNHCgT5871K1IodTHqdz6NaVK5KXrtx6ctUl + QAFhwtizIwfCmOEx0EaNzRxznArNDCGnhbwyjEbxoDALFUIaDi16NCMNMVIkIFHO3qua6jyZckXkpyra + OW/Olqlbn2oHMv6R7qZBgmJfjRlKtsq4YsLjWoUp52MxWJ+Ka1jI8JAhOPfupDtAMEHCLb149HiS53ue + tWz17M+bJzc+xQsb3rXZ2CHD48OHmnk9Jl0zDiVE1TADZmXZRzrc16CDJ+FQAQoIuJQeKy8hsVd8uLkG + 1yqgfCIKPqFAUQICJzwA3IO2bCABGZRZJWB00Qzi3FTTEbMMYxxhReAbilWQ/50GKxJZJDYYwOACAwlQ + OEpOtM0W025OuucalS192FMSFZ7QQAzbGUlJBgQZpJGZxg1YnYzWoQFIgMB0haCcL7IBUg7XhJmnnoxs + IEMKSyKAnpWDOvFaKjXBJROGrc3zV4YlDFWBintCkkEHExQHXZoX+TidHDG+UZ1FZ/JIoKlwrgEDB2BS + 2qqrVgxUgQoKuARFeeRp2Mo6Na12KBO9wmYXo7YF2xIUUbDQgX2vPoKDLootdkh1G80JYyAOqZGtdFtl + hG2PVdEJJAU7FMasuZRisEMLKJATVJZTrmKelr7mA6VN8GZITrsJMADBC+dCksNSyvhSbYJfvelGVckt + nP8VnXTKMMEOOABcsZ4YvPCACizBou+x94AM8mp2jSyyPvGEXOg9KG/ZVoYm8OMCYRY3goEGHbxgkAUs + lHHQwQbDWPCLQf/8zJuUQVtBDB7kUC7NTz94g34PrGACAldTWO+ieAV7zl6/EsteOXlx3Zc77bpEwngL + uPDZkFAzkkEOOVtQN9BFW0Yj3nsLSLBHSxsFt+AODvfAAiUcQGGJOvUq4l9nv9Vxx2P/dPKtKj9h4omD + TTq4FxhssMMEFFAgwxj89Yx6z6uz3rrrr8MeO+tsyEA6BWFR7Lnu3mnwAgsNoIACAwp44pLitSJ/PPLL + M9+888k7r7yJtp5wAgMorND/AgyB7/6FDRvosAMME5BR987mo5+++uuz37777fNcAQUxSLCDDhrg2b3+ + omEwtwwPRGAFLEHAAdSmNgQYMIEGRCAJGJhAAj5QgQ5s4AELSMEGWlCBJDjACCjEgBU0oAUykMCq9teI + 73XAAzCIQR+8Aq4gwVAOY5ghDFtYwxi2kIY6vGEfageDF+yAAzjInwmLaJgNvEAGLQjg8EyggCdCMYpS + fKITp2jFK2Ixi1CE2QpSAIEZqIpVRlyEDXCwAQ50oAP2s18a2dgBHagRjml8IxvdOMc0wjF8cLTjG+/o + xz/icQdv5MAGNLCsMSLyLBoQWEFmwIK6PTKS55OkJM83/8lLUhKTk8wkCzJ5ybpF7AUceFsiS2nKU6Iy + lapcJStb6cpXwjKWspwlLWtpy1viMpe63CUve+nLXwIzmMIcJjGLacxjIjOZylwmM5vpzGdCM5rSnCY1 + q2nNa2Izm9rcJje76c1vgjOc4hwnOctpznOiM53qXCc72+nOd9IMAzbIwA00gAMcaOAGGbABEeF5Cw1w + AI4ekMAEJvACNXYgB2L0ZxFtxoEdDPQFE4gBDDwgyIQulKGSuEEHYtACF0TAAShwIgocoIIIWAAGOdCo + CTEgtw5IIAalo4Dd5heDCXhABzg4JEsdcbMJWCAFwhvCCERgANU4cQUQ+MwGnNbTp/+9dKAFaWHPglQ7 + +tWvhE/9wg1eYAEXqGABCmCSiUYwAgMUMFAJOEEXRdgBUm4VYBrQwQQI9hjMnGFpTo3rFTIggQicgIAj + OABhC0vYwVqQsBRaAAQkkDu+uspmORBf+TLFjKqWwW5K88AG+slXDpwmsAYwqlnNykG1HZaDZxVBB1EQ + ATBugKeQNdJcXzA+NfkHEG1qg6o8+9Q+rYBJGzTsBg1YwOOmtoAlUAAKVGCBF+x1toTTgQR0VpxAJCgY + PJPASme7gRg0gAQiyKBxi3vc4RIWtapNXD8cK90HZSB0Md1Ppu5aqsiYTwaqgqwGZKACExwArRfUIIGL + u8HSHqD/BCdQwQPGldH3huYG1N2Fwu7LmQKZYTEwiC5Dd9AAxCkwseY9L3kzSMDznsABLNAOhEeDwuo6 + EkEO60VjDNFJCnCPpTigwAkMgFgRp9WCEIRgBpGL2rMewAQOaEE14Nrio3zPAxMlGHbjhBUaKQYRTvan + BmAAgQSYFb2oHTOJSWxgEwc4cQlg7muV9WQocwAGHYnWpxLGnE05xA5h4XA7PQABFCBusOWFoIETGGQM + Ijq9BlwtAhaw4ge/WRvxhSlNeYZZDNuoGAVqg35z/E4MyGABqUmvmTdI5BMTebiqTvQGR+tjEyiVqZHm + htzEVzqiYZgX1BqVZLLMII3a4AEl//Dxmcds4BMXmrwjNq5hR6CatTZABtaY9S1sANCcVTbXM9Z0f8L1 + IhZUwAMs3UAEDlAAZx/QvIku8ZCP2+4KGvqsPi6BiiXQWWpP4ns7kKga6Hwjiuy6YTS+g0dYzNAONKCo + gi61oseM7PQ+fNmqPqyg+RXCGHQX347AQJx3YS03aWrGVV7OHcD9gi2z0wYSUMEBxktmRKO23SJedXk1 + SNzjdtAEKviNxhlh7QlDiz9cwWsyLFOMbnHbMzBA+To1MIEVIACtiUOukMts7BIf27BYpzhaFeCAB6iK + 6T3nQf+kbDpvZ3fgbkpGrgOk9HvDMwcUWIF40V1YiRt60BAvNf+Zz6teC0LBtTwfe1/nhinN5rrGI/eR + nQEElhzIlp0cCDUJpC5mNE8dg1NX9HmJTOozNxy1oyWBAhpQAR1AOtI34IAKyYdlK4ccMuAyWEfAElt4 + crwCC6i8s+9udXUbG+YTV7eyjVzYwSJAAUqVwQseO2vQJdHfkYkMVJahIzllqyFqsr1v05kDGdBdwKue + udUT624Rp7r8eT+2giNAgc61eK7PeuRiFsbthh3MMc4ROQxwUAN/4kAMOEDl8d0C+R2iEdqqnRiaCV/w + aZ68kYAszIC9RV5c2YwOSBQLzdkhYISMyJ4Hkkr+dQZYOJ873QAMDKCPGR/VvZyZFVno8d3/5r2ceTnb + cpUUC7jXbMXXDrBQZlXL2t1Vt/0Hnk2EZ0CXRnmACiAAa/Fdqr0b5iWgqWFdxBHaARKWgDGA+3FA973T + DWwAzjCFD2LX0IHKgWgL2+XWGDrSZ3BhOnFACpib3akf8J0f+SGb5i2goZ1feXGQCkagCjDZW/UUDnTA + CkEF3yCMyDHM0WjaHnjGFGiUBkBA3V2dBBUZqxXaHY6foSXgJWoecSXfkkmA2KUTBjgL+SiGpRlN0UhF + GfLCyHnKx00A/LkTBsyAAtxd34mZFPrdJaLfL5JfzAWZspnVvAlGDHAAn5VTbRXEi9Tf0WTXrqEJZFiH + qFzGv6VBDOwA/ymuU5IwAOKQGgPSYdYJXx4C38Ol2vCR2GB10JqhQApYwCg2nejsFtFBo0KIylaEilYM + 4c9QAGj01Pc1AJj1nnqRoyV+Hi863O+pWxQWX4mNQAmggAss3Tk5FL+dD5BcGBCCisjtY4DsX1fAyQTo + QAV+WgdYgAIgmUGaHy9qojBaoXlVYRXW4Qyq12ol2AJEwGcM0Thx1FQdokgCHP4RTcjdTbeZQUVuFZKs + AAf5nkyuICceoBTCmy9SJZCln+cJGgIIhXN5gDJak74B1QM8oyJyikdq345cGbacSlVFzLTFVQ6wwOGQ + AGIRX951HufpopFBZfAFIyYyW4AdVXvR4v813QxGPhKuXZ8a4pWMBYPQUIRjQMsEdEDqHdxcLuHC9SKr + TeW7YWL6vZxnPqU6qtZ4vCPYeVo1IZEGflxUQMdEVF/RhSS1UFWP3J8vWAAiWKZGdQAmHF9o3lxDhqNB + fmKI0eRdLuS6DZqCeUkJTtPq0c11eZtIckWmLQybJCJE0JgYUgBJgqVGpYsFVI1Tcp5eYl7wHWcFZd7M + GSDMueDVmVaSEYWbUdMNDIxZZgZIaqeB5KO3yJiZhMsI3cmb9YkDlACC4SXoTaXfVWGxCSMv8mU6hliz + qVm/QKI0DQQFJGbaCdzPNOLdNEc1CsM00A8HmORs5cAMOMBYlcDlAd//XjboHp5ZOobeslWdQo6fWSnA + DBSmMtlAnFXAhnKkforoWS7mtqhdZGTWzoCFBwiRxuEAcQgVAihcQubhje5dC+Id572k1cWooRmAAdBb + skRTx2WXwzDmdhppY4bgIRCC3VBmT47dBkxACwRXOPKllmpeoSFgkRHaHYqmTdbcmEnkDOwmMaVFRHQo + 0FTf0ZlliL5icfiQBOjAdz4ZDrxABURAOLRofPalg6pnxD0ocZbZod3hZmolAsyCM4GOi9SfVtRmNeoj + 7R3lfoohTjUN4WGBzeiHC4gWacEbvJ2aXhoXjQ7q1eWpzKnjUaEAjjUTDvCghzZHpKrlR2afZDjq/27d + jgdwI+ENBwTQJQJp3cS1pI2+5LAOl4Qym8R1olMqgMx06y9ZipxdGFWs4qMODbX+B4Zl4wvo1KF+EwYI + 7ElowA5QwAM0gAJQqVPyKVXCnITKYCfSoWcm26AOVgn0w68lU5RSWdt9y9BhZ5t+pMhSgwfI6VHI08Du + UgagkQ4IURtmw4/GAGAtrN1dJakS36l+qntWbLruYR6WgApIwDJ910YGHD7WI+M1qmP244jiwU3Vz8mS + hMDegBlxACEZUi3NUw7owFJU1u3sQA5oAMDWAg7UqQMACnkyKJZWpZ6W30weWrGV2WAxgAwskw7EAOK5 + SfaJLCweyAcubdBt1v8owawtOBREvcALSMD4wMAPeYBF6cAGkG0R9c7/pIADLMACMED1MAADLIADNIAL + sMAsnmi1IdEMNIB4hKldbiKQHeuhxa3rkpi6qtpZmYAFWGovdQBNISV+fkWVHYc1xqZkLM2AloS+aeCn + 1NkZjFAHOKcpbYCXTUiAGZVRjZYIYO9Rld4M7EDpYsPk/YmJ7KLDOiHsQuyoViKNnioHFUAC+EMyZYDB + +ps0PkeMcFsjjmF21Y3SVJTYFm4tgA4GMkUnddLOBF0kpUFY3N4p3YymBpYIEAAIEMAEUzAFg0AIGIDX + tQDpkkQOSAALpIBY1aUK5qKiLWCWklmDPqjn8aH/1Z1VCbgALSBTLkTE2invxw1vdYrg3zrjDFAA0+Su + LRSsTJ3dGvjbiMoBRe1AapqQBlBA6lKpARRACExxFYeACFAxFRcAazXQu77A/1aCpVRACpjACBSA5TVc + nuKdcCpkQlLln+KcASRABHiA9/aSBngAfVGr9dGvBxqH7Olw7UjMTp2E1OQtuHmGbqUlM9TOySWSaTjA + EorAFGPvJFfy9VbyJE8xAYSAAkBAHZsEB1BABLBLi9alCU8hFLZkTBZrMCaWWZUAfUxuLuEx7/6xrCqm + jUjEdhZMz9xOQgWxLUgN+dCfY/bnp9gJGFtMDsjKsGlxAWxx9l6vq0UzNIdA/wgQwAgoQARIgB3fgrPI + AASM52gtnJhp4ufdqFTCpE1m0AungDwek33WsAtRpyvOqlpWxho0somShQ7QVLQMSN4Yjb01VAwsgBlj + bzRrcjRjsiVnskKTAATIsElIjYpaDTvuol5GIamqr0bDrnqJKTfPMi7Frx4/zB8jDG12aFo+Rig5rzIb + bg5MQCdd495khQU8APMFs7moXHhF8BZX8zRbMlBPMjVjLzZ38gNcaChTQAuEL5X+GB/KLY2yMuiNHwSd + 1RyD8jHZQAdIw96Sobcsnqf8SM+M0P3A9C1wAIxJ33TeHzAsBmWO9KvsgAsogAFcs1GdcfZusVBLsSZX + 7/9oFQABFMABnAALZJxJyI0EPACgCaZdKuswoq+yvmgL9iEMT/Qx7e7+3mNCYCuS5l+QzA+lzvU/JdEe + T6f9+kHEJPbgaMAMnMBZaXH2ZjJf6/UlV7JCb/EIrAAMlAUGeADV0IrENVzEbWaymmrsVp4IJMADtHYx + gZbQtSW3GZ0aXqsj5Wb9+K9ZDARQ+QzTpiFu6ubudAAcEvZDF/VtGzUmu9ptT3EIJAALPO/UevAMuMA4 + s64atyBVvyepEZkBmMAMeHMv0Wkua2d/fmjb+SAM3E9oQKtBMMymWXdmuY3umMYCQHBfn3E12/ZfdzhR + V+9gk0ADTMB8l0TvWICBMiz/Ko8rZReXQ9pcszEABSzTcBTx9EWmf07LrB7EVZFQaWeDhLnIdYE39Y1K + ZanKgLcKBvSmAhQACPQ1bYepXvt1iEszUUOzNnNzWmND/I4xCozVgRGXVZcnS+7deh6Y2phAAwytMg2E + BNBXkYu1fyppKuamxEjuaHAApkj4ne2rZJYB4Li2f5VAFbO3bdM2lfe1YAc2UL+afBuGzXTUWhzobhdk + CfNp5hlgDA5WFFhAjw6ThMWAf+zjjvCxPn/KWQP5NvgVkf/Itj3mKwYJSXK5kXCAXbccNCd6lW/4JTP0 + bfs6AYiAA/yLaNiAB4hnArygmcGt3DIczh0AAzzAC6w6/y5FqWUF6GvmDUUsBjUclEIFR5wZ8KLiOMjW + 4w8rOSR4IRol7uJKwEER0k47ggdEclFdMW5L8TT/epX/dXtPMiefgAWY+FFYSlOjLZMEWDmzuLFtdNYF + GAn0trzz0rGXiRDq2nWmzp1PTK13g7PoTIieIXPgyL3CQLVzQf/AgAVAQFgRD8w0FwRYwCxyfBdIAAMU + lRRHeb9ruFD3+qEDexWXgJfEa0mwbAz82YGO1gHq7J726YiZVQK4AKgbk1IwRSKbO3YyjCD769AXMg9+ + qJXpDXUYwgxMANcLRItYQAOcwLARwAcIgAB8AAEYwImoAAu8gPFiQwwkwGxbss7v+v/fU7l6azIVj0AC + pIC4BUcupD1LtKjWzdw5JyRyhSIFpDswtWqQSvci7y0+rk4oiW3llwTH0iqOzMlEBLrZfwGdusACtIQU + h8AAuP3bfwDhJx/bxMDAQ0IMkIAEO7RQV6/g57t677tuG9UJVIDJ48fczMCfQHWYOXwrS6VgxjIFPHcz + Rfd3k1ynAMIgN0hX825q+3lHAuip1A0F4L4jbAAFsFwEW/AAgAAIuD/7S7AEH4ADxAATRwIFIADvMzQQ + FEQig7BIHB6TSKZSKCoQSJAOz3rFZrVbbtfLw00ijBLpcCaREGjz2pw+uM+HEQklw331e37f/wcM5LrR + maCQman/SFysUJRRhFycmZGhgPHIuRHc9MPAealgYZxUTIxEdDQljWSVtGChyOO8sumoUCEZENj9GPAF + GQAGHvj44CVRqdixmb2iICEgGCIqMJi2bjKi3j6yxi4qCJFekNloPt/aeJmJWFEoOxuZMzuAe4unQ1BY + meFA/wcYUGAWDOpiVLAwKRGiUaUmWYBI4UUOZgP/adhxMGGjRg0ddQRJCVIrVqEsxDqH45aJESGIfQAh + LCaBmDUJFIMZ4oAJFRTMNYuRIEQIIU+QFPFG7VsSbUy4QZGWoGdFi7MIUXCBAoEBrvLqfV0z50DXnREm + yKqaVu1aLjh2TIhxSMZchwvnVpob/8MDWraCMHSY8EgSKVUkF6HyKHLwDAsx+AqyMcHBAZfBQNC0SVPz + zMvDPhA44AAGhmYwFBQoenTJNqVQsD1tMg21iAMJXOTouwkHjAcoTJgogSCNGnzDESAooYBBhBgacj+H + LvBGjg4vYFCQizDhXOwTJOzQsUFTdEA3QBUOeWqkYpAf2ZtyCMM5Jww7IJS4uctyZ8wEgv0PhqaXPisB + gh1KQ2GEbaphaikluomtNQmTWEAC0sjrQ4MOKLAAAgcYAE44OgwYATkT9knhARn2wrBFFwO5gQMPYICr + lEpi8G4HHKh6cQ8McpiglYYKG1K9IhVqhAIPMpjFAxdMMKCX//9s4symADnzj5gCFHDBgyYdKGEE1J54 + kKnVrKmmqW4YXMIAokxgwZ8e97jKQxQUAO6MEk5YYIUULHhhAx7nJLTQKzLQIAcOdNjBA0c70IED8QzV + wxMPBGuvyPUwJbIVVCCRAQYdLhRkgwcUMGAYK2uiskr/hPHvsxEUYOEnQTiA4AQSwhmCwTWdgjA2Ns0E + ZygEHCiHUi/UQeSBFlxIQQUXWLBAhgl0YFJZbZXFwAYbSN3WCxw8OIiR9c49bKT0VHkkEsYqiEHHWV5w + QISYLHv13ld9AVDVy/glRhoHvNRNBhUSCMcIMoll8xuFVUvKiRBGSCAFGMLdwoYbcNhgg0X/OZBUAxwy + ABdjk08Ol4Ny110XMXcpYXcU+EiBgYOS/7ihghKMuXKmAV71r79/O9tvGAE+KEGGbAOp74ETokgt4tUi + XIobo7BBjSsTHlgaZa+/BhvlDDxAKLGPzh4FU3XRg9kkCR77w4YdIhjhaHyHHhrou/n7uaZdRoDAg0H9 + yCCGFVLt1WrFy7xGzWx61UkFD24Ou3LLL3/uRxgYi5mkklLJFHT3FElIcE5yqMCBEYqZEugq8+as53+P + HgFZWwPRgW6ioDizzWliC9ZqrKGYmIEZOqAcc+WXZ54TtygoZfTOO2X5PZcnoUCHeSMwoQBi+MPSZ1fB + J9ozEUyA4AVO/zSwgCVwlCIz/ogXPurqqVE7Vgbcmue/f/+/GBv02NaRT8XseixDVwWstYPxbEIGC6AM + v1rVmfDhLWj/EhAwCkCCFcRge1Aaymu8oQ2HtUlh3wgWOGaDABVI4H8vhKH/chCDjQzQXCVJ22E6ZYqE + KAluf8AACxB2r75d0Iir0gy+ehYgA5ygArPAQQxUgICh+Op3IiQh/aZWQiUMxQQz6FoMxThGsW2IWm3L + 4SnMJZJzGUkwiYjB/ujTggNMSXx5C1ARfZZEvs0kBCV4QPL6wIEHICwEiRsh/IDFDQghZTVPEAcCInAg + MlbSktzKgQRksJGQqG10amSXkTIlkflwIv8DEQjB0YAhNNdZMI+swgzsQECCQAKFAVC4muNg86tELqFh + UBkBCiygvUsW05gYGldcPJLAULIRXZxiRaiIOQsbpKAARxOaLI/IStjlSxcGcMHgAKGDFihAQWlanJp0 + 2Ugr8i5rCFgABRp4THrWcyB/gR4Od1g9mR1wdDHA1jlsEAECqHIzPeMmBfmYTQEJoAAREOcfMgADFyCM + AA9rJMMWZ6bWvI8IBZKTPUU60llo4DzRk94z1bU2joRSESyowAtKSc0GpPIzGOxjLBWax4PizRghSEFE + cTYBFIiAAIfkqPB697iksKZX0mihIEk6VapmIQOFSEgzCQg6NKrRMC//g1cV0GGDmmKzgjtNYtCUSD6a + /BSi6NjAfXj3IHQqoX4bbZD8ohACBbRgclUFbGCxwIHrcI5tLjubewrIqQIuhAISkGMzMFDWm2LmZ0VE + KCz7SLRYCQCoQgXiA0mApt+VtqlLdZAWp0GUA6CABT8UbGzpmYEXxACa76neV5epihlYggNh5ARZbdqf + volPb3yLZVpnsosQRAC4m/DAAxhwgHB4Ayno7OgvHdnOBY2pRCtwoWzFa88ZRs9smppZ6DoCs0RQC6Dz + bEY1h2tBnJYvX2f1qWeD+g/auqAElzEK7+7KmkQ6UnGl5Z0JLDDT8TaYjDfYAYfWmEPBMPZI6gEJ/0Tk + E5DJzhdLsgPfZvK1TRC4FbSAyAAFFBCTEzpVhAS2XzacQLwDNGDDDsZxDAkhgbJVr12H9ZxiflyXGZgO + IBlIwXyJm7fj6guzFLTMT/cLkB04wE0BdmRqG6QavPqKVyeAgAROnGMyh40DgUHpelvqLmbqllO9hcHt + xkpZhr5uxBTc40w249bncmIDLDjBAXDpGhNmlKMpzCvkDECCEzwAtmWG9Nc0AIMet/S2m0Kv6GRmgQpI + QAdjBkSHzZpTzC50s7EMEHPfGpAX5OoAF4VxhCTkoOwmzp0GWIH6Ir3rynGAQzAljENwmNs1MrNaO2Dw + nJW8N/rudJUh/peUQf8t0Qk0gAS7axzwXMwg7GoUa0RRwAySzWtya+sG5DojY4fd1WfCx7yMiIGc/yHf + USu3zt20r0z4PBActG822C1hR7N9lOBtlygIsNi4y73wHl21sPtMY3phprZ0tUIi8P2HqCubWRHrkY/I + JZp+pw0IGDhgtLYuMIHv2svH+TIEjE4fw2VeKGZBk9hDbpul0ZaKhUBWqsGlMxL3c9/LtmrEllF1n5uR + AwugYFdIZWStr4FIpqqcRAyogNJnvvW11ELC6k0vsVf6kTdX4Fpap6mSWfVhtuKRrcTQL9o3UZ9yQm1h + L56f77ioclyCxgUh5Xrg+/KJCjxgFRfeLWIqnF7/THH6BY8+h8a5eVzlUim5Rc/PZ6sSmQWMANZSK3j9 + RoimlBvYJSJYQAwwLnjWByQDgJmBKHzcORu52/aLjx4FdvDztJtVrTm1PPBbWWLPOjctHPCvCu8+dboi + +DWyLtb5IiABubfe+kDUAQzeCOR03ZC3Cux+u6IXA8iqhd43dbZCXcn2nRqDACmo/iZsQAEwEQ8Jaepl + gefXVC3zbicQmKbrE8D1uZTQ0aH04DkLa4QKyxRKmAjemwXJc7aOYztTWyhpUwsdmIHOwzYs4rKq27K6 + 0oYnGIEFmIABRMFNyIHNgTgD/JRhYykFKoWTQJ61QDIPE5AlI58JxLya2Le0/8AAHYCAAwCBQ0K0Ldsl + ++Gla3iTGZC3FITCLhgXDqmh9kigTdE0Blw8hrgx8ws6V7mSO2ul5LKSn2qAkZs7FcMlvco/dRowp/Kl + aDiAnnjCKLRDK9CQwICIFjxAz1EsTVtAJUHDuQu6JTPEVSquo7sMoJGy+JuFHZgijzKtYQHB0SMh+BEH + AzABG7vDTsyCM3sj88JC3MItLCQghSC/yEoL4fI9nBJDPJs8WIK75nJEP2MBrRABosgy5lMkLqKfI0iN + 2aAYFqhFT+S6sdmkYgNEHKK4zzEFweC0mhlE+UuyUZtA4wK5boqyuOuLDmABBrA7b3uYlTMhXgTGXByB + Bv+gJGOMwh+RACQ5PGZSvHbbKq4SBQ9YPYuQQMrDRrwxrszSBc3rix1ogFTBskXiMozKpRmTjUNyIsBj + xwGcwmD7QyGLwe6THmiSgQC0wWpEvzqjQFJDq1k0vr5gnxJYw975FS5jJ+AZloPrCciLyK3DCNsijAHa + KvZILGequFXQC4WzCFbcOLe7F1JjqOIivvcrRvoouTDhFScwsOtyDTeEkF/yrgSIAF2byevbgBh4F3kc + u4oUPzYakhnQizqsCgnsx2jwx/saQ87AwNxQiRVAAKjxnaSimnUSxwL4oq0UQFuglpZKmzWbOI5QLIlr + rAqQRugQys1QP3xzTB6MiR//zA0deAATyMVD07tyLD2FZIIQAAEEcAG09MuFQ8Y9vMKFcCYMO8Wdk4SY + ysdV9MhDtMBXSqtXijbPOsPomIAFGDRfIq01qcqqpBomBA3JWcrSbDAbIKxk/Crw+zFEGMvE+iRzuRby + 2Mf00ylWGjo9C5BGjI4cgIAEOKdf3LaB28W8A8biGSbl5Lo8fIQq3C20kU7orLhUQAROi4EOAMq0uEFr + 1MaO287HzE1ajI7IaIASuLJeeb78m7UtUq2sMQGLSU73jK0NkIByubCR8CSX4iqKowQWIY/GzEZFxKM7 + W8RtBKoKhSIK6DwQeIKseQpLJBZfWrmiqAZ4EjcLlblC/xClwcw5ULEeYuutUcEQtVTE7eQpMMyzuIwO + HfCvMfmdLHIx4CS05ksTI9gaVeTRSKuPNgqy6OTJ1lxNRpABCSBNL1S7xzQ1owtDm0i6I5UBBlCQQeMK + 2IA+LRq9KR0CEogALu3SMrMBD0DN84pOwjxUw0SjhZiAZWiR87s3vZm8y1qobVTKFvEA7qEuLFNCbks5 + YFk+BlUBjgxUQZUAUWgm78O5sVxVstQO3evPtVDLEl2r3zM6uBS5FunKBqCiz6NSxhHOCXEYcDgqBxCr + Uo002oKI6vSqMrU5V1UIUYABmexItXNL2bHAywOaOG0RDaiA7oHRpAoWEUTPEzKKAv8owgU4VmQtMwxY + B/mkT0S1yMIMtsIwskf9QiN6048b0Gs1w2kMiA5QHaKQ0jIBOObjtl3quwJYgXVl1xwb1HfRSYwcU5eS + OFCpmR7ZRyUirlekwMgETxfRgBYwAerCNqnbU7t6sQETglF9WEirD+f0FA7FzwV0VcOghEaNVbYg0VPT + LEO8G+WizCOdgBQwp92xq2xrPv57mBgtAhJIAYh8WQfbEPXCNAZUxvB7CImgVp6dzbZ0xTC0zfUrKG58 + kSiytqNKAuuq0tRawgWhGAhI06kNrOY8oCDNFFY9wJlhAYCCQFnNVzy7IxRdSxWdshfJASH6PCZIjSqd + xDeshgP/OAEL6Fq6papkwj1orc81E7/csoBpJZT/3Dh7G9sj0k7iM9A5ISoVIrhFSllf3IYQMIAScAB5 + slyIJaxKa49D3Vs2+z4Z8FtC6VkydJ021aZtFYBLnZMcKCdBw7aoMVczqSsEi4IROAG/AtjbpadxSUat + lcFPqshz2c+dzY3sdDtt3aNElEUnfZEMkAAXUACjospOLc7rqt4VOAvtzbG/8MpnvD13y8lmPIxAMZTh + LbXXGZ8PiwYVLck5uQEKWIFXO9ctW8K9W60CkCSH1d/xAhI1q1lErUcyVYTs+du+gFRZdNNKxZui64x/ + NRQhLIEOBLhxHB4IBQcFi80NDqya//ycU8TaH6NXx5IpSslOjzNiAnVM5F1RQ8EAw9mK2ZgrGt7M7qqG + ElABrdRhB5tITrtPsfxed6kWAqYU0U0obzo67jyroZ2TDaiABbg22b3EM8klqzkqBGiA5shiMlvBV6BY + BiTMhkgIGADUHiHRJFW/y9NGnwlZQ/kzzLwoKOYocx1H1AABEWAA1cvjMusA22qZmUGstAkVm9EWJJUl + o8RGymPfQumAJxE0O4Xi5wswMzkAWpnbTAasDOCA2jIsT/5e6VQIhZAIDsjerstXbLUMFi7lHVRj4d0B + C4AgcSBYhrlTakANcRAB2u0HW440ZkkPxEASwmyEOMOYEz5KEf8bn/4YQ7hTXm2xzBM4J4L9tzWU0uqi + jRVACW2G2Q3wAAnQPiJbDFKohEsQZoyZ1Sbz2LVKxO/M1XDZARZQAQZAgBFwkyoiioquIiGoDQZoAP3B + Z16zARzogMKCiJEm6ZEOlR2YFJMhYyS2zbENMRZeZkrRALIxWs/TjGjAac3YIAZwAQrogGHu6KkihBeA + C7m4C7yIgRh4Af4sYRcx4BIdXKIEHxc+mRzAChQIDjPwijqoBwQwAQdoAdAN6oXDAA3wGB3ogB1oFA/Y + AUgJGaCGjuy0LPSFRfX9uEU2mQ14Cwt4lgZoABVQgb9ugGkJlQ7I4bHetW65gRvIgAyAa3z/9TA9y7N/ + RGRXimmT0QAZeQEJ4Ge2zgEWRezQzgJy/hdkRtG3RGWztRxvceymFu3X7gIk5TiPO+e96SyBhO3cFqme + hUVsHFv1za/U1e3hPqZCFluw1deOxSm8Ju7mJiMMqEYBqK9zbjYEtixfEAARgADQdu7uRhkMiIBrggnL + u5JaDZ/kPuYBABzX9u729hrwjpJeQKsKAlpYKZpVIgAEqCX35m/+CSL8yBL6SlKOC74AOZ8Z6O8Eb54K + OAEDuAnypm5T3hdh0AlyUPALx5wJwAURaGkVlsz6ypICKAFOxPASBxsdcOb4vm9+vFbBnZ0PKMFsNvEZ + P5mJSoHV6QXT/2XSBT5kYdAFGJ++w6bxIX+RP0MA/ZDFykNkFdYFAUCA1yLyKN8WCUCBymhpHgzJmvgF + AkABLJbyL58TXEkAe5HvWy3l4gUGmBCBBICAQQbzN4eOwknQEJBvFb4gkbysDyiAioGBx4bzP1+fGEhb + 1pGd7pSJJMKJASCBBpgAIQf0R7cIDXigVGGdnyWfovGFz8A124X0TocODnBmBRUQgNnXPNpyA4AnC3Bz + T2f1gVhBCEiQJpeSNx2GJhcA9UYBCHCMVuf1vgjCCrilYlg7UmcVLTEeI+31ZF8LDqiABlCABBitKIA7 + u7koAziAPUmGVVf2bUeH54GAFTABEuDwXa3gBREgARNYAQiAVW5nd7WAsApwgQ8hAQXhChJgAAdwgQrA + x3bndyDEAUaBAU7OCwnwAA6o3H5H+IRX+IVn+IZ3+IeH+IiX+Imn+Iq3+IvH+IzX+I3n+I73+I8H+ZAX + +ZEn+ZI3+ZNH+ZRX+ZVn+ZZ3+ZeH+ZiX+Zmn+Zq3+ZvH+ZzX+Z3n+Z73+Z8H+qAX+qEn+qI3+qNH+qRX + +qVn+qZ3+qeH+qiX+qmnepEKAgAh+QQJBQA8ACwAAAAA8gHyAQAG/0CecEgsGo/IpHLJbDqf0Kh0Sq1a + r9isdsvter/gsHhMLpvP6LR6zW673/C4fE6v2+/4vH7P7/v/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaX + mJmam5ydnp+goaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2+v8DBwsPExcbHyMnKy8zNzs/Q0dLT + 1NXW19jZ2tvc3d7f4OHi4+Tl5ufo6err7O3u7/Dx8vP09fb3+Pn6+/z9/v8AAwocSLCgwYMIEyr0hiGD + BhwbckjEoeGGjYUYG2XY0EFCDAozZliYQWGChA4bMmRcWWhjBxggLTxo4cIFhBYWKlCAgfIiy/+ffDDk + eEFBRoUZLGa2gHCzxQMWMyrIiOEhBwagWO1kyAHDQouvX5XOfDB25k0LE3L4zMq2DQYcHSbMgGCzaViy + TsHStTmDJ46rbQOfwcABhgyZX2+OzVuWsdMHJGFwACy4cpgNE2TafVyWbOOxTJ1agLHBsmkvGl7MeNDU + c1K8M5M6lr30a4UXGk7rxqLBAwUWdx0vXvy6s1kLFHbk3s1cig4KXhVz9vyUbPEWwD1jr82Cgo7m4J3c + gJEdgvXY24djpx6belgYKsPLR7KhQu3ZeJMCf51+/eOwTMmQw3wEEpHBDnMpVl1+xLWX13XaMTVDB/EV + KJ9QElgQmmztacf/YYft7adUCzNIMKCF8uHgwWFh/QcbZ4w1GCNtyCmHYnhcVTBiY69ltx6ITvFHG1l9 + lXZjcxzIAFyM6Dn4YYgPNvZVd98dydwOFUjXoIcM+sdekDGSuIOVzHnAAlNieQgjbGP5KKJ7rFngAZm7 + vfBABC5o12F6Dj71H4fC0cXCnHSe9gILLsDIn3scZscol0pBwMILhRqKqHl99pedo5puiR1dclZqmplM + sfDkj6gW1+WjiQ0qqmWHJsqof0K+qN+f671WKqWvLmNDBjcEa1EhL1gQgYvsfQYlpH0KSmggGNwA0QbU + bqBBhb3aYcMNG3CgQwc7eCDuDh3owEEO1wIS/2uQxOEq24dRbtdjq88GpQEHO7wAwwQx9NvvBDB4oMMG + N2Q7xw0cvMAvBUUVJYMMDMcAcAc4/EGqebX2qSeQbP5Yar16ZKADDDomxtTJTVkggwcbUGbwGm+9FNNI + NIdkwc0q85RSH4ceuyqt6L0bb3GAuuAqHxp0EIMFLjTgdAMqQB111A2kAEEFMOhQ8MtqbODBvkbZHNLY + I4kUFcQBq7VHsbJ+mHGyenrJLr17pMYiBBGkkHcKKVTN9996S0rSDmtxTcYGL4QdVQWMR7X44o0vLoNk + Ltux7oL92aopqtW9+bEeGBQbweh6j5736aabznfeLlTQQeWGe2FDwjOXff8U47ff/jgLN1MggQ6F13Fx + dYp6yeWfns5kNMh09FZB0yqsvvrpektf/dMPyNDB1rHL3gEFUh0Vku7kO16+VDsBj0fPxX/pZpvn/Rjb + kpIyL4cG5NVUPer786+69MsLXveygBkL8A5y5ksg7mYQNt2FJC3rY9rc8hOlJvmoM/Ijy+e0Uqy+lU51 + LqCeCFk3uhB6cEKwG2AVVPSbkYgvdwyEoQIdiJwXGKkO7KPgu5g1HT81yT9LORodMtABGbSgavwLYQnx + xMQQ1iR1eavaA2IwGRVi4UAxkMHYcgfDxnnxKA30IsRwYwcz2WRBP2OT0EDUuUhNyg4coABNpsdEvSn/ + kYSpS4ET9bi3PEHQilbIwQTIF7kXKpCB5iPkUWKgPjrkcDg8+iGDglZBZ9UBfw/4YANQR0I9KlGPnmTd + HU9ngTEBkgoY+J4LE8lFRILxfDEcHwM9UDFHGusx+0kV3HTJxrzUrw7PaVr/WMfHJ5bQiUsEId8a0IIJ + cO+UULCb2cqnRRg2MJZefFxOJrADbMEhVuYxntzS874JYoc2v5wDDrrCSVCOknQmBGEJQ7m3FlCAAwKE + phJERrKQXJOQrnwcQGUogwm8bg5m8hmg4CUkXIKJh0HkVRwykCG8IdGOqsMTH0l4RxfQ06MRaIALZkBG + fTpBRTGoQE4OCUtFWlOG/zBYThwOhaY9/WxRcsOcrpY3hxxUYG92/CQxjblRPn50iXp8wD1N6oTCgI+l + CTTKAq+pxWqeTXzIqdJMjXWThWqsXWwiDqDSCQcbeOABTiMdPOfZUSU+8a14umPpRrqDFDKVCKkEyT+p + 6UDdWXWqMFQZLeVgJ1kdD0IZBFqqgLPBNxAmBkecnlw56dFPWnaJyASp0V6Qz7sOAQNYst0XWarIxwlU + i1FRmUFl6oaEIg9OuVLKrQ7rHp7CgSsz8Gj/7GhUtx4zmXDtZN4g4EzPJiF0Ko3qDA9ZTTC6souLY+RM + L0W8oMF2jX1CLFndUlH/mXCUG63sWjMbV+rpjQLPNP8uEWxQLFlaM5HYFOj5/jk+D3QWDaJTVNz046fr + 1OpB9BNiG3Agg6btDZ5GxaN4fytKJjK4ajJgrXo/m6FV7hWqf0Vg+RZ3swnU0g05lNsOW/SiScbWjfZD + gw06wIIUqACKDm7iXOVZTCjuT29Oq4CEJ8wD9ppNcQONKnRfeUikMHAHH2aDGTGGwbchDz8d2pUbZheD + TFbtu73lKEe/mzou35hvMkgvjzHggeQO+XH0fa9fuSi+qXhAzPhlgc90aJyh7elUD0iUgNWAAwmcCXVw + 7ehaxyvj8sZzfzGAs3ptsIMMrxmbzn10GE3LZtKA+JbWWRM55eeixJrKLHtOQwf/snTodwrarRslNIIP + DYEYeJPHPNDBBNKcwOUuEJYaTi1yOnBfMoDTSe4zXi+BFMQUlyEDMMgkHTVqWXcSesE1FqodWSCBXns2 + BxIoyvlaGeS/ttJx1TSgDCSQ5DS4trpNCqu8FsPLT9lWDUQs8JUBjdkmMrjByCwq9WxSgbrCugga2MGs + xxfkM99aoJB2HAsqEAMbrYGmmMqcdTndo47dqths2EAM5Ly6yxITiuJFJsjrXT3zxOBE/x7C7AzjXr/m + OtJoBrfMFVhQraZBdF2ljog4/Rk7e2y7Z0A2ojhZXntjWa7NRrWXRToDD+z43zdY0c2yeXBwQ1eqMKc6 + +Up6/3NEwSiDtmLjDuPHmnejQQcyUKvas/xby3L5reElXd8gQIEbppwIRbzZy2M40KzL171W7UsVzS3n + Hs4mTAud26ZQrIaoW6BveYwxl8frWxh73KPMhIG1J8yBpTG34NxGeMFHQhW7m+HX1n3TTTWWwcaaAbRy + 9GAn95hvY8qT2bh/It+UOKG7HyHgKVWuy/3u3JhTXZs64frpMc1QCrJn7Ir1kdnLkAMK5JnepUv1R2s8 + aO3vEU8PgEG5fS8EHOwg+PCddJq7aHAHMpADXfeZODnGp0i6hvFnMGsL1PpBjDK78pdlTEQlV3rTAoxk + V763ASQzEpPWOBfWXKTFd/A1Ev8e8GpisGT7dV1NlilRBnRjoHERED37pntOBF4h53H15j8WQCHkhwRm + pVJ9FYHH54AbtmEjIRmbtwWPFGz+tSp39iLTJwZRNwPtNEoeF0omyFazVz16EwOm14JEUBhAZnXxBYFW + 5Wjsl0hUgXK+hmnowXMPlUvukx8BZmxdQGYycCfSYzpvB09G6EmXF0+AFipQiAQ3EBcv1HcIRFVDxlcE + RxU5mAW/Bn0/eGeIRx2uJwY4IEelNmO0d2r0FG3et3sWcHJ1mAQBBx2ilYV/p3WS9m1Y83RfcG49R4he + UnH69RVBCAYcYCzDNFfuVHkNlkyD1klOY4D4dIlJIEgEh2H/WShDRFZI5mNA3nF6Z4IpmxJ9NnV4qkI3 + ZIA/EPBivKVlMYZvbJhl5DWNchKI5HcDRPGJUJV1Myh6qXUbLdOFEZBzwzYdnCEiDaUrHugFB/I8SBR5 + SPVdk7dgwVVMmSUguqgEhGEYavZKw+eAvRg2DSg+UUEV4+cFl9Nzhuhk67iKXYB2edZxs6dg9kaN0EZU + qwMBFvACFviPQ3AgMDBNLVWDL0WOoRcDHUAG59Z8PgcomDM/+BcGNyABd3JgdXRM78SGDpZqs1hHesMC + 4keSS6ABElABUNGJrBRf44iQsCQDyvcFqJdunPMZ2AV2GCcGSSJMdSRU1xhyvZVZ9IR7/y4WAf6IlABZ + RO4lc8U3lSs5lYszAY0EBvkFbMqYaT8oL05hSWGglK5Ii9VDXmFJi9T4f6TTABCgeWy5BBsgAVIVUF9E + g+0HX1UnEpPDhQ5ZeOiWlcKRXR1CG9hhhleQAWUGAbI3ebDYhh11liG3aq7zmEtwh7NWmQhHa8EYaQW5 + OBTwAoqWBRiol10ihqVoHInIBTlgRIVpY3GYR6zZR8IVOKPRkLRJBJm4RWh2cEQ2maUVjLL0QJzJBRCH + bhNnYmPHINIXaluwA8oGlJXlVqYGh4aGRx9kQlJEGgh4nUKQA0vjQuC5fkI2oE8ZEskxkliAc5wDms2Y + Kf/VlV6AGf8Q4DSgdG/hxX0wRpQHtnshmAKlxJ9MkJMiwX5SkZtOKZflozIngaBWUFidtijLiEY8h4jx + iAV9Ro+w2GVBSXtDhZb8J4dWIwNPCKJGIGsPc5CdOFpKCl9FJhUwMJ7CSV0Q4kOO4qDoORZ6ZppT8II0 + cVGrBp8aGZb5tnYfSVLcSJt32E97yJtNClDNtWa3kxP21ZmGtW5rwnrNFz8QugUaMAEtcGOnU3txp6Nn + mX1r1TcjVZVEigQBdxhWR5DpV4Xtl6IlIootylXm2ZfQN2JvElFewAEzUDqbJJb1qWBCiVnNCVRWMwFD + uqhHIEgQSGRwuW3M1aQi0R3b0wW/JmL/W3J/T/YleVaaXaCALVaPNzZ5OypjXiaHCxYBLHBQrhqi2SaV + NGiixPd3b6pr46YDLCoFGNgo7ahDMxk0slGjVIADiYM3u4VZqJZ7WmaWH1c69gSl0XoEtPOWVghpgJVw + LTU+vmOdVFCe9Gcck7SB2rGnWPA919dxxwpCsniWlvc/Qepv9coEGcABcjGrmOk4tvaW2RR4MyBdOshV + OUVJstVpkIQqnqoFGJBs67o/SjdoIhef7tRbfdMAcmKpFQtwZYaZtFqtziWVwldI5KaDnolTm0pb5rke + gJkFy9mhGdWwvnWE5CVykScDALuzRWADzxGB3rlcAgqpDuSSwRkF/4UVcX0JKSobP2P1RgSkkx0HpGMK + UtiofTYmnYkiAd2qtUPQZ09lrQPKpvvqbZAzOfAnnHnWVbqEKzyieEBTduwpBag5FxFbe7IogOxqb0al + Ry0gAzbHt0qwco5KhQUXjhsbl8lXtk9AKnfhfGIHhhmTFzihpU2wnFPbfUiHRz3qbIFKPYxZAW8Guk7A + aC2UpM8lX33Ikrpjl/vpBB0wA7J7Hia2jJzaJV/Re6eZUP0ncqmGudY4s4fJNyrQAjElvE/AixxLTelH + q7EqtmNDAYN1BXGEU+tWFl41bHiBS0tlBRjwHJEVn2DKmiXonPK0dCxgSubbBDewA3/rs8IXS//ZClBM + WlC5GkiDtCQYZKWmmHjYgTX0+gTEOqHdy7tHlURWy71yaE9Zm8BFsAEM/LOCC12RKra580dVsMBLsxSZ + xl/nORy18mlLUYkVXAXae58cmbuGWUxxZ0IF6B1nar5CMUir1J0suZ0dW2QygMCohG0JomlVChs7F6NL + QVKt+gQ3MAETum8baZ9WW5ZsXFSbNCF7y8Lr5QEo2bFV9Wi4Cal/lRMieQUr9jzSwcPsZnHEuRStw2vy + m3YimKE19sgAXI1tqFEiFQMrTMdG0HmolZIn6rGi536C98RGgAOQ1Rr4oYzmlL9MUXdXgK6uiJFIqKND + iZaa1ZO85bavchX/GLDLzZsHODxaF7ZtfijMI9pwl7wEFOUVrXuK8/c+6mEB1ca/3/OnGHlZznZUHWl7 + MmY1SvXBeNAQwfIQOBAsNmADvVwNNqABOcAB4PICEuAB5cIB1nLO6rQiSgpzQvtSn2hIObETg1cFOrA0 + rDElwCYjiIXBM2CXVyCi+7dJBVxvAjiottesJac9cywHF/s1t8mAAPMCKEHP0IAwGj1rOQExJSEBO7Az + fhDFMsjJGTZpuXY2f2wFd7g0CgK7yVJ/SlGJ3HoFGlBlTLzGFO1gyHqPWsY3g6K6c4ABXpPDeaMCK7AC + m0QWWMMBF80MGsARX/MRD6NSUME4DwMwO2Au/0o9UZKJpN9JmTDcZgoZFUXr01hiFlDmLpizFIqhPWW9 + BD4lba95akr4iMKFYHhSAd4sBzbgwjABHCGlAg6wAguwACvgAC9mNAz3AncpDTEzAdqGOwr5Sg/TMPBb + xkutNEBmkHlovN552lhnMzGgs0+wTiUTHJJkyGCxcG99BTkwmDM2wssKnbcbqLtnNBMgymlQ04jSN4zN + 2JEd1Q4g2ZKdVlcDrdHA1B4QA7dqNtoJygZUiVVB3GhgfnKhd5y9d+qLzyxFjKINBYiTUvQDFiQWve79 + AJWd3ueLVtNI1NEGvm3M1/uDq6DjNUbUAI8N2Y293M1t4I5N4HR11cJARP/8glrZXZleVDZT8c45kNcw + MxTTRJkcbtrGC57EeMxOsBWJcyeb8aJ/SRfy/QJWvQUcEFkZpZjed6gCbJ8OkMgYngaEIQGrAT1RbeAH + HtmNPeTMvQLRQ1wiLgzzCzkz2OSFNDkUkwcrBhLru7HBjK0cKxKVmOQnZcfI6d5rsnAvwOVN8OJpVaGw + 6YbABdFBCVQtIAE5rmJFFI2M3dzNXed2fucqgOd7DtVRvQAuAANxzgtMLZmmsolVjJCx5EIT4AEcoAHe + PQY36rXGt6/6jEA309oRutVGkRQnYxNBwkAxAANIBtJOoAMPIIJs565KmJHKBFKD/ZJ2cAM6kJpQDdn/ + QO7cyS3Ze37geO7YDKAC0OzawRCZKSXe/UqtVYc7O2HZxA5vAmcUtjPB2QSV4lhrxeUFGHAvHsGUZQfq + 3TEBLK4Bpn6+rwymQomPa/5/+WY1LOBhdRCQXuFieJ7nu37vyd3ruz7kKfAAL1DuuYCaEP6zndxFI/HV + fgHwY5AaMdHhnljec3k28BEGb4EvCvMRFCAxKM0Bf3EZz6N2gqZqrR7J8yRFJ6fwgVlELcDYKLAAd17g + y63cQ57nNG/vDrAAKjAD9N0LTL2ArGRIhmS6bX02JpHSDE4GgmRAWgdVj3q6nR0DMy0G4PwQGlARGRDp + rw3UgZqP4ft2kVjLVVNK/yiv7SilIQ1w848t5Hz+8vrO633u687tACjgAC0QvMdA69YdnqddujAsUL5z + 2W+QAaox7UG7m9ausdUE5WPfBxQFvTyZu9gsi3e7e6wsB4KUSXE/5L+u3DLf2FBd832e3EYe2S5AASxY + DP0rmWbW0ibqaFmOFLwD5Tlw9GFQGMRM8E0eSwvJMpPQv1U2QgDc12P5f8cKAU23+CzrNdYn4CjA3HEf + +m8P/byu67r+9gXOTJZsDAwfepxsmcobOeMDMTHwO4MujyOzyRwbRmmdx0U2ARxQ/oGglERorN4byc2K + uR0HzTsvBocNBJLZw5VyrJBH5UrZZDYdUeYzWnWoVP/KlEXH837BYfGYXDaf0Wn1Wp2bWGaVWVxen8no + cT2+bpfJ/+YqBu0sWGYmOjTYGNc0PCj0APskBwXz7CzlLGQkNhpBQ0XJdGRSGlIiUlwiVFVTV11TZV2L + XFhTUiBiOGxGf3lsOGAsGqasrrKUs6qUq1aYnaGvrJiRIDyAtbe5u8E4YizgAikJKyXR+Srl0GcMOWF2 + cm68G8HnMDPZA8kx7/Q4echQj6A2DTFctWpVRBWuhLAcpmLVKleKBy98FUSTgYMEGQ+MLEBiLcu0J9Ok + UMNypGSUki+lZFkQAYZGmzcL6qAAp5y/THd+mrMkSJM/GUcnSOBADyeZGx6LWlL/R07fpUB0eDXVigbD + Dgu4cimERQtiWYphI7io8GlrGDcsXDRo4CxmM5bJ7qqYEu3uNL7QSqJIEYNpW8OHx2TogMcnup597OSh + ExRyHAsVKEjQoQEDYh45JOyEsyfqJUCNL8foUNizYRwSvqKCSOvhxFkSi+SCUOHFQMMYNOggFlKkSyYk + 8Zp8ycyJNOTMVyxIQYFta+tbb+zYSRRonj+P5/DRFLRxnXEUJrzQgaPz7xzEHlz2Pv60n38VDMnYwfr6 + VhwTWpiLorQYisXAhcZaRa4GWPCAv6aym2AGCFLQC4m9nkEOGbr8Aqwuleq6MAUZcrigvxNtekQd8sjj + JzI//6oCrygZYvBgg4zawqCDCg6J0bH52oGhOhS34kAGCGSxLclZxGIorVMgmACHw3B4wYIIoEiJL2oy + vEI5vO5iiSRo/PJSugo4aI/INbd5ZDuhepoqn8m6m7Gq7ySLgwL1NvANux1i4BGfxvq5CpAYXthATTZx + skGHGIioaEAmzYLllAYgYCGGKbfKIAcPYmChwgVIRYm5MPVaKUxqqFiJrlWbmWKBBiroYFFGcW1Egx1k + GK2+SYCqrEWj9vgxqkGOQm8HRdvKjgIWeCoWWDzNq6DGRXLVCoMcIA0rlrTAbfKsS1mAgVOtcPCgghZO + keKYEFcqU8yYOtSrS3kBQym6Bv9m0OHWbAE+w1meSiPvHKnKK2cSH905hAIPcsARQlApwHNQSi6mEQYP + zg0Ypw7CIeKViki2lMAWHpjB3K22faGCCBZgAAUqMNwSplVdtevmUz10SQrBKsihBo+JNsMGXk37px9z + +AESxoOBpWTFTeCIYWMOsG0KAxw4eGECHqGFFo6x35kBPR36LFrr4GBYN4K5VJArF7niRsUFFvbkwM+b + FJMQpCOKQykllk7ia8wQq2FVGcFTVQKFBkhUW3IxOnhz4YPn9FHq8kg7lk5rbfxXIxtwALQParvLbLXJ + t9rghY8mCpfAtCCwQLWscVIxLmugwNAkn1MqU8NovswL1SP/opvuQdaJBkec7jBfmrR0pPqJqhmDlex5 + a+W5QXSCgNPBAw9eeEECGNCX4IXxd0B7b+ZvCs7rihkbTQYKrPZAb61u6GhCB0SShAypylTGUxVz6AIT + w3EJePqayQS+B79scYtghPoR6opirHNwB4PcIQp6JLAsiWmNdDnQAQdyoIERSrAtNsgADnLQAQ/soANo + 08D7bpIdGbAAAnNZlYeg8xJ9BZFMMMFXEAm3wCm44AUslJwGoJI5O0VtToVq0Xi4QwgZzQBR7EEMBjKQ + gQg6sS0ZuMEZx1iQR/wvCYxDIoiIp0AQKY6OPwReHB3Ary6QkWh9Y8cFX6Q5zCmMHYVk/5EGK0AjCXQA + Bzjk4yOztQEPvCEuU6CZvcokOOOBSZONG2BfjJgMa6wgBS3YFCQ9VroYuKNO51ia1KIWJ6JQUZa0JAQF + 4oE7VO4SRRjgAAVA8iqdMfCOPRNcz7y0wGjg0YDIc4ALZNABR/Kyl6DBD9TqVJ/7GAuWQ7He9ArWnXfI + YALymCY10dkoScqgBSpYwMyg4MkkDhGBXaLXmG72JSxI4y4LUMFFlpfOE2XgdVm84q8896t1tDKh2YyM + /aymlIAKlKLbEAZ84uLMDOkTRMZs3EeJ2ckPIVBV9DpCAyyQg4riahgUeMzl5kQo+xTSld4Bp2PoIwjV + eHGlPQWGYv8o4AIAUsEKwsvSD19FRGfg0UP6RKCpSgmDFfrUOhflUbRWlDBp4bSmLz3kaSQhDrFWYAIe + 0MFEqZrWxAxjQipAgUgCmDNkKO5VmizgG+WZuGWyyl2zKteQ1HodDOjkeYgMljarh9M7fe6miS0NPhKp + yBykMbBUfcpXKrQEey5OjmRKZl04C8oP1QteyREcBCSgy8paJwOgOkpiqaKHbVKGm/7gKou6mchNCEIC + k13tb3kARVExYQFF9SSGuCSvOxrRZnN8Dpe2lKFSxgCwwG0NR14QiTlEi6a0tVM2qbfFLWaVHTzB5eqs + m1ZwsMtCbUxqcpZTjeLNcQka8stzOxr/HSZsQQIdS+91XFcxoRhlwC9NxzYJDN6vrmMonNjBOf+7yxzI + oAHF2ZB8L8yznTUnJgSM1+GEeDMxRWAGAokwkXAgvgkwpqvR41xDsfg0PIgne+Q1hMp6cWKBbmACEFjB + W/XlM3vds0tYMBU9XXIqDycwcX25Qim5iF4dDzRd4YCWJDpI4xhhcWpJQ1hODWWwy2SGA1OmZgYAFJLj + IAPJdGwJfXE2RNGGibQtQYJFbmdmNt2gAzBwKeroRC3wSMt6M32xFHHaCbTqmXU6YIFGnwBST4KUziFe + qhuTyyHnlGQkDYgABHBMWUb/JsUegEGvDPHHF9nURQwtzXeo2Opv/2pRMjHw7aidiAMYuKCNDBxeaZUr + zHkR7pOlTa5+G9ACGbxgf7jGFQ46sOKLLRiWG/wuImcdGds+7EbOhp8GrNSAeDahcco5VaadHFpYydOu + 9UUepmSgg6l6G0Xy8/MffMVV6U2xO9cjdIJPZ5840GgHqqW3x3SwLne6O5lMHuBdhQwr47zXOUtggqdb + UAEYpOngAMPABkwnVsga+pW1TWihN6dY80ygzB1XGwweIO4kT/zC5mazEo5b8To79SQiUQE0Cz5vl69p + V37G2LEgE2vaavnFBb7Ydiuwg6ETzQYIEaBIJ22XvGQyvvNi3Eg1K8oIPCCaQp/6mjzVgRfEoP9+s0xa + FW8bmakI0lD+OIQHRH321migAu4MsmeP/Fkky1OOlR62vvSrgkzVKGJ6LxrpJvlHbA6FvJJRmAWfxqJU + S2DRjm9NDmZQYcAwWYEQR7fP7JqzLR0TeYqvgAcM7nmABUcCE3Dp0+U+LFoqGOAahHpqZc8mxTza5xu1 + SwELh3PU1/OYdubQhVQQgRZo6qzBZ13/sjsDsQ38c9V2uu4PnXRWmmto1j/R0SzgABRsFlZGbWA+u571 + +EaHASsgcSJib/6AtQzVh5STN50GRjJvMgbsHy5DSPJO/2ziBjzgAfxOmJZss+RlqZaB5owDeFjF/hqk + uhRQbTSAA0yN7ZL/Bk/I6zT2LZweq3N2q7fMrgNx4jVaYKico1VixcOMz/CQCvVazwUeQOOWwgVZ6AZy + YO3ww37EC9G6q6FkDSA07taA8DDArZ2Kywli5bOKrZkqzb6s4a1+zgJegDOe0Im2ZZJe6xISJpCKpeRo + jOkKYQZ6KwHDkBuy4wHUD7q+ZIiQSZMwMKSM6DhUwCJeL//iUHJeqAOiaDRka9UGjA2PMCgOkAMH0SZs + oANY4AFFq2dWb/nuMI4+DIDeyQFSQFNEKBIfqX9gQASvSd/sQ9AQDE7uY3M44QtJkWV0IP3W7xk+xAIV + ZwI7qq7i5QruxhNmEZVsYAMMccUkz7AoYxIY/6MZccsdZMDEhrEpcGAGHnC+kK/wBmfOiA0JUKEFuIhj + pnGXMMAUI6GwLq9pPGc+Lo8S4GAH4HAcQyEDKMAYttGAjAqvMLHDLoRUUAoGqk8eeQm7bC8Q5AMFbQp7 + tKkVoXGPBNImJAACNIvdzk3OOAs5giyPVmEGZPEh0al/dsDPyiY8wKPkYoyh6GDZINEjt2EHZsAFWuKA + Mu3rRAy0pOCdVqAByE4zOo8lg5ADvubGZupyvmzWfuQOABLCfHIUeMwBWy+Jmomj4GijvLEFJkAHlHIp + yQj7TjG2dq8kK8NizEYRtLIgwCEFSGUPWc8KTUo5RiIVMg4GnLAs0wk4DP8R37qvc6aHxmzLECig5ejS + GzDgBVwABW7xGEiPcYDIDkXCIihgB3gqMCsqA3RAAgLFy4yywJ5mDmCgJyWTEXKADotvEzvpiD4kAjSF + 4z6zp9Ku9tSBJJWG1mANWcQJHgBzNbchAySAXdQv0shts0iivfLobhgvHnGTjFLs1CSvJ2RrULSHBSpA + GI+zGwjq0WQGiHinjpJLC0xJmqYzsLBvAtguGbvLtvagE27zO7VBN9spXiwpeJ7BvfIoLXCsBdUznT4Q + VBrmeaLFOWUr1coqMu9TG9KlrUglgJ7SzpDH5zJOM8RoQFerdLRrGeEEWWJgPyBUMEsBAowseJyPLzD/ + JQbkLUOBKzjIxzIFrMGSRWNCqNlIlBu2RQLw4wHexocu5ArmQhdSZk+Y5UWBCzhyYAcsMwYqhpXwJ3/Q + xj59FBRIp8/WhRWM4Z3iJi3w5gXmYUkjLHx24ERjIAbSg4Y6IG2wtCA+znS0D0mkD1o0jizHVMdc6Iw0 + AAduIANsAAOUtE1HwQbidANiiIZQKAfk9E7xdFAJtVAN9VARNVEVdVEZtVEd9VEhNVIldVIptVIt9VIx + NVM1dVM5tVM99VNBNVRFdVRJtVRN9VRRNVVVdVVZtVVd9VVhNVZldVZptVZHIQM0YAM4oAN4tVd99VeB + NViFdViJdVjbRwdyYANU/8hW1SDtXsDotOg7pBVZqFW3rHVar7VasXVbtZVazSYGWlQQI6wY1Q4GkPEo + 0DVd1XVd2bVd3fVd2zWRQGgHOEBAmVUM0mUneNMwSeWt+vVf3wlg/XVgBbZgA/ZgCRZhC3ZmGsAFLuMF + 7PXEihEET/EcWeBiDSFsNDZjORZjPXZjP7ZjQXZkRbZj74Cc4gFrjFNVgWMHJIRC3ukETGBmabZmbfZm + cTZndXZndTYBFKD+upDbVlagynTFKEDABoU/xWppmbZpnfZpoTZqmxbLjlZZ/KtWM4BXAuRCUIABGEAB + FOAEwnZsxbZsyfZszTZt0XZt1bZt2fYEZIZU4sYFOP9SXKnKUzygV65M/BCS2pTxb/0WEW/sQiM2VsEt + 9BjABODWa70Wbrv2cWXGa7s2ciF3ci1XcjF3cil3cyuXcyP3czEXbsH2BBzgr6wrfLJvNPrzGU8wAGvM + dVFwWrTtmsaqrH5wVhUjVCpMbMP2BOD2BDSXcTEXdIWXeD83eIO3eJV3eY+3cRvXd8P2cVrgMbNyx9Zu + QoUF7mKLBGOplViRyxRqxjJnoeqAnApuVj2ABSLgxxjgd5e3c4fXcxkXcotXczv3fj3XfhkXeBfXfb0W + Gh4ABqqXmgKMleJkYS7HRWQ3AMdjxhZ4NmcTtjBnu6oGQ2G1Fh3ga3tXZvq3fVH/4Hc/OIRBeIRFuH09 + mH9F+INPeIX5l4VTGITfF3rDdgEuAjyjDbISsaYi2Ft3uFp1CygcWIt82ATTMFpjLIPiYOMGOFR5LAU+ + 2HdN2IQNc35B93ErV39lBn8zN3+bl34vd4qBN3IXt2t9F3ghRzV76qJaF8b88ydy2AzL840NSbHM0Pf6 + AA4yo0dXVQNgIAajeH/J+ITJOHnfl4qFN4yZV3kRuX6ZV3OBl5DbdwFcgAJUyqc2QDm5qx0JzFq/S4H7 + LXzHN7bYccswRk8gtlVfgA7b130XmZAHmYMfN4xRuHEH2XIf+ZFheXNhWZYrl5ezWHLDmIyBdwUgAAaG + lnWO/6ZXtsuwTBKOD8zQjnDuqKeOw+kouSg9T1UDKEAFRneLczmWLxeRcflyP1ecvZiWX9mDOXdyg7l5 + 1fmVF1cBFiClegqK3KERB8mxEBhwE9KWwOt7w5ISoFMaU1UHHmABFFedabmcQ1h4bZmdVViQjzd521mh + IVeWgRmeXxmig1dmT6AF4LGifOkNekSrjBLzxrd6EIufF4wxquKepRNVn8IFEvdnM5ed3XmW5deKQdec + PXijGXqi4/eLOViXs7hrTYABIkBKKsp1VqmCVBpIxEMzm262CNDVAC7WGCwvk9iCTVVHZsCJoTidjfqn + GdqnF1qXa3l4F5etxfibYZiR+/+3oxlABbxQUJlnsEKDOQutMfayJG/LyziHDbGpHYoiNWK6VG9g11TA + eXE5l806een3l83alx8Zooc3hadYodEZos2Zp4sabh0gAijAblmotQIlCVc6pwbwTlpbwXzEihrLe09H + EMjJIUsVBygsZpb3sy1apyW6ikMXeT27oQ95sys6s9kaswPZn+gZP9umsagNsSQYfPVy6fp5kLJbHdPB + A/D6UjeABUwYinUarYE7uWcZo4/Xl88Zfi9aoxf6vR3ZcVEAAnCblzRAQpLQlZhmywIbu/27b494tnNK + EnrjVDngASKaojE7ssUYqJF3qBGZwR0bvtV6rVuZiiOaAVL/oAMECgdW6RX3Moeh+RW/ibsVUhGzN3y9 + yyeohvMQvAW+VsMfe7M326HJ2acnPLnfeZ0N+aEzWqhz2bLhNgWkDj/D4SBnWx012QRbfLwQRg11b46l + ebvKxTMzlQMgYGbV+bFb2LjBea4pG35xmZfB2JHt16eB3JB73HJt+QRU4MjRCcTzzRWRDtG80sUDLZQz + c8S/K8U3oVyWGFN1wAUUIKEp252L+6ajuIUF2ZV7vKfpN5gdd8IF2cvTOYzBtgHknJpAXLANzP+a/Civ + aJrn7hlxKyrEAcZNVctN4Gdx2rh923iDmqdx+rEBuctvfLLJ2ayFm9cZN2wbIBvwU0Iu/8NzmC6rCLvL + FBi2YjsfaIqw/9w0/oigSZUDWkBsyTrHsTi9z3mRJRfN23mKd33HM93Gh9uhW9h9O1ygMkA5R+4rhWUZ + iSWDvBLl6N3Ot1qlDUk/jllSc4AFeLut1XzStdiXc923IXl+zZ2oG7yy13qVu3YFXACbUam1XArVXeyx + ojzf9Q16HEuwKw8lWSyRRPTfI5Xv3EqFbZzSOzutHfybGdqRd3mQKxrNabmdcd3NFxpunbuS0Wmw/IyD + FkubpNkkBU4fVvvLTBxqnPzfBqFqEgVV351DF8B3wdmhiTfDcd54eX3cvTnIvdjgLXyMG/dniTkGTJuF + JClQoJqB9f9Sy5Y+0Pitg7JXtr3KjdcUyzN1sMJ6AWw6qOO7xme5oZmb4A3feXue5dMa4YX7wTP9Z1WA + BSTgu1lH6A243ks8xREN5C0P37Ptmekki6Bu6lP1KSAgcXM9vjkbvXH+3Ce7zMm91n0ds81d0dtXcSOA + ulbKnrlLxKm7ik5SfJHdxfWeKPuNzxGLBaJx0Dc1wVEgAeL6vdebudFZ5inb8W98woGa9RUa3Ik8bCEA + I1Yqmevcu0JfEXvvtRWyxaa7HUSUVTVABri5rXX9uIW89Tu6+3sdCBgnFIohLBaNRqSSyUgWh0vj8KRY + zHK8Lbfr/YLD4jG5LN5IKrO1uqKWtWf/8JlbXo+/3W86vl2X8ckJ/t3Fwfnl5QXWzVhUyHhomE1SVlpe + YmZqbnJOerQ4oJyMEk2JEiU9SUkhDUE9NR01rZaayp7SHuWyqraeMKy4wGR0FhuXZejAUNA1zykaNhsy + Qg8G8uEtCmrfSXtnq0nHvORgHJ+jp6uvs2/hSID+KvXCUqVO2d9L0UPtJ+2mcvJqnhNZ9kYFo7ChHcNM + GTpMaMRmYrZD0qD9WaSnGqFoepz5wWYHpDdAbGBwINZwJcuWLjnliBFB1Kh981zRW4JTZ6lT/07ZO4JE + oEFZAIUIhfVLXooKHF5CDYPDAzMLFi7KsAgInLeL2kbOCQsSGqCw/4oshvzYzBGFHTeiwo0rl2UHCyqE + KPjlk2hPVLaY8LVV71XfVkQHP/mJd5SDBx7mys3hIcYcipa5Yr6sEVvazpu79WET7tGEHTggo06tGhMG + DxZShEIaBanNoDcLxqIlr0rRWEr2AceFdLjsBSoewHi72iUGDR1eVGWxRnTm6ppHT/+mneu3OM0aOYrh + IYfy5ebPn7ehYwKLBgtOmFCgwCCrnayiAAX6O5U/nkB50XfPb0KMYsIQDbQgg1vouZRBDtBZdZV1E1qH + 1nYXcmXWdFeJtxCDH4II2Q0vvIZCXrspRts/8+x3EH8/LZXibMG5yMtSeTnAAgwehrgSBhvsMP8BBRRk + VcFV2R2ZnZJLMtmkk0862YYMQ1IAQwen9Zillixl4IEMEKigwgoLRFGTmUudmeaZBKqJZk1smgnnmnES + sYADDUQwwwuSbLmSDRvosAMME6gRIQsRIpqooosy2qijjUpXAQUxSLCDDhqY06emm6KDA0QWQNDACiiY + kEAC8ZmAaqqoKrAqq6m26mqrs6paq6y10krrqgnktUIDLrAgHg6ZcsrQnx14AANlG3m2ERyHuPHsI9NC + S+2011orrbbXTgnDCztwMGyx45K7CQ47UMBCqKMuQGa778KLArztyjsvve7W+26+9uZbr7/wAqMCBCzI + IEE55fqJwwYcdND/gaWWNgxxBzo4THHDE0Ms8cUNUxwoxRpPvLHII3O8w8QcbKCBDQiz3LIZDj43wSFF + zqwHzdrWzCyzfGw7c7U6byTHBJVywKfLRyOdtNJLM920009DHbXUU1NdtdVXY5211ltz3bXXX4Mdtthj + k1222Wejnbbaa7Pdtttvwx233HPTXbfdd+Odt9578923338DHrjggxNeuOGHI5644osz3rjjj0MeueST + U1655ZdjnrnmcGNgQwY3aIADDhrckIENxG7e0g2AcrDDCxK84IHDKKuUetjNte4B7BPEAIMHJneQQ+22 + s2NDDhKo64KoDBgXgQstVCABlsRzjQHMEsRA/yQFVs0waQwTeKADDitTj04GHEAHwZgMKFACCSUYKG8D + D3Q4fPlTw6z7MtBO98iUlBLNfvfDhA12IIMHuEAF74lVAhBQglPlBRi/IpgOBDhApmlgPZW5TND8IJ7y + XNASNvDAA1aggAQ88IGmWiELUQirFVjAAyAMIdKakwNBFUoiXenfGrhXgQ6hjoZkyMEEXLAAEyCABAhw + oArh58ISQLEESUSAAlbQAgq8QFxCbFkGXzAoi1CkM2rxA0qCuMUv4IACKjghCttoKviVqlSnWmEKeYUC + FURAQeQ747gyKIGqSCQtF9KGdAzGxzBoAAYRSMABEHCqXclxhXJM1RtRCP9FXqkghjM8ZI8yACTsyeAq + SerDR0oZkgjJACWc7MINZHKCBLxvjrJ01RwpGcc3qvAEK4iABSbQATOu0jw30MEfC9HBbnDjK0aiQ3KC + yYMORICNkqxlJGs5y0ea6pYmWEAKZrADZ6LnWH+cQaS6Y86QbCVo5GSBQoKpgRgsIIkufKM2sanNW2Lz + jSRIwAkaYAEJpAScqfmTB3i3QUEidBqgGYkFFGS0M95AAg9AwSXbOMlrzhOfF5UjFPOCAgdAQAY6AKZA + W2IDDsDASBLizDn3sNCzjKYCVtpkCHdgl/alsFRwtKarLkpNa9IxiQpQQQU6sMeStsSTHfijBaTDw9D/ + uHQa2+lMKnm0xQmo4JXTvKZGp0lJWfIUivLsZ7CuhNSVOEhQROKgVxBqjah6phEi5SMGZnCCJZrAiXqt + py016kRb0tOr81mACyjAAZKetRM20AD6KJBDqCaTEFPtindYUIHHnBEHLWDkA+N4T56CFpI/zaZel1gC + BjQli4hN7CX+5DqZPbatoMlIs8BRjat4wIL348Ai3+fTbHqVq8KdpRNx2VkGOICXO2JtJzCAUseGUSTf + wQxkIbuVZlh2T1scYQpMsM9UqTCvngVqPYEbx72at5qdXUAEKKAF5hLQj1XhHkkQ4ZWyJPMZgtBQHBwB + g4deMKLddSSvQEve4p53/5I7/WpGdyXFB6IgBRZACU3hCwYMSEZmlXFrOO5r3z3o96Ve8e8GVps6HGC1 + gTsFrnlPBUeOAra8nmUwWOE4n+PEwKoWBoODXhARH1Y3nYXQzjNs+5npwiAHRx3gBmKgAlia9688/equ + ppzNrvJ1jlLc5wIgEIMK7vgLN+BAsghVkZi2dbraSKdGKETiJd8vB2pEYmdZDEcpk7fFWf6teFl4ySsI + TEEVPuuPXhDKlm6myIFQtIXODJZEnKTEQsRBDBqAxK2+GKy/XTFYOz1JfLqYwZdkgDCmx9wMUoWcQE40 + dY9s3UFwuA0wwEENhJhIS8dSxva0Z5Ujec8ZW7mvOv8lwQhK0GUKeECLJW2ODny8LCAX2aUj6QabMSJV + ESPTv6a+YAZekAIFEDiwCDbwTwE77o0KF58qVMAdI3BZAK/SkzugTA8xRJ2pVrciF9LvdR3xgkFTrwMu + UECu+6rng1dTvKKFsQuz3OnwWnFHJh7g6p4Tg3CsdLbTFkmIQSztskA13+SswAsmnjoNtADcKmQxUB+J + Xs9musWZjnGwUehAXu1SRx0AePk8paxo2zsbGAp5ZK8tkkJV4JtnzIAFGODAW+6Vr7Tc6KclKdp063nl + EERBA1jwAt1SDwNTIVQjnCr06tCWI60OTbWjO4Gn8JECDvjqgmNcXISTF9TjlXr/ni2ZxBIooDETEN4F + u7gMjBfd3m8tCeM/Tu0hq0UGMdgBvEP4CQe0L+F6Hi9GW9x5dOvdzpSsKLsd4AJIgP1yGggSNUqZ+Gig + BSOL/rC+rYNFHQsxJhF4ZZ1BH1xh11zhoS13RitJx47m6N+pw52PQ3moRqD5w7N/PTqNXO2E7mEGE9AB + nGmIAR1UYAFS3HWfOc/nThtY13ynYzVtjoATHKctmMLcDTqwP6DPlpTTjit3JjRZ78hU5QkRBryApYVX + qHVVaPme8NFc+bFcgkGdTrnQfOxSUaXe4rjWBFjAA0jI2nHD2kmWokEa/4hFiPWPDGyfyd0PDshAA8DH + JdEY/8PJ2J4Nn/ntHafVHUchn9fhXuM4R/M11ZEQXaOFHIUok5pJX/ZZhS9dIA2Bn6XdnJ/pVAO2HN71 + nU/t3SNhGS7xk+n907Ytzga8wLJE1+NNl+Ot2X4l2lgo1MZxRUPtQBMKkQ5YwAIQl8F53q8lGPHp2oJp + Wnqlm3ygQARMAM8JzphBSCBhB/ZVQ9uJYDhcFzJJXyQqIR1QwPYZ4hZ9XwWkAAPkldaJ2xROoVepHyAu + 3Gih2zRFERQxQATEwHslzg1MhgmKWNtVn0csXuw9Gr6NxUQUzMGwVhqlAO9BkSjmE/CBVykCVqjlIT1l + 2V/F4EexQAckzvelS8btULPYW//HBd0HqqG0nSClcED3ldQGUIARsU9wzZOnkV87BhsW7trBtdzKLYAM + wCLhnFRKPV8SmpNYRFWadURJaNwjbkhTyZQHhEuY8cC5VIALrMAJrOKVBVbo5ZmvrSMWOiAzspDw1RIU + kcAJpIBhGc5z9V93JFQ/eiM/XpsfsBn3+JKyKeQ7tAd8sB/xuRyDURmvLeMexlhPGZzD4YgMyOHddJtJ + QJ7/reTG0aLI2eJayEGVSIAOZGJiaYCXtICovCAMYp07MlxYTR2LtZ/DgRrgtYAODM6PpEEHfhj/oKEI + Dl03CtJ1BRL4kIdCjsH5xMADHNEUIRie9eFPWpkp2iTV/RT//DTABIAh35zLxe0b22HbmpnSLhIkv41R + lUSCXZpBRD3AXSzcRknZp22hRlkkDWZhPV0SCjyABAyl3DxESonGogHka+Zbh2Fb7UGWHIyD+KzmMaig + 5CRDREDAApxQFHEVYdJgDW7VnlGhBA6VBdyjYkrAQVVXL0oWLrqeW1ZnfUmJsPSmMTiIDlBM0cCNg3BA + eY6PS/wJDIBC+1hUMzoccn4WM4ImNfWUi53KCUQAZvlNk8nmW3kcmjEaOv1f4+3QGkje0JhGd2qC9eBA + sxEKCzwABxbMDqQMOX7NYrXOz5HGC3TABmSAgmqCBpCIQ1qBG91dC23kucnj3ilj373R/wpMAODoQAys + 2keYRVJCnmzl4vRlBHiEB0LOX0PYQAdQQAtEgAMskEWx2woITPQk5tZkQJCASgo0gAogKQqsgAM4QAq4 + wAPMAECBKCacCwXMBCxVFATCz53BY06S5vAhpxShQAXs5tsQacYZYf+5FZtZCHaGhHgAo5B6AAusQAmI + QAgQAAGAAKIiaqKGQAF8ZAQs19doJuZtGQkokaUegBIhgAkMYtKFKSbEBASIAhvllO85I3y6Z/AdGAkw + AAs8qd1E6fYQqP5Vnxu6YY66nndYxQ/5Tg4EqbFwwDmiAAKEwAAIwLEia7IeKwGMQAI0wAxcJpRyQF4e + EQkYgAhca/+2ZqsIiEAjcZ2O9KA6HM8MgMkRPRg9odeJiiWqmuoNvt8DmGXfdIlRHt3OeFh+GV1owCYj + XAWy1SWXwEAKlMABiEABDMAAfADCgsAHgEDDDgAIPOwAEEABFNsCWEC4Ss07RYAnStEIHMAIeGzIHsDH + kuwBrNcD7MCnXgJeiurAOlKvJWfohSZG5WQ7lsoSnQAE7ICF0k1VHtpjhmBj4qszcNw0TElpnCeXSEAK + IMAHJGzCNmyiNuyiLqrDOu0AiEA9YuzTaMDSJoDIZioJhG3Yim3ZfizIjgADOMacbsIGqOcKCIEE6tU8 + feZf4l1phpYU5Wxu9U1VyqpAWsOG3Vf/ZB0dbBZo91jJv7IEBnhtCBzrwUatok7t1B7qwSLsBxDAAaDA + DMAd1VDaMB6AAXjsx4ot2ZItpo4syBrAablAyalOB+RlJyJRLGlhqv6azfrhFmrZ+7XuVL6NLNJrZOaf + jTpmStpBSLDBlLzAOEKFDrjAAUgtxEJuok6v1Fatw0JuATCADKjsuEhAA0hR6mbqyI6spZpt2ZYu+X5s + ArRA5y6uDlBACuzly9LszMKncnqa3kIA3/JNlP5s9FGnL2qnN/IXVkwAh8IkS3CABSgACAgA1EZu9Erv + w1pv9BrrB4yACgyD1IxQBJiAAYhu+o4v6pLv+ZrtCBSACKCABbgv/0u4rQW4gANkZShKZAK2abv+ld62 + wC/1zZCaRNHe6qNxGNEepZIUzKV0ryZwAAugwAhc7sMSAAUvasRObvRWrdOGgLO+gNTswAM43QgYwAib + b/mKcQmLMcgeQAKswAy8avFsgAfMwDDaHDTWIEdeVO4i5xu9a7z2TZ06wjlN1hpCGnU9wqREJdsewwSg + gAEgqhRD8eRGcaJKLvVSMuSGQAk8gAAizQ1UwLCK8BhjKiiLcumW7QjskwpsMVw84Xucl82iok6yq5bl + 1ftZQBvXzbQKoa2a4NAOpCKo2oT6ahJvQg60AAJAbBVTLfVGrOQmsxUjbAGogH42TQdAQAmE8f8YmzEZ + Y/MIjy/ZgrECzIAmN8RUHFADMMCDfWYz9qWpoijLIUA9CvPZbEBE9CO1HS+Pvt53SAQMXMpcmOMKGIDC + Vq+iUnDUWjElR7LDCgABnIAMiDPLaABWkUC3hvLYVrTYIoBFoy83G0ACQOpDM0SXzEADkCr74aQWrp/V + KdyL5VQCOAAMAE7XFomrFa6GaIXsicb/ABQin4MNLG0JFMDVWq/EPjJBT60UW3EjC8AAlEDr8my5fN8M + LADBmrL5hrIony5GWzT5FhtqpqxcDNM5KhAxppdfxqxGjp65nQoKuIDS+c33RWcuT+eN7uKQ9dChoCCF + 8jQ6bMADJEABSG//1EosJCN1Mid0I1PvUh/AAlSALZPLDUzAt4Wu6W606WY0N3Nz+o6AIzG277LD+cBA + e4CbEq2c/Z70FVrSaTWADGzt3QxTDMjWLULm9G1FtRzxXqeDBCyACFDwYDdzJAO3bxf1UCusCJhABPBx + 0uTARMESyCoRZY/xZZtvRlv1RpdusUWAW89FAc3AXVhd3fKhr6GXKiaAxcah4LyDDlGDNdC0/kmI5HEo + 4aXGcpfAwhZ0FBv1UUcuUiP09DJsCIzAAkhzOmQADuRA7rxA7FiKr+J2GXTAtyWRKZevCTcSZU/4c1+0 + 2HbrClAASHMJRLBACjykTvWei7ZcA45fCjST/+CMEDPMpqPZdUHmdQL7swyswAFY7n07smEX9X0bNBUT + QAiYgASwAxpUwAMcKRTg0QOkkmNrggcMajdHd9hS9whTt1aP75WPr8eegDB4OEsYj3rOnRQR2GgWX0f6 + VHGVwAm0b+G88cX9MUcQ8Wew5CW+QD8vhwSowAEANtROckJTcgVHMPVWbcQi7AFQQDr8CBzLL8EZQAg0 + bAEYABXtEiQ4+SVIAAOgMSlLNymXrXRXOHR3M+nyU1svxwhVwJHG7e9B0iim4gNdAaTGM9ugZQU8H+DG + Hohtg4EesK8+dVQwXQJMMSQndY8TNmLj91Af6wjIADqIaIgLZ0Y/uqEeKv+3muw2dZ30oMMEnAAIn69F + X3mnoy+mXnl1l+87U0CDK7pkfIkJOZBv7aR7gpdY5eysIQ4u31tcaiciIC2DQJMIOK3DDrV+G3XBE3sV + P+yxGkCzHwMOKNLXgjC3SnzBcqu2iq4JePk5TMAHG4CnQ7ena3XIj22VYyoYJwC8okciCSpNgiKwkZYE + bqQKxMCX780wCUkk3qvQPWWvevZLbIAMoAABPHAFJ/ufP7IFU+3RS+6yM3xzEakHi8ChhkAIUHwKF2wB + FMDUK6oBHLcMGJUxTIACYCvqVnSVh/uFk+1lj3zqigAJyHxrx8XqFWkDiEJq310y7lQdHQhrL06hwfn/ + CWpGQVoAFinZh9gABawACRAA1FJxQQ82QkM+wet3xDotCSR6J2hA/J7ztWa91Uu8AUh6xXc+1XtrCsx8 + McBAt4/u6ZJ8ZWO1uEu52E66Apj+rKtDPm7mLBNn+1USOqPmfznOufAOkWTFBtFB8U9JVghLiHCACyAA + YDs+0Qu2fjvzYRs7xBJACcRAcwVsCaAw1Vc8tkq651/rxBfs1K9uA8CAMOs26Uo4hX+6ZWe2lZsu6Z5W + C8D9XOAAidA9EDBOCoUpYSyVjiaT4nRarFqSDM96xWa1W27X+wWHxWOy+JbrvGAUikxWsVhmbvZEstNt + bmV+X4uBYSgAISQoHDg0/1QkQFRsbAQxjDwkJCwwgfHD6nhQEAkpICgwECkVMSgoRTVdRQ0hIBBReNjR + vPJYKSEhOTjY/fUlQfAl5jUWDt4dLmY+QFDxsJUey9CBqXhIcUApStBVMjlBWWiAsIjZ2ZteZ293l77h + 8ICZiKmYmaOIsdvBsXkHeAXDjhYIPiAiNIARpUgIJ1VqKAmEwoiIBiAatSCarQ4tUBwAZUrVqVQkT4kk + pSrUARS0pHWIcGLYiF68hiELlvMmL501jS0DNoJBhRwBA2bgMCGbChQMTCiB0qCcjB0ajF7FmnVaBg05 + OOjY4UFsBx0c9Gh1p8MCAxEfBFys5Ehuw0mMFtale/9owEEDCSLosLXBAgoEn1KRQrXq5OLEIkaZCiUC + AYoZVjXlYOHAxIERx4gV2+WMmTLQOZP14mwiRYwNaNnh2DFBhgUWLSK4eDBD34scGFz/Bh78jw0bvoWz + o7AA5N5KjwpBtJuornNHCT+AYDmjtaYdDUg4PmzyZGOTiEcaCBHyQIoOtm7EiMk557HQok/fHE3f102a + CE64kOA4TTDgSgMcNvAqBw00uOEfAR+EMEIJt9DAhQMSwnCh6mCBzqG7JAGRrr0IKAECCRzs4wYKTHil + JFZISqk8lWR0jIAQTqAART4w6MAC5QwA7Sb8fvEsNGRsIgao0U5goYoJn4QySin/pxRIggVCOAhDhD5M + yC5IJNIQEg8HEICAE2RQpw8MPCgIlpIMaOVNGGdMqc5UDCnhgQ6M6yMDGFQgwYDOSjOGmZ3286mZQoEx + oIQIaqEyUkknpZSdgR5gMcuJunyuUxC3pChERUT8IAQH2ruMggYQsBEyxsRDLLzySioAlGcowMEWDlxA + AMhFgSHNSCST2enQ+kgYwQAEFqiAg0qfhTZaaXnIYQYURiDguoYUAnWuvKLDMC+EtiThgVy5a4EBEtKb + c9aT5Ix1PJJqJYGBFjby44YKTji20CFJm8/I/I7ErxfVcJ02YYUXFhCGBQxgBK5NQe2UrhCf2zCSiAUI + 4RkJ//jsYwIVEhihAJMZe+w8lEcSCbIRElBhAmlegICBEkagaVhggAq2l3/rA40nX0yIAF+Gj0Y66Wk0 + sMAgTe+iRFSKonbO4nE/MGAFhG3Z94AYWT7vzVHklDfWUQ44oQJ4YIjABJoC1hnoIo8UTVjQcGZABieV + 5rtvv7fA4AUVDBAgy4Uu0pBqjL+UTuoBSnTWFgxYSCCVk1tp99VY413F8lNMsGCaDaxNVOCBg8VJ2CNX + 56yABCAA7G/ZZ0+6AwgUwFLbhyS2eFOJpp4ozE4RujGGaTCA4ELPDxN7PBdhZV48xxJ4AGQ/JHBgJ9SJ + RJInuRFF7dicGl2hWdrPRx9aHP9mOAHii6pOHC9RMfY0ookGcB2CyCV3YYQBQhBJeDBXNgEKsGWhIEEL + 1iGYBejCPqFZxpB6QiSf7Ow0nEGACWK2t/R10IMT0kEEsAUdvcQFfo8IU/zuQiYQkKABMOCgHzDgAgP8 + zzyco9Nj6jSjU3RuEAm0Xh9swCYGeK0mn1kUovRTt5+UZjQKYEFRPjhFKgYHAxNYAAiyRLFRgctbFZPf + c1jIgBikSXIiBEH02hUvzRlQMaQYxAggoCNNZEACgBLBoJLYM4D962em4YmyUmC0KhbSkO6wwQtcUAIy + gQoSDPmUdOz3rXFhJwJSPB4aQ2AnVkQPjrDqZNheYYA5skP/AyxQQPhGE7Tw6Uc/QkLiAfKIAgug6pC3 + xKUfOHA7A3xAUxCZxJe49ZBIFhOFBDCAAmZAR03YoH/4K5u7BhgjHComjqVEzsgEtkclCgyWOkPNaXCW + gBVY4Fy5RGc6vTCBE3wCLtHJGDCNGUwuGeJ9IjCBCwjJP/9tkmXTXFliUmaed4GAlMzURAdYsIIEYHA+ + weBZMrgpUdPxJIMOeIE6NbpRK2yABRdyCMWIqbFJqpBxzRGAAEaQgglYZh02gID/wjNQHr4KlPIqxTWD + WMcXtMATvkpiBb+5KO3VrYLhTJtLObpUQ95gAg5oy/t8h5eK+O6RKWzcRVJaggqY8XjP//TnNA34mLGN + hKbzMig22ZGBGKCgFKsE1hGJetSJGmOcLnhBDJm61/TZ0QUmIEDh6CeJYdLPsFBLXMS0GIIFZBSREDBA + Gl9EI8xRE0ZlbUUIBiBHhHIkBQh4W5C6+asLrs5u4yNBOT2wU7621m858KkI7se4DQGvqr2L32xBIIIE + tGA77XBmP+F02R0G1EWWjVUIQMDZd2igAg2Uz2eCNqSfLSNJD+VJZ0xQPqW61rt9kwAKCmCRuEyHmI3w + 4iTlua0PuC4CJ3rHDGWaU5RclrKLwW9mkanWduzgAbkQ1NweWCglVrBI0vUXe767YL7hoGksJGkXy7u7 + xZXXLin0pf8BHFBGgMA0smF1nsraGM0dapa57/CrCYAUy4h2r5XXdfESgYQCCuiVwTdWn8hG4JbBym9q + 8NwSPT0Ekb0k8JzukC802UhQAuZQmso9aEA0MAMGhHabv/gZHwFJ4GTgTAEQyCuOxRytF0Sgcr4M8qjy + 0rvhCY+wXrIRA2QWEA/bkEb/9CSeCTheObJ2Gi9oQAL2WFFvGrh7qYvry1DAAkiN2dGRuoEFEvAKqn4o + zVelbXMmxojCJZMF+4tv/yRb2ZXJiDyl/sRy+euO0TmAZDkrNATh6jPsqq4YCVhAjh69aynpoAG9dAgl + zfsQ+61wzYe7DgIG2dlpeBgEIIae85j/LO1Oomezq24HBnTAgo8A1aiok6ixgOWZC/alBZjkdboflAEK + MAAEglXzxYB8bMbBRaqGaC+NbWypZx63gCHeIQ7x65hr+/l4MGhACbx9YGKF89CjhSgxSkYCFcBX3RcP + TgaeSoJskZfNULMqsedJWI2RIAK2DIh8nw0nWYW4jQN0TLwMYQAXGHwasFWA0CxIQUM3PFEFK5QB6gUB + DzAb40dPyyJF0PHa4pakg6UOeSNWqhEsQG9YmSHENjnQso54subBrHIPUHOsx6ABOfcJz/BzKGM1nD44 + kU8JFo1upNcdyRMQrz3NG0/cUgeMh/BlAZgUu6sk2Z/vKq6dEAPH/83h12QDiDJWODADFSh8UKW1m/eK + JVe6lbYEDQiQ3UXfjg08gATMMeHIMT1SCb9TiwIwwMm1kvVRq1Gg0nujv+dkiD5rhQMPSEAeETBu78k6 + qBJVpdx4IRQZHHn0z+fDBmSwAhGk1OP1+3iwVX+/TSWgAjZfxwwPYGd3/TPabDzgZsmuFYdpvpsRDNrb + kxTrQBqAaBNwPvT1DwaRIQBLUvcxk+qiq4KkdzqAxkILDIiAyGq5VlA882u8G6qVazO6dgghmfCeIyod + gCEY8CE3+kgWBGAAfdq/EgQDDYAA/4OaqJuw3EqsqJktRECbKEILmBKusRGrF7k96PkkiFG1Cv80JRlQ + gROQDyyDGyfiJiM0nZooAQaYgX0zQRP0gCvRncNxOhhks+xLCAEAARN4gNVKQFEjmxjRobOyLD2DMggA + P3bggApwAGTZsrqRIO7JPLmKvxFAANmLwj20Am2zAMA6IRc8tr3zOyLjGAewuNmjoZVrGSbjpMqSlTfi + vfVDC9tRuNI4lLQrsNGiIHLjDBKwut/iwxLMARlwAP+pwiETNg4pLHkrNrgol/wrvH4bD4K6PfKIE4Cj + FQr8jQyQAXV5seIDBgSToLU7HZpQgAiIAVkcRdGTAO8Yrw/Qu6YDE045r4vRi1I5wEz4DfGzM2tSDNxr + GZPgOnfqPdcInBT/OIES+ES6eTieM8ItkyDUkLsWaLRmfD4MkDTliot4kprzIrYr1KLNWgDtAA4FZEBT + wylbHAWBkkBVgAWaW8N20ABV2QwriyslKioN7LwmOpZcw0f9y4EUADbnWD2s+jhC1IvHgQCUq8GYIr+U + KKCAa55xjBETw7asqJYFwJn78LkMtAnuoah+mYkRmAVmDEl1s6MFqL402zuG+BbFAZP3kUYymshsE0PN + 4aFcJDWWixM+y8msuCPQskMCo0MlOQ0Xm0OvKQF9AsKkFLNLYREuPCxhCqORWxy4CAEScAFQQ8dFPDzM + +jdOApvcSzVSukrSYwGZcLhDc8dw66YNDIqX/ykfv4TLdHMqQOk4leSSVVTFT9kLaXShCYDCWZwvzilH + W0QZmPPBEaDE3xgiF+AXQcmP8PkXRfk2i/oMPGQAE3nLy1wwBzsBbLk3SfJMkbvGkOKYoaC7vxy/sLK9 + 52HNSBSPNPzNd8CB/hOBnhO3oZqbGKuPDFIBCvAq4Hy0HICAEgiFKoxKV2Q9kZqOg1gpwrOiBZSswjyP + cKQTsIGRiAxL3+uEnjRL5ONIjbwuzPOFBKAlpDTPG/O1yEIsp+ydUOmWYouaEACd0sQKG7QhSCTM4Uo8 + 5vkaE3vNg4wBB9AFf/FJOkwdjtw57TEB32rQdOuAFcCSkBsVv3MzYaME5v8oAIoLveNQOXjRvfwSzNUc + G7BMzHcgCOh6sYiyjxbrxAELHzy8pBnltSkMrE3BUU9ZvYrJmEYygFB8ENrzJ8uppjKktoEzBeU6seO4 + ARiAgM3YziOk0jpUQuIzogawTCy9sR1AAQizp6nEwsQKRJT6AARgAVEUjiQzoK8Tmw91o1GYuf9Ei4q8 + lgCLJaFUURezw0wsgBFoAPr0UxzzAAZgIb+zCHl7pLsksovIt3sUUgshv4XET9ZUCWsquAgJoV5BItLY + PESLuHFDvjxSAVItVQYD1HfjUi+1muRsjgvbFlEoEQZNQPucSTO8qcZDiVoxqBIVjkhDAQcitBYFFp7/ + 8chhMaIU6NNk9a4aDQG6jDftGxMYlIhsLIASiJkl7TCYPFMezKkb4k9psxxejBAJgIBx5TwO3CYoLcZw + 4oy2bE539S4dSIEL0S0Je8H25BbCQoQM2zBGndURGLU7U9NZaQz9LAXrlBANgAEXeLV4dDvr6lR41LxZ + EFmKda0cAL5BeBqAJFQ1A6bCIpMEytlGBUyZfDnqlBEd6k9V41cpq4Aqw0OKYqKh3CYmAha5mwFr1VmO + ci6e1CynjFDhsVDFeh8CUADjmRBHjaauCyjzkx6Cc82oDQgPyJ4nLQa2o7XMy1oEUACW0tCv3aghagHA + Eqwf+1JWzRBY3a3XQVYB//FG6NzPB+RKTxobnLzOrHAwhoouT4wbTISxXpAMWpJVwnUtHGi3eK1XDpmf + RDipiZDGEkgBGHoShLxPgJOmUDrDANrVCTFcFIBDcPsVz1jL0EgWfYWB8kTd1uqAXzsIHQ0eEjqh3RGA + AqCx7oIQDt2kOHnAl8vVwxAoKAPXB7EBGEiBm7FDVurAAwMYo3yAdm3evbqBB2Ck6xtEDTHU6tiLA9DD + 281K3DuuNZ1b/QTLzQXQVMKuVWpM4g0fFKiAwZ3fjcKiEdAsaQweYYqOVjUhxGE+uzUKMw24wnwe3aXJ + w7TU43gqQUs+I9Ee8Yk4ejwBCDjdCW6tndwxujypev8KI+sQgROwgImFELe93B6ck+KKOTrhPTWUEukb + mWT5VSV5u0zkhe1UABdYXhu+sRyoABN4tx2WULl4hLdAgAcQ4iGmVWj7GhBtQGrLRT4r3whxsCqjTdzk + sk7tBSBZAdvV4hvblcqxJ4nh3+klOcTJ1xSoYQnBXcyNF8yyrwJ2Ec2lEh1IlxKYidIZjUwMH7mrAO3t + Y+/yr2sJzbS9y6shk/b6shcA4Q31V8JM4heJxEk1m9+VkoGYAVfDmTomktvsBZxBxhSQAfn95Bvel1Bo + VpDj0ohRiBDIk0Ru26wcYYE1UsQDm1Qg31XWSWtxoJyB2AYuQn1dxmF2NA6wgBX/yLmlC82DeIvCOWWM + GAETWIB7mRQRlibdY7zmyT04MthI6YAZSIEFsJnsoglf7kl6ZIAViAAKOFpx/q4M2AEKaJteSqmJpmh2 + zlcHmAEP8NoIcdv91F2awkXx8NbIk5Qb6AAKgIAFSIAbWjxVeGcHeIAY4AAEZuilyk4XIAyZBAVQSIXO + YIAUMJ9KmdzhEjGuLL9qolsmrpQNgIEHcIATMAJvSABvUIIEUAAUaAALeAHmrWkxM+kYYAEX0IYVIOuy + LgcWiAEPOONaxlYRuy/ejTbHWLrliuMp0QBroAALaAEXiIC+5mvcmIEYkAAOkOCuvrF42AEJkIAJgIEX + 8AAd/8ABbBYO7v2kxdDW3k3TA06YG9iADvCAFwDtHeiADaBpw8YxArmBDCiOhRlS3eXdRz01pUXh0r5d + G1BtyTbt3O4Cevbet77Fyj2FJcZt3SZu2enouD1ie8bcnFK/4S7u51YaBSRZps2c8gCophW7FIbu7e4g + hPxGEdVBuMbF6Hm8A1Bq7kbvKhK/VnE5xCtDSTXSWilj507v+hbqggiJAc7FmjLqd5HrfGUB+xZwD/rD + ZLkcsiExcZyVk0GbGaDvAYfwKKGAFQgUz3FjwayTR5RrxxiBEtiwCAfxv0HfVAIgj34jlaHOmSoAtHmv + EHdxpeHiN6wVuO3K+orAnEqPZ/8gihfncYbJAA9YJDcJ36+BkR0sP1hAADCj7R5ncgjBgS6GBfpCLgFe + UzgyBBOQAU9u8i2XFFxAjwNH0h6CbeYxmVB1gH3i8jSnkt8jQsMIG+ROvBoRARJgkoVW8zuXEBuQANm0 + YNuTWw3HcaEAMzwndCp5jwhQz/SI5f8Gj8kyGRtxLz4u9El/EhVxAFlS9Jwq4VCal5AggQ1bckoX9XeY + PAdQgF4BD8vBwa5DhcsBXAfY8VGXdTmGgcxQT1jg6TGccQ4RAQ9vAfyb9WDnVQpQAQQ4mQAq85NJdgRw + gGAW9meHkA2IARdYgRNIANByBUNQDxJIAChwAdaA9nAXkHi5iAGntvYDGIRNWXETYAAVeIAJ0AGuFvd5 + zwqHroAW+OenEIYMWoAUaAGqCHV6F3hN0AAOSAN60AfBfoEO4AAtH/iHh/iIl/iJp/iKt/iLx/iM1/iN + 5/iO9/iPB/mQF/mRJ/mSN/mTR/mUV/mVZ/mWd/mXh/mYl/mZp/mat/mbx/mc1/md5/me9/mfB/qgF/qh + J/qiN/qjR/qkV/qlZ/qmd/qnh/qol/qpp/qqt/qrx/qs1/qt5/obCwIAIfkECQUAPAAsAAAAAPIB8gEA + Bv9AnnBILBqPyKRyyWw6n9CodEqtWq/YrHbL7Xq/4LB4TC6bz+i0es1uu9/wuHxOr9vv+Lx+z+/7/4CB + goOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9 + vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3+Dh4uPk5ebn6Onq6+zt7u/w8fLz9PX29/j5 + +vv8/f7/AAMKHEiwoMGDCBMq9IbBRgYNOHDkwKEhQwYMCzM2wrCBgwcJMShUoBBjwgsPEzFqXEkIg4Yc + HmDEkFGBhU0LM2TEgIFSg0r/lkD54OggYUKMkBVmWMCJs4IMkiZ14AhK9Y6NDR6S4pzBtSvXpEmVzqDw + YkOGqmjhaNDxggILC29ngAXLlenSpWR13EjLNw2GHC8miPRage5cuV3BlnyR42ffx2BwSKBQ9+vhwpfD + JiarAbJnLxp2UF4q9zLiwqcxV7g71kPnz7CvZOgAg6YFw6Vzns6N+ysMHWdjC5fCAQaFraYxp959+DZZ + DsOjO7GRFXlqw0ll8M7ZO6cHG9LDJ9kwAa5l3NizZ1+u1QKMqeLjD/l7/Dbz3DTRo94PFi+H4PKJh4No + M7DA23ra4UYTc7hZIIMHGwQoXgY6SLCgatspuFyC3Ikl/4MEwEkonQaT2fbVdaWhluB6ytH1VQwvvCai + cDnUFpZTdK3I4IGIXWhfBTBEOKNwHMSg1H4d5qhbZj266NUEOgwpXAfa3cefekmyiB5iDnYgZWxULjWX + imFduJuZWyrV5ZewdVDTjz1myF6cLfbHggxesumZDjIYSKaVycnJoVZ46ulZmFY2yeOgDNK1pqGP6VAT + fn9it6SK7NF1Z56QKuPQDaDeAB4hfLLA344LXmjpYQsqJUOUg9gAqga0VuRYp3XI2pEOHezgwa87dKAD + BzlUBAiVfmq5JJ1btrjso37csAGvHrwggQTWvqDtsBuMimscN3AQWEgUPCXDuRRABf9DB/D1wWdTZ2ao + 4Jb5cVloHxlgNVNdb/XblAzrtvstGxgMZZyaYm11l4PrmuXupFfOiSmjFNvLqR7hvtAnBBy7AIHHIHPc + ggVkOTywGljBMEGrW3WlsFxP8ZSDt3iUeiqSmNbJ45+uXnzHDTqsXOADLRRt9NFHm0oBDBzcerIYG2h8 + o7NXTg1w03ogi5+iyWlIpqP34oEBskSXbfYDaKdNNMcQtMAClE+TYYO4o5GGIs5JvUUyiDTXISm8+i17 + qo4s5rZpHjd0EIMFbLd9dgtlF010C2y3MAOUAMbdhQ0diNRqos3CvLQOfc8habJZ7ix4ejDbC6sdGbxQ + 0+SSQw7/edospH270WnP8J3mXpAHV1M4N5okYlxNkEPNfd4sKKWAdtizVW6KrLvaD7DgNtq5X492Cx5X + AB3wW+DggVvwbnjYjmGRXNYdWlfNdaIcEk6oz3FgEPQMHtc+eeS5sx3RtBe5B3hsBhIQEvlks4N9nUhn + N8NSi54SIzu8C04Iuo4EI2aaw9WBPDahnAB3173tZS97JnSb0e7kmgVeIQcTYB3y6CUx1MSAdH6D2AZ7 + w6jC1Ytlr6pD7GaAtMjt7noC/F73ABiD8blwCmM7jvGUUz963cg7AosDsgaXqXmlaGq5gZYcasS4I5qR + gCZE4QALaLsK/O6JUtCAxsTiNeht/3A5t5nADjIHh1LZ8T6Ei56ZxKgWD8jgAY4boe1KGEACntCMIrSA + 8pwGRyVQCAZlalbhioc3rshgAh2gJBv+hioJsm9V6/FgHDKQFe0lcoS6Y6QSSfi9tT1ABjuQUSWZYL4Y + rCZ0wNSZqrgCA12+4XTb6SHo4qUdIL4ODhuQgQhhaTtY1vKEazTbIiugvF06oTiDASZ3qKikQbGMAs88 + ZvPGdLeuZck0hGwDBnZggf5p856xHOAiAXi7sm1KlN6cT+eOVzwzxYudw3SQB7LYhvit6nkagt704ICB + 4tSzbdSkZiORuMQCom0GOwBoQHkwz9WcR05dW99+qrSaT3bAmP+jlIGYUoRSJqmmoBN9Aw5eEANHUvN/ + 3IMcGjuqzxIWzQISKN1I5yM7wAkOpZfSjf1Sc8M4IBNJVaTT8WY4zvaFzQ2iyV0i2VjLfpqwkUlco/Yg + BwM+LnUINniBdVilvkwxB01feaMbtpgj06jKUj/E41fZcIMJIFJyZPVfNgGotqEasQUT2MtbjYABCZDG + lJzUKjt7U5ilTIChavBjzlBpmeVsCDGqJBgHpAkBfPbTo0nc3j7X2E8XuIACkp0sEeLqoSsG6o59vU+B + crID0KKBlJsVFJZWlB6v4i8NG7Dsx5RI3bTuM420DeAsPxaD3OpWCBiojsT+CNgzjalMMfD/gHdDq0PQ + KUul8srpGm6wgz7VrntEre5GVahd2uqubRNw62RtUF/63ZFiwPUtZoLkBpshNJlYHe8gB5sGGAbQrPos + qn7PFlTtVnOASf1uEYKGV852MVE07Q/JOqBUMzgURam6W1SZi1oKnyG8Fahd0YiawsX6d7bVzZ4bRVyE + HJQocFRL5onpBJcPGbcMF1TSJvXz0PXIF7oTYMFYSZhC/Hp0w9fdsSSdSGQehEZo8a1yiiG8HVPFIJej + bC+akFxa+9XLQek8w05z7Diz2eSRJdQmGoOcYSUC6clvnVttHihlnNLVhw+EGdzWwNcDsQqrldLslc0w + NvtiGHtLXCJ2/7UnyxTabsUt1u0NDCkm1l1xmOrJWZrlUsHQ9kl1zXRvXTmUWj0bFqMFJDWpUThsFWrY + v/eEAAveU2YjhIl48yJtD+HrFOQxTaRgQK55nZdZLYHtuWPotAi99+d84s7c/lQbf4nmAgu8oNlGKJJT + MYtKNScHJ+lV4BmuGuvEWCqqmUbNpslQHCJad6hdXqQZOaruyc0A3EQOjS8PqlVlsvS9eBxJrfe9TktL + uas7g6eNoTaBGSByy7n7c6jPTV20BtrYbkOgvuEthAFNvK4BD3lNkZcTMpfhxS5SVolXt6xeh5uefUb2 + NWHuWEEv3ahIbQzNjbABTOIE1vQGeCkthf8TDwg4DFGOU37UnCq/OhcNN5AABCKwY+wZe6OLdaxsl762 + FqAT20Smzi+5iuTA4VW4OGFaqr3A763KupOYBluewzC3GIDPrI2UZTbT6uGynlECX596cVoVXDPpqH6n + lFd6l+fijssPgpn1/P3OUJwcI/aEw0Y2LZmu36SxgAI7mHoSEhfD0to007BWrmXSO3guiDZQFVNUDzkU + TzCkfXYKX6yxs8vhuWfYdq19EEx1P4TQ1Oekp9J5cstOU7kU0wza9uLpf5+bgX8hmqLGpnY7etYez93+ + kUwg95UAQ98D0qbtd0fMARfohH639idYJ2HBhRpG9wXzVE+vR11KF1v/brdh/xVE+7d7bdF54jQo3YYe + t1EWeIcFW7RmEeZ3W1NtqzcGGVAcWnZE9PdyxcZIsvVy/zMyE7B9GQhem/do/eZtugE9CfgiC0UGpyNw + jrZcWVc4zdcFVVcTGOVyxKZWdDd9gBZU/kQBLLaDSZABOwADdKRJu7Eov7VmMQBxW3B8ycVtl1I1AteE + W4Bj1oRuMshhszSBLtACFbBxXHgEJDIpqoNQ9tYhQycDfPgFz2Z2QTdem6QbcKgFFmZdsEd312REsZdP + tpOHn9WHStBpkQZpBkZeB8VNOAR2ctaIZVdeC1ggI6cFrMRnZ+RnbkNqNbg98bduskU5vjOCOxhd/4GV + GV+zc8DIcwxDemBQggv4b30XVa6yeFqgP4szTYEGd/Yng5+GXdlDAT7HiUbAe/UCQQRlXinYaKVBFutl + fM3DNe4kdAfmflmAAyUHOa3FT7FkfYH2Y6U2OSykg9zYfQTCaCDHgVQ2PzzXTdlWE2z4gz+4dUvRilgg + KWPFPdcDd99De7fDSKL2MQiEaP0oBDmwOMRzPCWmfoqCIlyBe5l3BccHYSQZcEjSgO8oAVrWNmvFWNfl + Z+pWh9VlWxWAhh0pBGl3JJYWSFMVOt9oLxLQASlZBYkoYU8VQU/VjF+gAefzghJZjZjIT/MHZiJEARz5 + kzxAYhcHcJsFgNQ2Q/8AY4zGd4rjlDpJxo4ryAXz5BaHVYlnZYez6GOzVXksxIv9mDiYdFIxllnxRWM/ + eBt6tQWV9oFjmFXhF5dbUFiH9XrXRUC0OINlVWpo5DYUoF5g2QShIVNNspATk4xTxCUIxI9VsJJ4Q45v + WZKPSAXR9DE7domvhY1clnJAVpEPgFRf+ZkeKTSYdiKBVIbKxCW31wHnqJImdWmNhiV/FFixGUceMAPW + w3A3iYv0x3LTVzQV4IzA2Y1HBnLBB3rLaJgNCSJLGQWFV1CcBJXk545TQJVu4T+z118VyEYelnJ+ZgEx + 8JvhyQN0E2mf904IWIZBRwESAKBO4GBLFlx8tzP/DemT7Gkk17RfQWaR1ChqtGg5euSXwNmCJccs48U+ + n/hxXFFVinmAuPaebTlnFhOHWaFjrsWh0tdfscibeKKaAVoEVEla0lZOmNWGX7GgaShTt2FKHqhkfnd2 + kBgDBrRwaVSZNllLsaebjcRsPTodOkAZTSqGIzmaY3iGyzkFbvIW6keOCXgZcFEBufeO1Uk5ZYWPlUh9 + V/hTaGMBXrelTyAZg8Gk4vheCNhFV6MFbuJUI+mifeUibUqhTTBPPVWnFzpbN1mlvMk7MxADasmnS6Bo + ojk/CKprSlKOL1CmUVBf6RM6UIUkXCWVWACPjkRWGYaj99id1IhILpCc68mp/3AVViHJRRG0jnQGJSCK + BEWiGa+pepe2VYhhkFZQUvcpgU83eTH4Y0XTbqXKq1DQfxE6ZeE4WpTiJJ3JoOMRmF40dKvKVQAzc1MQ + XdbZZzVYaFiYmYyVn5QDAd+prVBAX39qVx83mC5qWi5lqk5gPn9aGGvKRWtaGhPQQlYgR1BIqRtKpdij + RkzHO8vGo/paBBsgGucpfgBZRZnhrFRAIRbSnB0oqsijoBxQfExQKkDlY49zi/pISxL5P5fTshv7BH8R + Q4iKcYBFZ8KFS6/aOYi6KE7JqiQDZ1ZgA5YVW0Zlp4xlm0a1ma2FTru6s3BVnb86J81kms7yi3IRglnL + f/+LYyDLxCToChdN5LJLQB7j9mn4qXD4qWE99j3K1lZaGwVFwlLRw4Z/ux1dIXhXoAFg+CPL6nmpgyZL + cX4PKxr3mpk3eYl0ik+M5ZAighEYsLnFOgf05UvLiqDuCShaUQFvRq5HEEWJoY7hGqhaQVydy7GYdK+v + hU3xOqu122XZFXjsygcNkQGhkgHgEbvPYAMvwQG9Yi0eICwcsAE+AQjm842PRohBK5An4hzX9kIb+IkU + p2Ypqn/PKhoWcDTXJ3uVN0v9tV+54x7/8QccoQMfYRQjYRIesAMcgLrOEC4xMQErcxtPQQETIAE7YDJ9 + 0LN/C6auC35fYYhliwQVJQH/nWSYMuYoLOu2liQBQ5N0alWZF1mvsXhEr2LBcaABtFGfa5cCKaBscgEj + OdDAyqABG9ABMRES57IayXIuEwADOzAsBDsHGWAhdXaaS1pvnqQZcmGkVwA0RmI3GFKcy1IXOIE5WLAB + FMCblGi7t6ibdzh5OxYDGktRQxEYMoWrEZACDdAAKWBPYyEzxBsMBdMBgjF2Atck6PK/EOK7isN5siZ+ + CllnyqEUXpwF9GnEYrqILLPCTHsFG2BwHryf9ViHc2dUQjVke0AhWXavLlDGmozCERABmezJNHlDbewL + HOEBS2wgLSNc/OKfKCHCbDAgJXdZdZKykAaCt9e7UzAg/yDhpV6xuoTxQAGcyC90UY1VjbspVFUoi21T + AeCbB973ACmgAmeMwmacAp3syZ1czZz8NkoZDbNhFFWyurO8H1uhExKAEj3sBn/xAnT0VNNGdM4zSLeH + v13YsWfbm4uotG/xZgSMBTnwrrAlrRbrU/h4fy7wADAwM2IDE75kQGWMxpxszRGtyZvcySOTrc/AAW7x + RQPZXAscMHnAOZSBc2wmrE+sJv/ZBYkDugjbrTfSsOkcBTlQARxzfZUniegrrcbGMSDlwjcWNCxQxtZ8 + zZ+czWVsW578yRL90CyQmMnAERZyE+BnRVL1utzkARygAa6sZxAsSOPokm2pHEsRyP8qLS4gERJccllQ + cc5ZHTxERJP4hJFCZYU2eZGLRAGbKgdA00D1NM0Q3cmZPNRDncmEfc0PrQIugEsx/QvR5UuyHIpyHHSF + sTQvoANfnAZeuDImtSNhXcSnFSiXs9hSkC87IMY2jKYk8QLF5dMFW8VWCHPUl3A0KzmtZSqHGAdRcxzg + Q9HXLNiBDdjYrNRFbc0Q8HDLwErhTGcJyRs44ScBM8pT2RYecpoY4pqYBTCs/QT5wgG+UhQwwBM7kAP9 + DBrlMWjVGtsZiqOP55tCxAFZ5gJmjMa9PdFLvdQVfd9mHAFe+dRPCDh/vIhp28tOEczj/QYw1KaD+GqI + 134r/AL/2R0FNvApwGsD0O0EQelKWKi7DZejHxalmJsGJFwbWuYCZ9wAm6zURz3UR23Y2SzcEaACEfBw + Dz4LSuzLYJTg/goWClqKq8TOc1XVi/tQBeoU61LheoDcFhCzt0u3On2pRdNaOTgHkpFjRV3RaWzlmyzY + Ke7i1ozGDzABOlsM+nOy85bjYodiXHETANMBLSwHrUfdNVRKRIjLjNB6jTy1WRmvRfThZcARtEHTDSDN + E83iwN3bRY3UhV3YEp3G7nHZuCBH4dRtdiW9jWLETkESICLaYXBJfptJJhhh6Armmk4Iock7SgfJOalN + NT2ub/AXrEY5Ql3f1DzrtJ7lWF7f/4FtzS5QAXkNDAc+Q15TR8Opx0hiHqDk6GFAnwnMTowINs08CTBU + lxJLqfUoaEYjSXTOaYBRAfAt30bN4ome6ESNzcFd7ihuxg/wpsQgb1dHxKE6bb61ygAT3qPuBUXib/FF + vV5rL3taCSRilbor2wNEq5PD06HUBqRdHhBQ4io+7oT+8PDt8Ctu2Gks0SrQAhJgDF3q34wIqimGrAt+ + Lp8kARxQ75F5sqrolgEoPYXRRJjAJ7SDWJA3kXPqUSyQ0mwQmlq24iic6Fd+5fCN1BUv7kNP7kEf8UKt + AhCgt8MwG2MZTKcZgIpKziMBIs+7Bkb2fYUcoU58G2SKCatWAf8nd0T3NNd0eq83f/BqIC2G9AARMM0N + f+WenMaBjdTBXffAzeXDHfFmDAFkLQz8ihwHBriGKYYgmBMAXNk4YORR8BcwkOSIG9aHJ1Vjeyc7YPKH + IBksYFv6qec1r08egyczXrIVIlMfE9+47uKAvfcSL/d0n/dzn81n7PfZrgtUqUwdaEqBOmt+lW9bnQVj + AzEdH7rWVvuR8JGINKeVGltIo2yeCeI7kGMvvujZ3PBGT+5z/8lBf9R1X+U//9tmrPR4fQHDQJ/Qhmsk + GjHlWb0MrnE6UOBj8LmA6H9K+mowsgGMLwhzU3IxDwSPlpA4fBxbLGQL8qhINDzplFq1XrH/VNtmB6u0 + Ig1xKpIiu8optDpSXqPh7nYETZ+763U1OdVwxThqsgYJCw0PERMVDzV2ZCxmZipmZCQnZS4rJjU3JT0v + LT0rQTs3SzVlZCgmdjYwFmGnbnYoWCA7RykzSy0qYjyiYoWHibM2JixalIuOiIRYlISUIVwsYIKLD286 + aiEg2sz4wMvm9FzgzO3aXNjW6drTyVNUIGJyBLPz9feLZyluNX0S2OmTKUqhTiHcVdDTDAssZlDwkMMG + P0I3PMSggGlSpEgGPUqSEQOGBxwWUaasokNCJSXKYC4bEvOBLYgSTqq00ihGiwYOVJiRR44ovDrg4rBh + k0cpHD7nikag/xdjAw2dV7Hms+HooyhdBTMdDIhJIFmDYxPmCmgBEkkPHLBhxYCDw4sJFaA9ZOvQod6I + E3RsyJCVcLYbOTz8awHVhTcm1CA7mfB2cNbDHjCBaSBU3BwyRN+lO7oUqRx15UbL8zMhZ2HXrwlxA6gr + 4dlSCBmOuo2LE8Pevjy4KmwDx44YpjiKmkRBQocbsKEvwrAhcbRmM6MlmSFBx3PCjSg8+MaHszwzcdjF + sWMOKtI8ntOfbsenAQQYlaPnh80hxl6yvr+6zSzlwuLNkoBASS6gviSJYYccbnglKww00MEDD154QQIY + OJTghQt3CAw//UgcpEIPYJhgAo1SoSAGkv8kkKCVirLKADEZHuijj82G+uyz+MzZ4w051FMHPaTmU62F + F0psMqsc+lOorIFoA5DKhD5aiKAFLVlFxg1oLAwD4nLQgYMcNAjTyTUHGVMDHHLooAMzcbhBTawy4GCC + GVigJipxlDINvvfoKLIpIQVlzI5AG2ChAzYh5UeDlmw7kMAApRxwQN5AQvC33WaI4QUcJHwNgwwyKDXS + VbHI4IZXVSUsA24euOO9I41cR42jjrqDNHROy6PXQsehQ4YcWE1WmFnv8kjALWsbaDdTOqoW1GtFiqE5 + HEZU1ttvJe2gJRZc4FGOdspxJ111ify1tHR/HXKNMvywACdw8S2kuBj/+No0lE0NIsussw6y1F8ExcKU + kwoogGGHuPKNWGJCpoNhhlrTJZRQJNnR1Sl54VsUyHigmm+zBwC5c+KIMchBggpuyTRgr64NuDcqcxkY + 50n0koGVHLpdWeh8KdQBBgsgmGezIdHtWEheTTOqNJJDLllYcPqIYIYdVB4a3wxeqETKZ0n5DTfdwFI4 + 2oEJgoQSGDnwzuu5WZ0rsYvH28zd0IjNdZ2r1dnVPXWbJjxINyiAmG58OYCBAoLRsjYU3ApMWFqxSFE4 + 7Zt96YDUxUFv0gaWZpg3nDvKIU1dpoIUDTV3VAd2PfXUgGDr0CW2oXG8YlaL8rOvTAtAs0EVexO2/5Cv + YLLucG/etZYzmsEnFcbwzA14rnd6SDxC9vUN1QVFnbM+6NmuNee/xUCHf9zGlqPM0ZJWeOLVDvA2Z1PR + NodY0e8/nww8UAHxmK5HR9obYza2Ho+1Z1jp+diuzgGok71Abv7zFgBjkIr46awjvotWbbY0vMtFrgJk + aZ8E9mdBFRJjKxVgh47coQfQCM5W4ktdr8AHD+zFsIZPgQALWLNCcOXpBRTwSMyqFbyzFYhsv/sgzQTC + F4bBwDlCtCIicBBAMIyvR4PqIdMYs5Sl8IqGOmQaOdIzhhS0oAIvUNwVV7WBIr4PQHT8oIAshzCBQe5K + YFmQBWSwg6DBkZA8wP/BBHzSGV95pnBPiyF71iVGqPXqVuPojAtaQAFBFvJbOLDQBMSWmxFiTomQ46PA + SJkcDz5kBjDgQNc4uUIcSMACO/oM1iw5r44NK1B/iyQDYTeoXp4rHD9cRRVjecEs9scWn1AQzaZlqbEw + 5HJo681/ENY2hkmAA8mEIwZeIL0wCEWBR0KPuxzIt+v1LWqKImBoXhiGBkSABa58ozdXtQ3HlRBhBvPU + 76BZFlyIEIROLKEEKohP/22gAmkYymlQF76meK9qpgEZos5lnjMMQQYv2IBCieZJFD3iIR2J4sz2qDay + VS6leFzY5OzBP5CGTgMvyNEti/IxeGbvPegMlsf/fsqUHu3IDxGZyCBnqiwcdACUIclmH+PXKQNB1aUE + wY1RwZTU5mFEBhDg0Xm4tx4aFglI7wJffG5ovT0sigxLswBgYKlVZVXoBY7DRPuqGc2FtFSPY1Obpj4y + kofJNXQcqMU4AZVWiP5SZLiaaGjKKMM0CMUFDwiVR+NKWGVNxzgw20uWoAiwUhaUU//qCrWON4FuapZu + LyDXDKemK441BZKlEVx7dkgs8tBraSyIgQ5SxdqhNWKfk8ump6KquWkeN3hPdVYkerED4XoNAxPwamLZ + lU4E+lKBO22PFymqVnBAgI0TSOF0h2ajDrwgg9DNUhIlt1zfECRnT8QmbiDi/wGZovdbN4iBC4KSy6lt + bDQNpKGtzkoapYRDDSyQgcPOx1+hEccDzXruPxfkQeOOzaXKgWpJESphiW1ABuO03t94ZU7BSTJkjuze + RU/n2w4gVcQTq5AEJvA4p0bxYAnzFweXCNUjPuGeNY6U7hqqgmKtlYfiA2aiZkdR3C7KoZUFJAr3a+SV + 3aAuRrTFLXRTKbYJGX7YQi1fYIADfGg5WbMqnbl8BFRJfjes6mQdAwkYDhUo+QEUwCybcdeysLHFfQHN + DcGeCbCXdtAhFYCBcADNqlm8WYxxjuGBd8q3dGBaUae7Qwt+m9BIL04DHEBRewUKP9Me7Kl87AodIYHC + zP+OOj9ZtMA4OyYPnQbuDa6D8pKTMtnKzoAVkKb1VnPAXs9GAsh6JdjmguyvXsDgvMde0yxureSM5Upq + 36WkJctT5zU0gM+BjJC1+wc9UN7XoNDyimjRZk2BxLra6C6Rm8v1lHYaSd9Ajc9j13qoMzTGAjGYsb0t + mIGlUoovXTmpNElZKTN/YtofRbjodFC6AGfXtob6NrGcFhWsiSECbLRnli8OOi7DoL0wO+2/BqqgzEmz + bKYFpBtT3qQcJFnfE/W4bq3WYtREkDPkrcAOIpzz/m1BXKA06csnfs0SMpvZNXOIDDxAY6V/hwJSmefq + cCg7X952xeaZLBkgAEgqinr/6+leuRE/K+aaS7VKGA4FJHaA8rZfxQYx8KpD2xnZ8BX4xOQxgxhs9wKg + 7R2ORMyxCfk4v4HOPBeeAKQOGJ8fm3JR18H6OZEI946sNeYBWC9y5v3H5S78o5lV/51o7c7qjloc9a/p + AI4c2u93tWvXkE0DuakHAeU9aNa17x+X78LKyWtp7lC834OBa/zXzLJ0uO580HfPumAefp7bob30C8nl + umYQ0VY3kNRNSoEOnB78FmkZDB5Abpy+y5x8w7Q4yBsRnLc/mRQS111p7lLCAm2u6iEoYLX4jzAwoAMe + YM/QSPDWyaJuKJ5aYDuYJwHxKQNY4jigrsOIZ6paie0w/zAlcEAGyqXzyilXvi2ynMCjRhCk1AvHKu8r + KuF9doETapBn1A4BX5DvAihpAmzBpiaxwuGFzsAJHOb7ehCfPAkG/uO0QigkQMshWOAJlHAJVcIGOmAG + UsABzCUFLaldYMjkXgkLtUr8VuQJHS5aXk0GuMkMZWUHLKBkGAxQ4qkO16EmsA5Z4FCuSi169AISYkYK + G6KkJuNz+hArtiE8woB69OahJksMqCcFfOsFOEDrEjGZisOImutTUMFBRDATUYI/wGBeAI+ccukBVKv4 + RDGWTkRDWORmAEkVRgIGZOQSW7Ew5CiDLGCA1qAIz6EF2MJnPErvctGbKCQHdkACXv9kI/jCRdwiMFjx + GPVhLrqsFxfD6/xgCELlqKiRv4pmBzCEGWNgAl5gB+REML4ROjSgA1gO7pShF4BDB9hvHbXKBlzlBt7k + BjLABsbEHqMDA/RxAzaAAwwyBzYAB+rEGAGyIR3yISEyIiVyIimyIi3yIjEyIzVyIzmyIz3yI0EyJEVy + JEmyJE3yJFEyJVVyJVmyJV3yJWEyJmVyJmmyJm3yJnEyJ3VyJ3myJ33yJ4EyKFcmAzSgIOXkKJEyKZVy + KZmyKZ3SKUNEBxAyTYRyWTxpGXPMRVaBArayK19kRcrxK8UyLMkSLM1yLM+yGbNyLbkyK6NRHfmL6erK + 6VKhLu3/8i7xMi/1ci/5Ui9LyEt2gAMQsSoRoRFaAmnmwRGpZzHJTQwk8TEbMzIVEzInUzIhszEZMzNV + wAFS4IeGbzAJawtM7R2pMC9M0yZQ8yFS8zRVszVZ8zVXMzZdkxJ8xmHggiGr0jAfAQI20wFQ4DdRYAF+ + UziFEziJMziR8ziVcziTszmXszihEzmTkwEYYAG80AWqkBVAE6Q4C5S4Ug33AnnEczzJszzN8zzRszyd + iStXAekIMwtmRQZYgLc2cwXs0wEWYAXwcwXyUz/70z4BNEAF9D7/c0AN1D/zcwESlD8X9D4n0QyEj4KS + ykYwwy/OrNXILEOjTkMt74ggwkG2//M9Z6GhViA473MFehMoHGBFN7M3U3RFYTRGZZRFVbRFZ/RGcXRG + 6xM/g7MBZiA4FKpoiqjhBtHqWA3mYK7mOMhIK+cjBJHQJiNu3lMKMIADJGAGeFM4A9QB9LNGvbRF9yxM + xXRMxfRLa5RMw1RFuXRHUVQ/3XRFAVQ4HSACCi76kmkXORG55usgdEaVmAhTZE5mUinipqUUfGaw3rMD + vqALu/RG0bRMN/MnvHBFJbVSWTRMf4J6gMJSJxUoXBRMyRROYbRLUZQMfhQ3nUeO4K6ObrBK9mgAbeZA + kIMGYRUHF2aDrIRBQJEwc8AEVUBBT3RNuTRHibVYjfVYcbRLe/9TP+uTP1cgBWbgUcKPqS6sA/n0VlHh + Bm/1ffYoB7HVBvn03RYmUM3mI1wJE29yA+CvWZmVRl3UTEEVXuHVRulVXtMUKNq0PlMURT1VRv1zKq5Q + hXTHCZ1NhKTwfpJoDV+uIRK21RbEpEClICCBOYytJydlPu8zRl9UX5G1Yz02RvlVY90VTl00ZPMzAh4g + zeBIXQFQ4tYmW80mpfyUBk0r9ujOjhQCJCTBz5JOJ+VwHjJWWIU1ZPkVRTe2aFsUafHVRpe2aflVBUIW + XpV2TZc1RaGWSxvFA65oKx7BvdyHDeHL+RIm8kLrWRzOiaDOIwDhJ29gAlIAWGF0z4QVauv/VU3zNW6b + lkWfdlj3dm/p1m45Vmj31Wqrlm8XoAFkoB5BZ1IaDW31yp+SdENnJrmiivly1n74pAKyzic5oAJUAAUa + NWQLV2hF111L12/x1mpH9UXNlEZJlmr1Vl/31TcdwFGEqEqRASIir3gY1gNNyVU5VHILBkt6QQIC1ibB + hgXw0zqJlmOZtnlXN3qh926XNl+rlm7bFF/nFm+311/3rERX4AFCTIV2UYpsJlbDjLkwVL7ODPbOj6X8 + KAAlwWFCUSbVhwJ400Fd93nrVW6b9m/VlGn5N4C7l4C9FGn3dmjp1n/z0wXUbxqFRn0kQMf6yWydC1Zf + b5RKaUrWt1N6/9fyfMF4dzJ5pSJjoRd2RfWESXdHXZdZo/Z0AfhqG9WABzd1L3VYURYG6pduMOhhDWaE + nqrHkuvHJC7IWMqC7cd4fAbzdLJty8VRozd1rzd2BThpZRdwQVaAn1ZfXViBrbZRr3ZHVcAFKkBxh8sL + PIxs5wdyremIjbRmn2i5BhBnPACCVxIHKoBv+faKndZ5o/h1p/ZFjbZ1X1djmbZfAXeQE5hL9bNR+LB/ + NGBP4CstpG5P41iUSMvMMOz85gu+XgBdXXIDLCBYBfh1BziKA/ddE9l/CxmA+1h6nfeQVdd1W4AHnQcH + +CXiaDZsVS3MpgSVEO2qbKOqlOuO+mJ8cf8yB1gAblW0XQfZi0l2dGu4euX2i/0Xegt3kEs5atcUaa+W + kV3AlptHA/qjFwTqnNs4g4/0klWpfnqMAOXrCR9Ch3WSAx7gN920lOO2bq/Zf9+1cFl3i6P5hqn2kAuZ + gPu3XvnTBaS1f3AZrz6FcjYZSdX3ctO5clRtjvUomHtjnkG5JXPgARgABYRWcE+4aNVUe7MXhakYkPt5 + oE35mfuYm1d4eRnagnA5bX/3a/0qYovHbOvL/DqR4uxlh1+SA5bZOod1bk/an126ZFmZektaZAl6haG6 + mbXYn5fVPl2AiSF5T+RR8sRW3sqMVisZ9gg1icjaiKHQIzY3J0V5S2X/maBZF3ZfenBZuX+VNoZb929n + eWlVWVn1s5YTjmCdhXIv12E5mr6KuFVPgVra7XytJZBQdSU1QAa6cKkL+YSxN6pdd26PNosJuZtJ1pmr + 9mkX+W7BmAWOF3QA6HGEerFPKkEKVYlyELQGBGeoRHNCqYR+q7JV8gZgwKvyWZ9FV6BhWqCn14pr2IWr + GZFReK6jV5BR1A8qoLUXR30cB7fXOGc8zH29Qn7G9ofLBoRoO6A0oS1cUCdtwANqRbNL+5RFe2RLl6qx + OqVHFpWjtrmvWGm7NAVU0ajnhjqOYzZiNWbluGY7ue5ctYM5Ga0XjWHXjic5oKu++ZmnuEaNFqr9//a4 + OfaFrXiPETmBrfeGtflL+XOMZ+AF7HhltFuKgKev1obDJue+HnaliHnyLAW0OqIX1nuEd0B5QRe/a5rE + /Xq+BfezbVR0X9pL7bqVBTmawbcF7mWFGBeJdFkt5C6Yybr56CdJv9uv2nkTHOytKdxz83OP+/ezF7ml + /9e//bquaRTEWTebr3hf8/MBOgC4J8wRILpgl+/hym9nRsmDMpqqoui32HYCIoCUu/lv83nER9fN63y+ + 87W+jRyanRyl7fNwZQC7m2cDXubCjhjMV0qX9TTeUslmIXtm/6nRTA8ot7CEu1d1ubiKo7uVYfifNby/ + VfmQsbmZrVMFxLfFvf9GA7f7wT3wUtJ4bK3lcY3nkifuE0Sl3niypuYTP290r7nXm1vZlB9dtMG420Mb + dRWZZPOzAVpgAkDdeZil4XhZACk6wW/VnWV8oy2ak0HBXHExKNXVJ070e5+bqf0Yb5t3iqFaoXs9gFE3 + 3A8YQFUgkx4ZjrII7pCohMZcyCzZ9WT2UszitmVWfX24FzRJwG+ywiOAkdv1Xus6qlk4cKd6oFF60gE6 + 3Ks5m9Nca6QrlhCD/Ko1eHcb0CN6oon+cozrUHvWJxdQBlpgHg46ny/96V++pC99Wb23eSN9qWdXj+fc + C3X+o9HH/4aUlQ5beBE26HfM7K01YQntFyBkSnn/wAZcxoV+VUHTvHT1mV4zvG5HdoEDGEzPNG5lGk7t + 00SrARDA3n9spIiQB+hje2fUnqfluRvbnW13gERNNGh11KVtOG9NN8Nj13tD/59lmD9RwEdHJam68zsB + MCTchhBhP/Zlf/ZpH/Y3QRW4koqS/j0zgBbAoBHZ9UCFf/iJv/iNn1k3rgKBITQ3QAe6oFmQ58vSc/qp + v/rPU3ddREbokc99skKcsE+6EAWokzmdMziPs/zP/zmfE/3Zvzir81mboJUehvutiOlOzQZdNlttEBP4 + HwgqMmGlSBwOiUXksckUUmCvHQeH4WGz2i236/2Cw+IxuWw+o9PqNU/Tgcke/66GSkW/2/P4vb7P//sF + AqqkuDzMxHhsXLE1Oj6S2eBscHR07OhgWmp26Fx6WnZqcoZaemZ6knaWsraa7nRybGjYQNre4ubq7u5m + 4HB4SExQxBQbH08cxwwrNzsXMy8bRz8rU0xIvOhs3PB6f4OHi4+Tl5ufo6err7O3u7/Dx8vP09fb3+Pn + 6+/z9/v/AwwocCDBggYPIkyocCHDhg4fQowocSLFihYvYsyocSPHjh4/ggwpciTJkiZPokypciXLli5f + wowpcybNmjZv4sypcyfPnj5/Ag0qdCjRokaPIk2qdCnTphg1ZJIAYwIUGNk6LHI6z1cODjo8gMXEoQoj + rf8xM3So4MIBgxMJRoxAcGKBAxUsXmgw687GhhcVLDyA0GCFiggQWligsAOH3pYYNOyIwcKBAhIGCoAQ + IGBAgREHSixwIcODlcbnMuTwIDmFCgcoTphQwGABYQgVYHSgZfokjhcsGqBIYLlACBCZP3wgQCCEiM8M + HECYwHh3uAw6Jlho4ULFggUoXis4cQJF9xUNDN3mkIG6SA4TUiQoQMA4fRAD6ts3PmA5CQcU8rLHCwY7 + WABcWwcykOAJBy544HcNVNDBegFudAMHMTywQAkFfKDZAB8MEOJ9BNxn34eaCQDCASjM0AGFuWwgwQMq + gGeCeAzieIICO9q4QAMsxLD/QzcvWqTBBC4wgIABIcxXIn75zWfifR8YF0ICLXBAJCQawACBd20tKFuD + CjIo3oILolBYCzF0UIuWENlwIXzFgeikcfPheWeU+RnXIQgKzJDDm2xk8MIDKOw4JplnJuhgo20likIE + Muww4aAKaeDBDCkkidmH94GaX6ih5gkCiQMI8IEBDLCwwaVoZNDlCgzY2KiiCb7WKAoK7mrmgubZJgEH + br5KkJERKDDCniTSl6ezd945Yn0fhsDAC8WawUGGDOzaLbfcjveat7zi+uijKkAggw7YBoTBBpqmYIIB + qCbXrKn07edkk8xGqZx+HZIwg6vshnGDBCrsiGBbu37b//B43DL8KMPi2biCCxXssIGlBONTaAsajrDk + p/eaKi2/JPcLLZ4hImeAChQMzDEXGWjqwI2OLvzwwr0u3PN44TIQHgoONBCBBRNwUJbM8+RwpAkhdBiq + vSTfm/J+VWN9b4ghIKDCBEtz0cGmC9z8XbnfAg2xrt5G/KiOClgcgw5Kg81OBhxQ0IIKCYiAaqohRluy + 4IKTuK+dpZ4KQgEJsLAx2DC4sELbOU7eIJqWR8xwrzqa8JwLR+dWt92+MUCCCJ6OrLK0VdtJ9cpZ/1tA + CgCKTgFlZ34H9MQM5tqr2b77PPlsK0AHg6Cin9aBDBGcwOHf+g7e7+GDD371ynj6uf/CuqLfYAEKteK6 + +8Pjkktut+d/u7kCFUOgGO3IgzPgpgyUoOynq9dnOOtNst4/4voJgAAo8ADyNnCoWulMbRPzXdrIpzCd + PcxX5ElBC2YggZjBbxc22MEDGHAAJukLcPzKF/WYhTKTre51JPITAyjgOILZoAMQQNStgNcw8kXQfD0j + 163EQ5foHC+DuEhNBRqQLPsgx4QnhFKJlJPCq7lOZVgjUYoAhUGO3eAFMwxP+hqkuZ9FrIEOG1cDGfU2 + GzmgBRV4ATeECAkdWMABCVhScUSkJ9g1MXokDNyypJgnVBHABCzIEthwIIEI0ApXlstZw8q1QNy1DYI7 + tJWDhmb/NBhMx41quIEHWLCAEYAAOYCDVtYSJz2q+S9ahTPZH1Nkgge4CGwbeM/3xoSm9CkSeDr7zhe9 + lUBGQpBHJ1DBA4xHN02KYQMw+E1lPAWi/JFyWSPKYyr5mMeUmSqJJWjB9pbWNE5x0Yzi0qHmyGSrMD4y + c2cTT3gWUBgLsGlIyAQDBnRQgQWQgEn2ctY0pTdCrJEwZYWT4j4BSIAEPICQS8MB5IJmLl3tMILiGt/4 + emZDXo3PbAgaUxpfkMl5biFOMfgYAjKzGWqejGTQ8x9Kp1lCwmnNlRZQqMw0IAEI0EqiEgWXOiFavgWW + M20Qy5WCKJaAEzTgARPwwPtAeiFE/9avAHYMIcqgZKpTknKJML1qyaiJRAIoQAYf5VgGduACGjaSfMKD + oC99F0mNsu2cRUWTA1KQrh00VYg36EAcSdCkUVbzZKuEqT+32keX6qdkBOgQAU4AA2ItTQctSOSiFqgr + MLKthubCoQ3HiUswtcUuEhgr8nqzqWQtVpSl3F/0oNm/xJ5SoPYZoQlRFYIVxLJuGrDAArg4yV5+docM + tCwYb6jDSQYtUuiSwQvUA78cyCAFCvhg4qqK1T7+04T8GijhXKrExKr0AyJIwRVlhgEZ2Ax3jBTXRdNW + UUcKtbiNdO9cH/VDC+wAsjDEAV8dsCF6UalUivVja1WY1az+b/+K/orSfbjWghfKDHILQBA6H1rRC3cL + s3IFrlB/x0sFrW8uDbAAGyE8KBzEwEsIGIF86jTFwzmJVIILKI2vB+Puqu5UXFsBBTLYgQcARzw8qyh7 + JVY+i24WXDw9Gw8n9xrc0SUFD1CMiV/UNAcggEMfehKDZ1yigKrSsNG8JhS5O1h8DUAErMqt6Lj0gFnJ + 5ndk0qhwjatOtiYZl2T0rLnYiYIUzMAD8iTS3SbQAiw776RXFWzV8PSsreZ4tihc4uuk+KEPHMAF+RVi + DmKgAh2ZcYy33Cmp9wzcnNnwvTuFVGwWEAEWwIADGjimabgEgRNYJgR1lNq0RDg1gZYZit7/RWVsobkn + wO3HBDGo8tJkSDYKI5mn6EufA8dVZAWOsW1xjaAX69I+HTCbKfWkAHwWm6LWETTMCdYugU+4bj+iMDkF + KEEEuilEDcRgLaBWVAJ3R8mIepbPqD4ncYHn5DMp4M9rLK9T8MapEvQNOXxiaaX1aNg9Dva7A+Xno1kW + wAS4QAL6zWAOKMC8BISz36WOK7Z/+96d+RSuwXPbjVYg5dEMuik5sIAH5WNVAxM7sNE0Nkpf+1rEgeo+ + B0jBC8JdNw7M4NM8jHb52LrTU0NUfOjsdy4dNht3PkACThdKWVnAgHlp5plJr6rqCjz0fFUamxl/1inX + bgATREDkIM0C/97W8mT14o7rvOrpT5csUZnfWdoQlWAaJxDEpGBAAg1AgAjoNHGkKxZUKa3xmCN9Zv5x + HNmX5gyrhrV3LRjs0OzEnIXdWmGYo62tTPYZwZlM1LZFuQKPNwoGZEgC1YKXqnuaYtulSVj8pHC1xzaR + 4gxAghPA8vRccPNgJrzI4pLRkUzOaLSvrn3LKp5ROFJBDBguFA+0oHlpt16jXwz6ZhU9pQymO1UzXzXk + gKgACEBB+2gq/SzcgA5gSAqQTaIsHs+gTZMlkBfVmeGN0y5RXSSx0wqsye4JBQ5AwIYklsm82PFpzSrF + HR9ZnJ400Zd5mXEsTgrEgP/93xZwUgVEwP/fzVy56E45ZZjZKEquvFw5LZkN3uBmOUAETMDY5cQLMACH + XB68tZYIus6wwZ/WwM7GaY1qFcABJMAKKJX5tSAAdoBkRAB3yODAFZxcfV/4CI8DjlHsDRkDLcAgFQUH + VEAChNLqaF5X7VPysZv82R+wBU4JhQiKEMABrACstdEWikGcwECBIEpsyMbsGVe4fFGTuc0Pstx7yZka + Bo2kYNJQ5EAFrMABMN+MGZsfZpcJWtPQ3aGBaZ5yiIAJvIwWGqIXcBILRA4uldrgbdgNqZNbkeECVg6f + 3YgDWICgCcULNIAGApZ2CdakWdeA6WFsCZuYkUgIkICkWBAs6gKtaYn/dUiADLRAkFFbA8acJHofLgIN + JCKZA4EJCkCIBfIEBTSPlIjiNXUeVlkc0i3janUXNS5AhBAhJKCGDniCrMkEanBADnDDyH1DjChi4ZnP + qsWVDebSGWrbqnEfmkAAAQGFDTzAAUgc9GwcB8odB+ojd6kUSyXdAISAASAAA6SA7oUDBmSABuTADsAA + BcyABViADCTCNmSANorEDWxAJtwkMUjADuTArI0DJ80ABKjACpDNjdySwWEU+M0ccE1U16kNxEiSeDQA + DAQFDkSAAfxN8Q3YPcLbYTGaFPITAKXIATCAC0yADuRcNl4HLTaAA3gHqHELYUTAA1QAU5EEBnDA/02y + AAS4QArQQR2kgGEgBgV4gDvqwg1EhuolipAhmRhtpbUdVyPBniT2mQL4h0LmBAeogAikCp/806+x5h4h + GB7So4BVSWcM4g4A5S1sUBGZgGWIgAgYwOn0ZgH8pgGABgRsYkj0nlqQjQkwZ2yYQAJAZ2w8xwOsIGnm + Ag5MwIx8iXodmUVelOyN07Upng2eiVuswAyQVk7YwAs4AGqWYDOaGWxy1UAFWx+JSkpuBgEYgAIsQHR0 + wG1CAgY0zZslS3E02rIQgAg838V0QF1ixN1IwKYERwmQAAJUKAJYKAlUKAmUgGhezAWJQ1/EAWsEDQId + IA1qTi/tYPjkYvDs0v/6LIAFSOZNxMoCoCaVPBF41WPyNSEpBh0SpcoIoEDY5ZUG3VRlkMABnE4IFECT + NimTOilzGMBnINV/cETqcYeOlEACIMCWJsCWgumXfmkw4tc4xEl22kwCdA72adt88aDE4Nme6RlG6Ugb + smBOaAAFLEABbEbx7UdbYh40Kt+kiUiDCScJxOimVYcHuEACLAdxOGkB9GZv/uakng5xMGl/lJ9GcNJZ + iamXQmcJPCd0RqeafimGlsB5tsk4KBMLpMAKSE6OdB2RVV1nxZ72PZS5wCgL2KZP4AAFoMCNShoqneKw + UlofLqH0AOIImMCPSEAOAKgtYACjMsAIMAmTBif/pVrqZfgmk14rS64ATF6ErS2ACaBqqI5qc6rpcz4n + mHYp3LDAf46DdcBAU0rO+sQZRYEfW3FWn3WWvv5MnfLqP74Evtlon4og0P1PSiWsEiLbM43ACUAAXpSD + tpRApWarpF6qb2rspEaqpDIHA8hAtC7EC7gAbISqqY6qqJbqqH5qdJbACbDAjO4CYaYYjeiI2zzih1Vb + GX1YtsEcDprAIMprT9iABKwAn1JJVdUhPg5bxuEYfbKMqYhACUgKxpDsLXCA92BGk/rm137tZWiscHas + x4bICHyldS5E7x2KhZaqyrosqX6pyzInlx5Af8gANupCjMTBYPydLfVr8KBT/4VpZkTx50z9xLS2Z2pG + Y1u+1LHa5+aplghI7ASETjnkgCeZDpRyLKVKasdyq6ReRqUSR4IqQARopETAkQOYa5dGZ92m69yuK8yu + awl06QlMioN+gyR0AAVAwKzw5Tn2ztp4JjDK3K06DGysgIwChQ6kgLD2U9SSpNzlD5hFy58mKAkwwMQS + 7C1MwAIoKXFYaueCrdh67vl+rgGMAKDorkJkQAywbruyq8qaKsuSqvyma7selQuwGeaO1FN+2FTKFeAG + 7W8d1y6ZpwwUKZ5CAFku7WxNDX4Iaj4OXWqBSCs6AAsgjdp6Qw48wIZ47XCGbedyK/lirKUSxwhEwA5I + hP8HK0CXzi/dyu3csmzdvm27IsACKHA6WAh2rEVyCQ2uFplQWdTPuKnX6cjLZK1MYAALkIA8PuMfZRcE + E5aMiUgBmIALwIDeesMGxEAD5BNzeK3okjH5Tiq3hm7oJiiPLTBCFEoECMfsxq4cr+v8wmzslkAJbC8M + tHE4xFCKReX1tddbpRXQXpatpIAECEUMBOsKgaTQsVYe6senEEAVWm0LSEAfx88hFShzaKsIl+8IjzDp + nk4lK0AL9KpDQJcK2G6H0i/szq0Mw64dh6oCqECZqgNhToCrDgaY8Fud/WDxZtvEjEca9W9PeAAEmIAI + MJ9sSXGO2gsHnsgHLM4tkwb/B4MDDrBAsmwsGgcnGpPx6JIwCV9rCajADjdEBkyAl3ypqMZuDM+yqapp + Dc8ul9pIA7gQO9xADrxAUy5neGCmEc8gqj2gWt1IaMDMBU4AGCch/XEcQQGqcYhAAgihJo+DB6jAkmxs + +QonR48vOKMvc2gvBNibQuxcmm4pu8bwK7csHaOrmMoFSb+DDlBA5Hwn8UokD9KZZ3mlDKyqUGxABZjA + Yn1gB1LPKSbdM4mAXPyIR7kDDlRA8yQoKHvz+fomVX8yCjdHf6SuLtiABmxADlxCWHRAUuoGL+gAkjCn + 68rzDcNtW+cv3Jprs06ARYsDYUpABQgG8BrgLxV07XHl//noCAq4wAu0L0/swAr0TcM+2kN7mShVrX9c + bjvg2zFGqraG8hl/MtlWamd/rqSOgLXwwrvg5DfqJfE0QAXFwGjxQgc0QN2Cqkqz9ErLdtzWbwIMqQQc + djlIQielwCIG8cCtE+Jtpa0sLxfnxA3MwNlVV2GdpRIlzojoZ0tGQAzYNTm8AHwcAKR6LEiPbhmT7Rlr + bAkH5+J8DS64iweoRQOUK+UBJwnwpwq4AGSmpyO8gIYgAKnarzzLssrut3+vbMwuADfFQwyNqGtQ5a0S + ni22hY+0wLUcBdShAJ/2KQmJ0HtqjcdtTQ4rFbjFQwbIwAmQ7niLrlVjddiWeAmT7f98kEAM4AInWUAK + sMVzrljI+GaFSmddWUAm48J9V6jsquss0zM8y7E7z7Caeg02lwMG8BeGAMdlDpVG6ZTLwcaAUyxSZG4J + WJWOEl80h8hydE2gLDE56AAE+JUYezLopjiJl3Cbk/ikMgkC9Jgt2BSyaGiGHkCeH4BnaOiG3u0JhNx1 + kwEMoMCPi+n9tiws0/Zb33Eeay/zzsMsGsjNKIycRWJAM8BX7jZQ7IAyL0mdIFttXe/IhACzroBxIrc5 + bAAFJO1yiPdwpvhmYzaKgy3HGsB8IICLP0LvpdgJjAClwsWe3+2we4aNV6HEsomSjwEMgC8Mt7QJ7Lcd + Szv9Ajn/dFoo3h2nPATgLq8F8PIOqZVJg69Adae6T3CADIBvh6yfi50Ky6i7AIRACTTADAhJPdgABezN + ra9k2YrzOK85rGM2rGNqvJ93I8SK6iGAsHtGnifpsGtonsPFCHCoaBrnpo/BfbM1mDKnkcMyf7c0o7tz + HpvAgCtyPQhoIrpAb9mImRyyEe+IbNiFYWvFBszAAihJ5fmLlIiQcjDHCCRAA8jAncIDB7iACfy6k9r6 + +Xr3+I4zrZd3ASgAWDbCtELACwd7kvb53WL91g97nqtvTEN4I2C07LpzbSd6ka802dMy3FhAfb+DBvjF + dkCldxCzRZEHYaQAiVk8UQzob7/F/2WEwDQnR6kjgIdakNu7AwYQOosB5+cGvGZvNsBTNRl/bmiH/Rrw + VaHDxZQ6/MMzfNdzfchIfIyWdBrsQArARtwu+hzXMJHPsct2aAocszyghgTgJATI+HZy0d0XxgPIwARU + ym7YQA7AQIY8Jwn4XCWPgB7nPWnow9aagOPL+m92dMCDt7+fb8+XgAPMvhnw1Qq8xcJrPdaPf58//PkT + ewI4wAyU/hlwgJcoQDunfQy3/qLrt7SrNI+VuzqgBhDAZpCIaoU6nVaNCIRF2eF4U2rVesVmtVtu1/sF + h8VVzU7GeqRUC9RilWpVJjrb2H635mQOkqgg8gsENPgzECEc/P87LDxsLDA0BCwIKSBhgMjB48GpWDEh + MTg4IBklRSglTUUlYWU9MCAxcZDR0MSZaWAoKUlIKDFJMAHuBS7uDSZOFhZGNh5mcIGR0qQW0+iQiKmo + QGuxoIiB8cjBqDY/R09Xx9DA2eDQ2ZHvyMnRuFHPt5poSIgsBAgJ0KBFkBgJMtiIEKUEs2rh6RChxIER + olqNsohRlSpRHSmOKuGCg6YMMFqsSICA1zBnv44xa4bsWMxhzRQsaPFC304eGDLc0NBuw9AbGWyU45lU + 6VKmTavdeGDCUSBFiAoCHJjQQMJGAwsQKHCihQekdjJMQGFIo6uNGt22gitq6wIYZe1wqKD/IqVLmcaC + 8XVGbJkymsRWVKjjVPFixo0dPx5jw4OKA5S8JsIciaBVzJsfOQIhYkEMfHh0WFBwKOPaVKZQjTq1msQI + QCcsjMRj40UEEyp9+XVWLDDMXyx7uTTxqwSCExBwQ4YeXfp06nYw7LBwwgCBEIu8d41EKHwh8Z7BP/pq + IIUOTRtiuFBgoOJrtiROtT5w36J9jfJNuJjgoTtyiAqBmQgLbKbgjBMuJl8UUCGGTKqjsEILL1Qsh04Q + EKE7qxgxyJDPCsoKq64WKUCRBFgQ0I4OWHAggREqao0/jljRL662KGqIhQ5IomABYVYCrjBm/DKyMF8S + QAECCVrEMEop/6ekkgsJ+BAxK+84O3HE7xCxSrMQCDDAhBR00kSCBhQooaIRLiIFNvpKyU9OtjpiLgUY + qNmBhRUUQMDABh0EprhmEjQumSVNYKCFH6uENFJJK9RgBhNCsEwhgtDT6jyBvgRxTAQihHKMClAoIU46 + 74vTFVZz3O8iikgoYQEKqMlAAghQXQkZlwxtsMjgDv2rUARWmCCxSZdlttmldojgABBSBPXELT8D0zww + AfrDhAeew2MGBTyC007+6FyFI9YQYGCGanDYYxcGg0k0ySSTgwmYUxhgAVxn/wU4YDE4YAGFA7jTcltr + B5JEy6oIsnYEZKvB4IESRJivxh3hPPc+Vv9bJUUBC8x5IQUFEBzuXgRpqinVExqQYUKBZ6a5Zh5uCBIB + Qg7KNkSFyttK08wSCeWEB2TGo2IECngzrjpbYbXO/d5a65UVzdkgrxOUDAwwYllC7sDkVmIgBQmUtTlt + tSPloIUSNJsKbi0RUgSrLD+cpIASnMyA4haWfhOjHDc6V0e4TtGPtqvN6cCCBfZK8KXBwB5uOEOJQcGC + DdbmvHMMMbjSAMsECu+Q8n4G8SrTFaFqABEYiKFU6yxmGkf6Xo3VTqlXQWAEAxB44JwMPEjBhAN6NSbs + mo5UOdi/DIRgB8+npx46DDxoQYExJdn52hK3/B5ihVIkP6TNzcHAbYz/Y2vrxlRie8tVjA4QoYQH7NLk + BsflXTllYZtHBq0Ow57qFdCAS9nAA1BAgq80zA+ng+CmwOM9qgyCBAuYAdqoQTtYrItOh5uajVxjO98h + gAX408QEUsCAeh0nZcDqi0zCloxdlK0CsjtgDnV4BwmsQGeTKJ1mwkS0TQ0RTAahhCUg4AF0VKwEtXNa + KTzWkfqgAneuqN/90KEDXOgCOcVhnnDCGMNldO0lKIiA9Ha4RjaG4RYJEMQDGTbE75AIaA974CQIAIIS + RAAGpUGf25gmOCvKBoTtKyRt7JcODLwIBQggwW9iSCgjIYlliloBBfrWRk520go3kEAKKtOduoGP/3Qg + OkhmUOkHEIBAAZpkJO1GMDj2OY1wtZQfFu2HQk2Ajg+RVJBgJlmoeVnyJcopgdE8AEhPNnOHkmkBAzrE + ujAdZERC1NZmJJGiEBjAAUyM5RMDd6cbSXF+U3ta4n53QnVwAD68oNdKlCfMMS6oWPTyxS8aMINHOdOf + B8SBAjlEiT9UhWfeg+BBvcNNERzgBCyYRhMF+aYp1ghWGrNRukiRRV7mTwYq2Jq8iolPMlLyN5Y0UNlg + +U+WUs8DKxgB+b5HTfRMcDyemuMkQnCARoEznLWbH9TWErWLXgRxFPld8PKhgwo0oDfwlKT/uHaomvxl + Sb1QgAsI2FKuqq1SCv9oYCICIsfzfO+m46PWJBDQgD/mw4lM+xj87lS1XKbTIorUojqG9wAG+GZyhPLa + PS/nwpYspwQqqEtXFUszDYSyBNvr3mVKZ1OeYcuBXinAinBIjfSJ05yFFCF+iroK+i1SHzeQwQp28ZJL + HmlBkxvU8vK5gAfsYJOLxW2zPACBExwgrOP7h8J81inU+YFaB3DAnvTx1qZlxBWssavGYJNREQCvo9Xw + QAROwCbZpmxlB3JhM/iyixM4wAL9zG16IZWBCjCANuZJWOpARTqhiQgsF5wB0n4aOKLS1ZDPvShFqpvX + fOCAAinYmkqQJFUGlRGfzhvGyxKrXgpPyZ0kAIv/QTVFx2pt2MN+4I4JWrCD63J2ohaNVWg/+DTQItW6 + POHADBxgWAYTdp6KQhQxlmObiFbYxxS6QQwWIIIBdAehqetZwjx8SjIhS4P7LRy6QKafwa24FDFFQAuS + opsIKACY93Jw5Zo3jIkkIAIvePKP1eyYXPVjmnUcX7XuSNnyUKt+ENjqcmWZO/oUbiNXhOT8OJoUHFgA + BcS0FwBrXKhfrOC8a4Y0ZHTQAuMZV5twu+lZM826RXSzBJlMs0TFaVRz+lmEzg2qK2jzYp6AzgVCgue8 + SjrSGv+GAQ6owPkiveumYGACC/hHV8Y6WU1/mL5fOcACbqMU5rqGaq9xbkU//0uKAgAv1OhwT5dpBWEI + P3iqJyWpCbLqU16XmyeFvhQ146zKoQnXS10JAQhIEL2lMDdqHFMF7t7CPozglSkxPkGg6slaRUeVecfY + RSZ7bG6Gn8PAKsAwARgWR60gub7gQQR6UnQCCpT4HJ0dJH6ie2+N7kc/9GO1UiSgl8sNa9GCgYlMJAnJ + Jr1gsw3HeRjUZIIREFSOFa9jTb3SMyGSbwQlaIAamS3LQwaVNeQkrSpW/YBrp0MHuzoZgm48a5kPfBcI + UMAKaptzst9BAw/wR/eqKedPBS2ISu5QdZWt66Q0G5dwiUtsKlrR5w64KRo4MKxL2loAijd54s6kx8u+ + +P8q7EAF27Hz0OKcJWEDXTyPIARYbKN0Zp94xfDTu3PLaZHEDVjx5+CADIoXa0XhWJLDpMnWk9kCfzHe + 9nmYwQlEIHE7p5LDw8Vj2w8RAtcl3SnNznfu6rN86eJnwFVXhw74CtVhFcvBgwd315KTgAZMYOG3v/0G + KNAABGCqbkWfGwUnT1N4m/Dm69jzvXPJESrHD35TV0wGKOCJQr2eWH0pBmABIzJiBgNBgQdoK/BTwJKR + kbxBiEvDFi/hip5hhBQxgBJILsUAuXF6DX57H7cotcEpoRY4vY/bgRZYgJMxFOXIMYP7P2+joQQoLx9R + QPDDAEshH04DOg3LJuDCDEr/OJYK+L66k6Urwo/2qZH/IgUsIzCmuAEY2BXDkjlC6TbAkC16GYxfUIFb + qUHb24BoAQEjC5+32xY64oxMowQFeIA8YwrkoxqhOqQRKiSMML3FyBqWg72pEqPqcy2YQIDMGcIuNLcM + eAHKmJZSisC1IzaIAbptKgAUmADG2EC8y6haIhepOUI6mboSTIfdyDoyoxxKWjCuSx7mqC3oE8Q1axwU + GIEMA585ekXLOz+xKoQEcAH9asMiFAW5AhlzeTppozb7QcUC6wQF2D7lObgi8bbKGYwHgRlcTMVdKwmn + Ep3Is0A564xF5AqGSgA9GUb486wqCi1c4h3R6ze/k8Qd/1Cg7UM0e8kx41AeFSyBsHuAF+DEaMwtDTgV + nRHDD9GWYWO/zviDMTGABZCBQOy8UfsgS8yd+iOtk6tDxgAlbZunRCEmlsCXcDs4HVMABoiACbgtfNy1 + HKA03zEyLrEb8QEfy7om8gmBvam9XmO6D/ygvEO1VmGxJXw+x8gBQ4Mq1mqQAfSumHOeYAi7GXg/kVQv + DhClL+Gempqsyauj8WAdnpKBb3QrXVSV1nBI5pOV+iihJlwMGFgTREOUeYEhWvMVYOAXhFRKCtOBxyMl + SwuEt5PKoVOdnUmRETCBCCC3xZjEX0QncSQkOBSwLIOMF/mTq/KLisRCAlSSZFCAFv+gu7dUsw5wgAay + GzzqjBPZCsu6qa8IgbWiALdculETIUvEt67EyTiJyMYApWiiMYwcuAa7J6nahVu0zEjrgBUYE2sqIsrK + S8mqingrABMQQsiwt5vsQBAkHNcovZSDTRiYsUgKRaDsn2XMF3pRCd3cTVVcgQKYFvgqw7HSprzMwRAY + AQfgvMbYQP+iSTjUkQBDObFkDHcCFIRbHuSoTap6TGPozpj8zvTCzDejvGwhT2PjtOOazKQ8TSiykaiZ + E2cbnDuZOqzciRvohJAijpfzn8jhBUwYUDVjSt+KLwiEGKjMRhRRTwXQk3vUM3GSq4UszCirokDDIhOC + UX3wABb/ACnqq6rIUUvtSyaIGtEf2wAIaBOfuZZToq+CCBrvwJRRmYDKdM+JShc5kTKQ4cpVOUfpdIwb + wB5deL1mpE16msLt/IWbmAFmOtL0KrTe+j3xWbtY3BJMWRErdc+ZZE3QYgtetLJqozrpCDLVwk49/K7r + KwYG2EIHfVN/ArwZM6IKdEqpbLuTRAHlio7l1NI7qbIKrT+dBB7q6IDVS1PDk6rblCEFQAEXkICQfFTc + soETPIERGE+h80wSgTOqpASHOprpeM/lm9ARAqGo2ygwfQx9dAAGyCd8cblKerBmnEcVqAD0itV8jAEH + OBhOsyMTwSZOMS7LUIAzg9XHcMMj/4SVk3OfwjzMQZWOWYWR7cvOofzPBFBB5ogACXDTa8UtHXCB8tMw + oaNArnCYSVjPCdhXc9XKurIdwfzTQB1V6rABCXinRck+UXS9rFsSZYNGflWsDGCB1KAWMrwmRuSUukmR + vbFW6zkx+ZGyLPXAPzvHXaqOnkQBjXQQMAvSZYiQHfVYTnqBfoisgNy0idsmWEi86mg2TMQ7L21NwqEi + UdjJ6pAA7VLBi/yai32wlZjBlf3ZxXq48pO44Uwo1BGRJFqACuhYhZXRhuxULmVY3dlECtGAGNCu1WIw + M81ZA1kAFvCAcv3axdID3RvPT5m4JLuMrzhOFtBTlg3Hjemz0P/r0h15TeoAPJSIJCIhsyWBJ75gLcMy + m4QN3MVqm3HRS5m6vC4pw1AwAQjw2k2dScP5wI1p2On6UnelEIJJQaI81NhzIUalhdH9sRibMZ3ClIY5 + NuPSo51CARZoT+pYWsllMXNRF/dxzYi1EB2QgVxYDt/wv4zk3F34hQVwgRhoXOHFLXhZAPpRXrnJo4Ki + lhFQgH75nIlSzSPEyVLjmOi0T+q4wxMYGx27zRXk2mgQXfTNLT3IBRnxA0ogKLDAFO7ojlmawedV2tiF + WlNb10zMUdzNXgqAgAZIQfFVCfEl4dVSggZ4AO9DYEizgQ6IAQhgABKItz2yYQK44Z1SAJj/2YEDBlam + 20UatbJ0pVFRVaooyQAdiIEHcIDkwJFAsY8oVomXmQEJ4ACfbeF/wgEJOImUUBU32UUmgYCYoZINpCUq + Sj78JSQQ1Jv+rRAcgAEWaAAUYIAkOIE6vuMkYIAViIAKsK0sLrcb6IAJqIAHCGEVaABEboAGSIEHmIEJ + 2IHzpZBz7UUOftjnatoLrRIN0AEJoIAKsIAHaIFRNuQHsAAZmIBxwFBATq8MyIEO8AAJgAEJeIEdyAEf + vpBzzUk/0x2Mmt7KrZIb2AAd6AB52AEd4AAcwGJWpjAbsIGfWOZNtd9e3sqMks+cvN1oho4awIBurgFm + Bufj2zO4lVBP/82IWvoY37K2cGbnxUK+uYKuckpCkfO3drbnlkofwKlQp0lnjnGLxKk2ErzngXam9GEg + ilrjjHLayHU6QiABNyboiD4gi8EY54TbU5NDVBOFGVkcifboHUKNS7Qdlw2hKYs6jDABd/nolT4gGViA + c7G/FKtJwlxCkMgklsbp6pkAFUgOp6tm0ApVa6aIPInEnDZqzlFHlPgIXy6X1jwnjhiBBMCJvzzqqhaY + bJORGbmRoLZkeo7qFFBbqxbrmWkkC5CKUEjCFRshI9QPQ/AWNBvruAaYG0CLraARX+S7EHpq9mUACnBU + uQbsC9mBFOidWankN/RnVaMR4wvsxp6USv/BXBq5ZJukybY+ACbRHMfWbEhppAdYgMKu0Yz+So3wnVoZ + i1Xe7NSGTV3prRmpmnPy6edyk+bQV9W2bSSGgRRIgFe46+qNWpzU6m6EAcC97eKWDgNLgUODH494Nubm + 2wgoTeOWbkrxgBkonpg6hBlpmotw7feS3wZggdqe7vGuDg6IATfLGI/o7Y64wAaQEPKG7+rAgQlogTUA + 4FR5BdN5k184ARRQAQio0vgW8Om4AQ6AAQtIgRXQBdqYBIyxVz62ABjgAFwe8ApvChtQ4gdwgWX9xFuL + gCegAwsXcelwZQ6I5RiYABSXAA/QAXsY8ReH8RiX8Rmn8Rq38RvH8Rxq1/Ed5/Ee9/EfB/IgF/IhJ/Ii + N/IjR/IkV/IlZ/Imd/Inh/Iol/Ipp/Iqt/Irx/Is1/It5/Iu9/IvB/MwF/MxJ/MyN/MzR/M0V/M1Z/M2 + d/M3h/M4l/M5p/M6t/M7x/M81/M95/M+n5IgAAAh+QQJBQA8ACwAAAAA8gHyAQAG/0CecEgsGo/IpHLJ + bDqf0Kh0Sq1ar9isdsvter/gsHhMLpvP6LR6zW673/C4fE6v2+/4vH7P7/v/gIGCg4SFhoeIiYqLjI2O + j5CRkpOUlZaXmJmam5ydnp+goaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2+v8DBwsPExcbHyMnK + y8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4+Tl5ufo6err7O3u7/Dx8vP09fb3+Pn6+/z9/v8AAwocSLCg + wYMIEyr0hsHGjRs4cGzAoSGDDQwLMzaysYHDjhcTYsiQEWOCBA8cNtjQyLIQBg0cPMCYQKGCBRY3Z5A8 + yQEHxv+WQPlgwPExpMgKM2ZYWDqjAgWSMF50wBG06h0MOTxQUNq0awWkXr9a0OlhQwaraOHg0PGCwlIW + SZHKbQpWKc4ZFF7o0JC2bxqsHmjW9Up4bl2nEzzk+Om3cRgcEmTYHEv369fKYSUnbSrjBVXHoLto2BFD + 6djLc+l21WyYMoUdfEPLvnJDhwSwuA3rDlu4AgwdZ2cLl5Ijsk3McpHKUG2YuVKnEjgMn+4kg4fjXXmj + 1q7TuVIZHoJTH39kwwSumJfP1cxe+Xa5OGF8Jk9fCAYdMZamRu1eO27vFsTAgXj1jbfBDludZplq6jmX + 3G5gUeCBTwWOl0EHxo3VYHL+6QT/YXd0wdABgRXOhsMLR8W1HnfNNbhhXDF4VuJ0G8BwmXOS9cefhxxu + txoMOcw4HAelWbDjiztup56OTRkpoJDCdSDDaXHxiNxqqzXX3HcdQDmblExZpiWDK17G2oPf6eClbFLC + BdaSLXY4pno3ydDlmqDpUIGbYlaZ5JjrLYiUBXbimeeU2XGIJIOEvdggCxTcaahfUj6QXqNMitljj1xO + yowNGTz00EqE6CADC/wpx5yiicapWZqFXJSBRRgw5ukdDnWkQwc7eODrDh3owEEOFQHSpoM+poqljjuy + UKgfGECUAwcd8NrrDsAKm8MNtt76xg0cgBQDBU89NRK5JYk4/x8fplKpqqqs+Snost0N+qxQOHQwE7nk + nstvSXrd4O0bQ+mb4FgIJ7XUUjKIaFYfevJ5pZLv0oumvZLqkcGBE2AH18IfJ9VwBxt0O7AZG8g0wauU + bUbZaTJQAINipOZhKqqcvnexh6ti2anGObwAw1ObZVelihVMMPMGJ6OxwQuv9rnpjV81zIHJdBxrJs+L + Zspojkg5m7Ed99kI6HvoifwC002PYUO4B1N28W44WUCBBDrUbEe7hYW14pk4ok3o2HS8LYFbdxG2mZYL + zxBDdCS2vYUNHdT0at+AehXzb3rTETGZyH5YMaeD44FBBymejTlvMagpuRfm3aRg5gvGW//XBEHecXOS + 9ebWm9/dsXxvHRyc5yByugkatgUTrPs6Fjhoddd/ZnL4O1h2r32H1g8a5uLW/QGP8R3RJ3i8lpmP9Vps + z1+RAWnLybtpz2fKFfML7M+hp7ssov9u9YQRmx000BZEqcZPPUtedkiyg8i1Lwo56BjwEtW3DSmwdZ2D + w+cAOLp6+W1O2BteHE5HATfJi0WXUpVXcPfAKpCQf8qrmO2yVCXwOE+Dp+JdjrJUJv9srXR0OFH8KLg6 + nfWuKwHqQAZb2AQCLgeGHuQgz4xopAk0MGunol8RrSfFHDGMcG64kI34R8E/HfE9hMIfE6OQAR3YSGSq + s+D1DiiDCXT/AGtsaJeR+kc71YVNBq4bIfzCVMQK8u4wMODAEteIhOjFwCa02+KRrAeD/L1hg6OL5JJ6 + VzEgxgEHMCBkJJVUQcKQa0KMdAIHhjZKHnUxiiyjQCDh0CZluQhHc2SSJ+HAgRIqqDd+zCVnWJjKJZBw + iseLV6OABzhCoTION0PW+RKIzO04a5ZuKJ9+uCgnD7JHcZaRZTGNuQPsKA9zCqSa/eJCKDtaMo/HmRsu + 0Rav9ihMhGx4X2TShkB0+nB1dsLjOHmAgRfE02LT3ORyNqmz1kFzT/PEFKtAiER8roFI9QOn/FCYyee8 + YJEDtcEL5MYbOdouZ5zZUgU8ANIz7A5C//Bq0W52eCNCYXMNNrgOFFsJwBmmZgYSaGkxMSABQp4UoMDs + G12W0jxaZhF8/yvpznq4SzaY5znT/BBD5zeXpQR1oEgQKVeixtEpylSpcJHBDm6YBj1OlVM+BWYIweg0 + rXAFpeibmJy+Eh+hphIDOuWo1yZKwz7pJAYeEFgbMOnPeeF1N1VNww3gh6b2vPWEUf3hDFgK1iPYYAdd + 4xph+wM4qlXGN2xjQy0rC9C8BqorAmzDBm5zmO6lJ6r17OGrwCPQgepgZZG8Htr2g0a7KXGxT1XgN1M1 + 0ytF9gyneyI1h9vDdP6vAk/q7BGK8xTXUtdiaFpWnSTAVjPsb5kdJf/uGX1m0zYIEYq35KCyFvQ7ndyt + vJ0dzcpUJNikwpVTqIoBbPKY3GrS87q92eFzy6BfiF5uMEab4/cyVUcPvFO7PHgbDOIHV72alF4c1twE + bmqG1a7qtUdNZ3YWPAYMECm8zO3m1MCLFyD5dZw38MCUjKTiwgYKfNKUixrVwFhS9hHEHmSxGAhoTiKK + rrBRTKEzFYvhI4BpdhLtEJK4WYEGzSCRvQUD32RqRCBPbS6xRUPZkLY4x/7TPY/9I12rzAMiwVd0l3Vt + kxxXFjVUiky15Y1UA3fPOT/GA0Vi84+tZFp6EjpA0qHzEUbzSPQiOU6M+q6R8nJhMbz0xBMtM7z/MKPk + LxCwJmSsbmF8CmfvYNfCkm4kaajHrGom8LFGk0Gkz8A9jcIJyv6rqKG/wIEhmlGH/9lhaDksIfzGukbH + KW2mMvs7mqpmLOFBw5ixZG2KWpa9Fg1DBl4wAxMa9pA0lOMkxQJUZ8c6p5Aso3CrrVLFjSWRN9YCY1l9 + Rk0KG7qrnExWB83VOCnHSB+N9RJWSVbSlkmG826oYlyaw4Ij86i5rWm4vxC0Sq/q15lF6UK3xJlEKnwJ + N+iABINc2deWmYZ0QWy+sdDrSQIboc0p9eQQ/fJkH1nPg0paB6h8ciSMxi1yM+OtxSdazDSlkuY9qMG1 + KrWm/4wMGjgPdXPG/9VML/omAnZ30XkQQf5S9JA+P2BrIEXiL+y7elz34Gl7pvMsvG3H6ozysWN64sUl + BQapHXsSbtAWFPt7qhxFeMnIsDvkGfJKixLesLOAgdmaU8WO8nrPTlu1xAremAwPNaM5CaKezg9GzxSD + iZOZ1a2NvKsb38LTHvnL2s2P3w9fjfrA/PklvA8Gdw2m7+SLzrnEYPJYiKabuz5yGZc79pSvXNFMG9df + O4pi3RmLHYnee6PfBi7TvW1Z7dmiIYfhvLa19rJgCvO6W0GITYIprRstcho+oAIv4H73jxBdBEK8taAz + J3QxYjM3BUVma9+mKIs2PmFgA7+FVUakbpDXP/9ewTBtt39FMFvK5kOt9l0zVheEAiSelkPAthulJENz + FQYutmHBV3qjp0xwF0UmKAMSkDsYqAQpB1zyNFg+tl5blRf6twW1VEoptlfO4X5TQHhbIXWq5nL0Zj3D + NHQ3yARH53dwd1bdBnn7sRnE5HYVhzwu14EQJ3lhUHZ75F2iRVhw0mU+ghcDNoVMkAP58Uu5JUwz1HA3 + 4oYOlAUH6DuZF4bOBX1VkHICZ3E7Ykis0nx2kV1wiHISAIEPwlD9VkhZSCgSMCJe6C5iiH1QJU1ICAVt + NEZHY2ZL13OCA1RB2IhG8FsjwV9b5Xjo1miJ0jA2yAV/9kpxJ3LWJIhTsEr/W8FmhAaIcaVSdXSBqkgE + KfdG4ieJ6hVqC2gknNUFn+aECsUdRfiJTgBvVOJ/M3VWRoY5l7iHx1gEo4EordZtfFdrKjYoQNVpVtBr + JwV0akcv2NhEoYQww2Vr3xhyhEEoazWOThBBkkhWzJhQSjUokCKFXLBtUhSDDQlnGod8UJByiCN1raWA + T1hNMRB4AImDh2NZ6uhNjYVgk0GDwLGQEGVGm4RU0/Z8ElkdbiRd1BOA62eN6+Qe95OKHWkEcINA1Vg/ + pjdwuHFfC/mFXWd7fVdP/7YFQbOEhdSN/pRxcpEXu7aTvlc8NRRk8pYs1mg0DiWEBbZlehdR89JeQohq + /1a4Ud+VYm7mODqgk1ZJjtfhfDbHd3fodBVAXluAfrfFj2i4NWkGPd83j5lDfjsTYkpifnG5BA7olN0Y + R3qWhY6jkDQnAw/AY5RIWvrIGU0SmFagAahjhTPZkJYGkVF2fGG2mEMAGTVhdmOplLaUXlVjclkAJpj1 + lH9DmF+kBaEnj8nTiWZGX5vDkaqZBBpmQIPFUyjEYU6Rf7Vpjv7HTBGnOCLzkkrgRHu3OtH5ZBUVHQW4 + mJ/lS0v3iud0lM4xYqkZh5VmeGPJfluYNLVYBVgZfucENqSHcV2WFA/wGuJYnNtlPKMpg/rIj+qHF6lX + BeYRaGgHaHMUFw1DnFJAQP+lUW2Pd3NNOBkxEJ/+iXIIchjh9z2kZ4LWU0eUSQUSypze2J7sV2Fih3K/ + xY4913dYiH2bkRf9uaFGcCCtuaKleEITtipdSAVtdDiLU5ClhSngdDd5cwU58EaaOIl/2Inn82otiqND + gBUdwz/LBZkNuiVqhQVVeIY9CJUutxTrcwUYgCAtQ4rXJ2g0NV9cASTpaaVDkFMtqFUX94FWsiEId6NN + EEE3wVOtVG4sICDfaQQa8Ii/NJ7ThTZI5kx+SqdFgFHb2aMB+nKbgW9XAErooZIr2pYTAJdNoGGXZ4hZ + plw+9pWTghG1UiuEMFmPhJF45WFnE3Rhh6Z2NZNbZp7/uAEeh1oEREF7rYJe5+iE6vgViFWldNCqoHID + FzGn1WADGjAtvPICJxEsKaEB0PpJOqaS6faY3/ofm8Z7VsBdPscq3HY8TZEXEAoF95Ehrkl+AOh6x5MX + FOIH0poDHeAB1loS16oDGyCq1AAuKrMyRhIzFGASO/Aw0FJ2f0mhgHglnPECkaoEhsNvYNOBSkWDiuQ+ + dvUcDomk85Wc9ZKhgJAB4bJfLPAALQABaaU0U7GtyqABG7CvMDAuI2ETfDISSrMDwiKwcZAB+5RpTCeB + M8Yzi6OX7oMfhQhzBpYap0GAYKp10UmT9aZJVSMB7jgHLxETEgBcFtACLAsBLSC2/24iM3qxeNRQMDSR + sR4qGeeCsH22B6eTIilkdrd3iFeoMDGwtU8wWa3ZZnQRVyASF68BtEyAAxOKkeS5twoFKCRhnWxQeVCz + sivLsg/AsmKbuZnLAndxN1czDZWHaHbBTyRnFwFCM3tAFOcRJjFEiZdWGDdBAe0qBfkyE0NUNP10NO0k + AW8IPeIJVbkXR6WUFImhrGygAWwhAxAQAS7gAmWruZyruWVLtmTrG6ELDRcSErkrPlJDGTuhGIi7BlhB + blTyhyVlhLoEKciLcqyrFJf5nlUiOzOQGCohe0iXnHkVX+ljJPIhs2gAmqzEAi1LtmUrtgccvQh8wBBw + mWpVsf/C0Et8snxb16vqkgeU84uyGowsJ3emEQPtS4WBsTMceLxdsAExAH6AM4z91mNjdVx4YHkEXL0I + fLmYu7mZu7kL3LIzoAMAvAuVFxmem3Sz+k2aEbUooQG/SgaQQbzC25JvOigB4rdJGC5fOy5IhBNfQQEx + AAMzwwHj+wSKC7IIBXJl9S5nCHh3sDH6cirWq8DTi8Mse7kInMMQ4AIPMAEduwyzRXu193hu2ypOERV7 + YQfvA7bcCEepgXEoVL9hDIoHAhKS8RbqEyNrBcFRcAPKWHUaG3lpqHYChslmoF9TsrJ1jLmonMOcK8eo + HL2QtgzWYWy5NKuoMRZuoi4/vGT/bTFW/jV3w0thMCDKbLQB+uoBXwsDJ7EDOcCwYHADxiEy6au+W8cV + iEXFacARUMOyLmDAN9zK3dwCpiy9rdyyefzIuFB5omhbGvWUuttlCsvMcQCoOHPGNWSKixMjwjwFDSEq + zprLbKQVzMlJosbOyxEfGuoGMAESezK23FzHNfwAlpvDEU3A4Ty2LSBLS0wLtTGhTuabETeVeJPRXjBu + ncpttVaE1dhlIuLPfXA6Q/NBwwpxJKkqqCIB5vwYpBG2dAzH3vzN4PzNEo25ZAtUaksM7zrJW0RNC6Wd + STHEI5MD+Uxsb7SOFAiVTYFYtbsIWbG4KmpWEZifXZGwVdkG/0PBFm5xx9ysytO71kE9x5xrw3N8wPfn + nMVwaoiHhm8qV9MXM4/zlnAQiogJRxNDSoSrxzcdCEMafMcKThH7Fb8R1VxAaZNBwzfs0NJbthR9w+G8 + wG5NvRd90L8AqDFdk9XFnr5cuu4EBxqQq2OKl1PanVnNCJABgdr5ZK/lhtY8BjpawDq8yqm8uRGtynQs + 0T9NwJ07ti7Qw8ZgZxoif/S8q/0kOw2jzIe9BUQiuEbUdB1mL9lWCZ9ljrTMHHd4GWNhsm1gA7c7Jc9L + tqrMyjps3OD80w/906s83JrrAhawA8agA25R1Y9nXW2mVTwbHdWNBc6Mjt4UdzCHrGM9Cf9N2nCVWtpt + RoOQDaakAb87jLmmDN9tHdT0jcOY/d5u3bIW8AIs7QoXEtA/x3Rq54G1DB17ceJVwF1MwUMaRW22WqKU + sL0GRNCuxo4cO7naVMDs/dsb7uGdLd8QHddwfcpCzQIUSwyAm3RmxWheCovCJBcakrB6ca9q1qQWEL8M + WjvLRCfOsgMF/qo6BtFiyk15bU3Mk71o8DaBcSoPAAEN3dYgXtGajeQjntnyPcMQYAFaSwyrHVqFySQi + q5VwhdUiTQWnk5L0TJpfFtuRAG2ESZ8RNjiPPgUXUhp3ztNO/uHhfOTtHcdNbtx67rLkRQPDsNr9XZ66 + dWshiZ9Q2Jz/AFvhSThr4OeaTEKQMVLUmVC+IjF9coduzxHKaqa8IDEDdw69Ij7qdDztmq3k1t7ZfV69 + FlBJF/DqoEVSj2vlhRlRXZM852JFwk4GgDs9IKaxkFTNoCChMCom3/ZNZnpFZ2A4OmvKTj69FC3iI37c + 9L3k9B3cgb7KLisf3S4MU65XY6Jlr71u3FG6EpIDnT6RiNZdEAaFDtrFB+oJHONxuhthDvoUApbmbMQB + j9gC22zZ1W7kfU7cvj3fcf3nnVu9LKC1ri4M3+2TT8s1VmtgVttRTOHxHJDblIcDKbsnOFE3XEHJeDFi + 8AwK0mowS8HmiWMagYpYACvjTvASO0Ck/8+O55at5MRN7Q+t1kmu5xUt33dM6CjfCpVDh/bsgembj6b5 + gVjt9dkYrMlhbZpxNzo+CuAytFIjKAI29WKAskLc3mLb0Kec9ns+8xuu5Dac9qeO89E4DMyNtP/13zY+ + 3qf9egcUJgK2LXzPBC+hA77yAtbqxcj8Ar+S66rAxvz6+kojARIg+y+wAz2R+oyZ3ixwx3Jd9g7N4TXc + 26SO6jH/zf9+5xAwA/pdDHJYewZ3qq6W1K7oqHm4xe988e6K3jmgLUpMCy8x/sMSsOD/BDZQHAZr0UAN + 4iB+3HBN/xou+XHc2aa+wBUABDrekFg0HpFJ5ZLZdD6hT41EVplVrP/Yq9Za7Wa34ep1NgZ/s9Ywlnsm + x144TJS+xGQy8/qe3/fzM25s/gA5YCpaHhIfFBkXGyEbW1gkFVkmE1syLxkpNy0ZHRspK1ssYjYIVVdZ + W4syOibUyMDMZtZwz9za1Hp3aYGzZGIkOnAyXJOVl5mb+zRyPCgqIhM9RSEfJ0O3HUlJQyHBMy27yRMh + EmV2kJ3d31dxdmJmLMp2v2jT7vnbyGRusemn798/XVgowNihAV5Dhw8hJsHxgoKFc52qhVv0CZSka5s2 + cuIIDtQ2TelmvEgVkWVLIhhySKhgb58WM10K/vLnpRcwgPm4+LRigYUFGRN25GjnkmlTp0wwaOD/IJMF + hAiaLnb8ZNJT127etJIkde5S15IuHlDgMOhpW2cZXgBc88tLmS1Bg/48OBBvrTRg6t0aBkMChxtuESd2 + iEHehCqUILjQxK2sx2pjzZbilE0Spk4bOYuCwALGYcWnWRmalgtNwH25Bv4MSFCvXaDBeAWMYUwPat+/ + +djI8QJRuhbpuD2iXHKzcsuVvVl7AN0zqLJcNbGg0AF49z02DFUompOgLvLm98nuq7MgLQvv31eY4EGH + ae/38RPB0eHQAxcuIEAOG8/MyWw6y7jRSKvLRKkuwePQksED+/KrEAkMdKjInmCEsok2fMzTyw1bbKqJ + jFuukGEYCXLozcIX/93CIJZ6FJnMEayUI5Akcrwqx6uxOipJSB9vjMyCCWFM8hUPYlCxxH4AUw83Dv3p + yUR8xGBjjA0rYNFFJcF8CJYYLMKqko9GCUezBjHDZrkDtwIym+amm0ECHMIEMwMOKEKRphN1MnGMmzqE + DT2fOAysgoQ6oDDPR5nRQJoZHkjHuEgGFKmjcSjR1KOsyCknwebGMs6C+RiCVMkNKOKpvHvwYg1R2XAZ + 9Eoq9RGonnWWUtXXVaZgQbJKHkQwLJCuWe6rNsFStkFiZ5hAB7Z+hREHHTxwDMX0psQp1ivRGxGn2uqS + ciYWZoBhrWrZfWYHGawattggLdPGwDifLRC7Nv83sZSFCmLwIAdq27UwAxyYJOrPCuqqxdC/xCBoytoE + GsPQWyxYtLCCOX4Cgx0qagFA0Jz9BM2vwKpukW84wnRIrP5zoYIXlOpYyRv4m6Zh11qrElDbxD2PvSrx + kUECR21OeggNYuhMmwW/EcccUVduFiQ4SxG1xsmKyjgOpZVkDFsYZHjv321/9tBWvmJ11Za1R7zrtRha + BBtsGzoobiMbTSqWq5SjDhXwNyvrG+YAtYOhg5rtBnM/bbcd+kOJ87Ky25wAw2UGCjzYgODG2RUOhjI5 + m3rTlN0UfDpMzNpKSI7QgeABGWj+EnQYNdDhBRgoqILLibFsDe685jJIn7f/AxpmodsL3kCm0hXEiEBR + Cgf8779XH9xMrstQXAPbmYcRgw3mmem9yMkjMVBZ295ptr+yOJWD8NndYYaTJts+upeZDYvBp78CQJEh + rkuMox+kNLAD3r1mPXKLDZYodjE2uAFt9ajADg7oKwzAoFI5Ghyz+jYg5qCOTSXMREgsQAGVZPBXGchB + B17QJIzx7H2uiVi4TiQb9QnlfWBAlwfAx8IX3WACxwEV6khGmb8la4TYk042AjQagNEnVUL0lQ0QJgsU + lec15goDF2EjJRIFgyhdQpoVLYSDCfhHdmQhmcquw6l67chZCMLRA7q0LjSyK3cSmMBq0BYluhjPL+zj + /0uiLCiBKu7RQoxpmrya9aYhESscrXsZ9RqUHYYhxXOMLNgN+ESBGXQtRXcp3k0k5y0J5moo6cJBDTzZ + yBxQwD+CI0u9CDe9pw2OapeAEAROtYNOxrJgMIlLfHClwy+mR1CVY2VQ7JIxGGwgiMREDXhkUMsbgbBT + IdGRdZyYLNZpxBOTiIEOemXNdknFAzCQYaHMNS4QUYmCBtGCPVj0OXX6RgMdyCZy+gZCXqqsieIUZ43q + lBBhVnOfvrrBcGJgPsHcCofQhFgzDynNujUUODjLJt9WV73rgUMsCSJn/hAKswdEqwPp5CjHYJItJ83m + YYAh3g7JdTF8bvSlqMlAhv86iKlrbMZqWSPoOIllo+kYbVo9tdvBOkCFVtLUpqb0VkVxdQZprsSpp8EA + B5omoJaBZmrjLJD/UHoSlATMMF0FHSjd+ZPfMbMgDVOlVa8aMaO8YJFuRcwGYiAsk4Xqegd6U0DTRNhN + bG55fgWdDTYQVcfMooapLJFcMLs+o3jApY51yg04iJYkmnUcRNLap5y2sqO8oK2evR0G4CrK84FxULLK + Uk3MY48dMNS1EbGBBIxYOn6NMJLb2JEv8ZfCHeBAn719Kp/+uCWK0qZW5LHNbIwiBOe6xQMWAKiPVFfY + b17khJ2QZqO2m0FQKrAi45loGCtaSF3QjqvpbYoOyIT/psTSqZJqQusvtSMBHWigufZ9KwdkQRRElYhb + bcNV99BpYKdIigIHxZRZjUqqzgAoLR7Ak4SFCMrdNQmjwSMkg1G0nb6CmCUI8y5y6BRA7cnpjvGJwQ7O + yOLwRSWqvsOrPY1XG80RRS06bgqGLDAyJeo3hGQtnGT2akAjW/GnEohoZeN20VrNojRTZgoOKLC90oYU + juQk5yka6+U9ulCytOIHQHiCBi3x4z0yUJeaXYK3skUGpVtTk3R8eaPszCBgA8YzMa9FNsqa6ERb/GIZ + JVDfQ0MEJjFoQQRgvCDypjSKLJAQNSdtTRFPgMSOthw0/2G0+YW6JRiipaDvuL20/2bHHkj5MKutyU56 + KMwef3L0ico4HznguiU/hQGlADSyPu8NQpiugEKGSWx1ykOU9Jyg3JSXY2k3ZAOH8FT+QJUOC0Sat9u2 + Yu488AIr905XRpFB72JAmB1woLPmdsh+YDBZC8ApQNLJ2FEksNxy29uKUcnBDqwcg94FhgIxiDd9ok1w + lzyUP2NgxH8SYQ8KBJy5Eu9qVHSwg3QnfAIv2EEHOrCBens8InvygAQWuKsYTEAhUma5U20QiBtoAAc3 + yIANMFDgmxf7BjfAwQY2kAOkF33gQ3f606EedalPnepVt/rVsZ51rW+d6133+tfBHnaxj53sZTf72dGe + drWvnf/tbXf72+Eed7nPne51t/vd8Z53ve+d7333+98BH3jBvyTod7DB4RGfeMUvnvGNd/zjGf/zpg8+ + 8HuSgCgvnQLNNyACDeC85zv/edGHnvSgN/3oT1961K8+9A1AS7QENnnKQ+WhHNjB7mBAmNzDXPe95/3v + dx983wsf+MM3fvF3b3IOdJyYkppBClaggBGIIAQFqD4BrF/9EGif+9n3/va/333wj1/85Q9/9g1AAgWs + QGbsmP0fXPgCWVwiXpiOAIDuHy/955//+Pf//v+v/wBwAPnPKiZhcwpD2+hnIiwgAlYgAUhABAbgAwSg + Ai3wAjEwAzVwAzmwAz0QBNJv/SD/QAbQ6/3owIXaqWxExvMcwAFUwAVd8AVVQAZpMAZtcAZvsAZxcAd1 + sAdvsAUdgPNc4F/ggN7QiANmwAFIYASmrwAIYAAm8AOkcAqpsAqt8AqxMAu1MAsHAAQIoPoM4AASQAUo + QNJMUAlg4tgy4T8iIAU8T/PgsAE2bw7dkA7lsA7x8A710A75MA/pcPNAL/+sYTdW7m52wAJQwAAq8AOg + sAtBwAsf8Qkh0Qu7kAAisRIvcRIl0RIpURMxsRM5cRMz0RJDEQSgkAI/4ABWoAJy4AyZ4KfWKAVUQA4j + oA3vrxZxMRd1cRd5sRd98Rd9MQVssQ1lsQFGsANWzG5yIAZc/+AEDoAAFvERI9EUG5Eaq7ERodAasxEb + u5AbtbEbsfEbxZEbt3EAFpEASAAFWGACbs0VX4JVKswFPE8FiNEWU8AFahEf9fEW97Ef+fEf/TEgAXIg + 9zEf29AFNK/zZjEFZqcwhI5jNsACFgABnBAcIfEJS1ETp1EjOTIjPXIjP7IjpVEauxEEPiASRWAMKaAQ + KQ+sLIIYhVEY7dEggbEmbfImdREfabIWZdIN7y8tOkD2HuUGZGABDCAKMTEklRIkmVIknXIpNZIASJEk + qbECCeAAVOAFhHLvcmCNQq8nh3EmY1IsyXIszbIs0fIs1VIs2VAs37AFKEC7lCYDJqABSP/AGpuSE01x + L0uyL/nyL/0yMAFzMAUTHP1yIydwAEIgAR5gt9xRA16gAeEwLG/xIPkxINlQHzMTIDdTM+9PMwUSMz+T + M2USJiNgHc2wXTBAAiIgAQqAETcSFAeAFDHyIqdSKinxNmuTFGfzIn3zNr2QNn/TN4dzEk0SBBngAbjj + DG9gBxAhISvzHnFRJ3VROqWTJ3dROhFSJ62TO/GxNC2zO8PTO3tRJ/FRDiFgBjwgGasFB1jABArAJD8x + I42TNzdxNitxPpNSP3lTNkfREe3zEqcyN6eRAGDTAFBABliy7zgAXhASPKkTIfNRO7XzO/vxHu/RQqcz + Hy3UM7fTPEf/E0Tvj0L18TpNVBjTUy45xgMc4DUdMS9BcS87cSSlMRTzs0ZvVC9t9CLx8z8zkSQlcRp7 + 9BRHwAVWbfZ+qwXucDpJdETZMENzsUR5siArU0Kvsy1x8TrHM0s1NEIt8yDNMyZTAAImQAGHsgJOgAI/ + 0T9HMSp7M0B7s0B7M04xkk5nlCnf9E37s0718hEpMAQWQAIeku82gAJcQAXM0jvJcyetNEK5c0otkzqv + FEovszLBNDpLdB8pNTwjAFFlIDVVBQNeAAJKYAJrVDb31EdnNEhLkVUBFEBPFRTtcz5xVEb7lDjNkQAU + gAVakfJswDlJz1KxlDoxVVhHNFI3lEsl/3VZuXRCiRVKtdRSnfQW3bAB1HNBlQQHZmABDsAaWXUkazNG + eVQkv/UjdzM/zbVNRbFVVzUKQ6AEGgAGsPXuupIF2lAIORU7u5NCnRRDJXVLN1VTC3I7p3VDiXVKhVFD + m9UNWSAGjrRaOiAFEkAEZLRAx1Vc+9MT25UT35RAMVZAwXU/PfE+d/QRZ3METsAC2vHvZIQa6nFgL9Mz + c/IfDVY0JxRZxdMgvdNfIbUgm1QmOS89X2BeX+QFFmAE4rNHLbFHLVZOY1UUL3ZA2xVHgxRWoTZINTZr + l7YLC6AEIOBh/y4DYEBYKBNSMRRSAbZLwRJhe3Y0vzRMl1VEo3VKRf+UOzVvCCeAPfNkAuATXJlyQDO2 + Tv0Ta2/zRqOSRgsXJPczXHd0VivRAFRgOQPvBmIAAnqyS3U2F7WzSmmyQ6dVZrUUSzeXbme2Qzd1YR80 + H1mxXSiABEw1T2P0Pp0WY0X2W38TXceVZJU2Nn1UR6lSMVfAAwZPA2QgIccySkPXbXPWWZv1YC81dAN2 + UzP0SuvWSTezHmvRAnq1WmTgAATgRWl1cE22Pk1RR181d6e2fM8Xa2HUVTU2Y2cTBYRX8DZgBt6QLaU1 + eZOVYEGUWPl3f0f3f63XIHO2O8kTLIWRBcBWVWRgBAQANm00VUE2FHeTOK/WcH23VWkVcJUWdiX/uBQZ + 8QReYPC0dQaHEVovFWEzFVnZlloXlWCll0o/dGY5V2bz1x4ZcoEhRQYUUQBMVnYPt2k31k4Fd13ZtFxR + VYg9kk7zswtPkgHmN/Dq1wX1dTojFErJM4v/8UqV1zy9VGCjdXqrlGcLWEqrlQVU1FcoYASkUEBhNYld + NXGNk0bnGIgleHdr9UdLViP9Un6H135psTTVFktplmY3F26bVVoJlnT5kVJhGGajlFpxOIdZFwEYMRub + co4t+FUBNzg92GMb12k1mEdndZN58xQJwI8FTwMqADrtEZIJGJErVIW1FIsjdVLbUlGZV1rHs4DBUnvb + hW9DYGnf12rXVWRj//RFL1hOy/WNZdd32xcT+7IAVgCDBI+IvjMhFbZJ4RZEcxZm4/aWBzZhi/VRtxOL + BTJLE3YGtvdXPOBoQ2AvA3RP9fNOzdV8O9KZ1zc2wxUSPViZm/gLSSACdJjvMkAC/ENfddlEFfZLDfZL + wXKRD1ZCZ/iQo7R/0dZss/n+WiBv2yViS6AAMNl9U5WkN5lNczNHTZlcOTlOEXdVTfEDCABlLQBU9w5v + KGUyWRijMXpaDZhD3dZ/p1dEafJnFxVT+xchOa8F7MRMV4UFuFU+l9mOT/pjL9Yp7VR931ddMZJkR3IC + QwABVKBMKS8HxrbzwNOhz7aMDZlZz1ZDHRl12/+6hm+WSidV8xpWB7YSP0TVBUr1e0NWXKcWn0Wxgzk4 + dufUd/HYfbUapi3xT3e1nSsvb2QxJn22MzvXhVmYi0OzeSsVWa8YkQ9SPEvU81gASQqGlRXAHJ05k+k5 + QIuZamH0b7PaiDu5sCUxVxcABvZ67gDLBRwAO1kYeY81s5lUShOZs9mWi3FZs2kWdL9zFisgjevHAUIA + NlU1pbO2YotYiGm3d8+3qhk3sKnxA0YgAiRb8FbzARCVnENbgFeYecE5rrcUs2cZoi/0kUH7Xl3Aoztm + Ax4gAeIZu0eZfH8zcBU3VXe3u8WbvGO3RtvYABhAQc9QB+AFrbmUvot1v8P/WHQ91HmL2ouB+qGNNUuD + dgasuWNEVWJFGnc99p+1VlVxW3FrFbb31Ij/c2kZ0QBOQDldMQM8ABFsETRzkrRjOYVP939Lk2fPeVgt + 22zRVr/vNT3XU2lAyy4NNDER22RLcnzBdzDHlzD/khIt8kUBE5MFM7cbcTEfwAMG9e8gcwbOEzplssnn + elEZerT991Ix98h1WYbJmScncx3Tm2OI92jNEbDr+KQjOHdrl5k7MXxBmbax1hHNUaZVUSvdcQg2oIhg + 8nKL+23pOsRDVLMJeVjbNoXb1krh0HjhkrptRlsnkmK/8Ua30cvPPMyrMde7nMx1XczLPBOrEftMgAzf + /1zwXNIqxDR1j1ct19I6y/I705IYpf3JE7XZIRrTgPLYq2UZXYAButUChx04yX04y/3c0Vc40Z2DL9kC + 0VEdYUBvTXADmERYGmAWlzRR09baTxhtm91K/b2FQd2yxdTz7p0hVY3bQ6cDWAAFRCAaqVKPw5u8GZt9 + tRqf6Zixd/0UH3gEHIAVe9vvwKNpqlUtpb3fM1zgq31hWZ6Mhfvfq7gYIWA35B1skHAFSuAAmvAJE5MR + fb7nExMbf37ogf6SG5HogZ4bif6SL9kLC0AEwjABGuBTN90ODKFMROY777DVub7rvf7rwT7sxX5JBXE6 + HJZobYZVZsABE+AAJNAD4f8+7uV+7isQBERA/dhvHWq+6nlg1GYiMlKgBV/w3mcxBmdwFhH/3hU/8Rkf + 8Rl/8SH/8SW/AVzQ9YaQ0F4AGUM+tT3g+aJv+rbvC0V/mEl/9E2/9FH/9FU/9Vl/9Qng7tfPBUhQ4fle + xCLKIjpT//4v2SKj93n/93vf94Uf+Il/+PFRdhCwBGNJOC7vfj5d7KE/+qUf7EGvBaYI1Pg+CmzgBjYA + W9RtAmDOj3Iv92hO/MMf/I+v/HuPMNSf/Ymv/Ns//HUP/DN/+Wg/g4JO8oBu/wsPCGwYIXFoLCKPyiRz + ObTZMjYetWq9YrPaLbfr/YLD4jG5bD6j0+o1u+1+w+P/8jm9br/j8/o9v+//AwYKDhIWGh4iJiouMjY6 + PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/gIHCw8TFxsfIycr + LzM3Oz9DR0tPU1dbX2Nna29zd3vPZuR0eLxIxMRMvHTs6GhgfDvaaGxscOx0dOhs5Gy4wzvb4BCDRYoV + KE6UKKFghYoGEWZ4wPEvEQYcHihUmPHARYoILSzMqACjg4aJyDBo0AHDQgQUCRAcMECAgAgECU2seEBh + R0mTgmzg6CBhBgSODQwuWNEghYsHMl5wyPDOZzANHlhEWMHg5QgDIgqACFHAwIgD/wcQKEDRgIWEnlT3 + YOAAQ4aFFhEaqMi7IqkDBw1TtHgwg4KEDVPe8toAI4KJrgXEiohcILIIr5MnV07QYEIGxHo6VHChwsEK + 0qX79j2duq8KCBR0HPZcKwOHCSwamDAQYmYIsQV+S/79uPdMEQlUVNAhu45VC6IXQF8hnbTf09L3LkDB + EIIMCTo6L4+lAcaDFSYQjPjqG3Jkr18fvwdOFkWFHOHjaJDQIu9q1dRTj1aagHm5AIEFE3BwXysYbBBD + BCek1xtwmFVW2ViUGSAcZbuNsIIMGyjYRgY7WOAACguwxh9po62IWoukJVVaCzFEFeIpGXggQwQLJHCA + CLsJB/8chkNShuFjBBSAwAIzuGWjGTZcVdCJDLnoV4pWstjidA404IIFMXhgn5OhZPBCCwuU8FV7FBaZ + YYVuGuCVe0V+ZcAKHox5Rg4zNGAlagNSSeWKDAnqomousDCBcnlyokEHFLjAAAlghUDnnG5a2J6RmVoG + AgElVAAio2LgCMFe/QGIGosqjhZglgGi4EAKOu2wAXijUnKDBxaowEAJJGQIGZwUYjbsmpmqGWwBJDQQ + g6i4dmFDBzpuWZoK/l1bXYB/siiogAx1BMEMEuQwFbSP4KAfAyMQABlmk2FqbJFjsWlhhpcVMIICEUhw + bhccUNBCnwNyS+WqqrbYKmtVYqf/wgMwJOjvIuGslIKkIrSroZvvSrZmhpjSi6yav5F1wgzmSnyFmSls + S3CVfhKqsJYHp7aXUk6FeUPKhoxYYgIkxNTmph9fuHHHyMbLcW8lQKDzzldMkAJfqrlqcKAyY7nw1X/2 + tZSXhT0dSEAxtIDCAb1J+PGxao58GacdY/oenWAZ0ICYYfOQQQUGcbtw31mnGjNDrdJMmnYLrAWx03jn + gQFoLSlAwghBIg3v2u7B6bHmchYdAggiOLAD4zzgUKJ2qw16LdYJy5xl31Zfp0IKBlLgweKjzyHtAygA + i2+FlgMvt9EUGou5kGvSvYIEt6ccFwsq8EVdoaupvurWALoK//PqDEVgwQsS4R5HUDG4sAACR9I0sqXE + E7/p+nRWODIIBqBAAfhPj/g8ivxlGXPWgrbOTwK0FsNglJTuTaADOIhN+NTAgQpYDD3p0VC9Qna5CcVt + WMWCFwcl8zkGVCBiT9PVAxyAouqkjmsJmxkL/Se9/6AuL4CpgAea1MAy4MgCK0gAxtxlqUxt8HLvYxun + iBUcmjDAAot6mgZe8ADoeatg/OvfwQrXPwGqzlvYWUH3voeyG4IhXRZIgUsidDzKTKiIlbOX24gGss1N + ZjciOIEFOvBFf+HATFAE0PRetCLXbe16ggNkt6zVlBlAjIFg5AIHZOCAElhGU2qUk72SJf9JzGkqc2/a + JNt0QwADmGyJOyOhiVhjnVZ5S2YGe5nqTIk1QQJSVhbgySK3YIMc2EYFCaCUbyxnvKNlMmSZs2D8MihM + C/0GiRQQ4c5w1IJSAjBVgVNlFrP3t4XR7GDSQQEDFvAQCXSAebVUDARQoAAEWEZDm0xaJedUzEtOUmRA + lMwn63e/nemulC1TGOH8NjgXZfOfrnxRK1VpLY8cSAfiDF9AKtCAND3mjEH8HfzUhsm3YZKSvuwkMkHQ + IQkoMmUc4BVfWqm9KrUykCa1nkkHilJDUccFNLTh6JoYGhRAkjiVOhol40RRtRmppx1U4zo7CLJPNqAD + o7uBDBoQq27/YY+P2VsVP/1W0Glyq5o1i44KvFS7HIR0Zw2KAAPQKTeeUvBoxKSk+zLaPnayjVghOIAL + 7vk0DDhIQNJTERYFaCX/pJKKV/qjX6P4xwjopANhhVZFHpUCBYzAc+zRIPwqa1F6uZVzwZTkmywoHAOY + gAWLlZgT+QNYbaFWillD5atWGU2EBZBFXG2BDBR4x1FtYALPPMHPdPPZOm1UTh8jWmUrKc95XupCan0P + aBsAg/DpoAIQuJZeEebH6mmPYAorVCqnSTAtSqchHkEkB0YborFCFj6Wbd/b0MhGtgpRs/K1HNLeEwIS + rCA54WviDAqCokGuVqDYBFzfsFZFv/Tz/6SG2ksDXPMdRtFGAreB7G6QBK97Ca298z2WcIuauQ/Hb14W + EksJHrAD80ost1n5rza7xdcsMsxVr2ytNF+nIm9lZwEOe0qNbHQD/fBIcumEXxA1aTR2xm2NIb6kL0Mm + JAMsAAa3xZsOnrglac54wNiFGZZY+1cv08y1ATqN1ywAg7stBwM6mIALFIAxEJxxY0Yj0rDgarwP01ez + InPbu8RygBO0AM3hu4FuVxzea6bUxSi1lqJXiWCtURPRq4GOClqQQJr6JAcxMBVkf9TLeRkzufXVZDGL + xmRkcVBeGSLABwiggBaIbpwTMFU3YdldP8F4gDLGqmuv68+qTWeGMf/YwULhsYG9lcBHdRKxMTma5xDf + ea1o/CUbUd2xIx0gBR6YMu420NRYUaeqjZ5qdvkHW1xTLy/jHqzfWOMQiNzqHzbYAQtWMCnevEtIHWxy + ZSzTbKJ2ttqcTRbHKEcCBbhAAvGupUBaUJDqBqrdjz4l4CiuUhQCNHsRD+R1ZAkDu3rDA4xB56flKa82 + FstjRXvrskedas8iE20HWIAFyltLLOTnNjGyDq8P3NIpotuvXl5lFftJSMBQ4FndcFwLEiAhIqtPZMVr + 79BAJupLAVfE6vnNCEiQAJqL8uZWuAEMsJKCgYUbhn/1NcZjPLPrKRqmjzZU/1wAA0xjwwMtWFf/xnyJ + dWOyac7tHOq/hZrcjRWAAAMggL4c8DCli/0KtIGBdK+1cyxFc93acvSB0S1moj/apNdBHAtgAHls3IAF + J4iJOiOp0bWpPJNxC/yQsA5MedJrOMZJAY0i74URQcpE2Fp72iO93UTb2Gri9g+CC+eX2UmZGx5wQGR/ + 6B5TE3H2pV5nTwNu0X53lnOJn8wIEqAAx5ve91/IgEosAIEI6KXjQHeh6wibTcC9CquojbR1GmABQVtD + DlTACchEy8ENygGRv2lKnqHc1HHYywERAYSFAWjGDLyAYahfGATEC8jAdOWYYdXfxSWfYK1d/tGfuQ3K + dLTAC+BdNGwABTxU/0TF3pOl0Txh1FvVy/YBXJJ5xZ/xXgtmIBdIiww8AF7MnaJhF9DhH67902utFK4F + kIugSATU1sJNww5AQHpNVJvQYPa5zQ0OXpwYFRHB3r2MAAKsAHdERBCaAYPsQAw4hzWx1hW9iGG91pf5 + UR1SlWpJR4PFAMhJwwQsQO8YlZOxT8AN3jsNkXFxzpG1UQI4QHJYIR3IAwdwAD+gWC8ARQ7www1wmxxY + RWhI2god2D/l3wqdlGnlX1VNXEOwQNhNQwWYgHoNHFAl2VDBzQPqGQ9+odukDQKYwAKkAAUA4BxkwAYI + RQzIQAXIQAxIwA5wgD8AQwbggD1IwATEAAyoQ/8OSOMd3MAOUAALQMDZdZyjpdJpxF3M0NjxWdX0VJf0 + rIAL4Ik1aEALlIBvwFO8bE4YahiH1R5GIdNM0EQJrABb2FwdxMVcbATLmFB2lIZDtMBg7MAkggMHvAAF + aEQLFEUEcGSBfEQFxABJ4MEN6MBQuMAWgR5hEdQeAlQTRppKmqI17UUKTMAnMgMHuMABtEsnjeExZR20 + MeBF/WTB3ctOkQUkKpFNssG8VQBZmUAJIADQkAAJwMQBTKVCON7y4MIQCkx2cBMDMMBXgqV2+F/64YFN + uQBebMtevQ4KZV4fbcvxvQpUTRyMNAAFAOEyYMAONAC7CAtngVg7JSK11Vn/UHHQbxCHASDACTiApcFi + HDCIBDxRWbFVklXGAeDEjHQARbICBuSABIgiA5yAAphAApiACZAmaZ5mWszKsOVlGzhKDGgE/NkMC9UY + S0Ha/gFUSw6YNGVHCnxINdiABKjAAcBZkQ2cMKWce8mXDs6ZBileCCCACliA7eABlJRNAryE5JRFWZjF + d3anVSoEA1Dha5rCcBahCR3ECZwAAyiAaMJne7JnWJZGClSAUuXBZ87AjkzJosWdHkqcFG2NHJ6jMNZH + DVDDeDiAcabc1DXnT3GScvljJrUNvHSdCTSADDymHGAnA5DFCHQd0HynVJqFiB4AiB6lcwFiKoxIC6yA + /wIowHyCJXyOJVi2p42mpgrIAAcoZRtYRGicHV64EHepWzsOXZGypECJWUMihw706DFowASsgHEaJQPW + 14S6ERdy0pGpx0wYQAmgQBedHh10wJmgE1l8p1VOpVROpZp2J1kcHE2O6Sk00WSipnze6AmgwFfqKZ+y + J4yigH1uKIfmwEUQBHWhIpHWWEr+zfQQUmoE6gzABjWQ3YK2i5E9W/cJVZs0opYij3BUSgksAAtYpx5s + AAtEDomCp1mUBYmqapqSQAmoQE22ggeU043SKI1yk57OqFjmqgME5x7kEUtkS3/8p/GlCit21+CYol0m + x5MaAwa8QHEe55Y+4LVSKP+SFZGyiIUBHMD5ORi0soEArkBXtCqbrqmJpqlVsiuK6osLvEAmfsJIvagJ + iOZBwOeu8qmN3iuNnuYJRAAx8oFVxIB0scx0uAzy8dXnXdWXseJo/GaoXEA1dEADUClyXpYieh9yClwy + yRwDtIDi8MEGzIAKmEBMtCq7rquIqmq6Ag2IIgADQMA8osIDSQ1p8uuezujOHsRX+qyNtmc8xoB5vgFK + 6MBApIBp0F3QXQ0SFtaWtZBBZOicOkMOQIBOVspy8qA/KuBF/ZLxsMcBgGkLeIC8xgFxQuWJtmy6lmjb + qqy6WmXMVkCxgYINRM2e4umMymfPtief9my/5usCQED/rPUBLjmHWlrTzIQZXyVru7UOKgVqDNBtM9zA + A5CAhYXfRtWe1jZoqmlKhS0LA5TlBoirG2yABSgAmqopu7Ip67ou27JsV5SAC+CnKezJAsSor/KqjXKT + vvLuzuLqaKqA5P4BSV7kA0SA0trf0pYbHp5jwgiINz3XNVSA0/WiO9XZIbITxzCnWITACIDsxwECDixG + AnQFrL5u+rbu+voICczq5HICBuide/Kq77KnWPYt4Oopr/YpexZkqfpBQNgG2qnUsrLK8C3v9pAtNggi + CQiP9iqZp0ZSvlnYGZqAA5Aq0cqB/O6OBLFum7qsy64u7E7l+YJd6VJCg6TAaOap/9/y6+6GZY3GcFje + aFo8RO36gWe+wAy0AEeMma5ZV+Nmy+qoynSoQPcwEzWUKQOcjXwo2fVVG8cWZXR+q31GBAq/wQ1UAJqc + aNelr1lUZVW66tu2bcm4wNCSApTcxmj+bu8Crgv3a9/yL3x6UwxwZh7YwAZcRBHuaXRoCYAK1koJklKE + rAYnw3i4gAn8SOB1rp4Z16YUHAmcQMLBbx7sQASUAIiiawiXaAh7spq+7AF83QMUYyccm9SIJgzv7r6u + cq/KcK6mxQMMKlys2aG+jFVhkYDFXf+UxhnzaDbggAwwwCIn4JUiYux9hYWJrTdBxIoOrAwsgI+Astui + K0yYKP/LgrHKsmqsKkAKzLIaRAEO1MM64IMOcGM3xoEOsICJ0Kgq/6zu/u0cA2+MRgAM3LEe3NJFxKHh + hJfFtRQKFZTLMISJ3TM0dMCCEktzYuqmBsdufK8J8J5CFQLZRYACnGgnf7I1WzMJY7S6xqoD0CwcBMUE + VAALpGVedMkDVMAEADAcdED5AK3e6uy97m6funH99u7+rid1lq0h3MC0TNcWWZcJqiQUuqV9Uu002MDe + oNMZFZf22dnBLUALKNwhYKECJJvawm02gzBVcvVZrC4ZlwUDTO8bxCZWOAADnAfQACMDyM4DXFoc8CUb + x6dYurHPwjEr6yye6hgLJLEgJCT/D59dttAf9vxn4DhABJCqNzRSuc4EZiGTv41hOrXLJ12wmfVYIWAA + BaBAVGo1KK/pB4/x+rK1WBuAApQ1G4xIBTgcOz+lGJsmfXpEBRDbG0wfjMpnDMcz/vouz+q2K/cqv5it + HqQEaAb1lhSpgHVXt2QHT1fyNBzbLO7UAf7k0GhI+U2tInDAA/CQF4f1iI7wRq/pRluz61qlV5jABLjB + DTgRCpTmaWpnAiRECWjnap5mMD7ACzx3GEzfae6qb8+wG89w/wJuHIsmaeZXUgPCiHTgD/+H6ygrwu6F + 3RV0NVQZQtwL5QBT7l13AojuA4BNIjSIxYrAuW4y61Zlmqb4/zW3rFVGRnqzQVxMQHn0SKzSdwmUpnbe + uHx7NkE+zF+fwQs4wJ3ma03br77OdJL3qQzjLARoZSIEBGiaNAHb5il9y1JAwAQ4szbkgAzoUuJJYMnJ + DWJWmAh0M23vdx/YbUUDS8q2bHmDNgjHuQiv7gicQL+oQQZIptSUJlTKd3ybZqDruHzTN2vmd4V7wVzn + 6Vj2bqMPuK/utgvvb1qoAEQ0Qh7JgMDYTHXd2LfESATQUJpbw7GpQOTEhPF8VpygKVUCrLM0wgY8AEJs + det2tPqSaIqP8EUzwAusgd6590vQN6AL+7AHOn2bAAo8QEifQQdYTG7X7yuPpZG3MoDvav97Io4MGHIf + ZMCj2MVgG+G34FoDOIS4nBhipAtRqABOoUcyZ0yJA2OgquGWE4KQj3a9l7aainfcfnB5s2kJgLQDzYAD + 8LjX6fh74/jBP2XCFzsCAGN+AfkY6AAELEAM56/ONnrP3vUM1+hu5+oJTPU3D0I+T4AMiCPLjBmjdURE + xgBUDPc25PFKpDtWTw75kUAwytQaPoIAnkBojzZYh/U1gzXQs6yIdp35pQAOl0GXP0iw33iO4zixE3tC + JADABquelNB6/u7OAnfWazwM2/XO0mS2/wFKvKH73cUQewQLVMAFIvo/kKRsPgAEDIx4tYBIHKQjvGAK + mMAmuyr7wq7/aPN8WJcFTrBAKYNBBkSNWgf7ewd6jif84z/905fmu0cAZ6CBBsjASaYyz/KvXXu9TsPz + 7/JqTrBgJNCGB8AABSwjSFCAM75AO0CYOOeADpTzJfZD2w/CYpyAZ8t57+M7u4p3iwe9ynoreU6A2FsB + B+xdn9d34zf+fZvme0M/88d2oKGBnq/xe3Y+o7dxHN90xoflz4blWih7PGTADWSABuCABmiAFAgBGw5C + BqheJ290rk/liquqeNd/aQMNEIhIKNYOw0MmlUsmBqYqIUqJkilxxVKt1+02ay1FSw2JjXlG8ziyCMPE + QDHgctSpjoqf5vM4XW5nAAzMw2NQkTFL/1NcZGx0fISMlJykrLS8xMy8xNhJKTEYITkYJREtPTgVRT1F + RRhtJT1wNUU9MCBxmMiwXGMo5UowsRIeHuYyDva6KkWR2bDE8GhhUBAc3JPbs7626yOkyzNZeODQND9H + T1dfZ293R+OoWEAAXRV1rS01pWXVj031J0oEAhflKmmA8YABAinAgjkEZqJKMi3CgoUpweDBixuWNsyo + AwfQN0B2BI30c21PH0BvIsB49k7mTJo1bd6UiSNGAxMkDKyqBZQEPn75ABqF9QrViRkdK8VLwSCMRWNU + h1WhegwiggQMUsjIYcnGhAZ5smHjs7LPSm0s1wZisIIFR5x17d7Fm/9XpocIJlyFkmWvFL5VswyT2ndq + 1ioDt1BA8HCkkgcXCyw+fIisGBbNXaZMUbAC8iUdM1KgqCaS5NqTqwcRInnCjgMWHfTexp1b9+4MMhjU + U0UrcL6gwhUHJZpqhAEFLzVcgtHghIIpFKtWpZi5C7IqJxpMuJTBAwsHCqp5O/vHbRz2aVOm1EPNOwzJ + u+3fx59fUwcICUSMQKywVwKyp8BUhMoHnxFQsCAmS2RYAIvqIsqsQuyQuWJCExygABMNKIjKGpPuKKSb + 9FQScS2WFEjAgQrC0i9GGWekUY0ZVvgEwAMRC+6eBAMczKihlELAARgyqeCEhjhzqIsKn/QMDIv/VpAh + Ew8gUDGt9bIZMZv2VFPvtRNMEC0GHGpEM001ccogBhUUQGAEHfUJyJ/F+jGFsFSSk4UIGC+xoKfqJLLK + Qu0s5A6MElCoIBMNYojgm/S2gaO91q75kjU9HGghsjU/BTVUTXKwQAGAeiwusH1UNY4WPQ8A8IROE7mE + BQUOmOIyzC40FDusLkKAqf1kkE6PEVG6w5pC7qiUS0JM8lIFCs4UtVprr03DgxR84jFIOvkpylsD/1kO + lxd2ySRQXHutqF1er3uoBBJOsKA+sTpoAYU3nA3TUrfaes09LhVggAUdsEU4YVE7YAGF5QBTJZZ/iCtq + YqRqGeGEB57TpNR1/+MtlFd2fUVAgRnsteQGYo1lrWV+T0TvpEFMqiYFCv5UOGed89vAghUSWI44wYak + UzAhAVpswASkPUfdid61Dspdo5ZXAQvOkQCCFcy6FDb1mFX267PqkM0BCGJwame119brBQf8gvVUH2O5 + U9WgSHlVFAATkMs2czzOlUkMvdjuUF9JsPocDihwYYWA5xDkm/b89cOtFEXzm23NN6dJgwpuhZjuAYWD + JbhZ/BkaVgNEUKDTtNM14WPCRwbZwl/BQPxqczDQoYK3Cf6DG/TOCrskZuFCXo7vaOW8eefNueEFF0qQ + U6nijkKdQB8TK7AAEVCYgPl0b32a3amJwYzdqv91P0dbK7wEU/jHR0RPUq4VYLAD8Z/nv39HOPGZTwBD + MQElZU9IWVXSSBCKFGTub7Eb1ER2JTKtwAsMwWKfOTbwANTIRiVaCtPjQtisLtXBBChwAQUO5j8WtjAN + GrhRAhaoFHANiIARC9erYMWVBVSAY00jX2ey4yTaHS5x6GhTBBwnG9eIDRso4YY24OJBB7gABuhyYRZd + 2IEGlGA4E0NVYrDHDz6pwgAIWEAR1OG0qU2wQr8CGa+icER05IBxC0hN5OAXJhP1Ky0yu4ZccKZFQjov + AxRAgS1sOMBV7Ugo28PhIg1QAheca43kA8btnLQZi2DFglRAHAvUgYEO+Mz/PPFhmfwAxh7jSfF41YiA + BFBWSFqq7QZXUkC5xiiU0y3mMHJbFawOcIIKUCsdTisc1DqjmTfmbh03cFM1UskearblX/DxRnzmUA0V + zKADWKxlOHO2AxZESE4Hqlgw0SmxiAkNFSZQgQTYAbghFjFqnDTG+tjBnwWY5YPE+xJbHheSlIRkARGo + wArFuVBs2YACOBLjt8YY0Tp5ixVy2tAMHHRMQWWSmURkZvry6cx1aGACjfOgivBAIoBCq49j+6ceUChL + hta0Wjnoz09qoace5Uli1iOdnfQ2BAvoYJZ/w+RmMlM+7FAoK7ijozrsGBXgYSqgLOWDirqBEuOVbQY/ + /7RpWNE0lgaQoAA6AtLpgMJLb93pOBhDABmO+sB1zY5QT0WUSJsZVXXgyzJ+6EYhMPUeL+mRXyXqSqfm + KlbG7iYa07AFxFr1yIr9VFwIat0gj5lUKd3TnnIkKTs85wCyaXNsktISFFWzrIGhIAUJbWxs80OqBchr + ThItHT5OJ1HtEY0UClBB+NwRKBIEDq8iU+ZI+aqOF7SgLMET0Uq61MetvmW6m7KZMWW73du8oIsI2Idu + R1E3IZVuOERD1SRdpNnN1vULI4OaofTpDhxMoAV4TKV7WDq8lzKrfq8ZhwO5O+C6eI4B1UtVebH3xeAQ + 5zAjEEECWGCQ4ULQOhJErv/5sjJfd+RABiswAcEsh1r1QNHEURxYCmDwOgK3eCYm7YsIdIrA7amqbrxd + 644WcCSZ0DNDeJWvMjMZWnfwJSQyrVySXdY1bNxvQyzwAFhdPGV2SE8qoAgXZdkptFeRVxYmcIFCK1zX + 49oOfZtkKiiXuw5SqWAB+Q1hSUAIpkuJSBwNqA2V9byODMxgIQ1GUJBYhc6KljFu3pGBlOeZVME59Z7X + MWIG25EBGLRABVMcbB9Ru989cikQ8UGBCmKw2D2XWhIdSEGcAp1OMGYZh9wbAQJWANuZENe4hnM0SB3N + 4Xds4KTykZ/LrgnQYJdkOkTYqKmVLQkPr0CY4YJ2UXz/udNA12KSYa6Jj6W0SUO9scy8fgep3IBKwTqR + DzKF4rKON0WCvUS7y4Y3I3AAAxcwQJg2jDYvW00xQS+lAiwes3G53VRIq4/I7xiLA4IHvy8dK1Nxplw2 + uMkCCQA83hdfgl+9iNYFs+IwBhLXW2FVghNEwAM20TaFuPC0RDVpr5J+B75UsESRzExs1vXaKqdo0AZ4 + E+M/b8JD2xlGOwmthqMbUiwApIAGTAvlENwCU5UqOE7K9+DvuIEELO0GJTdrbIZFXorYoocUgAfoZ+fB + BmwFHHC9laL22O31TAEKFMyAvcPlLMG1E1KogTsnIJpOK7vG1RAKtr+Vmo6LLI52/1PbgC852vcNz7tO + nxYFQPHEia1FersnDdFXyoW5THaApdQI7OHgaJbktGqp0EyY8RjvHRTOeT2Qg9ynRl8rgILFgmTXmtF3 + 7TaQIQ16nGiAWHkw7fEiJ3bmZ0k2C7Diu1+/Zxu8AEuqDpC+x7Wj8CJIdYiDwAtIPU8LC/m43I5aAg6w + 5neQ0gIq6ODMtoSick8Om21pgAU6MP7pc/eQb9KbVDEO5PiRdCIdCEMAUVM033OvXEuzJ0kzqBIlnLil + +zIB0zK9JJM/PnIPkziBBTCbius/U8MBC5AKpMO9o8gxQrMYOWmd3qMJNqod9Fuqbfskv6MJHJABB/Cg + VBI85f/LlGpiuOBxLbQZwVLDKRnCN36jvAQCirgLrxWgAP5bNFzJsKqzCiJ6ubuQgMrQryEEww1kmXU7 + CxdZwCMcMA6IAOy7oVfTPsJIMFbAFQaAgB24C807Hy0klM7DQjULPZrgANNYgJ0rsX9BlvSoP/kziQWY + AelDwwHTgRSIrH4AkqKjvdo7DlAAswk4QwYMHKnzqAvRuy1Yvz+ciVt6v5RaLScyRFaiAz1iDY2AwUfc + Lh1QAQjDxAEUIxrDvf9AAQroxFqzsPTLq/iyOgWYQLvIAAmIgMCzH4BJPVZ8GUBQABNogbujxdjSgQZY + nbWiPRY0L+4LCjkpgQgQs7rwMar/i0Cp+baru4kcYAHHOZF5HKGAMpFrGhONwcZsZKxtVKQmXLUc47e7 + QYUEYJDFyzaoEwZQvAxRpB0ctIk2SYF+crjpqj9tCizIySb1YAFH5MfGyoHpCR0mfEJqI6Dk0JtFgQB5 + youUu0I+LEY/1IsOmIEIeDOGsz/5yzn4ETsH+KqPJLANUpJXayS1irYaKgWMcg69QKbzaaOQoh31Y7+I + fAGfcUZ6zEm0gBZWgg1pQUigtCkYipChMpoG2yUwAi9ZWA4G8KHboKfZiQiGlJq9Ska8uAGy8CCN7KrV + i591y4MFgL4J+EqwZKi7TAFTAZCBRMqjIYqfKpIXwA3Nu4pi/yifbmO5RoNInPAr5LG/TGmNYSOo2diI + /SFMsdIBC6itn9Cexkw6VyuQUDBIjYrM37OOYhDFp8KrzLwJaFIiQpxHTcuSV8QDY4E+sChN7rqB6MgR + 7bmYAzqvpDgjFGgBI4jM8mOSzsPOwdnC28AAqAiJEcMqYjMeTVmB6STN4wyrHGiBXFKnRnIVdpLDUTij + Brii3Eg5z8LNrMBPmcQNx3sAPBqs4VnFmKkmPQCuYkJP7rIBCGm7cFSgVfOHEbDGc2zJjuosZYDL94II + 4suNDZCBSytEPgKbIwso+YsAs0vQ7Rq9hYgbBrubb0GgV0CADRk13XjLXvGkCdqOHOXQ3P+Qhq35oP9S + i5YxlrjIPwpNUbGCMRMol27BLe5pTVBYmhfZDRkcOLu6zo+KF3e0yxd4AJqLn8IT0z+wAxWwAA84zyQN + S0QKmsuitgFUiodhAAvwSLwAnChpknw6s+Db0qm8iwyYgBQIPFD7NK4JO9WgRgaoJHBS09jaoIVISxra + skgKjoxoASRlSutUqtt0Ss/Szbvw0Abop53zJ5faI5lagRMdzEatqdg7AViRk8RMDPASDjmRUp/cv/u4 + UQzTgqecQaf81LvggBjQmumQJlWCLtkwVgd4AAmoU1YVKxygAChQhVCgkzLCoUWZAQqzDzbaU2JIph/b + 02ToUfvQCZv/jL+F20DkG4TwW1VotSk7sskTUEJhqgcACRpUKIHQSAGfy48bdbk8RJ8g61NTvI0cmAAW + cAHS+jRpUtaHtYMVaAAXYAEYCEZ4ZSwb4IAJ+FKgaQwZW52PXZ0RKIEFaAEK+KYYkUzO2CQthK9yvQ8b + yAEJEERwDbEQq8ZqPIEqkoEX2AAqxFglrUrpiLrPGBQGoA2YmJGUq8xtqyBHe5JSnBENeAEZgAAVcIAV + WAEHWACt1VoHcIAGOFkOYNSgdbEM0AEJoAALeAAXiIC3hdsWsAAZkIAOuFj71FTCAb7Oetq7Uq661I8M + 4AAPgAEZqAALYAHEtYDFnQEKkIAd2IA0/zVbF5PZDtiBF8DcHeiAHChbGQFYiuC8/ew7LtUPG8CBHOAA + HegAHeCAHNAAyZ3cUsOADKBd2NUPK+3VhvQsX93ONbkADADe2BVeu7jTY3hJC8LSYB3e5a0lb32vgcs1 + 85Fa5qXesGrKi2iqz9q1eTHY6vVeF1IXrgC+iIivK80QKmDL71Xf5j2B4soCTyW4zeC8qGuG9bVfLaoA + FOCKKpAgzIAj6A3dPdyQDrnfAvafGCgPvi04LbXNlTtf4EJRA5ZgzoGBSGERcYXJC/nfLMiVx4DMCQZh + zWEYFaDXwJnL8r2wKTgBM8XUEHbha9kAxpGKqRCc+f2xRssCKVBUGP941hf24U+xgdLQX/F9NESpuqWS + IRJgRA4A2h924hm5yxUArwkJYD69DKyIgiLRhSfmYmvpgAiggjDWT+H7KEUJBmzr4jQGFeMj4QSQAizV + 0xrkjFxhgKZ7VzXGY8faAQsojze24uFbqn3tOQHL40KOkWX8Tyr4DML5DA3NpChIgDRCU0Om5BmhtHrz + C67QAhuO4zCY0RMIvyau5FG2i3mDANIy4zCuzEcOBqSFgAnoYVKWZbvcgQqoN3kprkUGV4wIA31FIRnw + gDue5WHGiRygNyXRZIfIFS8oLkWVgFkk5mjOCw2QABaIgJkzITceije2gwVQgQiguLuV5nG+CRu+2ICq + hYDelJe4SYATkFgIoACftV1ypmebwIANgIEKeIAUYNjZAGcZgAlRrueBlokMwAEO2AEPkAAYkIAX8IDN + 1YDOJeiJpuiKtuiLxuiM1uiN5uiO9uiPBumQFumRJumSNumTRumUVumVZumWdumXhumYlumZpumatumb + xumc1umd5ume9umfBuqgFuqhJuqiNuqjRuqkVuqlZuqmduqnhuqoluqppuqqtuqrxuqs1uqt5uqu9uqv + BuuwpucgAAAh+QQJBQA8ACwAAAAA8gHyAQAG/0CecEgsGo/IpHLJbDqf0Kh0Sq1ar9isdsvter/gsHhM + LpvP6LR6zW673/C4fE6v2+/4vH7P7/v/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp+goaKj + pKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2+v8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f + 4OHi4+Tl5ufo6err7O3u7/Dx8vP09fb3+Pn6+/z9/v8AAwocSLCgwYMIEyr0hsHGjRs4cGzAoSGDDQwL + MzaysYHDjhcTYsiQEWOCBA8cNtjQyLIQBg0cPMCYQKGCBRY3Z5A8yQEHxv+WQPlgwPExpMgKM2ZYWDqj + AgWSMF50wBG06h0MOTxQUNq0awWkXr9a0OlhQwaraOHg0PGCwlIWSZHKbQpWKc4ZFF7o0JC2bxqsHmjW + 9Up4bl2nEzzk+Om3cRgcEmTYHEv369fKYSUnbSrjBVXHoLto2BFD6djLc+l21WyYMoUdfEPLvnJDhwSw + uA3rDlu4AgwdZ2cLl5Ijsk3McpHKUG2YuVKnEjgMn+4kg4fjXXmj1q7TuVIZHoJTH39kwwSumJfP1cxe + +Xa5OGF8Jk9fCAYdMZamRu1eO27vFsTAgXj1jbfBDludZplq6jmX3G5gUeCBTwWOl0EHxo3VYHL+6QT/ + YXd0wdABgRXOhsMLR8W1HnfNNbhhXDF4VuJ0G8BwmXOS9cefhxxutxoMOcw4HAelWbDjiztup56OTRkp + oJDCdSDDaXHxiNxqqzXX3HcdQDmblExZpiWDK17G2oPf6eClbFLCBdaSLXY4pno3ydDlmqDpUIGbYlaZ + 5JjrLYiUBXbimeeU2XGIJIOEvdggCxTcaahfUj6QXqNMitljj1xOyowNGTz00EqE6CADC/wpx5yiicap + WZouZRCqRYx5eodDHenQwQ4e9LpDBzpwkENFgLTpoI+pYqnjjiwU+kcGGuTAQQce8OrrrylpQKqtcdzA + AUgxUPDUUyOJW5KI8/Fh/yqVqqrKmp+CKtvdoM4KhQOGNI1brgzmTvACBzdw+8ZQHcCQ4FgIJ7XUUjKI + aFYfevJ5pZLtyosmvZLqwdEOEyxn2sIJJ9VwByoJvMYGMnUMFmWbUXYavzAoti0epqLK6XsXe7gqlp1q + HBMMKW4m9NAVyDABDDukazIZG7zwap+b3vhVwxzUaoexZuq8aKaM5ohUsxnbcZ+NECbZamcbLE2GDd8e + TNnFu+FkAQUS6DBzHesWFtaKZ+L4Xs+3ciCBW3f9p/fK+uU1oNpg2NBBTa8eLrlcMNtN855kHvthxZwS + GvYcGHSg8uGALqhapIx/Yd5NCgKa3pYzTBDkHTWbvf+kir3t3d2rnuPBwXksBh+3BfKlzgUOWhUOr85S + c6dUXmlffeqq77mYdX+6Yyx20wlq3tvNXL0Wm/FXZECax9lvmrmg/L4w/hx6ssuilteb2RzYdmjQ1nIK + kr4zpzqZwA4CRj4r5GACujHcnOaHlBhYjg4RW9+8LFaZOa2sXnIIXWly57qy+Ul2BaxC6NzyvUtxDXvK + mRDeTmU7ipXJP1nrHR30hygFZk+Ct7NJpO4WQifQkCtxUlSgjvUcAZLoDVhjVelUg0OxyFAONyjYf8B3 + wop1hVDu62EUMqADG4lsiRuiH28C2AGruWFdRmLg5Jb4NRmoKYM6QGCYHES6duX/rCkw4AAPtZgE5MXA + Jh1c45E4NAMYvO8NEbweHYNox4o9EQ4amMAcA+mov/2HJCrkYxM4YLBAumdB71rOhnhHgTfGoU3JchGO + OJilK2LQDRjgwKn658F4OYowdKEAkDTJhBEyj47vapTu+kaoTMKhZkS05P9+uZ1mmfINyKOAxP72oonB + zSsx+Bwvi4CBHWBHUGxETm44ExdCTaADh2RD/NK3SmoOkXevZMNoYCAZKk0OMx2SnJ3MuM0hYOAFx3kh + FeflrmV+xYFxSKRAs6REvb3rkW3g5FYWKcxlYUpvTXnBHvvJAxu84G28CSMzqfgu3Hhgo2ionQdF2aLd + 5IiJ/4R6JhswcB35ddCOWlMmbiSA0m1iQAJzLKnrkKRMuixlAkpbQxIJylQhTkxeED0ZDIDo0pHek3NO + 5ClHj+BRrjxNeMxrKUbhIoOkIXJKaYxXC69quqimAXn8cyo4JwjGvy1Fq1vlZk2Fd0JGDbFPOomBBwio + TszpNGdU3I1bz2C+0f1VfaC0Xyt3NBa85nUINtjB1nLq11b2rXligkH02IBKNG22pMCcC/7aUCOpgbM/ + qBWjUEFUAQ/wc6txjC0uy+a6iS1lh21AJs5gS72qxmuxZRjhHD2rPpbK67NeIYlML8uD4jxFjGptJ/Wq + RKdmSSCpZ1jnC0W6H5yuCFZsOP/RN/sq2QRSVD38+i51izCajuEusSXkFHRRFQPYqHN67X0qe546tcsg + dwz13ZPphsbg/DZVO0bz73wxy0mP6VfAIX2unzgzgemaobTbhe3mngq4NPzuaQ/SlNkWar/U6HIxEybC + DTyA1uEmKqwMxSqLsqgGhWo3nKps0IHDoL9x7nZ5SmzxIotJ2BgLAUytw9RKOTjFBhWyaj2uoZSnzFvV + xpMMY8OvTilKP82s1slDIJJNrRo1sL5nLIId7RkqRabD7Cak+r2gNseAsiJN1qCKxCmcqpSUCUgHzUMY + zR8rquE4+VWMRspLOseg0uI+esqDHrIX9PfHtyXrSEiW62T/neKBSceYKIvGswQhK+bNyODQcwbwlhr5 + Z/rNRdNdkGU+LYgzHEc2O4IFL5pbq6HmGreuip1BeFKqZXeNWcRWUlWJyZCBF5iG0QOuZBB3LQE5Ixqz + Nd2P/yzJNYyOJY897YKPY2teSrpyz1+I5VTDBLUEzjqnYvQQeNId4wpPkbOCpuCfwiLY2ZWh0gMPpUsD + dSNcayEHIBmntP/2urVqyWiw/nYRoojA+/4vwNB1p4oEy28tLHWQtRY4YRyOBRt44I8tFeuYHbpy3wxQ + 40gYjVs8rb6P37A9+PSNqb0gXpr3+pMU09m0iQy8Wi7Qlra+Igv6O3ScH9DjMr/ZJQnZ/xpIefgL61Zy + r61cb9Ww3Apsq3FVLy3lzm5plzhPwg3a8k53I1Z4RnrBBm7LhdqJ06E5WxQ84b0FDGzgNp7+ecwBP1f4 + DjbuSZB33273UlpbGNo7gpExwwBiYJI5ayy99Ze70LRUp7LNX006vNSjSyxDHgnmm/fndyvX0s0lm2QQ + 7mFXOdu/nRkMGrwzmqiMXVBecQbZbPLrjaCB28DFoK8DK9BbxOMwFL1PleduMoe49C6ciISybTRDmaq7 + GaDqBcpfPjeltOGKWRjwq65oBTpc8ir4mGvtWfj4tRcGttmIljkWfc/GOU0SKXynfjxweC9FXpHVap/W + Mg1jcGDHQv+1JnzY1krdpwXy1j34pEoUFEbhpxwSIIEIaAQcV3kWB3/1oyzJkRfptwWoRHO9JyedM3pZ + MHepx07mxR3TVxcUYEQlqAQ6txlCJHLZF3jiVmgk2HcsBDePFW3up3RnFwVXl1Ys9km5A3QD5kRl9YJB + SAQ5kB/9o3CshH9TdCN4sQNHpAX31yp09YaftR1T+ARRhFaqlnTuNXnJYn4BsoRfuHES8BzUk0NNRUl2 + JQMSMCITyC5YCDU4lkOKZYNWwEX/x0QJ50l5ViWV5YV/OAS5dXmF+HcrZom7FYFfQGcgNz/Bk32/twUS + lSigWCYppjX5hRsN83WdOARR5EXRR4j/5ZVhUCcXRnJSRNeEFxVwmViDhEcFLrdenoeCo8Zot+YbwJGL + SzAaWraAY/dLIfdUlVV1VLBUQoVdY/RCc8gEGgADy0WOZCaKGFhW4GiN1WVfqreDA7UoUhcpnEgFeSNq + YpcpSKdnXRBFhIN1TDV5bxhWZgNC8rgENzA4+WdRUVh8BCWMhFI3a2h/htVcpLhts9WK5cNJNtRqR6gk + u5Mc7bOPDSkEbbNhlKeQktWNs0Y3wsaPxghZAmha5iiJUnB4W3FT3Hh0hUhIMRAdK8kEGfA72ieU/4Ys + PJgdyIeLUyCOWThudCWHbsQFj1NOBGaBobRMdBI71XiU13gdctIh/185fSy4UzUpBdenZJA4bqwCklWQ + johCe2+IWEwCJ/tRamTJBDagAz+ZhbvHbvsHbB2gkk9QKUZiiLSoW0XTJHQ5BRrQAZ22Rgr5Z2dia0hR + Sgf4l0IAGTXhcYIni70IQ1Rjcnc5UOQoSh3JMMvoBPdhHEgmOScZf6AXFw3jbaDJVRUGUobpSauoIi6Y + BWByY1FHVBTlarHZBDg4i/hVTQPoStFRf3+ZWdJES0kWYrXEHR32mU0QhmK1hZhJcXLBkFeglOTWRH+1 + M0Bnfq+Rkb1pBFeHnBZTRaGYfUkhIW3pBOZhZ4BWZ6ykm6KFBRqgFYIYaHdojxa0FDHgh/N5BP83gCCH + AX3WU5G5M0ZGk5hXwGmXJ3N5uX0BtHlTcCFHoSE+B0BqJVCH0YUR6p8USmWh6JSKBI1fgZ5UwEWDQ4S+ + 6GvHmCh080BVcECbyWozSpj/E2cvKpsHFFCeNXvB2X4iswMGiiAJGo3691e/JWFV4Dh3uZQqF4INhUcw + tqRN4HJUxUrOJZEuRFd5J59PcEA3IZzPlh0sMHV61KGIN1c6tplsRnNYBKdmWgRE8n4UaZ5lmBpJgW5X + gAOy53O9h3S4NAGKuQRjgx4MZ0L+E5eoZWi2ghEYEKrgiQcTCnOrZns/6l5OYlZWQFODKY2iOCacQYxW + gDznkXixOEyg907/e4NJ/XkVoSorFmGd1WAD0TItH3ESwJItozoHcJVwzIVndfcfkZZHzZoE1rV1rIIl + PdoU0HMFs4k+qZJvrgVqD5gXFOIHxpoD1PICEhADMKCsOvAw3uAtKdMxRsIvPygBO0CvfYAV53GoVfmE + V8IZLyCogCk4huk1jYhRiJink7g/0Fc/wxeghiE71woH9mpfFvAALdACZHU0U0GsyqABG0AtQEMuNsEn + I3E0OxAslQoHGRAZuENULEp8XyQ0FSBf5YMfk3FROXtHp0F/BupFgHRhhPh+7LYe7CEB8QgHL+ER71pP + H9sCEAABLfAAOOEUMaMD6ToNBEMTDFuhkrEv/+JSFkJhmShmRQP3jzXbVjHwtEwwoaNJhCgpq+jjrTeH + BTjgZ3JpmtCIWh7DL7i3B4YHUHd6px7LAh6btQ/wuForN4i4d2DbZ3aBHlLaMjhRcCSrBkRxq61zdx4Z + pjdBAbxJBfcyE3lLNFCZHebEr3LLBDiQndi3Vn0Dlp8EZySaP2whAxAQAS6AtVn7sY/LuFVrtVb7AL4B + sc9wISGxuk6IGpSxE4oRs2uAFdZGJbdkXCn6S6X7q3T4uUrxAGm1YVI3FolRMlqwATt3m12Ds4ykMJVF + uXhQmZ3EAlZ7tcPrsY27v8NLvM2ihtDAAdJUQVFnbwQ6FXngOBPlj+15dP9WZBoxAL5QcKAdFy8wNH+7 + ewUbEAN8opPtOK2KGlOdewaHtyf/y7+QC7mO+7j768JWawE6kLG9YHiRcac8917OBkSJwQHacgeQAUaX + BpBQOCgBErt0+C0SEBKDyTpfQQHwGjMA4wV961VyGaJHqJkFagcZcLL0xAJYK7z8m8Ig68Ir7Lgt4AIR + wALfyQyH12kAOJ6a0ipcqxdIbAaNVU/t9yY+MlvklR2UCgZdXBT1xDp4ESNJg7BUcANGayVbA5eYSRf9 + pchpUF9TMsYsvMKMy8KbXMYqzL8BIpXBYB3imqizdxxugi40TAb60z02uzfxG2BFAwOUnKMbwK4esMT/ + 8VotOeCvX/CQIUeAlshI7uGgfkkHgHEqaYy1ZkzGjYu/YwzN/uuxEMDG1qsLhleJs3hkV0U0RsOvvgwH + cmozbsZdTHkYMVLLreoQonIRZWAdpten7pVicRIfECpP3yJHHyu8/ovGjLvJWrvCkPvPjYu1FOB6xlAb + G3Rji4SJ/xOkJSzI2euSAEfEyDgyqwwIoWMw5kyApqOifDwoM4B+zkoaFtDCn/zCaDzG00y8Kv2xFfAC + 9+wL4eqkh8o3tpkUODwyOaDOYiCSDrY5soUbSjoJTdN0n8Yq5OmnXfGDGdcGBIMiYBy8xPvJAX3VxQuy + BI2/iru4LH1+d1wLrSy6/zJqo7Css4RbN9csyF1kqEFrYzu8JYa21oPgfwFVV+WZHbfo01+gaJOxzy3N + 0o072Ji80mWctcYLuTJwur8gp25omjcLbRUkdbGDTpCEoE84fK12kYztCIcHRGGaqpMFHnRNxQiSvyid + yZxcvAHN1V592Mab2MYLAS4wA6K8C2pWbDBUzq+MS6zTMDuQA6XNBURit0QEcNpVTHxNCJk1TpAZYuNX + aE+dBsaKIVPiAlRd2JkMzYUd22b82gCNxmlsAc2ZC4LJiLx9wHb2ISPxzVPMBsC8jRJJiij2JJeQA/TU + lEd2syqCiMOdBfVlfixc1Z4MsgbuwpvM3at92M3cyf/UbAEvkNGxcCG5Gk53VK7wG2l1owESjgXWxRSH + +W896iQcegnO+6VAqZ+mQzczLQbGiiAnfbXM/MJe3eDRvLjD692rfeMxLAH//Qp0i6tFSEcYuntaoiE/ + qBdfewZYoY7kO+TGh9Mr66KZQLdyQ44AqVoWIDsRjXY/g8LHa9WG7d0FvuMMXuavbbUs4LTEcKCbNVRM + kqojpiRx1uUi1AGGVc6yvKidbdT/59BcB4FlpAZcdB6D3cL+q+M1vuDgrcIHnuNnDAHEgwM0MAwHCn5t + O0Fx+Wt4KKBo6BR6Ec5kUKqYY9zt+VUkoXcdfgjYKxI625GOprs/LgUvoQMI+gD/tO3SmezJiv7oCP7d + O97ajk7NLCAfF2DpmgWcmYOCQ6Vdj9yr/CJA9GsGVi4/F3qETnLMnuBHRhxtDHU7v1XieGwbU6K40yzQ + Ng7pv27mNe7rBn6n+7zmOHDswhDkBIZRHLmeg/QhlyshOWDnUjBj4fJSr46GugmvG7wJByK2gwE7rvYU + /TXrW2QbM4DawN7SiQ3b6v7uPL7o6M7C1ey0lS4MmeXWa3qaex6pViVSTIHwPszkOJDPe4ITcsMVbzEW + Pzivyx0JBGMwN78wLePE/jKvqw4FPb8VuB68M+7oXA3bwf7awO7VGY/jkG61LmABPl4MjzOG59zQAwvn + ECwX/3FW9FBgA6h2t0NEN+JeCrVBm42EGnXOWArbsYJt2Bdv4x0P3oie0lv9v2quUcWQ20qXjKKtjcdo + S1Aov03RX8JN9rKpAbbuAS/grjBQ+RLwAr6i86rQxbsi+RIwE5aP+dWyF45/pqkrAw9A1QSuwond3VDf + 4J58xq79677Ov1c7A+WNC2GonbDasDTqP287a3a2r/0K8LRu9jkQLMNi/JvQEMeqAzmAAzfA/GVfHB0z + 2+cO9Rxf4+G91bA/+/zb+gjez1lZDM0Xh1di+MaWco0ocXxKGDGy5EwuK6XvCRgQKvVf9iLZv98NBK2H + sMV6DI1H4RFJNBKJD+MzuYw2k/9KoyW24X3BYfGYXDaf0Wn1mr3OdCaV2Vxen8nss4p9r/fX+fQA5fwE + /w4D62RiJDpwMtoiJScpKy0vMTPFNHI8YmaGWiCchpiUkEqLsJhUWVpTTVVlp0pTXYtkPCA1eXt9MXF2 + Pi3uEuXw/gCLl/ua7+j6kPnsZPykBfcoYHY0fr2/wcPF1XBeKCxO02NRWbNUT2VZj6pcn7TgqZQgIGYk + vMYBBsSEIYeECsSURVNW7RiiZIbw9HHIkFmiZRZYWJAxYUeOXQJBhhQpEIMGDi9ksIDgYtSVKPVsxZPp + zpUWUrPezUJFBMIDCjowjBQ6VEwGlNAMBYr4bI8zZwynHZv/9lAqtkLE7sSAIYHDDaJfwYY1U3LHBDxP + WqStJcQeu5rt7tmKu9OUvFIwrSCB8VFsX3EcYFBICFFiM0JOmTGl8xCq4mtRreqJ4SioX8uXxxF8UUFU + z3XsiuRc+xY03iZ04Y1eyyQJCxk6MMf2ZQNwhYzWEBnDrXshVasWG/6xMHx4hQkedHiVvZy5JAw4OsCo + 8MAFy7RWltTCNzd0Pp2fbeLNJ69FdRYUPChvvt65jnNYgReLxtjYVKhK7Q8mREfGIgk5KmNPQAExgGMG + dK5bKworSBsvJ+/cOW2VzxbESxQXLNBlwA3d8KQ/hSoqhCLecktqMf1KVGgPZOD7L0AO/2H0KwMdJrhF + rStCYXC1vOLRLi8pYqkCltBUk4eFfnCIUckyMjiJgjkOPMShhKipCrGlEJtKKYeirECbDtRbUkyRNDAH + lFFG8TFC0roDTQoeU3OiuwfrAk0UUWY4rpsx+fxiA3Mi0lI+Eq9UzERkpImvPok02oGvPiH1RgMJVOop + Ox3l+o61JSC8h5Z3wDuNSOyOnEAHGyLtEwcdPDALyt4EbYxQLfF7prGlRtQDoxlg4ADVVIHVRIMdZIAg + AhdSUw1TOX1U1p6b5FqF2bRW0miCFwAMls8McPAEI4T0wHI33gxTrDDGkgLRxDws8JIrbeGtZIdz9lEr + SFjY7LQVTf/ZAnInIemM5UJ+sH00XiVviE4wca3CEsVxD7lmREWpzE0GCcI8WGMzNIghxx2zUIfONotk + sMJ2bqriOrYwkuGFJDfm8zlWYZBhOBb2y6M3RK38zZqmEuN5ImyUmSGGbGNOOgwbOuDM0mjx1anH7aSm + CUhSULNiJVwayeFXpfmEztVXFaXvoUMPm3JLZ5AiBL0NvgZbYxtygMGCG9M5GdRlq4arzZPpuvTji5GW + u08NdHghMDzgK/ExtKtKlJp0f05GYv5i4MbwjTcwKJR7dAoZay3oCdV00JVYma0ZvoR580gx2ECYg4Yj + e7fEsqS84ip7y60ZCybg4PWDd5iBWrz/1cn0WdNksknUmv6Os16c/4t7+EiHDaxopwwDsWdYBY0qkFfn + aHeH67XFAIYH0iQPLr/9BTXake9Vc8iMKPAHfXgzyKGDF2JQjShFRmewokoeKPKYWvnmSB540f74dIMJ + lMczgpNJj7A2upQF6VLLo9Y+cBYD5LgOgsGyQbfiAKUDGsJcZ9vd2ioHHIxUAGMlhBQOJkCdBenoHW95 + Baem1kM50YNIn/ocDTlgMBsCC3ESmIBgVDi+xzXkeyEazBSldCAa7mmJS4qdx9rXtw26xFnhQZ12cqSW + O3AEbl3c2A2cNIOMIOQ+lJPclCLmG+AAjRgwwEEN3KgkglBAh3HB/6APUTaFB/0oa/aA3kogYIFtbOCB + gYSXZmzWLjwmkIULueJTxMe2arQLBpS0JIxs4J7PZep9rXRTXRy0qXlwin1FiIEOlHhKeJnEAzAI4Ink + 08L5TDF3iFlMoKJUPV1uSAMdSEn72mLImniwLRWayZBSUQTWTbKSyzzYDXIAQNrNIVF4LBfbBuEbodmB + lIXzZnMSJoPPkYJ5AKOFasaDOmit5AF5wuU7DUeQVn1oMevy2aFwR0WFOoQYLgLoelJJyDCy5i48ehY7 + JPQSKChoCq55ga8eujludUACLCKflNK50N2ZUzgVKGVImzPIWsZEZPOwiyz2Zk+XHI8LHvBIN/9hGjM4 + +pIhjfMkbhxmKKDNp1yjdBkXgxobHBYyp1jQW+mUJ7BsSsFomovq8GywAZKaZT/ALBvQ8CBAte7xQLnI + 5VfDIsFCmlF++7oaXKopqs9Z66MZg2tAh/qk2q0QUes6jFRW2gdi7ACof/2KDSRwp9UErpo+tOe/0jgK + LuygjY7dX5Ne8EQWocg+CKUiOQshB43AxrOXeYEF0mQvwZ0in2K8aHY0AgMwtdaGcNxBYL4FpXJWaYWg + tNgL/sHbvnAgBhihqckcJKTSsGJg53mBDnDQWOVuDo5x2NXkVAQRg+YKgTD453bFEgwK5FVCIMMstHjS + E/SQEL0lhKPiAvj/SbVFLJ1LmQMFOgDV+n6lW7CVbWUxysrVpIkYG9mBXwcMwZKQlHG/4V3lGmOiA51H + eBEOS4FmYJ11YDAUEaroEbamEWxB2MMlnJEEYpA2FE0sVvuBAYtbHBIcUECyJGNLXdHopiOJkL457mL/ + xkoRcjYkUIhtSjVYlNsOG5koGJiXK1py2+VJgQqhybLRkCNgKgdyVTUr62AKoUIWzlB/Y/4KBphLQU61 + phbQg8fKPGpKN3vzvhPIr5plrGFrXGzKex4KBnQgz9Sp7mMbXdkD2nWcIhv6lLwcxhy7pOaCzlDS2qU0 + QGYkHfbtI7apu/NKWOJSR7z102Sel1mJ1r0K/yziwa0OywZgIEe8yRZOPbGAQ20dUsR54AUwpgAy2yqD + Y2tFAjtIYrDDMixjb/gJ9eJyuxaxjUlD25slycEOYByDY0eJAjHQCnI6y+24frukchjC1riavx08Qt1w + LYkOdkDscF9rBx3owAZYXe+R9M8DEtAeOScwgW14ROCetUEGbnADDeDgBhmwAQas13Cx2EDiONjABnKw + ARxo4Aae1vjJUZ5yla+c5S13+cthHnOZz5zmNbf5zXGec53vnOc99/nPgR50oQ+d6EU3+tGRnnSlL53p + TXf606EedalPnepVt/rVsZ51rW8dphjAuA3AHnaxj53sZTf72dFudoubnP/rbQdDkyTwJGM1IAUNiEAD + 7I73u+ed73v3u94B3/fA/13whd973SPQz+O40+2XwAA4OQBugztxKzCo/OUNjnnLZ57zm/e85kHf+dBv + RQIv6AB2M95FDXigAilYgAkOIIIQFCAEs6897W2fe9zv/va9173vef974fO+AAQQAQIUsAIXyMBRjcdE + /0J7kJUciyXHMlb1sX997Vuf+9nv/va9H/7tW3/IjcAx+gqcghUkIPYD+IAA4B9/+c+f/vW3//3xn38Q + GIAECnDA8nfL+SShf8rCZlogAurOAVRAARdQBRrwARkwAh1QAiFwAi2wAjGQAiXQ7lwAZyigr7qIA2b/ + wAEQYAQMQPYIYADc7wNYsAVd8AVhMAZlcAZpcAYHAAQIoABEYAQOIAEagAKSSwDTAM5yLRSqAwHxLgXq + TgnpbgmdsAmhkAml8AmnMAqp8AqjEO/ojiXShAUmI+CSxsosAAVEAP4+4AZBIA0JQA3V8AbXEAfdsA1x + UA7fMAXnEA7v0A7rMA7xcA/vMA1BwP0E4ANGYAUqIAeEMA1mJIdSQAXsDgEj4FgicRIpsRIt8RIxMRM1 + MRNTwAUikQkdEQKY7/xiJgdiwAUYYAQIwAxVEBDTUAVhMRBh8QZnkRZnURZjsRZxsRV1sRdvMRdVkAXh + jwBIAAUewI8SkQxixwPW/8sFtFAJoREBPXEaJZEarbEasfEatTEbuXEbPRESlfDuHDEFHoBwUi9mNsAC + FgABio8XAxEO17AO2TAP51Ee6fEe7TEf63Ef8RAX0zAERCABHIACwLDtmOtuEDAcK7ETN7EhHfIhN/Eb + JzEFPpEDfaID2A5YboACUMAAVhANXTEe+VEf8XEkTbIkUdIOXfEdB2AYD0AFXiAjs24DGHEJJ5IhKTIn + wXEndbInefInfTIogRIop9EFepIJI6AFfkJubgAGGoAE/FEk3xAPaZElrbIqsfIqtTIruXIrtVIPQTIQ + zzAEEuABPOAc264cLMAoIfETJbItq0Mbj7AoizIb5f+yLueyG+1SErORIj2RIu3uGLctfTwgAhKgAM4Q + EOUxHuNQKucwHhlTKh0zMiPzMVMQMnFwMi3TDRvzDs/QABiABTogGYeFM+5uIiXyGimRIY3yGxlyNafx + NXHSNd0SNaXxNmezNl8zEt/y7lKAHzxAzOAFB1ggAUIABBLTHvswDxtzAPwwMjkTLJlzOukQDStzOelR + DxMTNGUALbXOPeaOIvmSL8XzNlvzNnnzL1vzCF/TGtWzLvfyG+WTN1lTPnczNimSH1hrYzzAAUKgKvdR + DxWTD1VSQMNSJbEzH5uzH6WzDzmzH+UwGEcAAhBRADMgsqLRPFnzWDrxPamPPs3/8xN50y3vszfPEzdT + sxM39DxlUz1zUgkhYAJI8XBkQAHej0Cd0zrZ8DLlkEHdkEcfcx9zFB+dUzHZsEiBVB8JYCrFUgBCYAFg + QAg3gAKcke5GdDc3dERhky//8krnUz3Rsz2lcT5DFEz7Mi/JUwVSQAaCkDAhoARAQADasEAdNCQJFDsH + dE5BUkD3kE4v807zNBDfkBaBtCVDQAEsoNC4zgZ2oAIiQE0lUUx7s0W3FD219ESzNDbP00R301Jz8y1Z + EzAbYAY0JF42YAYW4ABkMST/kE/hsUeZc0mRlFUFFB739DF1dDn91DJ71P0IAAFUAAa8s+pyoEYSUkvB + sTU3/7RDQ3RMpVFF55NZQTRLaxNT0fREQZUacbMBvBAo4qUDUqAEROAdg3ROW5VVX7VOB5Qxg/Q5mXRH + o1NXfRQ7W3EEGMAC2jTrCsQ0Ee89t9FZyVNbRzRbx3NFIVFTAVYic5M+XZM22RISCaYgleQFUjUEpnIx + rfNB2ZVP+TAzE7RHCzRe/5RBjZRO/zBPb1AESgACFDXrMgAGVKItyXNLpdUtY7MayzNL29NMI5UbGbZM + xZRZBRYJf/MBJkA4IWUCTOA431EkXzVJBbU6oxZX01U517BIYdVHN/YV2zU62bUVCcAAVOB82u4GTrEt + oZVL1bZaKbFhPRRaFVZbNxVFa//zQ9HTbRfSRcXTBWYgXyOFAkigFaU2O8sVQZ32QUtWZGl1QUmWcOkQ + QhmTFkNgBTzA7TRABsAxJ1PUTDs0bidxaD93PIe2U9FUWmfzLYd2PWcWEmegQrVFBg6ABSGXXpv2Vpl0 + a9lVV3+UXB9XOjkWQhv3XZ0TBSq37U51HEX0Z0XXYUPVTFm0Ye9WWk/UZkN3PDnUeWs2YJWQBVo2UmRg + BAYRbOWVR12VYw1UdxsXSR1TXqdTMjvzaXFQAAbgBIqX647XShc2TPE2YD9UUi9Veam3Pr00dA32emn2 + PPGOe+Ple+HvZG8XUP/0Otf3gdt1HocUT1HyXJ/zFYMRBBj/4AXcDgdmoAFUQET9t3+P8G5RF0RlllI1 + 9UsP1llPN29FtxppM4G7F1IoAHw/oGkTtx6xFl2p1ncveA41FmuV9A6H9Hel1g5v8AMIgHjdbgMqIAmr + l1JrdnMN2FnzEnSlFzU9dGA3N1uxOHMVGF4oAAHcT3Bl9WkRFzNrFUirdkH9cCQ1NiWRFFBXFYpRgGzt + F3OtdG4T9nMplW0991M71zaxtW3rVmdVd2BFtDoo0gJcN1iU1mJBNiwJ13dnN2RL0lWNOI5fsTI9WSoZ + dwAKYAX8eOskiC2VsEtrtpC11XTBFIY9FRup1YBpOZIFVlnBVHP7Nl48YAFG4DjpeGPf/1hHO/N3nfZi + h/hOMdZOkzRjLdg5Q4AEIiCHre4GJIA6khcbdZka0zZgyTQ3v9hh2zZTwRiXtbhg2RJZYgBp+wRcxRVs + +XCJd/Rjc7eOjTSPH9dWXxWfDXdwpfMGRwBR/fbqmMZ4jlVzy5SRtdhzyTRuV3RheRY+67ZZodco7a4F + +mFGl2QDWCBVkTNjt3ZekRle+/CkZ9VcA5VIPVafQ5IFQ6AEGkBGG69YWcA3wZlgp1eQlzVFIXmjubSi + L1ptXXRu/5LuLnJYxQQDXsAF1Fh+EXRdEfdcT7ZVbxWgqbZwP9aI/zlkr7YlCUABWKCSF7UDZuBRdfJ6 + Hbluazmjxf/UUkF3erlYNzk3hSeaoxvAAl4ApMVEAyrgBFoSis3Vmb16ZE1Zg1sarLu2macWlK2Wmt+P + AKBUJqVuA06xhB06Ww85Wh+ZWefal8c0Uzt1LyM1hQn5YRFQTStgP4nHP88wV4k4XQ/0jruaayfzQU26 + iQPVfAGRFgnRBbQ562zgBR6gCZE1tOPSbgvYbvV6rqEbrn9WRRUZNv0XMGNUnlNlAx7AOEv6JP10t9tX + fYt0SBvbacMaoCVYRwlgOxlABiS26jigAoxFIeEWkisRdDkUWYM2dQF2hrv4PrlRNsORbxkrZqA6BQ5T + fNmbmgk1iGsbZEt2lGsXV5UzTw23M9f/2ABO4AFGMxFvwAMYem+LeoWf91lnmWdpeYYfeiKr15db9D3r + jh8kYDCDRQOcEirX+EBf2onJFQ2FfECFvCtZMgWz8irBEkC5VonXuKbN0qmzrkzW8lhTm2HHGZxNuJap + tYshuj2N+n8hWTxflAVeCmwudwE80gzJe2SBmIg3/JmpE7JT+s25soEPwAFAOBnBgCYfAAm38G57GkXp + EsDB3LMZWUOtVYV5MhqVsrhN1QJWgASKbxcdPMi1EtMBFCQ3fVU53dNtkWs5M9SLHGxVdiDnW+sO8gB1 + 0pWF0rqHMihhOXNnvSe7FMZhXdY/MT+b+nVM0QVOQFXjLxaXtII1//PYjT3Zkb2CK3gW2ZwEFkAw+XwM + uiUGWKBK6S6QcxZUSTR5YX0nVRxtlfVZTbiRdZNox7EclWl4xJAMzTC4eXde5T2T7TRrq3oe652DOVgQ + PyDPD3Hay4A2PKYR8bfcM/fcybzWbZPMcdM2iVLcG73uGsAFJgOwN0YHZmAFSmAERgAFxRIWzzDk11jk + RT4YR77HT77kT34WVX7lexwHAZIHE0AFugDgzYBuJuBuqOUvobHnff7ngT7ohd7nmxDoi77nx/ROvPDZ + bOhP1nr92i//pH7qqb7qG/j4kk8UvcrmOeYk4kAljNIRHdARHYCExV7sSTjt0X7t117t3b7t4f/+7c2e + A0vF9Lj7elav9VZAAQ4A9wjAYgH/7wU/8Al/8A2/8BH/8BU/8UWg/5RPBjog1QF+RsTpbr60OsAPklhi + 8zW/8zn/8z0/9EGf8yOxJ1hHAnTg7j+rIJ6E1Yf+9WE/9mWfCTu6AkQo3bheDThuA1il2DzP4BQOBoJ/ + KxQu84hf8ziv+ENP+Stv8kZv80yPA3BAypcIAzLA4i4O7L5u+7W/+7P/+7kf/L0//Ml//MPO4nI//dV/ + /dm//d3//eE//uV//um//u3//vE///V///kfCHjCIbFoPCKTyiWz6XxCo9IptWq9YrPaLbfr/YLD4jG5 + bD6j0+o1u+1+w+P/8jm9br/j8/o9v+//AwYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqO + kpZyZeR0eLxIxMRMvOzsdGhgmI7aaGxscHT4cuTkbNTeFu/ZcMSwpKygnCQgKCw0NETMeGgYd2LgeFBU + zDy4RLi0WMxUwNBqs8dhaOjAWESgQB8YgBCIkJQgmKy0iLGuXSUbODpImAHBRYoGzRY4UJHCxQMZLzhk + sEVwoxkNHlhEcMDABIIRBkQUIBCigIERIw4gODGNxYsbHB9h4ABDhoUHERqqULFiwYoVKqilaPFgBoUX + OTTejMplA4wIJkagLFBABNetXEWcRMl1RIIU/xMySFWEoYMMFyocwF0BF+7buHYjtqCAMS1fKqgmsGhg + wkAIAiq1Iu6KeKVhAgYSOJCho2+hbjNcOFiguWhRB0blxh26AMWKBi1kSNCBljJrJTckPFigoGTWrSu/ + gq1dYKVWriRQVMjRGlAGCS0aBPWsfO5cuc6VG60GwcIEDsOvC8GQY4KLE1hD3MadO2xYsV5FFDawQsYG + 7Hsy7LDggDTdoG8/M2/OfLOKvHvd85WBB23VcwB6BPTGlQFenbSggriFlVIBCCwwQzYA2mHDRynMB1F+ + EYH4loggGuVZZyq4YEEMHgiHIUfFtbBACQ6KZ15uX5XX4Fe97TbCAh64WP9HDjM0ACJdJSJZV5Il5gea + Ay6wMMFkQWqjQQcxuMAACSnp46CX5+k4Hktb0UhYYSXM0B6VcAgIwVBxCUWXnHOOeJ+dno3mQAoPUNDB + BjasScoNHVjQAAMlkLBgeGKBReZWDD4qnqMorURCCjFcGOgaNrAVQWefKRmqZ3EmKadc9xmVQgQQzPCC + mpp6ogEMLTAwAm+MNkojhI2i1OCY5e0YwgEmRCABrGtwQMFxyzFXl5HJjWhkic42R1QDD8Dw1LGZoCLB + PFqKYFgIuIL56IKROsijgmOie8AJM0C1bRkvtJDCnULhO6q+d+17X7NxbbZnU//JKwl8FqxgAgkmMUr/ + Hq9i6frwuryWSykCENhUcBkTpEAUc0bVBW2oIjI5bUSlPtdACqxK8KrGjGSgQwwtoHBASrw5fG5X6eYK + aZnnSVwACAY00OLLYWRQQTN2UdtcyM/KKWq0Iw5VVANR6pDx0YdgsEMFESxA0rkJ4ggpjl2VzWuODzcY + wgAGqLDD1mHgMINIoDlHcnJH5sukvtT6fTJneppDwQ6Zzh3IWiwskKi6OJbJKLsQTnp2hBQTNvQCMKyW + OBccsKACUf7CGSrIc4V8+t8lN91sii8g7vkeB8UAAQoIoFfYbhSnTSOZjQItJsTlnqsPCjLgIPsWGXTA + QmYRidrvv6WjXn31fjun/5kDEajoJ6DK48HBDCkwUBJWZEsq+brpQjom2rr63pU+DFRgHfhY3ODBA6Lr + ByqccPrvTv4DlZOeYxeQSeQ02LgfHQRktxmBJ3hfUpvEHgQ8yjXMZ41KzwksoIN4MVAKN3jBAzLDuulB + z0h/mxML93WyOpkIItZ4AQ5AGMI04MBbKajHSW6jI54Nb3gLmqDwHkREtKFEHx203w2noAHjiA5vAOxb + fgDnrAGaTkn6kqIKIPCAdKimiWnggAxUkICTJCh+Ghwi2yzoq/G0UUw6SokIGDADJooRChog4XyOhMJp + lapv0ZLW3kz2oZKtIAUW2IHW8ggGG2wndAkQ2mEYBP/HCuZsUkekIBvfyKOhHc9ljmwCfB5QtSxSj0kj + c9r/CGnFAN4HBQxYQQQqIAEONHKUWtjABCAgmxKMADFgEl662BhHLxnxVzWK1I2SKAIUUCB2ulQCp0qI + Ar4962mu/J+dpHY9aEHNRKeKQAuwlstpTgEZMmhACXSDG0uuK3icZIkbJ5YzsLyxk4UZgQNg8D10MoED + FoiiFv34NEN+jFrRQlKIPjQ95xgFAhVYIECl0I22yMhMKqnRD4HVSXoeE6T1/NmOdpQSok2poku4wTpH + txx8WfGK+XpavhoaFNZhEXvaexILVvQnlTYBBzGIQPnQGLxHqctsOzNbPn9H0mT/9oxiwnKBNIFaBAwM + FXuDROhMlYOvE5ZqVDRVYcngVA0W9OmfViXCOzpAgRQo4ACFWdQmeRfVMP3Qgr3KFTGRqBsDmIAFal2r + EehVpKL461Qkutf0pjZI1DVNlVBz1mhKAwEZ0GKwQOVlC1TwjETdim30zOeNgOYw0zrVK2b73cOQOgIT + NGAChFWCDmQAAYe89H8I1S3p9gXImvrvhXgTYGciUo4ZwIADmkXnBoYa193pNaR4TW3ZGuSrtf3QqX5N + VwhIsII7zjYJeyTSm7iZQr7VCYbRO103G2pThTarKNOAAAXCCNAMcEACy1CArQ5jQepmkjzoCqnlNJla + T26w/wAleMAOlhteIfDSBUTRKmi6WtYtwrQ+KGRlQjEMwMqaxiI56JwjXxOjBCzMo5NKjNpQ+19kthiN + RwSWxHTGks3Z8MFE6MD+AkmnxYr1vFt11ipNpjoV3umARyEHco3WRAzogDsKCBeCstJa8cCYiFrmq4Ad + ptc3Tmw3K3HXA5ysYyPcYFae8piHV0jWJBtSkBo2ciG1WVNUlaYFExhICJvrpudGEH32VOoEC91My50N + pCteqqMIMIAQKKAFO8jxmYfASzcxwKWEVDJXXXgyyP54hWC13nI8ZJoKxICRDNxABWRkIEGvT7X2hJgR + ezdakGY51goaIjMfRYADpMADlP+utKXXeU3oiGisrOzqqNiLMm3GmU5gjVNEqnENEs/tYI0rjErGdUlc + 8XpXg25xSYt4ZQyeZzEGIMEJXCABbBP7CMmol4kA2OxmJydw7G2l1ML6Qt56Gs9yUSQMkpc4DLzAKo7b + HY3DHT9jgvlG2CU3aXmtszBH8AAosIBy492EJ4Zuwv5+rDcbG7UqmmqVY92bFZNCAVEWDMoPKMFuJFhB + 3kXO4bi+9bgpGLQdnWtc6y5BhfDo8ZXq9yeHVbJv47S3EE17SYLUZiv/ZsXmuAAGVT2W/moGglsZoMtR + ndi5mxmx3FQuy9qV8W4IkI8RKMAB2IL50V2jkwpAQCibMfn/1bXq3pM/9oTtlWlz5Hs1GNBdUzdgQVzH + JvGzYZCjPC9mX+s5a1nzjI7EioGZ6+4E+FDATXsX5HBTaCfVocyhoGpvkJ1mnxZKBAIwGDaVPKACueJK + 4jx3n8UNfE8uE/PWyPRVBEVwgBIoYAUsaJnn/RIPFiwEOYNLL75NT72Q1UmyLDyyyRb6Vc80wAKdDxQH + KnCC2hwaffEraa4xx9pCvz+Zxfv6YxrQKhzAu/lQgOQLKuCW0bAZflxd1elH9f3bKnHYtIhM/zhAC8DO + tmzAW9HcolQQM5Gb5F2goZGdaNkIPrlLBMTAOekfFXCKDDwAh7weqakODL1Qsm2a1aHO/wpin0xB1PZg + Vv65yA5AwAnYjLeBGe9VjhD9ys6Z25ecVtroxggQ3WU94AhqAQZswA7EgAW4hTiVzhV5GPY0C7QBnB/9 + HZGZSANAQAwYnKZMwArgzl5dmQU6ChohUY7EX/Dd1eR0xW1ARgXYlxnkAgcAwwbg4EbkAg4Iww3Q3hd4 + xNeQynldIeCdnAspIJIl4ALim7NcTUoFSgWYgDDVGJeJVHURGBGJ1NlFSs2tmwksQApQwPh9AQZkwAYg + BAXIQAWgGgzsQA4Qw0bcAC/sAAxMQAzAQCzYYiFywQ3sAAVAn73UGwJVndS13pGtjt64F+H1zwq4AJBo + igY8AALcxv8aBaEc/c6BWR7EtVHYIUZjKJjc3ZKDcUFOSIAJMoRQNAN9VEMLMMUO/OEn4NcLTEAFsEAL + LEQEAKQLeJEFoBqfjcEN6IRCmFBxxVRuqdBD0pl5WY8zHtApToAwtgYHRAAJbNT7sRYcGeGXMVVUyRra + kQuZKKEDzMAHlUEJ0kMC9AMCkIBMyuQBzGQ0qMADSIAIfkIJHsdooEBQMoAsMUBRkkb4Id4ZeMQMRMDr + DVfgNN2/teC/cJ8AEV7foAAqbh12dM3tgQDZCJgbAeFIxSH88FUGaYVhGEAJMEADVgdGXoF2wEBglA9W + 7Bo+4QYJmGJAdMA9YgIkSQDezccJKID/CSjAYRZmYZqAYWblA6TaVnaBlcRAODTl4JTeCTXj033V0+2b + Tb2gZjQAewSKDbyAV/qgGl7g4wkYPGngO30USoBAPiDAd3kAT3qBhsSGAsDkwhxAb75Eb9okcNok8jFA + BEQTKNgAbHCIUJ7ACTCAc0Jncz5nUY6ONXTAGWhHQoANCrBZQ9FZ9Ezipknjh1ANnjRAcNTAmmjABDjA + AWxU5WVSjWnX46mm+5iUVrSEP6hAfZ2BhtCKSbgECZBAcNqkgApocL5ES5CFChScJ5TSCigAdBZlUZ6A + UAolhToDYcJW/cBlFuCA1zAENRgg0/yLeiWUTKXOTQkQiIxGCtxR/4emxXquwAh05PANIV9NXhv2iia1 + 1hxxmwiUAArMUOKBwQ7EyIy0BIEa6IAyKYG6REuwGwgS6SSMEF0eZnROKFFO6IRCZ2FmJXidASp4wzLo + XYWdDgFpkd8RmSoJ3px8xjSspDoOR5p5JX5Gnlj+nkeFo1Ih1biUwApYAEWdwQZYgAIc6ICOAKL6ZnA2 + 6YAKZ2+WQGxxggf4koQ6J4VeKoY+J1FKaFFGxpSCAci5BRdJT9SUHHpFYgxmWDOcJwfAqFQgXJ0yyD1F + HBzmFX0iE1KR4rA4AH256hgpzT385pIu6aMC56Em6GtVo5w+gkA5gGE6pzNMp4VW6KZiqJYW5v8JGKcq + ikH+xADeIePgMMuzremQmVzg3Mc0yAC3YkcHNMABfJ1YFlFemaXOnSU9aQV4qMQBMEAL3JJthsGQqIAJ + HMBLJKqjPiqTFquB2qRLjAACoAAEyM0llF/HXOm0amm1WqvGbmpzOic1HqcaaEAyLAOeeFXrmWubChd4 + Ag4KhCaoDkcOuABHJobaoV1YTlc9jRbamQtZoEALeACzhoEEOEA/HKujEmtvIq3SMq2SQmwFACzMxMAO + SWumVi2naum1bumlLoDEtkEOwMY7IiC5Blm+JdngidVXnWIIKl42fuUwVRyPnmWApU3bFQAJMMDhbcCr + bsEGsIB3FCzDNur/4BJrsTLtWkLAdVbCBsyAbHCshMrSpWKtxl4q5Z6ACrAtGyCkBBijpxSX9rHcx6Tc + Yo2nktASDBzLDEzSuFSOUtna66qLzhDGbvBrC2idG+BAVRDswTJtozJq0wpugfbmujGoXyZC1zwAA0To + UBpltWaqtWJtlk5rcypfbboBJE1AofCLF16m2XYY9QQZk3gtrEzAArzaruTcuQGRopnUbRxf3LGA9bYB + BnzEAphPgQruTOJv/ips0hqAxlmA4kpCc6UAYVZu1sqSM1wo80av825qLVkiG2xAQrQAQ4jTtAmZRLoX + 6o2KixodlXQAzfQgz+nePM1amCXRo42AtlbA/w7ggNCOQdKsAKK8hP7+7rEKp+8iQA4PaEto6wRAJiJo + SGAcpqYmsPRyafQqcMY65wJEwFnAgQ1sgDecIAAypJMUYFVi5pHIxbUA8bHIigusrn1qIBCRVOQkCL9m + XdSewQ5EQALUMEzg7w4v7JLS8Q7vLx4nagIsQAuwKyKwWgOMRnNmrLQq8KZe6BFv7SErLwqwQAS7Acki + YwFimAtWD4pKpVy4QAz86rFsgAwwAHqoX1niE6E1Wgi0BB+7wDWwcUdQwAokysP2Lg4zapMqKYEKL6Qq + QApAMhfYQAbgAC90wCzoADBogAbAcBXogPMsMPQaJRJvbORmLZc65xO3cv8ZQKEHTOE7coYqFZQBGlJZ + yQUL2GPB7IAKbImueVm4mR3FcEkIwB0qdsA1l0GaRQAP/ib+7m+B3rE+96/gHmwJOIA1GuIO7CMLuABy + qAxFyMAEqBoYdICERW60FrLzSrMiV2gCW7TyXi45Gy8aWImyOMTeSU9NXXI4o0oKVADMYggGtBoCXNwF + Vsy5bUWiSoO/0rMZ6OAzFGwuH2ouzzId8/MsIywDoK4XWAlghMRI1KQ/oIAKRAALqEMQU8EONIB0Pi9F + MzASV+sRd/VQRucCqADH2QEHZG+9SN/2Tpa+eR/3vMDR5IAMtOfXtS4n2trNoDJkWEByfTQaZAAFNI7/ + byoso/bzwiqtDQ/14RqAAhz1FgwKuDYDYRrtTCKfTGwPq8jvFniAA1ysM2sqWBNlIW9pEmepE0sA35LB + DehA/+WdZdoHKo2ofD11oOY0gDCuCVgZCr8huiCVCJDFy4bPA5xRohK17wpoYduw4S7tSZiAbDm2B9DM + YipmAsAkdVO3CSTAYmL3AjxATXDBCzyrCXy2Z2e0ppY3Im/1dBbmerD0GsCHbRWJb3nmBouVZmRdX4Pw + A5wAMKUl0LhPutWcbydA3mJLGdZBc6EzWPjz79ryLQ/2gAq1wnJFcz+hWZtSAtgkAlj3YmZ3CVT3bh6f + 8iWXZj/r8kqvlioy8w5l/2irOOUypwlEbBNmSH5R5mE9R+o1W94kxQQY+NbENTu1HV0nla5yG2Cp9EPf + gQ1MwD0nCoMLr/5CeeH684ML7wgYdRYURxUrQAlw+YdveHZTt4d3uQI05rtlgVVLZzSrOViD9meX93k3 + pwLkLTnPzgvIwHFUDamGRgzJRS2Vs/JEYAMY6j2EHfCQSdiFXaLGhAtMwB/DwQbod03isu8e7Q0ntxwb + N3CigLFgAXSjwJZ7OHaDOXZzOKlvOHaHOgo8AEFbQQfQA3SyuIVa6zNrrYrTeotnmkpT9RswTwyIQ0Mg + h1MqVrWpDKt0QDJvSw4phAocyoCKmX8lqikmhQwIav8egHeEP/k+528/H3Yt/7SA/imrU4H4OABM9oN1 + jzq6b3gJmHpM/kP9YIEO+BKn2rozV+hGN69GS/OsP2cf93IdSLEHTIAMHGN8Vw30qAo9wkLH3RBg0uV+ + B1NN6+UCuMBE7XocDEmt1LKTLzjCHvbgAqcez6S2CjAVxPU9e7i6W7eYmwC7szu6p7yYMwAqOvoSgI4K + RC70njetfzUj73yLT7RZXDwcvEMxUiE3O0ADlAML2FIO1PbRqPZkPsBtjco82hJL9kEEpsBV1HDwGige + U7nXHygdM+weK1/NJ8ENcMxIxDypv7x2p3uHlzpM+oNF4vcRaEBbOECao7d5ezX/i694rb/5c8qdjPMB + Qu4iBXzDDMxAQ0vAC+jA0MsOKwZzDuiALxSzMGjA3cOBBNzzDvMulTMtcnu9HBOoHvOrcUq+EXAAraB6 + dpv63Ke7ds/964u3H1tBljM7rBcyRmetA/f9zzenWMev4mTADdyABuAADmjADdgABqC2E5ZBBuj3xh/q + Py9tLpM9Hu9vk/6vI3dA9PMABsAAOyFAyqv8l8O8qKt8y5+/CryA+PNAspBPhCIw80ari4f2EQM+EDAY + J5TQqJJheEtm0/mERqVTatV6xWa1W27X+wWHrZhdCmEYkdQHxIHkhr/Xann7AHfT4e23iKSauPniqEBB + IEkw/zFJNClRXIRUZExMdJRcJEFYqNj4stlpYVAwQiEyYihFKUIVMh1aNY1VbS01WXjQEdPd5e31/QUO + Ft4iRCEZSeOL41PWk8ujk8vMwzNAcOH40oB5QCkpSaCMpExwDDeHnCQvQUBpeRH0wplBUSAiKrovWn1l + 9Rdatc+fqxOjIsDoNEzhQoYNHT6EuARHjBQKjuGRdueNxmfP8GhkA9IOnRMV4nXRUSEFg3LiyEVaxCjd + TErfEjCIUCGbFxsTGswiNTAfUFqoZL2Sxe/ECQcsJJyMGFXqVKpVhXmIkMAOxzkZ1TBzw+drWK5wkLWD + 4AHMCwj1wL106TJmOpeWwplYAf/hBZiUKeqd6PcqIC1TQ/8JJFoKMIqmuaw+hhxZsuQMMhigSUOtY5yN + cUB69hwNmQIXMDSA8XliEbhL4mjOnQQzZgl7DSaAyeCBhQpR/GD5GwwQuKshRfvVhqFk8nLmzZ3rwtAB + QgIRI0BGA/tGrDSv0DJuRTEDRxgZC9KZk5u+ddyakBzICDNxJWCkSg33O2pYIHAGihxUyOE5AQcksMAl + OJjBgRLQ0OwOBzeCMKRpxooGGmXuQMABCcSY4QQEwEGPLthEhIuccChZgQIxPGgLoP3wEQ6V/U7pJxVZ + YjkhrxjGM7BHH3+EKIMYGmjEOu+cQXKzzijcCpoDSkDBgoT/wLBAgSfvwrK1115zzZxvUKhADA1iiGAB + 4mQs6iijEDvFt1MWU+EBD5QDsk477wwjhwcsgrCzZjT6k7vOHOTsDutOeOAFG8SwwIQn6YKLS0nLmYsd + BmbQJSUVFENKsMNqxO9Fw4hDAYnT8EQ1VVWl8CCFA4yMpisnK9Rju1g380OFFzLQpcorubQrPfVkqoSE + EzAVw4YOQrGHFYIAUtMV+1gBaqiCUGDBsVW35dbODlhgYAQ0PAptpAdBwyhdQg9QgIVTxWDByrdGHJbE + SdlRwIJdbpChgeLoA/XMwQojCJZSjCjohAgoCLBbhx8WcAMLVnDUgAiP5IpJzpzBOJME/xyIgZdGSUDn + nHEkbcTeSEogIV9eJHBhhQWgnXZgN2FEk7hY7MmLAqggBjpoql5wwISRBA2pwa36xEOZJq0rYQUWOhDZ + SgTkWq+SSh+JDctK2NV3Fw4oiHmpaRFOhWY0AxMKP1QcaIFqoeem2yENKrAyja48miNpWulYGmkDRDih + BQ943aXRR02cFDavgW05bF1s0FQBEwIDrDChDI7RRs4RZsA2xOsmvXRebnjBhRKQGfS6NS5kepqy+u5D + hAUmWLTqX7Wm6SUuhV0EbF+wMsEeN50d6mw17ytuiBynzt106afXgoyJSTAgtGXS3Rt27sAylIQG5BbZ + BJKzFLH3E//rrclYyXfJgYWDoUWeRn18kzZGfYwaxQUKdqJeAAUYBQ3MYAUJuIj2IkS7jyhwXeFLwAJm + 8DNGyctrrnmcTFI2rGKd4H26yMAEyiSKgtUvOKD6V/LQJgoG5AUGoxtgDAXYgQaUQEIKlFWsOpYHW73K + AFGzwA5+oTjWZLBrq+kdvVaDAJf5ggMyiACnYjSQNBEFRsHJXD5YITUAytCLpssABVBwgOx1JCOzChxG + 9PAZjYgrARGQAAwTZ8H2jANrcTlZpYTnC8pNrFmZC8wsTqi5Ff5DOEvBCQyi90VGCu0GLFKAuHS4N7KU + JTvZ6c4ISsIjXxBxLo1Tj73a10RfCEn/BQownv740bZRqaKVWczHCVQwgw4sspG37NYOWLCABLCOkkzT + zJ8+oiRAlUAFGwKGr1ijRPbNJIk2JKUvpDMLQKYtbYQUDjXZ1DnnOSACMtAWLsWpKhtQYAEso512nCQW + Nf5NUGvI3scAFIyRzYtSkbonHteXpXJELhgamEDZrkitfdjnHsZ5031gsQAXSIBO44SonTbQggRkj4cc + cWB3zhU7slgHWzp4aC+UicFQrmdEJmVZNH2RAwqsZBRFWWWNgjOYVIgKYQpYQQU4GVGe9ggDPiFBAazD + NLEcrRm3cgb43mCNBrwgpCJ1VBH5WTJmzuZk/VSpNFtgnqAccpsx/9VPm/4BmAS4Y049RSuBbOCBUGAv + M30b5ho8s7QHmYsabjBBCxpGTwtKwneghAkeoflBX9zNAZzKIppaKRhstm0go0hBBcKZVspOJgcWQAEC + h3orjG3HqGR5J4QUYBtbdtJ8RdxgEvG5pVES1hcvaMFP2BaqKZ7wmq6sDyAdkAIK7LSyv7XKCxqAwDrs + 4aLqbNBd+4TcjfxQBfMcxkhFeVUtlahS/hwGDiaw1WahkHO3XRO16LMfLaLgFuQDbnqlogHLIGOj1wlN + cZP0DKMewwAJYEEX6RlV6zaTn5DL6i82IIMVoJJg360tIaVFnxIuJQUwoKB6JawQgEbABCIoI/9GAaeZ + sWhvO4XqzAJgwJCRau2ezGymHgP8ix24oHmkSihC2Za22QLGck2Bx4R1vJDUMWBBsAINfYepPUJxbCMI + MIELJrvf3V3Vv1StC3YVclkVmEln+7gijD/nIsIoRgELaEAQdzxmYGRgBgw4hHLNOKFJgraogMKILGXw + ruj29USAdU11r7viUnJjUykMayALxrn8gQ4VDaDAU8m8aC90wAxDdR26+HZXNWK0GiR4z5L3ez5JlKyO + /b3jaqSskA3AwMXNYp7maIyzK1prfplTAAoesFdG15oLOSDwqzSstPiqs83p7EMJIIBehZSYWJ3m2jg8 + /cw9MoQDmO1u/sD/ahycFbKKgDmIb229bSpo18XuXSAO52AuX5dbrm5ggEkcQkQT3TnZ63j3sFLq2mCE + kDfNM+SBuYm2gRZ6KSpgQY65PfApTNOGkM4hh71HTCEbqgQMSMFe1k1HJzPu3bBZ9rwfooMHVBlg90No + gwWJtt9wCswz0DTBCY4Bc8rVjBYKcq+pwU6zHMAEKYgBnRfiSZOtdn30ssS7Ne6QG0igBQ5A5Mg9Ra1A + FlLL4sXJbVQ+dSbggAUmGBf34MrZWsE34dZZgAX0u/O+VvUu6ntETF4yWIjIx3kK7XLnFFyt/AwBp+qm + usoxgJUFRXrc68SQcdN5w0EdMyL1jItdnLz4//QM/SE7gMCLERyQujOdP7+xOxfzrnJNVfStGKVruBfI + XEqz4QQs0DbZd6fBCzoZyn5txKgbcrc/A0ybNCsov71K8lYshaETSP3mx4wBthgCyGc08i+V5HIfGksv + ii42f5EdaqzBvvGyb0gHLLCpP2LuRSsMdLXx4fswC1H4tr5BDE6ZwEmLPqNz/cgIRIAAQOi8Icb+HfDu + DDy2R+SRWzWB8com3hOIuWMlI4g1uImj86s1DbAAH3sQWeGwSnqdCVwSBxmNFpgSiOA5tfPA9gDBD+wa + x4MI2uu+utsyBAMVpZAR3oowBpSwHJgONXirl0uuCpw5OEsnBFiBGIA+1f+zp5ShLgyalNaaitRZALhL + oTbxN/JaQfr4D/uDQQnjgEc7FxCjQK+rtEJJg4eDAPOLCsRDot+xPlGKMj5bCB2YgRRIwsUYQCyrqbgD + Ly3ShxOQoOCbQuDSAVcZl80oFAvcG4Z7lRFQgAiYACm8PzsjQ6tyJuojQYh4pO1DJKOoIrCatlWqtuJ4 + gA3MQwnTgQYYHOWaFV5jIIbrgwNgAApAxPvjr5/bP0gIuv8ymdZ4xCCRgAhIGIOZEfGiKZiqtlmwHA3s + xB3rABUIRY7ZtfbrCNhZF2tIgZSbuCbDIMVjvLQ7Q3pziA1ggRUAv6DYH4NCDKA4qKWwh1kbRh3bQ13/ + czmvELJ2TCO56sIoecF1k74TOzZZrK4RxD6I6IkoYkHkKUA4HKvPsQ/UO8cJywEX6KX38gpyayAtnLkF + 0AurkC794yDqEzU0zL4ZKBOzqR+xWroBNKTiKIIVmIFVPMie2oAHOIFzQxK/SZIjQSpxMYGDQElWXD3f + ySDHYY/z2Mcg0Q2kc0PEkDYmXKyawgfeusmUhKgC4iUEMBKMaZAOg6vAUwYDKImlJDFF3EmM1Emf1MiG + uIEJSIFJjAXFurIzoS1aWIEIiAE5Ysq0GksigcpX6RuHvMBAtDQ30BXIEEMsUbwQ6Ul1uEbIWBYt6irv + S4z9GY5SWAAHSJTSiku0/9KBialLZGzICSS3jYAaCeLEqZCuMWxE1kKH6qpFqUi/CODGxVA1y1ObLWsF + VHABGaC1yaSsG4CBGurDl1sjQdwMi5G1s3oMdgssfVKZDwRLbIQIDCAEvxBAxqzEoCDKUsCpFtgBuLRN + tMqBFogk4wKtwEu4zCSjEmiAF4oMY3M3khrCIzJCyFirB1iAUXBDUsCH3AuVwoAFWdKp7EwvGygPG/RO + pGEnuiLEFhg7qvjL1HrFdlO71mtPyBgw3hjH+2Cw2jK08TJE/lQvyEMzu+Q6WWGn2LkaFfBByahI9kyi + IaSJ06QKtjosT9GmgfE+ZxmCBVABC4BGDY2oCjMBcf8Jsu8RNzdAgwR4rs+sCnbDJ+sClktIzslAnaOb + RFL4roAktFIJIuzU0Z4aExTw0Uzw0gm5QmIioxG4FDwETXnZmrOjxtczqQeNjBByqfGKFpgCnSzSCyzN + UpV8ADRLswdixwfKg4drgRwFzXq0ozJ0nJMqzOUYsAZIQnxzOsTEMlRoyxiYxzztKU05gUGElQ1jM10T + l/tyAAvogB9EUDsTTH2qi+nCKuWkCg6IgRZYAXJMOv6gn6VIGMiUAK3EVIiaCAVZx0o7o7AIjwP1S+nT + s/8STbNj0cfQrjKRojoUyMwxG7241F5FqwFTTR9rA/eyjm91LzegjRVIAVp6jhP/xSeq4prGa1LnyIEJ + YAEXcFTnSRh7sAdcJYIVaAAXYAEIw9Ydoxx4dYBeMoDBKVgMK9gCKNgSWIAWiIEOuFaKPC2LO7FEPbvq + c1PmsIEckAAWSIECK56QtRxUKh6mmE0PyAFT/dfK0gDd8JdOAxGbuJw4gQEzPU+Kq9iv3D/9i4lme46W + lQEIUAEHWIGiNdqidQAHaIAWoAAdwNOVTa8M0AEJkIEZeAAXiICszVoXaAELkAEJ0AFeldgmS9FPO6JY + zEgWKJAMyIEdgAEKmAELsAAWkFu5rYAYkIAd2ADJhNoxs4EN6IAd8IAXeAEP6IANiNjlQFfVQlH2aVbn + yAAc/8gBDtCByuWAHNAAvu1bW8OADLiBDFDZc21FJPq0fLTYRQWSC8AADKiBzXXdU12cY2PVPJLFx33d + 2x0n4nRFDoKUIvRZ3AXeiBJDIZwqJuXdKDuW4FVe4TXUE6HGJFWi2SiHdFve6sUlC2hJ1GI9RW1ESukd + KIEP6xVfLyqEt9jdBb0z9LhHE1MAB1CR8YVfAYoBB0CleyrN9PFeWCSRnwOE+PXf6YGBKFIAnezKi5MU + 1liB0vjfBSadbzmlbwiRNM2/xgMHWSJVBsZgodmAgPIxe4qN/e3KSfgGBigNm83gE7YTDFBDQ/gQEMZY + PEoHNZAgDghdFLZhHwmhFTgEV/9UUWX9OXbIkAl42hsmYh/pAAtrCdV6vUjZIEdQsiKGYlShPZZoYe9l + PXzMJyQLHZ+J4i6uEzLYjRP4BvUhwlD7BgWYJWLz4jUmkAx4AfhsCe1FIsHcoHKwiQVggR3QXDbm4+XI + AJhhifMxGfXlP3ZIgBN4vj5WZALRLqHtDzt23izxEkieWQgwjUXGZAF5JBlwAW9QAwjWoNX4hjSDEgiQ + AQ9I3ExW5anIARiAAA+RqkjOkg9BZOBb5Vt2jm1ggQioslrQiq9whHzdLQuQABPG5WOOigzYgBegAAhI + AaQjrjQ4ZKVl2hfYW2TG5uXAgFaWgQd45nx4zAhggQqYgA2SqOFsRucgkdwO8AAYkAAYKNwOyAEcGOJ0 + tud7xud81ud95ud+9ud/BuiAFuiBJuiCNuiDRuiEVuiFZuiGduiHhuiIluiJpuiKtuiLxuiM1uiN5uiO + 9uiPBumQFumRJumSNumTRumUVumVZumWdumXhumYlumZpumatumbxumc1umd5ume9umfBuqgFuqhJuqf + DgIAIfkECQUAPAAsAAAAAPIB8gEABv9AnnBILBqPyKRyyWw6n9CodEqtWq/YrHbL7Xq/4LB4TC6bz+i0 + es1uu9/wuHxOr9vv+Lx+z+/7/4CBgoOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6Slpqeo + qaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3+Dh4uPk + 5ebn6Onq6+zt7u/w8fLz9PX29/j5+vv8/f7/AAMKHEiwoMGDCBMq9IbBxo0bOHBswKEhgw0MCzM2srGB + w44XE2LIkBFjggQPHDbY0MiyEAYNHDzAmEChggUWN2eQPMkBB8b/lkD5YMDxMaTICjNmWFg6owIFkjBe + dMARtOodDDk8UFDatGsFpF6/WtDpYUMGq2jh4NDxgsJSFkmRym0KVinOGRRe6NCQtm8arB5o1vVKeG5d + pxM85Pjpt3EYHBJk2BxL9+vXymElJ20q4wVVx6C7aNgRQ+nYy3PpdtVsmDKFHXxDy75yQ4cEsLgN6w5b + uAIMHWdnC5eSI7JNzHKRylBtmLlSpxI4DJ/uJIOH4115o9au07lSGR6CUx9/ZMMErpiXz9XMXvl2uThh + fCZPXwgGHTGWpkbtXjtu7xbEwIF49Y23wQ5bnWaZauo5l9xuYFHggU8FjpdBB8aN1WBy/ukE/2F3dMHQ + AYEVzobDC0fFtR53zTW4YVwxeFbidBvAcJlzkvXHn4ccbrcaDDnMOBwHpVmw44s7bqeejk0ZKaCQwnUg + w2lx8Yjcaqs119x3HUA5m5RMWaYlgytextqD3+ngpWxSwgXWki12OKZ6N8nQ5Zqg6VCBm2JWmeSY6y2I + lAV24pnnlNlxiCSDhL3YIAsU3GmoX1I+kF6jTIrZY49cTsqMDRk89NBKhOggAwv8KcecoonGqVmaLmUQ + qkWMeXqHQx3p0MEOHvS6Qwc6cJBDRYC06aCPqWKp444sFPpHBhrkwEEHHvDq668paUCqrXHcwAFIMVDw + 1FMjiVuSiPPxYf8qlaqqypqfgirb3aDOCoUDhjSNW64M5k7wAgc3cPvGUB3AkOBYCCe11FIyiGhWH3ry + eaWS7cqLJr2S6sHRDhMsZ9rCCSfVcAcqCbzGBjJ1DBZlm1F2Gr8wKLYtHqaiyul7F3u4KpadahwTDClu + JvTQFcgwAQw7pGsyGRu88Gqfm974VcMc1GqHsWbqvGimjOaIVLMZ23GfjRAm2WpnGyxNhg3fHkzZxbvh + ZAEFEugwcx3rFhbWimfi+F7Pt3IggVt3/af3yvrlNaDaYNjQQU2vHi65XDDbTfOeZB77YcWcEhr2HBh0 + oPLhgC6oWqSMf2HeTQoCmt6WM0wQ5B01m73/pIq97d3dq57jwcF5LAYftwXypc4FDloVDq/OUnOnVF5p + X33qqu+5mHV/umMsdtMJat7bzVy9FpvxV2RAmsfZb5q5oPy+MP4cerLLopbXm9kc2HZo0NZyCpK+M6c6 + mcAOAkY+K+RgArox3Jzmh5QYWI4OEVvfvCxWmTmtrF5yCF1pcue6svlJdgWsQujc8r1LcQ17ypkQ3k5l + O4qVyT9Z6x0d9IcoBWZPgrezSaTuFkIn0JArcVJUoI71HAGS6A1YY1XpVINDschQDjco2H/Ad8KKdYVQ + 7uthFDKgAxuJbIkboh9vAtgBq7lhXUZi4OSW+DUZqCmDOkBgmBxEunbl/6wpMOAAD7WYBOTFwCYdXOOR + ODQDGLzvDRG8Hh2DaMeKPREOGpjAHAPpqL/9hyQq5GMTOGCwQLpnQe9azoZ4R4E3xqFNyXIRjjiYpSti + 0A0Y4MCp+ufBeDmKMHShAJA0yYQRMo+O72qU7vpGqEzCoWZEtOT/frmdZpnyDcijgMT+9qKJwc0rMfgc + L4uAgR1gR1BsRE5uOBMXQk2gA4dkQ/zSt0pqDpF3r2TDaGAgGSpNDjMdkpydzLjNIWDgBcd5IRXn5a5l + fsWBcUikQLOkRL2965Ft4ORWFinMZWFKb015wR77yQMbvOBtvAkjM6n4Ltx4YKNoqJ0HRdmi3eSIif+E + eiYbMHAd+XXQjlpTJm4kgNJtYkACcyyp65CkTLosZQJKW0MSCcpUIU5MXhA9GQyA6NKR3pNzTuQpR4/g + Ua48TXjMaylG4SKDpCFySmmMVwuvarqopgF5/HMqOCcIxr8tRatb5WZNhXdCRg2xTzqJgQcIqE7M6TRn + VNyNW89gvtH9VX2gtF8rdzQWvOZ1CDbYwdZy6tdW9q15YoJB9NiASjRttqTAnAv+2lAjqYGzP6gVo1BB + VAEP8HOrcYwtLsvmuoktZYdtQCbOYEu9qsZrsWUY4Rw9qz6WyuuzXiGJTC/Lg+I8RYxqbSf1qkSnZkkg + qWdY5wtFuh+crghWbDj/0Tf7KtkEUlQ9/PoudYswmo7hLrEl5BR0URUD2Khzeu19KnueOrXLIHcM9d2T + 6YbG4Pw2VTtG8+98MctJj+lXwCF9rp84M4HpmqG024Xt5p4KuDT87mkP0pTZFmq/1OhyMRMmwg08gNbh + JiqsDMUqi7KoBoVqN5yqbNCBw6C/ce52eUps8SKLSdgYCwFMrcPUSjk4xQYVsmo9rqGUp8xb1caTDGPD + r04pSj/NrNbJQyCSTa0aNbC+ZyyCHe0ZKkWmw+wmpPq9oDbHgLIiTdagisQpnKqUlAlIB81DGM0fK6rh + OPlVjEbKSzrHoNLiPnrKgx6yF/T3x7cl60hIlutk/53igUnHmCiLxrMEISvmzcjg0HMG8JYa+Wf6zUXT + XZBlPi2IMxxHNjuCBS+aW6uh5hq3roqdQXhSqmV3jVnEVlJVicmQgReYhtEDrmQQdy0BOSMaszXdj/8s + yTWMjiWPPe2Cj2NrXkq6cs9fiOVUwwS1BM46p2L0EHjSHeMKT5Gzgqbgn8Ii2NmVodIDD6VLA3UjXGsh + ByAZp7T/9rq1aslosP52EaKIwPv+L8DQdaeKBMtvLSx1kLUWOGEcjgUbeOCPLRXrmB26ct8MUONIGI1b + PK2+j9+wPfj0jam9IF6a9/qTFNPZtIkMvFou0Ja2viIL+jt0nB/Q4zK/2SUJ2f8aSHn4C+tWcq+tXG/V + sNwKbKtxVS8t5c5uaZc4T8IN2vJOdyNWeEZ6wQZuy4XaidOhOVsUPOG9BQxs4Dae/nnMAT9X+A427kmQ + d99u91JaWxjaO4KRMcMAYmCSOWssvfWXu9C0VKeyzV9NOrzUo0ssQx4J5pv353cr19LNJZtkEO5hVznb + v50ZDBq8M5qojF1QXnEG2Wzy642ggdvAxaCvAyvQW8TjMBS9T5XnbjKHuPQunIiEsm00Q5mquxmg6gXK + Xz43pbThilkY8KuuaAU6XPIq+Jhr7Vn4+LUXBrbZiJY5Fn3PxjlNEil8p348cHgvRV6R1Wqf1jINY3Bg + x0L/tSZ82NZK3acF8tY9+KRKFBRG4accEiCBCGgEHFd5Fgd/9aMsyZEX6bcFqERzvScnnTN6WTB3qcdO + 5sUd01cXFGBEJagEOrcZQiRy2Rd44lZoJNh3LAQ3jxVt7qd0ZxcFV5dWLPZJuQN0A+ZEZfWCQUgEOZAf + /aNwrIR/U3QjeLEDR6QF99cqdPWGn7UdU/gEUYRWqpZ07jV5yWJ+AbKEX7hxEvAc1JNDTUVJdiUDEjAi + E8guWAg1OJZDimWDVsBF/8dECedJeVYlleWFfzgEuXV5hfh3K2aJuxWBX0BnIDc/wZN9v7cFEpUooFgm + KaY1+YUbDfN1nTgEUeRF0UeI/+WVYVAnF0ZyUkTXhBcVcJlYg4RHBS63Xp6HgqPGaLfmG8CRi0swGlq2 + gGP3SyH3VJVVdVSwVEKFXWP0QnPIBBoAA8tFjmQmihhYVuBojdVlX6q3gwO1KFIXKZxIBXkjamKXKUin + Z10QRYSDdUw1eW8YVmYDQvK4BDcwOPlnUVFYfAQljIRSN2tof4bVXKS4bbPViuXDSTbUakeoJLuTHO2z + jw0pBG2zYZSnkJLVjbNGN8LGj8YIWQJoWuYoiVJweFtxU9x4dIVISDEQHSvJBBnwO9onlP+GLDyYHciH + i1Mgjlk4bnQlh27EBY9TTgRmgaG0THQSO9V4lNd4HXLSIf9fOX0suFM1KQXXp2SQOG6sApJVkI6IQntv + iFhMAif7UWpkyQQ2oAM/mYW7x277B2wdoJJPUClGYoi0qFtF0yR0OQUa0AGdtkYK+WdnYmtIUUoH+JdC + ABk14XGCJ4u9CENUY3J3OVDkKEodyTDL6AT3YRxIJjknGX+gFxcN422gyVUVBlKG6UmrqCIumAVgcmNR + R1QU5Wqx2QQ4OIv4VU0D6ErRUX9/mVnSREtJFmK1xB0d9plNEIZitYWYSXFywZBXoJTk1kR/tTNAZ36v + kZG9aQRXh5wWU0WhmH1JISFt6QTmYWeAVmespJuihQUaoBWCGGh3aI8WtBQx4IfzeQT/N4AghwF91lOR + uTNGRpOYV8Bplydzebl9AbR5U3AhR6EhPgdAaiVQh9GFEeqfFEploeiUigSNX4GeVMBFg0OEvuhrx5go + dPNAVXBAm8lqM0qY/xNnLyqbBxRQnjV7wdl+IrMDBoogCRqN+vdXvyVhVeA4d7mUKheCDYVHMLakTeBy + VMVKziWRLkRXeSefT3BANyGcz5YdLDB1etShiDdXOraZbEZzWASnZloERPJ+FGmeZZgaSYFuV4ADsudz + vYd0uDQBirkEY4MeDGdC/hOXqGVoeIIBN7ABG6ADOsArO8ABOjAsgloHEwpzq2Z7P+peTmJWVkBTgymN + ojgmnEGM/1aAPOeReLE4TKD3TnuDSf2ZBxjQEMlKDqOxJy0QAQ6AAgywACoQARBgAd/5B3CVcMyFZ3X3 + H5GWR+C5BNa1dayCJT3aFNBzBbOJPqmSb64Fag+YFxTiBy/RER1ALRIgFR0gLDiwqtHANhPQAgtwAiZw + ACIwAB9AAAVwAAjAAA3AArQqFFd3qFX5hFfCGS8AsErANrS5cA1om4iYp5O4P9BXP8MXoIYhO+MqBzaQ + AzsgASHxFCJzLh6wFy27DObxACmwAAlwAAZQAATwAQIgAB8wACAgAiOAACfgABEwA3rHBxkQGbhDVCxK + fF8kNBUgX+WDH5NxUVl7R6dBfwbqRf+AdGGE+H7sth7sIQHx2C0d4QEyu2grwxniEjMdkAMciwwbUAEr + gAAjIAIhEAIgULggoLBISwAgQAAEEAIGMAIJkAIUkHFXYZkoZkUD949V21Yx8LZMMKGjSYQoqavoo643 + hwU44GdyaZrQiFoewy+4twcEIxKSAY2VMRKwGzPHigwc4LcjoLBFe7SHa7jDe7gfQLQfEAII4AAW4Jd5 + QBS/2jp355FhehMUwJtUcC8zUbpEA5XZYU4SwKWNmp3Yt1Z9A5afBGckagcZkBWSJDdESEcK0xQFl7PC + 4AEuYAIjEAIDgLhIi7SLa7j9279Hi7QFMAImsAItUKBXAXFABIf/F5uiv2S9u+sEEMExSvEAabVhUjcW + iVEyWrABO3ebXYO1jKQwlbV3eRAtMkGzIMOVA4oYY9kMHMACJXC4iTu8Oay4ilu8xHu4jYsAKiADZVoH + jjNR/tieR2dFphEDFfwEB9px8QJD87e+V7ABMcAnOtmO36qoMWWdanAvUmyf9rYz1ku5yaADLIACBVC0 + Oly8PUwAAyDHcLy4x3u0yusALNBhe3sGkAFGlwaQUDgoAeK5UOAtLzC3g8k6X0EBMQADMQMwXpC6XiWX + IXqEmsnARszC9rUwO5MZjqgw51fEyKABD2ACBjC0AFy4AMzDq2y4dAzE/bu4jvuwLkCpddBY//XUfm/i + I7NFXtmBy1+QAQcCEvXEOngRI0nTx4dstlayNXCJmXTRX8xcBrUhszXhdJnqNVCjS9hLDDuAAiEgvMPL + wwG8uDxszgHcw8Q7AAIwACKQAEOsiHOgP91jtXtzwgFWNDBQzVBAzDmgr0dzEjuQAw8TBg8ZcgRoiYzk + Hg7qvKAjxoR8T0bHwUSoUcnQtybgzjucw4ubw4k7x7As0nOssMebtEzbAM1bqWYgpzbjZtzFlIcRI/4s + BQ0hKjdwEWVgHabXp+6VYnESHxDKBsQcsykCUlGnKQG4IOf2xLmgATGQAgcAAsK7yupszuzsyiP90a2M + tCJgAi4gASxNbf/WhtS3qYdPeT0jY7+CEDoGE9MEaDoq2suDArVjTQYTahxTPIreC3KKek5OfQs7AAEm + IAKxLNJ07MpYXdLrXM6F68pFa7QioAAq7T5s/QUi6WCbI1u4oaST0DRN92msQp5+2hU/iMZscAMBTU/I + XEGZE3rlC7JFxKHFMAEokMo+/NFx7NGxvNuK/dj/O8AEoLQlsAAPgH5vQImGGrY25mwYZWh3TQj+F1B1 + VZ7ZcYs1zQU6Gi6aAYBkDJVNmU+FFti1YAElMMuOfc6Jrd5b/dGw/Ng/jMMfUABgzbVtcKCDKZFBt0ii + 122WcHgPHNcqeIzgEd1foAFxZBcrikMwNH7/lLcyk1sMNwABI3C8Wq24jM3O7i3H673OvK3ex/vOBmAC + KrDHpGxiGxSgAKddxZTdgZBZ4wSZITZ+hYbaaKDagTEld0GDAurLHZlAdWLjvcABKWAAbuzYcQzfiW3V + wP3eIr3hONzKBUACJwABEnDZWpDQ26jfzYNiT3IJOUBP4S1uV6siiGjghfctgoGcbBTeJVnRk8kLNLUC + ImC07u3hAZzhHb3eHb7k58zKFj7Zt4xOa2BdTHGY/9ajTkLblnAhHcMyQKmfpkM3Qz0GL2EbB6Mi8jpB + PfrTWAXhHQDGs5ABMLACbbzKTw7lf67VW73bqw7fxtu/w40AKPC0ZfQX/2FuARpchJpaUDbRLKeLCaAr + N+QIkKqFrTkg6lpwLy/QSfFbfJnKp5i5IbDp4q0QSWxstBfe5yEdy3ju6nze7cBNwEg7Aidw3NZu0x1g + WDC9z4v6zZRAbJhYjhB4638B2jW0YrM2caq4bYCFF8gtDKm7AOMMwB7d2OyNzu/N4R/u56z88MArAARg + AAqgAsRz4mLQqpgjuj/6VSShd1ieCFiBIqXLdZ7HFYKF5lYQqjqgFRNdm57+XqN9Z0LmosIA1QvQxgtL + vKwO7gv/ykmu6umM8LPMsAZQAitgAfZuzQiiPO7XiE1SAYJlyJHgRxONyTlyO7/F6MmFMjQxEvHK4//t + ZqEx33DiMww3AAM5r+2s/Nu6/eQMX84Xztjs7e0dbrxGawAo8ABuewYzxt1ouDxaCxVWvAkH8vWDATuu + 9hT9pfI5ijLZyYhXxYIDbncrV1bpvgr/ROd23ucb3so8v+oH39i9nfAGf8cEgMAL4AICEvJRMBRqvic4 + Ab8Ig8w/qAMHLQoEYzBv8cIojBPzpxcqbAYw0eyLNkne+vTReKEguH9mvwPKLgsc0AB1/gEC/Od1v8Ow + 7Plxr+TaH/QYTsshcABJv/RjYAOoNrpDRDdcTwrX/JVKLfVlEf1UYHgosmDWrXXeWkeCDwSVymw4tMh0 + POWS2XQ+oVHplFq1Xqv/ONdI8CEMQIRw+Cv+gsZnMzg8WKPTbrC4bUbTxYNPl0BatCZ0MrAImTA0dDw8 + Xl4kYB4lXhR3dDYGCzEzNTebMjY6dhYdJyAlPSg1MDivDnM8YmYsZoiIhGppaWWGdGttfW+Lgml3i25z + h2JjOFaZm52flzAsDvTa5tjO4u6u2+Dg6NCw7763u73nRBBOUipyoKkwbHBydDhyNGze9fc34zVyOOjI + geNGPn5PbGzYIWECBVu4hFWQMSwixGPDKGacaGsjR1wzJrg7OJLkMwonRHxhg22OuTxjutlZUyZNOTw2 + a+b5MCDEARQzOtwo2QRDhgyqhiZVqqToDaRLMWx4/4UM2K+MFTnu0uiRGBFdxLIGEyJDgtClZ9E+eZEi + QQE9dMSpGYenZUxxNlmqqZtNzoAuIAocOBFhxgsNaREnVuwsAw4dL2KIxXhxozEhXX1lvlqs2NcZvHgh + kzGhg8HFp0duqLBiRLUzbsjZ1RtzLreb4OTKqRnuG4EQBkykmIADdXHjx3nc2AHDITCMmi8fE83ZInXr + vZ5zlhVjB3Hk35vlsGCCgAAQA9hosxP7Ju31Y3TThUl3/ZcPewQQQKDCggccT8ELUMBnbuDAgwkmskCW + X34JrTOMKgvrlggjYrAiXj6TYAMAB+zQihcWCAGMlbIpUQ6a3qDJpRPxoq2ccP/AQe8+EEQgwYQFHphg + Aw957LEKRF6YIAZeFrzoOs46szAXjaqaJUKLKvvsBdN8rNIJDSAoISX0yJHprhVjgw+3uMZRzy5yuPQt + gRRk2NHKN3vUYIcJkIFuq14ww04yJD/DE6IkjSxChtFEgtNQHnZoQYEQurhGpbm+YWm3Mmwr08Q60pvt + vBFBwA+EEBBYAIIYCj3U1NP+8QAGGRRU0M/oGMyuOkDtFG1CPouZJZYKJOCAw1N7xKADCKjZSZuWVJwp + UpeWPbNMM+Hj9LxpfRNBsAc6AFZbtDDgADKHqAptlgdpfVDcCp0D6znnPPvKAhZi0OHXbT3EQAIVSNgS + PS7/dzOn2fagLfFMuejiNL3zdvpAhBMs8JXehw/CIAcJJorl1VizkhVWYdLtU9wJIazuMxm4uwRiHzPw + oIUTDLjvPk4p3QbFgf1NEVMXx/zXGj3AMEABF14w+eShObmhg1WpkmXcJamjsM9cmyZ3XYw/21jXGSjo + VWiiecyBBZZDELjLTDNtEa7zzrZ0HG785ffgaUEgIYIpua67kAx2qKDIy8bCNU/rugKN1qpvJZzqcSWK + wYNS7eaRgwpSYEBLGfeV2b1K55vUTIJh41ybafUQIAQTIJBg3sZRXyIDDmCw4IEFAV+XwsCnFqajp41M + N7pYjoDBgw68S71HG3SgoIEE/wh4mUt+7ai8vrxuzgZMuT5/Ea63CkDAhSSE734J1imwGF2tMob16Y0x + trp8PivT5V2QuqPSew9xgAECBUgwIOxNLX8Pp0vhEz2c1Ew9jtrXThIgA/nNr243eIFnrgPBjvGJaRV8 + EnSOBJFBUYA0ZmEgynQwgRY4AAEiEsBfvOENZQmsPcoKGLLYJp8Y3ecALvDAAj8IMYlNYG+Gw1WTQIMd + cQ3xKufzynWUJgPfcQAHOMyhhzgQAxWU0DXuMdv0rEe2zM3GhfKRkQgYwIJsPXFoCfFAgmplLswcCSt7 + KuJDMna1CpDGTWSE0wYo4IIFIGAEbuEZGeoQpkk5qktrk/9eC+8ivRGBygExsOPJNPCK8E2mXFihCPmk + IzvyUZBIXsmaBzjgwUe+CQM42IEFVkACE+4EhlvcS100979XWqqVXApBAh6wtVGaSgeRmeAPowZH29VJ + Y4MLjSwWNAEPbGiXwMpBBVSQgD7GqDa4GeAbaPNKLs4HNikMxwBEkILgNdNUHqgAC6b2Ko/lznC1q6Dt + QMYZGVDAd+Mk56E2IAELqOAEBxARK2MoG5mRaZCZaxEc0BMzv4TAAWO8p6Ey8IJz2glKVRkmyBwUKI19 + xEkxeEEHciDKh5oqAx2YgQNIUAC4PStZNVvJwLp5m5jGoWwLRQEMTjfSDt1AAjNAJxz/N+NONgIRiIDj + jDL/o9OH5SAGEThBAvSnEsyxEFmB7CYtp1e2l/gFBAqgwGGUWiUNSFRpQ40d+2pVtQx+7DMcfIEORBpW + YGWAqRBAwQGS9zJAyhRuMcviQbfZPDPsoasWYJxcBXQBHEhAb5YRImVyR7WuQIiiLHjADDzKAbAiVoen + vOv+QIe2Sm2TPYHMCS395xcCmIAF3OPsgCTWU9il03xcwWSDMChZZFggaxtw4mtPtUMWqEAB/vRL5VTI + UkidSIu8oZ4ruYrLDuQUuKexQQ5g0FhiwlNdfLMo4S44qz45iRQe0EEqqss1ObHgriBoVKToA9/OJVcm + Bj3taz4A/4IEtEBe6QVPbBurpwshLmRSs+QQd1sBj+ZAl/49WQdY4IAEiCAEYUPuIXWzIvlgiq/YTJ55 + TGAB1zrYOFHJ7tKcc8mm3enAl6SIEnfATBLbbQMPbIACDNApFBbQoKRN4WtUBJPzmEcBM6jjjIuzgeyW + Fa2y6sgafYg7qlgMazDogAYajOQyJooBfeTfS9MWM5l2kVkKzc8JKBBXLSdmrKy6lSXTervcpksW85RA + Dn675pNhYAczcCoCtsRKIb+0x4TU1IY3lR8UvEDPxUmZdo3htNv6TXYc9QoMPirjRqcuA8Vzqgn/8ob5 + wiY+KpxqbYYcAhUsY9OL4bP43Bi4YP9SFrxU0ZuCZPACzea51USzgQcegIJ8qRS51JqpK7cYSL6gp4ab + 7TViOlCx9r2TxVEu39IGNYEX+PbZDOx0DB4gYRH4RQD8SiEMxbbh+qJtBAyoAK+7nRqKZfQruM2gVuQ8 + C1fRswOhjHcOdxiBEjDqLyd6XiFXqDn0FCA4jP53Wm6gA+ZkZGm1LRwE7YRrGAji4WS8AQwesIASGKAA + j9qUmLNqapj45QMjUMFwOg7xaCuoTpI1os0Rx0FQZjnmwpOYB2YQTbecsGxCtlnzuMlyEjzgsD0fCgco + wILZ3radZ8WFBSRi5aQ6/ZE4iEEKTDAChMIIUs9VdhuMFQIGwID/62jhacX9hHHKAOorMZBAUNq+Sw3o + MwIMSCnC0jRfmRCAmjIq98IscOS8l6RbqxKfJvEUHQyNi2Qv2AGDF9/M6xqvBG7RqzcJqFDCMmAGTc+8 + vH3awydTO2mf2bizT6/3CbjgBAjQ36ZGlPvQ7st5t3wAq2OvlImxVWS50pUQYqBtDvA8+E/stAhXUMIT + AtR5vL/P9AngkxnsoPlQkYovLaY0kembBVJXnGa7r1SmTjEPB3M/bz51ABV8Nf1nUc6QYrUZqlDAP/UP + 62IhwAFOwARIYJoAzzwIoAAKYAQS4AQcAAJgzv+WYnUWAgZigAIGxRYWZFBGA9PMS80kkJzk/wTcHMAE + DoDCdMwNRGAESgAFIEAG+i8E0UIeDAQGhCR8XGWe7O7y0EsGEStlZgACVoABFKAESOAASEABGGABGsAC + DMMHE0MeOqADPIAhKCAGPHAHNIu6oPCecKAGbdAhOCgSgIcLu5Ak4iEDbgAHNAAHjMIozjAO5XAO6bAO + 7fAO8TAP9XAP+bAP/fAPATEQBXEQCbEQDfEQETERFXERGbERHfERITESJXESKbESLfESMTETNXETObET + PfETQTEURXEUSREeMOAUUTEVVXEVWbEVXfEVYdEMS/ET6epAzgkCXAAXc9EFdrEXdfEXeREYfTEYiXEY + jVEYhdEFWuAIJP8gxmRxFqdgDQMiFCShGhfhGq0xG7FxG7WxG7nxG73RFPptA2DvoZRDBlzAAVAgAQ7A + AEbgHeExHuVxHumxHu3xHunRAAwgCRdABeClv6ARExKiAyTgAl3nASyr/BBSIcsvIRnyIR0yIhdSIhty + Ii2yIivyAVqABbIOlEDQjoyGAlqgAZ7qAEqO+ngvJVVyJVmyJV3yJQlgH28kBSxgApYvIK9gIAuSVTSS + F33yJ4EyKIVyKImyKIkSFyFgGRUMBmLsIz8I6lLgqRDgAEaA5AqgwrAyK7VyK7myK73yK8GyAERAHw8A + ARLABWHAnnDSCaLCAyigVSyrBR4AApKyLlv/wC7x8i71Mi/5ci/9si8Bcy+VUSPLLxbIIgee0W74rAJI + KGxCQAHFUgTGcjINgDItszIx8zI1MzM5czM9szInUzJFQCwrjABEwAQaIAYUby2jIQckShdbQC7l8gFo + szZt8zZxMzd1czd5kzdlUyPpEgJYAAb87YlyQIREzgAI7zFDQDIjUzTH8jmjEzolk+SoMzKtkzpFUzqz + Uzqpszut8iod8wBQkwUkoBxx0jEoBjj1MjZ/UyNrczZpUz7hczflczbxMz7ncz/rkz7hEz9jsy6Tco66 + IzEhRjVWgB1HEzK5Mzqzk+QetAAgFDslVEKn00ErFEIxtDotdEInlEO1//M591EBUhPeQrHG3lIjYxM3 + 49KyCHM+XfRFYVQ2WYA+N7I2Y1RGEfI2c3Qjb5Q/43NFl5EsgK97boACUukqqwU6M3M6MVMsOzM0mxQ0 + KRNKq1M0rXNKQZRKn/RJoVMBHVMESqABPIA1eWDvZiBAk3I/ZTM/fZQwafQ/45I/afQ32xRO//NOhbRG + 2fQ/65M26TI2LQAGVtNuMkACIsAErlIBKRM0s/Q5rdQ5QXQ6KxREI/VRsZRCJdVRI9M7HXQyIfM3TkCM + DDQT8Sbq5lJI9zNGazRGfxRGX/RGfTQhX7VVd9RWbXUjcfVHb5RPeTVPV7QCnjB1+KwFGMCfGtRJr/90 + SjsUSiuVS620Oy/0QZUVUzmzWZn0ORMQAVZAxALy+SxgRf9UVmU0Tmd0TnWUTVsUP/kUSGmzXcfVRWdT + Xl0UXgWVAnbAKR9GAyygnygMSh11WZ3UQi20SqW0SrXUSwM2O6f1SrcUSw0WNK8yHVaAAkxUEzeAh4Az + Vls0Pm1VXfXzPjkWN1+1ZOF1ZOF0Tn+1ZOWSBSigSOtmB1Kgj7yTSjP1Qgd2NEOTUnXWOa2TO511WYM2 + W79TU0WUQUGlBQoVFPvMPUk2ZOmVXVN2RkHWTlX2aqnWXsu1Y83VTu+SBejGUCkABb6gORF2LD30Zis1 + aNf2UxnWQzX1ZyV1Q5v/NUKxE2dHE5xUwOFIce8eIBf9tGVnlVzflXBBNl3l82Pp9GRjtVw91jZl1VXl + Mil1pHF24AEUQKV8lmgZdlqPtmi/1FLnVm6D1kuHtlNHVywh02FVygBQoB1KkakeIALus2Mhl2pv10Y5 + ll3dlF49llfrtU4/tlchV15bIBcpoAOYD1hwgAIcoPMe82451TI1dVI/lEOnN0ohdmfl1mY1tEuld0vB + FDhSQAKWFxPbLFVhlVzjFHhn9VwP91dzdXhd9XZhtT/7tH1dNCmVyPS2RQcg4ARSSnVT12EjlntFdGeV + 1XMjlHul9Fl1lloXeEEpGAFeVy07MYoqwGkRMnLv/1c/gbRkdbRl+9NVVVZO8VRxgVdH5/dOeWsHLhZO + dqABSqAqGRVtMxRiJThaeThtH/hgz/ZTrfeHFbZgmxRMrWW//DcTFzMu89N+hReF2Xd4G9dxbbdwVbhq + R9hPHTcp0cl8ueYFUKCPKFg7mXVgu3duQddaUfdzJ/VCPfVmLfVnI5MEUsChPpGnuJhqPVhd3fdxRXhl + a3SK/VN/URhIEzJdVXQ26Y9oJqAtGlQfPRdn3RhTeRZ1N9VZK9NoeRZui5hDT3diJVQF8NgTbwDc1vR+ + Pdhci/dx8ddkYTVHi5ddTXiW19Vx9VQjZQCDtyUGSqBaNhlnu/Rmr7eBF5SNP/+VbbdTmSv1OnWWgHv2 + c0lTBBygTENRAygAF/O3R2d5amPTdgUXa1cWT2FZivH0g331VjuYPStgabUlBhDAN27YkqX3dCdZiPG2 + Zo/WS/GZjYs4M5s5MhMQBbgvFJs3AgZznHvXlec1P9HVcVE4kdd5hVGWoUf2PWeTLg2LayiABMLggLUX + Wj95k7lUhxsVgon4UlXae0ezpBV4QReAbz9RA9AxKe90R7fWm7m2cKcYPufXj1tZim9ZnAsXp980QI2M + o3+5OeP4URf2UoM4S3NWgj/ZMi+zQ4kZjXO4Qh9zBawZFLFZm920ca/4j6f2XX8XkMv6p1fZeGvZir22 + Bdr/hGtioC2i91oNOGffWHwnWKotOWAftmcLOHs91SoXdAUKGhRvQIRsGqO59oTd1XDr1KjlFZA72Hfd + dVXj97HJ+QEowJ2BBQYYYJPnOVqj+mD5WUvdNrA5VUNR+3tzuK/xOjIPoAFGzJQlIEYhQJWHumor+6e1 + +IN5+5CF11yv+DYBFCFjAD23xQNIiGYf1pI3FDyxFVSnd4Gve3v5WTsDOzQxWWcPQIlF8dfOSUV31D+h + dovfFJd/e3DNmUXDOTePmo/5NJ0fgFf0lZdcAH9uuGAN2LWrNasJG4izF22T2a9xeJjPVh8lVGINwILb + eRR7aQZUtH6P+qF9VaJz2ncl/xuc07l2A/ehQRh+V/SFY/hNcCDotOQxTXq7Vdu1CxywYTtih1aqN1SY + a7xoTTM4ymIUF0sG1Le4GbpdP7yyiVuWa7VrObyWBTeFz3o+6XIGCLVuMEBlFiUB9dqv71arlbV6pTWY + iViIrVVgrbvFldR1N5oUo+h47bOic3qyJ/pqzZrD19m3Ebdd2bcnWyB5TxxOsBkFQgAwWtrLpzpSWXuC + rfqMOzfL0XgzT1dvZVoU9VgZ9/SbL7qKD9mcV1m9H9pwZbSyy3lG9fKzUacDZjYB61liHVbGEXiS8Vph + QTrR/7t67xlMSwACQLsT+yw4X5RVQZiz03u9kZubqXhr3//XTrG4V99zkYUTjBsHByygyxZ1iCW5gWEd + wQH6Q6nVxvu6dLHbiJO5OUmgYs93EzPWiYGad1v5fYV7cKO2zi9alke4rLtZNnkLZrmmygMYWbt8O2lc + dL13y7Mab2UcgltbfBd9URHAARomIImHh2xarY3dsg35Vf+0hAtZzvG8VRfauFX0CPJVeHgqAiZsUaX3 + Q7d8YYV2wW3cr4e55QXc0A0WMg2AYUoDJ89xkSkbrU3W4glX3d39zgnXyD+4p53YPeUSBpmba440lcIG + y+VWsLG62g0cMzvz6q3+Mzcz62c7UxWwWhAgBSIdGtGUPVX14tn9yM953mOV3ZtcXNv/F39xuu3XdFBz + nWhwgDHZUdVXd24Z9O8BP/AFf/AJn/AtdXXFEgFINAZKlROHz3WQHt0tPc/fW4sxGoSRXa11d5Et3bwR + sgKIM4cyVggnzDEJmOq5O/VVf/VZv/W9njmXcwRMgD/O00yXQAOOBsiRkoPR1bHP2Wq5OM8vvO17fz77 + mPPp0gUuawIK9Ilejf3kmVEplOpnPEoTVtZRW+uBuFPB1DQVIAVIxfaJIp8oXBl3O/jrFWV/VMPPW95J + Nv37eIUx+i5zcVBv8pFygAKisgSmEghGBlEhFCoaC4Sk8ZhcFpVO6RFajVadWqSSC4WKDKMDorSAwHC8 + NbvtfsPj//I5vW6/4/P6Pb+P37xQWMxYsDy0IEIkLrYoMi4qOjo2UiI+QlpKWlZOIj6wDM7ISOTY+J2i + ptLddMi0qJwkjCgN1NrWgtzq7vL2+v7yEhiQJKCksMBw3KgyNzs/Q0dH3+R0SMRUWBy6uERwf4N7c4uD + h5d3o4+nq5+vl0N8VlBIeChL3+O/ZXhUuKiglDhgQMyIggUJGkyocCHDhg4dDhljYkGDBzE4mMqncSPH + jh7dUOsAg0I2QyYfoEx58mTKlixRrvwk09DMljBl2nwwiEIMDzqWfQyaykaOFxOyQeCWFMJSpi6YQm36 + VKrTqlSvTs1qdWpSFy0syIDRQY3Qsv9mz6KNg+HGhhw6drzwIHcu3bp1X+zwgFevXbpx+wIOjLeDjg03 + MKRNvMcGBhuOH0N2nCEy5cqWL2OGjGGz4s6eP4MOLXo06dKmT6NOrXo169auX8OOLXs27dq2b+POrXs3 + 796+fwMPLnw48eLGjyNPrnw58+bOn0OPLn069erWr2PPrn079+7ev4MPL348+fLmz6NPr349+/bu38OP + L38+/fr27+PPr38///7+/+vBlg4dwDXBBDDsQBgHGiAGoGJraYDDBhzowEEOG+CgQQYOfscBDBZE0IAK + C5ygwAkONBDBAxTsABSHZrECQwwUzEATWDx5UMqL2GWQgwcyuOD/gAImlEDCQCMkYMIJxlgwgQ4a7OiR + DRpw4IEgh0CQggoNpOBIBWIZFqV0N+zgSgMOMJBACQiQcIBBCJRhggIoqBCBBR5sKCY+G3gQgwzafBNB + iFyK08IDM1AgFg4N6qkcDhI8wECRB7hJQpuUtmmppgeQgMAJLkiQUaPPcDABC92kEEGqqrK6aqqrQsAC + KYyOOhwGOUhQQQQoICCEGJQCaymwAgk0EAknpEABB7UyQ6YMDwwqYgrTCvqqqik0ICKXLljQk47MApfB + CxY4gIICbA5bUKacXkrpGGPAWYIDMmwA7in7zDDOtNay2mq11wrqwicUeFCvvbth8GgLvAo0/wanmD68 + rqaXaioECSrEQNbBedigg65bptrNv6uKnELJ11ILwQwScEDrxrJlsMMED6ggqZsFRSzssJhOPDGxJszr + 4st0YLBDBVlma62rI4/zb7X7xjpKB1AODds+LKiggMTscs2uzxQ/nO4BJTSwQ9V14EBBvwEL2jaq6ARs + sshtexPwAzK8oPHZqWnQQQwtOCBLGD0L+7XXhmdKgq8nUKD33m1g0MEDSSsNt8l0u3B525fPjW0KLVQg + wZOiPi6aDTtYkMICJiTQLtiIc90mAjyH3aYYJqBBdelrYMDB39RS2yrcqmY+fPF0m0ztUzr1pPvunonL + wgIIiODwCD2HTf/G4YnzPHvObY5QAgoPvPD8Ght8mDmh1ZaMKvubGy838iGq4EIFeZufWML8QLCALBHt + jFOz09m6IuY1iEGMYmaQQf48MAMI9Ct5b2Ob5ohHN7aJrGTY4hLoJrCDDeQpf0GxQSsiwAAigY92m2LX + ALHXqYe18HUPM0ACHkC6x8EAAoSqoAXfZ8EMSrCCQqTbV1jkPBFqpHcwYIEDTHCzBH6tgDprYbCq+LpO + zeIAETBY6WwQAy2tamRMwyD84JZBb7yqePvCFgRCx4EQIvEevnvFCb3nsHbFrnCJ4x7hNqVHTo1ABAdI + gdl2pwG1qeBVmnOVOioYqAseL43zI1QLWCD/Aw8eMY7N4EAFsua9A24PYt7L1CgN+Mmube0AIkCACiQA + x7NxYAYhCmMEm8Y2cdTyh3Xz19L65ZUKeCCTmvSDBnQAgwc00U1HyuMVeSYxSw1wlH7cmrCG4YCMddFj + EahT3SZIxstxrpsXlCTygIitOoEuGQwa5ilyAKQFlGBNCaQdKA03wJ3xUXu1g5jFVkCBHJQuZiCqU/Io + 6M1bvo9zcgNiOnyYxqfMYAIdeCU77ZCBVjRAAcUagws3dU/ZqZBwByxc7Ay4ygVUAKCPw9c257fLRh6v + eGeUXxnfNzfkaUlFMtiBMCsKBw3wI0gnCMivBAi7VCJVewUsJVJtRwKU/y7rcTfwgAVcsEMxYs54nRse + 8eZmuQkW1HMuYEEFYvBBl/m0DTmIgQnlKdLvgfSPE2uhNKm4x2kCchgLkIFK90YmWXIzksQDZ/vCWc7D + 6rKbJ7PpinRA0YreSgIzSAEDjIQzAm7tk/nE4z5luFQECksEJLim44ZGQsAK8W0NlV/7jhe3r271pbRM + VdJWlKPHxnEDEsDaAs5FsT5CE66kFO7hvBZDVHZNlaOdQE8P1jtZrg+ciL0pay24SK7SNLu73Jc3DvWl + HOD2ebdi6wlmd8fOBlCuda0dSXUWtlKqUJms9MANq7YBGWwzZGLkoXW3esYekrGrdXvoyfY11hh0QP9o + 5tPADmJAs/Iq83o9i+b2KBzf4MaVwlEs6bpWGQEdPO8GE7Bq5dw2WDN6FXOGVWNMv9m5Vq3vborK3w0k + ALhzadaAV1xhZ1OJ3Hkq1YAlLUgCWqDgs2Egh1cVLFf7+0MertiHF0To5tj3Sxj01a++gwAKBCeGZ2JY + WN6L4TQ/Os09jnSzBEQAA2ZQ37N5gAVYxeV1X2rQmvYwZBNkccjCGkEuQaBJjj2bBnarOgW0zk3xxec+ + YTjP15kZvXkU8qXYHAEY5E8HMThVGBlp4v4SNsCac22d/1tY96VoeRYgWA7QOqpCc7lXHGWmM3X8PRYK + 0Lii3N4LxcxhnSFJBTL/iGqId0ABpIWzfT00NRpNvOdbchWI1uXl0xow1glghFkY4FO+AOIrjnaKj3MN + d68LB1/3ijvIv+bwzRTAAh24em+PegC2cpni1GKu2YZttjdZLM618VJbLpiBt8L7n6laABa+DZaPI8bU + A2pWih8taXztqm5grSBUcYwlwGja39Ym1IwkizIamyxdRe43ZPCYwQu4+CIPPQAFRvrVee/KPV4HGbji + DnN7c0bx6xWDBVnOnw3G1YJZMhKsuCSjslUbciq7VtlrG9457ZSMI/MHfdDqcrEUDUr21hO0Pl/XxF2H + wEc72nbDWAELOsBOHIwrv+wLHr/COWpHOtugEnSx//vQsfcqdwksojN4fdIGi9bdcYVR5F4Mj6upe0rz + 8cW1+B7vCbETPKAD8V4wDFqgNMBb2aEij2S/sRv1gD37xfzyCgU68Ob6nLYBTgyDukbaWQujG6TZ8+yw + ZNj7F1axUiZYgQV2sPn8AfVoKGPkbFEMv5eOvpz//Xts/10tQrXxBc2VTwcgkKZeeb2Atje7HjUsUsI1 + Ps3i99mb5uVyn8YMulyiJRqbf2LqHvTEU3btssVZZ/jFShrkBwdYwAngjK1RExQpXvCZnT4FUK69F6UV + 0PUggJI4QAUQW1qtgbhUQAs8Rcf5XWLt0g/dVMnNlN+Z0YD1m6hpUEW40n10AP+5lMAyLd5dFdfO0Zoe + nd+t9dylGEABGAACoICd4I8GugFR9ElVTcv8jZEk0VRM/V2o5dnJTB9YRZ+IDJwEbN963IAFAIR5hRSl + 7ZNdRRpJTRzY3ZzNhY0QHAADtIAElJYRsoENcIAEKKHwOE3TpNh23VSKwRbq3VlDxVbm+BILlA99dEAK + lEDijV8Z/lHEaZiZSV6vUVElAsuXlcCSqMAMeEAcyiEb7M+VHN0aUZ3UcQ4K6tKoHZYqQpIJThttuQAF + bCF6pM0KIIABVEqjWRG6rRuj1dopZY/tGdAQDAMDRMBOacDrfWIb2MAGNNipaIunZdAZ9aH/leJr3VnJ + JRv/lS1N8RGeeWjAiGkUI4IZez2i+p0ZBPLaCtFVziBAAqwABGjhMubBrUzADEALvzjZ3vHjf2Hj6fHh + v0mhde2LRbQMfEgOPClaD64fesnVpPFiPmEKfB0gAihARZjVLNLjG/TNC8iAnJEi0+XdIJKcYPGXOOnh + CLIKtwjge8CACiSahLUXQ0oMU1lihuFcR60QR51ABFyEMkbDWrTFhXwjddhABkRIMgbFRVHAAxAiyexj + 06ng8/GQOujf/4Va39lPBrKHDDBALvLeGdJkjklkMCrVGfZeAjCAA7TABLwfPkxJlcjIjEzACxTGYWTH + lLiFXsTFDnCAYRzfM2SADhwF/wtAEAhKmbI5ob58FZ41JiBW37Q8QCG1RxeawAFOog76TK6JX07qHEl1 + j7sMxAFcJMttQGAyAyDEAKCoigpsSapV0pcMWnRs2w5IAI1owyHAxE7U5ZNwBBI+C9LVXcmN4KjtoSOp + 4ikSpy69Dba0wCG2Bwe0QAIIErghEDD6GHD13hhWUaT1Xhkgy7BxRO84GJoMiQnISQIkCXqayALYzw4A + pXFgAGFaQJaogAPg5326pgOAzAPcjydOg9+cSoEhFGGRU/+h4GPmW4FSXQNAwARg3Xl0QATM4KydH+Jg + T9q1o+7dnJBFGAkowAocAylsxLa9QL40EZuoqIpCU6eYAP8KNIAFJANqAkdtbpo/rMACoAAKLICO9iiP + LsAKNEALzAAMzKZGZAAHvEAM4KOq7JDy8B/TmGIJ3t2eKVRzOqkLxIBGggcGeACFfllyCaMZMpwYMqCO + /ZZ5/aABmEAKVMBE/SbqlAsDIFoJqMmd3qmdqomcKMACqEALwEBR9kbRKN9+OsAKHCqiHuqiroBrZovA + YJtHABUFtEA04qHbLFTTyE+p/dtqgRx1OSg2sUeNpQB1hhSGbajPkdlnTlhyUWAFGmMMgNh4dsAMrMCa + xNN6omeS8Kp69qqeMgAEvECEAkfHgEiOLip+Nip/Mut9MiuiIioEXIRHsAIFGGZSTF3/Kk6Xiz2fnTXZ + ibFRDORADYyqBDRAhU7amXoo2JwbMAbjukQECQwfBMhAJ3qEDiRceZWBr/LqrvaretppPFXgCrwhl+LG + VAFWjq4AtOJnfjarsyrrwqoAvXJlPjTjDsBAB2ZOIumXTQEiYhEnY2JlCG7OxP4TjX5HBkiAIn6Zr7Hq + qmKW5bUqAQGLwyiAA8wAnHoEDsjA6iAawLKOnqrnrrIO6/Cr0fYkphXHDiATwzYswy4r1KqAokZsAzRO + UGiAR+bjGKlY6J3a8/kXIJ6c+mjpW55H0YDp9egTh64r244leiUEMSDLilSsRmzAFyVAvKBn0e6tvx4t + 0QJsCbih//ENRw5UQArsKNQ6rLMuq34+7X2uAI+2JYDeww14yKZha0i2WNMZzwg2VNws3SKFqtmehw64 + gKmGIarqWk2mHfAdzj2NgRiYAQvUA7HewyHtSt6WgN/yq68Wba8O7e7GU4hmnnBswLGNyAI8LuMeqqFC + q35CbJCmwAMEqlBkgG49EHfpozQu51VaoccN2LVM7Ja6xwY8AHWqbc/54i7SE82ybcQkQIjSLspCw5ee + QND67tD2a9Dir/D+7p5OBAUIqmxggI05L8Q2L7Mqq6HyJ9U+bwOwQN1yBCB0ILYKDzt0q50tXedO28hM + rMa1RwZYwGUKVx/d4PhRk9kdyfDZj/8EnGZZaEAFdJmeGq3+7q7+/q6/3jC/WmQLDN1upE0DKG9+Mi7z + Nm7DTq3jOuvULkAEgLD1+giTZgl3rY3Hhdr/ARg1WktFQGd7UAAKABmwnFIK61jZ0VpBmIEFaN9ZZO3C + 5CrQAm0N1/DR5m/QVmAEvEB8zkbkMBEKKLDDKqrjLmsCLzAhi+ibDnBQ4kr2ruTHPtTSuQ01YmOeXUvb + wccLNECiTWQekWGtAZ9meg8ujs0JLICb7kAiR8MOzICQ5GoO722/3nDf7q6/Fi2uCpsE24bCKGyzHnEC + L7ECK7GyNi8EUMCsngUO/IgFNMLyQd84kd6yaVWrpEoL/BN86MD/KgeEhYrhJ7ssetnRD4aPA0hrgtGv + NNwABazAz+Jwr7oy8NIy/7IOMSzAG9ouAZdJkATp1DrsAkNuPydwoypq1CLqxMKAHmuEDeCAzFRVNHba + x00lLlnh3E1LoM3je1wNA7AhHzmeuY1dGsIv29GXYnxp68Tyv+ZwHRst4MqynZ6ACljAD9uGBjhYAyws + Ejdvo/4yMO+zIDssChAfLgfFIkPQdXlVH3rTQoEtwCBDq8VHOK6AkQCZ+kqRz4XNl6nln7YeKt8uBTgA + rqb0OsPxv5b0/9bwnEAAUKcCBmQAW+QAB7i1hWTIZOwJYBXyIBcx1SZxXUMs4/o0Ghg0R+CA/0h85FBX + zkDqYUQrTaq86V+Xhw6UqnWKlCNm5iUKkvhI6xt1hri48Tv67v/O8km/Mlj7qp2aAAOkgNuZsw4saQU4 + pTd8BcENnhxhjTDrdCHrp103a35G7X0GaQS8aTkfdA6YivocqNRlcfjWnbQabHnYAFdrTZmeXcMFnwAV + AwR7QD0HhQ48QG/h6Vf/6zrLsXcTbUqvgAdEQ5K+QAdGwArQqZwwgPJ+TuiAVzToAAQENCD7cxEv8PPu + NjAjqrXxFWjgyp9YcOUwph72UuX4J2XOx92WqggIkuw8E5puJkGwmZuSAmOP5wRkDf4C8CybtP6up4if + dPAiwAJIwDNEzv8E1GcKHCoKlAh7nsB7J9JXOImG28GEBqkwO+4fH/F+umYw63fz/ql5g4blGpsScpck + hx45ZQ4byYAO4Dg4yoDMWRECOtzukYDglq1obMAMVNYNgzgtmzTfDm2Jf7UJsAkDKC0zxMzhLgAD7CgD + 0PkJzPiM0/mO9nYFnLIz7IDq7Hh/+zLEDnLDGvri/nMpk29ozOdq9l0GW6U0L40l5we+rg74Ocx0Z0/s + hk+IRgDLUe4xw4ALqDln/++Inzo813GSiLnRWgoKpDgzLDJlDYmJ0LmcMwCe2zmdDokxrAxM98GE7ujj + Ivog4/RN53Ve+zJ+6qgD0O5ySwmf0EhrU3H/QWEqM3sFJ2L3e6xVBIzjMkH3pRREARTACDBALB5paEBK + b8UJO7u7rupqLfMvqn94CaxAF/sBvkDAiOS6nd95rqPArcP4jNu6n6pMSKdCB7hATfdywxtqj+c3f+p3 + jk4sn5cGg5nKLDEh3SU2obDAjffH8SIu68DJprwLNO1rPJ17S46GBlhAOhOJHB/tDvPrDps5WfeunToA + g/tBB/Qxncp5wOc5rhN9wC9JrisAnTuABRjzKXAAMj1tbi9qj0ft8u53ISfqlmipVn9ExyxRI3SFBoXR + N8ADC1wEcJdvetPbCqDnpISBAMGqA+hUMJmGB6SAAtAwqscy38Z8aKe5/0n7bwIgC2qfgoPTaYng+a3n + ep0v/tHXuQKYiDFUMyrkAAucCW7n9o/j9y8rMQJDLgQDu2ckjG0W5jKzyrZ4hX/Ow1lxCFHYYQrk6Lm4 + SQXOCVvKQIKhhjutwJ5+t0qvOom7u2fb6Zy0AFrXwd22wArsusADvNAfvdDXudEvfjzGAOn+AZBcfkAn + ez8XOgIburIb8qHKI7SbxehnrCF44ESDQlkVDNfTByschTKTmMB8xSiEPmjgQA4NFR2TORCYEsJhoig0 + IY/GUpKZYDQqOF7VesVmeRkYxMFQMMQnFKMsLp8ZZLO4fQqrIJKM1q7VTB4px6qvUnEI7BMs/FsJRP/8 + U1F0WPwjTJnxuLmzvMTMtMvI6XiRmIihoJiQeNnJ0dBcZW11fYWNjb25wcHh0OHI2djAubGRDX71gFhQ + KClZMnJSQmpeanJWQi5ZaYGpi82xWFk7OWlbSwNnS1szYxsDX7HIkbXZqXBZ8RusL1REDNwfTNyHBEiv + gYsKHYQdZIXBho0MNzRo+IUBA0KKFS1exJhRoxUbFVY4KbJMCTQiyqKBXGKiBAITUnTIwuAhBRhwbsyR + QXEmXU40Pb2diLAj2AYYLRws8KMPUj9HjhopGuQIUFN7/VxMmLhR61auXb1+BZtJB4QTCJalPNtkCBGV + zdiuPVuEhIkIdGRtoOD/IImZMmTKueE7pqdfc0lUxNgQTIeFo42kPvVXtWk+f0vtrWgww11Yzp09fwbt + eUMMFQoQqH3GjNkRtqhLgmy7UsGDzbBueGCxAo5Nn2PU4PQN+BwcBxYoycIho4EfSJD/OZ3KT+r0qFTp + qXjwQlVo7t29fwePpwsKlUbiog5JRC1r83GFRFu7QEY2WBwouPhSszcK4OLOmPMtp29OWAECCmp7BQMJ + IEikKegcpGwyySA7xB4HIphhB/rC47BDDz+kaIcWUFDAvNWSSG0tJOCDyxkVE0BGgRUeMEgWD4zqSxw2 + /hInuB1zUmOMBbDzIJgcKGCQHkGUWnKqQp4zJKp//55LSoUIKkAQRC235LJLGyZYAQGz3FvvvZFMVOat + 9GAsAYU5KpFFggh4AsecIIEDEMAeh0NhBRckCMYGHWSIgBAoHYsQEccYkezBJQt8oUtJJ6XUOw4eYOAA + ZFRD68QTW0SriGQckIGKYEgTrKaa+APSx//2y9GMBmIQhgsvmKNMSqqoe7CfyipbAYUIKNiuUmOPRRaj + I1M4gYRkQnJPGWilVQu+khJQIIJIhclLgVUDS4e3cFj9cc9zDjtIhxmWI0QQphiFzjnrmHJwkAUaYEG7 + ZPflt99VuJjzmLNQ7BSuF91C0dMETlBBhmJloeAjcfdk1aeKX+WrL/5kpOAgLv9aaAAgCfGJbroHHWsS + 3usisGCHrPyFOeZ+cZhhAZSgXW/gZXLe+Vo0kUlghRk6eFkWGT5SlVWdeOqxvzdyvCmBBSpAKIcYvEDq + V+iqawReJ712sN4IYnhYZrPP7rIDCBIYMyWCYWtRGoOZaKYEEhJIwQNgDqpggYXzNPfipdGwU6cTEkBB + BoQw4IAFB/p8rN1+oNq6Xgq9pgeRCjhAu3PPPeRgBgfsDmnT9sxU71r0evY5mQVmgJNvm/XbKTidetJY + uIoPn5qiDGJwoUEKh+ea0coCSgQpCBD7vHnnP9NAhpnYHiLnad5W7e1oWKw+iTBSgKEiGcjjkbBwcPot + MHT/9Cwx8YpwSwFYyZ77Fcrj4XXKgRRYkCD25/8HoEZ2EAEGvKd0b3kbtHy2GhNVqwQMUEEFXkKRvpmA + dgAizODotL7geMME7qPIBvTAB+Y0aWSUE1nXSPYP5liJBZwLYAxleJAbxGAFMHJCMj6lMxelqDUlERMK + WlY0YfTtb+ezE2DSwaNXRa13FMHAkeaElLChUFePcVKu6mUIB7jgBUScYRjFaIkMeABTpzHPs87DwDWV + KU07QwAJVACDvVFEBrNzQ7j21J/B1ekvZGif4izSgREt4EkoowxUlFIPeiEqEZihAAzHOElKWgEDHaiA + ClTixhUljD0IU1MT0KMSBbhA/5IUJB/gKqa+pmGMN/w5wQcFWZENzIARjkoZr1DWKC4arw+IeMAEElNJ + YooxA9IrIJrc0h4Fdm9NOHzNpk7QAAr4DyEegUIeNZY+Dv7GTuHiHdUswoUHNOCWJmyUIx9RIXbmz4Vf + LGY8YziWw+GQmcpMD8IGxqKSIGOaM5igRYxYp3Fpc5tKpJPSxnE4EFokB3poABVHxkulOOlJJmMKrlKA + JXl21Hk2gIED2GY9USJQWj4s2EoY0IId1LEiFVxi7tTAtAC9sjcMnWVFMDCoFFwnhVRiYbyqk7KMOqIF + HgCjR5XaL3iwYAEraSADUccaTursCMlYyQKqmZHxWRCJ2v8UTvmCNBgSmeCJF7GBBOYBIenwqnJRQicg + QvYUP0XSpUvFa7I4wJgTAA2ap3MN3axqpmc64wQuKFJGYGox/6zvJnrqEU/KEEiNhC5kyBNZLn+6KHfl + zw8paIEw8zpaZGEgBg2oZw/jls9PSSM1yDgNAyJQKo0MVINLy104Ijs4dMhSIzeQAAt6akUTMgmoUwqb + Wx2Ar8SS1rmS2oAFGNC2Z9iTPcw80+nYY5YVbC6pCLmjV5/WQYRGFh24e4NZxZkRohjFkFjEKHwZecIp + 4Sp5KYjBhp673w5h4AUuMIGmztTDkXCKNZ58Roy8qJUKpDKsTPtLbhvLRJxqZTEqyBr/hQyhwqrQCyBQ + QoEDAMpfEnMIAztw3Ehfg89nomY9PGOmWhZggWHW9oY24VEbdidZ9c10R+rVyg0mgB+2VgWFWsRs8fqg + vEiW2Mnd2UAmGQAj97QlTXLTJ1VzqAAU/GkrtgUrBwHjTd3haQ1SW68ALRCBW1anZPCNinF/1bXrDGQC + 1nxynr/iARfE8q+oMylKA92ilZwAvzWuLR7FDE7A+YaJaIhlQzWigRewAMOKdDMK39rOpeTDXSPWc6i9 + ooG8AE2fZ7LWYAWtEgScYAan1EhX9djjmJrvseaN5Vk3goMJNABycQYbnd3cS3wklx4tsIuolf3bojCA + BNRlsYGv/ydoZagAUFxZ7PrKVVOy6o5p/EFzVwhpKLjuSrOYZac//LAAYQ1Nv8uGtzA68ADdmJqHoFL1 + GxM8BDcFlMF+0w9jdcybcK1y4BXmSpTZLDwjH69ymAbqIVZwLwjIANbxxvgrbJAXPzdTTaol7CfvbdYU + EKsr4SVorWVK4W/vJNdp3kgGKo2f+XY2vsYt91JMxsg5ZNzn9YGAwKJaMHxy6jXX2xQ1/c1g8vnEabcO + 827fEO6u4EACLZh4CRMVmck46sgNIsTEI2iqn5cdE6PR5LPaMm2RdLK6bz8J207wgKUz+MYGJXgTxcpb + /vjWKzmYQTfuQT+TwZk69p3XIRyQnf93m93xVdDA1Z9qlgHDbWAmPWlczLOCrXploAPvtphtN+aDA9kr + X+pp2O/XaYviTzoOdwRSCKK3x9feCh1w3OGepXbtOhPzCBRl6ZqwAAgI5Sswvd3FyCvWbkKa6l5ZDJs/ + jM7Muv6nJ6yHC2SQJdv/HAMTKA1WEWwtua0J5CNpwmm6PAGyn7zp45X6oqHOQYR7ReZrVlJzrsgoOvdS + XkHtue5zPJpZgNNYoMwTCWeKqmuZhhKIIO77stnJrf7wi4IiPUhLgzJ4vlErisZ4M/xRIWGzImATBHaj + prsSwHg7sRboKx2aljRZnezhoZJigmzZFrD4PNxCr9xSmnLIsfr/+4rFaJcWmg4mwShNc5RDQYHMQLQU + jDcOUA6hi6pRIjDN0zcmaAICqYCyOTkJRC/hyDsLTCIBMT2wEDI2U5II2TD5gStfqpB8wIwHkAAudMJQ + 8y96Owa1O4kB07zVSLUV25QFOKrOaDDx2qNxEJBWcbpV+g8gDEIZuJUSYkPkmpAssqiuUwHtq7s61DMh + cwGb6b0ZLLADGsVOsptsgQE6xLYbIihcSyiEyjFcK0OwgAcLUAHIqRJz27otyqxEaQCWQSpOXLYbqAAH + 0D1QWbEEOrUEZA9kWAAWaMLj80Ld+iqbihUda8QNNMMYiID8C8GvKbxzuqh7sDl9gAAYwDNh/3QyHGCB + Aloxe1q7kVOmt7AeE1CABsAKz8hBckhEVtoRm0BEi3FEsDCjy2IrLiqhJdG/Xik8Qym5xlNHEtuAFhAY + KyOYPzS/uTm690gGBVi8TfQKlPvCDuIjMWvEm5jFsMgBSHykoHoEr8koFuI/lXGEBpCBdIxI/uIAF1Cx + e7K86qoWuHkG9bsGnOyKQqQdx+K2bQucbNS1sMiAeOjG96Kc+TmZyWlIrtGc9svJEuOACIijtCAsPlw7 + LLMnF3MWByAb0MCmP0oomsJG9DKfqZM0zrABYggW4hk2wuMiYpuKBZixaOzK/dpJu9nDnzQYgomWhIkm + BYCAiwuLbAu9qP87xIFrxJTkDJphl675GkUhQf27Jc/ch8xhAa4czP3KAQDTITb6uBisrhjLQgeoAKP0 + PIBLPm3io5IEQ6eEOc7AgKKYq5ecPsrhLJsDhDgTMVU8zdHagHYcrAQUSjR5zthQABVgAeMDDZEMSOUz + r27ywaipy86wjxZYPXphw+JKwrBLgZtczhLDAQuwmXe0SOgULKlCnZVAAcbjDqQEQ9BjpVX6znF5Oe6w + gQ4gFCWRkuP8QPiiDrCDiuWByPbEqxugABXouIwESqnyvRxCAM6jzeO7O3LJnXJhtNFzot7sjLSCgFzs + rDdTw9EMzYZLATmMUAlVKlshDzWaz7P0pKv/GkUqyxbsDI0cvMDb+kIIE1DEySnQaJzLUhR3UVDl8ky3 + yodfzJDvstGlCp3SMECPcxF57BkqY5gp8A7kc7Qdu5MR/Y88GdDuICcSSi7L0RpjO84lww7RytL9Aq4+ + 470dZYsU6ZRRYYEa6Q5Zs8wLPFJw8bG+0EbQGA3yzMX968vJucR1U4GWQcE8zavoQgF4tKpnujdlOKxk + 6w7J/BZGdDne6iYNDM/PuKQZ4IP0VMNd1KW6Uk5NVaqNU4E0Ssa4e5GUGoLXEczPIFLc5C3zKVHdalPv + 0ABuHMJ2+bCqXMOkkApkw1USuxFjgEdfPamxfIIPgoDm8g6U0xin0U09/3msDBzI0OgAC4ifFppSrmOn + b2yAioPAa8UrDeiCsribK7u8A4MLZFg/0xzSpnMlamwlVwG9vntK7rgNd/0lJdOVd9mwLpIBHcBSfFWq + Zl0BEtAUFXlH7GoPUUqGFXAYDsEmJcJAvDOvb2JTJeUQ4HKvpGBRXDkZz8IwBxjUjNVYpYoumykRNaoe + HKLBJ4gGb2EHkBxS20QiHWwskpwp52vY7uA1F4gf1RvODlsK0HqBTO3Z0dKB+0ABarA3oxMV2CoBoJAg + ntVHRds7bmvKMfuxqYWySluOrGMrdVKSPsEQD7jVr81XGIgAP8MqaaEbrGqC6jyQD5G120nUJoI0sP9S + V5j1kBvoAnPC2ig5lEDAl5YC3CfjNZDRDSwk29LNwiU0EMj8jsWav3PwkeZ7xb7ATPAgihl4ABcwp8zR + XaTQXRWo1weQgeP43CdjHBiwANRaCTF5tuWNIzHxyAeIAR2o0VJlWoqJsFQNs5el2++wgQ14ARkAGcBE + AcAk3/FltxWY0RjYAYIdXhK7gXhIAXb7CTjYjRNYgBSwgFTkEpH8Kh58XB3hsXWN2Q6gABaw2hRAYARu + gBRY4AiAAAuYAA6Y3vZ9rgzggBeYgAqw3RZ4AAhoAQ5mgQqIAQnQgQ9dXQczl4RFVpla2GXVkgzAgQ7w + gAmgABmogBvWYBmgABj/8AAdwAG2pWASw4Bb0IEO2IEOyAUcmGCUvTtjXdgilT+pRVEtwYAb4IUc0IVe + MOEgFrULsAGFqAFkATPlmzWoY7RsbNUuuYAaqIEL4OI3xkFFCxIN+pE1FRfehOM8Jq3G5RPbKbgw24nL + 3F49JmRKqqAwcFmMWSKBI4wdkZolLeRINuROTRpGfsvxcppzUAAZgWRJ9uQZ0k4/5sHb7DEfOQEH6JhP + VuUwigFjlNw/jhUMWppZm5VVtuUYmoAU6KOThNqnpcZvWIMF8LJbJmbnuZHHAWYyg92bepUdGZLsKOZo + 9hwojIAFcN0MJC8wvN6bIBDtu1dpBudkuYEX4Ktv//DfHXTLsKIJnZ3DcHZnmIFCvUBkTFZTFiZje1SB + Jnvnfd6XtEqBTa7kJLIYb4oVODCBFOgfflZoZLmUvpi1yNq2pyMHM3gA1V3oiwYRT8wPfgzQp1Xm3fCT + O8PokZaUI3EBqNGtg0rYcrVfF6AApSXpmP6OE1sX+gXm7nTdkhyQMcVYmfbpD4kJeluDMGC+b6EdkH4A + If3ppQYPfWWBqSQHYAan4fCG8V2BCOCfv2XqreaMDCDgB1CBAgLocwCSHIEDgG6AFqAADeHqtgYPHKi0 + Wwy4a5QpndUXt8Zr73hfCngANNSNb1AAewQHpPjFFpCBHdjivFZsrhjiDpgAC7Ww2m4wEwbADBdggQlY + XyBe7M3mCriOAQtogXfFDNCagRh4gR/m7NQmUA3YgCL2gBfwgNjWgQ3QAK9V7dvG7dzW7d3m7d727d8G + 7uAW7uEm7uI27uNG7uRW7uVm7uZ27ueG7uiW7umm7uq27uvG7uzW7u3m7u727u8G7/AW7/Em7/I27/NG + 7/RW7/Vm7/Z27/eG7/iW7/mm7/q27/vG7/zW7/3m7/727/8G8AAX8AEn8AL/jiAAACH5BAUFADwALAAA + AADyAfIBAAb/QJ5wSCwaj8ikcslsOp/QqHRKrVqv2Kx2y+16v+CweEwum8/otHrNbrvf8Lh8Tq/b7/i8 + fs/v+/+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2 + t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy + 8/T19vf4+fr7/P3+/wADChxIsKDBgwgTKvSGwcaNGzhwbMChIYMNDAszNrKxgcOOFxNiyJARY4IEDxw2 + 2NDIshAGDRw8wJhAoYIFFjdnkDzJAQfG/5ZA+WDA8TGkyAozZlhYOqMCBZIwXnTAEbTqHQw5PFBQ2rRr + BaRev1rQ6WFDBqto4eDQ8YLCUhZJkcptClYpzhkUXujQkLZvGqweaNb1SnhuXacTPOT46bdxGBwSZNgc + S/fr18phJSdtKuMFVcegu2jYEUPp2Mtz6XbVbJgyhR18Q8u+ckOHBLC4DesOW7gCDB1nZwuXkiOyTcxy + kcpQbZi5UqcSOAyf7iSDh+NdeaPWrtO5UhkeglMff2TDBK6Yl8/VzF75drk4YXwmT18IBh0xlqZG7V47 + bu8WxMCBePWNt8EOW51mmWrqOZfcbmBR4IFPBY6XQQfGjdVgcv7pBP9hd3TB0AGBFc6GwwtHxbUed801 + uGFcMXhW4nQbwHCZc5L1x5+HHG63Ggw5zDgcB6VZsOOLO26nno5NGSmgkMJ1IMNpcfGI3GqrNdfcdx1A + OZuUTFmmJYMrXsbag9/p4KVsUsIF1pItdjimejfJ0OWaoOlQgZtiVpnkmOstiJQFduKZ55TZcYgkg4S9 + 2CALFNxpKDM2ZGDpRYVI+UB6jTIpZo89cjmpMjfE9IIEEkTlgQ4UBqKDDCzwpxxziiYap2ZpumTpDRYx + NqodGgRmAQQNqODACis4cGwDLrAQQ1l/tOmgj7JiqeOOLBT6RwYa5MBBBx7s4MG4O+zQQUoarPT/axzm + uYACAiMYIIIIBdBbrwEjIKBAChVI18erVM46K2t+Cmptd4NqKxQOGNL01FMyPExBSS9wcMO6blhXQQom + GACCACCHLLIAH4iQwAoWvBCbHnryeaWSAh+MZsKS6sHRDhMsZ9pSTFGmk4gqYawGBzOsoAAJIhAwwAdM + f7B0004PQEABI5iAAgQe7PFqrKG+N7OHtGIpqs0xwZDiZminXYEME8Cww3xCk5HDDCcUAAIIAwxw9957 + E4C33n8TEEIJLXTgax3Smgn2op4ymiNS2dZsx302QpikrZ1tEDcZO7CwgAEDkJy33nr77TffeTc9QAEK + uCCBunYAXFhYK56J/+N7Y99hAwcSuHXXf7ODxbNTFZO4+RY5RICA3Xn/fTfgSpsO+N1K610AAg3sgEfL + ZE77YcyhEir5HBh0kDOg6N94WaTHe7FBBSZ8zPf8SlO/d+nPg0CAAAOU8ECQsYPV5Zakot7Qrju4Eh8e + OHAeFjlwN/GBW/uu8D4HjCB0zZNe9PSHPw3iDW9MEwEDLOAvOiTuQYZxkeL6c0CaTW4DbeGK17R0uUHh + BTYTzAIMFjCCECxtevXrG/7wdrr8jS4EBmCADA4HBz0FjEU0FJiZmhM5YLVlOQoKHqi4o5MJ7OBiOaxC + Bh6AgL+Rznn64+DpPOg30rlxBClQEx24N0WZIf+MdnMSnsLkUL7SGBBQf/xPBSYAwDBOYQcpGEHUOvhB + DtqviI6E5NJEsAAZrCwOWxsgzMrkH8UpkA4aeAGigKeb3RCMgDaJFOwM+YQNUIABBSDZ/KD3yL5F0n7P + +wABSpACGIAxDidkFPpU0z33TGaPcLhBB2zkJwdlyYAN6gqhVMZKKGBgBxAoAQGcFrjnlQ6It6TeN7fp + NJNBoIRNnJKRoAhI3IUqW3KMw30mMJkH9kaKV2oKDDiwymoqQQMyWAAJtjnL/KWxjfVL6BDTODoCnGAC + c6Aj+NqJMCnG7JNx0MAEwhS8RnVqTKt5lgT9iYQctCABSWteI4O4wTXWsqX/02PaAVpQyDe0qVouwtEf + n+lCeXIAVlm03JUcRRi6UABIJGUCBxowgjaK04xCfGoRWRrV0I3AARTQXDpdtkUa3o478JQDDrTC1Tjt + x2vIMUwMxpfUInRgBSH4AN9MF9U02lWN+kvoQVM3OAfEgIlqcGILQ4VKni5Oj2xVw2hgIBkqdRRNHeqo + nQDbViHsYAHyi+QQp9pBWq5xehksQAkgoFU3SNSOxhTm7AiGUTdwAAZbcaZZwYY7gu3nBf2s7BAuKz/p + HRSvUnueXglAV+qdjnQfCAEKtPeGTAp1ObalLZk4lKs3YOA6T2wnPtsDyKa8TrdH8AADlkZcXLI0uL91 + /6ld6yc1wGEQARao6RqCScDC1tFgnGwtG2okQ1NK152rpd1Svgtet6KAoMT95l6lCr0GO3KueCPZCBZQ + gdKuAWDrxC9hKdqn3LFhrFhU1MzAp0UrzWXAuQXvDuC6WfQG97NS1Wxe7/q3EJBABTAw7Z5kSyuvfq+n + bMgAzqJruz+l9pRbHAuBCzwEHTTAY0EUonrNK071KjSSIUjADChbhpuiiXH/dSbBqtiGGqlPUHWMrldt + O6umeIDLbeUABBAQgg/6lsFXjnJU6QraAcAxnoGFlfcW12P/Gky/aCifWxzbnyIPjJNF9gpJAM1kHuCA + bh4DpwdpuV41XpmhH/yAAP8KwIAKs0GwkHagMONU3TWcCDv3hWYUeayeiElgpAXOQAwcMFCnfdqlMBXu + ntXYXhDaWAUxMF4ZtlbMlxEav3TJkYfRMBp6cm0waVNbCyv6R7bhsNJE2MEDTFAAbtpyuO79LbHvylki + hgABLkDnGbzc42ey+Z5FRbQZGIgrWX2qhqhNbYSABOfK3mACKxAB//BKRAjfWa9z7awjBxACBsTgwjse + 4GN1OjBpItMMocxNMxM1rYoKXEuE8sAvwT2E5BmAf+CssoyDXd4NNpKhch1tYsUguxZpWLWg2g6ZE60D + ZrqzazvVrmaGzvIhYMAC2rSzxPXc7gd79sF/OwAK4pv/Bk1NdzNo5U2kE/hxMmzAA0UybA1XaC2LVikp + E5B303kgARWQoAA/xCuwPajumiv4m6MrAAkWMIGCd8G5hV71c00+bTKEMgawrtaRChY2IidHQpecOw9y + UAEL5j3dn163/WIezr6RgAWZH0Mw98P4xpXS4zsHw08jm0e0OppJMxCp5otwHwuYYJtnjPmdF2w6dAM7 + wiFwwAsMv4WeY0nagGyPiUGk7zBk4AWm8Wij7yjwgBOzAhKw8O6H4IEVlDviMpa4ZouNXvZyUAAEMEEL + dsD8LJxWzfgEcH7LDgYMvDb7n+I9W9JoR5cUkgEeKbZ7NzBnIYBQQMRIwBZc08Nu/521NCAwAgzwP2aA + eH8iXfeGZDdSfV+QAyAhcm2GO+mBZmonaXE3fkgAAw5AZz8Egajza+nVfrb0QSFwAAvwAmaweiK2giTW + HCLYBTaAdrWVhDwmSHZkJG6zci44BO+zAi+3cFjHRo/Ufg9IfGpkAhWQgId3HHNScsYEM2DTeGCgUc3U + gWZlhq83KM7ybVFoBDnwACRggTeIdXp4SxBHZUwzAhFgOGRwf1PUNTFTGUnGf0b4U/rhX4r3UUBXVEg1 + h0eAAROAAnZTPcJWSxA4dVm4V5PEACxAaV+QSWm1Wl+zKGQXe1qAARtwG5QxQysIfR81eWujcpSIBDoQ + ASXgMf/chFAPlmDBqGC+ZXPHRXE8KAPKxgX0JmZLqDjQtR1FqAUwBHkFtCC3d4YbBnbR1hRHxQH1p3kZ + MAF2B3wMBmqfZYzoJ2UrRQIRQIqHJ2jQ1lUIJFRzwXRf0Ee7cUCB5GPYKE251wFQmItEcAOv9DG6xGl0 + VYzDdnx6BkKkRgFgaH9iiIjT13ZycobTiAUn4hYlllMkJm0ExI+x8gIDSZBE4GQioFIw9lQUSHykM1wc + 9EMIkALhEQan1TjcJXaBcmKKmAW7YyNBlSU4hXSG5hUWECnh6II3AHUNuF7jtFnD2GnFpVnldAIPAI9a + YIqeso+zpUJJsZFV4H+whR4Lckf/OhOS21YryiEB8oWSRvACEUBuFthS5nV1tlRsnxhEelNxFBAGNxVg + 92aP4fOTtCFKTDhiGPkh0ncjeOFFywiXQqBRnmdupVeMLxZj0SOV1fMBI0BaYMCBkkdbJ4eWGmmYVpAD + 55FhnCRia0aAFbUUMvBFkrkEOAB1GNRpLkljmwmV9INLolYAfnWSWJCTtsJ9yJmNQNYFyqROPPlVr2c7 + 0HcjOBEDb1mbRiABmChXzdNgCxmVd5mHCrU0IWACESABS+kEzleIFnkt3IZWYikFGVB0YmiCQahdXwWQ + EkCc2CmFLWACI+A83+mS6OabfHg/emMA/nOdV+B1sbYhPwaJ/5CDmlPwWluBG2nZhhbJHvimPjLwG/25 + BDbwAi7we794Rk41fOHJkDN2jASwAFkTj1zTKRgJoWrnk6w4BUcYec44nTw1WyfmG8ARoktwcA5Qbig6 + ZQmFmb4JY3wGMiUgA/xJBfT1hg/EhA0Sn1CgATDAUSVmglqEdLgym6lHpEaAA3aYQTd4XsNmUHW1VyAz + Ag3gS1ywnl1pYnf6OIjFnB3gO9dYo7XyIqR5OYRkpk0wASdgAJo4oFTZYmyUmXRVTibgAjG6lRm3RSM5 + hneKj1eQAa9FSldKlNsGXaQZMSZpqEyQAxCgACLANDk4oAUKq6AldfojAgqwZc0nQPaYgv/1dkqwxwWv + eKGPxSS0qCT1diMxEB2oygQj6gIIIGoxWUQOFoxWd6Bu9EF+FgEMOgX0BU1fyn3SKANaSaWxVZ8+9n0e + GDYCMxYTMKTLugQYEAOYZZkLGav5s5BNekYRBgIWV6ZTgGopmH/DNHmcWgVciihFxXZW+qDtGRce4K/v + WgS76DG0ulLUOmO4dI539UMk0EuRCQWaYiQUJX3RGDx0UrBToAEdAHnZ9ZwGg2TO1icUoAPpaaYagGk+ + RIPnRozE5qThlDcFkADxlgVgQnkcVjvoekw52gT3YRxG21H12GyBGhcfKn4RmwQd0AIKEAJWSIx5dj9U + 1Ycy9zwVd3H/WFC0iXlASGKUaEOhTHADiNmwBSio+ucchBIdE3m1TvcCKlCFMHmOLEqtDOk3uoQA54QF + OWCNgfJsw+pMXlGoWMBAsnWf0zeYsDkDkLIDH6u3BWkBz8qdmsmZjJSZMeZITmMAKJBVFERPYEePR1KA + h1G1WBAsCcKWsrZq9tRYAbKtnGsEO6SoKkWgGWtXo9ubUdZGyVUCOFazRPB4GepzqEWGypEYuAYFF3IU + GqKuH/IyrRm7tNm7TTA3KBCgjKSbMAWrOZhXm0UACNAC1VsdthFbnCFmbBtd3igBOpC3qXo+7Ymp6nq7 + SfIsVgu+SFA+42aODbeZPku8Ecii9aNL/yqwtP+EIM9Bo3MLvZPxGhDrBDZQtNxIVEf7nofoG4tBwE6A + ARKwAFy7UPTTYi/JppgpAPxKAVMavhsVKxvHtlvCAs7CT1egAbCoghM1qP8Vfd/xAptrws3rAgcAlXYZ + ngwXTpDEXnKVABBAf1aAAzBglpj6XNA2AxNQw0xAOWYpqv84TKjUOC2IJxkgERygAzrQAeeSAzlwA/pL + BzGwAgfgQ+Z2fHyohbW0YH8jVzw4AwP8BNclrNo3WDzGGR5wx0owVqtZQBmKbyLpgRO1Nro3CBjQEJ1M + Dtd7Ey7QAMjCLC7wAOAnd3mgAxaAAgrna0/VXnxmscUFcVWZNyYTR/9XUBw1USU+mpYI5LjEc8iIbBs6 + k3hemRu2+DV50Sp98BIdIcceIAFSMcc4kMTRwBEwwAINgAIKgAAGEAJUQwIlYAILEAEzsBfMqwZZiwAs + qX56x8C7+WnNg0Qo4INWsDtOa0p9UqxFJQN426lX9L9sWS3X+D1NQUjrvAY2kAM7IAEh8RQGWBIwsCoa + sNDEMFYz0AINcAIJgAAHIAINKDgigC8IYDUp0ALg8b58BAMMwJfpJWM7G0lKeq9ZBlGdih/1tLgGaKUy + 1K6Q/E9GJ7I6VVjAjH/rwR4SsMFzcAMdMc0hkRqnETFH5QEdkAPYnAw4QAEqYAIgjS8lPS8FUC//YT0C + I3AAJIAAJ+ACMUDMctABDbDHmsibVHlL6PXHbdQ8CGC2tIEgg8EfamaAaOMU33sFOJB2X2qs7BlrbRYx + a7UwKzsSa7MjlTESjl3RLK0MOSADDVACBUBcgjPW9CLW9TLWI00ABqAADVABI5IHGTADKNDEv9iiDkZV + jTqVIPQBJPCXWcAwM3HM2ZYab0coJiGHhk0BONHPmkSaB21vYpF7E7IHGZAVN8wUT1sXp/EsJQwNWcsA + 4FwA4hwCYj0v5C0vpC3OInAAJcAAKpAyTN0GOWABJ8C1oBuTUrxuPitJdyNqIyADWwAROKMUD5BhIweH + 7FoWQc0ErsQUJes4//0YYCGoZBuA0WPQLTIh0TwTi7HIRYjhrs0Q3woA3mRN3vcS1gZwLyVO2iIwAgoQ + ATHw3mywA09mmSyssQtMcx8jACPA21sQLKxrMJ00SNENrDHAJ1+mwzT6ONmRJgmeBgzz4yQXRUkGKap8 + DDpQNE08NSNO1uZ94uNt4iLdgCHA4g0wA7+R1WegASyQAMclVbX8UlTmkqUTp/7NnBxwKhEtTcntFDEA + AxVtMV5w2FzBOLbbk6j4I27dBjZg4TmzM2GTGX2C3SW53cmQARXg3eE84mFd0igO5qPN6aONLyRgzhAA + A2huBjCgAgdgN74GyMboWeMk06mDADzeBRlwIP8gobt3MTEv8DanDgU3YHRWQuhH1rh0EQOaawe1AdE1 + QZiGrqeCclSJDgwdoAI9VNqfLi9dvuVg7uUkLuYs7uI+LAeupMcg0McMp1APNz/EOzogEAIKkGPWtwE5 + AC4QDQMnsQM5YBZicAP7fJQi54zYOBnPAuOJ9uSD0rKsx0lFBXa4lQwbIAMMINIjru1crukWPy/e/u2C + YwAHYAIr4AIVkOxxUIe/J8N9Z2cNGdOxTHETJgFl0BAP8RCYQgbWYY1A15WlVFuYawGTKAe3/tApsuGz + FoBliBljIR/IEOwugFLiXPEpfuLmzeWgTi9SP9ZcLi8kwAAtgMRykMJxFXz/a8puVbWZyAUCuTyuiVA+ + ZSmqaytIZ9XTNnSqcnADD62nx4mCf02swj0BU3EMHfAADLDqog3q217eBeDliq/i5M3p4vzuB8AAETDy + F/0GJs88+kp1PFu+D0bICzADBl8IMNRAaOa/HHot/0EBa5xM9c5YNxGLKsih0N597Gkkfi/GulB34CzS + 2Y748oLxGq/xUB/qWJ/45KwADmABN6noEtAAdNbHnYWv0XO8oPYxA2DFyzcJQVmfH4mfqfGhHt4G8ykB + MfAUNkQta7jkabtFmzEBmb0LMnACn37xGS/83q74Jb745t34Jw4EhdAI1XppeEnlktl0PqG8TWxh+AxA + /1gCCEQYbLne8FhMHlxPMlyU3Xa/4dGNZGaZVe4zWR7f5+v9/GT6ZDxu4hDhNHQm6lgqIPn68Abz9ibv + IikjLzdn6ig4EkdJS01PozJYSoREDEQKRGRdY18NYmldZQtea2VvdW13QwhCEBhSZiQ2MFBJNyBIBr7C + tsCstay7zLiyBEJWPJzHyZ9sdvAyAf8CJwMB02cmRMsTb3I8JmQsWOwk1TVtwpSu06eBmSrwk0GvXkOH + D6HkiFbsFa2KunbtqsgrVy9gHXHdKhCL14EEC1iIg8hmwgkRWbZpE1NGZhcs224SONACyUqfiHLAqMTu + D9FL6gxWkCHh0M8nGDi8mP9Awc+/dwEN/hnUzmgeFjI6OBU7dtSOBgdA4MJl0dctYLbWCgvmK5faEHdF + kEDxQAKHnmQ5tFAgYoCAaVxyarG5bTG2KyFIqJDQjGxlJhk66PNHlOvWPAg/UZCQw3ISDIskUKjjDxLW + o68BcnYtKZ0FCh1slNatO8MLFWhDwK04PNest7pCkrx4HKOQkQZImHAAQYYOyzsgIPgg4AM2mFuoXet2 + 2JsAAw4mNN1t+cYOCv0sXH1XyZ1XCxNy5LaMo8MLGFQ/4QwgTeABjcCr1DkqIQvAymC9B8W6AQYH0Bop + o48+Yguj45gTLjnjSAohFr1Y6MBBsnZQoYAPsiBPvG7/ZrqpRQIIEIEBGSiDsLINYEgIQa4w+awOsHIc + C4MNpNrHQCA/4ySrgw60hLZ4KHhBPR2xrEeDCRwYoZi5ggHzl1raCqmuDZMjCRZiQhDhmAgq8GCDsTLg + soQQBOBumi8SC0OLPc8A4QAUZmAoS7EwyOGFGPYIMEgo9fjEjhgMqeyGDXTwAEALNoO0Pqzmw2QP+pA6 + isEdrjxUVVNwmNDLNjGcBZbhzKT1lzHBtBWjXUYqqYQTUqiuyJVukCACafTM6Ttl9/zA2QIYoGDOVcnC + wYMY8OC0QEEgKYjT21L16ch8KJDBMwMHjK0gUEOlLV1QdviL2nkRyUCC3wiIq1Zc/zWMtaPibLV1LSGI + EaEEFSw4QiwbYEghgVdCyOKKKwA9w+IaR0CA0DXoHWuDHaYa6kkhA5Sh3BhQJSuDDTSFzyoBBYmNW5i1 + IurUEzvOuQ0MPGhgBBCCi8sikND0sLgwO5QV15HuOgCBExxoYR6nbOigghQYIGHFPLnumusBDEigAQsk + 4FhnpzDg7z9O4dNWUn7im+AFHZgZS4OoYMB2NdngocSSmZ30REECPWtNUgp20O/sxZ3gwAUSaOTIrQ8z + PJqjDXdN2milYallhBIcWCjCF1hYAQERiGEMxqZPiCCGaRmPUAcJSO3E8Aoo3UDxn45c1HBH+WbyQIFk + S+fRd/8YtC725ZXQoAUEvswIV1rdujXgMXv5963kDBBGJGLyTcABFvrCGSLMKHggBQcWOEEBE0pIwIQT + UFhBBRdmUJh5sVbuYAcPXiABGEwABjCQwAs84IEd6EADw4LIafARgzo8CVRZqQR9bic8SJEqEn+TVAwM + tT/GVeBOZJqLrkDUL34hTVYohMULX+icEZlgASmgAGl4d6moNKIFEIDAVyTQAQ7cYHciNJINNJADDugg + BzggYmVs8DEJTKWDxgPI4GQ2Mg6+LHB+M9xRPoEfIy6PCiPo3IekNznmoClX3JteMDa3keeAbiHm+0kG + cuC/HfjFgWO0DAYycIM+8o5lekv/Crq42BkvJihw61AKJ74YkG4xxY+M84ALFHAAvOzrI2vB3L9eSD1f + 0AUYakLjmoQwggSgwAWFsKNPbICBIlaSlnHIAA504Dt0WfGC/wANBpdkFQR55oJVkcEEcFNLneGAAipg + RZvYOLQ27uqEs7pVmLQnpqP9AjqslIC8lBnOQ7XnP55K1+0K5Mii/Kh47AjEpHZgNnHOKwcVYADqlGO9 + kKjxmtWr3iepZ70LlWkuBbDGCBTQgBl4AAeDnOdDnXIDDuRjD9oangcJVzNRzWYgnzrnOvSwDIdCFEIp + OoCa4KLPi2Bze/qspkBhGtDiEMwAqoQaX2BHUp1CZBFSYVS2/7TCTiYVTl3/WBdBiCIlgrxgljvVkQZY + kEkMEVQ4RCPOVAGW1VLKZTlKEwnTDGAC1+XUqWVFhQZAZjxPeaI1bN1llLpIIHUBjhDHxKFZD9WBB6Dg + VRaanr6Qs9Kr/vVfvKCLCbUqKzYVYAQmUAFO8RrZRCTRA0LhlEUzaM6DvAyYUYoUJLkYoDpUoC8jlWxl + MNCBFiTgLqakZtJYqhbBas+Ek0NsS0sJwxGQoAQLsEAITxvcJUBlUVSJB6k0itGYbZFdQf0RtwTCjxjo + wLTCJcsLImACEnz1Q7X9K4eMEzBPyipNM83qMIhRgEHN4K7WFW6iaCcphHh0o+4MZhXno//OBCVXKzJA + 2Svdy5sdWGABWlssN1cKSqRJ7rYC9SdgpbmR5qwJOgyAgAeaGuCd3qADQolHp5Sa3EZaEXCfDZ5zgxSa + 8mk4SxuYgelGkL1Ydc+7WD0aVjnUFuO0kEwztgsCXLADFuM1A+iwgzu6BSS3ymcdxcSoIwVnzqT41wPt + HTKEcjABFzhAu0xDKV202mB/tpCwk5vmjv0Kiy3Y6AFCvrJOM8ABGFjgAUdmcn7r08s7e3GRS25HBzkl + Axh4oAPyfDOEoBIDF5zAAMUQUZrVMosai2nMhu3njiPMFu/1qk0HOMEDrHxoZcpZNUf+aEEwGLO2zted + ze3sfjfBD3n/xDPDot5NsfaagO1mhHuSu+avU8qvf7rUx9vMUK8MgAIYVNfWsbvBC4gaKuHZN8SLVNA5 + hWoQc1EAmeFqNoTwKIEHNEABIwBfr0iSbu9ZVaWZY6lLE4tY5ySgzcz+ds4SNQFTs1WDjPwsaN2KRT7f + gbkT1MOgOYCDWt/7QTmIQQoUcAsRSdqTtd0X5wYqPY1A+NjLsQsJVlAB5TF8f1H0QEUrmFEnw/WjkrTv + 8UDqKGSSleSq2sAEWsBlBJhRhkPTnAkNW71emzmGK8QqmVJpghTAoOb708C1VLNO5Wp2xNsK6r99WYkj + m0wCHhhi0zt2mg7IQAUPA9/EUUpseENY/9LYu20+e0xeERxAASwAMNjppQO9wXXa0FWrv4NXYvrY4cgT + kJO98f4gZqbgBCUwI694HEp+WRx7REthS7dJC04fwAWGTjy9PFABFsAMnaN6sjrvbGJRwZoPJhu05z8/ + LxxIoAIRWMDDDPpof83456Dc9OWtOkqDGkAFI4/9vHoj+go2CesZhHKkXv1qSInWvy/oQA68ffx52UAH + FGhAAnhVXtxSHryBvXhXr7cmAhggHIjXvqXoMPoqCvPEe4Z1ff/MB8M39P3LyzIEUEABSIDn0iylKueN + Ng5gZKu7zoS8QEAEFiAGwKn/nuoFEmJk+i6LIGmDWM6tPsFk5EYHsv+PAjsGjybgAVaAFbpA9wBKOQbm + TF6wAb+svAyrRm6E5khwNy5g9i5w/r7Ig14jAz3BuWJjBljgAWYgBl7AL3LQiHSgAlKQADVO886E6G7F + 0ipncyxnF2yQvZpQR+BrgjrwrbBO4LYFyfgGFJZh4b4wZ3jEAhqAARzPoHoFhmBIwlLIk2xMDwGrlB7w + BH6rDR/EBoKiBzHQ2iSpowRHQIyqZAjIAxjI/QRxVTSgA2bAAUrAAFZwlN6IxjrE0iqve1whx8isFQAR + uCbRSHKA9lijufwmi67t2qKkdmoDd14gB+4uFZfnCRvgBA5AFOtQ8g5wVtRE2FxQm1LKoGykAlD/URcJ + qUeyogjRUNX8bYPcZRIEbQfqxhkrCQfcIwJQ4HTuQkQ6TprsMLf8JcxAwgbVgBstg0cuUGaW7P747fmu + LUD8gQJgoAM0IBfdkXnOgQXCsRfcSAE1xN1+zwAHpgBAINnS4x/JQgOgzc7O8OXwrKPu6w7sgOvyAyLD + KbVqbwFMAAEMoLUQq+jGCxQxL3N0jCHP4wU8kk5Cb9+Q6iDMMOVCTLSUAgasbxtjUpkkKgZaAAU0KXJC + kcE8gnJi6sZIggBGIAVC7ScdAgN2QAzpq8mk7eqczCAuSwaWUAPYUCpFiCoJrAQOIMbOyA4jbarEK9i4 + q1dK4AFGUCzJYew+/zDEZLEanw/gLOiYXkB36BKibIADThBrSAB1Hs0c71BoPmmFOgc6VgBHAnMl5sBc + Nqr0xtBv1uVtZkAfhWguJ5OWeKQFGKAox8vMMsRofk96hIAELAwmQ/MhbkAH/sOXrtGoiMf5soVBYEAH + /DE2a+kGPAAOG+8X6/DLCGtXgm5oco8EUmACJhA4x4HD9iE+koKdjooRM4HbvO43pZOWxI4CIuAEzA1o + 5ELeqklXSolGEsACovI7nYED3oMi+wz1Xu4z4kPQCk0S4XOMJMQF5LCTkMPtFLCrwm8EVgA2+7MeiuUQ + N3Cu1KmYcCeIQHNBxUkiK8AFbm8EvAwUHYw4QP+ETQalAmDPQk0BKoRCDI0CySJJJ6tvB3DRRCXrSGIg + Agaj5zSPMaeqV7ygABZABnBQRk9hDoxw3/6NGqtiggSNgYRUuDQABgAwAUgS3epwR8/Ir0YAEN+zSU1h + FZErGhFEJ3FHbjjAO7kUouIsBh5ABcptC1rr0dJNROTUGkRAfETuTOthXAyJ8ICnKByhHyiFCfHUvYIi + BUwADzWOSn+hBBogBip0UO1hB37qHYSJShgKUjUMB0hnfU5ASmOsQ2tqBD7nBFagAR4ABh4VU+uFA3ZA + gGKgXDxj68yFgBBIBFWVxRZB31SAARBgAEUgcnirBBTAAR7gNqLzVp3BBnD/YKIG6FX3xmRiQAJgtIGQ + 9cqqRgZybgEWQA4RwATsxwEiYKGOtVrHQVk7oAM8YIooIAZ4UoH4iFwP7W524AX8YyoMbwfOlf/gdSVk + KZBwQANwIAME1kz3tWAN9mARNmEVdmEZtmEd9mEhNmIldmIptmIt9mIxNmM1dmM5tmM99mNBNmRFdmRJ + tmRN9mRRNmVVdmVZtmVd9mVhNmZldmZptmZLgTKGJWeZQGeHa2d9tmeBVgn402Y39kg6QAIk6AFaoAWU + tmmZ9mmdNmqhdmqltmqp9mqt9gEeoALkptCI1pYAVonOdWzJtmzN9mzRNm3Vdm11gANyoB9rrj3SJwV2 + /1VKEeBu8TZv9XZv+bZv/fZv+ZYEEGCV7uc+OGBoYVZZWXWKLNNcHPdxITdyJXdyKbdyJRcP1nXQ6CYs + rWs253YFGMAEjJNKSbd0Tfd0UTd1FVUIDKBbGUAFIoAFYKBMv9YJ0oZVkwQPWKAfeBduevd3fTd4gXd4 + hbd4iZd3+6Ez2RUSA1bUHA4c3ycBSqBXRbV6rfd6sTd7tXd7uZd7Q1Vw48cEFGABWgAGxpVm1SYGXtUy + L2uC+PR93Td+4Xd+5bd+6Xd+WcNk1tXwAJPFMEAHZOD7XmEEDqCASeCAETiBFXiBGbiBHfiBG/gASMCA + J7iAS5LuImACSlRm0+Za9v+GxGgm20Q4hEnYZgINRglWpzRAAligAUR3FAt4twy4gGm4hm34hnE4h3V4 + h3F4gitYVAf4aeDEA1IYZSUqHxaENehzhJmYhJvYs9xGCSPRujSAArBmegn4LGdYgrn4gLtYgn24i8N4 + jMW4jMeYjNHYjGu4gmmYBFbJBSSAc1H26TwMs1Ytktoqj/V4j/m4j/04j7di+bpFboLUqerEUH+xpnx4 + kSG4kR35kSEZgbl4t4A4Y04AAtxMZtGq1ByFUufxiZ04lCn1yWpjI//ytGzAA0jzLLNYgbmYh2E5lmU5 + lsOYgr2YgDNmAQoFcTt2MD3skNIFmExvmKGvmIn5mI3/OZmReVQALo/1rwNSVZk6oCwJOIFnmJEjOZu1 + 2YG/2IuxmYBNoAFE52XhS4IssuU+ZXgUMZ3ZeUnS+aNGpjNnt4j9qIoXoAQGsJUlGAHAOI29GYwB2prJ + uJvTuJsD+pqxeYG/mJW7tQGW7WUlkiqMtD7pqp3QeUXvc5iwLZgyAQYKeZ46wAUcr41rOYz5+YtP2odT + mp9VeoZZGqBfuqXJmKVZ2qQL+KTXOKC9mJVNwAI22GS7D3j4Dvqeq4Q7gwxR7W+uMi+rgkE6gJdjJwNc + RZG9uabRWHApGKdn+pr7eYJT2mle2aBr+aC9GasF2qsBugBIIAJUgmUz4OQ4RTeL/9o1ipqYoEuj+ixM + 8Y+iJ+ibykoHLIAo5+6f1zimxZiN/VmNtfqVBXqfKZisAzqlK/iqzxIyKeCnR5ZIkxc755r+8pqUra52 + YFHJ9rIP7GAe5NiIqhjitNixXbmfAfqwYfufF/mldZqwJbmfJbumbVu3CRqsz/IYXOAF6FljySkehVmR + fnCLmNkmL2quCSczaWaC9m+ncuABNvSxyXqnzbqgZTq3xbqNFxqrGbu8bbm8GXmhd2tYZeB8QxZJygVd + hFkahwo7BYQWDwm6Ue+z+4BdqUunOsBQ8Vm2zbqMuZimfRuxDxubu7qqSVqnu/rAZ1uSJfuVn4YFPjpk + 9Q5Apv8xtKSvtInaXaINCFuu+Qbud4yHylJ7f17AdEj6gLUaxtVYwRFaxsm7wGuahr/6rLs7x7carcH4 + pas5ASLA+EyWZ+4RA1Vvye2a9HYJrzfaFadxZixIAoo7diSAAUR1oCV5shF8wa05rCfbyyMbzGF7x3+b + uwlczREgBYy8ZJNvSqLslzIzKzMKtEa84FDNGnMzKR6SpGAg4mR4zL9bzA1assuattc40Rnbph/cxiH8 + x2N6txogLFK2WFiD+erbIi8zvxtxmO4cQpdLs/IAOnUq0F1BvBO7sXHbi3McrLvbptGawsXcwbPasbeb + oPPZATL5ZCVks6O8IseQg1JPykP/a8Ryc/VIhVMkUKcmwARc4ax5O8i7etoL2sdpe5EfO6ax3ZYn29sR + PMz5+RV4XWWlWtbmD78Vqck08MldUcSe+1GUylOaHdAZzQAenKvLG6fRO73PGLj9uaS1vbZR+qDH+6a/ + uHtWwNKNWAIsKusuKjuHehatDcqjr4I2EzY2CwYw249gQMtxmYEn/Nsb+KRjutVtHIGtmscbnbKz3eBj + +AAq3dxfgII86P6cfOCSukWJh5lLPAhxs74wyHx1qsV7ddERftZj/aDRnNbD3NEtPOnD3dUbfIGxPdET + wAXenGTP4bnbHeMVMejbKdnP+agjHoSX4soZJ8AVwCzFGNFj/3uMDZuRv3ynwx3ctZvkcb2WTZ6rC3yC + d6sEGIAFOt5j//dVeYnv8ou58TLbQjjgNFAItY1SVpx5OAC7RXeLbzu8b32sOZ/Qx7rLZ7zgS3qhDVir + FWAFLntlkcSQFF+prc7lPvxBCwfUSXkegf5LRWPrw2m1BbCaNx/WwXzHGVzlq961c/zqlz7Rs/2189k1 + IwAG1P5ii2wC4lGjCy7UN7OL6M/nR3z1wl6u5Yt/nWqaiZKqvfuf+f2sAV7BS//zcV3VtV22+z698X0F + vJBl4VH+rg4IKpXZsEg8DmVF4xLJbCqdM6nwGK0ykdPl0DKbcGy8MblsPqPT6jW7fc7EHP8j0YFUJ+ER + dzu+ftj33R3o7QHqkRwe8uEtBjIyJtYd+inySdaNFJBEeGC4fYKGio6SlpqeorLZeMh4QRFlYVUpxc5S + zVxZwT5JReUa/cJqVXhJ4KQiJ7PpuCAYjFza+Qki+lULEloPXv5Je1vaTW4HZkv/3ZVbm0uPKDxsKMfL + z9PX2/PoxFhY8GbJCMcCOCyJP1wBuejCIozWFn9GplDY4ekexVAaZqDQA00dummCsHVr1C3ko0J9CC2y + hpIRIHUlG40YQSKBChhiKuLMqXNnKQ0vYvwTCEXhL2BWZvEqSjBJwoS1gGWBJQMGPJ5WyWDw8GBBgpiO + pon8CM5SJW3/2qp5M/ntLDWzZP1AU6CiQo6rdu/ivYchxwsKT4X223ULYdFhWhjKunV0YRVcEjhkyMsz + wwsIJzSGVHSOLbiRljibBb1W9Nk8IzcjWFBBx0TJrl/DdmODw4QhDQ8bhYqL8dHcDnf7+m0LaYV/UWfw + m7DjRuyccFKYOGDAwGbSna+3xa6d43bs5yzNkanARYfm5s+bz+CBAvJ9uJRcWQqfuEGExIvQErJ0v5D8 + 9BnmEhQxU8jwwjHoUaQBBSmckEAgB2z0nXUTdkchhQ9+Z8ICLkjQGoIfgrgTDjtM4JdhWxwxhYoP2cai + Fi+2mOJDKtJo2EEyyjCBBxt4GKI8OLzA/0ID0YkgAnXQPIJANUrqoSQipj25pJRN5gElk086mQiWWyr5 + BzQxGUkCAxFU4AFzPqKZZj03cPBCbcixsKIT+j1B0GJMDWdnfozRqZ9BQtXoXgUxvNCBBmra04EMDZRQ + 5JeeSXhadeZIuk51kl6KaaYeeSnCCCe4MEFViJJaKio4eKCPoLc95ItTiSE2lGHGBRTfnwKmyIIFMniQ + w02myrNBDBGgoIAJCZRgR0zLMtuss89CG6200kJ4RwkJKKDAAi0YA6y334KCQwcwxBCDX43RaFuNKK7b + brvqyumuvMhJRYG9MezAI7jy3NBBDCxEsMAJJRwgQgEFGGlkAQYozP+www03vDDED1MssQELWxxxwg8b + vPBMDKwQAQuPnbmvySdjhQMHO0gAFDG67qMrzPvQLLMFM9dMc8w625wzzjvfDHTMuuIyAQwe6IDDrygn + k0EHFLSQggMDI1C11SVcbbXWWmPN9dZfe9311mJ//XHILEzAGtNro2yDyiybm998fc43t37+2V13cXvT + DZ/ffPcXgwRIK822PG57AAN7LDzQOOONP/B45JMzXjnklkOeeeaYX0655p2z0ELkFVAAQ9KGo26yDRps + kAMHHeygQwezdyC7DrHTnnvtscs+++29+6477L3bjrvwtOO+w+wcbKDB0qnPgwEGNkzPgxjUXz//vfbY + V8/99daD/z324VvfPQ/Voy+G9D1C377778Mfv/zz01+//ffjn7/++/Pfv///AzCAAhwgAQtowAMiMIEK + XCADG+jAB0IwghKcIAUraMELYjCDGtwgBzvowQ+CMIQiHCEJS2jCE6IwhSpcIQtb6MIXwjCGMpwhDWto + wxviMIc63CEPbbABDshuBy+QQKE6wIEclIyHFcFABjKgARz8MAc40MANbsA+Je6PLxWAgAsi0AAUoGAB + KXABBCwAhiRicR4ZaJMESmQbCsQABhLYga/SqL8MjCgGD/giCk6ggKqVQAFhVAEEZPCYyNhRGRnIwbhs + EzoIQKAF7hGcDpyX/0j6OY0CD3BBAxzAAGMdqwSiNEG2GLAAFbjgATLowPMuKQoNwE0JN2tcC2p5OX6U + zgMcOJQr3ecTC6zgWMhKADFNcKxjCtMEJSDlCh7wgiv2kg0bkMAMaGnLWl5TdNh8gCTLpK9org0DQIKa + A0xwNVESM53pFGXXSKAhCMRgVOBcwxonUE0yQrIFkcycNmvJxUiyYCr5auU8TeW0CkTAASgQ5rWIucwE + GNOYEF0nskipAAdQ4EAFRQMGdECBx12TmyIV3Uj1acvIEQFfvNyoqTTgAQuogGroTOYx01lTiiZADyWI + AAxWytIx7CUGLSCj6CSnOZJCjqT+jOSudgTNn/+exwYdmIAFUrCCBqFTnTcVpk0hKlFkfSwFE0DkTzGw + g48OdZ/aHGlS2VpSk7JgUEjzKVSjuoOqLrSrEw0lMvfa1WM+FFkniIAO6ooDqEGAlrQ0aui4CdLPHfUB + X9gBXev6mjVKQEgNQsRXayrRZO5VmVuVKAJKsIAJoBGcHbWAC1Kp1MW2gHFFFSls2So6LrZgBhR4ARKf + atmddJQCEFABChigTK36FbTJ9WpylSlKBrTgBWSd5wZeYIF8cnOttI3tdh272MhxF6leyJGhfosX9cxA + BX9EgDqLudy+gtazE11nCU7gAAvsYKM++ahaJcdd7yrWu/9F6lu5yIKIVNb/vBTBACw1qQIGJKu0w1Qu + X+cLWAovF6InUMEENupR2SJVm7J9LHhBKlvwCpibXHSBJCmJA98qOBkY4AAFXLCCTzq0mBGlKXMZ+ln5 + 7vWh18LaCSxA0ES+tL+05eeJw2tUACt2rUXdRwVgUN4Y02MvL5gBg7A208DaFMzFXKZyLRxYZCrzAAlo + QYLtiAEYPCACIa1tUp/s2PDeecT8jCRA8bWBI2OZFBjYAAwskFA/ZnWiD5UvfOPbYzIz16Z6SIALODDP + G0xgk1L+b57v3GkAh7jJ1txncl6wgekGuhQcGNYCQtlVSDuUq4rmajIX3eMwM9SdnAC0EnGgRxY3LrEi + /2byd9vqXT3X+bXZjW0F0pbaVLuBTZklljIlbGutXtirW32ve4FcbRPw9NlY3IsmE4tiT8cWz7YdsZRH + 6t8oQzKSX+gVqqG9hg1MoAXEzZarHS3a0Mr6pu61cLcJjjUTNGACGr2kDTw6VKVqN911LrZS9dzYftrW + mo6zAAUkoDZ7qyED+YAAV0jAzogSnNu3zvZNbe1ZwCIA4TGoSy+dJoMH7DPjxBYxz40a8e+GOKn6TOUM + TFdvkN/gBVtswAoUMMy/+vXMBKe1tv/62fbW9OAqoADNXdmvm7v24rV1MrHdLWA9v1bi4S2qbpXzYpCP + AQcwcAGEr4Xy9hb86u+99v/dr/5Zl2s9ntG0Oc7VzWnDh+6xJk7xdpFt+GBLcgJ1TLU410PyQzT0xygX + eEU7L9q+I5fCkK51zBvQ02jO5tdCj/KJl+zuiC8eyrE/6tAhMAOPvz3GqELovhPt14J7fsc/Dj1ER1/R + vuL64CmQgLiVWIMc/EutAZY4qBM/ubN3F8/DbvfaaxknOOYLxr0cNJybPmTk6tWmoP+9t38Pa1pfmwQK + iIBEwKmBTAOb8RRHO/Yr7riJ05b1BdioiU4FHBJU3YAOFFoKLIACiJKEvRyaSZTUsZ/A/RtNDR+PjRkC + KEALyJMrZQAMDFWK9dPiDdjE+R/3tR71bV9SYdcMEAr/BzSfHd2ABOCVsaBf561ThfndwFEd8lXYwI1Z + rR0LAjCABcwgFkmApu3f9LUe0M0e2WGfYvFfuzWObu0ION1ADmTa1DhI5r1crGFYcwHcEFpYD/ZYthXT + 1vEaFu1ABRDYzzXW2Snb9gmg2UUZxZ3bSP1TQJlaG97QDXjAFinUCTiXjhXfMAWWkAEZ8PlYclFg1lEd + sgSSA7SAB2zUNFVA6KQdis2hk0khZBEY6x3bsKGgP8XWeElAByzcDrkUCziAAzbUGRLfIv5gZ62cBfpb + hiViCTCAC8zcRjUcVcFeHM4eCeZZxXlf/10Oz3UXWyUWr+SA+LmQOD3NA8RUhGWe/9MxYhhuniN249Rp + oMr9GzuhwAxwADUqUb/MgJQ9lvaRYv/FHrJR4aeF2pJBEhkF1OBMXg1lwA7IQASsQLFgnRDGGt4VJKPd + 2kKemUIWnzE11DJxgjpikbC41eE9jgCa4uGR4DuaIBXOFgn6U+TsA6+0IgzxRXqZk7WZGWDlXdU95NTJ + ZAS2XMBFGjqdQAPMwEnOU1a0wja5VcadoPaRGJ4lXrtZH/dB1rJBQARAQAXwFiCW0C9BgCflFDotGoUx + mtQ5Wspxng8iYkza2sE1wGr81g0AZAs45VpdnIm547mFIv9pzidaHFFqXz4GlI78mQthGrHgoMu95C72 + 4AR2lv9C7phMet58adUCWEBhmVcNsgCLzVns/dccFtvrGZszTmHQgZqxOU7RhQEL0VgEDIyXGR8uql+Q + GWaksdzv0aJ8RWQoLRMK6KRjKpgg6kPhrZszhhri0RnZqRsUchoyZlckSRIFeECbiRAHwBRB+h62pWE4 + CmGZhSEZQiSQGR87JcAJpEBGpVrq4ZxxnlQcwuW70WP1DRi7DeCnNZ7sWcDpndAGyMACnNzKpVxiah4i + 8pXe9RVgriZX2Z0CnMACRADX2dswzgALgFgnJmWTVaFG+twANlZbduRwitSK4ZdUZhAHVEAK/NFMDWZo + saasvZfoYeB8gdkkUiI7ncAKPOX/DvBkjA3auNxcvG3TCbZnKGKmHf6c49ThO27X0D1ARBxdB2WADDwY + iYqoYJIhJAKh3mEbfwZfMuXkA8BAjH5nDgyiPkmfE0IZetJjesKWW9IlHqYbiQVUeYyQDlhGDrqmXrUf + LvZgJC6kGALWyQ1oAxTSlcFdGQwaifwD4+AWKLaVmNajHT5jUWHk55jiRVppkWoQDkxAA1wlc4mZ5wGm + axIm1I2WV5IZaGENImhLC6RNBlBkoGmAAlbAJknmAA4lmYoU5xjqMxbqHBZlHsrANIJQDT4ACjxdWHob + LrrcBYIlt0Hap5YZpDGACjhTEvYpGUzTP2RfiXHXMcKjoZ7p//9lK5OJaT9FkgF2XQcxp3p9Gaj+oHt9 + KvChK3xF3eZ9FYri5Ia8Zwc467OSgQZwQKqsKjYtI1HWlgk6XoRqV6cpXraWIK9AqgW9AGmeqIjGpDeq + 5jeG6JIGJiViywq0AFVoqIzdQOvgQOE8UAbcgMieajLMhj2JnetJIfUBXcuCYsA2oas2jhl9oAZNwAr8 + KtV1I6PtYrddG64VZHuNkgmATApYgAQoZ/RoQA4IEQxMgNHsAAfgQML+DwbcAA4wkgd4wOxIEdUeDl/E + wMtkF2a6ntlxZLUaI5Rha7Itm1kaaQWgQFY1mvC1q35y21b+2/HpmGx62YZQACvmxAYAqv8FhKcLjBFR + ecFu5YDX2o+4tNG5TIF7yAAFGI0u1SsyiBOJrCqfySGi1qo8ditl+uj1KZXtqSkH4YAFMMBMpN+l0mTF + Yliywl+/GZMgAWPN2gMXsoDULAAYMUBx/S4YocAKNEAL/O3Gxk+0smoEpEAEOG/zOq8+xoAHYOk8JCAM + bCKIJWpS2mOEeuZbIur2iY4LWIAHIG8DcUALXEbMAdy5WuDdvuZBetYyCZkoCVIDuMDt4S49aICitEAD + CAwpCbCxEDC2LKvt/SH/iAsMtKMXNYAKqMADSzAENwD+7spjnK8pZIDgSgB74FyrfmlwvqrZ3qHaot0n + 6tPIXK4DmZX/ZZTWV74r+znidKaoJJZhqCIACsBTBzBuMnBAQKpA7xbXCTAAAxBxERuxERNxGDlAAzyA + BPQw9DyNBejT86ZA814x82ox9CIuVeyEyNnTP4XURjqetlrO2Xrkl04fBLDAlXIQZbhwVupi7PJYBn6j + dPaihoEMt4TrgulAh/rRCRzx7xZxHwHvCRyyIA9odEUx28wY1FwxFlux81KyJF9xBTuxF+uEyGGvzPgf + o66gZXpu652xqG0aG2uyBtWgC3yoTebtw+6gpuogmvkgaXEWA6QA2vApTnAoA2YLEQMzEguzMANzKTEr + 0tZPR/1aCjRAFmtxJbdWJTMvM6MSCwje/06kaqpU0xgfpX95ZLfuKK1SqIqNzDdlEBxfxqINaxq2b8Eh + q6aC2fnNZgTIQGiKCAV4EvAmMTALsiEjchLvcxEjcnTVzw93ESUjtCR3kSVvMRanAARMQNKuib9s8z2a + bQjbmQAuHrt5MyS18f5SEAZ0QBzbJKfKcHz1rKyxk92BjO1JAEjbgwbMnSH28zD7LkAfMSIncrbcl23C + j7D8bzNvseF20UIvNPMedSVHMAuYiVUsUuIQw7LZkoOSboOq3ecGYDwO1dFW7wTpwAOcgMlNZyNeWFnD + 735OICXm5Ax0wKlZBaZh4yct8T4fskADrz4TsnEhcgq47fsIS2RWMP/0Hu5Bj9EzS3JDe1EKtABUZjAy + bHCqUPEYu6z3oqA3U6vajiTzdVDqMoCEHR+dzjBZ17INm8CA8vXpWkUHtEDvArRdI/E/67QRG7Js0zUD + JFwjf0uQTHLzFnX0IrVhbzFiO2Wu3gUshS3hjq1vGuyEmrG/Njctka/5dhAGyEDc6u2cXifFqt+2gSrW + JABtGi/1FjcFPNgR9xESF1d6/3Mhs/cwC7S2WEAfo879JXZCP+9933dhC3Z+T/MDdMJduA2NsoAYp2Ch + wpYVFrh2XVxuofYGTYADBK03vmvPTpjrqnVZLgdeJB0LXFVOq3dt0zZtI/KIH7IgtUD9tU8vN8D/8xp1 + BBB1i+O3YLf4FRuvPd8FqkANUbkVJ1ZfM8IsR9pWPX/QDrhAXqUoLxamat7nSm8nChDSKuH2PHRAhzag + gB5yeqc3ere372b5iAtoBAQj9AjiDESAChS2iyN0mrO4i+v3QVdy8+qvZDRYF/BrJ5IUVYMzCY/te3Y1 + BW0AIOfUWdMaD95krYkSImwY2uiAqeYFHASMEtv1EAu0a8P2EF/5e+ckC0gX9NDG7kLvmhM1mr+4mh+0 + 4QZ3GUl3XlijBLRCU0pm0PFoZnoiqMHV30Z5A/0jMDlITN6n36Hm/L7rWu/ArdPDVxeLeec1IXP5lmt5 + svcREYdMBcA0uGQA/zXFmTNH85n/tpuPUZvvt0MDY5/rxIhQABUHqa3qYWWm3QrWUpmIOwXVIKXOlBhS + 7M8quZeV9goYbQws+mXBAGlaeWuPODFb+mtb+hLD9u86wAPI9+E4UQ780BFN0Q1Qzz1I6iY585r7Noy7 + eW/3tn43M1s39prcTm0QrkmVFLFR9f9lX2LFQDouZ5tGoGJK4N6K6ANerJXauGSoBws8mIASfJbPtrP/ + s9AT8iCjAHnYwxrtgOJUk2PpFgxE7ci7wZ9H87ZTMlEXNmGH+m93O7ev+AO8fHMM2gvIwCMpGQtmtWZ+ + Ije95wpTkA38u3Oa6H2mXzEJKCrNgAcQuz3owP8MADCyr3eIU/psS/qkhzgRN0B+qZGWenAKBDEYLYAD + KDbH8Vbfr0EOAMxhdz2ag/rHXz23R+8VJxZ8xgYswUArJHexueX1pbtkjT0JSaoLlOboPekQItNKK4CL + 7pY5vwYGLGxdi3iW/25s33WkK7t7G6IKYGI8NFwnD9UDr0DvLsACrEAE62OV7TwycMAeWTLXbzw0+7Zv + e3tw52+D/z4OKODZm5Sdq2cLclNrkaqulpCvlZNKD2Yd7+DuWykQ4HhDYtF4RCaVSx5O5jApGCcGijG1 + XlEnVFZ75Wa54O2WYTI5Xky2MaOjRBwOlWruWK3wdnqD7qLoyGgj5NFpaWj/iIhIWYxwcWF0SYmchFxs + jGx05Gz0TGmRuCkkLU3C2JCQsXhoaWltbWF5oK2dlXWNfYCAmNHBMA0WHiYuFs6RaVhQSCgpSYCONkmY + Nnl2dk44WWhoodjRMBZHupFoQdH+GtNaZy+ruoIn8zpTUPEY59nwqHBZ6XKw4I4dPXjwLOiyAoIMDxvy + cYBAB1MkSY8sXlx06VElSp4YYUqhqIKgfCV5YMChQwKFGbFcvYLZisUrmS0gvGJhQcaOQSZ9/gRKTMOE + c81KILhWYlqzpdiaKXDQAgYHG0HFeWDRAIUCKlTiVVlnpYzYr1OwdAGD5cSJBjvE2eggg0UEgnj0FLwz + /yePwRWKHsj4Ja7DgwYpPFaqWJHSx8UdL02StClkBBYxOFgVl4GDhAoQIPGC6erWS5ueW8yYWhXzatat + y7VwsEVBFDTNoFVTkLuKihkvwrUWpiEZQipWuo6NN0YMWORewsaL0EEcBxl08+C1w0fFCu15VyzgDuiy + MQ4sJHO6SKnSesSIHTVmnIkFjJ7Ag+V4MWMWC/60QsOyZYYKpgLGPgMPFOeGHWKYAQIVFpiCmRJIeCYK + BlZIgYUKJuBgFARJ4aAFCMsiS4wunEMLHnq+SOsKhXQwJgcYIspDoLrm2I4P7vS64zoHIIDBoWJy6EcT + SSzB6KNO0FsMEyU7gYACIf8/LESDDjyAIYYK9PPvJlpymiEGGDzoQAgqz0SzEBw66CeF7U5wxoQqHMhw + Ah3qS5OJoVJYKx4zujoruRSZ8xMLLYwrToUHcihmAxiy2isvHPHaEa899OrLAhh+G0aDGFgwkiJNOLrE + MVI1anIiIzP0wMM8mcBAgxw8mECGGVi5iQUBKYChzAJfBTbYITDYLAYZKnggElksmGGCHaYUFgkNJHhg + BbOUqwItFFEUNFDksFghAhk4DcaGFx5IwSC9csRxj+5y5IPHCCx44ddgMnihM0Y8QVLUiTDS6MiM1FMs + hYXujFYJlDbo4IUXYJgABgk82EGHDVxNOGM0bcjgBg3/NuCAgw02wOGGDOzVmIgdWFBhi+LKIlGeQAtF + qx1EGWiAhRfwNGWDCtItiLvs1qWD6B2JVjeFcYvhIIYHlEz1EVP/TSxVgjEyDIIHLEv5FAxssMFksFHu + umyzE85ABhVkdiesdcJA0WZBs1AAhQgoGG+YHaoFT9J2dRy66Hb5uu4Bt4i5wYMZQmqS1CT9FZWiq/1N + VeezL8c8c7N1eGAZrwwly1AyvmoOLBWz2MIEFCB4QTVhcJggAoAIypG7u+owmo7bh0YoAgnIva86FZ6M + WrFRqdYIMsfeUyFK4DWHPnrpW4M9Aga4UrHbErPHdu7RDa17BmhNyWCHChrYS+i//+kAvDv2BzooXMBc + v3cCCBRZLPmrL/LX+IzciwwlZgCO6RXQgAdMkAceoII+aU8d3wuDWZhjIuNUEAUNmADPSrGBCZhHXT2K + 17ridTQ9BM4gGZKAmYSBgZWt6niSg2FF3CO5TkCCIorwRmAQuEMe9hAJOrBAy8zyLS5gq2aDquBXnhMh + FKSgAjAiRgdmQBd1watd6hPh+i51HZHkTRiOAlVh1pOYUVnieE0imBk7YZgIRGl8PoRjHKGHAQlYzysv + YxG3ZLZEI5LhBFBhAU+KcS4/VHEgO4qXCW3HLsHpoRv4IIYNmkaYTThiVPvLSCYTI7CBQWZfLJCOHEU5 + yrPlYP8GUOiTF94xhgjKo5XKSWKgqJCCGGBMGBJwwR7yoJ2jHZJ270uk7QbSgjUUwwYesMC+IpNJivgv + fxaZnNX21bxNkdKa1wwW7CCwAuz5aYl7FIsqlyNOQUEglMWYAPrg10t3DY6RJBxapCAgAXFsQAYtcFLA + 3tNM93TEIjA8oyYaAIEKCBKbB0WofTDwgha07HPdc8cXKvi2cHbLUCsAhAqJQYGWlRB3gvtopUKYSO8U + DaMwyAw/IGAYfj4TSY1pD9T656TJtAAwCcVpToEinNiQLondKwNEXTkP0VGhATcVRwy0UpDslDBogJsU + u0Q6wgWkYALjSMVcCiO1UiGJf1j/i2kzl7cJFzxAAhrUaVrVSgogXu97qDNR9gpFqNAJ6gRyakEHyCYM + paIAfiB9HzDX5766/AOD+bAnXSqZycU6BqZJ+hcNP3E3Rq3VspdlQg4o0IDZvOyOsTTD99RiIuWw8goq + kAFa+bpUHEFVpHz5ZaX+WqMGxCAfNqAWG9HImMegR6yWIJg/yRqBwlhgB7bEbHIt6yl/NJCVqHPH9rzF + IkJ5xa/ELElfL8VLkgaWsLqrQ6WaaNt86OCeLnTSPtXr0q9CEySGsekO6Kdc+uq0AxGBUCtVdBxXvmNF + z93jWjAqAy8aQ7uDOxrtXivM9jUyNrUtCQ7ytdLzPCa4NtQk/3osKdN8PkBK9QVxTm0wgbVFkL9+ood+ + i/itWHIhNyqoAAf2Ooy+MtWERftuIz/ayO9AuCSOIsxWOaxJNAKXVEVu7CICOeMQN9mHNgDiCv6YHAdG + l2Zsm1m2/miCCEAyu1oxyAh/ySNd0i6E4MXDBclbEg4EUYxHEtUz/znn/RlpmYYBxQQq62Q+x1GzLrge + oEY3USyLDnTyMI6gHvBGA7MWmO5TH+7ct10dPXjN+cBBDBhTwwxHpplE9up5MNEAF8xAAozuc6qllwH7 + xaabRYXuO2YGN9GykgrhisF8kwrmwSGNhOu6Szvh2eNL52MHFoCAMhFT5H46rn/CjU8bZ//gZVVXW3rl + WcDb4NEOAMtyUNwmbd0AAUWT1Li1OG6nYLMTuHfVSAVX9QkOJDADTx6mamW890deqm+PDFQGGrV2wM+G + 2xS4VcspHtSh5tq957JSASswrq537VcEr7ukIMQ4Inu0gHcDZQMxQEQmvjrDDf9Pk8r7lyeKeziBt7xr + GZAiA7mCcP2uktD9rSsY/qiCGKi20SiwMcbd1dSQfpS7tC12SfYm5E2qF3mPtVqpRp3nDTDZ5Vc/E3Ui + kO2HngjRfZQoUe0aWhQsIK9B0S5Thb1jLApOxyNUc1A2QAEKp5Grv43hnNFL5EVAgAUpxHrggSUBCCCE + dDAztKHkBtf/7a3lBAqZwPPycWAcd/dSsBUpFnUUd6DgqwItYCMzI2vJ4jWuvamCxAzOKXjWI4ineATw + K7WVrWuhrh2FkkIKKLDnn5g7sMLUeKTRDViTcn6nEtBqkTfivzhjmIxyNtJA6dN66itUgSiQUx6hy726 + pkjWEwTLNlrAcqCkHbCK3PHlL090wybdJMi4XyYsHFP1vhCav1UMnWTA++r3/ycYkKIUMANCo6hDGy2L + IpRrOa2lsQrfCylg2zFGQrME0wvjA4obgIGn8QiRYxIAAiv+SSNNYCMWmACA878TFAcnSBcJOh2i2hZw + 2jaysDUUUBRqKz9eAymLEzOQEr7ha7/V/zCvZPEIGVKPGOoX5UuPDWuEFrCAs0LBJxQMETmO79Mv8FO8 + FKk5tXg4qTBBn3BApPEOdmMnHEOkH8QMBZEBF9gqZpMhqnmm4NI7+HgEAoPCOhQGVkuBV6uyK3Sg7fMj + ukmDD1sNyvNBdqm0YfsluPMxzJgWNRQyAOKn+8O75Xss0ksBC/AAibPDTZSWF2ABKMAe6zq8I4IrmfEv + 2ks0Kuiy1vjCLCIpSRMsdNu8RcSMNoMaquEqVdmwT0O9lAsJCLAMTeTEYeSBY1OGPjmxIpIgJGo4GVyO + tPArFuA/tAMzj2q7RVokSaGUdrNAq9AACmiBUEmPsNqn/DG9SlyERP9wARKcRmIcRhvoqxUJu4TrNumK + q2s5geapJVbEQRMyxOGDl6ERyAqkRavAAA+QAQ2sJKg7nvZirGcDrkbwOxt0x2HMARYILUBRRopqpXt8 + q3mYMhfQM+BwQKjSMRByrWB6kG60isRZnDd7DMqZKXNsj+VJQlKjAMmrSCjEgRlhQbkiRbbBFlgatLQw + gQWQRvswP+04s1f8K5UkCJa0ikxzgeEZwpRbtlDLOzoTq0ZQPZ/byf7DFwtwgCnTyBjEMlkTKqAylHcT + xt5zNLYLr6PztcpTRPcLioPUwIKxP9PrF4eMun3ZGh14y7BsvQ6wAPSRoALklj5SpQj6qbXguAf/WD3W + oLwdNKmBbLD10x2ptArNEkJ+eZKSgwz8e6y8Y6N1nABUM0zqg4GC67pZkzWxSMZvgbW1UBQYQC7M8L3K + I5oRyiJXbCTPDAq4SEjGoSn/Yb4Mi8SG/Ajjas0nFI4VSIc8ss4ERDhuKUWuuBvWpEaKy8xeWyR/xCJ2 + MkP7SBytukXomzPScza/ZIxukIDCjM6WwwAgWgAT8CxYQzybS7jQ2UgqgACKtMy4NDpECpwyTD+LS7OC + bA0i0TdcVE50RELlCwlA8M76bDlt8pyipL0VA7AVUcuaGaKj0knerEa3K0+osqIt4kYHZY0MQD6QSK8Q + FJiW6i3kiY9eaBUN/6U+xNQKQRsi/tq+xqSgn5ICFYBOBLnMMXuftmNR+MkRhIBR1sgBp1EmfhErULs7 + TgMgyfC7kfRRwZPRiEg0PqSHuKI1j2TBE0gAFHiAnfmQ3iTPiguzjEtQ4sQM41RD+Ws+/Cs50StHlHMB + m6rMMW25G4iBFMgvb1vMJPLDsCuqKcBNBmTSaiw69dM4f9TMzqzSGM1AIUNCr+IqyfAkM+JFSYAAeqFP + RHUyHKgAByg0b5q9AgTRUgyLsnMBeqISOmVKLeqRSfnN4fxU1kBMfVo+TlKj9lxWOawkkWxVVw0xHLCA + bKu90bq9/QodPdI2brAAcrtU8HQtXQIv9elBNP9rULxsjY+zgEmgSYDBpPrTRamJzwjYR2ltuQ14gDMA + SpixOSwjSsh0PAfQGbAcxLh0u3d5ShYVvvNEECgDOcbJyi6NrP3BpKssDArYTXztsxxogbvatmsFrcMD + O1OshxSQ0zO5zKjymzHsNeJzWARhocQcntGMGiQU1DdUngaAsRPl2Cbz2D9aUyw8otExsYlClK7YhqRE + Ezp1UQSNqmykwFlUV+AQjj6lUeWLKYa8vyR0E0v9WVXTV7dSUwC1x0LJ1iGqKgow2AL1K48CyDCUxd/L + 02JtjYVq11tsQw0jx0B1L0XQ2LC1tg1gAWu9TrG7QiJtG7OoKtXLk5XVRif/lS2kMbp0zRMOalfd8qRO + Qsd9OkLgkoR7FdxU04AZWJs/eUzv60hU9B7jgArjalu3DboWzUyFLUMf1FPgkCSQ26qa7FuabLZNo4S/ + i9bRtawMWNR/4E/bY0Yj9aYpaADdfJWlNJq6IKlsnLTayV3dVaDCGC7IEj1M6qd9KdQK8ACrM97kOqYF + Cq0PjaWIEjsAnQKzA9emNdC4fa0QeirfjNkzgdDvBV6Y+jRSBV2D8bACS1+gpQBGDUXR2VZws6jnwhDR + TRPIrV4GzV8epFpgkVELAD3NPTmTe9dclBxFoBefTWD19YAW4KbPgSDoAjsLAoOqGolgKcm4DUMG9aV4 + /9pe+3CUzDUerm1IrWSMKJGxFE41WJWy43gOSIVB2duGOC1et82LRJTbHaydgbTcYKGO+9FFkpPQ5oOm + FHgA6UXiPsMApWoRozVSyFSieECtDD2QLwScbETJO+6u/kUTDESXTsNKELS/9AqkM1a1DmCZRl2i2Xyg + GCyOFXgAArXft01YwBpPX5KUuq3aD6GOcGQ+mSQjJpGP1STkVEvPsiwOt+k+hquZE4gKUYiWJlW/oQvP + BBXD7+g4YTHODx7H0XMclyqMrUHgUQ6xcgA0rmBM+B2tROMKWkLhOUXYOk6/4OuOTd1iYckArCCuq9zA + TRNeT1CBFPAF9BXm5PpGf/9IxeXgSCrLFgypgHZ83BSNUozDYngq1x52vUfxjH2BD21eNidZ1Uwc52qT + twUS2gYqESyk1IFtAQ7RmBs2Sf1lNxFKUI6Dt4TRAPP54DXk5n7Gs8Iw1NgN6OSS0XNQ57QNPy1YAJFs + ZpXFwZNEM9pNsJHSC5zJZDQ5yLzd2yx9D956InEOafrSgAwkrn9wvKI2ai4QCNWU40hWu+26IjHjrmGt + 5ozRAA9giWTRZzzT6tArqwqIgQ6Y4p/GLAzAj+rgptxAa9pAg9xoXAmgirIhRFh8rSyy43NrKns+ExtY + kwlAtpBQAZ5NhL8GbFAwtQ4R66uDuXtCnxqpkQUAj/D/MN+Vfmege9nu8sd1ymO8RpM3UIVW4AXPAO2y + kgUKeIEuPGxr0+sOyJJVsAALyInWrgAKmAAPyAGQnuwwqx3dqV4yMzOnnuquQYkc2IGHiYHiNu4YkIAX + 6IAc2NjTtk8cyIEc0IHpjm4csG0b7senfFIthtJp1mxgwYAMwIGRGRkN0IDrdu6AuwAMYO8amJ4b3t+m + xl6hu0sDuoALSO/8hktJ1kEdbKcxq1zttVv9JvCEakUymyq/2aKoisoBL/AHtyaOcmx3Ir7d7sFrvCAK + gPAN1ymOupDq7aVe+lUp5RE9yHAOR3GEqrEIPD90xQ6ppSoHT/EZNyAYiIASyh1s/3zqYT2zo3EBlKLx + II8jwqs0SpPbBN9G2fpr7BLyJuehlaEiHJfbFv9vdGMqF7CAQ3XyLYceDgDHFLgOoovqqRU6k+qLrXFn + Lldzs7mB/Ng6tYvSqHbqSrkOcPYAyV7zPA+WHIgdx5atX+NMdoKq3hFTPTd0szkmF5hwdzJXk3zau16A + AQ3rQ6d0BMmBIAo2MKzcwUrQvWDaSgd1tMmtgJDyIr9derYLOinjSQ/1Vl+NpkGESMlgqX4nPGiAA3b1 + XAcWuKCAXIoUzP7z3r4LjKIAHdL1Y8/rANyO9MHgyyOhXXKi+kX2aT+QxPk8N0n1YJNLvpCIFqiAlKX2 + cD8Qzuieon947P8miBpJiHmBAcIU93d3PcVhVIEwT0Vi5x6F93w3kBvoAAqYiUjwA3XfC5YabYPS94O3 + WpWogDD6jvn9Aw2RAF9B+Im3DxzYAVVggWT75jZiARmYbTyn+JB/ixuAbh3ogA7YgQ7QAQ6wblYX+ZeH + +ZiX+Zmn+Zq3+ZvH+ZzX+Z3n+Z73+Z8H+qAX+qEn+qI3+qNH+qRX+qVn+qZ3+qeH+qiX+qmn+qq3+qvH + +qzX+q3n+q73+q8H+7AX+7En+7I3+7NH+7RX+7Vn+7Z3+7eH+7iX+7mn+7q3+7vH+7zX+70f+iAAADs= + + AAABAAYAAAAAAAEAIAA0OAAAZgAAAICAAAABACAAKAgBAJo4AABAQAAAAQAgAChCAADCQAEAMDAAAAEA diff --git a/UE4localizationsTool/Forms/FrmState.Designer.cs b/UE4localizationsTool/Forms/FrmState.Designer.cs index fbe68af..662bb40 100644 --- a/UE4localizationsTool/Forms/FrmState.Designer.cs +++ b/UE4localizationsTool/Forms/FrmState.Designer.cs @@ -7,18 +7,6 @@ partial class FrmState /// 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 @@ -28,11 +16,9 @@ protected override void Dispose(bool disposing) /// private void InitializeComponent() { - this.components = new System.ComponentModel.Container(); System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FrmState)); this.label1 = new System.Windows.Forms.Label(); this.label2 = new System.Windows.Forms.Label(); - this.timer1 = new System.Windows.Forms.Timer(this.components); this.SuspendLayout(); // // label1 @@ -55,13 +41,9 @@ private void InitializeComponent() this.label2.Location = new System.Drawing.Point(0, 73); this.label2.Name = "label2"; this.label2.Padding = new System.Windows.Forms.Padding(5, 0, 5, 30); - this.label2.Size = new System.Drawing.Size(10, 43); + this.label2.Size = new System.Drawing.Size(38, 43); this.label2.TabIndex = 1; - // - // timer1 - // - this.timer1.Interval = 1000; - this.timer1.Tick += new System.EventHandler(this.timer1_Tick); + this.label2.Text = "-------"; // // FrmState // @@ -69,7 +51,7 @@ private void InitializeComponent() this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.AutoSize = true; this.BackgroundImageLayout = System.Windows.Forms.ImageLayout.None; - this.ClientSize = new System.Drawing.Size(185, 61); + this.ClientSize = new System.Drawing.Size(165, 41); this.ControlBox = false; this.Controls.Add(this.label2); this.Controls.Add(this.label1); @@ -82,7 +64,6 @@ private void InitializeComponent() this.ShowInTaskbar = false; this.StartPosition = System.Windows.Forms.FormStartPosition.Manual; this.Text = "State"; - this.Load += new System.EventHandler(this.State_Load); this.ResumeLayout(false); this.PerformLayout(); @@ -92,6 +73,5 @@ private void InitializeComponent() private System.Windows.Forms.Label label1; private System.Windows.Forms.Label label2; - private System.Windows.Forms.Timer timer1; } } \ No newline at end of file diff --git a/UE4localizationsTool/Forms/FrmState.cs b/UE4localizationsTool/Forms/FrmState.cs index 1e0a861..6cd7b08 100644 --- a/UE4localizationsTool/Forms/FrmState.cs +++ b/UE4localizationsTool/Forms/FrmState.cs @@ -7,45 +7,52 @@ namespace UE4localizationsTool { public partial class FrmState : NForm { - - DateTime dateTime; + private readonly DateTime dateTime; + private readonly Timer timer1; public FrmState() { InitializeComponent(); - } - public FrmState(Form form, string Title, string state) - { dateTime = DateTime.Now; - InitializeComponent(); - label1.Text = state; - this.Text = Title; - this.Location = new Point(form.Location.X + (form.Width - this.Width) / 2, form.Location.Y + (form.Height - this.Height) / 2); + timer1 = new Timer { Interval = 1000 }; + timer1_Tick(null, null); + timer1.Tick += timer1_Tick; timer1.Start(); - } - public FrmState(string Title, string state) + public FrmState(Form form, string title, string state) : this() { - InitializeComponent(); label1.Text = state; - this.Text = Title; - timer1.Start(); - timer1_Tick(null, null); + Text = title; + Location = new Point(form.Location.X + (form.Width - Width) / 2, form.Location.Y + (form.Height - Height) / 2); } - - private void State_Load(object sender, EventArgs e) + public FrmState(string title, string state) : this() { - + label1.Text = state; + Text = title; } private void timer1_Tick(object sender, EventArgs e) { + TimeSpan dateElapsed = DateTime.Now - dateTime; + label2.Text = "Elapsed time: " + dateElapsed.ToString("hh':'mm':'ss"); + } - TimeSpan DateElapsed = DateTime.Now - dateTime; - - label2.Text = "Elapsed time:" + DateElapsed.ToString("hh':'mm':'ss"); + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + + if (disposing) + { + timer1.Stop(); + timer1.Dispose(); + } + base.Dispose(disposing); } + } } diff --git a/UE4localizationsTool/Forms/FrmState.resx b/UE4localizationsTool/Forms/FrmState.resx index 51b994e..e113997 100644 --- a/UE4localizationsTool/Forms/FrmState.resx +++ b/UE4localizationsTool/Forms/FrmState.resx @@ -117,9 +117,6 @@ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - 17, 17 - diff --git a/UE4localizationsTool/Helper/CSVFile.cs b/UE4localizationsTool/Helper/CSVFile.cs index 1e0d96d..0f1c4b1 100644 --- a/UE4localizationsTool/Helper/CSVFile.cs +++ b/UE4localizationsTool/Helper/CSVFile.cs @@ -1,4 +1,5 @@ using Microsoft.VisualBasic.FileIO; +using System.Collections.Generic; using System.IO; using System.Windows.Forms; @@ -11,7 +12,7 @@ public class CSVFile public char Delimiter { get; set; } = ','; public bool HasHeader { get; set; } = true; - public void Load(DataGridView dataGrid, string filePath) + public void Load(NDataGridView dataGrid, string filePath) { using (TextFieldParser parser = new TextFieldParser(filePath)) @@ -34,8 +35,10 @@ public void Load(DataGridView dataGrid, string filePath) } if (fields.Length >= 3 && !string.IsNullOrEmpty(fields[2])) - dataGrid.Rows[i].Cells["TextValue"].Value = fields[2]; - + { + + dataGrid.SetValue(dataGrid.Rows[i].Cells["Text value"], fields[2]); + } i++; } } @@ -48,13 +51,63 @@ public void Save(DataGridView dataGrid, string filePath) writer.WriteLine("Key,Source,Translation"); foreach (DataGridViewRow row in dataGrid.Rows) { - writer.WriteLine("\"" + FixedString(row.Cells["TextName"].Value) + "\"" + Delimiter.ToString() + "\"" + FixedString(row.Cells["TextValue"].Value) + "\"" + Delimiter.ToString() + "\"" + "\""); + writer.WriteLine("\"" + FixedString(row.Cells["Name"].Value) + "\"" + Delimiter.ToString() + "\"" + FixedString(row.Cells["Text value"].Value) + "\"" + Delimiter.ToString() + "\"" + "\""); } } } - private string FixedString(object str) + public void Load(List> Strings, string filePath) + { + using (TextFieldParser parser = new TextFieldParser(filePath)) + { + parser.TextFieldType = FieldType.Delimited; + parser.SetDelimiters(Delimiter.ToString()); + + int i = -1; + if (!HasHeader) i++; + + while (!parser.EndOfData) + { + + string[] fields = parser.ReadFields(); + + if (HasHeader && i == -1) + { + i++; + continue; + } + + if (fields.Length >= 3 && !string.IsNullOrEmpty(fields[2])) + { + Strings[i][1] = fields[2]; } + i++; + } + } + } + + public void Save(List> Strings,string filePath) + { + + using (var writer = new StreamWriter(filePath)) + { + writer.WriteLine("Key,Source,Translation"); + foreach (var row in Strings) + { + if (row[0] == "[~PATHFile~]") + { + writer.WriteLine("\"" + FixedString(row[1]) + "\""); + continue; + } + + writer.WriteLine("\"" + FixedString(row[0]) + "\"" + Delimiter.ToString() + "\"" + FixedString(row[1]) + "\"" + Delimiter.ToString() + "\"" + "\""); + } + } + + } + + public static string FixedString(object str,bool returnValue =true) { + if (returnValue ) return str.ToString(); return str.ToString().Replace("\"", "\"\""); } } diff --git a/UE4localizationsTool/Helper/MemoryList.cs b/UE4localizationsTool/Helper/MemoryList.cs index 023db4f..eccc09a 100644 --- a/UE4localizationsTool/Helper/MemoryList.cs +++ b/UE4localizationsTool/Helper/MemoryList.cs @@ -50,7 +50,6 @@ public int MemoryListPosition { get { - if (this.MemoryListIndex - 1 > MemoryListData.Count - 1) { @@ -189,7 +188,9 @@ public bool isEmpty() public void Clear() { + MemoryListData.Clear(); + MemoryListPosition = 0; } public void Add(object Value) @@ -309,7 +310,7 @@ public void Write(object Value, bool SavePosition = true, int SeekAndRead = -1, } } - void IDisposable.Dispose() { } + public void Dispose() { Clear(); @@ -566,6 +567,12 @@ public void DeleteBytes(int count, int SeekAndRead = -1) public void ReplaceBytes(int OldBytesLenght, byte[] NewBytes, bool SavePosition = true, int SeekAndRead = -1) { + if (OldBytesLenght== NewBytes.Length) + { + SetBytes(NewBytes, SavePosition, SeekAndRead); + return; + } + if (SeekAndRead != -1) { MemoryListData.RemoveRange(SeekAndRead, OldBytesLenght); diff --git a/UE4localizationsTool/Program.cs b/UE4localizationsTool/Program.cs index f981687..0565e8e 100644 --- a/UE4localizationsTool/Program.cs +++ b/UE4localizationsTool/Program.cs @@ -57,6 +57,11 @@ public static Args GetArgs(int Index, string[] args) case "-method2": args1 |= Args.method2; break; + + case "-c": + case "-csv": + args1 |= Args.CSV; + break; default: Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine("Invalid command: " + args[n]); @@ -80,6 +85,8 @@ public static void CheckArges(int Index, string[] args) case "-noname": case "-method2": case "-m2": + case "-c": + case "-csv": throw new Exception("Invalid number of arguments.\n\n" + commandlines); } } diff --git a/UE4localizationsTool/Properties/AssemblyInfo.cs b/UE4localizationsTool/Properties/AssemblyInfo.cs index 3e222ac..70aef6e 100644 --- a/UE4localizationsTool/Properties/AssemblyInfo.cs +++ b/UE4localizationsTool/Properties/AssemblyInfo.cs @@ -11,4 +11,4 @@ [assembly: AssemblyTrademark("amr shaheen")] [assembly: ComVisible(false)] [assembly: AssemblyVersion("1.0")] -[assembly: AssemblyFileVersion("2.3")] +[assembly: AssemblyFileVersion("2.4")] diff --git a/UE4localizationsTool/UE4localizationsTool.csproj b/UE4localizationsTool/UE4localizationsTool.csproj index 603d600..8601ae4 100644 --- a/UE4localizationsTool/UE4localizationsTool.csproj +++ b/UE4localizationsTool/UE4localizationsTool.csproj @@ -5,7 +5,7 @@ Debug AnyCPU {C8AA2127-04A4-400B-9CA3-1951639BB0A3} - WinExe + Exe UE4localizationsTool UE4localizationsTool v4.7.2 @@ -39,11 +39,12 @@ TRACE;DEBUG prompt 4 - false + true false MinimumRecommendedRules.ruleset false true + false AnyCPU @@ -82,14 +83,27 @@ + - Properties\app.manifest + true + + Component + Form + + Component + + + UserControl + + + SearchBox.cs + @@ -101,13 +115,15 @@ + + + - @@ -124,36 +140,39 @@ FrmFilter.cs - + Form - - FrmMain.cs + + FrmLocresEntryEditor.cs - + Form - - FrmState.cs + + FrmMain.cs + + SearchBox.cs + FrmAbout.cs FrmFilter.cs + + FrmLocresEntryEditor.cs + FrmMain.cs Designer - - FrmState.cs - ResXFileCodeGenerator Resources.Designer.cs @@ -197,8 +216,10 @@ + + \ No newline at end of file diff --git a/cso.dat b/cso.dat new file mode 100644 index 0000000..5ab5db0 --- /dev/null +++ b/cso.dat @@ -0,0 +1,75 @@ +V1 +2:Hash32Len13to24,q +2:s,R +2:len,o +2:a,qN +2:b,oJ +2:c,E +2:d,s +2:e,X +2:f,A +2:h,H +2:LocresNamespace,c +2:AddItemsToDataTable,l +2:dataGrid,lN +2:dataTable,b +2:names,p +2:table,a +2:locres,HK +2:LocresVersion,g +2:Legacy,gK +2:Compact,S +2:Optimized,e +2:Optimized_CityHash64_UTF16,D +2:MagicGUID,bJ +2:IsGood,u +2:get_u_,k +2:set_k_,P +2:Uexp,N +2:UassetData,sY +2:AssetParser,qX +2:s143077981,aW +2:t143077981,z +1:1,UE4localizationsTool,qX_,aW_,z_ +2:InitializeContextMenu,r +2:copyMenuItem,rH +2:pasteMenuItem,SJ +2:Redo,zK +2:data,A6 +2:temp,I +2:tempstyle,B +2:OnCellEndEdit,Q +2:PasteMenuItem_Click,P8 +2:sender,zU +2:str,rA +2:Filter,qL +2:filterForm,y +2:filteredData,PL +2:row,z9 +2:shouldShow,EW +2:OnRowPrePaint,cO +2:ShouldShowRow,w +2:filterValue,b6 +2:cellValue,T +2:AddItemsToDataGridView,h +2:i,cV +2:item,AU +2:rowIndex,XU +2:FindPrevious_Click,t +2:found,L +2:startColumn,h1 +2:colIndex,wW +2:cell,kI +2:InitializeComponent,sI +2:resources,P7 +2:OnRowsAdded,O +2:AddRow,t8 +2:gridView,zO +2:dt,f +2:RowName,IG +2:rowExists,v +2:.ctor,z4 +2:items,pM +2:OpenFile_Click,Q7 +2:ofd,m +2:mergeLocresFileToolStripMenuItem_Click,G