From 56759cefbd14f3b147073fce97278b2817f34af2 Mon Sep 17 00:00:00 2001 From: Stefan Hasensperling Date: Tue, 3 May 2022 18:23:56 -0400 Subject: [PATCH] Added Profinet Monitor. This tool allows you to monitor configured Profinet devices, log failures and automatically assigns the device name to devices that have lost their device names. --- ProfinetMonitor/AboutDialog.Designer.cs | 187 + ProfinetMonitor/AboutDialog.cs | 105 + ProfinetMonitor/AboutDialog.resx | 3934 +++++++++++++++++ ProfinetMonitor/DeviceConfigurationFile.cs | 110 + .../DeviceConfigurationFileEntry.cs | 11 + .../DevicesConfigurationDialog.Designer.cs | 440 ++ ProfinetMonitor/DevicesConfigurationDialog.cs | 243 + .../DevicesConfigurationDialog.resx | 2626 +++++++++++ ProfinetMonitor/EditableListView.cs | 221 + ProfinetMonitor/Logging/LogManager.cs | 50 + ProfinetMonitor/Logging/Logger.cs | 252 ++ .../Logging/RollingFileTraceListener.cs | 145 + ProfinetMonitor/MonitorModeDialog.Designer.cs | 102 + ProfinetMonitor/MonitorModeDialog.cs | 73 + ProfinetMonitor/MonitorModeDialog.resx | 783 ++++ ProfinetMonitor/ProfinetDeviceMonitor.cs | 267 ++ ProfinetMonitor/ProfinetMonitor.csproj | 143 + ProfinetMonitor/ProfinetMonitor.ico | Bin 0 -> 38933 bytes ProfinetMonitor/Program.cs | 87 + ProfinetMonitor/Properties/AssemblyInfo.cs | 36 + .../Properties/Resources.Designer.cs | 63 + ProfinetMonitor/Properties/Resources.resx | 117 + .../Properties/Settings.Designer.cs | 26 + ProfinetMonitor/Properties/Settings.settings | 7 + ProfinetMonitor/ReadMe.md | 26 + ProfinetMonitor/app.config | 3 + ProfinetTools.sln | 14 +- 27 files changed, 10069 insertions(+), 2 deletions(-) create mode 100644 ProfinetMonitor/AboutDialog.Designer.cs create mode 100644 ProfinetMonitor/AboutDialog.cs create mode 100644 ProfinetMonitor/AboutDialog.resx create mode 100644 ProfinetMonitor/DeviceConfigurationFile.cs create mode 100644 ProfinetMonitor/DeviceConfigurationFileEntry.cs create mode 100644 ProfinetMonitor/DevicesConfigurationDialog.Designer.cs create mode 100644 ProfinetMonitor/DevicesConfigurationDialog.cs create mode 100644 ProfinetMonitor/DevicesConfigurationDialog.resx create mode 100644 ProfinetMonitor/EditableListView.cs create mode 100644 ProfinetMonitor/Logging/LogManager.cs create mode 100644 ProfinetMonitor/Logging/Logger.cs create mode 100644 ProfinetMonitor/Logging/RollingFileTraceListener.cs create mode 100644 ProfinetMonitor/MonitorModeDialog.Designer.cs create mode 100644 ProfinetMonitor/MonitorModeDialog.cs create mode 100644 ProfinetMonitor/MonitorModeDialog.resx create mode 100644 ProfinetMonitor/ProfinetDeviceMonitor.cs create mode 100644 ProfinetMonitor/ProfinetMonitor.csproj create mode 100644 ProfinetMonitor/ProfinetMonitor.ico create mode 100644 ProfinetMonitor/Program.cs create mode 100644 ProfinetMonitor/Properties/AssemblyInfo.cs create mode 100644 ProfinetMonitor/Properties/Resources.Designer.cs create mode 100644 ProfinetMonitor/Properties/Resources.resx create mode 100644 ProfinetMonitor/Properties/Settings.Designer.cs create mode 100644 ProfinetMonitor/Properties/Settings.settings create mode 100644 ProfinetMonitor/ReadMe.md create mode 100644 ProfinetMonitor/app.config diff --git a/ProfinetMonitor/AboutDialog.Designer.cs b/ProfinetMonitor/AboutDialog.Designer.cs new file mode 100644 index 0000000..8851c9b --- /dev/null +++ b/ProfinetMonitor/AboutDialog.Designer.cs @@ -0,0 +1,187 @@ + +namespace ProfinetMonitor +{ + partial class AboutDialog + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + 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(AboutDialog)); + this.tableLayoutPanel = new System.Windows.Forms.TableLayoutPanel(); + this.logoPictureBox = new System.Windows.Forms.PictureBox(); + this.labelProductName = new System.Windows.Forms.Label(); + this.labelVersion = new System.Windows.Forms.Label(); + this.labelCopyright = new System.Windows.Forms.Label(); + this.labelCompanyName = new System.Windows.Forms.Label(); + this.textBoxDescription = new System.Windows.Forms.TextBox(); + this.okButton = new System.Windows.Forms.Button(); + this.tableLayoutPanel.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.logoPictureBox)).BeginInit(); + this.SuspendLayout(); + // + // tableLayoutPanel + // + this.tableLayoutPanel.ColumnCount = 2; + this.tableLayoutPanel.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 33F)); + this.tableLayoutPanel.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 67F)); + this.tableLayoutPanel.Controls.Add(this.logoPictureBox, 0, 0); + this.tableLayoutPanel.Controls.Add(this.labelProductName, 1, 0); + this.tableLayoutPanel.Controls.Add(this.labelVersion, 1, 1); + this.tableLayoutPanel.Controls.Add(this.labelCopyright, 1, 2); + this.tableLayoutPanel.Controls.Add(this.labelCompanyName, 1, 3); + this.tableLayoutPanel.Controls.Add(this.textBoxDescription, 1, 4); + this.tableLayoutPanel.Controls.Add(this.okButton, 1, 5); + this.tableLayoutPanel.Dock = System.Windows.Forms.DockStyle.Fill; + this.tableLayoutPanel.Location = new System.Drawing.Point(9, 9); + this.tableLayoutPanel.Name = "tableLayoutPanel"; + this.tableLayoutPanel.RowCount = 6; + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 10F)); + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 10F)); + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 10F)); + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 10F)); + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 50F)); + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 10F)); + this.tableLayoutPanel.Size = new System.Drawing.Size(417, 265); + this.tableLayoutPanel.TabIndex = 0; + // + // logoPictureBox + // + this.logoPictureBox.Dock = System.Windows.Forms.DockStyle.Fill; + this.logoPictureBox.Image = ((System.Drawing.Image)(resources.GetObject("logoPictureBox.Image"))); + this.logoPictureBox.Location = new System.Drawing.Point(3, 3); + this.logoPictureBox.Name = "logoPictureBox"; + this.tableLayoutPanel.SetRowSpan(this.logoPictureBox, 6); + this.logoPictureBox.Size = new System.Drawing.Size(131, 259); + this.logoPictureBox.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.logoPictureBox.TabIndex = 12; + this.logoPictureBox.TabStop = false; + // + // labelProductName + // + this.labelProductName.Dock = System.Windows.Forms.DockStyle.Fill; + this.labelProductName.Location = new System.Drawing.Point(143, 0); + this.labelProductName.Margin = new System.Windows.Forms.Padding(6, 0, 3, 0); + this.labelProductName.MaximumSize = new System.Drawing.Size(0, 17); + this.labelProductName.Name = "labelProductName"; + this.labelProductName.Size = new System.Drawing.Size(271, 17); + this.labelProductName.TabIndex = 19; + this.labelProductName.Text = "Product Name"; + this.labelProductName.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // labelVersion + // + this.labelVersion.Dock = System.Windows.Forms.DockStyle.Fill; + this.labelVersion.Location = new System.Drawing.Point(143, 26); + this.labelVersion.Margin = new System.Windows.Forms.Padding(6, 0, 3, 0); + this.labelVersion.MaximumSize = new System.Drawing.Size(0, 17); + this.labelVersion.Name = "labelVersion"; + this.labelVersion.Size = new System.Drawing.Size(271, 17); + this.labelVersion.TabIndex = 0; + this.labelVersion.Text = "Version"; + this.labelVersion.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // labelCopyright + // + this.labelCopyright.Dock = System.Windows.Forms.DockStyle.Fill; + this.labelCopyright.Location = new System.Drawing.Point(143, 52); + this.labelCopyright.Margin = new System.Windows.Forms.Padding(6, 0, 3, 0); + this.labelCopyright.MaximumSize = new System.Drawing.Size(0, 17); + this.labelCopyright.Name = "labelCopyright"; + this.labelCopyright.Size = new System.Drawing.Size(271, 17); + this.labelCopyright.TabIndex = 21; + this.labelCopyright.Text = "Copyright"; + this.labelCopyright.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // labelCompanyName + // + this.labelCompanyName.Dock = System.Windows.Forms.DockStyle.Fill; + this.labelCompanyName.Location = new System.Drawing.Point(143, 78); + this.labelCompanyName.Margin = new System.Windows.Forms.Padding(6, 0, 3, 0); + this.labelCompanyName.MaximumSize = new System.Drawing.Size(0, 17); + this.labelCompanyName.Name = "labelCompanyName"; + this.labelCompanyName.Size = new System.Drawing.Size(271, 17); + this.labelCompanyName.TabIndex = 22; + this.labelCompanyName.Text = "Company Name"; + this.labelCompanyName.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // textBoxDescription + // + this.textBoxDescription.Dock = System.Windows.Forms.DockStyle.Fill; + this.textBoxDescription.Location = new System.Drawing.Point(143, 107); + this.textBoxDescription.Margin = new System.Windows.Forms.Padding(6, 3, 3, 3); + this.textBoxDescription.Multiline = true; + this.textBoxDescription.Name = "textBoxDescription"; + this.textBoxDescription.ReadOnly = true; + this.textBoxDescription.ScrollBars = System.Windows.Forms.ScrollBars.Both; + this.textBoxDescription.Size = new System.Drawing.Size(271, 126); + this.textBoxDescription.TabIndex = 23; + this.textBoxDescription.TabStop = false; + this.textBoxDescription.Text = "Description"; + // + // okButton + // + this.okButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.okButton.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.okButton.Location = new System.Drawing.Point(339, 239); + this.okButton.Name = "okButton"; + this.okButton.Size = new System.Drawing.Size(75, 23); + this.okButton.TabIndex = 24; + this.okButton.Text = "&OK"; + // + // AboutDialog + // + this.AcceptButton = this.okButton; + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(435, 283); + this.Controls.Add(this.tableLayoutPanel); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "AboutDialog"; + this.Padding = new System.Windows.Forms.Padding(9); + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; + this.Text = "About Dialog"; + this.tableLayoutPanel.ResumeLayout(false); + this.tableLayoutPanel.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.logoPictureBox)).EndInit(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.TableLayoutPanel tableLayoutPanel; + private System.Windows.Forms.PictureBox logoPictureBox; + private System.Windows.Forms.Label labelProductName; + private System.Windows.Forms.Label labelVersion; + private System.Windows.Forms.Label labelCopyright; + private System.Windows.Forms.Label labelCompanyName; + private System.Windows.Forms.TextBox textBoxDescription; + private System.Windows.Forms.Button okButton; + } +} diff --git a/ProfinetMonitor/AboutDialog.cs b/ProfinetMonitor/AboutDialog.cs new file mode 100644 index 0000000..5f17b98 --- /dev/null +++ b/ProfinetMonitor/AboutDialog.cs @@ -0,0 +1,105 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Linq; +using System.Reflection; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace ProfinetMonitor +{ + partial class AboutDialog : Form + { + public AboutDialog() + { + InitializeComponent(); + this.Text = String.Format("About {0}", AssemblyTitle); + this.labelProductName.Text = AssemblyProduct; + this.labelVersion.Text = String.Format("Version {0}", AssemblyVersion); + this.labelCopyright.Text = AssemblyCopyright; + this.labelCompanyName.Text = AssemblyCompany; + this.textBoxDescription.Text = AssemblyDescription; + } + + #region Assembly Attribute Accessors + + public string AssemblyTitle + { + get + { + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false); + if (attributes.Length > 0) + { + AssemblyTitleAttribute titleAttribute = (AssemblyTitleAttribute)attributes[0]; + if (titleAttribute.Title != "") + { + return titleAttribute.Title; + } + } + return System.IO.Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().CodeBase); + } + } + + public string AssemblyVersion + { + get + { + return Assembly.GetExecutingAssembly().GetName().Version.ToString(); + } + } + + public string AssemblyDescription + { + get + { + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyDescriptionAttribute), false); + if (attributes.Length == 0) + { + return ""; + } + return ((AssemblyDescriptionAttribute)attributes[0]).Description; + } + } + + public string AssemblyProduct + { + get + { + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyProductAttribute), false); + if (attributes.Length == 0) + { + return ""; + } + return ((AssemblyProductAttribute)attributes[0]).Product; + } + } + + public string AssemblyCopyright + { + get + { + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCopyrightAttribute), false); + if (attributes.Length == 0) + { + return ""; + } + return ((AssemblyCopyrightAttribute)attributes[0]).Copyright; + } + } + + public string AssemblyCompany + { + get + { + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCompanyAttribute), false); + if (attributes.Length == 0) + { + return ""; + } + return ((AssemblyCompanyAttribute)attributes[0]).Company; + } + } + #endregion + } +} diff --git a/ProfinetMonitor/AboutDialog.resx b/ProfinetMonitor/AboutDialog.resx new file mode 100644 index 0000000..47a6714 --- /dev/null +++ b/ProfinetMonitor/AboutDialog.resx @@ -0,0 +1,3934 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + iVBORw0KGgoAAAANSUhEUgAAApAAAATYCAYAAACobvdrAAAABGdBTUEAALGOfPtRkwAAACBjSFJNAACH + DwAAjA8AAP1SAACBQAAAfXkAAOmLAAA85QAAGcxzPIV3AAAKL2lDQ1BJQ0MgUHJvZmlsZQAASMedlndU + VNcWh8+9d3qhzTACUobeu8AA0nuTXkVhmBlgKAMOMzSxIaICEUVEmiJIUMSA0VAkVkSxEBRUsAckCCgx + GEVULG9G1ouurLz38vL746xv7bP3ufvsvc9aFwCSpy+XlwZLAZDKE/CDPJzpEZFRdOwAgAEeYIApAExW + RrpfsHsIEMnLzYWeIXICXwQB8HpYvAJw09AzgE4H/5+kWel8geiYABGbszkZLBEXiDglS5Auts+KmBqX + LGYYJWa+KEERy4k5YZENPvsssqOY2ak8tojFOaezU9li7hXxtkwhR8SIr4gLM7mcLBHfErFGijCVK+I3 + 4thUDjMDABRJbBdwWIkiNhExiR8S5CLi5QDgSAlfcdxXLOBkC8SXcklLz+FzExIFdB2WLt3U2ppB9+Rk + pXAEAsMAJiuZyWfTXdJS05m8HAAW7/xZMuLa0kVFtjS1trQ0NDMy/apQ/3Xzb0rc20V6Gfi5ZxCt/4vt + r/zSGgBgzIlqs/OLLa4KgM4tAMjd+2LTOACApKhvHde/ug9NPC+JAkG6jbFxVlaWEZfDMhIX9A/9T4e/ + oa++ZyQ+7o/y0F058UxhioAurhsrLSVNyKdnpDNZHLrhn4f4Hwf+dR4GQZx4Dp/DE0WEiaaMy0sQtZvH + 5gq4aTw6l/efmvgPw/6kxbkWidL4EVBjjIDUdSpAfu0HKAoRINH7xV3/o2+++DAgfnnhKpOLc//vN/1n + waXiJYOb8DnOJSiEzhLyMxf3xM8SoAEBSAIqkAfKQB3oAENgBqyALXAEbsAb+IMQEAlWAxZIBKmAD7JA + HtgECkEx2An2gGpQBxpBM2gFx0EnOAXOg0vgGrgBboP7YBRMgGdgFrwGCxAEYSEyRIHkIRVIE9KHzCAG + ZA+5Qb5QEBQJxUIJEA8SQnnQZqgYKoOqoXqoGfoeOgmdh65Ag9BdaAyahn6H3sEITIKpsBKsBRvDDNgJ + 9oFD4FVwArwGzoUL4B1wJdwAH4U74PPwNfg2PAo/g+cQgBARGqKKGCIMxAXxR6KQeISPrEeKkAqkAWlF + upE+5CYyiswgb1EYFAVFRxmibFGeqFAUC7UGtR5VgqpGHUZ1oHpRN1FjqFnURzQZrYjWR9ugvdAR6AR0 + FroQXYFuQrejL6JvoyfQrzEYDA2jjbHCeGIiMUmYtZgSzD5MG+YcZhAzjpnDYrHyWH2sHdYfy8QKsIXY + KuxR7FnsEHYC+wZHxKngzHDuuCgcD5ePq8AdwZ3BDeEmcQt4Kbwm3gbvj2fjc/Cl+EZ8N/46fgK/QJAm + aBPsCCGEJMImQiWhlXCR8IDwkkgkqhGtiYFELnEjsZJ4jHiZOEZ8S5Ih6ZFcSNEkIWkH6RDpHOku6SWZ + TNYiO5KjyALyDnIz+QL5EfmNBEXCSMJLgi2xQaJGokNiSOK5JF5SU9JJcrVkrmSF5AnJ65IzUngpLSkX + KabUeqkaqZNSI1Jz0hRpU2l/6VTpEukj0lekp2SwMloybjJsmQKZgzIXZMYpCEWd4kJhUTZTGikXKRNU + DFWb6kVNohZTv6MOUGdlZWSXyYbJZsvWyJ6WHaUhNC2aFy2FVko7ThumvVuitMRpCWfJ9iWtS4aWzMst + lXOU48gVybXJ3ZZ7J0+Xd5NPlt8l3yn/UAGloKcQqJClsF/hosLMUupS26WspUVLjy+9pwgr6ikGKa5V + PKjYrzinpKzkoZSuVKV0QWlGmabsqJykXK58RnlahaJir8JVKVc5q/KULkt3oqfQK+m99FlVRVVPVaFq + veqA6oKatlqoWr5am9pDdYI6Qz1evVy9R31WQ0XDTyNPo0XjniZek6GZqLlXs09zXktbK1xrq1an1pS2 + nLaXdq52i/YDHbKOg84anQadW7oYXYZusu4+3Rt6sJ6FXqJejd51fVjfUp+rv09/0ABtYG3AM2gwGDEk + GToZZhq2GI4Z0Yx8jfKNOo2eG2sYRxnvMu4z/mhiYZJi0mhy31TG1Ns037Tb9HczPTOWWY3ZLXOyubv5 + BvMu8xfL9Jdxlu1fdseCYuFnsdWix+KDpZUl37LVctpKwyrWqtZqhEFlBDBKGJet0dbO1husT1m/tbG0 + Edgct/nN1tA22faI7dRy7eWc5Y3Lx+3U7Jh29Xaj9nT7WPsD9qMOqg5MhwaHx47qjmzHJsdJJ12nJKej + Ts+dTZz5zu3O8y42Lutczrkirh6uRa4DbjJuoW7Vbo/c1dwT3FvcZz0sPNZ6nPNEe/p47vIc8VLyYnk1 + e816W3mv8+71IfkE+1T7PPbV8+X7dvvBft5+u/0erNBcwVvR6Q/8vfx3+z8M0A5YE/BjICYwILAm8EmQ + aVBeUF8wJTgm+Ejw6xDnkNKQ+6E6ocLQnjDJsOiw5rD5cNfwsvDRCOOIdRHXIhUiuZFdUdiosKimqLmV + biv3rJyItogujB5epb0qe9WV1QqrU1afjpGMYcaciEXHhsceiX3P9Gc2MOfivOJq42ZZLqy9rGdsR3Y5 + e5pjxynjTMbbxZfFTyXYJexOmE50SKxInOG6cKu5L5I8k+qS5pP9kw8lf0oJT2lLxaXGpp7kyfCSeb1p + ymnZaYPp+umF6aNrbNbsWTPL9+E3ZUAZqzK6BFTRz1S/UEe4RTiWaZ9Zk/kmKyzrRLZ0Ni+7P0cvZ3vO + ZK577rdrUWtZa3vyVPM25Y2tc1pXvx5aH7e+Z4P6hoINExs9Nh7eRNiUvOmnfJP8svxXm8M3dxcoFWws + GN/isaWlUKKQXziy1XZr3TbUNu62ge3m26u2fyxiF10tNimuKH5fwiq5+o3pN5XffNoRv2Og1LJ0/07M + Tt7O4V0Ouw6XSZfllo3v9tvdUU4vLyp/tSdmz5WKZRV1ewl7hXtHK30ru6o0qnZWva9OrL5d41zTVqtY + u712fh9739B+x/2tdUp1xXXvDnAP3Kn3qO9o0GqoOIg5mHnwSWNYY9+3jG+bmxSaips+HOIdGj0cdLi3 + 2aq5+YjikdIWuEXYMn00+uiN71y/62o1bK1vo7UVHwPHhMeefh/7/fBxn+M9JxgnWn/Q/KG2ndJe1AF1 + 5HTMdiZ2jnZFdg2e9D7Z023b3f6j0Y+HTqmeqjkte7r0DOFMwZlPZ3PPzp1LPzdzPuH8eE9Mz/0LERdu + 9Qb2Dlz0uXj5kvulC31OfWcv210+dcXmysmrjKud1yyvdfRb9Lf/ZPFT+4DlQMd1q+tdN6xvdA8uHzwz + 5DB0/qbrzUu3vG5du73i9uBw6PCdkeiR0TvsO1N3U+6+uJd5b+H+xgfoB0UPpR5WPFJ81PCz7s9to5aj + p8dcx/ofBz++P84af/ZLxi/vJwqekJ9UTKpMNk+ZTZ2adp++8XTl04ln6c8WZgp/lf619rnO8x9+c/yt + fzZiduIF/8Wn30teyr889GrZq565gLlHr1NfL8wXvZF/c/gt423fu/B3kwtZ77HvKz/ofuj+6PPxwafU + T5/+BQOY8/xvJtwPAAAACXBIWXMAAC4iAAAuIgGq4t2SAAD1S0lEQVR4Xuz9Ma+l15IdCPZP0E8oW/mI + p59QjtouU+09c+Q9r4RMAlWAeuS0QaPL0wAcgEw+oEsAW8aonSo8TA0E9ACS0hBaUjtFdEEjoaVGpwxJ + g5HD2RGxVsSK+L7LRybJc5PJCCAQEStWxI7vy3PO3nnOvef+VysrKysrKysrKysrKysrKysrKysrKysr + KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr + KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKz8f+eVv/vD3Xvzm1e+/+OyoWSri + v/75y78B6srKysrKysrKys9FfvmbP/q9X7z++A8+ev3qjz/64uWXH73++Le/+OLV1794/errj774+Gv3 + j9Iv27Gjbz56/fK3L6zP5y9/tYfLlZWVlZWVlZUPRH756R/9NTvgnYPfpy8+f/XVPBi64vAYentYTC45 + FYdaj1988fLti89ffvnii5e/toMqRlhZWVlZWVlZWXnfJQ6NH//KDnM8APJQ6IdBvtvohz4e/uow2A6F + 5CD2OsTpkwcucTuw/uL1x5/YR+MYbWVlZWVlZWVl5X0S+1nFc3D71A5wVD/g8VA3DoCpgkddr7nU4aCY + OGPUsF6xY9/YO6EYdWVlZWVlZWVl5TnFDmb284h60NMDXx0IA88Dnh38vKbzFacf9XVYTD5iavamjz7U + F1+8fGs/f2nvkmL8lZWVlZWVlZWVR4n/dvRr+5gYhzYc1sLGQZEHPcaT1w57bo3XD4eVKz/z6JW4x1wT + mORoX7zeg+TKysrKysrKysPEfuPZ3nFsh72jPMj5wU0Od/Qj5sEy/ORAiRPLHGqV4z0zBy55yLEmVXDj + +zuS+9H2ysrKysrKysqPI/Zu3TmAfeKHMBzUeEDLg9rNwc19qSk8Yh78HJe+zJPPGl2j8aS28mpLe0/n + v9mvAlpZWVlZWVlZ+QHFv9AbX8PDQ5kf5KiCqXXfDmrEcWgjP7RyhaEWvd1CrwdA+OQIftdL5/da1Jlv + 3yuJS15ZWVlZWVlZWXlX8S/rtgOXHbZ4+BKrhzYexCzHQxqx5Hg+cM0lxzGrL6s1ua7EpRUzT01c4rDg + VM83+9U/KysrKysrKyvvIPGRtf2sIw5ZPGjx8MVYcB7CmK9DX+WYp7IfOW29xJAHt/DOS0x4XGPyUpFT + vv1spL3riluxsrKysrKysrLyu8R+HvAcrPI3rHkIux7O9AAWlmqx8cL2HGvI0xx7z7WVQzy5iR1rXGjN + UKr84nTM1fGXv8YtWVlZWVlZWVlZeUr88Gi/newHLhyu/KDFQyNxHOyg5KUP1UMba5hvfQybFnn2zjUG + 5xIPTvTQOTre+gMX3qe4NSsrKysrKysrK1P8TxD64VEPWHWgikMWDlyOd5tqBzce4o5mD2KvX3111vnS + fr7yF68//gP7uPh3fSej5f2XeUytzv/qzas3cx36rpi3/MDjGnhIFCsc74veL/YQubKysrKysrJyFfs+ + xDhI6aEKhylTHKZUeRBzHvKMWYteb49+amv80F/eHT+r+fEfnPXtK4a+ijVjHs6ns5mln9fn3KojZ/D2 + ELmysrKysrKyQrF39fLQpIetPFjVYassMOPz0CW+/bUXe+fODndY5iGCn9/8xL52yGeC8joU47y8Vs5O + y2tNfA+RKysrKysrKytx4PI/7ecHwlA5MPkh6nLwIoZDFzk4UH71Y7zT+C4S70zGX82Zs2PWuhbEzDmG + a2PO7H6cvbKysrKysvKzFvu+Q/uZxzhE1WEqD1jA3R+HrcDr4GV/F/t9/bOA9g7rR68//q1eQ86O+U0d + g1+8iqn2s6JovbKysrKysrLy8xH/2cEvXr1pB0QeonhQwgEqbByuZj5+6ean8XU3+AWcr/x671Suj9cb + Pm3dB+uFtisrKysrKysrPw85B6JPeUBy9cNTWD0shUoearj9JvX78FH1d5X46zrzWnFthl2uVXKFv/0p + XvvKysrKysrKyjvJ/I1rUzkYuc5DEzk4OL599C/H/NBiP/t5rqXegcW16XXrNRNzC+yj1y9/i3YrKysr + KysrKx+u8Oce47DUlYcm93lwciwUh6cP6m9Fv3jt3ycZ1zYPiG5xHwRP7tFzL/ev1aysrKysrKx82MLf + SuYBiYcmPxj5YbEflqgW228gf4gf2/o7sjeHR49xUGRO1e/Lyf3yN3/0wRyoV1ZWVlZWVlaa2EHpqUMj + cT08JTf4H/TX1/hX/nzxyt+ZtWvP6857Ugdp3A/h7UfZKysrKysrKx+g2DuH/rOLcvCxA6IfivKQFDn6 + jO1jXrT5oIV/BzzvkSnuDe/LvFfU9/UrjFZWVlZWVlZW3lnOwecTHoiapc+DktvyT/5n9cXZcYi0dyJx + D9zWfSoM9yfukdmv9reyV1ZWVlZWVj4YsV968UMODz7p64FI/XiH7efwV1fuDn3zZyJdcXj0e8SDo3KO + b18PhBYrKysrKysrKz9tyd801gMP46N6eEz8i1dvUP5Bin+kfw58Lz5/+SWgJvbl6HrP2v1pOA+WdoB8 + ud8NubKysrKysvLTF3v30Q9ConHoucP4zuOHeRCya7I/Q3iu8cu8B9/wCzDnPnxZB+zSuF/xTmTcszpc + frTvQq6srKysrKz81OUccvxnH+Pww0MPfB56gLue+MVnP8yf6bOfJ7TvSfzF648/sb9FbV+8bWrv/D3i + i8j98BwfR39yrvkNry+v167/Gw6QeJfyq+BFXR0gA6PP+/ni81dfoXxlZWVlZWVl5acndgA6h5r4rWIe + mIbPg1AeKM9hD+XvJDh0nQPiOXjlASt69wOYY2+N+0O82+nXeg6l1s8Oq/Yuqh72fD2bB5rXfbhocSv2 + N6/bdbAH6qt/5F33N7JXVlZWVlZWfqoS3/t4f+jRAxEPPvbu2fc5zPm7jTi45aFN1spDm+TMt58dtIMa + 2nxrsVntGv2jZusN5fXk+rhmzkU/cr/7OxwP79NeE6rXFHms+S16rqysrKysrKy8l3IONv63nuOwU5YH + HdU4GL3bx8p+kLOPqNnH19B1wtfDl3LCP7zPP/5W79zZevZOox08tVdcX6zHnr4m/Jop+J7/Foc9Xw/f + D8laXkf0oF/xh/TnHldWVlZWVlZ+JhK/PMPDmRx65PDDw1XE7/aumR2uTg//+cJaD4c4YMTbevA1HzXf + fIj1j6n5Zd/ok+ulX3PoDLwP6n/b67Zfjqla1lf/tNbz6IvP9m9kr6ysrKysrPzExA4wfphph6xQHnI8 + h/y7/uLMR1+89N9o1rXUxpq1vuMeh4YfBzBTOxw+9bel7Xspo2dw6c9rYu/k0Xpu3oNvd4DEQdnf8Ywe + V5trBfZBfw3SysrKysrKygco5xATv3WMAw99PeTkYecd3330XzCJw1L0kv7tYAXVOGfK+FjW38zjh0fW + kS817N3yjhePOa9J/Ntfu/9yUPaK+lqvbMyxH2OvrKysrKys/ITEDi560IlDTajjQ9/1t4bt8KVreC/t + axYHt+Borh+4iJOvv1SjX+o9e7CP5fpacq3Aq6bw73KAxLuQ6IG1rYdjod4Xar9UhNKVlZWVlZWVlfdb + /LsPeZDBwYpxHnSA2UfGKPtOYh95977XA1Xlak3izoXvNVkXPfiuqH2cbb/ZrX2S42uiBxV42MKYZy7j + 3/E1PlP4MfqlH9dDDrPe/pWblZWVlZWVlZX3TuyQw8OMHqYcq8MNDz7v9L2Pp/7Lu8NTrVHv0uVakiNX + eTVb1Ng7qS/wZxhZMzlVhx7elz1j3fSh5IV+t4/v7Zd4skf2Y6/qjfw7Hc5XVlZWVlZWVh4u59AVfz0F + Bx0edsIP3PUcdOyvxaDsW4t+lHvX1/yeq0OVxtnDfM+XBf5J/sY1lByt5doek4O4sJqx8b/jAdLEvj6o + 963eNVvYd7m/KysrKysrKysPlTrcxWGGBx0qDzyWs4Mmyr6T8F04VznMsW+uabnM33CB0Wc9ecyrbVxw + zJ+qfWct4rf21Tx2v3BZ31r4m+dU9pzrmdrPb6JsZWVlZWVlZeX9FP5mdB1g4lBzZ+2jbpR9JzkHJP/7 + 2ql5QAv1ODE70Al2NHgyD7jao+Uthzr6F9Uc/NY7rP2VnC+/758atC88rzXQH2vkvIiPfq8/DbmysrKy + srKy8qOL/eYvDzXtMCNquB/S3vEgZb/gkgczUz841XrsTx8fQ3/qXwJ+DrimdgizX2DRHulPRf+Ljziw + ftDMWezvYttfrZHf6v6+Yh9Le2+/TtxLWy/Xlpne4SPylZWVlZWVlZWHyjm4xLuDOMyY9VgONTz0vOv3 + FPbDEw5uskbkYc8B6qkvBjfxQ6X/TOG1R/WqNdw3XBW49cDh9hPriyV+FLFDsc7C9WOWmunY/UWalZWV + lZWVlfdb7B0vP8CMgxVjtSj5TmI/M4iDUan1PBprSe5bvvuWXwnkPXAAQz/2ct84yDEfXDs0/rgHxim+ + ps/F+eDjGji3KUpWVlZWVlZWVt5P8Y+FcdDigY4HsWa/5eFuin/83Hry0DTXefn2u/yCSv6Vl6yvvlwn + 9MTA7V3AH/Kj6e8iZ4ZPOA9n4+z0Y85X7UvRV1ZWVlZWVlbeO9EDTR5kTHkYO9b1HX+Bxg5D7KX90vd1 + z+HuHAhR8q2E72x6H/Tg7IGXH+u8fPucX5HjB165bp27sJj5Xf/O+MrKysrKysrKQ4SHLj3M3WH2FTYo + +U7iX+FjfdCremKtE5v/Lj9feQ5l/ldeqk8dyrhGrvngj6yn2C8g6Tx+TxkfjTjm3ncgV1ZWVlZWVt5r + 4QGOh5i0fujCAcc473iAtLrsZX2wFtcxffH5u32/pP8JRu+Jw9jw5VreoOTZhO/Eci7e15ix2+/6buzK + ysrKysrKykPFD1g4uMQhBu+E5WEM+Xd8B88PkNJ/HqCs/4vPX77T34C2dy21N2fl/FzjxWfP/+XcfoDE + PKmMYXP+PUCurKysrKysvM/ihxcqDzF6uAH2rh+r2rtp2tP8/g7h9zsw1dzVr+YO7H3484A8QPKQSI37 + 0bF9B3JlZWVlZWXlvRYe7vwgx4NMHsDicGP6rgdIOxzqoU4PSqbe+3scmE79m5wZljNH//fja3Hs/vFA + m4p7EvMWtu9ArqysrKysrLzXwoOjHm7c94NNWMO+zzuQelDSNTz+ngcm/yLw7Fn9M37Hv9/9Q4t+dyU1 + r7/dl/NvsQfIlZWVlZWVlfdZbg8wjHnYOf73OkBmX66ha32/j2zji9BjZp8b8+bs7/j9lT+0+EfYZ56a + FfPJfaC/H2GvrKysrKysvNeiBxcecDLO3DnkffFuv4hih6HZq9Y62LHf/wAZvXX+XOs9OUDG1/jIQVdn + VOx73o+VlZWVlZWVlR9d/OByDi08vOjBRu27HmriACm9YfXA9L1+iQbvQGpvvY735R1Iu8a83nHPGZuN + e/W831m5srKysrKysvKNooeZOMAghsY7ZN/jAPnFy19Hb/Q0S/X+Z83veYDUnpy/ruX9OkD6THntOjdn + Pvf6s/0i8ZWVlZWVlZX3WPIdPBzueKjhgSb8dz+I+c/+oScPdvRL3/2QxwNkHL6oMb/j78kBknPWfY45 + 854kvgfIlZWVlZWVlfdc7IDlBxgcavyQA9WD2It3/G1m/+3j7BcHPPo8PL1rbxM9QEa/sxYOY67vyQHS + rlHvAbUOjjhQHkXJysrKysrKysr7Kb94/fEnPCiq6iHMDzrH/vLTP/prKPvWwncgeVhir1SuYwdB0Y9e + f+za4+6bffHFy7fRv/fkOvZnEv3nMKHmM37Kfyp2//OXv8KlfWux+xYz4pA47gN95lG2srKysrKysvJ+ + Cn9GkQe5OEDGQSZsHfze5at87K/AeG/vEWvkoQlrZmx+ziF5r41ZYi5iHY86YlVbPe+011MZVz7UDrC4 + tG8t9ksx2ZvXhN68tsy9Q/+VlZWVlZWVlYeKHQpvDzLtgBOYvQOHsu8k7DsPbVwr4liTPPo6S/XptqnO + foNN1fxFczaud/T1x+9ygPyE/dJ6b/YPa7kXX7z6FGUrKysrKysrK++n2Mer/fB2f7DCQecNyr6TeH/0 + Ym/FMk7/cPyAFVZrVZ1PHvysd6u+cLymuI2DXGGFe/wuB8hz37L/sfRDI3Y9a7zr922urKysrKysrDxU + zsHlKz3M0PcDjx+oeNj5+J1+DvLUxd+r9p73azB3xTjDiWnBcw54quRUHAc32lkz+YpdZ/luHzH/8jd/ + +HtWZ/3YK+Lh23onfpcfE1hZWVlZWVlZebicw8uneYjBQSYOTGWZf5dfIvFffMFBKQ9rtgbWuagfrO4w + zGBWa6UXOc1Hv7qe6nPhSx/NJf4dD5D+M6acDz3Y3+KaKfIoW1lZWVlZWVl5v8UOhXGYuR5qQvWQ9d0/ + xraf68vDE9aZypysEzGwNotgWhe9Kr61N372AX6Zyzmc8bsdIE/dm9knZ+Qs1P0FmpWVlZWVlZWfitjH + rDw4tUMONA9Aznn1tfFR+q3EvgKHvdgjD1CmJ661I6b/1IGrzXjwiOugRo7GxRNM1fOhXIt+4d/+kDd/ + A93nQazrcs79+ceVlZWVlZWVn5ScQ4y/U8YDlh+WTG8OPEe/028K69fY8LCUPg5XXIfrchbncgbPa33x + W43yrA654lS9c0Szjor69L/DAZLvvOqa1MD6WnbgROnKysrKysrKyvsvH+XfrK5DDf08/Mhh6Lu8C+nv + xKGH95JD3V1vcomnBWfmo+7g0kP7ZB6+9rna8CfPfM9/ywPk5ZdnrAe0elf84nv8NZ6VlZWVlZWVlWeR + OPDIQQkHmzrkyOHn2HPg+U7vQrJXrsHDmaxn9urLYQs1mR99Ihc6eyWOmqbgVX3hPW/xtztA2ruPOof2 + a3jmP/4EpSsrKysrKysrPx05h5v4hQ8/5MTBJg9U8PXQ813ehTz8N3qIMsu12C8xiWOWK/YkDt9y7SAI + jLzIx/rJpV7yrD/6LQ6Qdl/Yy2usj8UyC2Ousx9fr6ysrKysrPwk5aPPP/4VDzc8fOXhh5jbwE78JUp/ + p9hvevPvSefflZZYsZlX/CllXq3WTP+ON/3Jd/0WX2Nk94X3r+5dHEYZ4/45fvSdvqB9ZWVlZWVlZeXZ + xb4k/MUXL9/mIedy4OmHoDgkffwHKF85Mn9hyO8R/HY/9T6egzvKV1ZWVlZWVlZ+emI/i9cOO8fyIFTv + mOHgc/TF65dv3+Wv03yI0g7guH9xv0IVp+79W1lZWVlZWfnJC397OA85foC8PzxW/uW3/ij7Q5YXn7/8 + kvfu9l5J7Lxz7+wjcpSvrKysrKysrPx05RxqPo1DTqkffuQwyTgw/xqan/VByL4EPA6NdYDkvUnc7hfv + neu++7iysrKysrLygYj/FjEOP2HroKiHIj8Qtfjn+fOQL37z6vfn/ZgHbPrE7Z7uu48rKysrKysrH5T4 + X1Hxd8nqgFhKvB+K7Of/fm5fR2PXy597zPvhB8S6Tzwwlv+x36t993FlZWVlZWXlgxL/hZDX9Qshduhx + H9oPknGwNN7P6RCJv7DzltfOe+Kx3CPGgdHu371eWVlZWVlZ+QAlfq5PD0R1AIq4cLX2s30f+iHS33k8 + B2w9HLqeg2QeuM0nJpwX+2cLV1ZWVlZWVj5kOQeeN3n48YNR9z2+4PER7Yf6M5F1eIxrDY1rd3Vc7gmU + h0r7mUm0WllZWVlZWVn58MQOSzz48MDEA1JhdWiipf/isw/ro1r7SzT2DqveB79WvxfE4n6ZPzlH929e + r6ysrKysrHz4Eh9lx+FID0bNZ9wOTlFjv5DzIfzCiB3+5rXF4ZA/64hrP/dAfal5s784s7KysrKysvKz + kY9ev/xtHIzw7ho1DkZySKpcO0S9fvXVT/WjW7wLGx/lt+sO32wdIvFxNvzifvz1h/5zoSsrKysrKysr + Tfy3sv2j23loCg2M78rVYYoHKFfzX7/65KfyLpzN+dHrV3+c1+jXJNfisebqXlDzMPn5y/171ysrKysr + Kys/P7F30Pjzfzw0UfVAycPU7UHq4HYQfd9/NtIOfPbb0u165Bru8Mp13D7CR9uVlZWVlZWVlZ+f2MGq + HZ78cKgHqtA6TD19qDz6lfV7n96R9F+SOXPZfH4dOi/ixOWa9FqpwX/5W7ReWVlZWVlZWfn5ykeff/yr + dpjygxRjHJwQJycPWWU9H9y3x//E/oQilnio2Lr2i0Jnhq/qevphkCozR9z4wIqzvzSzsrKysrKyskKx + v6RiByUenPLQBKt45umPfGrEb+zj7V/+5o9+1MOk/3yjfUz9+csv/dDnM2EGqs8bB0fncH7Mqngq8OPv + 4XFlZWVlZWVlZcqL16/+OA5MPEzVIcpsHsiIQYn7QavhOIy5f2x8lPyJHfS+728w27uM9sXm1u/0f+Pr + QHX2spiNPJ8peJwzYhwijVu6h8eVlZWVlZWVlaeEH2fHwSoOW3XAwoEqD2DMF6dyOIhJrDWCn8Off6XQ + J3aAtd+Spr3qy9/61w9Zj2uf9M0yzvWUI7zih89rkWvaw+PKysrKysrKyu8S/OIJDlJx8PPDFrQOWHXo + CpyKGo2lNnA5pIFbuNb3GdxHr8rTBy45r1NFjj5nYA/TiG2dl7/dw+PKysrKysrKyreU/hU/eriCz4MY + Dmx5WMOhLLhx2GOPsNTimGY/VenFmP0s9hywiNFXYtZpzcS1D/P7VT0rKysrKysrK+8g8XOGr/wvtujB + LGNqHrzi8BVxWWrVxqGNPWldwZmq9bPG/RbH2srvtTrLyH/x6q29A4tbsLKysrKysrKy8i5yDlifxKEv + Dl526Lo5eEXsBzQc0m7ys+6Ol2vNelHvM33v3w+rqexldvIQH//N/nnClZWVlZWVlZUfSF589ur3z0EL + X8gdh7s8hNmhTA5qmi8stHEdix7MMVYOa4rbayKH/re+cKmMyXv96o9xqSsrKysrKysrKz+U2C+U+Ff9 + yMHLD184oJlVvB3QLHfiOtD1QyYxHvSY11z2cSt94VPJn7mqORaz2C/K7LuOKysrKysrKys/stjPRp7D + 15ftYIZDX2j4fgCUQ2D55Jfvve4sfSox4Frvvls5OIIbawE/sf9d7M8/3p91XFlZWVlZWVl5pMTH2i9/ + G4dGvOMnh7nA+iGOPg965LCWGPP33MCmkt/q3YaP9ffguLKysrKysrLy3PLiN69+/8XrV5/igJaHvjjM + 4SCXB0HkoBrzwBd1PDACQ95j6ZVrguOK+sTDvtnfrl5ZWVlZWVlZec8kPtr2v6n9lR3cePjLQ2Ae/Prh + sB8i4euhUP2jyte4HSaPffHFy7d2sN2fcVxZWVlZWVlZ+QmIfxF5fP1PfY+kWxwmBbPDnuNuw08esKqp + +iewt0c/tb+TjVFWVlZWVlZWVlZ+auLvTH7+8lf2113O4e4ND4h6MMxD5PHdysGR3MpXjf0yzIsvXn5p + 73zuO40rKysrKysrKx+w2GEPPzv5x67nEGi/kHOnH73+GBpce3fRatFqZWVlZWVlZWVlZWVlZWVlZWVl + ZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZeX9kfzeytev + /ti+Psi+Ssj+qo1+F+WL1y/f1lcNvfrk5H+9Xy20srKysrKysvIzEjs02kHw6Ff8InP/snI5NBqmfsaC + +yHTD52vPrFD6H65+crKysrKysrKByb2riHeRbwcGutQKIdEcNJnTeLUqIX6u5X8EvRffvpHfw3Lr6ys + rKysrKys/FTEDnHn0Gd/q7sOgFD/U4lucYiUXOPigHjXg8rDZOjBoOcw6X+C0f8Kz370vbKysrKysrLy + fov/GcVzgKsDoFg7+Llf7yDGIVBwcFJxUGzYUa1hXWHHetwOlm/s74XvR98rKysrKysrK++R2MHsHNTe + +oHNDoLtUDfebTR1vHLpZ01Y8uNA2A+L6mutxp5Hvefov7a/BY6Pvn/zR7+Hy1hZWVlZWVlZWXmE+DuP + /tvUeNcPBzs9tM1DXXD1UCcWfucWTkz5iYHjlpjzJEcVbsz/8ks7VNpH3/vzlCsrKysrKysrP5L4zzx+ + 8erN3eFtajv0TZ4e6MAxftnon+s8pajPfkd7H7Pog3UmL3D33xz803Ow/PV+9L2ysrKysrKy8gPJL15/ + /EkdwKg87OFwhsOcHtCoyQGutfQZJ8+UXOvjeesdynjy6SfPsLEmY62PGPX+m+Uff/LR5x//yr6iCLdh + ZWVlZWVlZWXl2wi+41EOWnrgkoMcOHoIvOCT80QN+zKXfcA3y5rgI8c89ZYPXFTXC46u735+ldB+9L2y + srKysrKy8jvkHJo+1UOV2tDuK8dVDmhlA3cVnBq9DoZ8x+kDR3/OMXNzjeBKf+Hc5huO+OAvPsdXCdlf + 0flsv0poZWVlZWVlZcXF331sByg5dPEwhQNVcEInljzgPIx5P9hS1OgaqKla4Q1NTLiMtafW5nrCybrk + 9D6cQXMnfnNy/tH3/jzlysrKysrKys9SXnz28td6uDLfD0s4ZBGnf8fNgxZ47sNqrg5hcnBrvcivPOu1 + lv1aD8+F7xZamFzTVOT7GvTRI/GKQ1++/Uj/is7+POXKysrKysrKhy7n8GTvqPnhyA9EesiCrwcoxuXX + gY72rpY644tKn+h9vya5LZc1xNDTFNyLPZo8w4DrGsxfek6t3l8dXvwVnc/2o++VlZWVlZWVD0jw1T11 + 8FEVTA9NdUCTQ5wfsuIAR59x+llbOHtqfXDUBsftybtmHj28rvDikFfW+abgRG3NMntqrJzslbziMk8O + cv5XdOznKfej75WVlZWVlZWfrNhvG9ch53og81gOTunDks/arIdm7P2eyI9ewQUnczf1lkO+8+7rNR9+ + 9Wp9RYln/vQzv6vi4XPdWl+4qv5VQq8+2Y++V1ZWVlZWVn4yEj+3JwckP9SEvRx4yLO8+6HBFd4N5n7W + 8TB1PZQxdkVtYsfGmn0G5qNHxVrb6pTD2DlYn1xylIuY65CX6w7VNbW/YdWjsBevX7598fnL+Oh7v0po + ZWVlZWVl5X2Uc2j5xA42POjoYWYebmiVy0NR9LjnOAb1WHpdsBknRw6YVMkVp/DAqKg9Oe3jfODMsUfm + oJkzxRqMNRd+XX8oMONILWuKq9cSeg6TX/GjbztU4p9uZWVlZWVlZeV55KPXH//WDzHtUKOHn/LroFOH + IdYy9j6mzCnmPOakr+Sd/23V62XdY9s8mkdOlfisVTy4dr3ls6/2yFrUaC17pYWvfRNv+bBU7WX/bsfu + VwmtrKysrKysPF7iAFmHrIvaYcXybiN2Pb7G7NF6Ja8OW2aLW7V3mPbtazBmT+Lgwg+N+KKnvvesw1xo + r2U/1s7cva+cyIWCh/Wdx543M117sUfl7KNv/7fkVwntR98rKysrKysrP5b4L3HkQaQOSGlxsPGcHHIq + Nw5Flne/8hm7jT7FY72sjXzgnXtvn6gb62jsqvHxrYY9GZvPXplHXcvTOi845GfP5Mks4GkcHNaSgz7k + gaM+88Ttr+gcP/6Kzn70vbKysrKysvJDCQ+QPHS4zUOMHoSKk7lmo85iKvP0L/zMR23iuWbk2KNq0Q81 + aT2HfMNQ632nHzXksq7zFOs84uVXLZVrkVtY4aytHseXNQIHl/3Eso487R1xruNfJfTR5y/3o++VlZWV + lZWVdxP7Cyp5+MCB5HLwsAMKDil5aInDyPF7fMcNDa7WewwlR+sqRwz5gXeMa8ncUNZrn+KPHPpGHrN5 + D84euHOhDeN6sq73hGqt5ZWjfcInr3z2JdfxxMKnkuN1UNZGr5f10fd+ldDKysrKysrK7xI/QNpBAweK + y6HEDxiKFR7c4lQfwWDJtfrg0DIfvWddcpNTOdZkndQoJ2xgyVUe8Nm7cqq1nlv0ufQnhl6VD3u/fvB6 + X6wnfaha7/zR8y6eazQLjv3W9+HkVwnhobKysrKysrKyEoIvssYhoh8y7g4fjLvPfOXMdw56M3/BrQa5 + xFQNRx19wxnHWqGs6TnUmHoOc9MHv3HRh7mshwY/8k/luM7Vj5hY1cUsuSb8W86Ikw9c9X6tsqwtLPiM + U8/jxH6Wct+hXFlZWVlZWakDpB8SyvIQ0a0cROTAwkNI+MIzTHqaXg8qwXXr+VFrivh6qAnb14fPOqrG + I8ca7cO4z6hc4ODTbz2oI2bf8HG9ptm3802LH8q1gl+9Zr3GWldr9fXTl7jqDzfq39jXB+1veq+srKys + rPxMRX+JhgeEdnBg7AeHOqi0GvXB81rBzK8+ocUFZ/DcB9c5sPQ1X7nBkZ6O3fQlN2LUkE9Mctk7cfK4 + fuWCL1Zw+qwjNtd1tZz3AJfYsRaznr7O0vqjhsp85pBPLDmhWes5++qgV3+8B8mVlZWVlZWfmfAAWYeC + 64HBDxPq46Bx4aBeazzv3N6DeO8VPaavtnrQyoFKcOdmL+AeG5+z1YysC19nDZuKvvTZN7GB917wkeda + 2kP5VSdWensedczPNdyHeg785GZt3Beq9tT6zCOO3Mu39vOSeEitrKysrKysfOii70DSxiGhMB467g4e + hfMwUflWL371Rw16JIc6McRRrweZ4rC39kwMePcrZ9Z7Kg4/6zJXPNamFS598oJz9dkvfK2V6xG8+UdZ + 71zRrIefdcBS2eP42kPXfqqefP+Ti/tLNysrKysrKx++8C/R5OFA1A4GkaO9HlJYx4MGbWryJCZPctW7 + z5E5WPZRTG2qrEXrHMZHcyYo+3NNanJQp1zt41zGbvtstK7aD9ryjMdad7ziFM7a8CU/1s0aw9GHNRHf + cCXHfPTP3Cd4eK2srKysrKx8iMLvgfQDhB8Ewo8DgRwmYBXXusjXYaT6sEZwYK1m6pjBtPVSHeuZrZrg + Zy/kMhYOa4hljFnUz3W4lvpHJ1/zzF3XjBx7F08s+0ATQw197UU/eVSJdU3nkuM5xNJ75rQGa77Zn41c + WVlZWVn5QMU+wtbDAw8AdRjoBwrGjs0aO2A4hnr4mXsCZy/myMs+Gc+1e637YtO3PHXURDxqT85smw/c + ypFfsfrsVT24FrnXHJV9Mjc4mYcfts/DORXTHq6H44o819GeT8Xhaw1zgZvan1Lcv3azsrKysrLyAYp+ + hN0OBsfPQwgOCY4ljhww1gUenFTG4M6aO3/aUGC+vmLSP3PFIeZ58sGd/IhLk0dfcVP0mHXOQV31r7jw + npv6TVzmwh8Y5mGeyh7hi8Ws5LhPTCxz0ef4d3X0Pffy7R4iV1ZWVlZWPjDh90C2Q8SNtTwPDXXw4GGC + nH6gUI4r+rScrEFf18gat6N/8sFxKzOZop49Lz1Ec12sNXum5rpcS+YVrXW1b6/LWZ7oSU7vpZzwi9P7 + NJ6t4byKyStLva9PPPsER+PkM3cOkfsF5CsrKysrKx+Q9I+w64BArA4BlbvjOl8w8iqPwwZqkwO96+2Y + 8BPLuOo7D75j1fdJlbqJKS/WD7xZzxWPMdd2m3jNwx7kJE/w1usmNzH25DzRl9j1nmY9uB7T95oneMCL + x77oAUzi/ZnIlZWVlZWVD0XiI2zb7OswoAeBdgjIg4H684By9VVjneOjvvDgaw19rp8592NW2sSkb9VP + G9dEdT76O0f6Z531lTWYjx7BUw2c3KqNNVgLP3uHeg9g6muuenVOcWVOw8Bt+KwdfWIN8BI7dsbmH5v9 + gbGe+uKLl1/iYffsgnfeP/G/qLPvjq6srKysrHw3qY+weSDRA0ccBgIPTDUxOUCE1R7gAPfY17vm6Be3 + +kzNnOTZ22OskRzGztP5Yt1cTzjJk9rI9TjywWWPrBceMa13izrizFVNWeKamxhnzlhsrKV5wRgnVmtP + jPVRY1io9tA61trf08ZD71klr7P0rf1nyr4Q/RevP/6Dfbd0ZWVlZWXlG4QHSNtE4xBwfGz4bYPFAaBt + vODNg4IrOFFTdeRa7L7XSyx+xWNdU1nDNDm6Pn2NwTdf+6u95qXOY/DQm/lcHzGx0JivfFwf+eyDnlVP + Ljm19rVvxVUPH317vVyHcNw/6nnnMYYv/NZDlLWuyj32ffilmpgHsx1Vn/Pab5F/9MXLL4/+er8gfWVl + ZWVlRYQ/A1mHBRwIsImardx1oyV/5rInMfSK3MDRW+PiVi/nIMeZWix49nNM88VhbSrqtJY8xTPvuBzw + PKd+cFwln1Zyxm3Y0egVfPIUz/5mpy+YzsN+inkd+t7luFblub5q1LCXK2vUN3sec3j4PZtc5pOY16Oz + R87tm4N98tHnL3+1v12+srKysvKzFf8i8bNJ5uY+bG6uYyO98pm7x7WeeXK4fvTVWuSh2WvEre4yZ+EV + F6d4sia4NVfvS185iXsMDH6v0QMK+de1iye9xbLWMWjwBTd7NHuAU1zprb28RuKj7M3+XntT16wo+VzT + fvYQD8FnkXZ9uA5icZ24P8iRWxzcO1P7Txg/+t6fp1xZWVlZ+TmIf4Ttm+B1A60NEkpfLDfZu802FfnQ + wrPG/eKSn/Elp/16z0u9cyvvPvLkJNdqk4fZBCOHuawjf9i5rtZNP7mOFXeuk7HlEKcP1XzWel1p5BRX + Xt0b9gjtMXu0POrZq3r0nH08jIfgs0jOSLVZZb68HveRh1XOHe5/E/yLl1/az1PuR98rKysrKx+k6M9A + uoXPgwF93SDN6uaaXPYBNn1y2MeVa7IWttaSOHOdV1weZIAJX/tkHpjxGCc+5mBMLmcIX9eq3rRZD37k + yAcmOXLTV+v8iLWuNPLV/zqD9gkVzsRQw37Ma07zrU45M2/+5y+f7V1In1dmjGuu+dwiT9+s+qxtCizv + EeqPvjkHyk/t5yn3o++VlZWVlZ+8xM9A1saYG2ZtfEdjU+TGqJtj8KrG9bZPcZOnihquQ7969Npck9zE + +8ysD784WSP1c41WLxg1ZxDcY7GWIy8UXLNU54cf3MA0X7xaL31VcHVNxSNXdZce6Mt5NG44NOulP2si + T17lmbN36vAwfLjktXBuscz1mRGDl/XAlHvLgXae/+ftk/3oe2VlZWXlJyf8Hsi7Tc43emyOpR3rdbZh + 8uAQvODWhuw1ucEyrzzUNR57AhdtfCp7wr/mqibXFN9q79caNdaDCjz5wC6x2LaWxPSN13p6XH72Et/5 + 6iPf+t1w1RpObXmq8CdX75HzRLOf8yL/XB/x8j7zOmK+8hlTM89rlGvQHj2PHPPArI61zkn78i1/ntLu + y36V0MrKysrKeyt2gNTNLzYz2+Aqzk0QG2DnIhYsfdWDsaduoIHHeuzluSdqMpcY+MJNH7ngaDzXjp7s + VRqc4KlWzmvNH+sqdrHQxvW45nLFTPSD03nag7hjXqu8PifzykmecBJDPPnUhrNecLOhlQPvUzwUHyo5 + m83Q5oUv+FPX1uvi2shln8CosV6uO3JUrbefFbWPvl98tl8ltLKysrLyHkl8hF2bmW5qsdmFNTy1bZwR + l61Nkn1qc+w12oN1ibd81ZLPvNcBKyVWs9BOjqv1El6q8KIWNZkLf/YiN2vAj1z3J+caB7f4wrEcFfy0 + RyfvGhf3tu5mzVYDPGxpy2WPqmeNr3n0Od5p0+ulr3PldZBHTHNHGwau+Rq7pS949jkx703g13uds5lv + /+nbrxJaWVlZWXlOae9AmvpmFpYxc4brRsa8Y8bTGsfRy60cGoRTPYSTWMTsb5Y+eYGNGuS1J/HGVx09 + s5dwoh9iz1MxF3JVr9zINwtceW7Fzxy0rxk2cPSxOulDfmLHal3nFRb9hKPzSK/ox1mAq2ad9g6c2HP8 + Mk3NgDnaddS91LnvNK+BmF2vXptZw5BPninwWK/6TJ815FFZ/+KLl/5XdOyj7z1QrqysrKw8RJ76HkjV + 2siwcTEndblJ0h71jc85dxj7Rcx8cGodcjR2PlS5kQ+NnFhR9uw11YOcjGWtyBWvcdQe5Tra361wGTcc + 6usAY4/beuQ0do7GjYN6xySWnNvBnT21d8TlFyYcqY1cYC+e4WPsOZvNElr3mPPprJEnFlyN2a+p9oCl + Mtd6J5/9o6/6raf2OIdIXOLKysrKysqPJ/waH9+IqBq7rxstN7PKlQ8cMWvSFw7rusoG2bAe0w97Yl1b + 1gq8+NGLsfrshVr3I3fnt3UcmxzVg2MO5c3Y1XnsUTzNB4bY/bqOwoTDe4DeoRqjFr3Teo62z2BxaHGD + R1t8+rHWwaQ/1d5Bw8PxYeJr41rMz5nlPuh1UJVnvnJaLPnQWRtadeFHTB3rc6ZjJ05/D5ArKysrKw+R + +C3s2uR8E5qbkm5w3MSAk+N81LBfxZHTHqwzrPKxDuunVm/lI0aOPat3zFE1wMBxlXlMiyu8wdGYa1Rc + ONdT7MrhjGWLN/JW5770G7UzzzrHTk7zjN1nDJ98tdpvciPXuVdezMca5h/90WtbHzPE3Lx/3SZH+MW5 + 5/NeMA7s5IGbH7VXXvHhg994g++99gC5srKysvII4fdA5saETak2tzgwKKfFtnk5dq29xFD62Ye57A2O + 1T/Zc+ZHLeLkHCVHMV/X1POYRX3EZltfiansXXnO02Pvh55NiTOnlv7RuU5gldM16MccwdEeWs989Kje + rliPdfS1Z64nmjXIU7WP8x78c5AxG+fDvDJPzjpyys3c0cjhWpD3GH1iLXIDaxxialWTT5U5Nb8HyJWV + lZWVRwgPkNzIapOTjX9occUCDx09hNt6pC9WOOl7ffhmlcc4MefGDLU28uQgx5qymDFrrvMrRh77ZZy5 + g2Xv4FUu4s6J3pUrjNw7rOqjztdIXuDOwxrFh0+VurDk0UoP46oahzWwrOu9UGux45jh9atP8JB8iOg1 + mq8258K8qpj1+GG1h8eSSz601/f+1ae4oVVfnMCrTvruAXJlZWVl5RGCrwTxzYebEVU3uMSwUTHHOt3I + EicH+chd+errBuo59Kj8EzUyx0UxC2Pt0TBf68RY03M3tY1L1ZqMCws/cqwvvK91rat84frvUnVpnROx + 1yL2+sapfuS5sm5a6OxdePS/YLC5jnHAi5qXv8VD8iES644ZLzNFrHPf4byv5ASPGGoSlz6GtT7FI+cy + o/leQ9vr7O9v4xJXVlZWVlZ+PMmPsLEBUXNjks2KuHLcR+5Oo0/n1ubXucGHz57O09pa3zmTB5szEz8x + e9f6skEbN/OcOXzmtD44xWNt1decVcc5WFsczYd/rK7L60jsukbGNxy3wJuFBldwWPaI/oEnT2Ktrxqd + D3n2pmKNR/9ZQ59NZ/E5Qi2mDV+uB/N6LfQaRx37ug4sOe7jPoEXc3CtwpwjahxqYnuAXFlZWVl5hNjX + +NQmJRsZNjbdwHITy40u+OSFrRpq8UKbL72orHPFHOQpHrnyI66ZaFkf/uE53uuyr+cwg+Dskz1GP/aZ + HGLuex/gsKxXTqrwaJ13fK4RdswLnmrhZalZK3WxxswJBg0+/R6zrur7NSrPcnhIPkTmdXCOmpXXUvdb + eZGLuF1v5iU+6vUWI5c1mS+rec4QmNw/tdnTD+J7gFxZWVlZ+fGlfgZSNiUoN6/YoPpGxg2uNi/hw1d7 + 53uM3r72WD8110A9a4ih1nwqazOfMbnUuJasEe7kec6x8pMLXua1ZuZgqdpDVbns42o+tM0G39dyP5R1 + OsM1V/OQ13og7nzmZT7l3fizxi3yeEg+RK7XGXM4xljnZ05m1tmVzx5P6mXNuO9aP9eiHznwgUcuavcA + ubKysrLyEOE7kH0Du25Q7otywwq/apN/NPqQU/lYj/m+rlr6jSfcxITrvmAzjjrBzB7lPPSZz55PYNFP + Zhx55XiM9apX2NSDBz/8iMsnr/VE3PPF4RqKVSwY6ouv/cO6YpaoU776te5dXa2FNU6Mh+RDRGeKWeta + Cw9tM1OFY370AD6w1nv0Yj7rgTMXfYrjOcTKY+0eIFdWVlZWHiL2DmRsQrKBiW0YlNzc1ARPXtb3Te/C + kd6dW3zWpH84PheUM0YeeMa9R66HfPmI4TuOnObVJsfUeCO+74M1jzLPdZXLdSZGXqsxO/IXzTpqXQNt + +tKXvLCqxek84MNPvfSuOjwkHyI5B9ae15Wzg8e8x5g9eR4XT23nRL1Z7f9UL2Iapx5e5LEO4z1Arqys + rKw8QvRrfGKzik2Om5Ni3MjcJif84nAzxMZGLvisYd+yodpj1qUCYz3xrDNl3bBch3UzLow+VXprfPq6 + L5Y+OZd6chnfYFlv/WbsXNQhFzZyrEkfMXkz7n3Ldy70/hpCWZfrO15c9uxY2ah99M9Axix9put8vE69 + Luchntcb10MMeXKpUtvXwfqoqT64t8krbuRq7n0HcmVlZWXlIeLvQPpGpCob2bC5kVEt53hsZKXFoZ99 + TbNGcGDKJWfmLzr6Oe9grQax621d4VlDRQ37Kpex1rAfecrneuqzVntoPDnu5+zVz+cU1ZqIg6d49CaO + 2oyx1shFjfYo3qy/zOG2fPLxkHyIxExYW+alzpzNGjNXPrC6BvfZS3syh5g9Kr7eO+VHXHW6dmjUOb4H + yJWVlZWVR0h+jQ82Od2U6OumlphtWrlxVQ253NCSd7Q2uuoR6xRfOVkDjFq5mo14y0ktcy3PWolzPWDF + jz7kEM8c8lqv/U2vvQPj2rd8xcTv68NHj+iN2T0uvGrCsm7OEfXkRt2MqcEtjvZOrvUVXDHnHB8PyYdI + zizXy1noR9yvwa/tUgPcLXoibvms05yuC47Hlbtg7I9+rDd/D5ArKysrKw+R+FvYsgH5Rlaba9/UYkNj + rja1yjWVfnc55jM+lvG01LaJoiZ5jNmXFnm/FuS1Vn3tw9rwi9dmQP6iNz2eWqfFR83nGqrkkqf10SOw + Piuue9aQJ1zN3/aAcpbWd8ZQXcN8Xov2o+Ih+RDJdW3OYzkXcfdbLrg6e1zPtb5dW9b0XMXTVi3rJmf6 + iu0BcmVlZWXlIeJ/icY3H2xEsmm6jzg5EqcSa1xsfNJDN73MWXxs3zip1403Vda6w2a9auI5V2CVBzfz + wU2O+8KjghOqvvYuX2O3th7XMb/xIqfcjsEnDiVe66gfdtZkLvvVNcwa1pUlD372qBxj8pnDQ/Ih4nP5 + ujVLYTVnzDqvGbH7hWcMq9dW/OOPdRRzxZrVG/X03Qa39Th2fwZyZWVlZeUhMn8LW5Ublfuqwu+xbnQ3 + daKeOzyPUe8x/eSV3/qKH2t3vHr1uPUkBh7X4SxRW3MVN+qLV9detnqFshYc7WV+csOnKt/tyGsPzdPv + WOVCWY8cfOV47TesrXbWBEY9uPDU0sdD8iHCdXV9ndFsvxeBpQInT7leD591Wa+cURu5GUcP1jDvnOyH + 2OweIFdWVlZWHiHxM5C1GemmVX5tYpqLfKj6sz42SvYILf7cGIufM8lGmT0Fv3DMH7lYv9bSnHIUy15m + Rxz9er75d7HgNQvvC9aGtlmcH8q4aqteY+1V9cghZi/D2S8scmYFn1j0DPyeI5Yct8RRA8VD8iESs/f7 + odegs5GTPmzimYvr8zrvQR19pab1Sg7x+rekr2tkDfXg+w7kysrKyspDxL5IvG9QtTnpZpUbm1jduNJn + DKz61WbYYu/XN1iuS8ua9AXTWapfYRH3a0uVutCxHpR1rR59Mz7a6j2vuZ5nbfVGL/SlFl+5YVWr5sS6 + BvyI73FXi4kdyz7sW35xqNqvccgTv+VErQ4PyYeIXlPOKDau4+Qk9jw5mFn9eW+0R7Psof1gyWtKXnLC + N8s1udYeIFdWVlZWHiL6W9jclLhRUbmpTRv+De59sKGy17Ti50aoOSj7ex5+2if47p8cawMPvmJa0zDr + C27ksZYpOTeqayQuNY5rj9mT8dE5D2sN13ka72jkr3jkjs0etMWb+OSw3hU54smT/LSZN8xjrX2Or/Hh + /Hq9Mitjmbnnqq7ljC/XTOzCkzgw8iU/+kQOODT7Hn8PkCsrKysrD5H6HsjaFGNTCpu+52rTUk7LQ3VT + a3WeQ+8bjuVUJ/+ur+aTP3jar/XKfOdnvWJuYxNv+cxFvvGOn5o8mUPiyxrudzt52rM0eORTL7jZURs8 + +JKj3/rAZ0yecliTGNYsrPJ4SD5EOIetnzPczKXzRVy21UpMTuFisWblZB2ZibNUrfQFrzjBt/weIFdW + VlZWHiLtAIlNqMfYuLBZUZlvPjmKw1440MgBlzrDQqOH5bKHxVDl3eVdUVuqeLe9Rv2aw2yupTXMOz84 + s67yUU+e5bjeZRbH0Ie+9CG/6vua1T/qyg5s1sC/VcvNvPehRb+j2ou42Zo3LB6SDxGdhdcSM9X9bNdB + v/HuriU4XuNx8aO2cHKUd1frGNVy8D0HLuM9QK6srKysPER4gOQGpBueanGKZ5jnsKFFHJZ85VRN5K69 + 0Ys1iRdG3LDko0Zri4c+yGcdrWA6l/ZyHzGVM1VcvOqHnpJ3C2xq1NGP2upVOdebXroG68hlXnPsRx7z + k6vXVP3Rmzh8nStqAkscvqvyj8VD8iHC6/H5OKNjtD2n1+Tc5OPawck6yVs861gTHOSJQbO358uPXOew + xx4gV1ZWVlYeIvVLNNicRK+bITHgyPkmZhzh0Y88fOLJq8235eGz71wr5uhc9xEzH1qz5XqmyZVrdM7M + VxxczlQ+ucrn2r03am54Wl8cXU94bb27fsHRetYUT3LAQwP3HLjRCz40OB27VfTXGdIOHA/Jh0jOLrPw + Hiie90HmJO7cg7FG71nk+3103/n93qlfWHGyh8zAtVv+6B4gV1ZWVlYeIvwlmrtNjJsdfeK6YU1lL7We + a5sf1iM2cmq11rHkKffeZ23PAXff5mAu/Ik5V9a8m4N+1siaxBjn+uAUn1ziwWm9pEb7zL6KZR/Jc83G + 15jc5F9rOAd98gtjHPzKR9x4yOMh+RDhrDk7ZpnzUS85+HpNyk2cuelPCz/WiX9frpPrQTXHfOoeIFdW + VlZWHiH6NT7cwHxTUz83qh4Ti80rbNaJEv/Tf/7nX//V23/z9V989c++/u//53/w9d/+R/9946hmHfIR + w8cMbZ0xp+cM83lqrtLq7VxgpYG5olZ7VW1wk3/DdSsY89TqUTMFHkqfuFn2pk+NGFxo9hkY69M6LjOI + kn+bb3P0nM4VcVn1rQcekg8RzqPXnv7NdXrc8sSVo379m95ff2Cay3jMpH2ozCnXeXuAXFlZWVl5hPAA + GRuQbnSxkc0Nj/41Di75gXf/f/jnf/b1nfyrf/eV5/7eX3z29X/zD/+77JmbI6z3azNVTmtanjj86tWx + uAZcV3LAQ8/yo3auH1jcC/qOo9650MwRV3tU12MuY+GRqzWtt+Aeo7a4GodyjfSJzxgc9s5+4KRa7NyY + X/lhI4+H5EOEs3H+UsyFa1Df1efvcfIkT06rF0sO1yw8+ImjRvtETvKss9weIFdWVlZWHiHtI2zZiGqj + ks0pMWxm2NAuShwc1jx1gJzyn/7Lf/76n/7rf/H1nx7+3/nzv//1f/0P/tu2dijn6TO5vawd85DrOYlZ + U7by5LJfxsynXzOYstdTNdfazqFmrfQgh1jWn5h+aMykmr2ytnp4TrAZu/U1Srlm5GUdwemX9jr2xkPy + IeIz5Nrj2s9sHsPqzJlTXPVSS17ck8wNHn1yyb/Ugct1lWu6PwO5srKysvIQ+ej1x/lb2NygfEOiTUzz + YVnDTSw2S+SggUW/b3uAvJP/DR99/9//2f/j67/zZ38/19aZOEPEfWPtXF5fxK4nlzXAZp715LbcsVGP + +HfwGV9qgCWXyl7wWXdb6/nqk/1QR27G5jsv4uyLOPmZr36pnutxYumPWmDmGw8PyYfInCNmuF5XzKyc + joUfsdezFvnmI64a7VMcxZTLfGr2Qs2J9wC5srKysvIQ8a/xwUakmx03rMvmRa7mBkZeWuTtZyB/SPmX + /+4vv/5H/+s/9p+n/Fv20TfW0nV1Fm6y3Jg9R1xyxGc8c+nfxarMeb9+P3WW7h876ljjOBVY76n/LsXV + /sELWzlgrPM4+E/VdY7EmSuu4dpP60zxkHyI3M1aM8Y8c27Oq6qY1zi/atibcWKijqEHuU/WKEdqGe8B + cmVlZWXlIRIfYdsGpJvTtLaJHR+bWOdig1Ne5uBj4/uhD5BT/tP/7z+fQ2X8PKW9SxkfffeZ5vymHmPG + u+ujn3rHsXrHw591jM229e4UOeOFjmtoONbJGmAS95rOCV9rgxO5wLwX+hGnX3XVj1jWgRd5qQdGPh6S + D5FYE3PKHMQ1TyUvfXDoR6y5qoteN1xZt/An8lhb+wYW1uI9QK6srKysPET0i8TNxkaHjYtqeeSIxSbW + 8643fG54P/YB8k7+/X/8P/3nKfnRd268mI8xZ/QcrpE8+n49A7vEx5JXvam4Z4g119YQXzV6x78Nbfio + oVpMjD40rzHjwrMPYudkLPjBgh8c5pjXOPPWR3opxj54SD5EdBbO6erzlE+c1615zj217gvyXoP7BZ84 + eYl5jBzy5BLX9dmTdXuAXFlZWVl5iOhH2LmJIeYmdYth02Icqn5w3KL++/wM5A8pf/X23/pH33+CrxLS + jVn1cs3EYelrvuVQXzV1X7LGfOVpDnWttmHFc5t9umYNelMzhxkalpzq2XHDEPu6lZvrTCWXfal4SD5E + Yua4ZzkTMfHj+mtetfRbXuoqr+tE7JjmwXdectWffQKbNXuAXFlZWVl5iPCXaGKDqo2Jm9WMleubl8eh + FQffawzzPt/+t7CfQ/jR99/7i8/zq4R4vW5V2zUWZlavOXhdPafKntLjklf/aFtD8pzH8+Axpp91wqev + OdXoAc5NravgjFlTKnWSZx0ekg+Rmhcz5Dw1m18HtPDr9ShP+ZnDWvRZW2sKjyrxXa/oEZjm9mt8VlZW + VlYeIvU1PtyMdJMKq3HXU4Nc5bE5Dt/0OT7CflfhR9/8eUpeQ11X38B5rX69vCe2oRvH7V1d5S/KXNZV + bPnAEEM9Rm3G5g9+mxHqmODBjzhrLUclH9y0zKk9yv7ZC3Hln+MdSJmBPpTXYpy6D5XT6wh/1LodmKyT + fUWz55iHeK2v2nP7DuTKysrKykOEPwPpG1Db4GITnBvn3ATv/djQ2IPx+/wO5LeRv/oP//br/+dfxlcJ + 8a/o1LWea2/3Su9FKOPgRV3zJZ892v1GH8Gaz1hVctaP6zAuH32P0p/50O5rrvVJXHrCZ159y+Mh+RDJ + GXQ+2JyVM2K+UMa9RmsZs1b7qAa3enkd/OIg5jqJl++K/nuAXFlZWVl5iNTPQF43I7XcxOg7X+KsPdo2 + RM8Hz74Y/EMT++j7H/2rf/z13/t/4aNvuyd5/XVPiKmlT67jvJ+w9KmNM3ryPoevfQub3JqjeIrRn+o8 + 1rc+hbNnzKQc8DKO2fCQfIhw7ZhNZ8ZcFiNX1xC5wIRnFjh95be845Enj7m8R9KTMXsFr8+k93M/wl5Z + WVlZeYjUO5Dc3PrmmBuTxYLlJghNTDiZB/4hHiCn2FcJ/dP/T3z0/Yd/9ve//pv4Kzp6L2LDD+W9mbEr + 751a6UOfdWX5b6b/juDTOtb/nbXec+BP32NwU5HPvoxFids6bWbjHsVD8iHCOdu1APN5iB1NDnCdWfna + y3yti7jqihdKXs+hN7Dev2zWH913IFdWVlZWHiL6SzS1IdXG5ZuTbGrkknfZ1Lxmbp5hf+ofYb+r/B// + 8e31r+jI/WKc6ves30PNmeX9D67kRbMH+pGbfYXTlTg5xdO6O7/W0NprrFyzpnhIPkR8TczB+WM2+nX9 + qsSd5/Pf3AdeV+NdY/MLD6s59vfc8ZM3cOfS3wPkysrKysojRL/Gxzch36Rkk8y4NjTymHsq9g3OFHU/ + h3cgv638y/+9/orO/wU/T2n3Ke4V7ttR3vd57+nnv5NxkFNlnj3dstdYi+sET3qKZS/2zVxioYpFXdji + 1UyOH8VD8iGic/l10DpWceQxJ31cR9YQhyWWeK4TOc1nL7PiK19z3m+ocvYdyJWVlZWVh0j7JZq5KdGO + DS00Yq3hJsZ8Ysda/HN9B/LbSPwVnb/0Q/b/9S8++/pv/unf9fvIe0uf97/uM2LcY1pi/DfR/IUjcSh4 + 8m9JLOtkffaIfOR03Z6nrb7siYfkQyTnlhk5CzGdj9fjvmPXayeesfNrHfpu2cv6ki+80OCQl71mjB7O + 3QPkysrKysoj5KObdyBzMzIMm5Or+LHBRQ252sM3Par33wPkdxX76Jt/Rcd+njL/nezfQX3cZ7/njJlP + v3L675QqfK3TmlDll6/x7OOWvchzG7jF5uMh+RDRGXI+n4NY+MTM6uzK1xzz9NmfPaOG9yW47JX2LneD + s5/m9gC5srKysvIQsXcgfePJTSg2N/rc+Oh7bmxqiml9xIXtAfL7i32V0F/85T/Lj77z3w6Hirrv+Pci + pnnhma//9lnnseYirzzWu6WPflqXHORbLBYPyYdIXEOs267lqOZyRvDi2vQe3VtXqdXeF3/wec8sH1r5 + 7M+6ge0BcmVlZWXlIcJforluSmVzE5PNKje1gSum9ebvAfLHEfvo2+5t+ys6uO/8d8p/H/y7xL9NP5yw + rvIDh2YdeORkL+TIU25gsq7nYzY8JB8iNXPdl5g1Ys5JPLmo63iPVbO/6ayFbXXkOM57hXVF2Zc5xvsz + kCsrKysrDxH7CFs3Kd3MYnOLzf6yyWHT4sZFLOqADf4eIB8j/Coh+3lK+63v//of/Lf5b9H+vTyufx+N + nedWcM3BdyvaHicjbo+Lmz54SD5Ech6sbX7GPlupz5ic4mZNy4GPvswpp2PKA471Hcc82k+5s/ceIFdW + VlZWHiL8JRpuQvQzxsblG5psYswRL1t49kOdYXagsYPNP/nX/+Lr/+M/vcWRZ+XHlr96+2/yq4T40Tf/ + Lfnvo/9O1387HpDKZv4oY/Z1K/2CwzgeI6yPns/wSzQyt87TrKjOnXWm6EPsztJXbt7H0VO5bh2Df7c+ + 1Dh7gFxZWVlZeYjEz0ByQ6uNjRvS05sj8jda9bIRymZIzPL2kat99GrvTtpHsf/pv/xnHHlWfmzxv6KD + rxL6W/8j/oqOqP67U/XfX3GvGXHUSw59Uw8Wj6NYBw/Jhwjn5NrUnLXNVtyqQZzX0e9Liw+H3KqtNchn + DfHqAdzrpS7Xhm/5PUCurKysrDxC5juQ3Li4UeUGZcpNqvFkowSmlptcYqjXXOHh29+Z/pNzqLE/EWi/ + NLLyGPnP/+X/i68S+vOv/86f/33/KiH++8S/Tf0bFR7/dhHj33r+mxN/AmMPPCQfIjE71z/WZpa5iRen + rjXwqlc+uY45t65V/Yh7Dfsyl/WYjVj2kDxr9x3IlZWVlZWHiB8gc4PCJonNKBSbFDasVIufUN/oTNGz + 5Ym5fYKn/eHbR9/28at9rc1+9P044b9D/ltJzMcGtf27Icd/Z+Wk7/jhAsND8iFS68vcYnNGwzwG123w + bmuRbznEpcGfHFfHq8edeg3qOAv77QFyZWVlZeUhEr9Ew80oNkhuRhl7buYrzk0sc7HJzZrgXvv2fGHB + RWx5cEzt3bG/8+f/t/jo+3//S//FkZUfXvLfi/e+/TvWv8fEZo56+feEWi0ekg+ROX/OJTH9mI9WH7vy + +ERec2GpdQ/pZ50q8JmLtVSDO9fcj7BXVlZWVh4i/Ag7NyxuStiYuJmFYuOignfZ0FDLXPTBxusY8lTy + j2qOfanZW/rSt7z9PKX9PJ999P2v/t1XOAKtfB+Je4t7zX+DY+vfJQ5DmRN/5tgneyrfOec/M+cA9OI3 + r37/l5/+0V/DQ/RHkVwTytl0zqbtOq5Y+iNX9yn65rUDmzWOoZ/WZf/M1Yzq7zuQKysrKysPkfwIGxtQ + bEjHXrDYxHJDg1WfNYo3tbxwdA1ulvQzJzVND5Y8ybMPe9nPU9pH3/YbyP/b23+DY9HKt5W8t36/6+DH + +xv3nAejipljPTH9t9F/N8bs4/zXr7568cXLL4/+2g6VeMj+IOIz2PpYkzPk2rA5q2nO57M1PP0RJ1c0 + 1/Y8LWYAXnnBWTvxxI7uAXJlZWVl5RGSXySeGxQ2JmK+MRVGf25sgQUeNjDty3zE5TsPSh5r089c1RMj + t+NlyTHfP/r2rxL686//yb/+X/a3vn+H8D5S+W/A+1oW/zaDy3+Xqu02/s3Ae6Ku6t1/c/STjz5/+au/ + /vnLv4GH8XcW6xlz1Aw5090MXF9Uucqva2TvWXfDS5+cPg/rNJ+9c91TswfIlZWVlZVHiB0gcxPC5pQK + jPnatGpTc45j2MBSkW84Y9YEduUWj7XM+3rAE/MYGOcDr/LMwTcc8d+SrxLaj7672L3iv0fds4FJbmJ5 + ry/4yKPWY/y7EI/1qo/lAkOMj75/8frjP/jlb/7w9/DQ/kaZs7J/9D7YN+QL63nnYPaMLW+90I84Oawn + x7HkhpKj/diDucCO7gFyZWVlZeUR4j93xk2LahuRq25YEScXODcwbmZuhV/1Uac9lKP1zHstcxZDyQkF + rlzR4na8coi9b834t/+nP/Gfp7SPvv/q7c/3q4R4f/ze8F4hVoz3zuP8N6q6We9c8H0N3PfkZo+qmz0s + Tg56mb7gR9/nMPXUR9++pqnMkP0NE1x5VPI5Q+YOj/MER3Kis4ZYzqC+9FKseBXvAXJlZWVl5SHCX6Jp + apvR2NS4gQXWDw8NG5vdrHM+OFpb61Vf9ZmPWvBFDbsq8uhFzGzHsI70YZ3y7KNve5fy5/RXdHgv3Oa9 + 0PtKrfuo+eKhTtVykp9+8hPXnPLBMx3c0ldvDv6p/TylffTNGu8Dn32rVntU71wfecUDK46uQ1Vu8816 + HeKjrb9wFNM19pdoVlZWVlYeIvbxHzcjbm65yZmenMW1SQWWvsRNbze4wnMNi4+2Xh73Tdt8nU/z9D2f + fLkWcNi/8d1WTflU1sO3PNawvzFtH33bn2a0v+piX8T9oYlfL9TvDa697klheX+g7f46v+c7p2xp1Xme + awuvfLPha782W/ZSHjjSO32xVc8YuaPaI/qPGZIXOa0lnjH6uCo2fK3RnvsO5MrKysrKQyQ+wrZNiFob + 7Nyk5ubGTYv5rLnZ8GbtzHEt1rN39kSsNYkdTc4FlzzXgeV1Rhy1jLNG6qnEyKNvOfs70/5VQv/rP/ZD + 5U9d8nrtWqFxHxAfe/HdRl1w457G/a5cy0usvdiv1q28W/rCM5s9Ja+zaf7SM3m0wW884O4bJnjDvkGz + Hny9N7628ehDYw7Jo4499h3IlZWVlZWHCD/Cjo2JWjE3pty0ELsd8eR4/cyhV2Dav/wnc8DZJ+KwlY+c + 4lrvitpLDmtlrfaxGqkztRzXi1hnLrUvPPevEvrLf/aT++jbr4nXjXvg14w4rz9z89+qtDiR75zIEWdO + beEdK961ln5o1SdH1mRc9uCMwSlu8bIWuPZ0lZ5PcqDGo2Zdw4uXVnh7gFxZWVlZeYj4R9i2KdmGBtXN + MTYt+rJ5DW7lwCPfeA2Lje6bcPYLCxy5yMN3TmHke032iXrnCSf7PFkn/alYkxzGWQue1iQufe2jb/48 + 5fv+V3R4DXqvLtfmfmF5/X7NqnGfGseU9zP9wLUu4ut6rqw/lnHDiRGHWq7VAXMfWM3yLfqQN2qLV33C + 1xzuyaklh37hxa2avu4eIFdWVlZWHiL5W9iyMekmZpabU/hmkcemxo1Na2uzI1Z4r611sgf1cNiP/l3e + /OhVqjxdR7kes79jWOfiCwbf1WsrZk2zmas4cfQ3tb+iYz9P+b79FR2fcVxLxMOHvVwjfL1PgYWydyk4 + re/pdaxrq5Gc+z1fvNJau9czF/nqybh4wjGfmPCvea7fOV6DPDGdrWOFs1/kYi6uvz8DubKysrLyEGlf + JG6WPjck2aDmxpU51My4eOoHx+2o4+ZYteiTcdWQz1zEWguu+3dc+MgZP+vRK5Sc6Ddx8l0ZMwf1Wul5 + y0Pecfjvw1/R0bl5D+t+RTxVefP6qBVH7v4ejBqPg5u1pqxruaphf+VkLGsFRo2c4hrTbz3RK3J9Lccl + jtqbHgO7y3FtxRjvO5ArKysrKw8R/xnIuelxs1MrvvGoxOn3ja02v+BHfnKUV/0rr2sornXkTQ5ncgz5 + hkHTx1pZrzlTy7PPDTa5td5Tc3ENXI/1Ao+crDk2/orOn339T//1v/j63//H/xPHvB9PYu2ajzOmL7MR + 1/xT6tcpfFfrgfUUcw4s+WU7l/XZF/nEEF9rdA3gs27gjLkWudTIgcsarik9kt9ysiZj5FuOseWMtwfI + lZWVlZVHiL8DebNhxcYUqhsXefRvN0fPEyevuM4R6zgVMWsqLg7z5d+pztlxs9or1pAZiYtWbczkCsw5 + ErNPadXd2dDoUXH07X2ua/6t//HH/Ss6vo6ueRO7L7MrVpyq4XW4kiPcpooPX3veaZvFLXHhWU/0Ymz8 + xgE+eWYtDj7mQD3rmGdcdbUG69uawlM7scSx7r4DubKysrLyEKnfwq5NyDcl94FDmdONL61teKhxH5zq + M/t232P3JX8sseznsczhPWom5ssPDuPGTz9moSrGvtOGj3WktuqRz7jWKPzEwktlT+Sn7/zj5yyOVWwf + ff/J//sf+M9T/tV/+H5/RUdn5bpckzP4uhnjWgWjnzzBZ9/sl7GufzDWJnZdK+sNe4oPZd9vynks/Wdf + 4skdsdtZP3yurWuGz+sPmzWi7O/8PUCurKysrDxC+A6kq21EUNuwuIGVz5xycGCQesasU0zril9c8otb + NeRH7+IUNtabPuuAEXeb9eghvS0OrRrFr32HL/mmtgbXkfU09vVucnf9EkOearF99G0/T/lP/vX/8vW/ + /4/f/quEfG1q9uZ9Y4wctM3c6iROrN9Tzdc6wfHY8lBeX6jkTxz5a6yzev4mvutJv8fRl2t4DrXeE7nk + ErvJsVfyHKs67w0+61lXtfsO5MrKysrKg4Rf41MblGxY8CNGLjeu2EypuqGRr31oUw9fY/auOHpmjnly + 4Gdf9yun/YxDrTrmGEdu9suYqhzBGj/j6hkKrvPCJk8wxswXj3lq1TEuTu+hfIv/5p/+XfwVnT//+l/+ + u7/8+j/9l/uvEmK/1hMztZg68uSkT47qDZbrntycPeKnsIjZx7Stq/3crx7Fv/cb33N1Td0f3FHX65kv + TPP0a43yG+9gju8BcmVlZWXlEXL9InFuUMRik+Im1jYv8d0iX7nCsw/y7B22egQmXOGrTZV1WKucWZe9 + TTnXzTqKUbWvYo4r/9g2B/BWD37y4IeNnoVXHX3las5x+J0XNpU5t7HW3/qH/138FZ1/VX9FR/t6T9RS + dR3yKlc41yVf59A4eoCjte6XVj7qGCcmuPKpXCP66Rp9PfNb/VirqXN19lLm2D/8ntc+GYNbPnDy4LPv + vgO5srKysvIQ4df4cEMrvzZCKrHM3Wxgiak9qptlKDdQWYv1WmsWanyNibGX1meMfOsl/mVtxYg7Fj5z + sSZ94Qw1zHno3zjozb6lqHFbPrVhWTt46K3reV5wrYke1bN413U89tyoo0p9WvgXPrnKI36srhdxnydz + I2ZdrFcYY/qsK0z7VY4YNfH0oxfXVG5w4E/rueKzV655tOaoNV3pI+92D5ArKysrK4+Q6y/RjM2JajHV + ebphUm82OdZO3yz1xFUfPvnVU/qqdT42z9SYrdUgpu8qXK0n3ntVLuJYs3OBjzw5uk7m0Jt+1oKbecbT + v8Ha2pNr8VFy5lwWa33E6lddadR6DfpXT+3Fum51fXJdDx6ce96FDyy5Xl9+1Vev5MCPeOBeAxy5wKSO + FvXJlz7Krxzq1B7N+ox1FvbrvtXvO5ArKysrKw8RewfSNqHcrMYmFjYOCsS58bFOc/Tvc1GrvuaLdzDJ + MSY2+7InteU8PlbqyVHetYa8whS/+lpzg/vaB+OsY2bFs56+2PAlvqmfHLO+NjDGOk9hsbbWRHytr1xh + Vx7xirPfmFlndV5iyLMO+eCBC5w1jDNHjP0yj5g46snJfPr9Gkox7/HZgxxiWs8ewZk9eW3SEzn2udQ6 + vr9Es7KysrLyINE/ZZhqmxY2pNBrfKlxrOPuo1dTy6vv3FDD3FLBq7VDtT7jrMcMmpdYeTnzTS4x2OAH + zhmV575bzXffbOGxfuasD1Uw7ev1yGvuG3mO1ZwZuy2e+YZrz+QKp2GKH1+5rpkf15oY56CtusaXnozN + skfWUT0fOHnEtXdxi6Pc6CG41btPC+zSY2BZJ7Oizv079friX+qg5LjdA+TKysrKyiPEfws7N6G5+QGz + jUo2Ls0HPzjcxOZmF30kzx6ZBw6MOdYRS86p0R6RIzbWV0Ud4+jf+R4Lj5zi1bWQx9yTdcShlQvuUzVu + HS8OeZGvmuQLL31wG3aUtcxFP/SBz5paI+KOaQ/WhnWu5J7kCi96hp34xFibs96o5bIfLGdh3FT4Oker + geq6kS+fvTI2H33Ukqe15JeNnCtqDHMcvtl9B3JlZWVl5SGiv4VNW3rdoALTDe7gYo2jPI+Rn9zkwNJn + zaVXw2pOx51T9s5nnXIVS99tx9Uy5z2YE2Xv4EQ/xopHH+Vqj5s51PfctXflBuYxc4H3+ogVSw588jJv + lv3cXuNLX8lnX3CjP++LcFCXvuSrjrV3ylzxvJfpTV/PE1fexIgPrGYavaSH4uQ17i3HbPnJlZo9QK6s + rKysPETsHUhuXro5UbkxpdpmJRsWY6sL2+scB8beyQeeNnuVZo/M1aZKLjlUzzkmVriu6HG/BrWwVODM + cb2yxbvwDdO85649prKesxJzHzNoPnkzlzH9yutMTQ1XBR61oYzJZ9/iXWfVnuxDPPPAPLZ6Udbc9Ug+ + ejGefbJe/Yy1R2DUuQ5rPZYeiYFP7FKD2Pz7tZhDf8TKo+5H2CsrKysrDxH+DCQ3qrbBIdbNipsYa1oe + tZNbfNaCS3UubV/LcGLhR44x/Yixxk1OZyhOzUTe7M88a3qu4tR2Tb3W+VyLFqq5NpPXV075xlMln3n3 + qeCrTT7yZvscisu9Is85hiuPeOTILy744Gbtxa8ZyWfMnq2f5Fgb/fu1ttjzhZdf+VStPb5Z8pWjcfQ8 + NajlPIUVV2s9n9zi0K/66pM1e4BcWVlZWXmE6C/RlNXNDBsYNirHsXmR32vFokdT7TNws33tWKMUeeS0 + lvj02cvUa4BVn/t45iqP65aawns8awMXi3XSTl+U/OiHGYDPtXIWx2pe7TWVuVbjubCsewpLtXUwS/Wq + vPnMMR94rUle4RF73uroG0di7XuXY8/MT73plT5w7d16qhqHvKNeR1yt5HXNzA0eMe2XPnQ/wl5ZWVlZ + eYj4z0D6RoTNyDYt2bgUzw2OeceYKw5rytbmSB7ruUZYckM1N3mOtXULU7zFqA0lDo5Zqc+cKnitN+Np + kaO29eBrj5aDtj6ej5jraI78UOCCRd2V7770MQ57eH7y72Jg3v8mF/1UiYOHGnssvvji5Vvm1IYf9W0N + 87F25lmDXHALU472m9yy0lPw6DUwiR3DetceT8f0s87mQp/MZ9/Kmb8HyJWVlZWVhwi/B1I3L8bcFGMz + DNxzvmFFrvkjbrjpyQVeG6Dmnd/qsUGKWqyYctm/cjKr5bBmxpM7feXAZ22upzry5rNXxMSo1aPyoy+4 + wak650nMNbSu8oi9R3AuNcJzq5j5XgO+YcCzt+e6ZY9U5/MeoI/0wEPyv/rlb/7w937x+uM/OPoJf0Y3 + e2WPm3ug66Fv8HqNc8Gp+uAUdl3TY/e1bvRlPrlYC3yt017N93zhEdf6k6P99gC5srKysvIQiY+wa5OK + zQgbVdusIpfYJX8TA4vaUS8cs9wAsy5zugHDtx7SJxWY9uC6rC3bueR43ucQnq6la5ifMWYDHv2Kw74t + Rl3mUK+9vIcpaxOX9RiTc5Rrs74s/h0Ec0Vv9pn1nvcY6yofnOiNOTzu9cplrBgekrfy1z9/+TdefPHy + 14f36dE3xte1GHNuYsmTuOYLPPOGP1U7ahI7mmtq7U2svWZfU+19dx1ZZ7j7xTPcdQ+QKysrKyuPEP8e + SGxCfaMCppvTwXwDo80c+NCsvbPwyWc/5lt8qYk5NK9Y5lSdc59zDPnqpXniihXHLPtOX/u6KgaNXjED + Y/KKQ+3XmX2ES02ur1fWfdaw7ra+VPNckz3Tv8Ejhi9rzRlqrY+/8QB5Jy9+8+r37R23U//lsV9xTeul + c+V6akUbV2b0+aVOed0Hx1T6Gyd7oF6VtdTsQZVeDWtr0Ea/fQdyZWVlZeUhwncg+6Z2b6ke+4bY/eTI + Jqd49kFe+7eNELmslV7UzgVvKupMuVbjw2eO/bJOrXPR4wmteWip6Jux1DU++hs36ztGPOupjgdX81lP + X+orxr22/sQRE6+asFWnj5vO05z3Rh/NkW+Kh+Q7Cz/6tnfh4qNvzhLr1LrEaw7O6L7Nipzjwq1cYaGs + 77VZd+tHjcWsZZ6qnMwlV/Lk7AFyZWVlZeUR4r9Ec7MR6Yalm1jGVN28jK++255Tm30yDsw5zCGeM7jv + db1Wa5hvdUNzPXIRs5/WT5yxzpG9HWMucMbKaf6sGfnE4PtsRx0XHv3ggEccVjH2YZ7rtLqjyjOfcVtf + Fb0uPF1X+uMh+YOKffT90ecvf3XW+eTom5oJ9xJrxzw1X+bd/6ZcXF9i8HnN5DUcMTH1GWc9cM1rD80Z + tgfIlZWVlZWHiP4WdmxEtRkpzg0rtdVg4yMHVmuDg/gpTJT9sjewjLkWufBdUaeY1vqazqlc1lhf9LZ8 + qPRCLn2vo0Xvo9lrxNc172NXq4dmP/peA55o60eLGs25b/1gL7kbPKzyQq84a2UG5F2lb+YPhofkjy4v + Pnv1+7aea5vjOpdidT3Kj9lnTcXlc032aRzHqdcexHI9WTN7mN0D5MrKysrKIyQ+wq4NLTaq2KTKVo6b + V21qc7NDL2xwrQdqlZv15DhefvWhxXziX1Vz9NHD1+n1XIcxaxwX3+tNWw/4xEb/VgeNmuijdZWr+qnB + Fx7qWJs2+8X1kJPKdY9PS42avh752Xuq132DD5t90688HpIPEV6brWuWM6km5nnM2WqCQ80ayQWmvIi9 + B5QYax2HvXLBER77Wrw/A7mysrKy8hDhR9i6Oemm5T6wmefGRc1NjZqbm2yMR1tsVutu/Fr3WI+pve9U + nYm1rqMXY/czDsuaWK9jqYMXtmaO2roPbsGL+Kq9l/JQa2tKLXnkhAauqhzv0fCalTn3jZPrSR0w8qie + Yy25jOErRsVD8iFyO9vdrMTu7FG9n60mc4Fpnr7H7Oe4WNQzF7isMTHw9wC5srKysvIQOZvOl7EJnQ1J + NjP63LDaZobNinXMpS99qj42Oo+zN/HKzxz7xJrFUZtcj8F3DPjAtM7xE7t6PvisDcsc+BqjrjDMqLmx + ntrGzRmK03jeBz5s1lPZJ3tFXfrgzLV1TbfoEWtortYjRrxr1LuSC197pz04HpIPEV2f16DKmVwHp12f + x92qBhd8U6sZdRpz3WZRw3zY8qv+4z1ArqysrKw8RmzDyU0Km5BuXIypGWNDU47HUMMyBodYbnrsITH7 + FDfmYM9Zw74eA0tV7Fhykw/e7Tzga551Ey9+5agWVx1qaDXvfuS0njF57JF1rAFPaxp+LNcJXzByoFyH + flrURCw8+KxPnuSoybUc+tDiIfkQiTlkzpu5Y666RlPz6zoUK/ypXrTJOzr91iex3tfX1TUSP9w9QK6s + rKysPEL8N1S5KcH6hoWNjj43KmKOg3u7eZqlJq/6Tls++VoXMX3mveaCB0Yl3jGsl3H1cD5mzhmFw3pi + yqmasJ0z8swBK36tkfmGjzqNgXkMq7noefpoHfxUi6mIs+7EvR4+OOxRXObCMu+KGlU8JB8iXJOzcK64 + Z5ypMOZd9Vp4fVDWZz7xm36sZT9Yrn/1I76uCc7B9x3IlZWVlZWHiH3Nyd1GRKu4Y8nFBkau4I2LHppX + n7yoObjxLzUxS68lVmupn4p+yml5cjynOq4BHKr2cd/XYB14WJe4xuxJLvP0PSZOvlhykit4WKk19bWw + tsSZF5y9qFGHNZDLmL7wO081eNHviuMh+RCx+eYcxPQ6OJ/jNzGV9by+7AElxlrnq2af4hGb+PRV9wC5 + srKysvIw+cUXL99yQ+MG6ZsalRuZxMrRzVOVmxr97OP11UM308ARCy/5o1brvLfkoo56l5daWObIdSt1 + Vdvt1Y+6xC59yifOOs5B7bmo9Xr0zzjzvafytFfhpVpDXuJPYBEjDw55kQ8u6xyHrzgejg+RmOOsj5lj + hporcwMjXlzWCx8xe5LDXvS9Blhxa53qMWeJHsQzf3QPkCsrKysrD5OzIX2pG1RsUrG5+WYlmMaKz/yd + 7zxseLNv4Z3jsfEcKy4x4sUJftRf13UeuFUjGGPxs85jzOi4cGnhk9f5MUf0qZrKU7UWPdG36qsvtc3i + 8cz3Gs7ANXMd71815FdO5gInewBn7NiombWswcPxIeJrUjEf45g9sNIrV6+DuWl7HXyorsn8dS3wWk+u + j3rkjLsHyJWVlZWVh8lHX7z8ddvcsHHp5qS+59Lvm6nZ3NiA0WdON74WixKPmogDB8f6tt4nD6y4176Z + v6kvJVZ5clmbPZDPOmLg9H7h3/EYZx4acV1H+pe68J/sb77E2rdqwUNtzsFe31a9l/pcp7CI636Yj4fj + Q8RnwJxzLs7K+YipRo4asefYI68RMbDkIW6Y+xVH7+qfPKjHY509QK6srKysPEzibwjHJqQbWCo2qYt/ + lBsc/cyPjS363/d1jue7rTzqEAcn1po2+6EuewEPrOOpFqNX9svaqqn+YZnPnHDCv/ainwre7B0Y5gGW + Kr2Zt7ryK1fKus4rP/LqZ53kVLXe81pPbMSsMYw+Ho4PEZ8D6rPL3IXDJ+5zwz+q13CtBZ7xsdKHyh7M + GY/czFmsmrVioXuAXFlZWVl5qJzN541uerqpudLH5tVwKOtDZQNFLuuEmz3gszb82jxZn5j4zBHv/TgT + 69W3HGpRw5lYVz64iM1qXeBU8oST/a/rZT/Vk+f6prrm5Fscihxq6QdHc8CRu1jwg9tz0Ye+9AOWuFtw + wSkcfO1/FA/FhwjX5nypiomd10hlj7g+1CK2WuayH2O3oeQRI49KTvD6fdTY8nuAXFlZWVl5qLz44uWv + uQnlhiabFv2Z4yZHzQ3NebXRhZ08+h0jn2t5HmsFp/q5P9aanLTWY86FuNfAx5qso6/rNo5ZKHtcepF7 + VGfSuivGfsIRO31X1Fdt9I1Y8aohXryaRbmOpx/aOKh3jtU7R+YDV33j46H4EKm5YgbGnGnGnFevw2rn + dV05rAulz1zPI75dX+Kj5LGenD1ArqysrKw8VPgxdtugsDG1mBg2rLbxIU4LXvUIy9rAatOsXmqrxi1y + 5avWHMmTtchPaz3ZV/pHDWtjjsTAifWKx3pyuI5iU7Medq7DNdh71vVa1JsKPzH6Y87k6hrH1/6Zz9rq + RQ7XKbzbyFU/wz0m5ygeig8RncN9uRbOG3m5vsExn/WJP8mrfyPPCW5+9OgY/dDI9zVYF2tZvAfIlZWV + lZWHy9mEPuXmlRuT+TfxdfMK2/lUyQ2MfTIPDtV4tRZw8o7ere++W/AEnz3u6ouPHtDqG5s6e/Qa9Bk1 + 9KNn9WH9XGvmNU4cva6KHsiHVQy+9xKsxVHXFGuakq81jed4n5M+ObqG9cDD8CGSa89ZJbaZJo+5sCd2 + TmHEKyf1sMSUR1V+5lgrytpcl/geIFdWVlZWHi0vfvPq9+82tNDuJwcbouJusQEq9y4Oyw21r+M82UgT + U5+bp9lcs/drvMSxxsDZp9WIfao2cuEzlzxikmu1psKPaxCucBi3tZg3BUfXca5ijYe8aFubdcSQ1z7k + lpU8VHtyvbKB42H4ELE1Y6aaweew2GaHNpxqOdh+XcHTvuS0XumDc1T9iK/rXmskf3p63z1ArqysrKw8 + h/zi9cvfcvOyzSo3Kd0AHScWG1jh143PN7fhBy9i57OX5JvvNmLFWgx+YVWTeSqx5Ek/7UNfanpfyUtd + wzUGFn1q/axnD/VFa93r9V4UPfTadN3Ji3zhnItr6ZqKhQLLmuIpR3snHz4egg+Rmr3mUduuE7jmIo7r + Sh5qqJfcyFOzt+RzLdHq12PtvR9hr6ysrKw8i/ifNpQNKTeyjGPTpXou49goc8NkXnp5jcXgtT7Ae83o + mbhg8LO3Wahz3PY4FT1ZH7avlXXJvbHJgw9u5DmD9qj1ss5xqsxA1Vz6oZrz2HvdrxF+9Kc1jNpyHoev + 6lznsAZ8qZu96JOfXPTBQ/AhUnPU+u7bXFDFfF7GqHWbfSQ+ajzWtx7gN0sfMde6qHA5h65r2B4gV1ZW + VlaeTV74z0LGRhWbValuZNwkO3bDFd/xrOXGys228ypfNd7PlFzkNTd7EXuqhv7VxvpZb73MIt/6wC/+ + FaMm5vlaT+NcC3xi5DEXNeWrXmaAr/yID89i7UdcOYZzHfJH3HrdqXGlj/HZHw+/h8hlHtWD17XfXzfv + oeaJeTxVcF6zxuTwXhBLrtVTR43y9gC5srKysvJs8stP/+iv8e9jc6PLDWsqNjBubnc89nAFL/DDRU3W + IafcmeeGGvNFjlgqcsn3uDDmtY48cqtG8qhNFZzcXINctVDynMsaseGjTrR48L0XrmPkKyeYcHwWxLoW + axnrvDNPXOvJ1x6Mc23H2C9mxMPvIcIZdP24ltCc3Sy0OGduiZOLXGLO0dzws0e/D8pl7Ar+xYJv/h4g + V1ZWVlaeVX7x+uM/yA2sbVRha0ODj7j5qEsOMOXMvsrnplhaWHGvdXMN5mM9xr0ma6ngOs45aR2vmTSf + vaSePPXZw2tQp7Y411zkY/3kMn80+9KXuuDXDKmOh01+4rXWzLc+zNE/qmvpLFknNXjoPUQ427Q2F2PO + xbkvOVi/lvSDG/0qVz3kXmYsHMPhOw6NXjIfsGn3l2hWVlZWVp5dziHyE93UuJnlZoWNLDe/zMUm2TY2 + aHADL75pr8+89sYcrM86cKjOQy44EStGX3HWpR25ZonDchZy7njT5zqsaTnkDcv5PX4Kjx6Mp7Iuex+N + HqgDJ1Rw8umDqz7rEodWr8GTXPixFh52D5GcBdfAmcof1w8sr0di5bSa42ef0ZfXX71QYyp5YsHFeuhF + bvXej7BXVlZWVt4TOZvTm9jMYqPipsYNrhQbGnJhZcPjpkdfYuekX3j0KJ/K9Zir9SKnvOJjRuvlNZUr + jNyep7Jv1rktzPtofNR56B2x+rqGxicvNdQZc276rL/E5AHLPsJpXMRU5dZskgM/cO0R1mMqMc9z7cjh + IfcQ0dldz/o2h85EZY5c42R91gXOWr9WU8bMA7urU36uIX3SIk8/4sj/1A6Q9uMy9vVhT+pnr34f1JWV + lZWVn5LYC/zZnPzvZM/NKja68Knc9GIDDL7nyH0KQ5wY4+SN9VtuxrL5EocaN/OoY0zsLsfaiRVP6oBn + TPUe7FVret+sYa6wwDuXvseZD1u9Yv3iRK3yyy+d9bEeYvhP4Y1zbPFmb3AtDx8PuYcIZ+Daal1tzqGc + v+qQG9Z4xYUPPmuIh0Zt5wJH354LLPogBu99P0DatzzYx+wfvX75W/s5a78Ovwbei37fGJ/r+urFFy+/ + tFo7WNrrElqurKysrLyv4r9U4+9E1gs6N7CmwMhRbtZiwyBWNYpT72rIH7lcpyx76Az0i9P7qzLPnoUX + pjntlRzM2ricQWZp/lHWht/nLrywWgNc4eQsiC98YLpe1SHP9WmRV4x8X8Owo7redYbA2QMPt4eIr4l1 + Y866VrfAKw8fdTG7KmqOPzWv8QYzGzrzx6Jfca91xQn7Ph4g/V1GO/idQ2DeS1P3cW/g9xhcXGNqxW+O + fvrRFy9/bQdTLLeysrKy8j4J34m0F+58kaePF/uI88W9+RHLBkFlrWwY7Ml8+swNSyWHyvU95/37ppsc + rgFlnfZwlbq7uNaJnNlcMzFZn7H54DJH32xo1WR+WstRyYeSV/XUcU8yHxjzHlteVWuyTmsKC1tr0Woe + D7WHiK0Xc8TabT7k1CbeMPjeB9frPnKw7FtY9Zp5cshTLrHyS3OG9+gAWQfHeKdRryfmpi/XiHtLv/OQ + F9wxaORf/tZ/dvvzl7+yv++PUVZWVlZWnlPinUj76Akv5Hzxbi/qfCGPF3jiWlN4bCjcCFiXNbCsp681 + yRW1XF/nWuPcOzu0rxM9wj9Y4uUrT9e1fPIGzpgcxdmz9yU31ohcV69x/3CztvDMuS3/osbPXoWzX/ZU + JQ/xpTc5zLl9nncgeR30L7PBJ58adXr/g5v3Y3Ikrh5a13PMq595Xy8s89T35R1Ie0fQ33E8M+l18F4l + JvdO/WZ5veBo/imN+2X+Obye1yw/yO5H3ysrKyvPK+dF/BN/oZ4v+PbiLi/w/gKOmC/qaXUjEE5i6Ssu + fCo5igGPXGzMURu5+zUH7rywyUNt9qIFZ/bNnjf2Ka3+uH/po876c42cJ9YlP3nHNsxjcqtn2aq7tajz + GBp9Kt+w5FTuooLj4fUQsfXavZE5iMd11H0ij7HbvOayqqyLuPOZz/4tJ2sO1T5uxX8fDpD27l98j2zM + mfOqz9nHNblFLu+f8C1f3MplnfudT0zwr+yPJbz44uWv7VCJsVdWVlZWHiH225EvPn/1lb6gxwt1HR7y + Bdu05cEfGPGWhzoGbuOM3hdu9q/Y+eA1nD57oG/isMoPbinjjlev6hMc9pj5VHI81+uql8wkPZ1LRUws + /FqrcVWtH9Q5jI/v9Y7HfbzUwY+1ih8Y732oYXhoPUQ4g87POXxGx4vDWPPuq07OsN7r+NmTvuXF9x6s + E5x+KH3lHX3mA2QcHs88Nn+7dvXrekwZ13UFj3zl3il7363hFj0yD805gv/mWP/oe3+ecmVlZeVHFv+5 + SPkZp3phFisbgcX6ok1+cmH7C3tYKnlaT75ZzUeMDSRj9ADGHpGXnOCRi16ap+9rMIYSu6tXPmvSBz97 + iF91ZckhxnrNRRx9Klc1yb3Jdw56IKbfYtT7uo5f46oR/vHxsHqIxPp1TZyFeFrFzPd5A6Na3Lnk4f4B + j9xNDF/1Upv9mCem/sk/4wHS3s3LuXVOt4GX3l1HXS/zrsDST06swx7KY4559qv1Nd/j6PPy7UevP/aP + vu2PKuzPU66srKz8CGIvrvaRkL6w8wU5fLwwQ+MFvb/Aaz4w9Dg9aTNvPnDdGMKGRh78oZMbfTAP1tFa + +s7BusxlbHUzBzXMe3g+lHxXYKFco3huoeyf2KW+uOzfZsreMRP5xCaHdW1d9CSnelS9q2PXXNRUHRUP + p4eIzsd5OEeLeS0+99TDwfVcLGpn/xlTDQ9bPM1n7vTMPPp73vCjz/URtv98dP7507g++jW/Ku4B5jaM + 15E+VGP2axz00Dw5zps58K/rVG3Ex0qt/Uzni89ffuk/T/nZfvS9srKy8oMJf+vyvOh+pS/e+ULtfmwa + Zql8sc74qRd31k/c/JOLeKr2rFrmFJ+2uMT7OopVHD3NL6700xzq7mrND5Xc9LVX5qSP9w8u+/T+tJ3P + Gq3X2qgPrbhqkjds70sba1uMh9FDxOfwmTAflDPy2mo+zC6atfQTL67h5FXv6Kl5cgovTlPvE37U1b+X + 2ec6QNp/IHUO1cLCcnazcT2BUev6UK/3Qe+PcpjLfPHcZw9wYhZyiIHrWPVVHrneK/TNueef7kffKysr + Kz+Q2IvpeaH95KgfJvkCzRdfvljrCzJftEuRQ21iwOkbXrywzkFOezHunLLFr83jDndFv1xXlZitQ96J + FWN815d5rVEe65LHGqrUsQ91rnc3Q2Cz7tjTj9xWAzx4hmud9kWOfLcR46HzENGZbG1Xn29gR3XOmD9i + 1uu1dry4zXrunq9xYuYbLvW38bHPcYC0TyDquurfV+fKOW80aqKO95jXF/lQ5WrelT7wXhN1yR04c+Q3 + f/RNBeY8icPaVwnZa99+9L2ysrLyvcQ3mPjh+k+P2g+r+wttvqhrjBfleGHnCzIsfY2htQlEj/BDy69N + qvVJPuZRHRxT9qI/81SuozNFXPnqU/3Mzxrpq/1CJ16W/WZ91UpeVGvDj9rqgbqpozbi42ffmpmc5Lr/ + +AOkX5vNJ3Zeb2B1v+5mb7Fcb/ZGvtWCc3vPUENNDnoT8zzXQO45DpBn/fjxlaO8p3of4zrl2sGpGuZK + yWFt4Pf30LnQlhec6r25tsfRO3oVntY56qOv86/zsI59kX/70Rf46Hu/SmhlZWXl+4m9kNrXaOCF1b8v + ji/MtPkCLC/MacWPF+vSwnqO+H1e+8GXeNarT/6su9ijznF7arWG1jGsIXVUzhIWXPDYu7icr19/aOdn + L1j6Opvi4aMm16/es4ZcqvLDf/QBUmeO9fuMMb9fB3yf1TD6yY/aul6p+wbVHlFLvGPZU2LvceJpH32A + jJ99jLVzTlFieg2B9+uIfHGdB27xQzs27sXw2Yt1WQ+s9RD/ti9w6i3PrNQUf3Bf11/R2a8SWllZWfke + 4hvR64//wDZA++3H8+KKH8gPtRddtx7HCzJfqMcLc8SwrAle90N1M0AefQLrvdMHl30MS27mav3kAS/O + fb6086dmnc7msxTu1mO5TvKpztN1DxeYc8GfOLnJy17VM+pKMw+fdXgoPERilpiN6+t16NzOabwbHDmq + 5t1XzoVr6wYevec9i3zP8b73fo8+QLav7YH1mW4055d5M1a13LGacx81UUdb98Nzg182fJ2hMNxHU9Sz + B/USSz+vQ5yWfUas63td4obxr+h8/Ktf/uaP9qPvlZWVlXcV+zlKezE9L7CffDT/Ao6+GFsMPzDGxZ0c + x/DCnfGw7B2c0uRkbnKvPe5ysw/x5CBuPmLnM+c1tc6dJn/WuC1ecmHz2ljnsVj2ST8s61mjGj0jr73x + z/4Quc4Us4TWnJ7HNfLaODtxnx/XMP3s4TXBpyoW3MBY2/sgB/9SA+7DD5BfvPrS1uUcnCt8sTIrcfKL + h2sxzesMnz1vrarkZl+3gzuxC9d6OF4aedS4f+2hfTRmDXuExnVqT9j8Kzr+85T70ffKysrKu4t/gfln + L399XlQ/PVofffsLMF6kVeUF/eYF2vW2jvjgew/kWKeWeVes3ePQ4MPP3qMe2nqYCp9rkHPbA/xZd8Es + hrKn9iKmtXENXHvwLv5NL+Dm45/4IRJrxrq8Dp2RuM+b11mxWvbRWq+fsfFFEwOP3OYzD37rA5xc1wcf + IPnVPXNG3hPH3cesc17jjGtRP+uAz7jx3MaaZYNjVmsjrvVZ33qLBlfjwHpceWLeT3pm3VhTfeXSZx97 + zfMf+7HXwP3oe2VlZeXdxb86yL7A2D76/uLVly/wJ9T44muWL/T0mXeOvGC3F/KjxWV91c46xlqTXKjF + sUb1U0ufs2WtzgXfY1k3amljbV2L+d5f5rusgR7g9R7gmSa34uDVOuQWhn6cz2qO4p/0IVIz1Yw6l8Yx + N33kfXZw3Md1CD+5ZuFzPeadQ0WfiZllz/CpOh+wBx4g7WPWeX2cr+bibLg/fo3F0etjTL9s+FTm3Cdf + elcf9oYPjucd0/4Vp3qPmP9ay3zl3M98zRk52vCzryjxxFiX+cIZe95+nnL/is7KysrK9xf7rW/7yMdf + VOPnKeVFV164xwu6Y5NDlfqwhXW87OzBtRKzepmBsfYlr/VDnnVZyzw5qsCyD3zmuh9aNZ0TPajAGx+x + 9UPPSx/4qa9ffYV/vodIXiPnxZycrXJhKx+WMTmKp9+wvsad3nMRWw7K/ooTe+RH2PYfN16vzq/XSXvL + 8drKdVs9Wh1wxs5jv+Ozjvmsgc/+wT19gSUvc9RYnz55uY7UFa+wVONxrRP33rg+8mAvuaMauy/rd1w+ + +t6vElpZWVl5d/Gfp7TfeHwdXyXEF2KzfMHXF2Tm5wt6w6Zm7cASx1oSk5+96R9O8k2lTyrjYVlPXl0f + OMLLdaVHYtDsd8dxn73IZxyc5JqiNjjCOxse/qkeIpynZlS1eTAvVeKWNwvfas2Pa6oc1yBPubPHk/Zo + 63uTs/iR70DaAaWuuWbJ2YBnTrDGpVr+WN6vvF7kWh/Pi0V+3uvi4HE2YsfArZrJRR45xZXrFnOQ4zpn + A5aWPuLqY70rz761XnFY0/Mt99WL/SqhlZWVlR9G7OcpbcO1F1Z7gc0X22P5YuyWWi/G8Hu+1SYn+Ga1 + luo90kc9cPa/zCWYcphjD/qsdQ5irS0s/FZ3/MZ3HLyMmb/yiWmdruO+5V+/+gT/LA8RzsQ5Yi6dH7Hk + p1/XE7zLtWqdxmapktP1LzVHDS8tPHLIP/wA2a895rjOXD5yvC7UtLzk3MKffbRf+JwheF6PHswxn3zm + sk/YiqtnKXjaG3xiFwuf3Jo7sOwpcdYp5j3Ceo49L+uEpR9afcP/+E38BaGXv96PvldWVla+h/Cj7/jo + x/+aBF5s4wWXL8h8oXbsxo/4WH/x5oYx89c4NOoK13zHtcesS4zKHGbSvmkHhzj5hZWftcC1f9jqQ9sw + W9NqPv/4V/hneIhcZ9HZZS76yCuHObfSL65dalmvOrBeq7Z6zzqfOf1Yyx67uMQfXfIdSNN5jXexYuK3 + ayTvKHvHvaCO+wG1ODR4He+x+96fvXouOaKacz7qGU9b3NEL10WuXqf5VQecc9ImprzIE1eO487pftRi + PuBeYz/ys39FZ2VlZeX7S3yV0Mv4KqHzP3a+QLcXXo/5ohwvxMoJHC/WxMljj+Qhnur5GaPP0ezPfg0X + LvKcM3sanrmadWpbw+v7DGGf8uX6sDbjR3+kxnl4DdTEZTb1lXfl4PryPiKPa621BGs4+lq96fHJnf1Z + yxrahx4g7Z37nOesj7nadSBOHFjTUT/zLSf17Mma8MlVHDVcR7nC0dqJMWZtrdG5jZNY+eSaTcx7nRjr + TE6q5DOmnrj3jd6JgccZgqO+WPCAvbWvUPNPavaj75WVlZXvJ/ZCan9Fx3+m6HP76LteiPli3qy/IEds + li/SjMOOjUbqWw3VYsFZzx53dY3DHsgxHz3RQ+rdSk776AxeR//Y4s58WI+/ePUGt/ZhorNxJswSmM6o + PvIeQ9mD15g9TVmbvvQGpn3LR0yeYFkruPun9pEHSHuX/jIn5udcmuf1xTXUtTKnWOuLGnIrHznG03c7 + lOvM3qH0rzXsrTXKSaz1C45ys7fwGu6+zCB9mSdObnAYs57aa1p8lLxcB5j3xxqBVf7gX/Gjb3stxMNh + ZWVlZeW7in6VkH/0bV8AjBfeePHFCzL8epEHBy/eGqvKC7fwQz2Gf+0ZGDmzn/ZNLvK9T+CsYd3EnQ/V + XPXsnMx9/vKhH1+b+GzQmK3maXbiR/VeKT+vT7D0oeT4eqhR/66Gdcyzh+Kc/5EHSH9nKmcKzdkvc6ri + OluuuKreE/ZSyzUkZh3V8heOqK6rvFov8NDItR6MkVM+McXDZz/wWj3qpLevi7jP0/uV37Frj1iT3Mwj + x3qvVQVPe4l98wv/Kzr7VUIrKysr30vsO/L4V3TinZp40bYXW744zxfqFhsXL9isoVZceHJRl4r6yEcN + c+xN3jWWNckXLvmeZ4x8xqroofiLL16+fY6PxWIOmVuUOcd5PWZ9/rofV37UZD/UqDKXPUzJhb3kEi+f + cWms/+h3IDmjz4zZYpbrrMyxpuWOZg/3qyZz4M5c4FhT+LoWc62OajFy2Ye42Own6tio0zXoszZzyDcF + b3J1DfKUX3WFk3OpUQXP6nIu5AKL3hUXP3s4XjOk9Y++P/avEtp3KVdWVla+p/Cj7/Pi6l8lNF+wMzaL + F2K+WP9OH7V48Q5Fj8A7X+vKChe4+4jT0vd81YQylrnAT0x4jzzwqNjarme2mCuU83I+5YQt33KsSyxx + 1AqHvWgDRz+3xIFJr8oF3mpEH/sOpP/CRc5S88Z1lU/tWPhSn7myxDyP/rqOx1Dl3dVW34N5PNZiXfYv + X2O3Htf6vSfWcPyb87c61qxaYhEXp/dLHxzNh18c7elYzhh4i6Vft9+Aocb+o2gfe9sv5+Dhs7KysrLy + ruIffX92/1d0wtaLsb8QqxoGZY3h+cI9ctqDvYknH7mqLWVt9eRsWhv59FmjKnn7+dHn+qH8fp24f1TM + aVi/pnHNwOk7nrXwvS6UcfGZv97PXt97uW8WqjM+xzuQOnOozDfyaXkt4LhKzFxerygxXafx6Ctu1mNZ + 2y1nYgyu5G5jwaxmWuURn5jGTWWO6ln1GXOmY7W2OFHPuHKCpX+s1BYu64BXfsfCVhx18MWex+hX9jjd + X8hZWVlZ+QHl7quE9AWasb/Yywu7q8TBx0aDvNcN9TzqnuLneu6TRz9s9Cis+FpHG/zn/GiLs+W8Ohti + XsNdjnWzlnGq9Rj3gn4o60KNW7mqZ67FzKOP20cfIDFDXUvNl/ObRT5nzxrlqxIHBzH1li9qmMbay3OI + yaVqLe234VJnTCwUfWQW52h8/KhBTvyerxkcQw/yPCdc7cvarAcePYqbSlziZo9G345pHfPJO+r/Yd6D + 5MrKysqPJ/wqoXOo/PS8INdH33iBni/68SLdX/D5os04LXpk7uh8oc96cCdfNXNYgz2irniPfKfsTtp1 + 53XVrGrJCay4zjcc6vz0JY+a8iNmf/br6wDzXsGlEnO+qOef6QCpM6Q1fOTa3Hod8PWas9YsfYnJaT2P + Zh9wI+6c4IXe9aYGJ/o1LjnIK79w5OCz7jKL8LvF3Oir/S5rWCy92YOqdcWp+6RY790xKnH2SJ7luQZr + xpqMqf7x9mcvf42H1crKysrKjyn8re/z4tu/Skhe6OMFuuLAjr15gU8FJ/tRR471rT9jt1Ef3MDIs4Mw + LuPZhLPyWkprTov1GlSdI9d0ic33NdATPnHNMe/qca1bWNimyFG91zMcIOMa5P75tdV8HYcPPK/BbOPr + vQ9f67M/MM8PnDV3vJaH1b66plnHoZMz12zrUCUX69xzmGtrCF68wF2ZS58c+IiJhZV64sK3fNTH/Z/8 + rDEfdawlRk7W3uTKP5wvXr3Z3+BeWVlZebDYx0D20bcdILCx+89T+gs2lS/Y+qLttvLzxT43ALfAgREn + t+cE137P/M4jhbPqbG1WydX1l437Qr80a5HPWPsyvsGyh+RqrYnVevQf+c6ufY2Pr4+5Q2sezkRLbl6b + Xu9d/ih7Os/5lctY8ODr2p2v2Kz1vMaZx3XBd57wydW6Wv96HwKTHHoUjj66jljWuPX4BmeNqdRx3Yox + A7jXWPlXTs46cOaqBjyZK/M5n9u3z/G1XisrKysrIvpXdI6+iRd4e6EOO1/QGeuLOpWbQ9Yyb3bUxBr0 + z4ZycPuY6n36DcycTeeEz3jmPc5rHLW8B6biV64s79XsofctexybfZhHjj0TP/rIA2S9A6nXEXHNqzMG + rrPfWvRJ63iPXRGzRjV5sMZpPYYqxlkuOe8jWPat9VveFDXXnhFHbuDqY43WJ/Oh5JJHbvZovMprL3LZ + g/zwce9a38pXLfDEiPd1XI1zw2O9/cY2HmYrKysrK++D+Eff/ld0Xn16Dhtf+Qs21F/o8aKuL+zlV0zM + +Bes4S/f2qHmfftB+Zp9ztst1e+LqePwEVPZ6y6vfcIX7lRwIt8tfY0LP/rgA2TMUuuHjfl8xss9AvbE + NVKdnzz4wmXOfahf/0198o7VfPKUq7jzJYd4zsPY65LDNYrXe5DLa6YvXKuFVV7VVc65VKm95Vle+qrf + enk9fMknj32cF3W0qq1GMF2XuCv6vQ8/6rKysrKy8oTYwc6/n/IcPOxAEO8U8oVdrL7YS143GOaBvbGD + 6vv6G5ZtVrsevb6Y33PkEO/5uBfBmXXF9TXEcq2oVT/6eSy42VxD8+JzrUe+A2nfA3mZ32cZ12JW/cGp + unzsJKb5qi1+2FBiVOdrjffqXLPkBNZzHnsd+iHvPtRyrGv5aZ2LmCr5nAc649kraoqXfOlV19N98p3H + voI5R9bwvPSdfPp3udD7moiJjVzMtYfIlZWVlZ+K8KuEjvpf0Yl3KvvmIC/w59BiX8fx0r5yyP+UmdWj + 1XsrNrdfEzdF2Rxvr1XVrhvXfpdjP+2ZfOCRExx63WifyD9R//gDZL9nee3u0477Ib5x9JoaR/DkMU8+ + cbFNn+zXe1Bjpmv/2SM5pt5PeLDEkgedGLke2xreT+YQTazNInzB00fP4AYvuYmHWpx5i1XBVUsea5Pr + WPVg/+LbGhpLrfVBL8P3nciVlZWVlfdGcvMbm5VuYh6PfGx82Bidgx7INXxy3A/LfmmBRRy1zBOjJnfW + nPiRB0j/GcjLteC6icmsmnOcuaO8NuodFjr6mHrv8pserOoCY33WQLmG1tLXHGfoPQNjDX3WhF/qPNPG + RQ78i/U81hiqa7ccYs1PrsWOZUyNa2wc8TPvPYtntin6XvxvUPZm3xdf7Nf8rKysrKy8B1IbXt+4fIOD + Zg6bHjfN8COeNVGnG2xshD1/LDH0Icf8tANLZb3XdvzRB8iYXe8JZnKLaxDMVa4h52fOsbgfmouY92Zy + 5/qMycccXEd6NK5wCodvOOuUk3jMofnJa9by4GQN1Wto6/oYzx4xo/p1/xhr/8j3nl4vayeGeK5ZfYTT + coPvcWHT+tpYn/Vcg9hz/uGBlZWVlZUVl7nh0deN7WlOYcUHTl7LxYbNOFV60teasMSVAx9rFMd/8eDx + PwPJ6/B5aq6GHdU5M28KTui4V9bbFHnWMN94HgumMftA2Ut7amw1qq1+5GeuxcS8JmKtLax4rDHM+wtG + TXzm6HtPmY/5o1yzxcDaPOBkH/JEWat1lzUdr+sITmCsix6oG/zMffHy7f7VmpWVD0DsbzjbZhXvQtgv + TODJTrUYT/zD+yp+Ru7jn8zPyK182MLNyR+36vOxK4/hjKHGi81PNsCWOz5wcmIDDLwwxuCrZm3V+RrK + gSbn5B/+ETbWrWuRa8O8nE+v0zGpYz70ji915mst1iGmvZ1jeXBab8E1T00e8ORpTdb1nspvPVpNxGbJ + aTm3lW8c4WV99pJZ1Tq/MPKIeTxqki95XSNrpJ/rjJ1LrZrgBTZzXDtygZ/H9/485MrKT1HsFyvsL5/4 + E5tPcHuya4wnPON88mcOfPvCWDt8+iH04z/Y/1muPFLkcZiPy8TmYxpxcjKux7ljwAOTDdGwoXxeaM9Z + M+uZ5zp3/nN8jU/Mzvnkem02zNc5YTMncctbTjD63bJe8h53S67i7h+88lgHmnzJeZz5yk1s5qP2yqk8 + uRU3ntQWJ+ozb/7gJw6r/ZmnHznwWw1nkzU9Dg4te2lv9qk1JCd57af9J9/i/Sh7ZeUnJP53mP3P5fFJ + XE9m9/3JjhcOPPn5AtD5YV1Rk/yD+TuV9qf5Pnv5632RWPkxhY85fUzyscyc6/EN98eqYGnhz9rsSwx4 + YvSPsnesU7Hr4WqvfM4ASz54D38H0mbhXJiJ2PT9OpTrfuULw+sKlNdITOOw9CuX/Uy1P/S+7pprddaH + Coxc5Wh86WGqfdBLeelfOKfv8blmaOFZq3yLgSfXMPTp+epzwcVWLvhm73JcM3s6F3XIsZaqc/U8643z + 8rd4CK6srLyvEl/nUh9TNQttLxDw+QKg+Xgx6DH5VRe+1h/8zbGf2iF2/07qyg8l87GWj0fT8fiMDcw2 + rvJZZ9jklRKPXOttdVlTtc7xGDzkiDF/xzF9lgMkZqAfs9Cv2ZKnKvXOkfuSOWDKK+25qA1lHXnekzzl + aE7jrI9YMc25D6trRJ1grMt8cYmzJnFR8s1OTmCYsWH3/Yjf504PuaYLxhh+xNLr8LpftYqnOs75GV/r + uKbzzn6Ah+HKysr7Jv7l0val0ucJq090s3xi3z3Br1hp1cOfipzn0aMw9Db/bFy2UfpH3/vzlCvvIPr4 + 4mOsP+Zqs6Ilhxg1cvLYB8f5qshFvlvl3WGuzn9qbeSf4yNsnW3OaNdhOmLem5xd87TOu+l5NGP2Ql36 + VIsdl3UET32Ce7s+e7Om1bK+5uv5wIN3h6P21DRrvNt16CNPRb75sLnuyWVvxMmVPoGVZk440bfWu9Oo + D07wD+4+8zVLchE3jXXf4GG4srLyPslHn39sfz/Zn8B8wvOJrk/ssu2JnfG1vsdewzrww6IHajonsOxz + Yvvo23420w6VdvDdn6dc+V0yH7Pu52OrHmd8zDXesXwM8nFIyz6pwHI9YlDtE1pcxlnnGPzRI/MPPEDi + y+PbTDX7wMacjJlredRkDr72cW7yeN/qfjHWevZ2y/zMoada5Vx6oiZ1cNIqnz4s+WY5U+WiRi1r2jpU + xmadX/2o1WPGnANc9PKYfaF3fbMWlhr84kR8vU7nWF7XYk/mBNsfc1pZec/EPibmk5hP8nxiu18v1sqp + 3KgR7fnwVVnnPuuS233y7ziI46PvL17+ej/6XpmSj598vITy8RQYH5v1+MrHGB+fUOLkBSaP0Rtl36hj + bWhx4IOjazBWfeRH2P5LcJgl5qKVeztmp8b8/VrJNRt5coADK07UzvWyr/PD75j0wlpmXZHrPNRqb+Fr + H66h9cpNi/ylHzT7uC851Krerplx5bIH+8CPGYAdZc3En9Lg4ToMQ/+s5XqOHY6vWXm1odKPtWa9jvUf + f21/zx8PxZWVlecWe+fuPFnlbyHjCexPWD6xBbcntjy503eOYKLR49TD1zp98Yh8YXf52f8OZ23g/o7J + fpXQShwg7XGBxwbjfNyqL5j6fHw6Bt/60CpOv7DIJ8/7yWPbc4Ezpp/9MQNrLffYA+TH+Us0nK3Nqtjx + 9T7Qv16z3o+OBXfUcR3nBzY1+NWH6r2sVmyry57g3PCnxjronVjNMOsmL2przsDGNeRcxIuvGhz6wG39 + qcnpa6U9HMcHlzHnCg0+eT2POsON431Vey5q2Rc5KLH9tGll5T2RF5+//DKe1PJkR8wnNrH5ZL7UiXW1 + mkud4F5fGPtUzDVOPHKZT65yBg6+Yf4znvh5yv3o++cl+nji44XKx4k+fgornLXEsgd4/jhT33ndhs81 + YqaWRw/2mfXEsscDD5D5C3amnFPnQcw8Z274wKyO9cnPWO8771lo+bFuYff8iqOnr8+5vF754deMxYt4 + 5tGTmPcrntYnnr72oEUvVfC9f8bBTb7lkO99o7dzElNO5861HAPnd+WIVx4xlPyywW08xMYJK/j+Ms3K + yvOLfTE4n6D6xJ2+5+UJni8Yjh0/eTcvJK2ulHxq5UcPWMfZU3MXXqjF1b/8rKFGz6/soxH76Ht/xubD + FT4mLo8Bqj6mjvrjKB4fePyMxxH4jK+Pu29+zJIfNYVHXHMqj/04i2GPfAcyD5A5Q83EGdu8VOfjfjwR + 09drn8oasxefebeTf2LY4KNnrgkuMeESq97931d5inmd8BM/1jVzEbOH5tiDWPrgZ/3RVi95+o4LT2dU + fOaqxz0WWmuxPrH0qzZ7gZ9WtNeGbzz72Xc8HFdWVp5L4jcq40kZT1Q8efXJLDly8wUAvtZ6fFOfXItb + XWBmc31q4xU+sVlrfmDCw7qVHz7y6X/x6s2xn9gvF+3PU34Ywn/bfLzg39weB7SOQ/n4Ie4xa1iXueJc + 60bu1E5L/sSsrvdC78w//mt8OAOvy2fxuWMexdrcEvca5IkrR3NUr4t+s06VOeVoX2L02zqG3+W0ljEw + 44T2/LzGO0s/+3td9WK99ikec70vc9oz8sCnYk36Zi889oI/89F7zse5yOlxYuxna0CJZw55PBxXVlae + Q+znAe3JmU9QeXJqzBcEfbIzX0/66EMNrPjaw3HmuQ4t1WLn1ItHYYKr77nuU1tv1Pj6VNRcOVr/0v+K + jm3W+1VCP03Jf2dRfXy4D4w4fcVSrQf89niS+FKTeNlQ66++ro86mdnzWP/xB8iYwWcSzZnGfSF3zt1z + oXd1d9fcuXKPqDJDX++en/2J6ZrCKa5yUHOT63jn1lzsqzxdq/Jed8GxjvVDz7vZcqZct3J3/ciNnPYI + 7Vwq+icv8uReeBrDJ+6KPg07up8Uraw8o5wn5Cf6hMwn+niiUvnk99if1BVrbXuyg1d88FhDHuLQwpI3 + sMSlb6u7rGuWGv00r3NoD1rWXHj+V3RexVcJfbYvaO+78N8y1PyK/d8W/7757w1O+3dHj2l7jeQZi3W1 + nlmrseSP1RnDR17xBx4g+TU+nKHmjGsOv/KOM/br47UEn9ynYvasWsRU1DgfWPB6v+Y7JzDy3XdOrEEu + +5YlrzBX6d/wxEYN1ksOfMuzzzV3X1/rdk7hJ5a1ilecnuc9iPvY6o/12PPF9TxyjS9KPv2GoT4wiRML + nLlHPuZXVlaGnCelfUSbT8rQeLLOJ6wpcc2H7U/+tMzBOh/rMd/qwAurWhjr3W/YrD929H6Kn9zMRY+L + Sr9ap+ej36s3/vOU+1d03jvJf2/8G9q/X2L4981/U/xbF16cwqqPct333NXnerM24uOjb9j+WLzWoNcz + vAOp18mZOU/NWnM6/8ka5JgXqz3oZ374bT3xYx2NVVGPtQxr/SdmFv7EGbOv92b+Rp1/wSSW3to3eDE/ + c5Evf3LKdo5q8K948r2++rgPG3Fhhff12U95is861eq1Pwe5svJsYr953J7AUH/xsCcr/Kc49UTuLziz + 3nGLE5MXBeahrdfJ5zpuFefaEbM+ePHCQw6xqr1ymQts5NhfatWGVh/P6TpZH18lFB99/9F+9P1M0v8d + 9d9t/Bs2i8cI1f5N+e/qeXDQO3qpLV9r6Lui56wjt/BQ1jF+lp+BxD3gDI7ZXLgO5lNnfJTX+BS37sH4 + NzD1da73gvcr8oVXz5qXee1x5UWs2vuHrzWMk0vOqAmfc4RfdTVf4tlDMCpy9MnRvuYnd/AiD197iWbO + YtRWjyumdRmz/nfltMfF9x/b+AoPyZWVlUeK/fwIn6j+xBxP3MTFJmfk73Jmta9yE79wClP+k3rTu/V0 + H7jkb7l3HLPfxAHW14vZbV3V4JHj/3t+a/+DtneO9quEHif895r/Tvx3qX9H8iQnmlzY4sVjUfn0PYea + 9FHbZoGylyvXEG39HvoR9sftl2gus/i1VByz41rGdcQ1I5fxTU56eL6tpbmymnP8iR6MyQle5QpDH2CM + ExNtmNUDu58VHPCKq9r5ilEvPaFay7l1reJVL3LUf7IWudSZgz9nuub7jIxzfsdDycNDcmVl5ZHivwgy + noz5RIVlTIz6FJZWejEmRl/7BDew4KFGcSj5mu8x5rLYe00rM4HPGuc0XlhyqYGDP3pnrBzVlh/Xbh99 + v3716TlY7lcJ/UgS97z+venXv0f9u6tlXh8LWh88/vvDnzWwt1zLSdx7l2af5Ab2HO9AtnmG77P7jDVn + WNSxxix4jLW393FbnI5FT+LOYT9dwyw4xY0ZqcTYV3HWVy39whvffMk1HlU5cx3kss7zVz9mkesA5jz6 + zg+sxYJHLqwretEnP/zAq2fg5GtP1v7OdS69gUvuTvdHhFZWnkHOE/PTfKLak/HmCZtPevihwpMcY/pu + 0VcxXS/iqi18ctADGLVhYrMeyjXU5nWwznHa6Bvr3uWPRV332R+Y9HZV7NiYI2oUC4s8Pvrev6Lzwwjv + Nf8t69+BPvP9MUBOcqHuH57r9JkXXPskjtgxrZcaxa7xYw+Q/Es0nIPXqPcirqdmJC9w1t1c76iJvlET + ijq3pYythlz62ZPaehen+sx1qkfk0N9j7XWDyzrkEJ98zSlWNrjJAY8avOBqvfEuPUylh+WLV3hgs0dh + VPZN3H30GL7mWUetPpXXnk0Ptr+4uLLyDIKfycsnaD1x8WRFrvypfCGJJzPryW+9wKEm9xvU+0ov1+PH + ulHPOcKX9c2K6pyp6KUYezuOtelrPWdLTHoVHz2IkesxFTh4nXPtExp/Rcc+svSfp9yPvr+T+D3U+/nU + vU+fKv9W0PnvH1o467y2cRijPvmFa85xie/wR78DOefM62rxfS719OB9IUafNXMN1hVWPvXCwxpU5tRG + rniFl9XaiDtG3GPmFHcb2F2ta/Iqb5b1ra/4rZfj4buFah/yGw84/cyrGk5FHDW4b+QcO2s17z57ZL5q + stY42k9rjr+f1KysPIPwqzjyia9PTKg+YecTup7o/UXJ/KxDbVrFNT+VOKzPN/JzXc3nDFTnDIyKnPna + k/nA+gsfOcQrrjriWWvKGqk135X+qNGerRdiy5/Dw1f285QvPnv56/0f+TdL3LPrvX/q3pLXapCnX5jg + qCkFF/zghmof9tA8sVijelaNrXn+U/Gg3/qvj7Cv94DXELNy3sER33PmZ9z7ui+WNZ0TyvwFP3HWP7mO + 4hGzZta2Gumt/cjL2oaFVcyszqA4+7C/2uQKL3ugXjFel/q9J3pRtYfwGg5b83ebiv5aQ4wxc61/+mE1 + vwfIlZVnEP8YSp6M/uR0yxeX/sJASy7zF8UTm700ly8Asl7m4Sun5Ydmb+HkjNTZk5iozmg8xm7JQy7r + v60/sLuZM2Zecr6m4z0mx/hUxWDf/OL1x/7R9/6cUIn+Oz51XyvPe6ncvL/JYx37WI58cgKLf6foV71Z + X9yuzLGedbNn9viR36VuB0hbT2YOv3Jqpx8aM+f8WY/4G3D2sBxj+mmTRx88seztNeqD47XEzR+1xAKv + +jt+5YpfHPjIk8teWqs51mgf9up1Ze+0cr1P5sXva3TcMM7jsayZ2NDoEbyI2a+UvOgXdv/DvLLyDKIH + yPnkdBxP+oypMz56feILT/jMke+89KM+4qphrPzCMZ/OBP+255hp9tSa6VtNzEGt3sEpjPyoiT6V62t5 + LPOYTUV95Kq2+haXsWKcoXw5VPxMf57S76fc1/DrvsV9LFXM+Y0X9XmPE481iBPLGsekB2L2YG1xguec + zNU89LVHqzn64nO8S/0D/IKWPY44n65F/zoDr6F4vI5UqdF4Yl6v+eMzr1bXcVzqOBN9zwlGn31Ko39y + R7+ypbE++MkNZWy28awvNPOD5/ljdY3Kc33kmUM+LVT5jXu0cpW/8KRH79t7e/4pix7sx3rioch5Tdg9 + QK6sPINwE+ATMq0/OfmEB36UT9ji9BxfBFLJpQ88+7rtLwqRH2uDp5YaPOHfxHdcXWeuwVxaz5Ff8VPc + lqePNSIGz2uuWONZzN7gT1xzhbEHdV5rYP7R9+f4KqHPfh5fJcR7c6d5Py3GPQ68OC0GJ2syH3Hec+FM + rmLks79Zy13j6nUfRx/DiHMOYlB84f13+1vv+dqB3m1dwXIdrJ0YfOWw9imta6+49UkfNTdrEI/6qiO3 + cOEmv7Didn/2SnUsfPYPSxWO9QA3+OpXDdepXlJnPaieD9/rEJfPnoWzF3PVh9zqw1z0rzh4ajvXLdT7 + GUYl5rZjHgu2H2GvrDyD2M9A5hMbGvH1BUJjYl5DSxwY+wReLyTkkvNknfSl6gwZk+e1s3/FukbEuEby + EgePivw3cR278V2NyzrhVK3qTa3YzKNnz5VtvU6+1Wnec6q5fhwqvnj56w/xo29eO67Vr51+08u9rTrz + 5X4Fx3J+T+veMs5aU3K9LnrUGtM+UXu0+ve6wmtG5qnBkxx6h/+736WO1w7M1eoD49rKUUxzbiWfPdkP + fsTHtn6IWYN+XZGbNcKPXPEaF/4dnjn2M5Wezdd44NZvrp+K3q1OsDljYOhtPNRUvtQ5pjecXMtj9BNf + bfQ7casJ9TrM4b7iyEUPmRv4rX+U85m/B8iVlWcQ3yj8yRhPfH0izycsNfKdpz0UK/7ByEm88sqbvSZP + uYnLeoEJf8zXOYK3HHtynvLJTd8s8qzJfOaEQxy12ReaHFnDbGj0DizuQecQq3WqNpS49iUvbK2f1t6l + fP3qUztQ4KHzkxZeZ1w/7hfuR+Vwr4FlHljVRJ/GQV57MFZu4xEDHrnSjtfaimuNYpdaYsS1h+Dsb+9S + n/9MxN96P5u1/wUrewcSnLbm4bf5EkMesSvi6KHcqI8ceKgJbln2oDqmtaOf8oi7FTywwJlrXOs1ORKz + F/s1zGrpQ7Vnw8wHZjGx1k84mtN1za+86slj3bvemYcfav7Eqs/ka+/Ag3M3A2uLG+td63SuPUCurDyL + xF+TqCesqz9J+UKhtp7M+WTPJ7G8UDS8/MyDz15ayzxra+3qkTUDix4Vk+MW/SNmvvvkJi59Wg/glS8e + 4+IHb/ZrGHBijmcca7O34vTNal5z7NV7Fi808MKC432AR13kXvgvZ7z65Kf8pxh5rbwf7us1Q3kvIgcc + cfKZM2U+6+UeSj75Q9scgqnqGsnTvuZrTjDygst/67CFg+c9gMMPLmagAq969MucWGBmZw3x5Gauc9g/ + 7Jy9x4Eda32hrNOazAPLOlrU9Tz6SC57uR9aMbkdu+tBzGKtiZ79GtM3PvuwVvJa02L2h3/J00cu+0M1 + l1Z5d3nhUdsMR3mdoXFPprLPHiBXVp5B4h1IezLiyfuE8kmcWD7Bey2f1K0f4juu9mi1eGHQdbRu4lGv + ua7kaI+sRy+u6bzWI9bQXO8BXJQ59tEa5zgevnIbhwrcLX3E2q8pOckLVbytixr20xnIoxI3tY+5f4q/ + iOPXIfdpXlfcr7oXoSen9wn3VWPtyVjv/bVn1XFN5VMVLx7qEYe9rmN2csiLddm7uD5T43SfNYaFf7eO + 9DOVntGjY9H71Ch2VHnMZz2s4WXHutDi9/nczrWxxqyj3+YhBk0O1bjsi5i9QtEDayo2rWr0OHj2o995 + fb3Oy7VOTG7xq4brhdV8YV4P9VjWDUxqkEuLfMRVy1i5xcd6B98D5MrKM0gdIOuJzicln8gVx5M4nrz6 + hC7L+ojjia785mc9eMgTb3y35Ese2tfuOLnsU71QA+7kdC6uDxz2jDgsezGXawBrPM8V72JFWVv83t9j + 4ZZ/7OGlj5h1xRv1VoN1kgts1rPWD5I/oV++qevlNeG6gfM60x5tXI9pqRFTE5O+FlPJYU9iWutYm6H3 + I3aHM0c8eIKn33PKd19jcsCLOuCIWZP9hpLP2qx3rJTr9lzMWT2YI16xzqE5V/bmnG6jJnrVjMmFMq/9 + 2GNymQvtPbUHc8SzD3sKP2xxqofyuEbE2Ys8wW/zqCWmesHNBz/W7vnAdCZwJHftFRzmZpz9nXtefz7b + A+TKysOFv0npT8z25K0neTyBNQe+5IODHhazZ+aURw1+xaFPreM52FyLarlRN5V9ogd5hWmvhlMzx7kx + A3OOBe71wLRe5whej+lnnH3vryEsMOdVvjDtEzjnU775XKfyFScXvVq9xV+8fGtfYo6H1nstMW9cX/Pd + Mi5L3uRULWLRuG/k1z1kP9aQo70SA+7cuzww4okJHrnDv2DHtnpwgGX+qK5HP+dgjelTdVDWVI+y2e9Y + zYWPWNbK/O061zW87om8+6NPrCkY1q2a8InPHqwtXHiSZz9i5GR/5Kk9Dn72xTrZ23KIySM2+9BnrjjH + jj5uGQNrVnLZk3WwjhtfalIHTr7OGFjk9x3IlZVnkPgZyHqCm9YTNJ7gfNLyye9cz2tOn9RR1+KBz9j8 + lpf6yb3UAMv5qBZDW73H4A/lvLSB3dtYEz5V1q9e0Y+1VMZhmVesuIHP3ojpizLHWu3X+OhHbuunmPsz + x1jmC/vl+/5upMzq85vPa9J7pDm30F6Dewx/8h3L3sITG7zJx79X5o8PGxq9mL/2Caz4rC+O8hi7sm/W + S80F73ORw3zkei359DOGdb5wNW9YcLAe4uKhZtYOHvOXnOBxfcUp/NrnG+OjsybnhHIt+mGlRpVrDMse + qlwr5g4b3Ii9Vvo4Jn7xC49c3YfsJTzPgat1jFlLTPtFnnjEWjOxfQdyZeUZhL+FPZ/E+UQGxidrPqGT + 33GtY41jjKWmbLz4sDb8K6dy5Eturg+/6oLDXPCBCU5M63wdrb3hBdY5rGlcw9zvvJg9OJkTntZSE/M8 + YtS1GsHSwmeN1prv695wiYcfSk7MELnDefM+f/1PXUddi15r+oxxzczRz1rhhPZaV43RI+9Xi4OTPmwo + 5swewNhflZhZ6oljna6BB4dr3tUXF3UjF9pj74Ea+vexYFkfeK6TPMHdx7qi3ot1R5UfeeK1TijqLM9Y + feSqLq5Tc41vvuG+FnzPhU08ffQiJrnUE2fNzIvPPuRq37aGcLPH5HhcVvkau0WPnDHj4tzmtJf75BfH + fdSwft+BXFl5BqmPsEv55Jxx4fIkFq5z1Ged+NGzvzion72Ba4/IoQax2uhDLe5lHq6HOOuFE/VltXbm + E7/hNPwbNPrVzK6oJcY52jzEM1d9Yj5qn1N7kMt+U1k7OdceuN7kvHz7vh4ia0a9PtwHXoPZvL6KeZ1V + R472CZ88rU8dNYqRP/Nci1yq4Y2rGPrQZ63G0y8NbuH0w3qOvsZHtQeVtYYnH7b4Jye45hhXn+IEL3LM + J+a25mF8qQPeayKnONe4+Ed736gJ2+uVx/risa5ylS+c3MoXlzHzZaPWOWapEnMd+syzHzHtpXzlMfb+ + wLPvqGm9qDfYrN0D5MrKM8jli8TtySqqT+zw44mbePr6hBbM+nhcXGJuwU/rHPDEUidutuqjd2CaRw+s + F3j3L2tKn+RCmW86OMS0ln5bxzD6WVPrs4fXMsdY+cCqNvLM9X64J1avmjzUI57KXK0RsfbmWi9ev5+H + yJgb9yZnr2twDNcW19N5ypn3wDH4usZTflPUel76xprlZ874o0aVNdTG8Tj8nIf+4GSfG8z4oeAkBg56 + FZ861iSGmMoa54r2fsLHWlqjfYJX2J16rc1N363wLZfrRD/GYWMO+rdrWT754Vc/8Nlr4G1d+MSrTnve + cARLtZk4F+NjtRdt9pGamEnnjVzi7I0axchNjmN1janMs/74+xH2ysoziL8DeZ6A+USG8olJXF8w4kk9 + 84HpC0bmgWl8yxfO5AVHtfhar9Z9y4MT/e5qgQ1rePLEd3xgzY6a1gc21uQ6srbzuw1fazs/+2Y+cqzR + PponRt/5yHtPU9QwH31jfdWqRU7q7Hsj37dDZLsHMm/gpbxu54x43gf2Uz45mqv6Y2d/wZsCa2t6DP+o + +TOfPnPA0h8cV2LHRk/BGAtmvXpv5LI+ZlLObc7wzEXP4AROTHsELjnEmnPfexYeuVrDseTFGsTNau+s + Qa/Zg7nkqC+89IfOtRTnOvR7zLm1/uSJ2ZrwJ65x1ZeNXrKm9Rq52S9ykTculTh7uKWPfNiO02c/5e07 + kCsrzyD2SzT5BIXWE/P6JL8+eYPDWLW9ADzBMTVe9QuurpUKnL1YN/v2fvIilnWIhad1xDqvYnI072qz + 3flHtY/inIk+OcSc33DJo5ZzdEsfXPhhI69r09ZaVUM+62tdjUurrnz7OPt9+r5IvQ73c1ZcF66prjXw + 0Lh3rsDYT+21t2CzVjCzszZzUObN1lzUmM97Wx00c4bf8KJXXSuxWge1yS2b/eDf6axx/unlahyxVy7x + 4rU+GYeyR+DaM2qergf/gl/9miOs5pXPue+wjIfvOelvuOYyNo70ylpwWg7c6gGO5ukP1Z6scUxqIneN + q5Z6vQ6trbzyTo7XItdg1nQPkCsrzyD8Hkh/UuYTM57QfMJqvp7U9eLQn9QzX73IaVxiUNbPfuEXPpW9 + yGl9GMOvmuKZ9VrBWh/JKcYa9r30QM5j2FDNwT/KPPsVVrzGoSLv+ORYXXKYB8Y8cyeO2shNP6zWRI5x + 9kGONdA3eNg9u3CmnE/m5fyp4KkWFnWs17riAZM+vqYocecaJvWMq0fv02LyqJ6/4lGjcdWzH3PsMfk+ + l/ZHHFjozGdv48Fnnn5X9PR8qPcSnLmG+1pYFzo5zD9V6/mMwbNYLDnB15h5cJWPXK8vjFy10Tti9gis + 7hF7eY1i4M5+9JnPXpcc+kI1vuM3H7zEb5QzNu5d/bF1Pfj3MfzoHiBXVp5B8mt88EStJ2g8Md1mLjDy + ihNPZovZixjzXidaOYnb+lJj6wsv1unc8oPfc2W9j+TJ4RrX+vDv+JpjHTmsZa/gXnPh1/pNDZP65ACn + H71rxoo7t/K4FvYQX3vMPHs656Y2OOEH93buT/DQe1bhdWKmfh3Qut6KCx/Xpnow57oNjLHyilO56Mt1 + O155YoW7av+sg39Ua5WnWHBqBmJhi6dKvse5TsxePcCXWTL2PNbLOCzVYvZlb82T477koq7iwHg9fQaz + cw2tTVx8z1u91DIfFr7m4V95Yx1Zf/Jnjn7EkU+++RJTCwtLXzl3yjr2S4t1iDVtNRGzn/IjFp7p6Kt1 + xPYAubLyDGK/RONPUn9i1pOTWFN5ETB1Hp7c8wmeOPnwG4c55PWFpTDMg3y+qLgvvdA/4p5vtcajgkdO + 8aSvckzBKV/nq/XI57ra84oVN/tYD/TJGDzFol/0Yc3kcz36igc/bKrkmM81xJ/rslbVOMUPzvvwYl/X + LvcvMVybXBOx5CY+6qnSW/PVJ3xyL3ao9sk69wvrvnLgex+py76Ih9Ue5FZO54leytWY/b0f8KwfXPLJ + USzrj2Y9sMwLhz1Y1/vV+lHb54k4uOSTe8W0b3ESR8/KYx3wiCdXY/frWlmvmCvWmP2nr6qY9ih82lLy + glvKHvS1njlXYsZjnVrJT2ucVnt0D5ArK88g7S/RyBOST/rQ+ycteT0+HLwIzFzmYcmttQ4HtVPJZ8/G + Nau+54PL3p5j/uhdznsCox9cztw5bU3RqK8a8thX+zDHuvKFJz07R2Io40vO1uEa0l9rnCP4rOMsrNca + +tqr1qo50OPZP8q2OeZccY1xnby+zik/rktrVXGvJM56uR/BCzVcMfNZzxri4ROPmPWu04dmD/jJOapx + 8DR3rPZM/Lpu9gHe5hvc9J1zxXUO9k2MPPQlxvWozEeucM859+RaTcTZO/PByRywjLmO4Lf9khOzzbzH + sJMTmPpyDaMv/eKw172dqj2znhh15HK+kb/E0Ow5sNDqlT7y7EWu+ftb2CsrzyDxNT58ws4nJ7Bj9QWg + YeMJzpg5V+RmT9bMNYoHTuKIBb+vLe2Y8pSPPt6v8vSp7Nd8neFGtQd5XGuuN3slD36ociPXfI2tlpp4 + 9CGWMWuhiUlt4OjtVu4dsKdw+pzruf/kIWeZ16KzNuV9mLHZo1pvGrFeP5X3puqYd65j8KGMtR/xylVe + 62u9Ozv12rvr6Z/XGnzHjlW9zdl9ou85iZmb9mj1Ynxf65j5Utt09PbZwGdt9B7XI5yYBfmGB5c59mM+ + e1GJG+fY7Ot4v95eQ05h7HEbQ9kzOWLZs7iFc47wcd2I6Vsteb0P62vmhrmtPGP21F6RwwzCZR/D9gC5 + svIMwt/CjidoPVnvn8D9SVu5gcuTnJyIpe+xWcOccLwWHPqRV7y/qLgiV/wrJ+Z9Kld9M28540ADD6u4 + 1rNf8EPpk0ttNdJLczWv5jpn9lWt+uvMtJ4Dt+qCz3ri5CXGXi0X+F3t0bfP+ecOdUa9bvUxZ6hdX96n + 8PWaeu2xyS0OMdYqf/JmvnjFIS9yks96tVJHX+LgyQyOBR79qkfjInfbR9ZK3Pm1jmL0mXP1XMXBUz96 + xXzat6zWa84V6zl2M4f2ZJ45t9BYJ2ZrHOjso5bzNI7E0Rc9sZZztF56xgzM9eshVv6MueaJvVfUk+f5 + XKP3rR5lk6M89L3UTh6xY3vPytHfj7BXVp5B+DOQfHHgEzSULxbHnjif3GYVB5/56sV+FbM26oPPmqqN + HLHAq45YU+C6Bv25jvYu+1S+1057rTuxzog5VJmjH3jvwT7O4TVIL/ZmL/clX3XR8547+/b6Sx01+aGN + Az9rk1t5rzHO61d/jIfhw4Vzc5aYua5F56+5gxO2cPITEw0+13qCh9zEqJyx1sbMwqk87rVgzgU26xmH + rTq3VHAyxxi8tsbIzR66PterePYJTPOlxZlrNNws8RYrt2oa5rOhhmtQFSMHyj7soZzEhGtxW4/W83X9 + rlZLVa7buC+zJ9fJXsJtPSQmljWSZzx7FHaTB4c55hsm62YN8MssxgVmdg+QKyvPIPxb2PnkzCdrqD5J + yfMn8NBv5ODJrvF1jcpbveLeT14wWn/D0a/5zqWi3nO9V+djXfIEr/riE6tczEY+e136uF+41qcFHutJ + P8St96hxC2Vt+IVF3xNL3/SNT5Uc87lWw8c6io+Y6714/eorPAwfLjEn70PMHr7OWbhfA7jk5HWNXNVJ + TC74xLSXctkj+hTHFXjWu606YlrDfPg9x35RK3OJthjcwKuG6rFzek1i5juP9aixHJS8lss6qQFWdTfX + 731iTuYYO0d4kYOfcayvln7WQmdt9UD94EduzKF4+j02rvbLdcHTnrNu8lmTeeVILmaIPNcoZZ5+9SMn + fMXCd56qYdQT33IzF7oHyJWVZxD+DOR8wprvT1pTyQWOFwRw6WctbXILrxrlorcp13G8ejiuayPWmrYO + c1CuUTZm8Hz2vc8x73Fy1Mc8Erd6x8Jnn+B0Zb32mmsHN/pxDfautUZP76G5iInNOsWIE3N/5oBHz8pn + f2hwVA/2+ce/wkPxoZJzjVmvM2JO2LjWXpOK+5BWcuwVfuXDv+GhB3mckxyPqd+AtVmBU7M3fM5Vytyx + 0te1rUPb+5V/zbE/VWuSe9O/1xafmNZonPMeJc56qsfg03du48AffbIX6ovDGa8xe9EPxXWkj76quobo + XCtz9M22GdAfecW7Rf3wo9fAEBO7y1Mzx5nENm7Oh/yN3Z+BXFl5BtE/ZcgnaHtSw88nq/lUx8IGf9Z3 + 3Hnuo4aKXhcLX+uz1jjK81y8ICYftcrJOq11Hq7txFwrfeQvuHLZA35hyhUO8oFrj4ipxQktv+e8XnPE + jCOquVhj8E3Bm1y14QfX4+zP3OHpepmvetMXX7z8Eg/Fh4rNwfnDj3k5V5v7Kcws/NbjaN2H4qR1XO6v + 4FEbs2U/5gZG3sSjR1nPiQ08+KzXvFnWaf+O0595rAFMZ1JtfMRpwWdvrZm9a33wNHY71hg8xsZveeVr + Dn7w73I9Zm/6ipuNXtGPOeVnP+N7XNdD/p1ee0qca1dOca7lPvK55qW2OIypFmfu1GUfw9FLueGTO+rN + x9rTGnffgVxZeQbxn4HkE9btfOGhLTyf0OJf6+KFIJ/sgvea8pOvNYhnb40j3/tk/qZXxkeNN3tFPeYh + hrzyY45YV3nBQU5qI3e9ZsapjpF/k4dmL+mR3Lu+olELjs2ofPg+g+WcV3XJRZ3mWZ/+0egF/g3+HL9M + 4/PILDpPXF/F5PJ+MGbNrJ/3IjFev1n6UNaWf8XChrKOWJtL+ivGfqGSE611o4Z9Inf40oe+58HNWucT + q3rWaY37jIXLePYJX2egSm/wsteIsxc0sclhP7NHiXEt8jx2W/zAe2zWY9Ho0Wcit9WI1b7kcwbFNC6e + +nKdwnNV7NheGzNrDWP2Db8w54If9VWrPZI7cLXZC7x9B3Jl5RmEf8qQqk9Yj/EkjReFyPFJy5i84MgT + HFb7Bn9gqGWucbSv9DKrPapO5r7kIj+x5I4acogT4xrs5Xkq8mkP1nhmh9/4zN3UsR8xi6kR97o2P5Tz + ewwO+cWxnszDH/zSwOY65Lce5AjXc5+/fPjH2HlNMs+ckdfoWMbk1j3LXrRUwY1Ttdd8WlVwfS335T5m + PuaInM5afMezvni0VdPrFXMrM2re/ZarGvJcjQNtfcUq97b2+Nm3YcQx51Hy2CfXQE36jL2m+rCOedZn + LnGtkTrg5Dg21pi9VclrOPitznve1/cYa1ps9VJ3xctGnXLBM8u4WeGDxxzzuQZi1jiHvZ3DHGvAg8/6 + PUCurDyDtHcg8WT0Jy99PlGP5ZO68pELlRr4rJ1P+N5j8iuvPrnVCznJN7xhnDGUeFOtg7Verd+xHjuO + WRQn7yYfWOUyHjXRi1a5NXv4UZtriFYu+E25ntaSi1z6qo5X3nzyIpbrFZ7WskZrTV98/viPsTmrzyHz + xHyF6TURr2vitUhu+MXrvQKHn+tKXtYgxjzXyxrjkv/61R/bO7r2kZ75J//lwd/e9se6tO4jnz76Nn/y + haMzkqc1yUdNm985gsGyZ/MRR4+aWzHi2o++5rVO/c6tHGsNY4/wwTG1HlTEM++1xJ/gRd/BA1fryGGP + 9KmCRU/BEue1hFWtGa4cnbHxzZ/9EV9qaEWZVx775jUA2wPkysozCL/G507ticknaT2BK3afT3BygLOW + vuH/zT/874BXLuuzNnzmdO1UcIPHFxT2jd7kESMn60fc6qCel1zLWw/PwRdM47lG5qYKnjxiYmOO6Dn7 + cUbiZtXvfRAD87jZ8rOOmNf3vMXMU1kTOPiypqv7L9/i4fgwafO1+TkT8c4LzsCknnHLH8trz3uAXNwX + xOLrGlkj/OJRg//UVyP98jd/+Hu/eP3xH5wen8Qvzsl6mIt9shc44fd5NPbZlIOYfdM27jWfHM8HHrnA + pt949GFDwaWC51ZqyC0LHvTSx7Hq77b1DGux8dRPbsNCI6589UcPYKXzetEf6nmu5bHg5ltuzkAc3OB3 + XvjoM7hVc9Mv60KVS9+52lNqEmMsffdnIFdWnkH0AJkvCPmkjRek2yev+B7jyTx9cq3Xn/7zP//a5K/+ + w7/9+i+++mdf/8n//A++/tv/05+AVy8i6ecs/QXmwgVGv+XcMkZOOKnAog99Kvomp7iGtXU8jrzyqS3v + mL4oY53k1f2nP/tqH1r6ildN5cNHD8mHLSxmeTqnlv3ZlzV3mrlT+9c/f/k38JB8iOhcOa9cS5v7Jk7/ + qF4H7bx+vX/EPUZNxMWr+ujHOvelPznJ/w7frWn33H584NR9etZ8k+ugf67tMa8jZo48rgFc5sjreVwT + +vk6UMep6J08j59es3rU2uQqHnW0mAXcrBPs0tstfOl35WA+9Iya4k1lzq3UcAb2nTNlnDVYU5X5ozEX + sIYXxrV0XeaJUVnvtaNP1jmO+YFpH9aTS15gxUmu+8Unx3TfgVxZeQZpfwsbT9CnnqyKX5744GjOazKu + A+Sd/Mt/99XJ/9nXf+8vPsc7lexZvblO4ujLXPjEUWP8jMNnv8TAYQ9yWOc+ajKnmFtgsLd45iQGxhrL + PbUmfeUo19Viz2sdMcZxz6jkh1aP7MfejI9OntZ6T8eoFZOfFv6j/7ShzuDzyVwZ32B1LXK/hNPuAfyI + 4XvtjGt99lW8Wa0/vtchNn3xPb+cnR99248VnP5fsb8r1ssZJRfrx3yJY1barCMOTd/xcQ/Rj/g35dmD + 9qk1qib8Sz/kE4PVHrmecMIvjP2vOK9FeKZzlvSLS2z2Db9mTctroRW/+o4aYFpj+MSIu58963qSf9R5 + ySEPteSKFids5tCPvah7gFxZeQaJj7Piyc0naj5p+SSVJ217MjPn/NDbGNj/cA6I31b+03/5z1//03/9 + L7zmD//s73/9N//07+aaNgP70691x9y0VMV/l4Ln/VvM+4Wc+zIH4uyTnPCzn/vBi171ourWeiFHTHka + sz995TOe/dL3WvbQNZQX6ykn/M7hGrTRS3iJV3/zz8HnUzwkHyI+C+eB+jzp17Um9wnN6zY1bFrhhTJW + vHznz7U9ho9Y+5P7Xd6B/DbCj77tYGp/9vTFFy/f5rqYsZSz1EyqrIk68NBLaxhnTcaBOZ516odlf9YS + CzzmzN6JVw17Ng6srqH11NnXfPaOtZHPuHisJyfz8LO/21Ctyz6iyXE/emvP6AMMfbW28phb14JPntZx + FtZmXnDyNc5a9NZ8Wwcc+vsR9srKM4htCv5E9SdsPUH7kzdixVT1Sd2e4MP/LgfIO7GPvnNG9s+554vN + mNd5iK0WmrXEwNce9/nuO4eY94046skLf2LK5xqMnYe1ySWn8IizLzHwdA3D2Zu8wEOV5xyq9nJbyprG + FyWH6xXOdY9/Hod4SD5ErnOUn3OOa2ZMP+sMHzp7sodh2a/lEWct+eE3DnD6qaf2+74D+W2EH32/+Fze + oWzXjVnHtTjnWI89JzH8qcUJHm3rdWNdweEcirNH9APuPvuEP3O5vlvh2Fq6jsWZZ13l1Wdt73ly7Kd9 + NX/hhrKXq/kaA+s1MZ/l1Gov8jsHMxk+eNGzfOWwZvZhrJgrubMGsekeIFdWnkH4NT58UobGkzWeoMTw + goAnbPngi/JJTQ6f6N/3AGnCuWqteCHRWS+x8zpGnPNFjjr7gEM+NHu0evZHHfSCoybqZBbkyNd65pRT + fmHZf/BynpmzmBh5nits5nWNiGuNVjcwzhcWa3vusb9IU7PUPD6LXzfxfm88tlmdU7jmskbyxNp1uy9x + cgPLumNdJe/+6E3/EQdICn/85X4uzAZcr8X8GZMX8R0WceRCta/H0FaPmH20X9Wa37nEsg/X0j5U1k1F + fvaY3Fgn8hOPmqhjv+qj14CcWtbBj7r7Wvezd8XkaI9m6YNbGjn1qeSwx+SrpXpe1qnasHuAXFl5BslN + wJ+Y8gR9wi/OsUdpqRYHr79ImP2mn4H8tlLroD/W5Bpcr+aUWcgB3zHnAGeOPuOBcT291uSZoi7nEvxu + Dmr2Ai8U+dGzeIU7hpjaMOsBJa756BGqNbUG12St+oWxzu1UrH+Xx0PyIcL1fd7j533AbO16gEXMf5eT + F27cC3KK6z1NnRd25oizrnpeZwoFdqz5VIsfeYCMTy9iLp0nLGeVa0Cuz95rqz54rQ/isMwFP2piLXKU + 72o8YBPX9RJHnJjwvJcqMdQ1H3o/K3zhVC6ur2NVn3WSTwWu62otrfanZo31gF818Eeu8t1esFYTvvPQ + T2uKU/2T63jx92cgV1aeQfJnIPFE1Cc18cznE7fw9gJAH7m0J2c8+yWZ7yuzr6+H/jGPzob5dG6pqVrg + 8LWm9wptdZKnX3Xd1hqTN3q2tUPpE4+Ya4avfaum+jE3/YjF6oyYSXu3OcElngq+1oVf6jWieEg+RNoM + mNe0zSfXFtdSmrlRW9c+c7wXhVVO4qznPcN9Fk7rfazO9Oh3IDlnm9tnqpjXnVzEWkeMfGLE3Teu9+Ya + ck+lD3lVH+uqzTrT7BV9m07+TT51YNf1sAZz5B5LPBU51irOPlljXMd7nvVp73JWa3WIlUc8cqHOzz6a + 6/zOA1di8tgjfK7d61hb9eAKb9+BXFl5BuEmUE9aPGGh9DXvOXtCS45P8HiSC5e8Y3+YA2StZ2tof2Lk + hM+4v8Cx1nuZot6VsfOesnwBUz/WU9/52atmYJ+mNzyd467escOhLS4w43le7BOaNcIPvK/LHr0/73PV + udUezlMsfPbBQ/IhMmfgvB47jn87qnGypq67uHF97JFY+mqjTnsRI+eS876xRrPMQx9/gOzr10w1o86v + M9NPFb5a5Xt8eORHTjBwy4+arEV+4qHoZbXZW6yuB5zxVcG7qbnDM3/wiWWOilqq5UMr7vnyXedMsqbn + ROd1qzofqmt4rtUcP2PhINba5GB97TN99jbdA+TKyjOI/hxTPSnlxcFyjsNPHvyjyqfvFv1Y90P9DOTd + LLkOtHGozINPnRz2yh5SQx45FYNH7Fjyp01/9C1bPS79gJnfrjs54SvXc8Ru8tWLfuToeyw5crWnW1nL + FTG59D2W/szhIfkQ4Zo+oyrweX30Y/64Vs1FHKp90gefNekjf1t7o84xzTr2i/jhPwOJtTmHzzWuIfOK + H79ml1rkWRNKX/Poh5rsAd+5WCPqK04Lfq8LdUx7ew1jqQdetZMXfvZJv3Cu41ZVOKz1upHLvNaJ7TOU + HzH7Rn3rTys85TImZrVh5T6A1/OBk6s96Kc6jxZ5qQ3dA+TKyrNIbQL1xI6Ytp6ojPNJLRxiocXPJ/6x + P8Q7kLVmra9xrguMs9DnPJ1Xs+p1MJ9qebVHe5/RC1j0jBkuPdSCRyxnkFjXIDfXlJz6ZrWONeyXXKwz + exKjzxr60avWci5UcxFXLevp4yH5EKm5u+V1zrk548QyHlp9b64/a8lhPNYjXzBytG/0ifyzfITdrgez + QvWaLvMCC6VPPGLvY5jHoexH3H3UMK4+7I85jqYvPYIzMfiGEacvsfHY86l1glN11xzWZ479qYyzvpSc + wnC92TvqKheWdVFba2a95Fmvlrnk3uQuPrSvhzpyPK68Yokf1Zo9QK6sPIPwZyBD64kaT9CyVI3Nb092 + zxXmOGLL/RDvQMaLjayPGWgj1+eIuQSXWOvUkhMY+aiBqh8x1ygufeaVGxb1OUdhLefzwPfcqeeMmZd1 + wA/FDKglN/HEiq99PI9c5wWn+B0v7L6fq8yCh+RDRGfh+pyJfuI6s8ybGPQO5/3wHtoHWNSMWsc7r2Go + y7xwnuMAmdd3rM54Ucm3+U+OPa794r5UvmzlnrjnVKnTWnKr5trrVq2PxFEb9RXTv2KsN2zGjrF/4rh+ + 5Gdv9RWr3I213mOdyJ16wbke8VpH+OJrrH1V2St92JxLeJUHzhlgmd8D5MrKMwg/ws4n43hi6xM68NCo + 6bnkot+s/WEOkDdzYRauWfPJNWUMnlvFpB/irIXPOsbseZd39XzFrGk+OejFWXJ9yWnP4qqNnskFTr8p + eccS035PxbO29fA4bONDo1efJ9YIxUPyIcI5ORNjnyvnr2snl7jmk/OUWj/Vg2nfiNmz8tEf90t5x2c+ + fF7D47/G5zInNLCakfPnNcCPOFR5v7MOuaxDnlo1hTNmrmn26Pap3rRXzjflgB+s1qma/z97f9MrXXZc + B8J/oX+Cxy4L8k/wxB5r6J5p2JpxZqGqADVgW5MecEDNbIACWKQAmQDRgEVNRBimwBc2YLEAGS1RExZa + kFqwLLg8kGRYk+fdEWutiBX7nPuQrrqV+RS5NxCIiBUrPvbJPOeem5k3b/W0WOYnX30nF35zxBtyE1OO + +4qD67ErXrXGbOghnnpUrej3Al94+cqhOG/E6J8byLPOesLK/4V9c1LqJB4ntPDgUyp+wVor97VuIKtu + 9JOWbLhmS70wzXO9qLndewr8V3/vX735jf/47fwXi8hFrasNLVs1EqPuulMXp3jT99xLHY95juL0L9y0 + TTM34pp/F8+XL0w1ZKu2c7rHjAXGp+RDVs/U/X0W+drT8FO/fAy8ZvN3HHmJsX7FE+/jrZhjqZmnnMSf + 8hnIfuzHTEvXHnYesebBdn7h1LVns1Gz8T13z5MUHr7FRj1JxeC37sdDeOWK77LlVG7aiJfIZ1y54EoL + B0e13b+rJ15hiisntXjGoVQuZfebZ7HA5JdtfuWgJ7TNaYI4cwNbeecG8qyznrDqBpInb9o8UXVyOn45 + oW/40nGSO/ZaX+PjUn2XeL+M2Ww7NyXixvULk/ih/cb3b//uf7z547/8ce4l/m93/otF1VDN0LS7NvSM + QYfvcc8RR7PNOPNlMwZu6ztOaGCwwe99Zw75nvsSjl6Mi0O7exBPu/sqxqfkQ5bPrX34fGMfigkjjuPl + NeArX7bvMW3mS5w34qEl9NXLMec++gZyzBz96Se25tKetUdwOC9jvo/KZS2PlZbt+A1H+dV7YKwtYY3A + x8ys19iWzzxh4EGcN3OJM081lO95Xr/w4dMm1vkS78+4alaO9bK497pwiFW99GGPXpTKD1Ft2h5HrtuM + BS/zOkdYyLmBPOusJyy9ilAnpGxKnbxp03d8iZ/k44Qf+LwR+6wrLyAmPockMXE2LPRuq2biwU+b+Ut+ + +w/fPvdf/fWnb/7gz//ozW/+8Hfy1crMYx2JesrGcSIv55ux5KrGpkdu2qwdvktgkuVrf5VPGf0sb59T + 2nmqWXZwKKqLOog5pzH4fEo+ZHlfF8xKv/ZFe0nObLgEMeNLmAd8Pz7Wq7ClWav46eMYKidjxL3+I28g + 44vE91mlcyZKzsU5fX+ua/7UxBUT78ZX7fQT7+OBeNuN2Yw7tgt7eY/Gu86Ik1O9hRVuM3tcPjH19die + C07nlPZ6WQt5sIGP2i/kOF9x1Rp1bjRs5pb/Qk/ZS679Og9248lbcm4gzzrrCUs/BHBC6gIw7St21Wnz + AuAYBP5rvoWtmUKrr/o47nP7XLJLJ7djXvOz/Aed+L/d3/2TH7z52n/49ptf+e7Xqr/6Qbp3SWLiOB+2 + S+WHb/kXbTLqWBw92GfhquvYnjN808UnVjM6zljpJXxKPmTd7VN+zZs+RDOC69JcxCy/fHCLZ3WTO3Jl + v4AZF3XQS7yHv4XNeTSf5pkzuo3joz1lPkWcwk0rp+t0reSlD/6onfjkJU5Bnea5lpSv2sqvuOd2fNa+ + 8gtjrb3vRbLm9ThErHJZq/v33m+1+BLLL05q4sTSL86s5fXFU9xnqrgk8lnDfXFRs7HiLTk3kGed9YSl + t6FwUuJk1EkOez9xxZkn9bQhnh/yGjeQVTMuLqybIp+6+9Pe+ZLcEy9ktLsG8NeaGzVnbUgfo5rF/H1P + hW92cSmjPmukVGzWKF81xNlt+sVVTNiOM8drIUYeY3xKPmRFP8k+7x5zW3LBuI/drsds+b7fxrpHYmaL + 35o9hYlr9R75RzT5yyf7ps556BMr/05TsC9we3+2rxBiiQ8MdmvGLz0k6HXXQ/UdV05yAmOeapSQO3KK + y3wTYcoR5rjkEvd+2aPjyeVM4opXHMtx3HsVV5q8PSa7ufe8UWOrlf4uyiGn9lCxyTk3kGed9YSFG8g+ + MSV+wsoOrQvB5cJATJJ1ArfcV7kRY68xY2jZ2Yv9k8P50m5OxYiLF9rrvtbcPtPowx6KaRbNI27xiIm/ + +8iX3T3kl1bOyO0ZR68lqgWZsynvVgfPMPllV43n/BGNz6RjpT3W/Dnj5JQwtzjU2lNxbnl9TMrehXzV + qrpRj6J4xp7wRzQ9F46XZgHescLJUW75qZur/MDdzhoVR70hxF2S77lpQ2Qr37G2ey7VSB054g1u81xm + jvGsh+IXTuqFb9zqXbG2HQ/ddbpe1Q/OxlM951c8Y5yDeNWomPgSx1QTtZTjdZQjnrh7rXMDedZZT1j1 + QyBOWJ6MdRK7jHhjOJE7hnhfBLzWa95AjhmJ7XbOtcdCZwwXouGnhv3ac+810cswm6VjwO+Ob+Yx5+pL + gCk/ferGmhf+5MMHZpyMeT/16Zk9hh7kRXzjyOdT8iGr5rE5axbOI/uyB84ePuLkG+586YwHlzJ6Vl7w + JcKEW37yr/nP+h7ImuWFuSTCnLvHlN+accVGXuiWyUHNgRsmX/XVQ+J1il8+JLnUipcd+CaZI02eS9Xb + uamtZuYS836RL5/a89QXMWDA3zIDueJXjbQjh77XlG25mkM9hh/ckKgj28T7tO55zw3kWWc9YeUNpE5K + CX2dtDpJ5wlNfLPhbxci6s/yWcJ9qb56leTMhu8+JffJWO8RPNmFce7XuvG99tNMnJP9NGNhjksUf4vt + 9SEd9znkR0w68b1W+MnZcLPdr7jVq7jVBu+xb2H3PL1viHBozbYL8BnPmpsgtuyqBaw4xH2Gvf+IWV75 + wSP30X9Eczez/JxHcdrQNi/jzsk4edP22OxZfRVzHu3mSayGfPGovT785qiOxzMmXCLcciDXOUO3EN/r + Vh3w5CdHduRQ9pzBCb3ZO7/yKt6zXmq4EPPckPIzJqzjkr1n9XOJ+NLvfePcQJ511sNX/RHNkj6ZceLW + SbvhfuICt7hi8mkH/io3YltdXNyAXeajrZjixaOoRvsrbjVe5V8wsp7P0VjjFZMEZ/DADcy5OT95JZXX + +xk1yMlc4vJnbdiFRy2vzRhytz0QK3/gk8+n5EOW5vC5c0+cqzQ5ivu8yS9ux3fc+c5rQSw5FPQknnzG + ttzKI/6MLxL3GTT/Ppfw2kfawGecx6P8u3jvXTHluC/b8fbbTuG8iW8zA++5MhZ88ZibkhjE87qucMQ6 + R/tSDKK6ZUcv43cctngV3/nhk5PiPnmFM4ZZGletwovXuDCPpS/Z4hee42bfzRL6vAJ51llPWPpXhnXy + 6mT1E9VEJ3DnQOpklm8x4a/3CiTn4QUlbeJTev6yOeeFM/COB/7ab2FX31V7+OwHrPnCK8fyxL3wDBev + sLsemdfc1MZrzmZXHvA9333Zw2edsPmUfMhCT+6Fc2Cu3l/FKGOPioeuPfTxcCx9CfHMW77i4hYvsY7L + z5j18HrJffRnIPf+mnFJ4prT5kWs88R/SbyO10dscnRcpIVJPGeI5gid+arH3s4xnjgQ1M6crNGxyiNH + cfnOqRzr53UTG71bN968zDP/ggdGv8Xx5u6685b9Aq9mkURd15Q5c2O3tSw3sHMDedZZT1j+l5R+grbW + ySsOcMXCh8wLh7jpx8m+5LVeyVNdnwW9pTlDSPR2bTbqqBbnJEc1Qr/eDSR6+5zq475jKTez/yTdvboe + bOg732XEoiZrKQbtfHEcYy5jwjs++XxKPmRhf9hj9ud8dzM312LiGi+0sH1vXaNt8RRH/uTP2sKbp5js + R99A7nOmTV0z5uyOS8KfeZLyq65yHUOdjgOTn/kU5068ucqv3L3P5hdmeOUtke96nytF3C1PsSGOkZM1 + l4/56buQu/cHl30NT2EP5CBvr1tzWr44ypuxF3plbOaUbbh88b3WuYE866wnrMv3QI4Tnhj9iwQ3T3ae + 0CbDT87r3IjNHpxXM1NrZs1/2Qdn1ly3nPTBeZ3/oNP9vHZK2C43PNc+MzjwR73dJncX9ZGtmilbXvUo + H7LHNGPyFqa60I2PGsvnU/Ihy2f2PVxm5Jzg9fFxXmrxXvJv9KxteNozDoz9zRdfvGfcQNacnElYxdJu + vecgr2OTK6xrZpx45r9Qd487T77EfcTBabv7Jy/4FPAk3bPj7Gd4YVmz84QJV42KhWSs5xg8xeijz5y5 + e7XWDOI6pryscVOnMOZ1vEW5ZVPvPeSPvhXDTJVf2IfnBvKss56x8EH4Phn7RKftJyxxP8nbNh5FHPmv + 9RZ2zUdb9X0O752avJfmTV8SeNYA91XmrpqYK2fyntmr495fseSxhupdY9MXH0KM8cLShi++OClVd8MZ + Cz1qs4bXK3/LU27E+JR8yEJfzKdZ+ljM2XtOHC/FYSNfPK+x56VPbsbZe/jimSjetRmz3MBSP+EzkDUP + Z3rbPgZ2s/eqV7721nzPl10zDGwem4xJEmteYDsnfcWpJeF7ja7JOP3GZxwzwS/ujXQesUu9q501iQVf + PTOXohzkvX2m9CumfGHdy7HBM35zZ8zjsqvfJuB3LPT5I5qzznrC8h8CdSLXST0xnbxpl++2n/jzohCc + V3kL2/pEzexvPYZess/gM5ZvfEnVXbHXfOXUZ5ev49UYtPMrT7bNvMd6bzcc5YUmp8U4Fkf+1B3nLLKT + s9W5wcKHIB7Cp+RD1ksztc25zPdjUD7jyaX03vqxKE7WAl6x0BRhmgW8nsu5w2f8GTeQNVv0t3l8buG3 + +9k4wveciockH8dYGHiTW70YU65inq9Y8qg930Wc3a8eiaF29cj4tZ/siEGA7z3u+B4L/sBuuBXf6qLv + Loox72amxDcMODHmFI/48Pd4YeYzR3WdH/Z5BfKss56w4o9odBLmSeknJ09+2SXyFVsinmuvE/o1XslD + Xfa5mcFjtafEpNvec8CXbvu1XzmNut2fvu2l4r4H3yvtxFM3Vxzv0Vj3Cq3anpe1KXe48go3Ue07P3Oq + BvPLh/Ap+ZB1N1fNfIPfxS/c8KVpa6/iOgac9gXfc9pOkb1091gzPfAGUteO6l22zZez3+/X48Kx7641 + cmSPXJeOVc7GUVz1yiauGnutzF2iul4fPnTzkdN84eQZJl/9XvK9pkRx4JNTdSjCIh554nqfl2oKEyfz + QrzOC4I459n4qa22BH3pV07XaByxcwN51llPWP5HNKV5wg78BUkec9yvkz+E9V77a3z2HsOmBPfuQoQL + z84Fr+PYy6vMXb3RY/brvj5n2iNuPMt3TPbIId4xj7cvEe55dyKOcpKfvnDUBtel457Dp+RD1t5bGoL9 + JB52xponP+3E6VOKGz45laMY63QO+bQlyEMM2MwRR9ijv8ZHfbWfmm/szXxq7aniFqt4+C4Vmzl1XMjT + cRFHsWtOc8C790OPePQhx+vuucUpbOnItf7up11c81/Qdz1+ImfhPm/NNDDMphnu+iivucLbLp7bl170 + DS/7wrXajAk7N5BnnfWE5T8EdJL6CVwnrMUljVuOY2FnDZzkr/XHKF67enJWxdATfS98y6uYbOMo9lpv + vfeM7EFxXzPczkxRLPReS3zEWCP9xotXXItZvngZT73XbLu5wIrLeqUZGxzifEo+ZOU8Oe+cCyKbs5Kr + PQCHX/HwiZX9Fl/5sFHDa6VNzpghMErP2fLwG8ic7zpbCmfO+ZePGYV1XByPe77s5qgeMI9PHnLb71zP + F9Z8aNiMV11o+M1tfVff6zUmyRjrjbrLVo76w2cPxodOngSzS1RDscxxYW7bG2fDnOsx4a3Ru2SLeTzw + 2aNtl8xnrZBzA3nWWU9Y+ByTneA8MesETVsXnY7rxC1RTtnIETf813sFkn1uZMyZNi5QmiXs4mtmm3Fq + 4L/9h6/zCmSJemT/vSfwsFPM3vclO0W1s+bU4le+YcUrDiR5xp1x5pou8drUxWEv9xt/4n+iCTvnktYe + 97j2BF/7Edbx1mnHPimFMU+5IxZc5l90xZjPumkH/ozPQEbfFBy3Mdc+r8dkE+8aPD4jdj0Gju/1xPP5 + Ml5+xz0WuPfIWPKsj3zmj7ydX37nXOLFYTy5HQtcMc/z2XoOcqoObRPwDWfurU2+uF47xGulHnhr5XtO + 8i95uw8bOLAUqxdybiDPOusJ6+6vsIdPWyd6xnjiil8nsnH8ZFedV/tjFPWz+t1XF5x9dmLMVU7HO69m + J/c15q5+2+wSHbO9t88mHnRj5UdO8htHDHHVl+957kuqhuKmJzdsiWOtRx3jVY8lfEo+ZI3eNhfs6ft+ + PUc4Yq2Dl1xy3BevapifMWK39YhVHushTv/Rn4HkDD5TzfmSbFzt9aVcr19cinwdX48VHnbEFF964IU1 + vtcrftodDy0ZvMi12sotTuYaP+2OOVY5tIfPOrc9hn+No1/7FWetvQcEWOdNDW5z0tZsoSkDF2/jKDZ5 + E5N/biDPOusJq9+G4gltJ2adrCHG8Vhgbos786Bf7fsUl9S8tDHTnAUYejfGGQ0f9tLOi/zXuYFEfc10 + O4vN0/17T4UP3tI2s9eeebST23gJ+yvf/YgLSy0+Y/KR29ydp5hq7LX4lHzIwrw8Rpw95+Asc06blZK+ + 8iRbvuuKb7bqCAt/YMZNbZxr7pKH3kDil8+cI2ZI2+ekbTHM3T54vQ9wrjlVx+qKp5xZm8dnsyUeqxk2 + rvpkjjjs6/yds+c1PmNVJ+PNB46Y+B4f2mxxy5a/JPsYpnnA1WwtjV/jXuNSu2Kdf+XPWOqFe3751MpB + /pwn5HyNz1lnPWHpBnKctDxhZbvsJ25jHX+J91qv5FUfXkzCv2DcT9jjAkVcfOXf7Ve5r/n1Q+pX8xCH + Jv7CjJWzdGLkeX7hldt25qaNvPSZP7mT731Gj8Jpb/zCqD0f2uU5f0SDWfa5gGlm511z3J+c3jPx5etY + gEM7eZ1T+cEVj3niFJd2zfGEP6J5ab7aE2NDuK+dDxvSPKtBX3mOI0Z/yUu1nV+y8dz3HGAtygW/ucoV + Lmz60Ck1g/TcX/lmOyYf0nl7DDZzuZ+Ouz9jk3OtK07VTG1cm8dzZh+J1SPW8dlH2LmBPOusJyz9EMgT + XBK+y1tP/pbb3CXivt5bwavu6oW+uvj0BSfF9oKcFR/+zKn5KeIH/ppfP9T16RPzfjXPFndOC3HjShRX + vZCuB7tydyz9rqv8wKSzj8WUK1F86Ds7857xCmT3nvP3XCXk177S17Fwv7GWrilfNVI2rHMWFnnGk1TM + /JQHvwKJeecsPg/sK1b78b1RY/8WUzzxmS8uJOq3r5zgpi+9BJxVy2LiV4/yaVfPnqHqkAP/hksJvzh3 + 2JjDtOHoi9mbSz9j9FM7hzZ5jVst06qx+15zxKglWSuEOcDJNb3HKy/r7XGrz1jIeQv7rLOesPQ1PnVS + bifvOKHlS3aMPrD9AvJKf0SjHqpd9SdWfmhJ4n7R4oxptxYu7FXmjlqsGfVnb/WbeMchzk8e7eRafMev + ueQtbOQT61j7xRNuGGruIq44rGWYRDl8Sj5kVf+aqf2enfHyMafnVZ0ld3nie171kqhWxubxGj3Fpe1c + 8R/9V9je22fD7BP7SXuBtF+aPM9FX8QmB9p5gx+++ip3w7yWBNyODa5JcizuM3qs8bZTBsf8UWvHGXM8 + seZUXtgZAz+0483V46Ge8o0n2/3ktla+BBi4GaNWbfG7Bmegn7py2j43kGed9YTVN5B9cpbPE7ZO1vB5 + UstO/q6ZI65yX+1GLOuzV/agH/2rp19gjB8SPNMjv3zkh36tLxJXn6iJOdVPvaZ/mW2fl3jWE6a65EqU + A+EFWWK1xX0p7rVfqrfnZ1z1l1bca4XwKfmQpTnG7InRH3MCCw3peMcmz/PDTk1RvsRrFs9s1AYPvs8A + TPgjbyDjj2iyP/fh8xSetvnEUm5sPw6XPaY9sfQlzAPe/R0vsVrhV52txl4/fIk4XkM5PR/jxVG8OcpF + ffDTF2568Ie2vuylOt7H8cnz5xTxJSPX60Uu8yq+cxxnTPHw9z7pB6ewtne/bNY8N5BnnfWEVW9h86TE + icyTnyenx8StE13a4qrh/LBf6wYyLx6ajbL3Vt+ajxxI4y9hbb/iH9FYzbSXZK/E5rFSXDmlLa46qcUx + P3TVTXzus2qlvvIV95yMh03x/PJTd464incvCXL4lHzI0lw5J8Vn6X1p3l1b/tKqITtxx4yjOrD7eLUd + PabsNe4kuU/6DCTm9FmWrr3AdinuhuVeb7QE9Xg8Bs9r0C8bOW53PY+zLmu7Rhx+8ZxTPK8HHBhE+aqx + 88URr3tzZuY03rzu1fXE81jV9njks4bjxaNcsOLBVo30U6O2cjADfEnlMVc24m17vxFfcj4DedZZT1gv + fQZSJ7p8xXTS6oTWyZycgYvb8ip/jDLm4wXEMM1RM+2zhS8xvGLMkR81X/dfGXaP7t924hYb+NLBHfxN + FMv5w/Zay0a+HhPyrTY4iumxvNby+B5TjXucMbcZ51PyIctnkuT+l8RMEHIS61hz3BcGUR7qtt/8zu/a + zCmctTRbzQnslveEG0jNgtlsxjHfxIvrwrj4Ffc84hDjeb1l7/Ucl5+6OIq1Vm7V3XDlVr8Qw8Tt3Ls+ + iDsvxWveydZ7rzfs4Pg85itesRf4ra921Qkxbvhl05d4HeVULfqjHnPgX2ucVyDPOusJK38IrBOwT2yd + yDy5eaJmvPzmOHf4zIGP3Fe5EbNZ0RM9ut+MX/k9a8Xoex2X13wFUvO6NA6JnohB5xwxK0Uc8Cwmm3jF + 0u79lW21qiYxyMzxWnudqkVbtYBvdRhTH9l8Sj5kaTbMBO0z7fMWh1J7ypywu0bxth7FY444wqFRs2qQ + s+sLX9ijbyDZOyVms7l6rx3PeclDbB4H51WNjVuYS8Zhh+78WX/kVi/DiHuNxrq/x4pjdtYcM105w7f5 + pnbxnKVjfolirFN1qT2/NTD3K59afaQrP+zywZ81EFftFOUY967XLecFW/65gTzrrCes+CGgkxAnJvR+ + kroonsITHXz6S8JObtrIeb3PEvq8nIl9Pd6ats0F3fNmPc8nHpxXewWStXsWzFfiGHtrxkvOslPCTp72 + hHjmmch3rZqqUzlb7bBHPY8tGbUKwzyVy5jmSzEshE/JhyzN51IzaR+cvWKKJ9b77Vq95+InbnzPp5Yd + MfGKX7jyHOsa0s/4X9jas/ZZM1IGpj3d+LmP8G/31lzVEiaOxzwOmxz6qSnqO3qmT67EscilHfwW4xmn + ZK8bHIr6F7606hZOSUw55I5Y2BYP7TgwCHKuuSnExan4wIFlDctrvGuOfPo75jVc9vpun7ewzzrrCUuv + IujiAN0nZp3g5JQ2TuklqpPYyHmdt7CrN3tBY+7GrxclzYT5JrfmZEz5ki/ildOeZc7qs+1zdR759ItP + Xudgb8jpPOGqOfjUxWf95igOTsWqT+cIky8+bPVojE/JhyzNOualJDb8pWsP5JtfdbY49qc4+J3T3JmD + One10mbMxWPPuIEs4ayYSXu0eAg5tc/iMz44pk2Uq7hsiNVlzLmYq2dLnJK55Dim3B0bNTwvuINvvKG1 + D/RtvvXc8LQXhnpXnjBxX+o1cqm7pqRjXr8w43ud1C4LqzyKejuuWi7gkCd+9AixnPMK5FlnPWH5DwGc + jLB1gs6TFbZO2s7pi8Cep5zAXu8VSNalaO7Cqjdme2nGvUbb4Cj+Wp/dHDOGcMbq6Rg1xHKWoA7nXbyK + WT3wkOvctI0HDjDndJz4JjtHvMagd271qVhz+JR8yMp5Yhbbd8+EeXXs7vZXwuOFmHyLu4gbvaxfSOVY + vRLPW37YEvid8+i/wq4ZbYb2G6sY9+L7Fb/ssU/pmZ+cjS+s4nvuTynI6dzMz7pdO7X5o4b5uc+aBbbr + yi8O6o54+JT7HOMRF9Ya8dad3znaL+OUWQv27MMassUpm3Hyr3HUQy3i6TcurviKCTs3kGed9YQ1XkXg + CamTuE/2jvlJm/YSP+nFHyd9cl7vi8RrBvau/tYvtOOYaeM5Zjk++6vOzXppVz/2sj2lNtFMY1bKrNUX + 1qxruPJ2HAIfcXAvcxFTffisa6I81+rTvmLCUJNPyYes6JsSe9G+qTXX8MmrPOUurT2Cfy+eI7/6mIwY + e4pX2M6jDuwpN5CakVqzZExSc2NeYeKOHNVL3LGpX6pTOP0dy1zmV9z8GYPtvvd5WSunNfIRF1dx+a7L + HvM2v+Jhr/huF7d81CqbsV0rBp4w41H22cP32o2Ru9exWOEUr9NY87xH6HMDedZZT1jzFUickK39YtBx + XQhCdCEoLdxs5bzK1/hkb8zkUpjNoznmHrQvxoNvOcU3+zVeOVVf9aked72HhgyufNrOvcSXVv6syf70 + b3MoxTW+4qmVJ8n8WR/iGGZx4VPyIav2YLO/tJfSNTsxSu1lxcP2fe7x8q0esOa17rj4EXN8z3v0W9jo + 77P13uaciGVcOSHBtbhiabOm4nvdwsInd87C2C43ceUhJgyct2nVEt/zPJa1M2aY2chRXe+/4pyr6lF7 + LXEVB+ZxYMi9r5XxJfIlqud1Ch+x2ctzFXN/xqF3Aa/n8x6KhX9uIM866wnr8jmmkHVS4wTVSWonL2N+ + 4vuJ3PnIUzywV/trZvaQOHY3Y0jNyBzhI2a2Zg/s9W4gUV/9vUfhFWt+chS7cHq/VeNiQ8tPbTyfobiF + sVb4lic7+cKSS9viswd88V34lHzIin6+r7EP05r9pZmHqM4S56tG4aov2fsuGTzTqlXzUjTjI/8K+71v + vf8d9e75OBOx2kfGbPYtLgyc6/FyLIVYcaiLUzmIvSiX3sBSKo46WctixWXujrkELk5j9LMHc80Hx7HZ + X1Kc8ruudM93jQl3DubpPSs28hKnn/zJ231wtprE93jWDSx55BhPXMTPZyDPOuspK28geaL2idniJzCw + edJfObxguGT8db5IXPXVL2eRyHdNibwW5EN6P9OGH/KaN5CqPTWP2epdtsdsPvk9370GX6Ic5i/MewWn + a4rXM3gt96e+9u65YVfvm1jYfEo+ZKlnzWA6JeLi0O59AMeet2OV8T4WuWfVufAmttdRXuK7T8n6wlb8 + sW9hf/B/+kwt2HNrzksMQow4atjzQzhjsneOejhXHM2TXMYkmsG5qH/llrBH9VyY7L1W29f6gXUe4pI9 + dxevpRmkkSv7nos6k5OiWolPG4K8yjE+eBtu/ZrD2C6Lm7HU3OelfsdHTsbWDeQ3zg3kWWc9fOW/MrST + tS4SNyewTm6dzMD7AlFSMQjs17mB/K9//d/e/MGf/9Gb3/zh77z51d/7V5ceOc/YT89X8fKXFvey3+a9 + ylvvVlPzZk/r3/u4+plLrtulyZM9YqHNnseAj6fkpl5qz7NaiM/nhNe4k+AiB/tQPp+SD1ndF3vCTD4j + Yhm3GcferIZ4wodeoj3LV0x9FStOxVlbsYUXlnbXSf/BN5B38/n8LppRUn7GLNdkHpvmha4c+l7L/RSL + gQ8sfYsrlnFqr1d8k4GptnDV3YW4c2/z1JN11Su5Ftu56VM8T35yyIuY1wPfuGWrt9dqG/nS4ooHXHb5 + heEYSxRzPzXzZKv+eQXyrLOesPQK5H5CtvYTWz5iiqetGtuJnkLua9yI3a0//fT/e/PdP/nBm9/4D99+ + 8yvf/do209SB+/w+39hf4Iy96g2k6rL2mEWcsFccs8Cv3LQVm3niDE3+nps+pXmzn/NmTLUQR4y+55KX + clNjn4VPyYesywymNQ/mxfyaU37xGKvc9GdceZLm3fe92DuXsb1PxB76CuRH7/8y+qp/zzdm43zygwOx + mGvj137Tbky9qk7IVsvrFyftnrFrQK6c+7hzCiu+YcRlzznar1qsUVjEiXsdSdVQnvHkhx41Kw5RrYoT + 77p7bK+h48M6EZMII6/iL/BUK7DiJ96cO/+8AnnWWU9Y+QpknpC4AMyTti8UKXayOw8n+57b+cJf463g + n3b96C8/yX6//vsfvfnf/+//K+fxWXpmzQtcMzv3Nd96Rw/Ulgj3mSZ/szmbz58zm60c5yBHeNfpWNcQ + V5I4ezgvMaujeIvj6CGs6rDuex998El8ru69b7z/lS/6FYWewfaXfmM5X+15cWyfirUmX7HUzZU9ZNRT + T0hj4jXHc0fPwB54AxmPUfTMedhfs069ZrbYvoeMhS8xH3t8SayW51EPjsUal6CGcHCcCwFHtaeWlF8z + wG7ttWwu5w3/BW7Fp1+Yc4kN/AarHuJsolmKU3nQ7fvx5TGl75zMMew2NvC2havHeQXyrLOesPSXlONk + tRNWJ7NOXlwQ+qKA2LwYKM8lYq/xfYqfdf3VX3/65j/92R/lTWW89f1Pvv0valbXvYee/bVuIL2Hauu4 + 3fma444z7cnzvOppfYtHSc7uZw1id7l7nP7OCZ3Yjf2in3r5WfPDj5f+arza9fc/ev8f8mn7udfer323 + 8ZiNGXMmxWxWym095nQu7IrLL0x10V/4JSdtzCHskTeQv/j1X/vfNEPOs+brefrYXOPE0hfmMnNSGzY4 + rNn1xe3czjPuFldMIn5zmDtylAdMIl5zOk+4bPA7p3iKb5yqp5yBN1f5yUl99ZUvbtkZm7Zzu1bz0B+1 + XV7CVatrkiPMuN2v68y+5y3ss856yorvctOFAIITMqRO7IrNk1cnOnLsQmHxwpf9Rb2F/VlXvPX9/U9+ + mJ+nxFvfvbfay5LX+g86ffz6mHQ/xErcZ1w5gSnPBXUtxnz1Gz1ZV7VGvcprDBzlX+foHp1TstejL1u1 + JZ6XOabf++b7n+YvPetG6R9888Nf+sXf+rW/x6fy/9JSz+rF+qELz77YU8+x7b04wIubenIv/GVnnAIO + ccmOkwu864ck74E3kLHiVWP07j1prut8M14ScerO7bjzvabqCd9zHbtI5FG8V8jMb2zw2Fc8r1cc8vZ6 + xbf4PmdzxfH9tR48l6g/eqDnzpcvvmLJFz7i5BNzvnDYEmHgl32HWY/AhA9+yA3n3ECeddYTVv0Vdp2Y + tCl98vYFwU/kjk2O8l3etRvIu/XHf/nJm9/9kx+8+fXvfyPf+o49vsZb7+PY8rilpq3jOo5hxSbmdQIf + NZcUJlFMfGr1U3zvL9trSxCnn/WE95wdYx1yMsacwsmXX3VGTPjMWRpvfa+bp5/2B0nWqDnmfDU/Y8A8 + zlza+5wdM4yCPRBfolrdhzHjdG5z97ziPPoG8lsffN334/PKrxktVnsov2Mp4rIG6rDWpY5zGBeHeu8n + UU2P3XL32qNua3E7vtWzmKTyQiyWuPhLUKvt5l3nB2frSanc8MlXDnzxZl2X4r9QT/nOV12PFW6xzmnp + vLblh5wbyLPOesLKG8g8Cd92sguHblwXCtrFo02O6j3yM5Cvtf7mf/5t/uX35106Vn7c6ljWcZPuY5mi + nIzJ9xjs0J77k+pBLB6zhJCnWHGYN3jU6iWO52WOOJbnHMS7h9cDJgFXvLTLb3vpj+PmJj5PeffWt/Gu + eonXnj3JS7tx52oOxTX3mI85ilU9qyWe5xXHcZNH/hFNLP0hjebBPnlc6HccsR3L/ey5VQ+SHPIudmjy + il82j7tyllSP4m3z7LHEiW2cjgOTrziwKcIqL/i0Rx1p4wkvYe6wXxLWg0zM8297Meb8qkOBj1zlYM/N + V53CB7fzVVe54jTX4ss/N5BnnfWE5X9EUyeofOo8WRm7nNB2Mld+YrgYdJ0v5w3kay2/4OUx4TEqvcXy + OIaEbcdTsainxwUx4V2ralSMNmsiV+K1VYN82tWnenaOanl+YeI4VnZz7zD0IcZcYcVlLmKye77i4NX2 + r8Zb31Uz+BmbuYntfvFQW/zBC5uc0sRKNn7WIRfSPI+pzphTHPqPfgXyF3/rn/29nCuEs9X83IOLZk3R + vsR1fsYkdkzIqbziTGzPV92sU/Y83vKHLX7UZW3VdL33c/ul2plnHNUWR7Fpd6/AJKohTsVZt+uj1uQ2 + JrzyMt4xz0WMXBfmXXyT6hkiDvXoV5j6wQ/csXMDedZZT1jjFUiesLJD6yS9nrTEI4dx8DtfuPK+DG9h + f1GrjsmdbMepj2PHhIlXOZSsv9veg5KxsIu7YeQU7vGRp5hygLl2vnKUt+eKi3xwxQNOP/mYZ68HXmvn + XXNhQ2aO88VNn/HE06ZP27mIMW51hImXwnhz2N/ijjlH9VHzsV/jo7X6xx865Vw18zYjZI8vHfsu3/Zk + uuzgss9dvRSbQ5z2jVeY1an61zlQJ7TFxI28S3zGXpLsfcOp/IF17cqx3mFXTtqSWQd858zj1BzVNJw9 + VHPPAWZ5S6dUbNrqXXluW43uB7wwcs7X+Jx11hOWbiB38RN1YGELdyHHMV0g5P88vwL5j//NP5/Hg8cr + fMfle6yObWJL83iKUzilOGnzMTNcvcQBRl+Y+JtgputFP3zF5KNuYyWGN485JoqVyLf4pTbx6WO/4sr3 + ulVH9S12wehHjiTjiUFXDrHJwb6lg6s4MNa0Pl4PfGjE6S95xg3kL3zr/a/0XNusji+797txQxvP8cAg + wHy/O7f57RdvidcBt23XOYfiWw3Fb3PNBof7cd6SypUUH1q17voUh/ZL3GmzpvimxVNd6YwXp/eR/IVL + w972usXKZ0wYejW3ODdc8WWLH9h5BfKss56w9Ec0uADYyUpMJ6jiOonb1oXAuTy5yVHOM7/G511Yf/U3 + n775A32V0Pf+dR2veRxpX44fj79yPJ5YPw7KFzaEeeJVLcNf4sJmjNIzqR7zVbNi4M8cYsETntrmoi+7 + +OZ3ve4dmPIK34U1PM9jgVcd4SMmAdb1IOBJfDbYyWGs4vRVK6XqspfZqq2cR7+FHSvextZcmI32mJuz + a/+paaeeMuqYiK864HP/aYvHHPVLrI9TxgxDHfCVX/zA3Q9O1gXe/k0s89oWH7VcT67wkUccevnRi1q4 + sFkTczkmKZ9xr1n2EsVQQ/VwPK697/GO0zfbe1cPYUsGj3HPOTeQZ531hKUbSJ2UedJudkmeyLww8MR+ + Kb5fEEL/PL+F/dL60//+F2/+/Y//4M3X4r/o/C7/i44dVx27lDqeeGz8GL+UM7ghi+ePD+ztsa4+jSVn + 5wePXPEVF79ypbecsB1XT893DnoAc+n41KrVgvyMqw514cLSh3idjnmPpS0vbdYsf2nPl3/FyLMaksbm + fgp/wg1krF/41vvfwSyaa+4pJWY0Pzm5F9obJv6olzHsu/jOYTy5Jj2b17C6jLueWNe6i+3xjPks1nPn + KA6MNsXrok/3nLr7yBdftvNaA5ekb/2d61joyn0BzzyPSZLDmuRd5+hjdddn8Bd2biDPOusJy28gcWLi + pJeuk5QxP6nzJBaHunBi4oecG8ifbv3xf/lxHqtf/z7+i854PNKex1WPQz82/gMDMdnOrRrKZe09LzWl + 8yU9V/fw/rQrTr7ZqY2fNvFRL7EW5VQN1m3erCu/uOR5vGKBj3qsZbZryDUGW1qxrlv11Ounkcozn/oZ + b2HHih/gmmHfX81H8f36MYH0Y9Cx++Nzh2fvwKw+hJzCjUvtnM7jPMZVnvDUL+S4fRHLydqsP2zjhsbc + 6gF7xq0X63TOxBHzWu5zJuZUrnFUC77bPYPb4ldd2spJLv27WOJWs3ueG8izznrKir/CHidonLhxYvIE + fSk2xHHafnIntuTn+TOQn2f97d/9j/wvOnFTqf+i449LPjZ2vPW41WNCGXx7bDoHnAs3eIrFY2m8PeZ1 + Gus6EfO8rMc8YeKOXsbxuHq1Tztx+Jc46zpn+uI6D3mFRQ2rI47H4W95yUO8bPOLW3HM5vny73jPuoGM + pW90wB6wd83VM/cxkp97sBz54Gj/yBs5y+5c6ft+0pUjm7FRLzGIsLLpNw8zV/2deyNVmzVSZFttjzm/ + 5qWkT+4+g3PFq1nTlmw1QkbOFruzo49he8+dl1jZhlEHJg5s1SROP/S5gTzrrCcs3UDqZPSTtk/kebLm + iWwxxdtHPPmsGfq8Avl6C299x3/R+bd5U+nHXI+h9MT0WIEvrP3G/bHrPOBhe35i4he+xSNmtTzH+c7p + esyXkHPBlyRWdWfujGE29Qpc2mMtHfd6ERs248JnPfAcmxzEC7/EupfHpJ95Axl/Cdvzzb1oxtoTRfsQ + f2JTMoc1gHnOll+8Pl6S5u/5NmMeT7cZp48cxo0z450ju/sZf7Pflq9444ox1/3kNV8c2F3XdXPpmwDf + sRmX7l67vzia33qlT07JiqcY5lyvef4K+6yznrDiLey6COQJvZ+krZOnk5pc5ZU2vOowfl6B/GLXH//l + j99890c/yM9T/lO+9a3HIR8fST5GjcnG42U8xazOHk/xemmbb+LPi8SYlzh7NLfz0464OKbFGzrxKwYb + Mn3wEiNewlqOjboDB9aafa3X5NvxzD6dU3byEO86HZMU94k3kLH6X6NyPs6MGYkLu9mT9lr5GYOWLa4w + 4Ny/MNbe6yiOGsLI2WZxO33WRF1I5pHn+cJdvE5x9nq0VaukeD3PznO/4hYT5jHVcp76DIw4fK/DWhYT + d8RNkDtlj0OjVtU0QV73OjeQZ531hFWfgaT0Sd0nr0tjOJF1Mnt+2sJTI+/Xf/+j/P/TZz1m/c3f/W3+ + a8b46/d4lTK+Sigfs3yc+vGsx6oet5ce8z1n91nDngehB489EGusOBG3mGMuem4Vttf03I3XM7l/j1Wu + 7MTZY9ScxyJw1SyMuOzK2ep7rGpYn7Yh6S8J+5mvQMaqLxa3eff5taexN5fID9lywhe/8gz3YwGM8SXJ + N/+Ck181aLsvbM8rnTWA73X3mETxtolHjnEvtZefclNPuUPEXwJuaBfVEAeY1xDHa4rvdcElbvGd59ys + K35hzfE8xcUNOW9hn3XWExZegeyLAk5SnMyF88Tuk3fH7eT3E/22BmLxNTa/+cPfefP9T36YX29z1mNW + fpXQn/9RHvvx1reLP270d9HjWPmJ0TY865BfOLkS4R1TTvuKq07g0smTDFx5oWF7TvrkBb7XVp74zi07 + uOSXeGz5qjNlxmBDlF8x1U/8Lq/rPfsGMlbM4PNdpPbH/cT+iLUNrtfZcxpvv+qFzhhqVp609UiJHObt + fSrHxfDiUrpnz77HEO+87okc5Qkb+bRTao6X+OS4kCNJLnHl9CzXGPTKs1oekzTeWhK5u93YzIe9tHhb + LOTcQJ511hMWPgPZJyJOUomdpOPkhQ/bLgr0XzzRI4f1Eesa8epY3NDE29zxqln8D+qzHrP+9NO/qLe+ + f+V3f2M8bqHrMeRj7hpx+GXzcU4O8ZHnIq7nmJ25ZasHMI+VMBfcxmouYne5O1+9IM5rTLZw1dn5e1yx + nGGbY58TIp91csatXmDvwKeyibEAAP/0SURBVA1krDVP/nca7aHmo5Zdfuj0sbfiktN79WPRtgTcK+b+ + LXbpydqJ7Y8B7NDKE2/ULG7P3lzjMRc1LRZc2cSdB2zOssdcVz2vG7ZE2BLVeyme4tgdZ/nVe0nORY7s + nnGKcjqGfTaG+YSfG8izznrC6v+FPU9KYX3Ctp/aLwSmkU878b7Adf2WzkFPz4vP8cVNzXf/5Af5+b6z + HrfieMfNvB6j/THUY6bHDbZ4/TimBD/xfl4lh7g4l7wlqlsY+8ouIbft3e/eOybxPvssux81rvnth12+ + cVOnL57ni2s5S08+6obvNUvekRtIvpX9ac7P2bUnSeG2B9jN7Rz6xRVH+ZL9mIAXWIrVKzy020u/VEd4 + 8SneG77bExva6oRfdbb6KYHd4YwhH7k+j2YX1+eRvYvHVMftytNM1t85EJ8LdR0Djnqjrvu0Myd8qxX+ + +QzkWWc9YeVnIOuEnCeln7wSxetENkx2n/x9gUguezimOqjZOa1n7q9892v5l8fx1vf/ez5P+YUvPT6S + 8PU4SfT4IO68yR2POR/ju1g95iHGgw0MXMTcrri48hkX13FhHW8tu+pR75z0VS85Vov+XV+J4p0nzOpa + fHIYjz7vyA1krL//0fv/UPPX3HYsoLk/ifaSceZtuGJuV/0Q8oWpxug14sSIpxTH7Tlv2ZYDTvOBKTbl + rkb6xkleiLiJsYdqE9tjyptx+bSt7uRNDPyFsacwcVLU06R47FN1UktQN3OKN/vvccUSX3JegTzrrCes + fAVSJ6edoHWS6oRNLemLh3jN0UUCuYjRLr/rq86MyW5RrHKy1wfjre/4rsTzecrXXf6Y1GORxx6PoT9e + /himTxk+OYVXzgs1C29f2MWuuWS3Fkfx9MlXHcSlMYds15LJpR/7MSncdMaoPVe24qPvhikfNehH/B26 + gYz1Cx+9/8vap2Yee4iZl+97BEabe1SseOIurWO21x05hqs2+pLH/PCnbo5jsx59q3PHb3zyvUb2Mu6F + Lw7t4hIPWzXuOawrzlvk2qfrVx3FTauXcna7tWo1B/ktjnccx9T7nFcgzzrrCUt/RJMna5yklMKEL10n + rHiJbSc6BXif4MB40XF7yeClPzmhvceo7TWYG/+9Jf6LS/z1cXye8qzPvvox0UWbj0Mcd9Mez8dCvBdi + Vw5tq7f3kBQ3beNtgn6GBW+vuXTNZXX2+ZS7z1W55SNefclNX/H0WYfc8EetjVO1zAYfful37AYyVt5E + xnw5s+2Texn7NEx7gu+259KPGPM91/PEqfjgo+bOr9ohjBcW+Te+RDV3fPhmB19S+NID3/MyDrt5jSVP + Qs7AiSW+carOwmFfcyWVT27xMoa46kkmp3sKL17aivse2XPZ5wbyrLOesOp7IO2EleTJSdxP3jqhefJK + I68vFMpJTkjV64uA8vb4nnupt/M8d7cXJ976js9Tfv/HP8wv4T7rp1vjMdIxpd/ix5y+48tWLqS5ilUP + E/EntrT3UX36wNtX7Faqr+Vl7ZueEpsVeZLJk5+YZszazREmvvcWr/I3Hrgbb8m78FfYd+sffPPDX3rv + W+9/GjNq9tK0Sxy7s5dUXtr9eKW9uDvWx0nxzgcuno6/afZ2DuyFb3ONHPZRjnO9zqiROVeu/LSpZbuf + mNcL2eqHZF+L3eUCm/HkFLb0nl+xzk3xnkt2W3zZypHe68kG/uF5C/uss56xdAM5T8j7EzUxXQji5NYJ + 7nHaVYccj98K63kf+RLnp8/a8oXdzd+cZbN2vPUdX2cTX2vzX//6v/GW6Sxf4zjyuCVm2h8bt+FPnh6j + juMxGXnO3X3LVUy26kAbp3DU85mUr1iJ9Ux+8chVX2nZjltMeeoNH+KctFdexztncNJGrOaJvHf0BjJW + fCZyzfiJ9qe9ai+1B8WIy4cNEVe8riOZx02SufKthnDli6NeqGe5IcR3P/MVs/rC5e955RcGCX+PIzZr + uH2ZwWzVTHxpr+N1Q8tXjnO9rvcTxzXqMMcw5Qi/5lmuxYWpxnkF8qyznrD8M5B+4o4T2+06cXFyy/f8 + lzjwm+dx9OjcqbuuZnC/6th80MDSr5h6w3eJz1PirW98lVD8D+qf96Vj8+JjYMe8jzvwOsbBuRx/016P + Muvh8ZXsvL32Li/mVx7tt8xYeRdOY6GLNziWS87cm3BgwIENPv3Guo6wd/UVSK1f/Pqv/W/vffT+d2JW + zMy9an/pI6Y9tU0eJWNv8Yeo1rJHnajtdvVC3+q/4m+tv2Sfr3HLy5rQ8neeH4/APH/3gb2cg9iy2cf9 + qqMZKtewwifW9Vkj7daog1rX3InttVwnT1jOMeeDf16BPOusp6z8K+w8MXmS1gnrJyjseRHAiYu86Svu + /DssferMyzlQRzMlnzmqfYmlz9ohzi0+ehWHWPC8X/Fo663v/Cqh//Lz91VCOg7X4wkpzPBLfPni7Dk6 + 9p7Tj4dpxpTTGPNHzHDKzitMXMvZ88OevYVDVBOxyZ1aHOTPnImXlji+pGtyTsbe5VcgfY23tLWP1G2X + cH/aq45vHQfbv7DiLHGOYopnLGzVcNyw3UcfxTo+6op/w30rPyRsxjPmOPUlVyJuxpqnnOpPfHAKu/Ys + bOvhMa/TWGv1b85balgf5DLP9iHOeQXyrLOesOJ/144LQthv8cdJvvA6qTfxk33UI9Z1rjyP3UnyKX4h + kQ3duPopV/GswZ5lm6hWxcnJt74//vn4LzqxZx2DeQx3G8fG+fJxLBXjY0J799M2UW2vX0Lf41lDcYr3 + 6BzyMof5FgcHvBbnd5+0I2+LiQ/c+82aslWvalYstGPCl6/a6v0luYGMFa9Gxrz/YNxI9jHwvcLu41Vc + 7nvX4Paxq5or3nXbd/Hc6c++1bN4xMs3PnXxPZd2+RSPy8+ao0fHU2etPl6Odw7xO1F+1TJs2ZjB+PLJ + UQw2/OKrHuPKL7E+IV3DRTxylx1yXoE866wnLP0V9jiB46Sk7yfzbtfFgSdx4MqHzVho2olRKr/87pFi + ueByNuLK9bzE2EczQPtswPYcxfaa7ivudn+V0O+9+U9/9v/k/6D+WVl1TOL4cL8pdqza5zELrnzmBTd8 + iDDGLdfjEvfFKzxzO3aXrxmGrTyLVe7OT+42t9mjH7nKm/nEmVc5zLvli1t50o2VXvKuv4V9t/Jt7TX3 + e998/1PfXx0DHg/tMSX2XMeEx4K8WaN5zg9cAqxjqAN74GGrltniwPaZzS+7eZmfvI5nnapL32TWgLzE + 97p7X+Uq1tyu57OVHbENn3Vv5nMhX/FRq3zFo9b9fHvdcwN51llPWP01PlP85Ay54ONCQDww4jrRFYf0 + iZ855CuuGs2Bn/jb7CWozZqyI+b+HqN47KIVF7Zkr6V44Uvyq4R+/6M3v/sl/y868zEzXfvHvnUM6jjQ + bmxpHhtxxIOdsa/6twK81EN28YiFljRXMn1xWuR7za4nbGjZFK/lmHM8R7HiWM3ENt/nDrxnJnf5X8Yb + SF+/8NGHv7z29R3sj8fFpPYbPjk4Dh5HTL5s+ORm7sTTDq74yeljXTz54gkv2+eTqE4/Xm6rFjDLWdpx + 5TnuuvEr78qhz/7pb7OU9rhyQrtYXs9KPO1rnbSD4/zEEataLsx1fd7CPuusJ6zLD2yelDqBddLuJ7Ri + zinRif2TpHrNiwiwtkMXx7DUS0YsuR1rzq6xl8khdtOvcfKJX8RzDQsd/2c6/ur738dXCX1J/ovO2GfY + ub95HMaxJV/HwLk6hs7t4/rhGz4lc8Vf7L73rfe/srhfX/Jx5bBO1+ex9rrFga0Y+igu6Tp7LjR7RY3q + 0TM3hrhqXEQx8iXes7Frz53jmPO/7DeQWvn29kfv//J6Dnxn7TP/JeK+197/sis+j0/yJDu27OBXvcLg + 32rmI88w4sOmBKfmqtwtL+TGH7z03fZ5lm017vLUV7JzgS9M9RLrGsCJRa+tX+aQc4ePfNOeI77XQBxY + 1tpioc8rkGed9YQVf4WtkzZORD+p4fOEDV9i8aGXqFblUYCRN/DGPEd81VIsNfskN+27WuBMPTnK99zu + Ixy5e87gR8zjjA1/yawJ+dXv4b/o/MGfvZtfJaS9xeySu33lcaBOm/t3ftlVEzzl8yl5u/JtzvVDIj4z + t/jfWTdKn6ie8rNe2VPv81xijKdotow3Jt/znCfuxGRDpyjPagoXJ+ISYcK9b+ZIIv4zcgO5r/zf2t/8 + 8JeWfDU/t23HpPZu2H7cxHHR4+PHsrEtRpHveGPkbfOgzn3M57rrlbyca5sp8iTGh4Z0DeFuI1eYx1QX + GPTkqnZL5lGcV3HOmbXMd/E6yeMc6M2YsOR07LwCedZZT1j+CmSd3BKerLogCPMTtzkzHzmME5u58wJR + mOe6DJ5hWyz8mqP8jlfMecbxGToHnPQtJjx8l+Qm3lzwO+5adoj/F50f/eUnb/7mfz7385Say/eAuSde + PGLYO/x9j57jMT4lf+qlm4r8Q4y4qci+UQ/a56o+5GiGC18SedIZp78kucQRQ+2qs2nZqieuarW918NM + wvdYx7vXz8orkD/N8lep1zHiq9Q8LmnrmO3Cx2OX7fER1+u539zl63HS41G1mleaMXGvnMaF7XFhVStx + cq0+esw6zs1aNsdtDeOkLbnJgw9xH3bnpaYtPHnWD5jV8DxyFD+vQJ511hPW/gokTkrzeYLWSSvfeH4B + SWEMXPkzNv2O39YZ9eArLgw1xIVknP6sObG7OPB5HLKebMYdE7fqqxY5XbftjCWPfUY9SHyV0G/EVwn9 + 6Adv/vTTx/4XHZ8Hc7Yt/7JvCTkp8pOD46bczFk+n5Kfa8VNBd76xFvf3UM9YU9xHLPIx7z3848Y7ek3 + L8XrCicGPvOF3XLmnMXJ2JKfoxvIfeWr1N/44B/FTfQ6FvE5yk90rPJ41XGaj23FdDzHMbX8hUsrDo7b + /TglRq44hRtWuOqqT+Ju9yxex/nKESYbPnpULm2JcgaH4jmFm73zK2Za81Q/+h2fc7ifHGIel31uIM86 + 6wkr3g6qkzFOUj+Ry++Td+eVJpZCviTzhTvf4oOTvvUyca73BY6cvVbH4WdexEeedMfEVb27mOpLxEVc + +eC5XZI57FEcw1gz86yu/ovOf/qC3/r2GXpezkMMPuNpY58txo891D4aC5tPyVdf+db3t97/SnyB9er1 + CXpjBon2kLjtV74EHH9s5h6aszDDOwatWGryq5bLzrUcF/T42fkM5GutX/ytX8tXqeO49B8M6pj1cfPj + qNjFH4/XzWPleHCXVJ4/bvKJZY7Fwx91xGG8sft44Hc13AbHua0RR+7kWL1ths6Tv/W+4SfngqOP6gkD + p2MVJ+fcQJ511hMWbiD7RMYJKw28TlhhYZuPOE7uwGeeXQyM56Jalbtxu0/HSiJvE3BDLz81fM9TreZs + PNWzmPC0U09O5W26YkvQQ717P6p5qSd7w0M7p79K6Hv5heev9dZ37WMT7eN2D7ILX/oyP+PG51PyC1/5 + Bxo2q0Rz7jOGf5l7s5HnfOc1Z+dphq7PeHHpR5yYchQf/rmB/IlLr1LH5ynXcfu4jinFHzv4tJe4rfiI + kQ/ROaI4Htc9Pnpav8qNHpQZ67jjqpN6w1OTL+naVpPi9cDveNnstXOFD67HE2/b+YhpZnIyz+dv+9xA + nnXWE5b+leE4QcOmL53xDRux4evEtlpLwnesapod2vO99si3fpLBZ3zmQ7c/6w+OSWDOrTmUZ/nynbPn + Jb4waeUMUTzzlAtcWPMmLonPU+Z/0fnRD/LzlJ9lqYfE+9Yciffecm7i4oHT/FkDfD4lH7K8/0XfSM5o + OrlLfL/Yn44B/J1TwlrN2bVqMG/rKQy8num8AvnZVr1KHX/1bW9965i7JJ7HXsffbTwWqcnTYyNfHOGe + m7Xp33NR9y4nhTxxoJUDXbHB5ezCrWfxyXPOSzXDlrSveTGzYikjr2v6DC7JsVj8UsCH8qyzznrUGv+J + ZjuJp3Q89ZJxsiuWGKR9uyCkv3TV2Hpk/OYCQp2xzLvahe388F0ilnnoW9jSNZvrzR55N6J9dA/hyFG+ + 49OGqEbqik9+91j8jet8+f+Mb33Hf9H50//+kz9PqV7qoT7ZP/qZVJ/N97wUYsUNvYRPyYesnq37l9SM + jNuMg+OyMNWqvRFzP7g6FqFle9ylcsmpHOda/NxAvs6KV6n11nf8kh1fcq7jrMegH28+BhWf2Iibn4+j + Hr8NH5wN9zxgzR/9g5M++bQVa434VbNG6CWou2JmO3fkk9Ncj3ussfCFQRhP7bHmSviwnXXWWY9c+ccG + cZFw0YmpE5uYTmbYkusJ3vyZ1zkL95rqQ3yvEb5kYqzDHGGKN961pu56XafjJREze4+rd8XED73lin/B + 5ctecjeHZg7BrNrzVpPic1Wu1f/H3/7neVP52//59/KrhP727/4Hbx2xvF/XUW3UbB9c+Zpn8iU8ZrSD + y6fkQ5Zmw562PUQscWifvfD0eWzIEa80ubKb4z36OLioDmzEnae8kRv1zg3kF7bir/7x1vcH+VVC18fD + Hq96fPuxEbd8xWkL1+Na9YmF7bVHLdmUqAtRnts+K2TmsYfhiu0YZkNO5TFXftUkv2LGmdjkh+2Yx0Le + ++iDT/gQnXXWWY9c+eFynpR1gciTlicoY86pE3jjOA9aMmvPHMNlGzZruEw8+KlZv3k9q3KaQz+185jH + OsmPmLSJ6lXOwDwGXXHjqIfiLsXdRLVhb/lVt/mKiytszwvdXyX0vXveEtVujZhz9njLlRfCp+RDFvbT + vcc+uF/hLb0Hxa883yd4gXvNwiie1/V4fJjXnC2WfuecVyAfu/qtb37hvT229XjW44THL+yS5POxJ0ex + 5CqfNcR3vzD5nrds8Xsu2uJKNr/6SIwTsVFDOmMuvZ+dEz7q9P7FU35zZl7z1nP+o/e/w4fjrLPOeuTK + 79HTCcoTUyd0iE5U4X5Cjzg5ng+b+KXGFrManQsu+F5T/cEHRv6GpZ359FmrOehRcWpxB4+2Y+BeY4jT + Zh3xZRdHfUa/xprLPndzVQ/YhRtW9iZeI22rD+yaF7yBFa/zwZF0jeRYXPl8Sj5kZV+bM2e4zIa5Cq89 + bjh95HTe5LVdMccowq981i1fmM+1/HMD+dSlL7yPG/n4POWST/UY4XHt54djegzz8RVmtvIK33Iv9YJD + 8Xzx1Ku1OF3fOcJHHeHJ9bytn3jGHzmJNw/9rlxJ5lTdkPe/wsN/1llnPXLllzHrhORJWdqFJ/FujxPd + 7OKSL9u5L2qXhenicodXH/GshmI9k8XT7wsS7M4FtvFuchNPrnoI7zp7TtUhPmRhyUntGLTiVWcJfNmT + E35rxVw0N/L3Ho4n12LOTZuzCB8SNaxO8gwL4VPyIWufS8cD8xHfMM18N3uKxWqPyks9+eLs+J7vUhh7 + z7nOZyDfxeX/RUf/uOHu8XU/nxN8jAd259tzoXLy+YDnhfgue33VwlxtZzx4Vld28xjbMNVSnbKtlse6 + bnOQ4zzolMw/f0Bz1llPXf5bcmjIPJnrxDV7ntiIJYe4aox891OL231le63KdUz9rB5izSt/44qv2tKy + K6f47pPvsYG1P7DIr5jzHNc8tC89yI1aVk++cy9i/OIRu6srDgR7ES/su3rOB94cF8Xd5tPxIUu91X/O + s/TaW2JjjxMfeeZrz627NnjErJbHnBtaNa91O578JecG8sux6gvvv4n/olOPYT3msMdjnL6eY3pOWJ7l + Ol4+OaopfmnaXlt1Moe5XrtEfuiXhFzUsDo3cWHqW5IY5gt/Hb/z+cezznrmis+Q3J7MPFmhJZPnJ3tj + yukT3aXqpM2LlOLk773Eu8ygnMQhhVNmbmPIkaZtsWGT01zEFQOuPp0vXH71CV9CvLjsC7Gcyod4fud0 + rDgRT19x9Hc9cqqPxy2X8a4Lvdvl77zwiZW/NJ+OD1m9t54j7N7rjGsfvX/oshlvzDRlYKmveSWVwz60 + I1fa+cLODeSXd/lb3+sx/cQf33r+6HGnXc+FDZePeItyxAGO2oVnnsfxHExMPVjb/bIr74bDODjizb7T + b7vE/HWsztvXZ531zMW/LNxOYp6ktNN3nDxgfZHABcHw1FsOubfYkvAlE7/2KYx1Moda+eB2ruLNszlD + jLfbqinx/Iq7BK9imEMc1SqMduYYX7UUKyx4jA17Sc2RfOiOWT7x4lNm36WVX/wtLr3iEVO8Y92zepEr + Hp+OD1m1H0rOEZjJnLkfI48F5rHGOw68sazhujisswQ2+Zt07etxPjeQPztLb33HY5pfJfQtfJUQHvf1 + eMfzh5LPA38+UYQXn7qfN/b8Ic9jel4VbhyJ6qZdXNQTP/ARMw0Och0Ht/cqW/jifBqfOeXhOuuss56x + cKHiyVwnLU9oXgQUQ3z6wGYOfHK3fPFVW7mFiXeTJzy5y1ZOzUR7r3eZuXDUgQ288xlPrH2J56gmOKpn + nFu8teyLsLdj6tn5zr3iqO/27Ff5jO/7kO8cxK3O4nRMcWEdF9frCePT8SGrZtrmlq2Zei+ME/O5K0b/ + IpkPKU76qJfYnTD/rj6wjqn2uYH82V79X3Q+yP+iM54XfA64reeInjfFkeRzqX3Zquv1O0Y7MdZOTDmS + zhVHdsXIle2+15bffc9z/ayz3pm1TlB+BQVO2jp5ebKmbRonc4tisiMH0j/cPE9+Cvso7ljXUF2vv+zi + IP8u55qnOGz1HmJYc69zJI89C2duc+FLUAd4xiy/xGpUL+J39aQVS4w1OsY6wkNL6Gue9q95PfPst3N9 + zsk1XTUf968MY+Vc7J2aMuekXTO2LR+cFtRoTvmOb1jlMn7nTy0cNVKEnR+qP3cr3/rWVwnxv+joeYHn + F58bxEND2h7PodDkCXeeaqZvtnDVyVyro1jnTXxymiu+++vm8ZPz6uNZZ70jK3+r5YmrE9tP2vSJFYd2 + 86Zufl8AhliPENRt/phD/S3nllexyYl42OIOLR5rFM9x417yAjNRjvYzcstvu7GuX1xKHZeIWc5tHjHv + UTZlzJN+c5Db+fLVT1jnir/nkM/+yhEXeGs+FR+yxj5oS2pu9w2vHHGIJW582LP+jLXsnBfzshc07OaF + fV6VOUtfJRS/TMRffa/nRv6RpMSfR+7reYTnksUkFg8Zz9Mtt3hbTNjgLEmfXI8Jb42Zzl9en3XWO7Ty + X3f5SZsaNwE6aVt7DNwUO8FdxG2O55O/8IsUf3FSt63akqqT9tK3HODqnXjwxM2YJDioKcw5lZe+5uuc + jGUe573wQoPjucnZ8pJD2fNKG6/re++Owd/6yKYuvGLCm1eieuQr/iKf4vEQPhUfsjTTPoOwmjP34/Ou + GPfouO+9YoFZnvjCEev8igvb7IktrZzqc97WO+t+4b/ofPjL/VVCfC5tz8V+LuE5WZwl9fy82Hh+Oz/i + xUmbcYnixoVgLtScumqtfXBbZ5111ruy4i2QOFnr5HbhiY5Yn+SKO1YnfOY4B/ISv230U55yHdvziiOp + C5P3b+5L+2lbvnFHDrSk/DEjfebtOc5T7+yffPPJudMpW/3UmoO1PMfrFs/FckPv9cRDHWCzNrT8xskP + GXXg82n4kKUZax7O4bhszSs7c+jvkvvKWNeEnsdh2MwJTHXlywaXnMTBlZ280OcG8qyfcuXnKe2/6Pjz + S88r91PiOSchVs89j7svW7Kweo6nDS0u+H1OKZ72R++fm8ezznoXl/8xTZ7gfuLSj5MZwhObnDr5yXdf + UjWXqKZjwCGFbXXEH7niEBc25iSn/LJVTxjwrBHCvuILHzz2Eu7a88FDf5fGezZhqLU0awjzWsDlgyue + 6ne+8cxXPEU264jr0vnMdTHc893eJebg0/AhK49L9n37TC/tS+L+OJaMSbImcdnFDd9yW0P23KrnMepz + A3nWZ13+1ve6scyvEornmj9P6/koO55zyeHzMnjEnDfzZk3whTcmftjxF+gxG0c966yz3sXlr0JK0udJ + rhN7P9H3C0LZ9OuCcsPHhcMvODPW+NI3ObLTj/gmhVt+4WZ7/a5LLDkdc2zUt7jqo44E8arFOp1D22OJ + +6ztpw6OYfKVmzb9zgMW/hXrnJfslK3+nKV99QA2+cmhzafgQ1b2tdmH5MytfcbM4Z7Erz1ZPeVB3Oae + vbbldb7Xn32r3xYL/7yFfdZrLv8qofw8JZ9n/hzE83Ji/vwtYW7Ifb7Oj46HH9+Lef5g5qyzvgTrF3/r + 1/pfG5rWyQ1bWMeS5zlL9ouBYsU3Luo01r3YlzzPdf6ulS8e6jRHdcRDvDmuxUlhftUwzH3Puc0nZ/I2 + LjFwN4w6+dXfOagDzsI0E2u1Pfspp2sybj12LHXW6rg4ZVd89nOfT8GHrJ6Jj7nP4vsy7XHZhbnc5PWx + aax48qnv7fZle77kvAJ51he96r/o5IsNH+a3d4znoD1P9+d4Pm/pC9vjOk/iVdDzquNZZ33JVvy2WSe7 + LgChJfR18ksXj1j9oLNYXlQM10Vm53p+a49DJt96EXPfscG3veT8Nc/GM27HHUes6ijOmhLljNqGS0Yt + y5WAwxj9wVdcGP3KWaIemmX0DF2xza56nReCmhD1cKzyKfJD+PR7yMr+3ENpziHdwmNCac7dvmV3LDHm + jJ60Z72ZW7wl4iknfdao/HMDedYT1nvf+OAfvfeN+DzluumL/6Ljz017DofUc1eiWNrxBz7vfyVe+WTp + s84668u08rMwvAjoh5T/UMsfbIoxntqxzU4hL/OzJrCqudcRJ/3gdGzksEbnbnjYwslxTDjsjvcMs0bz + Z8zjLY3vvMnfMXItBzFiksJZf4nqvMgr27TyyMUMLjc8SeCUjBmvc5hves/n0+8hy2fAbJi75k+74zWn + fMZld87NsSpbcRy/S69d2LNizFH+xMA7b2Gf9S6s/BnyDf5rRsjX8Ra4y4dfjVi+mnleaTzrrJ+dlR+m + zh9K+IGVP7S2H1jjh5vF5MseWhz+AAx71KB478Izd8rM8briq3fb4qSmVC/lFAau53tfj3sOtKRje773 + S7EY6nSe+B4rnJIYaxXH/M7vuYSBw1603ZeMeZakn3j7spuzdOTLNlzCp95Dlu+j5uV8wtLeMeZhZmnZ + dly2vKyfNqTtniH5N3M5T3lZP7kdTzk3kGedddZZZz174a/x1g+u+qEp8R9cLv5Drn8g1g89014zfY/f + 5Kjvnlf5hYPfNVY87IwDk11+2qrn2PRVx2MjjzHxRr5ijqWNvdzxECe/amI/ylF/57vveRLHEet4xYgV + L/DE2m4MeaqhPOHNo+0xq82n3UNWzbn6Yv82X4jN1Rzf54wnnzm+N+fNnm17r59mDq97qXluIM8666yz + znoXFr8jzH6A9Q9P/TCTjB98ksSRkz/o6CsfsRbgbTtPfkr0NJ1xYSYX3GzUtViI16PvnMD3muU7l37Z + zi1bEjUZU43UPUPhEo8vkS0O6l1jVYM1hxAPfuYIyzxgs9bkCZOtWsoPnRL8jCkPNfiUe8jyOTRXzShM + cfO1rxFf9nXfd5yO+XEpbsWBCW8fx2nWAqb4l+ktbL3NGX/lm7+s3ki8E3Le3jzrrLPO+hKuuMivH1Af + 1w+4+sE1/cb7B6ls5wSmH3ryne85ZY+6yJX23PQHBskaZgd31CuMXNZ3LPWGQ2Yd5/g8ksKF0R51DPOZ + Uru9dMWFU0aeZPlVMznW84J1jmKIS7Z5xZVd3OZB2q7aiT3zFUjuIWbR/LJDU2LGtrWX9p2nmuCxV/pd + Y/hmq9ZVKw5+CuNVf910cYvv3IprSfwXkfildN3o8jPWOI5zn9A6Jtrbko/js3TxRxbnX9mdddZZZ30J + Vt1E8gfWfpHvi71+APRFf2LkW47HmssfiBYTX7ik/IxJ+od2xtVPwjpVe4tnDvFRhzH1uHI6rtheW3zH + 0q86whr3GlU7RLjFQ17K89yaYXHQ12ZinuM1T9n0L71bLlxq5SWH/UPz6faQ5fO+tF+P7zxhsie3H0fP + VX3FZGeNwpi3i/egdD3WXJx38RXI+ItafyfD554Y9uAcxVMixuMoDv4Y44OvxquY5y93zzrrrLPewZWv + HsR3ftXFvS/0dYHfsPkDofMyzh8EqgNfun9AdB7E68ku3zTsa37zulb5qZufsW2ezLE85YAn3/taXtrg + gs8ejqftvR0X1vHSxelexU3dnOLR3rkDX5K5Eta65Fssa8jeRHmoIWzpxedT7SEL/ecskpw15+/nS/Ps + uVEY+Jc9B0a7eObLho9jr1rqrV47P8X4knfpFcj8xZP/mMD3h73N/fq+tPfCxbN4aXKqx7c++DRuKuNG + Ot76jhk4zllnnXXWWc9c6wKdryTcX8T3H7iINZcx/WAQx7DyaXcubK+P2uJO2/t2beHwnaMY7IXRTi3Z + YpinZ5S4771CKlZ+250DTmrnVXznuc36LpnPWhccdsT3WUZOYRLEkDel64nT9ZRbvSr24Fcgaz+YNyUw + zlvzpw0RX7b4np8xw5XrtYon30R9C1etqmd1TJT3rrwCGa8IrrnWzZzPOGdtHPv1PSk+uOM4mG/Y4NKP + t8vzbfP4nsJvnM9TnnXWWWc9beX3dn3z/U/7It8Xbtf6gVA/GNZFHTgv8sQav8m3HMWAQaqOpOpJVK/j + ssVxbOBvk8zpfex9VGPUitlkUzLvBi9hDHXUYx6PK965d37WrLrwZ33yTRBftuUC7/qqIT0xyMhhLXH4 + 9HrIQl/Mo/3UTLR9XseSJ7z4rGW24p3XHO8vnmq9FEMdcAonX9i7cAMZN2o1W83bMzaGY9nacmpPE0s/ + tY4P/OKYoO58vDIv8r/5YX4PYXwm83ye8qyzzjrrgQv/IzX+a0D/IKuLMy/akv2innzjwZ6c5KWNeHHC + pvY+jnsNr+s5hVHuaqdPUc61HvTO9fzKKV9zk6N4Yi3wr8chuZtGzZadA3z3yVvi9b132Mm71JpzOQc5 + XaNqSrvNnBA+tR6y5mx2bCjhC5szY9/N03G41vC9uV01ApMkDu2SXOVueu8Z/rNvIPPmMWfpuS7zm117 + KF8YRFjGLSdrbOJ5qCPsygW/c+IX4ryereOXn6c8b32fddZZZ32xC69GvuVfV9GPi7Qu3CH+Q0EX8Y5t + PyCsDvjw9QNg56meYi/Wo51x6vHDpjDWijzm+g+fihNXruoo5vjgGXe3Mze1ZPYLceyuPzjALn3JE+61 + Zpy16ZcsP7nFkQ3xfOGZJ1H+0nxKPWTlXNa7ZJur9mFa8VvbRHve46jL2NukZsCMmgUy88V75mcg41ow + 58EetH8dP+mxv8SlZ07i9FWva3HfJsWVJD9isBVP7uDQpr/kE/5rvvw8Jbd51llnnXXWa654KyguuLgQ + 98W6LtKy9wv1Euc4XkJc+WVv2n+oOB8x+wGSsebJTzv5ewz57qtuY5DBMV8YZPkxh6TirLHhZS9dPdw2 + 8Th89ZwzVx9ynFv5EnEyX76EfNpVN7ndCzHUqHrihl7Cp9JDls+m/imc3eeEAKu5Mwbd/uQlN+3JdZ7n + p1hf12/rrfohz3oF8hd/69f+3polP9bis2OuxiY+97LzLlgcmzqeG9eOpeLiAmv+yAthXceUf4N9HJ+n + jJvl89b3WWedddYrrnxFcv3W3hddCX5ojItx2HmR58WadvLs4u25VUPxzDFtEr5qiwObvSWBi5u6Y8Ul + x/ELj7Wrr8Uu/U1fpHK6xi6q17Xgd5y1hUsq3nbge6+RL59a+xs55HrsPn5fN4RPoYessf8l5ds+wtZ8 + ite8toeKj33B3/Pkl4wezak+lPD3HinsUfKkG0id8y/OeYMlz3GLK4Z9rWNxw3Gs+eQOjDjtEQ87tDj0 + fR+e67VSshb+6vt8ldBZZ5111iusuJDGF/4u+Y4uun7hzYuzLsD0m0ecF2/h8JlHaZy1mZeiuPjEBs7c + rqM4ORU3XnGEo07lM6c5EvJCu+2adnJdFl69KOohe/RIfs8vrPJo30nGU1+xkqxr/hLnTBv+pW7NA82n + zkOW5s+Z9r2kf501bc68cy98iw8hR32Fdcwex+Gzh/gmVW/pZ7wCGW/v+l4wa88euOab+3LfOdApW03U + cmzWF188r+W2C3jLttpZh7X2PrIVd176+Uos3/r+xvkqobPOOuusz7XyX5LFBfWjdWH96INP7GK7Lry6 + MF8uxBdRTBf8xPPCbphf2N2nqE9xXC+p+MJUN/tudVwwv82duYZFLmX0X1L1y7derLPr4pA3aiSH+cI3 + bObi2Gc8eV3ba7ovvnKLQzx9ys6R37Wg+VR5yPJZc7aai/t1CW7xOw4+OSFWU75qKk8x5TbOupnT+alN + kic8NG3VesoN5Dqn515sziWyFRdHs6dYXPtvrWPYfGHiKS5bHJ+h8tkXWHNe4kmSe+Pf4lvukvovOufz + lGedddZZn2Pllwx/88Nfih94+d8kvhVfC7QutHkRl+ACD2k/L8jXC3RKXfxDWKu4NzlVM7mmGcscYi1X + H3zntp/itvmeXz3lk1d1NluSOazlmOqOmndiucXd6nks9DW28WreyZN4jcgNm0+Nh6wxF/eamO879sB9 + uIjX/tLiLunjToxadV3P40b+VqdqUJDX8zr26BvI+OxjzqH5bO7bvV3s3ovqzLzAm58SdvZhDm3xneOx + 4adevnDaXkc8ccRvbRzjlc6crle8kvgvOvFVQu//8nnr+6yzzjrrc6z4UHr+Jee6qK4LbP3rRL9Qw+4L + M+KthctuPjguibEHLuie3xd81YF9jRXfYqEhXdv7iIMci9EXVrG07/p2vHDTsDsm+1KzODOWccMcV8y1 + 4xVj78amrzifBg9Z2qv2G/19rn3e3b7l8zhOfGHa/+U4tJ1i8dnnJoe9Upv96M9AvpcfU9HMPufUKZpV + 8xLLPGK+b+d67copmzzaEVN+1VFuxpt/56fI3zDNJ5GvvrB9Nj1P5EtsrtBL8rt1+XnK8190zjrrrLM+ + 58q3vtcPqXWh/fq6yNZfeeeF1+Tuop0X5ow17pyOA0eeyzWvcyCJSxgr3pLMdXzpqmfSPWfMZ4AwxvrN + 6xmrzp5n/OZKX2uHn3WonbPjqpG55HR8Yqq923zIH7J8Ht+LtGzHfW/OmXtZGHXlbXz5rkuihx2TrgW/ + +M4jJ/SjX4GMP57xWTUTZJ/Vj5nFdj7xW9/4M1cc4uTf1ZW912gbcyK3Y8I73/dDXsjooTjzFAvtNvVe + bz2e+Cqh+C86563vs84666zPvuK38vhgOr7wF29968JbF2lefGX7Bfnuol12clinanZMPNXyeOWFn7mT + t3Myz/p2Dnp7jc6Vnn3aRm5ryR3uNSxufMULo+66jatu212jOIwBsxhz+RA/ZGmmu9lqfmHyqbV3+J1T + MuJdX7ZqiVc1LFYcq+EaeXwuJAfyhBvI+neF2odm0fyBVZyzah/lD57hFtN+O47jIG7i0pXDfOOIJ45i + 4iu/conJF9djwO/mQ6/WLuCpTtW8wZy77Hh3Jt/6Pl8ldNZZZ531ORb+K86HvxQXVXyuyC7AsnHhTWxc + uInrol48xQOTZKxtSdedtufJLo7yCzNe1iRPWvzKIUZ79HPxPAr4qO28wmk3Bo6wlPSJMa467ld+1tr4 + Vic0H86HLPXHfJyp5oHvuPaQfsbaho86kI1ndVWzeKzduPEyBi2e1+2crvvIG8i4edHeNKv2pDkxX8+r + PYgnvPjMFU91q2bliIdY++BUnvOMI9/zZKeo34anzfrep3DjAO/5iicucdnK1WyIez44nh823vr+0L5K + 6NfO5ynPOuussz7rys9T6q3vb33wcV28eVGuC7fpunCn3X5r4285rlsalxTGGrKVo7op1cN8j1PUY6+F + XuKQz7hsz0ssfeNv/sjNWs7pOnuPyQUvdPHWY8SH7iHL+tYMOZ/NedmLYZr/liOpmHQ/xpdexXFbXD2e + 3a+keqD/I28g4y1V9d1nkx9aHPiKwy/Zcdmmkc9aiasHbO/jcdlVp3zwPR82a4xc9eo6M0e1GB/5u3+t + J7/4wsIuHvPIgd+xyl38eOu7vkrovPV91llnnfXZV771HZ+nXBfUdZH9zrrI5lcJ9cXaLtp5we6LsV+w + nRN2x258cUJTnHeHVW5q/YDoePMwC2xxd6zxjEU/YuKlcI4hxO+4XROYa8Umjt53urjf/PDf8aF6yNKs + NR9nhb/NprjPvOyUkSNO2+5XnmxxQlPEqfzE2i6fmOoo75E3kPgYCebRjJqt5+KsEttHyJ6nuPYj2+Pw + Ub+4xSOuPlY79B7vWNeTDG717ZzmXTmyhacYf/QzTtU2PvDeW/VTPLF5TFRvi3+87K/H5ynPW99nnXXW + WZ9j6a3v+KEbb33jwo4Lb12MeSGuC7RdlCUzrzVymqPcqiO+ZMsTL/XGE94yY4O/xPuoruzyq+bObw3R + XM2pnqyhegMz7p77yBufWD6fz9Z7A7bPPWzjDftOMj59j2dMNYwbOjDpygvtNvUjjyPOG84V/X0um0mx + 4hHzPQ7OW+IRw7GwWGI8B9SPmOzSFO+jOlWjMJwbiiEP+TP3muf5ox/zUFMcr9OCPK/bdmN73e4NzRjj + iqH3Enzk56t46/t8ldBZZ5111mde/VVCH3x1XWDrq4RSZLveMRdiupgPnFIXeOrBFc85xWt9lf4BBA5+ + YFQN6sGlXz0kzJcdumo7j7hzy6ZfOYxVnZQPf4kPwUNWHQ/OhHngD50x+eQkhr2Fr70kxnriD5uxwdsl + uZBRY8S3fNkRe/QN5OqrY5JzUGLGq5CbcXItNzjuh0aOcrtOcVTLRDzFSxhzO/2LrTj54V/qtF8c4qo1 + conLbm7zxS1e5c0c6JvajCdHfaQpVWvh044Z0v80/+p7Pbbxjs35KqGzzjrrrM+x8q3vb+DfMq4L6ye6 + 8OpCLa2LdV2MDQOvf4DYBbt82S7g9Q+Hl7Ah7OU8nyWx5DRedYwDcc6smZo4fOV2nRnvfAh5Sx79g0p9 + NdtPJeRnjudWLfC8pvOFNY6cim8c8KS95tLiLyk/Yg+8gVx9v6P9jRnu9mN2cCE8NpvdnFk3ZdnFYw/V + cbx7MM9EPPUobOR1zazBXuo3c+CXTd08xVq6/7WuuGmX3/Mgt+3iRx3lkLPbyLvGU6xOxlQvvj4t3vo+ + /0XnrLPOOuvzrbjZ0Vvf8dm9dXH9NC608+JsF2hekPcL9rhIm7/rO+7AU8sHJtzFY8lnj33WygnbOLc9 + yXFcOeKo/ugTQl684sFD+7Cl2WoWzgOc+6W972/oiGm/tOVr78EtifiOLSnuqLHH0bfr9+Oi/vGc5Ba/ + 8IWv0dJ8mMf93Ef5xIbG7Mkx7ou2+dd+jSUevCXwO09c1QCHMeN0ruUzLqzzxet9KS7Ma6vfnlM8cW9y + Km68jG1YcTN+P5/z5be+n0223vo+XyV01llnnfU5V3x+qP+LDj5P2RfduBjz4msXbF2gE5OEb9IXcdRw + DDa5VXfFrJZ871dzDB7i0MAuXMPEdbxkYYhzzo2j+jXPOm48jA9bNZtJzbPPrvltX3WMbG97rDib7LnK + SbwwcmgHR9zGe0bZD7+BzN4S7R+yz+k8xSpue6j4diwCf5mDGvJRT5p5xe18xJrfuLjec9YrvvewPOGJ + sX5occAjHrLxEVcv9dtjU2fMeiRWNqRt8gtDnfS9ztKFU8BF7dD+X3Ty85Tnre+zzjrrrM++8q3veNtH + /0XHLr5p8wJ9uahT+0W7ORPXhR74rOuxC2dJ+cbHDMy94Xi+ZMzjvtej77zw4wcPD9dD19hHzonjOvYy + cPBTE4d2bueKr1gK8VErNXmU9FnP+yh35Kt2clbskW9hx6vv0dtn2WzMRZvS+8M+PE+5bo888S1f3MoR + h3zgnb/XEce18xzbYzXHVsulseYo13XEqy5F+WVvPcKX3b7lbT2qDvXox1zn7T50S/PYz7D4uE9c++IX + xPMHOmedddZZn2P5Vwnhg+rv51vfurj7Rdgv1uPCnjZ5kcdczxk++Z6vHOeDIwEntLDK81zjCHdRz4y/ + oOMGm4fnoSv6u4zZuM8xf2G0E+945wNLuc0Bz2vMOvSZK07mpN21vKZyHvkKZLzihN42k2T5NdeGyQ6N + /fb8e1wCnuyNY3ldz4U8i7XPXO9NXPzE2Et+a+DDLq6kZ3BbvriJbXNIEmPdW1Feagl6QXPfViN7Mk+2 + arnd+cSWFJ+8iinPMPVd+uM438+rk2edddZZr7D8v+joB7IuwCm6IOMCzAtyC3BwOt4/LBQrO+pJnJt2 + 4/IVF8fzgTcfOT1DY5CqnbnJeeiXh/uqfdhcc+a24UMqR8K9yBZ31LQc1eX+gbNG1TERNmJRb9SEH/rR + b2H7fqD7uIU95ufMYSPWx0a28j1PucqT7byqQe3cEnEzH/2VM/PJT17byitOat9jx4Q5R/GUqGfxUZ/6 + ro505UTsJm/UHbniC4eWlL9xur5zUdP9mc+42dLxyuT57ORZZ5111isvfZVQvvXN/6LjF1+XwPaLevLW + RfuOpxhsSPH0A0IXfNMdp28Y8F1sDuN33Q/ePPMHiM+OeeYPP99v4sVDDHtEXH7mUITLHvFRX+L8Xe6P + pfKVE/7jX4G0/mZD7NjkrH0cxKm9pM990s5Y5fH4GF/i3B2vWPrkRjzrNua45A4v37mssWMS71s2ebJD + u60awEMT3/Kzh3LcthhyWhKneJ545ReGGRRXzl4LmObtGT1HNYu/nkPn7e2zzjrrrC9wjbe+P/rgE78Q + 54W8LtSN6cLt9p4j33EJfP7wYP3kRZ5L8vYc/6GjHzj8oRL2Rx8+/A9nfNVeci7Tl33ZzC/tqTDmLQlb + fOWIU/7GRZz1rGf6F9sw4z7yM5D1CiT7ay5hrVesZmxuiuE5v+oRr3xxB97HV7mD6zo5bq8+1IlnPcbd + XiLuXQxxci55Syc2j8PO6Ti0pHiyyZl2zya8bAm5ijWnj5fiqjfrdh/YVx4w1J7cjodOsf7gB/bhV89b + 22edddZZD1h66ztuKuMHef4VZF6w7eKsizUv2CXEimO4Lurhu+059z8sdp64PVPlP/nmMVbNHPPKplz2 + JKz2ZnH5qZuvurL3mvInx/xNnK++3iOwkGe8hV1zbzMVtnTvv48Dcrkv4w2cov0FT7Gdt+Peo2akXDkT + rz7UU2Yt5whD3Y47nr5hA08bfT3esQ2n7HPtvPDHjF5/2cKrTsSFp975bSuv+MLpC4O9cUJL4o9uvnG+ + Z/Kss8466+HL/4vOkvwvOnmx5oXaL9y4mCMmHFjouqAT6xqNQ3feLh2DTv/Td+HmMVbug3NdZ27c9629 + 7Hl+nPa8tMlXro5fYswtjvUbYrj3aZvyzBvInEF7Ic695vwScivmQk7Wce7GUTz3bLhy1N/ncb5iynVu + 51uu4bLLr55LZw/mah7GUyretmvYWw3lSu7ybjiy5x4Rc/slDnzMmn0qjtkU8xrlW37Xge3itVNW3iOf + w2edddZZZ72w4q3vX+BXCb0XXyXEC3teqP2izot++qnJU2xpxYafmjza9UPE7MX9+F360Pw+v89cor3m + /LSXTvvON+narcXba8kHB/yU4gCvvIFDI/+Jf4Wdc2C2fdYxN+PCi+sc2uL5MZDt3J0nG75yZbuo3hWL + GsLatlldGG8bs3b9bXbjpe24x6wu+rc/chZPXM/zuPK8j7jt004+eM6ZueZv/SZPxwK8icsmbn3f++j9 + 75y3tM8666yz3qGlrxKK3/Lje/ze+9b7n/YPCL+49w+D8u0Cn2J54DBOXtZbN63P+KLwn7T2PcjW/NhX + 79Xx1OJWHP5+DN2v3Ip3XsYKh3gfCPMNU57k0W9he2/tpfbEvSomf8zO/ZSI6zHaqulxr1N9qcVPYY7w + ihmuehUXXnnGDbv4obvW4NCWP/EWx2SXZB/YlW+9hWds21PxQ5iDWPMKZ58W1ttqdk5zVE/auV5vinPg + Z273+/jcRJ511llnvcPL/4uO/rJ2v5jrop9+Yc3zHwDxeUx8efqHv8QW79yq/WgPd/ukH1qC+BbjMfG8 + 8sktKW7LJW6+ajS/507Z+M+4gdRM2ov7PrPsmnnT4rVvemGVb7GqISx5rJOY1ZSQ7znNha985ez4rruG + NPpCrAZjmeM+4+JUL2rZiiHPuZLuWTmMV77HDK96tMu3uOp7rrDEjeM9Vcvr7jmhUW/Ezk3kWWedddaX + aeXnKb/1/lfiphKfdfvgY/8BoAt+vC3O/wceb5H/n/HqJku800s/xFL0w5CSe6sffPzBVjHb//hh1xzw + 9EMUseRXzPOAi9c1gSlHeZ3f/R175iuQmEP79dl0HBSDnTm5B+wlxXJkyxdvxOgLU33PK209yidPscAH + VzI48FVbWPkV32Jep2L7sSDX/LQTB6Z88UbtjRNa8dCjBkU9KxY6MebSFo4czkgfHMM2vHu0FEfCPMXU + M64vfMqdddZZZ5111nNX/fCixg84+6GVP+SE6Qfa/MEm6RzT/KGIOqjlHBdx2meM83lO1U67cxR79lvY + 0Ptcy69jQTz9yRVv+Kmv9m0u7YFZPWESzTTxsMlX7jaTi+OyPS9x+m5LqteNqAdkYZGbNScHujGPXWpU + jDZroi54wp0T9qhhWPrEJtdmS7xrA7/OPm30C4l3NPi0O+uss84666znLf2g0w8rl/zBxh94stt3e/5A + 9FxxSl94zXEZceN5rvsz5/GvQHr/faaKLTz2EX7vC/ae7z7iwBUX7nbxXCKuPMqsvewVH3MwR74EfHKW + vtZVnmoyZrWKb7niO1ZCTLW8ZkjVTbvrA4dU3lbfsciVqBbyoSuPPctfUpzbGVjTfJ+jckOEm/Z6Icl/ + R77B4ayzznrlpT/OSPlG6/NfBs56F5d+SOGH2/WHlv+AS1xx0+LK9lqFb3zVvdSgKF5Y5pu/BJyVb3b6 + wX3gDaT/683ak7TtN23uQ3upeUs3J+ISx73uXUy+OOlLkmf5xvN49UltHOOD03JXZ/K6r2xxhEk8r+NX + DHjXgH+NJeb9Yo70m6vZCicf0v7OH5j8iDF+wSyG2taj+DOeOHPiD/7Oz5OzzvqSr1/8rV/7e+994/2v + xFctrBM7PxvnF4cQnfypEcvPysUrJPHHFeeD0Wc9c/lzVHb88LLna2HynecY8BZhKeQhZj1Sk291dlvx + mbP9cGU85JGvQMYNpM+q+aB7xtS2B/Fq7zW/bHKrptUJDmXWs2Oyx73O22pGzPsTH/NUvmHkecy5kqpp + eHI9ttl7HfQFJl7ortMx4aOei+qqh3zHnOc29eixMOnibwK+capOc0ru6qznHJ9+Z5111pdl5SuM8UcV + 438z94ktbPh5Qbm/OER8/bD7ZMW+E3W/LH98cdbPxsJzUM/F+bxMf//hlc/l+QPZbeeUf4Pves+5y0cf + xHZuzko7aj3jLWz11mw50/JrrpoRWrGS4ppmvap/wZmXPvLAufbzOpVHPLlehzHhymsOfcsHRp91yl+6 + OazjPuNDWGPHunbXaVy9MYvi4qte5Yf/Qo3EPL5E+SMncds7cdkDp595yQGmnK63+z175b3D3+5w1lln + 2cobx/VDKb8vME9ontx+wrvYiT95dqGxXOCNLR3/QeWr8bUy79IXT5/1s7Xi+Taef/HckzDmdvpp8wfa + li9MObIVE089gJFv9uCqXsXmnOJqltQPvoHc56rZ05bfM9exkZCTs1OL6/7/8d2vvfnjv/zkzW//4e+9 + +fXvf/Tmn3z7X1Rd9LDjm7WYT07zFEesMJOBsT+wa4+Ot11+6q51l19x5YZmTHb5FOTJ7n10fNmRR7ti + Wee+v2z1Qy6xi82aVWPWRvymDmtnTNjQG8b8FNVf+r2PPviET8GzzjrrXV1xA7dO2E/mCT5P6oum7BeC + 0MLEd1+1W5CH+Pv/Ln4w5lvfv/Vr5zMwZ33uheefPdfieUYJrJ7D8RyUFG6+bPp7bvqF0X5BbuPMu5sx + MGjDH30DyX2npo25+iaj4prxRiJeOfQ955/93r96s6//+tf/7c0f/Nkfvfnt//x7b351xcWdvVAveyjG + XuJ4HPN0rGbKHOQ2Dl/86iGpXm0XTo5qO646oSXX2DxWNc+dT7nmACsOseYSdxFn6ZTCWNts1IcvHuLI + U8zjzvf45Cz/HfznBGeddRZXfrH0OJl5AttJ3T5O7Dq5iTnHZa+1X1RUq4SYuHjr+/3vxA/L88/3z/os + S88niGw8//Q88+dePVfDJ0+2x1BHz2lpjy++1VYd5YlX+eKT19zOGfWeeAM5Zgps8+s4+H409+AxP2JZ + 98PbG8i79af//S/efP+TH7752n/49ptf+d3fGLXQY5vB+jcP4vEdb73VrHqS6/HwvKqfWMdT2FN1004O + 47RnfembvqxxV0c9HFdOcULMTx5rwu+eL9WWVu7OKdxjd7J+BvBpeNZZZ71Lq28e80StE7suENuJLlwX + j108VpzItViLcSjyf4KOP+b5evxxz3nr+6yftPT8k8RzaPzwklRsPceW79rPicSVTxza7Yllv5DKoe+4 + 9do5oy5rPOOPaHo2HYvlb3uquQvHzJ67413vw3yF8bOuH/3lJ29+90/+f29+5btfs9pzrtHfMMVLOD/q + YDbF5BdOrnOUV3hwEut8cRsDp7lbbcWYp1z3UyzHa8r2ui7gM4d+8ZRv0nzkVDxyrH7WYbxrE7f64iOu + nOCcz0KeddY7teLmESc+TuK3XQCEDc6GD2xJ1abd+bjYDA77TbxrATM+/YrjFZKv4q3v8/UPZ/Wq58iS + u+eafNl67mWcuJ53HbPnIPOFdY2NX7Wg70Q5e01pt595AzlmqX1p1rbbn7jXGbFV6/PcQGrFW92aq/vM + x2TMLW5oy9tjXkNx7WVibc/8ay3PTa7HaAsffuZBgDMWfmHTR84LWNjlM0474oWxrvrOPNRGvPvccUs7 + h/jOf+9b73+HT8Wzzjrr2StusvqPZa4XstR5Iu96nuS7BO41JY5nPsVjjgm/i7sUV1hwk7/2tn7o5R8F + feODf3S+Sujnd/XzE8+TfJ7eaNj2XJLwedj5eE465jxoYPJht4yY8oRVHDHlT96SZ72FfZml91F+cSa3 + ORLiii15jRvIf/Ofv1d1o8foU7jH6WtWzrLnKUdx5Rcnc2gzdu3j9RVr3HNcMm62/L2mOCXEmj/1nZ2+ + 1ap5hLmmJEf4kmvNjZM53cv57it+Xhg466x3ZMUPhP2iME9mSV+omtd68jcuRRzZMw/+6F++44axlmKu + yx79IPF5yhX/+vkqoZ+vhecERM8RPU/quRLYpjNGbsUolWu+6yGRu+QuhjrTT7tmIJb5xFnrkTeQ+T/Q + 1bdkmzntntElOdLkeB5y4f/q917pFcisyRmqx5R9jsSG5j63GvKnDW7WM6x4IZbXseanltAfNc3PmoYl + 30SY8+QjH/2BwRcmDmqTx/w76V6cc8fCzlrQJYrTFq+08eIjS3w6nnXWWc9acfO0n7g62dv3iwkvAIwr + z/HmQiZ/+iNXcWEVn1jXby3JHPKHlq381JCy+db3+Sqhn93lzwk9/njuQAPv50fzhIHjcZfEoj57AGMO + 45WneuRO3vX5rHj1IDfsR76Fna9AsnfNzPl2cV5hMXvyEVO+84S/2lvYWbt7eQ/Eou9bbM7cWO9buOyM + 7TjzoCGyFQPec3mPnV+y1YY9NfIxE/rY/MkTJi7zymdsSeaxZ2rGhamG8jNGDHU0h+XRV55yLtzgSNZz + kE/Hs84661mLN008Kf0ExUm7XxA6BrsuAhbHCQ9e4ayXmPIZR5+tDjm3McZfstVfuXd1sr/EscxHzsLq + re/zX3R+NlY+1ny867HPxxyPe/v1HCgshZi4yEMsMeMrvzipwRFWORLVsXryb3kZf/wNZO5HM4XOedqv + OG35sPdzsY+1YuK/7g0k6qqXz5O+YXNW+IqXLUmuas99IfYyNznGVa5E8TvZ811GX9YUt8RmaZtzGIZc + t1V/6xk5jIPfvsfSZg/PVZ64JXezLTnX47POeuKKV9n8RA958WS+u5joZLaTGnmMEVee81U7dfHIzTj6 + S2ceOdCKd0zxnT/6s3fVrV7gTBw1PC/e+o5/5ZhfJXTe+v7Sretj7c+3tv3xVyz8ek4U3nY+TyxeNXbc + JPNMy67akZt17mdQ7PE3kJy35jO9pOLlu/BYcXbPTyEv9KvcQP6h30C2eJ+ay3TZnGlgFtvzUIt8xpsL + zPnu73kXHqXrzRrgu901Q8PvXGGee+V7vaVHbmOIk2++613AF+caB87c7Nty/hr7rLOeuNYJ+VU/SSFt + 50WAFwJw3EY8dWDkiqNaHlP8pfouFQ+/cjUj88VTXvF2v2uNfIv33O0nZnng3uZ8/N63Pvj6eev73V94 + 3PicqccRvmx/jPPxl/DxVm5h1Ho+hK+abqtu4u7f8NVbGjbykDv5D38Lu2bqOXo22h5PfB5rjyvH9xjx + 1/wrbPS3+kvSj9kz3pjzrn4/R/a470d7lB86hZhLcSmqk+J+2o0jt+MjT77lhC++YqN+COvu+L6H9Jk/ + 4pZf/CXqqbzhM+78vY74ij/yOX/WWWdtK15N08lYEicrJU/WsvsE9xN+chSf+MgPv/Ihk4caXad5quuc + rt1x71G1yVEPiMfu/DmLbNSgTV95kvhDg7jAna8SereWHqt6rPm47Y91xP0xln15Tuhxr7obRl142hsv + /ebCb744wjM2/Ge8ha1j5BpzpebsjrdPDjHkQE/OF/QZSAlnLCGu3oOfc4VgP1OaK85ue/2XailnnyX9 + F0Rxz6uekuLaLC6DQ17a0OIg1vyIF0d4ctBn1KmcyW28e/lepCPudaDP5yDPOuspK25qcGL2yTtO0Dpx + ebIKp115tJU/+IWTy7rilxh/r4uaLTtf9TzPOYXJLv7sUTmMj9yIUQIrnBz1V7xjxJfE1yTFf9GJH/Tn + q4Set/Jx5GOCx4iPfT52/Xj54zh85VuO4pDmvmQPyRqNq576oOasO+PUD7yB9L/C7hl7rjlzS82t3MG1 + GiavcQOZX+MTfVlzzjaPfcdsJuYm1+qUbfHiL0k+uajZ3NKJq1cfz86Z2H3tG87uM0cztO5c59es4pS9 + NPmKCaterpc0l3bhk+uxxFwYl4D3/qd8Sp511lmPXPHKWJ2IPEGHvbTH0x4xaMdC4wQ3TPGKoY54hVkO + cOW07TWU47mes/e+ciz/hlexsl00e/vVz/pGbK+NXOV/mP9FZ91Ynv+i86CVj0keez4m6/HR41ePl4k/ + hsljnh5D1XI/RTUYK2zzkQscsY1PSYx8r5H+wh/9CuT9LHNu39edBF+SOcSUG/ZP+68M37byM5B383BO + xPj4VW9gPpNiylVcHOU1t/eneiGdA50SOe5T3pYnrGKskf7WH37HPC4/a1Du+qZU3syXVh3N2HzkONY2 + dPpmq0fhjKle+HxKnnXWWY9c8QNHJ+6LJ3OdrJu9pHjEk5847IlBC8+Y5RY3/Re4hqdcuDPWta9x4W/L + 93hqm6FmIq84IYXbvogPjmz5JfHD+cOv/sJHH/7yeev79RceBzwu9bgmtrT8gc/nZj324oubsbZ3UX1/ + Trxkq6/6KVZ2xZmz/Me/hd2zYjZIYuVf5/aY+K1tT5Rf/d6/5m3gZ1/1ReLbcc15KJrh4hMbvknikSNb + wpzRh7g4Fdv4iW/xqmUc9RPeNbzmPKayrxxgXku9pT1nj4UeNQbevuyspZjwwEzEkZ1+6t7T+UPGs856 + wso/+tBJO05Snpzj5EZc3OEbrjqyUQvY3mvnOnZXv+babPmyX4yzj/bofcGXPXO8Torl7NidVC9hWdPj + rTGH7xNvfecP7Hjre10sz1vfn2/tj68f+3qcCp/PI5esk48l8y65tE1GD4lw80N7/VFrt8l95A1kvoWd + fTF3zRjCmTWX5kxsmxlcyTzWqvlab2H7LD1Ta4n6v8RLTHUkxBTXXnI/FfO93fPaF69x1UmxmGp6THGf + V77Xhs+5yIFWHDHl7OL5XqfjXU9YccirvLSBD37xpi/s3ECeddYTVr8N1RcJP3Hh2wWA3OYrZv5P4Kn+ + iFWO54rnwpqLc1tjk+KXvfAtNyUww1vCn7GRQ1u4c8VJLGM9x8xtrOyIBSexru2xdbPwSfw/2HjrOz5P + yYf0rJ9i6fjX8aT4MU5N3vDtMVFOxc2e/OYi9nKuRLyq5XGfI2xij/0MJL/GR/1v5iubePEpuX9qPxZ7 + 3dd5BRJvYfcsS2fveXzla57KIVc8cRVXHnjN3ffWuRa76eF5ihXPYntfcauX8kZu7897eO/ErGZoiWo1 + n702G/lbTHOE3uLCA5M4p/pv+txAnnXWExbehtLJiYvKPFn7QiNOn+DE9xPe+IhN37Xzy2Y9z0Vt+qoh + CZ9c8DibeBYvbI8vrf7Oc2y3Rx+rVVxhlM7vPHDb7ji4Xle28ovHGP2P8db3+Sqht608phI7fq4Vw3E1 + PDHhfAysTorzL/b0FS+8/K4dseZ2fK/x3kcffBI3kflX/1/wq9R17Vgz+HyaRVris/axsJjirJc4+a/5 + NT7qq9ophTOWM/Txv5Odp2Mg/GovHbbF0K/jO+YiPGvShu45X9IvzeCzyA97+hYn1nntax7FEPfZhLV2 + aT7zrY/7WY+47HMDedZZT1j+H2jyxOVJWr7JuBCQc4kvfPCEmy6OalQ/xtOGXzN4zmY3n1zzRw0JcyQZ + z5puYxbVqDzy3Aev+cpX7xGTVK2eD1zZ1nPDksNccYSJp5je+o63Ns9XCfXK41bHah6zlDqWpnWcXYjt + +Wnb41F885UD6VrOzRpVp33neb3JTx9feP8F/K/3fvfC5rH+mmHOKulj4vMrtsdf5y1sfY3P7Kc+++y7 + iFs55GJm2apt/uKBg32Jo3jlq3/VJZc+MNNZd/YrqRot8MWfuoQ1vZ58ryHf84FbXc1t86ddszXfpXoV + T3qrafa5gTzrrCcs/RDIE1GyfJzc7YfWia0Tv+2dx4vCbd1d46LQuvmqgx4uyC1JTmvxvE7H265+L9QY + trgS5njuzEOObOWKl7mSrH3DT7x5XYP7Cz45ylHM48qRnW99r5uKuKn8eb3w1vHk8Qt/HFvFN0F82X5c + Lb5L1yLP+7GG17qtdzsjsJpFssXdN87HS3/uV6nz2sEeKewfGv3nXspnHFrHB77iXQOc13oF0mfYewlT + X+CLX5y5H+UHvsc8z/GOQ2TvsYGrDnsVl76L8qY/Z/F+4o4YuYiRm37UpJ8xzlJczdEc8MRBTDyPDS61 + x5QHG/O6PjeQZ531hKXvcttPXpyYODl1okYsxW1KneyWB9wvFteLyxDmyoaP3K6LeGqPJ8b6zE258TNn + 2T7PbntO4IpNvOtkjNK4pP2Z1xL+EOeGXVz4nheYxGt4rnLSzljbjP9cfZVQ7LmOWdk4Fjseej+udfxN + Cutj2nblSZo/eoQ2TNzCrE7ymaM6g0vceYpVDXLinYj/1Vep9e5F1rE5dq24+vk8lbthLcBe6xXIrGf9 + VL97X2OhNY+4u5+avPJVw+JpD/6WQ05huzAn7NtciuenHbj5kpHHeOWntrhL1YKPWTpPnPJV2/I6F4/z + 4FZscj0mO2LnBvKss56w4gYyT1w/MXlStn294MC/4y5tJ3Zz2WNJ4JVDXzHVqfwNc57qOi/7WEw55Vs9 + zIF8Cbi0DVOOaskuYVyxrvXCjBm7Yl2HMcNSMo/9lwRP9UefO2EO8jQDcyTOyxuED7/6iM/TPXppr75/ + 2BDEHOcxMREP9sxPftXn46VjG1r1jZO8ijFnScevfvLEZ656JEZ7SMUh6VNUe8XxB1p8lfru8fcbyOol + YS/h1af4Fk/NOHHk1Cyv8j2Q/Ra292DPtHtWzah4a8zUnBbVxH7Ake01VEeYuJ7TdVqUK8kawR09NI9j + jTun61g9+uDsceNxtj1PszSHdWJOcVI3RzzZES+peGvVzJzU6wbyG+cG8qyzHr70l5R9YraMk9fidWJT + D9x5FSN/40orpnhhyYGWP/jyKaqNvZBD8ToVH1jPu9drv/O8nriTN+sln77iHbvJLV97ImY1On7FlN8c + xsdMnQsccs0VJ54r73/lZ+FmMve39izpffa+xzExW7GqIQ7Fj5lyd+5dvOouUVx8z3dBjeap3m7vfMSR + p1z1Lik+7CX5KvW6scxXqfF88JlZz2ogf+uTWnNo9q6TEjzLf63vgZz9MY/bd7HrTIY7r+K0iYsL2ziR + zxojzjxg5FDQi754xgcHmPDymSOeOCUWH3WpW6zuVkezZYy8whkTFzzYquu5xd1yyl6iGc4rkGed9YSl + HwJ1AvMk1Yl5OVndZjzyukYL6tzXaG0c9aWvGh4T3/M9z3NGbcpes+zBMd6SsCWKl97ilSudca/d/cVT + H2AdG3HqwoQLq3zEa46MG4e+aqTN3KEl9L1HSLw69WX+rR976n3pmITfdmMd4+MSx4LHw/GMRZ7ilIql + 7TmoMYT8sDtHvktjzgm7tEnEIZ1TPagTN/FY4Zb3slg++ZK9tzhlb7zQX8hfYbO2emeMtuYvDkUxzSld + NYzjtTJmnJKFdQ6k8wxLDkS2cpXv9sxhLOve5DhevdsGl/G07+e6Yi/ldqy5ksZn3PCasbHzCuRZZz1h + +Qfh84TkxUQnqJ/c4OAE3nPav+IXm5ySLd85YUPaTv4S8ToOEdY9p+9x1Rg8+sXf81LDlijuPVG/cySX + HMcqv/d0h4k7dHGEdR501/Ka8j234x1LHgXcjMXXBv0Sn05fmnXdD+3cK7T8EU+bx0hY2MxTTLb6tG5+ + isUU9xxJx8BTPuLEhNNWTPke95qq5X7HmWt1h01/8F7iJq+x29qOl/+KN5CqGz1rjs12WXjME7hi8NeM + lUM7ucLEAy6uJHMYU73iE29u15J4bnPobzh098hci5UdPU08Pngh4slWjHnoBS1ux22fFM2FnIlL3Pd4 + 1DyvQJ511hOWvw3lJy9OVPpxASCuCwA44s2TXHyvV3mqFVriXI8nNmsPvTjyPZaSMYm4xrH6zlf+mKWw + rpNY2jHbxtlt7xU2a9z3aMxrdZw1zL70T4zHjHbmMG9g9Ed+6uZBjLflRyw+S/tl+uMb7df3iL304+la + cXFy75Rr/pUrXLWyNvHkRq3KufqdO2Mp8l/Q2SPsJbJVq2KyI2+T2X+rFRz3y95yxAtNQbz3FeL1us7r + 3kCqz65h3x+DkH0/sBmveXEMXDd/1kbs7X7bxKvm7s8+su+k4iu3cLfpR49LHcMvNTa5y5ef82+5qEk/ + +zTXRVzPOzeQZ531hLW/hZ0naJzYPIF1okq76GQeXJ34hSGekjmzjvIGl3pwVYOiWOrCzKetGStW+Kxd + GHMlA6fIR036wWese1qexRFzm/nklJ0xYswdORvusTGX2amtB3jtp1g8BPVYK/s1x2Oh4y95+dR6p5f2 + DdH83LP2X3u0GPH0U+N47sehuJQdE98lY1YrsZjB+l3iWYvx1Mwhv3HaVsP7Va5hLaqB2l5LOR271hi1 + aY+atF12/qvcQP4hv8Znzea9ys+ZYWt/4mDPzL3J7+PR3MQoL/Z1KW7zUztfeouhn3I2zPy0t/zq5xxK + +uJueelvOcWjP/gbBpm47EuOJHPdRo1zA3nWWU9Y9Ra2nYx+Uu8n8t2JPU/o5ggvTCf/0s2lT40ZrIfx + HPc81X4pBrH8qqmZrB9F8dY9l+pf8qpnx3YtO2tIvFbVUO8W8WctCedjrWvO0ltMOZNnc3AW5QkTX5hq + SBb28S/+1q+9019Yjpl9T9y39oV9TO0xE+45teJ2LAq7z2k+tM1FXzkScWHr2PfjqJzGm1N74bzOL9tn + rjman5hzdmFOiDiXfNqJ7T0snvaS130Fso/VLj6DjkUJ8eLvHOK+B+9zd7zQ7+Y4Zu2OVU2K6np9+Nvj + fasnH/UQc55sF2ArFnMMjvu0yVHejhXO/QyscOfYHKyj2LmBPOusJyzdQI4T107MXY8TOH1hsIWphuLD + vuR1HJqzVI/OEZYin3ngMNdiAzM/tHp2TNJ7Sj5re27pjO21l6/ZbK7Qd3ZxDVd/4clRr61m+cVRDYux + TtUM7q2P3oop12tc/OzROUt/+i5f1OuYcM+aP2cPjLj2tEvlbvmuBy/tjUMBzseq4nZsGW+u8b2PNOsL + G5ywKVf/iqln1qH0DBI8X6of5SVs93esZwlB/mvcQI7/hZ09ULvnl91SfOZ43sSIW3zwKKMm9YWnOCXi + l7wl0dM17JvehiO2+7SjxqYjlvUpyX2hXsuWl3zpxsNWvnzP2XXyX/DPDeRZZz1h+R/R5MmoE1P+0nFS + D4ycPvEZZwxYX0gKt5jyyl+xgZMrvOoUBrtzWrcNrseVm37EVDOxtsHTHgxPHz1U/+pP/sxB39SKy196 + 2BZHDQlyh1YeOaVVx3Vy6XtsiWoIL1+2uOYPnBJYykfv/zKfau/Uqrk5q/YEv/fgvjjFpw/OPAbDZw7k + Httt1SkhvzSxjt3n+eyelzhrXepRRj3Gql7lAhN35Gx+8ZhbPPNDq4dzXud7IL+HfdRedMxtFsN3e5c7 + DuzQi7P16TzHYWuu5NmMzi+x2O7PPl1fdcNPbMuRwJ+xtIPPHNWSfRXEPB99WUtiNUNnPLX5yxY+MebR + Pn+FfdZZT1h5A2knpk5YSWJx8vJE3bnwOyYBZjzGhak+hPmUyhO/arYtrniIt6/a4c/aiFdeYs3zPOc0 + l37amH3v5znCFK98i0n2ODCvMUV53n/gJshBXHb2yFz6SzeGesgFt3XXbL4w1pEdsXfwJjJmG/uJfeTM + 9A27k7lPi3lO1p6PSfWtOPMjjyL+qBsScdrIY23LmfmIq6ds5YtfQqxijFcf85Wjes4HDj91YLINq5om + gUGs7uJ+EZ+BnDZ70VbMbY/Ldj944F/x8r23fBPUgCjHMa/pMeVmzcFhTtQndhcrO2PCJOB2HjkVB/+a + qx6cKzjVS/U6R/WTayK+186Y7KXPK5BnnfWENT8DiROzdZ/MgY148ld8ac+52uAo/yVeyphBFxj2oNzO + FDHqiENkt551pn3hjLhmabv7wa4Yc+HPfOCYr3KthuLKFzZiUd9qok/jM0ac+SnimS9+xZcuTFzlJX/q + wXeuxd+1r/rx2S96iY6dHwc9JoG17dyZL17i3oN1X4rJVyy12dmP2O4DU++WveZLtZTfGHLFlewxz0+p + fuK0Tp7HlTNw2Mp7nbewv1c9tB/ZU2Oml2frvLAzz+3g3dSRliivffGWzxoZq3rwk6f6xL1W4KOGC/Hi + SBJjHdp7rexXOPTMBRfaBRzVuNSL2MaRjV6oM+LEhZ0byLPOesLK/4UdJ69OSJ7I46S1uC4czu2czoPd + WPJGrY4NTmGsH8Jc4cU1vriKgRd6YspD3OpIWKeEWNURNnCL0XZuxBXzXBflzHk3HnPVE3nT3rkpitGW + P2fc52++c2EzRlE8cca8duj3vvX+p+/S1/xoD5q598fHjnPXniju38UgfSxT7Bjd+pvt/qUe50KNfpzA + a9n5xaWtOPBrfa+xx0d9itf2mqlthrSzBjnWr7BlCxP/tf6I5tKn5pHGTINHTkrwbrgVI57Yzl32ldux + lzD5E7Pe5HQuMPHKN377qCNfmIvistXjto9qJdYxYRUPbXU9v/hWq4R5yVF86XMDedZZT1h5A2knorSf + 9LhY9MWkbMYd64sAJGvSH7WJp4iXOd1D9Z1fPRJvDRw5rqsvxeeQ9twSxZcojj5XHPZWp+a1HPZSTPG0 + xaPtmPdQXvGEyTZ/zOMx46u+5soexhM+fMtzzqilOLmh3/vmB5+8K/8GUfNqzn0Pgadwf4Utf8bc7jqB + dX1yQow3+Kw1cMtzDLyOpbCu/IpzlsajjmpYL+O5n7bxxWlsi6lO6CWBS9xHftjN7ZrNEfZqf0Sz9dAM + 2S/n656uNd8Qw5rf+6w4NfoQM1yxPQ+z4ThIZ8ziyFEu8JLEWM94iofvOeg3czxWNeTTFldYa9qKjXxi + tLPGTayx3Wce5XwG8qyznrDiLezLCcsTPjE7sUOA3/jkuZ/5xZu5e43M33qlEEe+bNSB9h6Nw5dMXHUD + Uz3HO951PJb4nse4Y8rbdcdRJ33pxMm12G2u/ODtIs6yq49J1WN81LPciXUe7JmTwnrgdN3MQ9/v8Kn3 + 1KV5NNvYD+ZMqWNg+5Lde9tx5LhdvKhnNYdUjteAqIZjFfN6oRPvXrKLTy1b/syH3/NwJtYBB7jszlW/ + jgnzePMlXa+EvNd6BRL9th4hNk9IzegzOy7usgPT/JVjePELI545U4NDe2CztvChKV6r/GVnDfOLk7GZ + pznTz9jVl737abOuY+jRe1e8+GnTp11xatn7jOcVyLPOesLCDSRORAhPbJ6gfbLiZB5+8IiJ6xcA+bJT + LEd1xPEa7ivHuSUVW9ywKeH7HOKVdpx8YdUn8a6l3hUPsXpZg/WEOe49LnmpJ57i9facW3z28TkLt7zA + ILIt7ljaE99t5d7FFE//Hfg8ZMxx3av549jMY9D7aB8xHQfTVadx52Q/9rzmdcz9nScJX7Mop+wlyhux + jdN15gzujzoUYXex7KEayelYYN2j8RLm/er3Pv8NZKy//bv/8eaP/8uP82by17//0Zt/8u1/MfrV/mye + 2lPsozh7zh0+j4nHHFcs/KnJjb7V++01JW+rgXhL4KoHm7zq2XjyCvfnydZP3LAtvseKI4narO/YyCfH + a5xXIM866wnLX4HUBaBO6jxJcdI6NvQmydtiqC2Rz9rBlZCfsnzlTMzy0ra44amLA1u5mTN85yrGuoG7 + b1zgtM0PbtWl/1INxdqH3VrHzXJNZj/1Qe7k3ddQrnplnmSLi6M6ibvc5Hlt8d+Ft7I1M2bkvs12rdkb + m7mSymdcNcX1XGCoN0Rx+uhhuAv53r/zNHPzxL3Y5He95nct22fwKMWVXThqCwu9c8vfRDmFLfs1XoF8 + af3Xv/5vb/7gz/7ozW9+/DvZJ3vnjH6s6HP2qe24EOs8HTfjiWOCuDjEQxODdsw0ucrf6+25Es+Fb1zD + h71EtRNnDNjcp0Q1Ko+czm3ebkOzj/UKnUL8vAJ51llPWPEZyHHCrpNx17LvLgDA7EJhceVULcXN93qq + 7zH5snMeYupfPu3kOG/DgCPm+Y2htvKqr2GlFacoP2sY/taY6iVHOnjwK8d67TXETd/qDduwqrl81YZt + scK6d/fvWMYNS1Hf0JLkkPvkf3lYc27i+3E/Me5jHKO0xQXue5YvbkrEZHtO+RLV79ziSsht2+ZlzGul + WG5pcZbvNSpv1Dd+YVZ/i7sNbmjyOEvNaPOAj/gXeQN5t/700//vzfc/+eGb3/gP337zK9/9GmbjLJrR + 96E59z1U3k087JFfNo9n8EwKJ0f8lFETuV175rUgz2OqlXbUZF2vN+v8ZKxq3Pi7aCbYnOdG1Atznf+F + fdZZT1l6CztPTJ3YofPE7BPaLwouHZ8nu05uxVCLJ33lQKcUxrythmLK1zyo6z7rmwT2v//f/9ebX/3e + v37ztfUDIb7OIz5QHxJvZYUA+17ZoYMbP7hCvDdqzl6KQxZmeyjM8GsOOKE9rhzEJI63jRxo2ajbUv2Z + m/wbWzWa6za4zZd0jRRxiFUc8ukzX4XkDCWYDcen7IjV/mxvzBkyeLZP1tvzqr5EvIztuPlLdl7qkY/+ + HWd/iucpp3hhF8+Ow8DJDf+F2F4rbM+59oYUL2xyQ+Lcffb647/st77jeuIzas++D4n2Ova1JH3awitX + uMc3SW7moK582ZLipFZc83KuwVE9+GG7KA5b0lj1iVxKxFVPfOVoJvEck18y8jt+biDPOusJqz8DqRMT + ohPWT+DC64Ig/n5xmHHl7Lmouee2LW7lKk674ol3PF4x+M0f/k6+gvCnn/4FL/+ff+nzU//+xz/M+vHf + MTRL9NXMNY/tQ5x9Lzs241dbfXaNXlaPvnJ2rHDajnk9adkp4lvMBXU8f/fBee+Jr0Lus0LLh1bM/bv4 + HoPcY5m7HcOyMy7N+SIujuwlqneXu3NTGB9173jCyRU28gyDhqiH68lDDYh4HSs/9bQf/QrkT7P+6q8/ + zbe+46YybnD/8b/55znzvnffh45X6ORQkqOYxLhVZ+csqXqMSVQjxTDEUQs5mg9a/M4jnjZwrx/xC4cx + ScaNqzopzPHaxaHtWnzZkXNuIM866wlLX+PjJ+c8sXHiV0zxjDVW+eJazohtuXcxiS4khW9xrxWvCsQN + 49/8z7/l5f1x60//+19k73jFMl6ZqD3lbG63HxriMexJWnmXfS+pWhFTDvHkEJs+eoLHXOMWTluCPPqR + w7yqV7WFN0/1FFdOyHvffP9pr0JqBu2pbM6ofWhmxbT3YVOjJvzUkj1n40uATRy1pi9e1aRU/xDmAVdM + dRauOOt1DYhjdz1Vu2Oor7p7jcKCT47HVefik/su3kDeLV0LfvOH/zZ/kb3sNfZFrI61OIUrhjzFqgYx + xQeHvEsuawOTMEbbsZyr8OaVWJ582ZWzccuWnzkbtsTrCOsY7VHjvIV91llPWb/wzf5PNDpJJZeLyB3G + vMAhuBA13hcDtxsjlxcC6eZ4LfrEfuV3v4abxr97/E3j29Zf/c2nb373T37w5td//6OaWXv1PeY+Nqn9 + lY9jseN5THhc3Pb6sh1XTHmyC6PdODCPqabXw96Imfa65XveRx8+5d8c+gxjzpob+kXJXGnsqY4BcXGr + ttnKEb7zUQuPg0S9ZM+ctiuWfEnPINkxcZGnfs3LmPyoT67H2sce2ubc6Te37MStrnzaX5YbyLv1x3/5 + yZvv/mhdD/TW9+XY9XHxPZcdPAlxz5FumbGUlYs82JK395hx1Ue8YxNrXPWFyc6Yxd0ve5PMi7jPYfxz + A3nWWU9YdQPpwhNbJ3ud9H7yUvuFQf5eI/n066SXX/aGk1c1y8erEfF5pC/DildE422ueHUyvjLE96Nj + U/vjHhGzY0fpPD/m0JW720ucq/wZX5o54BlH/Iin3dzmcwbFlEN/5Oz+tz74mE/Fh67orRlr1k3Gvty3 + /dVeuB/3wW9RDfGKG7owcqsGecZJu+p3rPGJjZrCWV/xi0+e256vHqFbyF28sAtjbfdHXYpje90v8w3k + vuKaENev+Ax27Cve+u5jhGMQ++5j1rHyX8A85vXcnvm0KXtMvvq0vWqxZuJbLXEcC86MI8ftju/cfm5c + +55XIM866ylLN5B+Ms4TdcbgN2f3lYeYLjKQwXEJPnNC0Ge7aCyJi+2P1m/zX+b1/R//MF+JwD65Nzte + l+Ok47IdH2mX4OhYQ6xexng8rVba7i/JnJ3j9pbTvTTDfd/C0u5ZfvG3/tnf49PxYcvnxzxzrqF9T2W3 + rxozhjzFPFe+ehaP2nPFv/As3jVbu2RO4q2rd4jVdX5I58xaJcpdktzNR558zXflN9f65DyIvwt/RPNF + rvgqIbz1/Tv5nZd+XNq2489jo+MjSY7xK558Hd/m77jLqBE1Wbdx9OqcftxKZxy456jOsOmDJ3uLL/GY + ap/vgTzrrCesu1cg+4THiSrMT2b48yKS3OJPrrB7HDWGbbXiN/Q/+PM/4qX2Z2PF29zx4fv6a87cu8SO + Af1dlCOOeDvWMdVhfKufvOWnXThENSp+gysHHPBUS774XQOc977x/lf4dHzY6lnu5pYNXHHllL9hqqUa + 4mifzh9+8bpG8xgv3+fT8e1+7330wSeL92nymec10k7dOVnHMNUVBs60VavtWcNzh2yclBHbcNqv9UXi + X6YVXyUUb33/xn/EVwnpmOQxkl4yjpkLOTjeeHxCys74Huu84i5/5FUMXAlqea40H2/WSUm+4vL3+j7X + jAEjvnLPK5BnnfWEdfuvDEO2k30/4cX3kzjj5Cq3MPGIy98lY5Yfr9Y94w9jHrnilYd4dbWOYR6bPgZ1 + bC7HVsc94vRTKz7tzpN4Po898c4jbn3EE+7xsHdO+hknFjnKS//9f8en48NW7cVnofb5a/8h5EZcHNUp + LOM3teUXRzw/7uSQp5riuI0ayM88iv6yPV7Vjf/4s3hfvXxVl/VX3qjDOPDGxAW+ckctiyfWM19yiGes + fPTvvK4f8rP+CuRPs+I6GO/A/PYf2n/R4fHx4y3b5XJczQ695+w8xR1vrqRrIGfZWV8adSRVR5zK617u + i9uxxs4N5FlnPWHFD5c6kXfJE7tPZmF7rOKM4WIiTvPFden6hpMbN1Y/Tyu+IihvJLfjoGMpXMcq9OUx + CDuPOy6wHndBTLxZQz7shdccXV+6a8i/6Vf5zXc8hE/Hhy2fFfPPmea+oX3e3c781LRTI+597nJGjLjH + UjsvOfI7FvptX4309z96/x++9633v7K4X195H1de1un+qO/zNCa8+orrcWHkAYetnBTGsg9F+YqHjryf + pc9AvubK/6Lz53+U310bXyvWx53H1Y6zpLGOOw/H3PKdI9v9JcVfUo916q4HXHPsMWBe64It7bW6X7yL + cW4gzzrr4UuvQObJqZOSJ+oFk71kz9FJL8xPePmSnQdpP36zjq/D+Hld8SpDvGUXx6SO8xIdpzyG6btt + x1a42SPOY68a4kmaj3jbXTMl6qiWY+5TVCt99lW90I9+BQEz9PFI2zHiPWvzxB2SHBwn+dfatBlTLWFl + K9/1TR3lde7bbyDvVhz3+K9Av/Ct97+zan9SfbwHMeF3M8iGyO/ZMi9k5c4exGl7jYov/rmB/OlXXDvj + u2rjD/fimyrymPN47sfeH5uyyXffeRVTXcaFiVs5G6bH1Pl6vL3W7XyW5/h5BfKss56wLq9A5gkKaX9e + HBRPDrHKl0TNEPrKd1+1irvk5/3m0Vd8/Yd/9knHbz/+IZfHJTWPb4jlzhp2UaZfOeQIF+Z+xjmDeihe + daq3ejXW3Md+DtL3o3n2eX1WzIj5S1ascsgTPrClkd96xzwPOOe74LIb6x5LPueXs+ut77gRjc9HV32K + 5sIsiE3bZim74ymB066YMIulzfxzA/n5VvxS+t0/+cGbf/n9b/C7aufx1eMDWzg5/rgkzscrbfMz3/IY + c/58XNt2LHHOUjHLk4CL+ucG8qyznrD0ReKXE1TYkv1Edl8nsLDUyXFRjDWlXRYWfyxzbh6vK15N0FcA + 5bGz44hjbzhjO6bHALby+LixVulNqkfEN+6okz7jFZPdOYrJDnnvWx98nU/Jh6zsu+bpuedxwOySyXWp + ePkS1PN9O7c4hbN2cL0X/bR333Tyl/4i/rtPvPX9Cx+9/8vrxvKrq8fH2sMQznDdL+ZyrvARfyEn7aXP + DeTrrvivWvH1Yv5VQjrW9Rgs2x+bejyWX88Bi9/l43necZeZ07yu1/GSrZf6n7ewzzrrCWt8wJ4n5p2v + EzxP8nXCJocnr5/o11xwHIOGKP8fn1ce37riA/TxFR95HMfx7ONY4j55JQvz4z54ifXjqNqJkZc5xYX2 + PBdxUWvGO7Z05K/nIZ+SD1maqfZjUvsyH7LxtW9yVdPzwCE/MdS4q6NcxNnLYsrxmPJV64u4gbxb8YrP + 6vux+mp22JD0YzbOJ45zI5Z+cdoPrTrx+b6zvtilt77jv+jETaUen6Fl1+PTz0XX9TiKTwzangfK22Je + D7jzld855xXIs856wsq3sHkS7ieyTlpoiE5ocKZ2qXp2wvfF4Nrry/79jo9a8Yc2+m8WOI66mOriyuNq + tj8O4ssPLb+Eec6JGpVrccVkpyQX2sVruA78vW+9/ymfkg9ZmkezpWyz94yI7bgEe1gY81PI75zmibtj + iRPbZxm4S8SWVu6jbiBj1S+fnEUzjNlybpfeP2K+7+bv8fMK5HNWXG/yq4T4b1rjMenHpR+nlGXX45n2 + jCtHohxxHO8afE6FiGs4cs4N5FlnPWXph4CfqPDbFp5SJ/s8gXFSK+bxruW5iTEn/u3fWT/90quRfbxx + /HXsLzpijMuunLQdX9pEjyNs4wT/Ti/xx1cxYD3nnfAp+ZCFmdib88kOrdjdXoUppzXsay0cjzv84rOu + x4SPnM2G/5wbyNpbzQiRnfMxVti2H9Wp+CbnFch3Y8Vb3/HZ7Pir737r2x4re5xD9hgeZz5v0xfPH/+O + D/E4cyXnBvKss56w4jOQOmHzBM4Tc57kFdv84rgwHxzWqRz4hS8svs/srM+24jNM8da/jq9Exxa245I4 + /m17fj02+TguzGsnxtrCyRPuOY11j8rfJHA+JR+ycp6c/To38KuI57ZqdJ3eX/Pmc/5lTZuzBVZaNkU5 + jgf2+BtIzsA5sIfNNpE/9yy+npfSwIN3XoF8d5e+Sih+qY0b/X6s5/Nezwk9pnrM06ed8S1XeOUqj7zQ + 5zOQZ531hKW3sHFS6sTtE7XxPlkrFraLYVnDhTGvEb+9/s36jfasz77+5u/+9s3/4X+pzWOs46zHwY97 + xcvec5sP+8orMV9c99Gjse5zxfiUfMjae2u/u2DfOFaJbbqPU+vKCV5iE8/YyofduVlTwtzbPjfx0BF7 + 1g1kPZ41r0R7lk0efdl3otywfx7/E82XecXnKeMbJPR4++PvWD7W+dylfePncyCeV3yOo8asdV6BPOus + J6zxKgJP0LsTOqU4sHUSK+4nd+UWDxjiwOKzNWe9zorvfPNjvoses3ociekx85iw6+Mm3Pj22Hdui2N7 + TvqMh+ZT8iFr7EPCmTDvjMnPWTm/5kYt7Zk5G2fWbkw5Lhkze+iqE4JZquayH3kDmd/goLlMw7Z9MgZs + 6sHlXnqP4IX/Gm9h61+HxrkSX2nzx3/5Y0bO+iJW/SGOHms+rqXNrvgSPO4tiDvefMXPDeRZZz1h6RVI + XajvTubAJB4rnLyKEQNf8ZbA47fTs153ff/HP6zj648PjjsfR39cKsZ4xPhYlabg8Z2+OF676hDfa89c + 5hHjU/IhC/1tZs1l82hm7EE4dMbS5/PeMOE7z2shr3nOLztxyOBIyFU8/Ee/Apn7szlacFwkmL+5mld7 + cd5FFu813sKOG0j0l2DmuBbF26/xF8jx/6fPep0Vj5kecz3ud4+xHgfZ1/jSfNyuscVfsXMDedZZT1h4 + BRInoU5IncRxwkIc48lOvovz3FdOxiJvyfnt/4tZ+blIfacbj/V4vKj7cW1/xpEPDmsxnj5zZGd847yU + J6ziGXvOW9jYA2ap+UK2eZvTdte4Hse91l5PMWHKE9fjqt/ivZufvEffQG4zpHAPmrtmY2yff/p2jIz7 + GjeQ8YcfPVfPhr6QiMf5E/3ihjM+2xd/OHLW//rCDeT1OOdjm/Z8rMsmDwKOc6uGcpacG8izznrC6h8C + PEFp776frH4R8BO58pZfJ3/a8yJy/qLyi13xKkr8ENTxHo8BHythbffjVRxhqYlZrORSizb9n4SHjhif + kg9ZmkczjdkkMZvmXOIcHC8J6tQxXBr1O1+cO1yY8Fsu+d3bZ+/YM16BnLPAnj7n2/aGOER28kIsHvZr + vYWNfphNfXrW7tcxxOOt7/iDv/ji7fgr5LN+8uobSAmPq47xzXEOKQ5Fj0nGyFWucs4f0Zx11hPWeBXB + pPw4UXnyXk9ccojnCZ6xtiWe+/1PfshLzFlf1KqbSHv8ZOtx0OOiWD9+9tgN7sSRS47E4rf2Eu8nO3A+ + JR+yqm/OMWfLmPmuLxzbm9cRflcLPVHD45qn/CU6vuIhZ+d0rUe/AtnzcVYX2wvi1/07r3yKagb+Wq9A + 5oyaK7QJZkJPzSO7pLgf5P+Zjs9TxvXsvPV9XbiB7OOG4ykBHrZ025M782HrMUh76fMK5FlnPWH5vzL0 + k9pPTp3QeSJTxIUNPjRP+qw3c0LiN/lnrj/99C/yban4YfLrv//Rm1/93r+2L+ZeM9aesYew49WPuBjG + D4t4BSJ+YHwZ3oLXTeR4/G72J39/DBtD3o5XPavj/uRbvz2HXD4lH7LUM+bAfK19prTJAWZ+5XJ/zKvc + 2GNIYcSd49jGRX3D07cc+i3Lf8INZM/EOWlrLmG5D+6luIYBnzmy4zz9vCs/Axl1bYY5M/typn0/wBan + 8mkTD4nrxG9+/Dt5jfmrv/6UnX8+l78CWcfOjqmOqz8Ozq+c1M7x3OCfG8izznrK0iuQkjw54+R1LTFc + J7rzR276vBDQjnhcxB+54muC4oYvbhbzOxNzFp9xadtPzpt+x8c+Kw4sPoCff9X5ox+8k69C+E1kzU87 + 9xu2RDHZ7i+pY6S4xTyOYwaO+KmZUzXMDs2n5EOWemLWnm2fC3uA7vl3Qb54yq3YziFPHI+PPNaCME8S + XKtX+oE3kPoO2ezN2TVb7cFjG6d08m/qWPw1XoGsG8i7Pktq3hDOpP46vsNe4jh8Pafgx7kXb31H73jr + O/4JwM/LisdsHpM+nnnMEms7xWIhyO3HRbVgt39uIM866wmr38LGSeondJ24OqmXxglrXMYa2y4WW+y/ + Pui38vjXiHHh1n4u8+Reev7SjLsIv+6HNShhxw+MuKGMv+iM72h8F1Z8J9s/4ReOa8+YHY+V5k+xPeY+ + w08+uOJXbMu55KY/ebIn/3lvYUs0t+aa+JwX+IrfSMdn3shh7ZlnuHMtrtpDhC/9zC8Sx3651/I5o80a + Wnjxza465If9Gt8DqRtI1G895qA43lzZGy8kueBp7l2U/yu/+xt5jYj/wPWz/MeE8apx7j2OB49JHh8e + jz6++7GHvx/rFOZ4zZBzA3nWWU9Y/SoCTkrZ6dtJWycrtV847zRqTOwRX90TF+R/yv/ZigtQ7yXn0ZyS + 5V/2a+K5aSd/5rTf9ZQbn5OKVyf/6m+e+3ZWvAqb81Fq3rSJx7Hh/srPeO9T+5PtvJG7RHmDk3hrt/mU + fMjSLJc90M65bD+tr4+z4s4RPmss3PsYLlFcPQZfPqX4IarzhD+iwSxzLt9z2L63IczNePngep1Xu4GM + Gaw2tAvi+2yKha7ZKYmxpvLcRy44nlecpfOt7x/+2zxP4z+7/Cys8RZ27Rd792M5js1+jCiDE5K19Lic + P6I566ynrPE5pjhB88Q0nTHG6bvgBJaWdF7yeLJ/kW9fxw3a7VsmnMMx6LZ3js+senlsikcORbniii9M + uf/y+9948+9//Aec+PErvjx5zF574px3kvuA7bnaJ+TKy5pR33DYnee1QvMp+ZClOb2/sMQ5a2PcJ+3k + X/YMzGMDk03f+8K/2qrhsTvJWtHzoW9h718BNmfJ2aQND522MPKwz+YoL/xX+wwk56kZ6Lvs+wB3YcGt + /LbFFS/zCjcuxeMpVRN48OOdjLiexWe1/9OffTm/Smhej3tvtX8dPx2bihNPe3EVN45iip9XIM866wnL + 38L2E9JPYD+h/STuHIst2S8A8r+ot2vi7eK44M6efZHK/tSJp+3xtpWfftrth562x5jPes4Lrdqh47OY + 8cPsGa80xFtnmiNnq3kxX2MTL9E+zPfjIPG8a034GQ/NGJ+SD1n7jD0H9lFz7hzqzDXfOdpn+K1dbP/y + ww4s87tv9lFMNkX1FA/74V/jkzP0vCW+F9p7/Dr/rOPxuBn5vOu3/7BvIFNoR9+7PWRvm7N4xEozDp91 + WLtrAW9+97yLeX7gIfHHfvFLaLyj8cf/5d1/6ztu+rXPsdft2Og4XjjiuW3S/HMDedZZT1n6d2Q6IXVS + puSJHZhsaD+ZHesTuk9s+WF/ESv+g0TPsl14CgcWuoXciJl/VwPzY08uXrf4qnHDSZu+YnFD98i3t+OV + jPgogeaT9Jy2T86tOOR6fJp7c5wct7zBI86n5EOW5qj+2yzlE/Pj47PruLSPfQrzY6ZcifiyU7YeXlsy + c9vP3Kf8EY1km3fNU7Jjy06uYktrH6rn+GvcQOJrfFiXcjvzpsc8hnnM/eC0LxGu/DuZNavO0oGnpoCD + rxLq/6LzF9zpu7HyFcjaT8+tvQDn/kySWxxp42XNxkKft7DPOusJCz8E5snqJ720Tt48aePk5gnueeDP + HNiv8yH4fcXNl8/m/foiYxh9zQ78qsf+iivpWs7JvLK7v/tlG668R95Ixh/V5Cu2NmPOtAQzcV73GR8S + HO5DPviMOXeJeBFPm/kZX5pPyYesmitnlraZhDMmvu9VGPDOh73h4WeMNnGP7zp7sM+s38+b1sx9yiuQ + 1n9J6DGTbNtPcX0/Ft+x1/oicfVOyd6cwzDgN7PTF6f8DRu4RLGl971Vj9Rum2Y+4hDVK00bb33/Xr71 + /ag/Wrxbcc2v+Tmv276nsCOm/e+8jhEjjvx1A3legTzrrMcvfQYyT8Y8UfukhIavk7VidvLKh22csMmL + 70Z7zaVXHn0W+BDvvUvNRjv5wZUwlkJffar2FkPffZY+NsqtXs6v+Ie5r0d81Uf8BWjtRTNwPp/7nuOP + M3xwlxa34hazGhUzzafkQ9beW7PNfTFueNm2D/D7eVR5FZu8tJWffPXoHPmKIZcxs/d6j76B9PmGBMY9 + DDtmNE5g7nuuY6/yFrZ9BjJkHMOFz1lv8OAzrhruNx/ivIxtWEnm4LGGCJtafNQHz+s6z2P5X3R+P/6L + zvce+lffeQMZ82j2nBF7lJ96xNqvmHxyFPM65xXIs856wrp8jkknqU7ajAHbObcXLPrgdDz+uvC1Vvxm + nT2sfs/Rc/lMZRsneSEZ5+yso5y06Yt34S7xWs4fGKV6G8frxlfuxOecvugVP5Q1t3pjtj5ONXvFgLc0 + LzU50981OSFRn1w+JR+yqnfOgn24r7jm9Hhps2s/hqV27hZTTc+dvfs4I9Zxt0tWziM/Axl/RFP7Yf+h + N9F+Yfe+GqO9pOKMvcYrkP6faNQ7fck2R+h9jpqR9l5n5gqzxzFjrCchb3I7Xzkjr/jSXp8ct8mT6L/o + xB/WfVHfX5tvYa9eY4acqY9Zze2x4JKvOKRrNB/2eQXyrLOesOpVBJ2YdlL6ydone5/UwPvkTizzGWdu + yGv9/9j4bsV4+7V7YUbvuc+q+TVLCmdTTtnOSawlsS1v5pNjvNKbRB7qcu7AN2780Pwi/5tF1NYfH+Xs + 3I/Pk7ZpzeY87UN48oz7knheCJ+SD1k9Q+9BfssWz+PQ3MrX8bnBZY86hcFXvDm7DV74wtpemv2T9+Ab + yJ5z7kvz+Wx7POdlfnMhwhR/rVcgVb/miMdIEv5dTDbjk9szdu0Zy7jVaj5j5IYODnD6d5j1l6hOSvIn + Vj5rVQ5rRTyOcbwD8gf51vfn/wM//BENZwqxXgOjxDw184ZlDn3UkIZ9biDPOusJS69A5glrJylOTMeA + O1dx8f0El8h/ra+hqM89qhdn6RklfTGCDbxmqj1w3vCtlseKvyRriEdbdcH1vGmDO+cSlvmsW/6SuMGL + Vwm+qBW1fS7v7XZzLMZ5nfNSLeeMGtIL51PyIUuzpNgMmG+zfV6PGz6lY13HMOG0s57HQryPhHho5ahn + 2U/4DOSYadlDJ77H4Wee/LCT077syHuNz1DHK5DZl6L51NtncI5EMc1Us5vvOVnDahe28eUr7j26Pmok + P2sZTt35s4+Lz6GcWaPxuPbEcY8b73jr+3/1ozXxC7Dm0Cy5B+4DvXtWF5+lsZ61a0DOW9hnnfWE5X+F + 7Sdk233hwcVHGHm6IGQM3MKN8xorPhCOmt3f+11tv1Bqnr5gFX8T8JXLvd/EM5e9kmP2LWezEW8Z8aXV + K3R8hin+LeMXseKvstW/ZrH+mkGzQYxrsUuOxOLiZA9KxPiUfMhCT84UM+xz0W98HhdgS+/+Jugh2Y8X + MNgWK75xAo9eEuKKBS/rPOmPaHI+2pe5fpJwTzu39r3k1f6IhscuhX1lZz9q7EO48WSb33udepfbY7HV + V2/3B38XzZF1/LhLN57Y1q/8spvjOaoZn6f8jf+If936kz5PqT+iUW7WSpv9JNUPts8hDvIZp6/ckPMK + 5FlnPWHlDSRPwj6Z58WmTnj6xQ/J+LzIJLf4+G8sr7Hi1ce9NubzeXtuzOMYeNpD4m4vjRziNzFhZS/p + GdyX7XjXVU3lqo9EvMbxn3z+3y/g80rxnXKaI2eN/XG2nrdnmfP3zJAtR7LlSuRHnE/Jh6zLXEsXNmKw + Q7uIrz2Is2PJcyG29yzfYqqDnm1PPY/j4/+IBjNHf83v/oibaH5wer+QPf7B670CGbNIRo95rFtjNsmM + EQ9tohzXssVPP/gZh1QN45VPXXUYq9riicMY9D0ftvDOvWKdG7pixPDW97/Nf5IQ3/Cgpc9YVx7nRo+u + VTHGJaMv51DexM4N5FlnPWX521D7SRmik3mIn+jkhz0uCsZ5jc8vxWcfq+4u7BP9febeT++rY7SJi6M8 + ifvK3UX5yYka6pX6ZibGul/HrnzmkBt/YPNF/CVlvMLpfe9612ycPWPkOkc++M1BPedOzafkQxb67rNq + HnsMPJa249DOS3tJ17KctLunfM+757iNGPIalzzjBnLMq3mWHjOmz9iSykn7io1aS17jGqIbSM2l2dVX + vuz7uZtTPMfF1+yWP3D6ylOs+/dcFz9qSBgbduVYbMnIJ6d5hl/is3fPvNXLmN76/tf1//eVo3ohykUd + 4qpD2zkVJz7zz2cgzzrrKQs/BHiC5gnJEziEJ/SM44StCw45iCkuG/5rXPzjr7h18VAv9R1inBC3K8aZ + w+56mnvGlat+zke9DSNPsXu8+R6TXzjnuPZ53b9qjxUfmu9ePkf7PSfnMqn5NLP7Nn/limeaT8mHLJ9J + s475KLUH2SO2tMXKZ23FSiqGmq07Hjak55IWX9L5Pfej/wq7Zor+mm3MDax920fEyHG+fOUG/jo3kPFH + NOydM3Wvmocxnw1cz9Os2AuEXNN7jfY9B3VlC08uexXG/s0nz+zC91xJ5NOOWOc0V/mDJ59aNZWXuES8 + JRkjd3BMPF/1ambDRg3Z5J0byLPOesIaryLkybqdxIX1SVt+2vNkLyEW8dd4+2l/+7p795wVc02pGdPm + BSv80Hc5ZncfSMRSjzh6KA7cdOZAZ57VBwf1VOeuh2zF4r9PvOaqY8zZev7eU4l81ztnSeTW7Ctetcjt + Hs97C7vm2ObX3BWjhF97omgf7feeK87cHQNufPPRS3x7DtJvDvBn/CtDnzNnyvl7pn3GzqG/7bdjXfvV + XoGMmjVf19dxr1nCzhht+i6o0fOnXbGJty/B/nZe5t/WA162C+sqL3myF77rzqE/uPDFS3z3Tct23m0s + fPbZe3SedOePWOYbh37Y5wbyrLOesPwzkPsJPE/SjoufduJ2wjPutV7jA/Dx4W3U7dn2vtlzzNX2Heb5 + Y2+FYf8S7xl8l47TN6zqWh31qJhxVKfwJYXRFjc+d/RaK16FvJutZjHxGTAb8mrvLsFzO3Pg+574lHzI + qj2xf81S89l+bN7mKo7j4PuQeP2O79r45Ten8d1eHM4amGZ49A1kzpHzYDaJ8Dlf77F8w5NLvu8x4q9x + A6n/RKO6ZZsPTHM2Jh/Sjxfw62NWudoT9zFscW7E6yVWechtjZplk+sxr9l1LS4O8zremGzVEl/YzGt7 + cCsemjilc8AFR9wZqzyzzw3kWWc9YfX/s8WJKA17nbh5MveFoLhx8ppcTnTqwF7j4r/X9JmAq/d1huRs + +5AU9uIe2k8s9ku8Y0sz32POUR7izduxFJsVNWZcdSXxvW2vtX79+x/NGcYs3V+zyNeMnTP9FGJVg7XF + 41PyIStn195sDs2puPvJ3Tl7LO32WxtP+VZ/5sBWTnBGvvBdgvekVyC1l57zigHn/ivW+9Gefa+q81pf + JF692Wfvv88lrGLkjhzTb8N/on03l2FzLsYk4ROvfMa8Vsd3vmPMlU18YKytmtKKqVZyZFOCo7qwmSeO + 52StjvWMiKnXuYE866wnrHoVgSftOJkL2y4KEsOqBqUvDJ//7af4oxHUa6le7KH+GQubvji77PM6hnqo + s2vxkktc/Ldj0DNOnD1LbxL8tGtOm2lh8aF1/+vHz7PiC98vPVJznpph2ppFfMUQj/0iLt9jiS/hU/Ih + C7Na/31OYiXCllzmNx5qQgqvPEk/LzJmduLC0sdMyvF41SCWnIe/Anndf81PPzmB1dzaC/ZVfHE2btiv + 9RlIr1uzLvFZUjM2ceQif8aLlzH5zXF8YuJAi6eY+OEXv2zwUoyj+l2nbe/hPYGxZubPmHJUW/yOTXv0 + MxEP/We9sk17TvqZS4y8kHMDedZZT1i6gcSJCL2frLJT86SVn3HKztXJHX+R93lWfM2MeqiPZlB/9Upc + M2xxYR27r+F7HHsiR/iIUauW1/C4a/S78ga2+aktV1i8xf9a/0P7n8bHBaynJPuxd2hxNJ/ijffMLcwP + LvnaB5+SD1ljBolmiT1s+xMn85LXuOcMLDX2nfmsKQnOpY7hyfO6lu/+yHvCK5Ddv/eas2z2xHzfzdN+ + w6/Y8l/rLWz0Rc3uwd7qF7bF3R9xcTaNHsQkK3bBKNU/OT2bsLJToz96cJYRb17LzO34hrO/14JgJumu + QTsw4dQVo426kOIvSX9w4YPrPkQ5iacN7HyR+FlnPWHpi8T3E3RghTO2bJ3k4iVHttUI+3VegeyeEs2k + PppLuufrOW/zjHMXK8kY8h0TnnmMVa87LPnTr3rEslba00+xfHFC/8vvf4NH7POt+O80ml1atmbZ4z0L + 9yMJfPOVMzhL+JR8yFLPmmNp3wOkOb6vxCunj0NxLAfHavI6Tj9rWpx9nD/zmhO2+8/4IxrtUfPVjPJr + L7Rz7saHliSfe1v2a30PZB2rrD/7+QzaT+ixFxPVEtdreR/FvNaombErHvY+x+hFbPQxmfl7v46rRvs3 + ORLvFfbWWzmqo/rdo331Gbk2h9sZM673jth5BfKss56w6m0onqyuZc+TWRycvDqZ5YufPOrPewP5o+1t + 1TmbpPsn54YPDFp+admUzLXYrOu45K5XH68hwbuTjaO6Y2blu508+P/pz/4fHrXPvuKVTPWo/ls/xKT1 + GOAYSIsn2/nuK86n5EOWzwGb81DK53zYn9u9X9+DfOWKU1wK8pvTPEjbW69dorfVeMZb2Dmb7VXS87f2 + WNo1u+zJlR8f0/iN//BtfFn1p5/t4xr5Fjbr9nGzfoGlD2yfD9r2uuenDd21UEc68T2PXMVHLfIV93qo + 4bHmIo4Zd+w+1+ty1ort2vJZX9ieo96OVX3mKe7Y5ECH73jlLDk3kGed9YTVryLsF43rBUEncp3Qaeti + svNRL7BXuYFkr+pvPVx8hpKYdfMxM2pIZg9oyc4p3+rAtvzlF2axrrnZxk2JmGzDKm/pqsl4/KB9jbey + 9cc0b91H2kv7LOaXvcRztVf54vEp+ZClmbK/5nUtO2c0zTyPqQ5scIqX2vAXOLJVZ9afPnQfN+WF//i/ + wu75fS7MPfeSsu1TtnKTnxzorou47NDxquRv/vB31i9Nf5TfIPCTlv6VofeUrz4XsRlClKv8qmMx+RWv + nnuNsIUtzT7K6RoS1lDMtOp0DfB3rnqnbzHlq77XqxxhLqqxRBzwO+azVKxwiGJZy23FpatGzxT63ECe + ddYT1ngVgSejTvzyN7tPZInlms46S+Km5vOsuIGMmrqQaD5hFWO/shlrrtUwDHbnoMbCqwZ9anHd9tzS + yYHv9Zw38But3qojqTxy02csvs/x8674jknfG2bg8eJcozft0sK3eGNtS/iUfMjSDDnXkpil5rG99LzY + A+be84hZDFjvr3Lodz78zlO/yQOGGRJ3Tgjxx3+RuGbxvdqxNBl7LVv71XFE7iWfx0G8/ZgEFteZ+MUn + bhTjYy/7L1L1V9iZBy1RP8zQ2GWOxJ1D3OvShs95N+m5td+FjzxyiMsuTKJY6j0Horp3ceDIv9a74hLH + i+v5YS/xnm+3u57nX3zHlpZ/biDPOusJq28g/eTECfqS+IkcOnPD1gntQvzzLP2v5lGfde8uPGPG9BF3 + jnLTJy7ebR3PzRjxtI2/eCkRow58zy1u+cZTvsRqVp2tdtdA7Kd5ReZt62//7n+MOTTX3r/nYO8bzOdT + Da+nmnxKPmRd5qKf84dwNtl3c19yKF1b0jWSo3xiXsNnkT1xx6x+SNR66A1kfAWYz+H7wFz7fIi1Xb7p + Pi7N9Zzsk9h27IlVnSXxf/jjF6rv/ugH+RY44sgTb9RRXfaSKA8iTEK+5SQW9lZHvKyReq/Zs6h2a6vJ + GqqjWqUDZ0y1k7e0fNeqL7njl1hN5HYM+c5jPdZyXmmrN3Iy3tyOwZYEdm4gzzrrCavehuLJWic1dZ2s + rivGE7uwjvXJDf15bmjyM3lWy3sHBh+9aw7yQguvGrSdrxqVI2HcMfAQu8RlK2621/Z8cTAD90aOi/Og + aTtO+zVehcy3saMeRTP0TJgDWM+dEjh5igu74MzhU/IhK/u7cGbNWfvLGREPv+Y1TJzK2fgS5Y3elRsc + t72O8sARrh6IAX/WF4n3fL3PiVtcMfG4x7vc9CXF7TqXehVXzclHnHzGocG5cjc7ejDHcfHUU7zGyfGa + myivZ5p5wGavxBmTKH+vJY0axiPmtdQDNbZ+m3bukMAo1cv59MXdOdUv/Y45J+0l56+wzzrrCevyCiSl + Tl7aebLayXsRclRHtk7y+H7Bz7Oqr9XUTOh1veCIV8J82Z036xXHxGshx+Ks5fGsUz2k21b8Ui9z3Eae + aisnRLGKVz3oz/sqZPw1tuqppvcrmzM3vsdsPptfNWTzKfmQ5XPl3ra5UjjvS/tXfM8RXzkT7+PiMcXL + J9e1RPnJTx014T/6LWzN6vM4VvaSnhvHoOWGl9q55JAnv7k8RolNXznieXzwyFFOxlJ7XuPi3/qpYctP + IS9izlXMfeWqr2YRFxzmhO9xi1VN5nSsxePlp8181U69z2w54tGWiKOYavhsFS8be59x622x8wrkWWc9 + YfnX+ED3CYoTePl58s4LmThDeJJX3HhxM/J5Vvwhjupr1hD4PiPml06JOe7E8z1nxabdOYlbbnLS5sWO + fPEKN0z5KfLJdV9Y4sq3PPSBCBc/sN/84b/l0ftsK76c3PvtM9335R6UU3G3O9dxPiUfsqKvZk2tOWp/ + spvXcdqUijPX8ZHPXOdM7sTVx2PV23r5PM/4Gh8J9sa5Yr+Kyeb+NbtLcjxnCWLNVd6Mi7PlW72MEVN+ + 1RGP3M6xucpH3DVEM5BDueZ3TdVAzHyr237nqbZz9/oQ1bF9mhZPWNoWKx2Yci2240PeEhv50rTnnsHV + DJVHvHngnFcgzzrrCcvfwq6TM2w7keXrZBXv7oQfNUziryU/z4p89fP6mGP2wywQnzv9woR7nu0pfcdX + j623+6Ne5LOG8oc9YhBhXad5XjNtYWZ7jmL/5Nv/gkfvs6/4w4TqVfP0PlurN/dqc4jjOARcaT4lH7Jy + njET9gTde0hNXDrtkdtx+cpTbeVCI4a89rMm605Oz1Yx4wLDTM+4gewZeQxC1iw+N7TNnHHn3eViTzsm + vOqJYzzZwnsOxLoGuYMzc8VD3H3PRb2d33HjGe59nJ+4xbom8qe98xCvfGrlXOLGeZvfe5DuvZRteXe8 + PYa6Xocx1WHcRdzkZPy8hX3WWU9Z+EtKnJTzRIXfJyns1IrxJHZendihK/75/5dtfL/hbV/aw5cQawFe + ezNbvjDVRA3gJYHvvmT5s9ayLY5+iDlfmOd2zlbPbNSz+dlDuX/w55/v/2Rfvs6H86QfPQKjiKP49MVp + XRzOyqfkQ1YdI86xa83lx1KiuPjCPFZYxFW74jMH9uTc5Yk3c8BLLPyHfwayZy3hvD5bzao5U7AnYZ4v + 2+ujJv2qwxoVDz35kswLYc+7eGrGi8s8zT+4xN2esa7X+RJwUgo3zPzQqg3fMKvZ3Js9bXGvo7hqDDti + kh1LXteDP7Xsxq/zeU7Hmb/6CIc9e4Wct7DPOusJC39JyZPVLgjz4qCTuE/4nScR5lon/+ddWVO9bB73 + c1aK4sAlzRdPvvOFK6djEM/J2F7P4rJDv8hVzLHgZY1rrGYI2fooFvrz/jHNb/8hv3x5mzn63c21S8/S + +0aexYnzKfmQpf4pPGbYk/bVc8kXlpq24sBvHr9Ne/3uB8y5VStziFPKJy+5iS/7gTeQ7330/nfUV/OM + 2c0XVlyJeLLvcArqzPp9HKUZI1+1POcaA+Y81HMhP3PBrVwXr101ZxyY94HtPmTmFW/UvuN1neJLb3HP + Hb5yEkfMecJVz7niJK960h/cxnY9cjjLXT/FziuQZ531hJVvQ8VJKLk5OUNfLgz/f/beXue27LgOvY9w + H0GxWwT9CDeRY4ZyptDMmEnobkAGLCu4ChiQmQU0AXaTgESAEmCRCQlDFGTIgMQGLFiUEjYs6ErQD9wO + RApmcu6qGmNUjZprfYdkf7v3Pqd7TqBQVaNG/cy191pnnf33KZ6xwBRvrGOwn/tFmt/8o3erfvbPfphF + faqf80LnLFM6TzZx8pUzffU7/CsJ3uJ3Do6D566zVj/GJcrxWpXLuHK9fvyN7Oes9e+Q95w9t8/xFKe0 + 8WuvxPiUvMtCT/anjhkgjpmmnOK0h6aoJuzmrHneV7bywJ9zgdc67QO/75do3vr36ov55vOg5i2fnJhf + Qp7qJDfrXWPlSxL34wQc+bOX/Ioxp2oZHro4FbNcqxPaeSXkqEfZiSNPNZq/4OSPfOk1RnEe6s15PVdY + 4ms86hhW+aknt2zG1lonW3HxiSt31kH8hJW9PwO5114PWeuXaHRC+olewgvAejJLis+4MOHxA7/PWX/2 + N38xapcIO7T3S5yY884+JDEK6jiHOWmT5zGrVXqJew1xTnWZk1q2ZKnhfZ/ihPzoJx/9L9PEN7k1l+qe + ZpBODvtyrsCFrdzkhYR9CJ+Sd1k69jUfZwjRnLCdR9z4wsCDDE5iy34ZU21hnnuV470yljV6tpQ730DW + PJyp9sT5hIlXsxOTjfkbc57ytEflui+OYopnjbUH68981rWe4KFG5VJkd5yxqt3xtXaJ+eLMPNngVp2X + xMPuWnNmcasOZ3WdUtjBMx/52E/xQ49451Wfq7hwxSqu+pODvM51Hfi+gdxrrwesvIHkyauTPk/OtCF+ + cr9MN8/4VvO5f9IwVryiptq6oEjnDGbP2WnTLyw15lOt4lHW2vLPWhzLL6zzCrfaiF9w0yc/hLmd55hp + 6x2vIj5nVf+oaTOXqJf1lNRePNdqeC0+Je+y1BMzSDCrbMwJES9z1vljb4pRvE5zkTv47FE1FaNf+YEz + 1vOoB2ORc8cbyF987+3P+aw9k81lcefUvPKdHxLxxfZ6awy1vPfSS1zyrnTxg5s289xP/gXuQo5qebxr + sI/3JT75fdyaa/mUtW5rxVE/+dbHeeLIVizzKFd91EN1hK+8rBHxqqUZZLfMWsyTXbnK3z8kvtdeD1n1 + JRo7oXWi6uSEP3WdzGWjRolhrp/7d5rjVUzNELrtFvXS/NI5K+cbmPEynr7b63FB38wnR7LWFZb2qGf5 + lzUMP3TVkBArbmqbp+JvP/uVX/2EEnqg5uhFAQ7tMeHtH3qJpx3Ye2+9f8gXP/Pum7/yr95981/zaXrz + pb7VO/0LfcxUs3Pm8CUVt/2chBz1mj0xg8T5XlP5Xsfzy77jDWT8o92zca6c3WeSz3hhEM0dWnb5sf/l + 2DWP8YGpz8S6Dm3h1MKrprgej1j60M1ru/mdt+Yq3ph4T2DeQ5zqJa1ZZ1x2x7uPMNjOgWSMvSf3PKts + 7+WYJGPyLVY9hadPLv0TPrj7SzR77fWQVd+k5Ampi4NO6IhB+oQdspzkMw/aOc/9VnDcgMbP03gvnzP7 + sJ/PUrj84tjePMa4RBzw554u8ytmcxU2c5q3xLNec1VHPYRXv8S6l+LxN4Cfs+Ib9D5LzxOimRy3/cZs + NmvE5oy0yWs+8De+9uaH+RyNt0vfe/tzn33n1/9vPnWftdTj1D9ngoYNTmLLbI5XnPjUjBNz23uOvKXm + qL30gU19xxvIWDGDepfEfJp/weTXPgwDvsQOEab9ukaM+ckFzzGPVT5rlwgvLjD5rjWPcpObmvnFAVZ8 + 6arjNWCLV/GyJb2/ENUSBzWIMya+10+fGiKcPZd85YqrfMWnTBw263lNYp7j2OAuecKUu28g99rrAUtv + YfeJ2SdnnsyOhZ/c9vPEF5caccMpgX35vz3/T+zF37XVDJrV7XWW0oElt3HEcBGCoI5qXfG6zprXsZLA + GO8arM+Yx09Y9iGWNjDFPVZxxpT73J9Q+t0//87svfTB/iHA3AYvhbldo3nKK2763o/+od94760PDv+b + 8YWRj/oPh9fDHmzOxNBX8cJcci57DA4ZHObLVs+sFzFJ4uQZFzjnKp4fb9SSZN79byDfH7PanlyS80Ss + JObPvYBf9Ri71Mlj/fL7mI0axMTxPsrJOs4XdiWsf52Dmt7Dc3yOqSHDDq7qW17VFI949XAs7MpdbAr6 + +bG4rlV+1GAd8bzG7LPOwDqZB0wiXHxxE2e8fPL2DeReez1g9c/4zJMUJypOYJ3EZ6xP5ootnKxV/Lfz + h6l//JN/4a3JR1/5WUjOkD3Y12eAzL2teM1nOnHOqx6d23tVPHMXP+KDR71K411Hvc9Y1/K+isn3uhF7 + 7mdP4y3w0c/lYi7vj5hz577Xuqo1apoUxr6FvffW+2987a13fta3vlWjZ2rfe0mKzxjinKHqmLYY50td + OZLIXezRk77H2mYt1Tj0Pb+FHevo+472g3ku5j7E8caMV3bHiy+M2o/BiXeI6maMfMzW9uAVjrqpA2ft + zm2u58mWD2lM+GnW7DXjrRVnfc+ljT7X/NZL3ks4qiVu+S4VW/iSxR89mCdexNaenTftrgO+fGH7BnKv + vR6w9Bb2OEF5YuYJ7Sd6xoV1TH7lRt6ive73Pvg+b00++vrBP/yw6muG9ucs3ltccIA5LrtqkJu8iKue + tOEpgwdftZSnHm03R/mZm7p54so++eIxX7m/9t3n3UDm38SO2qyLvthP9V/isM/7OeWSJ67Xz9zym7vG + ke+2attb31//1V/gUz5X5nKu5qNG121M9dOnVLz8Y6awicvXTKhjnAse9Iwjz3RglK7L+L1fgTxu2DWD + z7TuYZ1/xBO3GqZ1TMQDZvwQ1qu+q0+7+OkTKy78xuYe3L6SkW9Y2jE/JTH5ijuPds/RNnzWJxdx5jFe + /IyBX3XIc35hJic88yHtqzaPFXHJCbO8jFFki694cZZ+QxjbN5B77fWAhVcgeSLyZJQ9LxCHzXj5aTOH + uOxRb5FbfBs7Vvx5Q9XETIddM7Kf7UM81zVj8ujLNh85hsmmRGytOTDDOwZs5F3UXutlHm3PUc3CyXvu + 8f7Lf/gg66F3z/qy/uLBNq7FA+9aXUM1uxb04FpO88/zZJyc+DzlIfnWd9foOUKf+g2MOOuXpq06ss81 + urbqVE7i9BNX/Hoe57h971cg4zOpPk/tJ+bKWVdtHPpX+pxP3P3seRU7NPNLLyKOzwKc83n/sJPbszlP + uGqlz5zhM16SucxjnTU3RPXbJ0bOmMPySqweeqgGcxaObNVFXsc837HV9rnVV34J67v2WhLk96xpSx/Y + voHca68HrCdfgYwTN7SfsB6/sAenTvrQqtHYP/3oQ96ePG99/ltfYk/NscwT+9D8nOHEv8AzT3bivbfg + yE9hD9TpvuBBkNvxjnWdjstHnZTAqFVjxDxHXMZucQOpnlWfveT3zG5jL83p3Jht8s71XRLnnl7KNQ7y + IJ5X8eBmfKlnXIj80Iq3XfXCNyxF2CHieC3Y8CuX2vley/Omf+g730DGwjUEc9Tcpns/mv88tziDazkS + 8JG/iuqln7nN63rsp14V77ziSwpbege+8i8w5YTf9pztVNew1MQUP/FPPY2j3EWv80lO8zwlVif43i9t + 9aOon/sujeExcrxqmi1eYPsGcq+9HrD8b2GvJ3yITuiM1YkLvDFyqM/86QfvK9//z7w9ed6KG9H4VrYu + JNLd+2xn/JDOmbNLVMd14lWv85KzSM1yIZ5b+dWDtoSY9+nZpW1u5ki+/Mw/Z6i/RqP+rdnjau70l1kO + u2ZcsJGTWjHhZ75rSHNSlCff8Kv4iRs+Od2Ds1LWnhk3zPNG7BDHUrPeqEkfXOlZL/nk3vsVyFh4G1uz + Yh+aR3sSpj20TT847iufGLTyeu/yXSvvyq7c8Ncc+hDZ5JiefNidR84Tknz1LYwzUCpG22fxHODMk23+ + CRs4ezLmPNWtOSjKKTzyJYxnHcOrjvmzJvDVho8+qMG4pOqh9r6B3GuvByzcQOJE1Amsk1In8LCT6ycw + fWKq5Se5x6R/6bjpe+5vQmrlW6zqF5oyZks79uj7vJaqwXrr3tO3fHFVv+2ODW0iTuU6Xj1QU3jVpbgv + W7XCj29RP2fp86ajdswzZurZwe39pyamvJ4P+5Z/zu26zQUPWPMdv5SsLd09qyZjJReY57l0LYnNybzi + pW95zlm4o5bE8jP30MV9wA1kvI3ts0kwE/aiOQfH/OKm7fjkKe98PJY+xPKYUDxPvU65hdEWd8kZ/LAz + Ds7ayzmnXAry1Kex8iXBr7hzoCXur3VXOyVs9w/xvNFHvEOHr3jWJD7jvTfF0mfc/eRIigsR7vUSP3j7 + L9HstdcDVtxA9knKi0CcuOPkJkZdJzNt+bD7gqCY4qohznNvbHzFF3Oyh9WvmRMDnjGbQ77nCIcgd9YB + D9zmq2bzkH/qx3ho1XFMuRkPYZ/yD/F42ksN1Y3Yn/7N8357M/6G+VpTtmZYY9iDccmb8T4eiJHHWgMT + Thu5jZ1rwR75Iay98l0KX2ZIPHMbb2E95kweYhkvPjjOV2xgsiWH3/VmPOs+4AYy1tH/nZ4PM/Zc83iO + PZFfPPmpuceMOQ9x5Vcu4/JVTzWrnnKJub9K8asGfcad4/08rtxLn/zMNY5m7dqtEUOvqnOKA/M6jU39 + 0+yugRlhQ5J39E0RRr9s4alnLfE6zpzK6+NSMdmpcSz2K5B77fWAFZ9fyhP0JSessHFyJy5ZLzBdo+uK + B27g8ZM+t3oVMtYf/hA3kdm/+ro9/dIWy7hhHkv+Ic2V7zngIe6CuPLFbZtx2umzX2Pos+atPZJnc8Xf + s37O8ld4VTt9YugJke3x9JmrmcCfvvgS9QLXYukjr2tNrGOqgeMDTV7VtjzW93jY0kNqFtrKlX3I6LeK + +BTMArxqura4cK+d+Q+6gYyfTtIcOV/ORt+kjodxJMXjvpwLDvcaucWbscERrzj0F9y18qq349QDPyR9 + xt1Ocf4TNTS/i3Do9mWXWE3HMzf7tCSHmHPFz9rFUU9gL5shfMfhu02u1Ra/YvRlu4A3a2Ysa0H2DeRe + ez1g1beweWJCcHKmMPaU7XydzAMvv3Gv/dy/krKueiXSeqz7yhkKx2zNaa5r1fK6qNX+iZdY285xbvVY + 4gM79IrDZ+2oJT/sQwfvl3//t3hkPvrqb2GzF2tD2I89S4x/lad45dMuLDV4M75i15zED3ti8MV1e8Tp + F2fgkOqpWrQrz2zUbrzrKA7JuInjqb2+iXgRe8RnILX0ZRrM1HvLObnv1MsxaO6hnUet/YmTtuIuybW+ + 5CjnVN9qqEflmSC/6yaHopjXll248YSLm9ow16OXYvJNnNO55BJLMV7mkDtqmIw6F75qJsaaiq8ziSeu + sFWUh1rK6VyvkTr4h73fwt5rrwes8QpknpQtfVLPkz5j5HqusKdOctWTH7F8FfInt3sVMtYf/vDPcg7N + 4zOeZnNO5ZBz+LK1r1lr5hQWccVMVEN5nu8+eM2tnOCxh/wxk3D5h8RPHT13+ZdofB6fK+dgT5+j5qNd + PGKNL5zyD636tBVz33nJDXyVhQ/uxJxTsviaRX1Ua8ac3764Es9Brc53Ts7AOdY8cTP/gTeQ8SqQ5tB8 + kAuf+8HsiEvEgbgNAcf5tL0e63c9602O+8qVDV+9WwvvGsxxn32rZtUL8ePjPNQETg554oz4wvO6QzJ2 + xmZ86a0YfUhjKVHDc2UvWOjyac99d9xx5XoN5Z5mOWS/ArnXXg9Y/qoBTmg7+XUSW7x5OqmJExt8xnTy + N6/9yLnFTc66/vp//13enKqfa5+tRP6hk5eauMTiLoFLFy+xc464fty8tmOjpkniYR+xqrXGWeevP/w7 + HpGPvuJPR/oc3l9+zAB9sU+Kx11GzeIeumqETDx5NpP8rJO68cvc9Lt/4hf1Jh85VzHEtZclJq7nuG1S + PY6Y5gYObHLncUl54A1krGOWd/o4tNa+cl7uDb5k7m3mt43c5ViYDS6kuLQRR27XRn9g8t22XsqTT45i + kuwtzOzBlaZdMYpq9CyTB6yP22mOFaf9sjzgqg8b/HPcpWseseTNuOZRLcWVs+alH3bkUYR5viT8fQO5 + 114PWPUKJE9Enew6aesEt1j5aU8cAvwqLzHrIfmfH/4tb1dut+Kzf5//9pfZl/McvTRHzm5zOXbixZwL + rlxoSed4LHNDrA5irE8bGnHV8tjlHAtX8ty/QKMVf8oQ9XuO1ujlvcVLLOblzMIglsP5xStdMaunuHE9 + ts645syYcazOmI25xSPWufJnDeWVpoi35pw4V/lh0/c68kMe+RZ2rM9+/dd/4Re/9uaHPvf18YSNuRkn + P6XizVPuk/EDT5+cNUd9hK/6SprTotqeVz57Jc6essUFHznN87nEuagpMX+t45j6qE5xjZOiHslpbHCM + h7qSqL9waI++zHWOaojbNSXoL9vrOX/fQO611wOW30DqRD2d8ONkXy4ELgfmJzhymu+10844sFv9dZqr + Fb85qV6jb4jNKsF8U5rbHOdHTP4lJtv1IU/OUXHUweyIwyYvhLy1Z3x7+hZLN5Cqu/ZpnDFhxrmaV7jy + Bscl6lhOiPNVo3HOx/6FBSfrdEwYeLSN47mtJ77GSnu+9QDWccUu+0XM4uBYDYrsR99Axnrja29+QfPM + Gddj1Hu44tW+Jdw7NDkU1Opjt+YOvtVxzirBgaj2gUcO+wsTR/Xcd7zjyrWYJHOYNzDyMwZc2Kkf48qV + DR4x4qrh/OJVvPHiUVbMa8kuLGsIkzRn8Mmt+pzXtXgh+zOQe+31gKW3sM8nM09UivviilcnsuwFc1Fc + tvPiby5/XCu+CPLLv/db6H30w9ycK/r7rLR7n8DKZsxztZfOwb6KR1z2z+OvuEvERpyz3/KGPGqhF0S2 + evWeoYH5sSCXx6PmTV/8jk9/7i/tqMW47M5b+hru9Zur/s1Hftsed17NkThi8ms245RNnXUO2/O8T2Nn + juzys86rcQMZ64133/wm5u75MCvn5r7nvhh7wq9jxVrgeH7Xc12cdQZJ1nW7ayp2rsHnAf2TpnhdaeVV + 7JDGjj6n2HqcznuSVr5qqU5o5Tg+8lJPOzmU9LPu5KQ9etJXjvPKtx7MLSHWnHNNYOLtVyD32ushS78D + qZO2T1KctHniKm6yxuAfNvNdrzy30ycnPrP43J+cedn60U/+BX8/O/txvhD5nNljssfeVtt87OmMOc/r + N6djisPGMZItvnJVu+KHvvVx1McA1FfzuaD/YdceyH9iRvHT554yP6T87ilRTtfp43OVVzHFc54W4dNm + feNmbtprX9R3e9QIn5ikYmkzTqmc4NKHMEa84/QZf1VuIPnj4u9rrpw95rR9pb9KxA+pvUqO2Dy2wIor + n6L84lodxeuYMg6fHOODC57rtIszcyTiF77yQ1NUT7V9Ps1W9a4kc6G9T2IUxb1Hx7qnRDHFve4pFjbj + JzFcdV6ak3FoxdVzzMU6+wZyr70esOpLNDpR7YTFyQl7nLSOiXsRk8BnLGsK6wuWOL/23d/mbcvHt+LV + yPh8YM4TcrFfzZmzRZwcYTU3Y4NrtRILP+1r/KXxUc9y3A+O+d/74fe509usmuGQqxmE5fzSFsN+4AP3 + mO2heJDEKZ3TXOBd32snx3gpq3+IZlBO5Uc8fcUnN+Rch7nMO8e77tBmq84pvmAnzqEj91W5gYwVvw35 + Bj8PqXl9fzoeqXP+iQ/b4pe+CXp4n0PHcXqiR+dc557yU2NmryGO4uKoXtVJu/flvnJkKw/ScylXePOV + 073Fd55izvUa8lf+OX9iZTN38iHCIIdvtTye+awJjD5rCQ/Zb2HvtdcDVn0GkidxnZQ8UcNOnLafvH6y + e67std7Kd/Fet/5tyKdW/NzPv/3930J/zSlZ917+grtPO0U5llcc5Vk+OFbz0NnL8p3nMWGhb/nXfWLF + 5yir9+h3xoDPPQjTfIG5XTkVE7/tjBW+5k7OU+I1E7P8tF3EyfjLe478sOmrz9DCyQ9bcXBU86rnRT/G + Cj/kVbqBjMUfGP8Qe+39Yf/XvuTsH3rJaxuxshkfvHG8pp/C2pgVIq7XEAex5nR/9JWIv+KIda7X8Pja + s2OopxpdRznNcV76XrPsjjlWscAjzjqFExuS+W6f66xYxZirfI+3DZ7q71cg99rrAWt+BrJPTNh9suNE + luaJHH7EB0cXhYWX/pnv4jnxKuG9Vvz4eNxIagbNWHbo1T5k3ZvzsQ/jWW75T3HNFu4x9Dr3/tKffIM7 + ut2Kz6Vmr2PWmidtiGa43suqIyaBX3HWFC+0x7y+7BTFDlnz5Q8u7e7Z9cIOHJozXMS6hvEMK99ypdM+ + 4RY77JTgUJRz2g8FudCv2g1krHolknuRnPZS8YkXl8cDGHFhhXe+8gYvYocunnATxDquOqhluRUnR1zW + UUy5ioMvG+K1nasaWSdqVgw28qXZmzGvkzHy1rzmdN65X9dozkU/i60zVnype6o/4rBHfvrgSu9XIPfa + 6wErX4GME5YnrV841pM3tORl/PDrYmBSuSGVg4uLtLCP+/OQVytuJD//rS/VvC6Yb+6pZ4c99wTfcxzr + va6xw486bhen+SWMx+wfx/rycVOKeXu+tH2GkIzNPQxezLlgzSdGTtnkyRZfeM1yYOrZMXIrl7HkWo64 + ii8c+a6rl/ArzLTqi1OzrJhyCptzKa+4zmHuq3gDGStvIt97s16J1F6wh95bYzpmvb/BkXDf0uJkXmAm + 6IPnsnqK13mWT3tI1epz4ow3VvYhq109WKOw4TOn6tN2fYjP47WBO+/aTrEenU/bcMWUU37kJ8dz0F95 + LcynOK9w9uw6Z47i+xXIvfZ6wHrqFcgS+iO2YH1iwy5OYcxjDvC+6CCfeeSEHzdzP/7Jv/BW5n7rB//w + w3w1L+fhvD675q89SGp+u9AZprzyU8OWJN9zo66EeciBH6+cfhy/oan1S9/4Dcyy9K8ZC++ZEINWLO3F + d758r1mxzAHuHMzSdmPiMd/F6p7i3pOSnBU/cY7eB9YzeOzQFhNfnI6To9rMAd55ilWuScRf1RvIWPnF + mvfwxZrcA/eo/WAPbU+8j59yZatGaK/nORWjv8YbO7Rq0h6agnqyiVveqE18YCa+Z/X3ft1n1pSOeOVZ + 3HvCbty57os/7MxpjVoeu8hZYsqpORWjFi9jnpsa2MhPn7HD3zeQe+31gBXfwq6TN09InKQ6aXWi1okc + J69kcPoC4LbzhKMHLxqMV87gfTxvy/6s60f/58cv/vCH37efseG8NvM6NwSzT+7K0R47P4V85XaedOfH + Z0Xjm+Uf1/rr48Y056s9LLMmRpzzYua5R2GyG6O9+Mi1HMMznzXEG7XSJp6c1sVJm7XCt5olxJDn9eZM + yhvxzMP+E2cd1SwZfGChPa/6mGTO8A+t3Ff4BlIrbnKxT+7B9qnjJsx5rtfjpnxg58fA9cqBpm3cioct + OTBwxGPc8OIKZx3Fns7t/sgBrvjkut38wtNnD/LE8TriqqbnZ9z9Qyru+pBR1+KoiTmcU77xa1b6wGas + aiyybyD32usBq75Ec0iepGbrBA/tJ7JiEPjKS7ELwLDpV+1VyFU9cR55E6kVb6fHzeRv/tG7PS+l9s9j + JVu+79X3Dps+j4uOweT38Y239uN4/OM/f8jJPr6lnzzK3pxPs/hM4nTMbeN5zPd5yl/1jDe/teoOziHC + kks/4+LQ9lqNnespZ+0Jcb+54p/sUevoY/xzHL5zW8MO/Sq/Aukr3tI+5sWrkRQ/Bmmn1r7hu419w4cg + XhI+MXFgA1+xttnrkjPrFt/yVn9I5JDTEn7j11z44no+OIrPnsIrxpoprDfyFA/t+CHJNY581Q1ffOcG + VrHKVY7FmFM2uaUZkwiL+P4M5F57PWDl70DGCTpOUkj782Q9ifDiM8diqrFqcbzH1cXm23/1X3lb82qs + P/2bv8gbrHx10vaneeUXrmNR8dDEMr9tF+XH2/nx8zzxqui9Vn6xKOY4+uccNVPPVWKz5l4qz2LM9byq + Kzs1eeIzrpjsFYt8COyMR27Vh/Z+zZ8x5Xkd79P55AtXvvniKa+kehifOHJmHmzFYHt+yOtyA6n1mXff + /pVj5g+0p95/2ymyXR9SxyF1H3+3Jxd4xdPunLSJe25hlOv6XbMkcWhhPQNxE8zoHJ/zsBULfuHAIO3P + mohXPvOyBnkl6kWtvJCr2tDqbz0ittR3fMylnhZzvs86ebD3K5B77fWA5T/jk3qROEF1MtcJG1yKn9iN + GcdyXVBXFwf0UK3GaUfOYX9cXxS5xfrB3//wxbf+8o/zSydxU3naw6Frb7V/aWEtccMYrzTGnu9506gV + 34L3uX0voX0Pk6N9M5extVZqq6GanpuavK4jPXvDfyIvMcPLJ8ew5AtznL56uF21qVuQXzVClMd6KcYT + Jr643qNyqBFD/HW7gdT6zLtv/sqxl/f92NQx4958r7Jd13FZ/DpulPC99sgzu/JyFvXv3MQy1jbwrpGY + 5MTz+o05p+PnmcVzftqp25YAM3ypu9YHxnkG1jH3C9NMgaVt2jgrL0VxauU6Z/aD3q9A7rXXAxY+A6mT + kSfz4vtJ7pw6kXlSp18n+ZJL2/1VMhb5shUjFvIq30SuK2784sYyvpQTP4cTn1n8nf/+nfzb0tP+Tr49 + Hjdtf/2//47Zj11x86rH058f/pjX47xqcSh4bhCPvEV3nze/cNwAvXPYx43EFe9cOyRw1YBvXOZVvPyW + FU9fNWi7JC7f4sgPPcVzxKm86tUcSfre/9SL8yoe+Gt6A6nF34185xe/hm9s576OfetY9PFsTD70clwi + ruPm9iLiu0YPCetZLGqN2FJ/zZFO+4or33Txk9Nc2fKVI37nQKtW1c5Y8+UrdpLIsx7yqz5l1LD4yvNa + vq8rfK0jW9yQ/QrkXns9YNVb2MuJmpj7lDypEyfGXOElieGCoBruy24uxGs2rjzY3/4Y/2b2Xi9e/NOP + PsQxr8eAth6XeiwQq8et/Pk412MYnKgx6nQfPiVzxTd24x+FeEXtuLH8ZvwEjHheM/NZr2zVD1l7KZ6+ + 1bjghx4xE8ev7NBpZx/Me+YcvvqZ7dyruItqqMfrfgPpS4+/fmos98djpz2vx0Mx2ZVTx6gf7zWmPOBd + A5jxBn7muJ1xYvIhqLPGf5qOvHUGxVWrOIFbrmIj9xCfQfN1bPbzHjNHx3aNIde16o9Y1nRbMeOSk7Vl + U/YN5F57PWB95r237Us0PFHL5gm6nKyN2QWDWOjkMu5Y+c4zrnzVO2vmHvIqfLHmk7ri2Obj4nLxGPnj + EfZ4nEw3B3HFVEM8PiWfXJ/9+q/+wi++9/bn8qZSz1vVjR7lq4c9fyx+macYfc891cncjkFmjeJ6Dfql + jR9ynpscs08x5kFe37ewf5bFHyTHq9TxBZzcO46HpI/PfFzabyyPe8Xdbl5o9ZF/hXk9+YrDbg0cNToH + eNjOh+34uWf5NRNiWcPqS4sDAb7OAj05qckbsfSFQaum58v3/MQpVT9t8JR3yjFe5O0byL32esCqHxK3 + k7FO0hA7ecWB33bnzhO8LgjKd2zNGRzhzYOGr/r7JvL2K77dreOtY1/HnY+fMOjmejxsr+GPq3Odx6fk + z7Xy27z4/Nw7R71861s9Wk8MPntzjuJwHtkdk0xO+octGRyKMOcGpjrwGSNfdmNdU1zVhCD2Sb6BXJe/ + Sn3cWH5z/N3tPE48fvTLPmQcY8Z0XC851H3sDadkjPWu4pXPOITPC8Uueawr27TjksRYAwKOY53TNZpj + /s8oXjfF6syejivmGLie45IY5/X4voHca68HrHglJ09eXlx0QpYYHro4xHXiI952nuTJMTww9yleszHg + Iz+EdcWJL5t8nL+F+Glbv/k9/EzR+pj4Y93aOOOxm88Tf7yEe1w2n5LPXuOm4r23Psg+7Jm9NJN6U1fc + 5issORDV63jbiVe9iU1cOZ271hlc5qeYXzHqT9Jb2B9l6VXqOA74Iwl9LHWcdMz6+CLmOjniikNb4jHV + mXLEo6dqky8shf7kzpjsrJHxpYfxq8+SU5hs+pVv4jXUB3hjze08+c6XjL7019yQzu0e3tO16obeX6LZ + a68HrPEtbDtR/cQtLDgWC+38wSVHWMXUQ7WsTl1QkuOx5mS8fOh/843f+Fj/GsunZcWXePLYxnHnY6DH + bX08hPtjIV5yQ7KG8eirDvLa51Py5gt/AQU3FfEfpv67zDYD7ZyF83h83Rfykde8iXsdxRAHp/N4DEya + Y7USB7d12+l/ym8grxZepc6fC8ovaOlYpfAxcNHj8tOxfmzwOAATt+Lm12MVGPXgGbbmr3mpDxlc+mED + Bze1Yktezw6u4s5vrteE73H1mjHnt509whfHuFcy6tJWbN9A7rXXA1Z+iYYnYZ2cvCCMk3RcCNrWRcBP + ZtVJLOLKHTWaD7wvDCsuX7brtFk3vum810db8Scjfzl+9zGPqx17fwwOW7qw5Hd8PL7BVw7jZZuIy6fk + XVb0jFlrztNMhz5w8FyYM7iIFZZ5Hc/66sFY5RBX/tDJJYd5hYW9SMQ/TW9hP2fFq9Txrf/jmNWr1H18 + W/LYh3bMpHw9LsFnTj+WjQmHAHd71CK/OTNv5QUOaW7HrF76tNlTNQsnlnnFYQ3x1D/itCfH5qUUn7b4 + p/7klD7E63QN1NlvYe+11wOWfxnhfHLq5O6TfD2JdRGoGDHFJ9dible/5orj9a746ql4/KWYR/xu4uu+ + 8oszOu7j+Nqxz8diwQ6tnPAhFotaVW/WqlwKn5J3WTXfIvV84n5GPDGPX3BWKd7kX9X2mhUP3HXGG5Mt + vW8gP9rSq9Rx/OJdmXiVen0Mrh47PF6wk7dIxRivxzbiB5Zx2p2Dc0hxF3EQYx3mVD2TygupPPMt1zkn + fQjmQs/Vhm5eaa9DzoqHL9zj8FHrJMxXz3iVmQ/lXnvtda9Vb2HzpNRJC5knc2lyK4/SHMeMwxxhFQtc + taWJz1rAK542fMfiLe14O3avn23Fb2vq2I3HyI8/H5fT8dbjFXmU5hi3cNQbOcT5lLzL8hlSyz+0ZN2H + z9o52IM0MOw5MXKUr7zk0hfPpflXsQucvfcN5O1WfUHrvbe+iM9T8rjzWOuxg76W5oUg12OKd83mlE/x + POGVmznkVg9gxWG8MNqdo/jkF48Yap85JYFTvL/y0he+xE95rBc2pPHG3r7rtWOvvfbiOk7E+EkMnojH + yWpSF40Q2jphnSe8uOar5uorz/nqt9Zf52r8zPM+X/5v39ivRv6UVZ97DKnHwY7r+vgcguPMeNo45i4Z + D9viqlv5jEv4lLzLyp41q8/V+9ce11mFt2/7e6pe4pC2ga+1lC9fnFHP42XvG8iPe+UXtPoH7z/Ix5PH + Xo8D/H5chsRjWY9nn1PwlzxxDxkx5gsv/iHiCEceuI4jF8+lta7nigd/ma3iEwsfdRU/8ipGW3mrveQi + dp5RNnkf8OHZa6+97rnwbcU+IXEC0097ucgwLl8n+uCUD9vzFB+Y983c9ttWv55DfvFGXfB+6Xf/Q/6V + l73O668//Ls8PjiG8zHG46Bjy8cy7eVY2zEvcSzs1TetnqH5lLzL0jy9v2MOm0lzBSaO50xu2411vZTi + z3zHoZl3yKzXunILY7/D3zeQ913rTwnFX9Cpx5GPUUo9pm7z8TwEj68wy9VjLU1bdYY+pGu07XFwun71 + i/ohK49Y5ZCnmPDQ2cPizZk5KZnTsaxNGbVMV75z0n7rm3w49tprr3sufJi8T1ScmLgoXGHBtRPX4s0v + EXYI8sDLWsw781gr4+RYrLiWX72JF9c48fepX5U/E/gqrL/+8G/r5nEe0z5+dVz9GPP4lq44nyPEp916 + 9HP/4PIpeZeVM9XcsH2u8+y9H+T17B4be0weY8wpPrX4sjMvhPW6btccepH9LezHr89+/dfzp4SOx4hv + fc/nmNupD9FzYDyWxsPzpLnKTYwCjtVg7a7RzzvXJeQNvjCK+p1rdUx4zXPU6DzFZp585678xDMuX7Xf + /AIP/V577XXPlb+bphPWLhZ5cqbWSSsRPi8AnpsSfuXhRC/8FCcmqRh6SMpnDdWt/rKXWNjy48si8WPZ + n+YVN4/xOVEdex1X6TrGdUx1LO1CnnxyxU+Mx3rB5M984x7Cp+Rd1joj5pHMuXzugVMSI8f37Men93zo + 0RP1hI84awbWvGs/+YfsVyBfzaW/onM8RvW33uux5uNej6Mef5Pilq/nHG1yhIuXdvKa477z1tyRU5i4 + 0I55jdBeT37VMhx8+YZbfHJVC5z4N4yHea+99rr3Ov7R+QAnJE7UkjhxJfIND75O4pHvOSbJfTIGQV3W + Mi6wvpgMIa/zDT+0coWH/Wm9kfzeD7+f+69j55LHzmJ1/Oi7vRzbNdcfiz7u0MrzGqH5dLzLyt6Unp+Y + z7hqxmsvlj9zp995Z+7gFG/6Fc+Yns89V8m+gXxtVr77o7e+46eE+HjHY5+Pbdp6jBvvWD8f8vmx+vZ8 + Kd/yFHuqzglb5mnOVZxzEhe37BXL3NW3fPODlzaw93k499prr0esN/Bn4PokNZ1iMZy8jgmfFzbhlU++ + 4rgQLPVCLA7bax42Y7JRo/EU40PaV01huJH8X7y9+uSuH/3kx/mlovPx7eNWx6hiOE6ITbz5kIyZ7fyO + ESOevsX5dLzL8r6+p5B1P5A569jfBa48cbx+x5eeXitzmuO68hZ+xvcN5Gu79NZ3PIbx+7xvvPfE5ykp + 63MDzxl7fhCT7fjINc4QPadSml/PVWlK4qskzr7McZ7qrXOsOUOsZnxLnodvr732esTiT1XkiawT9HQy + C1t4daJf+Low1Mn+BLcuIIpRCmPfGUM8Z7mICzv1MB4wSPwJvx/8ww95u/XJWvFN63/7+7+F/cfeeVz8 + +LkvXsaoJY7rGHdNafY5JG1y3IZPmzl8Ot5laZ6agXO41n7cfypHGOKQmUd+CPHQxRUnMXJoO0c54lcs + +OHvG8hP1Bo/JWR/670FjzueD3pe9PMBPm09Rzz3ikccvcBv355r3odxj615EPJXWep4TsWIp39I/FZn + fImJh2qvvfZ6xMof0eUJqpN0nMCB86TVCayLgfOEoYbl0le+2xVLvWDVp2u131znr3XFK27NoHjXDf3L + v/dbL771l3/8ifj5n3/60Ycvvvwn3+h9xvGJYxBidh2btC+OWYiOa+QxFxzUvayfOGIZH/yJB8an412W + eld/CWeTD47FDcvc2KfZHSN/3WvwBw/9iy+bdR3rOtCDL3vfQH7iF774+OYX3ni33/r254UEz4226zki + v/IO356X0BDPq1zGM+eEs7bEOLJVN7g+c/GIJX/tYfqNr+4vz+y11yux8BMUfaL2yeon8KHrIsATXif4 + oZWHiwJjho8ahZ85g3cVJ+61lFe4YtIU9cxahUnYI/DD/4/f+2p+ZvB1W/FnCX/nz7+T37K+Oh6+z9RP + YMmndKxreE1xxnEkt0R1aIdOnzifindZ3R+iGTE75yNHPNkeE77Gtc9TXmLY87CZM8XyyVHeEOaGvW8g + P33Lf0pIf+tdzyE9X8qmDD/j0G7j+YfnYcYsLzU50OZn3LEZc0zc0hlDPDkLH3jq/dnHvfZ6VVa8TXJx + kpbduHP8IiAuseQgVrZhngt/seU7n3GPFdelYpajPBPNEFqSsaV2fGM53uKOv9gSN2ev6orPcsZnOnXj + 6HvBfnp/sTc/dr7/s0aOuB5LiVjWPDDWdj9FPI8ddmjx+FS8y0JfzKMZdExa5oySsRfZuSfTlOQb5rpj + rBnivuyRj1hr5oUcvP0t7L1ixTeT8db32/lTQnp+9POJz7FD1udUxOFDmkdOxMlx/qoz97Ajp2X6o4ZE + GLluh+Rb1/ub13vt9Wqt4yTlh7bnyet+Y637QgENmye+XxTIUT3HSh9SnOL3BUd+8zrW9cTreqc+h06+ + 244dsvLU5/Pf/nK+wvcqfGYybhrjLffPf+tLmDPmfXI/8zE770+yHFOLBb/rKNbHfuUKL984nhPCp+Fd + 1tV8uY+0TS88zTrmJ77WKA55VS95wGDzWCeneSM/ZKkhzGW/ArnXU+uNr/Kv6OSXJt/Oz1Ouz6vQeA7K + ls/nXTzPQi9Y2ReiGun/VO6h2UM5S+8P99+93muvV3DFqxd5okrihPWTmbbwPsGJn2z+w+j2UkM+4m0X + j1zlZyw55IlDnmzFW8tmHmsqT3brWU+Y6iTGvPiR8q98/w/yFcqP+8fK47OZ8aWYuIGNG1nNo7kxU/s1 + K8XxtlunHfs+1SGeNuLDLn7j5ZMLDuqsvUL4NLzLyp5Xs4UtUewQj2mPKWudQ7A3YMVlvPZNHMfIjkXh + 89gID3v0JxY6cvYrkHv9rGv8FZ133/xmfutbzzU+z+q5Sfta8zmYOXju6zlasbRRa+QxXvhao3JT75vH + vfZ6VVf8jIROap3MZQfOk1u24iceBRcBXRQmT773E3/mkVs8xsJnXDHVl3StJW5a+d4zYxeiOt7/qRrx + imC87R03evEKYbxaGTd+P+tPBgX3B3//w7wp/d0//27WihvGdZaaY8FqRglnHTFi697DBgZ/4s3zGiFr + LH3xjFt1LBY+n4Z3WepZs+RcEJ8JWjL3l7L6Jp2v49l7Vh/FdFwqZvPIV67ba2y/ArnXc1b+YYn33v6c + Pk+J5x+fo+tzLZ6v+Tztc0h+afGWHNnNQa5iKVbjkPf3zeNee73iK97ewAl9/kcPuE5scZoHLV5fGMTz + C0fW0wVi1Gu9XEAqphrJKXvWdD+1pHo1DwLfuek/mc8eS79VVz7z5KftwjqKqWbxIk+1yHlZjuLiqE7y + VSukcNrGb+kepa1G+R4vW7maDX6K5x/Cp+BdFmbyuTgTxWf1mU987kF25RFTrjD5lTPyGh95qSHiI6f5 + 4u5XIPe69cJPCb39K8dzLP+Kjp5r/twszedm+B7T89U5mU+u6qmmsNDxnN4/17PXXq/B4k/64K0MnvR1 + steJTpwx4KvPfxDLfvnFAnjrtNm3fMqM9VzAaJMjnnKFyVct2M1b666Y+ghTXcXkZ4zcjks6x7ngT27F + yFOOYuBZLDX4iHWdNR52iuqNHHLIU27lKSdsxkeuRDzWqhzWCZ9Pwbss9VVv91M4p88nfT7O3EvhzYNG + fT+WilcPxgtnrHOh1c/xtJmzbyD3usfyv6JzPOfyL5npuV+az1dJx/TcNT/syY9/g764vyyz116v2Yrf + 16oTmie6Tno7wccFANIXg9bNUb2ZY7zqh1qBn2oIJ6/wxa/8qkmfGDjdX3nJX7gjTl25ioemjdi0ne+6 + cNYo2/JVt/ywjav6wJrr/MKtlvinXNaGABMHtvOg0x/43NdJDnzUPjSffndZNZf6H7bmcB0ztt+2couv + fbFOS+Mp7jNftueEHnxx6WecvuzM2zeQez1g5QsP/Cs68a3v/ikhey6bjOe35LgRzXfAjjosu9dee72O + 6zih369/pPKEx0l/eVHoC0DFr/KEVU7xGRcuITfrkVvaOYdGnwt+4lMrp3PnfMpP36X4rTNvwYdYrPoE + dqrVM7gdvIkbltrzp/b85hM3rtcJW+I1POZ9uo76Nr9sCbmeo3qB8al3l+X9o3fNm9rwi3jvpbXnys86 + hnmucGjiVbf5I++QxnXsuA9i+wZyr1dlxWfq85vfX33zC/HKeEg8P/OVS/nvvvkrwdlvUe+11ydoxede + jn+Ujv9F4h8s/SPm/7jJL31g0vWP3aHlS1SjuMXvfwxHTnLbVz7szkvMZOV4rGuZT3vlpu910gZHfnJD + F89iihOXP3Llmx6SdRsPW9L1wJM9OBZDLfEsnv5Frvipmw+7aw5NcX7GrNbK41PvLktz12wmwtY9r3NX + LvclLHheo3gUYMDF7/wzD3bXaOzQnE+c+EeZW9xrr7322muvx6z8IdrxDxX+4XK7//ECLnv+g6d/VFsy + pn/8Ku/8j+ToayIM9fiPcNmsw7rCna/ebcs3/tI7bccqT4KcIcYtn1p1vK9zxwyVA27lEJdkDvGRv8QL + s7ppM899YeJ3DXLShsiuuGFeA3UQk8+n3V2W5qr+h855aA9skdq3JHBp56RuEW/aONbg8DFNW3oeY89L + 3OoFtm8g99prr732eiXW8Q/UF/Mfq/pHSsKbDNr6h008ccu32OkfQmLCUzMGfPYSN7Hiwfa87CGJWObM + eGvuIYR1PMfrQvs87k9e1Qxhjc5rPXpSPB+8VRBTXHbmJ9Z+xok7T7UGn6L5YDPfaogPnuyul5I9DGf+ + yg/hU+4uq2dTf/iOac62e9bMZ472IvG99X67hrQk/Ma6Tgrrr9y1ruR1uoHML2LEW5h8OzN+i/Az8VdT + Ut76YmD4TN3bn9s/4bLXXnvt9Rqu40IeP9/Q/7j5P16J+z+KxiGvxLHMY03DgKNu+4xTkNf/cJa95Kh2 + 9biIqZ7qqPdaX77rmcd6rFkif4l5vnzH5XsshXXAgcDvGUee9V39FLM1j3jtTy3bfZfmYyZwVbMxcTLv + iPHpdpc1el/MIhuzQvJYhZBz8l0zV3ZjEOWejoPF1XP0DiFfIjzsV/kGMm4CY75j/vef2ofbOhY6Rhl/ + 7+3j5jL+PN/bn9vf0N1rr732eg1W3ESOi7lJXfB50S/MtOLihl5j4EO7JMY4cum7Ld7w+x8nxUIrp2zT + ynWZfM5cMe2TmPUWB7niNT9s5cmWKCf5lu/c9IsHW/HKCYy4515xVLPi9Ndc1Vt5iLMeeeJAd25pyeHz + qXaX5X19Fs3fc9t+jHPee/u5T/rirjVSLupe217rzFH98F/FG0j8TeZ8VXHMf/IP0bFTfGA6XtKHxF9P + +czX4pXLt/59vKK5v4yx11577fUKrvkj4/aP14XMf/Smnxz7x6Njyp2c9MW3fzwUS5zYEMuHyA+9SvdU + j+sc1Ko52GPmtFTN0BlXjvQVR/0YYzx95squPNn0r7jqiXhr9Wk946E9PvCsi3kVQxw91c9t7+c1+TS7 + y1LPdY7au+YuTI9J48FZsbQv8BLGVnwci8onFrOEVKyPmXiKvUo3kPkD1HXjqNnb1h40O/aD/WrvEsUy + dxXVPyQ4xzH44LCP//C++YX4hi/H2Wuvvfba65ErLsq4UONirYu4fGhIXdjtH4v6R6D+wXA5/wOx9kjb + ctNmH+d6T8fEUS30nNgVt3jVz/N6T09xFVN92ZVrePKFRQ3XT8VXnLHujVhoYRJgoZEnH7Y4wtnDMOVk + vYgZV3WKY3q1+RS7y0Jvzsa9+Dzn2dsuGcfO8w7baq5c90Mjj75pt8WtHOYh1varcgN5uk7k7JrX9kJ/ + cLi35hNzMZ7s6pXa4pkTN7JvfzFeDd2fp9xrr732etCKt4p+8WtvftgXZ5PA8gLe/ziUZrz/sWg946zj + /sJXfOYBD10cE9VdtefPGo2j18pvv/gRK58zLNjAWSMx8oQBJ7bgFTMNG3Nc1ata1MWxuGZDHdRaY/LF + O/GXvuhl2uzOv+8NZM3B3ppFeM6lPVD3Hpu37kmiemue/ORTwFWecaxe13RhHeYl9grcQOLjLj2/zyq7 + 4jG/4fKVh1hzZYsrzspzPmo3Bnnzw3h1NG648/OU+63vvfbaa6/7rLjg4h+K9cK8XNztYr/yirPawROX + dtVInv2jQN9rIy5pX/EU46+inPQveq+5inssZzPb60mvs1UOY8V337AUxzxGfMxmPMdVe+3hfuW7fdEH + eYetmOnuw54RM5xPrbusOUvPW7OZiBN4cgsnJ/fQewKPMUrXWI6TONGfItzreVyxtWboR78CecyBawKl + ZjetOGYnXjE7Jotor+Jc9clY6o65BO4c2ZQP4k/z5Vvfx3+SuaW99tprr70+jpWvRvrnnELiYuz2UzFK + /4MAXaK8NWepF3leI+3IqdjkFYf85JIDDKIayvV+0oVTrnzUm31Torbs1actfs1D22fs2m1XrUVXHjHl + zbqdf+Ujj3b5ti+K8tDD4pWvmWHzKXWXNWY+7JSaqY9JxcQnb+LKm5y0TTfe/PYb77rklD1zsmb56PHI + G8j4iyOaQ9rn85kznvsixmOjvXqOpHOf4sweK3/mQVauYjbH+/kf5f3W91577bXXx7P8RhIXYbuY2z8O + HcOFXL5sF69xVW/9ByD8rMWL/8gpzrnOla38wgtjj8JaV4w5K7cx2WsMfuuOocfsD/+wrXbayrnyF6n8 + Q5TffeCDB+1c5WoOr5XCnKqlHGrx1YdPpbsszeYzpYy5OaNzct65hzoWqSHiuT/qyE6e/I4rllzPZd3S + jBf2oBvIuLla91CS8wGHWIzx0MqreODMbRv7nPzupzj6SZo37cbEzTrqScxzMIe99b1/Smivvfba6zaL + /5C8039Mvy/auiDXBTovxmYb5vyMm4wL+qKd+zKeOOjPGX0GaQo4XqM5lzgxxToOO331kbDWwCQ1B+1D + o7ZqNr7yu6fjmEcc5V1xKh647MR7T17HfdkTR16KxfgUusvKvuzts2G+iWEfiuE4OqdyCwNXvniJsV7i + 5HitqcmTXXw9nnxMGQv7Ua9AxucJc27O2HP2fMJdRg73kBj9iSPWgrhisjMnbdYJsdrSZ37z1HutUdi0 + 8db3cez3Twnttddee91gxf/Q45uPxz9qH9RFWcKLsi7mfUHnBXvhFZac9pXb+auwnknnoIbqdD3HkaO8 + xK8wcc32WmUvOSmJNSfjpsVZ7RF3DjHUg8AXBk5q8qoOY4gTf0KUL9v53WNio2bk1lwP+Axk9Z4zhZ8Y + bc2e815ozQ9+50hUS1zwun5izjW/8xbcRDXDfsQNJN596D31vngcc0abP+OwwYEPmcdD++pYx4tHzlXv + 4hNP3iHCL+OyU4Pv9VOIedxzDvv9A8ufEtpvfe+11157PWPF/8rjhjL+gcu/JqFvcdvF1y/ouhjXhTl4 + q09MfuVQqk7xkOP5ialG5HncctpvnuMjvsaMP2uzVtqQERNmvuJDH+Jzdu51TuGWX3hgxFUz8K65xMU/ + xGOed8Y7LizifKrcZam/5DRP+o3B7hj2u+TZHodNSR7xsL0+MHKzNrRiA5McvtcI+xE3kDifMYf2OPfS + e3Qfs8P3PNnui9s1hHftaRsWtcJnnmqLp/rKBQ+11vqOj5wQ5qEmfEni+Vd03sqfEvrs1399v/W91157 + 7fVRV/zPHH+l4u34e9vxP3a74B56XJR5Ibe4sKEjnnZrr5WagrrAlTv4FHEUX+t4vvyhDznVVU7ZFnNh + rOpTKpecFPqqVXlmd6zx0KjZdmmr3Tk2i/EUF2f11zolxPm0uMvC8Zj9XRD3+S1u/OL53g5bucoTz2s6 + Dttyo17a0OKWJm/UPbB730DGZwCrv81WQkyzw+95xWme6kCnkKfaykWdyVlzyjepPqwxY5gNnIkXT3mm + vZZyp6+a5B/2IfVTQvGD5/ut77322muvZ6x4Oyze9jkutt88LqzxFyV4Ee5/dOJC3BftjieXF/LyM0Y+ + eWuds/bctke+YY57fO2b3PCJFU4s+MUzQc3WwCBrvRT64nrtcw32Jy+1cNOKV02XxM9zZ70rWXmHRD6f + AndZ2Hv3zjmO2U77tpkH37DwM2b5JeSBi+MvXHWknV+Y4d3DbdUA795fosG5ij2dZnYRRr3O7RIx7a9w + s7F/9nLftOzys5d6NnbiCU+eNGKDZxzgFo8Y/apJAU+54KdPiWte/MWv/Cmhr+6fEtprr732+sgrf2/y + uKmM/6Xjf+v9A+Z1wT58XYjrgsyLuMQv2o4rdpVTknnT9npzhq4/c859FQud8bBN1h6SjDN/YMTTZ9zx + wVeMWPEu+LLhQ9I3Xsej/hXe8ci74vAhv8vCLC3wMfv0sf8xt2nVAfY0P7AU5ykuPjWEeZKFI7x7k3Pn + G8j85QX1Nqm5QxKb+z2JcWVrvyF1TMp3m7ylhmZRrtdrjo53S9ViTmLmK99xl+7Z9a6xsI+cmgO8roP6 + B/b+ob/4mXff3j8ltNdee+31nJVvm+mtb37+qi/Ckr4Q6yKPCzQv+utFmz60x1BPtZybtgvrOtY1L3rR + 9jz1dBy5NofhylGvltVnLnHks5ZrCX3PO3EMRw/4ql9iHMVHXQof3rusnmPOgOMGScz3IFx7GXs6217H + 4/CRnz7rON8FMeZGjvIkNse938Je5+r9Yn+1pzVWGPYmnmKrhg3teWE7ppyKM8dtl6uaPSfz1GPBqmbE + Lb8w6sKJFcdy3Ve8chaJX7iYPyW0P0+511577fWRV36eMt72ybd/7POUvDDXRZsX4fqHI2PzYp0xyxUn + bXIKS75d8FdcdTyHWjzF1/zE5ZvOGPkeU77E+as9/f4HzvHUhxRmds9qM4dE3lIn7M4T1nmQO/+MT8zB + vq41v2ZzrHzDtR/lSGc9YU/4ksCv49P3eAkx1brnK5D8ya6as7XNus4XseIx7vsyvvtlUyK3pWsWn9pn + qv6jhvWxHOGZT654J7vyeg70al7pU74dE/eVc0j1oKh21UH8gzfefTM+9pM/JcSHaK+99tprr5935Vvf + X8Vb37iw6ncpcQHWBRsX6L6I18U69ClmeXYxHzzDihd2cpTjNrmUxBlTLmo3F373UKwwcStfvM5pXmvP + Oede4+6fOahXeGJtp5B76Pf50N1laf51nutjoOPfPODg6LhWfGDzcVmlYtXLY41XzfBdissZ73gDGa9+ + jZk4S8/Tsbkv27PyzFZcOZ5b8ayJHs3nMaBec8QbfSt+xq8wj1U9iXhrDWKaAWL1LX7KW2KVo7zEjlhy + GqPgp4T2X9HZa6+99nreire+8x+94x/Z+DylLsS6mEvy4qsLdMb5D5KwQ07/CIwY/DVHecL0jwLsxp7C + UZOzSJb6wopjtmpXfcVYN2tJiDePfYVJFo58r6d+qDH7lz4eDz5Md1maK2fhHDWXZMwOEa9yyZt4+x27 + yAuxOPot2IV/qhNxyj3fws63UG0+zZBzpbbYIeF3jMdpibetPSpPwn1XjZbugbrCVC9ty+s+rcWpuZI/ + seIZvtavmPFOPVY7NHmKVW/zVeOpPld1FNNPCeGt7/1XdPbaa6+9PvKqnxI6/qd+yPu4QPMfGF6YHdNF + WRfxqwv12Tcs+c1LnFjVXMRjlUO/pGbVnO37jIkH16Qw48+a9Cnhe05K1mHftGde8Zccxe554xOrZqFg + dszfNsTnFBcauKS4zr+Kmw85c1Kn/3J8SMTveBzzP2I+T87Xs6S4L/uQ4EGUj/2tXMeLP/zGQs94++Iq + L7R4yl1t1XadOSaqn7mSJeb1FBt84oNXGHDFlAusOY57rYozNiXxD/2t7/1TQnvttddez1j6KaH482Rv + vMu/omMXYb8o68K9XqivuKElyhP35Mse9Tu2YuoBG/9AyL6ufeb7XClmi+P4FZbaJTCT4qcNCfven9vS + HDWDz+uaMvm+h95/2NpP57WvPq2P3OCJc0jxQyJGUW1o5knIz/gdbyDrFciaq23NpZmnD1uS8Qts5tmx + DbF6hZkM/tr78Kt+YtJnfvnEZFfMOSNu80sYxxxzP8Dad+ypWHN6L+rtXEnNk7bLPFaHn299H9e/L+zP + U+611157PWPpr+jEP8742RL8lJBftNcLty7KzgHGiz1zgLcoXzmoNeOqPWPoUzzLbXv299gprpjz0mas + cpTXWrU63rL2k89DfbfVM533kzb3qz1rVreLn7h81iNW9ZYY/I5JBsdEPUOLU/mJQ9/zlVy+HXqe7bB7 + rn5ODI6wQzR76BFXncU+1bBcxMlPfNZCLuySpfYJtzqp6Q+MOcBDNy4MtsWWmSaPNccM9E/9Z67niTdi + FOTRt7odsx71V3Te3n9FZ6+99trrOave+s7PE735X/JCPC7a7Z8u0MKJKUeYLup18aYtXDxwrR55w676 + 4BfXcprTuR5Xb+ieaeWKE75yBqfwlojFK708rHdbPneIz6M5G3+Cl75zkVt1s87MSW19Vz440gtXsvDC + rz53vIHM/0ydZsfxqtkVF5YaOLh+bM7cs01O5tNnLe91silVy/xZU/M3p+oYx33ZY4ZFV+yQ6sf46BWy + +N4Ps80+4Q88McaJVzww5jbe3KprtuqCX73zp4Twn+q3P7ff+t5rr732esaKt3vibZ/j4vrOcZGtv6KT + ogtzXoh5UZZWTLL6xPJC77GLvPoHIW1d+GE7Xn1HnDhriCPM8awVUjVYj5g4A68YbMQDe/tzPIR3Wz6H + 5lp1zS77wGtPwXFhnuIQ2TNHNnDkzjjrJd7xwskTx7F7vgKJV+NfMhttxMlJn/GFM/ITIzfkiCWncNSU + P/iqYzmIY4bO77hrF9To+qWjB+ujDmKNrWK55MFHrGpUXemOK3+t6bVkrzVmL/iV45jyE1vzOyZ8xPhT + Qvnxn/3W91577bXXR1/+V3Ty85T8KaF5Ee4LdF68xwX70OTIF6YawMCRXbm0V74wz/O4/Kxl8zQHuPiJ + k9e50/YZvGZ8xpSH664Lc2EW2T5z4hd7qlhoYVUjuIwtuZVjuuIeW8TrhcacxC7kUTeQmBX7ST/xOe/V + 3MWv/bnd8co1XtUOjP2Tc+Ixnxhw8pn7VI54yQ0OfbeztonHU466iZl2XvE1h9vKEZZ+22tez+s2Z7Sc + qincMOV6/YylnlzneNw4+Vd09g3lXnvttdczl35KKC6qeOsbF+YUXXzlE/MLu/slBy8wXfjXi7jkqq7y + 4AuDv+Y7nmJ9VVP1UavzvRZs8ONjADw0d10+i8+umScGv/jipIbtsRUfsajLPuBNzuCGrHMkB9jIYfze + N5A1L/dUPjHN5XjOT/7kIA6OHZfgLDHlPRkr/9DynXvY6ud9h0++aoTGTDMmHBzsMzkUt1MqVzkLlppc + iriS6hlxqxFYcZ3zMjGu+rot37muFUOO26FbDvzD+EMP+zcp99prr71utPLzlHzr+7jQvj8vxLz4Xlzk + 6yJOEVd81fGcsiNXF3/VOdWb/xg4x33xSoJzhVNULz6Yz0Nw9+V7u9q3BP7kIUZ+7nPiyqu6p/qNVV3n + HqIa1edCqg/tlHu/AqlZU9t8xCGNpRy2sM71vbQUh3ry2l4lY+yF+tIXNWom4E/175jVpu9c53vtrus2 + OZytciThC0u+ZrQ+4jk/OZJrXtVY8hCzeGDBuayPvXhtz9EMlUde/A7vo/7zuNdee+31iV7xlk/cDOCt + 7/gpIV6UeRFOXxftBRM3tIt4iq11BoeYRP9YOK/4lPEPSmHidjxqH/v68JE/ZKyZes5Dn46Hi/1DacdG + cfkeL1xY4ahVucRDK6dyF9vrlG3+o16BlI4Zeg/EzPfY6hc3a/BxYD3Fp82c4IUeMatTsdYdl9jjS3+t + m3HzZwzx4kWuhLxhm6hW1WRe1+1ewqE9t235ntP8s48e0MC7ftWgPNkjfdt7+T4fuexP+4NHfAZ6r732 + 2utTs/TWd9wgxCt3dbHOC7NfqPsC37Gp6+Kd/iqoJUme/WMiDQy11tysrxzjeX78mUlu7SHrPHfPJ1ui + eO5DuOU3b7G5d+XJbr/5kqdqek5jh47jWsf2qH3HG8jxPOTx6FmmTiGnMMupOi5Ri/VCFAe3j+kaV95a + 7zLP6iOn63mNwRdPuYU1T3b7E1eu214DGuLcyg+ckhzprNF9r2Stmbj7VYNci5/EuLJXbtVIu+fqHpHz + 5n/ZPw+011577XWn5T8ldFyI48PqfcHWRXy5mCPOi7zF1gs/LuzEh4YENzDPS9ziymuh/+7bD3/rSrPE + jJfzp+69a/7kW3zgOn6nvQMLWzrtwjsnNUUcrwH80Ik7h9i938KOvpzV95Fz0V51z8+cNXbYVSttP1Zd + 1/t53PGqnzaPu3KS7/Gn7cod+MTKjvoSxtDLuYyTgx7iScBfuVc1kstcxNbZyLmwk3Oqc30cgc86VW/0 + bznXIEZ+9crPSL75BT699tprr732uufSTwnxz5N9oAs1Lty4yIetC7n+MZA/8MprPznUuPALt39IyOl8 + 8OJt61flA/Saq/cHWWdXXHs8+dRugwNddV4WqzhiknP8Il8c6ofcQPpMaa/+2V6PtY7plVQs83R85Dtu + WPFbyx588rpX128bUlxJ8qFRU9jcb9dyPfMV67yWxKxH8thnrad85Vzih3QeagBjXHzqjGctaHGLbzKw + 4FK8tvo5z2sf16139u9K7rXXXns9eOmnhOLGIt5yjJu4l128Q8Kvi3zGha+c9hWXOI81vvkq/aNQ+445 + Y+/L/l07rr2d9hg2a2RMNQvrWqpzzrN+BwaOYs1JHnPElX/vz0DWDDaL5vb5Q8bslMKKw5xRZx4X14pP + UWwep8Zps/9ac7WLQxm5ZTeOHMNMK16agrm7nmp2PYsbPiRzuP81L3zLcUx1lec5VUvC3MqP+MhrTDyv + UXGrJT78st/fN5F77bXXXq/Yis9T+l/RWS/mcRF3W/HSjI9/DKpG5waWN62v4G/A+YzaT84bmGYXx7Ch + D8FxOPOEj7jlr8eu/EOST67wrtW28rzWvV+B1Ezqn/qQnpfxnLWPU9ncg/AhrFd7NC6wPg6T6z0bdy1+ + CWuseRKf1zHhwW+7tceV2z0Q99zGm5sx43ftGff64jVGDuMDp1bexNpWzogFdojb5RevNTDntb/qg7tv + Ivfaa6+9XvWVb31/9c0vxO+0HRf79/UPBS7o+scAtqQu9hVjTn4e8+0vvsofiveZfT85P/XAJGPP/Y+i + JHMWWz1OHK+tuqlZN+LuH+L9gNvswb3jDWT850Bz9Ew2Y8w08Mnr/dF2TdtzHC9NTvVccPnqnxjjEZN/ + FZu8xpJHH3mM0ff87gsfnBblKbeFfNW6kFmTM2XP8wzOqb4Wk1+2+Z3fIk7XPNdGfc7yRO2Q4EA6X/Yh + +yZyr7322ut1WvnW91fxV3SOi/0X83fb4oYhX7GcEp9ZAu/1+Zu4+Q+V/QOnf8DyHzb+45a+af1jl7Zx + +h+/i39MrZ6keqXdOvMW/qhlHPDJSx+8e76FPb6FvYjPWbj2RsEeMDdyGDN/7re5XQPxzpmPRcVYA5zG + JIVRvMbgm93x6Ln0JUf2wOl73hkP+8CWGiGya4bUzWvu9IfNHPDOdWdt5gbumnbzmqvZawbPoSgWOarR + Mc2VvH0Tuddee+2116ux/B+v9R9B1/kPWmjZFP0DB27/AyyusIpZfnEXvmL4R3P6Iy/5EOBW5yE3kD2j + 5oFg3xWLGWlXzhKfeO935i2cJZ4+Yx5PmzznnHIVF/fKp6w1NZdzJBELviRx5lzFshY54AnvOPhdX73F + kSimnMTNd37XO7ClnmIlFQfnKn7CTKp31HmCG/E3vvbmN/m022uvvfbaa6/Hrf4HEf+A1T9i8Y8W/zHr + f9SWeOZJUKf4S1yYeMqpmuSkbVr40MWVZv4hhd3xBjJfgc7ePbvE5/PjUHxq2YNnXNQRd2KV47byk3Ou + 7ZyyFaeEXf3IBa59TVzYmtN8aPG8T9sXx4E2pI/Vamceazc+67r2HPWR3b0aB3bmZNzskRcSfLOTJ00c + OZ3fGPOtRvy1Lj719tprr0/Kii9l4DN0h+izdLIP2X/7dK9XbdU/TPYPVP2DdUj+Y+Yc2Zbj/5DqHzxg + jTe3fXHSJwbc/nGnqC7stWbnyL73W9iaS/1r5hDuSfMKG/4hyPX8uSflCPf87EW/+qbdtdaY4ye/+nQO + /FWYq1lCM3dg5ClP9ohnnvnJIZZ6nW3O0Vqc5pYe+TM+eqwScc87RFrxUY925x3aRHVWXFyv1QIsZP9b + stder/mKz7odJ3N+gxcn/XqBgkzsrRdvvPvWB/FWRPxPMm4sWW6vve6+nv7HCs/bjh3abOcElprSuYw/ + ic08YDhHKh61OdtlbxOvd88bSL0CeXUcaj+2j5xdXOKKCcc+3Was4qibOHlV48IX/8pWTfHPIm7zUptd + s5ivOGLNSZ7ixMS9rj3jVdtiwip2Waf5XhtCTHmHBn/i4g8ucdkpxZ8+MOY7fmivoT6Qy9j7fPrttdde + r8vKP6X3tfiyxJsf6gKjk1t2675QyI6YuB1Lib+g8sX4WZn9v8u97rX8OXoS/aO2xPX8lt1cacX0nIef + dehLEid35VWN1PCFP6kp9/8ZH/YNHbNIEutrgdsuM468kuDQ9vzz8Z6cqlN1Gws98tVj9ZOH+p3XcdXo + GHz0goyaI8Zcw9XHa3vdjvUMKcwXLjv95E9O+i5eS74w5pUmR7Xch2ae41ajhDEJODPu+emLE/gr8Jes + 9tprr59h5bdx33vrHZzQOrFp50ndF5M64YnniU+8coZPjvHjBjX/YTr+Icxv9R43rhxlr71utvRc1PNP + z8vC6Asrfj5XjW9+xxtvG1oc8bsWcYp89R950odEvGof8qhvYUuvcz2J2R7O8d5zcSXEPX6qaVyvdYqb + 1Jxps94hqM865Mn2usIlFUsc4jniJE7tdvLEN92cpVfGMLfjXrd9xeasaVuPFNZtftcpToh4h14xx8sv + u/HkZA7zLZYY47/4tTc/3N/K3muvV3zFDVze0PlJbLYEJz0uCopfXgx0AVhik88LjHGOfxTzre/4x3G/ + 9b3XLdbp+cbnZ9kmzknN3OLIp6zc9lvkZ07hfV5VPES1C+cMtCXh3/sGUvtbBThntbnlt+a+bH8VD2zs + c/rObw7x7M8aFe+8MxeiPIjndr+0i+c5KwbpHrNG+uSFBq7YkvcEb9QiLiy5FMWdo1pXeNmJd65ikon5 + 3m2e4Z9njXhKxYnTnxrce77Svtdee/2c6zhJv1gns10AVon4GkPegV3kgQ9JjBeOp7nAxDfO+/Gj1/GF + nf3W914/76rnUT7vlueZPRcVS594PxeNe/n8ZR7t4JSd2upQq6ZL1aGduOWlEHvUDaT6y0/s8NdYauIQ + 4oxVLjEcE3FRE3hzRm1q8NvuvOZVzchZ8k/xA6s6qyg/cyToXzkWl6+Y11X8ZVjotKPmEq+8igHzWM1A + e9TnXM31PqrjOS3ipVQdaPiSxivP4qqRedJe+5B4YYNPw7322utVWsc/QnzLuk98P3mH2Im9XhTqxDdB + XBcGiOziLbEUizkHWn3ih63jyz37re+9Xr70HNTzSM+/1nruk8fnXOecn8NnTuvZb+auMUliqpmz0E4e + /YiTEzl3v4Fk35pnkdpH2s5tPMX2Ce4RX/Z88g8pP/Iop9qHoGfHNUfmZGwe88ERr7jGJzc5F3LuiZyM + sybwtqFpU2uOibWtHOe4XGEpywxdc3IUH7MtedAzNnvQNo56ZMzwEVcueeoRn5vnU3GvvfZ6FdYbX3vz + C32S8wQOKawvJE/5yhEuDFyPw4c0t23wRi77uO4arM0YvvDDt76/+tb/sz83s5dWP2/wXAldz7eM0S5f + z2H4FUusn5fNOz8fr3jpH9JzYCbIOV+4x1OTc+8bSO/dM3JuyTJ/+oekTVzcU26I6jNvyIFXT/oS1VKf + IZYfghrNle14+9yH5KjTvRgjJlyx5vS8K0+ifulr1qw7deWELXHOzyCnPrKtxpMzJ+c8v4tyfZ5R17B1 + 5hOPdQ5/fyN7r71elRVvBetE7RMeOoUnsmQ9sZXn/uTNfLsQMA5dtvcnLrtqsYZyvNbIDX1I/JTQ4b+z + f0ro0730HMnnRtr09Xyh3zKfUx6rWsRdl5zqIa+EOX4+PCnJ7R7SEXvED4lnbxfNSelj137wrjFo2Vd7 + POnkGUYZx0X2EofIF5cc2hA9NrCzFyX5ksqzeU0qV7Hsa9hT+KGzDzlVP23EPU/xVbskpppWo/oMrI8V + hLkh4lJrHnETP8TzRj595VXcZvBYyRHf7zTttdcrso6T9n2d8DrZdaLXyc+LgZ/I4jlHvnKdq/y0LS6/ + +8sWj/MIs1gJa6vGJUatevws1xfj5yE++/Vf3xekT8HCY9/PDT2fhthzBDbw9XmF59LEz/5Shzj8xsWD + dFyiHElyrP5DXoHUHKltzpwLOuc13XO3eL78l3HFFw+cznWdNjlDMjZ7Fpe+i/qhZvf2nJFvPVwXT+L8 + QzTP6OM82opLAm8tTu9N+YpNjH1Yt3gS1qo8YuJ7n7IrPmdQHc8ThvzWze2crrP/Os1eez18xedJ6sTM + k5YnapzQJs5p7nFih+3x4GeMvuHiV/20dRFZ7ZmjPHEaCx8iLGtnLvPNnzkL72v4KaH4xzg/T7nf+v7E + rXwu8Hngzxc9f/BcoM/njXDXiilPdvkuxu3nWtdqf9ZKe+FkLeGsm/G73kDmZ44x/6opMa8Esd5Pxwzn + PhSX/jff+I2Os87IUe3FRu0Do6w5KRYH54wB16yHzzzvA3/F0a/60m4ctc56ySNWueTK7tptC2++5ZNb + +ZTCTLsgLrvjZbOPMK83pHq1eBy5R55mO8UK329j77XXo1e8tasTXSdo+3Wy8sTvC0JzGS+844WzRnHD + L4w8YYegtl0syHXJvAu8JOtMH9jT/QIffQ993Ex+8Ma7b34z/0zjfuv7tV/+WOvx7sddghjwFs8B1rUa + 87yOuySHzy/4Xof4iC9YPmcndve3sKOvRLNQfH+1t8OvmYmPfI+njbxf+85/ehHrB//wwYtv/eUfv/jS + n3zjxb/9/d+6rpW2clFHdZPDeOdJIzaEM/QsZx7w5iivOKudvIl5jWv+7HGa2fIKE77w5t6Bz5qMk5u+ + 1VdMec4FtuI9T9qsJVw9lCfb85vbOVnn0Ps/+Hvt9cAVN0R5Yl6c7KtkjBcAcWTDb3zkGD5s5aq3NOOr + nb711kUna6Q988RDXfYKYR/FlOu1pSGNF++9t94/sHfire/9U0Kv19LzZDymEj5XMl42YuK6TBw1x/OI + tkvx0m7f6ynu+Vc8x+75FrZuIDFDz6i5NFNjrTV38lgDuvnlH1o3kOv60f/5cd5U/u6ff+fFb37vq/lK + JepaLZtR9TxWmrzwNc9qg+P8tl3UT/mqK6maIYGZHXmnnKwp7bMxnjZzGCvuFSftGR99Lbc41lOzlBiG + GoaZDZnxM4YZ3FeNEvZE/7c/x6fkXnvtde91nIjv1Am5ip+oh86TumxcaBTXSV8nP7HiWkx+5i81vFbj + tA+ZdvC6lvuFL1yX6mm8wLyn8wY3eGZn/PhHdf8VnVd/9WOMx9Ofa/DxmNfjS/HH35+Hqlf+Ifl8oJbf + 9cEfzzHaKRf1QkbPwtAn+He/gaz+PUPO5fMfujk4BmVnvovHu8ZTN5BX6x//+X+9+LO/+YsXX/n+H7z4 + 1SNPfeYs7GVasdIrJ2bhPM5F3GLOL5+250kUM1HfEuepxmF7LewJnMBbmq86NS/zhHcd5CYmcX5yxJMN + X7WaB07VYGzGW5Jnse7LeNVgzh2f83vttdeyjhOy3r72kxMnLTGewOJcnfwrJ4WcxIrPfHEyz3xyhy+O + cNrV23DU77mcs9ZovGsMLv3Kozh2rgmbevwVnf12y6ux9FhJ4rHS4wYfjy/08Xzox3OIYm5XDvmZl7Wg + k19YP9eqlsUqJyRirC9/7fOoG8iaL7TJaV+mFcs9lg9RLvC3X/zad3/2G8ir9T8//NuqpdncR9+OqXdx + V1wx1lj5WYuxylvF+GlLiKGuzzRnrTjzyg4+fUjnFK84EPmOKTdjjA+udOKaTZrxwWHc+LLFB4c5xKpG + xpRPO2Nv/hc+Jffaa697rniVDCcmT1I7cR3TyVonrWKy6fdJPWN+wqdOrnKmrjxhJvIH13iqLb5s7y1x + HHbHq2bkS8hzftvXdWSPOd7bf0Xn0asez0Prce7Hq/F67Bh3W3xhHTs061QObfcbdz5zzM541gXu9bxW + 8B71Fvacg77ZtS/yJqd14OlT4McN5G/zVvCjr67ZfdS7+yu2ysxd51tt+Vk77ZkPfeaVFk5bfnFXnvXx + 2oErr7AldqplMYli0wevbEpxVJ9xz13rz/y2vX7mZp4w+Puv0uy114NWvNXaJ2mf9H2S9kl8pWcObMX9 + pG+MvuVXD+Oov2TMk5r9ws86LcqpPovtPM3TPnmJoT744jkGSf4TmHKAowa4yx7xj/EX49vw+63vj3+N + Y5/Hn4/PYWcsfcTqsStfzwXmFn5o4fE4h1jc/aopHkU1r2oUn75j4j/iFch1ppJ1dmI9s86L5gpL3/Jv + dgNpNbMPMc008LRtxkWvPNddK/Ihwq85sD2nfcMs37GJTz+lOIw7nhhmUM32jc8ayln9q7zpw177pk9M + 8cQv/JFDPzSfknvttdc9Fz6vpxOTJ6UkfOKQPqnXE9r9VXTCFydrAHO7+ht38tZY84fOGPMsFpjjsx+0 + 8wIbOazrMc/1GqorvPOUq5jX7pxDPozPU+63vj+epcdCxzuPfTxm9jj449X+5IeWPR7D8GUfAp73O+zk + SyNHPVqzhrgVW2YX5843kD5TzbDMJGzwaIsr+xw7+Ef+z/MZyKcWavLYca7sZzNmrGbwOZpbNYRlXLVh + e/7IqV60K7/tFMa6luWTI/+US1HuVb+fmkeuONgLY8SqHmtFTPGqHRzvpZxDrjE/jkt80dnrsIO3fxlj + r70esI6T75s4CecFBifwctHiybpyFBe/8OKxjuHOUU2vXaKe1sPj6UcseYxZjuLqB2GcWObTV07hzK34 + IR5rftsDMz4wiWIz7j1UU/5xM/nBIfnW975gPm/VsY7jK8njDKnHw47/+phJZ53CWhqHVM3CyDNcsbRH + 75DGVl31HvAWds2iGcwufXB8fsVgTy0uaoF3ixvI7tczvgzrOSwe83MPiANvTvNaz/2nJt/7KS57+qgh + +9SHgryOy1duSeaJ57WFM890cpjX3Ildic+w1rrEZCvP/BmDHZx9Pdxrrwesq1cR8sTkybmeyIoNbSd3 + 8JKbJzZxiwPHBQr8xpTfnO7Zootb16v60hbzurLlI261aCuWmNUUb9Wwu7bqnmKcJ2O0ESefvUYtl4gb + h7z3Dyz/is7+POXPvnQ86zjyuA4teYILP7SEj1vFIeJmTJL1LMb6HpeNPh2TPTHyHvEKpO2l59GMHRNX + fJ//av/hK/c2r0B67Qttds1y+KGBkZP2xezBpSjeGoJY85TfdSY287qneIFJ5K/xrLXkp1SPc47swslN + Ya3OI985i6zzXOaTJ+lcz1nwsI/YG1/dN5B77XX3hX8EcBKOEzttnKh+8kL8xJ8nv9fJ3IqhpnidM3kp + 6k1+CHLUj7WsXvOsnjiHCEf+xC7lKq56hlW9tNfYgjM3fM+TnH3td2Ida07Gj/rxgXK99b3/is7TS8dz + fZz9uDqnNPnNgyi3482vmOkhmQM9MdY5BLbqKw5cXObl33p/4w5/671egdQcPmfMYjhszN2zi09cHAm5 + Yd/qFUjNN2epY3cW5oTduXOv8lXD/ebO2NgnY8CPuHjECicvbBfnVN3k0Ta/OKztmOzKtRxxM88EuS3C + Mu78sK3W8KtOaPKZ4/yaRfWYF/Z+BXKvvR6w8h8BnZhxUvLElD1ObIvNExt2nfxLPMVqSpIT+CHVg3bl + mK9ZvEbjNkNI1USPxE2fuZyFePNVt49DxUPIcb7nAKNNPe2ZJ64kYikLP3sn1rb3GrnLTwnxof9ULxwn + O3YhPF6KKV7HUhzqyk97PqatwSk78skXL2soZtprDF7FEJdfc1T9yuGr1G/e9FXq/FOG2bvnSrH5h51a + wtkYl2juipPzsXwGsnq2LV8zigvbuIXZnMS9xsp1PnzybB7EgE0+sPSdT7u44XtcsSXHa7topuyXGrmr + n3xqny3ikuQoljUueo689ktTMre4xLPmfgVyr70esupVhEXqZM6T9WxL6sQuG7rrtI9cXARmjl8YgBeX + nJFzqgs7NeuUljA/OBLFvI84ylkF8Z5DmNepGgsffXsG1VAcduPDpyjX8bS9TmKzZ/Fa8qeEPq1vfecx + WI63jmMdI2J+3PyxKh7xcXwjnvmGE3OOYuDNx+xUj3hh6Xe8ctjHay7582+9f8Rv/fffwp4zFbbOYHHn + iRvY4GccePwg+HOXz+G2i/eHfeA1W89zmjd8w37pG7+RN73YQ9fxGpVLG7pjoVNYQ/nqM/mNFd+w8FXD + seJY7eLSd47s4EqEj3rEuyZ04+iR+CHKlS8sceVbvHhR85D9H+O99nrA6lcgcSL2ia0TGidwnayhKc1F + zE9uCC8oI2YXiqinGG3xC08ueyiWGPDEnpKsYfMv+CqKy0YP8IXXHPTTznrk0ZavnMIo3YM1rYfyVLt5 + EmDAIclTHnNcxDvVYB4kbwi++Gn4KzqxXx2DOn5p9/HJY6lY8ukrRrzjtBmvY7zy0+9YSuZPjmvVqzzy + qic5suV3ns0T8cSaF38Lv16l/urP9o/xeu1QrdlDM8w5kpd8iOo0B6I6z/0h8VizR887bZsvcNqS9hFT + TeHC/BXTv/7wb1/84Q//LP9+9+e//aXBU+/0pYWn7mMgX/O5eJ4ksaW28r0m8DNW+KKrX/AP8RlUf+Sp + bnKFzxzVkqhPxSrP+PRD7xvIvfZ6wPJXINcT+nzyIi4bEvbCZa7zgRnP6rpUDjmoo9z2i+M642e95sHm + fOyh/JTEGp8284InsRqrhu28tl3Qo/NCJzdjjh125ETsJaIc1Z6xrqVY95LO/A/jpuIzX/vk/eD51X5z + z8QSpzg+sLAPfGgT1OljLCzt6oPaiismbvWhoF5LcrPWymvceaoxueZXvcTfj2/9P/XW92feexu/A5lc + 1PFeqgscnPbZs2YyTczmuOFnIFnbRbNGX9kHXjOaaJ70yYWQwxo/bd4f/P0PX/zun3/3xW/+0bsv/u3v + /xbyrHbqdZbitE7beOJqTknGmA++RNyOd97Eq8/gyW4suQODrnzHLDbjc+7gp1+9mxOybyD32usBK24g + /QRPzRN0nqiMU4DTd018xAzTRaDiac8LQ2HiPIFd+ZkvjFIYxf2wVWfUy7zDZ75zXIpfsfZVQ7zVhiaf + gl7Il+2SdVdhP3DO9a9EnDFH4dO3+T445IufhJvJPgbcm++TsbDz+Jj2mOw6XsLIhzC38OZIKm6cU05w + ycmYfIu3nvUu80yezHOu4vYq9eG/r5pZ45DQpzrUgfus4g0+/Rbwb/JD4jELpXubHzH60prDcyRzD42F + /nlveP/pnz/Mv9/9O3/+ncz9pd/9D6zf/XKunEPa5omY2c1x4V4iJrE6rp2XtYbG4+I8+R6vmaid/5Rc + 1rB8j2WcnH0DuddeD1jrqwh1wtpJqxP36kSePHCUI6xOdMaVgzz4K0+1va5iyps9esayKVWXNTJ+qtc5 + 4nftlszzHmmDrxy3PafiS77jEsWrr3PCJ+fUm3HZXQfHqvJDMm7+FRZ81aEd+BvHzWR8fvJ1/Zb32Kf2 + RQzSxy9tcjs+c5Xjx6ny3C4f0jXVrzFxUwrHY57xy7rtg2txw1UTnGkrB37XqJlC1GuZrbTVBxciborl + hnh+cYNzyO1egUSPsnM27ZM9GZNoTuyhZ0Quc8hR7Baf2Yw9Z13Vzn6caek5fOb0jJqZ8bR7v9OeuSmM + pRgW3OLR9pqVE7LUGn3oK7fEc5Zc9ZLeN5B77fWApc8x+Uk6T86+EAiTLW7Gl5N95NMvvriJ07caXnP2 + xFyNM49SeSGs6bXgMy7xfpTqw7jjrjUHMPkLZ4mXkBO45ziv481v3uSKn7ZxJe6P/JDKN23i/de6h3x4 + z98evNWq/eu45f7aPh1HHiPHxT8dH3JWUTw5p1jrE++oB588qy+8/c4XJl75ys+65h+y1lJvj6GHYs6f + c7cPO/tYTseaO+pTwr7JDST3qT5lE0/J+c7Yqn2+ETsk8m8xb95Aeo+Q6LP0n8etj6NjPjvyPQd+ccuX + NL7mNtc4EvZc6wq7iktUM/3seWFTwt83kHvt9YCVr0DypMwTM07q8o+TWids4KEpiaUGp2zDK6Zc2oiJ + Z1xinqMazoM0VxzxR5zy03wX1Ustv2KHZq+Ui77irHZyT3zrkbzGSiwPHNrld+7IMV7FyMNsjZUQz9hL + a9BPG38lJ97W5NPqlV/r/sIfxzWxQ3N/irud+SO+xCqf9iGnGoUDk534qN9c57Re4x2b+IKNOTXXwSEu + u7W4zS+csa5He8GHPsT7Ia/nQJ/b3ECOeULYS77iqTOGuPwTZ9VW7yY3kN+dr0BmbfbofoidxGYJCR7y + IGscnD7e8QrqP/3owxff++D7L77y/T/I/ahnz4A6mb9o5zZGPn2JuKMmfeXJll81qPcN5F57PWDppzj8 + pJ0na5+kzZlY+o4dUpjZodvGxao55rOPx6qPxdac5nEPnkOecPkDX2zHlDPyl7qaBTb8xtpun3MOv/GW + ta7N53OZTvwQ1RMWtotzy3bsENSQzTziXjfs+NLN6/C2ds3O+VNWjHbv149971m6ZKnnPM8TT8dWWMaJ + SxRHjRZgzJVduUs/2VGL9ZTT/HU2w0y6z1Kb2ms6T37n0B6cjit2k29hq2/2gvY+3lez1FyW63nY4+SH + 3OwGUjVDm0Q/zaXeY075xb3ItZj8lJfMH98o/9Zf/fGLL//JN178u299Cf04g9cF5vXb9z6yK3bCmlf1 + w5eQu28g99rrAWu8hR3CE9NP5jrphRObJzdtCuLMKz5zVp81mjv9p7DLfrQrfujIhXR/4W37rAumPoY7 + vzH6PoNhK46ZJLPm8Nn7SQ5rF5ei2sJlpyZf9byuYqWv4pXPepSw46/hvOpftMGsfMy4H/jzuPveJNhz + H7dpX3Ea03HrnqvPemuMttd16R6zp+qKJ1GPc+32i0ddvY8cz0eMfuQVtsQuuGmvWnVMbvY7kKpd83jv + xou3SuZob405HthNbiDtVT/161m5lxDG3Bd24jN2ypU+sNA/6/w/+sm/vPjBP3yQX/6Jb5T/0jf+Q/ej + 9lmFp2iGBR/zhATHdcZQUzPvG8i99nrAirewcZL3SeknqE7YFJ6wEvh9Iq+47JSw5ScPFxbkuO4LyeSG + hqC+tF1IKKqjPK/jHOXJVqzqBeaSXPAVr5ppK+aYz9KCWtNXD4/J97jj4uU8w+8emcf5pB1XrRTHkntR + i1z1FCZu8d99+1f4NHvlVs3PPeY+Fnkap63cpUZjsBWbOPJVR7mqNeKHVM/FTllzlJc4+WX3nCcORXN6 + juKeLzxjyWUe4y7X+Y2fhHVU+xY3ZOfac97eT+g+BspZZ9Vsk4P93eoGUn2rN/v5jOoprMXnshqLIKYa + wJ4z/z/+8//Kb5THzxNlvZiZPSTyFZOcMO6vhZzUiu8byL32esjSK5B+osuvk5UnKXCdxOQyJl6J4sYD + 1y8ESx4xz0mfMa8D7vmC4r4w1FHf7l/1k8c5jF84Oc5HrO3VrzzWdL9rd3zwwhYunjRjXaP34ngJccQk + k9O1HLuK49ipzxVnlfgNQT7VXqmVs8WMcWyofT86ZuDZ3mzvOhbgWP5SS1zHxBE2Yukvx7P68jEwPPSp + R+AWK376zK+472PuSXVUv3CT4i02fNQLvYo4Jz6x5t4Hiu7vAAD/9ElEQVTmhkyzeQ+J+mgOzZLcjIsn + 0WxTkHe7G0ifKetr5sJ8loVruvEZy5ylZsjt5re56vhhHyuuGYpjMeUkRr/r7N+B3Guvh6z+Ek2fjDpB + dfIKh8yTOG3ylJNCX5wnLwrhS5jrPaUhjk3uqEGeZK0v32dwXtYMyfoTr36qY/XEzxyPm63Yyqvaqb0n + 9u35NYPH6YPT0jldU3md33OUsA44U8NmDsU5zgt542tvfoFPt1dm1Xzc97rH8/FqW/vVsYMII7fqehy2 + 8D52ZztrjDptVzx8SfgV69nLNp7HPTfwy9y0ncMc5bJn8tMWlxzGk2sy+NRT+rjd6gay5uBcmAPStnEK + B5a8nBX7hSivebe6AfM5VFuz5yz0NQt4HXNcdco2Pznm3+Izp/GxA9XTjNVLuPucScdxzORaNiV4+wZy + r70esOozkDox7eTESTx918U99BrLPNbTBa3FLgwu5F/i1JE7a1vf9Mkltvaq/sapPPIaay1beWm7v+Cj + BnH1mHWRh7lgyy+9cIGrxoKZPzByi+81r+ocmHxxR47j9Fdb3JRX7JVIzZq69tXzrjH3c4+hTcRRDHUs + L3VzuwdxSdSjDZ7lLnH3Rw3hEvmHXmcqW7yQw6542hD5yJHmjIGrhtviHr7zpt3cyj80asO+zWcgfRbT + kvR7P7KVl7h0zEhO5Vvslq/gVf3omT26n3znyW85cJu1MOKdp3jcQD7/h9vrBpi1MRf7+F5shsbn7M71 + fOXsG8i99nrA8h8S18mZJ6ph42Q9BBcBnsiBMV6+iWNeVzW8tmOYgxcK98lde87a5FmuOF4nNTnFd232 + 4B5S/dJGrOYfWjGbP2oMDu3AK8bHgbkea4544E5h/mJX/oV0XtfLGLXiXVM2uSHGF0/2q3SRzxkptU/N + Xng/XtgvuBDfP/fo+cwZNjnqVzWIoxa0bMXBbR7iqK864DeestRW3DlZ13DxOsdnWHuyTvVAfvPbVlx1 + M8frVg1pYofc4oYsakrUQ318hnWW9I03OOQJg9zoBvK4ieva7HOIZvIZ0i7utOWrhud7rPwj79Y3wNk7 + ZpVtWviIl917WbXH9g3kXns9YMUrkLhw8MSk+ElcmnZfANYLELkvyXM+sPVC1n5i5Hit9I2bMa9vXMU8 + V5ycgRj05HscMv2wq7b1QG3yy+4cxapfaOOKA42Y+8hnvSXfubLlF77yzFc/+I1BX9nwlZO1ql5j5Hz4 + 2a//6i/wqffQ5bPmnJxZor2teIpjtHU80i8MWvG2jb/KVT3pQ4AftdJesPKZIyFWNdMGDhv1ZKtW1WFM + Ur1W33jdp2vLd/46l7DKpX2TG8isvRwDifWVpG+zF0Z87IWY9M3eAra5vN/oa/EV8zklmtP9ETvkljeQ + Mb/rnoszJt4zuGhWcaA18+GnfvvFG1/dN5B77XX3tf4lmnHy1gkrWU5snsTieo7iJx7txKlVE0KcoprS + lb/GDJ8x5CRuva44oSGYI+MLnnWWWNYPMc6oERzygC+5jKdfPInqTC74iI3cEOsjyVwX8oa23LDVH1hz + Cg9/4atWYMpVXtrH841PvYeumo+zaU+1z2UfwjNHe3ItOzmQ9nV8VAuS8SXP+ZfCXidOYrOHsIinZh54 + nevcyQM3/OqTnO7ttkvlmt92a0nG2Ce5YVMifosbmuql2vKFyaYUP6T4NpvHDqnYgd3qBsx76BiOucrv + 3mFDFm7WmBzVTVu8Q255A4l+Xbtk7In9aw89F4Q1al765O1XIPfa6wFLr0D6ySzpExV6xVdu2lkH2mue + apE3xblzJuXJLyFn5Xu85PCjRtvKsRhx9AK3ffYhr4T1QsQtnPUHTl+1Jwf14Xd+17L+lUcOsZOmgKf6 + 7CVeYsLl9zxXophyJLPm5IT9KnyppufSnBIck5q3bODBTU18+pMrWz1G3uAbTq448oewjmOnWQuf88yc + l/SgIL9t8YF7n0NHzOoVlja5h9/12lbuKYf2LT6Tp35z7j4+8Kf2WUa+z2qczDnkJjdg8RZ29rFjXb71 + Zn/FXReXduBeK/WF3O4GMvqhpjRs7KniMcs6W2G0yR05oQ/ZN5B77fWApW9h60TEyeknN07oOrFl18lt + cfqQjks6B3VSAsv8ruE84VWDmHoWzjozv/HMKTtymldcYmvfxCnDt/wUYYpTMufAPXfa7edcpptjfUO8 + Hnt2DTsmySOneM5tXOJ1kA9/lY4fvmqENttzww45biA/fPRfq9FMNSvncwzznvcgzgmvPPiKw578lKzx + lD1rS9Ye7Xsv6xNxq5c96KNG57ftwh7WR7VKGCt9SOXR9tpP8yTAinvILW5ovO+oPzDsreYwW6LctvuY + SN/qBqxqas7QtH0uxcq2WGIZmzlhX3IP/7Y3kOil2rWHl8ybuMeDX7xz7r6B3GuvByy8AsmTktInb5+s + OnH9xIbMvIyTm3jl9kWh8KxD38S5T9YR7ljy1T8w5EPgZ07VEt75Hkuu8eR7n5XvPNRFDLb8zl39IcXx + XODyET/z05asWHANO9deOLQrX5zUmo28BU9fdRgLeeNrb73Dp+BDVs1qe9MefFYdC+yn/ZErv7isYTGv + 4z7siaUWzhzVdC2O8s51oUsCl7h/2NnLuF7X+3rceerlPMSwB+9zGT989KJNH7zjhuYGr0B2z6VX2pgp + e0rIL9y4hZMzah76pt9iXnvGLOpFkR168IirBjh93GVXHnNu8RnOOAZeU73LN9xnEc/3pPjISwx6fwZy + r70esK5uIP3ELIwCrp/cugDx5I+czIedmtyX1VWs89qO+NmnLTmwwsM+sK6FebP3hS5hHXFHD3EYK3/p + g7i05+gYAZfvcdVwO+OGKz8wyeAHxpqdu/Lgr7XDHzEX4ytHMZ8JtRqbPudjrc9+/dcf9oUazM1959za + C/dVe+n5ExeH8cbOnK4pYb/CYafmMXHM86pf8CiKg9/5XQPYsL2P1UQt5LY0N+TMW+2OZx/Wl5/a4qvv + UnUOHXKLV8Sins8XNvrPXjmDa9n0Ox/1FCv/kFu9goe6qClZ/RTn1Tzmy6as+9XsyrnVDfDow/ro1XjN + KfF5uZewfb4RO2S/ArnXXg9Yn4kv0fAErZPST9JD/ITXCbxeANI/cjvu+cYRvvYxv3t1z9lPvYhZX+GS + wbuQnu3wbQbZsw585SmeXEr1Kj54kqpnsZkTccaipuFpZ4w9X8IBj3VCgpecjg8sbOKY4al9+xyQU84S + b5k1H/kqZM9rcx02Zmtce+tYc046YhTkt6/c5tNODXGuOJ0rrmnyUhKT+HEGvySxzhEW2mcojvjCTNAH + nCFPxMIvnDFg8HtmYpFHfctXIFVTvbw3MB4/x2lDZLOOdOZC3+IGUt/CzvoU76s51HuViqd2uzHVLTzz + 3r7J727mDbDVVW31lj0keNLilw2/8sgNfN9A7rXXA1beQNoJmzbFT3ZpiU7oPon9wtB4iuyFu+KSukgY + 3vURQ58zxyXxI66ZgJPvPcOmf1VD+7nCyjbttYZNLVuxkoUbftQs32yvU5zkB961BiaJmOTwVad9SfdS + 7JRD6RyLHdy1dmqr8ajPQmrWMZts8wcvRLFFJ4e5sS8XYeJ7vcIXu+u4bfFDqqds84ed+RObdQ0rnPYi + OcOo2/6oYzXUQ/Mrrhpl01eeY7f5IfE5u/fFfB07zwyNWOckljYeH+Xc5BXI46ZZPX1W9YNuP23OXpqc + tnvGiTGf/k3m5w2k95Cf4nvSHoWt9oKt9fYN5F57PWDVt7B5IuLkpD1O1nNMF6I6wQsH5jnqcarzMlHd + 6gV/zkM7uIOvftezS5KnPOMIX3O6bvPXGsDRt/nh9yyTx3xJxLwe8e7JOuKTi35teyz06GOcxNOHdtsx + 5QZW9Rmbuc0Tx3MKP+RR38hW/5o7fM457IgZ7ljXuLAzB1r2yF38sCWdz2MWQmwIe4aN+u6ztnHEk71K + 5YtveWFrHvE0r9dEHHsQXlj4rOm++OIWZrxbvAIZtTALelX96J09n8DCdm3ic7Yd897mBkyzjNmqX+M+ + b2L0S4g5f/DMjto3nZ893YYPrHDN5MLZksO486X3DeReez1g9d/C1onqtk5aaOeVEO/czpF4rH3xIFWP + 0nHwU9inbOuDHMnsITv7qEbmnu3KSYy9lXPB8djgLzmnOH2v1fOTQ6xqyI/Y4Ng85KK2tPVJjDlmr37X + 6ZrVK/Gu57r4gdFH/c7x+of/Pp+Kd105p2aJWTXPFU6tHNjYU/oU93uvtCO2SnBprxz3va8LZiCPfdET + vYWLJy7syS2MIrz59JML6ThtxrIG/cJMd03YxU+ctklwb3MDyfom6pf7G3j7yKMfMxEftknOe5NXIOdb + wOvsFaP2OZWjPOGrqKbylXOL+eNVY9RdZ2P/6CW/Zp37KWyJi6M6+wZyr70esPSnDP0Ez5OVfp3swhnD + yWyY4R73E75iwsm55BreOa0d97jqJmZ1IRZfOFd26kNmDcz4032r43WXWOctMdotmNv5iR266lcv4pLA + zVc8c0yX7TVYU/HipNZMnadcSPPa9jh6/Kt33/zXfDrebWkezeuzJ85Y4wt22IVRsCfDLLdFe1/9Ppao + 1fnneuK2bjHuUkMc4cXNGOsxJkls5BtP3MRMK58+8jQrcOVWrcucxm9xQ+O1NYNmW+cqW77NBs3jYtK1 + bngD6X2zB3xJzZF2z6B5iktOaccXLOe/xZdoxvw4xj0j+7F/zVp84bTXGEV5+wZyr70esOIGMk9CO1n7 + ZMfFSNInLU5mcfxkdm5q40GQO4T5KfIPrXzZmbsK42EXn3j6ZTcvNQV1ndd9vJ9qe1ycKz+x6EGtPAh7 + Kk7JHMnIdcGszlU9j3fsjAHnDOFHL/Zxf/JZx2Je40qv9TJm+dJvfPX+b2NrTsza4nNpD9AS+OJ1LuKd + x71WvHm1fwr4T2OZU5jkzId+6/34WEri0cdmnD748Lu+YxDDGfM6aSdH0jWAo44w5SQmHVhyO+a1wr7J + l2jYH/VVG72qP7HQbqc+8oW7jBj1TW4gjxpV33sttuZ2KV7MU/uWrbze+8g55FbzrzP6XGnzeEkwZ88h + HmTmSwLfN5B77fWAlf/Y8CSskzLsCxknfObMCxA4S2ytmTHzTZBzfaEQljjrNR85wpRXtuNpt5961Aen + uewZPvuWrR6Vj1jxJcwb9ZkDvPWowTyJ91pjKY4ZD317JvVw8d6qUzkXvbxeysqRbxpz0J9y97exfW/Y + +zy2mhMzc27u5elccW2fxLsWcjrXeaYpXrNqHVpxcJr7xntv/Xtu8f+KV3bjM6YH9s6R837lsI7XSju1 + YuBJgHdc3Kpp+MSuc4RJNId6QRM/5BY3NNWfNbsfZwjfOWkTd5/5cw+Iq95NbsCOm2bVVp+aj72GEB9x + +YetOuJJip82+t1i/pd9i1wac+GYAuv5FC8pXPz29w3kXns9YNWrFYucTmRiE+8T37kQYMrtOGpIEl8u + EqohvnIVl8RF7iTf/U8v/u3v/1blVw7rV9+0u74w1RZ/5YmjGb2W4rJHHv22HY+ZiGX+xYzERx3Dhp0c + tzsuCV+yxpXv/qgVYrnKV554XiPxyumasu/9bWzMhBnWmco3ncJ47VmSPNMU1azarCHOVW0X9NHxI269 + 5I8cu4FcVxzj+MHluMk8anzzyP0g85eaY16J4ZrF/cpZbOV6rPMucg6+OB6Pc/u567wfaNg2E2doXtvw + D02O8gb30LeYN2qgx+zV2BXe82jOnvXMSZ24+Ye+1fzex3vUDGb7vJIRI1fiufuHxPfa6wFLn4H0k/RK + 8kTlyQ9fJ/PkjROfunh2QXDOzOscx+Om8Cvf/4MXf/o3f/Hixz/5F16iXr7++sO/S/7v/Pl3Thcz1Q1Z + Z6q5Qowrnvbc/opP7fku4kxcGPDML07XEl629fAcj5dvvMmHD1lqqE7xIOLIrhz52euCyxnEvfcrCD5n + zwOdc0vC56zlU1/uxfiKJ4c6OeaPmsKqhnGEJ9Z9lCOevwL5s6zPfv1Xf+EX33v7c3HjqV9kqBk5wzqL + sO6vffbe1pjs0sovnrgXtQ65xbeCvWbZR3/1lK+ZOsZ5LZ582gM7JPTtbiBRU3XRB7O7P7DCnatj23sp + m9zCDn2T+U+fgUQ/2e6XTm7bNRPrON/r7lcg99rrAUtvYa8nZF2IXOwkdjxPaOKZJ52xjhdPcsEHr7lf + +pNvHDeCf8tL0vNW3Hj+4Q+//+I3v/du1vee3XvBc7a+YGnW5BimXGnZJZ73lCZH/NTmd33nz8frsrek + ZlAO8oo/4rAbQw3FA0+RT9255HjOoVHvHPt5b3yeu7x/2jYXZpqSs4d4nnxJ4jgGqNN7dq7j4qa/5A+f + 8eZ1rjiB3eI4xlvfn3n37V85+uRb36f922yFLfHMoR48coGLY/ujr5jwW9xAeo/u08c3tfU8CXPCrryF + L+xWN5BVf9Hqvx6njtE/YsVZajS/8bBDbnMD+dusiWOSOuvbfOUj1jPQP9mTrzr7BnKvvR6w6ks0dXLi + BNVFpmOtZa+cslecFw/Vz7hxhHksbvL+6Ucf8lJ0+/Wj//PjF7/759998W++8RvoWzNwHptp7qk5yauc + Kdpb1jG780PkM84eIycwSeDsVzz6juVcFgc2669zNAbxXPRof+QpVjb6pHaMHOW2DfyNr735TT4l77Ki + r2ZZJffJfTUPep3bxbGqY/ZT+fAVOzD2Vk7Fox5rej3nf1w34vEPdHye8jPH43T0ybe+o2fNsMzhfmLl + 9z7KNq5qRQyC2C1uaLxf2tave3rvuTfneZ2rnFvdQF7Wz2PVswmTnyJ/zHldo/3OuclfoqkbyDmL5IRT + Y78hMSt5EaOc5z7+A/rVfQO51153X+vP+OjkrBM1dfsVv5DkhRzcJ7HQFh9y4L/0u/8h33a+5/r2X/1x + 3kjGDDUvbey55+tjgmPRPuLiVS3lhC0sddetuOrQrpjq0g8OZMau+CmqKzx99EQ920ti5FFWbtaxHp5b + wp6qJdtrj7rH85BPybusnMP2UbMJK5z7jZjkxCGPce2x9wf/UlT70HkcShrrPosdHJPA7vVKbnye8pgl + X53EvBcz006/ZgRetkvypy/7FjdkUUez1Yzqs2DaV3HkG37iGPcmP4Nz7Fl91FczSEZ/8zNnxWkLr2N9 + wb/JDXC8hX3UGrVNz/6cj/HwK264Ys2BvV+B3GuvB6zTZyD9ZKbvscIpyc2c9v3E10mumhGreNVGjfic + 41//77/j5ee+60c/iVckv8O9YB7N6POmTV142nbMQorTtZTr9siLmGHnfBxbaHHOcdVI2wS5iCcm7WKY + ejwl3Qvc4ld/ziZRzsKX5lPyLkuzqbdm1F5k99y2P/dHXuO+T+Wc8gIbuZOvGsVNDPFzXcg9PwrQ//ns + /azzaQ/hT57pPAYdS212xG51A4me7MXa0C3et3mWy3hp2cW5zQ2YfogbNX1OYe2vAu6K96xpuxSO2je5 + gTxqVG3Ogx5XGOeOGDm+t8bOdsi+gdxrrwes9W9hzxMUfuiMu6YtXmGSpZbnO1/5n//Wl/Jt5Uev+OJN + zFIXp5hbs3PWwohjD8YPTbuOn8cSd/vpi2RyDLvKFWfWt8dN+CGo7/6RzzhiPUuJ5Ut8huHL9pzDrnky + zh7Eoe97A6k5er6e1+3yNWthsDW/S/PFnX5J8XFspu5jJC5iM8/rhP2yb2HfevVPgPUcmJsYZ6oZiY99 + SGcucWrVCH2LG5qsx/rqe5rTZJ1Hc3q8ebP2rW7Aoq56+wyaW31XPWzyNO8agw9R7GavoLJe9WY/9ZTt + kvjKyz20yE/eIfsGcq+9HrDqBjJPzDjRjwtLnpzLhWjBBv8pTpzcrinK0wXgl77xGzf7osytVnzje87a + ex0Se+P+6oJGXXvMGI6P53nd4Em8nteYuYgJc1vx0oqzZ9YPET/jzWv70OSWTRw86ykR1/wZY45sxQ/N + p+RdFvr3DNqf66diPX9zhDXe8eREnFJ54ScfHIjFzA5ctRWb/cC77yuQ/Xf0Mfvch+brObW/w6cOTLF1 + Xy43+xa2aqo3+1XMZhoc2u5XvLiHzlq3vIGcvXDMZNs87OvzNA6O55x4Fg/81jfAqp31Rz+bIeY5zQQp + 3OPkR3zfQO611wPW+B1IOzl10uskvY43L7RO5soLjKILh3PF+ct/+ICXnFdrxTe24zOZYw/LHte9+j4V + L87CKzww6qpNTH6Lc9UDovyqR/EaGVNcNsXj04agFmcwXzz1Uk71CL3kjjxy+JS8y6o9HFKzcM6ayWOK + O04/amFvc0/yFSsO+5RfHM8R51zL+XOGx7yFXXPWLL0vYU+Kx2Vf6Fvc0Hz5v30jPyajfjhm63HvubWn + 1uLAluScFHFu+RlIn2toxrx/iOYtCT9zFtxiK+8WxxtvwWNWiXr1Prqn+ksK02yZR98kau0byL32esCq + n/HxE/SQ0BBcqKSTF0Ku42GPE1zxwIirvuz4jcZXecVnMvMmkvvBntzWhVAae5OUb5yUwtou3yRzqhZt + 5whPLnzhriMWPHFgo55i4J17rHHZJVVDcWCDH37yLLc4wPmUvMtSX83oe9B82kftgX7PDVzzVy5znCMb + umuAKx5jFld+i+VXrvHu/gqk5oS+mn3uo2OYn5zaC+zhH/oWNzRa8VGZH/z9D/NXGH7zj94d/0lMqflt + nsXXPhRDHPsL+ThuILNn+OppvZ0X9jpf+QPrvZVPfYvjnfOznveSv86Y+pDkKjZwt3WsUWt/C3uvvR6w + 9OPBcaKmtpNTJ+s4kZMHEeZ2c3gRWPPlHzpeDXgd1v/88G/7JvIQP14n2/anmETHFMdv8usYul0x8JBj + mHgS8ktf4Og9a0q7zFiLambsKVu5xML3ePUvDD6fkndZNVNom6/EscWu2Zlb+yFPxwk4eYZ5rsRzxF+P + EXjdZ82L2H1vIPvv6F/NPHzjeGzlu9SeDn3LG8ir9Y///GH++kN8dCV6nebS7NrHIZotH4P0wbnVvPkz + OFmPx1i2Y5zDMY+lXOT1zMLBU+yWN5CnOehHn7V/+D6bbPHXGqq/X4Hca68HrPFD4ofoJNWJWSfrgg// + kMgbJ3jYF/VUM+RP/+Z/8FLz6q98JfIb/+G0R+2l99ZxCPft2qSOD49L216jpXKtVtVIm7yLuPK9Dvoc + dvA5g9ebdXq+0pVjMcniizf7Nc6n5F0W9uMzcCbOo/mEia95mzs5wM7HVzmKDfzQiok3alqectvWMUX8 + nm9h4z+fNk/O2XONPRHzPUt7nvadvvZ96I/7BvJqxTn/vR9+P/+Ywb/jF+swP+aSn3NThN9i3vxb0qyZ + x4XSvSF+vHyW5sI/685dYze7AdZMy2zqDXti8pWT+GKHhsDeN5B77fWANd7CpuRJutrBsRN3nNCMeywv + AtIU597iQ/H3Xno7u/bBvZR9iB8D+K0lIyfsQ+o4VZ4ukC3CnQPNfNZSXLGX+WUfumagqD7s6ZdYXnGi + pvWonsTEG/zD5lPyLgu9e6bQmGnO75wRIyZO8srvPV3lVx/yvZbiZ/45VrWFh37QK5Da/+k4UE/80DZz + CjHZnQv/ETeQVys+rx0fu/mP3/tqfZ6y9hGzcg83uQGLG0irezrGien443j5DIUZD/nAV8zlNj8kri/R + sE/OoX6twWmsZgub8wkTd+XsG8i99nrAqn8E8oTUiUmbJ/2KyS7MZNRi/hXnex98n5eZ12vFt8V1TEpy + j32h1N7la8/QnRd25Qlf+OmzlvPSLi5EfuVRV8/A0rd+LoyN+AV/9p5cxzxWORTN5LPxKXmXpblqJvdl + H6K5Q9dxliQOLY5wj3du65XXfOeqNzniMS7dvPv9kHis/BINZzrNE3PazMCXOCV9zg+/ebBfnRvIdf3j + P/+v/nv73/3t+jzlzW4gj1p9DN324914xfJ4EhvH9onYwrnp/JSoG32h1es8h8RjKcknJ234ofdnIPfa + 6wFr/SmOPjFx0k6MFyvaOpHld0w+OcYLib/68jqvuPn1fWmfOgar77yMpW0+48ihXfEl17heF7nel9yV + N+rBVjz0L//+b+WFP/5BjH8YNX/PQa6L8p/wVcNjNZ9x+JS8y4rePkPtS3hiU/vsHTtjkog1b8Yklbcc + C+mK5VzQyks+cdR5xFvYPX/NO+ZyOR+jkHMO6lXssG9xQ3OvFb8le4tflog9a/9xXPx4+LFLzOMjdtiZ + 74/TmgNd9o2Ot8+v+t2n+zsm/rTlM8/rhX3IvoHca68HLH2OaZyUdmKW/QQ2Lz68KFxw+iLw9ouvfP8/ + 8xLz+q4v/8k3eo/ar/l+LHSM6uInPnkQ8iy3tURc8LMGcdkh8dZavAUVF3CXd47jHn9tJ759GjeIf3bc + IP7g+IfuB//wwxc//sm/cGdzoT7mcqmetNd55MNuqRrGk+ZT8i5Ls2sO+drrimFGO84LR5JY5UxO1Qiu + xYYuXmjxWJ++i3JTDs69byDVVxqz90yavfYT3MXXvoULU53Q8fz9tK38DCSPix9PPzY6Pjpmfew6Zwjr + qU5g4hd2xG9xvKOG11S/OQdnpd8Ycnw+z1Mdzb3fwt5rrwcs/wykTtw8eXmCpjxx0uZJLfzQykOsLwDC + 5D/qzxXecsWfPowbtdyX9lf2PA7t9zHpPDtOh46L7m9+7928yQuJVwHj1Qzc6OFmL3S8dXaPNWbnzDnv + sg9hV3utOPFRi7HA+JS8y8q5bb7TvIUfmvMllrZilhOa9rq/8CMHcu6jeqoBPmq4vcYq1+rd/QaSvedM + 2KNm9ViKzYv4GV/9W3wm73Vb+hKKHuPx/LFjU8fP48LIrVzhFlux4N3kBrL+FrbNtGiPha0ZpQdHEvih + m7tfgdxrr4csfwWyTtpxksKOWJ+wxiO3MOLFpy38dfnpnp9lxc3c2GMci9q7HYNxTELD/+Xf+3/zG57x + Tc973RD+vEsz12NL8X2lJAZbWvHkUmP/87goxqfkXVbP5mJ75VzipE3t8499uGZMtRtrTsUsZ9QftSZH + PMQ4Q9iPeAXSBHvqeRrXrJDEcw+Mca++p6pzxG7xu4qv24qbuNz/OC7rMepj2dzJa+7h13FucUz8W70C + udZN0aw2swvmwqw14xqTZo39CuReez1g6R8BnZSydeL6STptw8yXOO7cuGH6JK14Oz737BdDXvjKPyT2 + HhKf/4xjEL8t+Tosza496XHN/VKwN+0TWhz3K1eiGvT5lLzL8tlqX9yLZsO+pu95yO28tU7XtzoS1Tm0 + +86rPqxXXMMrdvihH/EWdvSVaEbsxWalDIyz+z7B0X4au8UNzeu44vOU3/6rP85rRvyN/nmcdPxw3HUc + r45xaWLyUaP5qnebVyB/u2qrd/qcNTHa3lu8NSfsIbaPfQO5114PWPUqAk/EsHUi98neNuKOIxZaJ3bH + DWdu/HnAT9KKv2qBn/bB/krsWOkYxFvS8db367T0+OrxxJ7m82TFcu/L/tdcifDg8yl5l+Xz+TyaBTP3 + rMOv3DO21k2d9Sxu+YmlvWALJzWxoQ+JWMkDvkSj+WIPkp6LPjHXyp35qgeesE/rDeS6xl/R+d67+R/S + Or48Vjpu/Rj0cS7xxyBscoHd8jOQ7M+Z2raZbJY17lr7nHWA7RvIvfZ6wMI/AvMEPp20PMFT6mQ3jHjx + 6Qur/EO/qm/VPmfFt7K199ov9xz+57/9pdd237kfPaaSZX/acz+POjZyiImPnD5ufEreZY3nKftrHui2 + ESeXvjDxipu52JPnely4uKW91pIHnHkhrKF45T7gBnKdc8xIAU/cyct9JQc+sN5XyL6BfHrFtSW+EBc3 + lfFZ0XmcdWztcUlcjwePsx3rwG55A7k+tus8ijlH8dC9B3I4r/P3DeReez1g5SuQcULmyWkXGTthcRLz + RK6YXXhcyJl5qBuv1H1c659+9GHeyOlPkUnirR994/jjvInTF2okOg6v+1v22kc8tnocXRzLffM5UI+7 + PSdWWfl8St5l9Qz9/EzRPmOuRXw/eJzhlz1qnHNGnumu0Txx225uxcwuueMNpH5D1meRAO9jW3budR7z + zA9Zarh/ixuaT9OKj8jE9bDe+uZxd70eZz2Hwr/FZ05xM9s9/HEv3GInP/WZKzx88fYN5F57PWDpFUg/ + UXGi84QNiZOWOnH5FOT6CQ+7Y7A/jn8E4hvKUVe9NBN8XJSkQ+J3DuMm89Y3k/FFmOrFvb/uN4+xci+S + OIa0daz7ce9j7Mdg5Q2JWPHu/wrkmI22ZgpMePJqTmnFcK608NzJGuBKPOYy8OK2Vi/VcDt91kjs7jeQ + PYdm6T21nzNLy06ezU7tohr7BvL5K770962/+uN86zuug3mM+Tik6Lgf9i2+9R6PmT+Pvb76XT7+jIeP + ePuqMXKO2L6B3GuvB6y+gdQJCbtOVp7oJeavJ7Gf5JUfQjxu3G65vvL+H2RdSPToWXof6u+zQMcFLi6q + t1r9KuQn58tCegyxL+ytHlcXO+aOAcdjIlzHf8X5lLzLyhlslpyBGvuAX3HZGfPn3LTFTVFuxqR7z8gh + bxXWyLhqHVL8jPFYyz70ff8STb+FrRnnTOc5UxsP+awhvGqRf/j7BvL2Kz5P+ad/8z/yHZq4YdSfaQ25 + xfGOGnoe+OPqzwPF3e8c+rLNB6bn0PG8/+q+gdxrr7uvegu7TlxcQPxk9RM1cROc6JZT/pkT//u91Yob + NM2rOdXbZ1i1c2V/+b99Iy+mz11xIY56cSN5i3qvwqrjy2PlxxeasUMcq7yIkwMcMYliofmUvMvqOTGP + fJ9ncsBr7pITEnncpzDkyJawTnJ5DELoi6d8xZXn9VZ9/79Ec/S24zXEcM1YtmKe+xJs30DeZ8Wfao23 + vkOeu+IxW5/fIf5cOMf4/DbuwBa+/H0DuddeD1h4FcFOyENw0srWP5T4x0snrNvDt5N65d/q1b64ecza + 7NWzds/QbSsOTLhiIfG/7/iB7ues+Bxm1L7FxfdVWXmM7TFdj3MfV4/7safNGo3LR04In5J3WTlr9p+z + Yn5Jz/pUzOtoj44VjzHHvG7lLjXCX+t0ftcR/75vYetnfDCXz1bz5OzSq5BXe4StmoEhhvNTP7Af30L+ + 0RN/OWmvV2fpM5D5OMZjy8dVj7ke6xEjrsde3JFHu7BD9g3kXns9YOUrkMvJOG1dxE1HjCdy+MLEGTxy + o2b87/a5K74Mo/prj7JNnLPmxEzypZ/7M0O3fpv+0UvHFcdqOY7LMdfxFK/iV49N1SX/8PmUvMu62oP7 + msv33Lz2wbNaT9QbcmDOT7vw5um4qH5LY82F/5jfgeSsNkfb0JqzxPd9iO9V8fJTT17Y/+5bX8p3D+Kd + jdfld1U/TQuvQF49lv64Xz2PZVse7RTyEIO9PwO5114PWHgbyk5QP1EX0Ulbdp68kMTTZi2zdUG4xao/ + H5gzWL/TTLIPPWLXuGOfpFcQn7vieFwdJwhiwksM02OvfPmFsXbgfEreZWlfmrX2kvMAWyXwVcD3Y3PN + 7z7NFWfgnEH8ksXvY2f+oe//FrbthzMGVnsu7CJOUUy1UpPreGGGRy40cuKmJf4TF5/ti3cE9nrc0lvY + 9fjlYyXhY+yP6SL+uCaWj/kV53je7xvIvfa6/8pXEXiCridnn6A4SfNkDrz48FPbSS695jx3xY2d96i+ + 7CW8pHiwfd7TXlWD9iftB88/6vJjVprHCsLH4MIfx5Qiv+uBFzafkndZ6t3zQGPm/odLc9aeTCpHsnBO + tdNmvRU75c4ZfD5hKy/xu76F/fbpLWzNFlgL95yx1m5nfMHG3hQjLn7GGL/y463v+EmafOv7Hz74xHw2 + +XVY8RZ2PR6H6Hmhx0aPr2PAm6vHunis449x+PsGcq+9HrCu3sLWSVlYnfx9EjdOX7aEmOxb/AZk/I/W + a0e/vJhQp82ePovPXfMq7jZFNeMngj7tK49JHKM8djguOmY6rnWsi0c/Y/74XMcV41PyLkv9tS+fSfsY + /qG1F2HK6X31XiqP+Mzr4xhcyIGRL07HnDtnhQ9Jzr1vIGPenKPn094U87j84lCPvEOrVtV0ziLgPdXX + jg3teBcjPkcdb33H5yn3+nhWfYnGHjs8Bv04lS9Z8JbOnzzofQO5114PWOsrkDohh06cF2L6Jca9zoOO + i8lzVrxykD2spotfYGrWMUdfeAJzfuKyrUfc9P74U/5h/fW46Nj0cYTdsb7wt+/HVce9ucL5lLzLip6a + Q/01p8+VErNrj6d9QEuwrzMn7azdXPVSXnObI1+8IZzLa9z9M5A8Hujfs+dMFnNs3U/tV/xRs0W5iqMf + 62Ss6ydHWPjOMTu5h8Rfi4q3vuOdh7/+33/HZ/9ez1n1H34e75TD1jHHY9A2YngMi0cbXHssM97+voHc + a68HLP0Y8DiZD1lPXtm66NbJa7HSJuAeN5DP/MsGcWGf881/PIQr5rpszXpI7UFY+q1lf/kT8nuOH3X5 + MQmdUserj38ds7T9uJNPjvKcq1w+Je+yNJPmdKn5JOKS7zFw8TwSXvErrPClxyHhZ60FP8VUN+Zx+9D3 + /h3Ingez+fxpcy7xxPW9NL9t+F3LMcfTXvt7T2I4fpYTNnmIz7rxN6Z/7bv/6cXv/PfvvPiz/+8vPvX/ + kfwoqz8DiWMq0fO1HpOr54Cw5Okxhq3HyfH9Ley99nrAwgfh/WT0ExQnMeL048TmSVsnsfDCZjzs574C + Ga8OqLbq+hzef/JMJ9/yIoe25pStWMhzf97ndV46PqUpfRx5rISRK2yIajCvBT6fkndZMU/NK7GZNVvh + ml3CPfReLmKHPXBJ1DN/1pl2+slBno7V6qvuYz4DqRk5R9qab8EkR0yY8KEtF5w+HtM/215j2Kw5fcPE + LRt15cdb3/FTQnFTuT/e8tNXvgJZj4E/D2gzpscBsakRO/jiFk+POWL7Fci99nrAwiuQfYL6Sekna/mh + LXayD0GN0J373BvIeAVTvdYZvQ/6Q8QVp3zywPU64Do/5Lmzv85Lx2Iem7ZT6vghdjqmi13YgvMpeZeV + PX0+zhI6MMUdB5++7OS3yG/c6ocQE8dxl+KkDQme5qraxBW77yuQuIGs+akx+zo/Zw0xfuLykydcvmpB + Kt8EsdbOqRyXxLu288OuOvQlwirvsOOnhOLzlPEFv/3W91zxCq6OrY637Dy2shUr7nzMlAtxHH7ofQO5 + 114PWP0qgp+QfSKXv2A6iSWBQ9OOC4TFn3sTFp9HVF/MMC8ywDveGGZBDjnpr/HGUmJ+SnA+ra9C6nil + 8Nj48R0Yj9XktogHn8+jzIHPp+RdVs5ZM/UcPaMEvvZUtvaoPPmUwoyLWgvf8lQ744VNQRyzzRxg9/8Z + n56p9mJ7WGd3rLk6zmfxPSpXGDjQ1Zs2cDtGp5hs4habPjkeU96hRx79uNbFOybxm7W3/pv7r9PSf/p1 + jHEs5+Pix008CeILfqoH3r6B3GuvB6z+axI6WXFSh1ye2IWR4zHDKxb8Q77y/f/My8pHW6rtfaDZm3Op + nzgZP3zPfUrAv+rx9if6s5DxA+/xllz8dl783Em8opIX/zgOOq5m65iP58VTYjmnxyqxfhz5lLzLwnOi + 50k75kq7nwc1t+GQFTv8wqDTNwketPzGUiKHoppVd4kPzPTdv0Rz9Bx7WPwxv4Szao/ak7ie08eBNZOH + Yy5u24dmreEPjtdd+Rcx+pPHuUMOTDMUtkh8nvI3/+jd/FOn+VNCn5LPU9YrkCF5nPAYlG3HTjzhkvWY + yh/4wdufgdxrrwcsvIqgk9kvzH2C58mcGGw/idvmRaC4XuutvDH5qCsuuFUv6ucMXb9kxFb/zMf8MzZ0 + 5AeXdR71G3LRN/7hgfwwf3okber4OZL4XFYc4/hH6ncPgf5u2vGPV7wqEr/LFjpk7C20Se39kHEcFDM9 + xGuu+bT1fEns0MCA8yl5l6WZNNeYX3bF5z4w98SrRghzil854s6Y93c7JewL8X5e9xE3kJpVc4y5idex + Sk1OxjzeonzEEPe64M1YcdLmLOSrVmlxLMc5Q9Z42VOXfcQLSxtzKi/k89/+cv6n9Nt/9V8/sZ+njOtM + Hw/un8fAjxni5NBXbBy3lWfYfgVyr70esNa/Z6uTM7Sf0PIdkyQWtvDMbx3xuMH5qCtulOYc7MkeJ1lm + qBkN8zpTmF81em/3+As18TmquCH8j9/76ovPf+tLY5bSZud8qXsvxXGx3DouqxycPj6rj+Pg/XoGCY8V + ecqVrJh85fEpeZeVc9T8OG6FmQjTjCnOW20T7dVreK8WHFNwOYcLa4unHOV7/J5foqn/fGoOzRCYHQ/5 + vq+aPUQx5dR+aGdcfaA9r/oxz+3iK0YZuEngPteqFYfuGvKV2xz5nQd+4+Lrre8//OGffSLe+sYNZO87 + 9+zHlMct/eRYzPyuQUzHjzWCs28g99rrActfRRgnOU9M1xlz7BDk4KI4/LThhx2vhH3UFTeQXktznPtK + t33mSebcXcNyiot4vLX7cawf/eTH+WphfMsz5znkeraepffTc1aexYEB91z4k3vlj7wrYS3XiqlvYhmf + GGp3Dp+Sd1k+l/qvWM13xNoHF37blT/0jBfG3IpTMq/6tF2c6sNc1TX9iJ/x0bzrTFd7BN5c7S81c4WJ + P0Q4BbW6RuUe3BO+1hAndeOYe9YCrnqOOX/mj14hloOerG+ivNDx1ne8axDvJvzp3/xFXidep6VXIHFs + 1seGe16OkfMucwvreGD7BnKvvR6w6lvYOhnjhF5OavkVJ44TGVheEBQLXTnQz3kLO97iGf1YM4W9ew5d + cBATpnmUM+zkwEcti4eQHzd4t17xD4O+IFRzW0/hsqH7GCin8z3GOlWLcWKyh1aO8inXvRnPXGjlnjgS + cqOOcmTzKXmXNWblDJgXx0gzFoc8ydW+QqtO5a3c4p3x9FPzcWLMa6591xnv+zM+8wYy55AkPu3Vl+0y + agmXfWjUmf2EObd5jTnu3MYh8MFBDfRSLdWFKLbwFbvQsLu3+809/FNP/BWd+Cmh/Cs6//Bq/xUd/SnD + sX/zJdqb+77nsCUd6/zw9w3kXns9YF19EN5PXLdLxKffXMWImf+cG8i4UKoW6sVMbreo34r57JMDLVyx + 3ht96lu+tRSvaF7NWP2r7zrfxbzClX/CrMeCBx/a8pc6medY+chTjeKTU5jZqi+efD4l77LGbD5P4u1f + cQKTrJh48JnjvonyA5e0f+6hOsi1GhZ7zA2k9U9xnzOm35hmThl85QB3W3zVU+7k6vh0rZFDvzmdK0z8 + J+NhqxZt9SnskEuuhD3C9tyyM+625rF9MB4/JfSV9//gxfdesb+is37W+nQMZQfH9uTxymO8YkvOvoHc + a68HrPUt7NJ2sob2k3hyGhdPFwpJ4HEx+agrXoFEbV48QqJnzqEexNM2bs0GGzFyWUPxyiuMXOPd6n/9 + cUNdM2Qv9KteiyB+2OQNvuFuK0e2YlWXduUZjhzgmWv8NS6Oeqx5xaW9cpTHp+RdFvr2/Otsmgk+Y3YM + PC7Muc6ftRBL7Il49Rm45/bcbqd/7y/RaNZDYzbYvreaMTkQ+cLEdV7aJpVbte14KKdqdizjli9/CHPc + T6GPOsjvHpYjruXIXvud+jsv61ov4aaTrz7SGYcfvLjexjUmflnhn/75Q1517rvWz0BqVu1N+xv7yPkb + R77t2zFyw97fwt5rrwes+jFgnog4KXGCugwO9ekiIKkTvWs99wZStX0W9RCeNnunyF61ieYb+MEbeORR + nvNZTq345rR6Q6vnodXP7KdmlK34T+N1LejVh5bd/lMzZCw1uOqVvMwxXsQonic/bD4l77K0F82GGVoi + dp5RXMuV2D46Zx4z4SnOLdtreZ3OlRau2qpx9x8StznWOdMmJttnzX2EzxpP8i7skqihOoeIMzTnEUf+ + Fdd5Jw57nR4P48tOLrGBu9QczetjyTzWUV/P95zisqZs8X759/DWd1y/7vXWt24gMUPP1hjmXDHsB7On + 2D6gpx/x/QrkXns9YOXbUHkS44T0k3I9cduHllSe5ay5z7mBjOU1fY6+mDAWcsRrJosDm77Hq/6FD+zt + Z70Vr4ULq/WveYmlr542wzJPYY6b7fUb8x7QT+WDs/rzGHqs49oL8YXX/d2+858yrP6cgba07yHx2IfN + LlvcxMhLvoTcsovTxymwrGG2+qq24slnHcXcv/vP+Gi2moEzLlK4+LThA3NcmOoWn3bFijvjwqH7eDp/ + reG56DG1agHjY1f11AM1HcvcEMO9rucUd4kVFnZyew7FR13lkCuec+KnhOJjNPF5yvgt2FuvuM5pLvX3 + mdJPmzhjFXf8ENTpep63byD32usBK/4R0MmsE9JPUvl5osbJbbHmT5588UM/9wZyrZm+6qdvuNk1+8CQ + 67b8lbvmxW8qPmfh7fioh561B+lFwOWMZisfcxEPLO1r3HsIr7hqOka87Iw1b9aT9jmmLR92YxI+Je+y + ct6YP/etuVpybsbky3Zfx6BrAGt/qZO2x5vvdV0aC40agTkO+/iH9M6vQNZMIZwrZ+Y+r2as+U/7QJ6w + tCkZI1Z25imXXPPV0/MyN+3mehxY53lcGHCXi5rie94THNWAMGb66RodEya54sCfx8B7hB/Xaf0VnX/6 + 0fPe+tYNpPeFzHnWWRSXf5LYD0U19w3kXns9YNUNJE9OP7ld/KSGAIPoIuAXA4j8595AagbNKt0zSWMG + xfoi4z6kOOl3vRTWcF7Yz93Hl/9bfHEG/WZtzr3MXn7NA946v2KSxCrHdObOY4QcxCRXdTynuEu86ohH + Cdxj6pkYhU/Ju6yei3uk7fNUPPfVPN/v0IcUb4lhr6j1Ml5pcnyeaePxaQF+zxvIN7721js5j+0pxPeg + uOarWRdO5slPPuoEt2pazlqj+aiv+HXuPGbJId+5VUecA1du8kMGl70GDu7IyzrX2mtVPeJeJ/mGTY54 + jaEHeN5L/MExLH4hIq558c5LvPX98/wxhfgWds0R/SjAeCwkC546+GlPjuOSfQO5114PWOMG0k5infR1 + 8lJ0AndcfOYQX+s998ZrzBH1WVszuai/4spBnH7GgZd9oWGz7mE/dx/xMxyaQzWHtr219ByDd8rpvIiJ + I6k9FVf4dd2uN2OzhnKv/cyxmpXvQg6fkndZmim09pbz2jxh1z6GXvgh9J3j0vWm3WLxsMkpm1JcqwEc + /l1vII9e6n2aiX7Z4pSNfSgP9gW3arbvvIw7Rh+Y5IiRI0mO+OQVJl+YhL56eQ7qMjYw9XZBfvKKC0k8 + bfVgDcWqVtcFz+OYxbnCZKtecX9KLIW14xqmt75f9ld04lqpnspVnZ4NtRXzftPuuVYs9P4SzV57PWDp + SzR+cofdJ6fFLF6+xVPHxSHtjoX93BsvXYy8pnqlXNmc1edz2zlpC2c++KxF/zn7+PFP/qVqrbN1T8Yp + azw1pbgXMeSqh9Uhb415rcFnrZDJx3HyXMdce6xrActc4nxK3mX1XJrD9+N7wnwZJze078Vt1ZM98eYm + J+sCe6pu4OKqTvFcxL/rW9hv/XvfV81qM9bsmpH8wQthXDHFa7+SrCnuwltqKGflKF45zHM7Y9KZoxqH + lr/w1z5hg9ucqiE9aqg2bNVxfuGMlV5qlG3cruNy1Qd+c7t/1hrxAzvs+LvX+Cs636/PU66/Awk+fOVV + vRDrebJVRzpwSvj7Fci99nrA8h8DrhPWTkydvMLKNix4nb/UIe/z3/5SXlQ+6vK3Q1bdM6CvpOY4ZpAv + Ee77WTniQbCv59xAxrevqwd7q67bQ3M+5520ZPGva4OnPUmAdb8S5iqW+eJYDAIctZunXK85bNb5V+++ + +a/5tPzYV83H3prdZxv7Kp4dx8QkHVvrlE9MfOesdUOcV3hoszuP+o43kL/43tuf0zzqj1ltL8TOHPjQ + zan8JUfciTXukrmqd+EjZ+kx4oc+/Nbgoz65xMWfnBmvmqk9p2NrXD1SFDd/xno/0skRjxzlFN85iXes + +lm8+Ma7yg0/3voOmfVZd6mB3MbXHHAbS6Gv3H0DuddeD1j5Tco8CftioBO2pS82fcLzYhF4nsj0WcN5 + qvmcFf+7VW2fpft3T8TII3/O1pzilQ9e4qZV69e++9uc6Odf8be0Vat6la1+87jBd3HexDSjS8Y8Tnky + P2PMs/yJ9XF3v3DZjCG3/cbZe8qH8ao43h59+3OffefX/28+VW+61E9zyG68/eLEfhlr/LADt70qFlri + NWSjR+d1vDmqPerTnvWh7/kWdtzwZ/+Yj7r2kbpjNe8T+0AeuJJ1jynssdrOTZt95Y9aii0caOCYB3kd + Q11xTpjlhC1RLHOSO+MlFj/1MJ5m81hq5icv6wBXbNZsXgmxyhEnsYuY1RKescINW3iVbzWEpa0YpTBx + 3T5k30DutdcD1voZSJ2UOjFx8jJOXzYuBhYnV37VYc5z1rf+8o+X2ofOfhL46pV9TZDrcdZizoinDyzz + LSdeCf2o63f++3eqXvVj3epFv2egHzHPY9z5KcRKhDFeXMOA0z70qHvpY97KyfyOua/aJ9ywFHKLQ4w9 + Pjj0N9/46ptfuNU/FN0L/db5sq9p2NhzYWs+Y+53H+d0L/GdJ7s5xrvU5B/6njeQsTRDCmdwjbnnjCGZ + F75xFE9bQo5yxp6lGV/58lG/j+FaQyL8VEOxrKXcflyUg/rNcV7VXOqKo5hys664ptVvxNPvnuJN6X03 + x/zkiCefczlutRsHz3NnHvoo3nW6PuKNVV7aLcknpryQfQO5114PWKcbyJDDrpPVdeJ+MXCZWNUIYf5z + VvykRHxwO94Kj3rdg7NT0s942x4rPLCIKT5qthSP+jlvYf/On38HPdhXdvahXz0p60yVZ/HKG7UQLzkw + 8eWLC3ut2THhiqUtXJxD1BP5kxcxxya3Oc6Vf85J//3Dfucz7775Kx/lre+qi1rVDxpzztmAi6Nc4apT + mjVXrHwXYqP2gXGfxKcNYX3mh773DeTRNx6HnoGzQfcxE6f8tCfXOW1Dd64db8Usb/aa+c3BcUO8/cgb + /LAX3+tLj75LLLRi6tV9yav4obMe4srxHi1LnehFAcZjFFjx5r4Vz3yT4TM/tdniFJdx1V11xai9R9fq + uGITt9hSZ99A7rXXAxZ+yw0nKE7WPnETW05U2DiJhSsfduPKV+yWK779Fzdk8dcV8M1mzFc95R/y8pk5 + q4lm7xz5z7+B1HzqXxI9TLq35oQ98KG7jrhr/eQoFvYpzvoL7lJx2YVLEC+beHPseCev97T2KzztiXte + 13uz3/r++q/+Ap/ilwv8zu3ZbB7iPpfHhPtsqtl1VbNjjldexQ2/6rv2DN/knp+BjHX0/GL21owxA2dd + Zwzf91Hx8nvvsBFLHTVMe63iiuMSWOWceVXnwBDnfJLEIe2D5/zUUVe1XWcOfcOKQ6nZhNNGn8bUEzm0 + iytcYvNFzHhP1Vyx1haneF7aUT9tcq58SvAl8BtTHnK7h/CsZ3X2DeReez1g6c+R1QnKE3M9aeuEPbSf + vMJGnrTlhHycf0IrvuH8Z//fX+Sf6oq3mfMD3Owds/TFybHeI+KQq7iw+LbhR114BZL1YjZKYtQjTt9F + mOYRV7bmXmPlL/zJgX2Vh/6HvcQ95vOJWzUXO2tQCjfMRX3EUZ+Rc9iYoWc6sA/eePfNb8ZNVfzMh3+e + UvN5jVFXuOxDNKfPq56BqeaVDe320l/a5FSPOvzBCTt59/1LNLHiZj3nsb303D2bYi7Yl/tLXsjqJw+4 + x0JDGp88iXiIhxbH67QPQQ3Gwncu465Vw+Pie6xmUC7zVUNcj2ueEuNWbNGJG1Y9zVYN4cBovyQP9Q+b + fSbeIl/5qBGi4+A491I+ba9x2OLuG8i99nrA0pdo6oSk4ITWid0XFvmVY77H8iS3eoHFt5DvueLnJOKL + K/EFnPizXevcmitnNT90cjl72Ufs+W9hd03Vbc3+hyB+5p6EXM8LPHIhM2/tIRsx+ENXreaqtjhVkzUk + zpfdWMdLOGPJGqNducZDT8MKP/Hfjx/AFnedw33UfCLOHumX3ZxVkqO85NDOPKvJfI9BZmxox+98Axk3 + 5TrGkN6HdMeJux+c3AdtxlYtu7iLCKsYawGz/AsfNed8wtUPcuSoP3MGf3AQO9UMibqH9vxRS/nBI7fs + jCHuM4mnOohbTUnmMzbypInT9vmV1/1njZNtWHKdQ0z4qR7jiB2+cs1WPOx9A7nXXg9YeQPJE3Y9MfPE + VWyROnmTd7ZDQ9r+wd/f54/4v2zFDN/+q/+an6f0t75PFynpjPWF7tlvYbMedPetHqPvqvuY4jEApscj + bfKLR3FfPHFHPvuLg1ota07WcXvhKN44e1gssClr/DoPMfAznnrGkitJjBz6KfIpqAlxP+Osqz6JO+Z8 + 1lfsFDdMOPjIE55CvPji0Q4d+fd+BTJWvMqbM/jM5mtO7Uv7l1QO4+DimBVGET5yEwdWddJnnrALXtrE + S9OuPBfiK6/msTxg4FR8+Gce/HMcOfALkx95rFm6eC3KEy8l8MyhnRzGiHdd4zEuvvdOe+EMWfErziHq + V/UML5+5+wZyr70esHQD6Sdl2jwxcUHok/h8MtvFQjrr4UICARZ/ueBVWz/6yY/zrfV46zveno63vjVz + 7o370V6fcwMZPbxm2llXssRMlxw86Tyu9IMncW7jzcsc+mVfSNVK+yru9dmD2FM8+TPefHFrDzlzYxUj + VrUUS9xiVaP7t89cijjCix/COs3tGuqT/NTtS051QlZM9qG7luWOeHPES+wBN5CfefftX9F82rvmHBht + zNqzh4iz7rf2ZfzkugROTvHS7/zBT3za6TOvdOKopzi4nHHwzvHqnThzFLfctOmLXzbF89d45RAXVv2f + EMR7xsZbzr1672l734sa4DVW/IUruzE/Xp2rnjU3Zd9A7rXXA1b8kDhO0Hmxk6+YTmToPrlTdGJnTJyJ + hR0/Y/M6rH/85//14k//5i/yre+4Yax9HvL8G0gcLxwXXAwlfbz8sZDfWOWGLyFemrZyw1ct2cm1vIw5 + RkHeYo+8qT0XOOp2757J+eqRGKUwE69zjtG+qps2j+Pwu0756k1dHNYVR3kS5UMm7vG2j3j2WG3yvIfs + 0LQ1W+U+4AYy3sZ+42tvfujz16w138Xxkh/axbHDvsylqOfALa960xdnxT0mbNhHzbE/4m137uQCU40S + YRVvTuHkVoza85y35o465CLfsMpbBTzo7u05wKAlxbe4++jVddb8kJVfWGoX9ArZN5B77fWAhZ/xwYk6 + TuY4cSWG6USW7Seyc4XDBi9uoF7XFZ+njLe+4/coP+r63T//bh8jah2j9mHrmEn82KZtvvOUV7XK9sfq + wNhDddIubsc6x7nCpu0zncRjS8/KT3vGJOqDmRizmlexc425D2CQwkKbjRzZ5EqTNzDhzHU7fcXFtRzn + O37JP0QztH7MW9ix4nOlORfnxX5bKwYMuO9Be5J9nXvO8VpXfgpzR73Cp991xW9RHcRpk68ccc6CnMkX + d2KyV9+5Ybt2KUy9cqaOu3Sdlhlvndzan8VtT9XLeYoTc744iRendceBieO54e8byL32esDyL9Ho5Hat + k7jw5cR16bg4nR/ynFfvPgmrfsaHx07HBTZwHC/EkhdSXPqKM2/ipqNXCH3v13j7s6YeO8U6R9zKJX+N + p2/cxCJuMupKKq/9nkMzYr6RR05o8STqrZyztv2GsI4Esa4hG37b6AVM9UKUJ105F/Mpt+LExS0/tfJw + fB91Axk/m6RZTvMe4nM67rM75ynf9x12+9Ddb9XoqzqFZS4x1aBUTQnrqabXTVnwUdfw8H0u9clYYk/x + up7bkuYQ81plT8zzZw3GvcbCVazzyGNdxRQv7JSnXPnT1hzOl6+a+wZyr70esPJnfHgSuvaTUyds2RFL + v0925/fJPvmf9hvIeAVSxwzHZ72oytdx5bGjeLxwPi6yJclh7DKPcoVJukY/zrCBF5d9ZCNXunsnVnH2 + Zf20i9cxYNCyxWmbcdaanK6NuERzAS8OxXHlVLzwrn/qJVlqOyftiItz6CdrMKa42/Ahj7qBjFXfbl/k + 6tiVXXuT4JhkTmoeo/I7tsZPOWmT69okuM7J3NRtN09CftZvvucr3jzp2U8x5Xst5Q4s7Z5LNaVHrmnF + PNdrdj6k8p8Si1/Ne8o/fPVetcR7V4w1s8dag7GQfQO5114PWLqBxEkJ/bRvJ29h8OuEJq5Y2sTjCyqf + 5hVfIqrjooufjpELcT+2ngO8OcDEw+MgrZrp0y5hvGs0Tz1Us/En6kiuYrRVU1zvp3jlMN6xnmHFVhwx + F80O0UzIlT441lM8cSp2MVdp8kOLN+JXOalhP8WFoKb3F+a5j7yBHK9CXsyqmM/bMYh8xVTHcXCtT+Hn + +uJmrtXx/LTZRz3cnvVoV6224SO347Bbdz5sxDJOKZt15IPXueJLVLvFeFHLuF5DfNjNLdtykyfskFN9 + 47pfPVafHM0qjsdSV3zmi7dvIPfa6wELX6LBibmelH7SrrhiaeskHyd728ID2wt/RSduJn/zj9598cu/ + Fz8lhOOo44wLKGwdR+FlD41jPHD5nhP2lVzlEyvt3IWjGdu3Xslt3cK9KZ/czuka4NpMxKBpRyxtctxP + DQ5qAXesY13X63Qvw0MXjrziW1y4+lxxvK94bsNfjkNhsNN/4A1krGMu/GUa7SlntPkWrX0MucKEj7rn + +sWTtlrByxxifuzGPIc4T1zgEjwWbitf+MxfeIUBV65iiDc3ZZ1n0RDFhSFP+ion8eQIlyy8wxZPnI4b + T/2MUxi1bMXKViw16gpHrtWXf9j7BnKvvR6w4gZSJ69O7NOJWxgvIum36IT2eNbkCa56oeNvWu8114/+ + z49f/NnfxF/R+W79FZ08ljyGfsx1bBV3TL6wioWIa5zqQR/6+jEOXDHYwMXtnOZ0beZm78aHMFZxF9YA + B74wr5e2xYWXPkT5xc2ac2/CS1Y8tMTzV/7Czd6OMbdiqdnHbdZdOXUsrM4jX4GMpW9k91yYrWZN3+35 + GDpHsZaFX/Wb7zVWjrCuRU7as66k6tJW7cLDD65ilYN41bV4aNVaa6TvvdLGvOmTo/oj74S1jxzlQZwX + +mVSOQOzvWUPYfCLG7aEHPdDq45qOObcmsGw0PsGcq+9HrDwt7DtxKWdJyYl/eMkFaf5kyeu42XzZL/3 + X6N5XVf8lNAf/vDPXnzl+//5xa9997fr+PXx54VawseneR0DV48tLs7OUZ5izrkUcQ47cjsP8dbNqXqu + aQfPczrPdHGnX+K+cQszXHbF11qGY55ZC1jvTfOc+imW+vBZb8bbhi8+eZpNufSrr8cCe/ANZCz/84aa + WX7OG3P+DP56DMKXyJ98yIip9yJrjdAQ42XuER9zsb9i5CHWmHhZL+Kq8RLtvas2Y66rron3rVrBt1yP + tVgtcc2uGO30I6Z6w6edPPRSbvEUk5958DGL5TGOGCRx2eIdsm8g99rrAQs3kDhp/UQunbidsMZzTvrk + yi4hL+Tbr+CPib8uK26+463vL9df0dHjg2ML6WOO4z4fo3p8JJkP3XzhXVfcJ+tQqhfzhYk/8pIj3Hq4 + LyEuQc3u5bjXkC/71M/FeI6nXzXBk58i2/FDX9WJfD8GK0f54Lo0BzWAo4/lvAI3kLGOub5Y+xl7gp+z + E+s9uWjf2KPnK0eyYp5T2mPUa85TeVFfduDDP+SqVuYnFzZmhHjuSdi3uKyjePUaNZd+yqNWjqTrIF+5 + 3UN6citWNTtHAlx58MUvHnt5LcWUr1zZymsctmrF37rnU2+vvfa616q3sO1ETs0Ts7RwYn6CK17CemHr + RM+T/ZB4m3av26wf/+Rf8q/oxM8Dxecp/803fuPy8dKxx+Nmj9fyOLXdeS2dl7ZqpW6Zfj8/MkZpbMbl + TxvxMZt6G885qSXhJ69FPnTnp2aecx1zv3KEe4zx0F4fdaGBTX8VxGaPwqw27ENekRvIWMc876/70uyJ + a+ayey/DT86FHTxiHZMcnKpjmMVCZ+8Qcj0uv2zDVKvisul7P0n3hT1ngojXeOeM3omRVzg5FNUTVxzZ + xSl+93WsNHOVU/zgWr3qEThjmSMtfvrNk426xhePtnNTDmy/ArnXXg9Y69/C1skLbRcIi9eJnH7bwVGu + /DX2af8pn497xWdM4/OUX3kff0VnfXxCC8Pja3FJ8PTY5eOm5wSxK+HjCy6fN8RDp6+axj9pStdCbOVJ + Jrf7KjbrdT6wnqni0kvP5nEm8mR7rLDM53GwuNfrup1Xc4lD7OW1ib1CN5Dxechjpg+0H83vfujTfgZm + OdTOyxrGaZ7VoS2u82Gz3iLgIL7WHjns4/Xh4zFzrGOskXNBeyx9w4btkvnMoSjf63Sv5hW+2GOeJXft + E7GrPlVn0TOfx5T8lOqjHNqs77nN33+JZq+9HrLqh8R5csbJ6CfteqKmLVnipV3I1UXml3/v/823YeOV + s73us+Kv6Hzvg++/+NKffOPFv/vWl+px0WMse17c+ZiF8LEEx54DxMWftbpe5TAucVz53nP0l+1+cjgT + +RDUVU3YnIc8xVdOxVP7fG27FC4pvO0Rp/QM8ziNPha/5IQs/R79JZp1/at33/zX/qWaoWnnfqQLsxi5 + OgaZHyK74jw2zJu2OM3vnDPmdYVJ4B94cJb6inmNzu1456ke9JWccok5p2dpvvpc5o3ZJj64xpPtoh6z + V/dX3dZtN9djwFMuZkk/+iy99g3kXns9YOlnfOqkpeBkxklb+GKDQ1wx2Rnvi5O46iX9+eOGJm5s4gbn + rz/8O97y7PVxr/gpoXzr+3vv9ucpj8ejxB/TQ/yxk19avHrcp4DHXMaFgTN7K14y6h7c8NOGf43J7/jK + E9ZxxMRxEb/zjxxiXmtwTa/86ps2cxh37EqSQ8kalXPUfMVuIGPlTeR7x02k5tas3L8k9xYi3iHg9T6l + L/myGVNe5UecuOwS1s6Y1VOdqp8+ZzBB7pztKq94jCnHseFf5RW+avEu4kvdq3oukeP1Vi6ww666My95 + 7Jd+8Cw2tOU7r/IY7xzjUvZnIPfa6wGrv4WNkxMnq07q1hKdsDrJy09ec7MWRX6e+MwFv3HlhcRbr/FZ + yT/9m7/IbyPv9fGvf/znD4/j/T+O4/6dPP6/9I3fqMdlPlbwrx9HxgJnTLZzUHfy6rnBHPBQz3Mv+e4n + r6VrGe8U616Ohe2ims5VzYFRvAZqgosc6+E1wqckt+wZK7GewX/VXoHUyrez8zOR2Edqzj6Pi7DmScJf + c5xfnAvxfNnKUQ31L9+k+0wN+6jHul5b8ZSY22T0tXhghQeWftdSj8KcU3UnR7G1hvKHP7DQ7SvXawFz + 2+KZt8RSd7x5Hasaq1S8eZL9CuReez1g1WcgjxNy6EP6pMYJjZO1cfHLT7u1bMerh/nidh/EVDd+F/E3 + v/fVvKmMbyLHl0f2+vhXvPW9PiaS9OOxpOix0uPoj2fmqAY1OBDPH6LcQ6qeYvSrRvkdP0nUY03PgRZu + XNkvwcs/dPU3juoXt3g9t7DKI095VTN5xI2jeNR4VW8gY/Em8p3eSz8GsQeJ9nXFc35yBm55wpmP2u0r + 13uI57mTQ1tx8wdWPu3KAUe1ZbcvXmNrrcRNe0w1kE+MeNmHZMz6yz7z2KPqKgeYxzqn/cqnLT81ezb3 + 0Kzpec3rWZ0jbN9A7rXXA1Z+C7tOVJ2cLfMkJlYnsfnEVtEJXid/2ks8dfud0/ES1vr8t7+cb31/6y// + OG909vp4lh4Tf2z0mM/HjH48xm4bz2td5+NxF7f4VdP6K3Zpt+/4WvvkX2Gn3i6Iez/PQezAwxd2xU2e + 9HVd4Ky15pm8im9hr+sz7775K/W5yJjZ9qX9+j51HCrmcY/peFjM65S2+Ilv4j1hHzi5mim5B6b+sMkj + V1o50B3rHsQtz3kS9fI86J7HeV0L+6mayskYOMVnbORYLXEml3UKa199lKt64HQP+Z1v/UNUg7nQ+xXI + vfZ6yOo/ZWgn6SHhu62Yn8iX/Dq5ecGwWPDbbkx5a0x4aXIg5Cl+SLz1+pXv/0F+njLekt3r+asfkz7e + V8ceHD02fL7w8ep48/qx9PwZX23kNK58ceQX37jKX/2uB50c46E+415XvEPUX3WqPm3luq1YadWJ+IJ1 + /uQUT/7BeZVfgfT12a//+i985mtvftP3gf1BgPW+hm9Sx6dsHI8rbBxDHtusTdtjjTE3Y8C9vuoKKzzz + aZePWsLdr76MpTBHMa8t/1zTOO6bIG9yuw7nkHg89ZpH+4T73LDTZxz8wIyrfMdGPuPMd+6+gdxrrwcs + fQvbT1C/KCiGE7nF48WhFt9P/kt+cTy/496rakQO9ahruLB46xufp/xOvvUdfzJwr59vrcd3PPaG9eP3 + 9IV+SMQ8fthrLnzJyjXfxHO8hmLNQQ3xMl/acOUURhv+oZmDmoxbnY6533hp9mohr/CZL15i6hfc1+QG + Uiv+4Y/PYffe+hhg78D8+Mxj4HnAlaeaKcwXN3zhVxyPobblKCYR5lxyfCbnDh45zkUcuuuAL6x5wruW + 6r4Md6kYZ6y61VtY55RwDseU63ZxiJcmx+PyE0t/cqHF3W9h77XXQ1b9jA/FT0qdvHXS0k6RHZp8xVRD + cb8QVNz0ykWs9VqveMSKwzj867z4xnF88zj+Ik58E3mvly8cTx1XiY5vSx5jCY/5zBO3ecorzHp5v1HP + seTgedAxn6tx1ZCo98QaT205FRMWmnbnmD9yEXdJLmuUTR181Si78qbveOjX5RXIdcW3aN+Iz0fGfnhc + 6pgYhv0vOG0dRx0LP05pZ0yC4yg8eYynzzrOVR3h8JkbwjzlQiuHMfqyyy+e7I4NftUw/xBxhjb+KSd9 + 1jW/8ig9f9erOoxJiyuOsNUXR/UQ77zyxQ1MXNrJE3bI/hb2Xns9YMUNZJ/YOGElfbLq5CbOk1bxVcbJ + nf5L8lctm6ILimLys076rCceY8JlQ875IfFTQvHWd/zt6f+5P085lo6RH1thfSzl+zE3jLYEjwO4no9X + o97692/kW5tvfug1JFlDOcwXp+3WlbP4qEef9ZSnuoo7R7mql3xi7qewjnOgLca6XnvUyTjyPEd1Wrif + 1/QGUuuzX//VeGv7C8ce66/Y+DHJY8Fj5scEHMV4LC7yKicx2pnDmIlqpO859K9yJOjN3AVTX+UPnvVJ + vHxwXBfn0OLJnjxy0ieXHM9fbRfVUrxqSQoLvsVU13TluGQctmZEHetZWHOUv28g99rrAUvfwtbJ6id5 + nqQXuEudyKzxMv7ALmIZNyyFdVvOFyivJU7nWc3EFJu93O+3vr+bf9Xl0/xTQn6c4xjp+PVxa3v44mSe + ix3/pSafkrXic3K/+N7bnztiX8y3OS0Pvew5s2DrHNWbdsaIye+41Q1ZamQssEPKFpecihleYjGvBRwc + r5uYOBZ3XPVe11cgr1beTOYXbt5659jr+7n33Os8DoWdjk8/Vu0rTm7keM3ycTyFRbw4spXHHIm41V+c + 0C7KWTDPK9u4mmPVyIWWL8w5iquu9yq/8hBTXJg4qqlYYsQHjxzHFavZLmIVX3jDP+z9FvZeez1g9Wcg + dVLGyTttP1Ebx8XAc50D3Dl9UXgKdyzt5Aqb/Jpp4Be56kfdNnPdPqTrtB2cX/6938q/Nx0/vv2Dv//0 + /BWdPF48NnUszfdjVjgxxZWnY4o48JLD51PypSt+lPoz7779Kwc/3u7ETQXreQ9o2M25sH2GQ3KujLct + X3OK530qZqJ88Hg8JBY/+bR9RtmqUzFygX2ybiDXFT8DFDcKscd4lVrf5NZxi2MyjlPgy7HSsR5imNdY + /VEnhMe87SV+SOUbV49XCXmrDp7nzzgk7JSsP2dtUe7kliY/e1DUO/3KATbwxMg17XFJ9s86zVE9iPzG + vW/XYSxtYPsGcq+9HrD0Mz46ufuEbWl8PfEPm5Kx4BmmPPdR07jiULrvcpHIGPNodxy67OCY7byu1Xqt + D8xz1jrgz7+i88l863scI8o8TozRD5280GY3t48rNDmH8Cn5cy+/qTh6faCe1V/ivs0Wonlc1pnFq5nd + tzriT5s5xJNf/tlWrvKdL17XFvewP8E3kFcrXqWMV6lj3+Pz3Hw8dHwKW+J17NNeHi/Pr7iwzqs6xe+4 + 1/OcS/wJH9rmGr4e+2V2E9REbMgyt+ZyrnKvaip/xKMW642erK2YeOKoTuOT53WaDz/0voHca68HLPwl + mj5xr09Wi6fPOGX4Byf4Z87FxUH4KY78EQs+47LXvifuGncht3sBU7xjmKvmYawx+tT5U0Lv/8En5q3v + PB48Lr5/2X0cjbPwnZcxs3UMw+ZT8tkrf7CaNxXxH6T6zUHOoZl8VviIB679KN7z9h6uajhn5UqrDzjS + B5f1IIYvOm3Vs1jIJ/kVyJ914VXqN/NV6uPY1FvfOkZ+/OHr2C4cPVbKNV2PgbBDrvJPccPChzz9eHt+ + 2IUrlhjk/2fvf3pty44qUfwrvI9A+yUW7yO8DtWmya/nJvTogW5eCaSiaPxoZMPuVUmJ5MxEwpaykMDu + YCGMeHol2U6pEDZ0MvUsFwgKvawGBuHOfStijBExYq51rtM+N/c+93pOKRQRI0bEjDn3Wuuss//KH6KY + 4s5N2+eGFjd8j6850NgH12mLz5yZR8zjmcs6ipF3wiyG+L6B3GOPuwx8iAYnaZ3YV8KTFlz6lDzBTYPH + k55cj8GH9prCYCM/NMQ4A4dkXYudOR6nbfNLey344JV9oVfRnGHjV3T40nd8ldCPX6+vEsJ6sKZaY+wb + 965s81/KPbTvD2zgPCQ/l1Evfb//9juH5E/q+dzqJ0X9CteaUk9JLnHlOvdl9SrfYsIVawx54qZkfObt + G8jrMV76fv/tT7Rfvvdt0x+PTdvl8/GRL45iFaddMcbLpqCG99G24l5nxBccQk7OJQySfMuBRj3kIS4M + tsRqLL740skhLk7ijHmec3wu8T0+6hyybyD32OMOw1/20cmKE3WevKeTdjmB6+Que9ZznuyHMOSjhuNX + cdfRk2LilVa/to6snzmS5mWMmOwhmWdzE1O8sFUOTnyV0Jf/G35F56l/ldBYm4utqfeq90Q5vg+ISZqv + XB6SNxk5b/b3sl6Bq7/ZL/LdVnxwTMOmb3Mr55zv4jXEn3VD7xvIzzb0LHXsF6+B+NS/PS4p9vjLz31f + 8bT7cQm8eMX1x/X8eBaXMufsPOcmJ2zGT3ZywE8deHLbRqx5zWks9DXH6tA/i+Nhyz9y1NeqGas5Epcw + 12R/CnuPPe4w8Axkn+Q4Ye3k5EnsUlye1H6iCy/+Gjth5FFQe8ZVU/muxcn8Zd6uwxgFNTvufNX0/MzL + WMfFcVy1BsfiK5Z8zvNb38Sv6MRXCT2ll757Teo11tDr1B7I7/V1TNjwue7G7nUDyd5GL9fYFT45tD1G + LGLaN/mlPUZctuZsfRVrfN9A/uyjXvqOZ6n5Aa3xuOtxcT0eK/jIWXIZK9uwE5d1hTsP+swt2zHzM/cQ + aZeeH7piyk8cvubueuYzXvlXcsHpWl3P/eSpl9AS48R7Yfkw7rHHHrcafQPZJy5OzMNeTtaOSZND22u4 + hjDfTnzXEl0Q0rd5E1MvNufgXWkT77t6Mlwx6JU/eVlzsSs+5kJ+cpST8d4T2OQQ81/R+fYP/+ZuL317 + 376m7NP6neuZsWGbX+smzkPyJuOqD/US/fsaZ4zrTJycwhlL/yqPj7EkuNIU8T3mdc44cw4s7H0D+WpH + vDQa30sZXyX01nt46Vt7n48D990fC3GKR1t84RnLfOeDM/ISp89815jXMJOeA7bz4HvfwptTNRY960iu + 64szNdcTEvxDVEM8ieLijxrM48O1xx573HIcJ+A7OFH74uAnrE5gcBBPzIVxx8DTCY7aXdNj8hH3Oopl + nsVW3XWJ0QfGuWUrZjmKX8+BXlWn+MkVNnXX7jzx0484ZfiZY3UomjN/Recv33vx9Rv+ik73gJ5q/SHZ + f9vCaw0WD7/WlXj44gLjIXmToV5n373G6pdx9dv2GlNu8+A3pzFwElvqi1c1Im49FnZo5LCusH0D+bkO + /yoh/gTjp/148HE4RI+tP46NzcdMejzm6duxJG7ijV3F086YjqmW4lAcr75ke83CD028+lvmS+6au/g+ + Z9iar/ITU7z7mvjho+5HfHj22GOPW468EH6WkzdOVOOMGH3Z8MVZYg/UST9iiYmDvJG/xJRzFes60MCO + WNnExSEG6Z66ns1ZNRrrvJ6j+MXpPSmehPzugVjmkZO2+nn7xa/5Vwn9r3/gbd+rG95T9RmSGPq/irnf + /fZ6Kydx2DwkbzKil5x3EeDoF37357HWzeucldP15Befe6A9OeVwXvHAsTyzs+6+gbz50FcJHY/DO/M9 + 5VO7FOaP3frYUxBb6kTeIVcYctzm8eZ8xopruHzPqzjxjvexKS1sjcsvvLDQrGFY1VIs6kjoRzyeHeZD + sccee9xy4CUanpB2oq4nMU7y9aRvjkvnzZyKXVwEPFacxGKOnyxZa5HENZfqJj7rzpxr8RoQ5iYmTZ7r + 1Ta/alNU51LEO2zMbXzZqd/Ol77jU9/4KqFPeSv4sw3NdTVP9kOpXhZeYYeoTut+DALjIXmTod60jtCQ + uT71pjXUmoyjtVzZ4GGNI5+8FuYlrhhsz0E95cvv2vsl7Kcx8v2U8ZOM9oX3Dz3OEVNcj+MqKxfYdZ2K + hT2OE+DtN0fxK1/zZIy413E+cOtlzG/zJQ7uypeN2JJvucAOee/ZF7nte+yxxy1HfhrRTtISnsh+AsPX + iWsncMR04lceLwo62QNPm7zBVaxre31hlc+8zu8LzcNxcBI30TywTVsNz+s+up7XcF7Em988r1+1WVP5 + qz9rqQ7WpVrirb5e+sZXCX384kf//tnfT5l1WE/zaU717rpj6hGxrCExHPWgeUjeZKg/9SpxP+PWJ2It + wOc6Oh925jOvbcRVU3hql8CI+zyuUQ+xxPcN5JMceuk7Hh//wvs6BpbHuR5X4ivWuvPDvhLVVW1pl+RF + HWGrTb/rsfZDOQ+I8i/lyB8113rLXOjh7f0Bmj32uOfAm8PnidknKE7StnkBWOJ5cofIrpzQsDN2wqeP + uquNXPFkq5774PhcjLG/ig8ftvhV7woz32XME1jWlp542fJpV13jor+zTI7ljDzObbh4euk73k/5spe+ + fQ2q5drnGNr7MezMbZuH400G5rXeyj509tnxFPVee7HGYCPG+IFLlJtiXOjGOkY8cx2bczcGfD8D+foM + /dZ7PGZ66Xs+1nps7TgYxw9tO0Zg9/EgLvjAFB+5lgeuclp3jLmFG5f9yVYspWJHvtnyu07Xh++xttM/ + 9o3buccee9xjHCdi/GLDOHF1ohYWJzxlnMTjQkAs/Rl3zGvKvuJLvLbzxpyRt+RmLHkTEw7/mJ+5iqGu + 74Xb7YNn/KppOut2TH7HzC97nQ+44oop3/0hxCs/+dLMLZu/ovPdP3nxbfsVncAhrGf8wkYM9TFv9+y2 + uKklh8/D8SYDvVgfoc3W2rz3wXlAwG8btYDJb57wc43yOae4bYOjfPn7BvL1HqevEuLjj8dajzmPhRAe + D7I7PjHgHZ+46nas6heOGORcp3ItpryruVxGPfM9Pup4vf3y9R573Hfkz77ZxSC0n7A4gS8uHm4rJ/0W + cVKSgzruv5RDeSinuIZj7u7VeeK6FM7cxJVbHPjiiSsRF77NoVjixk0bPM2fsfInt3OczxxizUFMPbgt + TkrGJlb+EYuvEgKG2hljjZGXdTgHY9NvWxKYzxU2D8ebjOo5e4F4Ly7q+XoN1+tcaxT3sFOCZ3PJV1w5 + xTXtuOoK2zeQb97IT33nVwnhV3TwuK/HhB0bdVy0Lo7F1rzMJeaiOXou1SZWNbuGMPFXrOs0Z8wZUnWJ + 2TxhH/IJt2iPPfa418CvMvCkpawn7sTGSdx5xZMGT9w1D/7kex23vUZpclAHvuMdu7a9jnBJxw8/eqCI + v3K9jnznwp+6a1q91T9EOZNjc0Qd8qBZg7hqKi6sbI+xdmGn2lfzth5x4p0nzsyTzcPxJkPzYm70pj7S + XtZWtuGVl3vGWMW1XxZfbJ9XXAj27zrWWArrCd/vgXzzh35FJx7reAn3eNznb73reMhjYx6jdawEl5jr + zscxWLVMRg1qYJir+InzOnBhj/qsNTCKx4cce8At2WOPPe45jpP0wzhRdbK2Pk5oO7n9xAfWOE7q6Tte + Pm35OdfgdKx01mVM+aHdFjd82uoP/uR4PDGvcdiFL3lDKqfzPI4aHZet3LINF1ccxU8SMdaoHMNcBx/z + owf5jo+6Vzix8jkX5jHuRX71kVyLEQsOD8WbDPWn3lqiL/TTsV6X+i7OWE9jyJ15aV/Efb4Rszyv1Zy2 + he9nIH8+R3yQRC998/spx7GBY5Q+ZRxTwpNrx94SAw5/PTYH3/OMo3zvJWIScYAr1hyLfcil77HHHvce + /B4znKR28p5O+MFxLvwW8iWsozzx2z/byiutGupBmtzKXeIjx3m0z3zkzH6NH/jBdV/cxLMOfY+V73Md + GGutnBEzPmTt0fNaVK9k1EEfY376a90ZQ778ip84Es6lePqtFeOheJORc1r/Wk/3fN67dR2DY75r5CDu + 3JHvMfqZQxnzLLh4mmffQO6hoZe+j+Pj3XjpG8fLPOZ03Og4Anbm1TFpvvheC7qPy4wp9yK21vR5ZQdH + wtgn8Swsl7nHHns8hREnpk7e1LLtBHccFwM/yc8Xh7ogFHb40sSVg3zilQ+7hDzFhZU4Z8HVj3TjExs+ + 4xO3uhTH0h555tt8YSun7IzDdk7nksdYz8GaZYO/ingQqxlxy1d9r938qzklnTtt0+QpXzYPw5sMrU39 + dU+yuy/Filv8qYet+uIvftZLDVzzjVxiI2a41yrZN5B7PDD0VULxT0Z+ldAHzz6t44rHIo6jPqbmMSr/ + nOO+7NIU8ZwvHHL4FNRtX/LW+88+jQ8acUl77LHHUxn5nprjJNWJWye67DzZDz9OfOIp5iPfLyizxoxB + FG+8L16Oy1cP4DU/c8wH55xT9QyfXHJMUPM6JvH8tlsrNzH1wrkDL6EvnqRqrHwK4swL8ToU5SeW2ntV + fzZHaAl5yhPXaxXHY2Vb3RDWDU7EeBjeZFQva9/Wk/yyD/F1OMel6oXPnLaNQ2yI5bfuWPFWLPP2M5B7 + /HRDXyV0HD/9KzpxTNlx1ccXj2vKelyGP47dkQsMunNSX/AqZv5x07tvHvfY46mO/A/1+A+vTv46gXkS + 5wneF4a+KCyxtDtfmHKmf+QQK1v4gpUwv+YzzDnob/LCdhFP+c5XftUMGXUmxzWk50A9+uSp1sk2v/jl + 017irTuWIvvQa62TLLjWMbGuEbbizkPe2ndz5XtPoXkY3mRg7u537UX46JNrSQmbEjFI50iqvsUewibe + 80qEI8c5be8byD0eO/RVQvETgccxVb+ik8doHPPm61iUrZiOSR2Xyl25kuIlp4/3kuPmdr9svcceT3zE + HyA/gc8XB53QPOlpI4aLQOcuFxKz3fcLR2GHHnJR12PApWe++APPeopdzCcpXtuXPErVc67sQw9++BlD + jvhlr3xK14cGduiqt3BND5tc56TNmiXJO+NepzHIuXbnDEy1D5uH4E3Gua/uT1qYr1+48yp/7IPzYXcM + 3HXOkuBWbmM1h0Q+ORHfN5B7fB6jfkXnvWcfxg9P6JjDcdnHuo5DSJ8rwiqPuPjIX2JxbMd7N/d3Pe6x + x+sx8isi+LUQOontZC6/MJ784Ht84ZkopjmcUxeR8KnFdfGLzYPYUqPm9XnEIxecxjW35yvuNcRrrvKa + u+YKyzzNxT7kd96s3/HGZ78z3vMiV5K4fNniC0ufvWcOaxA/5855B0eiOubzELzJUE9rD+ELG3smjmGT + q3oen7llHzz4sJXrOPK7pot4Ep9j30DucYsRn/qOl77jeONL3/VVQnU80/djOLA+ruc55HJgH+0bxz32 + eA1HfsdYnMh1kuuk7pPeLwrF4cWiJDCPSzJ31qnYISu/bNbMvIqhhvNao47XGnMTk1141LO+nA97xhwP + u8TqQFBHOcqruVJ3/RGjlF21e35x5KuW4w/llB11XWcMIh9Y9ykuMOFHvcBHHWJpE1f80Dz8bjK8h+yL + 2nv0mPfZXIu7BOeihvYKeTOeHMsRXhjzVn5xaO8P0exxr3H6FR0etyV57EJL5Odbp95//udf+ODZb+z3 + Oe6xx2s+cDIvJ7z+SC1/wMpfeO6Hzlq04Xcdxcd8IVlL8f5judZxPnKIkadc4WtO+N6f9wLbek0+YojP + PShe2s1JfuWfufI7Jqz5k7vYF3WKY7HyhVHnHGXTZ1x1nCNe88EF/yVzG16cQ3jo3WR4H+obPfv+c/3F + a3yVGUe9zuvYip/2hnvStZnL/i7zvOa+gdzjCY24GcxPfuvXdOJl8EPyPZbE93sb99jjDRv6QE39YeIf + s/xjVX/kDGfM/7g5p2KMCxO3hJjykncRl6/5xcs5GB+5WZNzWkzYmC84L+FDLC4Z9ZofWpzOBV95lUO/ + bAn5VS/th/Cuk3LYmlM854vbMc9rvkvmSJiDmOesNZobWvmK89C7ydD86JnrUU/sT32VVL8LdmittcTi + vQ/ThsaeoUbvk/fV8bOWnRLcfQO5xx577LHHvUe+cZp/yE5/rPQHK3H9oTNteApzFIO9YOJSVFtz11zB + DWHdq5rI5x9hw933epXnwvqyT1yPm4gnG+Jx2lnzAk97yRN36GOe6CGEPOVAEFcN1Rz1JKqz4GkHnrbN + Jx5jFTd7xI1XuYvPw+4mQ/NXH9Ff9sE9Yr+ynV8cy+tc50AnT7b4xjvFw896tCWKHaJ5PB7+fg/kHnvs + scceT2LwPS38gzb/cOoPnv6YXf1R0x+29Q9l8ZjvsZ5vwZY4fGj5Es0p/qwB/qhPe9QJ23gTQ47Pr/lG + PUpikSu78DVmOmsiPmoSVw74jGds9nHFnXGff8k54cxbYi7CVQe48zyOuiE85G4yqs+LdcCeMRfxtI6r + 9XTswreagUPAK6meYBdHPXnc9OtyA1lfFRMvaX7w7MP4Tef8XeeTvP1OcOJ92fHBDabvsccee+zxOozj + Av5u/lFb/ljhD5v94eMfNeH6g1d//JxDqVrl9x9x5RbPcstfhfGUw69aq0+75mOu6nasbdUBBp5j5Ruu + WNeBTg5ljVWceV3DYpmHHMQZoy9M9dd6kyfxeXsu5beecylfec3puLiq71xxeLjdZHjPmn+1xfE1Qbct + fMWQ33lZk/gqyRsaUhhrFm7+jB3zPOEbyPzUbny34AfPPs2+1bPWkX7bWlftA+xPD+y44TxuPPf75/bY + Y489nv6IC39d3Hlhh1z90WveyucfAUjEaHdu/EGBOKdylxyviTzjcF7FG7Pa9FGr8XPdIxZ854UUtubb + HIyXv2BVm3LORTw05gHeGPmrZFzSc3i+67VW8pLf+yPsnGtx82ErvzHPFYeH2k0G1tXzl4yezDe8fGJa + V6+z1y0u8MlTbnJkj5r0LV/c5vkcR90ndgOJ91K//Tt+06i+sSbsx4pp3eL3eqW5bmAf4fr07DfippJT + 77HHHnvs8VQGf5j/fBHPP17AJPhjoD8MZzwx/ZFY/lBELHOJX9V2Hznky7a45ivc63pucZf6FI9V/xZH + Ldhrz5qn5wSe9aIOa425xWOuMPFGjdRnP23muKhu+mtc8wVuMcw5pWPKW/mNi195VjtsHmY3GejnLOhP + 0uvDGrRui2sNvhbGxGndfK9fuNdY7J7zOi7/Kd1A5k/k2e8t9z50v74GxLhPyYWIU7HBNTx4qsuXv+Nl + 8v3S9x577LHHExj6o+AX8Xnhnhd9iTDxh7bc4lp9/ZEY/OKyh+RbnDVmXa83+amHz9wQ1cn4jKme8wpT + 3qi/8iDOVUx5qr/mti0ea5G3+spLzHLTpi+s8lxYU75qQc7c1a9c2ms+D7GbjOhDPasv6bW/xEwcX3mt + aWsfrGb6q2Rcujlez7lVlyLeU3kPJH8Gr3vkurAv8qF7DdLgKW/lelzrLkkusZmH7xmMZ0Pj/ZT7pe89 + 9thjj9uPfAP8B29/hAu5XcB5wV4v9lNPrmJXtRQrjL7XQJ2DI21ccQonP2z1CbG5GZeIozrJU52qtfRO + UZ4LuIh5bcToL7GakzHZNa/5aYs7eM0Xb/iWP7Tw1FY346pPvPxzHdXIXOq1Lg+vm4yeGz2iH+8pepZm + 75J1TcYrnOtEDUjlh1i87Z5bPMdWfMVC7n0DGTdmx3rwJdLZ56Frv2B7bGCmEfP1khtCXsbN1hyeh1rw + FVOd+Em+w/5wv/S9xx577HHjEX+s3vL3NvHCXxdvYqHXi7oLLur+x6Iv+IO/xN0uLOs513g13xTlOW/O + AV9Y5ojDPM91rPCyEde8qA1MHOD6g9hzgDvncB6ENZZ64WfuYUt7neZ0TeemZo2aI4Q55R+ifM9de1eO + ax5WNxnZR8zNftRD98zesldgjl/FVAvxXqtihXlcuRLnGdfnyzj5iZu+9w1kvnRcPXWfV1jtk8VWTLyr + vQLfuLk/0sC1Lx0nP+pd8A/56PDzpe/9iyh77LHHHp/j+KU//O1fOC66+JQ2L8q8ELcQ0wVffyRcIz5z + FFes8zvH50tu5l388aA/a0Ay7vNFTQo4ba+xtK32Gk+M+cLAbz04oRNvP+3C1Tcxq+u1nNMxcT1v+inM + cV9zqabzUINrkE2u4xUz3+vzkLrJ0DpGj9HLsq7CaQuXNI6Y+BlLrb2QbtvF4/JbGKeW3XOBE/49byCP + XuIn7KoX2Fxr+FofbYnWV1wXqyFO+qwje2KdW74J5qOfdacGp+eJrxeKfd1fJbTHHnvs8TmMuLDiKzp4 + YTbpi7wuzAfOPwjC/cKdtiRii3Te8kcn4ofOesa7wuSvGGp2vGPnviuuuR1LPblrfIjXCJs9n/uYWPmW + D5z9WqzmZe2KKdc17Z4XNZ3nfXhOYWEbVhxia+88lG4yMD97tB5kY70WS4z2odH73JNaD/3UiU3OGvP4 + Kqon3uAST5/YvW4g4yVg9NO9VF8U7M/RL9d2yWOsuMbB+hUzPrXvxcodOWlzL62254kHzDgH/9jjT+K7 + K2Ov91cJ7bHHHnu8ohEX03hP0XHR/SgvvH6BDlvi2OABz1jg4pGjHNUWv+oQRx5i1Ufy209tHPniKpaY + xYWlJm/lKC6ZNRVre9Qht3KJn+swVj50YVmj8dSW79o5PqcwaMwvv0R1aGse789rTrzjPIRuMtDH7CUl + bMqIG9Z2Pz6Oy0+MNZPHOZBnWPDMH7UqZ+KatziJHXKvG8jjpgp9aj9MV/+NQYDnGlxsPVWzMNpLTfFX + bOQJO8UYz5rgXWN8vC2v9Ptvf3TsQX6V0H7pe4899tjjkSNe3s4f0D/+Wz8utPm72rgI+0UZF+FL4YU6 + xC/cHlO95jWmOZrHPwDEVlGe7MTzD4jx0u9aEsXE79hqo07mcA01h2nNlzzqNda4OJOvepkXkn7XEUex + rkfMRDkrT1zPG/mqL/zwPa84h/CwucnItVc/3AcT9er9OaZ85WJNtp/GRXzOEf7KT9/sqkms8hMnlnbX + ucczkPlrVepj6afk8LGexmptjMlWrOLli8v6tMVTDfGUK67XWbW45bO2sKpBQW7nFD/ixPVVQvul7z32 + 2GOPRw79fBkuqvlmdV5ocfEdF3TGdKEGbhd04sovXXngiDdqkCfMcy65FpOfYrZzQ5dPqXrJJY+2i2ql + veSXJi9jxW8Br3PFEb7aEPhr7SGGrfVlV31xpI2nuPhpH8LD5CYDfbGPEPVVa3AcsV7Xss+LiC+udHKP + HHHSpn+SrM2cQ2SvddfYXW4gP3hun7pmX1xb+qkRL1GMfu2H4o5RxA8NYYxc4ZnvtTLX81zIrTrAH/KB + gd/a12HzWw6lvkrora/sl7732GOPPR414kKaX6MRz1LGy2B2EfaLd16sQ2jLL7x8/lFYMPeBmc8L/ayL + uQvLebuXmuciV5yMFT9E+arNGhTZHgutOinGS6n6yxrJ7Ryba6l1PQfqrbFTDWFhK3YhPv/oRXLk85C4 + yfB1a63qQzGXjnE/lL/kiYMa8BvzXGDKL675p7hkqVG1w7/xDSS/0mv0NWT0in7P/bcPve5V78OQdb7D + V40Q5VUt8ZM3553zGdf8Uc8w5VediBXWftaUZDztT+Kl73ylZn+V0B577LHHzz7iv/K4kMYzKfES0Fvv + 9y9ZDNEFnRdj+NAeu8wdvImX77lWTz64/CO01LmaU/Ex35K34qqTnJiT8yK+9EO76iUHPAniU1ctYcxT + vSEW6xxixJ271vB5ZFetQ/MQuMnwNfaaiEkyxj5NHPN1rH7Y2B+sD3HomWMY/eqF2jmI+2MKP+xbPwP5 + i+8/z09ep6hft6139Th4wslzbttnvmohh3VNVBN1Lc65UQP5mhs4OcZr2zD6ozZ9CepOX1K+cj32/vP6 + FZ39fso99thjj0eMeP9Qv/T97M/9In99EZcG3n5zlC8fF3lwRn7NAxtxcfXHQXxwXarGwlFO4+qVf2wC + Jw/i8cZ9nvJDK25aMfEKL1+1fY5et3IllRvCfHCQ0zWvehO3OXy4bzLm3OyH/XVvwDz2UlnWKztiwpyf + fs0JTs2nmM1b+cS9tvStbyCPnvqtKNlD2/K7P9jJYU7GbC3CnOuxdd3iACeHsZyDUrHylds1MoeciTMv + tPzUNod8xiRXNWUjTtvqiy+d/0TvX9HZY4899ng1I176xgd08ifT+ldx7OIsqQs0RdzBixi5kJmnPyQS + YcqTeM2Mh4z8OedD/AfrEldvwmeduQafN+ewGsIfkoyzH8+tuamrjngSizdfMufmQ3uTEfOpn+rB7Qt/ + 7bewi7zaq7SRt+aLU3vhdbzGlZaEb9gdbiBHL76m6o/2aR8sdvJpv6xO2cXtY73wQ+SrVtU0GRyb23Oy + pvmoDT+FeUNs/vDddv5aP2Mm3Qfz349f0emvEuLDsccee+yxx087/KXvt96LT33zpe+6APcfiMQvtEth + lcuY+7ywJzfmkU0uYm57TeCZx9wHfcNVo/IlyksO7UOPeRdR39KOVx5rrrjmFwdY74tLcoiPumlDh/Ch + vMlQP+qjfLN9Pb1e08wPu3xqYNqbtocf3LThQ0MU6xzPR+6KhdzyBjLON+8z+45+hB2CvmQbhzytxfPO + OVhb8Sy3ec0ZfMkD86mnyll5IZzTe1Is7Yw1X/aKlU9+15s2tHzJgS/zlDQeH2Z69wvvPd8vfe+xxx57 + PGbES9/xks9xgeVL37gIx0X36oIs2zHxZevCHjJt5U48xWqM2um3rfqFqT/TZ5tc5kVM2FpHcfE7R8K6 + EaMWdpWXHOdJL/iptvml33/+53zYbjK8l9EHe6ueU689rzngPSjGFRa+6ohTknHYPnflSDI+sVt+iCbP + rZhTc1ePXCvXMvoUZjniTNxiEnJGnazd+JonW5zMqzqKHZp1wq58cj1eeHLpE5P/YA3GrrRqlu0+seRS + +1webxxYXveOYwJfJfTb+6uE9thjjz1+1qGvEuKv5uTXj+gi/PDF+OKCveAlcdGWzjr0D5l25ErWupOz + 1mzejImveoqvuOestSouO2Me77zA1Kv7ymts+rLLz7rPPuRDdJOhtfT8tFOzP65TtnDlKJZ4xmd++MIm + H3jG1jrSwqlVJ2IVP0Q5kls+A5k3JsecYy3eE+3u3dYtTuHNE5a26kVti63cyidPtnjgdNz1mNtykuNC + HvgtwpXbHOisdeLJN5xats95smsu4ZDMK8xqUfChxLc/jMcunkHe76fcY4899njE8Je+D51fJaQLNC7E + 5wvyesFGrO3B4cVfF37UlvACT076xYHtNTSPtPCr3IxXjPbgS9jDhd+4YVV/YuBBmkeb4r7ys9YNb3xi + 1D5U31jP6DdiuYbzfmhtGasaa6xtccBDjvg9N+bPeMU6V/yUwFTTat/6BlK9tp79aF2KjTVIDr7yir+u + bY1RVE+1NZfyhJ15a77Nufjigo/6yithDLXZA/HQhVWdjp/4lUOM4vUzh3XEK3z1OYdsiXE/in+o91cJ + 7bHHHns8csR/5fGST/wxjpdWjwtr/NdeF9y8YPsFOC7IuBAzfr5YC4deuW7XRR2S87TvNdSH6jdnsbPG + nPuz+inKpw6O8ztn+o31GtWrfOn4UBS3/yYj57V9Q5/sJ9c549039qF9YNKVu+KBLTmyhReHUnkU91GD + +SHJv+0N5DHnO2Mdo5cDr3VMXCJ+15jr8zryh5xyrHbmzHmUU3ZyJHPurtHcFPnkliQXObIz1+LFkX/o + ykn7zPE6sC/yU8MX7jGviRr0qz5s5aXNX9GJ91PuX9HZY4899njEwEvfz7943FjG994tX12Ci7BfxPXH + QBzwGusc5innQgJ3ftVlTmLGdbxiicGueYSpHjFJxSyuXNWWVH6I+MpdajgncuNlNW7zzYZ6UO+1J+xJ + uvcTe6FY9s81gNsY8pibMe7RKcfnAb94L+UwfsW76TOQz/N9xdUT+1F/ijWOHju2xl/Gs31Z9WKr5si5 + EsbE67xzvHtzvOPKq9wQ8iSog7WVbRyPJZY1m9dx4ec82VlXQh44nS9e51uMuah5/GNy/BON7+XdL33v + scceezx66Fd0jotvfJXQJ7ro+sU4L9Jp84L9E7BV+uJufxwM7ws9pGLswznlJ6cx1GYe457jcefBF+b4 + mot+hMvPeSDvcktvNmzu7om2cO+9MXDELw7xIScu81N3XdmKV4y5IyfspWZjt34JO7/w2vpkr+xFumOQ + zCEuDZlc8YYEJnHs0Gue10r8AU7WkBw4+mgMOW5bb6EzR/XbFr9t85kDQdz5A+ccbo8Y7cwd/rRdErea + Pu/quySf8tZ78VVCb3+YvyS2X/reY4899vjZR36V0Ffwfkq99I2LsC7EbQvXRbyx/sPh3OTxwq488Rqf + F3j5XsM5XefADl01Das5KMUlb+WE7fMhDr94nn/oe/zxUT9z7d132BD2KiH3lO+xQ6qWOGaveacaicF2 + vnqB7dL8276E/ezPvZ+xFop6z7VRmisfWPGucgMLnRjt4jUnY6bLLpzzlA0tnmzN5XniCC++2+IOv+sU + Tu2cK9zryQcHkrhJYuSUllQu68leeRWjvdRTjvcVNvkfxas0+1d09thjjz0eOfyrhL6QXyWkCy4uxnVB + Hj6xuGDXRRtY5VlszVOuz4E4Y2VDqxb8jq25zbmK02atkoxh3sEhHjch3KqbDvXnPWU/2Vfb1S/jhRMr + O3MWjvmaJ2OsBd35M9524eJaXuHk3PoGUvOH1hqrz9VX34eA37nFqXjz5Kdta668EKvdfvOUqzkGln7H + Klf+EiuMvs+beYXTdrxiax595q3x5qx1et8rfoEHNvCyr/M9Ll+Yzw0tQS3n8P3jH8YN5X7Ze4899tjj + kSP+M3/rK3jp+7jY5lcJ9QX60Be+LtbAeGEXj/GBJ9b8qiHNvBlvzP3QEP2BYGypoboVp3a75qO+9Ydn + NLSW7h9akj0qvkjFnBu2xXzNmmu1xVeOpGvYPKdYYy63fA+kPwNZ2vauerS9gXS/wl2veyrMY1kjsJdw + hQe3bcyhGq1nnkQ5aTPmuqRyvcaMpWa99JMnLuZCvPU6T9X1OrRPNchPjH5hHjvFgWF+xsmpeYwjHL60 + uIgLO24o82aSh9Aee+yxxx6PGXrpO7+bLX6e7D18lZAu1n4Rl68Lc2v9UXAOL/QXtufDP3NTj3mbk3hy + 6Kc9exO2coUd/k2/+9GHemUf1m/32CKerZ+cz7IP4im/NWzpzm+NuPLJ45wpYVvsXi9hz765ZyHsbcaF + c23E1jqXwrV7rsRraF9mrH2vs8ZH7RNv1c3x+SSodcagV7+5E5v9iFdzE5Od4vHKE66azDPdXOGSrq86 + Hm/f6oSQv9bLZyaPY3U/K7nHHnvs8YqHXvqOGwK8VMiLcFzED1vaL8y4WPcfHI/Bb7u59E2nMF61KWnX + 3G57za4z51M88z655x8P9ee9u11rkL3EYcPP9dB3XtWg77ok+F5bGP3EDr/nOnMUT/+GN5Drh2jchlhf + 6jskeIV3rHVzHqrh3Jfimmv0Bby1Yq0rntgqs07Na7VmXvviQmZ8lZXj+Tkv51avLsVLDVmx6aOmuBkf + fse7JnKzj+phctsmdxHdSPKQ2mOPPfbY4/MY+hWd48Kbv6Kji3mIX6gTj4t64uSErwv5ekFnLCVzwAEP + WNnihTA257P5DwkbGP+wgffpvd9gj956D6rvtFsyzrWIp5zJnXiJ7YGwq7naxh4lxh6Fdf6MZVyxWz8D + GX2tYv1BE1uk46YTP+KqQ7tqEPeanYc6Xkv4qWbFaDNPuV4fvN7rkFHL7LWv8Fuu6jZ31YOffXle95D4 + 2kPy2StxYcmlyPfaGVtyxhzGV6zmCQ5zFFceuLMnxY9/lD/Zn+TeY4899rjhiIvu8V/8b8Sv6BwX4vwq + obrY88J90rpw025MF/n2O4YLveLTP/9BEK/qJBb+s7vfPMZQX7NPrkP7FHoV4iMnfeR6vZKRx/0SRvGc + WYtcq4E6kp4//Vs/A1l9qK9em/eWva/YiQ+RLbyEfHEm3jld48wVp2yT8r0edfeLeOc8MEeI8Sr3kKta + YUsQ475UnMdCxFff+YwPqRpnWbnAUbc4owfDJT6/JDncG/Nluw8e1/P+2+/w8Npjjz322OOWI14Wjpe+ + 40Yiv0ro/fNXCeGizQs7BXH6sp1Du/P7op8X/szpPxATL+yjp/LVHrmeEK2pehS29j6xtnud8nMPlrra + F9mVYzjqXtkxh3FDZw3jMXb7T2GzJ/VQfenYaKw4xkXM9rCwzul67UNfzGG6a7F++JVnnMQ6hpyOJyZf + XNqOI9Z9Fh76EK8jnuYTt/uAll08s1FjFcsnX/UjXjFK2VXbeZqHcXJW/sDEsfharzjGCx1xcj7a743c + Y4899ngCI95PmS99x6/o8IMPQ/LirQt44+sF333ZxaeNGkesMPKe2PucrtaidZcwXvahtd5a42J7neRa + fvDmfiHvlF/cuZeeM8Ri9/gQTc5/aDz+kqPP7KltcX0Na1z5sHsPEguOhPErrXjZh2TM8UOKPzDazFGe + bPWrfoqjXM3hc5GXWNrtd53mnnipYUMUp22+5lTMxWPFr7msFjkZDz84hc14cqyG58v2mHKyTuIurBex + J/A2lz322GOPPS5GvPStX9HpT33rIr5e3PFHwi7uJc1BXNyIxRvkD/3uU/wt3VonRb5EWMa5ntIVl+79 + qZrpt65aS7wF8ROXdc852OuMHbjkLjeQJtFb9ZO+7+tcV9nuM9frjLUeeMZSc+3kguM+bZO1FrBDM/9q + vpxDcfnM8zkqvtjwf7INv+dF/fOc3WPrijFeQk7ilK7fue3P+YQLKw7r99yzluIpjitGW/Uy13ICi+vH + voncY4899njiQ18lFDcg+X7KD97Ol75xkccFvS7wutgTzxixeMn84D/5Lw7WutS3r6E0RbHxB5Ky1hj7 + wbjnJ99qA+cfULNXDPU7z3nBSTnwW95A4ovxz+tVj+pJ6xj4IYN7FUvN2ivn0FWXsvolzk1bj4ftK8V5 + 5TNH/Mq1eObQLy6xjGeN5knW/OZ2Da+ZGOPNa47X7Jhwz0EMvnOapxyPCS8Jn6K85rdG3Zl3iUtUdz8T + uccee+zx+o145jA/pHPclMRL0MfF/N14X2XcOOATuM/+PG84I/b+8195nS708UdKf/D4hyoFf9D4x9X8 + 4hMrzT+E4XsdxP2PdP8hLlHukieZPXQN1Syu6gTnhjeQ8fh7/+qvfYnh6jt77riwilNONegXd+HLB799 + cauO5XXdqdfcEnIkjQlvf2pwZw5rkCO+ajleYn2cbHJUN2sQV71R1/MzBpEdsZV/jk+tnPKTq7lduh+J + 5kjNWPxTut8Tuccee+yxx5MY84/U1C76Qzdi+QdS8eOPHn0Xz1fO+oex/mAy3rUMr1jbocV1TvJufANZ + 86qP7K1t91Nbz9oDiXDVnLyJ+ZzKHTVCWOc0f+GTL96V33PQjhoX8a7deszDPMfClsA3LvmoZXUO8f5S + yE8e81DXOOTVfOSJO/M4nzgVM+4hax1wOu65pxil5sp4a+N+xMNujz322GOPPe43+o9U/+EafvzRMvzk + CyMeeWstyYNzpN14is2TvMNPTs3T+cLDF3bLl7B1A7n2iR6JLz0WVhzEU8z2/ORQxC8s7TNPdYCvc7a/ + 5qfN3LDPgphqIw+xqqUYeZVDvot6zryBd0+JMV+1QntO+cWbfSOH/UuIqZ4wxVeusKoj7pKTNemX5Bze + L+2q2z06d9TbX/Gzxx5v1tDLnPGeN72cKcmvkonvKPzK2//nfh/LHk9p5B8u/vHCHyzaF1Ix5VzktbY/ + 2vSTe7KhPQY5/GUOzNO5Na9xlH/LG0i8BxI9hM4erTf1hPjsXzniTRz7UPkH/h++9ruV33nNSV7FkSNs + rVU1xA07cIq4awx1Zjw5EWdMfPGGrXj6jVUeBXXb9hgwy8n61mvF6bO31LTXmuL3nPLV37UWV3bFap7W + nqOeyyd2wq1f4fvLxvfY4zUe+ZUwx03hIR/mp2zzpIfopE+bJ79fCBj76NDvfOG951/cN5V73Gv08dh/ + 8EL8OJ74/IOnY1z8oQeOP34S1RTPc1MylzzGPVbxw0dNxITd8gay3gNp86Mn2d4z+pSsfgq5iPd+Bfe3 + /uw/v4jxg0///sW3Pv7uiy/931978etf/1Ll1lzla88dO3NQH/2myA/eElOtwlSL3PItJu6qI36Fpb6Q + 0XvVpj8wrBly1A38EMfFU2wI42Ejx3ozGXMfUryQ4CQGWzHNibqTm9pscWE3fsgnPPz22GOP12Xks4zx + khVPZlwE+gLTFwue6MSKQ4wXgaqBm1B8GCM+iLHfLL3HLYaOSR2jfUz3MeuxEubIHj6l8io+6yqneIee + 9ZqXUrnNqzgx+be+gRz9ZB/dU/fu9uzbcV8fMPqH6Abyanz/nz558Y2/+6sXv/etr7z4//3x72MOy416 + jq39+DyyHUO+cPQ/4sLdJid5ZmM+F3LIAxf5sk8851NnjtnFH5zJTT18cN0X5nXTz1jng9taOStXmLiK + Fyc1MeVzjsq94TG+xx57PGLEs4T5k2Xj5McJDd2SJ3vafbEYFwX5rHPStI8/gp8c/A/jj+F+yWKPz2Po + ePTjro9VaJeHjt867r2Wi+Wc6jMfMuesuuXbvOkDS57PcesbSOuphNhcJ2ytq7Vwi1u+5GU3kOv41x// + 24vv/PB7L77619988Vvf/C8vfvmr/3HUC1tS81mPlz75Lqo3apKbmNmDm7Wbk9p4qlW+5hfXfPGgp7/y + w8a8xhPH4ucak7vaU5Q/c6tGxRf74KakDz3i1CHxpMN+omGPPZ74yGcFlxMYuu31oiIBx3iUa0wXH6uj + nLY/Ovp5N95ruV/63uOxYx6jOAZ1rF0ehyHhOzZqLDnUEROvMRz/rZsj7EGei+Yy/5Y3kPot7BD1tvZ/ + taZeL/dMnNoDcJ3/09xAXo186fuT7774g+/+adbqeX2u7ktYifV7ih+xFNmHBs9trW/FmWeS3LCtltcf + fsbbRlzSfV7VhHgefbMVz/yqjVqKu2QtCecCt+daayePXNUusVhoxW/5TPsee+zxU47jJH3XLxTzJJ4n + evNM82QX96FY1lDtjMMXf0jwMiY7ngGJn+d7/itP8ddO9ni6Yz2G6/gijjg5PB5XH8cgeMhrntdMn9zO + sbmd49wFG3MHtnIPueUf1rqBtPnXfZnSe+g8ccs3LuzH30Beje//08f50veX/++v8aVvzKV5S9iT+9k/ + /eQ7J+NWJ2IuGfN82Fgz94Yx1DKfUhhruo+5vaZy5PccHZv+5LfduHM6R/2kZOzIoe0x1EW9UzzszGU+ + tfyQ/d2Qe+zxREc809cncJ/YfgIrrpN7PflnnBhrCBtxy696tOVrXucIC12/gnL8EY2XvvcFZo+Hho4j + HWc6huZx2cc6/I4pjmPw8E91VMs4JsIR6zlOcdrKR00XzQXOXW4gKTF/98ietXauM0TrBrf7X/3EmBcv + RX/e40f//q8vvv+PH+Ol7+OGNV76Rh/oNYX9yPcey6eePAi4rGWiOikrXrb55GGejosr3+NVn4IY4/Rn + rmz2tvqZ0/hJmON8xTDvGT/JEfP5Z1/PfoOH4h577PEUxnGivpMnrJ2sfpHQiT9OfrsAKFd45Q6ONC9e + C55iuTVf2o2N+iN2aMYOyZe+34qvE9rvp9yDQ8dMCo9NHC92bDPexx6P7RAde8FzW3FKH6esaXwXcdJ2 + KW6fA6jrccRSbnoDOT9Ul2tjb6vvPPngkUssxdYk7PN4BvKzjH/+l09ffPuH36uXvnNN7E/r857Ddi1e + 7QFzFDvvzRnPnMqbGjb5VlsxzK0eZn+KK2/klz3zIBPzHGnYHV+5bTd3jaVUH11XseO6vj+RvcceT2XE + S8E6Of2ELq0T+BCc6OAM8ZjZEF4YVCds4hkbWPMrHjHmin/qgTWcP/ITw0vf+XvN+6Xvn8uhY+HquJSv + Y8uPn3EcSZRjetjGxXwP+MpJDHOuvnhVd61/6xvI7Jl9r71Y76WNo7WPfIp8xe51A3k1fvC//uHF1//u + r/qrhKzP0HPNkFzzsrZT3G1ygc19q3jGJL1/mnuVrG01r3IucysHtudVXLaEvOIeWPnKIVccxZ0D33i0 + 5e/3w++xxxMY8XJv/EeHE3OepHni6oQ37Sc0eJarOPmKrXFgPYf7jmke1Vpt8InHnJxXOmOOSw5fXyWU + L31/Zb/0/fMw+riR5rHMY6SPweZUPDEen4pnjmLkXdRSfunk6zhnD4wrp3DLkVTdkCN+y5ew9Sls9GB7 + IW39Fif5M+ach/yndAN5NeKrhOKl7/4qIet/WetpLxKTXOG2L1HL68m3HNmYhxhxxDB/xgJLbnOEa97B + p99c9Yu4/Iw7N+3GLyXyrKbq+Lw1R/P3r9Pssce9R9w86cTVCVonatrQ7eOiopO8tMVXrGPSXr8vUsp1 + LGtJkjPzG+95z3UYK6zttc6hPzluLD/MX9LZL32/caOPCTzeOgZwXNHXsZGax4Zs8hKjX3XIq9iqyfM5 + yl/j5UvYc+VBK+e274HsLxJPuVhnSPZrunGtH3bVYr780E/9BnId//Nf/t8X3/7h3xw3lX+Wvdf6bG+A + zbXLno8r9qT2r/bHfNUlTzGv0YI+NI/szlecNSme7/wSxqFRA3Xahk+bXJfihm85JeIeNnvZv5G9xx73 + Hm+9Z88++okq4QkLzQsPxU/6tBULjHnI6VjleJ5xm6cayNe8rcmtXMNZu+PgiiMcGGpDr3NVP/wVnf1V + Qq/70GOcj7+OEztGZDvHY81pf80tnsX6mOqYS/D6OGyNGHzxKk/zBX7jZyDRU/eQfaTdPa09rqL8sQ7V + ov263UBejfgqob/4GF8l1C99++Pbe+cx7UPu0YVunnzmRNxEPOWVrhzZ3ZPyVMNzJMVNe3Ivaxm/OY0n + P/EZU532offbkPbY444j3/uok/vQKTpB6c+LQNvi9clO3GLTh5YvG7l9YVAebOStdnOByUceMc1D7XmJ + Gb7WKQ6xsB2DjZe+8VVCv70vZK/JqMdRj689zqfHOPXkCX8o348jx1o3f5XMOeo1X6L4oR+I3/4ZSO8b + fdUaqCXiVTzXAK08xDpf3DfhBvJq6KuEfu8v38uXvn3NvZfwtSetjzj3sO3O8X1tfKnj8Qf4rhVDnSu8 + azS+PP5HXDzVAW9qcV1nnbBZI/Pfe/5FHpJ77LHHrcdxYubX9uiELp0nKCTjac+LAfy2/URXruckl/WF + dU7Hu4blEcucEPJUr3iLX3VTd1/FJ571mKv8ioXNeErisL3e4X/y1nvP9q/oPPGhx7Ae33pMddzgOIHd + jy9sPzagM99qSOSLvwp45OSxpJzJcW7jEtY/8m99A9l9sTdbg3pUb8KEN3/BJJHD+C2+xucpjPgVnXg/ + 5R/FS9/jV3R8n/rYOu/fgWuvMwZfMUjb4patnMS6jnirj1rI6by1duetczuvJHyJ8VWnNeaLD0TykNxj + jz1uPfD9iTyRD7k8qfNEbY0LATHlCDM8JfG+AJykOF6HFwfK8DlfzW8czYFaLliT4plX8yKvYow3Pntf + ayC+cugj/tGBvRvvp9wvfT+NEY9PPZZ8HEv4GMr3x7JihwDv49JtcROzvOJUvAVz0R66c1Yb/O7jXjeQ + uR7rT727JFZ9c0+JNUf5jJP/pj4D+VlGfJWQ/4qO9gr7ZHsl0X6Ox4PHSMQSB6fwtIkzz3HVHPMsgnz0 + 4rrjtKsWOModcxhHdon5OcdxHPKQ3GOPPW454oYmT8hD6oQuu32crB5vXCdy4emDKymu5cg/zWV1QtwW + v3RxVAOiPMnIXWIZ93qHnbriZ7zj1vtDuOeFnZKfYOWv6OyXvm895mNFW49N4X0srbET5yrvwMZxoRoU + 1fZjDHb74pVvnKxDTLzb3kA+zw/RrP3V2tifYs6FNFa5jqnOgf3WN39+byCvxt/+0yfjq4S0X9qzPD5y + LyGX+3uyO55cPn4Vs8cT0v7gr3nSlW85Zqvm9GUvdQ5xHg/JPfbY45YjPhCiExXCE7NOdjuB86QFrhMY + fGJpd27XML/y+uQX3nzGDQvt+FUcue2rt+QaljblxDEcGmtMPPONZ3MmJ3xig2uY+OlLgH8a/0nnS99f + 2V8l9HkPPK48huyx0OPojxEe3/Mx6Y854sArJik+8lMTv6rZPEjVKM6cq/Pu8Ayk+sp+u+/R51Xf4ss3 + 3ONa18/zM5CfZfzox/+WN5Xxqe/f+9Z7L/7D134397H2eDwG6zHXnN7zfmyKn/bkhFbeudaMKZ5+1GPN + 0gtf+QNPDUw6sH293GOPO4z4g+MnrZ+wfeLyZA2sfFwIdFKPE5qCePOV33V5ASoueyis84qr/OJ03DHn + igMbcuKprrThzW9fmPPEuaoLDD0qV311jvt5M/DJIftXdD6Hob3Ox2+RfnwMr8cxZD6WyePjVjVDJwae + RPzkrj75D9VGjFjhvY6wb3kDiU9h93HrfWZ/aU8tnvpFTvMLX/Rv7hvIn3qMX9H55vwqIe1t2XxM5Ofj + lfaZo1w81u5PnXzmiC/cucLdvhKfa/hHvX193GOPO4zjJPwQJ25fXHBy9kWkT1id9H3iKuZxcXChOMdS + LusuHGKqIX/Gm+O8rM85Hsq56r9qXPSnml5PdYSNfNboGPeYnKu5rqTysmY864Nf0dnvp/zZR+9tPz79 + eMFWDLpFXD0u4nlN6LVuP45r3tlGjnJTU5rH+mlD3/wZyJhXPVl/3uPa58qVnbLEhf28fIjm8x7xKzrx + fsp86fsbX679rX1f7PF4RezQzmsMghwc24o1RtzmdNvrylZdrydbtULvG8g99rjD8D8CdeLypNRJ7yey + n/CVt+QqlvwHbPeB9bzuVz3ZFPTmmjnihrY4cohbXPXEFaYcSc8hn3sTceOqBrhLvbLFMc06qj+48ile + 99D1Kzr5fsr9Us5nGrGH4zHifgLnY0vcean5eLgtnnDljDzD5LsoH/ascfanrT5uewP5vF7CVj9aR/mM + 97ognYc1iJMxxlUjJL7iJt7zF9+luMerHfHS9x/9d7z0Pb9KCPvvj4VierzEa07z3B+5C3a2oeXPudY6 + 0PsGco897jDqBlKik3W9QEjyQtEneZ3gljdO+uLzxCdePgWcc6zmVl35GcM80mOuC75yxnoSa67yp9+5 + mke5mEdx6Z5X+V7HeyuMtrjF8blCOJ8Eed0zcz45YvurhF4ytN/aU4n2/CqWvovzKOFnjeEznnzEVo4w + iceuudDel/H4hffPP9dnqePa8bI+vHfXkuZ7btvwm+s58Z7IeGk2XqKNX33Z49WNeD9l7Gt+ldCxz3o/ + ZT7GdgzrMSmf8RJyxIO+yl9s5jbecdUGl/4Ri/eN87DcY489bjXyWYQ4Qeuk7ZO7fMbgH1q+4S5eI/hV + Q0JcXHDanzzUak2u16MgpnrzwqQ4NC4+A3eJerSTk7p5slEDuvJYz+uPOdI2vmHFZ37GnLfgp7kLR1+L + ja8S+pxvKl6XgX3p/S7hY1HascP2PZ92c4emnfHA0gbuj5HzTjUZAyYxTsXwWLeG/KL91vurfJY6306R + 9dkf+0Av0r62GVNc/TavsVXWeSTxfYlxsxMfIokv5/7Rj/+Vt0N7vIpx9Ss6erz0GPTjhMdP+Hi8aOdj + KW21lJd64BLWNm7Y+wZyjz3uMPCeuj5RU1Nwsp5jpxPYxLHBi/y0oSuHceUp3j57UA5rqC/nA++8mdM9 + VJyxa79xSNeQTv6KB7bULD5l1obdPjHyVAM+4lWLecM+xHtVzOcp/3js41lKfJXQz9fPgfm+1r6Y7fsn + rh6Xsk1LRt0H6p3w1MSOWHGFjRj04DLetRoT56J+/tb7Y56l1rWj5ksbErZ6AGbHNjHF4WdP0Iy7vWJV + f5lfeHDj5dh4r1+89B0v0+7xaod+RSf2OF/61mOix0L2IXp8JfX4k9ePMY6Rls7T45xc1SC+X2nZY487 + jPlGeJ6kPCklfqL7iTskMIk4lKpDHD54zQGufJfCGat6ygle2sxZcOUVbtpjLpV/SNUVr/CuEbbzlC+s + 6j3AB9a289yv+MhjLZNR69DggOc1HT9uKD71X9F5k99P2evW4zQfH+2bx1Izhty2xXe888WT9jrQJ7G8 + sqllw+9annvyxaWtmDDqj47H/jM/Sz1evbC6Uav6ytqs79yVl76w5rffOcnPush3bsYknMvr6qXvv/j4 + Oy9+8Ok/8FZoj1cx4lnfuKmMZ4Fjn/UrOnos+nGajw2wfuyEyZa034951jn0voHcY487DHwZME5KnbR+ + YuJk7XidzLogGE95Kz9x2u4/JF7rSqvGmIPzJm/EWCvtjoOPtRVG3H3vpbjVx4yhHi9upzqKtz1x5ITv + ueK5X/z0wU/N+OSfxXnpcz7Undih86XvN+0DOljn3KsSexzEqz1JrPc/JG3ul9sDIxf+Yi/8IQfWPXDe + xMzPeOdMu/nyIcYd9RpLHB+U4Rfez2ep82XxqEtuzccaPkfVLKx7z3mID37qrj9x53ed5p5rY07Y8Pul + 73i/X7zv70f/vl/6flUj9lV7rcekBfvvdj52xNYc+bMeuYe9byD32OMOQ89A5gnMExLS/tWJK/8UD6Gf + MWrxZEO6VmrGz/mwJYElR/zwLziw15h8aNRAfMzvtcMnp7iBU2atzin8ENmnfM+hpM85Syc+saoVfta5 + 4Bk3MeHUkd/SWMeEQcczlPEVQq/7zST25Lx36deaO16cso+Y8a/ygbOG4s4xf8y1xCou3+OOiWe+7MAl + 4JFDCR9x5lhuStnxs6f4gNbB/wh5nZv1xT8k69EHp+OynVN+2eJMLXvU8PnML57mjNpVv/mq9at//Psv + /tO3vpIvz37/Hz/m7dAeP+2I757UPtde8zGQrRjwxvRYrHkjJ2Pg7RvIPfa4w9CzCDoR15O08cMP3E9k + 8pDfHPjIaw5t+mUf4vzkmXZO2hXnRejKZ45s1e/a0z7Vp06Mvmyfs/gXWPM7rwX9oK74wL2m517WVX7F + oCWqCb3ih535Nofh4l7Om7H4YMbb77yu752sPXA57ScfJ+MAA0/c5JhWfteRPte75muO5q/zJb7wnae8 + tTbyz/GqUXHhihnfaomjGl4vOZKsi7j4kvQVpy0f0jzI0g/jEsXEFUf5zTNdc4as8z7PD47Ee/3igyT7 + pe/PNvIZSD6Oueey6/GAjb3u/dZj4o+L5/TjQs4h+wZyjz3uMPqN8Dg5dbL6SRo6hSexJPnEnZc265xz + zFdealwYFIetC4zj4uGiU7VCON9lPGKyKVmzcsiv/Cngo17rxtNmra4HDuyZk8K55E8bOYlFTWKVQ8y1 + 8j0XgjxxxWtu+yVZTzXQ+xWHNd993W4kx5q4LyHC13UPX+u2PHBmzdzX1Hg8lFO+56kWdc238D3P6wlz + rvyrGGzjZB343sNaX3NK1OeaW5yMswb5M7bU/gmYzzfrCrN5KIVTDy45HlO9xkKfefnS93//sxff2V8l + dDni14Nyz+ox5D6a33uKfa29t8dAtkQ5ygu9byD32OMO42UvYUvnyZonMW3GdCFQvIS+8x+SqkN++hH7 + DPneW+FWp+oxnnyzm+O54FeebPIHtsZYa9RMG7E1vuJZu2KwhQ2epPh4zB7kGK9wxYhrTsngHzznuA9e + 6k/jZU0eVk9+qHftQWpKrjt12ynOU35ypPE4ZI7iWUf1Tns2ainusat6jiuGvOZd+dDEWKM0MXE8pnj1 + VZz2M5f5zQHvCm/b5zkw1vG8soWTp/qjD8ZKyFFucUd+i3JKJ6cx5HRMWNi//LXfffF7f/lefogkPvX9 + 8/5+St1Aal/X/dYel629JL6K81bOvoHcY487DHwZME/oOBl5crrv8TrBjaO484SrRvlVTzUaL65sSnJT + aw6Ls57ixa/a7nc8scKdb72kj5j8kXNI9ZPY0hsFOOQahz3xxspWH6GXnpBDDnuRHjHlZEzSnBaPQzRP + z9nacj96Hb5n0vdJ4vsDrHWvszme3/XEbUz8rud7CF+1Z8y010/dPHHErzjnLpxS9QbGesxVjrihB0Zc + MdWrmNneC/iYy/NKwneM/loXPXbPxbfYFUe+5u4e11z4ionfHMMNy5ysi3l+9b/+fv7CC76f8rip/PG/ + 8fbqzR96CVt76PtyhfW+NiclOZIjVn7z9g3kHnvcYfjPkZWME5Un6RpL3VhxHrDHCa+YcR6cj1jORRy1 + Gleu56nOiClOe9bhHJkrTLyOeZ01p2KUiIsnv6U50588n1O+cxT3epozsYqjh5TAKJd1Eu8cr71y3U99 + yFvvP/s0vgqGh9iTHL1G9s21+LrXNSreudyPwYEoPyXqcw5xxWnd+c07tHKZ73zNvfKrBm3J5C75rO9x + x0d+YJKFo7qZf+CZJ94qGZ99rPPMWNdse52v+eEjj37a597kD7G8yqGvuHMl4kK6duUfdnxnYtxcxU1l + fPL7n//lU95yvVkjP0TDNWtPtF+9t4o3B/bk+R5KZy3m7hvIPfa4w8DX+NhFjiel/DpZTYQNfsXoD6wv + ChLVL11Y56w1xPFccSoujrDkQhTr+aWRK/+c2/vQONYkTPHOmXW6bmsIcxmfMfngeC34xvP65Ag7aZcD + y7qHrfqqDcw4qeWvmv3Rhzx/h4fZkxvqN/r3tfQ6obUv6Wtt4nmMODDhxCzWnK4pnbxDKuZ5xKGb43Pl + fOLRT4x41XI/NG3VWnkDS3/V7FVCPLTXDD3FuIPfonjXEK9rznz4nl91TGYctYawnttjTsUYv5q388wn + t2pY7m9987+8+IPv/smLb/zd/5Xfp/i6j3oGMsT3YNkP+blPh4/9Oe9TcalrXw/ZN5B77HGHoRvIPmFx + gvrJKcylTuyMM08SHItBN+7ziDfEeMKqPueWv9oe1xyOlzZ+1qW/Yp4Hu3Hk0B9Y10l9xSNX9oN1M6Ya + 0KuIqzlnbJmfc40cxUxWPPnsxXO7PvkxP4XYuzzUntS46jd9rYX+4FW88dCnWoaPOAWY1Tlyen+7Bvyl + xuAi12u7VF5wxKPteNVmzhpPyZgE/Tem9fR8zbUaifdckjUnuUtMNsS4JqrdPM6lea0ueLSr/sTO9YE3 + f6lPnuIS9NIxr1sxywkf+PN6tjK+p/Jbn3w3XwZ/XUb0rXXU+rhX2gPFfc0h4oqv/Iotsm8g99jjDkOf + wnbRBQ0nM3GeqDrxU8RdRJhOfJ30VY8cxb2+Ym6PeieMXJun5KK28Mo7xPtAj1aH+cJ9Ps8Rtub7PM2Z + POef/JgjsY55D+UHz+enX3UoiqVecEjYxJPXsZVfvubhnJV/CHlP7ibS1+j911qJyS+810TbcgbfeKov + LOeB+NziuHR95i7+VR3xvMbUXac5wmCfYux59Ou2eOFTUAfxiqXdWNdu7szvPOEeV27hwat6jcuHhH8W + z2u/86s+fWFlW8y5rsGF/xCv49JdW368tzI+pBIvg8dPNcaN5f98Yi+FxzOq3rv2tNZk6xHP+fAvcsI3 + LGT/FvYee9xhXP6UYfgPSJ3gJjqJlSuOTn7UJV6YzWN1kD8x1Rsx2QtXMed03ag1Y8WXqE7GwYe22pSR + HzpzPa95XbNx5TWv8yCYc+V3HvsS13iZI276HVddj8tXrOZ03sIZcRfiwYOk/6Rezr7qsdZ1WkNo+YwZ + Jv/SZo3CFRvx1bfHIHDG1vnUmzjwIap1jrVfHNZSXcRbvIY4aS+54Pc8lW+y+o2zN9orBr9t9eQ9rDXk + Qx6u6TnCy7c5Ug676y5xxjq/cfnKQQ1I1aBkXtjU4CnfYumrHvFD4pm/+CL0eNYSN5cfv/jnH93+5jJf + wmZfV30KP+2Bra3zDl21Wgvfz0Dusccdhj8D2Sdrn5gZCy0ht/BFq0ZI2F6n6jKWuOU65zJenK45sPAN + C50Xm9S6CCN34n2hEoaa5oet2onBd108i8tvXPORQ91znucSXjHxUzcHPMWJKS4sNeZPnLVlK6fitFe/ + ajN/rSluSfDee/ZkPlijXrE27q33HbZJcSwPmnkS4iUXmM+37qVr30+fDz0vuYyJm/aCjxh9YOgHopzJ + r1jkFAf4eY5l7lUvNdxXDcW8H3Fht+/x5Fu94tGv2KKLc/he17VwzaH50l84KY6R1zV6jq5HnBpyxmR3 + zY6NuHo4JH+y8Zv/OX8D/Faj3gPJHlLCv1grdPPUf61jsZ0fet9A7rHHHUZ9iCZORp2cdpKGjrg4rv3C + lVzjV75JccXxePCZI5644EPE1dzOF37GWIe5iqcvO/ATx/SBVQ5tCDgVj9y0oZEPXPlDkwN/ySHW8zcv + 4sVXLHX31DzHOi/szGcsxfyMO7ZwUb8l44dc1c34B29/+lS+4sd7Rf/S7H9g3AfGFRsY15u49kB4xaYW + Xjpjym9ctYStddZeBt/8OY/bvXbH0l7mAxeiuPiJec9jPvJDigN75K759MVXnVFPsvDLvsIO6fknnnbi + PUfNbXhot70GYm0nnrnNHbmp25Z4Dc9znnCXeO9k/HJO/BzjD/7XfX45R++BVJ/qDf0Dw5p7Db7e5Icv + XbHG0z70fgl7jz3uMMZPGcaJupys8nWS64T1WNkLV5hO+FUjhrkliPfFQ9iw15ryWa85i31o+cBmnviw + yaMPDd8xl3ONrjNzm1+ac5VO3DmNeUw+MPbk64l6Nn/xxzzda8aZrzwI60XceKqTfmrVQr3mV/5HPPTu + OrIX7YHWu9jVM9epNZ/X7hzY637A7jzhgZ3ioYkr5rjny3aO/Krt/OBREO+8qhV+2oynVs3WikNYu+Zq + PGOsl5ziIa6cilGKf8QLV50HMM3tsdCq7zWdV/OzxsDMdp7HvKeVo3nA85rQKZ571UPEyQEOX/y4Yfzy + ccP4rY+/+2R+FadewrZe1S98CbHiibvEKj4f4/D3M5B77HGHgRvIPhH9xJwnMy5kbsOH5ElefMXI5Umv + nFXEOeMS1aBt2ucMzLXinlu4S8Znf+DaXMaRD7trNPbAPBT1Ijtx1be6pzrkIGY59D2nalk91WkeRLW9 + HniMs4aL5qsYc4UpDlFPjD2BX6zJvi97nvtWYv5pPZFTsdbOgw0R9ySsVZzF99rZD6V8xsVBbueJUzWV + wxritda8qjN957gUFvVrTuVNfvo5f9ec/MNnHc9XXLbyhs8cYJjHeVe4ck/zDA5iw/b+yJUtjscGJ3xi + Ob9xMD987yVeko5fvfn63/7Vk/0eSb2EHT2rd63H7dqHWLfWbpz2JdwzcsPfN5B77HGHUe+BjBNSwhMZ + J7Bd4CyumMfLrnzyM7ZwzJ48m8/6UCztwMVJnFzaZx85XUexpa5hKcvcWbPqWi+GTS0eMXEPkS/uKo7L + HjUixvzL9RpfvrBLP3nAThK1WV+iOTVfzUte1SXX5wj7l/7wt+/629nqr/vCGtRjrbGwXo+LctpnnSt/ + 8DqmuqkvOG23JId9KVd42dZ38tLvHMkVX304F7nMi7gkce+j7eQ+IKqFnNaKlV99MZdzys55Ul9hV32B + B6z5GT/sEUsbfsaK63piaz3Fam7W8V4Ko2Suxw7969/4cn5PZPxM4usw/KcMaz+4prTXdSbe6y2fumXm + BH/fQO6xxx1G/xY2TsrLEzRkOal1AVhjaR/inLAHzzjh+9yKK99ryC8euSmMS4vv8xS3+FOvnM7vusVz + fsa6juav+KjRtrjF8zjziiP/kNVX3ohZrcSsjuuX5QGHBO7x5snu/NKS8LPWwWn8rl/tEz2gf/Q0ba19 + +uu6Kie57UuKqzzLP3GX+spXbGhyUhKDVn5zJf04jxyT5nVu8c0WJ3npN95x+pFjNZSn2IlD7TWTM2L0 + PX4RSzlwzwd/ckfOWidz6JftOPMG3tzyiwP7pdiRU/qQ3/vWV/KLxZ/Ky9I/zYgP7WgftK5Y52mtEvmO + K/cQz3Udsm8g99jjDmO+hH0+adNnbI133nIRXMR5VWNgnSc/Mc6PucnJeec8WXP0es5VDuzmiwsefcO9 + riTzV9u4XeuCQ13YIeD2ukdectGT7PKLZ37MoRzag2c+eC2Od6xzwtZcK1656YuLOs7xmr/0h795t2ch + sT6uoXqElq++u3fb+8Ghb1jYA2es8o0HXMKeZBMXVrUoGaOM/tInjzG3PS/Fa5EHjDUrd3JO8w2NPNcQ + xMVxfI2t2uOjB81DPHmMD1lyJKiteZhPHoQ5D2CNt17xnpuxnNdx1Irfzo73Mv7ox//KW7HXc+BDNL2+ + IdzzsFOve0OO4uKeY9D7BnKPPe4w8reweSLiRHXbTnDD8qTVRSEvBNOu3ODUid712m9+816incPanitR + 7cKN6zHVds7AF9vjXav3JuOVh3ky33LEUUwY+OxNonqDB+k6mF+2aqrOqs82e1pFMfEPzOs6VzXEr/ih + leMc8d6647OQ6kG9VV/su9bg61pscSs3bYuJT17pymnteGnlm588auU1B3b1oJjxO0di9anFSVnmEia+ + xGvB7/U5D7kQ8KYe8Zhbcw3NuDjpn/dRc8seHOatcjVvzzFtn098r5/59JXrebJD4qYxfhf7X3/8b7z9 + ev2HPkSjfcRauae29uKEbbwW+cZlDcm+gdxjjzsMfQobJyZOYLd18sLmiesnb/FxsjuOXMuz2NCUnNP0 + 2eZFJGt3z6vdcl1Ddor3ImHMubJXPeLMDVv+2u8qzut+mR9+1GQ+OL0uj8tXnup53prjtTJODNpyFv7g + jjhtavFGnKI693oWUn2OtVivvQbEII37GpzrOY2zNv3mGI+SNYQXFxzFUljPa6/zVO202x/zeixylS+h + n3Mnt/NKW07FTzZ4qR0rG3ss22uWZD5iQzMeNtYCaVy54Dh/2KxXuZUD+zwf8fIZeyAvfeGH5DONn8Qz + jW/OTaMPvQdSe5B2rh+PNfao911cj4vfMWj54u8byD32uMMYX+NTJ+w8QeuEXeJD54m8atRc66coLr7h + a3yNed3ECm855ZPXuat/rnXKM3uNAydPuGuT4jGmWqjL2mu+c8OWCKPuGtbHIYVVDud5SJgjX/M6plqy + a47yl7zgK4f6Xp/Irr6jh9KzR1/Lqte1lW8CDDUUT07UcQnMBPXQS+X8BFHdyvW4zeGxlev9+ZzJuehT + sbU/8SvGehLFKidqS4hV3Liz1hIfucCd63zxirv6o1bPLa5s9zWX5s38xOa8v/b1L/Gm8fV+efonjfju + yV/949+v9WO/lmNTe8aY9BkTdx5rwsPeN5B77HGHkZ/C5omoE1QnLk7SPun7xG7umrvmeT3HPA8x+OIV + ZjrjlFljct1XzcrNGNenmLAlLqxiabtwLRXrtZ0153RhPfnFEW7zIQ5M/I7bPkd85KPmyml81lNMss7j + nJHHOIQ4Y8KvOG+99/YnPBRvOrAeia1l9bk24FMe5nC92qfUkwduxzSn6ynILy5rDV/1pWV77ALL2sQ1 + j2xJ8UMSQ5+y1aPwVSsPdXtdjZEjyVzo4TOOuRhf7CFrbtrcz7Jn75XnUnxJ91+21Q9bOr6j8Q+++6dP + 9ut2XtWIl9/ja4Xi0+Jav+9LaZfkSeNxuMpNnCLbsX0Duccedxj1NT4SPznrRIZeObLFhX3wzC+MuX3y + kxdiuZDmlk8bunO8rud6zHPAa77qpl3cxpVT2sVqN0c5rEeObHF9DohxDVf9tVbFWdOx9Ckea8zyFhGm + Wp4bsapz4NKFmSCfMXLhk6P8Q+7x6zToW32xx+oT/ug1fe6JOKk7R3mZcyVV3zTrykcdxYGDY/pCkDvj + qgXNWunPuNdPYQx456LWOSa/8g6dMuq1vfJkVx3xDp15xQMHwpj4liN+57R9rTW/+V4zhHZw1MNVHBzU + w/sa/4a3V2/u+M4Pv5ffSYm90f7Y3iyY9qf27NAZqz3W43HFU8y4B75/iWaPPe4w1g/R5IkaYietTtyX + xZuDWhHTya3aym/cNHMqHjZzZSNGm76L5yk3sLWGNOLwxYPuXlWr+ei5MfqyyctcyRJ32zGvi5g0OUcs + bEj7XV9itVmz8PK9pvK7liQwiGzhzU+9xDXPrCPNuekfvHd4ON5sVG/sH73BF7ZyumdyUzfuvtdDffJU + M+OcY5nH+2iuxOYzjuaI8/mt999+9+B+pHqKO69qJNZ21aRoTs1fHON27ekXZnjXaq06ylGe+Iorp+oq + 55TrOaYz1ra4zk9cmnHZqz/ymBMv23797/7qxf98w59tjK8Viu+kjGdXtafYS+xDCfdFewUOeMUlvvIV + d1u+bOTuZyD32OMuY/0QTds60SF+4vaJPU/oOsnjIsATWzHxvJbbKwaftahRj/5iX/tHLfai+JjDaqP+ + Oj98x1wSz7zDtxqIiSOcnMTm/Opr9ddaiqOe9Ra4C/kjphqJs+aBn+fqOZ1X+SOnfeiu4XWUJ19xy7v5 + zxtqfvWivrNXimId73Wk1Jpelu/+oXO9xqXPfVg4yOuYi+cpfmh7T+kvvfvb/1v8YT1uKH/nrQ+effjW + +88+Db76KWH9iq36kHMvrZ3X/K5XvIpNbLXnvKvfWrFZ58DKPvClt7UesId011BeYRJi8bvT339NvuD7 + Zx3xEnW8f1MvUWuPeq+4t7kn0GUXB77yeg+bc5W35sOHDu6+gdxjjzsM3EDiZKwTMu0+kXWyQoBPLvA+ + wWWLy1rBr3q6KLSonue0bjz+640L9h/99Z+9+P4/fpy/zPCDT/+Bl7kXL3707/+aWEi8vBK8eIlF/y17 + 3ZQDCz+xigMXt/jEyjap/JCVe8iowZgw7AH2b+Sbr/ritO48nwN4S+IVgy7RfNKHZI70wK81bHBH/fTX + GrPnuNnhIXmTob5cjx5DG54xsyHkik878BFLH3zHVWfm0qesedc1pA/5CR9Kik+9/+L7z38lbip17td8 + VlNzFe76EHGGrPiSEzb67NrOT9tziHss8+hfiXOrvtXE3OCBC1y+MNST33yv++vxgZj4vsbjevMmj7gx + just9gT7Ilv7pT3RPnXs0LZnig/xGG3l6TEImXjXCs6+gdxjjzuM+hCNyXpy6oKhmE7i1Z941xM2TvyR + L9s4lhOSLw397eNfGopPP8b3rcWb2nFDifmrD86nfhRTL8kh7v1JOs4ccahVL3nKW7CyXZg7MErXxL61 + f8RZPyXsxRcXNnoujBxgHfM8iOzmp6ZUrQX3enFTw0PyJsN7yh5cqreFM/pe1kSduHj0fX+kKzcxiNuQ + 4HIeqwUbIlzzxY0hl/iZR7wH9QvvPfviMU++9D3q5jzsg/NmPxJhMf+hw3aO53pOc7k+w1NL1hhFdSGT + ox40r/yZD75zRqxs9k/7P3ztd/Nm6gef/j2vKG/miJeo4x9vXSN9b8qP/eYeujSX/sJTbu1zxJ1PvHKN + A9x86v0eyD32uMPI90DaCdw2tOw6uY+4TvKBFzf8w446yXW+xULTrhrkV+yQ+DLaeJbx8xr/z/GH4Kt/ + /c28UFZf6oO9BabetZ6Jt68aa1wxrW9ozZt+5zmv4xe28pc6kMZWzoo9NFdoScdmn1Ej41Erba7b5zO8 + 8g6JvJ/lxucxw+dHD+gV60RMfXqs1hN64a+1mkNfHOYNPjXEuIk3Z9QxUW+vah/jGZ14NhMvfb/9Sc4r + 4VxaV/XmIh5t56hXX1OtkTZ4tv8j3ryOzZyID39waAeHvBTWdF92XIfi5ds3ffzFx9+tnyDUPtae+F4x + frWXvd/LY1dY85V/xauayUOtU/ywQ+8byD32uMOoZyDzJDVN0QmbJ6tkxC988iqWtk78sx92C+JxQ3fr + 9xR9/58+zmcX0JddqNjnWFfYjCfHY4XDTqm41WUNSedKW22P0e9anXOuCQ7mJk67akkcC01xXs+JvhTz + XhT3uV/OTfmQh+RNRvURvbEP9YmY+Yqv4nFqrIXrpg0hL8TyuHbjS6O36rH4whvz2Od1Ix5vMYhnieOm + Er+f/+xT9Zs9qQ/15EJ89H6I54aWKG/di7IN930Q/xRfMPWz1lQ/yolr0M/D1+/EdzbGde+Xv/ofa3/G + vnGfsEe9/9f+oW1fe09Vd+5125CZ2zkQxIBNvV/C3mOPO4z4Y3A6MSnjxD1iiPPEHhzo5MhWDvXgUUvW + 2nExu+f7iv75R5/ms5JxQVVv6Jn9Z69cG6Vxrv0KYx3EaD8QH37o5E0u/Oace/IY9r9tm5OY6xTFXUvE + oaw1y4+45Y0ek1f2TT9IE/NWv9bLwChah+K+BvcL17pSM77WP3zXjstuTTu4xhcuO3Nv+Ewurh2zx+yj + fGGQwLG+XoO4WlcJ1+p1PO51K/ZgjSPOmObyHtyO2H/61lfybS5v8ogPxHzj7/4Kr7xw/bUH8rl/2C/s + 07p/yHHp/awatLW/PkdyH+BIFPf6FaO9byD32OMOY7wHsk7c9ktOHEn4Ep3Qlpd85Cpn4EM/f/EXH3+H + l7j7j7jIfjnfPK7esQ7tw6q1fknxyfG1yy+M3NM8hbMe89da4qTNuNeRjTqYt21occccGesczVf88hfb + ZPW9hmJh85C8yfA+Qms96ql6Hr3aHi3iscG1OZw39iRi7AFz+75IjjzVIqY8593yrQD5TGT2jf60NvTT + dop6pVz333vmdtWQVI7zDYv4klc47VH/kP76nf+XZ/+bOfI7G78V39mI/fB9q8fA9u4SX+Kq47zVVw7q + HZhih17rJGb88okBn/F9A7nHHncY+CQmTt715BySJ7ed5Dyh/YQPu054cRJT3GISckKe6nuM4oM78R6o + 0xrkL+uETV5ygEmcV5p45EHaV42qabj8k2jei3kkmqv9lsqnOK5ang+7uc5xrXzPlc9D8iZD/UmqF/bj + fYqrdb1sfREL2/M8HzHys5btAznQE3NRD7J9nlvfQKKPufbuW2tFb/A7PsTW0fVsr1IbP8Rqap7is5Zk + 5Sj3y//tzf/6nXifd7wUn6+ocC+0f7VHtvcVL785l7mH1L7Tbky2HidxDp31jnjUsnrKA7/jyi2xnH0D + uccedxj1VR48If0kLTtxcsxX3HkdtwsPJXkV64tJYK/DG9TjU+DxKUysBeLratzWRqzt3oPEIi99csrX + HhE/RLkeT18x44ojW/jD86BW2cVvH7bV0RypzWd88q/rJsZ8HpI3Geov5vb1yE9hX23bWg+p/sWRqE4I + fcxHXzbjVYc5c872J+d63lveQOraUf2mrccV/bhUz2kfOvnQLsoVXzXdLsxrL3XXePoHHt9jGOfym/z1 + O/WdjV//ku1b70/uy6J9z8RVXnJCgp9x23+PPWAnd8FrPtqOy3ZfvazzBrZvIPfY4w5j/RDN1Yk+hLi4 + dTJLnHeITnr311rxLMDrMuIN9b9mF2Wt6+QTGz6x2oPyocNfayqunMoNWetRwq89X/COS8DzOYZk7MBt + rs5xXDFgZQfXY+VDV53D5iF5k6F+0Df6UG/qr/qNWPZpHPGpVechAafnlO/zCtdcg1c2/BWr2I1vILOH + 2oPuqfoRZhzgwIqT9lyX85WfwryOI6d4JuLFs2/xdpT4wMibPOK9m3E9vdpL7BHwNYbHYeWsedC5t7JP + nOvHwmuf8LAt3jWsB3IqX3hi+wZyjz3uMuJrfOqkzRMaJ2+fnMJXOV8sWgvvmld2SPyH/DoOfbEu1oS1 + pCz7kfYqxeM+pA3f+eVnrYOrGHMe9A+pOmsuYy32eEQ8+Y2rjjjFT2zmFGZzOt5Yz+f1eEjeZNS80Qd7 + kSimvmbs0BfrLduwii31hXlu8RL3PUaPhYlvuT3v5/cp7KsxP0Rje1V9NRY9lh9xE6+htZSwlsd9vSNH + NS2ur9+JZ+Te1HH5nY22D7Uvy/6ErT302Ippz2vviYELrbyr/OKHbbySi3j4qqHY5DQWvP01PnvscYeh + ZxF0UueJKd9O0MBS6gRGXH7FLvyuSSxtXCT8F2Ret/GNv/u/ah9qbRKuUb7WC+EF1mzhuW+U8iu//ROH + tvOqpuUrlnLR23UMNYS7rzgENeRXrUXE9RqheUjeZGQvtT7vBZI+pdaSNn3aiYtvWnUrl6Lc9ttGTdXm + HqYtLnMlzOncQ+7xDKR6o8a6uzfZ4rh4bOS6aG0PzFH8mO+QX/7a7+Z7/t7kD8TEDyLEr+DEdzbmurUH + thfrvjiWe5m+9h17WnzqwBR3fsY9Rl8c2eK8TJdoXtk1HzDZlUdOyH4Gco897jDyjwBPVJ2k68kKjZNY + kj5P3syhXbERX2LE41m8133EsxvYI+5BrtEvelhrxhnLvVljqSWeT/5aw/hdD32oBrDOFVb4he445qgY + bcWqluHDvvIP8R4qTs1D8iZj9HLMf9oH9lT7kBzwtR9jLcQDm3Wbozhwx2RbffqeP/MMT5/xO7+E7X2l + PWKwRzzs4HBtwrSeshep2pkHOz5dHJ8yfpNH/DxrXDf7vdjYc+wd94p7kvsSPqVjxGgXV7FDV17YFNUD + v7W4bos3bKtTfsSpUbPjkOZUHn1hofczkHvscYcx/gj4SRq+Tt5DdCLrBK+Tl/jqJ9+wuhDQDnlTniHQ + TeTYM9qBa+3ak441J3Mk4lC8RuHm+9yq5bW9/ohnrgQ1fB7ldo78aWvuql91jZO+8w7NPOE8JG8yuifu + TfTCNUvPHrEW+cBoCwvttutDgn+ez3Byfa7CJRbX/NVH2Le+gbS+Qlfv2VfbiHWvo2fjN8/XZ3VCOE/Y + 8bJtfGfrY3/i9CmP+F7a+IohvUSt/an94J5c+tor7qviwta8de9LPJ+2uIPnwtqo58I81fQewh71mzt4 + IYbtZyD32OMOo97HpJPxEJ3kOjl1EidGyZwrP/On7zzF34RnH33ETaTWmGvnPsIX3usXdiVXeylB/MwX + 1nzo2n/rp3O65uBYTsUoa96Yx/LAQVyY8kddy+EheZNR8x8yejzE16P1JSewhV82BVzsTWONV0zzmJ2+ + zTH49Ctv8Jp7+09hn/uTDTl8Ys0zzNbRcdQUplpeJz4Q86Z//U68RP17f/ne3KPD1v6cxPZH4nuYWHAk + jrswjn1vTurEybHYmoMYtLjO91o1B/O9lvKUs8bVy34Gco897jD0DOTVyXllz5P/0Dy5V7wuHsR1kRD+ + Jj5j8Acf/Wmted2Hh/YGMeMYXnuceua6ll34wYc95+oczlP9gCfbceWOvLQbX0U9eI1LTY765SF5k5Fz + cl7p6KV7914hyaWI91CdgTtW/oynHH7Pib3TvOih/SuJ+K1vINHzMX+sZVmf1qLeeg3n/fEcrVH5wPFs + Y/x6ypv89Tv1s4L2dWHYY+6b+dqjsW/c0/LThlQ9s8Hrx6ljXt/iy2MmuaqREnxKzwc74t5P1Sa37aN2 + 5c8czbufgdxjjzsMPQO5XgBwouLE9ZM446aV99CJLSx8YfHG7zd15DMGXLevWXsGTDYk4yG5n9LaP8tn + /DKHUnMWn3bGllyTwlVvaNRAbWCDe2Gj5uQrPutxfYfwkLzJ0JzqQz2mpgz8EPTbfctXDLpt5a4cyVoj + xec2zLlez3mB3/wGknOrn9qvWrv3p/6BaS2V52Kx0PFp6jd1+KeotVexB7UvxLRvzgEOQU5rz6/c8DOu + 46lFeNW3GjUH9UM8x6oe8ytOrRqeG7bn1LwRT0z9ig9830DusccdRj+L0CcufJygflLrxIXIZl5wI9d0 + 4sKMGy/NvKkjnh2Jn0XTnlztwUO4Yr1/wltHrDHmG5a56SPmOZonc2inHznihrDG5AGb/M4f8zlXfsZY + p2zEZfOQvMlQL667z4e0r70x2SVjP7wuuawxtGzyUEPa4tSo1f2If7cbSPWxSPUZfvY4Y7I9PvaOdd+0 + G8j4FHV8mXl+0TcfO6219oB+ifna17lfHZMvbEjU4ZyaV7UUR27XcQ27+y1Z6z7AO8UV89yyO+bi+SH7 + BnKPPe4w+nsg+0TNkzNOVDtx+4QFHhpiuSbA++IgftR6k7+TLUb8dJj2z/fG92Psr/SKXUjWOOLa37nH + s77vuTDxknuJs07ms17anSeex2Yd872O4VcYD8mbDJ+/+n1AtOb02bv2Y2LwC5d9xFPIVWzIgmdPlqM6 + Q4tPP+QeL2GrB9nqzfcV+0Vf/VvfK8+5od+EG0j9Okx8Wrz2S3vB9WpfgLee+wWu+Mr3fROWtaidKzx9 + xhJPjHHHyXdRzHOR45yXc1dda0jbuBYPO2IZJ2/fQO6xxx1GPYuwnrCHX7YLcXF1IrtUfDnhw3+TX4ry + Ec8u+LrD7v2in/tDf+FMH/HWvc8lD9QKKYyiXPEzTl98SPOQ1zyJ89faOZ/bFlde2sR5SN5kxHxaY/VU + PTauWK3RxPOcO/yqqXrnvKolP3IMG3ZyoLNGxiRH/Zt/iMZ6oq2+vLfZb68rNaXWEPHiQr+u1414RSI/ + DBM3jbEWrlvr0nprT3IffP22VyGyjat9A3/mr5yc12tIy3afWNde+ko968KGnGrKLi5s1HDc68EHb87v + +L6B3GOPO4x4BhInYZ/AfeLi5NRJqnhjllMxxCHEEwMe7/X5eRn+Jb+1f5LCV33wuI/C170UTzUrZnlX + krHk+GOpGOuxr8aaf+I+wEk76lDcF0+5xTt8HpI3Gd4rdPckW315jyNuscLFJX/EDgl7xIWlJp45nVc5 + EZef2rmM3fNDNNmHeovefd3NcVE8xeNWL+R1uoH8EZ9p/E/f+gofn37MZde6aWudY/0hGWOeYhTHkN91 + 2rcc1vP5O6dzV24J/VHTObKJn/pgzLHmCOv5ZRc+8mef+wZyjz3uMPx9THWS86RsnCfsGjvs9cSGli+O + 5Pnn/tUb8Yb0mCOeAYyb1ZD4fdjv/+PHN//0ZnyiUnu27uFp3xJryf0tv3NTF4Zaze2Yc6CBAb/gVy9T + J855IY0rb50jOZVHm5zMlRCXzUPyJqP745rKp62+Dul1XWuvkxj9xi22aI9BN561iY2eaDtH2C1fws5/ + PrVW9nPqlXjagZNfXI9LmC9e+L/5xG8g47sa45epfv0bXxrrKTvXLQx6xRVzaQ7qPFjv8FOIDd9w1J21 + vE5gEOYdkjzVc7nIDVtyqmWx5hz6iLXmY54x5pIn3HmK76/x2WOPO4z4FPY4QXWiU/cJ3Cdrx+yCobzE + 224MJ/znMeLGML5MOD/FGH0c4n17H8GJ75CLm8pb3FDGT6qtezmE/Z7sQ3y/07a49rPW57nStJW77sWs + f65zGadc+Yklt/GuxePHa9GWz0PyJkNzVl+0oSHrWhQffZ/W07rrYQ7VEsdrlW/ifNRQvfZHzUNuewOp + a0evM/QJi7VJEoNWHHLG3H+Kz0DGP6V/8N0/qQ/Nqee1f2Hag4rZfvTjqP0IEZ9x5npM9We9ri8bNdjD + 4NKXZI406xyCOSFVg7xh0+8a0l5LGrWGb9rrlaYdORDsxX4Gco897jD0EvYqfhLrRBXuopO8ODzRByfq + HPJ5/BGIZxrjZ718Ltjndag39Pv8xS9/9T/md6794NO/Z7VXP+KN8zGP9ijnp3jP6qtx9q6eKY6JIyy1 + 8RpnvuU5H9zJkTinYsZBrvXLeOPKtzzGmwfNQ/Imw/tRn+pDknFK+hkXh5hirCXJ+tTKhd91ErO8ERNu + cyeWfuuIZZz8278HstemHro3+hLHg0txntYyeId+Cl/9Fa9u/AW/3FvntNblGo8J/LKJJ8f46/7NvI55 + rup1bOEHj5hrzxffpeNdS9zMf0hqPtgr32s7r33NxbyL2Ip3HLJvIPfY4w6j38fEk5wnZJ2oZifumHGU + v+riH/Iqf30m3mdUb0wPYT81r+wjFnr0k7EZj5vb+PT05zHi2dGrPdV+qo+MW28edxFvrQOuNPMzjpzU + hXWOMOS1r/mU73k+z5qn3MLlm07JOHghPCRvMryHYUsOP3qL/rt3xLQmccsnVms0XLklHj+070PF3F9r + VF7rqHHzl7BrbvXB4y6EPfvanNdr6BzxK84a93gGMl6hiN/WjmcZ9TOC3ZP1yJ6FnzTXVrzU7acddShr + TH7lk+O1ZGeN0BTHUc99i6fNPK8RtvnivyxvxuZ857hiqgt/2IyH37oluPsGco897jDwNT44CceJm/o4 + qYnJx0mLC5FEObLlr/ar/ABN/EHJutWz+ll6Uf91EWpO4osdLzm/6q8Z0rOQo6fqe/Yq/9TfEpPdHNgr + vsbLrvmnDek8iefLF7bmNX742Te5PidjwkJ4SN5krGu86s85WEP7zl1rKY4Y41yrsOYAU97VHMDVU/fm + eZK7fApbc4fmGuEfWr6tXXHP0Vq7hjT4t7iBjGcYv/M/4obxT1/8+je+nPOqrxT2M/tTj253nscmxj1g + zYwzBn3BlVTOgi+ifmQ3zvmqn4lljnTFJMYJe5Wo6XJgV3NLHBc/9MrR/B13e99A7rHHXYaegfQTs07m + BceJLJFPLnFwjWN1vv9PH/NS/bgRzwic50Y/Pp9EvYi/9i9c/Hi24VW/rI1nIdmjzZ+SPfUFcsQoubfD + dz7xB9bt+Akbsa7n9dWfeBJwDDvNP3PkI++ws+4Ri7xDeEjeZKx9+Trkd4+2Dq5RfOe4VIw5ZdMv2/yx + l6tYjaEjt/Lv8D2Q6s+FPUU/ksDXPRbWdnCZH9qwz/sGMp5pjFdIYh6ff9gX/uj30Fqjr0lx5zqOPPAL + IweCXHHaXzHWWMRx569zpZ29TFF/zlGeS/FTz8dy2kedsLMu8bS1Vs7FeNqrjpzIpewbyD32uMOoG0gX + npR5cksfOE7sPoGFKwauxRSnfhU3kH/7T59UTfWjHuE7Rtt6CMkeB0e9M3Zw4rdo46s4XtX453/5tGq3 + tt4k5vuaRlycwcVasyZj8lVHGDT8WQN4clyslvjgoa/WijXPcdURNvKOGA/Jmwz1k1q9ZH/oyePeqyR8 + X0vizBc3teZwfVG3uBThFTM+pHnlH3LrG8i5BvTga5AkTm5hwVOOJPNge96tX8KOT1XHtSZeNckbS30l + F9fl2nsN7X27Pbi0JbWPxmmZdWqfFxs+eIn7HLIPnZzwFxFeNQOn7fM7VrXS7xqKzxqHlv8AJ2zxUL85 + siVeZ99A7rHHHYZ/iMZPzNR2MutE9ZPb/TVfmMurGP7S9dpbSuLqHbpscZx32KGjVvuIh7zKn12MP0Te + R84zNPrQ3MmTTVGfrZkjbuKIqaaw8os3bXHbbzzzc/5zfmrmKSZR/jnnzOMheZPhc2v+7tH6Y69YB3mK + UZJbPNgdm3uDOpyLvMyRXvGy+RhQqoYw8e7wDGStiX3Idp129Kiek2d8w1NXHrCn8jU++TL3D7+XN5bx + Hmy8N3L2rnW7XWsJsTUiZjpikgXzfRJec5HjchWrGks87KipXiYOnnKrp5/Aq3hiLeJ4TopyWK/wQ8A1 + jmOH7BvIPfa4w+hnEXBy+om7nsSFjRMdmMQ5joU8dsTLyrpgaJ6fNOfwo2+KcMW0DvE0T2DxvqhXMerZ + 0xCbr+a1OdueWvHql7W0Juc0Du25g1N+a/BQH77j0DWnzbHGu17PkxIx5VF4SN5koE/r/ZD0U3dP6l38 + wRm5jWUu1ycfuR3zWhL3UQ/9ebzyskZzhN/tJWz1GZr9oOczDmm7cXItR/hvffO/8Cx6miO+0ufrf/dX + +RVhehk812br0Vrbn7pyyJGNPehasrWHwoWVtrlKsh60fNmap2qSO2X2MX1o2Ws8xeZNvs3v8cxLDvJR + CzmaRzpk30DusccdBm4g+2TtExYns3zY86S9yoF0jvD4T/2xo57B816WvmA3x/soyZj3zX5lB5854cfL + 2T/49B/YxeOGPs1Zvdmc3rt6RFw8w9mfS/Nm3OsnttQom5wxn+LUEuV2jdbnvMlzjiR8HpI3GWOtp7V0 + 36f1XvDcV82qe8jgFZcc4aaLb6IeKmfEaEf8hjeQ+gBezp+9ca/UD2Oj91ojOeVbLjHnPoWv8flpR1wz + 4m0w8Z5tf2+l1qk9aD3xlCPH9+Vq3xwPPfJDLrjFM7/zdRz3se/xUZe1wZn9K1+1Ksf9tBtvzHtA3HPA + AR6ybyD32OMOY95A6sTUhYAXEJ2ojpHfOdDieo3wX8UzCHEj53PXPIc+zwuseR4zveZSg68az1/8+te/ + 9Eq+eDw+4ameNC/m1LySGSst3PUhkQMOH5/EPD5jmWt1HE/bNPJVs7XHxdc8xS0cWPEXiTwekjcZ1Wet + j/6hh1Qca3P+4CU292StH7bmqFqJmb/w5Jd9CPhLr+Tc+mt8tMbs30Q9Qro/xOx4SN/iWYsxq/vUn4H8 + rCO+Kgw3lX/Kt+Ng/7RerV94xcnBvpKfth1z5JRmHJr2ESs7OFWXNcgdvLTxOCoPPmtIIn8Rz+tc842n + 2NSeD+xK9g3kHnvcYfivSdQJvZycikNPv2zlWb6f+I99D1P8N1/1bS6/qIzenBeSXO/ZYubPelbnkLjo + P3bEOmqO7Ekac80e2y6fOYqFVo32+2KrHEnj0LKV57GVozka69qoQYzac8RVfOYA5yF5k6H+oOc6tL5T + 39TFMT/jQyumOPiKdf4Fb2jgzXfuOef2z0BivVqb91nYaZ0zFtrrgMM4Y0/9pwwfM+KtOXFT+W48U/nN + vqmsx7b2ZNnr0LQ7p/dO+fKFtd2PheMpwqx+C/zmsU74xu3cxtcc1HIMXPmVZ74wScT2DeQee9xh5A3k + cQKm2Ik5sSV25ZMb+gp/7Kco4xdnqm7NAT16ydjaj2lKcRL3GuQwprhqx5voHzvWLyXGHDZ/YOkD87hi + 1aPsjJufORfrolStE6/nGH5hzRcmW/jIS/8iRhx50DwkbzK8d/TEHgPPnoC572uRnNfEGuQqX5jsjJHf + MvOdr3rKQw3MiRhr3PgGsudXD60dF6/XwnWO9QFDPnJgP/768bqN/D3/v/urfNvOr309fl8be+R7qL0q + zH1KPw7cb9kjduiKLXzijtUcp3rEKY3DHvGsIx65xJw3cgyDNLZ/C3uPPe4w+n1MOCF1cl5fOBbs0nZ+ + 44/9A6D3P6oHzZH168Kz2CbKFX4Vv/IdD/tV/CGLtagepO3Gjzm1h1qnhL5y1rUoljZrYI4VNy79xlbN + PBfrA1p+czC39Vk5biPGQ/ImQz2o9+wl9wC9jjj7VK+uZ4z2RZ3imoAj+9AUzEu/eDYvMXGdc/MP0Rxz + e99td38Q+N67S6+j7faf5m9h33rE16Dlp7//sj/9nXtFyX3V48H9K1xY+s0NDel44+I31+tJe075lK6B + +EM1FHO5zp91lbufgdxjjzuM+iRlXgBwMvaJ2Sdo2p/hIhEc2AcvbPqPffk3/oCMub0Xn9O05BJnjupU + LPClnmyt87FfMh4vV/k8sjWf96M5JbMn5HV+S2KhjZO5wi3uOcWxuPy1p/B9rq4x7cotnq8POoSH5E1G + zqm+OL/6rv4pk8Pe17WYj7rX+SXiPNADbNSetUxzTp/7rp/Ctj6wrsZGLPzFhm9Y8aHf5Jewf9YR78n+ + 9g+/lz9SEC99/4d8j/iyl7GPJuv+SxSrxyykeI2hLriNeQ2L0U7fcGHtd+3imU6xemlLiO0byD32uMOI + l7DHRSFOVrfzxNYJPX1h6fNkLtEJTomL3GPG+I/7qLdq9KI+Z3/qR3bER8+MndbhdcOmH88gPmbElxSr + rvfkc2o+cR7sLzm0i9c48jnPCVvmzJjijdUcGZs82KwjiXqZ0/Mkh7jySxPjIXmT0fPPfVCfHhe+cj2n + ecQzt3lhKxd2x1Z+6vRtrsTpK+b5zLvHTxl2393f2qPWlL5zl7yJ0z/s/QzkZxv1ye+P8HOM2lPt4xDu + edj1OA4s8hRjPuPpFw8aeItjnuN6Ssc0v7REMcfD3jeQe+xxh6H3MenkbN0nvew8cQ1LnCdyaeO6/9jf + wca8Xbd6Mqx8CnizJ+mRf0jyRhx5lS+MuT/68eM+kR03xDnfMmfUllxhaz/yk29xx9PmXLJDKyZpDmql + 0K86hc0c4TOv5wps6BU/fB6SNxk+f9hrz+3DHus3O7T2R7GKs85ao2WNIb7mSxRLnNK1ELvtp7DtGUjr + L3X2xj6ptT5I54lT6w9feZR9A/mzj/j+Wb2f0r9GbDwG6fdx1Bz4/ngoz/U5t/PKltjje5nHHMjMF+b5 + ofcN5B573GHoZag+WeeJuUrHJTjhddKfdPAP+7HPQKKe9SD/0Joj5oMQo/xkvNe61uy6jYcd/+U/ZuT7 + INf6WXvuXeCIN7724j444Mm/yisxvmpprjNPPVznDX5iXpM466bPmln38HlI3mSoH/XRfXHfZF/0u/Zd + eOW1ZH7GwZEWrhzkXeCZ27UdU33FE7vjDeToe8WyzzNWOuPcU+LyQ/YN5Ksb//rjf6v3U8a+/vJX/+N4 + PLDn58cAxy4k+SF83Co/fcQ8V75rcVt6noyHFIe45ou5yAl/30DusccdBl6G6hO3TlQ7Ods+tJ24KfS7 + Bk7ushl77DOQquXS9a+xtNXv6BO+4s7zWpUnDrHgxM+YPWbEMwJjTs7jc4yY+Yqhr5DurXnr4/gQj3bW + svjaS/grdmGnsK/SZfcxIazx+zwDGfNmT6MX9hlYxhuHP/MqZjVqjZbb0rE5x+QrJkz85jUu+9bvgUSv + 7JO9pe/7IJvrKU5q5mtdwfHc5MCPZ8/iAyRxLYlPKe/x6kZ8u0S8n1LfT9l7r+PLH79+bMbjRbskuZN/ + eoyveIXBRwyY81UjZN9A7rHHHUa+hB0nZZ2MsvukFVYnddnQKcSKQ0z2V1/FDSTreW8uNW+I9eMx5KPW + 2rPwXve5nrB4w/pjRvwB9Jpa02lu9ci+Wvyxaq4wr5HaY4yvPNiMXYlqrL7qDXzuZ+UxJi5i4PGQvMnA + 3N1H9cV+Fdf6XItXucSUN8RyxRu4i2God8FlHXEUk32PD9Fo7lOvEmHkaG3ed2rjiyeseRBgb+f7/OLZ + /G8c/5DFl3Tv8epG7Gf+PON/+1r+kIIej9D12Nhj54+NHsPU9nhOro4DPLbiT07nK1Y5Fttf47PHHncY + 9T2QPFlbeIKGRDxPXvoWP3EpdZKz9mOfsZtzt665q0fOSRsc8F3Eay1+11M++OSafsyzIPEy0uwDtvzu + wfql/SCfseZYDqXzmtexuX5hoz5jqqF6zs3appV3NWfXuu0XiZ/6YR+uU5KH9U0MevCJT99yGU9fErhx + K196iTlf+T7Hbd8Dye+BrB675+ppFcY8Dr/xqxjszlc8ZZk/nkGLD5F8+4d/8+Kf/+VTnnF7PHb8KF/6 + /gRfJXRcz/N93LbvsqHtsYzHJx83Pl4hfMzq8aRWLa/p9apO8cHZz0Dusccdhp5F0Mks8ZOzT1jyxGWs + T+xVi/P4X5LQnN6D5oYQZ1+DK+yQxMLPeOcNrvjUuR5q58WzHo8Za91Ln/2M/mg7b+SQB585zJtx1icu + bmra4hWXfunKZV2KevGaZw591uUheZORc8e8mj/7gXhvw891dF7YkuKSo7zKUdz0kORJ5hxeQ1K88INL + zq0/RKMevD/vy9c68cm/WnvJA3znAWtOxijxHr+44YlXQb7/jx8/+gNwe/SIb5T4zg+/V++n1GMwHgv6 + 4zHiY6fH3GPFcdFjLb3g+wZyjz3uMPzXJHRCni76ibW+OtGBN1YXeJ7gj30TvM+jminZE+ejD55is0e3 + IfAb91jzFev6zx/9dT6nC66ty/uSrd5etubqWWu3fl1PDP5VHed7XP4arxj90KgH7ohTEju4PCRvMrwX + X0P3ybitSTqFaytNW7keV32vOfIyJs388Mkb8xaHcerwU27+Hkj2kT103+jH1lL4gjnP6gweceee4qwF + TnMr9xD5EY9nz758nL/xC1fxgZI9Xt34wf/6hxd/8fF3XvwqP/E9HxN7bAyD6PHhY6vHLnh83OSv8f0S + 9h573GHUH4E8KXlCUnQi1wlNnp+4QzKn63jdRz8DqflMV7+co2JXUrxYS/fmoljbXHfOJb/5j12Tv1n9 + 1HvO6XbPL3vlrvywxW+7+c4918O6hXWN5lYNxcW3PMfEOeVR85C8ydBeSLy/2RdiwleZdbQ+36OuKX7b + eDxPvvg+Z9VFDdUXR/Pc/D2QMT97U6/VH3sTlvbAtJ65Xy3N85jygZ1znJM1sr/mAZ+1ws6Xvr/7py++ + 9fF39/spX8HQ9a0fR+xz7zn8wv04iuPEjhXZnu/x/QzkHnvcYazPQOoE1Ynd9jxxr056YF1LWOjHPgMZ + b+Kec3U/A6sLzaHJX7keE56S2IyFD3EfNeJZjMeMP/rvf1Z11Tfm6L0fov4OqTyXEe86yWX9E6Z5lesY + BfzOFR8x1YPdWM9ZMnK6f/k8JG8y1I/WU/1bj4jPXpWTeRW3HOqR43HWT6m5Vp/54VOAdax6MAn/1u+B + zD5tfq1Bfq2DMXEclw2++75W2JlzinX9jhHLePutj1q0C4986vDjg3Jx3YqXvr/zP76Xv/yyx2cffgPZ + gn3P/ZbP/db+Cyte2PTPcRwH+wZyjz3uMPyPgE7GPlFX7bzGG/MLNU9yymNvIHUxShkXE/jSg0Nfvbiu + 3pVz4hJPrP2yyXnMiPcN+dxlszb6xJ57T4pVjoR1mjfX6Tlev2XyKte48lde24eOPiTkep408trnIXmT + sfbVa28s44n12mFbPDFpW7v5ql22840nPMXyQg8u8eaxv8O+5Q3kMde7a7/VHzHZ6lHx4jHPeb0mixkm + u3IPPWoa5lq1UNd7aTz5S27z8U9jvJ8yPp0cX9C9x8Mjrtm1z7aXubfc06ktvjxe4o0cPVaH7BvIPfa4 + w6gbSJ2MdsL6iXp9EjdPuc5x3qu4gcx61aP6mvNUT8FzrjDThRPrmuZbfLUj/pih74LUfGMO1kd86cMl + eRLuReYg7rmym9P8riPO5ImTes29jLmPePLNxhzwQ3hI3mSM/tkHxHs89Ckuf/YvX2tWXujCjQvd2OSf + 43OeFsWVf9tnIN/+ne6V/Sz9zzVgjzyefTOn+FyLchVTnea7ND5zO6dEmMuCj/lcco6eJ3x9lVD8uEC8 + /28PDFyzsUfrHpYQ88fNpbEjbnl6zCX7BnKPPe4w/H1MOjF1Uuvkdb9xXLhhH1jmMh61hFMeewMZLyNV + f5xLNuZiP+Hb/INHSZ+xxtrOnsWzWGvkh/2YEc9g9FyHplS/5fec4qmXEuLNR474zutavY7Uqxy4c6qW + CeawOj5H2TNXscm5/Xsg0YM0e6EtPHumHtywnUNBbq/PuZGfNcwHT3rln/MdV573cOsbyO67+1t7AkeC + 9XTOXG/bEmJV4/BrTojmgg+u6qxy5luOJGOS8zzOk6hO1jrkt775X/IVhnjpOz6p/PM44j3i2g/sUdsp + xx7OPQamva19p+15wFrvG8g99rjD0Nf41MnrWvYhOsEliueJzfjLch/7fkHdQKqu+vWevC+ff/L7giQs + hTlVY2Bae69V/mO+Zy4+/an5Zm3YPf+h6Z/6C01BT2d85FFyjrLpZw3H+zEfPGGsXZr25DO+cOSPOd5/ + /iu/9O5v/288ND/X4X34moWrL+/R+5ZGzOJLDHpiwq9jCy9iFOV5/pp305ewv/L2/6l5U7iO6pl4cKrH + XMeMg9NrGCI+ZdQKYR3hhbkYNznCqB+qJbw1sJWPupZTdfrxyq8Ssl/Rie+BfdNHPGmQ+2N7UXsm4d5B + a7/gw449xWPmce238vensPfY4w5jfBWHnZiJld92aNh2skvzZJaWLf5jRlx0UdMuJlZbWhJ+xl2MW1K4 + 8ruO4gOzWqEf8xUgkVu1co6urfkTo+9xz5NUj4yjb9a4yJu1e1+8hmvwGqvaCwZuY/LPvR3+hX3cBH3y + hQ+efXjIb3xezyxUfyHssXub66yYfGK1nrSnLwz1pOc+pxBXzZm3cDMGrs8HG/4tbyD/9/ee/R/ZN3vv + vq1XYqv0Okxb3lUt2arheZ5fnCs/c0xTug5issXJeOZAuz1zGivuUgPx5/nBwPiVl/g+2R+8gZ/61tuO + 1r3w/Vr3R7zUjFd+8TpHsp+B3GOPO4zxEvZxIuIkls2TdTmhxUtfQk6LMMnjbiDjP3b9+kHWZn30Yn71 + ccbTpp8xw8Rf16Aa4XdtrD1ijxnxErbqa46uPfe7ejbb/RPPMK+7ylUN5WOO7mPUIHfga45h4nnMfdid + W7yu/9FbH7z97hfee/7FuHHh4fszD9UePZvtPTdOP2KL7fUQQzzr0L/iOueca/UtptzGmnvLG8gYmt/7 + SZF9aPWGPoF7z+5j7Z0z63Ss60y8uehJGHJ8PvBKiDnP+R2fnM4llnPK91zVhDjuufGyb36V0Cffzd+n + fp0HXsJe96H3QnunfVj30nOVU/nGDXvfQO6xxx2GnoH0kzL1IXXi09ZJXDxh5Huu4mGrzqsa8XUa/usH + 8fJQ9WpS/b5EgpO52afbEqtBjscfM/IZSNbOeVPP+Xquh/usPPKVD17XU47HVe9KX9fg3CHJlXQOeOKe + 8ZrDOcSLu+iaU5LcZ38eN0z50vcf/uYv8JD+TKNrQNDHYR+inqovcamxNvppLzzWu+KeRNzD9jplR730 + rU7NYT7tW36ReIzxFhj2sq7jsk9hhgcmaUx70zbmQLxsas+94sL3x9rihc3HP/WS11zanEfcyjPtvOa4 + 9LyQ/iqhfOn7Hz9+rV76zpewl33T2rQXwtKXBM7Y4CyYc/cN5B573GHgBhInp07u9YKmE/WKB7/5OtmF + 6UQP7PP8HrX4bz3+a4//3v29N5i7+3QMop7XmNY415qcWvPjnlXFM5BzDgn64Ly0uz/w1QuwtsWZmrHB + oW8Y8COn6nKuwxdfNZUbeGEmnpsSuPJXX3n0B6fw5lbvih8SL32/9d6zD+OmMv6gvOz9lJoj6xyi+S7X + Qhx69uU1Cqcu3ET1vZ5qKgbe7KF44ZNbvJrvti9hx8AnsdlPradt71+9r7rWQFtrKw5l8ia3de9H4ayb + GPOdIx/1kF921rBcavEk5S/xgVss8cPXOjwOXHFwIYjFqzD/6VtfyW9xiJvKpzr0ErbW5msRJnzsVe3B + zKuc5HrevoHcY4+7DL2E7SekTlLguHD5SVw2uYhDFL/S8T7GW46YLy6y8RUb8VUbtbbsSesjVutd+k5M + e3DOfczQeyBrTuuh+1QPiAlLXPHiNv+KK47wxMirHPkvEa8XfMxhMauh2FVvykcNaV8b4+Qqprkapz24 + 4B9YvvT91gfPfsNf+vY8cGcutK3TcPXpuPzC1cvSk2PBlQwO66vuWl91pg3/1jeQ8Yd79m3ruMCB9R5h + DcveSbhPHpt1wMmYdGESxFQrfK8h3OPOl3it1pZjceVWzsKbNZhDfOjMkUau1/N4vJ9Sv6LzVL5KSM9A + ap3Za9n9uA+xPSgObWiI54S/byD32OMO4wv1EpSdzDqJE0cM0rH1JK4cO9nB6wvFvf9bjmdAo4ev/vU3 + 8/2U8fLQ6Dns7Ln7ht0cxZT3mFFf41P1Wbv2zjDq2Qu5Eos51vmQ5JmtWs2bfMRgdy7mcN15Xa9rdK73 + JlFu90zMeKrhuGzMxR7S73jLgUVePuuuOGvQH7LU0ZyOK3aqk/N4Pm3WENfrjhqZ6+uRFt4c5Yfc+gYy + xi9+8OxT7yFtiWOHzr5Ny3Y/5eDXOg8Bx/ejOV5DvrDiSqxu1+qc8GUPXurGxUPccNpeRzFJxjxetcRx + v/XKD531kkM8sbfzbT3xVUJxrfv2D793l/dT9kvYS7/ss9biHBOtrbjEVgl830DusccdRv2UoZ3UOilx + guLkliTXxU5uxzq3azzFX26IC2tcYPXSd68da5l70BeskHhW8zFjfLI8ai4XSmiI8BTub8dnfvKT0zZw + 9A9RvLGqIal487yO+I4ntoj4az+Tw1jqo87ogRjjwtImz3PbJm7zyR/1WENSeUNzzYwLW2MVL5vzhM88 + +T6Pc4AvtYk3x+YkHv49biCPOd9d11K9WX/d92KTlzkWm1o4+YplHmz5EZMgBhE3YzafdPO7R+c95K+i + GhGvOrIzfsSkiYnj8c7D2iSOVR6x0qwjO3D9ig6+Sujz/2e+P0TDHpY1lc9eS5NTvJf6hz7y9tf47LHH + HYZuIOuilycxTkqdsDpp/WKok91PaMWFQzon/ht+HUa8BPQXH38XL31//UtjPb7WuOF8zIhnQ1Ur99v2 + vG3gxXE/486d+y2u+1qH87JG2FVn1sV8nVd8CjDJUt/nzzrOg911bE7GMr5g8sc85buQz1jyLnIVK07F + u87EQ7etWK/P6tV85juP9qyhfOXCH3lLrGrd4xnI95//Svfjor1ib4fdayC+8shJCZtSMbNTk3tZWzUU + p0TM4+I7Z0jwsgY5oy7qoAZw2TWPYsxz7qhDv+Yp323Eks95M2a2x9e82cPzz/VXdPIZSM5Ta4z5rVf5 + stVjcjN35jWPe8uc/QzkHnvcYeQNJE9Cnaw6ec8nNbFDnAcbHPjkjdznr80N5NXAS99/lm9ej//kY31/ + 9N//jNGfbeRL2NybuZ+9b7mP8s0W1/PliycuOAuWGo+b5486zPNY28R9vuQ71zhLTDXKJ2eIx8Mm5nVU + I2KYb0rGKCfc5ijf6sDu3npe8Id2bmLNPefN2BpfOYmxh44r17H7PAMZ45j/U+9D/Wod1b/WUHHjmGhd + iIM7cd+3OYfjLZ4HW9wQ93sucItT9SXAr+pdSXKYN+aj3XFI17vWPt+p3iKdBxHm8wLDP8Z/8NGf5isz + j/kVnb6B9DltXu+XfXgcPc++1xhyjuN+30Duscfth24gdfL6Sdw+T/IQO+lPHIsVZnZ8ae6bMv7nv3z6 + qF+hiZG/hc39wR6tuvdXj9Fnsvk4SCp2hR+S9ilXMeKMOedkH4Jc1IvcGWM+ccjELmNWSxznKz5157dW + X51XmtLzIAa7+xIfvIWTeOeKK7wwizmuGkMqZjrzGCMH897vBjLmXXs894dY9W5SWK6t91DrKm7Vc2Fc + cxI71wTvrDtPIkz1K19zXPSpXMWbBzs1fa+nXODut4awpovVa/uhGGscdsSFy5ZUbXLj/ZTxj3O89B3/ + 9H7WrxJa3xJU81UvPj9wj2XccuU3T/h+BnKPPe4y9D1udWLKPuTlJy5iwtYc5yPn+aNf8n3TRlyQY7+0 + f2nb/s2YPQ4mvtfFKRs1xBk6OY3NnMZSKm4Y8c6Rz/zka77mq1Zz6XucWNfEHMDYW+ISrFv8zheOfhqT + DV/8yhVOrHjlrzFih05cEr5i5oedPTAmu7hhJ+fCTg594oqFvtcNZHxlktbo+4H+6EecHI8pp3HyTZ/x + Bau5m+9zKSau82pu4sVjTCIOcO9dXJs7JOu1rdyQOUfbQ5RPPeZjrVOeciym+hD5lpMYclU3hb5yhYX9 + q3/8+/nSd36V0APvbY8P8Zxr0T8kawaeNv2IERMuzG3Fge9nIPfY4y5jfAr76sR14Um8xiIXYjhPbOf/ + +je+xEvLHjHe/e6f1D75XpZe93A8PsueR8wlOdKqgRzV6NjEy9Z8h/b5M57YdT3o9geHebILp3h+zSke + beHNPfTqByft1T/Hap4FV82ME7uyldN295F21Lb6Kct88sNW/lWex72+sHvdQMbIXwpiP+pPfcNv29dW + a8p1uI38yjN+5RtvcMmZMTxmXb+5znPulT1y2UPFhNP3XGCNr1z3gU07OZxryGktwBQDxj6G35j7oZWr + uoVHPmWtly9981d04qXvegbScrqurbdqtFQspOLXtUL2DeQee9xh+DOQcYLWic0TVBcJnNh20isWUnHY + wlaJ/D16xA1kfZWQ7SP29oG9lnA/EcOF9bPkRszj8l2q1qHFSX75UyuGfNkS1LsU5Zp0beYRU13nho85 + 0Z/siQlnjQck+UtfqpHCWPXh4nzzZWv+ETMc0nONOqGtztQQcbLeHW8g41nIt95/lu+FzF5SZv/qfayp + +ncebEnxwk9u18+Y8TTnGuvctpGz4IlZrxfxzD3lM4e2ck55iSEufwjzW1ijcpsr23lZuzCI+F676y1z + EB/zDa7qN5b8gUnUg2xo5SVf85mtPOFlW9ztfQO5xx53GPEeSJ2sOklfepIvJ/h6AVDuZd4hP/rx5/dr + NK/rOP2KzrFPsX/a53Vf5Y+9DU1JTtZArPIueCNGSd84FbPcEUt75jnH+2g+cOUptzjkX9UVJ+sueM/V + ceBdQ37lc74ZsznZi8cVW3vwvlJXXeTKr5rhSwz3eVy3gD/mj9w73kDGiGdA1VetWTrXpr6BC0ucaw+d + snDFqZhxyidW3MV2fe7B5lbcfNRSL6tGPIXc0pTg1jyFdW7VOPLAxfynODnAWCv8B/JcvBa4sg+cNZJL + rfrKGxyK5pOt2h6fHMsr+9BHXJhrCLHkCG/evoHcY487DD0D6SdondAh4UsM0wkMLk7iVcCZJ/1T/umt + pzR+8Onfv/j639qv6MSe+uNgWo+F9jv33HzYlsOYfH+s18e0/RlTfmLVg2T6sx50z02f9mkOszXXxB7O + V1/wkTs07ZKFc52nuhLrQ/GKoUYJayreNnKLY3JZJ7E5j/x7voStcfT9SfZ/9IM1qFc8PrUmccxf9wI5 + yL+qJTvjJh5ba3dM4n1hPvlV0+b2GsJXUeyUH5jkwMFvjnDPk6juVW8eLztwcjxHdvFpQ2R3PLXXdGF+ + Cv1R/8BWf+SEGCaeBPmHJr7yJfsGco897jAeeg+kpE/iw7eT+SGu18kcxw/7Lz7+Dm+R9vhpRnzyMb78 + Nz54E18G/Kv/9f8/9n0+RtrztvXYXUnW8ces7Igzn7jsrj3xzJVP3ZxDm4hTeUuscstn3LhZ4wKXrTrh + q4awUc/iwsq3Wq4dR93OKx0YZc0TZ0rzkTP9yn3Av/czkDHiJyO11tRrzyG2B8NmvNZ9YF7L90P4Wsvx + mj/txsKGkFs+OF6vazHu4txD13xmYz7rPeLFaX/MnTH0Ji1b4tyysw7jxUdMmLiBQyY/416b4lzxPZZ2 + zk/f7UU7fsnT/NQ+X8Urtm8g99jjLiNuIOvk5IkMrQsKMReeuMO2nKpDSZzxuAHa49WM+Cqhb//wb/L7 + NfXSt/Zc++2Po+LA23YtcY7nOUcCLh7jxIrfujiMq5+RRyle2o4fWjmFwa46pziwmkNx+carPOOfapVt + 3AVTrdUXJ23lHVp+9SrtsnDbn/Gn8AxkjLiRVX8t2IPGtSfma00hsa4Q+hHvHHE7R7b8q3hx1hoWr1qs + MbSkarQI9zqDT0n8wi9cOSbZz8i5XkfNa77zIlactMHNeUKbXOUnz7nCywau+s7X3CMeecyVgEeO4uLQ + Hr0dsm8g99jjDgO/C9wXAJ2cfkLPmGReXFIP3vliFbK/yufzHfgVne/0S9/++OTjId2PSz2W9AdX+S+R + q3z5V3VPNY0v6d4QB2fBXCdufVTO4Q/tAq5iygt/5BGXOPZQT+JoHsXbZw1J5Cp/xa8w4rPu07mBjPHW + e88+1Fpzveq7egdWeyE7NWTY9FMcozjf8YpJWAN9NVZ9HKLYWkv9uQxeYNTAz3NMWWPwPV4c4tAus2+f + Z+3HecqvvOGTG/msIY7XTL3wQvtcFV/squfx0JaPPpuXuNVSfN9A7rHHHcb6HkidoOuJCqwvSDrBC6df + tuUW95D4/rD47rB4j98etxnxPW2x57/3l+/lr+joMerHmo+rPZYRgzAW3JeI11j5EVNdzMFY2l1fth8v + 6lF84SMnNTDMxbjxvWZJ8qWtzoh3TxLFUhJD7kmYF/aDnENQt/cI9hHjHIkv840c4iFP6QYyvxvyg7c/ + qj6zZ/Zaa3H7eo8cx7olD9W0OoEdkhjj5RtH8a7ZGgKufM/LmNdc6o8cxi9FMeo1x3sQr2qHT4589VU1 + FKN2yXjmdK7HNHfWW2oqz3MVO2GyWUPzqIbyKtd8x5Enfz8Duccedxn5Hsg6mZcLBnHFzpxD88SXfboQ + jNqKM3aIvjssfzbrkb/sssdnGz/68b/1S9/f/M/5SxN4jPi48HGsx3JoFz6m9PWYwufxEL7XWuKF0fZ6 + 8j3vIcm8rNHSMRyfhbOfjNe8PZfnC+ta7ZfNWrOGS3NDfE7lqf6Don4PmTUaC/sp3UDG4BeMf1TryF69 + Z+3BirefUntMXPtROPYkxOsqR7ZzK2fhXMdZM/Er3/MRl+/5hau+uD6fzbHWOPO8D+nOQZ7Lyj00cWEe + H/bIZ33nXGAn/NDeh8cKJ2fmGB4YRXXe+sq+gdxjj5sPv4HUCRsnZZ3Ah9TJbjxwwBsne+Z33OtJiys7 + Nf24mYlnyuLmJp45+9G/76/9ucX4fz79e36V0J/wC4D7senHR4+nYriolxwx2YoNjuXKl61jo+Xq2IHM + nIl1jHbVmP2kZiz7kM3cwlmjbIq4ZVs+MEj6nr/wTv7AYacmDzLjYSvvKXyIZh16JhJrQf8QroV2roFr + kQ/OYRcOTq2dvkR8COKZb3qI1ZUIUz1xET/XSju5k6OctGuepT/NwXzlTRza84tPvOMulk+O8lfpfHJP + NnSK1VT+Gh9CvHjEZF9hZZvknMnvvoMTsp+B3GOPOwy9B3KcrHUC8wKyntyLJE++8swXpjlw0rN2CLnC + WsOOl72/HD+b9bcP/2zWHq9+xKe+63FbHsvy83FrfMQKnzzPbQ6Ph+SxDmOK43iQcB7jS1RHMa/b9SAr + rjxJxsJO/tJXxs+8IeKY7XVaGx51itu54hdG3POe4g1kjPyS8Q/wnkj1rrWof0mv6WLNsQ+MK9b1IBWv + Om03V1jjwmZcfaGuchRrbPareYon/wFB/uSlb7XlA6PvuOUJA09Y285PkU8dvMEpvHupOgtPHPC7VvKJ + V07izTnxKLMm46wR+H4Gco897jDwReI8Ke2klsaJ2xeNimdMgtzmQsTDSY4asrOOibChlW+1YfOl74/+ + 9MVffPzd/CLuPT6f4Y9ZPzZ83Oqx7XjzHSc/pB5P2slpXDFJ5aWPWhVb6jRPGv0OXNzM7TVVXBI8qxux + lt6HkSNhnmI1B+f02uiBPrHKEUbpetAphqf9RG8gNfLT2UevtT7rHWvhXlGwP/04rXvQGvU832MrT3Mj + ptrgOcdjK9/rOD/jijFedYNLETd7y1yI2yPH6jnmOYorr+uIg97SX4W5ind/XI9zKV2ffV7UaJ+1hBPL + uGHKrTj9K67w/QzkHnvcYfSHaHghsxMUJ6djkvNFRdhZOndeGDrX42W7BL7mpN/z/PLXfjdvKr/613/2 + 4jv/43v5vYl7PH5o32OPtfeyHUtxbj1meHzSX7gjbrj4Pu8VR3HxS8hxnvDiB5Y+tHI8Ltvngd15iim/ + tGwJa4d94stefcMzh5jbgx+8J34DGSOeLXrr/bc/8X3FuuZagHGvaDs/15v+NXdg5AKDv+bDX7mHDq7h + p5jiEuOL5z0qX/WaB62YbOVXHYshbnVcxDUbXPheSz3VHIzB7x6LG77FB4c6scoRt3PEEb76ieUcwltr + btXfN5B77HGHoRtISZ6c1HmCLheFIQs2+Ol7PVwYcOI3nvyRI05fRKoucXFPoji58Ynj+NLt+ARyvBy7 + x08/tJfa39X2x3dwFFtsPK58jCxXWNcDrpzO7To+78Af4KYcfvFNJ155VvsKE5+5jmlO4es8J4z1SzOW + NRbxGomJa/LUPkTz0MDvZuPZyJJcI/bANQSc0CtHe5E+axSv/MaEI9b5wjpGXuXBnhxiFPmaJ2uMePtl + qx7xro350feZv9au2KEjVjkXNYY+5XSth3gPYSmBMbfqGW9wGW/ujFcvjMnWHJpn30DusccdxnoDGbKe + tOsJfTqpeRL3RaI5jnccFwvkNcdzZr3DJh8+uZlj9QtrH7Xa/vWvf+nFl//b1/IDI/GdiXu8fPTecV+1 + 16Ftr7HPeJz0mCAHuNseU+3SrK8cn0OcxrvuWlPxtiFeb+ZC9zzslbxRT2LYGqv5XMhvIafwyUGdQ1tc + OGKsa/K63EBq/NIf/uYvHH2/O9ZxrLfEcO2B83w/4C+YScVYu3hmn+vhsfB49cA6KcQmb9Z0zPOAT+15 + Y45Dgwdu51sOOe5XfmIdV8z5Wdcw5Wo+t68w5EJ37pyvMNqhI0cyckIsR3lu7xvIPfa4w8CHaHjSxknK + E7lOWok4FJ248lOYmzHDq7601V25kuKl3RfLzuuY+5fCeSSBuR9fZRO/kPOdH35vv59yGb1XvZ9hj8ej + MPBGfPXJP2lK8vLxkuZjtvCKG0Leyf6MIj765HwR45w1D231NrGukTH1QfuhfMw3Y8KKZzV8niv7dbuB + 1IgbSTwj+ezTXIuvt2zoEsOLd0jYkOaWzRxg2r/5GDTWNTPHcss/RDzVE6/6Mhu6RbHMk2ger/lgHJxR + 6xQHR77inYO1rr44siuftuLAVb+5qU3EhX2eM3kRlzBW8QOrnLQZP+x9A7nHHncY+BANT948Ue1kpt8n + bp/kzjnJER928i9yKrZesBAffOOWX7yL+MIBr2NpK5550OH/6n/FS99xUxmf+v55fj+l71VoPT6+X6kZ + L224sIGHPsTxX/rD3/6FX3z/+a8c8Xf8JzZTq27VCs06Yw7DaQNX7szpPMyVGPPEl3QM8xRPwlrDNkx5 + 0OStEnPUPJBZo+3mtf+63kD6iGPgrXxW8tmnWpf2Odca6yYWvu+T70vn9r4L9z1TvHIGDt6amz454qeI + a35p2srxngcm3/LRv/uzZ/ido9or1jhj4dOeXJs/hDmINV68jM/8Uz3lOfeUBxFPePlX+CH7BnKPPe4w + 8iXs42SsE5y2XyRC+uLBmOUIcz/zeJIrVrjFVul5iOU8yPd6Heu5B69ic97MZRy+12175cRL3/HzgD9v + v6JT++H7c4jbis3HgRzTyIOopuM8JMf439979n+89cGz3zhujOJlzvouwc7THF0PPbC/wtouf4lX3cL6 + 2BHfa7stv/KttuQqjhqhgVUflj/y6BdHkvibcQPpIx//Y01f+ODZh8caP133J/eNgn3BfjhnxCTJMZ7n + lK+8Ax95ngO8MOd4jLg41YtyTIKfcePLVq2azznkrfNhHfTTPtcHBzVHnLrihq+cwiSBMbfjXUN2xcU9 + xdFX4uKajpx9A7nHHncYeKZnOVl1co6TGDJP3HmhqfiFXVyzJcKa77bkwNhT9VU2ceZUnHmao33mpg9+ + +zMuTFzEgetXdN7krxLKPfC9ou97ihj3jTY4jdV+XuCyeUj+xBF/LOKmIr5X8NCfaM6so3oxH+dU7Nwz + xLFTf4eUPWpCiy+8tHPcVg3y0AN7Iy7McyWKK5ZieW/aDeQ68j2T9iy178O6L9pD38uU2C/h636mP/Mi + nhzG1npd56JexjuWUjgx+pVLrOzEOefCKX3IzCWf9qnu0OvxDq7iKZFrmGq2nPPLpi486/SczvE5Usj3 + PHE8f38P5B573GHoGUidsHXy6qQ1+3RiH3rFdIIXh4ITnrjEePOCoouTLhbwZY9ciup3DXLEo5344GGO + 5JDXnDMvtGoj3nnxKzpxU5kvff/jxy9+9OPX/1d0tHateexL+doj7gVt+eJLlFc53Esekj/10Evf+UzV + +8/jpiJf+uza6M8x7yGFvJFjGrmss+RmjkvEK2fWCI15uBfMqb4Gp+0r3VzorPOG30BejXiW8gvvPfvi + sf53j334yPeo9tH3KMX33m1yJZXTHGFdv+coXsacA7s4iksY83j7FzHFqXsucFZe1Si/+xyaohriKX/4 + R07VMd/nqrjXl53x5owejTNE/MNWbsh+BnKPPe4w9B5IncRDeMK6Xye5iecqPuqpTubbhWmtf8isBdu1 + X2S8hmLQXV9Y5qRN3+ZWvGoLW/tjPcXPtTV3+/FVQnrp+3X8KiFfz7puCXBguWe5T70vJYxd+cHnIflK + Bm4qnn/xqP/OUfujU2/U5767H8W9X/A7Z8RDoo7ihq954nWc/KxJTuLCjCNZ6kT8TX8G8rMOf5b62KPx + LLUeM+1p7qv2vWKwC2N8PA58XPIxWB6H5qsOuaYH/wpjDdVWjaqreZPHXGHuyz5Ec3kd5aq+eOIqJtyx + lVfCecVxXLVgc37jrxzXmk/xrH3E9g3kHnvcYay/hR0n5jyhcYLqpHV/5aiG89tvrTptux+a9VSz6p0F + 84O3+pLEWQt5jcm/ypM4Dj7mkS+O6spGfdqMhf61r38pX/r+1sffffGDT5/2VwlpPbl/EvpYG/eDMa1X + awXW8RSPkxOah+TnNvKmIt5PmT+p130NnXj31TFiGe/e15y1VsUOrH3GiDl3SMRVy2uavc67byCvh176 + jmdo8Sw1Pu29Pq4Dq/1vTglxCM8BiwvvGv14STJGnb5J5V5gob2GcxHDXPCbV1zyvCZixnW7/J7H8Y7T + H5jmaWziPf+a41z1JvF4yL6B3GOPO4z6Hsjj5F1PTJy4dtEg1jZxO/GFea2w+yJgF46KG+YXkbLbDz19 + 2ocuYV7HIY15rc69wjPP6hVPMfM7l1j6bSeHvObGr+jgpe+v/vU3X3z7h3/z4kf//nRe+vaecx2L3Xtg + cfdt3fJDd17vNQ/Jm4zRX/XEvtjzjBtGLVsc2c6peGhhrLfWVB331adr5QhLbsjB3zeQn33US9/vv/3O + sX986Zt7yseh990fE8UlFncO7cLdp36QJwm8uLCrR3Iwf2NrDJp1vJbJyOUcGUu76zmnYqy5SsRURzWA + db5zHVNu9W26ahALe78Hco897jDGS9g8GcfFJU5aSZ684MguzbhzO6dPdvevLg6r7f2c8g5JjLZyJB7r + XMcgwDtn1AyJWPERG7wF7zprPmJX+cA6lr+i85f8KqF/vN9L396f1pX+It07OCuvsKhD3hrjIXmT4b2g + H/jqBX2xR8WrX9ORb77nI884qmO6Ys4rrvkua4x1oua+gXzc0LPUx76+e+xl/txi7fMh/vjCtrg/LvWY + 0Hb80IFL4LNW5pyPwfSX3LBTAqcgxnyvVbldW7JyZqx128Enx3M4f3Osbsbalj8w1WG+10k8cyDyVSee + YeZDuMcee9xq4AaSJ2SenHZS8yTVCVwnctrTn3xx7OQf2KonB7xDR03WdR7ympuiC07DzQAAfHZJREFU + +ResuGlzHnFNr7GqH37G207c4i/jln1orQEizLTxsp7hoX/9G1/O91Pmr+jc6KuE1Ad60P734yB/9tx2 + Y553aO1NCGvzkLzJGL2kvuq3cfFSbC9OscKArzVcok7lhM09ST591SqdnKVnYpm7byBf6cifXOT7KePV + muPmEl90zv3XY5KPwyJ6nJMvTmhK1yEnbeIWH7nGP8Uz1nlrb147pPKFU88a8MWrelZjzOPYIsJUe0jm + NSdEdaXFQ0x9wufDtccee9xyxIWxTkSdrJSJP3xREMfzwZc0t2PwE1vmFcd11qdfWPqTM3zawiReS7by + PWfFPZbxnI81xHFs4clun30aNzkuFTM+/Yj9Jr9KCL+i8ylv+17dUA/oDXP6Orof8xV7gKNaWo80D8mb + jOoz528t8b5Xu3qnPeLGSVxy4FU7NY4Hx8RRvLGeo/iag7Z4+xnIz3/Es1166VtfJaTHxR8/SD8+Q8t2 + MXzkUWbtl/kXWrW95mEjD70Kqzil4snvY3FyDq24YephYj1f57UN/DzfQ7WO+Ed8aPbYY49bji/g5Zo+ + Oe0ErpN6aD/5dZIbh/mlK6Z6naNaLc3NfOOppmJrzhrzeQNLIc9j4mKe5iM2eeKe5wB2FUPcuQ/Mabq5 + tK3nk+R8XSe+Ssh/RedHj/wVndkf7Naw1YM46ld53WOvL23lUfOQvMlQH96PepRoHaUZR79c+4I/xB92 + 5k9ffLfXOYSVX3W61r6BvM+oL7zH73p/lI8bH1s8jjymhIemiNu8tlXDc1Qn88xPIU/5EMacY4L5Zr22 + oUeu2TX3qIe+FZOvPJ9HPMzPWiGJG89w1bLe3uXDsMcee9xyxMszOBl1Mrttmiern+h1Ai+ckjjRWVMc + 5Lfv/IqFKC8x9NE8+KjXF59VqsbIFZdY1Wnf8ypmtmNXNcJOvGIzd8Z6LVNLIk/COGOq43bJUUM6fkXn + y/FVQn/7Vy/+9rip/GlG9WS1vS/3YXe/nlMSfVEG5/B5SN5krP2qD6yFPVJfra9t5R2Ycy2/bMWId658 + 1bjuSRjiwFS/auwbyCcx/KXv47H58K3346VvPJ6XEo+j60PwGPcx5nHH1uNBunIy5scW41ULx1vFHpCs + Id/rL3OFqBbkoi7n916qPut1fsdSM678eDaY277HHnvceoyTM3WfoHWSLuInuXgj92SfLw7lHzLqkLNK + cCC6OPXFZNqHVo1Dpy+8MPZjvqRyGQuN+aYvTsWGj/qjrnEUW7GaO3uC3bWIZaxrpo686q3xc1/g6Vd0 + 4quEXvYrOp4z6/ReaR7h6qVyPRa+ajFXdXk43mSMPq5s6zG0+rxcB+3maD+4/4wBa96a17nMM86M9Txd + m9i+gXyyY/0qIT1m9RjrWLDHW7E+nvg4K0datiRzyKc9uM7PuHFcFp6k+Iyrn8Iknit9iOYa6xp4YCvX + dOKIx806t3iPPfa49ThOyPyNYZ2seWJS4EsaR0yCE1t8xXSSi7PGPOfMWWpWbxLV79xznunqRbU8zhzW + C53icYuFVq5zgbOWx5gzuQs/Ocaz/FFzkexDfPpXfJ9v5YStX9H56l//2Ytv//B7L/6VL30nZ+3Ne9Lc + xoGGVLww1lCcWAgPx5uMnrv7q3VFf9Vj91s+ucI6Rpt1sF7iiQGvHK8RNjlrTLVO/BHnfPsG8rUa+iqh + t/hb73l86LEN7Y+55MD8OMFxheMAvh1jwsMu7vkY9HoVk79ga4+rX9jIkTSuOT2/sY4pT7le57A/5Fbu + scce9xjHyRvfg5YnpC4AugjoRNYJXpp2n+CyeTEgT/keK9viVXfJq1oW97mqlsUH3yVzz9zEKs7YIc6t + eYQbp3is5fEUqyvu4NFXfIrH2pakv9R7aA2pT3N1TFzFf/WPfx8xSq+huR3j/FYnY/RnbmOew8PxJiPn + jZ6iT4n80NnbtCuHtnpPjDUyp+wLftrkXYjmUR3N0bjNy3hhB2e/B/L1H/nS91ee/cbxmOev6Jwe+/Tx + +Odxs+qMN39wM9b5ig8ufXGVq1hK5er4nHzUbF7WCAksY8ylfyXgTFs1VXd//+Mee9x55MsqcTLbyT5P + XJ7IjCumOHRz5Sdn1GrezGXewR25bjN2EstRDZ9DMejGXMCnn/nel+Pi9zwZc2F+y1KnfMWQIwnca5V9 + SNVw3GzVEg/1OfeSk/OcMGjFxamejF9x2sIHn37Zh3gvyRP/0DwcbzJ6b7rXaSveMfdrXerfsUOKt8jA + mVv5jDvH44qlX7nO2zeQb+KIl2j1W+/84YdP1+OvjwNhEh4/xCpPwvzVdn1lV53QXoO8NXYZJ6d7P+eJ + J454Ke8//3Nu0R577HHPgTd580TnCawTtk5mYmkThy/hiW1+1ZCvulbzzIMkt+aYuWXLl31IcEdN8ck7 + zwd/zCFx3+pkfy6Oi3fYVVMxYlgj+xCfHO8HvvKgBy9t7Xvz15jXyxoU95vXscqJ/qjlKy58jcP2+Zuf + HJPAeSjeZFTfnDvth9ZEbOZAhr3mFwZfOekvtV0rtuKa7ypX+L6B/PkY41d0/OdoD+3HmY6ZcZzIt+NM + OZ3vucwzfvqMDX7m9/EqzPlpC7NY2gtefGLuxzO13I499tjjniO+fkInu19Q6mKhE7vw9v2kF94XkajV + F6tZxy5c9MVRTsYWPWLyTUtmPcenho0+IYhlfuZ2nRTZrj1+SOUPDSk+ZZ0z+Vmj88URrjojh5jm9xqq + 41r29IVd2fCdl3maT9jh+9yKrf0Ik+aheJOhXuYaure02Vv2H3b5Whf2pmKMS6qGcIv7fqlO7VMIucKr + luLEodXPvoH8eR750nd8ldD79is6fsyEfYiOF5c+BnlOKG/hK7bqqxqwIV7LRblV+1KfOUfeO1z2Hnvs + ce+hr/M5XxRcgHs8tdvkCrcTPu2KOS9t8ByTYG7DIm41qm7ZquVz07fa4nYuuGVfCeeu2odUbeOUX/XM + dyy5LuApJi54rFFcw41bPOUSU/2Rl5hxL2rMuVbe9DuHPSnm9qFRU/ODy0PxJsPXVz1YL9Iz1nxJrcPw + 8LUvyl1r1RzkrXXTrxzVVB+Yz+eA7BvIPXr4VwkdN5Yf/uIHzz6t44fHzjjueMz18cZj7Cceh9CFFW9i + 4gCbOPheG9L8Eftof/J6jz2e2NB/rX5y+4nrFxLF/ORPjniXF4Wpm7PEKl9xYB6reZJjmOUIz7zCrY5h + nocc8xnPHMbAN73MI1x1Kp/6odryu+bEvLZw+FarMPJYZ8zJubreodVD8rEvNQ9riNvSmGpKCltyoYkp + 59A8DG8yup/Z08Cyb+4Z16F+gV/ZzJUmH7Wgyzau809Y2KwjX/krZ99A7vGyoa8SOo4VvPS9HEN+HHtM + IiyljsnGznUsj3zZwVnrwm9e2slV3ef75nGPPZ7iiPfU6ITVCdwncp/o0h0jxovC+UJhfPp+YVDc68hf + cyZfcy75phvvWooLUx2Pl531mV/+1bwWC1viWOQfetZqTLbkMsac9FnPpXDFNEfq7k31AnNbecAZYz3x + JOJc1iYfQh7jxacWn4fhTYbP7f1lL8TUr9vwG4estnMQG2s9Yay/cDzfeaOG/CM37X0DucdPOfxXdI5j + Kr/STcdWSh6XfYyt+BrT8ek8cHkM067YoZWDes3zGkds3zzuscdTHvEsZJ/IdnLjBD6d5BDHxOkLhGPN + lQ9e8Rlz/sRoZ13m60LjGPkl1of80i4H5nM4X/2M+sxTH9KwyVEO42sfqnlVI+XEZ5y+MNQBLt95hV3i + R03FDik/4xc4Y6qTOP3uAXrImmMxHoI3GZi/54aPflZ9adcaLPZTYLKzh/RNJ06uy8g79EXt/QzkHq9i + xNfj5Evf7z2rrxLSMZjafB1/fWw2T5i4J8z9iKu+tOT9t9/ZN4977PHExxfee/5FXAz6xB4nuPvE3Efu + 4a/c8HVRyBza7it+SNUxf60x7OTAHrWJKx91hXd91XuQx7j4iJ/xGWfMOYdWrvLFbbG45agudNdN2yQ5 + ETOO7Kq5+J4TdvHWHElwyS9NUW/eY4nFMA+w0DwEbzIwJ9dp/akn9d79gSs/+Ykjlpj5EuGKKQ8+5nau + z5c8j5fNGlFL9RjbN5B7fB5j/orOfOm7jk8dkxc642HzOBVf9jiPLCe+qmd/2nqPPV6jEc9C6sTGCY8T + ui8A9PMkbzzlwlctXCTIcTF+zkkc/PaBoU5hNseczzguxZm4cjSni/PFyTyrVdwFS96FnTUO7sobssQz + x/xhJ1e8s155L60VwrlDI8Y4fXGKR1+1C0vb+6BPruM8/G4y1IP31/6CES+9iNardThPvur5vMKFiTNw + 5QTOWHEXXnL3DeQeNxrzq4Tetl8za8ljcj1GqUvimKYNbuhnH+4bxz32eA1HvHwxTnqe4FcXAefoogFp + LmKoJzz1cuEQV9iQwE00T/GpvQf3q06I5Xg/yYuY4oXPnque1RnCuHKVH7Ga40of4v32vLAhFst6C3aK + GUaez5u51MVXnFhp8UPSNky+5ch2X7V7PuXe/gYy+4p+1Dvt7ps+MYl6b95cb9qW4xhyIfA7P/XCSV5I + 4eBXHmsUZ99A7nHHkZ/6/kq8nzJf+s6fZtQxvNqu8V2Wz48b0ee/sl+q3mOP13zEyaw/WHmC50neootB + XwDChjj3hK1aIo7hyu25JifnZq76AFfSOYpf5clPruIVA6Zcz0vMZGCqoxyT6ivtOdeaUzXLP3TypDuv + 7cmp/MLXOdd4x9a8zCXmdUpHjOK4ejlxLc5D7yaj5+0+VsE+HLbFZ9+MCzdbPHAQc/4qVTdzkN95s3ba + xWMN+fsGco8nNuKGMG8sJV9pm5Q99tjjTRpx0h9/nD7KP2r5h6v/SI0/ZhXvP3r1hzL5tCluK17+Iarh + dUsHRqm8tDEneK07l3jldo/Fi5hx0ma8bdRLueB4rcENIX9yLngulQO+/BNH+KGDWzWJOzb0Wi/z20d/ + sq2H5J33vHN6f4WX2JxeI3AeejcZoxdqrVFrgN1rSSz4IeQhz2s0b/BDWM9zxZOoztC0m4f8qmHc/R7I + PfbYY4897j7iPS6XXz5L0R8w/2MIv7kZqz+AEsTbZ+7By1hq5jEXfPzxLDx5XovzWqzrdcznVDyFmNtr + jVMe+emXbXnkCy9t4tzUqitZ6oPXdTqX/MKdc2jLLV5h3avPVf3IVjx9xyZHca/jPZTQjzgPu5sM9aa+ + su/qhb2FBJb9K/bQ+jqOesAzTh8yjwvlTZ7H2+5487xe6H0Duccee+yxx5MYfJM0/0jqD9XFHzf+sczY + wg27/c4RnhhzIKyZnOZ6HviHz3ldVKcw56g35rdtfIpiypNdecaDyDZO5Sz1NWdqi5Mf0vVaVnythbjq + opcrO7nkn4R48qXFZb5i8J3LnhhzjvCVL5+H3E2Gepk9de/oy/bJpPpfsPKXfNWtesElXzHHZFeMPEjH + hzDvdXgJO17dqE/0fvDsw/hULz64Z+uIteb74o7YB/nTfL8TL33u98ftsccee7xGI77ap/6wheYfNPlp + 14V/xgaH8cTSbkx5jXVN+cotHuvWnMEfc07fted7LH3x0mcdStkVa37YLuAznjZzy7e5Vpzzy/c6zVPs + J2GopzqKJ6fmcLt50yfPuJ5bNdI+9yvxesoL4eF2k+F9VG9ck+PdY/NqnfRTuI6BUape5FCEVd01X9zM + 71jVoa+47Kf6DGS+D+6DZ79x9Fpvi+n+Yx8OW3tQ6z4/DozFJ37fjQ9rxKsknGKPPfbYY4+nOPArNbqY + X1zYQ1MCgzz8x1Ec+RVLnHm0a77Mk3/myXapeTiH2ynVi9eCLwHm8696jTUetubo+oqpNjiSNfcqJ4Vc + 98UvX/YhV/MIR+3myE6OuNTKa57qGDfi5GgO2amdR5uH2k2G9zP7gJ9xCnxbEzHozivf9CqBe8xrp/Z9 + kUSfC648ny/8p3YDmd8feNzs5RrYq/pPe+yd7TvXWzyXZS9C8Gzl2+/EdSrm5PR77LHHHns8hZEvZ3/w + 9qe6ePuF/0qn2B+IceE/bHFOmHKoW6wuRTH327Y/SPRlw2/MY2mzl8wfvUosr7hdo3JsDW0jp3DGmo++ + K0bpOVs8lj7zV9yxjonf9hDHyMk6h3/iyxcnfBP0of7d7jweZjcZ3vPsiz0tumPQmTtiXHPWM0zzMFa2 + YVmPMeXMOax++Y1XLPKe0A1k9JLvoV7Wnf0Ky7ViPYitfu+HsM5pXuPQh3/Mmy+N/0582ne/9L3HHnvs + ceeRH6zhF42fLuwU+UPr4p7+/GO4ciH9B8L5JfgjUbp4OY9qwm+O1TPemtPzh155qCVxXznC4RNjrvvN + az+1S3Fmf4M/4uYfMffFqdqqIb70wMkzbI2NuqZPc4amrLmheYjdZKgH9Oj90DZZ/bm+BXch3rVtj6ld + iit9quN5xBmvOk/gBhLvcexfK5GMvtNf13TYF2sWPjgRJyau+J6nObifn8RP8+X3FO6vkNljjz32uP3g + +5k+xIVawgu5XdxTm82L+IM8v+iv/Mb0B0J8cihXOSUZtz845J/nld8iHPohu7kdwzzCUqq/Wdf7Uy/D + Hv2e+YVXzO3uC3ytrXmtD+6Rk3KBt3axGH3ZlUuu11JOCA+vmwzvrcR6UZ8hWqM4whT3PMRoExfmfMSu + 7eJJTty1v57v3i9h4+bRf5VE+8A1SEaMe1M8rEd82cKDpzz5qYvfeV3XchlnLN6TmS997/dT7rHHHnvc + aMQnKY8/WPWzhy7LRfrAoIWtfxyKK/ELveWvc1Rd8c1ujnHJQY3JTd7iJ6Y88rsX2qk9F37zOtY1bD7F + TpwFO8RzTvUl5KEP+ee456zcjBsGjvbEOFXPBbknsRrhB1d4aB5WNxnep/eUvYy1ar2r3Vxfw4gTLy5j + wHru5KU9c8q/wDAHaqleyh1vIOPm8ehv3DyiZ61VvU9b/BLi6/qSR1FMc8Du3OQJKx5EMXGdf+h66Tt/ + FWW/n3KPPfbY4/MZ+Ucj3mf0Pr4v8krqok3bfb/IOxc8+uQsF3rLP9dDvnLnHw/Y4KdmPa9/xR0xzlN5 + UYOxgVscsdmr4uJ6DLjXY27NRdtjxDwG3+auHOnOFQ9zz7jzUlR/xTjfmEdc1xVHXR5SNxnqyfvsfhSz + uHEHbnnOSd/FsKyfuh8Tt5uHxyH9q5qUzOPc93wGUq9K1D7Qrl4v1iCe1pC48umfY9Au4jysW1Rz7G0I + 7RED9kmsTe+n5HL32GOPPfZ4FSNf1s4bybc/qYsxL8jrxbl0YS3tzz+uwuUPzGLOd3/moK7HhHtsxMNf + asqX7TzZWktyE1cObdaQDi7E4swTnnzG3Jet+WaM63A8be+5uZ0z+cVT7uqT38L6Eqvh8wTGQ+kmQ72o + D0njwpY4c+ZaDA+M8cQvdMrKY/5aY9j0H5ov7HvdQOb3OrKP6K/XPPtT7+K5FudkG6Y1Yw7G6IsXuHyf + 3+dBPmtI1rrJk/Y1Ze2Pjr1+9wsf7K8S2mOPPfZ4ZSP+mBwX2neP/9rrWUldfF10sR4X5ojxws8LNWMt + utCrjnJkex5804Fn/qyx5gxJPv+AMFf4jMs2P234zk3bxPkpUdvqD30I+JbDWPrKvRLGx1yFzT0QZ/TL + uOZeOZp/rd9x9D04UfMQHj43GepTUr56OuQnrUl84VibxVSveLOe45Lki7PaC19xx+7xEjb/ecQH69TT + 0Wv61XP3Kqxs84OnOliT8K7l0lxiBwc1JNc9eG3lIRf1hCm/50EeNGsr9/3n+VVC+6XvPfbYY49XMPJm + 8v3n7xwX23pvlC7Q6wVYkrjFnXd10S//EOW231hoSHOrHmuL4/yaNzVyXIvrvSBuMedUHfjVAwUx2ZI5 + n3PP9Tpf9bvGzI94ygNx1Rpz23xrPLTqief1SqxG+JHHQ+YmA3P2ekqI+3q8x1pT6o5VHdcmV1zU71rO + Vw3nrLGyzb/HM5Dxqea1/1qv91r4YR+4a9+Hq/ViHyzGODC3xYN95iKOmrOG4jknZcUyx2p2bXDEp/9p + fuo7Xpn5yv4qoT322GOPR414D1F+jcZxYT0uvp/kRdguwHVhLpyxvODPP6a6mKc2XtnEPYYaxJnbghzn + NDbjyp81Zr5qOE+1Ck//yCu7tXDU6zmHXxht88FzTH31fIqVTw0efM01a7WPums/D/TL+iGdD81D5CYD + /dv+hKhv9qieHZs4ciqPsa5teZYPPvMpyodNn7XB716dWxzad7mB5Hnc64btvclHnP2X3zxhI1Z4S9UM + sdzUtDVX8hiT7bmnOocEln1Qy+649ZY+ZLW9j/C5V/krOvv9lHvssccejxjxX3m+f+r4w4ffvX2WX1Se + F1y7uMsXBhHHY233xfzADu2+13VbvJSs5zktmsv9Oa/zOqa5VF9c2RLnjRz6qg9pzmlO4p6XvmLJJSZZ + MNV20TyXeGqJzce6nutxHhI3GVc9aJ3q27W4zr9aA/ioLQ1bMc+b/MbNJ+b8wJSX9Yin3PgGMt7/pzV1 + b0u/HmdMPef6JOSVnRyI8K6t9fceVL7pmtNqAm9R3ZNNv3Os/+TZ3MEjt/s6x7NG2ZD8zsz9Kzp77LHH + Ho8fv/SHv/0L+as3cVHF+4p4MfaLLy7OwnUxFiZeSl6kO6cw8nXRB6dxScXN9jiEcx52Cmv5nJ3nWMe6 + PjD3lZe4+JYvbopzMo88E+VVvvgvy41Y+uyfseZ2PmpMbnHCZq3m3uF7IL0H6616XGSNh057yU/hmhRX + 7OwvMWqI1c0c1A1MuV4r5NbPQB7zv5M9SR7oqyRxaPE7T+vE2pO3yMCMe8VBjXVPl301XeL9UGdOzte8 + jF/0K1w8YMSFWbzzEc/3jvtXCe2XvvfYY489fvZRL33Hyz966ZsXb12MxwVcelyo3UYs9OBTJzfj0A/H + gTk+MeOxjmvhykE+4ybO0xzKmbypB575jmlOq2W9IdaSGHuQDZ+YOCs3fHLkV03D+VDfZFSfnF+9ylas + +6Nf6+qYcmdO21XP6na+ca2uuKOnjLvtPNi3voE85v1Ia197q/6qR6wF0n7lmp55bYde81YRZ+VWDeal + L0w5FSfOmEQc9V/58hmTX7zAMr/jzfF55zpUP655+VVC+6XvPfbYY4/Hjfzk53EhjZfsjgvyh/WJb13k + Ly7WuhiHVIzYuGibD5l5iq+85rQ9MOst8dBmoyfxlrjFEOcc5JZP2/3mAVO8eKwhnrhXPayy8ta6zZmy + cqMGH9qbDO+r1qN1SlOKY7h69nUUN3jkTg7jwuWrLnnN7xhyyUsbdToO//Y3kL529LH2ltrsXEfqhUuO + Y1p3YRJyy07uwaFWnnieL1t1ledYcq2mZM3JOcgdesFGnQNTHmrBV+3KVb7hC/ej+Id6/4rOHnvssccj + R7z0jU99x0vfz/5cF+2++M6Ls+Lt42LtsmKV43bm4o+KpHIZv8oJWfP4h6G5nhP1TB7CrwS1ITU/8dLV + T2hyKOKteRLlr5jXKTtjwtjT4fNhvMmoXtlXrcf6896AzTXKz7Wk3zHgilud8ie/fNUbPOQ/xBc38Fve + QMYni7uf2Wtj1nf0Slvcwhmr/MHtGhWnn2Lr156037W6Rsc9ptw1T/WEFZeCGHjCxPN8cYuTvvI5H7nl + B8/y5Xe+6hKP655e+t7vp9xjjz32+NlHvsn/+A89/lM/LrTxu7d1we2L7/mPErCOZXy9kLtkbOGXj/jk + Wr2lbvKlI+8irrz2IV4TMc5PUUxY5YUwNzmJiwt/1JYo1+OZa/6KU2atZ3/Oh+wmQ/2oj7kH7JN9r6Ke + B2a5inVt5qjuqllP/qi5xK9yGj/ybngD+YX3nn/R51cPabM/rAU9Z9+MJU/9pw+71la+713vidcVNvOk + bR76yp0YchTvWEvWsVphrzlXWrnFo606wpNHXzEXxdd5H8IDe+s9vPQdx0W8YrPfT7nHHnvs8YgRz5zg + pW98lVBdhI8LcMpyEYYP7ZJx4+MCbhd/XtCbs9gS5UWMcXBmDyO+8Nx3jteoWhHPGESx6on5ylWs8lcp + Pmyv5XldxwVY3ODz4bnJ6D3A3nnPtaYQs8GRtF8c5nocvvC2q77luXjdsolLRg3KLW8g49lO9dX9Tbv7 + PTD1yZj7wLRftj7GwvZ6niOu7FGbNR6av/DEes7EibUNXaJ8Stjqof3mVCzzuAbOl7rmVj77WWKO95ye + B1Fd4Za/f0Vnjz322ONVjHipR18llJ/6/uDt/CohXXDrIlwXcYj7odO3C7bweTEXprodE9759seCPGCy + p1+iuqkZV40xjzjwi5N+8yaO3hwrP2t179CwIeSFXjjx4QA+HDcZa6+StbfVhm+Y1YE9c4ornq1f8bVG + adqzPvtM2/yIH3LTl7DtBhK9oB/4fLwl7N35bo91cN2pa53NVdxrqH7WoK2YMOWJP3iKE7uqPX3o8Lu3 + nr9yaCt31JEvDqXmHnngKt992JOPOuK2rtoSzbe/SmiPPfbY49UMvfR93FjG15TUJ037QowLf9lLTFj7 + iksa00U8c+qC3rjyEiu/50whH7H2Nb94XY/zJwfYwMt/SHs+5pBkLnspoZ/xsJkH7O0Xt34mpHqJ3ijq + bcU91r7FbW2D59pyJeJHrap38AbGvKxLjvLEVf2wb3kDecz5jvquPsK3nkefp1jb4MCfvMVOveSaTi75 + wD0PseJKxFeuOKk7JizlwMonx33vr2rQd7sFORn3GoetmPLOczQOLua4qp88k5pvmTO/j5fvp9wvfe+x + xx57PHLkp74/iJ9t46/o1AW7L8DA+gLuF+XiUtZ42YvWRb4x/FEIuyTyxala/QcEfvOUl7HVf4iXetqK + i3Ou17yVb/Ipt/hmo/pSr1yv1tAijDxKYOKvmGqO3OS2Dz33KuWSh1jxlxzVCt5tbyDzWavRT/Uo2/pr + DvkHTzFIx+TLrjmqdnNRRwJuxSyeuWl7X4g5ljziyk3b/La7/5EnbRhkcj2WfuBVF7pq0ff8xpsrAdY+ + MOSOuuavUvnoK39FJ66B+6uE9thjjz0eMfRVQvFHO176fuv9+ALgutiuF9++MLufvL54P5jzgERuy4Fl + PdYpW380PI+46RTNGdprrbLUC9E8ZRfeXJ9T9q3f/xjD50/xvmm7Bh/raFm4shkXVtyhyfV8YVd41ul+ + 17nDD7nlDaS+6QCiviToL3XFes/L/v/ae6Njy64bSXRMeCb0d1OKbhPGBJkgE/Q3EVWMmPaAJvBDLPUn + TZAJNIEmyIR5G8hMILH2PqXpafFcSgIiEAASicTaR4y7tu6tusVn8Jnk5+xDzrryy7VTvcwz9j7VOUv3 + XkXhD30/w8x9hyI+k/bWVN664Kov/FmfuTyxO+5728HvPrAZlbs7Ps9+efzFxPzR9/55yrW1tbX/hsWf + H8KPvuNf6PgUf56yvvDrizC+gOML8ahHbE5qhOsLt9xxxprJ3PriHJj2hWOn5zhzzb7QEB+xz1/9y72W + puJHXDz+XDqbzi6Pup9rYoiTLz3wwIGuu32m9MAxQz3DkuM9YclpfmFvfYH8li+Q1+484zyXnrd69Kdn + G1jhhim3OvvGjwit+RkHb2CaLbxr6Thv9MLZU9/5wuB6djsTOcEvzGa9X3hyqcc5YeJ7b2gaX1zN5jxx + zHU+ueyZBuZbVzX+T/T+Kzpra2trfxPLP0/5p09/uL7Qfn99wcWfpxxfjFFn5Bdj1frCjEhOzMoNA08a + Ftl7xXmV+zmE9znU65g54+mlp1iz7/31PbI4R/p1Dnmfj59F4IZFX2dXzz8bcb2XuHPPHmdQK79H5bVb + rh7rd75Axv92/gzlcQ7LhfszftVzvj+7xx3kVWQufZ8vvry40j92UO/ETs3KWcv1v4fzxyzr4pLvGvKa + y7znWkccjz1b0XZ6L51aVR8uXedo35kXJ/cV/6f4s+T7Hcq1tbW1/6aNH33Hv6Jz/b/2+iKcX3j7CzZy + uxiI5Rdq6yPnF2xxcqa/sGsHvLnFr5w98hP3OiO46kEbtXPgPIO5dD/qUqkz8bw6p5+1nsly54qnzwC8 + 1lWdmH0uwOHA2bOZzOXk9az0Jp69N/8IO/fmWfCcfTY+6zj35BWnesobz3lqeN+1xFPucfB0ltLrPuY7 + f+KCAy2dRZ41+80D5hrZFx7RfJ5FEV489tQvrx5y7fZ5zQFTjvMIKy2rxWkN5c29zXlPHpz4tWnXf6P7 + N73X1tbW/kamf0UHP/qJ7+zwCy6j1/piL0xf6JXLm8vZ4jQvsegfXjOZu17rS1t5zRkW0XH1Mv/y+Ts+ + /ttNn0M/I3KcG67zzs/B68Z9VjPRHzp010jnbGLEodW1eM73XfL3fweSZxrn8rrPWudNzPnssXa9M3ft + m2f/mC8cufZ4X5p+Bjh5g8v58Ic+ONR84rDnfe1K7cDZ1zlUS7t3+OeGufSsu1d49dAXBm5z1BOWkTqu + iTnq+M6qxeOc41eMP/u8L5Jra2trv4Dlj77jz1OeP/rmF+H6wh4eubm+mMOJc677wHxeM8KVC2+3uex3 + 7tH3KXL2p4/881F5RpyD59f5XtXNr2dg7VG45hMXh/3WxmfZ+OTKk+N7hp71Ln/nX6LxF0g/uz+T4ok1 + 3nnMB6+xZx25zzk/68JmfYviZHRdapk7hrPMGXftzR73O7cjejknvnC6a7kGMLl6miEvtN3JF8dj91vr + 1DuxOYeo+syTbzuE54vk/lnJtbW1tV/W4l/R+Ya/Suh6WfgZX9D7i/H44s1efmG3L/J9AZAXPblh3peO + 73q1d+Du3BE/sv/oC0PPUmfl+bPmOat+iGeuen5mjRU3cWGo71zkfQbWVxQfMzy/8978AplnMvdnOM/a + HOJVd89xzLFfOlaTh53QuGlxZvKnhteto17jr3qRl0ctJ0dzE0OtCBzR84ilYbqarZmsucd8amLvK63S + sHibI08c9bRDPc0hWt89NZDH752Mr2v8T2ttbW1t7Ze2eBHzH33nLwCuL879BV9Y13ZRXNgZh9vckwZy + +Jgh1zWv/Kdfwx+m19l0PjjOrOfy52kMXGDsFy7unIvaZ5TrDFkf+8qDY7zkGAaceWh8wAuknqnOxlpR + eTnPX/jxLIkf/fHc7g/4k2748z5imaOHMxiP2JwTzucbPWgmZ/CQF/dp3vuHx7y40q5ZYZrPWufAjurX + 7JxRPrjkgysd6JaTI371LR+7LBbOeH39+nG/G7m2trb2QVY/+o7fz8ZftZJfsPMLOr94Z95f3E8sa/VY + +xd69Z3z8rIo7NdzOfRZj4vVzuxY8hmd37h6/PyMM3JyHfNZuNfNAxf7nmajfuePsOu/rYdzpV+5nrWj + PVP273PitHa7eOr1DHoZK++zCa859p1znqFzuNfF0YztQ2619V0nfO7heQ5NcZS3B9YaqR2z3D92Ft6z + iUWkS2fMHf3iZD37wOb5xw7mTxp+nm9++Pzz/o3ttbW1tV+J6V/RuV4wvo8fffcXcF0+/UX9vADmF/yD + J271Zw3/9Jd4oeVRfhU2Lq7wfE5Enbs/m/az35wrqict48DJI+fkJc5cteaetB1T/jHfgbRnd9eZ2Nez + PD3zjZ/xjsmlKd3mAStctXoZG4+8au/Jk0O8dLsufvSKT031o5d59wq32dK1KC9+aemzBI5czlnjtQ41 + qjZdw+TCqk/N5kHzxifWPPaoM+c6qpc/0t5/7WZtbW3t12fxncD885T80Xe85OFygOcXenp98Rf+lF+u + CwB5/qsoP8dL66/xR1J+7vR6VtT1OTw4Lrt5KaJGdM7sq9d+6jnHzyMdRZ91/ff/Ley5388+3DDxyk/M + +KGlHeINjPnjTrn3LK85d3GUHzPKMXt/jlGfnnNdz7yfR/peV+591sUlZ/bEd5+zwhMr7l1T7rhm5izn + j37NP3C0HxzORf0r+z+ea2tra2sPFr9SI/485fUFv/4Vnfoib5cE8P6if/Dynzb7tf8Iqp6nzp9n1zPk + 89yeXW6fgcfqcR69viTdoc+++BbFST5xufrgHHpv/RE2/ha2XOfxOn2cF89Uz8K+zxfPPoeqpWW5+q6R + fIs1I+zKb7zEuu7cdVujZ1rfNXNfePG7XzOGiSu+ejcOXRyfk3uvNTDf2l2PnmFdd0+60kg8MMPl6sOf + +sxzR3NSM+Pn/7PfiVxbW1v7O7R4EYzvVPLH3//hHi8rmccvRf87+yLvFxkuR3hdXszF0yXYl50w9JvX + 88U3T0w7qD8wcvoszfG+R+SM1/8efMRf3Oo7kMdZ0m9nR13nDP7VUy6O5p335Mkb85jJXuGI7t5Pj1y1 + xdIyztA7ZtTzOZyL5y0N02TEjPWYFyZu1jPPemhp5+T6DCI4OUsffGrmfsNUD33DNdccnF+xew864eSW + Hvwv+2ci19bW1tZ+FZaXmfy6pHRpudcFxkvNa2Cvoi7HKwY3847TndN7ledc9AdnakWefnHihZ6P+Itb + fpf62tlnheusOiM48vlMyY/avHQq1yzniGu+uew/aI/58KxbG/zut37zCtfM4UPH8yvWLDFo9vnEh452 + gK8cc55PzDV6hhr04J68Vy6utLWv+9DXGaBvZy8e+1aLI6+z6Vx2PvZ/3r+dvba2trb24eYXHi44XXy8 + yNj3eMOPWpehtISdnMhHTBx9YJNfPcPRU4RW+LtfIOMM8vNM57OBp88bueN6hhsnMWicefpRZ1+9wnge + 5jXjs1f0vdrTNeeke/Sa33XOHNzUCDcdj61JjDV6vod41K5jDn7PDr3KySc+dK0nTechb77j6mV+zEbu + 0bUUO0c/fsUP/9NbW1tbW1v7GHt9mc2Ly3t9scWFdmHiFL9d/OJI56i1q7z2tK679nvedf7Fpbd/B3Ke + r8+DZ1TEs2bvePaaET+xjtnzPHbSxUt3LPLktwsTR3uzx1ozyQu/6YjTUT3ozrpnuacwPIf3vF+Rfcez + 9l7l5MhjhnPOUy0MufA7t/zY7Z549pHLZw9Rrucd/eR3r2vqffn2d/zPb21tbW1t7f1WFxQvKV1gcOS6 + /IQlT70bXz5r5/v8yQVObtTkg2OY6VRu+Lv/Ek3szfNn7M9FZ/T8dH921HjWwvhc/rn4Lsc1/9grDWoq + Eu9cO6TTeXpwxbcobeydGuG5g659vQP81uKc8xUNF9ZOHbrmmtd7IteeM/oOn8OMolwcOXcwDwzacOHS + 1r7EGJ0nrs4Uvfj1Pvuj7LW1tbW1DzNdarqwdEmV62Jj/bVcnljo1GXY2NiVOXrApdH9Os+hJd6JIb73 + R9j5AnntlOtcd6x73g8sc35mwNgnNvlXfnIrlzc23LWUZzScHjVc9X1evIrEyqndO45+uHEcLyz7/Myq + nnHoPDnnvJbmmDFe4NpZnLPHmP3qaab76lXNPH1wUat37lHM/Mvn7/if4Nra2tra2nuNF1FdWrqk+qKy + C4t4OS++vPQuL86hd78UW089x4RrVrE0TEu1z4a/+29hP52tzp05z8i+zlvPdcxVz3zOy+2zubxmrC5M + eeLQwjz2aaa5ve/0uy65qUn80Ordjs0dU6fPNXhZI465jMi/3hfWETPicJfcOKV5xZzPCNw1nJfx8upz + dswbN/Gj5xzogBO/coz/Ga6tra2trb3P/BLDpcbLyS+qynmJyS884uQJ6zx59NRg1Ew6uTWTeXNV10zV + wMQR/t7vQMY/ZWhnyDP3OTPqORirT073UMvPZ0sfWlYnF7V6pSeu58EzTDnOxzOa33aox1xzWV+uPPjq + VZ+YuI31bPEDY88x1PDkcA5RM6o7jjnbpT1ycLTL90qrd0z3uebXOWIu6iM6L7GcfeizJud7/me4tra2 + trb2PhuXkl1WdWERixx+XGRZw5uHefXEa8x1gTvvnNG+c68w1wuP+t0/wtY5/NkVu4dzel5+zLifs9Ub + +h0HLzimCY60GvcaWtanRs91HBzmvsN5PXfi8p5JN81w8E1LZzrOJ65js2ccy4Wnu96hk7ntfOKpLixy + nxfHnZwR5Vftzy2Pev8s5Nra2tra260urxeXkzC/4JHbTOSaO3rK1XvKtUPYmCF+7u66d2TkzEf8InE/ + h86X/tXnMA5zf7Z6HuYRpd95z/p883tn4+I25vycCUw959t8OTmBYx5Y1zpD905dcacezlG4eomxNt7I + NacoPnnCq8eZ4lsN7IqX65xw4uy7VvepZTh0ZkQOF3fOsScN9t753/ra2tra2lqaLq68iHSR8bKqC4o9 + XWxd9yWmOa/F97p2hOceanDuZU2+x9IXnhj4H/cv0fRZ8lx1Vp6reHoBeXg+5uhDU54c5/sMOdqh+s7p + M4ijXcm5+FVzdvaYJ47zC9MM5tvFjb5cGrmDexTnPPmlSy6xkSdn6msWuc6LqBwz2FdajIV7Hr3qI3fc + 91dNrnYBl6731Zt5ahk3a+Q/8z/FtbW1tbW195guJV1GdVFl3heiOy625jivetLMC0+X4BV5AWpefee4 + dnIyJz/cNCfW/v4/A2mfQ51lnlG1P0uf+epdc+XRTx3/bIgrZ1986cCVNy5t5d7vfcLhva+xxKWTPeah + /8jveu7gXMxI79C4RfLgE3Ou9rhe5RHpPpf8zLunHclLzOZYy7VH/OQEdvFGZD54pllc5x9zxbli7N5/ + 4nBtbW1t7a2miwmXoF1kxLsH90utLjy7yAJznc7hNa858nyP94T7PtWFZSTGuXe/QOqsfgY/33Dr/bVn + r5h9PX/MdS3MdbrumPr0ym2P5jr2+Xpu1vfdtvc4mzzq3M8+OIrc+RW88tKTU5d598CXlnv3emc6udI7 + c9Ta0WcpXnCEmes8WVNHM+cZnKfeuSsd+f5Kn7W1tbW191ldiuZ+mVWfF9Wo5wV28Oyi8z49+r5bO33u + 5ISG+s71HPUHvEDWbjuLndefP58pamJ6duRXFJcc8cHTDHg+WzPFmRH8nkMPn/GM97NUbrOuec6J7/k5 + 2xyrGccOOTVumMXWmrqlSQ3tKifm7tqqXUO9yh/qoVf1Hb/5pXE+w+xxVrv2x9hra2tra++0eVn5RddY + XVKOHTlq5saXtsfRp/ue5L3yJz3vXx74O18gz3/KcJxL53zy7B2fGWPg/ZydDycPHNXi9+cpvGfEee6X + R01t56rXu6F147iLzxozXoOTXn3kp/vcDcs9rE1r6jZ38AOjq/ZzSce5dUZy0qt37GLEvsZKw3LtEn7r + PWD7OyHX1tbW1t5mfRHNi64utapxGQaeXLvcNOuXGXiT6/Oep05w5Im72z5yfM71hH3EdyB13jxD5ufn + cu913XH07PlOHmJ/DrfIPLnUaczmiJUf3PBXs8I9FvfJqec6Hm+fg80WZj3MkGezM7aO5+qNeYvYxxnm + 2bvlxzOfOHP1gIPrOumJYUb9quk1H2783/7w6ff8T3JtbW1tbe2Xtb6QeMGFJ9YXVEZh1eel5T3G0guM + F9zQl+arePqF+z6do3fe9737O5A61zgLz6MzIh4Yc9Wt0Vxhk+fP2xreHzzixYu9D7sLS13wOzYvsYfd + kzf3iy+N2zx35syVCxMetfjiSae8+qg1573K1c84+1H3zt7tO1Ejf5qrWfVZS6Nz10StGeclZjsSiznO + XnF/qfja2tra2ntMlxAupL6cdFHpguoeLyv1cXEZj5da9jtHr7EzipealeOShHffZ2av+e/9DiReIPM5 + w/Nc82w66zz3VY8ZnR914DMH3zna4/lZ57zXDxrzDF03NnXVUz/55k8aTzN+hifMuT17xajlxvFeYOes + 5gvXTDh5d40zynvG50dtmM9Cu3Hviw/OvdY5Cs86+p/+zP8k19bW1tbWflnzS6kvqSO3i0y9rAfefZ9P + L9wuPfWo4X7OnVrKx1mIK3/7v4XNc9R+nifP5W7P0Fw/v3Gy1/nAgkPemEmN+xkiTzz7jtsZOJv9wbnX + mkuMLl3XkK7nIybeGhNHHPmNc/LaG7v6MVc9nK81eF7XLj7+N5WmammLn5jn7KcueSNaXhz36FHP68jn + PmBy/ie5tra2trb2y1pdPrcLyi6nvKjmpekOLvo1Vz2bozfXLsHgH5yalQ654jsnMeIRP+Iv0fRZ/ILn + M9CFo9cRM82v5zFvTcwlTq3iqb68+dJEvM0pklPnEIdeZ/KcdcXs4fm1b+bNqRjY6abp53G+zhDY0CXe + PMwOXFziT3NjJvkdsZMzpcHc5vqMd6zrqdUz83NDLc65+6qvfP9Zw7W1tbW1t1heQnU58VLKGjEvKF5q + Txxg5BnHeZifdXNnLm8MF6POUBrZF946pf0B34HEmXDejFn3mdz1bDr7OL/ca+WM4muP91sT+jWXmOFW + zznDc5ci8yumh27tRC+iuNIUR/zRE55186Vz6x28nA/PGWI2Jx+6B966FjVvOuJiP3pdTw3k4nQtjbse + 4tNecRMzvZGz/uY/P/9P/me5tra2trb2y5kuHlxSivNiw0U1o+bE6zn2WCPeudJQrzwx7UYtP/VdE1H7 + rvwDvgPp59GzCNe5Cov4wvUsQ4c44hNG7QNHjvqcq/raoRw4eollb56luZ23zrW3eMyPuepFzh5mZ0/z + 2NPnar15VtXoHZj0bU961raP0WeLP/Z2jth58uhjF71nFXG+7D/skD/xez/4+wK5tra2tvYW02V0XmrA + cIH6RdWXVV9i4qrfHOXN6x760vF5YfLmw51TGozwnHvbv8yBf8oQZ8lniHMz51mmEyu+nP2hZbmeUxrg + 8bOyXPPVZy5OO7Bzp2a8V/Xl4DZHsycPPZ7PdaLOntXsJ3b0hY1zEcdz+A7kzpXOs0bPI7/31AeHGlH7 + fMwQq5z85oo/Y80Vb+qBC6z4l6e2YVHvC+Ta2tra2ltsXEIZUcuzzsvJLz5ecOz3BcbLrXrzkvQ554t3 + z+WYU635dPUrH72/5Mvdl8//8Zsv3/7ul/rzYXqBjJ06q5+nzpT5+Xz9GdT5hTM2hzqldedGVF9Y72st + 9VsLvexn3T3x0Eev8zlXMxEtrz5ngKlnfZvRHLw5XYPbsXeUDvPsOXa5Y4/axheuOt1me757Q8tc/J7B + OZrv54KWap9X7b4vkGtra2trbzG/fMYFlpEXmDwvOcS60BjPS61qcqXj+qVBXFyf8TnxX2loRvOFXy6t + b758/vmbP3368fI//K0u2/gRdj2v7cs8z4TPdfR4Vs2JIwy8qfm1eT3zOQvnbHDYay3mptf1w37TgGMO + WOfJo6ZmHnHmQ0t9ep7hNiNM57BzWr817nPZJwe7pwZwYjljkb06E+sZm68Zn5+cOTty9qHDnZVP3xfI + tbW1tbW3WF5+utQit8sJUf2rVv+YwcVG3KP50/zJ0yXYdXMez2H9yo1fWjlHDXnxkvPT5d/Hv+Txrz98 + +nd+NP/XphdI6WqPztq1O/iV8zwVzTXjdeap3Z+ZYuXUuunn3Oxl7T3G26ww79GFT+6M8qF7empZpOs8 + cGpE72m3YR3ZE4+Y7wCGs1VPWtR17jmTdc3qrNg/uFY7XmexXcI69lk0o943f9wXyLW1tbW1N5guM1xC + ynnp1SWF6F5YxDF75uo33/dMTdYPXOTw6nOmsOw3f2hIN2vqcH5qcf56KYxfBZQ/+v4r/8YwXiCpnzqe + 83y1o/HuY6dHaYiH3Gpi3sua2E2jcHKL4z3mp3PHU10aAwMHu6A5eOImx88JHzn5mpUecnIyto5mmjef + Uz7w4gIvLOsZG/ez43yuob730hOzWHPYixl57wAHmGrwu97vQK6tra2tvcXmZdUXkl9cqvOSMu++4bwI + xX/SGHO8BB1P52XZesbnTOtB+9QrjrTU9/lDCzk40gX+6S/xo+/485RxSfufp/QfYdcealSu2rCeeTgj + +5OPnnjZt97QI366eFnXnhmHB4c7oe1Y6/iscPCvnPyTe+5zXHPnfHKGFs9A16xrDA9eziGv+cS0Uz3y + q+bzv8KoL83Asxc4e+JpRvP32s6ufs71eUePvt+BXFtbW1t7i+lSqkvMLib0mHvNmcBqTpGzs9+X4dhF + 19yI1ZsXaeWOkQfdiJzJmhzyR332VSfPNaBZ2sSumD/6vng/Y+Z0zUizdzR232P6zYmcdeOsldOlD5/6 + ijVLnjTE7zhn0zl34jfu0AHWHOMxP+fHDHc6x/uZc8/Mba405mxEuXDMt+dszTd3zNdOaeMc3jvz4iT2 + 9ZmKypMPjny/A7m2tra29hbDxaNLyC+k84LqSwsX24ziIvLSYw4N4jlzXIru1sfs/SzqCUsd1/IdLzDp + Slv95FQubs9oXjOuWzOJgVP6VUPfd8B7NrnknDl4/hzkyC+eOM5FfvCHpnJybLf3KkafPnfIzxmeWXPE + NZ990xsY57OWhmupll/10LCeziOO5sElJg69e7Nf86wLi/zQ7x1T32vl4EUkZlrCBm68fYFcW1tbW3uL + 6fKKy6fyvJD6ooKrbv7Mxem5U7NqxuRktDp6qWc60SfWOXHypFleOt1Tnjrsq1fRcpzBelc8z1X6Pk+/ + c9kT3/SEjxnTBM45YsD7HDVDjuqBswdcc16TTyyjPDnsXd76cHHu/fkZuAvr3pP+/dkab0z1qev9rOnN + M225cOOduXieRx/n4C7q+Q7lrQ9+cUpHvYNz1cM5E3FfINfW1tbW3mJ9YfXlpcuoMHpdnuRlffAGhz2/ + 9FB3XjPk3znO4x7ywZM/zyaXuOs3fsXUAt4RXhzyyoUfec/YWcVzrqI4Odt15EPLOJofLp3Lg6/94k5t + f87GZr+fv7RTb+JVM//a/NO5B/fkmabzk0duYRmJa85zcjX3dBbxMQMsolyc3scd6tF999l78uD7ebDP + Pr8Dz9rOgR7yfYFcW1tbW3uL+QXU3heULraOfTk2r/GMrIub9X1euHMzBrf6XTcHnhzyWqt5wkbO/tN8 + 5L3Dzi9O4azp54xrZ4+cwOXSVP/koCaP3IFZLay0lJMn3ZqXS+ch1kxgrH1Otes5p3Jpup8Yd5y9PnOc + Ba5+9BzPHrGeMb0jTm3Wtjty39FYn2FoWU/a6PnZeka9GZ/n1FM/cT8Dd4fvC+Ta2tra2lusLi1eQn1h + dY5eX1Kjz4tMF5x4uthKw/CadT/wyPNs1EE9++qNWWHiMI6zMZ/zmHG+aumh1xrVy3mej/nki3Pv3XKb + n1zmtsvnxdEO+aMezxKx8uyrbm3pnfioQ4e86tM1WxjnbnrW91j6wumBw0NjPpfwye+drS3sic/cuEND + /eyBp92ayaic7hrKVddM8iw6p3L0xQf3eoH8475Arq2tra29wfxS0iXUDjyie19YM4KrC7Ix52f/6LVO + 71QtLfTQF997Pe/nnnXt8lw1tbLO3tyF/PnsA6c7Dq1j1tx50q1oLp3mW9/46iNvvLH7WQrLnDXxk49+ + 183rudtsYF+Ll59n1bw0Mqau8Wxe+ZgjP2eiTy+M/jST3Btn4j5z8lVnP6Phl59nOF27et7ioSHfF8i1 + tbW1tbfYeSHp8koXxotK/eBnbe6X29Dj7Nl3vVtkrpmzLz0/w6lXvcCyPvk6B3cQ617P3vvMqdv67j17 + y4/YjtnA02OGc9pxyy9Xrnl4z8m1A9xZP3lq1GzvPjHfV3lwDFNe9dF3V095xuAy99p5iWXNXNjo2azN + O668Pp/EbJ415tgrDDy5OF03p3p2DuXphlePezrXeaC1P8JeW1tbW3uLPV9WxIgLy8sqo+e6wKhBfuu5 + 20UYfOKddz+j9dCf+amVzlntHP2xt59JXhzyBp41InaQR7/tulx834PadlnP+0Nv8FD7DPQnV5zMDe+z + EGftvKcdQ6+0gDtWUbnV2o18nuGG+ewVz7msBw7uXfPOQY75ybty00wPTmIP9dkzzv181IyZrHvO53vO + eqbj7pj09juQa2tra2tvMb+AlOclx0sLF9NxsSemGL2+JMFnn1yPwjXns8258pjhnM84Xl486hlHunMv + 64H5Wdj7ag5uemoc+AN222EcP0fWdK81k7VFzbmmvLjkDw26ZlvH3bjUGdjlwUNsrec+etl/OA/68JrL + fR2rz5nyqJMDrznrFRa58YZG4pw7/dCoeeXmOAee12fQ0zz7dK+dk3OcHbzss0ff70Cura2trb3FcCEd + F5NdSnVBGf6MxWxfkhmJR33r2Sz6psFc+Jg7+MU1jvCTm1py8ly/+lFXn1rmrpN9cm86R466zyb9OoPc + ecyztn5rdN58iyfu88T8DKpLm/yzr5maPXL31HPMNc1Pvebx2QfnvuvEvP7aTObUxzMCGz3bn9iDR097 + VN9w6UvT6uJwrmfbm9fzPrsvkGtra2trbzG/pPzi0qU0L6nuYY4XWeaqeQHavOPKVcvPvveqb2dofmO9 + 64mjefS7fsG1GDz1sj4x6RSmZ2xMOLjdT0y8mm+uej1LzFwamvPZpzOI39jZBybeGSd2x7Ou/bbPsFfn + E6Y5P0tyR691NHdqVX3F5F+5dBwvTLyMcjt/OLHps4951wGv+sSaaxhnfU61Zqdux32BXFtbW1t7i+nS + Cs/L7eGCy4uLl1pFYh79IktcvYM3nP3WdowcYVd81LdcZ0COKM9aXDr0gN/6ptfxzLUL7vPZszj1pucZ + yen5rsGb/XTTFK/xnik8OdZjrt7Zz17sfNirOHiFQTN3BC6MeenID05EnU+OPeRmjh3dZ236zpH2ife+ + ntcunxGuOfU0NzTCxRfH5jvqcyZ2cea86V0Onu11/uX7Arm2tra29hbLi0eXEC8lXVqeq/YLy3l1oVlP + l+TEWkP8mrud4+Q9cOniN5e8zMH/a/NnzJy8mgsv7M6buGPSdSeHZ5s87jt7WfeztoMrnmbkgdUZqXHy + x4xzbM5nimM1cuMSq3njalY5ziA96ysvXrtjqU/POmarr7w53eN87jE+68bRc1wayjNmX7zWdo70ME9c + HrU5NBB7ts8oLGb3BXJtbW1t7S2GC+y6mBR5OfnFlZdU9g2Li44+eOaDqyg/8Nyp2nv07DO2N8/nxznJ + Ebewy53Xjj3od+6Y8xOPvdytHLypVXzWnZtWuM5JHWk2H1hz2HO+cZuPnTft4vaMMOE9289RODWqZ5qV + a59hVStPzvTkyqOm196cwd7CMu96RJuXa6aieZ0j/KHvmHNbn5yv7sC56iyXQ6vr5Fav+XLV+7ew19bW + 1tbeYn7pjUusauZ5cSGq3xdX155XdL50sp7cM/8aBvzei9pd5y3eQy6dwunCXrm0z5mB5Q5F9PTcxTee + uMK6FzvJD5yYNOTAre9cRt+R+UMszxnMSUs8uXQVT37V4rP+2qx4mq9IB2eeSbnrasb11FMtnusXp/oz + L8xmVGe8uMhbT70xF7j1VOM8zau8uB1r7sr3O5Bra2tra28xXU7zQkKenpcZ+ojturRaoy851K3hXLk4 + yeNMz7aedqPHPGboVfsecm/55dpXM4aXfs7YM8iPOXBsf2LUYC4eNJGX7jFTvQc8+aenpnYZx+YVmyfs + rBHl0U8stLhHmGabRy75Jy+j6dxn2S+8e8K9vufQbh4i+nLMyL2n2ZsHXjyfR1/4mfv8OeM95/SuQ+PJ + jZu6UV9xXyDX1tbW1t5iuvR0CSFHXThdmF9ewDWjWvz7Rdhcw6kHTXGIsda+OkNGePMODvWkobnk05vX + c66JXnti5j1vfc6qN7HOT3zoB07vsxnOGj08V8eeE9ddc8jtcxHOHbUv8Z5xdx1EeO01raf58JoZtevd + dySX2tA3be4Tt3rkObfq6hnf8uJZfscmL89GLGt54HZGcFoDdWs4lnmd9b5rXyDX1tbW1t5i42LSRcTL + SD3huOTaJ4+55pN/zTJ6nn3j3nTloz814M1VnpGc0kmctXoWnTe4yh84547WVA+YOF0jpqY0mEsXeLv0 + pTV5/BxYD885z3u+9al7cRSdDwdXeGlphlh6Yp5bX72HOel13Xj12PezRN6u87Y3r2vxhXd/YsM5p/o+ + f/anxqhTy87I/uAYr6L1bvyLE74vkGtra2trb7G6fDwyx6V4v8DOvDk9+xgvB79rYFfUjoN741XOnu1Q + f/LcqU8/ecpR9znHuRizZ7nO41zgyH1eOHbwOV55zMmfelecO+d+5/qus/fV3LCpYWcPzuWB1RlY17xi + znYsHesXJzUmR5r+DIEVz2Z8zmc8ypOTOebgjaVO5ojK4b1fLg54qJvfmM6m/jlzc3LreazeF8i1tbW1 + tbeYLiVdariU+hLMSywuKF1Sh+uSq4uMPmYPbvHD2dd+4chNWy4908W+WTuWMes4EzmJo9Y5z1pahVWN + Z7tjzRuRfdTy7sOhkx65OMTESZ7F7jW3Zi2K98RB7jPA0jXnOLHXZzlmEieHDt48T7q4B6Zac9IHv3PV + vVfn0LmkQ77F5OYMMMxQO/ty6jNXr3XEgV7OU29wjx3Iu69e1nLpeU1u1PsCuba2trb2FotLRxceLiJd + XPeoCytzXlz3iwz8wlR7zijd0lbfdMWBtmamXmGccT+1T17WpWXxOEPmxxmaf2qKK+cOuTiH95yd02Yq + Jpec4iM6T7XOodnZg4Z0ikNMnPbJvfWq7/PEzQPTjOaBvzgXc/UwB0/N5HVekY6Z3iOdnlUfPe9nTA64 + mqn88FND7n1gV02N3tE7S8d2iue1PLB9gVxbW1tbe4vlRXQ5LjU4al1kuqgQ1fNLy+ebc+QZcSnmHDWl + MfnUTQ5m1PO5xJmfc9/86fP333z5/B+//dOnH7/58ukv6FODefELu+rYc3r0r9h7DKcL8zMNPeLFMaxq + 47aOaTEvjeohd03V1btcGl1r/q7vefd6rnDbAT3jyMnxHXdNYrXbcWn0jPLi2g53caQr/m3+r3nM245b + PTi923vgXjnjWbtezple5uSWq1f59d/9H/cFcm1tbW3tDRaXjy4oXVy6lHSZ6fLSZZe1X16OX7EvQeNx + Bn3tUd/4cnLV11zhVtdc5jhTvDzyEdP+7T//17/85su3v7v8u998+fRnzWO3ZuX384HPPZlrt2mE6wx2 + loEz71k4NMk1DnDoVa6+RegYdvmca9w54dUjT1rSUwSX+91r1p6H2sC93xqJk5Ou3PQiF09zcugZdmrR + 5/m7bv2pK25xiGEWM8VRztr7tevgiHf2xznIcS44qo9zMO4L5Nra2traW0wXVl9QuMR0Uak/Oca1ywsz + yDVz7/flp3xipmEz0sse+5U7rvp4gXyyf/3h07//9odPv7/431/+E87xoJXeZ27s6humM6vvsz1/57cm + cXn1DaO3vj4/9mLG8tG7vHYcPPSQtzb7no++zo28vefOGcd676WTHMx2zVwz4eRpbuiaJvqGK1d9uO96 + tVOeM696F+a14957VQs7dU8OeORGzTPtC+Ta2tra2lsMlxMuI11aeRnVBYaLSRdUOTmqwdXF17h6k/fc + e8KGpp+B+Zgv7PL/ixfIJ4s/Q1Y/+v7h88+354kdvof7Iw7e0SudmlWvPeeSZ/+bKBKvOmPzhDmuumbt + DM6RbuXjDM7TLKLPnJ496ohXs6PGvqgx23onp3umITcNzYA/eaXLXHXytKv6wLQ7ceWBJ4d8rzmj2h1Y + 483rGXn1L8eM8tbx+fD9M5Bra2tra28xv4T84vLLShdW8hJzLvGqj8uN/FMveezn7Bndc65jnYf5rRf5 + /+ML5Gn60Xe+VH759s/x5ymxp8+G3X2mxBgHfrlqnfOOI9czqac+NLt3i5cP7eTrM2ePPPSe+I2dc7mb + tc+pXzrGS0xuPfWlL+17n7sCuzQqz35j0Gncee5DL5znEuY9ce97Gut5xHRinhefeOvAi3+4eM+9ng/f + F8i1tbW1tbeYX0KdX5dTXXrCicmtFzUuue5X78GTl5G7bjm51JGWOCfPMfn5ZyD/llY/+v7y+bvrTPmj + b5zjivX8iP4M7Txn9Jn7M2i2eOa5I3Lq3njSNG1x5aMnLjkVL3ye6dhlOXiY6V7vSR75gbcDB0c7iT/0 + pKu+z8vHbPI7L17iOEPXwKBx72m+cHrW1Wtcvaljs7Wzualz4O6lV/uQJ5fYvkCura2trb3FdPFUtItJ + deasx+V2YahxMdYFZ5zBHxh46dpFPXFav/k1Z+cZOP2XfIE8Lb4zqTP4Ofys/TwXppicxoQ/cdQHLh45 + gYvHqHzMV33sdtz2CJNeabKv2jV65n4+zPD5iqcZclmfrjn3wRnnPXe+mK8e+s1nP2p56NE1E/h9ljzH + 6ZrT7HDpH1jPxJm6N87I2aj3BXJtbW1t7S2mi0iX0b3WhSW/cF5WuuDyAlMvaro4E+uZms2cs6VlGGtE + YKrTOd9+1W9+gcxz8exyP1P1Dk7z8EzJtV5/Hnru5jrP57KXn4n4PMOoe657mrMz1P7uKRdHWokZR948 + 7kqO/NhF3YGz53rSkovzpAFO91SPOUb0LvwJyxn58yw47GXeLq7r+dzsI3/CztniXr4vkGtra2trbzFd + ULqQqj5wXFTXxWW4LrLzEpu9q3YtYuqPmjzocV/1fd5nMddczL37O5C+38/lzxTx5NRzHTw9s881hzUd + Ovy8yOneFU27eMSrf+SugVnF3lG5zyqa+07kZ+/KiXnu/XbfD09+OOfHjqwV+dyWgwtNzUCjOU/7xK1+ + zlGL2PP8X9/ltfO8V3zWyvcFcm1tbW3tLfZ0Kd0uMPnFPXPMTTxnq+9avOiid2iVBvPSzZp61WsvXfK0 + 4+0/wub5dEY9i0edrZ6HuXB5zmv2CbcePgd8VtIdel5zTuerGfVMV5g0T/x06bi2+N07/luh+xmyLz3X + Vs9mNIe8+8Lv85hpHuKjG1866caZ52Fu3N5HjeSxFpdzwlKn5uXqQac4jD6zL5Bra2tra2+xuoCOy8gv + LTgvKXKFa+6GuVv/3OEz6mtu4DUD13zyHae/8wUyfzE5z+BnqfPEGa0uvGo8Rz3n6Zz3HfKYkTen84g6 + S+KaPbjqFY/Rcc1mnv3miFd+9ODeQ3/siT7d+aPHWmfQvuRUr/vCa/7w7D/g6Ye28JphHxjw2z7Ns9Yz + nX3NO9595IqlaRzF/T2Qa2tra2tvsbqU6LrEdKFlnxeWLi3hzW3eK43sW8/n1Gv8inYpNj5nlacbPzU/ + 4AVSZ3g8vyLzOr/19XmIJw5wuOPDQ8e0hOdnodnaIRfHdG02PWc011xpiYf+3DG0LIfOWU99cVwz+dR5 + NTP2W6/x7ovvM6VH/Nz5hI/8ijkv3D17vkv70C991u7iZh0c7iksOfsdyLW1tbW1N5kuJ7+EFIUj93rG + 9Loc5X1BPl2KjrtO5tRKTHlG53WNPXaWwN79Apnn4P54LjvveT6cnbzCvtJPrTvvCcesvVjwHNmnXvWj + lpMvnTN3dy3Ni9vnEd6ued93clFTn7yaTQ6eBZo8H/HbbPExf5srvHPU2OEambPX+IFVjT44PsvaonLN + iH9i2tU66AlLv+p9gVxbW1tbe4vp4tHFhGgXKHFhdZn55XXlwjTnnMTI7f7Uymhc9XPuoe8uHed/zK/x + 4ZniufmMitVLnuM6+6sacWgKu2LixRen9yh3P2eBiT9ngN9nvM58ROTuJ9e1VYvT3OY7T3lGefXs/Mbv + Ge6XVx9n9FlozfOD489gfXFyVn3iL2rH5YmZRnnt7B7yPs++QK6tra2tvcV08eiC8osJcV6OVducX2AZ + 5TUz69vMwdNu54f7Wfycgd/qD/gOZJ/Nz8nnzOc6njlceHJRV55RvY7zWaWhCF556BHPHvXVk1712RNe + 3MRmrtp1XeP0OX/fNyP5Oq/rV35w2C/O5dJDblzWiZkX33LxoI1Z9d0TT13Dgk9XPfrFZ9+0a3bsI8Z6 + 8K98XyDX1tbW1t5iuhx1Kekyknfd0XmZ8xJERC0cPIvWq3lz34MI3cEvXdTiKs/41u9A2o+weU4/9yss + ZhT7/P3sswYXNbWINa/x6tM1r7y4gRFPV37FOkfmpqcZemoL93i5etjHmjPKb7PZ59kMk97Zu+ses+w7 + T1z1kps5zvlUI8fnMCL1UN+5XSNPH/ul1d51a2CG+6yXfGL7Arm2tra29hbTxdMXFHJceLz0gnPjoae+ + 5jRbUT3OlI7h4BI/sYccde/QbETxPuzPQMbuzPXs+pxw3nwGuWr254x9VjY/tMKpBRx+8orv2o6zVznr + qeXen7nzxc1c84ydazexwpm7HzpnXzM+G7m8635e70nf/WufSfbEVS2ec688dxiG3X0O5wLjDB11z4j7 + ChNnXyDX1tbW1t5ifmnJ80Ial58uLuNF3zx7GY+LsvrAbz3q+YVZPOpmfsTOG0/nrg/7NT48k86pc2Ue + z0uvmj08x6yRN+Z1aRim2vULU792IoKDWBz2nO9YcWxG2OjTvc6cO+Vjd+QPO584kcvHDPviY8/Fyehz + PaN+5abh2jpzzorjXOKDkznP6bjNgY+92XcOe1OD52VfcX+Nz9ra2traW8wvn6cLSpdZXVjya2ZcdFe8 + XXwnrjxnLz3jFHbmR+3nGZxw8sLf/y/R9Dkiz7Pp3Bn7bOMzYI457xmHfWlXLV7ic1Z1zZuGXLPp5NSM + 949ZaOu55jMoFoczT65+xwu/7WruTZP7cWbnqUee4aVh5yzuMZMePOKaLQ1idx7cdZrPPPjWLw41Esu8 + 9zxpnP39DuTa2tra2ltMF1VfWF3jUuo8OU/5uMiAj1x97SEmTvTmHC5Dx3PeOHLhzbvipf3u70DmOexz + QN5neu7jGSNPjFzVxWWuWjPjmS2ml/6dP/vt0GDu/CtPt77zWgsz3ee8+Q2jbuv4vDt4Y578WeM5Wq9n + hQFv7rnDPTnk56ww1sI1773WsDqiOea0A3HMkzewy3VW7VS934FcW1tbW3uL6eIZF9N1UXX0y9IuuoOn + XD3pCoMrV4+XZ9TSShzx1PXZ00f/mnnvdyD1ZyDteR7O5ecbXNZ6Xp9Hb9bOl676T7h2qi9O8aOvPHD2 + gMn1HNJvjZMvjeRwVv3mESP3lhvPn6V0xTV+n5WYcaCj8xA3jna4tvJzVtz7PHzimjuewzDlwtNtNrWI + J6besSN8vwO5tra2tvYW0wWVF5ni5X5BVc3ornn0EOXnTOLkAmeee8W9z9UsuSPXLKPmP+TX+PA851nz + OfN8inouYKrBnbjPu15ixItb/c5VSwt83z8j+D2rGc1V7T3mrqUZ7w2NcHESt5j8zsUVJ135FaWJ/Z07 + 1u5znc+ZiUWtXuN3fumrd2lnnRH7z3nxysl3Dbn42tEYuVfcF8i1tbW1tbeYX1jufimVj8us8eSZRs26 + bs60Xs5TR7lq9DkfTk5xLWKGuuQm9lEvkFfMs9m5IsLJyd7kydWrmLzWqT3WdyydmOu4RunQhcExoznX + G5jywjl7ufTPWlzF3tlnk3Z5cZE3t/mVHxxpRC2uOOLNOfirvvQqF27e53QsdLpWX9q1J8868eRzlziJ + Zd2Y8n2BXFtbW1t7i+kyqgvK8rPO3C6zvBTr8hKOWH7rt452yKtfOzjHuuesvlyzvetj/hJNP0Of6451 + nq7n0TPaM8CBC1OO2J/dE9Zz1KYLK17s1jnM1Tu5GY3j9YnNXB7YxbWdhVmtmYpxTkb1hU2d3tn9Po/r + jNwjuaV14TrD3NUR2DmrGe2fecQ515zmMTedV9x9gVxbW1tbe4vlhWmeF5kuKuEH5pzML9dlJq7mxC3c + +rr0xDt3Dj2vDQPeF2jVH/ACeT4TauZ0PSPObD1ypSOueI6jd2ARU6M/Q+dIyznC2k8tcabe4DEPHmJj + XtccZ7Qzeamt+YnLT6x1cT54a5wzkz/7I/pc8ZFLp7WAOVc45vpZMorL6H13x7TDY2llbfNXvS+Qa2tr + a2tvsXlZMY/LSTUvLXGA33NdbNJAzj4vOq81L33Nnbi42Y+crhk5sN7/7u9A6ozaj3qe/fY8xmn87HeE + d7971CCuvD+nyTk9e7E/+T3/NJN953JHYuJV3zTUFz97eiZ/Fu5PXuPChIPreXCf+pyL+JD7fPWJS1MR + OGa7f+w6vGYfsBnbfb/PTI2pJXxfINfW1tbW3mJ9YV0XkF2Qupz6krILLjHxMd884M5xLc3IUU+ezqB+ + zmXdfZ9vXeO++89AxjnsrH0mPeM8r58V/fbC5ew3j1rGUe070j3PvmLPDyx38H8D5smzXH2fQ+1c9FSD + 13VxzRNTj9H9Nhe64aYBzkNOdx24cPZYi/vk3j9zx9J5Bp9F3pzR5/Mo93OJUxifI3U4ty+Qa2tra2tv + sbqAdAnxIgr3y0s9XWDFJV949TweeXIY4ecFCY+Zp7o0QpO65953/x7IPr+fEWcOVw/5MyfP/hWfGswT + BybOfYY7qj543F9c4davHZY7hhrziV/uWpkb94ZbXbrEyom1vvjYI/zkZX25+E/a52x5zfZzuUPTc39m + 41JD+tI7zzNmwo85cHpW/IwXZ18g19bW1tbeYnkx6ZLiRaQLqyM47n2BnT7nqg6NmgGeWtYvfMTWLq6d + IbDCLb7/F4n32SLC+1kyr3Nbn8/hmPJ8tuJ3TB3W0hc2Z/o8jTcPmsYdPc1a33SzNr5766rGrHrNC50r + Z+/kptcc99kZzrz4NdP86ieOvYmT43OFGbdzzGQsTvO/PnOvn3ce2OWaGX2fZb0vkGtra2trbzFdarqo + xgXFS+npwjsvtNIg9jWXjuZqX8zLvSZv5BnRbx3hV/5h34HsM0T0c2ad5z3OKu7BUQ0OdPpZFeWoS4Ou + ftcvetrJXP0Z21Un93DosjZ+aSXHucJ6TjMRzxnXcX3nOTfd8seezxFDzTOpl3ifN2fJE8dxeWvdZ+5c + 4plrruuKeQb0NbcvkGtra2trb7G8qOpC06XES445LilwdFF51Lz3q2e142f9rNE5zkIez1X8wphf8SP+ + Es15Vn+2cV7vse959PxZB6/62gOdwsQVP3ut2XPGCyfX+cifz3L2VXtfO57niVd9P784Pn/OKGpfYtxz + zslRc59zjx5cdfelp1nM6yxWG9drYOCL67Xz3J03NG1uXyDX1tbW1t5i48LTRcTaMfHOCwu9ebEJK+4x + U7o2X7Ew8sNzxuLlpcF8aFzx7X8GMs7Ns/czfP3FQP1+JkTnlwZz9Qq33D8b76fHTvZcC7yjH7Xc9wbn + pmN18YWRzxm5+umlp3jsPzx4wXGe9rQG+dzdZ+Ucd3a/8zGfefOLZ9HPIXee754c1BHFj+i7z13N7zP1 + HHT238JeW1tbW3uL4VLqS6hrXXy4pMqjpos3uNXjJUdc2uXOL97Uyj570ESsGasx2/X7/wwkzl7P8HCm + G85n9l5zDePnUZ8Fn/0J6948R+DCvOd4aUgne8xTp/FRRzzrK2bt2OVzr2KfL7nkR780yHWNiDMnhzx3 + 8SZmkXOnpmudZ+l52+0xezOXd227RoQPzdzZ52te1/sCuba2trb2FsvLxy48eV1KvLhweekCU83Z6mPm + jKcXPjTnxQhe98+5dOY933Pv/RF2/xnIPJPleSZ9Njy3zpvcwuSaOyM8Z+iqO1LTcsfqHMYZPJ4l/YHT + mPDmat5j9bMGT9yq2b9pZN35qSNu9li/9uZ3bE25MOe/6mVNDPvJcbdZ9U5e5snBWaWH3lVXf3LFKSdn + XyDX1tbW1t5iupjqggq3C80vsYjFMSyj8ssfOVa7ru8UB31i7uLKiUsvNYl9yI+w/VzM9ZyFXbHO6ZzR + n736LCwKH59fzupz5efB3DF3zbqO9zoyF5f70qMmhtnGbjPqCTvxF479V84dwKAtLeHprsmZ6ntNXp1F + eWkK43MF32esfvLieG1Y1KV9+OBePjjETu6+QK6tra2tvcX8MtIlpAsN/nzpKq9LzfucVczcdyjSHZP+ + ySln78RrjvmH/RlIO8M4W+Q6d3EeeFcPOGp9BsrF0bxmmwM9xeSm5nPPNRI37erVPHLVmhcPHO1oTmp4 + bZjymq2afHJqd0S5casnbuXUuBw7Zl47ye3+wbFauXYmVhqdF08c96M/sdmLGrv7HMlnD3vR379Es7a2 + trb2FtPlg3i/kHR56eJy90tMvJy3+pVW7TVMOj4zcPnV15zzhEX86O9A4lxdnz3VM58cuffwWfRM9bij + eZqb3PTgFn/yiu998iPXLuSmTU46MZ1F2KjFO2Yiv2k/4PMch/boqY/nqNy5iSmC71xE5MI9ug5w8AoT + j7nPDS324DzjLX+eU74vkGtra2trbzFdRLiAcOEq16WFiwt1XVhymxUWnNYhh72RX65+6/ulT1wzEZPr + Ln7PJ+cD/gykn7/OQlzPeOsTz2cT11zc9NLwXFrCyE1M+5BX/4zFBSa8auVWl1ff9ghPHTt/9runuTMf + GhHdH7Dgu0666yQHrt7JUU886Y25I3cMZ7jq0JYb52mXcGAPn59Hc+f0bpx3XyDX1tbW1t5idTHFRcXL + SpdRXVR0XXy6KOsitLwjLjVpnDPakfPV60u4+uTca7hmXSf77/4OZOy8Pevx/HR/FnCMq2dRNL50va9Z + 8YaGvLi+F+681gFHmLji1xy1MmctDa+1t3qaiSj8gVt843qNMx0c5ppXP+MxPyI9n+3UJudJM3PyT630 + wLIvXsyAL7/xGU9N7R356O8L5Nra2tram0yXj19CfnnhwuvLKvO4tHRxKfc6onlpWO/ElGcMTuAPWuGY + jUjsgffu70Dq8xpOzJ/NfZyZ/PO5Kvea3J6Zn4e0hSMn/9BQP936hRfP/ndRbRrVt1r7pSUMO5irT630 + yN05q37xL2+N7vvM6Zpvv7DS0hw1iD1x0QtNzGhv7+C+4FYdETxw1ev+Uy0Hrp7pyS/NfYFcW1tbW3uL + zYurLyZdWLoA1ddF1ZegLkzmhiFH3d48zSVX+FmTN3Szx1n1s+7+2/8MJPf6Oe/Pg75647OgAyfGuXTr + D/xyaXld8znT2NiZOTg9q9iamlFdnno8j/LQkl84ZrsHHWqRV3lEeXE7F7ex5hT+wnM+41VLr3LE4kdu + +o4Vh966fj48Y/E4V+crHuvMMV+5esm1HYydG//i7gvk2tra2tpbLC8tXVIZ+4J6vKR4UTm38Kw7nzj1 + uOuplu6co6Zwi75LZxH2US+Q+RyR5/l4HuYTR+3nTozPNfNZ155Ry6GrXZVbrRl5zBSmGYujT9f+lznn + hMk1D7xncPZDg5jPnTo9e8elMTzPZXyd8zivuI+45bdzW571g/7Ii9+x+d2PuvLLgyOe6sj3BXJtbW1t + 7S1WF1lcRH4ZZexcDgye2DUTHOehnv2K2RfP+a0x+jYvrPnN9V5w3/kCGf8Wts6S5+FZ6xnOGH266n6m + +RkgxzMFBgdHPOe+xp618xxWi+d8nVW59CeXfeMgWp8a4gZeuuwnRs7gMa/a54g5z/f1XszVPPNXcziD + c5/7iannmOnLe5a1zQ2cOxNXfrhrSGd/D+Ta2tra2ltsXnS4iHSRKS+Pi4t5XXJeH/lNQ3xG7QseXPkx + m+c7+d0TTzPRe/cLZJ7DXWe7PM+asT8Xd5/BcxJTHvPhhg1Nm1XevOYW33jeE1Y8x8ylUVqZd8ROzKPm + rGtph/rFtc/EeOK6l27m1ufsK62nfkbOA+cM65yRzoGD7/nBtVnpaqb2cFYzgasWVzm4hmvXFfcFcm1t + bW3tLaaLB5cRLqa+tBDrcouLyrhzlpeZcM4Ky5jc2T95jnevZ/IMZzywnHnzX6KpM9Drs7Po+fz8gGcv + azyzu+O5i3Xmg4NaWM1UrbxnK34V93yeVZjXmhk49SIXD/mFJ6ej75u9fp5TrzXZZ646+5zp/nkW6Ivb + WPN6tuN9pnnNUZ/4V85SvYiaydg7Cpdf9f4Ie21tbW3tLYaLbV5Mwupicr84HsV3jmppVs/y7FXeXOh1 + T1jv6/nOySUe8f0/wsa5tT+jnjfiQ47nJm71mJXbDCL2BK6Z7B3awKF3cspV1yx4mnN+Ysydm/XF097b + jOlI44wj1/zQucfg185w2xMxcWHC6d4rjZOXPT8f+84RnnGev/jet3k/v3qt1a750qr56fsCuba2trb2 + FtPFhIsMjkus87q0eEmh15h79VIDsXH0fFa5+mfutWN+xtZg7/J3/yUaPNf8vHReP1d9Lubn+UuH9Tkz + dJ2nmvyn88gb657m1fedcug+9+Q+j32zJ8y95iymj/Mgug7y5lbN/a7hOmM25ujo9Sxy7s0+a8Yxrzxi + 9lkbBhzzd3xqR19Y9Yj5XPGvuC+Qa2tra2tvsb6ceBnlBaWLyi9ai7z4Tiw1osd+ReMOzxnbz7p76vMc + xTct7nAsOW99gfz8nfbXs1jUmTzmuevsyP0ZxD2xdOM6x/eVJ7ej8nTPvU8c9Xkm9E4OXLnze165+k/c + wUl943Bvcrg7MeIVk0MecdTdBzb3lxZ11PMzwbHfPbmM597OuS9mxIucdTnnqq+8eshLW/nV2xfItbW1 + tbW3mC4kv6xwIfHCYj4vK7vA7EIrpw4uwSccu0aP/th74I6doVvayN/5Ahnf7azz1Tn6M42eXH1xb9jl + 4OIzzz5rzTTHcPXoT3hrEZc/zZgnn/2bruWlS/ysgfV/S6XFWe1Bbf/Nse55fTZ9njNOrHWzZ7k0iiP+ + was6+5fulSs6p3fyHOLZnLxxzieGPHqFZ9185zonfF8g19bW1tbeYnmZ6QLy/PKnC0p4531RCsPlhsuy + uNEnR73iq39EXKJ2wV+esXSag1rxvT/CjpfVPovOxpzPEZifeT5nc0as55zzHifWn5U8NbgDkVrKGTUn + rnijx77wrI8cteeYd3zwqZdRnpzG6zxnXzWx4cWbux53m2MXeaahfRnlo8/nPGfEy1nuJse5Y0Z99xOL + +vQL3xfItbW1tbW3WFw6uugidt6X4S2y75y6LNnL/OqdOHb05Squ8KcdrtE9uHg37J3fgfzj5/859t+e + AdjMraYDe8L5uUiXWsq/Gi+XHmLP3XZYjX5jfjb13H2uZpmXc178cSbO1JmMP2tih+bJHZjNooe68ugX + R8/UHPmJqS48896r3PmF0YF13TjPHR6Y5b4DuuRe2L5Arq2tra29xfJy0gWl3Gq/nF7lEfsy637mwVF/ + 1B17prnCxiy9d/GSvvLqM3/nC+S//ef/+hedsZ9F9Yzlef7m33vn/MTgwNXXbH0GxeHnyV7qZFSva80O + 7sHLPt1nMs+oGfTOWdXaH1i56z/Mhmvm1C8eMecob/zgGifiqI3jeqVj+albfLnVd6526HlsZswpguO8 + fYFcW1tbW3uL6XLqy4iXmi4lu7CQ90WnGvPkWPS50VNuXPCprZ77xXvsue4VtfOdL5Bh3/zp01/G+eM8 + OrNins/6EeVWP+kAV29yod8cnzu5rYG50jAO5r6C3XJErzUjjXMuojx5tx4w1HLymafmDQeWTl2v62yM + 4ldeO6E5+5NTfuzRjnDtBG5nTxzRZ9Nf9AKDR248q/cFcm1tbW3tLXZeUMrTdUFlRC4f/NAwLnrEbW7M + WI7+vZe1a7OnfubZk5N/5e/8M5Bh/qt8dB6du/F2PEM/j55l5PKrdr2KifNz8BnxGWtn9foM5dZzTtbH + XGGX956ecxwY88SnhuZ81mufBdb5qFOLOGtxivfg2oEoZ18aD1riopaG6yD3s4gftXjKhRevONa3fHKo + deH7Arm2tra29hbTReSXkV9e6ukCk2dPTv7IjznpnReiZpznee1JXcXGk29Ycd78Aqm/SJPPQtez9FkR + +7xwPQdc/fucc3MHce3z2nehxmw4tLtuTuMR4T7T/ZwxXLm0XE/uvXLNlIb2E6e7lnOrLg5njty9d7RW + z5yaV66oGWla1O7Rl7OvuvS9jhl5YrNXM5b78wUWvi+Qa2tra2tvMVxIuITqwrILqfF5UcHPWed0nn1e + dI75rPCbns0NPDx6py6f593fgfzXHz79+zx7f3Y40/wsddZ5/q6Vg9uc4h+xnx17aodzHT/m1HO+druO + MO8PrTPmDOfNWwOcyi3W7BH/Wn5q6Zw668mbHMxlX9yoT+f8mUsPuXHoT/2suWv0Hs5wzg784u4L5Nra + 2traW+y6fL6//CdcVH0ZnV6XVHDiYlNk/sgrvHma8QtSuHPrgjzyjJfXvsCIB0/z736BDIs/B6nz6Vw6 + I86G50sso3G9Zp61NNQjV3nx3INDx87eV1zOjpkrjl3WK1xzR+wdVxT/io6NmrFmrT+8ZpBjRt4916nc + 8Mn12mewY+w0TuQVDXc9nwXe5wB38jRfPdbi+dyJ+bywfYFcW1tbW3u7xeXzzR8//eG3f/r04/UC9nNf + foh9WeHCc0w1+p63nzOJsT5nUbNHvvCe79o1sv8BL5DX/ngZ73PobA8Yzn98Lsa7fQ6H1+yRq848dHNX + z6HPHuPoc6Z4xKb+wan89fNIw3Uao4656u7f99cMddQfu6688KPX3v3eaxpWS6MxOOqpN+fP2XNv77nz + wPVe8jMa//J9gVxbW1tb+3D7t+//9//3my/f/i5exuIvieR32HR56UJjrYtMF15eauY9g4uverz4nOP9 + 3tG5e+81/Mo/5DuQ1+Xd59HFz8+G51LPzw7s7PGzEFa5vD+rniVOTBxh4uTcC+8ZcnmWmvM6NP+KrvQ0 + N/o2H+57XC/nyA1cOnUG8tIPjuYGLzmzj93StZ5mrJb+S43Mm/9UD/zwwrLfO4T3DvvfgXj8TlL+57i2 + tra2tvbrsfyzfj98+/vr0vrut1++/bNfaMr9Uow8+wOblyxmTtcsOK4nDblriPMRL5Bh8Z1bnQHOz4bP + qzP6s9x8PC8+C82fOtIfWpqPmD37rIj7fOtCSzo1c/Qyt347dDR/5jj3nPfeyDNS03qVG5Y63oucXj3m + 7a3vHJ9RP/HkIVaumRd56Q6sXZj6wHE+7GBus+LPHPzw/Q7k2tra2trfjeE7b5/+cL08fX9davkCJdcF + mBdeOHNdluAIt/rAuwe9gUdtc9n7qBfI63PQWW/OMyN2Hj09y9Nsfx7R51zVzR+z2sXc8af9Z0+Ydsy9 + M9ec+KWZWnOHZjUvzokPDt33Yg4u/rnP++cer7OfOHiqy0vvPB96L3cQ91wczdUse64hTvUfHNw+175A + rq2tra393Vr86DtfKq+XuOsC/PG62P6CyxIXZ/mB+WWoi/N2kRrX68qvGL2P+g5kPvuX/ss0fk49i59T + PWGOZxx455oZGkff9wWvvXnFyRx9zXsUnpF6qOHJHX2bdy3lrIN/nqcw8rWr++RbT5j3Tx561EoMEdzj + eQI3Tkc8X3PxmU3dxqYWas1JI+cMkz5mZj857Bc/nNx9gVxbW1tb+4ey+Of+4s9TXhfdd7/98unPeQnq + orQLcF6YwMVDf16gqgtX74NeIMPi5TWfwc6j87/Cx8tA4cQu7uhrPnF41+B1ZE8Y83uPNT24VVNXmu43 + LLmtdfZPneSdZxqRZ65zYh7e815rtmfQT8xw9FpfuppxvmrHG9NMz5fXGeb+qmsve/TsH7PgET80UO8L + 5Nra2traP4Hhdyd++sN1CX5/XX4/6YLUxXhe1ujx4uTlOpxY9D/qO5Bh+ZeP/vQ5vwvpz6A6MV76jdkz + 82UAz4tnFj/zV25zwjTvc9IbsXo9m8696ez3nP3voGgu3YiYm2dRLK0jH/rGHfXp7Jc2c+1G3bsq0sXt + WT8XHHjPiKscu3B25YWJSy+MWjee4eADr7OwL+6+QK6tra2t/VNa/C3S+O7hN/GrhH7ov5DisS7MxPqy + xeXL/ANfIMN++8On+ItGdvb7C4Swei45XwrEP2fPmcirz51PmqVj5wr32XT1mFff8tJ6gY/9pWNc2zNn + J3ZyYq753QfuTq3Yc+zKeWKen37qDy2fuXLtHNzEgNfe6IvDvGZr5n529V2nZsiJuC+Qa2tra2trl+lH + 3/FCWL9KKC9PXax9edaFetUf+R1IGf59bL082FmZNz5fHjLP54Gr1qx6iHiZOPPBu7y0Mj7xdM724lAn + MXLnbOfVr15rjTnVzFX7GbWzcOqXs+8agQ+seJ1XndHOdmAv3XTCcc6HXuSqrzie4cqfZmJ34VXrjA8c + 6dL31/isra2tra29MP9VQpfnj751meoy/jW8QMbLb/3rNPaSoLpfDPiSQEy5ejVrM6rBsVqeOF80bC5q + uTg56/mh6zPtdq7w3PGiZu7nEa4cfc6ob3mfH3uhJay9e3MeuOdTr/rin84Z52g2MPWUl55qw5GjHjNX + PF2c3t8azWmN/Q7k2tra2traf8Hi4oxfofPND59+vC7Ynz/6R9iy/FF2XPR8AegXAVz6/jKQfUZ59sWp + 2e5lzBnmxQGmucntqLz6xmsOdYoH9xnnO8dnXbfcZlW3NjDXcJ56cH0uBz915jNkbrjPtM79OZITe4mL + 75qvetUfOD+PY6bwoxanddqF7Qvk2tra2traP4hdF3v8fsz5QsCXBnhg6CePXHD6ZaPz7gmTl87LWrtd + jxraZ9Hnindg59nHTmrUvPWd531h7k+9Uydi5sZTrV7tYX9yewd4xLwnt97Iqwf3Xu8n73Ll6hVW3N5b + NfvClEfcF8i1tbW1tbV/ILsud7xE2ovAdLw4RO4vBOolRtfMeIEIzxpRPJ9RH/POY24OTru46eyX7gOG + PcCBCXcOZ+W+g+587Wg/uVYnt+ebIz3mpqmZ4sd5qk++9w0TJ2eqdv2Iszc0OYd+81R3zj3hmuGOiPtn + INfW1tbW1v6BjL/ap35VUV78+ULQUS8B3UOdHMOdj2j86jmXO6Uxdsw58ZOTuzHb7vzGxU1d0wdv1unJ + R+563gfWHO8/7Xqll/jY11jU8nP+CYuIeUVyjvNiX59Z/Oxl3fHe8/09f+9d0faG73cg19bW1tbW/sEs + /5Wa/J2X10sAXzD8JUYvER3ZT+7E9MLgGpG3A6tZcsDrWfFSR9G4cw6cV9joi5P4kVsvYs298uDlLJ4t + MJ3ftbynWc04t86gWdWM0hGn5i9MOtqhXuOR92zqJI+5zX6tr7r0Bta9M+4L5Nra2tra2j+o6SUyXwT4 + ooHasHwhkKMXmPiZsz8w65314F5+1sXJOM8XrjNkZC3exDjDKE3lr7hVi8N8cK3uuclHfXJiHpzSefDX + WsY7zlPatuuJh5o5/dQtzx40pZdcasirz5l9gVxbW1tbW/sHtvjb2fVvZtcLw0NkL6PnjM3lS4vXnHnM + g1dY5+WjP1++4KbDWpzT0btyagFjX9hNq/M51/PF0yzjVzmGd33uMH5E9p5nmqf8jPLGMZseGGdv+pXD + lQtHPXn7Arm2tra2tvYPbv/2n//7X/TvgutFIF8Q6oVCOV44IgL3iN54mThmqpc1+rVLPeaOK3eXBhya + PjP2BcZ+xuL2+b0WZ+Li9rz0kleaHQtPzqyd4xE49qaTOzz1ppby1nidjznVyumYwTk0U2e0+XFWemD7 + Arm2tra2tvZPYvxdkfUv7PQLhL04RGReLw+ZT/cXjKwNA248OrjgS1sY+ppF3VrNca2qi9MapVO9qZl+ + 1D6LHZptjdRh7Vw/R+HmPtfePe8jzrnb2YlVn34+w5nrWQqn3/fPqDz1L619gVxbW1tbW/snsvgLNvnP + NcaLpF4w8kVE8XphEG4++oUxd75zXvAzPvRuLz+u61jOznlxpVF6By4f89J9wLL2HnN5YcI1w16f5zW/ + cuM4v2bE0czleI7Oz3nUjaVW4MknL7QiFs/m2TvrfYFcW1tbW1v7J7X4juT1svDTeImIWC8NfNkgjheQ + 5x4w1szFwQuJu/rw0uAOaQyMOwpnDo3jBSuctXaeuHpnDT906Tpb6Y1ea6kv/umOP3JNU+foaHzuay54 + hRuv5/yc5Bnfe2NXYfB9gVxbW1tbW/snN/5b2n+4Xgzw732fLyAj4qVCOV4ozhnnXDF69WLSvZphv7Ss + pxo9uPO9J744rgXOVXNW/eIcffGl2zqY8Tnxc/aKlRsOPXfuYu06VRMDbvvo0qhe6QlHrr5y1cB8rmfU + Bw69yq+4L5Bra2tra2trZfmLyL98+7vLv/vtl2//7C8S+RIh18vElfeLR79gKJ8cvcCgLg3LhWOmZ4WB + Z1zTzj7nnmZc1zmadzzi2dPsDb9yaasnTHPKs8fa/fXMxKUB7/rU1FxqMWZ+7r7qO5d59rSP8+TuC+Ta + 2tra2traV+1ff/j07/Edym++5O+VxI+886UCrpcPvWyonrFnTlyzUat38vLF52t+zGou49VPPcXimXZi + zS9X//LWBC7NG2ax+6brvcudW7ycQQ0nh/g5d/InLg3qcNbx5mHm5jlD7pXvC+Ta2tra2traf9niBSL+ + Ms71Yvnj9WL5s14s/IUjol5Iqp8vIqyN5z3ljrtjXjl0vc6c7nnpJa65jpkfXN9Vntjr84svTWCmT96c + s92BPfQ041rSvnMbS49Z9YmdZ3BtePNyzrj7Arm2tra2trb237b4XZPxo+/8G97xOyfr5UMvNHDH3fVi + kv3iNNd7zvcetJzHvLgTBx/nKydXtfovZ1NXz9H8mpUWddUXX73GgWUUnpFcOXvY6Zh87vZ9rYmdmss8 + +52/mt0XyLW1tbW1tbVfxOJH37/94dvf55+n/NPnn/RCkm4vKJVfjpcVeNfGyRea5p51zZpu1hbP3pOr + L27u0K7CuEd6FtXriN44O7k+M/XZy7z50kTeEfPgFcdnzU8+MOacU97czvcFcm1tbW1tbe1tlj/6jj9P + +adPP14vJ/mjb72U4GXleNkhFhzHZl/x/qIkTsQbTzoRieMs3QOGszlHc9Unpt6ID7z0xNWbvORe9U3L + cuk9xZ4RNvOI1Y89dOcV9+Fc+wK5tra2tra29mEWf+s7Xyq/fP6P+Fvf14tl/7vdfHEZLzsPeXKVu2ue + /cj7xerkdT5q62undIT5DkXN107Hb1zMS7MwcoTVTGI6A/afLo60lJ/10z7tTKxy1OLF/278n3BtbW1t + bW1t7eMtfi9l/rOLXz7nrxLqlxe+1PjLTLzwZM2XH+XufAlSLQ31fM71T6x5PT95jbknN8/Qc3UmRcMj + qufc4hXn/AyiNp7ynLfdR69cdfZ0fuLmgfF/qrW1tbW1tbW1X6/pR9/XC8z31wvMT3gpul5ovvbCo5ci + z3MOL12vX5CgBQ5xzTHveWA6izCfA24188Dg4KeWuBbBRU+z6PM8VSM6D9o6Y59NUTqZJw6fGp0n/3qp + 5/8sa2tra2tra2t/PzZ+9P2nzz/+Rj/6zhee+bI1X5zYj15wxIsXI+Li5IuTONkHd8w/1Gfec8A79ovb + 6aX5yjkfOXTg2uv1047sPWCuoVngqrP/Hf9nWFtbW1tbW1v7+7b40Xf8KqFv8s9T4lcJ6UVJL0GIfCHi + S1G9MFnfZ52jFynvZyRHec3S+wWMedWtUbjXoVvYPXdO5LPWWeR9TumURuU8d87Nz6l73/6OH/na2tra + 2tra2j+e4VcJffr99eLDf0XHXszoekkq/IyDc38Ji55moY8XLUXhzSUuf9BKvYyHFnP1q+e7qec65dGj + 9w5F+2wUkyf9wD/9hR/t2tra2tra2to/j8WPvuO7lPpXdPSSlC9K+SIlxwuVesL1gpX8erESNnuNi+t7 + 7li65qQdtfLCe7bmLlcdXHHOnms5v3Dqnh74N9eLOD/GtbW1tbW1tbV/Xos/T6kfffNf0ck/T9kvT3yx + cq+XrDtPdXD0Ujbr+4uc84QplwMDVzpe+7mU10xG6eF8xQvPOefMXJz9/Y9ra2tra2tray+sfvT95dvv + rhcn/Cs69jKlFyy9WOkFrGrlh2suZ40H/MqJeS1u1tXjvDQsP7Uj105peC9i7Tvy4qR/2r99vba2tra2 + trb2X7H80Td/ldA3P3z++XzBqhc0vXBd+eNLW7g4Ny5eSvES13Vw9GKX2DEvbMwYv2ZcIziG9Tww1w2P + l2p+FGtra2tra2tra/8vpl8l1D/67n9Fx1/Y6kWN9XiBs75m5gsc8nOmOMpLe74sDg/MeIg2f3nt8PnA + r2fkY6+tra2tra2trf0tTb9K6Hrp+i5/lZC9lNVLH1/O8LLXuL+86aWuZ9mTq3dw6mXQudmbuLilmzrd + d278ZSM+3tra2tra2tra2jss/zyl/Ss686XNvmNIHy97Vp8vfOVRZ69z1ORm3ljnjnsfc8x/2n/3em1t + bW1tbW3tg81/9H29WP54vQT2n6d88Hrp08skMb08qs8XvsyBO1/z4gK/8/rlMb7zuC+Pa2tra2tra2u/ + Upv/is63f/YXvHxRtO80Pnm/AFrkC2PNZt350GTOF8i/xHdMebS1tbW1tbW1tbW/F+tfJfT5u+ulDr9K + 6Hjp6+8o9nce3flCaFzW1suYffyi8HiZ5RHW1tbW1tbW1tb+3i1+9B3fHbxe9uxf0ZmeL5nyszbHC+X1 + 0pg63363L45ra2tra2tra/8Edv4rOtcL4U/1EskXSv8OI14oP/05vtMYL6L7ux3X1tbW1tbW1tbW1tbW + 1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW + 1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW + 1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tb+Xux//I//Hxaj + /Gt9YvBIAAAAAElFTkSuQmCC + + + \ No newline at end of file diff --git a/ProfinetMonitor/DeviceConfigurationFile.cs b/ProfinetMonitor/DeviceConfigurationFile.cs new file mode 100644 index 0000000..921fc0f --- /dev/null +++ b/ProfinetMonitor/DeviceConfigurationFile.cs @@ -0,0 +1,110 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using ProfinetMonitor; +using ProfinetTools.Interfaces.Models; + +namespace ProfinetMonitor +{ + public class DeviceConfigurationFile + { + private string OldFilecontent = ""; + + private string CurrentFileContent() + { + StringBuilder sb = new StringBuilder(); + sb.AppendLine("Name;MAC;IP;NetMask;GateWay;Role;Type;NetworkAdapterName"); + foreach (var dev in Devices) + { + sb.Append(dev.Device.Name).Append(";"); + sb.Append(dev.Device.MAC).Append(";"); + sb.Append(dev.Device.IP).Append(";"); + sb.Append(dev.Device.SubnetMask).Append(";"); + sb.Append(dev.Device.Gateway).Append(";"); + sb.Append(dev.Device.Role).Append(";"); + sb.Append(dev.Device.Type).Append(";"); + sb.Append(dev.NetworkAdapterName); + sb.AppendLine(); + } + return sb.ToString(); + } + + public bool IsDirty + { + get + { + return OldFilecontent != CurrentFileContent(); + } + } + + public List Devices { get; set; } = new List(); + + public System.IO.FileInfo GetDefaultFileName() + { + string fName = System.IO.Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, "Devices.config.csv"); + return new System.IO.FileInfo(fName); + } + + public void AddOrUpdateDevice(DeviceConfigurationFileEntry device) + { + DeviceConfigurationFileEntry fndDevice = null; + foreach (var de in Devices) + { + if (de.Device.MAC == device.Device.MAC) fndDevice = de; + } + + if (fndDevice != null) Devices.Remove(fndDevice); + Devices.Add(device); + } + + public DeviceConfigurationFile() + { + OldFilecontent = CurrentFileContent(); + } + + public void Save() + { + Save(GetDefaultFileName()); + } + + public void Load() + { + Load(GetDefaultFileName()); + } + + public void Save(System.IO.FileInfo fileName) + { + string FileContent = CurrentFileContent(); + System.IO.File.WriteAllText(fileName.FullName, FileContent); + OldFilecontent = FileContent; + } + + public void Load(System.IO.FileInfo fileName) + { + Devices.Clear(); + var FileContent = System.IO.File.ReadAllText(fileName.FullName); + OldFilecontent = FileContent; + var Lines = FileContent.Split(Environment.NewLine[0]); + for (var i = 1; i + /// 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(DevicesConfigurationDialog)); + this.splitContainer1 = new System.Windows.Forms.SplitContainer(); + this.groupBox1 = new System.Windows.Forms.GroupBox(); + this.listViewDevices = new System.Windows.Forms.ListView(); + this.columnHeader1 = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.columnHeader2 = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.columnHeader3 = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.columnHeader4 = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.columnHeader5 = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.comboBoxNICs = new System.Windows.Forms.ComboBox(); + this.toolStripOnline = new System.Windows.Forms.ToolStrip(); + this.toolStripButtonRefresh = new System.Windows.Forms.ToolStripButton(); + this.toolStripButtonAdd = new System.Windows.Forms.ToolStripButton(); + this.toolStripButtonAddAll = new System.Windows.Forms.ToolStripButton(); + this.groupBox2 = new System.Windows.Forms.GroupBox(); + this.toolStripFile = new System.Windows.Forms.ToolStrip(); + this.toolStripButtonSave = new System.Windows.Forms.ToolStripButton(); + this.toolStripButtonLoad = new System.Windows.Forms.ToolStripButton(); + this.toolStripSeparator1 = new System.Windows.Forms.ToolStripSeparator(); + this.toolStripButtonRemove = new System.Windows.Forms.ToolStripButton(); + this.label1 = new System.Windows.Forms.Label(); + this.toolStripMain = new System.Windows.Forms.ToolStrip(); + this.toolStripButtonMonitorMode = new System.Windows.Forms.ToolStripButton(); + this.toolStripSeparator2 = new System.Windows.Forms.ToolStripSeparator(); + this.toolStripButtonLogFile = new System.Windows.Forms.ToolStripButton(); + this.toolStripButtonInfo = new System.Windows.Forms.ToolStripButton(); + this.listViewFile = new ProfinetMonitor.EditableListView(); + this.columnHeader6 = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.columnHeader7 = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.columnHeader8 = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.columnHeader9 = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.columnHeader10 = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.columnHeader11 = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit(); + this.splitContainer1.Panel1.SuspendLayout(); + this.splitContainer1.Panel2.SuspendLayout(); + this.splitContainer1.SuspendLayout(); + this.groupBox1.SuspendLayout(); + this.toolStripOnline.SuspendLayout(); + this.groupBox2.SuspendLayout(); + this.toolStripFile.SuspendLayout(); + this.toolStripMain.SuspendLayout(); + this.SuspendLayout(); + // + // splitContainer1 + // + this.splitContainer1.Dock = System.Windows.Forms.DockStyle.Fill; + this.splitContainer1.Location = new System.Drawing.Point(0, 76); + this.splitContainer1.Name = "splitContainer1"; + // + // splitContainer1.Panel1 + // + this.splitContainer1.Panel1.Controls.Add(this.groupBox1); + // + // splitContainer1.Panel2 + // + this.splitContainer1.Panel2.Controls.Add(this.groupBox2); + this.splitContainer1.Size = new System.Drawing.Size(942, 395); + this.splitContainer1.SplitterDistance = 388; + this.splitContainer1.TabIndex = 0; + // + // groupBox1 + // + this.groupBox1.Controls.Add(this.listViewDevices); + this.groupBox1.Controls.Add(this.comboBoxNICs); + this.groupBox1.Controls.Add(this.toolStripOnline); + this.groupBox1.Dock = System.Windows.Forms.DockStyle.Fill; + this.groupBox1.Location = new System.Drawing.Point(0, 0); + this.groupBox1.Name = "groupBox1"; + this.groupBox1.Size = new System.Drawing.Size(388, 395); + this.groupBox1.TabIndex = 0; + this.groupBox1.TabStop = false; + this.groupBox1.Text = "Online"; + // + // listViewDevices + // + this.listViewDevices.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] { + this.columnHeader1, + this.columnHeader2, + this.columnHeader3, + this.columnHeader4, + this.columnHeader5}); + this.listViewDevices.Dock = System.Windows.Forms.DockStyle.Fill; + this.listViewDevices.HideSelection = false; + this.listViewDevices.Location = new System.Drawing.Point(3, 62); + this.listViewDevices.Name = "listViewDevices"; + this.listViewDevices.Size = new System.Drawing.Size(382, 330); + this.listViewDevices.TabIndex = 2; + this.listViewDevices.UseCompatibleStateImageBehavior = false; + this.listViewDevices.View = System.Windows.Forms.View.Details; + // + // columnHeader1 + // + this.columnHeader1.Text = "MAC"; + this.columnHeader1.Width = 118; + // + // columnHeader2 + // + this.columnHeader2.Text = "Name"; + this.columnHeader2.Width = 68; + // + // columnHeader3 + // + this.columnHeader3.Text = "IP"; + this.columnHeader3.Width = 116; + // + // columnHeader4 + // + this.columnHeader4.Text = "Role"; + // + // columnHeader5 + // + this.columnHeader5.Text = "Type"; + this.columnHeader5.Width = 78; + // + // comboBoxNICs + // + this.comboBoxNICs.Dock = System.Windows.Forms.DockStyle.Top; + this.comboBoxNICs.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.comboBoxNICs.FormattingEnabled = true; + this.comboBoxNICs.Location = new System.Drawing.Point(3, 41); + this.comboBoxNICs.Name = "comboBoxNICs"; + this.comboBoxNICs.Size = new System.Drawing.Size(382, 21); + this.comboBoxNICs.TabIndex = 1; + this.comboBoxNICs.SelectedIndexChanged += new System.EventHandler(this.comboBoxNICs_SelectedIndexChanged); + // + // toolStripOnline + // + this.toolStripOnline.GripStyle = System.Windows.Forms.ToolStripGripStyle.Hidden; + this.toolStripOnline.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.toolStripButtonRefresh, + this.toolStripButtonAdd, + this.toolStripButtonAddAll}); + this.toolStripOnline.Location = new System.Drawing.Point(3, 16); + this.toolStripOnline.Name = "toolStripOnline"; + this.toolStripOnline.Size = new System.Drawing.Size(382, 25); + this.toolStripOnline.TabIndex = 1; + this.toolStripOnline.Text = "toolStrip2"; + // + // toolStripButtonRefresh + // + this.toolStripButtonRefresh.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.toolStripButtonRefresh.Image = ((System.Drawing.Image)(resources.GetObject("toolStripButtonRefresh.Image"))); + this.toolStripButtonRefresh.ImageTransparentColor = System.Drawing.Color.Magenta; + this.toolStripButtonRefresh.Name = "toolStripButtonRefresh"; + this.toolStripButtonRefresh.Size = new System.Drawing.Size(23, 22); + this.toolStripButtonRefresh.Text = "Refresh Available Device on selected Network Interface"; + this.toolStripButtonRefresh.Click += new System.EventHandler(this.toolStripButtonRefresh_Click); + // + // toolStripButtonAdd + // + this.toolStripButtonAdd.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.toolStripButtonAdd.Image = ((System.Drawing.Image)(resources.GetObject("toolStripButtonAdd.Image"))); + this.toolStripButtonAdd.ImageTransparentColor = System.Drawing.Color.Magenta; + this.toolStripButtonAdd.Name = "toolStripButtonAdd"; + this.toolStripButtonAdd.Size = new System.Drawing.Size(23, 22); + this.toolStripButtonAdd.Text = "Add Selected Device to the Configuration File"; + this.toolStripButtonAdd.Click += new System.EventHandler(this.toolStripButtonAdd_Click); + // + // toolStripButtonAddAll + // + this.toolStripButtonAddAll.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.toolStripButtonAddAll.Image = ((System.Drawing.Image)(resources.GetObject("toolStripButtonAddAll.Image"))); + this.toolStripButtonAddAll.ImageTransparentColor = System.Drawing.Color.Magenta; + this.toolStripButtonAddAll.Name = "toolStripButtonAddAll"; + this.toolStripButtonAddAll.Size = new System.Drawing.Size(23, 22); + this.toolStripButtonAddAll.Text = "Add all available devices to the Configuration File"; + this.toolStripButtonAddAll.Click += new System.EventHandler(this.toolStripButtonAddAll_Click); + // + // groupBox2 + // + this.groupBox2.Controls.Add(this.listViewFile); + this.groupBox2.Controls.Add(this.toolStripFile); + this.groupBox2.Dock = System.Windows.Forms.DockStyle.Fill; + this.groupBox2.Location = new System.Drawing.Point(0, 0); + this.groupBox2.Name = "groupBox2"; + this.groupBox2.Size = new System.Drawing.Size(550, 395); + this.groupBox2.TabIndex = 1; + this.groupBox2.TabStop = false; + this.groupBox2.Text = "Configuration File"; + // + // toolStripFile + // + this.toolStripFile.GripStyle = System.Windows.Forms.ToolStripGripStyle.Hidden; + this.toolStripFile.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.toolStripButtonSave, + this.toolStripButtonLoad, + this.toolStripSeparator1, + this.toolStripButtonRemove}); + this.toolStripFile.Location = new System.Drawing.Point(3, 16); + this.toolStripFile.Name = "toolStripFile"; + this.toolStripFile.Size = new System.Drawing.Size(544, 25); + this.toolStripFile.TabIndex = 0; + this.toolStripFile.Text = "Save current Configuration"; + // + // toolStripButtonSave + // + this.toolStripButtonSave.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.toolStripButtonSave.Image = ((System.Drawing.Image)(resources.GetObject("toolStripButtonSave.Image"))); + this.toolStripButtonSave.ImageTransparentColor = System.Drawing.Color.Magenta; + this.toolStripButtonSave.Name = "toolStripButtonSave"; + this.toolStripButtonSave.Size = new System.Drawing.Size(23, 22); + this.toolStripButtonSave.Text = "toolStripButton1"; + this.toolStripButtonSave.Click += new System.EventHandler(this.toolStripButtonSave_Click); + // + // toolStripButtonLoad + // + this.toolStripButtonLoad.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.toolStripButtonLoad.Image = ((System.Drawing.Image)(resources.GetObject("toolStripButtonLoad.Image"))); + this.toolStripButtonLoad.ImageTransparentColor = System.Drawing.Color.Magenta; + this.toolStripButtonLoad.Name = "toolStripButtonLoad"; + this.toolStripButtonLoad.Size = new System.Drawing.Size(23, 22); + this.toolStripButtonLoad.Text = "Load from File"; + this.toolStripButtonLoad.ToolTipText = "Load Confguration from File"; + this.toolStripButtonLoad.Click += new System.EventHandler(this.toolStripButtonLoad_Click); + // + // toolStripSeparator1 + // + this.toolStripSeparator1.Name = "toolStripSeparator1"; + this.toolStripSeparator1.Size = new System.Drawing.Size(6, 25); + // + // toolStripButtonRemove + // + this.toolStripButtonRemove.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.toolStripButtonRemove.Image = ((System.Drawing.Image)(resources.GetObject("toolStripButtonRemove.Image"))); + this.toolStripButtonRemove.ImageTransparentColor = System.Drawing.Color.Magenta; + this.toolStripButtonRemove.Name = "toolStripButtonRemove"; + this.toolStripButtonRemove.Size = new System.Drawing.Size(23, 22); + this.toolStripButtonRemove.Text = "toolStripButton3"; + this.toolStripButtonRemove.ToolTipText = "Remove selected device from configuration"; + this.toolStripButtonRemove.Click += new System.EventHandler(this.toolStripButtonRemove_Click); + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Dock = System.Windows.Forms.DockStyle.Top; + this.label1.Location = new System.Drawing.Point(0, 25); + this.label1.Name = "label1"; + this.label1.Padding = new System.Windows.Forms.Padding(2, 2, 2, 10); + this.label1.Size = new System.Drawing.Size(807, 51); + this.label1.TabIndex = 1; + this.label1.Text = resources.GetString("label1.Text"); + // + // toolStripMain + // + this.toolStripMain.GripStyle = System.Windows.Forms.ToolStripGripStyle.Hidden; + this.toolStripMain.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.toolStripButtonMonitorMode, + this.toolStripSeparator2, + this.toolStripButtonLogFile, + this.toolStripButtonInfo}); + this.toolStripMain.Location = new System.Drawing.Point(0, 0); + this.toolStripMain.Name = "toolStripMain"; + this.toolStripMain.Size = new System.Drawing.Size(942, 25); + this.toolStripMain.TabIndex = 2; + this.toolStripMain.Text = "toolStrip3"; + // + // toolStripButtonMonitorMode + // + this.toolStripButtonMonitorMode.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.toolStripButtonMonitorMode.Image = ((System.Drawing.Image)(resources.GetObject("toolStripButtonMonitorMode.Image"))); + this.toolStripButtonMonitorMode.ImageTransparentColor = System.Drawing.Color.Magenta; + this.toolStripButtonMonitorMode.Name = "toolStripButtonMonitorMode"; + this.toolStripButtonMonitorMode.Size = new System.Drawing.Size(23, 22); + this.toolStripButtonMonitorMode.Text = "Start Monitoring of configured Devices"; + this.toolStripButtonMonitorMode.Click += new System.EventHandler(this.toolStripButtonMonitorMode_Click); + // + // toolStripSeparator2 + // + this.toolStripSeparator2.Name = "toolStripSeparator2"; + this.toolStripSeparator2.Size = new System.Drawing.Size(6, 25); + // + // toolStripButtonLogFile + // + this.toolStripButtonLogFile.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.toolStripButtonLogFile.Image = ((System.Drawing.Image)(resources.GetObject("toolStripButtonLogFile.Image"))); + this.toolStripButtonLogFile.ImageTransparentColor = System.Drawing.Color.Magenta; + this.toolStripButtonLogFile.Name = "toolStripButtonLogFile"; + this.toolStripButtonLogFile.Size = new System.Drawing.Size(23, 22); + this.toolStripButtonLogFile.Text = "View Log File"; + this.toolStripButtonLogFile.Click += new System.EventHandler(this.toolStripButtonLogFile_Click); + // + // toolStripButtonInfo + // + this.toolStripButtonInfo.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.toolStripButtonInfo.Image = ((System.Drawing.Image)(resources.GetObject("toolStripButtonInfo.Image"))); + this.toolStripButtonInfo.ImageTransparentColor = System.Drawing.Color.Magenta; + this.toolStripButtonInfo.Name = "toolStripButtonInfo"; + this.toolStripButtonInfo.Size = new System.Drawing.Size(23, 22); + this.toolStripButtonInfo.Text = "View Application Information"; + this.toolStripButtonInfo.Click += new System.EventHandler(this.toolStripButtonInfo_Click); + // + // listViewFile + // + this.listViewFile.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] { + this.columnHeader6, + this.columnHeader7, + this.columnHeader8, + this.columnHeader9, + this.columnHeader10, + this.columnHeader11}); + this.listViewFile.Dock = System.Windows.Forms.DockStyle.Fill; + this.listViewFile.HideSelection = false; + this.listViewFile.LabelEdit = true; + this.listViewFile.Location = new System.Drawing.Point(3, 41); + this.listViewFile.Name = "listViewFile"; + this.listViewFile.Size = new System.Drawing.Size(544, 351); + this.listViewFile.TabIndex = 3; + this.listViewFile.UseCompatibleStateImageBehavior = false; + this.listViewFile.View = System.Windows.Forms.View.Details; + this.listViewFile.AfterSubItemLabelEdit += new System.EventHandler(this.listViewFile_AfterSubItemLabelEdit); + // + // columnHeader6 + // + this.columnHeader6.Text = "MAC"; + this.columnHeader6.Width = 118; + // + // columnHeader7 + // + this.columnHeader7.Text = "Name"; + this.columnHeader7.Width = 68; + // + // columnHeader8 + // + this.columnHeader8.Text = "IP"; + this.columnHeader8.Width = 116; + // + // columnHeader9 + // + this.columnHeader9.Text = "Role"; + // + // columnHeader10 + // + this.columnHeader10.Text = "Type"; + this.columnHeader10.Width = 78; + // + // columnHeader11 + // + this.columnHeader11.Text = "NIC"; + // + // DevicesConfigurationDialog + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(942, 471); + this.Controls.Add(this.splitContainer1); + this.Controls.Add(this.label1); + this.Controls.Add(this.toolStripMain); + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.Name = "DevicesConfigurationDialog"; + this.Text = "Profinet Monitor"; + this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.DevicesConfigurationDialog_FormClosing); + this.Load += new System.EventHandler(this.DevicesConfigurationDialog_Load); + this.splitContainer1.Panel1.ResumeLayout(false); + this.splitContainer1.Panel2.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).EndInit(); + this.splitContainer1.ResumeLayout(false); + this.groupBox1.ResumeLayout(false); + this.groupBox1.PerformLayout(); + this.toolStripOnline.ResumeLayout(false); + this.toolStripOnline.PerformLayout(); + this.groupBox2.ResumeLayout(false); + this.groupBox2.PerformLayout(); + this.toolStripFile.ResumeLayout(false); + this.toolStripFile.PerformLayout(); + this.toolStripMain.ResumeLayout(false); + this.toolStripMain.PerformLayout(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.SplitContainer splitContainer1; + private System.Windows.Forms.GroupBox groupBox1; + private System.Windows.Forms.GroupBox groupBox2; + private System.Windows.Forms.ToolStrip toolStripOnline; + private System.Windows.Forms.ToolStripButton toolStripButtonRefresh; + private System.Windows.Forms.ToolStripButton toolStripButtonAdd; + private System.Windows.Forms.ToolStrip toolStripFile; + private System.Windows.Forms.ToolStripButton toolStripButtonAddAll; + private System.Windows.Forms.ToolStripButton toolStripButtonRemove; + private System.Windows.Forms.ToolStripButton toolStripButtonSave; + private System.Windows.Forms.ToolStripButton toolStripButtonLoad; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator1; + private System.Windows.Forms.ComboBox comboBoxNICs; + private System.Windows.Forms.ListView listViewDevices; + private System.Windows.Forms.ColumnHeader columnHeader1; + private System.Windows.Forms.ColumnHeader columnHeader2; + private System.Windows.Forms.ColumnHeader columnHeader3; + private System.Windows.Forms.ColumnHeader columnHeader4; + private System.Windows.Forms.ColumnHeader columnHeader5; + private ProfinetMonitor.EditableListView listViewFile; + private System.Windows.Forms.ColumnHeader columnHeader6; + private System.Windows.Forms.ColumnHeader columnHeader7; + private System.Windows.Forms.ColumnHeader columnHeader8; + private System.Windows.Forms.ColumnHeader columnHeader9; + private System.Windows.Forms.ColumnHeader columnHeader10; + private System.Windows.Forms.ColumnHeader columnHeader11; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.ToolStrip toolStripMain; + private System.Windows.Forms.ToolStripButton toolStripButtonMonitorMode; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator2; + private System.Windows.Forms.ToolStripButton toolStripButtonLogFile; + private System.Windows.Forms.ToolStripButton toolStripButtonInfo; + } +} + diff --git a/ProfinetMonitor/DevicesConfigurationDialog.cs b/ProfinetMonitor/DevicesConfigurationDialog.cs new file mode 100644 index 0000000..37181a2 --- /dev/null +++ b/ProfinetMonitor/DevicesConfigurationDialog.cs @@ -0,0 +1,243 @@ +using SharpPcap; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Windows.Forms; +using System.Threading.Tasks; +using ProfinetTools.Interfaces.Models; + +namespace ProfinetMonitor +{ + public partial class DevicesConfigurationDialog : Form + { + private DeviceConfigurationFile CurrentFile; + + public DevicesConfigurationDialog() + { + InitializeComponent(); + } + + private void DevicesConfigurationDialog_Load(object sender, EventArgs e) + { + comboBoxNICs.Items.Clear(); + var AdapterServ = new ProfinetTools.Logic.Services.AdaptersService(); + foreach (var nic in AdapterServ.GetAdapters()) + { + comboBoxNICs.Items.Add(new NIC(nic)); + } + + LoadFile(); + } + + private void DevicesConfigurationDialog_FormClosing(object sender, FormClosingEventArgs e) + { + if (e.CloseReason == CloseReason.UserClosing) + { + if (CurrentFile.IsDirty) + { + switch (MessageBox.Show(this, "File not saved, do you want to save now?", "Warning", MessageBoxButtons.YesNoCancel)) + { + case DialogResult.Cancel: + e.Cancel = true; + break; + case DialogResult.Yes: + CurrentFile.Save(); + break; + case DialogResult.No: + break; + } + + } + } + } + + private void LoadFile() + { + try + { + CurrentFile = new DeviceConfigurationFile(); + CurrentFile.Load(); + } + catch { } + finally + { + RefreshFileview(); + } + } + + private void RefreshFileview() + { + this.listViewFile.Items.Clear(); + foreach (var device in CurrentFile.Devices) + { + var item = this.listViewFile.Items.Add(device.Device.MAC); + item.Tag = device; + item.SubItems.Add(device.Device.Name); + item.SubItems.Add(device.Device.IP); + item.SubItems.Add(device.Device.Role); + item.SubItems.Add(device.Device.Type); + item.SubItems.Add(device.NetworkAdapterName); + } + } + + #region OnlineView + /// + /// A simple wrapper for the Combobox, that overries "ToString" + /// + private class NIC + { + public ICaptureDevice Device; + + public NIC(ICaptureDevice Device) + { + this.Device = Device; + } + + public override string ToString() + { + return Device.Description; + } + + } + + private void toolStripButtonRefresh_Click(object sender, EventArgs e) + { + RefreshOnlineDevices(); + } + + private void RefreshOnlineDevices() + { + if (comboBoxNICs.SelectedItem == null) return; + this.listViewDevices.Items.Clear(); + this.toolStripButtonRefresh.Enabled = false; + NIC NIC = (NIC)comboBoxNICs.SelectedItem; + + var DeviceService = new ProfinetTools.Logic.Services.DeviceService(); + var task = DeviceService.GetDevices(NIC.Device, TimeSpan.FromSeconds(3)); + task.ContinueWith(new Action>>( + (taskResult) => + { + foreach (var device in taskResult.Result) + { + var item = this.listViewDevices.Items.Add(device.MAC); + item.Tag = device; + item.SubItems.Add(device.Name); + item.SubItems.Add(device.IP); + item.SubItems.Add(device.Role); + item.SubItems.Add(device.Type); + } + this.toolStripButtonRefresh.Enabled = true; + }), TaskScheduler.FromCurrentSynchronizationContext()); + } + + private void comboBoxNICs_SelectedIndexChanged(object sender, EventArgs e) + { + this.listViewDevices.Items.Clear(); + } + + private void toolStripButtonAdd_Click(object sender, EventArgs e) + { + + if (this.listViewDevices.Items.Count == 0) return; + var onlineItem = this.listViewDevices.Items[0]; + var fileEntry = new DeviceConfigurationFileEntry(); + fileEntry.Device = (Device)onlineItem.Tag; + fileEntry.NetworkAdapterName = comboBoxNICs.SelectedItem.ToString(); + CurrentFile.AddOrUpdateDevice(fileEntry); + RefreshFileview(); + } + #endregion + + #region FileView + private void toolStripButtonAddAll_Click(object sender, EventArgs e) + { + if (comboBoxNICs.SelectedItem == null) return; + foreach (ListViewItem onlineItem in this.listViewDevices.Items) + { + var fileEntry = new DeviceConfigurationFileEntry(); + fileEntry.Device = (Device)onlineItem.Tag; + fileEntry.NetworkAdapterName = comboBoxNICs.SelectedItem.ToString(); + CurrentFile.AddOrUpdateDevice(fileEntry); + } + RefreshFileview(); + } + + private void toolStripButtonLoad_Click(object sender, EventArgs e) + { + LoadFile(); + } + + private void toolStripButtonSave_Click(object sender, EventArgs e) + { + CurrentFile.Save(); + } + + private void toolStripButtonRemove_Click(object sender, EventArgs e) + { + if (this.listViewFile.SelectedItems.Count == 0) return; + foreach (ListViewItem item in this.listViewFile.SelectedItems) + { + CurrentFile.Devices.Remove((DeviceConfigurationFileEntry)item.Tag); + item.Remove(); + } + } + + private void listViewFile_AfterSubItemLabelEdit(object sender, SubItemLabelEditEventArgs e) + { + var LI = this.listViewFile.Items[e.Item]; + var LSI = LI.SubItems[e.SubItem]; + var device = (DeviceConfigurationFileEntry)LI.Tag; + + switch (e.SubItem) + { + case 0: + device.Device.MAC = e.Label; + break; + case 1: + device.Device.Name = e.Label; + break; + case 2: + device.Device.IP = e.Label; + break; + case 3: + device.Device.Role = e.Label; + break; + case 4: + device.Device.Type = e.Label; + break; + case 5: + device.NetworkAdapterName = e.Label; + break; + } + + } + #endregion + + private void toolStripButtonMonitorMode_Click(object sender, EventArgs e) + { + var form = new MonitorModeDialog(10000); + form.Show(); + form.FormClosed += (a, b) => { this.Close(); }; + this.Hide(); + } + + private void toolStripButtonLogFile_Click(object sender, EventArgs e) + { + try + { + System.Diagnostics.Process.Start(Logging.LogManager.LogFileName); + } + catch { } + } + + private void toolStripButtonInfo_Click(object sender, EventArgs e) + { + var form = new AboutDialog(); + form.ShowDialog(); + } + } +} diff --git a/ProfinetMonitor/DevicesConfigurationDialog.resx b/ProfinetMonitor/DevicesConfigurationDialog.resx new file mode 100644 index 0000000..bd01e83 --- /dev/null +++ b/ProfinetMonitor/DevicesConfigurationDialog.resx @@ -0,0 +1,2626 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + 122, 17 + + + + + iVBORw0KGgoAAAANSUhEUgAABLAAAASwCAYAAADrIbPPAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAJkdSURBVHhe7N0JmGVXXehtOyFMARlFUUBFuTI4XGiCil4P + KrZNrK46e6+196rqLmnH1utVEfUaRT8rzuIIOACCiuCIs/hd5SIzojI44wwIMk+BMJOkv2/v7hUNlZWk + h6qz99nnfZ/n94Qx6a7/XmeftfoMHwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALDyQgoP297evjj/WwAAAAAYl9CG769T/cKmaW6T/yMAAAAA + GI/+AKtJ4f9ziAUAAADAKF17gOUQCwAAAIBRuu4BlkMsAAAAAEZn9wGWQywAAAAARqV0gOUQCwAAAIDR + uKEDrD6HWAAAAAAM7sYOsPocYgEAAAAwqJs6wOpziAUAAADAYM7kAKvPIRYAAAAAgzjTA6w+h1gAAAAA + LNzZHGD1OcQCAAAAYKHO9gCrzyEWAAAAAAtzLgdYfQ6xAAAAAFiIcz3A6nOIBQAAAMC+O58DrD6HWAAA + AADsq/M9wOpziAUAAADAvtmLA6w+h1gAAAAA7Iu9OsDqc4gFAAAAwJ7bywOsPodYAAAAAOypvT7A6nOI + BQAAAMCe2Y8DrD6HWAAAAADsif06wOpziAUAAADAedvPA6w+h1gAAAAAnJf9PsDqc4gFAAAAwDlbxAFW + n0MsAAAAAM7Jog6wTtVUz93e3r44/6MBVtbOzs4FR48evUN1rLpbvVXfq2magyGFh3Q9LKbYxFR/ZZPq + E81m+Mbu8fOy7l9/e2zrH+7r/v3jusfuJ/Z1//mvdT29VPff/05M4VndY+8zb+C/f/K1f59r6/7+j732 + n9P1Xf0/O7bxa/pfz6lf12a13rb1Q2OMn93/mru/fnJKG5/Q/14OHz58i/zbAwAA2FvdhmVxB1h9DrGA + iWia5sLNzSMfHTbD/WKMs1MHPG38mu6x7rLTB031E2KqfqM/QKpT/RchhH9u2vDm7r//wIc9Lk6oQ+nQ + +7rf4xu63+s/dL/vP40p/L/dfeZXup/Fz3Q/kx+Iqf7f3c/oq+JmFfuDsLatPmNzc/1jZ7PZzfKPFQAA + 4PoWfoDV5xALGK8DTdN8TNd/j5vVl5x+5VH93d1j5c92/U73+PWC/nCmruu3Fh/fdM6tp/W3NM387/t7 + RH/o1fWY7j9/VGzjl4cU1mKMD0pp4+4nTpy4KM8KAABYFYMcYPU5xAIW70B1rLpr2AyfefrVUvW3dD22 + aerf618hNU/z13WPT1dd7/FKo2o2m10TQnh9TOHPunvYb3Yz/InYVt/UtnXoD7n6GfezPj1yAABgEgY7 + wOpziAXssRjjHdu2uiS2cTOm+jubVP9C9zj37CpV/9o97kz2rXv68GZp9sGmDa+MKTy/m/9Tu//s8u6a + ONZdG5+1tbV153y5AAAAy2LQA6w+h1jAWeoPqbo++9Rby049htW/1jTzl9Z1/Y7i44x0/a7or5nu+vn1 + fA19WdM0n9u/fTRfZgAAwJgMfoDV5xAL2KX/UO8Y4yf3n33UPU58a5PqJ3WPFS849TlJpccRaY+6NF36 + 7pjCy2OqntZdd9/eXYMb/bXYf3NkvjwBAIBFG8UBVled6hc2TXOb/MsCVkj/LXT9N9LFVD+ie0x6Ykzh + Rd3jwnt3P05IQ9a/LbFK1SuaVD+9+/eX95+j1n8DZXfvujBfygAAwH4ZywHWqbwSCyatX9+n3vqX6v/Z + pPoJpw+q1t5ZfDyQlqSNjY33N838L7v76S82m+EbQwr/49ixYx+ZL3sAAGAvjOoAq8srsWAaunV8u67P + za+qemr/ypVL0sGrS+temmRteEPT1M/o/vXlbVsf6daDz9cCAIBzNbYDrFN5JRYslfX19dt2G/TP79bv + Zd2G/be7jfu/X29dS/r/5mn+uv5QK7b19/afreVQCwAAztAoD7C6vBILxqn/cPX+c39iGx/ebcIf26T6 + Zd1/dk1pHUs6g/7rlVqXnXrVYoy3yssNAAC41lgPsE7llVgwuPl8fqf+7U+xrX+4/xbAQ+nQ+4rrVdKe + 1H9YfLfW/vzUAXETtmKMn5iXIwAArK5RH2D1OcSChaq36nvHNn55TNXPN234x24dnrzeupS02Nrw5u5+ + /fuxrb+lbatL+ldC5iULAACrYfQHWH0OsWC/HAib4dP7b07rP7uqruu3FtegpLF1ZXf//qPY1t8RUnjw + iRMnLsprGgAApmkpDrC6fCYW7I36aH3PJtUnup7uwEqaTO+NKbyof6tv29YP9TlaAABMzrIcYJ3KK7Hg + rNVb9b1iqv/nqW8HTOFt11tXkqbYB/rPrOvW/nfHGD+7aZoL80MCAAAsp6U6wOrySiy4cVtbW3eOKTbd + 2n5ilapXldaRpNXq0nTpu2MKz+r+df9NhwfzwwUAACyPZTvAOpVXYsF/6jajN4+b1Rf0bx3qNqgvn81m + 1xTXjSRdWxte2aT6CW1bh6NHj94hP5wAAMB4LeUBVp9DLFZYday6W9OEr+7W7+906+HK660PSTrDLkkH + r+7uqX/e/evv699uuLOzc0F+qAEAgPFY2gOsLm8nZFX0n1/Tv+2nu+4vb1L9su6vJ6+7FiRpD3tb/yUP + sY0P7x53bpcfhgAAYFjLfIB1Kq/EYqI2NjZu320gN7uN5K911/oV17v2JWmfm6XZB/vPzoqpfkRK80/K + D08AALB4S3+A1eWVWExFfbT++CbVJ5qmfka/cSxd75I0WG14ZWzrx7Zt/dATJ05clB+6AABg/03hAOtU + XonFkgqb4YGn1mEz/5vitS1JI+xIOvL27rHrF9u2PnL48OFb5Ic0AADYH5M5wOrySiyWRdgM9+uu2cub + NvzL7utYkpaw9/avHO0/N2t9ff22+aEOAAD2zpQOsPocYjFG/bd6ddfl5/ZvvWna8B+la1eSptChdOh9 + 1x5m+RB4AAD2zNQOsE7l7YSMQH9oFVJ4SEz140MIbypeq5I04TY2Nt4fU/iDpgnHjx49eof88AgAAGdv + kgdYXV6JxVCufXtglapX7b4uJWlVuyQdvPrUNxqefmWW+zMAAGdnqgdYfQ6xWBSfaSVJZ96ptxmm+un9 + B8D7NkMAAM7IlA+wTuXthOyTpmnu0V1jj6pS9YrrXXeSpDNqPa2/Jbb1T4cUHtw9tB44/QgLAAC7TP4A + q8srsdgrMcZbxRS7y6l+Rv92mNL1Jkk6t0IIr+2/7KJtqwfkh10AADhtFQ6wTuWVWJyjpmkuDCk8rFsr + v3L6bS+F60uStKfVqf6rmOpHbG1t3Tk/HAMAsMpW5gCrzyEWZyHGeN/uuvmxjbTxxutdS5KkhTRLsw92 + z1V+s23rS/s/UMgP0QAArJqVOsDq8nZCbsz6+vpt+2/I6r8pq7teTu6+fiRJA9aGN/RvMYwxflp+2AYA + YFWs2gFWn0Msduuuh4PdWnjipenSd5euGUnS2Kpf1nWi/4OH/FAOAMCUreIB1qm8nXDlVdvVXbpr4bIQ + wj9f7/qQJC1FVVW9J6bqKflbDAEAmKqVPcDq8kqs1XTtq618ILskTaw2/GP318uOHj16h/yQDwDAVKzy + AVafQ6zV0M34dv1bTbp5/23pOpAkTaor+z+o6B77/3u+DQAAsOxW/QDrVN5OOFkxxs9uUv1LGxsb7y/O + XpI06WIKL2qasH348OFb5FsDAADLyAHW6bwSazr6TUpMselm+uLSrCVJK9kV/auyYoz3zbcLAACWiQOs + 6+SVWEstpY27d3P8wbqu33q92UqS1DWbza7pnvv8UdvWX9zdOg6cvoMAADB6DrA+PK/EWj7dvPoPZX9q + N7+rds9TkqQbrA3/ElP9CH94BQCwBBxgFfJKrNHr3ybYNOErmmb+N8UZSpJ0hh1JR97ePR/6oepYdbd8 + mwEAYGwcYJXzSqxx6mZyu/5Py+dp/rrS3CRJOtcuSQevbpr6GW1bf06+7QAAMBYOsG44h1jjkdL8k2Jb + P7aqqveUZiVJ0t5Wvyy28eEnTpy4KN+KAAAYkgOsm8jbCQfVtvXnddfo7/cfulucjyRJ+9g8zV8T2+qb + PBcAABiYA6ybziuxFmtnZ+eCtq2PdD/3F5fmIUnSoquq6l39K4G75wMfk29XAAAskgOsM8sh1v7rfr43 + 79+uUaXqFaUZSJI0gj7QPXd6aozxk/PtCwCARXCAdeY5xNof/c+0/2D2EMJrSz93SZLG1um3ttdPD5vh + fvl2BgDAfnKAdZb5TKw9s7W1def++qvr+h3Fn7UkSePvZEzhD3xzIQDAPnOAdQ45xDovm5tHPjq29Y9e + mi59d/HnK0nSMtZUL2jb+ovz7Q4AgL3kAOvc8nbCs1dtV3eJbf3D3c/vvbt/npIkTaWYwp/1X0bS3foO + nL4DAgBw3hxgnXsOsc5M9zO6R//NTYfSofeVfo6SJE2x7nnCX8UUm+5W6CALAOB8OcA6z7yd8AaltPEJ + TaqfNEuzDxZ/dpIkrUB1qv+ibetL8+0RAIBz4QDr/PNKrA9XHavu1r/iqvvZfGD3z0qSpFUtpvDXXpEF + AHCOHGDtUV6J1R9c3bX7WTyuy8GVJEk3VDN/aUhhLd8+AQA4Ew6w9q5VfSXW1tbWnX04uyRJZ1f/1sKQ + whfm2ykAADfGAdYet0KvxDp69Ogduuvnh6qqek/xZyFJkm66pnpm2AwPzLdXAABKHGDtfVN/JVb3e7t5 + k+oT62n9LaXfvyRJOvtiCs8Km+HT8+0WAIDrcoC1P03xEGtnZ+eC/sNnQwivLv2eJUnS+TWbza5pUv30 + +mh9z3z7BQCg5wBr/5rQIdaBtq2PdL+fvy39PiVJ0t42S7MPds/Rnri5eeSj870YAGC1OcDa55b8M7H6 + D5ftvy2p+HuTJEn73ZWxrXdW8UtiAAA+jAOs/W8ZX4lVb9X37t/CUPr9SJKkxVbX9Vtjqh/RPZ+4MN+q + AQBWiwOsxbQsh1hbW1t3jm392O7XfNXu34MkSRq2EMI/xM3qS/JtGwBgdTjAWlxjPsRaW1u7dfdrvKyq + qnft/nVLkqRx5RsLAYCV4wBrwY3sM7H6bxZsmvAVIYTXF3+9kiRprF0VU/34aru6S76tAwBMlwOsxTeW + V2LFGB8UU/iz0q9RkiQtR1VVvaf76+Xdff1W+RYPADA9DrAGasBXYjVNc49u7r/e/TpOXu/XJUmSlrJ5 + mr+macJWd6s/cPqODwAwIQ6whmvRr8Tq/2S2++dedmm69N27fy2SJGkaxRSe7/OxAIDJcYA1bIs6xGrb + +kgI4dWlX4MkSZpWs9nsmu453lP7bxfOTwUAAJabA6wRtI9vJ+z/BLb7+7+g+M+VJEmTbj2tvyW28av6 + L23JTw0AAJaTA6xxtNevxOr+XreLbf3Y7u991e5/liRJWq1iCi8PKTw4P00AAFg+DrDG0x4dYh2IbXz4 + Rtp4Y+mfIUmSVraT/dsKNzePfHR+zgAAsDwcYI2s83g7Yf92wVOHYKW/ryRJ0umuaDbDN85ms5vlpxAA + AOPnAGuEneUh1rFjxz6ym+Njuv+vtwtKkqQzqk71X8UYH5SfTgAAjJsDrHF2pm8nzN8u+NrS30OSJOnG + yt9W+MT+D8PyUwsAgHFygDXebuwQK8b4cTGF3yr9/yRJks6qNryh/wzN/DQDAGB8HGCNu92HWP3nVcRU + P6L7767c/b+VJEk6n7rnhX+Y0sYn5KcdAADj4QBr/F17iBU2w/1jCi8p/W8kSZL2qPd2Xd4997h5froI + ADA8B1jLUZWqf+0/p6L030mSJO11PuQdABgVB1iSJEkq1f/hWWzrx57NtyMDAOwLB1iSJEm6sUIIr27b + +qH56SMAwOI5wJIkSdIZdLJ73vjUo0eP3iE/jQQAWBwHWJIkSTrj2vCGkMJGfioJALAYDrAkSZJ09tVP + n8/nd8pPKQEA9pcDLEmSJJ1LG2njjSGFOj+tBADYPw6wJEmSdH7VT9/a2rpzfnoJALD3HGBJkiTpfAsh + vCmksJafYgIA7C0HWJIkSdqruueWT11fX79tfqoJALA3HGBJkiRpLwshvLpt68/LTzcBAM6fAyxJkiTt + dbPZ7JrY1o9tmubm+WknAMC5c4AlSZKk/Sqm8HdtW31GfuoJAHBuHGBJkiRpP9vY2Hh/99fLdnZ2LshP + QQEAzo4DLEmSJC2imMKLUpp/Un4aCgBw5hxgSZIkaYFdEVNs8lNRAIAz4wBLkiRJi657DvrU7e3ti/NT + UgCAG+cAS5IkSYPUhn/0Ae8AwBlxgCVJkqSh6j/gPab6Ed3T0gOnn50CABQ4wJIkSdLgNfXvzefzO+Wn + qAAAH84BliRJksZQCOG1bVt/Xn6aCgDwXxxgSdL4qqrqXd1G7vVNG/6lSfXLYgrPaZr6Gd2/fvq1xVQ9 + rXsMf+K1xbb+6a4fvk4/0P29LuuLqf7uXf/dqa77/8/9evfP+q2uZzVN9YL+n91/Rk3XK7u/z9uatPbO + a3+NkrRPXdU/ZjVNc2F+ugoA4ABLkvajS9LBq0MIb2qa+d83qX7eqQOntv7p7r+7vNkM/6vbnKW4WX1J + SOEh3SbtYIzxk6tj1V2PHTv2kfnhedT6bw7rfs0fFzbD/bpf/+d2v4+1pgnb3e/r67vf53d1v88f6+4v + T44p/G7Xi/qDuEvTpe++7s9Ikm60pnpu9/jyMflhBwBYdQ6wJOnM6z9suD+M6R47nx1T9ZTur98TU/0/ + Qwp11/9IaX6fGONHdQ+vPoy4oPvZ3CqljU9o2+qz4ma1Htv4VfnA63H9YVf/iq9TB3+Fn72kFawNb+ge + N2b5IQQAWGUOsCTpPzvZb5aapvrz7rHxN2Nb/0RM9SP6w6m2rS7xSoDFOX78+C3rrfpebVt/fmzjw/tD + rm4mT2ya+v9UqfqnWZp9sDA/SdPsqu4x4Nu6hwZ/MAAAq8wBlqRVq67rd5z6bKfTb+v74f6ApH8bX9dt + 8kMjS+Do0aN36N++2M3xRD/Hfp79XL1VUZpoTf2Mft3nhwAAYNU4wJI00T5Qp/pv+w8k7/71D8Y2fnlI + 4cFbW1t3zg9/TNeB6lh1t27eX9hshm9sUv2E/gPpj6Qjb991jUhattrwyratHpDXOgCwShxgSVr6+s9I + SeGPu3/96Jjqo93m5lNns9nN8sMc/Kf+baD9wVZsq2/oD7a66+b53XVzxYddT5JG3anPImzCV+dlDQCs + CgdYkpaoq6pUveL0W8XC5W1bH+m/uS8/nME529xc/9j+euqvq/5tSv2rPK5z3UkaYTFVT+u/ETUvYwBg + 6hxgSRpjl6SDVzfN/G9iqn+uacJXtG31GSdOnLgoP3TBvsuv1npYdz0+qrtX/mbThn/ffZ1KGrb+reIp + zf9bXrYAwJQ5wJI0ik59+1/9jO5fn3pllQ/qZYz6Q63rvlLr9BcCFK5nSYvsypDCRl6mAMBUOcCStOgO + pUPvq1P9wu7x58djik1KG3fPD0mwVJqmuTBshk9vUn2i6xdOv8U1nNx9zUva32az2TWxrb+jW5YHTq9O + AGByHGBJWkDvjSm8qNtc/HDb1g89fPjwLfJDEEzO+vr6bfvrvL/e++t+bW3tQ4U1IWlfqp/uc7EAYKIc + YEna6/pXWDmwgtOaprlNvw66tXF5ty6e1f31A9ddL5L2uGb+N/XR+p55CQIAU+EAS9L51h9YdY8lz46p + /u6Qwv9wYAU3rD/Q6tbJoW7tPLrbaP9l91dvOZT2vrd16+wL87IDAKbAAZakcymm8Hfd48ePxM3qCxxY + wbmrtqu7NE3Y6j9Dq2nDf5TWm6Rz6qpmMzwyLzUAYNk5wJJ0hl3ZPV78TrfR/mofug77J6X5fWKqH9Gt + tz+8NF367sJalHQWxVQ9LcZ4q7zEAIBl5QBL0g3WzP+m++uj27b+/BMnTlyUHzaABelf3di/3bC7V/9U + lapXXW+NSjqzmvlLNzfXPzYvLQBgGTnAknSd3ts09W/HNn5Vday6W36YAEaibatPbVL97f2XJFySDl5d + WMOSbqB5mr8ubIb75+UEACwbB1jSynfFqbdXbFbV2trarfNDAzByW1tbd46p/tIm1U+vqupdhbUtaVfd + WnlPSGEjLyMAYJk4wJJWsrd1a/+pbVsfaZrm5vnhAFhS/VsNu/X80NjWj23a8ObCmpf0X/Xf/Hl5Xj4A + wLJwgCWtRvM0f02/ue03ubPZ7Gb5IQCYmKZpLuz63H69b6SNN5YeDySd+nD3n/eHOACwRBxgSdMthPBv + /Rpv2+oBeckDK6Q/zOq/hCG29U93jwevLz1OSKtcTOE5R48evUNeMgDAmDnAkqbVkXTk7d26fmL/Coxu + iR84vdKBVbezs3PBta/MWk/rbyk9fkirWJWqf6236nvnpQIAjJUDLGn5O5QOva//IOf+M61OnDhxUV7e + AEX5M7OOdM8Bntp/qHXpcUVapfo//OlfrZiXCAAwRg6wpOVsbW3tQ01TP6NpwpZvDwTO1bFjxz6yexw5 + 3jTVMy9JB68uPd5Iq9AszT7Yf7NnXhoAwNg4wJKWq5jCi2JbfV3/Ffp5GQPsiaZpPqbbwH9z08z/vvT4 + I61AJ2Nbf0deEgDAmDjAksZfXdfv6NbqE2OMn5aXLsC+aprmYP95Wd1j0Nt2PyZJU6+75z7ZN/YCwMg4 + wJLGWffE+ZqYwrNiit0+0td8A8PoPy/r9ONQ/QxvMdRK1dS/5y36ADAiDrCkcTVP89d0f7282y3eIy9T + gFGoj9YfH1P93SGEV+9+7JImWVP96Xw+v1NeAgDAkBxgScPXv6rh2ldbecsCMHY7OzsXtG390P7bT7vH + sKt2P6ZJUyqE8G/1Vn2vfPkDAENxgCUNV5WqV8W2/rZqu7pLXpIAS+XUq7La+gc20sYbS49z0hTqr++2 + rR6QL3sAYAgOsKTFd+qbBL3aCpiQpmkubNv6SP9q0u5x7uTuxz1p2auq6j3dNX5pvuQBgEVzgCUtpv6J + b0z142OM983LD2CSUprfp3vce1zXldd9HJSWvbW1tQ919/IvzZc6ALBIDrCkfa4Nr+z+elmM8Y552QGs + hPX19ds2qT5RpeqfrvfYKC1vJ2Oqvzlf5gDAojjAkvana98m2L+tJi83gJWUP/T92rcXFh8zpWUrtvUP + 50scAFgEB1jS3nUoHXpf/zbBequ+d15iAFxH/0HYTap/aZZmHyw9jkrLVGzrx3aX9YHTVzcAsK8cYEnn + X13X7+i/hWtz88hH56UFwI1omuZjusfN7+0eQ9+2+zFVWq7qX/KlLACwAA6wpHMvhPCm7q+Xb2xs3D4v + KQDOwvb29sUx1Y+Yp/lrdj/GSstSTOEPYoy3ypc1ALAfHGBJZ18I4d/6Ddfx48dvmZcSAOfhxIkTF8U2 + Prxp5n9fetyVxl/9vGPHjn1kvqQBgL3mAEs682IKLz+9wfLB7AD75ED/ge9NU/1p6XFYGnf1y2KMH5Wv + ZQBgLznAkm6ykzGF/7fbUH1eXjYALECMcdY9T/mjwuOyNNqqVL1ic3P9Y/NlDADsFQdY0g3Xf+V721aX + 5OUCwAC6x+HPaFL99O5x+eTux2lpjIUQXh1j/MR8CQMAe8EBlnT9+oOr7onng/IyAWAEHGRpqWrDv6c0 + /6R8+QIA58sBlvRf9QdXYTN8Zl4eAIxQ9zj96Q6ytAyFEF4bY/zkfOkCAOfDAZZ06uDqRf1nreRlAcAS + cJClZWgjbbyxu1bvly9bAOBcOcDSStdUzwwpPDgvBwCWUNM0B2MKf1x8nJdGUH+IFWO8b75kAYBz4QBL + K1lTPbdt68/JywCACQgpPKRO9YuLj/vS0LXhzf2rBvPlCgCcLQdYWqVCCP8QU2zy5Q/ABLVt/dA61X9V + ug9IQ1bX9Tt8uzEAnCMHWFqF5mn+uibVJ5qmuTBf+gBM2M7OzgX9H1hUqfrX0n1BGrArfGEMAJwDB1ia + eFd0XRZjvFW+5AFYIU3T3Dym+uv7t2/tuj9IA7b2Tq/EAoCz5ABLU2yWZh/sru0nVtvVXfKlDsAK297e + vri7P1x+KB163+57hjRQ/SuxHpgvUQDgpjjA0sQ62X+len20vme+xAHgP1XHqrv1f8Axm82uKdxDpEV3 + RdtWD8iXJwBwYxxgaSqdetVVCg/OlzYA3KD+7VtNU72gdD+RFlob3hxjvG++NAGAG+IAS1OqTvULm6a5 + Tb68AeBGtW19xAe9a/AcYgHATXOApcnVVM9dW1u7db7EAeBG9R/03myGR3b3kP6LP8r3Fmmf678xOaX5 + J+XLEgDYzQGWpphXYgFwtubz+Z1iWz/W52NpqEIIr/U5ngBwAxxgaao5xALgXHT3joPdPeTFpXuLtN/N + 0/w1KW18Qr4cAYBrOcDSpGuq5/ZfnZ4vdwA4Izs7Oxc0Tfjq9bT+luL9RdrH+s9l29xc/9h8OQIAPQdY + mnpeiQXAudrY2Lh9/7bC7n5y1e77i7SfhRD+udqu7pIvRQDAAZZWIq/EAuA8tG31GTGFFxXvMdI+1V1z + L1lfX79tvgwBYLU5wNKq5JVYAJynA7GND6/r+q2l+4y0H8UUnnP8+PFb5msQAFaXAyytUg6xADhfm5tH + Prp7/vTU0n1G2o+66+33Z7PZzfIlCACryQGWVi2HWADshZDCQ6pU/VPpXiPtdTFVT+u/XCBffgCwehxg + aRVziAXAXogx3qq7r1ze9YHr3mek/Si29U/nSw8AVo8DLK1sPtgdgD3SttWndveVPy3eb6Q9LLb1Tr7s + AGC1OMDSKueVWADsoQNNqk9cmi59d+meI+1VMdXfnK85AFgdDrC08nklFgB7KKX5J/X3luI9R9qbTsZU + f2m+5ABgNTjAkrwSC4A9d+rVWN095srd9xxpL1pbW/tQ3KwO5+sNAKbPAZZ0OodYAOy1+mj98d1zrf9b + uu9Ie9B7w2b4zHy5AcC0OcCS/iuHWADsh5hicyQdeXvp3iOdT+tp/S0xxk/OlxoATJcDLGlXPhMLgH1Q + HavuFlN4VvHeI51HVar+aT6f3ylfagAwTQ6wpOvnlVgA7JNTn41VVdV7Svcf6Vzrnrv8hT+AA2DSHGBJ + 5RxiAbBfUprfp2nmLy3df6RzrqmfMZvNbpYvMwCYFgdY0g3nEAuA/dIfNHT3msv6b5Pbff+RzrXuuf0T + 8yUGANPiAEu68RxiAbCfYowPCiH8c+keJJ1b9bfnywsApsMBlnQG+WB3APZRf49pUv2E4j1IOvtONk3Y + zpcXAEyDAyzpzPJKLAD2W9vW8yPpyNtL9yHpbOrfmho3qy/IlxYALD8HWNKZ5xALgP2W0sbdYwrPL92H + pLOpPwytt+p75UsLAJabAyzp7HKIBcB+6+4zF3b3nMsvSQev3n0fks6mKlX/dPTo0TvkSwsAlpcDLOns + c4gFwCLEGGdNG/6jdC+SzrRTr+hrmpvnywoAlpMDLOnccogFwCJsbGzcvkn100v3IulMi6n6+XxJAcBy + coAlnUe+nRCAxTgQ2+obZmn2weL9SDqDYlt/S76eAGD5OMCSzi+vxAJgUbr7zcEqVa8q3Y+km2o2m10T + UtjIlxMALBcHWNL55xALgEWZz+d3apr6/5TuR9IZ9N62rS7JlxMALA8HWNLe5BALgAU60N17LvMthTqX + Qgivr45Vd8vXEgAsBwdY0h7mM7EAWKC2rR+6ntbfUrwnSTdSTOElx48fv2W+lABg/BxgSXubV2IBsEgx + xo+LKbyodE+SbqyYqqflywgAxs8BlrQPeSUWAAt04sSJi7rndI8p3pOkGym21TflywgAxs0BlrQ/eSUW + AIvWNGGruwe9d/c9Sbqh+s9Ra9v6i/MlBADj5QBL2r8cYgGwaGEz3L9pw7+X7ktSqSPpyNtTmn9SvoQA + YJwcYEn7m0MsABZta2vrzjGF55TuS1KxZv43Pv4AgFFzgCXtfw6xAFi02Wx2s9jWP1y6L0nFmvq3u0vn + wOkrCABGxgGWtJgcYgEwhJjqL93Y2Hh/6d4kFbosXzoAMC4OsKQF5tsJARhASOHBG2njjcV7k3Sd+g91 + j5vV4XzpAMB4OMCSFpxDLAAG0DTNPfrPOSrem6TrVNf1O2KMn5wvHQAYBwdY0uLzdkIAhtDfe7rnfr9f + ujdJ1617rvK3a2trt86XDgAMzwGWNEwOsQAYQnfvudCHu+vMqn85XzYAMDwHWNJwOcQCYCixjV+1trb2 + odL9Sbq2mOqvzJcMAAzLAZY0bA6xABhK29YP7e5FV+y+N0nX1n+DZdtWD8iXDAAMxwGWNIJ8sDsAA4kx + 3rdpwyuL9yepK4Twb03T3C5fMgAwDAdY0jjySiwAhjKfz+/UNNWflu5PUl9M4Q+6S+XA6SsGAAbgAEsa + Tw6xABhK/0rgpqmfUbo/SblvzZcLACyeAyxpXDnEAmAo3f3nwpjqx5fuT1LXVW1bf16+XABgsRxgSePL + IRYAQ+ruRZd1nbzuvUnqCyG8qTpW3TVfKgCwOA6wpJHmg90BGFDThK/o7kdXXe/+pJWv2z88e2dn54J8 + qQDAYjjAksabV2IBMKS2rR9aVdW7SvcorXYx1d+ZLxMAWAwHWNLI80osAAYUNsMD19P6W4r3KK1yV4UU + HpwvEwDYfw6wpPHnlVgADCnG+CnzNH9N6R6l1S2E8Nru2rhjvkwAYH85wJKWI4dYAAypuwfdo0rVP5Xu + UVrdYgq/lS8RANhfDrCk5ckhFgBDqraruzTN/C9L9yitcvWJfIkAwP5xgCUtVw6xABhSfw9qmupPSvco + rWYbGxvvD5vh0/MlAgD7wwGWtHw5xAJgSIcPH75FTOF3S/corWjN/O9jjLfKlwgA7D0HWNJy5hALgCHN + ZrObxVQ9pXSP0mrW7St+Nl8eALD3HGBJS1xTPXd7e/vivJwBYKF2dnYuaFL9pOI9SitZSKHOlwcA7C0H + WNKS5xALgGEd6F95U7xHaeWq6/od1bHqbvnaAIC94wBLWv68nRCAgR3o7kc/ufv+pNUspvCs/po4fWkA + wB5xgCVNI4dYAAytux993+77k1a0zfCN+bIAgL3hAEuaTg6xABhadz+6fPf9SavXxsbG+9u2+tR8WQDA + +XOAJU0rh1gADK27H122+/6k1Sum8PLuOcnN82UBAOfHAZY0vRxiATC0mOr/XbpHabWKbf29+ZIAgPPj + AEuaZg6xABhabOtvKd2jtFJd1bbVZ+VLAgDOnQMsabo5xAJgaN39yGdirXpteOX6+vpt8yUBAOfGAZY0 + 7RxiATA0zzcVU/34fDkAwLnxhEKafg6xABha95zzh0r3KK1OcbP6knw5AMDZc4AlrUhN9dzt7e2L89IH + gIXrnnc+pniP0mrUhjfEGO+YLwcAODsOsKTVySuxABjYgSbVP1O6R2k16vYeT83XAgCcHQdY0orllVgA + DKs/xHpS8R6llchbCQE4Jw6wpNXLK7EAGNLOzs4FMVW/WrpHafqFEF5/9OjRO+TLAQDOjAMsaTVziAXA + kE6cOHFR9zz0D0v3KK1C9ZPypQAAZ8YBlrS6OcQCYEgxxlvFFJ5fukdp8p1s2/qL86UAADfNAZa02jnE + AmBIx44d+8gm1S8r3aM08drw7+vr67fNlwIA3DgHWJIcYgEwpBjjRzVt+MfSPUpTr/6ZfBkAwI1zgCWp + zyEWAEOqjlV361+RU7pHadL1byV8aL4MAOCGOcCSdG0OsQAYUr1V3yuE8KbSPUrTrUrVqzz/AOAmOcCS + 9GE11XO3t7cvzg8RALBQYTM88NJ06buL9yhNttjWP5EvAQAoc4AlaXdeiQXAkEIKD+vuR1ftvj9pul2S + Dl7dPfc4mC8BALg+B1iSSjnEAmBITRO2u/vRyd33J025+mXdc48L8yUAAB/OAZakG8ohFgBDim29U7o/ + abrFVD8ijx8APpwDLEk3lkMsAIbUpPpnSvcnTbYr+2+kzOMHgP/iAEvSTeUQC4Ch9G8pa5r690r3J02z + bn/yO3n8APBfHGBJOpMcYgEwlLW1tVt396EXl+5PmmYhhY08fgA4zQGWpDOuqZ67vb19cX74AICFqbar + uzRteGXx/qTJFUJ47fr6+m3z+AHAAZaks8srsQAYSkrz+3T3oit235s0zWJb/0QePQA4wJJ09jnEAmAo + IYVD3b3oqt33Jk2vS9LBq7vnGwfz6AFYdQ6wJJ1T3k4IwEBiW31d8d6kCVa/rP8g/zx6AFaZAyxJ55pX + YgEwlNjWjy3dmzS9+gPLPHYAVpkDLEnnk0MsAIbQvyonpvAHpXuTplVd1+/Y2tq6cx49AKvKAZak880h + FgBD6L+lrmnmf1O6N2lq1U/IYwdgVTnAkrQn+UwsAAZQH60/PoTwpuK9SZNpNptd0/hAd4DV5gBL0l7l + lVgADCHG+NndfegDu+9LmlYxhZfs7OxckMcOwKpxgCVpL3OIBcAQmiZ8bem+pInVhON55ACsGgdYkvY6 + h1gADKH/nKTSfUnTqX+76MbGxu3zyAFYJQ6wJO1HDrEAWLQTJ05cFFN4fum+pOkU2/on8sgBWCUOsCTt + Vw6xAFi0zc0jH9204T9K9yVNpqtijJ+WRw7AqnCAJWk/c4gFwKK1bfWAQ+nQ+0r3JU2jbg/z7DxuAFaF + AyxJ+15TPXd7e/vi/LADAPuuSfWXFe9Jmkxxs4p53ACsAgdYkhaSQywAFqy7/zzuevcjTac2vPLw4cO3 + yOMGYOocYElaVN5OCMAi5Q91f1HpnqTJ9K153ABMnQMsSYvMIRYAi1Qdq+62ntbfUronaRJdsbW1dec8 + bgCmzAGWpEXnEAuARQopfOEl6eDVpXuSJtHj8qgBmDIHWJKGyCEWAIvU3Xsu330v0mS6KsZ43zxqAKbK + AZakoXKIBcCi7OzsXNA97/2j0v1Iy18329/PowZgqhxgSRoyh1gALEqM8Y4hhFeX7kda/tq2fmgeNQBT + 5ABL0tA5xAJgUWKMD5ql2QdL9yMtd93zib/qX2mXRw3A1DjAkjSKmuq529vbF+eHJgDYN7Gtvql4L9Ly + 14TjecwATI0DLEljySuxAFiQA/1nJpXuRVru5mn+On8gBjBRDrAkjSqvxAJgAWKMHxVCeH3xXqRl71F5 + zABMiQMsSWPLK7EAWIQY4+ySdPDq0r1Iy9zaO+fz+Z3ymAGYCgdYksaYQywAFiG29Q+U7kNa+h6dRwzA + VDjAkjTWHGIBsN9ms9nNmqb609J9SMvbxsbG+6tj1d3ymAGYgpDCRmjDEyVpjMU2HssPVwCwL1La+IQm + hSt2H4JouYupfnweMQAAAMDya9s6lA5BtNRdFWP8lDxiAAAAgOUX2vDkwiGIlriYql/N4wUAAABYftvb + 2xc3bfiX0kGIlraTYTPcP48YAAAAYPmFFB58STp4deEgREtaaMMf5vECAAAATENoww+VDkK0vIUUHpLH + CwAAALD8Tpw4cVHTzF9aOgjRchZTeFEeLwAAAMA0hM1wv42NjfeXDkO0nLVt/cV5vAAAAADTEFP9zaWD + EC1ndapfnEcLAAAAMA07OzsXhDY8u3QYouUsblZflMcLAAAAMA1N09yjqqp3lQ5DtHz5LCwAAABgkpom + fG3pMETLWdvWD82jBQAAAJiMA6EN/7d0GKIlrKn+NM8VAAAAYDpS2viES9Ol7y4eiGjpCil8YR4tAAAA + wHQ0m+EbS4chWsK8CgsAAACYov5bCWMKzy8eiGjpatv68/NoAQAAAKYjpfl/O5QOva90IKLlyjcSAgAA + AJPVpPCtuw9DtJyFFB6SxwoAAAAwHU3TXFin+i9KByJasprqT/JYAQAAAKYlxvhpa2trHyoeimipatvq + s/JYAQAAAKYltvWPlg5EtFzFFH4rjxQAAABgWtbW1m5dpepVpUMRLU+z2eyalOb3yWMFAAAAmJaQwsNK + hyJatuon5ZECAAAATE9ow2+WD0W0LPWfZ5bSxt3zSAEAAACmpWmaj2lSuGL3oYiWq9CGH8kjBQAAAJie + 2FbfUDoU0VJ15dGjR++QRwoAAAAwLTs7OxfUqf6LwqGIlqiY6u/MIwUAAACYnratHnBJOnh16WBES1Ib + 3hxjvFUeKQAAAMD0xFT/XPFgREtTbKuvy+MEAAAAmJ6tra07H0lH3l46GNFyFEL4t6ZpLswjBQAAAJie + ZjP8r9LBiJantq3neZwAAAAA09O/eqdO9V+VDka0LNXPy+MEAAAAmKa2rT+nSeHk9Q9GtCyFzfDAPE4A + AACAaWpS/culgxEtRzFVT8mjBAAAAJimpmk+pklr7ywdjmj8zdLsg/0M8zgBAAAApqlJ4bLdByNankIb + viePEgAAAGCamqa5eQjh30qHIxp/62n9LcePH79lHicAAADANMU2bpYOR7QkNeEr8igBAAAAJutATOFF + xcMRjb5udn/Xz/D0KAEAAAAmqm2rz2pSOLn7cETLUUjhC/MoAQAAAKYrpuo3SocjGn+hDb+fxwjw4XZ2 + di7I/xIAAGDpxRg/sUnhA7sPRzT+ZrPZNSltfEIeJcB/6R4kLm+a+hndg8Td838EAACw1GJb/+juwxEt + R6EN35/HCHDabDa72TzNX9c/SFRV9Z7ur5f3Xz+b/2sAAICltLGxcfu6rt963YMRLUcbaeON9qXAh4mb + VXW9B4xm/jfdg8Xn5v8JAADAUmo2wyOvt9/RUhRTbPIYAfoPNwx/XHqw6DoZ2vDUzc0jH53/pwAAAEvl + +PHjt5yn+WsK+x2NvG6v+pw8RmDV1Ufre/YfkFd6sLhOV8RUP6Jpmgvz/w0AAGBpdPuZryzsc7QEhc1w + vzxGYJV1DwiP3v0AcUPVqf6rkMKD8/8VAABgKfR/GB9C+IfSPkej7yfzGIFV1X8gXtOGNxceIG6sU28r + rLaru+S/DQAAwOj1n6dU2N9o/F2xtrZ26zxGYBXFVB8tPDicad5WCAAALJMDTVP9eWFvo5EX2/jleYbA + KoopPL/04HBWNfO/jDF+dv5bAgAAjFZI4VBxX6NR1+1dX5JHCKyalOb36R4ITu5+YDjHTr2tMMb4Uflv + DwAAMErd3uXZhT2Nxl7THMwjBFZJ9wDwuOs9IJxndV2/w9sKAQCAMevfQVLaz2js1U/IIwRWRfeAfavu + AeCK6z8g7E11qv/C6TgAADBWMYU/Lu1lNObW3unD3GHFnOeHt59Rs9nsmv5thVtbW3fO/1gAAIBRaNvq + s0r7GI272MZjeYTAKght+L+lB4P96Eg68vb+bYU7OzsX5H88AADA4JqmemZpD6MR11R/kscHTF11rLrb + Jeng1cUHg/2smb80xvig/MsAAAAYlM/CWspO1kfre+YRAlMW2/q7Cg8CC+natxXO5/M75V8OAADAYBb5 + 7hTtTd2ediePD5iwA1Wq/rX0ILDg3uZthQAAwNC8Cmv5CiG82l4SJi6k8D9KDwBDVaf6hWEzfHr+5QEA + ACxc/7lKpf2KxlvcrL4gjw+YoibVv1Ba/AN3VWzrxzZNc7v8ywQAAFiYkMKDC/sUjbiYqqfl8QFTs729 + fXG30K/cvfDH0kbaeGNs48O7X+qB079iAACAxQhteHZpn6Jxdigdep8XQcBENan+stLCH1sxhefHGD8t + /7IBAAD2Xdysvqi0P9GYq0/k8QFT0i3u55UX/Sg79bbCY8eOfWT+5QMAAOyrmMLLC3sTjbWm+vM8OmAq + 6qP1PbsFfvJ6C37kzdP8dbGNm/m3AQAAsG+aJrSlfYnGW71V3yuPD5iCmOrvLi325al+XtgM98u/HQAA + gD3XNM2FTRv+pbwn0Uj7f/L4gCmoUvWKwkJfqtbW1j7Uv61wfX39tvm3BQAAsKdiG7+mtB/RSGvDP+bR + AcsubIb7Fxf6khZCeH3+tkIAAIA9dfjw4Vv0e47SXkTjrG2rB+TxAcsstOFHSot82YspPCfGeN/82wQA + ANgT3X7jst37D426H8ujA5bYgaYN/15Y4JPo2rcVNk1zm/z7BQAAOC/9t6F3+40rdu8/NM5OvWKuaS7M + 4wOWUYxxVlrgUyt/W6G3FQIAAHui22c8eve+Q+MtblZfkEcHLKMm1U8oLe6pFtrw7JTm98m/fQAAgHMS + Y/y4/h0fpX2Hxlj9pDw6YNmcOHHiom4hv+36C3vaeVshAACwF5pU/1ppz6FRdkX/Afx5dMAyCSmsFRb1 + 6tSG//C2QgAA4FyFzfDA4l5Do6xt63keHbBMQht+pbSoV62YwrPqrfre+ccCAABwxrr9xJ+V9hkaY/XT + 89iAZbG2tnbrS9Ol7y4v6tXrUDr0vu6vlx8/fvyW+UcEAABwk2Kq0+79hcZZv+9bX1+/bR4dsAw8yJYL + Ifxb29aX5h8TAADAjZrNZjebp/lrSvsLja9+L5xHByyD0IbfLC1m5Zr6GTHGT8w/LgAAgBvU7SEuu96e + QiPN2whhacQYb1VV1XvKi1nX5m2FAADAmTh69OgdfETL0vTe7e3ti/PogDGLm1VVWMS6gapU/au3FQIA + ADcmtOFnS/sJja9+T5zHBoxZTNXTSotYN1FTPyOljU/IP0YAAID/FGO8b3EfoRFW/3IeGzBWJ06cuKiu + 63eUF7HOoPd2XX748OFb5B8pAADAKTGFF+3aP2icXemjYmDk4mZ1uLB4dba14V/6n2X+sQIAAHxE04Tt + 4v5Bo6vbz31JHhswRk2qn1RavDrHmvoZTdPcI/94AQCAFda/U6Npw5uLeweNrPoX8tiAsWma5kIPpvuS + txUCAACnhDb8yK79gsbZFd0e+eZ5bMCYhBQeUli02qNCCP/c/YwP5R83AACwglKaf9JsNrumtGfQuIqb + 1RflsQFj0i3Qx+1esNqHTn9b4d3zjx0AAFgxTVM9s7hX0Miqn5BHBozIgRDCa8uLVntdVVXv6f56uZek + AgDA6mnber57j6DxtZE23rizs3NBHhswBm1bXVJasNrf6lT/bXfz+rw8BgAAYAXMZrObzdP8daU9gsZV + jPFBeWzAGMS2/t7SYtWCaupnVMequ+VxAAAAE9ftwX6guDfQqOr3ynlkwBjEFF5eWqxaZGvvjKl+RP+n + MXksAADARNVH63t2+4CT198XaFQ187/MIwOGtrm5/rHdwvTAOZJiCn/dNM3n5vEAAAAT1TTVC0p7Ao2q + k94tAyPRpPpEYZFq2E6GNjx1c/PIR+cxAQAAExPb+OWFvYBGVjenr8kjA4YU2vD7pUWqUXRF/7bCpmku + zOMCAAAmYnt7++LuOf+Vu/YAGltN/Yw8MmAox48fv2VVVe8pLlKNppjCSxxiAQDA9MRU/XxpD6DxdCgd + et/a2tqt88iAIbRtfWlpgWpkNdUz88gAAIAJ6T//trgH0KgKKazlkQFDaFL9M6XFqZHVhO08MgAAYGKa + NvxjcR+gEVU/IY8LGEII4dXlxamxdOotnk1zmzwyAABgYmJbf0dpL6Dx1O2dX9+N6sDpiQELFTbDp5cW + psZVaMMv5pEBAAATlNLG3Wez2TWl/YDGU7eHvn8eGbBI3QJ81O4FqfEVN6svyCMDAAAmqkn180r7AY2q + R+VxAYsUU3h+YUFqRIUQXruzs3NBHhkAADBRsY1fU9oTaEQ11XPzuIBFWV9fv+3a2tqHiotSY+oH88gA + AIAJO3r06B265/8f2LUf0IiapdkHfT4xLFj/FaClBalxFWO8bx4ZAAAwcaENv1/aF2g8xc3qS/K4gEWI + bf3Y0mLUeIopvDyPCwAAWAGxjZulvYHGU2jDY/K4gEUIIfxDaTFqPMW2/rY8LgAAYAWsra3dutsLXLl7 + b6DxVKXqFXlcwH6LMX5caSFqVJ1MaeMT8sgAAIAVEdrw1ML+QCOq26vdPY8L2E9Nqr+stAg1nupUvziP + CwAAWCEhhYeV9ggaT7GNX57HBeyn0IZfKS1CjaeY6kfkcQEAACtkNpvdbD2tv6W0T9A4iqn61TwuYB8d + 2EgbbywtQo2j7oZ1Tf82zzwvAABgxcRU/1xpr6BxVNf1W3d2di7I4wL2Q9tWn1FagBpRTfXcPC4AAGAF + tW39xcW9gkZT2Az3z+MC9kO30L5198LTyGrC1+ZxAQAAK+jEiRMXHUlH3l7cL2gsXZbHBeyHmMIfFxae + RtIl6eDV1XZ1lzwuAABgRcVUPaW0Z9A4Cm34v3lUwF5rmubm3UJ77+6FpzFVPy+PCwAAWGFtWx8p7xk0 + hqqqek//Srk8LmAvhRQeXFp4GlGb4RvzuAAAgBV2+PDhW1RV9a7ivkGjqG2rz8rjAvZSk+pvLy06jaaT + TdPcI48LAABYcTFVv1rYN2gkxbb+tjwqYC81Tf1/SotO4yim8JI8KgAAgP5thKG0d9A4Cm34wzwqYK80 + TXNhk9beWVp0Gkexrb8jjwsAAOAjtre3L+72Cj7HeLR1e+xur53HBeyFblEdLC84jaV6q753HhcAAMAp + TVP/Xmn/oHHUttUD8qiAvdBshkeWFpvGUZWqV+RRAQAA/KemCV9d2kNoHMW2+qY8KmAvxBR+t7TYNI5C + G74/jwoAAOA/Vcequ3Z7hpO79xAaR91e7nfyqIA9cKCu67eWFpvGUdtWl+RZAQAAfJimmb+0tI/Q8B1J + R96+s7NzQR4VcD7atvrU0kLTSGrDmz3gAQAAN6TbN1x+vX2ERlO/586jAs5HbKuvKy0yjaX6F/KoAAAA + ridshgeW9xIaRZvhf+VRAecjtOHXi4tMo6ht65BHBQAAUHIghPD60n5Cw9fvufOcgPMxT/PXlRaZhm9t + be1Dx44d+8g8KgAAgKKY6p8r7Sk0fN2e+zV5TMC5Smnj7qUFppHUVH+SRwUAAHCDQgobxT2FRlGM8ePy + qIBzETerWFpcGkmb4ZF5VAAAADdoe3v74o2NjfcX9xUavG7vXeVRAecitvWPlhaXxlFK8/+WRwUAAHCj + +ndwlPYVGkWPzmMCzkX3APeCwsLSCKpS9a95TAAAADep20dctntfobFUPy+PCThbs9nsZlVVvae8uDR0 + oQ0/lUcFAABwk9q2ekBpb6FR9N5+D55HBZwND27jLm5W63lUAAAAZ+JA04Y3l/YXGr6wGe6f5wScjZjq + /1laVBpFVzVNc7s8KgAAgDMSU/Wrhf2FRlC/B89jAs5G98D2lNKi0ghqqhfkMQEAAJyx2MYvL+4xNHj9 + HjyPCTgbTRv+sbSoNIr+nzwmAACAMxZj/LjC/kIjqErVP+UxAWdqY2Pj9rPZ7JrSotLwtW31WXlUAAAA + ZyWE8A+lfYYG7+R8Pr9THhNwJkIKhwqLSePoiqZpLsyjAgAAOCuhDY8p7DM0grq9+MPymIAzEdv6u0qL + SSOoqX87jwkAAOCstW19pLjX0OD1e/E8JuBMhDb8TmkxaQQ14WvzmAAAAM5a/43ml6SDVxf3Gxo2L1iA + s9O04d+Li0mDV2/V985jAgAAOCd1qv+qtN/QsFWpelUeEXBTjh49eodu4ZzcvZA0gtrw5m5EB05PCgAA + 4NzEtn5scc+hoTvZ78nzmIAbEzerLygsIo2gmKrfyGMCAAA4Z21bh9KeQ8MXUnhIHhNwY2Jbf0tpEWn4 + Ylt9XR4TAADAOYsxflS3x/DOmzG2GR6ZxwTcmCbVv1xcRBq87iZz3zwmAACA81Kl6hWlfYeGLbThqXlE + wI3xIDbO1tP6W7rx+PwrAABgT4Q2/Gxp76Fhiyn8XR4RcENijLfqFsxVuxeQhq+7ufxmHhMAAMB5i23c + LO09NGyXpINXr62t3TqPCSgJm+EzSwtIwxdT/fV5TAAAAOetOlbdtbT30PC1bXVJHhNQEtv4NaXFo+Hr + HsA+I48JAABgTzRteGVp/6Fh6/fmeURASWjDE0uLR4N3ZdM0F+YxAQAA7IluD/grhf2HBi6m+vF5REBJ + neq/KC0eDVxT/UkeEQAAwJ6JbfUNxT2IBq3bm784jwjYbWdn54Kqqt5TWjwattCG78ljAgAA2DMxxgeV + 9iAatm5v/q5uPL6FHkq6B65PLC0cDV/crA7nMQEAAOyZEydOXHQoHXpfaR+iYauOVXfLYwKuK25WX1Ja + NBq8kzHGO+YxAQAA7Kmmqf60sA/RwIUUDuURAdcVU/2/S4tGw1al6hV5RAAAAHsutOHHS3sRDdxmeGQe + EXBd3YPWLxYXjQatm8uT84gAAAD2XNOEtrQX0dDVT8ojAq7LNxCOs5jqr8wjAgAA2HNN09yjtBfRsPkm + Qig70C2QK3cvGA1fjPHT8owAAAD2RQjh9aX9iIZs7Z15PMC1nLiPtvfOZrOb5TEBAADsi9CG3y/sRzRw + McaPyyMCeiGFh5UWiwauqf40jwgAAGDfdPuPy6+3H9Hg+SZC2CW29beUFosG73F5RAAAAPsmpLBR2I9o + 4GJbfVMeEdDrv+mutFg0cE04nkcEAACwb3yszDiLqf65PCKg13+7QWmxaNjCZrhfHhEAAMC+6vYgb9u9 + J9HA+VgZ+HDdwrjiegtFQ/fepmkuzCMCAADYV01T/UlhX6IBW0/rb8njAba2tu5cWigatpjCi/KIAAAA + 9l1ow4+U9iYato2NjdvnEcFqa9vqs0qLRMMW2/qxeUQAAAD7rmnCVmlvooFrmoN5RLDaYhuPFReJhq0J + X5FHBAAAsO/qrfrexb2JBi2mOuURwWqLbb1TWiQaOKfsAADAAvWfwVtV1XuK+xMNVkz1d+YRwWoLbXhq + aZFouC5JB69eW1u7dR4RAADAQsQUXlLao2jI6l/I44HVVqf6xeVFosFqwz/m8QAAACxMTNVTinsUDVdT + vSCPB1Zb/7WcxUWiAaufnscDAACwMLGtv628R9FgteENeTywuo4dO/aRxQWioft/8ogAAAAWJm5WX1LY + n2jg1tfXb5tHBKupbasHlBaHhi2ksJFHBAAAsDAxxk8s7VE0bN3e/TPyiGA1NU1oS4tDw1Yfre+ZRwQA + ALBIBy5Nl767tE/RcLVtHfJ8YDV1C+FRuxeGBu/KbjQHTk8IAABgsZpm/tLCPkUD1n82WR4PrKaYqp8v + LQ4NV/+1tXk8AAAAC+ebCMdXaMMT83hgNXWL4NmlxaHh6mby1DweAACAhfNNhOOr2yf+UR4PrKYqVf9a + Whwarpjq78zjAQAAWLiQwlppr6Lh6vbur8jjgZV04FA69L7S4tBwxc0q5vkAAAAsXL1V36u0V9Fw9R+s + n8cDqyfG+FGlhaFha9vqU/OIAAAAFm42m91sbW3tQ6X9ioZrY2Pj9nlEsFratnpAaVFouLobxTXHjx+/ + ZR4RAADAIEII/1bas2i4wmb49DweWC0hhY3SotCAteGVeTwAAACDiSn8cXHPosGKm9WX5PHAaomp/vrS + otCANfX/yeMBAAAYTGzrny7uWTRY3R7+f+bxwGrpFsCjdy8IDd5P5vEAAAAMptkMjyzsVzRsP5jHA6sl + tOFXCgtCAxbb6uvyeAAAAAbTtvWR0p5FwxVT9bQ8HlgtdapfWFoUGq6QwsPyeAAAAAaT0vw+pT2Lhium + 8Pw8HlgtTRv+vbQoNFwxxk/J4wEAABjM4cOHb3FJOnh1ad+iYapS9ao8HlgdTdNcuLa29qHSotBgnTx+ + /Pgt84gAAAAG5UUP46rfw+/s7FyQxwOroTpW3bW0IDRc8zR/XR4PAADA4GIKzyntXTRgTfMxeTywGtq2 + ekBxMWi4muoFeTwAAACDa1L9S8W9iwYrbIZPz+OB1RA3q8OlxaAhq38pjwcAAGBw3T7l+66/b9GQdXv5 + L8rjgdXQNOF4aTFo0C7P4wEAABhck+oThX2LhqwJ23k8sBpiW39bcTFosGIbH57HAwAAMLiQwsNKexcN + V0z1N+fxwGqIbf2jpcWg4YoxzvJ4AAAABhc2w/1KexcN2qPzeGA1xFQ9rbAQNGD10fqeeTwAAACDW19f + v21p76Lh6vbyT8njgdXQNNUzS4tBg3Xy+PHjt8zjAQAAGIUmrb2zsH/RQIU2/FEeDayGmMJflxaDButt + eTQAAACj0e0d/66wf9FAdfN4eR4NrIaNtPHG0mLQMPUHink0AAAAo9HtVf7f0h5GwzRP89fl0cD07ezs + XNBd+FftXggarv6mkMcDAAAwGqENTyztYTRMszT7YDeWA6enAxMXY/yo0kLQcMVU/1weDwAAwGjEtv7e + 0h5Gw9Xt6e+YxwPT5qtQx1d3U9jJ4wEAABiNmOqvL+1hNFwpze+TxwPTFmOclRaBBqwJX53HAwAAMBox + xaa4h9FwNc3n5vHAtLVtPS8uAg1WN5NL83gAAABGo9urfF5pD6Ph6mZyJI8Hpi228ctLi0AD1jQH83gA + AABGI8b4KcU9jAYrpvpL83hg2prN8MjSItCANc098ngAAABG4+jRo3co7mE0WLGtviGPB6atu+Av370A + NGwxxlvl8QAAAIzJgW7P8oHdexgNV0z1d+fZwLTFtn5saRFomC5Nl747jwYAAGB0mjb8R2kvo2EKbfjx + PBqYtibVv1RaBBqoNrwyjwYAAGB0uj3ky4p7GQ1U/Qt5NDBtoQ2/X14EGqSm+vM8GgAAgNFpmvr/FPcy + GqRuT/87eTQwbTGF55cWgQaqqZ+RRwMAADA6Tap/ubiX0SB1e/rn5NHAtDXN/G9Ki0DDFFP183k0AAAA + oxPb+qdLexkNU53qv8qjgWlr2vDvpUWgwXp0Hg0AAMDodHuW79u1h9GAhRBenUcD01ZV1btKi0CDdVke + DQAAwOh0e5Zv3bWH0bBdkUcD09U0zYXdxX5y18WvIWvC1+bxAAAAjE5M9VcW9zIapNlsds3Ozs4FeTww + TU3T3K60ADRc3c3gaB4PAADA6LRtHUp7GQ1Y09wmjwemqTpW3bV48WuwupvBpXk8AAAAoxNS+MLSXkbD + VW1Xd8njgWlKaf5JpYtfw9W29efk8QAAAIxO21YPKO1lNFz10frj83hgmroHnk8tXfwarn4meTwAAACj + Ux+t71nay2i4UprfJ48HpinG+KDSxa/hqo5Vd8vjAQAAGJ1uH3nH0l5GA9Y0B/N4YJpCCg8pXvwarPX1 + 9dvm8QAAAIzOiRMnLirtZTRc3d7+f+TxwDR1F/nDShe/hqn/+tNuLAdOTwcAAGCc1tbWPlTa02iYur39 + oTwamKbuIq9LF78G68o8GgAAgNGqqupdhf2MBqpt63keDUxTTPWXli5+DVQb3pxHAwAAMFobaeONxT2N + Bqnb2x/No4FpalJ9onTxa5hCCK/OowEAABitpg2vLO1pNEwx1V+ZRwPTFNvqm0oXv4YphPAPeTQAAACj + FVP4u9KeRsPU7e2/IY8Gpqm70B+1+8LXcHU3gZfn0QAAAIxWt3d5SWlPo8G6LI8Gpqm7yL9v10WvAetu + Ai/KowEAABitJtXPK+1pNFiX59HANHUX+aN3XfQasJjCs/JoAAAARqtp6v9T2tNosH4wjwamKbThxwsX + vgYqpvAHeTQAAACj1e1dfqu0p9FgPTqPBqYptOExhQtfA9XN49fzaAAAAEYrpupppT2Nhql/cUoeDUxT + d6E/bveFr+HqbgJPyaMBAAAYrdCGXyztaTRM/YtT8mhgmrqL/GdLF7+GqZvHk/NoAAAARqvfu5T2NBqm + bh4/lUcD09Rd5E8sXfwapn4eeTQAAACjZS85rmKqH59HA9Pk1HxcdfP42TwaAACA0WpS/TOlPY2GKab6 + 5/JoYJr6z1wqXfwapuBlnwAAwBLo9i8+T3lEdXv7n8+jgWnyzRHjKvjgPQAAYAl0+5ef3L2f0ZDVv5RH + A9MUU/Wr5YtfQxR89SkAALAEYlv/aGlPo6GqfzmPBqYppuo3yhe/hii04UfyaAAAAEYrtvUPl/Y0Gqr6 + 1/JoYJpiCr9Vvvg1RKENP5RHAwAAMFqxrX+gtKfRMHV7yd/Mo4Fpiin8buni1zB1Dzrfn0cDAAAwWt3e + 5XtKexoNUzeP38mjgWlygDWu+j/FyKMBAAAYLQdY48oBFpPnLYTjqn8feR4NAADAaHkL4bgK3kLI1PkQ + 93HV3QR+NI8GAABgtPo/fC/taTRUPsSdiYup+tXyxa8h6m4CP5FHAwAAMFr9H76X9jQaqvqX82hgmkIb + nlq++DVE3U3gsXk0AAAAo9XtX35y935GwxVT9ZQ8Gpim0IZfLF38GqbY1j+dRwMAADBa3f7lcbv3Mxqu + mKqfz6OBaQpteHLp4tcwxVQ/Po8GAABgtJpU/0xpT6Nh6vaSP5dHA9MU2vDE0sWvoaqflEcDAAAwWvaS + 46qbx8/m0cA09Rd56eLXUNW/kEcDAAAwWt7NM666efxUHg1MU3ehe9/yqKp/KY8GAABgtILPUx5bP5lH + A9PUX+S7LnoNWHcT+JU8GgAAgNHq9y6lPY0G68fyaGCa+ot810WvIWvq386jAQAAGK2Ywu8W9zQapNjW + P5xHA9PUXeiP3n3ha7hCG/4ojwYAAGC0mqZ6ZmlPo2GKbf0DeTQwTd1F/r2li18D1VQvyKMBAAAYrX7v + UtzTaJBCG74njwamqbvQH7X7wteANfOX5tEAAACMVpPqlxX3NBqo+tvzaGCaYlt9U/ni1xBVqXpFHg0A + AMBo9XuX0p5GA7UZvjGPBqapSfWJ4sWvQepuAq/KowEAABitEMKrS3saDVNs41fl0cA0NU3YLl38Gqbu + JvCmPBoAAIDR6vcupT2NBqoJW3k0ME1tW4fixa+hujKPBgAAYLT6vcuuvYwGLKSwkUcD09Rd5A8rXfwa + pkvSwavzaAAAAEar279ctXs/o+GKm9UX5dHANMUYZ6WLX8N1+PDhW+TxAAAAjM7a2tqtS3sZDVfb1p+T + xwPTFGN8UOni13BtbW3dOY8HAABgdDY31z+2tJfRcIXNcP88Hpimtq0+tXTxa7hijJ+cxwMAADA63Z7l + vqW9jIarm8mn5PHANNVH63uWLn4NV9gMD8zjAQAAGJ2QwoNLexkNV0obd8/jgWmqjlV3LV38Gi4fvgcA + AIxZ29aXlvYyGq75fH6nPB6YpqZpble6+DVcMcUmjwcAAGB0YqqPlvYyGq4Y463yeGCamqa5sLvYT+6+ + +DVgTfjqPB4AAIDR6fYsX1vcy2iQZrPZNd1YDpyeDkxYVVXvKi0CDVNM9f/OowEAABidbt/yqN37GA3a + FXk0MG3zNH9NYQFooGJb/0AeDQAAwOh0+5ZH797HaLiqVL0qjwamrWnmf1NaBBqq+mfyaAAAAEan27M8 + obyX0SA187/Mo4Fp6x58nldcBBqk0IZfyaMBAAAYnaapf7u0l9FANdWf5NHAtHUPPr9XXAQapNCGP8qj + AQAAGJ061S8s7WU0TN0e8jfzaGDaYqqeUloEGigv/wQAAEYshPDPxb2MBqp+Uh4NTFtow2PKi0BD1N0M + Xp9HAwAAMDrdvuWK3fsYDVe3p/+RPBqYtu6Cv3z3AtCgXdWN5cDp6QAAAIxH0zQ37/YsJ3ftYTRgsa2/ + I48Hpi221TeVFoGGK8Z4xzweAACA0aiOVXcr7WE0YE342jwemLbuYj9eXAQarJTm98njAQAAGI22rR5Q + 2sNouGKqUx4PTFtIYaO0CDRc3UwekscDAAAwGnGzOlzaw2i42rb+4jwemLYY46y0CDRcTtABAIAxim18 + eGkPo+Hq9vQPyuOBaQub4X6lRaAB2wzfmMcDAAAwGrGtv6W4h9FgpTT/b3k8MG1bW1t3Li0CDVdow/fn + 8QAAAIxGbOufKO1hNFzz+fxOeTwwbTs7Oxd0F/1VuxeBhiu04cl5PAAAAKPR7VV+s7SH0TDN0uyD3VgO + nJ4OrICmDW8oLQYNU0zhj/NoAAAARqNpqj8v7WE0TCGE1+bRwGqIKfx1aTFomKpUvSKPBgAAYDRCCK8v + 7WE0TN1e/iV5NLAamqZ6ZmkxaLCuzKMBAAAYhdlsdrNL0sGrC/sXDVVTPyOPB1ZDaMNTi4tBg7WxsXH7 + PB4AAIDBNU1zj9LeRUNWPymPB1ZDbOsfLS8GDVWM8dPyeAAAAAbXtvXnlPYuGi7fYM/K6S78b929EDRs + 3c3h0jweAACAwcU2bpb2Lhqu2FbfkMcDq6F7IHp4aTFouLqZfE0eDwAAwOC6fYoXPoysmGKTxwOroW3r + Ly4tBg2Xl4ICAABjEtv6saW9i4YrxjjL44HV0DTNfy8tBg1X/8H6eTwAAACD6/Yof1jau2i4Upr/tzwe + WA3VsequpcWgAWuq5+bxAAAADK5pwz8W9y4arqa5XR4PrIbuor9wbW3tQ8UFoWFqw7/n8QAAAAxqZ2fn + go2NjfcX9y4apH4eeTywWvoDk9Ki0DDNZrNrjh8/fss8HgAAgMGktHH30r5Fw1Wl6lV5PLBa6lS/sLQo + NFwpze+TxwMAADCYkMJDSnsWDZiPnWFVxVT9anFRaLDatj6SxwMAADCYmOqvLO1ZNGT1L+XxwGrpFsCj + r78gNGib4ZF5PAAAAIOJbf0DxT2LBqubyffm8cBqian++tKi0HB1D0g/nccDAAAwmNCGXy/tWTRcsY1f + lccDqyVuVuulRaHhiin8cR4PAADAYJpm/tLSnkXDFVI4lMcDqyVshvuXFoWGK4Twb3k8AAAAg2nS2jtL + exYNV71V3zuPB1bL1tbWnUuLQoN21YkTJy7KIwIAAFi4zc31jy3sVTRwa2trt84jgtXTLYL37l4UGrZ6 + q75XHg8AAMDChRS+sLRX0XCtp/W35PHAagoh/HNpcWi4upvFWh4PAADAwsW2+obSXkVDVr8sjwdWU0zh + WeXFoaGKbf1teTwAAAALF9rws6W9igasqX87jwdWU5PqXyguDg1Y/Ut5PAAAAAvXNNVzy3sVDdhP5vHA + aopt/V2FhaEha+YvzeMBAABYuBDCm4p7FQ3XZnhkHg+sptjGzeLi0JC9d2dn54I8IgAAgIU5evToHQp7 + FA1c3KyqPCJYTWEzPLC0ODRsMcZPzCMCAABYmLatP6e0R9GwtW31qXlEsJo2NjZuX1ocGra4WX1JHhEA + AMDCxDZ+VWmPouGazWbXxBhvlUcEq6uu67eWFomGyzcRAgAAQwht+KnSHkXDFUJ4bR4PrLaYwp+VFomG + K6bqKXk8AAAAC9M01QtKexQNV2jDs/N4YLXFVD2ttEg0XDGFl+TxAAAALMqBJq29s7RH0ZDVT8jzgdXW + LYjLr79ANHDvnc1mN8sjAgAA2Hf10fqehb2JBi629bfkEcFqi6n+0tIi0bDFGO+bRwQAALDv4mZVlfYm + GrZuLut5RLDaYoyfXVokGrbYxmN5RAAAAPuu24d4d84IS2l+nzwiWG0xxo8qLRIN3o/lEQEAAOy7pql/ + r7Av0YDNZrNrjh8/fss8IqBbGFfsXigatpjCc/J4AAAA9l0I4dWlvYmGq59JHg/Q67/1rrRYNFx1Xb+j + G82B0xMCAADYPxsbG7fv9iEnd+9LNGyhDf83jwjoxVQ9pbRYNGwpbXxCHhEAAMC+CSk8pLQn0dDVP5NH + BPRiW39bebFoyLqbSJ1HBAAAsG/sCcdZTPUj8oiAXtysvqS0WDR435dHBAAAsG9iCr9V2I9o4EIKX5hH + BPT6t6qVFouGLbThD/OIAAAA9k3Thv8o7Uk0bJubRz46jwjIDlyaLn13acFowNrw5jwfAACAfVEdq+5a + 3I9o0Oq6fmseEXBdTTN/aWnRaNhijJ+YRwQAALDn2rael/YiGraYwnPyiIDr8k2EI60JW3lEAAAAey62 + 9Q8U9yIatNCGn8ojAq7Lt06Ms+5B6zF5RAAAAHsupvCs0l5EA9eEr80jAq7LNxGOs+5m8md5RAAAAHvt + QLfvuGL3PkQjqGk+N88IuK7+s5aKi0ZD94HDhw/fIo8JAABgz9Rb9b0LexCNoKNHj94hjwm4rp2dnQuq + qnpPaeFo2Nq2+qw8JgAAgD0TU/2VpT2IBq4N/5FHBJTEFF5SXDwatO6m8og8IgAAgD0T2vCLpT2Ihq2b + yx/lEQElTaqfVFo8Grr61/KIAAAA9kyVqn8t70E0cD+WRwSUxLb6usLC0cB1N5VX5REBAADsiaZpPqa0 + /9DwxTZ+eR4TUBJj/OzS4tHwpbRx9zwmAACA8xY3q1jae2gENc3BPCagZG1t7daXpINXFxeQhq0JW3lM + AAAA5y204THFvYcGbZZmH2ya5uZ5TMANCSH8Q2kRadhiqh+fRwQAAHDeYgovL+09NHT1y/KIgBsT2vAr + 5UWkIesPFvOIAAAAzkvTNLfp9hlX7d53aPi6PfkT85iAG9MtmG/dvYA0ik5W29Vd8pgAAADOWUjhUGHP + oREU2/g1eUzAjekeyL6wtIg0fG1bhzwmAACAcxbb+gdKew4NX9gMD8xjAm7M0aNH79AtmpO7F5FG0ePy + mAAAAM5Z01R/XthvaODW1tY+dPz48VvmMQE3pWnDv5cWk4YtpvDXeUQAAADnZH19/bbd/sLnX42wOtV/ + lccEnImYwu+WFpOGbTabXTOfz++UxwQAAHDW2rY+UtpvaPhCG56cxwSciZjq7y4tJg1fSGEjjwkAAOCs + hTY8prTX0PDFtvq6PCbgTMTN6ktKi0mjyOdgAQAA5yym8HeFfYZGUNgMn5nHBJyJ/m1q3eLxQe5jrA3/ + mMcEAABwVqrt6i7dvsJeb4Rdkg5evba2dus8KuBMVan619Ki0ghqmnvkMQEAAJyxpglbxT2GBq9O9d/m + MQFnI6bqaaVFpRHUhK/IYwIAADhj/YeEF/cYGryY6p/LYwLORrd4vr60qDSG6l/LYwIAADhjIYRXl/cY + GjwvVIBz07bVJcVFpcGr6/qtOzs7F+RRAQAA3KSU5vcp7S80jmKMn5JHBZyNEydOXHQoHXpfaWFp+Nq2 + ekAeFQAAwE2Kqf7m0t5Co+ht3YgOnJ4UcNZiCi8qLCyNo8vymAAAAG5St797VmFfoTHU1M/IYwLORWjD + jxcXl4avqf4kjwkAAOBGbW9vX9ztIz5wvX2FxtKj8qiAcxFTbAoLS+PoA/1NKI8KAADgBsXNar2wp9BI + Cik8JI8KOBdN09yjtLg0jroHuY08KgAAgBsUU/340p5Co+iqbu99mzwq4FzN0/x1hQWmUVQ/KY8JAADg + BoUQXl3eU2j46pflMQHno2nq3y4vMg1eG97Qjcg3VQAAADcoxnjf4n5CY+lxeVTA+Yht9U2FBaaR1LbV + JXlUAAAA1xPb+ltKewmNo5jqo3lUwPkIm+H+pUWmcRTa8D15VAAAANdTp/qFpb2ExlF9tP74PCrgfOzs + 7FzQLaordi8yjaOYwsvzqAAAAD5MjPGjLkkHry7tJTR8IYTX51EBeyG04Q9Li02j6GR1rLpbHhUAAMB/ + iqn+ysIeQiOp22v/Sh4VsBe6B73/XVpsGkv1iTwqAACA/xRT+IPyHkKjqAlfnUcF7IWwGT6zuNg0ivqb + Uh4VAADAKdvb2xcfSofeV9pDaBzFGD85jwvYC7PZ7GaXpkvfXVpwGr5TN6WmuU0eFwAAwEe0bR1K+weN + I59/BfukaapnlhadRlIT2jwqAACA/rOMn1rcO2gU9fPJowL2Ukz1d5YWncZRTNVv5FEBAAArrn8XTbdP + eNvufYNGVBO+Io8L2EtN03xucdFpFPVv8Ywx3iqPCwAAWGFxs/qC0r5B46k+Wt8zjwvYS03T3LxbZO/d + veg0ntq2nudxAQAAKyym+vGlPYPGUQjhtXlUwH6IKTyntPg0jmKqnpZHBQAArKimaS5s2vDm0p5B46jb + uz0ljwvYDz4Ha+ytvbN/pVweFwAAsILiZvVF5f2CxlP9ZXlcwH6IMT6ovPg0lkIKD8vjAgAAVlBM9c+V + 9goaTyltfEIeF7Af+peiHklH3l5agBpHoQ1PzuMCAABWTP/tg+tp/S2lvYLGUZWqV+VxAfupSfXTS4tQ + 46iu67eeOHHiojwuAABghbRt/cWlfYLGVP2kPC5gPzVN+OryItRY6m5al+ZxAQAAKySm6udLewSNp26/ + FvK4gP1UH60/vrQINabqX87jAgAAVkT/Tgwf+TL6rtrY2Lh9Hhmw35o2/EthIWokVVX1nqZpbpPHBQAA + rID+nRil/YHGU0zhRXlcwCI0qf6Z0mLUiGrCVh4XAACwAmKqfrW4N9Boim39XXlcwCK0bT0vLUaNqKZ+ + Rh4XAAAwcf07ME69E6O0N9BoCpvhgXlkwCIcO3bsI9fW1j5UWpAaR/18tra27pxHBgAATFiT6i8r7Qs0 + nvpvjN/Z2bkgjwxYlKap/rS0KDWimvC1eVwAAMCEhTY8u7gn0IjyZVswiNjWO+VFqdHUVC/I4wIAACYq + xvhxl6SDVxf3BBpNMdVfmkcGLFLbVpeUFqVG1cn6aP3xeWQAAMAEdc/7L9u1D9D4Olkdq+6aRwYs2IEQ + wusLC1MjKqb6O/O8AACACapT/belvYDGU0zh5XlcwBBCG55cWpwaT1WqXtWN6sDpiQEAAFMSNsP9S/sA + ja4fzCMDhtC29bywMDWyujl9Xh4ZAAAwIbGtf6K0B9C4sieDgW1vb1+8sbHx/tIC1XgKbfjFPDIAAGAi + mqa5+Xpaf0tpD6BR9bbZbHazPDZgKKENf1RYoBpRVVW9Z319/bZ5ZAAAwATEFJvS83+Nq5iqp+SRAUNq + NsP/Ki1SjauY6q/MIwMAACYgpvDHpef+GlchhTqPDBhS0zT3KC1Sjavu5vaiPDIAAGDJVcequ12SDl5d + eu6vUfUB74aBEfG1rctRvVXfO48MAABYYrGtd0rP+TWuQhv+MI8MGINuYf7g7oWq8dU9eP5QHhkAALCk + dnZ2Lmja8O+l5/waW/WJPDZgDEIKDy4vVo2qNrzhxIkTF+WxAQAAS6jbfx0qPt/X2DoZY/y4PDZgDJqm + udDXty5HcbOKeWwAAMASiqn6jdJzfY2spvrzPDJgTEIbnlxctBpVMYVn5ZEBAABLqHtO/wel5/oaXY/K + IwPGJKTwsMKC1fg6mdL8v+WxAQAAS6ht64eGEP6h8HxfIylshvvlcQFj0n+2Ul3X7ygtXI2r0IYfz2MD + AACWVL8Hi6l+RFVV7yo979dwhRD+LY8JGKPQhqeWFq9G1xVra2u3zmMDAACW2Obm+sfGVD2te55/ctfz + fg1UbOufyOMBxiiksFFavBphTTiexwYAAExA21aX1Kl+cfH5vxZajPGz81iAMTp+/PgtvXx1OYop/Fke + GwAAMB0HYhsfHkJ4U2kfoP2v+9m/tp/D6XEAoxXa8OulRazx1bbVA/LYAACACdne3r64e85/edcHrrsH + 0EL6sTwGYMxiik1hAWuExVT/XB4bAAAwQfVWfa/Qhj8s7Qe0P4XN8Jn5xw+MWf/h4N2ife/uRazxdSgd + et/W1tad8+gAAICJatv6oSGEfyjtC7R3efsgLJnQht8pLWaNskflsQEAABN24sSJi2KqH+Fzi/evbi/8 + I/nHDSyD2MZjpcWs8RVCeH3TNDfPowMAACauOlbdNbThibPZ7JrSHkHnXv9NkPnHDCyDpmlu1y1eHxa4 + JMVUH82jAwAAVkTYDA+sU/3i0h5BZ1+Vqld1P1ZvH4RlE1P43dKi1hirX5bHBgAArJYDsY0P30gbbyzv + FXSmxbb+4fwzBZaJbyNcrtq2/pw8OgAAYMVsb29f3O0LLu/yTppzrWkO5h8nsEyOHz9+yyatvbO4sDXC + 6qfn0QEAACuq3qrv1TT1M8p7Bt1gbXhl9+Pz9kFYVjFVTykubo2uS9LBq2OMn5hHBwAArLCQwlrThn8p + 7R10/UIbfij/6IBl1D3oHSotbo2z2NY/mkcHAACsuBMnTlwUU/2IqqreVdo/6L+KMX5a/rEBy6hpmgt9 + GOBSdeXGxsbt8/gAAAA+ojpW3TW04Ymz2eyawh5i5atT/Vf5RwUss9jWjy0tco22R+XRAQAA/KewGR7Y + NNWfFvYQK11M9TfnHxGwzLoHuc8sLXKNtDa8OcZ4qzw+AACA6zoQ2/hw77Q5Xf+qtG7/9HH5ZwMsOx/+ + t1zFVP/PPDoAAIDr2d7evrjbO1ze9YHr7iVWrZjCH+cfCTAFsa2/t7TYNc6qVL1qNpvdLI8PAACgqN6q + 79U09TNK+4pVKLbxWP5RAFPQPajdu7TYNd66B+LNPD4AAIAb1bb1Q6tUvaK0t5hqVVW9p2ma2+QfATAV + TapfVlr0Gmf5mzQOnJ4eAADAjTtx4sRFMdWPqKrqXaU9xvSqfyn/1oEp6R7Ivr686DXW4mZ1OI8PAADg + jGxtbd25/zb6/gPOS/uMqdS/6iz/loEpOXr06B02NjbeX1r4Gmv18/L4AAAAzkrTNAebpvrT8l5juQsh + vL77/V2Yf6vA1IQ2/Hpp8Wu8xRhneXwAAABn60BMsQkhvLa031jiHp1/f8AUtW39xYWFrxEX2vDsPD4A + AIBzsr6+fttub/EjszT7YGnfsWzFGD8t/9aAKdrZ2blgnuavKT0AaLy1bf15eYQAAADnLMb4yU2qn17a + dyxLMYWX5N8OMGWhDd9fehDQiGuqP8njAwAAOG/9B6A3zfzvi/uP0VefyL8NYMpijJ/YLfqT138Q0JgL + KfyPPEIAAIDzduLEiYtiqh/RpLV3lvYgY6yqqvccO3bsI/NvAZi6mMLzSw8GGm+hDf83jw8AAGDPzOfz + O8W2fuwl6eDVpb3ImOr2RU/Ov2xgFTSp/rLSg4HGnVdhAQAA+6VpmoMxhReV9iJjqW2rz8q/XGAVbG9v + X9wt/it3Pxho5DXVM/MIAQAA9sOBmGIzxi//iin8Xf41Aqukf+ll6UFB465t68/JIwQAANgX+UUPl29s + bLx/955kqPrP68q/PGCVhM3wmaUHBY27OtUvzCMEAADYVzHGT25S/fTS3mTBfWBra+vO+ZcFrJrugehl + hQcGjbyQwsPyCAEAAPZdtwf5wqaZ/31pf7KIQht+Jf9SgFXUNOGrSw8OGnnN/G92dnYuyGMEAADYdydO + nLiofxtfk9beWdyn7GNtW39+/mUAq2htbe3WdV2/o/QAoXEX27iZxwgAALAw8/n8TrGtH3tJOnh1aa+y + 57Xhld0/9sDpfzqwskIbfqr4IKFx14Z/6f8EJI8RAABgodq2uqRO9YuL+5U9rf72/I8EVllK8/t0Dwon + r/8gofFXn8hjBAAAGMKBmGIzT/PXlPcs590Hqu3qLvmfBay6pqleUHig0MgLIby+fxtoHiMAAMAg+n1J + t0e5fGNj4/279y3nU0zVU/I/AuDUh7lvlR4sNP5iqv93HiMAAMCgUpp/UpPqp5f2LudS/zbF/LcG6A+w + mps3bXhz6QFD4+5IOvL2GOMd8ygBAAAGF1L4wpjC35X2MGdcU/15/tsB/JfQhh8qPmhoGfrJPEYAAIBR + 6L90Kqb6EU1ae2dhD3OTdf/fL81/K4D/0jTNPRb2Naja09bW1j5Ub9X3yqMEAAAYjfl8fqfY1o89m/3m + elp/y/Hjx2+Z/xYAH65p6meUHjy0BDX1b+cxAgAAjE7bVg+oU/3C4n5mV6EN35//bwDX17b1Q0sPHlqO + uvl9Xh4lAADAGB2IKTbzNH9NaU/T179Sqz5af3z+3wOUNc38b0oPIlqCmvlf7uzsXJBHCQAAMEpra2u3 + 7vYwl29sbLz/+vsa7y4BzkBs41dd7wFES1M3v2N5lAAAAKOW0sbdQxue+mF7ms3qC/J/DXDDDh8+fIsQ + wpuu+wCiJaoN/9H/aUYeJwAAwOj1h1Yxhb/r9qL/0P3bA6f/U4Cb0H9gXvFwRMvSo/IoAQAAlsKJEycu + ijHeN/9bgJtWHavuOkuzDxYORrQcvbdpmnvkcQIAAABMU0zV0woHI1qSuvn9ah4lAAAAwDS1bfWA0sGI + lqeQwkPyOAEAAACmqU71C0sHI1qSmvnf9+8jz+MEAAAAmJ62rUPxYERLU2yrb8jjBAAAAJiepmkuDCG8 + unQwoqXpimq7ukseKQAAAMD09K/gKRyKaIkKbXhyHicAAADA9Kytrd16Pa2/pXQwouVoNptdEzbDZ+aR + AgAAAExPTPV3lw5GtEQ185f2bwnNIwUAAACYlhjjHZsUrrzeoYiWqpjqR+SRAgAAAExPbOufKB2KaKm6 + sjpW3S2PFAAAAGBa+oOPWZp9sHAooiUqtOF38kgBAAAApqdJ9S+UDkW0XIUUNvJIAQAAAKYlxvgp/Tfa + lQ5FtDyFEF67vr5+2zxWAAAAgGmJKfxu6VBEy1X/mWZ5pAAAAADTEmN8UOlARMvVJeng1U3THMxjBQAA + AJiWpqmeWzoU0bJVv2w2m90sjxUAAABgOtq2fmj5QETLVmzr78hjBQAAAJiWpqleUDoQ0dL1gbAZ7pfH + CgAAADAdcbP6osJhiJaxpvrzpmkuzKMFAAAAmA6vwppOsa2/JY8VAAAAYDpCCodKhyFavjY2Nt6f0vw+ + ebQAAAAA01Gn+oWlAxEtX90sX7yzs3NBHi0AAADANMTN6nDpMETLWWyrb8ijBQAAAJiOmMKflQ5DtHxV + VfWe+mh9zzxaAAAAgGkIKTysdBii5Sym8CLfSggAAABMTtNUf146DNGyVn97Hi0AAADANHgV1rSapdkH + m6b573m8AAAAANPQpPp5pcMQLWdVql4RY7xVHi8AAADA8mua5nNLByFa6n4sjxcAAABgGkIb/qhwCKIl + bTabXdO29efn8QIAAAAsv7AZPr0/9CgdhmhJa8N/HD169A55xAAAAADLL7Th14sHIVri6l/K4wUAAABY + fvVWfa+1tbUPlQ9CtKzFNh7LIwYAAABYfqENTywdgmh5q6rqXSnNPymPGAD2Rf8HJv3zCEkaZSls5Icr + AKZgc3P9Y5sU3rv7EERLXjN/adM0N89jBoA9t7a2dutuk/js4n1Ikgaue3z6/vxwBcBUxLb+0dKDvpa7 + 7qb9I3nEALAvHGJJGmsOsAAmqP/murqu31F64NdSdzKksJbHDAD7wiGWpDHmAAtgomJbf1fpgV/LXQjh + TU3TfEweMwDsi+3t7Yubpnpu6V4kSUPkAAtgomKMtwohvLb04K8lr6meubOzc0EeNQDsC6/EkjSmHGAB + TFhs45eXHvy1/MW2/rY8ZgDYN16JJWksOcACmLD+VTpNql9WugFo6buqbevPy6MGgH3jlViSxpADLICJ + Cyk8pHQD0PLXfx7W5ub6x+ZRA8C+cYglaegcYAGsgJjCH5RuAppATfXc2Wx2szxqANg3DrEkDZkDLIAV + EGP8lO5J54dKNwJNoh/MowaAfeUQS9JQOcACWBGxrX+6dCPQJDrZtvU8jxoA9pVDLElD5AALYEXEGO94 + JB15e+lmoOWvrut31Efre+ZxA8C+cogladE5wAJYIbGtv610M9A0iin8dYzxVnncALCvHGJJWmQOsABW + yOHDh29RpepVpRuCplF3Y39iHjcA7Lvt7e2L+y8UKd2TJGkvc4AFsGKaJrSlG4KmU2zj1+RxA8C+c4gl + aRE5wAJYQTGF55RuCppG/TdOtm39eXncALDvvJ1Q0n7nAAtgBYXNcL/+kKN0Y9A0CiG8qTpW3S2PHAD2 + nUMsSfuZAyyAFdXdAB5TujFoQjXzv/Sh7gAskkMsSfuVAyyAFXXs2LGPbNrwhtLNQdOpu9E/NY8cABbC + IZak/cgBFsAKa5rwFaWbgybWZvjGPHIAWAiHWJL2OgdYAKvtQEzhz0o3CE2qq9q2/vw8cwBYCIdYkvYy + B1gAKy5shgfOZrNrSjcJTae6rt+a0vyT8tgBYCG2t7cvbprquaV7kySdTQ6wAPiIJtVPKt0kNLHa8I9H + jx69Qx47ACyEV2JJ2oscYAHwEfP5/E7dTeFtu28SmmL185qmuXkePQAshEMsSeebAywATomp/vrSjULT + q7v5PzmPHQAWxiGWpPPJARYApzRNc2FM4eWlm4Um2GZ4ZB49ACyMz8SSdK45wALgPzVNc/CSdPDq0g1D + 06r/4P6QwkYePQAsjFdiSTqXHGAB8GG6G8NjSjcMTa9L06XvbtvqM/LoAWBhHGJJOtscYAHwYdbX12/b + tOE/SjcNTa8Qwms3N9c/No8fABamP8TydkJJZ5oDLACuJ25WVemmoWkWU/i7jY2N2+fxA8DCeCWWpDPN + ARYARU1T/17pxqGJ1lTPPXz48C3y+AFgYRxiSTqTHGABUJTSxt27G8WVu28cmnL1r3WjP3D6CgCAxXGI + JemmcoAFwA1qNsMjSzcPTbfuicEP5fEDwEI5xJJ0YznAAuAGNU1zYZPql5VuIJpwm+Eb8yUAAAvlEEvS + DeUAC4Ab1TTNwUvSwatLNxFNs9lsdk1Ioc6XAAAslEMsSaUcYAFwk7obxk/uvoFo2h1Kh94XUnhwvgQA + YKH6Q6yYwnNK9yhJq5kDLABuUv8kskrVv5ZuJJpya+8Mm+H++TIAgIXySixJ180BFgBnJMY4624cJ3ff + SDTx2vDmbvafki8DAFgoh1iSrs0BFgBnrLtp/GzpZqJpN0/z16S0cfd8GQDAQjnEktTnAAuAM7a9vX1x + 04ZXlm4omnjN/O/n8/md8qUAAAvlEEuSAywAzkrcrL6gu4F4K+EKVqf6L9bX12+bLwUAWCiHWNJq5wAL + gLPW3TyeXLqpaPr1G4fjx4/fMl8KALBQDrGk1c0BFgBn7dixYx8ZQnht6cai6dc9efj92Wx2s3w5AMBC + OcSSVjMHWACck7atLy3dWLQaxVT9RtM0F+bLAQAWqj/EaprqT0r3KEnTzAEWAOesu4k8tXRz0WoUU/WU + nZ2dC/LlAAAL5RBLWq0cYAFwzmKMd2za8IbSDUarUv2E7lI4cPqKAIDF6g+xYgrPKd+jJE0pB1gAnJeQ + wqHuhuJbCVe4mOqf6y4Fh1gADMIrsaTVyAEWAOctpvrxpZuMVqfuCcVj8uUAAAvnEEuafg6wADhv/ZPG + EMI/l240Wp26JxU/ni8JAFg4h1jStHOABcCeCJvhgd0Txw+VbjZanbonFt+TLwkAWDiHWNJ0c4AFwJ7p + bizft/tGo9UrtvUP50sCABbOIZY0zRxgAbBnZrPZzepU/0XphqPVqnuC8SP5sgCAhXOIJU0vB1gA7Kl6 + q773oXTofaWbjlat+me6S8K3EwIwCIdY0rRygAXAnoupfkTppqNVrH7Czs7OBfnSAICFcoglTScHWADs + hwPdDeaPSjcerWL1kxxiATAUh1jSNHKABcC+qI5Vd6vr+h2lm49WsfoXHGIBMJT+ECum8JzyPUrSMuQA + C4B907Z1KN18tJrFVD2taZoL8+UBAAvlEEta7hxgAbCv+s9AKt2AtJp1G4c/OH78+C3z5QEAC+XthNLy + 5gALgH3VH1bEFP66dBPSitZUz11fX79tvkQAYKEcYknLmQMsAPZd2Az362467919E9IK18xfurW1ded8 + iQDAQjnEkpYvB1gALERs49eUbkRa3UII/9B/2H++RABgoRxiScuVAywAFqZJ9a+VbkZa3UIIr6636nvl + SwQAFsohlrQ8OcACYGE2NjZu3x9YlG5IWt020sYb27b6jHyZAMBCOcSSliMHWAAsVNvWn9PdgK7afUPS + alfX9TtCCg/OlwkALFR/iBVTeE7pHiVpHDnAAmDhYlt/V+mmpJXvA00T2nyZAMBCeSWWNO4cYAGwcDs7 + Oxd0N6Bnl25MWu0uSQevjm31dflSAYCF8kosabw5wAJgENV2dZd5mr+udHOSYls/tj/ozJcLACyMV2JJ + 48wBFgCDiTF+dvck8UOlG5QUU/W0pmluni8XAFgYh1jS+HKABcCgupvRt+6+OUnXduqtpk1zu3y5AMDC + OMSSxpUDLACGdiCm8Fulm5TU110ff1cdq+6WrxcAWBiHWNJ4coD1/7d3L9CW3XVhxzsJkIRHeCpPiYCo + mKLIGEp5eNVgGMKde+/+P/b/zNyRoWoHZWlTtXVcRXojXa1ZVCyxVhukauOjNVi1olVXQECigCQWUR4K + ASQ85P0yPPJq/3tmByaXnZm5M+fcex6fz1rfdQPhkczss////cve+wCw41ZWVu7VlObtQwuV1NW9L61t + m8f3hwwAbBtDLGk6MsACYCrEUfzGujDduHmhkm7v4nLxZ2KJq/0hAwDbxhBL2vkMsACYGqmE7xlarKRj + uq12aX/IAMC2McSSdjYDLACmSi7hF4cWLOmOhV84dOjQXfvDBgC2hSGWtHMZYAEwVQ4ePHh2KvG6oUVL + ukP1AmL//v337Q8dANgWhljSzmSABcDUSSl9TQjh40MLl3SH2vi27njpDx0A2BbdEKteTL9ycG2SNJEM + sACYSmnU7Lmg7L5laPGSNvXRtg3f3h86ALAtDLGk7c0AC4CpVReqw5sXLmmofth5uD90AGBbeJxQ2r4M + sACYZrtSaX59aAGThqobm19LKZ3THz8AMHGGWNL2ZIAFwFTrhhG5hGuHFjFpsLz2F2F/OK8/hABg4gyx + pMlngAXA1OuGEStl5cNDC5k0VAjhI96LBcB2MsSSJpsBFgAzIef8lKWy9IWhxUy6k26ueS8WANvGEEua + XAZYAMyMVMIlQ4uZdLzqcfOSPXv2nNUfRgAwUd0Qq15o+3ZCacwZYAEwU+rC9dKhBU06bkffi/XI/jAC + gIlyJ5Y0/gywAJgpBw8ePDuU8IahRU06XiGEj8cSl/tDCQAmyp1Y0ngzwAJg5uScHxRjfO/QwiadoNtS + Gy4/dOjQXfvDCQAmxp1Y0vgywAJgJsVRPL9pmk8NLW7SiUolvqZZbx7cH04AMDGGWNJ4MsACYGbFEp9x + Qdl9y9ACJ52wNn6oHkMX9ocTAEyMIZZ0+hlgATDTUgk/PLTASSfZzbXDGxsbZ/SHFABMhHdiSaeXARYA + My+V8PNDi5x0snUXFKPRykP6QwoAJsKdWNKpZ4AFwMzrXsidSrx6aKGTTraVsvLhNGqe2R9WADARhljS + qWWABcBcWF9fPzfntb8eWuykLXTkWwpzznfrDy0AGDtDLGnrGWABMDdSSo/o7qIZWvCkrRWuDfvCo/tD + CwDGzhBL2loGWADMlZzzU+oC9/nNC550Cn06lfBd/aEFAGNniCWdfAZYAMydnOOBusjdtnnRk06lVJpf + yTnfuz+8AGCsuiFWvTD37YTSCTLAAmAu1UXu8OZFTzrV1sra37Vt+Pb+8AKAsXInlnTiDLAAmFtHXsY9 + sPhJp9htdeN0RXeR0R9iADA2hljS8TPAAmBubWxsnJFK/M2hBVA61ZrSvKVtm8f3hxkAjI0hlnTnGWAB + MNdSSueEEl47tAhKp1q9wLip/rw053xmf6gBwFgYYknDGWABMPfW1tbun9v4tqGFUDqduuFo2B8e2R9q + ADAW3RCrXqx7sbt0TAZYACyEZr15WG7jDUOLoXQ6XVQu+mz9edjdWACMkzuxpDtmgAXAwkgpPTaX5U8O + LYjSaZebPw37wtf3hxsAnDZDLOlLGWABsFDaNnz7Uln6wtCiKJ1u7sYCYNy6IVYq8erNa460aBlgAbBw + co4HlpaWbh1aGKVxVC80XlfK2mP6Qw4ATot3YkkGWAAsqNQ2zx1aGKVxVS82bkptuCznfLf+sAOAU9Z9 + s7I7sbTIGWABsLBSCf92aHGUxlm92Lgu57y7P+wA4JS5E0uLnAEWAAutLoY/tXlxlMZd98hq3XRdsb6+ + fm5/6AHAKXEnlhY1AywAFt2uuhi+dGiRlMZeGz+Q2vSs/tgDgFNiiKVFzAALgIXXfWNcLuGqoYVSmkg5 + vDzsD+f1hyAAbJkhlhYtAywAqLoXbddN4B8OLZbShLqxdnhpaeku/WEIAFtiiKVFygALAHorKyv3CiW8 + YWjBlCZVvfC4rm2bJ/aHIQBsiRe7a1EywAKAY6yurt4nlfimoUVTmmC31U3ZlaPR3gf2hyIAnDR3YmkR + MsACgE1Go5WH5Db+7dDCKU225U+mEi7xWCEAW+VOLM17BlgAMKBZbx6W23j90OIpTbqmNG9v2/D0/nAE + gJPiTizNcwZYAHAncs4Pb0rzrqEFVNqWfFshAFtkiKV5zQALAI6jlLVH5TbeMLSISttR0zT/kEp4XndB + 0h+WAHBcHifUPGaABQAnEPaFR8cY3z+0kErb1VpZe18u4dDGxsYZ/aEJAHfKnViatwywAOAklLL2mNzG + Dw0tptK2ltfe2LbhW/tDEwAGdV8I0n0xyOBaIs1gBlgAcJJSSo8NIXxkaEGVtrvun6rHUTy/PzwB4Iva + NjwtlPDmofVDmtUMsABgC9q2+aa6gH5084Iq7UTLy8s31c3cFSmlr+gPUQAWWN2nPDGV+JqhNUOa9Qyw + AGCL4ih+S11EP7F5UZV2qr1l78dSCf/ai94BFtORVx3k8DtDa4Q0LxlgAcApaNvm8XUhdSeWpqqVsvLh + +vPwnj17zuoPVQDmWErpod2duPXcf/Ox64E0jxlgAcApyjk/zjuxNJW18T3dNxbWY/TM/nAFYI7U8/s9 + 6/n+cO3Tdzj/S3OcARYAnIbuxe6+nVDTWirxTWnUPLM/XAGYcQcOHLhH98h4Pce7C1wLlwEWAJymI++d + aOMHhhZaaRoKJbw2lvjU/pAFYMYsLy/fPbXhR/xDMy1yBlgAMAZhX3h03VTeMLTYStNSKvGaNGq+oz9s + AZhy3TsNu0fCY4zvHzqvS4uUARYAjEnYH87Lbbx+aMGVpqlukBVLvLA/dAGYMjnnuxlcSXfMAAsAxqhu + OB9eN5vvHFp0pWnLIAtgutw+uFora+8bOm9Li5wBFgCMWSmrX5Xb+LdDC680jXWDrLYNe/tDGIBtZnAl + nTgDLACYgNFo5SE5r/310OIrTWupxNfEEp9RD+FdR49kACZpfX393O5bBT0qKJ04AywAmJD9+/ffN5Tw + Z0MLsDTN1eP2zalNz1paWrpLfzgDMEbNgeYr6/n20r1l78c2n4MlDWeABQATdODAgXvk3PzR0CIsTXsx + xnenEi7pvr69P6QBOA0ppUekNlx+Ubnos0PnXUl3ngEWAExY916LuuC+bGghlmahlbLy4frz0nrhdb/+ + sAZgC+pe4HF1L3BlPZfefOz5VdLJZ4AFANugexSrLrq/NLQYSzPUp2s/FfaH8/pDG4DjSKPmO3NuXrHp + XCrpFDLAAoDts6suvv9p82IszVoXlN23dHcVtm14cn9sA9Dbs2fPWTnHA6nE64bOoZJOLQMsANhmdQE+ + vHlBlma1oxdo4dDBgwfP7g9xgIU0Gu19YD0vHs5tvGHzuVLS6WeABQA7ILXNc5eWlm4dWpylWWy1rH6w + /rx03759D+gPc4CFkHPeXS+sr1hdXf3c5nOjpPFlgAUAO6R7vGB5efmmoQVamuFu7C7kuhcW94c6wNzp + vqClW8dDCW8YOA9KmkAGWACwg2KJFzZN86mhRVqa/cK13eOFy8vLd+8PeYCZ5jFBaecywAKAHRZH8Zvr + RvgDQwu1NA/tLXs/VjedLypl7Wv7wx5gluyKJX5bPY/92lJZ+sLQeU7S5DPAAoApUMrqV+c2vm1osZbm + qVTiNamkfOjQobv2hz/AVMo5PyiVcEk9b/3V0PlM0vZmgAUAUyKldL/u4n5owZbmrRjj++tG9CfdlQVM + k5zzmWnUPLOen37Leyql6coACwCmyJ49e85KpfmNoUVbmt+OvitrZWXlXv1HAWBbpZQeWs9Hh2OM7/7y + c5SkacgACwCmz67Uhv84tHBL89zRr6APV7VteFr3OTj6cQCYjO6bBOv5Zm933rmg7L5l6LwkaXoywAKA + KVUX6sO1245duKVFqSnNO1IbfjzsD+f1HwmAcdjVtuHJ9UL45+q55qObzz2SpjcDLACYYqlN677xSAve + baGE16YSvn9tbe3+/UcDYEtSSt/QXfx6RFCa3QywAGDKxRKflNv4oaGFXFqkukd8UolXpzY9y/uygBMZ + jVYe0n+LoC9IkeYgAywAmAFhf3hkjPGtQ4u5tIhdVC76bM7h5amk3L3Hpv+oAAtufX393G7I3Z0f6rni + 5s3nDkmzmwEWAMyI/fv33zfn5hVDC7q04H00lea/tW242DALFk83tMo57qsXty87+mUQg+cJSTOeARYA + zJClpaW7pDb87NCiLulINx65M+vIHRj5nv1HB5gzKaX7HXOn1ec3nQckzWEGWAAwg7p3evjKb+n4ffEx + w3qR292h0X98gBmVUvqK24dWy8vLNw197iXNbwZYADCj0qhZubhc/JmhBV7SHeuGWanE380lHKoXwQ/t + P0bAlCtl7VGpDT9aP7+vq5/l2zZ/tiUtTgZYADDDcs6Py228YWiRl3Sn3VYvhq+rF8UvaNvmgo2NjTP6 + jxSww7pH5WOJT60Xqj+Z89pfDnx+JS1oBlgAMOOa9ebB9WL8z4cWekknbrWsfrBuil+aRk1z4MCBe/Qf + LWCb5JwflNr0z3IJV9XP5Cc2f0YlqcsACwDmwJ49e87qvoVtaLGXtKVurhfR16Y2XFYvqp/i7iwYv/rZ + OrO2u37eDqcSr1laWrp10+dQkr4sAywAmCPdy93rAl8vwIcXfklbK4Twkbph/p/1s/U99YL74f1HDdii + 0WjlIUdewF7C/9hb9n5s6PMmScfLAAsA5kwaNd/RXXQPLfySTrM2vq3+/JnuSxS6r/HvP3bAJv1jgaNc + wn9tSvP2L/ssSdIWM8ACgDnUrDcPy3ntjUOLv6Qx1sbr64b6iu7OklJWv6r/CMLCaQ40X9m2Ye+Rx29L + uLZ+PnxjoKSxZoAFAHNqeXn57t2jGkMbAEmTKcb41lTCz9f2p5Qe2n8cYe50A6tUUq7rzH9pSvOWoc+D + JI0zAywAmG+7Uht+9IKy+5ahjYCkyVYv7N+VSvPr3fvp4ij+k5zz3frPJsyM7rhNKT0htc0P1gvIX4sx + vnPoeJekSWaABQALoG3D00MIHx/aDEja1m7u7la5/bHDOIrn14/orqOfVJgO3QvXu8cB6/F6aSrx6ovK + RZ/ddBxL0rZngAUACyKl9DX1QuRNQxsCSTtYGz9QP5u/WzfmP5FGTVPK6lf3H1uYuH379j0glnhhLuHH + 6nH426tl9YODx6kk7XAGWACwQA4ePHh2d+fH0KZA0jS1/MlU4jWpDZd3d2rlnHd7/JDTUY+fM8P+8Mjb + 76zKOby8+xKC+sdeti5pJjLAAoAFlHP8bo+ESDPXjd23i6bS/HL3brs0ap6ZUnpE/Uh7BJE7yDnfO5b4 + 1FTCD9Rekkr8c+d8SbOeARYALKh6gfO4pjTvGNogSJqdmqb5h1zCtbX/Xv/14VjictgXHn3o0KG79h93 + 5lB3R1Upa4+qv9/PSG3zL+uF3c/l3LwixvjezceIJM1DBlgAsMDW19fPrRe9Vw1tEiTNQUffr3V1/+jw + 4VRSrnYfOHDgHv1pgCm3f//++3a/Z0d+77pH/46cs7uBZbzxi7/PkrQAGWABALtSG36kbgxu3rxRkDSf + LS0t3Zrb+J6cm1fVC4Iru4uC1KbntG24uPtmxJzzvfvzAxO0Z8+es/q7qL7tyLvOSnx+98hf/f34g+7b + Ko/eXTf8eyhJi5YBFgBwRPe+lBjj+4c2DJIWr6ZpPpXz2l+nEn//yHuU2vCC1DY/mHNs2zZ8aylrj0kp + 3a8/hXCM+utyTs754W3bXNANBbvhVPcPCmo/XS/AXpZz8/ru7rj66+wF6pJ0khlgAQBfNBrtfWDdHLxy + aNMgSUMtlaUvrJW196USr+uGXbmEX01t+NnuQqP++X+V2vS9adSkWOKF3aNw3TfhdYOvjY2NM/pTz1Tq + 7o7q/jqPfnNf8031r/9JtYuOPoYZv7sbSNW/xxfWfunIN/rl5vUxxne7a0qSJpMBFgBwB91FZSrheXWj + 4JFCSROte5QxhPDx1bL6wdzG60MJb+7e73RkkJ6bP+re95RK8+v1X19xbPUc9fOpDZedqE3/nZf07486 + UirxN7v3g3V1w6f686+a0ryr++upf23Of5I0ZdVzuQEWAPDlUkpPiDG+c2gDIUmSJG1nBlgAwJ3qvqWw + u/thaBMhSZIkbVcGWADACXUvIPZeF0mSJO1UBlgAwEkJ+8LXpxLfNLShkCRJkiaZARYAcNIOHjx4dmrD + 5XUT4avfJUmStG0ZYAEAW5ZGTbO37P3Y0OZCkiRJGncGWADAKck5P6huJH5vaIMhSZIkjTMDLADgdOzK + JRzygndJkiRNMgMsAOC0dS94z3ntjUObDUmSJOl0M8ACAMZiaWnpLnVzcXh5efmmzRsOSZIk6XQywAIA + xiql9IQY498MbTwkSZKkU8kACwAYu5TSOakNl9fNxm2bNx+SJEnSVjPAAgAmJpb4jNzGDwxtQiRJkqST + zQALAJio1dXV+9QNxxVDGxFJkiTpZDLAAgC2RRo1e2KM7x3akEiSJEnHywALANg26+vr5/Z3Y3k3liRJ + kk46AywAYNu1bfjWpjTvGNqcSJIkSZszwAIAdsTy8vLdUxsuW1paunVokyJJkiTdngEWALCj2jY8uSnN + 24c2KpIkSVKXARYAsOP6u7F++oKy+5ahDYskSZIWOwMsAGBqtG3z+FzCtUObFkmSpLHXxg+EEt4w+Oc0 + VRlgAQBTZWNj44xcwqGmaT41tHmRJEkaQ7fFNl6ZUrpfdyd4/eNXDvxnNEUZYAEAU6lZbx7cbSyHNjCS + JEmnXF77y7ZtnthvOY4wxJr+DLAAgKkWS1zObXzP0EZGkiRpC91YuzTnfLd+m3EHhljTnQEWADD1+pe8 + X+Yl75Ik6ZTK4eVhfziv31rcKUOs6c0ACwCYGV7yLkmStlKM8d2xxNV+K3FSDhw4cI+cm1cN/e9p5zLA + AgBmSs75zNQ2z91b9n5saHMjSZK0urr6ufrz36WUzum3EFtiiDV9GWABADOp+9ag1IbLPVYoSZLuUG5e + UcraY/otwynzOOF0ZYAFAMy0OIrfnEq8ZmijI0mSFqg23pDa9Kx+izAWhljTkwEWADAPduUSnh1j/Puh + DY8kSZrfuscFUxte0A2b+n3BWB15nLCEVw/9f2v7MsACAObG0Q1mvHSpLH1h86ZHkiTNYUe/XfCR/VZg + YtyJtfMZYAEAcyel9HWpxD8c2vxIkqTZL8b41rYNT++X/m1hiLWzGWABAHMrjZqU23j90CZIkiTNXitl + 5cOpTc/pvpW4X+63lccJdy4DLABgrh06dOiudaN5KITwkaHNkCRJmv6Wl5dvim28Yt++fQ/ol/gd406s + nckACwBYCCml+6U2XFY3QJ/fvCGSJEnTWyrx6jiK5/dL+lQwxNr+DLAAgIVSytrX5hKuGtoYSZKkKSqv + vTGltNQv4VPHEGt7M8ACABZS3RD/01DCnw1tkCRJ0g7Wxhu6x/83NjbO6JftqWWItX0ZYAEAi2xXKinH + GN89tFGSJEnb18Xl4s/Un5cePHjw7H6dngmGWNuTARYAsPC6jWcq4Xl1c/SJzZslSZI02VZXVz8X2/ii + aXhB+6ny7YSTzwALAKB3zIveb9y8aZIkSeNt+eg3C15Z199H9EvxTHMn1mQzwAIA2KRupL/CNxZKkjSZ + lpaWbu2+UCXsC4/ul965YYg1uQywAADuRNgfzqubpSsuKLtvGdpISZKkrZVKvDrn/Lh+qZ1LhliTyQAL + AOAE4iie3/2T4qHNlCRJOnGpxGtiiU/tl9a5Z4g1/gywAABOUts2T8y5edXQpkqSJH15qcTXxRIv7JfS + hWKINd4MsAAAtqhtw9NDCX82tLmSJEnx/9V18v+mUfPMfulcWL6dcHwZYAEAnKKc81NSiX88tMmSJGkR + a0rz9tSmZ21sbJzRL5cLz51Y48kACwDgNLVteFoo4bVDmy1JkhahpjTvyCU8e2lp6S798sgx3Il1+hlg + AQCMSXdHVs7NK4Y2XZIkzWMxxnfmEg4ZXJ2YO7FOLwMsAIAxM8iSJM17qcS/6h4VrGvemf3yx0kwxDr1 + DLAAACYklvhtBlmSpHkqlXhd24a1usztOrrasVUeJzy1DLAAACasbZsL6ob/N5eWlm4d2pBJkjT15eZP + 2jZcXJc1g6sxMMTaegZYAADbJOwPj0xtuPyictFnhzZmkiRNW6nEq9s2PLlfyhgjjxNuLQMsAIBtNhrt + fWDdiF1a+8SxGzNJkqahI3cM5/DynPPufuliQrohVirxj4d+H3THDLAAAHbI6urqfeqG7N/kNn5o8yZN + kqQd6MbYxv9cyupX90sV28DjhCeXARYAwA5LKZ2T2ua5R7+KfHjTJknSpKrrz9/Xn8/ft2/fA/qliW3W + DbFSia/Z/HujL2WABQAwJTY2Ns5o27C3e99I3ajdtnnjJknSOIsx/k0q4ZLuH6T0SxE7yOOEx88ACwBg + CuWcH1c3ald44bskadylEq/p/oFJXW58o+CUMcS68wywAACmWM75QakNL/CeLEnS6bS6uvq52MaXppQe + 2y8xTCmPEw5ngAUAMANyzndLbXpWzmt/ObSpkyRpsDZ+oP681PutZos7sb48AywAgBkTS7ywbmp/98jX + nA9s8CRJyrl5VduGmHM+s18+mDHuxLpjBlgAADNqNFp5SN3QHc5tvGHzJk+StJB9vl7kXxlH8Rv7pYIZ + 506sL2WABQAw4448XlhSrhtc314oSQtY922C9efhtbW1+/dLA3PEEOtoBlgAAHOklLWvTW24rG70Prp5 + 4ydJmp+WytIXcglXtW14Wj39+zbBOWeIZYAFADCXDh48ePYxd2UNbgQlSTPY0cfGL20ONF/Zn/JZEIs+ + xDLAAgCYc3EUv6Vu+q7IZfmTQxtCSdJ0191tVc/jL2vb8PSNjY0z+tM7C2iRX+xugAUAsCBuvysr5/Dy + C8ruW4Y2h5KkKaqNb6s/D7vbimMt6p1YBlgAAAuoWW8eVjeD3TcYXr95gyhJ2tE+XS/Ur/RuK45nEYdY + BlgAAAusexQllnhhLuFXLyoXfXZowyhJmmxLS0u31vPwq2vP7h4R60/RcFyL9jihARYAAEfknO+dc/y+ + nJvXD20cJUnjrSnN21MJzwv7w3n9qRi2pK7d91yUIZYBFgAAX6a7mKqbxe4Rw+79K4MbSUnS1gshfLxe + iF+Rc35KPd16RJDTtiiPExpgAQBwXPUia3fdNL4oxvj+oQ2lJOn4HX1EO1yVRs3KoUOH7tqfXmFsFuFO + LAMsAABOSve+rO6OgdSGy0MIHxnaXEqSjtZ922sq8ZpcwqH19fVz+1MpTMy834llgAUAwJbt2bPnrDRq + mrqZfNnq6urnhjaakrRoHXkZe25eldr0nLW1tfv3p0zYNvN8J5YBFgAAp2VlZeVe9WJt1A2z6gbzxs0b + Tkma5/qh1Z/mUfyhlNJD+1Mj7Jh5HWIZYAEAMDYHDx48u23D3rrJvDKX5U8ObUAladbrhlbd44GphEsM + rZhG8/g4oQEWAAAT0T1m2Lbhad07s3IbPzS0GZWkWen2d1p1Q6tmvXlwf6qDqTVvQywDLAAAJq771q1Y + 4kV183lFjPHvhzamkjSF3VjPW7+VS3i2d1oxi+bpcUIDLAAAtl0cxfPrZvRwdzdD/XnbsRtUSdrJum9Z + rRfKV6aS6rV/vmd/2oKZNS93YhlgAQCwo5r15mE5x++rG9Pfu6hc9NmhTaskTbIY41tTGy6LJT5pY2Pj + jP70BHNjHu7EMsACAGBqpJTOuf29WfWC8r1DG1hJOt26YXm9mL+6/vHhsC98fX8Kgrk263diGWABADCt + drVt8/hUwvNyCa+uG++bhja0knRStfFv6wXwi9s2PL37xtT+PAMLZZbvxDLAAgBgJnSb7ljicn931luH + NreS9KWWP1kv1H87tc1zS1l7VH8qgYU3q0MsAywAAGbSaLT3gd1LluuGtvtmw/cPbXYlLU4XlN235BKu + 7d5l1T2KXC/S79afLoBNZvFxQgMsAABmXvfS5XqxurtevP5Y3ZBf3TTNPwxtfiXNVbeFEt7c3ZXZtmHv + ysrKvfpTAnASujuxcm7+ZOCzNZUZYAEAMHeWlpbu0g20UgmX5BKuCiF8fGgzLGnGauP13V2X3d2X+/bt + e0D/kQdO0SzdiWWABQDA3Ms5n3nkDq1R/KG6Af7fe8vejw1tjiVNT90jgfXC+k3dHVZp1DRra2v37z/S + wBjNyp1YBlgAACyc7pHDlNJjUwk/kErzGzHG9w5tliVtX92jv92dIKkNL0ijZs/6+vq5/UcWmLBZGGIZ + YAEAQDUarTwklhjqBvmF/Sb+xs2bZ0ljrI031M/by7pHfdu2uaB79Lf/OAI7YNqHWAZYAAAwoHvsMI7i + +alNz6qb5iua0rylbqBv27yhlnTiLi4XfyaVeM2RxwHrZyql9Ij+owZMkWl+J5YBFgAAnKTuHTxtGy6u + G+nn5xz+V1Oad23eYEuL3urq6udCCW+oF5s/l0t4dkrpG7rHdvuPETDlpvVOLAMsAAA4Dd17eupm/ynd + Y1B1c31lvWC/tm60P7954y3NaZ/u7qzq7lI88q2f9bOwZ8+es/qPBzCjpvFOLAMsAAAYs5TSObUnpDY9 + p7uwz7l5fdM0nxrakEsz0m25jdfnHH4nteHf5xzbsC88uh7uu44e9cC8mbY7sQywAABgm9SLgYe3bXh6 + asOP1I34Sw22NJW18UP12HxFPUZfnNr0vd0wtruQ7Q9jYIFM0xDLAAsAAHZYKatfdWSwVcIP5xJ+IZX4 + urpZ/+jmzbs0ri4ou29pSvOOnMPL60XhC+ux9z2xxCellO7XH5YAR0zLEMsACwAAptT+/fvvG0fxW1Kb + RqkNP143778USnjtaln94NDmXjq2paWlW3Mb31OPm1emEl5S/73DadSktm3+sfdUAVsxDUMsAywAAJhB + 3cVE2zbf1LYh1o394bqxv6L2B01p3nJxufgzmzf+mts+mvPaX3Tvpqq//y9ObfOD3TdlppS+rh4jd+sP + F4DTttNDLAMsAACYQ6urq/dJKT02lricSvj+uvn/D6k0v9JdfDSleddSWfrC5osDTV2fzm18W/09e1X3 + e9e9PP3IFwOU+Iz6e/sNBw4cuEf/2w2wLXZyiGWABQAAC2hjY+OMeiHyoG7IlUbNd+YcD+RR/KF6gfDC + VJpfTiX+fndnz1pZe59h1/haXV39XIzxvfXX97qcw/+pv95X1l7U/dqnEva3bfjW7u4pwylgWu3UEMsA + CwAAOKG1tbX7l7L2mHrh8pT+rq7v6h5XqxcVzz8ygCnhF+vP30ol/nE3+Ioxvrv+uU8ce/ExL3Xvlgoh + fHytrP1d/ft9U/17f3X3CF83+Ku/Bi+u/5lL66/PJTnHg20b9rZt88T6a/eo7qKv/+UEmGk7McQywAIA + ACaqe5xx3759Dwj7wyP7Idju7k6j2tNqMZVQcgmH6s8fqBcp3fu8fiK14bJjurz+e907vr5YNyyq/52r + Tqb6v/uSY/+79f/jZ27/365//se6/888iv+i/vGhnOM/TyXlWOLq0b++5oI4iud3f+3dS/UPHjx4dv+3 + BbDQtnuIVc/fBlgAAAAAbM3y8vLdj9x5OzBwGncGWAAAAACcku0aYhlgAQAAAHDKtmOIZYAFAAAAwGmZ + 9BDLAAsAAACA0zbJIZYBFgAAAABjMakhlgEWAAAAAGMziSGWARYAAAAAYzXuIZYBFgAAAABjN84hlgEW + AAAAABMxriGWARYAAAAAEzOOIZYBFgAAAAATdbpDLAMsAAAAACbudIZYBlgAAAAAbItTHWIZYAEAAACw + bU5liGWABQAAAMC22uoQywALAAAAgG3XDbFybl41NLDanAEWAAAAADviwIED9ziZIZYBFgAAAAA75mSG + WAZYAAAAAOyoEw2xDLAAAAAA2HHHG2IZYAEAAAAwFe5siGWABQAAAMDUGBpiGWABAAAAMFU2D7EMsAAA + AACYOscOsQywAAAAAJhKtw+xDLAAAAAAmFo553vGEpf7fwkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCo/tE/+v/CrvwB3Ec8JQAAAABJRU5E + rkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAABAAAAAQACAYAAAB/HSuDAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAB0gSURBVHhe7dixcRxBEARByHCH5tB/O8g//cUeoghkRpQF + I9xefwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAf+Dz1S8le24DAAAAE8+P5h8le24DAAAA + EwaAbgYAAAAAZgwA3QwAAAAAzBgAuhkAAAAAmDEAdDMAAAAAMGMA6GYAAAAAYMYA0M0AAAAAwIwBoJsB + AAAAgBkDQDcDAAAAADMGgG4GAAAAAGYMAN0MAAAAAMwYALoZAAAAAJgxAHQzAAAAADBjAOhmAAAAAGDG + ANDNAAAAAMCMAaCbAQAAAIAZA0A3AwAAAAAzBoBuBgAAAABmDADdDAAAAADMGAC6GQAAAACYMQB0MwAA + AAAwYwDoZgAAAABgxgDQzQAAAADAjAGgmwEAAACAGQNANwMAAAAAMwaAbgYAAAAAZgwA3QwAAAAAzBgA + uhkAAAAAmDEAdDMAAAAAMGMA6GYAAAAAYMYA0M0AAAAAwIwBoJsBAAAAgBkDQDcDAAAAADMGgG4GAAAA + AGYMAN0MAAAAAMwYALoZAAAAAJgxAHQzAAAAADBjAOhmAAAAAGDGANDNAAAAAMCMAaCbAQAAAIAZA0A3 + AwAAAAAzBoBuBgAAAABmDADdDAAAAADMGAC6GQAAAACYMQB0MwAAAAAwYwDoZgAAAABgxgDQzQAAAADA + jAGgmwEAAACAGQNANwMAAAAAMwaAbgYAAAAAZgwA3QwAAAAAzBgAuhkAAAAAmDEAdDMAAAAAMGMA6GYA + AAAAYMYA0M0AAAAAwIwBoJsBAAAAgBkDQDcDAAAAADMGgG4GAAAAAGYMAN0MAAAAAMwYALoZAAAAAJgx + AHQzAAAAADBjAOhmAAAAAGDGANDNAAAAAMCMAaCbAQAAAIAZA0A3AwAAAAAzBoBuBgAAAABmDADdDAAA + AADMGAC6GQAAAACYMQB0MwAAAAAwYwDoZgAAAABgxgDQzQAAAADAjAGgmwEAAACAGQNANwMAAAAAMwaA + bgYAAAAAZgwA3QwAAAAAzBgAuhkAAAAAmDEAdDMAAAAAMGMA6GYAAAAAYMYA0M0AAAAAwIwBoJsBAAAA + gBkDQDcDAAAAADMGgG4GAAAAAGYMAN0MAAAAAMwYALoZAAAAAJgxAHQzAAAAADBjAOhmAAAAAGDGANDN + AAAAAMCMAaCbAQAAAIAZA0A3AwAAAAAzBoBuBgAAAABmDADdDAAAAADMGAC6GQAAAACYMQB0MwAAAAAw + YwDoZgAAAABgxgDQzQAAAADAjAGgmwEAAACAGQNANwMAAAAAMwaAbgYAAAAAZgwA3QwAAAAAzBgAuhkA + AAAAmDEAdDMAAAAAMGMA6GYAAAAAYMYA0M0AAAAAwIwBoJsBAAAAgBkDQDcDAAAAADMGgG4GAAAAAGYM + AN0MAAAAAMwYALoZAAAAAJgxAHQzAAAAADBjAOhmAAAAAGDGANDNAAAAAMCMAaCbAQAAAIAZA0A3AwAA + AAAzBoBuBgAAAABmDADdDAAAAADMGAC6GQAAAACYMQB0MwAAAAAwYwDoZgAAAABgxgDQzQAAAADAjAGg + mwEAAACAGQNANwMAAAAAMwaAbgYAAAAAZgwA3QwAAAAAzBgAuhkAAAAAmDEAdDMAAAAAMGMA6GYAAAAA + YMYA0M0AAAAAwIwBoJsBAAAAgBkDQDcDAAAAADMGgG4GAAAAAGYMAN0MAAAAAMwYALoZAAAAAJgxAHQz + AAAAADBjAOhmAAAAAGDGANDNAAAAAMCMAaCbAQAAAIAZA0A3AwAAAAAzBoBuBgAAAABmDADdDAAAAADM + GAC6GQAAAACYMQB0MwAAAAAwYwDoZgAAAABgxgDQzQAAAADAjAGgmwEAAACAGQNANwMAAAAAMwaAbgYA + AAAAZgwA3QwAAAAAzBgAuhkAAAAAmDEAdDMAAAAAMGMA6GYAAAAAYMYA0M0AAAAAwIwBoJsBAAAAgBkD + QDcDAAAAADMGgG4GAAAAAGYMAN0MAAAAAMwYALoZAAAAAJgxAHQzAAAAADBjAOhmAAAAAGDGANDNAAAA + AMCMAaCbAQAAAIAZA0A3AwAAAAAzBoBuBgAAAABmDADdDAAAAADMGAC6GQAAAACYMQB0MwAAAAAwYwDo + ZgAAAABgxgDQzQAAAADAjAGgmwEAAACAGQNANwMAAAAAMwaAbgYAAAAAZgwA3QwAAAAAzBgAuhkAAAAA + mDEAdDMAAAAAMGMA6GYAAAAAYMYA0M0AAAAAwIwBoJsBAAAAgBkDQDcDAAAAADMGgG4GAAAAAGYMAN0M + AAAAAMwYALoZAAAAAJgxAHQzAAAAADBjAOhmAAAAAGDGANDNAAAAAMCMAaCbAQAAAIAZA0A3AwAAAAAz + BoBuBgAAAABmDADdDAAAAADMGAC6GQAAAACYMQB0MwAAAAAwYwDoZgAAAABgxgDQzQAAAADAjAGgmwEA + AACAGQNANwMAAAAAMwaAbgYAAAAAZgwA3QwAAAAAzBgAuhkAAAAAmDEAdDMAAAAAMGMA6GYAAAAAYMYA + 0M0AAAAAwIwBoJsBAAAAgBkDQDcDAAAAADMGgG4GAAAAAGYMAN0MAAAAAMwYALoZAAAAAJgxAHQzAAAA + ADBjAOhmAAAAAGDGANDNAAAAAMCMAaCbAQAAAIAZA0A3AwAAAAAzBoBuBgAAAABmDADdDAAAAADMGAC6 + GQAAAACYMQB0MwAAAAAwYwDoZgAAAABgxgDQzQAAAADAjAGgmwEAAACAGQNANwMAAAAAMwaAbgYAAAAA + ZgwA3QwAAAAAzBgAuhkAAAAAmDEAdDMAAAAAMGMA6GYAAAAAYMYA0M0AAAAAwIwBoJsBAAAAgBkDQDcD + AAAAADMGgG4GAAAAAGYMAN0MAAAAAMwYALoZAAAAAJgxAHQzAAAAADBjAOhmAAAAAGDGANDNAAAAAMCM + AaCbAQAAAIAZA0A3AwAAAAAzBoBuBgAAAABmDADdDAAAAADMGAC6GQAAAACYMQB0MwAAAAAwYwDoZgAA + AABgxgDQzQAAAADAjAGgmwEAAACAGQNANwMAAAAAMwaAbgYAAAAAZgwA3QwAAAAAzBgAuhkAAAAAmDEA + dDMAAAAAMGMA6GYAAAAAYMYA0M0AAAAAwIwBoJsBAAAAgBkDQDcDAAAAADMGgG4GAAAAAGYMAN0MAAAA + AMwYALoZAAAAAJgxAHQzAAAAADBjAOhmAAAAAGDGANDNAAAAwNznq+ehKenn9fvVu59PfX3Pbd7dTNL3 + 73mbAcCJ50Pz7vEpSZKkf9/zNgOAEwYASZKkTgYAAM4YACRJkjoZAAA4YwCQJEnqZAAA4IwBQJIkqZMB + AIAzBgBJkqROBgAAzhgAJEmSOhkAADhjAJAkSepkAADgjAFAkiSpkwEAgDMGAEmSpE4GAADOGAAkSZI6 + GQAAOGMAkCRJ6mQAAOCMAUCSJKmTAQCAMwYASZKkTgYAAM4YACRJkjoZAAA4YwCQJEnqZAAA4IwBQJIk + qZMBAIAzBgBJkqROBgAAzhgAJEmSOhkAADhjAJAkSepkAADgjAFAkiSpkwEAgDMGAEmSpE4GAADOGAAk + SZI6GQAAOGMAkCRJ6mQAAOCMAUCSJKmTAQCAMwYASZKkTgYAAM4YACRJkjoZAAA4YwCQJEnqZAAA4IwB + QJIkqZMBAIAzBgBJkqROBgAAzhgAJEmSOhkAADhjAJAkSepkAADgjAFAkiSpkwEAgDMGAEmSpE4GAADO + GAAkSZI6GQAAOGMAkCRJ6mQAAOCMAUCSJKmTAQCAMwYASZKkTgYAAM4YACRJkjoZAAA4YwCQJEnqZAAA + 4IwBQJIkqZMBAIAzBgBJkqROBgAAzhgAJEmSOhkAADhjAJAkSepkAADgjAFAkiSpkwEAgDMGAEmSpE4G + AADOGAAkSZI6GQAAOGMAkCRJ6mQAAOCMAUCSJKmTAQCAMwYASZKkTgYAAM4YACRJkjoZAAA4YwCQJEnq + ZAAA4IwBQJIkqZMBAIAzBgBJkqROBgAAzhgAJEmSOhkAADhjAJAkSepkAADgjAFAkiSpkwEAgDMGAEmS + pE4GAADOGAAkSZI6GQAAOGMAkCRJ6mQAAOCMAUCSJKmTAQCAMwYASZKkTgYAAM4YACRJkjoZAAA4YwCQ + JEnqZAAA4IwBQJIkqZMBAIAzBgBJkqROBgAAzhgAJEmSOhkAADhjAJAkSepkAADgjAFAkiSpkwEAgDMG + AEmSpE4GAADOGAAkSZI6GQAAOGMAkCRJ6mQAAOCMAUCSJKmTAQCAMwYASZKkTgYAAM4YACRJkjoZAAA4 + YwCQJEnqZAAA4IwBQJIkqZMBAIAzBgBJkqROBgAAzhgAJEmSOhkAADhjAJAkSepkAADgjAFAkiSpkwEA + gDMGAEmSpE4GAADOGAAkSZI6GQAAOGMAkCRJ6mQAAOCMAUCSJKmTAQCAMwYASZKkTgYAAM4YACRJkjoZ + AAA4YwCQJEnqZAAA4IwBQJIkqZMBAIAzBgBJkqROBgAAzhgAJEmSOhkAADhjAJAkSepkAADgjAFAkiSp + kwEAgDMGAEmSpE4GAADOGAAkSZI6GQAAOGMAkCRJ6mQAAOCMAUCSJKmTAQCAMwYASZKkTgYAAM4YACRJ + kjoZAAA4YwCQJEnqZAAA4IwBQJIkqZMBAIAzBgBJkqROBgAAzny+ej40kn5ev1+9e3zq63tu8+5mkr5/ + z9sMAACmnofmu59PfX3PbQAAAGDCANDNAAAAAMCMAaCbAQAAAIAZA0A3AwAAAAAzBoBuBgAAAABmDADd + DAAAAADMGAC6GQAAAACYMQB0MwAAAAAwYwDoZgAAAABgxgDQzQAAAADAjAGgmwEAAACAGQNANwMAAAAA + MwaAbgYAAAAAZgwA3QwAAAAAzBgAuhkAAAAAmDEAdDMAAAAAMGMA6GYAAAAAYMYA0M0AAAAAwIwBoJsB + AAAAgBkDQDcDAAAAADMGgG4GAAAAAGYMAN0MAAAAAMwYALoZAAAAAJgxAHQzAAAAADBjAOhmAAAAAGDG + ANDNAAAAAMCMAaCbAQAAAIAZA0A3AwAAAAAzBoBuBgAAAABmDADdDAAAAADMGAC6GQAAAACYMQB0MwAA + AAAwYwDoZgAAAABgxgDQzQAAAADAjAGgmwEAAACAGQNANwMAAAAAMwaAbgYAAAAAZgwA3QwAAAAAzBgA + uhkAAAAAmDEAdDMAAAAAMGMA6GYAAAAAYMYA0M0AAAAAwIwBoJsBAAAAgBkDQDcDAAAAADMGgG4GAAAA + AGYMAN0MAAAAAMwYALoZAAAAAJgxAHQzAAAAADBjAOhmAAAAAGDGANDNAAAAAMCMAaCbAQAAAIAZA0A3 + AwAAAAAzBoBuBgAAAABmDADdDAAAAADMGAC6GQAAAACYMQB0MwAAAAAwYwDoZgAAAABgxgDQzQAAAADA + jAGgmwEAAACAGQNANwMAAAAAMwaAbgYAAAAAZgwA3QwAAAAAzBgAuhkAAAAAmDEAdDMAAAAAMGMA6GYA + AAAAYMYA0M0AAAAAwIwBoJsBAAAAgBkDQDcDAAAAADMGgG4GAAAAAGYMAN0MAAAAAMwYALoZAAAAAJgx + AHQzAAAAADBjAOhmAAAAAGDGANDNAAAAAMCMAaCbAQAAAIAZA0A3AwAAAAAzBoBuBgAAAABmDADdDAAA + AADMGAC6GQAAAACYMQB0MwAAAAAwYwDoZgAAAABgxgDQzQAAAADAjAGgmwEAAACAGQNANwMAAAAAMwaA + bgYAAAAAZgwA3QwAAAAAzBgAuhkAAAAAmDEAdDMAAAAAMGMA6GYAAAAAYMYA0M0AAAAAwIwBoJsBAAAA + gBkDQDcDAAAAADMGgG4GAAAAAGYMAN0MAAAAAMwYALoZAAAAAJgxAHQzAAAAADBjAOhmAAAAAGDGANDN + AAAAAMCMAaCbAQAAAIAZA0A3AwAAAAAzBoBuBgAAAABmDADdDAAAAADMGAC6GQAAAACYMQB0MwAAAAAw + YwDoZgAAAABgxgDQzQAAAADAjAGgmwEAAACAGQNANwMAAAAAMwaAbgYAAAAAZgwA3QwAAAAAzBgAuhkA + AAAAmDEAdDMAAAAAMGMA6GYAAAAAYMYA0M0AAAAAwIwBoJsBAAAAgBkDQDcDAAAAADMGgG4GAAAAAGYM + AN0MAAAAAMwYALoZAAAAAJgxAHQzAAAAADBjAOhmAAAAAGDGANDNAAAAAMCMAaCbAQAAAIAZA0A3AwAA + AAAzBoBuBgAAAABmDADdDAAAAADMGAC6GQAAAACYMQB0MwAAAAAwYwDoZgAAAABgxgDQzQAAAADAjAGg + mwEAAACAGQNANwMAAAAAMwaAbgYAAAAAZgwA3QwAAAAAzBgAuhkAAAAAmDEAdDMAAAAAMGMA6GYAAAAA + YMYA0M0AAAAAwIwBoJsBAAAAgBkDQDcDAAAAADMGgG4GAAAAAGYMAN0MAAAAAMwYALoZAAAAAJgxAHQz + AAAAADBjAOhmAAAAAGDGANDNAAAAAMCMAaCbAQAAAIAZA0A3AwAAAAAzBoBuBgAAAABmDADdDAAAAADM + GAC6GQAAAACYMQB0MwAAAAAwYwDoZgAAAABgxgDQzQAAAADAjAGgmwEAAACAGQNANwMAAAAAMwaAbgYA + AAAAZgwA3QwAAAAAzBgAuhkAAAAAmDEAdDMAAAAAMGMA6GYAAAAAYMYA0M0AAAAAwIwBoJsBAAAAgBkD + QDcDAAAAADMGgG4GAAAAAGYMAN0MAAAAAMwYALoZAAAAAJgxAHQzAAAAADBjAOhmAAAAAGDGANDNAAAA + AMCMAaCbAQAAAIAZA0A3AwAAAAAzBoBuBgAAAABmDADdDAAAAADMGAC6GQAAAACYMQB0MwAAAAAwYwDo + ZgAAAABgxgDQzQAAAADAjAGgmwEAAACAGQNANwMAAAAAMwaAbgYAAAAAZgwA3QwAAAAAzBgAuhkAAAAA + mDEAdDMAAAAAMGMA6GYAAAAAYMYA0M0AAAAAwIwBoJsBAAAAgBkDQDcDAAAAADMGgG4GAAAAAGYMAN0M + AAAAAMwYALoZAAAAAJgxAHQzAAAAADBjAOhmAAAAAGDGANDNAAAAAMCMAaCbAQAAAIAZA0A3AwAAAAAz + BoBuBgAAAABmDADdDAAAAADMGAC6GQAAAACYMQB0MwAAAAAwYwDoZgAAAABgxgDQzQAAAADAjAGgmwEA + AACAGQNANwMAAAAAMwaAbgYAAAAAZgwA3QwAAAAAzBgAuhkAAAAAmDEAdDMAAAAAMGMA6GYAAAAAYMYA + 0M0AAAAAwIwBoJsBAAAAgBkDQDcDAAAAADMGgG4GAAAAAGYMAN0MAAAAAMwYALoZAAAAAJgxAHQzAAAA + ADBjAOhmAAAAAGDGANDNAAAAAMCMAaCbAQAAAIAZA0A3AwAAAAAzBoBuBgAAAABmDADdDAAAAADMGAC6 + GQAAAACYMQB0MwAAAAAwYwDoZgAAAABgxgDQzQAAAADAjAGgmwEAAACAGQNANwMAAAAAMwaAbgYAAAAA + ZgwA3QwAAAAAzBgAuhkAAAAAmDEAdDMAAAAAMGMA6GYAAAAAYMYA0M0AAAAAwIwBoJsBAAAAgBkDQDcD + AAAAADMGgG4GAAAAAGYMAN0MAAAAAMwYALoZAAAAAJgxAHQzAAAAADBjAOhmAAAAAGDGANDNAAAAAMCM + AaCbAQAAAIAZA0A3AwAAAAAzBoBuBgAAAABmDADdDAAAAADMGAC6GQAAAACYMQB0MwAAAAAwYwDoZgAA + AABgxgDQzQAAAADAjAGgmwEAAACAGQNANwMAAAAAMwaAbgYAAAAAZgwA3QwAAAAAzBgAuhkAAAAAmPl8 + 9fxoqtdzGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI+/j4CyCW5wlnxoX+AAAAAElFTkSu + QmCC + + + + + iVBORw0KGgoAAAANSUhEUgAABAAAAAQACAYAAAB/HSuDAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAEZRSURBVHhe7d0JuGZZWd/tpRJjWj4ZBBnbBptBIM2oQosi + QYyICGgQCQIiEuOAgiCCAQRCAJFBEAxBg+KMiEOcAoQYZDCKyDwqWIgiMtnQsb+q8hxe8rydVdicXtU1 + rX3OWs++7+v6XUUidp+133Nw7T9VUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAmdFt9KQ + bT8bAAAA6GL7ovlJDdn2swEAAIAuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBu + DADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYA + MG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADj + ZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4G + AAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAA + AACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAA + ALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACg + GwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALox + AIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPA + uBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIyb + AQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkA + AAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAA + AIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA + 6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBu + DADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYA + MG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADj + ZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4G + AAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAA + AACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAA + ALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACg + GwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALox + AIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPA + uBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIyb + AQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkA + AAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAA + AIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA + 6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBu + DADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYA + MG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADj + ZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4G + AAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAA + AACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAA + ALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACg + GwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALox + AIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPA + uBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIyb + AQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkA + AAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAA + AIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA + 6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBu + DADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYA + MG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAADo7qxoe9GUtL6+NWq9fOrg2342rc9MUv62 + dzMAWMT2/9C0Lp+SJEna/7Z3MwBYhAFAkiRpnAwAACzGACBJkjROBgAAFmMAkCRJGicDAACLMQBIkiSN + kwEAgMUYACRJksbJAADAYgwAkiRJ42QAAGAxBgBJkqRxMgAAsBgDgCRJ0jgZAABYjAFAkiRpnAwAACzG + ACBJkjROBgAAFmMAkCRJGicDAACLMQBIkiSNkwEAgMUYACRJksbJAADAYgwAkiRJ42QAAGAxBgBJkqRx + MgAAsBgDgCRJ0jgZAABYjAFAkiRpnAwAACzGACBJkjROBgAAFmMAkCRJGicDAACLMQBIkiSNkwEAgMUY + ACRJksbJAADAYgwAkiRJ42QAAGAxBgBJkqRxMgAAsBgDgCRJ0jgZAABYjAFAkiRpnAwAACzGACBJkjRO + BgAAFmMAkCRJGicDAACLMQBIkiSNkwEAgMUYACRJksbJAADAYgwAkiRJ42QAAGAxBgBJkqRxMgAAsBgD + gCRJ0jgZAABYjAFAkiRpnAwAACzGACBJkjROBgAAFmMAkCRJGicDAACLMQBIkiSNkwEAgMUYACRJksbJ + AADAYgwAkiRJ42QAAGAxBgBJkqRxMgAAsBgDgCRJ0jgZAABYjAFAkiRpnAwAACzGACBJkjROBgAAFmMA + kCRJGicDAACLMQBIkiSNkwEAgMUYACRJksbJAADAYgwAkiRJ42QAAGAxBgBJkqRxMgAAsBgDgCRJ0jgZ + AABYjAFAkiRpnAwAACzGACBJkjROBgAAFmMAkCRJGicDAACLMQBIkiSNkwEAgMUYACRJksbJAADAYgwA + kiRJ42QAAGAxBgBJkqRxMgAAsBgDgCRJ0jgZAABYjAFAkiRpnAwAACzGACBJkjROBgAAFmMAkCRJGicD + AACLMQBIkiSNkwEAgMUYACRJksbJAADAYgwAkiRJ42QAAGAxBgBJkqRxMgAAsBgDgCRJ0jgZAABYjAFA + kiRpnAwAACzGACBJkjROBgAAFmMAkCRJGicDAACLMQBIkiSNkwEAgMUYACRJksbJAADAYgwAkiRJ42QA + AGAxBgBJkqRxMgAAsBgDgCRJ0jgZAABYjAFAkiRpnAwAACzGACBJkjROBgAAFmMAkCRJGicDAACLMQBI + kiSNkwEAgMUYACRJksbJAADAYgwAkiRJ42QAAGAxBgBJkqRxMgAAsBgDgCRJ0jgZAABYjAFAkiRpnAwA + ACzGACBJkjROBgAAFmMAkCRJGicDAACLMQBIkiSNkwEAgMUYACRJksbJAADAYgwAkiRJ42QAAGAxBgBJ + kqRxMgAAsBgDgCRJ0jgZAABYjAFAkiRpnAwAACzGACBJkjROBgAAFmMAkCRJGicDAACLMQBIkiSNkwEA + gMUYACRJksbJAADAYgwAkiRJ42QAAGAxBgBJkqRxMgAAsBgDgCRJ0jgZAABYjAFAkiRpnAwAACzGACBJ + kjROBgAAFmMAkCRJGicDAACLMQBIkiSNkwEAgMUYACRJksbJAADAYs6Ktv+HRtL6+taodfnUwbf9bFqf + maT8be9mAADQ1fai2Xr51MG3/WwAAACgCwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAA + AACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAA + ALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACg + GwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALox + AIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPA + uBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIyb + AQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkA + AAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAA + AIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA + 6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBu + DADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYA + MG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADj + ZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4G + AAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAA + AACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAA + ALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACg + GwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALox + AIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPA + uBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIyb + AQAAAIBuDADjZgAAAACgGwPAuBkAAAAA6MYAMG4GAAAAALoxAIybAQAAAIBuDADjZgAAAACgGwPAuBkA + AACAPOIt5/KbUq4R3TD+8c0vq/jnnBedE//4StFn1b8EZ6bLAHC56ErROdG/jG5+gm4YXTO6fNT66+ni + DAAAAMD44u3lcvGyfsvo2z5RypOjn4tetlvKG3dKOXS4lL8/VMon4p/3ydPtH0r5P/9Yyt/EX+9t8dd9 + Vfz1fzV6Zvw9vz+6Q/QF9cvh+E44AMRD/ORXRw+JnhW9KHp19Pbo/VF8Ds3P52SLz+6TH43i++GTb4xe + Gr0gelJ0v+gW0T+LWl9b8gwAAADAeOJl+5zoAfEC/kvxQvfmeHtpvuztd/9Yyvvja3pJ/OPHxdf3lfXL + 5Z9cagA4P3pM9PvR30Tb5zhCb41+JfrO6Nxo79edMAMAAAAwhnihPjterp8WL/xvireV5kvbaB0u5YL4 + ml8cX/td6zHW7uIB4E7RC6OP1Oc0Q2+Ltr8jIfEYYAAAAAAOVrw8nxsv0c+JN5Tmi9ks7ZbymjjLPeux + Vum/lfKw/9V4NrP109FNojhSpgwAAADAwYkX5ptt/wx/vJ00X8RmLM70mHq8VYlzP6z1PGbtQ9H2jy/E + 0bJkAAAAAA5GvDDe+EgpH4o3k+YL2Mx9opQn12Ouwnb0aD2H2dv+BxLeOoojZsgAAAAAHIx4SX5+vJU0 + X7wyFC/F165HTS3OesULS7lo7/mztP1vKfh/x5w+AwAAALD/4uX4uvFG0nzhytInSnlGPW5qcc7Ht86f + qZtFcdTZMwAAAAD7b1PKXeONpPmylaV4Mf6f9bipxTl/q3X+TN0niqPOngEAAADYf5tSHh1vJM2XrSwd + KeXD9bip7ZTyntb5M/VjURx19gwAAADA/vtEKf8x3kiaL1tZ+odS/k89bmr/WMrftM6fqWdGcdTZMwAA + AAD7zwCQhwFgmgwAAADA/jMA5GEAmCYDAAAAsP8MAHkYAKbJAAAAAOw/A0AeBoBpMgAAAAD7zwCQhwFg + mgwAAADA/jMA5GEAmCYDAAAAsP8MAHkYAKbJAAAAAOw/A0AeBoBpMgAAAAD7zwCQhwFgmgwAAAAjiRva + WdEVNqVcNbpm/OPrxK/Xj24c3Sz6kuj8U+w20ZfEX+vm8etNohtG58b/+wvj12vEr1eJrhj/+HPj18+s + XwosygCQhwFgmgwAAABLihvXleLF+quiB0Y/Ei89z41+LXrZbil/slPKO7eX54tK+fihUjbxz29ePvez + j5Xy/x8p5cPxdb03vsa3Rv87vt6XRi+Ofjp6UpzlIdG9459/8+hy9bhw0uL7yACQhAFgmgwAAAC9xYvx + t8TLzU/Fy/174sbVvExma7eUN8WZf3I7CkSfXx8FHJcBIA8DwDQZAAAAeti+9EaPiovwX8ctq3mBXFPx + cvfS+PWb6+OBSzEA5GEAmCYDAADAmYpb1SMPxftM/Nq8OK657R8f2JRyy/qo4FMMAHkYAKbJAAAAcCbi + JeaZcatqXhj1T21KuWd9ZHAxA0AeBoBpMgAAAJyuuE29IGpeFnXpNqV8VX10YABIxAAwTQYAAIDTES+z + 3xC3qeZFUe22fxygPj4wACRiAJgmAwAAwOmIl9m3xG2qeVHUZfbI+ghZOQNAHgaAaTIAAACcqk0pD4mb + VPOSqBMXz+9a9VGyYgaAPAwA02QAAAA4VbulvDluUs1Lok7cppQfrI+SFTMA5GEAmCYDAADAqYiX1zvF + Lap5QdTJtVvK6+vjZMUMAHkYAKbJAAAAcCriBvWiqHlB1Mm3KeX8+khZKQNAHgaAaTIAAACcrLg9XTFq + Xg51asXL37PqY2WlDAB5GACmyQAAAHCyNqU8MG5QzcuhTq14YXh/fayslAEgDwPANBkAAABOVrywvCRu + UM3LoU69TSlfVx8tK2QAyMMAME0GAACAkxEvq9eK21PzYqjTK14An18fLytkAMjDADBNBgAAgJOxKeXB + cXtqXgx12n2sPl5WyACQhwFgmgwAAAAnY7eUV8btqXkx1Om3KeUe9RGzMgaAPAwA02QAAAA4kXhJvX7c + nJqXQp1Z8RL4wvqYWRkDQB4GgGkyAAAAnMimlB+Om1PzUqgz61Apu/Hr5eujZkUMAHkYAKbJAAAAcCJx + a3pd1LwU6szblPJt9VGzIgaAPAwA02QAAAC4LPFyerO4NTUvhOpTvAj+Tn3crIgBIA8DwDQZAAAALku8 + pDwhbk3NC6H6tSnlavWRsxIGgDwMANNkAAAAuCw7pbwjbk3NC6H6tSnle+ojZyUMAHkYAKbJAAAAcDzx + Unp+3Jial0H1LV4G/6A+dlbCAJCHAWCaDAAAAMcTLyhPjxtT8zKoRfqi+uhZAQNAHgaAaTIAAAAcT1xq + /ypuTM3LoPq3KeWH6qNnBQwAeRgApskAAADQEjelO0bNi6CWabeUP6mPnxUwAORhAJgmAwAAQEu8nDw3 + bkvNi6CWa1PKefUjIDkDQB4GgGkyAAAAtBwp5cNxW2peBLVc8VL4+PoRkJwBIA8DwDQZAAAA9tqUcte4 + KTUvgVq2nVLeVj8GkjMA5GEAmCYDAADAXvFi8vNxU2peArV8m1JuUz8KEjMA5GEAmCYDAADAJcUN6XIX + lnJR/Nq8BGr54sXwafXjIDEDQB4GgGkyAAAAXNKmlHvFLal5AdT+FC8T760fB4kZAPIwAEyTAQAA4JLi + peTFcUtqXgC1r92xfiQkZQDIwwAwTQYAAIBj4nZ0hah5+dP+Fi+Hz60fC0kZAPIwAEyTAQAA4JhNKQ+I + G1Lz8qf97UgpH6kfC0kZAPIwAEyTAQAA4Jh4Ifn9uCE1L3/a/zal3K1+NCRkAMjDADBNBgAAgK142bxG + 3I6aFz8dTPGC+Av14yEhA0AeBoBpMgAAAGxtSvm+uB01L346mC4o5XD8+tn1IyIZA0AeBoBpMgAAAGzF + zegVUfPip4NrU8q960dEMgaAPAwA02QAAACIl8xz42bUvPTpYIuXxN+oHxPJGADyMABMkwEAAGBTyiPi + ZtS89Ongi8/nyvWjIhEDQB4GgGkyAAAA7Jbyp3Ezal76dPBtSvl39aMiEQNAHgaAaTIAAADrFi+X58Wt + qHnh0xjFi+JL68dFIgaAPAwA02QAAADWLV5CHh+3ouaFT+O0KeXs+pGRhAEgDwPANBkAAIB12ynlbXEr + al74NE6bUh5SPzKSMADkYQCYJgMAALBe8VJ5m7gRNS97GqvdUl5TPzaSMADkYQCYJgMAALBe8QLy1LgR + NS97GrIvrh8dCRgA8jAATJMBAABYr51SDsWNqHnZ03htSnl0/ehIwACQhwFgmgwAAMA6xcvkHeI21Lzo + acx2S3lj/fhIwACQhwFgmgwAAMA6xcvHf47bUPOip6FzgU3CAJCHAWCa/OsnALBOR0v5YNyGmhc9jVu8 + ND65foRMzgCQhwFgmgwAAMD6bEq5S9yEmpc8jd1OKX9RP0YmZwDIwwAwTQYAAGB94hb0gqh5ydP4bUq5 + Xf0omZgBIA8DwDQZAACAdYkb0GdtL+Xxa/OSp/GLF8dn14+TiRkA8jAATJMBAABYl00p94xbUPOCpzk6 + WsoH6sfJxAwAeRgApskAAACsS9yAXhQ1L3gzt1vKq1r//1nblHLn+pEyKQNAHgaAaTIAAADrES+N/9+h + +CVuQc0L3qzFy/+fxNm+p/U/y1q8PP5M/ViZlAEgDwPANBkAAID1iNvP/aPm5W7m4uX/IfHrlfb+/2fu + olIujF8/o360TMgAkIcBYJoMAADAesQLx+/GDah5uZu5TSlX255vbX8MIPrmiz9YpmQAyMMAME0GAABg + HbYvyXH7aV7sZi5e+l9bj7g949r+GMCv1qMzIQNAHgaAaTIAAADrEC/H3xu3n+bFbubiXD9Qj7g945Vb + /5ysHYp3yPj18vX4TMYAkIcBYJoMAADAOsTLxh/E7ad5sZu8q9cjXmy3lFc3/jmZu389OpMxAORhAJgm + AwAAkN+mlOvGzad5qZu5eNn/03rET8n6Ox2OV7xE/m49OpMxAORhAJgmAwAAkF+8FD88bj7NS93Mxbke + Wo/4KWv7YwC1T/tdEMzBAJCHAWCaDAAAQH7b/578uPk0L3UzFy/716xH/DRr+2MA8RweVI/ORAwAeRgA + pskAAADkFi+HN4lbT/NCN3Pxkv9n9YiXEmde1R8DiF5Rj85EDAB5GACmyQAAAOQWL8OPjVtP80I3c3Gu + H6xHvJT4n31+638nc3Hmc+vxmYQBIA8DwDQZAACA3HZLeUvcepoXupmLF95r1SM2rfCPATyiHp1JGADy + MABMkwEAAMgrXgq/LG48zcvczMXL/evrEY8rzv6g1v9u1uKZXOq/EYGxGQDyMABMkwEAAMgrXjCeEjee + 5mVu5uLl/uH1iMcV/5w1/jGAm9bjMwEDQB4GgGkyAAAAee2U8p648TQvczMXL7rXrke8TLulvKb1v5+1 + 7QtlPToTMADkYQCYJgMAAJBT3HRuHzUvcjMXL/VvqEc8obX9MYCdUt5ej84EDAB5GACmyQAAAOQULxfP + jttO8yI3c/FS/0P1iCe00j8GcH49PoMzAORhAJgmAwAAkNPRUj4Qt53mRW7mTva3/x+zwj8G8PR6dAZn + AMjDADBNBgAAIJ94Sb5z3HSal7iZi5f5N9YjnrR4Fqv6YwDxIvK+enQGZwDIwwAwTQYAACCfeLH4mbjp + NC9xMxcv86f833Uf/3tX2fvXyV48p6+px2dgBoA8DADTZAAAAPK5qJSPx02neYmbuVP97f/H7JbyR62/ + XtbixfJ59egMzACQhwFgmgwAAEAu8ZJ8j7jlNC9wMxcv8W+qRzxl8Uy+r/XXzNrhUj5aj87ADAB5GACm + yQAAAOQSLxUvjFtO8wI3eY+sRzxl8b+7uj8GEN29Hp9BGQDyMABMkwEAAMhjU8rnHiplN245zQvczMXZ + zq7HPC0r/GMAv1iPzqAMAHkYAKbJAAAA5BEvyfeLG07z8jZz8fL+5nrE07a2PwbwkVKOxJn/eT0+AzIA + 5GEAmCYDAACQR7xQ/HbccJqXt5mLF9kfrkc8bfHXuGrrr525OPO31uMzIANAHgaAaTIAAAA5ZH7BjbOd + 0W//P2aFfwzgN+vRGZABIA8DwDQZAACAHOIl+bvjdtO8uM1cvLS/tR7xjMUz+v7W3yNzcebPr8dnMAaA + PAwA02QAAAByiJeJl8ftpnlxm7l4gX1UPeIZi7/WGv8YwL+vx2cwBoA8DADTZAAAAOYXL3nnxM2meWlL + 0BfWY3axW8ofN/4eaYuXzP9Rj85gDAB5GACmyQAAAMxvU8rD4mbTvLTN3E4pb6tH7Cae1er+GEDUdUSh + DwNAHgaAaTIAAADzy/ofbhcv64+uR+wm/ppr/GMAD63HZyAGgDwMANNkAAAA5hYvdzeKW03zwpagRf6d + 691S/qTx90rbdiCqR2cgBoA8DADTZAAAAOa2KeUxcatpXthmbqeUt9cjdhfP7MGtv2fmtkNRPT6DMADk + YQCYJgMAADC33VLeFLea5oVt5rbDRj1id/HX/oLW3zNzSz5PTo8BIA8DwDQZAACAecVt5lZR87I2e/HC + ek495iJ2S3lt6++bte1QVI/OIAwAeRgApskAAADMK14gnhw3muZlbeZ2SnlHPeJiNuv8YwBfWo/PAAwA + eRgApskAAADMK16U/yJuNM3L2szFi+qP1CMuJv4eq/tjANGP1uMzAANAHgaAaTIAAABzihfY28VtpnlR + m70426K//f+Y+Hu9bu/fO3M7pbynHp0BGADyMABMkwEAAJhTvDw8K24zzYvazMVL6jvrERe3WeEfA4hu + X4/PATMA5GEAmCYDAAAwp7hwvj9uM82L2szFS/lj6xEXF3+vq7W+hszFS+dz6vE5YAaAPAwA02QAAADm + Ey+ud4qbTPOSlqDr1GPui91S/qzxNaTtaCl/V4/OATMA5GEAmCYDAAAwn3hx+K9xk2le0mZup5R31SPu + m00pD2l9LZmLM399PT4HyACQhwFgmgwAAMB8DpdyQdxkmpe0mYsXosfXI+6blf4xgJ+tx+cAGQDyMABM + kwEAAJhLvLB+U9ximhe0BO3rb/8/ZreU1ze+lrRtX8ri18+sx+eAGADyMABMkwEAAJhLvDT8ctximhe0 + mdsp5S/qEffdSv8YwD3r8TkgBoA8DADTZAAAAOYRL23/4oOlHI1bTPOCNnPbl6F6zH23xj8GEL2oHp8D + YgDIwwAwTQYAAGAe8aJ6n7jBNC9nsxdnu2495oHYLeWNra8ra4fi2yme+efV43MADAB5GACmyQAAAMwj + Xhh+K24wzcvZzO2U8u56xAMTL8M/0PraMhdnfkA9PgfAAJCHAWCaDAAAwBziZe3z4/bSvJjNXrwIPaEe + 88DE13H1vV9X9uK5/349PgfAAJCHAWCaDAAAwBzi5vKdUfNiNnsH/dv/j9kt5U2try9z8eyvUY/PPjMA + 5GEAmCYDAAAwh3hZeFncXpoXs5nbKeU99YgHbqV/DOD76vHZZwaAPAwA02QAAADGFy9pZ8fNpXkpm714 + CfpP9ZgHLr6e1f0xgN1S/rAen31mAMjDADBNBgAAYHzJ/53pL6rHHEK8EL+l8TWmLr6/rlePzz4yAOSx + hgHgPaX8chx1+wI9c2dFAABji5fSV7cuZLO3U8pf1iMOY41/DCB6ZD0++8gAkMcaBoD4fn1mPS4AAEuJ + F9Ibti5jGYoL5RPrMYcRz/sara81ea+rx2cfGQDyMAAAANBFvJA+qnUZS9JQv/3/mN1S3tr4WrN383p8 + 9okBIA8DAAAAXcTL6Btal7HZ2ynlUD3icDalPLT1NWcuLvfD/IcxroUBIA8DAAAAZyxeRG/RuohlKC6T + T6rHHM4a/xjATinvqMdnnxgA8jAAAABwxuLC9cTWRSxD8ZJ9bj3mkOKF+G2trztz8Zncth6ffWAAyMMA + AADAGYuX0He1LmKzF5fl99YjDmulfwzgx+vx2QcGgDwMAAAAnJG4cH3F3gtYon60HnNYa/xjAPES89f1 + +OwDA0AeBgAAAM7I9t+NbV3CMjT6b/8/Zvvn4ltff+bis/nX9fgszACQhwEAAIAzsv13Y1uXsNmLc72v + HnF48TL8sNYZMheX/J+qx2dhBoA8DAAAAJy27b8L27qAZSgukU+pxxxefA7XbJ0hc4dL+ft6fBZmAMjD + AAAAwGmLi9ZPtS5gGYqX6uvVY05hp5R3ts6RufiMvrEenwUZAPIwAAAAcNoOl/LR1gVs9rZ/rKEecRor + /WMAv1SPz4IMAHkYAAAAOC1x0br73otXluIC+WP1mNNY4x8D+GApR+Pc/6I+AhZiAMjDAAAAwGmJS9Yv + ti5fGZrtt/8fs1PKu1rnyVx8Vvetx2chBoA8DAAAAJyyuGR99gWlHN578crQ9oJcjzmdeBn+wdaZMheX + /f9Wj89CDAB5rGQAeFY9LgAAPcSL5r1bF68MxeVxut/+f0x8LtdqnWkFXaU+AhZgAMjDAAAAwCmLC9Zv + tC5eGYqX6OvXY05pp5S/aJ0rc/GZfVc9PgswAORhAAAA4JTEBetKey9cWYrL8fvrMacVL8MPb50tc3Hh + f3k9PgswAORhAAAA4JTEC+YDW5euDMXF8an1mNNa6x8DiHOfUx8BnRkA8jAAAABwSuJy9ZLWpStD8RI5 + 9W//P2anlHe3zpe5+OweVo9PZwaAPAwAAACctMz/7vLRUv62HnN68Tk9onXGzO2W8r/r8enMAJCHAQAA + gJMWL5YPbl24MhSXxul/+/8xmYeayyrOfeP6COjIAJCHAQAAgJO2W8orWxeuDMXL4w3qMVPYKeU9rXNm + Lj7Dx9bj05EBIA8DAAAAJyVerq7fumxl6GgpH6jHTCPO9ci958zebilvqcenIwNAHgYAAABOyqaUH25d + tjIUF8an1WOmEZ/XtVtnzV6c+8vqI6ATA0AeBgAAAE5KXKxet/eilaV4aUz12/+P2SnlUOu8mYvL/4/V + 49OJASAPAwAAACcUL8g3a120MnS0lA/WY6aT+XdtHK+dUv6yHp9ODAB5GAAAADihuFA9oXXRylCcLd1v + /z9mxX8M4F/VR0AHBoA8DAAAAJzQTinvaF20MpT1t/8fExf+97bOnbl4AfjJenw6MADkYQAAAOAyxQvy + +a1LVoaOlPKhesy04vN7VOvsmcv8xzoOggEgDwMAAACXKS5TT29dsjK0PVs9ZlqbUs5unT17ce671EfA + GTIA5GEAAADgMsWF8a9al6wMxUviDesxU8v8GV5GL6jH5wwZAPIwAAAAcFxxmbrj3stVlo6U8uF6zPQ2 + pTy69QwyF29z/xC/Xq4+As6AASAPAwAAAMcVF6nnti5YGYqzpf/t/8es+I8B3Ks+As6AASAPAwAAAMe1 + /XfJWxesDK3lt/8fExf/v249h8zFi8CL6/E5AwaAPAwAAAA0xQvyXVuXqwwdKeUj9ZirEZ/nY1rPYgVd + oT4CTpMBIA8DAAAATXGJ+vnW5SpDcbZn1GOuxor/GMB31EfAaTIA5GEAAADgUuISdbkLS7lo78UqUV9c + j7oqa7j87y1eBv57PT6nyQCQhwEAAIBL2ZRyr9bFKkOHS/loPebqxOf62NYzyV6c+5r1EXAaDAB5GAAA + ALiUuEC9uHWxylCcbXW//f+YOP8X7n0ea2hTyvfXR8BpMADkYQAAAODTxMvS57UuVYla5W//PyZeAN7f + eCap2y3llfX4nAYDQB4GAAAAPs2mlAe0LlUZOlzK39djrlY8h8ftfS5rKL6vr18fAafIAJCHAQAAgE8T + l6ffb12qMhRn+/F6zNWK57DWPwbww/URcIoMAHkYAAAA+JR4SbpG60KVpTjfjepRV+1oKR9oPZ/M7Zby + Z/X4nCIDQB4GAAAAPiVekL+vdaFK0sfqMVcvLsiPbzyf9MX39y3qI+AUGADyMAAAAPApcXl6xd7LVJbi + Urj63/5/TLwIn9N6RtmL74En1kfAKTAA5GEAAADgYvFSeG7rMpUlv/3/0x0t5e9azylzO6W8qx6fU2AA + yMMAAADAxeIF+RGty1SGLirl4/WYVHFJfkLrWa2gr6iPgJNkAMjDAAAAwMV2S3lt6zKVobgQPrMek2rF + fwzA98IpMgDkYQAAAGD7Mnhe6yKVpTjfjetRuYSjpXyw9bwyt30BqsfnJBkA8jAAAACwveCn/U+Fv6iU + C+sx2SM+9//UembZ25TytfURcBIMAHkYAAAAKDulvK11kcpQXAb9lu/jiOdznb3Paw3F98RP10fASTAA + 5GEAAABYuU0pt25dorLkt/9ftiOlfLj13DJ3uJQL6vE5CQaAPAwAAAArF5elp7YuURlay6X+TMTn/8TW + s8veppR/Ux8BJ2AAyMMAAACwcjulHGpdojLkInhi8ZzW+scAfqU+Ak7AAJCHAQAAYMU2pdyhdYHKUpzv + JvWoXIYjpXyk9fwy9/54F4pfz6qPgMtgAMjDAAAAsGJxUfrJ1gUqQ3Gbjzs9JyO+D57ceobZ25Ryv/oI + uAwGgDwMAAAAK5b5vwfeJfDkxYvwdVvPMHvxPfLb9RFwGQwAeRgAAABWKl767tK6PGXJb/8/NYdL+Wjr + OWYvvk+uWh8Bx2EAyMMAAACwUnFJ+tnW5SlDF5ZyUT0mJyme24/ufY5raFPKd9dHwHEYAPIwAAAArFBc + kj5ze+Hde3HKkgvgqYsX4XNbzzJ78b3yP+sj4DgMAHkYAAAAVihe9u7ZujhlKc73L+tROQWHS7mg9Tyz + F98v162PgAYDQB4GAACAFYpL0ov2XpqydMHF77Gcjrg4P6X1TLO3KeUH6yOgwQCQhwEAAGBl4oJ0+UNx + p997acpSXP5+oh6VUxQvwtdrPdPs7Zbyx/UR0GAAyMMAAACwMnFBuv/eC1Om/Pb/MxPP8GN7n+ka8n1z + fAaAPAwAAAArE5ej321dmjL0kVKO1GNymuL746mtZ7uCHlcfAXsYAPIwAAAArMimlKu1LkxZiouf3/5/ + huJ75PqtZ5u93VLeWh8BexgA8jAAAACsSLzcfU/rwpSlON959aicgYtKubD1fLMX3z+3ro+ASzAA5GEA + AABYkbgY/UHrwpQhv/2/n/g+eVrrGWcvzv3U+gi4BANAHgYAAICV2JRy3dZlKUtx6fu9OOM3qksPaj3j + 7O2Ucqj+uHAJBoA8DAAAACsRL3UPb12WJP1T8XNyh/ojQ2UAyMMAAACwEtv/rvPWZUnSPxUvD/+5/shQ + GQDyMAAAAKzAppSbtC5Kkj69I6V8qP7YUBkA8jAAAACswKaUx7YuSpIuXfy83LX+6BAMAHkYAAAAVmC3 + lDe3LkqSLl28QPxc/dEhGADyMAAAACS3KeVLW5ckSe0uLOWi+PWf1R+h1TMA5GEAAABILi5DT2ldkiQd + v00p/7b+CK2eASAPAwAAQHI7pbyndUmSdPziJeLX64/Q6hkA8jAAAAAkFpeh2++9HEk66a5Uf5RWzQCQ + hwEAACCxuAg9u3VBknTiNqU8sP4orZoBIA8DAABAYkdL+UDrgiTpxMWLxEvqj9KqGQDyMAAAACS1KeXO + rcuRpJMvfo6uXX+kVssAkIcBAAAgqbgEPb91OZJ08m1KeUj9kVotA0AeBgAAgKQuKuXjrcuRpJNvt5RX + 1R+p1TIA5GEAAABIaFPKPVoXI0mnXvw83bD+aK2SASAPAwAAQEJxAfqV1sVI0qm3KeVR9UdrlQwAeRgA + AACSiQvQWYdK2dl7KZJ0eu2W8ob647VKBoA8DAAAAMlsSrlf61Ik6fSLn6tb1h+x1TEA5GEAAABIJi4/ + v926FEk6/eLn6kn1R2x1DAB5GAAAABKJy89V9l6GJJ15O6X8ef0xWx0DQB4GAACARDalfFfrQiTpzIuf + r9vVH7VVMQDkYQAAAEgkLj4vb12IJJ15a32xMADkYQAAAEhiU8o5rcuQpD7Fy9P764/bqhgA8jAAAAAk + sSnloa3LkKR+xc/Z19UfudUwAORhAAAASGK3lD9qXYYk9SteLp5ff+RWwwCQhwEAACCBTSk3al2EJHXv + Y/XHbjUMAHkYAAAAEtiU8pjWRUhS/+Ln7R71R28VDAB5GAAAABLYLeWNrYuQpP7FC8YL64/eKhgA8jAA + AABMLi48t9p7AZK0XIdK2d2U8rn1RzA9A0AeBgAAgMnFZefJrUuQpOXalPJt9UcwPQNAHgYAAIDJ7ZTy + 561LkKTlipeM36k/gukZAPIwAAAATGxTyle2LkCSli9+/q5WfxRTMwDkYQAAAJjY9qLTugBJWr5NKd9b + fxRTMwDkYQAAAJhYXObe37oASVq+eNH4g/qjmJoBIA8DAADApDal3Kl1+ZG0r31R/ZFMywCQhwEAAGBS + ccn56dblR9L+tSnlh+qPZFoGgDwMAAAAkzpcygWty4+k/Wu3lNfWH8m0DAB5GAAAACa0KeWbWhcfSftf + /DyeV380UzIA5GEAAACYUFxwfql18ZG0/8XP4+Prj2ZKBoA8DAAAAJOJC87nfLCUo3svPZIOpp1S3lZ/ + PFMyAORhAAAAmMymlPu0Lj2SDq74uTy//oimYwDIwwAAADCZuNz8ZuvSI+ngip/Lp9cf0XQMAHkYAAAA + JrIp5cqtC4+kgy1erN5bf0zTMQDkYQAAAJhIXG6+c+9lR9Iw3bH+qKZiAMjDAAAAMJG42LysdeGRdPDF + z+d/qT+qqRgA8jAAAABMYlPK2a3LTsZ2S3mD5qz1ea6lI6V8pP64pmIAyMMAAAAwiU0pD2lddrIVb1Dx + HsWsDpfy0dbnupbi5/Ru9VGkYQDIwwAAADCJ3VJe3brsZCsubz9Xj8yE4vN7TutzXUtx/l+ojyINA0Ae + BgAAgAlsSrlh66KTsTjrneuxmVB8fl/e+lzX0gWlHI5fP7s+jhQMAHkYAAAAJhAvVf+hddHJ1qGLj8rs + tn8WvvX5rqX4Jr53fRQpGADyWMkA8Mx6XACAOe2W8vrWRSdbcXH7lXpkJhaf47Nbn+9aivP/Rn0UKRgA + 8jAAAAAMblPKLVqXnKTdvR6bicX37PmNz3ZVxTO4cn0c0zMA5GEAAAAYXFxmnti65GSsHpkEjpTyob2f + 78r6zvoopmcAyMMAAAAwuJ1S3tm65GQrLm2/Xo9MAvF5/kTrc15Lcf6X1UcxPQNAHgYAAICBbUq5beuC + k7E46z3rsUkgPs/btD7nNRXP4Oz6OKZmAMjDAAAAMLC4yPx464KTtM+qxyaJo6X8XeNzXk2bUn6gPoqp + GQDyMAAAAAwsLmvva11wshUXtt+tRyaR+Fyf1fq819JuKa+pj2JqBoA8DAAAAIPalPI1rctNxuKs96nH + JhF/DODivrg+jmkZAPIwAAAADCouMc9rXW6SdlY9NskcLeVvG5/3atqU8uj6KKZlAMjDAAAAMKjDpXy0 + dbnJVlzW0vynpXNp28t463NfS7ulvLE+imkZAPIwAAAADGhTyt1aF5uMxVm/ox6bhOLzvXXrc19Zt6qP + Y0oGgDwMAAAAA4oLzC+0LjZJu1I9Nkmt4aXjBP1ofRRTMgDkYQAAABhMXGA++4JSDu+91CTtFfXYJBYX + 8jX911leqp1S3l0fxZQMAHkYAAAABrMp5d6tS03G4qzfXY9NYvE5f1nr819T8Qy+qj6O6RgA8jAAAAAM + Ji4vv9661CTt6vXYJBcvHu9rfP6rKX6un10fxXQMAHkYAAAABhKXlyvuvcxkbbeUP6rHZgXiUv6M1vfB + Wjpaygfqo5iOASAPAwAAwEA2pTywdaHJWJz1wfXYrEB83l/a+j5YU/EM7lwfx1QMAHkYAAAABhIXl//e + utBkLF6GzqnHZiXi5eO9re+FtRQ/3z9TH8VUDAB5GAAAAAYRL8TXbF1mMrZbyp/VY7MicTF/euv7YS1d + VMqF8etn1McxDQNAHgYAAIBBbEr5/tZlJmNx1ofXY7Mi8bl/Sev7YWV9c30c0zAA5GEAAAAYxG4pr2xd + ZjIWL4I3qMdmZXZK+cvW98RaipeTX62PYhoGgDwMAAAAA4gX4uu3LjIZ2y3lLfXYrFBczp/W+r5YS4fi + EcSvl6+PYwoGgDwMAAAAA4hLyyP3XmKytinl0fXYrFB8D9xq7/fE2oqfgW+vj2MKBoA8DAAAAAOIS8vr + 9l5ishYvP+fVY7NSO6W8u/W9sZbiBeX36qOYggEgDwMAAMABixfim7UuMRmLF7931WOzYnFBf2rr+2Nl + Xb0+juEZAPIwAAAAHLA1XK6PtT1rPTYrtinllq3vjzUVz+BB9XEMzwCQhwEAAOCA7ZTy9tYlJmPx0vMl + 9disXHzf/3nre2RFvaI+iuEZAPIwAAAAHKB4IT6/dYHJWFw831uPDduXyqe0vk/WVPz8n1sfx9AMAHkY + AAAADlBcVJ7eusBkbPvCV48N2/HrFq3vkzUVz+AR9XEMzQCQhwEAAOAAbf9d8dYFJmPxsnPbemy42E4p + 72x9r6yl3VL+tD6KoRkA8jAAAAAckHgh/urW5SVjR0v523ps+JS4qD+59f2ypuJfB25aH8ewDAB5GAAA + AA5IXFKe27q8ZMyFjJb43rj53u+VtbV9ua6PY1gGgDwMAAAAB+RIKR9qXV4ytinlDvXY8GnW9N+C0SrO + /476KIZlAMjDAAAAcADihfgbWheXjB0p5SP12HApcVl/Yuv7Zk3Fvx58eX0cQzIA5GEAAAA4AHFB+bnW + xSVjcdbn1mPDpcTL781a3zdrKn5GnlEfx5AMAHkYAAAA9llcUC53YSkX7b20ZC1e8O5Ujw5Nu6W8tfW9 + s5bipex99VEMyQCQhwEAAGCfxQvxt7QuLRm7qJQL67HhuOLC/oTW98+ain9d+Jr6OIZjAMjDAAAAsM/i + cvJrrUtLxuKsP1OPDccVL783bX3/rKn4WXlefRzDMQDkYQAAANhH8aLzea0LS9bivHerR4fLtFvKm1vf + Q2vpcCkfrY9iOAaAPAwAAAD7KF6IH9C6sGTsg6UcjV8/ox4dLlN8rzzukt8/K+3u9XEMxQCQhwEAAGAf + xcXk91oXlozFWX+pHhtOyB8DuPhn5hfr4xiKASAPAwAAwD6JF5yrtS4rWYvz3rMeHU7KbilvbH0vraiP + 1UcxFANAHgYAAIB9Ei/E3926rCTuc+rR4aTEz8iPNL6PVlU8g+H+2wAMAHkYAAAA9klcSl7euqxkLM76 + 4npsOGnx8nte6/tpTcXPzjPq4xiGASAPAwAAwD6IS8lV9l5SMhcvcvetR4dTslvK61vfU2tpp5R31Ecx + DANAHgYAAIB9EC/E925dVBJ3hXp0OCXxs/LoxvfTqopncIP6OIZgAMjDAAAAsA/iUvKCvZeUrMXl63fq + seGUxcvvTVrfV2sqnsH31scxBANAHgYAAIB9cLSUv21dVDIWLy8PrMeG0xLfR6/b+321puIF5jfroxiC + ASAPAwAAwMLihfj6rUtK1uK8X1CPDqclvof+Q+t7ay1dVMrH66MYggEgDwMAAMDC4mXmvq1LSsbi4vWy + emw4bfEzc6PW99eaimdw2/o4DpwBIA8DAADAwuIy8pzWJSVj8dIy1J9dZl67pby29T22lra/C6I+igNn + AMjDAAAAsLB4kXlV65KSsXhpObseG85IfD89cu/315qKl5hh/sM0DQB5GAAAABa2/fO8rUtKtnZL+cN6 + ZDhjm1Ju2Po+W0vxovZX9VEcOANAHgYAAIAFxUvM1VoXlIzFWR9ajw1d7Jbyx63vtbUUP1NXrY/iQBkA + 8jAAAAAsKC7w57UuKBmLs167Hhu6iO+pH2p9r62lOP/16qM4UAaAPAwAAAALigv8rVsXlGzFhesl9cjQ + TXxvXWfv99qain/9uFl9FAcqvpb0/3kMR0v5QD1uajulvLN1/kzF/z16Uj0uAMD+igv82a0LSsLuX48M + XcVl/sWN77dVFP/6cYP6GA5UfB13bn19mYrvs5fW46YW5/y11vkzFd+v96rHBQDYf0dK+VDrkpKl3VJe + WY8K3cVl/i6t77uVdPn6GA5UfAbXanxtqYoX4yfU46YWn2X6P1YTZ7xRPS4AwP6Li+XzWpeULMVl62vq + UWER8TP0W63vvczFmf9HPf4Q4ut5auvrzNDhUi6IX4cYW/bDP5by13ufQZbi+/S/1GMCAByMeEG+4aFS + dluXldmLs31vPSYsJr7Pbtr6/stcnPnf1uMPIb6mK8bL1cv3fp1JWtUfYYrvrW/J+H+Tdkt5TZzNfxgt + AHDw4lLyXa0Ly6zF5XETZ/Lyz76J77c7bf+T2lvfj9na/rvt9djDia/t+a2vecbqvxN++3q0VYmfp1vv + lPLuvc9k1uL78pfj18+oxwMAOHhx4fqGuHC9Y+/FZbbiovWcOIt/l4V9F99/t4rvv9/c+z2ZqfjZemg9 + 7rDi69x+Dv9179c+S7ulvDae87fX46xaPIf7xPN4des5zVB8H/58nOH8ehwAgPHEZeVBcXF5xd6LzMjF + BfGP4+t+VHTjegw4MPE9eZ34XnxsfF/+6d7v1RnbKeUv49fHxZmuVY84hfh6vyC6R7yE/UR8Fm/Ye65R + OlLKh+Nr/PX4Wh8c3aJ++VxCPJebRtv/2/Si7X8l4t5nOErxffaW+Cx/Mr7Wb4muUb98AIDxxeVle3m+ + a/SouNC8MC42r4oXgXfFJedjey89S/bBUo7Ghe+D8fd/a3wdL41+NvqP8XX9u/if3zF+/dz6JcNw4vvz + qvF9evv49Xvi+/bp0a/G9/Ifbf/7zrcvMheUcviS3+8H1UWlXBhf03u2X1t8jb8YPSG+5vtG161HmV6c + 5crRl0cPiPP9WPQ7cea3bz+H7b/OtJ5Lrw6X8vfx93p3PN8/jL/v8+JreGh05+jc+uVxCuK5XTf6uu1z + jOf5U/FcX7n9/t0+59bz79VHSjmy/X7Zft/E3/e3t99H8TV8R3Tb+J9fpX55AAC5xEXns6IrxqXn7OjG + 0S2j20RfGX11dKdoOx78m+he0X3jn3//vcX//7fGr98cv94t+rr4x7ePbhX/+Abx69Wjs+rfEtKK7/d/ + Hm0Ht+tFN4u+NLpt9K+ir43uEn1jdM9o+zNzqZ+l41X/+XePX/91/PoV8estou3P7PXi//2F8evV4tfP + qV/KqsVzOCuexzXi1y+OX28d3S7+8XZk/Prom6Ltv5bdL3pg9O+jb4/uHd0j2v7r3dfGP3879pwfnRf/ + +AujK9S/PPsonvv2/z6dE21/58D59XPZ/ixtP6ft57X93Laf3/Zz3H6e2891+/luP+evj3/+9nO/XXTr + +Mfb74ft94X/ewQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAKeX/Ass96gO8Jt3/AAAAAElFTkSuQmCC + + + + 17, 17 + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAABYhSURBVHhe7d1bqL1bWcfxbZ5Sy02SaRBFgXTRyVMRopai + 0pGi0vTCi4KiA6TYRV1kbioPXZjtSDYZEm3FCy224QHTSioj0yyKbjIqwjAx1OicO3c9A4Pdw3/s9ay1 + /u9a8x3P+/nA9150jOnv/8655rwFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA3XhY9PjoudFLol+KXh/dFb2rUS+M6Guc + 19/aQY+J9uDF0eweXHd3RA+MgB0Yl/GZ0cuj90Z3R/9zgMawoa9PRLP/3a+7J0R78MZo9p/vFP16ZATA + CT0xuj36aDS7pN0zAHozALI9DYCREQAn8ORoPJqcXcojZQD0ZgBkexsAo7dGD46AK/b10Z9Es4t4xAyA + 3gyAbI8DYORJAFyhR0d3RvdEswt41AyA3gyAbK8DYORJAFyBb48+Hs0u3dEzAHozALI9D4CRJwGwkQdE + r4j8q/++MwB6MwCyvQ+AkScBcJNujX43ml0w3ZsB0JsBkK0wAEaeBMAljff7/zSaXSzlDIDeDIBslQEw + 8iQALujzo7+KZhdKN2YA9GYAZCsNgJEnAXBOD4/8id/FMgB6MwCy1QbAyJMAKDwo8p7/xTMAejMAshUH + wMiTADjD+Drf2cXR2RkAvRkA2aoDYORJAEx8S+RP/S6XAdCbAZCtPABGRgD8P+MT/77k5/IZAL0ZANnq + A2Dk7QD4P+M3+meXROfLAOjNAMg6DICRJwEc3lMij/5vLgOgNwMg6zIARkYAh3W/6APR7GLo/BkAvRkA + WacBMPJ2AIf0TdHsQuhiGQC9GQBZtwEw8iSAw/n9aHYZdLEMgN4MgKzjABgZARzGE6PZJdDFMwB6MwCy + rgNg5O0ADsGX/myXAdCbAZB1HgAjTwJobfzG/0ei2eHXxTMAejMAsu4DYGQE0NYzo9mh1+UyAHozALIj + DICRtwNo6eXR7MDrchkAvRkA2VEGwMiTANr5o2h22HW5DIDeDIDsSANgZATQxsOiu6PZQdflMgB6MwCy + ow2AkbcDaOHx0eyA6/IZAL0ZANkRB8DIkwCW97xodrh1+QyA3gyA7KgDYGQEsLTbotnB1uUzAHozALIj + D4CRtwNY1h3R7FDr8hkAvRkA2dEHwMiTAJbkt/+3zwDozQDIDIBPZwSwnDdHs8Osy2cA9GYAZAbAvRkB + LOWd0ewg6/IZAL0ZAJkBkPOZAJbxrmh2iHX5DIDeDIDMALgxTwJYggGwfQZAbwZAZgDMMwLYPQNg+wyA + 3gyAzAC474wAds0A2D4DoDcDIDMAzs4IYLcMgO0zAHozADIDoM4IYJcMgO0zAHozADID4HwZAeyOAbB9 + BkBvBkBmAJw/I4BdMQC2zwDozQDIDICLZQSwGwbA9hkAvRkAmQFw8YwAdsEA2D4DoDcDIDMALpcRwMkZ + ANtnAPRmAGQGwOUzAjgpA2D7DIDeDIDMALi5jABOxgDYPgOgNwMgMwBuPiOAkzAAts8A6M0AyAyAbTIC + uHYGwPYZAL0ZAJkBsF1GANfKANg+A6A3AyAzALbNCODaGADbZwD0ZgBkBsD2GQFcCwNg+wyA3gyAzAC4 + mowArpwBsH0GQG8GQGYAXF1GAFfKANg+A6A3AyAzAK42I4ArYwBsnwHQmwGQGQBXnxHAlTAAts8A6M0A + yAyA68kIYHMGwPYZAL0ZAJkBcH0ZAWzKANg+A6A3AyAzAK43I4DNGADbZwD0ZgBkBsD1ZwSwCQNg+wyA + 3gyAzAA4TUYAN80A2D4DoDcDIDMATpcRwE0xALbPAOjNAMgMgNNmBHBpBsD2GQC9GQCZAXD6jAAuxQDY + PgOgNwMgMwD2kRHAhRkA22cA9GYAZAbAfjICuBADYPsMgN4MgMwA2FdGAOdmAGyfAdCbAZAZAPvLCOBc + DIDtMwB6MwAyA2Cf3RHBmQyA7TMAejMAMgNgn43XdjiTAbB9BkBvBkBmAOwzA4CSAbB9BkBvBkBmAOwz + A4CSAbB9BkBvBkBmAOwzA4CSAbB9BkBvBkBmAOwzA4CSAbB9BkBvBkBmAOwzA4CSAbB9BkBvBkBmAOwz + A4CSAbB9BkBvBkBmAOwzA4CSAbB9BkBvBkBmAOwzA4CSAbB9BkBvBkBmAOwzA4CSAbB9BkBvBkBmAOwz + A4CSAbB9BkBvBkBmAOwzA4CSAbB9BkBvBkBmAOwzA4CSAbB9BkBvBkBmAOwzA4CSAbB9BkBvBkBmAOwz + A4CSAbB9BkBvBkBmAOwzA4CSAbB9BkBvr4pes4O+MNoDA2CfGQCUDIDtMwA4EgNgnxkAlAyA7TMAOBID + YJ8ZAJQMgO0zADgSA2CfGQCUDIDtMwA4EgNgnxkAlAyA7TMAOBIDYJ8ZAJQMgO0zADgSA2CfGQCUDIDt + MwA4EgNgnxkAlAyA7TMAOBIDYJ8ZAJQMgO0zADgSA2CfGQCUDIDtMwA4EgNgnxkAlAyA7TMAOBIDYJ8Z + AJQMgO0zADgSA2CfGQCUDIDtMwA4EgNgnxkAlAyA7TMAOBIDYJ8ZAJQMgO0zADgSA2CfGQCUDIDtMwA4 + EgNgnxkAlAyA7XtNBEfxpmh2D3TaDABKBsD2vS6Co3h7NLsHOm0GACUDYPveFsFRvDea3QOdNgOAkgGw + fR+M4Cg+Fs3ugU6bAUDJANi+/45ujaC7L4pmd0CnzwCgZABcTd8WQXffG83Ov06fAUDJALiaXh9Bd78Z + zc6/Tp8BQMkAuJr+LfrcCLr64mi83TU7/zp9BgAlA+DqemkEXY0vvJqde+0jA4CSAXB1/Xs0/pUE3Xx5 + 9Mlodu61jwwASgbA1Tb++/2MCLp4UPT+aHbetZ8MAEoGwNV3WwRdvDqanXPtKwOAkgFw9d0TfV8Eq/vx + aHbGtb8MAEoGwPU0RsCPRrCi+0Uvi2ZnW/vMAKBkAFxvb4geHsEqHhmN37eYnWftNwOAkgFw/X04en50 + /wj2anzY7wcj3/W/ZgYAJQPgdI0fDXph9KgI9uILoh+L/i6anVutkQFAyQA4fZ+KPhD9YvTD0bOjZ0jX + 0LOicd5eEN0R/Xk0Pq8yO6daKwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZ + AJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZ + AJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZ + AJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZ + AJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZ + AJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZ + AJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZ + AJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZ + AJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZ + AJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZ + AJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZAJLULwOAkgEgSf0yACgZ + AKfpnugvojdEPxl9d/S10VdEXxJ9jrRQ48yOszvO8DjL40yPsz3O+Oz86+ozACgZANfXx6NfjsYL5KMi + OIJx1p8bvTb6RDS7G9o+A4CSAXC1fSp6a/Rd0YMjOLLPjJ4dvS0aT8Fmd0bbZABQMgCupvF//G+JHh8B + N/qy6M7o7mh2h3RzGQCUDIDte3v0mAiofWn0jmh2l3T5DABKBsB2fSj6jgi4uPE22d9Hs7uli2cAUDIA + tuk3okdEwOXdGr0pmt0xXSwDgJIBcHN9MnpBdL8IuHnjLr0oGndrdud0vgwASgbA5fvX6BsjYHvPiP45 + mt091RkAlAyAyzX+pv9JEXB1vjr6aDS7gzo7A4CSAXDx/in6qgi4eo+Nxp2b3UXddwYAJQPgYv1H9NQI + uD5fF427N7uTmmcAUDIAzt/45rLvjIDr95zItweePwOAkgFw/l4ZAadzezS7m7oxA4CSAXC+3hc9KAJO + 54HRH0azO6qcAUDJAKj7z8hX+8I+jK8O/q9odld1bwYAJQOg7rYI2I+XRrO7qnszACgZAGf319FDImA/ + Hhr9bTS7s/p0BgAlA+Dsnh8B+/M90ezO6tMZAJQMgPvub6IHRMD+jA8Eegpw3xkAlAyA++4HImC/fiia + 3V0ZAJyDATBv/NDPZ0XAfj0s+pdodoePngFAyQCY9ysRsH+vi2Z3+OgZAJQMgHlPj4D9e1Y0u8NHzwCg + ZADc2Pip3/tHwP6ND+r6tcAbMwAoGQA3dlcErOMt0ewuHzkDgJIBcGM/EgHreFE0u8tHzgCgZADc2BMj + YB1fE83u8pEzACgZALnxe+P+/A/W8vBo3N3ZnT5qBgAlAyD3oQhYz4ej2Z0+agYAJQMg99sRsJ53R7M7 + fdQMAEoGQO6NEbCeX4tmd/qoGQCUDIDcayNgPePbO2d3+qgZAJQMgNztEbCeX4hmd/qoGQCUDIDcz0bA + esbdnd3po2YAUDIAcq+IgPWMuzu700fNAKBkAOQMAFiTAZAzACgZADkDANZkAOQMAEoGQM4AgDUZADkD + gJIBkDMAYE0GQM4AoGQA5AwAWJMBkDMAKBkAOQMA1mQA5AwASgZAzgCANRkAOQOAkgGQMwBgTQZAzgCg + ZADkDABYkwGQMwAoGQA5AwDWZADkDABKBkDOAIA1GQA5A4CSAZAzAGBNBkDOAKBkAOQMAFiTAZAzACgZ + ADkDANZkAOQMAEoGQM4AgDUZADkDgJIBkDMAYE0GQM4AoGQA5AwAWJMBkDMAKBkAOQMA1mQA5AwASgZA + zgCANRkAOQOAkgGQMwBgTQZAzgCgZADkDABYkwGQMwAoGQA5AwDWZADkDABKBkDOAIA1GQA5A4CSAZAz + AGBNBkDOAKBkAOQMAFiTAZAzACgZADkDANZkAOQMAEoGQM4AgDUZADkDgJIBkDMAYE0GQM4AoGQA5AwA + WJMBkDMAKBkAOQMA1mQA5AwASgZAzgCANRkAOQOAkgGQMwBgTQZAzgCgZADkDABYkwGQMwAoGQA5AwDW + ZADkDABKBkDOAIA1GQA5A4CSAZAzAGBNBkDOAKBkAOQMAFiTAZAzACgZADkDANZkAOQMAEoGQM4AgDUZ + ADkDgJIBkDMAYE0GQM4AoGQA5AwAWJMBkDMAKBkAOQMA1mQA5AwASgZAzgCANRkAOQOAkgGQMwBgTQZA + zgCgZADkDABYkwGQMwAoGQA5AwDWZADkDABKBkDOAIA1GQA5A4CSAZAzAGBNBkDOAKBkAOQMAFiTAZAz + ACgZADkDANZkAOQMAEoGQM4AgDUZADkDgJIBkDMAYE0GQM4AoGQA5AwAWJMBkDMAKBkAOQMA1mQA5AwA + SgZAzgCANRkAOQOAkgGQMwBgTQZAzgCgZADkDABYkwGQMwAoGQA5AwDWZADkDABKBkDOAIA1GQA5A4CS + AZAzAGBNBkDOAKBkAOQMAFiTAZAzACgZADkDANZkAOQMAEoGQM4AgDUZADkDgJIBkDMAYE0GQM4AoGQA + 5AwAWJMBkDMAKBkAOQMA1mQA5AwASgZAzgCANRkAOQOAkgGQMwBgTQZAzgCgZADkDABYkwGQMwAoGQA5 + AwDWZADkDABKBkDOAIA1GQA5A4CSAZAzAGBNBkDOAKBkAOQMAFiTAZAzACgZADkDANZkAOQMAEoGQM4A + gDUZADkDgJIBkDMAYE0GQM4AoGQA5AwAWJMBkDMAKBkAOQMA1mQA5AwASgZAzgCANRkAOQOAkgGQMwBg + TQZAzgCgZADkDABYkwGQMwAoGQA5AwDWZADkDABKBkDOAIA1GQA5A4CSAZAzAGBNBkDOAKBkAOQMAFiT + AZAzACgZADkDANZkAOQMAEoGQM4AgDUZADkDgJIBkDMAYE0GQM4AoGQA5AwAWJMBkDMAKBkAOQMA1mQA + 5AwASgZAzgCANRkAOQOAkgGQMwBgTQZAzgCgZADkDABYkwGQMwAoGQA5AwDWZADkDABKBkDOAIA1GQA5 + A4CSAZAzAGBNBkDOAKBkAOQMAFiTAZAzACgZADkDANZkAOQMAEoGQM4AgDUZADkDgJIBkDMAYE0GQM4A + oPTOaHZ4jto7ou+XtFzj7s7u9FEbr+1wpjdHs8MjSVq3uyI40+uj2eGRJK3bnRGc6Y5odngkSev26gjO + 9JJodngkSev24gjO9LxodngkSev2nAjO9LhodngkSev2lRGc6aHR3dHsAEmS1uuT0UMiKL03mh0iSdJ6 + vSeCc3lZNDtEkqT1+qkIzuUZ0ewQSZLW62kRnMsDoo9Es4MkSVqn8Vo+XtPh3H4+mh0mSdI6vTKCC3lC + NDtMkqR1emwEF/Z70exASZL237sjuJRviGaHSpK0/8YHuuHS3h/NDpYkab+N73OBm/Lk6J5odsAkSftr + vGY/NYKb9qvR7JBJkvbXayPYxOdFH4tmB02StJ/+MXpkBJv55shbAZK038Zr9LdFsLnxhRKzQydJOn2v + iOBKPDD6nWh28CRJp+tdka/85Up9dvSBaHYAJUnX359Ft0Zw5R4dfTCaHURJ0vX1l9H4oDZcm0dFngRI + 0un648j/+XMSD498JkCSrr/xnv94SxZOZnzo5LboU9HskEqStmv8qd/t0fhQNuzCt0a+LEiSrq7xJT/j + O1lgdx4RjWXqaYAkbdf4V/+dkff72b2nRO+LZgdZknT+xq/6PSmCpYxfEnxLNDvUkqT77j3ReGsVlva4 + 6FXRR6LZQZck3XLLP0Q/Fz02glbGXww8PfqZ6A+iu6PZJZCkIzReA8e/9H86elp0/wgO4SHRWLrPiV4c + 3RG9LrorGn/jKkkdGq9p47VtvMb9RDRe88Zr33gNBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4ORuueV/AYiSMnnnZW4G + AAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAACCgSURBVHhe7d13vG1nXefxJBCSUAXpAgGlKVIUKTbKAEpV + adKHIiCgIKIDKDhIU4qA0kRABQUElN5kYBiaUqSMgKBU6YbeQ0KSme+D0pJfknt/d7d1nvf79fr8wzln + 77Wee1nPL/fstfdBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAALvmsHS5dJf02PQEafIekK6Xzp0A9pxxcXtOOib9P0llH0zXTwB7ws3SZ1N1wZN0 + 0p6WzpoAFuveqbrASTrl3p/OlAAW51LJP/lL/Z6UABbl0PS2VF3UJO1710kAi3GDVF3MJO1fb0oAi/GQ + VF3MJO1fX0+nTQCL8MpUXcwk7X+XTgCL8PlUXcgk7X+3SQCLUF3EJPW6ewJYhOoiJqmXAQBYjOoiJqmX + AQBYjOoiJqmXAQBYjOoiJqmXAQBYjOoiJqmXAQBYjOoiJqmXAQBYjOoiJqmXAQBYjOoiJqmXAQBYjOoi + 1ul16eLSArt9qv5OdzIAAItRXcQ6/X2CJbpmqv5OdzIAAItRXcQ6GQBYKgMAMKXqItbJAMBSGQCAKVUX + sU4GAJbKAABMqbqIdTIAsFQGAGBK1UWskwGApTIAAFOqLmKdDAAslQEAmFJ1EetkAGCpDADAlKqLWCcD + AEtlAACmVF3EOhkAWCoDADCl6iLWyQDAUhkAgClVF7FOBgCWygAATKm6iHUyALBUBgBgStVFrJMBgKUy + AABTqi5inQwALJUBAJhSdRHrZABgqQwAwJSqi1gnAwBLZQAAplRdxDoZAFgqAwAwpeoi1skAwFIZAIAp + VRexTgYAlsoAAEypuoh1MgCwVAYAYErVRayTAYClMgAAU6ouYp0MACyVAQCYUnUR62QAYKkMAMCUqotY + JwMAS2UAAKZUXcQ6GQBYKgMAMKXqItbJAMBSGQCAKVUXsU4GAJbKAABMqbqIdTIAsFQGAGBK1UWskwGA + pTIAAFOqLmKdDAAslQEAmFJ1EetkAGCpDADAlKqLWCcDAEtlAACmVF3EOhkAWCoDADCl6iLWyQDAUhkA + gClVF7FOBgCWygAATKm6iHUyALBUBgBgStVFrJMBgKUyAABTqi5inQwALJUBAJhSdRHrZABgqQwAwJSq + i1gnAwBLZQAAplRdxDoZAFgqAwAwpeoi1skAwFIZAIApVRexTgYAlsoAAEypuoh1MgCwVAYAYErVRayT + AYClMgAAU6ouYp0MACyVAQCYUnUR62QAYKkMAMCUqotYJwMAS7XKAeA9afx/QVLdS9Ij083TRdLBiS2p + LmKdxh8sLNEqBwBJ+9e/pismtqD6A+lkAGCpDADSdjsuPTQdltig6g+jkwGApTIASLvRMxMbVP0hdDIA + sFQGAGl3unFiQ6o/gE4GAJbKACDtTp9O50xsQPUH0MkAwFIZAKTd6h6JDagWv5MBgKUyAEi71TMSG1At + ficDAEtlAJB2q/clNqBa/E4GAJbqGqn6Oy1pO52QzpRYs2rxOxkAWKrzp+rvtKTtde7EmlUL38kAwJKN + Vx5Xf68lbScDwAZUC9/JAMCSjb+/1d9rSdvJALAB1cJ3MgCwZHdO1d9rSdvpXIk1qxa+kwGAJRufSPaq + VP3dlrT5/AvABlQL38kAwNIdmb6Yqr/fkjabAWADqoXvZABgLxi3BH4yVX/HJW0uA8AGVAvfyQDAXnG2 + NN6JrPp7LmkzGQA2oFr4TgYA9porp/ulF6f/SNXfe0nryYsAN6Ba+E4GAPa6w9Lhkk62Z6dqf+jkXwA2 + oFr4TgYAgLk9M1X7QycDwAZUC9/JAAAwNwPAwlQL38kAADA3A8DCVAvfyQAAMDcDwMJUC9/JAAAwNwPA + wlQL38kAADA3A8DCVAvfyQAAMDcDwMJUC9/JAAAwNwPAwlQL38kAADA3A8DCVAvfyQAAMDcDwMJUC9/J + AAAwNwPAwlQL38kAADA3A8DCVAvfyQAAMDcDwMJUC9/JAAAwNwPAwlQL38kAADA3A8DCVAvfyQAAMDcD + wMJUC9/JAAAwNwPAwlQL38kAADA3A8DCVAvfyQAAMDcDwMJUC9/JAAAwNwPAwlQL38kAADA3A8DCVAvf + yQAAMDcDwMJUC9/JAAAwNwPAwlQL38kAADA3A8DCVAvfyQAAMDcDwMJUC9/JAAAwNwPAwlQL38kAADA3 + A8DCVAvfyQAAMDcDwMJUC9/JAAAwNwPAwlQL38kAADA3A8DCVAvfyQAAMDcDwMJUC9/JAAAwNwPAwlQL + 38kAADA3A8DCVAvfyQAAMDcDwMJUC9/JAAAwNwPAwlQL38kAADA3A8DCVAvfyQAAMDcDwMJUC9/JAAAw + NwPAwlQL38kAADA3A8DCVAvfyQAAMDcDwMJUC9/JAAAwNwPAwlQL38kAADA3A8DCVAvfyQAAMDcDwMJU + C9/JAAAwNwPAwlQL38kAADA3A8DCVAvfyQAAMDcDwMJUC9/JAAAwNwPAwlQL38kAADA3A8DCVAvfyQAA + MDcDwMJUC9/JAAAwNwPAwlQL38kAADA3A8DCVAvfyQAAMDcDwMJUC9/JAAAwNwPAwlQL38kAADA3A8DC + VAvfyQAAMDcDwMJUC9/JAAAwNwPAwlQL38kA0HfedPl0RUlacK9I1f7Q6dqpeg6depdL50uHpFNULXwn + A8C+OzjdMP1D+kqq1lOSpAPp2PSSdP1UDgPVD3UyAOyby6R3pWoNJUlaR+M/OC+cvkf1jZ0MAKfuSukL + qVo/SZLW2fgX5/Hr5m+rvqmTAeCU/Wg6OlVrJ0nSJjoqXSh9U/UNnQwAp2yVL46RJKnbC9I3VV/sZAA4 + eddL1ZpJkrSNLpvKL3QyAJy8V6VqzSRJ2kZ/lMovdDIA1MarLk9I1ZpJkrSN/imVX+hkAKg9JFXrJUnS + tvpcKr/QyQBwUqdNn0zVekmStK0+lcovdDIAnNR496VqrSRJ2mbvTeUXOhkATuqlqVorSZK22ZNT+YVO + BoDvdf50fKrWSpKkbXbTVH6hkwHge90vVeskSdI2G29Jf0Qqv9jJAPAd41OXPpyqdZIkaZs9Nn1T9cVO + BoDvuFaq1kiSpG03PpX2m6ovdjIAfMdzUrVGkiRts2++AdC3VN/QyQDwn86Vjk3VGkmStM3umL6t+oZO + BoD/dK9UrU+3N6TflyRN17hVr9oXun0lnSl9W/VNnQwA/2m8uUK1Pt2ulgCYz4NStS90+/P0Papv6mQA + OOigq6Rqbbp9IB2cAJjLadLHU7U3dLti+h7VN3UyABx00NNTtTbdficBMJ/rpWpf6PaudBLVN3aafQA4 + Wzo6VWvT6RvpPAmA+bwwVXtDt99IJ1F9Y6fZB4C7pWpduj0/ATCf86bjUrU3dPp6Gv+RehLVN3eafQB4 + Z6rWpdt1EgDzuU+q9oVuz0il6ps7zTwAjBdWVGvS7aNpvAAEgLmMF35/MFV7Q7erplL1zZ1mHgBWfa/m + AxIA87lGqvaFbu9LJ3s3WfUDnWYdAMabKow3V6jWpNP4COEjEwDzeVaq9oZu904nq/qBTrMOAONtFav1 + 6Db7aykAZnX2dEyq9oZO426yc6eTVf1Qp1k3rjenaj263SgBMJ/fStW+0O256RRVP9RpxgHg0qlai25H + pUMTAPN5T6r2hm7XTqeo+qFOMw4Aj03VWnR7WAJgPj+Tqn2h20fSIekUVT/YabYB4Ij0+VStRbeLJgDm + 89RU7QvdxqcJnqrqBzvNNgDcKlXr0O01CYD5nCV9LVV7Q6dxN9kF0qmqfrjTbAPAa1O1Dt1umQCYz11S + tS90e1naJ9UPd5ppALhYqtag2/hVwuEJgPm8PVV7Q7cbpH1S/XCnmQaAh6dqDbo9JgEwn8umal/otl93 + k1UP0GmWAeB06VOpWoNul0oAzOcJqdoXuj007bPqATrNMgDcOFXn3+1NCYD5nCF9KVV7Q7eLpH1WPUCn + WQaAl6fq/LvdIQEwn9umal/o9uq0X6oH6TTDAHDBdEKqzr/Tl9MZEwDz+cdU7Q3dbpH2S/UgnWYYAB6Y + qnPv9qQEwHwukap9odvn0n7fTVY9UKe9PgCcJn0sVefe7QoJgPk8KlX7QrdHp/1WPVCnvT4AXDdV593t + HQmA+RyWPpuqvaHbJdN+qx6o014fAF6QqvPudtcEwHxulqp9odsbU0v1YJ328gBw3nRcqs6709HprAmA + +fzvVO0N3W6fWqoH67SXB4DfTdU5d3taAmA+P5R25m6y6gE77dUB4OD0gVSdc7crJwDm84ep2he6PTG1 + VQ/Yaa8OAFdP1fl2e28CYD6nTZ9M1d7Q7fKprXrATnt1AHhmqs632z0TAPP5pVTtC93+OR2Q6kE77cUB + 4OzpmFSdb6dj0zkTAPN5Sar2hm6/ng5I9aCd9uIAcI9UnWu3v0sAzOd86fhU7Q2dVnI3WfXAnfbiAPDu + VJ1rt2smAObzP1O1L3T763TAqgfutNcGgJ9O1Xl2+3A6JAEwl3Ht//dU7Q3drpQOWPXAnfbaAPCUVJ1n + tzH9ATCfn0/VvtDt39JKVA/eaS8NAGdJX03VeXYav/cZv/8BYD7j9V/V3tDtf6SVqB68014aAO6cqnPs + Nl75CcB8xp1f4w6wam/otNK7yaon6LSXBoC3peocu417PwGYz/iv9Wpf6LbSu8mqJ+i0VwaAy6bq/LqN + d30a7/4EwHzG7+urvaHbeD3BylRP0GmvDAB/mqrz6zbe9xmA+YzPfan2hW7jToKV3k1WPUmnvTAAnD59 + MVXn12l84tP45CcA5jPu1a/2hm4rv5usepJOe2EAuG2qzq3b+MxnAOYz3qVvvFtftTd0Oi6t/G6y6ok6 + 7YUB4B9TdW7dbpYAmM9dU7UvdHtxWrnqiTotfQC4RKrOq9tn0mEJgPmMT+qr9oZua7mbrHqiTksfAB6V + qvPqNh4PgPmMz+iv9oVua7ubrHqyTkseAMZ/qY//Yq/Oq9v4FwUA5vOkVO0L3f4grUX1ZJ2WPADcNFXn + 1G28lgCA+ZwxfTlVe0Ontd5NVj1hpyUPAOPV+tU5dRt3EwAwn9unal/otta7yaon7LTUAWBMVmPCqs6p + 03gfgTMkAObzplTtDd3Gv1CvTfWEnZY6AIzfrVTn0+0JCYD5XDJV+0K3td9NVj1ppyUOAONVlePVldX5 + dBufJQDAfB6dqn2h29rvJquetNMSB4BxX2V1Lt3GpwgCMJ/D0+dStTd0W/vdZNWTdlriADA+p786l253 + SQDM5xap2he6beRusuqJOy1tABjvqXx8qs6l01fTWRIA83l1qvaGbhu5m6x64k5LGwDGpypV59HtKQmA + +Vw0VftCt43dTVY9eaclDQDj85TH5ypX59HtpxMA83loqvaFbhu7m6x68k5LGgB+PlXn0O3dCYD5HJqO + StXe0G1jd5NVT95pSQPA36XqHLrdIwEwnxumal/ottG7yaoD6LSUAeCc6dhUnUOnY9LZEwDzeVmq9oZu + G72brDqATksZAO6ZquPv9qwEwHwukFZ5N9nX0kbvJqsOotNSBoB/S9Xxd7t6AmA+90/VvtBt43eTVQfR + aQkDwJVTdezdPpgOTgDMZdxN9pFU7Q3dfiZtVHUQnZYwADwtVcfe7T4JgPlcO1X7Qrf3pI2rDqTTrg8A + Z01Hp+rYOx2XzpsAmM/zUrU3dNvK3WTVgXTa9QHgrqk67m4vSADM59zpG6naGzpt7W6y6mA67foA8I5U + HXe36yYA5nPvVO0L3bZ2N1l1MJ12eQC4fKqOudvH0mkSAHMZL/x+X6r2hm5bu5usOphOuzwAPClVx9zt + gQmA+Vw1VftCt63eTVYdUKddHQDOmL6cqmPudEK6YAJgPs9I1d7Qbat3k1UH1GlXB4A7pOp4u/2vBMB8 + zpa+nqq9odPW7yarDqrTrg4Ab0rV8Xa7cQJgPr+Rqn2h2wvTVlUH1WkXB4BLpepYu30qnS4BMJ93pWpv + 6Ha9tFXVQXXaxQHgMak61m5/lACYz0+mal/o9vG09bvJqgPrtGsDwOHp86k61m4XSwDM589TtS90e1Da + uurAOu3aAHDLVB1nt9cmAOZzpvSVVO0NncbdZBdKW1cdXKddGwBek6rj7HarBMB8fjVV+0K3nbmbrDq4 + Trs0AFw0VcfYbfwq4YgEwHz+KVV7Q7dfTjuhOrhOuzQAPCxVx9jtsQmA+VwmVftCt0+nnbmbrDrATrsy + AByajkrVMXa7dAJgPo9L1b7QbafuJqsOsNOuDAA3StXxdRv/9APAfMavfr+Qqr2h28XTzqgOsNOuDADj + OKrj63bHBMB8/nuq9oVur0s7pTrITrswAByZjk/V8XUat32M2z8AmM/YsKu9odsYKHZKdZCddmEAeECq + jq3beOMHAOYz/qm+2he6jV8l7NzdZNWBdtr2ADDeUvGjqTq2bldMAMxnvFiv2he6jRcT7pzqQDttewC4 + TqqOq9s7EwDzGbfpjQ9/q/aGbj+Wdk51oJ22PQA8P1XH1e1uCYD5jI99r/aFbm9JO6k62E7bHADOk76R + quPqdHQ6WwJgPuOtequ9odt4K+GdVB1sp20OAL+TqmPq9vQEwHwumMaH9VR7Q6dxN9mZ006qDrjTtgaA + g9P7U3VM3a6SAJjPA1O1L3T7i7SzqgPutK0B4GqpOp5u70tjqABgLuNuso+lam/o9pNpZ1UH3GlbA8Df + pOp4ut0rATCf66VqX+j2rrTTqoPutI0B4PvT11N1PJ3GCwnPlQCYzwtStTd0u3vaadVBd9rGAPCbqTqW + bs9JAMznvOm4VO0NncZ/nI7/SN1p1YF32sYA8C+pOpZu10oAzOc+qdoXuo1fT++86sA7bXoA+KlUHUe3 + D6dDEgBzGS/8/mCq9oZu/y3tvOrAO216APjLVB1Ht/slAOZz9VTtC93GremLuJusOvhOmxwAxpsqfDVV + x9FpfITw+RMA83lWqvaGbuPN6RahOvhOmxwA7pSqY+j20gTAfM6ejknV3tBp3E127rQI1Ql02uQA8NZU + HUO36ycA5nOPVO0L3Z6XFqM6gU6bGgB+PFXP3+0/0mkTAPN5d6r2hm7jo+kXozqBTpsaAB6fqufv9pAE + wHx+OlX7QrePpvF2wotRnUSnTQwAp09fTNXzdxqf+HThBMB8npKqvaHb/dOiVCfRaRMDwG1S9dzdXpUA + mM9Z0qrvJjsyLUp1Ip02MQC8PlXP3e3mCYD53DlV+0K3Tf0afKWqE+m07pP/kVQ9b7fPpsMSAPN5W6r2 + hm43TItTnUindQ8Aj0zV83b74wTAfC6bqn2h21Hp0LQ41cl0WucAcLr0mVQ9b7cfTQDM509TtS90e1ha + pOpkOq1zALhJqp6z2xsSAPNZ9d1ko4umRapOptM6B4BXpuo5u90uATCf26ZqX+j2mrRY1Ql1WtcA8INp + 3K9fPWenL6UzJADm8w+p2hu63TItVnVCndY1ADw4Vc/X7c8SAPNZ9d1kn0uHp8WqTqrTOgaA8R79n0jV + 83X7iQTAfB6Vqn2h22PSolUn1WkdA8Avpuq5ur09ATCf8b4vq76b7FJp0aqT6rSOAeBFqXqubr+WAJjP + TVO1L3R7U1q86sQ6rXoA+IF0XKqeq9PX0vclAOaz6rvJ7pAWrzqxTqseAH4vVc/T7akJgPn8UFrl3WRf + TmdMi1edXKdVDgCHpH9P1fN0+9kEwHz+IFX7QrcnpT2hOrlOqxwAfi5Vz9HtPQmA+azjbrIrpD2hOrlO + qxwA/jZVz9HttxIA81n13WTvSHtGdYKdVjUAnCMdm6rn6HRMGo8JwHxenKq9odtd055RnWCnVQ0Av52q + x+/27ATAfM6XVnk32dHprGnPqE6y06oGgH9N1eN3u0YCYD6rvpvsaWlPqU6y0yoGgCul6rG7fSgdnACY + yzruJrty2lOqk+y0igHgr1P12N3umwCYz6rvJntv2nOqE+10oAPAeJe+8W591WN3Gr/3Ge8mCMB8Vn03 + 2T3TnlOdaKcDHQB+PVWP2+2FCYD5nDOt8m6y8VjjMfec6mQ7HegA8M+petxuv5AAmM+q7yZ7TtqTqpPt + dCADwOVS9ZjdPp5OkwCYz6rvJrtm2pOqk+10IAPAE1P1mN0elACYz6rvJvtwGncU7EnVCXfqDgDjE5XG + JytVj9lpfOLThRIA8/mrVO0N3e6X9qzqhDt1B4BfSdXjdXtFAmA+q76b7Ph0/rRnVSfdqTsAvDFVj9ft + lxMA81n13WQvSXtaddKdOgPAJVP1WN0+nU6XAJjP/03V3tDt+mlPq066U2cAeHSqHqvbIxIA81n13WSf + TKdNe1p14p32dwA4PH0uVY/V7eIJgPms+m6yP0x7XnXinfZ3ALhFqh6n2+sSAPMZd5N9KVV7Q6dxN9mF + 055XnXyn/R0AXp2qx+l26wTAfFZ9N9mr0hSqk++0PwPARVL1GN2+kI5IAMxn1XeT3SxNoTr5TvszADw0 + VY/R7XEJgPms+m6yz6bD0hSqBei0rwPAoek/UvUY3S6TAJjPn6RqX+j2x2ka1QJ02tcB4Aap+vlub0kA + zGcdd5NdIk2jWoBO+zoAvCxVP9/tVxMA87l5qvaFbm9IU6kWodO+DAAXSOO9lauf7/SVdOYEwHz+T6r2 + hm63S1OpFqHTvgwA90/Vz3b7iwTAfFZ9N9l4H4EzpKlUC9Hp1AaA8XnKH0nVz3b7yQTAfB6Sqn2h25+l + 6VQL0enUBoBrp+rnur0rATCfddxN9hNpOtVCdDq1AeB5qfq5bndPAMxn1XeTvT1NqVqMTqc0AJw7fSNV + P9fp6+lsCYD5vDRVe0O3X0tTqhaj0ykNAPdO1c90e0YCYD6rvpvsa+ksaUrVgnQ6uQHg4PT+VP1Mt6sm + AObz+6naF7o9NU2rWpBOJzcAjM26+v5uY5gYQwUAc1nH3WQ/m6ZVLUinkxsAxj/XV9/fbfw6AYD5XCtV + +0K396SpVYvSqRoAxgv1xgv2qu/vNF5IOF5QCMB8npuqvaHbb6WpVYvSqRoAxq161fd2G7cSAjCfc6VV + 3k12TDpHmlq1MJ2qAWC8WU/1vd3GmwkBMJ97pWpf6PbsNL1qYTqdeAAYb9NbfV+38cKP8QIQAOYyXvj9 + vlTtDd2ukaZXLUynEw8A44N6qu/rNj5ICID5XCVV+0K3DyV3k0W1OJ2+ewAYH9E7Pqq3+r5O400fxps/ + ADCfp6dqb+h230RUi9PpuweAX03V93R7WQJgPqu+m+y49AOJqBao03cPAG9J1fd0Gx/8AMB87paqfaHb + ixL/pVqgTt8aAH4sVV/vNj7ycXz0IwDzeWeq9oZuv5D4L9UCdfrWAPC4VH2920MTAPO5Yqr2hW4fT6dJ + /JdqkTqNAeCI9IXv+t9W0UUSAPN5cqr2hW4PTnyXapE6jQHg1if63w60VycA5nOmtMq7yU5IF0p8l2qh + Oo0B4HUn+t8OtFskAOZzx1TtC91ekTiRaqE6jTdWqP73bp9LhycA5vPmVO0N3W6SOJFqoXahRycA5nPp + VO0L3T6dTpc4kWqxdqFLJgDm89hU7QvdHpEoVIu17d6YAJjPuJvs86naG7r9cKJQLda2+5UEwHxulap9 + odvrEyejWrBt9uV0xgTAfF6bqr2h27g9nZNRLdg2e2ICYD4XS9W+0G28Md3pEyejWrRtdrkEwHwenqp9 + odvjE6egWrRt9c8JgPmMD337VKr2hm7jw+k4BdWibatfTwDM50ap2he6vTVxKqqF20ZfS9+XAJjPy1O1 + N3S7U+JUVAu3jf4qATCfC6bjU7U3dPpqOnPiVFSLt42ulACYzwNStS90+8vEPqgWb9P9awJgPqdJH0vV + 3tDtpxL7oFq8TffbCYD5XDdV+0K3f0nso2oBN9mx6RwJgPk8P1V7Q7ffTOyjagE32d8mAOZznvSNVO0N + nb6evj+xj6pF3GQ/lwCYz++mal/o9jeJ/VAt4qb6UDokATCXg9MHUrU3dLtaYj9Ui7ipfi8BMJ+xWVf7 + Qrf3pzFUsB+qhdxEx6UfSADM55mp2hu6/U5iP1ULuYlelACYz3ih3njBXrU3dBovJBwvKGQ/VYu5iX4x + ATCfcatetS90G7cS0lAt5rr7RDptAmA+4816qr2h23USDdVirrsHJwDmM96mt9oXun00jbcTpqFa0HV2 + QvrBBMB8xgf1VHtDt/FBQjRVC7rOXpkAmM/4iN7xUb3V3tBpfITwkYmmalHX2U0SAPO5U6r2hW4vTxyA + alHX1WfS6RIA83lrqvaGbjdKHIBqUdfVIxMA8/nxVO0L3Y5KhyYOQLWw6+pHEgDzeXyq9oVuD08coGph + 19HrEwDzOX36Yqr2hm4XSxygamHX0W0SAPMZ1/9qX+j2msQKVIu76sbkNyZAAOYz/gW42hu63SqxAtXi + rrrxux8A5vPDqdoXun0+HZFYgWqBV9149ScA8xl3f1X7QrfHJFakWuBVNu77BGA+431fPp2qvaHbpRMr + Ui3wKhvv/ATAfMY7v1b7Qrc3J1aoWuRVNd7zebz3MwDzGZ/9Uu0N3e6QWKFqkVfV+NQnAOYzPvV1fPpr + tTd0+nI6U2KFqoVeVePez4tLkqbrT1K1L3R7cmLFqoWWJGmXukJixaqFliRpV3pHYg2qxZYkaVe6W2IN + qsWWJGkXOjqdNbEG1YJLkrQLPT2xJtWCS5K0C10lsSbVgkuStO3em1ijatElSdp290qsUbXokiRts2PT + uRJr9I1ULb4kSdvqOYk1+3iqFl+SpG11rcSavThViy9J0jb6cDoksWa3T9UfgCRJ2+i+iQ04Ih2Vqj8E + SZI22SfSGRMbcrNU/UFIkrTJbp3YsEek6g9DkqRN9Lh0cGIL7p+OT9UfjCRJ62rsP2zZFdLfp+oPSJKk + VXVCem66XGKHHJlulx6aHp+eIEnSATb2k3unX0pjnwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgHgcd9P8B3iUls7+K0kkAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAABAAAAAQACAYAAAB/HSuDAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAGePSURBVHhe7d0JtGXpWdd/OvPchCmMkUlEEgIYoiCIguAQ + QEAI4B8NiJrlBIkkII5BcGBQIIoyuxSBAFECMiQQgmnADoEOCsgsXDQWoaFJVbqqcqvqnr3z/+06+6aH + mu6wzzl7P+/ns9Z33YQh6b57n+e8z5tO8lYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABc681vfvPtfd9/cPr09Pyu674y + fWv+569Kdx0cHPz65cuXf/vChQvn8/cfYPifDf+74f8mf/eu9Krh/3f4xxj+scZ/zA/O//z28Z8OgB3J + LH7HzOSPyM/Pys9/mFn9r9N/Wa1WP5F+dpjlly5duufs2bP7+b95gP39/TdcuXLldfm/+ZX83bvy//eD + +fkf8vOf5x/rc9MnpD+YHjn+0wEAsCs5qD00B7OnpmfnwPbV+fuvyvJ+d35uxfjPNVwQfPXwxzD8seTv + P3T8wwNgIpmtj8mM/dD0tzJzvzl//66LFy/em58bt7e31x0cHPxG/nm/P31x/kefmJ48/qEBALAJOXA9 + LD09B8C/m0PY9+3v75/N35+Ve++99+Lwrzzlb35p+uj8sfpXjgCOKfPzccMMHWbpMFPvvvvuy/nbszL8 + 1WLDd9HwnZS/+/R02/iHDwDASeRA9XbpWTlkfcvFixffmL+9KMOFwHBAzN98Tg6J7zL+aQHwIJmT75k5 + +dzMzFecOXPmytUhuiCXLl36neG7Kn/zWfnzePz4pwUAwM3k4PSk9Dmr1erO4S+9XB+tlm/4cxn+nIY/ + t+HPcfzTBWhWZuFTsjT/04ODg/89jsoSzp0796b8eb00f3O4DHj0+KcLAMAgB6RHps/IgenlWZRX6yNU + XcOf4/DnOvw5D3/u468BoLzMvHdIn79arX52HImlDX/1Wub9f8zf/BPJv00AAGhXDoHvnQPRlw5/6eRw + UGrR8J9lkMPh1+d38ZTx1wJQTsbd04dZN/yr4+vp157hv3Egs374zwx4u/HXAgBQXw5AH5GD4Pfv7e31 + 62MRw+9i+J0Mv5vx1wSwaBltD89M+0ur1ern1pOOwfifD/Nv8zffc/xVAQDUkoPObekTh38f/HAA4sbG + 39HwXzXlLxcFFidL/2PTc69cufJ/rg41rmv8t4O9OH/zA8dfHQDA8uVw89FZan/66omHI8vv7Ofz41nj + rxFg1jKvHp6ek8X/zDDDOJrxrwAb/isFnzb+KgEAlieHmQ/NEnvHeMbhhIbf4fC7HH+tALOSMfWQzKhn + Hxwc/MZ6anESe3t7B13XfXN+l+82/moBAOYvh5d3yiHmW/x7/Kc1/CtE+fHk8dcMsHOZSU9f+bd2TWr4 + zwjIjy9Kjxp/zQAA85PDyiOy/H/BxYsX7x0OMUxv+N0Ov+P8zUeMv3aArcsceoeu6/793t5et55OTO3g + 4ODX83v+c+OvHABgPnJI+YDVavXa8dzChg3/+QD5nT9j/PUDbE1G0LMuXbr0u+tpxKaN//kA7zz++gEA + didnk0elLzpz5syVqycVtmb894u+KAfDx46PA2BjMmuGf3vXS8cRxBbt7++fzY/njI8CAGD7chh82sHB + wS+ujyfsyvAMhmcxPhaAyWXGfHrGzbn11GFXuq777jyLtxkfCwDAduQA8uzxP6iIGbjnnnsu5Zk8N3/z + tvERAZxa5sqjh7/SaD1pmIMrV668Ls/lj4+PCABgc3L2eOscBr93fQxhbsZn89bj4wI4sSyZ739wcPDL + 6+nCnOzt7a3yfF6Yv/mQ8XEBAEwrh40/kMPgL62PH8xVntGv5Vk9dXxsAMeWUfKs8+fPX1hPFeaq67of + zA+XvgDAtLJQflwOGf79nwtx4cKF83lmnzw+PoAjyfi4LbPj7+7t7fXracLcHRwc/Gqe2VPGRwgAcDo5 + X3yhw+DyjM/sC8fHCHBTmReP8W/xWqxzfd9/1PgoAQCOLweKh+Yw+DXrswVLlWf4TfnxsPGxAlwjy+Pb + rFarn1hPDZbo7rvvvpzn+BnjIwUAOLocIob/5Gf/fc9FDM9yeKbj4wV4i4yI9xz+MvL1tGDJhr/yK75g + fLQAALeWM8Twl4G+Yn2coIrVanVHDoaPHx8zwNX/cNcrV678v3FMUES+w79sfMQAADeWw+Bjc3D40fEM + QTGr1erH84yfMD5uoGEZCe+b5f/MejpQTb7L/+X4qAEArpXzwu1ZEO9cHx2oanzGt4+PHWhQ3/dPu3Tp + 0u+spwJVdV33ovy4bXzsAABrOSAMy/9PXj0xUF6e9WuzALzN+PiBhozL/++O44Diuq77hvxwCQAArOVg + YPlvkEsAaE8++u97+fLl16+nAK1wCQAAXJUDgeW/YS4BoB35yFv+G+YSAAAal4OA5R+XANCAfMb/QJb/ + 3xo/9jTKJQAANCoHAMs/b+ESAOqy/HN/LgEAoDH54rf8cw2XAFBPPtPv47/qjwdzCQAAjcgXvuWfG3IJ + AHXks/z7Lf/ciEsAACguX/SWf27JJQAs37j8/7/xYw3X5RIAAIrKF7zlnyNzCQDLlc/ue1v+OSqXAABQ + TL7YLf8cm0sAWJ58Zn/fwcHB3vgxhiNxCQAAReQL3fLPibkEgOWw/HMaLgEAYOHyRW7559RcAsD85aP6 + 5Cz/v7H+1MLJuAQAgIXKF7jln8m4BID5ykfU8s9kXAIAwMLki9vyz+RcAsD85KM5LP+/vv6UwjRcAgDA + QuQL2/LPxrgEgPnIZ/HdLP9siksAAJi5fFFb/tk4lwCwe+Py/7/HjyVshEsAAJipfEFb/tkalwCwO/ns + vavln21xCQAAM5MvZss/W+cSALZvXP5/bfwYwla4BACAmcgXsuWfnXEJANuTj9w7Zvn/xfWnD7bLJQAA + 7Fi+iC3/7JxLANi8fMaeZPln11wCAMCO5AvY8s9suASAzRmX/18YP26wUy4BAGDL8sVr+Wd2XALA9PKZ + egfLP3PjEgAAtiRfuJZ/ZsslAExnWP7zmfpf48cLZsUlAABsWL5oLf/MnksAOL1x+f/58WMFs+QSAAA2 + JF+wln8WwyUAnFw+O29v+WcpXAIAwMTyxWr5Z3FcAsDxjcv/z40fI1gElwAAMJF8oVr+WSyXAHB0+cg8 + cfjMrD89sCwuAQDglPJFavln8VwCwK3lo/LEdNfVDw0slEsAADihfIFa/inDJQDcWD4ib53PyE+vPy2w + bC4BAOCY8sVp+acclwBwrXw0LP+U4xIAAI4oX5iWf8pyCQD3yUdiWP5/av3pgFpcAgDALeSL0vJPeS4B + 4C3z/jXrTwXU5BIAAG4gX5CWf5rhEoCW5SNg+acZLgEA4EHyxWj5pzkuAWhRXn3znua4BACAUb4QHQZp + lksAWpJ3/Ql55189vv7QFJcAADQvX4SWf5rnEoAW5B1/bN71O8bXHprkEgCAZuUL0PIPI5cAVDYs/3nN + X7V+26FtLgEAaE6++Cz/8CAuAahoWP6z8Py38TUHwiUAAM3IF57lH27AJQCV5JV+jOUfrs8lAADl5YvO + 8g+34BKACvIqD8v/j67fauB6XAIAUFa+4Cz/cEQuAViyvMLD8v/K9dsM3IxLAADKyReb5R+OySUAS5RX + 1/IPx+QSAIAy8oVm+YcTcgnAkuRdfXQWmR8ZX1/gGFwCALB4+SKz/MMpuQRgCcbl/xXjawucgEsAABYr + X2CWf5iISwDmLO/mI7O4fP/4ugKn4BIAgMXJF5flHybmEoA5yqv5iCws37d+S4EpuAQAYDHyhWX5hw1x + CcCc5JW0/MOGuAQAYPbyRWX5hw1zCcAc5FUclv//un4rgU1wCQDAbOULyvIPW+ISgF3KKzgs/9+7fhuB + TXIJAMDs5IvJ8g9b5hKAXcirZ/mHLXMJAMBs5AvJ8g874hKAbcor9/AsIt+zfvuAbXIJAMDO5YvI8g87 + 5hKAbcirNiz/L12/dcAuuAQAYGfyBWT5h5lwCcAm5RV7aBaPF6/fNmCXXAIAsHX54rH8w8y4BGAT8mpZ + /mFmXAIAsDX5wrH8w0y5BGBKeaWG5f/b128XMCcuAQDYuHzRWP5h5lwCMIW8SsPy/23rtwqYI5cAAGxM + vmAs/7AQLgE4jbxCw/L/reu3CZgzlwAATC5fLJZ/WBiXAJxEXp1h+f9P67cIWAKXAABMJl8oln9YKJcA + HEdemWH5/5b12wMsiUsAAE4tXyTD8v+aq98slHTnnXdejbrGz/Dt48carivviOW/MeZ/PfkMf01+uAQA + 4PjyBeJf+S9uOPg94QlPePNjH/vYN99xxx3j/5SK8ln2VwJwQ3lFHpL+w9WXhSaY/3X5KwEAOLZ8cVj+ + izs8/A2Pe8ghsD6XAFxPXo3bsjB83fotoQXmf30uAQA4snxhWP6Le/Dh7zCHwPpcAnB/eSWG5f9r128H + LTD/2+ESAIBbyheF5b+4Gx3+DnMIrM8lAIO8CsPy/+/WbwUtMP/b4xIAgBvKF4Tlv7hbHf4OcwiszyVA + 2/IKDMv/v12/DbTA/G+XSwAArpEvBst/cUc9/B3mEFifS4A25dFb/htj/uMSAIC3yBeC5b+44x7+DnMI + rM8lQFvyyIflf/ivCaMR5j+HXAIAYPlvwEkPf4c5BNbnEqANedTD8v9v1k+dFpj/PJhLAICG5QvA8l/c + aQ9/hzkE1ucSoLY84mH5/9frp00LzH9uxCUAQIMy+C3/xU11+DvMIbA+lwB15cD/ZeNjpgHmP7fiEgCg + IRn4lv/ipj78HeYQWJ9LgHryWL90/XRpgfnPUbkEAGhABr3lv7hNHf4OcwiszyVAHTng/4vxsdIA85/j + cgkAUFgGvOW/uE0f/g5zCKzPJcDy5WD/z8fHSQPMf07KJQBAQRnslv/itnX4O8whsD6XAMuVA/0/Gx8j + DTD/OS2XAACFZKBb/ovb9uHvMIfA+lwCLE8O8v90fHw0wPxnKi4BAArIILf8F7erw99hDoH1uQRYjhzg + v2R8bDTA/GdqLgEAFiwD3PJf3K4Pf4c5BNbnEmD+cnD/4vFx0QDzn01xCQCwQBnclv/i5nL4O8whsD6X + APOVA/s/GR8TDTD/2TSXAAALkoFt+S9uboe/wxwC63MJMD95LF+0fjq0wPxnW1wCACxABrXlv7i5Hv4O + cwiszyXAfOQ5fMH4WGiA+c+2uQQAmLEMaMt/cXM//B3mEFifS4Ddy+//88fHQQPMf3bFJQDADGUwW/6L + W8rh7zCHwPpcAuxOfu8vGB8DDTD/2TWXAAAzkoFs+S9uaYe/wxwC63MJsH35fT9//PXTAPOfuXAJADAD + GcSW/+KWevg7zCGwPpcA25Pf8+eNv3YaYP4zNy4BAHYoA9jyX9zSD3+HOQTW5xJg8/L7/Tvjr5sGmP/M + lUsAgB3I4LX8F1fl8HeYQ2B9LgE2J7/X542/Zhpg/jN3LgEAtigD1/JfXLXD32EOgfW5BJie5b8t5j9L + 4RIAYAsyaC3/xVU9/B3mEFifS4Dp5Pf43L29vX781VKc+c/SuAQA2KAMWMt/cdUPf4c5BNbnEuD08mt8 + juW/HeY/S+USAGADMlgt/8W1cvg7zCGwPpcAJ5ff21+z/LfD/GfpXAIATCgD1fJfXGuHv8McAutzCXB8 + +X39Vct/O8x/qnAJADCBDFLLf3GtHv4OcwiszyXA0eX39Fey/Hfjr47izH/zvxqXAACnkAFq+S+u9cPf + YQ6B9bkEuLX8fj7b8t8O83+d+V+PSwCAE8jgtPwX5/D3wBwC63MJcGOW/7aY/w/M/K/HJQDAMWRgWv6L + c/i7fg6B9bkEuFZ+H3/Z8t8O8//6mf/1uAQAOIIMSst/cQ5/N88hsD6XAPfJr+OzLP/tMP9vnvlfj0sA + gJvIgLT8F+fwd7QcAutzCXD1X/n/9Cz/q/FXQnHm/9Ey/+txCQBwHRmMlv/iHP6Ol0NgfS1fAuTP+9Oy + /B+MvwqKM/+Pl/lfj0sAgPvJQLT8F+fwd7IcAutr8RIgf76favlvh/l/ssz/elwCAEQGoeW/OIe/0+UQ + WF9LlwD5032W5b8d5v/pMv/rcQkANC0D0PJfnMPfNDkE1tfCJUD+/D7F8t8O83+azP96XAIATcrgs/wX + 5/A3bQ6B9VW+BLD8t8X8nzbzvx6XAEBTMvAs/8U5/G0mh8D6Kl4C5M/nk8+cOXNl/FOkOPN/M5n/9bgE + AJqQQWf5L87hb7M5BNZX6RIgfx5/3vLfDvN/s5n/9bgEAErLgLP8F+fwt50cAuurcAmQP/5Psvy3w/zf + TuZ/PS4BgJIy2Cz/xTn8bTeHwPqWfAmQP+5n3nPPPZfGPxWKM/+3m/lfj0sAoJQMNMt/cQ5/u8khsL4l + XgLkj/fPWv7bYf7vJvO/HpcAQAkZZJb/4hz+dptDYH1LugTIH+efsfy3w/zfbeZ/PS4BgEXLALP8F+fw + N48cAutbwiXAsPyfPXt2f/xDpjjzfx6Z//W4BAAWKYPL8l+cw9+8cgisb86XAPnj+tOW/3aY//PK/K/H + JQCwKBlYlv/iHP7mmUNgfXO8BMgfz5+y/LfD/J9n5n89LgGARcigsvwX5/A37xwC65vTJUD+OD7G8t8O + 83/emf/1uAQAZi0DyvJfnMPfMnIIrG8OlwDD8n/u3Lk3jX9IFGf+LyPzvx6XAMAsZTBZ/otz+FtWDoH1 + 7fISIP+8H3H+/PkL4x8KxZn/y8r8r8clADArGUiW/+Ic/paZQ2B9u7gEyD/fH7P8t8P8X2bmfz0uAYBZ + yCCy/Bfn8LfsHALr2+YlwLD8X7hw4fz4T01x5v+yM//rcQkA7FQGkOW/OIe/GjkE1reNS4D803y45b8d + 5n+NzP96XAIAO5HBY/kvzuGvVg6B9W3yEiD/uB9m+W+H+V8r878elwDAVmXgWP6Lc/irmUNgfZu4BBiW + /4sXL947/lNQnPlfM/O/HpcAwFZk0AzL/2uuTh5KcvirnUNgfeOMvj3P+9T8K/9tMf9rZ/7X03Xd1+SH + SwBgMzJg/Cv/xTn8tZFDYH2Z1af+KwHy//+h/pX/dpj/bWT+1+OvBAA2IoPF8l+cw19bOQTWd5pLgHH5 + f+P4D0Vx5n9bmf/1uAQAJpWBYvkvzuGvzRwC6zvJJUD+356+v7//hvU/AtWZ/21m/tfjEgCYRAaJ5b84 + h7+2cwis7ziXAPm/+0OW/3aY/21n/tfjEgA4lQwQy39xDn8acgis7yiXAPnff1CW/98b/18ozvzXkPlf + j0sA4EQyOCz/xTn86f45BNZ3s0sAy39bzH/dP/O/HpcAwLFkYFj+i3P40/VyCKzvepcA+R9/4KVLl+5Z + /19Qnfmv62X+1+MSADiSDArLf3EOf7pZDoH13f8SIH/X8t8Q8183y/yvxyUAcFMZEJb/4hz+dJQcAusb + LwE+wvLfDvNfR8n8r8clAHBdGQyW/+Ic/nScHALr29vbOxj/JsWZ/zpO5n89LgGAB8hAsPwX5/Cnk+QQ + CMtn/uskmf/1uAQArsogsPwX5/Cn0+QQCMtl/us0mf/1uASAxmUAWP6Lc/jTFDkEwvKY/5oi878elwDQ + qHzwLf/FOfxpyhwCYTnMf02Z+V+PSwBoTD7wlv/iHP60iRwCYf7Mf20i878elwDQiHzQLf/FOfxpkzkE + wnyZ/9pk5n89LgGguHzALf/FOfxpGzkEwvyY/9pG5n89LgGgqHywLf/FOfxpmzkEwnyY/9pm5n89LgGg + mHygLf/FOfxpFzkEwu6Z/9pF5n89LgGgiHyQLf/FOfxplzkEwu6Y/9pl5n89LgFg4fIBtvwX5/CnOeQQ + CNtn/msOmf/1uASAhcoH1/JfnMOf5pRDIGyP+a85Zf7X4xIAFiYfWMt/cQ5/mmMOgbB55r/mmPlfj0sA + WIh8UC3/xTn8ac45BMLmmP+ac+Z/PS4BYObyAbX8F+fwpyXkEAjTM/+1hMz/elwCwEzlg2n5L87hT0vK + IRCmY/5rSZn/9bgEgJnJB9LyX5zDn5aYQyCcnvmvJWb+1+MSAGYiH0TLf3EOf1pyDoFwcua/lpz5X49L + ANixfAAt/8U5/KlCDoFwfOa/KmT+1+MSAHYkHzzLf3EOf6qUQyAcnfmvSpn/9bgEgC3LB87yX5zDnyrm + EAi3Zv6rYuZ/PS4BYEvyQbP8F+fwp8o5BMKNmf+qnPlfj0sA2LB8wCz/xTn8qYUcAuFa5r9ayPyvxyUA + bEg+WJb/4hz+1FIOgXAf818tZf7X4xIAJpYPlOW/OIc/tZhDIJj/ajPzvx6XADCRfJAs/8U5/KnlHAJp + mfmvljP/63EJAKeUD5DlvziHP8khkDaZ/5L5X5FLADihfHAs/8U5/En35RBIS8x/6b7M/3pcAsAx5QNj + +S/O4U+6NodAWmD+S9dm/tfjEgCOKB8Uy39xDn/SjXMIpDLzX7px5n89LgHgFvIBsfwX5/An3TqHQCoy + /6VbZ/7X4xIAbiAfDMt/cQ5/0tFzCKQS8186euZ/PS4B4EHygbD8F+fwJx0/h0AqMP+l42f+1+MSAEb5 + IFj+i3P4k06eQyBLZv5LJ8/8r8clAM3LB8DyX5zDn3T6HAJZIvNfOn3mfz0uAWhWXnzLf3EOf9J0OQSy + JOa/NF3mfz0uAWhOXnjLf3EOf9L0OQSyBOa/NH3mfz0uAWhGXnTLf3EOf9Lmcghkzsx/aXOZ//W4BKC8 + vOCW/+Ic/qTN5xDIHJn/0uYz/+txCUBZebGH5f81V990SnL4k7aXQyBzYv5L28v8r8clAOXkhX5clv87 + r77hlOTwJ20/h0DmwPyXtp/5X49LAMrIi/yIvNAvu/pmU5LDn7S7HALZJfNf2l3mfz0uAVi8vMAPTd81 + vNDU5PAn7T6HQHbB/Jd2n/lfj0sAFm18gSnK4U+aTw6BbJP5L80n87+e7FBfkx8uAViWvu8/f/0KU5HD + nzS/HALZBvNfml/mfz1d170ozxaWIcv/M/f29lbj+0sxDn/SfHMIZJPMf2m+mf/1dF33xXm2MG9Z/p92 + 4cKF8+N7SzEOf9L8cwhkE8x/af6Z//Vkt3pBni3MU17Qxx8cHPzS+L5SjMOftJwcApmS+S8tJ/O/lr29 + vaxY/Wfm2cK85P28reu6l6xfVapx+JOWl0MgUzD/peVl/tdy5syZK33f/8k8W5iPvJTPG99RinH4k5ab + QyCnYf5Ly838r2V/f//3sm+9T54t7F5exqecPXt2f3w/KcThT1p+DoGchPkvLT/zv5aDg4NfyY8n5tnC + 7mT5f+RqtfrZ9WtJJQ5/Up0cAjkO81+qk/lfS9d1P5AfD8mzhd3IS/gV69eRShz+pHo5BHIU5r9UL/O/ + lr7v/16eK2xfXr4P2dvb68Z3kSIc/qS6OQRyM+a/VDfzv45h/8oe9jF5rrA9efcetlqtfmb9GlKFw59U + P4dArsf8l+pn/tdx5cqVM33fv22eK2xHXrgXjO8fRTj8Se3kEMj9mf9SO5n/dXRd9915prB5ed+efP78 + +QvrV48KHP6k9nIIZGD+S+1l/tfR9/1n5JnCZnVd9+3jO0cBDn9SuzkEts38l9rN/K9hf3//bN/375xn + CpuRF+yD/Af/1eHwJ8khsE3mvyTzv4zvyvOEzVitVj82vmgsnMOfpMMcAtti/ks6zPyvoe/7j8vzhGnl + xfr48R1j4Rz+JD04h8A2mP+SHpz5v3xXrlz5zexqj83zhOmsVqufGt8xFszhT9KNcgiszfyXdKPM/+Xr + +/6FeZYwjbxQHzu+WyyYw5+kW+UQWJP5L+lWmf/Ldu7cuTdlZ3vXPEs4vdVq9Zrx3WKhHP4kHTWHwFrM + f0lHzfxftq7rvjHPEU6n7/uPHN8pFsrhT9JxcwiswfyXdNzM/+Xa29tbZXd7ap4jnFzXdd87vlMskMOf + pJPmELhs5r+kk2b+L5r/WkBOru/79xhuksaXiYVx+JN02hwCl8n8l3TazP9lyu6WFa5//zxDOL6u675q + fJdYGIc/SVPlELgs5r+kqTL/lyk73Ivz/OB48u484tKlS/esXyOWxOFP0tQ5BC6D+S9p6sz/5dnb2+v6 + vv/9eX5wdHlpPm18h1gQhz9Jm8ohcN7Mf0mbyvxfnq7r/k2eHRxdXpqXj+8PC+HwJ2nTOQTOk/kvadOZ + /8ty4cKF8/nx1nl2cGt937+L//C/ZXH4k7StHALnxfyXtK3M/2XJTvd5eW5wa3lZnju+NyyAw5+kbecQ + OA/mv6RtZ/4vx8HBwa/mx215bnBzq9Xqx9avDXPn8CdpVzkE7pb5L2lXmf+L8uF5ZnBjfd8/yV/+vwwO + f5J2nUPgbpj/knad+b8MXdd9c54X3Fjek+esXxfmzOFP0lxyCNwu81/SXDL/52/8DwN8XJ4XXF/XdS9d + vy7MlcOfpLnlELgd5r+kuWX+z1/f95+eZwXXyvvxsHTu6pvCLDn8SZprDoGbZf5Lmmvm/7x1XfeSPCe4 + Vt/3Hza+J8yQw5+kuecQuBnmv6S5Z/7P17333nsxe95j85zggfJivHB8T5gZhz9JS8khcFrmv6SlZP7P + V/a8T8ozggfquu6Hx3eEGXH4k7S0HAKnYf5LWlrm/zxlz/vGPB+4T96Lh+zv759dvyLMhcOfpKXmEHg6 + 5r+kpWb+z8+VK1del2cD9+n7/qnj+8FMOPxJWnoOgSdj/ktaeub/LL1vng2s9X3/2eOLwQw4/EmqkkPg + 8Zj/kqpk/s9L9r3PyXOBta7rvnp8N9gxhz9J1XIIPBrzX1K1zP9Z+a48E1jruu5HxheDHXL4k1Q1h8Cb + M/8lVc38n4crV66cyfOAtcuXL79+fDfYEYc/SdVzCLw+819S9cz/eej7/l3zPGhdXoS3Hd8JdsThT1Ir + OQQ+kPkvqZXM/93L3vcpeRa0Li/CM8Z3gh1w+JPUWg6Ba+a/pNYy/3er67ovyXOgdcNN0PhOsGUOf5Ja + rfVDoPkvqdVcAuxO13UvzTOgdX3fP398J9gihz9JrdfqIdD8l9R6LgF24+Dg4Nfy+6d1Xde9aHwn2BKH + P0la19oh0PyXpHUuAbZvb2+vy4/H5PdPy7qu+471K8E2OPxJ0gNr5RBo/kvSA3MJsH193z8lv3ta1nXd + K8b3gQ1z+JOk61f9EGj+S9L1cwmwXX3fPzO/d1q2Wq1+Znwf2CCHP0m6eVUPgea/JN08lwDb0/f938zv + nJYdHBzsje8DG+LwJ0lHq9oh0PyXpKPlEmA7uq77svy+admlS5d+Z3wf2ACHP0k6XlUOgea/JB0vlwCb + 13Xdt+R3TcvyHpxbvw5MzeFPkk7W0g+B5r8knSyXAJvVdd0P5PdMy86dO/em8X1gQg5/knS6lnoINP8l + 6XS5BNic1Wr1k/kd07K9vb3V+D4wEYc/SZqmpR0CzX9JmiaXAJtxcHDwq/n90jIXANO766673vzEJz7x + usNMknS8lnIItPxL0nQN8/TVr371OGGZyuXLl387v19a5t8CsBkuASRpuuZ+CWD5l6Tpsvxvzv7+/hvy + O6ZleQ/8hwBuiEsASZquuV4CWP4labos/5t1/vz5C/k90zL/NYCb5RJAkqZrbpcAln9Jmi7L/+adOXPm + Sn7XtOzg4GBvfB/YEJcAkjRdc7kEsPxL0nRZ/rdjb2+vy++blq1Wq9eO7wMb5BJAkqZr15cAln9Jmi7L + //acPXt2P79zWtZ13Q+P7wMb5hJAkqZrV5cAln9Jmi7L/3ZdvHjxjfm907Ku6148vg9sgUsASZqubV8C + WP4labos/9t36dKl383vnpZ1Xfei8X1gS1wCSNJ0besSwPIvSdNl+d+NK1euvC6/f1rW9/3zx/eBLXIJ + IEnTtelLAMu/JE2X5X93VqvVz+YZ0LK+7z9lfB/YMpcAkjRdm7oEsPxL0nRZ/ner67ofzXOgZX3fP2N8 + H9gBlwCSNF1TXwJY/iVpuiz/u9d13UvyLGhZ3/dvO74P7IhLAEmarqkuASz/kjRdlv956Lru6/I8aN3l + y5dfP74T7IhLAEmartNeAlj+JWm6LP/z0ff9388zoXVd1/3I+E6wQy4BJGm6TnoJYPmXpOmy/M9L3/ef + kedC67qu++rxnWDHXAJI0nQd9xLA8i9J02X5n6UPz7OhdX3ff/b4QjADLgEkabqOeglg+Zek6bL8z1P2 + vnfL86F1eRGeMr4TzIRLAEmarltdAlj+JWm6LP/zdPHixXvz47Y8I1o3vAj7+/tvuPpmMBsuASRpum50 + CWD5l6TpsvzP12q1ujPPCNa6rvuh8d1gRlwCSNJ0PfgSwPIvSdNl+Z+37HvfkOcEa33fv3B8N5gZlwCS + NF2HlwCWf0maLsv//GXfe26eFazlhfiw8d1ghlwCSNJ0PfrRj756EXC9/50k6XhZ/pch+96H5HnBWt6J + h6VzV98OZsklgCRJkuaU5X8Z7rnnnkt93z8yzwzu03XdS8d3hJlyCSBJkqQ5ZPlfjtVq9eo8M3igvBvP + Wb8izJlLAEmSJO0yy/+ydF33VXlu8EB93z9pb29vNb4nzJhLAEmSJO0iy//yZM/7+Dw7uNZqtbr2vySZ + WXIJIEmSpG1m+V+eM2fOXOn7/gl5fnCtvByfO74rLIBLAEmSJG0jy/9ivSrPD66v7/t38W8DWBaXAJIk + Sdpklv/lyn739/MM4ca6rnv5+L6wEC4BJEmStIks/8vW9/0fzHOEG8tL8mnj+8KCuASQJEnSlFn+l+3g + 4OCX8xzh5vKuPOLSpUv3rF8blsQlgCRJkqbI8r98Xdd9SZ4l3Nrw3xU5vjcsjEsASZIknSbLfxkfmOcJ + t5aX5d39hwEul0sASZIknSTLfw2r1ern8zzh6Lqu+57x/WGBXAJIkiTpOFn+6+j7/nl5pnB0eWk+cnx/ + WCiXAJIkSTpKlv86zpw5cyW73NvnucLxrFar14zvEQvlEkCSJEk3y/JfS9d1/znPFY6v7/uPHd8jFswl + gCRJkq6X5b+e7HB/LM8WTma1Wv3U+C6xYC4BJEmSdP8s//Vkd/uZPFs4ub7vP358n1g4lwCSJEkasvzX + lN3t2Xm+cDpd171yfKdYOJcAkiRJbWf5r+nKlSuv6/v+kXnGcDp5kT5ob2+vG98tFs4lgCRJUptZ/uvK + zva384xhGl3Xfdv4blGASwBJkqS2svzXdfny5d/q+/7Rec4wjbxXTz5//vyF9StGBS4BJEmS2sjyX1uW + /+fmOcO08mK9YHzHKMIlgCRJUu0s/7UdHBzs5cej8qxhWnmxHjb8V0tcfdMowyWAJElSzSz/9fV9/+l5 + 1rAZecE+xH8gYD0uASRJkmpl+a9vtVq9Jj9uy/OGzem67svXrxyVuASQJEmqkeW/vr29vT4/PjzPGzar + 7/tHrlarn12/elTiEkCSJGnZWf7b0HXdN+d5w3b0ff+Us2fP7o/vH4W4BJAkSVpmlv82XLp06Z7sY2+f + Zw7bk5fueeM7SDEuASRJkpaV5b8d2cM+M88ctq/rupeM7yHFuASQJElaRpb/dmT/+uH88B/8x27k5Xvc + wcHBL119GynHJYAkSdK8s/y3Y39//2zf9++W5w67k5fwaRcuXDg/vpcU4xJAkiRpnln+25K969Py3GH3 + 8jI+c29vbzW+mxTjEkCSJGleWf7b0nXdf8pzh/no+/7zx/eTglwCSJIkzSPLf1sODg5+ObvW4/PsYV66 + rvuG8T2lIJcAkiRJu83y35bz589fyPL/fnn2MD95Rx/add13rl9XKnIJIEmStJss/+3J8v8X8uxhvvKe + PqLrupetX1kqcgkgSZK03Sz/7clO9c/y7GH+8r4+brVa3bl+danIJYAkSdJ2svy3J8v/f8mPh+T5wzLk + hb19tVq95uobTEkuASRJkjab5b892aF+Oj8ek+cPy5IXd7gE+MmrbzIluQSQJEnaTJb/9hwcHPxafrxj + nj8sU15glwDFuQSQJEmaNst/e65cufK6/Hj3PH9YtrzILgGKcwkgSZI0TZb/9ly6dOl38uN98/yhhrzQ + LgGKcwkgSZJ0uiz/7cny/7t9339Anj/UkvfbJUBxLgEkSZJOluW/Pfv7+2/Ij6fn+UNNecFdAhTnEkCS + JOl4Wf7bM/xl/33fPy3PH2rL++4SoDiXAJIkSUfL8t+ecfl//zx/aEPee5cAxbkEkCRJunmW//Zcvnz5 + bss/Tcr77xKgOJcAkiRJ18/y355x+X9qnj+0KZ8DlwDFuQSQJEl6YJb/9mT5/+0s/0/J84e25fPgEqA4 + lwCSJEnrLP/tsfzDg+Rz4RKgOJcAkiSp9Sz/7RmX//fL8wfuL58PlwDFuQSQJEmtZvlvT5b/11v+4Sby + OXEJUJxLAEmS1FqW//ZcuXLldVn+3zvPH7iZfF5cAhTnEkCSJLWS5b89Wf7/r+UfjiGfG5cAxbkEkCRJ + 1bP8t2dc/t8rzx84jnx+XAIU5xJAkiRVzfLfniz//8fyD6eQz5FLgOJcAkiSpGpZ/tszLP/58Z55/sBp + 5IPkEqA4lwCSJKlKlv/2WP5hYvlAuQQoziWAJElaepb/9mT5/82+798jzx+YUj5fLgGKcwkgSZKWmuW/ + PZZ/2LB8zlwCFOcSQJIkLS3Lf3sODg728uPd8/yBTcoHzSVAcS4BJEnSUrL8tyfL/6/2ff+uef7ANuRz + 5xKgOJcAkiRp7ln+2zMu/++S5w9sUz5/LgGKcwkgSZLmmuW/PVn+f8XyDzuUz6FLgOJcAkiSpLll+W9P + lv9fzvL/znn+wC7l8+gSoDiXAJIkaS5Z/ttj+YeZyefSJUBxLgEkSdKus/y3J8v/L2X5f6c8f2BO8vl0 + CVCcSwBJkrSrLP/tsfzDzOVz6hKgOJcAkiRp21n+25Pl/xfz4x3z/IE5ywfVJUBxLgEkSdK2svy3x/IP + C5MPrEuA4lwCSJKkTWf5b092iP+ZH2+X5w8sST64LgGKcwkgSZI2leW/Pdkd/kd+WP5hqfIBdglQnEsA + SZI0dZb/9gzLf9/3b5vnDyxZPs8uAYpzCSBJkqbK8t+e7Ao/Y/mHQvK5dglQnEsASZJ02iz/7bH8Q1H5 + fLsEKM4lgCRJOmmW//ZkN3htlv+3yfMHKsrn3CVAcS4BJEnScbP8N+kuyz80IB92lwDFuQSQJElHzfLf + pLvSE/P8gRbkA+8SoDiXAJIk6VZZ/tuTHeDOvu+fkOcPtCSff5cAxbkEkCRJN8ry356c/f+75R8aljng + EqA4lwCSJOnBWf7bkzP/T2T5f3yeP9CyzAOXAMW5BJAkSYdZ/ttj+QceIHPBJUBxLgEkSZLlvz054/+4 + 5R+4RuaDS4DiXAJIktRulv/25Gz/Y/nxuDx/gGtlQLgEKM4lgCRJ7WX5b4/lHziSDAqXAMW5BJAkqZ0s + /+3JWf6O/LD8A0eTgeESoDiXAJIk1c/y36RX9X3/2Dx/gKPL8HAJUJxLAEmS6mb5b0/XdT+U5f/Ref4A + x5c54hKgOJcAkiTVy/LfHss/MInME5cAxbkEkCSpTpb/9mT5f3l+PCrPH+D0MlBcAhTnEkCSpOVn+W9P + lv+X5YflH5hWBotLgOJcAkiStNws/+3J8v+D+WH5BzYjA8YlQHEuASRJWl6W//ZY/oGtyKBxCVCcSwBJ + kpaT5b89Wf5/oO/7R+b5A2xe5o5LgOJcAkiSNP8s/+3J8v/9ln9g6zJ/XAIU5xJAkqT5Zvlvj+Uf2KnM + IZcAxbkEkCRpfln+25Pl/z/nx8Pz/AF2J4PIJUBxLgEkSZpPlv/2ZPl/SX5Y/oF5yEByCVCcSwBJknaf + 5b89ln9gljKYXAIU5xJAkqTdZflv0nelh+X5A8xPBpRLgOJcAkiStP0s/+3puu4788PyD8xbBpVLgOJc + AkiStL0s/+3J8v8d+WH5B5YhA8slQHEuASRJ2nyW//Zk+X9xflj+gWXJ4HIJUJxLAEmSNpflvz2Wf2DR + MsBcAhTnEkCSpOmz/Lcny/+/z4+H5PkDLFcGmUuA4lwCSJI0XZb/9mT5/+b8sPwDNWSguQQoziWAJEmn + z/LfHss/UFIGm0uA4lwCSJJ08iz/7cny/035YfkHasqAcwlQnEsASZKOn+W/PVn+vzE/LP9AbRl0LgGK + cwkgSdLRs/y3J8v/N+SH5R9oQwaeS4DiXAJIknTrLP/tyfL/9flxW54/QDsy+FwCFOcSQJKkG2f5b0+W + /6/LD8s/0KYMQJcAxbkEkCTp2iz/7cny/7X5YfkH2pZB6BKgOJcAkiTdl+W/PVn+vyo/LP8AgwxElwDF + uQSQJMny36Is/1+ZZw/A/WU+ugQoziWAJKnlLP/tyfL/r/LsAbiezEmXAMW5BJAktZjlvz1Z/v9lnj0A + N5N56RKgOJcAkqSWsvy3J8v/V+TZA3AUmZsuAYpzCSBJaiHLf3uy/H95nj0Ax5H56RKgOJcAkqTKWf7b + k+X/y/LsATiJzFGXAMW5BJAkVczy36QvzbMH4DQyTF0CFOcSQJJUKct/kyz/AFPJUHUJUJxLAElShSz/ + 7en7/oV59gBMKfPVJUBxLgEkSUvO8t+eLP//OM8egE3InHUJUJxLAEnSErP8tyfL/z/KswdgkzJvXQIU + 5xJAkrSkLP/tyfL/D/PsAdiGzF2XAMW5BJAkLSHLf3uy/P+DPHsAtinz1yVAcS4BJElzzvLfniz/fz/P + HoBdyBx2CVCcSwBJ0hyz/Lcny//fy7MHYJcyj10CFOcSQJI0pyz/bdnb28vu3z8vzx6AOchsdglQnEsA + SdIcsvy3ZVz+n5tnD8CcZEa7BCjOJYAkaZdZ/tsyLv+fm2cPwBxlVrsEKM4lgCRpF1n+2zIu/5+TZw/A + nGVmuwQoziWAJGmbWf7bMi7/fzvPHoAlyOx2CVCcSwBJ0jay/LdlXP7/Vp49AEuSGe4SoDiXAJKkTWb5 + b8u4/P/NPHsAliiz3CVAcS4BJEmbyPLflnH5/xt59gAsWWa6S4DiXAJIkqbM8t+Wcfn/63n2AFSQ2e4S + oDiXAJKkKbL8tyXLf5cfn5VnD0AlGe4uAYpzCSBJOk2W/7Zk+V/1ff+ZefYAVJRZ7xKgOJcAkqSTZPlv + y7j8PzvPHoDKMvNdAhTnEkCSdJws/20Zl/+/lGcPQAsy+10CFOcSQJJ0lCz/bRmX/7+YZw9AS/Id4BKg + OJcAkqSbZflvi+UfoHH5LnAJUJxLAEnS9bL8t2Vc/j8jzx6AluU7wSVAcS4BJEn3z/LflnH5///y7AEg + JwGXAOW5BJAkDVn+2zIu/38hzx4A7pPvCJcAxbkEkKS2s/y35cyZM1ey/H9Snj0AXCvfFS4BinMJIElt + Zvlvy9133305Pz4xzx4AbixfFi4BinMJIEltZflvi+UfgGPJl4ZLgOJcAkhSG1n+2zIs/33ff0KePQAc + Xb5DXAIU5xJAkmpn+W/LuPz/uTx7ADi+fJe4BCjOJYAk1czy35Zx+f/4PHsAOLl8p7gEKM4lgCTVyvLf + lnvuueeS5R+AyeS7xSVAcS4BJKlGlv+2jMv/x+XZA8B08h3jEqA4lwCStOws/205d+7cm7L8f0yePQBM + L981LgGKcwkgScvM8t+We++992J+fHSePQBsTr5sXAIU5xJAkpaV5b8tw/Lf9/2fzLMHgM3Ld49LgOJc + AkjSMrL8t8XyD8BO5DvIJUBxLgEkad5Z/tsyLv8flWcPANuX7yKXAMW5BJCkeWb5b8u4/H9knj0A7E6+ + k1wCFOcSQJLmleW/LefPn79g+QdgNvLd5BKgOJcAkjSPLP9tGZb//PgTefYAMB/5cnIJUJxLAEnabZb/ + toz/yv8fz7MHgPnJd5VLgOJcAkjSbrL8t+XixYtvzPL/oXn2ADBf+c5yCVCcSwBJ2m6W/+acy/L/IXn2 + ADB/+eJyCVCcSwBJ2k6W/+YMy/8fybMHgOXIF5hLgOJcAkjSZrP8N8fyD8By5YvMJUBxLgEkaTNZ/tuy + v79/Nsv/H86zB4DlypfZu124cOH8+P1GQcMlwOMf//jrHmAlScfvsY99rOW/IePy/4w8ewBYrnynDX8F + wGvWX29Udeedd149rA6PXJJ0+h796Ee/+Y477hinLJVZ/gEoId9p/vL/BgzL//CXqQ6PXJI0XcPFqkuA + 2vb29lZZ/j8qzxsAlitfZk/I8u+vXSzO8i9Jm80lQH05L70256a3yfMGgOXJl9hj82XmtFKc5V+StpNL + gPpcAgCwSMPyn++xV62/zqjK8i9J280lQH0uAQBYlGH577ruv43fYxRl+Zek3eQSoD6XAAAsQr6zHmP5 + r8/yL0m7zSVAfS4BAJi1fFcNy/+Prr+2qMryL0nzyCVAfS4BAJilfEcNy/8r119XVGX5l6R55RKgPpcA + AMxKvpss/w2w/EvSPHMJUJ9LAABmIV9Gj87y/yPj9xNFWf4lad65BKjPJQAAOzUu/68Yv5coyvIvScvI + JUB9LgEA2Il8+Twyy//3j99HFGX5l6Rl5RKgPpcAAGxVvnseYfmvz/IvScvMJUB9LgEA2Ip85wzL//et + v36oyvIvScvOJUB9LgEA2Kh81wzL/39df+1QleVfkmrkEqA+lwAAbES+Y4bl/3vXXzdUZfmXpFq5BKjP + JQAAk8p3i+W/AZZ/SaqZS4D6XAIAMIl8pzw8y//3rL9eqMryL0m1cwlQn0sAAE4l3yXD8v/S9dcKVVn+ + JamNXALU5xIAgBPJd8hDs/y/eP11QlWWf0lqK5cA9bkEAOBY8t1h+W+A5V+S2swlQH0uAQA4knxnDMv/ + t6+/PqjK8i9JbecSoD6XAADcVL4rhuX/29ZfG1Rl+ZckDbkEqM8lAADXle+IYfn/1vXXBVVZ/iVJ988l + QH0uAQB4gHw3DMv/f1p/TVCV5V+SdL1cAtTnEgCAq/KdMCz/37L+eqAqy78k6Wa5BKjPJQBA4/Jd8JAs + //9x/bVAVZZ/SdJRcglQn0sAgEblO+Ah6T9c/TagLMu/JOk4uQSozyUAQGMy+2/ruu7r1l8DVGX5lySd + JJcA9bkEAGhEZv6w/H/tevxTleVfknSaXALU5xIAoLjM+mH5/3frsU9Vln9J0hS5BKjPJQBAUZnxw/L/ + b9fjnqos/5KkKXMJUJ9LAIBiMtst/w2w/EuSNpFLgPpcAgAUkZk+LP9fsx7vVGX5lyRtMpcA9bkEAFi4 + zPJh+f8367FOVZZ/SdI2cglQn0sAgIXKDB+W/3+9HudUZfmXJG0zlwD1uQQAWKAs/182znGKsvxLknaR + S4D6XAIALEjm9peuxzdVWf4lSbvMJUB9LgEAFqDrun8xzm2KsvxLkuaQS4D6XAIAzFiW/38+zmuKsvxL + kuaUS4D6XAIAzFCW/382zmmKsvxLkuaYS4D6XAIAzEiW/386zmeKsvxLkuacS4D6XAIAzECW/y8Z5zJF + Wf4lSUvIJUB9LgEAdijL/xeP85iiLP+SpCXlEqA+lwAAO5Dl/5+Mc5iiLP+SpCXmEqA+lwAAW5S5+0Xr + 8UtVln9J0pJzCVCfSwCALcig/YJx7lKU5V+SVCGXAPW5BADYoAzYzx/nLUVZ/iVJlXIJUJ9LAIANyGB9 + wThnKcryL0mqmEuA+lwCAEwoA/X543ylKMu/JKlyLgHqcwkAMIEM0s8b5ypFWf4lSS3kEqA+lwAAp5AB + +nfGeUpRln9JUku5BKjPJQDACWRwPm+coxRl+ZcktZhLgPpcAgAcg+W/Psu/JKnlXALU5xIA4AgyKJ+7 + t7fXj7OTgiz/kiS5BGiBSwCAm8icfI7lvzbLvyRJ9+USoD6XAADXkcH41yz/tVn+JUm6NpcA9bkEALif + DMS/avmvzfIvSdKNcwlQn0sAgMgg/CtZ/rtxNlKQ5V+SpFvnEqA+lwBA0zIAP9vyX5vlX5Kko+cSoD6X + AECTLP/1Wf4lSTp+LgHqcwkANCUD7y9b/muz/EuSdPJcAtTnEgBoQubdZ1n+a7P8S5J0+lwC1OcSACgt + A+7Ts/yvxplHQZZ/SZKmyyVAfS4BgJIy2D4ty//BOOsoyPIvSdL0uQSozyUAUEoG2qda/muz/EuStLlc + AtTnEgAoIfPsWZb/2iz/kiRtPpcA9bkEABYtA+xTLP+1Wf4lSdpeLgHqcwkALJLlvz7LvyRJ288lQH0u + AYBFycD65DNnzlwZZxgFWf4lSdpdLgHqcwkALEIG1Z+3/Ndm+Zckafe5BKjPJQAwaxlQn2T5r83yL0nS + fHIJUJ9LAGCWMpieec8991waZxUFWf4lSZpfLgHqcwkAzEoG0p+1/Ndm+Zckab65BKjPJQAwC5b/+iz/ + kiTNP5cA9bkEAHYqA+jPnD17dn+cSRRk+ZckaTm5BKjPJQCwExk8f9ryX5vlX5Kk5eUSoD6XAMBWZeD8 + Kct/bZZ/SZKWm0uA+lwCAFth+a/P8i9J0vJzCVCfSwBgozJgPubcuXNvGmcOBVn+JUmqk0uA+lwCABuR + wfIR58+fvzDOGgqy/EuSVC+XAPW5BAAmlYHyxyz/tVn+JUmqm0uA+lwCAJMYlv8LFy6cH2cLBVn+JUmq + n0uA+lwCAKeSOfLhlv/aLP+SJLWTS4D6XAIAJ5LB8WGW/9os/5IktZdLgPpcAgDHMiz/Fy9evHecIRRk + +Zckqd1cAtTnEgA4kgyKP2r5r83yL0mSXALU5xIAuKkMiA+1/Ndm+ZckSYe5BKjPJQBwXePy/8ZxVlCQ + 5V+SJD04lwD1uQQAHiBz4en7+/tvWI8IKrL8S5KkG+USoD6XAMBVGQR/yPJfm+VfkiTdKpcA9bkEgMZl + AHxQlv/fG2cCBVn+JUnSUXMJUJ9LAGiU5b8+y78kSTpuLgHqcwkAjcnn/gMvXbp0z3oEUJHlX5IknTSX + APW5BIBG5PNu+S/O8i9Jkk6bS4D6XAJAcfmAf4DlvzbLvyRJmiqXAPW5BICi8sF+Wpb/3x0/6xRk+Zck + SVPnEqA+lwBQjOW/Psu/JEnaVC4B6nMJAEXk8/y+ly9ffv36o01Fln9JkrTpXALU5xIAFi6fY8t/cZZ/ + SZK0rVwC1OcSABYqH9w/kOX/t8bPMgVZ/iVJ0rZzCVCfSwBYGMt/fZZ/SZK0q1wC1OcSABYiH9T3uXLl + ypnxs0tBln9JkrTrXALU5xIAZi4f0N9v+a/N8i9JkuaSS4D6XALATI3L//8bP6sUZPmXJElzyyVAfS4B + YGYs//VZ/iVJ0lxzCVCfSwCYiXwe3z3L/2+uP5pUZPmXJElzzyVAfS4BYMfyAfx9BwcHe+NnkoIs/5Ik + aSm5BKjPJQDsiOW/Psu/JElaWi4B6nMJAFuWz92Ts/z/xvojSEWWf0mStNRcAtTnEgC2JJ83y39xln9J + krT0XALU5xIANiwfsHfL8v/r42eOgiz/kiSpSi4B6nMJABsyLv//e/ysUZDlX5IkVcslQH0uAWBi+UC9 + q+W/Nsu/JEmqmkuA+lwCwETG5f/Xxs8WBVn+JUlS9VwC1OcSAE4pn6N3zPL/i+uPFBVZ/iVJUiu5BKjP + JQCcUD44T7L812b5lyRJreUSoD6XAHBM4/L/C+NniIIs/5IkqdVcAtTnEgCOKB+Ud7D812b5lyRJrecS + oD6XAHALw/KfD8r/Gj8zFGT5lyRJWucSoD6XAHAD4/L/8+NnhYIs/5IkSQ/MJUB9LgHgQfKBeHvLf22W + f0mSpOvnEqA+lwAwGpf/nxs/GxRk+ZckSbp5LgHqcwlA8/I5eOLwQVh/JKjI8i9JknS0XALU5xKAZuX9 + f2K66+ongZIs/5IkScfLJUB9LgFoTt77t86L/9PrjwAVWf4lSZJOlkuA+lwC0Iy875b/4iz/kiRJp8sl + QH0uASgv7/mw/P/U+pWnIsu/JEnSNLkEqM8lAGXl/b49L/hr1q86FVn+JUmSps0lQH0uASgn77XlvzjL + vyRJ0mZyCVCfSwDKyPts+S/O8i9JkrTZXALUN+5Mt+d5wzLlBX5cXuQ7r77RlGT5lyRJ2k4uAeobd6fH + 5XnDsuTFfUTXdS+7+iZTkuVfkiRpu7kEqC871Cvz41F53rAMeWEfmr5reIGpyfIvSZK0m1wC1Nd13ffk + x8PyvGH+8sJ+w/rVpSLLvyRJ0m5zCVDfsFPlWcO89X3/+eM7S0GWf0mSpHnkEqC+7FYvyLOGecoL+sy9 + vb3V+L5SjOVfkiRpXrkEqC27VZcd6xPyrGFe8mI+7cKFC+fHd5ViLP+SJEnzzCVAbcOONexaedYwD3kh + H39wcPBL4ztKMZZ/SZKkeecSoLbsWr+WH7fnWcNu5UW8reu6l1x9MynH8i9JkrSMXALUlp3re/Pjtjxr + 2J2+75+3fiWpxvIvSZK0rFwC1DbsXnnOsBt5AZ9y9uzZ/fF9pBDLvyRJ0jJzCVDX3XfffTk72AfkOcN2 + 5cV75Gq1+tnxXaQQy78kSdKycwlQ18HBwS/kx6PynGF7uq77ivUrSCWWf0mSpBq5BKgru9iX5xnDdvR9 + /yHDfyfl+P5RhOVfkiSpVi4Bahp2sWEnyzOGzcr79rDVavUz61ePKiz/kiRJNXMJUFN2sp/Lj4fnGcPm + 9H3/gvUrRxWWf0mSpNq5BKgpu9nz83xhM/KOPfn8+fMX1q8bFVj+JUmS2sglQD3jbvbkPF+YXtd1375+ + 1ajA8i9JktRWLgHqyY72bXm2MK2+7z/If/BfHZZ/SZKkNnMJUEt2tKxq/TPybGE6q9Xqx8Z3jIWz/EuS + JLWdS4BasqvdmR+35dnC6fV9//HrV4uls/xLkiRpyCVALcPOlucKp7darX5qfK9YMMu/JEmS7p9LgDqy + s702P/xVAJxO3/cfu36lWDLLvyRJkq6XS4A6srs9M88UTm61Wr1mfJ9YKMu/JEmSbpZLgDLuSv4qAE6m + 7/uPXL9HLJXlX5IkSUfJJUANww6X5wnH13Xd947vEQtk+ZckSdJxcgmwfNnhvifPEo6n7/v32NvbW43v + EQtj+ZckSdJJcgmwbNnhuuxy75VnCUfXdd1Xje8QC2P5lyRJ0mlyCbBswy6X5whHk3fmEZcuXbpn/fqw + JJZ/SZIkTZFLgOXa39//vfx4VJ4j3Frf95+2fnVYEsu/JEmSpswlwHJlp/vUPEO4ta7rXj6+NyyE5V+S + JEmbyCXAMmWne1meH9xc3/fv4j/8b1ks/5IkSdpkLgGWZ9jpht0uzw9uLC/Jc8d3hgWw/EuSJGkbuQRY + nux2n5tnBze2Wq1+bHxfmDnLvyRJkraZS4BlyW53R54bXF/f90/yl/8vg+VfkiRJu8glwHJkt+uy471T + nhtcK+/Ic9avCnNm+ZckSdIucwmwKM/JM4NrdV330vElYaYs/5IkSZpDLgGWITved+d5wQPl3XhYOnf1 + LWGWLP+SJEmaUy4B5u/ixYtvzI+H53nBffq+/7D1K8IcWf4labqGA+vjH//46/7vJEnHyyXA/GXX+6N5 + VnCfvBQvHN8PZsbyL0nTNczTV7/61W++66673vzEJz7xuv83kqTj5RJg3oZdL88J7tN13Q+P7wczYvmX + pOk6XP4PuQSQpOlyCTBf2fV+KM8I1vJOPGR/f//s+vVgLiz/kjRdD17+D7kEkKTpcgkwW8N/1ttD8ozg + 6l/+/9T1e8FcWP4labputPwfcgkgSdPlEmCesvM9Jc8Hrl4AfPb4XjADln9Jmq5bLf+HXAJI0nS5BJif + YefLs4Gr//7/rx7fC3bM8i9J03XU5f+QSwBJmi6XAPOSne+r8lzg6gXAj4zvBTtk+Zek6Tru8n/IJYAk + TZdLgPnIzveKPBN4q7e6fPny68f3gh2x/EvSdJ10+T/kEkCSpsslwDxk5/utPA9a1/f9247vBDti+Zek + 6Trt8n/IJYAkTZdLgHkYdr88D1qWl+AZ4/vADlj+JWm6plr+D7kEkKTpcgmwe9n9PjjPgpblJfiU8X1g + yyz/kjRdUy//h1wCSNJ0uQTYrex+n5znQMvyEjx/fB/YIsu/JE3Xppb/Qy4BJGm6XALsTna/z8szoGVd + 171ofB/YEsu/JE3Xppf/Qy4BJGm6XALsxrD75fdPy/ISfMf4PrAFln9Jmq5tLf+HXAJI0nS5BNi+7H4v + zu+elg3/fZDj+8CGWf4labq2vfwfcgkgSdPlEmC7svv9cH7vtGy1Wv3M+D6wQZZ/SZquXS3/h1wCSNJ0 + uQTYnux+r83vnJYdHBzsje8DG2L5l6Tp2vXyf8glgCRNl0uA7Rh2v/y+admlS5d+Z3wf2ADLvyRN11yW + /0MuASRpulwCbN7ly5fvzu+aluU9OLd+HZia5V+Spmtuy/8hlwCSNF0uATZrf3//bH7PtOzcuXNvGt8H + JmT5l6Tpmuvyf8glgCRNl0uAzbn33nsv5ndMy/b29lbj+8BELP+SNF1zX/4PuQSQpOlyCbAZw+6X3y8t + cwEwPYdASZqmpSz/h8x/SZqmpc3/pXABgH8LwIY4BErS6Vrq4c/8l6TTZfnfHP8WAPyHAG6QQ6Aknayl + H/7Mf0k6WZb/zfIfAoj/GsANcwiUpONV5fBn/kvS8bL8b57/GkDe6uDgYG98H9gQh0BJOlrVDn/mvyQd + Lcv/dgy7X37ftGy1Wr12fB/YIIdASbp5VQ9/5r8k3TzL/1bdld85Leu67ofHl4ENcwiUpOtX/fBn/kvS + 9bP8b1d2vx/K752W5SV48fg+sAUOgZL0wFo5/Jn/kvTALP/bl93v2/O7p2V5CV40vg9siUOgJK1r7fBn + /kvSOsv/bgy7X37/tKzv++eP7wNb5BAoqfVaPfyZ/5Jaz/K/O9n9Pi/PgJblJfiU8X1gyxwCJbVa64c/ + 819Sq1n+dyu73yfnOdCyvATPGN8HdsAhUFJrOfytmf+SWsv8373sfh+cZ0HL8hK87fg+sCMOgZJayeHv + gcx/Sa1k/s/DsPvledC6y5cvv358J9gRh0BJ1XP4uz7zX1L1zP95yM73W3kecPW/CeBHxveCHXIIlFQ1 + h7+bM/8lVc38n4/sfK/IM4GrFwBfPb4X7JhDoKRqOfwdjfkvqVrm/7xk5/uqPBe4+p8D8Nnje8EMOARK + qpLD3/GY/5KqZP7Pz7Dz5dnA1QuAp4zvBTPhEChp6Tn8nYz5L2npmf/zlJ3v/fJ8IJ/SN7/5tv39/Tes + Xw3mwiFQ0lJz+Dsd81/SUjP/5ym73tn8eEieEax1XfdD69eDOXEIlLS0HP6mYf5LWlrm/3xl13t5nhHc + p+/7F47vBzPjEChpKTn8Tcv8l7SUzP95G3a9PCe4T16KDxvfD2bIIVDS3HP42wzzX9LcM//nL7veH82z + gvvkvXhYOnf1DWGWHAIlzTWHv80y/yXNNfN//i5evPjG/Hh4nhc8UNd1L12/JsyVQ6CkueXwtx3mv6S5 + Zf4vQ3a8787zgmvl/XjO+jVhzhwCJc0lh7/tMv8lzSXzf1Gek2cG1+r7/kl7e3ur8UVhxhwCJe06h7/d + MP8l7Trzfzmy23X58Y55bnB9q9XqjvXrwtw5BEraVQ5/u2X+S9pV5v/ivCrPDW6s7/vPHV8WFsAhUNK2 + c/ibB/Nf0rYz/5cnu93n5NnBjeUleRf/NoBlcQiUtK0c/ubF/Je0rcz/5Rl2umG3y/ODm+u67uXje8NC + OARK2nQOf/Nk/kvadOb/MmWne1meH9xa3/efNr43LIhDoKRN5fA3b+a/pE1l/i9XdrpPzTOEW8v78ohL + ly7ds351WBKHQElT5/C3DOa/pKkz/5drf3//9/LjUXmOcDRd133V+vVhaRwCJU2Vw9+ymP+Spsr8X7Zh + l8tzhKPLe/Pu/sMAl8shUNJpc/hbJvNf0mkz/5dt+O/+7/v+vfIs4Xi6rvue8T1igRwCJZ00h79lM/8l + nTTzf/myw700zxKOr+/7jxzfIxbKIVDScXP4q8H8l3TczP8ahh0uzxNOZrVavWZ8l1goh0BJR83hrxbz + X9JRM//LuCvdlmcKJ9P3/ceu3yWWzCFQ0q1y+KvJ/Jd0q8z/OrK7PTPPFE5ntVr91PhOsWAOgZJulMNf + bea/pBtl/teRne21+eFf/ef0+r7/+PVrxdI5BEp6cA5/bTD/JT0487+WYWfLc4VpdF33yvHdYuEcAiUd + 5vDXFvNf0mHmfy2r1eqOPFeYTt/3HzT8d0qO7xgL5xAoyeGvTea/JPO/luxoWdX6Z+TZwrS6rvu28T2j + AIdAqd0c/tpm/kvtZv7Xkx3tW/NsYXp5v558/vz5C+tXjQocAqX2cvhjYP5L7WX+1zPuZk/O84XN6Pv+ + BevXjSocAqV2cvjj/sx/qZ3M/5qymz0/zxc2J+/Zw1ar1c+sXzmqcAiU6ufwx/WY/1L9zP+aspP9XH48 + PM8YNqvv+w/xHwhYj0OgVDeHP27G/JfqZv7XNOxiw06WZwzb0XXdl4/vH4U4BEr1cvjjKMx/qV7mf13Z + xb4szxi2p+/7R65Wq58d30EKcQiU6uTwx3GY/1KdzP+6Dg4OfiE/HpXnDNvV9/1Tzp49u79+FanEIVBa + fg5/nIT5Ly0/87+ue+6551J2sA/Ic4bdyAv4vPF9pBiHQGm5OfxxGua/tNzM/9qG3SvPGXar67qXjO8k + xTgESsvL4Y8pmP/S8jL/a8vO9T35cVueNexWXsTHHRwc/NLVN5NyHAKl5eTwx5TMf2k5mf+1Zdf6tfy4 + Pc8a5qHv+6dduHDh/PoVpRqHQGn+OfyxCea/NP/M/9qGHWvYtfKsYV7yYj5zb29vNb6rFOMQKM03hz82 + yfyX5pv5X9v43/f/CXnWME95QT9/fF8pyCFQml8Of2yD+S/NL/O/vuxWL8izhnnruu4bxneWghwCpfnk + 8Mc2mf/SfDL/6xt2qjxrmL+8rw/NC/ud61eXihwCpd3n8McumP/S7jP/68su9dL8eFieNyxDXthH5MV9 + 2dU3mJIcAqXd5fDHLpn/0u4y/+vLDvXKvu8fmecNy5L393Gr1erO9atMRQ6B0vZz+GMOzH9p+5n/9Y27 + 0+PyvGGZ8gLfnhf5NVffaEpyCJS2l8Mfc2L+S9vL/K9v3Jn8d/2zfMOLnBf6J6++2ZTkEChtPoc/5sj8 + lzaf+V9fdqXX9n3/NnneUEPea5cAxTkESpvL4Y85M/+lzWX+12f5p6y83y4BinMIlKbP4Y8lMP+l6TP/ + 67P8U17ec5cAxTkEStPl8MeSmP/SdJn/9Vn+aUbed5cAxTkESqfP4Y8lMv+l02f+12f5pzl5710CFOcQ + KJ08hz+WzPyXTp75X5/ln2bl/XcJUJxDoHT8HP6owPyXjp/5X5/ln+blc+ASoDiHQOnoOfxRifkvHT3z + vz7LP4zyeXAJUJxDoHTrHP6oyPyXbp35X5/lHx4knwuXAMU5BEo3zuGPysx/6caZ//VZ/uEG8vlwCVCc + Q6B0bQ5/tMD8l67N/K/P8g+3kM+JS4DiHAKl+3L4oyXmv3Rf5n99ln84onxeXAIU5xAoOfzRJvNfMv9b + YPmHY8rnxiVAcQ6BajmHP1pm/qvlzP/6LP9wQvn8uAQoziFQLebwB+a/2sz8r8/yD6eUz5FLgOIcAtVS + Dn9wH/NfLWX+12f5h4nk8+QSoDiHQLWQwx9cy/xXC5n/9Vn+YWL5XLkEKM4hUJVz+IMbM/9VOfO/Pss/ + bEg+Xy4BinMIVMUc/uDWzH9VzPyvz/IPG5bPmUuA4hwCVSmHPzg681+VMv/rs/zDluTz5hKgOIdAVcjh + D47P/FeFzP/6LP+wZfncuQQoziFQS87hD07O/NeSM//rs/zDjuTz5xKgOIdALTGHPzg9819LzPyvz/IP + O5bPoUuA4hwCtaQc/mA65r+WlPlfn+UfZiKfR5cAxTkEagk5/MH0zH8tIfO/Pss/zEw+ly4BinMI1Jxz + +IPNMf8158z/+iz/MFP5fLoEKM4hUHPM4Q82z/zXHDP/67P8w8zlc+oSoDiHQM0phz/YHvNfc8r8r8/y + DwuRz6tLgOIcAjWHHP5g+8x/zSHzvz7LPyxMPrcuAYpzCNQuc/iD3TH/tcvM//os/7BQ+fy6BCjOIVC7 + yOEPds/81y4y/+uz/MPC5XPsEqA4h0BtM4c/mA/zX9vM/K/P8g9F5PPsEqA4h0BtI4c/mB/zX9vI/K/P + 8g/F5HPtEqA4h0BtMoc/mC/zX5vM/K/P8g9F5fPtEqA4h0BtIoc/mD/zX5vI/K/P8g/F5XPuEqA4h0BN + mcMfLIf5rykz/+uz/EMj8nl3CVCcQ6CmyOEPlsf81xSZ//VZ/qEx+dy7BCjOIVCnyeEPlsv812ky/+uz + /EOj8vl3CVCcQ6BOksNfG86fP39h/JsUZP7rJJn/9Vn+oXGZAy4BinMI1HFy+GvDcADMj3c3/2sz/3Wc + zP/6LP/AVZkHLgGKcwjUUXL4a8ZdhwfA/G3zvzjzX0fJ/K/P8g88QOaCQ2BxDoG6WQ5/zbgrPTHP/C3y + 983/4sx/3Szzvz7LP3BdmQ8OgcU5BOp6Ofy1IfP9zhwAn5Bnfo38r83/4sx/XS/zvz7LP3BTmRMOgcU5 + BOr+Ofy1IXP9v99o+T+U/zPzvzjzX/fP/K/P8g8cSeaFQ2BxDoEacvhrQ+b5T+QA+Pg881vK/7n5X5z5 + ryHzvz7LP3AsmRsOgcU5BLadw18bjrP8H8r/m/lfnPnfduZ/fZZ/4EQyPxwCi3MIbDOHvzZkfv/4cZf/ + Q/l/N/+LM//bzPyvz/IPnErmiENgcQ6BbeXw14bTLP+H8g9j/hdn/reV+V+f5R+YROaJQ2BxDoFt5PDX + hszrH8uPx+WZn1r+ccz/4sz/NjL/67P8A5PKXBkOga9ZjxgqcgisncNfG7que2V+PCbPfDL5xzP/izP/ + a2f+1zfO6NvzvAGmMwwW/0pQbQ6BNXP4a0Pm8x35Mcm/8v9g+cc1/4sz/2tm/teX2exf+Qc2J3PGIbA4 + h8BaOfy1oeu6H84B8NF55huTfxrzvzjzv1bmf32Wf2ArMm8cAotzCKyRw18bsvz/0KaX/0P5pzP/izP/ + a2T+12f5B7Yqc8chsDiHwGXn8NeGLP8v39byfyj/tOZ/ceb/sjP/67P8AzuR+eMQWJxD4DJz+GtDlv+X + 5cej8sy3Lv+85n9x5v8yM//rs/wDO5U55BBYnEPgsnL4a8Mul/9D+ec3/4sz/5eV+V+f5R+Yhcwjh8Di + HAKXkcNfG7L8/2B+7HT5P5Q/DvO/OPN/GZn/9Vn+gVnJXHIILM4hcN45/LUhy/8P5AD4yDzz2cgflvlf + nPk/78z/+iz/wCxlPjkEFucQOM8c/tqQ5f/757b8H8ofnvlfnPk/z8z/+iz/wKxlTjkEFucQOK8c/tow + 5+X/UP4wzf/izP95Zf7XZ/kHFiHzyiGwOIfAeeTw14Ys//85Px6eZz57+eM0/4sz/+eR+V+f5R9YlMwt + h8DiHAJ3m8NfG7L8vyQ/FrH8H8ofr/lfnPm/28z/+iz/wCJlfjkEFucQuJsc/tqwxOX/UP64zf/izP/d + ZP7XZ/kHFi1zzCGwOIfA7ebw14zvSg/LM1+s/PGb/8WZ/9vN/K/P8g+UkHnmEFicQ+B2cvhrQ9d135kf + i17+D+XPw/wvzvzfTuZ/fZZ/oJTMNYfA4hwCN5vDXxuy/H9HfpRY/g/lz8f8L87832zmf32Wf6CkzDeH + wOIcAjeTw18bsvy/OD9KLf+H8udl/hdn/m8m878+yz9QWuacQ2BxDoHT5vDXhsrL/6H8+Zn/xZn/02b+ + 12f5B5qQeecQWJxD4DQ5/LUhy/+/z4+H5JmXlz9P878483+azP/6LP9AUzL3HAKLcwg8XQ5/bcjy/835 + 0cTyfyh/vuZ/ceb/6TL/67P8A03K/HMILM4h8GQ5/LWhxeX/UP68zf/izP+TZf7XZ/kHmpY56BBYnEPg + 8XL4a0OW/2/KjyaX/0P58zf/izP/j5f5X5/lHyAyDx0Ci3MIPFoOf23I8v+N+dH08n8ovwfzvzjz/2iZ + //VZ/gHuJ3PRIbA4h8Cb5/DXhiz/35Aflv/7ye/D/C/O/L955n99ln+A68h8dAgsziHw+jn8tSHL/9fn + x2155jxIfi/mf3Hm//Uz/+uz/APcROakQ2BxDoEPzOGvDVn+vy4/LP83kd+P+V+c+f/AzP/6LP8AR5B5 + 6RBYnEPgOoe/NmT5/9r8sPwfQX5P5n9x5v86878+yz/AMWRuOgQW1/oh0OGvDVn+vyo/LP/HkN+X+V+c + +W/+V2f5BziBzE+HwOJaPQQ6/LUhy/9X5nlzAvn1mf/Fmf9UZfkHOIXMUYfA4lo7BDr8tSHL/7/K8+YU + 8ms0/4sz/6nG8g8wgcxTh8DiWjkEOvy1Icv/v8zzZgL5dZr/xZn/VGH5B5hQ5qpDYHHVD4EOf23I8v8V + ed5MKL9W878485+ls/wDbEDmq0NgcVUPgQ5/bcjy/+V53mxAfr3mf3HmP0tl+QfYoMxZh8Diqh0CHf7a + kOX/y/K82aD8ms3/4sx/lsbyD7AFmbcOgcVVOQQ6/DXjS/O82YL8rs3/4sx/lsLyD7BFmbsOgcUt/RDo + 8NcMy/+W5Xdu/hdn/jN3ln+AHcj8dQgsbqmHQIe/NuTw98I8b3Ygv37zvzjzn7my/APsUOawQ2BxSzsE + Ovy1IYe/f5znzQ7lMZj/xZn/zI3lH2AGMo8dAotbyiHQ4a8NOfz9ozxvZiCPw/wvzvxnLiz/ADOSuewQ + WNzcD4EOf23I4e8f5nkzI3ks5n9x5j+7ZvkHmKHMZ4fA4uZ6CHT4a0MOf/8gz5sZyuMx/4sz/9kVyz/A + jGVOOwQWN7dDoMNfG3L4+/t53sxYHpP5X5z5z7ZZ/gEWIPPaIbC4uRwCHf7akMPf38vzZgHyuMz/4sx/ + tsXyD7AgmdsOgcXt+hDo8Fff3t5ezn798/K8WZA8OvO/OPOfTbP8AyxQ5rdDYHG7OgQ6/NU3Lv/PzfNm + gfIIzf/izH82xfIPsGCZ4w6BxW37EOjwV9+4/H9unjcLlkdp/hdn/jM1yz9AAZnnDoHFbesQ6PBX37j8 + f06eNwXkkZr/xZn/TMXyD1BI5rpDYHGbPgQ6/NU3Lv9/O8+bQvJozf/izH9Oy/IPUFDmu0NgcZs6BDr8 + 1Tcu/38rz5uC8ojN/+LMf07K8g9QWOa8Q2BxUx8CHf7qG5f/v5nnTWF51OZ/ceY/x2X5B2hA5r1DYHFT + HQId/uobl/+/kedNA/LIzf/izH+OyvIP0JDMfYfA4k57CHT4q29c/v96njcNyaM3/4sz/7kVyz9AgzL/ + HQKLO+kh0OGvviz/XX58Vp43DcqzN/+LM/+5Ecs/QMPyPeAQWNxxD4EOf/Vl+V/l8PeZed40LK+C+V+c + +c+DWf4BcAhswFEPgQ5/9Y3L/7PzvMH8b4D5zyHLPwBvke8Fh8DibnUIdPirb1z+/1KeN7xFXg3zvzjz + H8s/ANfI94NDYHE3OgQ6/NU3Lv9/Mc8brpFXxPwvzvxvl+UfgBvK94RDYHEPPgQ6/NVn+eco8qqY/8WZ + /+2x/ANwS/m+cAgs7vAQ6PBX37j8f8b48Yabyitj/hdn/rfD8g/AkeV7YzgEvmb9FUJFd95559Wo68yZ + M1fy41njxxqOJO+M+V+c+V/f+Bm+ffxYA8CtDV8c/pUgWKbxX/n/C+PHGY4lr5D5DwuVz65/5R+Ak8n3 + iEMgLMzwr/zn8Pfnx48xnEheJfMfFsbyD8Cp5fvEIRAWYlz+P2n8+MKp5JUy/2EhLP8ATCbfKw6BMHN3 + 33335fz4xPFjC5PIO2X+w8xZ/gGYXL5fHAJhpoblP4e/Txg/rjCpvGLmP8yU5R+Ajcn3jEMgzMy4/P+5 + 8WMKG5FXzfyHmbH8A7Bx+b5xCISZsPyzTXnlzH+YCcs/AFuT7x2HQNixcfn/+PFjCVuRV8/8hx2z/AOw + dfn+cQiEHbnnnnsu5fD3cePHEbYqr6D5Dzti+QdgZ/I95BAIW3bu3Lk35fD3MePHEHYir6L5D1tm+Qdg + 5/J95BAIWzIs//nx0ePHD3Yq76L5D1ti+QdgNvK95BAIG3bvvfdezA/LP7OSd9L8hw2z/AMwO/l+cgiE + DRmW/xz+/uT4cYNZyStq/sOGWP4BmK18TzkEwsTG5f+jxo8ZzFJeVfMfJmb5B2D28n3lEAgTGZf/jxw/ + XjBreWXNf5iI5R+Axcj3lkMgnNL58+cvWP5Zmry65j+ckuUfgMXJ95dDIJzQsPznx58YP06wKHl3zX84 + Ics/AIuV7zGHQDim8V/5/+PjxwgWKa+y+Q/HZPkHYPHyfeYQCEd08eLFN+bw96HjxwcWLa+0+Q9HZPkH + oIx8rzkEwq2dy+HvQ8aPDZSQ99r8h1uw/ANQTr7fHALhxobl/4+MHxcoJe+3+Q83YPkHoKx8zzkEwrUs + /5SX99z8hwex/ANQXr7vHAJhtL+/fzaHvz88fjygtLzy5j+MLP8ANCPfew6BNG9c/p8xfiygCXn1zX+a + Z/kHoDn5/nMIpFmWf1qWj4D5T7Ms/wA0K9+DDoE0J8v/G3L4++DxYwBNykfB/Kc5ln8AmpfvQ4dAmjEs + //nx9PH1h6bls2D+0wzLPwCM8r3oEEh5ly5d+p0c/p42vvZA5KNh/lOe5R8AHiTfjw6BlDUu/+8/vu7A + /eQjYv5TluUfAG4g35MOgZRz+fLluy3/cHP5qJj/lGP5B4BbyPelQyBljMv/U8fXG7iJfGTMf8qw/APA + EeV70yGQxcvy/9s5/D1lfK2BI8hHx/xn8Sz/AHBM+f50CGSxLP9wcvkImf8sluUfAE4o36MOgSzOuPy/ + 3/gaAyeQj5L5z+JY/gHglPJ96hDIYmT5f73lH6aRj5T5z2JY/gFgIvledQhk9q5cufK6HP7ee3xtgQnk + o2X+M3uWfwCYWL5fHQKZrSz//9fyD5uRj5j5z2xZ/gFgQ/I96xDI7IzL/3uNrymwAfmomf/MjuUfADYs + 37cOgcxGlv//Y/mH7chHzvxnNiz/ALAl+d51CGTnhuU/P95zfC2BLchnzvxn5yz/ALBl+f51CGRnLP+w + O/nsmf/sjOUfAHYk38MOgWxdlv/fzOHvPcbXENiBfBTNf7bO8g8AO5bvY4dAtsbyD/ORj6T5z9ZY/gFg + JvK97BDIxh0cHOzlx7uPrx0wA/lMmv9snOUfAGYm388OgWxMlv9fzeHvXcfXDZiRfETNfzbG8g8AM5Xv + aYdAJjcu/+8yvmbADOWjav4zOcs/AMxcvq8dAplMlv9fsfzDMuQja/4zGcs/ACxEvrcdAjm1LP+/nMPf + O4+vFbAA+eia/5ya5R8AFibf3w6BnJjlH5YrH2HznxOz/APAQuV73CGQY8vy/0s5/L3T+BoBC5SPsvnP + sVn+AWDh8n3uEMiRWf6hjnykzX+OzPIPAEXke90hkFvK8v+L+fGO42sDFJDPtPnPLVn+AaCYfL87BHJD + ln+oK59t858bsvwDQFH5nncI5Bp5J/5nfrzd+JoABeUzbv5zDcs/ABSX73uHQN4i78L/yA/LPzQgn3Xz + n7ew/ANAI/K97xDI1eU/h7+3HV8LoAH56Jv/WP4BoDX5/ncIbFie/c9Y/qFNGQHmf8Ms/wDQqJwDHAIb + ZPkHMgrM/wZZ/gGgcTkPOAQ2xOEPOJSRYP43xPwHAK7KuWA4BN65PiJQVZ7xq/PjrcfHDmD+N2J8xreP + jx0AaF3f94/PAeGO9VGBaoZnOzzj8XEDvEVmw2O7rnvlOC4oJvP/x81/AOAaOSc8JofAV6yPDFQxXuw8 + bnzMANfIjDD/CzL/AYCb6vv+0TkEvnR9dGDphmc5PNPx8QLckPlfi/kPABxJzg0PzcHha9ZHCJYqz/Cb + 8uNh42MFuKXMDPO/APMfADi2HB6+cG9vr796mmAxxmf2heNjBDi2YYaY/8tj/gMAp9L3/cflMHHu6smC + 2btw4cL5PLNPHh8fwImZ/8ti/gMAk8iB4n0ODg5+cTxjMFN5Rr+WZ/XU8bEBnJr5vwzmPwAwqZwv3rrr + uu9dHzWYm/HZ+O/4ByY3zBbzf77MfwBgY/q+f/a99957cX3sYNfOnj27n2fy3PzN28ZHBLAR5v+8mP8A + wFbkwPE0f0no7g3PYHgW42MB2Djzfx7MfwBgq3L+eFT6ojNnzly5ehpha/b29g66rntRDn+PHR8HwNZk + DJn/O2L+AwA7lUPIB6xWq9eOZxM2LL/rn8/v/Bnjrx9gZ8z/7TL/AYBZyLnkETmUfMHFixfvXR9TmNrw + ux1+x/mbjxh/7QA7N8wk83+zzH8AYJZyQHmnruu+fm9vr1sfWzit/C77/Piu9OTx1wwwO+b/9Mx/AGAR + chD80NVqdcfVEwwnNvwOh9/l+GsFmD3zfxrmPwCwODnDfHQOMT+9Ps5wVPmd/Xx+PGv8NQIsTmaY+X8C + 5j8AsGg5yNyWPjGHmjuHww03Nv6OPjH573QGFm+YZcNMM/9vzfwHAMrp+/4juq77/vHf10gMv4vhdzL8 + bsZfE0A55v+1zH8AoAk57Lx3zj5feunSpd9ZH4Pas7+/f3b4D8zK7+Ip468FoDzz3/wHABqVw88j02fk + IPTyvb291Xg2Kmv4cxz+XIc/5+HPffw1ADTH/AcAaFgORE9KnzP8+yBzUCrzXyM1/LkMf07Dn9vw5zj+ + 6QIwMv8BABqWc9PbpWd1Xfct+XluOEgtyb333nsxf+zfl7/5nBz63nn80wLgFjI3zX8AgFblEPWw9PQc + pP7ucKga/r2TwyFrTs6fP39htVr9RP7ml6aPzh+rv7wT4JQyT81/AICW5YD10BywnpqenQPhV+fvv+ry + 5ct35+dWjP9crxr+uYc/huGPJX//oeMfHgAbMsxa8x8AgOFgeHsOYx+cPj09Pwe0r0zfOhzW0l0HBwe/ + nsPbb1+4cOF8/v4DDP+z4X83/N/k796VhgPetw7/GMM/1viP+cH5n98+/tMBMBPDbB5m9DirzX8AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAICteau3+v8BeYaFKishyPMAAAAASUVORK5CYII= + + + + To start monitoring mode, please start this application with the following command line "-Monitor=<time interval>" +If you start it with "-Monitor", without sepecifying an time interval, the monitor runs once and then ends. This is usefull when starting it periodically from the Task Scheduler +This is an Single Instance Application, so even if you run it multiple times, only the first instance is actaully running + + + 227, 17 + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAGFSURBVDhPYwCBzOb9/9V8lv4vn3DiP1iAVADSnNR9779b + wfH/FglbSDdEPWDVf//a2//dSq7996++/t8sef//+MZjxBukGboBbIB5zpX/FtmX/7uW3frvUHjlv07s + 7v8di68TNgjZAJgh1mX3/jvV3f9vU3D+v03WYfyGaEVt++9RdQesEaYZ2RDf1rv/zQvP/U/sOI/dIJgB + loXXwdik9A4c62VfA9OOjQ/ABhlnHP3fuew2qkG68XvA/jbKuQ3WAMKGhbfAGs0q78GxU8Pt/xFTn4Fd + A9UKASADrArv/NdMvwrXDNJg2/QYBXt0PwUb4FR9FdMAmO3oml26n//3n/Lqf/TC9/9DJj4F2z5t40M0 + AxL2ofgXpBHkZ5jG1OUfwM5Pm3wPeyCCDACFOMzPIANAmkEag6e+AAceVCl2ADLAvuo+xPb6h/8jZ74C + +xUkNnPXW/yaQQBkACi+Qc4G+dOu6hpu52IDoED0aX0ADl3PahyJBR9IaD/zXzfxAGboEgQMDAApg1gQ + B3mXnQAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAMbSURBVDhPVZJrSJNhFMf3qb73ua9RRGlFRREECUoXwQqK + EZXaXFrR/UJBUnQj6QLdiyiCwqIb5XRam9bcpltlZc05s7xsbm1zc+7d9j57b/0777uVdeDH4Tm8//97 + znke3Z8oPmqrKD3nspSdd42tOOPiKTONC2p2s7JznWxlndOz5KD90sx1jyflZROx4rTDHuVYLDzGyfF0 + FvHUBDFOhaE3xKG2wY/yi77M8p3myXlpLladdUZj42m5c0iEe1iC2y/BNSTBOSjA1p9FizeNrAQ0+njU + vhiG4XIP/59Jycm3fDIjoCsg42NAoizhvWYioP17Fq+9GTJQ0BWS4Q6KOGX2o+hIW31eTh3UdbBQIotP + ZPB5RMKnEVkzezcswvFDgLWPx2AkrY2SYhIiiQyKD7dLeTntoM7Fdr2MoPx5GB76i9Ecw7aGGBwDAnUh + al1YqIsmTwqmL0mM055KTjiYJp55zD+l6IZP2WceReXDMLw/FRhJfMgSQ/XTKGzfBHQO5kxav/Gw0B4S + aRElJzuYruD0oH7dkwjb2xSFoT4MZ78IX/gXnD8kVD6JQK1vJNMrrxNQF2yncVSjOBkUnyCDNQ8DySMt + MegfBOHwcfCSuJdQuzB189hQH8LBhgj0d0a0UdROOogoJ6LoOBlM29+nL7sVZNsfh7HpdgB2n6CJ7f0C + Nt0LQq2vp/pV8xi6/DLeq1dMcLTIxYecuR1MNXimLD3erRjvB6G/NIyvQQUb7wRR8+gnym8E4KAdfCTx + B8JNb8NFBkxUsGCPLWegxqIDTlZxeQil54ewvpGh7Lofy+r8WP2Mx1oT01jTQPU8GUHGnN2vJgwW7rOx + QJxhV7uCez7gbi9w2wvcpHyd8jXiag9wxQMY2ySkaYTC6qZ/Otj7JtMXTPyqeaOgupXeAX1U1SZrbKGz + oZVuxSqhQj1bZXAZpswub0zl5TrdvBrrwEgyw/WFksrAKI+BKI/veUZTooa6+RSTMcbxCstmx6dvbu7J + y3W6+TWvdhRWtVjnbrXEC7c2sr8YcxQYTTmqTGxGVXNi1pbm1oJKs+E3Qz7PPjvfPHcAAAAASUVORK5C + YII= + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAHcSURBVDhPdZLdK4NxFMeff4RcqBVl8hYuhJS0mryrlfeR + mDZXaC6IGZmXGxdeosSNUi5IuyMXYs28zqyWMKEQyYXUse/Zfs+ehzn1vXmePt/vOb9zpFg1POcifdcW + 5TZsskotTrIteCjy+/8CWNS2TV0TZ9Q56aeakQsq6/WwSsz7pDVsk23pNLYREhsHDxnMN51QWusxFZhP + WRntJ5RtOufveW17VN6zqzZBMuBmu48yjB4WDN4/v1kwgLLMXjZKbz2g0VV/1ARtI1kJA1AaAM6y+Fi5 + 3R5KbdkLGyAdM4u2BaxMFaCs3gB/5y4wu0hXGigrxXTJ0pqvVEZVA26SsCa8tjBIDinBcESJDVETGURy + SDn911RoDVBmhytsgDUBjKs8YAHWGM8iODGcN3QnK98WpDLHHb+FhCOBgYCRDhgtixJQ8dSTrKaFR+5c + woVht7/TfxsA0s08k372lapXPkIG9zS+HgxvAhemrTuk+Fo3G2AczC1KwOWLbwz3OT9IZw9E7wDnmVS/ + SxpD2CCp/SKCRkskW3e+qHPthRwbj+prxHnCRHQgXl20XzH/ysmADdM3aliUfdnLJsIAqyodu6X62Qee + GW3/SY5VuDAcCfacYzni15YfTFWS9AN6YDUl3q/NbwAAAABJRU5ErkJggg== + + + + + AAABAAUAAAAAAAEAIAB/UwAAVgAAADAwAAABACAAqCUAANVTAAAgIAAAAQAgAKgQAAB9eQAAGBgAAAEA + IACICQAAJYoAABAQAAABACAAaAQAAK2TAACJUE5HDQoaCgAAAA1JSERSAAABAAAAAQAIBgAAAFxyqGYA + AFNGSURBVHja7V0HXBTH938LAoK9G7vGDth71Ni72CtgjcYYExONUQ/zT/KLYEvUGFM0Ggtg7733giUK + ctiNRqMmdkU63P7f7BW23u4hx4E3389nr8zOzr6dnfnOmzdvZhigoKBwWjCOFoCCgsJxoARAQeHEoARA + QeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARA + QeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARA + QeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARA + QeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQZFD4RMa + 5AIMWwqrcVusyfgNbnikAsv+B8Aewd+39QEzDNbSoARAQZHD4LMyyBVc2C4sMJMZhm2M1TiX+RwLpFJz + nwYkgotIEHMgzWWjfkhwqlxalAAoKHIQvMN0pbHW/oYVt5spCGs7E88Cewt/32dYKMMyUAl/ezGm+o0R + jiAdDNMHhvwtTo8SAAVFDgFW/ioMA7ux2r5LqjVW7Ehs7UPA4LJPHxj80hzPJ3xKAZZ1aY8/p2L8uhgf + eYH9By/oFBMQEsNPkxIABUUOAFb+Yvh1lGGYGliZUb2HH7Hy6vQBIYlK1/iu+Cq3IVdaCFbz8RjXBa/7 + izEwTZEsHpnjUAKgoMjm8F01lTEYmFCs/P4sF8LOYVmY4oL1F9V9D/ydB1v6IvjXA0/G4fl/gWXiYwKC + DT6rglxYlp2DFf1zThNg2bVIHoNiAkO4pCgBUFBkc2Dr3xQr+FGsrm7Yip9i0lza6odMT8Twr7EGj8FK + XIJU7vQr2OdICruRHSZja/+PT7jOHQnhGMZtjCcNSALNsStwmsSkBEBBkc2BFXg1VtWBWLFZVP47YOt9 + gIR7hwetwAo8hAsHuIRBSXhUwbBCxqrNHjOw0PpyQIjBJ1TXEVw4+wEZJAjVBwQPIWlQAqCgyMbwCZua + G+vsHayqJbD1v46Vtxa23qSi8wngKf4trfcPSfIJn1oUu/u78H9DPFhs7ishAdyptez/GIN76l+YTgUM + f4p6QAl9YEgaJQAKimwMVPNbYJt9GCuuK/79Ve8fPNZ8zgcJADgCwAoNLEcApvDZ+DUJuBFAtiqG3+TC + w4KWY5M/1Hw5phVDCYCCIhvDO1zXjwFmHfmNGsCEGP+QeennLBrAc/zrg937VJZ1qYO/lyFplMLavx1/ + 98RrOG9A77Cg8Rg+35TWQAxfSwmAgiIbA/v/g/Er3NRbH4et9s/mc2YCwMpMLPqxDOcKzHiS//h7Af7+ + P4z/Kj2toJH4tYT8xguGx/gHL6cEQEGRjYGVtj9+rTX+Yz9HdX6++Vw6AUAynruBQXnxKI0HcQ0man97 + bOXv8OJ/ivF/5FICdhCeW0MJgIIiGwO7AC2AuPIC44K19hd9QPDH6ecsBEAqvzex+KGKPxiVhT8YYjNg + YRnGH2GO7xMWtAzPDeOqPwu+MQEh+hxHAN6rdC4My816siI7NwRi5b91YOakYuakar6AB59QnRu4gKsd + swDVOzY52n+G9gcywXfVFAb7iO5gx9Ef4qUW4z8jOSPX+oRPzcWf2KINtr1bSGNS9EOC02yWLUyHxQ7c + sIK5vNH9rYDlso9JjgkItiRYM0znhfe8jRW6OJ69hv382vqAGWZjH2cENBMAqvQpGIbysdj6MxWJ+y+W + lYp6/xmp2P/HJNib+FEJw59hWiVIGc8xBOAdpquAeT0Af3ZBoQtDphfi9BfJEm8qFnZh2K/4Mh6pXem7 + 7Cs3NpfhPUzCHzO5LgbltmNWECH/wY/FeGy77B+iWpi9Q4OKolx+KF9ffMqymZ93AuFI5Y/AX/OQCG6o + 5t2qrxgDm1YLBRqE17ZijGqs/TKPZZ4xDLvGYIDllwND4lXzLlyXB2UifvVEvmqMUb3mIVMJIA0/rjMs + M58xMKeih07nEsayv45hmH7GUT3ojBV3n1E2oQZACMAU/jOGj+WaMhaq6ANCbuFztMfKvweMLsFrUP0f + ZJY+WwMf3g0F/xgL8DQUt0hW3df0Ss9iBnXV+wc/UYrnExpEZmctZBm2G2Nz6/VGEhpQxm+wxZjObzFk + 8q87yvUjylgx62Qj4rEPUShSWKMU827ltLzgymIpZ0ejjJ5ZJprRaLbeBQxDov1nJinKFxZUF9/rL1gG + Ggs97ewuXwJ+BGDebTLKoWuJ7++AyRMwAs+1wXMJGP4Hhgdi+A2WZWtjWIopfn8MDwNSvw3MB/i0qzGf + D2MeNyMaGmOA1vrAkGMA2ZwAUP1xQX2GuDsGmcZBsxyYYV8jW/5P7hyyagn82oMZW8dBsiWiiueNKt5f + CvL1QdlC8WeWVS6RgNuxD+ondwqJMzdXSBno4xjRuAk1vbHSbFWQrw4q+zvAaFRzhHz4Tlkf1KISfMOm + uRjAsBa1gL6mcz+Y5gKUxPwriAFE67qBLT3XEPiGBRGiqEZqNz7lc/z+EPlrGpkejOFbmDSmN3aDsv9c + AHwJ7UwvwcNxUrBnGCatWfTgWYKVVWqvnsykGlyXYQYOdWw2sgF6/5BwcShWflJwo5gs1JpkZHuFeVMe + NagXEvnCdOOwQP/kONm4irQMyX2EONxnZZAX6wKHGKPvvAPFY+tjpb5I/pB1AFCe46RvD0bdfgF+f4Xy + xyolgP1+JFl2ColHjIh4zT383RSvuW+Ok20JAPsx2OKzO1DwTo6UAzPtNn7Vwkx7zQ/3CdfVwq/TmIVe + DpWPZadiKzZTHI4EEEymizryFWMTQ6aqkr6pQEPxCZuK/XzmErZKWdstkWI/klMHcSBWnD5YcdZxlncH + AsvecCx3y83/kZhqs67sVpSrPGvspOrxmINa4H7sCj5iUeEH44JABfC7Jf6chKTRDLiWHx7id3d8F3/y + 75GdCaAUZsF1fNg8WuJ7ueYCLzcPyO3qBm4uruCK7448XJIhFV6nJMGL5HgwZMBWY/K/Jv0rwbxrrGCf + o2xztaThim8hH8rm4eqO8uXi/udCGVMMaZCUlgqvUhJQxgwZzgkBfIay/cgP813+lYvBzXANn7+yLWmR + /CrhlR+K5s4LJXLnAReU8xXK9SgxFu6/fgHJBpuN58TIVg0r2T/8QCTPdni3/VoS8MT8cnex0vuTscEl + oZyJaeqDOPhud2IF6yYOR/lWYcKDbH1Ygny53Ll8s2RAWgq+Z0NGkiLy9Ub5NgtkC9NVxoq+GO/QimeX + eIpx7+A3aaTIKE85PEoxxvMsZzcAGIFpXZXLvmwJZOFOxtVPrKNJ8QrwSe32UMwzP0cAlsqPF5OHS8NO + UEJqMtyLfQpH7l+FLX9dgMeJcZrlwMzbhRnXVSqfbivew8/ateT+wY17gk/RcpDf3RPcsTAT+YhkpJAQ + k24qyheXkgjXnj2A/fdiYM9dPSRoKLw8+fxQvu0i2cqAcehIk1EyDxbajuW8oVuF2lC9cGn87wEuLsbG + j8wzS0Z57sY+gY03z8EmzD+t8mG9fMIYoKw+MFhInmG6LzDv5mhJI7hxL2j2ThXN+UGwWH8IVt88r0XC + Wdh9miKQbRU3dRa7TlDdppsiCMmHth8FBdzTlcIJx8Ph4tP7tiZFkIrvthK+23viE9j45MbMHYDveBz+ + rYXv2V3m2YhB8DLLMr/h75XYSMiOeGRbAvAJC/ofSveVWrzPsfKP8H5fU5qkMD+Mew5fRWyCs4/uaL0m + GDNvGj8MC7AHyqbHjLfawpbNUxA2dvkEPN20mTCIfH/+dxu+PLUOSeq1titYqIzyCVRsb66FhX2MiuWa + nGxduhp8VqcjVMhfjCNNNfkuYr5NOrUWHiWoyydHnjXDdOQ2W1A2P7XrCVmu6TgGqhZ6R1P+ERiQUIft + /x0uPrmnEpNTG3oiAQiMgPhuK6OAkfhTk+bJx7uYh+s6j0Wid+P+xyUnQJft8+BZkupoo1ze3cePqkoV + 15SXpGBV5WwVLEOMfvnAuCDINTzOujDs1ejBMxOt3Sf7EkC4bgOKp2oh/uX9AGhR2jay/i/uBQTsWwT/ + JsSqxsVi0hf7TRuFsk2tyGIfFgux1THrNli55rcMkFQsUkhJZXIxaSqC+2H43r8vIQmsVx1dxkLyN0av + ejkgRNB/QAL4H8pmlTxJ5Rpfqy34V3+P647YIp/+6T344NAyiE9NsS4fy36LBfgbYd7pyIjEJVAhT4JS + 2B3Z0X0CuLlqH119nZwIvXctgIfxr6zGw7wjeVYPCUqwRp5pvHwvZKBu9KhQC75r2s+SZ9efP4SBe3/j + uno2g4X9YGA66YdMz1j/QSOyJQHgSyA6VJRaC5sXVdfN2MKWzFuI+08K5+Log3Di4Q2IxcJZ2D03NCn5 + LvhVqg8lsTXmY96F3fDH1ZNqopDVVmtiIRGspuoTNrUnyzCbGZXs+6BGCxhft6Pl/4X//oKfovbD0+QE + rnKX8SoAHcr5QJeKdcDD1GoQpGKB6bZ9LtyPe2k1fdKHBc6wEyLgCsy/rdZaWNKnno6qdSdU+c2FleTd + nVePYdedSDj24DpXuYvlzgM9KtWDrhXrCkiCxF2E+fyz/ogV2bjC1R/7/+sFebcyqDi4wl3QMLLT/J13 + 4dfWwy3/SeU+8fC6hRj53X+Gs32x8Aw1pzn4btNY6/TJDbMZ3WEFLSxqAP+HefKtmmxy+KpBN+hftYnl + /17Myy9ObchIUkS+b/G9fpOhi21AdiUAUvGvqVlhy+crjATwqaWFeIWqVq+dP8IjUR+/Yr4i8EfbkVAU + WxQzTt2/Bh8eDVWRxDgCoBeNAGAhIXpssNpz/NxyMLQsU9Py/9dLB+AXmUozvHoz+LxuZ0FrOwLV2HOP + /7aaPlbEECzAQfwwk4p9B/OunNJ1U+t1hkHVmlnul2YwwKprJ1G2wxJjJInhh0TxbZPe4MojgReYx12Q + pGJT5P1oiDMLyuCNBHBblHe98b4bQQOGo4wT6nex/D/2zxX4+Fi4lktVgfLtwArWXRyOZW8byt09I2ku + bzsC6peoZPn/3ZnNsO7WnxlJirzbAfhu12XKw1pBdiUA8tZ3qrWwHcvUgDktBlsK8rXnD6D/nl8545oY + U7DQE3XXDGJ067vnF6vpYyHZjYWkizgcC/F2vGc3a9eSVnZ7t8+gFE87+QjV5pP/SX12Snnlgy1dPxPY + CkYiAZxVIwBgu6B8AkOpT1hQJWBIH1DeANipbE2Y+d5ArMzpRr4FUfvgjysnZPONgOTuzKZ9UFOpawkj + cccfXQlHHsh7+5qWoa4onlNB1rHDvPsGVEDuSbp3zXnduxWXj8P3kXvVLtUElG825t1kQd6F64gaFoV3 + r2FregXw3W3r/jkUzp3eKxy2fzH8+fhuRmRLIz77SJ62X2wjsicBhGEflmFUDYBf1u0EgTWaW/7vun0R + Jp+Wb1w+9m0NY3zbWv6fwNbkI5XWBF/EFCwks/hhPsbuyXXMOqseYmIDYAK2lJ22zYVnSdIRiFKeSADd + 0gmAVMruO+bB37HPrMgGpBZWiBFt9oB51wXf6g45A2B+7BKRLlNxrwKWsH13omDS6Q2Kld+MRsXLw9J2 + owRhf8QchXlRSqN57C69yADou+IrhnU1bEL5eoIKyHDp+s4fc8ZJc56MR43tMHZPMgFkaKyrmDwx76qb + DIA2O555F34HwjqMsXSV4rG7QgyAT5O0jzjxQFoJsmJPQmY8rDVkOwLwDtWRhn8XvghVB6DfWgXCe6Wq + cb9JAZlxfhusvnFO9iF/bD4QWmN/24yfseD+hgXYKli2hz4gZJtAvjDdu5hglJp/Qvsy1eGHFv4W7eTO + y0ecxpEkM4TWulRVmP9+oGX8+DpqJwP3LbJqPMICfBcMTNWYwGCBDm6NPMf6tOJI0CxTLHaZeu5cgF0m + dYs+0WiO9Z4KedzT5zltQ/U26Mxm2fgoH/FSm84P8wmfmocFl8uMcZzaKkoiKe70m2CxqJOh3L67foK7 + r5+ryqoGlC2eYdla+oAZtwR5F67zw/e6NSNp9sRu0v+a9rXk7SXU3gIPLFElVgX5DuBHR9Se7GoAJMh2 + BGBqYaPUrMTEALil6ydQIo9RxSaW6xGY4XIqV+k8BWBdp48hv4dxfDYNK9bIA0vhzyfKGhZXSMCAfdiZ + d/jhWEh6YyFR7cOSyvZRrXaW/3vuRMIkGYOQB7Z0i1sNgXqmviNHZOeQyG6eU7vFWmwhBooDUT4y/Nde + Lr/29JgIBTzSeWuJ/hD8eOmQpvdCnJe2dx0PZfMXtYRt/+sC6CI2yWafyYlli0i2sljgbpFJLWr3a4eq + /zzsApjxKP4ldMUWVYuDjwbcxuLig+QpMABi2SMTzr7LSILfNvSD3lUaackbDWB1qD3NyIwHVUO2IwBs + waoii17Bn1YNgFULFIcNqM6aGZczAO5aIBmfJi3XTGTmdtj6m+NGI0kMPbhUrYW9ih91JR6AYUEzMJkp + oIJfWvpDizLpXckfLuyC5VdPCeIQxxFd/W7QtWIdi2zn//0LPsK+tVpBV7ISYyX7h5HpnnQv7wvBzfpb + 7pOC6XfZ9oOmoVACop1s6fopVDSp5ARbb52HaWe2yMRmE5EBamDe3RHJ1hNl2wwa8KF3SxhXO91L9/i9 + yzDxlLJNjLSzWskBSXYTyiYYYsZyRzRPQp7tNCUiQnj70VCrWLpiE4z5suaWFmckWfm6ony7MnSxjch+ + BKCxhe1czhtmN0/31ox5co9Tm/kg1v/PareHVmW9Leo18Wr7FPuSJ/+9ZTV9rGDbsYJJhtJQPmKc7GLt + WuK+StRX4p1oxi9R+yDyidEj1jOXG9Qo9A50r1iPMxKaK+Xlp//AOJRNk6eiAbroA4OFBsDQoCpIm5dB + MmcdYF7zAUiCvpb/UaiiBuz/XfN7yeXiAgd7TILCnvksYUo2ALJRJRJAlcsBouHJMB2SJ6NKngS/igyA + pAtAPCaV8NeLRzDqyApNKrecf4Jp6Jn4dryrOVNMyI9ETgy+5rwhWtygvb9AzLOHtiZFQDbuqITy/Z2R + i21FtiMAn7Cgb1Cqr9XiTa7bCQJ4BsB/417A4X+ucH1sL1R3y2Pl9y1aFiubu6WCkW7C4ujD3HCXBieb + L5EABO6qWIDzomxXGRUDIBme3NB5HOTOle6hyS+Y5kznt8Y7bl+EuZH74EWyJrtPMhaSslhIBIuVoHz9 + Mcm14teai3HB/vsUyOeR7qK6MHIvLLp8XPN7KYrXHug1RTB68OWJNbDnXowkrhUfe2z9GVUDoBcSJDFW + lspbWLN8G2+cgW/ObdcU12QAFLSwSABVweh7YvNiLvWLloM/2n/AOU4RvMZ32G3HfHhqg8s5T7qrWFLq + xJiW+LY3shUB+IRNdWGBIRsgNrcWj7Tmf7QhY67aJ5ORlp+MwxPnH02tBLCd8CUIxpxQ/a+OOXaRUVnx + p12Z6jCXZwC0BlL5vz69AXbejQGD5pVl2NsYtYY+QFhIsBBPxzsGiV9rZey3b0T13YXnVvHR4eVw4uFN + zfnXsWxN+L7FYJ7cadBr53z4W8Yoh+QQhOQUwg/Dd5sHM+Sa2ugJQXHPvLDb7wtu7oRWfHtmE2y4dUFL + 1Fgyzx772AIDkE94UD/8ytC4e59K9eDrxr0s7zvy0W0YemApZMSCh+WOGCF7iZ277IVsRQCmFpb42Je3 + Fo/0nbeQ4SyRd58ciMGP+K8vuLSfU8G15SqbgPF88CUIp7GG63rg1xa1bPuibkcYWqOF5X8Sqq9JaSnc + VZ65PCCXqGA/iX8FQ/YvhntxL0Ab2LVYgOUMgAcx79qIw5uWqASL2gwXEFKfnQvg+kvV1c4s+KpBV+hf + tanl/71Xj6EbpiElU27Zqg5IAAdFspEW9pqabwdBZ+yyzWo+0CJvfEoS/Mn5RJjuZXIz5P9eELkfrr74 + V0ve3Ub5vMmKOiL5/g9ly5AHoNgAuOHGWfj23LaMJEUeZ1qMf7Cqk1lmIXsRQHgQ2deMGACtrv5TvWAJ + WIcqtrmApBpS4XHcS07lJu6gxEvtduxTuPr8IRy7fxWuYUFXcw3lA9OIwo8GMk4sP+I9P1W7/jfsv77H + 678GY2EgsxBJdudB9bZ/5YYwyqe1wMd97bXTMP3PndrkY1kdyiawEpsW1LwPZPFIEdqUqQHzeQ5TBF22 + zkHCeanhbsaRin1+EwX9f+IKvBC7UzJ5l4gf1cV9WO/wqT0ZcNFkABxfux184N3K8v/QXT2Mx+5GJmG9 + 3j+4vzhQiTzV4IJZuq7TWKhWqJQlLOTsVi2jODLgZvmTpbwPZNbDqiFbEQCqYYH4tVItXvfytSDkvfR3 + SAyAZMyVMTmHm6fZZhT4GjbiS+grDlcaYuPDy9UNdnT/HIrx3I7l3HpnN+0LnSumryR24/m/MGDvr5om + jiABdMMKJmALJKcq+DZjGJkhtrZlasL8loMFYT22z4O/Yp9qyo+BSFg6bOXMBJKUmsKNyd95LXVUwry7 + 4ZLsWi16+HcCxkXtaQ4Wty+03O+XlgHQokw6gc67uBv+uKI6b0MTUL4v8N3+IJAtTJef5B3KV8bW9Aq6 + e8K2buOhkMkDkNiZ+u78CW6ghpQB2QwMsBX0/jPUpjJmGrIVAWi1En9ZpwME1mxp+b/2egRMP78j0+TA + dzglJjBY5AFInFiYK1jBylq7tkqBYrCmU/qU0PiUROiybS48FU0JFau5L1Fr6bj9B4hTWRjEtA5gSSwk + guYbySkQZZMlz5alqsLC9wMFGsAY4pasMhJCkN8tN2zo/DG8w3NpJhOGpih4XGKEdfqAkAH8ILK2I956 + jxp5EpC1CbZ1/dTSvSP3I6M2RzLHA5DkX2ckgD2CvOOmAEM0ZMAA2KBYOVjaLt0ASLTP7jvmazXmioWL + 4ZYBC8waAyBBtiEA71AdWcLnEBZSq5P7iUPKqg5joGaRdFtS8NktsEbTAhCaQJxY3sdCIjCRYyGph/Kd + UVtkQ+wBqEfthAy3pYk0ktpFy8DK9qMtBYfYCdpsmQ2vkq1O3zb7J5AVisRTgGeibJPlrvEpXArCO34k + WKlm1dWTMOOC9fVWSHSyIEe3ivUsz0Ms3INQU7mj6KbMBun9hQZA0xDbdbXRE4KySDTbun1mcaklQ3+9 + dy6AByrTe7WBfYmE4hMTMEOwQhG+28H4fBmaZTQI+/5EOzKDDK8OyagHIAurYwKCB9t84Rsg+xBAuC4/ + CkOsxCWtxSP+7FuxhShqGmMnU2cH7fkFrr74L1PkwAr2Gj98pH1YXX8GpENsYujqd+Fm2pmx8/ZF2dbS + FwkstP2HgmG1FhtD4KVqy8FiHzZE2ocN0x3AQtxW7orcWJkO9ZosGAaMxfuQiqXkCET6tmO9W8No3zaC + KcNz/twBodfPKMlmAAPTWh8YfEyUd2RKZIwWAyCZrET8O8z3vP3yEfTA7gabgQolI99l4tyll5LnHEZj + 90SM/2vQDfrxpgCHIbHOuqC6kJW8dMBOw4YnywyABNmHAIw+9tcwF1yVpCIFqFqB4rCOeACawp4nxYGf + FZWLMc0aZyXh8ts5YPwoJo1pED1kutgAOA/L5GfirDOnbL7P0jYjoCFvSuj0s1th3a3zXDyGd12NQiVh + FbbKrryhufaoAfyb8Epg4JYANWIkJ8FqujXDp3qi+kRM+nlB5lqS3rcNe0Cvyg0FSRHtZMLJ1YLFM0jc + kl754Ys6naBD+VqC+GSy1dQzmyStG69iJ2BFfRflE3jAYN71xSjrxa9Vbl4/599RPX0U+NA9PXx2Yi0v + /2zb88l83rRewAasYP3EcZAADuD5tub3Kd1XihGUIPPzEm2UdFfK5kt3j56O2uhafN9KFYvlj2DwZDSd + a4V5pzJBJXORfQggXDcKhVkMvArLyLzegZWFKtfVZ/dhwN7fuCvEBUr8LffwMoUpFAvJEH483/ApDAsu + x/Bcc0YQG4BfjIkHIGcA5HkABuz7DaKe/iMhomoFSnC2Av5CG72RyG7GPpEUPgBewWShPRYSgZXYNIsN + +7DEA5DlF3iLpGXyFIJNSJx85yQComKfxP715af3ILerO3hjn7Zh8YqSeAfuRnOaDFlkVfrkpv8s3EQC + qHo5ULhtmbGFhS/U2nAi8y/vB0LzUlUtYXOJC/W1U4rvkV+Arb1jU7zxqD0tEOVdIaMBEBTXHZN7XvK7 + WO68sKXreG69R/M7IsOrxAAoV/aUiN0UToaeK2DZ0z42mwnITgQwH4UZL9cqGP8bRQ1CFXsAbzx6xZXj + 8EPkPst/Y0URDRIDCCoDSBgdeNdDUIy0D5sP4xArcVlBTNGVPoVRre/woaVVT0hN4iawPOFm2zEW2ch3 + +bxFuOnCHryhwOH7F8GfvLXsxOSESMSwUiifwPvGJ0wXwDIQym/teNucWdCtXC0IbtZPYAtQA7Fqr7h8 + DBZEHxLYMYRPb8ljyTr7PqFBRKM7zjJsU0ZA7nwY84T4d+zAClXYRKAk3oeHlkEEt4aCdQoXE774vOl3 + e71oiA3fLZmwEclwq+kK36dM/vOflfMAXNZ+lKW8PUHtrQcSwCuTy7Jc5U8vB+m/TbiMBFrvckDWGQCF + cjkQ2MK6YAt7kOWWOhYKx38JxKWVTLqoWSR9tObriE2w+Ta3d4KMom9Oh1E8J8oILOFsY73/DIFF0Ts0 + qCHjwkawvAlKcq1R1/K+MLNZugE88vEdGMZ5hLGyrQfRFrxypU89//z4Kjj4zxUQV17evSLxRyPzFlAW + +cJ1P2GcceJr5J6wSzkfmIr9Vv6sQDmQdKJQ/rkX90Dk03/kfG/krpmEBPC9QLYwXR6MTFwOS6q9BzLB + a2OXdDeLeCTQXpwB8KWkpVdr+WXwijGwvvrAGQIPQMw7f0wrjL+0mDFNaariCj2iRgtuQVUzyFqJxODL + rakIfEKSErJM+VmJeTdU26NkHrIFAdQM1RXGuk2WlimspDIZvejcYSL2TfOa5qQTw9Bv2DLdef3UFF/6 + 8qz1p8VqMv56DkYvMWEfNlynyT+hM1auVrwlwIgH4tqbZ0HudRPVn8wE9OKtArQZ+45neCsGyaiK67AF + GyC+L8p3CM+1Fl8jbnXMKOThBX0q1Yd2ZWtCxfzFIZerK3ch8UF4gHl5/MENOHz/ClfxQSY9hQpoMO1Z + J+jDGrsnxLlLnYS9C70DQ3gelE8TYmH2xXSDmsz7UnzPkm4gy1xwSXZtcGnE/8T+CQvx62MxAUg1AGnZ + 6lmxHjR9J33WegR2pTbfiZSRJT23lOQHGfLMCmQLAsBCUg4luUHWNxeq6nKVgK9CWTcIyatdUlheFMuc + ZtJcWkQP/U7gjYPyfYlfs1SbQAWIWwCJYmrlGURhATEy24BhISatWlm5/AKZtPjwdHXjFiTlptOmJkOi + IVUUX75CiGVjWCB+zOX0AcKtqlC2Pnh+g/gaubxQSttavqq11Dz8jnk3Wibv1uJXf9l3wHtJysQgTzp8 + KIXxnoE4ADVEzVPTZIbMRPYggHAd0emJV4rF8qTM6OLKLDSSAe86oQqmqhmwZOQLW9jfJPKF6Sbi1/dy + uaVWSOWgtQKI7vEMDEzNmMBgyXgn5t9fjHE/eJvvryST+Iw4bYkGwGIFC5BWMJStO8bdJpe2ktotpzpL + rwFNFdEUloy/2+C7lbgTonyr8WugwnWiSi1vw+DLKtcFUyqDlmdn4TxjYN6LHjI9Y9tDvQGyCwGQ4Ss9 + ClPeSh9JVmgFY5RMXHnDGC+hcwzDYiGZIVkfy7iSLWxMjyqVR8niy1d9xS2EtcIsFA3JiWUm6gOC58mJ + 7hMetBnvoTrNVk0Gfn6qDZsKr2eI32vjGNEKwFzehevKMcb9693lKix/aFSJoGXIxuQnwIKW8oInViF5 + BsYMCZb4h6MGQLbJ1YnTUCIqsYyswm/+deZrxc9oipuCIV2y0v9fdP/sAZ8w3UyUZjJfLC2GO2GmC7Ne + y5CRKew6a1xfX9bf1Dc0qBDrwpLOfGW569WGezIyfs27jhTaRRh5vF5k/LPkXXgQqrAsaclcZK5XVaPN + sTLoakNU/0Fi91ozkDzJKADx0+6kNoxnS56JNUJxWrx5g0dYlu19OWCG7FRLlK8GXkg8m/KJ72vN0Chu + WLTYXsR5zm1OwsJkloUfLwdmzfRfqSzZBD4rg/JiJVuNzN4ZTLMBtRrzbH9oSzeCOOivwp9fY+V6YO0a + LCjv43Xh2BSXYkziWGu1zVDyR9BAAAZs9x9i5/pb/PlHjP9MxVlCNUKnuri6MHMxvY+A142yCpNAYgOV + DfmMhZc5jN9TYgKCI1XyrgImvBnTrsUanQwVNQ85Mfl5rDH/SHfuBcsyP2P+zURysroyh3dY0HCMNx9/ + 5lfShJRIXVLJOe1EmZxM6aayZFiZBbKzc8bcBjMJ2YYACGqGTnVDAmiKUpHWorCKoloIv/vzzxpPMXp8 + ASetWFuNL4BlIhgwHNcHzPhbs3xhumIMackYaMKaSEqpv4q/GuBXfUmhZWEDPuNTa/SBshNH+wOotp7F + Pr+WTQI5eIdNrQXGDUvLSJ5bWsMC8a+XqEKR4RSLwU6hAJMAPcPCEUhjruiHBmuadomy5WFYlzZI8mS0 + QrClutjZCfEu3qSdDBmRRRWjhZVJ0rWLxx9HMfS0PkC7Uw02QBVQf+qGBO/NcDZNYR6ItIGu5jzmaatJ + GJfMWU7kx5SxH/yNHwfxbyQSU5b3+cXIVgRgC7DvhgWJOWQuBjwWnoAZO+8Nks4UYN93GX4NEwUnMgam + ij5QuF12VgOJrDCS2H+Mae1AXgXbgnnXy5GyEWDeBaFs00XETYimHcp32JGy+YRPxW4WcwFlqy06pcej + QVYt5ZVZyLEEgIVkAgrPzesWtWKdlfqjWSZbmC4XGdbEnxXMcpnkJGpf/Zgs9vYSA8mzLcpyQNLCskie + AY4nT5QvFGUKEBXOWNY4Scvuu+VYg2nEirhdi5ej2oqNUK/L/jM09J6yD3IkAfiET0MVzUAWXRdbvl+C + sZA4tIUl69+DsUXgfFp5Q0ThSE4Bb5R4ZsgXpvsMRZonY4DriPLty1CimQRsYT0wx86jLJZdXEzEfhu7 + ENX0AdNT3iD5Nwa+W7JW+V4ZA6FkoZGcgBxJAN5kX3QGyJpLviIDWzQqinVjAkMysB9z5sEnNKgVuLBk + TTyLVd5USCTzDN4QxA5ByIZs2ke2SMqr5aL8TWr6uZco6CsIRH56eSrm55QnL7WtE2YnuObzzFOodd2x + +ELd+RmX+iru+osjUevfIOlMQR6fCnU9K5XqIrbsxsXcWZdwS2GjxMwBKdPEB4QYXMnS7y9Bk63WOnIm + ARhb2Gt4ePIfAlXEdTEBUlfZLJeP2wATvpGMtxvgfSSnYxlP2QKSLFkz63M8iNGvhKOfmSLLQFw1SRdk + MR5k6PeNCNsmAsCKR9SyUeYL1Rw5lMZOrbvvps+aU/KsQpTCcMmafYizGC9C3jtQ+qjiGYJ8g6LQqq88 + VKYwVETmlnuL7ooMzizDs7y1wdItzNIxAfHzm54pLQ0eLNtT4PmRqA7IeIpTWCneehAiIFrmWDBuJpoh + 2EoAnOFN3hXSus9z+s3kpuIq+3TLpW/NtVJ8veq4MW/c1vxbfE+lNNPDrHsZMhLp1SeyyKZlYOH58Wh4 + uGIvsEkO7QpTZB/8CcbG8E5GLraVAJbgBSPlfLiVCADAygwtnghqBACSNKT+43Jx5WSQxpNqDFomqoAo + LsikLYwrbfG1ykgQf+M+/D1nLRjirK8bSOF0IG7qZC1Bm/0KNBMAVn5XLJFkriPPOqu9FVZrTcUTUOQc + ebS6aco9HKtwnlVIV6ObrqoMWqBJ00g1wN9z18PrKPWVfCmcDqTiEwJQ3VNTDFsIgMzVf8jKzNgzw1pF + VJnsItEK5GafWZu9xqrG0Ta/QIv8wEuPr9Ired8paRJKBCQXN+Gvh3B7epis6l+hYkXo7z8IfLy9Ba69 + FNkbriznNajJk9JgMDBbtmxhN2/e7JmWlib3ksk2dt3xsKlvqLm0+ITryFK3J5UrufpEHAWDngVqLblq + 1eX5t8st4miMYp1YlOS1ZQagfBdA2l0SX2ON1B5vOwWP1h6RyFm2Qnk4fPgwVCpfQS13KHI4WMSMGTPi + v/rqKy/8Ka5GxO2Z7E+m2bWdwBYCmIQFcXb6heI+uLRPbsvsN1tVb83xeFNHJRkK6lqMKkGIErE6e0FF + C1G0DWDgvZ+3wKvTlyXXfD9/Hkz4dDxQOAeSk5PTateunXjt2jXxmm5EkyCN9Blb0rOlCxCKXwHWEspI + P1hLC2xNYLkhRKV41mwI2oYopZJYt3/ID2WqGRjF92LTTP3/SGn///jJE/Be02ZA4Tzo3Lnzs71798rt + nU4WKLTJk1MTAZA53diIEg8kHzUruzlcsXDLtJhaCUBN3WYUq6z6kuGM7F2URiDS09ayJJVcX18JsgTH + GQDXweso6XDvyTMR0LRhI6BwHnTr1u3Jrl27isqcIlPpbZoHo40AwnXFTQZAF76RTmlOtGyl5tUAteG1 + N+lvq52TPc8z1ikRgBZLvdpQqJZhUNlriQbwAyUACiMcQQDvY8Qj5v/W5krzwYriKBsB+QYyYastVduF + eoc1jUS6GKeUGpRGHsRkII5nbRRAjgjENgCxh6LVJc3T0igBUFjgCAKYhF+zpZVYrkCrt+BKlUvNqMYo + 3A8EcaQyyGkq8sTCSp5PzR9BLiPV3HrF6YFaONUAKHjIegII0/lizNKK+q0ZPLdaU0Eeg989TKfMYWRW + E5nEIpg5xZgisXJSqY0fysihFJdHNHlQ1kX4q4jo0kv4NVnxOlvux3czFsdTeCbuPsZ47+HvaWBdA2BP + R0SkNm7UyE1jzrxViI+PT/vtt9+Sd+3e7VG+QvmUiZ9PgJo1a3q8ecrZG1lOABmBaeWU3ViWO4hOPcbC + XyEmICQ+Qwlnnnzvoh5BlpfyNIeZ6uTiGP+QDx0pGydfaFAI68JO5f4oawBsREREUqNGjWze1z6nIy0t + jR09enTCsmXLyPvjynGZMmWSDxw4YKhatepbnR85ggBQa/DE1K/iDcqZw0wV7DzLQKPLgx2zCqpFvnAd + WU9wrSRDWGacPiD4Z0fKxskXpjuA+Wfc7psSgAS3bt1KrlOnjltcXJygDI8dO/bVwoUL82c03ZyAnEEA + 4bpqmPgVSNfuzQbBX7GFHZuVGaYg3yz8+lIUTKZY1kb5LmcgyUwDWeXXxYW5A6bdfigBSBESEhI7bdq0 + fOLwChUqJEdFRbnky5cvV0bSzQnIGQQQpuuDqYu2hOIIYChWMNV99uwN77Cgvdjci7snj8C4N+ATh8oW + riOr9ZANSt05mwAlAAGIN1zz5s3jz58/LyEAZE7YsWcXdGrXISNJ5wjkFAKYyTASY1oqsExzVLFtclfM + bGD/ugA+uZ5l2DKi0YAzDBiaRfvP1DRBw15AAiBbVa22BFACEODSpUtx+MzuSASyxk//4UNh5dI/3tqJ + UQ4hANNS0v0Y44wjsoWXFz8BmQ49WaYqjzmOqYKRr3tgVLWVZvClscZdes8yLMzRB6qvAlszVEfc/clU + uOH4txGmUYK1rNvPG99Pd/jJhT/J6q4uogyIY8m6a9ZHEZLw9EOMsxb/kC2dVSfn+66akptNcyXryA1E + Wargd35lXwHum5y3vGBrjkCnzkSwTRo2ejtLugJ+/Hkh+/knnyo+c5HixSAyKhJKl3g7F0zKcgLwCdP5 + sQz8BMY+KaOWmBZvPetCmZxtWOYfYNl2SALXFGULDcqLLXkIXvIB/vVUchFW8lWwNidAxXef7NwThkJ+ + gCSgOAXTJyyoHsr3O/6sA6Ktu8yyGe+hvLAJ9QNIR2paGrTv2AGOHjqsHAkzccmK5TAiYIijxbULspQA + sAAPxgK8FH/mVk5Aectu41nlveE1TMJZixVsoLxsOk+MvQorYQ/WlJQWAlBasYfvPWjN5YF3zsCy0CUm + IGSvXDzsBjXAiLswbjFraxnwf8sudkIJwIJbd25D3dq14XWs9Q2T2nfqCHt27jLNBH27kGUEgBWsArb8 + FzBSIWvefVoIQOxVr1VLwGsfYVtbVR8YLFn9FMlpEpLTLP5zyHv9KbsjW5u7b22uH2+68RwkAPFoAqr9 + 0/KwrOE4Xl9Xac1AJW9GST5TArDg598XwScffqQaL3/BAhAZGQkVypV3tMiZjqwjgHDdHCyQX6hdZG26 + q5aJPEoTbUxxyF5vdbCSCTwHUTYyHTKSNQ+VgfUKpTbvXylzlFpuHnaghtJdfK13uM4f44eanAG1T/2V + kyGbEUBqWirce3AfPHN7QslixbPsvimpqdClR3c4uHuvpvghP8yBKZ9PzNK8yQpkCQH4hgblYl3Ym1gg + y8tdJKuqZuDGcgtliObdx2Iz66sPCPmbH4oVrCNjeli5Sk5UP3fGRXDHNFQlUg2szKQfniym6/gyJRsM + INYGePKvQwKQ7EWABLUOv/op5Q//+T1cXK17WCMB3JyzBl7JrAeY1QRw/dZNCAgIgOjIKHB3d4cRH46C + 2SEzwC2X/b2Rb975C+rXrQ+xGvcuadisCWcryO3+dnkHZwkBYAUjJtR7DLd0mfQiuT6rloUu5IWQEoB5 + YhCeuwNpTFX9UOGWUFjBvsGvr833FctXp0hZ+On9QIFs154/gDFHVkIKa5CRwYhK+YvBH21HQC6GG0SA + yMd/w7jjq0CJABCT9f4hs/lp+ayc5om5dguveEetq+GChLO+40dQ3KuAIF0+qZGWb1DffnBg736J3FlJ + ACz2d/r16webNm2yhJFx9+UrlkOAv/13PAtbvQqGyNyHcc/FLZnOpgo3hMrt5QVHTxyHhnXqZkn+ZBWy + igBI67UuYwtzKKv/oBCPS0N+zYCN2MIKNgGpGTYVG2qGPGgHcXrmzwGVG0BQwx6C+6Ua0mDI/sWgf3Yf + 5GYGcjlYzhdmvZfeoIddPQmzLkq3cOc9tx/Kt12Ud+/iVxSIhkHlrq+Yrwis7/wJuLsqO66lIgH06NED + du+WypGVBHDhwgVo2rQppKQIBz2aNGkCJ06c4MjAXiDk07d/P9i8cZPk3AfjPgIv7I4s+H6u5NzU/5sG + wd/8L0vyJ6uQVQQQjK2vztEPi9QerPefMU0kG6lYF1G+KkpXfdvQD3pXEVYMUojCr2GFvqCcR2N9WsFH + tdpZ/n8TsQk2/nVBITZLfAJqIAHcFsgXpvNDgtqq5ek6l/PhCMeatZpUOGsE0KxR40zPdcmTYt4NGzYM + Vq6UOnG6urrC/v37oXXr1na7/+17d6FOrVrw6oVQ/Xdzd4NDR49CHk9PaNq4CSQlCTde9q1dCyIiIjiC + eFvQtWvXLCGALVjBetiSWOYDS52B6aAPDD7AD/UJn1oVRY/BQ7bZdMOWaH2nj+HdgtIt8/6JfQJ9d/8M + canSoXuSGSvbjYQ6xSty/4nG0HvnArgd+1RJvsvYtNfXBwidgTDvZmPeTdLyhB/7tIYxtdry5HsKMdhV + EcyfTkuFr0d+CuePnJBcn1UEcPfePahWtSokJsr7PXXs3Al27dhpNy3g12VLYOyIUZLwGr4+cOb0acjl + 4got27SG8xFCJ1MG5dl7cD+0b9XG7nmUVbA7AWABJmv//4uFuJBjH5V9jeXfB1tYgQEQ+/99UPQNSlcV + yZ0Htnb9FAp45JGmiJzy2bEwOHRf6luU182Du87cH38U/xJ6IQG8SkmSvxELO5g0xi966HSBho/5tx3z + rpuWJ1zSeig0fiddkfk5aj/8FnNUeBuVFYHsTQAkz74Mmgrfz5ilGMfNwx1Onz0D9WvVyfT7ExtI1949 + YP/2XZJzE6dOhu9DZnK/Q76fDUGTJEs5wMiPPoQlv/xm1zzKSmQFAZAm8BYDjvWiwD76PfyoHBMQItjy + COX7CmVT7NjVK1oGlrf/0KJW33/1GErnL2Y5f/BuNHx+Yq2kX14pX1HY0GUcuJn641GP7kDggSWKRk2U + b3KMyABomgZ9A+UrrfZ8HnifvX4ToYhn+pyWTw4vhyMPbwrv42ACePzsKVSu9C68UrG+D/tgJCz7fUmm + 3//fx4/A18cHnjx6LAgnrfuOfXugS9v23H/91cvQuGFjiH8tdBIqXb4sRF2MgiKFHNyeZRLsTgBqLWxW + AStYOFYwgdnXZ+U0F3BhD6PkLZWuG17jPZhQt7Pl/48XdsHY2h0sFftVUjz03vUT/JcQK7iuZ8U68F3T + dHvj4uiD8FO0ssspytcB5ROY5pGcvDHvzjMKnpN8VMpXBNYh4Xi4GofQklKTofXm2RCbIlSzHUkApPX/ + btYM+HpqkGpcr7x5IfqyHiqVzVznm9Xr1sLgAVJn0OreNeHP8+ct/fvklBRo26E9nDgi1KAIUazftAH6 + 9Ohlt3zKSmQFAczFU587+kGxgk3FCjaTH4YVjCz2EI0tbDml64Ib9wK/d+tzv1Ow/zxk32L4ocVAKJU3 + fSn1kHPbYPWNs4LrJtbpAMNqpvPK5JNrYdff0UqyoVbCVo/xnyEyAAb5Ya5uYQBUtadu5XwghGcAvPPy + MfTZvRCSDcLhLEcSQHxCAvjUqQW3r9/UFP/r4O/gG900TXG1gPhaDwoYDOtWrZGcmzDpC/hh9hxB2NLl + y+CD4SMkcQf6D4ZVoWFvhWuwXQkAKz8Jw84W08nBz0l2Quos9rMnQ2wo4FXrBsCx8G7Bktz/h3HPoSf2 + 46fU6wK9Kje0xNM/uQuB+5dAKs8nYGXbkVC3hNEAmIaVsA9qCbdeKS4NEAkGppE+UOKfMB9l07RVzwTU + SoZ7pxPO/r8vwYST66QZ4UACCF27GoYMHKw5fpkK5eFSZCQUKlAwU+7/+OkT8K1VC/578FAQ7ubuDvsO + HoBWzVsIwu/d/wdqYfwXz54LwosWLwYXLl6EsqVUe2bZHnYmgKmojzKP8MicN5hhsC+x710TNYAHAvnC + goh3j+KCIiWwP72163jI427UwKOxovujBkCG22byWtvktBQYvOdXuPbyEfe/IMbfgteZ++P3Y59ia0xG + C+R3XEYNQNYDEAnqAGonbUEDxAZAYps48eCGJJ4BCWDVFzPgZsRFyTl7EgAhwY6dO8PBfVIHpP79+2OF + ugA3bwg1AzIKsGrtGhjQt5/W21jFxh1boW/3npLw0uXLIdFEQeGCwmKahnnVZ+AA2LpBulHub8uWwIfD + Rtolr7ISdiUALMA1sAA7dEksAtT8bjJpTA390OmpIvlmonyTla6rW6QMrOiQbgBcd+00fPfnTijsYRwZ + KJg7fWRgxeVj8H2kcScl4pCzscsnFjvBuX9vwchDy6x4NbJBev+QEH6IyQPwOhjXGrCKPLncYE+PL6Cg + zEiFGI7yAzh1NgJaNH2P7EwrCPfy8oLLly/Dnn17Ycxo6fqpjZo2gRPHjoNbrjdblYvcd/DwobB2ZZjk + 3NDRI2H5InmD46oN68C/n4SboV3njrBr2443lsvRsDcB9MQKttnRDylnAKwZpiOeswdRvlZK141Blfrj + 2kYHQWLA+r+IjbDldiT3oAtaDIJWZb0tcf9+9Rj67f4FElAb6FK2Jsxqka7q/h59CBbgoSAbcSJsid0T + wcC8d3hQPbJID8qn6hhfOX8xWNv5Y6segGY4ggBI5es9sD9sXS9tSUeMGAFLly6Fh4/+A19fX3gqss4T + x6Ctu3dC1/Yd30iGFy9fgrevDzy4948gnGgZ2/aQ9OV7qWTUoHbt2vDo4b+C8Hz588O5P89DtcqK/mM5 + AvYlgLCgn7GSOXzRTqxhnyEB/CiQLVxH9L3LWMEUl3qZ06wfdKpQ25gG1tOh+3+Hi0+Miwp1LucNs94b + aNEOONdg7B5EP7sPk+p2hCE10vuTnx8LhwP/XFGSjYwzke7JPZF8pNlZo2UpKrEBkGWVpx6npiIB+PWA + PXuk79ZeBHDl5nXw9faBtGShw1QubD2PHj0KzZo142Qe/+VE+On7eZLrO3bvCru3bn8joxvp43fq0BFY + kQZSumwZiEENpEDefLLXEcPh8JEjYOWy5ZJz38/9Acj+ATkZdiMAb6MB8DgW4Pcc+YCs0QOwc0xgsNAA + GKZ717jUuLIBcG3HMVClUCnu//OEWM4A+Cw5gftfyMMLNnUeB0W90leNXh5zFH6I2g/zmw+EtlgpCUjf + t+/uhXDz5WN5+ViWbB7SUMY/4QeUTVPpmtagGwyo2sTy/+zDG7Dsyon0l8KY5kaA0Qi4a9oCuHdWOiJh + CwEkJyfDP/89hKTkZKvxCBXN+2EuLPl1keRcu3btOCIirTxB9NXLUL92XUgRpemJ3YTTKFttH19NsolB + KvEHY0bDssVSNX8oVu7lS5ZavX43dk+6d+nK2QT4qOZdE8LXrAIvTy/Z61wZlxR3F1euwOAzuhQrVszL + w8PDJSNEhloU+/Lly1Q8EqzFy5s3r3vhwoU9yFLQWtK1JwG4YgEmZm+HGgCxAL7Aj2pYwR4J5AvTjcQX + oehpUiZPQc6Q52Gamhr1+G8I2P+7IE5Ik17QvVJ9y/9LGGfogSWwttNYqFrIqFiQrgFxF05MS1W4E7sS + +/9D+SE+YUEMy7AnMP807dW9rM1waFDyXcv/6We2wNpb5+XvlgmjAGfPnU0Z9eGHbvqoS5I+vVaQSrB1 + 61bo3j19+QOSVv/BA2Hj2vWS+BMnT4I5M2ZlSAt48vwZ1KpdCx7euy8Id3F1gQ1bNkOvbn5Wr3/24gX4 + 1qkFD/6+BxkFkbtq1arJM2fONGAXLLctz/H69eu0L774Innt2rUeL168sOofnSdPnrTBgwcn4X3ckAhU + u4/2I4CwoNqmbcAdDDYaG4DaSABCF9sw3QJ8CZ8oXdWkeEVY3HaEpcBtuXkevjq7RRCnWclK8Gvr4dw0 + XILElGT48NAfsOD9QChgMhCeuH8VPjoapnQbQlA6VP9n8MN8wqfixcw10OABmDeXO+z2mygwSA7bvxj+ + fCy//umbEsDTp0+Ta9WqxT548OCNJsZXqlQJ9Ho9eHoKJ9acPHMaWrdsJdEC8hcqCFeuXoFSxUvafK+D + x45Au/elk4tKlSsLUZGRULRQYavXk+5J4KgREL50+Zs8MocCBQqknjhxItnHx8dL6zUTJkyImzdvnrqF + l4dJkyYlzJo1y1ONaOypAQRiC+bwNfvx9a3CFtafH+K74iuGdTWQ3XIUZ3WMrtkCPqljNDyRAvAtmcl3 + Wzh05unqBus6fQQVChS3xPv10n4Y7duWm1BCsER/GH68dFBROEQzJKcIUd41wLw7hT9VGbwmahph2FVx + M90vMTUZOm79Hp4lye+W9qYEsGPHjhfYar+xVjd79mxSSCXhZLpyy3Zt4PTR45Jz02fPlPXPtwbyTsZ9 + Ph5++fEnybkhI4fDiiV/aEpn/5HD0Ll9B0hLTdUU3xo+/fTTF/Pnzy+oRQvAFj+1du3aLnfv3rVpZlTd + unUTIiIiPNzd3a1eZ08CWICF+BNbErAHsIUdhy2sYHsubGGLsMBcQfmKKV1HrPytTVZ+YuAbvPc3uPL8 + oSTeF3U6wFCexx9xCvIuUpbTHLjCd2QFHHso7/mGshEPEzIF+D9R3g1D2ZZpeb7u5X0huFl/i6YSzTkl + /Q5prLwZ8E0JICoqKr5e/XqehjRDhi1yBQtia37lCpQsKd+ar9u8CQb07iMJ59x1z53HPrf26bivYmOh + Tr26cPumcAUkYv3fsmM7dO/cRVM6cQnx0LBRI7iij8noY1tQuXLluIsXL+bG/rqrWtyNGzfG9e3b16bW + n6BFixYJhw4d8siVK1fWE4DJAHgGC3FDWxLIfLCkHrTBFvYYPxTlq4UCXiSe3XJXuWNrSlp2swfg88TX + 0GPnj/A8SWp/qV6wBIR3/MgyBEcqPd9BqPeuhfC30hRgFvSMgakfPWS6QN/1CQ8iPqlfgAZ828gPeldO + X6tgx18XYGrEJsX4b0oA2EIbuvfpxezdvpNhWVvXazIO63377bcQFKQ8HyA+MQEaNW4MMZeEhkpSaYkv + f/8+fdVuY8HRkyegdYuWIJa1VOnSEB2jh8I2eBkuC10BH40eA0mJqts3WAW2yobjx4+nNGrUyGo3isg8 + cODA2HXr1uXTmjYBdqtSV69enUpsDWpx7UUAyGzMMwxw8MaKxADIVtcHzLCphS1LDIDdxmOlNmrgkaaZ + fHLIhYVyZdsPwLeYdDrB3VdPOH98JQMgagBLsfX/gB9WM4zbmOQcylcfNCCs/SioXSx9wsz353fAOjkD + oHk3FSSA67PJmoBSrUSrEZC0hitXhcOuPbttUok9PDwgoN9A6NWrl+pc/9nzfoDJE6Qc2LjFe3Ds4GFw + d1NfN5BUoAmTJ8H8OT9Izg0eEgjhK2zroRIj5d7DB2F56ErVtQRdWSbRhYXk27dv54qOjpb093U6XdL0 + 6dM9rHUD/vvvvyQfMnPxyRMBUWA+prVu3TqOrKMoBmpXKaNGjfJ477338mrpYtiLAMjy1Rdsudg+YP/E + /n8DcSjKtwjlG6101fulqsDCVumG+bXXI2A6ViwlDKvejJsxKM7wQ3f1MP7EGlAG+wnKt1AkG5lnSoYn + VZfIJR6Au/wmQuHceS1hT+JfQkKq8tBcakoqjBgYAEcOSB2TsmpBEC0gjkG1ateGJ/8KuBtcc7nCdiSe + zqZpu9bwOj4O6jdsANcvXxWEu6AWsmb9OujXq7fdn0Ov1yc2btw4V3x8vGC4uUqVKokXLlxwxW6AIpOF + hYXFBwYGWrYsN6Nfv37xa9as8dQ61GcN9iGAMN1YrAwO3xYbW9gwbGED+WE+YTqyTO9hFFdxCvDIGs3h + s7pGzzDOAHiGLOV1UfE+pbwKcK6/ed2FGtcS/RH48dIB2WtY4xB585iA4FMC+cKn1sNOhCYPwHpFy8Ef + 7T4AVxtWziGegH5+flnqCJQRkNb2g3FjYZmM/0DfQQNgXfhq1SHBYxGnuAk+ZCVkPgoXKwoxMTFZsgw5 + 2Xy0TZs2iSdPnhT041F2A/bR41q1aiWr3pNy16dPn4TNmzeLDR7s1q1bU/AdukMmwC4E4BMW9BP+G2eX + HNUI1ljFxmL//1d+OLawRcDYwhZVunZRqyHQrFRV7jeZAtx/989w89VjxXuR6rewpT+0KFMj/f74Aj86 + tAxO/veXwlXsE9MEJUHCSJ5jsHD8ChrQp1Jd+Lpxb5vGxgkBtO3cAY4fPCI5l50IgCDm2hWoX6cu9rmF + qyjlyZsHLkXr2UoVKlh98AlTvoR5s+ZIwrv17glbN2yyDN/aG3Pnzo2dOHGipKKPGTPm1S+//JJf7v09 + evQoydvbOxeq/wJDYYkSJVKQvFyKFCmiakDUgkwnAJ/QIAZrxDn8qakPay8gAaTgRxMkAEFXBAmgIVb+ + s0rXkT79l3U6QElP41Jer1OTIOTCbnittJSXCc1Lvgv93m1gYcEUQyoE43WKw3HARuJHI5RPPAX4R8zK + T7U8Y68KtaF16eqK+xACLwxM4cQVeOTgoXDvrF6SXnYjgDTUAgYF+sN6mfn733zzTcLXX3+tOByQkJgI + zVu2gAvnhPYQbobh+rUwoLd2Q+Kb4urVq4kNGjRwi4uLE1TaihUrJkRGRrrnz59fUplRxX89aNCgvOLw + Xr16xa5fvz6vq6trprBX5hNAeBD5fgaO9wAkO/NWxwr2gh/uHR7khwJqWmXXzgL+oA8Illi5kKC2IkH5 + ZSRJTbd18JJgtuI4qvHvy6jxpUqVSiLbdRUrVkzWkn4pRg8N69XnXJb5KPnOO6g9XIJiRYpCVoGMnLz/ + /vupp06dEqjtbm5uLHYDkps3by54BuIcgup/HKr/EgJYtWrVSySGApklmx0IgBsCfIJ/C9tyceaCa/N+ + 1vuHSLohWMG6YAXb6TjZjCsAMSy01AeEnBGfQ/k2onx2s07lNAIgcw1at28Lp49JVjFmFy5cGP/xxx9L + xshJ9+t/M4Lhm6CvJOl18esOO7duy/LnmDNnTvyXX34pGQ1A+eN++umnPPxuwP3794m3JTx79kxAGEh2 + SdHR0aQbkGnbE9lrFEDzQhb2AFYwsvDHe9i/viM+5xOm80ZJo1DcTOlDZUw+WIoyfBgzODhNfA7lm4Gd + +il2u3cOIwCCDVs3Q/9efSRj+VhJks+ePevq4eEheJcJSYnQoEljuBx5SZgQVrLFy5bCqKHDs/wZLl++ + nNCoUSPSDRCMBlSqVCnx4sWLrtgNsBh9ly1bljhixAhSyQVq/oABAxJQA8idGdZ/M+xjBAyfOhR7W8tA + w1p2mQ/2MRaTQVj5Zf1vvVfp3LAG7nYQQZEyvB8JatDlgJBnchGQAOqzDBxD+TT7itskQA4kgPiEeGjS + rBm3hyAfWBHYDRs2xGO/WKAFRMVEQ5OGjSExQei4VbBwIYhC9b9cKdU1VjIdKSkpae3bt088evSoeDSA + 3bt3bxye49R9ov737Nkzadu2bbnF8bZs2ZLq5+eXqRsn2msUgOwB+BPKPEppvb3MB5sMLHMQK7dOHxhs + dRKST2hQNXABsmCeL2QdST3Cd7uIYV3m6AOnxypFQgLA3gGMxcZqBopmkweYplxSJgD2dEREWpPGjbPl + Ejdzf5yfPPGzzyVDXx06dHiNBTgP3yj23cwZ8H9TpRtRdenhB9s3bbbrtmPWsGDBgtfjx4+X9OuxtX+9 + ZMkSznHn4cOHxPnHFdV/wXt45513kvR6vWvhwoUz9f3YbS6AacWdRgzLvI8tWgmrO32KN/+Ti6ts6jZg + jbmJrWqEa5pr9KWh36WBBniHBRVkgG2P6dRlgVF1mRQ8pVk2scldvNEh2ZCUhTj8iGQNcDomULgmoTUg + EdQkk5UwiYqQiXsqpL547XJn1mq/pLuPKopzOCIiIqlx48ba8yIL8eTJE24WIlYQQf83d+7cadiqJqF6 + zWlMycnJhvdbtUqJOH1a0k9etmJ56rAhQx1GcNevX0+qV68e6QYIGKhMmTJJly5dylWoUCHXhQsXvvjk + k08kBvR+/fq9WrNmTb7MVP8JsmRrMIpsBVIBiBWssyg8WxMAUY0nT56cMGfOHEnXaMiQIfErVqzgwm/c + uJGILagHEoGgPJJpuNiCsljZ7L/3uALS0tIMLVu2TDl16pSEnLAbkNCuXbvcWCHj9uzZI9ES1q1b9xJJ + INOs/2ZQAnA+5EgCILh582ayr6+va2JiosDoV7RoUUNkZGRq6dKl3efOnft64sSJkgqEfewErGRkIQ6H + llOULw7lk4xcjB49Om7q1KluderUcXn58qVY/U+JiopiixUrlinef3xQAnA+5FgCwBaUDQgIiENVWFLB + v/nmm1idTpenTZs28SdOnBCfZxctWhSHlSyvxlvZDdeuXYtv2LChW2xsrEATKV68eGLPnj0TFi9eTNR/ + QV364IMPkjDcwx7cRQnA+ZBjCYDg4MGDrzp06JDXYDAI+tHYSiZgNyC+e/fu+ZKSkgQtpZeXV8qFCxeS + qlWr5nACIE5BKH/C4cOH5eb4Sxw5ifV/+/btKVhRM731J6AE4HzI0QSQkpJCKlDSkSNHJJNk8uTJE4eQ + VHIydXb//v2eZGFOR8tPsHDhwteffPKJJjLCbg1x/nEtVKiQXYyXlACcDzmaAAi2bt2a1KtXL3eWZTWV + uSVLliSNHDky07zn3hQ3btxIrlevnuvr169VndEGDhz4Mjw8PH9mW//NoATgfMjxBBAfH2+oX79+4tWr + V1WdpfLnz58WGRnJVqxYMdv4N5DRgFatWiWfOHFCNa83bdr0CsnObgvrUAJwPuR4AiDulAsWLIj97LPP + VB2lsKLFHzx4MFMWz8hMEPnHjx9vVX5U/4n1H4oUKWK3oUtKAM6HHE8ABM+ePUupW7cu3L1712rlmD17 + 9qtJkyY5eGk6KW7evBmPWoz7q1evFDWTUaNGJS1atMgu1n8zKAE4H94KAiBawJQpUxKxgivK6+Xllfbn + n38mVq9e3eZVde0N0g3o1KlTwoEDB5RkM+zYsSMJK6j2JZAzAEoAzoe3ggAIrl69mtSgQQNX8Qw7M5o2 + bZpw/Phxj+xi/Rfj999/Txg9erRsBS9RokQCsf7bw/mHD0oAzoe3hgDIfnnDhg2LCw0NlR1SmzVrVsKX + X35p1xb0TYDdl1Qy71/s+UcQEBDwcsWKFXaz/ptBCcD58NYQAMGxY8diW7duTRyDBOWPLJ197ty5NF9f + X7u2oG8CQmBt2rRJOHr0qGA0g/T5Uf1/3aVLF7s7LlECcD68VQRAHIOwL5186NAhgdwtW7aMI9Z/tZ1x + HI1ly5a9GjlyZD6+T0OVKlWSTUuG233RGkoAzoe3igAITp8+nejn5+f65MkTbkSgePHiqRs3biRr7dll + UZXMBJm+/OmnnyYTX39CAmXLlk1dunRpSrt27VQ39swMUAJwPrx1BEBGBB48eJC0YcOGZGJd79u3b26s + SHYdPstMkElOMTExcdevX09u3759fkSurJKdEoDz4a0jAIqMgxKA84ESAIUFlACcD5QAKCygBOB8oARA + YQElAOcDJQAKCygBOB8oAVBYQAnA+aBIACdPnkxq0qRJtlk4g8L+6Ny587N9+/YVkTsFlADeSigRAFSu + XDmhaNGimvZVoHg7cOHCBbKEutyUakoAbykUCYCCggdKAG8pKAFQaAElgLcUlAAotIASwFsKSgAUWkAJ + 4C2FIgGULl06zdPTk7U9SYqcinv37rkkJSXJTZmmBPCWQpYAChUqxI4dO5Zxc3PY3pkUDsCJEyfSDhw4 + ILfuACWAtxSyBFCsWDF2zJgxjKur3degoMhGOHv2bNquXbsoATgRKAFQWEAJwPlACYDCAkoAzgdKABQW + UAJwPlACoLCAEoDzgbzszXh05wfmy5cPxo0bR5bTdrR8FFmIM2fOsLt375aru23xOGRLWpQAcg5+x+MD + caC/vz9ZktrRslFkEchiqhs2bCALkorrbjIejfGItCU9SgA5ByPASAICB5DSpUuT/ejZvHnzMjllRV2K + jCEtLQ3OnTvH7tu3jzEYDOLTf+HRBI/HtqRJS0zOQXk8TuPxjvhE/vz5oVq1apwmQEng7cSTJ0/Ya9eu + ka3J5Co/wVI8RuNhsCVdWlpyDsi7+h6Pz4G+NwohnoKx/x9l64W0IOUskNZ/Jx51HS0IRbYBWQxmGh6z + 8LB5TgglgJwHUvlX4uHjaEEoHA5i+CN2oS/xiM9IApQAciaq4jEHj054ZNuddCnsikd4zMTjVzwSM5oI + JYCcC7KJZkc8/PGoj0cxEI0QZDMQopJzXknBIzUL5SBl3gPky34S2GhEy0IQ9Z60+MTavx+MWuDVN5WX + EkDOB/ESLIgHWSaa7E3Pf6csZI93TCr+bDxaiMJJ4Q0Bo5ejNWTmc5C8WgHS0RRSuSaBcaTFXjD30TPy + LIQkn5mO15CB/r4cskPhoHj7QYjpDB41ReFEdW2NR0QWykL2UNgBRqs5H6RCfYbHAgflkUNACYAiK1AN + j5N4iNey/weM3msPslieuWAcThWDqNXDIft2AzIdlAAosgLEWElaXbENgLT8pFuQlTYAgkF4hIO0/JNx + 9GaQQYt6TgQlAIqswBQ8ZsiEL8bjQwfIUwuP43jkF4UTN9r38LjhAJkcAkoAFPYGGZlYhccAUTjpc38M + xmGsrEYBMBr7aojCiVNNVzz2OkAmh4ASAIW9kQ+PUyB1XCJDbu3B2BJnNQgprcajv8w54lQzxwEyOQSU + ACjsjYp4xODhKQp/AkZS+M9Bck0A49wKcR0g2kogOIkhkBIARUbhAtocj7rhsVEmLlHBiSNTgoPkJ8OA + W8A4LMjHn2DUTGI1pEG6DDl6TwZKABS2Ig8YFyZpB0aPOjWUAWlfm4C4sl4Cx1Ug4pvQEIyOVHwQQiI+ + Cykq1xO5H4LRF/+UA5/jjUAJgMIWkGG8+Xh8BPJuvc4IQmTElnDU0YJkBJQAKGxBJTyiwTgPgSIdxKdg + GGS9P8MbgxIAhS0gKjNRd3O9aUJvGciwYQ8wjmzkKFACoLAFZPycGMnedbQg2Qzf4PE/yIF2AEoAFLaC + WO5/xqMsOLcdgFR2MpmJrNA0DozDmjkOlAAobAUpM2TqMRnDz/2GaeVkEAIgPgzExyHZ0cJkFJQAKCic + GJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCic + GJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCic + GJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCic + GJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCic + GJQAKCicGJQAKCicGJQAKCicGP8PBVkkDiOiO/wAAAAASUVORK5CYIIoAAAAMAAAAGAAAAABACAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAHQAAAB0AAAAdAAAA + HQAAAB0AAAAdAAAAHQAAAB0AAAAdAAAAHQAAAB0AAAAcAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwAAAA + /QAAAP4AAAD+AAAA/QAAAP0AAAD9AAAA/QAAAP0AAAD9AAAA/wAAAP0AAAD8AAAAPgAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAACAAAABgAAAE8AAADZAAAABgAAAAYAAAAGAAAABgAAAAYAAABTAAAA1wAAAAYAAAAGAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAA + QQAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAF8AAAD8AAAATgAAAEgAAABIAAAASAAAAEgAAACjAAAA + wgAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAEAAADAFhYW/yEhIf8hISH/ISEh/yEhIf8hISH/ISEh/yEhIf8hISH/ISEh/yEhIf8hISH/ISEh + /yEhIf8hISH/ISEh/yEhIf8hISH/ISEh/yEhIf8hISH/ISEh/yAgIP8HBwf8AAAATwAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAABECAgL/fX19/39/f/9/f3//f39//39/f/9/f3//f39//39/f/9/f3//f39/ + /39/f/9/f3//f39//39/f/9/f3//f39//39/f/9/f3//f39//39/f/9/f3//f39//39/f/9DQ0P/AAAA + mwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMCAgL/Tk5O/k5OTv5OTk7+Tk5O/k5OTv5OTk7+Tk5O + /k5OTv5OTk7+Tk5O/k5OTv5OTk7+Tk5O/k5OTv5OTk7+Tk5O/k5OTv5OTk7+Tk5O/k5OTv5OTk7+Tk5O + /k5OTv4qKir+AAAAnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMAAAD/VVVV/FlZWf1ZWVn9WVlZ + /VlZWf1ZWVn9WVlZ/VlZWf1ZWVn9WVlZ/VlZWf1ZWVn9WVlZ/VlZWf1ZWVn9WVlZ/VlZWf1ZWVn9WVlZ + /VlZWf1ZWVn9WVlZ/VlZWf0rKyv9AAAAnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMAAAD/9PT0 + /v////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////99fX37AAAAnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAABMAAAD/9PT0/v////////////////////////////////////+vr6/9XFxc/P////////////// + //////////////////////+bm5v9hISE/P////////////////////99fX37AAAAnQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAABMAAAD/9PT0/v////////////////////////////////7+/v82Njb9BQUF + /u3t7f7///////////////////////////7+/v8zMzP9Gxsb/fz8/P7///////////////99fX37AAAA + nQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMAAAD/9PT0/v////////////////////////////// + /8LCwv0aGhr+MDAw/J6env3//////////////////////////9zc3P0LCwv+FxcX/sPDw/3///////// + //////99fX37AAAAnQAAAAAAAAAAeqUsb3ulK+l7pSvqeqUr6nulK+p6pSvleqUsYnulKxd6pSzee6Ur + 6nulK+p7pSvqeqUr6nulLLl7pCwIeqUskXulK+p6pSvqeqUr6nCXKOsAAAD/9PT0//////////////// + /////////////////1JSUf6EhIT9i4uK/0tLSv///////////////////////////4eHh/1VVVX9cHBw + /W1tbf3///////////////99fX37AAAAnQAAAAAAAAAAeqUsh3ulLP97pSz/e6Us/3ulLP97pSz/eqUs + 2HqlKxp7pSz/s8uH/4+zTf+Qs07/1OK9/3qlLP96pStFeqUrrXulLP+60JP/1+TC/8HPq/8AAAD/9PT0 + ///////w8fD/7e7s//Ly8v//////29va/wwMDP/r6+v+3d3c/wgICP/v8O////////z8/P/t7uz/7e3t + /jExMf2srKz9xsbG/RoaGv3s7Oz8+Pj4/v////99fX37AAAAnQAAAAAAAAAAeqUrU3ulLP97pSz/e6Us + /3ulLP97pSz/eqUs/XqlKw96pSzlqMR1/6zHfP/A1Jz/7vPl/4CpNf97pSx5eqUseXulLP+xyoP/rMZ7 + /3GYKP8AAAD/9PT0/+Xl5P0FBQT/AAAA/wQEBP/a2tr/bm5t/2ZnZv///////v7+/zExMP+kpKP///// + /3p7ef8AAAD/AAAA/xMTE/319fX+/f39/ycnJ/0AAAD/Xl5e/f////99fX37AAAAnQAAAAAAAAAAeqUr + H3qlLP97pSz/eqUs/3qlLP97pSz/e6Us/3ulLEF6pSuyjbFK/8fZp//m7tj/v9Oa/5m5Xf96pSuteqUr + RXqlLP+WuFj/7fPk/8XRr/8AAAD/9PT0///////5+vn/+Pj3/2JiYf9cXFz/Dg4N/9XV1P////////// + /4SEg/9QUE///f39/x8gH/+5ubj/+Pj3//v7+/7///////////z8/P75+fn8/f39/v////99fX37AAAA + nQAAAAAAAAAAAAAAAHqlK+p7pSz/e6Us/3ulLP97pSz/eqUs/3qlK3V6pSx+e6Ut/+nw3v/J2qr/or9r + /7TMh/96pSzheqUrE3ulLP5+qDL/3+nN/3meNP8AAAD/9PT0/////////////////9PT0v8BAQH/R0hH + /////////////////9bW1f8KCgn/tre1/xwcG//8/Pz///////////////////////////////////// + //////99fX37AAAAnQAAAAAAAAAAAAAAAHqlLLV6pSz/e6Us/3qlLP97pSz/e6Us/3qlLKd6pStIe6Us + /7nPkf+StVL/haw9/6vGev96pSz+eqUrFHqlLNt7pSz/v9OZ/7zLof8AAAD/9PT0//////////////// + //7+/v9kZGT/wsLB//////////////////7+/v8rKyr/HB0c/3V1dP////////////////////////// + //////////////////////99fX37AAAAnQAAAAAAAAAAAAAAAHqlLDJ6pSuxeqUsuXqlLPB6pSzNeqUs + uXqlLGJ7pCwEeqUrkHqlLLl6pSzSeqUs63qlLLl6pSuoeqQrCHqlLEl6pSy1eqUsuXGYKPsAAAD/9PT0 + //////////////////////////////////////////////////////99fXz+AAAA/9DQz/////////// + //////////////////////////////////////99fX37AAAAnQAAAAAAAAAAAAAAAHqlKwp6pSste6Ur + LXqlLLt6pSuBeqUrLXqlKy17pSsteqUrLXqlKy16pStheqUs2nulKy16pSsteqUrLXulKy16pSsteqUr + LXCXKNoAAAD/9PT0/v/////////////////////////////////////////////////////X19f9VFVU + /f7+/v////////////////////////////////////////////////99fX37AAAAnQAAAAAAAAAAAAAA + AHqlKxp7pSz/e6Us/3ulLP97pSz/e6Us/3qlLP97pSz/e6Us/3ulLP97pSz/e6Us/3ulLP97pSz/eqUs + /3ulLP97pSz/e6Us/3KZKP8AAAD/8vLy//////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////97e3v8AAAA + nAAAAAAAAAAAAAAAAAAAAAB6pSvle6Us/3qlLP97pSz/e6Us/3ulLP97pSz/eqUs/3ulLP97pSz/e6Us + /3ulLP97pSz/e6Us/3ulLP97pSz/eqUs/3qkK/8VHAf/OTo5/05PTv9OT07/Tk9O/05PTv9OT07/Tk9O + /05PTv9OT07/Tk9O/05PTv9OT07/Tk9O/05PTv9OT07/Tk9O/05PTv9OT07/Tk9O/05PTv9OT07/T09P + /U9PT/0VFRX+AAAAYQAAAAAAAAAAAAAAAAAAAAB6pSsJe6UsC3qlLAt6pSwLe6UsC3ulLAt6pStbeqUs + wXulLAt7pSwLe6UsC3ulLAt7pSwLeqUsDHulLOd6pSw1eqUsC3ulLAsmMw0aAAAAYgAAAGkvPxCrOk4U + yAAAAGkAAABpAAAAaQAAAGkAAABpCQ0DbUhhGf0MEQRyAAAAaQAAAGkAAABpAAAAaQAAAGk4TBTBMkMR + sQAAAGkAAABpAAAAaQAAAGgAAABFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeqUr + bHulLNx7pSzke6Us+nulLNx6pSzVeqUsUHqkLBl6pSzRe6Us3HqlLPd6pSzme6Us3HqlLKR7pCsDeqUs + jHqlLNx6pSzpe6Us9XulLNx6pSzOeqUrNnqlKzR7pSzXe6Us3HqlLP16pSzheqUs23qlK4cAAAAAeqUs + rXulLNx6pSzue6Us73ulLNx6pSvEeqUrIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAeqUrknulLP+90pf/hKw8/3ulLP97pSz/eqUszHqlLCV7pSz/lrhZ/6vGev+Oskz/ts6M + /3ulLP96pSs5eqUruHulLP/D1qH/1OK8/7zSlv98pi7/eqUrpnqlLEx7pSz/k7VS/7DJgf97pSz/eqUs + /3ulLP56pSwUeqUs3nulLP+AqDT/wtaf/3ulLP97pSz/eqUrgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAeqUrX3qlLP+80pb/qMR2/36nMv96pSz/eqUs+HqkKwp6pSzvia9D + /9Phuv+evWX/w9ah/3ulLP96pStueqUrhY6yTP/c58j/e6Us/6/JgP+70JP/eqUs2nqlKxl6pSz/hKs7 + /9nlw/97pSz/e6Us/3ulLP96pStIeqUrq3ulLP97pSz/4uvS/3ulLP97pSz/eqUstAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeqUrK3ulLP+iv2v/4+zS/9Xivf+hv2r/e6Us + /3qlKzV6pSy9e6Us/+3z4//U4rv/wNSc/3ulLP96pSyieqUrUYmvQ//a5sT/e6Us/32mL//m7tn/eqUs + /XqlKxF6pSzje6Us/+nw3v/V4r3/pcJx/3qlLP96pSx8eqUrd3ulLP97pSz/0+G5/4qvRf97pSz/eqUs + 6HqkKwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeqQrA3qlK/OHrUD/1eK8 + /4etQP/b58f/e6Us/3qlLGl6pSuJeqUs/9bjv/+FrD7/1uO//4uwRv96pSvWeqUrHXqlLP/U4rz/lrhZ + /4SrOv/q8d//e6Us/3qlLEN6pSyve6Us/9Hgt/+NsUn/fKYu/3ulLP96pSyweqUsQ3ulLP97pSz/uM6O + /6XCcP97pSz/e6Us/3qlLB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AHulLMF7pSz/y9yt/9Dftf+kwW//e6Us/3qlK5x6pStVe6Us/6jEdf/O3rP/yNmo/36nMv96pSz8eqQr + C3qlLOeCqjf/w9ag/9Phu/+iwGv/e6Us/3qlK3Z6pSx6eqUs/6bDcv/T4bn/z96z/3ulLf96pSzieqUr + EXulLPx7pSz/lbdW/6fDc/97pSz/e6Us/3qlK1B6pSs8eqUrcnqlK2B7pSsCAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAHqlLEF6pSzCeqUsyXqlLMl6pSzJeqUsyXqlK2d6pSsJe6UspXqlLMl6pSzJeqUs + yXqlLMl6pSy2eqUsBnqlK1t6pSzGeqUsyXqlLMl6pSzJeqUsyHqlK0p7pCwZeqUss3qlLMl6pSzJeqUs + yXqlLMl6pSyeAAAAAHqlLHd6pSzIeqUsyXqlLMl6pSzJeqUsxXqlK1R6pSyEeqUrN3qlLHh6pStqAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHqlK116pStHeqUs + onqlLGR6pSuFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AHqkKyB6pSuHeqUrb3qlK2t6pCxiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAB6pSwueqUsb3qlLFMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//// + ////7wT////////vBP///////+8E////////7wT////////vBP///////+8E////////7wT////////v + BP///8AA/+8E////wAD/7wT////AAf/vBP//8AAAB+8E///gAAAD7wT//+AAAAPvBP//4AAAA+8E///g + AAAD7wT//+AAAAPvBP//4AAAA+8E///gAAAD7wT//+AAAAPvBAAAAAAAA+8EAAAAAAAD7wQAAAAAAAPv + BAAAAAAAA+8EgAAAAAAD7wSAAAAAAAPvBIAAAAAAA+8EgAAAAAAD7wSAAAAAAAPvBMAAAAAAA+8EwAAA + AAAH7wT8AAAAEB/vBPwAAAAAH+8E/AAAAAAf7wT8AAAAAA/vBPwAAAAAD+8E/gAAAAAA7wT+AAAACADv + BP//////4O8E///////g7wT///////HvBP///////+8E////////7wT////////vBP///////+8E//// + ////7wT////////vBP///////+8EKAAAACAAAABAAAAAAQAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC8AAABoAAAA + aAAAAGgAAABoAAAAaAAAAGgAAABoAAAAaAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + JgAAAFgAAADXAAAAWAAAAFgAAABYAAAAegAAALUAAABXAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQAAACCAAAA + hQAAAIUAAACFAAAAhQAAAN8AAACIAAAAhQAAAIUAAACtAAAAuwAAAIUAAACFAAAAhQAAAIUAAAB1AAAA + CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEB + rWVlZf9ra2v/a2tr/2tra/9ra2v/a2tr/2tra/9ra2v/a2tr/2tra/9ra2v/a2tr/2tra/9ra2v/a2tr + /0RERP8AAABfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABAQG3NDQ0/jQ0NP40NDT+NDQ0/jQ0NP40NDT+NDQ0/jQ0NP40NDT+NDQ0/jQ0NP40NDT+NDQ0 + /jQ0NP40NDT+JCQk/gAAAGkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAALbf39/95eXl/eXl5f3l5eX95eXl/eXl5f3l5eX95eXl/eXl5f3l5eX95eXl + /eXl5f3l5eX95eXl/eXl5f2Xl5f8AAAAaQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtvj4+P7+/v7//v7+//7+/v/+/v7/tbW1/oCAgP3+/v7//v7+ + //7+/v/+/v7/qqqq/pqamv3+/v7//v7+/6ioqPwAAABpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC2+Pj4/v7+/v/+/v7//v7+//7+/v9LS0v9OTk5 + /f7+/v/+/v7//v7+//7+/v9RUVH9RUVF/f7+/v/+/v7/qKio/AAAAGkAAAAAeqUsonulK/F7pSvxe6Us + 73qlK1l6pSyuiK5C8X2mL/GJr0TueqUsTnqlK7qHrT/xl7hZ8SkzGPv4+Pf//v7+//7+/v/+/v7/zc3N + /2tra/5qamr/zs7O//7+/v/+/v7/7+/v/k5OTv1bW1v94uLi/v7+/v+oqKj8AAAAaQAAAAB6pSuVe6Us + /3ulLP97pSz/eqUsqnqlLKK60JL/ob9q/8rbq/96pSydeqUsrqPBbf+xyoT/KzQa//j49/9+fn3+SUlI + /7a2tv9eXl3/2dnZ/729vP97e3r/9/f3/1FRUP82Nzb+oaGh/bKysv4yMjL+tLS0/aioqPwAAABpAAAA + AHqlLGF7pSz/e6Us/3ulLP96pSzeeqUsbq7Ifv/N3bH/vNGV/3qlLNF6pSx6iK5C/9fkwP8zOij/+Pj3 + //z8/P/t7ez/Nzc3/1JSUf/+/v7/+/v7/zw9PP+ur67/i4yL//r6+v7+/v7//v7+//v7+/3+/v7/qKio + /AAAAGkAAAAAeqUrLHulLP97pSz/e6Us/3ulLP56pSxMkLNO/7TMif+mw3L/fqcy+3qlK097pSz/xNei + /zM6J//4+Pf//v7+//7+/v9+fn7/wcHB//7+/v/+/v7/Y2Nj/zAxMP/l5eX//v7+//7+/v/+/v7//v7+ + //7+/v+oqKj8AAAAaQAAAAB6oywBeqUsZHqlLJB6pSzFeqUsdnukLAl6pStpeqUslnqlLL56pSx0eqUr + CHqlLG16pSydIi4M//j4+P/+/v7//v7+//7+/v/+/v7//v7+//7+/v+2trb+RUVF//7+/v/+/v7//v7+ + //7+/v/+/v7//v7+/6ioqPwAAABpAAAAAAAAAAB6pSuWeqUszXqlLOt7pSzIe6UsyHulLMh7pSzPe6Us + 6HulLMh7pSzIe6UsyHqlLNIjLwz/9/f2//7+/v/+/v7//v7+//7+/v/+/v7//v7+//z8/P/n5+f+/v7+ + //7+/v/+/v7//v7+//7+/v/+/v7/p6en/QAAAGgAAAAAAAAAAHqlK2p7pSyye6UssnulLLJ6pSzFeqUs + 1XulLLJ7pSyye6UssnulLMl7pSzSe6UssjZIE7gsLSztODk29Tg5NvY2NjbwNjY28DY2NvA4OTb2ODk2 + 9TY2NvA2NjbwNjY28Dg6NvY4OTb0NjY28DY2Nu4dHR3fAAAAKwAAAAAAAAAAAAAAAAAAAAAAAAAAeqUr + YXulLKZ7pSzNe6Usj3qlLCR6pSxoeqUsq3ulLMd7pSyOeqUsHnqlLG96pSyxe6UswnqlLI16pSsYe6Us + d3qlLLZ6pSy9eqUsi3qlKxN6pSx+eqUsu3ulLLd6pSyIeqUrDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAB6pSuuqMR1/4asPv97pSz/eqUskXqlLLqvyID/jrJM/6bCcf96pSyEeqUsx7bOjP+4z4//nr1l + /3qlLHd6pSzUrcd8/4GqN/97pSz/eqUsa3qlLOF9pi//scqE/3ulLP96pSteAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAHqlLHqZul3/ydqr/6PAbP96pSzFeqUsh6LAbP/N3bH/qcV3/3qlLLh6pSyUxNei + /3ulLP/E16L/eqUrq3qlLKCfvmb/x9mm/46ySv96pSyfeqUsrXulLP/A1Jv/e6Us/3qlLJIAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAeqUrRoCpNf/J2qr/ytus/3qlLPV6pStXiK5B/8TXov/I2qj/eqUs + 63qlK2CmwnH/rsh+/8/es/96pSzfeqUsbISsPP/L26z/lrhY/3qlLNN6pSx5e6Us/7/Umv97pSz/eqUs + xgAAAAB6pSsLAAAAAAAAAAAAAAAAAAAAAAAAAAB7pCsNeqUsxoyxSNuCqjnbeqUs1XqlKyN7pSzLjbFK + 24KqONt6pSzSeqUrInqlLM6JrkLbg6s523qlLM57pSwkeqUs0YyxSNuHrUDbeqUsxHulLCx6pSzUg6s6 + 23ulLdt6pSy5eqUrZnqlK3p6pStWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAB6pStueqUsuHqlLFsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHqlKzl6pSxPeqUrMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAD/////////////////////////////gB///4Af//gAAf/4AAH/+AAB//gA + Af/4AAH/+AABAAAAAQAAAAEAAAABAAAAAQAAAAGAAAABgAAAAfAAAAfwAAAH8AAAB/AAAAXwAAAA//// + +P////j//////////////////////////ygAAAAYAAAAMAAAAAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAHgAAAB4AAAAeAAAA + HgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABeAAAA1gAAAOoAAADpAAAA1gAAANYAAADWAAAA1gAAAOkAAADqAAAA + 1gAAAF4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAF8AAACWAAAAAAAAAAAAAAAAAAAAAAAAAJkAAABfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAANAAAAK8AAAC3AAAAtwAAALcAAAC3AAAAtwAAAMkAAADrAAAAtwAAALcAAAC3AAAA + twAAAOwAAADJAAAAtwAAALcAAAC3AAAAtwAAALcAAACvAAAANAAAAAAAAAAAAAAAwAAAAGkAAAA9AAAA + PQAAAD0AAAA9AAAAPQAAAD0AAAA9AAAAPQAAAD0AAAA9AAAAPQAAAD0AAAA9AAAAPQAAAD0AAAA9AAAA + PQAAAD0AAABpAAAAwAAAAAAAAAAAAAAAzAAAAG0AAABRAAAAUQAAAFEAAABRAAAAUQAAAFEAAABRAAAA + UQAAAFEAAABRAAAAUQAAAFEAAABRAAAAUQAAAFEAAABRAAAAUQAAAFEAAABtAAAAzAAAAAAAAAAAAAAA + zAAAALIAAACjAAAAowAAAKMAAACjAAAAowAAAKMAAACjAAAAowAAAKMAAACjAAAAowAAAKMAAACjAAAA + owAAAKMAAACjAAAAowAAAKMAAACyAAAAzAAAAAAAAAAAAAAAzAAAACkAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAUAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAABMAAAAAAAAAAAAAAAAAAAApAAAA + zAAAAAAAAAAAAAAAzAAAACkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADJAAAAaAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAASAAAANYAAAAAAAAAAAAAAAAAAAApAAAAzAAAAAAAAAAAAAAAzAAAACkAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAADsAAADxAAAAuwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnQAAAP0AAAAtAAAA + AAAAAAAAAAApAAAAzAAAAAAAAAAAAAAAzAAAACkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKwAAABiAAAA + 7AAAABMAAAAAAAAAAAAAAAAAAAAGAAAA6AAAAJIAAACCAAAAAAAAAAAAAAApAAAAzAAAAAAAAAAAAAAA + zAAAACkAAAACAAAAFQAAABUAAAACAAAAIQAAAOEAAAAGAAAApgAAAGEAAAAAAAAABQAAABUAAABUAAAA + twAAACkAAADXAAAAFQAAAAIAAAApAAAAzAAAAAAAAAAAAAAAzAAAACkAAABGAAAA4QAAAOwAAAB6AAAA + jQAAAHsAAAAAAAAAVAAAALQAAAAAAAAAngAAAOgAAADgAAAAVQAAAAAAAAC3AAAA4QAAAEYAAAApAAAA + zAAAAAAAAAAAAAAAzAAAACkAAAAAAAAAAAAAACQAAADkAAAA5wAAABUAAAAAAAAACwAAAO4AAAAYAAAA + 6QAAABEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApAAAAzAAAAAAAAAAAAAAAzAAAACkAAAAAAAAA + AAAAAAAAAACwAAAAmwAAAAAAAAAAAAAAAAAAAK4AAACuAAAArQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAApAAAAzAAAAAAAAAAAAAAAzAAAACkAAAAAAAAAAAAAAAAAAAAZAAAAEwAAAAAAAAAAAAAA + AAAAAFwAAAD/AAAAUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApAAAAzAAAAAAAAAAAAAAA + zAAAACkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAADWAAAACAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAApAAAAzAAAAAAAAAAAAAAAywAAACwAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsAAAA + ywAAAAAAAAAAAAAAewAAAOYAAADWAAAA1gAAANYAAADWAAAA1gAAANYAAADWAAAA1gAAANYAAADWAAAA + 1gAAANYAAADWAAAA1gAAANYAAADWAAAA1gAAANYAAADmAAAAewAAAAAAAAAAAAAAAAAAABcAAAAeAAAA + HgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAA + HgAAAB4AAAAXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///9B////QfwAP0H8AD9B/zz/QYAAAUGAAAFBgAAB + QYAAAUGfnzlBn585QZ8fGUGfDhlBgAgBQYBIQUGYQflBnOP5QZzj+UGf4/lBn//5QYAAAUHAAANB//// + Qf///0EoAAAAEAAAACAAAAABACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAKAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAWQAAAK8AAAC2AAAAjwAAAI8AAAC2AAAArwAAAFkAAAAAAAAAAAAAAAAAAAAAAAAA + AQAAAGQAAAB6AAAAegAAAHoAAACUAAAAtQAAAHoAAAB6AAAAtwAAAJQAAAB6AAAAegAAAHoAAABkAAAA + AQAAAC4AAACNAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAA + jQAAAC4AAAAzAAAAywAAAKMAAACjAAAAowAAAKMAAACjAAAAowAAAKMAAACjAAAAowAAAKMAAACjAAAA + owAAAMsAAAAzAAAAMwAAAHAAAAAAAAAAAAAAAAAAAAAAAAAARAAAAAAAAAAAAAAAAAAAAAAAAAA+AAAA + AAAAAAAAAABwAAAAMwAAADMAAABwAAAAAAAAAAAAAAAAAAAAGgAAAPEAAAAbAAAAAAAAAAAAAAAOAAAA + 8gAAABQAAAAAAAAAcAAAADMAAAAzAAAAcAAAAAAAAAAAAAAAAAAAAIQAAABtAAAAbAAAAAAAAAAAAAAA + WwAAAJYAAABlAAAAAAAAAHAAAAAzAAAAMwAAAHAAAABXAAAAqQAAAEEAAACmAAAABAAAAKsAAAAPAAAA + qgAAAL8AAAANAAAAvAAAAFYAAABwAAAAMwAAADMAAABwAAAAAAAAABAAAADhAAAASgAAAAAAAACaAAAA + dgAAAEwAAAAAAAAAAAAAAAAAAAAAAAAAcAAAADMAAAAzAAAAcAAAAAAAAAAAAAAATwAAAAIAAAAAAAAA + SwAAAOIAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAzAAAAMwAAAHAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAcAAABiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAMwAAABoAAAC6AAAAjwAAAI8AAACPAAAA + jwAAAI8AAACPAAAAjwAAAI8AAACPAAAAjwAAAI8AAACPAAAAugAAABoAAAAAAAAACgAAABQAAAAUAAAA + FAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAAAoAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//rEHwD6xB8A+s + QQAArEEAAKxBAACsQT3srEE4xKxBOMSsQQAArEEiPKxBMjysQT58rEEAAKxBgAGsQf//rEE= + + + \ No newline at end of file diff --git a/ProfinetMonitor/EditableListView.cs b/ProfinetMonitor/EditableListView.cs new file mode 100644 index 0000000..ef6d495 --- /dev/null +++ b/ProfinetMonitor/EditableListView.cs @@ -0,0 +1,221 @@ +using System; +using System.Collections.Generic; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace ProfinetMonitor +{ + class EditableListView : System.Windows.Forms.ListView + { + protected override void OnHandleCreated(EventArgs e) + { + base.OnHandleCreated(e); + SetUpEditingTextBox(); + } + + #region ScrollEvents + private const int WM_HSCROLL = 0x114; + private const int WM_VSCROLL = 0x115; + public event EventHandler Scroll; + + protected void OnScroll() + { + if (this.Scroll != null) + this.Scroll(this, EventArgs.Empty); + CancelAndHideTexEditor(); + } + + protected override void WndProc(ref System.Windows.Forms.Message m) + { + base.WndProc(ref m); + if (m.Msg == WM_HSCROLL || m.Msg == WM_VSCROLL) + this.OnScroll(); + } + #endregion + + #region SubItemEditing + public event EventHandlerBeforeSubItemLabelEdit; + public event EventHandlerAfterSubItemLabelEdit; + ListViewItem SelectedLI; + ListViewItem.ListViewSubItem SelectedLSI; + TextBox TxtEdit; + + //Double click events are only fired for the Items label, never for the Sub Items. + //so we have to emulate an Double click event + Timer DoubleClickTimer; + int clickCount = 0; + + protected override void OnMouseUp(MouseEventArgs e) + { + clickCount++; + DoubleClickTimer.Stop(); + DoubleClickTimer.Start(); + if (clickCount >=2) ShowTextEditor(e.X, e.Y); + } + + private void ShowTextEditor(int X, int Y) + { + if (this.LabelEdit == false) return; + + ListViewHitTestInfo i = this.HitTest(X, Y); + SelectedLI = i.Item; + SelectedLSI = i.SubItem; + if (SelectedLSI == null) + return; + + int CellWidth = SelectedLSI.Bounds.Width; + int CellHeight = SelectedLSI.Bounds.Height; + int CellLeft = i.SubItem.Bounds.Left; + int CellTop = i.SubItem.Bounds.Top; + + // First Column + if (i.SubItem == i.Item.SubItems[0]) + CellWidth = this.Columns[0].Width; + + TxtEdit.Location = new Point(CellLeft, CellTop); + TxtEdit.Size = new Size(CellWidth, CellHeight); + TxtEdit.Visible = true; + TxtEdit.BringToFront(); + TxtEdit.Text = i.SubItem.Text; + TxtEdit.Select(); + TxtEdit.SelectAll(); + } + + protected override void OnMouseDown(MouseEventArgs e) + { + AcceptAndHideTexEditor(); + } + + private void SetUpEditingTextBox() + { + TxtEdit = new TextBox(); + this.Controls.Add(TxtEdit); + TxtEdit.Visible = false; + TxtEdit.Leave += TxtEdit_Leave; + TxtEdit.KeyUp += TxtEdit_KeyUp; + + DoubleClickTimer = new Timer(); + DoubleClickTimer.Interval = SystemInformation.DoubleClickTime; + DoubleClickTimer.Tick += (a, b) => { clickCount = 0; DoubleClickTimer.Stop();}; + } + + private void TxtEdit_Leave(object sender, EventArgs e) + { + AcceptAndHideTexEditor(); + } + + private void TxtEdit_KeyUp(object sender, KeyEventArgs e) + { + if (e.KeyCode == Keys.Enter) AcceptAndHideTexEditor(); + if (e.KeyCode == Keys.Return) AcceptAndHideTexEditor(); + if (e.KeyCode == Keys.Escape) CancelAndHideTexEditor(); + } + + private void AcceptAndHideTexEditor() + { + TxtEdit.Visible = false; + if (SelectedLSI != null) + { + if (BeforeSubItemLabelEdit != null) + { + var args = new SubItemLabelEditEventArgs(SelectedLI.Index, SelectedLI.SubItems.IndexOf(SelectedLSI), TxtEdit.Text); + BeforeSubItemLabelEdit.Invoke(this, args); + if (args.CancelEdit) + { + CancelAndHideTexEditor(); + return; + } + } + SelectedLSI.Text = TxtEdit.Text; + + if (AfterSubItemLabelEdit != null) + { + var args = new SubItemLabelEditEventArgs(SelectedLI.Index, SelectedLI.SubItems.IndexOf(SelectedLSI), TxtEdit.Text); + AfterSubItemLabelEdit.Invoke(this, args); + } + + } + SelectedLI = null; + SelectedLSI = null; + TxtEdit.Text = ""; + } + + private void CancelAndHideTexEditor() + { + SelectedLI = null; + SelectedLSI = null; + TxtEdit.Text = ""; + TxtEdit.Visible = false; + } + + } + + public class SubItemLabelEditEventArgs : EventArgs + { + // + // Summary: + // Initializes a new instance of the System.Windows.Forms.LabelEditEventArgs class + // with the specified index to the System.Windows.Forms.ListViewItem to edit. + // + // Parameters: + // item: + // The zero-based index of the System.Windows.Forms.ListViewItem, containing the + // label to edit. + public SubItemLabelEditEventArgs(int item, int subItem) + { + Item = item; + SubItem = subItem; + } + // + // Summary: + // Initializes a new instance of the System.Windows.Forms.LabelEditEventArgs class + // with the specified index to the System.Windows.Forms.ListViewItem being edited + // and the new text for the label of the System.Windows.Forms.ListViewItem. + // + // Parameters: + // item: + // The zero-based index of the System.Windows.Forms.ListViewItem, containing the + // label to edit. + // + // label: + // The new text assigned to the label of the System.Windows.Forms.ListViewItem. + public SubItemLabelEditEventArgs(int item, int subItem, string label) + { + Item = item; + SubItem = subItem; + Label = label; + } + + // + // Summary: + // Gets the new text assigned to the label of the System.Windows.Forms.ListViewItem. + // + // Returns: + // The new text to associate with the System.Windows.Forms.ListViewItem or null + // if the text is unchanged. + public string Label { get; } + // + // Summary: + // Gets the zero-based index of the System.Windows.Forms.ListViewItem containing + // the label to edit. + // + // Returns: + // The zero-based index of the System.Windows.Forms.ListViewItem. + public int Item { get; } + public int SubItem { get; } + + // + // Summary: + // Gets or sets a value indicating whether changes made to the label of the System.Windows.Forms.ListViewItem + // should be canceled. + // + // Returns: + // true if the edit operation of the label for the System.Windows.Forms.ListViewItem + // should be canceled; otherwise false. + public bool CancelEdit { get; set; } + } + #endregion +} diff --git a/ProfinetMonitor/Logging/LogManager.cs b/ProfinetMonitor/Logging/LogManager.cs new file mode 100644 index 0000000..ad3795d --- /dev/null +++ b/ProfinetMonitor/Logging/LogManager.cs @@ -0,0 +1,50 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Reflection; +using System.Text; +using System.Threading.Tasks; + +namespace ProfinetMonitor.Logging +{ + internal static class LogManager + { + public static string LogFileName { get; } = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "ProfinetMonitor.log"); + private static bool InitialSetupDone= false; + public static LoggingLevel LoggingThreshold { get; set; } = LoggingLevel.Debug; + + public static void SetUpLogging() + { + if (InitialSetupDone) return; + InitialSetupDone = true; + + var TL = new RollingFileTraceListener(LogFileName); + Trace.AutoFlush = true; + Trace.Listeners.Add(TL); + + WriteProcessStartLog(); + AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionOccured; + AppDomain.CurrentDomain.ProcessExit += WriteProcessExitLog; + } + + private static Logger DefLogger = new Logger("ProfinetMonitor"); + + private static void UnhandledExceptionOccured(object sender, UnhandledExceptionEventArgs e) + { + DefLogger.Critical(e.ExceptionObject); + } + + private static void WriteProcessExitLog(object sender, EventArgs e) + { + DefLogger.Info("Exit Application with exit code {0}", Environment.ExitCode); + } + + private static void WriteProcessStartLog() + { + DefLogger.Info(string.Format("Starting Application '{0}', Version '{1}'", Assembly.GetExecutingAssembly().GetName().Name, Assembly.GetExecutingAssembly().GetName().Version)); + DefLogger.Info("Command line was: {0}", Environment.CommandLine); + } + + } +} diff --git a/ProfinetMonitor/Logging/Logger.cs b/ProfinetMonitor/Logging/Logger.cs new file mode 100644 index 0000000..ff61819 --- /dev/null +++ b/ProfinetMonitor/Logging/Logger.cs @@ -0,0 +1,252 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace ProfinetMonitor.Logging +{ + public enum LoggingLevel + { + Debug = 0, + Info = 2, + Warning = 4, + Error = 8, + Critical = 16, + None = 128 + } + + /// + /// Helper Class that logs information to the default Trace Listeners + /// + /// + public class Logger + { + /// + /// the current loggers category or name as identification in the log file + /// + /// + /// + /// + private string Category { get; set; } = ""; + + /// + /// Create new logger for an category. An category can be any user defined string + /// + /// + public Logger(string category) + { + Category = category; + } + + private void Write(string message, string category, LoggingLevel LoggingLevel) + { + if (!IsAboveThreshold(LoggingLevel)) return; + + var SB = new StringBuilder(); + SB.Append("\t"); + SB.Append(DateTime.Now.ToString()); + SB.Append("\t"); + SB.Append(LoggingLevel.ToString()); + SB.Append("\t"); + SB.Append(Process.GetCurrentProcess().Id); + SB.Append("\t"); + SB.Append(System.Threading.Thread.CurrentThread.ManagedThreadId + ": " + System.Threading.Thread.CurrentThread.Name); + SB.Append("\t"); + SB.Append(message); + + Trace.Write(SB.ToString() + Environment.NewLine, category); + } + + private void Write(object obj, string category, LoggingLevel LoggingLevel) + { + if (!IsAboveThreshold(LoggingLevel)) + return; + + var Message = new StringBuilder(); + if (obj is Exception) // Special handling for exceptions so they spill more info into the log files + { + Exception Ex = (Exception)obj; + Message.Append(Ex.Message); + Message.Append("\t"); + Message.Append(Ex.ToString()); + } + else + { + Message.Append(obj.ToString()); + } + + Write(Message.ToString() + Environment.NewLine, category, LoggingLevel); + } + + #region Logging Methods + /// + /// Writes an Informational Message to the log listeners + /// + /// The message to be logged + /// + public void Info(string message) + { + Write(message, Category, LoggingLevel.Info); + } + + /// + /// Writes an informational message to the log listeners + /// + /// the objects .toString method that will be logged + /// + public void Info(object obj) + { + Write(obj, Category, LoggingLevel.Info); + } + + /// + /// Writes an informational message to the log listeners + /// + /// The message to be logged + /// the objects .toString method that will be logged + /// + public void Info(string message, params object[] args) + { + Write(string.Format(message, args), Category, LoggingLevel.Info); + } + + /// + /// Writes an debug Message to the log listeners + /// + /// The message to be logged + /// + public void Debug(string message) + { + Write(message, Category, LoggingLevel.Debug); + } + + /// + /// Writes an debug message to the log listeners + /// + /// the objects .toString method that will be logged + /// + public void Debug(object obj) + { + Write(obj, Category, LoggingLevel.Debug); + } + + /// + /// Writes an debug message to the log listeners + /// + /// The message to be logged + /// the objects .toString method that will be logged + /// + public void Debug(string message, params object[] args) + { + Write(string.Format(message, args), Category, LoggingLevel.Debug); + } + + /// + /// Writes an warning message to the log listeners + /// + /// The message to be logged + /// + public void Warning(string message) + { + Write(message, Category, LoggingLevel.Warning); + } + + /// + /// Writes an warning message to the log listeners + /// + /// the objects .toString method that will be logged + /// + public void Warning(object obj) + { + Write(obj, Category, LoggingLevel.Warning); + } + + /// + /// Writes an warning message to the log listeners + /// + /// The message to be logged + /// the objects .toString method that will be logged + /// + public void Warning(string message, params object[] args) + { + Write(string.Format(message, args), Category, LoggingLevel.Warning); + } + + /// + /// Writes an error message to the log listeners + /// + /// The message to be logged + /// + public void Error(string message) + { + Write(message, Category, LoggingLevel.Error); + } + + /// + /// Writes an error message to the log listeners + /// + /// the objects .toString method that will be logged + /// + public void Error(object obj) + { + Write(obj, Category, LoggingLevel.Error); + } + + /// + /// Writes an error message to the log listeners + /// + /// The message to be logged + /// the objects .toString method that will be logged + /// + public void Error(string message, params object[] args) + { + Write(string.Format(message, args), Category, LoggingLevel.Error); + } + + /// + /// Writes an critical error message to the log listeners + /// + /// The message to be logged + /// + public void Critical(string message) + { + Write(message, Category, LoggingLevel.Critical); + } + + /// + /// Writes an critical error message to the log listeners + /// + /// the objects .toString method that will be logged + /// + public void Critical(object obj) + { + Write(obj, Category, LoggingLevel.Critical); + } + + /// + /// Writes an critical error message to the log listeners + /// + /// The message to be logged + /// the objects .toString method that will be logged + /// + public void Critical(string message, params object[] args) + { + Write(string.Format(message, args), Category, LoggingLevel.Critical); + } + + #endregion + + /// + /// Checks if the message must be logged, depending on the logging level + /// + /// + /// + /// + private bool IsAboveThreshold(LoggingLevel loggingLevel) + { + return loggingLevel >= LogManager.LoggingThreshold; + } + } +} diff --git a/ProfinetMonitor/Logging/RollingFileTraceListener.cs b/ProfinetMonitor/Logging/RollingFileTraceListener.cs new file mode 100644 index 0000000..2383006 --- /dev/null +++ b/ProfinetMonitor/Logging/RollingFileTraceListener.cs @@ -0,0 +1,145 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace ProfinetMonitor.Logging +{ + using System; + using System.Diagnostics; + using System.IO; + using System.Linq; + + internal class RollingFileTraceListener : TraceListener + { + + public string FileName { get; set; } + public int MaxFilesize { get; set; } = 512000; // 512 KB + public int MaxFileCount { get; set; } = 5; + private TextWriterTraceListener TraceListener; + private object Lock = new object(); + private int Count = 1000; // Start at 1000 to check size and file-count on first written message,after that every 1000 MSG + + public RollingFileTraceListener(string fileName) + { + FileName = fileName; + var File = new FileInfo(fileName); + + // Create Stream manually to open "Shareable" so to enable reading while writing + // If an IO Exception is raised, probably the application is already running. In this case create an new + // filename with an perpending GUID + // On Error Fall back to default system + try + { + try + { + var Stream = File.Open(FileMode.Append, FileAccess.Write, FileShare.Read); + TraceListener = new TextWriterTraceListener(Stream); + } + + catch (IOException ex) // The log file was probably already open for writing + { + File = new FileInfo(File.FullName + ";" + Guid.NewGuid().ToString() + ".log"); + + var Stream = File.Open(FileMode.Append, FileAccess.Write, FileShare.Read); + TraceListener = new TextWriterTraceListener(Stream); + } + } + + catch (Exception ex) // Something unexpected happened like Access rights or similar + { + TraceListener = new TextWriterTraceListener(fileName); + } + + if (!File.Directory.Exists) + File.Directory.Create(); + } + + public override void Write(string message) + { + lock (Lock) + { + TraceListener.Write(message); + TraceListener.Flush(); + + CheckSizeAndCount(); + } + } + + public override void WriteLine(string message) + { + lock (Lock) + { + TraceListener.WriteLine(message); + TraceListener.Flush(); + + CheckSizeAndCount(); + } + } + + private void CheckSizeAndCount() + { + if (Count % 1000 == 0) + { + lock (Lock) + { + CheckTraceFileSize(); + CheckTraceFileCount(); + Count = 0; + } + } + else + { + Count += 1; + } + } + + private void CheckTraceFileSize() + { + var TraceFile = new FileInfo(FileName); + if (!TraceFile.Exists) + return; + if (TraceFile.Length >= MaxFilesize) + { + TraceListener.Flush(); + TraceListener.Close(); + + var MoveToFile = new FileInfo(TraceFile.FullName + ";" + DateTime.Now.ToString("dd-MM-yyyy-hh-mm-ss") + ".log"); + if (MoveToFile.Exists) // if it already exists, then this means we filled up an log file in one second! so something is clearly wrong + { + MoveToFile = new FileInfo(TraceFile.FullName + ";" + DateTime.Now.ToString("dd-MM-yyyy-hh-mm-ss") + ";" + Guid.NewGuid().ToString() + ".log"); + } + + TraceFile.MoveTo(MoveToFile.FullName); + TraceListener = new TextWriterTraceListener(FileName); + } + } + + private void CheckTraceFileCount() + { + try + { + var TraceFile = new FileInfo(FileName); + if (!TraceFile.Directory.Exists) + return; + var Files = TraceFile.Directory.GetFiles(TraceFile.Name + "*", SearchOption.TopDirectoryOnly); + + if (Files.Length >= MaxFileCount) + { + var Ordered = Files.OrderByDescending(a => a.LastWriteTime); + int Cnt = Ordered.Count(); + while (Cnt > MaxFileCount) + { + Ordered.ElementAtOrDefault(Cnt - 1).Delete(); + Cnt -= 1; + } + } + } + catch (Exception ex) + { + return; + } // we ignore errors + } + } +} diff --git a/ProfinetMonitor/MonitorModeDialog.Designer.cs b/ProfinetMonitor/MonitorModeDialog.Designer.cs new file mode 100644 index 0000000..b9d3430 --- /dev/null +++ b/ProfinetMonitor/MonitorModeDialog.Designer.cs @@ -0,0 +1,102 @@ + +namespace ProfinetMonitor +{ + partial class MonitorModeDialog + { + /// + /// 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(MonitorModeDialog)); + this.notifyIcon1 = new System.Windows.Forms.NotifyIcon(this.components); + this.contextMenuStrip1 = new System.Windows.Forms.ContextMenuStrip(this.components); + this.stopMonitoringToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.showLogFileToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.backgroundWorker1 = new System.ComponentModel.BackgroundWorker(); + this.contextMenuStrip1.SuspendLayout(); + this.SuspendLayout(); + // + // notifyIcon1 + // + this.notifyIcon1.BalloonTipText = "Monitoring Devices"; + this.notifyIcon1.BalloonTipTitle = "Monitoring Devices"; + this.notifyIcon1.ContextMenuStrip = this.contextMenuStrip1; + this.notifyIcon1.Icon = ((System.Drawing.Icon)(resources.GetObject("notifyIcon1.Icon"))); + this.notifyIcon1.Text = "Profinet Monitor"; + this.notifyIcon1.Visible = true; + this.notifyIcon1.Click += new System.EventHandler(this.notifyIcon1_Click); + // + // contextMenuStrip1 + // + this.contextMenuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.stopMonitoringToolStripMenuItem, + this.showLogFileToolStripMenuItem}); + this.contextMenuStrip1.Name = "contextMenuStrip1"; + this.contextMenuStrip1.Size = new System.Drawing.Size(162, 48); + // + // stopMonitoringToolStripMenuItem + // + this.stopMonitoringToolStripMenuItem.Name = "stopMonitoringToolStripMenuItem"; + this.stopMonitoringToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + this.stopMonitoringToolStripMenuItem.Text = "Stop Monitoring"; + this.stopMonitoringToolStripMenuItem.Click += new System.EventHandler(this.stopMonitoringToolStripMenuItem_Click); + // + // showLogFileToolStripMenuItem + // + this.showLogFileToolStripMenuItem.Name = "showLogFileToolStripMenuItem"; + this.showLogFileToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + this.showLogFileToolStripMenuItem.Text = "Show Log File"; + this.showLogFileToolStripMenuItem.Click += new System.EventHandler(this.showLogFileToolStripMenuItem_Click); + // + // backgroundWorker1 + // + this.backgroundWorker1.DoWork += new System.ComponentModel.DoWorkEventHandler(this.backgroundWorker1_DoWork); + this.backgroundWorker1.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(this.backgroundWorker1_RunWorkerCompleted); + // + // MonitorModeDialog + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(241, 129); + this.Name = "MonitorModeDialog"; + this.Text = "MonitorModeDialog"; + this.FormClosed += new System.Windows.Forms.FormClosedEventHandler(this.MonitorModeDialog_FormClosed); + this.Load += new System.EventHandler(this.MonitorModeDialog_Load); + this.Shown += new System.EventHandler(this.MonitorModeDialog_Shown); + this.contextMenuStrip1.ResumeLayout(false); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.NotifyIcon notifyIcon1; + private System.ComponentModel.BackgroundWorker backgroundWorker1; + private System.Windows.Forms.ContextMenuStrip contextMenuStrip1; + private System.Windows.Forms.ToolStripMenuItem stopMonitoringToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem showLogFileToolStripMenuItem; + } +} \ No newline at end of file diff --git a/ProfinetMonitor/MonitorModeDialog.cs b/ProfinetMonitor/MonitorModeDialog.cs new file mode 100644 index 0000000..124573a --- /dev/null +++ b/ProfinetMonitor/MonitorModeDialog.cs @@ -0,0 +1,73 @@ +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 ProfinetMonitor +{ + public partial class MonitorModeDialog : Form + { + private int MonitoringInterval; + + public MonitorModeDialog(): this(0) + { + } + + public MonitorModeDialog( int monitoringInterval) + { + InitializeComponent(); + this.MonitoringInterval = monitoringInterval; + } + + private void MonitorModeDialog_Load(object sender, EventArgs e) + { + + backgroundWorker1.RunWorkerAsync(); + } + + private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) + { + ProfinetDeviceMonitor.RunMonitoringMode(MonitoringInterval); + } + + private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) + { + this.Close(); + } + + private void MonitorModeDialog_Shown(object sender, EventArgs e) + { + this.Hide(); + this.Visible = false; + } + + private void MonitorModeDialog_FormClosed(object sender, FormClosedEventArgs e) + { + notifyIcon1.Visible = false; + } + + private void stopMonitoringToolStripMenuItem_Click(object sender, EventArgs e) + { + ProfinetDeviceMonitor.StopMonitoringMode(); + } + + private void showLogFileToolStripMenuItem_Click(object sender, EventArgs e) + { + try + { + System.Diagnostics.Process.Start(Logging.LogManager.LogFileName); + } + catch { } + } + + private void notifyIcon1_Click(object sender, EventArgs e) + { + contextMenuStrip1.Show(MousePosition); + } + } +} diff --git a/ProfinetMonitor/MonitorModeDialog.resx b/ProfinetMonitor/MonitorModeDialog.resx new file mode 100644 index 0000000..adba825 --- /dev/null +++ b/ProfinetMonitor/MonitorModeDialog.resx @@ -0,0 +1,783 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + + 294, 17 + + + + + AAABAAUAAAAAAAEAIAB/UwAAVgAAADAwAAABACAAqCUAANVTAAAgIAAAAQAgAKgQAAB9eQAAGBgAAAEA + IACICQAAJYoAABAQAAABACAAaAQAAK2TAACJUE5HDQoaCgAAAA1JSERSAAABAAAAAQAIBgAAAFxyqGYA + AFNGSURBVHja7V0HXBTH938LAoK9G7vGDth71Ni72CtgjcYYExONUQ/zT/KLYEvUGFM0Ggtg7733giUK + ctiNRqMmdkU63P7f7BW23u4hx4E3389nr8zOzr6dnfnOmzdvZhigoKBwWjCOFoCCgsJxoARAQeHEoARA + QeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARA + QeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARA + QeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARA + QeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQeHEoARAQZFD4RMa + 5AIMWwqrcVusyfgNbnikAsv+B8Aewd+39QEzDNbSoARAQZHD4LMyyBVc2C4sMJMZhm2M1TiX+RwLpFJz + nwYkgotIEHMgzWWjfkhwqlxalAAoKHIQvMN0pbHW/oYVt5spCGs7E88Cewt/32dYKMMyUAl/ezGm+o0R + jiAdDNMHhvwtTo8SAAVFDgFW/ioMA7ux2r5LqjVW7Ehs7UPA4LJPHxj80hzPJ3xKAZZ1aY8/p2L8uhgf + eYH9By/oFBMQEsNPkxIABUUOAFb+Yvh1lGGYGliZUb2HH7Hy6vQBIYlK1/iu+Cq3IVdaCFbz8RjXBa/7 + izEwTZEsHpnjUAKgoMjm8F01lTEYmFCs/P4sF8LOYVmY4oL1F9V9D/ydB1v6IvjXA0/G4fl/gWXiYwKC + DT6rglxYlp2DFf1zThNg2bVIHoNiAkO4pCgBUFBkc2Dr3xQr+FGsrm7Yip9i0lza6odMT8Twr7EGj8FK + XIJU7vQr2OdICruRHSZja/+PT7jOHQnhGMZtjCcNSALNsStwmsSkBEBBkc2BFXg1VtWBWLFZVP47YOt9 + gIR7hwetwAo8hAsHuIRBSXhUwbBCxqrNHjOw0PpyQIjBJ1TXEVw4+wEZJAjVBwQPIWlQAqCgyMbwCZua + G+vsHayqJbD1v46Vtxa23qSi8wngKf4trfcPSfIJn1oUu/u78H9DPFhs7ishAdyptez/GIN76l+YTgUM + f4p6QAl9YEgaJQAKimwMVPNbYJt9GCuuK/79Ve8fPNZ8zgcJADgCwAoNLEcApvDZ+DUJuBFAtiqG3+TC + w4KWY5M/1Hw5phVDCYCCIhvDO1zXjwFmHfmNGsCEGP+QeennLBrAc/zrg937VJZ1qYO/lyFplMLavx1/ + 98RrOG9A77Cg8Rg+35TWQAxfSwmAgiIbA/v/g/Er3NRbH4et9s/mc2YCwMpMLPqxDOcKzHiS//h7Af7+ + P4z/Kj2toJH4tYT8xguGx/gHL6cEQEGRjYGVtj9+rTX+Yz9HdX6++Vw6AUAynruBQXnxKI0HcQ0man97 + bOXv8OJ/ivF/5FICdhCeW0MJgIIiGwO7AC2AuPIC44K19hd9QPDH6ecsBEAqvzex+KGKPxiVhT8YYjNg + YRnGH2GO7xMWtAzPDeOqPwu+MQEh+hxHAN6rdC4My816siI7NwRi5b91YOakYuakar6AB59QnRu4gKsd + swDVOzY52n+G9gcywXfVFAb7iO5gx9Ef4qUW4z8jOSPX+oRPzcWf2KINtr1bSGNS9EOC02yWLUyHxQ7c + sIK5vNH9rYDlso9JjgkItiRYM0znhfe8jRW6OJ69hv382vqAGWZjH2cENBMAqvQpGIbysdj6MxWJ+y+W + lYp6/xmp2P/HJNib+FEJw59hWiVIGc8xBOAdpquAeT0Af3ZBoQtDphfi9BfJEm8qFnZh2K/4Mh6pXem7 + 7Cs3NpfhPUzCHzO5LgbltmNWECH/wY/FeGy77B+iWpi9Q4OKolx+KF9ffMqymZ93AuFI5Y/AX/OQCG6o + 5t2qrxgDm1YLBRqE17ZijGqs/TKPZZ4xDLvGYIDllwND4lXzLlyXB2UifvVEvmqMUb3mIVMJIA0/rjMs + M58xMKeih07nEsayv45hmH7GUT3ojBV3n1E2oQZACMAU/jOGj+WaMhaq6ANCbuFztMfKvweMLsFrUP0f + ZJY+WwMf3g0F/xgL8DQUt0hW3df0Ss9iBnXV+wc/UYrnExpEZmctZBm2G2Nz6/VGEhpQxm+wxZjObzFk + 8q87yvUjylgx62Qj4rEPUShSWKMU827ltLzgymIpZ0ejjJ5ZJprRaLbeBQxDov1nJinKFxZUF9/rL1gG + Ggs97ewuXwJ+BGDebTLKoWuJ7++AyRMwAs+1wXMJGP4Hhgdi+A2WZWtjWIopfn8MDwNSvw3MB/i0qzGf + D2MeNyMaGmOA1vrAkGMA2ZwAUP1xQX2GuDsGmcZBsxyYYV8jW/5P7hyyagn82oMZW8dBsiWiiueNKt5f + CvL1QdlC8WeWVS6RgNuxD+ondwqJMzdXSBno4xjRuAk1vbHSbFWQrw4q+zvAaFRzhHz4Tlkf1KISfMOm + uRjAsBa1gL6mcz+Y5gKUxPwriAFE67qBLT3XEPiGBRGiqEZqNz7lc/z+EPlrGpkejOFbmDSmN3aDsv9c + AHwJ7UwvwcNxUrBnGCatWfTgWYKVVWqvnsykGlyXYQYOdWw2sgF6/5BwcShWflJwo5gs1JpkZHuFeVMe + NagXEvnCdOOwQP/kONm4irQMyX2EONxnZZAX6wKHGKPvvAPFY+tjpb5I/pB1AFCe46RvD0bdfgF+f4Xy + xyolgP1+JFl2ColHjIh4zT383RSvuW+Ok20JAPsx2OKzO1DwTo6UAzPtNn7Vwkx7zQ/3CdfVwq/TmIVe + DpWPZadiKzZTHI4EEEymizryFWMTQ6aqkr6pQEPxCZuK/XzmErZKWdstkWI/klMHcSBWnD5YcdZxlncH + AsvecCx3y83/kZhqs67sVpSrPGvspOrxmINa4H7sCj5iUeEH44JABfC7Jf6chKTRDLiWHx7id3d8F3/y + 75GdCaAUZsF1fNg8WuJ7ueYCLzcPyO3qBm4uruCK7448XJIhFV6nJMGL5HgwZMBWY/K/Jv0rwbxrrGCf + o2xztaThim8hH8rm4eqO8uXi/udCGVMMaZCUlgqvUhJQxgwZzgkBfIay/cgP813+lYvBzXANn7+yLWmR + /CrhlR+K5s4LJXLnAReU8xXK9SgxFu6/fgHJBpuN58TIVg0r2T/8QCTPdni3/VoS8MT8cnex0vuTscEl + oZyJaeqDOPhud2IF6yYOR/lWYcKDbH1Ygny53Ll8s2RAWgq+Z0NGkiLy9Ub5NgtkC9NVxoq+GO/QimeX + eIpx7+A3aaTIKE85PEoxxvMsZzcAGIFpXZXLvmwJZOFOxtVPrKNJ8QrwSe32UMwzP0cAlsqPF5OHS8NO + UEJqMtyLfQpH7l+FLX9dgMeJcZrlwMzbhRnXVSqfbivew8/ateT+wY17gk/RcpDf3RPcsTAT+YhkpJAQ + k24qyheXkgjXnj2A/fdiYM9dPSRoKLw8+fxQvu0i2cqAcehIk1EyDxbajuW8oVuF2lC9cGn87wEuLsbG + j8wzS0Z57sY+gY03z8EmzD+t8mG9fMIYoKw+MFhInmG6LzDv5mhJI7hxL2j2ThXN+UGwWH8IVt88r0XC + Wdh9miKQbRU3dRa7TlDdppsiCMmHth8FBdzTlcIJx8Ph4tP7tiZFkIrvthK+23viE9j45MbMHYDveBz+ + rYXv2V3m2YhB8DLLMr/h75XYSMiOeGRbAvAJC/ofSveVWrzPsfKP8H5fU5qkMD+Mew5fRWyCs4/uaL0m + GDNvGj8MC7AHyqbHjLfawpbNUxA2dvkEPN20mTCIfH/+dxu+PLUOSeq1titYqIzyCVRsb66FhX2MiuWa + nGxduhp8VqcjVMhfjCNNNfkuYr5NOrUWHiWoyydHnjXDdOQ2W1A2P7XrCVmu6TgGqhZ6R1P+ERiQUIft + /x0uPrmnEpNTG3oiAQiMgPhuK6OAkfhTk+bJx7uYh+s6j0Wid+P+xyUnQJft8+BZkupoo1ze3cePqkoV + 15SXpGBV5WwVLEOMfvnAuCDINTzOujDs1ejBMxOt3Sf7EkC4bgOKp2oh/uX9AGhR2jay/i/uBQTsWwT/ + JsSqxsVi0hf7TRuFsk2tyGIfFgux1THrNli55rcMkFQsUkhJZXIxaSqC+2H43r8vIQmsVx1dxkLyN0av + ejkgRNB/QAL4H8pmlTxJ5Rpfqy34V3+P647YIp/+6T344NAyiE9NsS4fy36LBfgbYd7pyIjEJVAhT4JS + 2B3Z0X0CuLlqH119nZwIvXctgIfxr6zGw7wjeVYPCUqwRp5pvHwvZKBu9KhQC75r2s+SZ9efP4SBe3/j + uno2g4X9YGA66YdMz1j/QSOyJQHgSyA6VJRaC5sXVdfN2MKWzFuI+08K5+Log3Di4Q2IxcJZ2D03NCn5 + LvhVqg8lsTXmY96F3fDH1ZNqopDVVmtiIRGspuoTNrUnyzCbGZXs+6BGCxhft6Pl/4X//oKfovbD0+QE + rnKX8SoAHcr5QJeKdcDD1GoQpGKB6bZ9LtyPe2k1fdKHBc6wEyLgCsy/rdZaWNKnno6qdSdU+c2FleTd + nVePYdedSDj24DpXuYvlzgM9KtWDrhXrCkiCxF2E+fyz/ogV2bjC1R/7/+sFebcyqDi4wl3QMLLT/J13 + 4dfWwy3/SeU+8fC6hRj53X+Gs32x8Aw1pzn4btNY6/TJDbMZ3WEFLSxqAP+HefKtmmxy+KpBN+hftYnl + /17Myy9ObchIUkS+b/G9fpOhi21AdiUAUvGvqVlhy+crjATwqaWFeIWqVq+dP8IjUR+/Yr4i8EfbkVAU + WxQzTt2/Bh8eDVWRxDgCoBeNAGAhIXpssNpz/NxyMLQsU9Py/9dLB+AXmUozvHoz+LxuZ0FrOwLV2HOP + /7aaPlbEECzAQfwwk4p9B/OunNJ1U+t1hkHVmlnul2YwwKprJ1G2wxJjJInhh0TxbZPe4MojgReYx12Q + pGJT5P1oiDMLyuCNBHBblHe98b4bQQOGo4wT6nex/D/2zxX4+Fi4lktVgfLtwArWXRyOZW8byt09I2ku + bzsC6peoZPn/3ZnNsO7WnxlJirzbAfhu12XKw1pBdiUA8tZ3qrWwHcvUgDktBlsK8rXnD6D/nl8545oY + U7DQE3XXDGJ067vnF6vpYyHZjYWkizgcC/F2vGc3a9eSVnZ7t8+gFE87+QjV5pP/SX12Snnlgy1dPxPY + CkYiAZxVIwBgu6B8AkOpT1hQJWBIH1DeANipbE2Y+d5ArMzpRr4FUfvgjysnZPONgOTuzKZ9UFOpawkj + cccfXQlHHsh7+5qWoa4onlNB1rHDvPsGVEDuSbp3zXnduxWXj8P3kXvVLtUElG825t1kQd6F64gaFoV3 + r2FregXw3W3r/jkUzp3eKxy2fzH8+fhuRmRLIz77SJ62X2wjsicBhGEflmFUDYBf1u0EgTWaW/7vun0R + Jp+Wb1w+9m0NY3zbWv6fwNbkI5XWBF/EFCwks/hhPsbuyXXMOqseYmIDYAK2lJ22zYVnSdIRiFKeSADd + 0gmAVMruO+bB37HPrMgGpBZWiBFt9oB51wXf6g45A2B+7BKRLlNxrwKWsH13omDS6Q2Kld+MRsXLw9J2 + owRhf8QchXlRSqN57C69yADou+IrhnU1bEL5eoIKyHDp+s4fc8ZJc56MR43tMHZPMgFkaKyrmDwx76qb + DIA2O555F34HwjqMsXSV4rG7QgyAT5O0jzjxQFoJsmJPQmY8rDVkOwLwDtWRhn8XvghVB6DfWgXCe6Wq + cb9JAZlxfhusvnFO9iF/bD4QWmN/24yfseD+hgXYKli2hz4gZJtAvjDdu5hglJp/Qvsy1eGHFv4W7eTO + y0ecxpEkM4TWulRVmP9+oGX8+DpqJwP3LbJqPMICfBcMTNWYwGCBDm6NPMf6tOJI0CxTLHaZeu5cgF0m + dYs+0WiO9Z4KedzT5zltQ/U26Mxm2fgoH/FSm84P8wmfmocFl8uMcZzaKkoiKe70m2CxqJOh3L67foK7 + r5+ryqoGlC2eYdla+oAZtwR5F67zw/e6NSNp9sRu0v+a9rXk7SXU3gIPLFElVgX5DuBHR9Se7GoAJMh2 + BGBqYaPUrMTEALil6ydQIo9RxSaW6xGY4XIqV+k8BWBdp48hv4dxfDYNK9bIA0vhzyfKGhZXSMCAfdiZ + d/jhWEh6YyFR7cOSyvZRrXaW/3vuRMIkGYOQB7Z0i1sNgXqmviNHZOeQyG6eU7vFWmwhBooDUT4y/Nde + Lr/29JgIBTzSeWuJ/hD8eOmQpvdCnJe2dx0PZfMXtYRt/+sC6CI2yWafyYlli0i2sljgbpFJLWr3a4eq + /zzsApjxKP4ldMUWVYuDjwbcxuLig+QpMABi2SMTzr7LSILfNvSD3lUaackbDWB1qD3NyIwHVUO2IwBs + waoii17Bn1YNgFULFIcNqM6aGZczAO5aIBmfJi3XTGTmdtj6m+NGI0kMPbhUrYW9ih91JR6AYUEzMJkp + oIJfWvpDizLpXckfLuyC5VdPCeIQxxFd/W7QtWIdi2zn//0LPsK+tVpBV7ISYyX7h5HpnnQv7wvBzfpb + 7pOC6XfZ9oOmoVACop1s6fopVDSp5ARbb52HaWe2yMRmE5EBamDe3RHJ1hNl2wwa8KF3SxhXO91L9/i9 + yzDxlLJNjLSzWskBSXYTyiYYYsZyRzRPQp7tNCUiQnj70VCrWLpiE4z5suaWFmckWfm6ony7MnSxjch+ + BKCxhe1czhtmN0/31ox5co9Tm/kg1v/PareHVmW9Leo18Wr7FPuSJ/+9ZTV9rGDbsYJJhtJQPmKc7GLt + WuK+StRX4p1oxi9R+yDyidEj1jOXG9Qo9A50r1iPMxKaK+Xlp//AOJRNk6eiAbroA4OFBsDQoCpIm5dB + MmcdYF7zAUiCvpb/UaiiBuz/XfN7yeXiAgd7TILCnvksYUo2ALJRJRJAlcsBouHJMB2SJ6NKngS/igyA + pAtAPCaV8NeLRzDqyApNKrecf4Jp6Jn4dryrOVNMyI9ETgy+5rwhWtygvb9AzLOHtiZFQDbuqITy/Z2R + i21FtiMAn7Cgb1Cqr9XiTa7bCQJ4BsB/417A4X+ucH1sL1R3y2Pl9y1aFiubu6WCkW7C4ujD3HCXBieb + L5EABO6qWIDzomxXGRUDIBme3NB5HOTOle6hyS+Y5kznt8Y7bl+EuZH74EWyJrtPMhaSslhIBIuVoHz9 + Mcm14teai3HB/vsUyOeR7qK6MHIvLLp8XPN7KYrXHug1RTB68OWJNbDnXowkrhUfe2z9GVUDoBcSJDFW + lspbWLN8G2+cgW/ObdcU12QAFLSwSABVweh7YvNiLvWLloM/2n/AOU4RvMZ32G3HfHhqg8s5T7qrWFLq + xJiW+LY3shUB+IRNdWGBIRsgNrcWj7Tmf7QhY67aJ5ORlp+MwxPnH02tBLCd8CUIxpxQ/a+OOXaRUVnx + p12Z6jCXZwC0BlL5vz69AXbejQGD5pVl2NsYtYY+QFhIsBBPxzsGiV9rZey3b0T13YXnVvHR4eVw4uFN + zfnXsWxN+L7FYJ7cadBr53z4W8Yoh+QQhOQUwg/Dd5sHM+Sa2ugJQXHPvLDb7wtu7oRWfHtmE2y4dUFL + 1Fgyzx772AIDkE94UD/8ytC4e59K9eDrxr0s7zvy0W0YemApZMSCh+WOGCF7iZ277IVsRQCmFpb42Je3 + Fo/0nbeQ4SyRd58ciMGP+K8vuLSfU8G15SqbgPF88CUIp7GG63rg1xa1bPuibkcYWqOF5X8Sqq9JaSnc + VZ65PCCXqGA/iX8FQ/YvhntxL0Ab2LVYgOUMgAcx79qIw5uWqASL2gwXEFKfnQvg+kvV1c4s+KpBV+hf + tanl/71Xj6EbpiElU27Zqg5IAAdFspEW9pqabwdBZ+yyzWo+0CJvfEoS/Mn5RJjuZXIz5P9eELkfrr74 + V0ve3Ub5vMmKOiL5/g9ly5AHoNgAuOHGWfj23LaMJEUeZ1qMf7Cqk1lmIXsRQHgQ2deMGACtrv5TvWAJ + WIcqtrmApBpS4XHcS07lJu6gxEvtduxTuPr8IRy7fxWuYUFXcw3lA9OIwo8GMk4sP+I9P1W7/jfsv77H + 678GY2EgsxBJdudB9bZ/5YYwyqe1wMd97bXTMP3PndrkY1kdyiawEpsW1LwPZPFIEdqUqQHzeQ5TBF22 + zkHCeanhbsaRin1+EwX9f+IKvBC7UzJ5l4gf1cV9WO/wqT0ZcNFkABxfux184N3K8v/QXT2Mx+5GJmG9 + 3j+4vzhQiTzV4IJZuq7TWKhWqJQlLOTsVi2jODLgZvmTpbwPZNbDqiFbEQCqYYH4tVItXvfytSDkvfR3 + SAyAZMyVMTmHm6fZZhT4GjbiS+grDlcaYuPDy9UNdnT/HIrx3I7l3HpnN+0LnSumryR24/m/MGDvr5om + jiABdMMKJmALJKcq+DZjGJkhtrZlasL8loMFYT22z4O/Yp9qyo+BSFg6bOXMBJKUmsKNyd95LXVUwry7 + 4ZLsWi16+HcCxkXtaQ4Wty+03O+XlgHQokw6gc67uBv+uKI6b0MTUL4v8N3+IJAtTJef5B3KV8bW9Aq6 + e8K2buOhkMkDkNiZ+u78CW6ghpQB2QwMsBX0/jPUpjJmGrIVAWi1En9ZpwME1mxp+b/2egRMP78j0+TA + dzglJjBY5AFInFiYK1jBylq7tkqBYrCmU/qU0PiUROiybS48FU0JFau5L1Fr6bj9B4hTWRjEtA5gSSwk + guYbySkQZZMlz5alqsLC9wMFGsAY4pasMhJCkN8tN2zo/DG8w3NpJhOGpih4XGKEdfqAkAH8ILK2I956 + jxp5EpC1CbZ1/dTSvSP3I6M2RzLHA5DkX2ckgD2CvOOmAEM0ZMAA2KBYOVjaLt0ASLTP7jvmazXmioWL + 4ZYBC8waAyBBtiEA71AdWcLnEBZSq5P7iUPKqg5joGaRdFtS8NktsEbTAhCaQJxY3sdCIjCRYyGph/Kd + UVtkQ+wBqEfthAy3pYk0ktpFy8DK9qMtBYfYCdpsmQ2vkq1O3zb7J5AVisRTgGeibJPlrvEpXArCO34k + WKlm1dWTMOOC9fVWSHSyIEe3ivUsz0Ms3INQU7mj6KbMBun9hQZA0xDbdbXRE4KySDTbun1mcaklQ3+9 + dy6AByrTe7WBfYmE4hMTMEOwQhG+28H4fBmaZTQI+/5EOzKDDK8OyagHIAurYwKCB9t84Rsg+xBAuC4/ + CkOsxCWtxSP+7FuxhShqGmMnU2cH7fkFrr74L1PkwAr2Gj98pH1YXX8GpENsYujqd+Fm2pmx8/ZF2dbS + FwkstP2HgmG1FhtD4KVqy8FiHzZE2ocN0x3AQtxW7orcWJkO9ZosGAaMxfuQiqXkCET6tmO9W8No3zaC + KcNz/twBodfPKMlmAAPTWh8YfEyUd2RKZIwWAyCZrET8O8z3vP3yEfTA7gabgQolI99l4tyll5LnHEZj + 90SM/2vQDfrxpgCHIbHOuqC6kJW8dMBOw4YnywyABNmHAIw+9tcwF1yVpCIFqFqB4rCOeACawp4nxYGf + FZWLMc0aZyXh8ts5YPwoJo1pED1kutgAOA/L5GfirDOnbL7P0jYjoCFvSuj0s1th3a3zXDyGd12NQiVh + FbbKrryhufaoAfyb8Epg4JYANWIkJ8FqujXDp3qi+kRM+nlB5lqS3rcNe0Cvyg0FSRHtZMLJ1YLFM0jc + kl754Ys6naBD+VqC+GSy1dQzmyStG69iJ2BFfRflE3jAYN71xSjrxa9Vbl4/599RPX0U+NA9PXx2Yi0v + /2zb88l83rRewAasYP3EcZAADuD5tub3Kd1XihGUIPPzEm2UdFfK5kt3j56O2uhafN9KFYvlj2DwZDSd + a4V5pzJBJXORfQggXDcKhVkMvArLyLzegZWFKtfVZ/dhwN7fuCvEBUr8LffwMoUpFAvJEH483/ApDAsu + x/Bcc0YQG4BfjIkHIGcA5HkABuz7DaKe/iMhomoFSnC2Av5CG72RyG7GPpEUPgBewWShPRYSgZXYNIsN + +7DEA5DlF3iLpGXyFIJNSJx85yQComKfxP715af3ILerO3hjn7Zh8YqSeAfuRnOaDFlkVfrkpv8s3EQC + qHo5ULhtmbGFhS/U2nAi8y/vB0LzUlUtYXOJC/W1U4rvkV+Arb1jU7zxqD0tEOVdIaMBEBTXHZN7XvK7 + WO68sKXreG69R/M7IsOrxAAoV/aUiN0UToaeK2DZ0z42mwnITgQwH4UZL9cqGP8bRQ1CFXsAbzx6xZXj + 8EPkPst/Y0URDRIDCCoDSBgdeNdDUIy0D5sP4xArcVlBTNGVPoVRre/woaVVT0hN4iawPOFm2zEW2ch3 + +bxFuOnCHryhwOH7F8GfvLXsxOSESMSwUiifwPvGJ0wXwDIQym/teNucWdCtXC0IbtZPYAtQA7Fqr7h8 + DBZEHxLYMYRPb8ljyTr7PqFBRKM7zjJsU0ZA7nwY84T4d+zAClXYRKAk3oeHlkEEt4aCdQoXE774vOl3 + e71oiA3fLZmwEclwq+kK36dM/vOflfMAXNZ+lKW8PUHtrQcSwCuTy7Jc5U8vB+m/TbiMBFrvckDWGQCF + cjkQ2MK6YAt7kOWWOhYKx38JxKWVTLqoWSR9tObriE2w+Ta3d4KMom9Oh1E8J8oILOFsY73/DIFF0Ts0 + qCHjwkawvAlKcq1R1/K+MLNZugE88vEdGMZ5hLGyrQfRFrxypU89//z4Kjj4zxUQV17evSLxRyPzFlAW + +cJ1P2GcceJr5J6wSzkfmIr9Vv6sQDmQdKJQ/rkX90Dk03/kfG/krpmEBPC9QLYwXR6MTFwOS6q9BzLB + a2OXdDeLeCTQXpwB8KWkpVdr+WXwijGwvvrAGQIPQMw7f0wrjL+0mDFNaariCj2iRgtuQVUzyFqJxODL + rakIfEKSErJM+VmJeTdU26NkHrIFAdQM1RXGuk2WlimspDIZvejcYSL2TfOa5qQTw9Bv2DLdef3UFF/6 + 8qz1p8VqMv56DkYvMWEfNlynyT+hM1auVrwlwIgH4tqbZ0HudRPVn8wE9OKtArQZ+45neCsGyaiK67AF + GyC+L8p3CM+1Fl8jbnXMKOThBX0q1Yd2ZWtCxfzFIZerK3ch8UF4gHl5/MENOHz/ClfxQSY9hQpoMO1Z + J+jDGrsnxLlLnYS9C70DQ3gelE8TYmH2xXSDmsz7UnzPkm4gy1xwSXZtcGnE/8T+CQvx62MxAUg1AGnZ + 6lmxHjR9J33WegR2pTbfiZSRJT23lOQHGfLMCmQLAsBCUg4luUHWNxeq6nKVgK9CWTcIyatdUlheFMuc + ZtJcWkQP/U7gjYPyfYlfs1SbQAWIWwCJYmrlGURhATEy24BhISatWlm5/AKZtPjwdHXjFiTlptOmJkOi + IVUUX75CiGVjWCB+zOX0AcKtqlC2Pnh+g/gaubxQSttavqq11Dz8jnk3Wibv1uJXf9l3wHtJysQgTzp8 + KIXxnoE4ADVEzVPTZIbMRPYggHAd0emJV4rF8qTM6OLKLDSSAe86oQqmqhmwZOQLW9jfJPKF6Sbi1/dy + uaVWSOWgtQKI7vEMDEzNmMBgyXgn5t9fjHE/eJvvryST+Iw4bYkGwGIFC5BWMJStO8bdJpe2ktotpzpL + rwFNFdEUloy/2+C7lbgTonyr8WugwnWiSi1vw+DLKtcFUyqDlmdn4TxjYN6LHjI9Y9tDvQGyCwGQ4Ss9 + ClPeSh9JVmgFY5RMXHnDGC+hcwzDYiGZIVkfy7iSLWxMjyqVR8niy1d9xS2EtcIsFA3JiWUm6gOC58mJ + 7hMetBnvoTrNVk0Gfn6qDZsKr2eI32vjGNEKwFzehevKMcb9693lKix/aFSJoGXIxuQnwIKW8oInViF5 + BsYMCZb4h6MGQLbJ1YnTUCIqsYyswm/+deZrxc9oipuCIV2y0v9fdP/sAZ8w3UyUZjJfLC2GO2GmC7Ne + y5CRKew6a1xfX9bf1Dc0qBDrwpLOfGW569WGezIyfs27jhTaRRh5vF5k/LPkXXgQqrAsaclcZK5XVaPN + sTLoakNU/0Fi91ozkDzJKADx0+6kNoxnS56JNUJxWrx5g0dYlu19OWCG7FRLlK8GXkg8m/KJ72vN0Chu + WLTYXsR5zm1OwsJkloUfLwdmzfRfqSzZBD4rg/JiJVuNzN4ZTLMBtRrzbH9oSzeCOOivwp9fY+V6YO0a + LCjv43Xh2BSXYkziWGu1zVDyR9BAAAZs9x9i5/pb/PlHjP9MxVlCNUKnuri6MHMxvY+A142yCpNAYgOV + DfmMhZc5jN9TYgKCI1XyrgImvBnTrsUanQwVNQ85Mfl5rDH/SHfuBcsyP2P+zURysroyh3dY0HCMNx9/ + 5lfShJRIXVLJOe1EmZxM6aayZFiZBbKzc8bcBjMJ2YYACGqGTnVDAmiKUpHWorCKoloIv/vzzxpPMXp8 + ASetWFuNL4BlIhgwHNcHzPhbs3xhumIMackYaMKaSEqpv4q/GuBXfUmhZWEDPuNTa/SBshNH+wOotp7F + Pr+WTQI5eIdNrQXGDUvLSJ5bWsMC8a+XqEKR4RSLwU6hAJMAPcPCEUhjruiHBmuadomy5WFYlzZI8mS0 + QrClutjZCfEu3qSdDBmRRRWjhZVJ0rWLxx9HMfS0PkC7Uw02QBVQf+qGBO/NcDZNYR6ItIGu5jzmaatJ + GJfMWU7kx5SxH/yNHwfxbyQSU5b3+cXIVgRgC7DvhgWJOWQuBjwWnoAZO+8Nks4UYN93GX4NEwUnMgam + ij5QuF12VgOJrDCS2H+Mae1AXgXbgnnXy5GyEWDeBaFs00XETYimHcp32JGy+YRPxW4WcwFlqy06pcej + QVYt5ZVZyLEEgIVkAgrPzesWtWKdlfqjWSZbmC4XGdbEnxXMcpnkJGpf/Zgs9vYSA8mzLcpyQNLCskie + AY4nT5QvFGUKEBXOWNY4Scvuu+VYg2nEirhdi5ej2oqNUK/L/jM09J6yD3IkAfiET0MVzUAWXRdbvl+C + sZA4tIUl69+DsUXgfFp5Q0ThSE4Bb5R4ZsgXpvsMRZonY4DriPLty1CimQRsYT0wx86jLJZdXEzEfhu7 + ENX0AdNT3iD5Nwa+W7JW+V4ZA6FkoZGcgBxJAN5kX3QGyJpLviIDWzQqinVjAkMysB9z5sEnNKgVuLBk + TTyLVd5USCTzDN4QxA5ByIZs2ke2SMqr5aL8TWr6uZco6CsIRH56eSrm55QnL7WtE2YnuObzzFOodd2x + +ELd+RmX+iru+osjUevfIOlMQR6fCnU9K5XqIrbsxsXcWZdwS2GjxMwBKdPEB4QYXMnS7y9Bk63WOnIm + ARhb2Gt4ePIfAlXEdTEBUlfZLJeP2wATvpGMtxvgfSSnYxlP2QKSLFkz63M8iNGvhKOfmSLLQFw1SRdk + MR5k6PeNCNsmAsCKR9SyUeYL1Rw5lMZOrbvvps+aU/KsQpTCcMmafYizGC9C3jtQ+qjiGYJ8g6LQqq88 + VKYwVETmlnuL7ooMzizDs7y1wdItzNIxAfHzm54pLQ0eLNtT4PmRqA7IeIpTWCneehAiIFrmWDBuJpoh + 2EoAnOFN3hXSus9z+s3kpuIq+3TLpW/NtVJ8veq4MW/c1vxbfE+lNNPDrHsZMhLp1SeyyKZlYOH58Wh4 + uGIvsEkO7QpTZB/8CcbG8E5GLraVAJbgBSPlfLiVCADAygwtnghqBACSNKT+43Jx5WSQxpNqDFomqoAo + LsikLYwrbfG1ykgQf+M+/D1nLRjirK8bSOF0IG7qZC1Bm/0KNBMAVn5XLJFkriPPOqu9FVZrTcUTUOQc + ebS6aco9HKtwnlVIV6ObrqoMWqBJ00g1wN9z18PrKPWVfCmcDqTiEwJQ3VNTDFsIgMzVf8jKzNgzw1pF + VJnsItEK5GafWZu9xqrG0Ta/QIv8wEuPr9Ired8paRJKBCQXN+Gvh3B7epis6l+hYkXo7z8IfLy9Ba69 + FNkbriznNajJk9JgMDBbtmxhN2/e7JmWlib3ksk2dt3xsKlvqLm0+ITryFK3J5UrufpEHAWDngVqLblq + 1eX5t8st4miMYp1YlOS1ZQagfBdA2l0SX2ON1B5vOwWP1h6RyFm2Qnk4fPgwVCpfQS13KHI4WMSMGTPi + v/rqKy/8Ka5GxO2Z7E+m2bWdwBYCmIQFcXb6heI+uLRPbsvsN1tVb83xeFNHJRkK6lqMKkGIErE6e0FF + C1G0DWDgvZ+3wKvTlyXXfD9/Hkz4dDxQOAeSk5PTateunXjt2jXxmm5EkyCN9Blb0rOlCxCKXwHWEspI + P1hLC2xNYLkhRKV41mwI2oYopZJYt3/ID2WqGRjF92LTTP3/SGn///jJE/Be02ZA4Tzo3Lnzs71798rt + nU4WKLTJk1MTAZA53diIEg8kHzUruzlcsXDLtJhaCUBN3WYUq6z6kuGM7F2URiDS09ayJJVcX18JsgTH + GQDXweso6XDvyTMR0LRhI6BwHnTr1u3Jrl27isqcIlPpbZoHo40AwnXFTQZAF76RTmlOtGyl5tUAteG1 + N+lvq52TPc8z1ikRgBZLvdpQqJZhUNlriQbwAyUACiMcQQDvY8Qj5v/W5krzwYriKBsB+QYyYastVduF + eoc1jUS6GKeUGpRGHsRkII5nbRRAjgjENgCxh6LVJc3T0igBUFjgCAKYhF+zpZVYrkCrt+BKlUvNqMYo + 3A8EcaQyyGkq8sTCSp5PzR9BLiPV3HrF6YFaONUAKHjIegII0/lizNKK+q0ZPLdaU0Eeg989TKfMYWRW + E5nEIpg5xZgisXJSqY0fysihFJdHNHlQ1kX4q4jo0kv4NVnxOlvux3czFsdTeCbuPsZ47+HvaWBdA2BP + R0SkNm7UyE1jzrxViI+PT/vtt9+Sd+3e7VG+QvmUiZ9PgJo1a3q8ecrZG1lOABmBaeWU3ViWO4hOPcbC + XyEmICQ+Qwlnnnzvoh5BlpfyNIeZ6uTiGP+QDx0pGydfaFAI68JO5f4oawBsREREUqNGjWze1z6nIy0t + jR09enTCsmXLyPvjynGZMmWSDxw4YKhatepbnR85ggBQa/DE1K/iDcqZw0wV7DzLQKPLgx2zCqpFvnAd + WU9wrSRDWGacPiD4Z0fKxskXpjuA+Wfc7psSgAS3bt1KrlOnjltcXJygDI8dO/bVwoUL82c03ZyAnEEA + 4bpqmPgVSNfuzQbBX7GFHZuVGaYg3yz8+lIUTKZY1kb5LmcgyUwDWeXXxYW5A6bdfigBSBESEhI7bdq0 + fOLwChUqJEdFRbnky5cvV0bSzQnIGQQQpuuDqYu2hOIIYChWMNV99uwN77Cgvdjci7snj8C4N+ATh8oW + riOr9ZANSt05mwAlAAGIN1zz5s3jz58/LyEAZE7YsWcXdGrXISNJ5wjkFAKYyTASY1oqsExzVLFtclfM + bGD/ugA+uZ5l2DKi0YAzDBiaRfvP1DRBw15AAiBbVa22BFACEODSpUtx+MzuSASyxk//4UNh5dI/3tqJ + UQ4hANNS0v0Y44wjsoWXFz8BmQ49WaYqjzmOqYKRr3tgVLWVZvClscZdes8yLMzRB6qvAlszVEfc/clU + uOH4txGmUYK1rNvPG99Pd/jJhT/J6q4uogyIY8m6a9ZHEZLw9EOMsxb/kC2dVSfn+66akptNcyXryA1E + Wargd35lXwHum5y3vGBrjkCnzkSwTRo2ejtLugJ+/Hkh+/knnyo+c5HixSAyKhJKl3g7F0zKcgLwCdP5 + sQz8BMY+KaOWmBZvPetCmZxtWOYfYNl2SALXFGULDcqLLXkIXvIB/vVUchFW8lWwNidAxXef7NwThkJ+ + gCSgOAXTJyyoHsr3O/6sA6Ktu8yyGe+hvLAJ9QNIR2paGrTv2AGOHjqsHAkzccmK5TAiYIijxbULspQA + sAAPxgK8FH/mVk5Aectu41nlveE1TMJZixVsoLxsOk+MvQorYQ/WlJQWAlBasYfvPWjN5YF3zsCy0CUm + IGSvXDzsBjXAiLswbjFraxnwf8sudkIJwIJbd25D3dq14XWs9Q2T2nfqCHt27jLNBH27kGUEgBWsArb8 + FzBSIWvefVoIQOxVr1VLwGsfYVtbVR8YLFn9FMlpEpLTLP5zyHv9KbsjW5u7b22uH2+68RwkAPFoAqr9 + 0/KwrOE4Xl9Xac1AJW9GST5TArDg598XwScffqQaL3/BAhAZGQkVypV3tMiZjqwjgHDdHCyQX6hdZG26 + q5aJPEoTbUxxyF5vdbCSCTwHUTYyHTKSNQ+VgfUKpTbvXylzlFpuHnaghtJdfK13uM4f44eanAG1T/2V + kyGbEUBqWirce3AfPHN7QslixbPsvimpqdClR3c4uHuvpvghP8yBKZ9PzNK8yQpkCQH4hgblYl3Ym1gg + y8tdJKuqZuDGcgtliObdx2Iz66sPCPmbH4oVrCNjeli5Sk5UP3fGRXDHNFQlUg2szKQfniym6/gyJRsM + INYGePKvQwKQ7EWABLUOv/op5Q//+T1cXK17WCMB3JyzBl7JrAeY1QRw/dZNCAgIgOjIKHB3d4cRH46C + 2SEzwC2X/b2Rb975C+rXrQ+xGvcuadisCWcryO3+dnkHZwkBYAUjJtR7DLd0mfQiuT6rloUu5IWQEoB5 + YhCeuwNpTFX9UOGWUFjBvsGvr833FctXp0hZ+On9QIFs154/gDFHVkIKa5CRwYhK+YvBH21HQC6GG0SA + yMd/w7jjq0CJABCT9f4hs/lp+ayc5om5dguveEetq+GChLO+40dQ3KuAIF0+qZGWb1DffnBg736J3FlJ + ACz2d/r16webNm2yhJFx9+UrlkOAv/13PAtbvQqGyNyHcc/FLZnOpgo3hMrt5QVHTxyHhnXqZkn+ZBWy + igBI67UuYwtzKKv/oBCPS0N+zYCN2MIKNgGpGTYVG2qGPGgHcXrmzwGVG0BQwx6C+6Ua0mDI/sWgf3Yf + 5GYGcjlYzhdmvZfeoIddPQmzLkq3cOc9tx/Kt12Ud+/iVxSIhkHlrq+Yrwis7/wJuLsqO66lIgH06NED + du+WypGVBHDhwgVo2rQppKQIBz2aNGkCJ06c4MjAXiDk07d/P9i8cZPk3AfjPgIv7I4s+H6u5NzU/5sG + wd/8L0vyJ6uQVQQQjK2vztEPi9QerPefMU0kG6lYF1G+KkpXfdvQD3pXEVYMUojCr2GFvqCcR2N9WsFH + tdpZ/n8TsQk2/nVBITZLfAJqIAHcFsgXpvNDgtqq5ek6l/PhCMeatZpUOGsE0KxR40zPdcmTYt4NGzYM + Vq6UOnG6urrC/v37oXXr1na7/+17d6FOrVrw6oVQ/Xdzd4NDR49CHk9PaNq4CSQlCTde9q1dCyIiIjiC + eFvQtWvXLCGALVjBetiSWOYDS52B6aAPDD7AD/UJn1oVRY/BQ7bZdMOWaH2nj+HdgtIt8/6JfQJ9d/8M + canSoXuSGSvbjYQ6xSty/4nG0HvnArgd+1RJvsvYtNfXBwidgTDvZmPeTdLyhB/7tIYxtdry5HsKMdhV + EcyfTkuFr0d+CuePnJBcn1UEcPfePahWtSokJsr7PXXs3Al27dhpNy3g12VLYOyIUZLwGr4+cOb0acjl + 4got27SG8xFCJ1MG5dl7cD+0b9XG7nmUVbA7AWABJmv//4uFuJBjH5V9jeXfB1tYgQEQ+/99UPQNSlcV + yZ0Htnb9FAp45JGmiJzy2bEwOHRf6luU182Du87cH38U/xJ6IQG8SkmSvxELO5g0xi966HSBho/5tx3z + rpuWJ1zSeig0fiddkfk5aj/8FnNUeBuVFYHsTQAkz74Mmgrfz5ilGMfNwx1Onz0D9WvVyfT7ExtI1949 + YP/2XZJzE6dOhu9DZnK/Q76fDUGTJEs5wMiPPoQlv/xm1zzKSmQFAZAm8BYDjvWiwD76PfyoHBMQItjy + COX7CmVT7NjVK1oGlrf/0KJW33/1GErnL2Y5f/BuNHx+Yq2kX14pX1HY0GUcuJn641GP7kDggSWKRk2U + b3KMyABomgZ9A+UrrfZ8HnifvX4ToYhn+pyWTw4vhyMPbwrv42ACePzsKVSu9C68UrG+D/tgJCz7fUmm + 3//fx4/A18cHnjx6LAgnrfuOfXugS9v23H/91cvQuGFjiH8tdBIqXb4sRF2MgiKFHNyeZRLsTgBqLWxW + AStYOFYwgdnXZ+U0F3BhD6PkLZWuG17jPZhQt7Pl/48XdsHY2h0sFftVUjz03vUT/JcQK7iuZ8U68F3T + dHvj4uiD8FO0ssspytcB5ROY5pGcvDHvzjMKnpN8VMpXBNYh4Xi4GofQklKTofXm2RCbIlSzHUkApPX/ + btYM+HpqkGpcr7x5IfqyHiqVzVznm9Xr1sLgAVJn0OreNeHP8+ct/fvklBRo26E9nDgi1KAIUazftAH6 + 9Ohlt3zKSmQFAczFU587+kGxgk3FCjaTH4YVjCz2EI0tbDml64Ib9wK/d+tzv1Ow/zxk32L4ocVAKJU3 + fSn1kHPbYPWNs4LrJtbpAMNqpvPK5JNrYdff0UqyoVbCVo/xnyEyAAb5Ya5uYQBUtadu5XwghGcAvPPy + MfTZvRCSDcLhLEcSQHxCAvjUqQW3r9/UFP/r4O/gG900TXG1gPhaDwoYDOtWrZGcmzDpC/hh9hxB2NLl + y+CD4SMkcQf6D4ZVoWFvhWuwXQkAKz8Jw84W08nBz0l2Quos9rMnQ2wo4FXrBsCx8G7Bktz/h3HPoSf2 + 46fU6wK9Kje0xNM/uQuB+5dAKs8nYGXbkVC3hNEAmIaVsA9qCbdeKS4NEAkGppE+UOKfMB9l07RVzwTU + SoZ7pxPO/r8vwYST66QZ4UACCF27GoYMHKw5fpkK5eFSZCQUKlAwU+7/+OkT8K1VC/578FAQ7ubuDvsO + HoBWzVsIwu/d/wdqYfwXz54LwosWLwYXLl6EsqVUe2bZHnYmgKmojzKP8MicN5hhsC+x710TNYAHAvnC + goh3j+KCIiWwP72163jI427UwKOxovujBkCG22byWtvktBQYvOdXuPbyEfe/IMbfgteZ++P3Y59ia0xG + C+R3XEYNQNYDEAnqAGonbUEDxAZAYps48eCGJJ4BCWDVFzPgZsRFyTl7EgAhwY6dO8PBfVIHpP79+2OF + ugA3bwg1AzIKsGrtGhjQt5/W21jFxh1boW/3npLw0uXLIdFEQeGCwmKahnnVZ+AA2LpBulHub8uWwIfD + Rtolr7ISdiUALMA1sAA7dEksAtT8bjJpTA390OmpIvlmonyTla6rW6QMrOiQbgBcd+00fPfnTijsYRwZ + KJg7fWRgxeVj8H2kcScl4pCzscsnFjvBuX9vwchDy6x4NbJBev+QEH6IyQPwOhjXGrCKPLncYE+PL6Cg + zEiFGI7yAzh1NgJaNH2P7EwrCPfy8oLLly/Dnn17Ycxo6fqpjZo2gRPHjoNbrjdblYvcd/DwobB2ZZjk + 3NDRI2H5InmD46oN68C/n4SboV3njrBr2443lsvRsDcB9MQKttnRDylnAKwZpiOeswdRvlZK141Blfrj + 2kYHQWLA+r+IjbDldiT3oAtaDIJWZb0tcf9+9Rj67f4FElAb6FK2Jsxqka7q/h59CBbgoSAbcSJsid0T + wcC8d3hQPbJID8qn6hhfOX8xWNv5Y6segGY4ggBI5es9sD9sXS9tSUeMGAFLly6Fh4/+A19fX3gqss4T + x6Ctu3dC1/Yd30iGFy9fgrevDzy4948gnGgZ2/aQ9OV7qWTUoHbt2vDo4b+C8Hz588O5P89DtcqK/mM5 + AvYlgLCgn7GSOXzRTqxhnyEB/CiQLVxH9L3LWMEUl3qZ06wfdKpQ25gG1tOh+3+Hi0+Miwp1LucNs94b + aNEOONdg7B5EP7sPk+p2hCE10vuTnx8LhwP/XFGSjYwzke7JPZF8pNlZo2UpKrEBkGWVpx6npiIB+PWA + PXuk79ZeBHDl5nXw9faBtGShw1QubD2PHj0KzZo142Qe/+VE+On7eZLrO3bvCru3bn8joxvp43fq0BFY + kQZSumwZiEENpEDefLLXEcPh8JEjYOWy5ZJz38/9Acj+ATkZdiMAb6MB8DgW4Pcc+YCs0QOwc0xgsNAA + GKZ717jUuLIBcG3HMVClUCnu//OEWM4A+Cw5gftfyMMLNnUeB0W90leNXh5zFH6I2g/zmw+EtlgpCUjf + t+/uhXDz5WN5+ViWbB7SUMY/4QeUTVPpmtagGwyo2sTy/+zDG7Dsyon0l8KY5kaA0Qi4a9oCuHdWOiJh + CwEkJyfDP/89hKTkZKvxCBXN+2EuLPl1keRcu3btOCIirTxB9NXLUL92XUgRpemJ3YTTKFttH19NsolB + KvEHY0bDssVSNX8oVu7lS5ZavX43dk+6d+nK2QT4qOZdE8LXrAIvTy/Z61wZlxR3F1euwOAzuhQrVszL + w8PDJSNEhloU+/Lly1Q8EqzFy5s3r3vhwoU9yFLQWtK1JwG4YgEmZm+HGgCxAL7Aj2pYwR4J5AvTjcQX + oehpUiZPQc6Q52Gamhr1+G8I2P+7IE5Ik17QvVJ9y/9LGGfogSWwttNYqFrIqFiQrgFxF05MS1W4E7sS + +/9D+SE+YUEMy7AnMP807dW9rM1waFDyXcv/6We2wNpb5+XvlgmjAGfPnU0Z9eGHbvqoS5I+vVaQSrB1 + 61bo3j19+QOSVv/BA2Hj2vWS+BMnT4I5M2ZlSAt48vwZ1KpdCx7euy8Id3F1gQ1bNkOvbn5Wr3/24gX4 + 1qkFD/6+BxkFkbtq1arJM2fONGAXLLctz/H69eu0L774Innt2rUeL168sOofnSdPnrTBgwcn4X3ckAhU + u4/2I4CwoNqmbcAdDDYaG4DaSABCF9sw3QJ8CZ8oXdWkeEVY3HaEpcBtuXkevjq7RRCnWclK8Gvr4dw0 + XILElGT48NAfsOD9QChgMhCeuH8VPjoapnQbQlA6VP9n8MN8wqfixcw10OABmDeXO+z2mygwSA7bvxj+ + fCy//umbEsDTp0+Ta9WqxT548OCNJsZXqlQJ9Ho9eHoKJ9acPHMaWrdsJdEC8hcqCFeuXoFSxUvafK+D + x45Au/elk4tKlSsLUZGRULRQYavXk+5J4KgREL50+Zs8MocCBQqknjhxItnHx8dL6zUTJkyImzdvnrqF + l4dJkyYlzJo1y1ONaOypAQRiC+bwNfvx9a3CFtafH+K74iuGdTWQ3XIUZ3WMrtkCPqljNDyRAvAtmcl3 + Wzh05unqBus6fQQVChS3xPv10n4Y7duWm1BCsER/GH68dFBROEQzJKcIUd41wLw7hT9VGbwmahph2FVx + M90vMTUZOm79Hp4lye+W9qYEsGPHjhfYar+xVjd79mxSSCXhZLpyy3Zt4PTR45Jz02fPlPXPtwbyTsZ9 + Ph5++fEnybkhI4fDiiV/aEpn/5HD0Ll9B0hLTdUU3xo+/fTTF/Pnzy+oRQvAFj+1du3aLnfv3rVpZlTd + unUTIiIiPNzd3a1eZ08CWICF+BNbErAHsIUdhy2sYHsubGGLsMBcQfmKKV1HrPytTVZ+YuAbvPc3uPL8 + oSTeF3U6wFCexx9xCvIuUpbTHLjCd2QFHHso7/mGshEPEzIF+D9R3g1D2ZZpeb7u5X0huFl/i6YSzTkl + /Q5prLwZ8E0JICoqKr5e/XqehjRDhi1yBQtia37lCpQsKd+ar9u8CQb07iMJ59x1z53HPrf26bivYmOh + Tr26cPumcAUkYv3fsmM7dO/cRVM6cQnx0LBRI7iij8noY1tQuXLluIsXL+bG/rqrWtyNGzfG9e3b16bW + n6BFixYJhw4d8siVK1fWE4DJAHgGC3FDWxLIfLCkHrTBFvYYPxTlq4UCXiSe3XJXuWNrSlp2swfg88TX + 0GPnj/A8SWp/qV6wBIR3/MgyBEcqPd9BqPeuhfC30hRgFvSMgakfPWS6QN/1CQ8iPqlfgAZ828gPeldO + X6tgx18XYGrEJsX4b0oA2EIbuvfpxezdvpNhWVvXazIO63377bcQFKQ8HyA+MQEaNW4MMZeEhkpSaYkv + f/8+fdVuY8HRkyegdYuWIJa1VOnSEB2jh8I2eBkuC10BH40eA0mJqts3WAW2yobjx4+nNGrUyGo3isg8 + cODA2HXr1uXTmjYBdqtSV69enUpsDWpx7UUAyGzMMwxw8MaKxADIVtcHzLCphS1LDIDdxmOlNmrgkaaZ + fHLIhYVyZdsPwLeYdDrB3VdPOH98JQMgagBLsfX/gB9WM4zbmOQcylcfNCCs/SioXSx9wsz353fAOjkD + oHk3FSSA67PJmoBSrUSrEZC0hitXhcOuPbttUok9PDwgoN9A6NWrl+pc/9nzfoDJE6Qc2LjFe3Ds4GFw + d1NfN5BUoAmTJ8H8OT9Izg0eEgjhK2zroRIj5d7DB2F56ErVtQRdWSbRhYXk27dv54qOjpb093U6XdL0 + 6dM9rHUD/vvvvyQfMnPxyRMBUWA+prVu3TqOrKMoBmpXKaNGjfJ477338mrpYtiLAMjy1Rdsudg+YP/E + /n8DcSjKtwjlG6101fulqsDCVumG+bXXI2A6ViwlDKvejJsxKM7wQ3f1MP7EGlAG+wnKt1AkG5lnSoYn + VZfIJR6Au/wmQuHceS1hT+JfQkKq8tBcakoqjBgYAEcOSB2TsmpBEC0gjkG1ateGJ/8KuBtcc7nCdiSe + zqZpu9bwOj4O6jdsANcvXxWEu6AWsmb9OujXq7fdn0Ov1yc2btw4V3x8vGC4uUqVKokXLlxwxW6AIpOF + hYXFBwYGWrYsN6Nfv37xa9as8dQ61GcN9iGAMN1YrAwO3xYbW9gwbGED+WE+YTqyTO9hFFdxCvDIGs3h + s7pGzzDOAHiGLOV1UfE+pbwKcK6/ed2FGtcS/RH48dIB2WtY4xB585iA4FMC+cKn1sNOhCYPwHpFy8Ef + 7T4AVxtWziGegH5+flnqCJQRkNb2g3FjYZmM/0DfQQNgXfhq1SHBYxGnuAk+ZCVkPgoXKwoxMTFZsgw5 + 2Xy0TZs2iSdPnhT041F2A/bR41q1aiWr3pNy16dPn4TNmzeLDR7s1q1bU/AdukMmwC4E4BMW9BP+G2eX + HNUI1ljFxmL//1d+OLawRcDYwhZVunZRqyHQrFRV7jeZAtx/989w89VjxXuR6rewpT+0KFMj/f74Aj86 + tAxO/veXwlXsE9MEJUHCSJ5jsHD8ChrQp1Jd+Lpxb5vGxgkBtO3cAY4fPCI5l50IgCDm2hWoX6cu9rmF + qyjlyZsHLkXr2UoVKlh98AlTvoR5s+ZIwrv17glbN2yyDN/aG3Pnzo2dOHGipKKPGTPm1S+//JJf7v09 + evQoydvbOxeq/wJDYYkSJVKQvFyKFCmiakDUgkwnAJ/QIAZrxDn8qakPay8gAaTgRxMkAEFXBAmgIVb+ + s0rXkT79l3U6QElP41Jer1OTIOTCbnittJSXCc1Lvgv93m1gYcEUQyoE43WKw3HARuJHI5RPPAX4R8zK + T7U8Y68KtaF16eqK+xACLwxM4cQVeOTgoXDvrF6SXnYjgDTUAgYF+sN6mfn733zzTcLXX3+tOByQkJgI + zVu2gAvnhPYQbobh+rUwoLd2Q+Kb4urVq4kNGjRwi4uLE1TaihUrJkRGRrrnz59fUplRxX89aNCgvOLw + Xr16xa5fvz6vq6trprBX5hNAeBD5fgaO9wAkO/NWxwr2gh/uHR7khwJqWmXXzgL+oA8Illi5kKC2IkH5 + ZSRJTbd18JJgtuI4qvHvy6jxpUqVSiLbdRUrVkzWkn4pRg8N69XnXJb5KPnOO6g9XIJiRYpCVoGMnLz/ + /vupp06dEqjtbm5uLHYDkps3by54BuIcgup/HKr/EgJYtWrVSySGApklmx0IgBsCfIJ/C9tyceaCa/N+ + 1vuHSLohWMG6YAXb6TjZjCsAMSy01AeEnBGfQ/k2onx2s07lNAIgcw1at28Lp49JVjFmFy5cGP/xxx9L + xshJ9+t/M4Lhm6CvJOl18esOO7duy/LnmDNnTvyXX34pGQ1A+eN++umnPPxuwP3794m3JTx79kxAGEh2 + SdHR0aQbkGnbE9lrFEDzQhb2AFYwsvDHe9i/viM+5xOm80ZJo1DcTOlDZUw+WIoyfBgzODhNfA7lm4Gd + +il2u3cOIwCCDVs3Q/9efSRj+VhJks+ePevq4eEheJcJSYnQoEljuBx5SZgQVrLFy5bCqKHDs/wZLl++ + nNCoUSPSDRCMBlSqVCnx4sWLrtgNsBh9ly1bljhixAhSyQVq/oABAxJQA8idGdZ/M+xjBAyfOhR7W8tA + w1p2mQ/2MRaTQVj5Zf1vvVfp3LAG7nYQQZEyvB8JatDlgJBnchGQAOqzDBxD+TT7itskQA4kgPiEeGjS + rBm3hyAfWBHYDRs2xGO/WKAFRMVEQ5OGjSExQei4VbBwIYhC9b9cKdU1VjIdKSkpae3bt088evSoeDSA + 3bt3bxye49R9ov737Nkzadu2bbnF8bZs2ZLq5+eXqRsn2msUgOwB+BPKPEppvb3MB5sMLHMQK7dOHxhs + dRKST2hQNXABsmCeL2QdST3Cd7uIYV3m6AOnxypFQgLA3gGMxcZqBopmkweYplxSJgD2dEREWpPGjbPl + Ejdzf5yfPPGzzyVDXx06dHiNBTgP3yj23cwZ8H9TpRtRdenhB9s3bbbrtmPWsGDBgtfjx4+X9OuxtX+9 + ZMkSznHn4cOHxPnHFdV/wXt45513kvR6vWvhwoUz9f3YbS6AacWdRgzLvI8tWgmrO32KN/+Ti6ts6jZg + jbmJrWqEa5pr9KWh36WBBniHBRVkgG2P6dRlgVF1mRQ8pVk2scldvNEh2ZCUhTj8iGQNcDomULgmoTUg + EdQkk5UwiYqQiXsqpL547XJn1mq/pLuPKopzOCIiIqlx48ba8yIL8eTJE24WIlYQQf83d+7cadiqJqF6 + zWlMycnJhvdbtUqJOH1a0k9etmJ56rAhQx1GcNevX0+qV68e6QYIGKhMmTJJly5dylWoUCHXhQsXvvjk + k08kBvR+/fq9WrNmTb7MVP8JsmRrMIpsBVIBiBWssyg8WxMAUY0nT56cMGfOHEnXaMiQIfErVqzgwm/c + uJGILagHEoGgPJJpuNiCsljZ7L/3uALS0tIMLVu2TDl16pSEnLAbkNCuXbvcWCHj9uzZI9ES1q1b9xJJ + INOs/2ZQAnA+5EgCILh582ayr6+va2JiosDoV7RoUUNkZGRq6dKl3efOnft64sSJkgqEfewErGRkIQ6H + llOULw7lk4xcjB49Om7q1KluderUcXn58qVY/U+JiopiixUrlinef3xQAnA+5FgCwBaUDQgIiENVWFLB + v/nmm1idTpenTZs28SdOnBCfZxctWhSHlSyvxlvZDdeuXYtv2LChW2xsrEATKV68eGLPnj0TFi9eTNR/ + QV364IMPkjDcwx7cRQnA+ZBjCYDg4MGDrzp06JDXYDAI+tHYSiZgNyC+e/fu+ZKSkgQtpZeXV8qFCxeS + qlWr5nACIE5BKH/C4cOH5eb4Sxw5ifV/+/btKVhRM731J6AE4HzI0QSQkpJCKlDSkSNHJJNk8uTJE4eQ + VHIydXb//v2eZGFOR8tPsHDhwteffPKJJjLCbg1x/nEtVKiQXYyXlACcDzmaAAi2bt2a1KtXL3eWZTWV + uSVLliSNHDky07zn3hQ3btxIrlevnuvr169VndEGDhz4Mjw8PH9mW//NoATgfMjxBBAfH2+oX79+4tWr + V1WdpfLnz58WGRnJVqxYMdv4N5DRgFatWiWfOHFCNa83bdr0CsnObgvrUAJwPuR4AiDulAsWLIj97LPP + VB2lsKLFHzx4MFMWz8hMEPnHjx9vVX5U/4n1H4oUKWK3oUtKAM6HHE8ABM+ePUupW7cu3L1712rlmD17 + 9qtJkyY5eGk6KW7evBmPWoz7q1evFDWTUaNGJS1atMgu1n8zKAE4H94KAiBawJQpUxKxgivK6+Xllfbn + n38mVq9e3eZVde0N0g3o1KlTwoEDB5RkM+zYsSMJK6j2JZAzAEoAzoe3ggAIrl69mtSgQQNX8Qw7M5o2 + bZpw/Phxj+xi/Rfj999/Txg9erRsBS9RokQCsf7bw/mHD0oAzoe3hgDIfnnDhg2LCw0NlR1SmzVrVsKX + X35p1xb0TYDdl1Qy71/s+UcQEBDwcsWKFXaz/ptBCcD58NYQAMGxY8diW7duTRyDBOWPLJ197ty5NF9f + X7u2oG8CQmBt2rRJOHr0qGA0g/T5Uf1/3aVLF7s7LlECcD68VQRAHIOwL5186NAhgdwtW7aMI9Z/tZ1x + HI1ly5a9GjlyZD6+T0OVKlWSTUuG233RGkoAzoe3igAITp8+nejn5+f65MkTbkSgePHiqRs3biRr7dll + UZXMBJm+/OmnnyYTX39CAmXLlk1dunRpSrt27VQ39swMUAJwPrx1BEBGBB48eJC0YcOGZGJd79u3b26s + SHYdPstMkElOMTExcdevX09u3759fkSurJKdEoDz4a0jAIqMgxKA84ESAIUFlACcD5QAKCygBOB8oARA + YQElAOcDJQAKCygBOB8oAVBYQAnA+aBIACdPnkxq0qRJtlk4g8L+6Ny587N9+/YVkTsFlADeSigRAFSu + XDmhaNGimvZVoHg7cOHCBbKEutyUakoAbykUCYCCggdKAG8pKAFQaAElgLcUlAAotIASwFsKSgAUWkAJ + 4C2FIgGULl06zdPTk7U9SYqcinv37rkkJSXJTZmmBPCWQpYAChUqxI4dO5Zxc3PY3pkUDsCJEyfSDhw4 + ILfuACWAtxSyBFCsWDF2zJgxjKur3degoMhGOHv2bNquXbsoATgRKAFQWEAJwPlACYDCAkoAzgdKABQW + UAJwPlACoLCAEoDzgbzszXh05wfmy5cPxo0bR5bTdrR8FFmIM2fOsLt375aru23xOGRLWpQAcg5+x+MD + caC/vz9ZktrRslFkEchiqhs2bCALkorrbjIejfGItCU9SgA5ByPASAICB5DSpUuT/ejZvHnzMjllRV2K + jCEtLQ3OnTvH7tu3jzEYDOLTf+HRBI/HtqRJS0zOQXk8TuPxjvhE/vz5oVq1apwmQEng7cSTJ0/Ya9eu + ka3J5Co/wVI8RuNhsCVdWlpyDsi7+h6Pz4G+NwohnoKx/x9l64W0IOUskNZ/Jx51HS0IRbYBWQxmGh6z + 8LB5TgglgJwHUvlX4uHjaEEoHA5i+CN2oS/xiM9IApQAciaq4jEHj054ZNuddCnsikd4zMTjVzwSM5oI + JYCcC7KJZkc8/PGoj0cxEI0QZDMQopJzXknBIzUL5SBl3gPky34S2GhEy0IQ9Z60+MTavx+MWuDVN5WX + EkDOB/ESLIgHWSaa7E3Pf6csZI93TCr+bDxaiMJJ4Q0Bo5ejNWTmc5C8WgHS0RRSuSaBcaTFXjD30TPy + LIQkn5mO15CB/r4cskPhoHj7QYjpDB41ReFEdW2NR0QWykL2UNgBRqs5H6RCfYbHAgflkUNACYAiK1AN + j5N4iNey/weM3msPslieuWAcThWDqNXDIft2AzIdlAAosgLEWElaXbENgLT8pFuQlTYAgkF4hIO0/JNx + 9GaQQYt6TgQlAIqswBQ8ZsiEL8bjQwfIUwuP43jkF4UTN9r38LjhAJkcAkoAFPYGGZlYhccAUTjpc38M + xmGsrEYBMBr7aojCiVNNVzz2OkAmh4ASAIW9kQ+PUyB1XCJDbu3B2BJnNQgprcajv8w54lQzxwEyOQSU + ACjsjYp4xODhKQp/AkZS+M9Bck0A49wKcR0g2kogOIkhkBIARUbhAtocj7rhsVEmLlHBiSNTgoPkJ8OA + W8A4LMjHn2DUTGI1pEG6DDl6TwZKABS2Ig8YFyZpB0aPOjWUAWlfm4C4sl4Cx1Ug4pvQEIyOVHwQQiI+ + Cykq1xO5H4LRF/+UA5/jjUAJgMIWkGG8+Xh8BPJuvc4IQmTElnDU0YJkBJQAKGxBJTyiwTgPgSIdxKdg + GGS9P8MbgxIAhS0gKjNRd3O9aUJvGciwYQ8wjmzkKFACoLAFZPycGMnedbQg2Qzf4PE/yIF2AEoAFLaC + WO5/xqMsOLcdgFR2MpmJrNA0DozDmjkOlAAobAUpM2TqMRnDz/2GaeVkEAIgPgzExyHZ0cJkFJQAKCic + GJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCic + GJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCic + GJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCic + GJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCicGJQAKCic + GJQAKCicGJQAKCicGJQAKCicGP8PBVkkDiOiO/wAAAAASUVORK5CYIIoAAAAMAAAAGAAAAABACAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAHQAAAB0AAAAdAAAA + HQAAAB0AAAAdAAAAHQAAAB0AAAAdAAAAHQAAAB0AAAAcAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwAAAA + /QAAAP4AAAD+AAAA/QAAAP0AAAD9AAAA/QAAAP0AAAD9AAAA/wAAAP0AAAD8AAAAPgAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAACAAAABgAAAE8AAADZAAAABgAAAAYAAAAGAAAABgAAAAYAAABTAAAA1wAAAAYAAAAGAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAA + QQAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAF8AAAD8AAAATgAAAEgAAABIAAAASAAAAEgAAACjAAAA + wgAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAEAAADAFhYW/yEhIf8hISH/ISEh/yEhIf8hISH/ISEh/yEhIf8hISH/ISEh/yEhIf8hISH/ISEh + /yEhIf8hISH/ISEh/yEhIf8hISH/ISEh/yEhIf8hISH/ISEh/yAgIP8HBwf8AAAATwAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAABECAgL/fX19/39/f/9/f3//f39//39/f/9/f3//f39//39/f/9/f3//f39/ + /39/f/9/f3//f39//39/f/9/f3//f39//39/f/9/f3//f39//39/f/9/f3//f39//39/f/9DQ0P/AAAA + mwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMCAgL/Tk5O/k5OTv5OTk7+Tk5O/k5OTv5OTk7+Tk5O + /k5OTv5OTk7+Tk5O/k5OTv5OTk7+Tk5O/k5OTv5OTk7+Tk5O/k5OTv5OTk7+Tk5O/k5OTv5OTk7+Tk5O + /k5OTv4qKir+AAAAnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMAAAD/VVVV/FlZWf1ZWVn9WVlZ + /VlZWf1ZWVn9WVlZ/VlZWf1ZWVn9WVlZ/VlZWf1ZWVn9WVlZ/VlZWf1ZWVn9WVlZ/VlZWf1ZWVn9WVlZ + /VlZWf1ZWVn9WVlZ/VlZWf0rKyv9AAAAnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMAAAD/9PT0 + /v////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////99fX37AAAAnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAABMAAAD/9PT0/v////////////////////////////////////+vr6/9XFxc/P////////////// + //////////////////////+bm5v9hISE/P////////////////////99fX37AAAAnQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAABMAAAD/9PT0/v////////////////////////////////7+/v82Njb9BQUF + /u3t7f7///////////////////////////7+/v8zMzP9Gxsb/fz8/P7///////////////99fX37AAAA + nQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMAAAD/9PT0/v////////////////////////////// + /8LCwv0aGhr+MDAw/J6env3//////////////////////////9zc3P0LCwv+FxcX/sPDw/3///////// + //////99fX37AAAAnQAAAAAAAAAAeqUsb3ulK+l7pSvqeqUr6nulK+p6pSvleqUsYnulKxd6pSzee6Ur + 6nulK+p7pSvqeqUr6nulLLl7pCwIeqUskXulK+p6pSvqeqUr6nCXKOsAAAD/9PT0//////////////// + /////////////////1JSUf6EhIT9i4uK/0tLSv///////////////////////////4eHh/1VVVX9cHBw + /W1tbf3///////////////99fX37AAAAnQAAAAAAAAAAeqUsh3ulLP97pSz/e6Us/3ulLP97pSz/eqUs + 2HqlKxp7pSz/s8uH/4+zTf+Qs07/1OK9/3qlLP96pStFeqUrrXulLP+60JP/1+TC/8HPq/8AAAD/9PT0 + ///////w8fD/7e7s//Ly8v//////29va/wwMDP/r6+v+3d3c/wgICP/v8O////////z8/P/t7uz/7e3t + /jExMf2srKz9xsbG/RoaGv3s7Oz8+Pj4/v////99fX37AAAAnQAAAAAAAAAAeqUrU3ulLP97pSz/e6Us + /3ulLP97pSz/eqUs/XqlKw96pSzlqMR1/6zHfP/A1Jz/7vPl/4CpNf97pSx5eqUseXulLP+xyoP/rMZ7 + /3GYKP8AAAD/9PT0/+Xl5P0FBQT/AAAA/wQEBP/a2tr/bm5t/2ZnZv///////v7+/zExMP+kpKP///// + /3p7ef8AAAD/AAAA/xMTE/319fX+/f39/ycnJ/0AAAD/Xl5e/f////99fX37AAAAnQAAAAAAAAAAeqUr + H3qlLP97pSz/eqUs/3qlLP97pSz/e6Us/3ulLEF6pSuyjbFK/8fZp//m7tj/v9Oa/5m5Xf96pSuteqUr + RXqlLP+WuFj/7fPk/8XRr/8AAAD/9PT0///////5+vn/+Pj3/2JiYf9cXFz/Dg4N/9XV1P////////// + /4SEg/9QUE///f39/x8gH/+5ubj/+Pj3//v7+/7///////////z8/P75+fn8/f39/v////99fX37AAAA + nQAAAAAAAAAAAAAAAHqlK+p7pSz/e6Us/3ulLP97pSz/eqUs/3qlK3V6pSx+e6Ut/+nw3v/J2qr/or9r + /7TMh/96pSzheqUrE3ulLP5+qDL/3+nN/3meNP8AAAD/9PT0/////////////////9PT0v8BAQH/R0hH + /////////////////9bW1f8KCgn/tre1/xwcG//8/Pz///////////////////////////////////// + //////99fX37AAAAnQAAAAAAAAAAAAAAAHqlLLV6pSz/e6Us/3qlLP97pSz/e6Us/3qlLKd6pStIe6Us + /7nPkf+StVL/haw9/6vGev96pSz+eqUrFHqlLNt7pSz/v9OZ/7zLof8AAAD/9PT0//////////////// + //7+/v9kZGT/wsLB//////////////////7+/v8rKyr/HB0c/3V1dP////////////////////////// + //////////////////////99fX37AAAAnQAAAAAAAAAAAAAAAHqlLDJ6pSuxeqUsuXqlLPB6pSzNeqUs + uXqlLGJ7pCwEeqUrkHqlLLl6pSzSeqUs63qlLLl6pSuoeqQrCHqlLEl6pSy1eqUsuXGYKPsAAAD/9PT0 + //////////////////////////////////////////////////////99fXz+AAAA/9DQz/////////// + //////////////////////////////////////99fX37AAAAnQAAAAAAAAAAAAAAAHqlKwp6pSste6Ur + LXqlLLt6pSuBeqUrLXqlKy17pSsteqUrLXqlKy16pStheqUs2nulKy16pSsteqUrLXulKy16pSsteqUr + LXCXKNoAAAD/9PT0/v/////////////////////////////////////////////////////X19f9VFVU + /f7+/v////////////////////////////////////////////////99fX37AAAAnQAAAAAAAAAAAAAA + AHqlKxp7pSz/e6Us/3ulLP97pSz/e6Us/3qlLP97pSz/e6Us/3ulLP97pSz/e6Us/3ulLP97pSz/eqUs + /3ulLP97pSz/e6Us/3KZKP8AAAD/8vLy//////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////97e3v8AAAA + nAAAAAAAAAAAAAAAAAAAAAB6pSvle6Us/3qlLP97pSz/e6Us/3ulLP97pSz/eqUs/3ulLP97pSz/e6Us + /3ulLP97pSz/e6Us/3ulLP97pSz/eqUs/3qkK/8VHAf/OTo5/05PTv9OT07/Tk9O/05PTv9OT07/Tk9O + /05PTv9OT07/Tk9O/05PTv9OT07/Tk9O/05PTv9OT07/Tk9O/05PTv9OT07/Tk9O/05PTv9OT07/T09P + /U9PT/0VFRX+AAAAYQAAAAAAAAAAAAAAAAAAAAB6pSsJe6UsC3qlLAt6pSwLe6UsC3ulLAt6pStbeqUs + wXulLAt7pSwLe6UsC3ulLAt7pSwLeqUsDHulLOd6pSw1eqUsC3ulLAsmMw0aAAAAYgAAAGkvPxCrOk4U + yAAAAGkAAABpAAAAaQAAAGkAAABpCQ0DbUhhGf0MEQRyAAAAaQAAAGkAAABpAAAAaQAAAGk4TBTBMkMR + sQAAAGkAAABpAAAAaQAAAGgAAABFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeqUr + bHulLNx7pSzke6Us+nulLNx6pSzVeqUsUHqkLBl6pSzRe6Us3HqlLPd6pSzme6Us3HqlLKR7pCsDeqUs + jHqlLNx6pSzpe6Us9XulLNx6pSzOeqUrNnqlKzR7pSzXe6Us3HqlLP16pSzheqUs23qlK4cAAAAAeqUs + rXulLNx6pSzue6Us73ulLNx6pSvEeqUrIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAeqUrknulLP+90pf/hKw8/3ulLP97pSz/eqUszHqlLCV7pSz/lrhZ/6vGev+Oskz/ts6M + /3ulLP96pSs5eqUruHulLP/D1qH/1OK8/7zSlv98pi7/eqUrpnqlLEx7pSz/k7VS/7DJgf97pSz/eqUs + /3ulLP56pSwUeqUs3nulLP+AqDT/wtaf/3ulLP97pSz/eqUrgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAeqUrX3qlLP+80pb/qMR2/36nMv96pSz/eqUs+HqkKwp6pSzvia9D + /9Phuv+evWX/w9ah/3ulLP96pStueqUrhY6yTP/c58j/e6Us/6/JgP+70JP/eqUs2nqlKxl6pSz/hKs7 + /9nlw/97pSz/e6Us/3ulLP96pStIeqUrq3ulLP97pSz/4uvS/3ulLP97pSz/eqUstAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeqUrK3ulLP+iv2v/4+zS/9Xivf+hv2r/e6Us + /3qlKzV6pSy9e6Us/+3z4//U4rv/wNSc/3ulLP96pSyieqUrUYmvQ//a5sT/e6Us/32mL//m7tn/eqUs + /XqlKxF6pSzje6Us/+nw3v/V4r3/pcJx/3qlLP96pSx8eqUrd3ulLP97pSz/0+G5/4qvRf97pSz/eqUs + 6HqkKwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeqQrA3qlK/OHrUD/1eK8 + /4etQP/b58f/e6Us/3qlLGl6pSuJeqUs/9bjv/+FrD7/1uO//4uwRv96pSvWeqUrHXqlLP/U4rz/lrhZ + /4SrOv/q8d//e6Us/3qlLEN6pSyve6Us/9Hgt/+NsUn/fKYu/3ulLP96pSyweqUsQ3ulLP97pSz/uM6O + /6XCcP97pSz/e6Us/3qlLB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AHulLMF7pSz/y9yt/9Dftf+kwW//e6Us/3qlK5x6pStVe6Us/6jEdf/O3rP/yNmo/36nMv96pSz8eqQr + C3qlLOeCqjf/w9ag/9Phu/+iwGv/e6Us/3qlK3Z6pSx6eqUs/6bDcv/T4bn/z96z/3ulLf96pSzieqUr + EXulLPx7pSz/lbdW/6fDc/97pSz/e6Us/3qlK1B6pSs8eqUrcnqlK2B7pSsCAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAHqlLEF6pSzCeqUsyXqlLMl6pSzJeqUsyXqlK2d6pSsJe6UspXqlLMl6pSzJeqUs + yXqlLMl6pSy2eqUsBnqlK1t6pSzGeqUsyXqlLMl6pSzJeqUsyHqlK0p7pCwZeqUss3qlLMl6pSzJeqUs + yXqlLMl6pSyeAAAAAHqlLHd6pSzIeqUsyXqlLMl6pSzJeqUsxXqlK1R6pSyEeqUrN3qlLHh6pStqAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHqlK116pStHeqUs + onqlLGR6pSuFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AHqkKyB6pSuHeqUrb3qlK2t6pCxiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAB6pSwueqUsb3qlLFMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//// + ////7wT////////vBP///////+8E////////7wT////////vBP///////+8E////////7wT////////v + BP///8AA/+8E////wAD/7wT////AAf/vBP//8AAAB+8E///gAAAD7wT//+AAAAPvBP//4AAAA+8E///g + AAAD7wT//+AAAAPvBP//4AAAA+8E///gAAAD7wT//+AAAAPvBAAAAAAAA+8EAAAAAAAD7wQAAAAAAAPv + BAAAAAAAA+8EgAAAAAAD7wSAAAAAAAPvBIAAAAAAA+8EgAAAAAAD7wSAAAAAAAPvBMAAAAAAA+8EwAAA + AAAH7wT8AAAAEB/vBPwAAAAAH+8E/AAAAAAf7wT8AAAAAA/vBPwAAAAAD+8E/gAAAAAA7wT+AAAACADv + BP//////4O8E///////g7wT///////HvBP///////+8E////////7wT////////vBP///////+8E//// + ////7wT////////vBP///////+8EKAAAACAAAABAAAAAAQAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC8AAABoAAAA + aAAAAGgAAABoAAAAaAAAAGgAAABoAAAAaAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + JgAAAFgAAADXAAAAWAAAAFgAAABYAAAAegAAALUAAABXAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQAAACCAAAA + hQAAAIUAAACFAAAAhQAAAN8AAACIAAAAhQAAAIUAAACtAAAAuwAAAIUAAACFAAAAhQAAAIUAAAB1AAAA + CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEB + rWVlZf9ra2v/a2tr/2tra/9ra2v/a2tr/2tra/9ra2v/a2tr/2tra/9ra2v/a2tr/2tra/9ra2v/a2tr + /0RERP8AAABfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABAQG3NDQ0/jQ0NP40NDT+NDQ0/jQ0NP40NDT+NDQ0/jQ0NP40NDT+NDQ0/jQ0NP40NDT+NDQ0 + /jQ0NP40NDT+JCQk/gAAAGkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAALbf39/95eXl/eXl5f3l5eX95eXl/eXl5f3l5eX95eXl/eXl5f3l5eX95eXl + /eXl5f3l5eX95eXl/eXl5f2Xl5f8AAAAaQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtvj4+P7+/v7//v7+//7+/v/+/v7/tbW1/oCAgP3+/v7//v7+ + //7+/v/+/v7/qqqq/pqamv3+/v7//v7+/6ioqPwAAABpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC2+Pj4/v7+/v/+/v7//v7+//7+/v9LS0v9OTk5 + /f7+/v/+/v7//v7+//7+/v9RUVH9RUVF/f7+/v/+/v7/qKio/AAAAGkAAAAAeqUsonulK/F7pSvxe6Us + 73qlK1l6pSyuiK5C8X2mL/GJr0TueqUsTnqlK7qHrT/xl7hZ8SkzGPv4+Pf//v7+//7+/v/+/v7/zc3N + /2tra/5qamr/zs7O//7+/v/+/v7/7+/v/k5OTv1bW1v94uLi/v7+/v+oqKj8AAAAaQAAAAB6pSuVe6Us + /3ulLP97pSz/eqUsqnqlLKK60JL/ob9q/8rbq/96pSydeqUsrqPBbf+xyoT/KzQa//j49/9+fn3+SUlI + /7a2tv9eXl3/2dnZ/729vP97e3r/9/f3/1FRUP82Nzb+oaGh/bKysv4yMjL+tLS0/aioqPwAAABpAAAA + AHqlLGF7pSz/e6Us/3ulLP96pSzeeqUsbq7Ifv/N3bH/vNGV/3qlLNF6pSx6iK5C/9fkwP8zOij/+Pj3 + //z8/P/t7ez/Nzc3/1JSUf/+/v7/+/v7/zw9PP+ur67/i4yL//r6+v7+/v7//v7+//v7+/3+/v7/qKio + /AAAAGkAAAAAeqUrLHulLP97pSz/e6Us/3ulLP56pSxMkLNO/7TMif+mw3L/fqcy+3qlK097pSz/xNei + /zM6J//4+Pf//v7+//7+/v9+fn7/wcHB//7+/v/+/v7/Y2Nj/zAxMP/l5eX//v7+//7+/v/+/v7//v7+ + //7+/v+oqKj8AAAAaQAAAAB6oywBeqUsZHqlLJB6pSzFeqUsdnukLAl6pStpeqUslnqlLL56pSx0eqUr + CHqlLG16pSydIi4M//j4+P/+/v7//v7+//7+/v/+/v7//v7+//7+/v+2trb+RUVF//7+/v/+/v7//v7+ + //7+/v/+/v7//v7+/6ioqPwAAABpAAAAAAAAAAB6pSuWeqUszXqlLOt7pSzIe6UsyHulLMh7pSzPe6Us + 6HulLMh7pSzIe6UsyHqlLNIjLwz/9/f2//7+/v/+/v7//v7+//7+/v/+/v7//v7+//z8/P/n5+f+/v7+ + //7+/v/+/v7//v7+//7+/v/+/v7/p6en/QAAAGgAAAAAAAAAAHqlK2p7pSyye6UssnulLLJ6pSzFeqUs + 1XulLLJ7pSyye6UssnulLMl7pSzSe6UssjZIE7gsLSztODk29Tg5NvY2NjbwNjY28DY2NvA4OTb2ODk2 + 9TY2NvA2NjbwNjY28Dg6NvY4OTb0NjY28DY2Nu4dHR3fAAAAKwAAAAAAAAAAAAAAAAAAAAAAAAAAeqUr + YXulLKZ7pSzNe6Usj3qlLCR6pSxoeqUsq3ulLMd7pSyOeqUsHnqlLG96pSyxe6UswnqlLI16pSsYe6Us + d3qlLLZ6pSy9eqUsi3qlKxN6pSx+eqUsu3ulLLd6pSyIeqUrDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAB6pSuuqMR1/4asPv97pSz/eqUskXqlLLqvyID/jrJM/6bCcf96pSyEeqUsx7bOjP+4z4//nr1l + /3qlLHd6pSzUrcd8/4GqN/97pSz/eqUsa3qlLOF9pi//scqE/3ulLP96pSteAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAHqlLHqZul3/ydqr/6PAbP96pSzFeqUsh6LAbP/N3bH/qcV3/3qlLLh6pSyUxNei + /3ulLP/E16L/eqUrq3qlLKCfvmb/x9mm/46ySv96pSyfeqUsrXulLP/A1Jv/e6Us/3qlLJIAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAeqUrRoCpNf/J2qr/ytus/3qlLPV6pStXiK5B/8TXov/I2qj/eqUs + 63qlK2CmwnH/rsh+/8/es/96pSzfeqUsbISsPP/L26z/lrhY/3qlLNN6pSx5e6Us/7/Umv97pSz/eqUs + xgAAAAB6pSsLAAAAAAAAAAAAAAAAAAAAAAAAAAB7pCsNeqUsxoyxSNuCqjnbeqUs1XqlKyN7pSzLjbFK + 24KqONt6pSzSeqUrInqlLM6JrkLbg6s523qlLM57pSwkeqUs0YyxSNuHrUDbeqUsxHulLCx6pSzUg6s6 + 23ulLdt6pSy5eqUrZnqlK3p6pStWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAB6pStueqUsuHqlLFsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHqlKzl6pSxPeqUrMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAD/////////////////////////////gB///4Af//gAAf/4AAH/+AAB//gA + Af/4AAH/+AABAAAAAQAAAAEAAAABAAAAAQAAAAGAAAABgAAAAfAAAAfwAAAH8AAAB/AAAAXwAAAA//// + +P////j//////////////////////////ygAAAAYAAAAMAAAAAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAHgAAAB4AAAAeAAAA + HgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABeAAAA1gAAAOoAAADpAAAA1gAAANYAAADWAAAA1gAAAOkAAADqAAAA + 1gAAAF4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAF8AAACWAAAAAAAAAAAAAAAAAAAAAAAAAJkAAABfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAANAAAAK8AAAC3AAAAtwAAALcAAAC3AAAAtwAAAMkAAADrAAAAtwAAALcAAAC3AAAA + twAAAOwAAADJAAAAtwAAALcAAAC3AAAAtwAAALcAAACvAAAANAAAAAAAAAAAAAAAwAAAAGkAAAA9AAAA + PQAAAD0AAAA9AAAAPQAAAD0AAAA9AAAAPQAAAD0AAAA9AAAAPQAAAD0AAAA9AAAAPQAAAD0AAAA9AAAA + PQAAAD0AAABpAAAAwAAAAAAAAAAAAAAAzAAAAG0AAABRAAAAUQAAAFEAAABRAAAAUQAAAFEAAABRAAAA + UQAAAFEAAABRAAAAUQAAAFEAAABRAAAAUQAAAFEAAABRAAAAUQAAAFEAAABtAAAAzAAAAAAAAAAAAAAA + zAAAALIAAACjAAAAowAAAKMAAACjAAAAowAAAKMAAACjAAAAowAAAKMAAACjAAAAowAAAKMAAACjAAAA + owAAAKMAAACjAAAAowAAAKMAAACyAAAAzAAAAAAAAAAAAAAAzAAAACkAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAUAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAABMAAAAAAAAAAAAAAAAAAAApAAAA + zAAAAAAAAAAAAAAAzAAAACkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADJAAAAaAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAASAAAANYAAAAAAAAAAAAAAAAAAAApAAAAzAAAAAAAAAAAAAAAzAAAACkAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAADsAAADxAAAAuwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnQAAAP0AAAAtAAAA + AAAAAAAAAAApAAAAzAAAAAAAAAAAAAAAzAAAACkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKwAAABiAAAA + 7AAAABMAAAAAAAAAAAAAAAAAAAAGAAAA6AAAAJIAAACCAAAAAAAAAAAAAAApAAAAzAAAAAAAAAAAAAAA + zAAAACkAAAACAAAAFQAAABUAAAACAAAAIQAAAOEAAAAGAAAApgAAAGEAAAAAAAAABQAAABUAAABUAAAA + twAAACkAAADXAAAAFQAAAAIAAAApAAAAzAAAAAAAAAAAAAAAzAAAACkAAABGAAAA4QAAAOwAAAB6AAAA + jQAAAHsAAAAAAAAAVAAAALQAAAAAAAAAngAAAOgAAADgAAAAVQAAAAAAAAC3AAAA4QAAAEYAAAApAAAA + zAAAAAAAAAAAAAAAzAAAACkAAAAAAAAAAAAAACQAAADkAAAA5wAAABUAAAAAAAAACwAAAO4AAAAYAAAA + 6QAAABEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApAAAAzAAAAAAAAAAAAAAAzAAAACkAAAAAAAAA + AAAAAAAAAACwAAAAmwAAAAAAAAAAAAAAAAAAAK4AAACuAAAArQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAApAAAAzAAAAAAAAAAAAAAAzAAAACkAAAAAAAAAAAAAAAAAAAAZAAAAEwAAAAAAAAAAAAAA + AAAAAFwAAAD/AAAAUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApAAAAzAAAAAAAAAAAAAAA + zAAAACkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAADWAAAACAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAApAAAAzAAAAAAAAAAAAAAAywAAACwAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsAAAA + ywAAAAAAAAAAAAAAewAAAOYAAADWAAAA1gAAANYAAADWAAAA1gAAANYAAADWAAAA1gAAANYAAADWAAAA + 1gAAANYAAADWAAAA1gAAANYAAADWAAAA1gAAANYAAADmAAAAewAAAAAAAAAAAAAAAAAAABcAAAAeAAAA + HgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAA + HgAAAB4AAAAXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///9B////QfwAP0H8AD9B/zz/QYAAAUGAAAFBgAAB + QYAAAUGfnzlBn585QZ8fGUGfDhlBgAgBQYBIQUGYQflBnOP5QZzj+UGf4/lBn//5QYAAAUHAAANB//// + Qf///0EoAAAAEAAAACAAAAABACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAKAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAWQAAAK8AAAC2AAAAjwAAAI8AAAC2AAAArwAAAFkAAAAAAAAAAAAAAAAAAAAAAAAA + AQAAAGQAAAB6AAAAegAAAHoAAACUAAAAtQAAAHoAAAB6AAAAtwAAAJQAAAB6AAAAegAAAHoAAABkAAAA + AQAAAC4AAACNAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAA + jQAAAC4AAAAzAAAAywAAAKMAAACjAAAAowAAAKMAAACjAAAAowAAAKMAAACjAAAAowAAAKMAAACjAAAA + owAAAMsAAAAzAAAAMwAAAHAAAAAAAAAAAAAAAAAAAAAAAAAARAAAAAAAAAAAAAAAAAAAAAAAAAA+AAAA + AAAAAAAAAABwAAAAMwAAADMAAABwAAAAAAAAAAAAAAAAAAAAGgAAAPEAAAAbAAAAAAAAAAAAAAAOAAAA + 8gAAABQAAAAAAAAAcAAAADMAAAAzAAAAcAAAAAAAAAAAAAAAAAAAAIQAAABtAAAAbAAAAAAAAAAAAAAA + WwAAAJYAAABlAAAAAAAAAHAAAAAzAAAAMwAAAHAAAABXAAAAqQAAAEEAAACmAAAABAAAAKsAAAAPAAAA + qgAAAL8AAAANAAAAvAAAAFYAAABwAAAAMwAAADMAAABwAAAAAAAAABAAAADhAAAASgAAAAAAAACaAAAA + dgAAAEwAAAAAAAAAAAAAAAAAAAAAAAAAcAAAADMAAAAzAAAAcAAAAAAAAAAAAAAATwAAAAIAAAAAAAAA + SwAAAOIAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAzAAAAMwAAAHAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAcAAABiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAMwAAABoAAAC6AAAAjwAAAI8AAACPAAAA + jwAAAI8AAACPAAAAjwAAAI8AAACPAAAAjwAAAI8AAACPAAAAugAAABoAAAAAAAAACgAAABQAAAAUAAAA + FAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAAAoAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//rEHwD6xB8A+s + QQAArEEAAKxBAACsQT3srEE4xKxBOMSsQQAArEEiPKxBMjysQT58rEEAAKxBgAGsQf//rEE= + + + + 130, 17 + + \ No newline at end of file diff --git a/ProfinetMonitor/ProfinetDeviceMonitor.cs b/ProfinetMonitor/ProfinetDeviceMonitor.cs new file mode 100644 index 0000000..121593d --- /dev/null +++ b/ProfinetMonitor/ProfinetDeviceMonitor.cs @@ -0,0 +1,267 @@ +using ProfinetTools.Interfaces.Models; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace ProfinetMonitor +{ + class ProfinetDeviceMonitor + { + + /// + /// the currently opened Configuration File + /// + private static DeviceConfigurationFile ConfigFile; + + /// + /// The Devices from the Configuration File, but Aggregated by their NIC + /// + private static Dictionary> NicDevices; + private static Logging.Logger Log = new Logging.Logger("ProfinetDeviceMonitor"); + private static bool CancelationPending = false; + private static bool RestartPending = false; + private static System.Threading.ManualResetEvent WaitEvent = new System.Threading.ManualResetEvent(false); + + public static bool AddNewFoundDevicesAutomatically = false; + + public static void RunMonitoringMode( int MonitoringCycle ) + { + try + { + Restart: + CancelationPending = false; + RestartPending = false; + WaitEvent.Reset(); + missingDevices.Clear(); + LoadConfigurationFile(); + + //Depending on the Cycle time, do it once or stay running + if (MonitoringCycle == 0) + { + Log.Info("Running Monitoring only once"); + ScanAndMonitorDevices(); + } + else + { + Log.Info("Entering constant monitoring mode every {0} milliseconds", MonitoringCycle); + while (true) + { + ScanAndMonitorDevices(); + WaitEvent.WaitOne(MonitoringCycle); + if (CancelationPending) break; + } + Log.Info("Monitoring Mode Stopped"); + + if (RestartPending) + { + Log.Info("Restarting Monitor Mode"); + goto Restart; + } + } + } + catch (Exception ex) + { + Log.Error(ex); + } + } + + public static void StopMonitoringMode() + { + Log.Info("Stopping Monitoring Mode"); + CancelationPending = true; + WaitEvent.Set(); + } + + public static void RestartMonitoringMode() + { + CancelationPending = true; + RestartPending = true; + WaitEvent.Set(); + } + + /// + /// Load Config file and Separate devices into Network interface Cards + /// + private static void LoadConfigurationFile() + { + Log.Info("Loading configuration file"); + + ConfigFile = new DeviceConfigurationFile(); + ConfigFile.Load(); + NicDevices = new Dictionary>(); + + foreach (var entry in ConfigFile.Devices) + { + if (!NicDevices.ContainsKey(entry.NetworkAdapterName)) NicDevices.Add(entry.NetworkAdapterName, new List()); + NicDevices[entry.NetworkAdapterName].Add(entry.Device); + } + } + + /// + /// Do one single scan over the configured devices + /// + private static void ScanAndMonitorDevices() + { + var Adapterservice = new ProfinetTools.Logic.Services.AdaptersService(); + var Nics = Adapterservice.GetAdapters(); + var Deviceservice = new ProfinetTools.Logic.Services.DeviceService(); + + foreach (var nic in NicDevices.Keys) + { + try + { + var ConfiguredDevices = NicDevices[nic]; + + //Find corresponding ICaptureDevice + var CaptureDevice = FindCaptureDeviceByDescription(nic, Nics); + if (CaptureDevice == null) + { + Log.Error("the Network interface '{0}' was not found", nic); + return; + } + + //Now Scan the NIC for available devices + var Task = Deviceservice.GetDevices(CaptureDevice, TimeSpan.FromSeconds(10)); + Task.Wait(); + var OnlineDevices = Task.Result; + + //There is a problem, that sometimes, but only sometimes, we get an "False Positive". + //To mitigate that, we check the network "Two times". + //System.Threading.Thread.Sleep(1000); //wait one second + //var Task2 = Deviceservice.GetDevices(CaptureDevice, TimeSpan.FromSeconds(10)); + //Task2.Wait(); + //OnlineDevices.AddRange(Task2.Result); //this creates duplicates, but that does not really matter + + //Now check if we have an Device missing + //go through all configure devices..... + foreach (var ConfigDevice in ConfiguredDevices) + { + try + { + //...Check if they are currently available... + var OnlineDevice = FindDeviceByMAC(ConfigDevice.MAC, OnlineDevices); + if (OnlineDevice == null) //... and if not, then we have an error + { + if (missingDevices.Contains(ConfigDevice.Name)) continue; //Already Logged + missingDevices.Add(ConfigDevice.Name); + Log.Error("Device '{0}' is not reachable via its configured NIC", ConfigDevice.Name); + continue; + } + else //... if the Device was available, but it was missing before, then it is reachable again + { + if (missingDevices.Contains(ConfigDevice.Name)) + { + missingDevices.Remove(ConfigDevice.Name); + Log.Info("Device '{0}' is reachable again via its configured NIC", ConfigDevice.Name); + } + } + + //Check if it has an Profinet name + if (string.IsNullOrWhiteSpace(OnlineDevice.Name)) + { + Log.Error("Device '{0}' has lost its online Profinet name", ConfigDevice.Name); + AssignConfiguredSettingsToDevice(ConfigDevice, CaptureDevice); + } + else if (string.IsNullOrWhiteSpace(OnlineDevice.IP)) + { + Log.Error("Device '{0}' has lost its IP-Address", ConfigDevice.Name); + AssignConfiguredSettingsToDevice(ConfigDevice, CaptureDevice); + } + } + catch (Exception ex) + { + Log.Error("Device '{0}' throw an exception: {1}", ConfigDevice.Name, ex); + } + } + + //Add devices that have been found on the bus + if (AddNewFoundDevicesAutomatically) + { + foreach (var OnlineDevice in ConfiguredDevices) + { + try + { + if (OnlineDevice.MAC == null) continue; + + var ConfigDevice = FindDeviceByMAC(OnlineDevice.MAC, ConfiguredDevices); + if (ConfigDevice == null) + { + Log.Info("Device '{0}' is an new Device found on the Network, which is not yet configured", OnlineDevice.MAC); + + //Check if it has an IP address, sub-net-mask and name + if (OnlineDevice.IP == null) + { + Log.Debug("the device {0} did not have an IP address yet. Ignoring", OnlineDevice.MAC); + continue; + } + //Check if it has an IP address, sub-net-mask and name + if (OnlineDevice.SubnetMask == null) + { + Log.Debug("the device {0} did not have an SubnetMask yet. Ignoring", OnlineDevice.MAC); + continue; + } + //Check if it has an IP address, sub-net-mask and name + if (OnlineDevice.Name == null) + { + Log.Debug("the device {0} did not have an Name yet. Ignoring", OnlineDevice.MAC); + continue; + } + + Log.Info("Adding device {0};{1};{2}", OnlineDevice.MAC, OnlineDevice.Name, OnlineDevice.IP); + var dev = new DeviceConfigurationFileEntry(); + dev.Device = OnlineDevice; + dev.NetworkAdapterName = nic; + ConfigFile.AddOrUpdateDevice(dev); + + Log.Info("Saving config file"); + ConfigFile.Save(); + } + } + catch (Exception ex) + { + Log.Error("Device '{0}' throw an exception: {1}", OnlineDevice.MAC, ex); + } + } + } + } + catch (Exception ex) + { + Log.Error("NIC '{0}' throw an exception: {1}", nic, ex); + } + } + } + + private static List missingDevices = new List(); + + private static SharpPcap.ICaptureDevice FindCaptureDeviceByDescription(string Description, List Adapters) + { + foreach (var adapter in Adapters) + { + if (adapter.Description == Description) return adapter; + } + return null; + } + + private static Device FindDeviceByMAC(string MAC, List devices) + { + if (devices == null) return null; + if (MAC == null) return null; + + foreach (var dev in devices) + { + if (dev.MAC == MAC) return dev; + } + return null; + } + + private static void AssignConfiguredSettingsToDevice(Device device, SharpPcap.ICaptureDevice CaptureDevice) + { + Log.Info("Assigning device name and IP-address to device {0}", device.Name); + var Settingsservice = new ProfinetTools.Logic.Services.SettingsService(); + Settingsservice.SendSettings(CaptureDevice, device.MAC, device); + + } + } +} diff --git a/ProfinetMonitor/ProfinetMonitor.csproj b/ProfinetMonitor/ProfinetMonitor.csproj new file mode 100644 index 0000000..fd01afe --- /dev/null +++ b/ProfinetMonitor/ProfinetMonitor.csproj @@ -0,0 +1,143 @@ + + + + + Debug + AnyCPU + {98B9B592-2686-4FEF-B950-91A1D27ABCB3} + WinExe + ProfinetMonitor + ProfinetMonitor + v4.5.2 + 512 + true + + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + false + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + false + + + ProfinetMonitor.Program + + + ProfinetMonitor.ico + + + + ..\out\Debug\Ninject.dll + + + ..\out\Debug\PacketDotNet.dll + + + ..\out\Debug\ReactiveUI.dll + + + ..\out\Debug\SharpPcap.dll + + + + + + + + + + + + + + + Form + + + AboutDialog.cs + + + + + Form + + + DevicesConfigurationDialog.cs + + + Component + + + + + + Form + + + MonitorModeDialog.cs + + + + + + AboutDialog.cs + + + DevicesConfigurationDialog.cs + + + MonitorModeDialog.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + True + + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + + + + {f23836b7-30f9-4a77-8ea1-8c57b7bc953f} + ProfinetTools.Interfaces + + + {6696f4a6-c9a5-49f3-8463-16a85bacb6e6} + ProfinetTools.Logic + + + + + + + + \ No newline at end of file diff --git a/ProfinetMonitor/ProfinetMonitor.ico b/ProfinetMonitor/ProfinetMonitor.ico new file mode 100644 index 0000000000000000000000000000000000000000..839a2c2db9e583bac5b61106b443860241df31bd GIT binary patch literal 38933 zcmd?Q1y>x+^ESM@xCMesg1bww;F92Oi#r4f5`x>}9^45YAUFhfcMAk}S=@EeeYk)B z_glPk&Pey1?&+$QxvJ`F000O;0{nLX0h9oL4FEv<^_i3N|I#IN0Kn{P9wp`fm&O4A zd_4gGV&eZxhob=ibddl6&TIaE<-Z^T02PSG>m`fF8Kaaui2ZX7QUgoS{J`BTh@F)b0zMyoGcds|z z0C_OyrvFn&eDB5|?jZt$1$I`>M3T_2(X#@n_wO(Y)m?IsX#=BVaa<_JEerf)ok|V# zk^qd1-*DP`zyGS4dkH0I%w$5f6T+JWd1LsmTZ0*UxmD5py}61WV&49se2+PU68glZ z9E%G;`t$~<{lbii&|0(9p-{@JeJpE#BGt7~t3pBiH2rRp!ABmL;%XBsR&4gvLQLTq z@QlK-kB^6g+pCiJztRBh7c-b^l4%+#I9;thjH2f9@ES-JAwLhRgfTZ#>FA+qUtJK- zBUL>{ad9fevy!K8tAcWKhjz~md6T(_(^Si!URa5GCQNnHwgPX6W__`rexm3w;FO<11kWzYcqWVWvgAQ#AgQK8Mxd&yg^S72Iz9_bt-R7< zAu`8o+FWh6}hNH1|TUlUnUIskg4 zJ*MWBzDcGpF-s-O%d^%Qh47ru1PU5J0Mvz!#VP|RI$wnGqBXr0Z(t5x-|6WMOfgRs z`{yHAL?DF*38W_L6*8EQ1zNqok0I>}CWgm(9_+D_cDXzq1+6}6rnvqN>P)4wN$OeZ zeD8nPXD8q&epa1(K`gqSG$)Q}tnj}o5FX({7c49P^eMtBZYOtLtUz5OimVScn0x4B z9tm)mH}K^}EE>)%Qjr@Es}Ft}zz7|Lp>P!cr_`8$oUF&S6Cj(dZTKymKu z)&L353&t1}XDoVKe{Xx}+4+`#-$tTmSzWj?fBVgEU=&wgc;LiG0P+2VWbG zD9+r;UjxgF6eCU!5hFI^F)<|>pfLS$hDTV3If=DhDu&U)1*Cd-Cj(e3`_7IzI__0V zEyRy#2JLh;*)25NEwt@`pya6jBx{0{z5fH472*?I@(;a5;qG>y#YcV&KQ$TrOR@Ef za9fNV-qaK=7`O);$h%}RA(bKBqN3JA0|R_+HHY6C5p zM{zIYt}TY3MIgI9^!aJ&0YYMBPGODs0S{1m%|sk}S+nrKLlE)Ek&+zg1t~TBV~Tvew05bW$b17oMq^{2k=pbechIIRG`7q5 zDh}15WOuc+iWnhN8v}_nc)r0b+P3_eJJvFr3$t~=1OiP(klNC^VmC-dv8499k?ydK zR%_p-(mhb)fTh5y168Vk+f zCM?}YkaXB|sT&;WM2Tkawo`qkut*WrN1#~4LV^=xoPWS?l+|9Hzm}ggLw22gL=jVq z+`}W4wz6ikAZZ{ocR9NGj7zFI;8@+CHsQ!+aakoaazir$<~p*V*{Z=-V^jwh;9ogF z>)JL(%$TfY3Zk=h=`;R*X;?$Tl*)g$re_)WKjHu*lVXUR9J3pP{18pnzH*P` z*+rb4L5A@-L6h~}E@;FrD4{53Fsu|yJ9BU(lb=5(HiCL5)))$`u8b=O+nk)AhLqGC zGWXCGXAW4*0;oPaOZbL12_dHsNc?%1W@=2M|DtmGuGSXqX(@9E~>x4mZCUMsHZ4fCT=*B4EfU>}&W zF2%omT%X>eX5y}D!g@$Yk&9T`E-0z*i6tB;ebf@bCNhr$3q^XHU-H?OUli){^n!D5 zN19F^y{Vt}p@`ots1|Mj@IgCK8t>q_O_Xu(0qB@zfyaEg{0a@AuXz znjL>6enkU3axHBA5mG%@{*i>hbHe90+oR|`j(vwVKig9^lNMt1COOu!*o=iwv>?3=zhiV!Gqp{W?Lcv)^H#c-tl+}Gm`y1Z5Ans4s6m-}7NuV9aO@M0OCLO+{L#dPF*(ZSdO^4l$|-3d?g1 zT(Mg71Be4`43kGY?9nVXl?P^3$_wN!(9h*gZdJ#4#AE;|Be6t@VG6y==*2XV23C(SR8K$!_{Fv5HI6cAp;N+;UM)uxz$z3kT=f?iV?lCTET> zx5@X_b}V~u;Vr;+2FBh)&OF||RD_%@8tyKJOPq6$a(8Z?B`?Sh{qV5R2c4r~ zJW$BrCF`|K)?CJ(`x$Fw6mp71d%rRMWFPn^_Vi0TJu#0XsTd|kHOffQV07bBPs+Fk z4xigSqVQ^6I%l|#|BE|Whj9HHxx@Mf7H~=QC7PzaV`WH)Z*(LyBg@{fh15s8m_~ER zIGRR@_nzIXL+N8ZAvs;iD1%HkZ}0aVK7Ca_vHBx4-O2+2#Br)&C-C>| zqRqv)i5g^H)Iii|2+V<{01^+=NZcJBY)uP0`WX8u-+lXKkd8q-_2g6{sa2{NGNT~GsF~$D;sZDDHe$wUvZ~9yyX8}@SBf>DfEB@4?zNsY_cU^@P>M?V&*b6yTa zU>j51;VMcs>=dJZQAjW{)3t-4@IE?KDwRO>h4+hpeL+plwiJfGKeJHV-Ps^v7ggm0 zy=^p}+Sq9F)t|F%+I%=HaviQqR53d2mL?Od=X1n@1HApWTfF#!LY_@bJ|2WAPJ-bQ zG_`cV4F$@Nnn`*XnM7Li;|o10WBTEbD(HJ#`$0}yn^@ufuLDYi{{z!KJ4~w-o34g; z*L*Ex^?YzP(KbJBR@=^u>TP+^As$~n!zgDaN%HYy?q>{Q2a`+>H*Peo^&X z*K~A`B^vSk_pcC-kW%fcpJF{UY80Jj9n|MC%kirC`uIG`tDVRc?*ZmP;2PLHK&c(43ob2nz*(xLK8rgHfR`EXr{6A z{3V5_pGk;nrr&Z#SQy?dIJ$nTxL? zbdNf_n+TWlb(8mm2C*56;VqzlrUqtd(Ev1U^L)@!O?YxlASHB*;2;xutTw{6H z;Lr7R4|Dizp+F=0D4X42Y)@0m01P&zNHNvKf*8-8AO`Se=)at`_`apjNpUm~z5R-1 z?z61-lG8P}Lz6s*XxxX-O8W<9DmrjF>^kXA&hI17trP|j$-(>m#D>8XK z`g8wi@3dP1qN#u1yAV$``2x>l_Vyvbe(M%Xs4K6%q zfN;lFYb)FX@*%=hoK5R833%fWBRu#}w|zWp()MHnN+g?i=$_7z%AMi^4+XtZ7w4NMbe1qNmO~&d)LBCV{_Z*Fb&VRt=~DJ`?m(dW>urpM!J8qAtUoI``8vh zJLHCFVryFPue`4h(DdtwL6tgIt)D*S=xy5OH)fp!VI&j7;#jKAFlQe=ES9+;1cl8> zh7nRi9oa63??SpeY!fW&Wlp7b(wi`Ht5)Hb0{1?Z?x7_KibHAm9;J^J;8oN?BV(}_ zH{_75(b}(PPlX(bpeD-wG;hS-d3&9PiX=SkX&3Q=^WhV_Y-PG1;rw-3~X%$?J#iy z%ob_zCOSrC1K0VkgVwZ2ZHCFPOk7Ju#)qO&w4@qn0QTLb)KNy=IoendEe!lHtdfZg zl2jhRsU9Us4n5nvqQ$P;!b9fvXBs(7ktWTGkoHIlS2}WtsRR#aI#X_-vEGAJ6!(GQ zFa`T@AXG;MZ3}1ct>Lr7RK3~zDEmG5GlpnSN4=hePA#rE-D6n%LH2i!GmP%>2mRB; zzytTi+n}O6RZ#v<`-2B2%@4nK5cM5@hS^v*4E0&z#RF|k)>hvR&*51vW0IcdxhoLs z2(2pI!P-YTFOq7NqU-+X4Fl!e@J8r~%?7^7d{B|hKKVdLE$Q+2SG5e>VulxeU%Q(^ zXicko-;(ds%Kg12X2=gQw=`9DLHYF-+UCo$ZkK!uApW zF@XWzZprIgZn9hxC>J`dDr%N>Y<8lz)gk{+XY1#e0S>iC%FBqqG;=(uWd9hi-+ZqE z$MWE2ut1^3@GgNQrNrWVV9P#2PzZ9@R4%h@W~v0Y^?MVeE1+y(M+#i6Bp>-0Zg}NA z4BY~ucq<0>WZ$!z%JTtg)#z}=lShI1o5P&%6Br8Qvk^NZF(HK*;==UF=krlAoQFf` zO3aN}{((08=`gppGC>W+p;&2U%#PhQD!rB5_D=D!KVh#JPn_?xB>3|AXMEJxPp{pa zQ=RLmT3R)`rBu0$2J%4e^4~V<+Vrn<^0nvCbRRW`-m&QsvShaY3XFH?+1l@2aY{vI z$mECzAfA?jAy@hKIwS-LlqA_JQ=ad3CX!F{hB?x9755qkgdB{6o8uohKGo8m4Y)6S9rW?A4H^|xX({N z^U5WL#Q2n)=w7@%3Z)9f>YwLyr~_H5&s9GJ-Qv}BFNzJ*4>?n<0d>gg_no5cK)1CR zV9;)|<-#&?eW<87ShgBRWl#t?!r0F8xY1GiW;J9_`{M5=^c5{Bjo;7L*ek(0`c1M| zY^Ln?d|>(mjA1)C!8`ap*uCzVC_FnEOZ#XN&XaA`%V!u4r@`7j-d1?_O|B9O|G?an zpiEcyb&pg)MIyd!?L9*5X}0u&LZ zz!p+pWxM{_7`Mq9@1FB6ygL?F#nDukqtRUtWzK|L_`C{OToZcawJ}dvZ~vI@AVaKI z5CZkbEv=HXVOr73ZWg9YEin;`@JEum**=rkM_OW()>P(Ibh6W(TIIHE{cAJ>lC zicV2G`pDxx4c|+romzh5*?}A3G*eV|z;qPWRzKgj4M%>YzJI~C9F0TCT>vy~4(P&e zR~n*eKapGOMf+EmChA&IdA}9+z*(G+CI(bgzG$?Ypn=1f8=4`7r0Sc_D+pXaWe`3wP9Oa$i7`l`VGADe4~MA*f1f{ zl`=>wBM#)saj1l%YuU z;OS?2)Alv7rcMFX2;td{K;4$g8E}bqNfI6F&apOIfdKc0)qUcx*U!!MmQv}z1(ccw z!0Of6jP5S$DR*mq-NW_qqA6U-{J2fFIIj) zSG=tGPcVM66jjl>ZQpltnw(W-(Ep$We(y!6H^HDSW`^;Z6Q@%(G+5g9Jf#F7nTj+_ z26dX{*p9>o$bvuGL&p#kk}`T?hSxpWTs3>zS~nAp_1L^%?x2BBCpK>g8#(G$&Qeo= zQ~8P?114IV$X=TAKRQa`sdjLjuf9;mu_>nJ?7Sb*8JN39Z}IMFaM;d^8%Bs*NPjqe zLUYIsO#&`rVpbDezwrDk;ZSFg7y$}_}I%#Hhy4(fm=sCeV zK-nyC8Vk64M6b0$KESNHNaG=C3YH|jU;C9^m_P}Qpsblg&F-M-86{jpm$QDVV?1>5Acl$ z-onGX(=_GbHs?weLi=`~lk zpBCq)iO^Wj}xEHh$TTcAHV~NiT(A&AjiDT+u#_Tmh%QxyfK9Mvm@(jEnrW zgDU;dVBW6Z`(>Rkkg3<@Wd)cwKgl?31wfe5qagNCOmer7w}>W0piD29ei9nHYkR(Y zd);-4oEd;lN3(9Zwel-9Vej2%^E>HixZM=i!$lDwjH+g$CATFmx$S$Ga&IWZC?*7P zF$@qbdOOcaWRP4)jZ~r+uvPuT1CY^^&Cnl^Ly#QBHBM?xw|TiNX!68JA7g_fV$rey z5WpVYvEC}@DYoyJoaUp+rE-+tzy70dx>|8%AROv$7$Zq%O3*M;*_PLQTLOH_JeN1w zNCEJg(K2+~w(#~Ad*we!D?WHi?CK?~HDY;-SB+pH$-Ox&NNjIiO~e-;HYFnB<7URj z0k>bi8unSMGwMPvH+k-Jjsv{exNq3KV_MaTe49jhb%pyi>ATLzu7Z1P_K&4~J)d=X zf+%RL$+^XcpLQXh#oQ8fF7dvolm`6hA-b4t=%YhzYXQk2%=5F>ccxuy>rE_uNb*l? zcjw$8O!yeXIDW$G=S-Lw?1Se9E}wD8AjZ)VD3sQK9ZvxA@gr7#_6rSFzAcixQv>Kl zlB_*`$YDS<9$yq-)NPR`LWmoXyzn6k>#@2IAr4C95mjh;i65vWo8_}d3(7ak>3g|> z7T-}emI-;7=QNmJL?(EkoPKu6z|^(Sde|v~v#v;kO1uPBo4%&kgoJSXTXLel;y6Q* zyi(U7a+aEw5|yk*GVTt^T-gCs?+xTAeYc>v4cVk*JFsXTwHAs=|N` z)nQJ>1Va^}#@Ng2dwSD-MjruIMzB_diC33r?La|^x_k6ByLzDkjp*DZn z!TCqG1t@%Z@t%0VGq|R<0_87Z+qYjTBJd{|vjA+807u7Yt)2QphUSV;mGHjDRm?QY zdCP7myIMhzA}#V+`=wl5Fz$Q4>Ps`xo%qg-|BjF2PGx#9;(5Dx1E(Q*w4%Wqh0^xd zFqfTq>UaJq585fCEa3UC!e2Ue_m=08T-6;9T_hlE@i8HPMV9E!x->2&o6;?Gk^IjX z4iZ{CLwXT?8>1D!QGFy6aBCIsbt63aHJ1x4$ZL^+|1f6>23nL-QkcpMxk=jhS4^pI zm98>&3-NlV92dA(J)i&K8$Vo@-xT-Ta=&=J`OLv(O2KDPJS>*Sqg|=pM%NXNvbB_H zEph6KH=8qtc)e8tsv~*)VeP?!JX{iaRExxOiR8;X8|G$d zC)xkhPnBB6;!brT;Q{gVeCoy$@PVW2Tu9K1grI-nJke#??1kN#|K zOUHlFy~|r}q>obNqYq=qMRtGyfLD54W5yzMO!}4*;`ILSL4;0Z|7GFW{?-WVhXml+ z$2|0+Qj%(m9Sr@2b=u321NyD`yKl|Ev}K{W^`P+63rtMK@mGJuum{8Lx^c9#m`CPW z6>TCcTHtF0a+etrMw~WhQiagKDt&50!V+8YM};b&62V{ml<3aojn?EQynLUs3%lGN z*L-<4$KH)m=6NIy=Aaa7>rG*EleH*vZV~fksdiv31~6`uMFd@AO`bwd`wNnJlA?iU zFEK}+3udnwRXUX}#b{Fko4sNzbF$3v)~JqeKU;8p4=X;_tKCn3h!D6p9C3&loGaY}lGcY!uTmQ%Zp#)SH{zZ@l#f{?aF6&o(2A zr$0M}9yq1dtTw|27L__$1>-f``?gY=a0#VMf5k%xNKCw6#KZ1h1sCUYlo- z3^?V)SI{K%SW_XX3fV|jIP)^%%x-*&(E(hyVASV1@m0B}$08+!f&;~B{Mz_8>ms5k zOVFhmoqo*N8j0c`U_I%Tz5f>l{y>5Ks-7HUbEuce2`MY%*|zKE0)DEQ;uhGheq8lZ zW=b4@Y=1{#w)dd_bT1PPSM1l7qg;cAbC%*WKCCyJXPBxBu2holNduWOir z0%^1^D?#*aBr}!$q(3nUc(Db!?mf%7;Ii(gNTb|h<}c&Y-)dX9!`#7BPSN}n{<}KU z!AY`)>cfI3(&<@>2Sv3O;B=(gKQ03+$UJC^p#W6dP-Rys(3eQ{___S*$b3E2&c~}s zQWY*QA0R^oSU-jXVo6QR`EDL%45t6b$F#)^(`K0XOHYQZ{O``lPSOn>U%5O>Qv}g% z4ZG`rT0EIYgp!8re$mbpC6J&;m{JAO0G7h2Y_`5$FX*BwwL~(06F;h3IS-Hs5b5oC zD{Ef4ABJp~;TBN~H3g^g$zEF2Nml=ASy)87U|%cziAfUwiJ%}PS#G*MYLG&P>$*-< zyj25>PnfO;KN?^A)?^JS&wl1ppHg_y`w{nr_}cqmm3{|87ocSs+s9vn1rpk9&}7}A z8bnBl1qgj|{D`pL>}T>rfiAs%8aolmTwe~s*thf@T3h4iG}hZ&T!i62Y$M;qr+aE; zvw=StRFXLGEzxlZCctw7a-*lMP;ih>+D+WZ?vxt1r;fR zadARJBK;2Iz?wLLx)8df^`M$h8$NoTQqr5U%0R~?533=fqDRb684Tu-qwvdR-D;u;Ecu^f}MxQB?U;U z&y@?PuCvIR8oLa@>xhqTB-`+%EjA}nSp+4p>hc`92#5cz3NFY=rydnI;FTk?;3Bu! zzl%X#rU!LJ%KWQU+r^lDCzv##T+w<~G?}4sSuUB><20P%8~%rwLvl?>^`T^oB+w@) zf2y=fShI*zQ+hYWJL)tNbAq+^Pg{NWG~3uT7x3aLGn{jiD4ab@mF-$&)w zhne1TZxU|YgIR{!p(0C@&HIZl9!+K()pBo6&^0V5p3nvc&Xqs2HzWg6HjrqbK26D} zfUXftwro^eL_ora!k6uD&QOcEfkazOJ^E4zBl}PxTQtkpi~12+9RF?6ClPBl;;r&3 zGTF`Vln#d$Y!aEz=&uYJZ9g5>c#BG!$&Y321lo2={dlT7?>y^TY(_-hl{sZ=$?6nj zR+eJw<;u;-@^-De%=aEK-X!}lWxXlf!UL(UYG`2Uqe8}J{f9=z7I=E~K53>OQ~yQZ zvC7fSY#%5c_{-NR9`)3v5L-3P;z~S zvK@bstdez)w`4eR+Juu+zro&=-*N3YJtc+yE@7C@ZS|u1w_{0j9W3~0NWGCEnWgzb z`W;eGHj*t{v+XSOzHyXo>r1rRPjJ#sy(Mz450UtiA+E7`%s+BRA*9$j^7tX$21!o= z9~h@5v#|u5JL5M2a9=bD&sOKdAq&S7Q|0Hrlk{ViqQ&~3U4)>tU?gX^hmbANraBde z(PMsnEywW-4-FYQ67)m8Xl99U+?tQx5}z>C>aa{U+H)Ga%4SmO=6%Hc$rWMWg;fPm z5)u<S|C(sEh=U}6 z`R*ge1E;fLp0`tVrZl-up|kH~#Z08C)q|*0>>`tT0|Oz_@~q=v>G>WW#*f*CU^;GEO1EPBXjW)qfD6Col_O z^ceC2q0Zc!jZH^BRFDWa>S;)j2d#@J7LS=)Xyc{#QKt#^r%~5@Q~w=9F*1~gpDOdg zQ+4hWtSo$gS^>tZd+|~KbkLoLa8Sd8{#10p<81TH#>5c8L`6orkk8@YkdpaCn^t&i ztjgm_<9dSo$=Zophva=yM2-q1gV)Zh&2watOjj8|5?}*OS_P*Fg)55;^cYjoQ__k` zp;>49oaK{Cq@-Sc2unZQ*?MIIV!vl1V=(@rih9(e41Hm=1K3MTORE=rj{aeKr$o!c@2`<;MEiC+Do{!a?QK!B>_=-i~xzG3P z)|A7F2)fYu{*Y#bqE$aepzK>*TwI~AOLab5=ja5?v@)MQHSdh3a_D@X9!DD@LBuIK z3i=(@5WIzI!l=zT>w9~Q^~!Z@Us#E1Wr*!+;@`jv8zHQuDZ7col3x|f1keG1;rs?y zyW`uFIbs}C01M@X8f&8Ow)0dpa(k#d_@K05PF!<6=4wS3&6=;@bjIvW;4J{r=4{Ia z?)<+H9!%nlPmh!TK1lQ$iGwKhwJI7ARY5o#)4vp)VPmJVh_wSM@J%UG=(O0{QiR$Y zD!`2T^fU2xG)-+tDv=m4{f&rj5p%5IkKcjuRo*6=^~qM}ziI{yy(YO?$Nr*}R)O?+ zG-Xzvhc%lvVU2H#)B@|vmnX^ARor32A!5UamF)SL;pW3Fc5^as6V9)tqW=)W?0$$BPe@lQk@9&7DYSt6o;;}@?-_EK zMP1^z`YE}YaphAzgoqSJzP(amX6|b+pAZK`nF>eCs z$t6k8f!r-OblT9T!o6vNVmmA&3s|r6oSaCN`BvOkk9o!0i9*=LTXNW}|Icv;)9>F? zzhvA6n!KxuU{qpb0Zch6W7BQJ=oV-|SST{o%y1zSOgTDgNLyBFwK4Dw!!mq#b0(QLZjX0dyT>@3ufVP$y<@joC`Yqq89I4!^F*;m1DYVw(EszsZ2X>nP2DV7mJ-6g z6B36D@ifE9Zbh(B)OuFkOi=}QcXU@(jo%TB>J-cB!VaFr1MKIs#UNZV+LGvYaq->Z z^7m2Q6klb;*+a>sAwz@yy-nL?;t>Fx#G4nYKle8G|C$f`YcEjP?i z1nm#Ie52EzNF&8aqhXT!*_IA|c&G%lvMQ|#wfyV}t*Mn+sPY#z@Ou9*g4Ff8^zNIb2G#WWT{gY8}k-I=;(O*j_qswK3Jhd#X%B zI&!mQ%zgE`W$Kr7U;OcE(D+_lC8+omd_cC8z!kz*W8q3FaH$k}@GHK>-&pUyHWjQAJV?WC`c*MYz z_a3O}{iCK_$LK=c{5%Tk&j8LdEAus_>C0e>$GT9i`lZVqZ*;B&t+!)2$_gP>GJfcL zu~~5jIa-KLcWWXg+V#w|^dpZVuE#5AZYK*i{A?TZmI@}v;c5xzq#dG8yVo{D&@FVf z<+{+Tw~`DR$k0V^C$T!m*@08fB&}*8pb3!P4i1kBX^JzaNcN3^uA}IK1AsV>a9`DH zEO{M*;h!iCZqNAW9y{?x;aQi9HJk$9jSuyc=Es9tCsru@@!_~$RKPZQxrENQ7(!_u z1~|O-zXycI-Z#F#s?1DbFqrmY{NTr67=JHlEA~X_qUk}FOb~Fa1fZSlz|25jpG^Bj zJUHI_UO7hu;l^%u`1%o#Om==v!~}k8nBam}tQ>kKW%aF7sv`$WB9T@>uxlt*G?=dQ z$!cDBMBV}k7)O6ji16bkzf1H%+ za*v#LKfJtf>xZlql{Xw=G}w;lXWJ$qkEdfM&B|-`Huahg>_-z?)<<8tqILNCU~Jd? zAWF8d7b_}5#p4fO?_7oD+ZF%k+0m&cQ}b|tw(q#ih8?WZhS7o4A@5eQEpd;P0k&-R z+CUbtfHr5q;=DEV1Cf&{cEJu?awVD3wn&<4;~ywImdLGpVd*_9!K0SC@b%ga-cu?L zOH-wF|HpH~neX1)uN=d3jk?-VrjdCd6fbQzKC6xEY=Q?pJJCmTLYSW{MG;AtC zJu&ZQcM&I(TJz6)IY8kJ++hwA=4BgaYf#nZN%c@m&YV1Mu$MV|G}p5MRJWcwT;tuG zyxL=Xe%wjI|FWDXk|jX>FBesScT1Rl}P9RPZ5i>^j? z675Xq*Z<1b=4tn6$6n-6aRZR=O)DKt0h;y24p1M;U~53z)g{;UVmnR(R?jA@46eA3 zBnbBJH&SEO`agX5(Z<;Z+3E)+=XwZC4;!5r^GLfQJ}Z;+00U-v`%YqE8alcWv`Itj zjPigTs+DKz7-Cm#hz4L0L+hO&oEh$(lyj3jWWD{vAZ5?Ep>>4ZRdeppov;FbU3v2u zZnum79f8`J`Rn>-#F{Yz9#h4cCmBpEUulYs!G8g1p~=HpM}xhOMNbnD5F3{nF8)o9Y&{_{^%D8mDmB z0p59q7RHPBxhl@-?&+JyH{=lQaedUDvsE~Xt?3idWHv@m6d?yP5xY@v?JrGlt3`4* zddTmRSnk;Kp)CG1(`t^IGebOH2ny)FCotSSb}NvYu3D_U{>Wo!+u>hVK~4VStG_aI z+3Hend8ZDaxNT3T>GtyNT_@$hdfsJG0O<`oVDHnEVM|psGT~FrgVk%eqN%h zs>OZfNwRkFRs)2-%dvv~JvngOC}KTN9sH)gx61cPOs*``FT^b0k8=PRxSxFRx!Y4_ zJT`qt!k8xHYhlt4H9z+)bY`I2iu+SD%0MX8-R$q!JtQ?+?!j9t@w$5f$1i*s;rt`< zJZW{LaPx|ZN-Rfi?wD){@sCRc0ared-Ur{_w)0-YB$TYot3G-G^Y2|oD%?UsM=r;Prs z<_BK)p*Jl4#b&Ywl#>+EWdA`?>(G{;kC8}z*k1aKB4O6`&>0?64Rxcv%f-;c4E&Eg z+WiE_fQq7mBk(@J|s34 z^ydOE-0kY5|k!mq}LyoU$I}jaAsfO?R=BSzkz&Z{x0^-oGvW<+`0Lo$qgU2A=!eU-dSNO-j{|M822{ zf^O*`)www}34%UkMC zd)h>!A)l&fCBJcU8e@(SOr>}!ts=rj3PT^O< z;0XYXRWRVuc&HbH&y^hIQ~R_|j1jpDzF+tf_Ejc!a08eLO?JKU>@>vb3Tp0o4^FWs zpH>|Z+eArH(m2SN%O%4sS?arlANP_~ACE*_r}m`neun%-ZL(VeHMwhlq&CF>(lRjg zior#K3wJEaE>H=^A5Ga=?_J|}3|iez1gNPige9(LM^!uB3}xT`I*3>eo?+DgN@1*2 z8zI4bfnxr-x3*uM*Pl`Q6snM-*Y3yfrqbemFtUgUE7>)~>zOYHaj0-C9vP6N;=2>+ zRCaCfwBWO7kB#>B_R`Tvhw9-!UP4DTg>lRKM>F}Wyf=G7M26I-^rq_>fK6sVdMn2; zQa}x$qbt@H+)a+QgE14+N0hg3qfW0PF%h?Cnvp?z19L=OfVWaA%O)C4wX6G%!WD?E z_XFsv8(x_^dP61PxJsZik+PzKRuf(;?jv04o=VhI0&}#QffN4WWVXG0-06$zrQs<2 zz`CJpNq-M|mV#CQu%7&>L~^qk=I~IWkRaNw9VcJydZfL-CgOXKkf06kMlju8x=DcH zF{lIz@>p5QVt8CWk^Cz)#2{a5av7Y!~Ld4q0HhJ-i$m=*dVAP%`OZDU&Ms3xH6h9eMvg^8oP#89SSK?4LTVro& zUMIs+(bul`n0%yUkR@4wB+)YGD#!;dhtY7h(Bl($#Vz<(*VkrG@{W(KpKywGhvm=h zjy6|57zFkuS-{SxD5^J}#TiYwak88I2}D1V7JVm^RQ;$4w?6On=_%goALE_c0H*P$ z3LW2OGIGkkS?(l$@nP+JImpEAnkiOEw3{vM7xg&bh@l_QDb+-~_7d^%LT8xE5_Tcg zYqY2P3%Vp?M%Ae_3Q+G?Sn{a~8vG&NdiN_aNgmXC*TmQ$Tj$8ePZ|xdgxd;;dZT>+x9(2x@KJ2b9@O}5-5c%k%FCqateq-O` z&9oo!$#P1js${jaKe1oicU3h3X&%~QRJAqUt~Q|%F)flddRtP{1ubWuRSqs*l8+A0 zIQ+W$898TE30CecibJyPe=NV?CL4GueoIsXX8- zO73@m!7$uRMHAK=N$3AX-Wnd?JJsxqBCDV@i@#1P`g}b@bhS6hQSu3+i%_iob=hNg zKU=G}vC>>^am9PZ{=zG(s})ApDj+Z<1cs-NTa8j3@;;2M+{ByR-ZZMZ%Ru5jlF3k} z{Ha1o+s|x+tnH4!>GCO$c8$pOW0z|7AcZsfCA)gc%)6!@cMGI<-i&AWp|x+Z@wky- zVrpwxQi~}zo*k!9U#ccu|EMC|aY4H0H#X&MB~nbtF^mfO&fuTN>v_Euace-4T^-X1hnnVIJ)x3@Sw7C9l&nmw=AnhSkDTlu8% z(HZSxs#=YvDL;02-&|j{`5Uw;iil%(;H9NZZzYC|f8ge1dA?{aC-+knAzIj*_m@M- zEIM;|kYRuaGKRC1KJJiDbs>3OH{mU@7(TQt1Y|^;z4}e3+1yTE&+QM&##P_^l=)ul zxv-qA|8Jve#9;TQA#Ow&W|4J?lDo=~^Tug>6T<80fZr6ad>`@k8#HWc(ci`pWS`}s zS0hi^xXfhGn8?JokG>z~C=XbWBx|`l=s#ZVNHo>epSR*4btVaG58QpAuW$VHSc z^MjEZMnbm-V~ao7{u{F8j~o(q+UQz%H3OkD8GJyuGIgCQqo4BjShmh5p8!MlV?3Bn z=L3;_fFbSI&|&rO5H5Z$lv=-z=B0yBgEJf9zh>Q4#R>p+lgw z1t`?qz#$acJkiT(JMTtxC_Ye@KQopXvikOn-R-$|eH28<_2eh`f9-q;JXKr!{~?7! zLL)*UI!6PQA-SOeiIgcCkS0phB~hHDM2aY`Br2i^$rv&g8WfpnK$56v5OL1_KhNRx z$IGpI-`nqf|G$6h^ZA~&*7K}qSZl9g@3r>X;?&lgMdzq%uP=+9;G1}iY;-g)c1il~ zwVq3ql|{pzFMVAe9r$JgQT@>c{&gBIRF!(i*|zP4x$XXSo8^7=!#MqC<@754rcum2 zosXlQysPyh-^`|GdFD(14(7%L-b*u4GV2p?qlVAWz#b%Ip*p?vbLv?>)d zc)7uKl%3SQ6pkjr>%W)xL|n_xHEcQ7om4r~Ov#WU!4>_?J9xfSal88d&-3W{)7FgX z;k=i!MqDsxyVkK;27!g}u6uf~q*{I50U2}MhRtef*FHSnV5K$N8@@WRl1D?>Kfy|s zS4Q-dYLZpuv022}RKX4V(sCWdFBD(dnO@PZq{8z?eix~7?&gW^>0y%+w$YScS4O8i z4ONe;oVCcNPQmEl!3?w1G_A9Z0y(W7_R$BZ#arpRC3oaNGCT@lk! zrc}0_yHkuh@2PPN7tixaf~HmTcA1arHdirMO3;39E?{Igw!LuL!}^=IRy>+lOmaL% zX|mVrP>IMGYa5$&;OWt6m3*`bT^*$?)z-$1yazu1L4C0fZnq;V@^suK$7ee&zn>%W zR)u6FXjm+Ef$HMovi=RnnF+oXok#4pm1ZQkTr0!}fxI(kFhp;PybFa*hhP*|s1EBNv6__~qGExswcTIp{@;J&w^gcqbpk zTIc%Zk?qIwEq9zxze$OY_$^Ut-Ao$2i}g39L@pirm%vXp|1g_^bg8Q0_PlhPiT?)VCGgaJxOPoGQ z71h=*o_vj9RX6wKlUVDUvB66~`jXYsGB@p6q|nErW32NPd#_#{Z#`F(CH%!oesPkj z5gTWim?8b9R^@3GTA;nsQcc~)wVUGB`HQ~HwQ;7sqh8?PQ-*125T_4yMWU%t3#`#xrq-zJBd z)CFa%V@7|?a|-J2d4BNY>fFlBuGbZWe0~4mcxakT9oOvM$!l}0{%g{_uoMUNhTw)b z<GIOq<6=4$&SZi84c~5GM(Jc807~m`W(kG4MJ{jT!pR?e5}SvR^_Y2kFf?x1PgOe z1z8WexsI#dYxl~{`lCxlkB7!BG2@(DW}|Cc6so<+r1_M@GIsa#6GGLy7hO8&a8svg z0juafZj+Qf<05@D4d-uzK{$ozC=gk7w@~v-tE-$_eQ;Quc#C~UE6?H-oBJP{|B&0R z(;K+iMS3dt((Xo=uPu?vy*Amjo-dv$63Wh<+DoTsIB1rXl!OcV?yTjnwia0WQEgHu z$#7mmdx3LR*6o=p&HPtBuF$-^rcS#>eXF*Lv6t+@DRK%5s}J%t1s@LiD(#TIpJyh? zjoVaSo!E3pd`q{nrr)CrOIqL5*NZs@a%y@$4%6I{Ds({e4_?EBJNE-}qb}y%?43Gi z^X>DGqx5E$a`SqR(Z8lI-O+I8L~Ipz{FFn1GNu6v7Wo`&i$+_~sVt-T){H6)nOfm0 z*S3X?D^y9q+4TO>JQIhY@tyN0`KuatZ>8f57>jbDEoNHDLNukcG>g!>F!vw(3T~^ z?8012Va+AE`_qq`Z+!K7RAj;IkET+fFpciem=p}tvI>37GIqZP(Km+E}_08U5NMF{HIx74%O%I{8YP2N%wZ$+Rxm%yJ{uFWXdBou{jvk{YT2goWw3KZw86{%XzGsdq^d7h5wpEf`lPY;}q3DD%asRXPJiUB9oo9#Nc6_^cdxce2 zc)HJQuYK@fHRGyXs~X8o8B^pV@i~EkgR6loQ?MkqSlC29vwINcGpXP zUGXuWTxef2O>S;mefxnv!I@xbJ79hB|NOk|#X_2uI|_Zp zI>?4GFLL+PrJg=66UEMVI851ZXKIyOf^l_Q)|XV)($Z2c8PjBKMf*2r+|S1g`aXsO z@H%6$#?H3tnI(L%Onl+f6nzpyY+J)>tMXEVRW$X$$88C5adFlb7MHSL8zt`0Q@6CV zv}!4hc-mYX(&N;S@98(z{ZJcQjHRU*k4M0|Gjn;G{Jl4LPhX;B^QP>ojs2T4y93=H zB8+Leo?c!SCnk~uq@TGSWau|$&7O3In}g%Hx`FZ9oUHCw!NwsvfswGHb-=*@Z|L^P zGA05ZXDM-aO{=*pV>h1IQx$*Fbl0w!rTo&HG8`>neDY74yGgsuRdwUn7e~hX&8y3s zUbmbxyW4jQC-udPoFj2czrXgaG@HlqwWLZ*(oA0Tw)2;F-F|+4Y%&pnfkyYBrTwlM zM8C3S71dFda?OR_)%2=sm5`$6XV;$2x6;OXa+#lJg|WRjSXjd5>*uF7drj%-nJdNp zEkD5J_VCr;D{JpS&}kPe&2?7Z*Nuk*j>^!3A3P;xb8Wco=yo#tQNA0!1J97ok5@cL z;z+i6daf+mXzu=itqaelNvsMGKPjXr`y`|JnSi`aokpxt+=bTG$~c3Nk}*6&U9!r` z%C6f?iH8jP9c;WJB736X)}*04+Q=Xz;sY!elcr8BGK?{vU)v?`TS7IwZXyw?V5hb) zPJVaIr?ExFHse|u4eiJ(`tHoQNtENXwwsUig(KoG-4RiCoVRY$qe5-o?gAf?Jq9lN zgy&}wSW7KZF0Rrd6?+KjlGvbuS6wwtnNyePTxr$x#}enxXn3Ymblj;VZSyQ+s*j0x zPqa~-z(Rk$%PS;gOcD#{!1N}?q9F2YEUTzV_8IAQd^g<4_gb5p&UQA3x=I?xZF>63 z!2T_FDfjELtLt(Pk77S#Dc4qYVfl-|cW%+{ zbGE%*c0O$uw8@QMp1bN!S>lwqYxG>bOUqbq&};L$J;pNxkC6&p4&)ugQV z;Dy$Pxv*;Nteo^|HT7wrzU=$WZQUz*d3oFS-tn5~aFZUa3Z13Bf|rzYV@rXBX^PEi zp(AWfK9rC{@9NSPzz$e?a@ZbLH8VKs*HnP1(`>q6 z(2@ALAqQVS7CT%A!^?YSg=Q%>T50y+~xavjX z&S9bJGG|xL`X|eG=+`-$#XgCO~+}HNi)PZ|MJDg-}p5H#? zvMe^nFNBZ!vHto@l9%@pNFC-Q9UYB56F%uh!7c`$0yAfkAT{G#E#vSi;=3tJp@G6Q zNHEQ4Ta|`uCa+gGl1pd2lyj)3bK>d6py8R8)C7`#>;}b)J4!B{>of>+T#N^O3GTP* z&RA)Y_DBoBx1HSBF$EfTut-o-1i)q@l`q?LtQJYYWGUwhnWHmU&dk}U^zg|O|D+|F zUgy1Fpr(mSNEEFOy292TpcX)a7cKHn2`>(?+qbXkS&#rvwkQ9rQXU}%(Uf;2RGGlG z21bIzgFohbM@K)cgl~VXP=Lq%8kpjsG834US;|SxWra%s{s>IMW`r+k#Z$38GTI(G z{@%>~>VDw(yC(%#20U>{JSedKIBfF7r|*9s5S_leL&0(td;x7Qk4r)0D7&z%tl!rA z)s!UYSxzXlxF)!0m*_Y@uT~q`=_fmmCrT{QA}O-Z%+_FKW%q?QG5l$-t1}LKlvUii ze504Qn2Zc}ameC=ceN=#^QUk%JaMfrVe=_S4%b|zU95UQS*Nk%RM#?kZ}&yGpFc0T zRP)8#eE(UxRo0cUr>_^ioc&wQTICgu=J666O-%Ok6sCWj?(^vIZTYcc7u;?TB3oOJ zCW~jyYg$YM7&L2l*^wDycpIo_Y(ml1#HB~Gtq7_BL)eapiU}bMQ ztqxat26+v)kH6#b$^?Sl`7Wk3^N{iS;;)k`;zdn82EEtZB0G1~)aa zH{8_s>>`qzs-ydn#9n{9PuqM|PdMqYNszo^vIUg46}r#8+o;Z7xNe+JqvOlTNBQMz zzO<*-lY)exI|+1-nHpq#w1A|i(6Y~!>#liB%nFuy(|W9q=X$PNZKT|(v{cfA3L`G_ z^mw0jqV^kRsN1~Fsp8wdkVE?V-OE`I6dUyA3Rq+n*}$o`lU|PbFY2Yoy0WfV+x19w z?`l$G-B>$e(HbpL1y3EU{xlJ{lF7uGQK5||aiC1{HP7gFJjnLJCbO7B%`!j0wyea>5`EmIDxrKSM`8To z8N&IIW>YLPf6Eg*0`-#-oh_%ge_!TKwLMb{={?xojv|~G) zEO}W)Rk-pC#HvejEpY~sIzQ#tFEM`fdU2kamlpTJhc!u>%XOB;s+qY-K^nf`NiqZA zXE}d`UoG&f1%9=_uNL^#0{@{F;0C+Ge*r>J7QY$&-xA`%5gLHr4@?gSqMwfIu?pb7 zC9r}c`0;IBKy`l_^8*1N`X*Hlph5C~Jg|dBRe;6_*bH=RTb*I}mw}c$41J(3yfyk+ z0sCwAq)C$qF)^`!9HOG41UoxB)*Y|m&j=G(Sy_oghYk_0uC6}?>gwt^K7xOS^PrO- z{nydaq5mwv5j&3mke}s0=p_sc40_kEUr+lPAd|^BXZ=+FKYjW{Cw@|ZzS;Ai_8+#x zX&W|d=>4-Q1_uYz+}+*(rObcYe>$B`ELyaPHhT1E`rEf}hrLc%MovzSCMYOK>+S6w zROUbJe{OCrZQ8VH^m+5<^}^jT<+PK6&zFI=rAZsLW9RogyfEoFm9B zfHzKn{;8q#mx_aJ<3t|okM>JViO znFR0vPg})YK3*HoJ*!+qW_N#XdfN{yZW){4yi&j1b06e1wi zn0Wi~C2^-D?wkMURQK0zqO0o*VPRoTz8$t zX{n6zJv}|&#w?EC?(XhhC^KyPL)}Q=2lVf6J`bo1*&h6JagLB7TH2oxMK#xmOIg-L z;sXz?XFbUAgB;x@N|t!u@{l-iVZk8(nT|erQcAF}un;RXRx(M9xT2z*7(14eNKQ#2 zgoFeM>_guRL)*X4e@fE8Yrw1v&?3P{4a}!KI!*W`ttF1eEFq%rI-&n`;0Zuni~Ou7 zK}5#=i^KYleFY9ZiQL?rLGB@)OrA{$2@4VS_P-C}jg%R|e_8P52KbT&Xa_v(Pg}q| z!v;Lx{(LFKt$k^7lv6kv=O9f0);|sUKdz16#_vcz45S}AbP(@nh{ul~4J4149^QZQ zSnyE>=0X|pBOTI*G5>#QeQC&>1HY!P+`sZ+{;cWu|6BhZ(UE>eWo0Ez-$0*+*WyRQ z2>vtXNoK!c#^5V+91j~0j2}LDELPuBUABC>2E)6kp;zaCk=7XGv4EWCpzKjDu7{GL2o@@%V9A1Z7S4@MC<$yI#;gqQmm-N%VK>AgGI@~#&JPPvO04xvp zC6v$oykgL~2(SS1mHjkWBXJ(4)B@cDoq{y3=_vaS;`e=Naz5}yzw7jX0#M!$WQoku zK*Bvn`CI=7y$=8q$O}ka&zMV3C1?}L#oqnv23ZkgQ<0xnaS`q}GKh@Q0OH`4Ik@Is z0ar~fV$gm$*L?zPU9tmV>fQQ$P zaF1S0R5#^)^RHi41NhOHMl`gRe&d5o;&+`MPyqChQ3tNKjcuhwIo!8h%(7zW10MGG zOys})*a&T$&bT+iJkT!zUk~e6^D3WF{?L`VaPLu#JiMox0C6Lh#WfxEM&#Nd4{;Fq z`;muuQlCb6#Vzl*NqG(J_QU&eP!{?z`J>16rC=k2z__-#fT?RI@I29GMPnAM$tsNa zMEnZyfm{I)MjrMZ>|^fHO2nIv=S*33;KiYTB`;EllQ%ROeGBtIj|ZqT{ZB1E1$DD! z$o2Du2Q=|_lOTih4spNkI`Q~<5)q!Wr{4$idGOHyd3bMH{Ol%CSRKXeW4%y!oWq*k zuE|5c3WIh`CoW}MGi4os=L8_G_uKxH*J} zHZGtu5bp;-*+F*ifUG{y+#!~S*b!o@5uN`pWPraL0V~0G7-JMmNFV(#baOaGm^rDnPr>0f7G$+^hZ-ezm}_7WmZyzgpmLwm{$W=XzwjZNSEMf{4UNb5(;>!(RT8N$ z=75;dPA`VU9sT*fc7P&3p2x#TQNU8bulKZ|5q^dL%`Gq&Du;V0e+J&4*Z`8C+ZcfF zIAF|#6Qq*>MgT6rKNZA5ksAP?69(cr z?uC2P1Cf-JM5j`zj6Lgt^lR6y(a)Vb_l+JE74=i>uUfT=rl_d+%?{HCJv}|z^5x6F z(FfXx=dDYy-_X$q%6oWzTo1I^DLt!wDht;c?h zeX)DB(YSvS0*Jkwvm4F?-3ju7X^itQ7nehHO-&6VIXM~5@ir3G)zw61W(MKx>_mL| z@`cdTTSF|8Uqrun@gglDA%QL{D@#vIOr#CAPcdiO#u)581K7kCx)2Ya-XJnc&LXV@ z-~?>~=c(C*oRSp7KI3fkZ5tskFHgYvFQd+IMn@#xvc-2cC?*B-rEZf%ezMa`}~)!2T?TebkA7zn2p^IXU0je9M+C z#5_0yh4Jx?#w?5RAp4goEMO1zJScb;1$#LZ2iOPV1baIn9RRou_#N_iCbb(7GGh)G z*zX!vH|mG$L5Kb}B7dNLoB%*K+QGB2R;Xj)06c>9>j8P(dn%ndmkX|M=ZO08y1?JB zz?H${lbMf|2421SY@+wnI5H-yau2T#D&M8vLmg8OmD)#YLY1o$%g8 zI}?~kIx~;4f)a!Fsh{>vSXda>339*rK@s?Z{qYLmA;1Ux5C`l4;Qn&~;1r~%18}e8 z2IO%c@Fd7hfi&*V;XYp`-~`b4A$9?z11|;Q<3QsXWN=6Z__4V6c?|Y$K?eK&X~3iUa z@=igwHo}>7G;uk57uv^b;c*GlI3BOw*^jhTz!@A1s1sxGI~r(Vp|`ienfw*-RSV07 z0vPW?WS0dqeexS*a7YI9tibmW@J#$(Z4B!83^b$Tv8oI^g*8z~YXzDawgt`;xX%l; z=YU;!rg9(T@a!M*PXLT}8M4aGG40<)lOR8Ch-pR^&WX4|=C1b*jas*Big5meXG`Rn zP|y4Dz5&n_kOt?)8)g_uKPwcN*bhvL0qOy$=L*0afB~-smeU7de@A_l0HmSZNcvX* z5A~t1xJPvo;0(Zkx)K>F66pfO==TeN0RRKqL0Qx>l73(@0`6121T+KCCk%Ms`3`{7 zehXj%V5IOp{U{d?2p*y!7V?PeL+C@ZKcass2o1fS8-PXt)(%xTB>yA&hlnt;yzq;C zontuW0NPOf_kl+l!2frXs0(#61NM;@84^a4A6N|kV`?#wFd)s8 z$F{x&VD{A?jZp?=G5pz>8EzaQ?MKEEL;0Wm5JZe>`}jVPNHK8j`mm%eMpYrd4@jG# V9HS}=P&wGgr?SMrToa@Ee*kwS*|q=x literal 0 HcmV?d00001 diff --git a/ProfinetMonitor/Program.cs b/ProfinetMonitor/Program.cs new file mode 100644 index 0000000..ca7b757 --- /dev/null +++ b/ProfinetMonitor/Program.cs @@ -0,0 +1,87 @@ +using ProfinetTools.Interfaces.Models; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading; +using System.Windows.Forms; + +namespace ProfinetMonitor +{ + static class Program + { + static Mutex mutex = new Mutex(true, "{8F6F0AC4-B9A1-45fd-A8CF-72F04E6BDE8F}"); + private static Logging.Logger Log = new Logging.Logger("ProfinetDeviceMonitor"); + + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + Logging.LogManager.SetUpLogging(); + parseCommandline(); + + if (monitorMode) + { + if (singleInstance) + { + if (!mutex.WaitOne(TimeSpan.Zero, true)) + { + Log.Info("Monitor was already running"); + return; + } + } + + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new MonitorModeDialog(MonitorInterval)); + } + else + { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new DevicesConfigurationDialog()); + } + mutex.ReleaseMutex(); + } + + static bool singleInstance = false; + static bool monitorMode = false; + static int MonitorInterval; + static private void parseCommandline() + { + singleInstance = Environment.CommandLine.ToLower().Contains("-once"); + monitorMode = Environment.CommandLine.ToLower().Contains("-monitor"); + + if (monitorMode) + { + var tmp = Environment.CommandLine.ToLower(); + var idx = tmp.IndexOf("-monitor"); + if (idx < 0) //Monitor argument was not present + { + monitorMode = false; + MonitorInterval = 0; + return; + } + + //check if monitor has an value + idx+= "-monitor".Length; + idx = tmp.IndexOf("=", idx); + if (idx < 0) //monitor did not have an value, so assume value 0 + { + MonitorInterval = 0; + return; + } + + //parse the value off the commandline + idx += "=".Length; + var eidx = tmp.IndexOf(" ", idx); + if (eidx < 0) tmp = tmp.Substring(idx); + else tmp = tmp.Substring(idx, eidx-idx); + + MonitorInterval = int.Parse(tmp.Trim()); + } + } + + } +} diff --git a/ProfinetMonitor/Properties/AssemblyInfo.cs b/ProfinetMonitor/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..dae8aa6 --- /dev/null +++ b/ProfinetMonitor/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("ProfinetMonitor")] +[assembly: AssemblyDescription("Monitor Profinet Devices and Assign Configured adresses if they have lost their configuration")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("MLogics")] +[assembly: AssemblyProduct("ProfinetMonitor")] +[assembly: AssemblyCopyright("Copyright © 2021")] +[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("98b9b592-2686-4fef-b950-91a1d27abcb3")] + +// 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.2.0.0")] +[assembly: AssemblyFileVersion("1.2.0.0")] diff --git a/ProfinetMonitor/Properties/Resources.Designer.cs b/ProfinetMonitor/Properties/Resources.Designer.cs new file mode 100644 index 0000000..f8eade1 --- /dev/null +++ b/ProfinetMonitor/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// 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 ProfinetMonitor.Properties { + using System; + + + /// + /// 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", "16.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// 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 (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("ProfinetMonitor.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/ProfinetMonitor/Properties/Resources.resx b/ProfinetMonitor/Properties/Resources.resx new file mode 100644 index 0000000..af7dbeb --- /dev/null +++ b/ProfinetMonitor/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/ProfinetMonitor/Properties/Settings.Designer.cs b/ProfinetMonitor/Properties/Settings.Designer.cs new file mode 100644 index 0000000..2a3ee18 --- /dev/null +++ b/ProfinetMonitor/Properties/Settings.Designer.cs @@ -0,0 +1,26 @@ +//------------------------------------------------------------------------------ +// +// 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 ProfinetMonitor.Properties { + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "16.10.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/ProfinetMonitor/Properties/Settings.settings b/ProfinetMonitor/Properties/Settings.settings new file mode 100644 index 0000000..3964565 --- /dev/null +++ b/ProfinetMonitor/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/ProfinetMonitor/ReadMe.md b/ProfinetMonitor/ReadMe.md new file mode 100644 index 0000000..997d348 --- /dev/null +++ b/ProfinetMonitor/ReadMe.md @@ -0,0 +1,26 @@ +# What is it +This tool allows you to Monitor Profinet devices and write Log messages if they are available on the Profinet Network. +It uses the Profinet DCP protocol (it does NOT! use PING) to detect devices and monitor their configuration state. +If an Device is found that has lost its Device Name, this tool automatically assignes the known device name to this device. + +# Requirements +This tool uses “WinPCap” and requires WinPcap to be installed on the System. You can download it from here. + +# When and why +If you have an Profinet device that sometimes looses its Device name, this tool can monitor this device and automatically assign its correct device name if it has lost it. Thes types of faults most often occour when you have unstable power connections or faulty devices. In that case, this tool can provide better reliability of the profinet system. + +# How to use +If you start “ProfinetMonitor.exe” without any Command line parameters, it opens the configuration dialog. In that dialog you can “Discover” all available devices and save their current MAC-Addresses, Device names and other data into an Configuration file. + +If you then start “ProfinetMonitor.exe” using the “-monitor=”, it enters an Monitoring loop and periodically checks all devices. If one is found without an device name, then it assignes an device name automatically. + +If you start “ProfinetMonitor.exe” using “-monitor=0”, it starts up, makes one single monitoring check, assigns device names if necesary and then terminates + +if you start “ProfinetMonitor.exe” using “-once” it starts up as an single instance application, and allows only one single instance to be running at the same time. + +# How to Install +Usually you make an new “Scheduled Task” that runs for example “On User Session Log on” and then start the Tool using the following Commandline: + +ProfinetMonitor.exe -monitor=60000 -once + +The you should make an second “Scheduled Task” that runs periodically every hour, and also starts the tool by using the same command line. This covers the case, that it started during User Log on, but then got terminated. In that case the scheduled task will restart it at least every hour. And if it is already running, then it will simply keep the existing running instance alive and terminate the new one. \ No newline at end of file diff --git a/ProfinetMonitor/app.config b/ProfinetMonitor/app.config new file mode 100644 index 0000000..ff99501 --- /dev/null +++ b/ProfinetMonitor/app.config @@ -0,0 +1,3 @@ + + + diff --git a/ProfinetTools.sln b/ProfinetTools.sln index 024d0bc..9137af0 100644 --- a/ProfinetTools.sln +++ b/ProfinetTools.sln @@ -1,7 +1,7 @@  Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio 15 -VisualStudioVersion = 15.0.27130.2024 +# Visual Studio Version 17 +VisualStudioVersion = 17.1.32228.430 MinimumVisualStudioVersion = 10.0.40219.1 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProfinetTools", "ProfinetTools\ProfinetTools.csproj", "{8C9C17B3-A185-4D73-9645-A8871F7B17EC}" EndProject @@ -13,6 +13,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProfinetTools.Logic", "Prof EndProject Project("{930C7802-8A8C-48F9-8165-68863BCCD9DD}") = "ProfinetTools.Setup", "ProfinetTools.Setup\ProfinetTools.Setup.wixproj", "{E6C11D5C-ED2C-43A9-8DF9-15D36DF77F6F}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProfinetMonitor", "ProfinetMonitor\ProfinetMonitor.csproj", "{98B9B592-2686-4FEF-B950-91A1D27ABCB3}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -60,6 +62,14 @@ Global {E6C11D5C-ED2C-43A9-8DF9-15D36DF77F6F}.Release|Any CPU.Build.0 = Release|x86 {E6C11D5C-ED2C-43A9-8DF9-15D36DF77F6F}.Release|x86.ActiveCfg = Release|x86 {E6C11D5C-ED2C-43A9-8DF9-15D36DF77F6F}.Release|x86.Build.0 = Release|x86 + {98B9B592-2686-4FEF-B950-91A1D27ABCB3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {98B9B592-2686-4FEF-B950-91A1D27ABCB3}.Debug|Any CPU.Build.0 = Debug|Any CPU + {98B9B592-2686-4FEF-B950-91A1D27ABCB3}.Debug|x86.ActiveCfg = Debug|Any CPU + {98B9B592-2686-4FEF-B950-91A1D27ABCB3}.Debug|x86.Build.0 = Debug|Any CPU + {98B9B592-2686-4FEF-B950-91A1D27ABCB3}.Release|Any CPU.ActiveCfg = Release|Any CPU + {98B9B592-2686-4FEF-B950-91A1D27ABCB3}.Release|Any CPU.Build.0 = Release|Any CPU + {98B9B592-2686-4FEF-B950-91A1D27ABCB3}.Release|x86.ActiveCfg = Release|Any CPU + {98B9B592-2686-4FEF-B950-91A1D27ABCB3}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE