diff --git a/ADReplStatus.csproj b/ADReplStatus.csproj new file mode 100644 index 0000000..62cb523 --- /dev/null +++ b/ADReplStatus.csproj @@ -0,0 +1,112 @@ + + + + + Debug + AnyCPU + {AF7EE9DD-D7C5-409C-A1E9-78E1078F6A89} + WinExe + ADReplStatus + ADReplStatus + v4.8 + 512 + true + true + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + Forest.ico + + + + packages\ObjectListView.Official.2.9.1\lib\net20\ObjectListView.dll + + + + + + + + + + + + + + + + + Form + + + ADReplStatusForm.cs + + + Form + + + AlternateCredsForm.cs + + + + + Form + + + SetForestNameForm.cs + + + ADReplStatusForm.cs + + + AlternateCredsForm.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + + + SetForestNameForm.cs + + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + + + + + + + + \ No newline at end of file diff --git a/ADReplStatus.sln b/ADReplStatus.sln new file mode 100644 index 0000000..c3efe26 --- /dev/null +++ b/ADReplStatus.sln @@ -0,0 +1,25 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.4.33205.214 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ADReplStatus", "ADReplStatus.csproj", "{AF7EE9DD-D7C5-409C-A1E9-78E1078F6A89}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {AF7EE9DD-D7C5-409C-A1E9-78E1078F6A89}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {AF7EE9DD-D7C5-409C-A1E9-78E1078F6A89}.Debug|Any CPU.Build.0 = Debug|Any CPU + {AF7EE9DD-D7C5-409C-A1E9-78E1078F6A89}.Release|Any CPU.ActiveCfg = Release|Any CPU + {AF7EE9DD-D7C5-409C-A1E9-78E1078F6A89}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {07B32D0E-B7B7-49A4-8ED3-43C83A52FC2D} + EndGlobalSection +EndGlobal diff --git a/ADReplStatusForm.Designer.cs b/ADReplStatusForm.Designer.cs new file mode 100644 index 0000000..7e86025 --- /dev/null +++ b/ADReplStatusForm.Designer.cs @@ -0,0 +1,290 @@ +namespace ADReplStatus +{ + partial class ADReplStatusForm + { + /// + /// 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(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(ADReplStatusForm)); + this.RefreshButton = new System.Windows.Forms.Button(); + this.backgroundWorker1 = new System.ComponentModel.BackgroundWorker(); + this.toolTip1 = new System.Windows.Forms.ToolTip(this.components); + this.EnableLoggingButton = new System.Windows.Forms.Button(); + this.SetForestButton = new System.Windows.Forms.Button(); + this.ProgressPictureBox = new System.Windows.Forms.PictureBox(); + this.AlternateCredsButton = new System.Windows.Forms.Button(); + this.ProgressPercentLabel = new System.Windows.Forms.Label(); + this.treeListView1 = new BrightIdeasSoftware.TreeListView(); + this.DCNameColumn = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn())); + this.DomainNameColumn = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn())); + this.SiteColumn = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn())); + this.DiscoveryIssuesColumn = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn())); + this.IsGCColumn = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn())); + this.IsRODCColumn = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn())); + this.SourceServerColumn = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn())); + this.PartitionNameColumn = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn())); + this.ConsecutiveFailureCountColumn = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn())); + this.LastSuccessfulSyncColumn = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn())); + this.LastSyncResultColumn = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn())); + this.LastSyncMessageColumn = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn())); + this.ErrorsOnlyButton = new System.Windows.Forms.Button(); + ((System.ComponentModel.ISupportInitialize)(this.ProgressPictureBox)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.treeListView1)).BeginInit(); + this.SuspendLayout(); + // + // RefreshButton + // + this.RefreshButton.Image = ((System.Drawing.Image)(resources.GetObject("RefreshButton.Image"))); + this.RefreshButton.Location = new System.Drawing.Point(12, 12); + this.RefreshButton.Name = "RefreshButton"; + this.RefreshButton.Size = new System.Drawing.Size(50, 50); + this.RefreshButton.TabIndex = 0; + this.RefreshButton.UseVisualStyleBackColor = true; + this.RefreshButton.Click += new System.EventHandler(this.RefreshButton_Click); + // + // backgroundWorker1 + // + this.backgroundWorker1.WorkerReportsProgress = true; + this.backgroundWorker1.DoWork += new System.ComponentModel.DoWorkEventHandler(this.backgroundWorker1_DoWork); + this.backgroundWorker1.ProgressChanged += new System.ComponentModel.ProgressChangedEventHandler(this.backgroundWorker1_ProgressChanged); + this.backgroundWorker1.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(this.backgroundWorker1_RunWorkerCompleted); + // + // EnableLoggingButton + // + this.EnableLoggingButton.Image = ((System.Drawing.Image)(resources.GetObject("EnableLoggingButton.Image"))); + this.EnableLoggingButton.Location = new System.Drawing.Point(292, 12); + this.EnableLoggingButton.Name = "EnableLoggingButton"; + this.EnableLoggingButton.Size = new System.Drawing.Size(50, 50); + this.EnableLoggingButton.TabIndex = 3; + this.EnableLoggingButton.UseVisualStyleBackColor = true; + this.EnableLoggingButton.Click += new System.EventHandler(this.EnableLoggingButton_Click); + // + // SetForestButton + // + this.SetForestButton.Image = ((System.Drawing.Image)(resources.GetObject("SetForestButton.Image"))); + this.SetForestButton.Location = new System.Drawing.Point(124, 12); + this.SetForestButton.Name = "SetForestButton"; + this.SetForestButton.Size = new System.Drawing.Size(50, 50); + this.SetForestButton.TabIndex = 4; + this.SetForestButton.UseVisualStyleBackColor = true; + this.SetForestButton.Click += new System.EventHandler(this.SetForestButton_Click); + // + // ProgressPictureBox + // + this.ProgressPictureBox.Image = ((System.Drawing.Image)(resources.GetObject("ProgressPictureBox.Image"))); + this.ProgressPictureBox.Location = new System.Drawing.Point(72, 22); + this.ProgressPictureBox.Name = "ProgressPictureBox"; + this.ProgressPictureBox.Size = new System.Drawing.Size(40, 40); + this.ProgressPictureBox.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.ProgressPictureBox.TabIndex = 5; + this.ProgressPictureBox.TabStop = false; + this.ProgressPictureBox.Visible = false; + // + // AlternateCredsButton + // + this.AlternateCredsButton.Image = ((System.Drawing.Image)(resources.GetObject("AlternateCredsButton.Image"))); + this.AlternateCredsButton.Location = new System.Drawing.Point(180, 12); + this.AlternateCredsButton.Name = "AlternateCredsButton"; + this.AlternateCredsButton.Size = new System.Drawing.Size(50, 50); + this.AlternateCredsButton.TabIndex = 6; + this.AlternateCredsButton.UseVisualStyleBackColor = true; + this.AlternateCredsButton.Click += new System.EventHandler(this.AlternateCredsButton_Click); + // + // ProgressPercentLabel + // + this.ProgressPercentLabel.Location = new System.Drawing.Point(71, 9); + this.ProgressPercentLabel.Name = "ProgressPercentLabel"; + this.ProgressPercentLabel.Size = new System.Drawing.Size(42, 12); + this.ProgressPercentLabel.TabIndex = 8; + this.ProgressPercentLabel.Text = "0%"; + this.ProgressPercentLabel.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + this.ProgressPercentLabel.Visible = false; + // + // treeListView1 + // + this.treeListView1.AllColumns.Add(this.DCNameColumn); + this.treeListView1.AllColumns.Add(this.DomainNameColumn); + this.treeListView1.AllColumns.Add(this.SiteColumn); + this.treeListView1.AllColumns.Add(this.DiscoveryIssuesColumn); + this.treeListView1.AllColumns.Add(this.IsGCColumn); + this.treeListView1.AllColumns.Add(this.IsRODCColumn); + this.treeListView1.AllColumns.Add(this.SourceServerColumn); + this.treeListView1.AllColumns.Add(this.PartitionNameColumn); + this.treeListView1.AllColumns.Add(this.ConsecutiveFailureCountColumn); + this.treeListView1.AllColumns.Add(this.LastSuccessfulSyncColumn); + this.treeListView1.AllColumns.Add(this.LastSyncResultColumn); + this.treeListView1.AllColumns.Add(this.LastSyncMessageColumn); + this.treeListView1.CellEditUseWholeCell = false; + this.treeListView1.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] { + this.DCNameColumn, + this.DomainNameColumn, + this.SiteColumn, + this.DiscoveryIssuesColumn, + this.IsGCColumn, + this.IsRODCColumn, + this.SourceServerColumn, + this.PartitionNameColumn, + this.ConsecutiveFailureCountColumn, + this.LastSuccessfulSyncColumn, + this.LastSyncResultColumn, + this.LastSyncMessageColumn}); + this.treeListView1.Cursor = System.Windows.Forms.Cursors.Default; + this.treeListView1.HideSelection = false; + this.treeListView1.Location = new System.Drawing.Point(12, 68); + this.treeListView1.Name = "treeListView1"; + this.treeListView1.ShowGroups = false; + this.treeListView1.Size = new System.Drawing.Size(760, 381); + this.treeListView1.TabIndex = 9; + this.treeListView1.UseCompatibleStateImageBehavior = false; + this.treeListView1.UseFiltering = true; + this.treeListView1.View = System.Windows.Forms.View.Details; + this.treeListView1.VirtualMode = true; + this.treeListView1.FormatRow += new System.EventHandler(this.treeListView1_FormatRow); + // + // DCNameColumn + // + this.DCNameColumn.AspectName = "Name"; + this.DCNameColumn.Groupable = false; + this.DCNameColumn.Text = "DC Name"; + // + // DomainNameColumn + // + this.DomainNameColumn.AspectName = "DomainName"; + this.DomainNameColumn.Text = "Domain"; + // + // SiteColumn + // + this.SiteColumn.AspectName = "Site"; + this.SiteColumn.Text = "Site"; + // + // DiscoveryIssuesColumn + // + this.DiscoveryIssuesColumn.AspectName = "DiscoveryIssues"; + this.DiscoveryIssuesColumn.Text = "Discovery Issues"; + // + // IsGCColumn + // + this.IsGCColumn.AspectName = "IsGC"; + this.IsGCColumn.Text = "Is GC"; + // + // IsRODCColumn + // + this.IsRODCColumn.AspectName = "IsRODC"; + this.IsRODCColumn.Text = "Is RODC"; + // + // SourceServerColumn + // + this.SourceServerColumn.AspectName = "SourceServer"; + this.SourceServerColumn.Text = "Source DC"; + // + // PartitionNameColumn + // + this.PartitionNameColumn.AspectName = "PartitionName"; + this.PartitionNameColumn.Text = "Partition"; + // + // ConsecutiveFailureCountColumn + // + this.ConsecutiveFailureCountColumn.AspectName = "ConsecutiveFailureCount"; + this.ConsecutiveFailureCountColumn.Text = "Consecutive Failures"; + // + // LastSuccessfulSyncColumn + // + this.LastSuccessfulSyncColumn.AspectName = "LastSuccessfulSync"; + this.LastSuccessfulSyncColumn.Text = "Last Successful Sync"; + // + // LastSyncResultColumn + // + this.LastSyncResultColumn.AspectName = "LastSyncResult"; + this.LastSyncResultColumn.Text = "Last Sync Result"; + // + // LastSyncMessageColumn + // + this.LastSyncMessageColumn.AspectName = "LastSyncMessage"; + this.LastSyncMessageColumn.Text = "Last Sync Message"; + // + // ErrorsOnlyButton + // + this.ErrorsOnlyButton.Image = ((System.Drawing.Image)(resources.GetObject("ErrorsOnlyButton.Image"))); + this.ErrorsOnlyButton.Location = new System.Drawing.Point(236, 12); + this.ErrorsOnlyButton.Name = "ErrorsOnlyButton"; + this.ErrorsOnlyButton.Size = new System.Drawing.Size(50, 50); + this.ErrorsOnlyButton.TabIndex = 10; + this.ErrorsOnlyButton.UseVisualStyleBackColor = true; + this.ErrorsOnlyButton.Click += new System.EventHandler(this.ErrorsOnlyButton_Click); + // + // ADReplStatusForm + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(784, 461); + this.Controls.Add(this.ErrorsOnlyButton); + this.Controls.Add(this.treeListView1); + this.Controls.Add(this.ProgressPercentLabel); + this.Controls.Add(this.AlternateCredsButton); + this.Controls.Add(this.ProgressPictureBox); + this.Controls.Add(this.SetForestButton); + this.Controls.Add(this.EnableLoggingButton); + this.Controls.Add(this.RefreshButton); + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MinimumSize = new System.Drawing.Size(800, 500); + this.Name = "ADReplStatusForm"; + this.Text = "AD Replication Status Tool"; + this.Load += new System.EventHandler(this.ADReplStatusForm_Load); + this.Resize += new System.EventHandler(this.ADReplStatusForm_Resize); + ((System.ComponentModel.ISupportInitialize)(this.ProgressPictureBox)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.treeListView1)).EndInit(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Button RefreshButton; + private System.ComponentModel.BackgroundWorker backgroundWorker1; + private System.Windows.Forms.ToolTip toolTip1; + private System.Windows.Forms.Button EnableLoggingButton; + private System.Windows.Forms.Button SetForestButton; + private System.Windows.Forms.PictureBox ProgressPictureBox; + private System.Windows.Forms.Button AlternateCredsButton; + private System.Windows.Forms.Label ProgressPercentLabel; + private BrightIdeasSoftware.TreeListView treeListView1; + private BrightIdeasSoftware.OLVColumn DCNameColumn; + private BrightIdeasSoftware.OLVColumn SiteColumn; + private BrightIdeasSoftware.OLVColumn DiscoveryIssuesColumn; + private BrightIdeasSoftware.OLVColumn IsGCColumn; + private BrightIdeasSoftware.OLVColumn IsRODCColumn; + private BrightIdeasSoftware.OLVColumn DomainNameColumn; + private BrightIdeasSoftware.OLVColumn SourceServerColumn; + private BrightIdeasSoftware.OLVColumn PartitionNameColumn; + private BrightIdeasSoftware.OLVColumn ConsecutiveFailureCountColumn; + private BrightIdeasSoftware.OLVColumn LastSuccessfulSyncColumn; + private BrightIdeasSoftware.OLVColumn LastSyncResultColumn; + private BrightIdeasSoftware.OLVColumn LastSyncMessageColumn; + private System.Windows.Forms.Button ErrorsOnlyButton; + } +} + diff --git a/ADReplStatusForm.cs b/ADReplStatusForm.cs new file mode 100644 index 0000000..623c176 --- /dev/null +++ b/ADReplStatusForm.cs @@ -0,0 +1,446 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; +using System.DirectoryServices; +using System.DirectoryServices.ActiveDirectory; +using Microsoft.Win32; +using BrightIdeasSoftware; + +namespace ADReplStatus +{ + public partial class ADReplStatusForm : Form + { + public static bool gLoggingEnabled = false; + + public static bool gErrorsOnly = false; + + public static string gLogfileName = string.Empty; + + public static string gForestName = string.Empty; + + public static string gUsername = string.Empty; + + public static string gPassword = string.Empty; + + public static List gDCs = new List(); + + public ADReplStatusForm() + { + InitializeComponent(); + } + + private void RefreshButton_Click(object sender, EventArgs e) + { + ProgressPercentLabel.Visible = true; + + ProgressPercentLabel.Text = "0%"; + + ActiveForm.Text = $"AD Replication Status Tool - {gForestName}"; + + gDCs.Clear(); + + RefreshButton.Enabled = false; + + SetForestButton.Enabled = false; + + EnableLoggingButton.Enabled = false; + + AlternateCredsButton.Enabled = false; + + ErrorsOnlyButton.Enabled = false; + + ProgressPictureBox.Visible = true; + + backgroundWorker1.RunWorkerAsync(); + } + + private void ADReplStatusForm_Load(object sender, EventArgs e) + { + toolTip1.SetToolTip(RefreshButton, "Refresh Replication Status"); + + toolTip1.SetToolTip(EnableLoggingButton, "Enable Logging"); + + toolTip1.SetToolTip(SetForestButton, "Manually Set Forest"); + + toolTip1.SetToolTip(AlternateCredsButton, "Provide Alternate Credentials"); + + toolTip1.SetToolTip(ErrorsOnlyButton, "Show Errors Only"); + + try + { + var key = Registry.CurrentUser.OpenSubKey("SOFTWARE\\ADREPLSTATUS", false); + + if (key != null) + { + gForestName = key.GetValue("ForestName", string.Empty).ToString(); + + key.Dispose(); + } + } + catch + { + + } + + if (string.IsNullOrEmpty(gForestName)) + { + try + { + using (Forest forest = Forest.GetCurrentForest()) + { + gForestName = forest.Name; + } + } + catch + { + MessageBox.Show("Unable to detect AD forest. You will need to manually enter the AD forest you wish to scan using the 'Manually Set Forest' button.\nThis happens on non-domain joined computers as well as hybrid or Azure AD domain-joined machines.", "Forest Not Found", MessageBoxButtons.OK, MessageBoxIcon.Warning); + } + } + } + + private void ADReplStatusForm_Resize(object sender, EventArgs e) + { + treeListView1.Top = 68; + + treeListView1.Left = 12; + + if (ActiveForm != null) + { + treeListView1.Width = ActiveForm.Width - 40; + + treeListView1.Height = ActiveForm.Height - 119; + } + } + + private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) + { + Forest forest = null; + + try + { + DirectoryContext ForestContext = null; + + if (gUsername.Length > 0) + { + backgroundWorker1.ReportProgress(0, $"Attempting to connect to forest {gForestName} with alternate user {gUsername}."); + + ForestContext = new DirectoryContext(DirectoryContextType.Forest, gForestName, gUsername, gPassword); + } + else + { + backgroundWorker1.ReportProgress(0, $"Attempting to connect to forest {gForestName} as currently logged-on user."); + + ForestContext = new DirectoryContext(DirectoryContextType.Forest, gForestName); + } + + forest = Forest.GetForest(ForestContext); + } + catch (Exception ex) + { + backgroundWorker1.ReportProgress(0, $"ERROR:Unable to find AD forest:{gForestName}\n{ex.Message}\n\nYou probably need to manually enter the forest using the button."); + + return; + } + + DomainCollection domainCollection = forest.Domains; + + backgroundWorker1.ReportProgress(0, $"Found {domainCollection.Count} domains in forest {forest.Name}."); + + int CurrentDC = 0; + + int NumDCs = 0; + + foreach (Domain domain in domainCollection) + { + NumDCs += domain.DomainControllers.Count; + } + + foreach (Domain domain in domainCollection) + { + DomainControllerCollection DCs = domain.DomainControllers; + + foreach (DomainController dc in DCs) + { + ADREPLDC adrepldc = new ADREPLDC(); + + adrepldc.Name = dc.Name; + + adrepldc.DomainName = domain.Name; + + try + { + adrepldc.Site = dc.SiteName; + } + catch (Exception ex) + { + backgroundWorker1.ReportProgress((int)(((float)CurrentDC / (float)NumDCs) * 100), $"Failed to contact DC {adrepldc.Name} and fetch site name:{ex.Message}"); + + adrepldc.Site = "Unknown"; + + adrepldc.DiscoveryIssues = true; + } + + try + { + adrepldc.IsGC = dc.IsGlobalCatalog().ToString(); + } + catch (Exception ex) + { + backgroundWorker1.ReportProgress((int)(((float)CurrentDC / (float)NumDCs) * 100), $"Failed to contact DC {adrepldc.Name} and determine global catalog status:{ex.Message}"); + + adrepldc.IsGC = "Unknown"; + + adrepldc.DiscoveryIssues = true; + } + + try + { + using (DirectoryEntry directoryEntry = new DirectoryEntry("LDAP://" + dc.Name)) + { + using (DirectorySearcher search = new DirectorySearcher(directoryEntry)) + { + search.Filter = $"(samaccountname={dc.Name.Split('.')[0]}$)"; + + search.PropertiesToLoad.Add("msDS-isRODC"); + + SearchResult result = search.FindOne(); + + if (result == null || result.Properties["msDS-isRODC"].Count == 0) + { + throw new Exception("msDS-isRODC attribute not found!"); + } + + if ((bool)result.Properties["msDS-isRODC"][0] == true) + { + adrepldc.IsRODC = "True"; + } + else + { + adrepldc.IsRODC = "False"; + } + } + } + } + catch (Exception ex) + { + backgroundWorker1.ReportProgress((int)(((float)CurrentDC / (float)NumDCs) * 100), $"Failed to determine RODC status for {dc.Name}:{ex.Message}"); + + adrepldc.IsRODC = "Unknown"; + + adrepldc.DiscoveryIssues = true; + } + + if (adrepldc.DiscoveryIssues == false) + { + try + { + foreach (ReplicationNeighbor partner in dc.GetAllReplicationNeighbors()) + { + adrepldc.ReplicationPartners.Add(partner); + } + } + catch (Exception ex) + { + backgroundWorker1.ReportProgress((int)(((float)CurrentDC / (float)NumDCs) * 100), $"Failed to determine replication neighbors and repl status for {dc.Name}:{ex.Message}"); + + adrepldc.DiscoveryIssues = true; + } + } + + gDCs.Add(adrepldc); + + CurrentDC++; + + backgroundWorker1.ReportProgress((int)(((float)CurrentDC / (float)NumDCs) * 100), "UPDATEPERCENT"); + } + } + + + + treeListView1.SetObjects(gDCs); + + treeListView1.CanExpandGetter = delegate (object x) + { + return (x is ADREPLDC); + }; + + treeListView1.ChildrenGetter = delegate (object x) + { + return ((ADREPLDC)x).ReplicationPartners; + }; + } + + private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) + { + ProgressPercentLabel.Visible = false; + + RefreshButton.Enabled = true; + + SetForestButton.Enabled = true; + + EnableLoggingButton.Enabled = true; + + AlternateCredsButton.Enabled = true; + + ErrorsOnlyButton.Enabled = true; + + ProgressPictureBox.Visible = false; + } + + private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e) + { + if (gLoggingEnabled) + { + System.IO.File.AppendAllText(gLogfileName, $"[{DateTime.Now}] {e.UserState}\n"); + } + + if (e.UserState.ToString().StartsWith("ERROR:")) + { + MessageBox.Show(e.UserState.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + else if (e.UserState.ToString().Equals("UPDATEPERCENT")) + { + ProgressPercentLabel.Text = $"{e.ProgressPercentage}%"; + } + } + + private void EnableLoggingButton_Click(object sender, EventArgs e) + { + gLoggingEnabled = !gLoggingEnabled; + + if (gLoggingEnabled) + { + toolTip1.SetToolTip(EnableLoggingButton, "Disable Logging"); + + EnableLoggingButton.BackColor = SystemColors.ControlDark; + + DateTime Now = DateTime.Now; + + gLogfileName = $"adreplstatus_{Now.Month}.{Now.Day}.{Now.Year}.{Now.Hour}.{Now.Minute}.{Now.Second}.log"; + + System.IO.File.AppendAllText(gLogfileName, $"[{DateTime.Now}] Logging enabled.\n"); + } + else + { + toolTip1.SetToolTip(EnableLoggingButton, "Enable Logging"); + + EnableLoggingButton.BackColor = SystemColors.Control; + + System.IO.File.AppendAllText(gLogfileName, $"[{DateTime.Now}] Logging disabled.\n"); + } + } + + private void SetForestButton_Click(object sender, EventArgs e) + { + SetForestNameForm setForestNameForm = new SetForestNameForm(); + + if (gLoggingEnabled) + { + System.IO.File.AppendAllText(gLogfileName, $"[{DateTime.Now}] SetForestName button was clicked.\n"); + } + + setForestNameForm.ShowDialog(); + + setForestNameForm.Dispose(); + } + + private void AlternateCredsButton_Click(object sender, EventArgs e) + { + AlternateCredsForm alternateCredsForm = new AlternateCredsForm(); + + if (gLoggingEnabled) + { + System.IO.File.AppendAllText(gLogfileName, $"[{DateTime.Now}] AlternateCreds button was clicked.\n"); + } + + alternateCredsForm.ShowDialog(); + + alternateCredsForm.Dispose(); + } + + private void treeListView1_FormatRow(object sender, BrightIdeasSoftware.FormatRowEventArgs e) + { + if (e.Model is ADREPLDC) + { + ADREPLDC dc = (ADREPLDC)e.Model; + + if (dc.DiscoveryIssues == true) + { + e.Item.BackColor = Color.Red; + + e.Item.ForeColor = Color.White; + } + } + else if (e.Model is ReplicationNeighbor) + { + ReplicationNeighbor neighbor = (ReplicationNeighbor)e.Model; + + if (neighbor.ConsecutiveFailureCount > 0) + { + e.Item.BackColor = Color.Red; + + e.Item.ForeColor = Color.White; + } + } + } + + private void ErrorsOnlyButton_Click(object sender, EventArgs e) + { + gErrorsOnly = !gErrorsOnly; + + if (gErrorsOnly == true) + { + toolTip1.SetToolTip(ErrorsOnlyButton, "Show Everything"); + + ErrorsOnlyButton.BackColor = SystemColors.ControlDark; + + treeListView1.ModelFilter = new ModelFilter(delegate (object x) + { + if (x is ADREPLDC) + { + return ((ADREPLDC)x).DiscoveryIssues; + } + else if (x is ReplicationNeighbor) + { + return (((ReplicationNeighbor)x).ConsecutiveFailureCount > 0); + } + + return false; + }); + } + else + { + toolTip1.SetToolTip(ErrorsOnlyButton, "Show Errors Only"); + + ErrorsOnlyButton.BackColor = SystemColors.Control; + + treeListView1.ModelFilter = null; + } + } + } + + public class ADREPLDC + { + public string Name; + + public string DomainName; + + public bool DiscoveryIssues = false; + + public string Site; + + public string IsGC; + + public string IsRODC; + + public List ReplicationPartners = new List(); + } + +} + diff --git a/ADReplStatusForm.resx b/ADReplStatusForm.resx new file mode 100644 index 0000000..81c9bd9 --- /dev/null +++ b/ADReplStatusForm.resx @@ -0,0 +1,2834 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABGdBTUEAALGPC/xhBQAABW5JREFUWEfF + lQtMVXUcx1npmgaBUKiZpEVsKjhUbqg1sUJxiTQxER8JmVu+AEXBXVBBQjSIYPggRbERCy0Q0EwRhSVD + TdPL5f1+g3BB7oX7OBcul1/3d9qxcw4/ra2N7vbZ7vmd7ff5/p/HDAD+V8jiWEIWxxKyyGdr8aGX1t/a + Pd8jxzf+k8sbq1Zf3azyvr51yOOX9SOLMz+GuWnvg+PZhSPvpXpoVqb5VH2etStxe+7eF6leFGSRY0tR + +NQVuRuS/G8FdsTVnmNy+gqhQlMJPYwSlPp+YIb0JhhQ6pRQ1Hkfjt5OAp/0bbD0O68n7udWXaV6iiGL + iO/NQEevyxvlB0viGZn6odH0g39LQe09WH3e32gXba9cespjB9Wfgyyuydvm4pm7QZFQc2ZYaxohJfkn + lFoVhGRFwmTpdL1T7PwUyoOMKnx5N2rSp9e21h2tPGXUGWj5sHGYrPNhGAb6+/sh6UYKTAmzY5zjJOFi + FzKq4F+wPyawKMLYqm8kGyPp8nRQMSryHQcGUCqVoFAoIDjjANhIJ2vELmRUYUfeAW1GXQ7ZlMPyqCUs + OL0AerW95HuEC9Dd3Q3NbS0gif3A6BDt+EDsEzxsvhEStvNqGHRru8mmHGaRZizPC6HX60GlUkFXVxe0 + t7dD0q9nwFb6BrPs+KpxfKcgwK6CyOr4u2fIhny4AM8LMTg4CAMDA+wMtLa2QlNTE8yMmA0OUY75fOfT + P1t+lI5fl7mDyWssGtVMDD/As0JwAXAPYIDGxkZYf/oL0yxMVZIBfDMCFm7KCTI8VncJGlGIA1AhMIBa + rX4aoL6+Hs7nZcArIdYGMsCqc37LP8vdM6JhtAIZBRUA4YfgAvT09LAB6urqoPD3IrDZN81IBvgw2XuR + b3YQe72KhWIoOQeGUKgVghloaWmB2tpaKCmTw6uh9iYdEcAtxctiRfqm/xTAIs4CJhybADG3Y9hTwG3C + 5uZmqK6uhkdyGUzZP9ukIwIsS1n7snvq2pFGfTsp5UPJzePMwfJbS/DL9gODwcDeA3gMOzs7oaGhASor + KyG/uBDsDjgNkwGQJSdWav5QVJJSPs+S+2b5snKcfo1GA729vewdgNNfXl4OMZfiYUbELC3fKQjgfMy1 + PfVBFinlI5DHmoNVgpVArtPpnl5CeP6rqqqgrKwM3BM84a2Dszr4TkGAebGu19xOepJSPpx84tcT/5Jn + /i3Hqce1x9G3tbWxux/l+ffywTrEFpy+csnmOwUBvM76jHs7eo42W55Hijn4cu+fvAUj5+QdHR3s2ldU + VICsRAbeJ9eBRfCkoSM5J17gOwUBEIcjc0pWJPsY1ToN25ADR4Y7G0Xjo8eDVaJJftGbreE7XHOcdr4c + p14ul8P14jywCLICp2iX38Q+wQPHlPDpAwEXQ+FJ3xPo6+tjwS8bCnCELqddYPvl7ew5x2dOjGuO087J + S0tLQSaTgeTwYpi0x1ZNuUYVEMk3i0NtpdOYoAsh7EWCjTnwXJc2lbJ1BJ/xqKEYNxyuOU47jvzho4ew + 4bgfTNhpbnCP9/SnXKMKHE4xC1Ks904eXHNyI9Q3N7DXqRi8YBAcMR41brejvPjBHXA/thIsAiyH3GKX + H6YcCFnkcI1bsts62FbrFCUZSb6Wyn7R8KOCoLCmpoa94XDEnBg3nDQtEuxC7Eesgmy0i4647aJ6c5BF + MW8esi9/PXymThL9EQSkhUHilWS4UJgJ+fdvwpU7V+D7Gz+A9GIEeCasBbu9DmAV8NrgO+Fz7lO9xJBF + imXHPcfNi3G95Bj1bpN92FzN1GAHo3WAHdgEzoQZ+5yHZ4VJBmaEOjyeF7XwZ/FRex5kcSwhi2MJWRw7 + wOxPTmcqQAzpYuwAAAAASUVORK5CYII= + + + + 17, 17 + + + 258, 17 + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vAAADrwBlbxySQAABspJREFUWEedlWlQU1cUgCPUTvtH0NpptdVxa2dafzgurTpVQCCyCAERV1ygdQM1 + oNZlxE6ta1sWTbS1VcENxYVFiIDKvgSQJTeETVRACBhFa60d6zj+OD3nvvdicHtp38w3976T9/jOuffc + h+JNl0OEZqvjGm2GQ7jmYzGkUERq3RzUWp3jKu1YMaJwiNSOdVRrdH0jNG5iSKFQa0bhcxlIgBj5b5dj + WNygPmrNP32itOAQvm+7GFbgfZ4DxdTaZDFEsWR6zlGtzRNDij6RWg3FcDSJIfuukKSGwKjyOx1L8272 + 9F13AOiPjDuQ9Vit77ZElJgt/TYfekqxITuTn0QUd1pWFnVY+kcnPKHYB9+feLqsoM1CjNhz7jHF3t34 + 27OQnBbLAl1Lh8/Bismi5vVXWNo1trXlb9hY/wCG7k6GdzYchFlZJtjU+BfGHsLo/Trou/4XcD1RDOvq + /oC1xvsw5tdsHvviSC6sqb0LqxHXpFIeGxmbAsuv3oYVVbchrLB9h6h5/RWW1syirz2CLc2PuCACX97Y + 8JDLv63/kwuX6jshit2HKJxHsnuwpuYuhBa3weqaO7AK5+HIymoLhBTehKUVXTyBZZXdEFpkRwJLUpvZ + 5qZHvOJNJEZIvN70ANaZsGKx6igUk1xt6BGr7oEITCAcIfmKKuI2yru5nBJZUtAmn8CilEYmyTeQGLdi + HcklsVEQR3JxD19uoWpBLMh7i78pJ8ywKN+eBM43MhJbqyYxQsstVN3Dq+ZiRBBLVZNYWO6llSjlcjN8 + rTdDWJkZQvJa5RMIOdfAbJd7dk4TeJytAPcz5QLJ5TAtWQ9uOLqdxvFUGbgiLpxSmIrNNyWpBKacLIFA + nUmUd8KS0g6Yn3tDPoEF5+oZVc0rxuUegieBn+f/wai4NAhF+WKULyy5BXOuXJdPYN4ZE5O6O9JwD/wv + MJh8tAAmJRbAxMR8mJgg8GVCHh47kcO5MEFk/CHiCow7dBm802phEYpDits5cy61yCcwN9nESCx198v7 + bOEN1rvJpH3utC63rTikqA3mF7ZCcE6zfAJzTtcx6m4SR1B39xJjg6GYGswqtpGTeDGKabkFcTsXz0Pm + FtyEoGw7Egg+ZWTSeQ5H8fz8G6DS1YEq0wj+GQz8kBkXDBzfdCTNAD641N6pNeCFKFOqQXmeqIKA7EYu + npN/E2bj3wnMapJPIAgTILF0rD7adfqVDWYPw2NTUX4DZuddh2BEpWuUT2BmkpFZlxv3+KvjRfBJfDqM + ik/jjMTOpu6mcQSBEoJkw2NSYVhMipVJx4q4ODj3OszKbcEE6uUTCExi7MUGs22yl/cZGwyR9llabl41 + ia+0QNCVazDzcjPMyDTJJxBw0sC4uKK3OLRUkEvihdhgC6xiSU7iG7xqqlgSz7zUDIGXmsD3Qp18AqoT + BiaJiQUoCMKXZ+IXMRCbKiCLaADVxXrwR/zwazcD8c2sQ4zgk2EEb/x2eKUz8MfnSByQ0wgqfNcn3Sif + gP9xA7Nd7qE/ngXHtQdE9sNb4vh6hGfpOeoTFSbun93A8Upj8gn4HTOwUNpncbk/02SC89YEcI5O5DhF + J0A/hEYJ6/0WnNvw+YEs8EOxX1Y9zLhogukptfIJ+B6tYdYGQ2if6WMy19pkvfd5Fu5z0GVhr4XlbsKq + G3nFktgHt8gb8UgxyCfglVjNrN39YoMhzxvseZPZ7rMk9kOxL0Jir0ysHnE/VyOfwPSEKja/0PZYPRcH + v0JMqMQ9FsT1XExVeyEkVmbUgecFI7ierZZPQHmkkr3yPNscK6tYXGp/EkvLba26jouVeCo88VS446lw + OXNVPgF1Ujmj77+0z0LVJEbE80zL7Y9IDdarar7cgpyq9kCxO/7P8EmvheiLFfIJpOoqmcFUD/qqaiir + vAqlREUlp0SivBKKyyugWF8ORTYUlukFSsugQCS/pAzv9VBZXQPVtXZ8iDJ0emaxWKCruxu6urrAbDZz + Os2d0Nkp0NHRwbl161Yv2tvbRdqgrU2gta0VWltb+e+s2o4mXK/yZtm/74JLR+M52YlEHOQkxEF2As75 + KJBFHInlXDwSAzqJwyKHfhaJgbR90bA7aIIdPTBlNNszrR/sdOsHO1xxdHGCHS40x5FwcYbtGNs+VeAH + An/fZoXunfi4baoQo/tdrvie6yA7Epg6fmecciDs9XSGvUoniFc6QzzO4z37c+I8cO6Bc4TmsTbEuWMM + iXV3hhgOzRH87Sf3959tcvl0lqh5/TVxzPK3d7gPG7x/uvNgjZcTMmCwZvp7g/cpB7yRvZ4DRfojzjYI + 99+5jvpQVNhcCsW/uXe31eZ4hTMAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vAAADrwBlbxySQAAArZJREFUWEflk7+qGkEUh4WkSJUiBJKQJm+RV8gLpFMIqKCIpLNMRCKIhaA+hVgI + VhaChaAoaiFiJVhopa3/XfdkfjvZu7tzz+h6CZdABj4WjuN8vzO7J/BPrOl0Sn+bwWBwyGQy38XxbwQv + LJFu4Q+mafricrlcwSDDkMxmM2q1WmYikcgIxQfBS0vGLX8BOKEbRw5WqxW1223qdrtmNBr9ITTvBPxN + 3A7glZXLZSqVSlQsFqlQKFAul/PIbYbDIS2XS+r1emYsFvspVHyI6wG8cpDP52k+n9N4PEaHlEqlmABn + Go1GdDqdaL1eU7/fN5PJJB/CDoDD1SdHNpu1DrVDhMNhjxicz2fqdDq03W5ps9nQYrGgZrNpRiKRX0L5 + VuCEQABOpCOdTtNut3sIEQwGH8lBvV6narVKlUrFolarUaPRMIXys+C1Jce6L4BhXXk8Hrc6D4VCfwJ4 + 5ZKTBc7H6xBTgQAklF8FHy05lr8AhoVz1YZ1sN25V+zI8Q04HGkymSDAN8EnS451KwB+vxdObiOU9wRw + d+qGu3LZOfbr5Mfj1QC4Zuepn3f+fXP7VfmVALIz95Ofd1Us5YDb7xZLDnwA52oduHnXyXHV3H632EYo + /QXg5l0nB9x+VX5XAG7e3WK3HHD7VfnhoA0gPywVCPG7rmuJ90PDfrVziCV7fQAI3FIdnJzbZ+OWawM4 + HToBvDXZOepc56hz79sJIOU3A3CzDLFuxrk6xFzdRwDdLPN1dMzV0TFf39N+rw0gr5ibZQTQzThXRwCu + Dvl+v9MHgIibZV0dV83V0SlXh1wbQH5U/CzjXXN1BODqCMDVfQTAF60+JfILt+HnW8W+chWh5AI4MhVO + /FQ5EMrHAdTDVZ4qA7vd1oNQegOI9V7wRYAfngO44HxYrwQoINVzABec//0KBH4D79x8dkWpevEAAAAA + SUVORK5CYII= + + + + + R0lGODlhtgC2APYAAHdnmPaDd/Z1aSMKWaKYufiUivmjm/q6s/7s6ufk7Zeo/brF/rOqxsnD16e1/fNM + PPmrowAp+jIaZP/6+dHZ/iZI+0o1d4R2ooOX/evp8P3k4hQ6+ruzzMvT/vLx9cO80fr5+0hl+1p1/PvJ + xP3c2WZVjDdX+/NTRP719PibktHM3PqxqvVpXPvAugoy+nOK/PRiVMPN/uLe6fRaTPeLgfb1+Ort//P1 + //7y8dzi/uXp/jkjaltIg1VCfwQs+vJBMP39/v39//z8/f/+/fz8//z7/Pv6/Pv8//JFNSkRXvr7//JC + MvJCMfJIN/j5//b3//zV0fn6//j3+vf4/x1B+9zZ5fZ7b/3o5vzZ1fNXSPzRzW1ckWyD/PzNyFA8e/3g + 3vReUPJEMy9Q+/VvY0Arb//7+/7w7/Dy/2BOh5yRtNje/tbS4NnV4peMsUQvckFg+/RlV6yjwWR9/LG+ + /e7x//vFwODl/pKFrf74942AqYye/e/u809r/HqP/Kmfvv///yH/C05FVFNDQVBFMi4wAwEAAAAh+QQJ + AwB/ACH+IENyb3BwZWQgd2l0aCBlemdpZi5jb20gR0lGIG1ha2VyACwAAAAAtgC2AAAH/4B/goOEhYaH + iImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AE18j + KwUBViwzD8s/wM6jKCMGAWBLP9fY2dfP3Js4LTRw1trk2t3nlF8GLOPl7tno8Y0aBjDv9+Ty+oYTB2NM + +LJlGUMjxYE6UDTgwIFin8M/CAo8AIgPDA0IWnA83GiIRAAk+GbQqIOAo8lCJKxQdMcCwpeTMAd9CbCS + HBgDGmLqxFEAZLkmAbToHLrihLsTBkoOjalhzNEVeJbGHGKgSbkTEKJKhdm03IMUDTXVEFQlARA2KjLU + qMJm7J8aRv+2mjpglVyAK5gyyJBBgMAdNGhK7CDjxU0SMjwKewFwh0AcDlXkgppAo9yMEZZkrPEDAICE + zwMGJAlNurTpJBIGL44jQ7KmK3DKFQgbqYYMDltKiDbNu7fv0iX+CHFdCYpRbVm6SPIgJM0F0L+jSyd9 + 4a0UI8OJP2pRFxsTKxohgeCQZ4eE6aQPD5BQ+LAXMqEljO79wYiUGlKuA9HOyEC7a0hAEEkGfpQw3287 + DOAGAFvcwYEfHySgggoe7DGhDFVwkMYdFwDQw4FJ3HddDSAYYUQR+/F3SArknCDUIwRacCBvOyRRQh4E + JFCFB3/E5YgHGewhwwd59ICGdSBIUYT/iUYAAYQQKar4RwHkwKFUIwkQwMNvh12QYwKdxJVkfkUIYQQI + UDop5RCVaWMFbYvUwAAP5/XmRQkNsFEKEGUKUQSKUg7SZjY0lNEICFUAMCNpO3jhRwN/RGmKk5SqGSlx + VGpTgCMJ+JFgbwAwwBwsQDQpHHEG1PRDCo40sEVvO6DRgFuyqJmdXAfUxASrjDTnRW8lMECrLZZKBUV3 + 12zKSAKenbaDH2D2UixMVxyHDQ2NNGCgaRIAYFagtEzAgptDMMJAD7z14MclNiygABd8mFDBBi5E8EcQ + 4E4y6DUwwHkICAzAV1q3KlCSgwIiUBHBwgw3HAS++UJygDYnXImI/wcMLLpDGntIokYfFTQsssj3RvyI + Bg9kg8SLiqRRJ2leMBAJHQqYMPLNDpvsyBDjZiPgInd8SloJH0Cihhz14qy0vYRArLMhBmgTQJxxLFpC + ZI6oIYIPS0fggxgiYOBADGrYcMPT8yB7QniISMGA0KKVUIQjNnDBNc4+mIDBAmejPYlT2CyhnCIMWGAa + ABk4osAGSr+hgA1+W7JCTcomUoXA1GG9iB1v4OzCCzlEfgkO1v6Qhb+FyKBbejwkzogDSYu8gR59i25J + ATVhlogRF5jGQ7SKOCHHzS5gULvtlXzh0zVTK0IA3D1AuogONo/MR+jIYxJANk3gZfmMEjQg6f8hFCgs + MhVzZJ8JCSvtqogMAAx8ByMxMC6yCHSon4lK2JyAOiF5mBEAeKSIGMRuYT5QgP7WV5OfIaIKLxtADwqm + iA4cMAIbiMECM0GT/mnlEHvoXXo+MLdEUMB+DKuAGjaIiSuEIRsrUEQcXpYEANzqEDowXwp1wEJM4M6D + iQACukjDAwoiIgrVSyHkemiJCaTsGu5DhBGqVhoOSEERw2sYFXjIREtMDBtNsFgh1rAlmC3CAbKjQBcv + AbgfMKF5iLjDgXYQB0XY4YA+0OAaK6GBmrDMEDXA3AAQp4jONUwPe7RE1LABhkQIgQOmWYMiFCCyECTS + EmDIhgESwazS8OD/hoWwAQojQIUlXlISJMgGE3KCCA5gTgIySwQXRJa+U05ikddggSJEGJoStAYRarjb + wvhgS0q08QcONIQM3JAeAoyPECJomAuwV0xI4OA/L0EEFUPjBc0ZIpgNw0A1JdGCbMxAEasLzQWGVYgs + LmwDxxtnI2iwEmwhogYRbICPDGGDAyJSnpCwBxRbkIgPlGYHIEiEHhoGT4A+4prZMEMieDlIRYSMYS9w + 6CNGkI1GJmJGHDChyFYoFafVApc/sCciGnABww2AgId4QcNMIBeT0mJ72IghIm6VgVgi4qILU6BGHZFJ + bPyxEEAQ0TMJkYOG+cCUXSxXE//zP0HwqUQg/1iqICjJMJoOtRFfEMgiSgUCQCEimgwTp9+0WgipXoKj + 2BiDIoRQIkboMAILkIxNZbECQimiVGViqw2c+gTJEOETbqVEpq6xySD6KauJWEDDxOCavV6iXImdRAev + cYC/nsish+DqwkSgHctOYgiZNWY26jDXE4GyELNMa2UFYVpWxAYbUHAklBjBh4Y5YLa2mEE2WLnTJy0i + iRHQ41ZqWwnMphYSpRMjUiPF1j8ANQIkjapUn/uIJ16jqoKAUpkUMUqolpS2mdgudx3h3R+At6xpUsQB + 47mUw/7BvppArSXMEcRKKYJkwMVvfvcLj14tAsA1ta+AEbGf6hJivau4wf8N6CDhr3qiwdMyxITPUGEL + fyLDhXDCE54gYeZ6eBJPqu4TnMDhMxxBdA52BYgJQYQp2GDFL15rjGWsiCOQeApTyPGJT0EEJUzBCUge + 8iZmXIgjnOHIQtbZjnehBBxHQcmZmLISnHAEIkTBxFKasipiTAQuH0EJC8ayKKLQ5S4/LUVMfkWDGdHl + IBwhyvlSU5x7QYQ2K0HNpiACEezsZrSJORf4KjKYiSOE1z4j0YM29KFTIeaHBSHNgA7FpR+W6UvsmNOd + NgXEQB1qUIwa06XWxKgXnepLsLrVlUA1rDUh61m7+tW2pgSuc82IXfP616/wNbATIexhI+LPxk62spdu + zexmO/vZkCg2tKdN7WrjwrLSNjapR21tSZC62/eCGH6z/WtuC6LW4KYtudPN7na7u9uTfre8GRxvZtf7 + 2XCe93T1ze9++/vfAA+4wAdO8IIb/OAIT7jCF87whjv84RCPuMQnTvGKW/ziGE9EIAAAIfkECQMAfwAs + AAAAALYAtgAAB/+Af4KDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+w + sbKztLW2t7i5uru8vY4oCF8kXxoIOEO+yaZlOGYoGi0GBQFW1WNwMDMnTQ8nJwbK4ZwIWnUrNHBITNxI + P+7v8O5MKeL1lV8rBVYz8f3+8CvsCWSEjISBa03+KfzXYqBDQzg0QADz4MFCf02ygIGR7YRFdyMeivzS + IoC8hRWbnBBQAMKBOi3qdMHy5YoZPGYQXMEjcmAXA3AuhoExxoqBEWbKoEDBs6fTQnVo8FOIhOUKLROe + akVUJ0CWhQJWdNGwtayhL1a+9gvTBIyBKwj/ypid+6cMggIn/CGZYUVLXbp0cRw40S4eExYFvgAGjAeK + FSb+xrxdDPiKgY/x4EBQTJmuY8jxHhggscnDHxmnq+xpsIfNGiBVTO/pfGrIATD9mASA0pSSECNVVMRp + c6HElh0lJFhwk4SH8hIWAOTJQ0AGG9S0P93F7G7JjBY4KslYk6aNGx4DdgxYz769+/VJBiTpwaOEHxkJ + ZmfHhMVKvCVNFBCXJEas8cEWJSSh3nsMNshgEmhcQEAD+1VSBwv9zFAHMpDUIAMDW6AXn4MkltjeDmSg + kUYCFUKywlTvIGEFApCAUAMHF4hYYnwSDCABcz0oZ0ESXsS34IgN8rgF/4UtLnJZPCfQA8mHaCyY5ABu + 7ADAFn60oQIDMqiwxmqtNfAhAXFcQJ8b8JGoghBNHlJGAQnBA0NDj1SRRgkkSoCchGxUUQMkUvxRYBUN + 5GiBle25sYcUUhQR5yA4FFDYOwJA4QgIQhBgQY8M7qAlBw2AYJomNTTAQB7otZfGH5DWUAScTVZqWABk + NVIDA2g0KIEEF8TBxh+SguLBanmol8SjNRhRAwictoiDAYbRQCMjHsgAAJLtQZhHAoWaAgSsDNzxx7PO + GgGCEUWMSxsK1MITRgrXLpJAGmy6F98WHAz7io2QFlGEEUYAYTBl8ILmDhIphLeIhwm+R0YJHPwBwv8s + AwshxLoGA0HrXEOswN0PKaDQiKfvJbEFA/rVYrAQAru7WB0wulMythcwyEMa2OVy8Lgym4UFDPAgUYDD + ihz4ngR5rGEEJjY48YcdHajhxA1qqGFDJ7MOEnRPCAgAzxI0XLFIER+Qwe0AaMRxqiREaL0ABhhwIUYF + b5iwgQt4vxECH3JgsIAOmGj8x9dO0XApE2OYrUgNflig7wVrfOzIE3RQULcJEewdweegh/65Dz6AvoAm + ljslMjxZ5JqIFH4wOoAFd2QQiRMO6FEBFS6I7vvvoROeycFPkZCXPA/4tQgB+pLxQbiN3GADBiFsAPz1 + wG8QRBCcIC7QGPAwAcH/w2nIjgaTjizQhwu9Y+9D+xWIsTcVFVTQ/ud8TLoIBPEEsAgIcQAVewDgL0Y4 + gQIioAL2NuCDN7zgBQroQAwWQIEn6ECCC4jBHBQgAjFgQH+JIMEDFAaDeiHCD2To1hb2kDpEUOAF1gOe + C0TAhQXQwQ6NIAIIF4ED/yCvDooQQtrcc4ECLkIBFQAeFUyghw5sbYebaEEYYkSDRaigB90qwaAWQYQc + 8CF7fZjDH5QARU6QICjvGIPrDlEFPrUHAFVghA0coEDR+aACeqBAGT1Rhni54wQBUcS22EOkniVCDS/4 + XQX6cAOp7bETI6gZDUyGiBu5hwcfYEQHvug7OcTg/5GfKAMNFAaGLiQNi+zZwQcupogOcE50VHDAE0HZ + iRbAiAkGyEol0cCtNixiCjFIouj4YIMj0JKPj3kHDEiTCAIgKQkAaNkhjkBH0W3gg8f8RBfU4o4V6JKN + KWQPGlSwCAeIIXR3dEA2QWGFS8HAcYfIQM4I+QHvDSKYoqtADBy5Tk58gTveTAQDwrkeALSQEHY4Z+hM + YAcy9rMTBYDHCcyQCBn0ij0WWIMiciAC0YkBhw/tBA4wMy9FEECAO3hVIpzwgtKBzgSfDCknytACeDzA + hIXwgOTYswVDGkIPdfycGE4nU06YwYc/CIMVFJGGZ9YzETmI4egWYMyibgILmP85AZ4OIYV8FXSLh9AB + Jz/nAgVEwaqbKAP/0tgbQ3CgW+RMhAJCN0OHojUTGkDqPBSx0/WU4KCCoMArPxcCPd5VE3U43g/AEJJE + eHUAmUyECO7nAjEeVhN+/EEAcEoISSmNDIpQw/0iIAK7XtYSeEDqD8aXCGgJIgGRPYQNEgk6KuTgtJkg + AdEWZspECAFSrEzEAoQZAR+8ALeZWN0PGLdGQwBhYNGSrEsjYIIOIBcTNKgTySh5CI+BYFb2/MMZpBoB + PdzgupfYrTvqIJfu/vZpipjCXEHngvOitxI4mKI7wkDRRHgsZlAdqwvkcN9KDKELdjqbwIJ7CAcQtwKW + LbD/JCaw1qT6z7/q6loiuHA/EYBUwpHAAQ3eIRpFxIx4h4gCcSOggCmAWBJXGANotGpiFLtwuhu47Ysj + QQIYLVMRQAvvH+ZL2B1LoguYaVwQPSbkjoIOm0Z+xAGW8I4AtLUQ3/UYYAUx2phG2REV/kEBTHw4GxtC + b6B7wpcfEdF3sBbIQtahEijggD4UmEOUCIDCDtCILf/hCGegg5oljOdJgO8djUWEu4QchSk84QY3MG12 + uKeJIRSaEiN8BzPhrIgoXO0GZ5A0bSg9iwOkgAYBGANnC8FkRRzhCTZ4dFWve2lSCIHRT3jCFKJA6tMi + w9KpiPMUpuCEKfSalkIWBIdq/+2KINzgCU5wgg7X7AkzH0IJ0FaCqDtzbHEArdNOOAIRztqiaVf6D8we + hZCVEIUjHIHcFeq2gZd9imT/WQlEUMIR5M3tTOA53awgAhGC4O4WUZrflAA2KewtCCKIu+D72R4oAL4K + gRN824BBOCYorortEXzf1G62uCs08D9ovCceP3lZSm5u/x7OFgwXxPZaThmJ/4Hm3X1IEAaucq1MG+fe + ZoTNm9RznXNv6CFPxcGBvsOY6+LgRd/Pt1Ge9GZHvTNOTwbSq46Kre8x61zvBNifLnMoLjrswRaEn9Ee + irH34uqLcTsvmN4kj5Vl1js0HNv3zve++/3vgA+84AcfUnW4E/7wiE+84v1u+MU7/hRDb3zS5X4IyT8e + EZZ//MEHkfnEU7rkJu+84klN98s/ovSmT72iVc/61rs+O8SjfOplP/vX2/72uM+97nfP+977/vfAD77w + h0/84hv/+MhPvvKXz/zmO//50I++9KdP/epb//qPDwQAIfkECQMAfwAsAAAAALYAtgAAB/+Af4KDhIWG + h4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vYoTgzga + Ggh/KAhfJMRDvs2izMZQI10rBVbXAiwnTVlwYyzgLGNWBSsj0M7plBpfXSlWYzBIPz9hS/T4+fn3+Cjq + /42YaYDw7t48fQgTIjwBsCGiKyQgsADTRKHFi/hYONwoqAsEK/SYYPzB78cDMDOaIHkwAwaMGQ9E4gvA + 8R+eISusgBn5gwmYbwEMtBg6ggQOFBqwQIGChQQULS1S0DhQ0xkKLClOxLT44MSMqS20+PsDrKrZQnUK + HFTIREA5Dcb/zso91CXACYVNHsBZoQXu3L+EUJAIkEXhgzEFvpQpC7gxiRQPwiR8UOAAjsaYBZVZsRPh + gwcGsIzN3BhKAIUsUqBgTHruEBQGOuuDY6BY68YTsFipqA80lk0Z/sioUUVGFRUyVGRYsydDjT9CbpvC + sSJLSXpNApDAY2lPkSocGly4AIDHlh1okvBQL6HEDgA92lxg0KDBnwTSP2koIHl2C3SReJBcGnlsIYEF + AwyQRIIMNujgABIM4IYEaIxXBRse5JcJFCDlw8QDNFwhiRA1JEDABVskoeKDLLbYYgklEJCBDBpSMgIM + CMFAlSQNxJHHDiu6KOSQDC7oBgB5rPFH/xE1NoLHAXd5qF0kNXwAgBs7ELlgEhF6oV4S6fEwAIJZLjik + BEkA0IAMRjSZCHUPeHgCBGY8QtwH65npogUSADAeB2lU8QEbKhS3BqEffEBAHH6SMaGCLiaxRRoquGmI + GQboswQcLbCmCHEEpCekFzwAwAEHVfwRnBSP7PEHBx/kgYaYLkrgxQWpWvoHAgUgZAUUj8jQRgkRsujo + FuGlGt0lbSbARgPlkdFiEjvk8VyTKKglpV+MmAhAsQ+ScQd9pKjQQBsSgOsgGX40yZ8+Bdi2iAcfXJCl + gyp6QUAV15YSnQdplIAgiyoAkV+vHqrGSBEJpOGFsQAQ8NyyqsjAQf8e0jbIQwI1MEkaHhD0Rw8SBoyW + CBAqAKAng0fGEVwse7CRh5lJ2CdFDVIY3FgZLcQZEmUmJ0JAxg2SgQYHNNLCZBVbDHBBETjXAAIIFMvF + 8wkymVRAGYywccHKCnrBgJK6NLAHCFJMLYUURugsVxcs5NNEAZ4aIoUK6zlY7QceVxLFHzn80cENHahh + Qwd/3GCDJjevzbYRRlRdEwJjZP0DDfImwkAJD/JAQIaU6KCGAwqIIIcJqG9ggguoVyACHyIo4MAcT/xR + +yRATF2EEJAL4XZNNKz1wxiZHwLCB/cy2F6ukdiwgAJ88BEBFRG4EMH12GefPRUbbCCHAnNQQIn/ELuD + EDkQvtd0gD4zcIuIB0M7KAEDLz+SQwwYVCBGBD5o7////quACeTggL9FAn1FKILBgPA7gJAgSvR4QBcY + kQaiJQgNDIDEE2zQhxBUAIAgDGH2XOCCCvTBDpRYIEcQcBp8gGZeDFhZEnqggn4t4gwLwMAGRNi/HVbA + B2KogOp8IMTqifB6OsCdAjligJIwIQCXSQT8LDgANT1iASL4IAi7FwIRYEABC1iADhZAuBzYYQ4dmEMf + +iACEu4wgHTAXdv+wECAdAFH+BgDsBQRvyJdIGmM6MALqNA/7fWvAiHowwJi8Ic4NoIOQbiBAzAggv1l + TwF/CIIlJOcMAZSk/wl14BoihNAAGW4BP4xQggKoYL0AikEBFEDhJewwOhFczwU3wEQDm7GCJpTEAFFE + BBtoxaALkG0RWAQgFfrggFxyQpM5wAAGMsHJXpgBa/iYAXcSwQYAOAgAqFTEDRSwgVZibwMVeIEOHNmL + XeoCBynI2gPqoAgPXEBdbgBkInLAhTdurw+IU4Umb9MFn5GEJidLQ/IG4IUPMIICITDn9Vw3B12ZAgU0 + yAcMtKAIFbihQW6IAwiQKb3sEdEBSbRoKVpQGHwYoJ5oaJAEPqeII3TAn9fbgAgYqVJTCCBrMPgCH1d2 + gXAiQgGWvJ4PNqCAlPaUFFAw6A8OULdByEBdFv/QpyGeEAPqZc8EmHxqKcoQgKzNIGiFiGmDHKoIB7xB + e2JQAxHEWoovGPSFivgogwCwCDX8EHs+4ENA6TqKCUBAo8UrRJsIECEJaLUQObAlYE2gBsKWggRjwAcT + CrCItf3BAwBoVyKewAWJ8oGnlh0FBAwKgwmeDG2s+oMNDaEAc/qAChQYaGpFIQDNFqBOihAC20aqiBzg + 9JW7JYVdZbKEPSICCEUAQRGM0LdD6EAOhayeAm6XXFCUAQIy8Ykonws5dxaCnNkTgTO7CwoE9DaCKViE + EMi3xER0wATZiyt7RaEFg4KBo4qg7nRryoXsUiGs+wXFYfFhBbQOArqQ253/Im4KWC4sLsGfGEKH6AEB + RaBPhYqQ7PXEMFgMd+ILePwBEpz73Doqwg7ZjYAejmDiT/QsJHBILCEWaN5BiDgCGzhDjT1RhgIwlwYA + KsTuoNtjQeAXe3oYsico58IdIQIEH67mIP62gBBUb71S1gQUWvqDGZCAEQxs8hMg+QcKRDnMnDjAWgSg + 40KkLxFEmMITbnADGsOZEynIx9ZORsdCJyIIU+DzDbj750xsmAkrQHOT/6CEDd7gDAZsdCZk8wMWE/rQ + SuCzE5wwV01jogwGZUIwE3HnRChhCk6YghJMnYkv5IMhjZh0okedaVpXAgprgYMjmnyEJzwhClEota8v + /4EALazAys9thBKccIQj9HrZpEjzIpBd7VljuxQ6m7QSjkAEJSj727AIwhGCQIR1o9sUk243Ecr97lFM + ehDzbre36/0KTarbz/x2hSbLrVtaJ7nf7CZCwQPOiiCwe9kHjwW7Hc5wUNxbEANdeKOHEHGBYxsaHbf4 + IiieSV1pnBIhl/i5NUTyzLS84q14+W7vzQyO2+Lhprb5H1Le8JXDGeQwh8TJMcHzoA8C550o+ioyXqOh + X0LpRsd41AXq7/w4/S+6vfpZ1D11Vvjc5V2nutTRHPZLkFzhuS67JXD+dbWDQuZud4WL427vi9M9E3a/ + u973znd0573vZDc04DcR7n/Be+Lvhk/8KebbJLg3hvGKp7XWAY/4o0e+E46/vOZTkfXNT2Kgbfe8I7I+ + edEfIvN7r7whUG/6kbf+9bCPvS3cpnrZ297Dt8+97nfP+977/vfAD77wh0/84hv/+MhPvvKXz/zmO//5 + 0I++9KdP/epb//rYz772t8/97ns/zIEAACH5BAkDAH8ALAAAAAC2ALYAAAf/gH+Cg4SFhoeIiYqLjI2O + j5CRkpOUlZaXmJmam5ydnp+goaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2MODh/EyQkOHgkWBoT + f3hmwb7QomZYX3UpKQUCMGNjM01ZLCwzD2BWNAUFBitdCNHulThaUClWVjM/D00/+/z9/vthmuRrMsOK + gS/vEiZCoKFOACsnfiD5R7GixR8FFGpk9geKgQBNmjC5SLLkPi0bE3aBAOOeyX0PYMKZweQECzgRw5w4 + oe/fkmcpeeFBASFAzJEUkZ6YccIKNgNdoNTRggDHFyhfcCCA0uLACggpAsCZ+ONE0F5aDGR5sMQiEjAz + /wqsOPBlCIIygoY4GroMBZSvZ3WNoJHFYkgwKSBo+AM0sONDKEhYKVzxgZUCJBAse8wZkZYCP9r+O5EF + QpfGnVMLmnClAIx/I0/QaMFRtW1BCFbA6NnvQRYDKG8L/+Mw9L8xBhCgGG57CJ4ULv2dWLGYue0JUKzw + 5hf3yqYMfzKoqKGiQY0PKhI0+FNlzx/3RqyTmrBiRhh/TWgEnyRF0BoVbBCQxx0A9FBCCRLw4EUSaJDR + wxZk5FECAWl8sEYVf9QgnycTFEAWP0vAccBykyRQRQMcbMEDGm4MIEESA8Qo44w0SjDAggCgwQABNciw + ISZlXDHGaAVU90gRf0jBBv+BALQ4AIw0RimllDYeGEcD7v0oCR4jgPEPCwfo9UgNUlTxQQkWuDjlmmxK + CSMPFjDAgZaP0EdZPzRgAYkHMnDQxoJPtrnDkxZIQAYaEnjBgwQ9JCHBoDa2OUAPPDSgAp2LGPAAUvsg + kdwje6zhBwBpskmGFxJscccFd6DIgHgfeGAhG3GscUccF2xRwg5kBDplEltc4IGGmBaSwj9ZdEEiIxlU + kQaEU0rwKBp5fMDBejWA90d8hiA5CHgqyEAAASv6KqUbBHxQLG4piMbPGFeIuYgHCaQBQKRR7kDtHeoW + 0V8mMuxBQBs9DOpmDwBkqSUOBcQEYgDeORLHvVO6cYH/pQmAAkR4f4xLhsFRksGAjxviQIPD/BQQMSMN + 5IHvjEn0QEACUnhbSg0epJEHlFECwIDCwxXg7g9NfMpsHqXWWAIDHriSARtb9CClBResMRweK/jzQAp4 + MOIBBwBM6fMsRnyQxssxJsqAcCugzMQDGS0ChBAEoNpzHLf02CCNSSSRh20tvMYPEinIm4gMafRKYwlp + 8OIHglGW0DRnGnjZTwrtKAJEilG6kYcMxFJygyAUTKHGAjosYEMHdtigwx+jE1GJCgQkLWMJnCHAwn37 + MBEAaod8YAHPMaLhRwIbS5KDDWro4bwJIYjgwhtUVPCGCyJQwQUfCmCQwwJ/nDFJ/6hbzEiGukIEZsax + g7NgxiJGNOBFlFuMBwkRT9ARAxdySO/DBhEIoAAHOEAXRKACFZCDHhzwh9dBwghSaIOM1gaCGthsIxBA + 2Q/GAIVF7MEPTpKRF/JwQUYcoQML0MMbNuADAxLwhTAcIAD5wAUFEMEGkeDADu5QAzKRKX0bgYLl9pGF + OsyrdjTiQaweQYQ5YCAEYoihFKdYwAi8AQMMhETGkiQFKYBACslTCAs49YMDbAYREQxhjNxgnkfMQQ4V + oMIUDeiDCkTABCagQghcYAIXbICOc9RjBxzoCCnU4ItfLEIYo4GCrPEjDFZgBAFelqpLOWIBIvhjDAFY + ARHQcP8BDpiDDVBHgRjowAEUwCIfXsDHCPgghi7gggMIyQgjfNEIuDTCIn0xguj8gAVGQgQDFJc2AFiS + EfujggtfKAYRvEABNrADLQsRhEKc4XQKCEEIXAnDTs7hEUIAgRCKgMtd8gIFVujHCQ6wiAYQbwAXOKYi + KKAAMSwzgK+cngMWQIEjXMIGFJhDCN7wwhZu4AVPcIQQxikFIQDBnLrQFFKYYID3JWIPPIAZALSliDN0 + gA92HOD/NiCHBTjhD7LbxBli4ABlwlAM4GvE3Bz6h7n5AgGb6h0YgFcI2w2gBDKAaCGy+cINVAADMRXF + FJ4IwBeKT6Y1jWovUGAAddJGcwz/mBEPOJoIG7zghX5EKio6QNQBvsEG1XTE3IRqi17iiRH9aUCvJCDP + Q0QBkzDkwjdVcYMc6MGFFaDAH9IqU0X6IgD9mMF+EAEEQ75Hici8HgFNoABYUMAEPshiJDb2ULbGAgvb + gUDXNAeCLzbihCEV4Ab6IFhZYGAKlaBpLkymTp4SYqFFKC0QE3GDOZhApGLowxn8eZbd4mIEKNua3HJb + BNkqwgFveKUATeCAp64LFTToxxgQorlwelYQRFhAFAXoAxPkgBeE3ewtSBAdJqzAcIcwQhHm+101YFaA + 00vqdU9Rhqr27gS2FcQ45TvfReiAoAMUwV73iwoSsIAfcFsE/30fyog+EDAEHWCwKhy5Dzgs9hAONW4i + 9CDdAFYgBifV8CmGIIB+FGBZhqCwVBfBBRnqV8Wl0EBOQ9PBROhyoSI+REIxIEAM4BgVE4AAP5gABvgW + 4qEOLaEhiHADOvwhBp08Mio0YAWkRJgRnV3EE6Zwg9FN4bxaNoVbf8CEGYxAcwL+LhGiUOYypxkVKUAZ + xKCqiCBE4Qk2uMEZYHvnUpRhDO6CwBkTIeNEBEEJT7jBn1Na6FFoQCQw6bHmGo2II9xgCk6YAnErPYoW + 9IMFMEaEcxFBBCd8+s/pJTUoQJMytS5CCU6IghKiMGpZhwIO/TBiJqIQBSIcIQq+HgUKtv+TOUY3ws9H + OIISep1sT9QhsbZWxBGIEARpx7ranEBAAcagj0jKbcaHMDa3lUBpcIviC3o69yKCQARjK8Hd0aimvfEt + i+8Olt7b5rcvgkDvdgtcFwX/9sFvQW+FL9wU/h5EWh3+cFkQvOLoFQTFMT6KiIN34xx/xcVDjguQk7wV + Iz85Leit8pa7/OWkMDnMZ07z4TjZFQSXebVv/gpu1xwWOgc3z39eCr0MneiiGILRkc70ps986U43hdLz + EvU+a0JeR3d60B8x9apLPete3wTYwy6frW/E7GSfBMvTLoqUs90TaH/7I9wu900QNu51rzbeEb73vCNi + 5H33u8RTSveV/Rb+7AYX/CUOfwiPdybw0eA0c6oJecVr/O6Wt0TKK295xmc+EpjnzCIdvwvSG8LzCkme + 6W3jc9UEGVOJ/zyOVy/7Qiy09pag/Tskj3tK6L73wPd98IdP/OIb//jIT77yl8/85jv/+dCPvvSnT/3q + W//62M++9rfP/e57//vgD7/4x0/+8pv//OhPv/rXz/72u78VgQAAIfkECQMAfwAsAAAAALYAtgAAB/+A + f4KDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8 + vYlDgmZ/ZV84eFAkE1dYCH94CBO+0qIof1hQIwUGNCxWYw8wLCdNLCxZM1YBATQQXSQkGtXT85IICCsr + AeU/SEg/P0z+CRwocMmSMAAfsBAQIMUBEvQiIrIHwQCcEw8CEtzIsaPAB00ezKDRAofEeWX+dIFgBaPH + lzBhLjnZK+WIFTBmxBSIJOCJLD9msHigEMaPJjMy/lvy0grNXSQOWNGpkSNCJhetpKBxoM5DDVo0TPgC + xV6XOnVaQAgwZsxFjgf/nt7CoyEFGIQdmT6wYuVAC4jNhjlKOUwDlC4HUozxBzCwXFkTsunMy4RhnS4m + o22akBJHnQICHstC0YWGUoI+xxjQ0oyw6NeKtNA40fEEDAN1BMPejYhuAdobmywpcAAPHt7ID91jUVUg + 1gJik0sv1CVA838iDUCczv0PAghGN7JIceWTEEE1BEnp7kqLgNP/kJxIsf2SjD8JPuxhEGcNAQIf+EFA + AyowoAJ+VbB3ygpAEXRCAFocJwkQgqiwRxpxXMDDBTt44cUAbrgxwA4WJCEBDyVucYGKDKyRwRoeKOhJ + XfD9w8IKfwAjiQpVXJAGGTzsMOIARBZp5JFFSpAE/4gAAHAHAQnKmAkU7zlIAxaSyADCk258iOSXYIKZ + xA5JuAEAAwnsUQOFUkZSx2QDjVGHSZDIwAEAaEgwwJJhfsknn30a2cMFHKyRwHptMoLHAXAKRIMGdWbQ + 5AB6hsmnF0nwUAIZAFzgRac99AAAphaIuGefZJSQRwNspJcoIjik0KBAMxjg2CIUMuBpn0J6UUIJujbQ + wAdGrMHGHzKs8UcGDcjgAX8fEDCqFz0AimSmAHywhquvDlJGAYwJxEId8jDiAQd3UOrnAD2oygEDf0TJ + LSOussHAB2nkQcaS1hZpAQAcJDBvmwgYsJEAXziyhwxo9BAmD1swwAF+m9Swx/8fazBQghcSVHokGRfA + +2oZpg3URAAJNxItGV8KmccFe0QpCggqtAGABfsiKcEFDbSJQskCNZECpIsU8Ucb1X5ZwgUfZKBKAgwg + 7Ua/A/y7BpvcmWEAU86lIKEiHshwwalGJoEGzAm44kG0QVq7JBoBnzedAXhhV0AjUKOh8w4M9CxLESqk + UcK1PeSRtnQrABefAXQqssYFFiDJAwAy19IjDzpvcSBvE2ih+FEGCLNIA0GWPQDTF28ShCCra7LGj0ha + wEAGWD82whgm09AIAzkXmQQZBPwBwiRK/EHHGU8skMMcCnSghwIUOKBADjnEYMMfTzhRCQdbsGykF2kc + /hj/AmM0V8CtiBBANpE7ZCtJ8TrYsQAGCpjARQUViOFDBVREQIUJ/hPBG0xAvxgsQA2TqEHNhGQkkN1H + LngowECYMAaiKSJdR7IAAY4ViRxQoA99oMIbIuCCCETAByZMoQpNiEISmmCAGHDAH24QiQzEgYG+K8Hm + aLKCui1hBhZMRBsk1wCnOeIJf3CAA8Qwwhau8IlQVKEPSiiCPqhBDVFoXSNUsAUc7mkL4otIF+AwEBjE + hREAOFIJBPYIA/JBDFGUIgvneMI4ptAEIphDB55QvEasQV9H4oEKjEaPCbCAa/84QLkQAYTztKFSAPhD + 7RLxBBvUrwJ2LCH/NiCCCoiA/wti4MP9KhCC/rmghFHcQAigh8RGyCANXhxACSrnCxRAAJFLCEAjhLAe + D4wtD4+wgx5EQEIobiACb+zD8+wwBx3YgAJ/sEEHojmHGFBAD1zgAx8wGUUXhEAPfGxEERjgpSIlYJK8 + aAEZBVJBRjQSBOnJQBuOGAMTUMGJKqzAG+hHgTPY4Q9HEAQRENG6IFCgA84jJiqfKAIMRGGXDPAYAWqA + KF8MYTE8aQGuhFAEEBShCEZoox7wmUL+KUABf9DBJaLw0DnoAX91XGEIFnC9RUiBA5GDlxSkENKatGAg + YSiAZhLxziII4aiNcIIC+PBEF/hABA6Y5ifU4IAQVICkEf8QQx+gyQgOfOAPFJXCmnoBBdyJS3REPaoR + hAAEdB7CBnLgpgo3wAU9/OEMo6DDAkSwAXz6gAoiUOki0hPWnYLArbWgQRM+csZEsBUERuioI9RggoWa + 0AUmiAECTxEEB7wAim9wAF6LJgV4gkAKcsvFFR4wkAI0DhFGBcJHU6uIGPRvhSbowxRa4QA+WDarGMgB + I4xwWpAWAbGxQEABqpKFlCmCrZKkbSIcQFIfcGEOsLim/lK4vxfQsGhrNUJkc9GC8PwjBYuAbiMfAce5 + Ti8WSrDkVecqB+GmVwiQha4tyhAARMLAuYgYb1sbQYQg5OANLaxADPooiyDs9bcieGj/etfaVunGQgvh + aoIBdilb5A5CCU6gYQyOaYJ/3uKDcp0iFxox4AEnNk5BJOp6FxGE7N0Arwvgw0BxoQQ7YGCFLnAEhTzM + Cg0ojgkr0BEjBaFfRQRBCVOwwQ1uIGFenEEBx4yACXSgRUU0ksiqwIMBqnKC13qZwFO48Y1b6Qs9RCAE + 2usyUY9bCxKY9QcPuBuLwUyEKDwhe1N4gpx3oYMXsC4SQ5ZF4gQCgy5wmMhBiMINAK2EQUvHwq2YgBUQ + WQC0PhfMUXDCFELtBEtLB8yngMJpHjACITOCCE5QwhGOEIUdd+sVBhOIANBnCDaBWQlKIAKtbU0TU5/5 + FUNgwUAg/+CaSwg7CMJmcKJQPQoNhAsJMS4E1iBNhALP2ti3RgUEBsKCR0D6D9EGd7hPcecfbJiokQjC + rAO6blgQJNu9bsTqiBDseif3AAEIieqCAG11+zsV9cEEtIl9cNgQHN0Nlwa1H/4Hg0dcFhO/OHegrfFe + ULviFO+4aEIu8mJDvOSPIbjFUc7ylmti5S7vBcxjTvOa21w6M7+5LBiu8577/OdAD7rQh070ohv96EhP + utKXzvSmO/0QOW+5kp+eiqlTXRVWv7rWu6OjrG89FEPw+tf9HfWxX6LsDRe72T8R9hypfe2aUPLbG4z2 + g89dFB8P+t3hHvd51F3m5obE3p9O8qdXFZ43f+e7znmu+E4c/imM503eEZ/46ai88aEYaOVZsbqClnzz + regy6DF/aNJ7guCRx9VuJj8Nio/e9ITgOIu5w3pfyH7PsNc3opNT++n0PvfAD77whw90FxPfEr8/viST + f3ykKr8SmH6+9KdP/epb//rYz772t8/97nv/++APv/jHT/7ym//86E+/+tfP/va7//3wj7/850//+tv/ + /vjPv/73f/RAAAAh+QQJAwB/ACwAAAAAtgC2AAAH/4B/goOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpuc + nZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9ihN/eCh/XyhmUDgaUCgIJIIIvtGheH8aZl0H + KwEpY2MCD2NgTSwz4OQBNDQpXVpaV4JD0vKQEzgkLQZWVk0zP/4/TP4JHOivib8TcOAIMNCFhAZq8yIO + iofADAQDCQlq3MhRIAwBNCBAkThPA4kCNJacANixpUuBYR5kYZFiJEldCBAU2BfGZcAfD36cOBGGxYks + Yx6cYIFE6JKXP57+gJEC2M1ZzFbQCNqSyYMmVmgWWDHigLJlWB5CwYKgzooW2v8EWAHjr2lHZ1djdTEA + 48FPgk1hzCiwju0fHJDKCMLxxSSEAGPg+CXIIu8rHFoCwODYhImAAC26HP6kQQs+AQb9MVlhmRWOEVt7 + AkZiZR00UyhQaFgx5ini1qm60MiikQmTMeuGxGuFgDXwUzo3awRjpQ4Cxc+zJxqC58CJ1AIfzEihZZj2 + 84fwdAlgnHIKDdjRyx+EAsJKygZsggIyXxYeLTQAtsR75l3iwR9sgMCBBwxUwUADKjCQwAcyFCGDIEX0 + d8oQK0j3DxMnWIHFJTWwwUYafgBwgQVo7OCGG0lYMIAXErjRgwRbALAFAX5wkEAGB2r4yRBXpPCXP2GM + sUL/fJF4IAOPXpQwwA4DJFHlAFhmqWWWVg5Axg5kXJBHGjIYkYGQm2RGUBY0fCFJDXuokMcFSZCx5Z14 + 5pmlBEkkccEdflyIpiVanCDVPwIcAJEjNfzxQR4ADCCBnpRWemedPACwhgeNDgrJCln85VUAeD3SAAOR + UqmnlVTKyIMEaHjBwxZkbLGDBTKq2iWeViaxhR9VJOApIyikQJxAYKTwmyN7XOCFqnlSyQMaF7TRowoN + ZKBCESoAUYUME8rAQBoEXNADD1TuimcJFzQg6LCGXAEBV/4sAcYIyzESZxqT8jqAG14AEEccJf4R5CLL + NSqDCieWsIUblGb6gbDwEkKD/10FseCmIw3cwYOesuahggp/dJrJHmxU0UYJO/S7ZRIBf3AmvGYUcOQP + BWys7x004kmGGwSoUMUfGX4ihCAcQGrnpT3kwcbBQiKQAr0/NEEDk4pw0POdEuQR6B9Hm2KEuHfIeGkJ + BNQAAppbffhACrctIsQFeNa4RQJQp2KEByp7gecOeTSgIQorLHEoExDErUgDEN/ZwwUfyCIECHvc0YPP + HOwh3xAQ9PPPAwU8Au2e7WpeixQZrHjnDpqeV4YWkxUEgRmNFAFEAy4PUEIDpuPiwRoAjF4lDw3knVcd + cAjURAEFKgKEFFIIkUeWaYBNCRF/PPHHGWrYsIANDugwh/8OHZxhww1/OFGJEAnEwYO6A/BAwHMosDAQ + Dcs6/7wUgqDRw9CVWEAHFMCFF1SADxswgQvEsMANvGEDcggBBhTggBvYgRI1aEDwXpYGk91EagMRwDsW + AQQgFMEIRYDeH0g2iQ44QAEmEAMVIuCCCPggAjjMoQ5tGIENRKACcuCCA86gA0lUgQDwS8IdAHgT+3hE + Z/pDoRBOKAk65CAGIqjADHfIxS5ysYZv4IIecvCHKEAiDlLSEut6F5ErUO0ELWBECYswRSHwJxJRmEMf + QuDFPvqRixtwAQa+hz1HVIFOWyoBxUrCns+tYFGJKEIRQIDCtUXCAXyoQA3/WIEImGD/AyGgQggcGAEx + 9PCPNOTCHCjgCCHIYINaukAG7iiNAlCNBo0AghDsKElaNiIGb/DBDbvoQxOIQARzUEAHKEABG6hBBxSw + QwfmsIA+KOANYuhkH6nABwdcsBEJaMPokpCHd/mCBA+QChM0RsI/8OedvlyEDUTgxRpS4QUYmMMfvtkI + 7cUgBg54gwm2yMUKiKCCjahBHHLXtUXyAgEB+kcW4rgIKZRQl5LgghdNwAcFOIEOmYjBAl4QyC6KoQ8x + SOgd1EWGPPiiDCugWgqwdohd6jKeiiCCE6KgA4LiMAQKWMAZOqG+Dujhk8PMoQvesIAiMiIPjcOSBOIQ + Nl1gwX6q/wGD4vRnR0cE4QlTGKoCcmgCB5xvFGrQgwh8uEMxvOAJhUxEBu4wOjewUBcX+8cMDiBHQdgR + p4g4ghOmcIMnqO+TCkiFGjDAh03qkAspXYQM7rAlLzjUFho4FM62ioh3PiIIUXjC+W4w1AUoYRVHoAAG + TKlDH4hhAfqKFJcAkAsU2OxzUNTfIwR7gyk84Qln0N4rbjAHETgWh2JwAEgVIQO/camqtdCC5wASulyW + 0BFRIKxhp5DdWeTgBT6NABX0wAgV9KsEMvDgLHTyoRlowBHXbYQSdhqFKAz2CLVQwgK0qcPwKcIIBBjA + /IBQAyPYog6e80oK+ioIwBriCEo4wv8RiBAFCeMiBnzY4XhPqwg2lKwGUqgBdGFRBhrI5gcC0E8i4suI + IBDhCC4+QhQ4jIsjqEEOx92AAxhRAxCDoAZFkwUU7vODMKzAKp0dhIML4WIiBEHC+OWFHRqrww3EQLiI + SOGPQWDRWRRAICx4bzvd2WJBvHjC0VBDH5IagRBENhFcloIRQDDiVqDgWP6AAJJX/FkXK0EJce0FEWyQ + YR2KQA2LAIEkjWCEOq+iBeEZ4SZibOF52MEESd0AF+Q2RUo6WhVj+FAAOuHiUpMkBphW6o4VMUUp2A4W + XxiIFjgRhFoHWiIO4G8psYwIm2LUFVgg8gzyhYlaCyIIeXmCHo7/2wcadxaesBhBAAY05kYgOzt0oKcO + 0ae/Ja8CD5zNxLUtQwG2biCxcnv1fEzdmiBgIAJv/cO4e+3tXNSbELbOjhMQHYlP38TWt66YX89T63kL + fBD+JonBD87w7CzceQRvuCHuLfGKz8LF8rY4emCs8Y57/OMgD7nIR07ykpv85ChPucpXzvKWu/zlMAfO + w2NO85rb/OY4z7nOd87znltm5j4PutCHTvRbAL3oSJ8HxZPOdE9d++goJzYtjA1zqTfd4siGesmtPvWA + Rz0eyrl6KbiuC62LXdwFVznZceH1rYN97VNv+dvPToqw030UdofF0lkO91TsfeV9v7t2WCz4lk/8vfAn + NzshDn93xSP+8bBwPOS96uTJW94WWb+8uPGt+UnYet6S7/yxQz9x0Q8C45VgfNKJ0HY+m57zkSD86yFx + R9XPfvG3z70obJ97X/L+9QnXfWeDL3wly774rCY+8pW8/OY7//nQj770p0/96lv/+tjPvva3z/3ue//7 + 4A+/+MdP/vKb//zoT7/618/+9rv//dwPBAAh+QQJAwB/ACwAAAAAtgC2AAAH/4B/goOEhYaHiImKi4yN + jo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9jBN/Gn9YKCRfCF1l + JAh/V4J4vtGfKH8kKC0jBQZWNCzeJ2NNLDPgWQIBAgYQEFBXJEN/8NLzjmV/xysQVgIPMz8PTJD8GEiw + YEEmP8I8+AFDgIAUXbR8oUfRkL0uIwKMObHQoMePIAmGGQhnTIADCHBQq+hryIQ6B8bAQBiypk2QYZg8 + CAChhTCWuZBBGAPmJsElP04wZEguHIsTSIr+MzpwxpgCI4DSwoFghQAYP5CGFAhmRgAaEFa0wIgMRTsE + Wv8QjBgBxYDdMd4GNqn5QByElVpZDeliAE4YsSBhwChQAEpWZ4Ab2buHhYSBAFbgDETs8QGNyIFN1aGh + OeQDk3PL4Pik4UsXGjBmdDSIsEVoUzi+BOgL8oSAxiRQ4ahjgIbUgjNuk0LRpcBsg1ngQBQmL9UQBCRW + WCm4QrkoyzNoFlxygsYBZ7LskSjQpAk0754QGBDwsV8KLMxwXYPvqcvujw9hEQ9/BCJyRQos0PYDGCsE + V+CDhQwWwF4GnZCCBsBgYsQfMvxRRRUZcBBiAh/UoMIfCfxRwx9AQCjcCqUd9YAAGFIihCAgcpAGASVs + UYIEPCRhgQRkkLGDF2SUgAb/AHmk0cAHQ6TooihfGPDcQCx0R4kUKqzBYwluDLDDAGSWaeaZZCYh5g48 + MLnGGkVMyUkZV4whXlgnBABaIzXUsEcaJfAwJpqEFmooGiUQoEKHcl7SQowEsXCAJB404AcAEgygpqGc + dlqmmhaUcAcbKzYayRArnHDnA1asBkkNcWzhxaadjmnkDj3sgIauEsxKxgCZeppEEhdwsIapjiAAgVIF + PXCAGa+2MSSthXrRAxoEtMHAGhzsoUIGMsjgLYkq+OFHHiX8+CunZPRwQQY3IotIGQUwS9AYdWTIZxuD + GspDCReowEYVf2zoiBR/ZOCBCgz40UOQ7OYhg8HyDiKf/0FIWAHFZI0kECyaSZBhAQAqVCGlJkKo8MEF + PaxLKBmKliqvGTQ8x+pPjoAgw8dmopEHAyd/smEVHLRBBrVmekFA0HIikAKFBBmAMyNAFIHwHWcCwIG4 + qAAhRRoAWEBoEgDE4YGpNRd0QgEDUg0EEEaAIEUGgwLAhhAgtJJAAxe4bOYObbCRN4Q4rGDQAxCg1wgQ + IBgRd94EAMBoLN7moSmaPHBAMYEQ+EPQ2hwzIgTeRRQRt4q23NgAAEhrunSBdQBEEBIQuMpI6UaUfuPb + u9TwwZBnJsED04ENQQKknu2JyOhC5A5CnJg8IcgZFOhwQwwUPEGBHX/YIAgRlsiQBv/PZPLgh3ckBGBQ + ChO5zXvV8VZixwIOKNDHG2K8YYILVJiwARV8qAAf+sCFBSzAe+CbRAPQELwdMCADt0nbQJgwBhRUJxEg + GN3bWmQJCmAgBBWowAYiQMISmvCELoiAC97ABwU44A83kEQC0oA0C+QhMGWog0FY0AVHAEEIP4yfJG7A + hQqQ0AcnTKISTYhEKlSgDw64QRQi4QceoOl1FRmCFiA1g6xQTRBvG50kgnCEKXRgiWhMIwrfgIEYvEoF + POCZBN5VkSuojzv6agQQOfiIIAThCVM4wx+MqMQURqB/G9iACSrgggog0ZBo9MEGREAB7zmCb8HLg8yk + kYLZNMH/CpBoER8fQQQnTOEJT4ghBk4oBhFwoQ8KoIAasPeHHHSADh1wwAJe8II3JDICSFTiBuQwh0fU + gHVmSsId9jAPDchuIGMQkA95BwkiECEKgbTBDW6gBDWQ8A166IAOdCDIRQRBEHY4gwL0YAIxoJEKItDB + ORmRgTbwbAd5GOUuUHDHgTygDhdUxA/1aU4lOCGVpwzkNv8QRUwMQQkxUMAbqLBEFyiAe4zYwwV4loQP + DG4XZTjAc1KQR0TwkaCKCEIUnIBNJ5gyCjdwAihsoAYuUAGSJhTBAqS3iD3kgVoWYMA8dYGFMRCECTOA + ltvA6AgiHOEISnjqNV16hKGGwoMm/1AiFRRAB0Z44KdJO5Eu6DWbE2hJoJPw4xGIQEYluJWtpwiCDvSw + AZyS8AUUoGcJqIUGZuaiC54bCA3yswgOovQQ8wyCNaF6hFbYQQSENGEIOsAIFQAgmQRA2C3KEICRkKSH + aE2rWt9qVVY44A3BLOEGYqAERQhhDWEqExk4gAstQC0MBlCeIQ6bCD869am0yIEIRmjCCiiAERygVgmO + ZQsriIcFU9uEYtkK11o4QQ+RJWEFHNDaRAhho5+6wCZjoYGDrCCgmPCjehOIiwVQIbUR2MACYpiIKmzh + bwyoBQ2Q855E8LYRpb0FBcSAUzG80Lu/M1MP/BqLLxjkrJ8IMP8uKCACJlIhr4moAQFolYQ0zAIHCRrI + CZTqCfVGww58OGEIMIqIDJTATGQ42yygoL4ULG6Mip1HDkwAXy6w9xANoBYAbHEFwmpiuhLuxQJCYMIN + 6CHJfyjCZdNEABdBWRpRoABFS+gCN9ZXU3mA4OYqJg09bJmEfNCBIl5XAyloFkJXjgYdVsllDCzCCG2W + Qg2gR+Z52EAMqaUCZTEoBRCAYM/8seYf4kwPB2RXDotocw3k9l+KMLoiNqAzCTfQgR8XQgiFNnSl+4yL + MxCXhFxQs0mN0DxWk5oiGIBkBYrpXSGYbsyv7gUF3sBlEUzRpKAughBz3QslKCC1nBboHkf/TWxa2CGr + JXxBYVskxmb3IgiajkAFGutfw1rbF3aA7wJcC8RvS4PJ2h23d6lp7l44ug8YvnG7eUHfRTN6d/P2zrDz + HRpm++LS/A74LADOIoEb/OAIT7jCF85wgRO84bR4OMQnTvGKR0PiFm8FxjPOcXn5u+O7OKcfQX4LkZP8 + 5BDfOMpDodiRr1wWKn+5zGdOc0RY0+U1Z0UCY57znvv850APutDz/XGOo3fooDj6KoqOdEswvemVeDrD + hwAPpUN9E/Kw+tW33gutc92hVf/6J6guCK+LnRJkP7sn0q52TrC97ZowO9znTve62/3uCd+41JHO87nj + HO+OGGrLAQ8JbBMTHsCDJ0Tfz274QSz+8JBPaXWjTve/X2Lvdcc84dkd+cIytfOR0HzbRY930gP+faDX + o+lHX+7UU43Pro+97GdP+9rb/va4z73ud8/73vv+98APvvCHT/ziG//4yE++8pfP/OY7//nQz0QgAAAh + +QQJAwB/ACwAAAAAtgC2AAAH/4B/goOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6Slpqeo + qaqrrK2ur7CxsrO0tba3uLm6u7y9i0N/OHgaCBoaX1gIUBNYfwiCwMC+05tlzjgkIyMpBlYFYFYPAg9j + TWMnLOk0YwYpK1gjZSh41PWRKGVdXSlW4TA/D34s+UGQIJOCCH8wCRPwBJgZNApAQPAFhb2LheZ9gWCA + BYyAYRKKHEnSYMAHVgJMvEIPo68yQ1oYCHDiRMmbOEs2ARggxYEJf6S5tIVAi4FzO3MSDJhlCZwHcE7A + ACOVyT+bSgE+mGGAxBWhQ2EhgBDg30GSYZhshRPAyooUXf8OfBmBo8uELihGINDXxcCBAG2RzCA4sOQJ + lVrCukJAAkLNmyfCpDQAZcSwP9YeWbtS5suBFjTSESb5gAWNEYpT7aXxT+TBJifgFOhq5lnmTJuhaAkN + R+cJAXVSkxpygDVJJOIMtMBh5tSVESsCMEFSUkAX4aDq0DhROOGJMQWgILC4it6XFGPAlAyOfdMVGjOa + nEWIxCcJWhrqpGAxf+n99pgM0VF3BT0AQwEa3FYLDhqswAJCBgCISR0BpJVQaSl80csQMfWWBXkSTmJG + ClkkVRATLKyQmD0trBDiJENQ2ASBP8CRAhQtYeKBFH8ksIYHCTSQQQIqSDHkHzUIAsT/i6pccQAMNGZB + AxY4WAJkBlUQkMcFF3jhBg9uDOCFBUn04MUOW6ABAAFpsNHAH0syOUoZOMAn0hh1XFFJBhy0ccEWYQ6Q + xACEFmrooYRKkAQZJWzBAAdS7CHnJyPQINIMKZCg4CN7xAHoDhIgKuqoiA7qBhkXEJBABpNmchdWBTXB + QgvNSRIHGoOSquuupTKqqgetUoKCAa3FWsB1khhRA6+F7mCqF0m40YMEboS5A6G57moBAAyAUESwjyCw + AqwEzVBAjo8AUQSPJYy6Q7U95OGHHwxUIYMKMkixhgx7fKDCB2kwsAUAXkgQqq5J8BAHG+A2sl1CWSwD + CRBACAEE/wg8MnAoGQC0EccHCQjCYyNxspEAm154gXAPdyQwcsOFIJCCQgUtQcOKEwsBAghG8AzCoDtc + IKQHwGayrgwMdHlwqW4QIAPMhCBQQEAmBaABWItYXEQRQhihc89/pPHmKB7skXSgoqLBAKswD0EDdRBq + CIkQRRhhBNcUFxEnKh7UkAYa1yK6QwkfNHyFAQgt0UQB6VpMMZx1GxFLAhwAkES2zd7B9qQpDFbQCQbU + 2sjWQsBZ+uO0NFACGaWWwIGcZRxAIwQgLhJn3qXnIgUDAJQqQRsv3uU5QSfQMInWuetCOdqGXqCChCMI + kJABekZSMeqbEGGDGhRQoMYNgxxhSf8RHlwQeKFlFo4dAgKY+EMAtTuCvSVBBHGEHSGIUYELG2wghglv + eIMJQsAFBcSgAzlQAiWkwAGVbewDSUqNpQqCBAFoIBKOuwQRjqCEJzzhBmqIgAhHSMII+MAHInTBG7iA + gQVMAgg1sNyh3JCGCLqkDC0ISUEEgBqSDWJ+kSCCEDvowSfQ4QwoLKESlVgBMcihA2dwQiQIwDpD7QB4 + Q4HCgz7XhU0dYkmo21sQo+CED07hCTY4ww1uQIQNLPGNJXSBD8SggA5I0RE1UAHzCEUASV1EAxMsCAS8 + +IkNHiEKUVBCGZ0wBSesEXxUGOEGqPC/CrhRhEmE4wZe4EL5yaD/XVa8wMuokQJYNcEKPoSTKiNRvw0G + YYNCJOMUorBGKR4wBzaggw1y0IEYLCAGc9CDCJp4yTdSQQ6dbAQbLoC5JBCgaNPoAhjmwwIokCIIgnjl + KzmYyEQSAZuOiIIgdOCAPoigmEzkgg4ckQEALE1QBKAGCgTQnRkc4JqvNKQSjsBBImjCBjFwwBtMqEQX + VEAB4GNEDS5wqB0wYBor0CFBDPAMUNQvn/bb5xHA2Ykj2IACctiAC5TogxCooREZyMPG1vCtXSBgeD8Y + wwVtR4mL/qGVNiWFDrhggiW6wAF3VMQetoC5EqyBFynoTzxMwVFUqKEPkVTiC9a5iDX0Dn1b/7DhLTRA + NYUEgKmvWIAclsgHCtguAxY4lB8khwvpFWimjBBjIziqTVjYYAEVUKIJYsCID6S1UG5Q3y0KgJAUfAKb + GK3fLOzAh0yKsALJTITGDOUFrdZCA9I5AVCg9ocjYACdEaiAAxYBAncaKg0g0AUWXMTZQcwhryQUrT8T + UQVQEiqwUKNrLzrQUxKKIbKGAIIK3lmCzbXqCN9sKi/UMNDY5mARzERfPHNbjxw0d4QmsIEi2GDbAbjB + sq1drhhKKAcFIgIIH1AreMOrCwpEdYQOEGci0GAoHjCMvdOYAzqp0AFFcOB8SWhD8vC7iyP0YaQjFAFV + DxHDbHnhqATuxf8TRJBJF+hBEX4t1O8i7IsOXDcCJugvIlJK2fVy2BZzQLAJ5aAIFWQrCa878S5s8ILY + ivgQQtiCobYgY17YoZguEIF/DZWEkPVYF3ogoQvskIgaABjC2FFue6YAWxH2IaGH6J3aPCDXI9sCAyre + wEkRwS+RmdjLsrDDeEeoACkPQgo1qAGcW4rmW9R4hHwY8yEw1rMasLXOtljAe6kwWkQIoQYgQPSfAU0L + HYiAhFxQhBGkIIWdMdoWRHCAb817iLp1TW+XrkUOwnzj4Aqha14Li5uZpITemvDC59UZzwYc6lj0IZMi + eEIi6Ia3WtNCvyMUw4K/SLEu12PVTMpBlTf/UOrgCsJiQ0H2i6IQAhIW+ouOM7avWzHWEcIaEaneNi0w + QEIWY0TbhZC2nDQtwg1EWhEVi/ZN1S0hG3RAB/RWJbrFzYqcGprfAM8eYgNO8Fzsu+AIT3i0k6twXYAz + 3w2PuMQnTvGKW/ziGM+4xlEBxI17nMAH/3goOi7ykpv85ChPucpXzvKWu/zlMC841mKeCQ4FheaemDnO + d14Lm+uc5zCKBtCHToufEz0SPj96zY2u9EbYvOmVeDrUYTR1SjC96ljPuta3zvWu36Kpih1E2LGO2Icj + 9pucCDnGkwtxrxOi7VD3N9ybznC32/3uvlD71vWO9TDyHe9e7/LflT74Oa6DEfBKenbhm37qxU+d1oiP + vOQnT/nKW/7ymM+85jfP+c57/vOgD73oR0/60pv+9KhPvepXz95AAAAh+QQJAwB/ACwAAAAAtgC2AAAH + /4B/goOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6 + u7y9imV/V38aZldYCF0II2VafyR/CH8ovtSf0yRXXRAHNDQBcAEnAg8sJzAzLCwCYwU0KwYkLdDV9JII + KFgrEAFjYz8nPwL+CCOwoMGAYZg8mDGjQIARXTT8wVOvIiEUeEhAKGDlQZaDIEOKHPiDRcMD8ihapKah + yworJwD+YDKyps2AS/6dYLFNIrCVtvAg0JAiXUCaIgkiQfJjRskHY3bOgHFiRpMHTJje/AFmhgEsX4DO + QhEvwEeCIHNefWCFRQEIBv9GHMACBUo2FF1Q1LmyQouBAwFoRHX6QCTNLAFSPBsiltWELjQ6hsyJBA4c + GhBWXNEgbFojYBQldtGyohuSjyIfPChAIlpjVCMCgCmcdmqBA3Wiec7EGAeeL/rK0TZI80SBFhJfj2pB + A0kTkEwD/JWochTFFqXDDDc4w8qB6so5jUjxQyt3dl3+4GBFkUSKAE4PLjlhpU74TSQMNMl5EEaBFWHN + 8gUUBjzwnEFILBFAcvdRgsIK8RVE0xgpaOBaLcBckUJUID2QQoOTjGAFfwIxwQQcBuCwmy4krBCAeQUJ + A6IjGhgwA4xMNHECBAz6AoQGLQhgEA0rzogIHiJiVZD/cwZA0UkGMsiwBxAJqKDCHn/skQAQggiBCR4o + HBDfDEUaaQgCB7CAFE4/HKdJFQzcAUAJdPJgQRJJkOGFFztYsMUFALTxgZWCcFkJDgX8cICZiuBBg0wF + WQFBJhzcOcCleF6q6aacJnGpFyVswcAaVVjyDKOI1BEAcTPQAN4kQIDwRxyc1mrrrZ4OwAMABOyBJaqY + 4FBHFjA2MYYW61ECRBF/FCFFEVXcKu20m0ogAQAMqABsJROsAIeEq2nxEyRCcAkEEFKAYAQINUiR66Z5 + ukEGnhZ4QcYASezwLrUDeAFAAzVsG0kKkAYERgoXRlJEESAUIYTDRkT8hwUDSMDD/wUEMPDBBw2oIAMQ + GajQQBVVcJBGGnn0QMa91ErgBQelCrxIjax2MUEkRpR77rJFGFHEuT7/sUYChBjhiAdS/PGBH230IMEO + 06Jxx68yG4JCAQWHYYWTkizLpc4Le+lJDR54QMAFXuBraxIWEJBB1RfRYNASBXwxbiPnFvqw2IaSwsYH + ALixr6ZJ9MCArFVfYYBBDwSQcCRgt5JAGyXgusUaMqNAcIkPGPD4I1/n/UoCH6ABda1upPE2qnikoORM + SBhQZiM62wJCA1tIUGsSJTSAagsFGzf7IeYOIjouDFReKxkEGDmBFsGnYEYkhh6fSwJxzNvpBUk3iIU/ + BRkgI/8jxZMSRCcgJADA6Zv2IIPYr5Egt0BLWFFJ35gQcQQRQRwRxRFTmMIN/sCHEHBBDw7ogA6mUIk4 + pI1TO/hA98SCAhoMJwxj6BHeNBEE/fnPCU54wg2ccIMbTOEJdPjDBiLAQh+4QAwiUEAHKKECAAxuB36A + 30ogcII1jcE+qjjfH/TnQSUI8IQ2OMMTzmADFjrRiT7YgAm44AA7RCIDaWDfpXaQBrFgIUJcacHNyLeJ + IJjRjETgHxGVAMIAlvAJOXiiHJ1IhRAoQA1PeIQQPvBATUngDivBgZAEEoYVJKsUZ+xg/47ASEYqIQqP + BCEJb3CEGMzxkizcwAvUAIkqoKH/UwQIWD0gICEaTM8R+MtfGpXgwTSeT5FC/IMTOuAAPcjhDRXYgA8w + GQEX8GGGjpABGvaVBD+Ikhok2A4cxrdBDprxD7GEhBNyMIc+vGGXl/QBFbhAgWACgFMSaF41wIeTEYzi + lc88YydukAMHiIAKmDSBAnTQiARcYF9kYEA1IMWEAjAGkWfkHyh0sAAumMAFlxRBB47ACPVxigxsoMYQ + EtWUz3HwFTrAADznuAEHMHQRRVCepnpAtV5ggQVA/MQRYhlNVExBDyucoxwGuIgE8IBTeVgd3BTR0lUQ + QQdcuKQJcsCIBvSgWmnQ4U5zQQcHmACbLaxADBjBAd1pygK+/1tqLyggAoQ+sQIOWEQN4vCuJHjhmFrV + RRT6sFEnVmAOiwCBDTcVyrT2Yg4xpeMCanpTTZHhA3btRQcqIEcqADMRDGDZpQBQ0sDiQg0mkGMFiJoI + D7ShWnFwLC/sENknhsAGisiAGzblBqNpVhdqIOwTuUAERTBgXwyY4GlvQYG2sjCsiajBJzXFA8wBq6f0 + wOsTXcBJxCo2CYCcrS70ANUIvCG037yqbJVrCxE80QcKUAQbyhoHpVJ3FjZQLQsrYEVECKEE70ID0b57 + iwV4lYVccK1iJaBP9triBkF14gYOawiHagoAIALuazpgWxEwEBEM2BQZdKocAb8GA0/cwP9UEbEHq16K + Acyyby3sIIbVHvgQc10sg8XiYOW8AKqGRSz7LKCtBqNKB3mNgAIEXIW+VkycGq5FflkohhQewgN5INwW + cmwLNciRv4QowgcUbNqVlLhBZ3gDFONLYQsPIGa2SCUi0rmtICgAihVQhI0HUN/GPFk5HcirVBMRZE2V + gMi1OIN1W6iHRHDgUmQoQWad3Nozh6cPUKXyjz8wYjjPwgF5fQNlEVGDdtVAy4ZuhQ7E64NuIkIKmJZC + Dbwb6VZ02IkTPgQIpGCEdkG6F67cqQigqgAlmDfTDbMIOqsWBD2sNhGxihgION1pVRBhDk98LiKAIAQh + ROzUvU6FJZ3/aAJFPCxiGU62KxaQVxPQ9BBCAEHDeC3tU8RAvCYo7rBr1+1WdODTETABkguxM26XmxQ5 + QHcF1m08c7n73aIILx3FbYiFIRvfpKBDXjdAT/P+2xXW+24T9etqgN/CyHRcRLEdvgoO6zICVHB2oW5R + vhzbgN/VOPhs/UzxXoi85ChPucotQfKVu/zlMI+5zGdO85rb/OY4z7nOd87znvv850APutCHTvSiW+Kf + RucNY5CedEwwvelQj8UQlh71S/zz6VXPeiqwrvVHTF0QXO/6IpAedrEz4utmjwTa0w6JsrM9EW5/u9xp + 3tpBtNzsahRiOu/+dkUS4pls53vfUy0IUMDP/fCIT7ziF8/4Xp/c7NXD3+OhruWEH37yjf8D5rveccaX + S/P3lvvEM0/60pv+9KhPvepXz/rWu/71sI+97GdP+9rb/va4z73ud8/7ngcCACH5BAkDAH8ALAAAAAC2 + ALYAAAf/gH+Cg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp+goaKjpKWmp6ipqqusra6vsLGys7S1 + tre4ubq7vL2IZX8TKH8aZQhdOF1fGshdf18oeHh/wL7WnTjEI1AHKQZWVjQnYywnAmEscDBWMwVjEDQj + K2ZQf9nX+I/TKF0r8DDlfpz48QMJQYJMDipU+AAJCzA0ChyA8oVavouFcLRoAQHOjBkElywcSbKkyAdM + yhkwAMXMNIy+EKCAYmAMGJAlc+rUmXAgjXgI7sG8paGOARoPfoTZ+aMJQZAzWDQZcwIOiwdjfsD4gZIp + waQBaNQpI3QorC8pAsBJWjLhjxkw/yBGbLFiBYI6WDSMwNNFA5QRWCCMKACBBQ0kcLj+cDsSZQADzoaY + ZVWGRACpTkeKRMciwIoWdcyguCKoWiJgwPBMQIBlxIGfD0AuJXkiCw0SGiajwoOFXUGSD2DACdBlm6AJ + nBD86VInBbmmJW2vGKZb1AQsAQaKHHmCRooWFUshxw3BSlaDI7OwGFHGdHVNQywPbMxkTIovCMyskqxB + w4p0OdHQBWnvZYIADTgtFBsNELwki14QPNDVQmAUUEeBlpiRAguLLTROAS04aIsGabGlUBhwpJAbhpCg + 8NpvCpljgBYi5kJCHWMsgd5BD7DQAouNVAbBDCYu9oAALNW4C/8whc13UBhM0KAkkIJI1kV2CsJRABTU + eSJEDRkkIEMVMmQgBSdffEMSDM5QWYgZLYCxEBInBFBHWZkU8UceEkiQRBIS7OBGD2gAAEAedxDwwR6Y + lEFTgged4CYhX4ijUEJjzKMJEEIA8YcRZ+YxwKiklkqqBGRY4AUAccgghBRCTEJPAIw9oMWkf8xkBRKM + vUUDgZYAUYQQnYJaBKh/3GHqssv+mQQZF3yQAKORALNCZgbg+scBVsxGUBhjcFmJECD8wamwIAhRxLEg + lEsAs/DCK8EFDKxhhCQkjGEFrnis4CRBWWxJCRCe/kEsIccaQbAR5cZxKqpkuLHDDvEy60b/HhxQCwkJ + kyKwQpFLNAHBipcQ3Kmn6hbhKcF/gFmDB1J4kEAVDXAQRxp35LGFBUlUPGoSWxCQgbaOmGEApPWtgAnK + nKqMSQJsqMBBHj38DG8SPLRRA9GKHFhkEwFwLEnBBhNsNsucvJwBA1vsIMHVXqTB9SFDpMDrt01YUUwk + Kw9i9ilAMFACz8wm4QUHcw+CAASZfVUAyY2QTYjkqcjQBhpvLytBCa5yjYABRZ5ggHKT9B1LDXEAkHmp + fxKgsZsTHN1rCng6QvksRnAAQM/L8sCGnlTiAUEWMRYgme3WePBBCYXH4QGVLcywnUAFkE5lAgyQwewF + MrCIBaRIqKgt/xAJ7L5sCSpgaIVCTfzKdyhBxE/EEfMfQf8fQRBxSQ0cuME7qYerDh5ScCkrhKcV8Utg + EAQRBPopwQlOmMITjuCEBzrhCAMr3/9GRYY43C4fLSgSCyDnivzJjwgozJ/9pnADFp5Bgjf4Axde0IFJ + pIFipdoBAT54jZGMQBUL1J8hTKiEIxTRfkogQhQg+AQb3OAJZ3DCBiIQgQr0oYaQ4IAFTCUBApilBfNB + QrZKIURCmFCB+Eug/ZAYhSg8cApOuIEcozAHKtpxAyKYgw0eoQIemEqHZsHB+gJQO1AQYYGHyF8ZE7nA + ILgxCnKMoRzsaEcfVIALWGyEDJiXQy+aBf8CXSpF/Bh4Cfkp4Q9TpCQlNyAHCjgiAVv4ox8Sp4szOOAN + qqzkBvRwhkZkAACmIgPiaKmLHGDABD7IpQv4kElF7CGWpfJCFYipCyLkQAEmcIEyFYBIZ3KSVDyg5i6U + QAEMaFOVrLQDI2TgR1IlAQDi5IUNXkCFXJogB4xYg/bcGYd47uIGDqhALiswBwwq4gMblED3/FnLF6TS + jhVYACPeVaoePI+h3azFExRwTju6wAGLkEIJNkiAMzFUFx0wgSqp4IBFGiIB+/zZGnh4UlmkFJ3NPAQD + cDgqAAytprmwgUpXqQZFgACYpeIA8IB6Cx2EQJVv0IEiZOCFUvFgmlz/y+g1ciAGSvpABItIw+oGQIBY + MRUXangoFRWgiBpAc1Q9YMNZc7GAh/pgAzktxE5L1QZcjXIyCkimHd8QQ0R4AKmj4kECJqXVofBBlXo4 + 6P+SIDcWNXYydhCoR/eIiAxcwKpbw9BfCzSHjkaAC5Il1Q6GaVkWiUCwEXCBKxGRgG8CzRc0TcRlh2IH + 2EZABE9ABAgYkMPXmWW0QOqDKouKiD1MlgEFSiCVzlBPO8ohEUX4LKlKMNdd6AG2LpAqIhrAutB29xZ0 + UCsGFMHTAXzArEM5JNGUa0cxFPYQ5hvVBcyLEUTutkA5AO8cEsGA1Vlgsbr573tu8FQ79iEKiJCB/xvc + uYZb5Naf34WoIto5Ktae1xZ2eKgLYpAI7Y4qDyb9sC2GulaXDsIPq9sCglVMiyjogZJ8MKghPjBhuFaY + xrVwQEcrcN9CVIHDO/gAkGtxho5ugMSH+OWpZrnkWdgAl3aU6CFqIKqf3aHKtJgkFV3Qh0RQtKe1QNuH + MUBJ1CKCA6XiLphlUUc78iG4hyAvqXowZ1ksALZiSEQVWIeLC8eTApqNwBs4awi3AuACeaDyLFhmaHHq + YMjq7LMvKFDdCGzACYmogailwF9NsyIHLBZDprfMMFGb+hVHeOgGZnsIKdi6Bil+9SrS6tFeIoJhti6X + rlnRgUSLgQ7YXRcI7v817F0/1ATMPQSxjgXfZqOiA4D2tbQZZoRqW9sUgR2sIoRgBCM47dunCII57fgC + RZwN3ai4ARdgqwBQI6JgnYK3KXQggjuCFBEHK5u+S6GDrlIxoolQV6UHrokYwLYCq2b4K25sZ0YsXOKX + wDIVI5vwk2F8FKqk9SEu/nFL2EEPKt1AyWehgwGvHBYK9tvLZ07zl8e85jjPuc53zvOe+/znQA+60IdO + 9KIb/ehIT/onjqf0SxyP6U2PuiugLnVKDEEyV696JbCu9UlQveuQyDrYJcH0r8czf1Qy+9nRjj/diH2u + /r05L95e08Y2Uu64UPvZUcjIsT+ikYn0OyXwLvhLwhv+8IhPvOIXz/jGE53kSicb2iAfdco33vJIR1u+ + MR/5YZmL844PvehHT/rSm/70qE+96lfP+ta7/vWwj73sZ0/72tv+9rhXfCAAACH5BAkDAH8ALAAAAAC2 + ALYAAAf/gH+Cg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp+goaKjpKWmp6ipqqusra6vsLGys7S1 + tre4ubqNQ4K9u8C1Ewh/CFg4GiMIUF14I8dQxTh/KMHWn2V/eFhYWisFKQVjVlZgY2MPYyxN5WMFLAY0 + ByN1E1/a1/mSZSQjXSssBAg4seQBkh8IEypMGAYhEyYzfrCAQSPFCigkqOnbaAgFgisHAggYcwLhwYUo + U6o8GFHkgRZlzHDMN4HEgQM0YJhUyRPhkp4qT4ShEUALlpm7cNQpYAXGA6A/f5xo8gNGlhNjZpywkmXG + GCROpf6IqpLJj6dWApCI9gtpLA0r/7I2OYmS6g8wcGYESJHCQIsRB76QaIFAQx0EXepgMVAnXAEYVn5E + BLq1QGG3r7QYmNHQrMKoWeCMu9gimkdBeARlM7R6mgYzg1sEoPFAJ12FZlnIw4cZ1VK7KB8weQCvRYuM + f1ZnqqbhywEIY+DwFC7vXm9SBwrwPAEmbRdi1UZN+IMFQbgTJVOaO1Bm/HVPLbSrBBPAQGBXV66EG47y + YIEWV7ynSRlaFGBQSiwU8IxMsQyBQhdM/XAbQjAEMMIfbQkYyQQapLAOWQiFIYABJCCQmi0IIAABC5Mp + ZJABZpyo4SM4jECDUAs1EQAEV+Cg3C29QCGbhChZUUeAMzpiAP8LniX0QH0I4JDhLtVAIEAWKMFQgBZJ + LmJjkwilk8IXDHKExQEC/ABmOgd0eYgZBuikUBMP0KBMJ0AIIUiegggBwh959FDCBW0w0EAVGdRgCQo4 + pPAAcD+EcUIBPyZZBgIGnDDhiEhaAoQgIBSRpxBGFCFqqUJIIcUfJQzgqqsSkIFGHnFUcUkLXC20xBid + JmnjU3MWoIEmn/4BhKjGAmGEEaQua4SiXrwq7atJuAEAAWvoKQkJ0KE0QxdJonAAky4GsMInQOTJpxBF + GPEpCEb8Sca09MLqBQBxrOFBJDhAQUNK4QnYwgx0LdFEAV8EHMmnxRrrsBDpivqpEOzqCUT/qH/Uq/Gr + blyggqKPDKFiQwmNQcx7CBzQIkIzFNDrIw073Ge6NKfLiAwNMJDGBSV4QYYESWzsag8MSKIFlndBMeVM + Q1yRKW4CHLD0woTYfIkUCajgxwU9CO0qGW3s+4gGJEWDcgozNLmEWpVSvWcoQGTAwQVeBF1vEl60kQEk + K7Q90xU3LmQFCX7jAoQHbDBAt93TSoAGA3u4mUgZBTTRZBY0nDzTGm14IcHdAKjwp+SE4OGoQlmkMKwk + McvCARoa70BA5KQLAkGOBqwu4BpbaIyGDLUPrNAJBkyTpAcN9E6vBH5IvgLJCaUgpeQJMND1tEkAAPKM + dQRb+IxrXLAD//Y9sNHlCglZUWYtQQThCQN1T+vGB12O8IAAuquiBCHuE1FI+0Ro3x/ad4QAViIBAGDc + 15qXpOa4wn+FIAIECRFAAQahgEqIQgEpkYbPSUsCBGjddaaGCvcNcBDtS+EAgyDBIxQwgEeIghOmcAQW + SqIB45NWEgiwqtqxwoQUdJ8Qg6CEIxSRCBh8whlkaEQgNkIG0ZqWH3row1uw0IVGdOEUnjCFG9zACU94 + AiRk0KppMaAIVdyFBKOgBCfM8AY2eMINiKADEdjBETIAAPY4kMZgECEKMpSjF//AhQj4AAOOQGDjGtBH + SzhRFERQghJv8IcYuCACmDTBHBqRAeW9yv8CtmokMIj4hCOYAJOo3EAfdMCIBJTxVSXYmyj9uAFUotIF + cqDABBFRBR7o8AJonCUwpvACW2LSByFQAyNUYAEdFk2Yh3gkLDrwBmNGgAoLYAQHcuiqHZgPmsC4AQZq + aUsXKECMimiDAtGwPWFKkxY3cIAYfGDLCjiAEVtQYBrAeUJdKGEBYjCmC+6piBrM61Xe5Gcw7FDNcmZT + ER+Y1hZEKcB8TEEEl0RlBShQ0AtMi48U1UcO+GDMCtwxEVXg5gAsILaNiFARQKzoNegQAlv6QASKAIIf + dEiAKsqUIzo4pS0RmYgMvHKltFMoMGJATkxuoAOKYIAHB5CEOyjVGnP/oCcqxXCGRNTAkwPoQQLcZMP3 + ENOmREXEB1TKwC79FDNKEComXaBMREjhqCUYK1k1ZElbiuAIifiAAhkJjJfOspCo9EEMElGE67nqAi29 + qi5s0NQIvGGXhSCADpMqWV3owaZQRcQeVPrMzuriBhXwK2P1CEvTAkMBWo2ACzh6CCE0QFo74KxrbXGD + yr4gEQlww6skUNrd3qKYqXznH2rg0VcBwLi5UENGMblYRDCAcTyQJXRtUVNUymF/h2Dmq8hAv1tYzbQK + SOwGnICIGhy1rdulhQ1iGwHaHqK5rsoDFeM7C7lGQA+JiMNU82oLmxmWnxiIbQjAa4iUIhR4/KVF/wdi + uwF0HkKlEI6wLKZQ2RwkwpevKq+GZSFXHxDUECBgLVX3OeJYKAG5mPztIaSgWVdlr8WySC8qcYoIDkir + BDiOhQNiywdKHiKir0JDkGHBVI0a2RAfmCo7l+wKHcSWCoA98kEHwIMMU1kVOWgqFVh5iAY0c2hr+DIr + ckCFVNbVEGw480rTrGZVPKGpLrABIoI73m/WGRVhRiUV7FuIDGx5B17+cynOENBjktkQHpiqBHSr6FFY + WaN6PoQHPji6SpeCAm3G5Jj3jFtPn4IC0zUBgwshgw+a2hRDRuUbnlyIISRgDR+IQ3FfHYpYY1IOjK1B + DYLJ61FMAbGGBDAijP+gqhpIodPF/gQdRGDLExuC2cyugRGiHYoghDoCGzjpIYogBWdL4cDcvsQCbCmG + N18bBCB4NrrTTQki6GG6b5hCIii2LGLTexM3EEFsFZCIPLWLWf/uxA2+vYGHHuJYUljWvBMeCR1jUgwe + LjjFtEXxTDyBD7GVQxRySrOOa2IBqZ1rdRFhYI6bvBL2xvejDaEsiP3B5S+fRFBviQH2FnziOW+EAqZL + hZUHPRQ3aLQhReBzltv86JXoA30d/vBiAR3qhxA4KkOAdVI4ILUuCG3XR6EHHud07I4UBK3RzvZrKLft + cI+73OdO97rb/e54z7ve9370t5OOhJJTYRp7AXiO0kHQ73z/H2YR75bC146FMWU80zDk+EYaMPGPEOIA + Mdv43Ur+GkOofGc/rwvRK/St+Qi96TFPiNCzPhKufz0kVi/72tv+9rjPve53b42rj933tY+Z1avG+6oB + 3+5Pl1nBXz8qY2mrYccvvvSnT/3qW//62M++9rfP/e57//vgD7/4x0/+8pv//OhP//QDAQAh+QQJAwB/ + ACwAAAAAtgC2AAAH/4B/goOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2u + r7CxsrO0tba3uLm6jUOCZbvAsr1/Q2aCX1gIVy1aCHUjCFpYf18af8bEwdqeCAhmGgcpKytWAgFWMDMC + MCcCY1kBATAFKTQjK1oo09v8kWV4f8qMgEDDQIAZTU7M+PGjyRKGYRg+ZEgRScMTPwSwsLKiwJcuEwL2 + G1kIAQksLQwIQHLihMUfEynKnElz5oOGLE4Y8LiP5LYyJFYYtIKxptGYRpPKHDPjgIEJCHzqQtCChoAZ + M14eZZilyY8sTNuNOTFmTBMYLH60/BFRKUMk8f+gQBEpVdYXlSea3Ex6As6MjRAIrsAy4gAJDSOajWix + DEKXApBPEFWr9EGTAB6j1m2FQ0sAFkyWIKX44AQTAQVaHDAMEMGwkHQJ/fqD448GEjggjCggwArlmg/L + YSGxORWCA+hg0mTygEUAGhBa4JlQBgUna12cshjzY+/MMA8K/rFeXNSVFTQctp0Jg8aBOlCslUIgcIU8 + jExmWoR+pbynIRq0UIBlo7EVgAFfXIECQKvgRo9ey80ABxRf+JfJPxoUkFNNJ6RwQGyvAHQABDMUNdMJ + 7mVjISXLBOAdRUzAAYEWuXRTT0MzJZSCGeStCEkXViyk34HY7ILCBBAEYKL/RD8EcIBmPi4yARYQvMiQ + ZBAs2A8WWqRDEwwBVBilIiPQkIVNLAzW40gIGBSaTA9kkc+YhxwwhpVgBNCCGbNxAoQgIADxpxBCCCIo + JyggkEJeOa4gJp1DfJGCVzOBYRgpQBTxB6FFFCEEEEb8WQQIfxDAgAyV9HIADUv+gIQ9dKIABQ3rMdSe + fJb8eeifhwDx6R+CguCpFCAIQewfOwwwABkAxFFFoZKQ0IKQS30YZQtWPJAfQw9Y0UJtmug6iK+Hfkro + oZ16OioINSSg7LvLlkDAGh7w6ggeV9y5LUMzGLDiFRDAMRMTAUCBwjCS2AvswuMKqqugvwKbaaBAgGDE + /x8fwAuvBD3koYIkOBQAg000+DeEAa3OkAKunSgMiRCaAqDxzAN4QUAVUjyCBzk0BVAcCgacyRBzAlhb + icudrJGHF0nQ/K4EPPihqSNlzDrwGHWF3PMI4B5dSg0fXNCDBE4PsEMbVTgyxBUp0NSFVFXK1AQNc/FT + RAJhW9D0zEmgwcEjE6wgUwA99WOFVt0ZsGY/e6iQhhdll9DAIyswVwCUIwUw0+X+NQAAGTST0UYCjrQQ + wOIj0XClAQyWN8QeHJSwt8YlpN0IccWpnkKfPqogM99p0IlICv0Jn0AcTGssAQC2C59LEJ8kcAHNPDTv + vC1HEAL9Jg3wMPMOH1yPy//2f0BPfvmWrAHA7Mru4If4tpz/BxHnyy8JAewPIIEfOcNfy/ZBIAL6BBFA + 9NmPESqAnMYI4D9SHDAR5AtCAMlHP/MRQYCQUEEJZha8BuKiguWj3wXnd4QRPiIDaNBYEjroQUs8UBMS + DMIRZnhBIkRBCRhsBAh+9zQOTK2Fk3ghJ2SohCME8AhOcIISHlEDHipLApMDoi6OSMMjPOEGMxTiIDKw + PniRwXpSPEQEVxFAJRRxCjdwwhNu2IgabBBeXthDGBEhwVgEoYhJnAIdnuCEKDTCAwp8FwAuNkdD1DEW + RJiCIs9wBjROQQeMYIMb4JWEOCBtM5dcRAS1eAolRMH/CTcIpQD7MAdGfCBZ79rBGgo5iDHK4o6hnIIT + 9LCBCCiAEfiDFxo8EMb63UKGTziDAiJATFsywokDYKEHCxiMIJzBBcUkph4W4QHQpXKVLTTfNt4QzQi4 + 4JaKYAD7ttC/bPJDBN2swBxeaAQnJuFvrAyGHLppAjUoIgGTfFcPMhBPYEwBndHkwyL8wD5L9nMXduBD + N/ugCCD0AF47IORBc9EBMUTTBw5QRMbetcKJ7sIB9DyDIt6oLC+QzqO5wEA3X6AIFcyuktBC6S0UGs0Y + JEIKJB0AD3gp01t0oJbFFGgiOMC+jwUjkx5UaTRLiQgPPFRZSdiCNpDqQYsW0wRO/0gEAeBlATD2dBYg + LaYPmHqIPVhTWQzYxaH6GQUTiNUEfkSEE0sw1X4uIJou6EAiNqosMvDzq7a4gVWJKYdEyCCQA0grYG0x + zGJuYAqJ2MLsLlCDxdbCBtAsJlkNwQF4ueGvlp0FQIkp1EPI4KVeDa0r7lpMF9wAETVIIVQZqFpZKCGz + xFxAIvIALwDUdhY0JSZLESHOd6EBtL91hQJ8cFXDkg2qJ02uK3KAVzogIgNnTUJqpYuKIACVmDYtKw/3 + x91XcLOY4DyEE9tQXlf0IZpcSMQdZpeHyrZ3FWElZgjoyAB4lUCi90VFDKJZgQc2AI4BXgV1HQvZQ5zy + XTtNcP8qbsBcYrrAuodYw1l7sF0JgyIIuI0AJA9Rg9ntILoeLsV3RYyIBLyUVCk2xYpHbIg15HMAbkBx + jENxhA1UmMWHqEIgvWDUHYviBt/1gQ2aelYyYNPIodCBj4m5gSUfwgOU5CmUQaGG71bAyjWeHRm2LIqf + VlgMYC4EB1CpU/uS2RMxwK0JMGwIBrB5Czp+sybyG4EQLPEQxVUWAOSo5068AL6IAMFWoQoAqhZ6Em5F + LyKKwFuo3uHRnLDBd11AgUSQNAnvw7QmFuBlkSLirAMosqgvoQDchuC1h3AxR7W8aktwIZovyGEh+vsu + L9QaE3SowFITkYA78KBpvv21Jfj/TAVYH2JqUljDk5UtiSOMNgLxTUQNti0FAFM7EhQQNpU3Wwgh1MAI + Ukj3tymx3GKKwZ6IMBaxagDjdUPCBoONQB+ekAgjgCDdobJ3JBpLzArkIBG+KgK6yynwRtiADxX2gQiy + ighfCcEIAW+4IxSw4owm4uIW+6HGFxFusYaA4hVXeKdGzggiHLqYVCC3IRzmaJYTYQFUiKYI6Nyrh7Gc + 5BB3bHgrboRP+ernisDAjzcwzUWsteYad4C4SQtvpFsiBivewBz+XHFCWV0R+XYBBkyNcEN9HRE5DyrZ + z06JG5zXBB3QItTPLoIKdJoRc7/eIbWxPQdkr7b0A4YvuctMobZbIvADNPzhOal4Rwy+8ZlgPOTF2ErJ + T96QgtD15TfP+X5YniQIi+fn+xH6zi+i9KbnxTBQn3pE9GIIrG89IWIv+0LAHva1P70gcJ97RfC+966n + PfCJIfzhG//4yP923lsvLokl//mG8tS4CrFWhjWU7Q6LGPQJYS+XLX/74A+/+MdP/vKb//zoT7/618/+ + 9rv//fCPv/znT//62//+tggEACH5BAkDAH8ALAAAAAC2ALYAAAf/gH+Cg4SFhoeIiYqLjI2Oj5CRkpOU + lZaXmJmam5ydnp+goaKjpKWmp6ipqqusra6vsLGys7S1tre4ubqNZYK9fxO+gkO7xajEfyh/Ggg4LQgj + KyQHK10rK1AtLVcaWAiCysbimr1lVzgrWCkpBWABMzNjPycw82BLJ3BZM1YBVjQtqGEpMyHcuIOPSGgw + sIJFgAcPTjBp8uPHkooYmVTU+IPjEiQWwZzgZyAgFGQIUxL6giPFCjBjmHDESLOmzZs2Z8C0cuCLGRTB + VBYj2OWAlTEUcdoMUxHkj6ROLyqtmHQGjRV1fAq9FazOCBZjljyYCnJJlh8sdNKAWWBMABpj/9zCyJK2 + 4oOZOB+woJFixJetszSMaHdCKZOxMOCMSUEj2rYROHBAKYgFBwooV6C1GNHibQEWD5CMxcnkxBgB2AC7 + wjICBguLNxELoEFN8p8hvx4F1WDmihYDNNo2uSiV5gO6KboYVE0KR5kCAZSGadJvxIFloBBogKLlM8Sk + NJs8gEOjyzfmorQckGfzIpwZKyBM0GDqF4IWBazAKFxT9Jjy56G3CR5/QMACfzWNlEILGhDYygRYHJCC + FWC094AABmjhoICXIFAHDT84RRNdLdQBzCwIZFMAHCJilIUAddDHYSVQ0PBaTRSlAEEZy9GCwhV1GACa + TVkE0MWMkpTRwv8JCGLEghVd4GAMHmYEeaBND0AABZKN4KGOTRQVECNCQ5jRQgosgEcVamZwmQgCK1hh + 0wkCQPDHhild0YIAM+AIHwK5uSnIFwXUUxMLqX0CBCKL/lFEJxoccCNNJxRwpKCCaDFGkyEGcEWbojRK + SKNGCLGoEEJogoCNNiEKKpctZNEiEnAYwImoo/4h6qK7PopqEaYCkaolKHRBw2gYnQABngKu0JFxNJgY + 6iHB/hGsqYIIAQKqIAhbBAh/1CDJfDTIOqIBV8yYQk4r/LUJrokAwauu8gJRhLDWGlFEEVIUYYQUQCQw + AAANSIIABALUxER5QalmBV5oRTmLvIMI8a3/qSAYIW4eA3RsAQEJRELCsTM9ACV6AhTHhBUINHyLsKka + 8e8fZHRssxt5qAAJCgU8UFwTAoyAHogV0YAQEEb8wYHNTCfhRRoyDMuIBinMgBcMLTBHwmu2CsWBBEw3 + jQYDj5SxwhgiIsECFsyhsAJzDPAQNtNofPAoIziMwB5GM3ThMqbGqADADnMPsMMdezSCwleHygj4OFKo + cAEZSYSdRAk6N0JCwhn1+LgxGXBQQuEDtJH4IkN00edhWnwuVA1xWDC3BBd40AgWaTnuukpS3FFz2BYU + zMgIr+4ulAcMyA78B4ygZHwrRARxiRQXEB42Ac+bIr0h2ysSRPfdRwJC/xyVM70D9tmPEn4k4P+x/iMq + 9DD3HelnEv73nQRBRCVsyN30HeJ6HrwkgT9BvK8S3YveIAroiBoAoHw2Q1/92EeIA26Cge6LhAcAMDcJ + TtAR+lug+hiIPwse4gJh2wEHPrgIDG7PhBcsYPSkB0NCZICDTJNAFVioCAUacBX6C+IfiLC/RuDQZj0I + GQ8RUcNSfE8JRCTCEYq4iASgIWwAWOIhMOgKJRxhikH4YiNk8LsIajEXYQTjEZwARUaoAGw220HmzngL + KX5RCVNQAiOE4AcIDqAHAaSjLY7gxSM84QY+VMQRO9YGQd4ijFFY4w2cEAUqIqIGyuuYHB15iyNEgf+S + N7iBEvSoiA/AsWNokAInbUHJKTzBBq6sIQqZRjahUOxzkLzBGQ55g0XswQ1McwO4bLm7IEThDKGkwx/U + 0MtELI1pflilLYhwyCf8wQEukIMTEgEC/3WMDEocxy2zd0g5ROCcDlCECq5HzOcFQQznPGcF1KCI0d0s + A9K0BQZcEM8IiMCEDfBjHPJpCz70cwMOsGAR7NkxHtiOoLOwQwX6GYIcJCKgNksC8yA6CwX4IJ4ItWQh + Mjmwu3EUFjbgw0cj4IMQ6CARaYCgBB56Ulg4gArxdMEcEuEB63WsljV9hQ5C0E8T2CARi+RBUGOBzZym + ExENyGE4l8qKM5ggpy//SEQNyigBD1J1FU09JxVeegggzLJjFwjkV1WhhqvGUwGJIJ/NyGDStabiBiLo + pwgSkQGfJmENdmVFDDYQTypYFBHyM2NgVWEHt7L0qYYwQhuYlsXF3jWv8exDXCHoBcuqIqwRMIEyDyGw + OMrAs6iIAU7lSQFEJICkgEWtKXSw2ghsoAOMuqLNBipbU2D2nHA9BAjOOoA0DLC3n+hDP7OKiDRQ9rjI + 7YQC9LpZm20hadEVxQKKmoh12swLp8suKHLAz3Nu4KiHaMApLSBeUVBgAyutwGENIQOfWuC07f1EDggr + VrLSV6ZTze8mnuCClfpgtIaoQibJgE8B56+2PqAn/7V8SoY5OlgTOpioeXF7iCr4NbwXzkQOamtYRMgg + kxYIcIgtYYPy2raZhtjDKcnAhhVj+KAWVIFM1WrjSlCgn1SIAlTLCMgeY2IOK43AG4R8CB3bDA0NNnIl + 9NBPOZDSEAxgGg9UKeVKmDOeGEhEHiB4gS5bAp7xXMAliZsGM1PCCS6OgB0QAYIjSiCabpbEj0HK5EOU + UaN5lgSV4xmCRFShaSoO9CJMkGQ9JKKPSFQ0JOzA3wi4gMOGkMKYbXYBqUl6EdONZwVgXIgMbCGjfhjm + pxe93ESceK4bXbUiOuBiH8QAEUL4ANO8gF9ZJ+LL8twmIjhmMwB42teFsEGlI/8Q5kT82avIJsSgz+kC + /xrCux1LQqKjrWzqJoKhA0BDtBGBgX66oLXOTOwAeDtuQpDX24i42xqqx+N2A9u26EaEFGpQg7q2exBz + 6GcEmMuoGvxr38ced4aBbG1DCEEKIABBDbgMOJEKRQRJ9gFk6QwCKXjc327iIkKcMO1zioDUhvDWv7Ar + KBkCZg7LrgB6GWUxf5XqcQpsYi4ooOF4bjzeUpBZwrlEwpTEoOfn5EIj7OUv6GJK5LqIgWNZygdhK6Je + 43SnOIjQAaL2swL5ZtS96PVBncOiA1OPABXCTvNU4St9NDR7K24qcDFg+hFOx6XcV/ECgYd2AU18+7// + cAOkgfugAmpeuq4G/4cnKDeeJrg14yVxA6/zoeFrhboq1kcBFzQbtXtHReInT/rSm/70qE+96lcvCmQ4 + j/WIcD3sY//62cf+NrZvXu4LMYTa734Yv2+E73/fe4jm3RjFJ+jxkS/NrA9i+aYXVqMGCH3TY6sQu/p9 + 9p9f/eCn3Pbd9774x0/+8pv//OhPv/rXz/72u//98I+//OdP//rb//74z7/qAwEAIfkECQMAfwAsAAAA + ALYAtgAAB/+Af4KDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKz + tLW2t7i5upFlhEO7wK54fxp/XxpfdQgHWiMrGi0jGtJmJL8ogr/B25kTf1d4XV0rBjRWAScCTTBgP3A/ + J3BMLCwzAVZWBisrWGYI2NwCQsLxR1yBAnDG/JjBpMmPhz+YQJxIcQkTJidmnBiTIoWBfwgEijSEh0QX + GgUetFtCsaXLlw8lwoMXoMCBEYJ6jdzWZYQAK0we/GAJc6JMmQ+JFoWIBMwMAQewlCG4E5eWLmMULh06 + E0xGAScCsDhnb0yWMScezHjoECbRGSn/Vmi5UnXWlSsBBCBxG/QHCzg0aEBoceBKCzxYNJTBQozEHy1Q + SBw4sKKAgAAwfjzYCzMdjQNf6gqDkBLmXjhwC0CpM6QYwEcTfmkggaDFwQCbObdUmc+xaFRfRsA5AbMJ + YAMkoPwZ5umfFghWxrxz2eTBmAKMf4+6AiEATJUGDKAoppMUjp4pgHKdiOQBnBTKtXfq1aKeyyUnPKKg + uqoMAjx10DADEm0x9QALBsQnHyYIQFHAehM1YUUBV5hRCwkpCPCAUBOFsRFoC1qihQHTUXQCC11khwt3 + NKRVERwBkMBfiI4MscIYTSD10AmCcYNAZVlwCFEYY0AwI42KaIAO/0VhMGHFCKEJZMYBLer2EBJWkFAe + kofUMUMYJsIAwR/e7GTGChq29F5IXBpigEsspKCiJ0AcUucnGqyQhVI/hNEEDVi8xiUKArS0BA1dHNnJ + nXYawqiIBjyg4wMBtNCmIN4ZNUNhqdR556OC3AkCJgekOVEWEGwZYheZQWTFFarSuQijng5iBBB1CkEJ + YilsRpEBX2hD4wgQGRALrULg+geuygpRRBGVIGBAqxBlUUCUNE4QaRe1fLpsskDoiisIySY7yQgBTCoA + tjSyuUu44P5hRBFCkLsstJCg0CJFYwR7KTDK3muEEEaQK8WofkCiQQprMZXlv9yEO6+8RkjxR/8VA+zA + wCPLZEFRACPECnEudRpRsBFbDKAyDw080gUYSj0ggBYjBwTErQ0kofLOecjQyAQHNMzWwzUH5MXOOyfR + Awc1NHKAVkm9WjQ3MpSA9M5upLEHI3i0APUPTQTA3NTBfHD01UkA0PQiXZf4UApkR9zGDlcPYEHLiwzh + 5UQnrBD3NkI0sIXOSO8Qx9qJ4HEARQ/8LUkQQagiRBUX0I00GXE0YgCY89DleCOR/wG5IKOLjkjomuxB + gAR13wGqIWZ4R8Pni6BOhCGoo6LC2UjfgTgiNtKuSBC3kz5I7pgoIUkGABCusgR3CH9J6aZXrwn1j8gA + QOu/Sw8J9p8g/4j/FBegnbD3j++Sh/MDJLEx+rqAvwjzV++gAvy2hE68JM0jbYHP+LtF8YzHiAyg4Wol + 4FLAtIM68SFiDz24Wht0RaPXVWV/BGSECtiXhPvJx4K/IYL+HHgIBrBuZxbIwIJAyEARyu8Q5UNaHgKI + C8iJ8HYkJEQNIog0D9Iwf0Q4gg1zKIicIQ0NFvuhLYigBCEeYYCJuMPVMqfEWgRRCUQI4hEWsQcLXG5r + VaRFELAYhCM4AYqH+IAEw2jFI7jRCVFAYyGKYLWdSUCFbJzFEeKohCcoTxEbRFob8jiLIERhjzd4AhH/ + sL2d7QCMhIQFE53whCk0URFVYB8BIimLKDiB/5I3+GMiUobCUXHyFXucwg1sEIUpKMKIO/vAKWGhBFWe + YQpTkOMganDAnQFglq8Iwg2GeYNbKoIDSEtCAoDpCiUQ8w83oEAihGA5lZ2Pmax4wh9y0IcNhEARjVRZ + CZKITVUcQQQRSGcEcpCIQD6vCuVkhQvUGYE+JKIIZEAaFeOZCj3Qkwo3SEQ4BwAAfPHzFDqYpzodkAgO + OM8NeDzoKdCZTh+IgIQZqGYHJYqKOajTByaQJiJ4qLJ9cpQUORCDOqmwAF3+IYYqK+hJS2EDEfhAnQoQ + ZSE+4DwyzLQUQcCAQiMggkRkIJke+Ckp5jDUDQT0EDXIp8qSgDelhoIOG/9Q5wbmgIga1LF9m7SqKPig + ThcwFBEwHcAgxQqKKbyAngpIRBuQ9ku2ggIDN03nRRGBzJ31wK6gWAA9Q2ADRKgAaTwgJ2A30YGspvMN + 2jxEA044ADcsc7GcaOxKXXmIPVB2B6bErCbsMFQqqAERCXDeDgAo2kzQQaXprAAdUOtFla22tZpQg2Mj + 4IPTHsIDGr0sbi9BBCqoswLsPEQGpDoAMsBzuJegQAXKqgPUMjcJrIUuJegw1ArY4YHVJAMktTuJDhg3 + tk5AxBo+m13yRiIG9DRBYQ9RBcq6wb2VUMBQ35CIBiA2oviFBAboyYUoIIIBzuNBaAPsiCnI4aMYSAT/ + AZB2ARYyGBGwjYBZE5HWPBj0wozIwW4j8F2okrKkIH7EHPIaATHM9xAkpWqKHeFPdfIhERjbGRnWMGNG + TMEE9IzwgavphvH2+BA5YLELRHqIue7sAkdeRI3TSYUc9rJ9aVBslAsBZHW+AMfVHEBVt1wINQw1Akw2 + BAOI3D0yC4ILH63AUw+RBwqHyKXyucGI45oI3iWBAFoeSfFeKB8F0NMFLzaEfx3pw7qMDoNI0sF59ZoI + IPRvZQuuy6DbNOCy+vYQbPCzSUO0SJGImJ5FRYQQ4lBNCzyXRqUWSBQoWtE0F8IDJx7ABZKKJELvZMUE + BmQ1DScs+cRaIHYY8QZK/3yIIsBUacIldQbrcgNap5PPiKgv0tJg4RBqx9D05AOeLX25aHPp2Lrw6KFt + XQgjrNHNglDDdOl51kSAgAO1fSS8t1kBFvuAC5xFRBHWRoAdpGHfOggBPSNggjkjQgpSqEHTamBkiKFb + FhTosjpNwGxEAKEGFYt4t3sdkBy8gcUR2EAMZlWxGkQ80z2+gQNGHIEKrHwRBKsYCKQwcvwqYN5anQOe + BSGEohehYhSMshqsnU4xdKAR9TLZwLZsg58vPAIsdQQQigCCiUWZAlygAspdIIKOe9xT4SpCz4d7AwwA + nZ4vqC4jbob2I0cBAzRP5wYUMHRChKvuPZ4yPTcgB6G5SyLpM9bzoU2gAMMzolxHRt5b9c6Fp+97EnbQ + K7shsXbyRg4DZn9E5y9P+tKb/vSoT73ptVFs1ecNfaPnxhBa77iA1YpGv6A92YreqBDpPm7e0s7sfy89 + c/k99rIgPvwetcCdKB/2hUC+K4bv+kfMHpvSZ8Xz+Zn96nv/++APv/jHT/7ym//86E+/+tfP/va7//3w + j7/850//+tv//u4PBAAh+QQJAwB/ACwAAAAAtgC2AAAH/4B/goOEhYaHiImKi4yNjo+QkZKTlJWWl5iZ + mpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6jkO7vrk4KBoIXRotCAdfdVBfXXhYE384f9G/ + 1p8IV3UjBRBjNDNWDyxNM1kPcD9jJywCYCkFKXXJKFfX95Jl9QctVjToPx78CPNjyY+DCBMqFPhgxgl/ + KYppwEfxEAIz3Ao8APODicKPIEMe9BgwDAsaKVrgwdGrojUEE1bQsMJEoMibCEni9FjzBwsDELq43IVn + RQEWAXH+aPLjxI90Ah7OEDAGjpUTAh6cyBJQ580TM2is0NdyKCwEWlY4FMmkJxwwAf9oGFjRQgsULAhI + lMHyBwoOElg0HOhiNIUVGEiREAyJRJ2BLgjMvjpAAynjHzDCztUA5U/kao3K/CkzDQqUFgUCjHnApHFI + GN1ISEZVhthqpiGpQrAr7U9ZTRq+YEkhQABTgx+zWDEge/aoLy1oiEQyRsAIEpF/i9KApQsNGA8WKzwx + xsAX55/KrLAy42PNB1ZGaHE1ZAgCCFbG4B7PYsVE9JpoYUUWyClkhTyjzXIFFAZYIR5CS2QxRh2RAVjJ + BCk84BpCYSABRwtfoIALDtqI01FCYcBAAxR4WChJFzCcmNAMY0BgzRBmYBGVjAc9IMAKCGjnYiLSfYRE + ACuchw//DlCs9tEJBeg15CIIgDTGAf+5hBEMGyLU35SK4JECigYg0OJsVxzA1UcGdAYmImMcNEZzqgDx + SS9dZOhVEyxoIeKbhWjxg4212IlJGXjg1+USV54J6CBZxmLnpIZeggIWVxX4QxYpPPpLpYSACokGENiU + EHOe5gKqEIUAUcQkdViG0AkBRJqqLXYKAUSlQBghqiNYaJTQEgJMc6suu/7BKhCsCuEsJLXR4FRCAWgh + 5LGFMrusEEYI8msiZhgw7UFNBOAmtqrqmqwRRTD7LSJl1NEeQtTZeuy7knJbhBAgJOuIejNoakWF6O4i + RBG+grCvEVI8sgILOoVRAMEF6+Ir/xAgGFHDHwnc0cgEI3CEUBMpUFwxLruCAEINGfAwQAl7MDJBC5pm + YYBoJ+8CAqsXJDHAAGQ00IgB8x6UxQE452xJEKOk8fPTSfjBCA7iQgjHfEo7EgQRg3D9RxBMh8LA01Df + sbEiV6SwIRMs2JN1I15/bQjYgoStCQc7kD2ABHkkoMgQVxR50BI0vN2I3YMgHooMLpO9Qx4eLEJCnAm1 + cO01+GqCeNiKh1IDAHon4fEiWozb1J8u+YtL55HskYfPZOexyBAruMbEGIbvkkEeeZPdxtmJ0ITECmZl + 7uLusP+8QxyLaCCA25IZD2ANF+hNhgq5/3LEI9U7XkX2uxDB+v8hIACQ/MvAg2/L+IhU0QPZoqvvC/uE + sNH70x/I79wH9w/gReT6o4Xd6DcIKdxBbxcI4C225ggQNO5pQlOgAOPGCPuRjQcgkKAAE7eIIrRBbwTQ + 4CzoJjdGvO9pZACgCF/BwK8R8A8f0FsepLdCUpCQhIoA3dMk4LcaykJ8FTyf7HzIQvHhMBHdU14GiPgK + IjjxiIeQwfnawMQmKoFpBNThz9yQviqmgghHOEIQjkBBQ1RBbxzwIiuCoAQyknERJSBbCVilRlWEcWtX + VEQModbDOqaCjESIghIWQQaypcGPdmyjEpywvUTkgWwWQOQXoxDIJwwyETLQWx8lWYooHMH/CTeIAiHJ + FkJOmoIITgClJxXxyKfxwJSmOMIUnDCFJziBfQ0gmwS6CEtQRMEJT7ABJROxh/5hr5ejOMITbkAHYCoi + jk87JDJFQYQbWPMJT2DfB5+2hVdNMxRTsCYdbqCIBiTPDSr8picuqQQ1LICYEuCjOn3ZhzdsIAI+UEQh + ITjPT9wgAgAFqA0SgQaySa2fnhBDQCMwByTGDqGekMNCMZAIpz0NADSE6CMUsFARJIIByUMDLzVaiTkE + 1AchGJ8KkmeBdJLUEjFwQUDfMNBDZCB5u3xpJmJQgZmqARE1gF/DdHoJngbUBDlAxB6SlwSXElUSFKBC + QCtwBkQkYJ8D/9iBDJ5qCRvIFKA+eAIiMmCBHa6Bq5VQwj0BuoGfHkIKboDaWdE6CTUoFKBi6AAigBDP + py2RrpIwKkBNoIOx4tSpgGVEB3ww1URYcIubTGwjKMBYvIr1EFW4HxkiK9lFOOCrERABHRDBhuSRwZud + bUQfKhuBF4yPAxdM7SO4sNA+IGII2/zZBVBbkRdaSAdvCKgLGoqINiTvAkPFR9iAeKsbsDYChUXEFkjp + Eq/5FkALWGsExGAHoMaVn71lGnNT1YeTepS0mt2qS7B43dnQgQ/CpSgiGtBXoHG2t6lSA2hd4NZD5PZl + vJUtIvSwUKoqtaA/S0IpJQPFKSnBBLUt4/8gPOAFqKXRLO2dTQy064IYJMKcKPzrUDIsGdrOdLSHoB7Z + AAAgCbuIAtr1gXwPUQQE/2zBs3GxhTCwUBfU9BAr3eExBYyIG/Q0oC+4rCFU/LQSjJTIguBxQDfwTkRI + 4YEDwDGUCaEG7UaAD4rggGnnumVCKAG+wqVAIjJg4wEAILnoIbE1HLDQCHChnN/9GQOG1GDJnEGqAaVC + dxFRhJ49zQtPJrIIFuoDByiCDfWVgJbLzNGF8qGRKdYi0IZc5j/MwcsbSGoi8Ea2O2Sw038QbEAdwL49 + mO9pbhBxmXVw14DKQcmGMAID7pcEaXbaBhA+qQl+fIg9QPNnJVBvmSn/EOypihoRQjAu1AiQaMnGoNls + VbMiVFDfJJRA1kReQK3Z6mFFyKDCO7zwlitdYFYvopVPywOcZasGEYCWrcRVRBEScEL/gbuzT1hAcOtM + Bb0uAgg1YFf1dsDp1NpBBM8FKB8GvQgpSKEGG2OArwFOgT4AeqEb4ALFFSGEhFt8Y9Um6g30gG3hKuCS + i+DXyi4+b7ROQQcL4IKXT8qHZx/8YBpjWEb7mQMFiIAKEY+AC0ygABQ3Yl8IU9nQp0mEGGAgBDuvsxx8 + /nQpGIFddERreetc5wpwob+N2BWzvh5grpqU7GwVwQKcnnZf/UHtU1enDp7rAirwoemTcNfd865OlqZp + VwxccEAOcP2IVRH+m0wTwd8p4ARL7Crsj0c1IcKevUl5K/OwAP2t2qV5TfxK9KjWVekx8S3Ul1lUrte8 + 54fUksthC/a0l1/s6WP71Uei974/RH0IAfzgE3/4nNx9KJBvfEj0ovjNNwTzo88L6FP/+tjPvva3z/3u + e//74A+/+MdP/vKb//zoT7/618/+9rv//ZMIBAAh+QQJAwB/ACwAAAAAtgC2AAAH/4B/goOEhYaHiImK + i4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9iGV/eH84CGZY + CF1XdQh1V1oIXzgTKH8Tf0O+2Z1XZS1dEDQpLAEnAg9wSDBNMA8sD1YzBQEpECtXUNXa+pDYWFoHAWjM + OHGCyYMfS34oXMiwYZMlB2eMYWHAQBcEGvZpJIRNQ50WVuDA+BGmocmTKBueCDOuAJQrZjZmm0ACSgEY + I1OiZPKDJ0+dJ5E8EFDgQEZsMnG1KGAOIdCFJ37A+THmXRYrJ6z8YBEGzI8mT3kiOTEjRRcSSWdBOwAD + ok6wcP9mEKVRBwKJLl80fIFmZu8XKFhaaKFnxcqYH1GBZhFAAwrStKsQLGWh88GSeDRaYMGHYBK1LyhG + QDAgAE5UJCibnKAxYoIwyKaGrLDi9eSSMEhoGFgxobMnYF1GGBgDJ+FPkzQOfHkMG1SLMU1Qn2Sh+wqe + 16OA4RhxgMaDB8cZPgjQAm1zT1AE9DT5oMkYzb5XCSORgkZOk3IPXDmvCUeA8As9MAZrtWhAH2UJNTRD + AHVQw58lBZzEhBUraJFLbyvAkIVJTMBggIUPUmLGhgxZ0YJ1vWhwgAAFOfTefiFKssJCcLQwBDDaaAAB + OSaBQYMG2MXoiDsrpKWjAGA1ZMX/AdcI6UgXQcpUBn1TNRTGChk5qeUh2/HIEBIsmLdlL0BkcoUBLEi3 + 0BgrRDkmLWUaEuckQ0ABXXgzHBDTm/rMGckXMzaURQHM8cmLnzKq11ABMBpKZiV4fNFUgAGI6aguiEpC + QgFJKoSEANZcSkimsggxCKmKoJBCggs1JuqptpQpBKJFQAJBbQq9k+WruQBR5q9GoMplC5aV6CCvt/xq + qq++mtrIEAbgqlAKuyKbLBCz/iFEEcIWMkELMzB0QgrHWhsrt6YWEawjeByABKsPGIBjjN0+WgQIszrL + SArhKrTECSDyV68nQQQBChBFFCEECLU2YoYB4NH4xYO+pkLE/yAG/5HxJdjiC0KwCTOCQAoMLUFDo+cN + zMnGF2u88SXcAmFEEVI4UsYYaj5ArrmWFEzKwiAIwgEAjEAhbZ48a5Lxxj5zLAUINbQxwAAXMLICrkyw + MHHSSh/ysiSmckDG1FQv8vBBCjURANe7JEH21HksggANDbXAdi55vD01AYqUAcV9P4AR6t22SP32Dgws + ckCnPxhQKOEET5L32140kGoADQ0OOS0X6F2CB4qQgPYJRW5uSwYA6B23Igb8kMK8ptfCRg96c6AIHtXG + bgsDOxxehe4yGU42AEEDrxEab0vwgfG2KMGIDGOTbUENzNPyNSIEuE12G/pW78r1iGSAPP/ZZCTgvTYq + aD911efLAn4hAKifBBvtf/8IGxK8TXT9rzStyORTS4L5+NeKli1iD9Gb2h0IWMBGAAGAAyAD9RioivcZ + IgHqG0AcKFjBpS1iC2/rAQct5kFFNEBv9BuhKZpmwUFY4G2rUyEq/Ie9t7mhYTIkRcGI0MI/YPBtv8th + KXhIQzl54W1tEGIpgkCEi7VQeAMQoRJHEQQlOFERbEheBqYoCiIc4QhMNKAhQJDAASyPi6FQwhG8KEZD + pI5sMUSjJ77IxCMoggAhlCMo2HiEKChiDcnDoR43QQQ1HsEJbSREDTI4wEFuIghR8KITnJeIF5LNco7k + RBQO+QRKIgL/hGRLQyY5ccgpnMGOiYDg/kaZCSe4cgpWTAQD3sYDVmriCFOYwg2egMpDAFJ6tswEJ20w + hUQOIgGHq1kwLXGEM9zgDE54QiI8IL89LLNnN9jlE5yQCCnkL4CNvOYksnkGOtwgEUXoXQBlIM5KZNOc + 50xEAue3j5bxUFQRyGc+FVHGNdRTED0Ukj73Kc+3+VMf9hTVDQbqAn6+LYXaKKGjbDDQDShCnVNjZzsl + oYaBUqGb3xyAAJMS0AfFYKAmmKb8QLeRkj7IAQPlQyKQSbYdCNIXEjUUBgbKhUSckGxuaCmvRDBQBSQi + DrQkqajEMNAFpPJt7NuIMbX0BB8M1AaI/xBCCd7mB6U6agEeTUQNLDk1TG4UEjvVpwgSUQWMSiCcZ22E + CYqaCA6E1AsTjGsjbGBVfeYgEdkj2xbyqtdFKGCgFVBE5wJ4h+7tw6XNmas+XyBWsiYhcV59U0cH2oFE + sEF9EghiYRfxAsQq4g60NMJoF3GDDQxUD5VF4moXoQeGYhURDQCtRmd7iNYOVA6JAAEES8DbRKQ1nz5Q + g1h5QLYkiLK4hsiBCwa61kR8IKQ7UAF0DcGHgSZXEaCcGg+sud1BzGGgEeipT9+WhDg4trg2oEJFb3uI + PSx2al5QZnn/EAL0GpWtbmjuc/db24G+QRFSyIP6vCDa7cagr/l0gf8d/ljGC7B0uxRw7UAdoAjUHU4F + KmunDuT720UwQH4LLK8NKoBeE/gxERkIbxQbzFsdsNijOlhEGkI6AO5tVw031ucGKLCI6zaXB3BdbQw0 + rE8XxGARCdgq+czKWwVAOMJP7rCCm5sHwo6WDkRF7way3E0/YHQAFoDoaudAYo8SeRENoB1QPxBiVuag + u+iNgAlyvIgYg5Zvq70BBqabZzlwcxFVkHESAEDjjd5AD0xmKIcbcV/8UnmjOXgBofP8hgk3YgshTYIX + OKDajdpAAW/Is5D/2wgjlDEJXRXnDRaAARNcGb0+4AJ9GWGEGuxBzjtoA3nfFKc6b+IGNlBDDBz/gAER + iOHWefaBCJT7CKhR79dJADSfuCUIY0/ia6oON0PlQG1HIOxpUqCeBwCwRUd5W2niDrcJFECHSHRMCvjG + t8Z4VbEV/iHeiO1DuSGBLSEYodf4vumlsrXCIMSbCiJQwF8rAQSGqUsKIWOlwSLggg1UwAR84IICFrDr + SfxKZgef2Xv5XYh3x0JhzVLXyrnWb30IYVmy2i/Yuv2HmjPP5apg1iBmHjugr8LoOh9V0pfO9KY7/VEa + Qcrjnm6IIUyd6oqwepOwnghsPEbrXO86R8LOiKuTnSNgPzsirG52tadd7XCPu9znTve62/3ueM+73vfO + 9777/e+AD7zgB094A8gFAgAh+QQJAwB/ACwAAAAAtgC2AAAH/4B/goOEhYaHiImKi4yNjo+QkZKTlJWW + l5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9iniCGmVXUChdGiRQZlBDGhMTZX9D + vtSd0UMkGlAGBiksVmMn4SdwYSwPcCxgAWMGBS0rOFh/KNX2kl9dIyljYzA/D5D8GEiwoMEfYX40+XHi + AQsBBiAg+zPhnkVCKHAgWAHuH8KDIEOKXHKCRYADdehdrPalhYEAD34sEUmzpkgmM+BAOIAD2MpcI2iw + mGGTYMwfMJqIezBmRs4wcH5kkVl0YBY4Blog+EkLBQQ4TRaKXMiERT8IaLFo6YIDCgIEUP/KaDGjRcuI + FSto0ADDAiBNJj9msJBohqsrDQWOgpz5A04AGhC+fNEgKNojYFu1kOCW7iNIwDAK1KloONWVkU3AwKGh + RQNlT/Xq0rDygDHIdS3+WC5NCgeY25Dr4ECl4cvLqSCRLLHS5QrvUisKMhFwgMTWVlc2N/0B2GCTAC2G + Pw+F4gGTJgVI6J6FoE6BGQIPZinQZXyoiPVwodBgAI7igiwU8Jp9BDZCAgQBgPSAALkV6OAiCLQAAxLd + ETQDDQM+qCEhQyAAAXIFNUHdNBuWOAgCAWSREEE4GXCdiSa2IEB8RtHADIwmovDeityVRYJPOG7YxRi2 + DQQGBEFmAsT/LhPQcIJ3BuSXJCNLplIlIVc+gkId/wGUgnNT9pIlJF1Y4R0NOJAYJi9jMjLEFzSIRZCA + a/rSJiMI0PCfiC/WmcudeEZXIRI0gJkkoLIg6ogBRBEURgCklQhElYrWIsQglQ6CwwFPFpRCYZJmSsuk + l155KSNlMMriAylEuqGoo04qCBBSiIpHCzwqtAKMsNYCRKlFwFpGCp0ONEMXu/mJy6S//iGEqFcYUOEP + AtSnrC5AFAHsqYxYUWETVgB5rSdEYEKqsyA4QgKRLK6Q7LiblCtIEJYsWYQRl3KbiBZ9WViHmvBmEgS9 + gshLsCTZamtEEajWQSO16gW8ycEEHyyJ/xAg0BpspnoS1AQNEntisSUM32sECEYs8kWCHkMR8icjI/yH + EUZIkW4Ni2jRqExj9PmywIMMTAnKOK/hRhwpIzIEBAatIOXPsgiRMgNJDJCECooMwYJtcFgLNSgxU3nH + AGQP0IMMirQAIqFPfw0LD2WTvQXOiOBRAI1ZNOi2LHCXnQQB6SKCxRjdLdf23q00IEHcZHyQyAQryBmG + 3oi/wsAOfgOQQCIICFAhC5WHEjYiNVwQ9w5+JG3IEHUYpEXosMjAQ9Vk84B2Iv0OBAPsrwARBxl+55F2 + QQLw/koCW8Q9QAOKwEen8a80AHzZAHiQSBfiQu9KHowzr/0uCViQuf8U3+9CwOJkS4B1+bmo4EbcF5DP + PitHKFJDG3G7wcb8rMibiAfiKxsB+KeK0RHCA6YrGxroRsBZGKEBcUuC9xpIixLAT3UUFEXFFFEEAtBu + ADzYQwYTpYK4qW+EphCaIixYtvihcBRB8F8iPFi2EojwhaIz4CAa8EEybA6HYGsEAOPGASCCbYNKAwD8 + GGbEThABiYhgAPoGgIYbNnFi9FIhIj7wQS9YzyI6LJEWD5EAzJEtCbe7h7xkaKKBPXERXiDiRQwWRgI9 + MYwJJJvwLFKuGE5pYGM0BP5ayER7ZJGNJiLCEcLohw8CAINXxEQQjrDIQBKCA3HrAVfqSCAlLJL/CIgc + RBVO9xNLloiSigylIPbwwSRYkRpQDBIlY6jKP+xhegPYQRXuwckHodKTiUjA+8i2g/2BcU1K8GQUlBBM + XO4gjfao5YaicAQiOCEKidiDGa32Q14iUwlTeAIzESGEKQ4gA5GMlxOc8IQb6NCc3UznJYIwBSfUs5Yg + 2CYa5ZkJIkRhCjd4AjYRkYEp7iCe/KTEEZ7wBBs8oX6IqMIUyYBOb4ZJCWe4wQ2umQgels2Lx7yoRp8w + hYEegmoKLGRCLfEEOpwBoodIQ9wAsNJL9MEBHcAmTA2RxwHcoaaVOEIEhroBE9Syb2RjAFAp0YGhDtUF + tdzmAIy51EjowakR/+BDNpXHwKo+gg9Y1UMiPsA4r0bCDhvAagwSwb2ybcGsj4iCA7BagSckogdxGyBc + G2EHETjVBXL4XyvXt9dFLKACTq2AAzrKuK4WFhFccIFT+aCGRCjRrY9dxA3S6lQF3ICcUlVqZhHxBAVg + 1QU2YKzfKjpaQ3TABE71gQgUcVmylaC1iOiDDxI7h2yaU7S4JUQOEOvUF+ggEX44HWuD+wclyOG0lUUE + COJIPeYSYgGSHapsFeHRM06QuRQIAVZNQIFEgICFZPOC/Jh7BBFkd6gKUIQKWhkH6/6BCAp4b1aPiwgj + oHcAZPhicIkQg93+NbqI6C7Z9MrcBYgBq1TAgP8iQIDUXAoYtzF4A1Z9wAWTnlR5frCuHWCLVcoqYogf + heRjj6ADEic2B4qQQm3JVkTcHsHBWI0AFdaqCJRiNrgOqICBh6rYRewhgGdcQ3D1wFmnUsEB40SEB/47 + AAav2AZgzXEFYmBX8w7yx5m1wRyokOMIiIHHiviAVCWg5MzGgAtlziqaE7EGqQ4AuON51qyqEYUb9IG4 + G+YCghPhvgju0T6/olSvXkEBPVDBB0Me6pNTu4g1VJiKCH2OrPacC2wu4AVkjjNld4oI5H1wAPp71S5s + 0AE9mCDUZa6AAkhN0BkDmKoP0rPICOE/aQ7CDnRYABfcG2eivqC8Qkxe/hz/Z6JFU0IPYhCBHhwQgwXE + IAY6eIIarN0BBbzgBSHwQZPjvAER5NQRCbg0GRiwXkmNIstPrUAFqOCCDYgBsT5wQaTj7AIX9GEBkJAB + LolJgHYfihP0gnWxF57jDYSgDzb4LCRsLQErH9zZjLABwzceAR9QoQLT7jIkUlYFpCYBz1NaEsYXEYPY + 7pvfaTUBFzBAATpMYRIgqAH51gC8HTAbhTZYgB7kwIcQvOENYqi3Cd5QAZljAAMLsEEOoowwI9QABFKo + QRE4YAFoGtEGasjBDZSQgw7YobmUNpfUsi4FKTBMxddaeSyEQPd7sT1w9qXSH37l9pOBQFt5b0S2mEWz + aYWpNPCKoLvKs6UvxJPzVMx6ltxHSylu6drxiriS5jHP+c57/vOgD73oR0sigI1eGqY/vTRWP4jUj34I + aoK96lc3+0PA3vWqv33tCyH73fv+98APvvCHT/ziG//4yE++8pfP/OY7/xWBAAAh+QQJAwB/ACwAAAAA + tgC2AAAH/4B/goOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0 + tba3uLm6u7y9ikMoghoafxpaVwhdVygkZX9mgkO+0554OGUoIxAGBjRwYwIzD3AwPzMsDyxWcAUFKSMt + GjjQ1PWSySsGBWM/TA9IP/oFHEiw4I8HP5rAmEGjwAgsCP5Is0exkIYVAeDMOLHEoMePIA+GsWJlRJc/ + EyrWI2GABZMfHUPKnEmw44wxBroEU8kLAs2BTRAugZFlKLpzSB7M+BEmzM8lIwuQwMEzF5SXHv2dUBog + hQEIdb5o6YLADBQNeKCQuNICXgEDAv9glEMYssmPABAQOKtKq8wJgzOspIBwgISgnY72Uu2CBQINK03+ + gnxwwsAIvrQKBGQC590XBFQ9aUCwIsXCkDBKRsT8SssYCF+imUKABe4JgAaRIAnQAjFrVXtbXSGRwgrI + EwG6TPzN/JEGKFbKYSV4Qmrw5tgTSesCAYbdgmFmHFidvTwiFAgM8PMYYMR18/AHkVjBwiOYArHj6xc0 + QYOB2+CNcdJ+BH5hhWQEwQBBaATqt4JxBSGXX4PxsYTgQAJAQSEmQOyCxwguFcTCAb5tmB0JBeA20AkQ + vGdicwgcsFRBENDzYi8dQlJGHesN9AANLt74BxA5vlLkJFoEoGL/QgHYeCORzCFAA10BIVEAMUIOiV0B + D0y3RABZCnJkLUWOqQgOKxhUAINh2tKhmYyU8R9BDxjgZJu3QPkIHnNudkIKeOaiJyQorDDdS10EGahK + XBIEx2WLuvmHEIPAaQgCKRLEApuRygKEEJYmckUABDFBA3mdejqoEY0gUN9ASBiQqpuUAgFCqITUAQZ1 + WsxKJpG1xtnCdD+McYWvoAQRhCRAFNGhEM4uMkQAVP6QwnLIbqIss6ASWQSli2BB6orKZcvJspV0aES0 + ipSBRbVWYGkuJtsKgm4kQqxLJK5/FPDdD7HO6wkR9j7yaREIg8CIBhAGdIK8AtM7yL2OgFAE/wi3MoJF + QSlwGrEq+1psBL8BONXPDHV8rEm9klwMghRSLKLFq0xZoXInFDdihBE1COKHB4lMAIGKSPR6s7aQ5PsH + GyUMAACriCDQ4w80pHT0KkC0kcQAAyTxgSIHDOTPgFev/AjXaLuRQSJ4gDHdqWWr4gfaXd+hiAFUgpFy + 3KiAwAPdO6iQCAk9NkED36mosDXXSVwQ8yFCx8TEDBAjTsoFiw9AxteIkFBOlRBYfgobFqCdRB6PG4JC + Co6KbooQWqNtwRqWQrHkhK6L0oAXdKeRSBlTy5r7KDVgjvYOCSSS5kBhDE9KA5kPQICoHTHBgvDOhyLF + FnSXsEciNKyAav/2oaggAdpkrEE+LAn8zXgbrLHcphB5ZG5B8nwR/AcROd+oAt1kEFz+7NW/G7mva76L + XwFfJIXYcQ0NqavKAs0zwSB8AIAyWB8piKC/QwihdIzjXEXuNcHsyM8QHgAA3eymkmWdsE1ASEP3+KUL + dJXQf+fjmhe+x5MbYueFhmBDDgcggSrwhH8m8iEQeIc2EVLEhxRUBAhUiLYEajBZJTTCBeiWhyuGAomK + YEDmSlAEL37Ch2JEGxp4aEZt+fB/aPPCCIUERkUkIHMSAFob3fgHIAqiCmRAXwb3iLMJymCIyCOk2fqo + CCDswHRrU2QmglDHQyQAhERUnyQxwb8SJiD/kFzbgRE3eQkO+vEPNchcEthIykkQQQkEm6AHHsm4SLZy + Ekc4QiwTwQZaag5/t5RELjnYQUMoTnZ6DGYkdEkEXSYCjlyzgDIlEQRdVnOCF0RbD6YZiVfmUgkTTEPm + AFBGbjpimEqIgiKoyLU2YMuciohCLp2gzkT0gG4cgGcjXhmFJzxBCYmQAii5JkB9KkIJTnDCDZ4wwSog + cpAGTYQSpuCEKdQTEWnkWg96FlFEEIGiN7hBFCa4RbQBoKMSPcMNbPBPRTCRa3FAKSKeENIbOOEIidhD + 9NggU0SE9AlTwCkiOADAZPZUEApYgCDo8ATtsNNp4DqqIDYQARM4IApO/0jELPEp1UEoIAJgjQAVJtgA + uiXBqD29QQXCGgE+rJNuaOgqUtnqAwpodYgDYIBc1WACtro1EQygmwRYKVMb9MEHYd2AUhFRg3uaNKo9 + dQAVwuoDEVzUEGWlW0F7aoe+hlUMMUhEEZoWx67egAtsdYEeFHFMtOn1qE9wgAvYKoIcKIK0XCNDVx0g + htTaNhHQo9v0ehoEO1QAsWBVbSMdG0qOyjQGIqCrHGwQRrMOV6ZqeMNsweoDPqjBjr4cgAWc29EORJet + G7CrIkrKuHzK1A5iQC5YrbqIwHYPsvb4FA0rogATyDcCir2BIvaASc2NkiegEtNvbKAAKvy3AgpYhP8H + uNc7zBxpv7yIgRyoylYqxCCriiBA9EqgMNZgmBc6cIB/2RqBEDigmIf4QPQkwNPfDEolc5DDZFP7hg4w + QgUDhSl8TnwIKHqiA31YK4tdIAcdMMIDB+TaBbJD5EcAVBRP0AEXTLBdyrrAAWdghAyiPAAeAHNeeuCC + j2GMCR3MoQ9dZrEIFruIDFA4jmc2T5VnquQQKIACORAqLv+QAzXowQRKXvIGFHADKAIgejtwYnnedIll + OYDFFRDBCxRghz9Qd3+JIJiTF7AALoQg0Sz2wQZeoF5GZAC3jHutwIIQBc8u2QU+CMELuKCAGDgA0Au4 + wQJysIA5KOAFIjABFeL/zOIIVIAPoXWECtBAN83JOmJO+G+zkxsBH6xVDFTYQG/XyuxtOxsDc7isImrQ + AB7MmAAl3tCeCfGE/rqg3ObOt7kr8AYM0CHMjigCB16KNgKUs2wLeMEb4qvvhnPX2WLQwwI6HYk0hHcA + O7g234jtgBdUYAM71nazZztZPvDBAXNoqiQScOc4StpyUxDEAhzgAC7wgQtiMIF230AFE4TABFyQgwMU + oAPbGtkQHLh4EnjwgQhmD6c3CDMF6KCDDgTBrk7ORIeYy7gSNECujChCDUAgg/BewJZgP0Szxt4zAoRS + 42knxKeMADOxUwoNJUB73OUuhL7zDGY90+Te5T4kcFshrAiAh9rg5T4yIu3s8X1f/CDApd8h5etb8+5o + ggvfrczr80hR3bzkE+H50Zv+9KhPvepXz/rWt2kIE3nn6ZcD+0LIfvDSeOftWb970+fe9YOAfe2BL3zg + G//4yE++8pfP/OY7//nQj770px+LQAAAIfkECQMAfwAsAAAAALYAtgAAB/+Af4KDhIWGh4iJiouMjY6P + kJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vYw4CHh/ExpYJCg4JCTC + ODi+z6QIIyspBTQ0AmAPMyxwWU0zY2NgAgXVLSRQCNDslXhdBlYzTUhND2E/+fr7/PlhDz+yWBGQQouW + de0SLjLQr6HDh/mQ/DghIECLLwgVahSkBaLHj/uaNAlQ8I+wje1Q4GvY5MSJJRPhsMiyZAaMEz+YPGAC + Mp9NCCOGoGQ3Qx8SOCQhrDjQQp2ZL1i+oEAAZQSULhDMWTkxA2dOhzxHQsCBYmgvayuglC2D4iQjoX// + yiAYouHAgQIzwEh8+OCEAS1mA0dypoEaDJFgT9AYIbjxI7lfClgB6FAglrKOMy9CMa1rwyVMCnTRTDqR + sBY0TjDhyQ9MAQ1uS8sepMXADMohwazQMLu3IDwIDIxhrY+nlTq+kxc+sXJfFgMo4CaXfSUFmH5NrGiZ + ML03FBq4/c1Ywb07KCCxUBxgQTzfkgKYzZfWUMDrvjEaysgvPaTFmH4ztBDffo+g1wsJNPRzAgTlEaiI + gX9AyAsCEDTBzwMpOMiIhM/gAUVRxb0nnYaHcOjLEAgMt09oGZEo2BU0tNdEAWa46Fh1/DRBQ4022gKE + iY2YYYCFxdHQY2MTGBDe/w8QDHjkLUAikoJ9Oq3wZC5RIjKEAc39AMYBV0IpSJaFCMnPDLyF6SMkKATQ + HBMstKjmLGQWgsMYe+VUgJxzulLnIViMAVM+DxjQ50YjgOgTFIfKgt6fg5TRAj9w6NcoLEAIMQikbu6z + gpOXrvIjpIJc8Z8+MyAXqp9jRigFIy1ksY8VoK6aSqY/FvELl/oUausrP2r6JwowDDrRFb+2AkQRwma6 + SB2y6pOCM8luQkQQjoyaqa6LJIhqC9Vmgi0RkaBXhBGMQHGdPlaEi0kQ8EoihBFF1InHCvsgwai7lmAr + iL8bClEEs/UqgoKiPwTAI7+XkJstCEKAgO5ClOmkKv/DlfgbLyOanutsIl8IsI+RGGf8L8CMGGGExJpq + ecA+J2BRcsYobyhxDSBslgVrTKQQ28yPbJztyoJ80IYiKeAGBwkJORxYzYmg9wEPA+ywRyJQsKDPEhC0 + c21jQi9SwgBkD5BHIiikcN+IvAThcNi+bVH2ABIkkAgWzT3wBTT+fm1eAnObrQgMxEHwcy9OCwb1IRfM + 7YbdUuJmxd7sLO5bFUmULYEfiXSx7g+p9gKw5ckBMPcWVx+CQAC9Ztj2H3DLx4EEZbuhAiJl4JsPE2M0 + CLQoVaBRdhJ+vHoICTsRSrkuse8HQh6Zk12CaafmA+Yuze/HwQ6aQ35ICsSRzHz/cqQP4oEFcxOQyAj7 + gPG7KXkMv0UNiODQHp/ve6IC7WR7IUMiOHnAGFJQq/xxQgZeKNsO1tC5NI0vTB4oQfQGcDQDYuoOp5uY + BV3RgAnywHsbZAUbyKDA1IWQFQlIYNk4cEJljY1sSYhDC1lhhDtM8A4zXIUQ0jA3AOQwFKTjwARLYLwf + ciIIR0hEB8vWg5YZURPZE4QKJmi1J55CBtwjmwUyYEVTyICEMORiFy9RPkFkIIsDIAMDxyiuROwBjANI + ghjZ2C9FJACOC6SjJfyGiD2gcQcg1CMkoiiIBKBRAnMUZNDK+Ac28G8AbkikIhvBx0RUwXE5m6Qj3NaI + DzzS/wsa1CQjGPkHBpyOfqJcpCII0MNUbhJ2izBd2SroykUQoZKHoNoKa7kItxEyA+iDYQN4qYgj3LJ8 + lywbGf5HzEMQ4QhHKOMH5maBZiICmolDROPK5kNrGkIJxuRkIoJJNgZ4sxBBUMItjZmIBDxyAFU4JyGw + CU1FMGCCbvCAPAVBhCgYMwrZLITcuLlPQShBnUqIAulqAMcBsHCfCU3oFKKgCCEqkJnnDMIUnOCEG0wh + oIQYqPSc6M0jOCEKU7gBSM33TnPKkwg36OgN1KkIP8wNkPt0whluYIMnOIF0RVAh2S5AKkXe4Kg3eMJK + BdGAwK3Rm0GgwB+O+oQpiG1uXv8gKTGf8IIIKOAPT7hBEpU4wQG41JsOiIBaRWCDGzxIeMpEpS+EUFTB + dIAKalUrFZb6BxUETn3QYFZ3iJADE+Q1Ai7AgCJqoEuykUGf7DDQj3rTAREcNgIiUEJNywpYjdS1HUqo + rA8OawIbKMKPWJUrO+jaGzXwwQWHrcACFGGEbe7Ss7JRAgUMe1gxOGAR05zb9ALzWV7QYQ5vuKwYFDBW + RMjADTd9qkKK+ww9mGC0ea2AA84Qy8Cl4UhBwIAOZNEBDGA3uzFgBCvnhgZuCYa6gojBBlzw2+aqgg4O + EMN5I+AD3zKiAWiMo3SH8ihJYMsOFcirCCgw3lTcYAFywOv/ZUUwB0asIcAxfJJlY9uHBZAyE1NYAAbE + sIHLbkAObl0EYwMHgCLaCLaXjYAJ5NCBP9i3Ew/GgAkknFcfmEAPDbYjXMvGg1Bq5rN0sOx+EeuDDkv1 + xpVIog4cIAISx3gDJliAaRkBgLKS4Xayga8CrBzjCpgAAxSosVUpYYMcxGDMVIDxYX2wAQVIlREJECnZ + dgDmOanhBbyd82jFYAIuzGEOT7ADLAeRuDXn4AkUwAAGRFDiGKu1ybNtRA26HDgGuLdPIhYDf2M82gr4 + gA8h0EOH9ZADB6ghBgtQgwLmQGU58AGxciY1FzLdCBm8UIEyXJUNbPCCCvDY0rAt8Qao/4BlF5jABS5I + sKXnPN8XVNgRQmhADwI3AAKodlVv5kIEKj1tUpf7sC4gNAZ47QhtB24HnHOXUmPwghe4AK9LPneMYUsF + EejBAXd+hBHSUFa6+QG+T3JCaBWghwqEIAL4nrPExy1jEfCB1TnYMiRUoOc9nxVo2MqBGuaggHq/QQQV + 4AMV3mACMcjBBCJQAAYcYAM1aDwSe2BADwrOgz7bCOGJeMIfFK2GM6ihA2eIgRLskIOpYiIBFwgw2dCg + gk8X1BBxIOfcLmDCqxuCA9vmthc+7nVCAGEN3KYbAFRg5LILQQo1SIDW09iGQLq9CDWA+x/i0EOflz1C + 85KCFIoA93saoK8HH/h7qyI0sHnhLO9/4ADZvS6wUUlBZYSHu4vdjh4hsBYIKlMZxLRaUAixNkLBMgJd + gZ5KCX1e8bCPvexnT/va2/72uM+9IIfAe0GwTfa8hwvbfg/74ev+D9IhPvCDf3zk97750I++9KdP/epb + //rYz772t6+LQAAAIfkECQMAfwAsAAAAALYAtgAAB/+Af4KDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqb + nJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vZAoV19YWF8IgkMoOGW+zKZXBQECcDMnWTNw + LNlgWSxWBQYrKyNXgsvN55pdP+s/TOzv8OtNMzAwVgZdJBro/JRX8QADrlsiT0AKCFj6KWyER6BDh0hg + sEjxBQWehRgLwWtyAkw2GCeQrHvwQORDeWHgQNBiLCPGFQdGkLiCAIEGYVCgzMRSZ0UBGjQEPBj4MAyN + FftcKmWoAQuUAwHAzHjgTuCYAl+WamVkTgOEAgKaOMwSAAuKrWgXaRixgsUPk/D/wjQpiyOt3UNlbKYA + c0JggS53Ax9qEQBGwBMUBSsepMWA4XhMWBhYTJnEiiwAH4whMYSy4LwQZoiF9wCCGc+CkRWYUfWdFSjm + UN+FEmAovCwr6souBWRVmQNj4iEpkHS33S8pAFrRYtxSb0HPaaFoMSMenBbNKz2PTmvIlQBw1+HOTon7 + rSEG+r4rfZE82jpwNho47X4rFgHxUrSsv1RDAILvFLAffy4hUEA8AhK4FALJvTNcewpmhIMBrf3wQAoR + KjXhO0w8sEKGt2znCAophPfACCBmNAQN4c1ATooYWRHeGAPCSIt5iKAgAIA/hJGgjf1AwUJrSKzQGZCy + 4KgI/3XsLAEDYEjOAoSSh0AQnhX0RZlkI2YcyM4DBWiZJJWGaBAfOyckJCYzQ6jDTmQQrtmLl+wcIKcr + U5JZCA7VsTNDcXeqMiV0jByg3joGnBWooIM2MsF/aEKpFRF2RWfEIl2cuU4BiipFRBCVCtEbCIugFwY7 + WdSxFKWCsLrVlKLq+QcJbrFjxVZB5JoWEEUI8Yevivz2zgnMrQqqXbHyCiwifFaFRAAYHSuItOhQq4iv + vSoyxAHvNAFotX+Aau05ujYiBAjLIjIBZuwkGu1CoLq6CK/Z6pmCbT+A8e2il4ybCBBG9JptIl881o6d + /HyKKyNFFGGEFIzQ8GYANfriL/+8FxcCxLmNItICvjOgyO8m5TZihBEgoJuIBlawEwaGI3dSMiJAgGBE + DaQmUsYK77AQ2y4Zu5Rr0IIYAawKKhDM4wlQ9EJ0tE8PskcaFgxQgs619jhZzKnIMMDXAyThQSIGnNrO + GHFyTUoGO4A9gB+JQHHoA/uqXcnTF7jNA5V4aPqDqnZn8rQKbifBRiISs5PCz4GHYoQXYCdBQCIrjPaD + FRU3/kkekW9x6SFd9PkDDE1rbgnRQHyQBNg8HH6IBvitcwLCpodSBeRfk/EBs3Q2AXPtoGSwReRxKLkz + O0jcCjwoReSx+tcXJOLmOjBMsDwocTw/gAU5G4IAvk1kfj3/Jglov4Prhgxh8A9qjt8J7gPswEEisa8D + uPubeABA5Awg/s7W+HME0UBwAe1NDhHJmQcLaBfATNzBbVtIBA461UBOfMBtJahBBVHRAAmArQR72OAp + PtC23InwFAlwGxlkcMJSZIAMYLMAC1s4Cja4AWw7GBsNReEB7SVhDTsUxR6q9jU3zDCIn6hCCQcggQQg + ERQJWOIOjvhEScirEGxYohd0WEVIgEoJiWiA+TTYRS+GKxEq0B4Iy8gJAmiPB2zchBD84LYLQCyOi4ja + /sCWBzw+ImMeGB7Y5ufHPC7CA0tMQgMKqYggKCwRSgQbGTLASEQ4khEM0J4X0lXJVj3N/wicA5sdO0kI + R0YNfpIjZSGiFkmwUVGVgwgaA9zmBkrC8oy4RIQQ8iZKTnbyUzMzxB4SGYdbhsuUi7gg2CRgS1US4QhD + W4Qgv3a1Wx5BCZQKGtvc1j9diIpAzzzCtBSRBrdNcRcb408QjnAEYCpCCvAbwAWKwAsRNYcISoDmM69Y + CA5obwBJa4as7pLPdrZzETzQGxd34UsBuoQIUXhmFMCoiDRykxkdk00UJqqEKDiBn4QAARrcZoFmnmOg + q5qCE6ZwgylQNIxue9tJB4FSQ+gAHUdY6UpvoASiJRRsblhoYEBFASoo4AzMCMINWnqDJ0BzEXGIaTEX + UlNQLcAFEf/YgAN8EYUbnOEGdGipOBUhgxvGkIzo6E1NBTGHCLg1AmJwwA12oQYK/GEKTxAr0fYItt1R + FRImeKtbN6CHHIzVFjHYwBvsega8MkKZH5SNHUSAVbf6oAJ9UMMtHPDWN9ihqSAlhAyI+LUdAFE2OeCD + YLPKhw7MQgk6wIBgXcCHXCaCr187oFLWSgHKrnYDCshBaE9BhwWIYLVZbQQBYtoD8tjhBRXwgWDFwIUF + /GG4o1ADBgIrWB+YwAaPXWL8TnvPHOihAr99wxxyoIozLEAMVECuCF6aiATAkHj8scEcxIBc2m7VFFNw + QB+Q6wMq9KERMuhBTAEQoRyIAL3IlYP/Hq77CUp1gAJv4O9vQ6CARtRgml/jQQgjpAYFvMEH0l0tH/pg + Bx1EYQqa0IEdMMCH+CKXChiIgYdBPAAykDdCxQ0BhJFbARE4YA4UuKltG3FTB8QgBKpN8Wzf0AElL2IP + APhnEgIKI/3yQcpvla4LTCACEeS4xZr9Ax0EMdc/gPcPFJiCAubwAhGIAcXIdeuKHwECHu+gm0hSggJE + AObVusAHLnhDnfngAAVw4ch9UIAezPyGN6B3A3l2KxWo4ORHyKAEMR1AGu6kgBdUttCz1bR0K3BoTEeg + spnGtBwwwF5Pj9RtEoDbbtaaiAWcdwOIzrSwhS3dDYgh0kpocyOk/8CB+7qtDd1blB0cIAI+mADCqB62 + YK+tBwzcwA6SSIN4wzZVtSmBAg5YAAaEXAENuzrFKY7uBoSshxdQQMeTkEGWYyqBOETbbk+wsAIWMAc5 + cGHSb+iDHN5Qbz3EQAE2iPMfDgsJKTCAtDFcpPueIAgdzNUO4LYDUte85EjUIA/jHgAPuGxMQyRA3KFO + wgX+3fI/ACEDDCjBP78mAQKMuOaxbAAAnL1MALwS6A3YggdDLYE2HL3lBMD4gtEHdCFIwQOhLm0JNA70 + jUmhBhrEbdh6QAAZ0LPlGxPCw6RwsyI0gKRpeHolheCrjRntXDVY+x/axgMGoJWUjeoVrKTgsFyH1eDr + f2DAjzvZqHQOakonQ1nKVAZ0mtIUVoJvaOUH8c3Ne/7zoA+96EdP+tKb/vTLG8KR/qD6Y5S+9axHfalE + 35nVw572qr+97HfP+977/vfAD77wh0/84iskEAAh+QQJAwB/ACwAAAAAtgC2AAAH/4B/goOEhYaHiImK + i4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AjD8/D00n + M3BjAQUrI18TwdGlw9TUS9VLYAEGIzjS35zV4uPWMDQt3uDqk+Tt5ExjBiTr9I3u9+RgBl/1/YgoKBBo + gFLngAEaY7LgqwbvAB5/EBmh0LKCBpiFxApcichxkZk6NGbgQxJgXseTiL5AgMPEHRMrJlHKJHTFwEV3 + AfjN3ClIS4Am7ZAUQMGTp5kUJ9qdWFGUJ54VScmN0dB0Jx4IUcU1MTCk6kwUKYCOY0HVq8wrAcg9OGA2 + FJBFb/9JjVA4jga0tp3ixnW0dxOKAtcYwkGA91PfVl2yUjsBpfCmw6/MpNXK1nFHCEjEMTFguaMWxT+Y + FOjMEQGMul1J+0Nhpa5qiENojBv92l+BcSlq+0vRshpn3fVSjGsBvN7tak0aF18nu9qJjcvBlWldDc7d + 6NJQwBFHAzs4BKAre4el15GWzNQelB0fDII4FqnZA6M+bLPZIOsgG8JBd1iT9TwRgd9OXQQ2zBhNDQjO + XvoVchw1TCUYBBEL/tEgISiItFg6HSn4x4RBeIjSCOLQ1iEhIkrzFhAXEjLZMEgAyBF+Ke50xQPVBCBf + NMJRw0RM/YDYEYstDoKCYlZEVKP/P0KUp4h7PgK5IytEWrgIHorpuM6Slq1QTRiEgcPlSU1aCIIiWFZj + 4pStEFlEkQb4+MB1bK7CYpNFIiDWMOLVuYoQRVhY5Ivw+OkKkUIIoYgWDMloKCpvFaGoIjcN89ujqgAh + BAiTJmJAbz/AgOmfRUhqJSIaiKPTqJuMaWapZSbCgm+saoIfhYsYAYQURiwC5TAs1JpJiK5aacSbinyB + DYfCkrJpESC0qOEwxDVbCghGSKGtIjSA2p21lwi4SBG6CiJFIi1UIyq4lNDoSAN5eAFAIgiAugRR7Foy + pgxJDODvDp0aUukPI+SrryJ7+KtwFYk0Z6nBkoT44SJeKDwA/wGJeEmNlhB7kofF8yLCKDVgdPzJBxZ7 + ce4hOGBDp8mNuCqDBAqTwUYi/f2wKswxL5JBDwrvwEEiY1RTMM+aZABA0H40XE2ESGNSwwUWp3HmIXHW + t2bUirh6R7/+5rGyIQfkyHXPihAA9gAhH1JHNUmefQnKCnuRCBTVBCu3JTJY7MYeqFYzw96WVEFG3Tez + XM0DhFeiggV1J4BIy/Ux3vgkbOwQdA3/LH75JCCsnYTkiIjzuSGuZuCGwm6ocPokrq4Bub8WkP46J/wq + nESxt0eSwNpk2N57Jg0c7i8awg9/CQdr96D8JgxYXEKvz2PSxtp5UF+9JUsrfMf2l9RQgv/uDIBvSQLG + D5BE4uZP8rvCEsjQPiV+rF0C4PNHUkQbIOePehBHSAQQKqaw8vmvEGNKgOYU5jpbmOpRDGge/mqhqUcJ + oXvq20IunIS2zqDPYkPjRZHaMqYGWGwHDMNFrGpDrEVswWJbGNstRog6mYhrETJIXxLioCRBLKADEbkh + I/xgMQl4YBcMYgR+csCHCLzhBv4QEiNAwAOLXYBzEOFCBLYYAQW05QNrk0AIIbIBLkaAChTgHTDGVAQ0 + pOwXKxrhAswYARHogB4Sk5giTGgxA8LRESLwgRkxcEd1EEFAxXIj6yYYETVUQJBbpIIexCQgISaCAzRT + GA9RooAKmHH/Aw6QxhFGaUlE1KCKCrPAEVXUiBvooYxcpEIMngAMIijhCBQqltos1rSZ2KEPkNxiCObw + CyKQ0l2KyED6BuCFDHyDhoOwQwjoWIEF9EIJSqhkKQ+BQfWNcSc5EEMwfSCGOZxBF9jEpTFxpQi6KQwA + WCzKAt4QzAiIYZK3OIISomDMfbIzER8MGvua0gEx0DECelBDLY4wBSc41KEBXIQHunkxvHTABHR0gQli + 8E9XPKGhTnjCDaaghEYQwGIDQIMMq0KEDsjBBWYkZx9yAIsnnOEGN3jCE/jZCDCeMIWFsYMIYMnFDfDB + AYVMRQ4wEASc3sAGO+0oIjJnsST00jI6/3BAPSPJhwVA0RQ2eEEEXJBGnDohChHFISrfWRsH8GGr5Ozq + KGygBgwQlQ9KoINOHSGE8VmMB6sckiScoAMueDKjLhCBA85gg06owQEvOCwXXeCAIziBd0J4od/kBxw7 + LCAERKVjCPqggDvSkhJnyIEauGACyYr2EUpDKRk+gB0KKOANB92iDzawgRfoQQE3SGrX/tABO+hBDm/N + 7RZd0Ac17oGiA/BjdG5AgT5MU7kR2IALqIBcPWDAAQuYQwzm0IE5OGAOvjXBG6gwVuW6wAVysMMjxIfS + AVx1PDawgwJM4IOt0lGQZfSkgH3A3tAqdwMm4AIQH6GCtfpLAgRY6f94lJDVN5gAptjNMHYBLAcFLPgR + DSCg7tKAKScswAFy2AB7NcziCKi3DzqwQUkhkYa1KQxjrKKlbRUQggoY1MAHBbAPTBACEcQgBsLlaxUA + YOMBkEG6wpoCccfr2xDIwQR8qECPRWCCPvBBAXpYAF0t0QAH+4sM34RYSe9IgT+0maZ0yAQQ1gDdAfCA + swdMBAN40GQJXMCZeT5EBhgAtPomgQDxDDQhVACAZSqsBEBVtCASwABF1ncHd0henmtQBQKgYYEoTQIA + Ih1oIXzgAl5osr+SwAMGMPKAQuDAFhyNUi8Q4Gp53pQUElBflLqhDVUImPnuZAQQ1EAKnJtdVcmMsIU0 + K29SQCgXECQlhGxhi3NU050bAPCBBATqeXpR1LSJBAIQlEpb26JbErbgBzzPj0WCWJER5p0tZCN7oh9I + tP/6QqRjFUEK5BK2pAeRqHgP/OAIT7jCF87whjv84RDn2hDiEx+IT1wQF/9DxSNu8a5QnOIJn7jIN87x + kpv85ChPucpXzvKWuxwvgQAAIfkECQMAfwAsAAAAALYAtgAAB/+Af4KDhIWGh4iJiouMjY6PkJGSk5SV + lpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wJQQBSt1JAhDwcqsLD/OPw9g + VikHUAhly9miM8/PYU0nMNN1Gnja55tI3evdTQIGUOjylDjs9t4nLCkjCPP+jGUOGKAxBsyDe+uWzAjQ + oty/h4sQaFlRQMAMdQh/gElxBaJHRGVwaOiyggacE2EQIrHS5aPLRFAMjEEY5gRDbC9zDsLzZYWAg/ay + 0OiCQqfRIRpa0IDRxN4DA1eSGTX6JcUJe0xOrJjKtcwKMPfGxOOqc4iZFc0SnkiBg6zOMl//DMBg566l + W51aAlxdB2ZF27ungAgSfIgwpxYzmLArYAawKcKGS6EoYG9MR8cvu8xdd8IuZlCRUyGlsY7Jg62fP+JY + sffZ09QuW8BZ96CAOdgQSQhI+QxJgaK4H+KxsmQdDeDB/5Fel6Jx8n8pSqe4/VweCgOKuxmo7u/6OiSo + uaPDU6D4sxMtxFungfEHExhj1WvDEYD3jyUC+snXdkWA+R9h2MZdEEGgQ8JmzpwmFW5BEFGgPCO09sMM + WOx3jgH2/WCFc449OAiBHp4TwDoQLOhWiH80mOI8V2TRDRIkfAbiL6Ep0kI3TLCAE1cNohhMjYaUQdkz + TWxHFoFTXTGb/zNMwKFBTj5y1QJQzqTwUpT+AEkIHgGYZ1p8FiqDhYvPHBdmLVoakkJ20FR4Ji2CpSkI + Dok9E8Cby0DQDph4vgKEnIKgIOGdff7iVTcnPFmoLxog6Nuifj5iQDcw6AcpK0AI0QgUdf7QRHiXqvLn + YIuMaCdyoaYyKqAttPaAFqnqUgZYz0CwY6ynCBGnEYqk8B8cqOJayp9AFKFpIhqso6iwjwmhq5w4sJBd + E1Yy+5ixfxwL0grdsGAtKsQWoUgXD2QHRozfBiZuIgjM5Myn6ZoihBG8JjLEkM4UEC8pxRpRhJwrAMWE + AJftC5q/zyLLTYLoGgyKEUKAAIK2h8DApv9nDnsimL+l2meAiRlzUgQI2CIyxAHdWBFyJA8SoUjERkgh + BcWFQNENGCtDQiARLicCBAhS1EBzISRQCUbBOXMiRQIfrGuIBmNkl0UdSXNygQVJDDCADIhw2RuoVTOC + pSBuaK01B4ks5wzYYR9SoIOKAGD2AGkkUt4zBtzatiFjE5LG3AAkskIT5hXw196VcDA3GonUQaUVwSJO + SIF9NzB3DyAPgkW3eksuyIN9r5G11l7sgUiyz2TheSVrkGG2F1Ug8sV/M3S+eiMqWGB2D2sgAsVeTVp6 + +4eL5P567IdAgSALXwxfSN9/tG62GwkggkVaP7DgpvOOZDD6ABJIIfv/kj/AsD33jEjxfRIenI4gGM2j + v6IiCbiuNRnIG4JAazMg7Tz0DSib1nqQv0IgoCnOyELk5HcIDuzAbGgw3SGu0I0sZI6BhvjA93iQiM09 + AwYYZITiIJiIEXRjDCF8WRu+d4GhCWIEVBJACuM2NwLUq2tXgAKfQqErnamnCDyYGwNq0cMwQS8BPTDb + Dj6AJmY14IGkq94tABWmEZLOFqP6A6CQJIgzPEcKeQDcFKk4iBhwgQp6qI4XhEhGXMRgAxGIowmeIwP7 + DSAJDZjiIOTUgTj6kQLJ8cMGpZgLQInBjxF4AfS4cgHAtTEXGPCBHyugBtwkQIB39IM81EAFP/oA/wNP + SE0QLKdECeIiTosIAhdc4EcTdAA2cjNbCW5YSEYs4JBxdAEXUlM/IbpQGTboAyI3kIPPEOB7ZOCaP9QA + Rz9ywQYQAZ0i9hBEs13AabsgozD9SAUFRPMPPFMEB74nASb6gow5qIAnqWAHfyxSEDUowdw46BEFNDOO + z3QLKc02RI+cQQTD7ANZgICGuZHBlBChQCf9uIEFTAEdlFsEByQwN02+xAELjeMbHJCNBsFtEVKQ5+uU + +RIMINIHFQAkMBwkzUUwYG5JqJtObABQRL6BAu+MxYwc0cvXtc8oajABIiPAhxi4JJZaSwLauDIHoXqy + AkbdRU4HwYDvDWALv//8yBQ6oM5hOqBnt2DpTumHyQHsoIBMxSU3+3ADW/SoR42QwhbmNgACZCkSc+iq + H13AB5Xq9AhHUAJLHdEGupbgp45RQwUkiUgTKGCqoGiQEpRwhLEuQoNz20HvUqOGmg6zr60I7BF4Rrl3 + VgGKZotDcOxg0qH6wAd9oIATThGEwFK2skQY7TszsMa5XUB8wXmCA9SKSDG8IKqiqK0TnBCF0Yo2nIxI + wFznScjgHKEDchhqHH2wARHEoJ2eCIITbhCFKThhCk+IAnNzmgGkas0NbFCPDTDK2KFuwAQYmMMNlIAJ + HSiACDe4wRme8IQpBNgJ/HVEDdxr1jzu5wYv0Kv/dqkgBgxgwA6V/EOCFWEDO+RgARhwqlEDbIMzTEGw + UwXBdM2WhH6GKQZ9kLB2XXBfOcjBAQ5YgA4WQIEbxGABHYiBHl4gBz7IeJc3KDBzwdqIDBQUpnbF0w1y + 8AIqsFK7iLyyOqlgAhpXoJlX1u4G/mDiJ3DRESrwglXreikKKIAPYcaynOc81AUAFrJG4EBvWUyAGqSK + CAvQgwnUWV86z5mxYuiDFyMBgjhQNLNpyGqfQrkAB4iADxvwQZyxXF8qVEAMfNBDMSexYLqaVbX78nEH + MKAHEZhABBWgwhu+/IYQmCDUCnBADHRgCQbojq5LDNmDvGiDHAxBDRQ4gg3U/xDKP8y2EkBYwwVQazYe + kHSGjgABA/bM4gtUF9uM+EA16eoGAiAW3NPkQAkeTdceOBjdipBCAwBgR5i2Ad6LSAABkmjqOwJgDdjE + tyCkIAMOAEDN/U5CD+KAUIHXoAoMAMCv+z0AMvRZ4IMo+B1K4IY1w5QHcfAzuv80rz98gN0U19oOeECA + KtBScoQ5lhCc5qyRBa0GRthnyndwAXMyMFPZetbPjBWzmNUgAxSXgAUAwAAZvFx+x4qTEKRALyPUAGhC + o7YEvMD0KjwS5oQgedWlAIIaBO0PWOM6ARqQAchyL1OCcRbM6CWuDGD87njPu973zve++/3vgA/8IoZw + QSrBD4LwgkC84QcP+GQgvvCBJ7zi/zB5yC/+8pjPvOY3z/nOe/7zoBdWIAAAIfkECQMAfwAsAAAAALYA + tgAAB/+Af4KDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2 + t7i5uru8vb6/wMHCw4wkXTjEyaoFTD8wNAckZcrUoSw/2NgPLCl1GnjV4ZkP2dlMDzNWEF/i7ZMk5fHZ + D2MrXxPu+YsINGDy/zBSkNBHMBGCOinGkPv3g8mJACPMFJxYCAWWFQHALJT3IAAUiiAFTUDQJQUchj+Q + WKmDIqRLKAXgbCw3I8UVlyHxQElxguEDAy1xgkRxQCFHASPACaWowUCWfycgLA1ZZsWMfyywTKWok0bP + ckxmQEC2lRUQUnVgyENSAEHZVWf//wCJW4iuJRQ85bHQ8LYgijoskMSb0aIvKrujzASQl2WFUsP5Djxo + lm2JVMi2EEcq0+VavAKY9ZEYEy8Mjcehw5VZXG5J29Tt8KSQVwAf7HB4ZzIBfVucgTDxDPT2Ha/JiuHV + yhiId6IOcmooCiwpl4Xv80NBghDZhSPA9Gwspl0PMig7eV44SJcrIH74+WEInmYzfp2Q+e29tHzHduIj + bO3kZSeIgO/tMoQBgmUjQFBlCVhegQUCg4d35aRQXzJXeKaNFhcSU8dGTCzY4TAFlIPEcSMGc4Va2YBh + XYq/SLbeEDD+MuF+J2hV4yuaIUKCfNjQYNuOPDIiXTk6Esnd/1cNCaBkLxCUc0IXT+6CAIsNCVmlKz0S + AgFw/A20pSpdFoLAVdlYOCYus2VzgkRrHibXIho0QRl9cdYyRInYhJjnKWfNtciH8/j35yxoNmTAkIe+ + UkaU2cDQKCllFqLFRjlOOgoQQjBShgCVCadpKILOmQiCCjI4aidzBaoICU3Mw86qn1Q6CAr+YLNEYbR6 + wqkgnSIiWzZhBNCrr3MJAYIiB4D5wxioHYsJp78qokGi/Um7CRBFdGprrthQqa0mggpRJh58/rCEmuNm + kmwRzJZjRbvbFgFvIi1sJIBb9F4iRBEgBIvIFUCeIGa/lQhhhLmLAMnEwQhPUsTC3SaCg/8V8/Aa8SRz + FSFFpW3+EIaoG3NsxL2JpPDdbiWbDIIRRiiyQqxBRtsyI0CAAIIUUsSMSBcJMjGGqjdvAgVlzhQNCQgM + +NFGHnkk0sVGLNi88XkREpLAAFxznQgUWLIwa9HZEZH1IDV0PUASiZgB5AxjK71I2l1L4LMhKCT4QxNk + 1XJ2aEYk0XUSHiDyBZMnWC23IR7sMHgGiGBxEjZwxF1ygPghkgAZXe+QgOGT/wBHkqT+WQXnXLtRBSJm + MDnDi6EUYeuADj6nAuoDeLH6IWaY84DinDDsSBA6dGDDVAT+/QcHuJcgAyJQ7DeDnIpwsUEE2DvwlvJ/ + xOE41wBAfkj/vtlYwSilisiBPfYYIEeA4ODfXcgBTNIApyilLqLH+hHIgdwdaosaIlawECbQoG+wcIAP + 1vcGJyBvEUK4gNrugIgJQEpkvJFFB66HvQrk4IGKyMAW6kYAYYXsJ6aIS6V0IIb1bWAOvamCBbpGhg8g + YjXzQBGgFBEFEazPB33ojQrgNwA37CERoWuCuGahgAVizwRTWAr3/vABtXkhESigWUr4NQsKcDACLlAD + bGqQB7UB4Gs0kZOtjmAC/jlACanxAA8G54dTIW1etuAC/0Sgg9RkQG1JeB4iWgAuktHCAVRYHxUWkBoG + qI0MjMCDFgxgKFrkgA/840JqtkDECywr/xe2CoIC+CeGD0LGCN/j2gfkNww1fNEF7YMMAyRQt89R4wl9 + 4B8VnjCRKQpihF0DQOGqYQcX8E8PvpxIAtygNga0Qw7GxN4GTFmWNhCRDLsLRwcqwL8XHG8rUkBDAGvg + DmiuzwUOSGY+Zjk4G7qDAm1kYAemUgQAqG0L4nOHAqIZAR+I4AZL+QARk1BHfejAh+fswxFw4gF7do0H + ttRHBxLpQhi6RKCDa8NElOAA/vlgAxQISQZKoLYeHHEiR9AjKcU4ESAwYKBpCIkN4slAlv6idovYnBVx + kgNu8u8NNu1F2Ra6CIdyLQkcEEoMfLo+E8yTF+/xJQdo2TU0LIUIc/9gagctKo4MMHNwglyKA7QagQ1g + gKjVMCrXCCCwpSyArD7gAzVhcR+z/SGZBFDbAHgwzLLEgKaKXMA3XQGg8jjiA1Q96hogowZM8g97cmAk + YSehgq92LQ40gowNXvBY7FGhD0E9hToNIYMe6PUC5AxNFBzwRf6ZgAt2MEXZkqfOBJBUbc7rjRpC4ESP + UkEOFLDBaCERhCMcQQlH0I7ZcBpCYHbNAipAzg0UUAF+/jACb1BADAZ7CSIg97jGJcJyIZEBtQ6ADEm9 + jg64QFb+bUAEfXBAH/8QBXVqRwlRwC9yzWbXu0JiD87l2g7i0NbnxEAOFO2sNCsgBhHoYQExgHD/B3Jg + AzrYIAcdiMEfnHCDG0RhCk6IgniPYDYSMzentyVhezq0gD60VsG93UAFTCAGKnxxA3/o8A2cAOInOAG/ + UQhvJNhgWrVJgAAoS1EUOqAAMfjAugqOclmJ0OEz2OAJU7iBj0U8iQ/gjmtHrlIUztABLoihvVL+IR3o + 8IQ2P0EJ4s1cJPKq1x2UME8LwAAX3hBNH/Q2ymrQ8ptJXImREpFrZIjDpIigBgrEQAFcCIEJ3vAGE1TA + xjIWQwjsIN7hHoIBZDj0ACyQ3lVl7gaNpoAabADHTcgAAKk8Kg/CujhJ1CANXtDr2s5Y60l4gAGc1HUS + FN3rSGTgAwBIbElp/13sRRghAQ1Itq7XRoC+NlsRRfBAHFKsawCsQQrXZkQDLqBsvfKAAfkMN2n9AOtp + P5QA2VS3FDJQhQ/44QI8IEO5AcmDNrBhXCqMi/AS4QE2NIADBLgAAPK9b0DugAdpiGi/grWwVnEKZlKo + ATnF6W53S2AHACj1xgQVKCDA7F87MwI5zdvxtaEhDtYumQoFYXIQ2ItnICCnBFueuwt8IOaLE4K5FGYE + nWUc3GUcnATI4IUt5IEBa0hADQpc63IJveg7IycByNCDEgDgDn74QNQ/qe6ym/3saE+72tfO9ra73RND + yOzbGxF3Qch97ouoO94HEfe6393ue/9D3+/+9xbAK6Lwhk+84hfP+MY7/vGQj7zkwx0IACH5BAkDAH8A + LAAAAAC2ALYAAAf/gH+Cg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp+goaKjpKWmp6ipqqusra6v + sLGys7S1tre4ubq7vL2+v8DBwsPExcbHyKIaJMnNoQY/MCnMztWZYD9MTD8sEF/W4JIa2z/l2TM0Iwjh + 7IsF5vA/TWA0WkPt+IUjY/HxJwFa8gkUpAECv37lmFipg2OgQCgF4CBEMiPFOofthuAhYfABOXgnIFzB + iG8CCQPYEAoISBIfigMsEJ6w2BIfAggw+jEZA6VmuwlQAiDMYsCMz1lAOkGx0qRfgIZHYSX9MxXTEA3v + +rHoci+qVKVWlsSDMcJrq6qI0Eb6QkOngTJm/8G1yBLvgQE8catNGJETHpMCea0hsPIxG42LgWupdYSA + RlNzTGjgTZxsQlZ4NCg7g/C4XJgCKDQjw2PggV8DopNBiwchNTIDSEC2cG3MslhzM77RVhQkyKAgRIj4 + jtUWHhyoux8Nh2XGSrwAu3sTAr4815eU5ZAc6JpckHTpf6gToaXFdMIHWLojqj6e1orCLCar/zUhwO0f + YVLMD4ZAorkH1OznSxf37QSXgL0MkUI8KyDoixnY/TCDBg72MkJs5hQwQYW8CPUfSxzmQsIJ8FgRoi4K + 3vdAFyfmgkBf5VhxYIu2QADPijTe8iI80OVoiwH3nZCej7QgEOFbRJ6ymP8hKXyUhVFJyvIFieYcEOUs + YZnDAndXuqIFPEsM2eUoSw6CAow/6DdmKGUWYqM5Y4S2ZiskmPcDEgHO2UlSbf5RBgvkLIGanqysVs4Y + GxK6CZ99/kEChj+c0JOiqZjhXzl1cEkpKUMU98MSPW6KSaODtEDOToiJagkQQjCigUflLEGhqpcAQSoK + MZXTRB201morVYrQEOigvVZC6h8QhGFOAJoWC4kQpEIBDxjIORuJrUAUAUIiWNBVzglQWnstq0W0ikgZ + MD7AKy7VJSZEEXwmgoIA8GQq7rhUtTnEZUgQe+8jrGbbpqFp/jvJu4ocACkNic7SrmjvgmAuIl3Aw8L/ + jLCoYUN375aryAhU/jCGfGw6QkUEPmwgRg6uGWEEtG1+YSccI40CbyMVRKBzBGq4Bi8IEieiAaTgkgIt + I0pssHMEG9MWNLcwwlAtKMfaoLTOLpzhGhAgvNwmHiHPICYpfapxss5UNC1a1yBIMbEhV9jZRKqgTNwm + BTnrXAHLqWlbgxRSJEICjDPQ/cmvi1Bgws5idHAiCjOYA8bYrqjxxs4VxJBaDUkksYMbPSSCAKQP1CzK + sTdcrvMGC6SWwQCwD5BEIlCEnEUqfS6+c+uisRH7AG7QPgM5YxjeSghLz9EeZQ387kUiMsNpOixc+LCz + HkeQ9J0iHPyORiIjWNzs/+HAJkKEAjv7IMLD+QC3vCFSEPA7AIkkm1CoZPcZRAxLiyFaDReIXRLugIgh + lMYcd5kFBaynNx1oJgEAiJ0ECIAIPCzIMxDA2CtyoLoIbMABmmFDD2JHBg4U0EM/eECDaPGCpfUBI74R + jiI+QIbY9WANiYicOVikJEYogIER4IPWEuOHJMSuBBlAhAaaQA4kyIlsjohB3jyoOYGw7xABjF0e3kaI + FthpDON7hRiWpoArWsM34DmEENDwuzjUrzOgsQUXXLCzN9ABhopggwUk2ABEoOAyYUBSLTqwtAhQIDAE + 2EHsvCADRAyGHCewki3OMEad+UAOgdmCEWF3AQ8o0f9bEuJhLc63tA04EB9mHIQUahi7DxThEEOoWKxY + EK5aUOBsEXABF9rHCA5sUnZJRIShlkCDMMLCCVxY2t7MEsHYbSFwiLjUD1aIixjg0gcvZEcqBcG53zFA + aPdBwqxw8QQRAJEKjgvHNoXgh98loQaJIBgLeEGBq+mMCzfwiQdGCLsk0E90BYgcE/ylimP9oYU7c8Ec + agKE5knwA40gQQp0swsdTDECVDglRvawBedxMRk/XJoIWuJQ2E2QHR1EmR422kzY9WAP7MiBPT24UGNs + cxAckIAACdgOBxRyA+nERwY6GjseNLIdR0Ao5nqGDwL8MglpEIgNkLc0E9ihHVX/8MLvSnDUfOSgAkCM + gAkOCQ4pZLGf33TILQtZgaA6gwGKjB0AgumQBeBydTVtRhX4CbsdqKAmc7ioB/vghGZoUoAE+OhAAltI + F4iArMZIg06PSNeaSDGsYnXAHYnBgbjCjgxsMIsddLc0H7zADu9jxU0LsYY9CjAOrzTLFORQyNXpYQqq + /U32GrHP3w0AAAYVyBEcMNOdUQEDV3XFav/Axt/xAJ6JOUIHRFDbXIqBCwvQaCeo05vlGqIEviVDFVKj + AwWQtpBUEIEDcvCE7X5ne44wwmFjtwOI0oYCcqACZpf2hj7MIQeFpUR3MVGDEvxSdmlNznT3m74NVOAN + ctCD/wM6gFvvUCc8wTnCEYighOCkdhIZQMOBk+AHAanhBcWt7u6OcIMbTMEJToiCEmSs4RofgbtpfIQQ + 9DhiCiLoBmpQQAjuqmI1TKHFT3ixEzq8Yfd1N8eQkMIHPNtPAhghRHZwABdMsAEG+8AGZ3jCGWyQZBcr + QcNE2LB3KuEB+fl2gtCkUQcUIAIx0DGhf6BDmW/ghBs8AcZRQLN3D1GFltKXAdAl0hR00AEH6IELIeDD + H1w8hSMEGjhqxoQHOODa37nhA9sS1aAfsYazOpcNijXYIxLgB636dgAXgKmqKQEEBhDVnRKA7awpwQEA + UNmkPMDhriVha1aGtw2JHjZv0//Ag1+btAShVfYihACChm6BDJP1bRJ4UOIoTSXVBM6ADD5wgR107tWw + 48EdZL2mVgnsEntgQwM40AYDo9u5bejqnNwNL1sJ4d/w+ndSavC3GohbBR+IAwHycAEA9CDb94ZdCeIw + XkVVhU/U/nfbCF4DD/RTAjsgg8jNHfFX7+ACDUiAtVjVtSIYQQpGAEENElDykhvRnxyQgSedJXAhuCzm + NZB5DapQ81eDnAwA4IAHPKCEWRfh6VKQudtUUHQJkMELPAAAASoubUFkS1tTT4IEOvc5L6ABABfIQxr8 + 8AF9d50RNdhDAmRA9wTs/O14z7ve9873vv/LmH5fxBAAH/gvRHSF8IEf/OAJsfjCG17xzUK84//Q+MlL + QvKWz7zmN8/5znv+86APvehHT/pSBAIAIfkECQMAfwAsAAAAALYAtgAAB/+Af4KDhIWGh4iJiouMjY6P + kJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrL + zM3Oz7hdGtDUkyw/AVrV24xQP98/AnXc5IVDAeDgVnV45eQI6eBhJzRa7e7VEDPx30hwKzjwbTtwjR8T + K1AEDhzD7weTAtMUQkOwgkWYeEgEdJEIDQ+WAieWpGMyYwVHaCgINgxA4uSzMgZOxAszpqVLWkAydbHS + JF6WFjdl5RQ0tNIXGvyQGCgTVKimFmDiPUgxpGmropugFATHJIAZq8tIWMFI4x7YZCkexAsQ8CwyHCn/ + yDJ1i2yFWq4B5tIthgcCxhR698bC6shuPJOC+Rpgku7BgaqJiS1Od+JL5EVBcKFAmg7GlcuKMhvKLJpV + mbHgluQF3SgIkUNEiJQ2dWXrN8SsMZMerQpKz29MHiTM3Vr0bFUHfn9jgYJ4a0GyZa8qwxlcCueRXpuG + 0Xg4dl5d7i4P/D1XCsbgIJTnNQQO5c/rdY0Q/4NG/F3VfzTxft8WAvoCkNffLAaIBJw2A9piRlTgCJDg + LSukswR/D8YywT7grFbhLCsY+MMDWGw4CwoYflOAiASi90MWCKAYiwYyfbOEAS7Gkh8LNcLSBRLgCJdj + KIQdgodt1/3YigHpMGck/yhBFoJFjB9utKQqQ4yhIgSQTYmKARc5NMYEWqZCgnJIwBcmJ00KUgaD3xzg + y3E3pUlIAegddCYqXXTW1p2X5CTnHyRA+YBNt8Dp3FZMjGPLHDkI5ueffwRQZ5G1UBGBGBiosV6EDdqS + QwSggvpEed6AA0eLtCgQagQmaAcWpIJ8UWIYX9EiwqoY0AWEELCW2ASCpBQBqw1ihOrDAobGyQgeqLVp + Cq+MxFBBqBXYoSusfxSQDo2lYDvHBqHyocNeQ/0JgYFM2HfKn0o4YKwcdJALawvpBJBlKNAC8ScGxr6Q + bJxC/PFnHXcxMUa35SrCx6oKOLprEUYkQkI6cDQXy/8NJqwag2BFCOGxIlBACYZZQDaSwxuhukCBYB// + iYByM6DarSIYU7sxy38EnMgXWfQoMyl/TgEuqConlpMQRSRSRs/fzBARLGpYSvQNDiOt8yFfQNnE0yUz + YkPGoFbQ6F5IgxBxIihw13StQP9JxLQR+LBBBxwb8XEi//UYYiw2wA2qtXsVITi0iGgwA3onkOzKGSGA + KvfNgoEAwtWGXAElHFy/AnbcczhaBAh/YsHj2qZASsStoTpArhFmC5uIFlDiCLTAjPAbah+RgyCFFHJC + 0eVBe8KihwuhivBvUxAn0iFwAijuSgerijGuW2lcQEADGShyLjgnztLB0HFPf1b/DwOUP8AHicQlI7ey + TLG5Cw27tYP5A8iASBljGIiEerau2scUZ8kA/ZKQJgSwAD0TqoW7qOWWD9DPC4nQgNp+4LRaUAB8G1iZ + VYrQBvoBQGIFY0HmYrE5H2DAVTfZwxbMlwQCKI8rY7DYLJSgh1WZwAbcON4g2GAB8+2gAferDhMoRYsF + gC8CGqxGEHaTiDhIwHw9sN8hENCsJSiqFlHYXATkQA7XHO8C9LuAFBBxhRKBgUKzUIAPUia+kyTADSxk + QCK6gC4WmKkWdACfD3B3kw8kwXwWkOIhtJUhXfRhVRvA4TOYmIgigNF8H0QEDmzjplzYgXih4oISj8cG + L9Av/w6JGAGGgnNHWziBC6tCYjOW6Ig2PLF8ZGDD/SCgnADIEBdqOCIfnKFDonjSfBeoASIQUB2lgGkX + tnOcA3oZDFYmAggqGKAKEDEEEhyuaUDhxQ2OSIUkliMDAHigIlbwuzGMEBdqXNUblsFMDsyvfBJIgyIE + AA4kFOBeupjCwoyVK2Q4UxEgCKf5eFAFiTVGSr5Qg98isAHVkeMD7yyfH5KGiBsJaBcLTBnduEE+87kh + AREc3W2GgcpVVcCbwGCmEDhAvwG4EG9QOsEtf2GDfYbqDYB7hgx6CEhhLqIFB+zeMOyw0EvllBk1uAP9 + dvDSRmjBMsWIWirFgKxmxIEMHv/0gDuCsICiVgByyUjAL8v3Q4UYMZURwADVCgUJKWzhj+bzg08F0oGi + boALbaQFMwXmh5b2gHL4IIK00EoFBZyhGH6kHxmm6RIdNC6Vdz3qLxow1gHEsyk6eMERHfeCDozKF2wo + QUsvoFWrKGCzEXCBCfSgBhTiogYlgGv5SlDQs1BABKi9VB9QaovYLpWxbrmBAqSGVlYpIK+x8MBbBwjE + xKhBs8V13B+icATpWMI4ezWEDAAg2wHsgAHYuslzK4DJVYngDzc4ww2UoIQokOZ4XkREEI4gCTYI1Idt + IM4ZFsCFzTrgCDcIsBOm4IT2UvcICD7CElm54CValxCuZUT/A9DQ0h3I8ztqwECxUnuGMzzhBjZ4ghOc + EAUiHEEJCEaxEuJriNdk1xAMqOwAWgiC+1CgD5r0sBMCPIUbTCHBromOg1/ciDtgtaV+GOODjhAF6jrh + CFMgcIFNjN0GE/kQCVjuAOVYI+mYuLomls0/M1EDd3Z3AGRoLp88sYZHDhANtV1zJwggY8teIHty3oQH + PsCDV9LPAgSocZ4z4YEGaLmlW1Czc8LbLT/cd4BJ8ANI7wNYVHggA2nogZ+XWoIEKLk/AQOC60rBBg5c + QAJnNl8J/LChUI9aX52oQQ0y4GgetLSlXiDApB9UlEd1bHCEa6sgMvABBrShBzvYdEsl/0AGPwgyR0Bg + XdmkIOs/NAAAbWBAA9awBhU0QAVVuLQKGMAADqQBAF7owZFvTT8JoIEAUhB0jfSlL4gZoQi7M4Iw0zDA + HVjAAm54IrPXneqW/nEHeeBymERtBNbtDgTCfDS7Jz7xJFigBByQwafPpC8hSEHfu/tDnSnObrj2IA+6 + ztmgiRJtagOB5CUvXxJ60AMAMIANcV55Ij5QPTT0wAvp7oEFdpCEHXihBCVAAwAI8IEPrEHnlaiBDLgt + gxoIIQFV2LW8oc71rnv961oaAj7Brgmxkx0TYjf7H6qi9rNTwuxjd3slskR3uV+i7XbPey3irve++/3v + gA+84AdP+AvCG/7wiE+84hMRCAAh+QQJAwB/ACwAAAAAtgC2AAAH/4B/goOEhYaHiImKi4yNjo+QkZKT + lJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P + 0NHS09TV1tfYoygBCNneBT9hEN7XXw8/6HB15NRj6O8/BRrs0efwP0wsLRP0znjg95iAMdCtXzMoAu79 + eECjoEFmELLAY5IPy8ODAcLcQ7KizEVlQ66kkPhuyQMDZj7SAlIJx4oT9x6kUDmL5R+bkrTAUUgjJc1Y + QHBKKkNDoZUrP5GZSWEPHZIASZEhSMHkXgCkUVdGWtEUXwA8WY29nFggbDE8EBSm8Gh2GNeq6P8eHGg7 + rIyBe0260BVWBuA7Fjj2SgryKsA9K4EFPyLsSgMcuD+WjFNsibEpDTPgLdFLOVIQy5ZHDWlxjwW/zpCI + GAodKsW9AkNQew5NhLUnBCwgP9Ai23Ohz6NIdIWRuHfqU0PuljRgfLbqUkNYwHswr/lxU1qawKPB1rqt + oiWheL+FgCS6MbHH11oBLwxn9bPwwICHHj6tA/CajLA/q8z8dwLwN0sLS8BDgoCxTGDeDzQgGIty+Dzg + kIOslAfPChS+4tcPMKQ3jG0qkXDPFxm2UsZO6DAxUy82CAJiVGm9Q1wvL8jRomAaNIXEe7mo4UIELuih + 2BiQlbWLCBEkGUH/BYLFiI5punTwo5JyCCbcOw9YhAsRXPig5AY6XCQUIhNIl+Jkt3QghpIRYEBZAZBB + dcsRCmygZAVqvMjOmIXUAQ8cYJ0SVCN0IJmkD33cQJkGMMUl3ilCCNFIDnYmucEczylmJjotoDIoI314 + GYEPb9iBGnjoGOChLGe8wSYGmSq2AhIpWnEaKTZ9ikgMFXyZQ1J8GgIFreicgIIpnwY7yBxTRhACHbLh + oR06S/hUirKETGHoqC/EqhK2guABxjs7ItuIDSGw6YBZ2JZh2DsYznIDFUpScaNscL7DnKeKLCBqBCb8 + GpWuiBhQIDoFdAeLA//yEYVxB2iEToCzYPBq/1bgDgLFn4JmLAebQg6c8R9QQAaYuYvwoaQLc2AsRMYk + NPpDFhO6coMJorqwAMYjm0HsDycECksQax5KQViDYnuFzDNgBYsNvSZJxdHGXTEDXA8ceO0iNhQ9KtVR + SbpIGeY9UNwrR1QawQYCAzuo2IcwCtcMWsOiQ9RA7iyyEEUYkQgK/4VTsysmsNlBVnwDAfchPr8zw+Ct + eO1DDDzfpMgXmeFzQnWwTKFyki6si7jiilwx7Q8zCP2KEi+AzG4RRSSS3TtwnP1KH2y+gHjfRWCrRVNj + 3AqLAv+G4ERURvQNLn610kLBvxsoASwIRbysCHvvGCnLDc1GYOpPQRUBgv/1iGy4oixHFH6o6EkZYcTi + heDxLj7xbr0I62yKkJT4RmTsjlM8isUC2LSBpIDACAfEVo7ecQItzcIG/4rA4X5SgxpIAVtQIAkTZmA7 + WBDBVUrqlkoIoAIpCAJ+hDjAwZggp1rogU0V0FM2pDCAASShBARIBB5oAJcwcMcWdoig3h7ygRoaMRFl + sMLBltCpW6gvSXz4yAWMOAAAJAIBTHNgLYinJB+o4SFAIAMVOZAIAjnOabWAGpu4YJAiNICKSdgDIv7x + DhbqwmK+6kcN8kBFNCjCCnBZwlxyYQO1RUB/9GADD4yYhBwiQgM/m8GjcsEFNrlggt4AAgEkYEQysCH/ + EQaADAwgRwsdGPIN7MgAGqgIABMeAgdWgMf57simCCiAGTIkBAM4WUMykBERJAjcAyapCzrgLQJU+F4y + gMOIElCxBAlIxAokFoYxkNIWDugeH6CljNosgg1JoCID/IaI3FCrAMfqhRK2NSo3LUOGGZhiJ2uQiC7A + o1y/UKO6jMFMRjBAjDVMQh6QSIOfsUB1vZhDLamAyQ95CxGLNCIaVJAILMAALhwZBgYiiCdhgGYRUuAA + FQcQB3oeogwrOB0LOAcMOnzuUBXoQC6LsYaI1tACKByEBhLilBQgNJ8gPFQI2uaLz+QSBBcIZw0l4EhE + tOB0M1hHMShwzCVRDhgz//0AL2sIgGjO8X8/aEIA0lmMGNCLgApQlC5mOogqeAGOVVBECyS2kCYeQ00c + xYAN2MoKvnpAnksd6N8Ct4T6IIMICzjryuSgzGK0YQes/GQiUnAwdOxnGWp44p3YJwu+/sGNWx2ABNYA + rvn9wArOoIMcugdFov6iAT2gIlMb0YLMNKFuzNBBHwyppDABQwbOZCUkDNAgaNxAAYpNkhh0cIMoPPQW + e0CDUmtYAsk+gqzQUMNLQ/eHG5zhBkrwJik8S4gEAHapMsiKA+jFhyB89wZPcEIUnPBcWMRzpG5ggFmC + 0AcKBOEGU6ADgJ3ghCNE4Qj1XcUetjDdAezAD640C/8RnjAFJzzhDFOgMIKVcIQO93MVwG0wSU26lyAc + 2AlKgK9zjxCEI3BYCUFQDWFivJpPNCC4jGxDb2pDhAoXOMZE6DARxPsHo9qGvIowAgNiK9s7eKfFSggv + i4v8mVjN+KEJfsQeCABZKu4gDnKED5BnbOTfFJkQR7jEGs5bwx0wIMIlOnMo4mBTI3pBv3EuhQwA0GVG + lqAB7PKFB/ywAxFLoKuCGVkrMsAAHFPRDWmgjNgUjQoOlKDPjNzCBzojKSD0LxYJ4MAWRmpECxDAq4rJ + 1ctYQrCtqYAAPcA0IwFA0eawmm+R6l0pVHDjt5JatDxggAesExTFIZBvUkg2CP7/AOdMyEAGfgCABWz4 + 6wGggQAZoDS7XiYE9yVPCiAAAT0vYIELcEAGGchAmBtBzyKsAdoXKEESQjvSHZCBAekVUN8QWAMjSKEG + QnADIy0AgAvkIQ0MYIMMeJ0AD/BaBg3wAwPaUIItvJXepE7CFghAYgQBoQjgtqAUZFDtebfZAmRIwg68 + ANkd8FLEv04CGS7wgXWX6OP//oMfqs3znv/a5RdIQwXzbAhJ8dHnSCc1J9FwgTiom+iLSAADANADMuyg + 0EmXbaG3cAECVCGuUI+EDD7gBwLc4QI8cIMX0i7zHrhhBxVHQx7KXoUMoDrsljCpEarABg84fA1G2EO+ + O070RlXhHRVDMPzhQxGb9Ch+8aBIfCEeD/lOSH4QlK/8JhSfec1v3vOgh0bnQ0/60pv+9KhPvepXz/rW + u/71sI+97GdP+9r3IxAAIfkECQMAfwAsAAAAALYAtgAAB/+Af4KDhIWGh4iJiouMjY6PkJGSk5SVlpeY + mZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU + 1dbX2Nna29zd3t/gn1rh0wc/BuTQCGA/P1Zm6cwaAu3tM13xylr19Q8Q+clS8Gv3IAUCgMfqnBj4oIAG + hMbmDWxS4CBEYihoMBlIo8xFWEAmmTGwkJ8VFB9jhYRkBkKWgVaupFy1EshKSCggPODXhIbFmcBWDERS + AKiwAzv5oTMa9CW/FR6Zurq5KCcSfjOgSPU1QSBWmVt70YAJL+wuHPTqNVlqVheUpO3/mLRoOynIqREP + NrYD85OuI7uXqC7yGpeG31w4xuhtN/fwLQ0l28GZ4BhSEMB/MHcaAmFggSGVHxEZpNlT2h9MHjwMTQvK + 1XoB8LD+i7n0JsI/kOCb3UjzaE84Iv8YI5v3IruAg/zuJLTekjrGey//NAQGPxbFix3JHIzIdE8tljiH + boxCDu7AbHMaAoffmKjD1ITY0AFg+HpItA7TESJCBB8L5FOGdbANE0UfLvjnnx35rLDYCav98oQCCSq4 + QYDxBKdUMDGYoGAEGzjwBEAF8ANDdrxEwUWFEbigB0Qa8MPEOL44sIGCPojAIEQs8FNULzp46J8PJtR3 + kTn1nEDZ/y5OYOCDhQpE8REO4tWjnypACOFIBxV8+MaOHylWz4+qCCEYIkf08SEVRqaEpD2snImIGl36 + 50IfRl3RhHMRniInInp8WAGGM+HRYz0rlCnIn4PYUKd/XNzAlAEmgYaKTYsmMoQCguogVRdY4XDpI3I8 + +Z8cTkiFA1xLkDBqI3Y8GoED3810aDsH3BKoghVMEVaJ9RiGpSI39DckBgAxOoiD9Yxh6SwUUGFhm+ko + KwgUe9ojqp+MLHCjfyach5CyCDiVmqt+WovBhyJIGtYEtyJB3ixC+qcAXVY8RYsOLPpAAV3AtpMCLTGw + WMGIbVEaLLeLOGBqBCGk2tabPwTwLP8sCjwsh6/jMoJXsyjJoqaCfahnlAbZ/pBFyLGI8OG9F1mLw2IP + LBnLGx86AJG1giDw2g8PoPiKrNQmq+wVkZ0AViyyqpESuey0cwIWshwhrYLiJtvIBDPghy4sUzS9syN5 + xdWXK0+IgeO/EJm5yKpxPXB2K1PUG0EMO/OsQdf29OlKFMb+p/O4PCPA9w8nfFEKz0e4rCDMYzPqcz82 + i8JzEC98iOe4Wi5Cgom0cKqgCHkzUkfKxM2ywMMmcJyPTUIYwejH7YzBMixqsLiBp68XIYTvjDbXTgC0 + 0PGoD0WTg6myATPBVixE4Pw4Qloqi0IAaq1wMSwj+8fHzkJ0jsj/aT80pvqHG9CRT/i/i28IAnA9sLQs + dHz7H6HhAFFEESAo2wVccJjbK4LAhw9xIR5AAMHvlNWClJ3EFg5YUzzCVwRMJYIwTBBWLfj1IfyFAwT9 + SwQexPSDJpivFgVU0BvI8TsjGMFzhzsBjWyxgA9FwGngcCEIZKcILZQNcfOrhawO+MEaSMF9hSgDbjSo + qw+5gG3diIMMBOHCRCAgX+0IAwS2R4sbXM0/IjCZNZIwAB7EwW2IMFw9mHAlXHQPRHjjBgMGQMcBSCAR + ZehMXMbACx3IygTq2wYP6jiALSTielX6QQEqhwvRTU8bKiAjHZPQgESYIWo/WMIIemEDtSmI/wo4vIYH + LkBIL7zwEJxxDgsYmYsFsCgCJpCYNRqwA0ISwJJYRA0NhKYLLjwsApGyRgZIWUc3ZCARUIhMGHbjCzqh + TwEImwYD3FDHJNxBERgUgDBqKKgF1KoZHigBIXuwhkRc4XBLMAAveZGxD4khec3wgyQHkIRbImICBnjQ + 14DxhBW5E4q9EOMhakAGQpZgioi4Qi4VWQz5/JJNvxBoITLQBkImgQOMQopeHjDDYXTAkwpyAZh2cRmJ + CiIO1KxjCaQgwluFgQa38+gX7aWEXPjGpAmwwDzJ8AFFrOBnTcgVMihQpzvp4AZRMOkqlEoID+TBonc4 + 5SG+0J52LGEM2/9CRg669AJB3OAMTvhmKzAj1kMQQAKEBEAC8KgT/DAzGTYQQQ7OcIO6PsEJ25FFbRzR + gIJWs5yJIAELqhSGALDyGDW9wRRuYIMpTCEKSmBqLVQwyDqS4ZoiVNheOsoMItyVDlNwwhSUEAUiSLYT + tWFqAtAwzwFcYK2J6IJTcuOTaBzhCI9VrBKOEIUjnHYTv/1DAgBAyAFYQKqHKEMumQAHLXCxGUfw7BOU + QITb3ja4l/htDbbQ2h70VBEQSBkSUgCfaRDBCU7YbRCOsNu8jgK7VbhAawfQAGW9xT0CjEZ1e+ud6kb2 + MqL4LRCkwF1CuiENjBDOD+aVjduadr3KIY3/aV9RBeJa1A8eYMRYsliA8mbjwX8w7XJKutdHYLcQDRAn + ISWQh0fUYScsyOo3kAPgQUwYPaUAwQfI0Np6ggASCBAA1ZbBM9oQ4jsnfkQG0pDSOu6AABkGR0iKbBkc + hzgUFUargQmA3PyNoqae2AMD0FBcOzYAiVKuHpVjoQIA+NWgKtBaSH7XiwwQoAdlHkAeEHoRM035FkX4 + Awd6UMviWoDLRskS8NZMChl8YAt5HgAAGlCDmdjEJvwLHwgq+Aop+GELWi4uGdIQZaBcughG2B8IpGDE + P3SZFFJYAwHcUOgyT7rSWwGCC11YA17/4QJb+ABLX70JKSSAAyXwQqQl/2CBD/y4LVkyghSkAIIa1MAD + Wt7BBTiwBhmwNBNAqEED4rCFQc53kmhoA64P8ztWHzEOZbZACS5AgEp6YA+CQPMhMqyCKtyhDRawAD3z + TEYe+KEKvBFCtYGAZ4KjdQcAuAC9G8CBD2RABSrwQAPYsAYGNKANaQAAD5R97uK6AQ1+yACxK5OlkhOc + jjxOghcksAOBkwGtoY60k3dwhw+UOjqE4ACok+BynRs90juQAL0z8OytPFfJcbhADyyQ86NbnYwBvwOU + 8e2Xp0PC0QxoAxpoXuiiW9SOEiDDvD0+bboM4e2C8HokdP2HPXCAAQy4QAkAUIId8KAHSZj6DtAgb1gA + AIABBEhAnJt+GLg/S+6TCLRwB7yGPVy8BjKYImyBHvfHc/7zCPE86F0B+dGnovSmJwXqU8/61rv+9bCP + vexnT/va2/72uM+97nfP+977/vfAD77wnxEIACH5BAkDAH8ALAAAAAC2ALYAAAf/gH+Cg4SFhoeIiYqL + jI2Oj5CRkpOUlZaXmJmam5ydnp+goaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2+v8DBwsPExcbH + yMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4+Tl5ufo6aYa6ssFNO3HCDQ/PwFD8cQGTPU/Ajj5hPXr + NwZBQGAQBtYTwO6grwMKkVhp6FAVkEh1Hgx8QONKxV4tTvRj8sAAno+nLk46kGXjCpSpVD7Cs0JkPSZN + usDUhSPFA371TmDZmWueQiseid5CMGZJvyYplFpshADMxhFSb41o2S8Lxayy8Bhw2o/GBLC0cFjZWAct + LQRc/+vNMEgtSLYVTQYWOBsNw5NbQeyCMrO2n1BoNvhEePFHMC3Hn0j8JFjGWYwKESJsWLBt7MC2zBxQ + yZx5QwxtCGYMZLHshmjSpClsa6HwgDIHmGFvcKArcKgxq5PN2QA7whvZuxxDzlSn9rEFxSOI0NFreScB + A+EYizGatA8Ran75/tRl4BItxJy8KR4CufhB1i+xAPrDyrAnIoqbsCNMefxKtPXzwFetCCHEIwr4AJsJ + NhQj2HiZ4BHXDwbEIoRMi+SQW2mnOQgfJykMBEZlvtygGGy8HUPEf5ZoEMZAOrWCISMKuOAdF8kQAQpw + NwXgChAqzWiIHcSRVgF16QRYz/8DKPwoiJCFcAGbCx2mg4dG9SyB1SpQIkKBgqSJEM8QAQwEzy75kbYB + f/Eo+cMMfLHS5SBqgJkZBgEhgOUPTHzhpCJSqtlgQDzWA8FUjdhgI2l4HmTAQGPISeOUSAaExUgPxIkK + kItsKF1FKEz2wxIk3FKndx18VOgPttmCAWxiHPFRiGXFxAgRJsDWaEVuwmDrInYsGoELqX6kwUaaxuIA + rH99dGU/SyQ1S6CZ4QgTHAOhN8sRYsA2x06F8fnSLGcIG0GlHxVAXwG0qKEbUStAa98scyyYzpyD1EFf + pLPoAZscRGmBRD8w4BNLEHLo2g6+kvUzw0kHh4AiURrYxMT/CXTF0i1pVaIEl2HSwuJpsTCZoVpQfpKC + ryBP5JqZC5zthINVS5Yaiw0ua9axORfNiQcMAtoMCx0buhDeTkPMABQSQsPSXWZHo7PyHzbxSaArOUcQ + M89/9KyIqD9k/IqJpLmggNSNTDBwPwDFMsWJEfiQotT4IjBQEyTGQm0Eu6JEAn1Z0JJgmEqcM/UfXaz9 + A2uzOCBsCIOWw+kiLeTFpxV5w9IBbBWw6A0QBy6yguI0QByLE57uHM7kizzaTwEGx/IE3GbLyvUi9PRT + 4SxB9OGdmJIHqQgLA7VQC3RG5iB56IrgsGcYV79ix4abBd+1IlAAHrssU6QZN2PjGAg6/wiKrPDiQrco + ABsVUYMD+vuJDGHA+T8UkLksOTy9GzleK1JmPWFYwfZkEQTv+YAP5LgQ8w4xgQnFyBbDgc3WPncRIRRB + EeUxTJNukYONxU0EUwCHBUFQhAUWogy0qoePcHEE9ZGGCgsonDdIWEJFMGVp48LFFLLGBTp4w0AlxNcV + gManBzzwFk/Qg7Bg+A0ggAAE+GoB/eAgNlO9wU5vuAE3imCEIoDgQooI1w/OtAsMCMsFfcMGCIzwxUU0 + bElHzIUO1oMqbkhBClCM3+j6wQLT7QJ5L8yGDO4ghT8YoZD+I8sY75cLJ7zATiFwwjWAAIABSOAO5FPE + G3+ABND4Yv+HcTvbDWRIDRVIYAColEAGFKEugpkhGB0wQapuQMsoVGMLqERlEmSQCA2c7AdNOBQxzkDL + M0zBdtH4QBJyOYA0lM9yP4BByoThhCdMgQ43cEIUSOmMBPSAmWTYgyKw048AtG0YU4gCMafgBCd4rhgZ + SAMzk0CARJThAIozojGCQIQnWFObUXjnMBjgBmaioQa9XNUK96kEJdzgCUo4ghJ0tIw1oAGcH1BEHarW + hFYhIwj+nGhEKZoMACwzlRdoXlMIUkVjEKGdRyCCRElqDAYwcwBbqIIi9iEg4zGDCNskAhEaikxYCNQQ + RWgAGZjphgZocj7lPOcygjBSmU70YEf/LcQHSnDTOCASESmA5g98+oyYBiamNGVFVgmRAR6cFJUlwFcX + qoaEAGzwGYGxS2BWJAgIkQIyfHVEAi4wTx7oNIwDgUHTpLFX+KT1E+NRziMyYFJm8iCjiUCBZ+qBhBTc + tRoQ8isoBBNYRwDBAwA4ZS530IBMIiIk9IHDNIVxuEOEVrKQ7SskZJCHm+6gDRfsZQAUmYU4DqO2hQDs + gzbhH0nIoARvtSQBvnoIze7pB1FJBnIRUVpMLJcSSd1CdCXQBoTa8wB0ZYh2K3gJ3FJirYioQQO84Ns8 + GMGNxCNYHQZ43CfVMBP8bEUalspMCfjBvIkgwaqaYIDPJgOMmnhs/ymqUFlmWoAACE5E7soZvWP0DH7B + 8AMPbjqAHXCAuoiwguJ+MIbZKoNTTiyhCXXRgDwkIbo4xSwjBEAfJJCVGUACghdLaAQjzLgWeyCABVSb + SwkAQJyPyF0WfuwMIRdZCCCQQg2ksF1U+KEETM7lhaEMiRQwYXfSsGCRa7DGGghhDU6NRRE88AHx4lgC + JWhAhiGxAgdH45B41LIQuIqGD7CxFTJoAJhJPAA3EIANBymClvGogrfywA9sSMApCqmCPIiX0WQAAAfu + 6xAgaLkGXL2pFwDghzWQogEMSG2Ym8yDOGhaHPxdRBFkwGhU7oAMaOBAFQ6LiULKQAUMQEMPcP9s0Dio + ABz4MNgQcr0IP9C316i0QAm2wIA1PPsPCD3yIC6I0CrsgQEcAEAPLDAAZrd7AGhIgwxQ3I1pR5vajGAA + DyTgbl0OgAw9cEMe7nCHBsQBzipIwAf2wAEZxOEDeSAAGrbgBgnMmsQAj0MN9gxtaVuCAxfgwQ6wPc92 + j9wLSfCCBMiwA4u/m+T+9sIdGEBmc0x7EDenxBoYkAd29xvmQL9pD1idgJqjY3v4dkQNjJDuErA76FBf + phvQAIAPqEDcbmHEsD8AAACMeOQvJ/kyT2mBHXQ9DjLQaXBR4nFOyGAPbCAAAy6whQu4oQRusIAXdiBy + il+gBGnIQwMaIINJLWddFIX0gBSEAOkGeEAFGXj7Hjxw+EMkvfKsuDzmN8/5znv+86APvehHT/rSm/70 + qE+96lfP+ta7/vWwj73sZ0/72tv+9qEIBAAh+QQJAwB/ACwAAAAAtgC2AAAH/4B/goOEhYaHiImKi4yN + jo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJ + ysvMzc7P0NHS09TV1tfY2drb3N3e3+Dh4uPk5ebn6Onq6+zt7u/w8fLzn1oI9L8tTGMk+LwrPwIGKOMv + V5eAAR8UwFHw1oolCH8wMdDQFJBHQ1rMQMhkRouKpC5CghDxBwwtIEOJ/LNyEY4CDxAioaEhpaiWjPAE + iHhixZBuHUT8ZFamCwuOYLoMxbaATwQfCwoFQZZxI8IAS6kFiSHCRYSvfKQmMwMT4QMIE6rZ0VPB69cI + Lv8oCMN5CAuciA+6UFPT1cfbt32eDalzQiaNe9DO6HH7N0IFBdJScDzx8ZkOOX4bi1GgZBoJFkwQsrji + LEeIzG8rvFAzldqBE6ElUmS2gErjCGIc2LiGQEBsJiwQJ4shprEPOXa01YnYZLatIpEcbGj8uBsNJAiz + fLEFRAikGBUaU5nzxFdrR3QPaQGDsAkE7t8ZP32jA1iQ85pw7BSNh1b6RGqY0JgJcoEDRWEIrUBQLECI + 9B8hTwj4lg980DEODbH9MAZpsji4yBNcUKcGOS3EFNAJUDAIiQKoOZZDOWaMgdASNCzoixryuTAHMvhp + AhBCJ9TkyxNO/QUZMkT0iAn/AlYF5FOHiyjQmAjl8TjVfZukgJ1AKLjyYCE6bIDaBi82oyQlQxyQ4QwM + efnlH0G80NiOy2DJCZMzHvBKg4tQIJ8IU5jpSQERWZGWLiL8tcGIzOB35iRdmPjDDELikoN8gT3TGhGa + IABaQiOoctGbcIb41gbJaXolp5igYAVCYTiXCqlnTPeWHtJsqokBGY6RiwN/uWBhNKxu8gVEATXBYS0R + /iWCPHchVFktaqDmQwfyYBgQEgZkFUsQGPxVgTxDGLDlDzR4G0txb2EwTwsRsWCLHfIxGs8XeB06i5Rv + iXHDPHgg+MMSWNQiAmqZziNARCvQQoeEXzmAD6EBLZGC/8NjFjgPBBkWYCMsCzBGhT8HnBuAvrCw+JYI + Z+DTwrkCfPxKH39x4U8XyP4ABy2JfuUDrvjgC+QsT4TwV1T44JAzEii/AvEGSNNTRhMRtQmLDew+Ze88 + QwjMRKWv3BDeV1Rgi88QTS7RTyw6ZC2sOm+WAUN7Bcdig60RbGB2Ol/iMXdCdcPS7FMb1Ae3Ijiwd+La + sNgx9ld7z4PnidvJ8nTU81wh8AnCvTJFz3BhLo8GD8SWhdWegx7BkfRgQXVAYDTtipw+c/HoOA92EYZo + tDiQmQ8i/HsOqfoExIQAtCyAtwl8M0ISQjTQ0gHeEaSKzpc0RCRrLBX8zno5pC4sbf8ttD/FRZXmfDmE + 4gEF/q0DjIVgOO6NmCHpEmbUQtxbZYPfCAk8UdcrdGC0t3wvHN1hxAHidYs+oIZ5uCPVH7KHkALcIgYt + itw3+LSIIfwtIHXABcQi8CxxeIclirjC/TpHC369ZTfgSCAKEzGCiMxAgLE4g1tcwIVAxVCCFBOILl5Q + AT3sBn3d6E53jKAIuUVET7nQwVTOcIMbOGGDRQBCEYRwwkN84VxhYKEtnFDFMhZrG3x60/MCAoNeTGEK + VHRCFL4hBBkiogwyMt7FeCFHOtxgCnLkBp+KAJ1EaOB1P0AC43ZxhCc8wQmB1IYQCGmELCrCABGBQX96 + QQQlTMH/ikfoTDaKUEkmLoJ9P9ijecjoBCJE4YzVIGQdFwGFiDChcr9opBI6eYTbOeMiRZACBxGxn4D4 + KhhBUIITjkCEIxzBGoQsAgi2qAgE5OwH07JPFHrZSVhCwwhGmOabMAmkTQojCMxsJjOl4QFBSEEKIPgS + DrIQEVUOo5lBUKc07uCGD7hzET9KyLKGcZ+pMNOXxmjAABYKACkUEhEoQGUAkjGVJCUJocLwgBcWutAd + KGIIa/xBE9xnjIKyyk7IMEIeOLrQCygCBU1ighXM1Jp8YpQXIGCABFjagz0oQjIRSRFNBZGkY0ihARZg + qQRUoAgSSApdvpAgIc6D0mE0oAQs/x3AHR56iABkSJHV8OYv2FCCJHA0CVvo4iHgVU9hqPURRYVTMLaw + U47yYA2K0ECTfgAG1PnirY6oqi8ycIGs8oADiyjANRs2lz/MMhI33URkEyGDPJiVo2RgQA0UsZxCGWOS + lpgsJKgqWkPsAQA7YOkOGCCFptITIZQyxjAlkU9O1HSqlajCFrKahDbgUBBmCMA1ISCzYIzKjpAQpSao + Ooi4RqIBALjsQslwgc1e8lw/MNRnGwSEaT42FUoqVmkFoYKNspQMacjAIuqQIZOIcS5aBAEXjQBYUNx2 + EPedhAcIQIasDoAAPlVEpHiSTdmCk5AgSDAxirAG1GbVC3dgBP8UjlLPLiVjiSAwAjylYF1geIABZWVp + ErzwgQ4jQgNWwK4VLLwMIMCzBhquQQ0ukABfqCAN/RUxDz7Q2moqNl5+VYY0awCCzcZhABIgAHJrkQEO + mDereWDqIsoQxIDAgaS3GMJStIweDv9BBnUdwI4zwFVYGMEDKghxVnsQ4UYUoL0zqENxs8xlLj+itbsV + MQAYUIVY1MAD0A0zRyVQgjWYOBFV/sEJIGBOXtj5t4mQ7nlLAOBWSEEGDLiAoBeaBAsQYA1lJmZ7H2CA + OevCzn+AtGkB4N+FSoAMfqhCjVHxgTY42L872POhE1HLkmzvF1uWxAd4sGmOegEAbfizSvb/sF8AkCG1 + /iV0GmbtCCy8CiG/voYUCMCDHPs3CRLIQxsaUAOf1hcSQmgnB9KQh41KetBoyEOfJXGFACBhIslAtSSq + QIDotrqjAwAAANKwhgb8ocabNaUhoLNZKVRhDwxgN7Gh3eodlCAPeK2EBuDA2HxfQgYfYPW7lToAN5AB + DQC4gB8I0AA+N0AFKmiADOLQAAIQIA082IIXkkDxf5NhC3HIuCWGgBJyQOcDF0DDyL+N5AH0d6M9SELU + d7DTnv97AElIghsusIYqgMAmhwBBwbdggf4u/epoZ7oEeEBpGXAR7IxoAAfaYIEeYD3teOc0kr3ghQu8 + PMBwdwQTE9CAeJBfYAcWyHreOZpai6PhAhz4QI2/HnhLZKAGHFCByktwAQugtgQ7QEPoecADAKDB5gSQ + wRp8uuvKZ6K1GQCBDDJQBVkzFa+z7rHrd8/73vv+98APvvCHT/ziG//4yE++8pfP/OY7//nQj770p0/9 + 6lv/+tjPviECAQAh+QQJAwB/ACwAAAAAtgC2AAAH/4B/goOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpuc + nZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY + 2drb3N3e3+Dh4uPk5ebn6Onq6+zt7u/w8fLz9PX29/j5+vveTx0KfET8CYIMgbgpORxwEROhoYtkBmiE + owOQiouGGO0YQyDgR5MWQ7jZWCBiA8aTDR0Uw/Lgh8sZGrap4VIBpc0XtYA8MuCyZwAc2HLIsXlyQwgM + MQjO0vmoTICeLldYs6HAxEWUPiqIUJADF9NHGmb0ZDKDxC8hlHKIIBphA5cFdv+UMGvxgInLJTRQ9BJS + ZJKCqyhNKLgBrUwBqFlalOEl5KsjO1xMoqzQhwLhaF9g2P2xJEDMZjr42PQhQiM1PCua9DxRRxdTx4s6 + 1ET5ZoGTa1cEhOk5BqhXQbATzZGM0YUINdpWnIB6gFfwQw5mn1TADcEYqDCuIItBvGGFBd7qtHT5AMIx + Ct0jmIjxbYKVzUismPm9KIf0hiY6hOuy3CWS1ks9YsMbPpxkgg7iIPBUT1bk1IgTXKAkBoLiTHAAVEh0 + EZIsQDxXiAOTsUcOCnD0hEQKeABjR3cbzKGNh4RAMBYLwAQh2nTohLXZDyC5ohOMhDhQIEYCoYPCgpzl + 5eP/H0AKogMVRZ3RTBBKZdLCWDDMx0uEJ6nkTJWY4MHCjgdsmIsagEXAx23qHLkZXhPoQsRaGG1AATtD + XNkTDHHmwt1JfbiDQ4k9jZDLE32cRMVl7JhhhYkG5HJGmoFKQ8QmQxjwZoO46AGYndNcugkW/f3wwBe3 + nBHCSXJcA2YlOrp0gha3xPCpiNW8Sol7JkpVCxEYGPhErpzw5JOZstzAEEYYzCPeXWPoRQuaxd1Jja6X + QKGaS2BoOQsGgPFhgzVUDpQJCqU2gSotQ2GEE7mXlnvJEO+5xERzs+iwbAQugOeqIKJacmRPTfgqiw0n + +TAuvIJgK0kKUKVAy3AYvUEh/7mcHLBjALQEi1Gr9Yww3g+9yRJEog358C49I+z2AxNj9AnLDSIM6QJ1 + 9XwB1QyzPGHCSfrVY8bID/gWy74+4DrPFWCsZlYsOvzcEBVKy6NBFj3BJAsFUkdQQVf1oDByE0a/smKd + w9pT6g8GxXIEYD5cPA8KMPT0wNMzS0dF0PQw7bQsObyBUQVVx3NFXbK2DUsOq05dODw4LGG3zK/QIbhD + /tJjhuTkUf4KH0NG4OU5Tf5BwrY/gCFtLO02pIc9I6Ae7Sx6nFRkOkBe6BMtC5xUwTpAGuuSRLOcgRId + 9dAwlsS0XGRUH1HUU+/LBsuygBpHCCLXPHgQ+gMShtZyA/8dN9yQtjxXlPrAZ7ME8cQT5Z8RsDkwdoFE + T2B4HssTTpD/xPbkKN0KoCKAWxAhCjbgX/TGUTpBIOkHzKtFEJzwhCk4YQrZo58iZrAjANniCFG4gROc + ML9wNMkMqGsC+2wRQieAUBwN/EMdsLM6WyjhCVE4YAm5EcPD9IR4uDiCE5RwBCKaEC2LoBtzdqGEHBLh + CA67RodKR4L7uSQMisNFEJRAhCAcIYPd6FAjZLSnXjzxiUqIYjVeswjv/SBSvHiiF4+wQykiEUhXgMoP + 1sULgmyxizxsoPDIUqMgEOGQ22gMWvqiiKb1BI6/oJIh1QgNIChSCoqAAlSYwMdI1rH/GkhEYiICsKMx + IMsX8pKXNXQiSkQgYGQ/wJcw5AVIaggBLXxZhPB+cIKyBUMpqowGX4pghCIACQ+lYkIBTlmjQVAyGcQk + JiPISJ4V0iKGg6ilMI3QmEXgQSz2CgAzr/mIYDaDL0IwghGaRE3O4A0XrVxElZ4ZDCCAoJjcTCLW7GWF + cdIintvIwB+MAAIpANQQKdjREt5pix/94aCHoGcwGrCDBvyhBgZdxOGgIs5eAKEIEE2ERHexBx4MYAAE + +AMIgOSUHanLF5YMaUQ/CQwZlOCkJwUAI+qwI2X+wqGQACMxanABnJ50B4sYFFR66YtbdqgIxqxGAvKQ + BKPuYA2K/5iAD3tSPcZYEgQglSkyhCCDO1QVpxJgACMRIbLNMKGA9VQnSIsZDRlcYAdGlUBKFREWDEFB + GB+VKwgKiomRnmINW5BAXvOwh0WQ0kTmIYYQBiuFgtbgFMAkhGEZQVY0nPWkZMgDOzn3stnFYghm8qch + KlsDwv6BAZ3Alq42uwghfGALnx0AGe4gg0W0YEe8ZOgrUCsI1RZishi9bBoGkAdOAHO22dxEBu7gBaMO + YAcESMAiNFA3ez1AlrIg7h+MWwggSAGTHyDDSUsgAxCAgpbZpK0hasCGCyQht2RgACYVgYIxALcANZyF + eCEhBQ7gFaduYIB2PyHfRjAAAIq1qv8fLqsIBDyKgPoL7yAGzIg4WHcASbjAB/a7Cxm0Qb3WBQBsF4GA + ApD2ByzQTi/IW4g8fHgAPchDFXRRgzag4cMS0PFaE5ECWDYhfLug8SE4QIbcXjfBGK3FHggAgBu7IQ8J + EOsfIIahFviCw4+owhYOnGIG7DgWGfADhJ08gC1wYMiIMMNWZRXZadQgDTxgsxt6EIc9eKAVCUgDhCNs + 1Bw74goFQJ2pUhBgaTQgDyg2alW3kIcGRJUUfQFBFfKABgmwmQwXUMGfGaGBAsASgo2ecSUSoIItgPjD + eM1DG2TQWFDUwANVaEAJ3PBq6+5gC35obyM0oDw9RjAbaCEAGiL/bd0m5+ECMlDBH0ZdCUYmgAEEaEMP + 2HxSCZQgD2yg9iK+cJ2xPACS3VABA1zNbRCTgQcAIAAHVFCD3tb6uILYr3YzwIEGcAAAPCADsyW9g2+L + +hEj2GdPsgCBVGvjslSu7o1xql40WOACAGgDttnAABWsgQEyaIAfGsCAC9zhAl5wg8TbnQQ3ZFwFJG7E + Ll3CcF+CQwZVuEDAJw5r3e4gCXnes27VmwRC8/y6PGhDHNhghEi082UzKNM5+tKAVpfgvkfPutax7gUA + NKABAp3Es/bUBXb0RQWtti+v2631DyfBC1sAdgZqgE1E6O4HVpDxO4TgAZLnYQteqC7RT8rtf7N6egA8 + 4IEX7sCBD6yh6ZpAgfLQLY/LVgEIjSeAyXmAch6goeApBwAa0HCHPDCeDQ3QrpYnUQYk6+PPCShCDdZQ + gwbIIAMN8MAe2HDRsK+eH8APvvCHT/ziG//4yE++8pfP/OY7//nQj770p0/96lv/+tjPvva3z/3ue5/7 + gQAAIfkECQMAfwAsAAAAALYAtgAAB/+Af4KDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOk + paanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g + 4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fqoNgsKXHxMVNjgIsKfIPtW5VAggkqEhxAjBkGY0JSaPhUi + atR4sGIiIZnoKDCxsaREj4mKALGkRk5BkzANEqKIcmUlNSJ8xIzgQ4wIDA5iqLFxAyUim5NscNFp0ocJ + DAuKGm2EVJKCDTDfKLAxlVJVRnbemHTxIkdXS18VOXipcYMeqcH/0i6CMkYDNCdySrrAAFcaAho/flh5 + poPkRj5miclNhABJ4B9LuuharIiCQ41U5iijTEhDlsc/WOzibCgGVo0i6CwjPeiA48ctJj+KwfahDwXc + 8IwBzQIFsg61I2yI4W1Ek8dIVtRiXYjCaYgV1HybYIVJ4DBWENBayfyPjsvQdYQb8eBxltjLG0UxDJ2r + Nc4IqgdGUsC3sLwRqYi/xnnIivI/MAHGF8I40BYF5XwBRxjzQRCMHbX5QJw5Bbz2Axj2+SJWRHqggwVo + S9TxiwIahaCOFcjRkKEuNjwXARXuoXPAcQGyoB0vXGikmToksICcZLuowdRDfLCDQwCgFcCL/wgRuZDY + OhCABoNduQgZEQbuIADgD1lAoQt+D23QlzpDIPmYcrjYUFuH7uCRgnWBDYaLHhGJCU8dSzw2IC4ZQfRC + PDjMYB4Wt1CgkXTW0GRJGQHkGSCatbwQkQnYKFoJHjTAuQQNE9jS50O4ydPCa0wIYEsOEfkQIzxafBbY + DDfOQiJElM6jZWBMPEAoLUxChCU9YziKxAi1gBfBAtlYeqmZgUEaiw2pPpENEZukAFoKtCwQkRjaKFvJ + CnAyQQMtsz4kAjfeStICaHLKkqOv3QqSLiRQbDkGHrPwEZED8WoCBYOBwYDDLOxFMOE1805yxZYz4CvL + pxEgSg8JggaWBf+Vsbi4aqLyYoICjVzGCkttY1ZD7R8nW2IGHI+FgTEsHPWbciVXnPDYDATKEnOlJ89M + yQQV/4CEGbPccAMdRt9zRcW5klA0HWckbQ8CTTiahcivOPHEE0YnzI4ZIJ/QqSxPOBH1GUfYg4XNr2Lt + ChFT2FB22vVAAdoYK75yBNdTTEE3PVpISQsRSkzhxOH2uPZYu7IccYbhf8+TAsA/FDAELUrMHYU9BYBm + QC1KOHEEEVF4nU4Z8kHmbCxEiH6EEj6/g0fQSOxKSxSjj04PDhYukXcsowdxROTlcNaFhQ3bQkTuSqTD + GQQWBjD24EQIr7s8gD32+S0IEW66OWX4CBv/Lt1XLw8JADady0RBxP4Na+s+BkcZurQ/ETncKdI5rgHs + cn88KGAZrlbHPXl9TxpI4QwUaJSrnNVPXu7DRv4WYQA4/WAM9POfAcNBmvB5LhgHhIZNSEMCkCHBS8CI + 4HscYQDe/G4XKqQGEGbIiDKAATQOAsb/tkFDRgQONFcoRgg38wfmBMCCoknPIobIjBEu4gtsC8wBltMd + bQABJEVchLUecwKi0QKL3WFiMYRAQ9KgYEtMUNItgFCERoixGEUgIxBAsIgVgIYJL5vFFbG4iOZZg4xk + bGMiZgea/uGih+Ug4yKi9JgHoLAWipygN2Y4QyHwEREICBoTrHC5WwDS/wiW/IYRilAEUDKihchxWi7Y + KIU4XjIbpSxlKBWhgS39IACdPKQRRikEELzyGpaMYyOYJTQHniKXuUzEFYsAAiNIwZfZACUQpGAE1tQB + RGpMxRA6uU1GsPKZUmilJN4ICyP8IZykVMki8AAD0JzAbaboZjcZYQQQ1MCZNaiiMaSQBw+cUwqsKcP+ + 5kNAVMzTEUKoAQie+YctcECQz/BAD3bgB0EAlBFdsOW9XHFQR9iTmlsYQBIYAI0M9GAAA9hBHmQgBUYs + 7TG5yiNHk6lMKdSgBCgdgBc4UAlvkXMTUmCDF3KKUgJANBGZ8hxNX7HURDCAqAOQQBqqYIkdUuSnlv/I + wAeGClUZLKIMjFwcLZqqCAZwNac7uIAKagCKHYqiCgRwA1ST8AEfRvEHJ7BdLLj5iCpsIQlE3YFDMfG/ + lGH1EQ24ABmImgQJNIARJHDV+G5BVkQkAACAJaobVnqJqw4ihprggBckwFgLPHYRExAAaH5AA4cdwwhr + AMAOoDoAADQgAb/s6WEVwQY/iDSwaFABI8xAzB8IIIPKqAEBeJBZlEqgBATwqi5AQgAA0JYMF1hDDZPK + Rb0qYw8c+CtUdwCANbD1FhmQAQAWC1Uv+EG6WrQQl4DkjBqowLq0TSsDjgoLIKwhDzilLQ/WsAdG4GCL + oFkBcp9hhOU2l6gXYED/Al5BRw4wQALsJaoFAHDFRhjAlk3IITUakAcvPFikZEBDHIS7ij2Q2AKkZewA + LlDRRgwBwY8pwIKlUYMEmFUCDwasG7xwBw4U2BQfaAAP0EDbqO6AABNuhAayl6QX8pjEJ6VtY3dQgjRo + 9w/C5EQVpNAGApAhw1AlQx546oi/gOwHD8imNqSwhgucVcZRBYAfGlAFFWTAK+dMgBT8wIESoGG2J0bp + kmUAX5eqdrUFgGc2VECA0TY5pxbYAgAucIEGyKAKa/izEKK8B7ZKYcJ7UMEeGEAABvBAtklINEqTgN0P + /PkRLbhrYAywY2+wIbyzvbRIZyuBHgBgCzzIQxzy/xDhOAAgDX4AAADuYIEenDTYwrbADhgQhz+ctxFX + +PBqsyBickjhA22wAGBlTdQY0xqlZAAskGctbOcOoAcl4ACLHzEBEtBA1ydYgZXF8esSnDTe9U64sIWc + 6Tjw1J+QKEMddjNuYrUjqGkAMAAskFN2Jzyzo93CHdKwhy9LAg8FeHOcvAgPD6hgDQ1ggJ3RwAOODwDh + KXUuYMkwWx70wAtpuAAH1iDcb6vrhuM2wMDqcV4ZNOADa+DAs+NwgS1c4A5W98MF8tAAAhhZBSCBeCXK + EKzVNgEOB2B5PugoiAzQcQ8yaKMMQHLk3FYCAatlQhgCoIWzaLOCjYTAwP0eCjIbxkmVhFdFC86T+MY7 + /vGQj7zkJ0/5ylv+8pjPvOY3z/nOe/7zoA+96EdP+tKbnhqBAAAh+QQJAwB/ACwAAAAAtgC2AAAH/4B/ + goOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9 + vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3+Dh4uPk5ebn6Onq6+zt7u/w8fLz9PX29/jG + QqBBRH9Pas7c6NDBxh86dujkayRk3yY6QToocPCCjwgTG6iYqOCCyhsRIuT0cZBj4SEgmp78WaCACxUx + PiLEjECzps0ILlzQpCLC5CCUmGwswFChws2jSI+K+RPEJNBKZ+xg4JO0qtUIGJjme/qH66MFLzZssDoz + Y4QKJsRE2FCBytEOPv8JeV10Q40It0ljinnDZ6IDNTY6UKBzpsOCOXNamog5Je6kDn3GJtXYZ0EMQY0V + EYki6AncrT8j6TEx2YSCOZ2a3puLKEiOEJJvVuAS44bjS0BYI7rhQOdNHxsUfL6NSbehHC+QVnhxQyXx + U2qoHpWz4LkllMYPUTAq24FB67gdBVkQu6YIO0eaZZfmgHvNDVmdrY82x/1OB7bBm1JCAW9NMRRkxsxT + 8xkyRDExkGaTGCVJkxskLYxBAjF28DETTW9cNk2Bf5QBQRY//EADMSL4hmF146wQYogPIBBMFA7ctIEa + qomDxwNMrAhBMDHYVwFq5hSw4g9wlAELh0+IYBP/fOh8gcSQXfyiQHkvfHeOACuGMWIvOZRXgQ7qHDAk + HBrwckMfNlGhwDoazLDiCS3wsoB9XOSXDg40rIiEAXjsYmFNVAyXThkrPBAiE1a4mIsaF/qAQY3qdOFm + iCeUicsRaP4HZjsIsDDkAblQoCBN8bkj5IoB5KKHiVSoAU8XKzIBxxW32PBGTT68kN446yEw6Q8zRGnL + HLFVgOI7OFix4gNx2pKceVa6g8KpIRpwi30K+BMPBLGOYUsOjW4aDwlDwmDpLArYZAI9ZsBw6AwT0iId + TX3Qg8AYOf7QBBa12OAAF0ZpKA8eAuTLxAq13KCtDc7NU0C+SKRASxBP3GCx/4DzqBjiEgUcKEsUTlR8 + A8byrPBkiFZM7IQNN5zhhD0jDMmCorEo8QQdTzihBDeQVkLCCSuO0acsR0QxxRROaKtNz5RAYWiIM6Aw + C8U5T7GrvU2smMW5sBzRXBRKMA2PryvCQDMsSkyhRNH3fAHioWe/okQUR2x2TxlA/8AEvLMUfcTaPGvy + hbshNoHDLETUfcTV2Sh9CQ5Zh5hFvLEQQUQQi3PjuCVXEP5DFofLknjijM+jQb6f0ypLEP1kvrQgYkfy + c9lDx9JUEEpsbo1qsUOixck/sFC77Zb3Ho3xknQB/Bger8667vGsEAaqthT/+iYGoF6ALbw3DnsmeR5q + bf8tyB8vCPSR4BHAkM1ODHv5y1zOFPyLTJD3D0gI6/7811+CwNs/eEDobsE6etQhcj+AwQC5V48VoC4A + E8gF+tqxvhAhYXsSpMcEPPcD/XGPftmYzxfyxoQHfIEXIBxHC5awIuHlIoXkmAC1RKQfVgAQCe3TRQHf + gQXU/cAMruDQDt2RgumFaAxG2sXO4DGBMQxpR7BwiDvm4zQ9QSEWUnxHdlLQrQWuIjcc+gZ2GIEDT61o + fK/AThbPwaE6sFBvTbiiLIRghDBy40GKGEIAUMe8WeCRjaFRBAmeFiKEYXGM6PjjIri4ohkAMRTNYwQQ + hJCbhpijko0g26EwCEmPRRL/EbkpghQoWQ5FKsIAQ3oAv0QxhFb+4ZOIoCMIGrJGRcCQGAUawv1ElERW + CgKWhyiCEYxQhCKAQByTFMR8NLYiyrESmIkQAgiMIIVq2vEZmOzKIq5wP0T1shZSMEINqCkFbwChCA+a + TwpQ1wRnmsKVjBBlNWtQgz/UkxsNKYIlFfEFQiKKFdA0RDWlUE8CcCASt8TFg4RQhEWUwQrsdGcpAnoI + IdTgmHkYABk40FDxIAM7pkTECFDHMYqCwpOOAIEHSjCAlrpBBQgdIjAY2lCGkhEMQzpB3FJhUkIQoKVA + 7YEKrjkIme4CBMKcZS0LIUPUHewXDeABUFvKgw/ckxIJ/03FJPWJTkZ0wYghEkAEW9HTQiRAqkBNAhoO + GtNe6JOhdZyPJgsnR2B8wA1THUAPCHBVj/5BaUZ1RT2lgFRihrQQeAjfGYnxgR4kIa07IIARJlGjrH5i + DRdA6kUPawhmhlVqxOAADx4LVDIQIAOVCCwrGJAECRCgK1Io0AiApy+JzpQDW8hrEgDwAaxaVhPEvMNU + GVDNRmiAg2EAFTLYAAAJTDUJFmBABjr6Cw+sIbdT3UEG5lPGIf2gAMMrhhBkgN20WqANMP1FFeLghbxq + dKmFQAEN3qg3OIT3GAm4AF6nKoGqTpYXDADADty7BeoqggY+NJczPMCAEpA2rRdg6/8tLAqA/aY1CXlo + BB5SQFskjAAaNVABGgas2ztIeBYqYICFzcsAR2QvlcqNxhrysOKWSmAHeegtLKp5hy08GKhuAMAaGoEC + A9C3Wvd1hhRE7Ny8SoAMF2DAMVXR0A8wwAI/BmoJ4oDaRhgArCGS2DUSEAcH6zYJO9gCAfZgismqQAUA + 8EKWW5oEAqwBvoVAwAz1RgMvTsOiVcjDaN3bUi9cQAVsyEBfOVEFFdyBBzUuLRqqgOdC4KCCQ9rS0mQA + 50ETegdoaEMapCsIA0einmvYAwEI4IYeDGDOr76AHxbNTyx5twB+zkYVPnABHpDYvWjeQQ8AwAEGMGAP + IKgCStj/bE9B1FOcf2DDHz7QAAJcYAtkIAOhgeoFoXa5EUOow69WJOZwyOADPdb2tm1sAQlY4AIA2IIf + /JAHDnygDR+Iwx0CnIcS9ECq2oZ1S8mQhDRwwAORWMG49WUA0I4jA2uIQx7au+7nPnYHj3WDcwP+WIFn + dwAXQK8kSIBprcXYHB7wgAo4UAK8NrniMK94EsiABgK0mNaLCPcYjvy5FnzzHMesARvuAG+KezzmpR0A + AHqQ7z8wOxITSMEu9WUF1cEjAY3mNRqWPoAdqJu0P26ytnkAZQAwgAMywLkjUKBw74aIBlyLx5RlUIUM + cIAAcUjDFi6Qh2FfwNAAAEAceBsHnBUkQAbNrgQKuhCAJvAcDDk0CcL/gPgaVOEPGUB8AgRRzkyUQQMG + gAPPmxCAVdYwFHhYARx8aEEDxP30nMABBHDq9h8E4ISwB4UBcOT2Jowh8rnvhK2H1AQwpIAEYw3+J77g + 3QfQoAs/V74nnBiiAGhB+qWIWQFsi/1PDOGR3Q+/+MdP/vKb//zoT7/618/+9rv//fCPv/znj/1AAAAh + +QQJAwB/ACwAAAAAtgC2AAAH/4B/goOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6Slpqeo + qaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3+Dh4uPk + 5ebn6Onq6+zt7u/w8fLz9IJFQPW+QEL4+br9/nbt+3Tkj44/FIjEsNEhRw41f+wEnASw0hOHChyI4GIi + xAYTLt64CEGFjwgRDhTEIHJwYig1ahTw4eNjQ4SbOHPqjEAlggkufRb8ueHSUEVHU+h0kMOnQgQXO6NK + vQnVBAYHFPwdnbRAj4ipYMPipPLmRYx8/bYuChJDTgWoYP+hOjURQaSJDRt62oy7gc9ZeUDULrqRQwQV + uFF9mBDTh8scBzEW5KBwZsEZBx0c9MFgooJTsG8ARyKips/eqGLecOkQ48aTtYKU/OmwQMEbKqdzbghS + 9JAOB5911hSjoANE3pZiKHCr08Ef5OsEJ1KSw2NUqw6ieLJDQY+Ym2Keu5OOyPv1Ph3ojDqioMKc3oTU + vPCxk0ofG+pPFYQfpEMIxDhx8Rd8qyzwxk4hKPDHfgSiEsQCwd20gQg6aNdgKkQo8F1OFSjQ0oWoRBFD + hIo5QBSIqThwYE5iDIjiKR2YQB9OIrj4YiXkFRLEilSZkAOD0+SYjA4Y6BSCUNYIiUz/hj3hVAEFQEaj + ZDIL0HWTDy7MQcSNqDjBB2L2bTMlMQrMGIEPXEjE5Sl05PZGB2ui8oJOC7zWDgotfMFLB2ZGIMKdK4zx + ww8G8OJATj5AxA4Egw7Kwi5BHFHlTX24g8ASjSKBgC5KnCGIA2LYQA55MDT6wwG5BDHFEzecCE8KTDQa + QKpPsNpqPF00ygQYeOCixBQ23HCGE/EgcEKjJ2hxSxBKtOrEE1Gyg4IVgzLxwAq4ODGFtkpA5w4KKWSa + whC2BMGqE07IFs8QKzRRLQ2b1qJErVEosaU8dWTRqADxzhKEE1EccYS68kAxA7Jm1PLvEUQETA8OM8T6 + AxMk1EKE/70D3zuPAKaiSgvDkUYLTwESI1GovwJHqrE8E6yQaQET0EJEpN3ms8IDjdKAgr9BMHuEt/K0 + 4O7EAthy8crzQGEqGAoHMbM/COA8KAwa0OL00/mQUKqjVfPcsz9Y6DvoCWVYLQjQ8uAw9A8PXGH2RCgc + PCgYUPh7NtrxfAFHozP06y/S8mggNdsJN+0PCg9IfELFCgeEBRiNsuB3LE4HBEUYfJf990QkmMoCDo17 + g7ckLQwewM52fzN6JAdI/IMVoa/uDqONFhBnKjSYim25/pRhhcTXlvt1PQhs/cMSjH/MzfCYRN3oA8mn + rg3gldQxOAu93m6Ky43Crn0ivMn+yP8EuTdqALnfG/K1+I8Yv0QLq4xpDXTsN/KF2D/MoGf6o7SwtCtC + EAfzMjGE8g2qANlbRQDDMUBM4MF4SNidAsWBNepNYgSDe8DkLoE+SARGdeFjn5DKQLtBjQF1muigI4BQ + hAWCw4KTgIHEmHA+TgwBfSpMxD6mVL9wYOFYg3oAFjpxwz8UUREf/CA8yDMEA7juUZ4g1xEVwY/AyA8c + 5MHB3hoFAc3ZMIdIFAIIWuiSLrguWbAAghHGKAQX5uN3g1rCGEgBRkMIwQhGKEIRjBAQDWCuUR4TRR0N + sccigEAKRXBED5mhpHAhC3ShGOQhhCAFENTgkEpaJDLSwogrGI//hqOQpB2NUMlDSqEcAMmRAf7Itv3R + sRFCuKQUavAHN8KGGkpUxBXkNigaeFEWs6RlA9yggnCkkhFOfN4ITCHKQsTSCHkYwAB6QEtINHCTU7oC + 5GQVM1tIwQ3SlOYFqsmI8DUjMLZMBMme14VcWCCcA0iCH9J5COZp8h+P+KGpZpWLBsBzAGTgADkVgZx7 + 5mJMQwiAqYS4izQkAZ49+MApG1G5Y6BTEEJqAaaqZbtd7AEA/0TDByTRM4OmkR+DyFHclta1XSSgBA+V + ZhK80AD5wXAXbdwHPQsxhAJs9AcR1EcD0ADPJPAgAY+oqDCsSElGdGFtr/slLzhAVHhuYaTQ/8BHEoWE + gG0Oqgkt9YUUGvDOcCahBwwwqUBaqFNHwNF8zcTFB3ZQVAs0IJHLAMIY16hHRgwBAkgw1QmLwQAv/JMM + achAMrTKQj0qqQuJQ9YQi1EDBvDgnxLYAhv4WAy93mOMU9IALwcVyM5WwbBFBQADQDCMPSAVBCDAoxGU + hAAWmOoHCFQGG7ZAV3i6wQ9IBQYDJACANcJ2Sigw4MRYULjFqiCa/0wCGhrgiwSAVJp++IMUZuuIdSLL + lcuQQh7AidkLrCEXNUiAH3orTTKcd0qOfJ6yoPGBLfxTmm5ogwxswQYGlOC+AwCAI/BggMGxDQJxLYYR + EnCBsv6zB3fYg/8s9kCAErAXniUYqCIMcFtCVSMBHOjBheM5zQvswQN4TcUeMsAAC4xYmjuIgyPKEN9G + pQAbDWjDDiQAYAtcQAVVkHApWMuAO/z3vkkgbnAZgYMCGBgJBUDhNRhwgSQDeAdbyAMHkLpTTAjhA5bd + QUwPWwIGjE+ht6VBArMBBAIAQAJjhqcE3GCBPDSgAftNcSVqwOI4eMELcU5tHJbMCCwIylRM6Kg3auDm + HQNYmhLggRcuwAEOUDe4tKwIa1l7ygRk4AMfuEAeJOBgJA+gBB/Y7yOgwALXsS0Fzf2GB+JwAR7w+NEP + TYIFJFCCC5TAD3FIQwMIoAIwNyANHLiAH9D/cIEdGDbQ9+3BFszM2gEb4KfmM8cejn0BHkPb1HSVAF3f + SYYB3PrR992BG+LQAMVCAgE0iCyySlsOD9RABXfgwQ5ejO5+oxvOPWiDH6odiRF4tVFZaIFUzYEPDzCA + AHcggwTK7e+Kk5gMZNhCGmQs5EggIAX4a9QY3AaPGhRhDxwgQBt4YIEexNPbRTW1G7AMgDvc+Q8eoMQQ + WmC85xVgg/AwAopVcOc8ECAPPKh1CbbgBgBMmgdtUG0aqjBSpHKWEl+gARAXimACSdgDimXDH9jAZ8Xm + nJZdfkQZSJACAwfRCtHjXyYC1QRXHy8FQJf7JEhggNE+LwBx17skhoADeSikoOemOgEE8i74AY+gADAI + bIfBgPfGV+ILEGABthdKg/laXhIH2GKHZTWCNX8eEtQaPRJgkILAnx4SuTLVEh4AhxRAAQUJfj0iJjC4 + JQhgBeDVfSU4xgIDuF74lIBCWJHP/OY7//nQj770p0/96lv/+tjPvvaVEQgAIfkECQMAfwAsAAAAALYA + tgAAB/+Af4KDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2 + t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7vn0Xw + xEJC88H298FA+sD8/H8A9vslcFMQQUQG1nIiyEaOP2oW6FDjIEeOBUrs0PlzQ6EjgQUp2emwIEYfPlzk + bDDBhwoVPitFmMDAxUHJPzY8KgoZqaONDi/48DHhIoILHxEiIE3KtGmFCHxC6HGghqFOQjwf6dAxR8Gb + DUabih1LNgJYESFiLPij5OokJTn/KNB8Wrau3aYb3ryg8LBfVkZP7MQICrZs0QgVqEQwEWIlHxdiniqu + i/RNiDk57/1N5MTJgj5vDpOtIOYNHwVzpp5ZsOAJSTWo9YjgslIp2aJcFHR0i6iDAjFLmxbdEELBAgcU + BO1OlDNHh8EvNjwNzrS0muW8/0T5TV3pBhcoO3R8QomhDjt6+mwoLHaDgg7ZbziQM9aH9BcKdHSK8qfr + m+5JnebWFHqIIZpSPojRxxzYeZJTHyIcmFQFXDR4jw16VNCdCXLEcJApFCxAhYQuvNGXPgvQJ5YLIlBA + nio6cGHCWBWsNQ8Rc4Qm3GkfsqLEfGSBsxkicxDFlA8ucHFd/yywibaBHvAc4QB7E76gRo+wRCFiUlwo + EQSW6nRAF1PFgSlLDiZUCI8DYojFxwJT5ELEGfAEIYJYb8RgYXaqPKHDjEmFoB+frxxxgxN08BEBFTEI + YyY5QUTxxBltyZEcoYXeoOmhmMJCxKSb8tepK1FM8cQNT7w4KitHpDrFFEoc0Q0QQxYThBOoOjFFQrNC + o4QTUfza1qqsRKoEEUqI+g2tzRxxrLOyErtKEEcQQYSzj0pLirXWHpGttqJ8Se2x4KpyUBBKeFluKgch + y+u6qARBxLfsIDBCClZAgIu8X6Yz5AE/MMHED1bsK24/WPyg8A9g3NLvH/Sqg8MSC4eBgv8tEbszw8AK + Q5HLw/pYsfAPB+z7rj4FcLyEAQYPVAYECyNBA8bzKlTGASoHMAQtX56MTq11PKAwE1YgUAvIA9WRxcJF + w2vKCEsrLIDRR+sExQMcw4GH06UggMTCD3BdShlNgE21LEgPhAAYC89AwizqXkUCCwvDgcUsPiuEBQx1 + ayD2KBqUrfAJf49ixsgnXFw4KF+c0PfioCg99NSQf9LCyFbsXHknlyscRsGbczIEzAovUYDmoWcyRAAU + K7wC6qljIsDILaRSq1s4jAF27bFngoXjCs9wxb4KaTFyw5fA/tHtGaczxAqt/xDABJgMoXwi/OSzKusL + Q1BG9Zpfbwj/s6viobvnvCcviPUfaT9O841oETXDb1e//kdFyFMO/Iy0wPEPcNAE+x4BBCHcrh94KMDC + ljCzVBgwIAfsx8YWVgfxWcKChDAgrQ7IP3FoAXg/OIHHNrEzDA6igEWQwgO/0cFGGABz3yPhI4xAwxV2 + Q16cQIDIFNaEFHTChIUoghGKIAQjcBAaabvEF76mMCTU74dADIgRQGAEKehvES30RRYZYYD/wQEHrpAC + CGoAAhVuo19bRAQe6LYwA0RREm8URAprUEUpPCKJw+hR8w44AsEx4QEjbAUQaiAFKdSgBo5II8Y+MYEA + cIxoigujIQVBAEaATJGwwCMmfrewJqwg/xZCsCMHLDCANCQSYsSY17kiMaQyvHBhWdhaLPaAhgHYcgcy + aETegPEhTVICD0IbWgpiCAsV2PKYAEAkFgeBSVfgkBMGENwPHnA3WRThAsccQBIYYIRGHCyPnbgCGxXW + wFlkgAzZtIAKrpgINIYDemDTgi38kIRsAmANlmxmLw6IABASjZizqAEA6mnLJFzAA5aMRgQFkbKYyfMW + DeBBNnfQhmUFhBFfCKbCApCLIjDADdlMQgPYaQ2AkE8RjRzZA554Cw8QgKC25IEKtLHQPxxAoz9g2S72 + gM1slqAB2CjgIzQAh+MNjxd7IOUxk8CDDNS0GCdthAJH9klfNMALMP8dwD2p8Y9H1EGaPxiDLH3BAC9k + cwAlmCk0aOU+RhB1YX/sQjCK0AB0LpUHbLBjMwpIvtuhwJELHKYwikAAux4TDXFwRj2E2oghGCAMmDND + MT561m0mYBkbrAcIGvHVkc2gmsQowgdAmk0yACCXxuArs6KaiCuA8AdhqKoxQMAAiWZTAgDggF6FAYQh + FqGAbU0ECs63sHIiowoWyOoA3MCABDw1FvkrAhXr0Yi/Ru8HlFvGGvKg3CSUoArK5EX+7GEEIcjjgCho + 6MLA8AVn7CEPSi3tHS6riw/8QQo0BAEIbLiIMqRgZCGU6zMyMEoJnHUAFmBAFbpZiw94QQIeCOX/fjfo + iFeCTbbQaAA2u8sDDlRht60wZANKcMw8AKGQNf3vyJjgw2qkwbaVLUEb1LoKKVSBA1s4qwRkIMRH4CEF + OP1Bi63hAQDs4MADkEAPLmDf8JbiA3cogXJtiQZImCEFkB1ZAcZ6jQZsIQlTrmcJ/MCBDPyBwZ5IQAJq + SwYDI7kHNGYEHmgAYCQUQLLc8MOXp2xLC3ghDQ0AqiYyIAUV3AEAZkVyPRMMiSsQl4cFiCQ3CFuC+FZ2 + ADvwAg/8wIAGGCGXCFWEHffwhwSoQAV5uEAt3YzkHfSgkpBowQwA/IMCjCMBHEA0ks9KBqaWAABpyEMD + CFAFBXNABnFgQxoY/5BqAJChB7s+qxe2QABSPwIHEJg1gHVKjgSswQ9u2AGfFY3pAfTaDUkQN5i1Ge2l + DoAHafgAfR+RXlqf4ADUQ4cRGHCHHI+73QA/MBl4sAUOCMHJjhiBtuEKhxbE0Rs1SEAD8gAAaLM64O2u + pwS8YAFAxxkSGijACf6nMBaw1B0ywHUe4BvuJLObz/WM+ZG3UAJhN8COwW3EBEYwO1qfziMI/YAKCECA + PPy6B1sgwxZ2UGkA8AAAqf6AH9RMajRPQgOABTAMDsBlj9gDkXsIQgY8kIA9yMDsQrisma1eiSGQQOS0 + boIABNw7SKBgBWO47sIEW/dHICDbtA6YFU7e96xE4AELBmBBkH/QBBZA4KiFV0QZukCD144sDDTwW+QT + YQYtJB5rgT8BDdq7+UIMAQ8I6IIBxrD4hZ0gAHXAc+kHYYY6pEAAM2Bi4JsQALrP/g8rCAAMshz4Hyzh + ASwwAAkA+vvi01oAKyD97wuxQ1ojIQv5+sLD+27hgD1gBlYwABTAOH1F1KF0MKDBCrAg+/IrAgEG6EL7 + 3U//+tv//vjPv/73z//++///0hAIACH5BAkDAH8ALAAAAAC2ALYAAAf/gH+Cg4SFhoeIiYqLjI2Oj5CR + kpOUlZaXmJmam5ydnp+goaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2+v8DBwsPExcbHyMnKy8zN + zs/Q0dLT1NXW19jZ2tvc3d7f4OHi4+Tl5ufo6eqjQEDryEBF7u/EQoLz9ML4+fp/8/v8+gXkBdDfwGAF + D+ZK2CmIQkwAGT5yeONPjj8LzsyhMGcBRxsx7Pyx8XCSxEdO/lCwoUCBHBFvTFAR40JMBBMbKryhwqXP + iwU5KAhyWDLRSUZHMC7gEjPChgg+IkidSnWqi6hvQvCZkyOHkqKdYszhU4EK1Kpo06Y1IUfBArCX/1J2 + gOlCbdqodtFSqcBnAUmicB2pmcPlbN4NPsqKMWGCDxU+G/YatpsTaOBGUxSIqEDZh4gQCjBwvLHgSIcz + OTrY6DhHBBc+TuumrTmH5GVEMUIgThsZg+gcUxpFESSyA4Y+fPCidWEixpPbhfr4UC41qpg+es5UvGTD + zpw+G3ZXfXwR3VHcNvWawEBHR8M/HfTIpC71Tfbbsql6VqCGlBrNVFDnwwaiDVeUE0o4kN9Nc/R3Sg4K + QFbVBnzEUNQTT9AxhRxTYXBGcKpQ0IcY9FWwwHYBEaFEFDdUdMNiQr0SgwhoVYCBbfkEoUSGLVb0lixO + YGDCeBikOMUT2mlny/8TFOCknwI4pqPjEzdM4YQTNxBxCxELiLAgFXpEeY4SWFo5hRKA3aJGH1VVoIc6 + RyCoxBFROJFmLnI8NRUVDtwpjo5HHKGilr7kkOdUiXVgDhGCBnGEEl8Bo8YL1JngHjlBEKFpoMIQkQON + iMqB6R+OzllMDkNOtUE5mT56TAeyiQBiOEG0SoSfwSihwAYODPXnrbcqIyatmUJXS62+GjsLrsouCw2z + 2tRKaDjtOIPsOOcB41CwzcqSKbTdpuIQuOGiQm656HZzbrqkrMsuKMG6+64n085r773AZIvvvtR8EcAY + MJwgAL+kkPDDwT/AQPAoGiDMxAwLi4IAEwifEHH/KCggcTATD0xw8ScoPEDxDw+Y8bEnCGRRsQYnd6IB + GAhn8UXLnHwBA8IwkHBsYFjAgTALOtOsSRcw/8DEGCwLnckIJyAsAAKVDKH0ICNofLAAUlOS9SP6BjYC + wj+MYckQW9M8RAsIL2HFJVmXffEEECCMRAFs/0G2I/akO0EBCIcBQd12NyJE3ovIi84QYzjcAipdw9U0 + wkmfEk+6CDxO8hWa3M2IEPIwYrg5dVjOAuZ1u33IP418Xo4BTSBMAw6YmI6IEO00/lAAYP/N+OCEN4uC + FXIfsInshsQjReeFk3qQFjMgDEYXqRghPe2Fqy7OAWCPgUImxB8ixPRGHGU9/zhlpOBwAKoAAcL6x6c+ + 0BUsIPyA7qgIIQUINUhRg+f10oMF2CeIHCqKUAP2GSF5ASlD3A62BBawwgj5q0H+jDWB+G3MAK2I4B88 + oILUXUsdGlgC2GbGCin8oQp5SIIXGHGr8WUjBVZLGOxYIYQSDOCGA2gAAt9RhpshDAJlcMUOcDiAElym + BY/jGBRewQEiJuEDRYhWJ3CHsACYzBVFsAARS5AAKW4CCkX7ARJWEAs/JAGHSSDA/kqSgpH9AA4CbIUH + eHDGG3rhAyX5ggV/EIYUzIIBZEAjANYYjf4xQl8rANsMliiLPVygjgNIgh+k8UFOaMBnBwsD+mihgh4Q + kf8MXWTGuEJRhhWEoWKMnEUNmkjEC8hAlIOw3lEql7a13WILRJRAHpRRSRcqwgBge0Aqa8EGNziRAceQ + Fimu8ACwbRIXfggkDt2gggMSo1jJ4tojgCe3ONYiAwQg4gDQoMNkGvKQBllEC5qJsBR4bBdogGQSevDK + YmATEqhTBALgIMKDnYB0u1ABD8QJgCqgowCnRJjwfNEALziRBxmYxj/ccZ46iKyKUPOFET4gTRxuoYPR + wEe2bAZA6AUjmg+VAQic0Q7qOQIHVESYAYIYDBAwYIhE5AEHWFotR5TBAP00mvaIUQMCGPOTcVhGtbp2 + toseLAtBKwYDIHnDJLShnsX/qF3vGoGFMPJxocfggEOJuAM0gJQYRXBpOhdxhTG48QcFwEMyjNAANIhz + AD0gQCgRwrueMgIFMRVqRpWxhhJIQJw7+KgJe1GtvAkBBFtNBA3A9gMwRHUZVWgDVW/YgzysgRdFMELn + gGAPfRXgrSdYHDQIMFYnesEPe7UFEEQrvSJE8REpaJ386AeNNQAgkojlQVIXG4vQ0m5wtiUtbtl5sAdg + sBppaC0aB8ADBpyVFR/YAm3Zh7zlgq0JfrxGAgCQhM1GsgcXUAEIiDsKEBjBAwTQ4gDweL++PgIHBdBt + JgvwTmxwYAs4FWd5AUAA+oYiA2vgwAUOi0MjSkEKttPA/2Qpy19uSIEAPAiwgMmABgYwQAp7yMRK/9CA + NgBgoHdNggomBwksCICycKVpN6rAgN/e9ZNuuEAeVNAAIHSRkIiwZhdlwAA/5MENEmDwjQfQhkhMYASY + BFsBupcND2SXDOZ14gC84AUAAMAPafjABxpQhQ9k4AMqWIMfOEAAAFwgnlheMhHRsFNIoAACzJWpXMvR + gDvYNctLHqIWLbADCRhzB2cEtBMlQAYAXNcRCJhwMA+wZ3NIIQMcAIAN5czpTt91Bzz4ckQl0YXmURYG + XZCxOqqgggsAWMme9nQSDsuDNnBgDex9BB74BmMrDDMfMgAnAdCQ4SEmutN1JAOjdf9MADb8IdeQOAAY + Eiq/AngzIPtbQwLikOk2hNoLPPBCWSWABjRY4ALo5gADdFgDD1wCCgGwnPN4exv1geCVK2ZDAqRgUAn+ + IbKUIEEKfPjdMWhhapAogwZWkDgYgxfhjyjDFQ7QcMoyAWgQd4QZIGBqGJ/gAP3NeCK6EAD9go1jKdCA + qkVOCDx0IQVwOAG1g1kALWyP5YMYAgo0MAIDBAAMMaTsDALQgpvj/A9lQMAIUiAApzp86HXAedJJ0PMA + EBzGACzAZZWGgy4cAAIF+BcYTtCEoGL9YGOgNMvRdva2P8AKENCA0UUOhbaDLQwngEEAIDCCK4Sc5V+w + +xIeAAY3GqwACnM/uiAmFswZjIEGfL+i4hExgTEEoAAGOEAXSHAFFKx88qAPvehHT/rSm/70qE+96q0R + CAAh+QQJAwB/ACwAAAAAtgC2AAAH/4B/goOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6Sl + pqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3+Dh + 4uPk5ebfQufMQELp6sfsgkDvxvNA8/Tr+cL4hP37w/4BBIZP4ECCB4MZTMiw4Ssdf27EsGNngQ01av5A + dAjLBgU1C16IEBFigxgxEcRU2BBCjAgufRbMebKRYyknc/qIeEMlQgQXPoMKFQq0QgU5fTpQ+BPE5qcY + XKi4ADq0qtWqG0xwWZDRqaYFFa6KHYvVxAsddDgufEQkyh8FZP8j+KjgIyuVCm/mAqU6dsOLOUq8Qgpy + 5MkTOk56DqVi4o0IBXPmLHhCgcKRDhgdhOxTwYSPsRX4xBDcqK0Twzf+vAjq4vGCGDYEHVHUlIgNHQ4w + hAhr9TMXCqlJGwpCRMmUMzZu3DiiJkIIB2mnWEq9wMGbDVfFYKgp/M+RKE9uTHlyXLlGT4FzmrgqIkZw + 0kqcgJ/iZEqUG25H3dChgAr2odrF5hVhUShxxHdRTHFEU6fogMF6VcmhQ2AcEXEEERgeGAWGrHTwwn9C + 8bEAR0EQRwRhSlDoCh0O8FEVFSMyxKCFBp4oixp98CXXBg7IiKGBs9VCBwYoCSWGAkHuUyL/YRfmModn + Qm2wQH70lIghg7pQYIKOYvT4zpJMEeFLB3IMVUEOKnbnim0hfBaUCB3kg+UvavDhplx8vFeOicNoKZQP + CugpjpXEEBEDbz6JMcc4Vs5JjAN3RmCCoNw4eowSXOiIpJo3uhhUBUuFY6kxMejIhYDfjFrMEXLwVYGX + 2lyp6jEdQIinE9vMmowSCvDlQoycwmLHGyEGG0sQDhBlh7GwnIFoBHIwC0sfboYwmrSu2FDBdtjSUmK3 + Cq0FrinijmtuNvecq+66nOjK7rvwxivvvJcMQW8p9spb7iZD5HtvKP0K4i8m7rKbb8CM7PuvIQEPvLAG + CCCAQhm2FAzQ/wQ/ZPzDEqm4QxtpOGj8wwOZIJzIPB6Dq4HIM9T7h8OIpCvcviSIDIfLCxPShchjoCKE + EeV+a/E7Q7SgMRNWlJzwH+wETdoEEGgcBg2lNM30uCgUoHETBuCc8D0KE8eUTQgEwETGJ6xArhBFFJHy + Id869cUYGs9Qhyk/g2CEEAp7pcUMGrNAAt5GGOF230610ITGViBwShGGG74ImBxFrTHVp4AgxeZGLCJm + 3AwNQYPIXZ9iBAg1oP52IUOrg4AAGi/RAipF1CCFEZtLqwUMGoMBhc+212C7tCs8cPYPVmiQyvB/JLAG + s6NnzEQKKHScAAE8DFCCsXiwcPTdqcgwwP/4AySRQbB/S//A4KnssQP5A8QRbAqLZ9z4KhfAz0MNnHqv + 8QoTWEUDkkC+JHygc8L5gvEyFoYvsAIEaIAfABLQHfoFrnqs8IMEyEcGBginDDM43g8MQDFWyCB740tC + CfZAGiiIDAnKcwUBNjg+CfiBNGaTHgtgIYMSwM8L/HMKAuq3sQPAAgQcgN8AGAACm5TBACI8AQZfYYQe + wK8HKiAb4BhYgFkwgIApBABHynAAkZ3AgbKoAQDAWD4OrG4fCACD1JJGCxVYkXw8yGJCyGjGLtTCCAyA + XxK2EMSBfIF3DKSjLdDAxgEQAHHgwAMUNZaFEeCiAV6AXweb0Tp5OAL/Clv8QRgCkAshJFGTVXgjOXCg + tbppQRdAAAANx1eCBhQDdKFowQM0hoQu7qIKABAkDygoDFxOQmEaGIMIBceLIcjAAkoEgAx8QTlSDCEF + YdDYAyDwiw9AU4Lnu0VTxEaITlKiBScQWQAc9wsGzLJ8aCBmLYjjKHNOYm4iy4IfgVEDBrxPgrZ8hj08 + uQjRIYF0JQSGEdpABiX2YA1FqBiHTGGAXUrvfsPopxIHsIMPeMBbYjqmPAbKiBaE8gcz+J0x/NBQ+O0g + D6pUyCAQRwI4iJAJK0goMfqZSSWWIAEIDEg8IIGCMRxUYwXAQzKK0IBvws8NcSgkQSBJiABkU2MC/2Cn + MlRQgneWb4JS8AXYqDoIGhARpVhwhgzu0Mjx7cAPVeAFEIogM6oWwKIZQ4IloeEHN7RVewT4aC6aVpBH + pACvGTOiNBogy43uoAccqAFZRREPvv2BbRF1RBlScFSNQUCn0KgBAcjwVxXGIa6wKFw7mHYPyzZiAikQ + YcZSAFppqAAALVWiBLyQhwSEExVzbW3bQNA2qqIgeiIrwBSt4YEPbGGj5NsBAAiQABZS9gN5+IPeQPAz + tvEtpodAgBVEljEa4IAbGWBAD7xaQDdsgQAq2AP/JmsID+whARxo7AD2UITbgYC4kyWB/2JHg+Vqwwh7 + IEAJ/go/C7ghD3dgg/8em9iIIFaBA364Qwn+ST4C/GFzraVqGUaQzhcqVxwy+EBXGVzAJLihBGggwB0Y + 0AAGOK8Be2DDB9iwBgKkIQ0XcAMZyMDe8fUACFKgqyTMsALyjswAASwHdu8IXUHWcABk2EESvNBQC7wv + CUWucgYyGwkS0EC2TDjBAWorjhp4gAEAsACLq0znOtdwCxyYBB5aMOCMLQEMe83HHt7cBgtAc852hu4O + duAFADAgqJH4QgE6m9cxXIEh/PvABwAQZwl8OdHko6EXtpAHAnxAqpGYwAHoRt4H0CDKTllDAvwQhwts + Icg84MFu1+uFEniBB3mAsI33kAFUS6ILZnXyDNT/xqkmFvsPbPCAB+ILgiqwEHWb0EAKECmyBwhApTlb + sgH6XDcoh1vcLDhrxppghX2e+xEIKAAM1J0xFkDAwO9WhBascAJ6/yALBWBfvhNRBjxowAAweMASnDwy + GgR64IZAAQK+sAIWLIEJsuUlDerA5nwbHAt1MIBNGb61AozgvBD/QxmuAIUWrCAFAkAsyWdgACigfF4T + wAMeyoADBJAACnU4gAFSQIMACGDeJHfyGOqgAaX+C3BNaMIJTpCFGWThBDJPOhOQgAQwGEADOOh4vLKQ + 9LL7+QEnYEEKSDAEsc+rxGYn7wnAwIIArODSKf9D1hl+AjgIIAApWEFa806INyY8oAlIeMAM4MACAdCg + AAZYwQFGAAWtEv4QE0CBGSJ2hStIDGaXD73oR0/60pv+9KhPverPEQgAIfkECQMAfwAsAAAAALYAtgAA + B/+Af4KDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5 + uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OWTQkVA5spC6n/u68bq8PHM + 9PXI9/i+8O76+72A/AMYkKDBgwgTKlzIkNQNOxQ6UNAh6MiNhpEGXjoShEsIE1Q2bKhgoqSYCnxeKJiz + wAbGU0GIEHky5QyRCDhz6twZocIbPhjU0Hny0lOQo0ScTJny5MwfMTyj7nThowKGBRSLZiISxcmNJ09s + 0LlxkY/UszyBqtE6KSYRJU7/ut6Y4uQJ2YtccvrYIMaEGCo5XaDFKUYEhSNsHwU5coQI4yNd6ZIl2sFB + BzU2dOSgECNGRAd9+ISAenavCDUXEycKIkjmYsZKujKWFCSGAz0hIviQ6qNPB9WIjr6GrYQ1JiWZ9Zio + IFWMnijABwl/e0QJR+OeFnBhHpXP78TC3cokYiqGHu47KyhADPzoKjV9NuzWuYGLS9XYVd2gIGLDTh8h + rPWScLI4YAJPFcSwUHhuzcIfT1QsgJBx7t0yhR7z5bTBHNHBsoB/OkXY4SsUiJFhT9/Fw5F0vuTwxokm + pGgOa/n5QkEIJ4qQw4iudPCGTj7IMQWPrXSAXgQb6EFk/ysLCKahgEuqosdObxAVpSoiZOiDAtBdiYod + R1ZAgZepKAAiThikRmYpN8ihUwUSrmnKAqThJIecpkShwJsy4hkKmHqJwE2NzSiBYWD3+SmKE2dGoMCQ + iorChZMRvGFHpKLEgJ4LcWL6yQ0i6ISBp6HsmVMIiZLKSQdnwmnLEJ8QKo0NZuHkgpK1wGoUNkpgEOir + umLUZE4VOEXLEME2ZMOmYy6iUSjIciKrNEf8mBOHiTz7SbTRbjKtNG7mhGuuRfmaExeqftIBBpZl5ay2 + rcBL4zffrqJrt5e4V6Gq3D4Cb7qUzPMvwIQkq4gQQjBCxLwEG0ywJg47m/DDnQBRRP8Rqg1sSjvvLBLT + vhQrIpBAHgtSb8iDAIGwxigvUoQRUnDcsiVAGGFEETLPHPDLOE+sMyVGgBA0xj9PAgQIINQgBQhX0hCA + AS18cYoRNSBdw5Un/KD1D1KXIoXSSRPNIw5LbB3GBKbAXEMNPvOIxdY/wHDKxDU0QMCSB8BtBSp58JDE + AANkQGQBWzORAip/Az4AAzyiIMDWS7SAygWKDwAAjyTMoDUTD2CBCgeVu+HBiC00sTULOKCSwQ6KJ/GB + 2IlNUAATWodBgyolJD5AHoIDp8EYWz9wgCoESKC4FypEN0LWWsPheSpreKG4BG1EZwDtWgeQeio15FF5 + D1cnVgb/8FuvwEoDrAOeBAeqYcH8D0uQwIoUJVS+RfhFDXH91nDg0QoDutvBB9iCABZgDwkGcMUeLFC5 + EuAPIyOA2wy08Io0GE997HuJ7PTmP1fIoH6KK8EeXoIFOMDNfLBgQOUk4IeXFMB0WgOD/GBRA+kpjgy9 + WwgK3veDFKBAFgxIH+DyMEKFlCFvkLvCLKQAgMqRoYUKuYIJtYaEvdGiAWRwYgIUsgLs/WAGkqMFCAhQ + OcsV0SBfeNzWaPDDWtTAb5VLA0JSAMMfIKEOuPiADQFHBsYRRAOaWyMCcCEFADpRBizbRhloALcHkCBi + s2hi5XhQBXyUoQth2BoSbreLPYBQ/31bqGQ8SEC+5mmgFw3oQeWSIEJsDAwPKWhkAnshBBXoDnD3M8cB + Apk9JfoiCEEsIwBkQA4pwu0EFAxGGrLYui2wARb7AhnIjOaIAMDtBxBAmzAIcMskWKABq1gYdih0MknA + 64hwYwIL2igMKcShjAMgAwdgR4qPlTNgkegCD0/wvGIQgJk3bMPoXnHPRrAMC6X8wQlmaQwp+IGBKwwl + TAhkMk34oxEIsELZqFgAdh6jATyAZx9NQVFMXBQSOLACEgpnha4pYw2fbB0AqvDAXfSjY43AAw3q+MVT + NkMGABCi4ixAAFHaNGePKIMB0vmAEUDDnXusHBpamMhTjGwSeP/YX/BQGA0VSLKMEuBBA7Y4i5ElrKpZ + XWnwDkeNDPgBoML0w0BfYTGSUSIFD/DiDwqwPWpIgQ1BhecAksCDNsigpqYQWDtO+ggaPOCaKRgkNorA + gJiuMgl5SMPaTPGyiakDHfRkhBmswFMkFECy2kgAAyxwyxXuAABxAKcROCGFP6DjHTe7mcragVRGfMGA + cGsCG72BszSgYbCCBZwFenABDnBghGdkhBQ8sLYEcOACXriczYxQM3TcLLSNaAEYrvmAAoyjChzgAVyT + uwMvWOACbWgDB9bwgQbsIQEqUEECEvCBOBCgDXkogRucWISqBU0KJEOrAXioUIaKA2MfyMP/epOrPuNJ + wAI7SAIZvJA+CVxQsDKQghTSkQ5KaGCn15wBV9eB3i2oksIwjnHlGIfgSuChBSzIJNxgEEaArOG6Fhiw + jIdcxjzgdBIaKMADNlq7MUABkvG42gcYkIflsq61MU6ChyXghQswgKyVOAAMrrkE4aJ2IVfLQH0JAIAL + bGHD6k2CG3qAYQts4QJ5aIMfGpBDS0AhAHrVGgwgMKIEtIMNa6iBB9awhtEJYQ+IpcQEEFCAMV/zBwHo + QtEWoQEIzICnWlvomTddCBKsYMyBrqIWtEnqQlyhAAmV4Ar62mpBaODPWWCyBGkw6lbXwQAG1DXkCuDU + WuMBAV9IwRh453nNMDwgAFDw6Mx0pYUDGAAMZb701mAQACxI20tQJkQZBnFrLKwgAGOwtLb5lwIoyImU + NIBaF7QABSjQ+ws4wIMGtFCHEXThACkIQAAEwDwdr7sJDxBAC/q5phZckwkngAEMZnACZ88ABlnYGqjX + HWoBFEAD3yZTCgLN8ZKTuQlVXEEdwu0la5r85XADgxUC0AIc9DpSeYUczL2YhYlbYQUtWHXINDCCFTht + DGNgAQuS/ukHgGEMAkB6AFKwAqCfsgysLhoervCFL2gAB2VANgkkO4SQ1/rsaE+72tfO9ra7/e1wL0Yg + AAAh+QQJAwB/ACwAAAAAtgC2AAAH/4B/goOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6Sl + pqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3+Dh + 4uOpQH9AQkXkyuZA5ufv6/LztfH0vPb2g/r3v+6C/Pr1CiiwoMGDCBMqXGjoH8OHEGcFiUhr4p8gRJQQ + CXIkypEnTm7cCMFFwRw1ZyiiCoLxSEcnTp7cCHljisgcEXJG8FFBhJ4YdFSGYimIyBGjR5TItGnjxpMn + C3RKdVEhRJ8FdpwI3cRyI5GvHI9GcTIlpsg/DqSqzenjjYKgW/8psezK0qUSJS6jRFECM4rMG39erB0c + wYWIGHEtYWx5FOPGi3Mt6piDQcQbKi4I7+y5QGviRBYvDgpNSccCDHw2aKbSR02Uz4UmOqa7yYmNDgpE + VMi8looCJbARzQX1JAYX1YPfqInL0dUUPRUGb9DDnKjoVErs6BGzdoMcO1tJszoSQw5yqXw6BHeloIIP + tWI6iF9/yoaI3gvot9LTfY7+VVEsEJ1UG+T3nyodmKDWBuodmEoHb6hVQQ4OpkJBhFK9YUOFqNgxoE5c + ACfPfMB0cF5ODnCIyhwLLqeiKfxJFcJrL5LixH1SUVcjKTp8GEEFFOxIyhy85dTHE0KKEgT/jmy5yI11 + zahxoghJjoIBgUHqMgRDOlAhlRxabvkJicsoocd7OVXgpC1DiOkJmctQ8KELGOTippsICaaThriI2aYm + cDoTg5c5uWBgn3heAiU1CuqEAY3XBLqMAmj+CFeVn+igFoW1+MkVEddRYwOGhSnApiCJKhoqNTHuROUx + BH3jQKVveIapJx1wl+ahtKRaCVjZKEFqBCnO4usiQiwim6TOiFCpqcOYI0SssWXTR5EvABYttd4EMatO + fIh4aycdSCVGMUAUYQQ9HVRaASMOzZIsOsnOE8N5JmyICLetTHvOPbnqZEKWwLgTrzwUNBpBfIscHEu6 + RhhRrzweogmk/zDqgiAxPTYQGgEV4AUjRMRCTLyODZVuoC0wIxuhLj046UTFMCBIIQUIINATg7nDFCFF + DTXzu40OL4hgAhVv0Ay0ETWoIxCztxjxcw1A97MoMBHDJjQqRajAQB5bbDHuJzIMYPYASYz9iQRnDyCD + 2p300DYHcHMCQNt3OF03Jn4kcXYJHuydSQM7nG2BCoJjkoDcZkvgB0RbrwLCBW0DYHLik3Dgt9lkJLAe + FC2YwUoCFsy9XgE//ABHAVeocvfZF+QM2wxMpP7DCqow0LYXa8Cmge0/NCF6KlW4cbYEbcC2Qu2ps7BK + DZQbfrlKVgBvACsqbG52A1Af9MUDzP8ARf8rjJsNQAZbobAC8DBM0EoabDdOt1AaBGA7EgW4UgUalctO + UQszsF0W6uAKIfihbTuYX0TKQAPgWQEBryDd7lSChRPY7gG4ewUQCNC2ATBAbwxJQfhYoIFY1KB0Z3PD + 2x6CgwDazgBlkIUfyNC2PARuIWVY3v1KKAspvM5sO4gDQzQwBtuFIQDHYkUDaHg2L6wwIQZ4gO1m0IJa + SCEObUtCCaSQkAlkAXg0gGAthMCDDhIAIeoDXhOgkERXrKFwZ0vCBw7SBRbYjglW0AX8dteAgpQhAGEQ + IAFz4YHo/a139xiCFsLHhAKgYBdVKEEWAXePLwgAeCcQ4y5UwESzaTH/ctlA3QWv14uuaQ9tlFxHF8Bn + uwB84RdDYAAczwaAJ4YDAXAA3gOwEENgpGGWZtsCG8RhhgKE7wH5G8YvO4iGPr7JOt3rBCgNYMFW8hBj + BIhfExnwzK8IApq2wEITjjm+YtTggB0kQx5AWYnFEOJqqYCCHS8IAWQUQXMdTMIWbKmoaH5iawiw3/1o + 8EhkDEEFxksnA2qQCdp805+msAIS7mgFLDBDBmg4pdkugMhgsBMBKQjkFDXQxmHs4QLabGIaHHaLd7AT + BwZoAvCoCA0QECChbZMADz6wB1wEJHIpYGXqmlBPaTRgCx305BY+wNB6AKQdjxiCAYD3gzBAAAfU/0iA + H1Jaucc9zB0TAyUCoqhLGuDBGiBIwBaAeTwvpCEBPVUFWP9FiSsUQIq2awINeomNOEgyqWhLwgUYMExT + pMtglgioTIGXAk1mQwZ+8AJgz8YDAPhhDx5oKif+AVaHsPMPQyBB9YDHBIJ+Q6tu4GpOJdCDNjCAp+fQ + LCT+IQQQFCFZ9botVCGBhxYUEZM0wCo4fEaAEmgUsG7wghcAkAYGOFcFGdhDFVTQABWsgboMaAMAeoA4 + jYFVXdP6BwimxwgUQKCatjuBAQo6DhAw4A6FO+5kk7ADMrBtB26wgAV2oFEhGsG2GmvZbSuhARowIXw/ + eMABzjqPGiSAAyXwgv98J0vhtl3gDzdTVxFcSgkUHGAMCEbCDAZZkAQQ4A5yS8KEK9zBEmAYBJ21BAkK + gN7UIcEKWliIDKrAAACgoQebW/F8/wDjS2xpBfOkKutKWpA1fOADBPDxFtDgBf6SwQs96IEFsFyCC6Th + A57DBAqgEIATIHgJGPyM3hJQBc95QAZsYIMMZKsJLKTgBBPVpRXKiTlGlAGkLDgwVcFggOH1eRFYOC9e + gbcEK3Th0IswgwYKkGSqwgECrYP0IcqQwwI0YbGkPUEBvuA+TRcCAV0wABxATdUT0CDHpiaEBr5QgAAg + YQlUTe+r2SuUEbQg00yOqiA0cAUIUDoMec71D1z7PYLgjBYGBVhBF0jwBccuQkyc/oMGsACFFFAaCYvO + 9RKYsLor8DoxQrUxDARghQBEuwtdGEEXEGAGbiPgCvImwQEMsAIajMEKTQC3sqkKgzG0wKL0IcHAbVw7 + JjwADBacAQuysIQZgCF11UTwwtE8BgPkmK+nW7jIRy7yB4SBBgXQgLX1gwUawKF2yCa5zKn6gCYEgAZ1 + UHmSENCCFARgDHCYQbI1vvDFzuAEqyvACL6QabUhAArxPkAKrCAAdsPg4SyYwQPgMAYwjIEG7j7AAUYw + AQQw+NBimoDOcYAFLOABAViAIAKEC/JY2/3ueM+73vfO9777/e/dCAQAIfkECQMAfwAsAAAAALYAtgAA + B/+Af4KDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5 + uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4b5Af0BCReLM5EDk5e3pxe/wyPKJ + 9fPC7ILv9/i98v38CRxIsKBBY/oOKlzIsKHDhxAj4gvyJ0iQI0QyZpQYy6JHixUxKnFC0gmRI0qCEOE4 + iiJFQyovalSJcsqNJ1OeKMEZhA5LTUdgEnE5KCZKJUcwYoyS84mNG1PO/NFTAYOOn5aGClWp1aVMpEei + RBnpxOaZG2eImIgQwYeIBVj/K718SYjuIY9ExEZBe4NIB7aAXfCZYyMuJbuSVEZ5cuOPCMCAfVTgosbw + q8eQIVdQEMVyKzt9KmQGbGLBFM+spih442O0GAWoWRGxo8eEi9EiKsdWNaWDnNE+QuTgiBhWDNaZN8xR + sntVDi6jqcBtrsqJAtGQfTigvioGdsBU5nBXRSFEZhcxDBbfZWet5g7jU53hk/lN4/incrgHLILYkJbG + 2PFdW3oI8x+AxiywAWQb6PbLEAcSpEd9TjwI4ScgLfMbZAX6EmGEnKxHjA4DUmGHh/9diOEyDtzGXzAg + ZiIiMpgBRoE3HjmTw4L8zYjfJxMGdqMuKcZYEB08tiUC/3O5GIlJTNNgkN1V2MwlzQ1J+tBhk6D4mMwL + mp12i5ML5dAaYOmNGUlA3bwRWX8/nuIAZGIUFmcpFCTpAnzxlCPEPE6YBxhsxgjxJz59nBkBH3eaEoNm + TyB06Dw6UAHYBnwGo48QRrDZTRRiQCZePn8mhE+NPmBADDumziMlYFwQY6gQnnrjgKJ8MAkMpyCAMOk8 + Cyhqgq6/cGpEEb/Co4albJngUzCcIptsOnYweGIwUkhhxLYCqREqWxXcB4wRUtQgBQgCRZFkBUMCU0MN + RoBQg0A7nrkBlcBkm+28/ngLWLjCmPuuFALd4GIEFThoyDq1rlJDBgmwQTA+MRxMhf+YwHgxwMYDVOGP + goC9MUwPHA/wwccHi2CnPQ2nUkLJDPijAGRLCgNAyQT4U2MEfQzTRskXGDGPDci1NV0wcSTB8RZ7zNPB + fg0O88EOHPPgcTpBgMzWG8MJs4bGG5NxcjpKzMyWW1IJk8AWHEuQMzw1uqDqMB7kwXESAMBjw8EuHK0p + ByVbAI8CilbQGSMtqyJDyTtkkM5+EcRaTA1u3B2zODZg8G2mwxhxQcl5Oy0HMhwovfEOHsDj5S8eUM1x + A4k3asnLHF/QtOyi+OH6AGRc3c3qw8gA9sZxxI77JDdzXEICx4fCwe4SXN68J3uwzTEAqU/viR+mD7AD + B3FBgIP/LFWgATo6LJHwww8BdBFLHIyDzxINTKzPPiwyWFAyDyzh8ID9S4AALEDAgJIlwQ8cWYH9fnCC + 8cGiBvrjGBmy9xAcsGCBBZAFED5QsgGEziFlOMAS7NcELNCCdhtLQgMeogEB2I8JVigDLaqwO97dbiFl + WMH/1veAOtiiDd3zIAUPQoIxANAKeLBFDXhgwDhM7CAp2OEPZnAAXKiADAb8gPG6oYETAJAGCMgFASRQ + MjeoYFrzKEMBFjgD9+WiBsnjGBrYQJAhdKEJC0zBBHaRAPOVbAvMEwgJrFA/HjpwFyoY3sYA4Dh/FECK + DzDAOJ7XQUA+qRlQCEMhf2CFK/wC/wRJq6QMLMEV4PXiClZYYBZGgC0/dHAAJaAjKVdSEWPgoABheCEE + ZBiMGnCvgzxYYWIQk6FhQECKS2DBIXv5yzJKDxIZKY5KggEFL9qPBS0oVBzIyLg2yEgQxeQFFoy4wAMs + kxgMqOEA8BbIw4jIlKvAgwtfGIBlNCCCgXtmPiJxhQJscgljIAEzqoBCju2AadUYQgHwaL8ZmLAZHrhA + ENe5gzjUYIvAKIMBkLDAE1QRGn6oXAeT0IMG3PAfjkDBMReIhBWgQBoNsN4rt9CARtoCo38YggGsub4m + ZJAaCSCAOq/HgXZqcBI4UOACm5CCMFYjCCqI4ytLQAAVtKIdAP+BBApoIMUfNCEAL8VGBjigyA56AQBx + GCIp2DGpdUSCBDRgqP1S4EltFGEPfiDDRA3qhS0woGmG6gSrWFWOSgwBCgEYof1OQIOwckMIHiAAGbj5 + ygFIYAdeyMMHZCCDBDyxEucgLE4HgQIowGGBXqWrOEBAAB4MtbJu2EIeCEAABnCgAWxIwB7KtQeICeJQ + RZDWH2hFq9ESQqczWCATkGCAPc6DAQAoa2VLJgEyuOG6O5CA6STwh3ihI1roaAey9jGJMpghAJpkoyQH + sgYCAECk040v4/6gLRAUwQjnsK+h2PFZSRyAnAuEQRccO5AaqIADF8CnfCubhHJJ4b5SMAf/EIJ7iTKg + YKGKtZ8VukAmgXggATJgQIJ3QOK9VrYGIJDCn2ilCRT8F7VMeEABBAqRQ0lBBX7IwwUAsIUS8MACZNhB + EpKQXTLsAX2bQIEGAtDV9cHBAASOyx5kUIUqdHa3odCCAZKL2iZsWHuXuEIKLojaH8CgAGYAMyVwoAED + gKHJMQ6AD9UcCRmOwAAwKPP6WGAApx6krrP4QgsCAAY9/yALBoBCQwKQhRR84Q+8XAUCsEADATAhw/ZD + wgNooIEoG8QMuVyfACAABQ2cUxRX0EIBAuBVQ88gACOINEOUusAHWKEAEBjBHjssif+YAQ8jaIEVUtlk + NtIgmxHhaZlP/3CCGdDgACPoQhjxIOtFyLAMOEBBF6BQgAKAIc8cNfQDYJACLPgZImPYpJ4LeQIYZGEM + KTBACkaghRZoQANdMAMJtICDOmChCys4AA3GPIYHhNvQPHxAAFbwaKwgwABwaMIDMI3wJtSP2WaeQRNY + 8IAHFDoL6+OousXNhAAkOomogYIBrAADZSP85TBf9qbL7WnUoEALB1j5/4od85jXDw5wSMEBSJDmO6EA + D3hoQQpoYIXkPkCuPeehmb0cAAi04Avnnh4OrjABKKwAAhAYdgBgAAMBnAAMY9g4C2AQAHgXYAV1GAEe + Ho1yOhuCl2YI4xc00HUE4MCECEjzqe1O+BHCG/7wiE+84hfP+MY7fhWBAAAh+QQJAwB/ACwAAAAAtgC2 + AAAH/4B/goOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3 + uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3+DhwUB/QELlQufix+SE7eXrwu/x + z+/z7vTKQPb5/f6d+/4JHEiwoMGDCBMqXMiwocNvRAgFMTTxYawjEv9EHBSkY0WLrT4KIhLxYxAiHf+c + PCISpCmTHgehTEnkCBElJF2+LHRyosebNlc6iRJFpc5UIjsqUXLEZlMnN5wcUXL0UctMHZtOJRLlyY0p + T45MuVr11EklUZQ4cfLExhOwZf9f1XQyZcqZG0/o/OnTIW4rtFNuCP6zYEMEPVXJmlUi+ImOChEi88nh + t1VRPj4iR66w4NkQs7Yga47gg4qDJ8w+jzJ5q8/ozQ4wJhuiOlTKXXNEazatjDYpxbUohHgdwQEy37Yz + 6iKSQ4SL0S4cUDX2GXmnk8HUiHgtpu/x1cDs8HldgXK+pMLGjw6hV1j1Tz2N2TEBHcOw6rU3+TwWw/Do + zvQA98scz2lmQlGVtfLCa30IeEt+/tDxBnRq+ALhQBQUKBmCCapChGua+RBDh6zcoFsEb0xB4ioKjOYD + gMvcw00QJ/Ih24qoKJBZZC5QgGMqTvgX2Qv6BCQOBqNtcMP/j6josGNkMBojIzgTaiYCO+UUMWU3LUbm + wwbTDWMOOltyo4OQEYxYzD5leqNeZPataSQ9XUb2RpjBFFEECFrmQwF0Sw5ThBFGFKFOPEdoGEGFwxCa + Tpvd0KfZHIJKoacRh8bDxWhxBiOEETVIAQKk3NQZgQgbAQNCDSBIIQWp2ywwmgl4+uIqCKDCqk0Oo1Ex + TKg1BKtrNnb0yiGTpORAhWblCdMDDzyUsIU/Nui2gY/BDKCttlL4s6xmOgRjRBLbJlFDP2cI6YINwdQg + Qbnn5pODblQw+osH72orQQL92PFtBBvY68sebmwrQRX9OKmZC7XysocXBqvQzwJPmoAa/zB7lGAwAxNr + +Eagv+wBgMEE9KOjZnwIU0Me5ebRz6aadXrIsKgA4ce2A0xLzxlVRuCCAhcOQs6csnyAMw/5RCHGaGoG + 0wC52nqxBz0dPCkGMWwUrC0ZDcQTBAZPitCeIjSbkoDG2iZRcjwiPKmHE42yvO0F8eQgJBXYDnPztiV4 + sI4CGlYgcDAf7LCtBRKH40TbXooANzEyoFGuH+LMq9kGTTd6Ac4XFBEO2JqJMbgwfkA9QA8If0PBiS80 + HMwaEKfNsTdRKKCud8ZIMfLc8XKTwxs7+iCHMgSY7sYa3jgQeJTGyGABzpRzY4duPogQrjK7a4sGv9uA + GBlvy3CQ7/8ASXCwjfKjic2MFDzgDIDf2Sy4G+7LFF9u19ogCaeDw+zx/Lbv20YHxPAGR5QtFm0w3QA+ + cMBjVCRzzfAfztAwtWzwDxn221YcqnFBZtQgdluTAbJMwQEFXqBbIyQF2rZlPoVMYBdVMNy2yCDChBwg + BS/MRRpwNgAA9K4gOJjBDx5ggFwAQXI4W5tBDMCEHzjxAblggwzT9oFJdJAZVziBE3/AhDHoonQ420Hq + IJETbBSgiU5sAgl2kb2oZUASKbliMcqghQds8Qc04EUN2ne0CjICJdnQQADueAIN9EIGWuMb/BiBHY5I + AwUQsOMWi+iLBpCBhyX4YSTkCIwDwGH/i0gYAw6AwYApaiuTcFRJqpbxhTGEYYtZaAHpxqctHmhyEbe5 + jTLKEIBXPjEFKBgGAWg5AC/U8BstQMIWmRCANRJjmDwkQxUtwUlbdAEMd5wBFIL2Cz8QUwJpuEQ1ZwEF + AdzxBwfgJimJmYQtLPIaKBBAE7bYhAAsw5I8TIIbWmgNMxTgnAL4AjOqwEecJQEAfpQGDgwgSSeyYATO + 8AAAFEg+NygRGhMogBZBWYdgPiMOxByABHjAT10cEAcrmOcWiTgNNhQ0jFsoqTIMIEQnMuEBKRjlNKSQ + wWhugQEoPAYKmHhOA1zBGkaowhZ4uK0dlCANyKMFzRCQgobe1J7Z/6gBB0CYTy9cIA5sqJnQKoEDGqh0 + iwUQqDaEkAAGJJKpSeDBBRjQgAR47hP3aKAgtDDIc9IAD94wggzi0AOm+rQNHFCBDBLgAUvptRzmaMec + ylaGOsDBl08sAALCIQQZMGCphs2nBUpwAQLQdbE1yBQiDBVZNkkWspJAAATAsIQtLqEJBthsPBLwgTxw + NbTA5Rif/iAEXJ1jH1oi2iUm8AWNnnMGlOyHEdYQBwB4gaLA3RbHjAACIZhjUPAg7msx0QIrnPMHMBhB + GQgyXT9cAA1uwK5hOSYF7lqquJjyLhBGFd5KfAECmE1jANSbkAx8gAAA4IEFyLCDJDiYh1V0bP939yGE + PvW3Eii4Zm0JSQO1OiQBDWDAHS5QAi+QgQwO7lqfvPsJEpj1nEw4AQR0mkJNlIEEEDjrMgUAhXVcwQCA + BQYKNHAAbJ4XCRDQrTho8AMZo0CdtICCAcx5XjzWgR4kaCh0SaBkWnxmBCkYgzLPywIITGC96xiCeZ9b + gBY4MxZ4+MIIAtCEhi4zDAbQQA7jUYYqOzELY6BBF/6AZlWgAA91KIA8q7wEJhQAov/4ApP9PE8WrGAE + bx4FYK/QAgOM4QR2BuUMrKAFQhPExSfQ8TnBwAIrtAALmd7EZluwggKAYQZorDIMBhzkg2AhzFnw8xZh + wAIBHKAFED2qqQv/nYjPoAAFV+hCFwpQABg8wI65viMSmFDmEXh0ISSoNQyEnc0mwIEGAoAABFYAhQNc + oQ4I0MIXsAAFKHShBQcwgAGsEIATwIEJqj4yDKywggl82yEIIDILHrBRcv+g0XYEdRNgsAQW/IAFSxj3 + DJZgR2Vmu8rXtoIBRrDnqnTBADT4ZMAdznJhI6EJM6BBAbCAg4P7BQE4aAENAvDJULe85TN4QABSsAIN + KHuEGjBDHVIQ5hn0/I4bZjnMZxCAMRzgACQoQzCh/KNR1vvkKwiA2Ad+AgGcYAyAhsMYBLBzCKQACi0w + g4drDAnAbhYBV0AACVAAhTJg4Q9r3OzW6U74EcIb/vCIT7ziF8/4xjue8IEAACH5BAkDAH8ALAAAAAC2 + ALYAAAf/gH+Cg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp+goaKjpKWmp6ipqqusra6vsLGys7S1 + tre4ubq7vL2+v8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHCQITkQuR/6OLMQOhA5+vB + 6u3x0e7l9bfqlPv5/v8AAwocSLCgwYMIEypcyDBYkIa/jkD09XCiq4qLMArSaJEUx4wbNX7kNgTWyEgY + g6Q8ma3kK5aUVK58CDPaEJemVA6qaUmmICI6/wQhgu0mzlJBPW4ECnToEZ7LjkpTeeQIkatHlEBFVtLo + qKE7VxHJ+vRIlCgSq90MlTLsqiBV/+NGmZKWYVKhJokoUUIkyo0nV591/eoTb6y+SqI8mcL4LldBa7/e + guvEyZQbN5Q4EYw0V+XLZxhP6UgriOYzZ56c+TP6mEup3YL4xfzHjgkMrYnBBif7xp8OFSJEUECaVhQK + G4RHqLCg+Kw+yoVXiOE8Vg4RLpT7EGGjOqwnfKJv0OPbuyvg0cUs2Eqsn7U5VKJzMf/Kxgsfyjc42E3f + VAcx6anRzD3cKKFAcsJtQFwzQsDTzRkhaGfCZv2xsgCCwulBoTL0fBOEHPgJZ0IOyQiRjhBGhDNHdglS + hww8HX4DYXR8lGdMOzGC40CIEbjgYjFAFFGEg+HYYIJ2CxZThP8RIIBg4joY8MhHFMYsOaR73swRHRXd + ESMECEY0iGU3dASnnANKSiEFk2N2A51yIrBXCwhS1CAFCPk4gKEJXQpTQw1GqJlPB/FJR6IwQthppxT5 + 2GBmjz8OY4Sd/kSonB7D+JGHHx/IgGc+bwonwjAlDGDqAAz4s0B0b9T1Cw+nDvCBPx2wGIEYff7iRqxs + +IOcchXoEAwIZMSagK+FLicsMBkUa6oEx+ZjB4Yb5NpLFc4OQIYM/tywQYg+LPvLGhacakGv+TyBYQTi + +rKGF+aq4M8RtrIbTBU9nOqGvP7U224vHpRr6g781qOErT5Y20u2A3Cbzxk8brBaMLueWoX/Pzls+UQw + NcBqahKz5rOqcibIGcseAJyaBAH+KMDjqMEYcYfKefjDRXR9DENArAD4c6RwPqApjB9JnLrFHvWoqx0F + wzSQrRcXx9OBeDYCs0fFAySxRj0YRBdCMfCeysGT4RDxc4bEFHFBrHm0qY0OCHegCDk5yiIEB7F6EY/L + ylGRmzBrFG3qtuucHcF8xSTgcdYsh5NxdHIvUjcteagMANnevBBdBcgQfaoXDntjQ72YHpOAwFlzAI4e + 4ilMKs8pdqPDoxHIoQwDgg8ArTehRrCBgMnUIEGsjW+jQ7K1L+PB2uYyqs0UIogHvDINxJqE6tkE4UB0 + PmDQzB6lnopG/+zX2ABgfv8mQ0DuO6SKTXjRCd2MB2GbCkAN1jjRewQwP5NG7rKqxhT0tKXIPeNqseoB + /h5BlGAcIQbnO9M0/BCrAcThEUMxGSwoYLgIeG8aNaiftpDmCLD8Qg0RjMB2qhYNDgzvVBdghAk12Ao1 + IM8Hb2BaNaSwBethTxGO4UUHxRAparBhB7FyQ+gSQUNXLOBsVChiNXYWqy14ABJNTMWFIkAFA2YjfKe6 + QxEakcVUBGEKCqjA9LRRBSSqjANuC8lPymgK12GDARXcwdZkKMdc0FEZIGCeua5YIVUkAA0V5EEhV0Gu + Cm6BfCVUCwTMQIwPMCwJACBhCf/ICxI84P8BLSAGA9z4sS1ESxwIYMEPfsCEAJQhUwAcQAmW+I0CMGGV + q4QAMdaXyDVgbhtlaAEuVwkDDRSDl7EiQwO+gQUYDPMBWDhGHGI5gDR0AwtWGCYSDMCfX4DAhRVMQgky + oA0N0KAJw7RCN4PBARFmzQvuswYCaPAAXC6BBcZchgoWd6od5IENcUzGEArwgFv+IAwwqIMzMgAAasKT + kNEwQD1xCYYVvPIZBHhhIgvWDASsYAnDzAIEUCCNKvAzViUI2TJQAIEZDPMHEEAANTxAAFKqbAdbYMAp + jYGCAmThmSm4hhRUAACNxkoCJdBpQEmxVEMMwQwGQAJIV9mEAFASGzX/iAMPjHpUAHBggcDQQAoKissH + 0CCf2pBCGhhWQQm4AQB+aEACavBLUTS1ECRgATrLWgC0csMIBEBdBT/mhhLcgQNVGOMlCJSOS+BgBAJ4 + 6Q9oIFNwgCABDCiBTQf7LDLwAABt+GEi9oGjQtwVESWBAAsMusoZFCAfmAWAG6jJWVP9oQhO+oMQriSI + ILXDRL8dBGkpgQUD7HWVS5jBCio7DeZCYg9x2AJtK6g3MKUICCAYkm7fUdp+0K0SKBgBGJDw0iwcgKTV + SAFlJ1GEBHwgD2hwgwSouYU/AIpJYTLCdU8EChIUwKUvDUAorTGCW54glBeNhBRk0AACAKAHRq3Z/52A + oN/dhklMRlDsaRVxhQNYYaK4PAFlEzyNMsBhmDTAAg4wsYc1cIAAF1CdEczhoCK4Y8OKwAEU/vvSJcDA + AH6lRjbLawAooFcYKCCBAVT50gewoA4krkYLQDzMMaSgC8FI8goEgATWrjIMK/gCN64QgB9MtawwKIBz + c4ECLWz5uLhkAg0G7I0VwIHKZTWAFq6ACxy0wABjIOtLrWCAMkwgHFdIwZ1fygQmwCEAulwxLF6JgAME + AAx4XuUY+irpdXShAKuVLDpZAIEVHFkVKNBAFyBwghPAGZdwSPGa14EAKEhUsricgXIPIOZDj4KkZliB + AQJwAlwTkwZa0MA6w/+Bh3nOoNjGBsMJUgCBOqCAz1G2xIo10IIVpOAEn/TyMF0LhStkOyBdGLaxQ/wD + KxC6DnXAgTFPnYhX4qEkJLgCFCAAARrAANPr/sEDTgABFZ97INfWggBg8OqXotOlVkgzDQ6g5wOQoAVX + qIOqR4CFFeyb2gKwwhiacIIwBPwHJwADC3j9h4MjpA4eHjgrA27yehZ7Bk3Q9QlUqddWo3yY4pbsDCDd + AnpbBA9/qMMK6AkGM5/86VBvLQtYsAISfMHoziEpFFoAATgIgAn1DHrUJWtQXY/BAHXowoqX7R0EkEAL + BTAAHLLZ9II2HLnPFDi4xzCGAKzgAF0YwgR8vUhPRiBAA1v3dgoCEIAxsEAAJ/iwFcAwBiuwQL0F6DYU + NECCP0Sm8JQgKZ+jCQUckEADZsBCGTqPhxUTHvSwj73sZ0/72tv+9rjPve53H4xAAAAh+QQJAwB/ACwA + AAAAtgC2AAAH/4B/goOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7Cx + srO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3+DhwkCF5ILm4tNAQuRC + Qunjg0DohuvwtfSM+ffO5uT7/AIKHEiwoMGDCBMqXMiwYaohQxz+gijRF8WKvSJizPgHosZUQf6EFDRy + 5EZCF1GVHBTEZKUjLtN9REUkVMxuGmeSClKTJEtOLm9ii5jSVMufIk/WEvppZM9tOk8xFUXk6VSlrqxe + xbrqqE+utIiY9AoWlleeZMuaRVszrVpWLf+JHBEp9i2sI0eq4rX7Sm7eIHv5tgKs14mSrf2q+T0Sxclc + wawYE1Hy5AliyKCOKIny5EZgaf+yHZlCekoUausAShs95Qkdw5cxdzriZIqNG08eN3v3Z962IFHO4L5x + 4xm7dUa4HSFO/I+Nfv9UV4tSXEcfFzGYpfbtbQqGDREimGBmxAgI3t4WhF+/QBmQ8iCKSLdGR8z6CG+U + CTFSxN18aw7c50J7xwghRXz9iWNfeD5w4cQxRRhRgxRSFCGOAveZQMExUtRgBIX/XWNHBett4IASxlAo + hYTp2CCHD+v1gWIxEtYwITwKgBdeBcUR84EKNQiCXjhq6BjeHMW4MUD/El5csMc9fNzXxxPDSCHBAFgO + UMU9CsAYgQ8i9BhMFVkOIIGF8MRA4o5iAsNAmTzwkwMV92UnTBtJZHlBQCHcp0BstFyQJ5YEgMBPH+v5 + oAegskixRZkMoAmPHi6sx8eMv2TwKJYSMBDQHPfx8RwwCZSQ5Q4cBESBkWIIU0MPp34QUAeV7qiGMDtk + mQQbAU1hJBVnBOPBoEt6EJAaa0bgwq3AsEFGlmQ8yY8Sv9oRzBpeZOnFGgHZseCXOQSTgQXQqhCQDrVG + UAGzwOSKZRJb8mOHkS5QCYwHz76bQEAxpFuBtaSiEeusGbq6qZme8uOAlz6MJ4ypWfoR0AteRsAF/6Ox + CCFolmlIcc8RctynhzBF+FEmAPzc8MZ6LjgwDAdlesGPDekuO8wH+Q7ghQz3xHDfBhjL4oGSnDZwD6KW + FpNtlhxIGs63EShATA15lLlni+lGEC4xccCJ4308FtOAuwOQwa04JkhpTA1LY8nAkN2oUXEEHRwDwMnJ + gfMC2E/5WOYO0npjg5ERjHyMDGQnkbA3GAiogz4hugLC3Vlu4YhbytxA53oiKBMHsWSYy0hdzjTOct2L + RA6LEWQPEIfThjjlzKr3iXCZ6q5QXaYbi9SF+TFRJspuMh8Qq7givyOz8H0Xa8eDriUEmchYytgA9QaP + N8OA8UY3EjQuItzng//UznjQ9gDRe58MpfeF0CYzBJQ5gKzIf2/LAllvsPUzQ8fMSEg8KQYFoDa+abxJ + V2lwRN+AoQaoWQwSuKOFEJ4HLZ5BwwYru88bRjWNBsgPZc4IQgccaILsUaMGlHvX4pZBgTfMrQKos8Ya + cla2famPFwvY3HqoEENrCIEAxEIf3BBhv1PoAANzU5YDiliMGhwMSwk0xhEoIAfCRUAMdtpGFVo3P2PM + IW33UdcCmIiMA5ZrGGoIXxjxMzxuSOEC8uOBBX/RhyRGgAp9SMceKJglNEjPFxlkmRgUEKx0VIFcZdoC + 7HShBvHxIYvwGJv80oeLmITsjgrAFD9gVqYkbMH/hrzIQQT6UEiCdE1+n+RFSExYECkQ4EoxA6VsSAGE + V8qPDKmapSmAeMs0ZIAbOIBG8eQ3AAD8MhtmsAIWjPOB82GJDCushgGQgIQ6QEMFfDwVAKqQN2mgwAA/ + COcPDAANFBJzAD2I5jMO8ABxhlMaDKBhlnrAgW4ywwwHOIE7mQABaRShAVsIIpZ2AIAGGGsZKFiBPsW5 + hAKYgRpSwNM50VfPZCAAAmBwZxhogA0ZAECgnOIBAbhZjC8UIAv7tIIGlBHMRmQgDj0A6TMBwAAZ1GCI + usABDRYazhME4KHIwAMEZrBMR/yQaOeUAA8uwIHAjSKCh9BAAJogTiY8IAAk/1BGC5jwgwe0ABIJ8AMa + YDnRJPSAqQe1hRnqIAB3drUAWU3GCGDgTgjgoAyPyIAfsjnRAewpQRA8hzw2IdQxUFWcM4AAApZBV7fS + AAoogIQRVJAHL5CVmLIyT2/iw53tRCcf+4AqIXBQgBNwta4IiEoxNMACt/5gDAdYaSRkEAcAuEGgSbCp + eeRTHgvNwz/v+K0/RKsIBBwgAG5dAhgOoNpjoMAKp0UsDUYwCQ+sobY528EfKFQEEEhBCN3tTW/YgYjo + iLcSKNBAAcCABHeewArWjEZpw+DOB8yAnBOohAwYcIE9gSA571lHEfrzDvkI9hNrpUE73VoALeBhGgdg + wf+Cw7mEHwRAC1foBHcSNA9DnZcTZUBAARrrziwYILLV0AINZuBaGBTAms3lhRlSMAbXnoAGX8WGBg7Q + Vrc+4AQpQMBigfEFCLTWxyb+AoqxgYIvpOAH7WXoDwSQAurGeBZawOhhU7qCIUPlDxHmqThPEAYDjMDL + tqiDAU6wZfcaIMPhIIEB2hpdcbKABV3QQkdiEREIFCAMEy6xAbpwDxxowABNeECdw8kEAQQAC3rO70PS + e4UUQNe14QRDAazMj4jUoQBHdi0TZgAHA7TgC8HEKyg0ggItHGAFASCxa+FAgy7gQNIDuYJ6YaBo17aX + 1waAaxeGoOorM4LVGrhCpQP/MAZeL5rCYygAFDSA64J4OsyYdiccgEwDLXRZA4sdsqoLoWo8RBYBWNC1 + AVJQACuw+AEVxnQTApACElC7ISgoAwQQjdJn/6DCSGCzFbKQAhoYoA4pgEILWmCGFoxAAwv3NgRWYGkr + WKGdJ4i3a+MN5C4jYNwSQYGcC/DjbGPatA/IKAvAEAYWZOEBcFD0DNqLBH/XNwwngMEKCI0CYy8ksgsX + gBV+oE+bZ/u0Rk9uOGcwhgBMd7E+r8iDodCFAtAADCdoZ5tNznW3nuAEWRjDClrQhS/ochAPrYNJITCG + McDhByxmAn3p+wO6RznKCwYDC04ggH1DALJ/WPLZCxERTyzggewrKAAEBEADK4CBBjCAQaxZEAAWWMHq + BThAHVoAhY6gefCOiCwKHgoFHCDA1hrQQnqXaQbZPhj0sI+97GdP+9rb/va4z73ud++IQAAAIfkECQMA + fwAsAAAAALYAtgAAB/+Af4KDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6yt + rq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4chA4tnkgufl + xkDp6YNAQurJ7ujoQkXyx/T1+crs/YmGAFw2RODAZAUNHjRWcCFCgQodFksoUZjCiBV9NWyYMZhBjh1D + Igoi0tDHWEFIClL5h2XJPxhhEVGZ0lDNli9luVyZE5dLmo929hxKtKjRo4yOIM1FZOmtm05zCY1KtRzN + qdv2LYNaNVbTblqfscQ6TYiQsFuvdnUV5CvOav///sSddpNrtLNyjaAVOxMuubnWUgqWBo/dXmhtZ9pd + BsSIESn4thFRQpKIW2aNHRc5DI3IkSOeLysTAsJIEbOcoR1RYvkIWWKkpTiOxy0Ia9tKmkmRUkMKiNTR + Pn92ItqYEN6PpXwjEsWzkyjLdvf2DU7J6idPlNUYVMMDbW+2ndy4UXzYhx1bOGwXF8WJkylRlB67MKB+ + Ej/ilEyZMl5+MRBu1FcffuEE0Z4NN8RnDBsCDpDEHuIEMcUZN2Dn3zAEJCFgD+ooQeF4NxgDgIb15fFd + OOPl9kd5vXiARoMMAHfNGXP0YYICxKzRg4BkqCCPAxEEGQEfxKhAxoZryBOD/5ARUHHhLx+QOAAaCcgT + hQtC+qDGMH4ImMQWJ4pjApMODEOfgBf0w0WWfQhTRAlSMpCPEgpkKcdrt2RQgpcf5BOEAz4IKQIdwXiw + Z307cNDPHFQIyYcdwlggoAR95rNAo0G+cUYwe+zQYJX5dLCBkFQIw4YXPIIqzxOBBumCDcFkgGp9FviY + zxkVCFlBB8GAIGUSVfRDwZhBikFBMFUEWJ8EGQg7apBUZAdMAjvWR0aS+djApAshBnOkfQ30o8azEZiQ + Q6zVOmjrj+SGMEWvW3gpZz6ACvnGMIfWR4CfdQopx5O8gJBHg20oJ48ITOIoDAENlpBPFCa06kKZwjAg + Jf8PMlpDQa7QbilMFZ5aKwMjfVmzAJMVvCvMHhI0GOxIJC0WTR9MigBwL3vEax+BI7XE4jPEBqmwmQ1e + YEQiX+G5TAzkUhFDMRw06AWEPV9DJ8rGqPCrqooonUzQEfThRDFCzOrgvox4fUwHWAbpwwLzNQiAwV1P + c4QIrZY7tjFRe7neITI7szGTeiCTwbcOzttz4MkEoQeTG5yLDABy/z3Sz8icQW4EdybzQYM7vFw3NDQL + uQGvySSA+ABobzNuzcxQLqAbtfHBZAQeK7OGlAMojk29Qr6wtyKA6WLEixtqgyvKkDbzOZ+LqP0LwllS + 3EwN6Q7Ag+XT6JH3kI4Uzwv/Aw0m4bs0DmDqquTPZCCpgBZkTIwaHAs59DNAxPFr69DoUH+QclBZNFwE + Oq41Qw1iuF0IdFCNBjRoAAAAwTOGdbsKsG8aIJCdgBR1QLBF4HTYkEHIrGXAYyxgc02CWzb8wLsScI8Y + Z9ADCqkwh0jILxc8KN8dblgLOrzgex9U4TZE+MBwFcMB/yvWsbxhMdBhCxhE6AAXUOiDEHRAetAwwgV4 + 54WR/cIGelBfzWAVjiJkbwAloJouiKAGPVQAiBGogPXEIQNlCagEkbFFEGywgBckMUgbEEEHVPQIHgZD + BSN00BaaVQs7KEAEb7wdIO+XDwa0rHKyUIKN4Oi2CvSh/3kHId8DeeDFV9BBkrcTwQKGdxAgEOCS9uHB + ulCxEw9GwAVi6EPuKuJK3g2ADEZ0RekA+QY9UOBmEtHfA5PQBkayYklxfMECGNiTIjDAjvYBgBpVcQMF + XLAo53ngAHbAgBeuxRJaYEQCdNYgMlzAnOeURACsgAB1jkicO0iDDMIUT0cMwQo/+MEYsBATQ8Rhdcva + QjD7+QgYBPQHTLCCBhhhBBXASZxT4sA2GZqICWSBCQ9tghWgUAZGCIEAiZzUFhiQALoZgwYHMEYZWvCA + hwZUACPAQSNUcE98liAOJQQGHgD6gxXItA4ODakADoAHR3AADb4U0A4AUKlgIGAMD/+dQReO0QIYgPSh + cDBAPRshAwIg9IES0KYv8AAFONj0B0g4BgpawIKvBhQJNPhCSR3BADSk1GV/0IsuEHCAGbz1BwZIRh2s + UNOHPoAGJNgrRWUQhxJIwJe0AwEI8FGEzRgSFFAwQGMfGoYWKGMCXaBBE94qgBWYARIZ4MAFYDmAPPxB + NkcjzWnkAgTPnuMvfyHFAQKw2ocy4QRbZQYWUlDch54gAFpAQSQ8wIB7Bks2RYCMEIwQj7OcBR68DVNw + CfFZQQgkBWBYgnGbwAIsQOMAMEDCQ5ewBAG0QAMFXYQQ+qTdxpilNP/ASz3aAQoEfMEKdg1oFgLwhWgM + YQUsGO3/D8IAhwI0GBOG+UNnvRuZsPxWE1CAAAsOywKxTmMCI6BBGA4LhwOQgBO0AYIE5TKKkkL4BAn+ + QQDqIN1q4ICuzQ3oA+AAgbEK48cp+EGQw8AEA2hAstboQgDAsOKAfjUABriwLxBAAgGM+K0ngIFpt4EH + LKzAsOp1rEgNQFJdSHcFKTjBYX/AggJA4RuoDYBh3/qAE4zBAC3QqS1I0ALVNiHB6qVBF4z8DRxoIQAS + DmgTTjCDAkBgorDQ6QEOkIWk8lkAiW2qOspwABrg+K1LOEEYBKDoek4gv58QCA66sIIpz/kHJ8hCC9IJ + kAlMoNRgmPOhT8CCFYzgCl8QtCig//AFGqRgCXt+q3wDUIArQBkgOLhCHWjAAvm+9avPdfYK0omC115C + unjQggYsPYO65jirLLi0qCuChy8sl7G3husJTtAEGhhgBRBoAR4QgAXp4kDQgjZ3PXHg3jrUoQVWMEAW + uv2DNKOazjhNbkkmoIErwDnY+X5oFgzLAhpYwQopgEAKAA0BA9QBAjRoQQFQDgcvM2EGIH23TWEwgxW0 + YAgTIMoQcDAELRxgDIZ9gMXz3QT19lnJM1jCzQMq5wmH3LlMCEAAoMDrpZTUDFAowJQjrPOrmx3MdEb5 + CF58baogoAUvL8CIs1D1s1996mOg9sP/wGiGTsAME8BDCyBQgGEUEBcGEf7BAxrLeKoHFOcwEEAWDL+C + LtThD1fgaCOuUE8otMDyBiiAAVJgBWeX3gAoL/UB6sBUKCxc85UI+h9QUM96l2EIXxDIWJUN+977/vfA + D77wh0/84hv/+MjnRCAAACH5BAkDAH8ALAAAAAC2ALYAAAf/gH+Cg4SFhoeIiYqLjI2Oj5CRkpOUlZaX + mJmam5ydnp+goaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2+v8DBwsPExcbHyMnKy8zNzs/Q0dLT + 1NXW19jZ2tvc3d7f4OGXQ+LRQ+SqQIvq5ePnt+yD8fHtieToukD06vT1hfi8+vHzZ+9dwENAivQLB/BP + w3zyBOnz9+4hMH0L652zSBAYOo4dhX0MSbKkyZMoU6oMFyTISmJEBrn8M/Olrpoxada0aaslz2Iza/r8 + efPQTqJIkypduivjr6MhnTJ1JXUqLIxVrbKaqBWWkKxdVX39I8QI2LCkJgIZS00JtoRf/7lWgyqtrBEQ + Z5XRrWukrxC0r0CAMBJ3295lZWv0VYjtcDMpNaRILsJt6DMhke9K6ZYzGuTIm7l1dsbGj4c/Rmr8rRwt + zwAJF9Z8G+pYmBEJA3IPaOCNSFBmDHQPSJLAG23EW4QDKGf5WBUyupNwYBnEtzI/uHNbyCDOd3NiUi4k + 0X2hhrjqMWvzSlAiOoPV4IIoSe8cem43vLsfOYLe2IfxufFQXDlKHEGEgcZcoFxe1uxX3RHFeMCDcHHU + c+CBURRThRe6SVCFhQUe4cRowKxh3wBeyFBPEFEc6IRbwzQA4ABoDNhOFCI+AaMwbQhXAmX1iDjFGRDa + 5ppudxDkxP+SU8wnTA0K5pZEhf4cMcUUNzxRZDBoREdlkE48YcMUJPZSQw/C5RfkGTecEaYwCUyYmwSy + +RPEDVk+4cQwJ5KhZj14nkHHDcLIcOIANgJ6w6CEBrOHBbq5oSIiOVmXTQSYYirMHjt0WOchOan3TKaa + BpPAiRJMCqogZVJzA6kuCCMFh7nt8Kkhv2VjA6kbCOPBiUn8WY4apFLha3tSqtCIqMzEQKoJwhQh53B+ + MMIsMw6QyseTUeYWB0e5YoMBqVwM020SyyVybTMikKrAMMHpBkBo6mojBqkLwDujBUYs0qo0T/hAqg3D + yJDdAGRwp8i6ySxQLDF7APtBPeNmKgL/MTUkpxsD9ZjgbjHi6bZFOzYInGkOxXwgnAXmiaMAqRUYU8XB + dC6MjceZvmCMEdMO8KVR1xBLagfHdDtACfR68wLMyPwXXcve3LABqXogI8TBPoOjB6wEH1MEAMKh8Y3U + pMqhjMq67aDqNhVj6oMaymTghnB5dJODC6RerIwQdwjnBgjc8EHq28yocHASHGszB6kRlMuMEV3q1kO/ + 2NhABa9dM8PBjElMjE0IjL/rTA0984DN1qS+EU28unlOTQwmY+qCHesUUwOkku9BDQVTk+qAI3IBw4Fw + AxAwjQ6Xl10NrXMm2owNFTBuQoaMMIiL0/JS3owO0RerA/DW2wIE/9jRTdeMGt1nugEF2MjQadrOHxND + 75m6EIM2fhBfAtTHKBC77PfTRhE0JqU2IIMO7WLcBgK4jSq8r3XGmEPyisU+b7AuN2RQljByIDjGRcAE + 3/uGEPIwIxSd5hc3wADePCiHPYWDdMTjwdpycQM90A9Wv2tHAuamHP7ZIgcvWKEH30A7fzTgUEc7IS1s + oIA3eFB9ouvI8IgHAN3B4gYLwIAJ/sc4H3Ahc9wwAB4WwYAHBmiGo7iBDdQQAwdgQARi4KIHfSACuHnD + DFb4AQ3GqAgCEG8APGADKI7yxELCSg52nET4clGHE/zgBw+AACPiYMYB7MB8ogiCIQtpAgXQQf8cjwwl + EupQBkVIwY/EI4PxQuGSTcKsD4kUxwHCEMofsAALjPgA7oSzBRVojxMt2SQVRKAAlBEEBTSo5Q+sAAWQ + /KEIH0BiEnrgOmD+IQIu2EAFTMAHLihgAWAMyQQEQMtHNiEAuFxEArZQwuEAAI2AeQQU4FBLJKCTETIw + WtrSAM94MqIOLCjnD5pghSs0ggG7TBsaPuAB+PiTEXg4AAxqec4JNIINJWjnawAgrIcqogwSVSYNsOBM + QWSgDRrNTQmq6dFEoKAFjgzlAwKgBUck4AKV1I0FVtnSREygBU2oJwtq2ogacKAEOc1NDYLX00KsYAYC + ZcIJWoAAR8iAAMz/kxdq8NLUQ+BgBRMN5RLgYAAcPCIDBOBhbhpQBCmA4C+EYWpLJwDQWjLhATQwKyQ4 + MCEL/EEydxFCEQgjD7m+4gAlPQYJWPAAZVphBaWEBBsmJhggGEEKdvmDPoTwlbFgRSKKWCQjECCAB6QT + GmXoQgCQUM8HGOALiTUEOxKSELyoIy78WEtGRPsIcrSgsbY0qDS+AIGg1vIEAagDCirBDsHGBUia1exs + QbsPTuDhCgUQaWyPAQEWsLaWYFgBCTARj9AsZCCiuMIB6KnMH2zXGDiogxWQsASKjqELVS3FdDuBgBbQ + wLjHrcM1vkCDGbT3BAIgwXKJMYIAhFWsPwiA/16vgYIusFeZWbACCfjoCzMgoAAPAK4oT7CCblzBAA9+ + JBN+MAMN51cXQxgBin+w4lpm4Z7dGAIKoBAAA9v1ByewQhc0sGBalAEHULACC9oLZAGswKLgKMMXWmCF + LLT3rk7uwhdiUUosQCC7NbbrGFZwWnHgAQorGENMlckEFgQAAgL+Q2RPYVEotCAFD7Bye5vQBAgQuSMV + TvOa7ZqFBzwWChqYcCiWq4UDpOAEYGDyD5bAAhqM1ySBrjKTawwGGtDAAFfQgAYEMedLIIAEdUjBfw0c + ZgjDAQIjWAkKsFCHAkv6kQ+QqhUCUIAWaGEEOECBcC06klJXFZctgEIBIP8ABgEAudUQbrYBhqBoleAB + AWiGwQPqe2sksBYGLICDp2lwAANAAAoQ6EILVgAFA4wgBRDwtABYMIMmiHjTLJ5BAbRwaaSU8gp1CMAY + Unxrcz7SkSdw5ESz0IS7QpLGBZ80ix9QgAPUtNRMgUKqVxuGe0f847cOKr1TYPE/cBgtZhgCCVJQABow + PKbcBnnET0DQABgAC7iEclMRYIYvODoFVpgBHBBu8FDSssb1VfgPBAAHlo+gBX8YNca7OogyHLsOWliB + AVbA6wKIewxWoAEcCiAAlhvgAC3AAhQmUFWdU90R5MADOQxqhlGPl+d/MMMfqv32vvv974APvOAHT/gH + whv+8IgPBAAh+QQJAwB/ACwAAAAAtgC2AAAH/4B/goOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6f + oKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2bFD + Q9rY3N3e1t3h4tXl5tLl4Ojpy+jkqkDupty68/ST8O33+ZD8uPAZEuhvGUFBQA4WLKYw4UJmDYUofIgs + 4USKwuZdxMixo8ePIEOKHEmypMmTj4IEQQlMpaCVLHW5FETkZcxfM0lurAWT5U6ePXuGlChEWE6ORZUJ + fVgUiMSbuRwCKZIUai0hEi3+tKpKiJGvDrnScvoVRFWxsqR8xbq12FJsX/9rGKGKdhaQGlLwmq2bVopa + KSD4zsqb96zgVTW8+CnyB+/hV3EGDHDD4I/hx6hqWJAsOQ/mVgw4D0jCId3bZFJ4iC7hLogSZx8kcE7y + gd5pY0UuJOGMxoPp28aqqJacxM/lz6U47OBsYc1xb8CFXZgNIIPtZkDIzDZeMDqw0JwlVOnu3RcI3Zy3 + LKyZLEMJ0ZW7K8uwXDKZNQuPFgMv2UuC9TCVl4sReYgGwENBFbMHAPBxpF8w2km2QwMUrfTgLw3sJpkE + bCQi4DMqEfHhLbFx5oUi7ImYjYgX9uKHgTUkwt6IywShIjEFcpbHc39YyN41QRxxRI/DnCcaAYy0GE3/ + kEfYSOMs7xEXH0VKHEGElcLs4cVspSWpjZA2/vgLCMONpoKHNn1pJZbB7FHfABOiSWQ2rlUZxZDBZNDD + bDJwFMWVUUQhjBRv7jAeiuLcGcUUggaTwGbEdYioN0o48cQNYvoyRIQDSNCnIk8qNYUTUzwRKix7uDHb + mRWSOsUUrwUDwp6csfoQEYvScUOswWxJHIUUHXHGDXTAmlGUo/mB0RE3NGupMEJMxxmScnrTbLO8AoOe + ZBcwhsipyeTwxCDZ/sKAhgPwgFEFPoghhwJTDNOAaBYY8dANPkSgbwQ6DMPGm2R8WlAM+0awATEeQCqZ + rf7oUbAIxZQ5QBwLRcFH/8F6FJOjZKwVpAYV+7oQQzHzcrZDdwrkq68YZxSTALpJSEqPDRfr68MLxtQg + cRr+LLDBvlTMccwdoqHRFjVcFMyHHcd8gO4O/7ljQwUFK4BnMRkoPICy6RCRcsj9HgOEtJKpm04OVNsM + cTIfiJaEwNoE4fC+FQidTKqieSZODCYUzMUNygjRhmhkSOHNESK4EPLIy8gg2gBTArlAwRG8ADgzaIjm + hbfXUNA33Uw34zSX2NDxQsEbYPCMEL72F5g1GPy8rxxhO8OfZF1S43PBVHQQTWKa+yaNEmqkva8D4PrC + gds8S9PB5/q6sPY0EksQ9TMdhFCwDyHULk3J6RnuDP/flJvAeDUMNthMDGJQ3vvViBzdiwycwnloMkcs + 0D7qCzwS1jGRWY38dGEDPYCsYBVwgDi28Lg7IIMCIlAZ3RToiAHGogtQUEQV3gSn3A3DAcbblxj65z8L + tkIDAfjBGPCgCA6gy0zCcEIOEke5CJggB5lSRgF+wMMfrEARNdhYf6zzCwrErobSk8YJeviDE2hgEZkT + TQ/glosO6CGEdFPANLrAxB/QYAIaVNVstmAvXOiAAnKA3vZEcD5pBIAJPWTCAVCgiDXUbwAloGIsFqAA + E7hAgghUgPek8YUl9pAFGUxEEVz4OADECBPAAQ57bNCBGLzABFhEHRcGSY0VGJL/hwEgwSKU8zge6BET + bxCBHuYQg0rGQA1PoOQCYjCHPohABD9TXA0j4AIXcIGE2cABDZrQwwcUAIyJkMKLHueFBnAOE09wnxjE + sAEfUIGa0dsl5dxFARuYAwpjCEMPmwABgBCCAXf0Qm000QFtunOX+QoBBihAjyEcAAY9XEIWsLCIIpzr + cQO4wyMrsRIFvPOgEaCCCbjQgRwUBAUraMISejgGfo7yjgPYQgOSt5KaRQCQ7txABajABQUA8yFm2GE+ + Q8mINfDghUnoAQP2YIkbLEAPcgiBCd5gAhNQwZo7FUMI9KAABzi0ZZowYS8mwAJx8rAJVqCjIoCggiiK + ZgcX/zjlJG6QAwqI6wZqoEDLlHC5kXQBn0ykAQIY4QEhcsYNXENOJA7AAiY+IAVXaAQHaPW4HnhQroxA + QQseYNeoMgIEKgAABznDAx4B1hAQcGoPC/BERiQgDRiVQA2e8thFDCEFM2BiE2hQWUYk9nFIMgIIlHqY + K6ygiyosLSM+QCs31KAGIFjtVFjLlxR88gdMGMMBkNkIBlCmMSCYCxCSy9nOGgIFEAhtPmfQgrU+Qi5z + EYJahFAExiSkuc79AwoO8ICJ9hAMNLAHJOZBFSGAwLu7tcgfeMuSFQgAtjRowSQ0wt2nZEUjUkEIciag + gTEQNp9NOEBeKdHe3RbiOBOh7/9ChgCFAhy4hycQgBbMWUHuCpgQAZZwSHBQgCx0EQksSIFs9/vhQWjk + ECLmSBm0AAbYPsAK1R1FjBmhAQNw2BpYMAASYAuGAHRBqsNIKRMesGJtDKEMK7ACbJEAByMHYwJmgMAn + A5APFFyBBmgV7QxoMII/lGEXZiABBML81Dr44wojsMID4CjaHxSgDghgoS1wUIcUsIDOXbTCQr6wgjHA + 9qkBOEAXaDEE+7JZtAagCB6wkIIxANquLBBAC65g3VWQoAsGMPGQp6zWjpjhCwaAw6F/MFEWFAACX8AD + DkqBAARoIQACkK6NTxCARH4EB4Q+QXlXfYITWMEAK+A0Hc//jIkzA/sLKaDBfVf9gwewgMwk6YYGVsAC + Ex+aCUwIwwmyEAAaQAAKI5jAgh9x5i8ItgUGGIMVRk3tH1hhBV1g9kkQsIJK/4DehybmCcAwZitAIAUH + OEAdujACdKN7BHVYwQFoEG8rzOABSwQ4bIttBS3k2SpmMMMBAgCHJV561eAmbGjxyfIf1HiJTTj5qpHA + hDGf+zFaOEABSj5k89b750AX5wPkDQEErPsxZZjAeCFAAzDg0+dAj/oPiCkAKxQAC1DQs3PpqIERtIAG + NDDwy1kddWKamAVwEIABUoAFDRw9vIdYaxe6AO8oF+DacLC4FYoMh7AbgAYHWEEdrsDPJVnDvRKzfqIo + STCEL/xhrVo/vOQnT/nKW/7ymM+85jfP+c4PIhAAIfkECQMAfwAsAAAAALYAtgAAB/+Af4KDhIWGh4iJ + iouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TF + xsfIycrLzM3OyEPRz9OS0dLU2I5D2dzd3pTXgtbf5H/b4uXY5+Lr6dzt7vHy8/T1m0D2+fr7/P3+p/gI + BfyXDN9AgseAHDyIEBkQIQ2LDQzIMCKxhxUt8jL4R2FGjRtBihxJsmS8jyZzoUw5ayXLWkIevsQFcZBL + WUGCiFTYMaavnCA9djRyMxZQQToRFlnqsSjOQUQQAjFiREoRp7eSJt1H1chSosS29hNS1auQmsbE5pNS + o4YUEFf/j6m1J4VtVRBokx2dJ+WP3RpGZtqSQYbBHyNusc31BmDAgC0J4Aqu9cGxYwkJJtMC0cPyAAlV + NM8i4DkJAdGyZPDwzAMEalhSCCSxLOFDusXMEmzxDGDP7WwcZjve8QHr61C7LW+RcfyVitJ+AjdvdcGz + m8zTWSXw4jlN9lYfJFi2gP27qsaWAXgwr6rKDsumFUVl7+nDe8dJmCMKMn8+/Ux5wAeAfEjhNs0Rx3jQ + GX5puLafIP55g6AxVZDh2RqNGOiMhr9wwNp/qQSYXg0ZgohJESV4dtoie3WjVTEecDdcA4roxKGJjlQh + 3mX6+XNjLh8IN0APjERIjpHB+OHZ/xYkEugOksC04dkFRbDozo+5GIHeAEn48U+LwdSwZXz++IdlLatZ + RqOPBQrjgQXwrfkgPWfSoiBtchpS54ZIDQOEhZaF9iURe8pSw30D7NBjP4QWGst2cRJERKPDuOGZoIwq + EZWjsADKJab8HHHEpm4u+Jlt/ohKKJS7gJCiZYalekQQow7zqmOx8kMrobMOs+UAK/JDhBKjRsHpK20I + eUGqmh7hxLGueGgZD7I6++wwbHhGhnEuKuHEEzdEQUwCQmIm7BTf3sAqL3vAiR+q+hCB7hPGXvRrG/yg + e8MNU6zLSxqelcDPvnSc0SsxlVm2g3T2HLFvuFMYI8OOXGKoT/8U+9JrjBRodJePDi+oIYi6x0hpGZH2 + YBBBBCHMIe4xz3nmGz1PbLDyygogI4WnA8RRjwI3R+CCDsn8Su08NpgQtBzKNCBkEqCWM4UCPtzsQgzK + 1OCuY3nI04HSN/PhbzB3eLaDg+XcwEXVK2+wQG5CDpArOQ7YvLILcry8zK0DWJDODRUEbQLWzQTpGQfk + 2NBH0D4ocIMzNaTpGMreYEBF0HycMcwVKQSgiLSwuhiD3StTQTgwdQjwww9IaJCIFKYO4MXM2HTwRtAb + 6DEhMEysvnoBn3s2gHfYqAH2zX0QLQwEvjNxAgKKSJ4oG9RQwAfbEfhggvLCIPBA76tDAA//IQ0Iv8Uz + R+jwBvYsv10MDb7/AIfriVTnmc/NLMBH0BGY7oQxWPie7yCAgkRMzGzlScYCqOCCoFUgZ8gIQBN8NwYo + KIIBcStBX5ChAz0EDncxUEIyRjAD8DWhABN4Hd8GcAdkWO9ygnPAMlBQACT4bgZ1UEQGtvYZxBHDBgq4 + HePEsIDdJUMLLAAfEwRQhuB5RgJ5+oX+qMA+H7yhA47gCC9QsIL4LSGHirhD3HqQQF5QoA9i4F/V+iAy + SPCEFziAQ/xY8AVFSCE506JdJKAVCRvYoQ8bIN3NKqCHP/BRFy2I3w8KgANFyICHAyhB1CahhjZ6wgEv + +CDjIiCCEEaC/1uwGIIVJri6B6xgEVWQEX56cwkuRMAEClCDDTRXCYwtwAFi2AD7VuYDQv5hbMoYAQua + NwPoJQIIwRFeCZokiSDU7GYbEAEGFEC4xy3icbJUgB5MkEb+8dIFfaAAOfCwAlKujgb0SwQHKOYYL6ig + mX+gmjepQIUKcEEPenBADuZAARsswAYxWEAM9ICBEFzPZru8mRhE8LZDBgMFVojfCYC3CAbwTHYc2CAk + BOnNtvnABWLoZeDSyNGOtg0DC3iCPLAAhuaFYQRNTEQNCMBO2TGAmY7YJi9NytOe3owKIcCADaw5jxWc + IH5j6AIjMCi8HaRBo4+IwQtMUIGS+tSkFf8QQx86kAN94MEAYfDdEuBwBUY0AJIDAEAGJkGHBSjgBSEQ + mt0S6k0XbOANcqCmHfyBgzHY0Hc0KOsiGlCCuCVqbn1MnwPwKQITiEAMYnjDBiJbARGEQA99COgfaEmQ + LkTUd03wHCPWsAXDPoZhlXjcDfZaSSXEwAk6oMMfHufQbkwACkdtXgqMqYgE5MG0PsQRIyAwA4misBEM + QFQk9wCEKvkClMRAwQEeoEgI8La3yQENEEAghTcKFxF4KMAJwPeDB9CggMiVwGkAAwKFgOW7hzAD8+KH + hALUsRG+AQFcitBes8AXEeL1YgC+MD5EGAQIVimCESCCj7zAFwEGoO7/HL+Qwkc09yHtfYgQrgJd1Hy1 + CeT9AQtOOYmlQCQmGPHudw2Q29UxoQkGaKQkOIwRQSgExTY2EQq6UNz4hVaplECwTTrS4cmUoQWfBW0W + VoAHSji3IhTBEQmsIGHfnYAGFuRElHGEAxpkQZEPmAEEYqqJjxRZJHhowQn+CtoAgFEUZx6JBqisyDCY + FwHo/a8mzLCCB7D5hgYAsp418QUrtDh+cCgAFswxaExIFwZVVnIBtCDYW5A5IhoowDAVWcoAWDfPsehC + AAStES0YoMecfgAYUnAAUKcCDxP4wql7J1qRoOALNDiBOZv3gyycwAAtuEKTS3HrLkAgyatDgoxH/3Lb + AsAhxLz2dQFSQII6DlsTwzY1DQTwZU7/IAUsMbVfve1i6gpgDBCAgAYsiN4CFyKmZpjAELpwAAgUYAZN + ECC5RfwSFODgAAGAwQ+WsG+C5xsMArCCAQpQhxVgQQtdMEMXvqCBOnyhCytoOA1oEIATPKDb+wafFVqg + GRx84dhyDOu+V0dw6iLhqDB4ucBncNQ1s47gKy/lA1hggHSiBgckOMC5y5vzohvddzu3QgpInR08fKEO + nXvAoY9edCY84AFhEIAB6gAFM8CXBKYuwBiG+eVd5/yvJ/C4AApggANA79J6biQUEHCAFhiABpoOwAzG + AIcHCAAMM7ACDNaO9zAWtKAOjVx2oxWxDeghAAFlgEIZEECCP2gAemaA++I3z/nOe/7zoA+96EdP+tJP + IxAAIfkECQMAfwAsAAAAALYAtgAAB/+Af4KDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOk + paanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxse8Q8pDyM2gzMrO0pnM09aa1YPR19yM2YLb + f+Hd5IjZ3+Xp6uvs7e7v8PHy8/T19vf4+atA+v3+/wBf8QvobCDBZgYPSuOXUOEwIA0dCmsYUeJEIRaD + GYQosaJGjP48AuP4B0gRkfMgotSYD6QgISszzgKCkWZMmbFUMjRyE+erIkZOQnTp85YQoEakFCnKCwSI + oEWWMsUFRIqRGkFhTsUlpUZXp0S3yvLwR4pZEDVOHgvS7wKHPzX/4kppFoQtPg47BtyBW6Pnrrr41uQd + MKCEB6lr89XYQrjxW2uA5QlJ05hwCRnXANt9p8JLZS8ZMg/a3G4PgCSNkzAQa+uDm9QXykV+twU14R4q + WNdiUFlCmrnrZpfzwKMyjyruSHeT4qfygDhhCynXPSpDicolFgUhwm36tAaDB0j4sIj7HyLei6Vvtud6 + YzR7FNmtu566pgZkUvtxZN6+qDa2DeBGaI3U5x8mCbxGWBJtyHegKQwE6EZuicxn4IOW5BEgD/FV+Idw + GHKSQHhJxBGiKxwEaAFy2p0IShoSNGaYdhe6KEkNPVSWho2rsBGeBBTyiEqKjXlBlpCoUCYj/whInmKE + e4QR4GCTmyTYGJBTUpmJDPkRtsMaWpayRoBkHBmmKLw1xsNBNd6SR2V5HEREf8C82dheAdE3DAA6nkkK + GpU95mcoFlQWpD9t3uJBoYRhyaYwe+TYaAODhiKFZwtSGhB6xChIGBt50hlMl4RhBlCithTh6QCg/sMp + MThWpqk/rw4jBZSqnTrfnn0SBKIvdhIW2z+7DkNAZQAAhF6twXDwmbLbFaNCZWQQOyeqtSQQ44IE6kOE + EtxhO0sNjBI2az5KHMGWuLIUwWdjDXoL7q/AHCujX+scoe4RzAbTALUd3hPEvPwaU8O2hB1azxHpMswu + LZISFu89DUcRBf8ybTwrsBNKROHEEbsgcAANdSRSRWVJBDxPEFM44cQNU4hKSwtZ/GAzDYqEN8B+C7c8 + xQ0g59KCzTbPoMgFGq/s8hRPRPGwKSg8QPQSXySyhnOmyhPFGU/Y0LTMtbBA9A8QKLLqsPLccMMZN3zM + iwFjW4FDIhlfCdw7bD1xwxN896LFA0zYfIIWiWhbmYnwdMDFDX/QcYMSveAxRuA/LGEAHogIwVhjbuDb + jA5iRFDBHH8w7ksKgNs8RtWITJuaoOy84EMEtIvgxC8jwGAzEyeskIgUxTVmAZPrKOEA7chTAQwCNBCN + hBWKfIDyauoEEUPoyLvQATBl1IEE0WEgkEj/rI2RoXJ3C/CBfAQu6CEMCroTbQA6hDQQIIPpdCCCC+vz + cbswcCMaCzTwO0ClplXcUMMb+Ec7H5hADcQgwQmI9gADKGINCBvAFrgRBTWEYH0OXEAxykCDJexuBuJL + BNIqw7NpxEAEs0OeCRxwjC7MYGwroN8g9kAq8SjsGHOowPpEtwDTFWMCBRjb6hQRIexI4mmiyIEChAhC + B0yhGVAIA9GaUAAdCqIG72pMnIzxBB3IgYoyVIA0yhAALdqsCSRQxB4w1Rg/GGESdKBhK7ijABEMMQJv + mIMRm9EFMIytAChQBAcySIYfMuIJfuSDGoJ2CrYsAAMxRJ4PxBADKN6i/wwpMKHgfJcIIdzBOV5IwCPY + 4oAYbgADFLBBKUBGAQUwEIR92B43vhA/m4FhbooII2FW9IgY3JJ2JsCACENxhCh0QAEb8EEmkamHgnFj + CCtowtgMAExEZCB47wFTI+bwR/aJgQ8xUBsnjtCBGGAAjevbgAgWQAd1WIFyPzjBARYBHpSVgEWMcAA8 + hygCDNBQlpS4nRIuGYKB0s4FyYTgOmxINCYMkJ8Z1GACbkKHF1BhA+XcgAtCgAE92IACpTuPSg9xBiUE + wQEO0EMFPlpOF1RADjGYBEmCgYcV4DMMAcBc9HpYmKwxYgFcMEE5G+gDKvDhDQp4QQwUQIE55GABMf/o + gAPc+YI+VGADVFhqBMAqgjlQUhKem4XkvmezMKxAqIgAAgNWNQALiLMRT1iAHpQ6zaW6wKYOdKALaApS + sY5VDC9wwCAhkVZbdEFsRJvBPhVRAwYQNVePOIMT9PAGpRr2s4Z1gQgUMId60mMCB5Aa0WAQx0XEQWfC + koQd5uAAMYihr6ANaQXEoEwdLHYeZkji2FhgBi8OAi/OcUMlnDCHF/KhAn9d6jT5RwUTVKAPMNXBH86K + j8lVlAYEXMQaykWGBAiBJ5agwA1IK4c+mEAETt0AH6gQgje8oQ9y0EMHFqDd3+oDCmMY2wNo0M3xMUY1 + QZACCBBjiSvKUg1ToID/HXLQgSls7wwX4y5B6qDaN3axEXfYkRCsshQGj6QcZWgBPm12uUbswQhOKQII + gBCUxgokHUNIwQSd1+JGqEQpQNFKpQwByg7/YMCJdIRJjjLjktBkyITAQQB31wQapNDHJZkxTY6y0yEP + gQZuJBoNWvsIIZj5DzCxSUmgHFwj/8AKXYhEmtPMEJ1USsqpIxoc6gDXMiOGH0Je85lQAAE3u9UMkgDJ + QGyMoRWcYMU/oAEUKEGRjfipBSwI8w8s+tZNMGRQULDC2AQ35kww2j5DIKGmbQaHTnvi1FNZARhEScEA + QKHAULYEFALg5iWcoACTzjUmcAABQ476BzBIAQL6/yzsSXQhAEiA9BKyYAAsNNsSCFgBHNg6ajAUAAtl + uPYkJnCFAtzw2D+YgRVGEF5xR6ILBXDz7n4gABpg4crubgQOSBCAcx87DA9ggQFa8Ick55sRI0CdNtHN + hBnMgAYHGMEfmH2JbJihBVfAEArKHWB0V3QGYAjAClbwhQng+xEoQIAGvqCFFdDg3GU7EQJaEIATcNvj + TGgCGE4QgALQYAVdiPgVNKAFEmxcC12AAhZaYACfB2AMNRs19GyEAw2kIAA/uLnH2/q9MMxAajOAwwSz + sHObLWHhHn9AkxCABQOMAbJbj7vctx5sKkGhDilgAWRpPfe+ixIJMCjAyZs0gWI/3H0FArCCIR+wcL7P + /QQOh4MVDDACXFeq8BOAwhfw3vQxjMEKcHgAHFjwdRgI4O1joAEEDtCCOmDB4AePsiCGPgQcYIEEE8CD + BjQg1DIUPvbAD77wh0/84hv/+MhPvrsDAQAh+QQJAwB/ACwAAAAAtgC2AAAH/4B/goOEhYaHiImKi4yN + jo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcKzQ8XFw8il + x4JDf83J0J7P0dSqz8vV2ZjX09ja3+Dh4uPk5ebn6Onq6+zt7u/w8fLz9PX29/j580D6/f7/AD/xC0ht + IMGD5Qwi/CVkkEJd/B7qM9hQIkSL+IQAMbgR2EOM8DZGLAJyYS0hRkhuFNIQmUIgLeMVQWkEBMlxJc0B + qZnSiJGcHgmxdFekhhGjQmaGGwizXREpUGuAABHTJC4QDP5IqSEFhJQiVndxGNDmT42zUsLqWuNlwIA8 + Zv9BqM2lwo1bt1vkzr2VAcBdt2T28s2T5C+PDIJrgfCz4y+ZD4lrsUHz1w2HyLSGACjsNkmbtJhl+fmb + BIAMRkRCl2Jj4a+XBlUPBQmielSNC6QJMJotKPUw2uo4NL67JcHuQcCD8U4HZItr446WK09+TggHCXcl + pFlEnXptTnt4/LXAhjvyat7FxeE8QAIDvdzTI/NNbk+Ju0m2wJMOrsHwAUnEEZshQRAhXzT8aVPDfXdZ + AJ0iCVJzYDYNkBbHOxNW0wZ7h30HSw3i3QXXPBkOowJ7EjQAYYkeYgICbnfx4AGELY4iAxn4+VGjK/7d + RcZpO7KSxl8lgBakKgy6lQf/WEem4sF/SajYZCof/LWDkVOaksdf+mV5CgjO3aWbl6Zk0AN+kOnDoi4J + 4OjWDir0s2YuVbDnxoNkjlLhXV5gmWcoBBD5ZylbijgoKWG6peOhooTo1mWMgiLEmXdJGaknNbTVWZyX + euKBpgBy2iknn+In6qialOqWBKeiikkNlAJoqT9HCCOFo0mkKWcQtQZTBGV3QSpnMkkOcKGrm/h113bD + JnPHXyOqycsEiYxGHLKMjBAAC1kgYUAiVfLJZD4RwmLAD+j+QEMidd61w4zS2jJCuj+MkYgH2HVWBbnl + wkICvWBMU4gRoCYhrD39wmLGA+k+cEUiyrp1Bz6zzWkN/wz0dpFIoHehQfF5tgSwRLorUHvIie7CS7HF + qKTAMLoF4IDIk3+1Kg9wLKNywAnpjqEBIkIUO7E9RBiY8ylQwJHuDBojMiSfCBd99CkIWMEEuk2skAgb + 7CWBGIlHGJ1LGSnQuy4iQ7jp1pjyHKEEbVOfMm+6MJh8SKFuWTAPEUocUbEuVzSBLhMPQLE1afvud0TY + Be5SxhhX/7DEt4m0ZiiGixcdNi8GIDE4Cygk8vSbNbzDd9iL9wIFz+guQUIiCbA3ANvs9O12FHGnMgEL + 9EJQBsTjtcOrE30T/0sKkf9gxc+I7HlXVuso4YQTTzzhBH28jDDD4A8coEixFpSezv8RUUx/w/XAIBAA + vQEo4jyAi55zxPk3WJ87K0O0kDwYXyji6ABkwNM4gvCEM9zABk+IAvZ8oYHtYa0A7pPd0Mihhj/c4II3 + iIIShkE2ep0gdIiQQrF2kDhIVLAXOQhBDP5wBus5IRkaeBm6DvA7RLDhPwNAg8pWZIM+UKEDvHgCF1zg + ggWw0Am9QkYAPIcuMCBAEXhb27gWoQAfRGADMUhiLZ4QgzdE4ItFvMEChdEFB86whodoU2VKqAgMUOGL + V3SADWzhhBiEAI5f9EEUqrG+z70uERyQHQ8a4QI8XhEDQJyFDhzwhkLmUQwKyEYdspAuby0CRne5wBQP + oYYKWBH/ji4QgQNi8YQFcOGNeNzAKLOBggLQCw5aUEQVLNcZAsAHEXYwgSPzWAEMRGGPq3CCDRygS0NW + QAFn+Mbq0hWGAKDxEOG6i2U2aQg7iACVeYwAFxxwg1V0QA/FhOMG+GBEcKDgXOk6QQsWMTq39GANAyqE + DvpgAkP6wAR8sEEOTnEGPTQSjz7YgBwWcL9cIMCMS5gBCBOBSbfwQICHGKYIDPlFE7zAAQVlhBr6cEeK + VkAPFCjHAej1gwI80xAyKIHs0CA+RRxwiJ8Upw/0gIE/2EETvgmCA3xI0QhQQQRqyKjjIJcxgRmiARYQ + 5A4RQRs98CGmqeQDFzpgxGROwgZE/9CBHfowUahGIKBvwMBN0QEFSqaLBX8EpNrc2dJFxMABLsBmKl0Q + ghf0QQ0L2OMc//AEQSSxfn+gwwIWoAAFiKACPY0AEbmwADsI1RcpEFy6CmCGRQTyLwMoASRi0Acv9tSK + G6hABbiqgDlgIAY5KO0w9TAHBXBUDCHw5GevKAIF6KAdZrACvcIAAUZcFjC0a4QdbsCFiW4gsZ98owve + QIXl1nMD4dxlT8XABwfQAR5dwNjS1mnZwpDhMiiRhBoMW4HjejWx6DWkC3zggzdMtZvxKMMBkvcDOGCB + EQ1IAgG2MpWORKIDduDCC5p73PQaeANUEIMJuGDbS/iXGmYoQP8Y0rWEMSw0EZwyilyGIolkOiAGIhCB + F2UrXTDmcQOFNIEIMKAHBXRgg5XgiDZwMAZ6LcEKjvCJEKiyY41UYp9zmMMCViyHCoR4A2+QgwkqYFcu + YACZdtDBXjEBlGEgwKyto4FRFVGTpNwEE0+Ywh8osM8OxOAMOWisTcf6hzHqYwSsQ1cYDCCzRrAEJRXB + 1iBWEOcfeKvOjqAKTIDwZWQZQIY/YAKdH3HnP7DkwaiaQAqYONnKOkIjg3Z0RHJRZXAgwJX0YgINHvaI + nWxaJLjotKcLQF8mBKB/jC5EU1R9JDOUjaQCMFwkZIwsHBhgZK/kriVofaQJQADRPziBAbb/DAmmoOoA + WEbXAwJwhZM2+w/EDlIdeGfjGbTgwpvINmagoFuS/iAFsKbESy6lgQJIll5jOIDd9BwJFKzAjA2jQSzp + LYkhaKHcJAVDAcDN70YgYAVLAHYlZwABFFi74ImYwBfGgOwfhOEEK0grxBsBATjQN11gMEDTNs4IDaQA + 3wALgPdIzoguFIDSJD0BGFKgARzMm+WEwAEUaBAGhdPLcyxYgRaYh/NC4AALATgBzEkaBgEUAAKwfvjG + v1AAFvjc3A8AAxhUjgUSaIDgENcABGjwbnO3TtpjoAENnl4HKCDgC1iAAha+oIErIEADJBjBASjHKBx0 + YQW8W7rZW/eAfAdc7eIwYAEcYHCCsv/g5oOaAA5MzgIYVHzwmDc3qV1FghUUQAAvu3rmB79vPWsAC12A + gBW0PoPLj/4HWoN4DREwghVAwAA02FYWZgAHFih+Blk4wQxgIIAAFEDjOB8CChwuiLdjoetXAHvRp0/9 + 6lv/+tjPvva3z310BAIAIfkECQMAfwAsAAAAALYAtgAAB/+Af4KDhIWGh4iJiouMjY6PkJGSk5SVlpeY + mZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wItDw8PBxqVDg8WCycvHz9DR0oXL + 1cnT2J7Oztnd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7z0D8//P8AZwm8E/BgbyEEALCEOGv + hg0FHcw1UZ8QIRCLVNS10Z6QIkaMgGAIxIhDXkCEhDRSRArGkwmlyGR5UWE0fx3b1ZBZA4SRl9JysmuT + 4E9PEFJGYjsotFyeATyqGNkppWk/dxcGDEgC4E9LcAUjojOSVavWEuZSpvOQJ4lZrRf/0lmdViONhLcD + 8pwTeJGcEAZk8LZZp3acCjd47zwiEgTmKg8W3ia54MERY8eq9pSQvKVoo8aCQGMmZSSNW7M91kQKEoTI + 6FIqAptNouIzIdevSdXoIZmB7UGic4cy8nS23kes/wQX/mnNjrc9ZEBazhzU5rcNHLWuXooB3uO/uYsy + 4uWthQziZxHA63sR9fSfPMg+yyg5/FHrsd+HVeO52S37wcLAaVupFmArIPBmVgkmtdOYfd6sQeAA2bnD + Gm7flKWVBTXA8x5d/mlFwIGucCCZZ/JgiM0WbwEoz4PdeBDiABzc82EwDby1Q2X1QBhNcWfduE5yQv4S + mVl+kNiK/wcEJlGFkqzkaBYZNtlTZC9ADuCijdNcJyKUrMxHIZiqMDkbilxCw8ZbZDSIz5W6mIgamark + p1VXdKKSJXh5lgLAWyP2aYqXSbQn6Cgg8DDbB4daEgANNBSQwjWG7DZbhfrAmcoPPzCxxA94IOJBeVrR + 1iglZTzA6Q9LoCDqkQNIYOCpkeCBxKpNTCAqYqU+SWskOKja6QOuHiIFr1r5+usjZpyw6glXIAIErAPM + umwjCMDw7BeJKKgVo9c6ggALz0KRiJcDJBkutgI8O0IiGg6g2LqMIBAAE5yecEAiabx1QRH0LoJCAas+ + YEAicRC4hRQBK1KGAZ+yWkAiDNylFf8aHTacyAqrMhFAIg0Q6EbGGh/Swqo/WKHrIQlYvJV0+2h6ygjC + /jAGAolQa+ibR9QCBRyrwqAFvP7mA2MtV1iBawsUv8UDySUTUgYNKEOQiAouk6EsPTKvkgLKBZSBiAyw + SoBp1ISs8AC+KWuASA3o8tkjLlBom+/QiNg5gBs8zrNdLiiMwfYPTI8dYhJne8hY16rQEDETKYSKCItm + 5QFwPD7movaqLLhtbJY8pJg5LhrMsGoY5iKiQpOJs8P4K2OgvMLKh6ALQN8e9pJCE5wyMYYZFBOo9Tug + jX4LCWuvSkIiCXibRBtuMqKDN4u/3goMbDNhgNiH1BCvBTAnApr/Ai7EkM2F1reSwq2cwlDsIWzM2EaV + iOjARwQRvJH+LEQQccRlwNAA71aVOkRcgEDgUwQdXIA//PXhBtFQwv+Mt4vYrepjieDAjO5wuUPYoQI+ + aOAGFOCEZxxBgkcDxslOhzNE7IFyWiFDbRIRgw00MAIVcMAUghGEI/yvf/tzBQqc1bsUKKIKyBpAXBSh + hxDizwcmcEAwlKAExvhPRb94GMpOgINECKEtZtlBjRJxBhEwsIEVmMMvTti/EwbxFQJkGxIOBjIxWcBa + hlCDGW9IhQXQYRdEUIIT+ifInkFjAlRb1QzeZwgQEKBJediDImIgghtC0QGGvAURouAEJ0xh/wpOUMI0 + sFCzJtAxETAcABnGmAg1hMCJ+KMCBnChhCd00glnmIIop4GCRHJqBl2sI3RUQL9CEIECILxhBPpgPlo4 + 4QY3eMINQInFaEAheT9AQgEoZYgiEMBlA8CTIhZwvxtu4A0xsEEsbBAFad6ADtGsZjQGhrIsLC8RVQAA + JHF3CApw4YwNNAEGdPAEVzhgAxgIwhmeYMv/fQMLROSUFbiHiA+IaQCBEl8ORGBDS4pAhyVEhRIoUE4f + dOAPN+hkOPDwtWfty4sMmJEbdla/gyozAi54wQIYWgobUAADAI2ACQi6y3BoAAyDY0ELE5GlAezAEeSE + pQj74AAd7DAUDv/ogwluGgEFyNMbBxhgp2jATUNkQJ9a2QExP5MDPVSAqxvgggIWkMlMnEEHMQhBBYLa + QBGElBz2QtkDXpoIKWzGAk8KiSPo4AA5dFSZVDCBHBRwhoVWwg5/cMALysnVHKZDC1lAGQu4pQgVPM0o + RqjKI9SghxA89oYMrMALMKCAJ6hBnQUFzh9KWFB1LiAHfeDCGyLw2ga6QLZ/VAcEwoAyGtBOES0RyR+K + qYgjdAADb6ACV/FnQyqI4A0vcAAGFjDXBThgDnporFZNoF2pKtMEOm2HGQIQMVZZbREpKQJIVKKRR0wh + Bgrgg3a3+0ScxjYCYoiAdovLVQaaQAExgKD/O7oABsHWoREMAQF/qbuIG1AgBlwAIV8JTOKbmoAPCkCp + PCBQsx+A4Z74LcJHfjIJH6pBASFwLU5LXGIfvCGKMZhePQjWsZs5IiUgmK5YImGDDlCgD3zgw1tf617j + bkAMchBBDGIQhXygoF0oC0AwGQEEGWOkv5RozBkooAMF6CHAcuCDCURQATnIlg96eEEMHECEHGBiLtHQ + gN04hQQaSI4RGvFHojWBGz+rIQp2YKc6IfjGdYwgoj9owqQwbJCUkATQsxAIqJ+xuYIZ8REfMUinR/0K + VkNjCAZgH6cecOpGFFMtrlZSGYhcsG1CIiwlw4MvCR2A56LtEb0cHKcC/7BUSeQaSvRE2Q8EUEBnP/sT + 1/4GCgwg7R+woHDOLhkKOCbtE0CAkZHI9iTUfY4JHKDFnKIBjP98rRGYDmVMYEEdDn1sR2hBadIOgwFI + 229HaIDXoh3BmAu+iAmsoMLdLsAX+M3wRHQB4NJ+AAQQQNGKI8IMKbi3tLNwABSU1eOFGIEA4P3L2aE8 + ERMwABzqu0UDNPvlhNAADWZAc04t4QEB6ALODwEFK5yg5z8IwwPgkIJ5D/0P/34A0jM9gzGkoAvofnnR + kaBslCGh6jRYgRZu7vErFIDlGYeBFQqwgjpAQQMIQMEETl4yHLTAgt3udhiqHoAUQKAFXSCBBsxg7GWA + DQEFJIAA3vPOeGmfMmp4QAAWVhAATDe+2/cteBkQAIUWpMAKYEB73leA8yFcAQoHMAANBMCCGZygCVyX + NmGf/gccfGEEK1C9FcYAg9A3Ady0D77wh0/84hv/+MhPvvKXH4pAAAAh+QQJAwB/ACwAAAAAtgC2AAAH + /4B/goOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6 + u7y9vr/AjUODw8HGssVDysvHzaLFh8rO08/J1Nej0NDY3KDb3eDh4uPk5ebn6Onq6+zt7u/w8fLz9PX2 + 9/j5+vv8hkD91ID8EyRk0ECAv4AUHCjwIEJeQIoIEfhnokFZDh8WUljEiEeBQoxo9GUEBAiPJSkWHLlL + Sg2XEosUycjyVoM/Lo3UOGmxZq49JXjU+FOjiBQQPX3adDNgAIAaL2usnEYTXpwkTQckiSNEStVgX9vV + aCMha1alujLc2WF2wI44aP9xjWVrlkcVSUEg/glbrg1WswA8RApCJO8uvn3bJsmzZ7BhveykpGkr4UKC + R48HEQGGGBsHulktYy5UOHOug52nVSHTFoAUS6Z9KSQnw0JrSkFyUx0HBIDZJFsEYy4c0OBUbgT+NrWw + ZjA3hkmvNVA+QIKKeql9DeFhVgLcRrHjlrrTeqj4W2yoezF/3laJ3x/a32LQ9kIR+bWEeDHr5jV+WgS0 + 9d1/shjBWlZoEAhgWzcpGEsRTGVVgoOycMAghbFwJyGGsKzRVnwcunKBWRZ8EyIqHhzYFAEntmJhVklk + 0CIrvmW1xYyreFBWVhzgqEoDv7HnoykjbqhPeMFE2JT/H/jkRdw0eyiXhAz56EYNkFmRcdyQldCQQgsa + LNKGWTdyeUkZP6T5QxhlICLEe1mxuM+TtGig5g8nJOKBkkk02OQfSL5Sh5pMjJGIDMpJIKOZlhjAhJoF + JIJlU24AZOUsBSyhpgGJ0JcVD/zkdaksASCh5gFtHjJZVgAwagkeVjz6AxN1mChIHmbl4WolCAgg6wkj + IGLEFjAyueskGlih5gxdCKthUyCGWkuvyzZ7iBC2ZdXcsZKgAIeaJ0CRiIoD3MWtJA+oicQVbmar1XXn + QmJGumkigQciHuzXlAR+7hMoK1/MsCwCiGTgrnXxQkICC2rCQAIiUqiYhLkJN6LB/xhqgqFFIkoOsG3F + jJQBhppNiHstGmb1CHIjAqsZ5iE1wKkVAyszggPDaZaMCBDEZjVgzYggEICsDxyQSJFN3QG0ImXQoGYY + nCLiB5lb3vNvK5lu2qlyJQi5dCEGNJEmEwXce8h0WVkg3NeG1GFqmmOYbUgCO2p1GduGkHDnCbYK8uwA + DGSX8BdZLPuyITX0rFUanV09pBnK5twCIkOMaSTehQRwJwR9q2DWDlRiTkgKbzNBAwqIJKDiDv2K3kUY + GeOASMxmtcGI40MioGnOBCOyalNCJWLYGQq8EC+1aT4AQSJsgLbDx4d0IIcPEbigQ7wp3ElDIgk8m0Qa + ikQgvv/4GMS7wgOyjnF4ISDg+umih/QxfgQV2FGOk7i3gsAJd5p8yBrOg9ch1LCB+WHgBubYzC5wliYD + 9C0BMhvABb4SBDnMrwIxEEf+YjGEFdwJBokAQYCysgMBGqIDVJifCK53LC3QC0/+M4QMQCMBOSHiBS4Y + 3wYUMI4NvgIPGNPazpA2gB74J3pvmN8GbAAOH8bCALBLEwt6dwgVgGYANjREFByQw/HJwX7XIEJpgKEB + /tVrBH3LQAS9cLdD3MCCOuzDNHKjGyfGYgyy+kEA+gaED1CnDV4jhBoqMD8XOMCOshjjMYbQgt394AHr + M0SNgGfCQgRBASkcnwkW0AxE0gL/ASOrVwH69ocPgGYxIEgEHfQwvwiIoQPByIwnn0ioGbBrdhdQDhla + V4gzhKCL4nsDLH9BnFEZAwsta6AiPuCuAZQglYmIgQhaaQIKRKEXhFHkNALgSFsmogZ5oA74EnEEO5ig + lW9wwC6OwE46YuMLd/rB8rjXA7PschFzOOf4fOCCOTwBF0dQghLEOMta4EFzasqCGRIBBA5QhzmKCAIF + Cjg/KryAhbMIQkCPoMCC1qILL2RCChZBxHIxYgEhaKULhDmLjRLUmNSYAELTdIKH0bMpSaAZI5RAARMA + U3wm0ANGWUEEgbJTjBwVBwnQpyYroC4Ra5BAD+7ikUZQQAQ//43ABviwAAWmgghOiEIUkKqEpI4je3cy + WiKKYKwapKQRdsBABKh3QS4M8xRhnYITnPCEvSrBHDgIZZrAEMlDGKUke3GEAvRZSBf0QQ1D/cRmbnCG + J0xhCje4QVjR0YJ4bm8RERECCIBghKohQg0WpOsF5cDDf3aCAlxQZ2bPYIO+mvUcOIgVySbHCCBIISQS + Ac8fFptV8bmgAnpwQGYtQVs1LBaoR6hsZqdwBI8CQwtmTBMcCmsIIcSktJCI6waKK74KVKAPGLADBf5A + B+EJAoF/iIEC+iACiorPBzFwwg2iMAWYmmMIBnjbD5YQgKcuIiQiEZwgYsAFxrbSuD54w/8b0DuHBSxA + B3PIQQfmQIE5YAADXKjABjL5YBH84QZKsO4xcCCAOyEhaowI7kRMm4gndEAB432wjgtYAR9QgZAVyKF9 + dXxfFwBKHsi80wPq0IjQ7mUmkVDCGfQgAhIT+cpYpqsJFODaeaxAbMuyKSMKMpHZSMIOasDAGwiJ5Tbr + sAImeEEG8VGAeMJhAo4g7T+iEwkdOPcFb6CCC6in2gfTNcch6IMCFtBefZihxYSyAinZZxCKVAKBMegA + BhTABy6I4Q0m2EAIqGACEZRaD8m1QRAa3Y+A5XEJNEjVI/Zs6Urk5Z9PuF4HgoDmP9gBgVPwCRRe+IMm + FADPTR4EjU//044WgLleKTDwJBTMCmpjI2x3YoIBkB0Ja7fC29QogIDTNNJugxsV577GEOrs2Unv7B/p + FkW8r8FudQXglrMWxLw5hAK03skKJHC36AqBA2zfaQYbw8S+CZQCYqdpntP+NkA8GM8mBOALA4eEFpKZ + piWMoQ7SxkhchkAC3brYAHLL+CKuUACH/2AGvFU5I86Xx+QFQAvcljkivhC5eIIBAlTU+SEQAAGOgwsC + IRc6MeowBpcjAQ4GIEHOlT4ICGQ32yyAwEKpXggEpODq8QxAC/DNdRSMIABZcKS6smAFCGCc64M4ezzn + zoIU1EEDKJC10ElQgBnUnFAPmIEVvkR2Zp3jYAQFKNzc77SEJrCABiuAQspVPoEDBADsi1eT3lU+BAR0 + wQAscHk8swD3QZBgBQEAwwOQ8HcrlH4QE0CAFlZAAxgIWKSvR8QVRmCAAMA894wQOPCHT/ziG//4yE++ + 8pfP/NcHAgAh+QQJAwB/ACwAAAAAtgC2AAAH/4B/goOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6f + oKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDiEPEx7DGyMukyoRD0NDM05zSg9HO1NqU + 1tnb35jW4OOW3uTn6Onq6+zt7u/w8fLz9PX29/j5+vv8qUBCgwAOAtIv2L+DBP8ISVgQmBAhRows/HOQ + osCGvIqAABHRCAggII0wxLiriJQaUqQYKRIRJEWSvFSwEXIShMoiD0fCxAUiz4ASJ1VK4ahz560PFgYo + ZfAHZY2Ju4ruy3BHglKlO6polGqUlgoASa5ejdN1V5AGaMKKHZCn7C6ka/8H8FDhVpefuBLu1LAUhAiR + IHU97bkT1wKDvZIAC1Ic2FOaHWt7cEAciTEhy7C4omsTd66mvn1naSYnhfNaAEUoBQG8erHrxpgYQL6a + 5AII1X8HYYZ9iYPaqxcSPGp9jOBoZmzInL647jgzDz3EJgGwmzcsIwDW8pBRz3kwP78HeBEez/swFWuT + NLjnkhoP6X7wGZ9m+ioAfuZzVZmtdHy+hMwJI0QJ0n3Qz0PH+CbWBfm502AtQiR11Q57WHcLAWsxZaEt + yl3Vw4a23EXbeiDOIoWESpWQWomycCAdiSzCAsJ7V6FxW4ygXNECHo2sEZ6BOIKywg8/CHAAj4lcIBb/ + GUGGIgCRRBqQSA0dKpVGk58g8ACUS5CQiIu0kYclJy1AycQM5gyS3VVbrDjmJgVA+UMBiXjA3wAcvMkJ + CmMsAWUdiTQglgRS6LkJFDBAecIXifhUo6GbtHACkUwIgAAiNdA4QBIEQJrJEBAgAWUBZiBSxW9JVOEp + JiikAOUDUiICplJurBqOFa8ekEh9A2xhKyZbEvkAFogYsYVYV/5aCRRMKJrmH3tUqZ6ylRwQbJGJZDAo + ZdRCMsQKTYyKpCHoXcVkt5JMYACUYRhQBiJx/FaCERhV50qcRCIR6yGOKpWHm/ooRkQtT0KpKyJrWtnQ + avaygkCf+UKBacKcoisJ/wIF/3CCxIdkepUEeVocSaJEntBFIm6ItQZJDa9ixqRQaoBIEV6oXBBrLatC + Askal3pIAijuAKPIjZjBMwxeHlIEf0mIufAsKMD8wwNJG1JDykolwcbNrNGiwQyv+mxIBjUrJQFdRDti + BgtQgkFsx0yrmnYjZYAd8cyaDjB0Ijl7agYcZlZdyB6aJqHhzbWggGvJgCJybNYhI14LxD8s0QIiQih5 + VR70zr1IGTSYuUKjYv27SN+rrjtqIgyIhUbni+QQD+qpQBAukTQ8+8Fv/iHiABcmuBDBDUR34SeRY+CA + iAz8keFBIj5EIH0ECxCtxbUnPLtHdFcBeYgI00eAAf/RZtj9QxYcW01g1gQEOIgC4YcQhchlsA3lCImk + 8dt9iHQgvPRUoADRQgelfRmCAb8hA3cOcQMThE8BShAZBJpFpAAkIgEJ3BshXvC/CPBBByLrwgMoCAfl + OU4snULEAqgwvQ1UTx20YwUOwgClJrzNav0aABoSYQc+hI8LIsMYBX9wsEPsbkJoM8QRFBA96VUAhBaj + AQ0rWKeyDUAC8UEEHTroAz1EEF1dkBMYrtCo3/gqESLoYAVkh64vSO0HNzxg3BKxgAqETw8D6xYerDDE + FFwQRWwp1CGewIXwmSAGFgsVlOCAgkQQ5ipeWFn/OugCEXyRWleQUxO0kAjmfYz/ADcyhBP6ED7qXfJX + OFgckfyIqRxuwWmFOIMdp2eCDqDLAKIi0gxMaAgjfIA/EjjcIRSwgR/SoVtfuNYP8IeIBGxBXoI8hA0K + OT0XjI9aQ8gYE8aQCCHEizbCNAQFWNjCFx4DZ8IYwfE0JrhCeCBvFuCWIRxQygAeYRlHiOEs8MAzJuTu + S2u5A8AMkcbwiQGRwtDnLUAlpxPILBHru8oCEaEDPjQxAj54gy1/RYI3shIRbLCKUngQSkTEwIGG3Cgw + FGqLIRDwB2ciI+l2QBaoIOII4yzlQXnRl9xMAwpvNKAhpGCbpkSEESvU6QJOSYu/tIY4y3CpnGbw0EQA + wSZH/2WEA2Y5PSro4Qy3gOo2oDDCUT1LEEIAwVbao4g5iKGUPhCBAGfB0mAEQE4PSB8iCMIRiDRiAWK4 + qPTEoABZQLWuvMDCGwXQCI6wxH2GIEIOTCBYjPKBAk9ghVP9wjByDCEF62xCEfe6kCLgxDxyKGYpN4AB + CuTRFEE4whGU4FTE/gIBPPvBDC61CCCwJBIK4Gr4KoABhI6CCLNVwhE4a1tglElONGgEThTC1kV0QASV + HawIOgDFTvQlClFYrl8W09xfTICPcrrcIoQwXfaaxwZbLaX0fOACEyhgDq+pRGyd4IQo+CWfsfUpO9xo + JjBUVREAWUh1FzFNcso3AhUwAf8XYtABGwjinoiwzD2j8IQbRGEK/A2vEpS7XHhAYJ0/sMK4rPqHIoAE + sopYABc20EG4RmADfBDBC+awgDlU+AlqiAGFYzAHPYigAlRQwg2W/IQnOGHJ/FVCeZExBjkxQagzc9OD + 6EABObz1weH73wbEwEIqVIDM8rXDDTpsgxtMwcm0rQcJzPcDJDQOwYQAyYP+oAYM+DC7YA609Byg5CdM + YQpSzkcLrnWmdrLYIpTIAQVeYALhCjrQffjDmp0QGn3gC0os4GUj9nyIBSiAC0hW7aUFK4I/JLofZaiy + nKzwrkmQehBgzYECFICBEJjA1xXwARVM8AYTEFsOeliAhWH/ooHchoEGjYTErRNxhgiegQJqOIMTJK3m + wHThjUz4qCOmvaoDyIlIdJI2uSFlO02mINqjFsS63zQB0J4by8uY9zQ+DSUaiLq3nksEHlKQy3wFgLeR + SIi+N7HwZaDgpVAaA6MSTguF50N1coJBHSZQHH7gAQJv1NjoAo6JFQwRSgHAQq1JTgkt2M9MLDhZLhre + DijI+tw0+MLKWUHzegyhAAXP1xhkzvJJ4GAFWTg3kazQhRUX/REkUOVUDXDgpzsCAQY4wcmJBAcI/Nvq + jCBBAG537iwYAAtOB3siELACOteQBWdHwVnVPohWwSDobSsA0emeCBR0IQBblxMcDDBxTb4nAgs0CPm5 + u254RWAhBTBQZsYbrwgcdCEFYMA7ESnPCA2sgHIwFRvnF6EBCLANDqOPhAb2nvrWu/71sI+97GdP+9rb + /va4z73u5xEIACH5BAkDAH8ALAAAAAC2ALYAAAf/gH+Cg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5yd + np+goaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2+v8DBwsPExcbHyKFDycyly83QnUPP0dWV1IPY + 1tuN2NPT3OGL2t/i5ong5+qI6evu7/Dx8vP09fb3+PmOQoRA+shA+AUcBMSfIIP/fhkRYmShv4L+hBhE + mFBXESkgpDQ0AuJhEX5/QFbUJUXGHyk1UBZZ2TEixZG4pKRJAuCkRo0fJcLsJcUPmQEDklSRchNEkZc7 + b4HgUAKo05o1anRMuguIjDtkkjh1OhQpVVsqtmjdCnSLka+8COwgW3YN2l1s/wCwHcCDw1u4aMY6JXMn + QZFiXuV9cMO2BwMPmYIMCkKk8V1MIPzofWoy8eNPPsm6YXA5V407bL18EAkpiOLFRBSbFsSYcedJM8ny + cAvqNOvXkGSSpfkXty0GkwcAqOybFgcJW5NcgBeYWYKfWwHsedc8WQIvZLdIYR5O7tYeGYrbIkDWAnF5 + 1YetgQ40yQd7D5kJ4ZHcD/xd2hYBaUMWQA3xpHwRABaOyICcU2789096q9DAxA9WQLGIEFskZxeAoyDQ + xA8c/tCFIhxMtlxFEM1SwIMcPqCBIhZsRcZ0MDFoCgIzdPhDCoowQJZ9CcmYygobpohAInu06FQPMU4E + C/8KVoTBIRM0KEKeU+5RFZCPoWgxA4oPjJCIFIQ5hQZpMb5SBgQPdCjAFYlwQFYDGJJiRgAoImEAHonQ + J6aCcYaiQRYdZuElIlWQ9V6foqyA4g8ssHkIEHm4iKgoZQjQIRMFJPLcVndMGgoJNXYoISJuOrVDAp5+ + MkQLaXIIRyJAeAdUCal+MoEBS3RYAAqIbNpeHLV6MoSlKa6QyAdb7RBesJxo8ECdWiBSRKRO0cosJy0E + +cMMEyAiBXbt8XhtJkMA2WGUveqVxHnjXkJDh00Y0O0hIe7VriZDsGDjAYlcEB2Z905CAhgdhrEiInoC + xVnAl2hwQocs8HpIBkYGBSf/w5bUYeMYQx4iQ7KoYlzJCrlyGEAiDejlhsiWGGCjAYmksZV2LFPybocQ + JAKaU3nUPAmT+yYi6wBp+CzJEFZw+SHCW124iG1G40Bwii0gUkNTTh1q9CMojAHvwYbUwF4SF2/tCB6h + /pDFqIaAAG5Q7JqtCAIwXAp2ITKMTdshpkG9NQqhMjHD3YWwt0PchKgm9x80XvoFIjKEGVQViURgueVy + 4zH1DycQPggIawG1w96GuHB5BDfAc5rfrphRN4dIsF3IHgkLlcgGp9ugemuzlAFHhw+QYPXYZRtCxelq + mI2H1ynWkQjWQWltiAmnx2D2BFZ0uES0hwgB/QBOG8LH/+kOmI00ik0Yi8jQbQAsCBenY/COYqnRUkYB + Nq6QnyD8OdUGCIhQwOlEILcUlAxTZUAEAQ40gBIEZgGnE4PcWuAkDgngWN9ZliFscDofpE4dq1kNLUZQ + wR+MQWKGSEDoBmAByiHieJdbgOpsQYKHcegEHUthD6hEukKIIH7KsyGHPCeIGqBhKwRIhAAvZwK56YtD + TeAXIqgVFABs5xA56KDuQIiL+9kIR4hImZhCdogKnE4B62DdLHDVoQDMyxBskNzhEtGH073BbF1oFedw + 0KuEDSCJiFDD6SKQg7/p8QdEFIS/qnUWRFDvci84hxpp8cQfhCFniFDBVtxQvEIs0f9yLvhgzcrgMjUl + ogZvk4AfGmkIOpjucnrYmhZKti0+HsIDVBQOYhAhh9NtQJQsu0LamlA1RDCAPWRgQ2DU4AMg+mwCdDpX + ImTwNqIp4oeXc0EhfbYCG8EBhYa4gF68wCdDMPN0fDBaDTuEhEEdQgUMTMLCEAG/080hGpPsIrF+AKVE + FOGITvGCImyAu8tRgQ4+g4CNZpBDQ9TLKfM8xCctR8CaOStoVtuhU4CliDcMEo01S5qa9ieIUg2HEXZ4 + peV8YD2WURBesgsnqoDQkEU4YJAbSJ7IUPA7aS4iIxxhRC9PVwEdsEyhwGuoIYSgERC4rxBTeOTlKrBF + hiFAiDf/0o8QOiKEpw5CBzCcqlExlgIb4VA/UihCTRdBgYIalAIY00AJs6oIIXxkJV4dRAxUarkNtDRg + NxOSIiJihKM0Yq+D9EEsc5HPYpDgWT4dLAD/IKMO8NVyIUAoLWwTBCVEA3/Ai6khgPAXiRSEERQIq0Hv + 2a6r2uiCExKIYRmhA6mic5vXKmWHpFjXkJSIEVEY6iBdgAFglqI1jKlfY5GBgy11aAaOghVpC5LXQjjg + sn3Vg3FF0bfFnKMOc0WXIj5CkEfYwaOD7OsLdBqK5YajDNmzUTFh1Q8s/UEBbk2vCRRQ1UykhnfzuMIh + GdqIidjXBlxoZnpXagIMLOAJk0ju/xGUMOHU/FeE71gBEl77RkaYNhJqEIGCF7xSMYgAAw6IQQ5sAMwg + HOHFTjhCFKJA4RcfoTHdnQd8bWSnUqhBDtglcXpvQOQzOGEKTogxEW4MYPeeo3E2Wlok7CsIG+hBDEIW + MpGJ/AQkI9nGS/5vPlpgI7URyBGntUQHXmDGLJ+ODmd4whlYPIU4JzkKNyZCQsrqTXAWGBM5UIAIVLvg + G9DhCUd+AoWVoAQ9w8QM8X2SFZRK34NowgYLUAAX+GACKmzglUR2whPC/BZhLuoH4l1cJqAAKBvtCs2q + XgSZbbQEmMU6Eys45I38/AgqB0y3ukpgr299iBRo6wdIoAGeiMZdiQk4qMxWeBwxfH2OCRRgw+y0QiJ5 + QW11GODYnGsBSasyEhQg9VIPMAClc6EkmLTgdcCjgRl80e13lKEOaQvUfJktCQ1EumA0EC2/G1GGFLQa + XmM4AALGPfBD4GAFB+/QCWhw5oY/4gv/lrgBbGlxR6wADqe+obw63ogJQIEGWNU4yRuBAAjAYa4dWrkj + vlCAQzLB1jJvxBcC+wBe51wRO6frzyGhgXUP/ehIT7rSl870pjv96VCPutSnTvWqW/3qWEdUIAAAIfkE + CQMAfwAsAAAAALYAtgAAB/+Af4KDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq + q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DRzkPS1ZPU1tmLQ9ja3oPd3+LghOHj + 0tzl5ufW3Ovsz+Hv8Mzz9JtCQvfP+UJF+UCADBK4z1gRKSASGlkoRGDAPw0FPSzYq0GaPzWkZFx4sEhA + fwMp9tpDwMuAJB5A1DBSA0Q+IxEjiuzF5g6ZATgHxMFoRIoUmDJn8jJSJY2XJDlx9mCZMajQXhxKSEia + VIbLp8AalKCalMdOrL8S3JnKdQcAFWCBVdmClCqZCyr/7KWtlSFN26RJSnDIMNeXlAt3c5Lxs6dvryIq + TLq9Y8SwrwaKk3rhUENUkCCOMdXwE/jkhQSaLiPCPCgIESKkMzvyQzbnDgKWUau+BKINVwsfCJIS/Yd3 + KN3fCLTGiUaGKsyXTYMdsgJFpDRcS4B+lVqohhMnWjgSwmAHVQCVZ6NCYeWHeRplGDUYngSAB/GpDjQx + b97AIjbek255D/+Uhhn0/TCDBopkgAZVW4DQHyopzEefdooAQBUPxi1oihYA0hdAeon4QdUO090DXC0o + FODgD1mQoMgaN7n2gYWmDNHFDEyY10QKHCLCA1WwwVhKGSnUaN4YWChCAII+mvLF/wn0NWEAHomskR9O + blSY5CgFBAgHFIpsldSLQjlECwlM0pcClIh88B1WI8IyQQpI0HfCFYnUYEFSZFgpUpuwmDHGEmbawwBe + X105yghh0AeGioh4cGdOPfBZkG6SphJAgAEgkEgcVIHJJi1QPBDgAfPs0UNXRTg2ESvMifoDEzPgkAgD + dyXRgGqVmlKeeWGkUOeBkKoaCxZxmpdFF4moUCsDmRGU6ygrJGreDHQeIkQeSVmg4Gz5sBKAkL0mksGU + A9wBHxD6qIJAhj+cMEIiaroWoqGijCAkEycQiMgWSZVAbykGYJqIB8Nx8C8pu5q3QiIc3LUDXweHckWZ + r3J5SP8R2OYEQLoRf9KFqz/A4Nwhe0Q2gB8dh7ICoOZZgaYhGTjMRsqg0BCgfYhwJpgj1dHMCB4C0PdA + HYhcm9QFUvjcCQ5wBIgsIsCe1KPSm2hwYhYvF7JHiyetkUjPVDfSQrFMjGEGImvcJcG8YV9Sx4ljZE1I + vDiVwJ8hdIigRwxntN1IwPQVkAh0OfmLSAwRJB5BCH4vkiV9OBtidE5pNHaIHj4ozkfjithMHwSJ8ItT + Em0kwoXiEWDAeSIJ/0A0yaKf5KkhfKDuwOqH4MCCeUw8oAUiRriRUxIGH3KDCajHgLshKIwhJBLvHuLB + jjhJgNYhdryh+AYdLG8IDAEyCvP/lElUgYga2icuhvLeD1IGu03oa4gHXFuPiB3IJ14B++3/gQD45jmB + xQyRgMiQgW2DiAIVtkeB/gliAk2jT5EOkYDh6IkQN3CB4nxwAwcKIgsBkl8hgCA8nJDheoZQQwW2ZwMP + 4gEMQhNfIWRwKpzs4IKDUEP+IiCG7jmweU2KniH2UEKcoLAQU0hfBDawAA/+4U/0ed0hajiAHRTvEDv0 + Af/6N4YASVFrEhrdFQvhhNop7nYevBR9DoAIIIQRJ4UqBBEwsME+ODEF9GGCrxBxgaMlQgEbFIETVyAw + RAxKY+ExxBw0mLgQdNCBIwgQC+DVmi0U5hA6WGDiNtBAB0Ih/0AwyFEhPsA1MiTSECtUXBO9ATZZLIk+ + WRAhITLAtQEckRBOkAPqXvCN5LTSFSgA4A+a8DRDAIF6J7kIIhyAOhMQQRy/fEXQ1pgI24wOAEk7RAw0 + GYH9efBx5hEcIhpWOBwOYocR0IMHCcm7MSTrUQNwwy0J8YLMJc4Ej5QGZmRzCy1cTVMUjFoSGJCqQ3QA + dT7wYTai+QocsAsJxSyEEQCjsUToQIkR4EI1GDqLhDEhcoaglWBOWQgM2LObatBnbzj6CsANSVzkGmMh + dLCBDWJACRvdhRZY9oMHjOwQbxyA4RBxOsVVIKXtwwEI6SNEQ9ANJ+YUBAVqqribPoOls//4Fn1okAgg + kM98iDiCLhXnAjtcFauxaIGQBCQrPg7AK8+iACMTtzlnoDUWZgDZEpo6wwqBwAi5egHqIoBG73Vxq4tQ + iRGukogzUDVxVDDrMu4qiwMEyKddXexiGcFM1PHhCZMNRl5HpYiAwARdiriBGRWnh2cuT41DEuUh/loE + yyVCDdyMgAtWibsuFGuYA7TWP4rgkUU4YK5LVCjnJiDMHwSgtBAxwj8YUVTFUaGTq1vBvR4gS2OC4Fnn + HKwYsNs4HDxgreJMBEiccr9UKu4Nyu0FZXMBzp5Wq2jTRdezYuBe/ZG3bVc40Q/2qAh9AIQRC8jtEnnr + t/qGobsj1C//eP+wgMduEgNTaJzV1srVxAqEvYezsG7loAbXhq2+PwjuxSRBAXRGwAcVYLDSELDUlzoi + IBPuQAhOqjgRxJdmEAjQDxa2CGdxbBE2EMFgXywGPajhCErTXYBideMJD8IBItafHlqYivkeI5KY+ikn + gkABESDXqFxYgA68DInU+KYdWrURG0FhAz30F3Ub4IMCKBCFUkDZG1cAWbtkWForE0IHLzgz6qjABwws + ALSVMM1l+EmPaAXICnIJySSc0AEuVIDHS+6mDo5AatSY2M3I4Y1oktMbesDWPAQu8qogoYQFiADUSz7D + DW5wBic4YQpKiEIUlEBqYivhNCZ+yhfY/2UeCN24EjZQAB8+veQK/GHXN/i1r49ABGKTutSSfrNI6iBo + MHzhFDqYwwvEMFcfCPIGT6ADHabwhCdEgQjclvRKfcnmakygAGv9gblTcYYY6EEEC1TAtacwhRvQ2+FO + GDa+ZdNvcbz6B1Y4Gyts0EIlTOEISlBCEEAecmRX/Bwa2B19ltDhSBh6eVoQ9A9o0FZGvLx/I6hxODXu + xEww50S9i3XPLzEEAwT8B+kdOiYMIPMAQFjpkcAD0wO0BAGoGOqSwAEeA4QEq8sN65EIspBZ0IJMg10R + B2B2T0G3i5vfowx1UDmmAGoLZ82mDCMYg4Db5WxaUEo8ULDC0TF+dkZK4ADFIXOF2zPTAoo14dyFrwQC + LtUEIkfeEivA9OUxwfPNe/7zoA+96EdP+tKb/vSoT73qV8/61rv+9bCPvexnT/vasyMQACH5BAkDAH8A + LAAAAAC2ALYAAAf/gH+Cg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp+goaKjpKWmp6ipqqusra6v + sLGys7S1tre4ubq7vL2+v8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvcqUPd4OHU3+KdQIJAQq/k + 5OWWRUIgQkVGQOmE56zt7pAeHAlSpNQAIcWIwSL5Erbat4+fIRl+SiQZEOdPwIBG6IGwl+6cEIWohjB0 + SEhIAgYAdgxYOaDEnxpGCMIrgtBePUHqXLFrWG4PgxJkJrIcIMFIDYEg5Nm7JVJQU3cZCHgROpTlB4v1 + 8uUaGU5GGjJVq+4AkIEkMA4lJIRdaeFCA7PA/xqUWJtkx5Y4CeD+ApHGAtWhJRjIMKL3VJkDlRrwWDtW + RWFVLZgYkFSDgJu1aD4UeZwKCpwfPwpAAnEhbBIvDPZw7jwDNGgBjhr0WJsn72pUOAK4/rEETqMGFqom + 4fEBhKggtwshSLHENZMxOBjF+btyi4xSyA0FyW52RZbdM7TwJCSFgNqhZCquyo6cOz8sY8CPYESAuhsO + hFcRIaKdiPttQyBAQxOuLWEACosQEFYP18GyXSFB8AfOAQ+41gQNCCySBnVb2BYLe+4gAAcTro0BRRmJ + AMHBeSx1WEt7/v2XDQK6WQjBBIo0wOJKAOwSISda+XLACbthqEgVKg0FgP8HybFihgDNgQaDBopksNhQ + aJTVpCplGFAhaA+sgCIiRZQ2lAVabpkKCd+BhkQAOCbiR1VkNKgmKngw59oMdSjCxo4SXHVnZ22CRkN0 + iNRwJUttDJpKGQU4B8MVisypZH6OmgJFa2BOlogMSa7khoeZlpLCbidokYgRAAyVhKBmBQmLBoWGUQAe + iXDwV4+lmtJlgXBkiIgHiw6wA6kOyfrKBFZEGRquiPjxFwG9ntLFAySCNh8iCXgxVA+YVisKCjWCZoUi + cbjKwWrKrvIFGNki0UIiUgTHEg/GPbYULAcQKKWwh+jKUqDimhJAtj/QAK0hRhTLQ8GlXEGka9se0sD/ + X7ByplW7pAwBwW6+JdIqS14weRvHp0xAg2u2JpKAvStReyfKouDwGZjzIvIBenY2yZEqJHy5RBNfJDJX + i4vIGA7NpBiA8BhjGpLAZSytiwgdeoFkWHyurZArVWSohogCFWBgg145naIBpz88AEUiZlaniAkR1C0C + 1iQJkXYpWBQKB5WH1DsUA4l0UPfhHUBcSQthlIjgIVWwuMMaibxweAQmKF5JpK7RIOe3NSBiA92HK6A5 + JWMg7PUhNeQx1AWJLEDF4RvkcLokKBS6BAmJeMsSAxwrsMHhfJxxeyRBZ3uCGdz6buxbh9xg+eEYGH/8 + I9e6xgKihqgAduiIvHE4/xWmX/9IHf7+YMXjhuxMshSI6OAD7Ymb78gBzgYQdSEbsnQB/IdwwPzqVgEl + 2M8RTusc3FiSBNghQg/Ds9sBHbEy0EgmUXEbgB8SgYHLYWAKE2SEAHaTM0NIoVgZK4QIDucCPYSQESzY + TcUKAQTnScBqhjgD6eq2gBcqogwxtODbDpGARe3AMYd4QghoRwEfJgIFQfwBErCACBmAZSVJQBYhdriB + GDgRETiIotsSwaIksCF+FWChGr54iDC6ZoxEdJ4XkGiI0dXNBxvAGxsJgQcxquoQbIDZDsRmiClEMAIb + qN8eBzGEKCKhC8P6ixYFYQcxsPBsiyQEC7LFhBkWgv9qz0PEEdJYNyp4MZOD4Bpo+nSIDKCBJWSAniFu + sMMIKBKVqXNNCQtRRAZSDhFLrJsL5oDKQVjBOaszBAhQmIgVlq6YgqggaDx1iC0MRWaH6MPluADNPxhg + N6JBxB0Y6MBDKOByfFDaF1eAsHMdAgiW4hH4DBGDAUagAphE5Qh2AwNECIEDoSrBJP9gh0P6QAfQ1MBu + HpCID4CSQYmwpDAdAE0UIKFA3CtEIAe2hnZFgQuXe8ERoMm2H/AucMUi3NjsaQLroXKErkEMIgBAlTwk + IgeHdMEai1kAhHkOEeliiQUUIdG6YQCaLeDnp/5CSEN08HAVgOYVdoOEhdEQZgP/wKYhcnA5H9xyj2WY + GGiGeIi43ScRU9ihD/gAzWO6hprtKwEBzrgIB1zOBXYo5se0xwiMoOwMh4wAN6Ohzlp8YTdMYB/DCBKT + vRlCm5ckrH94IdYfsJJMMdmMIuzggsv1YaTQ+NEuDuaaACwCCBthGkhZeMpF1gFVijWEEKQghJvctLOH + e0Mz2vMLFHwJNJBMxEdqq9nKdZWizZisL9z6AyaYVhFAoAlCNlvUCFDBdsh4kDCS+saMHgIExVWEXS/3 + BtAeo7C68O1ukvnOmjDtD3zoKgYMmF304kKaPwhZIqb7s0SogZTCJGYy7HsLLOxmCX8U7h/mwbTx3tEF + rRUG/4F1AcTduDNFHXkvZA9nAuxK+BgHWCjgEmGc/ibCBvG9XAV26kQcFCo040FHfvalCB0AuG4maOIX + v+maEwDstO+lQHV9UIGv6mLCvUBA+kIDZHQ0YgGBvWcPnZgCTjZhxIv4SCNicGOj5nOCGljyTxlxjvcS + YQ5R3oAcvnzAU8nQE2oQ3+WsqwA2Xw8BLx5DJN4bhA7I+XIbEEEMbvChaey1a42gsSP6EOUIiAEDCD2g + Ktt20k7cQAGzm/M9zWa/EVwUNEsIQIzx8Yf3FkINIrDnXbkQ6dsNAb9hYO9pJeGAN+B2ztxUgnIVhwMY + 7KYJZPWEEzrwgijr1Ak3uIETlP9wBCQnp1+7EQClRBGDVB8uBH9I9g2mMAUnRIHZuz6EjEDkDjzgtwkp + KAUFXtDZBRwh2TbYdhSccAQlMNveRBgpbyO0HaU5mxoo8LVrkCBTUjzBdDd4ArLPMIVt6/oI+T5CvffD + nQftxxAQ50cXSvpIR2htEvmewhGmEIVkL7vZEdqPfyQEId7CBQ8GWPIMgn0KiishCjiXuIRi1G81kWs3 + YRBA0VqRHZX3nBD/LgcUqUqDaXdTExq4mWsKENunW6ILAp+61TWBhwOUlMlbx8QEINAEZyUs7JkwgNmZ + cGG0V4LHu0m32y1x6B9koeBzpwQ7fwADKub9EknF+98rEVw6Xph68IlGPKk9PojD/93xio+85CdP+cpb + /vKYz7zmN8/5znv+86APvehHT/rSm/70qE+96lfPekEEAgAh+QQJAwB/ACwAAAAAtgC2AAAH/4B/goOE + hYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/A + wcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3+Dhu0BCRUJG5EVA5ELiwkZsDBdofzVSNUZSRvtC + 64RA7nAVyaCCAAA3AxIO2COlYQ0QRoqAUPfHX7uAmVoM2VRDngUJSRQmbHAvHwghQiauK1cRYEtVG5kZ + QNLlUpEEHACQEclzAIF6DSGivGhOkD+XGCPRYMKEhQZLDLZI6Nlzyx8pJ/0l5WQmwI+vP1hAkVTlzk6q + CnfwyMPBg6+NMf+LafAK9uvYRx788JjaM4naCxwSEBsSV9iXAE3qMikAiYEFtAMkbGHAxkORraTmNmFS + d4WjIg1KhOy5owQDt8niFuaFo0Dir0uaHHDkgQBCqmgYJECKTPVqXSnC1M0yu5EMHlSTAFgTLeZvXAbq + /phxAA+jIml29JRQgsMeaYT/hN91QPoJCCgYybjAVySZOJenjR+Pq8sM6QbSL6qCnGeSPKhV85wtOIzB + GVgFDEhIA9qJlEQPp2HmCl1gBdCIHw2KtEUVErYyhAEHfiWAGYtIgaF/P70SxFZdnDCcFosUQcBoClnQ + wEUdsjKGdMUpQkBPaKigy4rcDJGCYowt4gf/kBngQsSKUG4DxQN1jaFfIgy0l1AJRuQSBBHf7FhXTYo0 + cJZCAHzHC5GCBMEmeBDgt4gMtym0RZO9uEkIEWBOg8B9YLEwgSI19KdQCYL9QuSibz6zVF11KCLEBTz1 + kKgwT1ZDwhJgMUHDIgzwJMGlw3yJCW+3UPjDCVcowsaZCX1wTKOUoFoLFHIm4kEJPLVha46rWBEiGNYh + IsSPIpVQA7CwkCCdZ4moAKsFHDL7Cg11zUDoFiJJwIC1r3xBJVgQlMkTAOC+kkKIJxSLiBci7UBquqng + AOhXKSjiB40+0dtKCyE+8BQiCcCrUA/LPkKrv5SUYUWnViQCxIwKJSHr/yILM3wJAq/9EMYIiWTw2KEZ + //GECB1o7EmcYM3griGhVtyAIg5EEAEG3/yqChx15WuswVtKkUgOVNgcgQk2qJzJFUiAtQQJiXyQ4QAc + KPKC0TY7oDQmK4QIw6CIUKoQDwkfEsMGWPMxRc6uCNBzIjKcmUQbiUzBhQtGb6AGOADpPAoOLn6FxF2G + CPFBt2oackQMFfhgsws4s92KFsPhkAi3dpZtiB6O22zC3ltfEh1YERNc5wDfInJGBUa70McN4fg9yhBi + /rBEuYgwQKMb8xKiANYVxCCO7KLg8MCBSEB9iBR5VGwVInTwgbUIsIduCRRNf5XFlYWIXHHqZhdt8/8G + wmOklSkr1CVAGYjIQGMSvQ+iQOcRhEDHVjiSMkQBbyMSB408SFwhbGACo/kAA32K3flMUQYDfYUJLUgE + AESSh/wRogOse9wCzGeUU6DgXslDRA14lZAkpOgQC8Cb556AGXKYQgPj+sEDuEeIKpxpB8w5xA24YMA+ + SAgI8SGFFoYFt24l4mRYU4D1MNGCKiWCAwAUICFugLbx2WGJl2DZD5hgIUTcgUYX0Bwh5kA/pGHREvwD + i88OIbaE5CERDqhiBN5QvTNOQlW4M4QH2mjCRGAAay+wYyUEEKIeFWIPJBxAEqqGCDlgTQ+CpETtfhDB + QxThdGxAhBJEgDWtRVL/ErVbAsgQUackCAkRBTTaBj8JCTywACwPIJMhMtADhZBhZoegQwYj4IKUsfIR + OHjlVx5AuEKsAWgWyKEhCNi6Vf6yETjg2TCxgIgqZGgHUhxEEHYZAQo80xF4mMGBlvAFEfJLjIQQXwR8 + cMVvMmII9/rBwAqXoSRUa5m73IA33ckIGNSlmITIANBuiYgbvMGAzuRnIiYZqUPIAA0KccPFDnFQVSp0 + EcKCjSEJIYNE7gCXFMXaHC6aiDJgS3DQ0iNESzhRQ3DSZj6AJEkPsb9O5dEQolEIA4JYCD1gTQ4lu+iR + HrhGQ7RxAGlIxAKwZoKZIkKLP+jiIdogkgsMDWsb/3DqIbrgNfYdggMi6UEizqBCm+VAq4W4QgxPgID2 + OahuFbWZEtE6iD+B5QTUPAQQ+CWDRPQhbXStqzBlCCNSDsANACAAOgexVKNR4QiB/QMeHvaVMKTUEDLo + EiPoUNYI+DKw6wLLpxLhkIgoIpU240Jk/zCC7P0ABiRCRBH0MRFF+BSmG2BhYL+QhZYpT69A2Mci1CBH + HyRUqwgY7ANGSdp++E0JIQBsYIeQ0a8YQBESKYJp4Yi1XkZ2BZz6Cgto+I908NQQN1CnD0QQWQ0EjrCS + 4ofs+kA/F5yVrskFSxMqmQgjWPAQNpBjBFRLV5OGiAYKYkk/FnE1rH1Wq028a/+rjOXcBRpCBwIOQWDL + AIMQrUBBFflDEc67OaxFYK5oLUD2whAA8v6jwoq4gRiA106nlqE8DwRDW/sLY0U01mghSNqsiIEDMNTF + AGCzpCAWvAhHGjByxgjqLkIr3nkugng64GYEPFkMN+kpGF1YqyyB+5JFzKGzG1iAlHmRQGCgoLo/EIDl + GGHhQ2CAfkcDHTDW3IsWuHYJLfCqItZBPBtID3j7VNSXixFM5CVJEwY1cQWO66VBtJkYXfMtJyiA2nWa + YAFr2wWff3EFf5JuzoMm3iDOZmIxcHlIo+bFh1w7A/5KDBIU0LILZKpQDYAwAC+7tSMoEFej8UEHtlh0 + MyD/EEMkbNQQqi4EEWLwhs7yktIqigYCrBDesKD6yo+gwKGn94dYK20IKxDOAwvwbb1K4gYNXmEUbjCF + S6vC3MTYdoiyYGtOzEF8CzjCDW5whigcAbK//EI8A7BjT5xBBKq9wRPOQO8p1PuXZTBAxx5ggHZzQgdO + oPcNbDAFJzhBCVFQgr2XaAZut4y5wq4zI47whHlPgd4qN/jBy+0JfDejBaa23RgmHAo+pfwJN3ACEY6w + dCUcXNk+DwgOUtDtH9Ag2J/wsskN/qWm80lPX2pU1LuxbXXL8LqmCMIRlKDyI7jp6wn0MpvG3o0W8SjJ + pfiS29sUdm3+gU+FoLs2DvBebRl6nBRRgpKX98TzQSgBXEMVLy2kLPhsICAATRvtaj8RTLRvHhQA/bzo + R0/60pv+9KhPvepljvpoq74TLnH9690d4tnb/va4z73ud8/73vv+98APvvCHT/ziG//4yE++8pfP/OY7 + //nQj74iAgEAIfkECQMAfwAsAAAAALYAtgAAB/+Af4KDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2e + n6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna + 269aBdzWeAU/D1Dg0yMwP+sseOfPZgYP6+tI35o1CSoMaRcEf1KkgBgopIiQP0CEAHnnCUuAefTWjblU + Q4UfADzIDNg4gAdAKTUEGhmpcOEgkwwrTdAypknEH0gMTBKSweIFHjskcNxp4U9IEDWKFDEiRSHClJrq + wHn5Q8CXSXs4AHCzsyrHHT4HSjFSEASQr0YPIqUEAeI6Jg9SoJDUAEASq3D/OdaYW4OkELFAjCw0enRs + IzMpmLI4sPaRDAI9JLyNOyDJDgtoLrRhwJcRSr+MrhRwSQ/JmC7uHFUhwEMnYwk8LjBYswfzKBpm11nB + 4ghIBgY8GO9IvXqPEdejUARgWqBwow9e4jreEqfKZeChEAyP+ECm6BKMvRDwAB3VZnpoIUxoJOXODrhJ + ADSo0f1UmcAvDRhX1ACN6Z07AHzIQG1ILwMvNbFCIx4QQFVVEpTAgBTtpVLHCdRB0EgCF8DlBgFBNJiK + FrExUQAOjLCBBlwAsIeNf3+gaAseY0S0xD2LqHBeVWQ0cM4QKs6CAg0RMSGAGYxwsNhOF8jwnIalrPAS + /wxPLULAfRvtkEZrN96CBYT0nEDbImnMyJEFDKSkYo6uTMDCSyuU4SSUA3ihgms4xmIAE/QsQQMjcUCZ + BBoJ8JLhKSjG6QoWSEQExhWKAMGAlxttwR1mgZKZCh4CgPeAFol+oNFOAIAAXI6SnrICnfTAiIgKFlRV + QhFItoLADBHBMV4iCYy4Ew+PChMEEYL8CU0BpK5ThyI1VLiTF30W46uvzXzB2Q9MBLAIAzSu0aorAQQb + hgaKyKAnB8oEsSwzWPSYwiK2bpTEHcyMu4wVwWaBgCJpDDnAFr8pokAOv2Qo7h//IkPCEhFJmIgKm27k + RrKJKBBBBXMA82/AxgzBI/89MwCJSA0A7JQEuIo4EMHIb6jR766UHPnKFWYxYR0iHNyXxAWLLLDByBH4 + UEEwzEKisisAZqnxIXv0cGwVinQgBs4kX8tJGVlEdC4iRfjh8T+J6CCCDzj7wIfTnNQRERKIIpJAqhx5 + sYgeLjAdwhlgazKEFRFZEaogVu9kYyId3IyzCSbHnYkGZi0x7MYJD4AGg4jQYQLTVDighOCZQADeDPMV + Qq3eiRyhB9MR9HED5ZgMcSY9Ux8CQnIclZCrITlUwLQJOpCOCQKF0tPkIR8wysHPf4jAtAsx2I7JARHN + oEjHHPFA5SEdMO3DC8ZfUsZ065haCBusN5aGIsLjvAH/vykBL8oVWMLURSJx7OQG0oio0TbOepTfyggE + r5NF5oPsYexGAFAEF5hWAV5VzxLwkU0ivMWRJISpcX4bWf0OaIkW0cNghhDCB3ZCBhMdwmEj88EG6EDB + SiAgfU0wxyGA8L97KWJpOKPeWL6iii48CwzzQkTiPvAzNYAucEihYSosRw+7IaIKXkqCDBKBAaaJoYSW + uNg6UmeIJ7WOYYWYwuPoB0VKsIhUYThAIpi3kTt46hA64NrIXEC+GariVWcpByI8sIUGxiERIsNZBZzQ + HfNxQgPBOgH/BMEGo22kRomQA9NE0EVKkCAiWUhEA4bkBf4gAoYjc0AfxUKKFkRk/yKI2CBHepAIJ8wv + Z7XroykMkL8fFEBNhihC+zgSQETkgGkbMCBmhGgKKf4Ag4UwQh4ayC5EzGF2DfLjJnw5IESUYEiUQUQT + Q8jI9tyFFCiA1zqaIEZEdG8AezuEIrnYHl6GwnSdwZQ3d/ImRPCBaZps5CTAEBESzNGQA5BAOA3xBqYV + T56RQMHpfhAGdRpCBrlR2D4JoYQtjqwDAI0EAui5jhPY8xBrwKcF2mkIJ2DSBxSIKCSGkL4lcAujaBuA + BeBniCd8NKQidcQE1LGOJVzUEFVI2MIQ4VKmwTSmjEAATdGiQkMkwEs7wCIhnuDQCPwTqIuYAKzW8YCT + GqIGSf98XiGO0NQFQJURZbAgtNaHCEYplRAhYFrEvqqIL1J1BIlI6QCshYjwjUwBbF1EpWragkTgE5yJ + eAHTuJBXRdAgWMAsREI3ArIPMu0NhUXEEIB1FioW4gMcaIAMPHiIGOBycpE1xJxKxQgQ6CURNjilD+wQ + WkPUASJMGENoDAEEEGwFBKxKhOxwFs/WDqIOrRxDDg/RldMmYms4k4NvCYEDs5xgtsT1yiIcoMYIvIGE + y/0DAuBAKibAFRF5kQIQcosICkSwAj/1LQosiJa+gvcuRTgjInTgUBf0drkpyJ0r74YQoRQBeFMYYHKz + KwgItNIKQzuEEXBrvjyOjAqpXC7/oegBg1mt8L+MsAEVmDbB5SJgoD8g64UT4kfB/i3CrUWAWGOyiIUk + RBEU2DDO8JpdA4ThLNJK1B+Eoogg2NUHIjhCdkeQPnkpoiBfaTAuvbpcDUx1HS3gr3iTrAgd9PNvrF1u + tko1yEJUBhEKqK4P9DCF5R5AvyyozSLowIfqmiDLrSUBTdfxXfAixJyHWICMI+ACLsCttTjY6zpowN+T + +FEH45zxE3zbghuvAwYkKPQfSqIIIsQgghEwAZNDu116NMG9lmGEA/YMZBu0VhyOboqFL6EEAY9sAy8Y + XWgPkD4miDgRNPRjDN5Q3QhgIAqhNQOIA9BlQzdiCqOGHI0j/6uks8ygzqXTA6b7HOw5N6EA0KVtXzLs + 6pGJoGdQHQIE0FxUHTdCBy/wGx+IcAMlgLsW7y7GELDA3W2moNDKLIQShMeHKUzhBjd4QrxlMXBiTKAA + ZpnB7jRBAREoAeAAf0IUCg4LIlAMGVCI2lnu9ImA38AG/o6CkGfBrIsnowCpRoJBOXGEJ0zBBk9wghOU + cASKn8Jf0dBA+n7AgmKfRBJEIILLb+CEIxxBCbpkhbugQUR6NLMR+R5EEI4e8CMQgeZJV8XSn4EDEP9g + FFGQuNGJYHSbh8Lk0NACPcZQblAcIQpRsPjVrY4KszfDYkhIrCimXnayWzxgdo/EnwLPDHwEDPcUZPeX + 3P2FdkwQvoTiYrwBI994Ak9iWRRDWa8g8fjCXtzkZu98dnG+ect/YllZN73qV8/61rv+9bCPvexnT/va + CyLqts+97odhEtzvftu+/73wh0/84hv/+MhPvvKXz/zmO//50I++9KdP/epb//rYz772t899VwQCACH5 + BAkDAH8ALAAAAAC2ALYAAAf/gH+Cg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp+goaKjpKWmp6ip + qqusra6vsLGys7S1tre4ubq7vL2+v8DBwsPExcbHyMnKy8zNzsd4z9KUUAIH09iOIwI/PzBl2eGGZSNW + 3d1LXeLreFo0J0jn3Szr4TgrLE3y5yf12FhW4u37Aeeav2cIUgzsNqbFwWdlunAbyAKCmYfPDsDYF+YE + DSwoMlXhkOZCCR5udkhIkuZPDSlGjBQBQhMjqC8BmAwsiMNSFT8AvKhMQnSA0aMtpbwEASKmECBChNjc + BGXMwCYGQk7awwBAyqJHw4Zt49KIFJgxZwKZqmkEmH1N/wRo2eqnBBkJYvPmJVvDLIgiQpqurflnLdtI + eAwspEFiSKQPAO7qnSyW71LAgGlGLWz48CMDD3Sey7IikhQCPHZQDruDB4A2DBqwSbCnRiGahP8UKcLZ + syMzBQaOgQLJwx0veCkn4ZGHg4zaUkA8pVQzt29DBfTJG4PlUY02XpJQJnOBA+0ana+PMhNg34MCkOLw + EK93x4UPCTykV1+qQJh9BfTUiApbqKYXDww8x58qeNDgHgSOSNGGG5MBgJ9UC6pigHbnGDDBgCXQJxYA + DWSQISsryMPEAxA24geFeZXwgYknrjLCCUvI4yEjGVyQXFhuMJBAjaxocII8SKQwIP8ael1QBZGsIDCG + aN0EoJUiH1iQlxcceAAlK8HJIwA4izBARl4APPnlKinKMwMJjBBwZlgSEEDjmql8kYU8TRCnSBEEGHiU + GxyAgKcqZbBAZRMtJgLoj0bxsMahqygmTwCOKRKoWCWomWGmrnwR2jkwRKMIA4IatYUMlCJq1TlN1LHI + B3MetcWQRIKKokDdwKcIG1qGdWsjHWDwRxCEIJtNprqigsIM8sBw5SEJMBlWCawygkEEG1DAVrOmKHQO + Ew4l4sEFYvXgaSJqiBDBuyY4YYuyooBrChZHdsOEFYoIEYeIA7gx6SJzmPDuuz68gJG9pbR3zgNfKKIC + jEbtwMH/IlM4IIYPB8Pb6iUkAKjIHiWElQRZBIvR8bt9HDYEw5/kxA8CiYBAwIheKuLABitX4MC3g8DM + CQkPjGuAxLUOYMG6hhzhwMoRvNEBL0HQ68nLf2BNCg1UnnARIh4AQCcDiyxQQcc+8NGBEr0QgazVVwud + yRVF63t0IhyImAQAi6ihcscheOsLvXB3IjcmlnbzwNfU8hDW0oroYDDgdAhTeDA4vHWOr4cYEYfJBCzy + AscH83HGMJcDc8B/3ZzQHSIJBBtpzogoQPq7FQhu+SBVCzNRN/wiAsLnR0lwcSI5UNHxBjEcoywRkOy3 + Cgn5/oBEudTKngQaijwRQscu/Oz8/9vQOyK9hjl2AwPjhRjBAWsfKKLAynLcgEzVqedSxqvdKIlIBtYa + wPYUYQflHcwEUVCG24JBtIfNBRENoNPxEMGFlS3gY51oUzfg8KFD1ABdR+mBoRBBARd0TAQY5EQZzLG5 + RMigVixRhLsO5oIcpHATOBjVDx6gjkMI4X1HIcOdDKGGlRnrhprogjxOYCpDhO0oSdiCIip4sA3YAIma + KED6fhCARCTgR8ZLhA1MeLCWYRETE+DfDwxiCCF8ICxkoJ0h5ldFNZwRExrYk+L8ZIgPQlGKiFDC5N4l + hztiogusI8i0CLEH2UmAbIjoABkj4IKp8ed8o9DgD4J3CBmwBv9Xh+hDx0zAtkuqQmbduJshigBEo3hB + EWc72BENWQkc/O4HPewjCAV4ATHezgd2pGUlzJCvFT3QiY4zShLikIinHawCRzgRJkGhgbr9YAYdNMQe + wJgtQwSBiu/igjQHY4oWbBEOTSyEJ4+yAwwZ4gmD9IH4hEmJFVCJBtkkBBDeeJRXImKMB/OBDuhZicT9 + gHOFAFRY+IaIIlaxRtMEBdfOUZpDSCEPULxDM29nAogOIqKbcNgPwsDGQtRAbMpkJiK2dTA5lI+gkRjC + lNCRy0KAIJkCjB8iZvguBXwJpJpIFKxqSggjaE8FiXhDxy4oTUFAhRR4gMPD4NQ5GHbTECb/uN0cIGoY + oGLCDJqz3usMAYIfJUGOhLjBIF3A1KaaAgUb6cYMNIAIIADMNoegQyy5pTuIujMUGoDWOeiKCICN8BAG + fJcdfsqbUZRBj9ek6iHEkggl/C0CPrAklLx6CQ1I9Rw0QwQALjDaXiJCcjRsK0whgYfqneCYlLjBXiu5 + WknYcqo1U0pTFPG9g6m2to2AqzyIqs+m7BYRROCpD3wKXEj8rgnYOwQQZBJROXRMD819RBlQGat+SaEw + itBDx8SZ3UZMIABbVKUhgFAEIwjBCIqYA88wa4LKlZcRiQtDARimmfYqYgGjtO99EzGEAwiECTRYRFqm + qYTZ9nXAhziA/zXpkYjpPmWadODDdfMH4ZDxI2KIAAx4EzEFcPqAvBBGRBnies2xrvcpfz3EAuYbgQpc + McWHQAALf5COfhVmOpGc7TxxTIghBCCR6l0vVIB8iBsoFWF9iCaRCwEBeVghn+1TS0QdMMk33HjKg8AC + h1hA2M6thcmHiEFiXbBVMA9CAyyegYvrGtEn8DQCIRAwmHVMpZKu16mLcCbufjvlMFVJEV2NqCADygU9 + T3kE8sjCFRiBZkMQwXbPfDCRJyDYJUCXEbhJBBEokFWEcUHKbnZQN5qQAizXVRFB6MMkXdA8N0/gAByy + QpktQYG9RqC+bv4DFML6WqFVZxEsPRh23f/MZ7uRic6NQG3HOFzeDZ0DDousRAxIJ4YFTCHYDUTHCBA9 + 4kUooYJ9eMIfbpBAN+94k43wqhOad4Yb2LuUUzYnrED8akjY+wn2jgKqcYyCsP4gwZs4whOeYIMnTCEK + +MZxlfnRCYif4QlOcIISqF1bFBQNDBXtxBGcMIUbaFwJL02xAWQFiiAQQQlnmMLLNx5s80kiCFOQ+RGU + cASO1/yjkDgCxI9AhJ37/OeSIILAg7BzoiPdE0Un+hGm/nRPML1qRHDb0avuiN7hr3eu2PrHerfAY6X8 + FGAHbtrTPgqr4a+5axf7JAgnCLbft+xy73rd8y5MsPM9EXQ/lpsL9/dcZLkd6YUvROJTzHSuh+Lsjo+8 + 5CdP+cpb/vKYz3w2OKv5znveGNb5PNClK/pIdIbzpQd06lfP+ta7/vWwj73sZ0/72tv+9rjPve53z/ve + +/73wA++8IdP/OIvIhAAIfkECQMAfwAsAAAAALYAtgAAB/+Af4KDhIWGh4iJiouMjY6PkJGSk5SVlpeY + mZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxse6JAYFyM2eE1opYD8/ + Tc7XlyhYEAIP1N9a2OKRyiwPYd/fKePsi1A0WenyPyft9oQIdVbz6UtjBlfu3ftCYwYSfg+sQEAg0N6E + d/x+PIBRoIuZIQ3trYCzhN+MFFpwZGyHp86YjvKQsFghcqQ9CDP4rWzpctyQLiz4nUjxBSOnPTLYrKmS + YE9NVgdgMJH3oABDSzUyZJDxIQ2AEmiw9rBAZocECWTIqABipAgQIEdB4aDBD84BmpL/EjSIc6fEjgFJ + 8g7Yy7fvXhVGpNQAIaWIELRpMw2BMubgNyYPDPiUlMEPADRk/GrevFdGDSmgQRgZfVaIkMSVusSUx6IF + nkg1ajBA4+Yu59t+PXw2UmP06MOIUUcassLx4wBPHyVQcUEvbr9gLVhwQyYJXyGfQwspIuXwn+DBhSfC + Y+BEOiYzVrx+VGX28wFed/C4QICD/Q8NiO6psSeBjD9FjBagaWaVhlZ44iGSwjwzjACJDGnw8JwFJQAQ + RxV/CCbFJGcJIoQRHiaYCApsyWOFGY/UECFuFuThhwqgIOadiIXgUIBxPyARgAaPMNCDdZtJcMEHbGyI + CoLiFbBU/zo0TKaIETJsIcFmO1hAQAYe0NhKGQWkZIAjexCwA5B97YAGB1q+MoEBTaQTGQqNsIFGkCWg + meYrByxJDRPrMCKbbX5tEQeSd6bSBY4/fMlIAnlsRoYfCRT6CgnTfINEAXAuokIJm13AhqSv4DCGnj9Y + UQYjH3jhVxI7fJAlqK50+RgL6ynCQGZ9SVDCHqfB2soKpIJBwiJA+AHoXmS04euk5n3zQBeMiOmXBQxE + YsMfQSyrCR6jpgNBtFP2xQOMj8QgQgQdaKsJBOcFsIgRBITLVwmfNjLFAnxEoK8I2A6SrbqRaNCEnjDw + mEgRxvoFwH+MPBGDHBv4oG8EPlwLMP8lKASQThMOKvIBrnwBEGkjCpjgwsQTv3AxJcUxuUgVIO8lciMd + hIAyyhs4sLIkV1RKTRYoJpKBqn2VMLIiZ+ixwc36mqDAFDtLoqSlBywCwLRHJ+IEF0uj7IPTdEQtCRbN + UhNArYcw4NcOGC7SgQlMb8BFB0+IHUkZAeh5AhSKsCHvABI0wIgaJkiMcgUO3GC3JFp4sycziezBKV8S + tNErIkTM0fXEG7zgxOKS4K3nDAYfIgUBfSWxBaGELFDBzT7ocQaNTobS+Ddh9ImICjH30HYic5yMsgnp + aln7JxPISg0YyRmyx9V87RCH268PT0Ew/xaDgOM/LKEoInH8ncf/IjlQ4XUIdgiTvSfHf2LA6AEhInlf + XqyhiA5v3GxC+uqP0v4mKFhN92igiDaQKQnVUgQX9KcDX/0vEwc4T/wOUQMLFC0DilCA4fS1geIV6oGb + EEA6zpYIAhxQcImgQPX05YIYwGoIIMTEF8rWhBYoImYlWITNJha79REjCD7sxQrSwQK4ECIIauNLEuyX + CAXcjA9BJAYRRBFDSuTkG5A7xB7mtJck8EAROVhhBCrQQGf8K4qW8EkVI0G2dAxrd2TagZ0QscCJuUBn + 7EDjJGD4Bz5yAgIo+cEY0EYIDzSKLz2oQSLUsMEI8GEceqzEZNb4iCGIkBq5S4QKiIYXZSVC/w44UwMk + JcE6RFCyERp4gJ74hgg/0I+Jh8iB8PSFgUj+0F+7aIFxmIeIIkBvLxcwkiGI8AKcWQyS2QKiLpS3hCYh + Yg2cRGAibLC5CGDAHkGY4h+0eQtRfaMJVUOEtPZigXodwgEoc8Ex8ygIW7oCAW3C5BcS8csBXMAoh3gC + 3CbGr3sQwZ2vqAP3xtA8QhQhZhy4XCHU4DUPgg4T7PqGFRIhAzINAJ+H6MPhHqqJIZToB0z4niGSuBcv + KEKMteQoJsoAh3R0zBA1OCReLrBI87FQlCq9BAIEmAVWGiIDXAQcAZq4QRPMLqeW6IIqqTGDUx0CZnwh + AwoNEQVQTowLAP9FTSk70QU9FRERDZCXF7JWiBXeEVZb9YQBjOPMtBVNkbHcnA/KiNRKMFN3hmhDX2iK + iAVsUAzrrGskUDC1akDgfxfoSxqIOrEQCFaSY0hHHRKxhb5MDxHFvOqy0sqJyO5psoiwIF+maohzTUwB + vupQKRDg2R/0lLJkCNfvDLHDCLhgDo+lBAJOoKcJIoIsewDRIc6wT305NLePKEM8qPEALCQCNINRaCGC + sEIqHPdOnN3EFa74Axg497dSEA0IEpEDMfCQrqklBQkEeAIjEgIIHwJBKZ2wOesiVxIo4F4YfGsIIYxX + EXYo7gYCKynVigIPPpuBT/sLAvlKlxDUtOP/9UAVnAd74gvcBcM8fwvfsiTiCObloAvRegoE+KwJBS3E + dgyTiDPkj4MT3mwpfPaDcBwMBGZpceEmhsfUWrgTlnSWDX+b40WYlmJ60JZpSLEWISdiO/DdKgZQhoHP + 3fcReKBBIA/g1EOcxsCHUBo/rxyJAqCDGiI1BFqgDLzDQY3MjogoSN315AKV0gaz7CCcHdEFInbZEFI4 + C5gN8eIIbAC1e2ZEKr8Bgw0rYkb5zCzF+qC4RCtCAyxYEgxsTKwMbi4ER7U0Iq6wD5A+4KWHONBWY2BT + Q+NU1IfIcjpWMAFGbJUOxY0AomF9iBTE8wcFqLUioqwISUfABLxGRAt+/82CP3NYERS4WYyTPYhFUwPF + mcj1I6ldiJZ+Y8iXcKK++NCBrJJZeT8g4LAPpIgbUAEDOfjDEaLAbUKMIB1ZcLYlbsDvG5j7vigIJBNK + l2pHBIHfT7jBGaxc7z+0FAYpWHAisquEhNNhClH4N3KhkOJOL4IISrgBHZyAcY03PLvtnMITnEBykzf8 + EUFQQhRu4AQlKOHloQjCEW4wBSJE4Qg4BwURnBAFIhxBCS4POiOO4IQjGB3oSm8EygVhcyKAHOpRtzXK + nW50JWA965nQeTaP8HWwY+Kf8v5n0s1uiGz9U+1s1wQQ0R53uZ+R7nWvhDK3ufa8t7Ode/f72QWfCXhu + 9t3vez884Re/CcUL3vGMgDzodM6JM+KS8Qa/fDYJb/LNA/7xh0i8vyyPeUREMfClT73qV8/61rv+HlN/ + vexnT/tUpDX2qcf96hGje9X3vvbAD77wh0/84hv/+MhPvvKXz/zmO//50I++9KdP/epb//rYz/7yAwEA + IfkEBQMAfwAsAAAAALYAtgAAB/+Af4KDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaan + qKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wGU4wMStZlgtKVYwPwXFz6V4JAc0Y1lIP9k/VtDdnjhYEAFw + D0va52De6phQBizn8OdhZev1jygkEFYnYfH+PydQ2Buo6Io7Jv+yPZghoMABKGYISjTUJUDCbE1Y0GhB + wsyQiSAF4agTIEu/eEiyCDDQ5Qq9kCGHkChwIiEcA1hg6hRZwBxKOAW0DNsJE4WBmvGYgCkABQ9RmBO6 + WHngD8wKp09hmoGAFN6YFQiy6tQwBqG8GSlIbKpRQ1CCNTL/akhJUKVKAiFiU63oei5ATkse5DYgQODO + Fgs9eHjZkWSHFx48EpcAkOaDjLyhENB4YFYbjBGU8P754OeOFwlkkgxYzbq1a9WsPUgxIhozpiFQrHRW + aODKx0g12HwA4IWM6+PIkZP5I0VKDSMggNiuNGTEDHhhWLTACmkPgQs7kosfv7rEnxog5M4uIkT6dEgH + TmoLE+BKpLeHYZOHnYSMhfCoWUCGBK7lcZ4RzhVhhBFFAAFEe+8xYgBKENznRwkD6HccbF4AsEUeDDTw + wQcq7FFDFSo00ECKHKQBQA8cnNccCOyBYISD7kWYSAFNnMPEDFA8YkQNbaBBngWTcSAD/xseCJIjIk8K + IsSCDE7Z4B85RhkhCjzCYwUWvzGSgB8WEIjcDhJcEOInDuLVpnRavodDAfAgEYAGj3DQg3hebMFADU2W + AsSNf9SmIx50ntMEDQI1sgYAfBKggiuGRpgCPEw404h3FpzJQwMJxOJenE9BEE8KjRShQgkarpYEAAzo + WEsL2GjDhAEvKSKFH8YdhwYHbck6ywh8/WBAo4p4cEGrA5DhRwbC0kICM7YyKiYPGwKQQBHRzoKAFT5a + gSwiUqjQa2te+HGJE91ygqiPLISlSA0MmMlaEltMKgkdMeghwgYO/BFEu5msIN8PYKiliBEE2LvaDm2E + Cokdc7xggv8LEWTMhcAEXwIFXw/UwUga4bVmAQdSQKKDAnxQgXHGGZvAcceU4CAAPAaM3CoPbDwSxQIi + +ADz0Bm7wO4gA9P8iKm2BsDdISDE4fAAJUjMiBMxcEGF0EQTrYPSk5DAFxhfLMxBya5W7cgNL3DddQRU + 8KFHDFOAPQm42jTRwiIMnJvhFlYrQocCFbwdwQZ8KKBGFHZTckCtPyxRwASKqOBFa69CuwgRFPz7dgVc + LKBD0o1LgsB1ntmXSAaXt7bFZYw4sMHnCthQuiVlJJoNEgcsAim6ezBigwhd+yCGHjkQcbslWvAVgCIg + MOAaGT0v0kEIbsMsQgfLX4ICDec8gGf/Ig34TUaM1pvQdQULdI8JCfCkEKYhGfzuahuMxDD70C5wkbz7 + l8BbNk4wPkTkwWEX0Fwi5rA/mG0AA0cDYCWaZysDzK8QMkDbACxQhUUsgApE20AMJIgJ3f0ABqo7hAfs + l6EPkEoQCyjc0CqgBhJeQmx5yxkihMABzAGgUoXIgRiI9gbu2bASEzBAZ2aQQkNUAUOs4UEHFaE+mPnA + BDU8YiUQkAVbaQoRbdCPBAiwCC4MzQcVyIEWLdGC8BXQEHtwg+sCZwgHvCxjVKDAGi1xs2wwIQC5MgQB + NKQvRKgBhDBzQfv2SAkcZiMMXVhdp1yFBkXcgA9EUwDjGDmJFNSK/wljaGIhpMeaHXxAEQ4gmgg2yclI + oKCP2UAVIvbAQgAE6xA2aCDcviYR0u2iC1TJRha0kAgOnCsJsUqEGYcWsIn4khMXvEQZmPYDJsBAEQDQ + Dw9gd4gO6JIPraQEHsZwDh0eQgoO8wO3DqEEOZwxi8sbQjQvgYNgZkNhh/hAa3YQPERQ4I4RwAArwwmJ + FQSTCXB4IyGU5TpFLDNjNLThPClBA580I5CEWMOeViMBdSFCBxvgmg/6EEGQPDMTH5moJMwgwCasIBEM + QJsX1oCIIGDAbVSAZ0iIcFJLyJMTWOhKFvBpiGyyJoEffcPQNraTIAysp4d4ISi60BkYYHQQHv9oXYaS + 2c0zGvEpUH3FEJToxwBMVAX6IQM3DdE2mJngDGAVRFgj8VOVQsIKPmHCCibqh9aU4JaGqGLG9JCVuU7i + p5qAg60iiQgWGggRMUBkBCowQqIY9rCCQGwlvqDYAQYJERtdDfoOoYChmeCyveyEZilBLG2MISKHKIKG + 1kqIKbgTZi8Qi1MFhlpI2LURdbCoAFaHuUQcQYYZW2RWlPcH5sqiDAdo2sJUEIc8ACAROZDsBvSoW0E4 + NxZluFQ2lmDBHUoBiHW8YwhukBfm9vYUFtFGC1Q6o+gkorQZ84EICGqJsmgDNFCako1INYU+WLEP/KXE + BGC5BJElAgg0emH/FDAJs2Y2TqqauAIsZwDgQwgBBCDAEhWHVlmwYXgTXyBnNsDwl6gCoQgwToQTlJqx + DcwhwZO4AuoAIq8dWikRFBBsBb6K40fgoUfjpVwioMOeRBzSgbYrsm/t2YQeG0IIDXJQIm4AUPaa+MSa + MAO1AELUQrBHy4mIgna5e2FSaOAdK/7sDgulCDsIVgwllnIjSKDiE8rZEFqGkCFpPNk8dwzMmvgCnH/U + Yg8L4dHYJfQGiHzoUyAAzj94QKMLQaP2vPAGJnCboZWGaEtMgAWd+TOgCyXVEDBTz5AYg0W78Fs0I+Kh + ATWxk0ptifhmo3cPdpIi8Jux/ZJ616UoQGfM//lgqcZgaFSwG68xsQLpMkKqdIB26aZdiS6cgwXXRi8h + RICBOXztu4cWtyc0cI5rNuLETrjBDQZ66HWSogwG4MjTLHEEefsb1q54whTOIG90AzwTtk7zFGzwBCcc + 4eCrCMIUbiBwekMcEycmQhScMAWOv/fimgjCE27gBCU8HOSaALMTnhAFjaMc449QgsM1bvCXg4IIDj+C + zm1uCiUogQhEUMLHeU6JIBwhCEE/OdElUWqdE8HpSxcF0Jsr9KhTAsxP5anVReFUpA9965BwKk+/DnZH + 7HZmZe9E0pCedrXLlextV8RTzx53TrC97p2oOd4rQfe9Y4J0cPd7IQIv+HVEEL7wiN+E1hPPd8Y7/vGQ + 79bhI7+ItRNi8kTv6Ukxn/m3G+LsnE/72kcferCXnvKoxzu3U8/61rv+9bpYPewHIXvEJ3z2hMgS7qO6 + +977/vfAD77wh0/84hv/+MhPvvKXz/zmO//50I++9KdP/epb//ogDwQAOw== + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAL + DAAACwwBP0AiyAAABP1JREFUWEe9V2lQVWUYBrOm6Uc15dSv/vVXG5gxLpALyz2XRQ6LCzdBQQFRUQy4 + BkIkFyhkSUgIBRcIhFhljUUERyt2LotCg2zZjE5T04+mKaMB3t73k3M899x7pgsM/njmcp7znu95vvd7 + zvcdrFxdd1rLsOF5cnID6yakxEkNrKuQEicYMFtsz+16RcV5bdrGub0gcJL7Yt1aODJgdMNR7b7RTuN9 + FDHs5n9w0S8oDLZ77f0DryvsOH6ztBaxZkNGGcDZvooinSfjEuH7nl6Ym5tjeDA1BaWV1eC278A8Ggle + rl+zOEE04OLqZI3i9SlZOUzUMDIKeZeLIC07F6rrG2F2dhYGDcPgqQ1ewDpn4TkJVmVINGCn4bm9h4/B + zMwMNLfdBGcf7SRyQQhXnPUXR6JiF6gTdc0tgNejzmoX6UCrEieIIcRZFV28VgJTKOKhDfpNpeHflhai + qC47v5B1Z9f+Q2hCzMOqxYkTQ4gC/S3tHdB+q4tmeFlSxID5eC3waCQzcEwXD2hYi/yaxOlXsgTeo+2d + t6H+aYuzBH4ZrHh3cPgSGaCQogEhjCZ1K+FkBrrQQKvcgFhsZEBjYmDF4gQFA7xgwKhYMBAZ96ncgFkh + rHkHcQbHbkB0IAqxc+5OkgBbITmBWEAsxSWnQUxiMnWgG5Ekh3p3wFJm7kXwCzpCNYsIfI4vkIg+E+f4 + 6OAT0U9qGpphGF/p0bF78C1mLPoTPT3bgpl6neqsMO3wU50NPKx/Brq2hGvLV9Fgd8yIxyR8ls72DurY + 3R+6oeSbKugfHGLXRWUVoNJ4dzlyHhuZgX9vbxYxL/n7/7iBkq1yA9T2d7VhEfPTuJ+QGKG0sgbreE9H + T7/YCwVX/yYuITWdng01MiAXmrthC73F78Nft7aw6z87tsBMrS30INeUaw9pcU40yC8qN59Gd/+DhoDw + k78ePx2/RK0WxAl0jV1xJJM4c/82fNUHhwyAz/WLBuTinQUqcHDjSQC8/X0gUheJ65cEKZk5bIsur74B + NQ1NDLRVXy0tB8rHmZRzUNvYbGSgp2+ADPhTh3ao1Rtwe39MPB8Y8oQZMNfiqAg1EyeciE2E1KwvWUBD + P/oYQiJ1EHLqNJyKPwv6jPOQW3gNyqpqobWjE/oGBmF6etrIwOTkA1rzGGGp9OnnkWYG/jHJAIEM5SXt + YOJZeZfYLDvv3IWR0TEWrCmJwP3xCSMxJXjtP5RN4tgJW+zW0sTEj+Dg7jumGMLfW997agDbSgcUzcow + PIJnxTQERUSxdn/X3QPcngDIuJAPsfrPISpBD1V1jbgkTSYGsGt1GETNcV38QzpvCouv0/h6xRAarrOE + M+D7DGfPZQLn6wuB4RFw85IKwsM4do33hxC00dDJuQd/cxC9xeWVRga+ulIMZdW1bDJk3MXvw0e4F7yh + GMLyzA9EA7h+UJS2jXWl7+ut7D69GR1oBO/Ta2i0E6o4fhMlPDkjm21Cgon74+OQj0acfbWPcClsqFYx + hEk6Z7DHt0DAzw02JnVm9gEB9D35Mt6LRiP3cP0XvQ+E0prPIJeKM39TqFMMoSWcggGTc8FB7fESGZLx + rE4xhJZw5nZCyd8WcYohtISTGVixOIFOw8faAHdYDXz2eaABvkI+6DIs4qxU9M8Hfv8RcLC3BFjK4Yn2 + onxQhMWGxG9CGZ4bJ34RSbAuQkqc3MC6CZnndlr/B0YKVVX/co4kAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + wAAADsABataJCQAACgFJREFUWEetl2ls21UWxZkPZVr2sC8FCRiGsk1ZCykUugItFESL2MXyAbAQYugw + YkdoBmiAAsPWBbIvTdI4TpM2i5vF8Ronjh07jh1nceqEUAq0aSKWSoiqZ37PMZphEAxo5klXTuz/e+fe + c8+99/0P+bVrcnLy7NHRUYvP57PYqqsthYWFltzcXEt+Xp6lsqLC0tLcbOnv77dMTEyszGz539fU1FTW + SDKZHQmHczxu96jb5ZLP7Zbf6ZS/tVU+u10dzc3yOxzq4Deekcvl+ronFPKFQqHsoaGhQzNH/fYVj8Vm + DA8PV3d1dckNYCIU0lhHh8YBHCsvV/LttxV/+mnFX3xRg++/r2RFhUZ27NBgIKBOn08u9oTDYetoKnVF + 5shfv/B+JlQ3mohG+vq01+vVeF6eRl55RYNr1ijx6KPqf/BBxe6+W5HVqxS8+WZ13HCDPMuXq/vxxzWY + n6+xcFgBHOaMSRi8MnP0f19utzur3eGogkZ9wSG7ysqUWrtWqWeeUfKhh5S8/XYlb71VwytXagjggRUr + FL/xRvVef726lyyRd+FCORYvluuBBzRcV6eBSMSkZQ/n/rITU5OTv9u7d+8dnZ2dzlg0qr1QOfbBB0q9 + /LJSjzyinbfdptQtKzUKcArgkZtuUnLFcg0QdT8O9OFAZOlSBRctkv/aa+WYP18tPBf96CONDQ0J/Yx3 + +v0/7wQKnxUFuJfI9/j9GsnJ0Qh0j9x5J4CALl+hFKAjRJwEdAjQBKCxZcsUBThM9CHAu65ZoI5rrpHn + 6qvVdtVValq2VJGNG5Xs7zfp2BOPx3/qBCWWRQlV+zwefdbZqZ0ILPnnJzW8erV23nyTPoXOL559TjtX + rdIgoIllAC8FGKp7AA1Ce4CoA8YZ9BHgOeeVV6pt3jzZL79c9UuXKFZVpRCCDgaDk4ODgzMz0NMrkUhk + +4l6Z2+vxgoLNfzssxpctTpN8Thi29/SogO7dmkvdMZhoRfQMBa67jp1LbhWfiLuWLhIfYg0SeqGbTXy + kCr7ZZep8ZJLVDv3T6pHOwPt7XJisVjsrxno6UXec7xEv7utTQPPP6/EffdpEIpH77lH31LvOnBAZh38 + 6it9kZurEJEHAO1csEC++dny8hn92981YFJI1UT4jFdWagepqb3wQtkuuEAV518gL2IO46DT6YyS8tPT + 4Pv27Tu7tbV1dAjFD7/1luIPP6z4cvILyCh0fjc4mAZPr4MHdeCbb7QrN0+di1A6FLsRW+8bbyjB/l4Y + 7O7uVhAdxShB2y23qPLcc1Vx7hyVn3OOtsFCHww00y/a29uz0w7QbCwOIh/lhyiii6D2viWLFVu8KC2u + 0Zde0nfj42Af1Pfff69v9+/X1GefKblhg1ykIPL664oDGqbcutAPPURRPotg8b1TT1XRCSeoGCs6/niV + zJmjID2i2b5DgUBgS9oB08NNe00iku5771UPAosgqjCiCkKzEdfwCy9o/+7daXAY0+eff65PKa0Bq1W9 + UBrAAS/Nyg9wmFQW3X+/3jr2WH18+OEqxAoyln/ccWp98km5HW1qaWmJpB0ww6QbB/qpeT8NJnDdQoAX + KEAZ+bOz5aOU3FfMU5RGtJtS2oUjyWRSlJN6oNyIlyajDigPwWIeNK87+mjlH3aYSgAtxoow40jhUUep + DoaDtOnq6uppB9a9+aYlyMYgAD6E12nEhbA6sq+ShxybPDsuvVQ7yKOPTphg6PTFYqac0uB0uWlwPgvu + uktvZ2UpD/CyjJUC/IMjxUccKRva6XO5Vb65fNqB11591RJgwLipdTfC8xG1lxp2XXG52qnh1rlz1XDa + abIdcYSqyWXna2vTIjOgBhwBp3PvWL9e75DnQkDLf8Y2c0YNzPazr7S0ZNqBnLVrLQEOcaP4NsrJScQG + uO3Sy2RHuXVEVM1m24knykP+AtDNoDKlZPKopqYmNTY2ysnfLli0IrwtPF+VMWvGzBlVsFCHphIer0qK + i6cdWP/hh5YAh3UyVu2UVKuJGsobzzpLNeTSyibbySfLRYUESJU3A25E5+QeUN/QoO319WrEER9OeJ56 + SrWzZ8s2a5ZqsK1YXca2wkAjJR5nb1lp2bQD5nbjh5LQe+9pm2mddK6Gc/4gG4IxkVhPOkkOhlEX6jbg + TMo0eIDSraFjbi8tVQNO7KC2nbDTS7sNPPectrNvO6ANM2eqEWvC6gnIRWfthPHy8owGaBwWc3nopXPZ + cKD2rDNlPfJIVQC+BdpbDTgHewB1AG4+Tcry77hD63Cyml7RVFySBjeXlziV8unoqKJ01FaYawW4zRjO + NKGlKEOuobb2X1VATa9sbm7+OkF0NgZN2TFHpwVj1FuDQx02mzwIzjQrDyyYEvqIYWPUbgRXibPbqB4f + z/UPDGhsbEwT9IoJyrQDTblm/l5eHHBznvPq+UpYq7S5uEj2pqbpRmQWsyDSTUm1/GWN8qCphINN7Zbg + ccMTT8hBbt0Z8I8ptTePOSZd54Ylq8kte1oYUkOcsW9qSt8yM3qYqI2nz5b/sFnq5iwXe4IIPUIgxQy8 + 2tra6VZsFhfPHDOl4gAVzb1YuRycz6ZcRJM3mxK0WNTGPXAjTSSHyHP5zdR4JWbEtg1rJB0+GtknAPSs + W5cWopfnIpwR4bdWRJ3YtEm13B2tVmuUMp4eRmZ9+eWXcxgk4+k7HANpI6W0ic2b2LweijchqPXnn6/X + icJ8b5rKZsCrAK7FjNCaMSfPes87T/ZTTpGfZ2I0njjs+NFSD9GHqJaiggKR8h+PY7O4kMwzLbUPGusf + e0wfHJulD3HA2PqMbeRQ09NNZ/uBfhO9PSM0k+suvu/h936cGQA8RPPq4O6QoldsKSlRjc02Sf/48YXE + LIbMjPFPPmk094IUrbaGgfIPhsf7HGSc2ICZ4WIcMAI1JWrq/IfoXQac7w3lBnwI8CCR+5iYu+kRdQyu + Uhyge67JQP507ZuYmJlKpapMWQ7SbluYghug9F0O3GgcwNIOAG4cME3G1LeJ3sf/IZ6Lku9edOI94wwF + CSLFzXg7k7YQ6om8ihny0+j/fcFE1sjISFU7Yuqk7rs3b1YDKSmgO+aijXwiK8WRKqwWZ+wAt/HpAdwP + 3c4zz5SbqGPcfnpNvRcXp/Nut9uriD4rA/PLa8+ePTOp50ajiRY6XJgeEUVA/nfeUQ0NqJKJacOh+osu + kv3iuWpieDUtXiIfQhvgyhbbulXNNLYCbsPlvFfQwBrpIb8c+X8ubsozuLfNo1NaaRqqNYfScrtgpc/l + VByG+pmiibZWxfku0uaQi2eqyXMudwtT6wypcablPPrMjMyxv33BxKG8L2Tznuerr6+PlJWWRoqLi8eY + ZirgesWFRgVQbMyA8qb8tXmOd4AcWvOczDH/38V97o9QakFUFgZR2qhti/mOO+FveD0/5JB/AqSYcROn + EfgIAAAAAElFTkSuQmCC + + + + + AAABAAYAICAQAAEABADoAgAAZgAAABAQEAABAAQAKAEAAE4DAAAgIAAAAQAIAKgIAAB2BAAAEBAAAAEA + CABoBQAAHg0AACAgAAABACAAqBAAAIYSAAAQEAAAAQAgAGgEAAAuIwAAKAAAACAAAABAAAAAAQAEAAAA + AAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAIAAAACAgACAAAAAgACAAICAAACAgIAAwMDAAAAA + /wAA/wAAAP//AP8AAAD/AP8A//8AAP///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACP/////////////////wAAj///////////////// + 8AAP//////+P/4/4/4/4//AACP93Bzh3dw93dz93dw/wAAj/f/h/eI9/eIh4eI9/8AAP/3j4eH/4eH/4 + f3+IePAACP94iH94iH9/iH94+H/wAAj/eHd/eHd/d3d/eHd/8AAP//+P//+P//////+P//AACP//j4j4 + ////iIiI///wAAj////4///////////48AAP///3d3T////3d1L///AACP//94+D//+P94j3///wAAj/ + //f4h/////f4h4/48AAP///3j4f/j//3j4f///AACP//93d3////93d3///wAAj///////////////// + 8AAP////+IiIiIiIiP//+PAACP////////////////+AAAj///////d3V/////iIgAAP///////3j4L/ + //eHiIAACP//////9/iH///4/4iAAAj///////ePh///+P+AAAAP///////3d3f///j4AAAACP////j/ + //////+IgAAAAAj/////////////iIAAAAAPiIiIiIiIj4iIiPAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + //////////////////+AAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AA + AAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAH4AAAD+AAAB/gAAAf4AA + Af//////KAAAABAAAAAgAAAAAQAEAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAIAAAACA + gACAAAAAgACAAICAAACAgIAAwMDAAAAA/wAA/wAAAP//AP8AAAD/AP8A//8AAP///wAAAAAAAAAAAHd3 + d3d3d3dwf/j//////3B///j4+P+PcH93f3d/d39wj3h4f3h/f4CId393f3d/cI/4//j/+P+Aj/iIiIiI + /4CP///4////gI///3d///iAj///f3/4iICPj/93f/j4gI//////+IgAiIiIiIiI8AAAAAAAAAAAAP// + AAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAwAAAAcAAP// + AAAoAAAAIAAAAEAAAAABAAgAAAAAAAAEAAAAAAAAAAAAAAABAAAAAQAAAAAAAFxcXABjY2MAaWlpAHZ2 + dgCAgIAAhYWFAImJiQCOjo4AkpKSAKmpqQCurq4AsrKyALi4uAC+vr4Aw8PDAMbGxgDJyckAzc3NANLS + 0gDV1dUA3t7eAOPj4wDk5OQA6urqAPX29gD3+PgA+fn5APv8/AD9/f0AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////AAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQbGxsb + GxsbGxsbGhoaGhoaGhoaGhoaGhoaGhoAAAAAFBsbGxsbGxsbGxsbGxsbGxoaGhoaGhoaGhoaGgAAAAAU + GxsbGxsbGxsbGxsbGxsbGxoaGhoaGhoaGhoaAAAAABQbGwQDAgEBGwQDAgEBGwQDAgEBGgQDAgEBGhoA + AAAAFBsbBRoYFQEbBRoYFQEbBRoYFQEaBRoYFQEaGgAAAAAUGxsFGBUUAhsFGBUUAhsFGBUUAhsFGBUU + AhoaAAAAABQbGwgVFBAEGwgVFBAEGwgVFBAEGwgVFBAEGhoAAAAAFBsbCQkJCAgbCQkJCAgaCQkJCAga + CQkJCAUbGgAAAAAUGxsbGxUbGxsbGxQbGxsbGxQbGhobGxQbGxoaAAAAABUbGxsbFBQUFRQUFRobGxsb + FBQUFBQUFBsbGhoAAAAAFBsbGxsbGxsUGxsbGxsbGxsbGxsUGxsbGxsbGgAAAAAUGxsbGxsFAwIBARsb + GxsbGxsEAwIBARsbGxsbAAAAABUbGxsbGwUaGBUBGxsbGxsbGwUaGBUBGxsbGxsAAAAAFBsbGxsbCBgV + FAIbGxsbGxsbCBgVFAIbGxsbGwAAAAAUGxsbGxsIFRQQBRsbGxsbGxsIFRQQBBsbGxsbAAAAABUbGxsb + GwkJCQgFGxsbGxsbGwkJCAgIGhsbGxsAAAAAFBsbGxsbGxsUGxsbGxsbGxsbGxsVGhsbGxsbGwAAAAAU + GxsbGxsbGxUUFRQVFBUUFRQVFBQbGxsbGxsbAAAAABUbGxsbGxsbGxsbGxsbFBsbGxsbGxsbGxsbGxQA + AAAAFBsbGxsbGxsbGxsbBQMCAgEbGxsbGxsbFRIODQAAAAAUGxsbGxsbGxsbGxsFGhgVARsbGxsbDQsK + CwsNAAAAABUbGxsbGxsbGxsbGwgYFRQCGxsbGxsSGhgVDQwAAAAAFBsbGxsbGxsbGxsbCBUUEAQbGxsb + GxIbGBIAAAAAAAAUGxsbGxsbGxsbGxsJCQkICBsbGxsbFBUSAAAAAAAAABUbGxsbGxsbGxsbGxsbGxsb + GxsbGxgQEgAAAAAAAAAAFBsbGxsbGxsbGxsbGxsbGxsbGxsbFQ0MAAAAAAAAAAAUFRQVFBUUFRQVFBUU + FRQVFBUUFRQSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////// + ////////gAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AA + AAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAB+AAAA/gAAAf4AAAH+AAAH//////ygA + AAAQAAAAIAAAAAEACAAAAAAAAAEAAAAAAAAAAAAAAAEAAAABAAAAAAAAZGRkAG5ubgB2dnYAenp6AIaG + hgCJiYkAkZGRAJ2dnQCsrKwAsrKyALm5uQC9vb0AwMDAAMXFxQDKysoAzc3NAN/f4ADl5eYA6urqAOzt + 7ADw8fIA8vL0APP09QD09fUA9vf4APf4+QD5+foA+/v8APv8/AD+/v4AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///8AAAAAAAAAAAAAAAAAAAAAAAQE + BAQEBAQEBAQEBAQEBAAFFRUVFRUVFRUZFRoZGgUABxUVFRUVGRUaGRoZGhoHAAgVAwIBFQQCARUEAgEa + CAAJFQYVBBUGFQQaBhUEGgkACRUHBwYaBwcGGgcHBhoKAAoZGRAZGRoQGhoaEBoaCgAKFRoQEBAQEBAQ + EBAaGgsADBoZGhoaGhAaGhoaGhoMAAwaGhoaGgQCARoaGhQRDAAMGhoaGhoGGQQaGg0LCwwADBoaGhoa + CAcGGhoQFQwSAA0aGhoaGhoaGhoaEAwUAAANDQ4ODQ4ODQ4ODQ0ZAAAAAAAAAAAAAAAAAAAAAAAAAP// + AAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAwAAAAcAAP// + AAAoAAAAIAAAAEAAAAABACAAAAAAAIAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAIAAAAGAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAA + ACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAGAAA + AAgAAAAAAAAAAAAAABgAAABIAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAA + AGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAA + AGAAAABIAAAAGAAAAAAAAAAA1tbW//j5+f/4+fn/+Pn5//j5+f/4+fn/+Pn5//j5+f/4+fn/+Pj4//j4 + +P/3+Pj/9/j4//f4+P/3+Pj/9/j4//f39//29/f/9vf3//b39//29/f/9vf3//b39//29/f/9fb2//X2 + 9v/19vb/9fb2/wAAAGAAAAAgAAAAAAAAAADW1tb/+fr6//n6+v/5+vr/+fr6//n6+v/5+vr/+fr6//n5 + +f/5+fn/+Pn5//j5+f/4+fn/+Pn5//j4+P/4+Pj/9/j4//f4+P/3+Pj/9/j4//f4+P/39/f/9vf3//b3 + 9//29/f/9vf3//b39//29/f/AAAAYAAAACAAAAAAAAAAANbW1v/6+vr/+fr6//r6+v/5+vr/+vr6//n6 + +v/5+vr/+fr6//n5+f/5+fn/+fn5//j5+f/4+fn/+Pn5//j4+P/4+Pj/9/j4//f4+P/3+Pj/9/j4//f4 + +P/39/f/9vf3//b39//29/f/9vf3//b39/8AAABgAAAAIAAAAAAAAAAA1tbW//r6+v/6+vr/dnZ2/2lp + af9jY2P/XV1d/1xcXP/5+vr/dnZ2/2lpaf9jY2P/XV1d/1xcXP/4+fn/dnZ2/2lpaf9jY2P/XV1d/1xc + XP/3+Pj/dnZ2/2lpaf9jY2P/XV1d/1xcXP/29/f/9vf3/wAAAGAAAAAgAAAAAAAAAADW1tb/+vv7//r6 + +v+AgID/9vb2/+vr6//f39//XFxc//r6+v+AgID/9vb2/+vr6//f39//XFxc//j5+f+AgID/9vb2/+vr + 6//f39//XFxc//f4+P+AgID/9vb2/+vr6//f39//XFxc//b39//29/f/AAAAYAAAACAAAAAAAAAAANbW + 1v/6+/v/+vv7/4WFhf/r6+v/39/f/9LS0v9jY2P/+vr6/4WFhf/r6+v/39/f/9LS0v9jY2P/+fn5/4WF + hf/r6+v/39/f/9LS0v9jY2P/+Pj4/4WFhf/r6+v/39/f/9LS0v9jY2P/9/f3//b39/8AAABgAAAAIAAA + AAAAAAAA1tbW//v7+//6+/v/ioqK/9/f3//S0tL/x8fH/3Z2dv/6+vr/ioqK/9/f3//S0tL/x8fH/3Z2 + dv/5+fn/ioqK/9/f3//S0tL/x8fH/3Z2dv/4+Pj/ioqK/9/f3//S0tL/x8fH/3Z2dv/3+Pj/9/f3/wAA + AGAAAAAgAAAAAAAAAADW1tb/+/v7//v7+/+Tk5P/kpKS/5GRkf+Ojo7/iIiI//r7+/+Tk5P/kpKS/5GR + kf+Ojo7/iIiI//n6+v+Tk5P/kpKS/5GRkf+Ojo7/iIiI//j5+f+Tk5P/kpKS/5GRkf+Ojo7/iIiI//f4 + +P/3+Pj/AAAAYAAAACAAAAAAAAAAANbW1v/7+/v/+/v7//v7+//7+/v/1tbW//v7+//7+/v/+/v7//r7 + +//6+/v/1tbW//r6+v/6+vr/+fr6//n6+v/5+vr/1tbW//n5+f/4+fn/+Pn5//j5+f/4+fn/1tbW//j4 + +P/3+Pj/9/j4//f4+P8AAABgAAAAIAAAAAAAAAAA1tbW//v8/P/7+/v/+/z8//v7+//W1tb/1tbW/9bW + 1v/W1tb/1tbW/9bW1v/W1tb/+vr6//r6+v/6+vr/+fr6//n6+v/W1tb/1tbW/9bW1v/W1tb/1tbW/9bW + 1v/W1tb/+Pj4//j4+P/3+Pj/9/j4/wAAAGAAAAAgAAAAAAAAAADW1tb/+/z8//v8/P/7/Pz/+/z8//v8 + /P/7/Pz/+/v7/9bW1v/7+/v/+/v7//r7+//6+/v/+vr6//r6+v/6+vr/+fr6//n6+v/5+vr/+fn5/9bW + 1v/5+fn/+Pn5//j5+f/4+fn/+Pj4//j4+P/3+Pj/AAAAYAAAACAAAAAAAAAAANbW1v/8/Pz//Pz8//z8 + /P/8/Pz//Pz8/3Z2dv9paWn/Y2Nj/11dXf9cXFz/+/v7//r7+//6+/v/+vv7//r6+v/6+vr/+vr6/3Z2 + dv9paWn/Y2Nj/11dXf9cXFz/+Pn5//j5+f/4+fn/+Pn5//j4+P8AAABgAAAAIAAAAAAAAAAA1tbW//z8 + /P/8/Pz//Pz8//z8/P/8/Pz/gICA//b29v/r6+v/39/f/1xcXP/7+/v/+/v7//v7+//6+/v/+vv7//r6 + +v/6+vr/gICA//b29v/r6+v/39/f/1xcXP/5+fn/+Pn5//j5+f/4+fn/+Pn5/wAAAGAAAAAgAAAAAAAA + AADW1tb//Pz8//z8/P/8/Pz//Pz8//z8/P+FhYX/6+vr/9/f3//S0tL/Y2Nj//v7+//7+/v/+/v7//v7 + +//6+/v/+vv7//r6+v+FhYX/6+vr/9/f3//S0tL/Y2Nj//n5+f/5+fn/+Pn5//j5+f/4+fn/AAAAYAAA + ACAAAAAAAAAAANbW1v/8/f3//Pz8//z9/f/8/Pz//P39/4qKiv/f39//0tLS/8fHx/92dnb/+/z8//v7 + +//7+/v/+/v7//v7+//6+/v/+vv7/4qKiv/f39//0tLS/8fHx/92dnb/+fr6//n5+f/5+fn/+fn5//j5 + +f8AAABgAAAAIAAAAAAAAAAA1tbW//39/f/8/f3//f39//z9/f/9/f3/k5OT/5KSkv+RkZH/jo6O/4iI + iP/8/Pz/+/z8//v8/P/7+/v/+/v7//v7+//6+/v/k5OT/5KSkv+RkZH/jo6O/4iIiP/5+vr/+fr6//n6 + +v/5+fn/+fn5/wAAAGAAAAAgAAAAAAAAAADW1tb//f39//39/f/9/f3//f39//39/f/9/f3//P39/9bW + 1v/8/Pz//Pz8//z8/P/8/Pz/+/z8//v8/P/7+/v/+/v7//v7+//7+/v/+vv7/9bW1v/6+vr/+vr6//r6 + +v/5+vr/+fr6//n6+v/5+fn/AAAAYAAAACAAAAAAAAAAANbW1v/9/f3//f39//39/f/9/f3//f39//39 + /f/9/f3/1tbW/9bW1v/W1tb/1tbW/9bW1v/W1tb/1tbW/9bW1v/W1tb/1tbW/9bW1v/W1tb/1tbW//r7 + +//6+vr/+vr6//r6+v/5+vr/+fr6//n6+v8AAABgAAAAIAAAAAAAAAAA1tbW//39/f/9/f3//f39//39 + /f/9/f3//f39//39/f/9/f3//P39//z9/f/8/Pz//Pz8//z8/P/W1tb//Pz8//v8/P/7+/v/+/v7//v7 + +//7+/v/+vv7//r7+//6+vr/+vr6//r6+v/5+vr/1NTU/wAAAGAAAAAgAAAAAAAAAADW1tb//f39//39 + /f/9/f3//f39//39/f/9/f3//f39//39/f/9/f3//f39//z9/f92dnb/aWlp/2NjY/9dXV3/XFxc//v8 + /P/7/Pz/+/v7//v7+//7+/v/+vv7//r7+//W1tb/zs7O/7+/v/+4uLj/AAAAVQAAABsAAAAAAAAAANbW + 1v/9/f3//f39//39/f/9/f3//f39//39/f/9/f3//f39//39/f/9/f3//f39/4CAgP/29vb/6+vr/9/f + 3/9cXFz//Pz8//v8/P/7/Pz/+/v7//v7+/+ysrL/q6ur/6mpqf+pqan/r6+v/7i4uP4AAAA3AAAADgAA + AAAAAAAA1tbW//7+/v/9/f3//v7+//39/f/+/v7//f39//39/f/9/f3//f39//39/f/9/f3/hYWF/+vr + 6//f39//0tLS/2NjY//8/Pz//Pz8//v8/P/7/Pz/+/v7/8bGxv/19fX/9PT0/+Pj4/+8vLz+ZGRkhAAA + ABQAAAADAAAAAAAAAADW1tb//v7+//7+/v/+/v7//v7+//7+/v/+/v7//f7+//39/f/9/f3//f39//39 + /f+Kior/39/f/9LS0v/Hx8f/dnZ2//z8/P/8/Pz//Pz8//z8/P/7/Pz/zs7O//r6+v/r6+v/ysrK/m1t + bX8AAAAXAAAAAwAAAAAAAAAAAAAAANbW1v/+/v7//v7+//7+/v/+/v7//v7+//7+/v/+/v7//f7+//39 + /f/9/f3//f39/5OTk/+SkpL/kZGR/46Ojv+IiIj//Pz8//z8/P/8/Pz//Pz8//z8/P/Nzc3/5OTk/8nJ + yf5oaGh/AAAAFwAAAAMAAAAAAAAAAAAAAAAAAAAA1tbW//7+/v/+/v7//v7+//7+/v/+/v7//v7+//7+ + /v/+/v7//f7+//39/f/9/f3//f39//39/f/9/f3//f39//39/f/8/f3//Pz8//z8/P/8/Pz/6urq/8PD + w//Hx8f+ZWVlfgAAABcAAAADAAAAAAAAAAAAAAAAAAAAAAAAAADW1tb//v7+//7+/v/+/v7//v7+//7+ + /v/+/v7//v7+//7+/v/+/v7//v7+//39/f/9/f3//f39//39/f/9/f3//f39//39/f/8/f3//Pz8//z8 + /P/c3Nz/v7+//mtra4IAAAAZAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANbW1v/W1tb/1tbW/9bW + 1v/W1tb/1tbW/9bW1v/W1tb/1tbW/9bW1v/W1tb/1tbW/9bW1v/W1tb/1tbW/9bW1v/W1tb/1tbW/9bW + 1v/W1tb/1tbW/8zMzPiCgoJvAAAAEgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + ////////gAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAA + AAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAA4AAAAeAAAAPgAAAH4AA + AD//////KAAAABAAAAAgAAAAAQAgAAAAAABABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6enr/enp6/3p6 + ev96enr/enp6/3p6ev96enr/enp6/3p6ev96enr/enp6/3p6ev96enr/enp6/3p6ev8AAAAAhoaG//Dw + 8v/w8PL/8PDy//Hx8//x8vP/8vL0//Pz9P/z9PX/9PX2//X19//29vf/9/f4//f4+f+Ghob/AAAAAJCQ + kP/x8fP/8fHz//Hx8//x8vP/8vL0//Pz9f/z9PX/9PX2//X19//29vf/9/f4//f4+f/4+fr/kJCQ/wAA + AACdnZ3/8vLz/3Z2dv9ubm7/ZGRk//Pz9f92dnb/bm5u/2RkZP/29vf/dnZ2/25ubv9kZGT/+fr6/52d + nf8AAAAArKys//Ly9P+Kior/9PT0/3t7e//09PX/ioqK//T09P97e3v/9/f4/4qKiv/09PT/e3t7//r7 + +/+srKz/AAAAAK2trf/z8/X/k5OT/5CQkP+IiIj/9PX2/5OTk/+QkJD/iIiI//j4+f+Tk5P/kJCQ/4iI + iP/7+/z/ra2t/wAAAACxsbH/9PT2//T09v/Nzc3/9fX2//X29//29/j/zc3N//j4+f/5+fr/+fr7/83N + zf/7/Pz/+/z8/7Gxsf8AAAAAs7Oz//X19v/19fb/zc3N/83Nzf/Nzc3/zc3N/83Nzf/Nzc3/zc3N/83N + zf/Nzc3/+/z9//z9/f+zs7P/AAAAALq6uv/3+Pn/9/j5//f4+f/4+fr/+fr6//r6+//Nzc3/+/z8//z9 + /f/8/f3//P39//3+/v/9/v7/uLi4/wAAAAC8vLz/+Pn6//j5+v/4+fr/+fr6//r6+/92dnb/bm5u/2Rk + ZP/8/f3//f7+//3+/v/l5eb/39/g/7q6uv8AAAAAvb29//n6+v/5+vr/+fr6//r7+//7+/z/ioqK//T0 + 9P97e3v//f7+//3+/v+6urr/uLi4/7i4uP+6urr/AAAAAL+/v//6+/v/+vv7//r7+//7+/z/+/z8/5OT + k/+QkJD/iIiI//3+/v/9/v7/xcXF//b29v+6urr/3d3dmwAAAADAwMD/+/v8//v7/P/7+/z/+/z8//z9 + /f/8/f3//f7+//3+/v/7/Pz//f7+/8rKyv+6urr/4+XipwAAAAAAAAAAwMDA/8DAwP/AwMD/wMDA/8DA + wP/AwMD/wMDA/8DAwP/AwMD/wMDA/8DAwP+/v7//9fX1uQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD//wAAAAEAAAAB + AAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAMAAAAHAAD//wAA + + + \ No newline at end of file diff --git a/AlternateCredsForm.Designer.cs b/AlternateCredsForm.Designer.cs new file mode 100644 index 0000000..f553da1 --- /dev/null +++ b/AlternateCredsForm.Designer.cs @@ -0,0 +1,124 @@ +namespace ADReplStatus +{ + partial class AlternateCredsForm + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(AlternateCredsForm)); + this.AlternateCredsButton = new System.Windows.Forms.Button(); + this.AlternateCredsLabel = new System.Windows.Forms.Label(); + this.UsernameTextBox = new System.Windows.Forms.TextBox(); + this.PasswordTextBox = new System.Windows.Forms.TextBox(); + this.PwdLabel = new System.Windows.Forms.Label(); + this.UsernameLabel = new System.Windows.Forms.Label(); + this.SuspendLayout(); + // + // AlternateCredsButton + // + this.AlternateCredsButton.Location = new System.Drawing.Point(384, 57); + this.AlternateCredsButton.Name = "AlternateCredsButton"; + this.AlternateCredsButton.Size = new System.Drawing.Size(75, 23); + this.AlternateCredsButton.TabIndex = 0; + this.AlternateCredsButton.Text = "OK"; + this.AlternateCredsButton.UseVisualStyleBackColor = true; + this.AlternateCredsButton.Click += new System.EventHandler(this.AlternateCredsButton_Click); + // + // AlternateCredsLabel + // + this.AlternateCredsLabel.AutoSize = true; + this.AlternateCredsLabel.Location = new System.Drawing.Point(12, 9); + this.AlternateCredsLabel.Name = "AlternateCredsLabel"; + this.AlternateCredsLabel.Size = new System.Drawing.Size(359, 39); + this.AlternateCredsLabel.TabIndex = 1; + this.AlternateCredsLabel.Text = resources.GetString("AlternateCredsLabel.Text"); + // + // UsernameTextBox + // + this.UsernameTextBox.Location = new System.Drawing.Point(74, 57); + this.UsernameTextBox.Name = "UsernameTextBox"; + this.UsernameTextBox.Size = new System.Drawing.Size(120, 20); + this.UsernameTextBox.TabIndex = 2; + // + // PasswordTextBox + // + this.PasswordTextBox.Location = new System.Drawing.Point(240, 57); + this.PasswordTextBox.Name = "PasswordTextBox"; + this.PasswordTextBox.Size = new System.Drawing.Size(138, 20); + this.PasswordTextBox.TabIndex = 3; + this.PasswordTextBox.UseSystemPasswordChar = true; + // + // PwdLabel + // + this.PwdLabel.AutoSize = true; + this.PwdLabel.Location = new System.Drawing.Point(206, 60); + this.PwdLabel.Name = "PwdLabel"; + this.PwdLabel.Size = new System.Drawing.Size(31, 13); + this.PwdLabel.TabIndex = 4; + this.PwdLabel.Text = "Pwd:"; + // + // UsernameLabel + // + this.UsernameLabel.AutoSize = true; + this.UsernameLabel.Location = new System.Drawing.Point(13, 60); + this.UsernameLabel.Name = "UsernameLabel"; + this.UsernameLabel.Size = new System.Drawing.Size(58, 13); + this.UsernameLabel.TabIndex = 5; + this.UsernameLabel.Text = "Username:"; + // + // AlternateCredsForm + // + this.AcceptButton = this.AlternateCredsButton; + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(462, 87); + this.Controls.Add(this.UsernameLabel); + this.Controls.Add(this.PwdLabel); + this.Controls.Add(this.PasswordTextBox); + this.Controls.Add(this.UsernameTextBox); + this.Controls.Add(this.AlternateCredsLabel); + this.Controls.Add(this.AlternateCredsButton); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.Fixed3D; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "AlternateCredsForm"; + this.ShowInTaskbar = false; + this.Text = "Provide Alternate Credentials"; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Button AlternateCredsButton; + private System.Windows.Forms.Label AlternateCredsLabel; + private System.Windows.Forms.TextBox UsernameTextBox; + private System.Windows.Forms.TextBox PasswordTextBox; + private System.Windows.Forms.Label PwdLabel; + private System.Windows.Forms.Label UsernameLabel; + } +} \ No newline at end of file diff --git a/AlternateCredsForm.cs b/AlternateCredsForm.cs new file mode 100644 index 0000000..f7c97e0 --- /dev/null +++ b/AlternateCredsForm.cs @@ -0,0 +1,37 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace ADReplStatus +{ + public partial class AlternateCredsForm : Form + { + public AlternateCredsForm() + { + InitializeComponent(); + } + + private void AlternateCredsButton_Click(object sender, EventArgs e) + { + if (UsernameTextBox.Text.Length > 0 && PasswordTextBox.Text.Length > 0) + { + ADReplStatusForm.gUsername = UsernameTextBox.Text; + + ADReplStatusForm.gPassword = PasswordTextBox.Text; + + this.Dispose(); + + if (ADReplStatusForm.gLoggingEnabled) + { + System.IO.File.AppendAllText(ADReplStatusForm.gLogfileName, $"[{DateTime.Now}] Using alternate identity: {ADReplStatusForm.gUsername}\n"); + } + } + } + } +} diff --git a/AlternateCredsForm.resx b/AlternateCredsForm.resx new file mode 100644 index 0000000..88be13e --- /dev/null +++ b/AlternateCredsForm.resx @@ -0,0 +1,125 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + Provide alternate credentials to connect to the AD forest. +NOTE: This is only necessary if the currently logged-on user does not have +permissions to the replication data of the target Active Directory forest: + + \ No newline at end of file diff --git a/App.config b/App.config new file mode 100644 index 0000000..193aecc --- /dev/null +++ b/App.config @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/Forest.ico b/Forest.ico new file mode 100644 index 0000000..270d42c Binary files /dev/null and b/Forest.ico differ diff --git a/Program.cs b/Program.cs new file mode 100644 index 0000000..45a567a --- /dev/null +++ b/Program.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace ADReplStatus +{ + internal static class Program + { + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new ADReplStatusForm()); + } + } +} diff --git a/Properties/AssemblyInfo.cs b/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..8877679 --- /dev/null +++ b/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("ADReplStatus")] +[assembly: AssemblyDescription("Active Directory Replication Status Tool")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("ADReplStatus")] +[assembly: AssemblyCopyright("Copyright © Joseph Ryan Ries 2023")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("af7ee9dd-d7c5-409c-a1e9-78e1078f6a89")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Properties/Resources.Designer.cs b/Properties/Resources.Designer.cs new file mode 100644 index 0000000..d717274 --- /dev/null +++ b/Properties/Resources.Designer.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace ADReplStatus.Properties +{ + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources + { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() + { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager + { + get + { + if ((resourceMan == null)) + { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("ADReplStatus.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture + { + get + { + return resourceCulture; + } + set + { + resourceCulture = value; + } + } + } +} diff --git a/Properties/Resources.resx b/Properties/Resources.resx new file mode 100644 index 0000000..af7dbeb --- /dev/null +++ b/Properties/Resources.resx @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Properties/Settings.Designer.cs b/Properties/Settings.Designer.cs new file mode 100644 index 0000000..7aac06f --- /dev/null +++ b/Properties/Settings.Designer.cs @@ -0,0 +1,30 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace ADReplStatus.Properties +{ + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase + { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default + { + get + { + return defaultInstance; + } + } + } +} diff --git a/Properties/Settings.settings b/Properties/Settings.settings new file mode 100644 index 0000000..3964565 --- /dev/null +++ b/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/SetForestNameForm.Designer.cs b/SetForestNameForm.Designer.cs new file mode 100644 index 0000000..6af881b --- /dev/null +++ b/SetForestNameForm.Designer.cs @@ -0,0 +1,102 @@ +namespace ADReplStatus +{ + partial class SetForestNameForm + { + /// + /// 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.EnterForestNameLabel = new System.Windows.Forms.Label(); + this.SetForestNameTextBox = new System.Windows.Forms.TextBox(); + this.SetForestNameButton = new System.Windows.Forms.Button(); + this.SaveForestCheckBox = new System.Windows.Forms.CheckBox(); + this.SuspendLayout(); + // + // EnterForestNameLabel + // + this.EnterForestNameLabel.AutoSize = true; + this.EnterForestNameLabel.Location = new System.Drawing.Point(12, 9); + this.EnterForestNameLabel.Name = "EnterForestNameLabel"; + this.EnterForestNameLabel.Size = new System.Drawing.Size(303, 13); + this.EnterForestNameLabel.TabIndex = 0; + this.EnterForestNameLabel.Text = "Enter the name of the Active Directory forest you want to scan:"; + // + // SetForestNameTextBox + // + this.SetForestNameTextBox.Location = new System.Drawing.Point(13, 29); + this.SetForestNameTextBox.Name = "SetForestNameTextBox"; + this.SetForestNameTextBox.Size = new System.Drawing.Size(240, 20); + this.SetForestNameTextBox.TabIndex = 1; + // + // SetForestNameButton + // + this.SetForestNameButton.Location = new System.Drawing.Point(322, 29); + this.SetForestNameButton.Name = "SetForestNameButton"; + this.SetForestNameButton.Size = new System.Drawing.Size(75, 23); + this.SetForestNameButton.TabIndex = 2; + this.SetForestNameButton.Text = "OK"; + this.SetForestNameButton.UseVisualStyleBackColor = true; + this.SetForestNameButton.Click += new System.EventHandler(this.SetForestNameButton_Click); + // + // SaveForestCheckBox + // + this.SaveForestCheckBox.AutoSize = true; + this.SaveForestCheckBox.Location = new System.Drawing.Point(15, 56); + this.SaveForestCheckBox.Name = "SaveForestCheckBox"; + this.SaveForestCheckBox.Size = new System.Drawing.Size(51, 17); + this.SaveForestCheckBox.TabIndex = 3; + this.SaveForestCheckBox.Text = "Save"; + this.SaveForestCheckBox.UseVisualStyleBackColor = true; + // + // SetForestNameForm + // + this.AcceptButton = this.SetForestNameButton; + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(406, 83); + this.Controls.Add(this.SaveForestCheckBox); + this.Controls.Add(this.SetForestNameButton); + this.Controls.Add(this.SetForestNameTextBox); + this.Controls.Add(this.EnterForestNameLabel); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.Fixed3D; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "SetForestNameForm"; + this.ShowInTaskbar = false; + this.Text = "Enter AD Forest Name"; + this.Load += new System.EventHandler(this.SetForestNameForm_Load); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Label EnterForestNameLabel; + private System.Windows.Forms.TextBox SetForestNameTextBox; + private System.Windows.Forms.Button SetForestNameButton; + private System.Windows.Forms.CheckBox SaveForestCheckBox; + } +} \ No newline at end of file diff --git a/SetForestNameForm.cs b/SetForestNameForm.cs new file mode 100644 index 0000000..959894a --- /dev/null +++ b/SetForestNameForm.cs @@ -0,0 +1,67 @@ +using Microsoft.Win32; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace ADReplStatus +{ + public partial class SetForestNameForm : Form + { + public SetForestNameForm() + { + InitializeComponent(); + } + + private void SetForestNameForm_Load(object sender, EventArgs e) + { + + } + + private void SetForestNameButton_Click(object sender, EventArgs e) + { + if (SetForestNameTextBox.Text.Length > 0) + { + ADReplStatusForm.gForestName = SetForestNameTextBox.Text; + + if (SaveForestCheckBox.Checked) + { + try + { + var key = Registry.CurrentUser.CreateSubKey("SOFTWARE\\ADREPLSTATUS", true); + + if (key != null) + { + key.SetValue("ForestName", SetForestNameTextBox.Text); + + key.Dispose(); + } + } + catch (Exception ex) + { + string errorMessage = $"ERROR: Failed to write to the HKCU\\ADREPLSTATUS registry key!\n{ex.Message}\n"; + + MessageBox.Show(errorMessage, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + + if (ADReplStatusForm.gLoggingEnabled) + { + System.IO.File.AppendAllText(ADReplStatusForm.gLogfileName, $"[{DateTime.Now}] {errorMessage}\n"); + } + } + } + + if (ADReplStatusForm.gLoggingEnabled) + { + System.IO.File.AppendAllText(ADReplStatusForm.gLogfileName, $"[{DateTime.Now}] Forest name set to: {ADReplStatusForm.gForestName}\n"); + } + + this.Dispose(); + } + } + } +} diff --git a/SetForestNameForm.resx b/SetForestNameForm.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/SetForestNameForm.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/images/Error.png b/images/Error.png new file mode 100644 index 0000000..08c6340 Binary files /dev/null and b/images/Error.png differ diff --git a/images/Forest.ico b/images/Forest.ico new file mode 100644 index 0000000..270d42c Binary files /dev/null and b/images/Forest.ico differ diff --git a/images/Forest.png b/images/Forest.png new file mode 100644 index 0000000..6a3930c Binary files /dev/null and b/images/Forest.png differ diff --git a/images/Go.png b/images/Go.png new file mode 100644 index 0000000..825a7b5 Binary files /dev/null and b/images/Go.png differ diff --git a/images/KeyLock.png b/images/KeyLock.png new file mode 100644 index 0000000..8605e10 Binary files /dev/null and b/images/KeyLock.png differ diff --git a/images/Logging.png b/images/Logging.png new file mode 100644 index 0000000..f6526b5 Binary files /dev/null and b/images/Logging.png differ diff --git a/images/Progress.gif b/images/Progress.gif new file mode 100644 index 0000000..53172be Binary files /dev/null and b/images/Progress.gif differ diff --git a/packages.config b/packages.config new file mode 100644 index 0000000..3aea39d --- /dev/null +++ b/packages.config @@ -0,0 +1,4 @@ + + + + \ No newline at end of file