From 40344f7f4b60ff0f0471dadea856fbbda93add91 Mon Sep 17 00:00:00 2001 From: BroPlasmaNinja Date: Mon, 23 Dec 2024 03:32:54 +0400 Subject: [PATCH] FirstCommit --- Entities/Cheque.cs | 23 + Entities/Contract.cs | 27 + Entities/Enums/ExecutorRang.cs | 10 + Entities/Enums/ExecutorSkills.cs | 20 + Entities/Executor.cs | 25 + Entities/Organization.cs | 19 + Entities/Repositories/IChequeRepository.cs | 9 + Entities/Repositories/IContractRepository.cs | 10 + Entities/Repositories/IExecutorRepository.cs | 11 + .../Repositories/IOrganizationRepository.cs | 11 + Entities/Repositories/IServiceRepository.cs | 11 + .../Implementations/ChequeRepository.cs | 20 + .../Implementations/ContractRepository.cs | 29 + .../Implementations/ExecutorRepository.cs | 33 + .../Implementations/OrganizationRepository.cs | 33 + .../Implementations/ServiceRepository.cs | 33 + Entities/Service.cs | 19 + Entities/ServicesContracts.cs | 21 + Form1.Designer.cs | 39 - Form1.cs | 10 - FormIT.Designer.cs | 131 + FormIT.cs | 68 + FormIT.resx | 3943 +++++++++++++++++ Forms/FormContract.Designer.cs | 169 + Forms/FormContract.cs | 83 + Forms/FormContract.resx | 123 + Forms/FormContractList.Designer.cs | 98 + Forms/FormContractList.cs | 63 + Forms/FormContractList.resx | 120 + Forms/FormExecutor.Designer.cs | 194 + Forms/FormExecutor.cs | 76 + Forms/FormExecutor.resx | 120 + Forms/FormExecutorList.Designer.cs | 128 + Forms/FormExecutorList.cs | 104 + Forms/FormExecutorList.resx | 120 + Forms/FormOrganization.Designer.cs | 145 + Forms/FormOrganization.cs | 67 + Forms/FormOrganization.resx | 120 + Forms/FormOrganizationList.Designer.cs | 128 + Forms/FormOrganizationList.cs | 104 + Forms/FormOrganizationList.resx | 120 + Forms/FormService.Designer.cs | 125 + Forms/FormService.cs | 75 + Forms/FormService.resx | 120 + Forms/FormServiceList.Designer.cs | 128 + Forms/FormServiceList.cs | 104 + Forms/FormServiceList.resx | 120 + IT-Company.csproj | 45 + Program.cs | 22 +- .../IT_Company.Entities.Service.datasource | 10 + Properties/Resources.Designer.cs | 63 + Form1.resx => Properties/Resources.resx | 0 Resources/Background.jpg | Bin 0 -> 228865 bytes 53 files changed, 7399 insertions(+), 50 deletions(-) create mode 100644 Entities/Cheque.cs create mode 100644 Entities/Contract.cs create mode 100644 Entities/Enums/ExecutorRang.cs create mode 100644 Entities/Enums/ExecutorSkills.cs create mode 100644 Entities/Executor.cs create mode 100644 Entities/Organization.cs create mode 100644 Entities/Repositories/IChequeRepository.cs create mode 100644 Entities/Repositories/IContractRepository.cs create mode 100644 Entities/Repositories/IExecutorRepository.cs create mode 100644 Entities/Repositories/IOrganizationRepository.cs create mode 100644 Entities/Repositories/IServiceRepository.cs create mode 100644 Entities/Repositories/Implementations/ChequeRepository.cs create mode 100644 Entities/Repositories/Implementations/ContractRepository.cs create mode 100644 Entities/Repositories/Implementations/ExecutorRepository.cs create mode 100644 Entities/Repositories/Implementations/OrganizationRepository.cs create mode 100644 Entities/Repositories/Implementations/ServiceRepository.cs create mode 100644 Entities/Service.cs create mode 100644 Entities/ServicesContracts.cs delete mode 100644 Form1.Designer.cs delete mode 100644 Form1.cs create mode 100644 FormIT.Designer.cs create mode 100644 FormIT.cs create mode 100644 FormIT.resx create mode 100644 Forms/FormContract.Designer.cs create mode 100644 Forms/FormContract.cs create mode 100644 Forms/FormContract.resx create mode 100644 Forms/FormContractList.Designer.cs create mode 100644 Forms/FormContractList.cs create mode 100644 Forms/FormContractList.resx create mode 100644 Forms/FormExecutor.Designer.cs create mode 100644 Forms/FormExecutor.cs create mode 100644 Forms/FormExecutor.resx create mode 100644 Forms/FormExecutorList.Designer.cs create mode 100644 Forms/FormExecutorList.cs create mode 100644 Forms/FormExecutorList.resx create mode 100644 Forms/FormOrganization.Designer.cs create mode 100644 Forms/FormOrganization.cs create mode 100644 Forms/FormOrganization.resx create mode 100644 Forms/FormOrganizationList.Designer.cs create mode 100644 Forms/FormOrganizationList.cs create mode 100644 Forms/FormOrganizationList.resx create mode 100644 Forms/FormService.Designer.cs create mode 100644 Forms/FormService.cs create mode 100644 Forms/FormService.resx create mode 100644 Forms/FormServiceList.Designer.cs create mode 100644 Forms/FormServiceList.cs create mode 100644 Forms/FormServiceList.resx create mode 100644 Properties/DataSources/IT_Company.Entities.Service.datasource create mode 100644 Properties/Resources.Designer.cs rename Form1.resx => Properties/Resources.resx (100%) create mode 100644 Resources/Background.jpg diff --git a/Entities/Cheque.cs b/Entities/Cheque.cs new file mode 100644 index 0000000..82c7596 --- /dev/null +++ b/Entities/Cheque.cs @@ -0,0 +1,23 @@ +using System; +namespace IT_Company.Entities +{ + public class Cheque + { + public int Id { get; set; } + public int OrganizationId { get; set; } + public int ContractId { get; set; } + public int Amount { get; set; } + public DateTime Date { get; set; } + public static Cheque CreateOperation(int id, int organizationId, int contractId, int Amount) + { + return new Cheque + { + Id = id, + OrganizationId = organizationId, + ContractId = contractId, + Amount = Amount, + Date = DateTime.Now + }; + } + } +} diff --git a/Entities/Contract.cs b/Entities/Contract.cs new file mode 100644 index 0000000..9c9c65b --- /dev/null +++ b/Entities/Contract.cs @@ -0,0 +1,27 @@ +using System; + +namespace IT_Company.Entities +{ + public class Contract + { + public int Id { get; set; } + public int ExecutorId { get; set; } + public int OrganizationId { get; set; } + public int Price { get; set; } + public DateTime Date { get; set; } + public bool Paid { get; set; } + public IEnumerable ServicesContracts { get; private set; } = []; + public static Contract CreateOperation(int id, int executorId, int organizationId, int price, IEnumerable servicesContracts) + { + return new Contract + { + Id = id, + ExecutorId = executorId, + OrganizationId = organizationId, + Price = price, + Date = DateTime.Now, + ServicesContracts = servicesContracts + }; + } + } +} diff --git a/Entities/Enums/ExecutorRang.cs b/Entities/Enums/ExecutorRang.cs new file mode 100644 index 0000000..6f74b17 --- /dev/null +++ b/Entities/Enums/ExecutorRang.cs @@ -0,0 +1,10 @@ +namespace IT_Company.Entities.Enums +{ + public enum ExecutorRang + { + Junior = 0, + Middle = 1, + Senior = 2, + CodeGod = 3, + } +} diff --git a/Entities/Enums/ExecutorSkills.cs b/Entities/Enums/ExecutorSkills.cs new file mode 100644 index 0000000..1c1fff7 --- /dev/null +++ b/Entities/Enums/ExecutorSkills.cs @@ -0,0 +1,20 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace IT_Company.Entities.Enums +{ + [Flags] + public enum ExecutorSkills + { + CSharp = 1, + Java = 2, + JavaScript = 4, + Python = 8, + UXUIdesigner = 16, + QAEngineering = 32, + SQL = 64 + } +} diff --git a/Entities/Executor.cs b/Entities/Executor.cs new file mode 100644 index 0000000..de2ae8c --- /dev/null +++ b/Entities/Executor.cs @@ -0,0 +1,25 @@ +using IT_Company.Entities.Enums; +namespace IT_Company.Entities +{ + public class Executor + { + public int Id { get; set; } + public string Name { get; set; } + public string PhoneNumber { get; set; } + public string Email { get; set; } + public ExecutorRang ExecutorRang { get; set; } + public ExecutorSkills ExecutorSkills { get; set; } + public static Executor CreateEntity(int id, string name, string phoneNumber, string email, ExecutorRang executorRang, ExecutorSkills executorSkills) + { + return new Executor + { + Id = id, + Name = name ?? string.Empty, + PhoneNumber = phoneNumber ?? string.Empty, + Email = email ?? string.Empty, + ExecutorRang = executorRang, + ExecutorSkills = executorSkills + }; + } + } +} diff --git a/Entities/Organization.cs b/Entities/Organization.cs new file mode 100644 index 0000000..e0edf28 --- /dev/null +++ b/Entities/Organization.cs @@ -0,0 +1,19 @@ +namespace IT_Company.Entities +{ + public class Organization + { + public int Id { get; set; } + public string Name { get; set; } + public string Address { get; set; } + public string BankAccount { get; set; } + public static Organization CreateEntity(int id, string name, string address, string BankAccount) + { + return new Organization { + Id = id, + Name = name ?? string.Empty, + Address = address ?? string.Empty, + BankAccount = BankAccount ?? string.Empty + }; + } + } +} diff --git a/Entities/Repositories/IChequeRepository.cs b/Entities/Repositories/IChequeRepository.cs new file mode 100644 index 0000000..8e8b477 --- /dev/null +++ b/Entities/Repositories/IChequeRepository.cs @@ -0,0 +1,9 @@ +namespace IT_Company.Entities.Repositories +{ + public interface IChequeRepository + { + void CreateCheque(Cheque cheque); + IEnumerable ReadCheque(DateTime? dateFrom = null, DateTime? dateTo = null, int? organizationId = null, int? contractId = null); + void DeleteCheque(int id); + } +} diff --git a/Entities/Repositories/IContractRepository.cs b/Entities/Repositories/IContractRepository.cs new file mode 100644 index 0000000..9db4722 --- /dev/null +++ b/Entities/Repositories/IContractRepository.cs @@ -0,0 +1,10 @@ +namespace IT_Company.Entities.Repositories +{ + public interface IContractRepository + { + void CreateContract(Contract contract); + IEnumerable ReadContracts(DateTime? dateFrom = null, DateTime? dateTo = null, int? executorId = null, int? organizationId = null, bool? Paid = null); + Contract ReadContractById(int id); + void Paid(int id, bool value); + } +} diff --git a/Entities/Repositories/IExecutorRepository.cs b/Entities/Repositories/IExecutorRepository.cs new file mode 100644 index 0000000..b12cbdd --- /dev/null +++ b/Entities/Repositories/IExecutorRepository.cs @@ -0,0 +1,11 @@ +namespace IT_Company.Entities.Repositories +{ + public interface IExecutorRepository + { + void CreateExecutor(Executor Executor); + IEnumerable ReadExecutors(); + Executor ReadExecutorById(int id); + void UpdateExecutor(Executor Executor); + void DeleteExecutor(int id); + } +} diff --git a/Entities/Repositories/IOrganizationRepository.cs b/Entities/Repositories/IOrganizationRepository.cs new file mode 100644 index 0000000..bc26acd --- /dev/null +++ b/Entities/Repositories/IOrganizationRepository.cs @@ -0,0 +1,11 @@ +namespace IT_Company.Entities.Repositories +{ + public interface IOrganizationRepository + { + void CreateOrganization(Organization organization); + IEnumerable ReadOrganizations(); + Organization ReadOrganizationById(int id); + void UpdateOrganization(Organization organization); + void DeleteOrganization(int id); + } +} diff --git a/Entities/Repositories/IServiceRepository.cs b/Entities/Repositories/IServiceRepository.cs new file mode 100644 index 0000000..3814027 --- /dev/null +++ b/Entities/Repositories/IServiceRepository.cs @@ -0,0 +1,11 @@ +namespace IT_Company.Entities.Repositories +{ + public interface IServiceRepository + { + void CreateService(Service Service); + IEnumerable ReadServices(); + Service ReadServiceById(int id); + void UpdateService(Service Service); + void DeleteService(int id); + } +} diff --git a/Entities/Repositories/Implementations/ChequeRepository.cs b/Entities/Repositories/Implementations/ChequeRepository.cs new file mode 100644 index 0000000..c04d1e9 --- /dev/null +++ b/Entities/Repositories/Implementations/ChequeRepository.cs @@ -0,0 +1,20 @@ +using System; + +namespace IT_Company.Entities.Repositories.Implementations +{ + public class ChequeRepository : IChequeRepository + { + public void CreateCheque(Cheque cheque) + { + } + + public void DeleteCheque(int id) + { + } + + public IEnumerable ReadCheque(DateTime? dateFrom = null, DateTime? dateTo = null, int? organizationId = null, int? contractId = null) + { + return []; + } + } +} diff --git a/Entities/Repositories/Implementations/ContractRepository.cs b/Entities/Repositories/Implementations/ContractRepository.cs new file mode 100644 index 0000000..f3a71ef --- /dev/null +++ b/Entities/Repositories/Implementations/ContractRepository.cs @@ -0,0 +1,29 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace IT_Company.Entities.Repositories.Implementations +{ + internal class ContractRepository : IContractRepository + { + public void CreateContract(Contract contract) + { + } + + public void Paid(int id, bool value) + { + } + + public Contract ReadContractById(int id) + { + throw new NotImplementedException(); + } + + public IEnumerable ReadContracts(DateTime? dateFrom = null, DateTime? dateTo = null, int? executorId = null, int? organizationId = null, bool? Paid = null) + { + return []; + } + } +} diff --git a/Entities/Repositories/Implementations/ExecutorRepository.cs b/Entities/Repositories/Implementations/ExecutorRepository.cs new file mode 100644 index 0000000..7581167 --- /dev/null +++ b/Entities/Repositories/Implementations/ExecutorRepository.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace IT_Company.Entities.Repositories.Implementations +{ + internal class ExecutorRepository : IExecutorRepository + { + public void CreateExecutor(Executor Executor) + { + } + + public void DeleteExecutor(int id) + { + } + + public Executor ReadExecutorById(int id) + { + return Executor.CreateEntity(0,string.Empty, string.Empty, string.Empty,0,0); + } + + public IEnumerable ReadExecutors() + { + return []; + } + + public void UpdateExecutor(Executor Executor) + { + } + } +} diff --git a/Entities/Repositories/Implementations/OrganizationRepository.cs b/Entities/Repositories/Implementations/OrganizationRepository.cs new file mode 100644 index 0000000..6e501dd --- /dev/null +++ b/Entities/Repositories/Implementations/OrganizationRepository.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace IT_Company.Entities.Repositories.Implementations +{ + internal class OrganizationRepository : IOrganizationRepository + { + public void CreateOrganization(Organization organization) + { + } + + public void DeleteOrganization(int id) + { + } + + public Organization ReadOrganizationById(int id) + { + return Organization.CreateEntity(0,string.Empty, string.Empty, string.Empty); + } + + public IEnumerable ReadOrganizations() + { + return []; + } + + public void UpdateOrganization(Organization organization) + { + } + } +} diff --git a/Entities/Repositories/Implementations/ServiceRepository.cs b/Entities/Repositories/Implementations/ServiceRepository.cs new file mode 100644 index 0000000..286d1d5 --- /dev/null +++ b/Entities/Repositories/Implementations/ServiceRepository.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace IT_Company.Entities.Repositories.Implementations +{ + internal class ServiceRepository : IServiceRepository + { + public void CreateService(Service Service) + { + } + + public void DeleteService(int id) + { + } + + public Service ReadServiceById(int id) + { + return Service.CreateEntity(0,0, string.Empty); + } + + public IEnumerable ReadServices() + { + return []; + } + + public void UpdateService(Service Service) + { + } + } +} diff --git a/Entities/Service.cs b/Entities/Service.cs new file mode 100644 index 0000000..4d0e8b5 --- /dev/null +++ b/Entities/Service.cs @@ -0,0 +1,19 @@ +namespace IT_Company.Entities +{ + public class Service + { + public int Id { get; set; } + public int Price { get; set; } + public string Description { get; set; } + public static Service CreateEntity(int id, int price, string description) + { + return new Service + { + Id = id, + Price = price, + Description = description + }; + } + + } +} diff --git a/Entities/ServicesContracts.cs b/Entities/ServicesContracts.cs new file mode 100644 index 0000000..a63df84 --- /dev/null +++ b/Entities/ServicesContracts.cs @@ -0,0 +1,21 @@ +using System; +namespace IT_Company.Entities +{ + public class ServicesContracts + { + public int ServiceId { get; set; } + public int ContractId { get; set; } + public DateTime Deadline { get; set; } + public bool IsComplieted { get; set; } + public static ServicesContracts CreateEntity(int serviceId, int contractId, DateTime deadline) + { + return new ServicesContracts + { + ServiceId = serviceId, + ContractId = contractId, + Deadline = deadline, + IsComplieted = false + }; + } + } +} diff --git a/Form1.Designer.cs b/Form1.Designer.cs deleted file mode 100644 index 52cc6fe..0000000 --- a/Form1.Designer.cs +++ /dev/null @@ -1,39 +0,0 @@ -namespace IT_Company -{ - partial class Form1 - { - /// - /// Required designer variable. - /// - private System.ComponentModel.IContainer components = null; - - /// - /// Clean up any resources being used. - /// - /// true if managed resources should be disposed; otherwise, false. - protected override void Dispose(bool disposing) - { - if (disposing && (components != null)) - { - components.Dispose(); - } - base.Dispose(disposing); - } - - #region Windows Form Designer generated code - - /// - /// Required method for Designer support - do not modify - /// the contents of this method with the code editor. - /// - private void InitializeComponent() - { - this.components = new System.ComponentModel.Container(); - this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; - this.ClientSize = new System.Drawing.Size(800, 450); - this.Text = "Form1"; - } - - #endregion - } -} diff --git a/Form1.cs b/Form1.cs deleted file mode 100644 index 181877d..0000000 --- a/Form1.cs +++ /dev/null @@ -1,10 +0,0 @@ -namespace IT_Company -{ - public partial class Form1 : Form - { - public Form1() - { - InitializeComponent(); - } - } -} diff --git a/FormIT.Designer.cs b/FormIT.Designer.cs new file mode 100644 index 0000000..e7b3245 --- /dev/null +++ b/FormIT.Designer.cs @@ -0,0 +1,131 @@ +namespace IT_Company +{ + partial class FormIT + { + /// + /// 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(FormIT)); + menuStrip1 = new MenuStrip(); + справочникиToolStripMenuItem = new ToolStripMenuItem(); + executorToolStripMenuItem = new ToolStripMenuItem(); + organizationToolStripMenuItem = new ToolStripMenuItem(); + serviceToolStripMenuItem = new ToolStripMenuItem(); + операцииToolStripMenuItem = new ToolStripMenuItem(); + chequeToolStripMenuItem = new ToolStripMenuItem(); + contractToolStripMenuItem = new ToolStripMenuItem(); + отчётыToolStripMenuItem = new ToolStripMenuItem(); + menuStrip1.SuspendLayout(); + SuspendLayout(); + // + // menuStrip1 + // + menuStrip1.ImageScalingSize = new Size(20, 20); + menuStrip1.Items.AddRange(new ToolStripItem[] { справочникиToolStripMenuItem, операцииToolStripMenuItem, отчётыToolStripMenuItem }); + menuStrip1.Location = new Point(0, 0); + menuStrip1.Name = "menuStrip1"; + menuStrip1.Size = new Size(800, 28); + menuStrip1.TabIndex = 0; + menuStrip1.Text = "menuStrip1"; + // + // справочникиToolStripMenuItem + // + справочникиToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { executorToolStripMenuItem, organizationToolStripMenuItem, serviceToolStripMenuItem }); + справочникиToolStripMenuItem.Name = "справочникиToolStripMenuItem"; + справочникиToolStripMenuItem.Size = new Size(117, 24); + справочникиToolStripMenuItem.Text = "Справочники"; + // + // executorToolStripMenuItem + // + executorToolStripMenuItem.Name = "executorToolStripMenuItem"; + executorToolStripMenuItem.Size = new Size(224, 26); + executorToolStripMenuItem.Text = "Executor"; + executorToolStripMenuItem.Click += executorToolStripMenuItem_Click; + // + // organizationToolStripMenuItem + // + organizationToolStripMenuItem.Name = "organizationToolStripMenuItem"; + organizationToolStripMenuItem.Size = new Size(224, 26); + organizationToolStripMenuItem.Text = "Organization"; + organizationToolStripMenuItem.Click += organizationToolStripMenuItem_Click; + // + // serviceToolStripMenuItem + // + serviceToolStripMenuItem.Name = "serviceToolStripMenuItem"; + serviceToolStripMenuItem.Size = new Size(224, 26); + serviceToolStripMenuItem.Text = "Service"; + serviceToolStripMenuItem.Click += serviceToolStripMenuItem_Click; + // + // операцииToolStripMenuItem + // + операцииToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { chequeToolStripMenuItem, contractToolStripMenuItem }); + операцииToolStripMenuItem.Name = "операцииToolStripMenuItem"; + операцииToolStripMenuItem.Size = new Size(95, 24); + операцииToolStripMenuItem.Text = "Операции"; + // + // contractToolStripMenuItem + // + contractToolStripMenuItem.Name = "contractToolStripMenuItem"; + contractToolStripMenuItem.Size = new Size(224, 26); + contractToolStripMenuItem.Text = "Contract"; + contractToolStripMenuItem.Click += contractToolStripMenuItem_Click; + // + // отчётыToolStripMenuItem + // + отчётыToolStripMenuItem.Name = "отчётыToolStripMenuItem"; + отчётыToolStripMenuItem.Size = new Size(73, 24); + отчётыToolStripMenuItem.Text = "Отчёты"; + // + // FormIT + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + BackgroundImage = (Image)resources.GetObject("$this.BackgroundImage"); + BackgroundImageLayout = ImageLayout.Stretch; + ClientSize = new Size(800, 450); + Controls.Add(menuStrip1); + MainMenuStrip = menuStrip1; + Name = "FormIT"; + Text = "FormIT"; + menuStrip1.ResumeLayout(false); + menuStrip1.PerformLayout(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private MenuStrip menuStrip1; + private ToolStripMenuItem справочникиToolStripMenuItem; + private ToolStripMenuItem операцииToolStripMenuItem; + private ToolStripMenuItem отчётыToolStripMenuItem; + private ToolStripMenuItem executorToolStripMenuItem; + private ToolStripMenuItem organizationToolStripMenuItem; + private ToolStripMenuItem serviceToolStripMenuItem; + private ToolStripMenuItem chequeToolStripMenuItem; + private ToolStripMenuItem contractToolStripMenuItem; + } +} diff --git a/FormIT.cs b/FormIT.cs new file mode 100644 index 0000000..c25d2ea --- /dev/null +++ b/FormIT.cs @@ -0,0 +1,68 @@ +using Unity; +using IT_Company.Forms; + +namespace IT_Company + +{ + public partial class FormIT : Form + { + private readonly IUnityContainer _container; + public FormIT(IUnityContainer container) + { + InitializeComponent(); + _container = container ?? throw new ArgumentNullException(nameof(container)); + } + + private void executorToolStripMenuItem_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, " ", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void organizationToolStripMenuItem_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, " ", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void serviceToolStripMenuItem_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, " ", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void contractToolStripMenuItem_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, " ", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + } +} diff --git a/FormIT.resx b/FormIT.resx new file mode 100644 index 0000000..78d6b48 --- /dev/null +++ b/FormIT.resx @@ -0,0 +1,3943 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + /9j/4AAQSkZJRgABAQEAAAAAAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwg + JC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIy + MjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAQABAADASIAAhEBAxEB/8QA + HwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIh + MUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVW + V1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXG + x8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQF + BgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAV + YnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOE + hYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq + 8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDwCiiigArV0y9WDCmsqlzUTgpqzInBTVmdLdajGYjg1z08nmSF + qaAzDqaDGQKilSjT2Io0I0thlFFSRpuOcVqzYjpavCzdkzjFVJYmjbBFTGaexMZp6IbmgKW6CkqeNhxV + PQbdhvktjNRkYODVxnG2qrnJqYtvcmMm9xldFpN2qoA38652pYZGRwAcZqatNTjYmtTVSNmdReuJ4yFG + c1zNzA0TnK4FdbpkCyxDPORVbWdPVVLAVw0aypz5DzsPiI06nszlKtWbKM561XkXa5FNBI6HBr0mro9b + c1XZdvNZsmC5x0o3SMMZOKYQRUxjYSVgpyMVYMOoNNoqxnpXhfUvNhRCwyPeuk1CFbi1PAORXlvh6/a1 + uwpPBr1SylFxbj3FfLZhRdKrzI+OzTDuhW51seU67YG2uiwXAJ5rH4xXpPibSvNicquTXnjWsiylCMYN + e3gsQqtNX3R9Hl+KVakn1K9KqM3QZq/HYArz1qxaQKJthArplVSV0dMqsUm0UU0+ZxnGBUj6fsjLZya7 + GCwQ2pPHSsG9lSBmjauWninUlZHHSxjqyaj0GaVBEYssBn1o1KCLyi2ACKyo7ySByYzwe1JcXk1wMMcD + 0Fbeylz81zp9lLn5rl6xlDJt71BqMZVw2OtRWMuybFa72b3y7UGTSk1Tnd7Ezkqc7vYx7O2NxOF7Z5rr + 8rY2GeMgVDYaObNA8i8+tZmuXmT5KN9a55z+sVFGOyOWpJYqoox2Ra0HVG/tVizcMfWui8RW32mxLgZ4 + rz6xmMN0jj1r0yB1vNJGcH5a5sdD2VWNSJx5jD2FaFWJxOjxRecyyAZB71sX8UP2cqMdOa5+8D2eosE4 + ya04reSePc7E5roqq7VS+h2Vldqq3oc1MoSVlHrW1pFyPK8s1nalB5M1P0qQJcc9K6qlp07nXVSqUri6 + tEVm3EdaqQSBeDW1rAWSLK9cVz1VQfNDUeHlzU1cvwOBdhga6yGQS2OAMnFcbDxIprrdJVpISp9K5cat + EzkxySSl2OVv08u6PbmtW3Pm2PXtUOuwCOUnvmk0uQGEqSOBWknz0lJGs3z0VJGb/q7j6GuibbLYYzzi + sC8XbcnFb+noslmcntRiH7qkLFNcsZmBCPLvF9mrspHRtO6j7vrXG3R2XZx2NdPp8D3NlknjHFZ4tJqM + 2RjEmozZzkDeXqakcfNXd3Q8zSifVa4W6XyNSx6NXdwMJdHB/wBmscd9iZzZl/y7mjziYYlYe5qOrF4u + 26kH+0ar16sXdI9mLvFMKKKKZRNbMEnjY9Aa7aPUYfsPTnFcTbDdPGD0zXoVvp9s+mbjjO2vNx8oLl5j + y8xnCPLzHBXTiS7Yjua6ZV/4lBP+zXN3iKl8yr0Brog4Gk46HbWmI+GFi8TrGFjlSMyY969H8J6dEukS + SbRkk815yP8AXD616x4aTGgE+uawzSbjSSXc585qOFBW6s821sf8TOUe9aun2sY0lpCOcVla2c6pN/vV + q29yq6OVx2red/ZRS8jpnzOjBLyMB49ztj1rrdBtQunFjXICUhzx3rudI40kt0+Wox8mqaRnmUnGkl5n + JXkP2jVHTPercWneTIpDcH1rPvJmi1B3XrmnnVpDjjGK6OWbikjqUZuCsaV5EcBA3J9KRtPZbXcTzisw + 6kzShj0FXf7Y80JF2JrN05xSsRKFSKSR3PhaEQ6aCRWD4lk86+Eee9dNpTJHpa4I+7XB6zfgaoT1ANeV + hIyqYiUjwsFGVTFTmblpAy2eF+9iq0Wnzi58xjnnpTNP1yEDL4wK04NYtpHKggE+9aSVWDehvL21Ny03 + L0pY2oRRzjmscwubgK/StqGeEn74OKYBFK7EEZrmhNwvocdOq4Xuhpu/stocLnisSyufPvi7r3rb1QxW + +ndQWIrO8PpFJL8w61pTaVOU7HRRt7KU7G/f3Nqumk5XO30rkNAtlutWaUDgGtfxT5EVttjcbj2FO8H2 + e1DIy89c0U7UsNKS6gmqOFlNdS/4mnFrpewHGRXlkrbnJ9TXceNb3nygfauEPJr0Msp8tLmfU9DJqXLQ + 5n1NrQLfdMZDW1q0qR2rDI6VV0SMJb7uOlZWtXTSXBjDfLQ4uriPQJRdbE+hWsIfOvAfQ5rpblxBak+1 + ZOiw9ZCOtSa1c4TYDzWlX95VUV0Nay9rWUexhTv5krN71HU8Fs0546U6azeHk812ppaHoJpe6VuprsfD + Fkm5ScZPeuP6GtnTNaNm4zwBWGLhOdNqBz4uE503GJ6t8kFqTxwK888SX2XYZ5NaTeJkktioYZxXHajc + m5nJrzMBhJwneZ5uAwcozvMitIxJLk9q1LgCOHnjiqVvC6KGFNu7hm+Q16klzy0PTkueeg21g+0Tjg4z + XZwxLbWG4+lYOiBFwzitHVL5I4NqsMYrjxLlUqKCOHFuVWooI5/VZ98pGeTWYOTVlUa6nJrQXSjs3YxX + cpRppRZ6ClClFRZXt9saVFcyA5p8yGIFaosdxqoq7uVFJvmG0VKIZCM7eKjIwcGtLo1uSpLtHNNkfeeK + ZTkFADaKkI4qOgAFaOn2JmlBYcZqrbReZIP5V2Ok2iKoYjArlxNb2cTkxdf2UDUsYFtbcMcYArn9d1Tl + kVvwrS1XUlt4SimuIupzcSljXFg6DnL2kjz8DhnUl7WZEzF3LHqaWmUV69j21oB60VIkbN0HFOaHApXQ + rohoo6UVQyxaOqTgt616Hol7AI1+YV5pVq2v5rZgVY4HauPF4X28bXOPF4X28T1HU7uIW5Ix0rzvVr3z + ZGVTSXGuTTQ7M1kkljk9ayweC9jrIyweC9jrIACxwOtTfY5du7bUtnGDKC1b7pELfoMYrpq1uR2R1Va3 + I0kcqQQcHrSVZuwolOKr1undXNk7q5PLEFGRUHTircrZFVCc0IpqwlFFFMRNGRipO1VgxHSpRITxikAx + xhqktnCyDPSmlCeTTMFTSeqsJ6qx0kOHj46VSvoAVJqtBqDRrtqwGkusD1rkUJQlc4lTlTnzdDJIIOKO + RV65sJY/mxVNE3PtPFdUZqSujsjNSV0INzdK0LTTWnIzRHbADOK19PnjhHzYrnrVWl7py167UfcKV1pH + kpnFYzoY3x6V1GoahEYiBiuZmkEkhIp4aU5L3gwk6ko++bOlap5IwxrQutQW5jIHeuSU4NdRo9olyoye + ayxFKEP3jMcVRpwftWc/dQurlscVVruNW0hRbkqBxXGTR+XIV9K2w1dVY6HRhcTGtG6HL90Uj9KjDEdK + CS1dJ1CUU4ITTxHSuK41HKOGHUGvTPC2oCa3VS2TivNioxWno2rtp8vJ+WuHHUPb07Lc4Mww31ilZbnr + N5HHJAd2Oleaa/FFb3W5Mde1aN34tDwbVbnHrXLXt8145Ld64svwlWnK8tjzsswNalK8ti4k8YTJYVTk + vNs4ZOcVT5pK9aNJI9uNGKOz0y8kuYgAeMVU1qyGzzO9Z2lal9lO0jNbMtvc6ihPKpXnyg6VXm2R5s6b + oVubZHISLhuKAuRV2/sns3weRVLca9OElJXR60JqSugU7JAfSvRfDKQSwKTgnFecHk1saVrktgNoPFcu + NoSq07R3OLMMPOvStDc9J1dYY7JjlQcV5RqDbrxznPNa2oeI5rlCgJ5rAZizFj1NY5fhZ0E+cwyvB1MP + F873AHBrvvC135tr5RPIFcDW34evXgvAgOAa3x1L2lJnRmFH2tFrsaHii0MU4lH1pNOuk+zfO1a+vWjX + Fhv74rldK2iZkfse9ctC1WhZ9Dkw7VbDWl0DVnWUkoPxrLico4IOK6K/ji8s7QPwrnhE7OQqmu2g1yWP + Qw7ThY31VZbTJ5OK56VdsrCtuwt7m4j8tKJtFeG4US5561nTqRpyabMaVSNObTZjRMwIIBOK27LVxApX + vXQ2miW32bJAPFcrqtvHaXwCYxnnFRGtTxEnCxEMRSxMnC2w68W51Biypx61UjSa0k2sMZrqNNvLNbUe + YVHHesXV7mGS6HlEEe1OlUk5ez5dB0a0nN0+XRGdOMtuY1Zt74wwlQeKrTsCnFWtHs1vJirVvPlULy2O + mpyqF57Iz5X8yUse9dNpGoCK02k9qydYsBZyhRWt4Y0+O8Vt5/CscRKEqPM9jHESpzo872MXUm33fmAd + TXbaKwl0j3xXMeIbFLSfC+tdB4ZbfpZXNc2Malh4yRx5hJTw0ZR2OM1Rdt/KP9o1SrT1tNmpSD3rMr0q + LvTR6tF3pphRRUoxitDUYhKkMDyK14tZu0hMYJ24x1rJON3FTCQbcVnUhGW6uZVacZ7q4m4yT7mPJNdZ + NAiaNuH92uRBw2a1WvbhrHYQduOtY16bly26GGIpSm48vQyl/wBaPrXrnh4Y8OZ9jXkSf61frXr2hjHh + kH/ZNcOb/BH1PNz3+FH1PL9VOdUm/wB+ugEUK6Jn5c7a5zUjnUJv9806S8n+zCPJ212SpucIJHoSpSqQ + gk7WFEalhwOtdtZqI9GP+7Xn0cj71we9d2kjR6GST/DXPj4u0V5nJmcXaKv1OKuE8y6k+tVHXaxFTPLi + Zye5qFm3MTXowTSPVgmkhKFYqwI6igKxGQDSoMuAfWrLN238RTQ2vlHPTFYtzOZ5mkPetz7JB9iyQucV + gmPLHFc9GME24qxz0KdOLcoqw0OwGAeKckzo24Eg+tMwa07HSJLtd3atZyjFXkbTlGKvLYhj1O4jbO8m + rVvrs8T7iSaoXlq1rLsNV6j2VOavYz9jSmr2Okm1v7YFVzxXVaCbby9/AOK87sFWS7RXPGa9MtNPgXTt + ykD5c8GvMx8YU4qCPKzGMKUVBdTnPEjrPqKxxtkZrrtEiFtpO4jB21w0Mfn62UB3ANXd38osdGPY7a5M + WrQhSRwZjpCnRiec+Jbr7RqDDOQDWHnBBqxeTedcu3qarV79GHJTUT6XDw5KaiaUGptDFtBxVJ5DPMWP + VjUVWrGLzrpF680+WMLyQ3GMLyR1el2yx2QOOcVzusHdc4Brpbhja2XHGBXJN5lzcFtpYZ7CuLC3c3UZ + 5+DTlOVRmno6oE+fjNJq8iZCIQfWnoVihyeDisyRvMctnNawjzVOY6IR5qjmVZMCowMmnuCZMCp1tyEy + w6113SOtyS3IEBBzk09fmkFLgLxVyxtTIC5FRKSirsmclFXZPHKiRc8YFR2dr9uuiT07VFfAR/KOtP0u + 7NtICR+NYtPkco7nO4tU3KG7OobRhBbbkwCBXJalI5mKE9DXS3XiBBZlFIyRXISymWYyHqTWODhUu5VD + DAwq3cqhu6ZYAxq3GetaNxKkMRU4BxWTp126qMnApl9cF2Jz0pTpynU1CpSlOp7zKV7LuJ96rW6hpRmm + yPvYmkBKnI4Nd8Y2jY9CMbRsjcEa+XyOtZF2FEpxTheyhNuarsSzZPWopwcXdmdKnKLbbAKWOByakMUk + YyVNX9KtvMl+ZeDXR3GnwrbcgDis6uJUJcpnVxcac1E4osTU9paNdShV6Ul1GscpC1o6LPFDJ855rWpN + qHNE2qzap80Tc0/w020SAHpVuaX7ChVhitvT7+JbTggjFcd4k1JZJWVCPwrxKUqmIq8szwKM62JquNRa + GPqd6biUgHis3FBOTRXvQgoRsj6KEFCNkFORdzAUiruYCtm1slZASKmpUUFqTUqKCuwghCoDiq90VXpV + m4b7OpANZM0pkY1jTTk+YwpJyfN0I2OWJpKKmtovNlCmuluyOvYi2tjODikzXRGzTycYHSsG4QRylRWc + KimZwqKexFmrFtbGdvamwQGVvat22gWFQTilVq8q0IrVeRablVrbyVB6VVmvZQNgNaVyslwCsQzWPcWk + 8Jy6n61nSal8W5nRal8T1IGYs2WOTSUUV1HWKXJ6mm0UUAFFFKpw1AC+W2M0g4NTg5Gahf71AE6MCKa6 + 7uRUStg1YGGqHoyGrO5W6Gt/R54mIVutYrxkcgUQytC4detTUh7SNiKsPawsdrdQxvCTgdK5O9QRS5XG + c1ZfWGaLaOuKzpHeZs9a58PRnD4jmwtCdP4mTLeYjwetRtcsTxxULIy9QRVqytRM4zXQ1GKudbUIrmIM + yynua0bfRZJk3GtZNMRUBwK1bV4oYdrEVxVcW0vcPOr46y/do4e6tXtZNrDitDRL7yJgGbAp+uzQySEJ + jNYgJHI4NdUV7al73U7Ir29H31ud1earG0BUEHIrkLxDLKWUcUlu7O3zMTVsgdeMVnSoqg9DKhh44d2R + lbeeacowaknwJDioc117nduWlA21GXANR+YccUwnJqeUnlJ2UldwqGrERDLg1E67TQn0BPWxPFbBly3e + o5Y/LbHapIrkKmDUbOZZAB+FLW+olzX1IzTa6bS/C8l2odzhTTdZ8PmxjDIKxWLpc/JfU51jKLqezT1O + fifZKrY6Gu/03UIDZruIGBXnwrc0BFmm2Oxx6VGNpRnC76GePoxqU7y6FnXpI7gny1zXNbSH2ng16Rda + TEbUkAdOtcLqUQhuMr681nga8ZR5ImWX4iE48kehVMHHXmoOlWTOpHvVcnJzXoI9QkiiaU/KKWaFosZq + 1pkgWXBFXdTgUx7l9KylUtNIxlV5ZqLMmCEzPtrRgi+wzxy54B5rOt2dJhs61ry2lxLDuYgjrilVfR7C + rO2jejO0+0R3emYAzle1cHPEYdQZR8vNd54aEDWIViMgc5rmvFloIbvzI8Yz1FeTg5qFaVI8TA1FCvKi + luQrbptDSPnPvVdngjc4xiqdu0904jUk0/UNPmtFV26GvR5EpWbPV9mlLllI6XwzOpu8bMqe9aHiyBo4 + VnRelcx4f1ARXSqTgV6Bq8S3uiMw5+XIrycUnSxMZPY8PGJ0MZGT2Z5q2v3QTYjEDp1rLmnkuJC8jZNP + eE/aTH05ontjCobOa92FOEdYo+kp06cdYoh3NjGTj60AkEUlJWhqaf2MPBu74zRpEzW17j3qKO+KRbMd + qitpP9LVj3NYyi3FpmEoNxkpGv4gdpSrkcVn6fqlxp5JiPWt7V40k0hXGM4rlBWWG5Z0uVowwfLUo8rW + xavdQnv5d0prrfBz5t3Q9a4kV1ngyXE7p61GOglQaXQzzKmvqrUehmeJo9mptxWFXT+L4yuoA+ormK2w + kr0Ys3wUuahF+QUtJS10HWJVyGIPHk1T71ZhmCJipltoTO9tCI8Nj3roHjUaNuwM4rn+rZ966Z1/4kQ+ + lc+IduX1OXEu3L6nOQ/65frXsOkpt8LZ/wBg149Gdsqk9Aa9DtvFVvD4f+zcb9uOK48zpTqKKiupwZxR + nVjFQV9Tg775r+X/AHzU12nl2qcdaryP514W9WzV/VV220QrvvblielflcImZBzOg967i8Ij0Mf7tcto + 1qlzcgN1zXT66hg0sIPSuPFyUqsYnDjpKdaEPM4R+XP1pAMkCrAtpSpcISKZGuZ1B9a9HmR6qasb1pZx + mzLsozisCcYmbHrXUqoi0089q5dzl2PvXPQk5Ns5cNNylJseLmYps3HbV2x0m5vT+6U4rPVSzAV3fha9 + hs7dvMXnHXFTiqrpQvBaixleVGnzQWpyF/p8tkdsi4NXNM1lLOIpItT+KtTivbs+UBiua61VOLrUl7RD + pRdeivaouald/bLkyDpU8Gnh7YyHrjNZqLucD1NbUztBYYBxkVpL3UoxNZe4lGJkcxy/KeQetaUWvXsU + RiEh2kY61BY6bPqDHyxReaZcWJHmrjNEnSk+WWrCfspy5JWbOh8JQtc3xlcZ5zmtnxpfeTaLCrcmn+Db + MRWZmYdRXN+Mbzz9RKA8LXkRSrY3yR4SX1jMPKJzB5OaSlpK90+kCuj8OWfmyGUiudUFiAOpNdzo0Ytb + AFhjjNceNm407LqcGYVXClZbspa9MUTyh3rW8L6ZbS24My4OO9Y8TxX+uKkh+UGu/itIba3zHjgdRXl4 + qq6VJU1uzyMVWdGjGl1epyPifT7eBD5ZA45xXIRWs0oJUcV0OuTvd3phQ55qazt/JhCsnJrso1JUqK5t + WzuoVZUaK5nds561sJTIWKEgd6tXQSOHGMGu+stMgSz3OoBIya5bWdPSa4Pl/dHpWdPGqrUs+hnSzCNe + rZ6WORPLVtWs8ccH0FMTS3mZiFJVaq3du1up6gV3ylGp7tz0ZShV91Mr3Ennz/jVhUCx5x0qtAm5s1Lc + OUXArR9Io1a2iirI256WGMyPgCo+p9607OHaAxFVOXLEqcuSJMiCOPng1n3UmTirt3NhcA1ksdzEms6U + b+8zKjFv3mJRRSGug6QqzaW7zygKuQKgRC7ADkmup0O1SDBmGM1hXq+zjcwxFb2cL9SxbQxW8Idl2sPa + qOqaqGjKKa1dUuIoomxiuLnk82UketceGp+0fPI4cLT9rLnkiN3Ltk9aQEg5BwalFtKybgKj2kNg16Ka + 6HqK2yL0Wp3UcZVWOKpSytK5ZzzU4I25qu5BbilGEU7pCjCMXdIbRRU8MTMwOOKpuw27CRxsCDitKK7E + ceCaaUURZxWfK/JArFpVNzFpVdGTXVyZD1zVPNFJWsYqKsjWMVFWQtPilaJwy9aZSVRRqHVT5WMc1RVX + uJSfWmRxmRsCti1t1hXLVjJxprQxnKNNabjraAQIGOKgub7DbVNJeXgAKofwrMJLHJ61EKfN70jOnT5v + ekdroTQPGC2M07XVthAT8ucVx8F3Pbcxtj2pZ76e44dq5/qcva899Dm+oy9t7RS0K743HHSkAJ6Ckqym + NtehsekVqKKnt4vNkxQ3ZXBuyuQYoFbT6ePKyKyZYzG5WohUUtiIVIz2GhiOM02ipYYvMbnpWhoRVLE+ + 1uasS2qquR1qn0pbg0XzhkqpIm1uKdFIfumrJh3LWd+V6mV+V6lONd8gX1NdhpejRNEHYDnpXIEGGQH0 + NdTpOsgoqMQMVz4zncPcOXH+1dO9MfrWipHFuQYrnbWc20uCehrqNW1iB7cruBbFcZK++QsO9Tg1OVO1 + QnAqpKny1TpZdYQ2+OjYrFm1KZyQrYFUsk0ldEMPCB008NThshzuztljk02iitzoHKxQgg81KbpyuOKb + DE88gRRk1qtoE62xlwemaynUhF+8ZzqQg1zMxSSTk09YpHGVUkUoiKzBGHeux07TI5LXdgcior11SV2Z + YjExoR5mcYBtbDDBpzgba1taslhbcoANZIIK4rSnNTjzI1pVFUipIYrFTxSs5brTSMVLBD5rYqy/MiqS + MMGDAZwaknt/KPB4q5ZxBgB1qZSSVyZTSjc67QdYijtQkmOB0pNZ1JLuFkjTJrmwqQzrg4Heult47drb + JIyRXjVaMKdT2ljwq1GnSqe1Svc53TdAkvpCzHjPSr1zp39jsskfGOtWbO9ayvGQLlGPFXL61uNRiLNw + uKudeftFzv3TWpiKntFzv3WSWdy97bfM2BiuY1q02yttyfStjS43SY25OMVpappSJbiQ8ms4VI0aunUy + hVjh61lszzgKQ2CMUOoA4q5qEax3JC8ZqPyF25J5xXtRldJnvRlzJMghcxyAjiuiij+1W34VzeMGt/Rr + ngox7VhiU+XmRz4pPl5l0MmeJra5z71u2t75kAUJnjFZusRt5pYD5abpt4Im2N370Ne0pphJKrTUjb0h + pm1DyvMKK3atzX9GVtPLg5IFcy9y0UqzRdRXSJBqeq2G7kJtrzcQnGpGonZHk4pSjUjVTSRxmlyfZ78A + +vNdPq0a3unFlX7orlr61k0++xJ1z1rrtKu45dPZMbjtwK6MS/hqxOrGX92tDU5DTAFv1D+uK9U0/E+l + NGcHC44rym9V7fUGOCp3ZFegeEJWKMkj5JGRzWOZw56aqI5s5p89JVUcLrUJtNUfHZqpzSyTxj5CB611 + Hjiy8m9EoHDVhRyxfZeSBgYxXfhanPRjI9PB1faUIzMuig8txU5tJBHuPSuq513sRKC3A60DKOD3FSW5 + AkwaLjHmcUr9AvrY0Jb55bMR9gKyx1rSs7bz7ZiOwrPKkMR6VlS5U2kY0eVNxiLxW/4Sk26kFz1rnhWx + 4cfy9WjOcVOKV6MkRjI81CS8jZ8bQ7Zo29RXGEV6H43h3WcMgrz08GsMulegjlymfNhkNooorvPUClpK + X8KAFXrXVuD/AGD+Fcov3hXXMP8Ain/wrjxW8fU4MY7OHqcn3rsNK0a3n0Vrh/vAGuP716BpakeFHIPV + TUY6cowjyvqZ5nUlCEeV2u0cSqqL7aOm6r+tjEMIqhajdqC5/vVq+IQAIQPStZP95FG03++gjO0kt9sT + acc11Ouy7tPUE84rm9FjLXq4GTW1r0MyRLuQgVz17OvE5sSlLExJ9NjgbRJGdRuA71y0UZkv8KO9dbDD + 5OgFh1K1zdjxelsZ57UUJ/Gww03eo0at/mHTse1cqetdHq9zutwoBFYG0kjArfCq0Ls6cGmoNvqX7Oxn + ni3pGWFb9nK1rp7CSFs464qbQdTtrSxKSoNx/WtDUNVtP7IZRFtc9MiuGvVnOfI46XPNr16k6nI4aXPP + b5/MnZunNVhxUs7bpCfeou1evFWSPdhokT2q7p1PpWhqMqmJUFV9NhMjswHQU27Um4C1D1mZuzn6HV+F + A1vCX8kvxUHiG+Go30cCx7SDg+9bHh+9t7LT/wDSF28VjRsmq+Iw8S5QHtXkxb9tOo1seLGTeInUktF1 + Ows0Gn6FuPGEzXlmpTm4vpHznLV6R4ou/smjiIHBYYry5zliavKoN81V9R5LTb56z6sjooor2D3y5psB + nvEUDoa6rVJha2AQcEjFZ3hi13yGYjpTPEd0HnEQ6CvOq/va6j2PKrfvsSodEL4egjuLlpJWwQeDmuqv + Ll7GxYLJkEdzXn0E8kBBibBNW7nVLiaIROeKdfCupNPoViMHKrUUr6Fu0WeS7M5G4E10dtIs9wgMeNvW + sjSzItvv2ZGOK3tMYcvInXviuTFS3OPGT3Ni7uoo7XapAOK5a435ITlmq5qEgnn2RueOtVbZJRdg43KK + 56FNU43ObD0lTjzGrp8SQ22yWPk9azr7S4r+5CIAQPStS4v4li2ldpPFOsI1UeafrWaqTg3PqYe0nTvU + 6s53UPDotY9yDBxXK3UEquSVOBXoeoX4lZkz7ViXcUM6iNMFzXfhcTUS989PB4qqkvaHJRQO/wA4HArU + jISDJNdKvhpYNP8AMbg4zXK3zrGWRT0rphXjXdonXDEwxLah0KFzJvcjPFQUp5Oe9JXelZWPQSsrBSUt + SQxs7gAZ9qG7A3Y0tGgV5Q0i8etddKLeGz3AjOKzNM8mOICQBcDvVLWrwZ2xNx9a8qopV6tjyKqlXrWW + hmX92ZZWUMcZpdO083cgz0qvbW0l3NtUZ9a6CO3k01A/auupNU48kdzsqzVOPJF6hd2RsoexFYEq75Dg + YrUvtUNz8uapmMFQQOamjzRV57k4fnirz3GjTXaHeD2rPZCjEHqK2V1EQwlCOcVlO3my56Zrem5a8x0U + 5TbfMRqhboK0LZgg55q7bWkXkbjjpWdckROdvSp51N8qJ9oqjcUPuLkAECs48mnMxY5NNraMeVG0YqKJ + xCMD1qJ12NipUmAXBqJ23tmmUNpUQu2BQqljgVp2kATBYVM58qInPlRJa2wRctTbu6EYKKaLm5EYKqRW + W7FyWbrWMIOT5pGFOm5vmkIzFmyetApKcEJGa6DqJEiaQccCmPEyNg1bt5kVMN1qG4kDNxU3dybu5Wpw + YgcGko7VZRbu7XyT8vSoYJTE+asTzG4bA70xrN1XdWSfu2kZJ+7aRqw3glTaOtVb2yO3eKoQytC9bME3 + 2pdprCUXTfNHY55QdJ80djAIIODT4pTGeOlaN/YbPmUVlkEHGK6YTU1dHVTqKauixJc7lwBVaiirLHKG + 6gVoWswPytVdCNgqIvtbiolHmRM4cyLt1CCMiqG5kPBIrRt3Ey4NMurMhd6is4S5fdkYwnyvlkUCxY5J + J+tJQRg0VudAtJShTUoUCkAyOMySBBxmtr+wHNt5i5zjNZAfy5Aw6g111jrMJsgrAZxiuXEzqRScDjxc + 6sEnTRzVjJ9jvR5g716NaSW95Y4G0ZFef6jA0khmVcA1f8Pak0Mojc8e5rnxdL20Odbo5cdQ9vTVSO6I + 9c08wXJdFwM0WOum1hKMTxXW6lYpeWe8AE4zXnt7bGCcr05ow044iHJPoGEqQxNPkqbom1DUTdufes8d + akEQHWmOAG4r0IxUVZHqQgoKyJWQFMimwyGJ806Fs/KaZMm1uKfkPyZelUzw7vaqsVxJDwDT7eY7SlRz + Qsp3dqlLoyEujJBM7ybmOSK3tNuPMwuckdq5pDg1oafdfZ7lXPSsq9PmjoY4inzR0OufSpnCyqAuOa1d + Pnj8spOwGOKyX8QL9l2RjOR0Fc5Jqc7XBCkjJ4FeVHD1KytLQ8iOFq4hWnpY19Xuksb4PCQee1Qz+IZL + iDZzzWdc6feyRee+SOtZyMWkVScDOK7qeHpuKvq0ehSw1LlV9WhLvdJKSeT7VEXkC45xXoGlaBZSWHnO + w3EVyeqRRxXjRxDIzV0cVGcnBLYuhjIVJunFbGPjNWbGbypxk8US2c0ahyhxVcZUg10u0kdek42Oru4E + uLHcOTiuVH7uX6Gus0llurMofSuf1S2+z3ZA7muXDytJ02cmGnaTpsvRMJbcEYzXZaP4ptrbTBFLjeox + XmqzSIMK3FJ5jE5JNFfBxrK0icRgIV1aZr+Ir9NQvmkQAc9q1PCc6LJtfBrlDWlolyLe9XJ4Jp1qKVDk + j0Kr4dLDunHobHjKOFrlJYVwD14pPCt9INQiDMdo4rX12JL3Ry0UeWUdQK5nQLxbO6O9cntXLTftMK49 + UcdH97g3C2q0O18cWHnaaJlHKivMEQs2K9lkxq+gO23qp4ryKaM2t46Hs2KnKqnuSpvdGeSVX7OVJ7xZ + WkQxsK0Tcb7TAXnFUZ3DnIq7p6+ZCy46V6stVdntS2uzPj/1gz61pXtpFFAsi9SKzpV2TEehrWmHnaWr + Z6Cpm7NMmbaaY/QnBZ4z3BrOuoil26D1q3obBb1cniresQJFqYPQNWKfLWa7o51LkxDXdGN5LDrVzTA0 + OoQseATS3AHBXpTVuN08XGMGtG3KDRtJucGjvPFMfnaAj9wBXmbDmvV71PtPhXP+xXlcow7D3rgyuXuS + j2Z5eSytTlDsyKjFFLivVPbG4q5G8YhwRzVXGakRcjBpSJkMGN+fet59Rj/sryB1xWEVwaOaidNTtfoR + UpRqWv0DHNd/p11AnhZoy6h9p4zXBZqQTyKmwOQvpWWIo+2SXYwxeG+sRSvazuT2IzqKn/aq74gOZkA7 + Cqmkruv0qzrx/wBLUegpS/jL0FL/AHiK8ix4Wkih1VHmxt966TxdqNrcxpFBgk8HFczoVo1zNtXripb+ + 2e3v442ByT3rlqwjLEczeqOOtThPF8zeqNa+zDoKgcZFZnhy6tbW6LXSgqau69LJFpsSFcA1iWCebcRL + tzlhSowToyv1DD0lLDy5utzudds9On0Y3aIFyMrxXn0MO+YhBnFd34olWHRIYAcEgcVznhyJftLtIuRi + owk3Ci5Mxy+cqeHlNu+uhWt2W2uUMi/Kp5FafiDV7O6sVigQbscmqmrmNriQou0dKwpsgV0QpxqyU30O + yFGNaUaj3RUIBcZ6ZrRvYrVLJDGRvxVa1RZLtVfpWhrUNvEqCIjOO1dcpWkonbOdpqIzTHSGEs3WoE3X + WojyxuIOQBVdVk8vjOK3fCQhTUvMnXKj2qKr5IymZ1n7KMqm7LF5d+VZGKSPa2Mc1e8DwRmZ5HHPY1D4 + wv7O5ljitQMjg4re8MWa2uk+awwcZzXmYipy4a9rOR5GLrcuDvazkYfjm8D3Cwq3CiuKNauv3X2rU5Wz + wCayjXo4On7OjGJ6mApeyw8YjTjFKo3FVHU0Ve0m1N1fxpjvXROSjFtnXOajFyfQ6vToV0/SDIwwSua4 + 69mM9yzZ711niO4FtaJbKcHFcYQc+tcWDje9R9Tz8vi5c1Z9RMkGpoA0syg881EBzzXQaFaI0bSsAR71 + 11ZqEbnbWqckbmjHeQwwRRDAPcV00clt9hGCNxFeeXlwq3uVHyg1dh1ByAwY7R2rzK+Fc0mjycTgnUSa + 0OnezVYmlzhj0otdNureMz7s55waxhrbTtHGBwp5ro/+EggFjt4DYxXJUhWgkrXucVaFemkrXuZclyt1 + eCN0xtPNWb+4WCARxNyajtRHKjznGTzVa3tDf3jMCdo6VXLG+uyNOSF7y0USCfzIrYu65J71T0iCS4vD + LngGtDVpZ4cWqhWB4qxZCOwsGkYbWI71u52p6dTaVW1HRayE1vW2S1+zegxXAzyGSUk+taGq3jTzHB61 + l134SgqUPU9HA4ZUYbasKSlorrO4ApPNdP4c09JzvYDPvVHRLAXU4DdK6qaxGn2xkhIHFedjMQv4a3PL + xuJX8KO7M/XDDbxlUIDY7VyTM0j8kk5q1f3ktzKd/QGrOjWiz3IMo+X1rWlH2NO8tzajD2FK8iXSZUtp + AZFAq1quofaNsceDmn63bwwACLBPtWEBJE4dl6VEYRqP2hnCEarVXqWX02aNBJjPeoS7IuCDWtBqqSos + TAY96p6q8IAEeMn0q4yk3aSNYzm5cs0Zch3H3rRsdHeZd7Cq0NhPKA6rx1rbTUVtbMowwwFOtUkly0wr + 1JJctPczb0PY/KGyPSsmRzIxJqa6unuZCzHIqrW9KFlrudFKDjH3twooorU1CpIoXmcIgJJpqoXYADk1 + 13h7SxFIsswHPrWFesqULs58RXVGDkyhD4euEiEm3tmqd1IbfKEYavRdSvrWzsDyvTivMNQuvtVyzgYG + eK4sHWqYhtzWhwYHEVMS25rQrO5c5NNpVUscDrTnidOor0z1yOp1I2+9Q1IOlDExh605VywBoI56U3OD + QHQvtAnl9BVBhgkVIJpG+Xd1q8mnB4t2eaz5lD4jNyUPiZnxPsYGtQ3MZt8HrisilGTxTlBSKnBS3HSE + M5Iqa1uTA454qxb6f5q7mNVrm38luOlK8Ze6LmjL3TaSUXa7eKzb2yMRJAqC1uWhcYNdJbxJcw5bBJFc + 0m6Dv0OSbeHd+hyRGDQOtaWpWXkyEr0rNNdcJqSujshNTXMhScdDTaKswwBsE1ZZFFKY3BFayS+dHgVQ + ltwvQdaS1uDC+D0rKpHmV0ZVafMrrcdc2rR5bFQRgZ5racieLCjJNZE8LwvkjFTTnzaPcmjU5tHuPbG3 + mq5c4xmlXdKwXNSSW5Rcg5rU3IPrVm1m8uUZ6VWpRTaurCkrqzO1jhhurHIxnFc1NG9lc7gMYNWdL1Dy + GCseKtahbvfDfEufpXnwTpTcZbM82nGVGo4y+Fly08Qk2/ldTjFZuoWk1xmbYQKp2Q+y3oWZcc16DHBb + 3Wm5QD7tZVpRw0lKC3MMROGDmpRW55e+5Tg5pla2r2Jt5m44zxWWo55r0oTU48yPXpzU4qSEBKnNWwgl + j96gcDbx1pI3YfKp61T1KeogJjf6VO8/mR4A5pklu6ruNS2oXbz1paMTs9SqOtWUAJA96jnCiX5aVG4x + 3oewS1R6F4d02yktNzkEkdzWB4htoLS+zCQcHtWZaarc2q7EYgVHJcPdSl5Tk159PDVI1nNvQ8ulhasK + 7qSlobP/AAkK/wBnmBkGcYzXOM26QsOMmnsm5wq85rTTw9ePbecF+XGa6F7Oj1tc64qlQ62uavh+Rp1E + MkpCntmpNbsrW0kWRCCc81z9hI8NyEYlTnkV280OnS6QGZlMmOhOa4K6dKqpdGebiE6NZSWz7FWSG3vt + FLIq7gtcFNH5crKexrsvD0qzTSWrthecA1i+JNPFjfkKcg81thZclR02bYOXsq0qTe+pT0y7ljkEUfVu + BVrWdNuIoxcyNuBrHjkaGVZF6ir95rU15bCFugrslCSmpRO+UJc6lH5maMUUgpa3NxV609H2SKw7GoxW + hHFAbMsSN1TJkydtz0nQZ7e90IowXcUwfevPiq2OuEMPkD1veCLxftH2eTkdhmmeNbBLTVUljA2vzxXj + 0F7LESpPqeDhoqhi50XtI7Tw5qMV3A9vGOAK858W2ZtNZkGMBjmuv8K6paWnl5HzvxjFVPiLZbniu0XA + YckVhhn7LGcvRnNg39XxzjaykcPb6dNcxGROgos7g2rujD2q1Y6hJa2rxiPcD39KzHYvKWPUmvcTbbT2 + PpY8zbT2FuTvlLgda1bBTNp8iE9KqTWkqW6SsPlNX9AjE07RM20EVFVrkuuhlXkvZ3XQzrQmK8HOMNWx + rse5IZh1IqndWLRai0UYLNnjFXQJPtEMV2CqjswrKck5KaMajTnGomZkuRCDiqqfeB963dbECbVhIJI7 + VnCynWDzjG23rnFXConG70ua06qcLvS56Rpqm58KtnsleW3S7LmQejGuw0zxQbXSXtfKLMRjiuTuCZZn + kIwSc4rjwNKdOpPm2Z5+XYepRq1HLZsqxjMgHTNdVd+G4IfDov1mJfGSK5dPviutkspn8Km4MzFB/Dni + unEylGULO2p1YycoyhyytqchtzW7p/hfUNQsmuoY/wB2BnNY6rk16T4cv72Hw5JDDaGRcH5hU42vOlBO + AswxFSjTTp736nm8kJilaNxypwajKc8Cr1zFI95JuXDbiSKhKFSRXRGWiOqM7pFbaaNpNWhCW5xSFNpx + T5yucl0xhDdh36VLq0qXF1uQ8YrY8Mx2DeabzbnHG6se/ELalJ5OPKzxisFJSqvTY5oyUq7dtjf8EIDq + JJHQVd1yNZvE0SLgAUeCYVM8jjqBUU6G58VOu4ArXmzd8TJ9kePUd8ZOS6Ii8XsNsEIxwKp+HbcS6nAp + XODmk8R7hqQRm3YFbXgy3jlvXkbGVFbN+zwp0X9lgvkO8bNEZYolIyByKZ4Yt0ELO4GDWb4vcSau6o2Q + tXdCjdLElicY4rKUbYZLuYyg44KKvuN8RRQDAiALE9q5O9jaNfukV0UpU3bNISVHrWVqV1BISqgcd66s + LeKUTswfNC0NzFiUl8jORT33yzqrEk5rU0y2SSGSRgOKoQYOoKSPl3V3c12/I9HnTk/I1r2OO109fkG5 + lrofBEWnizkkuWQPg/erm9dnR3hjUcDqK6VLjS18NgBQspXGMYNefik3SUddWeZi4ydFR195nNaksN34 + hZLcDYX4xXdXsg03w2QODsxXHeGrH7XrAOMhTmt7xxd+Tax2qnrya58SuetToLocmNjz16WGWtjz2ZzJ + KzHqTmozU4UNzUUgwa9tPofRRtsR+9dd4Ss+XumHAHeuUjUuQo6k13sarpXhnPR3FcmOm+RQW7ODMqjV + NU47ydjmNcu/tV+5ByqnArR0HTLd9Kur26wFVTiufVHnuAoBZnbgV1PiGaLT9CtbCIFZHGZB6UqicYxp + R6k4hOMYYenu/wAluck4VpGKjAzwK0LO5e1hYc4IqhbRmWdV/OrWoYhwi8E9a6J2bUTumk7QKbsZZvcm + r8jrBbAd6Zp9r5pLsOB3qO5jaaUhT8opuzfL2HJKTt2IYpSrFsnNPe9kJwGqFlKgg9ahq+VMvli9TWj1 + OZYtitj8a0tO19rGMjua5hWxVq2ga4yAelY1KEGtTnq4enJWlsdTo+/Vb5p5JOByAah8Q6ptLW4UDbxm + sOC7uNOkIVsVVu7l7qUu5yTWMcN+95nt0OeODvWU38K2IGJYkmmU7BpK7z0goooAzQMuWWoS2b5U1uf2 + 811EImP1rl8U4K4wwBx61hUoQm7tanPVw9Obu1qdBNZRSpuXGTUkMosbQqV57EVk2uoNGw3nitdbiG5j + AOBmuapGUdJao5KkJx0lqjHa9d7jc5JXNaxktri07B8VUutL/ij61nFZYHwcjFbWhUS5Wb8sKiXK7WLM + lqUG4VX2u7gtkgVL9tZlCGuksLazNgXdl3Y5zSqVXSV5IVSq6MbyVyK0u4IbI5wWA6Vzt/defKcDFOvp + QkzCI/LVAkk5NVRopPn7lUKCi+fuBpKKK6jrClAOcY5pBW7oulNcyh5F+Ws6lRU48zM6tSNOPNIn0TST + IwllXitXVdQjsIfLiI3AVJqN5DpdsY0I3Y4ri7u5e6lLsc159OEsTPnlseZSpyxVT2k9iS71K4u/ldzt + qliiivSjFRVkerGEYq0UTQOFfmp55F8sjqTVKnhhimUMpQSKVUaRsKMmnPBJH95cUXQrrYfEjvwq5olt + 3j5NaVhJCsWWxml8hruX5B8lYOq1J32MHWak09kZsFu0jZFaBaWGPHarBtTakHtVS+u8jYowcVHP7R6b + Ec/tXpsU54Av3algsGddxq2ipIBk5p8t15ERRRzTdST91bjdWT91bkAuTbKUPNUJ52mbnpTZZDI2TTFO + GBNbRglr1NoQS16jvKkC7tpxV2z1GSD5c1diaCW2xwCBWXNbujFgvy1F1O8ZIjmVS8ZI3Vh+2pluc1jX + 9k1vIeOKs6fqJhO1qtXZ+2jCj8awjzU52exzRc6VSz2OeqxDP5YwRkUlxbvA2COKhrtTTV0d6aeqLM0z + OMqMCq1Slxt96ioKZqaZdBXCv0rSv7aOaDeuK5pSVORwa2NNm887JGrlrU2nzo4a9Lll7SLMohoZeOoq + Vp2lXaF5rX1HTQU3xiseA+XNtcYrWFVTjdHRSrKpG6IWUqcEYNJWlc24kTcgrNIwcHrWkZXNE7iq20iu + y0G9g8vZIR071ylrZyXbEJxipVWXT7kBzxWGIpKrHlOfE0VWhY1tfSIzmSAcVY0DV2VxDIeOlaFlbQal + acY3Yrmry2Om3mVOMGuSHLVg6Mt0cUFCtB0Jbo67W9KF1aeai5OM8VwbwNHNsbjmvQND1qG5tfJlwTjH + NYOv6c5mM0UZC1nhKsqcnSmY4CtOlN0KnyI9M0mGdCzYPFZWpWq2d1hCMZ7Ukd/cWqlFNVJpJJ2LuSTX + fThNTbb0PSp06iqOTehaFyHgKkc1RJIY44p8TBX56VfewVofNB7ZrW6iza6gyjHBLKCyrkVb0/y1mIlA + yPWltb1beJo2XJ9apu5eQuOM0O8roHeV0W7ySNpsRjFTjT3a38xOeKzO+Sa3tHv0jieKQA5Hes6nNGPu + mVXmhFcpUtkUnDcMK7rR9ahOmm0kQPJjA4rgLretyWAIUmtbR51sb+OVyCh65rlxVFVIXOTGUFVp3ZV1 + e0mt75pGjKKx4ra0Ge1Qf6SQR71qeJVTVrJXs4S2ByQK4yzPl3Sxy5GDgg1FOXt6Nno0RSl9YoWejRra + zcRw3fnWJxj0FZF2moXkf2iZWZB3rf1j7Ctivkld2O1VYfEMSaQ9q8K7iMA1dJtRTjG5VKUlBOEbtaHK + mm1Kw3MSB3puCOa9C56iY3vS0FSeecUYpgJmnD61Na20lzII4k3Oegq82j3EUcjSpsdOxrOVSKdmzOVS + EXZsTSblrS+jZWwM816B4h0yO98PpeRqSyrk15ohIcHoQa9V8OSS6t4fe3M6/KuMGvLzBOEo1Y9Dxc25 + qUoV49GU/CUNpLpm9wodO561seJ4Y9R8OO0eG2jIIrjtJgSw1a4tr2YogPAzjNd/o8lneabPa23zooIy + a8zFRcKqqp31ueTjk6VZV4tvVPyPG9Pi867+zyNsUnnNM1aySxu/LjfeKtaxZmz1eWI5XD1Xvo7ZY0Mc + m+TvzX0dOXNaS2Z9XSlz8s09Gi+9wk+ghMfOvek8M6f/AGhqiQ+YUz3FU7K+SG1khdM7ulTaNP5GpxS5 + KgOMkVFWMlTkomdaMo0pqO/Q6+fSYfDniS2a5fzIZeCSc4NReOHtbmaB7JQFUckVp+NUtprK1uovmkwM + kGuXktbu4td4VigGa8rDvn5asnqtDxsG/aqGInLVaEBsAlotwTuIwcetdlNcR3nhYfZ9OfheXI6VDpia + ZJ4Ul87b5209fWr+jags/hd4SgJClazxFVvVrZmGMrylrb4ZHP8Agm2tZ7u4juEUnHGa5jW4Vh1e5jQY + UOQBWtoySDWHVJDG2TWdrkRj1J1LFiTyTXfRdsQ3fdHqUNMW5N7paGKIzvrsrWd5PCU8JbgdsVyqoQ2a + 7DQ54f8AhGbyFwN5HBrXGP3U+zNsfL3E7bNHJRx16n4PuRF4dkUwM+AegrzJD2969I8EzTf2JOscW/Ge + 9cuZv90n5nFnbvh0/NHCX7f8TKaQIRljwapMm5+nJrYnhe41WRCoDtJjH41qal4ZuNIktZpMMHYfLWir + xgop7tG0cTCmoxe7RzaZSRA0RODyvrV7VjZyPH5FtJEwX5t64zW9d2UyaxaNHbIHPRD3p/iW1uDdx/aL + VIRt42nOax+spyi/1MPrcZVIPuu5w5X04phTBrcfSmYbqb/ZR9OBXUsRE7Viodxmi622kswxkNVeXUpH + 1F7uM4LGlm047sCmCwZOucChKlzOXViSoczn1ZFLcyXd15khya7XwXb2rxzPKxWQDg1xKRgSkelei+E7 + j7Joc0j2TuuD86jNYY52pWicuZvlocsfI5LV4YpNXcRvvDNgE+tdTB4d1CKxXYOCua5dpY5tdjkYbYy+ + SK9U/tm3isl8uVcqnQ/SuLFVJwjCKODH16tKNOEex5ZewNBK8Mwww61zNwuZGx611t0lzrFxd3SfcViM + iuVmDCQ+xr1MK9Ndz2cHJ2136jEnliQopwDSAHAYDkUHIOamEmISoXmuu9jubtsTaVE19q0KyYIzzmu1 + 8XR2NrpcSRKolI7VwMUksLiRCVYdxUk9/c3ZAmlLBema56tFzqKV9EctfDyq1ozT0R2XgWzO2S5I6d6w + fF199r1ZlB4Q4rqtB1KwsvDjhZB5u08Z7151ez/aLuSQ85bNcmFg54qdSS2ODBwlUxtSrJbaIZjA4qu/ + 3qsBhjrUWCSTXrI92OhoaHZm81OKPGQDzW94vuQnlWaHAUcirHguxCRy30i8Kp5Nc5rN19s1GaU9N3Fe + ff2uK8onlc3t8bbpD8zR8GWQutdSWXPlQjcTVPxVqS6lrk0iY8tDsX8K6nS7YaF4Gn1JiPPuOFFcDFG1 + xcBcZZmrak+erKo9loVhpKvialfpH3V+pu6DpqTW0ly/G0E1iXjNPeFV55wK6PU3Gl6VHbp8ruORWNpE + StO0svKqM5p0ZNuVR7dDahKUnKs9uhC08tpF5eME1Db3BUkMM5p2o3Iubpiowo4AquhCnnrXTFaXO2Pw + 3Y6dt8nAq/p/2SOFzcjDY4BFVbSSOO7V5V3IDzWjrV9ZXEaLbIAccms5ttqFvmY1ZNyUEnZ9TFlKtKxQ + YXPFS2101uxIqALmgjFb2VrHRZWsySaYzSFjUtjbi4mw2MCqoBJAHerLq1qoIO1jS0WgaLQS9VIrlkj6 + CrsVrB/Zxlk4bHFVbG0e9ugOSOrGrGqSorC3ib5V61EpXkoomUry5UZqoXkCr1J4rQvdNFnbo5b5m7U6 + z0+TyPtR4C8iq9zcy3cihmzjgCnzXdl0DmvLR7EEUEkrYRC30rrtPXTv7JZJwolA6HrW14O0CJbUz3Kq + cisDxatst4Us+TnnbXnPFRr1vYx6dTypYyOIruhG+nU5a4CCdxH93PFNSR0YFTihlIOCCD702vUtpY9d + LSzNiz1XacSc1pvHa3UJYbdxrlOlTR3EsWCrcelc88Pd3joc1TDJu8XY0JNJcZcfdqk00sWYw5A9Kvf2 + 0xtjGQM4rJkcuxY96qmpv4y6UZv4xrEscmnBM4A5b0plWrGVYrtHcZANbS0WhvJ2V0EtjPDGHaM4NVa6 + XVdYglthFCoyf0rO0rSpL6cZU7KxhWag5VNDnp13yOdRWH6PpLXsysy/JXUXU0Gj2pQY3Y4qV2g0Sz2n + G7FcXqN/JfTk5yOwrhXNip3fwo8+PNjKl3pFEV9eveTFmOfSq5ikC7tvFNIKnBGDVr7Z+42Fea9JLlSU + UeslyJKKKdFTpbSSLuA4qFlKNg9atNFXRIISVzmoiMHBp4kYDFM60xmjp0kaN8+KnvpopcKgyayQGAyA + cetXtMaM3IEv61hOFnznPUp2ftAFjOI9wUgelW9PvRbnbIORXRTSWsVlg7c4rjrlg852Vz0puumpI56V + R4lOMlZF7UNS81tq4qpBaT3j8DPvU+m2QmuFEowCe9d5Faafp1oJG2jjrUVsRHDrlgrszr4mOFShBXZ5 + xbXG3gmpnk3nC81nVZtXAfmu2UFud8oL4hssDr82Kgrbm2vGABk1n3FtsXctKFS+jFTq82jIYZTGwIP1 + FbCTxXEIQAFsVhVLDM0L7lp1KalqOpTUyW5tXgbdVrTrzY4V+aqXN49wcHgVXBIII60OHNG0gdPnhaR0 + 13bJcw7lx0rnZ4WhcgitOwv8kRua0bvTVng3IASRmuaM3Rlyy2OOFR4eXJPY5WnKu9gB3p80LQuVYU1C + VYNiu291oegnfYui1QICar5a2myp6VMZwVHTAqrI5d81KV9xW7nY6TNFeQhZCM4rP16xt4BvjKg9eKw7 + a8ltj8hpJ7qW5OXYkelcscNKNXmT0OKGElCtzp6FqzuN37tqju7Yodw71VQlCCK14HS5i2nqBW8rxd0d + Uvdd0U9PvfsUpJXcpqW6l+3P5gG1R2qrcQGJzxxW7pmkQTWTSyPzjPWlOUY+8OdSMVzMpaVqMlpLszwe + K2L3SmvIPtG7ORmuYnURXBVTnB4NdPoV492n2ZmwDxXPXi4/vInLiIuP72Bi2Fx9gvQGPAPNejR/Z9T0 + wbQuStcjrOgLbDzFPJ5zR4b1f7JciGRvl6c1y4mCrw9rT3RwY2ksRTVak9UZer6a9tcNlSFzwazFx0r0 + rW7JNStDJAmTjPFec3MD28xVlwQe9dODxHtYWe6OzAYr20LPdFd0Kmp0uJDF5YbijyXePdkYFV+VPFdu + jO/RgQQeaUGk60oUkVQyzZRJNNhzgVPcCKCceUc464qgpKnrg04HnJ5rNxu7kODbvc6R44b3S8qB5gFY + sbvu8tj0rQ0O7SG5Al5jPBBqPWPI+3F7cjHtXPC8ZuDOSneE3Tex1Xh/xDb2Ng9vcqrHaRXJalKk99JL + EMKTxUKs79PpXTaf4I1K/szciMquMjjrWVqWHk5ydrmLVDCSdSbtc5c73XkkgUsFq9w4RBlia9G0bR9J + Tw9dC9dEuUBDA9jXCW+YNQEkR+VXyPpTp4pVOZRWxVHGKtzqC2JNQ0C60+3SeZcK3tWKR6V6vretaTqH + htY22m4C/dxzmvL2Xy5OV4z0NGDrzqRfOtUGX4mpWi/aqzRoJdWI0homi/f9jWLirszxGMBRzVQg11wj + a5204qN33LmmXkmn3aTxgEjtWnqup312wnkjMasMcDg1hI2xlb0Ndrf3NleeFo9rIsyjkdzXPXajUjLl + vfQ5MVJU6kJct76HGqPmGa7nwNew29/5crkK3SuGU81taRObS/hlABwwzmli6fPTcQx9L2tFxOg8VQQw + a8lwUYwseeK3vC+rW41EW1rbsEkX72OtWvFccWp+HkuFRRIqggLzXNaLrE8bWwhtctGwBavI/jYe3VaH + gr/acHa2sdNyH4h6bJb6oLgrhX5zXNMbJtK2hT9p+lel+PtNvb3RkvGMYRACQOteYWN5HAkiuOT04r0M + unz0Eux6mT1Pa4ZJvWJHpkNtJcEXLbVA708hI7tvJbKA8Uy0McupJ5nEbNg1t+ItPtbK6i+yOrBlBIU1 + 1Tnaoovqd1Soo1lB31XyOwMJvvBazGEkqv3hzWjo0KXuhFUjXdsxWT4V1aL/AIRiezuJOBnA71b8LPNO + r28D7Rk9a+erRlHmXZnyWIpziqkduWVynoWm2sDXcV4BkE4Bqbw/qdlZpeW5A4JCjHJqytsttrskVxIG + JUms7TLKKfxfOu5EgUZJPf6Vd/aKTl2ubcyrKXO+iZj2eB4qRnQhHk6Gn+ObeODW1MagKyAjFSa88UXi + hRCSY0YDdjFSeOIYl+ySodxZeec12U5fvYS7o7qUv39KfdWOSVQcmr2njdFKuTjHSqK5KjFdF4SWF57i + OWMMxQ4rsru0Gz0sU+Wm2zn0Xk+xr0LwG14dPu1t1jKj+8a8/mUreTIBjDniu78ARTyRXohu/JGORgHN + c+PXNQv6HFmqUsLf0MCZ5F1l+AJvN/I5rp/EMWpMNPa7kQwll6DGDXK3SN/bckbS5cS8vXV69AfsVp5u + oGRhjCkiuaro4PyOWvZSpPy7FnWLfZrGm+WwDEdfSk8ULJ9ph81w3y8ADFUJ7Z5NVs1mvPmONvPSpPEM + X2S+jVpzJkdz0rkUfejr0OBU7ThZ7JlDyiwBHFOaPbF2zTBOFBwc0wzgg5PFaWkb8smysyAkscVFO0Zj + xwKnLq/y9Kzr4Behrppq7szspR5mkzNbCzMV5rudNuUtPCkkgmlQsD8pHyk1xESBtzZHHau5utbA8GLb + fYZFyMbyOPrWmLu+WK7l5hFyUIJX1RyeltBPrC/a2xEeSa6GSLTZbi5aK7IiReOe9UvB5g+3yvPZvOmO + qrnFbGrQ6OdMllhieKR2wilcc5rKvJe05TLF1F7dQ16IhsNN1CLw9NPDs8pwTyO1cpZ6RPqepi0hXMp5 + PFd1qs15pHhm2tklAEoAwRzis/wnazjXJLmF1zGnzVNKtKMJTM6GJnCnUretjj9U0aXS777Ncfeqs0IQ + /IeK3NdnudR125nmAYq2MgcDFbFjFoMXhmaS7ZTdNnavfNdjryjCLerPS+tShShKWrdthvgyLRW0y6bU + WjMvPDdhXD3ixPqki24xGXwoH1rtbnwSbfw6NUM4UldxUHjmub8P6f8AbtWRcZVTkmijUgueqmRhqlNO + rXUm/In1/T7fTdNthGcSyLkgGuXJrpfFkol1YxI2ViG2udde1dWEv7JOW7O3AN+xUpPV6kXWrMCF9sYH + zMcVCq85rofCunf2jrMYxlEOTWlaooQcn0N8RVVKm5vodHej+xPCKRD5ZZhXJaLYJqetW1rMwVJHAY1u + +Nb4Taktqh/dwDb+NR+EvDq65cTHzxE0K7hzivPov2dB1Jbs8jDv2OFlWm7OWt/XYvfEe3j0sWemWs+6 + FVyVBrl9GilSb7SYGaJerY4Fb3/CM32rSXUpdpBCSocnOcVdsNet9I8I3FhNp0v2kkgSbcqaqNVRp+zh + q+vzKo1Y0qCo0/efX5nIa1e/2heZUdOAKZcYs7FUHDuKLCEXF0ZHGFBzVbUpPOum2/dXgV3RS0gtkepC + KVqa2RHZWxuZ8dQOTTLuNI5yqHOKvwZs7UycbmHFZjMWYk9TWqbbubJty8i5ZXMENvIkse5iOKonliQO + M0ppM9qaWtykrO5p2enG5UniqN1bm2m2mnwXk1upEbYpEEt7cAE7mPWoSkpNt6GcVNTbk9CfTbeOSQyS + 8Iozmo7kteXW2PnnCiruqNFawx20X38fORUeiyR2l4LidcqORmpu7Of3E3dnU+4vyRjQ9MAdcXEo49RW + Tp9o99eDdyucsak1O+k1bUWfqCcKB2rTcpo+lhMDzpB+VZ+9CP8AekZe9Tj/AHpFTV7wIos7dsRr1xUm + g6DLqcu4ghB0NY8cb3E2B8zMa7PS9Z/sayMckQBI61Fdzp0+Wl8RGIc6VLkpfEx2oahcaHbG3jlz2qj4 + eEM1601+PvchmrPDS6zqe5ySmc8+lauuX9pBZpa2wG8DBNYKlyr2aXvS3Zzex5F7JL3pbso+K0sUux9k + KnjtXObeM1YEM9y5Kq0hHXFRMCuVYYI7V6FGPJFQvex6dCHs4KDd7EeB604QyFdwRivrVzTtLuNTn8qB + MmtycLpNibS8t9s2OD60p1lF8q1YTrqMuVavscoRSc1OkTXE22NckngVNd2NzZgLNHtB71rzq9uppzq9 + upSoFLitDTNLlv5woX5fWic1CPMwnOMI80thdL0yS+nAx8vrXbhbfRLEltu7HFLFDb6JZ5YLkCuM1jV5 + L+YgN8npXlXnjJ2Xwo8bmnjqllpBEWqanJfTk7vl7U3SWgF2BPjafWmafFHNcbZCMe9P1K3jt5h5Z6+l + ehyxS9mtD1OSKXsloWddS1V18gg8dqxe1TJG80ihiee5qxeWAt0DA1ULQSi2VTSppQbuJBfCOLYVqpK/ + mOWplFaJJO5oopO4UDqKKm+Ux+9MosCSPy+oqnnDZHFNoosBYN1M6hS5xXTaDoCXYEspGK5Kt7Stfayi + MZJxjvXLioVHC1Lc48XCo6dqOjN7V7W2sYfkIDL05rlbzVri5j8oudlM1DUpb2ViWJU1Q7VOGw/JFOpq + ycLheSKdTViUoODxSUV2ncXIbravzHJq7HtmTA5JrGrR0+4WNhntWFWFldHPVp2XNHcmm0iQR7x161lO + hRsMMGunm1RRCUUZyK565Dly5GAaihOb+MnDTqS+Mr5q3a2M144Ea8etVK0dO1I2LZAzW83JR93c3nzc + vu7kd3Yy2Ljcea0tN1XC+XJSvBcazmU/Ko6CsieB7SbaeoPWsLRqx5J7nPaNaPJP4javtNa5QzJgDrWA + 4aMlD2rc0/U3kTyDxnimajpThTKoyetRSm6b5J/IijUdKXs6nyMKilYFSQRzQFLHAGTXadwlFWHs5UTc + RxUGKVwDJqxA0kLB8HBqFCAwJ6Cul0yxi1K2YEhSBxWVWooK72Ma1VU43lsU2jW6gyo5xVH7RcW6tErk + LVpC1hdtC3K5xUl3a+cnmRr+VZpqLs9mZxkk9dmY5yx9TV20uJbJxJgitDw7ZQXGqLFc4Az3rqPGGkWF + rZI8BUHHasq2LhGqqLW5hXxsIVVRavcwH1aXUofLdgqjvWHKBBcZjbJHeoSSvQkU1eW5rohSUdtjqhSU + dtj0/wAKavbz2nkzEAgd6wvFmlkyNcwJlD3Fc3Z3r2koKNgZ5r07SxHrOkbDjO2vHrweEq+1jszwcTT+ + oVvbx2Z5MplPyLk+wppiKvtkBU+4rrorKDQtfY3qZhJypIqh4q1Cwv7xTYxhVUYJHc16cMRzySitH1PY + p4r2k0oLRrc56RQrYBpASBSkcUgrqOwUHmnFs9sU0DvTsDNAD4mKnrXc+GPDNjrFhNNNcASBchc1wwVt + uQpwO9bPhzVxpWpJM+Wj7rXJi4TlTfs3qcONp1J0n7J2YjRpZ38kJ5CNgGu78Oa9rmoQLpthDGqdDK/a + uc8ROusTfbrCwkSED5mxxUWh61fWcqxWTqkjnAJHSuOrB1qN2veXfocFen9YoKTS5l36G/c6P/YviGBt + bnWS3lJLMBgZ9xWR4lt7M6iZ9MjY2gH3wvy11l94c+26U19q2pl59uVy3ArPtNSOoaEdDs9O82dAR5vb + HrXJSrbSWttH0RxUMQ9Jp3a0fRW7mj4U0vQpdNFzM0bSAfNuIrivGdtZx6qzWLh4/wDZ6VpeHtI26x9i + vpWhP9zNdN4j0vQ4NJliUx/aMcEck0o1FQxN7t3IjWWGxl+Zyv8AqeOkYHFNcg9KtSIUcrjvVZl54FfQ + Rdz6mMrjKcGOMbjj0qQR5QnNWotLu5bJrxIGaBOrAUOSW4OUVuU0PzVbtmbdgH6VXwMAjrVi3k2jIHIq + J6oipqtD1rwgk2paG6TKGGMAk1wV7Pc6Nqtxbr8uHJFX9L1TW9IsBNboVgnOFYjjNZfinTtWsbqOfU/v + zjcpFeThqPLWlzNWZ4eEw3JiZ8zXLLoR33inVL63NtPdsYTwVzWAcbjzQxyaaa9enTjBWirHuUqMKStB + WHBvmzU0UpeUF2Y+5NVqehAIJ/KqaNJLQ9C+H2o21vfXMFzGrhxlcjJqGfXpdJ1+6aCNo1ZuFIxisvwj + f/YvEUEqQiQv8oUmtbx/b3Ka6tzPCsSyr8u05ryZ0ovEuMlpJHgTpQ+vOM1pNFU6w19r0FzcOyJnDEel + dBqjx22vWM+nRFkfAO4YD/jXArcFZFYdVOa7TV/t19oljqkkyLHERhE4I96mvRUJRttsPF0IwnBLRWsR + +NFuF1S2lnhSMEDAU5p/i5rWXw/YvDy4HJxU/jS3jbS7G8WdpHIGcml1JorvwCjLGSydWxWVOWlN9nY5 + acrRoy7OxwCyhUrR8NT3B1hVgOC3WsXeACDV7QLmeDWYXt03uW+76161SF4M9+tC9KXoTXwaLVrhZCNw + c5rr/h4Y2vrtHQvmPgAZrkNfaUa3MZkCSE5IBrqfhs1wdamELIAYjuDd65MTG+G+SPOx8ebAt+SMfURF + Hr84ZCI/N+7it/XvsKrp/wBnt5FzjJ2kZFc3r1w3/CQ3LOVLiXnHTrXUeJr9kTRZN0JU4PynPp1rCcX+ + 79P0MKkZP2LXb9B9+LVtZsVWKRQMZyKTxGsH9posJb7vO6ornWXvfFViI2iXaAMk8VB4tu5LfXP3jI3y + jBTpXNCnLmivI5YUp+0gn2YxY49uSajYJsPNZZ1gdAKil1Qk8DFbqjO50rD1Ll/aV5qOWDcCxHNVP7WG + 0A4zSPq67dtaKnNPY0VKqnoiCMBpwjnCFwCa7bxV9gtvD1rFZ3RYsBlM5zXH6V/pOp2yqgdmlHyE9a6n + x/KBLbQfZFgZV6jHNFZXrQixYlc2KpQ+ZZ8FwapZ6RPf2qwPGc/K55NXPEOoudHt2uLFYyzhjgcdaztL + sgfDkaxapJDJM3MasMUzxNJd289lp7zfaSADtUcmuNx561/M4HBVcVfz81sTzaq/ibVrKCOEmKAZYYrS + 0Zhapq16sRRQSvPTim+G5I0+2XzWrQNGm3d6HFBlS38KMJXy11JyemcmsqjXwJaHPXmn+5itNF+rMmcW + tr4TWUIrXF1ISeeeTUOr2mmG202C0UtM2PM45rSuodPvvEOn2YDm3t0G4R9OnerKfZ77xgP7OVClquMO + MZrVTcVf1f8AkdCqOFpa9ZfojP8AFjWdvoMNvb3Eyvj/AFTE4qr4Rsls9JutSlGPlODVfxpqEuo6ssJg + WNoztwpzmtHXLk6T4NgswpV5hzVcslRjTW8mVJSWHhRW83+B57ezNc3csxPLMTVJ8nNWGqMivcgklZH0 + 1NKKSXQjUV6T4OsI7Dw/PqjsokIOOa87CfLyK2LeTURpbKrSC16HriufFwdSCinY48wpOvTUFKyvqVbp + 5Lm6klb5mdq7GaG30PwdGoDR3953zggVi+FtNGqa9BBIwVFO5mPTArX1hzqfiYr/AK6ytTtATpgda568 + k5Kn0WrOXFSUqsaP2Y6v9Eaemw3WieEnuYLxXebkoxz1/rT4fEcb2VvZapo7RQSctMF4K+tcveiS/vnj + 03zRbxfwnOBXQrrFzB4VcX3kyuw2xKVwQK5J0ravVt+jOGrh0velrKT9GrnPeIW06/11LXQE2xMAucYy + ap6r4K1DSXSSZd0RG4sK3PCkcWnyNe39iZEPKuF+7UHi/wATyajMYLSdxbHqh6A10wq1FUVOnst2dsK1 + aNaNGj8K3b1OJu3LMFH3V6VXRdzHNTSAE471EwxXrx2PcjtYj6GnMBnilA3UhxTuV1G8DitnTGsrexlu + Xb9+PurWPt70mKJLmVhSjzqxoaZZTavqijG4E5Y+gq54ka2hnW1tsHZwxFVNO1OTTFfy1+Zh1qoh+0Xi + mVvvt8xNZcrc+Z7Iz5ZOpzPZG54d0gzI93JjagyAaytVeeS8YyKVXPyg+lbuuXkFrbW9tp0mMAb8Vn2k + V1f3CTXKEwp3xxWUJO7qyMKUnd1p7dC54ctIom+13P3V7Gq2r3g1PUDHap8mcKBT9Zv4nKwWmVA4OKl0 + 63k0lVvpo9wIyAaz2ftZbvZGSum60t3si3avb6NprrNGBcMOM9RXPpFJf3YRPmdz3qxqF6+qXhbbyTgC + t5NJXQtIjv5XX7S4yq56UX9krv4pApexXNL45FuE2HhrTmju4le5denpXFMsmpX5ESfM54AqW8vJ9SuN + 8rZY8Cuhh8O3uk2EerRspwM4NEbUFzSfvSFBLDLmnL35DYrDUvCYjvflwwyQax9b1qbXrxWZAD0AA61L + rfie91lUilICLxgd6vaX4fePTjqjkFU5xRH92lVrJcwR/dJVa6XO9h9l4d+y6WNTkkEci8hWrG1fWZtU + 2iRFVU7r3o1XWZ9RITcUjXgKDWUWOMdq2o0pX56m/wCRvh6M7+0q6vp5E1jbrdXSxM4UH1r0S3tLXRtO + 80lc44NeaKSrAg4I71dl1O6lgELyEqPepxWHnWaSehONws8Q0lKy6lvWtae9kKg/JWJ3qxaiM3I837tO + vBEZz5AyB1xXRThGmuSKOqlTjSShFFYMQ2RwakVmkkBclqYE3dK3vDkFtNOUnIBPrRVmoRcgrVFTg5WF + 220lkBHjzcdu1ZF2JxhZGyO1bet2SabOJIWGDzgVz89w0zEmsqHve8tjDD+8ueOzIKeoBHNNAywA71Za + 3MKbyc11HaVghzincKKUyDtUfJ5oAOWPAzR07c1f0xoA5EuPxqK/MZuD5eMe1Qp+9y2M+f3+WxVoo5p0 + cbSMFQEt6VZoIOvH5Vr6Zokt4waRdqVf0rQggE9yBt681PqevRWkZgssbh3HauKpiJTlyUd+551XFSnL + 2dDV9zkKKKOldx6IUA46UUYoAtW8w3qGGav3EavEMY57VjjI5Gau2twfMAk6VjOPVGNSD+JFeWBo+SOK + hrcmt/tK5XgVjyxGJypp06nMOnVU9OppWGpzwp5UaknFXriKCW0MjNmXuO9Y+n3KW0pZxwe9XYLyB7xp + W4UdAe9ZVKdnzRM6tFJc8dzOxJbSBsFfSuo0zUormDy5sbsVh6nfQ3R/dx7cVShmaFwy0VKXtoaqzIq0 + fb0/eVmaWqaewdpY14PpWVG5hkDEdO1dZa3Ud7a7MZfGKyNR0W5t1M5X5TzUUa1vcnuTh69n7OpuVJr8 + yR7QuKo0vSgda7ErHcLg8GrdrezWmfLYjNRyurxqqjp1qHmpaUlZktKSszUC/bYyxOZKtaXdLG5hmwew + zWPbztC4IPHer0ib1Esf3qxnDTlexhOH2XsT6gfs9x5sBw3XIp9nJca1dpBcTHb9ak0+KG9VlmbBA71Q + nU2l0TE2Cp4IrNJP3eq6mSSfuL4l1LevaMNLmUIwIIz1rFIJ6VrwWuo65cBF3SEcVFqWk3WlSiO4jKk+ + oqqdRRtTlK8iqVRRtTnK8jNBro/D3iCTSpgpOUPGK58ICCaVSMirq041Y8si69GFaDhNaHqWsaamu6X9 + qjAL7c8V5jcW5t5mjcYINdh4V8TCy/0WcZRuBmn+K9AlZRqEMWIm54ry8NOWGqexns9jxsHOeDquhU+F + 7HBN1pQPapSnJGMUgjwec17Nz37nY6XaaHf6E8DMEvcZBNchcW/kTvFuDbTjIqa1CpdIJWZY88kelbuu + 2uleRE+mb5Hx85AOB9a5I3pVLXbT/A4o3oVbNtqX4FLRAbtH04Rrvk+67dqzbu0ksbt4JPvKaSK4ltp1 + miYo6nIIrXudNudR019WEgk2nDjuK1b5JXezNm/Zzu3o/wAzc0jxeYtDOlrY+fK42ggc1g3NteWMokng + eBmORmq+h6qdI1KO7EYk2HlTW3r3iafxNKHFusSIMYArm9k6dR8sdHuzkVF0az5I+7Ldm74WOmXSfaNb + uy4H8EjfKPwqzda1a6LroutCgV4GXa64+U/SuO0yzSY75WwqnJWvQzqmkz6GNP060M10FwAiZwa87EU1 + CpfVp9OiPKxVNUqresk+myRzXi2x1hJU1m6VIllwQIzyK6Pwxf6BHpKy3TI9yR8wYbmNY8On6z4h06eC + +vvKSz6RMBms7wnfafpWpyLfxCRlOFIGadSHPRtu49uwVaaq4fkvrHpHsUPFVuP7Te6gtZIbaQ/IWXAN + c2ynO6vXvFMN54h0pWtrDy4lG7c/Bx9K8nkjKOYzwQcEV14Cvz07dUd2WYn2lLle68yruPIJ4rotK8Vy + aboFzpTQrIkoOCe1c9Im0H1qMcnmvQcYzWp6soRqKzFzzmpbeQKxz3qInB4oBw2R1qrXKauj0nw3Pf8A + iPw9NosKwqLcb1kbr7VyviTXtS1WSO31B1Zrb5BgYzjik8Pyayl039kiTzCp3BfSsy+e4S7mFyuJ8neD + XFRoqNZ7d/M82hhowxEnpbdd0+pRY0lHakr0D1RaUGkzRSA0LO5NrdwzRMVdSDn0r0LxtYXk+hWGqTXi + zKVHAHTIrzBWz36VoSancz2qW73EjRIOEZuBXHWoOVSM10POxOFlOrCpF25fyGltr9OK7WyuNOn8DSxy + zhblDlVLdfwrgJHOeDmhZDjBPFVWw/tUtbWZpiML7dR1tZ3O8vNRsLvwZDEZR9qTtUVr4qtY/CM2lSxk + ysOCK4recUoY56VmsFBKzfW5isup8vK31uNY8mp9PvXsL2O5jxuQ55qAgkk00jiuuyasz0OVNWZd1DUJ + NS1B7qUDc55xXVfDx1/4ScLkjMTAflXECut+H8u3xXbKerBh+lc2KgvYtLscOYU0sJOK7GPrLY1a7HX9 + 6386ovcSSBQzsQvTJ6Vf8QLs129X/pq386zdvHQ1rSS5InRh0nSg/JEiTSK4cOdw6HNSvcyzNukdnb1J + zVQA54qQEj1qnFFyhG9yQyGmlvembjnpSHJpKKFyIfuPrSBs9aaM0DNVZFWOj8KRxyeILNZXkRN2d0fU + VpeNblJ/ELIk8k0ceBufqKzvCetpoWsLdzxM8e3GFOKg17VF1bWLi8jQosjZANcLhJ4jmtpY8t0pyxvO + 1oluei2C+G3tLRPtUIdEyynjJrkJb5ofEsl1ZMHERO3dyK5q33NKM54qdpCspCEj6VnHCcjbve5nSy9U + ZyblzXXU9N+26hD4Seea3Q+cSxZewNUj4i0zVZbG0mi8qCEZcj1ArlJPEGo/2Ytg026HsPSs4XAjiPHz + nvXPDBXu5fgctLLbpylvfSx6BoMcDyapqsNy0SLkR7uhFZuga3b6at7eXcfmSyk4cdqjk17TY/BK2MIH + 2lj83FYOpXMC6bbW8bAsRlvalToOd1JaN2+SCjhpVXJTTs3b5Ilszc6tr3nQqZH3Fwp9KteMNcl1C4it + ZIfK8gYI96u+ARHbG71CQDZGhAJ6VyWq3pvtRnnPV3J/CuiEFOva2kTphCNTFuNtILT1KZPJpqgbqQml + XrXoHrbFiCFp5FiVdzMwAHrXo2uSjSfB1rpsmnGCWUctwQPxrnfB+nfatajd7M3EESlpAvb0NSa5eSar + rzwRSXEkCttjjlYnb7CvOrS56qj0Wp42JftsTGHSOrLegXltpmkXG63ka7uPkRwvAX1zW1oulR2ml3V0 + sm2VlPl7ujGrTXEUllZaV9jMFyQEZmHRR3q5qVrDIqW3mgQ2ieY3zcsewxXn1KrlLTqeRXxDlLTTmevo + tjm9Ft9V03V1gEEcof8Aez5GdoNVfEt0urXvmQ2hjtoDgkDjNa0lxqmj2capze6ic4K5wKj1m/ltdIj0 + WO2VruYZkZRzWkZSdRStr/V2dUJydZVLK70/zZJb+KtJtvD72ywjzAhGOvNebTSAu8jLgsc4rW1Kzt7K + KJVc/aP417isadzI/IwK78NSjC7j1PUweHp025Q6lRgMkk1DjJzU8gGcCkWI7d3IFeinZHqp2REVwBjN + Oit2mZUQFnY4AArtdH8J6bdeGpdSvr3yZhkqh46Vn6PpOp2pXW7e0M1tA2cnuBXO8XB8yW6/M5Pr9NqS + i9Vpr1ZjX2kXlgF+0wPGGGQSKzgvGa7bxb4yfxFbwW6WoiVOWPfNcasZcnArTDzqSheorM2wk6s6d6qs + xm08Eggdjik2/N7VrXeqtdaXb2Jtok8n/loo5b61StoFlcqzAADrWqk7XZspvlvJWFsrKe/uhDApdz2r + o9Q1tbLRv7KW3C3C8M1UtB1ldDW4f7OHmdSqMe1VBE17I9xcByWySwHSuaa55++vdWxy1F7Sp7691beb + HaXpc02buWMmFeSTVjVtYa6jS1hI8peAMU06/Nb6e1hEFMZ4zireiaHM0P8Aa8iqYYTllPeom7P2lT5E + Tai/aVfkWvD2l2NtbyXuqZRgMxg8c1hanfS3t2f3hKZ+UZq54g106vPhEEaKMBRSWmi3tnbxapNBut1O + SPapgnF+1qvV7IzppwbrVnq9l+hc8PaHaXyyPey+UVHAJwaztT1a9UvpsV00lspwoqx4i1yDVpLdbOAx + FBg47mm6fp8+j3UF9qVmxtmOcnvRFNfvKm72Q4pr97V3e0X+hN4VsNNe5lOrEIAvAfis/VdVdZJrOynb + 7CGO1c1P4n1q21W+DWduIYlGB71z+c1tSpOb9pPr07G1Gi6kvbVOvTsJ1602lNNrrO4WlA3YAFJgYzWh + BAIoPPbBx2pSdhSlYoNGy9QRXS6Ommx6ZK05XzSvGfWsuG1udVuNltEWIHQVXvbKeyl8qdCjjsaym1P3 + L2ZhU5an7vmsys7BZmKdM8UJM6OGRip9RSMppnPpW9lax0WVrE893NccSOTiq56VJFC87bUHNJLE8L7X + HNCSWiBJR0RHUrzyOgVjwKipQAaZQqxu/wB1Sasw7FjO/gjtRaTrBncKgmfzJCwGM1L10JeugxiNxK9K + TvRitDT9Lnv5AqLx60SkoK7CU4wV5MrW9tLdShIlJNdZYaVb6dD59wRuAzzUqJZ6Hb7n2+bjpXNanq81 + 9IRuxH2ArhcqmJdo6RPNlOpi3yw0j3Lmra6026G3O2P1FYJJJJJyTSUV2U6UaatE76NGFKPLE2tI0l3I + ubiPEAGcmotZW08wG3IP0q1qmuzvB9i8oRbBtYCsSKJp5VjXG5jxmopqbfPPQilztuc9COpd+VC4rRv/ + AA/fafAk0qZRhnI7VlAc1rGcZK8WbRnGavFne+HPDFnfae0juN5HFc3rmiTaXcN8p2Z4Ipum63d6cwEb + nZmvSrH7F4m00CUKX24Pr9a8mrUrYWpzy1izw69avg6zqTd4M8utL4xDY1WJbL7UhkB568U/xJoo0e+a + NXBUnjnpVOyvmjYIxytdytOPtKZ6KtUgq1HqUZI2jYqwptblzAl0uYwM1jywvC5Vh0ranUUl5nRSqqa8 + yOiiitTUuWF61nMHXkeldzBexaxYlH2gYrzoHFXtPv3spg2SV7iuLFYZVFzLdHBjMIqy5o/EibVdMktJ + iwQ7CeDWYRg16LHPBrVj5YVQQvWuL1TTJ7GY7kIU9DSw2Jcvcno0LB4vn/d1NJIoxqzdM471oXunxW9r + HKkgLMOmaz0kZM479aNxJyST7V1tO52tNtWYDAHvVuzmIfYT8pqmTznFSIQDx1pSV0E48ysak8LwESIe + D6V0vhjwtHr6s7SDOOme9c7psc13MkUhIiY43Y6VfiubvwxrAMEgYA5xng1wV+eS5IO0jzcQqkounTla + Rr6be/8ACG69LDcR7os/KxHWqnifVLrxLKbmG2226cbsdaXUVvvE7vfuFRUHC1FZapcvYjSYIkLudu41 + hGmk1Va99bnNGmk1WsnNb9l5nLhGLYp4QIQetdhq3ga+0vS1vXIfPLLT9BOk3GkS2c1s737giMBc5NdL + xkHDnhqjqePg4c9P3ktGQ+HPBza3bPdLciMoMjmuj0PVm1ONvD90B9oXKBieuK5U2up+G5VSfzYIpDyA + eorspJ9Ci0VLy1lVL7GQw+8TXnYpueu6e1uh5WObnq/eT+G3Q5q68LQaJ4jhTUZAbWRuvpU3jnS9KQwS + aTtOF+cr0qXS7+LV9SP9tTMQPu76peJrdC7mxlYQp1JGAw9quE6ntYqb1X3GkJ1PbwVSTul8jipdwbBz + mun8Izvd3P8AZbyRRQyg7pGHNc47KwLH7xqNJHRsoxVh3Br1qlP2kHE9urT9tTcTV8QaYNN1aW1ikEqD + kMvem6LqBs5mgmdhbzDa4FR2dnqF7vlt42mKDLnrgVXvbOa0kAkHLcjFJJOPs5O7JjGMo+ym7sW+ijt7 + tkiO6PORU1hNELqKKUlYWYBmHYVq2Ftbat4emgit3bU4TvXb/EveubAZWKtkEHFKL504vdDg1UTpvdaf + 8E73xXo2l6Xa2s2mXgdnUFlDZzVfw14iOiXIeKASs/GCa57TRazXiLf3DrCv41evkjhm8ywik+zD7shU + 4rklSXL7KepwuguX2FRuXmzr9e0vURew6xfTCG0uGUSiE/dU+vrVDxHBo1lPbXOhkzMnzOwUlfxNWdAk + bxNZSWeqak0cUK5jXIFTafrcUGnz+HYbNLiTcVSYdxXCuaD5Xq49NlY82PPB8j1cd0tFY3NC1O88QaaZ + LqeGC0xtZUPzH8T0rzvxdp1tp+pt9ifzIjySOcH61oadEuh6usOpRymJzgIDhcmuu8TLoj6DJb3Nxbwy + 7N8KryT7cVMH7DEJw1izGD+qYtOCbjLtt/wbHjUjFu9QZqYkZxnioT1r6KJ9bHYemSMAZpp4NCOVPFIS + ScmmVY6Hwxrc2j6zDJHPsidgshIyMGl8ZwW9v4gmNvdi6WT5y/17VzozilbJOSTmsVRSq+0RzLDRVb2y + 7WfmNooxxn1orc6QooooAUUuabS0gFzWtomltqt2IVmhg45aVsCsinKxXkEg+1TNNqydiKkZSjaLszqr + bw5Zyyzxz6vbxPExHXg/SoZtO0eGyEg1MSTh9pRV7Z61zu8/nRurD2M76zOVYare7qP8DrL+28MW8lob + a6kmUkecMdBUNxJ4eTXozFHI+n4+Yd81zOeKUHJApLDW3kxRwbW829+vc6YXvh2LVZpFs5XtCuFUnkGt + XwjqmlrrNjBHYkXJmOJs9j2rgzkEitnwxJs8S6c2cHzlGfxqauGjyPV7dzLEYKPsZat6d/I29cvdLi1r + UYp7AvIZGAYNjBqkmtaYuk/ZW03M3/PTdVfxepTxTqAz/wAtTWHuNKnh4Sgm79OoYfCwnRg23snu+x0V + 3qejPYxRW+nuswxuYt1ou9S0eS0gSCydZVI3knrXO5PrRmtPq8e7N1g4K2r+87GLUPDEkyPLZSIqrhgO + 5qKC48MyXM7SRzJGf9WMVym75cUiGs/qi/mf3mX9nx1tOX3nUfZfDzaVJMLyRbvJ2xlap3Vpp6R2xs7h + pJHH7wEfdrF3c1bsGzOTjoKr2TjrzMpYeUPe52zo73w7bxtYLa6nDK9yQrLuA2fWq7+Hrk6zNpsMkUjx + qWLA8Vz5cveHB43VYW4ljuSY5HUngkGp9lUS+IlUK8VZTu7djaPh/V7GzhvGtv3Vw21O5P4VUhsLp9Q+ + yi3ZrjOSnetnQdZ1Bllmmu3eKzQ+WrnIU1N4b8R3k2sXGoTxxSEJ8zbcVzSqVkpaJ2OKVfEwVS6T5fze + xzt+pivDFNGYnXqpqCUZ5BFdLZ6vpur+KJLrUbIsrDhUPA96fqtt4avrmOLTZ2gleTDbxwoqlWcGoyi9 + i44t03GFSDWl31SOSLsF6cVCW3HpXT6v4aFpfwWdheR3Rl6YI4rO1HQdS024S2uLY+Y/3AvO6toV6ctn + udVLF0ZpWe5o2vimKy8Jy6VDblZ5PvS+tctuOM5qa7jkicJLE0TDqGGKrEHPHStKVOMbuPU1w9GnC8o/ + adxc05DUecU5DyB0rVo3a0PStMil8O+DpNTt76EzXAAMfB2//XrO8Hia51tblbX7SyncxJwAa415THGI + xISp5254rc0TxZe6Lp1xa2yRnzx98jla8+eGkoStq2eRUwNSNObjrKT9ND0i3u/tl/dansR0jBjMLEZU + DuKztLks7y+utTubaVrKLIUk9DXPL4gsV8MR6fbBhfTv+8kIxjPXmtK/W8tH03w5pt0s3mKGkCYxzzya + 8/6u4t30/wAkeRHByjJp6N6fJbsT+1LyO/bXY8Pax5WJJTyB9Kn0DUkk1K88QapkEKfL44B9KzfFF8s+ + oQ6VaxiNbfCvtH3mpviG9js9NttKgdXBUNIQOQfQ1qqd0lbV/kdPs3KEYpWcvwic9qVy+o38945+Z2Jr + JkyMjvVxyF6Gqz4JJNenT91WPbpJRSS2IY0LEDvWzplhf6hcqtrZmcQ/M6qO1ZyRgANuwTxXpOk6Zq3h + TRjq1ldW9zFKgeWNh0+hrPE1uSOm7MMbiVTjpu9jL1nW7fW5LLTZbc2AjO2VyOg+lSnUrm30+bRrK9Sb + Thx5m35+ewrOi1K21q9ma+RYbm6cKsv8KA96vXyQeBtWtnt2hv0dNxJ7H8K4uRJKFte3n6nnumopUlH3 + t0ul/UoeIPCNvpem208V4JLq4IAhXk5PtXMXmmXOmyCG6jeJ2GdrCu50WTTde1q61jVLsWzxkNCiNjBq + dIWvdXk1jxBFJNp6qVhlQDA9MitYYqdP3Z6/59ka08ZVoe5U1a39ey7nm6wFQWcEqKYsYPzcnJ4Arubj + wsk3h+612K4SKAufJhJySM459/aue0ww6dq0Et/bF0ByY24NdccQpRbW6PQp4yNSEnHVroVpdNkgt0ln + ikjDfdLDrW1ofieDS7Ka3ubJZt4IVvSt3xb4w0290yKws7E4x98j7vtXCRCKNsTAncOMdqzhevD96rGV + LmxNL9/Gxr6b4cvtW8zVIIE8iNtxU9xT9f8AEf22GK0s4mt1jG11HGaq2niLUNJs5bS0uf3MgwVq34Y8 + MP4leeR7tIioJ5IyTScbP2lbZbBOHLL2tf4Y7FLRtBN8GuLovFaqOZQOAfepNS8TXgsG0iOVJLdDhXA5 + IqOXVtQ0WO70dZ0lgYlSan8J+GotekmNxOI0jGSc4q5W1q1dUti5WSdavrFbDNN8K6lPpp1eHZsiO7B7 + 0mu+Lr7WbSKzkVEji4wveq99qd5psc+k21+z2YYjg9aw2IIOfvetXTpOcvaVNexdOi6kvaVbP+XyGnGe + TTCKKO1dqO8ShUzz2pwGeldLoFhol7p10+oXQhnRfkB9aipUVOPM0RVqqnHma+4ZolvpEtrNJeyBXVeF + xWdDB9ouCqCQ2wbkgdBUEVsbi5EFv8xZsKa67QdWh8K3ElpqVqsysMkjtXLVcoXcdW+hx1pSp8zh70n0 + OjttK0zQ9Kj1exuU85VyVJyGrjtRu7rxjq6R29sqyH0/nUF19o1W4uLizhmFlu3FV6AVsXF9pWn6dbXG + kSGPUU4JXr75FcdOm6b5nrJ/h6nn0qMqMudtym/w9TndU0ebw/fCG6AZiM4Haq9lpj6nM5QbVHQCug0v + TrnxP4gX+15WRpFypfjP0qPxHp7+E9UMdpMGjYdK6419VSv7/wCB3wxLuqLfv2+RzEqTabdsvGRVaeZp + 33tWrb2U2rySTSOBjvWbcwiCZkByAa7ISvo9zvjJPR7kAGTSkFTRSck1oaBSgEkADJ9KcI2YgKNx9q6b + StBQ232yWQKy84NY1a0aSuzCtiIUY3kVLDw7dSqs8sZEfXBrVutUttKt/Kt1Xzcdu1N1Xxa32QWdoFGO + CwrkJJGkcs5yT1JrlhSqV3zVtF2OGnRq4l89fRdET3l7Neyl5Dk1VzS5xQVOM4OPWu+KUVZHqRioqyEq + xbWVxd5EMZbFVq1dK1KbT2KxgHPPNKbko+7uTUclH3dyjcTPdXLyt95zmul8MaDa6gXa5lMbryBnBFZW + mWzQXMN3PAxtQclscYrd8T6rp09tENPO1x/EvB/GuSvOUmqdPr17HJiJyk1Sp9evYqa7rd1H5mm+assa + cB+9ZOnaPdanu8leg/Oq9rbve3ax7vmY9TXSBtR8IyK6FHiYdCKp/uo+zh8Q3+5j7Onbm/M5m4t5rKYw + zoVYetWtO1i60wsYHIDcYzS6nqM2s34lMYVm4CrUV3pl3YhTPCVVhkHtWtlKKjU3Zs1GcFGra76EN1dz + Xkpkmcsx9TUFKcUlapJKyNoxUVZF2zvWibaelaktrFeQ7lxuxXPVdsb5rd8NyDWNWk/ijuc9ak/ihuVp + oWikKkVFXSzww30O6MDdisCeB4XKsDVUqvPo9yqNZTVnuT6dp1xqU3lWybnpL7T57C4MMwwwpdP1K40u + cy2z7SRg1HdXMt1O0sspdm5Oe1V7/P5Fe/z+RZ0rU5NPnDA/LnkV119qNrqenBBHulI4xXA1q6NqIsLp + WkUMtc2Iw6k/aJao5cVhYyftYr3kU7u0ktZcSIVB6Zrd8O+FjrcUkzTBEUHHNad/Zf8ACSfvLVQqqOa5 + rzr7R3kt45WTPBANKNaVWHLF2kKFeVaHJF2mVr60+yXckAcMEOM1XHBzSlmZtzkknqTQcE8V1pO1mdsU + 0rM1rK+kkRLZSE3H73pXU31hpNpoo8y4829I65yTXBxkqQQea6HQI7W/1BU1GYrGO5NcOIpW99OyXY8/ + F0eX94m0lq7dSTTrfVbmP7PaeZ5LHnArsLzwXBpmhLqCXLR3aANk+tZ0Gtjw7fTR6e4ngP3c1f0C3/4S + m5km1S+ZYlP+q34FedXqVW+faP5nk4mrWb9p8MPxfqVrK817xbt00TqsKj527mqV/pt54K1iGcFZQOc+ + ta2pRTaBrJm0FWaONcPgZWnWuk3XjC3m1C/vguwEKuehqY1Eve0UH0FGtGPv6Kk911Kt3d6v4/uooLay + WKGPhpPSsq4sT4V1yKK+CzRjk4p2la/qXhm5uILZ18tiRlh+tUILHUPEmpvtZp5GJJYngV0whypp6QOy + nS5brRUrfmb3iDUbTVxFc6TYyKIh87BeKktEh8V6Q9u8iwPbrnIPWqWn69ceHoLjR57FTKx27j2qrc6b + eaJNDqMkeYpDuKr/ACrP2dvdWn8r7nP7LlSgtLfC73ucrc2j21y0bDgEjNQZMb5xkfzr0zxJZWWvaBHq + ltLFC8a/6leprzOTPQ9vavRwtf20ddGtz1cFivrENdGtGami6/daFcvLaMPnUqytyKsalpN5HYRavLNH + LFcMTtVvuk1z34Vr6ZLb3Ei2+oTyR2q5IAPGa0nDlfPH5mtWnyS9pH56boq2V/c2FwJreVo26ZHoataj + psy2yagmZLeTrJ70t/pMkNqLuFC1qzEK9WtDmk1BP7FnvVt7Z/mBfpn0zUykv4kfmTOore1h039DCjJU + g9cGvQ7XWL7xPoiaPp2lx+ZGvzydK4K9s5bC8eCUEbWO0kfeHqK0PD/iK68O6gbmzYHIwVboanEUvaxU + o6tbEYuiq8FOCu1qiWa2m06+8m4G10PzqD1rsdT1bw9aaTZ32llY9QjwQq9ffNef6nq1xql/Jd3DDzJD + khRgVS34znrUSwntOVzeqIngnWUJVHZre2zOn8S+MLnxI0Zlgji2DAKjmucknklbMjsxHqah3E96OSa6 + adGFNWijrpYenSjywVkDk5pmDWppuh6hq06RWsBZn+6exreHhjTtGuYv7fvV2Hho4TllPoameIhB2vd9 + kRVxlKm+Vu77LVnICIn1z7CtfTvDWqag0bW9m5VzgO3ArWk8Q6Rpb3MWk6akscnCSz8kfhWLP4h1OaBY + Gu5FhXO2NTgDNRz1p/DG3r/kZqriaq9yPL6/5I1E8OWlrrE9prepxWwiQNuj+bdnsMVW1C48ORaY9tY2 + txLdk/8AHxI2Bj6VgyOWIYszE9S1R5zVxoyunKT/ACNI4abalUm36aIXaWztUnAycDpTacrsmdrEZGDj + uKbXQdYtJRSkjHAoAKKKAM9KAClqylpdPjbBId3T5Kvw+GdWuMbLKTB6ErWcqsI7sxnXpw+KSRkZpc11 + P/CD6qksKTiKIS8As4wKs/8ACFKshjn1WziI77gaweNorqc0sywy+1f01OOBorsk8NaIlxsuNdjwO6jr + Ux0XwjC48zWHcd9oqHjYdE38mZvM6XRN/JnEY5rQ0RvK1qybniZf510n2fwZH/y8zvg9hU8U3gyCaN4/ + tBcMCPrUzxfNFpQl9xnUzBSg0qctfIyPHCbfFd57kH9K52vS/Ecnhkauz30M7TuqklehGOKypLrwc5YC + 1uF4wCKiji2oJcj+4ywePcaEI+zk7JdDiaMV2sEvgxSBJBdH3JomTwbct+7kuIQPQVp9cs9YS+46P7Qs + 9acvuOJxQBXb29t4MYbZLmZSP4j3p40bwlK3y6qy59RS+vRW8X9wnmcE9YS+5nD4wauWYwJHHYV048Ma + HPM0cOtoMdC2Kst4ECwn7PrFs4bqNwpSx1K1np8mKeZ4dqzbXqmcVarumY+gpy53M/pXVL4B1eMt5Lwu + COoYc1Rm8JazBkG1Lc/w81axdGW0kaxzDCyek0KpNp4Tc/xXMmOfSk09vsfh25n6NIdoqfW9P1BbOzth + ZShIl5+XvUGrIbXR7O1KkMRuYYrGLjNJJ7s5oONSKSd+aV36L/hippH7tLi4b+FcA0aSgmvXlYZCAsTS + geRoWc8yvT7MG30a6uO74QGtpu6k++h0VXeM2ursURO7XbzK7KQcgg9Ks2uu6nHfpdJdO8sX3S5zgVnq + CsJNJCNkTvW3s4Nao6XRpyVmr9DqF8Y/a9QFxrGnw3YVdqhRtx7+9M3eFrqxlkfzre9diVQDKr6CuXUH + YTnjNRbvmrP6rD7La9DB5fTX8NuPozrb/wAFy2unRXkF9b3Akx8isM59Kxr3Sb7T0U3VpJGG5BI4qmlz + LHIrRyOu05BB6Gumt/HWopsS8Ed5AnRJB1qGsRDa0vwM5RxlLa0/wZy2DnpUnOABxXX2s/hfXZJpNRVt + OnY/KY/uLVW48H3E0jvo88d7AOQVYbsfShYmO01b1GsfBPlqpxfnt9+xzauVbrmrljqlzp94Lq2lZJgM + b884qK4tZrNjHcROj9wR0qAAA896292a8jp9you6Oo8L6rYWmqSX+quzvgsvGcsazdQ1AahqE1yQF3tk + AelZTOThT0FRlj0FZKhHmczFYWPtHU67Fsnc3tTVI389Kr7jinxvgc45PJrTksbezsjo/Dts1xfpPcaZ + LdWKcPsXOKu61d29zqKafoTXAt5BgwEkLu9MVfj8SW/h3QLdNEvBM0o/exzLkocc4pPDWg6m8DeJI5YQ + 0bF9sg4Yd+a82Und1JKy6Hiym+Z15qyWiTvq/NGtpK2egaf5evWAiOOJCu4GuWuNCu9SmbU7e3YaZJNh + GJ+6uevPapNa8S3HirUIYHVYYUPIB7+tbyzXuu20GhabttbeJPnJ48zHpWSU6T53o3v5IxiqmHftJaSl + v2S/zMLXvDn2S5hiskMqsuTIo4H1qKHWNSh8iwuD51hAwLxL3HpXU3Os3+jW7aMtqk92y4Ujnb71RvNP + 0610ow28hl1WQZ2pzknrRGq5JKav2/zHCu5RSqxv2f6+Q6BYvEeqC70tYra0sAJDbSn5XI5PFV77VtH1 + 03l/qdu8FxGnl28KL9/3zXO2OlXV1qKWEAZLiQ7WwcCut+zW0+oWuj67tt4bOMoJYxgO3bJqpwjTas/8 + /wDg3KqU4UpKzv6bpfrc4+98P3+k2cF9eQlYZuUyeeeldHNp3huXwgLuKdTqCj7oPzZ9MVaWeaDV45tS + aW/0G2YxwvjIB7H3rO1LSrPUre+1eymjt0Em2G2B+Zj9Kr2rnbmdvNfkW68qjjzu3mtvRnGE+VLiVMj0 + A6U5GljZpLSV0z/dOK6zQb3TdFkuLbxDp8m+ZflYjtXJ3hikvZTaoywljtHXiu+FTnbTWnfoz06dZ1JO + PLouvRlrw8dNGsBta3tAepxnml12axtdWl/sOaRbY+hxWYzKyhehz1NV2O3nHWtFTvPmv8uhr7JSqc7f + y6DS2c55z3pnSn5GckcUwjd0roR0rQdKIxt8snpzUeaKSmikjpdG1PR9P0m4W5tDNdOMLnoKxoIGvLkR + xLtDtx6CqoPA7muiTXbS38PfYre0Vbtm+abv+Fc8ouDbirtnLKDpNuCbcn9xPfLa+HYPs0DpPesAfNX/ + AJZ+1UdK0261++PmSYHVnanaTotxqQN5cBlskP72U1LqepQxyPa6SWW36Z6E1jqm4Q1l1fY51eLdOm7z + 6vt/XY0V1+Tw5b3GlQiOdW43+lGn+EdRu9MOtRbCFO/aaz9Isbdla4vHVlAyyk81MviW+t45NN06cpay + HAU1lKMldUt+r7mUoSTcaPxdW+pq6l4qt77SI7OG2aO+Q4DIOQaz9I0p9UvpDrE7qUHAkNWm0mPQ0t9S + aYSS/eKnuaWX7d4pvfOgt/LRBjjvWKcIRap6Luc6cIQapaR/m7PyMDVQbG5mhsHYwZwWA4NYRBJya9QS + 50WysfsF5EBcH5c471yviDw7JpyLcxEPA/IK9q6MNi03ySVuz7nThMcm/ZzVuzfU5cirVnp898+2CMsf + WtDRdCm1OdSyFYc8tXR6lNZeFyq2Miyy455zitq2KtL2dPWR0YjGKM/ZU9ZDNFi0zRreQ6pGPOxwpFc1 + quqNcXLi3YpBnhRVfUdTm1Kcyynk9qoGnRw1pe0nq2OhhLS9rUd5P7gJz9aKACelWLewubvPkxlsV1tp + Hc2luNitJpU3KvFaltcWr2TQyqFkA6ms9Lue2jaAjBH6VW3EtnvSa5iWuYV42BYhTtB60wEjocVtJe23 + 9nGN0HmY4rHaN8FtpC+uKUZN7oITbvdHo+tata6Noy6U1spnCbd46V52MO4ycZNWb++m1C5aWVicngE9 + K6Xw14Z0/V7GSS4uAsgBwN2MVyQUcJS5pddzhhGGDpc0t3uKnhiP+yBfwXASVRuHNc3e6neXgCXEpcJx + U1/LPYyy2MVyWhBxwam8P6FcazdcIWiXljmqh7kXUqO66GkPci6tR3XQn0bw9cahbm7gmVGj+YZp+s+I + 7m/s1sZ4Yw8R2l171X1Rv7KungsLpwvRgp4rOt490qyTq5hz8zYojHnftJ6roKMOd+1nqunc1YPCOpXW + nG8hTeoGcCsKSNoZHjcYYcEV311rcOi6NGdGvQ4fho25Arg5pXuJ2lk5Zjk08NUqzbc9uncMHVrVHJz2 + 6dyGig8Gius7iza3b275ByPStZhDqUOQQrAVgVr6DpzaleiJJhF9T1rCtGKXPtY5q8YxXtL2sZksTRSF + DTK7fxD4chsLJZC+Xx1964pkxRQrxrR5kGGxMMRDmiCqCp67uwFSy200AUyxOm7kZHUU2KVoXUjHBDYI + rV1rXrjWjAssccawrtARcZ960blzJJaGsnPmSS0H6Jrk2mzbQ3yHjntW5q2ipfWJ1GFwzsM7a4oegrof + DutfYblYrlt1u3BBPSuPEUXF+1p7/mcGKoSi/bUd1+JiSpxtKkOOtQgYPNd54i0OG7Q3+mIGj25YIOlc + Q6NySMY6itcPXjVjdG+FxUa8LrfsMHtUsTEfNkgimoqkHJxS9OlbPU6HroaVveBHBIq9p7ut0J8sId2X + CnqKwwTj0qzBO6KV3kKe1c9SldM5atFNNLqewx67Bf2q6boluryOm1mbonH61y13p1x4P1a2lupfPic7 + njQ4B/Cua0fWLnSrgyWsmGb9K7+BtIudGa81i8FzcyodhJyVPpivHnSeHlbeL+8+fqUHg5WteMvvf+RQ + 1/Tz4lsf7VsoEtbeJeQerVyej65f6JK/2KRVZ+CSM4rV0y3uJL6O1vLue30x3JAbgEelT+KtHsVuUj0W + My7Fy/l8gfjW1KcYfup6p/h6nTRnGk/q89YvbsvVk194YNx4ffW574PdN82CelcwNX1C/iisJJjIM7V3 + Gq015dmEW7TPsU/6vNbog0O68OtOkwtr+DoPU10xi6a9/XXTyOqEHSj+8967002JdJlHhbWVg1ONZYZV + 5xzjPeq/jXQEsphqVmVNtON21f4a5qe5mvH3TSPIw43H0rsPCniHT47aXS9aHmQOuEZhnaaVSnUpSVaO + r6ruTWo1aE1iIav7S7o4GTGfkzj3poYjHNbev6LcaRdZaIrazHdC57rWGR6DNejCanHmWx69KpGrBSWz + OosxqPii3MEc8UbWsPMZbb5qj9M1mapHp9rPA2m3Ty/KCwZcFH7is9JDCcxyMrEY44qIk5qY0rS0enYz + hRcZaPTsaGq6xd6zNHLeMrPGgQEDHArPJ9KTrS4Occ5rRRUVZG8YxirIUEnAHWl2tv2gZbpgVvaR4Vvd + ViadsWtoq7jcSjCirl2+gaNa+RbFrvUonDLcofkrGWIjzcsdWcssZBT9nD3n5dPUo2fhbVbq2a6W2KwK + u5mJxwOtbKyeF9CTzYS2pTPFjaRgRtWFqvijUtYYfaLghQMBIxtXH0FY4Y4PvWfsalT+I7eSMvq9auv3 + 0rLsv1ZtXHiTUJokijkWCKMnYsQ2kZ+lY8kzysXdmZieSxzmrV5YT6fHbzsyPHcJuRlOfwrPzXRTpwiv + dR1UqVOKvBDyx+gppYU6VAu3DbsjmmhCe1WbBksMUmDmrlnpt5evstYJJW/2FrpbDwHezW8lzezR2cUY + yfMIzWVTEU6fxM562Lo0fjkcfgmpI4JJThEZj7Amu3lsfB+htbtLdNqTty6RnhaiuPG8FrI66NpVvbIR + hWddzVj9ZnP+HBv10OZY6pU/g02/N6IxrTwtrF9ZmaHT5DGD/rCMVqN4CntbAXt7fWscfVkVwWA+lZV1 + 4q1q9jMUt/IIz/Ap2j9KyXmdyd8jOfQnNPkxEt5JempSp4yfxSUfRX/M29RsvD1tYsLXUZZ7sHK4iIU/ + WsmwumsbuK5SNHKHO1xkGquaQk9M8VvGnaPK3c6oUeWLjJt37nY3Pj/UZQiw29pbhOmxM1l3HivWbkkv + fyAHsvArCBwaXNZxwtGO0TGGAw8NoItSX91M2ZLiVz7uahMrk5LE/U1HmitlCK2R0qnGOyFyaechQfWo + 6M07FWHA09W+YexqPmnDOaGJo63xvn+07V8jD2sbcfSufsolnvreJxlZJVVuccE1r+J2Ei6ZIGyWs0Br + I09xHqFs7nCrKpJ9BmuWhpRRxYRWwqXa5qeLtNg0fxRqNjbLthiYBBnOOAawQ7BSB0PWuk8d3dve+MdR + uLaZZoXKkOhyD8orma3p6xVzbD3dGLlvZC5pcmm0tUbihjninieRfuuw+hqKjNDSYnFPc0YtYv7fAivJ + 1x6Oa0bbxXrUSEi+JAPRznNc9mlzWMsPSlvFHPPCUZ/FFfcdtb/ELVVwJkhlA9Vq+vjvT7tNt/pCvjGW + GDXneaXeR0Nc8sBRlsrHHPKMLJ3Ubel0ejy3XgzVECfNbntkbcGpLjwjZXmmx2+m6xGU3bwjMMk15pvw + c4qaKZlORKyEdCDWbwU4/BN/PUz/ALMqwt7Kq1bvqdXfeCdatLYssKSx4zlDk4rn7qyu7W3Cy20sYJ6l + Dg1PbeI9VhUwxX0pQ/ws2c10Vt8RJ2jWHUbGG5RRt6VV8VT3Sl+BXNj6O8VP00Zw7E7cZ6VHjJr0Ce68 + H6ragCFrO6dsZHQUXnw7JtxLpV/Fd5GcFgOKqONgtKicfUuOa046Vk4PzX6nC5OAkbcd801gc7R1rTvd + D1LTl3XFnIgz94DIqlGAMsQRj2rqjUjJXi7nfCtCavF3Ez5ceP0rbtribQNN+0xStHeXA+Uq3KiqGm24 + u73L8RRjcx9qnhQ61rIJ4gTk56KorKpaWj2W5hW5Ze7LZav/ACOmtvEMll4fE+sQRXstycIrgAhfXNRD + R9B1PS/t63T6dIxISOblXPtWHIW17XFjTi3j4A7Kg70+/mOsahHaWgxDGRHGB3965VRs7xdnu/I89YTl + d4Plb1dtkuitsR3ugX9pE0xt2e37TR8r+dY5QgZwa7bUtWufC9tb6NYyhyo3XCthlYntzVm6tNBu9PtZ + NTVdL1C6BI8kEqqjoWHbNVCvOKTmrp7f8MXDHVKai6kbqWzW/rb/ACPPq0bGSzhU/aIy+7j6VfvvDF9p + 0f2xY1urDqtxDyrCsV9smWjOD2WuhTjUXus7o1adePuPQv6nbWkMifYZzKjLk57Uia5qEOnvp0V1Its/ + 3o88VmEsnqDTc5Uk53dqr2aatLUv2KaSnrYvRFgg2gjnl/Su10zXZbizhi8tUkt1KxNFw7t71wSBiEjL + FdxGM9Oe9dzc6FeeC7W01eK9trgvggA559q5cVCMkk9+hxY6FOSUX8T2L0ran4Qkj1G7WG6uL1MAyHLI + aoxJKhj1GKcrrFy7futv3QfTNRWE/wDwkeuSahql8lswXfHuHysR0FbVhPBf2tzLqMfk3O7/AEW7AwgI + 6AVxS/d779f8jzql6K95e91/RenewyW2t7fT7KKCKaPW/NzLIv3h64qa4u4tNuN2pwG5jljKlu6t7inG + B4ybrVbgRXMaF7e4ToxHQGsPULnUNTmgv9RAW3yFZlXG4etZwXO9dv62MKUPay1ei/PyMpLqfyjYNdyj + TjJuK4yF5rqbrSdGOnJquiagsc9t8xVj1Ye1Q2trJbmS5jtVvNCkH7xlHzIO+Kx9at7O81OGDw/5sqOn + K4wAfSt21OSs7fl8zrk/bTSi+VL7vPm8yPWNduPE11aLeCCBVIQyhcD6k1ojSJvBeoR6ncW0Wp6Yw4kQ + +tT+H9T03TrWXRdesFjV2OZccg/0+tcnq2ov5k9hY3k76WJC0cbtwK0pxlN+zirR/Br1NacZVJexgrQX + 3Nd0+43xFqNhq+qPNp1iLSJv4c9awpBz0NSFSBvBIGeAe9Iu1jl2PPXHUV6cIqCsj2KVNU4qMdkNjiaZ + xGilmboBTZI3ico6lXBwQRyKerOjKy5Ug5Uiumt7ix8RRC21SRbbUQAsN3jCsB2f1PvRObjrbQmrVdP3 + rXXU5IqfSkrS1HS7zSblrO8iaJ+vI4Yeo9qzyCBnHetFJSV0bRmpK6Y2lFL1UnuKQZOBj8qZRfGqXYsP + sEdwwts5KA9a35dP0Ow8NRXbXZk1GT7sa9q5Mo0Zw6kH0IoHznkkAVjOle3K7fqc86N7crsr3dupO80k + gyMge1ORlRQej54NQhtoKg9a6rwfoVlql2Gu7lAVP+rJxmprVI0oOTJxFaGHpuctkTaDoF9r8qNcSkWy + dNxrpdQ1vT/CcLW1oEefG0gVS8Va4NDH2LTU2gjl/SvObm4e4dpJWLuTyTXm0qE8W1OppHojxqOGnmDV + WrpDoixqOoSaleNPJ95jwBXWaELqK1/4nDD7AV431woJGCDjFWbjU7u5iSKWZjGgwFzxXoVsPzwUI6L+ + tj1cRhPaQVKFkvy9Dc1LxGtsZrXS8LA3G7FcxLK8jFnYsT3NNJpp+tbUqMKa903oYeFFWjv3ENJjvT0X + e6ruAycZNXtR0trFInWRXVxk4PSteZJ2N20nZjLW2iktZJXcAjoKdZarcaejpFtIb1FUFBYhR3rVn8P3 + 0Nit3szGfSs5uK0m9yJyhHSb3II9Pvr/AHziMkdS1USpRyrDkHmtSHXb23sWtY2AU8ZxzVVdOvZ4mnED + lOpbFEZSV+eyXQUZSTfPZLoVc4bOK6+zlttV0tbGC3BumGK5Dk/Wpra6ntJRJBIyP6ilWpe0Wm6JxFH2 + sdHqjoPB+iW+sXrC6dVRR0z1qx4p0JPD1wHsrkqH/hB5rZ1zwUmjWEd9Y3gVkXlg3BPtXCXF3c6hcJ9o + mLnO3JNcdGbxFT2sJe72OKjN4mr7WEvd6ofpunzapfLArfMx5JrevIdV8Gt5UU6mOYdMVJdeGrjStNh1 + W0uNrAZ61zl9qV3qMoe5lLkcDNap+3leLTh1RspfWJ3i04dUMigub+5IjUySuc13mmanpul+HZtP1exK + XODjcvWsrRvD2r2tiuuWgjkjTllPpWd4i8RSa7KhkgWJk44rOqliJqEfhXboZVf9pmqcfhW7T1TMmQxS + TsUXCFshfau1sLLw5qfhyWPzlt7uJc/N1NYOgiLTb6G71G1kNq38e3im+JbrS7vVWfSY2jhI59zV1E6k + lCN1bqXVTqzVON1bqjElVUlOCGUcA1Fiup8JWWl3GoMNTkVExwGHWsrW7S0h1iSDT5PMizwRXRGsnN07 + bHTCunUdK23Uy8VLBNJBKJInKsO4OK171tMg0ZLdImN7/ExHSsQY71onzLVGqfMtUdVZ66t6RBfMWyMD + PSk1vwvLaxLc2+Hjfn5e1cwjFWBHUV1Gh+JPJkEF4d1uRjB5rhqUZ0Xz0fuPOrUKlB+0obdUcuRtbBHS + krtNc8OrdKb7TwojYZ2iuOZGRipBBFdNGvGqro6sNiYV43juXLmayewt44Yis6/6xj3qkPbrSDrUgIDD + aa0SsbpKOh0/h7xS+jxPBLH5sLDoapXsMmoySXdvasIjydo6UaZoN/dxG8Fq72ycsQO1eiHXNF0bwwsu + nwxSTEhXgc8+9eXWqRpVL0Y3k9zxcRWhQq81CPNJuzORtvA91ceHW1dJVIUZ2UeHLDSdUs7jT7iMpqT/ + AOpcsAuafpJ1bW7qe10vfHbyHe8QbCgVa8QaToum2MLWF6Wv0P7xV6g0nUnzck3q9rdPUmVapzOlUl7z + 1VunqcnfWE2m3bW9wo3gkcdD7io40aWVIlIBY4BNdadU0vXdIaLVt41SJdsEijhh7+9c5LZzLKls8RSX + GV3cZFdVOq5K09Gd1GvKScais1/V0W9W0efQpYo2lSVnQP8AIc4+uKZp16trdRXEq+YiNynY1rWPicaZ + 4euNIn0yKSSTOJm5Irms7CGAJUnnPQVMYuacZr/gihGVSLjUXz7np13qUfi+0jsNLs1DgDLNxsrNsdZl + 8IT3GmTwRTyPgb88DNclYapcWMu+2keJG4cKcZFegC407xHpX2HSrBpb1k+aV/4T7mvOq0fY+61eLPHr + Yb6t+7avTf4ebZzvi7w1DplvDqUN2kksx3OgPQnniuQZHmXdgYHau10v7N4c1iS38QW/nsEwg+8FrL8Q + aHf22/Uks2hsZjuVQc7R711Yety2pyd+z7nbhcQ4NU5u/Z9H5IzX1S3TR1soLNRM335epP0rHz5bgSA8 + Gnea0LBhgnqKgd2dyzHJNejCCWx6tOCje3U09T1+91S0gtZ5MwwDCDHNZXbrSU/aA2CRjHWqjGMFaJcK + cKa5YqxPp9nJqN9BaRMivMwUM5wATWh4i8O3HhvUEs7mWKV2QPmM9AazLaKaWZI4EdpSflCDJz7V0i6X + bWcLXviC6le4dMxWwbLsR03E9BWVSpySWvy6mFas6c076dratmXo+gX+sXG2yj2qvJmkO1V/E1tSyaDo + KI8R/tLVVJEjN/qlOeo9azdT8S3epQJa5S2s4zmOCJdoBx1OOpqlpGmvrWpLZrcw25ZSd8zYHA/nUOE5 + 61HZdl+rMpU6lVc1Z8sey/V/5D9U8QX2pSOZZisb/wDLFPlQfhWVknIJ4p00XkzvFuVyrFcocg/So66Y + QjBWijsp04U42grIUEg5FKCWPPOaQDNWbW0muXVIIXklPQKM020ldlSkoq7ICzFApYkL0HYU6KB5XCIr + Mx6BRmu003wI7Itzq1wLW36tyMir0+ueHfDSmLSYFurlekzfdriljU3y0lzP8PvPNnmUW+TDxc35bfeY + Wk+CtR1BfMdRbwd5JO1biab4V8OPm/uRezgZCJyK5jU/Fmqal5iSXBjic5McfArGLZG5izE9DS9hXq/x + JWXZf5k/VsVX1rT5V2j/AJnWv45msriT+xraO2iYYwygmubvNWvr6R3uLmRy55GeKoliaSuinhqdPVI7 + KOCo0tYx179RSaXcaTFHGOvNbnUISatWcMM19BDLMI4XZQ8pXOwHqce1V9uT0q7aaRf3qlre0lkUclgp + wPxqZNJauxE5KMdXYv8Aijw63h/UhCsvnQSKHhlxjcKwiRn5c4969Gsk/wCEq8FSWLAf2jpuSuTklPT1 + 9q8/8oZfe+0qcbT1NYYaq5Jxnuv6uceCxEpxdOp8UXZ+fZ/MgpaSiuk7y2My+YYoHChVPy87ffOKe1vd + Q3jW8itHMV5VjjjGf5UyC6mgDtE7FWi8twWxwfoelRPPNO/mySMzgAbiecAY/lSJsyxDDLcJuDRp9ni3 + gHgsAf1PNdLa+CJLnSodSm1S1ginG4GQ459K4765qQyybAjO20dFLcVlVhOVuSVjCvTqzt7OXL8rnWDw + lpi483xHZg99pzTx4a8PpzJ4kiP+6lcbu96M+9Zewqv/AJeP7kYPC13vVf3L/I7270fw4Utw2v5ATaPl + zx/SoF0Lw1uwdfA/4BXFZJozUrCzSt7R/gRHA1Ure1f4f5HbWvh3w9cKS3iBYznoy1CPDOkSajJbprsI + jVQVkboTXHbqXdT+rVOlR/gV9UrK/wC9f3I7Y+Cbd2Ii12yb6sBVdPA95cTtFb3lrJt6nzAK5ISMO5p6 + 3EifdkYH2NL2FdbVPwEsNiltVv8AI6e78DaxasI0ijnz3jYGs+58NaxbgCXTJVA5yozmqEOp3kbZS8nU + +okNaEPivW4gETUZiM/xNn+dCjiY9U/vQKONj1i/vRnS2k8TFXtZkYeoNQYx65rq4/HerKuJvss+3rvj + BJpyeK9Lmj2XmgW7knJeMlTR7Wst4X9GCxGJj8VO/o/87HJYPpSZ5rtGbwXeZ2td2LkdSNwBqJ/Cdrcy + ouj6tbXZZfmErBCD9DTWKiviTXqhrMKe1SLj6r9djkaPatyfwpqsDOv2N5SuctCd4H5VjSQSQkh0ZSOM + MuK2hUhP4WdVOvTqfA7kfSlzSHikrQ1JFbmrdvqN3at/o9xLGf8AZY1RBpwOKmUVLRomVOM1Zq522meP + tQtkEF7El3CBgBxzWst34O1+NvtMI0+THXOMmvNVlZSTnJxjmmrIenXNccsDBvmh7r8jzKmVUm+am3B+ + TPRZvBFwNJlfR7uOeOU5687fSsefT7nQtCMEltIl3cn522n5VHv71j2GrXenNutb5oynzbQxwfw7119h + 8RZGxHqtpHcoRguoAP5Vzyjiaf8AeX3M5akcbR7VI3v2Zj6fDELGOxspV+3XjbZHPAjXvk1paTYReHxf + atO8c8NsTFbuOkj9MitM2HhrxDYz/wBnTrb3s5GFJ2lefSsfxF4d17TdPtrLd9osYRldg7moVZVHyN8t + 97/18jNYmNeXs3Llbeqlo/v/AAMnSIl1LU59Q1Fs28GZpmPQnsPxNN/f+KNez91ZDnrxGg/wFN1K6itr + CDSLYMCMPckjBaQ9voKmvD/YGjLaIwF/eqDMR1jj7L9T3rttrdbvRenc9HrzR3ekfJd/68iSbW7k6p9j + 0WRorJF8oITlCo6sw96s3d14c1WEx+S1hqMeI0li5ilPQsf7tYDY0+wCD/j6uACSD9xPT8ai06FXmMsk + QlghG+RC+3cPTNP2EXqtLfiW8LC3NHS3Vbv17/Mv6x4d1LRwJLhBLbsAVuITuRh9axyPl4/Kui0TVdRg + e8ubOSMWMP7yS1uHyjrn7u09TVtbbRPEmDakaZqsz4WA/wCox9e1CqyhpPVd1+qJVepS0qq67r9V0OUR + ySN3IHr2q007ShYzLIYl+6GPA/CjVNLudKvntblVEsZ5KHK/mKqqxjbpmtvdkro6k4zSlHU7K68RW+pa + HY6WNPhgeEhTN6j1rct7uWxWHTLsJf6XGolk8sAlR259q86jlYkc/Ke1aFpez22+O2mYJIMOpPUVw1cM + rWR5tfBq1lt/XU6y4t21KZ7+wZ5NKgcHyZX/ADAFWJEfVik9vBI2kQODJbZGUHfHtWRFd6ff6jp1rZGS + xj4Wfc2VJzW14n1ODR5pbLS28uWRMSeWco4I/Q1xSjJSUEtTzqimpxpxWvTyXn5+ZDqOp/2WGi8NXLyW + M0R82IruEZP16UDRH0rQYfEGj6kGn2jzEbHfqK5O1vXt0K2szJM/ysD0NTPd7WEEzunHIU/KTXQ6Djov + n5nY8NKKUU/Xz9RrySavPLc3Uy/aMEkN0NYlzbSrmXaVXPT2rWkYWmHR1kMikOD0xVExSOGeSYrgZQMf + ve1dlN222O+j7u2iM+R8KIyWKA8Z7fSogm5iMgADPNa02mPbwF7tZIZXUNCCvDj61lbcMQw59K6YSTWh + 105qS0H25d32LH5pwQAe3uKYPlbGcnPBFadwU1N0ewshbyxRAOsbk78dSB2qpaS3AMqwFNzqVbIGcexP + Smncad0dBpmr2t3a/wBk65EJATtiu2bLQE8DnutZeueH7nRboJKyyRMN0c8Zyrr2INZiKxbCqWY9q63R + NXWKz/szVbd7nSnbDH+KJu2D6e1c006T5obdV/kcVSEsPL2lLVdV+q8/zOOQfONq5bPAx1qdoprC7ja4 + gKNncEcYyK6DX/DFxoc0V7ayCazk+eCZOcdxn3pmu+J5Nd0+1t7q0j+1RDDXC8Fh2q1W57OGqe5rHEe1 + 5ZU1eL37oy9VvmvpklMCxjGFC96oRwvNIEjUsx7AVMsMroCVfygcF8cCurj1HRvDWnf6Awvb24jwzsOI + j7e9Ep+zSjBXY6tb2SUKcbt/1qR/2NpvhuzS51SdZ7uVMx26fw59a5dbiRbkzwkwnOVwelMllluZWlnl + ZnJzz3pFO913cqDz9KdOk4pubu2OjRcU5VHzN/d8kdd4WtpNc1bzNSjMtoFw8p6J71h+IYNOstYmi0+Y + TwKeGHQ1bv8AxGP7OXTNNT7PajBc/wATHvz6VzbE56596zo0pc7m9F2McPRqOo6kvdWyQMc0nalNN5JA + AyfSuyx6FgzyOM0pjKkErn1Her0cM+k3Fvc3FvujbkAjgimahKt5dyT20biPHOe1F9RKV3psP1C8s54I + 4bW18vbyXY5Of8Kbpt8trKROu+NhjnnFVG8ryFIJ83PIqI0cqasCirWJrgIJi8JwhORWvH4ovE0s2Rwy + H1HSsaDBfaQMH1pGASQgcgGpnTjO3Mr2JqUoVEuZXsWPst15X2nyH2dd2OK128W3X9j/ANnpDGoPBbHN + aUfi61j0L7GbVWk243VyKS7LhZducNnFYRTq39pHbY5oKVa/tYWs9ANrcrGZmhcJ/eIqDrXT6h4ml1Oy + jsLe0Ve2QOTWFeaddWO37TEU3DIzWtOpJ6TVmb0qknpUVn2LV5rl9dWy2slwzRL0Ga2tA8M2mqaZJcS3 + IVlBPDYxXJYz1FSxXE0GfKkZM8cGlOi+TlpvlFOh7nLSfKXru/u4kewF0z26HAGam0vTZmkjuZrOSS1z + 8zBcjFU9O0251ScxW67nHPJrttN8UT+HNPfT9R075ipVWx1rGvNwjyUld9TnxNSVOPJSScuvR+pDrutW + +maZHaaHeusUo/eRA5ArmLDRtQ1GNpreBpFB5NNt7K61m+kFrDuZiWwO1djo/iufwzYPpmo6aQCCA2Ot + ZPmoQ5aSvLr3MXzYanyUfen1vuZmq+LJpfD0eiT6fHDJFwzjqaxtDgtnv4mvcpBnJOKiVJ9a1YqrfPI3 + G411OsXcejaKul3NjGbrHEi9KqVqcVTgtZblStSiqUFrLez28zO8YXmmPcpDpiLtUDLjvWNaqtnA9xMM + uRhAahsoFnlZ5CAqc/Woryfz5iV4QdBXTSpqEVTT2OuhSVKCpp3sRSSPK5djkmm0DpRWx0Cir02lXtna + x3NxbOkMn3XNUQMAHPNal9r2o6laQWl3cl4IfuqB/P1qZc11YiXNdcu3Uv6F4gls5BbzNm2Y4OecCt3V + /DkOqRfa9NKbFXLH1rgh97luPWuj8O+IH0ucJMTJbE/MhrhxFCUX7Wjv+Z5mLws4S9vh9Jdu5gywtE7I + 64YHpXQad4N1PUNKk1FEAiQZAPeut1fRLDxLaC40ooJQu5vauVbXNZ02yfSvOKxD5SOmRURxU68LU9Jd + UyYY2piYWo6ST1TOg8PeOY9H0WWwu7cMyAhNo6/WszQ9Cl8RahNdTOlrZLmR2cYGPQU3w74fjv5ft2rS + G301PmaQj7x9BV3Wr+78QRtDpEHl6XYLjK8Fh2JrLljGclS0b3fRHPKMIVZRoaN/FLovTzJLy/GrXkOk + +HLRrfygQZVOC+OpzTdJ1nTNMSXTdS08S3EjbHnY/dPrWTZeKvs+jzWLW6rOFxDcR/K6H61hOxYPJO5a + YnPzHk1pHDXTjJWX4vzN6eDunTkrJeerfe5pavYppmqMkFxHOB8weM8DNb2i6tpOoW08WuM6zhMRTRjJ + zXFfaWUMF6MMHNOizG6kck4I9q6J0OeCUnqup1VcN7Smoyeq6mre6dd26pJdxypA5PlSOuN4ra0O+h1D + TW0Ce3s7QOCxvZeuB6e9WtN8RWup2zW/iaV5liTFsiL0PbOKxNW0W+tkSW5UiBwTF7D3rnU+b93U0fT/ + AIByc7n+6q6NbP8Ay7mPMoguZIon3xK2BIBwa0tK12/0afzLGXy8j5sCtq2uZvEul23h7TNLtoZY13PM + xGWx6Vy97YXek30lndJslTlge9bJxq3hNa9jpjONZOlVWvby7npdjp2kazoUmrX135k5HzyM2Nh9K5C/ + 8Z3/APZk2jxyJJaglVZhkge1cz9ulELQpK6xMeUB4qsWzWdHBKMm5u66eRhQyxRm5VHzK+i7AzZpppaA + Prn0FehsestENHTPetrRfDt5rUilR5Nt/FcOPkX8a2NL8MWtrYLrGvT+RaMm+CNeTKR/DjtVLXPFk+oQ + /YbNfsemKcpAnGfcnvXNKrKo+Wl9/wDW5wSxM60nTw/zfRf5su3GqaZ4ZD2eisLm8Awb4jhT/s/41ys9 + 5LczyT3MjTTOSSzHPPrVfeeR6jGTTRWtOjGGu77nRRw0aWu7e7e51b+CNQXw4NZM8JTyxL5Wedh756fh + XK9Oauvqd/Jp62bXMzWiH5Y9x21Rqqamr87uVRjVjf2jT109Bc4Ix2qWC3nupfLhRpHb+FeSa6TQ/Bd9 + qZzcOLODaHDzcbx7VvSa1oHhRTDpEQu74LtaY8qD35/wrnqYtJ8lJc0v63OWvj0pezornl5bL1ZQ0jwG + 8kf2jWJvsluF3ZyKvSeKtI8NobfRoEuJlGBMw+WuR1bxFqOsMWvLpm9Il4UfhWMWJNZrCTqu9d38lsYr + AVcQ+bFyv/dW3/BNfV9e1LVpGku7ksCc7FOF/KsfOaM0V3QhGCtFWPTp0oU48sFZBk9jSqpbOOwzSVND + byzvsjQs2QAoHJzVN2LbS3IafhioHQYrZbw+9hLAdYkFnE77XA+aROM5KipbTWbDR5pJLKwjuZgxCTXQ + 3Lt7EL2NZupde6rmLr3X7tc35feYZhkUKzIVDDgsMAit9dHsba1hl1LVoVRxuWG1G9/x7CsvUNVvdUff + cyllBJVQMBQew9qoE5ocZyS1sEo1JpXfL3sdJFrem6dG8WnaVFJIT8txdfMw9ML0FUb/AMQ6pqIC3F5I + UXpGh2qB9BWTuOKM0o0YJ3tdihhacXzWu+71Og8Ka0+ia7BcZPkudkw9VNXvHuhDSta8+Eqba7HmoV6D + PauULszAk9sV6NZwv4p+HskJIa70/LKTjO3t79M1zV/3VWNVbPRnFi/9nrxxC2fuy/R/Jnmx60lPcEHm + mV3HqoMmiiigAo60uDjODircOnXEqh8bVIyCT2obsJtLcp4oqd7WWO6+zyFVfOCSwwPxp7Wqxy+W93CB + jJZcsB+lF0F0VaWpZBCsQCSFpNx/hwMVDQMM0uak8oeSJPMUEnGzBz9akaACTHnIARncykD+VArlfNGa + swQCS48v7TCoCkh2BIJx06UCzut7wrCWbdtIABOetAXK9FBBUkEEEdQaOaADNLuPrTaWgLDtxpySlOQx + B9RUdFKyFZM09P1e/sZhJa3jxEHJ+fGa24vG91IBHqNrbX0fpJGAT+IrkSSacGKng47VjPD056tHPUwl + Go7yirnWi+8L6kMXFhLp8rMPngbcoH0NSTeErG8Yf2Nrdvck4xHMfLYVxwYg05ZGB4JHPao+ryj8Emvx + Mfqk4fwqjXk9V+Ov4mvfeH9TsZGF1YSoiAjfGu4Ej3rI5/KtrTvFOq6bIotr12QAgJKcrz7Hir0euaRf + iOHV9JRVQ5ae0O12+vbrRz1Y/Er+n+Q1UxFP443Xl/k/8zmM0V07eG7DUQ8mjapE7bwqWs/ySH8elY99 + pN5phK31nNE5bAbHymtIVoy06m1PE05uyevZ6MoZ9aVXZPumm4I6iitDeyLMU7B87tpHOQea6XRvG+qa + eyxmb7TAvPlzc4/GuRzigHHTrWVShCorSRzVsLSrR5Zq56tb6l4U8VzMb2BLO6XLBmOMn61zep+C9SJn + 1G3Ju7TLMJCfmYetcgJiox+tdJonjC/0Yxqk5uIFH+olyVrj+rVaOtF6dmed9Sr4V82Glddn+jOfcOsp + 80Nv9+tX7uytylnBYSm4nePfNtHCn0ruI7zw34tEkl7H9m1N/wB3DFGNoz256Hmuf1HwrrHhy+EcLea8 + kZZvIGfl7g1pDEqT5Ze6+xtTxynLkmuSS6PZ/M56e8ea3hs1RFWM4+QcuferdyBptu9jcWub/IJl352L + joMd6rGSNIZh5G66kbAYfdjX296uadbG1jGp3lj9qtASjKz459TXQ7WOyVkv61Zp215e+HbKKC+t7a6s + b9RIYnILY/3hyppbrRbDUIfteiXSySM+BpxBMqj29ayLZmhl/tNY4ZIopMeRKcjn+H3rRstNuZNOuvEV + vd21m1vLlIEk2uP92sJQ5feTs/wfyOWcOR86dn+DfZr9TEkikgkKMrK4OCpGCKejNgMpw1dDZXun+IDJ + Hrcotr1zuS+xwTj7rAevrWVqWk3mmMjXERSOTmOT+Fx6g01Uu+WSszSFe8vZ1FaX5+hVWU7uTk+tOF3I + shcsWJGMk1W3evWhie1aciN+Rbli32yToskhSMsNzgZ2j1re1W2tdLuxFZ36ahA6ht4XkH0rmgxABHWr + cEmcF3xjoMdamcLu5nUptu99OxaSIHEzYKK3zR5wQKtLZtEkerPbxzacHx5MkgBI6HirFtFDcLBc31vK + tiGKeZDgsPTdVjULlIi8Vi8d5buPlaSPmP8AwNc8pu9kckqr5uVf18+5kaldXU9v5iMx0/diOJpAxj9v + asbaVVpAARnBB5xVyZMviLOO/tTxp8otzdCN3t1YAuB8ufQ10RagjshKNONiC3srh1a4t0k8tfvMO319 + q0bfTrbU4IksjJHqueYWwiFR6HPJqw0qaX5GoaddJluHgcZx9R0xWRezm9uGnWMIzHJVR+tSpSntoZ80 + 6m2i7/ox95bKmzyLeS3miX98sjDLHuR7VTkvppn8ySRi4GBgYz9aknvJ7xkW7nZvLXarHkgelMlh8ohW + IDnkY7itUu5vGNvi3N3w34lbTBJa3cf2jT5htkibnb7jPQ0viPwutjDFqGnyCewnG5WXkx+zVk2kEtzE + wjWNDGpLljgsK1/DniJ9JdreZPO064+WZCMkDuR6GuepBwk6lLfqu/8AwTiq0pU5utQ36rv/AMEpXniW + 5uNHg0qG2ihhQYcoMlz65rCMfy7i2CP4fWus8UeHo9KMV/YSLLptyN0TA/Mvsa5YjY3zjryK2oSg43h1 + OnCzpSp81JaP8yM5bLZ6dfakd8n5RgU0nJ9q2dL0aLUdMvbltRt7eW3AZYZTgyD29TW0pKKuzonONNc0 + jKht5bmTy4Imkc/wqMmonjZWIIwV6g9RW/4e1+58M3Us0VrE8rJtHmrynvTm0HXNatLvXWt8xj52fGA3 + 0FQ6vLL3tEZuu4TfPZR6O+7OcoVirAg4I6Gg8H2pDW50HR6bHqPiNBYF1EIJPmMOlY7GfT7me0Ei43bG + I5BqKG7uLdXWGV0DjDBTjNR+XIylwrMB1bFZqNm+xmoOLd9i5eaVNZRRXEmHgk/iXmty90jTj4fiuraV + d+Mnnms7Rr2Nz9gv5SLU5xk8KfWs27T7NK8EUxeHORg9qylCc5JXtb8TCcKlSSXNZp/eisacsUjruWNm + A6kCm9a7DQdS02K3Wwn2nzODIR92tatRwjdK5tXqypRvFXOSj2713g7c811moT+HYtDjW2TddMOfasLW + rW2tL9o7WUSJ1zUOmm1F/Ebsfuc/NWc0qkVPXQzqRVWKqXemththevp94lwihivY1pX17qnim4G2DftH + CoKueKptEdIV0xRuA+Yis/RfENzogcQxo5bpu7VN3OPtYx97zIu6kPbQh73mLonhy81xZHgIVU6E96yr + iFra5kgfG5Dg4NaWn+Ir3TrGW0gkxHJwfaslmLsWZiWJySa1h7TnfNt0N6ftfaS5/h6F/SNUn0m9W5tz + yvVfWtPxB4muPEMkQeFY9vACjqa5vNSCQghgSD2NOVGLlz21HKhBz9pbVHb6ZpHiDw3DFq8UCPCw3MvU + gVn+LPFUniSeA/Z1hWJcYA6mq6eMdYOmPp7XBeFhgbuStJomh32olrq3RHWH52DHrXJGlyzdWta62OGF + Fxm62ISutmjS0zw1DLoT6suoCGeLkKTiucurq61O7BmkaUjj8Kva9qwv5USO38gp8rheATVdIbrSrdLm + SNQs6/KGPOK1pRkvfnu9vI2oxmrzqPV7LsGr/ZYfKhtGzhRvI9aysc05iSxJ6mkxXTFWVjqhHljYSlxQ + FJ7ZrsdCj0S30i5i1y0mjmkG6GUrwfTmoq1fZq9rmdet7KN7X8kcdS8jp0NSOo3sEyVzwfWmnOeKu5te + 6EqVWwACARUVPTk4oYmbOkavc6ROGRz5ZI3JnqK7qOx0/wAclWgAgaMfP615qi+edoIDDnJ71La6hd6f + KTbTtE2MHacZrz6+F9o+eDtI8zFYL2r9pSfLNdTrdd1W4vruHw+THBZW77C6jrjuawb95dEuLiysb8vb + SDDbTw31rrNN1nw9f+Fp4L+NYbqJN2e8h9jXAExrI5zwfug1OFT1i1a34+Zngo705Rso9OjfcdaWrXLO + Q2No3HNRhN6u5bGOgPenRHy8s2T7DvWpouhX/iO5aCziDMi7mY8AD0rslNR96T0PRnUVNOc3ZIw1HPTP + tVy2jlndYIxlmOAMd6llsrmw1JrSaLy7gHaVau7t7a08CWMd7c+XdXlxH8icHFY18QopcurexzYrGKnF + ciu5bIht9DsvCtk1xrhWS5kj3Qxg5z/hTdF1TUbvT7m3u7R5tLlbDzFcmFf9msmz03WfFt1NelS0EeXO + 9sDA7DNS6t4sjsbd9N0INBayR7Zg/OG749K43RlJ8u8nv5HnSoTm+V+9N79o+hX8QppGkXMDaDfTNMBk + yKcbf/r1zNxdS3UzTTzPJKxyWY5JNQvICPVsnLetR5x0r06VLkjq7vuezQoezilJ3fd7js+tGaaOSKv6 + bp97qdx9jsYWnmfnao5wO+e1aNpK7NpSUVdkEMDzypFGN0jsFUe9dtbWFl4LiW71VUm1lTuitMhl2kdT + 6UguNN8G2ckVuBc63KoDNIgK2/qMdz71yFzdT31w808pkmb7ztzn6Vye9X20j+f/AADz3z4t2WkPxf8A + wPzLGqald6rO9xdybt3KIhwsftjtWfJs+7HvJPXdjAPtWtomg3GsTqglS2tznNxNwgP1qe+mh+zR6HY2 + UEs6OQ1zFlvNPt6VqqkIvkj0/A3jVhB+zgtt/JHN0VpX2lXOmIhvLWRPNXKMeBnvj1rNreMlJXR1QnGa + vF6BQOTiikplGtPrt9eabb6dcXRFvbKRGAOT7E96ytxzkHmjJxjPFJUxhGOyIhTjDSKsGaSl61LDFLI/ + lxIzu3G1F3GqKbsRAE1ZtLWW7lEEEDSyucKADxWxHodtYx+fqt3HFKjKwsmBLSxnrhh0NMufELRW9xYa + ZGlpYyyFgcZkxnIBbrxisvaOWkEYOs56Ulfz6f8AB+Q5tGt9FubeTWZFkRhua3tpQZFPYN6UybxE8Vvc + WOmRJbWcrE5YBpcZzgvWGzl2LE5YnJJ603nvT9nfWeoKhza1Hd/h9w95Glcu7s7HqWOc02jJoJHGB+ta + G9gJz1OaBjPIzRS4ZcHDDPQ+tMYlLjjNPeKSPb5ild43AnuPWpiIuBAkkjA43kcEemKQXEgtpbk4ghll + IXcwVScAdfwrsPBTPp/isafeE2sVymyRN2c5GVHX3/WuUa/vJIFhe4ZYYhtCD5eD16delW/s8kWmWmpx + GU5lMTMSMBl5AHfpisK8OeDi+pyYqn7Wm6cuuhd8TaJHpPie5tJjJFb53RMV5Kn61gSLFHcFV/exBuuf + vCu+8cwWeo6Lp2uWwnMsiBZmfcV6dMn3zXCxzCGVJRbxMAMbZOVY+p5qMLUc6ab3WhngKrqUE3utH6ok + N5GI9kVjAD03MCzf4UW9ncywgJ5aRy5wX4Bx157Ukl9PPE0W+GKLO7YiBf5VTbn+LPtXQkdcU7f0yy0k + 6xrE9y3lY+4r5A/ClFvAlyEe7iMe3dvUMRn06ZzVSrUcoRFxKqHH9wZB+vWmU0DxW8bRyLNvjLcgRkED + 8ai8xPMLBMj0NNknmm2iWRnC9NxzimdcjNAJdyxaxiTePs8kxAzhGxgflU9rbu8m5LKd9pDEoxyB27VR + 5UjBIPtSiWRfuyOPoxosJpk1w8TMRFHIp3HJd8n+VXjp8tvHPNNpxKR4Dbm+7+INZXPXPNSCSQxlTIwV + jhsk4osDT6EyC3ac7osx4ztWXGOfU0kyQvkxK0WD0Zsk/lVZhg9QfpSUWHYkjwZFzIUGclsZxVm9nmfZ + G13HdJ1DBeR9SQDVKrIuiCmVicL2aMfr60MGupqJYXVvOJ5dKhuY2jwVibIGR14JwapSpZDeWt7qAlco + Mhh/SmpciKWXEWN3/PGQjb9KdDcsYjm/kjYnaUdSwx65qLO9zJKV7v8Ar8yCG3imQ5uUjk5+VwQMfWme + RKNxVdwU4LLyKllRhbriW3dQSflPzfjnmpo4rM2ayEzQyr99gcjGeoH/ANeqvYvmtqZ5JJyetGa0EtJJ + R5dvPDOrEHDEKx/PmknjtkkCT2s9pIPvYO4fkef1NHMtg51exRpc47Aj3qSWJFK+VMsob0BBHsQaZ5Un + lGTadgbaT70y7jKUHB4pM0UwJY3YOMNgjnIODW9p3i6/s/LjlYXtpHwsFwNy1zlLms504zVpIyqUadVW + mrnXbvDusLcTuz6XesCY41G6Hp09eaz9S8MahptlFeSRrJby/dkhO9fbpWJ5hJ5OT61qabrV/pjoLa5Z + cNkxOcoT7g8Vl7OcPgfyf+ZzujVpfw5XXZ/o/wDhzLIx1B/Kk4zyK64ajoGu3rSa1A1lNjaJLMfIT6sP + 8Kz9T8NXlnYrfx7ZdPkf9zJGckjtkdRTjWV+WSsyoYpX5ai5X57fJ9TA70u7nOMUEEdRRW51E0c5V1Ls + fqOtdZoXjfUdGZyzfbI5V24kbLIO2D/SuNpVdlbK8GsalGFRWkjnr4anWjyzVz0ybTfDet6KG0d3OryH + iP8AiZj13Dpj3FcnrGjatopW1vQ6x5BG1sxsfrWZaXjWrpNFcPDcKcq8Zxj8fWu003xvBqDxw+JIvtUU + S7YsKNpY92/xrjcKtD4fej+J5rp4jCu8Pfj2e/yMuHRU1y43aPb5FpCrzRzuB5j/AMW0elLJb3fjHW5B + Z2ltaNHFkwhsD5euPetjXPCKWMttJol4Z7i6ywghPIU5OVI7duayk1WO30J9GfSzFfeZt+0GQqy+uaUa + vNrDX9O9+4Qr+0XPSd+1913b7j4LS38T6gIs22mG2tyrMD8sjLUWnarJeNDpWrXLSaRDJ8xUD5QPQ9cV + e1e0m0qwtNAgFpcuw86SeFNzqD2bH86oate2iW8Oh6eYDECDLcgY8wnv7YpL39Ft08vMIfvFZap7eS/m + v59EGv8AhpbWQXGkTC9sWXeDH8xiH+1XNniu2m1FPBk8dvo+oJeGaMG5UjcmfT603UdB0vVdJ/tTSJkh + uVBM9pI43Z7kVVOu4Jc+z2f+ZVHFyppKrrF7S/zXT1OLBINa2lT2VtNbyyQm4nWT5opf9WV9yOayWUo5 + V1KsOqkcip4pCuMDBHeuua5kejUjzxOrMklxeSiw2RvNksgwEI9Fz1xWZfRtExVDsfo6qcA0HVZZrBbZ + QojjfKzEfMD6E9qp3ExkARwEcclifvf/AF65YQaZw0qcoyNzTNGs77Rbi+N4Bc2jBpLRjgunfB9a0rqQ + zFNJ0S7kt/D15IoaWdAVjc9RuPSuI+1lp1YjcARkZwGx6/Wuk07Up9USXRIJo7TTLiUFzKMiI9Tg9uam + pTkveb0/IitRnF87d1vrsv8ANroUNesE0HVZrFLqO6QAAyJzwex96yQzJLsiDsrc7MZJrY1O2tdKu7uw + gaC/JwFucn5Py4zW9p9tP4FntNSvIIL60u48bkwTGevFWqvLFdW9vM1+sclNW1k9ul/8jhHjXaGzknPy + +nsasaZLaW19EdQhea0J/eKhw2Paty90ybxBLealptmI4txYQKckjua1dPg0fTPDpl1KKK6juAVOziWG + T0P+NE8SuW1rvsFTFx5LWu9mlujkLqECYXIiuRpby4R2GCRnp9auarb2D6oo0eZ/sOxSZZFICNjkE0yL + UruDTJ7ESEafcOB+8Tds56r6H6VU1OJbK6ltbK++12jqr7kBAPHceoraN29f6/4JvBNyV/69fMqyXThT + EZWZUJAXOQPpVdleV8nLH0A7UFdrcj/69dJ4b8QWGjPdJc6cLiKZSoc/fStJNwV4q5tUbpxvCN2cuVI+ + tWbK8ls7qK6ikAuInDIWUEcexp15b+XcHcwxIN6YIOAfWqeCDWmkkaaTjqdnJZan40ivtelmtE8hcGMY + Xp/nvWRF4i1WDSW0yG7Zbdj0z09h7VnR3ZhGImIDriRP4f8A6/rWtrOm6bb2djLpuoPeXE6b5o1T/V1z + cii+WWq6abHH7OMJKE1eP2VbaxmXej3tpbRXcsDiGXJVyOKh0+5itb6OaaATxA/NGeMitKXxLqk+jrpT + yq9spwAV5/OqN3pl5YQQvc2zRJMMxsw61rCUrctS12bwlJrlq2u9rdi/4l0tLaWG8tURLO6UPGobcV9j + T9D8QRWGn3VhcWazrMuEI6g1m6csNzfwQX07pbbsE54ApdYsodO1OSC2nEsSnKuDS5U17KepPImlRqO5 + Wu7O4tXHnQtHv5UH0rYtf7JuPD8iSII7tP4z3rPWa+1i4t7VpvMYYSPcelO1DSbjS9RWzvRsJwdw6Yqp + a2i3ZlztK0JOz30M9VQbg3Poak+x3K2/2jyX8r+/jiuq1fwpZWWhR3sN9G0rDOzPWshNfujog0lYUIJx + vxyamFf2qvTJpYlVo3p662ZFmwfSWbAE4rJqe6sbmyKC4iZNwyM96graKVrpnRBK107nVeD10UzO2qsA + QON1ZfiOTT5NVk/s4AQjuO9ZOcZ5pKyjQtVdS79DGOHtWdXmfoIPpRVu+0660+YxXUTRsPUcVV2knA5r + eMk1dG8ZKSvF6CUtJS1RQZrQsNXvtN3i0uGQOMFQeDWfSg1MopqzJlFSVmjX0TSpdavnUs4jQF5XRdxU + euKg1S9mvLhVlmaWOEeXESuPlHtUUNxLalZYJGifafmjYgmoByDk89ajl967M1BufM9ugw0U8LnnBIHe + lCgtjODniruaXHKpVQw3A5rcufEOoXmiLps/lvErAq5X5h7Zq14P0v7Tq0c95A72KH94+OBV3VdNg8Re + LXsPDkQ8lV5fopPc1w1K0HV5ZLbW/Y86riKTrckl8Ot+xNp3w8lvPDh1Oe7W2YoXQP8Ad2+5rjE2QzSL + JH5icjg/rXSXdzr2gRT6FeTMsTDBVjuAHtSeEdCi8Qa4tvczRpbxje4LYL+wpU6k4RlUqSuuluxNKpUp + xnVrSvHdW7HLbA33cls9KYc56V0fizTNO0zxDLa6dPI8MfUt1RvTPeufZz5m4nnPXFddOanFSXU7qNVV + YKcdmTSbUt4yGHmH06im+W8KrJLH8rdM0xWUShpVLDPIz1qS5upLsrljsjGEUnoKZeuxF5hyccA9Pang + 7up5quamQNgKOp6Cm0kNpIvWFpcanew2dsAZpWCqDXW3Ljwdaiwt5Hh1sMPNlikyhU9M1CQnhDSVWOa0 + utRv4gdyfM1v9CO9M8Pz6QtrctqwS5nuTsdnBLW4/v8AvXnVZOp71rx/P/gHj16jre/a8Fsl1ff0/M17 + /VLay0j7Tqnk3+rzJhJEI+Vfc+tcDcXs92Q11MzbeFBPIp18lta6jPHDc/bLdWIjl2ld49cVSnl81l+Y + nAwCRjiujD4eNNX3udWEwkKS5t2/6sl0NWPxBqMGly6Zb3TfZXwWHTGPSsl5CCwVjgnJJ700n5QB+PvW + pp1hEkJ1DUDtt48FIyOZvbqOPfmumMIx2OtQhC7S3KEtncRWsVzJC6wzZ8tyOGx1qvjJq9qGoy6ndGaU + JFGPuxxrtVfoBxmjTNOn1O+S0g2rvYBpH+6g9WPYU20ldlSkox5pEmlaXNquoxafAyCSVsB2PyD6muqn + 1S38H2kmk6csL6uGxLqCHO0HsM1Wv9Wj8NWM2haVKjzONl3cLhgT/sHqBXIZ3tlmPuetcvK6zvL4e3c4 + VTlinzT0h0Xfzfl5EkzStO/mvufd8zZzk/Wuj8L+Fh4g895byG3SNSVDMMk+49Kp6IIbC4tdQ1TT5JtO + LbQR0yK1pbBvFuu3DeHNPa3gCZbc20E/0+lKtUdnGLsu/QeJrNJwi+VfzaWXkQNr2pz6cvhlJbYWol2G + QJgHnrn0rbnjtfAE1le6dew3l86FZY35GD3GOlVDrum6F4fk0qHSyur5KTPKAdp9fr7VlaR4Z1HWIpdQ + aFms4MNKxOCw77c9a5rJ6y92P/pRxtJpyl7kL7fzeZHHZ634z1WW42PKd252/gjBPYf0FTeKNA0bR4I4 + LHUfP1GLP2mM/dHuD0z7Ve1bxfb2No+m+GVktreQASSH7xPt6fWuIkZpCWcksTnJ6mumjGpJqT92K2X+ + Z04eNepJTfuQW0e/r/kMooorsPTClAJGakiiaWRUjUs7cAe9dSul2Phgx3GtLFe3jLuWyV/u56FiP5Vn + Ooo6bvsYVa8aem7ey6mZpPh+TUAZLm4jsLbGRPcAhW9h6mrDa5FpHlLoyCK7gZka+U581Tx909KztU1q + 81VsTzEQISYrcHCRj0ArMJqVTc9an3f1uQqMqmtb7unz7/kSzzyTzPJK++RiSzHuai60ZpM1tax0pWVk + LRmipYohICWkVQvUE8n6UDIqmigLuysyIyqTiQ7c/wD16sGW1iEiW0LSu2NksnBX1woqK5tp418y5bbI + wB2OfnIouK5ACQwIxweMirt7NcXUSXEkcghBKqT90E84UdhTLe5VGkC20T70KDzCTtPr9ar+a5jWIyMY + 1OQueBQHUtSW0aWyv9siaUgFYUDM3PqcYH0pgvbgWYtN4EQbdjaM5pwvHhHlwSGNOheNQrH6nr+GcVUp + W7kpdy1HH54lPmRLxu3ykgt7U9Es1gk8y4mMy/6sRoDG3TkkkEd+1U6Wiw2m+p6N4em/tn4e6ppLIGe1 + zMjvJgKOoAH4H8684Oc12fw51F7XxJ9nUwBLuNo2aboOM/0rmtYtfsOtXduHWQRysNy9DzXJRXJWnDvr + /mefhV7LE1KfR2kvno/xKFFBzmiuw9IKPwpcUbaBCYJyQKTvTsEd8ZoC80ANpacV96NhNFwuNoBpdlG2 + gLiUUYoxQAUUUUAAOKKKKAFpVYqw9M9D0pKKALkd2i4jltYJY0JwBwT/AMCHJqWGeATLLHNJA/ORIokQ + DsKzqKmxDgjQlkhZJZJYY2aQkRvC2wKf930qJtiWy+Xd7wTloXXGD6jqKqUu9gu3t9KEhqNiQ7CADGVI + 6svI/KkZBtLq6so/A/lT4JzFKTFIYgwwc/MD9RUsohKZdBn/AJ6wnj8Qf/rU9gbsylS96tPLnYkgjnjQ + YVlAVsfXv+OaiSBpQ5jwdnO0thiPYd6B3IaXJ7nNIQQeQfSimMerNuAFaul63f6Vcq9pOQFOTGxyh/A8 + Vj07d2NTKKkrMidOM1aSujqru40rxJJEwjTTtQdsSOzfum9x/dqtrHhq605XlWMiBEBLsy4b/dP8X4Vz + 4JH0rd0zxHc2UH2C5VLqwZhvgmGR+B7Vg4Tp/BquxyypVaNvZO6XR/ozBp1djHoOleI9Q36PP9mgjjBl + hlYeYDjqvZhXL3ljcWUwiuEaNzyA3BI9auFaM9Nn2NaWJhUfKtH2e5XySQT2pwcg8Y+lR80taWN7HTeG + fEN7oU813aeW6BQsqSnkjPau2it9J8d20s4ZINRY8hfvjjge49TXkYYjocVfsdQmsbhJ7SZ4ZUwQynnN + cVfCcz54O0jzMXl/tH7Sm+Wff/M3Jk1fwbqd1bCZUlmiMbSKM/KfQ9quw3GjQ+GktYITf6pdghlK4aFu + xU962vD/AIh07X7OTStZEMUsrF5rhwMy+gX0NYOs6BqPhi7j1WzJigEpNu5I3p6ZH0rnjPmlyVNJfmcs + KvPP2VZcs/uUrbFTTb2z8P8A2wX+mi4vWTbEJDxGe+R61mWPnzXTXSTJCYz5m5j6dAB3PtVy1trvxbqt + 9d3mo20DJG00skpCjA7ADr+FYUUzW8haMjPODjI+td0aad+/U9OFNO9/idr9juZbjSvGVrLNdyw6dqsE + eI1VMLP9f9o1yF5bXFlctbXMbRTJ1QjBptr591dRJbJI1zksGU8kjnPtXV2uqaXrulNp+usLW7tlbybm + KPe0zn+8e5rPldDbWP5GChLC/DrHt29PI5GO5ki4U/KfvKeh+tMnffIWUYU9ADnbVjUNNvdMmWK9t5IH + YBlDrjcPUVS3lGI4+hrpjyvVHbHll70R+5pGVc57fSpVka3Z0EuQRjeucH/GnWdwdPu4LuNI5ShDbZVy + M+hHen3jiRjdPLE805LtFCuFjz+gPtQym9bdDZs9XfTtGudPEFrJ9qUFpHXLIO2P88V0lh4MvbzRLe8j + 1CK6QLu+yh8jHoD6+1cHYja5wkZkT5sOeCO49zXXabq8nh+eLVLdLcRzBlS180t5efWuHEU5R/h7/meZ + jKc4a0dG39/+RDpeu33hW/nhs/KeOXgxyH7h9/eneIdPbRr2C9nuLa8NyPNliXoM9uPr1qzqWg3C6R/w + k322G8e4Je4TACrn+6fUVx8jtLJuLu2RwCc4qaUYzlzxfr5kUFCrL2kH5S82SzXkhWeG33x2cjbjGedp + /wAak0y8GnXLStDDcQshVkkx3GMiqjsbdpI4pNyuACR3HpTH+dCZGCmNdqr3Irr5U1Y7+VNcvQhlYMNo + GFBJHHrTMFdpYZB7A8mkyWbJP0q7HptxHareXNrP9jZtu9V4zjgZrXRI2bUVqLp4inb7LOyQwyuAbgru + Ke1QXMRtrqSBXR1ViodTww9aSR9xBRSpx8+OB+FatjFLrMUVk8tpbQwBiruAuT7t6+1S3y69CJPk957G + J/q3IBB7Z65FdJoPiC78MpdQRWdtcS3AARmG7b9PWsiC0LziJysalsbz2Geo9q6TXPB66JoltqD6hH58 + hyqZ5PfIrGvUptqnPqYYmrRdqVTXmMvVfDWtafYJql7bLGkz7sA4Kn6dqtXvi1r/AMNQ6TcWpuLhDhZ3 + OWUegq5pkHiLx/cC1lvx9ngUbtxwF98dzWNfW7eF/EflpJHc/Z2zkHINZx998lSzktdDGNqjVOtZzjqk + r6dtTIurO4s2RbmF4iw3KHGMihPs4gbzFYzH7uK6e9u9c+IOoJHDaRhIV2qFGAo9z3rmp7a40u/MM8e2 + WFuRXRTqcy5ZfF2OulVclyTsp9kyMw3Nm0cxjkhP3kYjH5VqX17b6jpqz3lzJJqA4GfSr2r6/deJ4be1 + h09VEC4JQcn61maP9gh1ZBqkZ8lT83FTzNx5pLVdiVJyjzTVpLotyvpype30NvdzMsROMk8Crmv6Uuh6 + lGbaVZE4ZSDmq+uSWD6rI+mAi3z8ueKznleQ/O7MenJrSMW2pbLsaxjKTU1orbGvrXiCTWLeCJ4UQxjG + 4dTWGScYp3sKcqZYBiFGeSe1aRioKyNIQjTVokWKU1auVhiJhidZR18wDFVKpO5ad9TpLHxK5iFtqkIv + bb/b++v0NSzeH7TUUM2hXPmt1Ns5w6/T1rO1jQ5tFMIlljk8xQwKmqds0sUgliZ0ZTneueK5fZr46Tt+ + X3HF7FfxKErfk/kRz28ttKYriJkccFWGKgI9K6208RW14gttdtluE6C4UYkX/GsvX7DTbKaP+zr77THI + NwG3BX2NXTrScuSas/wLp4iXP7OpGz+9ff8A5mL0opTyaK6DrCnqpYgAEk9gM00Amum8N28FpJPd6jBK + gjT926OUkVj0K9jWdSfJG5jWqKnG5Yt7s+GbY2ssNhqVrexB891PpnqCKwIYTcXJWOIneeFXsKdczvd3 + Ms0rmRmbJYgAn6gV6B4NsBoVo+q6rY5s5k+WYfNs/CuStU9hBz3kzgr1Vhabqbyf4hqd/p/h3wzDZaM5 + +0XabZlfkj14puhaXYWWg/2vY62bfVI0JZG4/DB61T0m01PW9fl1qzs0ura2myElOMj2FR+MtdstXeKO + 30s2lzExEpOBn24rhjBtqmt3q/8AJnnxpybVGL1esno/k0Ys9xqPijVwXcT3cp2qBwDWpfXdppvh0aPL + pRh1eJ+Z14IHrnrVzTtJ1jwzp0fiO3jt5Y2XlWGSoNYSvLr2sKJMiW4k6nkKD/SunmjN6fDH8zs5oVHp + b2ce3dfoXfDXhK68RSSXFw/l2UWTNMTk5/rWSmiHU/ELaZpB84FiEZuMgd66jXND1fwVan7LqZayucjA + OM/hUPhHxHpOhafeSzxsdSKnypMZ69hS9rUtKpT1WyX+ZKxFWUZVqT5k9Ipfqcjq2mXekXrWV5GY5E7H + p9azzketdNHa3mqT/wBs63FdyaezEPcKOh7VT1XQpLG1hvonWaznJ2OCMr7H0NdkKy0jJ6/qd9LEJWhN + +9+F+xiqMntXSWEcugWtvrhltWu/MKraygMQuPvEdqxbaMhvP/dt5TKdjfxc/r/9etDVNQufE2utOyQp + LKAiqmFQYGKqpeTt06lVk5tR+z1/yFliup7dtYFxbu5lJdI2G+M9QdvpVO7vpbu4a5uBG0sgwdox+JHr + Ucg8gAbCk6HB7hjnqfTH61dsdMvIrBdfl0+O606G4EciyPgO3oQDnvVKKW5SUYq7+X+RJokdhCkmqagL + a6it2CNYtK0cjgjG4H2rMvr1764MjfKijZFGMYjQHhR9Kl1jUv7UvzcCJY12qiIFAIAGOSAMn3xTtKsY + 7qfdcyrBbICzPJkK5HOwEdCRVruWlb35Eul6dC0EmoXxAs4SAUzzIT29QPeq+palNqU4kk+WJBthiA4V + fTjjPTJp2r6o2ozRhVMdrAuy3hY5KL6E96zScn0oHFPdik5Pp/SunXXrXTfDcEOjb7e9nDRX5Y7t69se + g5PuK5fNKDilKCla4qlKNS3N0HbvXJPrmtXw/ptpq2o/Z73UorCLYWEkgyCfSsjNW3t8WscqNG64ydvD + D1yPTtn3okm1ZOwVE3GydmasN3PLHDo1xfMNIS5wZUTjr1FbN7q58IXt1p/h3UvtFpMgLFgDtJ9D61lL + 4onTwq2hfZbfYzZ83Zlsf4+9P8LeHG1u7Mk6Srp8XM8yYygx79a4pwVnKqrJdO/n6nn1IRSc6ytFX00s + /P1LXhjwq/iKW4ur26a3gjUyNK4zuP1NWtb8aXC2C6Bpkyiyi/dGcDDSL/hVbxF4ijni/sbSf3NjBlWY + MQJsd8Hp9K4/PoOlFOi6r9pV26LsKjh515e1r7fZj2835nRa54Xl0uxgvre6jvrKZQWnh5Ebf3W9DXNt + 15OTW1pet3sNnJpBvWh026ceeu0NtGeSPf6VP4m0rRrK+gXRNSF5bypuJb70Z9CeOtdMJSi+WZ105zhL + 2dTV9Hb8+xzoyTwM1oabpN3qt19msYWmkxubA+6PWrGhaLcavcSRx/JbRDzLiYkYRB1Iz1+grQ1XXLay + tZNG0Jj9i37jdldssvtn0onUbfJDf8gq1pOXs6WsvwXr/kTT6jZ+FTLaaLPHeTyxbJ7iWMHYe4SuUlkk + kcvIzM55JPemE980mc1VOmoa7vuaUaCp67t7sM0neipIonlfZHGXcjOAMmtTYZ0PNSRRSSlmjQkINzEc + 7R60+7t47aUJHOkwKhtydAT2qMbWlUOfLQkZIHQetIV9DRSe2sZSYF+2TsBskZcBT/u9zVS8juluj9sR + klcbyHXbwfaknMKT7bVmIQ8SHgt7+1N80yzGa4kMrFgW3Ekv+NJISVtSxaNcNI8OnJITIu1jgZx9e351 + FcQCFUY3McsrZ3quTs+pp1xfPKgijVYYV4CIMZ+p7n3qrTBJhRRRQUFLSUtAhR1pQM9iabXUaJo0er6X + d2y2d1LrCKr2iQKNuz+Iv+mKmclFXZFSoqa5mZ2i6gdM1e0uoW2GORSXZAxX1wK6Dx9aMfFiypDPMbpF + dGePaZTjHAABrlEgYSfN8m1sHPY13XjAw6npGlanDcahd+WPKmuWh2Jj/Z465z3PSuWq+WtGS80cFe0M + TTmut1/kcl/wjmpKMzWotgT1uJFj/RiKrtax29ysMt1CYz96SE+YF/xrdS48LwsGXS727Pf7Tchcn6KK + pteRf2vFeWemW0KRji2YGRW9znrVKpN7r+vvZrCrVk3dP8F+r/IrldGjjlUC9nf/AJZuNqKPqOaeLrTE + tEU6IC4/5bPcN834dK2P7d1maKWa3tbK3hIO4x2yKAPxrOvb/UdUgiivtQSSNOY0xnHbooqU23r+f+Rn + Fyk/e/8ASnf8EjNtD5xa0js4HknYBC5IKn2Of51rjQ9Y0O3kvp9PtxEp2k3G1ufYZrOjtoEWZftKtIAC + hRCd35gEU1vnXY8074/hJyKuTbdlsazbk7RenW6f+ZabVZmjQCPThlg2Ft1BB9+K6C9sdXv7XybjUfD6 + RtgkK0aN+YFYlhpEhQyzabdzR4yCiMP6UlzYvBH5h0t40boz78jmsZqLkuXp5L/M5qkYOSULJryT/U0b + fw5fWOq20y3OjzsFLYeddnTuKrW0mp3GoXFpBbaZJM+QcqgU4P8ACSQKz5LQMry+SwQY6bgP1pzWsWyN + ktpeRnIc/Mfb5adr6yd/l/wSuVvWTTfp/wAEuz+Hdbt4BNPoURhg+d3ReCB6kN0rLnvbGaEr/ZVvG56N + FI4x+BJFSBWkJt4/taqesYbOfw4qCWyjQnEjAerJx+hNaQ/vP7r/AOZtT/6eP7rr9WWEXS7iBWGk36qn + Ek0M24E49CvH51HINJYoYrq4hdQFxNbggepJB/pU2n3OpadKU03UAm75iEl2K34NgGr6eI9UgsWt7iws + 7mEH781qrYP+8KG5J+7+f+Ypc6fua/PX8UzDl0/bdNFY3UV4NoIePK5z1ADAHNU1DliAhJAOflzit6PV + NIeOUXWhJJO/KvDOYwn0Wo9Bjhju5ZZ9Vm0p9v7mRYWcPnqDjt+daKbSu1/XyNlVkotyT0/rpf8AIwiO + eOf0pMe1dhc6Te398s3lWWrxKuN1i6ozD1KjBzz6Vh/2bH9sS2mkksnIbf8AaoyAD2HHNONWMh08RGa/ + r/h/wMuirM1q0UkiLtlCHBki+ZT75qv3rRO5sncSkPtVm0hjuLlIpZlgVj/rH6A1Zl0a6jiWVY/OibOJ + IfmGAe+OlJySdmJzjF2Zm0D0pxRgM4OKSqKJIpmiwNx25yRjIP4VZlFtOpkjZYWUZx2Pbp2P6VSpO9Kw + mr6loSAII54VZM/6xR835/40jwBtzxJvQD+E8r7kdf6UkU7xjy0YqG4buD+FTMbZ4ojbeZFdA4IB4b3B + 6g0r2JvYo0tXJYvLlDzBZN6/8syAyn3Hr/P1qOWGRkM4dZF/iKjBH1HancrmK9AJHSiimMkjleM5Rird + iDiuqtvEVtqgt7TxJmS2txgSQIvmE9gzen0rkaUM2eDWU6UZ7mNWhCpvv36o6bVvC1xbq02nqbuzEfmG + aMbvLB5wSOuBjP1rmyMVsaVrdzp8ckcc0n2WQqJoxIFYrnop6jPfH41t32kaXrttDP4ejlF4R+8tlXKK + BnksejH8j2rJVJU3apt3/wAznjWnRfLV1Xf/ADOLpVcowPBPvT5Y2ilaN0KuvDKeoNRYz3roO1NMmjcg + Ahsc/jXeeHfGcTBbPxD/AKVbhdkTMOn+8fSvPaer7cDjHesa1CFWNpHLisJTxEOWa/zR3HirwebRJNR0 + 5o5LNjuxH0UnJwvqAK4nbllVRyeMnpXY+GfGI00rZ3qtPpYzhCASpPf/AOtV3xV4UjuIP7Y0VVe3m5MS + D72eSVHoK5aVadGXs63yZw0MVVw01QxOz2l39fM59PC+ofY7u68yOBbeMSbJcozr6jPH61h+aXYMNsZA + G0IMYxU17f3t5HDFdXUksdunlxKx4RfTFUyRngYFd8U+p6lNSa99nXx68mvWJs9XjmvtQwIbKQyhFjz6 + n/HrWPreiXvh65FpqMYEjp5iFWBU575rJRsEdM5711eiXthfQ3VhqNglxeXZEcN5LMR5R9yewwKxcfZa + x27HPKDw75oL3eq/y7HKBmBPv1rV0nWJNGkn8mK3lWdPLZ5YtxQeo96ZrWjT6LfNazssmOVkjztb6E1m + Z7d/WtU4zjdbHSnCtC61TL15DDFfyrZ3JuIFbKTlCu7vnFPtr37JI0iBZjKhR1lXIXPce/pSWepy2Nnd + WyxQSJdIFJkTJTnqPQ0l3ZT6Y8BYxsJow6Mrhhg+uOM+1Jq+jJevuy/4c6bT3tbC7s2vpnu9J7hD0bHI + xnt3rU17SGe1GuaRam20qaPEu/GcE4yF7DpXF2N/FYySpLDHdxSxlBvJGw+o9CK6XR7u0069jt9baS+0 + /wArMaRSFkBPtxXBVpShLmX/AA//AATy8RRnCftI7r8V6dznbqJLcIY5EkfnlORjtVGTdJKN2dx6V2Gt + 6NcWG2d7YWWmXjFog7BmVevPpXOTTQpbmKJEMgbiXuV9K6KNTmV0deHrc8bx1GfZ47G4aG9QsxXqrf6s + nufWhriZoRavdztabiVXccH321XXc6kHp7V1Z8BakPDZ1d5U4UMsIO4lfXiqqVIU7c73NKtanRs6r3Ob + s4JpbyKOK3a4lLDEK9X9q1b3SJtM1mBNXsjaQSsGMa5YKCfr2punaxHphsrqzj+z39tIcvkkSL7j9K6J + rnVfiBqv+mXEFnbQrkDGAPz61jVqSTu9ImFetOL5paQ6vr8ifxFZaJfwQw6Es17qCAb3jUkFfc+1c6mr + zQwXGnSWcd1JMwVXnOTFjjC56VuaD4ln8LyXmmW9vBeSmXbHIvAJ6fjWd4n0PWrIDWL2KOIzPuxHwUNc + 1L3Zeznt0OOguSXsqmz+Ft6swJGv9EuJI1eS2kZcPtbGQa2pbDwzD4YFy99JNqswyFGTg+lc/c3l1qLL + 50kk0vbIzV/w3qFvpGtxXF/arPCDhlbnb712VYS5eZbrt1O+vCfJzL4l26+RDpGvanoglFhN5TSjBJHI + rcvvCFwfDz69f6ir3Eo3bSetQeLzBqt62qaXp80dnjDyFcKTXNyXVxcQrHJPI0acKu7gVMU6lpw919e5 + EVKso1Kfuv7XV+he0XxDcaHFOIIUd5RjLDOKyLid55nkkPzscnFJvKk4H51GylTzXXGnFScktWd0KUVJ + yS1Y2nRhC6iRiF7kU00c1oalu6+yxTL9kdnXHJYY5qszF25602rdpY3N7IEt4WbPfHSpbUVdkNqCvJlU + LzzxVyz0q71BwsEJwf4iMCuit9H0vS4xPqVx5s4P+oSoNS8S3E6eRZRC1gXoEGCR9a5XiJTdqS+b2OJ4 + qdR8tCPze3/BMS0tZ9SvIrcM784HU4Feiau2k+FPDA03ZHPfzJk5HK571yXhTWYtB1Tzp7bzAf0rtZLv + w94suCs4SOYjh24YVyYyrONVc0XyLscOY1JqtHni/ZrXQ8qUNkkjIqNzluK7vWPh7d2waXTpRPFjO3jO + K4u4tZbWQpPEyMDyCK76GJpVleDPTw2Mo4hXpsr0lKRSgEf/AF66DrLmnaZdapP5NpCZpcZ8sdTW/rl/ + Zy6faWFvDcJNbjDiXqh7qD3H1qtoxt7GzkvRNcWuqxkNB8pCuKozzy3lzJcTZaWVtzH3rml787vZHDK9 + Srd7R/P9Uafh3Sm1DUYnmtJ5bONh5xiXOBW94qv47VF0jStQaWwYbmjxnYc9K1NLhm8LeF/7TstQDNKA + ZIJQCpPtWX4Vt7m+1WbV30+O8hDEyoDyM+grzp1VObqP4Y7ep5Mq6q1JV3rGGi838zQ8hfDGhLq3h/WA + 4cL50EjBgT347Vytrsv9WW91NZGt5XzK6KcCrfiK70/VNYT+zLV4IiAjRtwN2fSusj1aDw54YTT9Q0h1 + kZSFcAFGz3pc0qcb2vKX32HzSowUrXnP0Tt+pyGtXUUUhstI1GabTzz5bE4B+ldf4J00aRpUmt3yhSVO + MjotYGj+D9S1G1XVbVYTGJNyxMfvAGp/F/iuW7tI9OS0ks5E4kGcAj0+lKp+8tRp/MjEJ4i2Govr7z6m + Pr2q3XijXSsAlktg3yRoM4Hc0apo+kTBn0e9Vfs0W64juPlO70UdzTtJ1LS9J0G7kYSjV2G2JkOAAe9Z + Wq6VFE9n9ivft1xcxeZMqDOxjzjNddOPK1FaJbeZ6FGPLJQjeKjovPu2WNB8Tz6ZdRLes9zp0ZIa3P3f + w7VU8RazFrGqSS2sItrY8JEvT6ketLfahDDo0GkwRxMQd80wQht393n0qgIkismlfa0jnaFzgp71vClD + m9paz/rU6YUKftPbctnt/wAEgZhHKDGxO3oSOlT29xHHBJkKrqvGF3eYSehz0/8ArVWCgtyGx3wOlP27 + 5Vjhw3zYUkYJJ9a6LI6mkyxp1nNqN4SIpp44/wB5cGIjcEH3iM98U/WjYRX88Oj3NzJpjsGj80bSTjuO + +MkZrb1a4uvCumTeHI5oy1ztkvCYQHRsAhVfPIx/nk1yOfl7En8xSi+bXoZ0pOo+fp0/zDPTnIHSk9u1 + FFWbgST1J9KKSnKO+aAFwARznPpSEYrvvCGi2Npo1xrusrBLaFCoicBifp3DVxeoS2k2oTSWMDQWxbKI + zbiB9axp11Obilt1OWlio1asqcV8PXpfsVKkTgkBmAI5I7+1MHJ9Kv6XpV5q14LazhkmkxuIQZwO5rST + SV2dE5KMXKT0Leg6Dda1d7IYZDDHhppFXOxe5rd8QeIYLOEaFokzR6apxLKn/LY9/en69qdnoFidE0Ke + QbwPtUucZOOR6j3FcOzt90MSoPFcsIutLnlt0X6nnUoPFTVaovdXwr9X+gjNuP8AhSZOaKK7D0wzUkYD + gqXVT796iooEbV94hubzSbPTECRWlsuP3YwZG7knvWKT2pMml4xkk5qYwUVZE06caatFCYoIq5bwxRAX + F2AyKR/o5Yo8gPcHGMVFcXEt0yb2ZhGuyME5IUdBVF3I4YWnnSJMbnIUbiAM/U1ad57FZbVSikHbJJGw + YN6c/wCFUqKBNXCiiigYtFFFABT1id/uqzZ9BTxH5Eyi4ibA+9GflJFXH1GedPsrzNbWi7mWFBgA46e+ + fek2S2+hm0tFTiPyoFldDuc5Q9uDzxTY2yFRk85x64pVxz8uTUxeWVy2Au8YIRcA/hTShVipBBHXNK4r + jRuYYzge1dP4PurnStctdSjTZaq+2aSaQJGUPBHOMnBJA5PtVTT9OnNm8q2kQ5/4+rg/Kvsqngn8G+la + lrojXUaXVyxnYttSa6YpFjoMD7zfQY+lc9WpGzTOPEVqbi4Semw3xfo9vp3ii4htMPayr50LxocbG549 + cdM1uQWtxrHw/d5LnUJIrMbY4gscUQweMk8tgVr6nZzav4AikLH7fo7eRIwTbuiP3TjqMcflXP8Ah7TY + d9xb3VlBduwDR+fcOwX1Oxeuev4VxynzQTvqjzZ1eajG71i/63OagmS2uEbyLWIqCCzEyfiV5rZkv4Jo + iw1G6c4xts7QRj88j+VMfTfIt3t5diSCTOGgCnGeqljn8MVvSwiW0CWV/qlw2MHy4hFGR+ef0oqVY6P+ + vyNK9aGkv6/FP8znrHTZZrYTjRJrhepleUqh59gP51L/AGXeOyXENpp1uiHoJQ/4kFia39N0W5lj8ttJ + idxk5uJm7ewIA7VPbaVqESskcdhb7uu2IFh+JzWM8Uk91/XzOSpj4pv3l9//AAX+Ri6NeJayzxahKluQ + SUmt7dWbcfTI4FYrWH2i++ZbllkY/vAvJ98V3A0W/nlZrrUnYY6ISvP4UqaDcLPHN/akweP7hBJK/Q5r + NYynFtp7/wBdjOOY0YSclJXf9djmNMtHsL2VJrO8uIivyrueMj8qG0950nC2d40mcoCCQg9D61182jz3 + M3mzatdvJjG4HBxUY8Oxl9z310x7nf1rP67C/Nf8zL+06fNzc2vzOZn0J7fSlP8AZ98Zz94hSFA9feoE + trmZ7a3khu4I88MZdo/DcAB+ddcfD0ZBX7bdY7DzDilGiMANmqXitjB+cn8hQsbHv+Yo5pTtrL8zk73T + ZNLMtyhvVU4CyleufVgcZ/nTdNNxAZftNzJGhBdS9msoPfJDc/iM10knhxpZN8l0k6Ag/vIyMn3KkHNP + urDV51jBumaNBgRCVmH5Pu/nWixcGrX/AK+41WYUpRs5Jv8ArujjpLiK6hZDDYzZJ2lUeJkz344/Oqdz + pDJEBFBPu6s33kI9iOPxrrptImw3nQ22eyPCMnj+8u3+dU7ayntJWkW3nHmZAFnMCR+HJI+tdEMQvss7 + KeLgleD/AB/r8jlLeaeMNGJIH3HGydA35Ejj9KsXcUSNJHd24ify8xNbSZjLe+SeD7V0jjTrdopY5Flu + QNs1vqVrhWz3DL0/GsOXSpLvUJlitwqk7sWh8xR9ATk/nXTGsnq9Drp4lSd5K39fL9Rum6Rp9zZRzPqs + lpdAkN51u3k57YkUnH4in3lxqejXcEtzfWuooUKwkyrcIU7jnp174qJoJtOYxw3EkExP3sNESPfGfyqC + 6juLqRYnjhldRw8Ua7m+pX73481Sak7t3RcWpyvJ3j5/oX7a+0e5Dmazn06SVdrT2b/Jjv8AIevHYGqk + +hRpqdtFpM8etBvnEUaMjHHVWHb8Kv2N/b2NnJbn7RbnBDRToJ4HbHcHBUn2yaZpmgzSKdRmE/2bdkS2 + JDtE2eCVznHtxU83I272X3/18mQp+zbldpdL6p/r9zMXUoLO3mdIEuYpMsGguEwY+eBnv+lVYZrmzIe3 + leIt1KMR+ddvdtchEnvGtvEWnkbFkyVnj+o+8D9cisRLDRNRuHjgu5tOZz+6Fwu9B7MRyPrg1cK117y/ + r8/wNaWJTj7y/X/g/ejEluPP2+aEDDkNjBaqrqM5Uk/WvQ9QV/sNnb+K9IRbKFNtvqGmKvzLjgEjgj8j + XKf8I9ey6PPrVvFjT45fLDSON2e3H4irp1Yv+tDSjiISV3ovwfoYlJT3UhyCMNnkUyug6wpc4pKKALcE + kUmTdtL2VJV5KEe3enTxSIVklwUb5hPHycdOR+HfmqRqxBdT2wYQuQjcMvUH6g0rEtdhWWOXIVcTM3BU + jY34dv8APSq5BUkHqODU5VJWJjwhA5Vj976UrthmiuY23ICARgMD7nuKBlaipJY2jIDlTkAhlOQRUfNM + YoYjpwau2V7Nay5gk25HzAtgOM9D6j2qjSg4NS4pqzJlFSVmeiu+k+NoDlYdN1GKPasaKfnx0A9ST+Vc + XqOm3OnXb2l1EYriMcr0B96q21y9vKsiyvHIhyjpwQfrXa2Guaf4itBp/iCQQvGn7m4jT5pGPdj1Jrk5 + ZUNtY/kec4VMI7x1h26r07o4Qj60lbWt6DeaNOqXcRiEgJjdv4x649axiCDgjmuqMlJXR6FOpGpFSi7o + VXK/TOcV1nhvxTcaK/2R5ibGUqJQnLIvfaexrkacrEH2qatKNSPLIivQhWg4TR33inwzBdR/2vomJo5c + EQQKWIUDlj6e4rgtvU5AAHfv9K6nwx4mk0mRreV5G02VsTRq2Gx6j0960PFXhmC4T+1NAi8632b51hT5 + E91/r6Vy0qkqMvZVNujPOw9aeFmqFZ3XR/o/M4SnK5AK8YJ9KaRg4oAJOAMmu49fc7fRNVt9X07+wtZR + 59q7LDygq4c/3m646VzWtaVc6LftY3nl/aEAyEfcMfX1rPR8YUjIz+VdvY3lt4p0o6Xqc/l31suLHyoA + TIcfxN1J/wD11zNexfMvhe/+ZwTi8NL2kfhe67ea/U4YH8utaenE3jw6VLfR2lm8u4ySJkA46kjmqd3b + TW1y8U0TRyKcFCMEVXHB/wA8V0aSWh2u043RcuojZzy2oeOZQ/Eqchh2I9qns57ZYJo7ppVfbmGRPmCs + OxHofanfaNJOg+QbWX+1BNkXAf5GT0INZeeAOwpWutSUuZWZ2dp4pmTRX0+e2juGl+VJbnLsi+ig1Tu9 + Fk06ygvbm3mEM7fuiwxn6isu0vntrm3uI7gGaIq6sY/u47H6YFekx3F547sJZr7UbbT9OgbmJMZ3Y4Jz + 2/GuCsvYO8VZPc8vEf7LLmirRb1f+SM2L4e3FxorXqTqZinmRxxkMGHXGfWsvRPEd9osVxYeYyJL8pDD + cVPtTrbXtTsbeXSbO7Vo2k2q4J457fWp9a8IX2jabBqlw4lMhBYA/Mp7GsFdtwru6exjG93TxUk1J+6Z + 2raLeaUsF+8LeXKdyM45P1FX9Ksh4kuJri/1GHT4Y04UcVoRa7q3iq0t9ChghzjDTPycVz2uaHc6DeC1 + u2DcZDL0IqoSlJezm7S/QuE5zXsqjUanTq7HSS6hpN5ov9m6RpryahG2FnjXkY/izUdu3iDxpL/ZUl0u + yAAPuGCPc+tU4vE8dtZwRaFp7wXiLtlnC7sr9K0brRtY0LTIvEUGoFpJgDMU6gGsXHkdrWfS+5yuHstG + rNvS+rv+hx2s6bP4d1xrOSTLoeWQ84qPVlsGljk0/wA5lZAXMg/i712etN4c1DQP9C8+51ZlBMu0ls98 + muGRbq6njs4/mcnaFxzXbQqOcby0aPSwtZ1Y3no1vfT5nS6Dr+pahpy+F4I4Cs5KrJL/AACsHxH4euvD + eqC1uCCcBldehpk63mj36owMVxEchl6ircNjr3iy4edi84QfNLI3Cj6mnFKnL2iaUXuEYKjUdWLSg9/N + nOyM7kseppm0muvPhjSbSWFdR16IB87/ACF3bKp6tH4ch0/yNLN1cXW/meRQq49hW8cRGTtFP7johjIT + aUE3520Ob5pU27vmzippLWeJFeSKREYfKWXANV63TTOtNNaCqMnFatlq1zbRi2RwqE8kVl8596XjPGfb + FTOCkrMipTjNWkdHc2qQxLcMxfdzkmsa6u1YkIAT61Iby4lgW12MW7DHNVrvT7qzCm6geIPyCw61lTgo + u0nqY0oKOk3qeg+BbbQNatza30SLcr/eON30rK8baXpui6gtvp85aT+IA/d9q4+KRonDRsysOhBwRSu8 + lxKXklLOerOaxjhHGt7Tm07HPHAyjiHVU3y9jo9N8WatopVPNLoedjnPFdlYeKfDGsWciarbJDOVJJI6 + /Q15jZKst9ELhiYgw8zHJx7V0njW/wBFvLm1j0a1SNI48O4GCxrKvhaU6iSVm+qMMVgqNSrGKi031XT1 + OZvDFLeSvAnlwliUX0FMtzsnR2QShTkqe9JjPXNdHoui6dqWkzML/wAvUgf3cR7iu2c4046no1KkaNP3 + tthda8Rx6tbQx29t9mKYXyxyOO/1q14O0ZNV1VWvYXazQfO69B9a5wxyRztCeWDY+XnmvQopdK0XwUJL + eZo9RmX5k3YYk+o9K4sQ/ZU1CnuzzsW1QoqlRWstF8+pi+JI4v7ZOn6PLLcWq8hAcjPfFX7rVtOtfD6w + 2sdxYasoAbZlQ/1qDQdP13TVj1uCyS4hbOV6kj6VFretReItXgke2Fsi/K4A5HrWFlJqO6W78/NHPyKU + o0170Y7tPr5o0vBtmFc3V/pZureXrIBuKn1pPG+tW+q3MNhYSt9nTA2kYwfSukL23h/w1Jd6XfCRCoCp + IQQD7D1rjNDic3h1a601ry1DHfgcAmsIPnm6sumxyUJqrVliZL4dvX5mpo2q3Npo91pUd3PbgDKzOvCE + c4z71h6fqNlqfiAT+I5jLEgKhkAwfTNafiPxRZm1NjooltYrg4uUYAgfTPSsjxNHoVrBYWujkSzGMGaU + Hue1dFGF3dqzl+B14end3lFpzv6ru79LlSW0Gv8AiRrTSIQEd9seemPWo7601XwdqbQybY5ypAYHIINX + buw1TwsbO6guQssihgYj83PY1kalfah4i1kzXDCSeZgoUHAz04rspXk1ZpwsehSvNrladO3zE0my+2XD + 3E0JuIYvmmRJArkHPI9cdabcvJq2ppGkwLkiKIyAJkdsnoDWjq5Wx05LFoIJSR+4nQ+XLEQfmVwOvfr+ + BqO2WfSdH/tOG9sZGmzC9tIgZwPXBHt1rVTv733GiqXXOuuiM29lmhiTTpYViaBjvIAyT9R2q1p8Vnaa + fNf6haC5imR4IFS4CtHLjhivXFUbKCKaYfaZHjtwcyyom7b6cUmpX/8AaNyJzDFDtjSJUjXAwqgZPvxz + Wtuhu4391fMqiQ5YnDEjB3DP+TTKPwoqzUKKKKBgo5469q6Lw1poe5Go39hcT6VA2J3hH3c9/pWfpGm/ + 2tq1vZLL5fnMF3lc4rq/EWoX3hjS28JRmEx43PcRghnB5wR2rmrTbapx3f5HDiqzclQp/E/y6szPGPiK + DWr6OOwQJZW67IzsCl/cgVyxJPHal5J+lOU4ORnNa06cacVGJ0UaMaMFCOyHQwvPNHDEu6SRgqj1Jrvp + JF8C6E1orR/25dAOJUUZhXuCe9V/D9jB4d0p9f1Ndl0VzaW80QZZQRwRn/IrkL6+n1C7e5uPmaRtxx2H + oPaueX7+fL9lfizin/tlTk+xHfzfb0XUgllaVizEs7ElmJ5NN2/KeDnsauaXp0uralFZQNDG8pwGmkCK + PxNdFfamdH8P3PhbVNCthdxNuS5VhlSed2RnPHofwrolPlaitWdk6vK1CCu+3l3ONopT1oKkAHBwehrQ + 3L32O1OkG7F4v2gPtMJ6keo/Ss+lpB60krCimt2KPWr1haRyZurgFrWFh5yRyASbT3APUUyyszcl5WR2 + t4cNN5bAOFPcA9al1C7+3SxRQGQwQgRxLIwLf4/h2ob6Cbu7IrXEpmm2K80kSkrCshyQueBUnkQxI3nT + NHNtLJtG4H0B9DmmI6QJIGi3TkYGSQYyD1FV2JZizElicknvTGJRRRQMKKKei78jndj5QFzmgBvfBq8Z + 40aGSKNbe4hwQwOVk5GDj16+1TXE0cdk1q1vHCSFdfLAZmP+0x5HHYetZpJbGSeOlLclaktzcS3Uxllb + cx9BgD6ComZnbLEk+9bOk+H5tVsLu+W4higtF3Sb2APsB9e1U4LYXFyYre3mmZ8hE79PapU46pdCFVhd + pdCoiZIPb6Zrb0vQ7nWMpbxoFQb3uZmKqijrkk4x+Ga2LXQtO0ghtbkNzdMBs063PzHPTcw6fQc1dvJr + y5VLa+3W8MQLQ6ZaRgFR6uf4R7nJ9q5p4i+kPv8A6/4Y4auMctKX3/5d/wAvMTR7KDTT5tg8EjIdrand + L+6Q+kafxN+H4VWvooRrUFw7SebJIHlubxB+8OeojHQdf0qrBcTTlQrlQGwJMEIg64z1/Kt+w0VboK8E + X2u4fkyS8Dj0UcY9259q5pS5G5Sf9f1/wxyTl7Juc5b/ANf108i3K1rLfu+nW8t5Iy7VJjAVTjtkYXHU + YH41Wj3RERT3Q3sSGhtF3yMfeT/65+lbC6bM0IjvLgCAZIt4DhR7E9/xrThtbeJQkEUcaAdUHJ+przKm + LhFWWv8AX9dDxamOp01Za/13/wAl8xng2KW21Qwy6fHa6feRmCYNIWkYt91mzx1/main0a7ttQkjvL2Q + tEzJthURDHTnHXitEDavBHtWjrY+0paamOfPTy5uOjrwfzFY/WJVKba0a/I5vrc61OTjo1+XzOdttLsr + d/ktIjgZBb5jn8auBDt2DCj/AGRilyFPy7W+tLxjrXJKpKWrZ586s5u8ncNjFsM2cdBnpQAM880AbiKC + AqlnwoH+1UakasUYBHNJlSSSTk1Xa7tUbD3MfPo2cflUUmpWKYzcFhn+FCatU5PoaKjUeyZdDAd6Ay4x + nnNZTa9pglx5shPoEps2u6cAro0xIPXy+1WqFTsarB1n9lmxwTSfLk85PrWYNd0wgESS575A4pw1jSy6 + 4uto90P+FL2FRdCfqlZfZf3GgAuTknBFB4xgg1Al3ayyFY7uE8fxNipo2LHCNG7Z/hOalxkt0ZOnJbod + uAIPOfpUElvBPxLGh7glelTtuA+ZWBHUEdKTKjBIHI7ihSaegk3F3RUksVZCkczqD2L7lP4NxWdceHIT + gm2t5Dn70ZMLfp8v6VuhRnilA43BiD9a1hiakNmdFPG1afwv+vzOTvNPmhjUG7u0CfdjvE8xP++1/wAK + zo9LaKQ3VzppmgJJM2nyDK++BkD6YFd6dw54z/Oqcun2zEOqmGXqHiJUj8q6aePt8SO6jmjStJfd/S/U + 4LV4IbjyJbO/kuwPk8iaPZMnsezVfudFuNOSO9iSfS5lXKTWztJC/wBSOV57c10N5pLzFTMkN8BnIkG2 + Uf8AAx/Wqto8mmz+VbXdzaSnpBcjdGBjpnv+VdscUpxXK/6/ryPRjjueCUHe39f1eJg3GpefIh1a3Anj + YY1KxYBwexOOG/HBqK5SLy5J7hIdQjlb5L2A+XIhPQkevHQj8atX9vE1w03lvpk33fNiG+GQ9846dRxz + UU+nSW7CeRlsLkqfLmh+e3n49P4c/iPYV0RlGytp/X9bfcdsJwsraf10/wCB80a1zb3fhvw1bSWLPdRX + LfvpSQ0DIezpyAc8ZBrPudK0jVm+zKToN64DmCR91rcHsVbPH+cVZ0bWX06RolTbc7cvaMd0NwP9j39v + /wBVVZ72x1zUPsttaC1Xo1jNJtUtnrEx+43PQ8Gohzptv7/6/r0MqSqqTb6a83+a2/TzRyGqaPPpt/LB + eQm3cZwmcg+mD6VlFSDgrXdXOnzaDL500K6np0ilGWdWDxEfwsM5Rh+XpWVPpdlc6d5mkLNcXCIz3Mc4 + A8pQcgpz82PX9K9CnXutfv8A62PWpYpNLm18+n/A+ZzcgQN+7LFf9ocimVJ5fHBy2cbe9WrSSxdXW/ik + 5yVmh+8DjoQeCK6LnY3oUaSlopjDrVk3QlRY7oFtikK6gbs9snuKq0UA0TB2h3qCDuGG6EEf40rR70aS + ENsB5QnLL/8AW96hDbR6/WngsjBkODjr6/WgCOlqZk+0EvEh8zktGB+JIAHAqD6UALTlcrgdgc0360Dr + g0BY7XRPENtd2p0nWyrWsp5usBpcdl3N90cde1ZXiDw9No1yTG63FqRuE0QLImexbGCelYCnaTjBH867 + bw14kt5rc6NrjmTTX+6zSECP8B1z79K5JwlRfPDbqv8AI86rSnhpOrSV11X6rzOKIorovE3hqXRphcQk + SWMxPkyqCFI64GevGOa50j0z71vTnGceaJ20a0KsFOD0FR9hJwDx37V1vhPxMdJkFreyO+nPndEvOCf8 + 8iuQpwcrj2pVaUakeWROIoQrwcJna+LvC3kw/wBtadAqadIASN44J7qOu2uIOQeO1dz4N8RQ2Uh06/j8 + 2GYbUL/MIye3PGKzvGHhptDvRIjxNFNlwsQOIfYk/pXPQqShL2NT5PucOFrzpVPq1bfo+6/zOXq1ZXc1 + rMklsxjnRgySq2CuPSqpGPr3orsaurHptJqzO6vIY/GGkvqKPd3PiFMLLBHGAioDjOMdMe/WuHZShIYE + MDjaR0q/puqXGnTB7aWaIuuyXY+C6nqPatnxRo+mW9paappVzGbe5UZgebfKp7k1zQ/dS5Hs9v8AL/I4 + qb+rzVJ/C9vLy/yOVDMOhI+lO24fDZA9hTTxRXUdw9cjJU8dOTjNbWlTW0F3HGHMsLHLK7bQeeh/L9aw + wcVYikjXaNoDg5D8nPtj+tZ1I8ysZ1Yc8bHpWsJp3iCyS28P6NKtzBg+Ygxj1Ge9V9AtpfEV/Ja65qrR + w2owYpHxn86reFPF19YQyJbos88rBSJRhVPY8Vc8ReHdStIRr19JBIZXBlgj4xXjNODdN6du589yypSd + GTt2e7v/AF6FObUV8N6hd2+kzpKN37uYjlfpWjF4Wvda0h9X1TUxuKZQMwI/Om6he6d4hs4tP0nRpFdR + nzMdPWs/SYbafUk0zUr2SC2jySpbAFF3y8y0kt+rHeShzL3ZLfZyaE8OeJv+EdFwqWkVy8nAJrX0/wAP + 6zrrGTVr57HTJSZNm7AyewBrH8VJoYvIodC3uUHzmNSV+uaNJS/8U3cOnXerGKCFcqrHA4q5xvH2sdO9 + 9/kaVIKUPrEFyt7tq7+SNnw7qdnoGv3OkJ5FzbzOFW7Y42CuW8WW1tp3iSWTSbppAp3GVegY+9dH4os/ + DWn6OsGn3KNqUbYfbzu+tZDX99rOlW+j2em28KMQDLswXP1p0NJe1XXe/wCYYa3N7dX10d9L+ZmW1tYX + ml3Opalq7fbSfkiPJJqjZXmpLA9hZTPsnOGQfxVop4ZGn6qLbW5BbKAGz13fStvWbjw3Y2kT6QSbqNQQ + w4wfWt5VknyxXNf7kdU8TFS5Ipzvtpoihovg1p77ZrEps0xkFzjd+dVPFdpo9peCDSpTIE4dh0Jp19qO + seJLM3U0pdbcY+UYxXOqzORjJNVShUlPnnLbotiqFOrOpz1J7dFsdXpkjeIvDVxpUzg3NqPNgJ67e4ri + 5FKMQeCDg1qabePpOqRXG0/K3zKe471peLtKWC6j1G0ixZXYDoewPcVpB+yquPSWq9TSk/YV3D7MtV69 + UctzVuxuVtLqOcxLJtOdrd62o/DTNoTahvTgetQeHdGj1jURbzSiMfXGa0lXp8km9kbzxNJwlJ7Lc1Ib + k2mrWuvXVvAbZ/8Alknap/GPiVPFYig06wbZCPvBea6HU/COk2WjNGkwMqjIy+axPBfiCw8P3U8N/GCh + bhwua8yFaNRe1hFtx2PHhiKdVOvSi5SjsttDlZfD+pW+jQ6rJBi0l+6+4Vl45rpfGC6bZ6glnot9NLYb + FfyzKWRWPp71gQRebOqbWdc5YIMnHevVpTcoczPZoVZTp88uvlbQ63wfe6Jpun3z6pbmWeRP3asmQR9f + rXKTOJpXdRtBbOPSuq8Ya5p19a2FnpsJQW8YV2ZcMTjoa5EDNZYeN71WrNmGDg5OVeSacuj8jofC+n3d + xfi6gs0uY7f5mjfo30966XxONDk0tfslo1rq24bolGMZ61F4c06XRdDfXYNQIcKSIwQV3dsisS912TXL + 5J7wxwvnDyIMVyScqtZyjsjz25YjFOcX7se1/ua6kmnabd6DqNpqOo6bNJaZ3krWtd3ln4v8XWyqRaWW + Nu5sA4qb/hJNXlgXRoWW9gZeSEy230/KrkMfhbWp7exSI6fOgw7vhTkVjUnLm55rW266fIyq1pqXtKkf + etZNa2Xdov6tHq/hPTA+mX6zWHQJPhio9jWf4VhRGe5v9OeUXLcSbMgDucVnavpd7bazHpNpeNfRNh1T + dkV176+umaVtu7F7WSJPLjzypNc07qmlHVy+84K3NCiowtKU+q0djkvFtxp13qkMGlkbUG1gOFzW9pk2 + u+EtG82ezgutLPzkR/eUH1rndH0yXWL95Fs/NDNukwcEDuRV7xnqGp6FYjQhfLNZSrlQy/Og9M1vypuN + FHY6afJhU797/wCZxus6kmqapcXsUKwrI2VQDpWQfve9SS4VjtYkYFRggKX3YIPHFevTgoxSR9DSpqEV + FbInS8lTLm4k3KMJnmtjQrUQ2VxqE9hbahbbcSIZtssQHVlH/wBY1i2du99dwW3mxRljgNI2APqa0dWu + LmO3j0y8jtGkgwY7iLghf7pI6/jSmr+4jKqrtU49d/QSytZNc1lpjbXtxaxndKkHzyJFnAxn04qLWr/7 + deRxQytNDbr5ULPEFdh/tAdTV+e2Oh6FGJbUfarwCW2vYLkqVXjKlR1/+vWZpzJapLqMio/l5jjXfhvM + IOG9wOv5U4Wb5lstgptSfOtlohuoFbSFdNj4aM77hskb3/ukf7PI+pNZ6KZHAUEljgACkLEnnkk5JPWu + v8A6NHe6o+oXZmitLJfM86NgArjkA1VWoqUHJl1qscPSc5dDJ13w3f6AkP20QmOUExtHIDnpnjr39Kw6 + 3/FOtv4g16S6Z/3QPlx8fwg9ePzrEI8yXEadThVXvTpOTgnPceHlUdJOr8XUjNPj27WDIST90g4xVzUN + MutHult76Dy5ygfYxBIB6ZH9DVnQLGG71NTdQtNZwAy3CRuFYxjrjPU1TkrXNJVEoc3Q7WxgbwN4YafU + beGZ9RTMJjPzxsV4BPtnPFebzyyXEheR3kcnJZjk1b1K5jed4LS5uJLCN2+zrMeQp9ugNUQcHOcEdKxo + 0uRuT1bOfDYb2blUk7ylv+mg7kMFJ9j7V0vhPQk1K/8AtN7C7aVbgmeRTgcDgZrn7O3e8uo4UyXkYKDj + OM967DxLc/8ACNabH4YsL7z0Y+bcuCMFj/CMdsYpV5S0pw3f4LuTi6knajT+KX4Lq/8ALzMbxNrZ1a8V + IZJvsNt+7t0lOSF96ybeF7i5jgTbvkYIu5sAEn17Uz7rdjjoDXYfYE8NaXJBrWlW93FqUJe1u7eUFkcD + gBumASM4/Wq92lFRiX7uHhGnBa9F+f8AmMvIpfC040e2sXk1C4iaC7inQSpJu+48ZHI68VHoXh6xmu77 + TdZFzb6p8oghkGwH157n07VJZWNtpuiDXNRgg1L7UPKQR3xWW3cZwcDnPA+lQG5m0+AaxqV5ftrc6hrR + i/KKDjcxPUYBGPastZJqL17+ZztuUXGD12v3f+S6+QnirwzY6LEk9tqG4yPtW0lTEyADksO3I/GudNrc + f2d9r2gW/m+UGOMlsZOO9S3F1fa3qfm3Erz3dwwXc3Unp2o1WeNrhLeEqYLZfKQq2Q+OrficmuimpKKU + ndnXRjUhFRm7vqUKfDC08yxRgb2OBkgfqajq6oe1sBKu0m4DJnKsMdwQRkHoc1obsW6kjdI7SCIIIx+8 + fuT3PU4/lVWby/NYwb/KB+XeeR+VP80RweVExBb/AFhB4Yf/AFqgPXjpQgSCiiigYUUoGe/SrVtbPdBn + bKW0WDI4GdgJx070CbsRwxGd1RQqKCN0hzhQTjJ9qtSzR2LrHYyHzoyyvdI5xID0wCOBUdxdgoba3BS1 + DErkDc31I6/0qr25z7UtybX1Yd/enBd2CM+/HSljUudoIXPc101roS6Zaw6lrkDLE7YhsWJWWYdyDjhf + c9aidRQIq1o01ruVdF8PSaqHle4jsrKMBpribgAew6k/St62uPsqSQ+HQbS2SIx3epSnmUHH5eyjk06c + zana2k+qB4tOjBS0tYNoOM/dAxkg/wB45/HpVqKL7O4ju7aOa5IxbWMf+qtvVpPVu/P4+lcU6jk7y+7+ + t/yPLq1XN3m/l0/4L/BGJpkk9jepdxO8akcHAMsqk4O0/wAPTr/Ouka5OoZs2s9rZOyyhyq59Zn+859v + 5UzTtCeaVp1nJ5/eXBX73qIwefxP6V1VtaQ20SLBGI1UderE+5rgxWLhF6as8zHY+nB+7rL+v6/yMe18 + PI0UaX7BypJjiThRnsOwH+Sa24l2RLCgVIozkKB0oJJUoqk8lj7n1p3LZzgHtXk1a06nxM8CviKlbWbA + bQcgZGc5Ip/BYgYA96ZnCbnOFHG48AVVm1GCLYwG6Jv+WmcJ+ff8M1nGEp6JGUaU5u0UXQRjnGfbmtXT + lF5pd7puR5gH2mEE914I/EGuRkmvZZFVZTCHGQiJ85HqF6kdOTgU/R7+00XXLW8SRGlEm2X9400pVuGz + t+VRz712UMO4yvJno4bCOEryfyXmW/7RsWl8uFnuJBn5YUzVU6jPIwSCBI3J6sSx/EDgfiRTPFMcul6/ + cWbXtnaWhIkhDxl3YNk8KBg+nNYzCG6tHnkg1HUI4BktIRDED7Zzj9K1hhIrf+vyRvDAQWr1/r5I1JL+ + TzJBc6jbRlOyuT+icj86o2zRXk37mW7uz3EduuR+LZNV2vGsrKK8tV0i2DnG1GE0yfUHNY41m4klN0Z7 + xlY/OYj5QJ+orphh19lf1/XmdtHCaPlX9fJfqb2o6qdOmEN1pky/L8hnnPI/CqsXifL7lW3hjAyVCbyT + +JrCuruOaYSvBvBHIlmYnPrVEShSyokOD7Zrojho21Wp2QwNNx95a/15s7C9S9lhh1CN48HjIlSLGfYM + aSymvtQtpYmubBQpwRcTrk/Sub/tHztm6205AnT91jP19ada6sbNZXjSxJJ6PAr/AJZHFN0Ha1geFlyW + sr9NDpnuLq1EcQksWycfJeHj688VWmluWuVV0t3wpOEuM4H1zn+dY8epSXkyuY9KVm6h4kUcevGKtSai + YLiIPpuj3BHI8hxj8cNU+xt0IWHcXqtf68zQtmkn3sNHEqjqxnwf1PNPuLOTTXink0y7gjc/JIkgYZ+t + c9qd5JOxxZLbs3P7t8rj2FRQX+oeVHBG8gWNgVHmEAH2yar2Dav/AF+ZawkmuZO3zf8AnY6Z9VuLW4H+ + nXsCNyRPFn9K0IvEDFmBubGZQMrvVo2P9Kz7m61OI2c902qRR9nkVJ1/4DjGfpTEuvt+poGfT7jBIAnT + yGb6/wD6655UYyWq/r7v1OOeGhJXaX9fL9TootWRm/0i0mjUrkSR4lX35FW7a8t7wf6PcxufrhvxFcpq + zRW0sLC1msLjhd6Sb4ivsR1qzcaddw28NyTHeQSHcLiVTt59SMFT9c1yzwcHZrT+v66nFPL6Timna/8A + Xn+Z1RLJw4wR1zR8rHB71zEeqXVpOFLMm8fLHcDdGw9Vfr/Oti21W3kHlykW82MkbgU/MVyVMLOGq1OC + tgalPVaovFMe5Hr3qOaKO4TZMiNH2GMgD0p+4hVYfMG6FTuDfSlJ46DB56Vgm4s5E5RdzKm0pos/ZLgw + hzyHG9HHUZGP51mTxfZ0iRI3s5SQDAx3QzY7q38DD0NdR8ueuM+lRTW0bo6PGpV/vrjhscjI/qK66WLa + 0md9HHyTtU1/r+v+AcbqGnWU6Ow2WsgYg4yI947MOsbe4ypqhfWLBUj1VNjkHyrwHcGHUbsfeHuOfrXR + 3WnNa3JkthJ5j/JHHI25GX+5k9e/B/A1UjtZh+5s4325In0u5GSByCUJ+mfWvVpVrpNP+v6+R71LEe6n + GV1/X9a6ehTg8RX2niO1vGt5GYbYrx18xZIzxsf++nv1GKbc+H7XU126T/o9+AJJLCVwQ3H3oW6MMdut + BtFuVmg0uF5Iz882nT/eUjH3T+fI59QaxnaO1hKKHubP+EMSsls3sf8ADg+xrpik3eOj/r+vyZ1U4pvm + p6P+t1/XkyneQreSP9pj+zak7qiQpEsUW3GOfesSSN0kZHGGUkH616AFt7ixim8S2zzWtyAINWgO4wkD + hXHtk8dfrWDr2iXumQRbpo73T35gvIvmUj0z2Psa6aVZX5X/AF6f5HbQxCvyP/gfL/J6nMnikqdY/McJ + wGZsAk4A+tTX9hdabObW6i8twcjvuHqD3FdHMr2O3mV7dSlRQRziimMKcpwSCTtPUDvSUlAx3K8g/jUz + qsy+bENrgfOgPJ9SABwKsJB9vgzboBcxL88Q5MoGfmA9h1/P1qmjMh3IxGeDg9R6UEp3Ft4ZbiZIYI3k + lkYKioMsT6CrOp6Vd6PcrbXiKkrIH2hwcA+uPpVqS1At4tR0qS43QpuuJCBGIpM9EOeePSorOKPUmljm + kkN7I25ZJZVWNQOWZmPJPtSv1J5ne/QzRjvTlbYQR+tDqQ2309sZ96aDTL3O+8L+IoryFtH1mNrlJAI7 + fdjIJ4wWJ+UfSsHxL4em8PX6xs6NvG5ChJ2j0Oe9YKMVYDOOc5r0fw9qNv4j0aTw9eqv2rB23DchVHcc + 5J/mK4akXh5e0h8L3X6nlVoPBz9tT+F/Ev1PNzwaK0tY0yTTb+S3YZ2fdcKQJF9RWbyOtdkZKSuj04Tj + OKlHZjkbacZwD1r0bwrrFprOlPoGqzrFAqEqQPml56ZPcdq82q3aXLwzxywkRyRkMrA9x3rHEUVVjbr0 + ObGYZV4W2a2fZlnWdJm0i+e3lRlQ/NE7LjevYisw16hKieO9DDxmSbV4xwqrtSH2PbB/nXmssLRSSRuh + V4+CM/dOeaWGrOa5ZfEtyMFiXVi4VNJx3/zIlIBGRn2rp/C+r6dZ3Vwmo6bFPbXC7Pu5aM9tpPTP51y9 + PRyvy54PWtakFOLTOmvSVWDizS1vRLzRr4Q3du0HmDzIlJzlTWWD7ZPvXawMfFWgDT1tZLrXIeVnZukK + 9Bkn9K4x12OVwQQSCPeppTbXLLdGeGquScJ/Ev6v8zV1Gw0620qxubfU0uLudd0tui48r2PvWVHknbxn + 3NOhkEMm9okk4Pyv0qM5BzWiVtDeMWlZu5p217NHKsiBF4w/lr29x0r0DQpNNvtP367q0k6xHb9lcnp0 + BHrXmUbyKC0YbPRuOMGt/wAP6m2k3dveukMqqxUq/OB3yPX3rixVFyjeO552Ow7nC8d/Lc6mx1+58LX9 + wtlZlrO5bFuLhSpP09azvEWn6sH/ALT1GBE87BCrwQKs694lufFTpFBZjZEcoyKcj8fwrMctqNnK97q8 + 0t5EdsdsFL5A9T0xXLTi01Jqz69WcdCEotVJJKXXq/67nQW3inR7HRktdM0dpbx49sh25x+NcpqFjf2j + rcXNs9r5w3JjjIrU8NeJ4vDcc6zWMdwZOh4yKh13xJqmu2MDXKKlqpIjKrz9CaqlTlCo+WOj6suhSnSr + Pkho923uaunyeGNK0CPUG/0zU/44ZDnr1qpaXGseILA2lkba1srRzMGJCMvoM9a5VZltZgVAlUqQQwx1 + 7Vetdsd5bG6Ba1LjeinqPfFaOhy3lu/M0lheS873e+uvySIdR1G81DAnlE0iZG/qfzqPSmf7V5awpJIc + jDnFdF4jGlzXiS6DbSrbKn7xgmFBrnI7W6vLyOK2QtLIflC8bjWtOcXDax0UakZUtrI09J1MaLqVxb3g + ZrOdSssae/Ss++0+5tJPtsdrJDaOcxuw7V0UeiWH/CN3F3POYdVtnw0MvByP51Z1fxVbav4QisJUK3kW + ANo4NYKq+e8F5P8AzOZVn7TmpRvrZ/5nE3RMipKxyzDmut0C5Ou+F7rQpADNEDJAzencVygsnEBkkynG + VDD71P0e/k0vVILuM/cbn3HeumtT9pT93dao6sTS9tStHdar1RX865TNo0rhFYjbnipome1mWSKQq/sa + 2PGWlpb38d/bYNtdKHBHYmsOW2hjthKbkGQ/wg06co1IKS6mlGpCtSUl1Lt1fXZXfJcM2evNZEsjSvuB + 5qSOZSdvlmQ9qsJpl9cAv5Xlp/ebjFaRUafkXBQpLWyM8sGkLbeCciu08CyS6R9q1ubSXurIIYzKpHye + vBri40MjqijLMQAK7zXP7Z8NeE7TR5pbX7NdAviIEOO5BrLFO6VJfa/Iwx7UoxoK15P8Opx2p3hv9Rnu + gAolckKB0FT6RZG91GJGgllhUgy+WucL3qggGSCenSuz8J6ZbrpN3qcmp/ZpUUgKjjP4iqrzVKlp6FYm + oqFGy9EUfEq6fbXqQ6Hcu1qy/MhPAPpisJsYCEfNnk1JLFcwSLNMpxJllY/xD1qOJfOlVcgbmAyaIRUI + 73HRgqdNJu/md14Rt7jSNCvvESCLgeXGJB1PtUulRaLNp1xJrEbw305LLIwIJJ9KdfeHru1NhpulXjXU + bIJ5Id2VB/Cp5jL441eOxMUenpZRN5rkdSK8qTU5OV9+vZdDxJSjOUp82j1bWjSWysYejPqNjqxl0799 + ImQM9SKueIfFc+sxRWk9qIXjb95nuayIpZdHupbmzuxuicqCDw3vUDat9vu5J75N7P8AeYcV0+x5p87V + 7Hb9XjUqqq4p22fU7XQ9Cv009NU0fUAt3jmAkEMK5TxSdUudTmuNVtyjqBu2jhak8O3f2LU/tcU7COLJ + Ee48/SmX17q2s3NxHmae2L73RF5A9zUU4ShVbdrdzKjTqQxDlJpru9H6HNTJ5cKMSDv6e1QKCxUDqTgC + tBrRL26m+zL5cUKFm3nHTt9au2GgNd+HrvVvtHlmKRYoIuC0jHsB1r0nUUVqevKtGEbyf9Me1iujxXFt + qumrcquCLi3fmNiOBnofpWbpVjLqOoxxpaT3O07pI4eXKDr+laWuTz2dhbaJLbRwTW/z3DLJu8wnkZHt + UmhLbWWg6jqztKLpSIbWWG52NGxHPyjkj9KzUmoOXVnPGco0nN7vRfknvp30MrV5YbvVDBYRSpbBhHbx + zNll9j6c1BeziYwWcOTb2q47fMx++3HXnp7AVUD4y6thicf4mmdBweT1rojGySOyEFFJdh0UbzzLGgyz + nCj1NegeIJR4W8J2uhwvH9rul33DRnsex/l+FZ3gLTYmu5tZu5TDBp6+Yrlcqzelc/rmqy6zqs97M3Mj + cD0HYVyz/fVlDpHV+vQ4Kv8AtOJVP7MNX69F8tzPJwDnr7V0nhK0ihkn1y7ERg09fMWOZcrK/QL/AJ9q + 5pQXcDOMnGa6XxLfWsNlZ6Hplw01jbqJXcnIaRhzjuPpXTO791dTtrJySprr+Ri315JqN9cXsuN8zlsZ + J257c84Fa16LXTPC9vaGG2mvbxhci5jky0K9PLI7GjwvpRvJ5tRltpJrCwXzJhGcN7Y/LP4VkanqEmqa + jPezbVeVudiBRgDA4HHalvLlWyJ0nNQW0f6SKhJz7UYz6UlTW9u9zMIo1ZieW2LuIHc4Fas6G7K7On8O + raaVo11rt2H845hsjDKAyyY6kdh9feuakmknkkmlJeZ2yWPfPWpb/wCzC7eOyd5LZThHZdpb3xTIoS86 + w7jnI3FBuIHc1jGCi3N9Tnp01FyqN6v8F2N/wzZQW5GsavpU11pCkxMy9nPTjIzVzQdJvPKfxJZ21pc2 + dhNIRZXEpdlTGeR049e5HQ0t5bLfXyaB4a1C4u9P8oTSxTTeWm8HJ64z2/E1R8UapYzyRR6fpr6bKimO + 5hjcbCQe2Ov1rn96b06/gvTzOO86srLeX4R81dNN66oo6/qUeranLqdtYx2cD4URIw4IHXjHPfpWVNcT + XUm+aRpJDxuY5NW10e/k0qTVUtm+xRtsMhIHP06nrVFASwC/eJwK7IxUVZdD0KcIRjyx6aGhYOtnbXF9 + mMuB5MSsMncw5YfQZ59SKy81papJtaGwRgY7VdpwODIeWPvzxn0ArNxz0qkXDXUKcXJJPHPXim4o70yg + qe3gSZZC86xsi5VSCS/sKh60lIGFKBwealVo3LmcvuPRlx196ktLVrqUgkrFGN0sgXOxc4zjvRcTdh1p + a/aC0sm5LSIjzZEUMVz04yM0XNx9pKRqqJDENqYXGR6n3PWi8uEmZYYgot4iVjOwBiCerEdaqk9uMClv + qSlfVi8g8/hTlGTnn8KfbwvcSJFGheZyAgXqx9AK7HT9OtPDEEd7qts02pliq2Lo0bxekmehFZ1Kqgu7 + Mq1dU1ZK76I5+G0hSyE0krrdCTCwkdvUHrke9dTHpUi6Y2qanfTnUZmBtrd4w7y46Egn7tPIjcyXeqCe + fV7na9sYmCnj+8mPlHv/APrqVIZtQuWknmMgJxLOATtJ/gQdz/npXFVqt/1/Wh5lau5LXT+tl5EcUd1d + 3P2iCf8A07BaeYRgRwjphMfjzj2Hqen0rSo47ZfPQ+QeSJB87N6tj9BViz02C1jifyliK/6qEHIB9Se5 + Pr/Krck2PnclnPAB7V42Jxjl7sD53GZg6nuUthchRyqbM8cdB7UwkOxyT7AdqBl8OTwc9T0odkhjMkrL + FEv/AC0YcZrz0m2eWk726jlU8AlQcevaq9zqNtZviRlViOCx4H5c1Tlu5rwJ9mzbW7jKyyIS8n+6Bzjt + n9aoJNZ2yvDEc3qZZZZMSOg6YPIWMdeSSa7aWEu7zPQoYDmf7z7v8y3O9xc7ZJZEt13ZQyrvdv8Adj/L + k+vWqU95HEkxtoTLeryGlbLJ67j0T6Dn6Vl2euvZ6rslbdA4KybiQWU/3mxuYD2Aqe6lutT3GIJHaq3y + 3DxiONPTHYH6ZY16MaPLpbQ9eOG9m0mrIoz3c0oDXE7SoH+ZBmOJifVvvOeuf51Yt7iSa0VBugs+Q5Vh + bw5/2n5Z8enWq0dvFCouMh2J4uLoHa3+7Hyz/VuPappru3hxcXcw+0JjD3S+Y+O22IcL7ZOK6HFbI7Go + 7RX9en9M6bXp/wC2/A2l+ILdme7sG+zTNETkgdDk/gfxrh7nUZbKfdLbRs8yZIuHMhH1AOM/UV23gjVE + 8Qy6vo0qziDULYskk2MeYvQgAALx2/2a80lt/IuJoJ54YvKcqQfmyfwFVSpq9pF4amuZxmtjUnh1Kygs + ZLx0tbW8QvFLGgPy/wDAeaihjspHdZJ7+6OflEMPDe/J4/Krll4stbTR47K401L+WGRnhe4b5IwccBaZ + L481cri2+yWi9hDCBj+dVy1NlH9P+CVavdqMPndL9Gy3HpqyWxSDwxqUsjKQJJZSAD64Cj+dX7LSNZt7 + dFTwnpzMvWS5Ykn6/MK5W48U6zcr+91e4P8Asq5X+VZ0uo3Up/eXkz567nJpewqvdr8X+ovq2IkrNr/y + Z/qjofE2lapbhb+9s7C3Q4QJakAfkCa5+zhlu7pLeJU8yQ7RuOB+dVXkLdXY/jTd2O/NdUKcoxs3qd9G + lOFPlbV/T/gv8zoz4R1kbSIIXVm2jbMpBPp1rQuPCuqxurPoCYIxiGYnJ/OuOErDo5H41LHe3EZGy4kX + 3DkVDp1e6+5/5mcqWIf2l9zX6mtqOj39i3mS6XcWkYGfmJbH41nrMy5YZZe4YZpw1zUipiN7O6HI2s5Y + EH2NW9G1+50hpBAsOx+ZFkUHdjp1FO1RR1V2O1aMHdJv+u9yOG4lMqLCrRnOVMchH4/WrU2sXP2hVkne + cRsCPtcYbP1JzU03iez1S5VtU0a3ZAMH7L+6b65Geahjj0K7SWT7bcWMnmARQunmDae5b257VFv5o/qZ + edSDX4/8H8C3Le+bcLd4FuuRh7RsqCO+wnP8q3JtQFxZQq8iSM53JLFmCcHvlT8rE/jWRfaPe3H2ZYJL + PUS42xGzILkAfxL/AI1QuHlOy1nM1nJAP9XcAlM9D8uOP88Vi4Rna39fqc7pU6tuV7f16m7Z3c/2mcTy + sY0P7wmLK9cZkhPTtyv6mrcAgVwLcrb+YcrkmW2kx6H7yH6/pXJpeSWcm9ZHWcdJEbI+oP8ASr9hrb2L + NIjLC8q5ZkX5H/3lHQ+64INTOi2tBVsNKXwnUi5ltCkcTrBMekTtuhfPo3Tp0789a04NViMnk3kbWdxj + O1vu/XNcdHMtxBJLuYRgjMi/My85GezrnsQDWjBLNGsTz+XLayMPLJbMYPYq3WM/7J45riq4WMlrueZX + wMJx13/H+vJ/edgQcdunHvTRwA+ec8g9KwrW+lt2SCIFiWx9nlG0kd9vbPtnHpW1DcQXKgxk7sfNG4+d + fwry6tCVP0PDrYadLXdCyqkyFWVdp/h7GqlzZqyp5vmOI+Y3T/WQn69WGe1XuQcgDJHIIoyAd3Iz6Dof + pUwqyg9CKdaVN3izndWtw3lT3M4hl3AxalD8oJx/GAMg9Ofasu8h86ZLW8+z2mpNyl6hHlXHbJxx+PQ9 + 8V1s8Tku0BG9+HRh8sg54PbvnNc7qFqiQSi1t5JrbaVe3csz2p/vA4xjPNeth66mtP6/r7j3sFiVNWTt + /X9abPyZzMF7qXha6ngCJskyLi1k+aKZfXHT8R0qhZane6fbyy2kkbWszFZrZxvQjsGU8fQ10eo6PLpM + Nrb3rPqGlyqWiaEjzI/UoeeeuV6cVy2p2H2e4D2zma1k5hlwRv8AYjsR3FerSlGe/X8T3sPOnUWut+ve + 36max3OThQCc4HSuhsNattQsl0vXi7Qou21nRRvgPYE919q5xhinbgEAAVWXktnk10ygpI7KlGNRfk+x + d1jRrvRLr7Pdxrl13xSDlXU9CKyyMHjmum0bWIJLZtJ1jDWEzcT43SQHsVPp6is7WtHl0e6VWZZoJV3Q + TL92VezCphN35J7/AJmdKtJS9nU3/B/12MmilYYOAc+9JWx0k0U8sMqSRSFJE6MvBrXntV1e3a+sYSbl + Bm6t0A/77VVHC+voaw1JB4q3aXbWVwk8BJcD51P3WHcH1BqZLsZzi947kmn3C2t1HO8fmQ5KscZ254JH + bdjpVvVLDMX9rWtotrZTSBIUknDOcDlgDyRkHn14qTVLKCW2TVNNRvsspxPGEwtvJ/dHt6GotFvYrG8Y + TRWjrKvlLPcIZVgB6sFHBOPUGp5r6ojm5lzx37FrUL658XXFnDDYTT6qE2vJG27zAOmEAwoArBuInglM + UsZjlQlXQggqQcc+9bF3FceHtSgu9PmuIUcF7aV2VJSvqyqcqD79RUWqXkviC9luo7O3gZELskIxu/vM + STyaI3T02Cm+VpRXumP9asWs7wSJLEQksZBVu5que1GCelW1dWZs0mrM9OZofHGiB1Mj6zGuFSNSRGB2 + x0Cn+dec3MBguZInUoUJDLjoa0NC1iTSdQSeJ5Fi4WWNHI3r3B9q6nxXpcGq2UetaS0tywTdcFYgqgD2 + AwCO/X1rhhfD1OR/C9vI8qnfB1vZv4JbeT7eh59Sg7TkUEc57Uld56xv+HNYOk6gs0oma0lO2aONyu9f + /wBddD430WGSGPWrLylEgGYI05CkHDHBIz61wKuQevFeheBtbilt5dFvpgkLoRGQMswPVR9a4MVGVNqt + Dpv6Hk4+nKjJYqnut13R56RtJFJW34k0Z9J1GSMQPHB96EycMyE/rWJXZCanFSXU9OlUjVgpx2Zo6XqN + xpt/Hc2UssMgGC6tzz1/CtrxXp1mRBqulsZLe4UNKFRiIT6M3Qt6+9coCR0rsfC13Bcwy+H9TmcWlyN0 + RMuI43xnJA6k8cVjWTg/aLpv6HLiYum1Xj0381/wNzjyDnvW0tpYP4f+13Ws4vVO2CyEZY4z3PQVSvbO + WwvJ7SZWSSMnG5SCR24PrUdm/k3Ct9mjuXPCRyAkZ+g61s3dXTOlvnipRZCpwOCQfTHFSwSEEqAPm4ye + 1XtT0DVNKt4Lu/szDHckmMdOnUY7fSs15N3CqFXsBSTUldBGUaivF3R2XhXxRdeHGe3EEEiyNhw/O31x + ipftE1p4kuLjRHa1hulKt5yZ69etcjBO8TRyxkrIpzn0ruLjRtR1rwt/b896s8iceUOMAcc+9cFaEac+ + bvoeXiKdOjU53Zc2j/TQ5q5VLa9MRImbd8zjpzUckCvcm1S5aUZzGkakgn2FdNdQ2es6Jbw6Tplw95Am + Z2UZUevNGheHbK48PXWqfbfJv7ViyqTjBHQUfWEo3e+wfW4wheWj2/4Jx8kMkUpikRkkXqGGCKemFUNu + Yt0A7Cug8RyWWqx2+o2qMLtl/wBMUKcKw7596qWOnyCGO9hi+1mM5ki28Ae9aqqnC7OhV06d5aM6nw54 + isB4YudN1BFV9pCbE+Zs/wA6xkmu7nTEisLDE1k5cXCfeVfcVc1KzfRb3T9aaG3+zzEMYY+QorTPiWC2 + 8RC+0m3PkXcQikjdcLu9a8/RNygr31+fY8myjJzpRvza+V1ujJ1HRpwNP1TUZmnguyvnOB93PrVyCLQv + DmuM7Bb2BlyoXnaal0/SL3U7+80m9na3CgypD2OfSpotJ0yLw3eW940cV/bMcsTgn0rOVTTlb+7szKpX + VuSUm/Jdnt9xz3jC8m1G4SaGxe1siPk3L1rkMBSVzzXc6l41tdT8Lppstnm5jG0SDpXCsPmB6eteng1J + Q5ZK1j2cvU40+SUbWO10ot4h8IT6czL9oswXjz1K1ykFlaI3+lSkMrYK1f0DVF0fXork4EMnyyDr8pqv + 4hFuNWlksizQOdysRilThKFWUFonr/mTRpypV5U1pGWq9epam1OwsmQ6dbAMo5Z+c1m3ur3l8x8yU4P8 + K8Cqe7KjI49aiZgCdp+ldMKMVr1OyGHhF3erNvwrol/rOqBdP2CSDEm6ToCOlWfF+r3+qayyXxjElsPK + Ij+7x1rodA03XfDHhR9ftri3WKaPLRSLk46DBrgJZ3ld5H5eRtxNY037Ws56NLRfqctGXt8TKpo1HRd/ + Mt6XFbz38CXDqkTNhi3TFehax4S0W6e0ttIbE8g3O0Lbht75FYHgLT9Ovbud9QW3dEXiORsE/StjTNAa + 6v7/AFTRdQNlBbkiP5s59QfauXFVf3mkmrfccWOrfvtJuPL9zbOL1WJ7W8a1a5M6xfKrn09K2PBlvpLa + ozazJGkKoSFkHU1lpC9zqwM4e4LSZfYMkjPNegaleeG9Sey09YRbtkCWV12mNR/jV4iq1BQ77tGuLrON + NUrN3WrXQj0m0NpYaj4isLkwqCyW8Z5BX0NUrbVtU0fw5dS3WmiW21AnF0D82T60kOkwNYatfW1y66bA + SsIY/fNZ2tazrP8AYFlpV9bCGDG+MgYLDtXLThzztvr1OKjT9pUcdHqt9HZLb5HNSuUIUNuHWojICu0Z + BJpdrFtuM89KVQqOTIhIxjA7GvWVke+rIfBhXG5mX3BroPD/AIoufDkVw0NsssNxxvdT19jXNkbgME5J + xg10niq7S30zTdEtpYpY4IhJI0Y6u3PP0rCqlNqDV7nPiIxnKNJxupfkilp9lp2sNOtzemDUridVt1Ix + GATyWNO1XQ73QNRlEUwuorPbI08DcRknjPv7Ut9N4cfw3Zx2cckerpxKW4BrnDNMivGZnw+Cyg8H0zVU + 4yk79OzClGc5NptLazX5eVhZppLqeSaVy0sjFmJ7k1ueJiLDTNM0jZZs8UXnGeAHc27kKx9qg8MWP27X + If3AmhtwZp1POUXk8ZGaz9WvhqWr3N2EVI5JCVRV2gL2GPpWtr1ElsjVpSrKK2jr+i/UpMc4A7DApVQu + 6ovLEgADvTM9T3rovBN5p2neIorvVI99sgODs3bW7HFa1JOMW0rm9abp03JK7XQ2/Eky+HvCtloFtKBN + Mvm3QVgeT+o/+tXBuckYGMDH41qeINUbWtdu74ZIkc7eOijp+lZNZYak4Q13er9TDA0HSpe98T1fqwo/ + CjFad2dJXSrVLdJzfEkztJ8oX2A7j3610HW3a2hShu7i2WRYZ5IxIpRwjEbl7g+oqGgkkjJz25ooCyDj + vXRWjf2FoEl0spW+v1MSxNE6Mkfd1bgHPSudXG4AnA7nGcVs/YtZ1LTPt7x3d1YWY8oSklhGo5wOeBzU + zt1MqqTSUnZGWo4J4yO5rq9FmuvCulzapLbos19EY7RpI85B6nOf5iszw1oh17U/IZnitI1MlxOqbvLQ + d62PtMOueJAJdagisNMTNkbuMbJdhHGwYHOO/OK560lL3OnU5sVNTfst0tZenRfN/gQwXEnhzQor+y1e + zmn1CMxXNqYwzIMkg89O3pz61yaKZpQrSAbjy7E4Hua09d1dtd1WS/eC3t9ygGOFcLwMfmazYoHmlEUa + lpG/hXmtaUbK73ZvQg4pyn8T3/y+Rdgjvp7ecwiWaxtG8yRHf5AM+mcc+1XYLsXWo3etSRRQLboGiiiU + hQ/3UUY9OW567TVbU5raFFstOa4FqFVphI3DyAcnb2707UP9D0iysV4eXN1MO+W4Qf8AfPP/AAI1RT1+ + f5GSxJySSWJzmtWw8O6jqWnPeWvlsqvs8rfh2PHQfjWbBA8znarFVG52UZ2r3NaepRafZyx3eialI4Lc + KdyTREevYj3FU29kXJvZbmTLG8MzRyxskiEhlYYINKIx5W9jjP3cUSyyyyM8zs8jHLM5ySfUmo6ZeoUt + FFAEkMMlxIscSlnPQDrVm8miWMWlqQ0KNu83aVaQkDqM9u1QpcvHHKigAyYBbuAOw+v9KhoJtdgfT/Ip + 0aksAASewFIoz16Cup0CztLa2k1a9aEyWzApaXEbbZVIOMEHOfT86ic1BXIq1VTjcsaRZ22i2v8AaOox + JJMd0X2dspNbvjKsFOMn88Vft2ukuVutRaW71WZQbe2lbdtGOHkz7chfxPHWPfNNdx39/GbjUZx/oNm5 + LiJSeGbdyevAPXqeMA2rax88zKtwzgndeXWMmQ/3FPf+vHtnz6klq5f1/X4nkVJrWUt3/Vl5fn+IltZv + dTSs07SF2xPd7cs5/uRj+v8AIV1lnp6WaI7piQDESKciIeg9Se570tnaraRo5jCyhcRR9ox/ie5qym3e + XLFj0x0JNeJisU5vljsfN43GyqvlhsGcZdj+8JwB60qAkh2A5GOKVVLBW2k54BqjqN89sWjtVDsqbpZC + crAM9Tjv7VyU6cpuyOGlTlUlyx3JLu6js5Fi8t552UssSdgBklj2FULmEXcD3tzfRw+XzHOV3RA4+4kZ + 5Y9OT/8AXqNrm0t7VZLktJHKoLRu2HlP8LyHPC9cAVjzzXV/emSOXNwoyzsu2OFQP4R2/wB4/h616uHw + yjt957eEwfLr+P8AX9epKuqXlqZ4Ji6rICfs6/62UEfxt1UY7D/69ZoWe5wtsySOhywRQIYQB6ngn/aP + 61ejtRLaCOMtskJ/et8slz/e5P3I/U9/c9KryRrA9uGjS3RhmYgiIEc4A7/qx6nArviktkerTUV8K1LN + nFbRwpJJskLPuEkillZh/cX70je7YX8KW91aK1WRLljDJnKhwJJhxwMfdQewGfeqIu7hrZpYXFnbhfnv + p/8AXSL6RqPuj2X35rD/ALWgtG3abCVmxzdXOGfPcqOi/qferjRcndlxoOpK71/r+u/oa7PeGMSSumk2 + c3zG4uWLTyj1H8R/AAe9Zp1PTLFz9gtDdSjpc3vIz6hAcfmTWJPcyXLtLPK8sp6s5JJ/E1EWJ4zxXVGi + randDDae8/u0/wCC/wCtDRutWvLtN0t4+QSFiQbVUHrgDAH0qnJtDfI+8HnJqLNAx3rSMFHY6I04w0Ss + LuPTJxRmkoqixc0lGKXFACUUuKMUCuJRRj60YxRcLhRn8aMe1JTGAJFOD4pvejjPegLFmC6kt5RJDM8b + r0ZCQa6G18Y3qQfZNQjg1G3Y5ZZ1y+D6N1zXKU4OQQc5I6ZrOdKM90Y1cPTq/Ejr/s2gaszPp15/Zlw3 + P2W8O6I+wf8AxrnDPh3BxzwMdBVTce5pVYjgY/GlGny9bip0OTdt+v8Amb+hSeXOXWaZWj+ceWckdQTt + 78f/AF62bOZoS9xZtFGkx2SRt81vMPQg/cJ6jPT2qjpVhbXVgRBsupcFpI4/3dxEe5Ts46cf/rqXdKJP + tC3CsMENcqnysOPlmj7emf59a5qiTbOCq4zk1/X9f0jo7G4imils44G8z/lpYSn5vrE9QpqcVvexpJK8 + q/8ALO7CEOh/uuM8nPX1rOX/AFJiWMsyjcbbdkoMffhf09v51etj5s8E9xKN5yq3W0kP6pKvr7/zrknT + j1/r+v6ucMqMFdy2/r+v8zorbUNzrFPt89vuOrDbIPXr1q9t3H3HWuckEtou6CL/AEWTOYd2QD/eRu49 + uv8AOrGm6oJNkHn71wAZWB4P91vQ579q8uthftRPExGBduen/X9f8MbDZxkDk9Qe1RSQt5yzwlBcISFJ + XKt7EdwanZtvTlgcEUxsMNwUlT2rkjJwd0cEJyg7owr6MSxSu8b/AGN333EKfftX7SJ04/mK51rKWLWY + lgkhFwrCWLcv7m6x/Fjpk9PfnpXdSxmR0uIiqXKghGIyCOcq3qDXN6jpiXUM0iKIFUnzVY5Nu57/AO4x + 6kdOtexhcQpH0OBxakrN2/r+v+Hsc5qmhx31tc6hpdq8T22Re2TctAfVe5X+VcqyEAE+vA716Y+6C7hk + gm230KN5U7nPnAfehlHf2PcYrA1/R7W/tv7Z0mNjGTturRV5t2x14HC16dCv9l7Hs4XF2fJLb+v6X3PU + 5EEZG4HHfFdFousWstq+j6u7HT5T+7lI3Pbt2IPp6gVzzrlsEjcB1A4NNGRXXOCmrM9GrSjVjZl3U9Ml + 0u68qQbomy0U2CFlX+8vqKziMV02nXUOpWi6PqEsSq43W9ywLPE3ZM9lP6Vg3llcWF5Ja3MZjmjOGVuM + UoSfwy3IpTd+Se6/HzK9KCOh/OkorQ3N3StUOmtJJHB/oNxGLe5jY7t2e49+49PxqDW9Mj0y+CW04ubO + UBoJwOGB7fUdDWWGOSSevWuh0h21OwfQrgqGk/eWMkrYCP1IHs3p3OKya5XzL5nNOPs5e0Xz/wA/l+RH + p09td2V1b3z2kJKhmvJ1aSbaCAEjHr/TvWKAVlJUhsHAYDg0k0bwyvFIhSRGKspHQimlmcKueB0FaJG8 + YpXa6l3UI4nC3ttGsUEpx5QfcUYAZz6A9qong8GrtlOsDSW9wz/Zph84TB+bHynn3P8AOq9zayWtzJC/ + VCRkEEH3oXYI6aEQJByK7fwdrMcQGmX7yRWF1nDLKRtx1AGcYPQ5FcP1p8bmNwwYqwOQRWdakqkeVmWJ + oRr03Bm94s0FtG1HKxmO2ny0KM3zBf8AaHaue6GvTLN08X+FZIJ2tY7q3X99dXL7pWxyCO4HbrXm8sbR + yMrDBU4PassNUck4S3Rz4GvKcXSqfFHR/oxlWrS7e3lieIhJYjuRwOc1VoBwQetdLV1ZndKKkrM9Svoo + fGPhlbm2hMmoxrlsHJBHUewPUV5hLGYpCpGOenpXXeC9eaw1PyJ5TDZ3XyuIx0Pb6VH430JtP1L7XDbN + FZXHKEtn5u/0rzsO3Qqui9nqv8jxsG3hcQ8NL4XrH9UclVi3uJIJEkikZZUIZWHUEHjFV6FYowI7etei + 1c9ppNWO41u3XX/DUHiCPfJfRny74k7icdGPYDpXHxyGKRJYsrIhyrDt71u+Frm5nvDo41P7DZ3x2zOV + BGMH16Z6Vmapbx6dqV1ZQzefDFIQkg/iHrXNSXK3Tfy9Dhwy9nOVCTut16dv66HV2tqviezOreJvFAhh + Ryiw5G4cdQv+ArjLlYI7qZLeQzQKSI3IxkeuK0NBuNKg1RZtZtnuLRVP7tD1btWl4qt3ma31W38Ptplg + wCJno59cVMG6dTl6PbZIim3Rr8j+F7bJLyXVs5hWOcV1fhjX7zTFmtIBGVu18smQ5VM98VyhcsF4Ax6C + poGI+XOO9a1qaqRszpxFGNaDjJHd6NrF3oOrTWGnXEN0LjChiMDce9Rarok+ha1aNrBElvcvvk8rgYzy + PwqtNe295odmLSwaO8tT+9uIhwfc1sXGkHWfCra3da0bi7QHELsMDtj615b9yfM9L6PueO/cmpS0vo+7 + 7PTYIL/R9F1bULBJPtWl30XybRko3as7w7p2rnVZ9Psbo2nmISwkHJX6Gs6TVkudDt7EW0KXFq5ZbgcE + j0960fEHiGLU4tNubfzItQihCTuvG4j3q3TmtEt/02ZTpVF7qWr0u9dtn8y3b6JZ/ZtRttVvdl9agmMM + 3yn6UsfiTTV8HnT5bf8A01OI2Qd88HNck8jXExeWZmY9STyadGPmOEJA6cVX1dP435lvBqSvVlfVPsdP + c+Irq9udMvbZTDeonks+M7/c1j+JIL6DUWfUJWaSUAkjvWhp2hajf6W91GVEEB3HJ5HvW/exaTHYW97f + TG+mEeAg6mudVIUppRV+hy+3pYeqlTV91pq++55equZRFEPmY4ANLqlhPpt19nuChkwGO1gcVZuZDf3+ + 23jEKscIHOMVmTxtHM6OQWU4JBzXsQu9T36bcmr6eQwNznPNa2qa7JqVla2zQRoIF27lHLfWsf8ACgDL + EdB71bhFtN9C5U4ykpNbCHmtKbQdQg0qPU5ICLR+jg1m9qvf2pfPpwsDcubQHIiJ4zTlzaco5c2nKP8A + 7a1A2bWH2yU2rYzGWyOKpM2TgHgdKsWNoJreeeQ4SMcH1NVOlKMYq9hRjCLaijQtNSa2tpIgineMbu9W + 7G9ukt3gt7po0l4dM8EVjMuDgYpyFl6Eg1EqUWROjGS2O98C3VlZ620t9cLGQuELDjP1rdnuLDUk1rVb + iGGQJi3t9vGT2avLYrh0B71oWk7CAnztmCCq54JrgrYO83O55WIy9yqOrzWeh2eoaLcafHpWl2s0stxc + 4klgY/IO9XkulvPFT3XiAJFDp8WxY9uUBxWBYeI7+y1uPVbnFzL5ZRdzcAYqzP4mt7jQZ7Hyv9Mu5t00 + rDjBNcsqdTa3z9dzinSraRavfqt9Xr+Gg+w0Sw1q71bVpXWCzgBaPy+Oe1UbnQbzTvDttK+yQ6hJ8kW3 + 58dufetq50XT5103SNNnU3EmGmdG+XHckU+zi1e48Wokc63yaYMRmThRjjt3oVZ7p6eflt94RxLV2paL + Wz7LRfezMtZ9Gj8V2smp6c1jBbQnfG3zb5McZ9q5S7lF1f3DpEZHlkLoy/wr6AV29xqayaDqt/qdin2u + 6m8qJiOBjrj6VHo3h+xn0Y3lhq6W+pOjRLG5AGT25/nW1Osoe9JeXkdNHExpJzmn27ruecOGaQt1ye9M + Bw3StPVtJvdGujbXqgOwyGDAgis1QWbAGTnAr1YSUo3Wx7dOcZx5k7o6awgtrHwdfanPaubm5cQWku7A + UfxED6Vypxiun8Uj7BBpuijzUFtD5kqu2RvbnjHtXLknNRQ1Tn3/AKRhhE5J1H9p3+XQSnYwvUgntTa3 + vDWjRa9qBtJXni2xlvMiiMnTuw6gVpUmoR5nsdFWrGlBzlsjD3EKVDHB6itTQbJLq/8ANuIp3s7VfOuD + Bt3Kg7gNwee1M1ZLezvZrS0n+0QQSfJMFxuPQn1q1fQvpOhw2s9syXd5idmli2ssZ+7tcNyD3BFHNdK3 + UXPzxVupUtm0+TXTLeLLLp/msXWBQjFOccdB24FVr+W3kvZmsxKttuIiWVssE7ZrXeS40rwwLeS2szHq + JEiyEq8iAfqp/wATXPZPemtXccdXcKKWgAscDrVGhPDA85igit5HuJHATb1bPQAV119HLYR23hrSBqcF + 5eqBe210AAWOOmOx559KxtCGmR3jXOrWt1JZqu1WtWI2Pxg5P41LBdqRfap/al7HqqOv2LDFnkU5B3P7 + LxxWE/el6fmcVa8526L7r9Pu3Kuo3LWeoTwWEvkxKohkFvI22XHUnPXPNP0GfR7e+ddbspJraVSokRiD + Ef7wA61SthaxapAmpC4FsGBn8vG8g8nGe9Sa0NOXVJ10iSd7HP7ozDDDjmr5U9DbkVuTXbf/AIJUujAb + mU2wcQbz5Yc5O3PGa0rCR9N01tVttREV47mFIUAZihHzE+lY1OVgrZC5471dtLGrjdWLmmwRXWowQzye + XCzgyuT0Ucn9Kv6pp2qX4k1oWUhspmOx0O8Io4CnHTAHeo7RUtfD91clyLm5dYIQkgztHL7l9D8vNQ6Z + q97o9y0mn3bQMfvKpyr+xHQiolzbxMZc7blDddykJmS2MK7QHbczDqR/dPt3qNAS2R2rrll0LxOiRSxR + 6TqpOBMpxBKfcfwkn8K5m8tXsrie1m2iaFtjbTxkHmiE+bRqzHSrc7cZKz7f1uVWJZiScmkopa0Nwooo + oAKVRk4oHJqe1t5Lq4S3iAZ2PFDdhN21NTQdKivJhNqC3UOmkmNrqKPcqOQSuc9u5710bGbEV5qk8l4V + ULp9rIn38n77D+7noO/TpmmaPBG2jvI7SQWcDDETKVF3KDkKRnHHc+lWLaK81LUGuZJBJcyqNkiDiNOm + cep6L6Dn0rz6tS8m3sv6/wCHPIr1eabbei/r/h/8ya1spZpZlaYvcOR9tnAzyf8Almp9T3x/IV09jbRx + RRsqBcL+5Ttj+99PT16mobG0t0jSExkQLxG3I3nuT7t09l+taDBgG7zOcZA4x/hXiYvEOXuo+bx+Kc3y + L+v6/AkUEFiW+c8A+tIFJwWBPHpyaFBIAwRxyaivZpbWNDDA0jynauQSqjuxx2rghFylyo8uEJTlyoiv + bg+cbKGQJKy/PMeUhX1OOhrLa5isohEd3khd8EoUl53zjcVzz7Z6/SquoX6WkbpbbprAEC6Z2H7+T0U9 + SPXFUCz6ncPLNchIo1/eOoyIQeMD1Y4wPQD649mhh1GOp9DhsGox12/r+rfqKkb3c8rySqqR8yS/eWEn + qF/vOeee3bHUWlWAW6xeWsduB5iwu2Pl7PMev0Ucn+cckqReRHb2uJAP9Htm5IUkfM/8/U/Sq8btIZGt + 7pV8tvMuLqQfu4zyNx/vP6ADj65NdVnI77OS7InuJmkm+zeTJc3Mq/LAp2u4HQyY/wBWg6hB+JrIv9Us + rVFM5TUtSUYVV4trXnOAOjH9PrWfqevIsUlrpQeC3k4mmZv31z3yx7D/AGf51zzMW7AcYOM811UqHc7K + GEbV5aL+vu9Pv7E91dy3NwZZ5DLIfU5GOw+ntVcsTjJzjpSZ/KkrsSS0R6SikrIdmikHNWLeCWaURwxt + I7cBQuSaGDaSuyEAnpT1jdmChTn0xzXRQaHY6fiTXb9Yn27haWwEspz2J+6v4nPtTo9TkjkzoWnpZLkD + z5CHk/77bhfwArF1f5V/kczxF/gV/PZff/lc59rdophFOGhbPzB1Pyj6VqG10OCIbr26uZfSKEIv5k/0 + rd1+1juzp19qN5Jd6jdqVnjsgr7iOF+bpnHXGelMi0a9hVB/YlrZJIeJ9Sl5/IkD/wAdrN1k0m3Y55Ym + Mopt2+aX56/cYUt1pKpGINKkLKcs80+7f7YAGKv3klxJb7TomnWSFfvN8rY9RubNP1LTre0sm83xFaTS + KcrbWqEhj9cAVnGPTZNnkW2ozycb8sAD64wDTXK1dfqVFQmlJX+d/wBbFhNXu7XYiS6aoHcQI35naar3 + usXUtysv2uB2HeKIKB+grStrBJkLReEb+Zc9S8hH6KKy9Tlt1cQx6OtlIn3gzuxP1yaIqDei/IdONOU9 + I6/9u/53LFvqt1Lt8zUbJPaW3B/9lNXS8v2cvu0C6UDJ+UI3/sprK0yRri4js4dMtLiWZtqiQsOfruAr + VltoNJ1E22s+HjvC7iltcEcHv/FUzUU7JfkRVpwjKyWvbT/gFGSCe8tDcR+HgsR/5a24fH6k0iw+H5cK + 82oWL4wd8SyqD+BB/Sr8t54cNtLHaHU7GZiCjbtyqO4OCCaY1vfywGW31Ky1KPHKSbd4H0cA/lQn3uv6 + +aBTfW8fvX+aKMHh/wC2eZ9g1CxuGX7iNL5Tv9A2Ko3mlX1jn7VaTRbTyzIcfnUyfZRZN9o06XdnAuYp + CMexByD+lXraa4Fi0VhrqmE4L2lwxTPTscqeR61pzTT3/r1Rtz1Ive68/wDNf5HPY/Git86jpOo3SDUt + PW0CqVaWwGMt2JUnH5Yom8NtJCbnSruLUoQeVi4lX6oefyzVe1S0lp/Xc0+sKOlRW/L79jAozTnRkYq4 + IYdQeCKbWpuSRTPC6vGzKynIKnBBrp7DxClxMkmoP5N2o2rfIuS3tKv8YPr1+tcryOhpVfbg85B/Cs5w + UjGrRjUWp2T2r3DRTRgQRs5K45RyPvMn95fbr9cVsCVZZ3klZjMFxLaKzDOP4lb1GMjOa4mx1S5t4PKW + b/R94cxtyuR3x2444rrLOZNbf7Qz7Y7c8KrZkjUd+Blkz6cj+fFWptb7Hm4mk4r3tkWxdSicxxqssch2 + MsibY5zj7rD+CQAjkcH+cMV6n9ptHZ7ROZBtaY43DPMcmeM5A5/yK2oJfT3xnUSF5BzyCJlHpgYJ6eme + D1rOaB13eWkkiy/eUHLAD/6/eslBNGMKUJQPQYJPIijZwwiIGVLAvA3HGM8LVw5Vd2VJ+vB/GsA2c8Es + MW4RXojxHKxBFymM7DkkE9s81PpuobdsTo8Nup2L5hAaF+OP938K8mvQuuaJ4GIwnMnOH9f1/WprH7u5 + cfMORjtUN1bNMVljZRcoPkPUOv8AdP1qxtycdD2IpvUfMSfXHUH1rjjNwd0edCbg7ow5lEkbyW0EyDIW + e3GWaHHRlOOCO3qOKoT3F5pl0+pQYcuuy/hTlZoz0kC+/fPQ/Wug1CGXcLm1QGdBh43GVmT0I7msS7tp + zINQsZQ5ZGO3g/aI/wCMEc/MvQ+oAPavXw9VT1PoMJWVRf193+T/AMjkfEuj2NiYLnS7hrmzuI/M37D+ + 6Ofuk9M9MiubOQ3PWvRIJLXSUEM+668P6kMmLIzbydAT7j+Vclr2jXWh332G6WMMBvjkQ5Einpg969ih + Vv7r/r/hj6DC17+5J+j7/wDBXUyFxuG77p610TSQa7o0gleNNSsUzGx+9cpnoT1LAdPaudHB+YED0qa0 + uZrS4jngfy5Ym3I+Ohracb6rdHVVp81mt1sViDnpSVva3Db3cSarp8EqQOALolflSY9QPbvWCRg1UZcy + uVTnzxuFSRyMpUo7K6HcrA42/So6Kosv3Qnv45dSdjI+/E5OOCc4P4461SVmjYMpw3Y1c0+7htLxXliE + tu6lJUYevcfTqKjv7M2V1JCWDBcFGUg7geQePakt7ERdnylUVo83+mgdbi0XOSeDF/iCazasW1y8Fys6 + EKQcHjjB46fTNDKkr7EFJVu+gjhnbyzujkG+LBHCnsevIqrTGndG74a1kaRq8VysMRjOI381N4UHq2PX + vXRePNJaQprtqJHt5VCzSuoUMT0KjrjFcEjFTjsetekeFL231fQ7nStSuUVlTYpYF5CvbaOnBrhxKdOa + rR6b+h5WOi6FSOKh00foebEbTg9RRVq+spLS+mtmGGjJ+9xx61VrtTTV0epGSkk0SwttPA5yCDnpXpoX + /hMvBrSS3EsuoW6/LEhAUMO5HuO9eW113grWYbDVFt53aG0uV2TFSST/AIVyYym3FTjutTzsyoylTVSn + 8UdV+pyciFHKsMEHBpldN4x0lNO1eRreymtrWQ7ofM6MO5H41zNdFOanFSR20Kqq01NdSZZCxQMfujjP + tXY+JY7rX9As/EaWlpb20A+zukPDZHcjsK4kHByOtdb4XXTbyG7ttYmlS3khaS3AfCCQccqOprOsuW01 + 0MMWuXlqr7Pz06nNCVvKCDO0NuA9DXT2IsdY0W5n17xDcpLbjFvbMSQeOD3+lcsV8qV45ARgkYxg57Vp + aBJpcWrwPrETS2Y++q9fanVjeN107bl4iHNDmW6103+V+5mA4bnoeKQHaeeorY8T3Gk3WuTTaLE0VmwG + 1Cu3BwM4FYrEs2SeauD5optGtOXPBSatc6vw94ouNFiuIIYopo7pQrpIMgH1qpI+ZSZCUViTsQ8ViRuw + +UHANbmk20M6FppjtiYFolOGZe+DXPUpxg3O25y1aVOlJ1EtXuVyAsmQcgelPEU7zRDy3PmnamRjNdJf + WsSkx2OnvF9nPmK8r5coehI6EfSptbNxrelwu0hurm3yPKt4dqxj3xWP1jVHP9b1WmjOel04Qx3RuL63 + ingIAgJJL59COP1p8V9DbXVvNaQ4CjEiyHKk0ySxFvpouXEZLfdUPlvxFW57DTrJNMuHuhdLNzPAow6D + 0puSej1KlKLVpO9xPt7tcXKxTyhZgSIrdTtz6Y9KzlfUJLWdkKRQx8OJGAb8Aea2L7VZ9H1C4fRrV9Pt + blAqiZQx6ckE9K5aaKaaSSRyWbOWNVSgnqVQpp62SRWZizZJyT1pmBzk1IVAbuRR5bSNhFJrsTR6Csia + 4tyLSG4RGEZGC5GATUVqkLXcS3LlYSw3lRkgd61LEPdaRcWbSn92d6RAc59c+lY4HX1zT6C3TRq+IbfT + bXUh/Y0kktptGHdSMt3rEPeu3upf7Y8CwhShmsmwIYYeg7sxrjoUjkuFWWQRoerkZxWOHm5Rae60MMHU + coOMt4uxfnV7XRYY84M3zMKzK0dcwmoGBWJWEBBms7rWsNVc3pO8ebuOxk/WpXzkZ7CmJncK77SfAMer + aFFdR3ypdSZOzgjFY18RCik5nPisXSwyUqjsmcIM4p/WukvvBWsWEzAW3nqv8Sc1gy28kMhSSN0YHkEU + Qr06nwu46eJpVtYSTEWZlG0MSPftU1vOA+ZG6VVxjsaDwvvVOKZbgmbNpdPFJ59vK0TLwCp5rd0vW9R0 + GxuPJVWN1k7+rA+tcVG5HQkVa/tScKqbyVXpmuaph+bQ46+D51ayaOlHiC1uotHtb2JltrOQtOMZMmTk + nFaM8Wh+MNRdba6TTGjUrGvCiVieDjtXE/abWSJ/OVvNP8QqiGy3yvjHSksKnrFtNErAp6wbi192upc1 + OKaC/ngnuPP8glBIGyDj0qz4Xshe6/bK0KzRQ5mlRjgFV5NY5kJTG9iGOWB9a6bw60dh4f1rU3EJdoxb + Rb87gW6lfwrpqXjTt12Oqu3Cg4rd6ffoYut366jrF3dIuxJZDsXsq9hWbSk80lbxioqyOmEFCKiugoyO + Oldr4c1I+GfD13qIFx9ovB5UQMQ8vH94N6g9sVyEARjtYnc/y8jge9dd43v1ig07Q7a7huLS1hVleKPb + liO/PPr+Nc9f32qff9Djxf72UaLV09/Rf0jj/MBZmkyxOenHPr+dOjlWe6Rr2WZo+AzL8zAe2TUT7C3y + ZwB39e9IVATJJDZ4BHaug7kkWtSuUvLsyKcnAUvgLvI4ztAwOMcVULFmyzZPqaTvyM0UwSsBp6ABS2SG + GMDFMrR0qawh1GKTUbWS6tVBDxRvsPT1pN2VxTfLFs375dV0rQrPRrbVrO8sdSO8RWuGbdx8p4yOcVn+ + INRDyWlklkLUafCInjJyXk/iYkc8mrNo2kJrGoX1ndXNhbWsRlsFODK8nGBn65/CudYz3tyeJJZ5nz6s + 7E/zJrGnHW7/AKuclCmua7W2u1tX+G2hASScnvS0+SJoZHjlRkdCQysMEEetMPFbnaBqWC3N1eRW8WFa + VggLnABPHX0qXT7SS6ufkhMyxKZJFDbfkHXmobhojcSGAN5JY7A5yQueM0Cv0NPXrhJLwW1uipb2KC3R + VJILD77A+7ZP5VkZJJJ6mk70UJWFGPKrDlBJAAyTwBSucv1II6k9zUkGESSVgDtGANxB3HoR9KgoGFHa + itHS7RJ7wNPsMNuvnSqXxuUdh7mhuwpS5VcgltjbwQu/Eso3qA3Re3HvUaxOsJmMLNGflDYOM1LfXRvr + 6W4cbd7ZC/3V7D8BgVNe38dxhIYnggjAEUQfIB7sfUmpuxJy0uUNpBOe1dNodusdvLbtZ+Ze3Qxuniws + MOMtIDn0z2rJ0u0jubtEuZGith80soQtt9OnqePxrto3ZbZ/trD7XdRCa9JblLcY8uIZzy3B9cbfesK8 + 7Kxy4qpZcv8AX9f8DuVLtor+eG2gLLaom2FcYKRdSzYH326n0HrXQ2FtGkLFZipkXzGkC42oBgtj1P3V + FZemWp86RrmHzTJteVRwfm+5COp54yOoAHpXSW6xz3RIIKwNumYA7ZJBwFH+yo4ArysTVSXkjw8bWUI2 + 6It2qeVArtEFcjGP7g7L9fX8adIrN8sZCkfxetPUjduYkY7etClnIBxkdq8JyblzHzEpycnNil1Qb32p + Go7nNYeq6k1tcS2sEwEsif6VPuH7qP8AuKe59fy5q1eXQmuFtYiI2zuWcZITHBdiOw6D1P0rKvLFoZnt + 0mPlIq7t6EC4kPI38/KBye1ejhKCj70j18BhVF81Td9DIZBfzqRKtvbxJlTj/Up6n1dj0HX+lp9iGCCO + NUKrvt4mIxGO8s3uf88YzC7ngAiVMloR2dx96WT2HOP/ANeYbaG2vluWu7qW302HDz3ZXcbiTrjk9+cD + 8TXqtXWp7jWl3sv6/r/hyynlJb3MzzqtqhH2y9cbnlbP3YvUH1/PiuW1jWmu9lvDEttZQ5ENshyFOfvN + 6k+tN1zXJdUlj2qkNrAPLt7dBwi9eR3J7msb1J6110aNtZbndhsNb357/l/wf6QEnvzSUUDHc10ncJTg + nAPr04qzZ2k19dJDaRNLIzYSPqT/AExWzH9n0aSFbLZfasW++qbo4m9FHRz79PTNTKVtEZTqqLstWV7b + SYo4EutUnNtC67o4lAaWUf7I7D3NWBcTXCummwpptjjZJKzYLf7z9SfYflTTbqs4acG/1KRsmFSSik/3 + iOp9hx79qdLLGJl+2Y1C8AAS3jOIo/b5ev0Xj3rLVvU5ndvXX8vu/VjYoLYQOLOBrpx9+6nOyOP6An9T + +VUpvLbYGuGnkHUfwAdgPX8qvTqWjWTUrnj+Czt8DA/kv4ZNQmCaaIyw28dnbLwGdsM3ryeW+g/KhNf1 + /X5FRfVv+v67I07u/wBbfRYJ91tY2cDA26K4jkYnjKj7xx61L9p8NhEkFvqes35HzC4kKpu+gOT+dYjR + 2q+W8cpuJx94OPkHHT3rpfI8RjSIJQmn6NZgYSRmEUje/wDerCSUbdPw/wCCzlqQjBK2mvfl/wA2zmYL + ySHUy32W3zuK+ROnyLnsQfT+ldQusavZ2qxr4j0yyiHHkWygsP8AvlT/ADrEtbXT55i95e3V3O2WaK2h + 3Mx92b/A1N9qtYNiQeGVdiSFa4ZnLH6DAp1EpPb8v1KrRhVaXLt5L/27/IuSapHOuLjxdqsoPLJBC2M/ + iw/lWKzWkOqxzwx3N9bD5mW6TBc/gTWnbT+INJt5Ht9I+zQlgzM9pwD25atGDxR4xltopY2sjESQpdIQ + fyPSkrx2tb1S/JELmp35bW/xJflEpjXtBE0c1vpTabdRMGSeFvM2n/dbiiXVpr/VX1RfEsUd2y7A0tu0 + Z2+nyqRUOlaJrx1hrqHT7e4lcszpKY2jOevGcVa1ewutPljbUvDFuqycL9lYgE/8BJGam1NSsnf5p/mS + 1RU+WEru3dP5e9r+JLcnxBe2Ds8enalDtyZI442YD8MMK46WaCVm2xGL0VTkD861N+juGbF/ZyLkAIA4 + H15Bqg1hEYhLFeQyknBTcVYfUH+lb0YqK10+Vv8AgHXhoxpp3Vvlb8m0a2hW+qG28zS9Vtlk3HNm8wUt + jp8rcGmeIZ5pEWG+8PxWN/nPnRKYw47/AC/dP1FXW0y6SBXudAs76BV5l06TD499hI/Na5/UpleQR2z3 + qWyAHyLt8lG7gYx/IUoe9O6/r7n+aIpWqVuZW/rzT/NFvQ7K4cNcWklhNMAQ1ncMAzj2B4P4HNRQyRTX + oeJ/7PuRJ8hVjsB+vVf1rNZgclPl5+7jOPpW9Z2q2+lS3NvLa30UybZ4HUrNAw6Ef4jP0rWatqzoqJRd + 29/69PvJLm/EpNp4gsw0uflvYgPMA9Tjhx/nNUr3QZIrNr+zkS7sc8yx/ej9A69Qak06ISs00zu1kp2y + HaGK+hZc5Ayeo/8ArULaywo97pc4kjjP76HIZlAP8Q6Mvv8AnioS5X7v/A/4Bkv3btF2/L/gGFS5yPet + LU57K9Mc1raG3nYEzRocxk+q9wPaswcmt4u6OuEuZXasOViOQa0LK9e3uormB/s7xsCrK5yG9f8AHtWd + SqxVgR1HrSlFNahOCkrM9N0vWotchlhMJa+fiW3BASXA++h/hI9BVVrqSxvxJafvGLf6112rKcco/wDt + cDoev1rhLWaSOZGSQqytlSDgg13mm6hFryu8+57pFPmxIQPM/wCmiDpuGOf/AK5rzqtD2butjxq2FVBu + S+F/1/X9W02u45oBHvc2txlo22+Y1sc8oe4BPp60reY10FK4voUxMuTi4j4yfdl/pTrUrFZtHMEZHIF0 + zZAP/PORSOzcAk9DWA80tvqCxNdZkJ82Kckg4x0PsQAuK5YQ5m0v6/r/AIJxUqSm2l0/r+vv3Op029AK + 2rOGUkLHMxIL55A5+n9K1doLdcHBH1rmMgwqUj2puby4VznOcyRn3/iXit2yuDcQFZmTzkUHP3fMU9GA + /n6HIrzsVQ5ffieRjsLyv2kfmWATjcpYuAR1rNu4vsp8xXEMNwwcuWP+jy9nGOx6GtLOCOF3DqBSsgkV + gQhjkGCo9656VV03c5KFZ0p36HJ3cUVs0xuwrQXIKXMCqT5Eh+7IvbHce1ZMlvJqNkfD80lus9oWmtLh + wAJUAORvPOPQD+ldDeWq287tdl5TDHtdAcGaLnBHqynHtwKx57Z5kGmiaJ7y2BuLG4AyZUA3FM9PoPUE + V79Comk1/X9fkfU4eomlJPzv+v8An5ehwDgg8jAzjB7Uw5+ldd4mtxqllH4gtoiofEV9llysoH3goHCm + uRwVJVh+FepTnzRue7Rq+0jfqauj30EE0lrdEixuk2TDG8qezKPUH9Cap31lLp99LZ3CmNkOcHr04P4j + FVRxW1Mw1TRI9qg3diMMETl4v7xPqDx9MUP3ZX7ikuSfMtnv/n+hh0UY/KitDYATjGa1gx1LRSjEfaLE + ZUswG6InlQO5B/Qmsirmn3z2F5HOmccq4H8Sngjn1HFJomabV1uinRVzUrRbO+ljVleM/NEyNkFTyOe/ + FU6adyk7q6NKAfa7J7QupeAGWN2k4291A9TnP4VnVJDM1vPHNFw8ZDDPIJqa+iUXPmRkeXKA4yRwSMkc + dPpS2ZK0ZVFbOg6tLpmrQ3ULCEL8rsqhvkJ54PU1j0qMUbcDzSnFSi0xVKaqRcZbM7/xzYR3dtDrtrcy + 3ZOEmlEBRdvRTn17V5+eDivSPB7r4h0e60q4t2neNCFmlnO2ND0wmecEda4G6tGtr6a1JDGJiCRznFcm + Fk43pS3X5Hn5fPkcsNLeP5dCtUkEphlWRfvDkH0NR0V2NXR6TV1ZnoutNH4g8I2+qTXNzc6jCNpjjXKJ + 65A6cDrXnTYDEA5Fd/8AD6/X99pE8UrR3ynlZNoBA5z+Fcfrlimn6xc20bq6I5CsmcEe2a4sM+SpKk/V + eh5mBl7KrPDvpqvRlAMQCB361c0u8exv4LtFV2hkV1VhkHB71SpyEhwRjPuK7JJNWZ6UoqSaZ1Xjq3mf + V4tXay+zQ6hGsiKH3Bjjk5H4GuYVhnt1rqzBDqngKSeS7u5bzTpAFjYkxxxn04/ziuR6VjQfu8vbQ5sG + /cdP+XT/AC/A63Xr7wtNoVrFpVlLFfYXzWI4B78nrzXJHmkz8uMAe9O2nGccVdOmqatc1o0VSja7fqAO + DnvWxotyYLpWUsNxCMEfazA9cGsccGrFvIYpUZPvetOpHmVh1o80Wj1G4tY7C7sxKLiCxZNqxyPucqeT + 83QjPao7aaYXH9m2M8tta3b7TI64Ctnpms+xdJvD1vdRXrzXUD4aCQF2XnqpxwOlaguFu4rgKXDTx+bD + Gq7wGHBJY/nmvDqJrc+aqRcd9en9fmVJdKtdM1O90vUL+NFaEyRTBQSW9D3FZjSaTL4ZaJY3Gqo+VdRk + YzXXW2h6FcaLFfu4kmZAW81+pHWsFbvTrKwv7C3sZLqZyTFIgyVH/wBalCtzO2rasOliOfRXbTXkipqu + qX3is6fZxaaBNGmxXA5fA61kL4cu5/EEel3bNBKxwdx4ArpbXxNdw6fYW9rYot5A2FlPJz06VHqmi+It + Qvk1C/URu5GJF421rGq6fu6RR0RrSpXg7QWttbv1F1zwLY6Po0k325Hul5Ck4z+FefBWLnHB7kGvVZPB + FtFAZtT1Nmk28bnrF8Kz6FZ3N1FqNuJn3YiYDdkUUMW4wk7uTROFx7jTm03NryOP0yN7e+SWSOUwMdrl + V4IqtqESQX8qJ9wNkcY4r0HX/GdobGfTLXS0RT8qkgAr74rgtSuJrueOaZVHyhRtGM134atUqK842PUw + derWXNOHL8zqPAEcepS3mkXM0qQTRltiNtBPvXH6naiy1Ge2yCInK7gc5xV3Q57e31i2e83fZtw8zacH + FT+LUsP7aeXS43S1kAK7lIBPfGaIJwxD7NE006eMktbSV/K6MW7YNeTMJfNBcnee9RjrTOpqQCuzZWPQ + tZWHL161u6Xb6yQ0mn+cViGSUPArFijLyKsYLOTwAOtdzo3iC+8O6DdwTabIhnBVJipAHauTEyajaKTZ + xYyclFKCTb6Mrab481jTlbzGE6553+tblj4v0K8tHXVLCMSuclwM9a4i4vYn0q3tEjCyBy8rkcsT0rUu + 4NJXQrOC1YS6hIw3Fe1clXDUnb3bNvocGIwNB2fI4tvdfmdIPDPhrWFL2OoeS55C5FZGo/D3U4GZrVku + E7bTzSeIvCx8M2FpcNdZlmGSnQjiqVvqmvaRardhrmOGUfu3b7rCsqaqpc1KpdeZjRjiEuahVutkpIy7 + 7SNQsCEubKVPfaSKzSADzn3ruLT4j3oYfboIblAMYK4qDxD4i0HVNIcQaUtvfMw+cdK66dWupKNSHzR3 + U8RioyUatPfqmcQx5NNBwc0p5pM4Negj1EA5NdbqRnsPAmlWHlyBLp2uyWdWVsccADI49a5WGJp5o4l5 + eRgoGM8mul8bkQ6rFZRwrCLO1SEqgwC2Mk4z3zWNTWcY/M5a/vVacPV/d/wWcrSjk4JwPWkpV/CtzrOp + 8DwLL4hW6liWWK0jaRlZThsD8s9+fSsXVruO81K7uIIxHFLKWRQMbV7DFdNpLXOieA7zU7eaPN85tpIp + R/Bj7y+/JrjD1xXNS96pKfy/zOGh+8rzqdF7q+W/4nUeArbT7rxGsWqSWyWYjdmW4A2ucYAyenXP4VB4 + 0stPsde+yaekcaxxKZCku9Gc85U9hgjiuj8Eotl4Y1K+vdIF5ZyfxLhmAXOeD0HvmuCcm4mcxRf6x8Ig + HPJ4FRBuVeT6LQzpSdTFzld2jpvoVTnjP1orU1bQtT0nD6jp81qHOFJX5SfY1l11xkpK6PRjOM1eLuCH + DA+lddotzrHh7w7carBLaCzuz5JjkXcSeRkehH1rk0BYhVUlmIwB1rdv4bDbptnpepTSJcAPcRXDbY4Z + emT2/nx3NRUV7RMMRFTtB7PfS+i/Iiu7iKLQrOwGnmG63maW4kHMqn7mPQYzUvhhbRL24vLnWP7OmtIj + NbMqbi8g6KO1UNY1KfVNTlublo2fhB5QwgVQFG32wBWzOJbDwjDp1xoojmv5FntrwgbnT0HfPT86mWkb + dyZpqCj1k+/37lS31URWWpyX+mi6udTX91dzD/VtuO4rxjP06YrC6nGBxW3r+p300NjpV5ZratpkRh8s + ZBJJyWOe5rERGckKpJ68CrgtLm1Jac1rX/pfgX1iW30nzJLWYTTtm3uFchSo4YY71nfhitPVpBmKwt9T + a8srZMxFl2BSwBYAH3zWXVIuN7XYUUVZtEU3SFvuxgu2T1xzTKYtwQkcduGwEG9hnILn+XH8qrU53aWR + pGOWYlifc02gSFHJrWmWTT9GihYJ/p481gQCQqn5SD1GeeKqafZ/bL63tyxUSNl2xnanc/kDTtUvPtt/ + NMAgUkKoRcAKBgcfQCpersZyfNJR+f8AkUwacBgfSkXjn8KmgiE0qpnagGXJOcDuR60zRux0fhlGFvdv + eNt023C3M6d52H+rjJ64JP5ZPatWXdcO81y2+UsJZ8rkSTEcL/uqDg+hJHpVq7uFMFtbxXovYLVFnllk + TAedl+RT7Ioye2A1SaVZ+bPGVLuFAfOBncfuA/U5dvYD0rzqs73keLWq3vUen9fr/l2NKJJLK3jjRi93 + OWWFmPLSEYeQjOePuj2Ga2be3WztUtoiRHGoH+83c1S0xRdXEuoqf3aL5FsDn5VXgtjP+ea0VwGzk4HJ + +teDi6l3yo+Xx9ZylyLpv6/8D87i44BYZ4qpfzrawhN6xhl3PJnJjXuSPU9APU1YmljhhkmZWKoMkA/k + K5+7EommneVRHbhZrpHUOkkn8MYx6D9anCUeeV3sLA4f2kuZ7IvIRp+ni4k8tbq4XMAflQAMZY5HCr6j + rWJ9qhlgW2upVEDLuaVQd0Ueep7F5D0HYY9ap6lfS3UnniTMsiKhiTnYucrGCSTz1P5UMqyKZdpIjkwg + BJ864xgcHnaox2/nXswppK7PoadBQV5bv+v6/wAiS5tLl9UGnu0SW0kImuGVs+REOQvtgYOPeub1/XFv + TDZWu5NMtflijHBk/wBtvc1oeJNWW2sBocUqzNuEl1dAnc8ndM9wK5BjuNd1CltJ/wBeZ6WFo3tOXy/z + /roHQ5zk+tJRR1IFdR6AAE9BmrdnZPezCOMER5+aUrwv1pdOsJdSvY7SEojMTulc7VVe5OegrVLo4fS9 + KkCWYAN1cnIEuD95s9AOw/rUyl0RjUqW91b/AJDyRG0um6JMDFsxdXpyokXOc88qozj3/Sn2dvv82Cwm + EEITFxfScAr7eg7YHJ/SooIorqEwrJ9n0+M5aZl++f7zep7BR/iaVY5dXPkWxW2063G4mQ4HHdvUmsm7 + HO9F/X9N+QsETSwypYyG2sduySdhl5z/AHQByfp0Hc1DcSlEaztIUgx98t98+7N2+gq/FdM6PBppVURd + sl9NwEX0H90fTk1kC3Ll3ttzxIMtPLwCfYf5NEd9R09Xr/XqbmkHybU/YraBZxkyaneN8sfsoPH8z7Vj + O0YmW4mla7BJ3E8An2/z+FXIljaMTzP9qgiwokmJWJT6Ko5Y0xLS7vpWvIx5Vsv3ZXUAtjso6fyAqUkm + 2RFKMnJv+vz/AC9Cwyag1jvWO3sbdsYeY4kk+mfmP4YFWLcWFsLeaXT5tQuZDz9pc7Wx2VRyR9aybi5i + mdlld5XY87G3O593PT/gIrUtl1yGxjjhMOjWZGRK7CN2z3LH5z+HFRNWW9vw/wCCZ1Y2jq7X87fjuy/c + 63rWn2ZS3tbHSEYEABFWTBPYHnvWTPJp4jBm1+7uZTyyQW52g/VmH8qqkaLDcO15d3WoPzkwDarH/ebn + 17Uf2xYw8Wui2o9HuHaVv5gfpSjTt8K/D/PUVOio/BF/JJf+lXZXe4tjM2RdTxY4Ek20/wAjSLLbBiy6 + fEwA6PJIT+hFTt4ivuRF9mhHYRWyL+uKQ+I9V2sBfyneNrAgdK15ZdvxOlRqdvxf+RnGc5OxVj5zhSeP + zNbVs1nNbJv154pgAfLZJAAfqCf5ViRyLFKrqc7SGAYcH61qjXo5M/aNJ06QHusRQ/mpFOpFvb9P1HXj + J25V+X6mnbpe2oLWuqzvG5ywtplm3H1KHB/OqNzK8s+26SzZvS4tjbuffK4H5moHm0O6Vf8ARLmycHlo + pPMX/vk4P61ctmvngVLDWYLqL/n1ucA/Ta/GfoahK2r/AMvxOflcdZaPzVvxV/0GW32fTJEuZbW4CYK/ + 6NcjC56EOueeOhzWdLLeT3Rnud9zvB/4+SdzgdPmPeprsxrc7b/T30+TGCYVOPrtY/yIq9aalqDAWkE0 + OpWoGfs9wmSfYA8g/wC6apaamt3H30rvz/R6/mZlvpwV457q1ufsvWQR8Oo9RkYI/wA5rWuWiuVSVpC6 + w8x6jAuHGMYEqZ684z1+tRm9jdoo9PeWycPl7O4fMYPqrHp9DUc/mpf5EJsNQ3bXQ/6qTnPf144OQabb + b1JcpTd3p/X9aq67kzTZnjllkjtLsjEd7CP3M477wOnvx9RUX2V/ti/Z1NlqkY3LGjfJN7oeeT6dD29K + l/dSPJDDC0UzHdPZvkxvgdV755qkZLcQiJGmnslGTuX57dj3U9x+h9jzQgin0/r+vu7WJTaw61kWyra6 + kud0J4SYj+7/AHW6/L37elYsqlnfcoSRc7k6c/jW06NezrHKYnuwuY5MYF0o9+u/0PfGDz1nkaHVUjju + Nsd9nbBeZCiQjPyS88N0+b8/Wmm4+hrCbh6fl/wDmKWpbqCa2uZIZ4zFLG21kIwQah5wDjg9D61tudKd + 1cWtCxvHtJI5opRFKh3Kyk5J9/0rOBpRjPTI9KlxTVmKUVJWZ6rp+owa3ZLc/JGYFIubdDk/N1YDuCec + dBiqd7H5oeJthkQ/LkjCsRwRx9yRcAdg2Oma4zRdVuNKvUuYGVcE8MMhgeoI7iu3mlt3SG4swJYJEdgo + xvMfWSM/7Sn5lry50XSndbHhTwzw9X3dnsZ1lcsjp5twsaTuqsckCGQco/1OM59Q1bEFy9tfDBhS5Dnh + myA2PmQk8AP1HvWVLBHNfNs8uXzYy8RA4fsc8ZGTyPQmrsVw81gHzIb21Gy5cZGYgc5weNyHH6VNSKki + a0Iz1tv/AF/wDqYpEeASRyLIOikjv3B/GlUEkhgVRhgBeMHv9KxtFvgXMG+LaCFJ3MC7kff57cgH3xW4 + OGzwR35zXhV6TpysfMYmi6FRxKV5bv8AZ0mj2tdWu4xq3zB1Odyn6isC9t1+xCS3dmSMfaLOVeWC87lH + PVSc4+tdV8pfcCeOT7ism6tjFceRChHnsZ7RiuVSUdV64ww/nXXg632X/X9f5ndl+IafI/6/r8rnLMZb + dpBcki11IrHerHtADH5kcE8AH72f94dq5bWNJudI1Ce0vFCTQtjHXep6Eeox3ruZvKlljt0j2RsjAxsM + ny8/OhGOsb/Mue1Z3iO2l1Tw/HqElws99p7fZ5xGhGIuQjE5+or3KNWzXmfS0K/LNdn/AEv8vuOG4PGa + s6dd/Yr2OZlLxA4lQHG9O6n61WIwMelJXc1dWPVaUlZl/VbRbG9ZIzut5QJYTnqh5H41mmtxf+Jl4fdC + QbjTzvGTy0bHBH4HH51iGpg7qz3RFKTas90FHSkoqzU1ZCb7QkckGaybZjPJjOTn2APH4isqtHS7lYLk + REloriPypAcDr068cHBzVGSMxytHkEqxGR0NJaaGcVZtDK0kR7jTJbcl3ktT5iKoLAIfvknoO1ZtXdPu + EhvYmZVKMPLkDZ24ORyARnHX8KGOS0KdFS3EJhupIAd2xyoIIOfyqPBBwRg0ykza8OapFpusW9xcQRzx + p8pRiQBx1464re+IVgi31tq1oo8i4T5nijKoG9j34riYyAeRXpcfmeK/ALowvLi7sx/rCwEa7f8A7GuH + EL2dWNX5M8rGL2FeGIW2z9GeZHAPHSjNOI5HWk6V2nqov6TdNY3sd4jhXgdXVS2N3PIrr/iHp01wLTXV + UrbzooClgSMjPbtXBKcMD6V6DbJDrvw8lWSeeS+siQibiQqjkcfTNcWJXJUhV+T+Z5eNXsq1Ouu9n6M8 + 8ooNFdp6h1ngvULG1vLmHUHWKC7t2RpWTeFPY4/+tXMTqiSuqNvRWOGxjI9asabe/Y9Qtrlo1l8mRW2y + DIIB6fStXxjbSLrb3j2sdvHeqJoo42yADWCSjV9f0ORJU8S/7y/Ff8A58gjBII7jNdb4PuYC+pabefZx + He2rhZZcHY4GRg1yOS3Uk1o6NqT6TqsF8iqzRHO1hkHjFaVYtwaRriKbnTaW5QIwSPQ05WwQas6nIk2o + TTRIypK28AjHXr+tVBVJ3VzSL5ops7Lw3dfaYmtXVZ7gqywxgAFSe+TxW5YwX0K2sLlC8M5RwTwg9Dz3 + rkPDl6ILzDlFTO7BX72O2e1dRceTdtM0FvLFZq4Lvzk57HvnnivJxMbTa6HhYuDjUcbaM37DQ7fUru8h + uH8tUI2iMgDBqhpF+nhbxBd2kdu15DINqMpyc0/yrC31S0LLdSWhXDZGGJ7YPejxA9q15bGK1nsLdHGZ + gvPX6158dXyvVM82DblySbcZI5zULq9HiFpI7doJXk3JE3auo8Q/8JLd6As8/lRxxruKofmNZXi64sor + 6xv9KklkKjLSsOGPbmuhtJ9V8TeHJJZbiOCPBzsXJIFa1ZNRhOySNsRPlhSq8qSWjuYHhTR4Nege41TU + JCqHGxnxx9aq3sum+HvGFvLZFJ7RCNyA5x681kabATqi2u15EaTBjRtu6ug8beGv7OtoL22tUgiwNwDZ + Oa3aSrcsnpLodMlGOJ5JyfLJaLpqZPjoCTVk1GG1eGC4UFCwwG+lcxO0klquANo56816DrJGueALS+nv + 42mtRtEZAB9K87Vy/wAmCT6Ada7MHK9PlfTQ7svnelyv7LsV0OCD3BzXY+KtZs9c8O6c0MTC6t1CyFUw + o7da5JovLYq4ZWHUEYNdx4c1nTP+EPvtI1KVV3Z8sLFlzn3+tVidOWolezLx2nJWim3F9OzPPVHNWpbK + 4t0V5oJI1cZUsuARVeJGeRVCkszAAeteh+NtULaDpmmvYTWsyoC3mAEEAdjW9Wq4zjFLc6K9eUKkIRV+ + b8DiNPunsruK4jUM0bZAI6133ijxJq91oFpHe6WlvBNhldf4gP5VwEcQDD5vm6itzWvEep69BZ21wiCK + 1XaojGM/WsK1JTqRlbY58TQVSrCfKnbciuLyy1PWoZpYRb2ihVdU9BWpomhW/iDxFLHpE0lvBEN6uwyQ + R3rmxctbvIgQMrjbhhzWha6jd6ZKP7P823kdcP8A7VKpCXLaDs7BVpz5LU3Z2suxN4i1HUtR1T7JeXP2 + prdvLQqOvNaHiLxBevolpouoaebUwqApP8QHesi2huNO1G3v762mMIkEjHB55z1qXxfryeI9b+0ohSBQ + FQHsKmME5RSV0uvmQqUZThFRTjHW67mMbOc2n2kRN5Gcb+1VCWwBniun8RrYWmkWVtp148gYbpUDfLnH + pWHfWYtFtgfvSRCQ/jXVSnzK7O2jV543ZRPWkoPWgdea3Nzc8J2aX/inT4ZER0D7nUvtyBz1qv4guxe6 + 5f3AJ2yTsVy27gHjn6VueA1kivtR1L7Ik0drbSMzswyjEHBFclKxY9c9/wA65461n5JHHD3sVJ9kl9+v + +RHTlGTgdTTa0tEghutbtIZ1BjaVVZSD079K2nLlTZ1VJcsXJ9DpvGMF1o+haLo73XmweUZwDGAVJ7Z7 + jk1xIPzGun8cT2kniOZLDb9nhRY1VCdq4HIGfeuXFY4ZP2Sb66/ecuAT9hFvd67W31O9uvEGn2HgODTd + L1GWaaUBZ7eePPlkjL7DjgZ965rQtOttS1iCzur5bSJ85lIHBxwOSB1rIBwQcDj1rqfC95pVlDdT6toU + uoxMy4mUErH6j69O9S6fsoS5d2TKl9XpScLtv0vd/ch3ja9mju4dFF689rZRqoZwMu2MlicnPauSPfPW + rF3NHLdzSwxCOJnYog/hU9B+FVq2pQ5IJHRh6Xs6aj/Vy1YTva3cdxHO0MsZDRuo+62ep9vzp097cy6h + JetIDO0hk8xRgbs9QKqUuOPrWhtyq9y3ZgXV+gnmWLzpQJJmGdoJ5OB+ddRPZkeMrSwtPEMd7b6egltr + m5YGNNo37MZ55AGBWb4aL2l2mpRaNPqCxEIQMlQ+c56HsDwacn2C9t9d1a80y5aGViLZoOI7eViSAx4r + CbvL/hjjqtub7JW6PV6epiajey6lqFxe3DBpp5GkcgYGSc8VUzzTmPAHOaTBPTrW6VlY7IpJWQlFFFAw + q0uItPduN0zbQCP4RzkfjVWrl8SjxW+QVhjA46ZPJ/U0CfYqUUUCgZq2bfZtMurwhS8v+jR5PI7kj8Bj + 8azOprT1X/R1t9PGQLeMM65yPMYAtj9B+FZg9amPcyp63l3HZ5GBXTeErJfNm1O5tma3tIzMs+4BQ65w + pB67jgetcwOSBnHvjpXfw2vkaBpWlm3DteXH2uQNDtPlLwqjuwPWsq8rRt3MMZPlhy9/y6/gRxwQ3Mqf + bLl45JC01wyr8rZ+Zzjg/wB1OM8hvWt2G3nh00CJ8XNywAKkgKzjp9AmB7biKjtbZJZpHESyW833n53C + GI5cgjGdzZ7dq1bRZp9TRp1ObaPzmyf+WsnOD9FwK8nEVbK/Y8HGYhqN+39fnoy8ypa20FtHkhVCjA/O + pcAjoMe/tTB8shZgBjpt59abNJHb2zTHdiMdPc9P1rwdZPzPmbOTt1ZVvJ0E5VljIt8MvffM33AfT1zm + s1ja28N1d3sl1LDZhlhdFAWa4P3mLH3wPpUt/JNZ2kpUq00TbEYDO+4kHJwDxtX8M1ka6r6elnp8RRHt + owzqrlxJKemFPp37c4r2sPSskj6HCUbJQX9d/wCvPyMxLZrq98pJB5hc7sLjc5+/wB6kIO3U1p6lqQ0j + S1uopCtxGzQ2Lo3Dt0llxn32jt+VUtNtj5/yuFP/AB7QyY+VCozLJnqMAn865vXtUa/1BmiYi1iXybdG + OdqDp+J6/WvRjT55WeyPXjS9rUUXsv6/r5mXJIXmy+SN2Tz19ajo5J5NFd6PXSsFSwwvNLHFGMyyMFGe + nNRrjq2cD09a6SBT4f0sXDbW1PUIv3QHJiiPf6npUylbYzqT5VZbvYLpFs0OhadMkjH5r25U/K+OfwVe + eR1qK2it7iF0MrQ6XBhncLlpn7D69cdgKZFZ5P2COVUO3zLyYjhQOcfh+pOPSrxure2FtdTQK9tFlbe0 + LYOMffbvkn/PSs3pojmemi3/AK/pdkZ8t0t4ElnKx2kThVt0PQevqT71oXbJeWImkIstNT/j3hAy9w3f + 8fUngZrJihZSmo3Nuj2zSkCLfjeeuBjnHvV+SZppmuppcSIArMgGIR2jjHduOvbn60NK+g5xV1bp/X3+ + Ylw67F+1oI7eEfLaRcBc9Ax7sfz69KkEDSmN76Myyv8A8e+nx5AA7F8dB7dT7dadHGsAE0nlq6DKo3KW + ue7f35D6f4YEEfn6ksqWzfZ7TObi7nPLk92P/so/U81JOy7L+v67sDdxpc5mjW9uwAsMMY/cxn0AH3vw + 4+tPuEl2J/bl80SKMpaQ4Z+fbov4/lVZtTi0/Mej7kbGGvHAEjj/AGf7o+nNZG8s+SeSeSTzVKDev9f8 + AqNNy12/P/gfmax1lrcY0u2SzXH+t+9Kffeen4YrMlnkuJDJNI8jnqzsSfzqLdRmrUEtUbwpRjqtxTx7 + Uuc02lqixaKKMe1ABnFGaMcdKMH0oAM0m7HTtS4puKA3NSDWL21hWFpFngbkwzjzE/I9PwppWzu5criy + lLDahJMf/fXJFZtLuNTydjP2SWsdDo7t7i3MMOvWpuYCv7q4jYbgv+zJ0YcdDmlUzQWayI41PSz8oV+H + hPoe6H8xWfZavcWUJtt6T2jfNJbS/Mh+nofpVlI1kLXuiyOvlrmS2ZsyRjv/AL6/5NZ2to/6/wAjncHH + R/8AA/4DHhA1n5iM1zbgYOf9dbn19x+n0qSAXP2oTRSRm5ZDtyv7u8TuP9727/Xq21jW/aXUhcJZhPlP + kjmMnHLL12HOM8/0qSR44Fkt0QoxGbi2AyBgf62M/Tn6e1Ilu2i/r+v67kbJbvCMzMllIx2cljaS+jdw + D7devUVGyTST3C3agzoo+0RdDMv/AD0X/aA5z3HPTNSCaY3bkOtw8sZUtg4uo+4P+2PzyPXrXaKVjbNb + zFwozbyngqRz5Z9/T6+hqkXFNbv+v6/q5afbq8cdnPOJL1VUWVzwFlUZ+Rye46D349K514pFkkjkBR48 + goeMEdq2m8t7NZE2LBM+JFxzby46j0B4/DI6gVLeRtrVnJOQq6rZL+/QADzoxx5gx1Yd/Uc007ehcJcn + p+RzdLQRxn0/WkrU6Rytgg+ldN4c1RrbzLGR444bplPmSE/uXHKuPbsfbNcxT0Y5AFZ1IKaszOrTVSNm + d7fSTbntbVEYvKW3KvCy4O5FOMYYZwPpzWVp4aG5S5Tezq3mSNIAQV4GQD1Ixg1sW1/FqPh4XM6lpLdV + tZiOTt/5ZSryOVIwfbjvUt7DF/YrTYjN9bylJdh+UgjPPP3X9hjJ964b8q5WjyuflTg15Ms3UQtjHc2q + 7LYgne0g3PEx+ZOO4Y5PcfhXRWc/2mBizwmZMBwhyP8A9Y5B+lczptwLmyaEFJJo2aS2hP3EZR86kdgV + 6AVNol7HB5MS3QZZE8wHdtAXGCoB7nHfB+UetcGKo88H3R5OMw7qU33idNtxtb5OOGHtUN7b/a7V40+W + ZDviKHlSvI/wqdo85OeCOD60xCdgcIzMvBz6etePGTi00eBCTjJSW6Od1IrewrMi+Wt8jOnzDMM65BHP + TdyD3ORVG3S3ja0murmZbbUFNrqJ+7scdOcdDwfzrdu7eRJbm1jVme5H2q13cqkqctgZxkiuZnSS9uLg + tdi1trxDcR24QN5sycbcD7pznn3Fe/Qkpx8v6/r5H1GGmqkN9P6/r1Rx2p2L6dqU9o4P7tzgsuMjsRnt + VHHPPArsPF+/VLDTtbET7mj8i6cRbVEi8DJ9SMGuQIGPevWpS5opvc+gw1R1Kab36+qL2kXa2OowyOQ0 + T5SZfVTwc/zqO+tDp9/PbuNxjb5T6jsfyqmK2tVY3mk6fqOSXVTbSnPOV+6f++SPypvSSfccvdqJ99P8 + jDPWiiitDcB1rT1U+esF8U4uY8McHG9eDz68A46c1l9K1YENzod3FsJa1cTK277qk7W+X67aT01M56WZ + l0UUUyy9qE63MsVwsjPK0SiUlNvzDjHHtimykSWSGGyKRRH57jlizHsT0A44H86ZlTZ4CrmNx8w6nI7/ + AJV1un317q3gi40G20Wa9MDmX7Qj4WFevIxyeG6+tZTlypM56s3TSaV9e9rLucXyD0rtvAOoW8OozWN+ + 0629ymAkUhVd3uB14zXEmtHRdQm03VLe7t22SxuCrdcetTiIc9NoWMpe2oyiLr9mmn65dW8SssSyHZuB + B2np1rMPWu6+JFldJqFrqFzdwXJuYhtaFNvA6ZH41xDHcxbHU8/WjDz56aYsFV9rQjK42u7+Hd3m8uNM + nuZYre6hJKRICXP5Z6ZrhDWv4ev2s9csrh5ZVRJArsjYbb3wfpSxMOek0GOpe1oSj5FXVbVLHWLm2UPs + jkKjeMNjtmqNdh8RLGKDxELmAgw3SB1Jk3HPfJrj+9VQnz04yKwlX2tGM+6HKcNXY60sep+CtO1Jrue4 + vrdvs8qt92JBnaAMew5rjK7Pwqi6n4d17SwkZkMX2hGIywK9hUYh8qU+zMsb7ijV/la+56M42nr94cgH + rk0w0V0Hbujq/Fmqw6xaaXPHbOskMAilnCbUdvb9a5auoTWEufAk2kG0md4bjz1mUZVFPBB9O9cvWNBW + TjbZnLhY8kXC1rNlywuXtblJEwWBwAenNd7HPBtjkuXETPFs8uD5lLAcE15wnB969B0dxN4fctYxb1GI + 3Q8gjuc965sbHaRyZjBK0vkbcsmoT6Fb3jxlhC25X/u46cCrer2F7rGjiea7iB8vft6D/wDXWZpCtPot + wceRsJ3MXzvHstX9FudLbRZVu18uYZ27/wCKvGknF3XRngVIum7xWsX+ZRvjYy/D5IHYveW5wRjOOaq+ + DNVgNvPY3k8whbhYY0yWz71o6HqaLp+p6eti0wkyUCcnpWT4Us9U0vU11AabI9uxKHPGK3bi6coy9UdD + s6NSE973WqMzVkudJ1kXFvbSWqhv3ZcV09/4e1nU9DN9f6x5ihN6wr92pPG0moyxme40+KOAjGSwJFU9 + I8PeIdZ06J/7SEFk6kAA5OPTFU53hGV0rfMr2rlRhUbUWtL7so+ErTRb2xvbXUXRJc/KzHgD2pbHVPD+ + g3hhj077VP5uFlJ+XGap6Podt/wl7aVqMwCqTlwwAJqv4y06w0nWgunzJJHtzhWzg1ryRqVXFt2lr5HQ + 6dOrXcHKTUlfyG/EG3ddeS7a3WFLhAVVfaj4f3bQ+IxFHa280k6FVM5wFxzmtPxcf7W8H6bqKBP3QCMQ + CT+JrgoW2SoS5QA/eXqBXRh4+1w3I91dHVg4/WME6T0auvuJtIMS6vamZVeISDcG7iuk8cz2tzrKJZys + 8KIMKZCwX2FY3hSNH8QW29Y3UNkrIcKRVvxDIjeJblo4Y44w33YzxW09cQvJHRUSljF5I6bwTpWk3ei6 + hcakkDmPhQWww4rI8N+G5NfurxorkWsMIJDEZFamnJZJ8Pby6Ng5lZyPNXt6c1b8Cm6t/D+oXMd3HFGA + fkkTIPHrXnzqSiqk4vqkeVVrTgq1SL1ukrnIx2Ut1qyadZ7J5w5CnH3iO9S6zHqNtqOb+ERzRkAKgwK0 + fBovpPEpvbOGOWRAzMDwBmoda1M6hr2+5VxMZwHVecYPaunnl7Tl3sju9pL2/Jo0o69y3rHjK5vtEj02 + 5sVhwB85U5IqWTVvCLaBsFiftqxhQcd/WofH+r2epajZxWylEhjAkJTBqlr0XhcaXA2lTyPdEDzFbIwa + yhSg4w0au76fqc8KNNwp+7KN3fT9TlSqu+d2FJ/IVY1KaOa8/dMzRogVSST0+tV2gO3IYUxoZEiEpHyM + cA16qPbVrrUho70UVoaHV6G9ra+D9buDKyXcgSFRkgEE8+x4Fcox5rsJZbm2+GkEMlqBFdXhkSfeDkAY + xjr1rjz1rChq5PzOTC6yqS7y/KyAdc12fw4imfxB5yQRyrGC7l2wRhT0/E1xntXoPgYyWHh7WNQMpRBA + 2zbIB830/KoxsrUXbroZ5nPlw0kt3p95yGt3i3+r3t3gqZpmYLnOBn1rNp0jbjyTnrTa6Ix5UkdlOKhF + RXQB1r0Pw7ea9pfhKaTTtQ02S0MUk0ltIfnj5wfxxzjPpXnijJx616FrWm3en+EMaho1jFJFFFFHdxSf + NknPIHU461hiGvdj3Zx45xfJTdtX1t+v6HnxY4POc8U2nOO+eKb0610o70Lj5c85pRnp0x60silH2kMC + vBBqW2XfcxjyWnO4fulzlx6cUmJuyudXpQvbG0uZ9C10GG3sPPuY5AQodxtZFXnJHHPFZMlzpcXhGK0h + E51Oa43zsxIQxjOABnB5x+tTXFxpB0e98uxmtLya4UQRlmKJGOWBPfnHWodX1aLV7fSrOGOO3Szg8pmP + ALZ5JrnjFuW3X+vU4owcp3s9/JbLrbfUw5CS/XPbpWhp8AaC+umiVo7e3xnI+8xCg8/U/lWcqk5IBIHc + VqHZD4aIGzzLm5GfvBgqg/gQSfzFdDO2W1jJoooqiiWCHzriOPKruPU9B9aWeZpppZDjMjFjxU1rlRPP + lx5UW1WAzyeMH04JqnSF1Fq/pECzarbCTiNT5km4cbV5P4YFZ9a2nZi03ULxs5WIW6NnoXPT/vkNUydk + RVdolK7uGurma4bG6WQuR9ahooqkWlZWL2l2b32oW1qmHaaQL5SnDHB7dq7KeSF/Ed7c2olazsIxb2xl + k+aNlGAOf9ok49qyvBamG/uNVmsWuLfT7dn3gfLG2CVz+tX9IRRpEaGQCW9uMSEDovBznpnB/WuHES95 + +X6/8A8vFTvN+St9+r/BHRwQ21vaQQRyhluXCZAwBCnzMSPU9f8AgVaekEy6cbp1Yy3cryHdzgH7o/LF + ZN4fN882y7B5KWcPTG5zlh+C8d66WOPyQkSDCRoFAzntXh42VoW7/wBf5HzGY1LQS6v+v1X3EJliQ7JG + KnGeV4qG+dTbtKgWVoSBGA/WU8KCOmB1/CrJkRZNzN8qgsQOtY+pypbMknRLdGmkXO0+Yc7eep/Djmub + DQUpo5MHTU6isv6/r8zMXyzqcj3Uk72emxn5k+UiY8kknOOQT+Fc2ZJbq5FxG265unygH8JJ+QfXOW/A + etbd5JFZ+H4LUzI814WublgORGBkjOcZOAMY6g1Q0SCe5vFuFby5w/lwlB/y0Iyxxg42rj6YFe/TSUXI + +roJRg5/L+vV6jdZuF0rSWjgkGZVNrAQf4FOZZBz/E/A9ga4tmJOMnHpWr4g1FdR1V2i4toh5UA9EXp+ + J5J9yayG9OK7qMbR13PSw1Plhd7sSiinICx2gZJOAK2Ok2NDs7eaeW/u0xZWSiR0Y58xv4U/E/1pZLua + 6uptVuADcSviBFH8XsPRRjHvirV9B5QtdAhlVUi/e3T9R5pGWJ/3Rx+dFoYTLLqDkx2dmoSAfxFu349T + nsawv9r+v6ZxuV25vrt6f8Ek8mPTbMJODIS3zxjkzyj+HjnauefU59sUooTeXU1xeSboY8NcOOMeiL79 + vw9BU+2eaWLaAdQuU2xRrwtvFjrnsSMnPYc9TRdywW1vBBCA8MRzEmP9c/eRh6dgPQfXIvxErr1f9f1/ + kiaWaS7miRsRyNHiCPcSLOHrn/eI/Hv1Iw2PyYsSgmO3g+XeBnyvp6yNjr/D+HAtq+5rISgXLgzajctz + 5Sjnb+Hf1OB2qPEOoJ5smYNGshtUD70jHsPVm7nsKQtF6f1+fT7yJEW9i+13X+i6ZCcJGvLOe4XPVj3Y + 9PyFVb7U5LuNLdVEVlESYoE6D3Pqfc02/wBRe/kDtiOKMbIYV+7GPQf41Rq1HqzeFO+sv+G/4IEk9Tmm + gZNOoA6Y/lWhsJj6E+lOC7v/ANVatrorG2W7v50s7ZhlGkGWk9lUc/j0q3DrFpYIyabpkW8jH2m7HmOP + 90fdH5Gs3U6RVzCVa+kFd/h95UsvDmqXyF4LKVkxkyMNiD3JOBV5vD9rbKovtasIM8lIiZnH/fIx+tUr + 3UdS1WUveXc07dPnfgfQdBSWuk3V/K0dtG0zKM4iQt+HSspOW8pW/rz/AMjGXtN5zUV5f5v/ACGX0Gnw + uq2V1Ncr/EzxeX+XJrSS98LrGofR71nAwxF2Bk/981Nb+E9SijMt5psojPAMk6Q4/wC+qrvoDlztl01B + ngPfxk/oalyhLTm/H/Ih1KM1bnvbs/8AIikl8Oyzkpb6jbxn/pokmP0FPGl6TdOFtdZVGboLyEx4/Fdw + qCHR7q71QafaQwXE+MjyZQVPGT82cU/UdDvtPlYXmnXNqv8Ae2ll/On7qdlIp8iajGo0/VP8yvqWkz6d + KiyG3lDjKPbyiRW/Ks90KsQV2kdQRip1UFhJE5+U5BBwa1l177UBHrVml+ijAk+5Mo/3x1/HNaXkl3Nr + zil1/A54ikIrel0a3vVMui3LXWOTbSLtmQfT+L8KxHjZM7gQQcEHrVxmpGlOrGewwHBzUsMkkUiSQuyS + q2VZTg5qKk7VRo1c6G1uDfz/AGm02W+rx/ejCgJcjvx0B9V6GnEC/T7VbZt3h6qGObVs/mYyT/wEn8+f + UnggncDwR2rdgu5b9/tsBVdWgUl1xxdJjnjucdR3HvWco21Ryzp8ruv6/wCB+XoNVjErxyZjy+ZUUcwS + dpF9jx07f8BxaikSN2N0w8tzsu40IA3Y+WUduev5+tV7gxuq6nahvszARTxFstFxyPp6f/Wq1K9vbwIk + Uhlby8yZHE0B9M91549vakyJO/8AX9f1YgkdrSX7RPhorkGK7iU8gno2PU/eHuDUBkm0y8SaJ1ae1I+Y + ElZYj90+4IOPoR71LKYxuCziZkTZJnpNERlSO+R0x2wPQ0yIblW24klgUyQZ/wCWkZzvjPv1/wDHvamV + tv8A1/X5ehHr1lbxNb6hYlPst4CwjX/li3dCf88YrEPBxXT6KyXSXOgTSjyLr5rd2wNsg6ck4Geh/Cub + kjeOR4XXDoxBHoRVQf2Wa0ZNXg+n5DaKSirNjo/DGpDT9UC3AUWtyphnU/3H4z+Gcj6V09oYbDULjT7o + iZIFNtM64IaFj+7f0yrEfgwFecxnnOTuHIrs4LhbzS7PVpQpFu32G7yOWRs7WPqRn9BXJXhrfuefiqSv + zd9Pn0/y+4kiN1peptHE4e8cheQf3br3zySSvp/eranVLW7eW3SOVlxeWyyHGVP38jOPQ+vFZGp2Mz+V + fxPHHNF+4lVJPneVepA9DhfzrVimhi0aN45HnubGXGwNlUt5B06deTXJU1SZwV9UpfJ/1+HzN3T55prd + mlt9iAfuiXyWHX14PPSrakEhs7VPBA4qro81ubdoEG6G34Em4YZSeD2q5lNxTIZexx1rwK8bTZ8piY2q + SsrGfqkckunm4t8Ge0k3x49B1GfcZrIv4ZIVlMMXzQFdSshjKhDy3fA7ccniujBKSbpS74GzBAC7en48 + VzF0s9vCpiuTGbCdoXUcOYJM85xg9TxXbgZ/Z/r+v8z08un9j+v6v+ZRljt9QtdW06GR3huI/t9rtwAH + H3hj168deK88PX8a9KsRcWEsSTKyf2RcfOeA5t5Thvc/nj5q4rxDaw2WuXlvBbyQxLKfLWVSGC9uDXuY + aVpOP9f1sfSYGdpuC9f69VZmSQPWtfS8XWm6jYk8+WLiL/eQ8/8AjpP5Vk9RV/RrlLPVbSdyCm/bIP8A + ZPB/Q11TXunoVVeDtv8A5GYaKt6hatZ6hc2xHMUhX8AaqVSd1cuLTV0JWjpJU34hlCMs8Rj+ZsKCV+U8 + ehxWdU8UrW88M0eA6FXHPcGhq6FJXTRCeDikrQ1vnV55FiaJZm81Qy7eG5yB6VQoTurji7q5PbMoWZGX + JeMgHngjn+ldT4F1XWLLUprXRrWG5nukwEmbCrj+I8jtmuUt3McysMdccjNXtLvbrSNVjuLZhFcxvtVm + GdvY5FZ1Y80WjDEU/aU5Rsn67Euq6FqGmXV2t/EkTwOA67gN2eflHcVlqwUjAzXVePtNvLLX45L6/S+m + uYVk81QB7Y/SuU70Upc8Ex4eftKSk3v2PQb21g1b4dRXlvpwNxb4E1yHBOFJB4znvXJxX6nw1c6aY9zf + aFnVwoyBgg5Pp0rsfBYbVfDOq6XMlzJFGC+YpgiLkdx35FcJbb/MuLdSFEkbBt3ovzf0rlw+kpwfR3OH + B6SqUn9mV16MpmpInCqRt+bOc5/Soz0pVHOMc13M9V6o7vxhPban4X0nUI8i4QCKTqR09Og5Brg69Cs5 + LnUfhbdW6RI0dqxJOVGADnp17155XJg9Iyh2bPOy73Yzpfyya+W4oIBGRkV0/geUDxFDayTTxQXAaORY + PvSDBIX6E4rl60NMuvs+pW05OxY5Eyy8EAfSt60eaDR1YmHPSlHuhuq2osNUvbMx7TFMyrk5IAJ4qlW9 + 4xW0PiW5ksWLW8pEitgjOQM9ffNYAp0nzQTKw8nOlGT6pHY+ENSSDTtV0r+z7m6lvoMKsPzcgHkg+nFc + kQQxGDkHGK6PwPqdzpOvJNDZz3fnRtH5MfBYY6jj2rE1CNotQnR4miZZGBjbqvPQ1nBWqyXexjTXLXnp + vZ7/ACK4GSBnHvXQ6GS4dXuMKh3AE/Ka50HB5ra8Nn/iaRhWUSniPIzzTrq8GXiV+7Z2uiyvfyNbA29r + KziSO4kzgEcYP1q1BBdPqr2C2lvdFH3klup9qybh7z7bPAUV3kwJQBgbvatK4vY4dTtI47GayjIXzVQk + MD3KnvxXizjrofPVIu7ceqJv7YuPCuvy+dYxxiVRlAc596p6n8QNSnm+zWypEjsPl29eelJ4ulglnjjj + urm6IwVkmXBUe/Ark75GjnjYOWkUZ3A1rRoQmk5LU2w2Eo1kpzjd/M7bxVeeJP7JSW+tIobUjBw3NZnh + Oy1PxBG9vFq0trbRdEUmtTWNV1zWfCKsdHxaBAWnd8kgcZFcf4civNQ1JbDT737IZQdzbsDFFODdGWya + +YYel/ss1aMWn62/Mg12zl0rWprYzvIyN/rCeTWW5zLkMWJPJY5rd8WaCdCu4kbUEvXkXLsGyQab4i0O + y0m20uS0uvOa5i3yDIOD6V3UqkeWOt7nqUa0HCGt2+tuxu2H/Ew+G95FPeiNbclljwMnHOK85Jr0DwBc + QLb6lbyWn2iWSM7AI956Vws0Z89kVcMGYbT1FLCrlqVI+d/vMsCuStVh53+82vCOnjVdTe3Fr5+5DgCX + ZtPrms67gmtdSnt5OHjcqRnPf1rf8Di2je5ubyxuJoVXHmwAnyzj2Nc/O0TXs5iLtGXO1n6kZ71pGTda + S6G0JyeJmuiSO6v57uz+GVpE3lLDM5+71PNT6TLrFh8PJpYoLaWykz3+cAnGa5/XJtTj0PTLW7mia1K7 + 4lQ8ge9aM3ijHgiHSBZvGxPEgGAwzXnulJwVkneVzy3Qk6ask+ad2Wvh/eW1tqF5LPdLav5WFVlyDUKT + pL4+spQ9myBuXPyp9frUngzW9H06K8XUGCyuuFGwsD9ao+Ezp114zd9QWA2jbiolGF9sUpwfPUk09hTg + /bVqkk7WsO+IF5bXWvvFHawq64HnQvneK5BrNlhM5SVYs4VivBrW8UQ2f/CT3UWmbVg34Ta3H4VW1W31 + XToYLK8uN0DDzI0V9wrvw6UacYpnp4RKFKEIvddTKKNsLjdt9ccUSSyG3SJm+RSSor0aw8qy+Fk0kiWz + PLuxvHzDJ7V5o/b6VpQq+1ctNnY0w2J9u5q3wuwygUU5QMj9a6TsZ1fiCKSx8JaBa5l8uVHuPncEZJxw + O3H865I9a6vxpbWtk2lW9qXwLJHZWk3YZuePSuUPWsMNrTv3v+ZyYLWlzd23+Ileh2Rez+Fl5Il1C4mf + aUEY3JluRn36156Bk13esJawfDrTh9hMdzLID5+Bhhz3B+nX0rPFauEfNGOYJSdOHeS/DU4Q9aQ0tA68 + nFdZ6KJbcK0qLJgRswDNjO0V1vi2DQ7eziGj6zcXimXDQySEgAL97oPpXPaORJqdlG1mbpFlBMEa/NL7 + e9bfja7sZ72FbTRZNMkTcJY5I9hbpjiuapd1Yo4q13iIRV+va3z6lTRdS0ezsXt9S0l7rzrhD5obGEHU + D3/xqrrMulXXiB30u3NtYcbUkJzwOc9epzW/4Xk1lbrRhFoyX9vAs1xDEoALhjtZmPqCuBmuZup3u7/U + Lx4yrSFmIUZCFm6H26iqh8b/AMyqaXtZNfn59vkUD1NbfhqK7N9Nd2WoWtjcWcLTq07Y346qBzkn0rE6 + Vu6cjp4c1O6k0eO4hJWIXjHBgcnt9f8ACtKm1jav8Fu+n9XNDUrrVb200K3vreObzpHuYkhH7ycM+CCB + wPunFZHie6hvvEN5cW1mbOIvgQFQpTAAIwOnINdBDa3x8W6NbaZtt7m2sY5EN1yqnYXOR6Hd096468nk + ub2e4nIaWWRncgYBJOTWNFLm07fmznwyXMmtNPzfb5EAYqPY81fv5ZvsVhbtcpJCsZkSFP8AlkWPIPuc + A96z+uB+FaeuTRy6qfJkSSKKOOJXToQqAeg9K6Op2PdGXRRRTKLR+TTBwMyy9dpzgD16Ec/pVWpHJAWM + 7toGcE9Ce9R0CQVquVh8OQJtIee4aQkpjKqMDB78luKyxW1rAEUGmWyiRTFZhyJD/E5Lce2CKmW6RnU+ + KKMelXryQKSlX16AVRodjYNHaeB7iV9PKtqN0sKzI5wyLyRgnrx+tdSNNtf7ZgW0uHhNvAFKyqG4wSxz + 04UAfjWBZQRBfC1ikYDBXu5yg83OWyCV9lXpWwkkbQahdW+3IiI2JkpmV8Ac5wdoWvIrNuWnW/8Al+h8 + 9iG+ZtPe/wCL5V+RZ02N5bqw858ktJezEnueFNb6MNoYnO4E1UtBIZbouVBiRLdDsweByOnPJq2FGccc + D9a8TFy5p2Pm8dU56n9ev6iKBI5APHLHPQYrm7qJr6S2jjLRi+uDK0Zxho16YOR2HtW5fM66ZMRhnkIj + TLD+Ljp9DWPPugutRuYVRfssC20Krz87ccZJ5Ge2a3wUftHVl0WryX9f02vuOd8QXgvLiSVFZftEnlKo + GQYkPJH1bnj0NWrl30fQrpyMmGIW6twf9Il+eQ/ULhajjSA68VuQWtrCP5thxlY8kjHX5n/nWf4umMVj + plkx/fOjXlwSxJZ5Dnn3xivagruMD6KCUnCktv6/TT5nJMabSnrSV6B7KCtrw/FGl3LqMwBh0+PzcHo0 + nRB+LY/I1jKOpPbtXRrasNM0zS0YLLfSC4lOc4Xon6bj+NTN6WMa793l7/l1/Ar4kWxMrHzLu/YsT3CZ + /mzfy96uTi2SdLC5lK2WnoWl2LnzZj1HXueM+gNEE6PqdxqCj/RrFA0We5X5Yx+eD+dULq2cR28G7NxN + iVx1JLfdB/DH5ms92ZL3nZ/1/wAMvzNOETWlm2qLPHcC9QxygDDByTiMH6YJx2471mwO8crXm/fKrCOD + aOsnbHsOv1K+tWVtUgItFPmz58iDBwqyEgyP+H3Qfx7VIs8VnFJqMH+rt/8AR7DjBaTHzSc+mc/UqO1A + LS/9f1/w45rZmZdEglUMP32o3B5wRzgnuF/Vj9KzNU1BLp47e3BisbcFYI/5sfc96s3j/wBmaaLAEi6u + AJbtu+Oqp/U+5HpWGSSScU4K+o6MOZ839ev+XkIAQe1OHNIOtSRQyXEqxRIXYnhVHJrVnS3YIY3nkWNF + LMTgADNdD5dr4cK8x3msKQcDDRW59D2c/oPeonuYtHga30+VZLuRP392oI2AjmNfUep/KksNJVrU3l7I + 0Fmchdoy87f3UH9egz+FYSlfV7HJUnzK8tI/mVNl7qt1JMzNNJjfLLIcBR7k8AVq6doZv0dbG3a7KriS + 5kbyreL3ycE/jj6GtKSG006OIaxCGkxuttIgb7ucYMrdcn06/SqV/dX18VtpWVGJxFp1qMKn1A4B/M9c + 4rN1G9I/1/X3GDrSnpT0X4f8H8F5sxr/AE+TT5zG00U6A8SwncjH0B71sw65N5SQDUNQnXbgQWmLdc/h + nP5VC9nGNNWN5Fmv/M2pFGNyxr3y3c+wzSWlrLcXKC6juXgUkMsW2IA49Tx+NEmpLUqbjOPv62/r+thL + lXFsyy6ZFAzciW4kcyfqf6VSibYAFktQR/eh3fzFdFJa6JDlfKgQgfe+3Fz/AOOKRVSzmtonJGovbjP8 + Mj4/LYaiNTTb+vxM4Vvd0T/r5szTcNLbuiS2bPkH5IAjD6HAFWbfxBq1jsSC9uIwOxfen5HIrdkuluIf + Kj1TTbuNvvJcRbGH/Ati1jS6V5d8FeJoix3KLSQOceqjv+dJSjLSSFGpCaaqR/r5pfkN1+9nvFieaz09 + SP8Al4tEA357sB3/AAFI/h0yaUNS0+9iv4VUefGo2ywHvlT1HvUmoQXE7xyLdJdsoC7lURzD/fQ/e+vP + 1qDcPtMe7Om3itkSqCI2P+0vVT78g+lXHRLl/r9S4NqCVN2t/W2/3fcY4Vo9kquVfOUZG5BH06Vqpe2m + qqIdW/dXP/LO+UdT6SDv/vDn1zV9xbX1yFuLKOHUk5eENtivAOpUg/K3Xpwf0rP1XSooII76ylafT5Tt + 3MMPC/dJB2b36HqK05lLfRmvtI1GlLR/11/q5mXunz2M5guI1R8bwwORIvYg9CKpds1s2l5GIP7PvgWs + 3YFZQNzwe6+3qP61U1HTprG78qYqQV3RyD7sidiPrWkZa2ZvCbT5Zb/mUQSORUsUrxSJLCxWVSGBHY1E + aVTtIPerZq0dHFeRxMNUijDWs48m/tgOAxzyB2z1HoQRTJbZrOQ2gdXIX7TZyjncCM7fxHb1HvWfpt6l + lcuJl32067JkH909x7jqPpWikTrHNYGQtcWn+kWUoON6feIH1HzD8azaOWUeV/1/Wn5Edp5bzRrEIx8r + SxBu/wDfi/nj8PWpm3yMjQyDdIfOtWVgSky9QfQsAD9dtVpEDu3k4RZh9qgw33HXO5R6dD+S1bikD+YU + dIUukM8A/wCecydcHsTggf7wofcJb3/r+v8AglK9UbLe/hwouCX+Xjy3B5HXjqCPYirPigC9Sz1yJgWv + FKz7QF2yLweB0B4NReYtzDPbx8pcr9pjXGNkq/eA/DP/AI7U+i41DS7/AEh8lpU+0wYXJEiDkD6rn8hS + envdvyFL3bT/AJfyf+X6HM0UoGW20lbHaKpwc11/g6Q3Ml3pck221vYzHsJ/5aYJQ4yO9cfWjpk5tbqG + e3aT7ShLArj5SOQRWdWPNFowxEOem4o62zaSa1ljkdY5GT50C5Jkh4I9sofxIqxoLzi6bTyViS4he0Km + PJd1JO48cn7vPvUt281prrXY2OLgRakmWB4biQZA46twP7oqtLDPa3DTQu7rbzRzRsjjLKwxkZ6Z2r7+ + tcD1T8zype/Fruvx/qxpabfzBbG2ErusDm3mUR7SB/CT78+1dOONrIuV98A1hzabdQX1/CscIE6Ldj58 + lT7HuSTW2knnIJMj5lGOa8bHJNqSPncys2prr/w49suw4QHHXGeKytTgEt4YTGhF7bvGRsLEyLyp4Hbm + tBYxKg3lyFboDjP+c1S1lY49OjuIzsa3mSTjnA6Edfc1hhpctRHNhHyVkk/L/L8TlNQWGdYbq41C7zdW + hUiGMANInG0juvA5qj47ja6n03VxBOkd3apl5WB3MowcY/rW9fLJZo5Xzmaxv9ygALtjlGfcdu/rWVq1 + ut14JZxbP5mnXhiaYzZG0nONv1I6V79KVpRl/Wv9I+qoTtOE/O3yf9I4UjHFIOtOfJOab3r1D3ehsa+P + PuLS9HH2u1VifVlG1v1WsStu4/f+FLWQld1rcvFjvhhuH6g1iVFP4bdjGh8HL20/r5BRRSVobGrqhjl0 + /TbgFzIYfLcs2c7SQMDHAxisqtqQtL4UUqshSC6KFmbgb1BAA7fcNYtTDaxnS2a8xVJBBBwRVq5AS5OE + KAgNtJJ6jPU81UFWpwoEJVSMxgnJzk+tNlvc6nxG9nfeF9GurOwnSSJPJuZzGQjMBwNx6ng1yHTFd7BH + q2qfC144ltfsFlKzMWYmQ4OcAdBjdXBHrXPhno49mzjwT0lDs31udn8O9Ris9YmiuJ4ooZYT/rmwm4dM + 81z+r7YdfujHNFMvmsQ8PCNn09uazADzyOBSg8jmqjRSqOoupccKo15Vk91Y6y18DzXXhaXXft8IREZx + CASeD0PpXJ9CD69q7rQoZNS8CataxNcvNE3mKiZCADk5PT1rhcZXduHXGKjDznKU1J7MzwlScp1Izd7P + 8DvfA4a+8O65pvlM4MXmZWQrt4P584rgGGDXb/DeRTrc9o0Pmi4typHmbMY69+a5C+iEN7NHkfJIy8HI + 4NTR92vNd7MnD+7iqse9n+BWp6HB7dc80ylHWus9BnW+Nro6muk6gLWWJXtFjLsm1XZeu325rkcZz0H1 + rs9de8uvAOhzzQxCCJ3iSQMSzc9CPw/SuM6GscN8Fuzf5nJgdKXL2bX3M2PDmpSafrljektL9nlULFnJ + IPYVN4qlafxNeztZyWpkk3mGQYIzWXZSm3lSVUG9JFdWJPauh8dX41TxAL0Wk9v5sCFhKuCxAxke1KWl + ZO26FKNsTGVt01c5arNqV+0RjdsHQt6VVFSRYDrnp9K2ktDqkro7SJ3ijEhn8xIxtVGGDg981u6tDBa2 + 2l3tq1w/mRhiZnP7s98e1czDfySWyRb3eIJsLMORmt3VIkk8M6Vc/wBoG5Vcp5ROPLNePUj7yueDVi+e + N+9iLxNeNcRRKs0NyeMumdwPoRS+LdBsdP0HS72xgnTzh+9aRu5Gai14E6VbyQ2c0KYBMrqFDHHr+FWv + EM/2nwJpks1xeSzZUYMZEajBHXuaVK65LdyKN4+y5dFdpmNbeIdcn0Z9Mju4ktI0IKtgEj0rnEKqd6zF + GBxletdV4Ou54bq5gttKgvZXjLZk5wAPrXKXZP2iQNGEIc5QdBz0rtpJKcopWPUoKMak4Ril16akcj/v + ciQv7k11OryaZP4T0uS2tJ1ukykkxX5SfrXOXUcX7p4opI42Xq/8R710sr6jd/DuILbwCxt5+ZN2XJ+n + 406u8H5hiLXpyXfuO+H00i6zJbItzIk0ZykEmwn6n0rl9che21u9hZDEyysNhOSvPTNa/g3zD4nt0iu5 + bZnBUtGOSMdKreNLZbTxNdxrM0wzuLscsSR60oaYlruiKbUcdJd4pnR+CLa9j0G9vLfVGtYuhjFuJFc/ + zFcXI6m6kZgOWO7Fd14U8OSXnh/z4dbktjJGzvFGwwMH0rgXBS5ZM7sMck96mg1KrPUjCSjPEVWnd37W + /wCHLl61uJEFrNJLEFH+t/hPcV02t67pt34Q07T7W3aOaP77FTgnvzXMXxEhiIgWH5einOfetvUZ7+Pw + zY2t3ZxJbk5jlA+ZqdSKbhfuXVinKnfdPv8A1c0PB3npZ3xi0iC9RV3PJIR8ox71neGo9JvddZdamENq + QxUqduD9a3fClzd2fhe/ni02NoVRgJhnc2fWuZ8PPYi+mfUbOW7iMbfLEMlD61ivelUf5HNG8p13tstH + qVG0+G812a0sZ0EHmMI5JWxkduar6pZz6fePbXMokePjKvuFQi4EUzPHGu3J2qw6VEzlyxxyTmu+MZK2 + uh6kIyTWulj0fUjNB8KLVWWMK+3tzgnNeYvndnHFeieI/JTwDpiJNO0hKZR84HFc5rvhu50jSdOvZrmC + RLtNyomcrwDz+dcmCmop36tnm5bUjCL5nrKTsc52p8WCwBGeRTT2q1p0TS3tusSF5DKoVQcbj6V3yeh6 + 8naLZv8Aj/7MviFYrUII4raJfkH+zXKGun8eyzy+LLs3EHkSAIpj3BsfKO4rmD1rPDK1KPoYYJWw8E+y + FUZOK9B8bm6g8K6HaXMEUZUcmNuuFHb8a4CEZkUepruviC0awaTBELtVSInZcbuOnTNZV9a1Nev5HPi1 + zYmivNv8Dg6AOufSlrX16zs7W6tlsbe7hSS3R2W5XB3HqR7V1N2djvckmo9y34Ps9WfXYpdHmtUu4ozI + plcYxjBGD35qfxvJrLaxFFrjW5u0hGDBjG0knnHesvR9Wv8ARbiW4065SCdkMZLAZweuM8CotX1m81y+ + +2X0iyT7FTcFxkAYFYezk63O7W/E5XRm8T7RpWS+f/DGvoc+gJJ/pWp6raMLRhugbH77ccqOvy4x+NYC + YWwmOSGaZRtK84Abv+XFdxYX1wnhyW3jGhL5mn/NI7r5iKu7t1LnPT6VwhTFmsm4EtIRj6AVVN3bKoPm + lJv8/wDgEQGTWus9gvh3yDdXf297kM0GMQbAOpHdqyBXVhryDw34eR9Pt5IJLx5YTGczTkEAqeOOuBVV + HsaV3a3qPlbw3deJdVkvZ7g2CwEWrISCzgAD6DrXHnjtjmuut9YCL4luH0RpfteVVyuRaEluvHB59ulc + iamimr/IjDxaun0st/ITJFJRRWx1BRRS4+XOfbFMAyfU0lLRSAFBJAHUmtfX2Y6xcI5G6JUiOAAPlUDt + x2qppkZuNTtIDtIe4QbWzg5OO1SazKs2s38oxhrmQrjPTcfWofxGT1qL0KIp8UbSSLGvLMQABTBya1vD + 6tLr1giTmJpLmMFl4IGacnZNlVJcsXLsdpOFHiieO4t5safp6wBFIV0OwAHIx3b8aspbw/ZcbZds97Gi + SCXadqDGCD06dT0qKKWG41fxDPI4mjluVhEiSlXXDE5zjGMJ3qwlyi2ekiQuTI807Bw2N27gjPBNePNu + 6+X5XPnKjei8l+V/zNuwRWshMVIM0ruSWyScnB/KrfG/knpUVsFSzt1CjiIZB+gqb5QeoPevBrO82z5e + tLmqSfmyjfNunsIvMRBvaUl03/cU9vxFYccsqw2W7bunuJLxg6heEBxz/wDWrR1WVVmnZTho7RlGEzyz + Yxmsq8n+zresrIDa6eIV2gKQzH8Oea9XCR9xf1/W6PbwMP3cV/X9aoytJuRNbrbSODJqN4qSfuwFEQIL + MGPfOPyrB8UXp1HxPey7wyiQohJyNq8D+Vdro7rbXNuZlbZpmlyXGM/xvz29QRXmUrb2ZieS2a9agk5t + /wBf1Y9/CJTrSklsvz/4CRHRS0ldp6ZZsbVry8trVfvTSKg/E4rfuJ0fWNUvIyDHaxGOH6cRrj8OaqeG + Bt1OW8OCtjbSTDd6gYX9SKYiH+xkUEbru6wSfRR/i/6VjLWRy1Hedvl9+/4I0bWzRrLTLBiV+2ym5uCB + nEKZA/k5/Kq8c6ajrV5qlyzxxRhpIto+6ekY/Mj8BU93eRfatTmjRnRIls4HVsBQMAn8QD+dZkw8qySG + OQO08mCFPULwv8zUxTepEIt3b6/rq/wsvkXYkcWweIEz3J+x2gz1/wCejfjux/wI+lSIIZNQeQANp2kR + cf3ZHB/9mfn6fSkWUwG6uAcJp0AtoMDjzWyCR+O9vwFV9Q/0DQbKw4Etwftc30PCD8sn/gVPdhq3bv8A + 1+X4syLmd7meSWU7pJGLsfUmoutJSjkgcfjWy0OxKyshcEZBHPpW0iHR7WJo2xqVwmdynBhjIxj6kH8B + 9ah0a3jkmmv7r5rezXzGz/y0foq/ievsDUtjaXGu6wsTyqJJ3LzSt0RerMfYDms5PvsjCpJNu+y3J9I0 + uH7LLqeogjT4Tt2jgzydkX+p7CrEWqzG5SaMA6iOLdQP3dog9M8Z+vTr1rUN1bzzR3a2+7TrL/R9KtCP + 9fLxl2H1wx+oFZE8CXFxcFZgyx/NeXOf9Y5P3V/HIHrgnpWF+Z6nLzc7bmv67f5/cTWoeTz2gnAI5uNQ + kBJHsvcE+3J9qkWMfZDsY2djIPvkbp7r8PT9Pcmp40MqRKYI8hS8FqxwkS/89JT3/Hr9MAtW5WMs8Esk + kznabplzJKfSMfwr79fp0qGzNtvb+v6/4buWIY3sYlCvBo8Tcbj+9un+vTb/AOO/jVCSO3km8yOGe6Kn + mS4k2qT6HH/xVOjtyXPVmLdAeAT2LdWPsBV+OzLybZAnmDgBl3sPYLzj8TWblyvf+vzM21B3b1/r5/iV + Vk3KSq20WD0jhU/+PPzU/nuI/wDj8uFH+zLGo/LNaEdjN5YV3dfTzJFi/TnFTNbSMmDNGf8At8P+GKxl + VRzSxEbmIT5i5eQyE9N8ccg/MHNRTwguJIfLiYcny8sg9yp5H1rba0lZCB8zDoRcI5H4EZ/Wq1xDIjgs + p80cgsmx/wBeD/WnGquhUK66EVwz3zDz4o7p8fLEzfvMescnU/Q1WlKy27KhfUbVAcxSjE8A45B/D3Hs + KlliTaTJ94kEpjCk9j/sN79DUMw8yeOWSaWKdW+W6UYcH0cdSR69x61pCRrD+v6/y/EyZYRb2qsrm6sW + OFbGGib+h9uh/Wr1jqUi+ZK6LOWTbcxEnF3EO/s69c9e/Y5stHKLl3jjjS9ZCZLcDMV4ndlHTPsPw54r + Mlha1jj1LT2b7Nv5HUwSeh/Lg9x9DXQmpLU6lJTVn/X9f1qR6vpq2TxSWsnnWF189vKfTup9GHQin6dK + mo2o0S6dV+Ym0lf/AJZuf4Seyt+h59a1LU2skP2SZkTTNSP7sk8WlyOPwB/kfaucurWWzuZbecbJ4X2s + O9UnfR7mkHzrklutn/X3P/glKaCSCaSOVCjxnDKeoNR10eqgavpceqqM3MREV6AOv918+/Q+4965xhg4 + 7itoS5kdNKfOtd1uGfatyC5lm0uK8WQG602QAZPLRE8fUA8f8CrDrT0W6hg1CJJlCwzKYJ2zn5W4J/Dr + +FEtgqr3b9jQnVYlmFvjEDLe2uf+ebYyPwO38jVQ2ltFcz+buKJsuI0DDDRnBI+uCPyNXYGeyMa3JKmx + neznGf8Alk+f67/zFUA8lpeQPLID9nka2kUnnYSc59jlvyqf6/r+upjG+qX9f1+ptMsMcM01vE0XlFb6 + 3t2/hwdsqflg/QVnSuui65HPbKSIJVdMnG+NvmGcex/WnO99qNtBIijesvkbseq7CCfQhR+dGqafPFb2 + LzABwrW7t1BKnKnPupGPpWcezM4JJ8snvp/X9dSl4lsVsNcuI49hhciWJk6FGGRj86x66LWCbvQNHvmc + M8Ye1cZyRsOVz+DD8q56tqbvHU6cO26aT3Wn3BTozhx1xntTaB1qzZnfwsp8N6RqTuGFvcy2MiPgAI4z + +WC1VyEAMP2tS4SSGVWJP3WDryBznkDPpT9BeO68F6/ZPGDLCYrqMgE8g4P6VNZ3ULX/AJjsVDL54Ji5 + dwoJPrzkj0Oa86Wja7f8P+p40tHJdm/8/wBTQmnSWXSZ42ES3Fs1vIFJJXb2P1OPX6Vu6M6Ppka/vMRZ + T5xg8VzlveyXHhe0ZJgH0+9DLGcbiOckDqR+NdBo7p5t3DEzsiPneQQGz9enavLxcP3fo/6/M8TMIfuW + uz/X/Jo0FGGb72OwqG7iE+nXMWzIaJhkkY3Yqz0bBwfpzSKdknzM2c8DHGPrXlwbTTPDhJqXMchdK9zB + Nt8lPtOmrM7BixLRnp7Hio1tJrvTNXhliuJHuLOK8jCTBsYHLHHX6YzViSZ47XThuEohmubdo2BPB/4D + 71F4cuVN3bRQG1WW4spreQFSGXGSCdvUkY5r6FP3Lr+v6sfWJtU210/T/gI82dGU4ZSCOoI6Uwip7nd5 + r7pN5PU88/nUB6V662Po4vQ19PDzaDq0Ii3KgjmL5HyYbHT33Vi1t6DGs/8AaMEkrorWUjBU/iK4YA+3 + FYh61MPiaMqek5L+tgpKWkrQ2NizjSTw/qeUTfGYZFYucgZIIA79ax619HZBbanDskd5bNsbUBC4YNk+ + g46+9ZFRHdmdP4pL+tgq08itBAAuGUENgdeev+fSqtXXUnS4HyuBI6jnnoO3pVMt7o6vw/bWl34N1Nbn + X3stjMyWnmhVkO3PK98nj8K4o9aM8UVEKfK277mVOlySlK+7ClpKtxade3FpLdw20r28OPMlUZVfqatt + Lc1cktzt/AtxbppGqWtxrgto5ItxiAxtyCCee/QcVwD4y2DkZ4Nd18NH/wCJxcwxWENw8kBOZGA24+oP + WuN1JHTUrpJECOJmBQdFOelctLStNeh5+GXLi6q72fQ6DwA80fi21EEMUryKy4lbC4wSTWV4iha38Q6h + FMqiRblsrH93r0FTeFHt08TWDXQ/ciUbuT746e9O8XxxReJ9QSIKE83KhSSPfrTWmI+X6lpWxr84/qYH + egcGjvRXUdx1khspPh6P3lwbyK9+7ubYAR6dBXKHt612dg08nw21eGOFWhiuo3dzJyueOn5Vxh6Vz0N5 + LzOTCb1F/ef6MdGefcdM11fi/V21waRKLOaN0tRFvcYEhHUr7VyiFQGBXJI4IbGK7PxRcNceDvDjSRwh + 0jZVZJdzbeBgjt0oq2VSDt3/ACFiLKtTdurX4HFU5Tg5zTeBxmlFbnYdJZEmCKV4tnzEeYpPzD0IrbsZ + ll0SSOS0k2LKD9rU8KPTFc3bzXMNpGRIXifHynpn/IroU1++vtAOlmEeUrAmSJMEDtuxXm14Pp3PIxFO + T2799jW1sacPCSG1vZXkBGEdiR+XQU2e4E3w0WP+ylPlnablnHB3dR39q0bu0uI/h+yGKKRVXLOD8wGa + hsJNTk+GsiQWEDW4V/37y5O3PJA9a4qcvd9JHkwl7ne0+rOV8JfbZNeS30+++xtIh3SMMjAHvWHqUXla + ndRNMJ2WRgZf75z1q/pDWkmqWovZGjtidrupII/KqGpiBNQnWyDG2DEJu6kV6kFao/T+tT36atXfmu36 + mxr80V1oGjlLuCR0Uq0UaYZfrTLKxtZvCd7PPqUqSwuDHbb/AJT74qtf6jaS+HLGyitUjuYmJkkVOW+p + pNJvraDStQtrkzF5VHlpGBgn1JqeVqFl3/UhwkqVo3VpfqVdGe0XWrU3xItt3zkZzj8KveNTpp1jOkri + HYMgqRz+PWs3TJWh1W1lSNZCsoIRuh5re+IMt5c6jbzXVkLVTFiPBHzD6CnLTERfl3/Qc7/XIPyfX9DW + 0ex0BvC/mSXixXJt3Mq+Zg7s/KMZriLOwmv5ZFgK/ICxLNjiujsD4WOgN9piuDfeT83BI8zJweK5MSSR + uSjMp9uKWHi7z336kYSMlKpq9+q/IneLbMqszDs3eur8T6ZbaZpWmNb6jLdK6Z8t24X6CuSV2Yxhydo6 + 113imx0S0sdMfSpRJK8f7xRLvx07dqdV2qQRVZtVqau+vTT/AIA7TF1+LwZeXVrcxDTixWSNsbgO+Kp+ + EbrUrYai2mW6zK0BEpc/dHqKtad4fmu/Cd5frqpiSPJa23cHHrVHwzc6kLfUbfTpIo0kgJl8wj7o9Pes + dHGdrbmC5ZQqqNm766W+/ucy+S5J6kmgE9hk+lTQWtzdbjBDJKF5YopOKY0MkMgDqyN/tDFd/Mtj1OaP + w31PQfF8it4N0qIRFH+XIERQH5fesbxbdwzaDoMMd69w0cB3o6Y2HjjOPw/Ctzxq10fCWkiaFY1AXDbt + 2flrG8aXclxo/h9Hs5YBHa4DvjDjjkf5715mE15fVng5erqn/ikcY3pWjobQrrFiZbiS3UTqXlQYKDPU + Gs01paASuuWLLGkridNqORhjnoc16lT4Ge9W/hy9C540mjm8U3zxXJuULjEpYHd8o7iufPWui8bs7eLb + 8ywLbvvGY0IIHyj0/P8AGudNKj/Dj6EYX+DD0RNajNxCF++XGMniuz+Ik2oyT6auoRW8bLCdvkvuB6fl + XH2OPtkBJwPNXLYzjmuz+JdwtxqNiVuxcYgPIi2Y59Kwq/7xD5nLX/3ylp/N+Rw2fr1rZ8SbBqMCR6lN + fxrbR7ZJmyY8jJT8CTWL1Na/iNSt/BiwFiGtoiIgQc8fe/Guh/Ejtl/Ej8zIIP3vekB2nIrRg1SKHQ7n + TmsIJJZpA63Lffjxjgf571m5qzVG5oD2EcOpG+0ua+drZhCUzthb++celbvhDQdF1PT5pdTtr6WVZAqt + bjIAxXM6bqt1ptreR274S7jMLjd2PXjPp613/wAPXvU0SYWmp2Vui3DEw3Ayfuj5s56f4Vw4yUoU3JO2 + qPKzGU6dGUou2q6v+keeanHbRalcraK/2ZZCIxJ97bnvWl4aujJ4g0WN7h4I4Jw3mSyAxr827gHgdOay + 9Qdpb25lkZWdpWLFehOe1SXAl/siwLKPJLyiM9yeN3f3HaulK8EmdvLzUlF9V+hqRXWtr4f1me2kQaXc + XAS6zsyzk5GO/wCVcya6mLzE+G1xgKI31RQxIOciM4FctRS+16hQ3lp1/wAhKK0NQ0uewgs5ZUVUuYvM + Qhskj3Has+tE01dG8ZKSugrQdR/YUDbJP9ewLbAF6DgHufas+rz4Oiw4jfidg7noTgYAoYpdClR3oopl + F3S7s6bqVremLzBDIJAhJAbB9aryv5js56sxY1a0rTZtY1GCwt3QTS5C+Y21RwTjNVpAY2dDjIbB71On + N5macee3X9CNTg10vgWF5fFunbR9xmflN4AAJ6VzVdT4GEY8Rxu6xYSB2y7kAHHXr156VFd2py9DLGO1 + CfozT068VLC7uDFbyPJeSsyOnykbCBt7nl+nTpXSxrFJcaeIkCtDbbSAcEgoxwR1645965C358LKCw+a + 4fvgg/Ken/Aa6TTUjlup2ZdpWJlGGPUIByB7sa8vEqyb9TxMZFJOS6X/AMjoiNoiVVOFUZz6cVKcZ/hH + 400ja/TI20xgxkAB2DHzH/P4V869WfJ/EzPnhS41CdJEkKDyVba+35Rk5598VhazIDp+oujSstxfrBli + SMIOMnvXUQwu+puQxdt4KjIyPlwc+n0964ycTS2+moCjNJeyydQTkHvn/Gvawmtl6f1+B9Bl7u0u1vyv + +hYkurZ9F8R39rEVikEdskocqMdMFfpXnTqVYg5/GuxV5R4LMQbIuNQAI2d8f3qo+PX3eM9SGxVEcvlg + KMD5QB/SvVw+kmv60se7hPcqOHe/4WRzNA60UV2HpG9pgaDwzq8+0AytFbg7emTuPP8AwGrmj28VzrGk + 2VyjSQRwNJIij13N/wDE1TIEXgyDg5nvmb2wqAf+zVp6XKi6vqVwUAFrYFQOeqoF7e9c027Sf9djz6zf + JNrfX9EZNxaEWKzxsfKnuXSOP2XGCfzq6I7pbvzBbxFdIhxMykYLDO0n15IHFTrFEZvDVkGDgR+dIAe7 + OSc/gBUTXD/8Izqt2Vwb68WPJx0GWIH6UKTf9eY/aSdl/Wrt+SZVtrdrq30vTwfnvJ2mkPtnaPywx/Gq + Os3n23VrmdfuF9sY9EHCj8gK3Ld1i1S5mX7mn6dtXjo+wKf/AB5ia5QnNXHWRrS1m3/Wuv8AkGeDn0oA + 4JI4HWhfvDnvV7SbF7/Ura3WN5FkkG5U67Ryf0rRuyudEpKKbZfv1Flpdjpo4kcfargf7TfcH4Lz/wAC + NX9Mge20I+ScXmrSG3RjxshXBds56E4H0DViandC+1O6ugu1ZJCVH91c8D8sVuXkhtYZApI8qFbGHPVc + jdM35sR/wKsJXskcc01FR6vV/wBev4IrXN8jTGO0Hyhfs9oDxsT+J/Ytz+Z9BU1hbmR0jhRXXkQIcAO4 + +9I/sB/T0NZ1sEldiTtVVyWHVUHH5nP61uSKYLGG3SRUub2MNKyjiG3HOB9eT78etRPRWRFT3fdX9f1/ + W425KsPKgZpYNwDtk7ryTuf9wf55PD7e3adiVIIIxJL90EDqqn+FB3Pfp9WxQs0oREJDKEVF6qvZB/tH + OSff3NbEcKhQibSoO0YHDsP/AGRew7nk1zzqcqOWpV5ENihQR7VBAC/w/ISPr/Avt1NW4onACD5Fxwke + UH44+Y/jipra0JO45POd3Uk9z9ff8q0orZVGAAB1/wA/4mvOqV+x5VbEq+hnx2CL/wAs4x9R/n+tWVtk + PVIyPYMP5CtGOBnPyp+P/wBc1P8AZJCOR+grmdRs4ZVpMx2tkxnYefbcPyNQtb7F4IK+xOPqRzj6itt7 + Z15KjPY7f8Kgki5JHDfoaFUYRrM5u4ssNuQ7H6cgYOe3pz/3yfY1mXEO1S2GH8LKeqY7c+nY/ga6uaEK + vIAB45GQPbHp7fiKybqAxyKQG3YK4xk4HVfcjqPUcV20a1z1MNiG9GYaypsW0u5NsZctHLzm3k7MuOgP + GR+NRyiWE3NxgLLzDfW44Dj+8Pr1z2I96nuYFXd/F8vJHPyHoR7jPX0IptrKrtE8hUmL/Rpz/fibo3vt + OMf8B9K74y6npRatdf1/X+RhBlt5ZbQyBredRh8cA9VPtgnB/EVoasH1PR4NVPN3bn7Ndg9TgfIx+o4+ + oqtqVj9nklhI5j/eKPRScMPwb+taOgt9pvGs5WXy9SjNu+f4ZV5RvrnH5muhvTmR0za5VUXT+n+H4oz/ + AA/dRW+oCG4Yi0vVNvP7A9G/A4P4VkX1pJY30trKuHico34VKUMRmifIZGxj3Fa/iXFzFp+rbQ32y32u + SP8Alonyk/yNUnafqaX5aqa2l+a/4BzR60Dg0ppO9bHSdHOftc3mbgft9jvYn/npH1/EmM/99U3ykv55 + PNXyxcWJmTOeXjByePUo3502xnEemWU7dbPUMN/uuAcf+ON+dBZbE2/m/OLS6lhdTz8nHH/odY+S/r+t + Dk12X9f1oPm1CWGxmtbY5LTRXYdcYBZQSPwYiqckks8F1E0zyhdso/Dj+TfpTra4MERg2u7PbPCwGByG + Lg/oKstZS6fFA8cm5b6ydyVPQAElTx6qKNEP3YO3V/1+hRZ5m0O5t8KYkuEl56jIYcfp+lZJ61vaHBHc + 3MqTrvD2kuwZ/jVcj+VYR44rSL1aNqbXNKK9RKKkkChIiowSvNMqzbc63wbGst7qFq0rBJtPlHUgMcZ5 + p1hbm5Gnu0TtG2FLSEEPg4IUemMCn+DJAPFenjEa+ZbOhJXcPuMORTI43EVgVijYJOVYlsCT5uhAwQPc + HvXBU+N/L9Tyqj/eyXdL9V+h0sLIvh/XreO1QRIySEAjMQJB468+3armlCdr+KSYAC5tFdNpyABwB9fW + sGCG0WTUElVYybQugRjsLZ4HPUcfrW1ok8csej7C5k8mSN2KYCgHIArzsQv3cv66f8A8jGQ/dy8/8v8A + gG8VBPII5pcKGyM4JzkmgAbSOT24oGB1JBPSvDR8wctf/I8uzynkj1IMI3i3ZDL9eR7frVfR7iKHXdLY + 3CqVvJU4yuAwA6ngD/GtK7SF7m8EpZYhdwM7xEqwGCDjpz6UvkWtnbaZcNFfFF1NXTcm7cMcY7ljjp3r + 6ClJOml/Wx9VRqJ0lF9V+aPLdTTy9Suk4+WZlyDkdfWqhrW8R/N4h1IgMAbl2w42sAScZB6H2rJ7Gvap + u8UfS0XeCZo6GA+oiM7/AJ4ZRhDgn5G/Sso1p6LcLZ6tbTyErGNwJwehBFZh60L4mEU/aP0X6iUUUVZo + bOgSIlxdrMissllKuX3cfKSCMe4HXisatbQ5Eg1ZJJU8xfJf5GQv1QgccVknrUr4mRH438g71MAhhZiT + uBAHIA/xqGryB/7JlPlRFDKv7wld4ODwB1x+nFUy27FOikrW1RdLis7GKwuftEoQvM/k7ME4O3PfHPNI + TdnYy67HSk8Rf8IZfpaXtnHpeCZoiyb29e2f1rju/Ndhoel3dz4R1S6h137JaICXswf9Zj1Ge9Y13aK9 + TlxjSgm7brdXIPBhhTWW3avLpamFt06kDPt/n0rE1NUj1W5WO4NzGJW2zk5MnP3vxrY8IXGnW2uo+o2f + 2yAxsBGkZkO7HHFZesvBLrN3JbQtDA0zFImXaVXPAx2pR/jP0CF/rMvRdrf5k3htmHiPT/Ldlk89QrIu + 4g+oHerfjiLy/F98GleRi4LM64OcDqKztEAOuWQMRlUzrmNTgtz0HvWr48VV8V3IW1e2XC/u3xn7o54J + 61L/AN4Xp+pEv98X+F/mcv3pKKWuo7jrdKbT/wDhDdejd2WcmFoslhuwT6cfnXJHpXbeHpYU8HeJIjcS + KZIYukRIJBPBPb05rij0rno/FP1/RHJhv4lRef6IWPbuG7OMHpXU6leaVN4K0uC2txHfJK3nOI8Z69W7 + 9q5VcZB9K7G7vLh/hzYWzabKkC3JIuuit97ge/X8qdbePqGKXvU3597dH9/occR04oHWl52g845oAznk + VudZft4lKRsrku2cj0rqdDbUJ9N1C2spbeCARh5jKcFsdga52SCaKzspXsRFG4OJgxPm/wCFTJcRonlK + vyuOSOufSuOrHnWhw1oe0jp/md5pluJ/B1/5V829QWlTOV+nWm6FZWNz4FnlvdSuEUF9sHnbFUjoMd81 + B4bsreTw1qEzQTrII2/ePny+lM8OHQjoF1/aOnyXN2rNlo42YYxx3ry2rc1u6PCmre0Sb0ktkjmNAuLe + z1qyuLyPdapL84Izx9KTxPdWN1r93Lp4xbs2VIFO01YlnjkMRlXzDtgwSSe3FO1uQz6hMDpq2bnGI9pB + 6elekv4l/I9pWddS127mLJPi2EGEZd27d3poaZlKozDd94DvWxdRww6WiHRJoZW/5eXY4/AYrX8HabqR + gn1Cz0+1vLdAVYTvjnHarlVUYcxc8RGFNzt97RyenGVdQt2iZVlWVSpboDnvXTfEIak11ZtqDQudhCvD + GVBP1xzXPwEy6vEYY0SdrgbFzlQc/wCNdF8QLLXbaW3k1i8hnR8+UsYxs4GeKib/AH8NuvqZ1Wniqbdt + n6/In0fUdQj8MMkOiwzwiFo/tBHJBPXPtXDMDu5OTXdaKPFTeGI209Im0/ZIilsfdOd2c/SuY0JUOv2a + zQfaEMwDRZxupUGoub0+ROGahKrJW0fR+u/YjSSNYYV8hWZXyxJPI9K6PxPLob2unvpNm8Ezp+8O1lBH + 4+9M8e2P2DxIfLtBaRsilEDZyPWrnifU7678MaUl1pP2ePb8lxuzuA/lUc3O4TXXzI5/aSpVY9b9f06k + 2hXGiDwbqMd3H/pmDkspOT256Vg+GY7N57s3lhLdgQsUEf8ACfU11fhCcN4I1K3NjLKuDl1xj9fSuW8N + a3c6FPfeVEkizRFTvYDaPas4cz9oo737mNLmbrxje9+5L4b8Ux+HoLuJrUymXGzkfL9fWqvinxBD4hur + WaG2MBjj2uMjk+orCkkDlmx1YmmoSDwMmuyOHgp+1tqehHB0lV9vb3j0TxbBOvg/TZDf+fGdvyZBI4rH + 8ZSX0mi+H/tMcaRfZsRlWyWHHX8MVs+JZrKfwPp7KoSdQmQqY7etZHitLk+E/Dk8mzyPKZUIJLZz3zxX + Dhfs37v8jysC/wCHf+aX5HGEgjknParelvGmo2zSsyRCZCzr95Rnt71Sxn1q1YyNb3cUgTcySKQuccg1 + 6s/hZ79RXg0a3jU2r+J7t7OWWWFipDSkls7Rnk81zprp/Hn2l/FM01zbPbvKiOI3OSBtFcxU0P4cfQyw + n8CHoia3kMTxygLmNw3J61t+J/FE/ie4t5Z7aKEwoUHlk88+9c9TgCTgDJ9BVOnFyUnujSVGEpqo1qtg + zjP9K0tYDRzWbMqnNsjZaNlZs5PzE/eP+0OCMVlitfW4YYxphhieNXskdtzMdzZOSM9s9hxVPdFS+JGP + 3pamFrO1mbxYiYA4jLjoGIyB+QqGmUmOQkHG7APXmvUvh7Oh0e4jlmslVJztjmhLdVxknPT2rywdRXpn + w3uYYre+VnnKBwfKFq0wPXByOAfwrhzBXoux5mbxbwzt5Hn16QLidRtx5rY2fd69vap5bcLoNncCHBNx + KjS7wd2AhAx2xk/nTNUx9vu+CP3zdV29z27fSq6+cbcZ3/Zw/YfLux/PFdUfhR3Q1jFmuPsR8Dvni9W/ + 4/edUKf3fqOvvWB9a6K2lsT4Hv7eVoBeLeRyRA/fKkENj26Vz3ein19RUdHL1JbmBoDDucMJIxIMds9q + r1oakCYdOcqAGtRjB64Zhn9Kz6tbGsXdBWgADoLHam4XI+bb83K+uenHTFZ9aEXzaDcruPyXEbAbjjkN + 26enNDFPoUKSiimWdH4KBPjDT1Aw244IXdj5TzisOb/WPyT8x5PetfwfIkXi3Tndgqebgk9MYrKuwBcz + BSNokOMfWsV/Ffov1OWP+8y9F+bIK6jwO8i61IsZcPJbPGu1gGy2ACMj3rmAa6jwUgufEaW0YkPnxSRD + awVlyD8wPt1/CnX/AIbHi/4MvQu6dIw0a3jJSRBdElMFT09e+a6XTTI2oX0zZEbTlMbc5LEZ647AflWD + p0Yi0UuXZlj1NVIVsqBjjH5GutuJBFdXZGMNfJnK5znHevKxb0a/roeDj5bxS3v+aNB2IViuST0pckON + wI44pxzjC/rS9+mD7V88fKXKNpN/xMb6ONWLoQX+TOcrxzjiuOuZ5LfTtDZ422YuCASDkknp6V01n5Uf + ia/aU5zsAwcYyh965ycxPbaO0e0MI7kEOcjqfU17eFST+78mfS4GKjL5L/0llGxhhl0zTGXPmvqSRspP + GKzvGbhvFuskgE/bJAD/AMCP+Fdd5cUXhvQG2wKy6pHueMDpz1NcP4lIk8R6pIHDA3cpBHf5jzXpYeXN + Nv1/M9jCT9pVb9fzMjtSCloruPUOhuYydC8Pw8YdpXxxnl8f0pY3xaeIJCvLFUB9MyZ/kDTrkYh8NgA/ + 6nPp/wAtWqokJk0/VJyoIjlXJ34xknt3rBar+u5xRV469/8A24tacWi1QOSMwWLOPb90f8aj+yu+jaVE + WGy5unIX/vlcmrEiRx6pqKxoERbH5QDn+Bf8acVWOw8MtuP3pWPHHEn/ANak3qn/AFsxOXvJry/Jsgib + Oh67c5wZZo4wfXLFj/IVz2ea3AceDJOclr9R+SH/ABrDrSG7N6K1k/P9EKv3hnpXQeGB5MmqXrR7ha2E + pB5BVn+QHP8AwKueHWuj0xhF4W151eYmQ28RGMLgsW5P/AKVX4bBiPgt3svxMi1UvOiAclgAB6niug8U + PGmsT2sZGLVfJ/3nzl2/E5ql4YgFx4k0yIjIe7jyPYHmoNQmM+oXczYzJOzZ/EmpesyJ61l5IuaXbLcS + RQMSqTy5lI7RoNzf59qvCd727ub2RR5krfu1x0AI2p9NxX8FNR2KiGOd8AtHZKARj+NlJ/RiKks1ImjD + AEKodvQ8k/yYn8Kxm92c9R3bf9f1sa2nQgGRkbDM/kxsc/e/jfP0H/j3tWlaokxyi7UxgeyDp+J6n8ap + W64soxuG7yef9+U8/wDjorYs4wMAYwDj8uK8vESPExlSyZdhjCr07cewrRtrXecsPoKghXc6j8a3bGDO + D1rz1qzx03J2CGyJA+UVb+wnHT9K04YEjUEjJqb8BXVDDcyuz06WX8yu2c/JaFeorOubTuBg11ssKygg + DBrHuodpIPasatJwZy4jDOi7nKzR4JyORwfpWVdQ5VhxkEDPuPu/4fjXRXceGOAP/rVk3MfUdDjA+o5F + KnKzJpTszmLpBgE8LkhjjoCcEfkQfzrLUPDM0IJDSBkYe4+YD88fnW7dxbnlTOMkEf8AAlJ/morFkiP2 + qN92G81DnHA3Dr+letRldH0GHldCaw2+4W5bkkh2x3SRfm/AHI/GsqIS2s06oSJYtk6Ef3lI/pmtaaLf + Ywqx+9BNH/3wS4/nVFV36hasDxMpQ/juU/zrri9LHZTaUbf1p/TGeJoFj1+6kjGI59s649HAb+tSf8fX + gWVerWV6GB9Fdf8AFaf4gXzLTSp+MvpqAn1KuV/kBTNI/eeGvEEWOkcMv5Pj/wBmqvsJ9rDv+5i+zX52 + OaNJTjTa6TvNazO7R9UjJ6CKYD3Dbf8A2erlxZC81S6WWR40d4JGwM/fwCf/AB+s/Tdpi1BC2A1pn6kO + p/pWrcsJGmOFX/iXQscDqQyc1k9H/Xkcsm4y0/rYlsflvtKkbYFM8ibgMEkkKSe54x2omkSbStBJfJHn + xN8p+UZ45/GquUEGnFXy0d/ICo64JQ/0NXXWP+x9OjIIaPUZEIKYGDjv/Ss2tV/XcymtU/N/+3f5kPh5 + 8XGk7WPM00ZH+8oH9a5aUYkIx3rqPD67brRTzk6ljHt8lc1dDbdSj0c/zrSHxv8Arub0v4svT9WRU5V3 + BjkcDPJ600dKUetbHSdV4QcR+JdId2KrtYZ6cfMK149PvbfS4r1IpGt1vDiQTfcO4cbOmfesfwiFHiXR + SWf7zHIHI5PSuyieMfD+fH3TqeBn/eFeZiJWqaeX5s8TGVHCqrdbL8ZFS2mktpdWjvIX+0/ZGRi6hnHz + AjpwOCOataDK89jo4aRtqSSgDYFCjb2PekupRN4j8RPt4W3K5dgOy+oP5CnaLGVs9N3SKzLLIQUOR9w+ + 1cVZ3pt/1szz8Q06DbW6X/pLOhCoMkg9O1RgLnPJHPfpTxhTgnPFNBUn5WH414Z8wrnO6oqwNqMiGUMH + tzuYkDOTznP9KydPne4vYJJ2hZv7RUcz+W2D9Ogz/EK2tTHmS6iN+0hrcB4/vId1Ztmsq3EKrqAWQ6sp + WWR8gMM5ZkPHpzmvoMP/AA9f60R9VhGvY676fkjiNfVxrt+HOW89snfv7+vf61mdjWlrzO2u37PMkzG4 + fMkYAVjnqAO1ZuDgmvZp/Aj6Sj/Dj6ItabE9zf28CT+SzNgOei1T6Fx8v4/0rX8NAf29as3l4QO5EgyC + ApPT8Kx2OTn3ql8Q0/3jXkv1G0UUdxVGhteF9o12ElzGBFKS3HaNvWsU9a1dCLx3c7qhYraTnGRwDGRn + n61lHrUr4mZpfvG/T9Qq6oLaXKY4QVWRN8mwDacNxk88+3pVKrfnxjTDbrGm8yK7SZO7oeMZx37CqZci + rV6+uo5xEEhtFwnPkRlSD7+p4/WqOM9+pq7qmnS6ZeC3ljZCY1cAsG4Iz1FA7q9ip0NdXpFlok/hbVrm + 6W5e9iAMRB2gc8cd+a5QckCultjoI8JXXmRzjVsrsds7D83OPw9axrXsrX36HNik3FJN7rb1/In8DahJ + p3iQTwh2PksMJD5hHHpkVj65dfbtevbvaw82dnw67W5PcZOK6D4eLrP9tTSaHHDJMsWJPPb5duRXNaw9 + zJrN5Jd7ftLXDmQJyu7Jzj2zUxS9s35EU0vrUn5Lr+hLoCyN4gsFicpIbhNrAZwc+lanjxkHi+5KecGB + Xf5pyc4HT2qh4YSGbxPp63GfKMy78Zzj8Kn8YSRTeKb4wu0kYkwCxJJwMd6mX+8L0/UmWuNX+F/mc8Tk + mikpR1rqO463QwyeEdfe2vVi+SNZoZVB81SSBt7gj+tcma67S9i+AdbeSCKRzPEqS4XKc8+9ciawo/FL + 1/RHJhtalT1/RAveusubyxfwBZ2UKXhuhcl5C+fL6HOO3TH61ysY4Y4BwOpPSun1PX3uvB+maV9ikhWB + y3nD7snXkfnRWTco2XUeJi5ShZX17+X4nL4XGSSD7ClRN2QCB7k03sKVRW51dDo7/VFvdF0yxTTlge2U + hpl/5a579Kg06wa9vobRNyySk4JHatLxHNO1hoNvNamHy7JSrk58wE9av+Bpbk+LLDdHJII1bap6gY7V + wzlyUnKPmeZOp7PDSnFW3e9zY0LR7rTrDWY55RlYSdrbsEEHn9KXwnrt5p3hqeCDSJ7tA7EzRn5eR/Su + g1K6El3rZaBkK2oUEr7Hk1z/AIZ1trDwncW6abeXLNI+ZIkOwZHrXkqTnGTavdr8jwYzlWpznKN23Hy6 + HJaOgutdgLXhsSZc+b021LrSmPWZ/wDicNdDeP8ASGJJ/wAim+HBAdehN5aPdRFyTCoJP5UmuNZv4hma + C2ayt1kA8to+VHc4Nep/y8t5HvJ/v7f3fL/hzW1QwXGgM8vilrtof9XbshG4+lU/DkdnJpN81xrU9gVU + lYEbaHre1jxD4Yl8NzWUDG4ujGFRzapH82evHSsTQ9SsLPwtfpcW0dxO528wkkZHB3dKy972bVnv5f5H + JF1PYNOLXvLov8jm9OjSbVbWJ5jCjSgebnleeua3fHlvDbXUKxaw+osQd26QPs/EVhaWkUur2y3ELTxF + /miQnLD2xWh4xj0uC9SPTdPuLM4O8zZ+f0xmumS/fx9PI75q+Khvs+1v8y/oM2jnQnF4uo+fuO425Owc + HGADiudspXTUYGiZkZZQVYdRzXWeC9Y1BdMuNOstNW5+bfveQKqcVyE5eG/kYgLIshOFOQDmopp884v8 + yKKl7WrB/nf8Oh2/xJjni1CzaeaWZWgG1pFA/lWBdanrOo6NBFcCR7C24U7eB+NGt+IdQ8QJbfbCmIV2 + pgYJq5Ya3cp4TvdNeGV4Sv7sonA55yazhGVOnFNJtMyp050aEFKKbTNzwPqcUOgala/ZWuG2k+Wik5Fc + dpkkA1OYXFiLhHjYCPdgqfUfSrfhjX9Q0N7hLJBJ567WBXOKi0a7u7PxHHcwQebctuxGw65HPFONNwnU + fccKDp1a0kvi13MTCBzuUkZPHQ053iKqI4yhHUk5zTp3Y3kjyLh95LD09qa5ErbljCgdhXaj0lqlc9Jv + pRc/DK3P2V/lRQJAPQ4zXLax/Z58GaUYXP25JHWVN7dMnnB4HbpXV2jXU/wt2FC0YjbB2g8Bq5u5uhP8 + N4bb7HMTBdkm4Vfk57Z9ea8rDaSa7SPn8H7sml0qPr3Rx3IyPWpImAkBztxg7qjPWnRkbxnGPevYex9G + 1dHTeN5bGe/tJ7LUZ75mtk8xpn3FT6dB+Vcrjmur8UXkd9pGiyppzwBbfyzMYgiyMPT1xXKVlh/4aRz4 + K6opPp/n5ABkgVs+Go4JvENhFO0sUMkgjkaI/NzxWRHnzVwcHI59K0dCnmtNbsbiEgSR3CMu44BOe/tW + k/hZrWu6ckuxW1G3S11O6t4w/lxSsi7+GwDgZ96W7nmmhs/NkV1SHZGoYkqoY8HPTnJ/GtLxjbXFr4t1 + JLqSOSZpi7NGMLlvm4/OsKiD5ophRlz04y8jWgMr+HbtBdXgiSVW8hIsxE/3mbPBHbg1k1ZhmK2lzF5k + 4Vtp2IfkJz1b+lOWC0OlSXDXeLsSBUtwhOV7kt0FVsWtCp2zivQfAEtlbtej+3ZrJiEbG1VD4zng5zj+ + tcrrtvpcElm2lTM6S2sbyBmDFJD94HHT6V0Pw+uraLVrhJdLW7Zocx7YvMII9ieM1zYtc1FnDmC58NL/ + AIHfzOd1sR/2vfmO4+0qZ2xMf4+TzUlvdb/C93Y5umZbhJwqKDGqgEFmPUHoBVnxegXxNf4tJLUOwYRO + gQgEDsKg0e88rS9XtZL4W0U8K/u/K3GZg3yqD26mqg700/Q0pu9CMrdv60MTNJRV3TNKudVndIFwkal5 + ZWzsjUdya6DrbtuOvlB0rS5MLkxuvB54cnn86zauy3fm6fBZ+WP3LMwcE85x2/CqdJEwTS1EHWtC0ydL + 1CPJz+7faFyODySe2M/rWfWlpYLm9hVipktn6NjO3DY9/u0S2CptczaKKKZZoaXMkGr2crBdqyoW3dMZ + Gc1HfD/TrkqPkErY2jAAycVWjfY6MOqkGtLXiX1m6czmZpGDlymwNkZ6VFveuZWtUv5GZXR+CXWHxVpk + mYg3n7PnJx8wwCfbmuc7Vo6JcfZNUtLjMSmK5jfLDJGDnp6UVFeDQV481OS7pnRwMYrTVoXZfNW5VlCL + hSQSDg44HIrrrqNEvNRPG6OS3kDDqckZxmuW1WAxa/r8DSRoNxfgbQ/zggAfTtXTSsZjKyw7zPpsUwkK + dMY6cf59a8nEK9n/AF0PAxivyy7/AP2puySKnB3Zz6U5T35HFMRvMEciqMMB9TkVIPvdMV860fIySWhl + 2yk+J7hVadc+Ud0IzjhhzxXJahJbWttbRyNIZYZ50YGPaQM8c9+T0rqbxVj1l5JA5X7OshxJs+64z9eD + XP36pHdX8UUSvGl2JwkuSzKQTj3HSvbwrVk/Jf5H02AaspeS/K36jre+sLjwtp0OV+0RanGWjVD90++K + 5HxKAPEWqrtKgXcm1cYx8xr0S+07TjY3MsenwQy2kkUiPBLyQ2MdK4bxpJnxRqatbJC7Tbjjr0/rnNdu + EknN28/0PQy+pGdV8ifXf5P9Tm6KKK9I9s6W4KC18OScECJgQfaU023bGjeIExjMkZwP980SEHw/oUxG + VinljYkcfeVv6mnQlW/4SCIKBujMgH0kB/ka5+n9dzg+z8//AG4dOnmarfsmCDp4brj+BaYs8M9toMCS + AyxGRZAB93c/FRNco88LIc7rLym47hCP6VV06PbqFnMxAQ3Cg4PIwRn+dNL8Cow0u+n+TRKf+RPP/X// + AO06xq3Gj2+G76EjmC+Qn8VYf0rCrSHU3o/a9RR1roLOEnwnq8qoWVbm3BbdgDiTtXP10Ol3EA8Oa3am + GR55FhkDjooV+c/99Uqm33fmKvflVu6/ND/Bp/4q7SR/08gVmy5V5EPUOc1Y0C4FprunXBIAjuo2JPpu + FT6pa/ZNeu4HGAly6k+2SM1D0n8iG7Vn6fk/+CXYN0lle/8AXmjfkYxUkCczNvHESHA/64sf6UunL5lt + HGww8kE9sQR/EoDr+pA/Ci3JlVMfLvg259SuUx+Rz+NYS6nJJ7r+v60N4soTI28TxL+AjrXshwnP8NYy + Pm3MwOGAhnGO+Mqf1rXsDyvOcHafpXlYhaHhYxe6bVv/AKwcfwiuj0/AC1zUJ2kHuP8AGt6ylAx71xwf + vHm0naabNx2IIwKQyHgZxSRyB05PNLsyetetCasfRwndXiSx8jOeaz75QHP61eLrGuaybycHJPeubFST + RyZjNOCj1Ma8AKv9MVkzDkE9d3+NaV5IAOv/AOusqc4ADHgDkn9f6frXDFHkQTMa6ULMORkbcj0xkf8A + swrBmXBVCekkWfyYf41szyYdpHAAVcnvz98/lhP1rFl+WeMEqf3i7h/ujJP6161COh7+Fi7D1GILPB/i + vD9PlFY9ux+16YGPKsP/AEKtG4ulS0iVQQUt2H/ApGJP/jtY6TKt3bsCP3aZ/HBP9a7orQ9GlF2fz/X/ + ADL+uYOj6QOPlsiPzlaotC/5Auv/APXmv/oxaq6mrrBal5C26BSo/ujOAPzBP41a0oeX4a1+T1jhj/N8 + /wBKpq0Lef6lSVqNvNf+lHOHvTKe3WmV0o70aWmKGN4CTxZsRgZzyK0b1wBgd9NhGP8AgSVn6bOITcbZ + gu+0aMg8ZyenvXV3BtbHTNDm8i2FzLIrmXkt5cag4P48/hWM3aSOSrLlmrrc5tpmSZol+8t0HBHrmtyQ + eVYW9wYYN0mpOxuS5MhwTwV9KopbwmxkuJ1db17yJo3P3WDbmPHsCKszXnlWUdq0jySR3Vw5UIFVNozk + H6kmplraxE3zNW/rQp6WrFNIILZbUDyOvGyueucGdz6sf5102kDbJogPG0z3H5D/AOwrlpTluvNaQ+J/ + 11ZtS/iP+urGgEjinoM8bgB79KZ3py9K1Z0s7HwuFHiLQRuYlYmYnp/E9dPp6h/A+moQB9o1dcD2yf8A + Cub0KJbbVJpVfJtNKaXJzwzJnH5vWnfnVbLQNAsfLhjib/SbeRW+bJ5+b/vqvKrpynZeX6s8HEx9pVST + 7f8Atz/VEeuXCrd6tcFRmS9Ee49QBu/wFbOgqgtdMC+VxE7kg/MOQOef8KzobnyfB1+JIFlM10+6RgQQ + SAAwP1z6Vs6SFDRxruAgtkQcYAJJJrkxTtSa/raxw42XLh3Htp+Fv1NY4wSAPp6VChlJgOI8BuevSpzk + D1yM1HzmIAAHdwcV4sdz5uErHNaqx8zU2MUJQ3MSbdpLcf571n6OYGv7GH7Ox36i77ViRgVC/d5JPHp0 + rXfdJZ7k8vM2qZBMuMhe5Hbp14qro0tybjTJDFvCrd3PySqvB+XJznHT8a9+npTt/Wx9VRdqLX9bf8A5 + HSm0n/hLpJNZUCwV5XKFeCcHaML749q5+YozuY02qXJA9B6Vr6YNHaLUn1R5fO8km1CE8yZ74rFY8V68 + FqfQU17z30S9PkaehSGC8mmEe4raT4+fbjMbDPv16VkHrWhZ2sdxa3ksrFRbw705AyxYADnr1P5VnmrW + 7NI25mxKcF4JzyOg9abV2OcJps8Q35lkXICjbgZ79c89KotljTFJh1KUXAhMdqQBwN+WUbOfUE9PSso1 + rQlYdAvXO0PPNHGu5MnAyxwe38OfrWTSW7IjuwoooHWmWSwskc8TuGKqwLBTgkZ7elavijWl17XZr6N7 + homCqnnkFlAA44rOtbeS/ure1hUGSRhHGDgZJPGT+NPvbaayv7m2u1Tz4mKMEYEBh9ODS0uTaLnfqVl6 + 88V1g1PQU8EyWcFs6anI8e9mBIJGckHtxjiuUUZOAMnsK7XxDcatbeFLKw1DRLeyhklDpPGAC2BjB568 + 5rKrZuK8+5zYmzlCPn3tt+foVfBVzoNrqFw+uPPGpiIjeMuuPXO3muakZHu2MJJTeSpJPI7ZzXZ+D5tW + sNC1e9sNHtLu1AIeaZhuTCnOATyADk1xG9gSfUEUqf8AEk/1HR1rTfot/wBOh0/w/gnm8Y2htxHvjDOT + J0AwQf51meInkl8R6i8pUyfaHyU6Zz2rc+HNvbSazdXN00ipb27MCm4YPuR04zXJ3MnmTTSAn5mJ5Oep + qI64iT7JGUPexk32SX5srUqnnoPxoxlSc9OnvQK6jvOwDtD8MNrQyp599lZE4VwB0bjHGOK5A8gV1Gpz + 20fgjSLVY3iuXleWTKkBx0DdcGuWPU1hQ2k/NnJhFpKXeT/yFUevSux8VT3o8N+HrO4ihSFIC8RjYksD + jkj8vzrj4xntk56V1Xjby4p9Ntoobi38iyQNFMzEgnJ4yeB9KVTWpBeoq+temvV/h/wTlOcA446U8EDn + A9OabxuGefpUkah3VR0ZgOa3Z1vY3tYuftN1YgX81wIrWNFMgOYuPujgcCuk8CS3c3iqLdfSNshbG8Zw + MdOa5a5V4NTlQ3ZleMBRKmfmx9a7P4frdS63cTSOX2Q7d7c9a87FvloM8fMJKGDl6fma+pz+UniQS3cZ + JRV5UBj8vSq/hW41KDwDOLW0MuGdll81QMY54PpTNY1BotI8QgRNJ5s4TzFj4UDA5NM0/W7Cx+HRtxfw + C62sPK8vk5J4/wDr15sYv2Wi3a/I8aFOTw9lG95R/LyOW8NX0VvrcMmoJI9tuJOxipB9ciqniKS3vNZu + HsYpViZ/l8xixp+g20V/fmG5hunh2k5txyDWPd5junVBIEDEAN16969aEF7W/Wx9FCnH27l1S+QjoY4y + hKhwc9a66w1rV7LwXPaRaMzWj7la6yTjNZus6Pb2GjWkpWVLmbBO5MLjHXOTVqHxLNa+CX0hdKkWOTP+ + lZODz1pVH7SKcVfUzrv28IuMb69dDG8PGBNet2uL+SyRST56DleKXxZPBPqO631KbUE2/wCsl6r7U/wt + PZW2tLLf2zXEIQ4VU3c49Kg8U3djeaxJJp0HkQYxs2bSPwrRXeI26G2rxez0W+lv8zT8H6pBYvNHJo32 + 9nAxtySo78Vi6i6jVrhhAYV8wkREYKjPStrwJcXw1dobG8itfMT52lAIwPTNUPFNvJb+IbtZZlmk3ZMi + 4AapjZYiS7oiHKsZKPdd3/wx03jhoJfD+hXFvZiBfK5IXqcVR0XxyukaK+nNp0cxcMPMJxgGtHxClzdf + DXSrh/L2REDAOTjkf0rzrcRx71lhaUatLll0bOfBUKdfDunUV+WT/M6bwz4nHh64uZxZRXLTLgLIM7fe + n614uudb1C1uorWKzngUqrQjGc+tcqHIPHFPVzXV9Xhzc9tTveDpe09rbU1dJjhuNagW9jkliaUCRI/v + Nn0rQ8Y2VtYa20dnZT2cG0FVm6n3rJ0qeeG+ge3mEUgkBVz0U+tdP8QLW8iurS5vdVhv3ljwPLULsx9K + xk2q8VfoYTk44qKvo09Nfy2IbDxvPYeGW0dbaORSGHmMSTzVODUrqTwdf2IuLZbYTLJ5T/6xif7vtxXO + A8Hg5zWzoumWeo2eotczmGaCAyw5YAMfTmqlRp07yS63KqYajSTnbdpvrrcwjQDzSsPakFdZ39DqdRuj + d+AtOjW2uWS1uHBuXwUG7+BfyBrlDXXW11eXfgG7sF02SaC3mEzXSn5Yh6EdzXImsaGnMvM5cLpzxt1f + +Y+B/KuIpP7rg/rVmVtt9KUkLKJWKuep5PNVPQ1YuJZJrl5ZQPMkO9sDHJ5rZnS1qbvjZbZtaiurWeWZ + Lm2jlZ5M5LYwf5VzRrqfE0j3ugeHrtkmLC2MDOyYTCsQoB78Vy3asqH8NLsc+D0opPpp9zsGHYDO4gdK + TBre8IxaPP4ghj1whbMq2WZ9oBAyMmkax0u51bU0XUUtrSESPasyFhLg8KPTNU6iUrFuulNwaeivsYuF + 8tTk7yTkY7V1vgQ3514QabfiyluI2V5JEDDAGeAe/FUbO60NfCN5a3dow1ZnDW8qruyOOCc8DrVXQ3tY + tRtpr6ISWazKJcZzt74xzWdX34SVjKverSnG3fpe/wAup0nxEtriDxDHPc3IufOtgwcKFx25ArnvDNva + 3uuwW11ZS3gkBVIY5AhL445Pauh8ZWelpFb3OnaPeWcDMweaRSqSZ+6Bk9sGuX0d7a11izmvIfPtllUS + x5OSvfGOaig70tDHBu+ESXb0/JkMK2cbG1u7acTLI4aSJwT0wF2kYOG75qWy1LULPRr20t0KwTOonlCn + K9QFz0Geal1eWOy8UT3NlbyW0SXHmwRSIUZVzlRg9KcZLm6u9WV4bqMzq1yYF4wQdwLD0AJNdCd1c7U7 + pMy1tLk2b3awubdHEbS9gxGQP0NV+lbWmM02g6xbhuAkVwBg8lW28fg9Yp9qpO7aLjK7a7CVoaPP9m1e + 2k3ogLbGZl3ABhg5H0JrPqRJWSRZFPzKQQfTHShq6CSumgePbM6ddrEVHWnrgzqzzhZFW4VZhv6kMAc8 + fjWZQndXCD5opi1Zu5jcmORnd2Eaqxbtjj8ulVa2bzMnh3TpRBEqK0kBkU/MzAhufwbFJuzQpuzRkDof + epYZHTIU8Egn8OlRU5OGqmU9UekakZLnxQ0ox5mp6YJQSdxGY++B1yPwq3pXlzW2kSv5mJIHtXMjZXgF + RhRz1FZMdyf7J8Laqy2+2Jns5MJx143ds4JrT0xmi0mZcR5sLsSIB95gW7H04avIrL3bfL81/kfPV4v2 + aXbT84/5HRWEhl062bcCyoAeMdOO/wBKtLwxyQQRVWy2I91bI0bESkjYTjDc9fqTVrHIJAGODg189WVp + s+TxCSqP+tzM1OINe2bkYEglgYlc/eQ4/WsTUstqEU8d1CBeWiLKHT7zghCAD6YB+ldBrSv/AGeZI8GS + CRZVAP8AdPt7ZrN1kJ9iiYLBI0F4YwQmfLikG4ZY9jk9a9LByvFfcexl1S8Y/Nfr+qMiRbefTJJmSTzX + tjEGVmAMiMDkgf7PrwKwfGkUp1eK8kBC3drHMhL7iRtA6/hWzbl0iljMwMuMbQP4o8Bh7ZQj64rN8Qxt + P4a0i7dw8sJktZABjbtPy/oa9Sj7s1/X9bHuUFyVU/O33r/gWOS7UlLTa9E9k37eIT+EJiCfMgvAQGk4 + IZccL9R1pdGzbatNHP0MWJM8/KcZ/Q/pTdBYTWeqWhJUy2/mK3m7RlDnGD976DmoIFddWSNnDNNF5eR6 + sm0fqR+VY/zI5LX54v8ArYvpHBDBYecFV7e6eG4P+zkEZ/8AH6zTdTR2n2PtFP5nvuxj+lbFzB54uCP+ + X21S4jPo6ffH14f86kkt0nM2xf8Aj/tQ6hT0kTk/iSrD8aSkiI1EtX/X9a/cQyhTN4gh2hlkAukB7jcC + P0euW6V08EqnUNOnYgJdQG1kJ6BgPL5/8dNc3NGYZnjPVWIOaunvb+uxrQ0bT8v8v0G1s+HwJ75rVlyb + qF4gPV8ZX/x4CsccDNWLS6ktLyK5iOJIpBIp9wc1U1dNGtWLlFpD1BU47g/yrovFaibU4r9T8moW0c2f + 9orhv/Hgaz9Zt44dXkeFR5E4E0WP7jjI/LOPwrRA/tHwaAOZ9KmJI7mFz/Rv51hJ6xl/WpyzndwqfL7/ + APg2G6bJIsM8kTfvo9tzGD/fT735qS34VI7C2lJhAEcUgmhB5zGwyfxwFH51kWdw9pcCZcHGCPqD/wDr + H0Nbs8ASICLa7WrbogRnfC2WwfU9R+JqJKzM6i5Za9f6/r1NbTpItgXJ8tGKH/rlJyp6dc5/E1o2UhjB + icgOh2nH93+E1z+nTpDIo4eIAjHdoWOevTKt+ufSt5kfepRleWM4JzkMD0B9iPyIrz8RDWx5OKp6tdzc + ikBHJ68H2NaFtceWQrHg9DXP2l2hAAzs6Ent7H6VopKR948eteZKLizxJwcGdPDd4A5/GrQvT6iuXiuG + X7rce9WFvGPYfnTjUaNIV5xVkzamu8j5jWZcXGcknmqb3hPQ/lVdnLnn+dKUnImU5S+ISaTzGyfujp/j + WVfShUIYgKfvc/wjrz+n1NWLm5VRhSTk4yOrH0FZE8wZyeGwcFf4XYdEHsDya2owu7nTh6TlK7KlxIBE + d4G5iXkU9CBgkex+6n4msnbulfc2SBtzjqznn8do6etW7lxjO7zFUB3J/j/uj/gTEn6c1WjLW4e4UiR0 + fyocc+bcN1x/uj9ceterTVke5SjyxKGqR3DLJINvl+btO0gjfjhR9AKy1UrJIV52KeR+X8zWvqrpBPHa + RsrLZLsZh0ec8k++PX0Wn6RYRgWss+dkjvcyA9oIv/imyPwrrjK0bnZGoo07v+v6RQ1/C36244MEaQke + 6qN365qYn7P4HkPRru+A+qov+LCsu6ma5uJbh+WldmP1NafiL/RbfStLBwba2Ekg9HkO4j8sUNfDEqUf + 4dPzu/l/wbHOt1pppzdaaa6EdiNPSrZZrmRGhZs2zFec4PQH25rVufEdzqywK8UQS0tZbeJUGMLtxuOT + 1x/Ks7SyLaw1C6B48sQLnjlv/wBRP4VOtt9kjmjAPm+XFCFxht7ncRj2AIrKSTd2c81GUm302/X8zSNy + s1po8cuSHuJLmQKBkImAMf8AAVb8qgnnZ9PeV0+cWpckjq8sn/xNPvC6XVyh2lra3SyjIUcu55HGe3mV + HquyS2jt4SrG4uhEm0dUiUIp/HcfyqEtUYR3X9ef5EkQELM3A+y6Qef9qT/97XJuck1011Mv9j6rdLnb + c3SW8Rz1Rcn+QSuYJ5rSmt2b4dO7f9f1diVPbRNPcRRIMvIwVR7k1AOtaeiIp1NJHAZIEaZgULAhQTg/ + lj0rSTsjeo7RbN2E4OrGBCrXE62sIA3AZbkZPsv/ANf16XxZOi+J7CzDIqabbqDn/ZXfwB7ACs3wZAl1 + qmlQvtCRvJeyHJHThc+vK9vWqd3eDVtV1K8jTMkzGOIhc5ZnAA/75BrzZK9X0/4Y8aS5q78l+ei/BGlP + EY/DGj2YlGZpAT++4+ZiRle3GOa6qwJk+1TiV282UqCWzlV+Uc+nBrAu544tatYVWQrp8GWVogjfKvAI + 6sPf0NdHYxeTZwoQMBMn3PU/1ry8dO0Eu/8AX+R4mZTapLzd/vd/8ibjOCTwMComnMTxtkgKGYlh8vA9 + f896mOCc8Y68mqOpu0VnO/A227Y+bu3A4zXnUVzTSPHoR5qiiYUs9xHpOlOjIjIJ7oklWGedpwMHPP8A + 9btVWxaWCz1ORxOPsWkiLdEdgDP83zcA9W6VJqUbmaa3R4Q8cEFoFUc5Zgx5I9Aec/jVG/miXwnrN2Fm + V729EMZEg2FF5AwDzx7V9DGN0l3/AMz62nG8Uu7X4u/5NnBMf/1U3NKT14por10fRI3LXEPhDUZT5Z+0 + XMUS5PzDaGY4rBPWty9YweFtMttpzNLLctlQPRRg9+hrCqKfV+ZjR+1Lu3+Gn6BVwrCmmpwrTSPnOWBT + HbHQg/mMVTq/fKYorOJoViIhD5Dlt+4nDY7H2q2avdIkupXj0OyttxCO7zld3fhQcY9B6/yrMrR1g7bp + IMEfZ4Y4sEnrty3X3JrOojsKG1+4UDqKKmtoGurqG3jK75WCLn1JxTKbtqyfTxYtfQfbpJUtTnzDGPmH + XGOvtVdiu5iORng1v6Vbppt9qovLCO9js4JIn2gMqOTtDEnHfv1rnu2KlO7IjK7dizp1st5qEFsZ0gEs + ip5rnCpk9TXR+LIL+zg023ufEEWqwlGaIRuW8vBxz/ntXJjHQkgewrc8M+Hz4ivpLUX0NnsjMm+YjB9h + 61E1rzN6IzqxSkqknovL+mOtdStrLQLlEudQTUZ8x7EIWDyzjcSOpJAxWGrYDYzzxTplZX8syGQISqsD + wR7VHVqNtTSEErtdTuPBrrZeFvEN/IgOYxEpw3Ug9xx1I61xLcj3rTj1y/ttDm0dJlFnMwd0ABOevX8B + WUTk1lSpuM5SfUwoUJQqVKkvtP8ABInSzneBpVglaNPmZ1QlVHTk1EiFpFRcZY4HOK3E8TXlv4ek0YRw + mJ12eYudwXduI4ODz61n6Xbte6hbWaQvIZJRxEuX/CtOZpNs155JNzVrHR+NW1KGLSNL1CO1i+zWo2ND + IW3Dpk+h+WuOAyew710HjF0bxDcIpvMwqsTfa2y5KgA/hXPDr1xUUFamjPBx5aMfv+/UsWUJuLyCFVDl + 5FULnGSTW9468pfFNxFFALdIlSPyw2cYAqr4QtVu/E9jG8AnjV97xkkfKBknjniofEM0dx4hvniYGNp2 + CkEkEZ45PNS9a68l+ZDfNiku0fzf/AMth85A9algeSGZHjba6HKtnGD65qHBzjIzUsJZXLKA2BzkZFbv + Y65bFrLXE0kk7O0jMWZgc5J713/w6MEJvXAvgWAG6NQQPrXnkLMrfLuX/dOK9P8AAy39v4burmK/iEXz + N5WVZlwO+a87MH+5sePm7th2u9jO1fUAfDFzENVZ5JrtmMBTqM9SeueKo30+ijwhbIumzJqRPNwUIU+u + DmqWqTXn9k2kU0KhJJCyMpG5j746VteMrrWLbQdL0zVLK2hhCAo8T5JwAOaypw5eWPn3MqVLk5IrrJve + 235lXwb4itdBW+85JVlmTCSpyq49RXKyyfatRM8rF1d8sRx3rsNBTWYfClyLHQY7m3myftBb5gO/HtXO + aCv/ABO4mGntfsjEtbDPI71tTaUpzS19f6sdVJxVSrUS19V/SNPxbbaXGtgmlg4MZ35uPM/TtU1x4xtT + 4POhm0nEqwiNWZxgHdknHWqHiq8trrVVNtpEti8aHzFcYJ9/pXMMxdyWJJJyTmtKdFThHn6al0cPGrSh + 7S+mp1vgXULTTb65mul35j2qCpYD14FYvim9h1DX7q4g2eWzfLsBAx+NdF4KvLi1tLtbZtNlDHLw3DFX + IHoemK47UZvtGoXEoRYwzn5FOQPpSpRviJysKhBPGVJ26Jb/AKGh4bW3bWoFuoHuIicGOM4LHtWn46tf + sutZSwNlG6ApGcc+/FYWjyyx6rbtDN5Mm8BX9M113xA0a8tFtb261B7tnG358Dbx2oqS5cTG73QVpqGN + hd7rbX/hiW2MV58K50aVmkglyEA4XmvPz1rsfD/iu303wtqOk3MBc3GSrg9DXHNjJx36VWGhKEpprS9y + 8HTnTnUTWjd18w4H1py/MeaZ06VInbPSupncx8UbuW2jJHJpxdnQbstz1Joijd2Koe2etSQo6PlSQfbm + obRm2iOPaBJv3Z2/Jx3rp/AdlBqGtyW9xYx3bNbuYkkfau8DgmsMQSR7LqSKV4y2NxX5W9s1c0VL6XWI + IdNlaC8kYqjq23GfesqsuaDszCu+elJJ28zJu7eW0vJraVQssblXUdAR1quoGQCSBnkgVqeINNu9J1m4 + tL1w86ncz5zuzzmsruK2hLmimjopSUoKSdzrPC93bxaZrdpc6hLbxzW52RKuRK3b15rkmHNdL4M1az0f + xHFdXse+3Cspym4jI4IFYuqNE+p3LwKywtKxQMMEKTxkVnBctWWm5hSTjXmraOzv07FOpQpKA5NR8be+ + c1fifzdGePYS0UwfcBwARjk/UVu3Y6ZO1jdnma6+HkMAa6nNrclm/d/u4FORjd3JJBx71yn1rsvDsFvf + +EtatZbm6EkeJoreIEqxx1IA56CuNxhiDWFFrmlHz/M5cK0p1ILo/wA9S7pT2sOo2099EJrRZVMsWeWX + PIrqop7SDx+lxZ+Hme0uE229hOgXflcbgDkdea4uIgexHOfpXX+ItR1m6h0bX7nULRp9u2BLVv3sWOdz + Ad6KqvL10FiIXml3TW7/AEHeFY9RtfEWoaRaWFit5cI6vHej5YQMk4P0NcuG+xTbSFEkEudyMeSD9fWt + ydtOHjCFpbmfW7SR1aZsGOSZiMbQfriqniKzbSfFN1AbE2SsQy228PsVhwM/jSjvr1QUrOev2kvw066/ + gdv4uXWNT8Ix6hqN/YQwsEnjtI15fPT5ieuDnAry9ZWinWRDtdGDLjsRXo+gtpNx4fRhoVzq1/EWicgF + lTJO3GTj07etee3KPbTtbSxNHLFIQyOc7SOorLCac0Oxz5auTno22fZL8L3+bOg8fNHc6raX39px3093 + apLM0YChGxjbgdOMUxBfXGraXqOomDy9QhMCMq7vlVfL+YZHPTvRqGoXeseEbZV0y2jttMISS6TCs5bg + D1NZK3VqukQbWuf7SiuMorkNEsfXhT3JreCaikdVGDVNQ7XX9fgWtBDR65NYkNmeGa2KjuxU7R1/vAVh + MCDtPY1qzXcdv4iTULZt8azLKG8rYCeCwC9MZyKimsZrnULn+z7eWaJZSVZYzwCeM+larR3N18V31Rmi + l7U6WN4pWR1KspII96bVGppX4Eum2NwWdpAGhcswx8p4AHXoe9ZladuRNol3D0MTpOMnrztPb3H5VmUo + 9iIaXQVs2hEugX9sLZ3lSRJ/MXpGgyDn8xWNWrot3DDfNHNEDFcRGBx9e/X1ANKa0FVV437GZQKdIhjd + lbhlYgim1RZ1+kL9u8FarGI90tlMl0rBySR90/LnsO+K3dIuTd6jMkodkv4dhxHuYkorL6dcGub8FzwR + 6oba7MccF7G8DSOWHDAjjHHX271qaVJcw2xieTE1vJtVQzBlMbFvTPKu47fdrz60dZL+tf8AhjyMTDWc + fn9//BVzrrC5eQ205MxFwnkyM6YUMn8IP5itLafmDcZHGKzJYxC00VqY5Ps7l4yhb5VP7zJPQZG4etaq + usiiRXDIwyDnNfPYuNpXPksbG0lJLf8ApDGiDRlJACrqVPOc5Fc5JZteaLLbswjlKGFynJaSLLLnA7rx + n2rpgQVzuA21lyb7bVJY42Ia7UTQg/d8yPn07jj8aeCqNSa+Zpl9Vxk18/u/q/yOUEbQyXVzE+4p5d3G + uMA54fvxyT+VEtqk2i63pafOYHW8gYdWXoT+RWrc3lWGpBlANrA5UqF6wSjIHTtuP4kVO9xDYajp88pD + CMtaXi5yhjOdnXqMHPp8or2+bqv6/r9T6Jze8fVfLVf15nmJHNJitPWrKTTdYurV4yhSUlQV2/L2I9sV + m16cZXV0e3CanFSXU1dBvhZ6xaMzlYs+W7LhTsbqM/ifwpt+htbgPE65t5mjBX2YlT+PP5VmLwf8a6i/ + Yak8E7Ig/tG3CrtXaqypwABnvgD/AIEaiWkrmU/dmpd/6/zJ5LlIoYLuIfJaTCVU5x5Mo5GfY5H41XMo + tIZI4pvMl0y53xEEkNE3XH44/wC+qZo8yzWXlTPtEe6GQt0Ebcgn/dYZ+pFUIpXh1ECdypceTKX/AIR0 + 5+nH5VHLuYqnq12/r/P7y5ewhIrqzibIib7VAR1xnDD8sH8Kqa8qy3EOoIAEvIxKQBgB+jD8wavJ5giT + gmaAldjDqRwUPsyDH1Q+tVpYkfT7izU7/JP2m2Y9WjbAYfUYH5NVLTUqGjT7f1/k/vMQUoOKSgDPFanY + dIM6j4cWRQWn05sNj/nix4/Js/8AfQo0HU10zVVlnUtaTKYbhB/FG3B/Lr+FZ2k6pJYXiyuXeEp5Usef + vRkYK1Y1GyNhcAKS8Mq+ZA/B3oemcd/bsawcd4vqcbgrunLZ/wBP/Mn1bTZNI1CW1JDj78Eg5EkbDII9 + cg/nV/Sbpp41hAXzYw3kr3dTyUz2YH5lPr9RSadLHrmmJpVwypfQZawmY43f9Mif/QffisdzLZyMzKUk + DbZY8YKEHsD05/wqbNqz3IV5rkn8S/q/zN7zo0aN4pFMZYtG7cCNz95GHZW/DHX1rQsr92iaF2WHblcu + PuZ/hfHVSehHTrWXb3H29xNEY0vJBiSN+I7odwfRv6+h6ujCSkJF5qyxZXyv+WsIHbn76+38q55wTVmc + tSCatI3UmNu3+sPmnliThvY56Ee/Q960obt0Khl4bgZO0fn0z+JrnIJ5IkXzghgLfJJz5efr1jb26Vor + eqcRRsysP+WfCsw9wfkcfTBNcNSjc86tQT6G4t0hBPzp7gdfx6VJ9ri2gmb81zWEZ4IV6JHzk7w8BP4D + K1J9pjOCJzj2uwf6VzOgcbwxrm7QdMsPXoKrS3jSKSCNg6nPyL9SOv51S823my4k3svZUaQ4+pwBUIux + K5WM72QZwrbmUf733UH0ziqjRLhh/InkcsTgkMB8zP8ALhfc/wAI9hyaoTSB38oKMbODnblfX/YT9TSP + PuVmLJ5Sn745jU+v+23uf1qnNcRldokEan52805J/wBt/U+i1106djvpU7EE3mzXAtlmVcjzDKwxtGP9 + Yw7eij09yKs/aEsLYXUSY8pTBpiEc7z9+Y/5649KULDHbSeeTGow5L8uCejP6uf4V7ZyfU4OoXcs0xaY + /OFCKi9Ik7IPf1/+ua64K+h2wjz6dP6/r/hyBlE0giV8jGC//oTn8q1bq+WHRJNoKz3wWGJc/wCrtkPA + +rMMn6e9Ure1RxKJJFSGNQ9y69h2jX3J/X6VSubp7mdrpwAPuog6KMYAHsBxW9rnS4qbS7FzQrKO91mM + T8WlspnnPYIvJ/Pp+NZ2pXzalqVxeyYDTSF8eg7Cti/P9iaCNPztvr4LLc46pH1RD9ep/CubLZB/Kqh7 + zciqPvydTpsv1fz/AEGE80n1oNWrG3W81COMjZF9+THO1FGWP5A1tsjqbUVdmpGsMNrp1lMSE+a8ue+R + j5V/ED/x+tC3gSZAZrs288G+7kITO6T7xH4AKPq1ZlzcHfcXckIBbBVMHC5+4n4KM/gBVyKWK+toIOUD + gvcydT5afM5+pbA/4CKxlc45xdr/ANeYlruhaCSUmSSJWv5+cfOf9Xz9dp/4FTZHEN9EFA26dZ7s/wDT + RuR/4+4/Kr23GnwmfaranKZpsfwQIM7evp/IVn2CHUnJlbBv7oyTEfwRJ8zH6ZP/AI7ST6/1/W5Cle8n + /X9akOtv9n03SrAE7khNxKM/xyHI/wDHQtYRq7qt2dR1S4ugpAdywH91ew/AVRPJraCsjsoxcYK+/wDm + KvJra02GSPR7268pyJ2S3ifywV3Z3Ebj0OB29axV4z7V09vCbc2Uccxxaxfa3BPCyNjaBx3+Qd+tTVdk + RXlZHWaeh0fQ9Yv0hZZREmnwDH8eMP198ms7RrFJdUitmRm8pi7BGKgsg2IQe/7wsfpV/UXWwtdL03zl + 3WULX90Gy26U8qPrkgfjUGlRtY6E9wDm6n2QwqQPvuPlwe3yEt9Wrzb+62up4vM+SUlvLb8l/n8y/YwW + 95cyTRWyhLu4KI7OWPlpj5hznkjGfeul6nBH41laTbpHJK0YzFbILeLk8sPvn8Tj2rVB2/eNeJjZ807L + ofOZjV56tl0/r8rCEDfjGOvQ1laggmlS3DohmnQYdd4ZVBY9Pp0rUHJwGX33Vz+oXQcTzRqrCKKQjaN3 + 3iI15xweGowcG6lwwFNyq3X9PoZUtzc5S+SeAb7ie78twAPkXCdOeuRisTxJO1p4e0fS90TAx/aZP3JV + 1ZieCxPIwa2ZoTc+Tp8I3SSCKzEfyjBJ3ufbGAD161y3i+8a68R3WSwSEiGNS+/aF4xn0619DQjea8tf + 8vzPrMLFSqRXbX/L8/wMJmzS4yqjack9fXtTeAMkZz71oaPbpPrFukil4YzvlGSPlUZbpXoN2R68nyxb + J/EL+XfxWi5X7HbpCAf72Mt/48TWKeKsXU5urue4fO6Ry5wc8k1XNKKsrCpx5YpCqMkDOM1oRQQ3espB + CpMDSBRtJ+6OpGfxPNQaeRHdCUsyeUpcOuPlYDjqD3xU1iwRby5fYSkLAbs8s/y8e/JP4U2EupWurh7m + 6nmdmJlcuxY5J5qCiimWlZBT42aNlkjco6nIIJBHvTKf5Z2hiRg0Aa8LJH4cvJmvblLq4mVPIAISZBkk + se+DjvWOfar02ozS6Va6aVjEVu7upUYZi3r+VUcHPI5qUiIJq7YoGe9bWnXOhix1AalZSvdNFttDA21E + bnlucnnFYgropdXlg8Hx6O2nRRrLN5v2kod7j0yR9OlKfQmsm0kur72Oe/QgcChRuYDjn1pCadGMnGMk + 8AVZrshWUAfeBye3ek+7tPB79M10/i8SWZ0zSJbaO3extVEiqwYs7cknA+nFZ+gWhn1iEvpdxqMEH7ye + 3gU5KDr0rNTvHmMYVuan7RmW4VoxIBhnY5VSMAduOtdJ4G0y5v8AxHEIdRXT2hQyiY4J9MAE89ai8Rvp + kl7Zw6bo02lMgJmW5ZsnJ+Xg9gMfnS+HZtFt7DVZdWt2mkaEpasEJRXOe4PB6frUVJN07pfqZVpueHbS + av5J/hsZGr3Mt3qlzNPP58rSsWlwBv564HSqQIweMkjA9qGPAGOaStkrKx1QioxSR0ng1tNi1Z7jUp54 + Y4Yi6NBkEt6EjpWDM/mTu4z8zE8nJrq/Dt2+l+E9auF06eVLhPI+1ZGxCeMEevNcgc5rGnrUk/kctG8q + 05ei/r7xvfmrVpF5jEjamOM7wCPzqsvWt6Gy0R/DL3cmoyrqwfC2oiOGGeufpWk3Y3qz5UvMy16tg7vr + 3r0K1vba3+HsgEmmy3JGCoi2yAE+vc151gkk9KkV2CkZPNYV6PtUk3sc+JwyrqKb2dy+u24ura3aZY4y + 4UyHomTya2PGSJb6hDax63LqkEcQKOzhth9MgmsGxnjt7+O4uLaO7jjOWgkJAf64p19eWVzdzywaabZJ + OUjSUlYz+PWlye+n2B037VPovT/hy7a+L9YsdP8AsNteMtvtK7cA8HrSeH7qe0uxd2+rR2M4YDdICcg9 + axpNgwEDc9c1aYWc1oqrII5o1yxck7z7DHFU6cErJblSo00mlG3NvoWdc1S61LUbmW8vEupxhEljG1So + 9sVjHOanEQBQFgFPU9cVeGgag2m/2gttm1z98MP5da0TjBWNIuFOKjsdVokWqW3hOSb+ydKu7QKzb5QP + MA+teeu252bjk9u1WWnuYIvKV5kjYfd3EAiqp4qaNJwcpPqRh6DpylJtav8ArqOiba6sCeDniu516DSp + PD0MqakZb0IpEbSFjXCYIODWnBpF5Mm75UTGdzOAKVanzSjK9rE4mkpSjNytb8SrFZzzAsifKO5IFOW0 + ZyN0safVqRIS10LczIuTjeW+X86SeIQzvGHVwpxuU8GtLvub3bdrjhbRAkPcxjHoCc0GNPM2q5ZOzYrt + PD/gOLWdLW9OoImVJ8sdc1X8IaRp2o6/LYaiCAoO3BxkiuWWLglJp3tucMsfTSm02+XcwLHyobqOWSPz + YkYEr6iu2/4TDQ7eaOS00CP7u19+OazfEWnWGieKY4IUDWRKlhnJ962PGC+H7qxtV0c28cqDL7fT3rkq + zhVcW07M4K86WIlTlKLtLz/OxQ1Dx0Z9LSwj0m3jt1bcvGQO9c2+ryfbY7qFEhkSTerKOhpbi7d9PS3N + 1G6r/AqYP4mqBgYwGTOFz3rppUacVojtoYajTWkbfezf8eWt8l/aXl/dwXUlzArgxDG0ehrkCcqOO/Wr + lwxkt4zuZmXg5PQVTNdVGLhBROzDQdOmoX2+RZsLs2V7b3IVWMMivhhkHFb3jnzbrWU1NtPNnFeRK8as + QS+BjPHSuYUlenWux1f7drfgWx1J0i8mwf7OX3bpHz6+gHFTU92pGXyMq9oVoVPl9+34nFirun4Zpojj + 54zjLYAI5qmBk+lS2sghuopCFIVgSGGRWz1R1zV4na/DG7dPEE1kJxFHd27I24A5I5GK5TW7I6drd3aZ + z5UpAPqM1HI3lXLmI4AYkFeOK0fEltDE9nPBIHWeBWbnkN3zXOo8tbm/m/Q41DkxXtL/ABr8UY0YBY59 + OPeuitzFd+EZ7W10J5rq3l82bUI8nYnofSubRtrAkZAPI9a6LwvPfzXVxpNlqkOnw38ZEzykbdoBOM44 + OMj8a1qrS/Y3xC93mXTXr+hJqdvqd14R0rVZJbNrO3Y28EcWFlBznLY78f5zUHiO+0K9uLSbSbe9ikEY + +0vcSbzI/HI5Pv8A4VkSDyvOiKK5Hyq4bAXB5I9f/r1VHWnGFhwo21v3t03PR/h9farNbXmk6fNChdfP + EshyYu2QO/btXPeNNKutN8RTR3UxuJJgJfOwBuyOeAPXNReF7wQ6pbrNey2VoT5c08DBX2nJ5PXt71pe + MINE8mNtHnuriRGImkkDEbSflO44rjUXDE36Py/U86MXSxzaWkl2/NmRoCGeS8tUtrKR5oGxNdE4hUAk + lRkDd+BrMtntljnFxA8jFP3RV9u1vU+oq3oOo/2VrdreMZBHG4EnlhSxQ8MBnjOCaZe31tNr89/BAfs7 + ys4imO44PY/nXatz00mpvTQZJqs82lR6dIsbQxHMZK/MnUnB980y/aSRopnk3edEp446fLz/AN80x4HR + 3REV9rD50O4fTg4qWVCdPaN9oktpsEZySGH8gV/8eqtC7JbEV4oK28qptV4wOAQCRwf8fxqrVsBZNLbo + HhlBGWOSrDoB04I/WqtMaL2lFDc+S2B5ysmW6AkcfriqDAqxVhgg4Ipeh96uakWlkjuTtIkQEkYHzd+B + 9e9LqLaXqUqVSVYMpwQcg0lHQ+tMot3qgXPmF2kWRQ+89WJGTz65z+VVR0xWm7NdaCnCZtH2ZJUEqxyA + BjJwc5PvWYPSkiIPSxc069l0++gu4ZHSWFt4K4yD7Zrur5/L8QNdhnEGo24vEFwADIwB3jgdSN/A/vCv + OhxzXbWLrdeDormCKWS+0m5Ejl5NyiJj2B6DOOAMda568dn8v6+Zx4yGql8vv2/E2dLuGEVugnDsybGA + bA3RnKrgAk7kJH410lhtETwIQwtztT18s8qfyI/KuU064H2h4YZFUoyS2hfA39WQnjuCUPPdRXQW08ay + 28kTgQTgIcEAYOSgAB42nKc88CvGxlLmTPncxo8ydv6/paGptCOeAQRjI6VS1WOQWi3EAHn2riSMA9h1 + H5fyq7gAkH0x1zSADhjyPusMg5rx6cuSSkeDSqOE1Lsc5rUUMjmSIZiuoWeLdg5YfNtP1DED3x6VkybX + 03b5wBmRI5crwV6xPnPUYKn0wa3zbObC704PiW2PnWjM2TgEkYz1PJH41k28kP2hz5IMckbt5W3vkeZD + +B+dR/jX0FGd46H1OGqJw06f0vw/FGJ4oja9sLHVCn75Aba7B6h04BPckjH5VyRGDg9a78Ri5SbTmnQR + 36qDK7HBcAtE3XqwypJ7g1wksTRl1cEOjFWUjmvRw8tOU9fBzsuTt+TIa6DTC154fvLdHbz7JxdQjd/D + 0fA/75P4GsA1f0u/On3cM6gYUkSKCcup6g/hxW0ldHVVi3HTcvGSKDUork4FrfIfMAH3M8Nx7NyB9Kv3 + VoHjla6Vd7KY5mAyY5F+4/rhscn/AHvaq9zaITcadHkxODd2Lv8AxAjOPqR+q4p2nXu+2SXeXdl+zTxM + ThhjCn344HoR71m+6OaV7KUf67f13QsTO8WZXEc+RDP2MbjG1vxwDn1DetQsWiuElCAOC3lowyBIP9ZE + R6MDkfUDuac5MGolkl8xGj2LuzmaL0P+2vHH+z7cuuEiaJZWl3W84CvIBkxMPuP7EdD7Zx1oW4J29H/X + 9fcY1/BFb3JMJLwSKJIWPBwex9wcg+4qn0PvW1c7rhXtplVJlbJwAArnA3A8fK3GewOD0NY8kckUjJKh + RweVYYIrWL0OqDugViDxW/pl5b3FoNJvpEWFm329wefs7nsf9k9/Q81z9SxHI28Z6jI60pRuhVIKSsXr + 22uNOu3guYykityM/kQR1HethrmLWbeI3ASPUVGEuXOEuAP4ZPRvfv39aq2mpW9zbLp+rA7IvlgulGXg + 9j/eT27dqq3djdaY67sGCYZSRDmOUeoP+SKyeuj3OZ+81GWklt/X6E2oWF3od+YJ4/LMih/KY5BU8jB7 + j3rVhuo9TiAlhkmMX3WRgLiMe3/PQfrx2qmt+LmwSx+VmKhAlzzsI7xv278HitGbw+JYEOkTNPKoDPZS + /JPGcdV/vD6VlNr7WjMKslZKpo+/9bFljPBF9rZ0vLQ8NcwjDr/11jPU/X86rwSpKSILhWyf9UpBH/fu + Tv8A7prKu7h3WWO78wXRAAZwUcEdm/vU7T76JY2iuhbSKeSbmM5/Bl5rP2WlyFQ92/8AX9fcbEb3cO4A + 3cKHqqRvgj3XOP1qVblmJBlYkdP9DJP6msuK4sIssiSD08i82j8mGan+2QsnD3Of9u+Ws3DyMXT12/Iv + CKZot5huW54aS2CJ+pwaZKzBwkrRgg5EcsoZQcZ4jjqnEsl1I6WVpDLIil3PmGUqo6nHSqb3m4COGXkn + BEK+Uv4nqaI07jjSbNCaZnnRFBM4GA0iBmUf7EY4X6n9KaphiUmaRY8Hd5jNuCN/eY/xP6KOlZ91cCxX + 7Osgn3DLeSMRn6t1aq9vb3GoSAqVdU5LsMRQjuT/AJ/OtlDTXY3jSXLduyHXN3JdtGkKuMN+6TqzE/xn + 1JrYstGa3DRK6vqW3dO7H93Zp3LHu/8AL60/T7KO1jluILsQQDKy6nKuCfVYl659+v0rM1DVhcWxs7FG + ttLRssM/PMw/ic9z7dBRdv3YhdzfJT0S/r+l95X1KeCQi2st40+I/wCsK4Mzd2Pv6DsKtaXbw2dudb1F + FaGI4tYD/wAtpB/7KOp/Km2GnwyW/wDaGrSNBpsYPlqv3p2H8K/1Pas3WNXm1W43yBUjVAkMKfdhUdAK + 0S5vdXzNUnP93Hbq/wBPXv2Kd5dzXt3LcTyF5ZGLO3qark0cjrSDJOB1PFdKSR3RioqyAHHzcYB71t2C + R2mmtNJzLdA4UY5jU5PvywA/OqenWIvbljKwjtoF3zydNqj09z0HqTWxFJHcXX2uTbD8vmAdRBAvCgZ7 + k4x+feom+hjVmn7oSqqQGGQZnAbYBj57hz8x+ijj60gs/N1hbOKQCJdqTYHVVwW/Dd1+lRbpFumuUkAl + jizt7QjsPcgHPuWFXI8afZAPIqyXEIMrfxRRDn/vpj/MetZNtbHPJuK03ZFrmoI4eSL5RKDBAPSIfeP4 + 9Ppmi5P9meHgSR51xGLeLttjGGc/UscfnVexg/tDVIzNGXiiQSPEp+7GPup9SSB/wKqOuaib++O1w0cK + +WhXoeSSfxYk/jVRjqojhTV4wWy1ZmA8HrzxQCQQR1FJQK3O809DtobjUle6I+zwgzTDdjKjnH4nA/Gu + y8M2CanqPnXcqxAk39xkEgIPuLn35P0xXN6dBGmnxQuwRrkma4YNkiFDwPqSD+IWuwu9+j+GVtjtTUdY + wSoOCsXRVz9MdfU+lcOJm37q6nk4ybb5YvV6f5v+uyM24uzq+oTXEoZkvZvOkAzkQIcBQQOdx44HVRW5 + MzW8se0knT4zI5H8V1L0HPoMduMVk6UIoJZLmRC0FuAVAI+cL8sa8erDJ78VuafaFruG3kLMICbq6Zud + 0z9Oc84H9a4681FeS/r/AIB5+KqRpx8kv6/DT5o2LS3Nnp8Frn5lXLknOWPX+tSA5Y7sYGeaayu53A7H + J4Pt/wDqozjh2XAGcZr5+UuZuTPlJtybk3qyK4aaO2klQJJLj5RIw5J4H481zd3JHNcFdiyxCVVKB8Hb + H8qDd3BYlu/C5rW1e68iLzEcbrdDM69TuPyoPbk56GsSSSK3gcOMNDHtO7gFsAOQT3HCAc8kkV62Cp2h + c97LqTUOa25B9otyLrUrhJ5rS1jf99buVYTyHhiSfTA4/KvOnYk5Ock8113iiR7HSrSxc3UV1ck3N3GW + xE245Ugetcex+Y4ORXuYaNo3PpcFD3XLv+n/AAbida0bQi2028uSV3yYgTcDnnksD7Yx+NZw7njitLU8 + wQ2mnZ2tCm6QHgb259cdMDNdD7HXPVqJmGkoopmhKAnkYIUuzZBzyAO1W3PkaKqA4a4l3sAw+6owMjGe + pPOcVRRS7hVBLMcAetXdUObxbVXyluohUtwBjr26ZJpEPdIoUUdTSqPmHOPemUWbO1N5e21rGjs80iph + euSccVuTeG1m8bLoNsk9nvkEeLwruXjOTjHGOR61F4Z/s5NSlvtYhnnsYkO4wPghyOOcirGiSeHZEvf+ + EkN8Z3YPBNCckAA5BJ6k/KOlYzk03Y5alSSbtfRdFfV/5GVrmlx6RrdxpyX0VyIGCGaMHaT3/Lp+FVJo + X+eQXEcig7Qd2GYdB8p5xWl4e0mXWNet7O3+ypITvBvH2xtt52nuc9MCneJrhrnWrlpLGxtGt2MOyz4j + LA9R696tPWxrGbUlB6u2pkQBpCIVUFpHULxk59q3fFMus217FpWrXkc5sUVYxGQVUEA46Dn61z4IwTkq + eowOtISWbLEsT1JptXdypQvJN9AJBHTkmtDRrdbnV7SF4pJoi4aRIhlio5YD8M1njtW5oW62s9T1LA/c + weVGxfbh344x1OM8UqjtHQmvLlg7f1cz7+SO41KeSBHSF5WKKxLMq54GT14roPCV1BYrqV2viGXTbkR7 + IoimRNngZ7cHFcwm5Ii68DO3rXZLeTaV4f03TtQ8LmUPIbt5GPzXEYB9BkDkfkKzq6RUV+n6mOJ/hqmu + vp+u5geIZXfX7rztVGqtGRGt2vAkUAAY/lXSag2veHvAMGl3VhaR2F6wdZkfMhzhgCM+lclZQ2097El1 + MLSzlkw7hCxjXPp1NX/Ext7e6isbHXJ9U0+JA0bPkBCeqgHp0FKUbuMewqlNScKfRa7dvTRGCc5560Dk + 9KO341JDE8siogBZmChc8kn0re9kdjdkdhfrJpnw40+3+0yEahOZmiaMAAD0PftXGHpXVeNTBDe2WnW1 + vNbraW4V45SchzySOa5Y53EVhh17nN31OTBL93zv7Tb+/b8B0YY5xn8DXYa1eX9v4Y0/TL3w8tiBhkum + TmXHvj3rmLC2N7ew20LiOaVwqu7hVU+pNdJ4yGsW+oQafq+rRX3kxBozGchQex468UVLOcUxVrTqwi7d + +t/69TPttdWJ2L6XYzBhghkIwPwPtV6w1PQGS8OoaWyvIMQiD7qHt1960vCloLPwvqmsy6ZY30XCD7Q4 + yuOuB+Irhy5DFlIGSeAOBWKpwqOSWlvMxVOlWlOEbq3VM9F07XPBD2qRXWkGIxx4MjJkufqDVNLbwTMJ + JDcvH1YR5I/4DnFcJ5rhSobgnn3pu/g5AJ9aTwWt4za+ZP8AZtm3GpJX8zs9V0jw59ljn0/UQzsyqYiw + JUHrmtCTwJpMtrvtNYiYqMsxcH9K86D807ziowGYfQ0PDVUko1GN4KuklGq9PmdxN8O7iO0Fyl7DsOOv + PJqk3gPWAH8vDxhgu4MQMmubW9nRcLdygdcBjVyPX9Tgj8uPU5wh52hzil7LFL7SfyJ9jjo7VE/VGnP4 + G8RRusRtGmOONrAgVl22h3d3r8Wjsgiu3fy9rdFNW4vF+uwsGj1KTK+pzxSaba65rF/Nqlikk1xEfMeZ + cfKa0jKtFN1GkaQniYJuvKKVtH5/MxLy3a2vZoG6oxBqHcT3Nbvi+2WDXGdc7ZlEgyPUVg10Up88FI7M + PU9pSjPuiWBzHPG4xkMDyM/p3ra15WM0Mz7juQY/0fyh+GDWCCR07VuXbWtxpkMouVE6qAIDJJIx9Tzw + PoKJ6NMKmk4sr2lxdRgfZ5Zht5CoTWjpeJdYhWd5Ii7gO4OCM1H4dvbywvs2dotzI4wEZcirmsRahZXc + VzqNobaaX514xXJV+Jw7nJVd5yp6K607/cb/AI68P22kra3Nr5zK/wB9nJI/OrMN54Yk8HtG6RLfNER8 + iFmDdqbf2niDW/CYv5riFrVE3BBycD+tQeAtSkRZrGHSEupTlt5A446HNefZujq7uL7njpSlhveleUH0 + dvvuQ+Am0JZL1dWhSRyv7rcpOfXHvXL6gskd3cRxxvHEXJWNlwQO3FdRp013pHjdDdWCQySuR5WRgA1N + 8QYZYNdS5lhjRZUwApyT9a2hUtX/AMSOiFXlxflNX3PO2DHPXFRHpWrIs65hEDqsnIGzk/jWYwwx7V6k + JXPbhK4wda6rQP7PudC1S21C5njKx+Zbxq5CF/oOp6Vy3Q8Vt+GtTXStegu/s6XA3bRHJ78VNaLcNDPF + Rcqb5d1r9xhNkUY9c1ueKrGex8RXQuLVLcyt5iRxtlQD6HvWKWYqqk8L0FaQlzRTRrSmqkFJdTU1WKBR + aTQ3CzNNCrSKv8DehrU8oaj4H3RwJ5llL88g+8VPrXMp0JIJNX7K6vI45LS2kmWO4+/GgzurKpB2Vnsz + CrSk4xs9U76/12Mv6VMrbtpYAICAQvBIpkiNHIyMpUg4II5FNXg5/Ct9zr3Rsa9b2llqok06PZZzxLJC + nm7yoKjOSO+c8VjDFarJaP4dLCFhfw3GZJd4wYyMAAZz1zWWRg8Uo7WIp7WfQlt5DFMrjHyndz04r1Ty + PF/jLTo3ZdOtNMvI9jMuCcKeCRyQc8cV5MDg11Gk6jqF1oraHpWmq1wH89rmJn8z5efXHSubE07pSVrr + v0OPHUHNKcUrrq+nnuc/d28tpcy20q7ZI2KsOnIqv0xxwa6HxJoOqaYLW/1Odbhr9fMEqtu9OCfXBFc+ + emcVvTkpRTR10aiqQUk7+ho2Njc3djeFLuCCOFAZI5X2lxkkBRgk89veoLbzZJvIRVZrlfL2BgOcjH6g + VtWAfw7r1hct5ZhuoQV+0kOIw2Vy4U9jzisnWFjj1O4WG8iuxv3edFGUVieTtHpmmnd2FGbcmuhXtEZ5 + 2t8sDICmAQMnsOfcCqtXb4hblLqEOElAkDFNo3fxYxxgNmmX0YW4EiKojmUSKFJIGe2T6VZomVauoWn0 + uSLcALc+YAWA3ZODgdz/AEFUu1WrCbyrtMhCr5Q713AA8E49cUMJbFSlqSeBoZ5IyM7CefUetR0FGlpc + kaXTW8u3y7iPymKjccnoRzjOcc9qoSIYZmjYfMjFSPcUwVpaqftSQ6huLPMu2U7QoEg4x19MHPHWlsyN + pepnk5OQK6XwdqFtZ6o0F4sJt7xTbys4bcqsDyuDjrisGS3kSGK58siGbIRiRyw69Pz/ABqOJij7h97s + ampHni4k1aaqwcX1O6jabS5liuJH8ywlNpN1B8hzlGGeeDkj0ytdJbnzbea0R1fJaRdpbaXAy3OOjr86 + 4xzXOyTjUdMtdeuJ2uOPsGoKVG4L/C49cccnuBVnTZZ7eRYA6m5t3WKRgN3AOY5AfboSeArCvOqw5lfq + eLXp88b9V+f/AA/4NHW2VyL21Wcbcn5SMYyRxnHap8Y7KRjBxWdbTJDcsqOgt5yGQs4ym49R7Bsgn3FX + UbaxV2BOCGC9jXz1elyy8j5TE0eSbtsVdTDwGK8gG6S3JDqvO6I9frXO6tb/AGS5d0lYRThZoZAfmWTk + q+Oo3DOffnsK7DCgBtuQRtIJBrEltNsUtoWUPApkslYEhhnOD64ORjHeuvBVre6zvy7E2919Py/4D/Mx + rqNpYmRdscodgqr0V/vFfo2A6H6iue8TQrdPFrEWwi5ytyqKQElHXI7Z6/jW/BIYpiOSFTeF5yYwenTl + 4mzj2BHSo5oo3ebTpJohaX+P3jKAFk6rIM9Oco3TH5V7MJcsrn0NObhJP+rdf8zz8g/d7ihTg5qa5t5b + WeSCZdrxuVf2P1qEgg816Cdz2E7q5v2Lm+082qOfttnma1YN95ByyD6feH/AvWmG4W2u49SjiBt7gFZo + mHGf4lHp6j049Ky7S4lt54pIG2TRsGjYdQRW7O1u8X2qIKtjfHbcJjP2aUHOQP1HsSKzaszmnHll5P8A + r/gonuLdvKH2iRDDKvnJKhDNGT92Qgfd5wGH0NU45pbeaZXRS4UieEcLPEedy+46/r2NQWj3NlefZnmE + UQb5i6lkwcgEgclSD+v0q7e2rxeUTKPssY/c3cYz5Rz+ZTdxnHofYzs7Mj4XZ6pkUkaSpDB5qOGB+yXD + dx3if0/p9DxlXKvIW3xhJYeJOMEgcD8vWr6zPayyW88YCSEGaJOns6fz4/l0t3SC8AAmV7uAZEijJ244 + P+0pB5HVfcU0+VlRk4PXY5ml/wAkVYmiVw8sUZVU4dc52n29qr8854NanUncl87KKp/h6NWpY6nLp37p + kjurR+Wt5eUb3HdT7isbvUit5cm6MkY6ZqZRT0M501JWZuSW1jfKX06YROSCLO4YAj/dfofxwadbXF9a + EwT23nRodxhnBBX/AHWyCPwPpWMJEkBLEpISMED5a27a71jRrPcpZrOYYbKiWJh6HqKxnF2tv6nNUg0u + Xf1/zNFNXt7xfKupgyD/AJYamhfb/uzJhx+NQW+nYvhOunxXloR/qY7pXP5jkfiKzXvYbh42EKR7RgpG + chv+AnpWqmj6c/hh9Xa/MNyj4NsFzxnAPUVjJci7X/roc8oqku19O/5W+8nnsdML8+H9Ug7gRyhvx5Wo + RYaYoB/srWyR1BC//E1liaBdpi1h1b3jcEfkTV46rMEH/FRSMPRQ/wDWlyyXX8xOFVaJv/yb/gmrpFw2 + lXDy2Hhq5cyRtExupCQQfbaKwzpzRLKLma0tNh+4ZN7E+gC5qK1vreaWRtWlvblP4Fim25PuSDx9Ktpr + lpZ4Gn6LZwsvSafM7f8Aj3H6U1GSei/r5v8AQahUg3ZXb6/8Fv8AQ2rK9a60AWK6fNqUScCW4xDDH/wL + qR9SKyL25s7e3SOW4S7mU/Ja2q7YIz6k/wAR+n51n3eqajq8gjnup7jd92Jen4AcfpThpTWqZ1OeOxjP + /LM/PKfonUfjiiNNRev9f15IIUIwd5u19bL+vySILy+vNVljNxIZG+7FEowqjsFA6VoCytNIJk1zL3QX + MVghGc9i57D26mqja3HZRvDpFv8AZw/DXMmGmI9j0X8OfeseZ5GffIzF2G7c3Jb3rZQb02R0qnKa5fhj + +P8AwPz9C7qmsXWq3Sz3Lhto2pGvCxqOgUDoKzuBn9MUFsfdJyRzSda2UUlZHVCCgrRVkJmp7e1kuLmG + CML5sxATcwAGe5Pai3t5J7mO3jUGZ2CqDxg5rSWL7M72ltOpkKEXVwD8gXIyBx26ZHXt7tuwpTtotyxi + GOCSwSZGsLU+bcypkfaJOgUH06ge2TVdyzESbgbiUg+QowA38I+gHOPpWjJFAlmpjj2hF32kLKC0n96W + T+QH+HMM2mtbCGMy41C4UtPnGIUPJz6Ejr7fWsro5lOP9f1/WwW0ccamRiJbaIjgcm6mPb/dH+eTUd3c + GVpHmfzFRgZT/wA9ZT0T/dGP09xTfN81kS3OODHb7uAiDlpD79f19BVjTo7ZUk1S4BFhY8WyFf8AXTdg + frjJ9gBUvTVilp7z/r+v62C8k/sXRxAzH7fc/vJ8jkEj5V/BST9WX0rmOtWL27mv7yS5ncl3Ysx9z1qv + W0I2Wp00ocq13e4Vb062+2XiQ8ADLyMSOEHJ4PB4FVBXS2lpHDpUFtbDztSvm+ZWiw0YBwFB77uPwFKp + KyCrPlXqb3hyCz1G+uL2/URWEIE0gx0iX/Vx/iQOPYVp3GoTXWrXetzvhLVBHap97MjjgDn+EEn61n3k + a2rW+h2bjbakPdhefPuT91BjnA6fnVqKMicPAVmFs3lW4wCJ7pvvP9B6+w9a8ybu+b+rf8E8SpZy5+60 + 9P8Ag/l6Esca2KRb1Znsz5s2CCJLkj5V+ij+tbunWr21mEf5pZMyTk9S5x+f+NUrC2iluFKsXtrFjhyc + iec/efitflV29HPU+teTjK1/cR4OYYi79mvn/X4/d2BWySdxwvYjqaYGBiLSINoG9yOfcU4hjhCPmx+l + U9SkjZVtmUbJMMWRh8ozwD2GTgfTNclKHPJI4aFP2k1FGNfvJNcGXeIdjCUpKu5fMI+XjHARPmJ9eDVB + YLWe6gy6C1jAmn8+MnbCv3QQv97JJx/eqe423Uh866aWBkZnmUEERA5ZsHvI3A9gPWszX7t9O0E/vjFd + agQ0sUYyphP3FDduB0r6GjDaKPq6MH7sI7nK63fnUdXublXJiLERKSSFQHgDPOMYrMBHU5/Cl429TnvS + Yz1r1opJWR78IKEVFdC7psCzXSFxmKIGaX02jtzjr0/Gqs85ubiSZ8BpGLfKO57fSrMqva6dGCwBuvmI + DA/KDxkdRzmqJ/lQu4R1dwooo96ZZoWHlwzSXRClbZMhWYjc54GCPfn8KoMWJyTljySe9Xbo+RZw2gOG + P72b5jgsfuggjqB/OqNCJj3Fxk1u2qQWfhe6uvt8IurphB9jMIZzH1Lbj93kdqxYInmkSKNWZ3ICqgyT + 7AV0eoPp95rlnYLPfR6ZbKIXaePfLEOrkKOwPapk+hnVeqXz+4c+oXekeEk0uC6s5bfU/wB7PHGmZYiC + MKxPTIAP51pakNU0XwTZ2lxbaNLp94p8m6RQ8sRPzEZHftnms1tStNQ8UQy6xdS3GnQ4geS3gEbSRqMI + ce/HvVPWYNMk182ugPNNYSsiwmY4AZsZ644yaw5btJ+pzezUpJSX956frpqTadJoFvoN+urWV7PfS/8A + HncRkrGvH19fY9O1YU5iBVYizKFGS2PvY5x7V2fiS61/R9Ns/Dur2tmsEC7opE5Lhc45+pPYZriHd5ZG + dzudjn6mtKT5lzG2HbmnPv53Q9IS4TAI3Nje3C/nQIZMvhCwQ/MV5A5x1q80i2ljJGkhEjDCGM8Nn7wc + N+GCBUQRrS2PzDe4IdCGUp6HPQ8H9a0ub8xU6kmtm7b7J4bsbNZXLXTtdSIGG0Y+VePXGT171mWtubq7 + it1IUyMBuPRc9z7Vb1S7+16pJIWi8uPEaeSu1SqjAwPfFTLVpGc1zTS7a/5f15EVrAr39vbXE620Lsoe + VlJCA9TgeldDfapqNnd6lPp+sm+sreIWKz3DDe8Tf3FPPXuKzPD+q2+jy3d1MizTPA0cKyQh03Nxkknj + H40y5vdPOgWNhBZFb1JXe5uXUZfPChT6Y7etRJXlqjKpFynrG6+Xq/8AIx2POM/jQT6E496c5YSncM7e + BkY6UwDPetjqFrofBdobvxRZJ5kcYRvNLugYDbzyCRXPDNdv4PZtL0LWNab5NsXkQs0IZSx7Z7HpWGJk + 1Tdt3p95yY6bjQlbd6L1ehg+JNRfVPEF7dSMp3SEAoMDA4GB9BWTkdaVmypz1JzTRwc5xitYRUYpI6KV + NQgoroa2g/2M2pouuNLHZhSSYFyxP17VFqElo19cmx8xrUufJ8w5bb2zW54X1eHRbG9lvNDa9jmTbHOU + yiHkdSCOtc/AI5LiNZjsiZ/nIH3Vzzisk25tvoYRbdWTd7Lz0+46vxJFZ6d4R0axW1RL2VPPeaJ8hlOe + D79PpiuKcjceMY4xV++EUVxKYJ5HgQlYSx5x9Kz2OT1oow5Yjw1P2cLXvfX7xuaTNLTfatjpLsul6hDb + C5ls5kgIB8woduD05qln6YFadzr+p3VobWW7ZoGCqU2gDC9B09qzCCpINJX6kQ57e/YTNGaKOozxVFiq + a7jQA+l+CdR1WHVjBPJ+6W3XBBPTJGevJ5rh15GOK7LxTDaab4a0ixjtY4bt4xLNIhyW47n8a5cT7zjD + u/yOHGrncKX8z/BakGvCG98NadfRlRIi7HGeTjj+lcnXYeHktr/QL/T0tfMuQC6yMegrkGUo5U9QcGjD + O3NT7P8AMeDfK50f5X+D1Ada6XSZobjRLizdpo5FyQYLYPu/3m6iuaJyB6jit/wxqNza3clvDqa2EU64 + eRk3VrWT5Lo2xSbp3W61/rch0nVJ9K1CO5hJ3RtnFdZ4o1zUfEmnQXE+lGG2j6TY4Jrjbvy476URz/aF + DZ83bt3H1xXcafqOv654Vk02z0+OS3j+9Kzc49K4sRFKUatjgxcYxlCuoq/duw7w3b+JtU0OS1066hSz + GQQ2MmsfSrzVfD+vNZ20scVxKwjYuOPrS+HdV1fTrptO0+RUllbaVYZwab4t0fVdJvI7jU3Ekk/IdKxj + H97KErWlsYRjavKlPltLbuybxZaX1lqkdxfalFd3DEH5ONtdX4gtrfUvBtvfxSoZIlVw3UkjtXEjRLc6 + WL6e/BkYZCFsn6V2/gw6ddeHbmxndCUySOpwaxxK5YxknrF+hyY9KEIVIu7g+1jmdR1jWrvT7TVJRZJF + GuxSoGfTkVxd4uJmJdWLHOVrutPfw/Fpeo2d7Zu9yHYxOFJ47fSuFlXLEYbaCcZHau/CtXdlY9TAtJtJ + WKxqSJynIA57+hqM8GgZrtZ6bV0dZ4gga/8AD9jrtzqZuL2RvKeBsDYBnGB/nrXKYxnNdp4OMmo6dqWh + QWEU9zdIWE8jACIDvnr6dK494jHI8T8FSVP1FYUXZyg+n5HHhZOMpUX0em2z22NTw3pMWt6slhJepaBw + dryDIJ9K3IFv/BHi6W0tngmdsRI8yYBBxz7VyVnLJBMssZxJGQyn0Ir0LxLpl5q/hi08STalHdSqgDRo + gQKD6epzWWIbU1GT916fMwxcnGqozfuS0t5nO+NfD+oaRqS3WoSwSPekuWh4APcYrluh55z716BfXOi6 + j4FiE8rJrEA2qGLMzc/yxXAsuFB75q8LOUoWlutDbAVJyp8k907bW+41NGu5PtUlostvbRX8X2eWSVMq + o9fY5A596ypYXhnaKRSrKcENxSqzKBgkc5yD0q7rE1rdTw3FtF5W+JfNTJYCQDB5JPXGa6dmdduWfqZ3 + Q1f0nUptKv4ruCaRXTk7fpj/ADms80U5RUlZlSipKz2PT7fw5d+KPCs00t3qf2i1QywW06YiYHkbfXIr + zcggFSMHOCDWt/wk2pxafa28Gq30flgqUWUqoXsBg1i+YSWJ+Yk5yawoQnC99jkwtGpTcuZ6X0XY6WWa + 01PwbFFHZxx6jYSkGSDq8RHLOO+OBmm6r9o1vRV1uSRW8hhAyRWixRp/wIY3MeCeO9UfD2pPp166CaRY + LuNredY3VNytxgswIHbmrluNK0rXL2zvIo9StFDJC8UrEBz0YbeGPb0zVW5X+I2nCTt6r9UYyqJdOlV3 + l327AorSDYFJwcA85zjpUe4y2OwlP3LZGfvEH+gPb3qaNZbG/EcimFjlHE0fKqwxkgjjg9ahjZLa8Kl9 + 8QYozR/xL0JGfbpWp1FfFHarF0kcN1Kkat5Wcx7iCdp6Hj2qvTK3L9xm8sEuvmMkOI5WZhgjooA+lUKt + WUyxyMr4MbqVIYEgE98eo7VDPA1tcSwv95GIoRK00I8889K09OYXMNxpzY/e/PCWLfK69gB1JHFZdSpK + 8bo6OVaPG1lOCKTVwkroeJZBA9uCVjZg7KT3GR/U1EDzmruooHMd5Ht8u4GWCjAV+4xkn8+tUQcHNMIu + 6Ol8K6ja2lzNaX4DW15GYGzyIyej+mVPNacJnsbpopjtmtD9lueceZCeFb37D/vmuLjcq29Rhgcr6f56 + V3EV+dT0+HVpD51zYp9nvYl+9LbHIDdeSOmfYHtXLVhZ37nDiafK+bo/z/4O33HTrGzRJHGsMk0ReWBW + XeCRnzIvoeSAK0rO4iuII9j+Y237xUjPqOe4JxXM6dO8DLb/AGsscoqS9do48qZfTI2qR9K1IX+zXylI + k2XLFo0Gflm/iXvw2CR07V42KocysfOYzDcya+aNocHleD0zVe9tpJI1eAJ9rhJaEg9eOn49KmVxMgaE + 98ZPH147Uo5UEAbjxjPSvIi3CVzwouVOXMt0cxqEXmSQ3dmDEXlLwiRgdk4+8rZ6BsY+oWs6RI5bVY1A + jtpmYRqwB8iU/eRhxwcDB+h9a6XUYI7cySujNbXA2XKjko3Zx2HPesSZWtZ5hdDzFcCO9QEcqfuTKPyz + 7/Wvew9ZTirf1/X9bn0+ErqpBNf1/X9bmLrFpNrNi9+IydQsl8u+j2KMqOBJgck9jx2rj2BViDyR3rvW + mmsbzcnkzzQqRKpwy3cPcnrkgdfwPauf1/SLe2lFzp7mSylG+MlCu3+8hP8AeHpmvRoVLe6/kexha1ny + PZ7f5f5eXoYHNa+kaklmZI7hBJa3I2XES9SOzAdAR2/+vWSecGlRijBh94dM10yV0d04qaszoL6CezaG + z/dygKXtZwB++iPO0+vsOxyPSqttqD2sYgaR5LRjkKScxE8EDPHTt3p+mX0DWZ03UOLOQ7o5QMtA/wDe + HfB7irrefZzyWdwFNxMByWzFdoRwc9A3oe/seufkzlvb3JL+u/8AX5GfKq2zbS7TxEbraRScpznj9eKl + IaMQs8ioHYtbXiZADd1bHT39PoaRN8cUiRB5bYHMtu3DxEdT7fUfjTE3RbjG6SWsx5Ei/I/sw/hYZ6/r + imVv/X9f8Eusv2iQpMVsr5E2NIozHMp7sB2PqMj+dZl1p5Eu3YYpzgiEnKuMdUbuD6fzq2ZI4kSPdK9u + mdmDmW39SjDhl9v5U9ouFmaSMpnKy7S0EuPUdUb1/p3SuiYtx/r+vu+7Q58gqSCMEcEU4EZya2bmKCRF + UxrbuW4LNuib/dccj6HI+lZt1aNbShD1PQZBz9CODVqVzojNSIc1Ytru4s33280kTeqMR+dViCOCCDSq + xA4JH0ptXRUopqzNX+1I53/020tZyesiqYm/NcDP1FPZtMYqVluoM8nBWXHp021j5oqPZroY+xXR2Nci + 1AATVpcf7cBH8iaa6wkgtqwbj/ni3+FZdJQoeY1Sa6/l/kambJOTfXLn0SLH6k1KLzS4jmLTWmcfxXU/ + y/koH86xs0E+9Hs77sTop7t/l+VjVm16+KmOF47SMjGy1QR8e5HJ/E1mM+4kkksepJphNJVRgo7GkKUY + fCrCk0E0YpUUswAUkngADqaosQAkZFXbKxkvJMQFQEGZJZGARB6nPT+tWRpn2QLJqbNG5wyWq8yOD3/2 + R9efY1blQkxJdw+XGD+606DIbp1Y9efU5P0GKhy7GE6t/h/r+vuEgRDDNb2EgitiuLm+lGN/fAHUeyjk + 9/ZzNawWimWEi2A3wQE4adv77+g9B+A7kyzSguiNHFNcJkx2sQ/cwe7ep/yT2qtEjy3bXEcgvLsAvJLI + P3UXuSeuPyqL3Mlrq/6/r/hh8IuYbkXk8hfUZvmhgx2I+83oAOg/oOYGkHlyxrMzqxH2mYdZG/uL65P+ + Papbq6hFsRG7sZT++uWH7y4Poo7L7/8A6qZZ2s8tzsh2JJGpZnJIS1XuSf73v/XoebGtrv8Ar+v67FmG + yNxK1orrFhQ17P8AwW8Q6Rj6dx3OB2rP1nVEvpIre2VotPtgUgi747sf9omn6nqUIthpunkiyVtzyEYa + 4f8AvN7egrGJ+tOMbu7KpU23zy+X9f1YToOfwoUEkCjuB61f0y3hlvYftW82fmAzFFydvfH4Vo3ZXOiU + uVXL+jafGsJ1e62Na274CZwzN/D8vUjIxx/Suls7eTTtOl128MaarfE/Ylc42KesmenA6Z/WnWNpZ6m0 + 2o3btB4d07P2W3kbLOSc7Px/rTGebXtSOo36MRIoW3gjO1VjHbHTb2/M159SpzN3/ry/zPHq1XUbvt1/ + +R/z+4i023lVVdCXu5lCoehjLfxnryRk+wArfSLyjDb2RIeRDFbv02J/y0lPuxyB7VHGkRilaeRtpAJd + VwzA+nTl8bVHZRnvWvp9vLBE1zcD/S5hjav3Y07KPpXn4mvyq7PLxuK5VzPf+vw/rqWooUtoo7eJAsMa + 4HGcnuf60Bly3zHI4A6GgzIkiQlSGc4GRx7807AzhQGVSAD05rx3du7PnXzN3l1GuVt4S0zFUA3u2ePo + B/SubvZPOZ1L+U7gS3OwHhMYWPBP3sE8e+e1aGo3avNLGSJYIGBYbTmaY/dT2A6k+1Y0bYaVxcBpsF1m + bG0sPvykei/dT1PT0r1MJQ5VzPc93AYbkXPLd/1/XyFmSMuqu37tG83UGQFk4HyRDnoBx7Z9q4HWtROp + 6nNcZOxmyO2f8/yre8SXcVnZrp6QyR3kgDSs0hyEPIDD+83U/gK5E8nBx6V7mGp2XMz6TB0re+/6/r8h + D14qzY2pvLuO2zt3El27qoGT1+lVuh61pZWy0gtuUz3ox1+ZFU9eD39D6V0s7ZtpWW5WvLkXd5JMNqoA + AgC4GBgDgdOKqUUU0UlZWCrtlHHLM0kuRbwL5jg5IJ7D8TgVS/nWhckW9pFZLjef3s317DOTnA/nihil + 2Kc8z3EzzSEl3YsSTmo6D1ooKNPSr2HSr+DUNizOm4rCcrtbopz+OfwqxpWvappV7PqFmQbqYHzJZY9/ + BIJOT61ij3rotDEmnWkupXL3UFpcI9rFPFtYbuMhlbqMVEkupjVjGzbV7nYkan4Y8Lz6ig0rUrC+ZZpR + KgcBz1Cnvg9u1cd4bsLe5nuLzU9NvLvSYlKzNaZHkseh/DnisN7mUxmASP5Od2xWO0n1xnGa2xc6Za+G + lk07VL+31WQ+VdW+cRyoc8jHYDAwfWs1TcU+7MFRdNPXWT3S/wAvzMzU5YJb248iW6ltlYrbG4b5tmeM + /h2pLS2kR3lMYUQruIlTcPxHWqsUYkZssAFGcscZ9qnuJ38kWxDl9xLhgvB9iOcVtaysjqtZcqHp5V7d + tNNuitlBGYkyE64HPbNQztvCsWyzdsdAOlXTAGSOwhCF925pgxAIxkgjvg1RbzLm44wzHgY9AP8AAUIF + Y0dKJs7O71IsY3CGO3YpkM54Iz2wpNZp4UKfx+tWZbtngjt/uQooykZIDOP4iPXmn6Xpt/qVy0enwNNN + GplIGOAO/PFTteTIXu3nI1k1WSy06y0HUNJ2W8d0t1MdhEsqntz7f0qj4j1g63rt5qCI0aSNtjTGNqDg + DH0FW7fV7e6Gr6hrRe81SaER2zSDKq2cE/UAcdq54K7EBcnnAx3NRCK5r2M6VNKbk1Z/hrqxg6fWlq5q + VnPYXQtbiZJGjUY2HO3POOgqnWt7nQmmrodGMk8ZwOgrttfR9F8H6VpDwCCebM8rKR847bh+P6Vz3huw + Op63Z2bJ5kRlDyKq5O0dffpVjxZewXmv3LWq7LdG8uNQTgAdevqc1zVPfqxh21/yOGt+9xEKfSPvP8kY + nXj0pVL7Gw2Bxnmm9BWjpENs+owLfW08ttuDSCFSWK10Sdlc7py5Y3OgvtWuLXwhHpVt4lgvLVyA1ols + VZBnONxHTNZmgnSYrudtVDNEsLGMDPLdqd4ll0KTVQ2hwSQ2aoARITkt368itjTNV0rS9Be0v/D8ks8i + swnccHPTHtXJN2p6J6+iZ50vdo+7F3k/JM4xwHc7ARzwKi2kVdYLG5AAIxkA5GM1VcADaVweuQa6Ys74 + sipKUj60lWWFFFFMC5pVpDe6lBbXFwLeKRsNIei1t+LfC9t4da1+z6rDeicE/IB8uPXBNReFNK0nV9Qe + HVL5bKJI8qxbaWf8eKzdUt7e31WeC0uDPbxuVSU4+Yetc/M3Vsnt5fqcnO5YjlUmrLVW0+8bptus2qW0 + Uq7omcbwoJO3vwPar/iubT59en/suPZaJhEGTjgcnmrnhCe90u5utZt9ON3FbRlWbPCE9652SWS7u3mx + l5HLEe5NCvKq30SBXniG+kVbfq/I0vC9yIdYSNpWRJfkYr3zVbXbL7Dq08IOVDcGqEEhilV16qc11Hiu + OO6s7HUolVfMjAYA559zUy9yun0egqj9niYy6S0+Zyq81e029/s/UobpYkby2ztcZBqgOtTE8g5zXTJJ + qzOyUVKLTOm8S6gurSx3MemfZl2jLquA1TeFtR1zzzYaROIzL1zUt94zTUPDcWmNYR+YqBTIBjpWNod7 + LY6jG8ELSS5wqjOSa4OR+xcXHba55apyeGlBwSttfX5l7U4NQ8P64r3MoN0CH8xfWuw1/T9V1zwtHq9z + OHCJuEe3tWX4js/E2pWo1HU7VFghHGBhgKt+FTfeKbeSwutXmhtkTasSD7/tXHOXNCNS6utzgrScqcK1 + 1eO7WvyL3gW38O3ugOt8sCTLkO0hA69xmsjQrmz0bxhLHAou7SQ7E21SsdPS28SiwuIWeMPgBxtyPetv + xpY6fpNzZ3GmyxRyqQSkZGR+VRJR53G7fMZyUXVlTu2pr5C67NeaT4l+1W+mxotwmxI3GQ/4etYWu6Br + LWcupXNpHFEBnagxjNdX4jvYdS8PWmoQSSy3EOG3hOAe9It54r8R6ZHFFBaR2txHjexyT7+1RRqyilJW + VtHcxoV5wjGaSVtHfyPIHGCDnrSKQGBq9qdjLYXk1rMuJYmIbFUB1r34NSjdH1NOSlFNGnoN7Fp+rwTX + CySQK48yNHKl17jNa3jbSxY60t1DZ/ZrO9QSwxhs4456fy965dWCtkjNdq1lFrXgifUbjUJZNQsnwsUs + nyrHxwo/z0rnq/u6in02OPEfuq0aremz+e34nFDIcY+ldn4RtvD11bXa6/dSRmLBjQyFVx3wO5rjGHNa + OmXcdtqUF3PaLcxRyAvE3RvY1pXg5QsjfF03UpNRbT8tzq/CGq6XpOt3Ud1GtzazZWGQxbmBHTAPrXK6 + 5Zmz1adFglgiZi0SyrtJU9K7jxwiW82l6xaRWVnKQu2CFxvB6gkAYrP8WXMviXSYtbe6tQ9uBH9ljUlw + CeSTXFRnaoqnSWj9TzcPV/eRrJaS0evVbHCKpYHH8PJrVtdS3aJcaNLFbFJJPOSeQkNGQOcH0Pp71kng + 4pYnaGZZECllORuUMPxB4Nek1c9mUVJakbdqStXVrOGJbe8tpHeG6Ut+8VVIcfe4BPy56dKyuo6U07q4 + 4yUldBRRRTKHbtxHAHbjitu+vTqGm2NxFaQwy2K+XJJbRlSf7rNgYz75yc1hVrafq91Y2d3p6yb7W7Xb + JDkbS3ZskdqmS6mU4vRpao6LUvDN9qvg4eMG1N7+Z323Mez5ogDtGT3xx+BFctff6Tb296ZAXYeVICVH + KgAEKOcYxye+a09L1fUNPW70T+0/sdndZSfC+YvA7AevAyKybZHkle0LLH5p5LqBgjkcnpSgmtGTSjKN + 1J+noE8ourGFm8wzW/7tmaTIKfw4HUY5Hp0qn7VYtIZJJdqlVQkI8jDKpnuc9PrULp5cjJkNtJGVORVm + 22g2rs2LqxWf5VkgxGwJ5fOTu5NUqntZ2tpfNXYSAVKsM5BBGce1ANdiCipJolikIR96fwsBjNR0DNHT + 5ElEmnytmOY5jbn5X7EDIAz0ye1UZEaOVkcfMpw3Oeab1AHGa0bknULUXY5uIwBMqofujgOT6k4FLZkf + C79zPUgdc4+vetbQNXfSL5ZixaBvkmhzjzUPVT7VkU4HBBApSipKzCcFOLiz0GaB7MxxxRNLGFaa2beC + 0lo3LR5zjcp5GOQc+1adneRXMA8yeJEnwh+XHksPutj/AGsZz2O6uS0O4jvrb7Gix293G3m202/BMo/h + yTxu/LOKuWM8kN41xDBm3fdHcwMBlCcllAJz2yvvj0rgq073T3PIq0Lpxe6/r+vM7nTbtpvkaNEy5V1C + g+W46nj+E9c+pq/t57A9Dg8GueaQP5ZVmmlSP/SHyD9ohznIznLKcA/QVrWF4LpGjaWJ3jA5Q58weo45 + PrXhYqhyvnR8zjcM4/vI/P8Ar+vzLZ2MGbbngggnIIrBvLGaF4UiWMspP2RmGQ4Od0LZPII6VvAZxjYG + HX3pk8UdzG8UqxiNuCB2PbFYYes6cvI5sLiHRnfoZNi9pPp6wBVjmj3PYzzPkxMOXhbJ/L1z+FcvFqNu + DdJJEH0u64lh2ZNq/wDfUe3H4HFbt9ayRmaBneSSb/WqAB9oUdHXHR1/X8TWNPZYdZUneS7f5Q4HEi49 + /wCLsVPX617lGUZa33PpcM6cru+/9f1/w5zmuaLJpNzujcSWz/clj5U5HY+hH9R2rGCFmwMA+5rubS7j + +yPY3atJYO+10yWNux9M/wALfmD7jnC1nQZNNlLIQ1nIS0M5/iAH3T6H2r0KVX7Mtz1qGId+Spv0ff8A + 4JhqcHkcelbFhqMD2n9n6mpksz/q3Xl4GPdfUeorIxhsEGkBI4reSTR1TgprU6K5jm094XuZGkgf5rbU + IOuOnPr06HkfpSyHy0D7ooZ5eRKgBguB7j+E/h37VQ07VpdN8yFkjubaUESQScqfceh96v8AkKYTNobt + c2zDdNZyLl4/XI7j/aHIrJ3W5ySjKLtL7+n/AAPyGohtJhtiWBnPz2sx/dvxw0b9j6c/iacsnkzOY/Mh + nY4ltpPlD/Q9M/UUlvMJo/Jsx50R+9Yz8kf7h78+nPsaW3j8xdlnMJCeGsbwdfUKfX6YNHqL1/r+v6ZX + 2AS4t3+zyZ5jcbVb6qeAf0+lJE0QuTH5ZtpRyyqvmxt7lDzjHpmhGcz+SPlYHBtbo+nYMcY/SrICtD5K + xKNgyba4+V0P/TN/6foaC27af1/X9XKM1tbOCFXawz89ufMjP1U/Mv61XGnTyRu8CCeNOrwnJA9x1A+o + qXzN12qqgcKfuznaw9iwwau3jLlZNs0Emfu3CCVSPZwM/wCetNtrYtycdF/X6mFtOaSulvLifVdPt7SO + DTN8J4lhkCSMMdDvIJq6Y9KSCMz+H9VhdUwZoZ9wPv8AdxSdW26IeJ5VqtfVHHZpK3L200824e0i1QOT + k+fAu3HsRVYQaUFAa5vd+OR9nXr/AN91SqJq5rGupK9mZnNLg+lb0cPh9YRvj1eWTuURFH8zWfNYytKZ + ILO6S2J+XzFJ4+uMUKon0CNZSe1vUo7eM1LBBNcMscEUkrZ4VFLc10VukFsDs0mxQkcyXtzv2/8AAQR/ + KqqyQxXU3+mzSNLw0VghRZPbJxj/AL5NL2l+hHt27pL+vkQw6NHGwbVb6OzT/nmP3kv02jp+JFSRwG3l + +1WJaztxylzcHDt/ugd/pnHrUiLCMYFvYL05zNO30HY/981E9vcSXLrFE0W0fPNduN2PfPT6DJ+tK99/ + 6/r5kKTk9X/X9epNEqxxPNE3kA53Xlx80sh9EX19x+LCpCY4YJCzvZI4xtHzXNx9T/CD/ndTJGFtFHNa + RsJAPnvrk/eI7Rr/AF5P0pROYrffFD5Dvkve3J3Syf7g7fh+dTqTZt/1/X9bIhaKPbtnBto9wC2kQzI/ + +8T0/H8BSzXChRAkKlgSRaoflXH8UjdyB2/UdDQlkk8wbVeGJzu3ty7+/v3rUXT7WCz+06hJ9ltyN0Vs + vzS3JBH3v7o9z+AqnZblytGzf9f1/TIrKylvnkn+0KiIM3F4/Cxr6IPX6c+mKg1DVIzb/YLBWisFOWz9 + 6Zv7z/0HQVFqWrzaj5UZVIbSEYit4uFUf1PuazCevp2qoxb1kXCm5Pmn9wrHr0JI49qQcinbT0OAcZ57 + g1dj0y4+xJfSRlbVpPLVv+ejDkgfh3q20jZyUdxNP06a/WdlZEihjMkjucDA7D3PYV1Ok6XDrQ3MY9O0 + izjLl5OTIeCV3dyT27VDZWC6nAtxfzw2Gl2sW1GEfMpznaO7MT1NT3V1ca1dRLBBHZ6dbphbXJCqOpY/ + 3m6E/h61yVJuWi/4b/gnnVqsptxTtbr2/wA3+RPqN42r3UVwtuttpcMaolrEeT6cjqx9eoFagtQzFhKs + U5UG4GPkCLxtznhB0P8AePAzjNMtYANtx8wYoWg8w4CL0MrY/ID/AAArQsLJLpQzIUs0OQGHzTkd29h2 + HQfnXn1qygvI8uvXjThrokT6fbedIt5LnylJaFX6u3d29z29BitUcfOwAz+tIpwQX6AcCo3Zc5Y8Hoeu + K8SrUdSV2fNVqsq07sV3kO5ICPOzwS3Hfj+dVr67FqgghKxXbISS+MRL3LehP86klZdOjUvIvnFd0fmn + GAOrN9Pf6VzV3I7s4m2SKwEjOTjb/tP7nsvYepNdWGoc7u9jvweFVR8z2X4/8AZKQJVysht1j2oF5kQM + ecj++5/IGmajeQ2djJeO0SyQMCIWU7biQcCMc/cTOfc1LNJDaK0E14Ldmj8yOVj80YI5dxn/AFjdFXsD + +NcBqd/JfXPmMAsYAVYlPyqB6fzr2qFLnfkfR4eh7WXkipczyT3Ek0rFpJGLMc9SahJ46U4/KATg5H5U + iqWICjLE4Ar01oj2kklYt2FqlzMUklWOONTLI55GAOmPXPH41HfXj395JcPhScbVHRQOAB+FWLpxZ2ws + Vb5gd8xHd+ykH05/Os2ha6kx1fMFA60VLFE07xwxL87nGaZZYsxGGe7lVTHCBtTdgsx4HcH64qrJI0jM + 8jM0jtuZietWr6ZcR2kL5t4OhBOHfu2D0z0/CqXU+lCEtdQoopxUhQ2BhsgUFCVoza3fz2UFq90yxW8f + lxRqoAIJJOcdevfNZtKCV6HrQJpPcBnAxnApWdmcsxJJOSTSD2H1qSNcnO0sq8tt7CgZZZzawBEaRWdc + OkiAgg9wfTp7021DJmddjyE+WibmVgx6MMcfrVcASygb9q5wC3YVetyxBRZw0o/dw4IAA/iPPt/P2pMh + 6ILpRBC7qQdx8tW3ht5/ib8T3pbSOWztPte54pHB8psAgjofz/oarXNw8/lxsf3cC7EAAGPXpTGuZnjE + ZlcpkfKTxx0pWEk2hu5nYk9Tya67SLXxDoegjVrIWzW2qE2giYB5HJyBgfga5a1WJpoknk8qNnG9wu4q + vc4Fdmlho8usXLaN4gmtbHTYBcQSTHLPJ32A4/lnNZVpWVv0OfFzVlFrTrpden3mT4hu1isbDRU0s2E1 + mpNz5g+Z5D39cY6fWsvSorOS5f8AtCZo7dImb5eCzY4UHBxk1XvLufULyW7uZWmmkbc7t1Jq/eTG00mK + x3W7mZvOk+TEsTDjaT6Y5q4Q5Y2NIQ5IKC3f9MyWcuxYlmJOSWOTTQMkD1pScscdO1Ko5Gcc9Ks3NXQ9 + Zu9DuJrmz8ku8ZjJdc4B9PQ1mktJJk9Sa67Wb/w4vg/TrTTreGS/2jz5THtkQjlue+SfyrkVHz4zjPU+ + grGk1K87WZy4dqblU5LN6a9bCAndnAPsa6Dw1rN54ZvP7WtrLzUZTHmXcU/Q9etY9lZz31yttaxNNLIc + KidTV67S9sIEs7uO5hjUkrFJHjaaqbUvdZdVxn+7dnfdeRXecXuovNM6xLNIWdguQuTknHtXYXOr302m + S2r6rb6jp0EY8zzF2NnooGeeOK5TSzGk7GS3huAy4CSllGfXIqxeWqXWoxQWMCbpcYjhkMgz9TWNWMZN + J9DCtCM5JPZen/DnW6CLTSfCl/fX2kSZnB8maRA0bE5AHt9az7LR9Eh8Ow3OpvcrqF7LstljwFwTjPPG + Pxpdc1TXRp1loerxRwwxFSAV27wvQE1aXxRPcXralcaZbSafawGC3iOPLi7ZGeprkSn8S6vo/uPPUKtn + UT+J30fbZL1Oa17TrXTdYmsFl86C2I3TRqAx9Rwcd/0rHRLeSRwzmJTwh25x9anmUzM2z5yx3tsU4Gah + 2IItxwWz0Oa9GGkbNnsUk1BJu7HNZLucRXMMiqM7idufoDUUlpLHGrvGQrdDnrXc6D4Ctdb8Mtqj3hhm + BYhcBlwPWuKFrI919ngzIxfaoHc1nTxEZtpPbczpYqFSUoxfw7kSWzH73mJkZXKEg0wjbwTyK1roaxos + scN0s0LAHYJBkAd8VQDTh1mZCS53KzLwT/WtYyvqjaM+Zcys0bdvrS2HgqbT4bx/tF1N+8hCYAUe/vxU + fg7TYNT1ny54xIiqW279p+tNuvEZvUiS+sLGbyl2qyR7G/Navafc6Xp+jTajJp7rLISkYElclRSjTkkr + OR59ZThRklFqUn0tu/uOOHBrrtIc6p4butNWJpJo/wB4h64HeuRNbfhy9ntNWjEcojWb5HPbBroxEeaF + 1utTsxcOandbrX7jGKlWIPUHFAODmtfxJpjaZqzxlg6v8ysO+ax61hNTipI1pVFUgprqWbdvmwELMemD + V20ubix1CO5RQkqMGw1Z8EzQuHXqOlX7u3vTDHe3EZCS/db1qJpPR9RTSbtLZnp6aj4p8Y6SyW1va29s + 42s7HJb6Vx9lPqnh/WjY28qRXDtsJ7c1J4X17XIol0rStpklbILc4o8U6FrmmSR6jqsiu8nO+M/dryoU + +So6UrJPZHiUqPsqsqEuVRey6+Rf8T6Re6RqVpcX959p+04LSAYIrU1Oz8JJpbGCUzXbJwVy5BrIOnWd + /wCEv7UuNVllv16RyPkAemK1vBes6NaaQDePDbzxtlnKAs49Oayqcygmm7xdtNDCtzKmmm24uztoSeEN + Yt28P3WlXMckrKGwAOoNc3YX+p2l8kEF3NbRJIcJ3A+lWo/E1npHjO41CwRprSVcFTxk1S1wXmpXL6ot + jJDbychscVUKdpttWUtde5dOharJyjaM1fXv6CeNdIubW6j1ForgwzrkyzEHJ/CuPfG7gcdq6i/1fWtT + 0hbad2ks4fYcfjWbF4e1K80mbU4LffaQffcHp616OHk4U1Go0ephJOlSUarWmn+Rjmul8H6lDYayqXaR + eROpidnTfsz3A9a5knmpYXKMGU4KnIPvXRVgpxcWdVekqtNwfU0Nf01tM1ee18uVFB3RiVNrFT0OKz0k + ZBtDHB5I7V2msLZ634RttQhMsurQHbdbiXYj+8T2FcRjHuKzoT5o2e60McJV9pT5ZbrRneeErzw8NMuY + NRsXu9QfOzam87f9nPQ1d8G39832jwvJJHaxS72Y3CZdFI5AB7455rk/DPiBvDuqpepEJcKVZCeoNb/i + FdW1AReK7jTY7a3baq4blgOhPselcdak+dxez2fmediKD9rKD2ls2+vRJHI6zYLpmrXFmkqzLE5CyL/E + KoAM5AUZI6Y716H4s046z4ct/EqmxgRECi1hAHGccnufavOyNp712Yer7SGu60fqejgq/taeu60fqbui + yi/sZ9Elkhjim/fROyDd5qjhQ2RjI4/KsGSN4pGjkVkdThlYYIpUJVgQcEc5rZ1w6QIbN9PmnmuHjDXD + Snd8x65Pr1/Tmtdpepv8E/Uw6KO1FWahTgfWm0UCNybULCTQ7SC20z7PqMEhZruNz849x69Pypmozyap + IdTFsAVCi6kAJDP/AH24wN2OlLoWsQ6Rq8V6bKO4iC7JIJDkOCMHqODToNZuI59Rt9OCW1rqR8t7d8Oo + BOQMkcY9ay1T0Rz8soyaivO7ffdFTUplvGjuxJB5lzkyQwxlFiIOAPTkc/jSTwibT0ut8z3CN5cyGLCo + oA2ncPXkc+lWxA2k6pcaPqMghiZxFcMo3bcdGHHQZzx2qOGa5guJ/sqiVY0ZZlKZSWMHhip6n9RgHtVp + mid9jINHenE8YHTORSYqjUuwKt1atA8gV4VLRFm+9/sgepzn8Ko5wensc0+N2jkV0OHUgqcdKuXqpcwp + exZ3NxcAkZ392HPQ/QDNBOzM+rFrcG1mD7FkUgho3+631Hf1qAjHB60DtmgbVyzcwLbygxlmt5MmN2XG + 4f8A1jVfoat2ksbo1pP/AKuQjY/UoRnAHIAyTzUEsbW8skMgBdcrwcj6gjrQJPox1tO0EodXZSORj17V + 2ltrglb+0Y4ULbPLv7YjKuORv65z059frXC1csb6S0clGba42SqGx5inqDWVSmpGFeiqiud1ButpYFju + 4ykp8+0uWlxsY8EMBwoboQfrWzDMIdnzCA7yscaSH/RXP3lb5sBG6j6/WuMjvY7KLykl87TrghiQn+rf + 0BxjcOnvW9a3Ekl7tVt8m3bu3EC6j/hBP97A+UnPSvPrUmzyMRQbX9f16/5NnYW0ouUJaMoV4kRhkqfU + e3fNKPlHO1sjGfaudtb+ZLlNpKlRsSSTog6eWw7An/vk+1dHDPHMhAIMinEkfUoa8HEUHTd1sfM4vCui + 7rYbd20dzb+XKoAU5QhvuHsc1iz27tKySRxi5YY2tgR3Q5OPZu4PrW91AJ7+/WmXVvHdQmOVAUzkAdR9 + DSoYh03Z7EYbFSpOz2OQvLVLoCcYWQZj82QZ5PWKcfyf/Iow3MtoZrO7h8yCZgssU2BluwY/wt/dccHv + XSXcE0EqtLIFkI8tbllBWZf7kg/Lmsu7slncwCGUyKuDbkjei9wh6OvfB/CvapVlJeR9Hh8RGUddV/X9 + f5deV1fQzFGLuyke5sCcFymHgY/wyAdCPyNYLrtYgHI9fWu4jubrS5DcRSmeP/Vl2GUdf7kinoeMD/Jr + NvtHttSuGOmRi3uCcmzkf5W/65v3+h59M13UqzWktu/+Z6tDEOOk9V3/AM/69bHMAkdsip4LmS2uFmt5 + XiZDlWVsMv4065jUXCpEkyt0dJQAVbPT6fWq5GCQeCPTvXVozu0kjcN7Y6u2b3baXna6hXEbn1dR0PuP + yqW8jvbeONtSjNxAw+S+gIYsvu3Rvo3PuK54Ak8EfnVyx1W905j9lnKK3DRn5kb6qeDUODWxhKi18H3f + 5PoaSziaJQxXUoj8qqxKzJ7Dv/MU4gvbLb2tyLmPobO6XbJH/un0+h/Co/tejagB9rtX0+5/572vMf1K + Hp+Bqz9gv7j93bTW2twqNygHMgH6OPp0rN6b6f1/XYxbtvp6/wBW/IzivkSqsyy2zg58uaPzEx39/wAg + atDyWYC2klgZjybObep47IxDfmaqz3VxBIsJ+1W2xuYZjvC/gR/SnyTR3T5+yWchzgtDmMt+GR/Km7lt + Nq7/AK/r1YsriBJAZ4ZHH8FzZhHP446/jSaVa/a7xf8AiXrcoOTFHPsJ+hJNLdILOHAt7y2kPG2QhkI/ + IVFpzQGVjcWTXagZ2pIYyPfODmm/huv6/Ib/AIba/r7mvzO1VdVgsUtrPRfEFtEO0F4XXHsNuK5qazlb + UW8601n7RnJDHMn8q0INOinhEsXhzWhE3IMN1kf+i6ypra3i1Bon0vU1zysTyDzP/QOfyrmp9bf1+JxY + eybS3/r+8zTvHltdKdryHxAoPyiSaUKgPbPFZkOmx3FvFcXMsjQNyd9yinHtkk/pVq102HUFkEOnTIEI + BNxfpGAf+BAVWubmTSGW2t4dO3AZMkRWc/ixyM/StE+kdzaD+xD4vl/mzQu9J0Z7Nf7AttQvLgNmR5Vz + GoHuMVmtf+YnkyM4T7pht1WFT9SM5/Grn2q2vo1+0yarqc3aBP3cY+n3j+QFI/2qCNY47Ww0hN335GzL + +pLfkBSi2tH/AF+v4EwbjpLV+b/p/cil5UYkJuJE06FRkJGhMj/TufxIFRvatPH50Ea21oucTXD8uf6/ + QCo723jeeMWl4b6dv9Yyxt97tjPJ/KtYWuoRWK/aRZ6bHjLSzndO/HYHLD8AK0crWdzaU+VJ31f9bb/m + VI5BBH5ihIyR/wAfV0Nzn2ROcD3wfqKfZ21xcO93aJlR9++v8bR9AcjP/fR+lRm/0mwctaWr39wes959 + 0H1CZ5/En6VmX2pXWoSBrmdn2/dUcKo9ABwKaUnsv6/r/hhxjOeyt5v/AC/zt6Gw2tWmmzrPYoL2/wCT + Jd3KZAbrlFPp6nP0FYM88ks7TyyCWVzuZjzyfXNRE4GMdaMHjjr0zWkYKJvToxhr1E5POKeMBuBnnjIz + mpLe2kubhIIEMsjHhVrWgSKxmgNiTd6hlXVxH8kbf3Qp++c9zx9acpWKnNR0RLZaNFa2ceqaucLkNHYg + 4kmX14+6vPU9e1bclqGg/tbXGEMDj/RNOhXDzL2AH8K/7Xel0+JbG4R5ITqfiGeQ4gkG6OEn+Jz0Zvbo + O9bTWESG4luJF1LV3Qm5uZV3RQDHQD+8OMYrhqVddf6/ruePWrtS95/15dl57voc67T67cQNNNEkEKfL + GgxDaJ2yO5J7dSfWtiG2iAjm8k+QceRDJw9yR1kk9EHXH/1zVS2tU8lGaNjGrbkhY4DMf45T3J7KOceg + 69NaWBmLT3TFw4ydwwz46Ajso/u/n6Vy4jERgtTlxeKhSW9l/X9f1chtrP8AtBvPnJMJIYkjHnsOBx2U + dhWuCcAcBB1Hp9Kdk56KAP0pCwJOMDvXhVasqjufM18RKtK72AkHpgD3qGaVLZA0iB5T92MH9Sew96S4 + mFsoJUNIeQucgDHLHHYVh3dyXeQrKMABpnZciMeuP757L/CPfNa4fDubu9jowmEdV3ewl3KLqeQGdNvy + vJKynYuM4JHUDsq9T1NMfy40O+RVUL5qNMc7e5lm/wBo/wAK/wCSMI1hR2Cx2wTfGrnIhz/y1m7lvQe/ + p14/VtZZ5Wjhcohbc6yEsLgnP7w/0HbNe1Spc3urY+hoUOf3Y7Ii13Vjc/6MPntFfzEkcgysxHJbnn+g + rC++25gAuedvb8KGOWJPzAdD0yaFUvlipMa8sR2FerCCgrI96nTVONkXLaxWS0lv7lxDbR8RqVJ85/7g + P8z2pLcCxt/tj5E7/wDHsORt55f8OgH+FStJFdDz5kmg06HK28KNvAfGdvJ79Saz7q5kup3mlK+Y552r + gDHQADjFUtRq8tH/AF5f5kLMWOTyfWkooqjQUetXlP2G08wHFzcL8uMq0a56+hyOKjtkjybmRQYIiP3b + NjefTI/OoJZWlld3OWb1Oce1AnroMPoOn0pKKXBGQaCia2c280Vw0CSorZCSDKtjsauQ6abnTbvUXmt4 + FjI8uJuGmYnkKPaqcCxS3USyuIYWYB2VS20dzjvWlrUxXFnY3d5caLDIfsrTAhdxA3YGODntSe9kZybu + kjIYAHgcUbTnH86kt4Zbm4jghXfLIwVVHcmrsdtJetbaVZ2JlvDI2WTl5G/u/QYP50N2KbsWtA+wg3M9 + 3OIJ4V3WpkhDxO4/hfIPBGar6re2940bx6fDaTrkytASEkJxjC9F/Crd1cwWkUdjZLd2++IJqEVyVwZV + J6en86xWxJKfL3bc8Bjk1CV3cyhG752Jt7YyTzkCtLUdDuNLsLe5uHhzcDKxhvnUe4xxWl4S0ZNRvXvL + 2J30y0BecowBHHHHcVS8Qay+taq1xI8hgjHlwqxyQgPA/rUe0bqcsem5k6zlX9nDZb/ojGzjigY7npQT + SpjdznHt1rY6zsfDcknh2wudXvtBkmguI9lrO6goHIOAQe3+FZmp3ul/2BZWdvpuzUldnubhwdx9AM9u + f0qNdf1ueK0PnzT2+nOskSSLvjjI6ZHTHHes69v7jU76a9um3TTMWYgYH4e1YRpty5n+ZxwoN1HOW/k3 + 02Vv61JdOijkule4UfZ4vmlyDt9gSOmagvb17u6mmZmPmHA38kAdBmrM7/YrBYIp2DzjNwoPGOoB4zms + 7lj+FdFjsS1uJXUeD7aWHUhqcumS3tla8y+Vg7T6nOfSuaQFiAoBYnC+9dtLqV54Z8JPo02nNaz3pLGb + bjcnfvzXPiJO3It2ceMlJwVOGrlpv06s5/xBqkOsa5c30MK28Ln5I0UDAHTIHestcnODyf5UEgjHfPWl + iQs/AJ7YU81rFKMbI6IRVOCS2R0Hha0tLrUHabW/7LmiXdBKFPLdMZyMVf8AGGpaoJ10e91ePULePbIj + xBTkn1I5J/Gr2n36+H9HWx1/wkssL/MJmUoxz05IP6EVythBHdX+ya4+yQZJMmwuUHbgfhXKvem5vZej + PPivaVnWmtI7bP7mtfkdPob2djb+RqtisDwxtKjzbl8wkcL0PWq3hfSbTVNSuDc6qmmOjhoPLYA5JzwT + VnUNenGkPpE97HfGZjmSSIq4APQd8GrVtqXhyXQ4rTUNHls51UqJ4hyx/HnmuaTkk3bV/wBdTlk6ihKV + neTtprp3szP8Q219J4oXTTqR1SaTakUgI4z0zWn4ludY0fwva6Ff6VaxQMMfaIm3ZI/kareDNGs9U1Gc + XmoG0MOGh2SBHJ9QT6Vm+L3nfXZLE6pNqMUZxEXfcRnt70Rs5qn28iopTrQouz5NXpbXytoP8JeJ4vDL + XEkumC4juMKXPAAHbpWb4k1a01zWftFnaR2lvgLsUfmTW5b+NTp3h/8AsS40aMbUKo7jkE98Guf0G302 + 51qKPU50htSctnI4/CtYRtKVWUbP1vc6KcUpzrzg012d7/I6zXLHSNH8IRTaVqDmaUqGWOXIY45yK5bw + /pGr6jcmfSYS8sBDbumDUniW302DWXh0eR5LVQACX3An2rbi07xN4V8PtqUF5HHaTKC8ZPPNRH93TtfW + Xcyg/ZUElK8pv7X5HN+ItR1LVtT26id1zHiILHz0qxJqE9jpwjt7yVRHgfZ7lAWB77c9qyrNLee9Z7y5 + eIYLiRBk7qdqlw7+XbvJHOUO4T4+Yg9ie9dqiklFdD0I00uWmlovuKKq9zcBerSN2rQ1uQR+VZITthXk + e9O0dEjkku5WCrEvy8dTWVcTNcTvKxyzHNXvL0Nbc1RdkXtb09tL1i5tGUgI525HbtWerFSCDyK7bx5Z + xSyW+pW3nSK6ASyOOM9ua4k1nhqvtaSkzHBVvbUIye/X1OnutNfUfDy6mkjSPHw+T0rmB0rofDt8fs9z + YSMzLKvyxjoTWHPDJBcvG6lWB+6aKN4ylB/IMPzRlKEtunoRDIrXl1m5uNIh05kBjiOd3epLDw1qeof6 + mAnIyM1u6P4MWVm/tO7W0VTg7uKiriaMfiexnXxmGh8crtHO6Xf3Ol30d5bNtkQ8ZrZ1XxBrPiQqlwxk + UdEjTitFbbwzo2pyx3M32yHb8pXsaUeN7DTVRdM0xQ6ZG9znIrllU9pLmhTu+7OOpX9rNTpUm33ehhab + ol/qd0bOBGVx1VjirOu+HLzw75IughDjPynpVC68S6hcX7XiyeTIf7nFUrvULy9kL3dzJK3qzZreMK7k + nKyXY6owxMppyso9USNOmVKAAg8V3i+LbXUvBkllfXHlXI+VRGuOO2a82DbSrKeetNaRs1VXCxq2v0Hi + MFCvy3eqdzShv5oke3WZlgc/Mo70xNbvrSynsbe7kS2m+/GDwazSSTknmmmt1Sj1OpUY9UGc0qnBBpCM + de9JWpqdd4L1qbT9WNskkKW96PKlM4yig9/wrK8Q6V/Y+tz2iyLJGrZSRejg85FZaPtAxgYrt2ig8SeC + 4o7Gz/0/TQWlK9DH3JJ7+1ck/wB1U5+j0f8AmefV/wBnrKr0lo/0f6HEK2w+hz1rtdB1HV9f04+HI9St + 7a1Kli1xjJAOdoNcSR7HFSW84guY5lUHYwba3Q47H1rWrTU4+Z0YiiqsNN+nWzOy8N3Gm2eq3FnqlkNQ + yfLgEBLAtnHC9Dn19q5/xBotxpOqmG5t5bWJ8vCJOSE7dKmmnu7q7XW3ZLRZJcI8CbQrAcYA6dK6O8sZ + PFugte2Vlcy3dso8+7uLrcWIGSqp+vbvXOm6U1J7Pf1OPmdCqqjej0euz/I89J7UlOZcE4GAO1NruPVE + q3bXjWyuirkOMN05/TpVWlHPBOKBMCKb1r0XRo9O8S+FJNNMVtZ3Nqm8yBfmkYdCO5z0NcFc281tNJDM + hjdDhkYYNY06ym3F6NHNQxSqSlBqzj/VyNWwuMDg5z3rfh1TTH8JzaZc6apvRJugu4wAw/3j1Nc8KfGw + 3AE4FXOClua1Kana/TU3xdSazpdhocGjRz30TkJcQA+YynswHXHqfSovLnuomQmY6rYNtSExAgxLnOfU + g9jxj6VoXevadC+k6joVtJp2rWwxN5f+qbHt1OffscVSMWtaj9u8SKhkSGUNLONuAx7Y7j9KyTt5f5mE + b2vblXn3v+TKe62N7HfR2klxboA93CV2IrE8gFeint+VZbYJOBgZ4HpWxdXVvFKZdNkl8i5iH2mB0wFb + PIPG3GeV9OO9ZckLIFYglW5VsHB+hPWt0zpg9CIqwAbHBqxaXTWrscFopRslTJG4enH51oakNIewtG0u + C8E6J/pjSAFQe2MfjWRyDxQndBF861RYvbQ27h0V/s8uXhd1wWXOP6VUHNX7OaLY9pcIrRyfdctjy36A + 59PUVXurWS1naOTBOThl5Dj1B7j3oT6AnrZkI6Y9a0I3F/CsEr4uIwEgY4Axk5BP48dazxilBKkEdQeD + TaKauKysjFXUq4OCpGMUgOKvBUvYAQqpcRDrlma4Ynp9RVE5DEEYIPI9KFqJO5q6ZqgtIpLeaJriGRW/ + ds5Cox4DgeoFbFhff2eVi85JdPY4W4MJ2qT1ViR+YHTqPfkxxyOtX7LUTbjyZl8+2P3oGYgH3Hofesql + NMwq0VJOx6UW+2pHJFtN1jaHY8SZGfLk6Akj7rdD9RTLG+khZVVWh2YQszD92e0b+qk9G7ZrkNN1htPC + IsyPbMu0F1yACeUbqcfyPIroFuUmlt5PP3SDhZpOBjAyknqM4H0ORXmVcPa6ex41bCOKcZao7SC5junb + j50+/GxBIPtjqPenY3DO7BHTHeudS5nt32qJI2jwDtO426/n8yH9K2bS+S6l8oMolVQzAY2sCOq+orxK + +GcNVsfN4nByp+9Hb+v6/q5O6rKjK2CGHzBhw3ese/01o4AqLJLbrnainEkJ65Vu+PStz7+DSEjdkE+2 + exrOlWlTehhRxE6TvE5GdCCt3JcAF8r9tjj3JJ/syp/9btnms6+0xUGIUWCWQg/Z3bdDMPWN88H2Jz7n + pXZXWn7pDNbOIblh8zAZV/Zl6GsC5tZI38lUFsWIJtpvmgm/3G/gb6/nXr4fFKez/r+v6R72ExiqNcr/ + AK/r+onLXER2kXqPKyps8uVsSx8cYb+IDA4P4Y61TsNAu9VjmNq0EkkQz5TyBHI74B69/wAq6E2k1/eD + TvIYupx5Fzw6jrhX75H/AOqo9bsYrC4X7JJKxYYe2uUw6EDnnowPtz+NehGrb3U7M9mOJt7idm/u/r+r + s43YAdo6n17U0qQPmBB7cda6nQLeC11SVru7OnsVIiMtv5sTZ4KuD296dqtnYQXQhvbaO33gMl3psgli + cZPOwn+o+lb+3XNY6Xikp8iV/wCvx+Vzk+ccU+KTy5hIGaNhyGTrmtg+HJrjnTLiDUV67YW2yge8bYb8 + s1jyRNHIVdGRgcFWGMGtVKMtEbxqQnomakXiPUURkmlS7RuCt0gk/U8ig32k3LL9o0ow/wB57SYjd+DZ + xWTt4PPP0o2MMEg4pezj00J9jTW2npp+RsRLpMp2w6neWw7JNBvUfUqf6U7yYYJUWO/0u7Vj/HEy4+p2 + gj86xM+tHU0ez8xOi/5n+H+R1vlXQjEcK6QM9DDqDLj8DJVKLTbqS6fz47KcglcSXwAB9jv5HvWBQKhU + mtn/AF95nHDyjs/z/wAzoZNPa3kXfa6P8xwM3hcD64epQhhwP7R0S3HqkXmEfjsJ/WuZzRmh0m93/XzG + 6En8Uvw/zbOmudV8yOOG58RXc0KjBit4Sqj25IH6VSa+0WBs2+mzXBH8V3PkH/gKgfzrFJ9KXk46ChUU + tL/p+Vhxw0Vpd/l+VjWPiPUETy7R47OPGNtsgQ49yOT+dZckpd2Z2Z2bkljzmo8epoArSMIx2RrClCHw + qwmT0FPI6EBckdATx9at22l3d3FLLDbkxQjMjk7VH4ninfZIFgjc3HmyueYIlJI9t3TP0zTckDqxRUCb + 2ARCx9ACSa2I9JgtIRPql15bt9y0h+aZvr2QfXn2NaS6ff8AmqhhXR4ZEEbRIpM0g4/h+8c/gK14tMst + KgEcaeXdZ46SXUhyDwPuxdOpy1c1SulojirYtbR/D/P/ACuZMei32tSQww2UGm2UMfmB5D/CedzuTk5x + 7D0ApZ4rayUppEp/d8S6k+V3nH3Yx1xz9T7Cr0l09/GYXCxWsTZNurEIrf3pXHLt14HP06VLBYMcPI/k + Aj5ZXjG8rj/lnH0Ue/61i6ltZHP7ZrWb07f1v/W5Hp1rGLf77WaLjKRjdc3JHqf4R146fWtl5p7lF06K + 2WNIzkWsbcZx1lfv9B+OKtabpMiQ97WFhlgxzLJ35br+FattDFaRbIY1Axz7/wCNeZiMbFPTVni4vMIK + Xu6v+v6/yK1hp4tws0pWWTByTwAT/dH9auMRjH8WePal45PftSLuJHGDivKnUlN3keHUqSqy5pBknGQB + mqtzdC3bbEEeQDcxY/LGPVj/AE71FdXhUSpbOgRV/e3Dg7Vz0A9W9hWUZRc7495trePDNM/O1vV/7z+g + 7V1UMM5e9I7sNgnL3p7Ess4DSDIEgUM8kw4A7O/p/soOueahLJbQrvMcMJXzIjM3AJ58yUD+I4+VR19+ + 8N7qFvYKiXKERspeEMdzK553yjPLeg964q91OW7ctK7jDeYqZyGY/wATc+nH4169Gg5+h7+GwrntoifW + tUkuCrxOUhc5kjaXLSt13sAeM54/rWDJIZGxkEZyTjn6Z9Kc5eV97sTnh2Izj/GrEOnXV5Y3NzDHi2tg + DIzNgc/XqfavThGNNWPbpwhSirkVpbfa7kIXaOBeZZdhYRr3JAq7c3NrcmK1iDRaXak/P5f7yUk/eb3P + THQD9aCxGaJ5xGscEQUP8+C5z6VDPMZSByI04RSc7R1xWlrs0ceaV+39feLdXJuZfM8tI1ACqi5wAB7n + NQUE5OaM1RolYCfap7eB7gkYfyk+aVlXO1emaZDDJPJ5cS7nIJwKmuZIggggIaMHPmlNrNnGQeemaBN9 + Bt1OJGWOPIhjyI1Jzx6/jUBOepPSk5xkDjpRQNKwozkevtXQCKXw5a/6bpa/bLyImJ7pSfKQ8ZCEYz6H + tVDTI7WFGv7yKK6t0by2thceVKcjhhx0FW9KsV1G6SfWbq9t7GQGMXZiMo3AcLkmom7b7GVSS3ey/Esa + No2nSwSf2xc3Vk0oH2Wbyf3RHOWJ9PpWbq62v9ptbaTNc3FoCFjMnV2xgkKPU9O9dT4m8R6hZW03h+a5 + 06+h8pFS7hQFgnpxxnAx/WuMVBbAmaLczpmIrJjaeoYY61nScpe9IxwzqTvUns9l09dkyTzUs4QIi4uJ + FZJw6D5Bnjafcda2bKG30jS5Z7htQtdc3K1kNhjUqf4gx/H9PwreHrLTJbtptdubu2sWRissMZJkcdgc + H/Pp1rZv9R1TTpotWv3ttTS9tnitPtcgleJOxKjgH+pNFSV3yr/h/wCuoVql5ezX+V/L/PyM/XIzpEJ0 + 830V3c3YSe8fYHaN+u0SAndnOT+FZOnafJqN9DZwZDyMAWIOB7n2qBQ0h9ST2HU139tGngTw/wDbZcf2 + teptjQ4IVD6/Soq1HTiktZPYzr1nQgox1nLb1/yRS8UXkOkadD4b06XlBm7dGyHb0B64PXFcQ7AgAAj1 + 5zUk0rTFpXlLTO5LAgkn3zUNaUaXs426m2Foexhbd7t92FPGBHnjcT19BTVG7I56Z4FdBokNiiy3mt6f + fy2Ui7I7iA48tvXng1pOXKrm1WooRvudFdXk/gjwgljZXcV02sAu86D5Y127SgB69TzXK6FYWd5PM+oX + MkFpbxM7PGgJZscKMnGTVeGF7i8ka1US+Ud8aTYLOM4A29zyMip7/UUfS7XTYIDB5JYzHcV81zjhl6cd + jWcIOK82c9Ok4KyfvPd/19xmXE7XEzSu7OTwNxycdh+VRY9KCDuIp6qScDBJ4HvWp17HS+DNFnv9TW7d + mtrS2Bka5eHfGrDkBs8VW8Ta9ca9qklzPMGC/u02LgbB6DtnrWpqE9toXhq20/TbucXl4ga9VZPk/wB0 + r2Pb8KydBtNHur111m+ltrdIyyGNMln7D2rkg+aTqvboedTfPN4iS0Wi01t1+8xiQAOKv6PBa3Wox217 + eLZwSHmfy9xWqb7BIxjyY8nbu64rt9NU+H9FI13woLm0uMSLc55AI457fpWtWfLHTdm+Jq8kLLd+l/lc + q+Kb6+sT/ZKeIW1OwZFYMGDfQE8/zpPDemz36i0sZpIdTkbOZcKhjA/M/lWFbm1a+jFyZI7My5cRjcwT + PbPtXYXT6TFZXOqaXqk9vLDiO1t5FBdl/wA5+lc1T3IKC3fkcdX9zSVKK1fW2l/OxBfTazq3iGK3uII7 + y509seTAuAwB5zirvirxKuq2S2LaWLS7Vvn3ryB2x3qbw/p/iTTdM/tzT4oH+0DLxycsVGcmq+iyXnib + xfFqV1FHtiO5kY4UY+tcjcb82lo/mcTcFPnaTVNdH19PU1I9P8L23g5JLox/bPKOZFyrl/TmuN8P2d5P + e/bLGOB5rZt4SVxlvw7113j/AFFtSubfRrWG2ds7i0TZOewzWWdM0zSNMQa7pV/aXWSEuIHyDxxn0ooy + ag29XL5iws5RpOUm25vbfT0ujO8X+JLzXpYLS8soreW3J3KnVj61oaTqfh2Dw55eoaK3nYIWRkyHb2Pa + sDTLYSX/AJqXKeZuwjXH8RPqTW74z1LUY7W00a5jsfLQBgbfkn/CtZRi+WjFaetjqq04ScMNFWW+jaML + QrHTtQ1byL+8FpbHJBA59hVzxcP7NSHSrTWWvbP75XOQprc0L+ztL0Y/274elAU7vtO3OQRxXGJBBqWt + CKKZLW3mkOGkPCCrhLnquT2j80VTm6tdyd+WPo0T2drcaZa+be6KJreT5hI2QQPasOeQTXDskYVWPyqO + 1dP4hOq6VbpYyasl3aOPk2tnAFYmkwLJcmR8iOMZz7110pXi5s7cPPmi6r69r/qPvytrpsNqB8x+Ymsc + DNW7+58+5kbqM4X2qrjC9eTW0FZHTTTUdT1XTLu68X+FpNJihjUxR4MkhznHTFeXzwva3EkEgw6MVNb3 + hrUb2O8W1tLnyPPIUt6VJ4w8NzaFeo7SmVJRu3nua4aCVCs6fR6o8zCxjhcRKldJS1SOfsrmS0vI5o2K + sp6itjxKYZLyO5huBK8igvjsawKM967XC8lI9KVNOambcPifVLe3WCC4Mar3HWqM+oXV0xaaeRyeuTVS + nqTtxwKlUacXdIiOHpRd4xVxzbgOR+dNzx0rUOg6lHpaak8DC1c4ElSWtnb6brNuusRM1q3LFfSj2kba + ah7aFnyu/wDwDJbBAw2T3pMqCOc1r+JX0ibVS2ixutqF53DvWMEb0qoPmjfYunLnim1Y2YtHkgksp9RV + 4rC4b/XIu7Aqx4m0Z/D+ohINxtJ1DwSSAZdfX2rOGrXz6cLBrpjbLyqHoK2rcRa54ZktYrGaXUrX5zcm + XIEfpg1zy54yUpPQ45+1pyU5vTZ/ozlcU2nEc88UnTtXUd6NKw0yfUrGdba0kllhO9pFYYVcdxWYevSt + C1kn024huJFbypOSgfHmL3BxVnXdP8oxahBFHHaXYLRIr5KY7Gs1K0rPqYqo4z5Xs9jGAre8Na2dH1SO + Rw5tHO24iRsb09D61gjg809XAG0YweaqcFNOLKq041YOEtmdH4t0VrC9jvoIhHp9/mS2wfuj0PpXNEfn + XceG7i31zSLnw9fyIsu3dZyyE/I3cZz+lcfeW0lpcSW0yFZYmIOQRn8KxoTetOW6/I5sJUabo1Pij+K6 + P/M0tAuLQyz2l7BDIlxGY0kmkKrA39/Pt9KvaNe2ej6y0d3HHeWgJUusjBDno+B1x/WuX6VZSUSKsarE + hXkuTgt7Vc6alfzNalBTvfZnReMNCGmzx3lvBNDbTKGHnMBuJ/ur12/WuSIxxXofhrVbTVtJl0S9kjs4 + ghZ5Fj3yzjP3ctnBHbHpXGapZNp19JGVYxk/u2dSpZexANZ4eo03TnujDB1ZJuhU3j+KM+ijoaM11HoG + lo+qT6RfQ3ltsE8TZG4ZBHfIrsPEenReJ9Pj13TN094Rm4hQZ2KBzn39vSvPhnnHaur8J+JX0i68ks0d + hOQtwF5P+8PQ1yYim0/aw3X4nnYyjJNV6XxR/FdjlCMHFFdj4y8Nx2bDVdMUtpkuMOcAbj/d7kVx1bUq + sakeZHVh68a9NTibOgarBpWr299Lax3McbYaGUAgg9xnjNXl8RfY9U1GfRrf7NZXSMklrLiRMH26fT0r + mlbbx0zwa29G8Rz6JbXlslta3CXKGNlnj3BfcVNSH2krsirRV3NRu9rXLo0nVPD1jZ319G/9j6nhZTAy + vuTrj0DdxU0F/bpbTaLJKf8AhHrm4Jtr65tiXh29dmD34B+tM0tDZCxi8QwXraDOS0YDlURjxvA9qqNf + pBJLoYvRd6UJv3DszKkTE43jjPTqOlSnzab/ANfmZazbT181t/w6KFleT2ay25uriPTrp1W5WL5fNQHq + AaXVNONky3UMEo0663G0lnwSVB744z7V1N3pFxMR4dvXWTUIcNY3AkRYGiIyWZj8xOMYH+TzNs0cF7Hp + 2sSXi6dE7F4YicxseNwU8VpGd9jWnVU9Y/8ADruZBJb+taEFxFd232S8k2bF/cS7BwfRjjJHoKqSBNzL + GxZNx2sRgt6cVD0OK0audDV0S3VpPZztDcRvG4/hdSCR61DWgbsXVkLW4MKNCGZJvLy8h7KWz0rP6HFN + DV+oqsQwKkgg5yPWrZCXSFgVSdAFCKpJlOev1qnSqzBgVJDDkEHBoBoOQSCCD6GlwcZ/WrSrHeLK0syx + XCjcMoT5p/DofwqvLFJBK0UsbI46qwwRQJPodD4b1TS4ftFpq1mj29yArToP3kfoV7da1bmxu/DzpOri + 70qcZimHKOvZX7BvT0riAegGBjoa39E8SXOjiW3Kx3NrKMTW8vKN7j0OO4rmq03vH7jir0JpudPW+6fX + 07M6ay1FJI4h5rJglUkzzAPRj6cH5W/A9qvPLNYy7beNT83myojbQ2ed6H+Ht7e4rEayjuUk1Lw7M8kU + cYM1s3MsXsR/EvvSaRrKwyoZkZogxPkhsOM8ZjPcf/qIPWuKdJO7X3HnzoqScofNM7LTdSE8LtNcEFMK + XddoB44f0Oe/StQN8gyAc/iD9D3rlp1S5P2u1ugpXj7Qudg5ztdf4Dn1BU+1WbHVJLeZLeaNYmwNsTHC + MP7yNn5R6dQfUV5NfCX96B4WJwKl71P7v6/rvY6Lg/MMA+h6GmywpMnlypGykDgjr9abDcRTg+W53IPm + R+GXPr/jT+QfmH4Vwe9BnkNShLXRozG0loHBtmWWNCf3MwLbO/yt1X86z7lmkY29y/7tmz9nvhkE/wCz + KO/vxXSDBbksD25pHjEqbZEjdD1BANdVPFSXxanbSx8ov39fz/r8fM42ezmiKRQtsjZsiyv13RsP9iQf + 4isu60qG3kRmhuNMuFO5TgyxHB7MOf513DaWqh0tJ2tlJO6J/njY/wC6eKzrm1vILGaLyZIom6tbtuj/ + ABRvYe1ehSxaez/r+vU9ahmEW7Rf6f8AAf4s5W5tJ7n/AJc7a/cnd9otG2yDgc4X+q1SZN+IJb07gwJh + voj1A6bxk+3augnsLeWSM28dnJMGyzQubeU/gflz9M1JKt9AoWee6MWP9Vf2guI8f74yfyFdka2n9f8A + B/Q9GOJtp/X3a/kjmZINOyv2rTZoCf8AltYzCRP++Tn/ANCFQHSrC5uoorHVkzISD9riMPl/U5IrWms4 + Z7pZIrWyback2NyYifcCTkflUGrWN9cTxslrqEihME3KiVh9GUcit4z13t/XzOmFW7S5rfP9Hd/kVm8I + 6yN/kRQ3Kr1NtOr/AMjVJ/D2qxTJHPp13Hvzg+Sxz9PWojHJFKRl0dT0xg/zq1dzakIoFuZ77y1yYvMy + AP8Ad5rROot2v6+Z0J1k9ZJ/J/5mdLZSwybHjkUngboyM0xrdlPIbH+7XU2cd/fabbzCfWJJIXJjZIzJ + GpHQqc8Go9Tlv7uIQzT6tcEn5kmiwP5mkq7vYlYl83K7ef8AVjmxbMVB2sc9MCiW1lgVTLFIm77u5SM1 + 0No18tusUUurCNOixuQo57cUy6tLy7RZLmO/uDjEZmlZiP8Ax3pVe211L+sWlZ2sZun6JealFJLbpF5c + Zw7yTKgH/fRFWrXQ7WeaOKbW7GF2fZt+dse+QMY/GnRWl7o0pMkMULSpjF1HnI9gRRHpryR7llcgjOLe + Bmz+gqXNvaWhEqspNtTsulv6ZWvbSzsNQeOEyXsCHHmYKK59u+KsxLl7aVZrPT4wSymBTJIp9e5z6cir + WlWkaTKZtMNxJk/8fM3lof5fzrZiuLpHCQ3GmaeOmyxtxLNj2bn/ANCFROrbT+v1/IxqYjl93fzv+iv+ + RytyFna4laS4u33cXEhwT9Rzz+NdDoV3La6X9lmS6nBOVtrcLGG9C0gBZvp+tVB4fmFwJZoiELbvMu28 + sSDPdc5/Imt9LVLoJAhluIzx5FonkwZ9yRkn8PxrOtVg42/r+vuM8TXpuCjuv6/roVka51FGaUmKAf8A + LpZ4Q/8AA35Pr96pVtk+xlJDHBEM4jhOPM/3n+830XP4VtWulyJAscojgjJyY1XJBHoDxn3OTV+1srez + k3Qw5k7zSfMx/OvNq4yEdjxa2Y04aR19P6/zMew0mZxG8UaQRKC2+WPp/up2+rZJrYtLK3syTGpeZyS0 + j8k/jUxweTlnz0xTy2Eyd2fTFedVxM6noeTXxdWto9gHUl87s8UZ3dcD2zSDcy7sYA6k8VTnvVUAwBWU + nHnPwmfRccsfYVlCnKbsjCFKVR2iWZJI4U3ysEA6c9az7u9/d/vz5EZXKpvAeTrnJ/hFU7m+EV2ixRtc + 37EgIAGMZ+nRfpz05quxWFmvJpY5pFOX3EtFGfc9ZGA7DgZr0KOE5dWeth8Eo+9L+vT/ADfyHyh7qNJr + x2t7XbtiWMYZ/wDZRew4+91P6Vnavrcdt/o6pB5sChoEibMcXqSO7nvWZqviIzSvHZyMwdQZHf8A1gIJ + Hynoo57Vy0827DBg/HIxgA+3rXrUcM3rI97DYJys57dixdXkk7B3dmydxdwfkJ64554xVaT5M54b0Gct + nv7UzztoBjGZM5Dnt9K1YLfSrbSluJZje6jOrCO0jBxH23MfXuAK79I6JHq6U0tCCz03fbpe6i8ttpxy + FlWPcXYD7qjI/PpToLEtYm5vZzbWIzJbwy7j55HZQP50y2u7OO2klv1e6uVHlxQsSFQH+IH2Pbp9ayiS + cA9B0BPSmk2CUpN62/rp/n9xJcXD3Mm4gBVGEQdEX0+lQUpPPFNrQ3StoLUkUMsz7IY3kbBJCrnAHWli + hklkESYPPLY4XPGSfTmp5po7eM21sVJVjvuFyC49Oe3X60Cb6IWeWO3ja1tnDqeJZh0kGcjAIyMfrVLr + R/kUUIaVgx9MVq2emxy6TdX819DAYNvkxEbmmbPIx2x15pmnafHcN5l9JLa2pG1bjyiyK/bd6D6ZPtU1 + zc3Gq3UbzNGFiVYnkt4R90fxHGATj86mT6IzlK+iY13fVtRS9u4yluWRJ5LW3ACjpnAwN1dLdav/AMIx + Z/ZNG1mHUtMuQ6taXUeWhb3U9OvUdSOlE+pSeGIrePw/rcWoadOxZreZBlXxzuQ9B7iuSvryXULue7up + xJcSNuJ2/f7fhWNnUeuxyqDxEk5L3F0/zTV016ldt5+ZwD7gdaIyhuFecOYy3z7TyRnnGe9W9Pt1kL3k + /lPBblXkieTYzjOML3P4Usm7VbqR44vs9qmSiZJWJfTPetm0jrc0tDprHxTZvbm3u9p02wQmy065hEol + Y/3nAGDyTmuUnkW4uZZxFHAjsWWJM7VGegzzioXcsAuAAvTjFWtNuLa3vYZ7uFpoEYZRWwazUFC7RjGl + GleUV8v67nXeGNIttKsm8Q61G6wIM2qgj5m7H3rldZ1efWdSku5/4j8qdlX0FXvE/iWXXbzKfurNOIok + G0Y9SOma59j2BOPes6NKXN7Spu/wMcLQm5uvW+J9Oy7f5iZOc0ZJo6VJBC80yRooZ3IVRnGSa6TvbsWb + K1aa4CrveJSGleFCzKvc4roNau43aDQvD2o6heabMF/cuMASFjwBjPofrUry6j4GgW3iKQajOGW5HmLI + Cnbj+E1Pp2nL4a00atrekmQXIBtJEuSksb4yG2g9OhzXLKfM+b7vM86dVSaqbr7K01ff5dLMwNYsI9Ki + gsp7K7ttViYmZpZAUIP3SBjjj3rHLEg5wSe/erd3eXN5LJcXsslxPIfmeZyzH3yfwqnxXRG9tTtppqPv + bgOK1fD9/b6XrNvfXVp9qihO7y92Oex/A1lU4A45OB1pySasypwU4uL2Zp3V1ca3rEtwY9091IdsajAG + TwBW34v07RtFt7PTbWOQ6qkam7l3HZyM4x9an8LxR6Hps/iS8VlkT5LJWUFZHIP+c/WuTu764vLqa4nl + Z5ZWJdj3z2+lc0bzqWj8Mfz/AOAcEL1K1oaQhp6vt6L8yFWXPJ298itmfxFrOoWK6fNfTT2qkNtY56dO + euKw1Yq24duOlaWl2y3d3HA92lq0px5jcKB71tUUbXa2OurGFuaS2NTTC2nb2u9HjuIpFyTIGBC+gPQZ + xWheXljrWu2CQoun6eAEw5yUXvzVjUZte0CxOnT3lvc2U5+W4UhyQOMZ607QrrRbO1li1rS5mMpys5T7 + o9RXnzlde0Sv2szyZT5k66V3suV/jZ9TT1/TF0K0hOg65M8FwxQw+aHGPwrd0C2ufC3h2WW7tlPBkk+Y + ZI7VyvhrR7LWfEM7rPLDZxPvgyMkkdOa6Txh9uuYbXSLS4jnlnJDlRhj9a4aru1Tv6nlYp80o4a/W8m9 + H8/RHB6fd6Te67cXOtPcRxyMWj8g42mrfieaZ4IEg1aS9084KI5yy+xNJdabd+H7Upq+iJLEWx5wJBA9 + jWIj2zJMy+ahJ/djGQK9CMYtqUdl8z2qcISkqkXdLRbNfLqj0rRJ7az8KLcXvh/dAnV1CtkevNcBaxab + qniR/OkltLGRiVMa7ip7VK/ibVotDbSvtStA/HTkD0rb8JeJND07Tjaalp6O+SxfaGz6e9YxpzpKUrav + scsaNXDxnUSbcn0fTvqJ4o1y403TBoSail9BIOZnX5wPTNYfhiPww7XEevSSBm4j2g4X34rOvJv7Q1gy + 2sanfJlI26DnpWprzBdL8y90q3ivJGx5kT/dx221vCnywUOr3tozqp0VTpqkrpy3asmc5qYtf7QmSxd2 + tgxEW45OKt3Ciw0xY8gyOMtz0qlZfZxPuuGwqjIwOppLy4WYEjJZjyfQV3JbI9NR2j2KY5Oeoo5Y8DJ7 + CjpxXQ+D49KOsq+sZFsq/wB0kZ/CnVn7ODla9grVfZQc7XsYkMrQyLJGdrKcg12d/px1PwqNVu9RaW4Q + cIzcAfSuY1jTl0nVJrNZRKIzgMO9XfDV9bw6lEt989t3VuRXNXXNFVYdNTlxKc4KtT6a7atdjAIOeeKA + MVt+JvscmqSPYKfI7fLisULnpXTTnzxUjqpVOeClaxaja2jj3bSzkdKjADZOCKYgA+8M16XoOg+Hrvwz + JPJOoudpyHOMGufE4iNBJtXuc2KxccMlKSbucj/buqy6D/ZAcm0XkjbUN9pWp2lvbz3sMiwygeW7dMVs + +HdUttFvbhLm1FzDJlQAOtdDLF4j8W6YLBLeJLSHLRl1w23sK5pV/Zz0SUe5yTxLo1LKKUe/e5zkng+Z + NLS8Ew2SLlWPAzTPseizeHDHbrcS6tnJVUJA/GtTw9aRXN7NpOtXUkaxcBGbCitLw1qOm+G/ElzYSGO4 + tpSAko/hPpWTrzV1e7WvyMJ4mouZXcmtVbRWPNdphfa0eWB5Dfyq3plxJZ38bi7e2jk+WWRBu+U9eK6f + 4geHn07UPt8UIW2uDuBU9DXE5wfmyQe1ehSqKvTUl1PUw9aOKoqS6nV6Q3hK3v7uXUBc3ESnMIx9+ue1 + K32XjyLaTW1vKS0Kyrg7e1Ns7j7HeRXCoH2NuCt0NddNBrnj9ZL4m3gs7NPlU4ULx0rN3pT5m9H3f5Iy + lfD1OeT917tv8kcMFyeSfxrpfDf2LUIJ9GukUTXH/HvcO3CN6Y96wVdkzGFDLuxjrmpJra6smjaaKSFm + G5MgrkeoreoudWvqdNaKqR5b2fQhvrKawvJLa4QrLGcEVXFdrDoeiX3g6fVJNUYapH95JX6nsAOprixk + Z5Ap0qnOmuqChXVRNdVo9C1a3U1tNHcwN5ckbAqy9jXW61YR+ItCHiC18172P/j/AN7ADOOqiuIBwDXQ + +F9bm0e7LqiSwSYSdJPmGD3we4rOvCXxw3X9WMcXSnZVafxL8V2OdPFOjcxyK4AJU5wRkV0/i7QYrK6F + 9ppaawuPn80J8qE9sjiuVOR9a1p1FUjzI3oVo16anHqaAv5BfC9iKxzF/MPlrgIc9q7q7VPHOi/aYnkk + 1OFQFtYY2YLzzuJ4AOM9q82VyhyDg1teH9ZbR75ZiJJLd+JoEmaMSDHAJHvzWVei2lKG6OfF4dySqU/i + jt/kY80bRSMjAgqcEelIXLABiSFHHtXd+J9Eh1O1Gq6RtnyoaaG2tiqIoH3s+3Q1wZG0+1XRqqpG5ths + RGvC/Xquwm4kYpyOy5APWmUorY6LHeeEPEFv5baNqypNbSjbA0vzLET7Vh+KPDc/h6/EblTFJ80ZVskD + 0Poaw0IBGTxXoPhzW7LXdOOg65IFjAzDLxuY9sse/pXDUjKhP2sNnuv1PKrU5YSo69NXi/iX6o876U4N + g9K09Z0S50W+MF1GQjZMb44YeorK6nHSuuMlNcy2PSp1I1IqUXdM2bO+m1J7PTdQ1SSHTkbHzZZYx7Cu + iivrDw6NQ8O6lDBf2M2WjuY1HmREj5Wz1464rhQcVr6DeaVbXM76tYveB4isahyMMehrKpT08uyOevQV + r9Oy79xUvbqCyfTBHHsuJVkhuJkMbrjoVY9Aas32m3t1YXWp3tzdT38coSTKiRdmMZLqxOfqMe9RxDV/ + F93FZm586S2gIgjlYA7F/hHqcfyrN23GmXskFxHLE6nZPDuKFlzkqatL7y4pX0snuzU1LXLPUNBtNNg0 + O0tpYAN1yjfMx7n8eM5J6cYrnc1sapplqlomo6fcxvaSkAQvJ+9jbupHfHrWNWkbW0Naajb3QpaCPekq + jQKKKKQC5q0sqyhYLkqnzbvO27mAx0PqKqUUCaJHjeM/MCMjIPt2oWRkII6g5HtSBm2kbjtzyM02gC/Z + X1xYXKTW1w0M4O5XRsYrpf7S03xEQupCLT9RX5Rcov7mU/7aj7pP94VxlSCQ9+aynSUtepz1cPGb5lo+ + 50dvrt5Z3LCOYeYjkGRTyw9M9GHHeugttRsb4KimO3O7a0cuRCW9f70R56rxXn6sQjKrZHXBFO84+bvy + c7s5b1rKeHjL1MauDhPVaM9OEc+nTxRIOG5SKd+QD/zzlHBHHTg+1acGsLkRSiRpR8pSQBZfxB4Pf07V + w9v4qlQhREgjmAV4id8JweMA5xj+fpWtb3lvd3Ji3EEciKVS6jHf++nHOVJFeXWwl/jR4mIwDf8AEX9f + 1/wWdrFNHMQImDEDlG4ZR7g81Ln5j/Ce4NcnG86FZkKtEGKq0z7kB4+7MOh+uK0ItWmhuPIlU7z0S5+U + kezjg/UgV5tTBtfCeLWy+S+B3/r+v8zc78gMtNBCNwTntnmq8d/bPJ5TM0MmMhJDgfgehqxzgEHn0Irl + cZQepwypyhpJEM9pa3A/fWyOTzuAA/pVQ6RCgZLe5uLUHn5ZDj9K0uepAowM5xx6Vca047MuGJqw0TMK + XQruQbnntrkKeBNArlvxIH86zr7Rb2Qq62NvC69TDvIPtgHj8DXWce4NJkgcN83vXRDG1InZTzOtDt/X + oef2+lzR6huvGZIucqJnjz+JRq1Dpunywu32azYoOFN2Sx/LA/SutMrAHK547c1Ewt5BloFZsnO6McVq + 8e5atG8s1nUd2rejOVtraWCXbb2txDEOdkF+VFSMt4krgw6qxJySNQB/pzXRNY2ROXtY/UYQUxNO09nI + FrFlTzxTWNj1X9feNZlF6tf195zmnyalZTOyx36ozE7ftajn346+9SSXOou7LslAPIEl8Bj8q6BtNsM4 + 8iMY9qeLOzHzLBECO22h4yD1t/X3ilmFOT5uT+vvORu4JtYmQX8tmnlcBnlLk/lmr/8AZ3nhYhqdyyAY + CwJIR+rD+VdGiQRHKwoOOCFFPJUgHnPoBUvHPaKJlmbslGNkjlLbw8Ek3NZRuc8Pcuf5L/WtWLTJUO0X + aQIeCtpEsfH1HJrU2oxG9Cw9TS/Lg7VVfQKKznjKkjGpmNae/wDX33KUGk2cE2/yBI/d5DuY/mMVeI6K + Sq47IKBlu2M9M0ySPdwzsp9uDXNKcpv3mcsqk6j99/qGEHGMHOcnrTwP7x6dcmoWkhtdqyyiNiMDcPmP + 4dTVaXUI1lEMUQEvT98csfpGo3H8cU40Zz2RUaE5/CjQDGQFYslvXtVaW9ituZJk9GkJyg/qfoKxrnVG + knCPLukz8sWzc34RKcZ/3m9eKryPI0oaSdIJQNqoP39zj0Cj5Y/0PvXXTwX8x20su6zZevNQLKrtKYFY + ZVphlmH+zGPfuxxzVe6mnZN8kxtGIwoYb7mUegAx5Y9uB7msxtWt7FJMSi0f+KRv31y5+vRPTsfc1iTa + jfzwSiwtJoYMlpJ2BZ245LPx29MfjXo0sN2Vl/X9f5Hr0MFtZWX9f11+RsXmtWlnbNaND5Y2n5Inycjp + 5rY+b/dGK5a91O51N0R2AAOIx0/D0ArNMm8jqSTxSNO/Kr8gPBx1NelTw8Y69T2qOEjT1W5LJMq5Vs5G + cRLwFPTk96gVWm+ZjhN3zNjhc+1IsZOSBwMZzXTWl9oWgLHdWq/2rqBUELPFthiPf5T949v1rWT5dlc2 + nL2atFXb/r5GTDpzXkcj2X+pgyJbiVggbuML24HvUVpqc2ll2sX2TSKA0hUbk9Qp7Z45qtd3BubmSZlR + BI5bYnAGfbtUBORjtVJX3LUXJe8KzFiSSSSckmm0ZpDVGodeKsW9q8rMBIsaDO6Z8hBx0zjrxUi28UaL + LdMAM/6hSQ5HrnGPzqKe4edQMLHGvARBgH6j196Cb32Hy3KrH5FsCsZxlzwzccgkdRmqvbFJShSxwoJO + M8Ciw0rAO1WZLdYIYJXlhkMqk+WjfMnpu44qYFNNCukjG/DZ+XGIsfmGyPyqnku5Zzkk5JPc0BqzR/tW + 5khf7QJHiaEW/wAh2q2OV3f3iOo+lauka1JZ2EttphLvPETeRXqo0RwOGU8HPt/OsGSXe8n2VHhtyF8x + c7gDTLl7dmC28JRAcgs2SeO/4/zqHFNWMp04yXK0DSx7JFMILsRtfcRsHcY75pbdFaTzJVLQoR5gVgDj + 2qBcYJJ5z09a1odD1K/0i41aCyDWUDhHaM52nGemc49TTbS3LlJRWrsaOlaVP4nmO6Q2ujWClmeZgfLT + PTOBljTfEWvW08K6RpEIg0uFvkO0B5T/AHmPX8Kq6l4kub7TLbT44YbS0gGPLgyA7erc8n61h7jWMabl + Lmn02X6+py06EpT56nTZdvN93+QufzpKBRXQdgucUhooVS2fbrQAqg57cetdtYWEXhfThqWs6ZDdR3kR + WEeZ93PTBGRn1zyKpaFpsFtH/at8lsyxKXWzvVaPz19Ubox9jWRquoJf30skEP2a1ZsxW4YlYxXNP96+ + RbdTiqN15ezj8K3/AMlrcuaalj9tFzr6XQtZIyV2kh39MZHI/Gs68vJbsqJJ5nhi+WFJJCxROwFMnvLq + 6ghjmuZJIrf5YUdyQoPZR6VAxAGNuGzyfWtVHW7OiNPXme/5CMSzEnqTSUUhqzUUHnmtTRNEvddupLay + WJnRC58xwoOO2TWYiM7BVUlj0AFdNqElx4cs5NGtbxZ1vIle5Xy1yrdQAQT29DWdST+GO7MK85K0IfE/ + 6ZR1fXb7UoLa2uJEMNovlxRooUD8uvSsftgUMcnGKVRnpjPTFVGKirI0p04042irIlhR9pddwC9SO2a6 + zRJtIhs2ttZ0m4WdjlLoHG0Hvj261neG9Cvdcv3j07YkkCCQrNIMMw7Yrrda8U3MdvJZapo0DXUKmIyK + PljY/n2965MRUbfJHX52aPOxlWU5KlBXfWzs0YiaPBqHiMaZotybmBhmOaf5RnGTXQ+ItY1Kz09fD+o2 + FpJMUUJOpzhfp68VR0Kz0fTtLN1rkN1BcSAtaybSoI7FSO/1rM0uC31jWSNV1OSJGBCyyNkn05NcsrSl + d7R/M5J8tSfNLWMOttW+6a38zuLGXVPCvh9bibTbea1AyxjPzqD61ylreWuq63cahf3NzYocyQSxD5VY + epp+oyanc3Z8M6fftfw9QQ36E1cPiS50HQ/7F1PRVB2FEcjgn196wjTa1SvJ/fb5nNTouKckk5y7Ozs+ + tmYGu65qOpTGybUTfW8bfu2C/eH866fw74o8PaXoxtb6xK3CqciRMhzWD4O8P2er3VxNfXLwRxg7BCwz + u+nWq3iu9s7i9S3sJGmSEbWkdNrE10ShCclRS2OupSpVprDJPTVtaf8AAMq4eXWNTkNtbcyMSsUY6VPq + 13ZGxhtI9LNrew8SyEn5q3LDw74k0SGDX7BInATfg84H0rlNS1G41a+lvLr/AF0h+YKOK6abjUl7r0Xm + dlJwqzSg7xj2fXzKSO4cMrFSOhHGKSWaSZt0rsx9zSoAWwOlNOQSrL0Nddlc79L3GsV2BQvPc1GacTzT + e9UUhyIzkKo3EnAHrXomha9o2jaC1tqGmMtwAfvpkOa5rwrBAmqR3t7DK1rEclkXIBrX8ceJ9N1mKOCw + hACnlyuDXn4n99UVGza6s8jG3xFWOH5W47tp7HPaN4fvtflcwkZHJYmqdzbyabftBNgtG3OKLDV73TQy + 2k7Jv6gU2e3vnH2q4jkIc53sOtdaU1N8zXL0PRSmpvma5eh3z6toF34UELwD7VtwNi5Oa87kRo5CCpX2 + NdB4R1GzsdSU3iK0Z7kVd8bPpVzdJNpgGcfMAOlcdH9xWdOzs+p59BfVq7pJNp63ORHrXUeE47G4vlTU + pikAOcbsCuWznipoiQy5PAPNddanzwcb2O/EUva03FOx3fjCPRI5IW0MgvGfmCDI4q7ovjHXbxI9P0u3 + jE3QuwqzpeseHbXQEV4la4ZNpCrk1xsGpXei6q93Zq0QY5UOvavJpw9pFwcdVs2eHRh7eDpShrHZy6mr + 4j0LVtLvYr7V5FkMzAuY+1a2sJ4YHhxHtZEF6VyNoy2arjSfEXi/T31C61BTCgLLHWZ4Uv7HSNXddVhR + 1BxkjOKpxcop3vKPRFNOcF715Q6R0IBqWs+JBb6Q028DhQ3WsjWNHutE1FrS7jw64IPYiug166t21wap + oiyQqhzuC4ANSXOj6p4m0SbXpbsTtHwU7gV0U6qp2e0X08zqp1lS5Z2UYPp1ucar7yEOAuePatPRrq3s + tSSPUXllsM/vY4H4cf1rN2heXUnBwVqTy4hGkg3IxPAxwD9a7ZpSVj0ZxU42fU3tb0G9RpNcstNkstNy + rQq5+YDscVNrOp6frGi2pmnvL3W9uDlcKg9ABVjSpNX8Z3EOl3OpbLeFAuPYfzplveN4L8R3KW622oAL + tRz2JrhUpX5Zayjtbt5s8xOV+SWs46pLt5tnGyqVG0gqR1UjpUJOTXX+IvDup21p/bl+9rHJctnyFIBG + fauRYAHHp1ruo1I1I3R6VCtGrHmixKcrFDkU2itjc7bwprUElq+h6tNnT5wRGSRiJj3/AM96wNf0Y6Rq + UkCFng6xSspXevrzWWjAEZOBnr6V3uj6laeJdLOja1dtG0S5tnC5Z29CepPtXFNOhP2kdnuv1PMqxeFq + OtD4Xuv1/wAzz7AzzSqdrZ6/Wruo6bdabdtb3cLwuOcMpGR61RrsjJSV0elGSmrrY63wp4mj0ota6g1x + Pp7ggQpMVVGPcjuOvFSeLvDYsSup2vlLbT4IgUFWXI67TziuQRypwMZzwa7rwj4jMaNpN1Fas0pKrc3b + 7lQdwc9v61x1qcqcva0/mu55uJozoT+sUfmu6OEZcYHWjgD3rp/E3htdMuWlsJftdqP9YyJxE3occfSu + YYY+tdNOoqkeaJ3Ua0a0FKIDk4qX57aXHRlPDA/yqNJGTO0kbhg47inGTOVOSvQZPSrNWeg6Xqtp4w08 + 6XrsoW6jTFvNkAse2Sf1rjdX0m40i+azuACVPyyKCA49QSORVNGaGRSrfMCCrqeld9pesWPiuxXS/Ecw + hlhX9xMBgsfc9c1xSi8PLmjrHqu3mjypwlgpOpBXg91281+qPOz1pNxHQ4rX1nQ7zRrnybyJkVstG+OH + X1rIxzzXZCamrx2PSp1I1IqUXdD4ppIZFkikZHXkMpwR+NDPLPJlmZ5GPVmyT+NR0VVi7AaKKKBiUUUt + ACUUUUAFFFFMBaKKKQBS5pKKAHZp6NgjHXOelRirdld/YphNHHG7AEMsqB1IPtSd7aESbS0I8SSB5Qny + g/MVHAz7dquRzS2+7zlk3bNiN0KH8en/ANetCJtE1JVX59Kusj5xl4HPuOq/rUWsabqFuY7ie2iEBQBJ + 7XDRuB3yOM1lzpuz0MPaxk+WSs/P+tSbS9fubNFhaY+SDn5Dtf6Z7/RgR7VvWOvw3F4yCQ+W3JiMYKE9 + yYycA/7hB9q4YAsQSARnHvVptiy7Y3ZW67XGCv41lUw8JGVXCU5ncW91BNem2huREinPlxHzY2Of7kmC + O3qetaL3NxZxpGrRxEthEYmMMP8AckGPyIrzaGZorlZm+dlbJJ53fn1/GtqDxLcNdZaWVUBz+7k2n/vk + kr+FclTB3emp59fL237uqO8/tVre1ElykydgyISv/sy/kRVi11e2uWby7mLavB80hP1BNcPbeIYZbj7V + JHCskbYHlk28j57/AC/LWsl0kt84cukB5zeWwlX6l0AOPeuKpgkt0eZWyyKXvKz/AK6b/kddHP5gyIyR + /eQhh+FIbiEEBn2n0cFefxrkHntoLqMQxWcm/wCXdZXhUj/gLdO5rVl+1wLDIh1aCJRyZIxKv14/ya5Z + YOz/AK/4Jwzy5J72v/Xds3F2yH5ZFPuDmlClV5YnBrmJNbeESE3ts7r0Wa1ZWYflVy2vb2aJZRFZsuMn + akmf/Hcis5YSaMpZfVir9P67o2/fOB71GGYTkB1xgZ9/85FZh1SeOPzXhhXHbZL/AIU7+13JUp9nyezK + /wDhUfV6iIWDqroaZbgncmaTOQeRn6VlrrDGYputxjrtgkb8OlOTUp3diqowAz8tjIfw5qvq0x/UqvY0 + /nYknAP0o2yEHGc+tY7X9+8RdIJ927GPsYUfmTStLfPIrSWj4I4LGFMen3icU1hZdylgp9WkabzRxc3E + 8at6F+fypstwEQuiOwHcjYv5msGWW5EoY3JhXdtx9siQHn/ZWqc1/pYeTzb2FpV6hIXuGI9MuQv6VvDB + JnTDLbvv6a/kbw1eF5GjSRGYZ+SHMr/yxVH+2HlmWKNhC+7pgGX/AL5GSPpkVlQalCYS7Qs0Z6C7uMIf + cRRgE1k/23NFdAEvDAc7ooB9mVh+HJHX3rrp4KPRHfRy2Oto/wBf13OmvpGto3kuNsOTx9olO+T6xr83 + 55H1qnNKFt1a5JW3fJAuGEER+kSfM314rBuNckmDJbRrbqT1gXYT/wBtGO6s2KS6uZlS1UebnOUUySH8 + T/TFddPDWWuh6FLAtK8tP6/D8Tdl161hURKkkkeDwo+zxsPTCnc34tVazvNT1e+i022MVpDJwVhjwMep + A6/jWTf6de2sa3F4hVpDj9643n3IznFVluorfDxiVrgdHL4A/Dv+ldCox5bx1Z1xw9PlvT1f3/8AAOzt + 7OLS3aewgju54uDcXGPKVu5JbCgewyfesu5v9OEgm1O8l1S46G3tz5UAx0BPU9ug/Gudub67vCBczyOB + 91STgfQUiI8LxyFvIGeHzyD6460QoW1k9f66/wCVghhGtaktfx+//Kxr6n/aN7Yw3Dafb6fpyZ8rbH5a + n6E/M5/Oq1vcQQG3mg0+NvJDGSS5YukvbO3px6VXk1FVZiQbuQ8LNc5Yrz2GcfnmqMs0k5BlkZyBgZOc + D0raMNLHRCm+XltZf1/WpoarcWdzJ5qSyz3LEF3MYjjxjoFH/wBb6Vlk59KTJ6dqK1irKxvCPKrB7UfW + pI4pJVzFGSFyWbtTiIIwDu81/TGF/OmVcSCB5ziJRkdXZsAVKJ4bVVNsSZscyMBx9PT/AD0qGeZ5ipcr + 04CgAfkKhoC1xzMzsWYksTkk0mcZopKBi4weeO9XL24tnKxWMJjgjJ2u/wDrHzjO4j+QqkKeigso3AEn + GT0FAmi3FbNFKsXktLdsxU27IeOhBz/SqgUeZhnAGeWA6fhWvNex6XGtvpssTTFCJbyEtmRWGSuG6Y6Z + GKxySe9JMUW3qSSTFolhG3y0J2nbgnPrUf4UAZIB4H0qxawxz3UMMs6wRyNtMzg7VHqaBvQbbwyXVwkM + YBkchQDwM/XtV2O6vLC2ubG3vJkDsVuI0kHlsAeOh5pxuDYTy2+n3DCMo0M86NlZ1z2BHHFT6boy3kMl + zd3K2djGpKySRkiVx/AMd6iTW72MpySV5bFGHTr26tZ7uGB5LaDBklxwKolixJOMk5OBW5qPiGS5txZW + Uf2PTgu0wRtzJznLn+I1hnHQZ696qLbWpVNzavJWCiigDPUnHfFUWCrvJ5A9zXTeHtDW5Iu7+GI2Sqx8 + uSXymlAHOx+hYdcGjQvD8d5F9v1NriHTMMn2mBQ+xx03jqBRrviCa/hFjF5Qs4fkeWGMxifH3WZemRXN + Oo5y5IfNnFVqyqS9lS+b7f8ABK+u62NRZbWzeePToseXBJISGI43kZwGIPOKxjyMLwO4zSncBtHK9Rx1 + pu4gcd+tbRioqyOqnTjTjyxFGWOep7ACr19oeo6dFFLd2ksSTKHRivBH1rofDWg28Fj/AMJDq0cc2nR5 + HlI/z56A4B9e1UNe8Wajq4eH7XItiPlWHPBHbPqawVaUqnLBaLdnIsTOpW5KSulu/wBF5nN0qjPPfsPW + gAk84xWvp9pcWdtDrk+nrcWKS7F8wZjdh2YA9K6JSsjsnNRRp20X/CM2U11qNs66ncxj7J8xSSE/38Yw + QR/hXMySGVneQlpGYkt6k9TVrU9Tn1S6aeZz6Rx7iRGvZRnoBVGopwa1luzKjTavKfxPf/IUDvT0Qu4U + DknAHrSwxPPKscaM7scKqjJJ9qnW1InWCb/R3OdxlBH+fSqckjVyWxtG40aLSo5rF76x1eDaPvbklPQk + HqpqKyvruW+Synla4hnuFeaMyhfMb/fPTr1rIO9Dj7yg46daPvOSFCk9hnFZezVjn9jGzW/qd34pv3F4 + ml3pmk0+2O6N9waRePukg4b0rkHYzzqF4XOFJ7Co4jcPG8amRlPLDr0rurDQPClz4ciebWPKvyhZ9xxg + +mDXM3GhFJ/gcl4YOCT19F+JHpWh+INIjXV9HkinXb+8AwT9MVnarr114r1K1F+nlwwkLIsKk455NZ0O + p3WnGWzsLyTDts4OAwPtXWaOup+DLZ7jUdJSa1mwXkVssBXPNOD55WcunRnNUUqb9pOzm/h6MXWrLwsm + lte6TeNb3UQwERiCT7g1zehWlrcalFPqVtczWbnDyoDgH3NJrt9b69rol061W3jfChTxk+prtbabVfBe + hbb2zt7uxbkmM/MM+tS3KlTSv70ujepDc6FJRu3KXRvVejMrxXqbaTYwafoerebYzIUMOdxXnpnrSeEd + L0qztHm1NX+1TfKFdOFXua52wgl1jWJbuxhjXa/mLCe1ddrviCKPQGS9sxFqJG1CB2qKsZRiqMd3v3M6 + 8JU4Rw8NW9+/zOQ8Vy6S2pGDSYQkaHDOD941zMuAflbNSyyEFi/3iarZBr2KMOSKjc97D0vZwUb3sFPi + hkmkWNFLMx4A71GAetdn4HsolvDf3kLm3jGQ+OBSxFb2VNzFi8QqFJzNzSNY0zw94ea3urZ0uNpyjrwx + rzS7nFzcyTBQodido6Cup8b+IoNavFitEAhi4Bx1rjz6VhgqPKnUkrORyZbh+VOtJWlLVlm9t2sL94Ty + Y24NbNz4pur3Sk04W6YHG4DJpvi6Szm1NpbXGD6VmaRfR2F+s0sYkUdjWySqU1OS1R0pKrSjOcbtEG1o + 2w6lT6GvQvD9xoB0Z470IH28k1xmtapFqd35kMIjUdqNFmt0v4xdD90TzWWJpOrSu7prsZYqi69FOV01 + roQ6gkUd7L9n/wBUT8tVl3dK9C8U2miPo8cto6CQDgCvPAxByKrC1vbU722LwWIVendJq2mp0nhK9tbD + VEkvEVo+4YZrqvFup6XrlgF0+2cyJ3Va82UkkHvXpPhDXtIstPaO8jTfjB45NceNpck1Wim2edmNH2dR + YmKba6I5Kw1HVfl062unhVztxnFLrGiXGkTKJ5VkdhuJFW9YaKXUHuLCNguSQwFQ6fpGq+JLvAkZ8cEs + elaxqJL2j91dTpjUSSqu0V1XU7LwXfaXfafNZ6isShVwoYfernPt914e1a6trFx9lnJARhhcH2p2paHd + +FniYTAt3PpW+fCcGreHn1JrwtcBNwOe9cPNSpzc73jI829CnN1b3hP8zktc8Majp1tFqE0QeGb5tydB + VqLXtFbwq1jc6azXpPySJ296v6Zr+pXumDw2yxysx2JJJ/DWPfaRceGNZgS8jWRBhjjoRXXGTl7lXdaq + 3U7YSc/3df4lqrO10ZEUs1u4aB2gfoSvBxXVXejaTD4bW+bW1lv3G4Rnk/TFN8SXFl4ilhbRdMlRoU/e + OBwazfDl1pljqol1a2M0adFxnB+lVKUpxU1o106l1JTqQU1eLW6VrsseHxZajIbS70y51K/kYCH99tRV + 759Kx/EWjXWham0FxFFCzrlUR9+F9M1uazftf6m2p6Rp81lEi4MkYx+PFXNHt9I1TTZLWGye81WdWL3N + zJhYz65ojVcHz9Oq7foiFXlSftXs91vb8bI87/Cir+o2clleNYyyRs0JxujO4fnWf0r0oyTV0exGSkro + Wp7e4kgYGIhHDBg46gj0NQUChq4NJqzPQopI/HWmG2nMkuvRLthIIVSo9a4a9tZbO5ktp1CzRHYwXpx/ + On2l3NBcLNBL5EicqyMVP0rsrlLDxdpDXcRtrK/so8GFVy1wfX1Nca/2eX91/h/wDzVfBz/6dv8A8lf+ + RwGM05Dgj17U6WJ4pGR0KMpwykYIpldm56ad0eieGPE0d/ZDRdTuIrWBU2IfI3CUf3WHr6HGa5/xN4cb + SJvOt47g2bnAaaIoVbuMHr9a5+OZkAUMFAbduxyPxr0Lw14iTVbc6VfJHJeyqY0urltwKf3Tk/ka4KkJ + UJOpTWnVHk1qUsJN1qS917r9Tzpl2nHWk7V0niXw1/ZE5Nq7XFsPvOqH903dWPT8q5tlKnB612U6kake + aJ6NGtCtBTg9CzEFuGZZ7kRuEO0uuQcdiRTPnicIyskgwcngioRzgEge/pVpLhZWK3u9wf8AlsCWfpgd + T0q2aNHbaL4lsdZtf7J8TOHTbthuG6g9BuPXisHxJ4Vu9DkEjDfZPzFMOcg9M1h+W8aq7JlG5DY4Ndh4 + e8XrFAdN1oefpTZGzG519ME9q4p0p0Hz0tV1X+R5dShUw0nVw+q6x/y8ziCMHGKSu08Q+ERHGdR0QG80 + 9xuJTkxE9vwrjGUiumlWjVjeJ34fEQrx5oP/AIBc0vTp9UvktYEV536K8gQH8+9Nubaewla3uLcxzLkE + SKQR+fH41ArkleD5m7IbPJrq7fxFbatb/ZPEivcOqCO2u1IDQ/7x/iFOcpRd0roVWdSD5krr8f8AgnIY + pK37/R/7NgllEZvLaRttvfRsVjyOvGOTWfe6bNYBDOo/eDfG6OHRx7EVUZxlqjSFWE1dMoAZOM4960Yj + ZXMJErG3uh9x1H7tuO/ofccVn4PWhevIyO9U0W1cfNC8EhSQDg9VOQfoRUdW4bwxr5LKZbbOTEx6fQ9j + UjWUc8RntJVJ3f8AHsSTIPTt834Ur9xc1tyhS0HIYgjB70UygooooAKKKKBD1Y7uuKswX9xArxxSskUg + w8YJ2sPcVTpaTSe4nFNWZopJZTHEySQOBw8XzL+Knn9a1E1MQW8cF0LLU7dzgMcrKgGP4uGH45Fc2CR0 + ozz/AFqJU09zKVFS3/r9TpmtNKnZ2t7mWwdQcQ3aeYuR23qP5isyeE2k3zmNwRuVopA30JxVGO5mjDJH + Iyh+GAPX61btHsXZvtxuFz0eBVOPwOM/nU8rjvqQoShq3df1/XUg8zJz19qv2Opz2FyrWl3LajPLJIy/ + nip4IbcBBZ6zbHDbliu4SoB/EFf1q0nnac129xpGnXqqdzsjblXPcbWwB0/OolJNWt/XzIqVIyXLa/lt + +Y241K4vrjEl1DdZwQ0qLk47FmAq9c6reCzeGOzgUZGZon24PphW21m/bdBuFUyWF3atwG+zzBk9yFYf + 1qtb6el9PItrd28VuvKNduI2b8PWs3Tj9pWt/XQxdKFvejZLuv8AJm5J4huUtlSabUFlIyrNKsit+BX+ + tV9O1q4je4kkijuEUc+Zbq2B7ntUQ8L6jLCHhltLjb/zyu04/DNTQ+E9ciimZ9NuJA6EAxTgAfkefpUW + o2tdGbWE5bXRPd6teCK3uktBbwP0ZFdFb8elWY/Ed9fyLDbrP8g/gvSM/wDfWaxJNH1oxrbiyvimeF3F + l/AUy20XW0k3RWF+jFcgxqwJH+FHsqVugOhh+Xdff/wTag1u6ikd5ftTKSVO7UNoJ+uKranqu8w+Uvln + HzA3vm5/w71VfS9fnQWzWGoyLGdwjZWypP4UR+GdaaQEaJdsQckMrYP1oVOmtboFToJ8za+//gki36QI + ZlSHzN42ghZOP+BMf5VZuvE17dWTQFA0brghYIYxj6gZrKn0zU5ZJHXSpIk37SEU7Qw7Zqi1vPa3Kie1 + yc/cckZ/I5q1SpvXc1VGjPXRsv2l4YHyiW6led0uH/MYNL/aV1O0wjll3y53Jax7Af5cfhVuFryykEyW + ei2vUjzHSQ9PRmY/pVOTXNQvSyT6pKiufmitk2g/8BG0GqSu9ENR5ndJff8A8B/mLax38aqiRpbI/O+d + 1i/HccH9adLbWyzkTagk0hPMdlG0jH/gRx+hNVhpN4VWcWNyYQQS842KfTr/AI1oa1FeJbS3TXul2gYK + osbKQAsPcL+fJofxWT3/AK8wk/eSUlr2/p/oNM1jZnemlwxsP4r+YuR/wBcY/EGqlzr946+XHeukZ4Md + sggT9Ov4isMn8aekxRCAqZP8RXJ/WtVSW71Nlho7vV+f/BuWBBNOysE2K3/LRzgH8TxTy9tDG8bzbzkE + CJRz/wACPI/AGqk9xNcndPO0jAcb2JwPQVDmtOV9TdRb3Lv9otEwNpGttj+JeW/M/wBMVUZtzFmYuT3N + Mpc9zTSSKUEtgoH5/SpPJbaSxRQBn5m5I+lLI0RPylnYdCQFH5UxkQDEZA49aefLTIX5z2bpj8KYWZgM + knHQelJQA+SRpTuYj/dUYx+FMo7UYJFAxKKt2Njd6hciCyt5J5iMhEXJplxby2s0ttPGUmiYh1bqPai6 + vYnmV+W+pXqSKCSeVY4UaSRuiKMmo6crMjBkYqw6EHBFBQ542hk2yqQw+8rdQaZQSWJLEknqTRjjNABT + ipXBKkZGRkdaVEaRwiKWPpitBooLAXNrfQyi7UAwTQyjCEdiO4Pr7UNibsW9N0WCaQprN3JpcbwmS3eW + Fish/pUNzrt3d6Ja6TKts0FsxMciwgSH23dcf5NMn1K51a8gOp305g3ZLY3bAcbiBxnpV+/j0HTdcRNO + uDqVoYimZSYtjkcNu44Bwf0rLrqYWal72r/BfMS10i1trYXusSzw2cqMIPsxR2Mg/hZSciqGp6zc6vP5 + lzsSL5cQQjYmQMZx0yR3qK9u77U7p7q+laWXCgs+AcDgcVPp2j3esu8djamV8AM54VDz09c+9NR15pDj + Cz56j1/Iy3ILEDO3tn0ptOZGRyjAhgcEHsadGjF1CqWcnAUDJNaGw3b6/pXU6J4bjktnvtVE0ViFwZrZ + 1doGyMGROu2naVpVhpyG+1iNbhQhEtmXMM8YJwHXPDY9Koa1r0+ryrE8zG3iJSKSRAJWTsHYfex71zyl + Kb5YbdzjnUnWfJT0XV/5E+ueIGvZ3itfLhjwYppbYNEt2AeGdM4z/jWGcxqrxyKd2VKA5I47imFiE2rx + k8kH71A3D/ez6cmtIQUFZHRTpxpxsg3tsKqWCnqB3rrvDXh20CR6rrq3MdijlZUEZBXjKse+3PtS6B4e + s44Zb7XYWW3T5SqTbJITxhyhGSPpVPxP4ll1e8KQSSLaRr5QBkY+aAeGYZ64rnnUlUl7OHzZxVa068/Z + UtF1f+XmN8U+If7Zvsw4itkXy0RRjeB0Zh61znU5Y8dgKUjc3TGelaWkaPPqt1sVZFt48GedU3CJe7Gt + 4xjShbojqhGnh6dlokGjaHc61JOtuY1S3iM0ryNgBRU+s+IG1GCC0toI7OxhUAW8BO1m7u3qTU3iHUbM + rDpelon2WzLL9qXKtc5x8zCueOWPSlBOb5pfImmnVaqTXou39fgAGTjvS9KCCCV4H9at6bpl5qt4tpZ2 + 7zzuMqijnitJNJXZ0Skoq72EsbyawuYrq1leK4jbKMB0966u48XRahpzQarpkM1+4CG9PVV9gO+K5e7s + 5LC8a2nhliZOGjlGGHrUaKd+SSAO/WsZ04VNTmqUaVa0n8mdbH4dsdQlupdD1JVtrWDdLJcnbubHQDri + sa80a+s4Le4u7RoUuOYmA4as9JAjlWbAPBK9K3bHxBeW2pW13cyfbDaqViimckKKxcasNnf8zBwr09U+ + Zee/3mSu+3OYn5YcjuKXzpFI8+Peo9v611DX3h/UdPurm+gePVZWJQRjCDnAxVe78J3scds9rMl2JiEC + Aj755P5VCrxvaasyI4uF7VVyvz/zOZjfyZ1mRijK25T75roNW8ZavrdhHZ3Dgop5KjBb61j6hZy2c5hu + ImjmU4YY4qqd6L8jc+1bOEKlpPWx0uFKq4zavbY3PDunWesXrW95ei0RV4bOCT7VV1K9vY55NLj1KW5t + VbC5YkGswkrGGzz+oq5p9rdj/S4rYyqvUkUOFpc8np0QpQtN1JO66J9ztPDF9Y6BYtcy2jR3GMF3HDVx + 3iHXZda1V7mRsoDhV9qmvvEN5fWYsSBg9eKrXmmWtppiSyS/6Q3OzvWFGgoVHUn8TOXD4aNOq6tVe9L5 + mRLIZGJNR0UoyTgDmvR2PW2LdjZT3tylvCm5mPQV6HqOtW/h/wANjTkgKXTJtII/Wqnguyj0mN9Q1GBk + BXKsw4rl/E+sf2xqzyqf3anCfSvLn/tVfkt7sTw6v+3YpU2vchrfzMV2ySe5NRU4mm16qPdSsNyT1pc0 + lFUM6Hw2mlvM41EgccE9Ko6r9lTUH+xsDGDwRWcCcdea3bHSLa4017h7hQ4GQpNc0oqnP2jb16HLOKpT + 9pJvXoVrOVrqRYJZCENS6vpiWDKYnDA89ay/uOQrdDwRVuMT3agbiyj1puPK+ZPQpx5ZKSdkVVchs1qa + XJEl7G8/+rzyKzpYGhfa1Pi7ZNOpFSiFWKnF2PYP7T8OxaaI4oVeV1wQgzg1yENzqWlXck9ojwxOeCw4 + FQ+FdRtbHUBJcqHj966zWNft9atjaabp7ysP4gOBXg8jozcLXT6s+bVN4aq6ajzJ7t7DrDww2tQ/bNUv + S4Zc/erlr2WXSXlsLW5d4icbVbiomudStmFpPLJCpOCuccV1F14a02Pw8t9Ddj7So3cnkmqTdGSdR3T2 + XQtXw806suZPZJaHKjSdUt0TUI7aSIDkSCt5bfTNZ0CS81HUWfVFUgBm547AUknjPUL6yj0lYIVyNpkN + QRwx+HLyG4zHdyH5tvUD61pKVSS97SXSxrOdWXx+7LpbsZOjatqWlSyWduyJ9oIUtKv3fel8UaJBo9zF + 5d8lzNIN8m3kKTzXR69oep67aDWo7SGGMJu2KeazfDM2jQQ3Q1KAPchTgvzmtI1k/wB5Fa9UjSOIT/ew + WvVLr8x+neLNSu9JTQrS0gMrgp5hHJFZV9o914fvoYtUDRxS4LmJuq96zZZJLXUDcWe6FQ2UYDBFdRbj + StW0qa+1zVWkvguEVj09BiqnFUnzRWj+8upBYd80FaMt7K7uM1G30zWrNbTw/pJWCNhv1CUYx9f8a4nV + LRLO+ktY5Vm8o43p0P8AjXQabql3aeXYSzT2+lzSZcBdpZe9aer6dZ6vKbHwxp3mQggm5YEYb0z6VdKo + 6EuWXw/1u/0Ko1JYafLL4e9/xbfXyR57S1avbSWwumgmTZKmQ4NVa9NNNXR7EZKSuhQcHPetDTb+Wwu4 + ruCUR3MTBlOOD9az6AcfWlKKkrMUoqSszub22h8Z27Xtirvrg5nt1UKpUdxXFSxPCxSVSrqcFT1X61Zs + r+6splmtpngkAxvRsEj3xXVXNlp/iuxN1p2y31OFAptFBd7hu7Z9a5Yt0HZ/D+X/AADgi3hHyv4Onl/w + Dh8VIshJG49OhAp1xBJbytDLGUljO1kPUH3qGuvRnoaSR6N4b8VQ31uula5O32dE2RRouFl9mI5z6Gsb + xP4Rn0qR7i1glkssFnbyziEn+HOeccc1yiuVxj1zXc+GvFtusKaZq/Fgqn7qk+YfR+ea4KlKdCXtKW3V + Hk1sPUws3Ww+q6x/y8zhGBFODfujHheWB3dxXceIfB0zJJqek2jC0ZTI0TMNyLjOQP7tcMVxXVRrRqxv + E78PiaeIjzRf/AHxyBDhwZIweU3YqyLGY2QvUUSQBiHKNkx/7w6jPrVIDsRWra5lbz9MCxXQKobQZczd + zgEYI46GtGbSdi5oPivUPD8jfZJN0LAjyXJKjPfHrVjxDJ4YudNgudOe4j1Jxuli25XOeck4wfpmsMxL + fXEcdvEY7py3mI7Kqk9eOmPpVORHjcpIpVh1VhgisvYx5+daP8zn+rU3VVSOj626+o33z+FAbFJRW512 + N/RPEVxozGIhbq1cYe2l+ZMHrj3961/7Ht9ZiuLnw2+GYYk02Ugvt6kj2z+NcUGK89cetWba8mtZBLbz + vFJ2ZGII/GsJ0deaGj/D5nHVw3vc9N2l+D9V+u5euNMjuZGFgkqSouZLWdh5ikZzt6b+npn271lsqKMY + dvVumD6Y5rrYta03WraO01yBYZkACahCPmA/2h3ye9Ra1os9pAklwEvLQqWiv7QZZhzjePx78+/FKFWz + 5Z6P+upNLEuMvZ1FZ/1s+v5nKLjPNKrFWDKSCOhB5FLJGYyuSp3DI2nNN5FdB3bl5bm3kCw3kAIX/ltA + fn/Hs38/emSWRCCW1nWZScbV++uexX/DIqpnmnLIyMGRirA5DKcEUrdieW2wwggkEEEdRRWj9vSUML61 + WdiDh1bY4PqSOv4imfYo5WjFlcCSQx7nSQBNp/ujPDH6UX7i5rboo0U+WKSCRo5Y2R1OCrDBBplMoKKK + KAFozSUUALS5PrTaWgBc04MRwCRxTKKAsPzg8HinRyyK2VYcD+LB/nUVFKwrFmO6dC3QhhzxU4uxlS+T + GTlkVyDWfS5qXBMl00y9PcQFV+ypNGwPJMmR/Ko4765iIKTyqfZyKq5ozRyIXs42s0aLarePKZGubgue + rGU5NPbUbvLYuLgBugMp/Wsyil7OPYn2MOxO08rqQzuRnOCeKltJrWNXa5hMzcbV3lR+OKp596TNPl6F + uOljUXU0gbdb2dooJyFkj83HGP480ybWLydUXzAix52iJAmM9egFZ2aMkd6PZx7E+yj1RZmu57glp7mR + 2/22LVXyDTamSWJF/wBQGcd2YkflVWtsWly7EYyTgDJqXyZlQsybVI6vxn6UjXM3O1gnsgA/lUBYsckk + /WgeoUUlFMYtFJS0DCjPGKSpY4WldUjVpHbgKgJOaAehHRXQ2fhPUJoDczrFY26tgy3bbBn2B5qww8N6 + ZIrM02qzgfOo/dxbvXPUisnWje0dfQ5pYqF7Q95+X9WMO00+6vpALK1mmYLkhF3Yx1/CtwaHpOnR7tb1 + LfNIgaOCxxIVPo56Cq994lvpwEhlhsbZh/qLP5ccYOccnNYTOVJCkc9xS5ak93YXLWqfE+VeW/3nQTeJ + 7iKH7NpMUelwnKloz+9YH1fr/Kuekd2kZmcszdW3Zz+NMz60VpCEY7GtOlCn8KCkopas1DGKuQWRIWa5 + LxW27YzqoYoe2VyDSTCyW2URGV5ztO7AAXjkH156UscU2ozl55gNqZMkp/hH6mlclvS41pWMS2kQjdUk + bZKse12B4x7j2q5DYQW0cF5qW5rWUlCsEy+aCPVT2FJdmyshcWlvsu3ypjvEJXHc8fp/jWazGRy7sWY8 + 5J61O5KvJaaFm6v5rmOOAyMbaEkQq2Mqp7Zqpnmgk9MnbnIBNBGOvFUtC0kloXdOWwkuHbUZZFjVdwVO + N+O2cHH5H8KaLia3lkezmuEiOY1fJUlPQ4quF/vZx/sitjRfD93rDF0SZbOI/vpUXeUHc7eCfwqJSUVd + szqTjTTlJ6GZBay3EmyJJHPUnaSB7nFdc2l6V4es3XUZS+oOgns7zT594UjoCvBHPep7jWLHwvC1loEm + 6/jfa+oof3cqYzgqSQTk/p3rlrudb2Tzp0SKVwWaZST5jE5+70A+grBOdV9l+JyJ1MQ7v3Y/i/8AJDtU + 1y/1swvqNw07wpsjYgAge5AyazWPP+etDnBwrZ45x/nmpoI5GfbDG8khByoTdx/hXQkoqyO2MY042WiG + pG5kWNFLyOcBVGd30rr9L8PW2m2p1HxBFfWyCQIkkBG6B+o3oRnntUttpWk+H9Nj1LUFttUhuQqqsMpS + aB+vA/z/AI83rOs3Gq3s0rTXBgZvkiklL4A6A+prmcpVnyw27nA6k8S+WnpHq/0X/BRZ8QeJr/XZFS5n + Dwws3lsYwrMD64+lYhABJI+8PlwelIcL7ntg/drV0LQpdZugGYwWan99dMhKRj3NbJQpR7I6UqeGp6aJ + EejaRJq16sPmi3gJ/eXEgOyMe57Vo6vrENnaf2NpJWKKPMdxcRMR9r9CR6U/WdcitLefQtEncaSxG8uB + mVh1OeuMjpXMdju7jjmojF1HzS26IyhCVaSqVFp0X6vz8ugh57UDge9A/wA5qWNBIcOSrHAXjA/Gt72O + 1uwkcZckYYkDOAM4r0Wysrfwro9p4gsrz7W8mImaIhHiY9iO49QaSz07UPAEsep3lra6jZXKBGkjblM8 + 4/zxWMiR+JvEpjheOwguH+VWbAX8PWvOq1HVenwLr38u55Far9Yvb+Gt3un3Vt0Xbxtds1ubvWdKhuRq + KgCedNxT02kdOKjl0Tw/d6Qkumaq66gAFa2kQ/vHPYelbV5d614F1GC3kuYdThkj2xpIWYqPYds1maba + aNq819davfLp907ZjijXaB74rFTklz7Ly6/I51Ukoe0Wi6OPXprFmLqfhfV9DkAvbElSu7dH8wx9RWL1 + UsGOc8A9cV6Db65r/g+FTeRw3trdD920j7zs/PjNcXq+ox6pfyXItordWPCRDAArqoVKk/iV13R24StW + qP3kmu6f6FVJ/L2nIY+h7Vf07UriC9ikinaJ1bKsTwDUVxpDxaVBqAuIJIpjt2BxvQ+hFZRLo5Ga25I1 + EdThCqmdxb+Jy1xfTX9vHeTTJsVz0X3xWdqMOiDSrf7FJLJfv/rFA6GucS5dDlThumRUlvePb3KXCPtl + U5GRWSw3K7x0MI4JQfNF2JYrG5uXdYk3FOWHpW3D4jfT9GaxEGyVhjdisKLU7qC5e4SX5nOXA6Grcmow + ahdRNMgjVRzjvV1IOT95XRdWDm0pq63HWcAiia9m+91ANZd9dteTmRvoKuavfCVxFCf3Q6CsitKUW/fk + a0YN/vJbi55zU1vL5M0cowSpzg96gpc1s1dWN2rqzO21Lxz/AGhoTWP2VYpCNuV6YriicDGOaTPHvTTz + WVGhCkmoIww+Fp4dONNWuFOVWYHaCcegpMHpW74c1uPRZpGntFmVvUcirqScY3irs0qzlGLcFd9jn6KK + StDUWpoiSypvIUnnmoaKTVxNXOkvNHtYtOWeOYFyORmsuzuzbNg8io7cS3LrD5h2+5rS1LRksrZJVkBJ + 965laPuTd7nIrQ/d1JXbK9wHuyZAuKpr8j4NXbO7VIyjDqKja2Lyb8HaapPl0ZafL7r2H2zgPntXb+Ff + EsWiswaEPu71xQjCMMdKtRNtII7VyYinGqrM4sVRjWjZ7HV69cS6/eCa3s2QE9cVSiV9OuUW73Mq87Ce + Ku6Xrt3JAtlbwr5h4DHtU2t+F9ThsxfXMqsSM4rhjJQfsp6I86E1Taozsl07k/8AwjN34ghbUraOO2hR + flXu1Mk1TRLTw/8AZhCTfA7GGOp9c1HoGu3SwDTXuRDARh274qlqtnbfaGj02KW6bqzgZwfrUWbnyVNl + sQoN1PZ1XotVb9WSSeIte0jSRaudtrKMKWGcCuceZSwnjJkcnLAjitW2MmsSfYr+6eNYhwp7GscldOvy + gIljU/nXdRjFXSWp6OHhCLaSXN5dTtoLIeNdBcwrb2klmudo5LYH6Vwdt5Vpf5uIjII2OUzwTVx5bywL + XNu7RRzDB2Hgj0rPlXGJEfcx5Jq6NJwur+6y8PRdPmV/dey7dzrhHD4nsZr/AFHUorNbddsFuoA4/rWb + pniK/sbCXS7WdFimbHmY5A9qxoWV5I3mwUBG5R3Fdbqk2ka1Z21joOnObxVGSBjFZzgoPlkrr8EZVKca + doSV4v7oj9T8H2VtoDX11qSC9YF1LtnzB6Y9a87dOflUgDse9dRbIltrEcWvrK0UR+dCSQK2NVt38bXi + Q6DpSQW1uuBKRjdiqo1ZUXabut79EVQrToO1R8yet9kvQ88zS1avLObT7poZo9ksZwVNVsE84r0U01dH + rRkpLmWwu48EDmrNpd3FnOs1vK0Eq9HRiD+ldP4e8B3OuaXLeR3UUcgGY485JPvXL3drLZ3L28ylZEYg + iso1adRuCexzwxFGtKVNO7W52Eg0vxdYvIrQafqlumFjAJ+0n1J7k/1rjruzmtJjBcQPBOo+ZHBBP4UW + 0rQTJIsjRMp3LIvUGusj1Kz8VWi2epoRrHEdveFwq/8AA/8AGs0pUNtY/l/wDC0sK9NYfl/wDieacrYI + 3Zx7da1Nb0S50K8NndgNKACrofkYe1ZVdMZKSujuhONSKlF3TOq8O+KX0+Xy75Dc2TEKd7Fii+gGf/rV + 0Gu+GbLXLcarpBtrZSm7y9+5pD2AUdDXmoODWvoviC+0KV2sJygkXbIMDkex7fWuSrhmpe0paP8AM87E + YKSn7bDu0vwZmzQSRStHIjJIpIKkc1GjvE6ujMjqcqynBB+tepudC8c2aF5o7GS3X/VqoaZ2+v8AFXBa + voGqaMBJd20kUEmVR2HDe3sfaqo4pTfLLSXY0w2OjVfJNcsuz/TuVTNbXVvJ9szHPHHiJoowfMbP8Zz7 + 9arNcvKZGuCZnZQA7HJGOlREfXHoabx+NdSR3KKCikozTKF6nFKVYZ449RSdMEEZ/lSlif8AAUAORyD1 + Ax6itfTNfvtKMn9nzNFHKNskZ+ZW/PpWLSg8YzxUyipKzInTjNWkro6stoWpQGZGbSr+JMKiIXWeT/2W + srVtA1LSFT7dZmEMOJB8wc/UHFZQdt3WtfTfEV3p08TZ+0QxkkW85LISeOlZck4fDqjn9nVpfw3ddn+j + /wA7mOQV4IpOa6eI+H9VWBbovp1zJI73Fwo3RgckKqD8BUF14W1G3tpby0xcWIwvnxN9/PbHWmq0b2lo + /MpYqF+Wfuvz/wAzn6XNOZChKMpDDrng03HFbHQW4tQnSIQMVkg3bzHKAQfx6j8DU+dLujjbJZOz8tnf + Gq/T7386zSScZ9KKXKS4LpoW30+ZfLMRS5RjhPKbJJ6/d6j8RVMqVJDAg+h7U+ORonDo7I46MpwRVpdR + lO/z0jud5yxmGWJxj73X9aNR+8vMpUVeaTTplc+RNBJgBAjhlB75zz+tKbFWJNpeQyrwvLeWxJ9mxRfu + LnXXQoUVansrm2ASa3kQtypK8EexqrTuUmnsFLSUv1oAKKSigBaKSigBaKTNFAC0UlFAC5opKKAFpKM0 + UAFFFFACUUUYoGHSinKOcYzntVxdMvCyb4PJEgJVpiI1IHXBb60XE2luUaK0fstnEkguL4NIvCJAhcE5 + 7scAD3GagnaDDCC2ZY25VpGyw/LA/SlcSlfYrVNFdXEO3yp3j2nKlWIxUNFMbSe5au7+8vX3XVzLM3X9 + 4xNViSe9BJPU0lJJLYFFJWQVJFC85YIPugsc+1R0oZgCAxAPUA9aYxKKKKYGhFaQMkUkV7biQr8yTKRg + /lg1FbW7396sBntomIIDyMETj3qpRSFZlxlSwnZJI45p43IOWDxke2DzVd5GkYM53EAAZ7AdBUdWDPG1 + msAt0EgbcZtx3EemOlAbEiwWv2GSaS7K3B/1cKpnvzk9qqAEkYoBG7LZNHPbigBfug/3umMVJBDNPMsc + MbyStwqoCxP0FaukeGrzVMSgJDb7wjSTOEAz0xmtmfUNI8Oxy22mJ9quGG5LpvkmtJhxww4Ze/HrWMqq + vyx1ZzVMSlLkhrL+txuneGLK0sF1XXZQbJ0K7Ld8SxyZwAykfpVbWfFM9+htbGP7NZhQCiAAsVGN3HIy + Oo6Vi6hf3Oo3sl3eS+bPLy7DAz+VVC20/Keo6g9qmNFt81R3f4IiGGbl7Ss7vp2X9dzT04WDSSLqF3c2 + 67Q8TRRCRd3YMCak1TVpNcW3VrO1h+zIVLwx7S4z1PYfhjrWSg2jLDI9K6fRvC73wS51B/sNk6FopHQt + HIR1UsD8ufU1VRxh70jSrKnS/eTf9eRk6bpUl7NHktBbFwkl08TNHHnpnArppLu38FyRrpN7HPqO3y7p + P9ZC6nkMDxj6VDqHi1bG0k0zQt0FlKhWVHO8K2eTGTzg+9ce+4/NlffFZKM6us9F27+pzqnUxLvVVo9u + /qS3FzJdSySSZaVm3E+lR7goxGxyR8xI/lQzs429MnnHc+tdXpvhaGy0/wDtfxDK9tbYBghABeY+mOwr + WdSNNanRVrU6EVzfJdX6GfoXh06iPtd/MbPS0z5l0VyMj+Ee9Ta34i820j0nTR5Gm25KAj5WuB2Z8dag + 1/xJc6yyR7UgsYuIraMYUfUDqfesEnnPB9B6VMISm+ep8l2/4JlTozqyVSt8l2/zYE0AdM8A9zRz19Kt + 29lPdB/s8M02xdzbIy20eprZux2NqK1IlgYOVcYIwenT616Fp2lQ+Ek+3axZW+raTeKqrcQ/NsPbg0yx + gm8EwJqUYttY0a+QRykDaVOM7SDnBrHtNPuNVka8a2vYdCW4LMsZ3CMewPB+tcNWftOto/n/AJM8utVd + a+tod+/l0aaHJYanrcd1NYW13LpEExdIHlJ2rnoB349Kt6vqPhu60RVttKubXVIz5YCtjHuT3q22oW2g + 6nBB4Znj1OK4Un7PJExMRPp05qvp+m6LdRXY8QXtxY6o7F/3inA+nrWLlreS0W1t/mjFzWk5JqK2te/z + RPDo2u+Go7XxNcwQXUaqCVlfLID0/Gs+61D/AITXxVarMLbTYZPkLYAx6knuaZa2XiPWNIcQG4vdMtZM + qrSEBgPQdelW/EHiLRNS0GO2j0Y22oRYQFeNoHv3/GiKfP3ltddPkNJ+0vZSltdfZXmjH8QWcukarLpa + X4u4l+4yHPHp/wDqq1o0Xhu30K9uNUeSW/A2x24+Ug+uao6bLPpMyapiGSSM8xS8n61Q1PU5dU1GW9nS + MPIclUXaP0rqVOUlyX+aOz2cppU76LdrS7KkhDH5c9T1qPOPetzTtCjv9DvdSbUreFrfpA7fM/0rCPtX + RGSd0uh1wnF3iuh0WqN4bbQLX7Csw1EACQHpnuaw47S5uIZJYYJJI4h87quQv1qLB/u/jV211e+sbK5t + LW5aO3uRiVB/FSjFxVk7+pEIOnG0Xf1M8twBgU2lI780lam4ZNJRRQAUUUUAHagjFJUkWwSqZASgPIoY + PQuaPdQWWoRzXUJlhB5FXfEup2GpXSNYWwiQLz7mrOtalo8+k28NlARMo+ZjXM1z04qpL2jTTOSlFVZe + 2kmmtCxp8cMl2qzHCHvU2qx28c+2AggelUCpU4IINWLK3+13KxlsZ7mtpKz529DokrS576FbFFdFq+hx + 2FqkiOMmudopVY1I80RUq0aseaI5HaNtynB9a0rGKfVbpYXmO33NZdSwzSQtujYg+1OcbrTcqcbrTc2N + W0tdLmULID+NTWTrcQ+WcA1T0+yuNYn+aQn3Jp93aSaVchC2cVyy1/dt+8ccrNeycryNq6tbOKzUKwMn + cVnpGQMimxS+eucZIqWFx5mDyPSsEpRVmc8VKCabuW7W4e1mWWE7XU5yK6KXV9X8SeXYeZhO47mucCbW + BIwDV6xna0uFniYhga5asU/eS1OOtFP34r3lsaWs+EZ9Is0ut+/jkVt6J4n0my0QKYP9IAwUA5Y1m3es + an4mnh02NlRW4JNZ+seH7vwldW10XSdM7iDWHL7WKhVfvdDl5PbQVPES97oZOuQXs1zJftZvBC54OMVt + 6f4Ns77w22oG8Am2FgM9Kn1z4gWt/pK2kViocrgk9q4iC8uEHlCZ44nPIB4rrhCtOnb4bfkd9OGJqUlG + 3Jb8UWrW4iRzaXrloVyFx60gtvsF1FNc27NZyHg+1bmq6Zo8Hh6OaOcG7P51mWF8b4RWN/Li3X7pPato + VOaLlFadTeFXni5xWnX/ADRn6nZGG5DxlSj/ADKFOdo9Kdp2qXOmSiexmMUw4JxVksmlXUoiQTwnIBP8 + NPh8N3OpWkl5aMrFRu2itOePLaext7SHJart/W5s6NpWm65Y3eoazquy5AJCs2OaxrLXdS0kXNtpt2Vg + Ykb1HGPXNY8eRN5U52kHDCuwHiXSrbw8dLtdMDzNwZMcD3rKcHB7cyfTojCpTlB2tzp9OiI28O6RJ4cl + 1G91gvfv8yjOefSuI24OME89e1dLqPhTVNL06K/uIhJbPhsKc4q1q2v6bd6BDYWOlCOYD55D1FXRqNfC + +ZN/cXQqSi/cfOm/KyMDTNXvdMkD2lw6YYEruOD7V3ph0rx9ZBYY0t9YjXoTgN6n3rzNUOeTt+tT2l1N + bTrJBI0cgPDKcGrr4ZTfPDSS6l4rBKo1Upvlmuv+Y/U9MutKu2tbxGV1JA/2h6iqikcA8Y716HBrmieI + tJe111RHqKL8lyP4j2rh77TZbVixVjDn5ZQODVUa7l7lRWf5lYbEyn+7rK0l9z9Df0nxHbTWw03xCklz + YAYj8sAOh/3uuKpa94Xn0tIrmCSO5tJxuRoTuKL2De9YC/KQGBK1uaJ4kvNHkeOGUm0m4mhbBDL3HPSh + 0pU3zUvuFOhOlLnofNdH6dmYJ+n40gzngc/Su0vtD0rXLaTUNBljglGB/ZrEtIT7etclJbXFvdG3lheO + cHBjYYOfStadaM12fY6KOJhVT6Nbp7odbXk9rOk0MjRTKwZXTgg16FpXi601+3Om62sMdzKPL+1yKCNv + pz0PvXLweEdQZPMunt7KM4OZpB09h1q2+neFtNiJuNTk1CYDOyEFFP41y4j2NXbV+R5+MeGr6K7ktnFX + a/T7yz4l8CSaajXVk3mwsfliXllH9R9K4qSMxybJUKleMYwa7rRviJ/ZNo9qbPzYUBEHz4ZR6Me4rmdf + 1+bxBeLcTQQRMox+6TGfr61WFeIT5ai07lYCWNjL2deN0vtf8AxaKXFO2N5e7sPau89YZS0UUgCjpR05 + pT1oASlBIpKtmzk+wm7Z41UPsCM2GPuB6e9DdhNpblfduO44z9Ku6fqF7ZXSXFlO0c0R3K24AA+uDxVD + BHXil7Umk1ZilFSVmjpo/EFreyW0euWC3EEIZd8P7uRye7N3xUf9h6bqQg/srUkFzM7Bre4GwRL2y54J + rFtzICICEAlZfmkXp2+91A5q/PotwZJRbSQTqnLC3lD4+gJyRjvWLpqPwu35HK6MYP3Jcv5fcQ3ekahY + edBJAWWNgJHjAdQfTcP5VnYrTs9Y1DTEkjtruaIPlWTPHvx61ow6vpN4YY9T0iPaihfNsz5b8dznIJp8 + 047q/oW6lWG8b+n+T/zOawaMjAGBnufWuhOj6Vewh7LVhHcvKUS1uU2lVzwS/TpVW68Oajb332OOJLqX + ZvH2VhINvr8tUqsXpsVHEU27N2fnoZFHt1FSTQvE7K8ZQqSCCDwaj5FaGyaexLHczQBvKlkj3DDbWIyP + SrSak25RLDa3ChAoDx7cfiuDmqGaAcHPB+opNJicU9y2stn5O2S0k83dnzElwMemCD/OnhNOkeQC5uYk + ONgaIP8AXJBH8qo9e35UpYnrSsLl7MtLaxlZWS8gwo4D5Bb2AxTjpUxjiKS28hkIARJlLD6jPFU857UU + WfcLS6M0H0bUY4mZrCQqBy4G4D8qqCzuTgi3lIJwPlPWo97Y4JH0NTx3lzGuVup1I6BWI/rS94n955EL + ROhO6NhjjkYppX2I+tWZL+6mwJbmVwDn5mJ59ank1zUpwolvJHCfd3HOKfvDvPsv6+RnUbSegP5Ven1e + +uFKy3BcYxyo6flQdVvfKVPtZ24IK47eh45ovLsF59l9/wDwCjtJ6AmlWJ5DhI2b6AmriarfRxyIl3Ki + v1VTgGqy3EyKVSV1DdQGIzT1GuYkNjdIiF7SZQ5wrMhAY+1OuNMurVA08ax842tIob8s5qEzysoVpXKj + oCxxUdGoWkXJtMlhVGeS1CvzlZ1bH1wSRT0s7TkS6lCoABHlxO2T+QrPozRZ9w5ZW3LiLp6AGV7iQ87l + RQv0wTn+VKLm0jiZUsVZ92VkkkJwPTAwKp0lLlDkT3Zanv5rgBSIo1U5URRhcfiBmoJJpJm3SyPI3qzE + 004zxRTSSGopbBSdaWrFvaXM5LwW8kuzk7UyB9aG0txtpasrUuPY1vr4algnh/tS6t7CKdS4dmDkDrja + vIpLefRtPaOVIJb+4jkO5ZQFgdexx1rP2qfw6mH1iL+DX0/z2MHFGOM5Faer6hHql59p+xWtnxjy7ZCA + ffGar29jNODIkM3kKQJJVjLKg9TVqWl3oaqfu3loU8UVu6tp2i2cYSx1eW9uBjIW22p+ZP8ASsuayura + COaW3mjilyEdkIDfQ0RmpK4oVYzV1p66fmVqKKKo0CiijBHUUAJ1pyrnkg474qWGFpZowCAWIALHAB98 + 12x8L2Hh2yg1LWJBqEUxI8m05Qd+XFZVK0adk92c1fFQo2T1b2S6nK6Zol/q05TT7WWXGMtjhfqeldKL + HQPC1wh1F11W8UMstovCoexz/Ss/VvF1zfRSWVjEtlp5Pywxgbse7Dr0rnGyxJJJJPJPWs+WpU+LRdv+ + D/kZezrV/wCI+Vdlv83/AJfebWqeJ9S1S1ayeZ008MGS36hAOgz1rELAgihiQThiQabyTwMmtoQjBWij + qp0oU1ywVkL1q1Z2F3eXHk2dvLPKOSIlJIqWGyiNqbiS6hDphzbtkMy+x6fh1rodR13SrH7DfeGRLZXg + XbOmcj8exqJ1HtBXf4GVWtK/LTV2/uXqWrXQtO0C0TU9XeG6VwF8mNyk0Emf7p4bHfPFYWs+IZdSnl8h + DaWkhBaCJiEdh/EVzjJrLvL241C8kubqRpJ5G3Mx7mq2SeBnFTTo6803dmdHCtS9pVd5fgvQk+8204A9 + R2qazsrm/uVtrSF5pm6Io5NXdC0b+3L3yFu7a0VRl3mfHHsO9dBeeItP8PRPYeG0Hmldkt+eS3+76Cip + VafJBXf9bhWxDjL2dJXl+C9WSR2ek+DIkn1ER3+rlQ0cCt8sB/2vU1yuq6xd6tdPcXUzOzHhc/Ko9AO1 + UpZpJ5GeRyzsclmOSTUYYD0P1op0OV88neX9bDoYXkl7So+aXf8Ay7IM0dKSpyiLHtcETHlSGBBHpXQd + exJBaTSFT5bgEbgcYyvcjPU10h1GHwvfWt94b1p51uE/exSx4ZSOquOh/A1kQ6zd2+nS6XKqTQPx5Uwz + 5Z7FT1XH5VQUm2mVmEblTyjfMPoaylHm0lt+ZhKm6mk9u3RnWaRp6+Mteu3uLuGxnmy8VtGpxI+OgHTF + RQavrWgxXum2lw2xQyTBRvROxIPauW8/bOZI/wB2ScqEJ+X2FbOneIb7SdOurS32eVdrh3kjBOPYmsZ0 + X6rTQxqYeW1lKOlk+hvQf2Zo+iWut6Trh/tVPvxOoO4nqMelRPqB8SeILS78RzNbWbLtDRxYB/H+tcrE + yySAeaiHG75xw3rzXTax4yk1bQ7fSksoIVi4LAZzj09KylRalpq316pGE8PKM017zd/e0ul5Gnq2s/8A + CKXJs/DWrefZzIS0bYcIT6H6VhWlhpd3ot7f32rGK/UkpDt++adoV7pmjCe41C2W5ujH/o8ZPynPfNYV + zK13cyTsFXec7VHSnTo2ulp59yqNC14xutry0uyEtLJIGkYsRxk+lINoJBBbjA9q19G8P3uv33kWgXHV + pH4Va7G40zwrbeHJbS7cW2qW2QWHJZvb1FXVxUKclHd+RdfG06MlBK78uh5qU2jrnNaGi6Jc65frbQEK + D96Rui1Y0Lw9eeIL5re02qByWfgYruX1bTfBVq1hFEPtwTDleQxqMTinH3KSvJmWNxzp/uqCvN/h5s4j + X/DOoeH5QLkZj6K4PWsIKztgKSSeAK17y51LWrhpJXlnJPypknH0Fb1h4d0+z0sX+o3bQXQ5SI8GqVd0 + oL2rvLyNFiXQpL27vJ9jJk8G6ommLfFBsI3FT1Fc86smUZMH3FdW/jTUTKis4e3Q4CHuPeteTVvDWuQr + HdWwtpsY3qOM1mq9enrVjdeXQyjisVR1rQun26HnOKK66/8ABVwkZnsJVnixnCnJxXLXED28pjcYYdRX + ZSr06q9xnfQxNKsvcZHtpuaduJpMc1sdABc4rqETQF8NksxN72FJpul6Tc6LNPPdhLheVXNc3JjeVU5A + PBrmbVZ8qbVmccmq8uVNrlY3G5uKack8daWtLRNQttPuTJdQCRfTGa3k2ldHVJtK6Vy/4h0VraUyxKSp + rno5HhkDoSGFd3Jq0N5ZeXIASR3rj763CysyDiuTCVJOPJU3OLB1ZOPJUWxHcahcXS7ZZCQO1Vav6RFb + zagiXBwnvWl4js7GDY1qy9OcVvzxhNU0jp54wmqaRz4GTQRtNICQc0ZzWxsW7O9ms23RNjNb0FrFf2zz + 3U4MmM8muXqaKVwQCx256VjVpc2q0Zz1qPNrF2ZcWY28jKh+XPWtKBGCefwR3FPkn00aYqhR5pFZsF1I + v7skhfQ1g7zW1jnd6i0Vv1Nn7T5/GMYqeMFMVmKGA3IKuRS5ALdRXNOFlock4WVkakc7wutxC+yZfukV + Q1zWtU1J1+3SFlHAp2/cQy1cma2urLYyqJBWMbQkm1cxhy05KTjf9DmY1iS4RpRujyN30rqtYudEutKh + t9Oh3T4/hHIrmZ7OaMkgErUFreSafeLPGASp6GuycFUtJPY9CcFWtNPVG1o8VrFqkcWrgog5w1dJ4h0C + LWY0n0K2HkovMnTNU7iHT/E+itfCZYbyIcqSKydH8bX+h2r2Y2ugyozzXK41KkueHxLocMo1asvaU/ij + uug/Q9Si0+WXT9TtlZW+Us3aoWnutGupZdLlc2z9fSufvb6S9umnk+8xzxW9oGvwW0TWd7CssDjGT2Nd + M6Tiue177o650ZQXtOW7e6IH0ea/tPt0UqyTOf8AVjrWj4c1y00dJrbUbBGfB5YZrLN42nak1zp7HZnp + jirFppGo+J5ZbmFVyBn60VEpQtUfuhViqkGqztD7mie68TahqC/YFudli7/KrjhB6Z9Kua14IvdNsY7u + 2lFxGyZYqelUtP1GDThLp+q2S7lyN2OlVxrl+IJbS2mlFk7cgjOKy5Jxa9krJfczL2dRSXsPdS+5j5NZ + 00+GF05dMxeA8y5rFa0uraATPbyCFujleK7C98J6evh5NRtdSRpwMspPes+58YX13oKaP9ngP8O/HJrS + lVv/AAlfXW5dCvf+Ar663OYQ7/Zh3rr/AA/4st7ezfS9bthdWbDCkAblPrmsnVfCmo6NpkN7cmPZL/CD + yKw1JYhQMmuiUadeOmp0Tp0cXT3uu/mdXr3g6a1gjvtOYXNnMC4WP5jGOvNcmPlP3cjvW/ofia+0OTYH + Mlo2BLCTkMPSr3i298N3sUFxpUTRXTjMiKMKp9KzpzqwkoTV13/zMaNSvRmqVRcye0l+pzVnez2dwlxb + StC6HKshwRXYjxFp3iiFLPWIo7S5AAW+Qck/7VcFu9etOUnpmtqtCM9dn3OivhIVrS2ktmtze1zw/qGl + /vpGNxZt/q7lMlGFYJJxXR6J4rutKIgmAvLEghreU5X8PStS78PaT4htWv8AQLhYbg8vYSHkf7tZKrKk + 7VVp3/zMI4idB8uIWn8y2+fb8jhwVAOQSccYNNJPYV0Vl4P1G6SSW48qyhjOGe4fb+lW0sfCemkG7v59 + SkGP3duuxc9xuNavEQvaOr8jeWNpX5Ye8/LX/gHJhSxwBk1p2GjalqK+Vb2d1ORyFQHC5rU/4SiCy3DS + 9ItLfPR5V81x+J4rPu9d1W6uBczX7CXbgGNtuB6YFHNVlsreoc+In8MVH1f6L/M0D4Vu7EldQubDT8jk + TuGcfQDJFQfZvDNqqGW7vLx/4lhjEa/99Nk/pWJLcNPI0ksju56sxyTUW7mmqc38UvuCNGrL45/dp/m/ + xOp0rWtAtZ50udASWCThXZy0kf58H9Kh1jQrOGGO40jUIb23mOfL6Sx+xFc8CMd80qlgQQSD7UlS5Zc0 + WNYblnzwk/Pqn94RkxyK4wGVgfmGf0rtl8WaZrkcdv4i0xCUwqXVqNjKPpXIi6VvLS5iEkaAgbMK3Pvi + o5Y41jR4pg+7qjDDLTqUo1N9wrUI1rc2jWzR1154J+1F5vDl9FqMOM+VkCRfbB61yU1pJbXDQ3KPEyHD + ZXoaLe8ntJhLBLJFIOjIxBrqNE8YJaW/2TVNOgv7VjltwAcn/erL99TX8y/Ex/2mhH+dfc/8mYem29xs + MtpeWyz52/Z5GALD6MNpHtmlu4owS1xp8lpKDhpIc7M9/lP9DXUz6d4W8Rnfp94NLu2A2wTD5Ppmql54 + d8TaFbN5G+4sfvboT5sbfVTSjiIt2ej7PT/hzOGMhKVpPll2en47M5tIJnieSOSGeNACwcgHH0PP5VGD + bScyRyQc/ej+YD8D/jQ9xDJbMj2oFwWJ81GIH0K9PyxTY22giKYjI+YE4BrqPQs+pNHaSSybbR0uc9FX + hv8Avk8n8M1EjS2szDfLBKDzyVINWbOC2KmS9hldGOFe3kUMp+h61JKzRyFI70uq/divI8N+RyP1qL62 + M3LWxPa+Ir+DTZLJngntWz+7mjVjk9SD1zUy6nol1JD9r0LysEmSS0mKk8cYU5ArHeT7W6olnGkgPJgz + z+GSPypWFkGAS4njbPIki6fkf6VLpRfl6f8AAIeHpvW1n5f8A1fsHh+7ljjj1ae0yWLm7g3AegyuTUDe + HWa3luLe+0+aNAxwtwFYgdwrYPNUzblhvjvbWT2LYP8A48BT5tOvltkuGtAYm6PGQc/kaVpLaX3iUZR2 + n99v+AOl8OatC0StYTlplLxhBu3KOpGKovazJkvDIuG2nKng+lWUa6tpw6Jd25XIBUkEetTR6/qVtG0c + Go3IQsW2sepPU/WrTqeT/r5midXyf4f5mVtoxWwuu3rpaxv9mlEL5VZIFOT7nHP40651T7TLKkmmaeHf + 5cxR7dp9Rg4p80+q/EfPUW8fxMXFGK7jxVZ6do7aNZ/2bE0sdsst1sYqXY9ifwrEnn0R7ZyNJu4Z2B2M + J8oD9CvP51EK/Ok1FmVLFe1ipxi7P0/zML8KOPetj/iQG1jAGoLPkeYfkK++O9MuIdF8+AW1xeeUW/em + WJcqPYA81ftPJmvttbcr+4ytp64o2k9BWze2uhR+eLS+uJMIDFvhxub0PPAp9pB4daxQ3dzfLdH74jjU + qvPbJ5pe1Vr2f3CeIXLzcr+5mFg0Y9q2oo9AWOYyyX7uGPlBVUAr7+hqR38PRiNkstQkDIdwklVRnsQQ + ORR7TyYe31soswcUVr3lzpT2hitNLkhlyCJnnLH34xiq2ny21tc+Zd2YuYtpGzeV59ciqU21exaqScXL + lfpp/mUaXFbQ1SxjjlWPRrX51KhpHZip9RzUcmtytbmGO0soUK4YpANx/E80lOT+ySqlR/Z+9r/gmZFB + JK4SONnZuFUDJJrSh8OatOSFsJFK4J8z5ce/zY9KkGp6tfxRxec7JBzH5aAFT7EDNQXsWpfakGoC5E0v + 3TcEgkfVqTlPbRf18iXKo9Lpfj/kWW0CO2kVb3VLOFWTfmNvNwfQhe9VruLTIN0dtNJdMCCJtu1W45G3 + qMetE2mi33efe2qOBnaJN5J9PlyKrwSWixnz4JZJM8bZAq4/KlFPdu4RUn7zk3+H9feWY7+2jsTCNMtz + Of8Al4YsSPwzj9Ke+sapctg3ckYkXy9kC7Aw9CBgGoJtQiKeXBYW0I9fmdj+LH+QFRxT+cUW6muCkY/d + rGAfwHPH60+Rb2H7NPVx+/UsyaPf29q9zPCIYxz+/dUY/RScn8BVS3WJrlVmaQwn7xhGT9ADirkMQuQT + b6enXBkupv6kqP0qxiWOJVTUIY2hP+qtIyZB77wAD/31RzdH/X5i9o1o/wCvzK7vaROI7axMThwwmu3y + R6fLwMfgaW+uPNnG+9a93NukjgUxxg47cf8AstNmtzMoYx7JPvPNPLuZv+Ajp+OfrUtzqgmsfsTLBFDn + diKEbsjpz2FLqrCtqmtf6+Y2a1uFuEcwQae0Ue9d7lScdDySSTWyus2NxapPLaXOqaguC02oTfuUPptz + yO3JFc2lwyndFbgt2km+c/r8v6VNa6Re35MzrL5Aba0207FOcct0FKcYtXkxVKcZJObtb+vX8Rmp3a6h + dtOI7eORv+WdrAI41GO3vVDBPFdLe6B/wjt3CmsGOS3c4lhtZh5g7jOR+PpTLvUtJ0nWzPoEZuLYw7CL + xM4Y9SKcaitaCuVCtFxSpK6tp2+8p2vhu/nIaaM20W3fvlGMp3Kg/ewOeKt79F0WRhsTU7lCV55hYdQy + kHORxwQe9ZE19e3NulvPcyGCIlkidztUnrgHpUXyiUrCjPuAClh8wPtg1XLJ/Ex8kpfG/u/zH3E7Xl3J + N5cUPmHcUQbVH09K19E1rUNOlEdhI1whXMlu67kPrkH+dZwtAsqyalK8Svk4A3OcdsdvxqT+0xbqiWMK + QFNwE+PncH17dKVSKnHltcKsI1Iclr/kdBqVxolxGkl9pJsrl+S9nMCMf7vSsex0Rtb1JrPSH8w7Syic + qhOOw55NZ6wNLbyXDyxqB0Dtyx9hUEcrxOrxsVZTkMpwQaiFJwjaLM6WHdOLUJa+d2vx/wAzXHhbVzqz + aU1psvVXd5bMBke3rWXcwyWsrW8sbRyocOp6g1Ml/dLereG4ka4DBhIXJOfrXZ/atJ8cxrFeeXp+sooC + z8CObHr70p1J02nJXXl0/wCATUrVaDUqivHq10ff0OAyaM1f1bSbzSL1ra+iaOUdOOGHqPWqG04zg4zj + Nbxakro64yjNKUXdCUUUVRQoOOlGe1JUiQvINw4Xu1AEeeeOfarn2RIYlmuGALcrHj71NEkVqxMf7xyM + ZI+6fUVWkkeVy0jFmPUmgWrHSuHkLKmwHsKaGOMZ49KbU88HkLEfMR/MTd8p6exoKC3QT3CRyTLErHBk + foPrTlEEZcTBpGDYXy3wPftUABJwOaKBWHDrkfhVqC2WSGVpbhINi7kSQE+Z7DFQ2832eTeFV8eo6HtT + 7y9nv7p7m4YNI3XAwPyqXcl3bsh9xeT3ccEczBlhXZHhQCF9DjrUO7auMdehz0pg6e9SIOOQM+9LRBZJ + D449iiQqGz2rX03RLnVG86K3m+xowEkijO0d6taT4cu2hj1K7s5H09WBcL1x7Vs6t4ostNje08MNLCky + 4lVhkA+3vXHVryb5KWr/AAR51bFSlL2dBXffoi3f6vZeC/KTw5diYzJ++jk+YD39jXN6Zo1/4r1KSaWS + OLfli8gwv0FSaN4dNxLHeayJrawc/wCuK9TWvrviJLPT59CsfLuLMAeXcLwRXMvcfLS1k92cabpy9nQ9 + 6b3kS6tr6eGrdNK020jhuETbLMhDBj9a4p5/t92DPKTLIcM7knFJbeZeXCW6uu6Q43SHpXZTWdh4Jt1k + uhBfy3C8IAMrWiUMP7qV5v8AE3jGnhFypXqS+9jY9Jk8GRJqn2yC4Ei/LER976Vx2taxcaveNcz4Bboq + 9BUF9ey3srTM7Fc5VC3Cj2qizFjkmumhh+V889ZHVhsK4y9rVd5dwz+VOEhHHSmUEYANddjusadrrd9Y + qRBcMARjGazppnnlMkhJYnk0wGlxnpUxhGLulqTGnCLbS1FwMDHJrS0zS1vA5lfZtHGeKu6DYRpcLPfx + MsPUEjipvEWo2M0nlWK7QvGRXPOs5T9nBfM5p4hyqeygvmc/NF5UjIjZA9KgPArVt9HvZoDOkLMuKtXE + mnDS/LaPbcr1GK09qr2WpqqyvZakWlWFlc2kklxIFYA4zWNMqpKyocqDwaNzKpCkgH0qOtIxabbZrGLT + bbNnSU+1zCMtg12f/CNxPZ44Jx1rzi2uHtpRIhORXe6Xr0l1arGHAYCvNx8KsWpQeh5OZQrRanTehyGq + aZJYXBAGB6is5nZz8zE/Wu/v9Pa+jbjLetcXe6fLZykOvyg104XEqpG0tzrweKVWNpbop7Wxuwcetaug + 2dve3ojnfaPetO0fTX007yocL3rmzJ5VwXhYjB4IrXmlVUorRmzlKrGUVozoPE2k21gUaBwcjtXOA1p2 + EM+sXapNLkZ7mtHW/D0dhAsiMOlZ06ipWpTd2Y06saNqNSV5GFauiTqZBla27y4sJLdREv7z2rnRV7Tp + oYZw0wBHvWtWF/e7G1anf3uxct7l9yxHgH1q/PEkIVlfJPWoL+SG8CmzQ5HUgVWs2InxOx49a53HmXNt + 5HM4865tvI14JFxz0pfMCPuFU5GLSfuASO9TA/Jg8NXPKFtTmlC2p0+l2ttdRM8+OBWHqvh95nkntV+Q + c8DrS2d08ThSTszXVTapbx6eq2wUuwwwricqlGpeOtzznOth6t4a3PK3M1s7IrOhPBA71XOSfeu7u/DM + uo2z3UUZDAZxiuNubWW2lMci4YGvXw+IhVWm57uGxVOte2/UgUHPTikyFPFdJpfg/UNStHuIxhQM1gXd + tJaTtDMuHU1rCtCcnGL1RrTxFOpNwi7tF3TNRjgkMdxGHibgk1o2ev3Og3Uv9my/u5P4TyBXNVJBN5cg + JGRSnRjK91oE8PCV29U+h2Ol+Hp/FQmvZblVkOTgYrPjv5dCe4sJokk7A1SGp3Fkd1nM0e4YO01t+Frb + RdRS4fWJ8TkHBc1yzjKCcp6x6I45xlBOVTWHRJbGHBFJe3Co0xiic888Cum1Z/DVtoK2sC79QXjeg7+t + clflIb6WK2kLRA4U5qRLVLaWN78uFdcqVPOa0nS5+WV7LsaVKPtHGfM0lrZF25ttVmtoJ9RM7WSkY3N0 + FGvTaF5duujRyrIq/vHbuag1HxBfX9slmZs26cKAO3vWSwChSDyeorSnTlo5aeSNKVKTs56W6Lb5jN5G + fU1JDbXFznyIXk28naM4qPaSMhTitTR9du9FMv2fYRIMEMM1tK6Xu7nTNtR9xamUylScgg+hpKlnmM8j + SOcuxzxUNUttSle2o8MQPf1qzb3EtvKkkcrRSLyrKcGrGi21hc3Zi1K4MEZX5X7ZpbjR7hFmnt1a4s42 + x5yjg1EpRb5WRKUW+WR0cPiqy1e0Wy8RQNIijEdxDw6n1PrVHU/B95aQC8s2W9smXdviOSg/2gK5tSRw + v61o6drd9pkxe0nZA2N6k5VsdiKw9jKm70n8un/AOP6pKg+bDuy7Pb/gGaUJBPoenemEGu5a98O+Jtkd + 5Aul3uOZ4x+7Y+pHasXV/C1/pcfncXFux+SaE7lI/CqhiE3yzVmXTxkW+SouWXZ/o+pz4Xnnil44xTiC + CQ3FAQ46cGui52XNXToLO7T7FNdi3Z5BtmkT92q4Oc981Y1PRTZzOgj+UIGE1s3mQkeueoz71ZgtNA1I + 2NnbyyWc4Qtc3k7YX3AWnJBq+gyxtZzC5iZTOY0O5SgPDOnp9a5XNqWj+TOCVR8/uuz7P/M5uWB4kV2w + VboykHNRke1dINTsHinZ7Ew6lLJuWdG2xKD1BTHTGasXXhz+0NTitdMe2u2ePzHmsycAd8oeh+lX7e3x + qxp9aUf4iscmDgg7QcdjRnJOOKt3FhPDLKgVnERw5VT8v1qoFPp+VbJp6o6oyUldHT2dj4f1Cxt401CS + 01HbhxKvyO317VZW08T6BA0tlPM1ocruhfejD6VyCsobLqce3BrQsNavtPcNbXLqACNhOVIPB46VzToz + 6O67M4amHq/ZlzLtJX+5/wDDlF42BOeD3BpGR0VWZSAeQSOtbI1mzukn+36cks8vImRtpU/TpXR6br2h + 22jiCaR7gRLnybiPOT6A9qKlecF8DY62Kq0oq1Nt/wBf1qcCSeDz+dXxrF8Y/JeYyJ/dlAcfrmtYz+Hd + VvAslrLpqu2A8bblX8DU58ES3iyyaTf297Cn8W4KR+dN14L41b1HLF01b2y5fX/PY56GeO3ufOUMCDlW + t5DGR7gkGrFxqDXVsIPJMjFtxkkRXc/8CABqpdWM1nI8U4AdWwQGBwaf/Zl+Ikl+yT7HGVbYcEeta3ho + 2zdum7SbHyLY5CSQtE3fazDH4MD/ADomtbERNJaajuKrny5UZWP0xkGprK4uLS7E1xaJdnbt2XakgfnV + fUpftl200VhFapgDy4Qdv1oT1sCbcrLb1Iob+8g/1V1Mg9nNNnuprnb5z7yvQkc1CQQeQR9aStLI15Ve + 9ha2/DFgdQ8S2NsUJDTKX4zwOTWHXb/DuIQ3+oarIPksbV3BPTJHFY4mXLSbObHVHTw8pLe34vRFHxtq + J1DxTqDL8yrJ5akDsoxWEbhp0jglkcIp43OSFH0pPtLNcTTO8gd93KnHJ9famW0rQXKSxyCN0O5XIzg1 + VOHJBR7F0KSpUowXRFp7qBoljme5k2ccTjb+AK1QBy4y2Bnqe1Xxqd3KRFvgfc2SWiTk+5I6VJBZ3MQZ + 1S2cMcHJjfH05q9jRPlWpVljtkUlL4SN6eWwz+dREqEBWcEnqu3pV9kuWYoLaM/7tsn9DVa4SQhAbcJj + uIiuaNBpruNEdqYQzXoDnqnlnipJ/sIjAivJZCi4QGHbzn1zUz3E91CYEtLccAEx23zD8cZquVubWEIy + bUZsgvHjJHuRSuiU03qxbGSxHmG+iuJW/gEThR+PBqwbrTQzZ02YJtIUNMc59c4pv9taljIm24/uYWqt + xe3V4wM8pkI4BPNJxTd/1E6d5Xf5svWhupBCbTRVnwCpPkvIJD6n3+lVxqF9bTyiNVgcth0EQG0+mCOK + Yt5fRRLDHdzJEp4VZGCjPfANW00/TJIhLc68qyNklRA7nPuaWi3/AMyWop+8vzZCmq6jHHcqt4yfaB++ + G4Df+VVDM1xMn2m4kZOAWYlio9s1BjnjkUuKtRSNVCK1SLpOmRbgFuLg54YsEGPpjP60y2K5yI4CQesp + Yj8hUCRFztAY/Rc1qacur2KTSWcUqqR+8cxZAH4jipnJJbkVJKK3182C6Zc6pcgCKVnK/KLW0IXH6fnU + c32/RmNrmW3ZvmIyM/p0+laNjHrviO/+zLqbeZtOFecqCPQCtJvA8VpGz6jrVrE6ruaMHcT7c9655YiM + Hyza9Djni4UpctWS9Em3/XyON3HzQzDdg5w3etJNYuilxb2tpDHHcgK0aIcceg/rXQTQ+DNPwqz3F5Iv + OQPlY9gRUV74utFltJ9E0uOxuYCQXGCrDHQil7Z1HaMH89BPEuq0oUm/XRf18jHsvDGqXqxuIDFDI+0S + ysEQn6mtA+HNNsbSd9Q1aJLyIsv2ZBuJI/2unNZt7r+o6gs0VzfFImJkMS/cLewHArHLljySfetFCrL4 + nb0NlTxFT4pcvp/mzs59S8OaT/Z17pEDS3MZzPb3A3oQRzknjP0rKufFOoSxXVtaEWllcsWe2i5Xnr16 + Z9qwCR/9enNK7Y5PAwOaqNCK319SoYOEdZe8/PXz/AHcuxLMSffmmZopK3OocMFgzEkZ5wealEpjk32+ + +MDowbkfiKhpQTjGTg9qAsOaQs7O/wA7tyWY859ab1pKXFAxMe1KM1asdOvNSm8mzt3mk7hBnH1qSazi + toJFuJHS8R8eSU4x9anmV7EOcU+W+omnafPqVwkEKMzOwUNg7R9TTr+xl0m+ktLjaJYzyVbOKvQ+Jr22 + 0RtOtBHBG3EkiDDsPrWIxLEliST1JqI87k+bYzh7WUm56L+tTstK8R2V9ZDS/EiGe3xiC4x+8iPqT1Ir + H13w7caQVmRhcWEnzRXCcqR2z6GsZSFPIzXUeG/FJ0pHstQh+16ZNw8L87fdfespU5UnzU/mv8jmnRnQ + bqUNV1j/AJdmcrjJwKStfXf7IbUWOjC4Fs3P77A5PYe1V9KsUvtQit5Z47eN2w0snQVvzrl5nodaqr2f + O1YoVPLcySLtA2R9MCtbxB4ZvdElDTKHtn5inj5Rh/SsmS6lktkgbbsQ5GByfrRCcZrmjqgp1YVYqUHd + Fer8cGntpbyvcst2M4jqhRWlzVBRTo43kkWNFJdjgD1Nad14e1KzszdTW7LGpwx9DUOcU7NkSqRi0m9z + LBI5paSlxzVFBTuwJHXtTRU1rC9zcJCrAFzgFjxSbSVxNpK5JbW01y4SCN5JOyqMmu58OeF7S3l87xDD + JCjLlNxwp/Gst7TUfBGpW1yssUquoO5eQfarGt+KNT8XyJaQWrCNedqAnJ9TXm15VKtlTdovqeRipVq9 + lSaUHvK+qG6v4huLc3GkaVeyPp5OFB549B7Ve8PeF7BbNtT12fyocZQKeSfetDStL0/wpaDUb4RXtw6Y + 8jHzRk+1cdrOsyancySAmGIn5YQeBWML1Pco6Lq+5hTvWTpYfSPWXVmnqvi+7vLWTShIv9nhsL8vOB05 + rBtbC8vS/wBkhklhX7zKO1WtK0C61Wb94fs8OM+bIp21q3PiT+xdPbS9MVElGVllXkP7iui6p/u6Ku+p + 1Jxo/usMrvr/AJsfqEvhzTtCSK3iaTUWHJ/uGuNmuXmbdLIzt2yc0yWRnYs5JcnJNQ+9dNGh7Nau7OvD + 4ZUlq7vzFyQetJ1ozTvlxmug6hvSkJozR1oGKoJOKu21tPE6XD27GJTk8UltbTRss7RExjnkV0V/4pgk + 0pbSC1VWxgt6Vz1akrqMFc5K1Wd1GnG99/Il1DxXay6StpDbBXxg1ztjplzqLkwrnvTrDR7rUizRIcdc + 1dtby+8PS7XQbfpWKjGknCj8RhGMKKcKD97zNS31240ezazuLccjGawIo11bUtrsEDGn32qNrF4gcBF+ + ldAnhKGawFxBMA4GeDWfuUFzS0lIzbhh1zT0lIpX3gyaGPzYWDR4ySK5WeEwTNGeorcbX9SsRJaCbzF6 + c1nwWMt1IXkByea6KDqQTdV3R1Yd1YRvWlddDN71bsrtrSYMp471UorqlFSVmdcoqSsz1PRtStJ7PLMA + cc5Nc74juraUsE25rmIrua3XCOQKuWVlNqj5LZrzY4KNGo6jeh5UMvhQqOq5aGWepxSVv3+gm1h3D0rI + trUz3AjY4Fd8KsJxuj0qdaE480WFtdyWsgeMkVoG9vdalS3LHHpTNR0kWcSurdfeqNpdPaTrLGeRUtRm + ueK1JcY1FzwWpt3/AIZktLQTBs8c5rnxwea2r/xJc3sHlcBcc1ick0sOqvL+93Jwqrcv77c0rS/8j5UX + Oavvpk8sJuFOc84rBjYxuGx0rZ0/WZIhtJynpU1YSXvQJrQnH3qe5Y067S2JSYYb3pZbtJJyVAx7VRup + BcSl1GM1b0kQCQibGfespRVubqYzgknNrUuxSKykmpLacxTBuoB6Vn3Dhbk+Wflpylxh8ED1rB07r1Od + 0k16noVprZmgWC0jHmEYOapav4TW5tmuWIEmMkDtXNWOoSWlwssRGfSultNYlvpd8z/L3XNeZOlUoS5q + ex5NWhUw8uelojL0fxJe6Bm0mQNETgMfSpdcsdHmeHVJ5QVJBdVpfFF3pwtsIV8zHIFefy3Eki7DIdnp + mu7D0PbNVY+6+vmd2Fw/t2q0fdfXzL2vy6bLf501SIsenWsmgGkNevCPKkj3acOSKiLuPrTw5HIJB9qj + rtfC7aB5TR36gOwwC3Ss69X2Uea1zLE1vYw5uW/occD3yc9afNPLPt8xiwUYGa6vW/CEkZNzYgSQNyAv + pXJvG0blGBDA9CKVKtCqrxFQxFOuuaDEDbQNpwa1NH062vZt95ciOJeW9aqWlsjXkUVyfLRjyxqxrFra + 2V+Us5vMjx1BqpO75Uy5u75E7NjL9oTeSJYbjb9ASOtU/Ly+Bzn07UsaSyMSgIUdWHatKW4srC2CWh82 + 4dcSMRwPpT+HRD+BKK1KFzaJbhcygsRniqhp3zO/UkmpfJIOOD/SqTstS17q1ZGoAILE4PpWjbarfWNt + JbW1yywyj5k6it8eBbmTQRqcc6cLuK+1cntO8jnjrWUKtOtezvYwp1qVe6i72NrR7bRr6G4TU7l7W4xm + KQD5axX2xSuobzFBIB9aHZmbnBppBOBjirjGzvc1jGzbvuCtnjNbWj+I7/RpB9nnLRDrC/zK34GsPBzT + xjjPaicIzVpK4qtKFSPLNXR2LT+HPErATR/2VfvwZF5iP1HaszVvCmo6SDMyrPbcbJ4DuU/lWGpG7JOB + Wxo/iPUNHkzbT5i7xSfMp/A1z+zqU/4b07P/ADOP2Faj/Blddn+j3McqV4I571btb65tYpI45G8qYqJY + 848wA5we+K6U3vhzXx/pkB0y9frNFzGT647VS1DwfqFtGs9sUvrduVkgIY49xQq8X7tRWfn/AJjWLpyf + JWXK/P8AR7Fl9d0nWL6KTVNNW3t4YfLSO2H3j7k81FpXh281GO4vdLuBCIyWjRpMOR+Fc5IjxMY2VlZT + yGGCKWKaSDLRu6EjB2tjin7Gy/dv9UU8PyxtRlb11RsSarrFppctnJ5iW1yfmfby/wBG71Ys4tN1y4sL + fyIrCCCLFxcCT95IfXBODVW28S3STQvdxpdpAhjiSTog+g71S1C6trmVFtLYQID94n5mJ9TS5JbWt5ol + U5X5eXlfdbfcaT+HBPb39zY30D2tqcL9p/du4/2QevpWVf6Vd6eIlu7KW2aVN6FwSHHqK37vwvfWsVv9 + g1GDUQyeY0MbBvLwMknsAKyE1G4e+W+nkuIyo2iZCXAx2Ge1OnOT1Tuh0akpaqSkvx/r5GQAR2Jpc55F + bP2+1ljcTW0E80j5Mq5jkUewHy0jafpl5fJHZ3TW0TJlnvMfK3YZH8625+6On2v8yMceuM0+O6mjjeOO + WREf7yhiAatDSL19zRRGRAhfcvTaO9VXimjRWkicKwypZcA/SqvGRV4S0GbmPUk9+TXQWvjPV7ZYU81H + jhGERkBAFc736UvPbNKdKE1aSuTVoU6qtONzqbzxvc31o8EtpbAuQS6pzgduavab4j0WbzbrVtMR5QQq + +XHhQP8AIriMkUZyAoTLE9c9awlg6TjyrT0OaWXUOXlirejsegRt4Luru5dmkhV8GIElQvH496ptoehy + aRLLBqET3q8lGZQDn0964pgVYqTyPSnB8dKlYSS+GbIWAnF+5Vl031O7i+H8VysLQalAwdfmxj5T6Vpa + TotxbeDdRs7Yxm5vrnyEc/KCq9T+hrzVZZc4V2Hpg123iyV9M0DQdMjdkdYPPcg85asatKtdQc73fbsc + eJo4nmhSlUvzPttbX/Iz5vAetxRSP5CuqnBKuP0qo3hTWrSMXUumyGJRvO4ZGBzzWcNVvgu0Xk+0Hp5h + xUz6/qrwmJ9QnZCMFTISMVuo4lbtP7ztUMatHKL+T/zN5Li7miWQeDrKRGGQyW7jP5GsO+02/uL1pE0i + S1D/AHYY42wPpmp4vFWtwQLGmoyBBwACDgU9PGOvMyKuoSMQcKMDmlGNaLukvvZEKeJg24xj98ijHpWq + xyELZ3AfHIMZ/lV63tnaMTPp2ouu7G6OfAJ/75NWZfEnidpnmkmuPMVcM3l9B+VZ663q0dosSyyC3L7x + 8vyls+tO9aS2X3su+ImtVH5NmvGdZs7hvsGj3luXA3BnZi3vniq89tresvg6OZHhbDH5yQffJpkvivXv + OWU3TiULtHyc4/KqY8Q63C8soup4zIcuRkZNRGnW3sr/ADMoUcRfmUY39WSX/hzWIYRdXFgtvF044qWw + 8Hapf2n2lGgSL1eQA1k3GrX12NtxdzSLnOGckVB9qnEYQTSBR0UMcVryV+W10n6HRyYpwtzJP0f+Z12n + +BHu7YXE2qWsSk4IJHY1mTaNp9prqWVxqAa1ON08QBxWEZnIwXbHpmmZJHNEaNW7cp/gKGHxHM3Opdei + VjuU0zwVbXGJ9VnnQLn5Rjn8qz9MvfDVpqN211ZSTQB825zzj3rlc0A9cil9V0alNu4lgW01OpJ38/8A + I7J/GVlbi6Ww0WCMSnKM3JSq19461S+s2tiIUR12uVTlvc1yuTS5YcDNNYSine1xxy7Dp3cbvz1JlneK + TdHIVcfxKcGmPMzklnYk9STmmEHOT3pprpUUdqitxd1ITRtJGQpxSUxilsjGB9e5pKKKACkpcUoBPagB + tFSCPIBJwfTFaP8AYOorareNZTLbEj96ynb9amU4x3ZMqkY/EzLAJ6DNKuQeOtdte+D7fSbC21O71C3u + YGIMkML4Yg+lZut33h6WBIdI0+aJ1/5au+SfwrCGJjUfuJtdzmhjY1WlTTa79EZy6Dqhs/tpsZ1tuCZS + pwB61r3GmaPoP2K7N/BqjtzJbKDgD61lTeINUnsks5L2UwIMCPdxisw/rT5Kk/jdl5D9lWqfxJWXZdV/ + XY3dU8QibUPtOj250yMrtKRN1+tYckjSsXd2Zyclick0zJorWFOMFZG9OlGmrRQUtKil2Cr1NXIbRfmW + UnzR91QMg1UpJFSko7lZYpGXeEJHriporcyuEjySehPFdLY6G0tqr3832CzPIcjIJqpeapZWtq9jZQLI + Q3y3J61y+3cnywVzk+tc8uSmrv8AAYNESzjMl/KkZxlQTncKoXt7CxaO2jxGe561SmuJZzmSQtjpk1H1 + 4rWNN3vN3NYUZX5qjuzp9A8UyadEbLUIvtumycNC5zt919DTPEWiafbWsep6ZfwyW1w3y25P7xPY/Sud + 7dTu9KRgRwT0qVQSnzwdu/mR9VUavtKbt37P+u4zvU628iok8sTi3ckCTBxmoQM/1qwb24ayWyadzbK2 + 5Y88A+tbs6nfoSfY7m3RLuLJjBysqc7fTPoauahr+o6pCkVxP+7AAbaPvfWo9MbVLyM6XYuzJKdzQ7gN + xFal9ptjb6KZLiZ7TVFOGtiuQ49qwm4qS5ldnLOUVNc6u+ncorFoltasz3Es9wUyoVcBW96yZJWnkLMB + n2GKVEyRkHJPGK7Lw94IuNQkWW+R4bZhw3c0qtaFCPNNirV6WFjz1Jf15HHC2lO4iNmCjkqM4pysXiVM + AFOVI6/jXoo/4oSaa3kihv7e4zt/vL9a5rSdAn8SapMYvLt48lvm7e1ZQxaknN/D0ZjTx0ZxdRq0Oj/4 + BS0q1fWNRgtbi98qM8bpG4FdzqNsngiNLjR7qOZmGJA2Dj6Vzvif+zrG3i0+2iH2qLh5V6GuYN1OYyjS + sVPXJzWfs3iLTvaPbuZOlLF2ne0P5e5o3eszXl41xuzNIfmrbtvB1xdaI+ryTxx7eduaZpNlpGnaQ2p3 + kqyzkfJEDzWFea5d3W+ITOlux/1YPGKfvTfLR0SK9+o+TD+6lu7GjfeLb+fShpg2LEvBZRya519uzduO + 6m78ZFXV04va+erjiumMIUlZK1zrhTp0ForXM/BJyQaG2jpUkkr7NhT8ar9a3Wp0LUXFIaUnNIKZQYzW + nY2DJJHcXERNvnk4q1omh/2krO0gRVGakv8AV2gtW05FVgvG8VzTquUuSHzOSpWcpezhv1NfW9a0uPTU + trGNSxHJ9K49LaacF0jJHrTUAEimTpnmu2tNS0e20o/Kpfb0rK31WNoJtsw5fqcLU05Nsw9G8RzaQTGU + GOnSq+q6tNrd2oVAo6cDrVKbfqF4zQR8egppinsZAzKUbtWqpU1Pnt7xuqNJT9pb3ma8nhqeK0+0BxkD + PWs9dWvLaNokmYDp1qSXX7x7byN/y1kliWOaqnCb/i6lUqdSSftrMu2EkRu91xzk966m5vrOCzBi2k44 + xXE0vmN03HFFXDKpJNsK2GVWSbewyiiiuk6grT0vUGsZd2eKzKXPrUzgpqzJnBTjys7lJ/7XjAB+WsbV + LIWbb4+GHSqFhqcliPlORUkt1c6pIVUE5rhhQnTnv7p58MPOlUun7pUuL6e4ULI2QKq1qz6FcQw+Yfr0 + rLKlWIIwRXZTlCS907qcoSXuCZp6hnOFHSo6likMbZq3sW9tCwLKV13Zqud0bY71aW9faVXvTBaSSZc1 + mm/tGcXL7QsU+evWrGCwBU81nMDG2O9W7afnmlKPVClHqjRthlkEnTNdHcm0TTgQV3YrlXmyMA80eawX + 5mOPrXJUoubTucVXDuo072sT+YQ2Qaa+qPACFOD9aoS3PzEKaWGxurxS8aFhW3so7zN/ZRteewye6luX + LyEtSWtrJeTiKPqauQNBBC8M6YlHY1RjuXtLnzITgitI7NRRrF6NQViW+0+bT5QkuKqE1YvL+e+k3zNk + 1WPNXBSt725dNS5ff3CpUZgBzioh1rXg8PXtxafaYwCuM4onKMV7w5zjBe8zQ0TxXdaZIFlYywYxtPOK + 6mLSdK8Wo1xC6wy+gwDmvNSpjkKSLgg8irdrf3Fm4e2kaM57GuKvhFJ89J2kedicApP2lB8sjW1zQNQs + Jj5sZkiHCuorAMZya9E0bxrbzwi21ZFPGNxFP1bwfaajG1xpci7iN20dKwp42dJ8ldW8zmpZjOhL2eKj + bz6HnAnlSNolchD1FM24960rzSLmwlKXMbLg9cV1fh7wPFrGnvP54D4yBmu2piqdOPO3oz0KuNo0oKo3 + ozjrWxuLtitvEWIHNdT4ZuNHt1kt9VhCydCW9az2g1LQLm4jjQlAcFyKyo4pLm4aSQnk5JFZztXjvp5E + 1FHEQeundHV3cF9Fvt9KuZHtHH3M1b0v+wYdNezvIPLvm4yw6Guf07Ur7TbkTwAyRJxyOK6GPVNE11St + 7F5N5JwH7A1w1YTirdO63+Z5tenOC5bXXdb/ADMPUvCF1bRmeAiSI88dhXOPG6NgqR9a7qaPUtLl8m2m + N3AR93rVhZdGu7JoLy28m4x3GOa0p4upBe97y8i6eNq04rm95eW/3HnODmkKkDODiuvn8F3M0JnsmEid + dvtXPXVncWb+RNGQR2xXbTxNOp8LPRpYulV0g9SkFyBTyhQYZWB7ZFbOhJbR6gkl3GCi8kGtnxjrGl38 + EFvp9oqMn3nFS8Q/aqCj8yZYqSrKmo3Xc4zJ7dKv6fq99pk4ltLl4nHoeD+FUMYzzzSlCoBZWAPTjrW8 + oxkrSOmcITVpI6xfE9jqKeVrWmxysx+a5i+Vx70XHhzR7u18/R9XVnP/AC73HDfSuT4zmhHIcEEgjuK5 + /q/K703b8jj+pcjvRk4+W6+7/I1b/wAPatpnNxZSKuM7lGRisrHXINb1r4t1e0iNut0ZYT95JfmB/OtU + 654a1WJU1LSjbSgY86A/ril7WtD4439P8he3xFL+JDmXeP8AkzjoppoVcRSSIHG19rYyPQ+1aI8Q3Q0U + aOEh+y7skrGNx555rXk8LWV3Ztd6Xq0RTPEUpAasa70LVLIBpLRymMhlGQauNalU3389Co4jD1nZvXz0 + ZPrFzoM9hbnTrSa3ux8sgJ+UjHX6msHPGO1PkRlkO5Ch9CDTCMVvTioqyZ10oKEbJ39S5Cl7NbkQR3Dw + ggERgkZ7cVdj17U7OeIXDCVoEMSRXMeRGp7AHpVa01e/s7CS0trgxQyMGbbw2R79an0i7hh1ZLrVI/Pg + fIcygvn/AOvUTV07q5nUjdNyin+ZJbalpTeRHfaUGVWLSywvh3z29BQ0OgTxt5VxdW8pY7VlUFQCeMke + 3WqmtXGn3GqSvpsBhtc4VSck+9Z3XvRGndXTaJjRuuZNx+f/AA5stocTxF4NTtJD5ojVGbaSP73PQVGN + AvWmniiWOZoV3M0bgj8D3rLyacsjofldh9Diq5ZrqWoVV9r8CT7HMY/MEEhQnAYLwaYY9p4ycdcrVmDV + r61AWG6lRRwFDcD8KW21O5tn3RuhOSSHQMCT9ad5l3qa6Il0SxOpa3Z2g/5ayqCAO2ea0/HV6t14quVQ + 5jgxCmOwUYrU8DzNc65danPHFttIGkyqBRnHFc1canb3FxJJNYo7u5YsHIJzXMpOVdu3wr8zgU5Txjdv + gX4v/gIyyxxxUtyQRCB5eQgB2f196vS3OlFl22EgA6/veT+lRiTSieba6UeiyA/0rp532Z3e0f8AK/w/ + zM7mno7RurocMpyD6Gr2dJJ+5eL+KmlK6RkYkuwO+UX/ABo5/JidXvF/cM/tfUdki/apNsgw4z976019 + Rvnt4oGnYwxHMa9lqysOjMP+Pu6X6wj/ABqQ2uh8bdSuffNuP8ajmgvs/gZ89OP2PwKTahfPIJGnYuow + rHqKZNf3l1H5c07Omc4NaRtdBBH/ABMbkjv+4A/rSpb+HssXvbzA6BYRz+vFHtY9n9we3gtov7mYe00Y + roFXwwFIZtRY5+8AnApqzeG45WLWt7LHj5QZFUj9KPbf3WP6z2g/uMHBoxmugh1Dw/Cp3aNLM2cgvcY4 + /AVWvNQsJ1dbXSIrcMQQfMZiv51SqSf2X+A41pt25H+H+ZkY7809IZJM7EZsDJwM1qvrchNsY7OyiaD7 + pWEfN/vetK3iHU/OmljnWFpRtcRIFBH0Ao5qnb8R89XpFff/AMAqw6PqM4hKWc585tsZ2EBjVweGb2O+ + S1vZILMuu7dNIMDFZ8moXkwVZLqZlT7oLnC/SoCzOcszMT60rVH1SBxrPql8jozoWg2kii78QJKuPmFt + EWx+dUtYk0FYoY9IjuSyffkmx834VmJbyyD5YXYHuFNasPhnV57R7hLIiFRkuazsou85mHIoSUqlVv7k + jLmvp5YxGdqoOyqBmq23jNW7Oye8vFty6xknBZu1dXp/h/QLW6ubXVr5GlCbo3Vvl5H86udWFPQ2qV6d + HT8jh8VYt7SW4mSJIpHd/uqo5NFzHFDdyJDIHjVjtb1FdNceLg9nYC2tEhvbTH79eM06k5pLkV7jq1Ki + S9nG9/wKNh4T1C81ddPaIW8rLu/fnHFbsPhHRbKS7tda1dILmEZUJypBHH/6q5/WPEmpa1eJdXUoEiDC + mMbcCstpJJH3OSxPdjWHs68170rehzOjiaqXNPl9O/qdbba5oVr4fl086Ms13youPX0NZ8/jHWptL/s5 + 7ofZwNu3Azj0zWJDDc3MmyGN3Y8YRTW3YeD9W1CF5lg8qOPhmkbGPzodOhT1m/vFKlhaN5VWt76u+pgM + 7NgFyQPenRRSTShIo2dj0UCt/UtCstEuLVpr2K8RjmWOM8itG/8AFGj26RLoem+RNHyJmOTVPENpeyje + 5TxbaXsIOV+uyM+w8F6pexG4kVbeBfvPIelaF/onhbT9IkVtTMuoYyu3kfSsK813VNSZxLcuQ5yyg4FZ + DK2Tk8+9SqVabvOVvJEqhiajTqTt5L/MYevFSRwmRGYHlRTOlKDjpxXYz0XfoPUkgJx9a3NB1yPQzM72 + sdxKwwu/kCsEClAz1rOdNTVpbGVWlGrHllsXb7VLm/kdpZG2schB0H4VS4HXNOKEcEH8a6PQrvQ10i9t + NWtyJ2G6GZRkg+lJtU4+6iZNUYe5G/ocwVxg44NSCMhVcgEZxipY45FV5kiZolPzNjipBbs8YnA/dZ5A + PIq3I1ckauqf2ZqcdjbaHp0y3CR/vyecms6zmtbOC9hvLJpJ3XEbdNhrpPC9zdxPPbaVbo8sowk0i8xm + qt54cu5LO51CadDcRuRNEeCDXHGtGMnTlt+J58a8YTdKbsvXU5ZIZZFZkjZlUZYgdKYBnPNbltr1zY6T + Np0MMOJj80hXLfSm6VoFxqVyEP7mMjPmOOPpXS6vKm56I7HW5E5VNEYys8bBlJU9iODTmmkkbMrs/wDv + HNXNT06bTrkwynOOlUWA7VcZRkuZFwlGaUkKpKkENzniu00/xxqdnpYsXcPnhXbnaK4mpEfBAbkVlWoQ + qq01cyxGGp11aornr2haRpotf7Uv7lJ3cZO45xWP4ispSxu9MU20X+ycbq4/T9Ue0njYOzxIc7CeK9F0 + S8sdf/f3tyEEX3YugrxK1Kph5+0buv60Pna9CrhKntW+Zf1pY4/SrO0mlk/teRkbGQXHWs7UNFaNHnhX + /R8/Kx7ivRdR06HXL3KbYrWAHDgffrk7xrt5vIcMbGN8bgOMV0UMU5O6fyOrDY32krxdn1Xb/gnGyKwX + BJwOg7VCxOa7LVrSxuGjisQCcc4rntQ0mezwSPlr0qVeM99GetRxMZ76MzlPPNTmd1Tajnb6ZqseKM4H + FdDSZ1OKZaluFeILt5qpmkzVi2tJbtsRrmlpBak2jBXZEkbyfcUt9K6Tw9pllcwyPduFKjoadoL2umTO + moRAN2yKzdVuFlvXe1yqH0rmnOVVunHRdzkqTlVk6cdF3I7i4ezuJYrWUiPPY03SxBLfr9qb5SepqoIZ + n5CMw7nFBTC55BrbkXLyp6nRyLl5U9e52WrafpX2LfDKmQOmea4sxl2YJkgULKxYBnbbn1rp7NtNjsiS + y78d6wSlh49ZHMlLCxs7yuZOj6gunXG6SMMPepNc1WK/kBiQKMVm3jK0xKYxmq1bqjFyVR7nQqEJTVVr + UKKKK3OgKKKKQCUUd6KYBRRRQAoNbOiXkVtKDIBWLSg+9RUgpx5WZ1KaqRcWd/dahFcwbIgCWHSuaudE + uWLSAdecUmj3qxTAOc/Wu1+22gtM5BOO1eTJzwsrQV7njzlPBy5aavc81lieFyrjBFR1u6nYzXM5lRMJ + mtqw8K20uneZIw3lc/Su6WLhCClI9CWMpwgpS6nFK208VdjumKhF4zUF5bi2uniByAagDFTkV0WUlc6b + Kauak2mN5Pm7skjNZhBRvcVcW9uJUEK5Nadp4ZubqHzCCCRWLqKkv3jMXVVJXqsxElZTmrMRe6kEa02/ + 0+bT5dkgqK3uDDKrqOlaXUo80TS6nHmgSXdjLbN8wyDzmtvw7rcNjmKdAVNNu9TtbmzAZR5gGKwBE8pJ + jUkCsbe1g41FYw5fb03GqrGpr9zbXF0XgHWsWlYFWwQQaSuinBQioo6KVNU4qKFBNT21uZ5cZ4qOIIfv + Hmpt5iO5Dg05N9Cm3siW702S2w2Mqa0NL8SXOnx+SfnixjHpUUesCW3EM6g+9QtZebl4sY9K537y5aqO + dpTjy1kbbafZ6yhlhcLKeSBWLdaXd2jkbGZAetVUlltJsoxRh71tSeKZZLA27xKzYxkioUKtN+7qjJQr + UmlDWJhh8tjvW9o3iK80qYMkpKf3Sa51mLMWPU0quVNbVKUakeWSOirQhVjyzVz0HVfE0Gu2yReSBLjB + pthZ6vosAvYmKwkZK5rE8P6Rc6nJ5kJ27ea7Rp74xxWF8oW3BwWA7V41flo/uobdUeDiPZ0P3NOzXVMz + V1lNbuUtbrEcbH5j3NXdZ8KW0cKf2W4eRh90HNWNb0fSxbRR6biS5YdE61hRT6r4Zu1llBPseayhLm1p + O3kc8HzWeHfL/dfUvrqlvoeiPp97YFbph97GRXENEzs0q8DOeK7WHV7XxFqiHVAkcY6VNq/haG8n26K6 + soGWx2relXjRlaas3v2OmjiY4eXLVVpPd9DkdK1280u7EqtvA/hbmtlb6DxNqSLMFgHcjisaXRrmO6aG + RCCp5Kjik+wmBjsY7h0IronGlP3ovXudk4UZvng/e7naT295olxFDpdz54bqnXFXJP7NS2e71WNRcheA + a47S9SvNKuhcOrOD3anajrA1a5aS4G0EYAFcTws3Ja6d0edLAzlNa6dWt2Zl7PHc3TtCuxSeMUwWyxoT + J3711vhbQrB1lvL912AHaD2rmtWniudSZLQARlsDFdtOqnJwjsup6NKtGU3ShsupV0/R7jU7zyrZNxz3 + rstWvtOsNHTT73TAt0qYD44plr4f1bw/YLq1tMmNuWVhXJatrFzrF2Z7kgEcYFRriaiafuoy/wB8qqzv + GPbe5Vt4bS4kk8+byRyVqk4CuQrZAPBqRkBHvTCmMe9elE9eKt1G5496bu45qw0bQhSy9aU2xaEzZwPS + quh3REJCMAMR9DWvZeJNV04qILtyB0VzuH5GsPBJqxb28lxII4VLuewFROEJL3kRVpU5L30mjeXxFBc3 + Dy6lp8U7uMbkG3FTahD4Vl00TWMtxHdgcxOMgmuZkjeOQo6lWHUYpM8+9ZfV4ppwbXzMPqcE06cmvR6G + lpmg3OtSvHaFdyDOGOKi1DRNS06YQXNvIpPQDnNQQ3U1rJvgldH9VOK0V8S6oLiOaSfzXjGF388U37ZS + vGzQ5fWYzvGzj26mI0bocMjKR6im49K7CHxbayMTqOlQzZ6leDTvtnhG7c+baT2+f7pyBU/WKkfig/lq + R9cqx+Ok/lqcbg5o5rqLPSfD99eTIdTa2hH+rLjrSDwt9rvJYLDULeWOP7rs4Xd9Kr63TXxafIv69STt + K69UzmM80u7JzgfhXQXHhPVrZN/lJIC235GBzUD+GtWjHzafLn2GatYik/tItYyhLaa+83dGP9neANTv + eA904hX6VxDA5rtfEENxa+GNK0qO3k3gGWUBehP/AOuuQa2nUYaJx/wE1jhZJ8077v8A4BzYBxfPVb+K + T+5aL8iuc+tGT61saamnrp14b0Ynx+7BFY5rrjK7a7HoRnzNq2wUUYoxVFmgtnGyAC+hGRnB9aIYIWxH + JLGpMgBk39B64qjtxRg+lRZ9zPlfc2V0yxN+IG1JBDgnzcAjP51HPY2KTyxx6irqi5Vth+Y+lZe0+lWL + O7msJ/NiC7sY+YZqeVrqQ4SWqkV+VbkEfUUu1iMhT+VWLy8mv5zNMF3Yx8oxUkeo3EcBhATae5Xmquy2 + 5WVlqVVALqrfKCcE+ldLqnh7T7C601U1JZIbrBlbj93XMszOcnrSnccZJP1qJRk2mnYicJyaalY2PEGn + 6dpespBZ3gu7XALOv6ite7l8HR6f/o0DtdFepJIBrj+/rS7GP3UP5VLpXSvJ6fiJU7JKUnoJ/F93Iz0r + sG1DRv7A22+kbp9uGlPY+tcsLK7cJi3k+Y4X5TzWlbeGtcuY5QkLokYy4dtopVfZyteW3mZYhUp2c5Wt + 5k58U3zaX9iRIkjAxuVQDVJPEOpxWxt0umEXTGaqS6fPBbiaRkCk4A3AmqeeaqNGl0RpChQa91JkhlYs + Xz8x70mGfkkn610uk+FYdQsFvJNRhiQ9VY81ox6d4UsFH2m+aeQdQo4rKWLpxfLFNvyRhPMKMW4xTbXZ + HFxxFjgAk+gFX7bRr66cRw2zlj0yMV0v/CT6Np7kafpivjo0lZt94v1G7kLJthXsEGMVPtq8/hhb1IWI + xVT4Kdl5v9C3aeBbx2Vb64iswef3hHSrE2n+FNIR47m9a7nAwPLHFcpeajfXjhrm5kc4wMntVQ46mhUK + s9ak/uF9VxFTWrU+S0/E6nSfGMuiQyRWNrCSWJSR1BYCsu/8SanqEsjTXbASH5lQ4H5Vkl/m+WmFeeTW + 0cNST5ranTDBUIzc+XV9R7N8xJYsfUmkDkcirul29pcSuLqTaoHFVJljSZ1RsoDwa2Vr2OhNXsCyHfnc + a3dC0a01VZ5Ly9WARrkAnGa58U4EjoSM+lTOLasnYmpByVouxJNEqXDxxneoJAPrSCNi4Tad3pT7df3y + FiVXPJHata6FskySWbF3ByWPeplPl0JlU5Wom34TttMt5pLbXoPKEyfu3YcViX9tbafrxFsRPbK+4D1G + elaeqazJrVlbwyWyrJEMBlFZa2+GAIIYd65KafM5y69DhpQlzyqTdr9OnqX/ABLqH9pS280Wmi1jjTGR + /FWAyGd84AzXU7LrUYUgWLdjgNit7SfAsZUPecEj7tZSxlPDxtIxlj6OEhaen4nEQX93baXNpqCMwysC + WI5H0qGaNNOmgKypcIQGdAePoa6fxd4X/s2MT2ufJPUelcdCGByibiO5HSuihVhWhzx2Z1YWtTxEPaQ2 + e50dp4ht7W/+0wRNBbsuHgjP3qjsNKvvEmokQmWG3kbJaQnAHuaq/wBki1hW8nniB4YR9Sa3P+EjvNWs + RYW6xWsUa5LLwTWNT3daS+fY56vue9QXk2+n+ZR13wu2k3qw2UhunQbnKchfrWrpHitbfS2sXsRPdSHa + pPAFUdM8Sz2MD2OxHV2xJIRlsd60Nd0bTYbOHUNLucynkqTzmsJtu1Osr9n/AJnNUblaliVfs/8AMhv/ + AA1LpKwatqbpPGxy0WeQD2FYusWdnql55miQOBty6kVd07VBLqUba27yxJ0Run5VcvEnmv31DQbdorZR + 8xxw34VUJzpy9969+noXGdSlP33r32j6HBSI0blHBDA4INMNdRqwsNRhiNpGRek/vBjvXP3dlNZvsnQo + 3vXpUqymtdGetRrqaV9H2H2s0SRuJBkkcUW9zJDJujcjnoDVTvRnBq3BPc1dNO9z0zw94vtDCtveKqqB + jnvW0wOuj7PZQqlsTzJXkLsioNh+aul8P+LrjTU8kthTxmvGxOXct6lHc+fxeU8t6tDfsb+r+Hl0aRZI + ZN0g7dayC5v71IbxfLTtkda7GCXS3046pcXAeXGcE5/KuF8R+I7XUDi1i2EcZFZYV1ar5Wr+fYwwU61W + XI0219rsVvE2l2FoQ1tMpOOgNcuallkeRsyMSfeo692jCUIcsnc+lw9OVOCjKV2Axxmuw0H7K1ofKZRc + AcA1yAQnntUkckkD7o2Kn2pV6XtI2TFiKPtY8qZuX6S3N0RPtUj0pYNPNwVhjUZ9aqaXL9o1BTcvnnua + 7DWTa2VnHPauokAzxXFVnKm1TW559erKjKNKK1f3CW8djplqY76MBscE964vVrqGW8cwKBHT9S16fUUC + PjisgmtsLhpQ9+e7NsHhJQbqVHqxKXccYycUlFdx6QUUUUwCiikoAWtCx09pzl14qlHjcCa1rfU1gTbg + cVjVcrWiY1nO1oGbKvyniq/erXB5qGXG7itEbIWKGSY4QU6W2lh++taWkzRJw+M1dvTHOmEwTWEq0ozt + bQ5ZV5RqcttDmaKnmt3iJOOKgroTT2OlNPVCqxByDg1r6TehZgJmJHvWPS5qZwU1Zk1KanGzPSkaC9td + sO0nHX0rC1K4vNNgaOOb5T2rGsNXmsUwpzUF9qU185LnivPpYOUZ66xPMo4GUKjvrEqSSNI5ZzkmmgEn + A60qIZHCjqa3o9AItRNu5xmu6dSNNano1KsKSXMU7CFredZGGV7128/iC1t9NUwlRIBXEterGhiIG4cV + nSSs5OScelctXCrESTn0OOvg1iZKU+hoaxq76pMGZQAPSswGkqxaRpLcKrnC11xjGnGy2R2xhGlC0dkQ + it7RZbc5SQAe9aE2gQy2YaAgnGa5qe3ms5CCCuO9YKpCunFPU51Wp4mLjF2Zb1iKFJiYyD9KyqkLF2yx + JpHIPSuiC5Y2OmnHljZsZRmiirLFzVq3vHgbKnI9KqUVLSejFKKkrM1mMN2m44D1Sktnj5xketQBiDkH + FXob0bdsgB471HK47Gai4LQpdKXNWHiErFkquylDgiqTuWmmbeh+IrrR5B5TfJ3GK6u88bQX2n+X5YWQ + jBNecg+tOUlTkGuWrgqVSXM1qcFfLqFafO1qdVpOuzabemYfP6A12em27eMJTc3jqkaj5UFeTLOwOa17 + LW7y1QrBKVB7ZrmxGDcvehozmxeAcvep6S7m14ls7TTtRaC1kB29SKk0bXr7TspbAuW/GudFy0sjPKxZ + 26knrXfeGjotlpD3c0itc4ztNZV0qdJRkuZmOKSo0FGa52X7PWtPFm/2uNDcN1+tIvhy1vrb7RA2HbkY + 7ViWOjv4p1GSZP3MK9NtTXcuoaLerY2shlPoOcCvPlSs7U5Wl1R5UsO4ytRlaW7XYj1bRb5FESIHA7gV + mWulGOZXuI/lXrkV29r4gS2tc3ybZMck0X17po0WS5+Us46CiGJrJckkOlja8V7OUfmjjNWv7dY/KtWw + emBV3wx4ew3229t90WM5Paq+j+Gp9XlkusbYwcqK09Y1e70fT/sAQcjG4V0Tlp7Gk9XudlSen1eg9XuZ + XivxFJLnT7CdhaDquazPDeirql+ouTstxyzVQjg864G8k7jya9BhltNC0PMQWTI5B61vVl9XpKnT3ZvX + n9UoqlSXvMxvGFnoNhapHZbXuO5WuEILHIq5qFy15dNIBwW4FSraAWhlHDeldtCLpU0pO7O/CU3QppTd + 2yn5jtt8z5gO1T3l4k8KRxpt29fetnRvDT6hp1xeyOFjiBPWsIW7O7GMEqD1q1UhKTXY1jWp1JNL7JXK + +Xx1zXS+Hli0y3l1WUkSKCsYx1JrHs7KS5uljxkdz7Vt3zLeT22nW4wqcHHc1nXlf3Pv9DPFy5v3fTr6 + Gl4X0G91SeXVDbwzoSSUkOM/SsvXLjTo9Ukik0kRBeCqvzXZ3UF74W8Oo9pe7MjO0jPNeY3U8l7cvPMx + aRjya5MK3WqSm37uyPPwTeIqyqN+6tFa6LKw6LOkjebNA4GVUjIpNH8Py60ZvIuI08sZ+c4zWeVCjBFN + DOn+rZlJ64OK9Hllb3WetySSfLL79RlxE1vO8JYMVOMjoaaUkHVeKWSGRMMwPrmmNLI3VuK2Wx0LYYT2 + qSKRg3DFfoaZ9atCzuGhEixjb60O3UHbqLHqFxEwKXMq4PGGrtfA13qOoalLJNeSvBChYgnINef455r0 + Pwso0zwhf37cNICoJFcOPUY0tFq9Dys2jCOHaSV3ZL5mVf8AjLU49Sn2So0YYhQyg8Uw+N7542V7e1bI + xny65aZy7sT1JzTMnGM1rHB0bK8Tohl2G5VeCJrm4a5maRwAT2FQE5xRtyM0V1RSSsjujFJWR0PhnTtL + 1CWRdSufIUD5Wzip7zRtGTWha2+pA25XJkI6GuYBpwPNc8qM3NyUmcksPUdRzU2k+h11x4Z0eK2eVNah + ZgMhQOTTbbw1pM9ukja1EjMOVPauX6r1oVsdaj2FW1vaP8DL6tX5be1f3I6lPDejHJbXYhjtiqs+jaUl + lJPFqgdlOFXHJrnwwJ5pWbAxTVGot5sqOGqp3dRv7jqodF8OtZLNJrBEmOU21SS10GOVxLczMv8ACVFY + Abil389KFQl1mxrCz1vUf4HSRReGEtg8j3Dy5+70zTrm78NG0ZbeylExHBLZArmC2aBk0fVtbuT+8X1O + 7u5y+86hfEGkw6d5CaPGZiuDIT+tUofELQWD2qWsGG/iK5IrDxnrSgAVSw1NFRwVJXvr13Zsz+JdSnhi + iMwVYjlNoAxVKfVr6d2aS7lLN1IY81TI9KcsLyfcRmx6CrVKnHZGsaFGGyRGSWOSSabTiuD6UpQrjPet + bo30ASsF2h2C+gNNBJOPWkPWnDggjrRZBZI37TT7O50x25FyPXisi4UxuV3A1dh0y9msGvQD5Cn5iOwr + qo/CmiHQzePqSebsyFLc5riniIUnq7nn1MVCg/ed7vocEiySthFZz7Cm4YHGDn0rrfCGpWulXsq3Nmbj + fwmBWd4jtJodUeZ7RrZJTuRT6VpGveryNehrHEt1vZtWXR9zBOaUIzdAalCktzU7xSW6DOMNW7kdDnbQ + pY9qcqFqlEZJzVhLdjzjilKaQpVLFZIxnk1bjsJpgTDC7gddozVqLTiwzXUeGNS/sdpIpLXz0cYHHNct + XEcqvHVnJXxTjFuGrOQghByrDB96sxQbDnvXSHw7dajfSXCw+VG5yBjpXT6f4Ss4drS/M4rjq5hTivM8 + 7EZtRpLV3fZHGWGm3V0R5UR474rqrTwhGwV7k5PpXQLBFbDbGqqB3qpda3bWiNvcFx2Bry6mMrVXaGh4 + lbM8RiJctJWLdvp8FnHtjQADvTLjV7ayhYvICw7A1zFz4muL1WitxgeorGtZp5LwwGMyyN3Y9KKeBlP3 + qjCllU5tyrMv33iyLVpTZTkQ2zZ3NjmsWNZTPNY6RCHil4EjLz+dT32iwWF55l/IuT820VFqHi0rbJba + fEtuEGPMUckV6lKmopRorT8D26NKMEo4aN1+Hr5i6PFY6VrSrrYEiD8cVD4r1DS7rVd+joYowMHbwDXO + vLLdXGXcs7HqTU97p1xp7IZh8rjOa7I0EqinJ6noRw6VRTnLW23QhSUwvuU59a0dO1T7LdrMy+Yo/hJ4 + rNZkjbI5BFRKxz8vetpU1Nam8qaqJ3R32o6dYanpf9prcKk2OUHasmx8Q38Fp/Z8LqqOcbiKxIJmWRFk + LeVnkZrrdTXSbrR4fsIUXCjnHavPlT9naE9U9vI8yVJUrU6nvJvTyLsnhq0sNOTUWus3X3gAe9Y0znxJ + fpBdKsDY4OMbqz9P1uWy1CM3mZY4z0Y5rX1/XbXWpIk0y3ZZVxkqKlUqsJ+9r59jONGvTqWnrf7XY5fW + dFuNIujHJgp1BHpWZXc22hahrJC3shwo4B61keIPC1xpB3gExnmuyji4NqnKXvHoUMdTbVKck5GXY6XL + fZKnCjvVe6h+zSmINnFEF7PbIyRsQGqBnLsSxyfWutKXNrsdqUua72LK3U/kmHzWEfpmqx606KKSZgka + kn2rodP0AKVmuuE96zqVIUldmdWtToK7MaDTri5UuqkKO9VZYjFIUPaut1DW7ayt2tbNVPGM1yUshlcs + 3U0qFSc9ZKyJw1WpVvKSsugiuQMVfstMmupFG0hGPWs8AjBrptJ1+C3tTHLGN2OtPESnGN4K5WJnUhC9 + NXZFqvh2XSoUnWTmsWW7uJkCO5Kiuoglk1mby5JT5OcgGna3otraWoZCCcVy08RytQq6yOOniuSSp1tZ + HF80lTtbyKCxQ4qE16Kaex6iaYCkPWg0lMYtFWoduwcDNQyLmQhabAjAJYAdTXV6N4cW6j3y96yLKxzh + nHNdZpepxWcWyTGBXnYytPltT3PMx1eajaluYmseHhZZZOMVzbcMR6V0viDXvtbGOMgj1rn4IfOY5rbC + up7O9Q6MG6vsr1dyHe3rSZzSUV1nWOUkcg4rRs7kA4Y81nKjMcKCam+zzRjdis5pNWZE0pKzNueFJYsj + FYs1s8ZJxxVq2u2yFY1pSLHLD2rnUpUnZnMpSpOzOc6UlWp7Z1YkDiqx4Ndaaex1pp7CZp8aGRwoplPj + bawOaHsDNH7Gsce8NgipTrsy2pgX6Zqo0zyJt3VUeMrWCpqXx6mCpKf8TUazFmJPU0lKoywFSyRgDitz + osRKNzAetaAtFWPdnDVnAkEEVY+1vtwe1DGrdTV07WpLWTZI2V6c10UkFnq9vuBUNiuAzk5NXbPUJbR8 + qxI9K462Fu+eGjPPxGDUnz03Zk+oaVNauSqkpmszGDiu4sdUtL+Py5tobHeqOqeHsgy2+DnnAqaWKcXy + VVZkUcY4y9nWVmcrRUksLwsUcEGlgge4lCRrkmu7mVrno3VrjAAR70Mu3FdGPCN19k84ZJxnFYM9tNbs + VlUisadenUdosyp4inVbUHexBS0YoxxWxsSRytGeDT3lEvUYqCgUuVC5VuWLe1kun2xikntpbaTZIMGp + tPvTZTb9oINS3t8L64VyuFFReXN5EXlzeRQzTxJjipPK82TEYpjwshwwp6Md0yWN+etWUlZTgMcelZ3I + PFPEjetS4JkSppnWad4kn06HZbNsJ4rsPDEcbo+o3EgluHGeTXK+GdHstUs2MzgSdsnFUrm4n0S9aGCc + sgOQM15NalGq5U6ekup4mIoQrOVKlpLr5nb3SyanqAF1bGO1Un5sVh39jHqGqpZWM37sdeeKcPGrTab9 + n8keYRtzW5pPh21m08X0d1i4xuyG6H6VypSoK8tOxxxU8MrzVui6/MlgGq+GLYAqskAGeBya5+4vl8Q6 + gN6bEzzS6h4i1GVm03cJucBq6TwxpUdrbf6bbDLjO4ioa9jH2k17zJkvYR9rUXvPa35kMXhexMRMMis5 + HTPSuQ121ks5PK8wsM9M11GuS2+mXJlspue+DXMIsuq3heQlix7dq0wznf2knoXg3UT9rOV4+ZnWdosr + j93uB6kDpV2LTY31eG3EoWInknpWg1t/Zq+TE48x+2K19KhS1sn/ALQtCxbkSYroqYlpcyOqrjGo8y67 + f5lPxMBb+Tp9gyorjDiNuGpFtf7K0YWUtgHlm5Ei9qWx0eG7vncylFHK5NbNtbzC6Eksomjj6A+lc8qy + jFRRyTrRp01FO9tX5sw4bOy0rSnuXBFwwwoNM8M6IupzvPvKuOQc1o+IryDUrqG3ii2hTg8VqSaTZ2ej + edBMY5dv8LY5qZVpcmu7JniJRp+83zS/I4zxRdXpuPsTz+ZFGeBUXhfRf7S1RDLCXhTlqrSBmmZpXLkn + qa9A8NwS6Po7XSQ+a8gzha6atT2NDljuzqxVb6thVCG70Oe8Z6bodlADajbck8p6VwZi7jrXTa3evret + 7pIxHzgiuyOleHLbw2Wk8tpgn45qqdd4enFS1bHSxTwVGEal5SkeSyGWQbWbIqu0bZPFdNotrbyapJLP + EzWq55Azis/VLcfapZbeJltyflJHavRhWXNynsQrpz5DLt4986qwJGeQK078GICO0lYRgfMM1e8J3Fla + 3kj3oBG3jNZWpXP2jU55YRtjZuAKOZyqW7D5nKra2iKCqWbb3JxXoOvH+zfA1nZjhpcEiuP0izN3q0EO + M7nGa6Hx9cn7VbWobIiTGPSufEP2lenT7anDjH7XFUqXbV/I4puTQOopcFjxU1m4hukZ03KD0r0G7I9a + 9kW5FhOn7gADWXWtqUySDMcewMeFqg1tIiBiOKmL0uKErq7IMHNTQwSzyCONSzHsKvWWlXGoKWhXO32q + 3o6y6frSB4S7A/dHWs51kk+XdGVSulGXLq10K914e1CytxPPCyoeckUzT9Ku9RLC2QttHNeh+KtVkuNE + 8k2ckQI6sKy/AV8LNrlWi37hxXBDGVXQdRrVHmQx9Z4aVVpXTOMfT7lZmj8s7l68VHDaT3NwII0Jk9K6 + ltQWPWLsvCxV2zjGcVStdQSz1wXMUWQT93FdMa83HbWx2RxFRwvbW1zLu9Ju7BlFxGU3dKuHw1fiy+1b + P3eM5rZ8T6rJqXlbrZogvIJHWrUet3x0L7Oto7JjG4CsZYityRaSuc0sViPZxkkrt6nKWOi3V+W8ofd6 + 0SaRLFMsbHknFdB4buLuOZ1ggEmTyDTNduLgS/voRG+e1V7ep7TkNPrNV1uTQZZeDXurhYjMORnIqTXv + Bv8AY1iJ/N3H+dP0Z9XuJBLauAV6VpXena1q4KXlx8i/wgVzSrVY1femrI454itCsueorId4Z0HStR8P + yTShfNAI57VF4UfSrMX0F6ELqxClu4p3hvQGlup7Q3DoF6gNjNUDplvp3i5LS4bMLHqTUOSlKceZ9zK6 + nKpHnbvqcxqUaPqcvk42M/y1paj4XudP0uG+eRWSTsO1a3jjS7OxuomtGUhhn5e1Jbrb3vhl2ub9zJH9 + yMv0/CuxV24QlHY744mTpwnDbZnGbDknFbukeHDqthNOj/NGCcVkoMMQwroPCmpyWN/JCgysq7cVvXlP + kbhudWJnNU24bl/whidbnSLmcpEwIwaq2sdlouukTFZoEfo3IxVS6DWPiENKpCs2a0NY0mO7ljlsxtVx + yfeuKSSneT0kjglGKqOUnaM1+Ja8Sanpg1O1v9Jg2hQC2FwDUOt6pdeKbNZFtAqQjGRWkxsJPCsdjKii + 9j4yvcVn6LeXdnHLYx2m8uMAntWUHFK6Wse/Y54cijzJe9F6XfQ5NLUufTFaJgEsADnO3pU9xYT291sl + XYzHNdlo/hC2lhWaaTcCOlbYjFxhFSbOjF5hTowU5s4OGzHmAKpJ9hW/baDd3SqUhKj1Iru4dEsbQ/JC + vHc1aaaGFOWRQK8urmUpO0EeJXzuVR2pROasfCAUq1w/4Ct2DSbK1xsjXjuaqXHiO0gJUMGPbFYupeIL + p490UbBP72Kw5a9Z6s5fZ4zEv33ZM6ueaKKMksq49Kxz4gTDJCpaQdKzNPFxeBGlfKtxk9q07vRxpbJd + oAwH3l9RQqMIO0tWVDCUqTcZu7KQn1HWJjHGChXqM4pLvw4RZtLK+JV6gmln15LedZ7IhXIwwrGvdZub + uV5JGf5u2eK6qdOd/dVkd1KlVunBcqLmiXFtabzLDu5Izis7VdQibUPOtfkYdMU20U3NysPmFFbrSazp + sOmyqYn3E89c10xjFVNd2dsYwVX3t2Y2o3E07mS5dmJ4BJqxZaVpjadJc3N0A+Mhc1T1S6863CBMYrFy + zcAnHpXpU6blBWdj1adOUoJJ8o53CykxngHg1ZudRu79Y45H37BhfWmW9k0zqrHaCe9dHNoK6fYrcxES + NjOBzV1KsINJ7l1a1ODSer6GTa6U77XuTsj9TRfRW8beXa/PjuKZLqE10wWVtqjsKkW5hijIUZJqUp3v + IlKpfml9xXQK8RDcMKSOeWEFY24qe10y71GQ+RGSDXXeHfDdms2zUDtl7Bqyr4mnSWuvkY4nGUqEW5av + sc7pHh271ucH7qdya7Cz0eLwvdJJOiuh6k9qtawYdCTzbSVVA52g1zOteM11Cy8vAL9M15zqV8W/d+Fn + kuricc/dXuM6XxJewQwJqFlcojjnYDXC6x4vvNVgEMgG0d6wZbqaUbXkYr6ZpkaNK4Crk16GGwEKKvPV + o9PCZZToK89Whh5q7ZaZNdyABSF9a1bHw/uTzpmAUc1avNXtrKAw2wUuO9azxDb5KWrN6mLbfJRV2TxW + 1lpEPmSlTIB0rG1TXpbtjHGdsftWZd3kt2+6R8+1QRjfIFJwDTp4ZJ89TVjo4NJ+0qu7HIrSvtHLE1p/ + 2Ky2/mu3bNSrHa2cIkyC1UbrVJpsorYT0rRynJ+7sbOU5u0NEU3ypK5zio80uGY8AmkIIOCOa3R0Ghaa + nJajA6+1bOmz/wBpTA3EnHoTXLVNFO8JzGSKwq0FJO25z1cPGabjozstajsYLTahUtiuQFpNLuZEOKuC + K5vFDsSfat/SLm0SBoZwobGK543w8NNWcsebC09PeZxjoVOCMGm4rV1lYvtRMWMZ7VTjsbiRdyxsRXZG + onFSeh3wqJxUnoQIrMcL1rUs7MKQzjmltIEQgOMNU9xOsS4BANZVKjb5YmFWq5PliTzypDFhcZrEuLyR + yVBpk9y0hIzxUKrvbFVSo8urLo0FHVjSSetSQzNCeKc0BAyDUNbnRYMUbTTlG5sVegRM4IzScrCbsO06 + MMw3VtzQRC35A6ViyOLdsrxTf7RklIQng+tcs6cpvmRyVqU5yTTIJ4ykhZRUttdEMFY1pQxJLHgjms+7 + tRESRwatTUvdZcZqXus1SsUsPbpWNdWpViVpILplIUnitZESWHOR0qNaTuRrRdzniMcHrSVpXFieWHFZ + zKVbBrpjNSWh0wmpLQcj7fpVjKutVKcrFabQ2h5iOcqKa7NjBNW4ZUbg9aSa33jcuKlS1syVOzsyjS0r + KVODSVZoFSRRB+pqOpYpQnWgB4D27hkY1v6Z4iKHy5+V6c1zzy7ulQk+lZVKMaitJGNWhCqrSR1Wr/Yr + iLzIyu4jtWVpF1HZXoeRcrms5ZW6FjUm5SKiNDlg4N6EQw6jTdNu6PVLfX7A2gywzisi40f+3JGlChU9 + q4VJXidSCSB2zXX6b4shtbTaRhgK8ypgp0HzUdWzyKmXzwz56GrZg61oT6ZJwflrGycVravrMupznP3S + eKltPDV3dW3nLwMZFelTqOnTTrPU9WnVlSpJ13qYVLU9zbtazNHIPmFQYrpTTV0dSaauia3tZrltsSFj + Us1hc23+sjYfhW74Xv7O0f8Afhc+9dmY7HV12qEI9RXm4jHSozs46HlYrMZ0KlnH3e55ZHK0bZHWpklE + so8zoa7PVPBg2mS36+lcjdabPaOVdCMd61o4qlWXuvU3oY2jiFeD1LL6OZV3wEEd6zWiaJyrjkVNDf3F + pkI/B7GomnMshZ+preKmt9jeCmnrsSW17NaEmGQrTXuHml3yElj3q2LGKS33q2DVBoypPpSjyt36hHkk + 21uWll24KmtG21a8jUiOVlGOmeKwwTnirtqzvMoVd3PSoqU4tXaM6tOLV2jY067e0vVupULc9SK72Dxr + bTWhQqAQMVjW17py2AhvbcxnbjJHFcnqk1ulzi1IC+1eY6axMrSVjyJ0YYydpRaa6l/VL0Xc5IbgnpUu + k6iunSbmAOO9YKyZ+YnmnLIZZAqjJzXT7BcvJ0Ox4eLh7N7HaWU0OpX/ANplIUjkE1p65rREcdtEFK8c + isOCa3i0/ZIoVsVlxTkXBcZYA9TXF7FSlzdEeesNGc+ZrSOx31lNYSaXulAjfGPc1JPFDZaN5qv+9bkE + GsOwns7+RY5nCBevNVNZuTJeLaWshZc4AzXL7FynbY4Vh3Kpy3t1ZsaHama7NzLAHX+8RR4pnsZoxDDI + UdeoFaNhdS6RpIMsR+7XH6nqVvqFyWKhTnmpoqVSrzdEKhGVbEOfRBo+kvdX6AJ5kYOTXc6lex6bpbtH + F5YVdoB6GqvhbTlhszcRtln6VV8U3M0vk2AAJLZaipUdWtbojHEVPrWKUHsjn9G0eDUWlubx/L3EkHoK + f4h0+302wVIrkSM3GAc11lubeO3gtpbcDj5sDpXO6lFp+p+Ikt4m2xr97HrWsK7lUu9kdNHEyqVuZ35V + +gzS9B1CPRi9uiNvGSKyvEOpeVZJp0lisco4LetehQWk1mgFndjy41+6ea861CG71nxEVYBijdulXhqv + tKjlLZam2Dre1quc9lqZgs4IbAPKu0kcZFZsixKRsIzXWeK0a3igtni2nHJFcsscGfvfMBXqUJ88eZns + 4ar7SHO+p0Pgex8/V2uGXIhGc1k+KZRea5cMDnDYFdl4VhjstAubpjhmU9a4a+j2SNdFg29ia58PLnxU + p9tDiws/a46pPtojOt7ZpHYZxinRwhLoKWBHrWtZSWj25L43Z54qK108XM80qkhF6V6Dna9z15Tte5Rv + tomUKelSXNyGtQmOaheJp7pkTnFRzW0sP3l4qlbRFJR0VzrvB92LSCTMe7IqG3vEj8StcvF8uemOlWfD + KEWjMFJGOaeltv1FnRNx715U5RVSdzxakoKrUv1NjxXq8OoaKsdvERx97FZfgSdYZpg0ZbIrTv7SVtL8 + sQlSRVTw7v0syb4s7hxXNCcfYSgu5xwnD6pKnHuULnVre01S532+Szdaxo7mOTW47gxgR7uRWteafLd3 + 0kwiPzHOMVXk0yVCMREH6V20501G3Wx6NGdKMEr6tdzW8VX1teafEttGNwHJFT6b4jtIdD8iS3+fbjgV + WFmy2OJIW3Y9KfpFr5kbL9mLY74rnbp8nK+jOVqk6XK+jMjSdSmtdSkeKMkMfu4qXXJ576UGSEx/hWlb + hLPVfmtjk9qva5bz3PllLbYD3putBVFKxUq8I1oy5em5z+k6hc6cwSOPcW4FdFc/27Fai48tQjdarL4c + vI1SfgY56V0srXtxpIibYAB1ArmxFeDkpRscWLxNNzUo2fc4W0m1AamWSXy5HHJFQ6vp90LtLm4mLncM + muttfDJlAnL/ADfWr0+hRSW+HbJA6+tP69CMrxNP7SpwnePpsc/rNjp02hRSRNumC4965O2s5uVWFmz7 + V6Vaada+TsIGBVmG2sIySAg9c0qWP9mnFK5nSzX2MXGKbPKV0m8nuTHHCd3pT/sN7o99DLIm0g9a9Dlv + bLT9SEnylDwfasXxVrNhfIFhILAdq6qeNq1JJcujO6jmNatNLk91kPiHR5rmwi1MnoAcAVo2NuNR8KmS + N/3kY7VRt/EctxoBsRbmUhcZFUPDeqTwSyWQG0Oeh7VnOFWVNp7xf4GVWnXlSae8Xdeh1R0S0gs7XVE5 + C4MmecjvUur3WnWE1vfWwXOBuHtXNme/WeTTWlwjZIGabaRwustteMQ69MmsfYO/NKV/8jmWFbalUlf/ + ACZZ1+8TWCk1tBgDqRV7RvEaWdn5MgJfoFrEXVILS3e24JHANUbW8SO8WYrlc1s6CnDla0Wx1SwqqUuS + UdFsehw3l1qVs5SNkIHGa5eQXU2pi1mlKgn1rctNallRfsVqxXoxAqHxBp0jWy3sY2yDk1x00qc7NWue + bQSo1OVpK+xHqnhqO1sVuo3yRz160Q6vpkujNC6DzcY/Gs+xe+1m3MclyQo4xmsryk03UTFMcj1rqjS5 + vdk9Ud0KDknCpK7RfstVe3VogpGT8pPatL7Xe3NuUeTcvbPasO9uoJGCwDn1q1bfaiUDttSnOmrc1i50 + o25rWZEkEdvdM04zTbiaCZHCJtFaV99nhhzu3PjnFcdd3rmYqny5OK0oxlV1NaEJVncsNIq/x4I9DUD3 + TyyADdIfeo5rBlgExfPcipV1KC3hGyIFxXao6e7qd6irXjqRTWU8wDS4RfSpEhsrSIPkNJ6VnXmp3F19 + 5sD0HFVVnKDJ5rZUptas3VGcl7zt5IsXVy8kpKDaO2K0bfxBLDYtbuN2RjJrF8xnbNdFonhxNTkUNIAD + 15orOnTjeYYh0acL1NkY1vbTXs+IkJJPaur0Twqk8/l3J2N6Gth7G18MyxvhWXvntVLxH4ltisc1kwWZ + ehFedPFVa75aSsn1PJqY2tiZKFBWT6mk6J4TulOVaBuvqKxPFPiS2uSjWLFZB3FcxqWuXepj9+/FZgyx + woJPpW9DL7NVKr946MNlaUlVrO8kW7rVbu7XE0pYfWqahnOFGTVsaVdGPzChAqbSp4bW7AuYwRmu7mhG + L9mtj0+aEIP2SvbsPsdFluHBlG1e9a81pZ6ZAcspbGRVu91W3aHy7QDJHauSv1uS5eUk57VyQdSvL3nZ + djhpuriZe++Vdia51ed1MSPhaowxvczBAeSepp9natdzbM4q5d2LaayyK3I5rtShD3Y7nelCn7sdx17o + sllGshOQaynwCCKvXesT3MIjY8Cs3JJp0lO3vlUVUt748uzfeY1NbWz3UoRKZ9ll2bsUtrdPazB17Gql + ez5S5X5Xy7nZaZ4cjSMNKByKyPEOnwWz5jI/CrL+KmNrtUYbGKxHkuNSlycnJrgoU6/tHOo7I8zD0sR7 + R1KrsiiAScDrV+2055RluKsDTja7ZG5qxNqEUUI2Y3V1yqN/Ad7qc3wEtvOlihjlx9ayrm4865Pk5/Cq + 1xcvO+W6Ve0SW2iuwbgZFS48ic7XYpr2cXO12XdL0aW6mDTKcH1r0K00a0t7MB1Xp1ptq1hJZCSFlGBX + Nar4mNvvhV68OpOti58sdLHzdWrXxs+WKasU/EcFvbSFoSM+1clNM8pqa81CW7kLOeKYhXb2r3MPSdOC + UtWfQ4WhKlBKerK1ORyjZFLJjccUyuk6yz5y4quxyTRVu30u8uo98MJYUpSUdWxSkoq8mU1OCKuR3IRO + nNUqUdKbVx2JppjJ1qGg0UJWAvW9+Ylwc5qK4u2nJ9KrUGkoJO5PKk7iqCTVyKdosc8VTU7aVmJolFPR + jaTWpqG/DjbTBpl1dnckZxVO1x9oXd0zXqmhW9ubFWwpJHNcGLr/AFVXijzcbifqkeaKPLbmzmtWxKpF + Vq9B8UxWmxsbdwrz9sbjjpW+Fr+2hzNWOnB4n6xT5mrADg8VYS5IXBNVqK6WkzpaT3HO25s02iplRdtG + wyCinMACRTkiZzx0phYjpaleErUVABRnFFFAEgf1pwweahpc0rAPVtsgYDODXXWPilLay8sKAwFceDzT + s+1Y1qEKqtIwr4eFZJTLs8kmqX+VHzMavT+HJorXzQegyc1lWdybW5WXGQK3bzxL51qYkXBI5rKp7WMo + xprQyq+2hKMaS0Od5RsHgitCx1e6sZA0Uhx6GptI0j+1GLM2PajWNHGmkYbiqlUpTl7KW5U6lGpL2UtW + dPY+NwyBLgc9K1Xk0/VYOqZIry0E9cVNDdzwMDHIRj3rkqZZC/NTdmcFXKKd+ak7M6XU/DLKxe3Ofaud + uLOa3YrIhGK39N8UMjbbnke9XNQ1GwvAAoAJp06lek+WauiqdXE0ZclRXXc49ZXTgMcelOaYlcVuvosU + yboyMnmsu40yWFjjmuqFanM7IV6U35laGN5XCL1NdRpOkTW5E7KCOtc1G0lrKG2nNdBF4oKWpjZecYFZ + YpVJK0NjLFqrJWp7FvXtWieD7OqDf0rmVVcZY4NI919ouvMk7mlu5I2xsqqNFUoqKKoUFRioIRWGevFb + +iWUqP8AaWi3R+tYNnbSXUyxx8muqk1GfS9P+zvENxGMioxLduSO7IxUnb2cN2VdY1GO4m8qJduOKt2K + rDZkkB8jvWVp0az3fnTL8pPXFaGsPbxAC2cZ74Nc8opWpo5akUrUolOe4xNlDtPtWx4b028vrg3MW1ip + yNx61zMZeeUIOSeBXXaYur6Fa+dGAYyM9KnErlhyxerFilyU+SLV2aXiDX7m2tvsk9uFJGM1ytkY57tA + Rkk81X1nX59WucyqFx2rV8JW5N19oaPcg7mojS+r0G2rMzjRWGwzbVmei2lzbWmnLg7Aq5xXL2WoLqGv + vcSOHVTgZ7VY8SatbJp/loNrtxVLw3ZKllJNIvLc159OHLTc31PGoUIwpSqy3eiOnnvLeSOe4wAI1wOa + 5/w7bCe7mu2jU5JIzWZq0strD5Cbv3rYxmtXSNPmist4kZBjNHKoU277mipKlRbv8RoavKttZySITG7D + Bwaw/DukXZla9jcZJzzWXr+pTg+VJICM4q7pOs31lp2QmVxwa1jRqQo+71N44epTw/ufaH61p1/qt6wy + GZeBjtXL3miXenzKJ0PJrtLK71W3zeGFXRucd6xNW8QtrGoRxPEF2nnitsPOvGXKkuVHRhauIg+RJcq3 + NDU5PsPhJEHBYV57JI7ptJOK9E1O5tJLSKGbGAOM1jLZ6TJKqlgAT1rTCVlSi3KLu2Vl9dUYScou7dzm + IJ/JjI2Z96nh1SSGN0RcBq6bVtC0yG18yCVScdM1mwaPD/Z7XDEdOtdixVOcbtHoLGUpx5mit4fjSa+L + SDIPatDxIkCqFiHJ6+1Z+nCFXYiTaRTtQmQMMSbj9c02m6vMKUXKuplzSb97W1KgV0fhW7t2kkafaWJ5 + zXL2HMBO3NavhoRpdOXwPm6GuPFU1KEmcWNpRnTmd3d39kIiGxz61nxT2jEkYrO194vs/wAh+bFZWms5 + TufU15kcOnDmueLSwMfZc1zo1urWKQlguD61Hc31mSpUKaoJDHcz7GbjvUt/ptvDAGVhke9JQimk7lxo + 000m2aM95aSW/GBxUGjajbWxkVgCM5pY7ayfTidw3Y9aytMjgW9ZXPyZ7mnGCcZFQpRcJbkt5fW8mspI + o+UHj2rV1HVYVtFKocjuKzdXitYpkaMr17VYuZ7RtMwGXdinKKfLoE6cZcjsxsnixWtNirzjFRxeIpPs + 5AQ1ynmqrkds1p219GYdqoSR6CumWFhFaI65YGlFaRNWz1662MqqaWXVb5lbHSsaK/EUxXYeexFXFu3f + 92kRy1RKik78pEsNGMrqJoWSXc/JcjdUV9aXFtcRs0p2seRmmfar2xRQY8Z6VX1T+0bmFXkYBOtTCD57 + 6WFThLnvdJF/W9HiOmecH+bGetZypox0TOY/M24565q/a25u9O2S3Hb1rL03TNPW8mjuWUjtuNaU5Wi0 + 29C6UrRalJ6PoZWjaxHp7TRmIuG+7xWfLczw6kbtYmjBbIBrXnNhpmuqyhXi7j0p/iLV9Ou4FW3jAYDt + XfGd5JqOkj0o1LzTjC6ktTJvNWmubpJgSrqMZqFZZJ7vc8hBPU5rP3HsDmnhZn5UGutU4pWR2qjGKstC + 1MBHPgNmrUbKUzmqEFpPcXSxMdpbvW3feH5LCzWYS5z6ms6jgmot6mVWVOLUJS1ZueH/ABFFZRmB497H + pit+Oa71SN42TZG3TNeX2tz9nuFkPY13Nr4jY2yi3jy2ME4rzMZheV80EeRj8Hyy5qa36mXOJ9I1HyhK + URjzg1FrkdoIlmjk3SkZPNX9V0yfULQ3bt82M/SuJlkZHMbk5HGDXRhoqpaV9VudeFiq1pKWq3LAvdrA + j7wrpNGkfVBh5dqjjg1zFtZyTsCMBTV+BRYScOQe+DXRXpxkrR3OqvTg42judbOtpaoYz+8b161xmq27 + eaXVdo7Vbn1lQfl5I71l3N9cXjYHT6VlhqM4O7M8NRlTdyB7qXy9ruSBVR5MjirX2ORly3Wr2mafDMGE + mN3vXdzwgrnc6kIK5gM5PFaGk28FxdKk5wCe9Qaha/ZbpkH3c1WDFSCCQR0IrZrnh7ps1zw912udTruj + 29nbrJCQPpWTYatcafIHRzj61TmvbidAkkpKjoKhALkBQSfasoUfc5ampjToP2fJVdzY1XxFdaphZDhQ + KyOWOBkmtCy0a4uyDt2j3rpbLQ7S2G6bGR61lKvRw65YmM8RQwseWC+45uy0W5u2HykLXS2Oj2lkwaYA + ketLda5Z2CFI9pPoK5i+1y4u2IB2rWH7/E+SOa+Jxf8AdidTq+uWUMBhiVScdq4eebz5iwGM1EWLtljk + +ppCB612YfDRorQ78NhI0Fpqy3aXZt5ATyK6SKKDVLfsGxXHCrtpfPbNlSaK9Dm96O4YjD8/vQ0ZZure + TTJy0Zqnc3s12cOc+1a0R/tRsuarX2mm0YOvSlCaTUZ7hTqJNRn8RmNC6gFhgGrItMRB6ke5jeHbgZqN + roLFtHX0rduTOhtvYma9j8jaRz0rNY5Ymjlj9am+yPt3ZppKJSSRADWxpV3FCPnA4rHxziiicFNWZM4K + asza1HVRMCiDisfOTk0mM9KeqdzSjCMFZChCMFZDQpNOHykU7IAqNjk1W5W5ej1S4gQrHIcemaquzzyF + 3OSaiAzTw22pUIp3SFGnGLukOaH5cjrUNTmZccVAatGjEopyqXcD1rSj05Wj3VMpqO5nKajuZ0e3zF3d + M816p4bms47FACme9eWzwmF8dqfBfXNuMRSso9q5cZhvrMEk7HLjMK8TBJOxWooortO0WikooAWpYoHl + 6dKIIxI4BretrZI1BwKxq1eRGNWryIxZbN41z1qtW7dOi5HGKyWhLMSKKdRyWoUqjktRIE3HJretNaud + PiKqxK1iJmM4q0BvXmpqxjPSSuhVYRmrSV0RX+pzX0hZ24qjVqWBQeKrEYOK1gopWiaQUUrREoooqyxK + cGI6Gm0UALnJqeGQIMGq9FAIsSShs4qCiikFwoop6RPJ9xSadwGUU543j4dSPrTaAClBpKKAHbqM5ptF + AGlp+py6fyh60t7qUupTL5h4qiAMU1vlbisvZR5ua2pn7GHNz21O3tNHsW0rexXJXOc1x92qJcusf3Qa + cmpXCRGMOQMetVckn61lQozhJuTvcww9CdOUnKV7jlyTwDTuQc5Oa6Tw3pcN180mPxrYv/CcUiFoQATW + VTHU4T5JGVXMaVOp7ORyFvqc8AxuJq7BqyO370VDe6FdWrHKEqKzXidDggg1oo0qqvE0UKNVXidMy2dw + uQQDWddaaucxkVkCSRDwxFWEv5V4JzSVGcH7rFHDzg7xkMkt3jJGM1HyvUVaF4GPzCnTSRyKAi8+1bKT + 6o3UpdURWt3LaTCSJsNVm41Sa8kHnHiljsUkQf3qgnspYm+VSRUXpyl5kXpylfqdjpt/p0enYcLuxWZJ + Hazwyz7wDyQM1zW50+U5HtR5rgFQxA9KxjheWTknuc8cHyyclLcu2V79kvVlI3AGuv1PxtFdaV9niQK2 + MVyOmQwzSETHim6lDBDLthbIp1KFOpUXMtUVVw9KrUXMtURK/mS5PUmvVvDMUFvpCvuXO3kZryWFGlkV + E5YmunittXs7XKMdhFY4+kqkVHmsc2Z0FWgoc1iTXrsX+riKM8Bq3P8ASrCwjCOMda5CK3vVn+0GNmOc + 1rvq8xgCzIQF6AisKlL3YwhqkYVcP7sIQs0h73V1qeoosa5aPtXQtql7Z2Rjlt8DGM1leE3hF288xGW9 + a3vEl/Aunt5ZXcRXFXd6qpcuhwYqSdaNFRukeb6rfGe6JPY1o/2+v9lfZ1AD4AyKyo7KS+ncp61Dc2Ut + rIEI5NeyoU2lB9D3lSpNKD6HTQ+NZ47A27Kv3cdKzNIzfaqZmHU5qoNLn8neycYzWj4eCws7kjj1rOpG + EacnDcxqxpQpTdLcj8S3GLgRhunpWXaW1zcKWjJwKXV5/OvZG68103hZYxZMZFGcUOXsKCdhuX1bDRdt + TlpJblZRDI7deldPqBW28NxjPLCuf1iRTqZKAYBqK81SS4t1hY/KK0dN1ORo0lSdbkklbqbWgWkE0RaX + GT61n6xFHDd4jx74qpayXSQZiOFqu87yzZc5PSrjTfO5XNI05e0crnXaSU+xEjGcVHbebJeERHHPOKis + 4Qthv3EcU3S7kQ3WSe/euOa+Jo4ZL43HU1dQgniiDvJkU7T518k803WL5J7cBTj2qLTF/cZIyK5rN07y + OOzdG8itLdyLdsUcjBpx1CadlR5cgn1rI1G5CXjgdKqrcncOoOa7I4e8U7HfHD3inY9Ag0ZpLdXE7YI6 + Bqh/s9Y59gkx75rMtLrUWtV2t8oqvPNeLJuL/NXAqU22uY4FSqOTXMjppNJh2bmkyfc0+PTrIwHc4yB3 + Nc0s17KnMpxWdc3l3CSDM2KIYacnbmFDC1JPl5y7fRxRXDKhGK2fCt5YQ+Ytzt3e9cak7SzKGfOTya6c + aRarZedu+bGetdNeEYwUJM6sVCMaahN7j9fvbMaiGt9pA9Khg1hIZFdQOK56Zo0lIznBp32mLy+2atYZ + cqRUcLHkUdzrr/WJL+BfIiPHfFVb/UL5tPC+TtGOTUWjanALfa4HFT6pq1s1oyKBmuRQcZ8iicig41FB + Q2OY/ti7TKq5GKan2y4bzA5ye9U3YM5KgnNXrWeaJcCJj6cV6koqKvFHrTgoRvBK41rGVm3SuSfWrsem + wBMsaZKt9KoPlFRTjo+oGASs5C1k53WsrGLqNpc0kinK9vbTEYBAqJtURZF2LwKL3S2ii8wuSe9R6YkH + n/vgD9a3Sg48250pU3Dm3J7nVA7o8SlXHQ9KtyTavqFluLHygOlR6xBaiINARkDtS2PiE29ibcxgnGKi + ycVKETJx5oKVOOq7mMSwJBzkV1nha+hVvKlx+NcpKzFzIVI3c1EszxvlGINaVqKrQ5TbEYdV6fKz0q/1 + +2skaNWVgR0rgL64We6aSPpVYtLOSTuc01SVO0jBqMNhI0FpuZYTAwwy0d2XY7ycIEU4pQJZXySSTVvS + IbeR8y44q7qUtpCw8orx6USqJT5UhzrJVOSMdTOa0Pl5PWrdi0AHz447ms26v+PlI57VQNy5PBxVeylN + WZXsZ1I2lob97dwqTsAxWK17IkhMbYquTJIehP4VPBYTTsPlIB71pGnCmtWawpQpR1ZBNNJO+52yalhs + Z513ohwO9b48NbLcOSM4znNaemXVlZWrR3AXI9e9YzxaS/dq5hUx0VH90rnDFSrFWBBFdL4dNiQfOUbg + O9Y+qTQS3zNABtNUkd1b5CR9K3nB1adtjoqQdelZ6XO0vdatbQlIgPYCufutYuLpiAxVTWY2QQXOad5i + 461FLCU4ebIoYGlT1erJpogyliSW9TVM8U9p3Ixnio66kjt06BRSUtMQlLmkooAuWl2bZwwNaU98b1Av + GawatWsoikGTWNSkn73UwqUov3rajri0eMbhVeKPfJtJrr4Iba4s8sRnFczeosFyfLPes6NZzbi9zOhX + c24taoJ7YRIGWkF3iPaRzUMlxJIMMeKSGJp5BGvU1vbT3jotZe8MJJJNKqE10SeFLlrXzR1xmsSaN7aU + xyDkVnCvCppBmdOvTqNqDvYaABTS4FMLkmm4Na27mqQpJalApKM0xjs4phNJRQMKKciF2wK1YbAMgJFT + Ooo7kTqRhuZSkggjqK1rbUFEe1utU7u38hsiqwBY8VLUaiuJxjUjcs3Ugck8VUxSnIPNFWlZWNIpJWEK + kdqbVl+nNVz1pp3ASiiimBJFIY3yKuHUn2bVrPpalwT3JcU9yyJ2lbDmpkXbzVCrEc54U1Mo9iZQ00Ly + WvmjcaY7eTx6UqXJiTGeKpzzbyayjGTeuxjCMm9dh7zqQaqsdxzSYNFbqKR0qKQlFKaSqGFPCEikTrVg + YxSGkVsUdqc+NxxSYJ5waYhKKKMUAFbWmBMjOOlYtSJNJH91sVnUhzKxnUhzxsa2sGLgLjNYpqR5WlbL + tk00DJxRThyRsFKHJHlbG0VIYzioyMGtLmgUUUUAODkU0nNFFAC5oFJSigDTsdSuLXHl5wK6ax8WHcFm + /WsjTYbdrfJIzjvWXf7BORHj8K8+pSp15OMkebUo0sRNwlH5noJ1ayvWWM7eaL7QrOaAum3kVw9nZTtH + 5qOQeoqwdcvbXMTtmuR4KUZfuZbHE8vlGX7iWxHqelLbN8hrOFlOV3+W231rUtbp9RvFVwSM8130en2S + 6b8yr93vW9TFyw6UZas6auNlhkoz1Z5MRtOOc103hOOyknP2sqPrWPq6RJfMIsYzVKOR4zlGIrsnF1qV + k7XO2pD29Kydrnea9HYRTxfZSuT1xXR6ZpVjd6cu8KSR+VeSC7lMgZ3LfjWva+Jru0TbHIfpXnV8BUcF + GEtUeXictrSpxjCWqOkuPCkV1qTpEQEWsjUvCs9rOETnNWNO8TyKxkkb5jWrp3iKC6vCblxweM1nzYqj + vqkZKeMob6pHJy6FeQ/wEfSs6SCVXIYNketeuve6fMhwUPFVLfR7C6LyOq80qeaSX8SIqWcTV/aQPMbW + U2twshXOK6iTxaJLdYhH0rZn8IW9wzNGQBWDJ4WmNyyRcgVr9aw9fWXQ3+t4XEu8t0bthrunvbASou7H + SodXvdOuLYLEF3E4rBfQ7qBygTJqnLp11E3zI1RChR5uaMjOnhaHPzRmehaRptidPU7lDY65rM1zTojE + xEpwO2a5VL+/tk2KWAqC41i7kGxmOKmGCqKpzqRNPAVlV51M1dOsLqMNJCwx7iqExurnUwrAM6ntU9tr + zW9rs74qnp+qrFqBmkAOT3rsjCa5pNHdGFVOUmrm7fXlxb2Hltb4yME1zSXMkSsVOM1t6xrsV1BsjA6V + zMj/AC8VWGpvl95WHg6T5Peja5DJIzuST1q/Z6xLaQlFzisvPNakaw/ZcnHSuyUIyVmjvlCMlZopTXLT + TGRu9NAaVvlGaiPU4q3ZSrFJl+lN+6tBv3VoaUHnpZFRFk461kHcs3PXNbb6pEsBVetYjPulLeprKnfV + tGNFPVtHVwSuNL+72qlYyo0pDDvSpqcK6d5QPzYxUWjsn2gl8cmuXkajJs4/ZuMZto0bwxlMD9at6fMq + 25BbtVbWJIVhGwjOO1N0tlaD5uTisHG9O5zW5qN2Y98vmXzYPepI9PldQyjiludpvSOgzW7aXMENphhk + 4ronUlGK5Tqq1pQhHlRJb3otbLbIvIFZE+qxO55qa+uVeBsY5rmD98/WpoYeLvJiw+GjK8nudbaXhZcK + hNUtRjmkJIjIpmmX6RKNwHFXLvVoGjKhRmp5HCpojPklCr7sTnSJUYdiKsPqd4IvLLkLTZbhWYkCq8kw + fjFdnLzfEjv5ea3MhhlZjyetXYNPlmQHPFZ3er0N/JEmFNVUUre6XUUre4W47OSJ8byB9auPax+VlmrI + a8mkbrzSebM3BY1g6c3q2czpVJO7Zt6YtqrkSgVrXl/p8UQ8sJkelcfHFK5xkjNWl06aQ9GasalGLleU + jGrhoSlzSkbl14ig+zbEUA+1UpPFEzWhhC9sVlXFo0LbWUg+9WtJ0WbUn2oOKao0IR5nsP6thqcOaWxQ + e7uJxtLZBqEwSKN3Irf1nQJtHRZeoNYUl27rjFdFGcZxvT2OmhUjUjzUtjZs7eOWyJdsnHesP5YrzHVQ + aYLyVFKqxxUG4lsk1dOk4ttvculRlFybe53IsrO50kyKV3Bc1xco2Sso6A1Kl9PHEUVztPHWqu47smlQ + oyp3u7iw9CVJu7vc3NGkh2ssmM+9U9SKLdHZj8KpKzFhtODSyKw+YnJrTktK5qqdp8w9Znj+4SKMSzgs + Wziot4xT4pvLBBHBqlEvlW9iI5zg1YtVj+0oJPu5quzbmJ9aUKx5ANNq6sNq6sehw6Zp/wBhEg28rnNY + 9xfWtkGVQCe1YC6jd+T5Ic4qFwzH94ea8+GElzNzldHmU8DLnbqSujUl8RXEiGNThazJJJbg5LdarEYO + KkjYAYJrthRhD4Ud9OhTp/CiMjkjvQjbTmlY/MSKZWhqTPIrLioaKKYBRRRQBIke4ZpHXacUK5WkZieT + SHpYbRRRTEFFFFAFlLyaNNoY4qFnaRsk5NKI/WpFUKajRbE6LYkhszIuTS25+yXqM3QGrMV3HEnNU538 + 1twFRrK6exkuaTaex6Jb6/aCx+Zh93pXA6vdJdXrvGBtqqwk24BO30zUNYYfCQoyck9zDDYGFCTlF7h3 + q6gXYKpU8SMBgGuw70EgAY4plKck81LHAXobtuS2kRAFjgVJ5LAZqykGw80sjqgxWfPd6Gbqa6FeBwj/ + ADV0NlNEY8VzLnLZFSxXLxdDU1aXOiK1D2iNS/Kl8YBFZ7FAwAxTHuWc80xMM3JpwhyqxdODhGxI8eea + gKkVpW1q0zDPStKXSAYcgVEq8YOzM5YmEHZnOl9w54pqpubAplSwEBq6NjpJPJXFQuu1sdqtkjGciqkh + y1KLEhtFJRVDFpKKWgBd7YxmhRluabSg4OaAJwKjkAzR5nFMJyaQxKKKKYhRS7iOM0gpyIXbApML2LFl + bG5nCgZrqYtIjEWHixkdaydPhNs4lHNdKutQ+QQwAYCvMxVSo37mx5GNrVW7U9jktT08Ws/HQ1mlG7Ct + fUroXk5I6Uy2tvMYAjiuuFRxgnLc7qdSUaac9zJIIozW/caYuzK4rImtXjJwuQK0hWjPYunWjPYrUoOD + RjBxRWpsTLIDTtqtVanK5WocexDj2JGhx0qIqR2qdZQ3Bp5AIpczW4uZrcqUU5wA3FNrQ0Ac04xkDNPi + UEjNWZNoTtSuNIqLLIgwrECgSHcC3NNPWkosibI6ax1GBLfB4OKx76dbi5ynSqXStTRrE3d0uRlRXO4R + pXmzncIUb1DpPC+lbU8515NWfEd/9liKRvg1qZTTrL0AFee6xfteXTfNlQa8uhGWJruo9jx8NCWKxDqS + 2Rnyu0jl2OSaZSnpTa9xKx9ClYWjNFFMB24+uKVXKnIJB9aZmjNKwrIuR6hcR/dkP51pQeJbuFAoc4rB + pc1lOhTlujKeHpz3R29t40eODY3U1e03xTAu4y4ya873UoY+tcssupPbQ4p5XRkmloep2evWlxOzPtq+ + ZdPuSfu15Ak8kf3WIrf0sX06FlkOK4q+WqHvKVjz8TlMYe8p2O/fTLCaNjheleea+kMN2UiA/CpLnWL+ + ycxMx596w7m5kuZS8h5rbBYSpTlzSldHTl+Cq05c0pXQ9TuIX1rXi0YSw719OtZemwfabxEPTNekx6Ok + WnBkOPlrTGYn2LSTNcdilQaV9zzeaAwzFDUE3ANX9XYx3jD0NZcj7q7KTcops7qTcoqQ0KWOAKcUcDoc + U6F1UnNTvMhUitWbMpmpIQGkUN071G3WrNjg3A3dKUnZXFJ2i2bE1taiz3DG7FYX8RFdTPDH9k6DpXL9 + JvxrDDy5kzmw0+ZMvppkrweZ261XRmjb5SQRXSQ3kI00ocZ24rCiUNLnrzShUbvzCp1ZS5uZbEq2t5co + CFZhVy2gvoV2rC35V2miQwCyUsqk4rSgW1aQrtWvKqZi03Hl0R41XNGpOHIeYy2d28pYxkGqlzPPA2xi + Qa9NuVtxIyhFrzzxEqi9OOnpXXhMT7aVmjuweK9vLllGxnm4nlXHJFRA881uackJtfm29O9ZF2qrdMFx + iu+LV7I9GMldxSHJBKy5UcVKsEhbBFaFhJF5eWI4p088KngisXUle1jndaXM1YzJ7WRcHFSRaXLKm7mr + rTJJHnGasW+qQRRlWI4qXUnb3UKVWpy+6tTDezdH2nikEGHAJq3dXiSz5HSrFrps9580YwK0dTljeeho + 6rjG89CFbZQoOKlSNPNUHpmpLq2uLQqjjrxmtO00SSeESHPrXPOtFLmbOWpWjGPM3ozSm0y3S1ikUDtn + FdFFbWUenpJhc4rIuLSRdJHzcqKvaGwuLICQZArxq0m481+p4VeUpQ5r7M5XxcYfORoVA45xUngq+VLw + xN36Vr+K7GL7KHVBxXF6Rc/ZNVjcDA3YNehStWwrij06aWIwTij0vxJZC90x/lyQOOK8gnjMMzIR0Ne3 + hvtdlnsy15L4ltDa6g4xwTWOUVWm6bOTIKzTlRZgkc0nSnBSeaaetfQI+pQlGT60UUDFUlTkU9pSwxio + 6KACiiigA71q2xjEIPGSKyaesjLwpNJq4FuXYJ8jvTLnbsGKqlixyTzRk9zRyk8utxKKKKooKKKKACii + igAooooAKKKKACinBGPapfKGM0rpCuiJVJqURgDNJuAFNaQ9qnVi1ZLvULULOc0zOakWJnGRTskCSRHm + poWBcBjxUbIydRTab1G9Ua5RPL7YrLlADnFL5shXG7imYJqIR5SIQcdxKKXbSgVZoNxV23kAHJqrTc+l + Jq5Mo3Vi5POMfKaqM5brTaKIxSCMVEKKKkWF3GQvFNuxTdhqqXOFGTWvY6UZGDPVSwULOA9dXb7FjzkY + rjxNZw0RwYzESpq0RjWaxRDAwRVKbVjbAoR0qbUNUVIiikZHSuXuLhpnJNY0KLqazOfDUJVdaiK9FFFe + meuSKGbvxQYyDT4yNoqTtk0hEGDTCMGpSw5FRYLNSQIM0lXEiUKM1FNGF5HFO4yCiiimAU4KxGQKRRzz + VkDFA0VsEUVLKB+NRYoEwAzV63RV5NRRRdzUhBUVlN30Mpu+hopJsTrUDv5j47Vnm4fpnirEMynGTWXs + nHUx9i46l9LDcu5KmTdb8sOKijujGnytUySNdYVhXPLm+1sc0nP7Ww57sEYB6051jMBLAdKSaw2rkcGs + 2a4dCY2NEIqXwipwjP4CtLCHkYjpVdoWB4GavRlT3rRtbESruYda6ZVeRanXKv7NanOEEdaSujvNIVE3 + EYzWFNA0R9q0p1o1FoaUq0aiuiHBFO3tjGaNrYztOKbWhsFFFFMBQxU8Upcmm0UAFFFFAEkcZlkCDua7 + 3QNPW3gDMO1c5oFj584kYZFdfe3KWFkRkdOK8nH1XJqlE8XMqzk1RgY3ibVdqmCNq40nPJ61Yvblrmdm + JzzVWu7DUVSgono4SgqNNRCiiiug6QqUKMdKipcnGKAA0lFFAD1UtwBmnmMgcjFTWpXcAas3RjVBjGaz + c/esQ52lYy6KfJjtTK0LHIMtiuq0XUYbeArJwcVzMAy9WJTtWuevBVFys5cRSVZcjJdVvBc3rOvQdKzy + 2WyaaaBzWsIqMUkb04KEVFF/S5hFeBs4ruf7bkWy2bwQRivOgrKQQeal+2z7du7iuXEYRVpJs48XgVXk + pM0ZXjub1mciqV9HGkmEquDITuGSaa7Mx561tCm4tanRCk4tWegyrum2q3VyEc4GapVPbTtbyb0ODWk0 + 3FpbmlRNxajudBqOiRRW+9OMCsG1haW5WNTg561ZuNYuZo/LLfLVaGUwyrIp+YVhShUjBqTuznowqxg1 + N3Z091pksVhkSE8VzVratc3Yi755rWm8QySW/lsB0xWZa3DRXIlHXNZ0Y1YwlzbmWHjWjCXNv0Ohn8Pv + Babwx6VhxbvMK9wa3bjxG0lkYiBkjFY1mfMkLnHWpoe15X7QnDOtyy9qX/7XvNPiABytPstfuproAHbm + qOqsGRQCOPSoNLt3nuQFOCKbo0nByaKdCk6bm1qdhM85iL7+cVxmqtI05Lnqa7KbT54bYOZSRiuN1WTf + Pj0rHBW5tDDAWcnYprNIo2q5A9KaSSck5NMor1LHrWNaysJJ4iwY4qu8Zjugjk4zVrT9V+yxFSuao3dz + 58xfGK54qfO77HPH2jm09js7e0tvsIb5fu9a5DUQq3JCdPampqNykXliQ7aqsxZiWOTU0MPKnJtszw2G + nSm5Sd7j4z84ru/Dt9AkO1hk1wGa63wrJH5mGxn3qMfBSp6kZjTU6LuX/EkysodUIwauaJqMslntjjzx + SeIjFJYnbjdVDwxqUcHyPj0rzOXmw2i2PKUFPCaLY2pzem1YMoC1Fol1IHaMNjtWhd3wktnCRkg1ycF1 + NDqBCDBJrKlF1ISVrGVCDq05RtY63WtOlfTi7yEjGetecyARzfKOVNd1O2oXVoUL4TFcDexvb3LKx5zX + Xl+icWzuy3ZwbPVPD94bjS4wSCQK5nxvp54nA+tWPBF2HiMRbkVveI7aO40yTcRkCvOTeHxnzPEjJ4TM + NO541u28VGeTUs6bJ2UdjUVfVra59sndXCiikoGLRRQMngdaACipDA6ruI4p1vEJHw1K63FzK1yGkq5P + bqinaKihtJJzwCBRzq1xcytcgoq7cabLBGHPIqlRGSkroIyUldBRRRVFBRRRQAUUUdaACgDNPVacV20r + iuR4pQMc0488DrS+VJtyFNK4XJBIoWo2lJ6VGc0lFgshc5oxSU6mMTFWLeUKMGq5NJRuK1yxPIrdKr0u + M04cUJDSGgGnUZppNAx1IxxQvNSlQRilcVyDrRSkYNJVAFKqljgDJp6RFutWbULFcDd0NTKVlcmTsrlq + y0tpCGkHFakmmiGLcBxV21eEwDGKpahqqxRmMEGvMdWpUnZHkOtVq1LIx70LE25OCKjGqSiPZmq00xlc + knioa9CNNctpHpxpJxSlqSSSvKxLGo6KK0tY1StsJRShSTxTzGwGaYxgJB4NPMjEY6VHS0AJTlODmkpK + ALiyKyj2qKZweBUAp/lmlYBlLQVIOKKYBTxIwGKZRQBZto/NfLc1pfZY2jOBWdZzLE3zd60nuohEdp5r + mq83NoctZz5tCg/7p9vUVHI7FeAcU4/vXye9WkhBXkVTko7lOSjuZdA61cntdpyKrMhU1rGSZtGSlsKk + zKRzkCta0vFB3NxWMBk04MV6VE6akrEVKSmrHUS30ZgwrDNZEq7uW6ms9ZWU5zmpkuPMcK3Sso0fZ7GM + MOqXwlu1smmfjpXQQK1sg3DIFVrAIFBUipru7VFIPSuOrKVSXKcNacqs+SxFqepRyx7FxxWXBbi6lAPN + UbqXzJSRkCn6fdPbz7xyK6o0eSn7u52Qoezp+5udcmhxG1+ZBnFcrqlgLOQ7fWupi8QIbbDjBxXOahci + 9nJ7VzYX2ym+fY5MH9YVR8+xj9TSVcFv5j4Ap8mnMqZxXpe0itGeq6kU7MoU4IxGQpIp4iYOoYdTWkF2 + jaBgVVyrmQRjrU9rA1zOqAcd6feKAykDBI5rV8OxxtMC5GazrT5IORnWqezpuSOn0+yWztQSMHHWub8Q + akZZDErcCuh1XUEtrMqpGcVwM8pmmZz3rzcFSc5urM8nL6Uqk3WmRjrQelJRXrnthRRRQAUuOKs2qKzH + dU88SlDwKhzs7GbqJSsZ1FPCk8KM0jIV6giquaCq5Xp1pXkZ+ppmKKLILBRRRTAs2470s560iMFXmmSN + kVna7IteVyCpYcc5qKjOK0LJ5GA6VFuptFIbdy/CVEYqtMQXOKjVyvAPFBOaLANoopaYhKWikoAWnAkd + Kv2NmtxjNa/9hxFAQBXPUxEIOzOepiYU3aRzZkYjBNTQuyDKmtG90yOBM8VlrwKqE4zV0VCcaivESWV3 + f5jmrenXht7oELk1nsfmqe1yblNvXNVOKcWmVOKcWmdzJqU09ntMWBjrXHaoMS89c10Ze4W1UFRjFcxq + Ls853dK4cJBKTsefgoKMnYp0UZor0j1BQSOhpM5oopAGaKKKACtTSpCkykE574rL71raCyDUFV+h9ayr + /wANmNf+G2dTd4ksDlSeO9YmiPHFflXx1713E8UH2A8qPl4rzi9fyL8lDjntXlYR+1jKB4+Cmq0Z01oe + pGS1+yZ+UcVxF/J5d/vj55qtFqJaD5pT+dVWu0Lg7snNFDCOm23qLC4GVGTbdzsLWW9ubcCMYGK5TXrG + eCcyS9Sa6jRtTP2fasZY1m+JBc3EZZo8D6Vnh5ShXtayIwspU8RaySOc0rWJtLmLpyDVu/8AFF7eoybi + FPvWCeGIPal3V67w9OUudrU9qWGpSn7Rx1EYksWJ5ptB60lbo6BaSipIomlbC0bAR1JGSJAetXV007dz + NWnZ6XEyZ4zWM68Yo56mIhBXZTA82PAWlttPkEoOMA1txwwRxFWwCKjn1C3iiwMZFcft5PSKOH6zJu0E + OGlK8eMZNOggitzhwOKoPr+zlSOlZVxqcsrEg4zSjQqz0lsKOHr1NJPQ6HUp7d7ZtpWuPfG846U9ppHG + Gc4pldtCj7JWud+Hoexja4AFjgDmpWgkC5xSQsFkGa03lj8jqM4q5yaehrKTWxj0AZpzkFjSA4NaFj1W + k4Bpy7mIVRkmtK30Se5QFRg1nOpGHxMznUjDWTMwsAKbvNWbzT5rN8SDj1qr3qotSV0VFqSuizYRrLdI + jHg16Da+H7ZrTlRyODXnKOY3DqcEV3WgeIY5IRDO3IrzsxjV5VKB5WawrcqlSexzeuaSbCcso+UmsftX + aeKbmCWDClc1xPJrowdSU6SctzqwNWdSinPcSinbaK6jusAXNSYApmcUhfNA9hScU0n0pCaKBXCiiigQ + VIrEjmo6KAJCBUZGDT05p5ApXsK46JsCklbuKib5elNJJ6miwy1HfzRrtB4qGWV5Wyx5qOihRSd0iVCK + d0goop6xs3QcVVyhlWYbYydaDauBkVZtX2na3Wspz090ynPT3SmowKfUYcY601nPQVobjG+8aSiimSFF + FFACipQ/tUW01btYDM3T5RUyaSuxOSirsruc0yuhhsoJAVxzWbfWot3IXpWcK0ZPlMoV4zlyooUUUVsb + CUuTTqQj0oAkjmKY4rRhnVlznFZNKGK9DWc6akZzpqRpvJubHaoXjDniqqysDyatRyA45qOVx2M+Rx2A + WpI4qJ4io6Vf3gJUchBT3qVN3JjUlfUzD1oFTNAx5FMMZXrW6aOlSTJYryWLoxqyk0t4wBPFZ2MVf0+d + InG/1rOpFJXS1MqkUk5RWpuwaVHLFyoziqN3pYgbK8V0NpeW5t/vDOKybu5V7jGcjNedTqVHNo8qjWrO + o09jKlSVE+7xVYZB962ZnRlwMVUMKtKMCuyFTTU74VdNUWNPg+Xc4rSZI2jNNgVQo7VFeyeSp21xybnM + 4JydSpoY2oKsbYHXrVUXrbcFQT60l3P50lVq9OnG0dT16UXGOo+SRpG3MeamtLprd8qcVWzRVtJqzLaT + VmaF5qDXKhSc1QxSZpc0oxUVZCjFRVkJg0U4EUqLvbFO5Qyip2hwM1EU54ouguOjlMfSnPcM4x0FR7D6 + U2iyFZGnYBfLJwM5q79njnkVTisSOV4/uNipY7yaOUPnJFYTpybumYVKUm24s6OfSIVtyQB0rl5kCTED + oK05NclkhKEVksxZix6mpw8Kkb87IwtOrG/tGSQwPcPtQdKnn02eBNxGRVnRpUjkO7Ga2L+eIWrZxkii + pWnGfKkFWvONRRS0OTyelITmlY5YkU010nWFFFFMAooooAKKKKACirCWc8i5VDimSwSRH51IqeZXtcnm + V7XIqKVUZjhQTTmidRlkIp3Q7k1veSW5+Wrw12cDHasilFRKlCTu0RKjCTu0XbnUpbjrUCfdqGpk+5TU + VFWQ1FRVkQt941NbuY51ZeT6VCeWNPibbKpPY02tCnsdKLueWDBXArBvX3SnPUVrRXcfk4J7Vi3TBpiR + XNQjaT0OPDwtJ6WIKKKK6ztFVSxwBk05o3UZK4FT2hG45q1OV8s5xWbnZ2M5TtKxmUUd6Ks0CrFtK0Uy + OvUVXpUOHH1pNXVhNXVmdNHqF3cptDHFY1/FJHLl+prasQwhDKASRVPVVLqWbrXFSajUskefRko1eWK0 + MuFHlbauTWv/AGK5g8wfWqWlsom5xXVR3cSWbK2OlGJqzhK0QxdepCSUEL4duUjxG689K19VCT2zDAHF + cRBevHdv5R71ekvLqaMgtjNcVXCt1Oe5wVcG3VVS9jnb+NY7t1XpUcIBzmnXSsJjuOTUCsQeK9mPwo96 + Hwosyqu2qtPL5HWmVSGgqe2l8t+TwagooauDVzae7RYMZGagTVniGFrNorL2Mepl7CHUtS6hNKxO7FV2 + dmPzMTTaK0UUtkaRhGOyFIozSUVRQUU4KSKaeDikAlLuYjGTRSUwFpKkEbH7qmmvGyH5lIpXQrot6bIi + 3a7+lei2whFmrwYLY6V5eCQeOtdHpGum0TY3NefjsPKorxPNzDDSqrmia2u2guYC5ABxXDyIUcqexrq7 + 7UJbyMiMbQa5i4heNyW5z3qsEpRjyyLwClCHLJkOafG7o2UODTQM08cV3M9BofJLLL/rHJphFBYCmFs0 + kuwkrbD81GTzxSZp8Sb3ANPYbYzk0VtwWCeWCR1qlfWyxcgVlGtFysYxrxlLlRRooorY2CipYYHmcKi5 + Y1q/8I7deTvB5xnGKznVhD4mZzqwp/E7GLRUssLwsUcEEVFVppmidw6U8Nk4plA4NAFxLcEc1DNDsPFW + IZhs5NMmfdwOazTlcxTlzalSipPJfGcVctoVIGRVSmkjSU0lcqrAxXNXbcKQAam2qowBxVaaRYzlTzWL + k56GDk6miLrAKmDWXcOBJ8poku2dcZqsTk5Jq6dNrVlUqbjqxKKKK2NwoopR1oASpEUsQFGTTcCrNnIs + UoLDipk7IUnZXL1rpRlTcw5NaVlbxW2UcAGpLe4VgNuMUzUriKKHORurzZTnOXKzyZ1KlSXI+oXGy3y4 + IFc/eXRnkPpTbi8ebgnj61WzXZRo8mr3O2hh+TWW4UUUV0HUHNL1q1bWUlxzyFpt1aPbnnpUc8b2I9pH + m5b6kSjikZRTQ2KC2aosSlBI6UlFMCZJ2GM8ipvODkCqdKDg1DgmQ4JmtGoIGaZMigGqkd2ycHmlluN4 + rLklcx9nJSIHXDHFJzTlG5q1bezVky3StJTUVqazqKC1M1LiVOAxxUwusDnrVmawXJ29apS2sie9QnCR + ClTmAuHLZ3VbgnHBY81nEFTgikDEdOKpwTRcqakrHRR3Y24PIqvdXDTnyohkmshZnXoa0tJlTzyXwT71 + g6Sh7xzOiqd5kcmkyIm4tk+lUJIWj612LoCC3GK5vU5FErIuKKFeU3Zhh8RKo7MzqKKK7DtCiiigAqzA + vGar1LFLs4NJgXfk8rnrVAuN59KfJPkYFQVMY2BpE24Y61GetNpRycVVhWsSCJmGRSeW+cY5q/bxZXJo + mCo2ay9prYx9r71jPKkdRTT9K0IoxO/NS3VqqRk8Yo9qk7MftknZmWrshypINOeeWQYdyRTKStbI1stx + aSiimMKKKKACiiigAp8ePMXPrTKKQHVWbKYgox0qrq4j8vturHjvJohhW4pktxJMcuxNc0cO1PmuckcM + 1U57m1pFvE65OM1pXNtC0DEqvSuWt7yW2PyHj0qeXVppEK9KidCcp8yZnUw1SVTmT0KkyhZWA6A0ykJy + c0V2LY7lsOAywFaaQoIugrLHWra3X7vDA5FRNN7EVIt7FaQbZGA9abSs25iaSrNEOEjDoadEAWJPNR0K + xU5HWiwrFuRVKHgVTp7SswwaZSirAlYUMVOQcGnNI78MxNMopjsFLSUUwClpKKANO11RrePaeagur5rg + +gqpRWapxTvYzVKKlzWFV2RsqcGpWu52GDIcU2NN7c1O0SBO1U7dS2k9yO2uPJk3HkVcbVBj5VrMI5oq + XCLd2TKnGTux8srSyFmqOilq1oXawlFLRTASilpKALttGhTd1NRXCBTkVGkrJwpxTWcucsahJ3uTbW4l + FKqlmCjqTXS2fh7zbfcw5IqataNJXkZ1q8KKvI5mirmoWT2M5Q9Kp1cZKSujSMlNcyJ48FKZJG2chTir + On7GlCuK6Kaxj+y5AHSsKldU5WZz1sSqUkmjkKv2ECSjLDkVVmULMy9hTra5a3bI5HpWs7yjobTvKHum + zNEsYUgDFU73yynGKhn1F5RgDAqmzlxySayp0pLVmNKlJWcmNp8b7XB96jpa6GjqaudFbTK0X4VSvsMG + JGKoxXUkQwtNllknJLH8BXPGi4yucsKDjPmI84oLZq1Y2hup9nYVvSaHGtsSFGcVVSvCDsyquJhTfKzl + aKluIvJlK1FWyd1c3TuroKejbHDDtTKKBmxDqA27cUkqm4HNZcblHBrWt5BKM5rmnBQ1RyVKag+aJmTQ + mNsYqKtm5ttyk9TWRInltitqc+ZG1OopI1/D0kS3mJe/TNd0gUrgYwa8uR2RgynBHeuu0HXA2IZT83ua + 8/H4eUvfieXmeFnP95En1/RFmjM0SgOPSuLkjaNyjDBFepMBKucggiuU1/R9uZo19zis8Dimv3czPLsa + 1+6qM5SilPBNJXsHuhU0JG7mmeWSODTeUPvSauJq6NLGRgUwt5XPaoUutq4NQyTF+O1ZKDvqYqm76lp7 + 0FcDrVNm3HJptFaRilsaxio7BRRRVFH/2Q== + + + \ No newline at end of file diff --git a/Forms/FormContract.Designer.cs b/Forms/FormContract.Designer.cs new file mode 100644 index 0000000..55775ca --- /dev/null +++ b/Forms/FormContract.Designer.cs @@ -0,0 +1,169 @@ +namespace IT_Company.Forms +{ + partial class FormContract + { + /// + /// 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() + { + labelOrganization = new Label(); + labelExecutor = new Label(); + buttonSave = new Button(); + buttonCancel = new Button(); + comboBoxOrganizations = new ComboBox(); + comboBoxExecutors = new ComboBox(); + groupBoxServices = new GroupBox(); + dataGridViewServices = new DataGridView(); + Service = new DataGridViewComboBoxColumn(); + groupBoxServices.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)dataGridViewServices).BeginInit(); + SuspendLayout(); + // + // labelOrganization + // + labelOrganization.AutoSize = true; + labelOrganization.Location = new Point(12, 15); + labelOrganization.Name = "labelOrganization"; + labelOrganization.Size = new Size(105, 20); + labelOrganization.TabIndex = 5; + labelOrganization.Text = "Организация:"; + // + // labelExecutor + // + labelExecutor.AutoSize = true; + labelExecutor.Location = new Point(12, 48); + labelExecutor.Name = "labelExecutor"; + labelExecutor.Size = new Size(104, 20); + labelExecutor.TabIndex = 6; + labelExecutor.Text = "Исполнитель:"; + // + // buttonSave + // + buttonSave.Anchor = AnchorStyles.Bottom | AnchorStyles.Left; + buttonSave.Location = new Point(12, 323); + buttonSave.Name = "buttonSave"; + buttonSave.Size = new Size(94, 29); + buttonSave.TabIndex = 10; + buttonSave.Text = "Сохранить"; + buttonSave.UseVisualStyleBackColor = true; + buttonSave.Click += buttonSave_Click; + // + // buttonCancel + // + buttonCancel.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonCancel.Location = new Point(283, 323); + buttonCancel.Name = "buttonCancel"; + buttonCancel.Size = new Size(94, 29); + buttonCancel.TabIndex = 11; + buttonCancel.Text = "Отмена"; + buttonCancel.UseVisualStyleBackColor = true; + buttonCancel.Click += buttonCancel_Click; + // + // comboBoxOrganizations + // + comboBoxOrganizations.FormattingEnabled = true; + comboBoxOrganizations.Location = new Point(226, 12); + comboBoxOrganizations.Name = "comboBoxOrganizations"; + comboBoxOrganizations.Size = new Size(151, 28); + comboBoxOrganizations.TabIndex = 12; + // + // comboBoxExecutors + // + comboBoxExecutors.FormattingEnabled = true; + comboBoxExecutors.Location = new Point(226, 45); + comboBoxExecutors.Name = "comboBoxExecutors"; + comboBoxExecutors.Size = new Size(151, 28); + comboBoxExecutors.TabIndex = 15; + // + // groupBoxServices + // + groupBoxServices.Controls.Add(dataGridViewServices); + groupBoxServices.Location = new Point(12, 79); + groupBoxServices.Name = "groupBoxServices"; + groupBoxServices.Size = new Size(365, 238); + groupBoxServices.TabIndex = 16; + groupBoxServices.TabStop = false; + groupBoxServices.Text = "Услуги"; + // + // dataGridViewServices + // + dataGridViewServices.AllowUserToResizeColumns = false; + dataGridViewServices.AllowUserToResizeRows = false; + dataGridViewServices.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill; + dataGridViewServices.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + dataGridViewServices.ColumnHeadersVisible = false; + dataGridViewServices.Columns.AddRange(new DataGridViewColumn[] { Service }); + dataGridViewServices.Dock = DockStyle.Fill; + dataGridViewServices.Location = new Point(3, 23); + dataGridViewServices.Name = "dataGridViewServices"; + dataGridViewServices.RowHeadersVisible = false; + dataGridViewServices.RowHeadersWidth = 51; + dataGridViewServices.Size = new Size(359, 212); + dataGridViewServices.TabIndex = 0; + // + // Service + // + Service.HeaderText = ""; + Service.MinimumWidth = 6; + Service.Name = "Service"; + // + // FormContract + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(389, 362); + Controls.Add(groupBoxServices); + Controls.Add(comboBoxExecutors); + Controls.Add(comboBoxOrganizations); + Controls.Add(buttonCancel); + Controls.Add(buttonSave); + Controls.Add(labelExecutor); + Controls.Add(labelOrganization); + Name = "FormContract"; + StartPosition = FormStartPosition.CenterParent; + Text = "Исполнитель"; + groupBoxServices.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)dataGridViewServices).EndInit(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private TextBox description; + private TextBox price; + private TextBox bankAccount; + private Label labelOrganization; + private Label labelExecutor; + private Label labelBankAccount; + private Button buttonSave; + private Button buttonCancel; + private ComboBox comboBoxOrganizations; + private ComboBox comboBoxExecutors; + private GroupBox groupBoxServices; + private DataGridView dataGridViewServices; + private DataGridViewComboBoxColumn Service; + } +} \ No newline at end of file diff --git a/Forms/FormContract.cs b/Forms/FormContract.cs new file mode 100644 index 0000000..880764d --- /dev/null +++ b/Forms/FormContract.cs @@ -0,0 +1,83 @@ +using IT_Company.Entities; +using IT_Company.Entities.Repositories; +using System.Data; +namespace IT_Company.Forms +{ + public partial class FormContract : Form + { + private readonly IContractRepository _contractRepository; + + private int? _contractId; + public int Id + { + set + { + try + { + var contract = _contractRepository.ReadContractById(value); + if (contract != null) + { + throw new InvalidDataException(nameof(contract)); + } + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при получении данных", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + } + } + + public FormContract(IContractRepository contractRepository) + { + InitializeComponent(); + _contractRepository = contractRepository ?? throw new ArgumentNullException(nameof(contractRepository)); + } + + private void buttonSave_Click(object sender, EventArgs e) + { + try + { + if (string.IsNullOrEmpty(comboBoxExecutors.Text) || string.IsNullOrEmpty(comboBoxOrganizations.Text) || string.IsNullOrEmpty(dataGridViewServices.Text)) + { + throw new DataException("Имеются незаполненные поля"); + } + _contractRepository.CreateContract(Contract.CreateOperation(0,int.Parse(comboBoxExecutors.Text),int.Parse(comboBoxOrganizations.Text),0,CreateListServicesContractsFromDataGrid())); + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при сохранении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + private List CreateListServicesContractsFromDataGrid() + { + { + var list = new List(); + foreach (DataGridViewRow row in dataGridViewServices.Rows) + { + if (row.Cells["Service"].Value == null) + { + continue; + } + list.Add(ServicesContracts.CreateEntity(0, + Convert.ToInt32(row.Cells["Service"].Value),DateTime.Now)); + } + return list; + } + } + private void buttonCancel_Click(object sender, EventArgs e) + { + Close(); + } + + + + private void price_KeyPress(object sender, KeyPressEventArgs e) + { + char c = e.KeyChar; + if (!Char.IsDigit(c) && c != 8) + e.Handled = true; + } + } +} diff --git a/Forms/FormContract.resx b/Forms/FormContract.resx new file mode 100644 index 0000000..935eac0 --- /dev/null +++ b/Forms/FormContract.resx @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + True + + \ No newline at end of file diff --git a/Forms/FormContractList.Designer.cs b/Forms/FormContractList.Designer.cs new file mode 100644 index 0000000..2c56b3f --- /dev/null +++ b/Forms/FormContractList.Designer.cs @@ -0,0 +1,98 @@ +namespace IT_Company.Forms +{ + partial class FormContractList + { + /// + /// 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() + { + dataGridView = new DataGridView(); + button1 = new Button(); + panel1 = new Panel(); + ((System.ComponentModel.ISupportInitialize)dataGridView).BeginInit(); + panel1.SuspendLayout(); + SuspendLayout(); + // + // dataGridView + // + dataGridView.AllowUserToAddRows = false; + dataGridView.AllowUserToDeleteRows = false; + dataGridView.AllowUserToResizeColumns = false; + dataGridView.AllowUserToResizeRows = false; + dataGridView.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill; + dataGridView.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + dataGridView.Dock = DockStyle.Fill; + dataGridView.Location = new Point(0, 0); + dataGridView.MultiSelect = false; + dataGridView.Name = "dataGridView"; + dataGridView.ReadOnly = true; + dataGridView.RowHeadersVisible = false; + dataGridView.RowHeadersWidth = 51; + dataGridView.SelectionMode = DataGridViewSelectionMode.FullRowSelect; + dataGridView.Size = new Size(800, 450); + dataGridView.TabIndex = 0; + // + // button1 + // + button1.Anchor = AnchorStyles.Right; + button1.Font = new Font("Segoe UI", 24F); + button1.Location = new Point(3, 3); + button1.Name = "button1"; + button1.Size = new Size(90, 90); + button1.TabIndex = 1; + button1.Text = "+"; + button1.UseVisualStyleBackColor = true; + button1.Click += ButtonAdd_Click; + // + // panel1 + // + panel1.Controls.Add(button1); + panel1.Dock = DockStyle.Right; + panel1.Location = new Point(703, 0); + panel1.Name = "panel1"; + panel1.Size = new Size(97, 450); + panel1.TabIndex = 4; + // + // FormContractList + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(800, 450); + Controls.Add(panel1); + Controls.Add(dataGridView); + Name = "FormContractList"; + Text = "FormExecutors"; + ((System.ComponentModel.ISupportInitialize)dataGridView).EndInit(); + panel1.ResumeLayout(false); + ResumeLayout(false); + } + + #endregion + + private DataGridView dataGridView; + private Button button1; + private Panel panel1; + } +} \ No newline at end of file diff --git a/Forms/FormContractList.cs b/Forms/FormContractList.cs new file mode 100644 index 0000000..99d3117 --- /dev/null +++ b/Forms/FormContractList.cs @@ -0,0 +1,63 @@ +using IT_Company.Entities.Repositories; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; +using Unity; + +namespace IT_Company.Forms +{ + public partial class FormContractList : Form + { + private readonly IUnityContainer _container; + private readonly IContractRepository _contractRepository; + public FormContractList(IUnityContainer container, IContractRepository contractRepository) + { + InitializeComponent(); + _container = container ?? throw new ArgumentNullException(nameof(container)); + _contractRepository = contractRepository ?? throw new ArgumentNullException(nameof(contractRepository)); + } + private void Load(object sender, EventArgs e) + { + try + { + LoadList(); + }catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonAdd_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + LoadList(); + }catch(Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при добавлении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void LoadList() => dataGridView.DataSource = _contractRepository.ReadContracts(); + private bool TryGetIdentifierFromSelectedRow(out int id) + { + id = 0; + if (dataGridView.SelectedRows.Count < 1) + { + MessageBox.Show("Нет выбранной записи", "Ошибка", + MessageBoxButtons.OK, MessageBoxIcon.Error); + return false; + } + id = + Convert.ToInt32(dataGridView.SelectedRows[0].Cells["Id"].Value); + return true; + } + } +} diff --git a/Forms/FormContractList.resx b/Forms/FormContractList.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/Forms/FormContractList.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Forms/FormExecutor.Designer.cs b/Forms/FormExecutor.Designer.cs new file mode 100644 index 0000000..cf5a63a --- /dev/null +++ b/Forms/FormExecutor.Designer.cs @@ -0,0 +1,194 @@ +namespace IT_Company.Forms +{ + partial class FormExecutor + { + /// + /// 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() + { + name = new TextBox(); + phoneNumber = new TextBox(); + email = new TextBox(); + rang = new ComboBox(); + skills = new CheckedListBox(); + labelName = new Label(); + labelPhoneNumber = new Label(); + labelEmail = new Label(); + labelRang = new Label(); + labelSkills = new Label(); + buttonSave = new Button(); + buttonCancel = new Button(); + SuspendLayout(); + // + // name + // + name.Anchor = AnchorStyles.Top | AnchorStyles.Right; + name.Location = new Point(172, 12); + name.Name = "name"; + name.Size = new Size(151, 27); + name.TabIndex = 0; + // + // phoneNumber + // + phoneNumber.Anchor = AnchorStyles.Top | AnchorStyles.Right; + phoneNumber.Location = new Point(172, 45); + phoneNumber.Name = "phoneNumber"; + phoneNumber.Size = new Size(151, 27); + phoneNumber.TabIndex = 1; + phoneNumber.KeyPress += PhoneNumber_KeyPress; + // + // email + // + email.Anchor = AnchorStyles.Top | AnchorStyles.Right; + email.Location = new Point(172, 78); + email.Name = "email"; + email.Size = new Size(151, 27); + email.TabIndex = 2; + // + // rang + // + rang.Anchor = AnchorStyles.Top | AnchorStyles.Right; + rang.FormattingEnabled = true; + rang.Location = new Point(172, 111); + rang.Name = "rang"; + rang.Size = new Size(151, 28); + rang.TabIndex = 3; + // + // skills + // + skills.Anchor = AnchorStyles.Top | AnchorStyles.Right; + skills.FormattingEnabled = true; + skills.Location = new Point(172, 145); + skills.Name = "skills"; + skills.Size = new Size(151, 158); + skills.TabIndex = 4; + // + // labelName + // + labelName.AutoSize = true; + labelName.Location = new Point(12, 15); + labelName.Name = "labelName"; + labelName.Size = new Size(45, 20); + labelName.TabIndex = 5; + labelName.Text = "ФИО:"; + // + // labelPhoneNumber + // + labelPhoneNumber.AutoSize = true; + labelPhoneNumber.Location = new Point(12, 48); + labelPhoneNumber.Name = "labelPhoneNumber"; + labelPhoneNumber.Size = new Size(130, 20); + labelPhoneNumber.TabIndex = 6; + labelPhoneNumber.Text = "Номер телефона:"; + // + // labelEmail + // + labelEmail.AutoSize = true; + labelEmail.Location = new Point(12, 81); + labelEmail.Name = "labelEmail"; + labelEmail.Size = new Size(146, 20); + labelEmail.TabIndex = 7; + labelEmail.Text = "Электронная почта:"; + // + // labelRang + // + labelRang.AutoSize = true; + labelRang.Location = new Point(12, 114); + labelRang.Name = "labelRang"; + labelRang.Size = new Size(43, 20); + labelRang.TabIndex = 8; + labelRang.Text = "Ранг:"; + // + // labelSkills + // + labelSkills.AutoSize = true; + labelSkills.Location = new Point(12, 145); + labelSkills.Name = "labelSkills"; + labelSkills.Size = new Size(104, 20); + labelSkills.TabIndex = 9; + labelSkills.Text = "Способности:"; + // + // buttonSave + // + buttonSave.Anchor = AnchorStyles.Bottom | AnchorStyles.Left; + buttonSave.Location = new Point(12, 323); + buttonSave.Name = "buttonSave"; + buttonSave.Size = new Size(94, 29); + buttonSave.TabIndex = 10; + buttonSave.Text = "Сохранить"; + buttonSave.UseVisualStyleBackColor = true; + buttonSave.Click += buttonSave_Click; + // + // buttonCancel + // + buttonCancel.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonCancel.Location = new Point(229, 323); + buttonCancel.Name = "buttonCancel"; + buttonCancel.Size = new Size(94, 29); + buttonCancel.TabIndex = 11; + buttonCancel.Text = "Отмена"; + buttonCancel.UseVisualStyleBackColor = true; + buttonCancel.Click += buttonCancel_Click; + // + // FormExecutor + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(334, 362); + Controls.Add(buttonCancel); + Controls.Add(buttonSave); + Controls.Add(labelSkills); + Controls.Add(labelRang); + Controls.Add(labelEmail); + Controls.Add(labelPhoneNumber); + Controls.Add(labelName); + Controls.Add(skills); + Controls.Add(rang); + Controls.Add(email); + Controls.Add(phoneNumber); + Controls.Add(name); + Name = "FormExecutor"; + StartPosition = FormStartPosition.CenterParent; + Text = "Исполнитель"; + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private TextBox name; + private TextBox phoneNumber; + private TextBox email; + private ComboBox rang; + private CheckedListBox skills; + private Label labelName; + private Label labelPhoneNumber; + private Label labelEmail; + private Label labelRang; + private Label labelSkills; + private Button buttonSave; + private Button buttonCancel; + } +} \ No newline at end of file diff --git a/Forms/FormExecutor.cs b/Forms/FormExecutor.cs new file mode 100644 index 0000000..ce278bb --- /dev/null +++ b/Forms/FormExecutor.cs @@ -0,0 +1,76 @@ +using IT_Company.Entities; +using IT_Company.Entities.Repositories; +using System.Data; +namespace IT_Company.Forms +{ + public partial class FormExecutor : Form + { + private readonly IExecutorRepository _executorRepository; + + private int? _executorId; + public int Id + { + set + { + try + { + var executor = _executorRepository.ReadExecutorById(value); + if (executor != null) + { + throw new InvalidDataException(nameof(executor)); + } + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при получении данных", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + } + } + + public FormExecutor(IExecutorRepository executorRepository) + { + InitializeComponent(); + _executorRepository = executorRepository ?? throw new ArgumentNullException(nameof(executorRepository)); + rang.Items.AddRange(Enum.GetNames(typeof(Entities.Enums.ExecutorRang))); + skills.Items.AddRange(Enum.GetNames(typeof(Entities.Enums.ExecutorSkills))); + } + + private void PhoneNumber_KeyPress(object sender, KeyPressEventArgs e) + { + char c = e.KeyChar; + if (!Char.IsDigit(c) && c != 8) + e.Handled = true; + } + + private void buttonSave_Click(object sender, EventArgs e) + { + try + { + if(string.IsNullOrEmpty(name.Text) || string.IsNullOrEmpty(phoneNumber.Text) || string.IsNullOrEmpty(email.Text) || string.IsNullOrEmpty(rang.Text)) + { + throw new DataException("Имеются незаполненные поля"); + } + if (_executorId.HasValue) + { + _executorRepository.UpdateExecutor(CreateExecutor(_executorId.Value)); + } + else + { + _executorRepository.CreateExecutor(CreateExecutor(0)); + } + Close(); + }catch(Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при сохранении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + private void buttonCancel_Click(object sender, EventArgs e) + { + Close(); + } + + private Executor CreateExecutor(int id) => Executor.CreateEntity(id, name.Text, phoneNumber.Text, email.Text, Enum.Parse(rang.Text), (Entities.Enums.ExecutorSkills)skills.CheckedItems.Cast().Aggregate(0, (acc,i) => acc | (int)Enum.Parse(i))); + + } +} diff --git a/Forms/FormExecutor.resx b/Forms/FormExecutor.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/Forms/FormExecutor.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Forms/FormExecutorList.Designer.cs b/Forms/FormExecutorList.Designer.cs new file mode 100644 index 0000000..165a483 --- /dev/null +++ b/Forms/FormExecutorList.Designer.cs @@ -0,0 +1,128 @@ +namespace IT_Company.Forms +{ + partial class FormExecutorList + { + /// + /// 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() + { + dataGridView = new DataGridView(); + button1 = new Button(); + button2 = new Button(); + button3 = new Button(); + panel1 = new Panel(); + ((System.ComponentModel.ISupportInitialize)dataGridView).BeginInit(); + panel1.SuspendLayout(); + SuspendLayout(); + // + // dataGridView + // + dataGridView.AllowUserToAddRows = false; + dataGridView.AllowUserToDeleteRows = false; + dataGridView.AllowUserToResizeColumns = false; + dataGridView.AllowUserToResizeRows = false; + dataGridView.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill; + dataGridView.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + dataGridView.Dock = DockStyle.Fill; + dataGridView.Location = new Point(0, 0); + dataGridView.MultiSelect = false; + dataGridView.Name = "dataGridView"; + dataGridView.ReadOnly = true; + dataGridView.RowHeadersVisible = false; + dataGridView.RowHeadersWidth = 51; + dataGridView.SelectionMode = DataGridViewSelectionMode.FullRowSelect; + dataGridView.Size = new Size(800, 450); + dataGridView.TabIndex = 0; + // + // button1 + // + button1.Anchor = AnchorStyles.Right; + button1.Font = new Font("Segoe UI", 24F); + button1.Location = new Point(3, 3); + button1.Name = "button1"; + button1.Size = new Size(90, 90); + button1.TabIndex = 1; + button1.Text = "+"; + button1.UseVisualStyleBackColor = true; + button1.Click += ButtonAdd_Click; + // + // button2 + // + button2.Anchor = AnchorStyles.Right; + button2.Font = new Font("Segoe UI", 24F); + button2.Location = new Point(3, 99); + button2.Name = "button2"; + button2.Size = new Size(90, 90); + button2.TabIndex = 2; + button2.Text = "🗘"; + button2.UseVisualStyleBackColor = true; + button2.Click += ButtonUpd_Click; + // + // button3 + // + button3.Anchor = AnchorStyles.Right; + button3.Font = new Font("Segoe UI", 24F); + button3.Location = new Point(3, 195); + button3.Name = "button3"; + button3.Size = new Size(90, 90); + button3.TabIndex = 3; + button3.Text = "—"; + button3.UseVisualStyleBackColor = true; + button3.Click += ButtonDel_Click; + // + // panel1 + // + panel1.Controls.Add(button1); + panel1.Controls.Add(button3); + panel1.Controls.Add(button2); + panel1.Dock = DockStyle.Right; + panel1.Location = new Point(703, 0); + panel1.Name = "panel1"; + panel1.Size = new Size(97, 450); + panel1.TabIndex = 4; + // + // FormExecutorList + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(800, 450); + Controls.Add(panel1); + Controls.Add(dataGridView); + Name = "FormExecutorList"; + Text = "FormExecutors"; + ((System.ComponentModel.ISupportInitialize)dataGridView).EndInit(); + panel1.ResumeLayout(false); + ResumeLayout(false); + } + + #endregion + + private DataGridView dataGridView; + private Button button1; + private Button button2; + private Button button3; + private Panel panel1; + } +} \ No newline at end of file diff --git a/Forms/FormExecutorList.cs b/Forms/FormExecutorList.cs new file mode 100644 index 0000000..2c0d6e3 --- /dev/null +++ b/Forms/FormExecutorList.cs @@ -0,0 +1,104 @@ +using IT_Company.Entities.Repositories; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; +using Unity; + +namespace IT_Company.Forms +{ + public partial class FormExecutorList : Form + { + private readonly IUnityContainer _container; + private readonly IExecutorRepository _executorRepository; + public FormExecutorList(IUnityContainer container, IExecutorRepository executorRepository) + { + InitializeComponent(); + _container = container ?? throw new ArgumentNullException(nameof(container)); + _executorRepository = executorRepository ?? throw new ArgumentNullException(nameof(executorRepository)); + } + private void Load(object sender, EventArgs e) + { + try + { + LoadList(); + }catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonAdd_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + LoadList(); + }catch(Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при добавлении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonUpd_Click(object sender, EventArgs e) + { + if(!TryGetIdentifierFromSelectedRow(out var findId)) + { + return; + } + try + { + var form = _container.Resolve(); + form.Id = findId; + form.ShowDialog(); + LoadList(); + }catch(Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при изменении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonDel_Click(object sender, EventArgs e) + { + if (!TryGetIdentifierFromSelectedRow(out var findId)) + { + return; + } + if (MessageBox.Show("Удалить запись?", "Удаление", + MessageBoxButtons.YesNo) != DialogResult.Yes) + { + return; + } + try + { + _executorRepository.DeleteExecutor(findId); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при удалении", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void LoadList() => dataGridView.DataSource = _executorRepository.ReadExecutors(); + private bool TryGetIdentifierFromSelectedRow(out int id) + { + id = 0; + if (dataGridView.SelectedRows.Count < 1) + { + MessageBox.Show("Нет выбранной записи", "Ошибка", + MessageBoxButtons.OK, MessageBoxIcon.Error); + return false; + } + id = + Convert.ToInt32(dataGridView.SelectedRows[0].Cells["Id"].Value); + return true; + } + } +} diff --git a/Forms/FormExecutorList.resx b/Forms/FormExecutorList.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/Forms/FormExecutorList.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Forms/FormOrganization.Designer.cs b/Forms/FormOrganization.Designer.cs new file mode 100644 index 0000000..30ef6fe --- /dev/null +++ b/Forms/FormOrganization.Designer.cs @@ -0,0 +1,145 @@ +namespace IT_Company.Forms +{ + partial class FormOrganization + { + /// + /// 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() + { + name = new TextBox(); + address = new TextBox(); + bankAccount = new TextBox(); + labelName = new Label(); + labelAddress = new Label(); + labelBankAccount = new Label(); + buttonSave = new Button(); + buttonCancel = new Button(); + SuspendLayout(); + // + // name + // + name.Anchor = AnchorStyles.Top | AnchorStyles.Right; + name.Location = new Point(226, 12); + name.Name = "name"; + name.Size = new Size(151, 27); + name.TabIndex = 0; + // + // address + // + address.Anchor = AnchorStyles.Top | AnchorStyles.Right; + address.Location = new Point(226, 45); + address.Name = "address"; + address.Size = new Size(151, 27); + address.TabIndex = 1; + // + // bankAccount + // + bankAccount.Anchor = AnchorStyles.Top | AnchorStyles.Right; + bankAccount.Location = new Point(226, 78); + bankAccount.Name = "bankAccount"; + bankAccount.Size = new Size(151, 27); + bankAccount.TabIndex = 2; + // + // labelName + // + labelName.AutoSize = true; + labelName.Location = new Point(12, 15); + labelName.Name = "labelName"; + labelName.Size = new Size(176, 20); + labelName.TabIndex = 5; + labelName.Text = "Название организации:"; + // + // labelAddress + // + labelAddress.AutoSize = true; + labelAddress.Location = new Point(12, 48); + labelAddress.Name = "labelAddress"; + labelAddress.Size = new Size(150, 20); + labelAddress.TabIndex = 6; + labelAddress.Text = "Адрес организации:"; + // + // labelBankAccount + // + labelBankAccount.AutoSize = true; + labelBankAccount.Location = new Point(12, 81); + labelBankAccount.Name = "labelBankAccount"; + labelBankAccount.Size = new Size(150, 20); + labelBankAccount.TabIndex = 7; + labelBankAccount.Text = "Банковский аккаунт:"; + // + // buttonSave + // + buttonSave.Anchor = AnchorStyles.Bottom | AnchorStyles.Left; + buttonSave.Location = new Point(12, 323); + buttonSave.Name = "buttonSave"; + buttonSave.Size = new Size(94, 29); + buttonSave.TabIndex = 10; + buttonSave.Text = "Сохранить"; + buttonSave.UseVisualStyleBackColor = true; + buttonSave.Click += buttonSave_Click; + // + // buttonCancel + // + buttonCancel.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonCancel.Location = new Point(283, 323); + buttonCancel.Name = "buttonCancel"; + buttonCancel.Size = new Size(94, 29); + buttonCancel.TabIndex = 11; + buttonCancel.Text = "Отмена"; + buttonCancel.UseVisualStyleBackColor = true; + buttonCancel.Click += buttonCancel_Click; + // + // FormOrganization + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(389, 362); + Controls.Add(buttonCancel); + Controls.Add(buttonSave); + Controls.Add(labelBankAccount); + Controls.Add(labelAddress); + Controls.Add(labelName); + Controls.Add(bankAccount); + Controls.Add(address); + Controls.Add(name); + Name = "FormOrganization"; + StartPosition = FormStartPosition.CenterParent; + Text = "Исполнитель"; + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private TextBox name; + private TextBox address; + private TextBox bankAccount; + private Label labelName; + private Label labelAddress; + private Label labelBankAccount; + private Button buttonSave; + private Button buttonCancel; + } +} \ No newline at end of file diff --git a/Forms/FormOrganization.cs b/Forms/FormOrganization.cs new file mode 100644 index 0000000..82a7d2f --- /dev/null +++ b/Forms/FormOrganization.cs @@ -0,0 +1,67 @@ +using IT_Company.Entities; +using IT_Company.Entities.Repositories; +using System.Data; +namespace IT_Company.Forms +{ + public partial class FormOrganization: Form + { + private readonly IOrganizationRepository _organizationRepository; + + private int? _organizationId; + public int Id + { + set + { + try + { + var organization = _organizationRepository.ReadOrganizationById(value); + if (organization != null) + { + throw new InvalidDataException(nameof(organization)); + } + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при получении данных", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + } + } + + public FormOrganization(IOrganizationRepository organizationRepository) + { + InitializeComponent(); + _organizationRepository = organizationRepository ?? throw new ArgumentNullException(nameof(organizationRepository)); + } + + private void buttonSave_Click(object sender, EventArgs e) + { + try + { + if(string.IsNullOrEmpty(name.Text) || string.IsNullOrEmpty(address.Text) || string.IsNullOrEmpty(bankAccount.Text)) + { + throw new DataException("Имеются незаполненные поля"); + } + if (_organizationId.HasValue) + { + _organizationRepository.UpdateOrganization(CreateOrganization(_organizationId.Value)); + } + else + { + _organizationRepository.CreateOrganization(CreateOrganization(0)); + } + Close(); + }catch(Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при сохранении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + private void buttonCancel_Click(object sender, EventArgs e) + { + Close(); + } + + private Organization CreateOrganization(int id) => Organization.CreateEntity(id,name.Text,address.Text,bankAccount.Text); + + } +} diff --git a/Forms/FormOrganization.resx b/Forms/FormOrganization.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/Forms/FormOrganization.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Forms/FormOrganizationList.Designer.cs b/Forms/FormOrganizationList.Designer.cs new file mode 100644 index 0000000..50d222a --- /dev/null +++ b/Forms/FormOrganizationList.Designer.cs @@ -0,0 +1,128 @@ +namespace IT_Company.Forms +{ + partial class FormOrganizationList + { + /// + /// 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() + { + dataGridView = new DataGridView(); + button1 = new Button(); + button2 = new Button(); + button3 = new Button(); + panel1 = new Panel(); + ((System.ComponentModel.ISupportInitialize)dataGridView).BeginInit(); + panel1.SuspendLayout(); + SuspendLayout(); + // + // dataGridView + // + dataGridView.AllowUserToAddRows = false; + dataGridView.AllowUserToDeleteRows = false; + dataGridView.AllowUserToResizeColumns = false; + dataGridView.AllowUserToResizeRows = false; + dataGridView.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill; + dataGridView.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + dataGridView.Dock = DockStyle.Fill; + dataGridView.Location = new Point(0, 0); + dataGridView.MultiSelect = false; + dataGridView.Name = "dataGridView"; + dataGridView.ReadOnly = true; + dataGridView.RowHeadersVisible = false; + dataGridView.RowHeadersWidth = 51; + dataGridView.SelectionMode = DataGridViewSelectionMode.FullRowSelect; + dataGridView.Size = new Size(800, 450); + dataGridView.TabIndex = 0; + // + // button1 + // + button1.Anchor = AnchorStyles.Right; + button1.Font = new Font("Segoe UI", 24F); + button1.Location = new Point(3, 3); + button1.Name = "button1"; + button1.Size = new Size(90, 90); + button1.TabIndex = 1; + button1.Text = "+"; + button1.UseVisualStyleBackColor = true; + button1.Click += ButtonAdd_Click; + // + // button2 + // + button2.Anchor = AnchorStyles.Right; + button2.Font = new Font("Segoe UI", 24F); + button2.Location = new Point(3, 99); + button2.Name = "button2"; + button2.Size = new Size(90, 90); + button2.TabIndex = 2; + button2.Text = "🗘"; + button2.UseVisualStyleBackColor = true; + button2.Click += ButtonUpd_Click; + // + // button3 + // + button3.Anchor = AnchorStyles.Right; + button3.Font = new Font("Segoe UI", 24F); + button3.Location = new Point(3, 195); + button3.Name = "button3"; + button3.Size = new Size(90, 90); + button3.TabIndex = 3; + button3.Text = "—"; + button3.UseVisualStyleBackColor = true; + button3.Click += ButtonDel_Click; + // + // panel1 + // + panel1.Controls.Add(button1); + panel1.Controls.Add(button3); + panel1.Controls.Add(button2); + panel1.Dock = DockStyle.Right; + panel1.Location = new Point(703, 0); + panel1.Name = "panel1"; + panel1.Size = new Size(97, 450); + panel1.TabIndex = 4; + // + // FormOrganizationList + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(800, 450); + Controls.Add(panel1); + Controls.Add(dataGridView); + Name = "FormOrganizationList"; + Text = "FormExecutors"; + ((System.ComponentModel.ISupportInitialize)dataGridView).EndInit(); + panel1.ResumeLayout(false); + ResumeLayout(false); + } + + #endregion + + private DataGridView dataGridView; + private Button button1; + private Button button2; + private Button button3; + private Panel panel1; + } +} \ No newline at end of file diff --git a/Forms/FormOrganizationList.cs b/Forms/FormOrganizationList.cs new file mode 100644 index 0000000..02cc410 --- /dev/null +++ b/Forms/FormOrganizationList.cs @@ -0,0 +1,104 @@ +using IT_Company.Entities.Repositories; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; +using Unity; + +namespace IT_Company.Forms +{ + public partial class FormOrganizationList : Form + { + private readonly IUnityContainer _container; + private readonly IOrganizationRepository _organizationRepository; + public FormOrganizationList(IUnityContainer container, IOrganizationRepository organizationRepository) + { + InitializeComponent(); + _container = container ?? throw new ArgumentNullException(nameof(container)); + _organizationRepository = organizationRepository ?? throw new ArgumentNullException(nameof(organizationRepository)); + } + private void Load(object sender, EventArgs e) + { + try + { + LoadList(); + }catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonAdd_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + LoadList(); + }catch(Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при добавлении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonUpd_Click(object sender, EventArgs e) + { + if(!TryGetIdentifierFromSelectedRow(out var findId)) + { + return; + } + try + { + var form = _container.Resolve(); + form.Id = findId; + form.ShowDialog(); + LoadList(); + }catch(Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при изменении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonDel_Click(object sender, EventArgs e) + { + if (!TryGetIdentifierFromSelectedRow(out var findId)) + { + return; + } + if (MessageBox.Show("Удалить запись?", "Удаление", + MessageBoxButtons.YesNo) != DialogResult.Yes) + { + return; + } + try + { + _organizationRepository.DeleteOrganization(findId); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при удалении", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void LoadList() => dataGridView.DataSource = _organizationRepository.ReadOrganizations(); + private bool TryGetIdentifierFromSelectedRow(out int id) + { + id = 0; + if (dataGridView.SelectedRows.Count < 1) + { + MessageBox.Show("Нет выбранной записи", "Ошибка", + MessageBoxButtons.OK, MessageBoxIcon.Error); + return false; + } + id = + Convert.ToInt32(dataGridView.SelectedRows[0].Cells["Id"].Value); + return true; + } + } +} diff --git a/Forms/FormOrganizationList.resx b/Forms/FormOrganizationList.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/Forms/FormOrganizationList.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Forms/FormService.Designer.cs b/Forms/FormService.Designer.cs new file mode 100644 index 0000000..1fe3a76 --- /dev/null +++ b/Forms/FormService.Designer.cs @@ -0,0 +1,125 @@ +namespace IT_Company.Forms +{ + partial class FormService + { + /// + /// 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() + { + description = new TextBox(); + price = new TextBox(); + labelDescription = new Label(); + labelPrice = new Label(); + buttonSave = new Button(); + buttonCancel = new Button(); + SuspendLayout(); + // + // description + // + description.Anchor = AnchorStyles.Top | AnchorStyles.Right; + description.Location = new Point(226, 12); + description.Name = "description"; + description.Size = new Size(151, 27); + description.TabIndex = 0; + // + // price + // + price.Anchor = AnchorStyles.Top | AnchorStyles.Right; + price.Location = new Point(226, 45); + price.Name = "price"; + price.Size = new Size(151, 27); + price.TabIndex = 1; + price.KeyPress += price_KeyPress; + // + // labelDescription + // + labelDescription.AutoSize = true; + labelDescription.Location = new Point(12, 15); + labelDescription.Name = "labelDescription"; + labelDescription.Size = new Size(82, 20); + labelDescription.TabIndex = 5; + labelDescription.Text = "Описание:"; + // + // labelPrice + // + labelPrice.AutoSize = true; + labelPrice.Location = new Point(12, 48); + labelPrice.Name = "labelPrice"; + labelPrice.Size = new Size(48, 20); + labelPrice.TabIndex = 6; + labelPrice.Text = "Цена:"; + // + // buttonSave + // + buttonSave.Anchor = AnchorStyles.Bottom | AnchorStyles.Left; + buttonSave.Location = new Point(12, 323); + buttonSave.Name = "buttonSave"; + buttonSave.Size = new Size(94, 29); + buttonSave.TabIndex = 10; + buttonSave.Text = "Сохранить"; + buttonSave.UseVisualStyleBackColor = true; + buttonSave.Click += buttonSave_Click; + // + // buttonCancel + // + buttonCancel.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonCancel.Location = new Point(283, 323); + buttonCancel.Name = "buttonCancel"; + buttonCancel.Size = new Size(94, 29); + buttonCancel.TabIndex = 11; + buttonCancel.Text = "Отмена"; + buttonCancel.UseVisualStyleBackColor = true; + buttonCancel.Click += buttonCancel_Click; + // + // FormService + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(389, 362); + Controls.Add(buttonCancel); + Controls.Add(buttonSave); + Controls.Add(labelPrice); + Controls.Add(labelDescription); + Controls.Add(price); + Controls.Add(description); + Name = "FormService"; + StartPosition = FormStartPosition.CenterParent; + Text = "Исполнитель"; + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private TextBox description; + private TextBox price; + private TextBox bankAccount; + private Label labelDescription; + private Label labelPrice; + private Label labelBankAccount; + private Button buttonSave; + private Button buttonCancel; + } +} \ No newline at end of file diff --git a/Forms/FormService.cs b/Forms/FormService.cs new file mode 100644 index 0000000..4c702f7 --- /dev/null +++ b/Forms/FormService.cs @@ -0,0 +1,75 @@ +using IT_Company.Entities; +using IT_Company.Entities.Repositories; +using System.Data; +namespace IT_Company.Forms +{ + public partial class FormService : Form + { + private readonly IServiceRepository _serviceRepository; + + private int? _serviceId; + public int Id + { + set + { + try + { + var service = _serviceRepository.ReadServiceById(value); + if (service != null) + { + throw new InvalidDataException(nameof(service)); + } + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при получении данных", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + } + } + + public FormService(IServiceRepository serviceRepository) + { + InitializeComponent(); + _serviceRepository = serviceRepository ?? throw new ArgumentNullException(nameof(serviceRepository)); + } + + private void buttonSave_Click(object sender, EventArgs e) + { + try + { + if (string.IsNullOrEmpty(description.Text) || string.IsNullOrEmpty(price.Text) || string.IsNullOrEmpty(bankAccount.Text)) + { + throw new DataException("Имеются незаполненные поля"); + } + if (_serviceId.HasValue) + { + _serviceRepository.UpdateService(CreateService(_serviceId.Value)); + } + else + { + _serviceRepository.CreateService(CreateService(0)); + } + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при сохранении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + private void buttonCancel_Click(object sender, EventArgs e) + { + Close(); + } + + private Service CreateService(int id) => Service.CreateEntity(id,int.Parse(price.Text),description.Text); + + + private void price_KeyPress(object sender, KeyPressEventArgs e) + { + char c = e.KeyChar; + if (!Char.IsDigit(c) && c != 8) + e.Handled = true; + } + } +} diff --git a/Forms/FormService.resx b/Forms/FormService.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/Forms/FormService.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Forms/FormServiceList.Designer.cs b/Forms/FormServiceList.Designer.cs new file mode 100644 index 0000000..00bac5a --- /dev/null +++ b/Forms/FormServiceList.Designer.cs @@ -0,0 +1,128 @@ +namespace IT_Company.Forms +{ + partial class FormServiceList + { + /// + /// 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() + { + dataGridView = new DataGridView(); + button1 = new Button(); + button2 = new Button(); + button3 = new Button(); + panel1 = new Panel(); + ((System.ComponentModel.ISupportInitialize)dataGridView).BeginInit(); + panel1.SuspendLayout(); + SuspendLayout(); + // + // dataGridView + // + dataGridView.AllowUserToAddRows = false; + dataGridView.AllowUserToDeleteRows = false; + dataGridView.AllowUserToResizeColumns = false; + dataGridView.AllowUserToResizeRows = false; + dataGridView.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill; + dataGridView.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + dataGridView.Dock = DockStyle.Fill; + dataGridView.Location = new Point(0, 0); + dataGridView.MultiSelect = false; + dataGridView.Name = "dataGridView"; + dataGridView.ReadOnly = true; + dataGridView.RowHeadersVisible = false; + dataGridView.RowHeadersWidth = 51; + dataGridView.SelectionMode = DataGridViewSelectionMode.FullRowSelect; + dataGridView.Size = new Size(800, 450); + dataGridView.TabIndex = 0; + // + // button1 + // + button1.Anchor = AnchorStyles.Right; + button1.Font = new Font("Segoe UI", 24F); + button1.Location = new Point(3, 3); + button1.Name = "button1"; + button1.Size = new Size(90, 90); + button1.TabIndex = 1; + button1.Text = "+"; + button1.UseVisualStyleBackColor = true; + button1.Click += ButtonAdd_Click; + // + // button2 + // + button2.Anchor = AnchorStyles.Right; + button2.Font = new Font("Segoe UI", 24F); + button2.Location = new Point(3, 99); + button2.Name = "button2"; + button2.Size = new Size(90, 90); + button2.TabIndex = 2; + button2.Text = "🗘"; + button2.UseVisualStyleBackColor = true; + button2.Click += ButtonUpd_Click; + // + // button3 + // + button3.Anchor = AnchorStyles.Right; + button3.Font = new Font("Segoe UI", 24F); + button3.Location = new Point(3, 195); + button3.Name = "button3"; + button3.Size = new Size(90, 90); + button3.TabIndex = 3; + button3.Text = "—"; + button3.UseVisualStyleBackColor = true; + button3.Click += ButtonDel_Click; + // + // panel1 + // + panel1.Controls.Add(button1); + panel1.Controls.Add(button3); + panel1.Controls.Add(button2); + panel1.Dock = DockStyle.Right; + panel1.Location = new Point(703, 0); + panel1.Name = "panel1"; + panel1.Size = new Size(97, 450); + panel1.TabIndex = 4; + // + // FormServiceList + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(800, 450); + Controls.Add(panel1); + Controls.Add(dataGridView); + Name = "FormServiceList"; + Text = "FormExecutors"; + ((System.ComponentModel.ISupportInitialize)dataGridView).EndInit(); + panel1.ResumeLayout(false); + ResumeLayout(false); + } + + #endregion + + private DataGridView dataGridView; + private Button button1; + private Button button2; + private Button button3; + private Panel panel1; + } +} \ No newline at end of file diff --git a/Forms/FormServiceList.cs b/Forms/FormServiceList.cs new file mode 100644 index 0000000..0945b2c --- /dev/null +++ b/Forms/FormServiceList.cs @@ -0,0 +1,104 @@ +using IT_Company.Entities.Repositories; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; +using Unity; + +namespace IT_Company.Forms +{ + public partial class FormServiceList : Form + { + private readonly IUnityContainer _container; + private readonly IServiceRepository _serviceRepository; + public FormServiceList(IUnityContainer container, IServiceRepository serviceRepository) + { + InitializeComponent(); + _container = container ?? throw new ArgumentNullException(nameof(container)); + _serviceRepository = serviceRepository ?? throw new ArgumentNullException(nameof(serviceRepository)); + } + private void Load(object sender, EventArgs e) + { + try + { + LoadList(); + }catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonAdd_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + LoadList(); + }catch(Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при добавлении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonUpd_Click(object sender, EventArgs e) + { + if(!TryGetIdentifierFromSelectedRow(out var findId)) + { + return; + } + try + { + var form = _container.Resolve(); + form.Id = findId; + form.ShowDialog(); + LoadList(); + }catch(Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при изменении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonDel_Click(object sender, EventArgs e) + { + if (!TryGetIdentifierFromSelectedRow(out var findId)) + { + return; + } + if (MessageBox.Show("Удалить запись?", "Удаление", + MessageBoxButtons.YesNo) != DialogResult.Yes) + { + return; + } + try + { + _serviceRepository.DeleteService(findId); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при удалении", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void LoadList() => dataGridView.DataSource = _serviceRepository.ReadServices(); + private bool TryGetIdentifierFromSelectedRow(out int id) + { + id = 0; + if (dataGridView.SelectedRows.Count < 1) + { + MessageBox.Show("Нет выбранной записи", "Ошибка", + MessageBoxButtons.OK, MessageBoxIcon.Error); + return false; + } + id = + Convert.ToInt32(dataGridView.SelectedRows[0].Cells["Id"].Value); + return true; + } + } +} diff --git a/Forms/FormServiceList.resx b/Forms/FormServiceList.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/Forms/FormServiceList.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/IT-Company.csproj b/IT-Company.csproj index fde08a2..5c98bf5 100644 --- a/IT-Company.csproj +++ b/IT-Company.csproj @@ -9,4 +9,49 @@ enable + + + + + + + + + + + Always + + + + + + Form + + + Form + + + Form + + + Form + + + Form + + + + True + True + Resources.resx + + + + + + ResXFileCodeGenerator + Resources.Designer.cs + + + \ No newline at end of file diff --git a/Program.cs b/Program.cs index f6b8872..fe3f78a 100644 --- a/Program.cs +++ b/Program.cs @@ -1,3 +1,9 @@ +using IT_Company.Entities.Repositories; +using IT_Company.Entities.Repositories.Implementations; +using Unity; +using Unity.Lifetime; +using IT_Company.Forms; + namespace IT_Company { internal static class Program @@ -11,7 +17,21 @@ namespace IT_Company // To customize application configuration such as set high DPI settings or default font, // see https://aka.ms/applicationconfiguration. ApplicationConfiguration.Initialize(); - Application.Run(new Form1()); + Application.Run(new FormIT(CreateConteiner())); + } + + private static IUnityContainer CreateConteiner() + { + var conteiner = new UnityContainer(); + + conteiner.RegisterType(new TransientLifetimeManager()); + conteiner.RegisterType(new TransientLifetimeManager()); + conteiner.RegisterType(new TransientLifetimeManager()); + conteiner.RegisterType(new TransientLifetimeManager()); + conteiner.RegisterType(new TransientLifetimeManager()); + + + return conteiner; } } } \ No newline at end of file diff --git a/Properties/DataSources/IT_Company.Entities.Service.datasource b/Properties/DataSources/IT_Company.Entities.Service.datasource new file mode 100644 index 0000000..beae323 --- /dev/null +++ b/Properties/DataSources/IT_Company.Entities.Service.datasource @@ -0,0 +1,10 @@ + + + + IT_Company.Entities.Service, IT-Company, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null + \ No newline at end of file diff --git a/Properties/Resources.Designer.cs b/Properties/Resources.Designer.cs new file mode 100644 index 0000000..b8ce74d --- /dev/null +++ b/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// Этот код создан программой. +// Исполняемая версия:4.0.30319.42000 +// +// Изменения в этом файле могут привести к неправильной работе и будут потеряны в случае +// повторной генерации кода. +// +//------------------------------------------------------------------------------ + +namespace IT_Company.Properties { + using System; + + + /// + /// Класс ресурса со строгой типизацией для поиска локализованных строк и т.д. + /// + // Этот класс создан автоматически классом StronglyTypedResourceBuilder + // с помощью такого средства, как ResGen или Visual Studio. + // Чтобы добавить или удалить член, измените файл .ResX и снова запустите ResGen + // с параметром /str или перестройте свой проект VS. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Возвращает кэшированный экземпляр ResourceManager, использованный этим классом. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("IT_Company.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Перезаписывает свойство CurrentUICulture текущего потока для всех + /// обращений к ресурсу с помощью этого класса ресурса со строгой типизацией. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + } +} diff --git a/Form1.resx b/Properties/Resources.resx similarity index 100% rename from Form1.resx rename to Properties/Resources.resx diff --git a/Resources/Background.jpg b/Resources/Background.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9fdbc95253405c62560d8553d9e12888d3342d6a GIT binary patch literal 228865 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%0DdEinaL%&6(pj!*Uf_ImpY}$0x4O_ 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 literal 0 HcmV?d00001