From a785f75585827b2ca8bba3f2043f79894dd831f6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=95=D1=81=D0=B5=D0=BD=D0=B8=D1=8F?= Date: Mon, 4 Nov 2024 20:23:58 +0400 Subject: [PATCH] =?UTF-8?q?=D0=9B=D0=B0=D0=B1=D0=BE=D1=80=D0=B0=D1=82?= =?UTF-8?q?=D0=BE=D1=80=D0=BD=D0=B0=D1=8F=20=D1=80=D0=B0=D0=B1=D0=BE=D1=82?= =?UTF-8?q?=D0=B0=201?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CompShop/CompShop/CompShop.csproj | 4 + CompShop/CompShop/Entites/Check.cs | 21 + CompShop/CompShop/Entites/Client.cs | 22 + CompShop/CompShop/Entites/Enums/ClientType.cs | 9 + .../CompShop/Entites/Enums/ProductType.cs | 17 + CompShop/CompShop/Entites/Product.cs | 22 + CompShop/CompShop/Entites/ProductInCheck.cs | 12 + .../CompShop/Entites/ProductsOnStorage.cs | 15 + CompShop/CompShop/Entites/Storage.cs | 14 + CompShop/CompShop/Form1.Designer.cs | 39 - CompShop/CompShop/Form1.cs | 10 - CompShop/CompShop/Form1.resx | 120 -- .../Forms/Clients/ClientForm.Designer.cs | 103 + CompShop/CompShop/Forms/Clients/ClientForm.cs | 102 + .../CompShop/Forms/Clients/ClientForm.resx | 60 + .../Clients/ClientFormSettings.Designer.cs | 132 ++ .../Forms/Clients/ClientFormSettings.cs | 87 + .../Forms/Clients/ClientFormSettings.resx | 60 + CompShop/CompShop/Forms/Form1.Designer.cs | 130 ++ CompShop/CompShop/Forms/Form1.cs | 48 + CompShop/CompShop/Forms/Form1.resx | 1758 +++++++++++++++++ .../Forms/Products/ProductForm.Designer.cs | 103 + .../CompShop/Forms/Products/ProductForm.cs | 101 + .../CompShop/Forms/Products/ProductForm.resx | 60 + .../Products/ProductSettingsForm.Designer.cs | 156 ++ .../Forms/Products/ProductSettingsForm.cs | 104 + .../Forms/Products/ProductSettingsForm.resx | 60 + .../ProductsOnStorageForm.Designer.cs | 90 + .../ProductsOnStorageForm.cs | 80 + .../ProductsOnStorageForm.resx | 60 + .../ProductsOnStorageSettingsForm.Designer.cs | 133 ++ .../ProductsOnStorageSettingsForm.cs | 101 + .../ProductsOnStorageSettingsForm.resx | 60 + .../Forms/Receipt/CheckForm.Designer.cs | 77 + CompShop/CompShop/Forms/Receipt/CheckForm.cs | 46 + .../CompShop/Forms/Receipt/CheckForm.resx | 60 + .../Receipt/CheckSettingsForm .Designer.cs | 134 ++ .../Forms/Receipt/CheckSettingsForm .cs | 74 + .../Forms/Receipt/CheckSettingsForm .resx | 66 + .../Forms/Storage/StorageForm.Designer.cs | 103 + .../CompShop/Forms/Storage/StorageForm.cs | 102 + .../CompShop/Forms/Storage/StorageForm.resx | 60 + .../Storage/StorageSettingsForm.Designer.cs | 109 + .../Forms/Storage/StorageSettingsForm.cs | 80 + .../Forms/Storage/StorageSettingsForm.resx | 60 + CompShop/CompShop/Program.cs | 21 +- CompShop/CompShop/Repos/ICheckRepository.cs | 11 + CompShop/CompShop/Repos/IClientRepository.cs | 13 + .../Repos/IProductOnStorageRepository.cs | 11 + CompShop/CompShop/Repos/IProductRepository.cs | 13 + CompShop/CompShop/Repos/IStorageRepository.cs | 13 + .../CompShop/Repos/Impements/CheckRepo.cs | 23 + .../CompShop/Repos/Impements/ClientRepo.cs | 33 + .../CompShop/Repos/Impements/ProductRepo.cs | 33 + .../Repos/Impements/ProductsOnStorageRepo.cs | 27 + .../CompShop/Repos/Impements/StorageRepo.cs | 32 + .../CompShop/photo_2024-10-27_23-57-36.jpg | Bin 0 -> 101390 bytes 57 files changed, 4922 insertions(+), 172 deletions(-) create mode 100644 CompShop/CompShop/Entites/Check.cs create mode 100644 CompShop/CompShop/Entites/Client.cs create mode 100644 CompShop/CompShop/Entites/Enums/ClientType.cs create mode 100644 CompShop/CompShop/Entites/Enums/ProductType.cs create mode 100644 CompShop/CompShop/Entites/Product.cs create mode 100644 CompShop/CompShop/Entites/ProductInCheck.cs create mode 100644 CompShop/CompShop/Entites/ProductsOnStorage.cs create mode 100644 CompShop/CompShop/Entites/Storage.cs delete mode 100644 CompShop/CompShop/Form1.Designer.cs delete mode 100644 CompShop/CompShop/Form1.cs delete mode 100644 CompShop/CompShop/Form1.resx create mode 100644 CompShop/CompShop/Forms/Clients/ClientForm.Designer.cs create mode 100644 CompShop/CompShop/Forms/Clients/ClientForm.cs create mode 100644 CompShop/CompShop/Forms/Clients/ClientForm.resx create mode 100644 CompShop/CompShop/Forms/Clients/ClientFormSettings.Designer.cs create mode 100644 CompShop/CompShop/Forms/Clients/ClientFormSettings.cs create mode 100644 CompShop/CompShop/Forms/Clients/ClientFormSettings.resx create mode 100644 CompShop/CompShop/Forms/Form1.Designer.cs create mode 100644 CompShop/CompShop/Forms/Form1.cs create mode 100644 CompShop/CompShop/Forms/Form1.resx create mode 100644 CompShop/CompShop/Forms/Products/ProductForm.Designer.cs create mode 100644 CompShop/CompShop/Forms/Products/ProductForm.cs create mode 100644 CompShop/CompShop/Forms/Products/ProductForm.resx create mode 100644 CompShop/CompShop/Forms/Products/ProductSettingsForm.Designer.cs create mode 100644 CompShop/CompShop/Forms/Products/ProductSettingsForm.cs create mode 100644 CompShop/CompShop/Forms/Products/ProductSettingsForm.resx create mode 100644 CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageForm.Designer.cs create mode 100644 CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageForm.cs create mode 100644 CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageForm.resx create mode 100644 CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageSettingsForm.Designer.cs create mode 100644 CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageSettingsForm.cs create mode 100644 CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageSettingsForm.resx create mode 100644 CompShop/CompShop/Forms/Receipt/CheckForm.Designer.cs create mode 100644 CompShop/CompShop/Forms/Receipt/CheckForm.cs create mode 100644 CompShop/CompShop/Forms/Receipt/CheckForm.resx create mode 100644 CompShop/CompShop/Forms/Receipt/CheckSettingsForm .Designer.cs create mode 100644 CompShop/CompShop/Forms/Receipt/CheckSettingsForm .cs create mode 100644 CompShop/CompShop/Forms/Receipt/CheckSettingsForm .resx create mode 100644 CompShop/CompShop/Forms/Storage/StorageForm.Designer.cs create mode 100644 CompShop/CompShop/Forms/Storage/StorageForm.cs create mode 100644 CompShop/CompShop/Forms/Storage/StorageForm.resx create mode 100644 CompShop/CompShop/Forms/Storage/StorageSettingsForm.Designer.cs create mode 100644 CompShop/CompShop/Forms/Storage/StorageSettingsForm.cs create mode 100644 CompShop/CompShop/Forms/Storage/StorageSettingsForm.resx create mode 100644 CompShop/CompShop/Repos/ICheckRepository.cs create mode 100644 CompShop/CompShop/Repos/IClientRepository.cs create mode 100644 CompShop/CompShop/Repos/IProductOnStorageRepository.cs create mode 100644 CompShop/CompShop/Repos/IProductRepository.cs create mode 100644 CompShop/CompShop/Repos/IStorageRepository.cs create mode 100644 CompShop/CompShop/Repos/Impements/CheckRepo.cs create mode 100644 CompShop/CompShop/Repos/Impements/ClientRepo.cs create mode 100644 CompShop/CompShop/Repos/Impements/ProductRepo.cs create mode 100644 CompShop/CompShop/Repos/Impements/ProductsOnStorageRepo.cs create mode 100644 CompShop/CompShop/Repos/Impements/StorageRepo.cs create mode 100644 CompShop/CompShop/photo_2024-10-27_23-57-36.jpg diff --git a/CompShop/CompShop/CompShop.csproj b/CompShop/CompShop/CompShop.csproj index 663fdb8..894afcd 100644 --- a/CompShop/CompShop/CompShop.csproj +++ b/CompShop/CompShop/CompShop.csproj @@ -8,4 +8,8 @@ enable + + + + \ No newline at end of file diff --git a/CompShop/CompShop/Entites/Check.cs b/CompShop/CompShop/Entites/Check.cs new file mode 100644 index 0000000..2127902 --- /dev/null +++ b/CompShop/CompShop/Entites/Check.cs @@ -0,0 +1,21 @@ +namespace CompShop.Entites +{ + public class Check + { + public int Id { get; set; } + public List Products { get; set; } + public Client Client { get; set; } + public DateTime PurchaseDate { get; set; } + + public static Check CreateEntity(int id, List products, Client client, DateTime purchaseDate) + { + return new Check + { + Id = id, + Products = products, + Client = client, + PurchaseDate = purchaseDate + }; + } + } +} diff --git a/CompShop/CompShop/Entites/Client.cs b/CompShop/CompShop/Entites/Client.cs new file mode 100644 index 0000000..bef56cc --- /dev/null +++ b/CompShop/CompShop/Entites/Client.cs @@ -0,0 +1,22 @@ +using CompShop.Entites.Enums; +namespace CompShop.Entites +{ + public class Client + { + public int Id { get; set; } + public string Name { get; set; } + public string PhoneNumber { get; set; } + public ClientType ClientType { get; set; } + + public static Client CreateEntity(int id, string name, string phoneNumber, ClientType clientType) + { + return new Client + { + Id = id, + Name = name, + PhoneNumber = phoneNumber, + ClientType = clientType + }; + } + } +} diff --git a/CompShop/CompShop/Entites/Enums/ClientType.cs b/CompShop/CompShop/Entites/Enums/ClientType.cs new file mode 100644 index 0000000..ecc7aad --- /dev/null +++ b/CompShop/CompShop/Entites/Enums/ClientType.cs @@ -0,0 +1,9 @@ +namespace CompShop.Entites.Enums +{ + public enum ClientType + { + None = 0, + Individual = 1, + Business = 2 + } +} diff --git a/CompShop/CompShop/Entites/Enums/ProductType.cs b/CompShop/CompShop/Entites/Enums/ProductType.cs new file mode 100644 index 0000000..a30a50b --- /dev/null +++ b/CompShop/CompShop/Entites/Enums/ProductType.cs @@ -0,0 +1,17 @@ +namespace CompShop.Entites.Enums +{ + [Flags] + public enum ProductType + { + None = 0, + Laptop = 1, + Desktop = 2, // Настольный компьютер + Monitor = 4, // Монитор + Keyboard = 8, // Клавиатура + Mouse = 16, // Мышь + Headset = 32, // Наушники + Webcam = 64, // Веб-камера + Printer = 128, // Принтер + Software = 256 // Программное обеспечение + } +} diff --git a/CompShop/CompShop/Entites/Product.cs b/CompShop/CompShop/Entites/Product.cs new file mode 100644 index 0000000..aea69d1 --- /dev/null +++ b/CompShop/CompShop/Entites/Product.cs @@ -0,0 +1,22 @@ +using CompShop.Entites.Enums; + +namespace CompShop.Entites +{ + public class Product + { + public int ID { get; private set; } + public string Name { get; private set; } + public string Description { get; private set; } + public decimal Price { get; private set; } + public ProductType ProductType { get; private set; } + + public static Product CreateEntity(int id, string name, string desc, decimal price, ProductType productType) + { + return new Product { ID = id, + Name = name ?? string.Empty, + Description = desc ?? string.Empty, + Price = price, + ProductType = productType }; + } + } +} diff --git a/CompShop/CompShop/Entites/ProductInCheck.cs b/CompShop/CompShop/Entites/ProductInCheck.cs new file mode 100644 index 0000000..9dab523 --- /dev/null +++ b/CompShop/CompShop/Entites/ProductInCheck.cs @@ -0,0 +1,12 @@ +namespace CompShop.Entites +{ + public class ProductInCheck + { + public int ID { get; set; } + public int Count { get; set; } + public static ProductInCheck CreateElement(int id, int count) + { + return new ProductInCheck { ID = id, Count = count}; + } + } +} diff --git a/CompShop/CompShop/Entites/ProductsOnStorage.cs b/CompShop/CompShop/Entites/ProductsOnStorage.cs new file mode 100644 index 0000000..7bec734 --- /dev/null +++ b/CompShop/CompShop/Entites/ProductsOnStorage.cs @@ -0,0 +1,15 @@ +namespace CompShop.Entites +{ + public class ProductsOnStorage + { + public int Id { get; set; } + public Product Product { get; set; } + public Storage Storage { get; set; } + public int Count { get; set; } + + public static ProductsOnStorage CreateEntity(int id, Product product, Storage storage, int count) + { + return new ProductsOnStorage { Storage = storage, Id = id, Product = product, Count = count }; + } + } +} diff --git a/CompShop/CompShop/Entites/Storage.cs b/CompShop/CompShop/Entites/Storage.cs new file mode 100644 index 0000000..f7136e1 --- /dev/null +++ b/CompShop/CompShop/Entites/Storage.cs @@ -0,0 +1,14 @@ +namespace CompShop.Entites +{ + public class Storage + { + public int Id { get; set; } + public int Size { get; set; } // Вместимость + public string Adress { get; set; } + + public static Storage CreateEntity(int id, int size, string adress) + { + return new Storage { Id = id, Size = size, Adress = adress }; + } + } +} diff --git a/CompShop/CompShop/Form1.Designer.cs b/CompShop/CompShop/Form1.Designer.cs deleted file mode 100644 index 71e1057..0000000 --- a/CompShop/CompShop/Form1.Designer.cs +++ /dev/null @@ -1,39 +0,0 @@ -namespace CompShop -{ - 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/CompShop/CompShop/Form1.cs b/CompShop/CompShop/Form1.cs deleted file mode 100644 index 3107eff..0000000 --- a/CompShop/CompShop/Form1.cs +++ /dev/null @@ -1,10 +0,0 @@ -namespace CompShop -{ - public partial class Form1 : Form - { - public Form1() - { - InitializeComponent(); - } - } -} diff --git a/CompShop/CompShop/Form1.resx b/CompShop/CompShop/Form1.resx deleted file mode 100644 index 1af7de1..0000000 --- a/CompShop/CompShop/Form1.resx +++ /dev/null @@ -1,120 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 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/CompShop/CompShop/Forms/Clients/ClientForm.Designer.cs b/CompShop/CompShop/Forms/Clients/ClientForm.Designer.cs new file mode 100644 index 0000000..8d32bad --- /dev/null +++ b/CompShop/CompShop/Forms/Clients/ClientForm.Designer.cs @@ -0,0 +1,103 @@ +namespace CompShop.Forms +{ + partial class ClientForm + { + /// + /// 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() + { + deleteButton = new Button(); + editButton = new Button(); + addButton = new Button(); + productsDataGridView = new DataGridView(); + ((System.ComponentModel.ISupportInitialize)productsDataGridView).BeginInit(); + SuspendLayout(); + // + // deleteButton + // + deleteButton.Location = new Point(869, 144); + deleteButton.Name = "deleteButton"; + deleteButton.Size = new Size(161, 60); + deleteButton.TabIndex = 7; + deleteButton.Text = "Удалить"; + deleteButton.UseVisualStyleBackColor = true; + deleteButton.Click += deleteButton_Click; + // + // editButton + // + editButton.Location = new Point(869, 78); + editButton.Name = "editButton"; + editButton.Size = new Size(161, 60); + editButton.TabIndex = 6; + editButton.Text = "Редактировать"; + editButton.UseVisualStyleBackColor = true; + editButton.Click += editButton_Click; + // + // addButton + // + addButton.BackColor = SystemColors.Control; + addButton.Location = new Point(869, 12); + addButton.Name = "addButton"; + addButton.Size = new Size(161, 60); + addButton.TabIndex = 5; + addButton.Text = "Добавить"; + addButton.UseVisualStyleBackColor = false; + addButton.Click += addButton_Click; + // + // productsDataGridView + // + productsDataGridView.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left; + productsDataGridView.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + productsDataGridView.Location = new Point(12, 12); + productsDataGridView.Name = "productsDataGridView"; + productsDataGridView.RowHeadersWidth = 51; + productsDataGridView.RowTemplate.Height = 29; + productsDataGridView.Size = new Size(851, 400); + productsDataGridView.TabIndex = 4; + // + // ClientForm + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(1056, 424); + Controls.Add(deleteButton); + Controls.Add(editButton); + Controls.Add(addButton); + Controls.Add(productsDataGridView); + Name = "ClientForm"; + Text = "Клиенты"; + Load += ClientForm_Load; + ((System.ComponentModel.ISupportInitialize)productsDataGridView).EndInit(); + ResumeLayout(false); + } + + #endregion + + private Button deleteButton; + private Button editButton; + private Button addButton; + private DataGridView productsDataGridView; + } +} \ No newline at end of file diff --git a/CompShop/CompShop/Forms/Clients/ClientForm.cs b/CompShop/CompShop/Forms/Clients/ClientForm.cs new file mode 100644 index 0000000..fab2adf --- /dev/null +++ b/CompShop/CompShop/Forms/Clients/ClientForm.cs @@ -0,0 +1,102 @@ +using CompShop.Forms.Clients; +using CompShop.Repos; +using Unity; + +namespace CompShop.Forms +{ + public partial class ClientForm : Form + { + private readonly IUnityContainer _container; + private readonly IClientRepository _repository; + + public ClientForm(IUnityContainer unityContainer, IClientRepository clientRepository) + { + InitializeComponent(); + + _container = unityContainer ?? throw new ArgumentNullException(nameof(unityContainer)); + _repository = clientRepository ?? throw new ArgumentNullException(nameof(_repository)); + } + + private void ClientForm_Load(object sender, EventArgs e) + { + try + { + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + private void LoadList() => productsDataGridView.DataSource = _repository.ReadAll(); + + private bool TryGetIdentifierFromSelectedRow(out int id) + { + id = 0; + if (productsDataGridView.SelectedRows.Count < 1) + { + MessageBox.Show("Нет выбранной записи", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error); + return false; + } + + id = Convert.ToInt32(productsDataGridView.SelectedRows[0].Cells["Id"].Value); + return true; + } + + private void addButton_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при добавлении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void editButton_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 deleteButton_Click(object sender, EventArgs e) + { + if (!TryGetIdentifierFromSelectedRow(out var findId)) + { + return; + } + + if (MessageBox.Show("Удалить запись?", "Удаление", MessageBoxButtons.YesNo) != DialogResult.Yes) + { + return; + } + + try + { + _repository.Delete(findId); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при удалении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + } +} diff --git a/CompShop/CompShop/Forms/Clients/ClientForm.resx b/CompShop/CompShop/Forms/Clients/ClientForm.resx new file mode 100644 index 0000000..f298a7b --- /dev/null +++ b/CompShop/CompShop/Forms/Clients/ClientForm.resx @@ -0,0 +1,60 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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/CompShop/CompShop/Forms/Clients/ClientFormSettings.Designer.cs b/CompShop/CompShop/Forms/Clients/ClientFormSettings.Designer.cs new file mode 100644 index 0000000..a67d60e --- /dev/null +++ b/CompShop/CompShop/Forms/Clients/ClientFormSettings.Designer.cs @@ -0,0 +1,132 @@ +namespace CompShop.Forms.Clients +{ + partial class ClientFormSettings + { + /// + /// 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() + { + label2 = new Label(); + label1 = new Label(); + nameTextbox = new TextBox(); + saveButton = new Button(); + phoneNumberTextbox = new TextBox(); + typeCombobox = new ComboBox(); + label4 = new Label(); + SuspendLayout(); + // + // label2 + // + label2.AutoSize = true; + label2.Location = new Point(13, 59); + label2.Name = "label2"; + label2.Size = new Size(130, 20); + label2.TabIndex = 13; + label2.Text = "Номер телефона:"; + // + // label1 + // + label1.AutoSize = true; + label1.Location = new Point(13, 12); + label1.Name = "label1"; + label1.Size = new Size(122, 20); + label1.TabIndex = 11; + label1.Text = "Имя покупателя"; + // + // nameTextbox + // + nameTextbox.Location = new Point(153, 12); + nameTextbox.Name = "nameTextbox"; + nameTextbox.Size = new Size(210, 27); + nameTextbox.TabIndex = 10; + // + // saveButton + // + saveButton.Anchor = AnchorStyles.Bottom; + saveButton.Location = new Point(153, 229); + saveButton.Name = "saveButton"; + saveButton.Size = new Size(94, 29); + saveButton.TabIndex = 9; + saveButton.Text = "Сохранить"; + saveButton.UseVisualStyleBackColor = true; + saveButton.Click += saveButton_Click; + // + // phoneNumberTextbox + // + phoneNumberTextbox.Location = new Point(153, 59); + phoneNumberTextbox.Name = "phoneNumberTextbox"; + phoneNumberTextbox.Size = new Size(210, 27); + phoneNumberTextbox.TabIndex = 18; + // + // typeCombobox + // + typeCombobox.FormattingEnabled = true; + typeCombobox.Location = new Point(153, 101); + typeCombobox.Name = "typeCombobox"; + typeCombobox.Size = new Size(151, 28); + typeCombobox.TabIndex = 20; + // + // label4 + // + label4.AutoSize = true; + label4.Location = new Point(13, 104); + label4.Name = "label4"; + label4.Size = new Size(38, 20); + label4.TabIndex = 19; + label4.Text = "Вид:"; + // + // ClientFormSettings + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(388, 270); + Controls.Add(typeCombobox); + Controls.Add(label4); + Controls.Add(phoneNumberTextbox); + Controls.Add(label2); + Controls.Add(label1); + Controls.Add(nameTextbox); + Controls.Add(saveButton); + Name = "ClientFormSettings"; + Text = "Регистрация клиента"; + Load += ClientFormSettings_Load; + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private ComboBox typeCombobox; + private Label label4; + private Label label3; + private NumericUpDown priceNumeric; + private Label label2; + private TextBox descriptionTextbox; + private Label label1; + private TextBox nameTextbox; + private Button saveButton; + private TextBox phoneNumberTextbox; + } +} \ No newline at end of file diff --git a/CompShop/CompShop/Forms/Clients/ClientFormSettings.cs b/CompShop/CompShop/Forms/Clients/ClientFormSettings.cs new file mode 100644 index 0000000..6c4d272 --- /dev/null +++ b/CompShop/CompShop/Forms/Clients/ClientFormSettings.cs @@ -0,0 +1,87 @@ +using CompShop.Entites.Enums; +using CompShop.Entites; +using CompShop.Repos; + +namespace CompShop.Forms.Clients +{ + public partial class ClientFormSettings : Form + { + private readonly IClientRepository _repository; + + private int? _clientId; + + public int Id + { + set + { + try + { + var client = _repository.Read(value); + if (client != null) + { + throw new InvalidDataException(nameof(client)); + } + nameTextbox.Text = client.Name; + phoneNumberTextbox.Text = client.PhoneNumber; + typeCombobox.SelectedItem = client.ClientType; + + _clientId = value; + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при данных", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + } + } + + public ClientFormSettings(IClientRepository clientRepository) + { + InitializeComponent(); + _repository = clientRepository ?? throw new ArgumentNullException(nameof(clientRepository)); + typeCombobox.DataSource = Enum.GetValues(typeof(ClientType)); + + } + + private void ClientFormSettings_Load(object sender, EventArgs e) + { + + } + + private void saveButton_Click(object sender, EventArgs e) + { + try + { + if (string.IsNullOrWhiteSpace(nameTextbox.Text) || + string.IsNullOrWhiteSpace(phoneNumberTextbox.Text) || typeCombobox.SelectedIndex < 1 + || typeCombobox.SelectedIndex < 1) + { + throw new Exception("Имеются незаполненные поля"); + } + + if (_clientId.HasValue) + { + + _repository.Update(CreateClient(_clientId.Value)); + } + else + { + + _repository.Update(CreateClient(0)); + } + + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при сохранении", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + private Client CreateClient(int id) + { + return Client.CreateEntity(id, nameTextbox.Text, phoneNumberTextbox.Text, (ClientType)typeCombobox.SelectedValue); + } + + } +} diff --git a/CompShop/CompShop/Forms/Clients/ClientFormSettings.resx b/CompShop/CompShop/Forms/Clients/ClientFormSettings.resx new file mode 100644 index 0000000..f298a7b --- /dev/null +++ b/CompShop/CompShop/Forms/Clients/ClientFormSettings.resx @@ -0,0 +1,60 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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/CompShop/CompShop/Forms/Form1.Designer.cs b/CompShop/CompShop/Forms/Form1.Designer.cs new file mode 100644 index 0000000..8ab7949 --- /dev/null +++ b/CompShop/CompShop/Forms/Form1.Designer.cs @@ -0,0 +1,130 @@ +namespace CompShop +{ + partial class ShopForm + { + /// + /// 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(ShopForm)); + menuStrip1 = new MenuStrip(); + справочникиToolStripMenuItem = new ToolStripMenuItem(); + товарыToolStripMenuItem = new ToolStripMenuItem(); + клиентыToolStripMenuItem = new ToolStripMenuItem(); + складыToolStripMenuItem = new ToolStripMenuItem(); + операцииToolStripMenuItem = new ToolStripMenuItem(); + товарыНаСкаледToolStripMenuItem = new ToolStripMenuItem(); + чекиToolStripMenuItem = new ToolStripMenuItem(); + menuStrip1.SuspendLayout(); + SuspendLayout(); + // + // menuStrip1 + // + menuStrip1.ImageScalingSize = new Size(20, 20); + menuStrip1.Items.AddRange(new ToolStripItem[] { справочники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[] { товарыToolStripMenuItem, клиентыToolStripMenuItem, складыToolStripMenuItem }); + справочникиToolStripMenuItem.Name = "справочникиToolStripMenuItem"; + справочникиToolStripMenuItem.Size = new Size(126, 24); + справочникиToolStripMenuItem.Text = "Справочники..."; + // + // товарыToolStripMenuItem + // + товарыToolStripMenuItem.Name = "товарыToolStripMenuItem"; + товарыToolStripMenuItem.Size = new Size(152, 26); + товарыToolStripMenuItem.Text = "Товары"; + товарыToolStripMenuItem.Click += товарыToolStripMenuItem_Click; + // + // клиентыToolStripMenuItem + // + клиентыToolStripMenuItem.Name = "клиентыToolStripMenuItem"; + клиентыToolStripMenuItem.Size = new Size(152, 26); + клиентыToolStripMenuItem.Text = "Клиенты"; + клиентыToolStripMenuItem.Click += клиентыToolStripMenuItem_Click; + // + // складыToolStripMenuItem + // + складыToolStripMenuItem.Name = "складыToolStripMenuItem"; + складыToolStripMenuItem.Size = new Size(152, 26); + складыToolStripMenuItem.Text = "Склады"; + складыToolStripMenuItem.Click += складыToolStripMenuItem_Click; + // + // операцииToolStripMenuItem + // + операцииToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { товарыНаСкаледToolStripMenuItem, чекиToolStripMenuItem }); + операцииToolStripMenuItem.Name = "операцииToolStripMenuItem"; + операцииToolStripMenuItem.Size = new Size(104, 24); + операцииToolStripMenuItem.Text = "Операции..."; + // + // товарыНаСкаледToolStripMenuItem + // + товарыНаСкаледToolStripMenuItem.Name = "товарыНаСкаледToolStripMenuItem"; + товарыНаСкаледToolStripMenuItem.Size = new Size(224, 26); + товарыНаСкаледToolStripMenuItem.Text = "Товары на складе"; + товарыНаСкаледToolStripMenuItem.Click += товарыНаСкаледToolStripMenuItem_Click; + // + // чекиToolStripMenuItem + // + чекиToolStripMenuItem.Name = "чекиToolStripMenuItem"; + чекиToolStripMenuItem.Size = new Size(224, 26); + чекиToolStripMenuItem.Text = "Чеки..."; + чекиToolStripMenuItem.Click += чекиToolStripMenuItem_Click; + // + // ShopForm + // + 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 = "ShopForm"; + Text = "Магазин электроники"; + menuStrip1.ResumeLayout(false); + menuStrip1.PerformLayout(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private MenuStrip menuStrip1; + private ToolStripMenuItem справочникиToolStripMenuItem; + private ToolStripMenuItem товарыToolStripMenuItem; + private ToolStripMenuItem клиентыToolStripMenuItem; + private ToolStripMenuItem складыToolStripMenuItem; + private ToolStripMenuItem операцииToolStripMenuItem; + private ToolStripMenuItem товарыНаСкаледToolStripMenuItem; + private ToolStripMenuItem чекиToolStripMenuItem; + } +} \ No newline at end of file diff --git a/CompShop/CompShop/Forms/Form1.cs b/CompShop/CompShop/Forms/Form1.cs new file mode 100644 index 0000000..f81a502 --- /dev/null +++ b/CompShop/CompShop/Forms/Form1.cs @@ -0,0 +1,48 @@ +using CompShop.Forms; +using CompShop.Forms.ProductsOnStorage; +using CompShop.Forms.Receipt; +using CompShop.Forms.Storage; +using Unity; + +namespace CompShop +{ + public partial class ShopForm : Form + { + private readonly IUnityContainer _container; + + public ShopForm(IUnityContainer container) + { + InitializeComponent(); + + _container = container ?? throw new ArgumentNullException(nameof(container)); + } + + private void ToolStripMenuItem_Click(object sender, EventArgs e) + { + _container.Resolve().ShowDialog(); + } + + private void ToolStripMenuItem_Click(object sender, EventArgs e) + { + _container.Resolve().ShowDialog(); + } + + private void ToolStripMenuItem_Click(object sender, EventArgs e) + { + _container.Resolve().ShowDialog(); + + } + + private void ToolStripMenuItem_Click(object sender, EventArgs e) + { + _container.Resolve().ShowDialog(); + + } + + private void ToolStripMenuItem_Click(object sender, EventArgs e) + { + _container.Resolve().ShowDialog(); + + } + } +} \ No newline at end of file diff --git a/CompShop/CompShop/Forms/Form1.resx b/CompShop/CompShop/Forms/Form1.resx new file mode 100644 index 0000000..949581d --- /dev/null +++ b/CompShop/CompShop/Forms/Form1.resx @@ -0,0 +1,1758 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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/4AAQSkZJRgABAQEASABIAAD/4gIoSUNDX1BST0ZJTEUAAQEAAAIYAAAAAAQwAABtbnRyUkdCIFhZ + WiAAAAAAAAAAAAAAAABhY3NwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA9tYAAQAAAADTLQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlkZXNjAAAA8AAA + AHRyWFlaAAABZAAAABRnWFlaAAABeAAAABRiWFlaAAABjAAAABRyVFJDAAABoAAAAChnVFJDAAABoAAA + AChiVFJDAAABoAAAACh3dHB0AAAByAAAABRjcHJ0AAAB3AAAADxtbHVjAAAAAAAAAAEAAAAMZW5VUwAA + AFgAAAAcAHMAUgBHAEIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFhZWiAAAAAAAABvogAAOPUAAAOQWFlaIAAA + AAAAAGKZAAC3hQAAGNpYWVogAAAAAAAAJKAAAA+EAAC2z3BhcmEAAAAAAAQAAAACZmYAAPKnAAANWQAA + E9AAAApbAAAAAAAAAABYWVogAAAAAAAA9tYAAQAAAADTLW1sdWMAAAAAAAAAAQAAAAxlblVTAAAAIAAA + ABwARwBvAG8AZwBsAGUAIABJAG4AYwAuACAAMgAwADEANv/bAEMABAMDBAMDBAQDBAUEBAUGCgcGBgYG + DQkKCAoPDRAQDw0PDhETGBQREhcSDg8VHBUXGRkbGxsQFB0fHRofGBobGv/bAEMBBAUFBgUGDAcHDBoR + DxEaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGv/CABEIAewC + 4AMBIgACEQEDEQH/xAAcAAACAwEBAQEAAAAAAAAAAAAFBgMEBwIBAAj/xAAZAQADAQEBAAAAAAAAAAAA + AAAAAQIDBAX/2gAMAwEAAhADEAAAARFKaGCTur8y6MMTSgEZGJOeK+cza3cnhuVP2aJhqx64Wfdgc8Sa + qYtmm+oXxDTf2v8APexpfA17P0foGbN38Vqsls2dPVxPsbQYRyP035augKTkshqAn7rLDMskHtqOTOqy + gL6F+j1rGtRgkEmDebIiGAdpK7cFFrD01CTWFvzodjp58LJIqwX67Em4xBGWblShL8H9k2K3B2nZTgb6 + Ui5G7+sQPb0NqP0mUzazy4CAC+EuaB3tvoKPtzgK30vDPO/vhcdw/B77H61qUc0mZUn8ohIcVxdzo5FV + PIu9VRXDqTWhknVnYb6Nx0dG0ydx5mWkUU047CVbOzDaUpo4rqIRHIJhhGilzFdW6o1LRUyr2ndIhIuH + bQO1Gh6XPwqMYNlyeMi1nIMgBbscSVm5W1WJJ6txHf5jlRL82l53WGEZDyrIi2ELqsltbvh901CbrUKu + rtNOKFRi2rOlwjAJuWmPn0BnRk6xdEM6cC7IIadCQnGVgH+NnqEUA9gWDSg+0weLPL4dR/TBW7IBaLMU + 0QVZYy9JwP8AFiATbH183YVtXX2g5gnBc1Al3nOi7WIsUfdcx65iYSw+Wwkkc3LtCjgGildpRpwwm+Aq + LbmLbAwEggA5Ivdpdj6r7hRoEq9GbDXWerrQio1nysUZp+MysXv2XGirCcsFgShIlI58vgTXlQD67Pm2 + KMO1Z1QIdszAlfSgIZsu6tnyol6gF9ZuPecUIP0rIAswY1lf6wyjZLr3TMZVTJRTy0PpugZnVhmc9JQm + RnLBTXNHpTWKhtdU1efWO4tcqNIwKAUYgKgv9M54My7YKjPicVJDjWhkC6fzgvIyoryB1yWYWNf6JaL4 + ozya02BIUKnbbWPuth0S6B08bvNvgMNsSsS2K6snYbVzDxSnlEwhQEBzLVKuy/UUkt/9ikWJxrqVKs5M + SqnMBIDi1MfBtnQRrNjl6Vqoy1cPUiZ1plrmYia1Z9LyWnPmQ6GNHGkBz6lGZFpy9tS86IyaQoG1DG1X + t9l2kYNeIQr6mlFRMy3RENNXHT43hXu05tFCJrvvBowXV3Su7EEOcAe0zwSE6aMTu0MqyEbp+Sl+iTQB + xzzaLyWvrAGwVHPXFRpkgtG+cW/qyzIFtCeWnW7EYV+Cn1rozFdzdAUdGhmfuzTWAC5S/KT6GmrLBhCi + sgzzJxqQpWRSzGT5XuJ8H/RqY6xUgsMXADRk0yqYbenLOmwWUmgzyk6FlZkL2EuKkTBSxtWGnxefTE95 + 4578904LJaY8WxNkCGYagkS1qat2OxPWmTeTKiy5UImGXt84OLo6W3Ggl3KrF69B0xXal9gx0O4bs2Q5 + snMP687W9pOcsm8NlZU47c26VfIiIQw2rSbkv6PGTr+X2vc4pF1Rea+TyJC1W3tOV+U6FHvtTm1uvVXv + EsIbCmXDn35b0L0V2BHgY1IgV1zwgtPm9pp/jAlmiQiuDzZEJLKVWgaoqebn6BfaFGT2wL61beE0uhcp + J/GxEubuel7yajTZKjkBq2e6GqFDJIEi8XFxpeGtgCaquSK16zL5ZoUhrICZ4LA0kEQkXyTHGi8SYlBq + YdbHQ3S6Ev7Zmg9CAZ2BajyrVbCcyAYscA2BlHUgGVnWzKYiNHL5VslvrquK2m0vQjMafeMYTNp/SkWJ + ek/oiPD3Clfq+2OXZE+0xWtYVWda7tZDPEdTYPj1zbJzo+Z9U66ICeZ2RiVa8pu4TZVboVgg56WyJaMF + +Q6l6y451oOe3JjYcaa98k9iqyTdnxf4zqzcrG7mNoz6SlaCmi6pJJ9SS+IbdOlzQKe0p9DVGLHUItNi + JA9FV8vJ0ANg9ICnl406ZIa/rgS05i4KnamDrh7peV6NBj3kIHWW++geI1lz/NmiJ7P2qniczqGM/nTY + W/G9OlN+ejpSimcaGBFVKw6LcprWuk09IzHScrbTXvPXfGg4Zkznef1XlLxbqfzNAWCSbuzr5qHkU205 + VYUb8iFSbqnAtNVYdn+pAd8oU9wutCY2lLzpc986p/FzHaon3LNxaQxkZwHq7skVBoHOb3gRSHeXJeUH + 8BucAeVKTSjPWkr3f320+2qnQ2dlBtvPcEnfIcoWlobFxgU2bk7uRQlg15bBKpdSkE3xVSNtDLtM2NM0 + 6lTqlLOPTalu0sN5dARWjfhWkbV0LfMdS/U/56pL5Md9FbxJZhk/OUPta3qGpZDq2FUOSViGHY4FdjQy + Z4Na0YjhwUN3TcpY9GXa8D1+ExY/+goKWb7sk3rjGlzfQqtlNC7mbKZws19ovm1MpmHNCyfWefX81O+P + vXbl4uOq3lUsC9VdN1IZE0fc80eYZvnzzEl+lksGK71SoyjQCyjUhPGHpys8N/QL5O4CbpGhtW0YrwWm + ojITQhiz4odDM8g7AFw8XqER0HTc/aKuShNMmieHwyuBSgGpF3RloGSLihouLsVzDq768ZIS4XCENMNV + F1aGub0pBfRwDTNeG78fUqnABGjdOhmuoZeG3Wa/cVYRbCsC5X5+0POo56XbcvNgZy/BKKNktFBEFOat + UYZ97W0M8+OaOhnrLHoExsxVNZ3peYxfiTnr7qyP9gDXPqNEMftC0Z7lahMhLAajZSxGb033Pr9DlCBt + DpZnrwgnN2k9wMevutRLP+Sy9onPpYZ9FW+G+iv6RlWoRbDnmiBUkD1gFJ+VKwoCV6PqOgleONMxma5u + oEjKaT+6Mxhm0iIASpoQ0M/lp08+t5c1Jt6uLMVFrz2HY0KmEqXm2g/BplPOToXiub6kiCrCxSWUZu+o + yy7ovEUj7ElxUngYQxClrUGO+M3kFlesJIVcGWm9ztiVckxlew43oRGRBCAvm2zuOdKBKWlDeCSa8SL1 + qcUH5atOUXZl4XhQIrTKyBbGyVx7dSVvHJVJlRHNxVYtzvI1mNMr9CMaAcArlrlW7msA7qlfzqymPCLN + XmkXHa5789F47hmfLUzbFfTJgRNOnlK9sJTWUqA4lzbHqGH7JiX/ACOwSkuAq+E/kcjPfYwIZ8NKiq6G + 9uQ2LbmZsS2dYQCd881rOlccxGiViJ4gZk1HVMymiTikOyMaqOaN0xd8qyijvUL01+gswP5ckf59gKvS + JNER4mp9TWo1c712pB1teAXOVEmZYimqsIEZvU31KNSgZhBhqmgOJVWtRyeeXozKprskYXP1X9te3h3t + J7VjqnD71DK9VHcppY6p0WTIfA2KXGvA3vJNOyFE/k7dLVlLdCGd5ZJoi40gdUuN5eGBUM82kREfKwiM + hpoi1LFnzbPRcI3HLurBH2THn3i6H+3QsZuHntJkbl9NWqGMavOOy2nA9XyDWTp5Unyp6pBCKAGuKbTj + SS3CzDd73j6pgynXs/KBPqC9JZANt0+mJvePmurYwhL2HFt0sZvHLUvLa3TtErBZJxnzpPk0NTYRH0/q + mfjyzUcUGuroMF1Ui49LNGkUA4jOq7pKkS6sAeVDluaVamo/VOXmzI1B2JbbBJ2hLbKhEAnjegisWnk5 + aMzGrDAOYaGiIYmBObsLu/UpEdgjsIfn2R6VumWMneG4VWiqetR8lKlA5pWyFKU0pBd8iDAkSxf6FkRh + HNbXRCaECzzcWKHZQXx9oZVLDdZYSQ23nVy5StSOuet2apmpgfesMFlXkSbjOblIrSxdqhlWYc6nY1WX + S6nyzMu9HoSW1WJQosGFlzYs67TngZiqvwNSTiVjRUJ5QlyW+X6gEu7LrKvr/ZPK1e77XTMwVSzkFy1Q + FIUWi0WUEx/z+s/pOHGxTee7cgJiGWoqDQJLNg+cjyl4s2qA+eJY0KzWhuOdlffPVNoHzLpKwsua8OAi + vssWvEIvRW68PNr6pb9GCGsNupXbRIKNuvUxmdMSpIJcsZZVMNE5aNlr1WbaI1i/wVbjnHFIZREc0m4m + 85tbRHJ78n8eAsMM/m2l55jc00uhUZ7Q0IcIGQt9DX49N7DMnTuVEE3FYIzi3E2BOCADVW7ddWK914ic + 56Lfw8XGTABpDoHxfbfiy6WIuehfoopyue2Nub6N2TnWyBmRV3W9zhy5Hcc7o1yXMzoOA5cXkaL4AN0W + YORyVi5XTQdUlRr2E9Sx1jB8XzVDOlSNoZppRZeASNDtdWNcljPtgEowBskOTouUzA2GRHEKdofUu17V + O2G5Yy2lOa5bySp+jxYReAmM7ENqs5S6iprfUrJ3tjs3Cwk7DBZjrA6851KOaxSBt0WmbTqlvDeU9wgT + dPFUTiCtnZyLiAIhpQCP5auChl2jJiFJ0Z1Vngsqjkr9GUZgdwJrrLtKagTX6CKG20g0PehCpazUo81e + 1lZsNt3O1IwwLKVfPGQHpNL6zzocXB8s0bkAG5VojWTw0OpU4TZVoX6A4Y0zNZ7X1FHsYjOV6Nm2lD0P + L4cfdK1ZvNgvQ0zG8GPRBg7l0nlqxvHyf5753TKJa5z9cbUDQtystZ7sC/cIJN0sy0JkZ7sXmlXXriQa + dinzFednoABtgKMt17zOmPQr2dOGkPaUuMvdhn1eepnZI+m/J6MqFjXPoJJALA+qpCQWWVXnPSuSQ0vS + fC4whmH1PRKHVii+WK1HktWNMU3AL+VI74JccqzoaaD6zH978Pzv0gjWF14yXKj6neob5Tx/S7zQu/Rh + 3aoF4o5mLtnHPZy+4VR+kuOUh/F/m3nAjcskEIIXWMHDLdMzCXy1qWlUtN/Oe0YtU+++e0e9x+IstyQ/ + hp9MmtQxt9Us3B0pluiZWS8Qc2T/AEJUwPvRbdHjRFmy9Z/3ed8YrUIvVGTPNMyvOwmlVJWPj9qF00LT + RjAjH7Eg/eZ+6vrVkjI1y5YPps38OprFk3nXOs6GjeuWLxxxlny0vXKvAmoigEdIcQFOWgKMYaLF8nRJ + opuKwcxvOOZotZ+99tNVHZK1SWVQmJPzcNQj3uCp7tUXXUENTYdU1wkSqtAhlptao1W6lJYJO5ZHipyK + XPXXPqQagyAto0jN9XSsbUdoV9NbSM0b0+p7+86o5666DnUsw2NJoAllKKzRvXDnXzgH5JbebebKdax6 + anh95pddR8Dtd1J6lmiustwr6tkOv4a5DczykGukcQ7Zv17847RC+pelIpevNi8PnznypmVKUeqjl7k3 + mP6x8KmUrWZbSHZBHLoo0i3k1xZ6aaVnL9GSZpqacm2eoEFLMwk2u+A1SJQ2OaVg3W88UsM1izbHlYo0 + jJn4muSKVYWyuwCX+qAQiHR0lNgXHK1o54MaIUI+PWytgPxhRIGUvApi32rrNYZ9WzrjYMx0vScHF9R7 + RJ193T6m5ttV9wyjbEUk1sT8b7GWGESGY9q9fMw4xuGFcvUWnFWaK0fUYd9RdBbkoc0j234BveL/AD4G + ZlvQ4865H9sWP6vm1Jtz5vyZkdCjUtaz7RAO0LxaDat5z4nrtYMPp6wtIBlqC7g7VSaWa+TDK1oaLdoX + 8iUGcHTaPfIrlGt9Z4VIYTeQyN6vxlljnvSLSdTVaCgAhWkkol7QdUbzV0SNMyNsJ9oNzhk+kNHrTOs8 + zjXS0OdqYvQKVSKsDDbZCKT6X8MjDiYuIewr8cjU2hsUDe04j3HLcdzxSssHQp7SXF8XmUF5Hdcl5tCr + tlTmqSGbOHfSdG/Pv6M/Omb69460PvPvA7vj7AQ8TVxWP0BgG95POFLaF1Vn12XRQzxxORpZ4ZbOil5D + 1JUaXdHyF7qeNkzwJtH6KAogxUZWhMWbiv8AYOS+A+tK7ia1ULlhJKpeQ/2NJoFomoZw6u3lEk1q8GZE + 2tLqsVtJCp6JAlnYbUwTnEdjQ9cNMrC2ZemB/pCpR4RHS0tiSjCfw2sy/S9M/GgpuWYKjynPXtOgzjL8 + AYWvQDENTpxlKBTpwUNa5YJ7vvbX5/8AP0F2L882t79sTnCWqAvEXNVwtJ0vL290BblJhFt2Y6XDmZ1Y + 0PppBnd/RqVpgqir3o6rVucVDIAzd0RtHcijgoOi4Whpb5t0QhZFRrlhh5JfVb19mzkTZXfb6UUtMPNf + SdSqo/fRdTYE15KCpEZal34VrthUVHLRfp0LKDFfhiSSbvXEWZP56eo3NCeEIxTdtwPTHoJrNNqs8/o6 + taoxGPd6gUMq2jDcq+k5k658YRJ+A3f8k5NBnJRYEbrDeGFPrUKdkZBw2Org7dIraql0eX+ig6Hfy0m0 + cZnSacVgXWav2SptgCBpHJd6JjRKa07jK+Q1OJKYUEuYxIrnK3YEy+rHFKymNqdo5fJZ2hz4BKiEgrY9 + nDgnuI6gPQqeNIrJajaNiZrYB7ZSWWH+OkJedi9tpS8Xvd1d4vB60Yze74vtFZsFYSoay7UAd0fURc0j + 8+/GPPP6lxmgYNZ0LK22HTFF0gxCzoExlE12o1d2kWrovqFTGv0KDFjdjUAuyRWeCWHfbM44zt7rr1+R + hji4AcQ4+Tq0b6gzrVMLYaHSeoOJP/ATIulx+Dox4Rq4h1n32pKtBu+SmhiImTwSbKwzMpWI40ytsD6h + kkWZKllTywiKqXwzhJFasShD1N6Kv5a6AYo6HIPN7Ghz0sxUtBzemFk571mbzvoUP00I/WxPcJNO5758 + zXOUvR1Poaz7L51QzbHkWtmUON7rh2pxN90g3rWIv+uWdBf0QS4un8xt2qBmyN6bxxXCEJUCW6hXbkLf + nIjRv/2SsLHv4OXa6949cRCzEQJ1dwUEwqRMLiu2NL4HrfWQ2w0FKshm23Wcm1aplg57cy8+fC4565Hx + QuUJBkM1ZUw+3icMHyajYOskPQFfXx4WaZQLL+tLNyGzSLhvWcc1HLtRzZ6VPV6WscY4PtbtWwuKzYRu + YctPRrKGpDtkGv47ndHuObWJOo+2SV5PAhc0t1l6T7zz5uiSuMS9VL8sffXDLquVam82LAf0XiPXC11L + Bm5TIGcHu6Pm49/Mm2LGNJJH0iSnqsmS+J75XLpzzQevCGhS+u0xRlRsjTKaz3hPZGfDNzQuKTMoOVsM + YpTYGPQg1JW9v1Bw+ycg46vlOroD6Dkzp146BLIw81Jmcb4tM/PVFpVtoqsC018+rNaF/YadUcbita6P + zaxScxi9yBStVnZBWJ1AZNYyHW8nkOiZ4/DBprim9Mded+6z7z74LzjvgIzYMlm9PxzXcj5dRlir3tNj + 2L0UnPngeOy2Whu9qgv8ukwMqYoziPTEjWSGn5VpxGjgjl/0MPz+t/obFhrH3UfPr39X8mrIi3VHATEl + YJPfC0m9Yxtn56qaMsXVuzzH7U/ee+Sc9c/WnvU830WKSk5hSpnh0WtULi+mgcwrjV2zMVHW400rV11i + YjEg9vswfdIxB6a1GOl5y6ZtmWnZv0wCaVhr5tbd4Sc5NMQqEKG57NH01Jxx8nNzF81ZgiiBg13HNdyM + wck5lTrJugLfRATpks6Sp/OMg0jl+9Fnt50p5syjNitzajY2C7ST+H+4PL4dXiFnd89wq65pv0As7cgS + r3K32iHXbZNJoGRcdOR9LNz6Tm4jaJZr8sc+Rxr73WsgLv1vYom2p2jxWm/nTecNeVf6xBZ77z8zr3j0 + XvP3w9eY6sUpGz5y5VPLDHcJXOmL6xXMEBIVBp7kARVBYE1uxRs9mF82syM1bjN+am6B+rRVZwT3Xn1h + Y1Jv5tcQEMivspvIuWWeIe0dew+IuF9PZyc1eTHcIFZKx0qnVvxlXq70Oj99fJp+XbDYysbhTx9Cb0iN + LndfoVix3ZThmr0UHJISKZp4pQqeb4qSlDPP4EPnPwFLS3eDqkXsVAGa3xssx7EcYbkoou0go/WHWp/P + 2yUICtHF3+lKOr7bJc/nHv8AQC21kHz6usA+dXit8V2zNpE/V87fcdD9panuWGQLf0ntDalQJ5FppRnO + nIOgizOw1y9Galy3eAoct3DFORlkQDPTx50Ad8/fOfXMk3WK9GYyaT4zPpnuIE7pmppvjelN5Fj1DC2a + BVzqnM6vdxGg3v8AUwT6ntVDJvWaTYzG2zUWTOdFkwxWbVCacGZI0fNLNRpVme8jmqaGeGD0ux5H05k9 + +9tRee8MJ0680nNuyFBhB+mkq/Fa6GSc2OHrE/ounS3bn7tZwVL8NyFnvDmXYx3bCvo+0la6H8sICb8O + iu47quHxTe0DyXPr7956H3PvjPLdT65soTjmtSeeM8StFu/GJTI2OPK5g3NQRZwb6q9aFe5giGLdsxb4 + ZrkHwMrWH9h0OIQiX6LHVVndUyHXbjLwB1Voqx26zOevPEd8+fM9989F17x7TZNcxLa5WR5/q+VTZTQM + 3f4QdTYVWmVbM+sy9eLZRr8qn7LVcd+8+le/e8tcXI5UQw1CqL3cI0dj0fXSTI++q0h1DM9Sh+5voWVq + dNa8MinT9Ac4kzaRo3C+ecQQcru0n1zpGzToRxXo0lqjnlvSerXGDh69jD7zz5rrnzyj1Af8+tOcchXT + MTOS+apS2PGouvfkd+xch1x9GNHs1Z1Vy6K7GQlE+uSo6Cqn8N+GzRHbvz1+hBZ5neo5dZ759zJ1598z + 73z0PPfvg9+89F1vf593ca3ju04cquvufv2bDpr+g0vu+O2TsKt3L/Q9PLtkUL/t2mPqxUJtdgC1cXd6 + eknVFy05qe6qsO0JvPfmWvOo5fqU0NUmvNlDANaYctEeEvQ6Yqe980PZSno48+U2ZXWQaxFKrA6/mu3D + l958zXvPvLPOJPRV4CIpnmfaLmTHA8ry3DBzk8VVqNbOvGtArI/xLSODcOptQyXRkh33FURCRMblcnEU + YTQfcpDxxukgH+ifzzuzBuQ7Vijf3nvAe/eeI695+Z15z6HX0fY+dmxnWFN7Af0V+dR2XpDck7me6zaF + lZjS4RKg3QbKnJGAmZVtQ9H05yu8EgMv1iHkWoxlynLpq7XkLss3p5/fP//EADAQAAICAgEDAgUEAgID + AQAAAAIDAQQABRIGERMUIRAVIiMxJDIzNBYgNUElMEJD/9oACAEBAAEFAo/gzvkF2xvuGdpzjOD71xLI + LDiZSwCbnuuG2Cbq9erYKmy91Yp2niOzQJ1n0t6AWuRh7QUrp67XsUatmVZas871rb/fU/zB3wtr6IA2 + Vi1la4PFd1TG7O5NZdXl5S7d6iuZypSo9UPBW37Q66u4FyJJvbG1CsqhFgXmiatL3mJLvPPtsxAuNmDA + Qnyxxe0a1cBFgdstB6M1gp6SXC4PtwBXvbr+ZMUPqCmHly1IStgwZ+AQjzrzzQeOTxwl/SQ/SYdvjw9v + HnD24e3Gc4znvkyWd5zlMZBznOc8k5DO2c/cmcs7+wz2kG8YnJntg98Qs3TNGCxyWKisg7DTotDKiogX + ogkkUenLkcwqM19QsoLBE+o9VasPm05F59eLq0ihaq7VbnWcQ1DH+tJ5eS80/G5ptPT7LlhlHCw7y2KX + Hh3xs8Qh31z7nNcOJFAMt34qjG8VAzsDNlG1NkbH1HZ3YIizubTD9dZAa99tfF2B2CxT717IqKbCpw39 + 8YyFMloNMjKkmLUPC7dFWJlXje19Ntd62gQ8ccf0Kq8cIluwVMsFeqM7zQ45WpBydpW916m1LCqCBOVA + knWeTG1K9jHVpDAjuML5YNGeT6kcWIkAgfpAMgfqlfcmL4Zx+gRzt7yOcc7ZMfE/qiILO05EeydoISnc + CcHbloa1cDjWTyFkLxtoBH1IsrIpsbFRCVTOPCAeyt54uU20nayv6q2SbGy21Zkm96k3Fo1yK2OZwByx + 8zemUvBXTN2pKnXJrhR4DVuLp5FhfiddsbJriynf8eRc82HTTZXcppo07lomyq09JKX6rA505cyCZE8s + 8mR376K+VSy69zml5UjY2akRa3L2Yg5ytZGIl0GlfEGdyQtNqt6naX4qup82t9O5QLIrDlR5YLTsW/1Z + ZzicWHkFZ+KC+mfJAZaIfFUrjjn+MmdgUD/uEqByqjxx8AT5CfrM4yvE147+2XRw/wBsewjHeS/Mx2EB + yY5FP5CPhKTGSLhim8W7GBRYn3HXM5pW2Qk+2XXx4pn6aFZ8oCPEsJ7Qm99cMA8BjgC3cAxTxrBS5zDq + 8XBq2yWa9kIy55NamzK8jqFggO6KzLLoqMboTk0hYQ1TUqmoa4FnacTeBMXNm+yth8da5cniC9KWr4sL + YT3tTGd/o/GAMFKZ8DDcmjYE/IGwbGLivtssax1WVjAhkRgj3XNU2WL9inDn7Ow+NSfOnRhY5sLHbCvH + NWjHkj5Ra4KUS8fuOMAz1FaB5QGuE8hQY3WgwtgqwkvxK1L4xHsqkw48KRW9HJZM9nB7jHDPfizsYOGR + zv8AShZHhCtI85yJ+kfzEcpGkzs5y1yzyrRFlThD0axsom8LEmgtaDZizDECuz+mdHZ9GuMl9IhHthLW + 6HUyEludVJTPKvtloB8VAymqqbK7DfG/JmQzl7w4uLy+igf3N0XK17YBcZ1DzJkWhxm2Bcs2/LPXrJWu + uGVi1YFTS6dlln/Ge2J8Ovm2JRZn3yI5R2zsQRW+rN9S5CtpHWKs21lNMVUSyciPeMr1mPlemseRupKq + 5fSKWLPQDGavSLQFlTddLbIc9dcRTrjKEr5rtz1lQivY/E6PzTCqniiUz3X+LQXRffUyzV+VPYa9Na5L + qzGEH26esWqNtV9OL2QyscZMZ3+1BzliOUL/AD2OIsfXnpfb+KeMRlRcRHfI7vzyreoyJeVwKw0+FRJc + eQ3FLx1/mK494+rA48Oc9s75M4y/wMNiYYq/LWtHzJhcoQ2eBKEmGWrsGXymx3+V2OzNJZNdXWNrWdrP + 63vkZpYkmVm83duJ9uWMDhldniczVM2WLuWK2M9dZlGl+pnTtZ4s13pGwognxRGLUtuU6vgfZgLAzroN + ex+aU81VgnCm2krYKU/PSMzTiQfDYPiFwZL126rgyIDKWzsUnbahFe6f3D17Qva4T9OXUNBV2lQ09eo9 + t4qlhrYWmvcW0Z958YkT+xBVW9019LfbH+NAEU6+tXkkmFOJVgF6Og3NvpvGT4FTYRzxtX3PkrK6ObTZ + 70q0GxihZDqC/I5BTg9oxzojD4ERBEGJh5atZdMHcnC1joZJMwvwnDTyKLM0mhYS7AaPk8AzEqeE2NMm + +pvqqDU2yKKd/mtjkvwRlo1yhFnkXeWTnlnPMWMuedztem4XyMcLRszV0jpzWZx2duufqRqWJxmsulM6 + y6Mauz41W7rKaqz9hs310LpK2Oz4ZcXzxcMLISzuhHDKs/qqTi8KrPjdPFuN0566y24NZmnsV69mwrw2 + empn0Lba1Qb4cdDsY6rta1cT8NdHzDWegeYdNttUNlYqeozwEutX1NSMbokNyemFvXY6Vu07BBZru9MX + cVAvNRZayF0LboHT1IxFcddshCOZ1QnBX6HYWK/MdrQAnDIrh2WAg1cfGAB5SEYADPgMu5lJ46ZLOxjC + 1NYwmwoV2/Efzzywm5WalZK5W6wCM5Xn7c5s/wCFbmLdbvMG1qtoLsLuwZSTBuX698l8AxH2w2Vd9CdR + fJqz7EzlGFxnJHtjD4rhvGNPJIq+vpOzjWnPAeUKg1GM35rZ/kL8/wAgsZrNiy4VyyQCKzv0aFFOtXYd + JDY7+ZfbwL4ydxq+4WeWauObaE/cOcQc9wPLGr1pGdSkrGXhFc7WIgtizKF0m5rjn1w2Z1e7+epLIvU3 + ZRTTVYunbrvqk7zt2x1WfNLTItXHrhcDTdlgDYmrcntP545QLw3PhsY4rJva52zYVfNWDyOjbU+5RE5P + 4uHCpGJaKBHuaiXjy8xeIAxk80+WBV5SIq9cUDappti7p55ONIVGcwKLKjJvifOekPFj41sntAcZy1QQ + jCLkQGSy1m9kEHFvZj8iaKpW6vmsmBkWSKjoV1T4i7TAhPqE9yfVwFJszNGyZVaLgr/40eB06rJ0IhGt + R6Ztv+38NDP6nZrNtjp+sxSnMnGF7cOWR9IWUSyISHfwCMpCE0xnx5ZEeC/fGMyx96rc5+oHt8O+Jb4m + rcxTWrU2qOzPtOwdMMtHMV1Lv15YTddaWNxK154YMdacLVqrEtRnVAEjZ98jP/pB+VWOVD1eIYHvnfDI + 4i9LWN2YBXsnbks1milsoBJobTGkzYufAVmkDe/GCifEie+ACTbJ9sg/bvm1Kswh1gJiTdkJtEQU7jZD + UTlig4s8RLy0sn5GqpzEaqni6FZeF9UL/G6UrEAPd2ysA2NueWG+fWSEZXrqJf6KcrnXQ0LvsanHjFcJ + 4DiYiHVy+/aqtO8GnrlTLV2eWsSym+5aiT0skOqMuTBmeEB9JLnIKQiaSyhavLlFUrif3D3JRcfGU/TX + /OzryOd8icH6sJBcde7y19fa7Wir+neK4yV+yymu7XuC1a0drg62oVMA8ZRsNs19cFdzLaVZvLqbTa5w + dbzCMqNLARsqyK5bi0zIXunxrvKSvTlkVQyRgvgyhVbI6ymBNpIQgvox/GzA7i1NvfeQdONseL3OxP7z + n6hn25988nGJWvY3a4AmHB9ZD78C7cPb5cXrH/uDh41e6+/vgfSMMFebKAtJQrxjOk8hT0+Pb+PWSWUv + 4u2cIwUxOem4RZnO+DP3XWIqM/yAYwuomTh7jYMjyOLHA2zWsB4KsT3Gv7yUxkjjkwJc4WNb7cjxLGlx + kbMLiSnyKFvcRISv9is+kbzDXMxNUUYy8GeqEYa6YsbAPPlGnLZsaw+TdFbbidYSNnuOFfbfP9f4Ubix + Zw7zVYi96geozmKOppxsMpaFSYUtdQEo19ol0VBkRA/BYcC11lotiz3wnsz1ToxOx5swwhgLPxyNgIb1 + BUg89My1pttRr1hSPFZV1llmqQFHeMjLzuCdEUlfGJx0cY8kiPLvnvnfLH7x/YzZPBi98QYncIPPVBwd + ZB2EmzMlVtYmu0D9pPYaea1GNbYnEVyrxPsQ4kcaH6ew+EZ80HI2WBf8rE2VRNaxFqGbgFEW9Xxq3ps2 + bfvBF4TqujzBJTnaYxkcitDEApfmfVZPjaMzkzwGrELbCvcVcZvl4rA2JYUaa1J3tHTMGaG93Zp7y8bU + tCWu2VpKW7XYjk3tqzDPbcDTaKdXWTbuU7I1FLr2LuV9YteI/wDCbLYW6lAP8n4iW6vPwSJk0WfK7vMe + PlDLm3q68GdSVHI0nvnVtm3Xsq2u57htOpVwPWm1TKev4zW9W0b9ncwK3V9TD1FSYnLGh9QdjyvKzptj + zjUXuzaFvhTVsbKgqWIwlIytSrVrMAB4x4yxm2kZjcnGTuGZO2dOLuOsTwLxDrrfqT14OH5DHkjT2lYh + bFh5nd6L+Di1dS/RtqbWbUac6z0llgqrlWkqrOUUTHFKkSOz5VXKjWrjX2pkktQVD2tXPovhHjlsGzJR + mjUEbB0/UwTZFlfiJc8s9pz27Xy4rEy8qMFsd5EcS+IvL/A++WNeV3FVpqXFM5Is77YKsR1RsMHqy7GL + 6xfiusQyjt17QOZqwA19s77oqqq1zsUpZEn606jFbVDc3Ekd4l/PdQku+LxcZIQwNBc8i86yDmjlAZop + +71jH3dFI+qgR49Q6mAxtcCzVxFXb9TR2zXF/wCMdtepajEdeWlZX6z1dvEP11+Ha8pG7L62R3XoqPi8 + l/XrNBBAzoY4Skp7Rda3GWWZNl2Je43kU5HfkY+8D7v5wLvrlKfCgVkZxRtRmtvW6GbKXXWUu8a5r2cU + Nb3XYYU2ylaIuOwbjhwbzcRB2B2AfTrh+nY/vEvbvnfNHES5v0lMTM7AZOzQeBrA8/8AjZe4eXxyhvlI + ZkpZ9MS39fW2CRz58gB+cXSfDOR0D5K3dfw7LO0ZwGcNXGOl7HG69kJu1gAw3Wxq1tjZ31h+aIyKnan3 + Jzl2BuCzKZAizuq4rs65cWGno4hY1bBlW0lsbgsA56ot87IDmh/s9ZB9FN3jZqLw3K2zV5qb44nBcbfU + v1a7Vf8AFKGGUrS4hrddVfhdNTM9Nv2dbZbEFszZ/a1gt7YnfEpLGcy1HupP74/Gds1gc70zgz7l+ZDn + Df4Ar8r/AC5P1NefWXNg8LPzK1nzSxkbdvb5og82dRKqi/BDrXfw/CMW6QwUBYldCuofEGeMJyaiDzdV + QrM1RT4/XcYZsa/FgR3Gv2lJzk9uN4uI+CO1X2Lkfeyw2YxccxWREFMUhH0wEZqGco6qTxuiMzhVjiPe + PhqHentbYS8VWTIXumw6D7ZoS707X8bKgPMqroyquVvUpN2tW1uv1s/N5OF71bFksvM7qWhUr9RNVO2h + gFGhL9Z1io2VhBo5p9kyo87K3Urxj5y/l3n16DT/APF6psNobb6LPk96bfqE/wDztuY9RZUu2o6OtVMB + rMTTouwaq6rKzO5fDWa5dsNfWJWw8DJwa556fvPpwHHcCS+waZpu5nUSCYIvIfxUPkbvORVkKMbD451+ + 3xgCOQWSz+C5+HVI/Y1RZx7xeRC4SMTXCfoL6o5T2vxJh9fce4OXaTAOaHAgnhXH7hZH1T+M0pfe6tV3 + RrOM2Z1FZ9XaVfTv7Yr2b3ixrkFPN48HZ0/P2T+qoOR8Nx7FY6jqVXs64PD6xvd27y61lVTbNirRtVsh + kpbprBIeO/rybdxq+/rdI3FhrGQXS+vsY7olXfchx0Won/xVbbsq425LyEsrn2kWd95epnaykV8VUtXd + uo4nAXLlxIFshDF2gsEzXVhj09ccrmCJqTHjie2SeCfeZGcOuRhd1zjg6dgG+Ka1GK7RHgefjJLNfHO5 + tGwDufI6djmTqpEXonZ6VkZSWasdP3DsKVE7KrGfNauRtq3besXZ1lNgiwfcb4SY6twPrRErIftzPtmw + /jFnFi/rYtQjlr8sKcrDhl2EB4jOaxvjs2K9e4sOnNd3GoxY2+nQsmzpIMnpRwFQreGlYX6edoPHY5op + ISCe+tHI+GwLjhzywsmMLjyqteFjVm1lS6HjtavqL5S7/KqezGw3RiyEdOvz5DqXYvpQOWv027B29DY1 + dbrt7QRVjW6e7LekUzh9L2gz5dcrlUBp7pnfsdhzM0uyGjl81lfsqh6Hz9tUwEldHvFzIe5s0Q41+OTG + DHCPhP5n6Y+bR3+ZxnzLIvjOTZTOJsU8uWk+qm0khmvYQwJcA+QxwGSZa+ImLtfx5cNL1rchQeuTy9XV + k22a9tM0tdVmsfLLjirRrESTjeDME47Q3L/uqGQBC2PL5/aSI84wKx+0FJJ2n3K/McoSn1bdRRct2lfY + z5BbjPlN9een2oZ6zZruKC93sBKFbHp++7ZK6derPDdVGvc/hnfLO5is25bltGLICRGLc8Jznp7OVQs1 + XawfHr92pZq1lNZx0v7Za6woef5p0vaxuu6deNXpcQZY0fUNUm7XYlLepNDtAZ09r7sB07u6eRtuoqGJ + 63CMqbnW3JkYPO2cpjKjftOdKWWvevP1RxZgPSlXlsOxPr4BbFwMdp+HtkYY+13m1Bz7q+4aRT2JNcos + I8WeWccfvXveqWy0VWfmefNJ7Sfdmun3OIMba4QyDT2W9IEZpWz1MGW1Dtc138TkesHV6WyOXKdlMkbF + TFvGt54nT3bOVemGRitHRDN3TijITDlzY5q1P21xliYhtmz5CgspbvXKrjvtV3Hd6ucXuKGbDdeCvX6w + eDLXVs2UJ6tdFT/PCzT9VfM7fVCGq24Wris+d7GMrUmPbrNdrvSWburoH/lWqDJ601kR/m9HNb1VXv2d + kjwWt2X0a32zpjNfq9dfV1Bpk0QPxln0LmvvttVg0ltNCsoCVdXPMEdQ6gyr7GqcWVeaui1qfEe0e3O+ + eKTikXvb+7XqVytqdUTXznTDPXEOHaeea+S9fYs+nUG9DB3KsHbwWDspxd7yk5IuWrWwgJ155NEwyNa6 + IZrjnNlTiqLZ7zr2cX3snA/cM/Xrf3T+LVBV6T6eIYs62zXSX7Wu7N20d8T9mnpHd6k5/IFjXJbFahrD + YlCa8Y0WQpAPhm5T5tdqm+SvzkbdAh7DPt1Mg65xEzmk01fZVg+VLL/xh4Ia2cbTpGdfRKs0qZCky6ls + 2609jZSqVSTGz1KZLqDW9/8AJtaOH1XQz/LqeT1fVxVetvqNymtD/GOSscqt9M7q2wSIuXPVO10+/Txf + TrNx6HZdQbivarTOTOUexs6dGG9P/wCK6uStdK66Mq9HA8A6N8rEa2rrlnyIj4yzycsCtZPNXXhS4lBi + mupBWKKbJTplYemPJ1boytVcq1cEyryo4/00hTOx3VtyGDsbeac69ydxXZRyN7YCam2Oy/fs54XuSQlb + Ll9dnJmZwY+hY+Q6OwSpsbOsWBYVhWssGTk2Pw7jLW1m29c0SSrp50iMe8BjY9nRUoWonvHx7RMUw9Jc + goltZ2Id3ixWXcS3VOixRA6UMpV1G7WU7GfIaEkfT9TKbKtCZ1dbOEKmv75W/pWOamxYZkWn5L2zhMZi + PdPSJd6G9Hjdp1RblhQKs+SpXi1t61zXqqJIqhVlFT6kCvE0m7BYay4WWKLESfeM10x6vTe/TGq70UnM + zPTze6LvVt+leLqAmKbfs2ZNykZFmmrC2SMU0W1+Izke2C5w4F6zGa0ouHdTNd77ZqINjOa5E3Vs1HLC + 0JFJdOKLKnT7KlvZ6S1aZ/jl+MRp9ikr99xAwOM6v+5tV82xPufaWF7fD/5r693CpQUhUdu8+5B9MG9K + sOpXe4FArLeysLmzabanTn4riC7rH9xfg6i2s5dsGe/w5xlvcV6ovvqK0r9yjnK7PZTfbaiXljuMd5y5 + fYl1OwbK0FhKUeW6qRq3OwIpT3VU/rbGUkicj3yfhW/ioOYrp3YWjczSz3RtuPqmZxnssoESGYUlcsLU + iuzqALkhW0defsmX9cgNm0yq2H1a2wNnhquiyvXu9I/ZWIK0n2jYeQV/UWdP06V/X3a81nh9vWx+AmMk + c74p0hnkk4d9bpPOn/bWt2Qpb8+rjPz6n3jeU8+c0sjc05gWQeWW+K7etDZPV/2dm376qzX5GptZsteN + VfLF/XFY23sihXCHvbTGvai0J2kjBXHTLhflEuR3dWt6byvC0DlbKTeQ5HvBB74TIXljdLXlvcsPKSgu + 2p0Wvo64uynrmcSzvC7Ijl05Yk/2p+pd0v1et/qTPbBPvluOVW1H6bXl9mn/AAXT/U5Hxrft06/JoLET + 5dQ3jm5nmIFneRzsvu5BQlVYPCFikjGVygats9U1jW2i8Xvynu2CmtqrP6Y7PNroiSEzyfuKmO2a/Zto + O2M2LE2/o1vxic/7M+AsZLTzp/8A47cFx25PFgz+e/wmMqf1tr7XU6dj10NEFefQVucfhkRm5H9GRjkO + 7BRb9NswsAhcrAl4TUqw7pdjbJHScU6/WbMbKdjVOxfcHAtM6fT4sscXGLO7jGHZtZcLxymu6wY6u1rV + t6hUWvO5AtC9PbykWKLjEz5Q+RCWK+2t+rF7KqorqmIyB44QcgtayzKqtaxVCn/Bd97UZGTkllb+Lpwh + DV241S0Q1M2tkPeovj4tbrWbFlzpwRBXTu2auOhLzyKpUqAr6hKfqiJyMTV+mz6ew7Vd2afZc5BduYMf + peovbYL4v9K/PHbNV9JNRNCzGemfGEBjgKa3K+otGUahxkPTgjlmiSJ6eiY1+8/5XO3Ka+huPxPSwxlX + pnXzhEEHcYqLlA1yhJwXxke+bZfej2mc4TlAZFElwM7pTimkUn+/C7d9Y3AtFWdT2i4sWmQTNM+OKp5K + Ge07K73NOuiIYlr4R00mTZcpawLnUgtX5ZyZxK8jsEcspFJbK241Up3l7PnV/I3t+MHf3cjqO1GD1QeV + eo12WbYv/G0J/TvpvY2NZYwdRYnPk7yyNCc4zXFVDXekHUbD0MDMgu5a+qrrtcd869dKxSHEfmfpq+26 + hLaWPHJF+0f253wWGWNtGeVCZYdqqxVZtfxEju1neIX+bw80eq5THfvF8mlDCnEV0yl2z1lYWdQLkZ3l + nsWzuszRNa0Lv79J/T3n/K6nQxar16qag/jI75cfFdGbqgcFpRJtOspaFvaS4VJ9pjvjkwarqWKDjZsZ + z9TWP9pxxYv981cIu7XD2KkXYtjPa15MI8rGYuDdBXGzuLb419O8w11gEbnUNWvjtpZtZZrg2flx4Wua + OEogysXdPLFRmm+vabEu2n95yBztk/DtmuDlsdz9Or1n1V4ps7RVZGeBhZ6PPAgcNlIM3l9DqIMeQsBs + ZUrzZxYAoB79lWO2XjYsLhrnAWbcaHixlyMh31w0+VTRvs5Tr62grv2klepV+ULZylB/R35iNQRhq1qC + K9tg+js5YDjpvFxGI+PT2bD2dpS/Rt1DdhuWlGAo5yFz3SvvlhnndkjmrFYuhwDH5yPqyAEMskTYKZjG + QaG6uz4isL4k4veqHYfJyN58c7C0C/Fj+uK2MyKLsr0vvkH06uwlbtttV2kp5NGqVRLJuUsi1Qzz67CK + j2twjK/0iEcyZPANH/Z3M8db8P8Aufjp477DqkpjVVdpcQPzTYnkFtHZ8v2pYzWXAIemLJ4PSOXNOVJw + 626WK1j2tGIUH/Xftlm2NUEtCyi5XlD/AF7Cy03udDWt2Eq6XfzJtLWwV51wfTk4qsDbGhagbRl4mC3x + 2ILs9WFXTORXWJSGFWDL49tbGRmp1a7aW6FIRrqo0y2NGw49aTaqkBChX9MZNmF5YuM7x+MP2HTKZWuS + a8BZFE2QVEWPIRfiwvCjvhwIsrMiwqYFZocTIJ6znxiWCg/KapxDQUUXobLS5ZDXV3G/kv8AGN/Hecrq + XODSQWDqklg6KvM/49XKGdNLjJpelcC+A2CzSfs309l5GQMznH46T3v9SFEVB8eKiMqGHpbG5oVz/wAn + r58+ssxV/aMOg23xfb7lntk/TEn2i5rkbHHbGvTy+BhY9PbBNfRnx1fYX27k1iK7VcB6es3GdPXoNqXp + bccY2Ds+bGMkyRPnqpMiP5zVz5xVxu2r9kX02iu/VrsjNarwUSEWmytni4EN2mAzt6Y4vaobjbqQgNml + 8z9UjPwdPt4Cdi1JrS6x7W93GKuNTYS4XrbGWB9jCDxBd5VqnPitp1qGrUrgLKqeLtRUZO2RFdhnLSqV + /EBRkj3lz85yGMaRznqpiQ2bQyN1YjP8htYvfXjJ13bqUvZzYImxjgbOaYO2t3wGTPA3AUea7Wi6LumJ + cMVITmi/t7DWRtBHpahGD01qxwdLrRwdfVXkeNeTsKwZ85oxi3rsrgvfJKIwmz3XXOWXb41hWJcK11IX + I2/iZWslb2Gv/sboYNCx4xyaM19u+vMbcbEspUL8XdEdPGqICqWVhgWPAA6aZgtX4osVQEIXFKaE+u14 + 6ukjFtpc2s4AjxeG3XZDPDYyKlmZRr5z5c6cYg1Z5jVZqW8mcE++Gz6jYUBY3ILx9t1oo+GqveAznvBx + yhGslxJropw7bJRDNzYaNaPoP9uWaargt0bqNgghYnGFGEvx5wjjMZAd5n85xnByqzgdewNrRa2IkPET + MtH6eNIaJ1nCsGR4O/EM4ZwdhUueFqEFlbVhVYZTEOi891pO1TD2Xu5CRZCF5pRrA7c1KrddpD+wNiIs + 8s8ZMx3Dxlse8N7sx7ZL4TbMg04/a1/9rbd/DHt8SVE4ZHiti0ZsInxDPEivMdk1BKG6iWY3TvEp1DnD + U0d9LPlToKlThTrP7dw7jV+rucEMiU5z5Yu+1WfOW4BptEVQZaDZWc43liUcxvdNk5x9NXww9ZcThwQZ + 3zW3vOHbtihdNZ9pzSLjijLK/wCwv29sGJyR7w3WKPHaVuPo2lYye85MZXHkp0dmavX+tbs9RFVZRxmJ + 7YvYvSNCY5GySxvhTlO3ANjeL7/Nqh5FnXHkHR7QNHsEVxwDiMuWirVaOwK3bZZmstTl2l7PX8MYPGYx + LvHJbQzXoWfZt0G2d6y/XBkt4i5JWhtaxQA5pNkvaMq+PvWHjGt/ubBflWYSM/DvnAWw0ZDI7EtFEnNq + UxThdTuAx6qjB6oq4PUVAsDb0jwblcsgoLL7P1FknWTsezPI4c8zSzn2iCAs4onK7U8TUmBdb4tqXfKD + borzyMdPnevI2tscjePz56PbZ2lW7K2Eo6tqLCq5+OmycmcqDLLU/iJmc/P+nbPxhisz2lYgs2D7KoD+ + ktf2NZrNgI2qOxuB/idopjo9mR0gvF9KVgwemaOD05rowdJQHBqIHBUuI7RGXI/TyQ4dpa8OzEnYs8U9 + NvItjs/+Np7GVY7bAaHHBF8InNCfaHP5TbpjZgAJS2dgyrZ88bfW+0+/woKk2qzW+1xUx5b1DySa5H4T + nLjh8WiB9lr/AJ47Dlyv4T+PbO3bNLXJNG8/ubePEe/wkMnvExHtxyqnyPvF4qzmQxnrpmEp5QmvZz0t + zsz1QkdGbFe8l9Z3wqPOu2S7aoinvnTafLt7bfFV8jWZ9WdyzmzPO+Mi7cHOnrlyzs/H9TLAHg1KbWjQ + qhE62kWDHaPhLAHCvVgydvRjPnNPFWvNj7Da4N6mFcn1azNVt7Gzxx+OtO21zYs1wtS2G12WG8o0TOF/ + YjyoQeeXJLIOO3fKNI7ZyQKGO5TjbAJh9plnKjZrEh0Njbavxzw+qsrxrV+6v5gKja9bA2Bhhipot1xd + nJYrCLCn2TP2fwwJ7rWcOVP+lJPqLTC8Vay4vI82Kriec4z3zjhlIZ5Cyg9as2VjnP7y1FCKNWyV8n1j + uBWldi+ktC8sHpqeG11Kb8TrbUSGsbM11Lq5Yn/xRR9WdIq+51E7xauP9e2dJL72cBUgRXeDvmT+/wDk + rxzXui9T6kQSEzyLPEOcByMW3jlLazXK5t5sQf1ZI50vP3v/AJkOWFRrsw9ZVNZdO0CxfT1dDGp8oW6L + aJ/HX6xlzGMBQAvJn6bd+FYXJpQOSOVbEpIGeYbFH0zV4v8AKNsutPi1tmRrbBGRtnpgtymM+e1sJ9Fw + sWqcTVMVnVmJT3Ff+vTaOdrbt8VYfItdw5NvEo+ENzyjk9jzx8crL8aNgyO9cucMtSjV6zfWb9izdZlF + plHLO+TlwyLGebuXLHf8M3v8OmFePWdVN7Lj/bpNfanP4tN9hP8AWVf4N7VVVu9PF31XU3/HexZI/Dvn + fOeQffKVGbOXqMoLpv6dj/1HVDRkOql4PU1ScDfUDwdlULBYJ5e167hho6+ErXqmjXU4XWOWeLhhdl5a + vmyRDjnb4yOUrRiXMXrKv4Mfenvy9rNqkwdfXhuFYYun3gS1zYZnpzKK6xQfgDGVRl6QIg7fCI74aCD4 + dNK41N6fkseYoMPC05XR7lUR2mq2J8LRzvOAXfPVRCLZe9P92uPnQJQ49gKZFjtnnEs80YTu8FP3rQdi + PCDlqg1LWYrSVxyooUVupm89hH+v/XTq+GoP8Xints9cdTNezzL6i99h00XfXdQjz1f/AH8e/wABn31t + qFTtnIbW0ZdtuP5sjxsfCJ7fDSxw1lq6C71J/kdy932fOfAQw3DXixZKzIj2jtkBOcM45wxOtO1ikCkb + jgaI0lgTK3OU0YYQx2g+/CK4sNJsrOpbOvar2DrOCvbWSzZVeLkSEz03eHD0ewHCo2VYFiVZKQZGmX49 + fsmEdyHPwvLOQZRi7AjLGDyC9I4p+J5HFv8ArPnkyn7lpi5UMsT3tqb5Zrl2xhfb4DIu1Mmd2o3tX1JW + QJoqg9pXXgbeWN/727PLtPjGRGTGa5fi1pz7Wp5O2n1HqaJ17G9jlHS5fo97/wAViQAsZVkYn4xgs44V + iSjUH220ZtA4bH/Sszx0bE/+RqM4Ouvnx6p67kGqQWxhPMQxVM2YjUFk6yBxlSe/p5xFAca0Ei+0TZEe + WEH22NfgR2Efh4I893upqLTappsUrCKliksbtqgDq1gLQQ9WQUT8CATw9bUPD4161vtC6stc6NS6M+WP + z5a/J1zcnWnk0OOen7Ya2FDFmDNfSsszU1XVq8/uYX1V/wCM2eKrVJtyvzEMgT7cmd2kXE+BZNemUa6o + ibsz7PPyOj4RkRgj3yKpFHj4KZn77OxZ9dVc+a8jy0Oli+jbDy1kYJdsh5Rkl/trj47KM3o8dvnf4D+6 + P2tZ3Yg8uRI4qwdaxXsC9W0qdsqr8h6rXhADUDGUInLtdVWGLOCddBWGwmECsMxSNlrDSbIxc+w/jLce + 20q86yHSoq1v5Y27VdsMcsyRr7M1WxYNkSYd/NUxchOP5KQ/c2fHc2KnVunE+TY79nCiDnBI7G4ODuLk + YvfWsrstWRIHLz0yAk4XXFvUlccZ1K88jZ3LLXMgVB+wgjjXk4FpOCC9OcLZbFc3owmPiIfJFpiS61dZ + 46kZGRg4OVVcsrV++P8AbGYLOFmZ5Sp3JobV4h02Qea2POpH4/0H8yjiM/Ct9Nsc3entWdjZ1tiuNXSO + uL/xi5iumbcF8udOT0xbxGmsgt2ssHFjTOgtXamlYjtOAn0VvX2R8S2xl/ciqF2vG6/tmWiiJLADjj7Q + pyeTyRMQNxE13gz2AsjDUTFgXlXaX2H1CW1dbs20DqMp7lz9MmledqbPetY2CJ9ddxm3cvLO5B2He8kN + byzpRX09Rs+v4r/OlvcCtf1rDIWLGeQfltAs+T0JhuqqoGyJEmsP1llx66GFumsxl+Cmu2CW0+0DUqln + Jy86ZWHbfH49XkZGRg5VZxzX9jx/5s/t2dk67k3IPK7e+v750yX6wo7xEdv9YzyZJZ3xamS0Ms/y2B5G + amax9d63qkhzkOfTnMcc9YrI4nNlHZ+nvepTZr+pVU2LFz6xxA1ooh9g3SCpLPpAX3OWCvI+Fz761swD + wGd8VdGllrZUmZY/UGs/AQ/qsW00EW8tczocSNewHDafeQA8PWJPH6+VQ9Z+Tp+vKNXu2eTYwGdu3wHE + N4FSvTZV1GzuzjMZHLINua9riY5hCz1aqSjtAhNPV+qOOyhGqpq3a5Uk7nTmCK0E8llo4n0m/rus0vk1 + /PlV7Pl9vPSuDPGcYqeE6Fvlts/ltfxbzv5/LPesUx0j/wB9PFx2ftjOl2G2OlJyOlAyOlK+R0vSjB6c + 144Ok144OuphgoUOEYjiy5j1IRgHldkdzik8a9iyXcp8059/PvYcn318/Z2n8tawdV1dw2URWCGWLcLy + ZkyBWMcKRY07JCqIiPgxohENJrAnA95guONufWxsWsWcLe+stkJ5pMr54Wwnsu7WfnAZiUBk1hw6sDDL + MRm0sEL6y/FVcXmsjOGrOPbIzvnT4zKN23nejI+GuyUQ23ZrgzLS5ixDWogli3Fn6Q7PlZlhPEB+kbIc + I1a+FCI+Ef6dhwBEWWTmAjfMML5Q4ijjPrSnUD2zUF23f5zxnODE9vjMxGeZcZ6gMO+AQBTYF5nXDcnL + E4OPysz3Og0AIZHCLJzWe6NrP3M0ey9I61f54I8sEIHH24XkDJz29onJxz5whMprj2wfz5OEMsk2TUcp + FRiENhmeTtMO+lDTIvQco49pXdspxfUWxXlLqa46w/8AgZjR9RtTHkEaFwwekuDk666GNQ6Mn2zlGaUP + Hq7x+S1GRkjOayPt1FwTYjyZsFku1NvyBJLLDNZz5ZwLQuYPacMYZafY8JeumMG/ORsTwNk3Bv2M+Z28 + +c24yOoLcYe9c1di2vwsZzA1E2V1nYFNg4dMoZp2kN7kOeWe/kZnN2STe3lPJfMYWzQBDdp2CKzTQHrU + Wk7YvsfDnOBE96OyFSLXHmfw1MfY2lZjW/L7OejsZSlud4AXPczArNifC3PC3PA7HhbKVpNmNQYSEcRl + kLhrpblKv5S0aw9BNZJZOspHh9PaxmF0lrCwuiKZYPSFlHw4YUZog5bW1/XPIuem2FPf+qGdpXz5zVLI + 2NUsCyqc5LPCq1jxvZVc/d/bIjBmJylHFXsoAdEsdSiyo4dQyDE2TynBiASgOKrCOGcnLy1DNhdDpvZn + i+jtieL6JdiujV9/8d19eGRqUjYs1cbenv8AMG42ybc5zlSPsh+Cxg/TDmVXs3t5servnkerPEKbiapZ + 6SezqZFhassTSmtmwn9HqJ/TbafsRBZCHFg6+0eBp7fIdK/HKOuc/DUfwx/KexSMldROepVOeVMwNlcZ + 6xWetTnr62ItosF3+69C35aSKrzGwOGcnOa/+PQ/093sj1qR6tbGD1hGD1fWxfVNAsV1BQPJDOOGPv04 + P/lbvtWt3QXlDRP2B09cuvB0xauNde8vylBYWiThabhnpGBlj7es/wD1jOWTmvaIB46z7RBExLLKiO5B + QtC/GxUwIQ1WTOOjud5vhX0zeDXbJ/VtEcZ1qscTv9jfX6fZXJjSqGXVqKof6eIucO/xpKmakBOcCnDR + Mx6eJyskESPgyG1owbFfIfXyGpnPtTnjDNnYBVv00OXXpLVHplTgqXGe3+jUBYB3TvIx6aHK2tbRjv8A + d2U/CMgYzjnec8h55WZ0+czZ/wD0nNnS+8YSPx1v8eh/g6pDlre2RGCOVfDy1mq1N0CtV2ZHpu5em76O + a/r97cPtr9IhWQziR/yCbPJnfPbIyYxiVnDdLTPPkdeMboYiWauBxS/APphPIF1VCNtZEPX07LIrLKJ8 + 44drtnqEgCp5N29iTIVkbz6evzg9OVfTV9TtqiI1t8yVSUvGyqZZXlmO0wMl2hNjFauqCS0royqgV1RE + eXGO0rGcJHbFcAiZE8iCke2eKOxJmIhOen55a1JuTQtjwDjkDkBnDOOcM4TnizxZ4sBY8r6Ir39nP38j + I+HHJj4dO/z/AP6Tmxn6mD3Fg8ZEe+a4e0aLOoA56iPis+xam7IE3TbCvk8lzyzprv8ANJpCLhnkPYwh + j0hOvKxYttZCV1trStf6d89s7DkB2wg5Y/UV7EfJCVBUpgL61pqHYr4NyVFW6iYEK3NV+WFLNYWiNz3+ + otUCH1Ul3Mu/FU8x4ZwjJGM4Rnjx3YMEoOXe2JgfF4wnOHtCjwESeTQGcmkHcqnHCrlwmvGEtI4CE9og + QwWe9n7Ww1gw2oKoHOGSMZ2zv7HcrhjN7QXjOqKo43qs5zSbZ11u4+p2x/sx/rPw6d/k/wD0nNj/ACn+ + HfkPxr80f8m1DnrO3w75E9srN4FXabHEsThuopMyla19bPKBRKxPGVTMgr8YqMWxm5b4tdA+yLlmviOp + bisR1TXLEbSnZyPiRyIg3kVuz4Bt22EttUOxAOF+fgmwxE/M2mIHxzVdiuMURZAHnDOEZ44zgOeNecV4 + fDJgMMY7VVhC545PbPGM4E8Yg8c6VLTba45PLhCxTBHJ2CERW2SbJ5s/p2+l96O32r6Lp6gvTjNxfPCu + WTyeR5wjOPx6eZ2tbP8Aiv8A9rI/0n4dPfvj+XmObD+Y/wAO95X+Nd+7Tf2LI8q76shhB2+IF2yLDu8T + IDdukdL1HfE32JlPUdgMR1QrL27SxPTfI6XVDeNGPfOPw7ZI5XY9eBvr6ZX1XieoaLpzZT9dufoP8Fh+ + 5f6Rmm/uO90ohU2auppOiOn6WRoKWP0CON6k+vLGvjJtWMm0/u72ir3KtM8RPZ1wwt3WHD6hrjhdTLwu + pS7H1A8sna2Tyb1opLyHkh7ab2fHCS3f07jRz+j6k/sx/wCjSl2u7L3r7D+zE/Hv8Jz/AL1YHVkFE4/S + 1e1oOxn+0/2q/Gu/k05fqZ942Wog8t0+BGHae8/CNmjAvp5HZr2IaPBkRyzxlnEvholeLU9VN+9E4BRO + Er4wXbJL4a2v57uXS72b5doP9qq52ns6c74zSWl4yuxXw7fDQ/3Wfxyfa1SvSOUrvOInv8NnVhq79bxk + Q5Me7/xr5/S7H+q0PucMEcgIz/uYyPp+LPbNXP1R7Z1B/wArpC/TdRfz5H++rntd2c/pdh/Z+Hf4d87Z + UiBjUMI3m37lkg5LpCZeiScN6fQ8LNB9Cdf/AD6r+3leyuwvY6uHBercCL4eQ4zzFnqcfPJi/wB0fDjy + xIeJPULPJtcjIZMZ3/0jNB9y9jj5Nun3Mi75q6Xp1CrJVhL9rGsSWHp0kLazFToPe6f7CL76T7ZStcZq + 2OUROM9x3VeIxgYeN/Gsn7Nv6q1r6bGe8ZE/CfhOd8Oc109vh1F/yOkL7HUP8nw753/0nNb/AHdsfGo+ + lLynWnny5mfLn56J+TXaOSJDifenqPZkxzlVMCOPbED4hkcFwkDNAAtoiSreKrpQXqCkbmjmyTOlX4zp + nYB/oz3gfaR+GvX5bszmwb5dh/6OlV95KeImftbb2nTVfVuAcYwolloVu9QucMIkbKvqleVFDFk/x/8A + oM4hvGaNrEugha+Ija2YLGz7swv262I5vHuq/wDzD8O/w7/HlhFmv/A/jqH+9oC5K3NN1jB01ycjQWcj + p12f40eR05n+OZ/jg5/jS8+TzQsbwv0EHHFVlYQFtWCxZZEROcIwlDMGABPYFwoyeynX5wFVfIufL8z+ + 4lNlUgYtwbc9vmlXIuVSwSSeR/pM4P1RiyyM6dX5NqwuC/3T8fz/AK9Mr4626XCq4vZxE9+up+krQPaD + 5+SFAWLreVhRhK5wQdpV2F5/iPzGCWV7PGa+w7DZ2Htas85Iu+HhZq/7RfjY+zO+d875yzvnfOWCtjcV + pLrcq9PMXg1smgkiFMBnHIXnCM4xnaPhwmc8R56eezaceHflxR52LmLz89ceRaEsh6s9UvPW4lrrDLJj + Ja2l3zt7MZLZBwlD1uquyc5SErsQckkCw9aHM9bPKKrRyCthkiY53zvlefraPFgYM986UX97ZH46K+3E + o/27/DUK8Or2p9q15vjX05Q5Spft2ztnjic4CA2GAvOYFh15IPX8dsk3NcOROROQeDZmMOxM4RZOFk/i + gXbal+NwPEon/Tv8dIQlql95zhOcJzxzniyExGeJWRARnt2F3eMHlgiUR44jOP09Rl2xv7wqtMZqMjKi + V8CppnJoxhVJjA+yjW1h5AkkgbuWcIHI7ximyqJTHaPxE9pnsUVns7tkwxVkXgbbKp9bOQTM+/kl2kiG + csh2mMEs6UX+idYUonafX24d0qeWNPdr5/3/AKR9Urjgvcn2mxE23oWlCxKO0TkRkRhflzvPcn8wUjms + UVnYnglkZyySzlnPOWQHLPQNIP3QkuO9nN0oiPxTnhLIrHkUm5GsdOfKz7fL4HOm+wUcj4WjIZUTOKSI + oLibeYDjNhTGC32vCC6opxhdVxit/YaOtvPtMH2zdGTdjPvOveZQdZvYzhWepqlndBZCYmSq94XWKCmy + zx/9DOe3b3wSITHhawonl7mZ9q2AQsGwkkHVvLtY9fcvAGeKByJPPK3KXTh3JZpKMqs9KJLKel2FIkl3 + D0yhkfx3xyE2Yd03SZjelnjjtPer4X0zQX5bubt3e3q189hGR3jIeY4N3BuLmLRT6avVaqbey9PYYEAn + p/8AvkPLI1SO/wAsRny2vny5GfL09/Qqz0i+8J4T5G8RjGzw3s49U+acgSziecWZ4zwwLPGM50/27SR5 + b6gOq8+qLGF1FcI/nl/se0vHkuceTGREf6KeS50D/JfzqIeG2ygXY5P2M4kbNdTMTTkCgcgcq1+wx35Q + MEI/Xn5mcn3yffFEMFARXBhSR1xImOVJrq1/TDGdvj01VWc5OccMcNsIxVhTMLlnk7ZB948kfDvMZKgf + A6asp/4y+fkuadXZUf6/tkbDIwzW4Cvfo9IuFFE57ZyHPIuI8qsje1eM20d5vVu87Cr3nZ1M+aVMsWF2 + Nh6lUZNpPf1qcO+GTd74ds8ZdPDszOS3lnS7e1zNvMr2Jgs8mO3xjJ/20J8drnVgfrsqz2w2e2ycYqmw + 0sTbYGL2Nc8orC1JF5JnJz6ZyeQZP05+M/EV1e5XOLCUDMWPAJbER5Jkucdvj0x/WmYjO2Tk5Id8ZTWe + eFysiyyMhiSzsfb3jPNkGfj9QdfG31FD7SxKkHCr/rP4/MZb+jY3R7UvT2iyNdZLB1LpwdKU5GkjB0ys + jUKyNWvB1kZ8u7YWv9qyCVbm+jPWDOeRpZwsHkUZKPlwZ6UMlXua4zSFw22dSRxvQzC9/wD1a0/Hss6r + VyifbE/j/wCNh7p+AllG6yk6u1d9Mhxz9o/twWSEeOOMfha5cVlsRk4hHjjvjT5ZyyyPlR8O2dM/1eov + 4KG6vV8r9TKPEWq1qO3x4+xL5x6fjPJq8f1AtBr3WtcTLVJtazaDKSfUW/8AcfxOXY/XW1wcek9hp56T + BrDngHIVEZAxnGM7Rk5Axjfp20o+oFRkBGceOf8AzOHh4c5rWcdtnU4+/f8A9YFwbnUQQVN3bmrF+6b4 + /Y+A/mC7ZQvnUbXcq+o1kBTn7sjvDQ7WSMorr75XTM4WOZ2zlnLvjPor52+HTntS6jn9PXX9rtnacTub + 1bEdWTiN/QdgmDYvtKvUVt3ZbcbG7OPtqHkMq7Z2zpmvztds4RnDO0/6RPtl0v1yp8rB/Hx5ZJZ3znnP + O/w2f07HvOQZZLDzlOcyySnJIsZhYk/HdzqYO9P/ANZ/tQfNO8HvrcT+as961we6fgPwgs1eyOo1LFW0 + WK8h8O+AEJCGi/BqnDJ+iGnh/mcVa8l+yf6X46H+h1CX6ShIHWbVkMYHbJj4jMjmoZavqDV2FOdP3Np/ + BWj6WfgozQVfT6//AF4xnjnJjOEZYnvs9UzyV+XbPULz1acPZ1wydxWyd1WjC3oYzetnC29ucbasMxDe + adt/Z5j2jO3w5Z7ZMxjDDCMcZii5q38d9Z/65981p8tftA56zE/mlP6ZkcyxdKw3FaK0zFdOBl7SGmQ1 + jYypcZrGIaFhbK3bEDyOw7mUDzxUcc8olJlzk82Nr069N/YuM7VJyPhov+P6i/rVzmMqtJgWFiWEMZP5 + +HSn7sZ+/a/wV/2H+KahZbGOw/7Rkz9+ctfTtNJ/U239TjGdo/3L8U5/S7T9137VDXHLrPpFZ6VWTWVk + VlZ6ZWenXhCMZbnNdPeht476v/fv8O/x0k/+Ks+9TFfup/10VgkVIUku/sYxMfDv2vkhcjq2nV2mPHyh + JeShVHtn/Z+w4eXWk2zp/wCS9P6L/8QAKREAAgEEAwACAgIBBQAAAAAAAAERAhAhMRIgQQMwUWETcYEE + IjJC8P/aAAgBAwEBPwG2jZEoxbCdlgm2zCPDZpaMolsRKRybKZGLI2bF9G7YIRCOJxIZkybts2aZiDi7 + bfTJowSUpNjpTRk112YI7bNG/p8tJ6Yi2DBTllTyZ6R1yiWxGTJRSq3s/hZ/E0t4OSknJ7bZiCUaJNsi + 2Gf2YQmjDGs2gwiL+FTgmRNo2+8o8JQobMJih3+GE0cU1s+WFS7LZJgWLcEYj+rIdTRTm1WGTLNCwrbP + LZtybZJtGrbfXw3bBMChFUsplO9Lgo+WP2V1N3V+THUxHh7ajBKK1Jxhjk0KtHJWlNwaths9Mz1zbBiB + SrKyG1AqkbumkVXpyzCMWiSGrYVuUI5Scn+TLHo4tGTTJgUNj3Zymzk3dQ2QjiiMlShlUwU6tomCUzFt + Cye29Hq0NnFrI89MyeW0bvThlWipNIpyPTNpEpo2U7PWRDZu1O75NEkng9WXSilVUlVKTvlo0fEpZ8sJ + Hh4b7ZPT00yow16KF6YZ5BlO2EzBu2zXWL7RF82+B4aPlUVXykKWfD6fLXJ5bTNo967N22IX/sGDTM/k + /wAHs20rS0T11fRs86fBhs+SpN2xamqGNrjMEtu0K2u0/uy3Z1NHLAoZtGBbHswj22zM9XKFm2zR4QQj + CPi+VJ/2OH1qf+xdfOmevg9CFhmzZibenr6eM2jZBtlKa6eXq0U4ZTm27ZQm2+nhkXVavhW8sqk2LVvD + F8GzwWjCt7b3ts4opwjfbZolnJibNmJIX0xbw9u9mWZPDS6zBL+6nZVsm1PTPVnlpQj82wYIyaV4V892 + 3JkWuuCb7OM+nFr0Si3JMk5S+z0PFpa6Q7aMIlP6ZdtsgyiWTNvBSYV5Vt2qzJDVsM86vQ8u9O+m2PLK + pZlEyJRb36JtIiqtU+m7YJg5P8CdpgkwxkGryLNnog4kGhbtopPbYZxSZkRp3Yss9NLohHzUutL+ylqO + vtsW0b6TZYEYd8p3hkM0ikwyEQraHu8I4pOz0K9OVZrB/p3yT/T66t79EM1das8q+G7rZJLRyYpatldn + oRoZToVlSl51my6btAr4XTw3aGvTJLPOmkSzPZ/bk8tMEtmbOy+iUmZFMj2bRDIZBVpWXbBKJT8JX4Md + sXy1fZq+OnFszNqiGZRl20PdsmSWcpZgXbAoR/n6sfYipKTRVMHis5TMyS/wZs8IwbOP6MGjP305Y4Xt + 8IlHJHImXZ9Eej2VZRyhIVsithlW7aJZMmIFbRJNpclLTKk0cmU5X0vL6U7s7b6vTKimp2lm7U4ZVl9E + MXXQzRylWp12V3voumuu0ccHGDL6LDNt3izFge7weXzanXbJJJLtgyzP1wZV5gVStn8kslGx5Z4cSGre + GyGcWcWcWUyvo45OONmEY7a+jBsUNM4kNGb4PRT1wmYZgwSjBi8on7cGj3th28ZTKbMMhM4s4NpspSX7 + IXX09NGevlou8ds2WumGRbZq73ZaZRtnl6qqv+Nn19t6QQclbwXV/RT0mzsxaFo/7H//xAAnEQACAgID + AAIDAAIDAQAAAAAAAQIRITEQEkEDIBNRYSIwBDJxQv/aAAgBAgEBPwFcVY8HamjLosulxR1Rhc7Z2aRa + bKsUUmStnVtkfjSWyaog02YR8cFJ70JolhmaFksxxhlnZWXg7M7MtllloxzZrirQ7bFo9MGEb4oqjbOr + slLqmQk0zsq5XD0daZtFtGWLZmjRY20yNstnbBs19MizxV8N0jNjk0KTMtEsEEkuabMpGxGyO+JJSZGC + SKVcbHLqsndH5E8HR0OLS42OkiMm3sdlJoaaZF0iWy2js2W2bHhEW2J0YG0jsy0PJsas+KKbKSJpMikl + 9Ms0y2ZLaLY3VifyVoc5wVtEcqxYPlbIzecEE+xFkqkhqhJkk2jNWL5f4drMPZX/AKQimTVDk2fDU1/4 + OCSI00SjT5q2YMCtlI2K0zsx5NfTZTbOlbKKZTaJ2k1ZCSpZPmknFpMWEiyWSv7RFYNFtGU+HrhQTRKF + CwyWUR2fLJaTOrs+CfRu8H5U1ghLsk0inI6NenWXEU0hLh2R1982dXWxJp7slJPm8EoqRH40da8P4XTL + scRYRv09JaFbMp8Rm0hzbXGWdWiUE2Rh1/ovjg3bRhIjcXRbMlo6ttjbSIttHZoik2SjXGTKR3Z+Rim2 + iGURkkSoWBW2dWzq0jwjoxzdGUtiaa40zsmLZtcVRho6stpjk2iLo2UkyVNCwxZ5qpFP9ltEpKnw5t8e + Ek65jZHCKwVZpkd8eP6StSNqzqfowmOmTwRyxbEVSHoXEtvnLHFtFYKoTLLs9MNDKbi8HVv0vPFk3jZQ + ljizsdjbMo7M7NrjFGj5doj/ANTRlm2YSJ5IRaQtmi2WxUWkPPKVFJLjFGzXDyy6LsV1Vmx4YtGCv4U3 + 4V/PpQsG2OKS4xZopHyZgiLcVXFltcU26IqkdWn9MItPhLJkq1y9EFZ0X6JRSRaa4k2lohdaoybKFFs0 + a4eiNJH+P6GkLKFaHbR2o7M7NkU2icG0SuzwxzHfDLZZlG+FFNFJEqohhc1ZGk+JW0UzTMM62Oq4xxv6 + +kppIUxTdj0Xk3x8bpk9Hyqq5StiikyUUkaHotHZWdkY4WEMllCwuPOFYss0ShSHs0R2W2ZXGWZSIybf + Fvl7NIyLKPeVhik2iWVzTQqOya4lpkIpo6L9HREopIWjs0jsy2xXRhDd8RyaLocrNvm2eEcotIbTRHD+ + slkSspCwx7+l0hOzbNGTZriWj49cZJ6ZHXFGvSzfFCwdlfFFFFceHahysjk0WkW2/okNcNrhJVxL9Ghb + 5UU0dVxLRGbitH5q8PzJ+EppohbOjR0OnGuawekVaOqHGjK4ydlWjb4gmzq0dWU1xgujsxOySOqaI4Qt + HU6pnVGuFSeTsjsi0bRTKZRTZD/Fjaa40esrhI8FshTXMy3y9CPjpGGilFEpWjZVnpS5X0o84h8bmStE + Vg6nS/Tol6dUPfGmelpriUjZGLZ1VDwyTZHDNHZnYk0z02ZJaEKqE69O9k2kjw2ii0RyxpIwjAuWM/48 + qb/8J2Rx9MEtnWzqhjdJCk3xGPCJU0Uemi/p3O9kpJoVtFtM7v8AR+T+HdNnhHXDi7Mpn5G/OI8rIxkb + TP8Akx61/UR19LJbPOZZIZIVZp8dkkOTfEUmh8LikdU0V/DqzSIxTR1X6F8aZOoM7ITVcaEUaI6EIRPB + 7xKTktiv6y2js0W/C2bQlXEXaJNFjNitGyhc9k/DHMdGjQ6n8rOqJRSWjHHhfEdc3Q3Zavjwtlstlss9 + EkzB1TKGqQtc3wvtkTTMULQ8HdndnfB8WZN8T0bNfSiv6Z/ZlemWU+LZVmudjpEdFoUley0PRbM/o34U + zKPy09G0UR2YMFIyZoWuMGDqmRj1LJNNcV9MtlFFMXG+Xzr620dnZHb4fE9Ez4/kdZMUQpsfCpqjsmYf + F8VzdGGUuKRXCx9NHhtc0SbitWQk35xO6/xIwbR+JsXwv9n4UTgoIhyieiRHCFpEcM6tooWDqkQwikVw + ijBSNcaMMwyj0UU4kk4sg0zql4TVcUUikUuPSWj4v+vCGfJTiyGhczyjrZSPBbR8bJRtYGdEiklzHm/p + 6UaLaNkdDSaOjs8Jn/0R19fSWj4mlE7o7o7onJNMjaR2O7Ox2tcJFcRn/Ts2t8vXDNL/AGLCLLGT8Hsj + oxxjnBjjZVlJEdGDBgwbNGuYyotMst/TBvnwcqYpo7I2Z47qjujujuiVOiWxPBZfG+KbZRgxx6aPSjC4 + WBfW6KMpCkdkzfGTKFTQ6se+dIVs8+z4plMoWvsng949FokLjQubMtiJaNItGUZRGDmj3jSN8LR4R2YM + GDBjnH+30WuK+8EIlof/AFI7FxGbi+PR6+nhE8/1r/ZZvj3hi2LR/8QASBAAAQMBAwcIBwUHBQACAwEA + AQACAxESITEEEBMiQVFxIzJCUmFygZEgM2KCkqHwFDSxwdEFJDBjg6LhQ1Nzk/EVsiVE4tL/2gAIAQEA + Bj8CPob/AEO0LesV4IaAGN42tP4p2kp4KGCNhN5LiNyZHoTJk7+i/DiDsTGR6JjHN1RW9COR7C8itmtC + p5r4y91dypK8ystbybk5F0t1Px7EGXCV55SuwosIrRMYw8lG9MEbqMDtvTQdWuYtxcbwF6wsv2INlN+9 + aNtqvduQ0frZLmKrtbnAuKdtVi0G7VaNaBaWEGhvauUvA80wwG0EOwZpIo6AvX2P/WcPCiMeTR2nNbzR + eSeKFrGnzV1Co2424iPmqlpG1EmtnFVZUhPFkUpRznYqrzbKqy8YUVto5M3X4N7Fzg2TpUwT3DXDbzTF + NkiNpvS4b0cVcKube39FrOoRsorqkrBB7zQGg8VabNj7SeXgvp24q6BvmqaNoRsq5Db6G7+Djm35sFvW + GfCqwz2W4I6N48blrNKs4dq2HgrG9B9wLKh+azEK08lrvHdbrFHR1iab9fb4J5vLqAVO4KTLJfVMubwC + fI/FxVlrrbOo/WCyecwAZVL/AKQeQ0jwUbbDRq7Mf8r7Q2UkN1bBH4Jgyd1DTWrdcE5+BcnaA2i3n70X + lw1dg6KAcqquIuVsXbM1E1rn08Vq7SqKwXUk3YJxyuY2HYCl92NN5Wpk2UPZ20orcWSODCL2ueE8Oh0A + bcNbFAVBopGRco6tLRvCtiZ3u3Is0jqOxvRLZHVrWlcUHwcwUtD2kdUVOKDDG07asxWtaKo0UHbehBEG + ta02gBvKDg6lRdaTSKSF7t9Aqx1b+I4p0McRyqZ1xjbs4osgqwC7tqtI+mUxdYN12q3EQWk1uwV2AwW4 + laWWpGNN6c1psEnzvRbFqs7UAZBIcKbkC+QGu5ObHV56ztirEWU3VVmwB2k3K3Lrt/BGoQkfqt3FPsAt + s9IKrdZmZrUNIRYWqLsxrn1RVX+jv9GrUDet6cQRdsVNGe8rLwD81ZZqtVacc1XXALK3MewtItM3khFz + ahjhVW+bG41qrmX78V2qLKgSALn8E+OX1T8KYhaOTDou6yaw80azuC+0+rhiFIK4FWDe6JoFk48VonWm + NuwO1OdAyj3Yuxqj1sE50ZMbCccQg+CYNfZxsXOVsTQybwCU6P7MQ/C1IbIQLpAS3qj80WzuLtJfdsG5 + aYPDosbk2O2cmhN9hvOs9pVkABu5AT32dqo3VRZO0TtO9PEuUvkNrUDzgnCJ5EUdzWt29qMOUVnwo5gW + UMIdHauUrHSutc11DcjZuV+CuVUcXCRtCArGSwl8tKuvuT3TN5RzqrXBtIaMCNh6qL6lz95WkEQ1qFMZ + Qiy+qtUBcrfJhmB0faqAEulk1tgqtG2Fp1a1wRfkeTPFrE2qMTbL2vB9o3I2XPGjvLSBRClye8R6RlrV + oUdG1se/tWqKPpSqcNlpWbJJPVzVpVG1e3aN6a+Vp7Am1FexUG3HtTh0Dcrhf2FWjzvwzXI15vyKrEfN + FrsQqupwVwTXelVH0MVeKFVfzU+x0gCE1pF+PBAnnKrTRVVjpFFOY6Oja4m5MjZzG3BVdgL0Q+jQnsxC + bFYrTpfW1aGbJi8+225TNhbZ0v4Jwd0b2lV5krL2uwIRhym5w3oilQE6SpBcfJF7QDJ27katZWvgnN5h + GwfkqSyta49ZassR94IljyK+SLWu1jtKm1rUh5x7FVXLliC4JzIpTFXCwFCzKpA+RpbpDtCdJqsYegbv + FB2lYfZ3J7xfyhKnbaqNIb81BTNjQK23nx3tTxc10uvrO2U/BNfhVRRXVdeaioDFTQaLZbbq+YVYjp2d + mPiFQbLs8ngnCMAWDUuOztWkP71NcPZCs2hHH1WJ7TjG75J9GgSuNXe0tG00RB5+FU5oq4tdS5aRsDgx + t7qqR8zhHF1j+KMeQ4f7hTJG7lXFNMrq2b7CrS9F8dRIVo8oZZNNQ782vIK9UKmA7FWzQIC479yH2Zpo + FhTYr1ZxCrSgRQ3Zq7EXG93auOYq69XgBXSa1dy0tvSHcWrlW+StWNK/YHLSG5zbrsFr1HbvR1CAq3Wd + 6HTOCvNsuRc9tGbO1G4ZrLhTguSNtazTZ7UHioBzYCuxW5SCSnufONHb1WUqqvaC4c3eE4Dmuv4bwgnX + qu2oCjBwrd2Jg3MWAV1yLS4mjNpT6CutwXPjbwvKwfJxuT9I8sfssotfIXhwuqsl0t8RdrhBtrVdzb1r + vHn+SpI4MtbDipbV2tXMeGbvKjRacbhxWSzBprFRhNnFNjtUYMbsAnyFrmGQ0obrLVQXv8kBXnZyIm2q + K26jbrNFpnyPOkFKbEHx5U/Ww1UQz9o5ITuL6KQ/amTSPGDHXJkkrdV26+nFco0W3XKTTvaDbFx2qr2M + hmpUjFRtLXU5zdiZowWtAvGxXYpzNG4t37Eb6uKqFr3q2zLXgg1aMKJj22nPbJRNfZb2i2rR0Y95WZjR + pxIKpkr5JHXYYLlNd3aLgibT25PuGzsR2Fr7S35jauzNWtsWFB5poAKFqoKpc4qtCGFW6UVU+3ozG3oS + bUQ2gd1XFG1HGyvVbigxn/iAbw4qpLXjzW0qgbQdqe1nTw7FVwFULGCs5rs1lzQ9qvY0t8kyw0WDW1U3 + hODOf0dygbI0AMufS9FqDI9uCtVZ8S6HmjzPNU1N/OX71jEAW0wTuxozz9yiyqI9ZOBxaaKi3pj9xQ0R + FGJmTysD3RsAtbCVS25kfVj1B5rWsA9l580dMaPpS1iU+KQWntNFQMquVorNRRRF4pSSrUWygPYTXirW + RPFeq7BcvGIGnpM1vmpGSvMjmuxO5SSzvsRN1IyuQlD+F6wqpbQphm0XSN/AKV0Nzoquaov2hCOTyjnU + 2OW5NdpHyQ9OMm4hMmidpMnm1od3BO2lzVDI+WxNk+q9yAsEvJ1OiPmtJlLagXWm4tCMomE56FRSnaiy + RlqI33IvqG/kgRSpwOwqpRc4VKcCuQhlk4MWuxsXecq5dloYOy75lCOB0mVubuq5CVjJrLug1tTVFsuS + ZU5rm0NW4p7WZJlBp1pv8rJX/s1jzBLsPQKdHISHtNCqFyAjuIWuKFFzuaEVppNmHFUcAjsTR0V2KzVW + Ocxt9BgSmOjj0bnXWWrQv5SMiiea9tVI7sw3BEB1Ar3lbVEUNHSqsSG3XoD8QnNY8PIxVh7kRESDudeh + eyVvwn9FyM72TM6Mn5p0Upcxw2FWpKY0CrOz7Psv6SsCRjrSGlukbqv7U0NFNVY3LFYq92qnX3C5F+kN + fZotWYnwWrK3xBCk0pBtUpRP3OcQiWRvdavubVXZPL8BWrks1O4VU5LN/wBZQc+utHZPFB8QaS67WQij + lLdpsXUCsR1J2uOLlYgpa6x/BCbWqdu1Eo22aQ8UDS9Qg0sutNPwpsdSbIon30FcNlU+GVoka4awdhTe + jNkryclkurSpb9b1o3Rg1xs4UROTi51/+FlMks8zorBMbA8ol5e4nacUS5wu7UdernVKlirQObSiyvI5 + OcHanY5bisVlOQYyxcrB+iD9C8PGzerE0Mv2acULqXByrUXOPkiwcu03UNydDG2SSxvOCI+zMrsc5WMq + med9i5H/AOMpNAdj3UUeT5TGWyyXtFoFco8cGqrRf1ipYnPq6zVldirluVuPsxmz+CvjBO/anMirosoZ + UX9IKaM4E2wuaEHD1eUXO72xTQjCTlY+P1+KZlVzaiy5agp2qu1awBI81QYBBo2oNbgFVEqowQstJ4LG + gO9aKw5/dNE7S1Mra3O2J07qWxsKZbYA32SnCKUWnDbdVPZLirTM0RzVwdXFB0TqPVprr+khbfQrUoH/ + ACctJQ5NK3YcWqOHKoA58Z5zTceH6IaOBjQNpTo8pYTBJf3T2KtbcDubJT6vUjXm05uHBRyYGlCFiFiF + iKJ21PdhT51wTjIBearW0JXJSPj7kyqzLJSPaoVK6M1L8SU9jYSbLqVtq6No98r1cfmVI2QBpaK3FSao + s2rGKjZHQvdRWYr3u5zzif8ACq0Gl+G9G1Tnb0a2cBtTr6dm9NDTSQeSvKfK6oZGKA9qFqotR9ZX46vO + ch0mltaN7Ea0B3/oi/L43aU3ariKquRMlhPWL1YmmD9l6sx23LUjaEdJz2lWrWo5uqOCy8XGkhuOF618 + lyc+4tb9mxO7rDX5Jk2T5JlULx1akKVzI3jJbQo89qEWUuMb8Lgnwsi5vSkkDQtWaKP/AI4i75lB8k2V + PitC3rWaDfqqLK4aiB+pMKkjsdmcInWH01TRTwZY6knRL9+5HMw4VNM8c22F4Pgg0kYbDfQ5ntZz8W8Q + snyuO7UBeCTXgB5qaKmrJrNV+ZmkrZrgrbATH1qLUZRxWsKLRsdzecjq1KKIbgrqL2jiqTNqdjtoTxpG + 2QKtO9aKeN1odY3KgYwDsuI8VajBK3eKvc0Jra1pmsytDmnetM0WLO7BEnarTDQo/aGlzRcg6X93h2DE + ninBpjkc7wuWhyg0fTmv1gQtBO20zfjRPyZ8OmiN1HKOaCHQ7xuWqK/ktd7B7y1pYx4r7y3yViDKWF25 + ERRl1l2OxOa6y1zq7Vr5QweCvyyngtTLneH/AKpW6V0tQMVlHfOeQex+adDFe4vJVZ6VbW5O2GyVrAUt + dJ28Kpps6KcDu6vaoXgFws6/gq7OKtWgwbVSOy6orUdqYRQUB2VVuI+DWeK34gVuVb7P4dqLsS1OFo2c + R6DXbMCoXxBuqSbRvoFNlZyeCTKm858jLVe1ak0UX/HkwX3zKz3aNRtPyt/GcpgeS0vcQauJp9FZHlTj + rt5GXvD/AMUeWMAtjUlzFrr2m5ZRkOUgva1tO83Z+i0b66SKgNoUNKXZtMzm1aTxVc7HbxmfG7BwogM2 + C1WDxKAezWb1b044B96sxC/5rS5cf6e3xRhssst1aNwCc0Noqi6LqjFSueDr7aLUx2pwVh13attnZmrm + bHlVwwb2Jz2uflDdjWocmQrOis9pVmxZHbRBz5xXhVN0UrSynNoqOxUUWwn5Kv2ePyX3aPyWpCwUvTaI + KGSSuk5jaIEDafFSNqCy1RVkjqmObcHLequYCViAmyQvaHDtUll7de/HmrWyl71r6ywCjIAGsvdU1iJ5 + aXY0XOsS+0tWO01GXKW6KOxSpKllhvbXnU/NCaW4yGv6Jxf73+E8HnNfTBMpb6Kdqu5v5pzbxS1tVppe + OB2oXF3BOY+8UOJwKZjSnR4IWgTgNZ3YnOtClAW7UwYezsVkc3Ap2NqI/L0L60Wti25aF/MkFgqSJ3Qd + TO6mHrG8RisvyE1a3KNeO02msNoRgnwfquB2OCKpeVk+UQNoW3PrdVqbLDybnWtKMbVVrSNUrIquLgFG + 6vRWKrpWN4uojymksdFl5X7h+znydsjrKJllybJW7GRtqfNSaSQl+830WtPIT5K+07vOJV4BzVlgiefa + ZVWmZNCHbwwJ2ijZEBrXCiaYWVFrXP5p1PWx/MI5N9mgY61TWJWUCWwZWvpqYYrCr9yo6rQhaC1SusRm + JOy9PZNUiJlfFARNDArrtZYq9yuovtGnf3K3ZuYCd+5CmelVrFMax4DmyByAc8HHDiiftGN/MR5dx8Ew + Yhppm97Pgq3hNzMPtBWnDsVzVqxWlSKKx81ayxpmOy0fyRpEWEPGqoYm3WABd9cVWO+mA3BOB/3BtQ5l + 1najzOlt7UebzipLgdX5qMk39XYtJEW3nY3eo634YoW22WkDWx2qy0OdZ51m9c147BeUy3QU6OOzFPGI + oLSc0MJptXKODVavPeVHvB4I0a6nkg5uqRQrJ8rhBIkbR1L0LYLB2tKpA0ydtEwgRsLXdJ+xZKHSsZPY + 0lsOtDVNP/qnGJwsy0fwKjflZEk4bRwF96//AB/7Mls9Z+oF+/5bk2THqR65TvssU2UdsmoD5qDLsjGj + jfqyDqo67qeyKkq5j3f8j7vJG2Y2DyUpyQsLw7WpsXNBV2ZwWVx5RJprEmqexc0rk2DxK+7g8JUIpYJY + pT7NW+eZzD0hRFlbRZciW3hu38k3KslHKM2Dav8A8gRkgeakzavyTPsxmmJ50rm2W+AVmTW4rVFkrk2k + tV9+eW1i5hzNdtuRAWGbdnOhBLW3Kkop3gta7gtI2r2dmIWpfRGzOGj/AI197d4MVp875RuKBYwx7Kfm + pGCQSGtebRXgN8UWvIO1O45wHM6KY4st1XqCrofmmMdFznb6p0bnAPG9q5AV7LNFR7Hhw9j/ACuZJ5BR + Mha4HSNxRwRt/wDpUloDnAp2P/hRFXdLorbzh0exNLyWCm5HanDWs/5TufTAcU6Olppwt34rR3HkrV5o + MUQyMB1o9InYhbl3arR4Ivpc5uCDYmVJ6ybbymOOP2Bem/YnPjmA6esHLVbEf6iaABIDjY2eaq7J5R7q + bDk8Errz0CqfZ56jdE5auT5T/wBVFXRlo9qVoUL5JoGOOqS7KWnHhsWUw/tR7jZjc5lHUBp9VTYsiyaC + KQar36O04nfRfvMks3Y59keTVZADR7DbKlhdX7NM/SRnq1xCdHlTLbJ3WrGwlWckyYMb9bFz7A7FWR7i + eKbIyuhkueFWtxXOCa7KnmMONBqlSfYnGR+FbJCl30/NQjJ5pI27mPpsVIsqyg/1FapI9vtMaV+8ZPE/ + jGQuXyIe5J+qZk8YlimfzQ8XFRXkCWtRvKjkMzg1wrZaEGfs5sUTeudZy0mU6V7xfVz7S+zww0vv0lxc + a4IH7M9/BwX3WUeCI+zSnfqrSMyloZXpiq5bKsnPBqIknYUco+0sJ6ty1JGvPYhidH+KIOTvK+6nzX3a + nvL7s1O0rKcFzSnOq1sZdW9y0cslNuqEWwSS14VVoZQG965HSyCQnAi9HlpPiTTPWRvtORfkzQx/ZcnM + c993tKpJLxaVftrx7lEWvl0tb043UqucCr9ipFaqUwMxB3qjYiT2Kk8ZjrvQ4FP2WowVWJzoz7JVXutH + tW0fNMrfZq+0blvVBHVRkUieXXa1SjUdv15LZt6XYtnR6SbQgYhNsmgNEbx0lS43g49iFu/Db2Is6JaF + rOLLuk7ci0a7b+wKOw9rLP4dic18gkINLk3rWVK37S8a2Fy+8u+AK8xu70QWvFC7zC18ne3uSImJ8mpi + 1+IVoOcK+SsZXkuTOlabzZCy/JbDKtkLeaL9x8k21qyNl1HHEsIVtjRG6jQ6m1ANALDsXKVjKk0msD6u + nVTozflcHN4/5wW4jOWnBHJZufHhmyMAVdpaDyTWR3NanjsKgP1tTLd6wFFpohqrWbVZMW4Mmasgf1Z6 + fJRH2SnyWHvgJq2sQIoqZbkbTwq1D7Ux8Z9tltVyWaN/cdf5LkpDwKygT0s6Mlpr2Kl41a18V+8C2O1a + SGMCz2LBZS/qsCldtN/itctb4I0eD7q5yjbXFwCcGmg7EL81yq0kEtVHkuKjGGrVFrGlzq4BeoeiHQyl + m6iMmhcPdTg4EEWsUyy8hGj63bQhpHMruTXMxVy2K+hTjaYLLa3qN9kCu5OfvuUL+s1zfQyrWB1RRXXB + UaDswBVUGyXPwQv3fgtvNGztQF/OKBawKorTBDHBu1at30U3bdRNJmYE0RtdlD/IKkViNvdwCccdq4FT + DNgsFVqp/usp5LV5Nz7wcQeKc+JujeTV/eU75A0zmloNvNURByTezFFzibVq9RJ9LLo9ysyxELS5O+7B + 7OxDK4PUZQb+x6ayuK1X6ypDC93bS5Myh0jIaYjElENcCRuTMnaKaO8niqqnYVC76xQcE2/WAUgRQPA/ + NRv6s8Z+vNM4OTGnbGPwTmloK14W13tuVrIJtbqv/VR5Nl0z3ROqLDjaRa+PS2m0s7wg3YKDNYc227Cr + kSp29chvgso9CIeOYZiPwUZTQRq4p7djaBSSHBtpOZBSy1dBc2MrXhB4OVMoyVOfGwRPuFRcmVmdI/sb + ch6FxxuUMc4qEA2MUC5jfJcxvwrWhZ8KYIuTaW1UjgaOtYhfvAJHWb+mxGkwpdvUcjb27apwbi2/3UK3 + 8VhS49HtXRGsmGyaEY70GY+6miJlagBWS6/qtQDdmJVlm+i1r3IgYq/ciPZBTX9ZuatM8TupKEHxsa/i + qvJJifbs0pUUUs0vPe60Vcn94qE/WCtOJquTe0t3LWjsmmKnyCeoJ12nbxQMuWGWRv1gF+75PLLx1QmW + 5i2Q4wRR2nC/arZq0FtKTOqpjHLHNlDHWdG3VqaqRpfe1jS/2UNG4OHYvNQ2BVercm6rgOCc+ooWp9L1 + 7n5pz+yM/gme8oCOoAn0z5L3/wAlHW65NifWmOqiHW6i44r1TvmtTJTZ3kFHRMaxujrcVlNOxHM6pNaY + J1RzWFc2ivoFzqLCqstpXYho3WVISdY3qRzKi26pT39Z3oMbvcE1jRWrqpgc085AD0KNBcexQlzSDnvb + TNDILqEgp48cziLkyoraaD2JrsXxXIObg4VVMMexb7641VGbEL6oMJ0ZNK0CrEwhvbtRd4pvZmOYDiFD + J4JtpAtZ0U9oGZ/aKqJ9ec0FQPJvPJPUjdziM0rfaUB4ehCWbbvmuWi+0viua+JoaBvQ+z5C0dsktUS2 + OJg20/wtKJjGcNS5NiibpHu+qrLf/kWPE7iOf0u3tWqSCHLSshfMG4hiEb4ZmOdsICszAA+1ECrzAD3S + 1Uiyho7s6q0knwcqx5QRs5uxZSwdGNo8iFHwcixjtVWnZ8k/5WoaN4ZvuVhhNnu0+ZTh9ohs1rR2u6qL + X3OwrTBCJ07jHiALkLZNS2uCLWqrHOedy1h/cqscGnsci/nOf0kaY5rlii3Slh7FVllx4oAscwvNE+Nh + MjmtPGq9U8eC5jvJYEZo/ZqUyr7OruqgbRPu0TQ9tbI33ollAuj5ro/EqygX9qG1crKxnE0X3hp4Lnn4 + Vi//AK04xk8m5pwom0oLdyuVkNJruQhPrWDDetahGDvyTmPrZJ+aOz/xYHYqMTNmxXD89qs7lYj8TmuQ + uvzAkgC0FospsObjz1WO0D7MqsRZblLQMBUH8k50uUPJ7oWrP/arUczXKHJ8opIA2jkWsfpAbx2EXrKg + 3DSuzSC+hUJ3Gnz9D7U9x1rUbG7KKrrymd3NqVoq5PIYfaCc+V7pC5x5xqpR21RfHGJLTaOvomtyr9nG + YVxGtRWMryZ2TP3YLUyox+K5P9oN8wh9ny+72Sntlyt0EY5rg+1XwVmbLGzMkkbGeS2KKGfKBDKzY8dq + JidHV3+3LT5LkZnM7zVyT2yeK5SF1Fkx0bqaYVuWquUme7xQfQAsNqu8bQspELmvjc620jtTmka2xQO3 + xoPxvVPs7EaQRD3Vq5OyvcQtNDHHGmGeg9CuCOHkV0PmsGf9i9X/AHtWvCfhBVqHUOHqyE8ygub0blRu + TuFdtERYd/8AVcxx95eqf8Sq+0GhEOANWK029qDdPoXUHRTW6a2QMbK5O+l6q9r1JBR4DxSt2+q5R+v2 + m9NvuQLADauUklaEXqzLdL+KAOLblRxJP+F5K8V3JpbgiMP8q4cOxUG1Y14KvRjvKEjW1eLiMzBlVNC6 + 51bkfs0rI5Oi62HJpMkNraIxRarv7lqPkHvFeslX2dxJrfacy5cqYbO8IMe0PNeTdZvcd3FZQ6PJ5DGX + VtUVTkkzz3VZi/Z+UO/p3KWLKHANbeGUwNrOWNbbeL+wLJ2vcw6xNkClPFc4lu6i1A8+6roZT7pV2S5Q + f6ZQkdkc5A/lncsnGBIqmTxbTZVqYWyNmxZR3WqSHKf2e+Sw6lbLXLlskEX9Ej8FXIJyJOq3KLP/ANkJ + Ysr07KerfhXi1F2TS6Ufy5afimt/aMsrtG8O0b94VjL8nfE5wpasV+YUYg/azrbf97H8l+4ZbbZ7Mq/e + cmMzO2P9FTL8jkh3kIOgmZa7bit+bFREYsNg/knDZioj7RCuC3cU2zQybblybZCPZbRRxRPYwfMJrbYN + kbVdf6FRintjo3fXcrWxyoTZ8VzAVTRgcFVjrlzyo9tybE6Nga07ArD6yU5vBerd8K5pHgmDcfmh3UQ6 + 8G5Fj2McNjnS2V/+v/2uKFdF7tVRsdR2RXKooBUWaNptVes0LurkWue7sT3TsEVptBUotyjJxI3rAq6p + b7SxVBeho8neWnpO1Qv3qeNnYwWlrh859tyZLkjRHC4azRhVB+1CCyBtDhjhgmtIpmeRc3FUFzc0TMpy + d7pGto4tCwmj8D+quyqdnxK79pyji4q3kH7RE8lrmmhuQ+1UezbYberP/wAZJYJFDXb5Il2Sh8kXPBdQ + 03r7k3/sTcnfBoS+tkiRS6M6kgEgFd61XyhWQdJxYjJloItmpYExxySDSCoNpt6LZBBCf+L81dMT3Ylc + Zz7q5k58lHk8YmY6Tml2CkY25uLfFQM33pyynuhFzoQZbWuhJkzGWdz2VVH5Kz3X0VYHz5OfrcqwZcZm + t2O1ll+XvLWyRPvs4IU1nIDLcjyWc7sFr5NlGRP/AJdfyQ+zftW7dN/m9O+1RQZTFSpogDkuhYOtEqZN + HombC675ZjRSxk0qKjimS+BRjjcA4Preg3KJn2/Z2rVyZ0h3vcuRhhi4NV8rlCSScfwTpBfZ2LWY4L1p + arpmldEoMshOY55ZXcrEE93txtcscnd3sn/RczJqd1wWrBCeEx/Na+Sn3coCabEkZd1nByHBMbsLgozx + GauNE3im8DmaJsW1oUXQTh7v5jKpzpJAWDnaooo3UIcW85iYLYfeDVQSjaKfmt9b1D2t2b81l14XKUAV + nXn3FxuVMnhZF3WrGqDoGte+uDnUACEk84P8tjKN/VTU6AtJzaXtWFbKF1DmEjPUyfiqm4J75TIwtfZq + D2I/evGyvvMw4xBXZY5vegWp+0I/GMp/2Odk81bzg0dit2akLQvihEdKUsrSua0yb6K2/JoT26Naj4GO + HVZeqmZpP/GvWOP9Jaol/wCtcybyWrDOfJNdNHajczSMB2FPaGUouaFgmyMxjcHBZFlcJBjlbQ1QdZAo + KXIrKe6FKHerL0GxGueZuNqB6/akbwHAvbj4IPbk1hw6jkS+UxntoVpcnyxzW1uuuQ+3ZTbibzQxqpA2 + yKX1cnWgCK6u4IRmVukdsrRXBVa0t7Tcnlxa5xOKI5F43XK3FGG8FbfbB7FqTOHELVmYVcYz7yjLozc7 + EKVtCr2OHh6Eesdv4KFsEjo7TSTRXzE+AVjKnutdlyrCQ9nthXsYfEhCN0di1U1DqqHM1+xrkzRRlgZc + uaU7ZeqKjrWruXOcPdVoP1Vqtu3lSMxc5tA1Ma+QR6gqwArktYbLlDo2Ev3YLRTtsusqSInmOqPH0BI2 + Gr8ccFX0CHXg3FZRk7rrBI/ynGy5c0/EtoKMU17CpI8GtcRacqMyiShNaC4KyzJtTGowXK5NLdhS5ACL + KGEqhj+Sd9nnAa6lzmFOc3LRf/LWq603eM03in0a0X9VdH4QufT3QvWFc8p9q8hyycew4fNScUHynV6r + U9roxo9/NVtkYd7TkckcyjrYdpLX4BUjmJPBHSZTQf8AGSnsicBbF5LFHPkEQeDatOtUJNULURDd+IVL + LncGlaws8bl/Sf8Agv25wH4JksuUShxHSfc3wRt3u7VKw9Fynh+zRvayQtamkxAybb9VUfIQNzLkb2g/ + NUjoO61dM+6jI0EChRuVxIWrNIPeXrieIQjlykRE4cmnxF4ks9ICipWo3WVe3+1OledG3Ab0aOYeLVjk + 5/prms+aE0ZZYskc69MdFozZbS9/aubEf6gVWsb4SBfZphyg8Vfch3HKOo1WtqqplloG/O/iEdWw53WW + sxrn7ULDG3diN9yo5tpn4LUpXsvTZZI2EOuNpfuuTD3AAjZycNPtmq/eKHuiiGy1cgM4fKKlquz33K91 + TuUk/wDqSNRK2Z9JFg7HsRqapqbHA6ycScVG55tOOKrtWtG0qRwjbUCqdZoNqBxqpvH8EynrKX+jLxCZ + JEaPa781bJN6fvtJtquswFXveSq0uTx1gmv2OVG1v2qBjMsdkrmudzJADitQ1NnbjVSZNk5axreTNttS + XblA2WdoktO5jbrPiuUsSXUrYvFe1SQQTFsUprIAMUyj6sv8EwvZR7WNr5Ka1zXNU0jjW0+tVZxVuNxs + 9VXuoPJSRmNunpQu2p7HChaaKvsZiCFVprmqEHPvcQnX6rblyV3tbV/UcnRG297cbLAqP0rT7UNF6wj+ + kV94b4xlfeIv7ldlMPxEIG7soaquKtBoanndGUNuouRjc/g1B8rWwxhoq6R1KJkkbnODjTWzO8EG2zFE + B0cXKpdIO3SuCL2vOUwNuo7EeKLvUsHWGKvtS8SuQYGNWlkfVzb6VTb6B4qtQa29OamvGLTVAjpejrFU + j1ndi1n2ewYoaVxDXUqnnJcnaHuF7naxTmYAKuARABVgk1zHaoieqE/vKPxzVCmGOoVLXqqim+tifu9G + bwT272vRG5SDxWTu3VCdXZeqbFjd2KIOpZxbRVkmsRu3C93BcjkOmdvnfX5BH7fLFkzQ2rWQWQ6p4KR+ + QYvpz78O1W8rk0m2nR8kNwCNlZQ1+Io4LI34W4NH8KfE80tirCnMOO0bk11ebQJzCiDsuWkhNF9rnZRs + u0KnsD0d4X4Kpubuze+VL7v4KjrQ+fow/wDG38E/wUT2TxC2K3pzpZjISKXNorZha5+83qlwCdX8E44W + XArFPs4qNzdjVo9avkVYiFhmOK5WRG7xcqtw7LkDsTCDey7yQqdZT2BWzU5mV6N3hntblSAWiqyEhqst + NFYgjdI72QmZROG2bV4BqWqxfWic6nmvVDSHBa50j/7WonamtHSIWtlB+EJrK1s3VTpNMRU1wQjtWvln + Ld4opAyIuqNiP2iF8Y7QpafVyk9GTioS5waNbHipfuwNMU3QlvNIuV2x9U61dertWJvPfuQkyEPlrdo9 + qA+xiIe1IAmOflEEVloAF5T2ZS95ylhs6NrBSvaUKNFFvKwzW5jZapIsndrGIhu5xRA9Zk8tVC+tNiEU + xNdhRHXFVwVrY69erPihC53JA1paRjjpVcwHg5epeuY4eC5ON8h9lqtSxFgHWNEXvlaCteZx4ABcmTJ+ + KNoEHSFT+7+GagvXqhG3e80VcoymvcaqvY+Qe09UibYjbc1OEjGPw5ya6jG2bm9idYdaGc3qa+psq5YU + TaoPHBbT8gtamY7FfgpGb9ZPaDSjk6TKL6tTirPVd8ihvwzaGLnbVbkoOKs5JGSzrG4LSZW8zO6rbh+q + sCxH7EYvT4xHqOxbtW7Ndt6So1AKJmNFlE0ZIc0kr1tF61esb5L/AEz7q1oYitfJh4VQZoiHH2lKfaaP + mpvrYnuYyrSsG/Euh5q9zR5q+X+1UZaftJooB+0nNEGOvhVBmRzyTQ15t5CiLAWqUdlV1Im85yZHGDG1 + uFk/VVZqnvfG6bRitG4kKOWEPyeONtALXzRJGN6oVsRLiV+7xOmd2LlXk9iaMnGuMLqp7Mqe3STXubVF + h/05FDJuKrtYVq7Vb2tXrvJqtjTvZ5K9oj75xWqGO4PQflR0YOOtSipE6p7L05scMjhxsrko44/mr5y3 + uqXSPMl+3M/vlTcG/gvtOVOc2PoNHS7VSCNrPmVealU2oMZi/N9pgw6Y3J7ZbtaisRUHYE2w0Gu9G3du + WsnNdqNpig7ICbIuLaX8UZHVfosa7EyZvOHOzFDYtI+oY5aFsdAPrFauBQPZRWhg9tc40brJdciHgl+5 + HRN0TUZHNEIOL5UHzP03a7BUYTlDxsZgtd5iiPQj/VA5NWMDfeucFiFemoqpVrqglPPXkp8/RGaHwR7Z + WqUYVuWMa5zV6z+1esK5SanvgLWyhn/aoIYZGSua+rgytMFRgACtSUuvRrdH0imwxANYMEN6DZLtxWli + dRzfmnSRjRurrM/MKtk1WsQCiG3lB0tHtHRKpBa7AFal5Nm8p0j8pDOg4tdf/lVacL7Q/FTPF1vWR88x + btYaJw2FUbNZb4Krsod8lWmj7xWsT4KFrhS79VXZ6EwR4lP7xVpzaZMWttO39iDI6BjVWyfJawIVsouw + bg3hmwqstZENRsly1nBowvuz66dsG5U3J2iIEc2/erLuadUpzdhQ7QgS3gMK/wCFyhJPZ+AXMa3sL7wr + briN+1at225M9l1PNajCVrANTKurtXbiicpstFLnFGCFryDi/BaJ73aJl9mtyLjS1wWLfhXOj+Fc+Jas + kXxrULfiRAXYM07tzFkzN76+mxRBv+9+RTmskIHdqvWS+DVqnKT4rWZKK9eWio+lrdbtLlHxNWvlHk1M + jgD57Ta3MV2RzeNys5SzRxjHWqgyNtGDN29XerbzZ43hqoTWNwxTmSX9oTof2TCRve+5G3IZH1vVGOEQ + 2E7Vy7m2PZKsQQl8mFp4oEaOF3R3LVIBpVzSiw6soubx3JsB6VU+OvNdRU2IbpPxXBepj+EKrIWM7Q2/ + NzQgBszvkmt86jbJovXSt920nkZQyQHZShRfFGXDyWimyae051eZcVuPYtUUWsT5rVvVmtG2aGnoZTDL + iW1rvvQDi2tcFU3KkYqUbR1s9l4BG4qQxtDGV5o2KzJz41R7Q6zza4I6Zjqdm1VjfrHbtA3BWK0djRuC + bU0phTBEgU3jcn6XmqkTXEI2CGnbtCa919FZLaOzkAqsj3Dg2q9Y/wCFetf8IXrCfdVKnyWrI5OiqXFX + 5ssd2ALJGdhP8DJQ67XP4K5wR1gfFNt2QML3IseavZdqsquTimdwaAuQ/Z8ru8Stb9n1ZuwKk+0ZOYBd + gaosbXit63KmJ6h2on1h9m+ige2QgM5wG1MhbczA2diBYRPk5ZaDcSAi6FsjY5HUoNvFB+Vao3BUFwDU + zUDmu9uhr2KmUtLB/NZ+aLsmdQey65GXIqS2cUJJInQPweCLv/V9ojdQ7xvRl6RGtxVUX9Nmt+q2WHLn + u+Arnu+BYv8AhREVrVvvCObaoWm40r+avPN7VrOr3qfmorOWRQtB17L7yvvLT2ucvXV8CtR9BjaIoFrS + t/FEazadcUqr1fmoiG6narVNLL1nKsjwGjyVnJBX2yhPUvf2nFB7DVrs3ahUm7crq1RtDQtPWQ0r3TOb + 7qNmGP4V6mP4UTYLHb2uojE2R5pfjisKVRIv2eOahVhl+bHNcua0q4MWDPJakcZPcWlmyIsj36O5W5AA + cDZWKrSgWUE4ukosn0bHP5PYKr1Mnwq9jh7qtOuVpoqzO9Qse+wGVPNquVtO+S5jj/UWrkodxqVqZHGP + 6awZH8IWtlELeMoV+WwD36q1A8SMNRUXXqm3NfrHqIX43Wk7SNMe/cVoIMTuTn5Q42HX2esmusVbZs34 + eSLspj02rqNbdQqaV4Lat5u69eBUeB1lyTnR8Cq6rjv5p8wvWPb3tb8ETM20d7NYeSNmzX2bj5K3k77b + O1XtICjEZAcRQhBhY4nAbqLp/Ja9rzVdYjberWT3F29OEuNoi5VkA95yZHDYL3GlzU5+wBMbK4F220jW + WLWvFarU0DuBVZTY7q1uVd7SGA8VrMIViWpjddVaKbnNuBzdqxpsVIxSnmURFyjvkuVdUbhhn0Uh5N2H + Yc28q251iP5rk2NYdrljUougYdGKAupcE7O9mUNqNh2hX8ownUf29qDBgM9T4egfQaVMyoNYiPkpBSpr + VU0Ya32ti0bX6R34JrJntq5xJvV8gb7y1cpp/UWrlH96unr4hXSkrXZE7ixX5NF4VCLooSCf5lU9o52j + qrORyQww2QdaKpV+XPPdYGqkmWZQffWvLIeLyr214ptqCJ3ean2MngaabGAK/rA/JSQuxa8j5qmLuqsa + 7zvVmVtAL91KI3tmj3u2oPyhoo3mMojfXNZNOO1FzukvApve9Cu1axD+9+qDKm+6j9YeatWKB1btyqNi + sRsx8Vz5G8Cvvkw4taU7lZJo6f7QTGtItC7XYWotkcNDtDJNq9SShaY1ujv5pTW9Z1EyOKhfKaCm5a1p + w9lYArb5rArVlI4hYsegHRvYTtGCbG2Qh2yt9VoZHAvVQgYxV20LWfRydJk8jWVxBG1aujfwejbyZ/gK + rXY5vEUzaOU8o35hb1yADkW1LG70dt+KsAkBxFUajbmwRuKvFQtUuYjo3sfxuR0kDx2i9axzgpyAQLbx + nLYpHAFOGBxqrJc4d1bK+ZUd2ElVrQkinWC1snf8AK9Q7/oWswxjuFU0xHjgtXKyT36K7KXH+oE6Zkoe + 4UuNCiJLNdDTV4rJpPArii5ue65WS65O+tqyjRnRsa6pfuC0Drh19tVuouWdo4ertctJk0eszojA9quw + z8o0yHYFQXBeaDRjaVD6G56vF4TgeaSiOa2qsxNAPW2p3Jte3yXKZOfArWZI1etI4hXZQxaszD4rUcDw + vQs3WAmGgADccLuxWIi5gbudtXrnqj3NPGMLWjjI4UXqnDuv/VXmVveZVBlqOT+0pr5GHfSq161N9Vfi + PmtU2n/gi/WernyBetrxC5RkT/BcpBq96v4rSQMsCzQhBzDRwVpuO1u5Od7JVc0LBeS8BH0MFhnAfC1x + O9qkkjiLYrWxtwzMKk4pkkUYDXXirqKy+wPeV8sQWvlbB7i1sqd8KdWeU1Cv0zvfX3cni8qoyVi1YWAc + F6to8FcKKSoB23r1UR8wqSZO0cHlEsjq3dW9OusoWzW00hH+XJ+axVnEqvoTdUEoq66RNjqTx/JWp7z1 + AqU0cm6qOUwC/pj889rBrc3gUy1S7ei+Oh4K+7PciHXFN8F2VVQi0Xt2Hs9HGiZbJtOvvTzW4mibssX+ + FFU7b/Q35m7hene1qhUfzWrRwiy3sQMnkuSFgcV0XKj8iteCtuMORuB5rn3uWiypth2NnOCy+uI3p5w1 + Vffmh3R1epXdVpVsyya1/PXrH/GV6yT4yvWy/GVq5RMP6hWrlc/xprJcpkkia1zi0qtUYwau3KRj8miJ + ruVGQMaOwKrslhJ7qo3AZ9Z7R7y1soiHvr71GtWW3wC5GKR/grT8mf8AEF90effWpkYHF6kNiKGxxKlf + JyllpNMKrlI5YeF6DshyyKSz0X6rlZyhpYU1qh79Flrd1/pbom85yEUIowfPNSK9F1qg2yH8kRGCxn9x + WNG//VG6jhitNk7eT6TR0VShqg0ZnS5PGJLONTS5SPdqOrdHaT2G4tNDVG1t2qsLg8blrtIzhGmaw8i0 + OafRij2F1/BOduatToqzJz34q/PvXYsKp7pajZgmgXtbrDM7KGAHKKt16V1TjcpHZPHpH2yLTcmxG+qk + dljMo0wvGwHwC1MmcDdac6ayjWSIM6pdVWXzsHdYVJNradsdG+Co6Eha9GjzXJs1uscU7tot2bKpjsAY + pdlq708qk3MDfmqoyFzSHbk18bqWZbL+CfZAo2u3FXw/3KOVwveKqJ8EkjKvpzytaR597NzRnqqZ8qb7 + LSitYMd3mLXyWB3urRuyfU3B+C5krPeTJIppWlprrBTgyM5VtOCsS2TW8ObgfQt1sRDpb+C0MAssCtPu + aqk2I/xVhoqf9sfmrcxtO+Qzhlqg6Lt3ZwRoK7HAq1/pn5Z5Y3xuc120FViygwP9u5WsmnZlLfavVMqy + NzRhaYgKPd3WqjnPHFq5Q2X+wxy5KevGNyAL2hV0kR95Udd+fpSSHoNVOshZbjrWkBatWRid+1YtW9X3 + rcsVUXJgGJxUlnDAeClr1arTxi25sVaIxyxtayxWorcqOa5pafNcowNa7mrasE+poKJ5jNHVXrXq9zj4 + r3G57f8AuPJWTxdZ1fTnf15PwGb3VK11zZqjxVs9JWMnbZFgEjtUNb+cPmmOwpKPzW707kRipW74vzzE + SQMPiteAjgVrNkC9dTiFq5QzzVWODh2KMyPlbZbg1q5mUO94NRaIXTPb0RIXFF0v7OZAB161QiycUb7K + Bfe9AyXu2MX7u6uy3u4LtOJ9Gzi7Z7Q3cVUUcHK/BEM5uC1xQJpigeHk3twuQmidLGzdgp9GaOxRtXtd + 5puTtyOGWVrbWkrzm70Q/IohwctDJk9t2LalfcD8afqaEuFLD0YnAAt5vZ2ek5/Xf/hRQgE0FSrRvoqz + tLa31DirjMuSmJPtBc1vxL1ZV9UK3qZ7SLLAmtR7YlD3EcEGWAblTRkeKuBWCO5PHaEc1naY7lyjmxjz + XKF8njRQxxijWtTWdRnpxe2XO+f+EU8E1dQBCQEE4u9l36Kg6TgRwKkdswXCQp/Y9p/ga2CFki0mdrHB + BTDc8j559+aPxTYRGHuuqbRuTg7Cis1oMdy0cR1d6DGCr8f/AFONoF/SccGohtWxbd7vrd6F+a9V5ke9 + avEnf2p0dLdcSrTQXH2nLlAChpaWG7FdgnbUW0s/km2LpmHU/RMktBlcWnYdy9cwPbzTVAve0FWHzMPj + giHc8fNXaJ3vq/JyeBqqvyeUe4rMjat3OVYDX2VCOxSSNJF9y59VWyHeC1snYfEqv2XyeqsY9vzVKp9i + eO9vzQMlk+6tZtJJn6/gioO1tFF2frmkda1RvTiCDwW4p9aGgWJBoi+OUEnYq6Mu4Ivc8R9lL1yhaxo7 + VcS/ghHFFznUvzZSfap6eTD+WD+ebi9PCgvBY5/kMUHbbZr5qYY0k/JZR2AH55rzRVF49PJjvJHyzZUP + 5rvRiZ7KfM49NDyT6OonMeKSN2b1SG7rb1ylWtGDM1wqtZYI5qzX9i1itzV2JwabB3rWk8lq56uu2p0f + RxHBW7VptBpA7pDetdojtbReFosrfFbHNLrqqkU0TDYPmmsldf0H/kvWNVxBza7QeIqtfJmHg1OsXNY2 + 5Pd2KOJjjrFetHwrnMK5rCvVA+K1oXhcwj3VquAVBWQ7L0WvaQ/csmLMnkNknoqxO0NNo0vVDgpNnjRX + uJrvcCnSBlXHddgi444Wa0PmuVklh74BCqyRjh3UbmHg5epJO+4rlI/iYr2NHjRQ6PrV3pxUj+s8n0sK + prMKNAWxR99TOxosnr0Wk/JSO9m15LKm7LTSsrH8o57j6eSn+YM2V9+vy9AIBSH2io3cCitLHzgUyaPA + r7TFzTz/ANVRA0qsM1ZCL8GjEqsjNHuCsso6T8FV95WsquNArYujzDOHbnIPI12tWil4tQc2MS5PJ0Xd + ErTapL79Hjo+xML2DV1bxe4IMsHRS3WTiEOQZJ3JQVymSSj+n+i5xj3VtBUGUH/sUkgmdcLr1Zno5m8N + vTmtqHG7BB3UbVUFQXOpcqsml+Mr71J4q+RruLFRzIneYVWxxfGgcqyM2CaWgWuCHIsDt6L2xsG80otU + mTuCqpFC0d41TWunIq7BtyeTdU0wBTRHw3JkdbsPAfRTo8na0X3F25cvEHDexOMMhjk9nFWnBsw+ElUr + oH7pB+ac6jZKdW9UewDt2IvgsustOAUz/ZPptHbmPCqi1S7dTeqO6SlfsjhJXPtDChU+jYW6o21U7d8b + h8v4WTndIPxzSTQMqxwF9UXStBpu2K3k8kTxtvwWMfmgS6PHetiNZIvmmg2TZWATqPYezBGCfmOPkUWP + va65WHc3olC/No8mpJJv2NTsoyvlO2q1TZYMFdmoNZ6tyFaJzRYcizEYtO8IZzYFbtie1+ONFXB7LvJN + DmUY4Ufx3owHXZWtP0Vidpjpu/FGN5JZZ1CrcYp3VZe8032kDbr81y0EbvdQ5DQ06hVLQPeCpQeCyiTw + UEfj6Nl2CYbzbKwZb6Np1EWPiY9hupphRfd4l6gfEtJGwtc32kwNYXjbtxV3Qu8U6hp0WqN0jg0YU2lc + hkRc3e9yrlOSCIg3Ea16H2PLLR6kiplUF3WZeF+7vo/e02SnWrE3euPmsocxro8BRyn7RT02IhSd1Rlh + oQhW5y/aku6GnyQCeN8aPbcqbv4G9MsRvNHA83N4ImtWnYtPkpJj2t/JMfG653asQucAqXeavcAiQ5tV + q35tHIeVj/BUwe29pVk1DsLKpas1WtjuWthuV62AKzDXiquvOcWuc3b6BkeCW4XKOZj99tpuKkc4WBaG + F6pWrdi0eJAqzt7Ew1ab6gk0TXOfG6yat1q0VvJcofA7zCvbkmUDtFkqkn7JiPayVX/sxw/qBauQAH/l + C1P2dX36q+Ix9lEyooXklP3NFPRqmsxsXprBsaue74l6x/xL1snxJ9uV72hpxKYxh3VVZSbRvoFp/WNp + qDrOKM+XO0krlYkIBapHuaHNLqNVC0UVIco1erJreW1B742kK8ksN16e+zo7T1o8ljMji7or7nKF90m+ + FX5NN8CvhlHuFXsf8JzMb2EqVPXBXLK3HGSQD5jNGMKscsU932lgBcTzVrZWPBivyx3/AFq/KJj5K907 + veXq3njIV91Z41Wrk0PwLVjYODQjeAqphjcWGmI4r10nmiHzPNVZypr3w9JrH2fFfuz5Gs2a9V66Q+K9 + Y/zXrXeaveSgm91Nli5zUyaLmu+qIyho0p2qzHRz1UkucVV2Kq/yW5iuz1K3AbM3ZmEhcABgcfknFoaT + vaKK1fRWhUHsvCDmXkFa0MQ4xVQo2Ef0AuSnjf7y5oWCxRc4qkQp2pu034qJpoaNUz8dcqjr1UehK/e+ + idur6E3gEwkGu+zcqPBOrUrJYWOoLNo7Vg1/yoreVVke68CtwXIVLHXUOCq91PZYqRsAOCDKXNuXaoRj + t9HbmwB8EC1oB7E93VBKsyxMp7KfucqKPIwAGNfbrvV5xWTCvZ8s3Por7/Q5wV72jxVxJ4BA6OQg9lEX + 6MMr1nKsUredeGptt2bCq0gVnAbFbcCAfRZ3c2ilPIyf2lFkVzN+05rlZZe5WpCa9voUaCT8laf80a5r + 7lZbWx+KDmuBDdlcE10bgSReqPjv9lXVCNaVVDQhVa1jwty5LKJW8HL7xa7zVFFKyF9twbzaKThmgjx1 + 6Ihtyo2SF/jReraeDl93f4XrWhlb7hV9yxUNcXVcneg8+0FJJduqMe1DfIfkoZqalktPZtX7uKt37Frv + 0Tm+BViN1adLchowXnHFGtY7Bqa71SO8diONlNbpCLWF+xetPxL1p+Jeud8S9c/4ldO9eucV6wfCv9M+ + 6nMcxmtcrD8b7FGqlb8UHMab8U4WKAq+lEX202N9qRhB1V93lX3aX4192d/2L7u0cZFzIBxcufk48Ffl + TBwauU/aD/dCppZ5SrTo32VTJ4wG1xQzY0WNEW/RRblQM+T4WsXx8exGwaj0GaFpfRuxepcvVFBmUNcB + vW4KzDE8M629XxuXq3L1bvJeqf5Ky2CYDuFOABqMRuV9FRVKvw3K07moAMaBaOxa8MTuLAr8kgP9MLWy + Ng4VCuikZwkXJZTOw9tCv3T9o/Ez9PQyXvVUndzNygC1ZdWic5mTPIbiuUgePdXPI4q6RqqHhdEqjsni + eO6E+yA0NbcApM9HI9r1orYtuuAJREA0hFA3cE5uVOLi7Y3Bq12WhscnOkYXUuwuRdGw2NqoKHbVYesv + QMR0b/ZwQsgP0hx2hPGTRuks6rQ0VuC+6PHeuWtoo+L1r5U33WJ1vKpbrrhRVklk96WippCe64lci2Y+ + K3LYtfM30BLBc9u1NbG8tdvbtWtlM1e8r5pT7xVHE+K5zVfIPAK6pV6tHgnrxX1vVzSfBXRuK1Yig6gC + c6N7be1hwKMcjSzj6HgqPD/hWD/hXS8lfbu9lYP+FdP4Fi4e4vWU90othktkLHooiVgd+KnjYKMa65dq + qc7h7aifGAbbqYLWjafdWvCPmtaIj3l02+RXr6cWquePsaVJwVCancFbe0xRdovPBFjHGNjcaXVXJuc3 + dtVJfsxi61DXyV7QtUBapkHBxXrpmcQnX2tTFP8AQhLr9dMkM2jPVkuKqw2FgJBvRY+5x6LrkKUB2liF + LJp1sVonsItXMKoNu5NbtT3DoNo3vFW8oNmNzHNWq2V/u0XI5LXvPWkyeCMN80TPOYq9FlyrlEpJ9pyo + 17PBG/5LUNfQj4K4LAZrwjajDqrWhIXMePBc6nuletarpGrntPisQmQdlSVR51eCoy0AtZtVcwLCnoWJ + mCRvav3eawzc69cplLq9jE6pEjes1ScFGOz0cSuc7zXPd5qW0TzEO4inzNk5+IRrX0JR7Sa7qSj0OUjY + 4doVJMjjtbxcsKLFYlckNayU3IsmFZpbzTotTS8Aye3feuT1T0hjVVm+FNtVDDm3+hR7QVUxgcFRkbCi + WsI7rle6QKwTUI0s07AVI7JpCHA821+SrlLGP7uqUDLJo/Zc381ahcWdrDcrniUdqsyMIKrUJ0jgWtG9 + RxnvuAUbYxebgv8AT+NeocZQy91o85aODKWxx1rgv3rLnuG5riuZbO9165GKw2i2UVSb0XBzIxuAKDZY + hJJtcjrMTK7AjVC5YK5P0jalV2+SJcm2Wn4lg6q1WlC0AFq2U7rNvag2TFY+ntz0U7WXNLQQgPZ9G7PN + 3UO5mcM12ZymHBZR2UPotvWvk7yN7dZa9W8RmbcTqFTZQL5pLrW4dis1u3I6O78U+0+23dvTHPbosnZz + WnEpz34BcllDCdxuKu9C8Vz0s+a1m0RETy4e0g2VlU9xaALlqscqwWozvDkBlLNL7QNHK+SyerJd80X2 + AdxbetB0MKqSTGpuv2KEaPpjag3Bapceyq6TdixK6SutLE+axd5p2q64VxRvqqCuCaHURIBotVpV4A8V + sK1ruCFzlSMHyqqNACAvPijamsDisC7itVozZS0XWZCmvdwV3oX3LXnjHFy9eHd29cmyWTwouRyYDvFP + M9m66gQfhViPAfwJk3uZn+g5SDe1ZUP5Z9Ka2+J8f+nTFa7Q7itbJofhonxZJoma19DTNcjyhApSygKC + 5SiK+ztUzttlb1+75RJH2V/JUmZHOPIrl45Ij5rkp2E7q09A0vVCyiGrijfZHYiTI/hisPQrC90Z9kp1 + sRl5aRbs35smI64QLXmOi+9H5K/KD8l94/uC+8f3BfeP7wvvFPfC+8f3hevPxr139yLg4vTdQdiFMFcr + 71cAqbEXY0V8Ra3fmLLTfiU3KCj/ABor3DzViMjNlXfQ7xTGQWLJbW9c9o4NX3gjgtbKJfiWs9x4lYV9 + B7eCYnfwJUO4sR5p+a7M5HuKVvWYR6X71kzHe0xW435RG3eNYBTCLLausYUCva1ck+SPuvWvZl4toVyr + Hx/3BchKH16IxKfK83vkTWYW3gejvX7vM+Pg4rXeyXvtXL5KR3HIN0hjceu2mZg8cxzH0sn3W08J7HsY + GtdTmLBcxerR0NWnzRDXincC54+ALnj4QvWD4AsKKLuqrzQLnLnM+Nc5q1a+DVc158gtVtPeXRC9cRwV + XvcfHNCqWr1P4fgnd9Q9z+CUO8nfwHYaV19ncO1N+0SEgtwFy14ogjZqRmkd4Zim8DmtxhGo9DB7fdVY + ptG7yVMrjjk9uP8ARObSlDmwWBzZKN7a+ZWTRcXZtZVbf6ULT1hmPZnbFHifkuRm+Jq5ok7pXKxvbxHo + QcSipe+UL1rZzdejnKZ2JycP4JUPeV1yfwb+CePbUHcP8HwR4o8PTlmN+iF3FTOdrOIqmtabGrjuTmtL + B2u1nn9EKW2N7ypYe93eWjhk0M7b6E2gVZyllnt2HNF45rjVOdGEblfmxXRKvZ81UAj0KbTcmM6rQPkn + jqNA/gi7mMJzPPbn0jvWSfIK/MRRa0TaqrXOar2OpsNFHtpa/BeSl75/HNit+eov9Bw9pS8Ef4JTO8sV + /TCl7yyc9h/gjggfbaFavC53yVxCwHmvVFXxv+FXtI8FlA2iyVKdllSaybNfzfPNadz3YKvb8/r6KsZU + 1skZ2n8/1wWlyM2PYdh4KEPBBrm5Ilp7ypUKunpXeyq1JoneYWqxkndf6FfQydnWkGbKnj/c/g5VJwai + 7dntP9Wy93b2ZmMiFqSR1KJ0dLdOk3audTjdmDBgbzwzNdZAN96HEKQ+2fxz43LHMUc8oPRT+C8P4F+Y + d/M3/jCk4qHQRl9KrmNHFyvfEFfO34V94Hwq/KK+4vXu+Bevd8K+8O+FRSMk0kbrq7iiBjbCrZnZXcqP + kee+1esatVzT4rALDMe25Ei9m2i1HOjqcAgTzBc3t7VUXHGmwrlRQ4+H19BfX19eKo36+vq0qMvZu+v/ + ADgrTdh8QVygtdrVziOLVdKxXOb4P9Jw7PQj9gEpztyc7rEn+CXf7khKl4UzWWaxJoAmQi93SO92ZrqE + EnyG5FrhftWtcwFEnBVdi69UTRtNSgN7gn94/j6GKx9HKW+y0opv8CkbHPPYvVWe8hbl21uaqOqVbfCw + u3uCwAWPpYFYUWICeLVdviou16o15AC5/mFrNYfBXwM/BeqcODlz8ojWrlbx3ggGzB9PZTYY+jiqYbXL + YAFv1ruw/X0Vo8ovHXwv+tqvpJk7sXdU/X0ER5/X1+a7fr6//wBK002X79w+voKzJqP3bCtdoKtsNDgg + 5jyOzYrpCFqzOPir2OHhmxRThnyiTqsopz7BKG3+Dko9iqA6xR3p2WSdG6Piqi/PeFQJrHXB5+S1XjNI + cWxsLUx77m1w3I+hisfRlbviH45uDz/AgLBQ3jxWCwzbFe4Ln/JXkots/NXNC5gGbwV1MxG9QM4lFWms + JCwRE1A5XUVxKxWjhIDztNypUSSyYVTdFedo6ysMu2u3p2wnH6+vzXtHj9fW1Ac5nV3cPrgtJktHs6u0 + H62I/X19V3rf+Z+vpyvw+vr9MFYfrjCu0cd60kV9MW7wiY8du9pXMZIPJa+THwWpI1/CQK+Mn3aq+MeS + uABQdvzyv60lPJNbNda3i5V0YHtRGiP2PKAeyQLXydxG9l4V9QfRs77k1nVaAo27hVRwsPPdRNjgdqMF + B6JAVrZgM1QSFNfSlT80zvLz/gE2bkUwdaGmaSyK69VtWBXNJ8FdG4rm04laxAWs4p0Y6MnoQtiqXW66 + u4JoxMrnOPBQWgbIZXiUxlb261E5zntFreaLlMoiHvr7wHcGlajJX+7Rcnkp8XrVYxnzWUsnkroyKUuu + VVKx1wieWjNHFRu5V1X+K5aF7fdqucAtVzfAo4ragYnUeME3SDo6zhvVrbs4/X05a1+7t3fXkdiq+/6+ + v/5Rt/XZ9eO9W637dtezt+qVX+3L51H58VZdd+FPr/O9Brfrt+v7kLN/YrTHVCEsBo7erDqMlbzmfoqR + XOA81grqjxWrLIPeXrK8QCmy/tHk4djGihP6IR/ZI7I3XHzX7rK+I7nXhcjlgjb7N/yVmR4kftuoqsbo + 3b23LGuamUQsl7zVyduA+yar93nZJ2O1Vr5M8je3WVHgt7yydm+QZnAHmtAVv/abVbFcSFjVazfJbk8Z + NV0jtVoqi6WNwpzeKs6AmIc599EH11bNVlTthb+aHGq5p+Jc3+9c3+4rmfMqmiqroWq6JtFqtarNs0RW + S92n45nOODlqgrmlcwrmjxXRV8lOCvLisoazsK5vzUkX2WpaaVt4rVyeJviSrdmEGlOarLZgwdjAr8ql + 8LlrzSH3yr6lYehcsor0oh8s2UU6dD8s0XfzHaubQqrKOOyqqqrSOx6KqDT6+vyquSrqjmdnZvH1ct31 + 9fnvQpd9fX+cFRuGz9fr5Kz9fX0d6oK417a/X05Fspqx1/ZXf2cRcnOrVVP19fVQqx1G870d60sg5eT5 + K/0JZnsDnx0Da7Fj6GtGS3sXJS37lgD8kL6cUdvBbs21HSRtkHtCqbNDA1kjL9VXqZ3tKSTrv/D0ty51 + eKLJ4WSMOKynJm3GOQsZ2NTnHpNzc4Bc9vmue3zRtSM+ILnu/wC8BH94iHvL7xF8QX3iL4l69i9cFFJC + 61ZAv8V6wKttXOqrg+ndWrG9eqA4uWMYXrfJYvKmaRSsdfnmmGLXWT8kf9P0d/pRjrsc3NG/rRDMOx2Z + ujcW62xXyO81S2VrWmIuYbUbMbOKu5v19fjvQbzvr6+r1QV52zf9fRVHusm7X2Hju+r1Zfhv+vr8V7W3 + 6+veQpiaeX1/jcvr6+tiMjtn19fmtVtWbh9f+pr8loWbt31u/Baq1kXFE4ehlHfH4LWIFVuz3rBclKT7 + Lr1SWGvaxYhh+FXPqO1cz4Fi4Hc4IswJvq0ouLgGt64/ROkZLG8AbHJ19SomkU1f4LgBQSXI0qLKut03 + 1X/9K9wWtIr3lbSuYvVherAWCIopWG4herfXgtSD4itVjQucRwC15HnxW9c0LmRhqNEwdZhGZjutGr/4 + eSn+ZTNkz+83MUCve9ASRnw3rTZK6y84/wCVZNzuru+vrctx/L6+mrt+vr8d6pe5mxu3w/TyWkjOkZ9f + X6Kru3x+v/d6/FWGU3fX15Lefr6/HeiXi92OamzM9uAcKehLddpPyUPeWrLpGdV96plUTojvbeF+7zMk + 7AfRo6i1RY7tycZJBZ7UdJC4s6wRfJI8Pw5QKQDK2ubZ5ukVIr+1RR9Z1/8ACg/5qKGNo9pXCivWOfDN + gsM1CnDrM9AUot3o5KfapmyZ/eH8SN254PzzMLrg161UUw+ynejaabuk3emvaa027QjpBwI28PrzVfr6 + +hTBX3D8vr/NMVajJaa3jYeP1Xinlr6PuNj6x7CqYHFG/f8AX141CtnwzXZztpf6D/8AkTTxQdvz0ZOX + N6r9YfNfvWT17YyvXaM7pLlWN7Xj2TVSSxmjm0/FR22NdaIG5ODsG4JxzHM+Y4Rtp4n+FHT/AH0TjS5b + 8+30MUc8Z3sQXOXOWKxWK5xV+aB/VlH45oXdWX8v4hUbt7QVNtpZPzzFR8E5t1+c57Tb29JqDm0dG5XC + rPrH9fNWd3z+v/K4Kmzb9fQ7pVuTnY/X5rRT3OtarsL/AMirLqFvW2H6/wDF7KtKuOYRN5jAa8VN3D6H + vlCvVchEVXFvo1jJYew0WVQvmMlA0i3xUZxbbFb0/ij6ALrnyG1/AIW9MH8wlSH+c5X3L1jPiC9cz4kK + ytPBHXr4KuufdWpC88VqQsHE1VzwzutWvNIfFMONWBZMR2hAW2ea5zfiCrdn2I6zR4rnt81zwrbUw7xV + Sey5p/i5Mf5YWVj+WcxTE/sFP1zclC93gtawziVysxJ9kKuTa7O3YqudZ4LWNYnYoSRmoKLohX2f0/T8 + FaO/5/X+aohtafh9f+blZbQ1/D6/xQoNqTZ3qjXArcNmag9Y7BPPsqbu5yh3ivdKFFrK8ejlXBv55ncV + 4jPCx97S+hV2wfwHDMadqd3kfBYLD+BD3AslPtq00C1v8VZl1hRc1c1c1c1c1c1XDNk5P+2FlVep+f8A + Fg8fxWUV/wBt34ZxxV9SqRxMb4Zq7sEMz48Wg0VCwEFTZNEeRBuBzG3tFeCOUPvla6zXeO1POJt0XFBr + QGt7M8hea30T+6pl/8QAJxABAAICAQMEAwEBAQEAAAAAAQARITFBUWFxgZGhscHR8OEQ8SD/2gAIAQEA + AT8hFhzWMway6lM0b5SLkLlzmWtVF4xeJniLGOZVdlV1iQvCYHpMOHDvDdgs6xJfL0zK0UWKmzLEq51X + Khp60fiJsEvsQWF61n0j9ZFpYHgZwzjHaa2kTzHLgqq4drsjll7rx0twRSLcq8s1Y0yoPwF0F2brNfcs + GxHAtghrxH1y4DdNeW4qhNiMpizwYeYdWG11M5+ZhIYnBaKno4gAegBbVk/RDIWnOrlyHZFVHHf1hZVm + hcIN4DF+YixIoqF6wOd3GmBrK+OnOIqHVbTK3u+6+kaIcHD2hIQKm/rvFa0VW+TeIDnnaCFXhviZE0M3 + jDfZ+IscVvCZ6eSXhVYRQvrUaqUj3g8FFqNYb4zxLNF0wbcA7FWrrmX+TpQIyZb/ALiWkQQs8MwUuA7E + T3Jj5YBM5LVRLO4BkZcXqG0FQa4/EuQsVYKX0lcuybQL6tK+bK9oLqQipSdSuPvxOzCyLw8ePqDlV2BU + XK/F4ZewALGlnDXjpMGJuzR1rdY6QG/5kacMPHTkuCOqtzbdj36ZwENzSXq19oT1CRbHmEuglpZXWWDZ + Sm1SvMpEPK1hr4+ooRpjSLCIU0PUSvSO7jSN1NS5QAOu0wHK9lRRR4XRMCuSMCxZaljFqM77RYF9cSym + zHFy7t6wS6LnR0iG27iPXtA1CCBun1lu2FdtRwgMkwChSPtT1jcBjMAFzL4ch1iG6pWhYoHC3uJYddKi + LIDKnHYgaxHRtFlSuTJ7kbFMMowSiorcq48Rmykttc1nPG4A7203pw+USGybAL6sLHhttUHuwWnfA2em + IOoeoX2aWmDfXmAwolsg4KMUdSr5iA9Eq65q62574lFShL4OD0JWGuxs9HXpBeO4QhtpCNdM2xctSikt + WS+RzeZeGMeVS1a1fk4iBK6FFixrk4fSPG2GjoM2jrgjQ7Xm/jmOPKKVa3v36czLVXh88nrsglxC98TA + GwBb0/8AZbprteKTZ87ljWJhHKBTUEzImOi/b0iaBXEVm3pGImze6lMx6bbyDv0jAJ49Q3cg4GihzFKo + DINONr7zDZGoN/WGKOWA2E2ug6QBqC2iNL34xBhoRo0bxllMMqgVL8EVKiKKbOkce5VtLxzzfmGrjBiW + i0eUPZ71BUAqsAGNY7ERfKAwJ3efHMcVFWKKR8v5jCgLnmOSnGYG8htVs936mPg8gUi3jmt9yKI5sbFl + 4S614zBVQObSw46P/HTKJmqro9usaDN9IS4y6iCmbXaa6Q8XIAd3FWV4PESLF3DlK4eU1MGgBy4Nnp9S + hhgY7Dt+dzKpBhFodefSBojUhVCx8cQKMGEZaenTqsKLKEjQXr3feY0CLqtXpz4gAKmcAPB1gGo3CQnv + AVhZoe6MlorA0dT3lHTnOKjUFFUVD38doq1rDosdVLd+5VPtLgq7YPMXVF+kUajvdvbtE0sGkdQWJYOw + lO5euxNi64irowvDuIQlOhcUVg0YZcS4ripc2ZZnliCdtQOcYEvw3MnSVAtjbyqYBDQzbL1tciuJfcAd + G4oQpV2vLxULpgwiU75pJQjiQb+YSi2VoZqMd6vB2lTmeWtDuDTAQoBkqsWEQHUmbq3XpFzKs2ylU48k + FUBeWnrqIrGQ4gllc23j4YC4TK4L0xhLzEQZ6jA69nqS2vVTQ49WIkjtG1pprzuAMzy0lM06XyXLxsU1 + Ch1Fqr5lVOO3XEK/hIDuwIIFNaFyrs3dZGzJLWWg8BGhB+td4gNBRpTeFKvkuIQwSHybv0CIJEWIl1nK + uYYGoDmV8Ot7TtB0EFKu64/yXtAtBr2lq9AdYCAkFDFBogpOTFLutFxb2l21Xy/iJ3KwKA9RMj3Ibd4G + gsFA5Bq+ixUIl6X5SGukCcAwhE2XgYlJjW2ka3vvcN/pejO3MQLAcZ56wq6hc92aUKXnMRsaUatlAiAS + 7rIptrMXDxKgBcPeBQqkLeAoMP8AXABbOAKPdxBAgtKtK4t17YiLzgpVQX9y7QVRcjWvF37wCKQ3VAiV + 5zGBEatTxn8ylFhpdI8losvC75jwsNqaI3h2fEVk0u6m7xRjiVdNqqF+le06soLLdl6PXrERoVxQ2KZy + 8csWgthb+ZwcFPTm6ekoAA0ILQaLfxG2swsbyK3Wv4hJLlvNq3bmYA8ABlHnxUBSlUFyzRgOgfczHabN + Ol8Fx2w0WLfTfM5TrBN33A+2JlZfXk7Yo6laD8S2alstz2IFDaM9n7hKW9ELV0H6mVUAWDdmssVu2vGH + zFgclIN56QgrCWhcyr2WdYl9BjI/iKgY07lLeoSwWlvpCLGXNQ+XxGoYzN1auXua8MsUKvIFdZlAcZLz + 88wytB1HEE2VpbzuBFhDhhtcxIsjNrPZfWECw2XyO5lydOvaNISrBrpDAuu86COhymJd/FSYEMEgWPN5 + X3lilNZDPpKQEOO3b/ZUgOZHVOz/AGJndqxVGhToxcEKiUqni7r6YMNnLap0F8fuHDJUjRZYCcyicOk2 + Homx6cXCGs7Gi9+PqIliyjwbZlReI6cHsSgH4aCDwrfivaBlQBaQDjRbuFVatgUjyuT+YCHGLhZ6y8sU + 2ZvmMAG4EbLDMWtgmOCiKTZmBNMF93L4Irbc7i2lpyRk4BAbXpqUee1EzxatufE6hPKNtl80YiSruCUi + BYGr7fmVSqywmhhpcvOdyi1UqmSzp5JU3JBatyiv1GwsG2jMPdKG9Qp8ynG1KnkbPg1FRZFwFWAAXTR3 + u5amJvdzHruuQDlp6pXgZYooQIJAUdNhpNjMIG5TQFr5Nl8whRQpXAFEC+Jfd+3WCbRYe5yxqgDFWKe6 + keIi0ji3Qe3vcsEsKxHi9+kvutYVaE4+WV7WI2Of8lQvHKjmEJVxE2cvZjjlIBeOMEEQ6GFYOa2tStNO + FC61TuYz0hHkBSNr6fv2gJ7aKHjXviCAcjBUUo6oMF+TdfmEdoKt2EYwYzal8Y49JSIzr0OspoSm69Yo + Iu0v34ljLZgBa9rdy4EFYu33mWQatVgj4g8N0P7uLpRdlKB5PSWYMA00G+8WhwKl8XxLAVhrPWAJ0mJU + ltHvERgBS21zBKo1tbFLttgz0RZOCIIVOsXAjIHLmAGkCi5W85IkKoFkBFzADW6b3T0pioclpUGNpM/c + yikGijpWyPsYurmKfLBmsVFKM95TdFhOX2jCjlomcLdzAIjbj4nAJQBl1vdSmhBKcYTpHTHPFWTIxu7d + ZioFdHCeumAlyKQ9+vEA6DYPlhbeuSGYHalWv8lxdN0VQNeeJZJ1TcC4L4xGlSLVohzYnEQRlQXl4KOj + hJoHqdIoGgiPjzBGNukxmJZ5FFbX8XLVyD8rEGLvSJc1dlPqCZksRDi8sG3isVdgCvzN015DV65hNryt + IPAZjln1inr5byZ1xi4dgfNomM+l2QINNtgYyms2d+SOS0ncp6CAw5b6sGMWtN1+CGORenKxtFfBWiZB + bWGJeJK4B+YFKQoVarXmAuGVRRMZThPmHOgbAsHLq9cc6la2Q4jMFbqseVYrrRVQ2TNeweAgL7KQA4q1 + /u0cQsF4v1mHFF0hvW4sJYkkbHm7xk6QWAQlEta1ZdYvGGKiXaVQ6GHORlQEu1MTZpgqo1MmvW1zvEpH + PhLZ0Rq75xAXsuK2jduYorDFLK0gZ67mjMIC9wyd5SmDmsNY1ztxzUACvYqld1EaUlsFZekAw1cxB6+Z + yrF1o6f3WDKtHeJCG3GafeJlzPYDxjeMQgKkU2PNvFzEumaGU1HoEc03T2MyuosKJDrf4gY6FhVTzWLO + nWFKteC6jitAaVyxy7QtwtxarB4iPVIPDhhqhk5FYlKRpYKHM4mklkM5RKtz4gutAtdysRqYot7RLSIp + TtXtLlijkT4ijrhNl0RsIxhUiQXOutRAKdGWWWh8AKL2L07JE14iJSzizMHFP2iDrbubBHacOsVLjVC6 + F1joFnIll5aSuPiWtBnKH1MIrNq//JWh5XCqjWzvEkpNCjZY0uYhtVwQALS48zcwMscRHPPEVjbFKCvL + 0ZjAy4FZ6NnyQQeFAD8NXkeosCrtd7o+nESESSRl3eL65lgtU4Xpxtlt7fC8V1uWgpiv4TJRV1YnXXUq + Acj3+0tAVKK51RxqIXEKYpcDfM12f23/AIVMR3QH6v8AkAJzVHrhfgiiVIw7Q2Gr5mHTlC1wa+JkqBu2 + qE331FX3t1EYVCwop77isnAQRLMmzEbBBxfVWX4mUGuqaMNa/cQTSVOEvD6mY+oGxrErYAdv+ymRDBTc + yLLg2AlNHvMCztUqHaq3qUsQCNVlwWC/ET2rUAC+m1exBEWR7bFnskq1OjaXeVTV1t6hCRa5uYemfibU + xXwi/EUKJMPeXcIDNKE0OPVdSgEVE0iNV3F95QiPEYpz4uvcYC46nGMx1mtKKdlPPJETDuvAert+YEa0 + OVzh/wBlIWNUbAM13M+8SoIClAu+QXxlzLLCCwIavO6cpBG3GG6rZHs4mDsC1sK66fWIUiWKXSrVOwag + nvmB8HfsxNxaxOEOUujZiF52IW1dagk87PzqCKVHOb2LlVzcE/MjZ4WWo9THvEXFS2Ad1wlVGH8rCnq3 + 4gNGcgl9sL5gisIvaLkV16uxlOzwg2+kXNIOK7/+QRutpUv1jVKtKgFs/ShekUIwAUhEAWPbPl6S+Fjp + CkFhxnGdR/SHLd4ipDQxiLOw3ReZltjynrW9nc6y06RsgGtOHrvctUBKJTfjh4iBwWy6cHpElKqwvTPL + EkjqKyu+8CoVeWOqs2Fe0YgTXFhnrEeSgrbj+O8bCgQOaee34qD34FPNPF9YH2XGo9TSkVlwygg85Vt5 + q+uI4SjTVLwNl8JfrHuF2UThO3eGDxug2viGpqNF2GtnXxAkeEQQTvnpv0gqbLi2HD67vvFGWdrst3cr + sZuxu9+0HgT6wb92VW4BpBze78S3uTVSlC/zAsaSywwUcS/VcCT6hNzyD7QJSYTugu9mIrFtf3tx8zHQ + TOo8/Uo7t6/8pmaBiTgcNv8AhEICzBSA37kV3gsnLke+pfYnCKW23+uBHp5K2btd/wBUSqoIbQHfc8RS + lwKtp0vWHiXEIXhXKwJZB2sd61Bsk60qAnIQ1WFXnjPMbY1hS83lxsoxzmDYSNGXYUFmTV5ivxfOLdhp + zpMkMnSmWmcnJ0H+yqHTQg1zXfpKFRia45HOLuILIoC0w4eKin723qHWWYNdkSKdKuJ7RYL109BqWFgv + RbE36wH+WWzko+Q92CXbQtl6TZLG6tfRnR5u45z7sep0m8wWzIZVC4U7T9j6RqWLTnlWI3+LarB3NI83 + Vyq8ShAJTFpNPox8LShQb4UZf8YUavNlfSQ9IKkUbbGkPeApAIYLcd39RzKOsie8fxl2dta81BFq3UHr + R+YLl26WvVz8ysoQ1NbDPZv0gNcPW38j7wBX1i5Q+iCdBMvUs9oBXB4Ds/uqAgolvk18Y9JXsx23AuGz + lHN9YjWDHFl3cAeId3z1iBbVl7csxoBiAj4IyrtjODChu87m/UZEgHpHIHcFeZswKjYxzbj331iZjBFa + /CPThjvkODvesRuCOxMPDnYRKltmZJ3iBQuI6wmpYAR1AA9OkF0Kr7gDRt+4rQABWimbL5iT2SkeZi6J + iYF5xKRRAJdI9b6QgbV2lh06D8QBZbSCA6ssrqNnaIUpegcPdPK1XMBtcxTg/HmITyU3dvKvHgh3P1M1 + 1p4Pg8dIjdWS3pAAaXcuzrXrBbv3amkp0yQMhx3IDBKDVIxilAbeUKHu3Hes+waA/wBjbEq4zS/mUVut + CV7KxwjHAP6iwCFDkW+NN8RE4zVbp6BFeW6p+pS7pFNkL+eM+D3gC2HllbeYq4VbaLGlvijMYjWK2Q14 + 6D3lpCzbZAUheC+X2llcCMUAUw+Zage5b5tzGBkDFq7s+KmUb5Rulag4XLzcp0RNVXytc4K9WItYbVab + /ZKRUCc2W8jiPGgaxTdrc660YYypJM5BXFOn0+YifkIFDBjF1LggSrRY9Gz/ANlAIAQCp0wBBgAUAKHt + BKBOlbmKN4MZK1jt9wCyjwVVL3zdekDYdDaFZjw/EEtkuVCrzG6uNpvcGEF1KDxMlJrxES4joD1DVZau + FSpFQ56ZHfU6S00ulSetAtO+JQAAa+da+IQsEklnhRw8dJiUWvC97hwvIn/LxirbU8TKkFNtL5K9eDmo + FReekq7zMj0u30f9l3/yomkuLyafhlBDGjI5E6CB6yjLCUC/kyD7hKe2sIoeDzZ3gggUFe9K58Z+5eTN + DA9Tft+YLo+8L7FdHNczOn6Q0O16g2VjQWx4wE3x4irWKV5zompobUvEsBgWweO/+QMC6I4GOKBXClvv + MZymXV6eJhJdGPU/DiUI3J5dEhwbpQu+N+8oLAErYPV7QOkqlMZlanDuIcTHNrGRCeznMK57YhV2hAJ5 + l3bKwSprp+ozLKuCEC4SKtgKnbXF/Uciwb1GGFYa+YaCLLwGt+viLpgNsJ8iN9kbqNmiNYgdLscaMamc + UQXtw+SWKSJmLdaW0eJaXfBRCnLcvDlZsfXWUCo5Qte0WIiPX/UUK41RuutXCry9KpzllkyLnsxqAb/o + N/URyvH9yy4fAL9odwlRPRzy9Ya5r+bMDFypXfqz8f6gu2yXugx53MGQ0Le9CHO4K5eEbG6NV1NHqwzY + WjoOiQF6CurfmVWcb6MsQcQdArar9olDIbFMFgCZLgvt68SkjVVpUbfQ+ZuWwxZCoX1iGcEzQyUG2JWW + y9VLaWdD7luGZEXIKotyAZIaHAG1q65ro3CUC6pXTvPmAaC+Fz6y5eO/oiXxA7FYBIZA6t12InxxxQdB + Wj6gbFuj7+YSXsjX7BBDDauPoJFcQzyRAtXQ9mJgAymnQfel9KivBFJyaf7hJRslc6KhMI7IyB4AtUyD + rR6gjN99iILThTZ1H/lw2ovQc+ofEC4NjBEoI0jQ9+INjdb6/wDHrRSTYMKntAL5x3iMhfsywXZmVx8E + pZDgLYeZaMNXO3n54iZSTRRaegTC8cXsPea8GetQ/gyiBDZRqBISuQyjo+NRUaDaKr1/UOR4Jpd/7KKL + JwCviLUVY0Ae8FWITPQGY0bK0sG/L+IG+W8l5gKBit3Pt32xyRG4NjbCqZ42Oqn4jMVLgt1wanNnw3Xz + AasOWor3ZZoHAXp64iCOZJivW/xFthiZGAWUG75Dad8QiMnd+4vmhIVGnHPWKoqz02J14mOO6OkbzzC2 + rdXxRmHRFU+GB7wRioDZgetzkBppFrp1iv1JdYaFgMI01bMqgb9Jdx7hJYWurxyZOIzkbSgbPIfuAPer + UPiiLkZcqv3H/KItkDSFMoV5t2X0SJhIQNKTr5gK7pbpnpCoXgRP3M/oI1XfZ7RbbzQRn+Mb20KPF1T1 + IDDKIjh6ejfeAUULqzr/AGvSIVneaIZlS1KuTNQhbkBpz/kQCwyEhTDnNfqLWURos11bZhCK8whmg0Yx + AqClYUBnSn7jVQAKAprxziICVoArIC06SotMwMJ4Fp2Ez3jp5FbpeEsOhh3ASlmNlb7/ADMohvMDiG4R + 0CKtjsba7HX8QGzrBeaa9yyJlygepw+zOg+IX/iCqpIF1kx9TPpDgIbDCyDsUsTdMp/SplaA+uvaAhin + lrcBwEehcA29v5O67jkgP8wIau7V03XlIA1E4G32ldozZQVz+oCLKL8n/kvhsm8xY6TmvL1grVLQ5OK5 + g6JOhE9MsolDJeuvwStMEpsldGCFdvJ9SBqzn8lzH1Diy5y44hoIcUUXySrd6Kfeomvlsa7t1HsoqEKK + 933CALEwmww+JQF7WhvD+YikE2+gredMDYwM2o947YuAo9+YqzgtGa3CbUVoqoAC0OVc+YVJVHZ3KLqA + 9WZhtbBq0l/EBaUwc53EqOwXnItsVdUy8bl9bGs1inr3lloty1mVjlWJOlJ+ZkaKQLuAK7FpfKDmgNzA + gCI4rMRbQc3ZqCpaGLeDiAUAW1n1gNJa9B7dmKxxkhrNjctSlkVllvrD3OBQoFkbCbPPe/8AYCtGOIrd + cL6IVUc0v3BNnxMeC3tFBSjopjrAV+cSkrYYLPciK9Vkum1/ydxdbP1CgavIfmokGetflMkZyUc8ALD1 + gLRQBumzXtAWtDcqApa5gVCgW5HUt9+nGYq3SijUGmBrQtje6tJZdMjk6IzgXJSt2XuWREmqG8KIrhqO + RVqxn4hYoDUZqmC5byUCtzNJo4g4LMAizu8xedtoIvQCGW3xDCsxsaANZwNY3i+WKjuAFw6nCwqcmYJh + N1xrXiVDpoMoThtjDadLWNXEHmBRz0iTDTQv6KlwdTA0O+MwIKR0rSA7hka4Bomte3pB5JtMfUARFZFL + 9GpkWA0GZkxfDAZ8piGNwlqkMYhpUgrSf6XEwYQMOiu8oLTcGee3NeCImc1Wr2zn2IeBo8xL15HTHMuS + ukUrWfCU9yX1UOW4db1AFHd075Uo+IVU3BQA/MygNcrdK4uJWo8QCiB4/wCVJgVGLn87OiAqHPNw5l+n + +ImaqmaPyEu3DJ7yuJRw2dZqNReGAtsam0/MRUxCujm3PpqAWxWhaOSjNmzmD9jm8qRHk4NcxIX1NfoZ + U8r6RgGyZDddpmaA2fGJYKQUjefELKKJ1zEN3iqxUBkyopndcTq/O+uIhoEp8RGMtqdVa+szBCnqXU3U + iuU0QrSlPZJTlB1WoKXcipvZjFlqDWbzjnMrLys4n3xAMPUsfRl4NG2qnjfrCC6FlrmqD2iK7Wii1wWu + YirM6iQgGcSD6DKYcl7KNtYcQtsRpK1MZxuXWHObvxGHC0QTfmClun9sG+8F2fMXWQ22PHeDZJAMYavm + Ua7lofiK3RjeH6j2PUCjbmqiN5yUVjx2wRBnBvYHhYtfFJQRhiAb7X5jYLYoEL/UdxMFQWs1Q3w58JFr + MLhUAuL136Q4taqFqXlrzLEoRzgcYcblRsjez0vXpGZG7Vgbhbd52FHBjOXnzKEZKICrSZfGd+IJmIEa + CghVgk0UZDe/EDNJgMOOHuXBByWLIqUs7GIvUIBN8OGPmNIoZK5Gi8Ny7KDatawl9qlvZYViutGq3uWZ + lyrQ5qzL5YyAobWTlbsXtjtDXqE1Qrwn1KJLVvbpor0rEx+VVbdeIHWAEctbrBiJr0DeL86mA8ix91IF + szen8XfMaWo5BVDkoay8bgJ5i6RbnaVh1puWaXaiHhQN3d1mZIq83P2vlgilbDv6lr7wWNCS3bFlbqwR + 7wX6LQNwvDfJeB6xFUwVgKIuQvcEMdJ1IdnFsRBre9/s72QUE1FN7uPE3jMuj21ra7EVRmFJbzaQWK2g + ttq/+ossmxnTpvXMeOhdvslPBGcp8XEQib+4H8QGHVtU+B+YuBUBUq6sWKSBotVV8VB2dRD0uGUCyavg + cX3V8TD2DXC8YMHgiQxBwhOAGrObig3N3KDneYWz2yMezBYAGxajnMGNiCm1bcEoEbkc/NRdpjgKr5YR + UBBIPcb4lhlWbXUtpot0eIem/WINByjv41MOZ+iJgpmcWpQXgcCqD13BCqhQLqoKqsRq5mDyhtnjLBl8 + P/tcSxoANg+iS0o26297llUKtFVW/MvuxLzNQlBnIiV7xYeMOa+jTAwlNl/3KGMoqrY48yqrkLHe8Xce + RWBXXHWPCFJM8L4mVKSaHvK88IuEpMsX7e0MATXgVRmIq+VEOOviCuLA1bCpNFj2qpdIo6R2fqVBLyo1 + PUZml9T9RTCBymntT8QgGMQaUPHlx5hjBoJeO9651qHKBTAJl8uNVFCCi7QeehVVTAOY2VA2me+9pdtL + trkbhcmVju+YZLpVFcW3GaQBCmgy14jNlaDdlm9Q1lSbLbtFFVao4rkXQW6iBwuBTm6TPZirBjmJb6GN + QI2WhoEsccWRxhBFRc3ADkv6lGWNKAJqnTnMRpnDe7Q/ZEJWdAoHHHSE2mef0w3H/wAtwGDOo/nZdO8J + N+iDH2ccgB07RvrKRawGbS6KbHxFZvJXN53sa45lOxChUu8Qcq8kUbvUUsD5p15TUKKiRMwC/KSo+VdP + mMB5ds9yJbBlsxrintm+8wGWWXKTHoC3cI9LOQdHSQWYlO4w9oDWR4fRjUe1z5P5x2ZVQTRWDqlWspZQ + Lerct6zm6MUVqi/54gwILLEiACU6S+FYbK0yyC7khBU6ZuhafuJTaFeOqr5JUDZV6LLbfre+nGSU9FMr + X2RJSRTgAHqX9TKh8bXy+IqKDXod5okDtjs5z7RDADVerWCwXzStc+Lh2rNlRPSVHAHEBcz4G39RDnM5 + 9Qv4lYnGLL4gqEPYRQgFvkj5uOUGlLh1IFC1YuN2WrqpCc4hbC9HXEAtnY5JZrc2qzEeVHaJADALXLiM + a/T/AGXmgzaygLrAMgQA2pT1gxARKtrHa4syQlbDGjcoNpyRGuOY8CBABTcGtjL1ZbUq+/7Im6Uaz/kU + NqALWi6xW4QZKu07q3cS7ldfBv5hBxlBvkyQEtmTrMtZrozw/usspzVpKp+U5IqBFBRViU573KalBf2m + oFLbRXkdY1uCxQlrw972fURQKlpkatHOZbXe+G1UWSGFdgcXfeZoUAM0FXfvfuRSbYaTpn5l40u6zw1F + UqzWdXn1PmCI4Bdh0h4AJbloSnD7wMSAAGcaG+Su0qlaFAVDu98R1HBG7tvLLDm+vDkgV/NmOGAUiD6S + zY9pzvxgWjjcOzgZ55yPqGxJA7bdgcFpVwS+HNg5t9y+JiiY1gCuxXvKoe893EbXKsre7luDY/RBFgcO + l0Y4T5ltWXLVns0kPMAVHb7Oqcjq5gzfVKD2dr2esIwLmXUfNwOTDFVXeh7miVfeU5g46GrHPM2A0FdR + KJHrVH6JZSKAxfL1jRaLf7DADnAfL9xGlIkpu5rOYNJaFkM4VS4lE7K/IJYb9rYwRA5+xmVA3vCUYhdg + xbYFoWPaXyhqtnsyQEBPtguxchj5hB1JvFjkXjmCpcQAVzOZivSUkkIbFeJgerVK4uJMyveAr8fcXHhS + gOKY9eiyrhtBSzS+wuO3e2+0yAb0pd+sDveTjMYy27ykRgsWaKZkoAutWamTZEPbMBlqhTpX9XFWIF2D + bWYYbX6SixY1yn0wOjbs/JGoRz0EO+ok5oM4KXdQ5ohTveXMadqqG75si3smphcYpqQvC1LxUtY1iMma + LVO/aGOsbjFp655hjLnh+pbXcdA/ECFWYK5GufOpheijUmOsVVWHFZqi9l1rEyKWVDwOiRD+BqKAdns3 + EUUdRQvOkedwVNSXQayY+YEsODYqoB0uFTTyOJaRLxZRZ+ehHeJRKTHuSi9QCi7G/TW2UBymNN3Zbt3D + D5bSVXavmPiqkGuIdtdyMQQb0W9JcvDA7953oV3TcoLR29Wq/EdoypMuaqUiJSdYF2OkiaAuZ4WvpYMZ + C2toKxg37xQQiGbdGN0lW+7G4tXkWL0CYZwj5wxWLSb8xQ1Zw9O0pQWbH4cQ6OisiCY7pmK/halC8C+R + MnRmq3wJs7C+7LDBl3TsdWIFf2dulLPInEXaC1qu9gLTmsQEsWasavS99oLxBjOjhevPiInFVWMGhqz6 + TICFtPOvNOpyt4P1HJVSxZj2gxJWF5gLpk894raNUnfS0yDYf3/aLaV/piOWiPNRUhpYWw6SsXKKHdff + /UJape3sRcUqyc9LzLE78mndWFQe8PKK/mWC9LRRjZd7h+cbyWrXpggMV21KwlTSHALXvLuW7iqEN8ly + jmXMdzOoamwbpzDOcXTcKGSHKvzL+gHUvPJ7RPZqCgP3EspB25W9wR7Cxsa+twerieLxLqXcuWuCm1xe + fqK0w8O3/sFQQXiLmChiNdzUIUtooCu+0u7IoSnefqU8lUsB4iNnAqCmnce35a4Qr5JivoQ7CVYefiDH + tnvcQKoN0BTP1L1NywiWXg8Ia9YRnVQ2ci0Pbo9Iglwzt2B8RTZQKrAUW14x6ym0oeAtHpn1jAbbLLd8 + 4NSnUbEabS62uYJiBhCWcX1c57RLN2p7vfuyzsm/Kwl0ZogwuWnsTSjiVBypV6WQw+Fb0yJ9wA5il41C + ZI2HvUwpAsEb4Ikg2iPJF9oZ8sLNwVgVtdtlNaMmzrP/AD7H/lwPV5P8iumw/GK/WCoMDeBCELStvmEi + gXMqGlttplThqEQQDTsPABEOVVSl13pKGoIEgFvXO9uZczTQlF9TxTm4sLiG1jO3Bi3cmmsX8zDB1a2k + RamtbYx8oQzPdnyhZDYhq2fAQOOeFPhfxPICD9RFN2iheLZ01cLJwR5T9CUvd39rLYShRfaI1teZblbl + bTzNwuvlIFVQq1rOmIMqY5BtzyeKjUpOoUNYK5ccQYVC4YosTVY6QI9XGl5RPmLCvRTbK+YuFImEBp7G + 6lusW0pWXPEcQFe39xdiukh8bi03upMnGeYLWw5b1KclXziNUnu6IrDU8LA4klIq838xYY3IEfmDM5d7 + vUwzHoMhkr49YCsAF29ygtAOr/UR2sasSAKWFd5mWae2V9sEKBUb5L0lAWDqoZn05LyHtivzKeC9N5m6 + 1+r9RvWHz/iVYC8IESupEUVw5bloxA48HWJlvRFiem8NiB8yfqL8CtugqH3NuAoDN/iI7qBl7Lqqd6Jh + qVWiLdfl4qbkRU67r5y7iGgbdF1WjGs/c0HIGga30MQ0ttpozWMkRAtaoXlMvxEjGzRTd1n6lbVYDq1G + T0hABtSbt259DiIHIBd2h+MmQ4lSqUuoaqtD1ZTGgM9b3+YuO8MsDKuKcOZswaABHrY4gwGZSMq74sGG + eqiMvtSv2CZGN7r8MJogcKm/TEpACM0i6vpn4hXYMKWwFvYKxuoHSE8X/wAZQKG6xzz6w0sV6dEfmHSO + PuKpbmsZiKhvceDHdLuWaLlt9ZUzxTo6WygteekAVlUoTTzDi9Mpwcd9yzn8oqCtrrtEYK0eJQjnd1rw + ysOCgouM1ZKaoAVMKqqHpKIcrF9EtXnp73R9JZ6bcd77RA9OMjycR+DZAN9564JdSQUAtndVUtp60Kz1 + y7xBXnQSe5UPKA6A+EJXVg4afss+YQDCrIA23riKu1ddSzyDm0HsQxCNAzrbyNl3kIOIz9mAvzLNFF6h + IoTRD1Ex/eYuTDA0Jeoi7t3bcAyI4u3CiFFC/CMlguuk8fFTHWZZQDnRBIN7aub1cpdZhpVj9xWpoCqt + FHMuyCnn8DBi7fS0/ZMtNXSn2SgsI8CfqXVkC39VgbCnJEU8amkEWzut4dRY4FCIC87iCZoRXTefxAoo + u7TnrAShnOLF5KFCja6MQEAFldGMAbcdx4P7rEdsyWbOKT8xhLObnL6altDULUchlA8RcYRxh1wVdQlG + rQEqh23mUO4lgqOmCEEWZhrvEXyUK6gppKUVm4JaGYaqvJfFXggE7yC7sy/xGaCm8034M4DVnGvkZn09 + eHPzqUuBpYasEuvWu8cY0zfgaojgojdkx1N/iIbXf+YBUIxVuICBmG4Xg/PpEeEYWzr6fmLeDAaJZTLd + 0p03xmIePYAJkxecysVRoQdGyluudXRKCsPOZ3rHvEw2AWUDfrxXzBgGM5Wn3uVlMBA0S6uuLryMJVuV + m2Hg3E0Ao1BtnUOK3mGBUBilW14mCU1d/iN2rjIgJIB1Kxfe+zLBzzAhlqpSelhaB0r+DMDDVHJnKnO+ + kuSBupp8yoVgQrYdwsW3ZprSHn/KD1hsQyo3VG7gMmRFcqzKva8JaL+oqYrFsO9czQCgwe/EaCkvuU00 + McNXv8mc7YwR12PpDh36LYbWu4Eg1QehxikKzGIhZ15iK/ojReTJfepUyaGAumERiUKtRSgPo4hVhjLd + 80j9gKy03WkGXdMor8jAhaFY8Qvp1NUp1rpBFLYl7HMFjKxvv/sVKYCeHIQ1W4CqLZzNjuqCQolmxfPm + G2zij71A+aNiid27teuIAEgXYtrL6zYdHvcupSwQVnXhgjHDh5gzUhdORs9ZjMo2rayNMQFZ1PpKYweU + tlCPNJpmfjOEz78y66RrDafmOK6WpzuMFvtDN/c1hoNFTiWvGvUlzAl+P5lFC84MfzE09V1179pd3X9w + RQSjhHiKpbel9KpXzMLYawv4EwQNloZnDlayPSLxClJrvVq/iVQurCh4NYdbJdLNq/GGJbLQ2oNAYsTe + YuCChKN7QfzFJhxleb3MPA4FfJj3hIXQswg8fqJQbIUAK1fBAKlW0e46gQ4RtiG+uCUKETiL1dFR7IC1 + Qt2X1HXZgesA/wBUqFgpGVdDZXPFd4HErbu3lv0gHWzSbhWZUYrDHbA6OveA5ON1j1hsHlEU5yjdSzx+ + Sr6i+oiqyPyxXK+F7kYxUjsW8UMxt2gC9WWJkjTi4eF9rzcV4aLDfGBmtLsw8wNyVdEQqpGWWhdUhv8A + EsKtRS0U/JNQx0VIa6cFrBr1eo6xk14PiVNGUKkcuepBRJxVfgU+jG9jOFP1DQ4br92J1VLsPzFpghjL + gaeagm6Go1WX2y0Ld13zRj7hAQ4iLt/VwLMWSqt79YrqjP2BTFZgXK3wbIFGIwipflD8SujrXKnWksIN + I9AiyWh6xLwEo7jqYRastq9bI8FXNR8z6jZS9V/gfKJz/pVhec36Zga6MZTxZcx1Hq1fL6lDfMy6NGZR + YHgAxUWw0cP+nzAqYKbKrPrLJtlXAB24hoU2kH0mSdDTU9WK4g8CB7QlqkIq7UpBiKvW3xE47uI/VR7j + qik/c+aJH7qKosnof7ESBWhF88woycqFrpnrAAgrWQ9XUQ2OdoH2gIip/oOIWDkzXr2S5LD/AAshoSOB + E8kyLgRFnbHrDdTjF8ZmCwimUPPXp7ylHot6t5jwVuB+UuOHR1ZjoiejEkiqxA7Bg9oMJLRiPW889IxW + BilmFBp3g3uVwi4dURdJfb2hZ0sV10dfEw1DZSjL+uK9t92WKQGsajrQuap95gm9wo+1H5ggEaoH33FX + a9UdHgO5FvesY7yrUjjZBwrl1vEWvtclWUGT2gIXfLWzzDF5CCOl5uCBQGxuX4Z6TL6tWbCZHtyesA8S + sX3CjCqN0neZClGsFXtUxN0jTvpj7Yh0PkWXowGi59JRmcBQIoMbx4gqteLoIopAwtmnLsSzo5isCCLs + tlPmzfWWMQtoYD0lnaHJAfIRNEDCpQ6WkaAUHIbntE5qF6Bcq1f1qfmWK6JYL+YnFxdE8cPp0gBg2ip/ + 4ksuPtGwfJdUDcSBQhZdCN7MPxLcQQHZu4+FzWCUO8bvWApRAkszoKqN9YJvmBGYe0zQFfUOYumjYI6E + qqdN0qQLhMFK9KYXGGCyg7LONUaVvrmy/SM9NJmz1xAaGWgAaeVYgwTBH+veCVMvAFzGP6tPmZ0eaDQG + S2AmyZDDda7uvxdR6tHKgN3pIp9kX6qCPdBPqWnY9PslGwVoIGrsYImUaAXTG6Q7qJXb/gprHhha0UkX + umS2j1beHUU47o/qgMF6UW+JkQzGS/USUAY6fnMELQrdDompkikp1NI7EbqU7p0kUI8gAzfO3OYngr1k + lCIoFF3sYpnDe6uggJ3dtFmZYnlL/EQlyjw/UABuRhCr8ENwJiQL48nmMKF8gFVKCBQ3CaJVjEpGRp+4 + ooB5EqsZJakq7R/qIBHCR1YyxDkq4gN86YBauuuYBjSYnWVQd4MQjTQ7Jn4gMrZHkH8MwqOq2iGopVe0 + /UAxOga+4Pt8WmketygwGvVhzW9QxSlPe4vGVhC2qurZbcP9mIFwtc8vEts0AXDfN1E2Axut0eK6TE4M + YBMec3zBOTlBRldbjgtkKky/mJs3usXceB3X0gECHW2L3cDpP9cxGjbdFNk/WgPxEbf1itKp3lpIC3NP + r0QqRVr7lujfIVdPX9RGkJQUV023Q7lxR+dp7W5fQl5YTdVlgIOKayzqJcC8y9iltKj4HrKPdCCgXktD + S9Yl28JpmGtGk4i4amDoutkoxYZtV8QUXJ4Kj3lLkdtN4vcwIZajm/4RZxiELOMsvd6wKSm1XLEaU7Cf + 5HHlwIoOOen3CeUEXA9hy+cR0B7xa8mX3lIujAZ+FqwRUjq/dQdAJ2/eMgdAgOPEuJFqwPoKlPzKXGdz + 9xjPjT+JvJmQi9NkXBMFQbOitb6yjrC0QtGLu+WCFZXw/MykdKmybwuPzAAUHFLMkBXLPm4NWWuEZ9Ig + EKFm1bySnKt4M+iYFf0ukFJo4gx8gWifIjK83JHSW45+0AWQoOV1KgOuIXl00NtXfzGqhqtsq/8AYNbv + N2YlCzyqqPHjiWAaikWzxGWQMvHPaDCC9FW10xFm7JdnuxLTJzCp9obVEwjfDvgxUFBlDkQ9WBBTdq9g + IdVUIGEXe+fWIRaFZfJk+pfHGD8RUF1eYLv0JxU8Xiutc+sqDYOk2nEuuIgWqRUmGhlXxFSWIQLwFDfW + tzCxVuLLgKpeuKigvjkiUeHvxHJigqmUc9E+Yn7ll5uDZt4PqUpAaQr4KekqRzJM3eZgUBhncU33b5h7 + 1KUVsH7joICMMZurlo5Dl1HfDRAIxAp3iHMdqYDRE4TcWHp9bFTJ0nBa/uAbK1qw7WdtvYifB0rYOnHp + AIZghYUU+cSytUaWKYtoOzFkVcHpCBK1NMB5lm38QCqEd4zLoV3lhiQsHFpfrDw/c9G3hq668MXNaCwA + KLC7VdvWLNtXAIVdA/MDIwkLCqtLPBB5wQiWqrq++/Iw2uUzY2H1PzDIsRL1Y/7MpyUBdOD2MQUFaXWK + 5uoTqsBsgZ3jLxzLGusAZe24N+mgvsS9ektKAzuMHRZ/P/s0eICiR5vMOmg54xMeauIc5rM16JW+agbI + AEujr8upRYEcoBfo+YVKbeXLcDEUonZulGLVY4RHswfJnf8AbENIeD+JVh3cg/EpFF6/YIYKhBVBEsbl + vXAKxfMvCENdZhqfdQjBBRFthWNx6vV6HvtCcBlrLLUMIC9YbNj9StFYgoWANntmIMfVajurXYGqIoRV + m8PdihaEAhewgX5GGHGKUKPnCx4BBw0Htgi4daowe8Clgly4YLsH0G7MeI/BAWU368xUcItjxMAIB6MH + JACH18MuI88pS8yhxAVAOcy38V/Klief37pbNgA21zljTV2mmtW6jPqrBWz81Ho83Lqv3FUlmFKiY1XQ + X/5MRxTXWCrHIfqMcZ/FL0umx8RGLj8oVnQQKpYYcVFEbNNcJLAHb6Iw0WyRYr2P2mLeRXtLvdZ1MIq3 + WfxKv0iO0v5zBNtE7jf4hhCiaxxx8Rnx0RiWt/jYhLBmsh5dfcbdqTk4nJeRaM1zh/cTJMXGh2V/ZmUj + LG+jCAc4d6lDitVz7R8szJL6gFNNdOmba5JwZX5K4qO02VOwLuMwGqF3VB2mOd0mAo83zLBq1XxdPwyh + GTJOVNfFkAQYowXpPcmMtBZtQAlF7cWPQ3cBngjWOOPv4irDWryQBYBkvCdJlAjQYsmHpgr0IFFSniKl + V0gO79IoAMifcpBsKAHL0/tRUFi0dD17veEVqs/5y41dGFyNwms7esQYNy7jhestdsVHx+JgSf8AgioG + g+tzViq0Q3qs961OIALKsXeXUBocAHoecTCg4AFV6EQgCOxD8cyxQUZ1jUHinowuSAStekAOMGSW5cUi + NAcX8QI+3BTb1tgmbr723LkXTSUfMVzjR91uzvMAROXK093HHEUAE3W8rHxBAgBZcDM4ueOssB2doy7a + kZ4OfhgVfJwy674IbLQ6w9szlhgiaM5QaKjBWVni2XkfiyB2kFcKsXjPZha4xue0Klm8UvzAFb6gN48c + S+lDxr0OXvGcbSWvzL5Uk1dZq4paImj90BlglgFhzUPOHCrXbcV9YqNGzeogRWk7TWFbeYhQNnRsjyBg + uN+lwMKOVwt7+kd9QOfVFwAsr2JXGZR0npFQzDQ3c9Ym/ZhJq3WBmm2LxdVBEt7630howWBoxr8zMcKn + kiAtSKQ7OPeKAWLQwOnd7Q18LnLdWNVV7ImtIukKXa57QaeCtNGdBzEK2VkC2u6OgaqCwJLRVGOxuVoc + G0c3zLuaHJVQUAcQ9wbXEG5DRVDJfMBE3yXWGrPliB3K2CqbuMoNLlbHj0fhjCMFB7m/iUDhVPjZ+ojj + RTpf/mYPkA7g/MBbBh2pdtRsAawtGCWlUOnfzGwNHUL+mNUo7s/EdpRqxloICAJb+A5jGINUKhXpBgpj + NY+9xCAOsY56cyvJWiUmCNKC6OXZLu5cAU6AW/QlO2VY+LzW4CWRsr+X9TAcGV6cdCo6MIMvQY3KHcaL + ddYXg2QQAuQeBhaAEyGNZzz/AMI6RRQvDePEopk2scPSDWi+CUmVlhSKtxtqx1c2zXPo3LAGreMnl3KX + UI0BXy5Y8hapcplru38E3ZyDN4+8+xKC5i/N8bzEL3CD4TMtWGHNc4faPNRRp2wVmFazDG+Ws680VDgZ + eSZnh3EFbWpwdIsoEtRQTtHi9W3ggSgBubPO3xFiUaIr0N+rMKOpS15ePmYqGnGbx0mbEcbehaLwmv8A + ZyGdZdbbmlJGPEJC8TkGq7GYDKhW1P1K938l/iVGTHJ/UCWl/U4lO0nIVAjgdUPyy+bgx1pmk7ylnOJi + 8pz3D9pZRGGw/MbeKuoIF38X/BMem7C/EYwFbkhmOCB6cx14ys7WaKrcZLCSwexYG4QEXNlbxK9q+oSV + G1Hp9jlghpQrSO1NLuwrFgVK5JmiIkAO3PSHh3ZFq8is6JbBSq1VLzUBZ7F9oFAKNZo10/Myyas2y0SG + 0WX51NLAtFo8Vv6llM7y2elEfQLHKN0iGNPeBKVUB3gU+oQGkNcpj6hoyjKc1ye0Q9AY+z+7zHjKJnIf + 31CmIzsvd5+MxKgBKUPhHZUg6DLWLmUE6m/cQcOw8zVniYZFMlseWOEZiwPjMRQwMbXuy+oOgCWhQMu4 + kw4W++Yq5L3vYmHd+tHT+8FB1Oi8FZZdWYpD5KuBW7jowqhlGYhVEjnjl9dSvYiHLQKeGmaUTRWyj0go + aDLXR+I+WSlbXbXWMTYGlUeIN9umUP8AZTS9GtY8Q0fSCvL7OI1/eyRpsqAzECpFaR0n3DxatwmFHvld + cVHQckXQ1Wd2vxFaQzCAL45X2IQOEtDld9y+vaGYKCxL3defmGOpbrqWGYxe5h+orrLNtzq+a6zKq9LJ + iwpb6Sn89K/2ZljVkvmtvwTCxAjie4GDzmWWvmg+de0wm0FpTyzFcM01L1uD6X3hK21vcYSvvPFypgpy + Dg6soxWpFa2nAeJazki9Rs/USwuziEbt8wJYFXDQeYH2gi6zmDR4be5FmcQ92IUyaHyV+ZTCSBkXPxH2 + lvss1Gh2f5Z39uwPuUuG4vC6zQ2xsu54MPSBBsEAC692VG7QnXpKxlcBfebXUTspk7wEJ4Brv3XmIE6H + pXEyzRM7tmQBFoadZkkgmNLfo27ONkrCnEDRFCMMo1n/ACBNmy3+ZcqjlEsTtn3i1XzmLXOpzXbTjrev + 7UExCJLNaKz6KMTlewMAmzwTPvALiCQeazXqfMvA2AfJn+8wGLuzXUYwhyHxjZ8MBtQceePfEPVQxQfW + 3MUOWYByelBbF+3oIv0YGXf5P3j2sHYt5vlMI0vpoenmdMlV/wAQVN5IqKVxesuR/ogC+Dpgz66rxBYw + gAIWFB6aJkVJrKNsYGLHH0QbLRbnoBlgulGC8h177lWYYDYgJSJYjx4Zg9at2c2e5LMkS9LLgPKyxA1h + vPUgdM9W4QqoDfPtBUcJQdBx+ZhCis8Qdc262HI9baiDzguhMDKoyCj+PSWoN7D/AAz81GrO7caF77dz + MhRKCW3oLx1YLDDuhGTGtPaKQ3bRY7itvaAACgU086mxpf05fhjntRFFgd2I4QNgOmdwC4Wi65sZkcNB + dJ+4q8hTBL1W3vcdwCQ3s6qU6r4bNda6RGXL/eIopDuo/EG2XqkflvUfmMUYcVb8xaGDjNxwUvRf3BSm + lEIq0rrf7xOAix6D+4MG8Sqt0MTIxA09Jg2yxdA+/wDJYiKHHH/pFDRvVX6zy/kT8TLDHRB+IhG4AOQv + GXLDGedEh6YutyqVLzlYDmuzUriUtZpvWB6cwJaFbIfdSICb+ib4Kxf1KYDwGglVkWHU0SpbO1GvmID2 + aA+wN+k4uDtdX9k4jlg3ZZk9OOsRYKKQqOa2RqFFpgfMfKwoXPz+YdVer8lY9pSqcl3eHL9QtQnbB4Gq + l4vKANPS+lwizY2gPPsmujMpBmHYmK/ukEqww4wMGw5rXh/2W0pJHHDXx9RUA8s+v+/cthYT+sQIjNFP + pBSkvukXvd0hk6C0GA3Egl4d94kuoPNHhqjLpuBEuLQmntTBQvgLBWKXLFBhUxYHsxmUsIEErd8RQBcb + IZ6wGJTy5fdi3lXdUGR4HOcdOkQxeXBRbrtBa7yolEwg1+JlpAQWDl8wql0XFU1jlIgwqzjNRhSue/5j + nwCwvZ1qZY1Sbr4gKobMMOwy5yadeIpkikW6azmrNwNZQc7NX+GL0qS7e8Kc0ekSSWbFdO98HaIcyaIg + +ppVy9Lg+tcRQ063VvlYvAC0ODWcHLtjLGiVGzi/DF7izZeRw1A9hF3R6VFxwUwyH1FJU8U4cdY95Crr + SblmhC2xLOQc5oZTKg1+ZMyGPUTboOyWTOOp/cyAnqU/MQafkIhViWhYFf7KymSZc4oxA26wG+qKztZR + 9D9wmWOrNIWS5d4amsdP+ClM0B8MSMCguND9wrq90kBYSmk4hgvSwVN9vSC11FE9bqVf055mR2T9IgFZ + BsKnq3z2ilvSBQnOcZikAgLuZ47tSx004rPvLWR0pL1EEAFxgp54/EEwR0UQ6Y/MvDpMpP4eLz8RF+pg + oQwb11duZRMA0sCzD3seYe+F3KP9Sx96U1Kf3/sFFsQDoVUtS+Wo7QOHEtsHFgeiz5goKGEn2ZioYlDG + H4zETYMmVzZwdQgxG0tU36xGDYnPZ2+sEvFalbNmHvTh7QE2QKb6m/RgpdUB8jdcpaI4JbfWZmPi2LHv + KUuF0S/omWheMynwhaubco+EEFBRG94fEBNZNJHuLPMo5fZCPBd5e8YULm7b5rM1x7hPmoyi1WWFcW8+ + jLM5TFP0NQtVsvaOq3Yxq1ctmdyixeGXWYNeC2+CAG2rFbpvVc+JbuHmqz2KDsS1dQzQ9YASO9ePQ/cY + YDnNXp/dpR4djz/DiA76Y8RbIYc9SIUudWyla8RCGkJRY+MQ+MJnbngz9QtbMKUTpRl9WCI6cWXfmLeH + 0n0QTNKqrPWtQmpUm586AmMWLAHsS0Fgo+GfbXpKbKpc6/r/AGyi1LnF/ENHAot61iYNlrWKmWUOhAbz + zNMMOJpPKJ+ET+4a766p/MBCrQL9yvAlrZTzqUTyqHBpzF4DaYL4li7mheI+JfGAfmE4AlWyXqeNQ5Q9 + f6ik2WbR+JaGlYEbim+OWskdCUnz/wASv0H0x/seykAFrDq41Cy3qH0mWfJf4nEN1/azjq1h9sV2l1YC + rVf3qfURfQigYgbQGqTvKbMAbF56yzgz0lGgFwqGusEZnYUumtX0jGAhbQ/mOQoG9OGv7bCIFOXhkex0 + 6w3BLNUqUU4xVQ3+lSAB1WiznLiJBxtN34Z4qKvL74tpRq84mS8jV7a+IJguYVr7HzBiPasIfF0fVGXC + oypgx0J7S3d+7/29JntzBpr6YmsDiyXcDqqWmfeVRZuAyOG5TDIGrRB1tuMf1FSo1TPF71AoI0tWJGY7 + dNdE+5gweonxANgBnte+pRhT2utQJ0Qw5t7pmX/ruOUvHDUt0HoP5qaJ5igh6GIvNgTKCnxcHJAAopl4 + f8mug2mfklkgdKa/8jqrmsOE4+IjkwkyBKBx9zJDIgrjqwXSDQ+pcoFQt3YPXmXJwcYh2qMLHNku77EH + HFLL/B1jLezjtLEWjWOJkwXAFpvPjPMaqbY231tjSqXF0e7LFFGujot6+IQgU2W1zU2TcpQjZ4Wtj/Eu + OqFq2ux59JiBGju9YzfaEONqVCsottDl6xEUZrN5WWuIzoodoa5qZUKLrEVcy9GqdxWcheqhArkAZwRv + FvVtuuNSstPAZ9UJ7Pmjd4+ialg4tl99yv1DS/mA8r2MEXYHmyDCFu7BuHUZ5pfknO3q/qZbjW2wb5pO + 0Qmgj6L+pbHrmW5e/rLICnCfTFKgdx9Tb3zYj3i8pZtsOFv3Js0UahrqFxXNpJ5y+SKbRMXpgRrpeZWE + 7wQ0w7Q9AwG+wCPZN8SsJo3gRe2vqYMLKAY79Doe8yuxu2/jx9y4VvUVjp5imTVi3g1HdP5uFWcH6YcL + zW2Jcou0uYYAdJh9yFbrdVtO1KT3ioMQTvXAcj1uMWLBHI2RQ3LE3AcQyo2C4aH6SXIANAB8Q0WEIWdN + CalGNN7iveEAIUCnh0i5ZBaVHw3l9YmOlAWC7bdxC1CtW0UZfghIxpIcMupTaTraLPApnMQgCixE2S02 + B7H8zkdOWril0QAXUHEFobRkql7dKiVwyoDrQ3UCfRsCgzxp6SokFiCWcGeYVrAjhgTSrQcjz6fVxxwz + oyftgxM2seV8RBoXQj7qY4a3+hF31BijxcHLDwr6ktkYLjPMELwtl5d5qOwBpWXv2ISIcVTMpe7YBKoH + Q0iRVzhrDqoFVD7SyuXtF6WXiWgiGccQFLPdZPZmS7RZ/qKUIbQBXkli5Obxjwy172YYJmsBmd6V+4h3 + hYiCAvMbGwyhzFceGWsNesFyiILklwWNC9dphxoWoH3/AFCTXgvJ1v8AcRGgBDGL1C2L0oRv17QFeT1+ + sx1s/K/EBmBasjfiPpxGlRl6fLCGmlF+lgo9YmBRVU2elLEYACgtepnUHwBgCedPmGPSebH+QGCIM3ww + aGxNy0HFRV7xQVg+8WIw6wEr0fI/wwRoWtYgOuV6QDpMJUDFrz3+IbXgcvAde98VuWq1cosuq8djiFCh + ZZaeh5K9YjEj2/5x4lKj/m7bKpxBIQDAdOkuq+ntiidNe0R4q4lcSguuWYc1LMUAxemO2mDJ1GMyFbXm + m/mPlqVqfiaJi1FwJBCgrZB3jrH7Aaqj9v1qw9pU3Z1YQAczVtTke1iXNKB1UPaMCqD7uX4iSvYYOjbY + zdb8yxj8sYyVr0MQwivuifJNAfefNEMsk5bKumGYZM8r9CVkwrdI9xltoaAtR4KQPmD0gVsc7rxFBQK1 + u+PaA9l3IRhMFo1GGlEtvV6IZwJyLMCYuCfsgDCnVj7jFmXrdEewYeWYQBnllgY2JCzVp1n9qUo5Ex4Z + YtK8wVa0aIOtFFdUgCg1o7EyDeekpTd+sCm5T1e0peXtMNnxFLoUr0mqplTzvUVZFQpQ1eqBqAyUrQX3 + lyOF+2Ch74GUhjsOmtwRRBi/1JnLfus+sCX7m87HBPtlGIQaAxvpAVZA5pFxAnUX8zLHRyLfzB0eOSsp + gI6AhoXogNYAAFl3A6A9voWLlsunOmQwYIoV1dyymTAYxWeMbl8KtV4DB8RU45rPFj8xMTAckR0tM3xF + A5ev/LTUVusUx+SE3osEicEXOKtrcBOAYTk6f7CJQSrNj1PPljzFmmtv8+dQGRC7AbLwifPRmxQbM56P + yesSr3/w5mgt79Iao5rEyOYvauyg6F6X1Y1tm1Fr+6y9LIck1HeuIvJUkSnkw3Nw491H6jpD3feYgVW8 + 8QU1Bq2tMqpVypV2fELcWHRSAzDFa0HIfMF+lP2Lr6gLOAQtjTIbyWYlgiF1FavNSqKIjde1zCKCGjUo + AmEpyX6QBotr51r5YlRcArozt7uIqWnQozV6lC0zAcvqZjYgLiqN+NysZ/WBf3K7Bfwl/iFWc3RLPN1A + TfAZwYMYLcFxvXwFjVYbJU5gsJVCXTpLcuxsSkt1XWKYsJebcSyuQf0MfLBZcKX0hZGUoEBfrBO3/jrK + dB/HWUaI6Evqx+yaXeU/cWdENlhj5ZQKtXDN04ihTG+0FAEnWc+zKjZdFBHlI2t1gCdEAcAYD2lXgFrt + NWLU+fYH5nyED9yxta4G/og2zy38RaIbpofbGFMFuBr3igKHND8Q2PIb+IJUUCAny9ohGrtSgymNQcKO + mp+EfiBkLUzm8xlR95NnZ0+SLxxa+WX+6EL1GVFhf4sYbupdHvBcrc2F33j0tyyGZmfjv+JSy9UYtyrz + fWDax1gheptXB56vaCQhhlt9By+Igg7u2x7vHghgaLhu1vPcdJ0zARAu7Dz3HrOTHJbU8h0+pdBsuCpU + 3OFerFp1GMm96tkgqKgUVoMtYW2ZHCshVG63Va4lWNcEse9xy4MTT+p1H+THvKndRyHbc4INrqlamWs3 + ERA5H3PHSGmVK66mtkvDI/Q38EIoqyg6pj7g8r3hpZZdURraG0uX2YeJXzZziWUKwmW8yrQ8MX9Sgoy5 + P1BLuwOIooFLrQA693HpBSAlC0RMNwGgLVgSgQlRwyYurznUQbaQWShaUiF4lcBtzQXBivV+IgRTYE05 + AtafEXCxUQQeNMHi5u1YsfXXzHa1jGlDx31FyY3dQaLrh+hCrt5V+zp6RLzZw8sYVm2iXa+Jja67ytvw + ShjYh721+YAKNB/85c1DR0Y9230S67CDW9S63nMDKj5UQl10zfpLTfWGjYPGM4msVnZ+pQbtgdNpsrpE + 2DKtFKfU+16ZZd2ryqw6ZfaY3RV9CLUIEBYcMSJq+CK7nDxCvJKX6R+in5ieywR5+hma7hQfqZtOLMvf + HpGGu3LQ67wCijfTtOQ1cJat5gFQNpYfjxLDTc3xKlmrLK2zYOfMACHTXP779YyOA0Xx18Q0UjWKeyuL + 98QO6JhaXyNeNsWOjRVB0DiAGIbiPqq5nF9vu+GJQqWRprJ/bI6Es8PK6fphqtekOPcixWyQ46P7li6J + VXLjOt95jezFhpwW216yjLNgU8Vr0vBLIYnBh6OcYlmwOS+Wm3UEA9KxlieomAj7gkNxJVtlZvp3iw1D + JbHxHh6DHIHTfJLS+8u9zDqU8H/CO4rHgV/RMqaFnwRtWpv0nhiJAIQcPPDr9RAt3uQd9mWO40GEddpx + raneY7AVFXmpltwM25Y5BUGxe9443NL1XPowIm4ojtVQpRM2S0DGOJan4jZcZXvA2aFoXQ233jlAhA3S + dXuSpoXgisj5ZI7ESUM3nPSA2ABUGrod+IghT2IEcE3bganTJzxAlzYmYO4t4y/4KCWptX4M/mKz/tSl + 1mUhLP2INcfsY6SZoil3CP0tTmEsIV8cj549YgGRGUM2OcefqCqPb1BXe4ttg+xLsOVbwhgtnJ5Iposd + S5hD0wRpicqmXxKzeoCChpDcffH3B+4FquRrzURijSiLiXz0fq5Gco88m/8A5pAWx8qGYRxg2xd5ceIO + 7p7skP3GwHyFX6xl/NWSOMPys0b2gFX27QBotoC7fHXvEGSAg4O6/mUgFViY7D+faBcM59mfP3/xXSU8 + 4ht9HZ1gtNJs1V1dHDzqYFGbE+Oz24jMB2q8d/H5gU6YitssFVdnNTM2AGFN2YYgXnF8q7mz0lk4Fc5y + U7+5k5LajQsx6j/ZiJawsC2hbG3iJMCNYnzbqImrrhb2WYqXYaHoP3BE2w1beM6zFFLmY76dHrw+Y2Xo + ypYrVu4dkEdI2RKaYa2FPUCn5lBzRGXOX4I+BwRKOlRvsRW2rNGb9Yigh5sfxGNNGvyHMcglbAPxHLRo + 2C3EdAdyoNAoJYZsHMzii7yvSvOCP2Jb5YEsNle3+RnvAvG9kvADZmgqDixZaN3rUotRWAHvULehui4t + dUs7Rit2M9cRC7YfdDvHLBQ9hhMKS0vKgVLW0OtvYxMunzYt6Ep6xRd1efzDKbMnlf0Q0SvWBKgd4lRY + Qyt6qviEiG6xiGyIV8r/AOzJTgwrtd+F94XSydFLPRPmB5609DMwK3u+afzFGYsr8/7LrwlvE3vH/OF9 + IQAStZNz3InMJiunSVof1f8AkVB3n/l/KXNS/dEXnzFxKsSekVLQKDQwUGfeJhgSCrTfedoC2sP7cUFC + 2sD/AJ0OZcyGLNKmlcV0lNjMrB0/yO6xtL6r0OkZwKDQHMw3EZlS6TuMswOh+JijQ5Y9eCYxtaS5Vfao + F6juoP8AYcGtNtegS2VO6uem4ultilL2gCAAAAVQaIBRsPG+0YdiIO1DjziNLuGrt0rqJcWqMbolv+bI + MTK8Wup4ZRZtLe65jW0GGip1nzBOwU514Z7TdPsnAt0x9yo9Un6hWYrZIX16kdcxaoStvRPmXxtF+r/s + s2iGNIGonaD1zKQLXVnySjOtYse8UtCXeEz5iVm5hNuW7zK8VA2iX6cQVCDFkfY0whdL0iJp+Y8DJljZ + p6RV94Mg3+WyPcyBB6ov3FzFeAhyoA1iFpHBal54YYRcilRRAiIoYo6neZdYF2XWIlybuVT5lgbTxuFj + RS615riDgeAuuu3EtBbiuPdlipIqXadJVUGwwekolwE9gD8sGtwzcq4d3nzBzcpyTAdIg7p+0QVAvmpg + jNIeBhEgcFlYcRdcRAJwPOSYWW7Xo4etkwl/bH6gVz9AZcBS8uLL+YsDuGYEc/8ABiqPSmpVFuMtgQ90 + 39SXOUnzP+ypVxld4hmWt+pLlqgA3Zrcsg4RUUVwMPh+pvbZGKdb8+0f5Ts5pW784lGCaJw9Xq/UJ0XH + QoHQ5iApjzLl494AAx2JcgDb2hqK5q+L/MANSGDl9Iuou92Je8WyyjBzFApNP78xTWxyJ69pTaNYzzBz + PHpKRpD0WjTC+aStWbbz/VmAUmqVmCqc0YfSBFUWC+5+GUClpFh6/wBmI1y+myzi91/5KXJKFvPU6Ypo + sXS19yzrjoj9SnhSCUG9L7TNW28H1USQsa3rGvmFZwvqER0Bnj/yYsQOv6QPVjWEiVHuk+yBM+If8jPX + KL/cy883dz5JZ10ARGFbAISxfTOoc4OUQSkguAF7v1im8EAWlE1qCjZTbZR+Zaoqbpru0ZcDLCWllxPS + zDCuTuVZFgszl6dILF3ukx1oc9yYQuauXqH3UQL+3ZH1FlIYrlU+yAS9JKb7Nxcfe1PuomUno18zYtC7 + QYz+JUh0P1EW4C+7ibQ78wBrmXY/5sbVtYgAihHOgIraXNML3mQja3+blpGjcdaP2QBnIvnD7YtFagYz + fDvi2AiwAHkf1O4Hwf8AkVE4WO8ApQ8y5zm5dy5qXfEXtqEX0vf/ANiuVLinutF6fzLS4bA5SK+mASI0 + 5avmC2clnkgKCxHJ3hNa90ckRizyLkeSE9om2B4/B9GUA6xCXJasEYBCMFD1IGw3Bt/HB3mVCi01Q6bZ + ehpLWP2iRlOX6itOPYhykODavSuY4EFLpyDpe0A60nPeWXN4M+kV0IFHiMEzVaHDj/ZwZIxkDNe0vgmS + ikvo3sfzHaOxYF91e8c9TxKRhSyqzcKK1kebzcQWcZSNw45DFPFQf2FgyPSWRdMmP65q4NlKbAj6q2AV + TmqFb9ZklXp+0Sr3qoi8GoFG6rAKmdQ2UXQWMuzr8xTUMLVHgWOIaVOzE+SJFOcF+GPSz81+yHDrDbD5 + JfAABm2r2NektgggEp8ShEC0sC7bS6liJHD/ACaJjl9X+BRCFxCId5MF/MRFFLpMaWnUVnZQBRk9jBbE + 0Gtr0Dn1bQVsO4gcO7npiABgg5n2cwkcmLJc7c+pGPPindNmFXtECrmlgnSln1CAJFjxvxcD0jKywVvX + xFwz5Eb9jrMnUlT34nXyGfM5eZlMtwDm4rusENEFUv3gyGVBotINao6y1iG6C1o1CPILN93MsDFu6X/h + C44LtFVT14aiRuLhzU47m5zlWHqjKVlQuXLlS6xBcMyvGReIEtr/AIsTZbIdue0ITnMbDp6QwIMrRHcq + UfMKDtPCViD7D1fqUbIFBdfE4lUSsvXxNIBVc9XiKEwLpUo9IoCgKckRklynCVTGc3jiY6RQsJd3F2Db + bk6eTT6dYnAKOI6rY+bk7t+fHHMvolHIiPGeOlGelR8ABBVAdjj7eYogujN6IJyW9dS+o5gcHdfxC2xe + mvjt/dSJFAQL67PDe+qOmNK/VBp89e5KDcYOe0Fzw8RLVOOTr4iojXYLRNYiGLYWCbJS2V5ddK9opoAh + muFOKftNMvZwKasra+TqYjsKAbA2uFwnbe4gSOgyPXH9UVh6Egum3pAQKAyWW/M0SG7q+5FAu9pct7kt + WB7L7k2GflxaJtCvADf2SyzdCzpwQZVwIquRjW0Y7RCfAlWNf1S2WUxArjmDmrVhHhma0UXhr8y4Q3qI + /MbNYRsg3umLgA4BRGPuOhFUAXpFHt+IxViU3tf95gzMQnJ845z6Q96Xo36Bj3hA5rVuRWPV8TGFbbnn + Dn2Ym/DqHenP3MJX6yDmzcXoUiNMPhv1IYvXSHnfOudS0XWD6wvANXBuD5hqzpHaFVUTbI1iDGNpfUYh + sZN3BSBSO8fn8TOfWa0U/uL0UJZrFwRWri91H2y5RbRnmUXqu+EgEdB95CsrVJXiDV30l3O3/GjiWd2n + RYYVYHSUdNuhEXOoJ5gciJfaBrSlnGiKxUIpvHjnxACy7+Of0ivEClsi8eT8wJmrzcru7CaZeQWJlpnv + LbpB6mpShDqZlios5SepE30AvvwYFfHtmnz30+kpmFv3HFQv9ozTk7XxL7mjAMrx4O8sTxcHQfnzHrBX + R5lJChtWvWLph3Wl/XmZXILjO8/3/hYr/wA/v70g7FxZ3v8Ar+e+AEFLgbb2f3nli4vNBcEBWq6sPljn + tEmcCuDS7zuJ58AFQrB3yVvmIwWzelPN8tEyIqNt2eIWjLaixG0dwtDnJ0gJrUs1ujeHEO/KJP0RLBcp + Qj4T6mVG8On2QKomw0+LCN0Y938y288L8zFAdQU9ICil4sIgMo+uvglDMiPtn7iVFbQN5+Zhb0jgGsxG + ODlfj8xkFUAXpW4McMIuPQUFoL75aAEFxehg5QSqru34wREoWoqimH0C/WDEUDJXCPe3wR7ueC6DsdA4 + CXdS7ACzh9esv8D0HAZfmMXONmTozJFp0C8AzAii4QRrrTkzFYU1FGnjO946ZhkXPjaAV49oFLmzYOWA + 5fAB/Mo2HrZVi13X6h87A/EyKHWyr4iZREdUkynga+D/AGK7a2BXYgBApQGuS4LFMAF6MotimmKHZ3jH + +Mu1Wh+pTfKnpevSCcoKdBuAAWAbRet943Urqv2zST4B9sws90BK7O9QX7E239RqphxK5a/MpK3ofucJ + pwvxFQjHN8ehBqFU5jrIMld0W3g6wa6Xl9sTegrBHYkFVdorDyxZ6Q4ylkpPq2lnK9PWER4UW/uW3bdq + 3zO7zyiuZOeTpGxsevPPkMbyEFmg+L4uWvUKuD9xcoOcwysvANHnvLoXZgZX+6w4UBoM/wDrKBtzis/j + J/VkcXVdcfX9rtNcXXU/uvz3KxB1ozfTzv8ArxrXVuVlVjnoxIPD5l9RTOM6iUBlooroth7srRjadX1o + x8RuaMyUKDszx3lkQLk4PTUSRQIHDMsRtyIt8xJJpmsvxiZ+60Av2mYsHTX6jrunhgMlXrVy2hRnDo3L + mgTCMnpojeNajN2dIlgDuis1uWXtk9aPqGYKMFNpF7EoYS4U0xDt1E8H+x1jYx9MTLMw9YwXbVnusV7B + toBvN/iJlYpUYXRXFFZjShd3dRhxr7lAKQU1YcY061E8SKUAXlrbKhSVm2173zWoAaoKpot4vb8QTQ2w + bvNZ5c9YEigJKu2sy4S1mCsXxjy/EslyFLtz/k5HfiUGfdglvWW9fczLhb9ZdvpLD+Ie6DSAae5BHlFL + 2gsoyXy2HHmUao5V71j5IiLCOYkDJWyrcV0t+oUrRagBywXKBe9ZtUCg3VsVWUC8XiCA7daqVXE9Pia2 + IdZfWNatMx3m6UYLZ2B38QiWmsbU07YKhpt6PiBQxFIevKtZI1ouMrdZlRJdYDguBUtE34lpbY7Ou0J6 + KWVLkWq4uVWLMlXNwU8Z/MRv6vt/4SU+RcdT9xLOjCsfoia4reMEzILdzMAW0cH7e0XXDZt/hX9ugGQt + dDH9j3O2bLx/f366RAZcc9/78+KBe89WP633esfXX3VnpuIE6V+IL7DcoigHI1iGzsacwaKCyF9H5mFM + YJZnpvWZtiAtVu+nXwzJd/rUFAJpStet8wQ6HLYh78QYJJsx9SwJa7NM4ier+ZgBDssJyPIkC0uGo67D + z6RX7xxtivA5/MXNiIepiWBlt01d3pIhQ86P5lkNPh9GJOM6h+Il1m7ifcqMj3lh0F9VfolzHFvywVAq + VzCbIgrb8ZcWm7UEodTjtjrFsdtelNMAN2yYqNG3FRrLbTa9HX0mBEBeeDVvWAVjel25b/rc8QduukNd + aemotEGp46S/ncKmSbVXnvCxQC1XbSHzb6RlK9TcANHvLCaOb/uCv7f7hMhev9zApvVDZueblHWdQfxO + K19Qwal8lfphSoFII0meYVCUsKW02t6IqkhQOskZocKmmMv4ZXG4NrHRv8RAZK0Aj7x09nlbDHPaV2AB + dU1+ZdQY4WnxctWqzWcQEUcKMEbVRsftgN3X3RfzLN6vWfiJBKbF/BByJulEO+2WUhVqnvuWxQcUzXp3 + go8uk4LJbyVLTXuJcA1k3UoKnFguB5+pWgHWPTq6GLnBhOnEduP+WM7/AJZmdW6XWWf+dEv0xSCzDN9C + +JaLhM5ia6HCn9CZQF7Uf391mQHJ21/fjqZGusfd/f3iV3WTuf7X9eMAYylidexErR5MZdnPEpAVuMjK + AdJbuta57RThfFpQOgUAaz5gTVvoub77l2+dH4nqCUH1PkC/Qz0c1/yMyXBqfNQy0SB4Ut8piWxDxKVg + mdDp4Fiq3lRBm9RLZsG1Y37SwygoDmJU6qr/ABACqMVRK9wg1+OJf3CaL1jcHwoP3HhdMrg/MdxnoUAF + BHcu6SdmYhuWmC9QSeDO2qJR0BVbS2tbq8ekym4xoOtu/S4A8eUThrlHrFMgoE0N68RFak3YVs9/qJgV + qwqi91FAUU2bvmC1FssS8celTecQFVl20ykTwpHBh74zAjZs60Xjvn1lFQ+qPtNh7Vn0M3D5yI/qJJVq + V2xfV6zjl6ofaouFB5D3g7CuFAfNsEqPC7iSooepKHDBRRU7nzLrRbMNczHX4gHYimzEylb71F9pNVHj + OPDMnCX2FarEb17oEfUGDzX7o4F7NpfuLBPUIikHQgI++YpsNy6xCeuWiF4M+sAWT1QK55/CMfFNn1lj + jnGKuLYlnKG/75j2VjNtYgwSirAPn9x8euA1T07nSo7YcXmpVYl0v3FTeA37xZdh3ks6PzT8w1IgjZxF + NSmzV3TqA8KV785fqBb9q/EEOK0LMavMxCoE23rcz55tK9xT8xsFAFtDzuI4b4YnKXiXcyPliwDT+Qlm + NXYaxZyTTcdWfTAb52R+GOxVch/JK23sV9DKZueLyvUIhgS3DwRldI6ibPx/sQl409Ym4LnO+vB6wkrm + HB9n5cRKHWWWdFS7pi5tXNC3enj1gkRdgEeHPrKyXOqEXkidGouVR43pcbDRTbNe4xtjGbe1eZY29S/a + JHEo7ljTXiVGizRSqDXtVxqkaELk7uG7dM1Aihox+IEWjwSr9H9wPEOgFG3OH3ikCTKob21pZaxi2iqb + 8QSyMzXDlLNAdYC8YAFoMe1xS9k01l5rsZh1fb64D2M+kHNdEFzxjyRNajtHyyzsT2PgIBX1C1yHvA/a + lgjW51cEmfbLAqdV/UYhgd36lnHOqqUypUsDInFeYCyymZVkXmm5eAtDJvETVZMahNtUf7Eb9KRnuQM7 + ha5NX+iKwB5KmAW+SBp9Eiml65IwhoBHFrq/G45Ko1yzj+8zKIN4x/f5CxdXVq1/Y9iU9P0gEoCOgMuW + NhxKXUcLnTrvex8QbLByCj159Z0YGMWfVghccB+NkooZo4mc+pr1xPeEN5WfwWK4svvCj8v+yjRPl+5f + r38uTI6bvkimTOH3AKDGZXUlXXzXDLabWZTf/CC9qpY+hoPuf5P4AIkq6MMEclXDFviBi0boZb/GjX7l + Qov6o1lS+8JtZ4Y4jHCvVRKYYquh+1KPWIu0FFj4azfeojZDjSrzcIWMuhR4/nMwgAVWglX2mWynclLQ + nlgeuDhicxEAd2XcduqlIRtjfaoWorXvDgzq+vZinuAQVpAtou+xn2jTirdT4cw9iqHHnofELXIyIA+R + 9oVUihrD6LN8tTL6OLvwshqs43Slrx+ollreLPNkqNMpVA8XxAIlsCl9d5oDcMxtUi8uivH3KdlVmMrr + tLMo+iPJVFTBTeMVfEobysPCnVIsecgL9SvUhtFPqy84IJQZNuJqEIxjMveQ3VgL7ajh9t4Hw6z7QEgG + 9cvWrxLwVF0W/qAPGF9IIHdm63majB2amALHXULPTpWpa6EspN94RgJGgMLMZviZ8b1QFy6JKOEQBLrq + IyUwKvFLUIWTjwhftL7DY7P8nO4tZTYXXrURhQgYzCqSg81cNyZqJzmeEucTDJll2hx2g3j6Tvp9YE6H + pHlFXtu4IFGDuZ+WWC0H5bgXiDvMqubMzW9DU2taeso4IM5017zdmMPzBS+YvZO4VSWd4ET34JXjhIq7 + gr+JgRd/bS4ENX5lBxBq6iVGB1H458Oow0zjBXpcxgc2IPyS7bd30YrhQtourMMdpBmaxVX2fMHEgy0c + vnpDJAXC1h543CCouwWryZ37xQJFbbVQ1wZ8w4GnNFr4gdsTf8LMVYu+jiGZqW5pHqXKWmjjsyxVKUzj + Z0mBTYdEh5L25prvEBc6iiPkilKcWV92Fjpyg0+Ye6oaC6WPu7faiXb5qBmGFa1Do9fWUp0IG3alnvUP + yKwga6mI+ZSAN2Bl6aPjMsUo+woa+CMPRLW7TfeVgIbtcLUIY0pQqXw4jsuJUK5rs/mIer1uahVXVYLZ + JVlsUq8usiUHKY0qIqW01VX08ygcIWi7ePSJYSFrm+SAZBReSAFhdFvMsi4NZ1ZFluri4xyh0pZl1bsq + BJQdV9MTExCgqpXqwKRJnOocbD1f8S91Dov/AOQZS3q12cQOx54iArBZxOyQnTLMttqMXqBViGjcobWC + Np6yhVDs5WVCoB1xiXtadEm4pcB+k2a+H2nUW6vwReBeh1X9mCtKMbukf9mXaL4/4LvHDmDL32Zdal1y + y+ujcoWckGwOB9wXb0ZodH8QZzE+v3HV9IFRW+mKmcPx/wCzuN8UaRMtnMs8zGVyRQt0yyEpnMb0mE9Z + TjOaifNk22XbX5FS+IWpYUau1tOmYZZq9NY9yBKxsxTcOVWkYo5YNQB6BDApUeKuzvqZ6oKvKUfLABYU + KySjwGg091kpKUyo+8Y+Jh120A36Z+JW3zlZ7NRWWZvkb+ZzLvNR+FjQ8+Ztmrd0QXgV0C3LduGDC/WK + Wqcv8oLWHncNMJX/ACz0baJUtYWI4TGMkLcuIQr8FxlkvkB35xAVhQxSZa8rG1m7b7Y5QNv+u0p2uIUr + bw5kjpVxJNaw8oqBWmZ1WBtQYVuJmJBS3dlrXEaAMd4oIEVgdo4XuLAqKGsRTIDwgpGkwc5g0T7SsE20 + pq7g0tUoa8itnaPsIZVCqc9H/INKAckH0u5YSaxm/fEurrTqCpobV5B/MQdNfigRi0TbdzW+M/mYFM8A + JvtfVn1HzWZVfzL9juS5Quj4lSomqFX3HaJm2/aZ+j9QpusJMK5zvrB4cXLvbLDWfMdkpNN/Uy8EQCOx + 9xsRvVxS5gfR58TBS140ZisdiKzrZuYh1X2T/wBeAlpZZ4jJidZS6ystA+kCqu96V5G5alHBvcYtPbiX + 5tJUUNltIpLbCjGJbq3qV7OIhSKtt7h+opCw3SfiYIAW2aeSzBBYRVAYAMEAl+AFr9ECqNy406gVvXM5 + 1jcF2FOpAVoODfDiFKE2DdeSoR643Hs/uXeQAJZdFlkoFvFdCW7oCDu4I4u7Had5gtx+o/5SbJSb/wCb + QCOwq44YbnIlPe0iuOEAtHdg9dk0B+IDl8fqDul7kc1QaQtCAA4zP1LcT/rpMym/rpAjJkxg34htMAtU + diKidj0gsUDKupYWiu4fbNg3kX8TlLxb9EI7Pl949Znr+AY65Vcv8VLak3kL+1lCeqoH1KVk5tsUTVxD + NWt+8aq7mhFILfVXuJRgyLntFaO137wUbuVeblU3MNI+kwRMMS51lZcFD7P+y6l0PqfDPqVME3Lesoaz + LM1F8y7tLMwAtyxvo8bjB036x6maldWBrJSnW7uUCtWlVxeM+P8AkC7yh88/8FR9SUHq/qhEHSZuAOyZ + xdRcQB3URu0o719S7y86iN9Utz4YPuI028iUxMFptS/dn2hFKwAlNRliV6tKt+xMm5Z5Tbt5R/MsA1Qv + nRKmzjUHAV3jlrTqTs8Swuio+jQxVzmBeJwHvR5B18S7V6s8FhMJq2CvTCUytrkHL6QMl/rkcS3oRtD6 + czDo5u8lXxfrKOudSqSIpcV9cF9xPsiJ0H3StOR3gCO7NwxZk/4mZ04IogxbxHLt8YlVu59w3R1a9iIg + 8kPeDQuEpvvGDN088wtribbBxOgpOIFUqu8vqmk67iK3kdyrb6Sq3icDF/MzTmqfMRptzQEsX5X6UrVw + s+hHaOP2f9VUGLLjHEYU5/OWmOjBXII+v+Du+kA6l1MsVOofDDSACF2miKzRJeW42Dg2+q8fMdZPbZHa + 6PzEpiC0aqGc8XES7JVu1e+4YaD3J3uuGrrkh993BbLsmHxuPDuRBZz+EqxrNS1DjmVwcar5iHaJuBNK + 7Ep5KOszKx7kr2eBSYbO1W+4TGHOSaCCsQIYgWgMdcQAzBvpSZ0sNOi5T5gxJp+ZYVydYhtf+eGXGDmA + cZeo0B9y4C3LlGbq/mZlOiKp0JdmeE9dsp6F7QXNa7SxNr7QlUraFPxGDMu82ARnYLlxTrC2SiR2qFl5 + +xCUOYlo3KU0lcXBpiASyytEuBptOsIUqDXk+4bTKUOnWepCA3vXhIAoXYe+oW0jQyltzKAEy7JV7gul + vHeWNXx0iqndOb/4t6rI6Wgkao+k5esbu4fqZI0ke5Osup3Shz8y4y7Ipj5n2TuQ2ujcKKwKwXjiCf3x + fb6blOm8GV79FH8zBCfKXR55EOKVLaxQ0/ZG0IgGeG8R1qaMDoOtSzAEDZVutQmBKdaJr0Kc1TxxTjNJ + aCqqUFUovDJbrkVeE4FwILMRFqhrtTbGHE0ZbtlXls8NwWoOErf4lxA29U7+zFYtZlC4uN3YPhn2zPwM + sKc5HPo1L3LJcKAxW/WKh3FYdSDz0lml5Pi/8hNvZl2LFB4P/IMuoP8Ay/8AjiUm4SZYAvy/iA9xX4hF + 3rBVvNxEDOYtuPU5ljbs54vp6EI6YUNVy+kQyDeMBvDkgfNZV1fDMJBQOq6QwboJmmj1YWc7eILATQHH + aKv4sxb6jLFZFBXBK0vgvMAIG+8d106ypLeMwWC3WPEFrt+oxC7DXk3EMZt0+koGtOPemLFS1pc11mNp + LuZazL62S3Jb+5YwNS1o+4qyVQ/Eommbv92yjdn1L/Wi1RV62zeH7f4iMCOy1fgitFeifzLt2c0/3KeV + 2/1At23gfuXbT0fudYnxmTTLpTYVfGovIK/OcxJoAZd8b3EydcKD4wRbit2LX3PgWDBrs9Jb0ejFQ37z + K9JoUN9tZg6rQaQ04z8RDQBaoB081BswFyDfsdntK8czSYB2O66myNMqSxZXdeCrMap68tYSwzhzRtxX + rVd0ZuhKHW1yb5VTW14pgHCGFNAq6sdGeNnArEDFtxNILinInRhVYBpKnHZ+z2lli3kQ/Ercni8fYSg3 + +l+GIRq98wOsvcuIag5q373NS0CL5lh4T9Cj7hIaCsyyXkfLcrf/AAYOAMuXMOmfMtnaXgwfUtHWj1Yw + ohDBDKrogiAe9Zt9PxBxOg3l8w0gqqYocW78zOW2+FHS/wC2QnqgKF6DH93hqqgOexzMN6PRwTIGq2HJ + 194htUhzisxAxppHWYf0ZR3K+YhZo6Qsi1jMG3VEa241q5mVwNJXB9EQbCfLSGy4Rh9YwpG+v+AF08Rd + IG4UwZp95hjhjpwYFfqLjY9VXxuHUKoi7piIFhB1ohqiwALXS2YEAaAD6lEyAeLgPNdcTBY3KshBuJQt + E4SV2g2TBq2n2imV7sscpUKlBhplK4z+A/2PG/MwW7eBmSfXy+tMARaX97gWT1C/mD4p4F/EClIVCYhM + 4DQbP4694FFgAnQePLz0IF0DxWAKw+K/kgcLAKCjTY2ZMZxmtBsAWQSiuTTZpeBh1hsj2gJQBVoTQL4B + 0qOAC7um7dpk9xO6MJGrpOaVqzBi3J5XhGCkGQYUgODdJeKWrwKxAOXuguHewbNo0nJzCWmeaN8ZiSiu + 2bK8Nh5gQwXbBV+KfZlqtDktDxuUvrDa95eesKYXx5/2PRb1lgXdGcbnYhY65rMDSIvyAfK39ErE1S8D + +4FQ4BxNnMq4kO0t5/5R2S6t6EVEpS/Kr+ZQbp9QLgqcUazrEY3Ym429vpCDgcU+76zCXZSxt9MXFrBZ + Q9OstK5AC2v7YNGz0cOXo9DvFSFJpC8aDEq4I6XWby/ED82Sq4KeHtFVh2vHdlGp2JRrEHrTtB37RXKx + e0N3WuILXYPondLZ7f7iuON0GUEV4xBuX/XLZvOJfXMt6wTACodW4AbV9idNzqnzLOfdE67gpZaFvT8H + USqqqBaFvEpilGuh8RLKVd3fSAyUhx36eM78wUCyms1rxcA29Nd73AAsBGy1ZYsvHfcqDtA3be4A5iz4 + PxPp/UDKPNTYfCVFsYs4qW1g8ZqM91TceKuLjEo42LfDGXv2mHOMB/ua3BCoWo4ttvh6fiEWyiAtDOHY + bwNguBGrLYADlwG9h5bDiwYVl6kLLAmVu20y4XqDJvDpRLQ6UrvgtEMuIYnSNascLWuqk4RjBkyrxzyo + nqidxFUuS4wqhR1cmtqaRgu9yF2jdNHIYXGQHAqF0abtUQ4sHwE5OZpijNdfie8TiiUKOwT+GUxN0hp4 + uVGAHLuOum7jHhZlpf41GqMvWn2QZvHSoQDlonSv/YqZXVa6Qxe/bD/YiNA0p6Vqi+jKDe9Yv0w+pDKE + vFT0s/Us085/FZ+IoUoNiU+zKHUoHEq5UFAMoHq1+YIxofQqXs7meeZTYSv0ty+hKPg7ivLvK79YoVgo + 4lmpZXN7mWIUMBQjxy1Z9MtxkurggC2jgi+EdGpSoSVSyq3XeYA7fpg5sq3l3YpTvF4+5htqZbmWHBEw + C3iASqDeIOFwn1LEwN8l/EWJaMgYl4TfzOz7GX2aHoxGzOsovltYqBWEdkhSVrzUc5SdCoWRpqzewZbe + OYjmLLbxaciyeFdxSG7NtBwA8XVQ6aJoLY0ex9y2Fdqvhp7ZZtgC6qAYM/2YnOoFF+JXihod+JsKdAB7 + rEY7Ko+AjJz+gftLvTHwKO3cmUyQS7bdwKgBdrcxqLlWE1baXfXcAgM8FX5JmR+VA9y5l15Qn4nKDxRC + QaNVbxCDkdOCI3QKDniMEVdNRyKcB5x1oyAIdgWwI4ZzlMcUqbBkopOVYFj8HG8U0vegLUoWJYjTdcBS + Z0XsWXJWAKK7V3kX3RL6EqFBqqwKHiluRrKhsMCzuAHDgLmzS9CkejZLQQA02K5N1SdcdwMUItq1atKc + stpzavUYByRC7BYd+G8Gi6MYIBsG7wjyU5s5HUSkWthOickJaTzN+vUQyzpdNC4K16xRyX0mdROoj6g7 + bs4bj1gl2vVnuRp8V1neaDaucvaKgbKQ+wb92WzwAs3nCfMtt8zVD6qPeOIYbhr4MeksrlV8g5xjnkzF + Quyi3BZ1o1LFJiLQTyL87mW6PhX4bjqj8Ap+yNKS3UPjMCzE4CPzBfyFxnA3+Jdq9WP92DV/mAq0peLc + H3MsCDjMXw41KqvVPyRx29bfuZMrepDMDUrb251qINBgm1gfHMVHjpAt2f3FJYB5ujrfMIhcivDhFw0J + YXxTBJqtcXouB6tfVT+LS66t5/dNYMOqxChQ7bX8wxAjqMpgnWjUooJGS2IZZb98RUuLu9WBfbHEMbQA + J1DJAqqKMNLDiD+m5XYP2aJW6L6qlO6+bblJKHYEWJ5pqI0BTt3hICqD/O0yokXTywRdazn9SFACijcP + llBFDAT7GCIYdiPoEcbdMqn5gubndv7gND2/5VMu50FTJEBgsPKr6YM7uD8Ii3LtdAL8QDCp0KHvFFbH + Qqohqr1zeb9JVll+2W5F9oFSLALi1119OvxGnlKsRbOCuqarJyGB2nAVo1bfBKxwJylLYC3Q0452N98L + 0JUeIVQLZjDi1a0irwjAXSiQwSqHuDDqqLwLwhYSwWxq15wne2zwMSrAqikUVcZFRrIltappdyht4Jow + 2XksnDiPe0cKBQ5rGDO0AdoWsVBTbhUzWS88bw42VIaqSqkoVgq0StZa4UaKCyhovbLERiCxrsL+X0jT + DtXfWViX130lX+I8Zkiyxlrr3lhul8r+YF7xP/jLbA9ZajJtQKd659JnKhttJ6MRG38I2gkFCs1x7x0U + AduyaV9CVBvNX3q5xGnmCwSrB29GLdVCkynT/IiqFPeOlm3T4x+Iqe6DGwftgCXfnn/lSquKmmQ4TrA2 + 6DgWVC9HgYshA6ArtVs9qqCIrUeBgJd15l8/ISV79hqOWOjp17xbBl4vMe8XYMAodDiuDtAo2HVd31vU + 2RX1lilLM0WAwJXeYsnRwLB5AjRq4rWj2v8AyDusOwFiOEXYWW2wPD7nMV9UIswCej91+5RXy0YyS6ub + 1DTEVHmv9TZnmKABUp1F/Usg4GkW4Kxx8zUp41AiXY8Zittbcyk0f94lyzsfRf5NXKQY+op/zJ6o+ycg + Q6hcVrDK1cTYf1yowLPbpK0fZS69oCrUIbdKmYZcaNYN7xjkdaA1DXgC756lvBVo6xaiHhZSypFru8o1 + 5a2FsW20URQi4AO3CNPAcRWnSG8aRdaovnFLsGLYF26mxrXLdeVN0yWAYYlNpbGn2p8iKG0NNDRQOXIG + 92BextuMkE0KltUvW/l01pi3XSWxdPJxbwa4N2QxCKrUN8GMDypHIoRCrAz7uWIFYD4mzSmC9HTz1ibE + AZ7Sv65VX2ga7wUrlbIoxjQULY00WgqAdYgBMr7RhvxQpH8TTINB9nPzOCbCl/Dn5iYDHCK/BALWRkIj + 6lS9x8ql9GYNCmkqvB0+ZTVNGZUOKT3lAOFbQvracTNpGlVh9XFBz3WcrFvgFTu5fuEvr/y63LmT7SxR + LszcwYADFHQmkBdNo7mUwBSKN8HqweUa0lNhjzGgz6syCX2Jz5etQW/egeb5YLJi7SiUp1iJV1wZxiIk + LjRWpekGz3xOd1JTflZyB8H4meW+sKxvX2gkAto5yPqbbG3KrKxAu9SmwA5W1rrCo0vDXFyiMJb4B/Eu + 4lHp+GvzLMASIpWGUc16f81f/L/5cGXKD0D3EGZbChGu4kCkd3FXYSLexYVWeJdUOH5mv+XGXJM5I3bA + 6fqLgHArVpxTScJk7mImLQFoBPDhxnVILqltZYZA2VVt8BnwD1ObLICboRKsy5OTd+QySYpKLAuRd3zZ + ZwZJiDUTlgA5vWaN5povVszNtZdsOTsyXrdi1okZ6tCWuqxgw9HDa04UwClCgRRq9cFX4LxaqzYiXXeL + tssyZzhsM4A0s8DK1fm846tvCtXKmoKqWbvO2FdYvpHNbB+ax/xXho+GfKFKbLLPZM+y/qWAguDqHGdk + qFhy3rVv7lqUTRH2cy5sp6MrpKXeI0VV7zGFBOMNcTLWs7SD0hgBuE6PPMBgnKXV7p/cWiACtB0swS3X + S0Zouqc76RFnkUsr4jZpp9HP1BM16eOJcw6l1L3/AMpRrpFYzcyx3iNWw++pZRRtRXj5+pZGocxM4GIE + w4cQWy/BKtZltdrg9G4QNFFk3RAOBrFQOQz3mWaGveoLbrDVdQmveAzDtQeGCIrIrB9SpVvvFSi3TMM8 + E3694BThb7WQ5hm1Yr6kwWpcr7nDDUP+Vb0lJuV/xQ9+1iCK1zEWA8r1E/HzMvY8x0CtkVpyM+ksWtJ9 + /wDRYpqXrIYvPY4HHqSwEGLZNJ0TqOHmAFyN2Ebrq8jbwUxAqtKAukqrwFIb1SF7K4Cq6DdoVZstA3uw + p0UUglkqgGQbcN3pvHMFoJBBgDDZqpYonCZJQ9INms3tuqrOWqtzV3FNiicsJRnY1jdiglKEVBwVUKwF + DvprLRgUQFWWUqwUx2Jh4hZjrAKDCu2rozNbha81jmUGCUsYtfRKxYot7QlmLY7zHcopLE0jTfmYRTX+ + o+ZoHhTRvvT+5QDa4H56fedPRofSUuBRC990VYM1BoLvf4joZEHBX57zEtUfcyibqHal0YxFG5V+0C/E + fFzPYe06WIs1nzEBsupcuXu+kohxvB1WUDuX9ow10BelGfuAMmzqo1Wc55IIh0WWAF4dpQ4lmj5mOpYu + 9pRbNldZnoy8RRzcDyaj6MqFbkMj2nARAICL3aQz1U5EP1LLt5i6zx1Y6xTDzL02W4AbDIkobk+kXU/g + S/8AEq1l/wDdV/8AFruXqXUHkBr0nAXzgRWplE3VUfhi2x4OpMn1FcFih5D/AD/tDLdYg1FHr2g21KEa + vv5h4gYEwdq4p/cT5tzdoplwbK3VvQTJaIM2Lw2kxq3WqVq7C4oWG6lqKS8HBV6pLXTgjlbQ7IheeLNZ + UPUaVpyrATlSwvo8ZEyWLBNZpQUA2FGSunC2gUjMBQ1RVekAy0fKxKk2TMfR3LS2suuJ8Si919bKM9oH + Qq5VJ51DSrn6oqmSWGoEOazfV5uCqFNMyRaqVueYiZ54l9j2j4kuFl7kLiXStZWWZyEdRQlC4EviE1cv + 7jrntPuAu+p9wAr1T6zjDUUKpo6Gg9s+v/HTDTNxB3mXcMsUGjvKLVsc1hldLaHFq1OXa+FEbbunxivq + VzQDatEQ36n7ogNj5P7lQWXlcHTUbEkMBbeQ/NgrUDlB+5gnOrL2nPt0T5bgmWNZgPglhtkL3TcF9sn0 + /wAiCLgpoFe8Y3SU4f8ASXWlq02P5lOV15P3MLszzklraPUPzD2fRf3Mi7+gH6nX2eBYgDJSbKyS0dGH + rZL+F/a1+Zf/AC3iX1f/AIWtT5ly4qNtiMzfd2ekDkxD0b/H/F6xKwXOb952Ah8pa/EqVOU5vUUPLLX2 + IFQ4WgHywTe2Epa49IpQq9TAjcixq/HD3lIBYRlfREpRlbaOM7Vh4tmcigqFReTnOim88UUxWQCAZFcY + MjiwM8pzA0GjQNUp5DFLkqhbUSKhGgtdr68+XMtkZum69oqqU6HJ1gzrHace8J0dYmzsfyxnvLN9ZrNZ + +0/pdSa/4zMnSsMcZ7wcRMcTMKvMNIlTn/pHy/3Nv9birQ3+I7b2YDSEECjhV7Tj/hz/AM6y6/4fprJp + HYwq3wzAu195kPV+83xowlB/xnH/AC7/AODrv9EaciXgy1WOqgdLW0nSNOrl/wCS1rtnRY3OM7COUMoo + 6sXdH6YZ+BfaOf8ApOvg/wC3uEt/x/MVXoD2gU+X3P8An0s8XKYoseXqxpSDZnL28EuAz+KXSe+5xTm5 + fVIB6blQ30iRX/UKo8wTJ0Edjkj1lLB6XV/JmDno512V99+ecx4UNUZRyDVGo7mrLogY7BP4+8X0vzP/ + 2gAMAwEAAgADAAAAEJoAnHdMrvNNNMGE6MIPtMXLWxInfJBitBOvuyI24+7/AK++CYoyuPTqY44jba1n + cL7zi775MuuI6yZV1/0U0ZjAByQng0/TklLnhWbBYCJYrwRsrFRwXf6ANIffz68HfgGVWO5kI2FnTRh9 + v59RwDoBiI6QhxnAQJYP1PCgOrOe6emOL94bfQENQXhdabir4xTQi7JrzZRMTo6jEExE6aZQw56EjdBi + GQp0nKG2rRIhgw4x1BY6krCD4xq/iJGjQZoTBCKoDgw8+O5UYMHOVQZJtyLIclgrr05X89Rbfhww7pgY + JwjwKOaQhQZhMfrzbQ4IEldjACAzfBENp0DWjiCTHTKLhxRxFdQJTiw1RkY34MKwUp1VQjJ1ZLzTMJ6A + mxzQ7YxjprhHvzlz7sLijVNYDYRySg1EH1C5opQDDTwKIqPBjpaDkxkDF7AKBAZKYwTRIhA4Jxrkvktl + bIwGpBADa2Sx/KbhZ/fIBCwlRAYprJAbvCjAD6x/jSwb4sZyUzxH2FWMzy6lBBz9pyRwacSIjAJCzJZ4 + r7AKqx9VDBRKahoK6yzRjAPrTTTLbcgSgDpGQJQQn6iIYbY5aiBQzFy2jqYn8nJiTDRnz5YwBiBrLQYa + ooQb13qWAxZA5KRqo5Ebm+J1zp54Y4bg/YShAxRUOQShBissirxvkarUmny4Rmbycd1Jo41TQkHihzI6 + KmI67kGlH7RRe9ApQQSD8Px2o5T5KA1xhs6URQIPijXZa4QlVzQGnLcGYNa0vLML+7qvN0BYGXqjHH+0 + JD1QrjN8fbEKoE9UV4iQM2sFhkbKgTmAcZ6r9FISaMrLQiKC5bDWUQgr2DQwPyY/CQ/hWqTChCMx/BiQ + BGzSG1g1qT5yD/ZTh9Nk/hu7I7aaT+fSzkxURiDR0KrIp75ddvwaJiLZIASaiHBw7ramNLR76SXgrpRy + 5y4Lo6us3JPV1RjXbi6yaLzAIDc8xHf8ajPhggghKKtqZJiqxwzjQZzQ0vSq66DCsZ4Ua4Zr2+Gc0Gl/ + ezriAYKcNO7CLRgphAayBwxiaiB5xju0gH/q/wCej+e48J79NtSyQk8AgUgeQMK0h+cOIArxW7wOYTtK + 3Jv+oWm3c0fr7/JUpnvAsjGGPI6Yc8cWKvg+CdKvglRGoyfRjCaU8ypk0ap15YP0IV5/UgFCiw4cI2ET + +kUX6Wq+6MgCHSnIqmY2vRgFalohuKdpZMJIaSwGYaR/tEg9JZu+mmcAuqgwjqGuTA6QNNZty2hptRIM + MY2KmQEw1lpRfD//AGMlmrMjsPAEj51aH83RyW/QPFIq/XceecUtkr7mHJMBEep6DmOiBXvjNEtCsXJs + BKWyivKGCJozyOthDfOeQIeNCCIHROPsDBzeGUSBAdpfJMuN4mppHMBosabfOHSQDDFbSFIDCCFAJHBJ + fk9n/XHf/8QAHxEBAQACAwEBAQEBAAAAAAAAAQAQESAxQSFRYTBx/9oACAEDAQE/EMLBncl8QZDwsE1A + dsB7oPRPyZxkvUZzziGchneGrVK/LgWuAPFqD8IZOAFu3Bm436nENeLU1BbgwCN1h/IIIIk1Ak4Fu3bm + 8CD8XuDBfEMS3DjCcD0T3M39WgEPadxgHlb6YIkFr4iuQHRBgezq11cMPSYEx4wjyxjGuI4F7RT0Joei + ZZ7KZD10mIr+JwnyvJj/ACeAV1dKKLH9JPYmsi4AqfCDDXE/UOG8LuQ+mCbWF6coC/ODB1GcwjD6iu3C + gwZ1W/GGK7kNX0wROBgvw4Szzk3NY+ZfqJwX0tzU0ZgMRYemEHvP0Wp6T3R28zEIwCOhmPK+IQpe5k7Y + juX8TEMHpJEMDEMPatYGN4amoY7MsErpdSXajcR+IdWCDcX8YXXKxyd8ELeR6EW8LAZ9aOiTFgwMmWuk + eIwOgwyI3L8DEP0wwJq1Aw3hx1jwxDGvGU/FkjAMHtdCYEH0jALcQy9vbfrDPmWo/wDDJ3R+9rU7oYhx + C7t24bc3hhxPpWxlu/jgWzQcBq1GN5nh1V+GIPwb4n+sxvpbtzeDd8tz+2ImE1TGWPg+p3DgXxsHAYW3 + hqCSIeBGo+GN95KSC1gOy1gTAmpIIyEUKOGpei+4wWrU1DM4OAYGDahib8QYNubjDAwfqLfTkxgRqDbw + GCLxRj6YNWuDFqKWoYE+kEawb+FvBDPlFEON41a4bh/xA3xGPW0OauQY0GAxay3gwW8YM9uLCEWo+EMB + l1kT4OAW80MUHhbmL2R1LduIm1Bm3LgDgimYfUHZjeDeQ+EVG1A9Ldu3y56YG3HROB0XreWMW443bz7x + HZwZvB8uS7uDiGG8HCMKYQwtYfqPWNdkwBhcGsXBHkGoskC1ghaw1NRJt5OOXAEkNw5ogcKkiPAcBsOM + WUF7rXeBqCEwwTOAxBAn8xDiawYC3twQf0WrX+BF4Jbq48QQ3neCZNwW8Bah6STU5zfvOpMUMMnClqCD + OrVq1JkJooOUIzjUEureCjXi6uIy0cIkZG2O+FA1lrif5H0Z1NcQcHQkGjhZjeAO0e0OG8JhuPmULBt2 + 8PBj9cDGsLjdvNEgyB2Ce6KahOC6wNYBg8F/zByF4EDjJiuQPgYJitW4K8Iyj2kyVwkZxG+qMQsm7du3 + g5wGQRbzFdBzbyC/wR3lcAzoP+JYZ8Bxq1amrcuHovBiNxqMdzCTiHtxiRMawUOO+Jhm4Md27eXAYcTV + qY9s2q/bEOEDE0G/UseEAI3xSDAQCNRfyMMcCcf6wOwn8Ym4N8zGGUtaFrgFubhkLuY4LgjJtP8AiBCw + Q9SYaXtMILfAx4GoIyhB/jPuOB4EcBEeuO5fcPyd3Vo/fyJ6+QzxJNbS/hHEIcTk4ON2+Fk57Q97/8QA + IBEAAgIDAQEBAQEBAAAAAAAAAAEQESExQSBRYXGRMP/aAAgBAgEBPxCUodMNwqxZ/Qa0CLHpFAV9i4DY + uCCyIbUIeiVGYU8ziY/RZZIJA+QwXos4lQQ5syQvovQXIyaBZRZuwdZAnNRIXQ5CwUJQHzGG0i7j4CDQ + YmXIUCjGsiMRFTkKKGoiWUXAwgSKUzDB4qUJSpWcRgzI4ILaKIx2RmGZxqQmRAeoWFyQncXxCfAUQoag + MZsK/KH2krCiWecZ1RiFUcsAy7hTwt01iH3C2ITG/kbGfDhXZCZEmh5jF8D+BIJoaoYKE9BOXKA/mJGO + wirQOmKimyMdhtCYRG7AlFUY20bhsjUXOgYKliG32iye/getAfyVKUbX4YhDeJCFvroNEJDFqMizYQ5i + Iu0RfGA+IXxDxIoRUkUVqOgtSNvY3bF1jFIrhUJFfZkh1FKcmg0BycHyMwR8YnoIfgJHChcvAYsHhOKs + hUwfA1xmECoRoYjihoQWyFswn0xLHDKxUgUVwECHImMNMn4EwmTkGDQ3yP1ILP8AKJLX4u+Quy7EWpqw + tgPUIXijUKkEEFQjoIsLGwdRMdBIHiKK4RJwmT9DIuxRRrcFgBDgNBM2BRS2ohcrVCWpASKKEV2E90QQ + 0DUD+kWuNl4livcIpBI+w5goLMKm02MFiQqgyW5B87sPwUPyaqCFjhMgU2m4OBwDgKpoiQXCxNxM+/FG + /CEQGwjZQwQDfwQKJMLBA+gTExZYooqE4A+ES8KwlCpwZQU5mhghYeEoBcHgJBLPob8UZFihBgyWCHyK + sMoA4rmrIL4HBhCQ+aYKihGXodBIsbFC7MolALMuwuDX4F0DcCcV+Aukgrwu4UU7C85rQUF9FBKQkagu + MlIXK0BqVXhQgoagoMiiGhI+53Ua06kME5VRBA5BF2hFDEwIe8I/mFCxVohI5QckKjpFokjSj2hAyVBT + G6iAQF0h0QVBwHpQ4B+SsaPTEw5n+I/SE5lh2WPWFdmgG4XxAhuKQpMM0QmCEgpCHIoSBoIhM4ISkAXA + aUBMIF9QjFhBo3wM5xwZhAui5EwayBP2NH0GFiYmJBAoBZ5CR0YlBMgZS0H4GhFRATAnkvoKiNSMwhPG + OoXBKFCxYGTBJKDBMMch1jYWPyEIV4WRQiTBILDC3ZjUODG/BaC+RGEZMHFzY0Ab4TUXX02hxDisMDgS + VtQoYkCYeQSG4fXgWJiLfGRDXpVV0ZwSC8jk2M3FjEiiioc1oifYXAQOJqY0y4SlUF6gnFXMNSQUGlUu + 1FyRfiJWAxeZCgUKjJFPBMgkXIOkFeCQlgF5yYOFwUqGGxMuERYEBQoQ/gSoLyDQSY5iBYX8glFIuK9g + yqKgl5mGwvAtSDdn+xVmELuCO0o+hPw0EBYjklBxwQHAQsKhNBiCCvBXpxgGOESnKKofoYkEPiLGBwSe + pvGwyEDhQxuF+DY4IsIiDCtMoxHC/wDgBlPhVHeQBganI6KBKE/EQJy3KExsoQ4KN4lLC4WGxI/RUiJk + SBzkgkLloMUzJjExOSxuUZA3AkKeiFvKN2KUIpQpDgcLXglS1MbB9hAUiYbg5IkITBwT0L8qJeaz86UG + Nwk7NuRuCVBSOsSRXuLKoXY4FewGvFYsuFNllxYxyn8++8jKpgXuMKE7EHoKVB9CdwvSHG4UWWOGIssM + UN0LsyFsPQ//xAAoEAACAQMDBAIDAQEBAAAAAAAAAREhMUEQUWFxgZGhsfDB0eHxIDD/2gAIAQEAAT8Q + XLcgPagFE1Ih3t4Cv18gXNIU+DqWmQqckgGQYjaChsoQp2AK6ASaijU0E6S5HkB0Ae6kKYKrtR6evYAA + 6HLrxAT9wP8AYaQ++L8gWBrTBfew+BKNqoRHaIHF3pAFqUPchdwXgOsWRoTFBmQuDBnSVB07jGeuvkeY + sFbbw9GKWqUkcuGldyBtk8RjkAhZv4IdMeaezcTW1UheKYTtoQ6M34sBXAY4n2O+nK9BTxwm2tz2AOv3 + TAmMAUSrwUjimzWZWIg7Y0HIp0V64cQ9v+pAPzvxM0aKeBcGq53AQOEKyZR9HgSlyRShIsprPwsWB+k1 + REQeksEwAQRl7tjgxmydiggvMISQXbM/IHPbGsDTrYPQa0JhCCd4gTUTbeAdLtBscrtaZyql1kI4DeXM + AhGOgDKbIXlXLYIHvHlq40uA/LowEa4jNuEW4dI2G1h1uroG1pVSYvIn+hlSH8zC2Ow0vkTC8pSOkYgL + hrbQRC4jBlsB5fUG7YuIQvS39YE5QEnuL8cv6hpOi2K3grelXWwAy159FcAM2gMDzCuu8NdwBg6c/jIl + BpM25lIAHQ7WHorEeVkFQFS4ZSQnZjaIAC5TNTWDAiooo2hAGh2+hUUlaMG0LzbM4EAskXiSfsCFgD+y + ATXeLCunpXH7k2l0jxU8AiDavJIKwX5SA7u/igBw2Yp1C43sziHMaHtbHQgKbUBraE8Zs+cC2hmZQALt + rGECpPRwsB8LRUwd27DSHu4i+AE8dLgA5hnzegf3d8NVAptWTpKB/qY+rAGVckr/AEAo26SkkAN3qV/v + XAFGdqiKAkogcfIIQSZST1hAWprG1QSOGnJAASHvGiTF92yAKTAkQMTiLAiBRnF/YNAL50SgU2Of6yAp + jhd6JoISg1RuJyXAtF5ZRCCX3V6B6lnOtgFv5jniQCFreVI6ic/cjDadsFK8bL7zcfudOLGsyREerCBQ + HK9hBYq6CQXYgvksAhahr0SuICK89gKZpENhKb02GKWTE1cLI++BOnu4A51mQQbb2HIEPppqA68x8E5x + P9Akrs7aHkaRAFSnvcf4BK3krNmApfxJ2AVColFQvAR0kPlT7A/zF0+tgDMjejUBu1ZQy3YGerikKhX1 + cIH6q2EQ/XAnpP5V3ZoNMtQL7kAk34cqQqQglghxwYZ3aFyr3YAfh7tPkA26hv5FpQc1wImQA2dEsVOd + GooumoitSlKtAZ4WWsZgI/8AV6aCamofqQt+buWWIBLZCp/C5DEYeZQAekct8cAioqu2PIXYPYA8VW0S + yCeSOBciOeQCUsrC9svUbjrOMe9YCmz9UgDBcUR5T5pPsBkMTTrSIAP2Ee20gPplVol7BnmK3QXdMPkA + mzmq9D2APGQZdEAlRjKtQFbRM7r9aBAsS2EZCW8EJp1XKg6g2+ze4AWk5NkF7vixgO4v75QnvhGdiPmU + lAVk+Q5MBbcZ0aQUJXnQUv664xtEwbYLn9IGCOtCJpKfn+SACP8ATu4AL0QYVtN4WrG0BKcURDKcjw9O + gWq6QikrixUaNgwiq0wc/GAISvqsgbXfEbJm6hcO9X4OSjPllHw4wD8CVleHs0/TRX+pXyxPO2EbiY/z + kIqAfhJpgJreurcwSyfbdRAtfTVJ5owMT2CCQ29S/wB70E7FLMAQTQAfMg9PGmAlJbulg40Ok0Avsr+l + gAJh/qUkI/0DGSTy1K94gveDFBB/pCU8AnIwRgBPOmzKsgAT6qg/l+iNe1cQ0FL1eDoFc0VwSA7JMLND + CD56dF6RGwASrRk2+A+fmwgzzrvAmehSZeRl9oQVbwxaZyOKwBTnfYvvwAFfltgs76jba2NpGV0cgAgD + pSAK4QWp+ABtHYbsQi5RfgCL+NsUiR/4JmvwCOJA8C71Q+N7Asm1gRNwLzGzA5hOjJKyB01CRsAPoNG0 + kgHjgsn/AMgXc3e/9AktubCLNsU5AKTNB4GymANjm/F0BS0suR/piGg9bBuAzWM7kWysf1MKCsnhML3f + 3vECkpERKQjhJYhN8qEMrZLDJIJ0aSr5BXukcCQvra4Ov56WGx6oUjGdUQz9jGcAl02CCD3ljFCT77WE + oHXnyqmAEN8MrQD6iuibsnoHogPAmkI22j7fkDoJkgFvqAEvu/mLlynhbeA50Fl5lkI1QPPbHYU053jW + SEz4ofhFXSisoBbwdNB3DN0CVOK8hM57cCTv13IIEq/tV8KfYYT9sYgJ6PydCCJ2sIibov8Affoxgj4S + JwVodYA0znrAi6oAempo31AAm7Fjmn8lrYnQHcUqdCZdPJazsAnTNig9Nlp33YjMILOdPYZuPNSdU6CE + wE1dEQAOKucl1tsIah/7dgAekcA/sIJRGFZSkAZvD9i6ACBhX7qq4lANMU/uvgAH8e69WGgV7w4Affg+ + PWes1E4noAP9UAA8BYjZdtbBqnZszglHpSIpC2/IIkBm/ZS1upZVQvZLKNoNv8gl3iATXlwaMXlLSDBj + 6Xl0jdZBDlJxj7RpsFhTaAGmUy0AHPw94pIkfkJv9Ie8wY20E+RQyIzfCPRWJhb3dTBWs4OdH0VYCQ6q + WgR0DBtrqLF+nVE/AphTO68086fQK6u+6gIBTsVEgTrh2MQRESumSWK8uRiu1fbraACgPEY7f8wjjzck + AvnSUQANlhJwtztYdEDrwn1YdP4OEAdGYZiLhDo11CwX2bbvkNkivdy0Bb3aL6IuQdQYLNJIDsViggI6 + dJrfumjuDfK3qax3DHYTqDECx9QYrX7o8QVy5cCE2doJdboNM6DPIW2JmxoCC5/xC4AAzeRUMHGibmqz + nE3LD0xwOBJsoXEAZ6/fEOfuFBdnjyIaeXJABmQTdalwFbyqMAwqmDqfJAnoQaa46gt3Rw6JACOwIKOE + kBW+8ggidERgGe29joyAkn5HlgdRoijMTIU1AAnsNvc3NLwnJt8wQCPmKO1p2Qdwr/L4scygWQvFu4Ri + 4BWwj7MTUGJ7SvsewCpIk2aQgFNYMP2/RSIYYBBqTQHNx1X05GTRaEfOFhaCz743IFI+Upe4UyusfE23 + wEHqdXz3SDO3Dve3KwpVEj5acAfz2Ci59lvQUGFeUQ+muT7iKtTG41+RB6sfBHVYrCcuouHGZxFVDFxL + QEsOkTAj6xqj9CASLNgBarZXwCBd+mQKNIb5wEu20fC88GM97GiZHCgYuuEQLZt/ExQpNDOsgDjbY3ZA + TJkAyMrZg6AQLKYx4Y9EgfQHyvFG2wYTpKevXRPoWRsLkaZ22toDpNs0kAo+qOOAdm0QORzMAT6wNAKS + ZCGKZHg8CqTQBjQcbp3PYAu7NKj8AultOOorEFvDQyQ4Cf4dFLxo86thwMoNNkAFZeJPSK5hO+uQOvwF + GIlGJZEWqq5APFu9swmNdIxCu9ShLoXfwHPWgMagTgABGW8pkBAU9RODIAChKKGAXWeiE1j2LifNGc2V + vHP0Kw3O17z1NEh8cLMOAmopxbBTeMoo2OgF8wF/CofdsARRan5MaAQ0MOvkS2/mJb/rp5c2KyYO9xe8 + Zgfpdi8qVDsih9kG24PZTMMRsBWc+d0IeMs8lW9MgRbXvTOQG8KdxjuEvGkLmAChzOgA/UcSM/Ib2KkH + w6pmhAwZQ+4TFig0y1XIjD67jShehH/cdKKyQ9LrpPrRlkLKggWZaAzWoZBD0VIQKPXLnIUKxIwBW1CG + 5+adsVf3DgaOxl5cwWFueoYrA77gBU6jAAxIxDINkXZ1WN0XYNS7X+BzhwbI9NBjZ+YEzvAo3fsfjSCe + GV2bfccYJQ23sD959x7C4hPTXIX87YAFB8rv5cM/0DS4iUK2RJBIDXRIM+BgJEWZInh8oUaVnFtA+KOI + cwFI5BInXYQGTbUXMYLtEL+YgLY1cNPGMeCeFVBvL2uyEAGGgSNAq5ffVQJXyjcJ7W5rBVeoc/qBIjK3 + lDkA8kZFmPBST3CAKuXZUnEXIzlQmd7/ALBvCHjvFtFT240DaYxqVUEFNN6Zv8QXW48gltPAemcACLyV + cogN785vBbIW6uI2P+MNQSQAf/OteIM6Z1L/AKQYiXkrPGeckgeLHy/YNe5xkD+oge1OvDo5hCPq7/mC + ERflhluEB1Phe+mQcUgJn2IcXCG3XEAIXqmfcrQ9GMoHAA6czBDMWVaQguRogj446QgwVZtywT+liW+g + n6M8dFMxBz96DfxKjo1sCYCvS0apyHcGP5eQNDorjBfAu98uTZBHaCMTsiRTuURYCLh0Wqi0iZidgXKZ + IAFMq96wEdet8YbARxRD+NdeSrEvsgxByJ+tP0LQ8T6+GcPTpIky4j3pG4ZwXNBegE1x9mS39DgjuCkj + 42OSQVP4NLxu4Ge9qMBZoAWB7dssCB/uyqXwAdYXt1oAiGzUMW9/QBzVRugUw0a3YmArO42T5QCiS34w + Fc/ZsYgo9pLP0MNQLqbdUWECPZMKUMZ2N1hCj639tfgFcTpuBddPUk8FoFAlCHUh6N4F9UhEHlPy+LCf + X5S44DYN1wJ/72SpMJra+LkCZ7eYdAi5P8z9hrciHV+ybIQgW9+NfoH21icFQ186AQUVycqAQwlTlJ+S + Egt39okp3gv9QmIHGiegNMlBoT2vnEsWBjGRi3IbmUC4ZHkMR5BL1JOQluCud3qYLASU1Hr3lAIEyOp2 + jP6FQ9RHQH/P6gEhk6tl7MHaIXeA4EP8+PoINN2Cf+qKg3sqPHUrUSu778ADi8lA2R1cMYCHx8uvrAGZ + +uEgHf36yQJL16wDU/UUz1EqMkcJ4P8AGKn/AK2ArmFAmgUFGQdIFIUoztB4Lb1XJCv53kASOwJ1DAer + cGFcVXoCAg/S/KcgQk8O8Ace2JLGp94CtKgmqMGKbgO+ycVJgkCb9TKWwJUaqiATEhfONEiG7dpimzFl + RIOyCVCrcvsYguAUNSMfkqiU5nxXBUXzJmCKO2AAxHpcI/kLdQhm3sz2F+aWXgfsEdfytxX8i7TG7e1Z + kFSeGv8AADddVvAK14Oi3nJFFj0xGU49VmZAb3ZdagKPfqdxiBf5jg/5grxVyW0DdjmUwGVH0nUYhW/V + fH3DQXS66PJ9BOEgNlVaIs0nwOQQf0OpgAkp/WBKBHQS1EOkvXDIk9Xptp4QwgPWIiygITQAdoaTqXtt + 84QIaLIjDf45XAjZ/kDw2Uf8yHQnxAlr2bDTR8Mz3TawSHoKa1HVeRBJDtstGKMGYRGY0AQPvB3zbD5M + KFVpZCK+QaNk24MBivxYEkTeu+L5CqJpfiTBTJk3mIFfSFf4oVb1KFmAXn98gRjqgzBCODo3FWJRU0Ud + eVZo1wdN8jIIP3W/ponBiJ/qFhBnRLDBY/NCB7m6AgN3AISmJBUeV65yTSNgEF5QSmpAJoxvLQbmhvte + vcguFH+GFH7EB3yDfQm01WqqniPXqF7DmEB6iRzxs0haHELrIom6UjJASbbgDndVZBxLFv8AiTqsH39z + oOvD39HRPlmaBHd/rYgQ99762ByIquhjQKDVd6060QUcT7ucmCiV6iZATTdoBhVU/UAhl75rj/JoOJVg + IFHRyb3cgQFIF/fjwT0LbTt20BXNYQJuapRntkGC8+wFC2v0BcOwQqeJCDfJoFc8tCfUkYTBPAaydOzg + g5zIULWCgci8/JMjvCp3+UDdacKgRTTH+2kBbuN1ZC+7FCXnI2+bOWCFMc3m6AnFKjQIUS5D0jXguzuW + cDrLOkSV3touRtdRaqjRHWuy9nK2FIOCabv+IfzGQWXLPTIWLiogQA9FFJB2WM1NU075DJF50AZ8z3kU + O3iGzuklrCR1ydASyKclT8HVgO/SgZTwBRdFATwra3VB9pYEdaN9wVBOHv8Awg2UEhWBsAZcSLaIpeeQ + cQNrzk8aHl7MD9lJ6xHvxehAlogpX8gCQad/YsSB6Hx3IRNvNyCeqZI0xViiDYU9BHIocYxQRxaAugAj + i0ci4DRKoFlzkBAu0T2g4V0Xw8a4G5SSSQx5Cen60A4ACPbpSGhpK5YC2GIipkB08lYgTz4xA3CUZ7xA + 39oa40BmcCojvO7pGkvvHdmAW3QuvQBW3SSMmPShHE70Ac2bgtZOgGn/AHQoAVxR+UD9j3LFIwF291GA + O73F2cgLZLGjoOmzhKP02vGB5UoCV3X09y0SIwYVCABkfZ25L3OqwHKVRdtAhIFIil0RYYp31gjJRkPx + DAULbOW+xsiADMtRT+BUvgaL8hoM9+zNqhIBACVZR9GA/PX8DNrCmlAVjlNJ/ABPg31Qok71gVV7AeMc + GckxoeSgyJSONAZgBG51WBxnBLxu9EqHZktJ+JVetvjFgN/G6digQe+UCLQWkdJQO64cJdB6OkS/1tfA + AkzTBLcacYaz/eUEMHqEpjv+iimQRUbUECmqBIUrAFaXGGgQU8d0VFbScKtcVSEb2oH3RHQUov6grFOi + C7NC0J1QntPqXTqRBePsEpSE8iIgfAr3i3IVSHM2aigDT/Cc66BP5uiCZ2uDIgpyOndWj7My4gE/lVz6 + EPsWcuIuU+Qt27vCDzEOjxofuvMr6JqAiT0TMck+QE//ADGr4gFN3yqZagFX0PI4wANk9G0ngQo+I25p + Nx8AgOvvV7QMWj+fiARzSoFPfw6ccOKlss2AI2ZjkgaYEMBFn9PywC6NfmE99QZfw+vGwgmNMqMEDs52 + HwF/eWEefHVM/FAiW9TNBdigU2AdPYgFhtnmwAKKglkQlN2kPP7Hadiw02PU79GJJ2FRUkwNhS02vCWF + n7QmbFzIxA+b9ZbEaESddt70HxiGolrNzwQDM3jrpx3jpB/gGA+hNdZTyKRoqDZ90/Ysy8L0DHT0Q/UV + hOiBzJ8MTGfUEvycFytEl+ugHQuunh/ojmsESdCkaJ7PgIpfbC91KQ4IxF1LQxfUonoCKsNP6xUQx0Di + MtdjOgr0tHJ5jhIH5/wgM/8AHSIN+bPBnkkBUIwObWkWhIjBEnRDFNDg65IaFQzFuLxlmSI0f9/wE7FK + tBSzNxhX0pG3txNFYiCDl1VAQH3A7FRCW6I+RQdySLBuEA6PgQt++hGAGbfBGD4oCjHQMNIthLiAX0xy + FtGz3lAVn+Oh1MFdkXDywOnoUjsgAx3NH8sBJdmOQdokBjDCgMiCxTn/AASB9tZIcieiGk0QWZTItrKi + H1m60Bi+um2NAJS3PbLATV7R3QLjCBEzFe9BpxTjpjg7BrmwnD9+OyKR39kgQDzmKvXYAi8bu/584Ri2 + 5Wf7YElkW994jGhmvTSAZ0tGkB+6NFMEACcBDzNbRmRkse/xHWyCJoWJOziTIAWzm/3yvl1VwLhAqSiU + tmEBvnUZ8NuIqkh78iMcXphKGyDHLEPPQojiIRruRkQqhaYXYOVtZfFEUgfAz6Y4A0H0Do3AokPuXrxm + qT3BbogT/MNhLqGgnVUZRukg0VBVC+Ka7ziKZ7hh/OMABpn4SLxVDFYq6OSLN8AbOfS6EDch4DBf2rLA + J3cxVFPqiHoMg+UTuOi8w71dARH5qWNjLZLtpl/AoCDBZ/oAKMK7+gYoJoBzItMBSC304BJ/I+/hAMmu + 4YxQzV/+doFDLqtEKszFrJ1tA/QcQhbHpZpH8gTi1EUZpzSkUi4bvIBW5xyWD0JDy+akELOZ3DzGCk4C + YfQxEZNmFw5m14OevUQeyKny1O0AGJFVALqugG5nSN24EXHBOeQvhMARSBvfPICmNUjDwLAPSo/17EsO + tgijBBK8hSIosKBeezBDzetEaAoUE1kDG9w3AYHulZr/AADXxTiGq5RMoG6G4zrYAARXy8oKkq3sCiiy + FpMNitG0xmRXpKo4ANsgS2US+DoqiCsQ115BCwJKYwrQ3hA+jHLpAsqCXMD32Jf+xqECMu3DDo8xNkFF + 4KxwHsYWHAlTcB8DndGHoHq9yAi0MImK87HHZ51LFCFJp510agCvOwSh6enJ3SRYgEv2jyEkW1IDMzvF + CgfscaCJVBj2cwwDr8IaCOICcZKXvBQyJlB7OArkFWAUDWgBt/moKSKpaJ6qbb2BUddyqrVRJ7+AQr2g + Ym2QZkFr21ucuoAJo2FmoINeOD5+sgEn2H+lBBmuOo3ABrOR+EAMm1yEAHnND/QCKReEROJaSsX7GiuA + S3afeQVC8knS1GzaCvLtA0mxgrs+KAlLgQaYvx1yIH+4kr8CJVW7EIblEO9aVAOItdXnKHQvdLE4AAlP + oRpNhE9S3X6Ej9109oAFTnr44YBWUd7Gmr94UD1XQVcAEWkFf5V+zpBff9HiWlqgS/bSpXHDg8tGoJKW + +OwkjL0hXQvBGWcsIagE+E/EoCtZSfeabhN4RGeQx6orkMmgTTbkQIui2ORiB0V5yeQnyoz3sATU0HoH + /JoNG2mcAX3qduAEPtAZHGPVtgQwADHxhoJKaG6GB1O1QASAGTGChRAEmzAzvSDAmF/HVAZ43C2AU4AJ + Dp3ay0cDUmIgRe2hDwH6g3f5E37r+AtBRJoERbFgWF7ACd8hwzbQVboO8QwvsirqwWJr5HgkI7uTXCwk + xp56gQKs9ZwdK6cYUNmwVKsDyF9+2mDCxv16dgWqo7Iqdkgsen+yABV3QKX5AVRtZgX47COGrZQiz2dL + sBUrtTQ0JhYUTCK57G0AxUDBTfYWFE5EMA9F5ZV7sgJ+hGLyd/kSKMMftAX2m+sTApBlQKg2BsQrnT3G + Qen7YDcjIiaKBTxkPumQhQiNlpbyAcW1Tv2ACPXjyykYgnCPwROxJUUqSEeqPO2gSwCBIIjLp9D6PooI + sqfxLIbGEuVRPFCV8vG1vhkGOqPuIBdqBR61fg0/9IU9shTn0LiuVIxAJ+13iAJQvN+wyevyCD38A8Q5 + QAnrSHSBL6a32YvlHLoAWbnskDjBaYJOClpDZeR0ZpuEuAgCN4WDfzGBxFkFwG4WT9Ycgu8QX4O8YBUh + JmJHDS58BNA6W9Q3ATjONSi0BmO7sf1rf4OjfNE2/gAR7eLMJ+jjQDsn5VgSUsbfZAQ5Zv8ATAm1Z+91 + AKifJd7WRYEfrc0q3IE3nIVQVelWVoQzBhECPaRsDYd0dUAFKxCxe4TAkHKf7WBHs5/L5UCD2QAAN7/Y + QiLc68AOtNBUV73CLeTTHkXWTr0hhCVmIHqMBU4lkfNoFypoN4CAxaSAAZwkF1QsBbMiqAdCQ7wSEPjp + iSuDdGHesV6Am/6PcX2CFH+ekGMzPFn7/wAWmMA1IN5DeARcGKppLXDk/FeRDMfc7tQsQ5faH44pDNVT + z+sEAZBkxcM4x4YgM8ir7nBDzVMBoID9DymCJppzGd4UmVFG9yMD1isHgTcf2yb4lcx9VuJz8lycew6R + w+JgLIGgipJAYMnThScVN60Qz1MFaZHDcBI8bGQ+doSWw4IZB/RVPwRvAxf+k2AYX0n3EO875IguKLBT + /tST5G8BruiVAK75rF4ciFH2CjgQkGghXA8RoBgrZ6qQL+yUQx3tf9FZaWQIlM7VIDXWoYB38vXIRw/l + 1iGKpSNF1WwIeyAqGSuyCwWSNKAiwDYsj0Qmo/0Dy2R+ERAaFbQJ1wBIHARBUN/QzKB+6AwHqM5ttIwG + aqVYe2ETPyeNg65k7sQo/CGBVz86MADUrnlCovI2U24F6qCQxvU/KhogCfiiNFWXlYA4NezsC7kSV+XF + ioKL/wBEDmBZAYm+lbABY4OEyDULSAceoMIU4FMZUW6vLohuVXt2tLNeSxNeyoXeqgCmwK7hjdBgd6gb + 4JqH8v53AGVsyfJ7xFA24lmSo+hENpK5ZIg+L+dzAlSFjJ67oUHEMAl58ygxeiy7jAq3ACLuPJj9wUhe + x4aE4JCSCor3QqxCV6v8TH2bK+iTmDTBp6gumCFQOl6vqEXldmVRzIDc/sn9sX4tOf5wAxdSJ18TNjNd + uPNRoAqHufNlY2MLfq3wIlQVzUBgV63kTkgF714kQb9Kn7FsDrJwwEonwGGdmGaMkOYxM2PonQCehRJK + t9PwxnMOFf0820FEdxG5CTQaZskswNd5yBxmsUGJ+nNCqdHUfoqa2LPcYhg/RRoKCfogBL1ynwA90zhH + GT0jzcw6DAvYVSIBVRLIXalDiBeasL9LCAGBRVn3QQ/JButH2gPWq1VE3t1FDK4K3hx+gVNYLT0DjZXS + 1YZMEez7RfBpOYbW1CYGxD+/uoXyDtdnAK1uI49Ap8LbjIgcw/7oQFF+Z/CyyVWVIqgB1j2V7F1BfbMv + cH9MjMGV4/PjoOKC89tFJvkxakx8iN057jkoulMiBvuqvoTuAWEK4mBC9Z0hgIsZezoAWVlBgl3BGmqO + yplBGX1nkDkuCAHSQp/k0KzmYyqgdXs80rxKMDQPlCSPgCF56E1vijddaifW4RgJbbhAg5I7XkFiyqUr + BD4kAfAcxNP4AshFQpZu4gONq7rdIQWWy0MIL8mpI9xiBFckOS6AQFFoRm/KYgBSZ5ooANXG8f3b0hJP + CC2AkB/GuA4FokMuT6hF1MEUZeFyFGKFUvQRPT/+hQ5BSyFgaihtQYTY1KgQGqR7BqTLHdDcjFjrPBho + Al8oFCfXcgZLRABfexWDQeiItVFNqroMD54oEG52bNSAsBZfplOz4gllXkjNyBIlhBAFwmgoF5MBbXQl + XAyjdcqXrDP7m0VLRLeuTs4gLU9n1+oRPypAtIHP/SEHXdA7ouDRd5vR1IAxq3LJIC3TIyICnzGnyDfF + U/4CEEVWFQAL+u6VtHUCI7NUE5UIsdgf6fAc7eCkP3MAYLziFH2irGR3BgvbOyaqkkH5niIVfiILaJfU + ADcIbVEZoAFYAHbIQQyMyEYoQ9WucDn6Ckxbmgj9H+rYAwHEYt0mABIcsGBVIgCGrDhRt/AgTcUWnbnp + Xn5gSMrjmMZbIQTnjzy6XAETcv4nmG0EZoAsp0ezgMzfgDHQtIC2wHJ/Ine1s0IIELFdQrMfgVwzmXKA + CY+LULgBsFsD3OjMRQBDb4BjlHomASWxk+Ff4Cg9gGPSQm1WF4JxTfDS4up+iSgu1gZ0V4UL/goDliqk + PO1VsCmYBzMRo5obw0RAGc+SmEAxEjGpYW4GS3ZxjhAHZv1umvdQD2x5h0sXVqwF3Y3cC4/MQDNLTG0U + vOAWQpH/ALwDTo4Fg9WgOKRF3yaVCuBsBBtSHArGIYMVvipUr6AiJtO8ZEOgHRL9Li1xZXDjSIArtnrw + HNulxuEhQ3j4wHWKRAkowhb4OmC4jxh7GEMXQBZ10DeWuzoGSC8gEozuIF8GqQ39obHa5YAbWJkGkkU/ + XxkO8/DnUicmte6zhRDp4mD02qBEZhJkwrAB7rh+dmAMqCUCjyi5ALmZZ1DjEcSZdA0QBhO9Dg4AF0qM + b1+4OfKiSIGc5Bn4gC79xUgEUWJvdJTr2yUkFI5eMN7GkIvc57tBLun8CJHviCMLrXkBMc3L3A5epk8B + +ouIiOeo01FAz/DmQgEcCcUeigaRIOIixLRIJDaXIjvgCa5MyqVXLeyFrHepAu/xIAJDrmLmzU64A5cz + XhAArk6h8vr2wX1yPPwF+8yUMhBJciDgBdq6GcgEIpsu6A2AwplXVlUoWKtsgQH5z1uBJmnAMRFB+UFU + A9Ey7YDW0dnCYqouF/uBV7b0lQUxvzWLbpokt4HmvrloHIOV7QWDqKXwqn8hkXgqBd/cioOqUGlbP3Fs + 10Y+1Auj3MA5yGoJbcM9fxikn8IUhE9DYUGxXexDyroAEhZvICabtXofscP0SRD+aMYEZVFlFbSmMJVU + AkyLGvGAtfoH05aVEsww3a37WgH6LD7CorZey7at8gHH6m0rxIbfvGwEDpFUxyCntHVQAUc8pbXnRN74 + QBLKVvPAp3L1qBW4CaWgN39As6CnfzukE1R2rvU4YnSo04M4M9ODDl9bNoEK3LTgKkXshmG3YDumcGEw + gbkatgLQDZLFET77IO2aHvAimcKgxAKEqeVARi7w8FVPacYUvsDzhKwrPaje9DwC1oCVPE30h5WVusGc + VMEAgTBQSs4EgElorWQAqvr0L9IFZrmXEz7sdpFh12lAgi1AUncCjboOSYY9jVbgfsw9QIVgTj99u52G + nGeCsDnjWQFGWz082X9DahgPBAde3Yg6v64YuYAAp/TTMHFmM6QXCdqbP+wpHUzpo7gVzTxhT9v8gV/o + wJzloSKnqQhOIGhuHCzQ1XUgfE96yOwGGgqsOQRPWLqFJXtXdVOXoGnFXQybonGcJWm/5A7FtTrdyAGA + eV1gXIaSqv8AaBAwOsDQe7oXSN74AgQpT+5mMhzZfkgJm1zQmtB7vo9kF/uNQgHTN9kWL9KHcfUwB6Dr + aBqNTG5aAi9iECDRIm/eLJlxf31q0wBKuArl5b6UFIngcLd4hAtxaYCyMkgK+/fHQDqvZ9YPYayx8GXs + djAWFUFo2otJoT6pgJDFVyzQMtDuABPj2NMctfUFTmapoouKpVoV/AYsqiGCPkBhWs5FgMa2FALnkap2 + I+n0P8ArvfvCDL8RiCJ4S8gVDXaAzmSQRp28aFCIHMjPDqnJQDyOhGgiCVWa4HUtxruMfbIVbMIBLYOW + /wBzACq3yxIyS0la9O8XEZ5d+YdgNxYXGgE4AxvTcCPuBOvpdBi2lvKQADofcAVOxUSHkm2dQPRQMWG5 + NikA/kR24b8sdoh6L0IHFN+0fwPCbjr8BDqStcH+7wBYWVWemk/N7KGZFeQQhEUdQKqTRMXGmb2Cxj0A + AoHJQhnUSeSCi7YALK1EL8gfyoQ4CZfkzskpcTIAibgc02pC+cVR+ABX138hobIqhbou6A++yvoZHXXi + NgFlqaWQtuzY0EZORQ7U9IImaqORF2kxgomcnH1BaLkFFwWQSSskBRN8Vqs5Z9IAc6QJb6kVPzC06FP2 + 6wMOoJt3wk8CeNybKJeXfkJM8ECJalPQBG3QLMY8gHRevrgeE9qwhcDtHRb8gKoSNhCrgcPqFURAC92S + gYj6bwadEWzy+QvIWsH45gbDuSZPXUMopCSSxs0s9x+ZsxSAEFW6qMfExP18wHWiPC0MKevlYjJ++svr + N2KoOzEVcD8DiprY3JPx2xYOAiPZBBK7oMHVoYvk5jEFYF2pC1dYE3wsVFfyL0jBFInsqEHTRhm1FKFk + EObGvApdkaqUAT/QBRU2Aibh/wC4U+0C4QjbXLA3EQlPnkCT2koRb7J1E9sfcRGLU15WZxAQ449kWeyU + Ac867RPYvsCNhbzrXYlBMo2E108jUeZEnAY1SBlGOcM7MB/I/di5w4c1hluRF29x9GApcZvs5C3drGaB + gw/AQvLd5voHS1GG1VaebkNN213RsEyK0GsMk6WKuwz7QYDXKpHSllbgQX8OfIAHO54q4nKQB2i6B0AL + qABFqBXzfrEBtB/9RALNLTaYAVF8MbRWyCpNCfxDk+IABdbII6K2kegC1sgdtzsGbZ9AAtm3WyUSIcx1 + qF29f2shC6vSdIpQ+0fQwci104+wqq+ePJAg+v4QpFUsVv4B3VAIGl9lfQUbY+1PYGFOQRKBe7OOlMK7 + u0N+Am+zBc+xEZ/SFIuR+QNHUJG2CLFgUot3M0SnCoyB2aumEBR7+oK7l++DxRau+mhJrsJhRxE8Kdzu + OEEtB1y1CF9RZEyN1fD+wlyAK0WiHfJCLJ59zsVFGXnDRGkDBxazpXAI639PxXAU6a0DHehMO59AEGhg + JFQ+9sZVkePC2gvRgQHBxWz1f8wZwAmDTk2hsUXpzOy0H38EPCr1C7vnz0E9IF1guP6BMT7VpkIPKbQC + 7S5LDXRRtuN7ypU7SADP3h6kBth4CTOhFdRJ72Q2IdzmtIAo9Q5wJsn4IDQGeT2QZTytwAi/YdDAAi5Z + VUEouzbJ9RWKi4dAzh6YF2e0oLdAfsQg4UK7YDY/VDyA8kOrAgDV5hLqEEvmj/F1HcSj7Tn6QqCga2go + kADqlFQ30AMoXpjxkFKKnGQJyeLj5BHdLaK5wCpPtvoWJEWPByDjG4/bBI0Oo23DyArlWaKzwVzySDyq + giuA7+PQr8cnWXgJCLBVqpRIWTfrYFCv2jFqLgDvvGjRZoVfUIuuXnOctE4Coto0JkZEBl/6yiy+IOi5 + QNMgbuX+A4tjD4Yvxi5cpdAWfI3dgHiCAq/L+9TJGynEDxrpSoXoNLev+YgMuuDikAtVTa2ACSdPBad9 + xXitKCqN5J+e7IRv2r60ABYsiHv8MGiUxvmU1wa58m7APaCM2SUcgX7V8UwNfJUwAiBvkxpprdN4IJXA + cnCpqFygcngyoAdzRnhhFsF5y2eQk6QgoaiQZUuq/wCAH9JjjxBP9CU2AOZJQ5geO92gzNCgBrmAaWBY + SyeH+wgVzgQ16t5CpoPEK62LH4gCspT+NwRf6X2cUtXOh/N6Dzgs03fZdBw0vr+gSkdK5XB3kkCqfzLA + fV4t9Ar43pFAAJyMNBB4LGiHmZjBN84bZNQlE8IcQtRxKJ/BH6kEUVSI4Pqw5lwnFCtPvkOhBMgrD6hi + lIhej0ZIuMbufiCi8d+3OwM+94iP0uxHVEAO32+gL/8AIv2YjPH/AHJsaEJdIvKHKyEB3CKTqL+EOt/0 + RSt1icAm5960IE+7fFCyl0wiBgonFT0HwO896GrxILAw+kVTX7SAhDF4GG8+64F7hzsjtLB/zLs/gA70 + OSvAR7JF75ZiwB7CwZeLHYAco0Zqy2wTfCDir5tIDiCXcT/YnyTdBVjIFjQUChufIUT1gv5wm1Vrf9SF + +zoah5KySSiJIOhpbiVgJvzwEqt6YM86AO/dGpYi/KoMgULThCJ5NE1YQOBvFK+6AfU3EFjjYBFlVd94 + FtfqKAOaHLISpvYJA+0K09Qv+BDEjMR10tHxD5DJF5FcY7/VBOKsVh5u7D43Mbg6wAewEdb9St/q9hrb + cFZcUG+pLamgV7kTTuEwzwG8VH8J1AU8h0AlZGEQfsujWCTGnvp1jECnfqwzpAlmFfOV7uDaBGInTa+A + RYCF5+ZHheAgfBTNiyqvShv1LnX5I7QF6WirhkPczHdsCkRDwETClMDnmaBrZ9nfYtySGD5sgpDuaosB + 1GxyAEjoYVYD3Mx66CjTgQyn790kjn6GFvsLeuN/YAZnBGeU6pj+Ai0YjuTN9qrfCGbjQ8KUGxoGIjK6 + K1tUgfM79Mmgm+d6MBJlKaCWkXAG+AIwiw5ODTBYF6KaSBWY+ByL6s8U5BJLEcBbByK+hTs8EF9cQpU0 + 6b1OgBxIHOdufcygPtbU2AFp4M7LLi5L96ESNprfH+oDQ5sKIJaxGLyECEI34YZoFLsgXXcPrDQCMzEC + 3o771QCvzn+YDJdg3H/dgQRcRVPsBGqhe3qmR9jQRA6TNEf3J/nb50ZSI2D/ANTLI3FHARsEzxi6YyPU + yJCBr90uSwCyxe+UDpwIFpeGb3dMjSu8k4YaxrGqPkAHHqw3iyqASrUwATsE5mvsXV/lEN0kB9DSIdw6 + QCLItc4eaRJUtj8iivYZdQdy5Y9UBZVvI6smOdJvtIKlrQpNhTOoN8FrNun8CvXuOBIyhG+QE1MffBEn + zLogES9LvQdmwNHkoLjgqhP+SC32kBLjYP8A+MY+AMXm6cUQJyqd8PAE5khCUSDJ+QZCLmwm7/AJ/Sr2 + rDzm8s2pe2gizlYOtSzUJMbE6HkROcFODq/YEcaouoCcWnAHUkqruHgIVfnu7lB9fygClMyJyAQeJrIj + zmoSFEizF+Kbb9AJN3M1wQCXma7OXYC7pw0M23h1ccQ/CUDYk2dNw8VTbnwYGM36z5g0dsRD+t2s5E0T + +jxRyIT0QIRY7aWmh4/BQU0sBNJgQLdZsHA4njueHfpYy/LBVGmjuDjSEAmbSINZI1CuhPFVMjJ5MK0M + JIrLddmwKdO6kQADxo9Wr4TQrXEwXpPAEwWQn5SjbSTLQL6l9nR8Amo8S/46SBKK0iYknu6SSEfMfU/g + L604UBXOJJYE3QNnSvxfrBvUb4A6w3PECLbS0ZGYROw2EQnAZmjhgFPmzwIKKkg3UgkL+YcE95z+lwBZ + JqikJzekbOHCPfAe+WB3bQk7i6y1g4Yk0KPo02AC41edLxZg6BbAwKLNHG+08LTEyJ59AntNLywOAqaF + +ei/+RriyUQAXpQC/wCpBHTwAn6BMERpZfuEfHoWMQHhQ4/0MDtXyxkdQKJv/W/AHH1p8YmDv3IK6rB5 + kMzDiKT3EhTDgz2ZAB+iTgUuQFGhY9nbibkXHqUZlQRPmGBpNgh19EzY0qUwsmqhQnR1ZELL6ZHuJuR2 + aSKhWZrbIMqbBN7b8hPUR9yXXtnFY3miiUZovyq8YE6Ahw6Hq0g6Nmhmq7BxOjOW2cg5SPdCG+v4Ro/q + EoJeh66VIKYhLesABq0AaKCm09nTpVtAVFwpB8DgEHYUPT+I1LFYDFOEXEga2v8AEJ3BB82iA+MSFBMO + Qvsu4iCsmN+NoD786vYaLFP9PZsBFNjflqIaBPPwmIhX7VIM7siPt/prFI47giIEPb0t6j3IHblBgXi1 + gcPGnNEjUuaca8QJ9/VkdE2IS5weTQnR1CAoBHr5TgeL0kHwCbW0GWMXbeeoJ6acNS/IwGSYjb3IxKJf + ghHGzEneovrI0B28tEiWPH8seH+GJarQxGI5N6xgAIzoGKhLqgKNbM9bVDQkksCJxf3Uvpqm7cJewzho + JPMLKTjpHse3t5rsCfyimBF6u9gR/t0Ag1upr+qgGh6sSVjAv+oNfjKGM5p9kWIY/fJw6EHL5O1weoGh + 08G1bfWkAQQka3dm4Wao/akaUJjErGY0sCeNNthawgv2lZPGE6gx8g0JtHerHFoebcZ4ruKQMKG4Eu0S + 2iAURMnAoQ23CWqDsDoLtBgg/JEAaEZyw9u+9g2GzWboYBSo11lWECnbQyJBwqFPlf0oSQ8v0mxwDs3z + EfARTVvkKzYLisYGzWigQhVQdTQqgG8DEA7tHoHmYOpPAMZz++YJ3VQdE8x4PwCtXIiQb9qutjAEuCcF + qA+2aQ2QXdy+T+hb3d27fsGw1+ir2B3uQN94AXTkIUs8AXW3CBLKkmIUq1vHcBN6BaDFbaiB1pJwJCYN + E1GKoHQNFqUcsDGzXLJWgAhTpHCONP8AAJSf6gA6KGBvKC5X29rhIyLUcb/tQ5opFw/oIN6oKwaJSrKU + 4buMBRO400A2pIMJte6YHzdBrEqQ/IwwHB1qRlRCucyExFWDkGME6jV0sadTM/3OON6liNuzptOBYn+W + TvcyuI0acSp9cSpdA5TV6AZRTs38fSGJijnY0AOZl4722Dvab24gkcPd0aFt/RfcwinVmqf5AgmDAU2A + GHorrG9QQ2JyCBvV1+E/CrQUdVzM7gTm/U71KRVtpJ+IwpqEvgDcGhZO9Iy78YPjmYGCJy92I4A6cWBU + ASecKgL3WEFg2BCFbQNyAJ9Ogj5qgHMYkBz0iyJbIUdedbn6Acf8YRXlpmQQetskMT71W/YH7HgYD5po + MVQUEbMlwHQgN/igKxV9+CzqE0zsry0DTZmTE9rAdPCO0IwFMlALeDgq8LL/ANAuI7xdsAJqcOGCxgWg + hLYOC1zOMpIqnqlcTh8LXSDPTth2q5MBnySbiAB/b9C0Sh/DxYYOFyAg58oCCgBZjHNjQkmQ2MauBfsA + oTHAfKCK3eqP/kBkRHv+HF2J/kPFUcPrS4Ak4BdGaOgmwSl9oBhvY+OIBBX9Z0RBQi+0CtKlB4ATBfQJ + QDSH1AvXX0VFUu4M/OHaXZFNMaNhPEGjCMAEOVUOEESH+UiH/pZYBEmVFYUfzn3IApP+L5M1ByVy+76B + X4desdBK5opkufiBDAxXRhD1lAOmkOZ4+5PErFw4dGQeReopAKQp7yBhWO8ILE9Dt13HTxWnMlYhVUtb + QRQuiBYvWcXyGZymQTAXCfsT1h0zhunAVEkErR6OQNFqVrgB3+MstJuvsBD2jwBuEkUNDby75BqwCrDG + 8xd3ssC9Db0pA9PHGDEhbaIgupsIwLSTTccKem2mUo/RoVSUJs6npPB0Amq7dibUgq/CRow5xVYknjAC + xx57X/DVaYml6hjnk5+odxqFf4Ed3RQWxoPJogIeFviKsLPWEcp0Ag72nqPAHevdPANklL51FbjBz+tA + 9mkuuqgtyBmqjNdx15C01j9AwbyPlFTYIFLTu8Y4C47D4tD6ZlAoMK0XBzQtCisHon8m/SwGX14D+pIm + Xgd5CXqWg341sV1OsmEksC6mEOiAdyLQx+Gh9+nFQXvFyawoeafAQJavg/8AEKsyHFoCTGPDTyjpCqsp + o2UYL5OChvyLLs3ufgM1dEJi7rLas5NG4v8Aln1ACX+/MyJnulxgQuafSQI+k45fxaCLv9AswgdloBiF + RVxAjsTwDVVVn4BtKGCjJPw0eskUNTP1pHyskOh8WgCeJoo6cPAEIhPNjPgIpPKh4dOH2Ml3d/EbKBeC + NAYpNc+jFJN6DodQOe2CtoWiUZBhlJXpoW87xEOjyHOMtvZL2XHhWClMi3fTuoMtJmwHCJmPMcM8tIUS + I6fAICD+PdRd0JZzae6i4oHTBIQxG0gWfskGP8ffwSSkNdD1iQHM7BAE8ALqBidGklt/QhbCDq68gApZ + tEeMQl6df6UBwUqXC/nX9LYVAA+4Ix8SB6B+chHM3iBCVd3duwh9S2ezQ/wpe0kdiD5oLBSFqRJ9yram + 3KQ3+4TNzbw4NizQYe0A6hBHonFFL8hcKiBnNdMQyfZdVgQYY06mTFtp6B+vpzsAD8If7zA3W9d0AFuJ + kF8Rtoe0REWPpXDM8qALZRDEALLEbOYSXztmhSi117bDY2xVkD4W1AtW4BKYCgySB5oJjPxMGooO+9Zh + oFw3hFshd4E6RQO3cgLkBeRZj8lQAqJl1AKd1AYQVAw0YJiFFpqqmhhgvkJ2JTwe1ywxTCQ2LnhVg/8A + nQ+xGhF5bb45SFJxKgRWGCTogp30zxoDKBPTVcj/AAGtr6ZLBXs7EWFNYseCvzWLwH2Gn7rzleDtORMo + gFLPPxvEAsnpE7Yvz4Io4HbyOAH6Ap3EADMjD9woCVSygfANHSUff6+ELWGFOfNH5O3YJLDqoZ0mmRdA + BiVhzziAm4vQSpCsAVLbtlxApnBRXMG6aCkL7TvlcMwxB3XkHZl9FNMI7jtxIjYzaB/wdjoRfGTg97CA + u1k+3CoyPQY5Qtw+csA3CQx6GlUD6XZB1AFaaUvIVCll/pMw690F+iHQLOIAjnN5eoBBAR3BL1ALyyAh + En/oMkQkytE4Ca7LlhDB+CNtt4XiC7/8YK2gEoCNJowDWhiFvITyiDvEwJzEnq0CkS7gAIZWP57BO5fV + jQjfYdUDJ44H+l9gXPyXJoV2DQd9E7CXa0gRCQ4ET/FaXglXiC+mWZoXPSBzuDHN4DrRe/oAc+sOYdiA + C4SRMUWFEmyEhUwfi0oWn+pW0iM7011VZjHH7QTsAqPDF7QTVQ6mCrYIsECOwhj3HIHeg1EDas/AGy4d + eEbH5AVIqgIBKDZ6JaoCLPBIQtAFcQIkm0xEaCNzF8A7GBQ5Qi5PouiaEG7t3XPHADepIkwgCMxky+1J + wMvkg7jICvfuc0LUghcbSEK+bzja17KwlmUBiaw8+UBa/fJ4FXGgrUBUA7dsDReG6Eg5PCgAV/dMTsYl + 9OE3bVBAnZ8xBnShU9dUC4qG0fArNkfoOhf8ggrMsBKBF5eO2wZpSzj+sKj+hRPsEdnRo2EF7ivQioHc + PTEVtaQheugJrHM6PIinUJNKEpg4VYE/eJ4XXaMD5NsgOfxEiqNlC/MfFgPAwy1AcKtgRsJFE52BvHRC + BXJWx5GTW3olYi+MJWDlPowE1cwJHf8AEEZyg/gUjKqRRI30vUf0kdkQ0+APNttL8v4XXEMTQgGSt9UM + iEbQxMV/fOyoWp/skbWRFmZuGPBS+9ZIK/YDgg2zv/cxdzOqMjdopNdduNbGQRZ2vUAEw4QCuS4BHF8+ + QIL/APXG4J7MAa/aGYOARa3N0YIBabCKIpXgOAC2WxHTlAxM+ZMHN5LtdGQq0tyBZpi0oAKyQNJW8NFR + J4kLekeGAPv03B0A+0JJOpQ/2ARygm81xU0BTpCTsFo8EHKOqY0gY2jc0cQzDsUw7LIB0+3HjkqpCXx+ + jUaAPOJjEvAGsLSAGPLSWegO/AUCCJ9Iv2CBLSwiC27o0QXDlDGFcPUIprCqPY7Db0WAB+DTYAq+CeMB + N9G6hKZX3ZkAeq66iIl+myP1jbQCm/SERuc9zBdIqIFuiBNwk0aHVH5MUJKZHVAUOZMSABTbccsV9VAG + b0qYg9rGkx3mCgOIVkEQCTXISqcHsMdglkmTSOiPS7B07+J62DqlpcAg3SZZO0eeVwXPx0IG4AH0H3YH + 1qAGeQfyL+nadiiI7AY2u7zZo043+jqKTQqh/rvAtR0eZIZLxvOQEtfDZxMgNYguMVSr8IJmoKBpz1iE + 42GeJIb0y1thEDeBsaWNaPeAOj+UgLagmcFg6RM1sDELStrgHHrsuiTbI7dWhF5qXelczkFX+QQBaXBX + JWz0Ag+zra8+gA1IWjdxB6EAmzzaQVL4PT7GAVSOK3IAZmwvgHngnguITnVfftCGG4mi3b4PjC4XTkNA + mDnRANjvniWlCDRUH6QXAKOAF/8AXRiemBGvR9icDse6MeuKWhBEXrQiH1AYB4IrhVaBKjX1XVIdf+C5 + lhaB7VCxRyMTQvIn6h1LCmlUeA6xPQxcgmELDRWqIJHM76SHsOWgH1cMPccHEBE/S7wI9E12cSqofUS/ + IryJi/zQ1afjEN5/fqDjvNM6CC/rRAbCloyKNFJDdGIH/wABI4FHuFb5AJIyBU4xaJRRJoUqgCROOSru + pdJu0/ALfKJKbgTxu+ncx5xLDfRyIKGD4kSJsd9/kEmytanbKGIEE4BZOGhwF+oS6sKtq7ivWBUqTBAr + FRCP89xwwLE7gR2jAYpjAMHiERrIWsbgjJUoCrdEyqHyGg+PsSHZ+KGAA0r8u2mDgwOT0FX2mgIvc1lE + hieHxBNoQpoD4KCuwhfHiGsRukFfawv2IzuTkYUboZflsV4zlnAF1cAoUUyByMvGwj38+lUwXpei3Aj1 + esoUPw0bQCKiBFxhSkwqBvp0jAFyCMG6Ekr5akTyLXDiKvfS+6skgTBzUGe+1VzcIrX4EJK8JGFIJE+Q + 7PIWB3ib1ToiAOvlzAh6bTdyKknqaBUA7g8z9ZwPAkBBxRIK/wB1CVwV/EBMuhBNXwHoTosb6wDM2YSD + W7g21rsNNe7o31D2gVemeJqQeS8NQjwgl6UUlAH2P5IJj/HtRw6mEhIbw2qhG0qTt0IBk9j09o7KvOH0 + M5hU8UgVOQIW15PLQK79IiKBOawSsNeEMnDio3gAB1IojABHy0PgKuHQOnIUQ0aAX50gA5kobjAs3vxr + dwAK9bZo4n+vEBUPICmz+0NUBwHL66HQDgMwIaJs9APNbIITkHAMbN+0Q2bCCcuDV9Tbo/5DUIYjkJRa + RBdJdMI+W3Hl+FEg3C4ral5CIUp4KHaWO00HStLb6SeunCs5AH9z6zugw0Q+3GjQmB+1X12Ky3AEDWFl + HggEdngDdAitVkiICq/O2VmpE5VD9ivLilYsCV6+RHMiouEyW6yVpVOYRYZkdWcSAvshlpEE4UnK/pXO + MlNB6Za0KQ0nfb0NRAhIDqRBf2+mYdaC90Vmt5FdiYLT5G+fqBI96amKcwBCl+uTLS8CeNdhhC3vMfLY + I8sQ8919AvXlYjjFhEDClny6MI6nGwBa94ZILQxAB2a5l8z/ACBbfgPSlHXDboKUk/qMUBaT/G1oAvVg + HR4r9QxZv01YdqbaBQjUQOAAcJWgD0lYc3gjayYeb9+oQ1HM9SAcmtxW1vv+S6ZVFb2T2AHYMC7X+uQg + rIdyVYZQ8QrKMpmCOrYwiuxxE6aIHgXyRHc5EzVr8FOcw8BHklLd0CjzkMBp5ZLEJeUEo1MQQiwxAK3J + fsBAG1P8kwQjEOpUghwgTwEDJKGwIzHXuHERcR0pL8MgHLVKATBZSnIJgqsUAew7F0ZV0gCbNoYVdzQm + ehvO64IbY8EuUbrInCsv9mEbAOW60EeCTFwK7DADvNQ057ToXdkCN8mYl6CZeqGXBtZZcYyVu1Bb3qj+ + AHAPCLoC9s/sAiKiDRAky8FvZzIFLRTa2QBbmgCXxBSAXW8SAUpUGgqr9RNlBDAXnbOC0/B9Nhd2C/Mb + uYJeBMesdTSIKNy0zQkrMmMbOwZKyOBMEyb0rtcvgFGNNMC+qgrmWHAJ/ETUJ5dfNEuKgmYlVZoREdMg + Eor5nQQcq/DtA/R0EXlUgxu2IL+QQBWeQhuXswRG/moKpc3sCvIjf8LDINhmdQSw3jmGDQTlzmxpTo5m + nOwIIrLoEohskIFS90BaB1RT09AFxzZNGxJUrM5REkuNq+RJrfRjgSCUmjyED+IRoAy1Mr1tNEgFEl0a + SOoSs2EV/pAJn/EYisQsARHqE8OnUPotqG36fHnOx3whPLuDmaMOEG0swoddSSJ/D0P4EhxnzAjS9CJ3 + 2YzYU6mRSdR+WO/HAxX9NgwCr5oRQTA3CCjE1ACRBYSEZP8A6ZGw2YGElSo6Z/IJxusjoC+2CzFlWBog + lDNopKS5MLM1aMidQ1n1IftTwzCfEVRcnoH31zhe+Fx+AZ6gxGWmhtwnQ02uWNOT6jDHcHtHACX67gSg + nGB9tHtfsBtnwDVKKfMMIzgn6Wh+/Y0xfrhDwyAMH5hfYAcToP8AT7AoiyPBKSJx/wAzkqMJSEaBbpUb + fGjwFZ8SosKygUCelYA4zElmQ1gdRL/8NjEoQfsNLooAFSBMCuDBEOiipz9JH93qaTqszf8ASaWtnOyR + 2sHKqHSgkKThD93gpcKkJiFAx46hD1KnIhvkG5kwBPpxL5iogU9tJFa2W0GHeRbL8kkKUAZ5COO0sPJB + ILRW4IeSUd0RQIZwUr9yQoG9n7AVJYYTSV355ACoNYkK7f8AJgXhM7tGkItA0WNH8AX6y8Gjw4VAYfjq + PEwNIqj6WP7FNOWm0Ew/FNSRF3DnQUP4ggbRFPS8Y7p5J0EqjBtdXMbLH6JHBPjh1MoP1QfcviA0bfEp + 59qUI6dxmJaPo2K4UQZ72YnwH93GlPCkCCUAB6FRNHzVMLEwNQxRKhEaiQL1BRFBooCESXN+QYAd9YXE + gEMk+YwvHzrzcLyEiu1j/IjaoAV7vKBWuAFKJ7YMxQG8JQpZgDwFX74feQt5x5MqT2GxOp2Z+EBtmLed + xzyhv6PQpQvHH5iPVUFdhWpDXeATET0CtoxI2YnhcP6yADucItP+uRexaA85IsaMm9WkQ+coOs8jP0Cf + QkGSC23QGoBFf64LpekmYGHGmhewnPkKZgyRHQnMOe0i/AduoFmA8yLZ6ANaVMvLkV9Qo8Wu5sOiZldS + QeQOigII3BRnaZINIElp5k4SFpEW49CWsWJRkKQ4ytA6dd9zFRog5RMjED9BhFUQMAoB3vWZGMa6dgis + TOaPgLZhD0Qp3YFYiIghAQNc1vAvyEMqNBo50YIUClbIfcbNAU2pQ5Ez45b3Ea3shZwGQEoBGj6A/g7B + N1aIjuBA0SmQjAKHU24Q7vpOGkTWl2FVHYGdWjnU5LqWVgAWjM9b7iRS6ZLosSgsRG419AoATpRuaTyW + SSl1oLOpCxkmiSAaWd/sAui6sfRvToLt5BnpaExU0CNtMIBW1CaPlwVZzhE3JCXg+JgBpaEyBocCC30g + C4kJbAotsi6kQK3ufpjqi4MgVwgnHMiNaHoPoCJaXFIXHRACRrPsvoxrSSOTyl8H4NzIG+iQZHggfRKk + qmU3IFUxcWsBrel7GAqDEcQZbhLSCr5gAABHDubbWrAAAXYmBYCUk9oNZR1DCyAzCMFQKTsE7f6NUHIg + 1zYsfBIwvDJmmQJRehki7xWBNOS8lhROCPWj9FYWhSWDu9ZfeWCNJmKe2bjY+ugxfWIWEQ/A8AI/sDnJ + gI9UetCB3fXhoZlpE/8A22gIM1uBL0OLgdpY+1A5TdKaRog49QCvbZIjpTAP1FSloSJvQeLXbgV9gW5B + VmQwwUgzW5SqF9Txz9hYcMBzIOwl9wddAzpr9GiN3NoJylUHf9AR+jQ4n4iRNA1IZuaTQAlhE4K4Fu0d + PXJ1HwGbpXSkJAjqTwCdwkyBL0Qdht4egRa7+ULa4AgR93VcAoG0g7YQATH1kZYCJ8xsIBz+1ILj4AAJ + rjy7yCDJsC66AgADf+CBkgtw6rk0BD3tcmCCS2dlaKeQqadhQA5GxGkLg6dEbjloPA2ifE1a0RE9KtR3 + YaDJSJH/ACAD3IohJvX6Q0rZXvKkgK3K/wCAARd3WDRibbxERmh4DJmqBNthngiWejAmvbuADt2bEPz2 + GgqQ0Yc4rjFGhCH3aPcscH0fwQkEFtYRPow/Gvxa4DQV7UlwKZS0J+FSQP8AHj9NijHOB1ElGwEAjscq + wFysmcCHYG8Q2AoqCcDTg99OqTBSdYVIhqEtJtcvglh/evwH5qYVWokYPsLCdQuziQExd7liL/CII4gQ + wpdw/ofckptBAuMC+NAL3ekIAY/5PMVQADKNocczBigsJRb56KCCFekmcRANqeq15YFwAAkM2NYqAVTd + RuKaAMgu+VcCwT0kiD4dTLcArjYhThoMjDhCe5klgXMJgF4qeoIhsJcFqFPIZl7ynfAiTosKv/AQgTop + RchpDlKTiJAsfMA2OlNH+TEf2dcA9gmU/hNpVkBesik5kLnoZzqeAbFoiDHsN7kDUX33wI7H/BC1ia+p + ONRyB8iIopmCvd7caEkZgeo0a4XZ30QMiNeE6+V6hPZ6TV4qxngMtxm5SdF2Ka6AemMkkvTTGI15BBGs + V4QE8NeYqPo2gDaADfsxg2oUghZXXU0ELaArQxj2iWc88HQWQTF8EtlxEhOS5xct2Nh0vF4D9r2tYAPs + 5wZiwAAccJ/uvpiArfTKVR2AAAq0UtcMACRZ7YIcnUMVTrJzvIAu9TUrgCAAAKbyCMdAAADrikMJEJBc + 5ktoebmuHRzXl/kDVkFdDoOD3TYnIZcQxpeDYdAygfYCEVZDh/sIRz9w6D9V+GAzNGHoz1xEbzRoVs0k + 4h0jQrAKbrsRH69WA+vVBC4JOpSUArC7MELJrwF56XMSANt74lCe4HAcjUb73AB34BITUMo3AbgLikIA + dAEwuwK+vFHAxgqSiZ8mPQBSeKLnSCJ/GZGW5ZmYhfeGbY04DApC/mAOawypSN87zVs4ATcobpKJCJrg + RBJAc0UdYYBvNFixQASftEHmm1JIgQ78kgWckosT+BLOnBDPwEHVB4vS6jTwMAaHfIb7UvAsHMYcC/2N + NRPRRecOraLV/WnkUZu3Ke2EAOn/ADcNUKAARipGr+JNxgALDd4SwAXQIi88NVP0EDlxqIfcjJAOrvcK + HAMmjp+4osCGc1voXCAAJBpIWIagAgYt38zaAAr3eFsLcwARM2D8+9xmDuwjeGmF4KEUt+x4dkRDuSaH + oIYzC5G19xIA11fd/umD+DihKdnBSA2DU5ABPsjN42CCf6MfqWU5kdrqKjYIqMeW6oE73CmrCCNmdH18 + ivwCEuDHQML6SScvH0domm4dQRBXj4H4bWUyYbehDBFIPUi0WM0jAFX0BBcXQLTQRfIateqjPQ2Y59MG + HlyIn0EqYCq1zINih4gkG7sDe/LSAwo0RAKo25NpBcANiyM1mUpawSKm5FK1BA8ygrFVpuIIY1oPZxb5 + gBQckh8FkMSoH9A+Sg96o1hKUEQSB7QEPrkNoxb3vf1qomFhwO4NEu8U24gLekiGbCWhyaEwYxDuGwWA + CY/iXmZJKiC+FtQwFJ4us74Acqa/Q9cAAAFza4+7iNgAE0fFPUlATG7+Z1haBQIrRS/DzRuq5jrAAIAy + VCUgIQEUrWZxCAA0IeDEwFzGO0HB86tNLnSRd7ArnywMaOwG+5gBfAiZBh4u743ogRqXzmH49eJ9/wDz + FG/xBVu9KdBevNmueE6O8E0NP+SmoV1B86MKoPYQIuJh97ltEW8BFQgdPWdm4YBNXxhpZCLSIxY00tHP + bCudAqrxJPsAJVk2KAoxw0S1QQ/FLS8dJP4Yot9yJSF4oYY3kGPS7OAfMEdscjbxIJvb0RfZi0q8AzO8 + mEjMvXrv2gep/wACMndgMIBjboFbGU9QIQXUShh1mhoIIvXd7/z9IedJBoYCXXFegqfeyaPQl6s5Bw8B + yq696NgRW2bN7gEKVdnm+FzZAICetJWwEEU/61YtoIwwjfQyGwEjI6VgkkI28YYNBstVJQyuQAKU+uZo + Kp4AAis41QdcCxjYqRmHWAiUC9mHOYLnWSIv0I2J15mdg+juHmimwW9A1L6l/YW0tOBIkCj/AAi4n4QA + n9i5QHs1LDwKNIhAWWogFg3ZnFBG3yw4wP8AGOIwgDatlc/BE0yMYAJT86L0jXa53CXIwTkHSe/CXnTA + 4VTEoIqr74RgqTaLIMNLET8siJMTFcQBOyWoUE1A3snFIjDqBjaZgHa+TKCN0jlVQnaVwEkcrfIE/jF5 + MPKcECFdWES7ANbCzJoRu9YBNbkQBIsPxnecIzGGzEYLoIO57aWQKzo+LVJlp1WX3QVy22HW4H2k8A1g + DRIjQyx0TvO/LQgw+QZAST9sSc5gAZSkfl0wDESkbW/AdkwAxfMIpgAQ52mMeAAgm/3aDYQdeXNp8lCL + IAD6k6cwWIAAxa6ibyIdwAQtSG1R58wABGF+oglYAO6NStB7gMOoXmTYVY3Afdt8zAKP5KJQKrMI5I34 + d3gdIZDeGFJmKj/ICuBg6Hf1bUSK1basFFs9m7qGiPrOoAYzehp2DPJKOV0+gn4wK4QKA6hPIw9L+Ap9 + ge0L0yC2nC+oCnag0Gi2HwFhSKzLoKWOQseIlp63iCWABDV6Aq/DXOLV8tx/7Ars6rCj35cJ8oRWYnR9 + C9zSnUVeuBy0WiJ3sqEhrBakWPSz9tQQOfAJ48mjN+GF7LhEbJcoPNE3mgxo5PqBUqWlVDAtGGN0QAG0 + Pldsgk8v7DdHMAA5pPodZ6wAAL1qD7xgEAiXAzF7BghQAxt77kYAGnvzO2awQBae3JoEAUEqE3pMFS3r + SLqQRkAKRjpG4EqFCA6fUDuMFA3J8dcwEaLwSMSTGXlbwc8QVDeaziCgvevjYmWgma6HzCogy6ATJ81o + xCmISLU047ugXNxCfkHQMJ40kV3SAd+sSIyfHFQFPQivouBXqwgZoCyBIodxOwSmFUYAowD4J7eng6Su + EiSEs/EJsqxUAnMM6CHCADxXhOITjAqgKEYPOEBYQZFYH/wC0Co5b2aWCUT6KCEy9JNeMMdz3UoxoaGW + +069BN/0QW3HhLUomKe6bICX5qhiEA4r7l2WBkAJa46oKUFCC5/aEyFxQyEJpVcX00EEQ1yzJUCojEFY + SxoJkwh4/pB0tAVGI+QYcU5UgKlycg5MFsf4YihhAFm7yeIH2aZskzjDTZYBhThgjoWXKUggB9uJ+qhA + 8g0/jQ2SLcpTEZlixIU1UYX0D9BGvvcGGNMBuVuGMV8GKIcjjT2/cE+Mn8qCfgA9Z+oY1+Ios+lR84/c + VuADHdGRAdSxsR0bgKWb4QfsggRovyQ+3xKMAr5YELSTSQ9EsCH2NucCRTV2MAf/AOGgIgfAILQicCDE + Q28D8SLrSgI2xdhIPrAXTRfojsRHk6CG6Q3yaPdx1co6lU+YYU3a5IGOVD3YRaaaMi6V0sICApKy7Koe + 4ALDfBly8CAXUpXPTk5CAQkk1ku60A7Lr/OhE2iIG1wCtaQekqiD+b5ms50in3+wQUIqoOx7DONswJtk + G4UgsNBj6rcTrdMihb4DGVyloGm6IGQui1CDLw86G7ULyte2Lg2rUfqFAW8u4ra0orECm+GRKIWlXDG0 + J0GcVMsL5+zFOhDEtxIEJHGldJQs87gHHb50FJD0YsJpSFdByKSipQZdM0+0RZKS9UwO/R6GBGBZWjm0 + wDKOqPo2BVcKRpWArg6PqP1YZ7oWU2rexlCqvXmwbJr9wTTdCS6SulwHH9C5YDyaNhqr14Lw2RdEDeps + sR1OAsJVrCa8OxUNsqfNiNt8prdBNnUMkjISNXQs9V1VjsX9CwHsxYokem+Re32p/9k= + + + \ No newline at end of file diff --git a/CompShop/CompShop/Forms/Products/ProductForm.Designer.cs b/CompShop/CompShop/Forms/Products/ProductForm.Designer.cs new file mode 100644 index 0000000..a920501 --- /dev/null +++ b/CompShop/CompShop/Forms/Products/ProductForm.Designer.cs @@ -0,0 +1,103 @@ +namespace CompShop +{ + partial class ProductForm + { + /// + /// 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() + { + productsDataGridView = new DataGridView(); + addButton = new Button(); + editButton = new Button(); + deleteButton = new Button(); + ((System.ComponentModel.ISupportInitialize)productsDataGridView).BeginInit(); + SuspendLayout(); + // + // productsDataGridView + // + productsDataGridView.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left; + productsDataGridView.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + productsDataGridView.Location = new Point(12, 12); + productsDataGridView.Name = "productsDataGridView"; + productsDataGridView.RowHeadersWidth = 51; + productsDataGridView.RowTemplate.Height = 29; + productsDataGridView.Size = new Size(851, 399); + productsDataGridView.TabIndex = 0; + // + // addButton + // + addButton.BackColor = SystemColors.Control; + addButton.Location = new Point(878, 12); + addButton.Name = "addButton"; + addButton.Size = new Size(161, 60); + addButton.TabIndex = 1; + addButton.Text = "Добавить"; + addButton.UseVisualStyleBackColor = false; + addButton.Click += addButton_Click; + // + // editButton + // + editButton.Location = new Point(878, 87); + editButton.Name = "editButton"; + editButton.Size = new Size(161, 60); + editButton.TabIndex = 2; + editButton.Text = "Редактировать"; + editButton.UseVisualStyleBackColor = true; + editButton.Click += editButton_Click; + // + // deleteButton + // + deleteButton.Location = new Point(878, 163); + deleteButton.Name = "deleteButton"; + deleteButton.Size = new Size(161, 60); + deleteButton.TabIndex = 3; + deleteButton.Text = "Удалить"; + deleteButton.UseVisualStyleBackColor = true; + deleteButton.Click += deleteButton_Click; + // + // ProductForm + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(1051, 423); + Controls.Add(deleteButton); + Controls.Add(editButton); + Controls.Add(addButton); + Controls.Add(productsDataGridView); + Name = "ProductForm"; + Text = "Товары"; + Load += ProductForm_Load; + ((System.ComponentModel.ISupportInitialize)productsDataGridView).EndInit(); + ResumeLayout(false); + } + + #endregion + + private DataGridView productsDataGridView; + private Button addButton; + private Button editButton; + private Button deleteButton; + } +} \ No newline at end of file diff --git a/CompShop/CompShop/Forms/Products/ProductForm.cs b/CompShop/CompShop/Forms/Products/ProductForm.cs new file mode 100644 index 0000000..7e330fa --- /dev/null +++ b/CompShop/CompShop/Forms/Products/ProductForm.cs @@ -0,0 +1,101 @@ +using CompShop.Repos; +using Unity; + +namespace CompShop +{ + public partial class ProductForm : Form + { + private readonly IUnityContainer _container; + private readonly IProductRepository _productRepository; + + public ProductForm(IUnityContainer unityContainer, IProductRepository productRepository) + { + InitializeComponent(); + + _container = unityContainer ?? throw new ArgumentNullException(nameof(unityContainer)); + _productRepository = productRepository ?? throw new ArgumentNullException(nameof(_productRepository)); + } + + private void ProductForm_Load(object sender, EventArgs e) + { + try + { + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + private void LoadList() => productsDataGridView.DataSource = _productRepository.ReadAll(); + + private bool TryGetIdentifierFromSelectedRow(out int id) + { + id = 0; + if (productsDataGridView.SelectedRows.Count < 1) + { + MessageBox.Show("Нет выбранной записи", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error); + return false; + } + + id = Convert.ToInt32(productsDataGridView.SelectedRows[0].Cells["Id"].Value); + return true; + } + + private void addButton_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при добавлении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void editButton_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 deleteButton_Click(object sender, EventArgs e) + { + if (!TryGetIdentifierFromSelectedRow(out var findId)) + { + return; + } + + if (MessageBox.Show("Удалить запись?", "Удаление", MessageBoxButtons.YesNo) != DialogResult.Yes) + { + return; + } + + try + { + _productRepository.Delete(findId); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при удалении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + } +} diff --git a/CompShop/CompShop/Forms/Products/ProductForm.resx b/CompShop/CompShop/Forms/Products/ProductForm.resx new file mode 100644 index 0000000..f298a7b --- /dev/null +++ b/CompShop/CompShop/Forms/Products/ProductForm.resx @@ -0,0 +1,60 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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/CompShop/CompShop/Forms/Products/ProductSettingsForm.Designer.cs b/CompShop/CompShop/Forms/Products/ProductSettingsForm.Designer.cs new file mode 100644 index 0000000..21650dc --- /dev/null +++ b/CompShop/CompShop/Forms/Products/ProductSettingsForm.Designer.cs @@ -0,0 +1,156 @@ +namespace CompShop +{ + partial class ProductSettingsForm + { + /// + /// 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() + { + saveButton = new Button(); + productNameTextbox = new TextBox(); + label1 = new Label(); + label2 = new Label(); + descriptionTextbox = new TextBox(); + priceNumeric = new NumericUpDown(); + label3 = new Label(); + label4 = new Label(); + typeCheckedListBox = new CheckedListBox(); + ((System.ComponentModel.ISupportInitialize)priceNumeric).BeginInit(); + SuspendLayout(); + // + // saveButton + // + saveButton.Anchor = AnchorStyles.Bottom; + saveButton.Location = new Point(157, 436); + saveButton.Name = "saveButton"; + saveButton.Size = new Size(94, 29); + saveButton.TabIndex = 0; + saveButton.Text = "Сохранить"; + saveButton.UseVisualStyleBackColor = true; + saveButton.Click += saveButton_Click; + // + // productNameTextbox + // + productNameTextbox.Location = new Point(152, 36); + productNameTextbox.Name = "productNameTextbox"; + productNameTextbox.Size = new Size(210, 27); + productNameTextbox.TabIndex = 1; + // + // label1 + // + label1.AutoSize = true; + label1.Location = new Point(12, 36); + label1.Name = "label1"; + label1.Size = new Size(94, 20); + label1.TabIndex = 2; + label1.Text = "Имя товара:"; + // + // label2 + // + label2.AutoSize = true; + label2.Location = new Point(12, 83); + label2.Name = "label2"; + label2.Size = new Size(134, 20); + label2.TabIndex = 4; + label2.Text = "Описание товара:"; + // + // descriptionTextbox + // + descriptionTextbox.Location = new Point(152, 83); + descriptionTextbox.Multiline = true; + descriptionTextbox.Name = "descriptionTextbox"; + descriptionTextbox.Size = new Size(210, 132); + descriptionTextbox.TabIndex = 3; + // + // priceNumeric + // + priceNumeric.DecimalPlaces = 2; + priceNumeric.Location = new Point(152, 233); + priceNumeric.Name = "priceNumeric"; + priceNumeric.Size = new Size(99, 27); + priceNumeric.TabIndex = 5; + priceNumeric.ThousandsSeparator = true; + // + // label3 + // + label3.AutoSize = true; + label3.Location = new Point(12, 235); + label3.Name = "label3"; + label3.Size = new Size(48, 20); + label3.TabIndex = 6; + label3.Text = "Цена:"; + // + // label4 + // + label4.AutoSize = true; + label4.Location = new Point(12, 285); + label4.Name = "label4"; + label4.Size = new Size(38, 20); + label4.TabIndex = 7; + label4.Text = "Вид:"; + // + // typeCheckedListBox + // + typeCheckedListBox.FormattingEnabled = true; + typeCheckedListBox.Location = new Point(152, 285); + typeCheckedListBox.Name = "typeCheckedListBox"; + typeCheckedListBox.Size = new Size(150, 114); + typeCheckedListBox.TabIndex = 8; + // + // ProductSettingsForm + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(409, 477); + Controls.Add(typeCheckedListBox); + Controls.Add(label4); + Controls.Add(label3); + Controls.Add(priceNumeric); + Controls.Add(label2); + Controls.Add(descriptionTextbox); + Controls.Add(label1); + Controls.Add(productNameTextbox); + Controls.Add(saveButton); + Name = "ProductSettingsForm"; + Text = "Настройка товара..."; + Load += ProductSettingsForm_Load; + ((System.ComponentModel.ISupportInitialize)priceNumeric).EndInit(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private Button saveButton; + private TextBox productNameTextbox; + private Label label1; + private Label label2; + private TextBox descriptionTextbox; + private NumericUpDown priceNumeric; + private Label label3; + private Label label4; + private CheckedListBox typeCheckedListBox; + } +} \ No newline at end of file diff --git a/CompShop/CompShop/Forms/Products/ProductSettingsForm.cs b/CompShop/CompShop/Forms/Products/ProductSettingsForm.cs new file mode 100644 index 0000000..7fe0b45 --- /dev/null +++ b/CompShop/CompShop/Forms/Products/ProductSettingsForm.cs @@ -0,0 +1,104 @@ +using CompShop.Entites; +using CompShop.Entites.Enums; +using CompShop.Repos; + +namespace CompShop +{ + public partial class ProductSettingsForm : Form + { + private readonly IProductRepository _productRepository; + + private int? _productId; + + public int Id + { + set + { + try + { + var product = _productRepository.Read(value); + if (product != null) + { + throw new InvalidDataException(nameof(product)); + } + productNameTextbox.Text = product.Name; + descriptionTextbox.Text = product.Description; + foreach (ProductType elem in Enum.GetValues(typeof(ProductType))) + { + if ((elem & product.ProductType) != 0) + { + + typeCheckedListBox.SetItemChecked(typeCheckedListBox.Items.IndexOf(elem), true); + } + } + priceNumeric.Value = product.Price; + _productId = value; + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при данных", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + } + } + + public ProductSettingsForm(IProductRepository productRepository) + { + InitializeComponent(); + _productRepository = productRepository ?? throw new ArgumentNullException(nameof(productRepository)); + + + foreach (var elem in Enum.GetValues(typeof(ProductType))) + { + typeCheckedListBox.Items.Add(elem); + } + + } + + private void ProductSettingsForm_Load(object sender, EventArgs e) + { + + } + + private void saveButton_Click(object sender, EventArgs e) + { + try + { + if (string.IsNullOrWhiteSpace(productNameTextbox.Text) || + string.IsNullOrWhiteSpace(descriptionTextbox.Text) || typeCheckedListBox.CheckedItems.Count == 0) + { + throw new Exception("Имеются незаполненные поля"); + } + + if (_productId.HasValue) + { + + _productRepository.Update(CreateProduct(_productId.Value)); + } + else + { + + _productRepository.Create(CreateProduct(0)); + } + + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при сохранении", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + private Product CreateProduct(int id) + { + ProductType type = ProductType.None; + foreach (var elem in typeCheckedListBox.CheckedItems) + { + type |= (ProductType)elem; + } + + return Product.CreateEntity(id, productNameTextbox.Text, descriptionTextbox.Text, priceNumeric.Value, type); + } + + } +} diff --git a/CompShop/CompShop/Forms/Products/ProductSettingsForm.resx b/CompShop/CompShop/Forms/Products/ProductSettingsForm.resx new file mode 100644 index 0000000..f298a7b --- /dev/null +++ b/CompShop/CompShop/Forms/Products/ProductSettingsForm.resx @@ -0,0 +1,60 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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/CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageForm.Designer.cs b/CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageForm.Designer.cs new file mode 100644 index 0000000..5a3fe52 --- /dev/null +++ b/CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageForm.Designer.cs @@ -0,0 +1,90 @@ +namespace CompShop.Forms.ProductsOnStorage +{ + partial class ProductsOnStorageForm + { + /// + /// 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() + { + addButton = new Button(); + productsDataGridView = new DataGridView(); + editButton = new Button(); + ((System.ComponentModel.ISupportInitialize)productsDataGridView).BeginInit(); + SuspendLayout(); + // + // addButton + // + addButton.BackColor = SystemColors.Control; + addButton.Location = new Point(881, 12); + addButton.Name = "addButton"; + addButton.Size = new Size(161, 60); + addButton.TabIndex = 9; + addButton.Text = "Добавить"; + addButton.UseVisualStyleBackColor = false; + addButton.Click += addButton_Click; + // + // productsDataGridView + // + productsDataGridView.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left; + productsDataGridView.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + productsDataGridView.Location = new Point(12, 12); + productsDataGridView.Name = "productsDataGridView"; + productsDataGridView.RowHeadersWidth = 51; + productsDataGridView.RowTemplate.Height = 29; + productsDataGridView.Size = new Size(851, 400); + productsDataGridView.TabIndex = 8; + // + // editButton + // + editButton.Location = new Point(881, 78); + editButton.Name = "editButton"; + editButton.Size = new Size(161, 60); + editButton.TabIndex = 10; + editButton.Text = "Редактировать"; + editButton.UseVisualStyleBackColor = true; + editButton.Click += editButton_Click; + // + // ProductsOnStorageForm + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(1064, 450); + Controls.Add(editButton); + Controls.Add(addButton); + Controls.Add(productsDataGridView); + Name = "ProductsOnStorageForm"; + Text = "Товары на складе"; + Load += ProductsOnStorage_Load; + ((System.ComponentModel.ISupportInitialize)productsDataGridView).EndInit(); + ResumeLayout(false); + } + + #endregion + + private Button addButton; + private DataGridView productsDataGridView; + private Button editButton; + } +} \ No newline at end of file diff --git a/CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageForm.cs b/CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageForm.cs new file mode 100644 index 0000000..4282b98 --- /dev/null +++ b/CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageForm.cs @@ -0,0 +1,80 @@ +using CompShop.Repos; +using Unity; + +namespace CompShop.Forms.ProductsOnStorage +{ + public partial class ProductsOnStorageForm : Form + { + private readonly IUnityContainer _container; + private readonly IProductOnStorageRepository _productOnStorageRepository; + + public ProductsOnStorageForm(IUnityContainer unityContainer, IProductOnStorageRepository productOnStorageRepository) + { + InitializeComponent(); + + _container = unityContainer ?? throw new ArgumentNullException(nameof(unityContainer)); + _productOnStorageRepository = productOnStorageRepository ?? throw new ArgumentNullException(nameof(productOnStorageRepository)); + } + + private void ProductsOnStorage_Load(object sender, EventArgs e) + { + try + { + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void LoadList() => productsDataGridView.DataSource = _productOnStorageRepository.ReadAll(); + + private bool TryGetIdentifierFromSelectedRow(out int id) + { + id = 0; + if (productsDataGridView.SelectedRows.Count < 1) + { + MessageBox.Show("Нет выбранной записи", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error); + return false; + } + + id = Convert.ToInt32(productsDataGridView.SelectedRows[0].Cells["Id"].Value); + return true; + } + + private void addButton_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при добавлении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void editButton_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); + } + } + + } +} diff --git a/CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageForm.resx b/CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageForm.resx new file mode 100644 index 0000000..f298a7b --- /dev/null +++ b/CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageForm.resx @@ -0,0 +1,60 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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/CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageSettingsForm.Designer.cs b/CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageSettingsForm.Designer.cs new file mode 100644 index 0000000..f6df6f2 --- /dev/null +++ b/CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageSettingsForm.Designer.cs @@ -0,0 +1,133 @@ +namespace CompShop.Forms.ProductsOnStorage +{ + partial class ProductsOnStorageSettingsForm + { + /// + /// 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() + { + productCombobox = new ComboBox(); + label4 = new Label(); + label3 = new Label(); + countNumeric = new NumericUpDown(); + storageCombobox = new ComboBox(); + label1 = new Label(); + saveButton = new Button(); + ((System.ComponentModel.ISupportInitialize)countNumeric).BeginInit(); + SuspendLayout(); + // + // productCombobox + // + productCombobox.FormattingEnabled = true; + productCombobox.Location = new Point(155, 12); + productCombobox.Name = "productCombobox"; + productCombobox.Size = new Size(151, 28); + productCombobox.TabIndex = 12; + // + // label4 + // + label4.AutoSize = true; + label4.Location = new Point(15, 15); + label4.Name = "label4"; + label4.Size = new Size(54, 20); + label4.TabIndex = 11; + label4.Text = "Товар:"; + // + // label3 + // + label3.AutoSize = true; + label3.Location = new Point(15, 82); + label3.Name = "label3"; + label3.Size = new Size(103, 20); + label3.TabIndex = 10; + label3.Text = "В количестве:"; + // + // countNumeric + // + countNumeric.Location = new Point(155, 80); + countNumeric.Name = "countNumeric"; + countNumeric.Size = new Size(99, 27); + countNumeric.TabIndex = 9; + countNumeric.ThousandsSeparator = true; + // + // storageCombobox + // + storageCombobox.FormattingEnabled = true; + storageCombobox.Location = new Point(155, 46); + storageCombobox.Name = "storageCombobox"; + storageCombobox.Size = new Size(151, 28); + storageCombobox.TabIndex = 14; + // + // label1 + // + label1.AutoSize = true; + label1.Location = new Point(15, 49); + label1.Name = "label1"; + label1.Size = new Size(81, 20); + label1.TabIndex = 13; + label1.Text = "На складе:"; + // + // saveButton + // + saveButton.Anchor = AnchorStyles.Bottom; + saveButton.Location = new Point(155, 175); + saveButton.Name = "saveButton"; + saveButton.Size = new Size(94, 29); + saveButton.TabIndex = 15; + saveButton.Text = "Сохранить"; + saveButton.UseVisualStyleBackColor = true; + saveButton.Click += saveButton_Click; + // + // ProductsOnStorageSettingsForm + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(411, 216); + Controls.Add(saveButton); + Controls.Add(storageCombobox); + Controls.Add(label1); + Controls.Add(productCombobox); + Controls.Add(label4); + Controls.Add(label3); + Controls.Add(countNumeric); + Name = "ProductsOnStorageSettingsForm"; + Text = "Продукт на складе..."; + Load += ProductsOnStorageSettingsForm_Load; + ((System.ComponentModel.ISupportInitialize)countNumeric).EndInit(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private ComboBox productCombobox; + private Label label4; + private Label label3; + private NumericUpDown countNumeric; + private ComboBox storageCombobox; + private Label label1; + private Button saveButton; + } +} \ No newline at end of file diff --git a/CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageSettingsForm.cs b/CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageSettingsForm.cs new file mode 100644 index 0000000..22a3f16 --- /dev/null +++ b/CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageSettingsForm.cs @@ -0,0 +1,101 @@ +using CompShop.Entites; +using CompShop.Repos; + +namespace CompShop.Forms.ProductsOnStorage +{ + public partial class ProductsOnStorageSettingsForm : Form + { + private readonly IProductOnStorageRepository _productOnStorageRepository; + private readonly IProductRepository _productRepository; + private readonly IStorageRepository _storageRepository; + + private int? _recordId; + + public int Id + { + set + { + try + { + var record = _productOnStorageRepository.Read(value); + if (record == null) + { + throw new InvalidDataException("Record not found"); + } + + productCombobox.SelectedItem = record.Product; + storageCombobox.SelectedItem = record.Storage; + countNumeric.Value = record.Count; + _recordId = value; + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке данных", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + } + + public ProductsOnStorageSettingsForm( + IProductOnStorageRepository productOnStorageRepository, + IProductRepository productRepository, + IStorageRepository storageRepository) + { + InitializeComponent(); + + _productOnStorageRepository = productOnStorageRepository ?? throw new ArgumentNullException(nameof(productOnStorageRepository)); + _productRepository = productRepository ?? throw new ArgumentNullException(nameof(productRepository)); + _storageRepository = storageRepository ?? throw new ArgumentNullException(nameof(storageRepository)); + + LoadComboboxes(); + } + private void ProductsOnStorageSettingsForm_Load(object sender, EventArgs e) + { + + } + private void LoadComboboxes() + { + productCombobox.DataSource = _productRepository.ReadAll().ToList(); + productCombobox.DisplayMember = "Name"; + productCombobox.ValueMember = "Id"; + + storageCombobox.DataSource = _storageRepository.ReadAll().ToList(); + storageCombobox.DisplayMember = "Name"; + storageCombobox.ValueMember = "Id"; + } + + private void saveButton_Click(object sender, EventArgs e) + { + try + { + if (productCombobox.SelectedItem == null || storageCombobox.SelectedItem == null || countNumeric.Value < 1) + { + throw new Exception("Заполните все поля"); + } + + var selectedProduct = (Product)productCombobox.SelectedItem; + var selectedStorage = (Entites.Storage)storageCombobox.SelectedItem; + var count = (int)countNumeric.Value; + + if (_recordId.HasValue) + { + _productOnStorageRepository.Update(CreateProductOnStorage(_recordId.Value, selectedProduct, selectedStorage, count)); + } + else + { + _productOnStorageRepository.Create(CreateProductOnStorage(0, selectedProduct, selectedStorage, count)); + } + + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при сохранении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private Entites.ProductsOnStorage CreateProductOnStorage(int id, Product product, Entites.Storage storage, int count) + { + return Entites.ProductsOnStorage.CreateEntity(id, product, storage, count); + } + } +} diff --git a/CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageSettingsForm.resx b/CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageSettingsForm.resx new file mode 100644 index 0000000..f298a7b --- /dev/null +++ b/CompShop/CompShop/Forms/ProductsOnStorage/ProductsOnStorageSettingsForm.resx @@ -0,0 +1,60 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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/CompShop/CompShop/Forms/Receipt/CheckForm.Designer.cs b/CompShop/CompShop/Forms/Receipt/CheckForm.Designer.cs new file mode 100644 index 0000000..8c89a66 --- /dev/null +++ b/CompShop/CompShop/Forms/Receipt/CheckForm.Designer.cs @@ -0,0 +1,77 @@ +namespace CompShop.Forms.Receipt +{ + partial class CheckForm + { + /// + /// 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() + { + addButton = new Button(); + checksDataGridView = new DataGridView(); + ((System.ComponentModel.ISupportInitialize)checksDataGridView).BeginInit(); + SuspendLayout(); + // + // addButton + // + addButton.BackColor = SystemColors.Control; + addButton.Location = new Point(878, 12); + addButton.Name = "addButton"; + addButton.Size = new Size(161, 60); + addButton.TabIndex = 3; + addButton.Text = "Добавить"; + addButton.UseVisualStyleBackColor = false; + addButton.Click += addButton_Click; + // + // checksDataGridView + // + checksDataGridView.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left; + checksDataGridView.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + checksDataGridView.Location = new Point(12, 12); + checksDataGridView.Name = "checksDataGridView"; + checksDataGridView.RowHeadersWidth = 51; + checksDataGridView.RowTemplate.Height = 29; + checksDataGridView.Size = new Size(851, 399); + checksDataGridView.TabIndex = 2; + // + // CheckForm + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(1056, 450); + Controls.Add(addButton); + Controls.Add(checksDataGridView); + Name = "CheckForm"; + Text = "Чеки"; + Load += CheckForm_Load; + ((System.ComponentModel.ISupportInitialize)checksDataGridView).EndInit(); + ResumeLayout(false); + } + + #endregion + + private Button addButton; + private DataGridView checksDataGridView; + } +} \ No newline at end of file diff --git a/CompShop/CompShop/Forms/Receipt/CheckForm.cs b/CompShop/CompShop/Forms/Receipt/CheckForm.cs new file mode 100644 index 0000000..15f642e --- /dev/null +++ b/CompShop/CompShop/Forms/Receipt/CheckForm.cs @@ -0,0 +1,46 @@ +using CompShop.Repos; +using Unity; + +namespace CompShop.Forms.Receipt +{ + public partial class CheckForm : Form + { + private readonly IUnityContainer _container; + private readonly ICheckRepository _checkRepository; + + public CheckForm(IUnityContainer unityContainer, ICheckRepository checkRepository) + { + InitializeComponent(); + + _container = unityContainer ?? throw new ArgumentNullException(nameof(unityContainer)); + _checkRepository = checkRepository ?? throw new ArgumentNullException(nameof(checkRepository)); + } + + private void CheckForm_Load(object sender, EventArgs e) + { + try + { + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void LoadList() => checksDataGridView.DataSource = _checkRepository.ReadAll(); + + private void addButton_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при добавлении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + } +} diff --git a/CompShop/CompShop/Forms/Receipt/CheckForm.resx b/CompShop/CompShop/Forms/Receipt/CheckForm.resx new file mode 100644 index 0000000..f298a7b --- /dev/null +++ b/CompShop/CompShop/Forms/Receipt/CheckForm.resx @@ -0,0 +1,60 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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/CompShop/CompShop/Forms/Receipt/CheckSettingsForm .Designer.cs b/CompShop/CompShop/Forms/Receipt/CheckSettingsForm .Designer.cs new file mode 100644 index 0000000..3f5c94e --- /dev/null +++ b/CompShop/CompShop/Forms/Receipt/CheckSettingsForm .Designer.cs @@ -0,0 +1,134 @@ +namespace CompShop.Forms.Receipt +{ + partial class CheckSettingsForm + { + /// + /// 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() + { + customerComboBox = new ComboBox(); + label1 = new Label(); + saveButton = new Button(); + label4 = new Label(); + productsDataGridView = new DataGridView(); + ProductColoumn = new DataGridViewComboBoxColumn(); + ProductCount = new DataGridViewTextBoxColumn(); + ((System.ComponentModel.ISupportInitialize)productsDataGridView).BeginInit(); + SuspendLayout(); + // + // customerComboBox + // + customerComboBox.FormattingEnabled = true; + customerComboBox.Location = new Point(152, 6); + customerComboBox.Name = "customerComboBox"; + customerComboBox.Size = new Size(151, 28); + customerComboBox.TabIndex = 18; + // + // label1 + // + label1.AutoSize = true; + label1.Location = new Point(12, 9); + label1.Name = "label1"; + label1.Size = new Size(97, 20); + label1.TabIndex = 17; + label1.Text = "Покупатель: "; + // + // saveButton + // + saveButton.Anchor = AnchorStyles.Bottom; + saveButton.Location = new Point(125, 297); + saveButton.Name = "saveButton"; + saveButton.Size = new Size(94, 29); + saveButton.TabIndex = 19; + saveButton.Text = "Сохранить"; + saveButton.UseVisualStyleBackColor = true; + saveButton.Click += saveButton_Click; + // + // label4 + // + label4.AutoSize = true; + label4.Location = new Point(12, 44); + label4.Name = "label4"; + label4.Size = new Size(54, 20); + label4.TabIndex = 15; + label4.Text = "Товар:"; + // + // productsDataGridView + // + productsDataGridView.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + productsDataGridView.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + productsDataGridView.Columns.AddRange(new DataGridViewColumn[] { ProductColoumn, ProductCount }); + productsDataGridView.Location = new Point(12, 67); + productsDataGridView.Name = "productsDataGridView"; + productsDataGridView.RowHeadersWidth = 51; + productsDataGridView.RowTemplate.Height = 29; + productsDataGridView.Size = new Size(336, 224); + productsDataGridView.TabIndex = 20; + // + // ProductColoumn + // + ProductColoumn.HeaderText = "Товары"; + ProductColoumn.MinimumWidth = 6; + ProductColoumn.Name = "ProductColoumn"; + ProductColoumn.Resizable = DataGridViewTriState.True; + ProductColoumn.SortMode = DataGridViewColumnSortMode.Automatic; + ProductColoumn.Width = 125; + // + // ProductCount + // + ProductCount.HeaderText = "Количество"; + ProductCount.MinimumWidth = 6; + ProductCount.Name = "ProductCount"; + ProductCount.Width = 125; + // + // CheckSettingsForm + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(360, 338); + Controls.Add(productsDataGridView); + Controls.Add(saveButton); + Controls.Add(customerComboBox); + Controls.Add(label1); + Controls.Add(label4); + Name = "CheckSettingsForm"; + Text = "Новый чек"; + Load += CheckSettingsForm_Load; + ((System.ComponentModel.ISupportInitialize)productsDataGridView).EndInit(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private ComboBox customerComboBox; + private Label label1; + private Button saveButton; + private Label label4; + private DataGridView productsDataGridView; + private DataGridViewComboBoxColumn ProductColoumn; + private DataGridViewTextBoxColumn ProductCount; + } +} \ No newline at end of file diff --git a/CompShop/CompShop/Forms/Receipt/CheckSettingsForm .cs b/CompShop/CompShop/Forms/Receipt/CheckSettingsForm .cs new file mode 100644 index 0000000..23e6dbf --- /dev/null +++ b/CompShop/CompShop/Forms/Receipt/CheckSettingsForm .cs @@ -0,0 +1,74 @@ +using CompShop.Entites; +using CompShop.Repos; + +namespace CompShop.Forms.Receipt +{ + public partial class CheckSettingsForm : Form + { + private readonly ICheckRepository _checkRepository; + private readonly IProductRepository _productRepository; + private readonly IClientRepository _customerRepository; + + public CheckSettingsForm(ICheckRepository checkRepository, IProductRepository productRepository, IClientRepository customerRepository) + { + InitializeComponent(); + + _checkRepository = checkRepository ?? throw new ArgumentNullException(nameof(checkRepository)); + _productRepository = productRepository ?? throw new ArgumentNullException(nameof(productRepository)); + _customerRepository = customerRepository ?? throw new ArgumentNullException(nameof(customerRepository)); + + + ProductColoumn.DataSource = _productRepository.ReadAll().ToList(); + ProductColoumn.DisplayMember = "Name"; + ProductColoumn.ValueMember = "Id"; + + customerComboBox.DataSource = _customerRepository.ReadAll().ToList(); + customerComboBox.DisplayMember = "Name"; + customerComboBox.ValueMember = "Id"; + } + + public void CheckSettingsForm_Load(object sender, EventArgs e) + { + + } + + private void saveButton_Click(object sender, EventArgs e) + { + try + { + if (productsDataGridView.RowCount < 1 || customerComboBox.SelectedItem == null) + { + throw new Exception("Необходимо выбрать товар и клиента"); + } + + var products = CreateListProducts(); + var customer = (Client)customerComboBox.SelectedItem; + + var check = Check.CreateEntity(0, products, customer, DateTime.Now); + _checkRepository.Create(check); + + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при создании чека", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + private List CreateListProducts() + { + var list = new List(); + foreach (DataGridViewRow row in productsDataGridView.Rows) + { + if (row.Cells["ProductColoumn"].Value == null || row.Cells["ColumnCount"].Value == null) + { + continue; + } + + list.Add(ProductInCheck.CreateElement(Convert.ToInt32(row.Cells["ProductColoumn"].Value), Convert.ToInt32(row.Cells["ProductCount"].Value))); + } + + return list; + } + } +} + diff --git a/CompShop/CompShop/Forms/Receipt/CheckSettingsForm .resx b/CompShop/CompShop/Forms/Receipt/CheckSettingsForm .resx new file mode 100644 index 0000000..16cc2be --- /dev/null +++ b/CompShop/CompShop/Forms/Receipt/CheckSettingsForm .resx @@ -0,0 +1,66 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + True + + \ No newline at end of file diff --git a/CompShop/CompShop/Forms/Storage/StorageForm.Designer.cs b/CompShop/CompShop/Forms/Storage/StorageForm.Designer.cs new file mode 100644 index 0000000..838be25 --- /dev/null +++ b/CompShop/CompShop/Forms/Storage/StorageForm.Designer.cs @@ -0,0 +1,103 @@ +namespace CompShop.Forms.Storage +{ + partial class StorageForm + { + /// + /// 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() + { + deleteButton = new Button(); + editButton = new Button(); + addButton = new Button(); + storagesDataGridView = new DataGridView(); + ((System.ComponentModel.ISupportInitialize)storagesDataGridView).BeginInit(); + SuspendLayout(); + // + // deleteButton + // + deleteButton.Location = new Point(869, 144); + deleteButton.Name = "deleteButton"; + deleteButton.Size = new Size(161, 60); + deleteButton.TabIndex = 11; + deleteButton.Text = "Удалить"; + deleteButton.UseVisualStyleBackColor = true; + deleteButton.Click += deleteButton_Click; + // + // editButton + // + editButton.Location = new Point(869, 78); + editButton.Name = "editButton"; + editButton.Size = new Size(161, 60); + editButton.TabIndex = 10; + editButton.Text = "Редактировать"; + editButton.UseVisualStyleBackColor = true; + editButton.Click += editButton_Click; + // + // addButton + // + addButton.BackColor = SystemColors.Control; + addButton.Location = new Point(869, 12); + addButton.Name = "addButton"; + addButton.Size = new Size(161, 60); + addButton.TabIndex = 9; + addButton.Text = "Добавить"; + addButton.UseVisualStyleBackColor = false; + addButton.Click += addButton_Click; + // + // storagesDataGridView + // + storagesDataGridView.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left; + storagesDataGridView.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + storagesDataGridView.Location = new Point(12, 12); + storagesDataGridView.Name = "storagesDataGridView"; + storagesDataGridView.RowHeadersWidth = 51; + storagesDataGridView.RowTemplate.Height = 29; + storagesDataGridView.Size = new Size(851, 416); + storagesDataGridView.TabIndex = 8; + // + // StorageForm + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(1058, 440); + Controls.Add(deleteButton); + Controls.Add(editButton); + Controls.Add(addButton); + Controls.Add(storagesDataGridView); + Name = "StorageForm"; + Text = "Склады"; + Load += StorageForm_Load; + ((System.ComponentModel.ISupportInitialize)storagesDataGridView).EndInit(); + ResumeLayout(false); + } + + #endregion + + private Button deleteButton; + private Button editButton; + private Button addButton; + private DataGridView storagesDataGridView; + } +} \ No newline at end of file diff --git a/CompShop/CompShop/Forms/Storage/StorageForm.cs b/CompShop/CompShop/Forms/Storage/StorageForm.cs new file mode 100644 index 0000000..cdd946a --- /dev/null +++ b/CompShop/CompShop/Forms/Storage/StorageForm.cs @@ -0,0 +1,102 @@ + +using CompShop.Repos; +using Unity; + +namespace CompShop.Forms.Storage +{ + public partial class StorageForm : Form + { + private readonly IUnityContainer _container; + private readonly IStorageRepository _repository; + + public StorageForm(IUnityContainer unityContainer, IStorageRepository repository) + { + InitializeComponent(); + + _container = unityContainer ?? throw new ArgumentNullException(nameof(unityContainer)); + _repository = repository ?? throw new ArgumentNullException(nameof(_repository)); + } + + private void StorageForm_Load(object sender, EventArgs e) + { + try + { + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + private void LoadList() => storagesDataGridView.DataSource = _repository.ReadAll(); + + private bool TryGetIdentifierFromSelectedRow(out int id) + { + id = 0; + if (storagesDataGridView.SelectedRows.Count < 1) + { + MessageBox.Show("Нет выбранной записи", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error); + return false; + } + + id = Convert.ToInt32(storagesDataGridView.SelectedRows[0].Cells["Id"].Value); + return true; + } + + private void addButton_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при добавлении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void editButton_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 deleteButton_Click(object sender, EventArgs e) + { + if (!TryGetIdentifierFromSelectedRow(out var findId)) + { + return; + } + + if (MessageBox.Show("Удалить запись?", "Удаление", MessageBoxButtons.YesNo) != DialogResult.Yes) + { + return; + } + + try + { + _repository.Delete(findId); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при удалении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + } +} diff --git a/CompShop/CompShop/Forms/Storage/StorageForm.resx b/CompShop/CompShop/Forms/Storage/StorageForm.resx new file mode 100644 index 0000000..f298a7b --- /dev/null +++ b/CompShop/CompShop/Forms/Storage/StorageForm.resx @@ -0,0 +1,60 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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/CompShop/CompShop/Forms/Storage/StorageSettingsForm.Designer.cs b/CompShop/CompShop/Forms/Storage/StorageSettingsForm.Designer.cs new file mode 100644 index 0000000..1835905 --- /dev/null +++ b/CompShop/CompShop/Forms/Storage/StorageSettingsForm.Designer.cs @@ -0,0 +1,109 @@ +namespace CompShop.Forms.Storage +{ + partial class StorageSettingsForm + { + /// + /// 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() + { + label3 = new Label(); + sizeNumeric = new NumericUpDown(); + label1 = new Label(); + adressTextbox = new TextBox(); + saveButton = new Button(); + ((System.ComponentModel.ISupportInitialize)sizeNumeric).BeginInit(); + SuspendLayout(); + // + // label3 + // + label3.AutoSize = true; + label3.Location = new Point(12, 67); + label3.Name = "label3"; + label3.Size = new Size(100, 20); + label3.TabIndex = 11; + label3.Text = "Вместимость"; + // + // sizeNumeric + // + sizeNumeric.Location = new Point(119, 65); + sizeNumeric.Name = "sizeNumeric"; + sizeNumeric.Size = new Size(99, 27); + sizeNumeric.TabIndex = 10; + sizeNumeric.ThousandsSeparator = true; + // + // label1 + // + label1.AutoSize = true; + label1.Location = new Point(12, 22); + label1.Name = "label1"; + label1.Size = new Size(104, 20); + label1.TabIndex = 9; + label1.Text = "Адрес склада:"; + // + // adressTextbox + // + adressTextbox.Location = new Point(119, 19); + adressTextbox.Name = "adressTextbox"; + adressTextbox.Size = new Size(210, 27); + adressTextbox.TabIndex = 8; + // + // saveButton + // + saveButton.Anchor = AnchorStyles.Bottom; + saveButton.Location = new Point(129, 117); + saveButton.Name = "saveButton"; + saveButton.Size = new Size(94, 29); + saveButton.TabIndex = 7; + saveButton.Text = "Сохранить"; + saveButton.UseVisualStyleBackColor = true; + saveButton.Click += saveButton_Click; + // + // StorageSettingsForm + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(364, 158); + Controls.Add(label3); + Controls.Add(sizeNumeric); + Controls.Add(label1); + Controls.Add(adressTextbox); + Controls.Add(saveButton); + Name = "StorageSettingsForm"; + Text = "Настройки склада"; + Load += StorageFormSettings_Load; + ((System.ComponentModel.ISupportInitialize)sizeNumeric).EndInit(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private Label label3; + private NumericUpDown sizeNumeric; + private Label label1; + private TextBox adressTextbox; + private Button saveButton; + } +} \ No newline at end of file diff --git a/CompShop/CompShop/Forms/Storage/StorageSettingsForm.cs b/CompShop/CompShop/Forms/Storage/StorageSettingsForm.cs new file mode 100644 index 0000000..0aa863f --- /dev/null +++ b/CompShop/CompShop/Forms/Storage/StorageSettingsForm.cs @@ -0,0 +1,80 @@ +using CompShop.Repos; + + +namespace CompShop.Forms.Storage +{ + public partial class StorageSettingsForm : Form + { + private readonly IStorageRepository _repository; + + private int? _storageID; + + public int Id + { + set + { + try + { + var storage = _repository.Read(value); + if (storage != null) + { + throw new InvalidDataException(nameof(storage)); + } + adressTextbox.Text = storage.Adress; + sizeNumeric.Value = storage.Size; + _storageID = value; + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при данных", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + } + } + + public StorageSettingsForm(IStorageRepository repository) + { + InitializeComponent(); + _repository = repository ?? throw new ArgumentNullException(nameof(repository)); + + } + + private void StorageFormSettings_Load(object sender, EventArgs e) + { + + } + + private void saveButton_Click(object sender, EventArgs e) + { + try + { + if (string.IsNullOrWhiteSpace(adressTextbox.Text)) + { + throw new Exception("Имеются незаполненные поля"); + } + + if (_storageID.HasValue) + { + + _repository.Update(CreateStorage(_storageID.Value)); + } + else + { + + _repository.Update(CreateStorage(0)); + } + + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при сохранении", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + private Entites.Storage CreateStorage(int id) + { + return Entites.Storage.CreateEntity(id, (int)sizeNumeric.Value, adressTextbox.Text); + } + } +} diff --git a/CompShop/CompShop/Forms/Storage/StorageSettingsForm.resx b/CompShop/CompShop/Forms/Storage/StorageSettingsForm.resx new file mode 100644 index 0000000..f298a7b --- /dev/null +++ b/CompShop/CompShop/Forms/Storage/StorageSettingsForm.resx @@ -0,0 +1,60 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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/CompShop/CompShop/Program.cs b/CompShop/CompShop/Program.cs index 70ba6d1..22edc1e 100644 --- a/CompShop/CompShop/Program.cs +++ b/CompShop/CompShop/Program.cs @@ -1,3 +1,8 @@ +using CompShop.Repos; +using CompShop.Repos.Impements; +using Unity; +using Unity.Lifetime; + namespace CompShop { internal static class Program @@ -8,10 +13,20 @@ namespace CompShop [STAThread] static void Main() { - // To customize application configuration such as set high DPI settings or default font, - // see https://aka.ms/applicationconfiguration. ApplicationConfiguration.Initialize(); - Application.Run(new Form1()); + Application.Run(CreateContainer().Resolve()); + } + private static IUnityContainer CreateContainer() + { + var container = new UnityContainer(); + + container.RegisterType(new TransientLifetimeManager()); + container.RegisterType(new TransientLifetimeManager()); + container.RegisterType(new TransientLifetimeManager()); + container.RegisterType(new TransientLifetimeManager()); + container.RegisterType(new TransientLifetimeManager()); + + return container; } } } \ No newline at end of file diff --git a/CompShop/CompShop/Repos/ICheckRepository.cs b/CompShop/CompShop/Repos/ICheckRepository.cs new file mode 100644 index 0000000..1572f60 --- /dev/null +++ b/CompShop/CompShop/Repos/ICheckRepository.cs @@ -0,0 +1,11 @@ +using CompShop.Entites; + +namespace CompShop.Repos +{ + public interface ICheckRepository + { + IEnumerable ReadAll(); + Check Read(int id); + void Create(Check check); + } +} diff --git a/CompShop/CompShop/Repos/IClientRepository.cs b/CompShop/CompShop/Repos/IClientRepository.cs new file mode 100644 index 0000000..cb742d9 --- /dev/null +++ b/CompShop/CompShop/Repos/IClientRepository.cs @@ -0,0 +1,13 @@ +using CompShop.Entites; + +namespace CompShop.Repos +{ + public interface IClientRepository + { + IEnumerable ReadAll(); + Client Read(int id); + void Create(Client client); + Client Update(Client client); + void Delete(int id); + } +} diff --git a/CompShop/CompShop/Repos/IProductOnStorageRepository.cs b/CompShop/CompShop/Repos/IProductOnStorageRepository.cs new file mode 100644 index 0000000..138e378 --- /dev/null +++ b/CompShop/CompShop/Repos/IProductOnStorageRepository.cs @@ -0,0 +1,11 @@ +using CompShop.Entites; +namespace CompShop.Repos +{ + public interface IProductOnStorageRepository + { + IEnumerable ReadAll(); + ProductsOnStorage Read(int id); + void Create(ProductsOnStorage ps); + ProductsOnStorage Update(ProductsOnStorage storage); + } +} diff --git a/CompShop/CompShop/Repos/IProductRepository.cs b/CompShop/CompShop/Repos/IProductRepository.cs new file mode 100644 index 0000000..904727e --- /dev/null +++ b/CompShop/CompShop/Repos/IProductRepository.cs @@ -0,0 +1,13 @@ +using CompShop.Entites; + +namespace CompShop.Repos +{ + public interface IProductRepository + { + IEnumerable ReadAll(); + Product Read(int id); + void Create(Product product); + Product Update(Product product); + void Delete(int id); + } +} diff --git a/CompShop/CompShop/Repos/IStorageRepository.cs b/CompShop/CompShop/Repos/IStorageRepository.cs new file mode 100644 index 0000000..92093bd --- /dev/null +++ b/CompShop/CompShop/Repos/IStorageRepository.cs @@ -0,0 +1,13 @@ +using CompShop.Entites; + +namespace CompShop.Repos +{ + public interface IStorageRepository + { + IEnumerable ReadAll(); + Storage Read(int id); + void Create(Storage storage); + Storage Update(Storage storage); + void Delete(int id); + } +} diff --git a/CompShop/CompShop/Repos/Impements/CheckRepo.cs b/CompShop/CompShop/Repos/Impements/CheckRepo.cs new file mode 100644 index 0000000..912f9f4 --- /dev/null +++ b/CompShop/CompShop/Repos/Impements/CheckRepo.cs @@ -0,0 +1,23 @@ +using CompShop.Entites; + +namespace CompShop.Repos.Impements +{ + public class CheckRepo : ICheckRepository + { + + public void Create(Check check) + { + + } + + public Check Read(int id) + { + return Check.CreateEntity(0, new List(), new Client(), DateTime.Now); + } + + public IEnumerable ReadAll() + { + return new List(); + } + } +} diff --git a/CompShop/CompShop/Repos/Impements/ClientRepo.cs b/CompShop/CompShop/Repos/Impements/ClientRepo.cs new file mode 100644 index 0000000..e9afa95 --- /dev/null +++ b/CompShop/CompShop/Repos/Impements/ClientRepo.cs @@ -0,0 +1,33 @@ +using CompShop.Entites; +using CompShop.Entites.Enums; + +namespace CompShop.Repos.Impements +{ + public class ClientRepo : IClientRepository + { + public void Create(Client client) + { + + } + + public void Delete(int id) + { + + } + + public Client Read(int id) + { + return Client.CreateEntity(0, string.Empty, string.Empty, ClientType.Individual); + } + + public IEnumerable ReadAll() + { + return new List(); + } + + public Client Update(Client client) + { + return Client.CreateEntity(0, string.Empty, string.Empty, ClientType.Individual); + } + } +} diff --git a/CompShop/CompShop/Repos/Impements/ProductRepo.cs b/CompShop/CompShop/Repos/Impements/ProductRepo.cs new file mode 100644 index 0000000..f8e2d59 --- /dev/null +++ b/CompShop/CompShop/Repos/Impements/ProductRepo.cs @@ -0,0 +1,33 @@ +using CompShop.Entites; +using CompShop.Entites.Enums; + +namespace CompShop.Repos.Impements +{ + public class ProductRepo : IProductRepository + { + public void Create(Product product) + { + + } + + public void Delete(int id) + { + + } + + public Product Read(int id) + { + return Product.CreateEntity(0, string.Empty, string.Empty, 0, ProductType.None); + } + + public IEnumerable ReadAll() + { + return new List(); + } + + public Product Update(Product product) + { + return Product.CreateEntity(0, string.Empty, string.Empty, 0, ProductType.None); + } + } +} diff --git a/CompShop/CompShop/Repos/Impements/ProductsOnStorageRepo.cs b/CompShop/CompShop/Repos/Impements/ProductsOnStorageRepo.cs new file mode 100644 index 0000000..8fc5199 --- /dev/null +++ b/CompShop/CompShop/Repos/Impements/ProductsOnStorageRepo.cs @@ -0,0 +1,27 @@ +using CompShop.Entites; + +namespace CompShop.Repos.Impements +{ + public class ProductsOnStorageRepo : IProductOnStorageRepository + { + public void Create(ProductsOnStorage ps) + { + + } + + public ProductsOnStorage Read(int id) + { + return ProductsOnStorage.CreateEntity(0, new Product(), new Storage(), 0); + } + + public IEnumerable ReadAll() + { + return new List(); + } + + public ProductsOnStorage Update(ProductsOnStorage storage) + { + return ProductsOnStorage.CreateEntity(0, new Product(), new Storage(), 0); + } + } +} diff --git a/CompShop/CompShop/Repos/Impements/StorageRepo.cs b/CompShop/CompShop/Repos/Impements/StorageRepo.cs new file mode 100644 index 0000000..08a565d --- /dev/null +++ b/CompShop/CompShop/Repos/Impements/StorageRepo.cs @@ -0,0 +1,32 @@ +using CompShop.Entites; + +namespace CompShop.Repos.Impements +{ + public class StorageRepo: IStorageRepository + { + public void Create(Storage storage) + { + + } + + public void Delete(int id) + { + + } + + public Storage Read(int id) + { + return Storage.CreateEntity(0, 0, string.Empty); + } + + public IEnumerable ReadAll() + { + return new List(); + } + + public Storage Update(Storage storage) + { + return Storage.CreateEntity(0, 0, string.Empty); + } + } +} diff --git a/CompShop/CompShop/photo_2024-10-27_23-57-36.jpg b/CompShop/CompShop/photo_2024-10-27_23-57-36.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5aa0728a9a73045153eaf29c5d3385bade2d5a7e GIT binary patch literal 101390 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