From b8929bf9eb416cc995572cb2b4398e6eaf5944d3 Mon Sep 17 00:00:00 2001 From: aaahsap Date: Fri, 20 Dec 2024 09:27:19 +0400 Subject: [PATCH] =?UTF-8?q?=D0=9B=D0=B0=D0=B1=D0=B0=D1=80=D0=B0=D1=82?= =?UTF-8?q?=D0=BE=D1=80=D0=BD=D0=B0=D1=8F=201?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ProjectSellPC/ProjectSellPC/Entites/Cheque.cs | 21 + ProjectSellPC/ProjectSellPC/Entites/Client.cs | 22 + .../ProjectSellPC/Entites/Enums/ClientType.cs | 9 + .../Entites/Enums/ProductType.cs | 17 + .../ProjectSellPC/Entites/Product.cs | 22 + .../ProjectSellPC/Entites/ProductInCheque..cs | 12 + .../Entites/ProductsOnWarehouse.cs | 15 + .../ProjectSellPC/Entites/Warehouse.cs | 14 + ProjectSellPC/ProjectSellPC/Form1.Designer.cs | 39 - ProjectSellPC/ProjectSellPC/Form1.cs | 10 - .../Forms/Cheque/ChequeForm.Designer.cs | 77 + .../ProjectSellPC/Forms/Cheque/ChequeForm.cs | 46 + .../Forms/Cheque/ChequeForm.resx | 120 ++ .../Cheque/ChequeSettingsForm .Designer.cs | 134 ++ .../Forms/Cheque/ChequeSettingsForm .cs | 74 + .../Forms/Cheque/ChequeSettingsForm .resx | 126 ++ .../Forms/Clients/ClientForm.Designer.cs | 103 + .../ProjectSellPC/Forms/Clients/ClientForm.cs | 102 + .../Forms/Clients/ClientForm.resx | 120 ++ .../Clients/ClientFormSettings.Designer.cs | 133 ++ .../Forms/Clients/ClientFormSettings.cs | 87 + .../Forms/Clients/ClientFormSettings.resx | 120 ++ .../ProjectSellPC/Forms/Form1.Designer.cs | 132 ++ ProjectSellPC/ProjectSellPC/Forms/Form1.cs | 53 + ProjectSellPC/ProjectSellPC/Forms/Form1.resx | 1848 +++++++++++++++++ .../Forms/Products/ProductForm.Designer.cs | 103 + .../Forms/Products/ProductForm.cs | 101 + .../Forms/Products/ProductForm.resx | 120 ++ .../Products/ProductSettingsForm.Designer.cs | 157 ++ .../Forms/Products/ProductSettingsForm.cs | 104 + .../Forms/Products/ProductSettingsForm.resx | 120 ++ .../ProductsOnWarehouseForm.Designer.cs | 90 + .../ProductsOnWarehouseForm.cs | 80 + .../ProductsOnWarehouseForm.resx | 120 ++ ...roductsOnWarehouseSettingsForm.Designer.cs | 134 ++ .../ProductsOnWarehouseSettingsForm.cs | 101 + .../ProductsOnWarehouseSettingsForm.resx | 120 ++ .../Forms/Warehouse/WarehouseForm.Designer.cs | 103 + .../Forms/Warehouse/WarehouseForm.cs | 102 + .../Forms/Warehouse/WarehouseForm.resx | 120 ++ .../WarehouseSettingsForm.Designer.cs | 110 + .../Forms/Warehouse/WarehouseSettingsForm.cs | 80 + .../Warehouse/WarehouseSettingsForm.resx | 120 ++ ProjectSellPC/ProjectSellPC/Program.cs | 21 +- .../ProjectSellPC/ProjectSellPC.csproj | 4 + .../Properties/Resources.Designer.cs | 63 + .../{Form1.resx => Properties/Resources.resx} | 0 .../ProjectSellPC/Repos/IChequeRepository.cs | 11 + .../ProjectSellPC/Repos/IClientRepository.cs | 13 + .../Repos/IProductOnWarehouseRepository.cs | 11 + .../ProjectSellPC/Repos/IProductRepository.cs | 13 + .../Repos/IWarehouseRepository.cs | 13 + .../Repos/Impements/CheckRepo.cs | 23 + .../Repos/Impements/ClientRepo.cs | 33 + .../Repos/Impements/ProductRepo.cs | 33 + .../Repos/Impements/ProductsOnStorageRepo.cs | 27 + .../Repos/Impements/StorageRepo.cs | 32 + .../ProjectSellPC/large_KPq-qORcEv8-1.jpg | Bin 0 -> 103150 bytes 58 files changed, 5686 insertions(+), 52 deletions(-) create mode 100644 ProjectSellPC/ProjectSellPC/Entites/Cheque.cs create mode 100644 ProjectSellPC/ProjectSellPC/Entites/Client.cs create mode 100644 ProjectSellPC/ProjectSellPC/Entites/Enums/ClientType.cs create mode 100644 ProjectSellPC/ProjectSellPC/Entites/Enums/ProductType.cs create mode 100644 ProjectSellPC/ProjectSellPC/Entites/Product.cs create mode 100644 ProjectSellPC/ProjectSellPC/Entites/ProductInCheque..cs create mode 100644 ProjectSellPC/ProjectSellPC/Entites/ProductsOnWarehouse.cs create mode 100644 ProjectSellPC/ProjectSellPC/Entites/Warehouse.cs delete mode 100644 ProjectSellPC/ProjectSellPC/Form1.Designer.cs delete mode 100644 ProjectSellPC/ProjectSellPC/Form1.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeForm.Designer.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeForm.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeForm.resx create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeSettingsForm .Designer.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeSettingsForm .cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeSettingsForm .resx create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Clients/ClientForm.Designer.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Clients/ClientForm.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Clients/ClientForm.resx create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Clients/ClientFormSettings.Designer.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Clients/ClientFormSettings.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Clients/ClientFormSettings.resx create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Form1.Designer.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Form1.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Form1.resx create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Products/ProductForm.Designer.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Products/ProductForm.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Products/ProductForm.resx create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Products/ProductSettingsForm.Designer.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Products/ProductSettingsForm.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Products/ProductSettingsForm.resx create mode 100644 ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseForm.Designer.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseForm.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseForm.resx create mode 100644 ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseSettingsForm.Designer.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseSettingsForm.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseSettingsForm.resx create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseForm.Designer.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseForm.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseForm.resx create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseSettingsForm.Designer.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseSettingsForm.cs create mode 100644 ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseSettingsForm.resx create mode 100644 ProjectSellPC/ProjectSellPC/Properties/Resources.Designer.cs rename ProjectSellPC/ProjectSellPC/{Form1.resx => Properties/Resources.resx} (100%) create mode 100644 ProjectSellPC/ProjectSellPC/Repos/IChequeRepository.cs create mode 100644 ProjectSellPC/ProjectSellPC/Repos/IClientRepository.cs create mode 100644 ProjectSellPC/ProjectSellPC/Repos/IProductOnWarehouseRepository.cs create mode 100644 ProjectSellPC/ProjectSellPC/Repos/IProductRepository.cs create mode 100644 ProjectSellPC/ProjectSellPC/Repos/IWarehouseRepository.cs create mode 100644 ProjectSellPC/ProjectSellPC/Repos/Impements/CheckRepo.cs create mode 100644 ProjectSellPC/ProjectSellPC/Repos/Impements/ClientRepo.cs create mode 100644 ProjectSellPC/ProjectSellPC/Repos/Impements/ProductRepo.cs create mode 100644 ProjectSellPC/ProjectSellPC/Repos/Impements/ProductsOnStorageRepo.cs create mode 100644 ProjectSellPC/ProjectSellPC/Repos/Impements/StorageRepo.cs create mode 100644 ProjectSellPC/ProjectSellPC/large_KPq-qORcEv8-1.jpg diff --git a/ProjectSellPC/ProjectSellPC/Entites/Cheque.cs b/ProjectSellPC/ProjectSellPC/Entites/Cheque.cs new file mode 100644 index 0000000..d728523 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Entites/Cheque.cs @@ -0,0 +1,21 @@ +namespace ProjectSellPC.Entites +{ + public class Cheque + { + public int Id { get; set; } + public List Products { get; set; } + public Client Client { get; set; } + public DateTime PurchaseDate { get; set; } + + public static Cheque CreateEntity(int id, List products, Client client, DateTime purchaseDate) + { + return new Cheque + { + Id = id, + Products = products, + Client = client, + PurchaseDate = purchaseDate + }; + } + } +} diff --git a/ProjectSellPC/ProjectSellPC/Entites/Client.cs b/ProjectSellPC/ProjectSellPC/Entites/Client.cs new file mode 100644 index 0000000..ab32a32 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Entites/Client.cs @@ -0,0 +1,22 @@ +using ProjectSellPC.Entites.Enums; +namespace ProjectSellPC.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/ProjectSellPC/ProjectSellPC/Entites/Enums/ClientType.cs b/ProjectSellPC/ProjectSellPC/Entites/Enums/ClientType.cs new file mode 100644 index 0000000..b2f089e --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Entites/Enums/ClientType.cs @@ -0,0 +1,9 @@ +namespace ProjectSellPC.Entites.Enums +{ + public enum ClientType + { + None = 0, + Individual = 1, + Business = 2 + } +} diff --git a/ProjectSellPC/ProjectSellPC/Entites/Enums/ProductType.cs b/ProjectSellPC/ProjectSellPC/Entites/Enums/ProductType.cs new file mode 100644 index 0000000..97d3cd4 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Entites/Enums/ProductType.cs @@ -0,0 +1,17 @@ +namespace ProjectSellPC.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/ProjectSellPC/ProjectSellPC/Entites/Product.cs b/ProjectSellPC/ProjectSellPC/Entites/Product.cs new file mode 100644 index 0000000..6c650e0 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Entites/Product.cs @@ -0,0 +1,22 @@ +using ProjectSellPC.Entites.Enums; + +namespace ProjectSellPC.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/ProjectSellPC/ProjectSellPC/Entites/ProductInCheque..cs b/ProjectSellPC/ProjectSellPC/Entites/ProductInCheque..cs new file mode 100644 index 0000000..da3c529 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Entites/ProductInCheque..cs @@ -0,0 +1,12 @@ +namespace ProjectSellPC.Entites +{ + public class ProductInCheque + { + public int ID { get; set; } + public int Count { get; set; } + public static ProductInCheque CreateElement(int id, int count) + { + return new ProductInCheque { ID = id, Count = count}; + } + } +} diff --git a/ProjectSellPC/ProjectSellPC/Entites/ProductsOnWarehouse.cs b/ProjectSellPC/ProjectSellPC/Entites/ProductsOnWarehouse.cs new file mode 100644 index 0000000..109fe9c --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Entites/ProductsOnWarehouse.cs @@ -0,0 +1,15 @@ +namespace ProjectSellPC.Entites +{ + public class ProductsOnWarehouse + { + public int Id { get; set; } + public Product Product { get; set; } + public Warehouse Warehouse { get; set; } + public int Count { get; set; } + + public static ProductsOnWarehouse CreateEntity(int id, Product product, Warehouse Warehouse, int count) + { + return new ProductsOnWarehouse { Warehouse = Warehouse, Id = id, Product = product, Count = count }; + } + } +} diff --git a/ProjectSellPC/ProjectSellPC/Entites/Warehouse.cs b/ProjectSellPC/ProjectSellPC/Entites/Warehouse.cs new file mode 100644 index 0000000..56847ff --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Entites/Warehouse.cs @@ -0,0 +1,14 @@ +namespace ProjectSellPC.Entites +{ + public class Warehouse + { + public int Id { get; set; } + public int Size { get; set; } // Вместимость + public string Adress { get; set; } + + public static Warehouse CreateEntity(int id, int size, string adress) + { + return new Warehouse { Id = id, Size = size, Adress = adress }; + } + } +} diff --git a/ProjectSellPC/ProjectSellPC/Form1.Designer.cs b/ProjectSellPC/ProjectSellPC/Form1.Designer.cs deleted file mode 100644 index 073ba82..0000000 --- a/ProjectSellPC/ProjectSellPC/Form1.Designer.cs +++ /dev/null @@ -1,39 +0,0 @@ -namespace ProjectSellPC -{ - 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/ProjectSellPC/ProjectSellPC/Form1.cs b/ProjectSellPC/ProjectSellPC/Form1.cs deleted file mode 100644 index 65c928c..0000000 --- a/ProjectSellPC/ProjectSellPC/Form1.cs +++ /dev/null @@ -1,10 +0,0 @@ -namespace ProjectSellPC -{ - public partial class Form1 : Form - { - public Form1() - { - InitializeComponent(); - } - } -} diff --git a/ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeForm.Designer.cs b/ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeForm.Designer.cs new file mode 100644 index 0000000..40db35a --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeForm.Designer.cs @@ -0,0 +1,77 @@ +namespace ProjectSellPC.Forms.Receipt +{ + partial class ChequeForm + { + /// + /// 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(); + ChequesDataGridView = new DataGridView(); + ((System.ComponentModel.ISupportInitialize)ChequesDataGridView).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; + // + // ChequesDataGridView + // + ChequesDataGridView.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left; + ChequesDataGridView.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + ChequesDataGridView.Location = new Point(12, 12); + ChequesDataGridView.Name = "ChequesDataGridView"; + ChequesDataGridView.RowHeadersWidth = 51; + ChequesDataGridView.Size = new Size(851, 399); + ChequesDataGridView.TabIndex = 2; + // + // ChequeForm + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(1056, 450); + Controls.Add(addButton); + Controls.Add(ChequesDataGridView); + Name = "ChequeForm"; + StartPosition = FormStartPosition.CenterScreen; + Text = "Чеки"; + Load += ChequeForm_Load; + ((System.ComponentModel.ISupportInitialize)ChequesDataGridView).EndInit(); + ResumeLayout(false); + } + + #endregion + + private Button addButton; + private DataGridView ChequesDataGridView; + } +} \ No newline at end of file diff --git a/ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeForm.cs b/ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeForm.cs new file mode 100644 index 0000000..15a6606 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeForm.cs @@ -0,0 +1,46 @@ +using ProjectSellPC.Repos; +using Unity; + +namespace ProjectSellPC.Forms.Receipt +{ + public partial class ChequeForm : Form + { + private readonly IUnityContainer _container; + private readonly IChequeRepository _ChequeRepository; + + public ChequeForm(IUnityContainer unityContainer, IChequeRepository ChequeRepository) + { + InitializeComponent(); + + _container = unityContainer ?? throw new ArgumentNullException(nameof(unityContainer)); + _ChequeRepository = ChequeRepository ?? throw new ArgumentNullException(nameof(ChequeRepository)); + } + + private void ChequeForm_Load(object sender, EventArgs e) + { + try + { + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void LoadList() => ChequesDataGridView.DataSource = _ChequeRepository.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/ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeForm.resx b/ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeForm.resx new file mode 100644 index 0000000..8b2ff64 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeForm.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeSettingsForm .Designer.cs b/ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeSettingsForm .Designer.cs new file mode 100644 index 0000000..7a9e31d --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeSettingsForm .Designer.cs @@ -0,0 +1,134 @@ +namespace ProjectSellPC.Forms.Receipt +{ + partial class ChequeSettingsForm + { + /// + /// 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.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; + // + // ChequeSettingsForm + // + 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 = "ChequeSettingsForm"; + StartPosition = FormStartPosition.CenterScreen; + Text = "Новый чек"; + Load += ChequeSettingsForm_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/ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeSettingsForm .cs b/ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeSettingsForm .cs new file mode 100644 index 0000000..6364d66 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeSettingsForm .cs @@ -0,0 +1,74 @@ +using ProjectSellPC.Entites; +using ProjectSellPC.Repos; + +namespace ProjectSellPC.Forms.Receipt +{ + public partial class ChequeSettingsForm : Form + { + private readonly IChequeRepository _ChequeRepository; + private readonly IProductRepository _productRepository; + private readonly IClientRepository _customerRepository; + + public ChequeSettingsForm(IChequeRepository ChequeRepository, IProductRepository productRepository, IClientRepository customerRepository) + { + InitializeComponent(); + + _ChequeRepository = ChequeRepository ?? throw new ArgumentNullException(nameof(ChequeRepository)); + _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 ChequeSettingsForm_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 cheque = Cheque.CreateEntity(0, products, customer, DateTime.Now); + _ChequeRepository.Create(cheque); + + 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(ProductInCheque.CreateElement(Convert.ToInt32(row.Cells["ProductColoumn"].Value), Convert.ToInt32(row.Cells["ProductCount"].Value))); + } + + return list; + } + } +} + diff --git a/ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeSettingsForm .resx b/ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeSettingsForm .resx new file mode 100644 index 0000000..25b324c --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Cheque/ChequeSettingsForm .resx @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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/ProjectSellPC/ProjectSellPC/Forms/Clients/ClientForm.Designer.cs b/ProjectSellPC/ProjectSellPC/Forms/Clients/ClientForm.Designer.cs new file mode 100644 index 0000000..b8a83d8 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Clients/ClientForm.Designer.cs @@ -0,0 +1,103 @@ +namespace ProjectSellPC.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.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"; + StartPosition = FormStartPosition.CenterScreen; + 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/ProjectSellPC/ProjectSellPC/Forms/Clients/ClientForm.cs b/ProjectSellPC/ProjectSellPC/Forms/Clients/ClientForm.cs new file mode 100644 index 0000000..0f7f135 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Clients/ClientForm.cs @@ -0,0 +1,102 @@ +using ProjectSellPC.Forms.Clients; +using ProjectSellPC.Repos; +using Unity; + +namespace ProjectSellPC.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/ProjectSellPC/ProjectSellPC/Forms/Clients/ClientForm.resx b/ProjectSellPC/ProjectSellPC/Forms/Clients/ClientForm.resx new file mode 100644 index 0000000..8b2ff64 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Clients/ClientForm.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ProjectSellPC/ProjectSellPC/Forms/Clients/ClientFormSettings.Designer.cs b/ProjectSellPC/ProjectSellPC/Forms/Clients/ClientFormSettings.Designer.cs new file mode 100644 index 0000000..9a8ff4a --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Clients/ClientFormSettings.Designer.cs @@ -0,0 +1,133 @@ +namespace ProjectSellPC.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"; + StartPosition = FormStartPosition.CenterScreen; + 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/ProjectSellPC/ProjectSellPC/Forms/Clients/ClientFormSettings.cs b/ProjectSellPC/ProjectSellPC/Forms/Clients/ClientFormSettings.cs new file mode 100644 index 0000000..7aec5d9 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Clients/ClientFormSettings.cs @@ -0,0 +1,87 @@ +using ProjectSellPC.Entites.Enums; +using ProjectSellPC.Entites; +using ProjectSellPC.Repos; + +namespace ProjectSellPC.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/ProjectSellPC/ProjectSellPC/Forms/Clients/ClientFormSettings.resx b/ProjectSellPC/ProjectSellPC/Forms/Clients/ClientFormSettings.resx new file mode 100644 index 0000000..8b2ff64 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Clients/ClientFormSettings.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ProjectSellPC/ProjectSellPC/Forms/Form1.Designer.cs b/ProjectSellPC/ProjectSellPC/Forms/Form1.Designer.cs new file mode 100644 index 0000000..2dbab12 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Form1.Designer.cs @@ -0,0 +1,132 @@ +namespace ProjectSellPC +{ + 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(216, 26); + товарыНаСкаледToolStripMenuItem.Text = "Товары на складе"; + товарыНаСкаледToolStripMenuItem.Click += товарыНаСкаледToolStripMenuItem_Click; + // + // чекиToolStripMenuItem + // + чекиToolStripMenuItem.Name = "чекиToolStripMenuItem"; + чекиToolStripMenuItem.Size = new Size(216, 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"; + StartPosition = FormStartPosition.CenterScreen; + Text = "Магазин компьютерной техники"; + Load += ShopForm_Load; + 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/ProjectSellPC/ProjectSellPC/Forms/Form1.cs b/ProjectSellPC/ProjectSellPC/Forms/Form1.cs new file mode 100644 index 0000000..53ad206 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Form1.cs @@ -0,0 +1,53 @@ +using ProjectSellPC.Forms; +using ProjectSellPC.Forms.ProductsOnWarehouse; +using ProjectSellPC.Forms.Receipt; +using ProjectSellPC.Forms.Warehouse; +using Unity; + +namespace ProjectSellPC +{ + 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(); + + } + + private void ShopForm_Load(object sender, EventArgs e) + { + + } + } +} \ No newline at end of file diff --git a/ProjectSellPC/ProjectSellPC/Forms/Form1.resx b/ProjectSellPC/ProjectSellPC/Forms/Form1.resx new file mode 100644 index 0000000..2a85aa3 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Form1.resx @@ -0,0 +1,1848 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + + + + /9j/4AAQSkZJRgABAQEAAAAAAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYa + HSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgo + KCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wgARCAJYA5gDASIAAhEBAxEB/8QA + HAAAAQUBAQEAAAAAAAAAAAAAAwABAgQFBgcI/8QAGgEBAQEBAQEBAAAAAAAAAAAAAAECAwQFBv/aAAwD + AQACEAMQAAAB3HTjBNXjANxYdvRNLyvujfURxfnWJuWKVspg2r9Wq6erz72kKcQ5vssjXOpYptj1FnRb + H0N0ebFy0Y5az0vxoTLkqV3p4XgSG/E3Q4HStH1KmjZY8+9D8yZq9VyfQ6uv5P6x5lJSsn2q5C1ULjQT + 173bDV9LNxZANDQU1axc6hfoZB0c6411OTp1Er6mbp8+vosbQ9c8Z8yx8X13aNmlm6k83N4a6U3NXfbx + vU20vRzo0+rv+vnzGR6C/q58f1sBZWSZdfGtx+bCdQ3KRl6QOAjYDnKLcK6DoClu6WArOwscTas6mOXp + JNGQJyMNKMQkWkqdIqIK05tRWUQFFHmte5T0fseN6zV6YTixNbaw+q2zp2xpk5vQjrnY2uV4fY26FM+f + Z6CRS9H50fCegcLZx7KM6EkFBZVbASwri1dU1KZuJnmZdDzvRWW9XO1KteaelcHvORs4veeiB829H838 + fTLPTcY1GxE+q4/Yre5McemXs09Tnejo3KGs85kaVDOq1oPQzZds+/5++UTfNY9Dal6PNw1jsBY1zNzU + r9M2LmHWjpocpCOpBzal3QY6jQBVSmYToRxqUig5J4uOkxJMiTxRJ2RJM4k7kZpy3p4T2dbY4y3Z1Cyb + 6HhOBNJLlJlucw9GfPRoDHHE5+ln9I3S83u29cNRxNLrOQ6fazXkpBCsQtx+N7fifN9sZRkz9D0tNP1f + lm5nqudz24sfQT5fX5ofTAWme7R7fKpaNDvOvl80vy0J2BPqNCebh+k1KMud0UkuhWkSTJ1WDZjeS+r+ + fW19fL1geTt5hQD0mjNcQ3pGkebW/RDs+b3O/r1z+oWvlsH5gMvSNy0pehDivGlWAhoTQNpso4zFBHaa + s6QnZ0Tsh0nIvJ7Iojg3I4NySBuREXkhlOQNEcG80ReTkXeRF3mDlI1W9gELm6q4YroKs4tKHPpc3OZf + c1qQ59MBsTKpxyJD7uKU1VnFluvVmlfneqBn1c7k9rCevUMEm/mLlumyNZ4fO6ii7YpLYs71+r86Lrh1 + vKUqrWj23FdP0nZny7fPlYxNbGzotcx6s2JninX0gRlZ+5V1M3RpVJegbmxy9ADEjLrV6EY05ZF2hMz5 + qZ0MnUJ6tkdk5FivQJFewLHS1w3BIpmkBRmBOVrIIiByk403emUkQTqEnemabDO8iMnkRYqBOVAnKgbl + cFOdgHpNcJsygsJiMlWFZwAyRzqxaDqalFXlZnrQRnPfYoR0Imer8VowvxKL2mAzIhiiVlw+eSNCedI0 + pZbS6UMlF7SwZnRT5uR0s+YdOjBhvLrAotYarIaiEUMEUTSiYyAIyAyJIFC4iirbg3ssAezKqj2Rmfcq + aZXVl0DC0GhIrg0eRWBoRoD2nKjXGSo9pFZWnKr2WBuVA3mgbTYUmlTJKHSQ8ouOkyumQ6Z0UkdVaayh + CJ4hIjwqV3MWyjKPMoygH2MPZ2I8HZkovUk7kWmgTTisIyiJk0SSYd6Qa1iZ9ksoR4ipKWuRiDJMjvFy + TxkruyEncgiMDHYYoyMgLHRXjZileRpUIkpg0Rok7KpSg44TVCGjXsA4zccZ40FGZBuRKIIue1nsh8cH + U7ePDwue7fgIax6C3ncd59HH506+iysN5vRlaPBd/ZBO2a7xRJMh0ok3DAtKlA0FljNieJ1AAyyTds85 + 0kPKMpad8JoWTrZC66Sjy+LsDo286suWUTpNk/OOel3eS0DtIXCxnQ1RRxlbLw7OvJwDtehT8827LGHe + yFLMEpdP0PzL025nKL5o5jIgqVvl/X4+gnzRufboh5JN87zVg+v52roZPR+H6mba42XHr2LcTp75aAcH + CvTvG4JdMehPzYue+wlyYWu1nxKTtm4/pM2+uLbLtX4lWdvS5GqdyHjM6u8Hyb9XTBwH1nZFz73e103D + ep8XC0buT6vHsLnV5+vRT5ucdA3PaXs8VwcYfT+Uzws8/R6FEUfg/oPOe28+6usmnl9B6OdZbMow23nT + n26Ja588+7n9ZSe1DdBE7Z6W/UuA9C8XQfnnoPleNb/dcf1uRJClmo9S3D5GtkLsJI8uhMQOpaGcdEo9 + EiROiuZ9vc9Od3wdRIeU4m/ztVneE0TZxNill7C1MaWibLO9X8x9UsgjLKpOczL4/suJ+l8897n9jye4 + +rk68dTLPtSFz1zyZmbrZGdA6ziO0sxcDay1FuYurW5h2sWy3fy73rxYqvs6vP8AfYr+TrykRC4S5Zo6 + cgxbce3m5aZY7732S7c2drVZ7dXPn6c7teblwcXarl9XjrtZr+H1FNCpnR+94PpevLsI4xuvHWYEc6t5 + F7kJvldjF0uXXM1szV+l47bxnzrKMJokhTleO5ubnDN3rNcEu+eaxOyzbPl2/kXq/n69f0GPrck7VNTV + 0lW1EMy3AvJKPLoEgBUjJwMLDbsBnY2TVz7nqxa1nFTiIeZcx2HHWCU00+llaqWcXocArSjOWftHi/tu + 8s5lhUcrmDh7+X9P4da+N9cDtGfl+tp2cnT4e2hVln42PC6epvy8X2udZbzcnpcrTO1QkzueFs5WbcuB + N9DgtKhdzu1j6HOebo4jVuKexib+N6RBVMXIhm7Hs4Fd135M8yrajCz5vROAaNzjXKeh6fJXFIPk9FoK + hq3uj4/umLd7E6CqQjZfTna5S7hcugbtU/PqDToaH0/HbizcNu1ulnU1B7klttTj2IO9mZmsGzDNCcgi + pyXUck16ZoVLONFMJouEjKXLu52uOkjy1koFdobVnnDWa+23gllFw1c23qNvOtZWGA8cVxPfcFqN0WKR + TwhM1ef6PGjKa+RaftfjPsdlxOshJ2MzO38vfIR6rXnet8lzE6etE8+6Sb3cfLrD342JnMgTc1OZw9/P + 78suOsTPTKzuhzOPW5cqx93nsHzLOe7ZOxiefpYHbfn5c/WgPl6diu9THXl+gwOq9/lrPfl1xSlepS3Z + Hq+b0CFG0vKbGJ2fr+dxy7iPn78ZHtBavI9JYyePTsDnFU6WaCb0OQ7fipBvMdyW4G59L56aK49mQ5KR + M+bevTp+f0XdfNNx3KVNdecci5UqtXa1m+jmCfGj17UosJ2lxtrF2R0yPLJNKI7GBq2Hz7lOoqMV2rXN + tZ2LcbRj0A3lcK9Uw+HjXSC51jotPiyV6hQ8/dO8fgpHf9F47M9kXj97N9Qbzdl9GBxFmOsrYp7LASGM + k98px4O8Bc8hd2o1g610Sco/VWVyeO6vCMy7iRluSD6J0zyNzO5fOvQuTomzdQ+MZx3p84bHboamDpZ1 + j7mTofQ8Z2U+3JSv3eHpz7dyfLtz1Hq+WxcjqOf636f5+iLRh6/Bn2pyz2ygXx/I/RWulyqspo6OX4vV + Y5Hq+M7c9KvpZ3bjefT2fd4OXfqm5d+WbrFLyjdZHO+amO5x79Zmb+Nz1YyK2TntvFqXOTHlW1OnLtDh + OjwPIsKQ5cnZx9gSSPK5iPFXSz9DTWr25JkV9quZENUZlZfR5Ecs9QF1enRlKPQyLdmgs2dI9EhbekyG + nTOpp10m9ezNqUt0d0RikQRZmAqyoqMeArFRjUsYELOknyhizl6lquLzfUSV5V6PZzk83D1uYuZZDE1D + Yw0FRswlQJyCR0DVhT2GTMrauLLatZjVsvj27JanPh7cOqJzJNcOmscafWfSn81XL0+pXvJrh3gOTtY3 + 0Pm/ZcZb1GR0GF043yGJ9T89UjeitFXGbBXun+f9vLVmxy76mpnZnPWhg9VzXn9WmCxW53I6jlO39Pn3 + ziNmxtVLyEp3MqUmhXsCSR5YarYBWxks3iAaw4xRsQkAJk6OdLwFfXZrLa1HNzzwv6VFbeM+S6fU5put + Jc8YbpeZzosd2RT6PmuiL1ulbi5MWQb9jjujrVepUjRDxGkvSOyRg8vYTalTsBmaYKNhlVmrE1rfOMdN + m5doBW2LFnJZnpNg8mJ6dn15yP0LNOQls84PU2NI5SXcyOW6sOolfK6ilWNT2qS83l79PLNGeuR2cb3G + zxyXsPA259YtlN3jugzbhrFWt04bBebNvh0K5paz6Ff4EHL1+ik81PNei2POtCa6XFc8aGPskl879L89 + 9PatmgbntrGTrosXaw5dt0hJI8R1KelEiVy6m1yfVeaptx5dW9LDnWOrLym2DyIVJq8qM5Y7WFOzUjQF + BdLJbTahkvZfphNGi9Fy503LdKaF3P0yxg9LgLh9Hj6GfRrc31HF681mcDzp16VS8vJxMOb0up5HXZ1t + PhQ16iby22no7cbpnQPUsxKTEUTkQGFiIrFaJrWeeidbi5liq2d0VpOCoeq2K8o0PQsw5++2bZry5muu + /m0Ky2M1Ck3vUub6JK3h3ofIrQ1i2khaqNWjr8eGTqKmNcq9RmFTc51fJw23n98cYPtDnn8fTz2cZW7y + HTHmvr+Zs8+iKwsaJZpWpHxNrGXbSQkkeKAp0fb5+jfAfpz9M8477hvB6chOSdBN1HMJPcwdbTJrWa+N + RnEhXlJrCCuDiu03qxIRUpEiRZu0kLtZHVNg3AmutjkunzLxpzsSnXXp2OhvPgq/U8tnt1uDv8neHARV + zPSVgMLhoJpWq2aVjlElsdZyOkno97nNiy4s/FOpjl3gzRdHTSWMSKBROlrqwwrNWMupc5c9nVF48h1k + Ofs2X865ZJjsSPKsj22NeKS9XzI4BdbkGNDQzrJxBIJF3I098hj9RQtGjq0t8HZLOWJUQcjTh4krwrEZ + KPKtxNBJCSR4Tbr3emCtEXPXQYnR9NqeFR9lVvjS9mknjfU949eWQ9ThL56P0IScYuvHbzs9oSVI2hAy + hGaljAHL0E+ZR1+t5/Xj0VuANL6FPz4x3r8TYOrxK16zjMn0XEoHK+gcgnNit62dc+1sQJpQUQCjEnYs + JMhb2ZI3ueNWLFrNkdPs8HaT0y15jqV3kuU1U1lXIFlCUrs41EWBgcSsDYzAWPEhYExfs48TorPKI69+ + UsnSrDshqGkdOaqdmq5Y3TqMHWIwZBSnYSgqGgqGwakUhJ0xk6GRuLJJIkkeFalLRsHWs1eW9jRyLfTI + KhK+owxiDRFGCsKNp2rqSwwxxYbMvWkQ1IRDIJPomc8i5ElmG1dSxW0KYxCkSO4xFMnpZco0sa1oanl/ + fbfK6nBV9J86yQ6oTLJ6h50ZobQ4ZFYHJpgxygJmksrlK+la0KvF0YDl3W54Nnoer5yQ9LFyV+ulnROH + aEh1JRBSSs0mItNA2KgbzaIMRiDu1pz0Ua58FHUF5JR2MuNnZ165Up0q54hvLGLGnVHbCwmMxd7B3R2S + GQ0eSUetx+3KgHR06zAxly3lXMept1GXlRNZsxsXShnOXWoGluGyWg21zRtTeq46w0SY5l0Wy1VyFWYd + VXrqdrndmzTs8/erXNVkXyB5THbrR8nKdOqbH27wbQz46xq8vpXjjS+gHrnfLfW+USrznsflS4DaFfNq + ozmdK5EozkMLbDMEJ3llEsYHZBYsNr5l7eSZe/QzKWjQHjfU6/BdHudQbz7Zrq159oHYrn9IvqvMKoyh + J0MnUrNJqi6cZScgpKIKaUbzRBTaGd7oW/NtSzAgYydzG2B3i5SVZa1yHM7XH9vPf1Oe6LSqTL1eG+Oj + OGNspRJJJYpONKLidmqB61gZMiExkIpIiUJSKk5sa2FudMZfe4PVdufH6+T1Gswxdq55PZzl7Wx8dC7n + K0evm67P55RazrZbKnRcej1onlHR5upw/qLV5jW7XnIwehu9oeMAtV5RwKkBGw65szhJmhKGmSBq0a92 + 5Wrk9+5cdnbNLl0zdXJlvoc2df1mNvNnZKNro7MTRx4S9ho8DdO3JwWzXTTyhy7LV5hUKYRRlKkkJ2dX + SQk5YfSDcsHbz9ElRu40tu+EyM8XMVRTXFcl1/O9eWX1/O9b2xyOrnaPHXKQLLl1A1hgKcgFWYleaICe + xFKh4FWLlcqK5VqSNMpTshR0cpPVzdH08Oh6PJ0ZeQ7Xk+n6Yw8WGfjpeHfv8M+fxtUs97fq/jZa9DBW + 7ntz5Kn1edz1zUL9OV+i5PMl9nN4x0Sd5yHV2DyiPd8sYobkZaLXRAH9P445plETKSAJEmbLs+Es3Glm + 6eVVkTgnSFutC5JIUpNXV5iepqXKkqpdThUeevSvOWba1jWsuXS0+ZeO21POTaepn8u0U9ElxmqdBKic + sSCWUlsdkKeBBjZOukcXZxmt1SjJFPGsZJZvHD7aN1w+d6XyObxOthbffjiwiblsc50aVvJvBZjHFfSx + jGnPNYiWpI1DZcAlckaskqwiLlnTTGU1btzW78dZBYrb+BsWeb196DeafFz+NIUVjGgQINS9DgCTuK3N + 6FWIEs6zkYvWim+XL0ldnB67jgy+66vzv1deh8r0+8nj2j6XnGn5T3vlQF5xlHCwgMTRKxndNTKgKrmX + ezZdWcNCTKa3HNDbDLUNMI+uS9FkA64UYy8/WlUu0s1nTSu7HFC2CHLTJpe0+fInZdH5h0ep6RbzNOWx + MYSyWjcGx9fJXdi8UetYzSKtLKgAw+kbC3s3OvLd7M3954palLnqmp3jJMY9lBzWDMP0diuTbrLJx8vS + rB5XH1SweZT9bKeNl9ehHA3evY4630iVrdVRpyE1hnrNXO4Ho3IbxwVuPQ898beESM8NgQQJwKeUUXvQ + /L9Wz1cWPt6YOd3HLXOJzlyzLx0fQMeXneqwXj1rovB+gr07n7HQp5bi+1Yh5S3VczEO04n2isvzT23w + 6s4jPm1Q27A+rjtc66zi2EuVdROdD0NPOqbXB7ANVu40ozhw3li06XTMb7WwFWyKBCMGndpVZ7bkvQNZ + 279S2ppwrF0w5A86w8ujF2sWLs4a7KmpMgNwOgqmgSPKNXqL+pUye8llwV7sGrEbcRz5ByzqcUojEjqB + rLlRXHsqSsuV3O4BzIFKaGgUBcUXR6tkSoLvZ5jpekcnZ5cepbxqueOlZmiKyp5xIlEUfaxHs7fd8u6K + zvOYtmXm7nQ6h57k91Xrzp+vaXldjUy2e36bxC+ew1ed6sx9O2xx/nPoPJmQLQHLmx0RJXdxrKLEsNMA + i8fKKnRZNerZY67j+lXJh6d51x3UAZcOlApIdsFcUdQcJNTShZTb73luy3LtgZZSQIAupRMvUxt6V2TW + PhbmHLupkcuiy5dx9LgbvXidOrhmlEaTpUkopUdXIqaoUV3Vy1Q7NcKGO/fzoMvo1PhrGb0tKjalDX1S + S4QukfN5VurUvLT6hk5u5rVdOhlynXdOatVVrPleX7TxdnATYM1Ys5d+xKB5a8mFFwVe1TvMcX9zl6Vd + x2nkt+z1iXM9FpynL+r8jZxc7+VGlWo3SpcsUZe563wW4nuoeJ7E5zlfWGPFR+n8kc4G8GKELdqtvJ9g + azwiHXcZNSiRSGJUatAQDAyEbNdWK3DcRnjLVgYHfnDTzej1Ou6GlqUUjTlJWO4YcoGRvYW5KkySGVaS + 30lZzrRXxvoT18je+j5bSS78Ek6skqSShvNvS8VPPbG+/m9GTYvKWrIs4A5UDeTqOU42MnYTO0MztUng + Sxmmpc+tr1LOjXJdd6OUHlG55jzb3TEs8ZNvc/NGtVbYAZIETgLmkiOYehfzl0iDlD7vG6PTPpOv5n0P + Tnucr1W5nXmVP1POrgCbzS8/U0c6zPtSoZd52niRj3eXmXaBOd7WZ5H2O+Cy+Bc4ec1d7KloueMCiZKE + dlkFZGqvipyssNA/HYQXY51X67m/Qe/PZvCtw03kCHYmsYyEZu5i7UMkqx9LJ25XTKzATt8b6D6+RsfQ + 8t9JejikkMmkM6QqF+KchFS83dmd86i02GjJqZJxmdEXZ4ZpMrOziSVk0OYmd5alPYrXO8/H9d6OSGej + Za8j9dWs+Kk6rnTNjOOdQMEyjnGcGzdHOjUSZcu5TvahJQqnUdH5j0HTHbZdWHbw2IDbnrOqa1LvKdO6 + 3PtScwOHYk60muq7byElnvJvHO1Os4jsDnjmf7pzR5PDqcIpKY1m4SSGULegWLJK0bsFFNpl30jP7RnN + tFbOoqc1yLzpI0reWty+E0M7KsPdwd2V0yTnGdfG+i/Rc7r/AEPLqKAfT57MQKiko02dpcnkWehry2md + tX47puHe0pNx6pnRBKZBSYi02IwKiCZxmTq7pWMkxJ4zhkplXO3A2atTntf0ctdO1lvkOjuaz4RH1fgj + AOM+dViRJLPO0c804uOXPv5+jZKnbqAtHN1NZbZww5notTmOn8/LmqvY872tWQjejpZJTDzyqmlPmyXt + 0OujyrSNrtPMyW+6WfDuzPRcUl5PPOZ9xpJ4mu/5OqJZ2KDW6fZs4Sfp2ti+T9D6G8tewwoMqo1ujpOV + Lw51DH18hd94vIk1es3bzNQZOjl0Fvk/QPoY+P7PP2Q+dv8As8p6caKLKFavIRSmaER9RnM0b8OHeT0r + 3n9TJMjM8R2kwykiKdiLTgM6ZZPF0STUniwZQaCNCYHnenHZPX47a7c9ZpN0zZqtZs8pzPcOAs4ArTxt + APQl0hSjGfo0btiqWqlD1MjYsqyOBHlFY1qXOdBOfSVtAv0/Bkngs+gYdvOzakzPvlUpWM7y+q0N6mN2 + YxQXs+KDXvGr849geyrmt2RrwXiwqdddIWYi8EE6i5GISdEohiTPCZHK1MqXeUJWPl6eIupZhKR0yrkG + CL5X0S87s63o48Tqdg/0PDxNvqpZ6c/b1lLnWzxm5vCVwSjcr4uPehU83bSjJkizoTxVOooUXYSZEWkx + GTId4pHUXVTG4RJQmSlHlbEKltcfp9+O5Ga6ZlYpTs47lfZuds8tz+hw8asxmHNHYp26apcqVWu07SWK + ihV1njixq2a2ljQz59Mdhk4z+zlq28E0w4zR83YEDQxquC+OUCNTJxSJDTKXpeXmnsO/8/Sr3mp4eQ9j + B5I8eth8z1bOwBllU8YzlL0NDoZCHg9RoFJLeeL2PibWIu8mSOmRxY2j8n6UtHNv9uek6f3+OAyZy2WD + Zp6t4QO+MhJnlzuZRvx47iTO086i0mSKmLUIoIdk0MzojGcaeLMSUXHUZCdkSeLyyTLNkyVQyteKD6Dj + bvfn0kSN0xC5UilTzD2UOp4xV6bn86o2RHzYsqoC1Wt2DhOBbZNLCuYJZkkNUt1DTNSq6zrNWt2miCTM + IWAgwnitYshghWqI04OphxJIJrULRlGQI5TSA1K0q6HW4veO6drBcZ4GbqZG1LJReyWJq5q7TxSSTI4d + DXyPpluZ1rtjbdn9/igzgo0ISGeZirZz9ElOBcazx2avHVKwTMzvWZnZUJKyCjLUTOpWjOKRTsRd2pk8 + RMmWajKROzSkkKayZnhJOCy9kZW6fjbPfn1ESN05ishhV3zrvrdnhDepcDLjVL9PNDbq2gYyRDp2lAIk + KtJ2hqduoXqtmtrM0kt0+XYsnNzAoQs2VFfiUoWRy1R3hFJ7EoBdKqhCm8pq1oyNYRSDzY9C1Kl+zQHK + MuVt4m0rqLpRLQ11I7Kx0yOEU3+R9OBmJ0zuvGX0fEyk9iUo0ySlTshzgNiiztTN8/RULzbwC1ka+OjO + muYxIOxJMJk9iZ4jRkw0WNYCBWlUoomoqWaggzDnLJReV0nB5uqIpdbxy9HHsWd+mAxPny7uNauWeRc9 + 7p5hZyh5LOgwnCLCSWqjhQ6dpWp3KdlwFgFiToicJwUJwXTWZYD2YDstwaVgJAjKZDeLIHVFcTyyUWCP + XIEhItnpd5nLcUKXP2sjWEmSYu7g7qu7Kx1FHGyE/wAf6RXDLTemA/0/E8h16uNkixdpYkeO9inVtct1 + rhLONWaN4PTGe8Zd+NKVnN59NZCVhRtC5lGT2wUmSLuwydgUpBuSRmNWZ0ReMs1PFhyicM7vKzEQJiMC + oacbMzs+RF2x2mTq5XTGrEjBy0LBx/n/ALzwlnm0bgs1QMPOguAthWk0saluqWgmHrKaURjhNAxkhSZI + WhnubA6QVtyi8O6Q7s4nZVGtIZI9cyWblTcru79O4Kjcy5dC2N4kmjWPu4e2SeL2VVUWtYa1JfB+jlvr + KKINZdMZFjQWaIybNeLxlUXQ1uvb65k7v6eeQii9HnQDtLUuZl/n0KzLWBShLUdnQzsrHZQHg7EZRijs + yV3kwNnnKzlRCwGQV4vDNNpYtJpYUdGOpkb+VkdufoiBY6YhAsSdzNIZ/D+q1rnxil1/O51iGiWV2k0s + BFnZCLvZBiDGMIoKE4Ds7KpwISHOMWpM6uk4nSseEoRWSelYHZRdRzPcVvaNC7EMzUypraZNY9WzlljQ + rniTxezFUE1Nxv8AA+jNDcKhvU3jPcmzv1yJEbjqKlInYAfviTs/bNOlr5HbimdbwGvezePXQQ5akq5Y + azJpOM042J4yIxkpYMRA07WRSQAzShTilkoSCTEYiotnUkzwzSehVb0LMPtucy+uPQGp3uvOAzRGuUXL + vn/fGs+f39S88KEbQcapupQzutR2jKVKcKCzuRd4wxRGqLtOLCTyp0rE6SpndAo6GJCYD0Pz/wBS1Llq + rZhsrVyprYZNY+LsYsbsovZJmZcZJZRcj/C+lGaSTICVFQ5akmeWg0R4gRnClAT0ZLIUumZ42xndOdV4 + T68mCZS5d6lZ59SxkunNPCYzSaGeKsdRcSZEJJqZThCZMOyaWRByiYpuqkMkO7KV0mHZIjVuRrnuyxsb + tz9EbK1uuIwLFBWq8TVwdG5Z4/m+w+dnGkK+bUnGY0ZtLKM4UGcDAomgDMKxADCOEdnV0kOkkdIIQYnJ + WqtwH6p5z6dqHkmlEAd6Cs8aWNr5EbbxlT1LWUEVpZZzmf4f0RyTE3GqMhJSKBLErD9sVpSjjRZiJ1zK + TT6ZQLK6Zw5NLvwSSBZuvmcet5hl3kU5QuZtJpYNJWRdMJpMJJEGlEeE4Ek01jJKFJnzUmcIhkV0zRJm + mRYrgB3GOc6Ovh9M+gNz3RejlGBGAlYcaI61qzzXmfdPNrOFm9vOqLW6xKBBJXKIikg0hjDkV7VS5LJ2 + eHdnp2dCAcCJTVRshNGn6Bx/bWWYyiuXsY+xK0XaytWjclsvF7JYe3hG4nRkJL4H00kiUkqUkqnrJfS8 + mtFL1earmJcOzCS5dTjSxqtWSztpJezyTSVjDSzrM0Eue0yXTEnSRklKopUkkJJI0ElSSRMkO6QklKnS + zXmksppZOks6dkqdkkiBKsTXS646lkvRyaKSDkktmaScZwKVjVUs6JXSgU0rEySudKKltKWTpSu6VJ0r + GCkSdKwhEo6vp0tS/BKXL2EsopLTE2EpZOlY+Eku6kk//8QAMRAAAQQBAwIFBAEFAQEBAQAAAQACAwQR + BRASEyEUICIxMhUjM0EwJDRAQkMGFiVE/9oACAEBAAEFAt5XcGfVWgjU4im6hAVG9sg2iALehGuk1S0I + JUdIhUVAxqVpa4bvGWv9Lqz1I9cyF1SVXw9SPDT1GrqMRkauo1c2r9bsYGsh9QYEPbV35uNDnrSYXxS6 + 12qEoAudbrSVZPYxOL3n5MJavES4ynoIqBvOaY/cQVDBmmkM9Z3ux/E05fusBMDmYB7Oc1rUOm2Onb6z + z88rK/1dIxqddgaq1+J87L3Um1OCSaNmlWXKLRzniuI8nIBGdgRstRto23IzvKMhK5LKymSlqZbTJ2OX + uuDVwWHrLlyXILO5Q2snEG9j8M35EFpB+xnu5yrgSRiuhA9MjkaS9zZJrbom23YeCXIeze58NIrVKYuZ + BOwvPfk1AtJDsF7Q48Gr9BNCI7j23Z6o4mhoZtqX94XObHoL+U2tf2k0BZFp2PHf+hP3lH+QKKNzx4R2 + G/NyCKoMPjLTS2Ur9VOxldiuGFzjGeFSNwMQxFIU0SG5b5uLm/08QggNiw2JePe4gahIfA25YmaImaTW + amUq7EGgbmRgRsRhG21OuFGy8oyuK5lZWVlZWdsrKys7ZKZO9ijupkzH+XiFxWD5Lx+xsVL+Of8AJtpB + +1nu5UPbiFxOcdpWOc+1DI6G0MASxJ/RKgP3xtla+MWcrK5FcnLqFCR6EsibJK505ngMbuTN2HEUTiVF + tfZz1KWJsb9AB6+sf2lk/wBKD3mndK8yKB3KVUfTWNuOWH9lVm83sjYxsjndS49znHaAemk0OfA0tY2F + dGMIxhwsNEMI8a9CleevpGVHpNZibWhagMbFwCMzAjaYE64jbcjYeUZCuSys+TKys/w58gJUdiRqjuJk + rHeV3YbXdynfG12m20g+j9uWnpjfSR6U/bUB6dofyj22/wDQj7vlgkMUjbXGSG43xGo2IX1K/wCLdg5R + RswmABBanE+K3Meo7T67YItX/s7f9oiE9VfzD2itcK2USvcwt6dlrvS8+ux74RC02rI8UdPna5tF2RUC + FWNYG2QjKwI2YwjcanXHJ1p5XWc5c1yWfLnbuu6wseXKzvhYWP4WTvYmW02Vjtnb2O9nKyiVntd/PtpB + X7cqHvG/AJ2dte+Dtovmz4nkgStaYCjEF0QjEuiqdOOR0laKQO0uYKvpzWsvwdKxX/DvE4NiEU73V5C5 + jVZjEscVYNJK1g/0LnktrRdR3gmhGrXAIY2yxvNHsVglQU53EwT8hQ1KRR6DYco9BiUekUmKOCGJZARl + ZzNmMI22o3EbT06aQoueslZKysrPlwsLG+QsrKyu+2FhY8+P5K3UJB3Pqv8AJckXLKu/m200nIdlOVH8 + m2QisK8PS4dyFH82fjaMriM6uPTHZYGeIgKdJWKmMJbWhIFmk/lDHZjTZGvZI8vmZGwipSiMXgoEacHE + RNLWMwvYtPbZzgtT+5Ts6ZYqxQe4HbK6EkkkOmWsM0R5TNFhCj0yqxTM7xODGmeMI2mhG4jaejM8ouKO + eays/wABG2du677YWFhYWFhYWFhYWFhY/wAFjMmNvFkQ9T+YXUeqr+paWVERy8NEVNpNeUnQoEdAYq2k + GBz6DiTTmVWvLFIs7Z2ufj6MJPhY1ji+D8ROE1/Juv5EYz0Oq9dVyErlT1F0aa2Ky29eigXju/XaTDE7 + wsXZhKzkZ7mVy64Vc8mbGLKsQSGG1Wu24odHiAbp9dqEUMadNGE63GEbgRtuRsPUUuTORxzvhYWFhY2y + FlZXfyvHYBYWFhYWFhYWFhY/yGsUbUPYNwU4ZGnDZyaewLlzkQllQsTBC3MvGSrxz0L5Q1ALx8aF2JeL + hXiICi6u9eGqOXgKxX0yFMicxvF6IfjUqktyP6Taa06RcCdp1ti6MrUWlRTSQumJe7BRZD4aAkwVJh0n + SBNcsOyK8rk2k5RRdNuAi5gRsxBG7GnXk607BmeVknfCwsL2PUB3yu67rusk2OKwsLCwsLCwuK4pzSsf + xD+HCwsLCwsLCwsLCwsLCwmtTG7OdxUbuTVIcMoDEBRUeOHTXTXBcFxKwsLCwsLCwsbd1krm8LrSBCxK + hamXjJl4yVeOevHFeNC8TC5cqzl9gSMmrtXiIF4iBeIgXXgTp4sG4wI3kbsiNqUp00hRe5FxQ9t8rKyf + LGFhYWFhYWFE37uFhcVx88g8mFhYWFxXFcVxXFcVxWFhYWFj+ZoTQmjaT2iGI1bOK9YYhRUBHEe3kwsL + CwuIXELiuAXBcFwXBcFxXErisb4RHfCwuK4riuK4riuK4riuKLUQimD04WFhYWFhALgi1cUwLGwCwsbU + u8QCwsLC4riuC4LiuKIHLiFhYWP8vCAQCaPNf/Ezs1O9q2MN9v8AFwsLCLfXjz42wsLCwsLgFhYWFhY2 + wsLCwVhMasBcQg0LCwpPTHSbisnfwkffcPLgrG3JiMsQQe1yyvGQ9bCwsLH8wCCAQ2Cd+Ta73k2PtW92 + YAz/AD5XiGIXYcixGmzMK6rOW5Hr/wApvmt/gj7MRCxthYWFhYV2fw0R1Yh7tZkK+rTlfUrRXjLrl1rp + RNorjOV0pV0ZF0nKBjmw9AJvfXMrKysrPkyuoxdeILxUC8ZAvHQI6hAhqESbCSC3ib90U2UNQ8S/YLh6 + tpfVe2PtF8rb3xrx0wP1GfI1OZM1ObLJ+TK8ge7prprphOgHGWy2Mm/EF4+BC7CV4qIoSNeJHYc/Bfkp + pKpOd4oFZ2d8lI7iyGxYkBbbJAtL+oRlmaPEleLUVjqPyWqKeOVnZdtpbMUTvG114yuvGV1HYikPWj6n + lb7eW0OTI3cmyXYInHVKoR1aqjrFdHWYkdbajrZR1qRQOmlrawZPD1REI801zprrUwvF1gvGV0ZWy7Eo + qMcnkFce9c51nkrWrPisDV5ivqM5XjbBXibBXVnK+8VwlXTlXTkXTkXTeum5cCtPh52nNyum1f8ApCOt + oLfu7ZwGP5HZnqvbFD5XWFrU/gD2Tfdj/tafJ98byfG9+SX27rJWVQPec+r9lNVQ/wBUB2wsJ7TkBWu1 + eTsg4oPeh1FGZXuMciLHqgCLEh9FE9rVoxXJLpBoSySWNX9NrqhdYIrRBm3eIZrl2zM2fr3V4q6F4+0E + NRmUDnvqnVJghqk6+qTr6pYTtWnaDrExUWqygBxsy+EavCMXhogvDwrgxcQoIerN2YP/AEU2ZH/g2C4F + EEKH8e9Q/wBS2Rzk+RwVN3/6PVTTyngbBwDaq/pFmqupXXWhXXjTp2luUds7aM3lccFxWtP56loY7bH8 + cPy2p+qbYpvzusPBwWBsPeL8NA/1IXNq5BO9tQ/I/uNgqHzn+XE7D3r9rTQsbPbkhX+1WZ4Ehc3kxnp7 + uNHlHJFLK4xyuc1/JwtHhBSWsdr/ADa5V2Mjk1T1WNhXiK0xjYLGpn/9F7uVwPcuo5SElyd9rS4nBsT3 + glkgag5j1gLiFY7CrvyX620kcbDp+AuymeeX4bRgEl/TLnuedP8ABioIqmONRFtdpzXQfCtRtshgqnM5 + d2r+0fkys/waM7hIJsqaz02Sv61rRxiDZvxbs44bp34kEUPlba7pu90O6wq/4qfay3u0tagxiPtqf5HL + 9baf+WwPXSghmMfTQdE4els7VhYT25QC1If0tuIlwcXSR7UW5dGVIRxkdg25XcKIWt9rsbx1B7Xjl/7w + owOJ4q6fvR95kFC6s5pZUV2WLwB/EuzVSh6jDTK8E9ahCY5a3wRQChf03tuRleJGRe4Dxhcy/J1p50eI + iaC4vhkiCiCriZscELuXLNt0fqfA3g0cVrLsKn8pDiKsPRGhsVhNdtp1Zk5+n1kNNrLwFVeBqrwNRMr1 + 41kBObE9amxjdU0wYq7TdhXGIlaOIKYxXQRC/dtruEnu1E7VfxQdrEfwQRWrj7hWE12EH99P72LI9Zc5 + j+/JMP3GjthYT2oLVD9l1SCdM06sE2ixCivDmFaYW8CeCEzpDqBHhqQWuf3kR+4zvFbZgn3Ufyecqz7w + BDttXIC59MalI10J7ObgkDJrD0D5Yar7vvQjEa7YWMqsWc4fSwTDD5G4k+VlPHoa4gmRzmj3MxAiLxC1 + /FCPFmR/Oz1eEj7PF+pyOfNTVn8EH4404Fu+N84PWwoxO9he0ylrl0SVJBICyMtVgNBd/c0u1VBSs5NZ + 7LUDivCMRpqK/djlwd8t6fxj/PB+NMJxlauPuFcVhce+n/3Nn8kvy/aYDyj+Gzx2Wp+3BdNdNRxkp9Z4 + bWj4PjLuMOHSX5AG1Wq65wtcsqI8orTQYjCxeGKrj7kjiFc+MI+3jKCjPdxeW2PlKCCPf9w+mM/jld3l + dmRvtuG5TAA559D3NcSj3fYaXPkcS1DONuDK0AL5S5zkZSyaWw5hk5F9l2RS+Nz8EXxbv1WbEoKE4Faf + 79F+JI2f1FmTptE8nIS8n9QtOpWI3RRfOHtEm+7pfW32V/uR7JqO0hd05PyNIDp5ab6yqL/rW/Fvq49Z + 9wtGgrzz6lDHBapf3Nr8ko9Twm+4PeDvDs8DCuRGRBmEBEuMKYIwWyFc3rk9ZOdUb1K9QuzYpvkl8FID + 4fiLTcVC1FvZoPOT1NsjKrGMQjwxUjIgyoGmCWQvks4Nl1WVx8LMEYJlVHKw4hp5cmjvIPZY2J9MTCYY + 2AoubmQemPvLPM+F+2fSgrc7jaokyxyBzk2MAMkYVx6rb8bYjS/He+DW4axE98o+SHkWws9dX+4wGmcc + nTNj6LYhh8nGSZzSaozIEFH8sfeG0/qu7NTl+256dgfewEGtXEKr8v8ApWfiHrsXiI11mFawPUfeOPmP + DrwpUDeFq3jqSMLj0H58NhdJ6q/2+z8YT08d+K4J46L9RPGwx/JtWP7Blc4uEpdFBgd41Bae+xPYkhda + uCyzgwrouaemE+NpVyNoTW+jgiw5izGJvze9pZcF1JMwOcZHeqKY8a8Q+7HO0N68K6tdB1dP49WCfhVs + jpho7Rv9Vfu6KvUlZ9OoFfSapX0aMo6KUdFkCnaXM0ri2rKzNu1I+WCuT0g4cNUOZqY+1e+XHKka2OXY + 5Q3c8QVW+pRRBqe5gVkgxEEPNPKljIdIeK04cpwgo17u2b6tQ2ais8BUd9uehXmcdKgX0qFfSYlW0yux + p02o5NiMbeL1wkQZIpqcc6m0aunaO3P0lfSVR0prZpdNhlR0OAr6DAvoMGY9DrtcyJrG8VxXALgEWNRr + MK8KxTUea+muT9Kc5SaXMBYM0FMXJAn2XvTLkoQulypQVmXNQqz2F9PtRKhp/Ws39Lia14t13fU5eYti + aPqytIslM1ANjiu1SR4V6L2R2xPGVyaUwRlMgAT67+leje2rVGZA1YWEQeOCm4DHP5wgdrZAhpjL+CLV + jaBzurDPO4Ml/p9Kc5rqXHlfhMba2MOKvn7tUHpWf7l5BAx55TllTL5ZIcM9LntbFUE17qPkP2w37d3A + g0dubAQTx9mv8xlFU/VY2aj2RVV+IXxog75K5Fc3Kaw5i8W5eMevGPTrrl4ty8W5eKcvGOC8fIvHSLx8 + i8fJjx8i8fIhfemXC5OnfxbM9CVybK9CeRCzKhalQtyo2pCm2kXwSo6fTlT9HgKZSt1wbF6IfV2IarTk + Onyh7tQ1DjfvzeLZ0HMeMtLnh8mkU2vq6wyMTk4c3sXsbI5ld2S2Viks5UEzHOfYmjkje6xHG5kDxZYU + 2ZmOYULoCweGTY4CnVw9Co7GsxGFunD7uFhcVwTW4NSH7cdV5lptkY8CWazfnMUNXL1YcImWXczWH2Z+ + 92hZbXQvxFeLqldaiVnTyunQKFWmVJTqhkbecenvbFM6dvGJjMtcfDj5YIkLu192RojfuDKCGCIW8dnH + A00fb2ainKocMHdOYnRosXFcUWqwEJQDJLGuYUrojEx6hfHkugyHQqQgSc2LqMXVYpXBB/bmuqVUkLw1 + MTQg1BqwgFhYWNhLI1NtyBC6F4mJ6LIZA2ONgfpjSpNMkClqvYpBwbA0TPt2I61JznvToy15qxTvbQnY + hCQumFdZhV2cpJBwRlPHotkXhXJrHYax66gbF1nBCy8IXZF46Vam9srK7jG8XSvGLxjULTFDaY2Vtuo5 + Y05ybDTKEMfRk0yN9atpctc39NlnisDg6EYjxyvhqwsIhY2f/bsHZj+mmhz38uNek5vQu1iY4iiiVc99 + Fb6QgpZOCi+KtHENEYr7N2cqRTe6wnNRauK4ItKstTuxQKJ7N9wUUxSe49tnJvx2075tamBNQ3CwsIjy + YRCCEsgTbUoTbgTbUZRbFKhVhDtRoG0x2k2GKSCeIud6ny9JfUJQnXnFSOa9cem5/JyhqulTKNphZDLJ + G2nO1RuHWPdrvie7nMLBgLgOlydz5HLZGoODix5cmkp07XISoTlR3ZWIahOANTlQ1h3OY8pGDtX72gFh + cVwXBcFIzIbVKZWe8dCVrpXER1+rPJPIWRcxPI1p4yERCxN1naQ3FYIKy0kM9lqB/p4BiHZuxVP5sORs + QiNirQUv5EO2w92ooJ/kd7N+GVlae77zDkNTUNgU1DY+Uob4WFhNmkam3HhNutTbMZTo4ZRNpdSVO0Oq + jo/TT6U7U+DihG3JiODEU6Hv6wi+ZGPKdCCC1gGe0bY8UqgMDtOjUumxi1Jo0bi/Q8J9B0L5mGMv77e8 + j6zQnMeFDxTYQU2AdZrcKOUxyNtYXiwhaavEtXWBXVCrT1+gPAOHhaLl4KuvANU9aR8LtPkNX6XbY4RW + HNv1JyuJbNpoxUCCc9pLfZX+6HYbNKBWFV7TMeMGZi60aM8aM0aM0a5BwtKdkZe+m5sHT7liZ8+A5dPv + 0lIodJ6kLtIDC3SYyb+mRw1mfFtWSKPwb5hS9NqP2YmoK9NJG+K3LkTxiKOTkdRr9eOeF8UenTvMY9k/ + VS2VmpROUcrXrkgfJhELisL2IlkahbeELbU2eMrs5PgiejptZxfpbU/S5wp608YcXOMBrcWx6W5N0/Tp + E/R4OI0x7BAJ4GeJcFbnhkjOrM4x6yS63d6z2OjUoHLuE3JfRrGGpJVjctR6HixV4ER81IyzCwU3Oaak + wTo3tXILG2VWj6gkc6OTruTbLwm3ntLNVcGx6vhzNX7N1RqZqTHqV/VuVW4rhN92j7+1j1W9+s0vAcGt + yoO07nN4PkbnqsXWjXVYuqxRTgGzJ6Y7QhYJC1dQqSQva38lm26wySdz06y9ylOVFdkjjdelcvGyKe3J + LGz41jHmXpcaf9zHlNTUFqjRmr6ZuzoIfaa5ZZY6z7DNN94/aY8Ynn1czyjcV4ktUOqBR3YXoPBWfL+8 + LHkbLI1NtPCbbamzxuQORLp1aRP0WIp+iSBSaXaaulYgLL1pibq1gJmstTdUqOQloSr6fUlT9DiJfoLl + LpFpgmp2YRoFHq3Se9qx4as5+XR2nRqO+xwZajiXFkoitYcnugevD03k6dAUdPj8Q7TGqdhhljBeTQkR + pTLwk6MMoQy0zakJIoLETDWGXsGGhNXEckU31ajuYo1E9pYPdhxK4tVrtP5IziSye0h7lD3X+wPfY/Hy + R/Har/cR9lGowgFbY2S3AzjNk4rj03f7uqPt0Bh8a1J3GgfdQe8x+3lEqOZ7CdQmBi1R5dHqULlHMx4y + v35cLCwsL2TZ5Wptx6FxqbYiKHFykgien6XUcn6HGVJocwX0i4jp11q8NeaDXvFSRzMXYLSc16xlAWv2 + 2SOHRTRXB4VHg0IHoaeWqatOmOnja2Z8Z8acR6g1jRqA5x2JHKzJznoDlYLVxTAmhBqMEbkaFZyj06sx + wCwpyWwQklzTlFU/VZ3fcLHx33NX1J6+oyFxLc3u1jyNVj4y+59giv2j7FfpR13PZ4d3EqP22g/Kesx0 + Mrucbkw5Go/3rJXyFrSqo9E2mcrNmNkTaB5Ss9tedx09BQe9p2BsU73Qe4Jju8F1wUEgf/FhYWFhY2bL + I1NtyBR3g5NsxFNex2/BqfWhkH0mpy6IUkR4zafb5Oa9jhIQhOuquoi478criuIQaQDXyq7HQvbd7MtR + lROa8NQQQCCAWE4ZELOATjhaaPt72xiX/bbqsa2/3nx3YAX3qdaOsv1LISx/dFALCf8AJNie8SROYcLH + Zge4yRyMCjGN64zJDPKwdckmTtFFM5tmlO4xxTtRhcFUMzV2V+JppUXRxzsewr/0Z+0QoY/TCpzyk2Pk + j943YNOeMrkp5+jDFqzCmXYJEHLP8OFhYUPdmzXuam2ZQm3ChbjTZo3LOdsohrhJp9ORSaJWcn6C5SaJ + baXUbMYeC1AlZchLhdTKjYXDw714btBRfKW6O9V6ghj6QXTXBcSsFDaSXgW9wrTuMFEYr72Bmx4aHqCv + XTq9fFJokOtVyx/7WdmNLiacnTfXITYMHhMU2lKUdJsyN+l203TLi+kXSotFnJOgS5/+fkX/AM+VFoTG + OfokPI6JET9ErqHS6kD/ALITpYAG2K5QkjK9JXELint9DC+BWLcs64FVqAdTm7osWXMXsP3s8+RnsFyU + VqRis3HSUwUHFR2HsUWpShQ6ixxbICgd8LCwsbH2iGI8LCwsLG4JCbPIELbwhcCbZiKD2u3yj3T6lWRO + 0ii5HQ4F9BwRojUNEqpmkU2mOCONY/hsDLBtqB/p4BiHex+T5PUh9OmPaGyMikb4GgvC0AunQauVFq8R + TavH1gjqVYL6rXX1eFHWIl9ZYjrIX1kr6zIjrEyOr2F9Usr6jZXjrBXipyutIVzcslAoIIIZTXPQmlCF + iVMnDhNQgmDtHnzqL2dGzUa2LpqLS5pq3HCLEe2zu/k/Ww95D6FlctoyU155MuzxpmptUdyKRB6DkHLO + z/hCMQ+XCwsLHlD3hNsyBNtlNtMQmjKBzt+gUXALm1cguSyV6l6l6lgrBWCg05zsVqHdD23te3HDVN8a + ZHRcMh4R27/y5C5Bcguo1dVq6zVFI1yHdwag1AINQCwsIBMcWqKwpa1ewbOmyBksMrJbx8HpZa4I5XqR + aVxLVhrk9ncDCHx3kPfYbM9io5iEe654UVlzVHqEgVe62RrZAVlTOxED2/jwseYEhNnkavFPXiIXFk9c + IWYkJYysg/wkf1CcrHqueS61H4Kb4VCBFLYaxG0wp07UZV1Subll69a+4jzQ5lcHrhJxZyc8V3FeGcjW + K8OvDhdBqj08yN4MTIw4Ss4uje4pmSmNKC779l23a4tUdgKRkcw1mpYlPHC6fJOjwsBU9LhNCYM6jgne + 4HbGwTjk+QJ+2UHrg0qP5scQI7EjDHqbgjeiljZICuSys/zY3xtjyhxCE0gQsSrxUiFxyFxC41NsscsD + knJvq1LeQ4j1GM5juhrfHBS3uTaU7ZWXe7v9mgykxYHPv1nBeIcjZOTYXV7CUBCy0O8S0guxJHZDWOsE + l1glOs8V13LruTbkwBmeXGRCbivEPVF5MTXprkCsoIbFoXFq4rimuexR2FPXgsifSJoy7StRlMGizMm1 + iZjabq8apaNHNSt1PDzFq7hZC/eCs4asJo9TU47Ebs7Ae1CJrW3K/SPsmuc1R3pmqLUwo7Ub0H5Wf8zC + DSyvA4kg5DlS9Vne6cVrTBIm0IGhsMGX9HFDAmvScU6cFF7Vyai7s12ByauYXNNOD1HLquXNy/fdd1hO + 9isbfs76d+NddjVBKJFkBNkas9pr04lGpzr6qVUvtndsVG8sTbPdsnIDurmnRWJLemPiQDYIZ/vTEEJ2 + FgIMRXDqIsI2Aw32YUz3O/8ApFH1C9/J0FjpxFsciLcbNwSzSpJYoZnxyeMLYm37AczVSo9RhcmTNcuS + ys/4GPLExcfRXbwYnHC0wfa31E/ZtTPid9Ts5N6RxnJMNBzRZ1HBj3PsPjuPfd3kd7eQ76e5Pk6YEHAw + W6723g63JpTIoYrrw1sVSUIwEGtVimU1WvTd02lrm4Ugn4v8YxdaYqOzNGa2rd45myNLQ8auybwpi4Hp + 5T4AnQuCfokoila+J/EFYcF2KIR7nZp74yuKPyHorAp7siKueDmHLwM+ypXJa0gdl8h9I9SkDOJCDsJl + uRjY9SUd6JybICg5cln/AAGNUYUsvTTNrJ4wUBxrb3u814/1D+mHCXCn/t67wy3fIdBuUPxncfJd9nL9 + 7O9h7bHfBKqdif7XS4GvdH0Hl7Qb8NSFsdih92GOTEsT3IMMC8fHzZqjsS2GSPFiZeIlT2XcOMwUbymW + HRurawoZ2TMmginbY0shSxyRHSYRYtXJhXrSl0j+LlhwWCg3CwjEi1wTSMeyHdMOXl5KL2PZA3qyyfcU + 73Mkf03ApvYNyVE0zIHC59g08fpE/RlgLCyJzk+H1mlbgjFueM1r3URsMayO/A5B4K5LKz/E0JoQVhhK + CKvH+ngGId5PVqFz81kYmarA+zBjxVo/ZPvu347j54WCuKkGNuK4p+OLfjgLsn/FYKwVAwtdN2p6Y3jV + YMGkOd8+2o3JA7rh7MucjHKrILZmkrmAqttlmCSGMiC2YR047gdUYE6FrV0gmB0boNUe1QzxzNcxrxFX + bXWvXHGTHYgItRG/Zey4hYWewHFgKIwopDG6rZbM224+I+Tuzg/s1p9fPjsMFMkHFmsWmQRudK4+iMHB + 0/VpIFPBXuwR+8z/AEdVMlwmXZmqPU1Hfhcmytcg5ZWfKAmhNG3UaSPYrUPYdhvB6r1tW4XumZVmy9nJ + sjOjbulH34riF2wzbtsfn3zgog4lbhrWkswuKfHiGLu0BYU2I4WOBTW8iW9J0MjppbfZtZvGJ3pg0hv3 + pMhtl7ZhBblgP1CdzYHWJZNRPK/+nKCV8LtK1H7jiyZ0cssauVnTOl0+RqNJ2XVS1PdEww2RE6t/6AtN + S7DaDoY3KzpUblZpSwotXFFq4qrQjFDVaMdVE4XJE5UgymnDnYKyonljpiDGPYKR3ri7ud752KDSoiGt + fKbEnR5otc1zZHARqwe24kcEJUyRMuTMUepqO/E5NkDkHLKampqG0Y+8nKx6r259tN7rqqWY5b6mOypO + z9Qd2LO2FhYDRC5vVewxlYUr8vDmzNazknxGIzuy6KQsXNvJ74w2w8uePjzOJJy8P7n9u94e79KZzluf + 3caunjR0Zvpf7SZYAzqIxkKB/Qc7u8ezk32b709R4h18qS1KR4iZSWZSp7Tnx91yKDsLnh9LX5YlS1Gt + bRAKs6dFKrOnTxoRWCdKidJex31mcWbuAsbfvKwCuBBaFdriKEHs3sMkqMduk4ojcFOd2IMTWPOXRtli + ma6MtU57+TCxhoKDyg9Nkwo7szFHqaq24pi1N2CwOSKZ6tT3ndxh01uK4ATgE3C1ZuHPVl5dHzLX8hy5 + xYlcTsx54Mm4qR/MlMPrJIOSS5f6u9h7yD1NBLR8P25mF08tcoM50qEtfJpTpHxQW4Y7MVueOrDarydQ + uVuI/VGRNFm2T1kwZQ9npqCChLUHdsAiOlLLH4BxUmmnEOnxPU+mPaXtwUDhUdcs11R1Wta2dGCo6bYp + dRsGtTLXYxvhcVhdwvdcSNn/AIlH6R1AjlzsFYBOcAOynuLlUcyNof3lcXuapY3eVjcogojPkCa450tp + NmN2UzaYZhroHI/dH1Wd9QOK1YYgynuTHrVRkSBQMzXm/I7Z6x3j90PbiV0yE5M93x4ayPLCwgRsPLo8 + 0K0sSdC4ptCfMekWJh9CkCGhyZZojWur1Ya4LmghwXZdkQHDUoMzf/32W8rUunugAZxIiyyVpy1fpnt/ + q0lp6no0R5bpwjgkMtZ2ZHuqPlvNcpujaU+nkFzS1yblUNTs1lS1OCy7KsQRztn0qNwsUZIU9mFhYQX/ + AJysHG5o9WRX63hJ8oTBolPULW5JHdroumOki2PDY+TrNTiHMLVyRyT3R+X6BLU+JkqewscmtQbxDvh7 + ojyRDJ0lmGM7pu3uomhgROFpf4d9SPZgw1PTPfUxmOUevSxyisR/fezDWtcSG8Q0etzWlOjUMXcaZamX + 0q4vo1pzo9DsgxaKwL6LUX0WqvpdLMbK8I6zF1gusV1HLk9epYK4IsCDe3FcUx2DIxsrbMIhsP739TwE + /uIZcC13kjT+wj9v9U/8WnXJK7YNQimY+boMa+Odl/S+LcKOw9jS2G02TT8FzS0hBU9TnrqpqsE+xaCr + OnRSK1pssalBYQ9+aMPhqksgZDYzNOWBO4lYamNaiC1c0CuZTCGgSuaySSAjwzHowvhTkM5HvtLlwwog + NnHJTvJCPRUZwjjCG073MLfZWTxrUBxq72vVcWE/CjV9v2njMmi+1nTop0/Q2FfQ4VFpVWNCtCjXgCDK + 7EJI2rrLrFdRy5yLMi9S4rgFxCwsLiuK4rCwsJw77n5g4VuHrwy1nxXdWHp5ZYPaTOWxlql9mtOP9FJ+ + KAB0eXMNO/NEIpo5XR3JInSV6txs2kOY5tIueISpPUDU5Jwcx3derFPULFZVNXgmQORgFPrscpqkbk1x + x/6CzxrItynMRG3JwWWlGJZcE6YPa15aeohN2ilbi471w9y7SZfCuBaUU5qIwuoSI08DB3Hc1WcpoQmo + bTM5tCK1A/0sIxDuPVqWxXZSVnSMbojedXSYq5EQXTauLRuW5aGkLCwsLiuK4riuKwsfwyOa1A53PuSm + Pwezlq9Zf6N9u3VdgqZR9kdpfxQt5RcziMZIkwKN9wbFhx+odoY60z3wtxK/1ysmCdylTGyBFqkrtcXt + dGat+asaetQypjw5o4p0QK1LTp5rM1d0ZLMLGxjRaQsLuFzXFrlxc1cyEHA7SqH0s03U5KhmZT1WC3A6 + tPlH2xlcQscU458lcZfprMuiCCCCEuXorUO/lo+qwjZHJs/JMc7rRu5s3Kx5J2rH8Je0J9ys1O1Wm1O1 + usE7XAvq9pyN3UnrOovRqWZENMX04tXRtxrrakxV9SnbIO4wgcLs8atSNawPaT35njV9Tne/6Km/FW9p + XepiJDk1RzlqguskNW3WqXGSej0PXELWa7+T4XNT2AKOZ8aEnURia4nLTWty13VNaY5RStkb7qSJsjbO + kMcrFSaFYRbsWgosKwtP0XxdK1p1uostKIbkuw73TXr3TXOYnFxWfJhHyVxhlGLhDGEEEEGHrIqf1X93 + nDdMH2Vhqygofx7n28kvwc9rU+7WYn6rTana3WCdriOr2nI3dSeuWpPRq2XoablDTYwmUoUK0YQiAXBc + VxWNsLiixSxBwq2DVcO4Q7J7GTN1HTYmKZpDh8IXcSX9mu5NU/wj+D/jE4h72NKbtyLZGO5CtLLWdT1C + K04PIXZ7bVQ1xJG0hwwspswKJBUkGR90GvPPC+prigmjmblFocLOlwyqzp00KLUey5hU4/F2QGtbwX/p + embXBeyJ5ELvkSEIPBWAuOXGu8R52PdEIrCrR8pImpg3c7gxrw4r9x+rU97ruNakONfcKj/b/wABGRqe + mA2m6bGm0Ik2rGEIQFxXBcVxWFhY/jKliDhWsOqOBDhs4Nkbc03kpInQrBCf8YPxqx8GfB/sOxe/kojk + I/JvxBIMdnkqmrmNV3fbrW2Tq3pjJVJplsH6XaUlKWMsrysb02qX2fXOHFRTPjdU1xzVWtQ2RldirNCG + dP0JpNrT/DT6NBVjDgVO8QQWOTpT7Y7Yyj2TuywsdwXBRzljnyiRYysHYhEKJvr0qPlIwJo3kbyjroe3 + 7oeqffUj9iIYj3Crjiz+G81YWFhYX7/wpYw4Vp3U3NIc3ZrsLUaLba1GjJBE/wCEH41Y+Efwf8RtD8Ef + cfFD4VJCyOOTD47kNlNnmrFj2zMMKtVWSRQUBCZjXiM89cuY9jDZkD290Ex3B1TWZo1Vv17KDl2KsVGT + NjhESDsHVLMMie+FrZOJP7WPVhYGSPTjvhcQsvahKuxWEWqMYWmxcK7QgNy4A7E4GlD7G9/vNtjem4uj + /huNzEf8iSPkK8zqb2uD27CTi+zBHagt6e+KQN4tVj4s+D/YIqD4Ir9Ifih/GnTYNW8arYpYnMdbncpc + 2VPDmJtSua0sTQu7U5jHgjCztlByp6tYgVTVK9hAlcgU6MOFrR5HST1XxFzSEVlciuyyuXp/SC49uOV0 + 0znnlhVozPNGC1MQG9r2Aw1Wjxq0Rxrbv9epeWozi3+Fw5NHZ38ZX68w8sjA4QyvpPje2Ril7Sg4UsLJ + 1qunuY8k8bPsz4P9h7FQ/jX6R9h+KP8AGpPyE/eryNErJI7Acw8um8g8wObVK9uTIVy5JzE5rmHYLKqa + lYrKprEEya7sHpzGSttaNG9W9PliToUW4WNhlcFCxz5XANTXAOOc8Hg+yEfJaDTjjjx26bVxI37ORRWo + n+lhGIt63qv7Z2CgPp3Jws582oN4T/yO85Q8r4+Qjc+k+KRsrJ/7tA4QPIanpeVbaWlo9D0PiVF+Nf6o + +3/FnxT/AMvvN8Wtk717I5elymh5CaAxkFYCjfwPUjLQ8Pa+FEEb5QKq3Z6xqa3G9RyNkaJCsterWlwT + K3pU0SfD3LS1AZQHZjWuM9dsYw7i2F3HoNChqzyGrpE5dDE2JnkOAi3E6K1Du7c+2m9/JlZVP3c4NXUy + sOKzGxOtQtT9RgCk1gBS63MnaneenWbLkwudLXd28n78/sj5x5XsyAX05BM2ezsDhNcrukRWJLlU1pHp + o9D1F+PCA9Cd7f8AEfFO/N/1B9Bj2r2XxKGyyVPZkTw4IOF2RasYTZCiQ4Pg7Hssruu+1exJA6prigni + naHkIPBVilBYFrRntUtdzHcAo4uai02y9RaNIVHpFYKKrBF5DIF1UZCuoF1A5YGUVL6tR3su4Qac3Fbb + sshckyTA6uE6WYp3WKfE8qWLgHTMXFzkGNWGoMCa31yekg5G5/wQfJkJ4DhPFLE+hb8Q3b2TXK5VjtxX + 9Nmrv44jco/xp+HBP+J/Dt/2acTceY7guOdgcGK2UXckIDMX15YgwrjlEIhZcEZWvUkPELK6i6iLyopp + WPpf+gkYal2vbAcQhInxxyhtKu0hoG5ICMjUZUZCuWV6lxXEbFRE9QHK/cXq1LfUT/S1xiHy2LcleaLU + 4nIXICH6jWan6g54cXSODMENOekzPS5JtFRU2NdI3vAcH/Cz5cbuGVPCQ6jb62/smOXuNbpmN8gUf4yo + /bKcMteC1m3/AFb+SBrnJz2uRGNyq73NTLjJY2cnulj9TSU+vJ0cOK4BGUND3tRJ5OacHu4NxsDhEd2v + LTS16xCqWp1raBwhIuoEZSnSFcl6lxQaB5CcIzRhNnjcWgAoe+n+qXfUjlN7N2yi5F6vt5PjpzvUelPK + sMEVuCi8sbp5LWUWhNq4eyJrdwpvyTjCYQ5v+UQp4e9G51PIxyID26loxToSxjgo/iicCU8t2/kZ+TOD + YndMeXfZ3tF7R/CKdzDHZisCTiH+poHRYxw77cU/lxZ2Cztle64oKlrNisqmtVZxycnSMCN6mxO1emF9 + arFHVQjqUiN+cp1uwUZZHLKaMpjDHHAS6IonDNLH9NvZ9V7fKO1X47YHlzuFY+ThkQHg/wDkP8I8xCnh + yqFzmdiE1yBytTomQ2IsCMehSfD9bN94/nt/vtJ8I/iz4IEtT5uw9muyj3RCxvxTnHhuThd0MbcsLrPx + zQcsrKjmexR3AU14I2AVWPu+PlFGMNKtu41KY4194/XqW5xvVO5OEX4PVXUTckunZG6ObmUFN7Kw04jf + zb3WFhEdtj5v3/MQrEHJUbnI7EIHCa5ajQFhtipJUeQpfhsEePCL5bD57SfBvwHx2f8AkgkcxvVhmT2v + iQKY7ii0ItI2IRau2XluOBw7tsHL3XFY25IO3Y8tMVwqKVr1AORhapJHiUexWon+nj7M30/1S+at8tnd + 0eyHv9xMBwYGEtY1u7/ZHuIj05vJ7HzlD2z/ADFWIeQoXu+2EDhMcrdZlmO5UfA+wMMG7SSyH5HYfPaX + 4f8AP9bO/KPg1QzPiQEcqOWHKBTzlY2KIXIhd87524rgUIimxoMWAsNQDQqtzpqpI2aOSP7n6Kvd5t5X + cY9MGK/k7bVz69nDK4oOK5rqLqEgmRM+KPtJ8lYblQv5s3d7bdvJjY9v8AhWIA4ULhad/ZMepYmTx6tp + kjGFnF7gim/jh+R2b89pvh/z3P5P+bd2WCGuYAwO5JvZH1FwWNsIt7Ma0OkxlYTWpkeV2CMjQjOjK8qH + 4LBXFaJ/aQSueV+5PVqW992KlQcYPNX/ACbPzgtK6bQg1oABRXhGZAwF/rKOyPcMPTm/xs+cqeEEUbpj + O/sg/iGkPbqemtkM0KeMAfgg99o/ljab4n47/wDQ/jHkie6NRvje18IQKa7sxrHOcxpJaRthFmVwwmx8 + j0CXTvDQcldJxQrleHamtDRvpbeFOKPjKh7werUN9SP22dmeaL57FcR/APi/u3awzk2B/Nm7v5c/ykKe + EOFG4YTuQmyYe12VfoNnV2AsBGK1dHaL5Z2mR8g+b/gPIPh/oxxaeqyVPjdEAQUHrOQYw5EcT2C5tQd3 + MmGiLK9AXJZ8v7hLoqcDuYTVpvqO9z1WvJhY2ah/G32ThhyKz0pv5QfUjvlZ8gPnKniDhRuGsffd35wU + x6u1I7TNX091RsDCA7aL3KCczmf9t2e8nx8h+B+A9lFK+IjozpwfE4FFwALs74Q7eUkBc0O+0XqeG/ar + N4RFOPGLTG4q7/PUt3e3kZ8fO57Wp1yFqN4FVZpXuU477WGcm1X8mbnseQWV32wPI4JpyNz5Sgc/wTQh + wp2zUcDkJ3fVcL2THpzQ4a5SOHhYUO5dhx7ybFRqXyyfF/x8lewWIwuRgd/DnGwTD6lRbytyzGMt9irr + uNOqONfep6re9p3GDPkg/Esp9iNqN6JeKkcs23rw8rkKcSbDG1YUY2m7s2Kx0pcleoriuI/hK9juVjyg + r3WNseTCmi5CnZdUcCCGd9W29kxy7OGqaSpGEGFvY7SfP/fOzvaJS+WVP8o+Tjgj3/g5HeP3WkN5XJ4y + 5D2K1H8LezNnHA0v8e+pHFfiuC4FcCg6VsfG09eDymVImprGjy52Z7LGRvK3Igdkb/v+B3dMWNsjbuis + LCwm9j/BNEHCpYdTdX9V/f2TXIHKv6ZFaU+nvqKRmEU78g/JsfZjeLpfkvbb9ye8nlb8nJvv53e28YRW + gN++yYueirvexvbdxr0G8a2+onL+IQH8WNwhvMMSbFS/beDnd6HmK77YTvfigPIPI0/wEKWMOEdh9CzB + KyePyNcmuyrVdliO7UfA6SPBx97/AKbO7Bqf8tsIe7/k/wAsfyPsz387vbZiG2gt9IjxOv2/1alvqJ/p + 4RiLeb16h5wsonbCwgEEBvYHbeRvJsB8jexJWV32x/FyHLytPkyFld9sKRnJRPkpy152Tx7kJrk1yljb + KzUdPdAi3+qA+7tN8K/u/wCW7fc/J/v5I/d3tH7+c+xBQYgMIIe+lZj0+J/Moe9b1Xd7/eQe28Hrv753 + wsIDzDySDLPJN6HBwIysrGTgeXO+PNjzcVlZ85UjcppfUlqWWWY9yEDhNdhEAi9o8T2iJwlc3CIU/wAI + E757tHq/3d8/JGnqP+Qe0Sox/wBFA3gEFpvdu8vr1Dc+2m99sLBXFY8mVnbCwgh5XjD95G8mwHi7+Uo+ + 3nCKKBz/AAvZlfcrS0rbLTNyEDhMdhe61Kj4lssRa6Ris+0XsfnvH7/7f7L23Z8XKP8AhJC5rOV/pG1c + zFFH3aVM7jX09vGrvB6729p3Gvp7eNfbKysrO2Fjy5QPls/IeSw3CYeTf5R2P8X79/4XsynsfDJQuttN + 3wvZNcmu5K7TjtMt1n133m4TR6f9t40PcfLbGw+Du5Z/Ad/c57VRynmi5Rt+JV84qQDjDsfbTu/k1E/0 + 8A4xbcVxWN8rKz5Ah5ZxmPySDIhPCTb3Q/jP+JxKdHlTRFjtPvCfy+ya5NdlTwsmZqejzciMD97s+IQ9 + /J7Nd7s9vOffCwmj1LTG8rvVd1UVqPt+trDuMGntxW3vnMg9uyysrKz5mwvcOkQi3Gw2xu7uP35LDFG7 + m3Ydnf4w8uFjyPblWIVp2odXzBya5EZWvVuErVEY8TRGMlN+I+Ld87YX7b7fxN91og5WnR/dX7s+q7vq + JxWgGIt5PXqKz5MrKzsFUMDwiAU6FOjLSi52xlY1OtNCdaegc+V4TftS7O9gf8jigB/A9uVZgytO1DJ8 + hQcmuwpI2TN1PSQVJG6NzZC1qHwHwHkynIe48/6Wdm7aE3Arvc5FD3b6tS31DuR7b1fXcX//xAAvEQAC + AgEDAwQBBAEEAwAAAAAAAQIRAxASICEwMQQTQEFRBRQiMlAVIzNhQlJg/9oACAEDAQE/AdELhZHDKSse + GSE6MDju6n+2xYo3YvTwkP0kD1WFY/GkRlWNcJaIsWkU2Qi7P/IV0NDyxRLOvoed/R7khxsUa1oorWiu + 0uNHpMe+A8W2LJedOpbPckvs9+f5HllPzwZGTIjWjRXCPkxyjEllPsc5P71ooru12Vx/T/6mT+rJ+T0t + e51KX/qe3B+YnqYR31Aoz41igmJ3xsbEbta1oor596YfUe2qI+uVUyUrZbXgWea+z91k/JKTbshkcTP6 + iWTyJ86KKK/xdcKK0rsX/wDBt0b0PLEfqIL7P3WP8n7qDFxvWy9L7FD1Wlcs05LIoo2S/Jl9yCtC9Vn+ + 0YZSlG2XRLNtltLZKbQnel62XrZQ0eo8pHso9iJ63Gow6CgzFHqLwIc+tG4ci5jnIUmRZHRdl6rhfDK/ + 99G/7Ls26fZOKbsgTVkSRDqMh1MkLXQ9rIJNLReRDM3/ACR08dCUU0bYiSExD/tpFWM22bBREq0XJi0e + sdVx9bneHNaR/qsvtHpM7zR3EWSpIzZVj6sx5FkVo3JMtMSGYkSsh4F10mWR8iWmX/lRAUtxKLfRDw7f + JRCJ9CfUfVjSXgQmjdZuo3li5MWj1jquMsUZeUftsX4IwUei0oyY1NdSENipGTHJu0Y7S6m5HuEDL0iL + 1CIStWMmUJCl00yySzJsWaH5IyihG6/J7fQqiTqJid9Ra4oJjxpeChLsPWta1orjRRRWt6UOCES/l5PY + RHoqHMyqV9BOZHwQaQ2fqU6yCymPLckR8CEtvQZl/ozDKEY+TfH8lr8kVZ4FIUTbRNc3yrv0V26KMnp4 + 5Hch/p2Ji/ToJ2j25fRU0OUxNvyeplWNjyMWcWc9N1hekfwf0Jjd83rel8LNwnxrSn5+RKKkqY/SY39D + /TsbP9NgQxuCpH8hNksjZ730xdmitK1rStK1T6mSr6D8l/x0Qyvl0PHYlycmbnrfaitw8daRlo6cb/w6 + jbNi069mtb4WLtUV8Ciu1DtXpZfOvgX8br9H8hPoNMSelFaNFcr0x4nk8D9NNEouLp95ikV8aREXdm6R + GyLsxZpQQ/USaG2/Oll9yXQjLV/9F8r7mREEyPdzP+IukDB4s6kXYtNvdlGyJela9Ba13LRGSK69iuOR + bh+KMa2qhCjXGiu3Wll6NFdeddpD8iellllllnU6lFa0eOd63zWrRQ2zdrt7i4PyV8dKtGRVjW3ttCjQ + yM+9t/6Jqn2drNrNhsNiNqNqNg1Wi6ckVrd9l8rFIcdH2s/nj9iSK7TVjVaeOKHo0KNapr7LXdUi0x9r + P55R8dxqxrW+w/BKE78iNkyO5Cd91drPpZvie4h5EYJbl3WhrShPk9GrHAUq86UW0XzYu7n6Ky0xwTPZ + /AvSzZL07ienTh5H3asca4Lg+EoGTPPHKkiOdNdSWeKP3HXoiLv4meO6IsSQlo5t6IXVd9x18F6vjKCl + 5JYURxL7FBLuvsZPHKPkToa78lwT+fNdOUPIyPVd+iUdaE/kPlLxyj5JidEvz3Fwkta+Q+TQ/JQoM9pi + wntpElpF2q7tl6tcPHw32tiKXCQxidD/ACV8CS4p/DXcsektIv6H8Chx4UX/AIGa0RL8/Ca+fWm9F2PS + WsH9D6fCcfn529MUmSZEolovJP4cl8r/xAArEQACAgEDAwQDAQADAQEAAAAAAQIREAMSISAwMQQTQEEU + MlEiBTNCUmL/2gAIAQIBAT8BGUiuLwjwcssTNo0zkbZuZvISvKEfR9YogJcmo+Sh4k6HPgk/8EnFSqJH + dKL4F6DXm7Rpf8VP/wBsh/xWiv2YvTaMVSRHUcVSJTcvJZeLLzfYSvDx9YeFInKiMreFnajahxro0f2N + fali8JlpYRQ0zUjKTI6VHFULT04+EWWWWWWX276U8MSPrDzqmn5w8WyM/wCjkQW8aSxeG7K4xRtKRZvN + xZZZfarvPCFJm59LVmxYVGxHtm0cbIQpD8iZwXi6NxZZZZfZr4j79ll9yisV01ivhL51dhRb8HtSPZkf + jyPxZn4kxoarro8FX0LpQuxLOjppwcmNogoyZ+Po/wBNaEYyqJQtO1ZtivJDSUvBKG10LTbPaY4tZojG + z2j2h6JJUaK/y2e9I95npJbpcnBqSSiPySI6K27mbIm2JUf4Q04s9mI9OJrfsQH2Y9Sw8+mS9p2e23Kk + VRwVjlImacmiTNJf5JtRJy3EhSFqRNPl3i6Hqjdmn/1sfHkS+yLZz/Tkofk8aa6FrKPB+Sj8iJqS3OyP + ih4fXHzl4WX4z6eN6dWex/8Ao1IbXVj4PJBWyVo2uSKaGzT8Gs+CiXI+CrNHxh+Bso0v+tmp5J6WxJkG + b7xJi8kl/lYTsseKEu3HyPzlcZo+sqcl4PdkN35x4FKhuzT1FFUajUmJciRPwSNoxM0lwcjY48jIJ+1w + PTl5J7peSmhRPcouyHMjUf1iuLxqSN9iY2h9aLZuN2bLLLN3TZZuLRwO30LUY5G4sasjpmjOMUb4kp8j + x6R/4LJVtJKx8G/fyRNL9zUUr4R/r+Db/g54cMSnZB8da+JZZZfatm4jq7Y0heqkflNo3xLizbEpI0P3 + LzrPnD4VinvI8lUutdNdCRQ137LL6K7Sbj4PekL1EheqY5J8loZGNeCOlt5RLD6UIvN9Nll5oXwLLL79 + i1KJO8Pojpxo9qB9iRXSuq8V8a8X8Gc2lwe7LHBxjjossssvNl4ZXZsvv2y329TwIT6m8XRaLNyF1X3b + +StrX+itP+E1UuCLj9knH66KLocUzahIrNFDZazZfZsQkTVcimL4iNGvs1VRqee7BWzUq6J0lRKKKOMO + NG3tIsfItP7F8Sz0zrya8k/BqfXd9MrkS/1M9R+1EVaonGnWEe5xRfboTHlMsfgV/ZfGLL7bNpJMl4Xd + 0p7GR/azVe6Vl0hu83i8NV2m8UViDQ0q6rL7Uj/xmiiijg4OC0bjcWWWXaw+p4ruUbS2SdIWp/S+8xPi + iy8W+5fXZd5Yueix9NiG8T078CuJeV2feiRmpLjs7ke5E9xHunus3yPcke4/sTvsMT7VdjaTg0RnQuRd + r036dN8G5lvtKVCd9bFhSN15cH9G19F5fT5HppiTiLx1vPpn/nqlw+p9SdCd5rLFlEX/AE9+Efo/KQvV + RqqJShIeLKLxXTWGX2fTeM0zabTVVPup0Rd4TKw+hYaslCiE/wC4lD+FteRYso8F4XDJNFl9v038KZyW + bkbrNbkXdUqIyvoroXRtND0ycbbJenknwR9NKR+JSJRp1m8Viu0s+m/Y3jeKxMfHe8EZX0V1ohquJp+p + NT1H/wAj1JPqvHHd0Hz1angfIuuuxCV9FdhfH0fPVqfqR8EuMLu2QnebGvnaXkXTPwaY18GMrzZXUuq/ + gxdMT4Nw9WKJepgh+sX0L1Mp8EPOJcYXborCIyFnyV8VdCQ5G+j8ifgc5v7NrKxpIQiQvgJkJdLXw3lY + vKEz6HiCxDElXIhd+yM+lr4TwxYeVmhEREcNWR/nwURn0WPn4b6K6Ee1I20RELMlXIufg2Qn0+firp9J + pxcbxqwTNOKH5NzI+MPwQ+Hpt9t9/wD/xABCEAABAgMFBQUGBQQABQUBAAABAAIDESEQEiIxUSAyQWFx + EzAzgZEEI0BCUqFicoKSsVDB0eEUNEOy8CRTY4Oi8f/aAAgBAQAGPwK0lSLVWa3lNpnbVbg9FksTarC5 + 481hjHzUjsGySks7DNEUot37rj3E9h3JSaJolzm1G7NUsAGZVyLKcp2Q2k0mndVNtCpXzJAbDW67Bvbo + Eyg97QC10hIcLJoNZQCqh3TcpwRzJ/EVdMRoOgQvucZ81faKSnQJwLZS2cTwPNb0+iANG6lXOymSZUUI + QmFxBVbjfNY43oLMtjNZ2UFmaz2KFYlnZkqOKzWSyPcP6bDkdogzVIzwvGKq+YRDiJcEHXQWZdECOKrR + bylMLgptYqw3DyWKizWaoVMripdwAVIWxOqBvCR4BROiKY8kYlBnleUIHMNsb1XmnXRMDNYqHZhjVGYI + tdOkxJQoQcHSqSFQTTqVDpIvdTgEzpYXlsmTQuCZkVcFMMlO8291QfIkEcFKFBJVIZaPyq7EfznNe8je + gVbzupWGCz0VBLpbvBZqgVAs1n31CsYVDtcVnsddgo7R2DkWn7K5Db90y8qlGTk3rsNPLYzWapNcUGtE + 3HJe9ZdQOwNh7eaYM1E0ARUKamDJXnm87U2N62NI4klRHbrxwtkVhaJ9E0zNCnTJtd5J3EXZVQBFVWk1 + vITJy1RdCh3joF7v2a7+ZTfFYzove+0PKyc7qVSG1UpZmFnZQWZqp+HzWMKh7iGPxbJtNp7lvXYZ02g4 + J7roxKG57ZNFCi1r75JTdhslUqljo0sB4qTcR5ISEiRVOXs/Q/zsM62FnzcDbJPbOcrAEbYnunHyRL2X + RwaqkBVcsp7G8FmqBUCzVSs/6BmsQVDYLYQ2Ta609yELKppKy2D2hNOAV2FGhgaZKkndF70TcU5rAbqb + sNmZLeoqtIlZIiaysiICdAg2kzqscVg6VVe0d9kOzbdb1Q0Rtn2ERzeiJZAfe0AXhlv5jJe8jMb9172N + Ef0El4N78xmvdwobejVmt4LNUBVG2b5W9Zl/SM6LO3oO4N1U7k2CqCzU0EA5gKrCW5Je6EnIRK8kXsM5 + q9Jwa3NTCcTrRAmJLyU31mtxHArvBDaeG55LtIoaBOWex7tjj0CumHSc6lY3tCxPcei8Kf5ipE04Krlm + qBUFmdk/6hRdAFhkVuqIbW3srJm96qj3qkY+in2s/JTa4Aqt0qbhTb8RYYwUk3pZPJNkr+wBEF5ivwHe + iMPNwXFTqmvvynIpstLCis1VTlse6bN05rs4nZsbOec0C97ieS3J9SqNYFvCygVJLNG+VQ1/rB52xXau + 2KErfK31vLgsgt0LcVWFVBXFZrMKpauHqv8AazKAD8uS+UqV1vqmtbdZLVEe6I6rcaf1KsF3ksUJ48lu + n0U4ZLSrxWS/+VNb/wATKm7JSObaWmQJW76qpAUp2ZhbypVUaqGS3lnt8du7OgbP+oDmVOxx5IW17/NZ + reW8VvlbyzXBboW4qsVWLdU+HRUH2X+lw9Fw9FmPRTCyKo1cFvLe747cU85d2z839F6JvSx6bbX+lV7s + 7d7Uz7tg/pAGpQtdPJU+Jn3+XeHrtOOgUMcu7h8ge4zCq9vqqxWeqwmfRZO9F2Rcb+WXxHVwtgt5z2DN + U+CleWazUrwnsA/0EjWiaO6vyvVlJT7IZaqkNioGei/w1UL/AEW9FVS/1VZ/uVf5XBZhMF75UalEf/L3 + VXN9V4jPVeK1eIt4+i+b0VGuQKzTTK8SZINuS2AdLWDQbM2PW+t5ZhcFNSW791uH1W65E4lWarNby3wt + 8LCQUUbYUzx2AbHHQLBChnzU+xHqvBXgLFBIC8P7rwyroYZqrVeadi7EdIrxQvFavFapQ3hxzQZeF88O + 8u+aBHETRa+JIhb59Fm/0WT14b1SEfVUgj1VIbUyKXtYXCd24hfiAieQbJM7Q3RLgJrxIv7As4xW7GPm + qQn/ALl/y/q5XmMuDYaNSqL/AGnn8brHsaxsmmVVkwLeHot93ot6Is4iyf6rc+63R+5ZN9Vm1bzVvD0W + /wDZQwXcVVZKC0dVPQWkrLhO1502qrDUc1SwIbB2nI7DOuwDZE6JslmVvFUf91dm53JVY70W670U3TFO + KNV5osm6XVZv9UGucSJFZfLVbgW4LHfkKhypKSZDgGVJlcf2rh6KrWqoCEQ5mq3GLdhrKGt2Gsofop3W + eiAk2QTi+UyVvs9V4jVvBbwWSyTIYFXGSugUGSbC+lsz1KZsUVUNiH1msgjlRPdzcs1EdnUrHEcCdGrf + iHyX/V9VuRP3LwXfuXgj1VIDfVSEJg8tpvKqoqj7p34aJ5tcn9ZWxnc+6CapreCzs89iqd0R2If5tgcr + HpoKwT81eD29JqqmzNVLUSs2lE8MkETomCVVfDii6c520iou7Vu7JMi3w687gidBJbxW8VWyc92F/ZAu + bOZWFskbzJqjJLJZIdxflOQUyBTmo0QiV5MtqZL3b1iM1C7QMMTmFPs4f7V4bP2LcH7Fu/8A5VAfRAwQ + L8+ITjZPvnmXBUYUSWGnNF5+YzTuu0SidTsBHab1QVQsrD12T0TlE7WLcPBOv3ZjKmadNrAZU5qHd12B + Z5hdoLsm5idVO15JkAELo4orCH+SLXlNT03KzyVbDLNc1D6qKedoD4eKWaq14RYw5yAmFDHKytUTfArx + W+1b7UGkicuC++wHFt6XBVhCfJeE31VIQRd2LJKI6UsqJizxHkpNC94wiwn+V7sADVVe0F4pxT2GoBUz + WXAlDEa6FSa8O1mEGcQU5O6bU7X9pOQ5yVf+9bp/csh+5ZM/ct2H6r3ZY3oVLtmqUSI1w0RbCa1rABkh + azlMpvSx/RN2XaW0tb1Q2HdbclkFSiKN0yNreqFoWSbT5gr0X2hzHaXVT2v1asPtLFSPCUr7HXtE4POL + RX6HQp15P6JqcofVT1QlkbRJUE03qn9bZSCaCMm1KAbqhyCqZWZ5o6SXFH8Lv7IWc7KqHhGdaKK5yIkB + PinXpZYZBeaamniqFSc4mtguEiSYGybh81BJzFE5+pTwDXgFcLa51WVxycXaJyfaJiW0Jzkh2Lbp5mZQ + mHvdPjonNAlWiDWSdpMIBpm/jRCV3mgYsM104LiBwmEVD6WynytlqZJo5bJllJHYKHVNsrY/ZajsNQ6W + 1shD8Ww6QmZISzUzpmpPbJhyB4pwZSXAp8M7xCCiS1W4w+S/hQp5TP8AZUijzVHsKIdog31TOq87KokZ + BTG6dUBzU7W8XSVUZAp3nskpvJGlEJjIZWD8wQutnRMqJaDhZyta4nGQm3YbWDmqBBolkr0GHMGr5q9R + hPy6I1mj1XmhZWzwhsEkjzQAo3ROnOqeSOKY0ZqbZIFzwDwTnF15uSAYTnrYwcrbsvmlbCbqdrlJFC9k + pMZKJ0sNg2H2y9pdSWU5JzID77EzaZ0FtbGyE5KoVVmpsiV6rxvuvF+wWY9Fkz0ThdbPOckNE57S0grE + w+S06hQ5/V/awoJp8kz8yb2jCTrNZxGolsXykojfnJopcBwUNTEvVbi8N3opckZ8FVdZKXDYuov4Iue7 + 3fFG4KI9EPzoiG6Qc2tsrYb/AKWovksOav8AtDsQEqZLBia3VXzvDLkrrCTTivNM6oKu2LrfNTEsKaS4 + WA9pIjJYGB7kfeAuGYdwRlNp5GaE9M9keZthDQbQHGSdO3NGxs1x9LKI8xbvLeChz1soqgyVC79q3Sof + 5RbXaLs2HPkiQaZppBzTnvPqpQZnnwRY9xPmpTWJnm0oNZFNTkhKRBQEVgh3TOhzWGIF8pXhHyK+dvkm + ua6dUOllFM5zy1RLdKrpZmUJOKaRSlVTeGad+VDqgDCBkvAC8FbpTrm7wmiJbqaBldsP5XfwVD5maBjl + 1/k6SpGeP1LD7S8eiw+0n9qp7Q39qmI0I+RUN3kUBxV5rsDGlzhoU0u4oy1scgoQQF4N5lShxO0Gu2w5 + koOcbKrDyTQ3ApzpxKugBw1CeKeiZ+bbdyGzzTVeNDyKzPqt4+q3j6rFXzVW/dXWPMlvfYLe+wW99l72 + ZKm0vCwxHei8UrxT6IOc4uksU14kVeJF+y8SKpkvdyKDW5DuMMS6vEafJZw1hfD9E2GGTPRVl6KZzWbC + pRctWqE8RIjnTyLERIjFMI5lqDY4N3OS9x2jH8Mc0b0WorI8QqBpHNSiw2t81LNVCaIkEEcCQty4eRWG + KRSvFRcUxOQK3lmqvkULsRiLIV31VWymQF67AkOayVTdR7QUsdqoQ2WVOa8V9W6qIw8V2jp9kBd6zUYE + 75n5Jrm+HpojKx3VN/woYKCzG21BgQIqrhMiUDTq6qkwU1KpZdujkU31tfLRROslWyM7nteamNjNZlZl + ZlZu9VvO9VvO9VvO9VvO9VvOW85b7/VeI/1XiP8AVeI/1XiP9V4r/VeI/wBV4j/VeI71RN93qvEf6reP + qt93qt9y3yt5Zj0VZKoXvGtP5gqMl+RyJDnzP1VUvZ4rS3QrF7OHdB/hS9o9nc37qTYcT0kojpFrchxR + a3FCbShQDd3OoFPNBwLaLg4BMu4X6ovjsY4xDkRkE7soQZDbTCMypKpCm146SWbSqNvBCcK7KlFX7qTX + EL3jqNM5I1VP4WYXBDtQ+9qFSK8Lx5jmne+bWvRXQ9hbw5INJFdFD6bM9E27FZeI9ESwtIvEKLMnsyeF + Sf8AySLGN7OG0zf/AL/wpkBw0PFGIwSh5IvPkp6pnRdAnTbOarD+yrCb+1VhM9F4bFQD964+T04hz6Ce + a5oOcfVAlwulRvam7pbhU7wylVBTBm2xqPJqyWRUqr72udqdo9ziCwA+a3VQOvWe9DpfhVL6yesGS3Pu + tz7rc+6wturJZLJOn3lHFVAKq0hVcPNVZDcFJrZKkSZ/EFRs+hVWub1BRxD1QbwJTnMza2TAfshemfMq + 9cvICG4wyR/1BT1C8MPGrDNYmuHks1eBoU7ognNPFTEQ+io8FOkRTNTlNXOxx/Wt4qjlvLeQc194NACa + WiZAlJbgWRFm8muMroWKGz0XhsCwkjo5GHCiFgPEZrsu2Oc7xXuvaGlvFpGaAhloIPFXTmDJN6KJy2+r + 0bMIqU6B82U1d4NV+HnxbJStaE82gDQm155IbTlMdwe9Fr+nwO+VWRWJvot6XVVaxym1gCaGxbkjOqwm + 90Kxwz5tUiPQoXb4Rk+J6ozfFP6kG4pIkB+i3XKQoeapDmONUHQ7tdYgH2U3wpic7uqiXsN7IGijv8h5 + WSFyWqF+GQt0+qkGRCSaq9KSosf2RuVAqjJqDg0kZ5Ldu9FQlbywvRxZiSqAplmGeU1PVBRjz24LJgVJ + V1j29VNkjWQTJDEFja+I4cpAJjjhhNyAoB0TiELjLsQnVAOzRJUPDduiXVT1NtBWUrTzom9Np3RU7h3e + hZWHoq/C0eVUArE0hb8uqxMhv8lihS6FUveq9wIf6lWBP8pWNkVvVqmHgqll6VdVvlSLy7kVk5UcsUkA + Zlq/upuqdVQV6KA2WF16fosAl0KwuKlfKkHEj+EMN0SpYAsM2rXopPJVCgIxLTw0NjiADMqrAt0jzXFZ + rMKia2MxrjzVGsHQKlOjiFhjPH614zy3SdEIcF7WDW7NGG5993AlBzLkxzXv4WP6mkJtyG5w5K64XXDg + Uz1tlOs5Ww26uQ26UW+Fvhb4W+FvhUNhkapsXtIV08J1C3gjUKtVkW9VUy8lQk+Vgif8TBFJ8Vj9sgD1 + X/PQfQoxG+1w3kcJIBTw+YWJzAiFXYaGaaL3mWoRN+buiom4yyRzCmI7vQoNeS4jja4XAWzoqzb1WFwP + dBUeVUAqrSFvLgVihtPkty70WCK4eaw3HIl0L0KJnmh27I5d9TX/ANlV8dvUrBEn/wDaqX5dJrA5nmEG + CHDc3k6Sx+zxfKRQq6FFYbzb7DmiexkfzqT2Q5azKdKTearlpr1Xu2mVglmobIjA92bidVi9nZ6J0KE1 + rQ2h6qbZ9JyVx3tDm8ojVvzZrKclOG9rgtyfRYmOHlskmMGFFt+9Lis1muPqiJGaxAyllNNm4z4lOvE/ + hmM0A5wbqVEfqVDHK1vVzrYTdiQKBDqLNNTpCS3lvLeWazWedj2GE195UXBNmd2xrXAYdFicheeTS75W + XWyksV09V8vorrpS6WER3PDfwodmXXuM0NVXPYYSuSvnevZWPYIpu80WxDzte7QWgihUyveQyOio/wBd + sbNFRxVQCsTSFR4VDNVhgdKLC5zVgiNPULcvdCt2KzoqR3fqr/KxCG7yXvIB/S5VMRvVq34MzqFhYw/l + csJiN8prA/1aVuX+im+CWt1KERwpDxefBZ/dRIr54QiTOZVDTmpRGAhTgPw/+27+y7b2V9xxVz2gXHa8 + DZVt/wDRNbgafML5/wByutc+7KqwxHDrVOZOclJUc1ZA+a8MqsN48lUeqcwB1eaeXMNRSlgFs5WnkNib + WgOsyTaFEAVTtlqHwLVXY7N1HSBaiCg05TsejrIogWRj+GSNjeuxgcR0QN9Bpa10+clWbeqwOB6WDuqK + jiqgFYmkLe9VQgrHDaeoXh3fymSwRXt61WCJDd1ovDB/WFT2d3kQsUOP5Ga8OP6Fe97VvVVvoC7NzsRW + JpTYDReaKuVfZ2+qrAI8lip+le7jeU1he5S7W8NCrk8KoTLk5Sc2/wBUb7XS4J3ZsqeLzJVj+yeU08mU + 58Mkwc9rFDYeoVYDFNsKvU2vLc5KJM0DpC2M7nsSuBUYFuNQo3NZYk7Zb1Q7u82UgiaU2QsDZsUrsuqz + sMq0kjfaKckKzs7QzI4tki/AHZYOKJsI+ogWhNG1mqUKkU2R+Ao4qsisTJLOSwuBt3QsTJoEMlxouH8L + 5jymi57HTNTdqpOz0cJLiuKrtclUIyc5oVC0IOa6o0QvNqqgqbT3NcyZ2udqdg2zTZ5kI2AEyGqbEhR5 + vPC3Ieu3ha4qTgRbJqm7+bDaFJ5B/MAt2GVMwWlXmuaBoQnbpnyXvIZI4LC0+aaIkHzBU6qIAy7UVRaX + tHVUe09CoTeZNhPdtAcJrNOiGsl7yGR+UzWGIPOnfT520cVnPqsTVWYVHhUtk5oIVYDR+WiwPiM817uO + 135mqjGu/K5YoEUfpmsWH8wIVJG3/So2nRbq4eqkyvmqxvQK7KayXFZ2ZWylwJU7Ih5IbAnkqrjZ5UQd + Iy2Q1uaqwqToTzzCmIMVeDHkqexxVe7K6dFX2Sap7M0fqXhQfUL3phhv4VR8KXNeLC9Cqx2fsQLo17lc + U2RHN8lN0aJ5NAVYkb1CDheJ/E5fJ6reYt9io5vrsETlzCiO9pcbo4p2I3DkJ2GK9zmHMS0VarCZKU1O + fd4XkINdnO3CSFW65AOBaVTuh3FCVvFVAKq0rOSo4bFQCsfs8I/pXhXfyuIWCLGb5grD7UR/9YWP2qOe + kgqujO6vU+yn1cSsDQO6NK5WnmU0cthhU7CoU+ik8AheDCXhQFuQPRZQfRZw/wBq3/st4+izcvnW49eG + fVeF91SEPVeG1brF8vot4ei8ReK5eK/1W+71W8fWwy2d4rfcquV14pzyWD3Z5ZLxmXU32driy9wGim0x + J8yq3l20MBwnuzqpKiqNo7AG1R0iqyPVY2kKjxtOTOnfUcVnNYmqswt4Kh2Mws1x9FkfRbpW791kPVcF + n9lvLeKq47EJurtlmqbaJ/B5rNZrOyQNUe5oVWivRIYv/UiIZ7Rp4HNBhFTwNCrjKmVxvVVb91lbRcJq + lgtPRDZFknVCmwrEFgeQsQDlPLra48kPg6LeKrJTcwzVBLyW+t9vqqEdyzkCbYLdNnzTbcWqkZrit0qg + WS3VurJZW7yJByUi6S31nsZhBzLvqsxNAyz5LCsS3is/suCyW6VkbM7aFVohfGVQm3G34LROh4qRoeap + a3t4bXPdjJyITuz8OdJ9/MLEqGyiwvWNs+iuzkTqqH4vMrfPqt5cPRVAVWfdbpWTle42n8I2HHkolKTU + rk14YUrgT7zaBCVh3B1MkSXwfVfKsx6I414hW+5cT5rFMnqt1UghNkvDLvJT7J+WsluHzeqQ2L/pjyXi + s8mqXbvloFvukq3vVYR97Knj3GSyXFZlYXLFQr3jBP6gr3srmu6rH2Q/UobvaHscwOqGlPY5910TD/lY + XTXaPc9rycMqiSMMua4jSzgdi7aFPaNnavzyb/lX21hHI6WUJHRZzWNpCo4LP455bvcE+ZoHSCmLI7ue + w/onhxImqhzkbsMU1UzICVMKjjgmlooqrN6+dUQ4rcXhhUaAjJcFms01Ez2c7BsHrZVwWGqqZKjm+qmn + dlJzOEwqwgqwSpSIOxhKxCS1svvL70pCRyUw4OYTJD6GNT4jvmM1WzisKqEJZ23tsc0G8DU9FhowZJ17 + E3QqcKmrXKllSu19kiMjN0ycFJxPmi4H1U78+RCxwx+krOXULC4H4qRzsJTnanYA1cjdKq5p8llDn+VN + JTxIzIqmypstVbTsDvCFP/wIPdEY5gNZFUFPyq97O1zobaTCcIrmiJeqHcEBDIN7QrEz0Xhun0R7btAg + +UV3OYWA15qREQH8IWGG/rNVhvWT1MB8+ql7RDcPxBTa4ObyUkWQWk3qGWikZg6GzmtU1zIjTEIqw0ki + yKJOGYK0WqqEBtgJzuLqeSogPVASrmiFzsvQnSKJKAsbPes0TZRL3IhY2ei3pdVQ/Cyl8pdbEPJN2ILf + NS5I0cVgaGpnRA8ChIbI2PLuRtuUU9AhFlu8E5lxpdxwqI2HhxSAFEO23+LrxTHwmucOqF913kU4CI0M + I0Uz7X5FRIbYtw/iqw/4Vz2hoiNywmUkHN9qc0AZPFV/zEhwvDP7L/mmft/0qup+T/S8WEUb72lThvun + kgPaG/qar0N4e1SiNBU4LvJylEBHVTzbDqVEivbO6KcynOLXTOqy+6zX+lSylmVrjZo8Jo1OamBdjAVb + qNQpjNXxnxFhKoV9JlO0OIkHIRA282U+ayQAnM5ItYby7TsojW6qp/csQkVecaBb8uqoZ9PgDIZyb97X + cyAmDlsNGgTCnIJvRM0NFd+k7PnsDuKIbdeIQH1PTZGRNUTIKfOaxNyTRCeZceaLrkW91XgOPmv+XTw4 + SIsyQkREbKo0T4jA5kNs5hzv4Q7NkUs+m5RF5hthOnIi6VvfZcfRZFXod9ruSlHZe5hThuDlJwmNCj2T + bs60TYAo0VceaE690aZLrZIqaDXGvAo3jx3hZzQCoiONpacl2QiU1lVYzhGZTnyq6jRZdiY4ehTovsrw + CKljv/KWSmZLJYXSW/Mc1jb6Lel1VD3kga5Wwm6u2Yp0TCjdaShh9UGtcJAJgmKO4JwlsZVTraJuxNAh + Zrii4+XPYu/O77KRUmiZUniR0RJ4CQGigt5TUIEcE45InkhdMxomlrsN4tqpgznwKbKU0y88XTUr2g/j + Nt+G4tOoVyLdrW8dUWh5ZFbwmVNgvDRzyr8ONEhzzabxHkvHcejXLxIn7VivfZSJer0O/wCquxoZe3Xi + vcRAfw8VVjfRXoXu3csljbT6gqbDIUaC15IvHUFNMJ7sXyu4LML/ABYLtULzZo3cudlKI2nkp8NqR3RU + 80KXeEtEZSRaRIqQJGzQ24XELemOa94z0W9LqqHuG9HO+9sFug2Yj9SvDJWBkkb7nh3AALih1TaKYsyU + 3ZI390qlRwNlbPpf/KkBNe8aWz1XJCS0CBa+87S6q2AoC4xv5RYLXqXASahJwlJOnonOQonQDviIXKnF + XHUkib1eCd12Ww/aJuY3dcN5vRSHtjjpKGsPtEU9aLxXnqVn9ldy6K9coqBYkHNeQRorsf3zdeK9zExf + Q6hsnK67Vqm0doOSM4Th5JgJIAq6x5za3CNmtbRfoNV7s3w15aXA+n2sOiNlNmQU+JQaEIYIDxkSrrxI + 2Ad1Npkt6fVe8Z6KTTi0OzOVrvwjYedAgt0LILIWFMaBwnZWgTsTr3ClpQwNMtU4yA5C2lFU2BCwqlpr + aZBGWiL2x3NnwkgxpgPA+pslcLIAHUqboLXN0Y6SumDHYTxMiAoodIXgCE0OyrknV42HYNhv3urVPfbq + P7qbZFdoxmDUqr4Y9T/ZUiXujVWK6f05ImCb4+k5qRodLQ2Ie2Zo7P1UmvuP+l9FWxzxWeqiO4nCJ9zV + G4aFVUtbGqimqiapZVVM0XPGLgqqbrL4qO9Ep0rTYcBxonn8RWUrI7+ew7nRNt42OQlmRYDsG2qBQtCl + ZdBxlXXQnz6Lcf6IHsYhHCiF9ohN55qkdvmFijMlyVY5u8hVYAepQ2Q5wrwKr/5REDMmSa6K9pnwbYCN + LTYVNpkpg9m7jIZqGRN1TVXiwTXuDCa38q/9T2jwcpMAb6qkA+ZWMNPI0PkV7l0z9DqH/aIcCDobQ0v7 + SH9Lld8N+jlVSe28NF7rAfssTaajYrNPjuaCBgAP3U2AwXfh/wAIw3Pa6XELNSc0OVMghYBJpOjgsUMt + /I5YInk4K4M+K4tdzVbJ8VW2imMLlJwlbOSmFltOfqq16rSyRB1UhYSnO1OxDbq5DZemBPBbOqkFkpnN + TWhVFKTnHQBT7K71Xhg+arDu85rOGOc1ONFL+XBfN5FZxPVT7P8A/SlDYxqp/CyPot0rJcFvLeNgpsSU + nZJpdlqm/nQJ4CwB2SMija6zzQumn2V1/u3H0V527TJHJw4hF/ssyP8A2/8AFl10ns0cpCTvwRM/Ir3O + f0PoVJwIOloF68z6XIBx7N+jrZgXHclO7fGoWXqpt+yhwzVwGLqnPdkBNPiOIqVvKtVkZLAQetDZVUK/ + hAA9Ubrpt+l1VKLCkdYZXuIzHO+l+Er3rCz+Nqts8u4a3lsYcg0lVsinkm7EJtmdpTlLRymTI8lSMV4r + 1ul5/EqQh6KRgs9Fhhwx5LCJdAsit1boXBby3iszZl3Leu1ISnzUMOad4I/l2zZ5qU5O+xUskWXpt+l1 + Qh2bv+GjcAThPmrntLPMK8QCT87c1SLDDNXURDYrCB8zaqUSK6KB8spItI7QD5YgkfIr3Zk76HK69pDl + kpyosD5t+k5KUX3TueS1FmJg9E2TMjOi+rkhCaTeiGo5bFbOWhVaKbfsq1TBIC6JdVNVV1zGRGfiH91K + DGML8ETE1GbWNP4MrIcaD7y8JkDgpOFRsyNlDssGyZG2WpATBy2HfhFvCyUwrzox8gpse89VxWSyCwtV + SiNVJwr8GLxArxKpXbBGUpI2C9ZIGdhsHVYJT0Uj91lPkpZhdm9vaQvpd/ZX/Y4hvcWHNXYjRe0P/lE2 + K2HU8Z5K81jS5SPs3mVehw23dJVWECf5VJ0J37V/YrBhdosdF7qJT6cwpRx2bteCm0zaqqiMVrhKUpFS + iNLDbVUtpNYhNYfvZUWgIqU70P6VfBuRfqTobi0y4jYqsOzPROf5bN2XzEWwGau2Yz+dkpLRasQI7mfd + YnNHUrFHh+q8WfQTWFsR3ksHs7j1KwezNHqVQNb0asUcjpRe89oeeriqxSsMQrB7RE/cvGJ6yKl7buH5 + gMlMWydVPDdxxmLalOKojYFnLqj2gxDip5DVVz1sE+GRGYTmRwIo14hH3j3Q3CUy3dQfCdfh8kLwFjYw + LuzydXd5qpMtVQzWc26L6p/K5e6MnfQVJwIKnCeQpe0tun6hkr0Nwc3UKqk4BwU4BuFY2U1G32pi3Ijt + 0S4LEwuZq2oWJsuizWEzCnWakaGzC4hVsrbTZmmDjstMqAG2C3QbBKJ1s3VlYO6xOA81ijwx5rxZ9AVh + bEd5L3fs7j1K937M37qga3yVY7m9DJe8juPmsTyVxW4qMCoB3OSuRPC/7VMWyciYbnX9DxVc9gnnYNjA + Ra4jNDtKq97M+nFvApgd7qKPlPHonXsgqSc0/dEwml/s/FnFn+lNp6G27GxD6uIUrzYrPup+zkO/CVIy + aVehxnNPJS9qb+pv+FegvDhyVVqptwO5Kd2+3VtmdkOC0HFx0CDQBdFByWA+qDYMNrXNGNwHFc1MDJZq + tVQqotzXaNk5mrTOW3DZslxyCMuGdr/wjYiHkm7I7mSc69R1VxW4qMCyHwlyJWCfsgRUW3XiYWEXgnMe + MQMpW+dgtmEMMjxOtsRDoqJ3bZLs3B8aFlzC7T2F3aM4s4hAHDE0KL4JEOIeWE9QvBnza4LwSP1BY+zb + 1er8mvhcbpmrwfIqUZocPqCvQjfb97L0Nxa7UID2lt8fUM17l4PLjbjZXULDGdLoveX3QtRJdrBvXnUm + 9VTnmoAT3RN9xmZoTmZLJHRCq4oa6WUKnxQIAaeW25+lNkjVPOryqmdkd/PYA1cE3psy7ofE3HzMH+FM + GYOxfM5ilFeLcINnnY1Cw7ERCxyohEhPLIg0Vz2uUKNwiDJyAj44fB6mwzCp/K/9S4TGT8ihEZ7Z6NzU + w8NPGWRRIM/0q82/55KchOzNTBIOqlG9637r3b8X0nO0g/ZBt2g4FYT5FdjEeYYzKLWOvjmsAIt06rDx + 8rM0VSylVWmy3U12QCc7XFE6nYgM5z2jPXup6fFXXTME/ZBzTMG2RT4bxRwRo4s4FS52NtOxEtchYGkT + BUrwfA4wnn+EY/sEWUt5jswrzGCSl7S590fS1e6dEiHK6Ux73XHnML3d49V/ZUwbQBPaM0d/lAXuzfo6 + yTgqJ8RsS8XVkVKIwtKy2RLgumQ4LW9UaJonMZ8kS6oHmhzWqoZKspKqaxlZqThLZJ+lpQGlkU8kzYb+ + EbR690QeKcw5tMvitYJ4IOYZtNkIfUbMQqg6EzDxUj5ckNkWPtKbY1BMeRO7wCxYXahb3oVvE+a8Qy6r + HFJ/UsD3Ac6rP7Ldb6LdkpOBGzJr7zPpcgInunc8lNppyVVJwBCnBNwrHDpqFRZbE25q6yV/PEQ1Fs5H + mcvRMIl6kFGd908p4ZqTqEDos68lku1AN80rZSmwcjbL6iAmjlsRnaU7qq47V8DPP4ubcUI5tQewzBXs + v6/4tkUYkDPiFI5hDYFjuuwOlgskZh6nkdVjzRllJSkqVbZXJTEucxNTALT9OY9VKjhoVRV2fdRCBpwU + vaG3DqMlehuDhqFWyYFx3JZdo1aHQrK2TnADmF7qM1w0CutFOIzV2Zu6LEVggmXRTjSDTwmg1ooNpsjv + Ovfa2AzUz2Yj9TtOWIyWBpPPJYnS6LMeqrEaqElYIRPUrBDat8N6BYosR3mmzJVw5j4u/Dqw5tXs7oeV + 10+WyYmRPJGGeGS87RZ52GwbAvibCpsMxZqF5Lqpii5rK3Eq1U2bGdl6C8tPJAe1M/UxTgvDhytxsrqv + cm8NCpPaWlbywtc/oFSBd/OV72K1v5Qsd+J+Yr3cJjfLZoFmqlZFA8bYQ+kbDzyTdriOiwsrqVnJb5VS + pulJYRNVBAWa3rBRB4U/iskH+z0IUni7GGY2br/J2iF5t5k95trbG9bChabMBr9K0KrnZRAPqFQ5o3BU + VM0SQJcnAr+y520XvRXUK80hzdRtXoRc12oV32tl8fUM17iICfp42VWNocFMQWT6KglbnZQKpWq0Wayt + iTyEpWxD9IlsOGtE0bVDNuhWMFpUxEbLqqxWo9iwtb9cQKccuPU0TaAA6IzJuyUpmc5ZqQbiVbiqiEWH + y+Mvw6OHFXImGKPvtdoxvuzpwNjbB+awyQac52mzBJzvpUnf7CoZjYoUIbG9m3TUq60TOiMsLlVdo265 + nG5wWaqVK9MaZo3WV5WUUlRVsmpihCDY3vmc80Ax91/0uobK21cqTK0VXLLYqVWI31UmumjLiZ2x36u2 + ITdXIbQWGE6WrqL3j2jpVCG1x8/7LhVsjX7o33t4UaKJs3uJaiZ0PCS1OwUHDgpj4y82h1XZxaRf52SC + Jg5hF/stR9CAcJEZhFN62s0na6yYTS+V4fNqpWmwWBscfq0Tg2Zrh5ohzmwxxqmXw57yJkT2KKmxTZle + 7Rn0uWI9k/R3+VNsi08V7yMz9y8eF6rfc7o1YQ9YYf3VGtC3gPJeI5YnuPnbDlrMprnZkWOOgU9TsQm6 + Ce2e+LDlw+NmM12UekTgfq2jFhVPEIlM/NYUzra/bNgsopHNTIprZVctmVtbKnYledLrs0Kx0VDsTKll + SSAsidEwbD/wjbdbkV/krMLMqdfVUbU7V4ZhAj42ma7GPv8AA67NU4w5NiH7qHDiCs7CofW0yof52zYN + gyNDwORWJnYO1bl6IX6g5EZFURlRVzVMtRszU+K52V7mbSQsY81hNsvlm0C1o1cE0ctiM/ntm3OS3VuT + 8lkAsRUyJqgtFpacj8eIPtBxfK7Xak8dDopPCKh2u7+Q3Tm05Fe6Nx/0OP8ABV14kbKqgls6quxW3Lap + QrHVBzMimunkZ2+zs5z2HHQKeveZepVXNCzJ8kJMzXyt6oTMzrYLZjP+gCD7Qa/K87V14mE7sheChg87 + TsHuDs3Io7SHoeHQrtIU3Q+M/l6qlnAFSrs4hMLCJbBPALOygWduVg6qTxWU7WD6W7D+dE3bFuFG89Zk + qQYsgLMRcUAOG1L5Xf0AQfaDT5X7JNnbQm4xwtKNp2BsHamwyKlFbI/Wz/CvezP7VvLMeVkjUIaaLAcs + 9sSyV1uQsyVbNdiGDSacdZWxjpTYY36nIDbHXYy7k7HMf0AQfaDh+V2mzdNDwVc0XQ6RP5T7wk4cLDaV + KwJvXYPcTbMO1XvxJ3/uNH8hTo5h+YZWV9RmpEzHEqbAZcFJyqVkspKTc1N6oNsKFczoFetjP1dsQW+f + wh2Z/Ke+r3Uu57KOZw+DtNhmtkirsQV1CkJuZwKdMWm3OSaOewdobGA9RwKw+5iafKVdiNlt02slSwBN + 5INOYse7QIc67H5RsHZHcYnALfn0Xu4T3LGy42yexI5jaysqdrn8H2UbweB+lTFjeUA/91vJVqEI0IUF + HStNommz+ADXjtIPFpU4B7RnLgvevYzqe5z2YY5qUptuztic6Jg2Iz+ew88tkW1e31WG87oF7uAfNfKx + e8jOVZlUYO4nwWVlSe7n8J2cWsH/ALVMKLygtH3OzyRi+zCnFqKnytCHSynf07qmy3khLUWsbq5AWzTn + anYlrTZlDbXmqxLvRe8iOct1UA766cx30rK/BXIlYJ+y9oiDdc1kj67cxgifUFJ0i3IHY8tgAod2PgHH + krrhrbAZ57DzyTdiCzn8GdgOGxP4+cr0I5hCJCM2narmrj//AOKT8uBtPTYGyEEPgudryp8JStH4W7Et + SmjlsMGg+Dns3TsS7+R2pHZy2bzKsObVfhmn8bVUWvE2lXm4oeuien9LShsjVD4Hks7Si5uaNMjK2M7S + mxBbz2YrtPgzs3lO2v8AQO0hZcQrzPMabXJagpzvZ23In8qKHNIPeV2D8AwIz1JsKe/U7DBoNmI/U/CH + ZLT8Vz7rtIJkVMUeM26bVLJw5CIPui17ZOFg67XRFHZPeUVbAoYGUqqdkR3JN2IrtKbDzyQ+Ens3gp99 + y+GESCbrgpHDFGbdqi5rFR3ByuxB0OqbYdgpyOxX4Bg5rylaedEwctiI/U7EvqMk34TptFh/ot+HhcNF + 2cTDG/nbqiyI2YU4ONja89oo9UdiqA79iunKchbBbq7YeeSbsQWc+8oFXuZbN4cFP+i3m0cF2UekXgfq + 2qqtnaMZQ7xFhbFBr82irUfULT8LPQJrrYLdK7B50TRy2Gj6R3c4bw82VVFUWYQqqrlRpKwyCntSOR/o + 1M0IPtRxcHa7fJVV+HJp1GXmi14uuHAoszYeHxEVyk7MStd+EbEJvPZius//xAAoEAEAAgEDBAICAwEB + AQAAAAABABEhMUFREGFxgZGhILHB0fDh8TD/2gAIAQEAAT8hNOrCmSWS8YxHMBOBeSY3jN46TBgxdttg + rxSPL5RLfwMbbeBEfzTAjpNpQHiFQdpU90tOziGgdQxLlXdGV1vF1V5QlqfKWMX0rsXCEnN8wLhEUTWd + 52ZjDGvBCVq12miYiLJEo6rjLmGnaAHeVkDApvEFsGpZ+NAZ9rLZkNyXNWsZYJeDSa4MvT36TI8MYqFg + YNsDkM19QRpGoFGnqak5t25hULbzc3L0BRokwx88lhVcU5+44cg14l7VLkpsQZTo7VFd+zBGjPKLc5Xy + UbpfZCGbsvoRKjyJ2GY+QK1tiUmL3v8AqADoOn98BU7L8HVD5m2YflhxbpR6m65qSinVnl0p5iOYN95o + dXvMDZi3DxMdLKNr5JTqXwzvKD7wDonUXFZfS6d0Do6TQdp9mZ/uKW9JRcZkeI/8xDf1kG1+OAQdqNtp + sjqjgrjAKBWgwVi57x4F4ZeO81NEdFTMxtKnRMI+0zX3yhVvNxDj7jseMxIVUTcmAzQ6cwITSlEoAB0b + Q579o8uYM+4l5v8A76BEqt1xFk9Cc5S/bGY+NNLetv3H5YFACwFZbRzViGIpVahfEtvDkmidk1tSy8XD + VBbBfB4lFnPnUlApyKNJUuD+pgbwzl4FYP0obUe6mhWJwCKXJYY17FI2xO9v6nm1sP3Ais6ln4xCxc8n + 8k0yv+NJuw5bMLoh2VKuJWtHlmoQ5BC7k2MThk1ZxTVme/4xf4nbANMRrZ4gaewmgd8P4VLNiV2R7lWj + 99DTpQjkHVTPxwnvhLmeHMfoixNJ3gRgjkUeZfZmGCBc0qZw7yxg3SrJUpJVWebvZul4OJayUBi85aDv + VnelRiF6y+YtzTEvb2iDVUDNwYPlWTWYy1Ohq9LYcTaq8xZbm0Y9q5XGFZvSXLi/fRvR3So2Bm4+cmIe + CIH6zde8G7GPBMFQ4e8aLcxZg5Sq2g6ny1Ssg0EdJYWvvBNqlnnt9zAqFHfKL3CUaS2WG2+JWpClFCaS + FNRY3yDnD9xk5Jqhffgz+4laqJ9YXJf7hGj6YmCat802b6mkWwIv0omtOL1I2361s8yw/AWzMzzK6Y6X + 0XLlsFpiaDj3gv7CaL/itDXq77vQsUFu+IaPfrgY6OhFxbaH2M0P4hz26Zj2ms31jydkyE7MAmTCEZUp + 6OMykrGyRRbMvEDkQobSyrhDRkrat4vjhLLeig7JcMJAB3RYhHyi91pFC3QwuYH2fOP1xjAB0BFUKaTH + 7qOAdZzvMWFmN2aMGNwXLENtFXcNy0TJVyujoVnTLK3q/uUD7CbyYXVeTLtS5QaRDVJqEOYQm5NkThkR + ZYp1i3Tb1vot4hHlPKEUSul9TPEzLTy6KlErt1IdoKaTSkkJ/immvjoL9uvj9sJ09FvJ+XptKKXFw6VU + sKkx0lXLzm66doRXiambETr5GLJtUB0Vl0/hKEZJykYBVZuU2h7uhuRBzMLfMzRDvuUHvzaHE29CVRDM + N8TeIBCt5cLDcQsM4NxYj0w7wEgPEwT46I+1lEQXuFR8yplOLxknw1DQgJhts7y8mjRrDS4m3mWMCwP4 + QyW1KVkw/IXYf3il+Etwf0B/ecyHL9IZXiYjrh8wpNibxfBB6iJsEfoh4OgiNbeY9mf6M8X4iYnmDxDx + MymeU7oCUTHQ7Z4y2x0U8zylegIECVKldFSpUolSpX4Cm8eGw8wsFF64E7cwkJohylbztAa7tzAI+xw9 + LtHaGJbXJ0CVZKdWVDDVu6C/FMRyCKa19DVeBVx0t3hJra4h6yyVmycjQ8xYHzR5OUq8QkxVXDZo+Qmb + s1JJFfLjED2fM2ba5lnFjmBigi101xYC7SPUaQeZiKKhZz/5B2+4xkvoiN5XuT3eJbl3gBpEr8fbPrIV + Ase0ZqRTRGhQbWz+hzXhjbPuO0QmuuK1WWDZUtgui/xYkDcgm3RbxPCVFPP4Xw6NHVI7Og/AqVKlSpXS + vwJUqV1y4NUYq7KNLIcMS1AwN3MPRpGkC2sB2HwxPSe0M0fwzg3uYtAL4TuQjmfwwz4DTFXZhTmWSkEg + tSiWln3Fs+zHKUt1ZMn7I5wQsX2iXbr8w3U+Gcizu/U4x8RcXs6kxkm/d3JQdk9QokpfDG8CmmAALxpp + KUgRhnwUxDvKeAV2ma0rFmXG2UabZUKQAd6YqBvKErYDgE1L2zP0Tk1OWhK9Gu0CPmgeNYktg6LZXRaW + nlKSiUcdOW0HhMu3RjLGZzMZ/wDAQRq0hASpUSH5n4VCVKlSpUCXayuGCYa9BKMCwMJ00ygXA6L3KNIj + 0c3rA6qgWrQ3YbrpINpRX/EE/sQ/oUJppHSHrLpFPEq6e5hBkFFw0/wRSTDtCgo7yuBDa7xmmeAZnF/L + pkA1PzHjdkRWq64mb+sRiINI96KZaO0QXtLyvviAjppFCevicB8qn6zTXF7yvWaiPua2fUOaoPQPbF0X + wmsv5jzEe8qUiI5YYWGWI6ReWWS52EvoVyg+dUeb6p2zT+PUYyI9wmpUqVKldKhNH4PSoErHUOiP8/6Q + g6sCiUMdiUbKvp2sUvXOYs46RRS5VMTtl5bidiL/AA2jSMPTqHcgO6GQL5hovmh9Pkh98OB8QLU+EN1o + bg+Yvr/McR46xHqBUGmCcRJxE9mJsPQgGyX2JoDRduO0p6n/ACs1BMQ/96B3G8xLJSX4Z2pd69ExKmdP + MO38nl34+BOzpJ0yup0qMg5HSpXRaWl5aCgoL8AnpDKSkqV/8w6pUdBg1myfEoDrTpfu1Sh9okFGJZ7b + h2dKlSpSV4leInidiN0TGSel6FrgzaEBdFSu0ZokTPGeEFxB9N5eD6q4nEQ1IY9NTPHp8fw9sO8lMS7Q + SneIlFQqlOIiMta1b8CLqLl+g6NZf3Kk7ErxKykrqfmv/wBqlQt+H4Qlw6PxEgp8HTKLAkCtrOl/hUSJ + 0Y6xj0roQhCV0UlJedlSvEo6n4K6r008RTWAmn4gnRbiC6RA1blDrorKwieisvwzAdpqhrGPW+rOpSJR + XiVKiSmdiWmDUPcoMDyZpwk60PIZWCmsXw5filSpUqVKlfiQOgekKOo3lsD0XDqiOtRPAqYFWSnU61Kj + GPW5coeIi1b8TZh7k2E6V9IIMzoP4NQcVk/C+pLly4R/CsrKJXRqVDodRh8vWmZmZfuovbMY2Kg4iLDn + KJWV69IJ6oZJjJ0UxoA+Y6BQ6R+CP6Cl1PyVLn5U757xfqPcu4/OZ82+5RdQDB2gFnN4mLZpa9noehhP + KXcz0SbnzENF5EdQXrENfljwPhiW57QXOFIJ+JcQLLqYivxNEuxptCyQl69dUbNdS9fYjpfQVMdyZkHi + FcupXu+pVzHGNy+IILGJceY8Sw/8EXf2wuAQlZs8TYD1DmfE0CRor48fCMLy5qHeAYmXSzJtOb0NEuFr + OCXGNLUZ+pCm7RxANfuzGrfzLgM3v/k7r4z/ADSV5i5Yiv42GsPSklxcYdJVzr1UP+Y9YxGAFgvSIUbQ + erBhB6XF9n8qIa5+Bj7qFowB7IdbVFX0Ai0T/e8Fo/qD09idCtb7DmzfzN/3UVxOHX8BFRt0OUr3PEKj + 9YJ/wDAoL8xrUmFAHSobuX0FE48PuYgNMa1BZv7Tz5fbPKIHZBNs/hVDS+if6j/zN58TOY+2Nmff/wBx + fX5Gc3+XidkfKc1PuOl9D0IyAU0psQXq+ZQf2YWnsFHnToDcueDFzH4UPlL6dqCumhMpx7y4qJEL4RZh + 7CmW+EWyZgdoyTDo4vrn4osjoYeIbDDOljnjjWPM3Z3nazCMePLeiKKM6dL5DPMVtP8Aroxx8rG9UTZp + GeGHBuD/AJeD1v8AOCxAWRBMGguaM5fucuQVjBQBfE2GYUsZeHRRn/rM4PkZS5XUs/kJUelP0y8CaFXe + ZX/j+IA/l06XKN6uGNgaVtHSqO8cXXKGv3z/AMGNFq8pwYE/y5tW7SazZPFsLMjHJX7m+Z9yi36GdrKN + lSqqn/aYAqg8NpV+n+o7TEfH6g9MtILovsZiGKeSOCsXEU5nBKYOlAa4psy4X4yx6t+6Ptr8G/cAfrCU + Nn6f1A93yJXonmKtLu6/uV/y0fW/cyOhS/ro/cFzoGLixb5nZV5TaOg1wf8AblfZhBlzLuFQ5eweiAF1 + v08hZ01I8M0u8HdyRWO8MANIZd+CVeSUAg/7EELA+5m4aXlFg3mYa4Zry6YPni2doFNTKTqNkwdFS83V + vmCK32D7miRG0oIQyvhlF1BYrpVafEAFF08yzoU1kmP1WkuCljBo8v5lhiwEDZKS8ZMwMPio6DFMxJj/ + ALBb2NyYeSleOJoEYeAYiX+R/lDn8s/9yKnJ7xmecLf89zPkm8DtGtLn74amm7Nc3GvT8R4/xGFoNXHi + Ch8/xLjggI666N94y5lRfL/mXNMLanOSLB2Nv4jxRwpcuVI++ZFmt6lxdd4cKC1tbuJwRrmEdAjJDivQ + HiLLEuzJK25yHllDe0droGnS4DZjSXcvo9+lZlO8N20MbTKDhquKQZsS7cwMuc01dO0BcGb+A743hOCI + MoPa4HACLHSO5UKtqLNT1KWKQBUhrzpojYsFOJ3M+4ZdI7k+ShHVc9YwGx9X7pVANhgKndhYMdTfNHoV + Idy+4vXDszeo42S6dNyQGNd4C0CZg1xMrW0rbEON95i9JfgY9xD1sMYJv16hByRi1fiGVsyE44bmREdG + 8C0pwmQcA+J20hy3Em1yDrz4lPVO8tNG4oxZcwocugbXwZx81RoJ2QQIory/8gweb+3TRWkS7xBPAtWN + peFAXpT5l6sA30RKBDnPHMrRA5rmKrlRCxBKpu0NBBNhcBFL5ElzWAxwxUM7Asg/ekOTMZnDmXwKtd8T + OR1DAzAkDYd4/wCRrOa/gSxgsKnia7tLj3TgQ9FR0ZhfVRyzU/qYW4uYrAakr3RRsQ5lr/bP/vv7mh/n + 8ywLPXc+5WoHx/c5UtaUzCgB03v/ABPL1et0bFPiUDs6W+K5+CCg8Ms2ek7pQRbM2d48DhHfh/A3d6CE + lksPeppMEWiLjpFm0NyDORyy2zLHcuyfFS/E8JcbKbnlmHsXrSjqCk2Ixr+mBPtktaVEbhNF4n2e0hjA + 1Ttx6+kwYFxzKz0mnrTeG1Gg/cYGlyWGvAHL0kmAbNfiVGlXcTl1DLBcuLUeMzOKijnN7a4YExQBNrmr + NaqKKmw3EuuvwXPAQ6VXLTWU1MC35mCxw1xCdPFp7So8BMx7vdFomApZrBtjuchtrMRZ2O9zXPLyyROY + yNB/tY7y3M1eEIs5YC9jeWJh7TzMxiKrAnKtIMbUzftj+YIRho+5lLcpiDjQOU5jaoaQrO+ZbNlburHt + Dxqqaw6vEx7xUFeU4FviG3LF0wjW8BxKlwHwhrD0AYG+hAcReGgOAbwIAKpUe4DD2OiApXe0+pUkxDVT + mWGmOVFyihpbmGh5QZlNrLINdN5wPwHGiMOta+qGrpvEK7QDWosMVPwI78UdJc1pJlsz5noAxJE0dGEP + YQwGaRwWYZauE0mfjSpUJFqzKnvv4wEIYUGY4JtEOuZbb9quSGp0JrYeL26z6gdLquIX1hLStiRqyj5x + qKAzXtLW1Sv1CtB4T+wIY7Wj3BCAvNN2HQ4SjK7UnzFDE22o3huJSb4wpGLIW3Wf5Rm6pKIcJugphdaj + bzFQOBdMpE7jO0a7ur+JUpCOsKjCzBEPOVsDUHlOIso6d5qdpiOAh+1L0G0FlwYCugryX0IskiKvL4Jh + 1VWbauarJiVW8nivE2+cZ27VEBOpZ1yxLpZUqVozVxijkELXMckzbu7wM5uuI01ob3B7xCLtABdtQZw6 + 0A07RC2Ua7fMRYZbfuGFFOCpe+rv5gVJLTh11lii4Gu+sZxw9N8TLtg7QYTSl9Xc32uaHReQYKB00TGO + sxoWspjBGF2ydpjQtHCGZrkwPMy8MrzK8xMas+oehoiOtZWo9yiQ6Otdo67zDkcnQUl9JgPeOx/qurM2 + LhAaFt5gz9s+Zds+Zi+0WTS1fBhs38wK9d5ZvsvKMgMTx2v3L0moiqxvWGhLwY2wvGrpqLfijLPDpJpb + QFl4cSu4j7TAXmmIMIM6EX/USw8hYtUSLQ7cf7MzxR0RgOhEVkcztk+EYLX50bLQBfxEsq6DZ/1wyKUC + pMfPJ7bjRBLtpUM9FRbDSFEwagimVUinq2jMm6v2nymU7iK76zt0BoN3d3NZrjIDZCXXg5rjGn+5lgNd + pK1M9ageYJetBTMVRjifZH4arhkYM2NB/uI3gStmgllpumrEJ56ATQdZo/xLVSNV4iW1Xa7fmWlpzmJU + toLs7zKYcLVJ7uVrsRPZCBUOcBeZanRKN1lV3Qmk6RYjpzFv+po6e4n3+BRFoGZ9BJSWDcyazcSnSFWc + i4WnaHmHA4Jyw7j8TSWfU8pbKw2BDzL60m6QYkFgvKTRO+LywTHb0plWq3v/ANzLXzR/4NutshJRJmZj + LhKwpeA5XNTiTBIhjQHWAAa5WgT5Exp/cJLOouqlPBzHg1nqVj3deoR90EuDaG7hbBNNfUzDTuRov2TH + LxacJlBaiu0wvAjwlEUccypsqfJtCJlLY8MdPWjKTSGi+aYk2rGOw3NYNReg5uWMvUTav/BKPW3NYbn2 + w3aeFlW0TTDE6Dph4hk5uHcgkO7q/uBnvcwaGSzLO7rB13xG203QeLMr4RT+cjLv3H/cwxDOhAy3fiJu + RdviVeAw0DT/AHaHu6M3RpxLpSsavMIawTEOCfNM+YY5YC9glOAl/wCfE36akt3lzeVIDAZgojn4uZig + e0ES/qWKjaO+uZtw3momBmrUuA8diuGOgwWsYepWeeoxV7SzA9HSZLYjr2dNcGvfiW2F2tzXw6w2UzLF + tTcgeY1w9SKpug0/xHjw7GXF/CZR1asahG3eRgMFGOnwS3RUIHUZ1+k0yY+of9f+kMh8WImHpq4PiGwg + UHaV7yneKczsMxsaxa6ZxLKBYjtcz/cf9xje7j/c1qNg/wC4r/SXIJhEfvGhCu5NrPfEJQRFA3U4iwqm + VtUKLWO0a6lt8PzFEyfQbXMrd8gPcEVcrP3C5SB8aDMpTtR0rttFtIDtNH90olfk/c3MBL0IUu/oGrHe + M1r9DUmnU8zaCG2FNUlkQSU30nZIR1LvAupHN7zJ+U+CdstKYm6mnkVBZoaPfwQLyPQ1rhly42eZkaq4 + lYd2aOkslMAAZTeUK8XfrMJZ5Tcw1dFFRx9E0nrE9NAVeK+cWSvBMW6xjyEJxrReDvAyqjGIDsV89M94 + GOm8bOhYcPxcS9DeY+kJUrRkXdaa9LU6nxNM9dS5WL1ZT5QgGssPFwYIieppBbdvwCa2GuKmieyg6qLZ + L3E0ryJblYbmN8sV3X5nefMw/wAkQP5oh/PHowVGJqJfzukn/ow/7cAKB4j/AIEf+6hs9EAO3hg/7qXc + xYPJwqB0nnEPNT3iTLwPSA/90NLuvqcgig/RGNT0wao7mgfcIvyKUUG/i/kmh53go0MZqoR3HP8A0jeA + ocwoNCKoV31gCk7mXYSgG8sx2AaugcLvEQ1NWaJcXsW6MFQ3cM0DeSFWNcXcHpE1jR4JrgO0A7Jpkm/k + 2Tr5jodYhxVdmFMuh60MQhWgUUXNeZ7wixXprLtFeGBIMrWt4Hu/eIfCBmc1lCqIttjm6iKNFy0llvPo + ZY8IJ+aZWr8a85X44t3HXSDAUaDhVemr5lEFAPq2/YYljga4TCOZLF3TMzlaO8yEC10SuDFOCAG5XNbT + cryZpPd6K/APGIjwF7z+YDhByrBPrBjseJZADruFIxlikRkK3jzsj2rLUSq53l3MdgvWNkQ0uDNC73Fs + D2VP9Elv+EsXR10g2Ddfl0uHjMyDXrKCzPQePdMwXU4yWbRdiLNorYjcR9zaMM521lIyqzaD7JRvN1Uc + w0yy+MfzDOtdrqW/6JjxOLP9FNHXP+LmG3N83MC7MvBKNmwNIXxA4zHeY3E5IGH12arTpO/pIn6sMAV4 + Bi0QcBANRBFuG9D9TNUe0xWUjpZscWClKWQvzmVLAAKzpDqVei5CKzg0HKxQbGrrcEHzwOJNbfu4UwQN + oJ/MA2xeY8exealhXnTBdBcJfqJeu7sVFiCDGst3TVRzD+6zuh2htdRT3gQ7HX5uZicXdy/cxqcRuvQw + K/uXDueyI1EY2xacwrAexhn2OSz+YM5XlJRqFKX9oXOGqhTtE6i1OvhL4FKWH3FSi0q0sxKRwI+gH1Bj + frLQ7TEn+A/7AaTXEZKMMF0MxQJ5rc1MWq5tvTg8zMSmcb2BAqxauL2ixGcE1zifFjrOalX77SyFwp07 + POed9bOsRqCU5l71FUCiOUticR7IqV9Iv0zxUaOZuQmlZ5iygJ4mERd1NJi9pcWPE3kxUJ/QS+m4PEdR + wh4hIGM0RiRI26NjTE0n5ZrDyk3SeUwXqFQr6MZYi9icC5C3jELx+v8ATPnlT+IFKPYMzOFHDshAmTus + 7J2tAbj/AG0WMoNarPicF1g7S9Th3Zgny6+4DQp2a86xD07KZ+0IsE8mrnv4l1eYo7MQuxt+PCYJu3aB + 3gxTC8XFDO57w1SvtNLHxsYCCVLLUY4NivuHwGL1IFDhqUJlM4n1xgxwovPl0EDT7z4Y0IUG4+P9vDNr + cOMaSyy1q7OI7bkvzMccQebn30DrHsjB5iWF8Eu4Lka3xHVQuzF9/uYXIZzjt+5a9RqsjVv+pjgrA9Ju + ynbBeYluMsGFwNczIcmhKiHL06rtZcQnoVl6+5grpoHkRVerVHSGMLtIC40Rjp1BIZoQ0BzKFxBDNaKP + EXEdpDpjSuk60Jouk8CMVmZU3V+F06Dx0MRGHRDpXQCMsWMk2M92f01xP02ZofgwmNZ3LP2wyI2vLjK2 + b5q/LF18r+2CK7in7ISwK3at9xGLGNr/AFAX271Atoriw1S2sx9gNNQ+4NypeGz4iEy65Kn8aMRqiPTN + 16jCXh9iDqkWrbRyoihPDwlpYnMh0A3KJ7EQ1TbX7RmPal39zSUcgzWCfJNtO7X8RJSHvZB8/wAzMqsj + 9sSLtqa+ZWr5EF0V7R1W/CF2j2QN/NHhLKKPd0OYa3pD9TfGUNyO1v3BaMElza9dp5AOHrJUHX2YELsd + JH/JKkdNMl5Llkym6WjMo0ZCknldwJrJSQ2HfqOhckNLgrqF6wUqAm53GNvgJY/lmL+ef9D0dtoFxedp + oG4q6r7lo7ZfOJrB98o1FbyulTiUDW8I5DC3gQ5DWuEFIRCjIQtj6gcVTf8A4lWfQ05dRZfhgvuqiQrN + K/slC17WgQO/gxLy79HlPOKzrZgBMU1R/Eq6LaxMIMeZrjYtWBw6auhfdzdQg1iH/iKGqR5moo0xHNey + DX4B6Lp76MfwKXQszszbh3zP6ioz6rM0YnnEErH7Z8/TDar+XUUfM2/c1ofiv1F+0ZXh8xIV4EGROxpl + ekKPBN/E/wC4/wAME/8Ac7ZgArbyPjs2y+4Wax/rrKjMXMA2caOk02RgbW+iU03wq/uMohsNX1LAXNdj + Vzy8TT4tqxHcE8zUHLFSoJcFatdpb2PBheCCu/tEtWcLoREDtv3AQckXDxLZd2qaf7E/YtgjVlzRonqX + V6yxuwzNNApmU4BYOjAdIe1/M1pSOxwN6TMN0hTPmJvR2q7QAiwsnOWhpHv7vz2ngrBBhN8vJ/UNI6Tx + Yt+fwyToLsjAHuJYf1gsLbpmIK5vEoRjvEdnzHgRr0xxSNAvlLaXmZJUy6kIRFLdMM9asMBtJR4jw8wx + PYxWqNAfEYSBV/CUBm3KrTWOmgwUnYkg9VH74igDDlmIW7LBjtL33kJMHzdOcEwIyVBSl07s1SmHDATW + zHQQ4AMbcAE43Is+hu5a/UtkC0s3biqiKyyBxdbq4hjHjCGXd94DnqdEPb1aldpkbwZ+0WZvu+ov6LM0 + YecTZB2Y4qz/AKxLr99P1GEtaI7TNEabhP1MInsofe7V+mM0Xe/9z94B+onr9rfsjl2H+sMaeIgccsgy + sfm/cznSv8Mqn+N/jPqIUQeP7QteFLNXYhgklre8xydmUs3XGf3Mgdzj+W3iUFAXWz5IBWPT9JgiY0l4 + EO1HzUwNztqzaB4UQKjY3n5jPrka1frWsKirWoHUfMBp4UJb/ifvasIFgOFQscNVRIvBgFJSzsgBBBmV + 1ZVV9NM9JH4DxDm4CxHnlXiJoC+JpI3w4HMuOZcZ7mdCbT05w4NpcI5MdHMYtPeDgl9HeZ+8IS1hrn9S + wpZlnoYZZp7ELw+Y5vQuVjbt9GKmNif88DKPM0k89PliLJDxLvFGac4j0HzRkGjGqqsM5LsIO1e7MS3e + XQLNfL/EqV0ZRGHpsFrJPE1BecwP9dH/AEWZsc+EQYDszC+DJ/OxH1UCPoMP9oitd0QewO/9iWNmtD+C + zaLxJerzkLEB8r98wifYudoBZjnWb4R+C9iGlu8L+4QBeaMDqF+f6Rxqv/OsYsTyMpNi7kdOiapb+5/v + GfE03HBL+pUsGi7TtMK+zgTNCOEpY27Nz9JaHHoapy9GzY+J9OrP0QK/UKYhvLfz0CLIDSrmZkPgBKN0 + nmbZ7KPwVXK7x1KK34nHAD4qXGLcNZ8zN+8Z7l3Na7IdKDGGNc06TSDLMF0JJoRdmFazIWuy8zGZuaQ3 + lsOsNz00W0ibio+oH3CsipiqvhGATqcLd2AdA5JhQbZepgwwGdqAE45mC6GGP9kmf4hmgi11WCVCeZdl + sczA9RXBPOIlcuQajRa99Za8mcepcvo/jXVZekWaYZ/KO5/DeoQq0aw3N0+RPpCYdo06g+SK6+qVwh3z + HIaOCQ+Jnsz5Mo9VgyUtsusspq/E00d4fETtA9mL/wBxrqDzL7OezF6rU13viUXYX3joGO8fg33l60Bz + vPaJNZcvxBCCmQeUtosM1NEEywEEJB0B1GF7xFFaF7elReC5mHN+H8Dhj+28JdJFo4yVWXXcjC/HNPAl + HpGsbm2YNHkYU4tSL0s6Mkygmsy8CchMibpczwFsIVNV4uDcZ4xt9xRYhU0ndUuvjSxR5hrk7f8AsNt7 + ar1gJS5te4pGdfL1MeHKBsTJHxsdZp6b6P0xWYDzCTCxBrnWBqO6oV8UsNv4f0Iu2kZooI58RF67SkB3 + oi8zfLGHrMvN9RcHesJwM4WmEgO0Ohu8T5QaE3gcZPuC6OJSD+dHQ9O/fL9ypU0a+5svwTZL4Y7T67n7 + YQGoPiW8y2+fM7QUTE1Duf6ZbKHgn6l8fRX6l0/1ujO0K2vplrmv8NkT+gjARxXyShq+wgUWX5jIrhBv + j3U5qd0y+Jyqwe4HQqBgdxTWeLA7Ig9vpDtwDWF26EST+rFRSrL6dpnPP8/gJdSrlFAhWlvRNGv5l4ry + cGIXEe9aRg01mjKfM9kzoLAQo2GxL0RwMobE0r/yBKG8P+Tfp3uC79nSwZwLlx/MH93/ANTBsHvJ6NzI + zL6lh8ohum+aFmF4mslG3BcQu0wpHVhABAdXY/iMUXSl/icz7CItXzDTA/E1pRWmj7h3ZTmXAaTGoQZo + WLbcwDDWxxqZ+Zl7BKUDdJjgI2ig5spw07Qaxq0JlLFtjKLPXVmFoq0uD8z4EtSVY3zrtKdMQXeO/Hso + b+XDHTjF6k19LyXK6h0KiLSt9r+eh/AKlTQB4ZofuzP6wo3SeGbj8iFZvufqC8wcRh5iZ93lMuKT/wAG + Zftz/DJDO90MQfPv4Ib7p/iDgkf7lg9A9oCYJZMTEuX1FGofFehlI8B9/jU+eItg0mfUoWoCa0pcaOuo + sq19jP8AxE4D6TYD4M2g+P8AiOyfObpeIQ09ZHZH/vMB/YR2ZtjNgTsfbNgHqI0rC214MW3+gjqvmjrI + N9JfrEMasJcmu8UTFHsuC0+WaR80RQr5leVtTJSwZfu9Ql/VG4ZpAyZpLFWMEwQ2oNzW5zLaVVhJlyrs + wNfklXpLWQxfU1hWDS666Uvi8woSm8JSB0GXd3ZalaMe3+Yz58blBncaMF3/ABRinZlZvbKldU6HqKlS + umm33Ni+RNm+mL0S033QNA+HotQGc6TVi9zgM/0U7Jv9ZL/6dAVynso7j4I7Ug2UQCGy7OsJoi9k+P8A + 2GicH4B4A1AGzptK7TF4mC9HHSnuBGMabxixjGM06YmI1LnclMdt8znM55rMr8T70JUIVT+G7TDDoDWI + ntcbTYyfUzWRoUYArtk+HRmZtUB9EJqAPdWr+2FG7vTMGwfMw4jtK9QzMoMyCKGP5iLJ8z52ZvPMNFGA + 4JcdJky6n86ZPmARDkvwwVZ/AveJp5dsSzLd1UaSwkWto+KOtSpUrqkqV1KlfhqBPE0L3Q07PUe5K6Kq + dh5JokBrh4f/AIOks/wFHTRD2xf3+Doyhe0r4ITsXMQ2QnwOI1gv4iIcrH/0yzS0uMZdOl/xAePiDQfq + Djh7i2Y5VzFaigGv5g7hsA5X2wyrHzAjKEo/sjUEeYpvINgYVMNipflhM6VUUpt8kMDgPcB74cj6YP8A + 6Ex/xnknqDTRLOT5ldp+vppM/wBShTKyrzP9OEhNsdCo2Bb2jOnHmLa4mtSRUOwPiHOzYa6m0DbMA5Lg + mFWxGKhx5ZY+ZiOYdDSnGJW6l5hSkqW4AkrrXLIpajrR4lja70cyqr7sYwCwKEHxp2YQdIetf/CpXRUr + ororqYmhF4ZoEQt/sgeqvMblxdj1G4D3MN9EMBqK9dNE8OJ9fh24TApeltIBWA5lX90BaXiYhFMSi7Uk + 0EoocOBHEaF1ZuC2Bd5tNeoT7GmNZZVRWMRN9L7lXBaL/wCg1CiXNxbiwNXtpEYttoDLfhHdbRgAgFVQ + 5I5tZbz94w5GFKmdiph955lt5X1gam+W0UNoyUXulG8s0ekdXRvUbsnaSn/qPCCH0JDs9raW+48s5SwF + T/UYKs5/oQ6lFy04ySnJac1w9Y9zIV7XDLdMWGByebj5gS7RTGTvBvxYU4lm1PeaUNi5m0l1ph7QIWas + /iO2mLmm27csVm8qAmnie6hv8ExbxEOuaUx3jBjo36MR1UjvFbZ5U1knvE4Q5NIVMWgQkYsuXDrX5VKl + SpUqVKlSvwqFmiXpXoRMiifAQ8xU1E9tB+F/8PmGiK1CUdrliSRutC8RgFJeIbqIQpkaMt6PqWJcr8oT + QoBzMoLPePFfLKdPljYrwRF3aJh/CK/0Jaa46neOgXzOFsvMYrbcYUVrP3zdHFa9FhgvAR3wusZmqUGN + GVLLyi3KvsgRrQLh5l+TCazxKXF8RFvrMvoIUKBxDB7hDsEHJEaMjK/AsYPSUwgW0S3GIQGMZ7BzLK0U + r/EvK42ogpUzZYo5RVxRKGtgl/i64lpCrLdfcWo3qK7mgsDeYnQwHKLd1kOyeHEGgRMLoVYYAtz/AITG + z0RSHQBKehs9RHeNakKTUMckAYMsxcmHZVKOZ3hg7viqB2B2YSSGX/8AWpXRUqVAma2Fxmgbi2F2VTu9 + PAC/xhVj2iYirLyXKnQdziW17ys3AC9IULBZ0l6NOI6YJUo56Gqm8Y6fWm2eis1eUrXOYn+uJ3JW2Zfa + 8TDzMTcls69M7ygbeOoLdL7t4J1hOdL4mTAOf6QEB8LF3mOKfIU0jnOxgl6u3pq/mKmnlaDNqNAY/ZC/ + 2wiB2FbQ/Y5kjz4yJ+yMdByZ/UU5xeYbM7IsHsP9Q1yko5trLXdgfNFsN/rEoIrTEbBTtrLb2MquBiHV + 1qD3LWG3ePaolBmggdovxDbr00iGDMlMsa6Q2XYqFKrTeH9xjG7UhiqYscTQIjVMIWmZvVQKuJxpTw+Z + Za1Z5ZFbh0LlyffiOaZI7stckWrzd6b3FP2KbNXGEPsE7Mw63CAQf/pUqVLW2UzlJYfH/s0XGdk3POs/ + g63li06NEIyu+wSj7qrZvddUZ2hTHmqmXrMdNEb7Ogqpc+6NN8z2je80EasN32lHMrvNTxFo8T1FnhEy + sp2hiVmBM64jp+/2v/JjUvihnEFPjsTxqCpTLLarZjxUXB08xO1s0LFKlJuvm7jqt5QR9MwSSytZ+4Ik + DVcHZ3lO/AuvayB1DYSQbKO8QEksLt2Q5dB4r+p6aqnkVVDu07X7Ic7KOTzxPYDmfmWC35vmI2/ZAW0c + V7E2SUBnYIkQ9rQzHgnmBlgPuaipnECKdvePMgb/AJmomI8motXmahNIrEuHQzErXaq7S9IgjvoIXwhM + Z2LL5PG0sH39yJzAsJt4h/5PEdJwpH5mNGhZdtorvfSIwSUIfQmMb0BiniNCx2SIAtUIWhmM7sCPgX+x + Kxd2H8wrlH3wxFQ1InWftqD2Z5VykJIGH/wtekKJmS0s7OU0s0RgPxzx24c+DnsEybS/Wg0XcUPMF0M1 + CieIRizOIe8Fmf8AExB3JapdLRhmAV56g1G3TEGL8McS3E7MsqWIIWEXJI/B/wBiZIXVrN43VCXT5xXK + 6+KjmBHeRogO/Mck85R2j+Ll1TVXEEfwwyLLzCylh3PrL4aE1w7PXMLtjLJ4txEdGwWY5pqa3hzaaRc5 + Jf8AgwugN1UqHjt38bypM43PUbkTXIS+1XY5RVtiddhFOB3E40PaLnESWk7oOyk4YpqVHToksJhSYGsu + JoxmhSajBImJlyLSPbhllzFDBcXJUOzBO8FtiFBq/cOEpqbRslwuNR5DNH4UPAeZdH1WziZCDmFEXBKS + 7TW27Q5UOnRW7WKiAzGaWBvPsQVaPs1NO+ciFfOpjW3sqEWadmcPWuX1u6kR3Mmnc1mhNEy7s+IKTgj1 + 8/V8TI3riUc8E1hO8K6PAxEUSjVZDqpmmEvAp0miNzWdreFZsqeEtuLCPM5JyE4CZDBasmZq+JXhwnFX + iBNWnaLVUFcy/P1Hel0PhCDg1lN2iTSE7Ev6mm6ANBxPFX8mEqaM+ogc0N+iXcOExkVVrMlZjKyEf7Qo + mgJr4lfTSM2cQhqz+6FkJ2YYBdEpl9wtxhtN0mnMH9mQFnNCXAKSaoe83MQauunuP1Brp7v8qAo2/wC7 + s15/rzGqXxUwJsFOEGD/AHLqjusDyRNbLrhE1FvZ6lha+aReCdpforv+pl4cTM7wv3BPtORe5Syn4XNN + TrvKWgCpoKGpzE1rWALVwAu1xTeN58DA2X8yzgFSwUrXLKeYbGH1O1mBcAKD28oxlQUOgIIBWNl1YwIN + ouvBTTtNEe/xO3Qs1Caw35gbkMbQ7NTTPGXFP2Oa3fwKh1knZudyEq4IIaIawuZPkdTtuz7/AORj0VJh + u25+5l9CpZWnvmIXvkagXJ77yydEDHS+UJxnntA8NwF59Vgr6kZoODaW1D6OjAdq+IZZ4PqUaaDRCmgY + vb/qapJ4zCgropTL42bThBJVSrvcbmnIB7ZtoBQG0SFNblGo7QQUuysdi23HCnaXMYKz3KHLN965XERl + pI/5Husr+2omNnBLi175ml6u6lJzLQKr77QG2yzpDyCmXDEtW2zcF5R06bRTgGNvSh8r+IlybQ+kyWr2 + Yfcy20W9aZkBvUWQHJ3QrlkwLpMtieIA2Q1wMOCSrHusfPf3ASgev6DeYRKiSZoF4c4vxBCr78y+7WxY + be8Es97zBE6r8as7ZPB9SrB/c0wZ2YV4xHSLILdWvpKEZxiVq+1qXd+kVx0lz2TbNK74ixM6+ZQoiM8w + yk4r7XtKvnTZ7v5IncMZnL5O37iGg95geJf7H4ohoCUtjU7BmHSO7L7NSq0/eVfscuH3UUxQ301zQBel + 1t01ky2wn1/38O9qzyaC0h/x8Nv4JkTvFq3mIhRMKHZjWFi1q5qSUwrXvMN7cQ1jSuAsvw3fmLSF2aD1 + 0VeUR2fBjfovK3M16GTTMRJYyuZeEMk5ZVT4EwG9pai9obNllEYh3Rhbm6ECR9Fi+onwdol12YE3Ryj7 + nFqFhd25lBLP94jkVwO2JQ7at4295uG85pW8s3TG3aPWBVSe37lel7Y8NoYMGL8LYsARNZ/N/qg9/wDY + 75jVc1QT4ZzgLAf7l0Neqwk9zVC2aSgAfC8RR2/vHw6MadGZgdZeOtcHxaqdi7j8zuhzChbdzRmNpSsR + 1YZpz8zuxQ0ae0TZIUhvMmmo6NqZcOJj99ZabHe4OVlGj4QoClaxN3oh57dHeUCnltLHiKG1TtOb8Swl + rBjMdYWcbdbYO0RXtDZmy1lUwbhE8soDWKoobUgbugja2EZrKlR2DH8RrFdjGPcp9/hWuR9pVe0TyQef + iZtPhNqdSNYxhhJyXbCmBMwJx3g2gsYqBjhSG3USqGi5mtczJzP6sHlTeqtIguxC0GvoS08IaS63Nc5k + eM0tBzk2fwmipRre90z0w2qbl1TWaYHuUcJ8y1DlOH9yUkUSmVYLf5Rg2hfMIFKrm/mWHllzKYIxMk1p + tGWUH1wctckRcrYyTw4jFAq7nMRbIXTM142t3fmX5boJ41TJUOxKJecNHh/mOT/Upt6QM71Ck6B6EwoH + drw6kEWw6mHwwrogowNxmDtQ0qe0RRdeyfGMDTQ23thO/wCVeEZW/fRFhgLik0yeJWc9zMrE4ogtrl1h + 2itlzBwtz/Cx98vZvyRh1zagFfAN0xMapRcG0pNZd4vQxNMd5V30mkPhwxIxSpY1GAWraZJZddiSy7mm + nQcTMTvgo9S1MPklNh8GC9n6mMAr0mUFWue70oJsXDma/hXd+fBKHwTHB0OL18SmF3aWkIpiFyLBdLGs + BQLbxynJtiIjZBFXPmiWAAeRMJo2vmBk6uBHLEmbi5fwjg8NmIUdDBv25rs9LFyvL7SnUeodqJXT5Zbt + 9ss/5mfDwSzVfco62+4DCmYFYniYaL8xXUqNa+pgTs+eJpGiP3L12mqITY1i5xX4lHFTxDjLfSC2LfMf + F0wUDDm819iO2N3efvb3N97A8ofZuofslUtY6v8AO0VnUTCQAfw7w7TI9DGIRZRY/wDJdGLzPVFM9ogg + 40u4euJmx/A+GXeuSCYz2Zbq5/6y0o9r8Sm0PhB4AmlYurkuavX+vUbnKQzOAu3xPLdibU+UBch2awAl + xtBg83wkBdCmY9qFGaa+0ywVtn6gpY9h8MNP3a/04g3xq/ZiOZdyKZeGY6hiJaTXmC6cdHk1lRa6mE86 + AO9TSNI6xUY1mk4hKxyztNl56ggjcThdpeu7eOk84Sec5/Dx8WvL/wA6V5Q2mDpBX3SUl4JmJMq+bGIY + fkuZbe5RrHreUVyvSYcLThhtyGtTgB9GJ2eKaP5jt/JLOMs/oREZ+ed6e52YbUHbL8fgKw6wDqM+Kl6W + dwZKQCPsd4lTzlrHOJp+IhUBuUmmuZjBC1hn8PXUXe5+CZFb/crBbZ/8ZZkJuRwQKUcb3et/XxHRYqyv + l/cS8MsXxU33itPrJFHBske3JMPtAsPDHt5zprs7xcDbJDGzCB3BVxAOVz/8Ss92z97e4YIib63HSY7M + at7yiGEBM0DJBkU5LCSg5Y4h/wBqN94GonBmKPKIN8QxLvgXNuX8k3L2r/8AIcEihTkQdDdcyy74SDDQ + yHpkgPkKfD/yaWLDa08kE7x94vhzFLhKRKSJiC+ijxMkQGrpBWh3RlVDSGrMC4G/iaEOOgjiAujPm5om + iVPd9xO1A/D1wfXSuxBbAcpjGGWuQKoY2RLbhB7qURwyY2PKVKXU8GIIeKViC6BrPCWl5boIpKdapUr8 + Lmuk2SzYgG2Dtnpc/TAJqmkDaH1Fq4te0PjgxviCb1FxW8d5lskCczTU4ldA1Et71xxOTHA0l44DY5jW + q4GUOc3k8pfCHK6/7li46Ea+SNXHaw010g0FGNB+ZrT3TT/cwq/36CUcc7f3gTXbpSOXVIy+UNpKQPLZ + mkjmyepQM7S/+YAO242MS0QG/wDzEYRy1TvMxMMSFGpEHRAf7TVCKe7Cy0Hkwwbo9xiKsq7QtxZBUtLY + KOsdokNiswx3haSkbSwyPDzGSL1bGFo6jVuOw9kFksTCxjt0YtT5Enxl/macPQMx7moKdi7mxNMVg5Pq + GAOrPLnXSmDc1bLtVlpDa0MqmkPST+F61gffeV10qdFSpUrrc9T68Amij5z+YuNYLtX9xH+58R+1UP8A + Ip5uL8H3H6TSMeREdReuJsK83DRb3hpfBfsIKAMRRt3lSQR0TfouS6IB2d5xGh2OIcfExTFrJpLOaBNB + 2/cq+8kFeJ9iINNOmz3MKOhRz87y9qsNeE4DxTC8j4iWV3KvAxyZpRhuZkEm4NUxiYxa78MTUbuRIoAh + MBajDh4Rkymlopdat2pRnlM1MwKHD+mOCj1ws98BO7Gmz5JXe5PwhR83blne5IoSe0eW8OzHW72iPxlG + k2pmyZgLdY1Q1xdEEEMVLHkfzLGg/wDlzmjnT8Q1tHxEL2u0c7j3YqmBR3AlGiJXIcy6LcQVt0YD5jFm + su97Lh2W+egOjVDI3B3Xq98vv8O1wszHVX04B8Qpwit7TaV6/wDjUssCsLuJrLeM/l7fxPqCB+2E49I/ + xNAHm0+gw4+Y7yP8Ki/21gqdrV4LGT3mmv1NCHqEBlIydFGBFIxk+tw/5pEEgjubxImOYe5rCRWqiz2j + sKCPOajoyvA+ZvJGs01bzQmtEVXWji4hZLzV4fHHiCrEroI+howm3saxFn9XPmJemrt+bfxGaQ3u04od + HIJ55ivFz+kybjuYf6Yj4T6hs07bQgGrSE7MtC8f7ivXNVpI2A4DOTJc5iO3r/f9J5VcyTsXKBgcMYT7 + 8Wf+A2mteKlRkVE+fRNZFzTQ1YsoeHFIq1y8RnMxQWtmAXL8IXpnhv4lpa0vmGkoBMck3PBNwu5KupvU + QSL5Ynf1i+w1IW116DdObWHmWsrKzziX4Ji06BCBoRtm8ilK0xGOiZXgPr/v4ejHzK30smJTaO/K/v8A + E/C5W8avABA6r9wPLzP4ZzQi9QLASsBx1neawJR+Oj+AuMhITsRhlixCxN4kyaT+kAj2oXRjWRi4RLbz + HOrJ26HSmrLqlPaElTZv4RHXnqvrpemniUQBvqGkpH3KzF2d/cQodx+Cpkl7q+zvGdYRP6J5IsPGgfaY + jyzv/fEgmNQ7JVaXZfVQd7eTFRuD/ZSajiE00bgMM3KnxSD8N5eFdXQPUOeZWj8M248RjBFwrMJl8OF/ + qaTSnU1zLFj2QJywM1naZYloGrB6gNo6lteCvnWKaq+SrUC6adz/AJAUwDuZ+YNKOftHNZmfyBCSx46x + o2774jVKO5H7lk2GWHgjJ6CvvrgQJcZeiof9jGP4ljIXMJ8yf7/CrhyVbs/AlylpX47/AI32/AdkSrSv + ySnr6j1/UA6MSKhJlqmQBsgTRiRI0V9wKcCMsCW+ZoTJdOHQH7iavOb5n7Hp+xPqdHn7wZqHaLukn+Zj + BsgXzcf7MNOzQbv3v7+5RDoWfzxMo3E5T+5h10HFEFUliVDvnMyfDD9CAA7CFwE9FNHigO8O4J5IwGOg + ckrTA3cfPeEgB4//AFEO/Zg9hgQpe6gR4FGp/wBiVUhrtxwODSaXjEaAulHEpHnbf1NLb8xHG6Yu81DN + koXmEMXNRenwzrC/wGUw+aZQMNcl/wATIAv6+mF71VMmMPaGoVgXj7QQxUrFTS5Xb+5kJWX76xUCBqG1 + QbLGMs3YuZLrd+DqOUBQdLSu8MOstSKIx+Lr+NjvznZB6ukHGfzMNfjXQw9n8GEwzPFPfef1AgCsTeVE + m1V4JoGo1qdyHFXqlX5lNBK1x0mlH9yaPKapo+Xpo8oaPEdGfc6O6YoVrLlepFYCv0mF63pnxuf4YdQP + cFlgK0DcjYHILDG7FFGyujxVXE9JvSeauUyBYzTpEVXZzMtIMJQcMwjXl9RbNjt34YLRgTQTcg4ZfXVs + X3O/WtScsO0VczVpPglqhwG2pLGbVZWSIteugb7jtK3iBuKP7IhkWqoyOczLBwCl+xB303g4x+40OgMK + ZJhrOAbBvKKsIa1n9StS+GA6FSoe5peUqdrQRnnSfM8qz+FRLo9aldyFTze34up+I6CFPQEK66R6V0ro + Q77kEbSzmXPUPUJVk1U9SMcCSg0szw7kALmCdKKarXouOoRgYv8AVbo7+IzCa1MaOaE/YTX89H7376fc + 9NTx0X1OnP2lSm1Ra+otV9rhbEbra7VCV11rgjRItatMpibxR9Brl6odl/SA5+Y5l+Eu0Xgy6k7lQvtD + zKd4RUUDuHriak3l+8BBFaKnD9x5wEku+0dSP5k98i7x/cTVSMUmkswnvSWKo3XWYay+DkfeGN0k3yLc + sZImVwu3wFhLAuV16+eJgHKU0/vX7gYJVuT+U7le7AeTrLB4gWiCR1vgmyzB5xKiEXgToUo5ftP+TsUP + wXen0/BbUtcBxfwDUCcQu/5ZBILpDIJo/gmIfjUog3NoNx6EOgvWLbfr6iQmGJbEf9unyWk8pSNAYFH7 + h1dauWAQTUGVNNB5h+0sTCLD/TvPMefibpj43T6ccJEBCxjhJQLIbIk3rlz/AFABaQcH+qCqsJ/vMaP9 + SXQ3L3BEYXsKCeI8oOz4P4MU/qX+omss0Kly4dBadwPK9Smd59f1Ajzu3CciAKa8Mse7JtkIbmsrRVEN + Q6ku68rCURRAfCPUaPenSJwSbq4+Jh0XoFw5e7Hn2xByY/pAPAUV+DW8oWMsVli2wUjHF61eP/YYK6qk + 8Q15v99blIZSllqtQOwHeX0tywmyxxj9zWIvLlP5IT6EZ8kFEywr4X+Zss7cwREmGr3Ygoj0T/5DKtnq + sl9pcXos09ToWaJeVWjG+s90qMPRiPtLtZi5rK/6/iFPXJubMNURg91gq83PTqNPEoV8f3GL44z9SMy8 + Doc4mTF4U6kNIaFvCsPzQmhN6lXfj3/uWkSvOItJQD6mS8xbswwei+EmHaczIYTiW14h5vqX/jDl8CHl + Z5GM18ywtNqv2TnV1snkm8WTWMeZiF2NYEpznQNKtQHfEtU132a4DkSfCNf+5uo9PwT5FCa6KGrUDvcf + +ibikr3fGZUoo5Z2rEI6zVPe35fw7LuZtq9ViiVijX8n3BKw7i2aBLe/RN3ZY1uTiAU8vaUfiEPr0TY1 + 6YQ+yHhGsIho/gINl9Ll/gmJQlyutdUuXa6nW+Y80QFmZ6heGYHF8/c6VzBXiXnb9SkNO1qoQqmisrvx + Gv5ZuufWjEoO0sjifTn3IadH6JkMa7ymjaruviDTyEp2PKGke5IwJhmi7S3dnlYwewOQAHliZ51wnoYb + onlNCjLas/Ew/wCz45imS6O374ggbWZKmCr4VR+42S+ihLOiSpeWEiDRaYOIfZP8MtG6lg+oxhhPCVnu + wnmyG0Loh2K66oCC0biw47M2BjLY8oK8v1iA7PfQFaRJrMB6zNQX7Js/Hwr5k+08XdfHWsFRKkOZak8y + JhLD4VsqlVZAZ4IirOborCA5aWynuLuYtYRC3GB7t4N6e4103uHj6hhRS9jSFwpxaz0XL6aNROZRCo/g + 4j+FShL8xu7rPmC8k8rKTToMAEWWCDpNUbdx1yrJ/wCMx2IgMa9IU3iD4ZoZq+zoo2pKqGAg0dSOXuy8 + ronenaY8Xv8ARNYHJDpgTjbjaVWzN23mXeV3GoHYDkYUBnkckKSaZZextH6H1ATLfmeEwin3NuNmgfJF + gqrYE6l1gxPbKWaTJoqLuxLkGF1cgRpJiQGNp9z/ADG55iLGJxIJoM2gE4FMtEM9jyl9z1iaML6X0HQH + lqaeYo4fYmVWsj0PMT8PY34hocHWnmATixLLlU2J87hGWD4MAR0WioV0BMkpdfa3aCglqNSOR1gd5FEo + 9eIJRuz/AGRm6ORDrrgqKrVwK0H8EhN89XrtPEbhfM9zHR6D+LLiPRUcglkxm+3/AH1SmyZe8DNgJvKp + bry1PEXKakNJUW4g+L0yDoSuRtRt01feaEEFom5ATRU0z5y1dWJt0+tNXpjSq1o7kBhd40MEO01Hli4D + hmhu/ES4tLUPiXLbNhwTHHxGtMJHL/GZBqgcxm5eOhxnCA00iGr5nlAGv7lbj9268O0pbep9QYRKEbj/ + ALM+TtQ/ma9d2szTfM2bgPeiI/ll/wDPMcx4Rmol4xPtGgTvLhW8VnWa9gZpmVZol97jKLNbPycL6Kif + Myz3r65LovxD8KKllnQmqDXLEja+Z6t+mjXuXL7MzxMz3+DUv/4PZ/Kya5oZHiZKp8H/AF14JQ5h6tZo + qPl7kY40Gx6ASfVh7eisTXdFjNtcR6fQmDmPh6OZMJAPjvD3T4TZNMtqvmNV4eRLt1H4/UR3yc/9j/5i + RjRgoId9eOiVXKaUW5lAWzmY2qPFFjiCgtRMtalp2mThZc3ZuqcMaAK52liBOSDiHQtECyNS3mUZsB0W + M1afM8OXLz1zOwH4IaRZcwCHS1Vj2JeFAc0Tdh8Czyd6oJmJTv8AwiDUqY2nR1G+/pQcpORE8JbmV3Wb + AzBvMPwPW67GMvq9auH5WEIXYGiRxWtL/v3/AANMy/HylPRJ28pvzgTRxK7n04EGYZhsAIzxGXrEjBDN + o5YPxPqddLxFXaEL9EVUA99+dRMcbpX4GZ7VMfQt+IzRkXg3l6q9OwzFaV22luusLeADuQlwKaQvst7T + TGBrI5nAnlcRsxRLphF0w9mZNZZidoCi44Qexe0pIQERnUE97tmn00b0kHbB0IzyF/v8FmvT6nUIKQvN + byugZac3HWi9oLaerArMzJGu8s0DOhMvBEpSGwY3Is89Hrscy4suP4Uqli8qluJnrfS5rB/IXDRNeZdV + NK/R79WE8JhzklNimd9ckUVeHZ6LGff9RjvDJyZgz8QRmv6j015o/E2dHofu6MgjpG/RKV9VH/GjLdZ7 + JDDGkzXsNFgIq2a6sxsXLtErUzzKBn1UFyR0cNmnMNJULNIcVzDpmN9JnjcYnFbKdcTFmG8Ra8DchkFT + 7iz3K8W4HOKho6X3hQ9e4Izvh3+CG70WcT6vUyCDTeZhn6AnIn2RqMCgmUXgpB42jXY5ibtCmmLbQZ5Q + nGgry6KNhklA77/hl4Q0hGm8XszMzzPlK7QKs9x6vQetwz1uXMy/WMOeZxhm47P99Uhc0eOI2A/1HRn0 + raMCyFiUTSzX9preJqjUPW5OY/iRge4sZld47yqEt3P6EA3/AGMrj+0AOyK1gN8lx5vEqiVOFu8w0mKy + f1MoOy5YOxXUw8DiBNk7kpgcjK1o7u/Mb+6cQ8S1LWVLtIeTF4xQODC3TVdvXRzHhgxh01LkU9yl9uty + 5noq64fNF4gLjOkKC6lhBFHMs6KZCQa3v6IWkBR01zh1TaDBDJsfsl/gFNSjq9fPS81tH8r46td5X4MN + xlOIkT9P99UmVZFE2IQvWsk0RPRvKLQ+o6wZoJPQXNQ09NLzB8xHXpU1jiOrzHSVz+1ucQ4q5oM+90yg + CWmHmgGUge2/xMlKtXr9RNtMHSayYSzuQNrpj2TUakVSNS4Ih34z/oceYF5gjCjdUA1ZX7YGtCpbzCHo + HaXfxGeRAD1KC6NZlPb/APFGHTxth7EfhedJnoEWDoLKhwJX5E1YaXW8TUzNc7nSug36Xjpv02jGazBr + FxG+IXa46VMdbrDL/GpZHWJwMq/R7dWfFKzuCHjASl9UC9dbU1zeDpM2G9zkLOJTqaTT5TQYY69M/JMD + ppMNITE0mArvNn9QswNA1U0+1/4D5h17E9r+uiPycVZXy3l8gdTL/wAmoGaDluLRZMVxErRL+YhgtbXZ + m7I4hqCrFnELZPECI8CKenjoypAw7o+Zpysp8MZqZ5DR6rsdwfhSU4hcsI8RY6ED/wCSsDoLJ8Is26uj + DT8WL3msqU00sdKguAEuHQuXHSbzUgy5fVqZRXdQCzRb6+IIBGx6OkIgu5r1KMMsy+4voUo1oFNLpfTM + SGdyGmU7QfZ0LjWEGDPiIiNT8UMhHxLnufWioeJ9BNP3HzVeoX5DeJMhNz8TtLGFte/h3gIIVMzUbvD/ + ABNhpKs0tIGugO0BvbOBXiZd+u01TXia8YRYKo3IOYDlkmMMUj6UM+Zonf4ZdOcMemzww6qm7THHQ7QY + rft0IP4XBsB3Zt3w3MJ6Oonro9sJUeXRljWs8KD+FctR5L8TLRe56Snc/Gv0ngESPUMuXnqzuSZ6XHox + LlTqFUVf5doQII5E36YHkfI/qNoL4SgpivghkhCgad5vxjL5R0jBBumutBblVr00PTpAgV5g3PqOswPi + YLXiGDx1ZWtZ2fjiaPt7diQDaHv+CUXjJz0Oh0vo6n/iO+81Zv1L/SM8SZoFLObsP56TlivR9meJujNp + 8aQ69j3LS2e5iK+hhrND0EhN+Tlx3BeMxu2+xDZK92fwluEV5gkHo6iyNA6tYNp7TuBLOqlWhDt0etSu + nhFxvcXc3jLmXRWJTLpyyzuyhsINLOgIxUqJGBayCks0f4doaQRyJvMj/wBpOiS1SnTJxK5C1j3cauHx + ABM7kfSw2giTLxQ0O6FCtuI14RZeII8nmHeJHSa1U0fE041uFbdGb6zMc3UVLIuMX/EPD6hp13/BwMoW + 1dN5rMuoODuYLYVkOwzR6V4tD2YOtjwgV2rPQ6Wu5n2lqxLTtQ3CIhvLTFGI8UnK3mf2FguF4JUpicss + nYQVegRsHMcL0eh3nQNowaRttHPS5fMv8BSLV+oomByJ3pfBPKeUModBeLedzTo6da6JEQkz2Z77z+pk + Syy0aP7dKiTKxKmzWFp14hb4g18w0ZRQjbIZlIsdn0qG3yxgWZ9iJeviZgyYmoO80fM2HeE+4503+/7n + 8/730mha95/ic8OhKm34h4hkmK+ZlL+PGAlur2JsTJntTD1oblKDzn8O4F2VwTaUcQxLvWeOmN2eCKym + PhKJg6DiUwJ2I566JbRW8oCadRgG0Vn4Eai4zHLB8xvdlLuFTlpid4BpL4Ix7TVmYjKxKMOjMw89GPSp + ZGg1DQYa/q7wTOnT9dGJErSfJAxwhSPhNVF529HRjYI5SB5/7xJUWR0Jk8Nosb6J4jljxPvT7c2p6jvP + 95msHnRM+X3/APKqaz0F7MaTFS+Z5u1GzRwvNygV3hkzD7fgV8pn4VBl9mlctqe5ZzB7RWeYi4W26GWW + ZTeBcHaJKmJeBqdddYCDKb1DqzJW0Cdgs8KlO7ARIm0ROiWVKj0qJ2KZUMzSXHM8BEp69z4nb8pfh4ic + xgwiR1yi0f6gOxuN1w9a6Gwzb+cOPIig/K8ptG8s8CJ11iiafYg1NXEdJTMNHCTL3TlqJiZ/iOvMdfqa + 3ippuPj8Lx+PYuOKHDackBSoLuWey1KPXmmJmtG5F/KeKp3vMAcdbnamBBl95ZOwltTLB8Q74Erp7mIP + iOFwO8AlNra5p1YKDCIdZW8TwiCYo0DpfS3ad0uVNUxNWunjpVbS+lS4MG9JZ7SlVqkttKvWB+FQQxmW + xfgpLP5NfV9XoaZ0mmcwjMRBU1e3ZAWKhEiqUT9k/jM346aaQfXSV8CZbppiEr4iT/yaPGps0+pnf510 + 26qlKU3uwjQYuOCquB5jpHQp5FsevYEx6XHSWHI3376Wdp4od0DKOlm7KbEYyy0IBBCFS5dymd+l9AQn + APSX0YPR16Uzz0uOeiqkmViaRI9c7wC+gXA6msq9msI/kkqMTAxqbJwzuFm5/wCOqSyIouWjcghslK3+ + RcfNrhlENSGtG01ITSJLWvZNXdiHijpmJ6fFf1MJHv0lbw/ZB02/Hz0FvHglxlEhFPLKe2W+ARUUqyaJ + 2Ic8hz1Y/wDEYh0ubV055FBJfVuQULgpTeUdLlwizSCwhBIKPI69uiM1yCR6mHtCPRet9WaR1Ro3It6S + nmMI6w6HSnI1hu+f/gkIRCmViVQP/QHVI2mViZBVMD+DmUA06GpMIfBp4SjxWVdQ94ze3mTb3F8k2smm + kcsYSP0x/uJj7zmXDjt+VdM1C5U2mj8TYlU60mDGncgodNTNa/bogemCZrm+wh0rp2IofaZgME9AOlzu + leem3iZlc9Cgy4MLmc5XA3/AUvSNpB06ohxUV/hXQjDWXmM1XNpeIy8Qldb6XTcwln/wshDMGKrsdU0d + DbbvP66MYkypZ5mi18wiT7O0CKP/AAFSwHUxDXzcrGJpK+fwKQ1NT7mN5Q2fPiBQU+Jm7+/+zL8B089M + nXUqPTxtuIMLZ+CGhNUz4v8AUME7R6do1Mk3z+FWb2YaBxMJTbr/AFlzMrvAIdpYMESZ08TgS5lpAYQB + LCZZyTRL8OYmNSK3dv10HMYyo6fho4jr106VmBMBL46EdIPRU40l1Li+4W6QUxldGAIt5cgTmXB68aB/ + 11SJEqbUV40fqGMTNoLgXsvEGGYCWg6+sq6F00E6NXzN53mRc/8AJdQ0ZiFbYjgGOY+n1ND8f100hM10 + 3ZtLyAaDpandiF9Hjxh60jmdRw6awx0PGW8y+8slCV6CG3WjdZRxNW9OgmFwk/XowCEQtXvVQWo0ovgz + PtIxF6PTKFtfw3lhmNTWpfEzxNziYpfVOiQJXRg5jAldB466whK9QpIDduA0Ol/inQavE8RAQ0v+34JB + xKsOk86MReE1JZH4IvDbzEP6gNJpcGvmBguaHmbueZ3+elbdDlnE2eJw/U0S+m0/c79GAps0hywwYMus + TEfe6xE3ONnu9TleEj0Yq/e/xDQODq6Twdo6f//aAAwDAQACAAMAAAAQPb9bB27KxKrskjg4dHO71xWx + olOokr2Gpl7xwQBigfO9isnZyHQfT1n0UyP9ndXaZipAVCOgNod2zatiJpmqaXRVSQyJixhxYu+9nWtH + zG3Kdi2Mxl8/FzfbDLTcG6Eq5Ut4pvtmqXyNXDWbkv8A/L0+9N0cIypv1Te1xk+9o+i9LXz8zhRgCFry + 8A/lO/rHlWUuY9X1TniGCe5y/Mah/Ttz75Ua0RabXZ5waUlDDZei8Y3fmuKlb3Yrm6rRmcD++eo0ydvK + LU0fXSKMR0tlqvyXt49DmfNQ9+vr5I3ZTyWDukle7kn8yjhlvrOk8Sc7L+Qi8BZOHFh/OrlZxz1hy8/z + 87w7jn4PYRHDh7vbNn4Ba3TD6qiIHROJQQ8Rc7WyE7ctY3tpzSsW9JV0c93q0zvMcK18y6pkokAuNSVn + umZ7E+Rne3gSqf5WjGWhE5ukTjA62bwvH5FMF7mkvkx29mXgKMN4tlp3bIUuvHofTbqbpLUL20+OmsKU + k8hJzZB5y8D6XhxB5MgJu/M4lHQY7vXft9bW/WALvCEHjQlsAzisTR6BCwM4zHCjWWrqD6Zmrb0JzJ4x + Wd87pg8Y6uQuHleciypX7UUAylnI897VR9Wa9zr4tAFY1+HeOCz2WVPM0Gz25/uq9GLwNR5Bea6y6d1g + m6r3erWKUnPCPOF5eLbQRaybk7ZhDhR/PG0qaaYzkx3X+/0wfkn9krGbfZMJjpa4Xgsm9zxlcZRLL46S + 7Tdty3SjY3MIvEi4R3lh19HPRSUrnpGuQaZLekzIFMNkOxfs7jJzduYmwauzHra9Ep18AEtmcnsNhlt0 + +5j/AMxRjCb5tkKXbERyxv19AQom73O0Voble+tAC4xfvxsADvWZ7t1pPAVH3ChWnX5kPIoVzbQkRn3O + wMeOCBRVWWHtY5fGiNgZJJrQSjDwU1z2FxMtj3m8WWpqQXoYRhnDok+WiHns/dWRWO57LKYcRCS6n20u + JM873+bw5KUMoN9nXp9/u6SY6Zgb6NxZbktS6qkQ7N6R5pz+UYWvm86lcNhO/I63g4eWKJ4RzziRRBqk + XWNmXZ5/TEe5WbWVKnWhzMEHtuWXltIkhR78aZN86DrGpIMZp86+BiPl+V1KjAonaiSU+nTxbgf/ADP1 + Va6N6+RD4ndhmL6b4y1Cc1NyQ5i36nek+9ViyuAQzG32Ro7/ADa4Q6FOjxPi1khRl76o98C7QjkEHGw2 + zMOhC0ZodMdBoqvE/Ocj9dGhxaWlqgM2310RJJeGJBldWUs22P1vjIgCP1kw7qOXp3skXSW+1s4mGi0z + oNv+3yXTDexxu7LUoaU03PSpBiBWNqvIlAjghcdfDnBKM5d10Vdo6ulzQOZB+JhR2J863n58vm5caD2R + GkraW0MpiVjygPVjykPkWgD+eo7S/wClw1Rdfb1E/qBvSW9rHRkef6p/kdYNwEvAhLvp1+2IARlAAqxl + FmpHhp7ChS3RNr6vmITV+n23rl33tsj8X26Kj9RtFU2Nr8nOEI/+MVC5yQD0GrHXOdxGruusZptcfPWU + suf7NR5abBOpo1eWjlWpfS/6Su/HDI06q+0RxBR49u9em+F4YvnMxiGSA4e1btnkQFochf3y6N8J5GXv + cEolacCUxxwYYs4s7+QHG2AwuglOqwsrljI+fDeheTchX6Wa3lDeXN9MLcPQRW33GsvM7xwyFDV6EwM9 + hzrqAjYAka7PjjpfocxL1JdQ9PI4NhuBgPWLqlFnyUDoG8EesP4zYllmoOsRVzsOp1+LbN0DZtaIdaN5 + MI1qMPL3u/YP6/v88tOUEt9qMHSSaxmw3YbsIYkJ3Qx1yAbfmZqJI7B+S3W+vaiKlmu0KwRVpY19yXH1 + 5lgUeFnHr0Acgu5XvUnrucculFCtNLrPoXeaFOcFUEEfeO2D3MQW7K6XCNa+W7xH9Rmo2NpUu6KualJz + qfEaDI02dcPcwFVXkdYDahKE/hms/bSp7MKvlBc0RDuQbVfvYMVsLI9uNqinyujyzl1HQB3fG4D8b6da + WL6IpXPBx9FoL/erjhmogXstkZhjsnmti/k8dj2G99zXQXlHJW8KxBD5OxR0/PeH4nSlhMKlt0aoxAuM + 3m1IyuLkeftpNieOUA+nXrUUBKK47C2zwSTvlC9w7uABDRznz1+P/wC+8cAg8Ce9iBi+8jC//d9DAf8A + nX4QwAYInvfoXvnvgvIIYnfY/PYnPv/EACARAQEBAAMBAQEBAQEBAAAAAAEAERAhMUEgUWEwcYH/2gAI + AQMBAT8Q4DkH7wv+W/5ZO7E/GC1LZ3d6rC9LS0JfA4Iw/dkge5iqRpl9SA23HLXJdXyOE9LxHspheoWH + Ui1tgjvUVi2vpP8AEq7sT1g8WWfgZZJtHPd3zvBKHvnZL1Cevkf3dXRXemQXH7H1LI9RGPcnloaTOmyv + cG2XRaOFyHqy4YnV7gVy80XqTV9s2OAmWQcltttts5J9LG3lkiEvXDZw+5Yf/KHeCB5vk6hOYWonRb3E + vpllGx/smT3BkYZJ9d2EyXkEGeRCYs4OVttt/ewy28LxtvCWf5HUsNi3gBF27EiWjZ5ysjJ2JxuaDcjw + 43jSzXSzY/BYXUW222222y2222zbbbb+dtt5yf8AJbbYeerCwsLCBYWSWeGcAIC6tm23htvG22222222 + 2222228bbzvG8ffwvOW8MzbwcDxu22w2222222222222222w+pP1h/b0OEFYMtNhd422xaW2ID1LnbAe + D8J1OHJnAU2yYFhZjy43sD1AtNbfHmll4sRHsJ5I9lmtgeX+TOPbFkv+x3yNWNtM+w53DHl1zwFSZ9uo + y9csbOru9IP2+uT1vpny87wfhunk3y8wTDnDe7eFyPhADU+kr1u/MnobaYeX0QeoHhNHSWoodQxrJh7g + LAvsjt2BEhrdgkHxtR0twyHwg+BMvsML2S2R9QBwh+YclgtvPBy8PFt2/Bnhny3vntE6jwnUjLRy7AgS + PnyEhYBt9JusqthJO1pdTpK6XlIGyu3cbYWpJkhu6uzYd8C2sjq6jRXsPsQ0ujqYf8RovE8PPiQnVkjL + beCbBh3ItLreuX9Jn+WPxwszyU/bHGL5PAg4q4dQNxk71LvYRiRkLxt2e2z/AGwdG27SGayIYZM8Etoy + F2dMgHROFoMhf9cN+cdCvEt7KvZMeTw8ZCA+WSLLP8v7ss5AT5d2NjPA9LRO5GHth8h2Qy/kc8gjPEr5 + eZLmZL0Lb2Q3tAdwIBIAfyYsBv2YCWtk0+3VyWRgGCw9QWjRhV11bvdo9XbjAPUcE8bwLbbbLxBrJ3ZZ + HGy28bzhAunljI2W2RE3UBYkjtjzbyCJp2WJ2hndqOoRxltoDIe8OAj2S3B7YZV7teto5Of9lLLy/i3q + GWQT3hbedyEztka852385ZZxnAzbHK92zYB0i8Z3RYdjBPIsPyK6llaeTsIXfBHOdTepxzB8gBsA2a2J + CxAcM4IGxBfPEeDPkDO+TG7h/aWSSRZGR28JZZY3eRPucdokL8sLYvnO3Lv9j0tyNW/I8jyGXjeBI+my + j2U2DMbe9ZJFthnG2c7Etttv5yyyyyyecbS2yyz8fOSTZP5I/LZrdvsb/YX63/jd/wBsgmBHVryyyS2G + St4+RzkWWJncMP423nLLLLLFj9vKO2TrZLo/IyhAy2YT3jW3lj73DbDb+XlCzltv/HLLLLLOX3jLrN/u + Z7THqN7YxGZA+xmywk4bD5abl/5zlAG8ZHVtsWw7MWTPPLfpseyZZf8AnA22/wDFmJ4Dq16M93WfUf8A + J40G2NJnpKg+3osl9Ws4EFY25llkNvG2222yfZPmdMZ6O5QO7OBAvUJOEcbw238LwcZx1ZG3q+4ONnk7 + t4WO4bL/ANXq/wAktInRyVe3iTSyOkdQ7znBZyceiYeyE6k26QA24yrxg7ZZMy7ttt5OWCdy7BlgZPnU + d2WNlncEwsjLScAR3iV36g8EHGSRh6tZuQj5EllrH4YgZOLDYMqwnBdnUc5PB6eSOCXj3daCQ2LHFmrT + 8smTf94YWFiDVm9wR+Fh2wiaQO6PDeMu4epeuGW2ls7gPUHO4ReoNZ+izPZiYcnt5L5+R03fRY+WF1AZ + YXXG222/lNuyG+33lBMg6EGt/F4rZ3xtklpbzlhC2i1ulh0ziWfeV6j8PnB5EnwjkP5G3gF+QkUKz/eR + 0kfJFJa9cZ3xlnB+pvO7/wCl/lnfBJtiW/2ElD1FlkGXSJMtOyRlkfh4+cZHr+QMLYvLH8j/AIEItUm3 + cEbY49cP/YW3+8LnbY52dP4z+SPBsvOR15KezB98HLw+cjo/llo4beMh5YtgmDwmdkaiGGeD2Qi6z275 + qQyNNGXv+dlqW22y5fY79mG2RZHvBNvHotkHrJfYfxgWjny38v4yLIH2c4fq+DEez7PkcGOZdl5Joz/M + eiA/jBkbf7ITC0dXdm+wZxkRwTx3Z1QLpvUkrgvE6m89nH+oY/8AHZ4ycsvk4TYUZS9yxwYs6gey7zrf + dG6dsuKc6xxll02WcZ+CPODkIsbsHgOvLotnuPd4P3s87xsmzHfCXajXfAcj3hvGX8kp0XhkYQ8HGWco + 8DL+RfOCbYI/qfFsvtZPTwNsttvI85tj3yidkLDMx3w8PGHG2xHBw8vLx85Dip+fGOMujh8/W/gee3tj + 2cv0Xwbpv8jh4fxkkcDxuvGwzHkHJ852e4n3g4y1iH22bD448bZeMjvjYt/BzL6nLBz2G2/2Xhjny3ZL + ILDjI4Yj29cPOXRHsW2R8hL+l7bY4DRPUsExLbnBbbanJ7Jfz5TY1QnOz+RlgOGz9CYn3gOrbVu7WC+X + R5DwursQ7tkRMTBxnnLsseRtsjhC+hzkmecT7w8h+DhmJ4WODHsxbllnDl9h5GGPGxq6M85yPA8jxlk8 + LM5foj+oSfy/jJeM2yTuI8siyJ9tu5HkmZLo2SWOw0BwWfj7wRZZbbxknGmcpDksTZwFkHLZy+8Z1x84 + PZhbFs4OHt35sDxYmGk8aGoKyG2238bENtn5yN7kx5SOo7glsng/D5bw8PnHzg4zjJhOWu2rJsux3Zhj + wsngZ/5EcZFnITykdR5PD5ETwz5wcE8MR5x//8QAIREAAwADAQEBAQEBAQEAAAAAAAERECExQVEgYXGB + oZH/2gAIAQIBAT8Qwh4ToF009E+k8bhwS3B1wWFLICBRBh7URojtwVqicE0Q3WKnUxUFtBOzrCNmKeg5 + M38FXZSTpvwi6CKb6m1oK3DhRtA8FWSlEKispo1majGiKPtCNMMRZSTibs0xpMXohPfBHCmEhojRiozr + HxFEZLQlBtt1mw2osqQHh6CNThuFmulo/wBfj0MUpcT81rh/QoyZkoJlMZLB2heGwsJujRcO5UJv6S4x + 0RgtD3e+DiU14biqdQxtioJaGz0aen0ZHwriQ2Y/sjPXhrEIQhMIQhCEIQhBIexI0E4M2IejcoJsbbNm + xPRuTEbtjaxp4JIeITdMVpilFHRpdFfwT+Cvo8VC0KKzYkQhMTBIhCExCYhBIhCEwxdG2KUShBohCCNi + bNlKUoTFFxSjbNkIQhMkEIQhBCCEIQhCEITE/Ew+HQ3sSwsLD/CTxM/4QhCYhCEIQghCEIJEGjkhfMXx + E96QneDQq0QcYr8oQoafQm0Q004xjZ1lPYnqjK8FtxWaRETQmVnCyrDaPjQvJ6QmLg7IRuxjEJFQnrC2 + BJUe50CEKGNBBK/SO6cYpODU9Mb30ZVi/Q4RlMOrDZnSIvnhK7D1gh4SkSOqPsYxcefUI9JrRRsYzwSj + 04comGPoGUKzTIzGiFuicBwmXYxz2xDSinguIhoxSdeGyagoPohvIW0uqFYUcMsicIz6G+GxojcJQEGb + NuR/MbvBEwyTejoe9HR5hnwfwQofclcLC0iXlStA1tTf+C+gKthNtsYyCs2QGkNyDG4xoixGjVEqIXhi + RhYzxrsVcEsuItln9MFxtiRohIXwSqOSDaGdKD8I72OKlNDYNNbGejHpY/08I1ikE2IxpwbZHXojOBrX + DFsY/qNesQTXSHNUNbYkMVCY3YXNMdaN08QbN1MV1pm6DOVTTwpprB1cQ4yTZdSf/wAJ0vBBCCqNmxWY + kUbkHpDkuKjHt8JbQhJMgtOMJ7w8N6OGeRVK+l30/wClzTKE6Ey9K+jd6yL6a+lS4LDp0oL0Iyo2twfN + ibQgNGzEarRidpAst6IbQeujW2xC2JfR7aHNTT/B2caRvsWoOdiGvRhjYQtNETTTEtaOJpnIhj3x4Ifc + eHBCDVJBCcY2XQ8OGhrYliEOFeF+vFJ6VPmGsNG7j/BtiJM1GNU3Yj0cBosNTpoiGgkhahBSr03Uh6KY + 3B6tzRLxEyw5Bdz09CJhm+ybJoS0WW2T9IekR7iUgv6OcIQhM0rJU8PCISEiD6MS1SUQ4rCT6J9PQhy2 + F9iGpRCNItimahZhIL7m+oYfuCYyhsrFWJvBs1hdjRTKkEibEtj7iw0yEzBFExCMv+4g+nEUqHOiNjWs + WCRE0ENrLzL6ODQnEcZFGOMTdGt0ghw2NEqNrpsKobUVQtCG8X8QhCDQ1msrKJ4V9Nuo0f8ASEN4hFil + RXjzKdQmuNmrs1eDa8R/gi8Rf4f4sm5/odelRcFIo2cio4T8UZRMLCDT/EJispaaE/6Q9xVv0hCEOYfM + 0kOkMbLSsrKb8IdE6NGjZ/YSPg1DpqkRCDQheWJpqIf9EroamZ+diFxPw8T9JlLjWX3Gx9QNUgR8gqtN + nMgmhtF2NXtilBpWJQhcI+CXzDZdKlELpYWzgvoklQ15hz8MYYoM0CGMmqPWiCRP1CfnzHuE0OziU1Io + JEYz38+5swmT0QoKmw4JUcKCTb0MStDhUnwpCTFw0QQhiyQex1CbFWQrsENQhCDX4hB4WHOhTKiRQtoe + Pf1fBLO1+H/pOSfBOls2xj1oYvZsdDTWylKyUjWGtYQxDTNloSg3DYLSFNmunzCTQbmCR4hPwxIWOhsJ + O06mejLvQyFG9FHwTKRsUxsZJG5TWBvZDmrPS4JjZoSrmFZ0X8P9EMaEQ50R4UbN6LotHoNqNKjxYJtM + TH9i2ss/ohDVGcm2g1sjo24Wc4z6J9FEOIjxFeIp9ExQ9Uq0hvhUJYTEm3oqx9G6o0fwWdFPBNkTIJaH + zZcJwtIaE6eiCjGUHWCHwtGxDFpZY+ZS0NiVCk7YUV/RhWbIQhP0oHHwfWKDQiiZOofZj1ti/gk2J4Nn + TmCfBLNGGmyi2J1QSl0ZVBK9eiWE+/t8EP6FH+FJUR/CfRtLrI9Y0ejX4P5Q2+D8hI6xeQSlQnBpMkKU + 8KNoa9MTTNi0NejZTTNot6R4NMSZB6GJj2tGw0qHNGMthPz7h8EV8OmLlsmg79LdYyCX4Twx7i0qEaY1 + MPmGGLGQ6OKKJUZYmq0cE0yPw/oqgkNXlCZI2bxH+Ma/l7jwiY3E8+Y6JRFOjFzHFI8IeHuLWo2J3THA + 1rLguxjbE2iSB30P0s3SUGSemJtCT0dbQmWjTKIeijIOCDpaIw/h6LD7jfo9dEEmfyKxkCRMXCbGiEw1 + MPfRHj6DpaGtiCShBi4WoxqS0Ek1ovvQTcDVUrF9EM3wf2S8F2MYehqfyOsgkM9Fz8aHrgaPCha7Y1EJ + UJFwYiCwxPEJijn0LxTg0mP6EvcPC+Ye2burBxObI4Jdm0s0TP7ImNkOvCfpi/C3QzVDbhQvgkEciULE + JhogsynCib2QtI8JjjQ2RNjEf0tWOBnp6FLrHtRjssdYyZTIieFQmsNsWGI8YuY68Wl/MkUbwotrDEqL + Bo0QeKLW0RTNqg3QxIeIJayX9LC3CWGMWKsJndHPw+Zk2a/jcdh7AlUW8JmYaJlomEy4cDyvortCQ+lK + LgxM8ExMomhoaENEzBPZejF3Dy2uMRpWcCQ89xuoshfMLMw9DeGJUahd4Ta2hSR4YoGj4NQh4TWEzSiP + h4bKNoTJhDGLuPc1E3EhHYZ6otwNNIhmII2EqdDYiUgtiGhohLo1NMNNout5JwgcYQ1oSi/Pp6PM/CKN + 5Wt4oj4ibYsoOiGzbZBDbTR0aoSofwWhxogs6ZSlJhsamGJlNPNLdEzwpcN5SmL8EIpwqx4M4Fw4fWHG + hQc4fY5Mbo6EqSQhtDVLIKaEnRExGIRMJjexrR/pSwTLhbT/AAn9PVDQijxSspPwxiRdDwQwmsNs0NJH + GhNlcgwioww8cGSQZp1iQVmETFEqc0dw0nwmGxh3GJ3KCLgahCYYlhkEUuF3L7jgWOkEigmj/Cm4hNVg + 3bYmDxiYxzQNB4bEhDxwWhkGvRPLKJhicYnd5TGLC4Yvp0fMIRCaJvHg+4fghiaLvCVEoUNbIuC6tFEN + GHQaphaGZR4WX+HweGy7GyiY9oQ8Ue+jWHh6/RD7n3D7h8Fw/8QAJxABAAICAQQCAgMBAQEAAAAAAQAR + ITFBUWFxgZGhscHR4fAQ8SD/2gAIAQEAAT8QFDcKcpK1rvLZoXVbjc3drX/iZY91Lcv1YIIHpN4gNjPm + Y5B1ioHvSSzHtdLPqEQI7YgsRbWmZZDsJfxFxXzOjGqHmmmEoNVH1GK5llN0QtSURTsuoKLuPMVUpkNq + v/XHC6tC6lgAc6gSyEUVqZCVW6Uvco0BMIwl5TTOBX4jVWvci7dqVd1G7bd1TAITOJYeqmrcEQFWF7wD + 0QcGLjbAYpiG1YQhpKmErwGtxoPYw/LMnZ7EhFrG8dY0FBN+mXqzb8R6pqFqsB8ws9Sqq79REe5HTkZP + 9+oxYRDBaw2uFVab5YaD2FpqLPAUIiPEdTY9uLm8rGruYqvL0hzhxKHaafE5vCmc5r/yKi7u4HCX8kLF + YN1D2w9wdGzGZrRpFkaaNuIj0AJaMdR7ggWW2LEtexglvcYJsuixDcFREUVF/o8EbCQFmzotfqJGOQDI + mqNHSdTWQCroouNdtKKoFYV25+pf5Y/RBNEHYvLrHFQASsdoOijofqGKBZpm/cb6lXAAv6mLqNTOSgge + WYMoKAYCr3in0L+hLE+T+Wj8Q4G0CoFWSmyy6YYKhNGz8TSeuyfoLMSa3+IBovbcA+rG89bNlvLEMlP/ + ACKadwe0HxK4I5DTDSpOMImYB8xpaLrg/UUvsbIavrkPkTCx+KubQnkqD5R2f+XBrbQIyr6v+dVqvkqV + HrUdavrEAx2gGhvm6ljHYLD25hRCnVj8ZlDaZPiIBd0u+YkWeII6JboVbVJFXhsZCfZM5bjNJ7iw6Xpa + +YetqPNdXbxlmEquz3Dp3hxNFLQa/mCKeeMkvz3xmUzAGG5T0XozItlWCy7WzlJ9RLBvPCenMaCpzjLA + KNHMcoeUylmr4bhllQo8PHmADYhss9IkQHWefMIjk7QgiDtrmMKukUSviGDy6Sx5SAF5lXBghwQGOhCF + oZ2s5P8AEL6uAKK6DXuG7IL24fuZdC0fhhZmgdhf6g2wLn0191C0LFm00X8YmS5dxOW9Iu8vSO7DZPLa + AUe1Wv7hRGTWcys2s2zI3nvW4FQuKjOKzw1VxDIoAg2gz3xCxUbEDk/J9Tdiol4sxggtDnYXUVxgJMFF + lKDbW3tctDT2x5ZdKAIWij9TALgQobujUbo7SuyVGgtC581E92UBkBpreagHTVrgQBfTbGJSmgKAuJAR + tm22F8wcUVwAtC3q6mRLVez6EBC/iK+0QBFwH4PUxzKi9ufs/qPFMKuk+ARoaRs+1M7SOH8Jm1cDNn2C + Ppf6DcMq6OhBKRcWxTXlsx5p9gVD818sRy57zUZMtb3nH5t6QfXEt1q4btrPv3jfiMWerBsWvnEcHJ5h + y05LIxlZP+cQoynYZdmGb/4h2D6jtfFH8IKGwDsuGs5YAAYP+BZ19uw1ZV9CJQPSJSlPMvVLVUXUBjcK + n3/7KbvAmVhRyUnNRyiQVPEVq0waqd4lM7liOkQcvJEC7TpiWXAJ64f7m8mQ7nOEhfNhUUpyDr+5cqKc + 5wF/DKMOucNktcxwGGKUuvlhcw4OSy9TIttCV1XXPiVdFWjnPSOQtC9fUPyDvzC0zvWGDitHeck+6lS3 + Ci1euIkFVqbWL6yuFs7eBCXTQnS6WWLLNpQ1vdQpMJvcS/JLDp3iHy6B3gQlzy7+iMlS8XUMxXwbr7XK + Sshu8uZRVbowWhL+4756z9S217V7ZdXhXYiZormyGRQS2tFRRqn6JWApBQi5DWTR5Xf+4h1EyzhSs+CM + oUrMhAEeW36gpl5YeZtPxeSW/FyozGwybh+1wz8sQL7xWoqDYIpEu6z/ALMQK+iJW64jM0YXS4BTR3W2 + uxDMKq9y4z8R02tq1SvV+IAGA0P42wKHluhXNSsQIK2kNtv3Kc7XUDO6RLoOFM3jB+4+YDbV9ZVKxzyt + fBDGFAZuPJldA6GnwYmS2jvqZcnZE37eG49ix6gtWOrc71eCWnp3M2ryx+p4nvUFjDXeXBdfMGy00z2J + Q/ubxatZh0mWv/ZaNCGG/wCpR1bviUrxdQQchcOA1EXd5lb8wx7cw3Zu7iGTTvuN0j0ZECCl5/hg+30W + mCJZm/8A4ZV0kC+7DU5lQrxPwf3BHPNXN3fOdTc7rpCLoqyb2Qxx9eoOHDndkzhw5x3nIMPW55X6l7aa + 9x2hLJuBnTWSBGGxG8jKurFmdhlIbtEqiq5u5dQXD4gopv32mQ5JXGyCoGrPhhKPIRAf5I9ARTJF1C5v + vDJ0DfTxGjUQbdkOrgOXMycFgqNwQIjwjiLAuWCrBRrCduxFMCZVLAvk/qOJ0jvastYartBvzrfmogKT + DDgFJZdavHmUNWiz4lEOjQR6l6llk4SOA4UGoZgSt1s4r14jshed4l39wRbOUyGNpftMRS5xRKTX1FG0 + 5mb04NcYGXVu6vPeEi4DnCftMkCNrgHil8XCjBQWvf8AuHZqIRV964jIWlZ5m42bliEwDw+bjoA8y/EF + 4Wn1Hyi4goqU0fTK4VzARvYMCHuPRQ3hfqYyxvB/MRuwM6PgjWpoVnMKAAOgQHGrqkxZK72y2pdgQxv8 + mKsF3qFNIHTE5eeFlIo9MsUtzmD6Oty6K5tq+m5Y9V7sCZws7C4sVevEsMGT7iW6oJ5Ne4FVasC4uA6e + ooPfrxMORgA68zLhT8S04UBmiCbTMOrTpuAq24GHSzKGorOrO8pgvLAndEMkQxTGDthyTDCd4qMx5YYI + 6zEdSwK+rhr/AJrKgX5CLy/uWRaYmemoSHUjNCD0fiBQFtVMZ4F7wkCM2X06SrE0RGVblTraMTJA5Jeu + SGNxFzsazDgcVzcCuzUvAq5TVVI0GoNAKo4Ej8ylZpq4AlLDNRparsNypZngfcAIUxnUq8D04mw15Kr+ + o0+hLClXnHxL9cFJR579ME1k9fu7rbAr6zY4fM5Iega7T9wAUAhSg1mu0QUKinHMSOcbl+RL5iNnIuJX + kEtUajO8CbrHGoY9yyZdNdoPzjXUjQ5OZXy28KlAO0yN6+ELSACtlun5lDrABLF5WDEuMcvI71gr7lUX + DQG/dtQ0e192WNj+pny0TUXGj/YiUlWTHmpbYydEAMgcFw30XAOMNwKsC2bneDLCalcLPCuFOX5k+APu + BZ7aBPm7/cCEHIuvkH1KQU6n81CMc6NJhcDVuBY6GHzGKEbyXW2fArDMUnNUxB+A/uB3fwpANvWaDEam + 0hR6S5p86hY+FzbCgNwTDxBVlXNMmB38ww68yzyEesXKVguOkLOG+SC8AdWKjYT0pesp9w8jAVQHeoBr + 1MuqmZmk+cH0z0mTiv5h45+oGv3AswX6hjrMKvqYn9QHaZ6Snp3lNzUI9yhZgXKKFq7xz3lziYjYHGrt + ge1j6loX/wCxTvxKa1H04u3t2l2xaVtiA2G9X6lUhFKnToPGoySI0mHoJFbbep0ipMdWPfUDtdHe4JXE + QUEYMZZuFNHPuLXyc3iLZm+ofPuJUCxuteswrbxyY4io1gVVQph8/wBQlUtHB/MxobFZNW94AtBvALlb + 2UwGQ4jcKtTrxVxF20DQevKvrqw3OrdC2Nw4Yigllc+CNfvIN1jMtwKtfgvzCIGlCa685jqXIVwtiw5r + PuWNeJcNUASN8fcHrUUZa1O1Rqu0N6bbiNtFxubxKYKhBvMvZ0oFkrfmCjhBybUNYrLnknV3Cy05eTNA + L7lNMCr3b01An3G2BltCAEUTZGjV3y8YblHg3i6dtEyrukO/zcDFk6L8QAM6HgrBbmFKRKZqqBuDXAh3 + B9iAwbuoe0r0IZn9rlta9xE2whFjugDNMLVfSA6yv9crHSOdnuO+p0YM8ZxOl/Mv4a8QBo3xBJgbljuL + 1l2zFmbCDlPZLcr1gatv5gODEAEEGTlNwdYPqCTBUQGGWmMQp/tQNwodZXQYDigmWPcMiFmVJTx7gTHX + rK843KZrUrNErP3UDrB19SjA4q8saoxuoZAKfqMNjnltYMoEuwTvMH34ofMoQJ2DZZjHbzLqs/LLObz9 + RMvaTzDtCyo2BQprB9V2INQYcv6JhVbaYfnU1gUtr3mpXdcIU9jTFDdDTQJ44mxEVZPubYPUsZB6ZkM0 + eJjqz5mgI+4aGzGyCsEndvUJxOmApQZncFjY3uMG5o+JarexiGUsqTFG4Mw2wNAiLOqEbS7yJdn9SiwB + 4IvVl4KHzAt57v8AlLT4rOg7PJ21Kn0LwY6HiAtGAs8l9SJZ+9gZvzFFkbbLj0ZTygA+X7hdApolIQF7 + y9kDLJDsaj2ggULYJuFO+sFBortqpbpXaVE1cAcE3jmIA17aQOb8QzQaLpXRYZMvzFy8KC1WacteYH8r + +AlEuHJd87mF0NDcSpc4MQ2pOFYd+wj7meMS7CktPPT/AHSFKRmhLGW3vvFOTUs9XtGmxJY6lDsIdy+0 + Lrt+Yi8e2dQKiOD6itF8QhQ686ghlXHDnEPuDxEPRShNygqNH4gNUQqazBGsEOrUOuedMp5YGKHcL6Os + EzRmCBcOiBmXUBKM7bgHSyVi5QahjrCptDNSt1kgY1CzzBnNkLH3C3aoKztLHWHZHXBHVjMrimCZZeWX + TWF+iiVNCDFJigvblPiotHflmzr2eJhrY96ZpF4CkNYZ6xLZ7u4MZvJcAoDxHtB2hqt84WACq+aZgUL7 + xn2VTp7zFfYGOST8xRYuFqatvNx+5zZf5zLG1ecDUHoTY0eGYBatWj+Zsh9YX8kWzRXhPQynvkuoepYZ + 1uLL0D9G4khh3Q+qi1vtNuztC81psqJqERog+eHxBsTVWtuKFuhulFqLWrQTvjcR0gF+/c74hInnqrrT + XFmYl4Blgu/ECxQ1OsBeEUPGeIVhHqEYD7EsGinbSn9zdB7YPfnxL2x4XLAelouV0TGMkHFjFAqN59+B + M2peYFzCXZcdFGZtO5TkV5lgUBMfmO6SUYa+CcYDA3gb8RTtnIDG6aIJeBUaYCoDKoE7lb7yol56weB2 + h0CaJWJywVNquVe4x4DDdKdoAunAPbACjNMDWHHiZsR0slP5ubZmg4lGBqFDvBxuA0IHS58XAxBnvKaw + CS2yWcy+GfzL98y1c/EV4/uC2HaWIOXYdUZB2gOIboENdQF1BUhAASglkPEyr8EYQSaDpaH/AAFmhF+p + YhS42NnPuZHiOZAqXeSBKGvuCDLGqidJW+ZSJ1Z7yja+IDjWmLDWuKigqo56xcQW0rPaZAxzc5K1qOm6 + 69Ze8LvluIUUHE1XWq44A9o1Hezlp4G0oRSuuoRyuLyGbxkYFF7Ja95IGpXy/USoXnUIeqZLFKbAqmy4 + N7o0tjSrzohgrb7BD6F8gg3+H4l+QNOBm081bRCmD5bljUXVaS/zB0EXee6rLIo33TlGXoxAXHuNGTvE + vqiDtmxpuF1ELv7w4CPSbMEytZ1Fg3li1i3y4xE4pL3Vbh4QjuFgfDGY6hdOT8xftL1ojdXMEXs6xozw + E28EHbEAiE14hJUya6DbEbXd5gjOoP5ir7w6GLh0mFeobQ/udFLWj0QhmD6w5KSs0sJA1jcoZgfBOxKU + YgOkw8EPENSz3H7l4/571LxxiGeEjsDErqieS/4eeQocNj9xNSWeaz/yu9tXlxMMbtLLD6IYuxu5g29Z + 0xAS5jnvAz1f+K7q4jkLjxBR23FLinHKLxTt2lw1aplK4rzHrVnM2GrZUoaZsRealw/UoGCtRbomxTXE + aZHPMuGsQWkmRnCBxY7iO02hOCwQa2q7g3lnrFR0VS/SUHT3NA/U5lEaURs4jBRJw7JHMgy0csyA8jKX + iPCPYjl34mS/npAJzfEtAoD1iIV8k0KGLbX+IRmAZmDaHEqsbjNJn0hjWoALpozBtChTrT+4ldZeskFx + OKiXUJiYhV8QOMxrOsNQW3HULhwf8boAEeh9SlUEQOIbySnBEvPuUniGp9MWLidyDZ3qOF5g4xGblsuc + 9YQwSqeYZ1+InaW75gmPwmvE7U5mYCDJEG0Pc0/4I9r31Zr6nb1PqWKpdv3FaVio0Joj44uE1BjHEEGq + lb8RaxMbgZr88Tu1MHHS/wDjWOnaDEphWbqD5gMFf3D5hbmVnCwU2vqbZrOGYpybxCJklEzXmUrBOwS4 + wb+YgwVYndgLrC7UqpReoPcwnMq4eG4duOY5NZnUGYFbh4xhmKumvEVQUDggAsOM2SgVvpHtIrpicNQS + 3TfiGjKNcXBNxR0aloZlMToCW9oLAyi9MelAsyN6ULMFYNl32/AQAK+k0UfU1+ZWm5t/Md94PPSHylxV + 0Rk2B0yUSueW0+0VmIwsl3L4iGxOlkUloOpP3FrB9gfct30SEHksWHuNQbBd0URqRSm6FovXMtbGBkNJ + XVRNalOISA8QG5S/Uo+JXaUdO8dwZ7y/Uxf8c2pQV/zaO4GhHax93NP+cEbVPBV/f3BRXBKxFbvp8Swg + gVekowmVZLGsemWebPmWUt0GYv8AbuCVqu0Czh1CxHCY3c6sdJX5ihuXrWIbcuk6SmOkdx02zG0jkIyZ + m02gdljEy2Xgu5hHXylU7DhK9hnefidn/wAi8Qo6jC/UWouLhkS3xD3F/wCSv/krDuiuDUB4Y3WrmAyW + RLQ2rNWJTpKOhUINRFveAvULCC3pAldpQFOUlMphySqw+MeVx4cGPevCxYRR/QiNpYOkYTolhHll3/kq + cwEaNSqNC4Lu8/UeBxSl5u7PxArGOW/7nOQcN/MRox7p/EEGnV3QfiYfIdW+UGs+9F/cTFqzPJ9xVkFa + RZwBRhVv4hpLoLZlAg8WhhLQrwoU7vVwW1Ab2yH6hhlJe7KjhsuVys3AsFWMy+h+INbwaLlkJ9bBMyIG + aH/G4xp/F4UW07N+pmgnZv4gKiRyE/LH4T1AfmXN4WCpZcJmqFtNr7jAOwpNl26Jk75JYKhVf8MEu2AV + ylfRDUZq9l72v6CGpkaLuWw5rcJJVh6mOEq2sXvUsp+lymAj7zOIeLKzEkW0T9JSMkOJiYa0wExHZEA/ + WTVS8CHi0JaIwMdl5FzJPz2iHIZNuB2Tu4h/pLq4CFDgQmcjbeJYVgpEyLNg1YPaUKCihNwwvhQqmejq + OhpUzDyQKYYvARE63C5uVtCTrRcszgCg3k7p9dIrojurA+GG7/CG+xLsaOQdn1GDQqyDfN4f3E8Lo1RI + pdj4+aBZEuECjqS7oL3cfiNGsqoIjSVDNmvMwVeY1VkxkwGROHwRXd6/wQcO0aT9TwXl/iN1aCkFWuO5 + 8x4VBuGzVnZ+IF8LEFZzC1zMbxMucS695s+5ZBhVd4LcHrHSUqE2LK9JeoAVGnYH9xdB1fo0NY8xLfXA + m5oU6lYsWn7D9y+Ht1hfqBq0ur/iTk7AqzzypSFVwQrso2hfuXdIqV2Ju7dags0c4VnT7l27/QAfcJ0x + qM7j9IECOh/EcyxzSfrU6sFSw5zzmPDrKDDOu2u4bDIB1wgFpB0WOsqhA8n9RlcGawKG1+ZVuyYQC2ju + 6ljVR4t93NNnfSjZxXpbHxGTbOoB+CXDLvofuGovnFX3FKLq6+JySxELZd2f2lXtBb9QRU9rdsSwLqv/ + AKSxKErRn9sUuR4EZdWbyB+ekGIdYKQfUKy3XKfuUzz9lBAr9MMVNrni4UNzOVZMMvRcuhQs3el18QDY + OTfaXA8Mz6P5hFoynbibLx54hLnAmO8Esem4aupoUuFLOUUgd6U+GVlwX8MILhfJEXGphjcbwnTMJacN + bzC+RvzB7PuYKtr8RxDgU+/98xrjetVuKq3lillJaF4jAT0bIQXhGDUsZy78ysmlnLzDaOHT2jQnTEQ7 + w1fMYO3SCDGv+KpQXsvcppcTJawD8RBCQDZmG5jWVwirf9cwVpjZe+8DA0KDR2+Mwyw1/rUcxtqD+cQQ + aQkLeMm5Y17F40XHEuFQPLUdirBUCtVUDRKrB/UsIsXDBByiXtRVc9TFRJxh4o/cFQE9sEQolFcELfNB + v/NwFt6Gv9XDt3sKsg65x9y87V4XF1Rdaj9EuItN4BjXYO0eNxlmGqlF77wy6EjQRO25Zl7rZ+4sbXIL + 95lS1R0t/MUs7EbemYiJzYqLq/pBSQZ7ploV6fqAlvLAyOeCqlojPF39RzIbXh/Qhfr2dOJLIMgP+WIG + KXF5pl5A12r/ADAVoGzALl4q2KCAlSUCvoRHALAbBKDyD7IgmjFO8Wr13Ls3/v3AqtuvEweDyW+DMD6e + wQuVbgy3xuKGrfESgGOc1HGRXdhGATkM1mOcIbV+JQxiGnaxFNbCurVv7YYl6vEMCjLS9v8AiFgtRgU4 + BN9IOsYUARhYOr0x0H8fpBDKLMg7+GY9vBy7/wA6wGIkzlPysYaCgj3CzfuN+jmZThIqzFozjXiaGC3A + XuNem05hhPhFhMANNLCvUU6dNiMutVLVeDT0bRemz7H9TJxAnJCEbpFW84ldSgwHAH5loAKtrljqPoRD + 2v8Ar/hkbu5gu0FnyqzF+Reuo03SKm4EdnGXPxDKuhnhlODZddLi5tOCQs84ECShDcqijenCHhHCBGab + puBfXAfcGgm0aNuQeuIt6MdOekSjI/LFi4xv3CM7s6qPVq61eLYSq6SnrDSKjrJA0mXdYuUHuQyup4ys + yrK8Kr/dJpnLF0PIIyiMDHfH1uA6EA6N+oZQBaivqoUV1S3zMtgwvsxqAIKlG2mUUK1qCo2hURBQHYAn + fAw0bkXIqOkZQru7GOsLLxDwY6xm2UimFp8dZUBV8vGcw001ligaDviJeskRYwo3QzAJaww4lPHCHZW1 + 7RsRtArEB36wnOtI0jf8pSAk3n7ixuau7MQtqC+FS6W5csqFX6Dy2r20gRL0GnL21BZjRyW9bY3TulXi + +m5YWha2OeKxL4t6QQLx7whaJnp0p+4qnN1vwCGGPedRC80Z5JtAvmMVWK2cMS069iioLaRw07lCq2vw + 3ntDdXkgMdu+o1ZDZWjQz0AepVva/ErWGnZpxHDxKIjYro71KWjEKhL3zMKgDL6g4Vay80zXAhPFGMXv + SXEU8AP4jS90lP4h49WY/NRNxAtpVTHBzikwVaedR3KsMmBV6e41lgWPUavtUfm2AW+bqu37laGIO27Y + 0KVEZl0PiWgcnbiBwu+0aX3LTWJau7OOWZ1o/NRF8ubjS1o6Y7rXzWYgZBDNGXMwkrWEM+5Wa90MYXi+ + CNTnAMK40BqHoazXQv8AcWGeogLQtcRWq1HU7kfwIvKM5+f3/wAQh1CXVx31K26Ordy61u2W3ZEAXOMR + 7G3AjtEhe6idbF8ZIJg5tMudy1ONM+GYwaSYYjmwxQBpoqo9RwdIeNTV1i14GVpeyya7+YLYIHsZcWlf + qIFq7a5lRuP4RM5xKA2XDvRiKmWMwN5sJTE+2gBverHGJsqcHI2WbbDriYeOJ1df+MmgzHftL6mRlTxw + p1YBdl7Q5YAUs4ooDx/cNA1VNmj8ww7a67hl563Rf6lDsNbArhCCqhmMHDcQkkWQpdc7PGoEDTQsWnCV + slHE5Yio2gXOPIipJUgUNh8S5VmFNK3nMJArIrHNx3lHhUwrW0ZgLTzjYWFckVbAIce++P6hG6HXTdl2 + RNJrJGwi2nDKlesrCtPTrNeJBbmFj8o8YulGR5p+IG3yrTKWNYBlsYrmq9Qboxuv4g9B0xjSCEmpbLRv + feBoWdHFfcfzFuWDnWWFl52xm1X4mUy+OXUK0J6Q1hVOOfMTwguA2gy4w59RzWwog2oKovgfMoavSbWu + thRm/hiwRXUo+jUTMcJZP8+yHXpYbqgK+fzEA4Bu/UervXCi8rfL+ImR4Dn3AVZQZhvSOmOXK7hKpxvm + HK9a7ZljlaUKLbdAd7Jj70LROjjOHOdwEIBUI0oHjnG2UNPUh0V74+otH2p0DPygA3Sc2cUSsH3LPXYT + VabgukAA13uahEoXxDOa0Lex8RqGs7f90hQoHPU1CmC8tkFW+YlwKttXKNBvHIagcNV4HEXgCyaz18ET + UN82h+YnqAtTzcogfPLn7mIbwcWhANHxWixHFIvlcA2DOG69VYcENQNnGabh2UkKVFRV7v4R7e/Kcfqc + 3DMqEbmutOvtjJNpc+S/+IbsYe8fud2C/wDlaNJAtTFarcpY5N9GVQY9bNcQ5HI09Ixs0vGIhKSmCc83 + UZVii46kbphfKS5bwiWVmpS7LrvhmjniIIBvjjcFXf3GBgHp1igavazqWHCGk1/Ut7bCDXDLM05vBLkG + acIO8kLIvTKYlOSFdsMbdNzWSMtWw7h/6JfOXzL0pRHd6S5vB4jlxUqYxbLf/QQZ63nEXZfBtemJuyLD + 5zAZElhbqVVLM7SZL8wFmSWyBv4nRqcqANvls9RvLMHBq3J1/uFQjQgs73w94oK0fpHYXlaxyIY/3WJQ + WVOqCOqrnIUvJFQrll1k+s/cGWfLCL6RW8QjZ3/jKBUGyW1W4TALzGauWLWdccNLZgLElXzVzfPSMhwA + guxb80+pcF1FGK+rKvkhhFKFTShDhttxGEpUw8s5+gb3aK4IbWtFRAKVoND61NyxmuEW181mYt9dGRwZ + H/blMr2uVFV8xkyqWHTULVdNlGAJdXNuyV8RLkblKADYzAfbOQ0G2WbzipRAfIywlTBNLQS/H+IGU7Is + AoE4bULnMu8lseb/AKiax5104j2Yi2zUAO12eRgYCcKRhfZ9XGTdub32hLBL/mMSxRdOe8WyFDdCFlDi + repaOsb4GA5S21aOcVx6hLMregwF/wBQF9YKIltrqrowYj6ngrlUqvTQ9NS7a9VDBAeF+XpE8OrViwzW + qC6rtLgqzT8yzmzIzTlD9xSsynetw5LFwGz5lqVYGnsxDXS4UWL7EA0C+tQA3Qc6uWEQCzPFQatWadI5 + jrBto3Nl1XXT5iNmypxbtRXoVElAoyKhPKvFd45npxexpByb6Yhb/hFn2rNyrKmPxjn3AXXINxtBxq66 + xRaQUwc9osuBjqNSxils9t/uWYmQ6rCRq7YMl1bAENaPWIkoIVKDnOZtTA3GU70PqZ5ZvqQUPPmHMQHD + EqCVO0qhYY30mwvkjBaF4rMr6ps6ahFNivVy3KXW/MwfWJs0aCrPuUCUeSVYusjtTFji91AryJntEsFp + 7mQHqXAQaES/EqJ3hwzMFaaqJYc3V1ntKRM3im9Mz4Z3dkhs9U+QmH/Gv2Ue94PcMOnMyTq98DYnpBdV + KQoDP3EgoYFrdH7uN6CzgLvLxgiPC6CLM3WKzzMN0jKu8GAeCPo7HXn3DnmYvSQ1v05HUAlspyuohK1A + TR17xka3umQNV36SsjL9S1/hiMqPJaF0UtR4c/DL8gcZAfJBvq4p4UQxEkNEMJ6lTnO74gvROA0Va7PA + SqYF5e0AIBUsmA/8jtC1AZ1R9Q0CbJBa7uazfMv6ktOKRk7QDBeb3VX7zLshW6ZkEaReYLaGaRLdW7kq + miE8llS9xWG0eEvr30zM4ah6qQDDKAOO0OLttq+JQtee2oORWPUOCDyaF4hmW0RgW+IIATNXL/3Zl6Ca + sH0OcuMa3Bat5K25AzxzECGNhzQr9xqkytJbK9iYCu02aaMrjOfqXS1xmMwyEgOQaX5ionMqN38QGm5W + QCy861zR5ynhQLEA3TeVvIY6xhQEhOa5cy2PTA4hBByqmNRuy4jRkByeW8/UftYnhFlla8ax+JmOUVBH + NN588QrUcjPqKgwlfN/qAYYS2jr1jsBTW5yCjdrYyLLFypetxg1ZRa++sqXJHgdQA25g3lapzmvMTpoF + ZrVX1bZaOQ2DRVgZ7r0lOoRohbytPEKGrrWNpPEIjJVo0F615cQwoQUKA1o7wRGCoVA0aeStsyKAbMrg + 8LrmobDGNA4OQ3z6zKPhPLO/zONkNdME33AJ82RqKgPUp9XDXiv/AJUrlV6P7nEFAf8ANBlOszbpi6jr + mBHTOs1DQsG3jG5QdS9TkeIB4CLPCjmMGccWR2PYd74iv3TT8w2dPRChd/KeXyiW+1l45yQsLVf3HVCm + luFKMGpVb8PMNkkvRdSeacfzOkbB9kpAYsmVnGFXidQ5jQGabvPMJnd8TvG30lSoRuAETrePuAx0jhZG + SqdYj1AI8Q5Qsd4BFmuNyFqiIDnqf7mJ1nVKiMqzyF/UpRusAuJuZXnL5mj/AHahjbgv4OJgTFjZjMrp + IFx/FRosph/Rbi2buVZCr4zgl5P7Sv1auCjQVVDW4UCi092YjsCNZMW9e2oy5XGOIVZ36QCIsvhe5oyo + JA5r1+402nPID5IdHGMcz/eoRUmvVrz9JVIQC0FNLXVM5lHxEaDpmHc7QANPD3m3378YwGw0db9Q9eWn + kKHxmKpdEcoD9UfctjBF0PFEZsBeyxBthUGzWYBLR1ZRRrtVQ6IOvyFrd1Nimk3XXxcMCFJl3ulcEpgy + 2evJecfqVWyrJhsSubVhnoNfggzaFBReF+GvcMhR1R61Mhbin5lr6EKTJUGgLFY6dNzEKW4Arfjj46w1 + Ig8NSHnJcH0xUWrelzSzBYzeVl10Iz3gZFVk7fEAKm0UVYquBb8x3jViRs75L9ysFAr8H+9R8+2+Hopc + zQAL3olCrkVGvGCM91ztKqtYgqwdfEzArHdEOeqBvn/ZlWJTriABYB2MZmNkiWTpCtKt+CABtlsDY59s + ZGss59c6V4cYl5G3Sl5uO/AiRxWDrfqZQoWAHGBarzRiAffxR2JvV+IwQjB4QIusczvYB28r89dRT5/P + sAFwFTaeEZlzuJp5aBBQO0dTjL9l/pCMSB8tuCYLeOvPeAGNqqrlWJZii/vrCw2QiVmNbq45Iq7gu3qR + GeAO5NcCgvlzzDMRXTljYCSOzECch5gX+fBdjPfKMaAFnFczIr5ijC/4TLUaxZcMrL1tZX1aRb4pzKeg + oVVXKk1XDB4Lw/mHb9WWHguJjvQgPu1Q1wjdij7hNqXQ03kEE6xQ5jQJQRx1lLjESMhDcDrTAXZuBaqO + +pfu5nWqschd1nmCTOSMZP5jDmgbLBgRZtEgDKN4/qPsi0sD8/pMz3hSWsGUlGBFpQRrjzGFEVeCHXkP + zLXui00aaPFdIdQDjNZwVLOnAE8CrDzv1AaXwqX4cwwThssGJsN7o/MPzhNLWPW/zBq34akTfvpKddBf + rMYUHPSVUEAlLtenxGZHIsoaHSnnpHpBAGqN+/zMPmz8V+4GyTxiCWOAbpCXTZqUyFFAVFsL5zM85Usz + Zfz/ABDpKgZzplhUaIX/AJ5jVIhQvuWrmPRro/oxTyW//RFZcUVKaccypMjIt1175g2hE0QNxbzniCJQ + nyqiPlnoHSEtsAS3D2qEMpmhu4y9yJQvJL8sbG1EQgeFuM7iAOhK32EbJg8f7jvfnM/DBIWbuofEApR3 + RRmVFlLihvFvJd+6mJAsByHk+PqCL3pFFu8Ld08LrEaMCcgyPbmXfebiomWvUADVikqoVwoHhlCdfzRO + qWn4P2zCXYu8m6+IsAzTV22AbwfKPhW6q6j1GuDEVqFtU5+Zdu3R3LUVafUHTrlRlfDUqhS8taOneY+i + ApwWgZZsDaM15YjFWtqX3uEmqwpLZWTdlR5b4qNABhb9xnITaGly8H/sHDLeE3adrL46R9m5AYX1FnqP + lABo6E3hlFEASroi1QmHDeIRVDqKRHZC/wBw/wCO70hei6gkZ7F9CBpSW2JEBG0pv1CrQbyBY2k7WEOB + jzVGKg3yKrPiaRdLSodQdXYOlwW6a+rfqCas6/0S8Nfz/RKMKsF8I1uPNEfVRw+QH8yyweMH4gnB2p7i + nKyYovrE6p24jxRSwr9rfc4cwEIg7Yfi5RW5geyj8sO5atdAoPiHR+Mz5+k4Jeo8/YsjskirVRkjvtM1 + gff8wetsxp0zAEtbVP8AjLALWhefEJdFlS38I9kgFAMq1d36mjvgMA+FhGS2FT/cpMDWrb2MTagw780u + ajF5YWVEG9WrHQEAagbV8amTHkC9jC7xxgiRQ4aLLaTC5ziA1w33mWJa6ZlmWygZc+CYrFI4ZkVJcO7I + 9ukSLAAvwGm74eCOSVpOPTGeanGDVf8AhiNfQywPRDtu4CBcYHA9+Jjm+rBB7rKHd2QfUqUUJmumJUUJ + ODAwtHI9YYcsF2NN33l3IUou3nDuo1jK5JaydBxUNBRepF4JsUv5hbKDZfVC4F3V9H+/2ZmFKxQwqUM/ + TBKKNAugrL2MwEQ5haNi/wBQ+sXqtsjZa/XViKCBdYDs62reLvVRglobrqkuZKlGtU/mBdEP2QFOespu + jcuMeYilKV0YsEE5hVxrz+oCwc83MJEKyoH/ANGWvDVEUoDqG14x1mSAmFALsLrAGeszJLAy9wjkHh/q + MdlBXFtZa4iWXMRoKAS8WECwSLm1Zc7nEvQhd0z8StSjbbf/AJC6A+QgGT4Jm8j1cS7KAvBUETRdZ+Yp + e4psZ8bm0CiZb/24qm8LboMjXaom6S8aqJxvwtGpXJL6k6IXXwepXlWrli+KUH+qW8tobbxhjDSXK6S3 + H1LmHGEC7TnbCorro1uYCYBgbl421vG/crXIA9L8rMHUtmuL7x1CL4S+8Nfr/n1GTpzUK2imLNRpOL6T + EgRBrDURNA5MwfdjWdSvGB70ToF3UCMvb1R41vSjBqSuUqDpop/cFkP2ibRV5UfcSYfhgfcoBhxn+ScB + Ud38zQr9/wCZhenP+Y+MDafzBDDV1f5lFGj/ABuWE6KrvvcpbXXFvncoBuof8zubq/zSrtdr/wA4htDX + AMvp02Rr5hZyOv8AJDwd3bHCh1ylOFD1nVfLcB+wP6lwwO4lSDDwiOP1f1ShYdgv3Uvljml9DUTXLgr6 + 0VnvCaQUDk3gQz5lIUybYns1LbfxSDHAIN9ogjS1EfP8IbMUVK2tuXjfqCVgqp2hDWWvTMLO0pBbMhGs + +JX87WdsPARQlJpsRsDjdGi8RBKqEFdXk8+KlAT0hkHYovvtDcYICPYYwWS4EsWYF92EVRRsN09kgpQL + alQKsetvuEtrtJF+QqEUOmp9jfkmEGyANebc/wAxCgFRgDwva4kANLCvNhnHiOudyyWK75c9oFTHegqr + X+YsiltJ+SHG7IMW+48wYZAqicQEIAiAshvOz3Fm/WbSvmx6QoXsFrKJQ41M80xFB4L1XXyzKDryHIpt + seR7REKQWIuswOcFbgarAS9hvES1UORCjv0FhL5aJwA5U5cUFblo7hVYrphSrXXpHaBgtLQKoaLoQOOC + al8pAyDKQNApesLFQLOiwUnnmyZXFbfUJndbpeiRPGigxawH+6RbLlRQMB54t7rGNnJZu/POmFuXRasL + QOjLxOxkeRXZtpgz8EpWG9tz9QLaXy7upUV3RxkesIibBTkTozfeUgallqJvTEEWNhuWAc3R0OPx9wpD + lFdAVrrguIGxCm8wexigO6wKhWCEcELvh7VXWC1ihgXHWFlNPmpW0g1VXDFdpeiUGOLQFtcwcrr0b9w0 + Prt+I8mEQsxeNyxqii9Vf+8f8JRoCu1EZ5wN9cv7/wCGpRa1a4mZrf4iVx9xBrVaejKVKDxM12EDBp3M + Tbs6jiLOR+Y1bPMKbVXxCCtYk9Qw6Xag/iIMIpURepWpve5UMWVtbK9qzdxhEO5cToHCw39JdAbQz+6/ + UXXs4vGq3dnF81z4hcF5JGUXnLP1Dqcdf4p6XqpPENdEOtQOqPYuDMAPNwhJCOICsHo1OAN5jhQgmDl7 + lFaeJfmd0uIYmAc4i3kj1NxrTM0tn3KEDN2Q7fdboAU/z2M25QEX8QTQ4A6dPEIQomwqrlUWaWtKqeGn + 7iTowgD2Cfcvat6I2XmnR06xRM2hZa4uC69S1LaoegrjbXAxnILOWYodXbeIIZsUicWJVaXJpiCTBwCF + Bgy5SqDrD1oS+xDDf1FMachD8RjamLpamYw9JZr4SrNky5Vpjl9A0icuLLMur5ixhYJCzgrpyn6hxeLp + uXRenrLZ4dtjEUakuR5XiZNwEG3NbuF2a0eC2+MVHEC6Cte5dWrsocRdpcyNUau6eaL8TaMUVbHk80xz + x6QDILYNmFpnrL5mUVuzoZXxEVcO6Me2bpSHBkvOSpkbvAlRXHIFuDiOBZ0d/BGSk5A5b4EHDC94EUy5 + pddWEp5BAVTm2UMrbFy271rtB0/MfCdtj1SLznvAC1vg6qsFEvdZj92mVpFV1yMxlpfUtzmmTsD9wFNf + UEVWNXGpZvm+sW3W5QZsvSO5bScaekZ3yqrsv3I4D2embhmlW156Y+fqPsUhdG+XgIsEeMwdljVlWY6z + LdOogzFmrfLmpaPIpH8Bfbne5SHPLMcMwNjJqde3FfqWdgO6bq2UUf8AdwZIaq4ETXaws+4xMEUDlL/5 + kikB7K/cyUpS/wDSwm5vP/ZxY3zBBEFJdIV4RYdO0VyN5iZUWsFe31Hd2N5nEDrMZwNdoChHFhEjc2rW + Ze6uKmCgmapgYMyHqlTZD8wSvCtV77xgzbn4lFct1W4qYyi2eX8RI1kN7mXJZzLM24hIWVdk4Kzq4DGh + 1GAlLnbnMpMCwWiYJl6mNVQULiK0SrWEoYCUNDDziJwgyy0wTDq/UPYnRhNWoeGmU90OFJ9zSl0pfkiK + HOtn5lXY3kD+Iqq+7IMJ71BkrVQYSu0tUDeAt+Zhm7wp9kfUA2APuxKdEjeccVfBnG87htZ0DisiPOdQ + ZMqMnLOVp7TnzZIEu3ddDDlgMYFsogxYxTzUxiOgq2yna+Y1nIsPHcv3FQWwc18sHuPFiwFdBdL8b7Qq + OGXA0iGjYlMcoO1JvGllOE1iHb36SaWc4t/UuKU0GqYCeW33GPKkyObgIAmCRgWUccOPMZE4JEB0G9xY + JpxUvxUxJwsAVoTd3uVzqrQU5vXOaesyg4TGT049SoD6uTHoNBqG0dMSAa2xXVgruAFsHfePMrwyFKGf + aEBQ75JRDvZtfzExCqQ8GunSGYQ7DIHjo/KNWVsGBsHS+eWV1ILcAGr0XNxiAbbdWvfO/wDMqqsAKIDq + VSV8P1LMhLZXR9R5cxFzaW3k+amRi4QZeXxvHmWb5RazcByznN9GU5MDsLBDVVYOtsSIitrtCnCtMd/M + LkSiB20rYJulp0lmlb1rVo7ja7VqPAkii9Vd9c/n1HSoFFn6iFPjDBKqoOR6V1lQbsHK6lFnsIRJ7q16 + i6JbisAfzMEFVFcEFDgB+rZRHTEZYb+/f6mN6QPzn/r7e8ZhpuEtu9EpbaslbDMCcAqCD2l3F/qUELtB + u/MJcPMK5bl+41K111NOx8aIjGMXu86iojnVssHFnRalSoovBGHqiNovL7juh43jcoxhY2RI6Yg6Qt44 + jspcWkrSwb1C2gfEdcBVRi7hHUzIFVM6vGbrpNs47yrjcX0he4LGZKBGWJK3ibcxDv8A8mxUs+WCJkIo + xiZcRax9QSWj1GpVBBxYfDMGBzhX1j6hodZsH9QqjsXkP3LBwf8Ai7mzWaxPguprPa/NH9QxkIixGkzB + 2JWwcnSvz5lwAIqgt9Q/HEt2qsp0VYArnmPFGwwimLWz38wEXi2BWyJZjuQTW3FA1VUr4x64imGAFxxS + GG6rrjHMZc5RsFXZTk75hXDRJLL7M/UOSoAZXi2mYIzxhWedXCoiHIRqxYK1aTDhmKl8VWkkN2xXFTd9 + 1A35jD40OFIeMMLiEV4BONxTiCU2DcqwqrpX3afUD0gdgs1dMFv/AJLGRgHIcvUrniBhSA94tt4hrDuJ + 2McV+BhDjDupef4QVgcKXxXCS3vs6GPHAJCgbq2r/wB3EutZhetrZCldPMa0FeEJ/MOCw7KK9zAD1u8e + KzdUgJa3wlChwlbJZreWgOFXM8uaCgxUopzQXmhCObDBSqoquV1RvVQATL+AtgFj0um3EMoKtEA0VAGO + GZYZRPk7X+4qDggqeuCdZEIOwrew/mInQB6RY2lVkvPTmyqRURWkdS31k/I1+pUw2XclkoLiUFp8QUYx + QCv0D+5Wug+BGcRmYvRzEQyfEUWjdy1GQLHMbFyLoqARydEQDw3rAqPqEf8Ay8zL0u8qr61I6YwmaMs1 + h9H8j6lrgo8xeOzXFxIh1urH4meqAQDn+PcYqNiWICbV8WHk0x0VwC1+rxG2AYXgc3cvRxbERcHWmmtv + EOZRAZjpHYg0W+GPupShmr/PJkp8nuIRm+TlYiXUhqL5QUjwMXF20mPMtyJdmlNQBq3hUCJUwcK/MvW3 + uDfpCormoNADVtF52t9S9HqLl6XfPi4AgVRcIe3W3YTI0mNfEVQELwzsM+YoBO8L0w05F7prxxa1EwgC + 0ig9G9yqeWAeyHgeWyaiBApGVGqMyy3Y6y6KqAvUCuYfb9x2i6wQONU0ocPSKg3oxPzKo6o5UrhjmwCI + gi8FX3KQbqV9pkHXgL8sQ0BKWtdmahV4q/AYyqPhu+V+o2+KcQBtxaK7+I0kCtIHbp6gXUAGXAvlnLAp + MKBaeyH8Q/PfFBFfgfqKtRbvAPnJFADmyPsS7z2l9iQhK24CQpDs2xfgP1Ee9zmWQRQqzzM2sBmBwLi+ + qNS68lTU9KpU8Yz1I02FMUL2O6Q6pMQQmdavc3WhvMMwCVCo3o6S1n3aIKgmDmV1Xe4LP3RZa18NephD + 3sFHkbgC6Gk52nShCjkZZBXKz8Onwk0UOsfWB7uY3djeQbZquRxN6jYT97qDLQei/mpd1fK0fNVGhzNX + SeoPNE5u1JFLg6hB+h1uF5BgRWdo/wBXzCfgg4aGzfXUZqnN2FQBrMheXG8XZolUzUEVn/2lriCuu+14 + viUgDrYJXS7fLUNzhZpTxfBK6VroV4xte0oYuQFDYBrwGJjykf5L/f8Awu81ynAShXWh+IaHiOkzqsqv + I/icTmEF3eoHvEpsTFCkTrNbwRgqlzk6nEdeAgreP6gCqkorF0bb1FoUOTMPgSZMvzLKBuhuC9lRXKZ8 + CmOLjkhUcyldGCO1Ww8Q1UA4KyZendmcsBmqailrW3WHDdQjxuKX+FmaFH1LThxMmha9VAB67NwUBZYp + qdc5jkHBcqdAt4KjbkK1/jBJFhxCvGdxXs2LPMWoHjI7h4qElztApeB6q2M2FAdXiZ5dDS6sdULDhmVC + cSiFx3tbWyt8EvVQWlB+4gaBFjCxneY8grt01NQv6fTYsVyyqFhjVd4lLgKxxEoGFVaf1pNRL7u6X9xh + azdOmGSsyfN7IHEN3jiYM6wZB3P4lLSPV/cBgB4Nj7i6h6jceKiVxOKZxjo+GJc6ZVzVzHivMTyIloes + KMOMM4VPuOuSFttcdo+CPhC5YOKzfcColMgJXeKYRWjk7oQR23bBQ/Z+4QvIgz+rmCK0qV4Yvq91v5l+ + 5BoXrsFj4HVm9vf6IkGZyL6AgWb5KfyqiltlubfP7IKI9G9+E/EMrIrge6IodIUH5LjhmKFonVKNe5c9 + bQwK4MIuE4ztm0MCvNwOoayCB8JgJVMCmsDlWvuL2s61ptW95i3WOIoduPTHuMjgPj9JmgF2wTatt3NM + FCuoM/Jxt8n9w8rqZyfQ9maMVnswK3zal3OVH0wqKjZXwLBj71ux+bgTS8lbjTB2qFOpwCP0yoBEatB1 + 7lEw1qqOol3BMWZ2b+GaIhi6uOu4Wih5HwMXvAolu2alMl88Ja5ug4IZwADA24buhx8RCqq0Ncq8Sn8e + toD/AIZq9IBiDtcXdfP/ABU4LV2eMwv7/wCMIK4ggZfPW5YOKVXBEAGXNqjZRTbqRokQ2re/97lRSZ7g + 65oPjzFQ2NYYhzkeMRtNWveAjFVZcDMlR4jH/wCpZRKV+ZxHTaaiGaGdE2py3KcnYOkeKlBUeQ6nOZYK + GMI2atV4hYM82xe/k4jxbOMcxWjuOqvF/iClaxvUqQ4PlRstBymbYkLLOJo14IU54LahbfiOHqU7iQR7 + Cy4CHWsb+sYxGyodzHy3DUKZECm3gS3QYyM6gotSq2n8R+0Vu5cZhQaSyoLeQPH/AJM6UUGv90lRxqUO + f5Jak6xbXs1AMIJho5SquW6NRePW1sPqEFrWtuXNl/cJBOy/iMFN1xAO3T9iPfLUaiPJawDsi0HtO2xQ + 4+4ublcrnKSAlIcV/KYU/nCvqMAp1Yf0yhBLwH8pWFhoEgKIc0r9Q1crzU+hqX6k8D/gfuLqJwN/gfcI + z+xvgUZzo+pPkgAMbSDsiVOoZzs9oOC9Twe2Gk7Mra84Llh2CuLgBbMFHz1jEeQaB+mWrCZiV6hdGava + QTI6KS+rX6lGADpMd/zFYTS0fm1SsNskXXiMWI0T8doIgS1Z9Nn4i3yAAnNA0dYhU2UWK7Ij9ItaPZ3o + oz6lsh5CDhOLO+yITBbOZooz15it06Y+Fo/MVXsF2Vi+zHeDqqVbH/VAvkt5j1r85mWhHopQ8wRlL3Yb + my53a/UXaq83/mkDqAFAJrDSJ0mCILdD3FgqW05i4Av7YKgVoUpaavxODO521QzeLr9f81HcZV8luTLN + OAt2hYARK5qNc0Vh1ZzAjkEab/8AYaRYC4xuYHnSWs9cb/iNlVbuxoVXEXRolVrMsYd8f7/VG7yE2KGo + w5JVnE95iU3Y3DTvpA2MURC058Yly4cLANHTNxNER4CLrcxrUXTa9UECE51FR73Mooxs7RtAsZQ3NV+Y + paAKqUzATdazwq9ypRyroID1SGxizmO/ZSWXC7vtf4h7utrKw6hdCmrzzHNeErdEuMN/OZn95yBmhRur + q/EB7BKpIBeghk2OY5SCUXfEYFyuGnCPGVBFkLlz9wRIJGkNnWCLWhcfEdJTmv4lqCmpcLSpEKcuxL29 + GNRVka8YgCDrBHM6eGmUz2g3GAGx/dynRokNPkb5hNHHEw81cdbnjcN9ItM25iWJ1qPZMDOwdorG6hzp + 4ExEcYOGj4ZiAHez6lgLLGGuS6+JQ2jvn2Yghluj+JYbSTgz0BnP15FRw44QFo4CWEikc2RMagudtYKD + 5H9QqGeYAGC0ISq3cUttCWr1jUcjxWPmA3EwFyufmEEtX0DFxccgU38/EVwQirJ9XxGFAsclvnmWbnJR + o8eYAhLVmg7VAFNuab8bgoVYl2p/t4qWgPpBZfhWbn0NYjuO/UZaJvAeauXTSQt8hxU34BlxfKdpuD50 + 1KQLKeEgUVMA3BxA6QcQIA1KYtYLjgYBhHGtn4qEJfSr4lx1KfJX9/8AazAQVfytZgJTi3hlAGwca79Z + g2Kb3epaOguCrZ2mPJLVhfqZhbXUqoBg4XyMugQXmjLjJ7h1Cu0zC0CeLh3clMisbqJGBRWMw47dJugV + zAKkuKOhCYrjN7+o+UsK0HpLaAaKuWugOmbjBEbe8OGpdAY9p2g5XNYZz2FWDJV922AFFpuCg2I6SVYT + N/cUxu4vEub2i7wUi6hxvKSiN9qwlBRyHZWO77gXFsXR7D9Smd37hxdrusRkyBS9otcf1A19bGF0d4KS + 2AOh1ov0Sprd0AP/ACKJwSLbfD1KUIER+7iAvmC+GC4iVEdAPyxTdXhW4wckDRhbLtAAC3FQLCKJxRKw + sFGoNJTPxABXFqeJklm4LWoVmWale4CQnbMeAyuAFGe/4gDQjzM8M7KdB8mC12rfE0wUB9V9H8oeJKMJ + kfcu5pgdagwMfxAPU4eeY8bgDvMd2SpVJ1T4i3ZceHDq90i5e+kVKrG9HXxMY+Kv4gflnPzN6XcA+JtC + vCr8wixN2rIBpHuKcB2XGSV1XwcRdWGwfyh8kt7pQUXp/aGAw4Ep2LMVFzNiZ7AP3ECwZI2PLfiOFXMW + HjFB9Z7z8PiXkgb2d6uyA40dUfbr1BZzd7b+GZ/a0hofKRCBDYIV3My1wuug9doKAcvagV6uUtzmK/lq + BXyvLLr29QN/BZBfyEOfkg3V7qbo9M0Wj1BxAoChHQT83MvKVHZZr/lQuaXlMQz9TbrKrr/zxLR7xw4z + n1C7sLkZzBOcmrtc/cscu+X+3ASSYPKsSoRdSwk4Zhri4rdSgMEDrZqU+KMr/uFZ0GXPEBq33Dx4gepp + eSvjcCtdYAn0jDerWg2PzlkaOsE9GZVicOP4ohnJ4cHAi7hpxnVfzQPohWBrFAfc1kaOYnPVjQE0B4Fo + XW4/Z2G5TvR+IREd0oeI0PVrH8sCrjCPa5YLNUayRuy3XbUVCVqjZzxZ9QKH1f7cTZHUFroCYcOFHBo1 + QWd8tFtBqzXBmU2XIWpWzc7ErdjyTAuxFJ1LJYlAxCpbTSuuuJm5pEPhjXn3KkjStMxVmBAUopbR0nuU + oCO/MwwbXEGgApisUxalKil3XMWyrWmIhRW8xc/mNR4Psw8T0QBrbCdZSxM6M3hhUUOHclEFmk/Q4lyK + wzQmmPL9Sxk+0GtfYht7e9PepXgOh+4/iLg0Fi90WfxKHJffMoESVUNZ3OxNyxmCYq8wY5gDLD46ocwb + q8rc5L+5lLOBmPEXu1Jpkv3GMP8AZj5geUieYHGL7mm3xacNvc/iUls6OT4BBuA7MwYwiF03B6JqgP5j + Nr8u/NXEk46OeAp9RvOcxDFcr9xKRGr+Qs+oaKs0b8WiuJqmtffAmRFQ/SKQiEaEh+YHoTuVHkcS3x9S + +JKHEqwbnEN4SFq2gJ41ABjU0YN5T9Wf1L6KQPzmP/WBc2CdJmm62WGCtwoZ4WbjqNxiznXSEwCUw9QX + a1h2LL/CfuCUq6iL9y/d/hywdp+EfqbzJpLEYY8R/BEKGd2AZtvR/cLwHYMw9veqH7nIoPJp+oDf7/pO + Fni1OFe9r9xpx3Wyx4PSzV2zgQ/hrgZ6x7J61yiNN5wyNdf77lxseU/uEF3ctyo1BD1MThLm1Z4iUVD1 + i8YmnT2cp6Pz/MpiRugNxLoUfuDqJj2rAt3ePimHyAbS/O1iX7ixxkFKgBbG3HXDGpQ4AiaaAjXIPdxK + StKqIyDQNm7acYjkMiwfTyQsnW6FPk/iGWhum1j0qpYcobEVt9Rrjc3q5TN1cYy2gdesu9DfXiWBUYk8 + Uv5lbYPt2q/MGuWdRrswwU+IhyJ+opIoU1k9y1XvFqfHErkeKz/DMIBXkR/T+Y0GPkvwNMMKvfeJu+dz + qPqZ87jnmc4sY+IjKUyO2y/3HLhj1Hx/yrxUtmRup2BqUxudGIvpcw4mGJkcbjN0nRSjsJ0mAoT1WH7i + JaO8XXxMf42D9wawOwwipl6RKAWqc6hXzwJe5PhuNmm9m/UE7Psfmou4XzT9y7VfAfpgvhO6f1Dovpf3 + FU+v+0Of0FHmD6P4gYOzWKlsNHGDq1NIqT2lG7NsOgqKr4D4IvT/AIaYDoAeje5URUO7VSmlV3P6/MNu + 1FVRkydpn7nLbHZM5tMiy/pRMyjJ/MteFqsgyptR0ido4lhdjWYFLbb0s4Vmn5idY6FwZwmNMoRl8M4c + 7Jk3eHvFo0nLuKjmVxmzW7lWaHvvG00A7hK6zrFHQmcwDAXrFsPIC7Zi5iHQq+YwDdHo94qgtQmrLeZh + oGMq1IIHG4HSBvU5AVLsxsotQMLdu8qL3gAYVqkcfEAVDVHTuJPNS9sJHkQBXd2KTW0DGJh+zzGgkyLV + K7LXhjbRMppq3xf+ZVWBlUZb/wAwYrY3Va9S0Hqxr/2DjgLDD7gNcauoHkTh5xErJ+tzK4S4oyKq6uo9 + gql+dzMyVFQ55gyMKClxE56ttPbiZnVX4zBYOu+T+ZZSG+IlMorbUpsNi1vg4+JSBrbl+sQEIkk5O5iI + FDfuBVjcsWpFrpAcCcXTBMVEOxNWNi6vr/w5OIDAgTTiPHDHtMSifiHvMLiI6uPH8y8/W4pfRbV+IhnH + RX+ZX6A2UcR7fAsUkQLn1YFK7ZD9TabzT8z6x1nOn/gy5he8uXcwXWM1p+daPq4aiz8TYaWc9f6TiMfE + dN2hZdj3jVsvesJ6P5gspNf7pCWo6YrN3G6o6UYUgug0QMEhm0rxSKJa8aLhPD3sIooY+DHOFdm/1Fr8 + r+JVzENYGVqoP4Rqlv2tHwUOVlQrDSgv+ZUhItQR1Jnlvx3l9XbQLU97goC4Rd8+Ykur6GYiU7RlQlO7 + SXf06P8AfuCftQzNPQOsOX7eP+oF9BbbHcagLasFuT/bg0DSzfmWlBnWGvqABc5f+GfyyzEdsnHR/MTH + 0I/mCKw+6QTl8hH6hQj+WvzBdJ4E0MotaBt2GWhFOuXCVqNMAaRRT1Gt0E1NnLVvAbDlmVGGyJT0hdZq + uhbGACNgpgmQDCu/UOSOxPLFcBRRxbaMWIzLLVstGU7RmGu8C3XjmKhRRZmsY3ATXBk3HEEPUbOmWjqB + noZ/NS732Z4I2asFl1Wai4CjrLR8uqlAcDvGEAAJbF8B7cxih4tQDYW2v1KJsbR/iEgQtaeI4O6rWnaY + QbJKXzhgx4VS3sf5lUlsVVvxXuB3qYGE10guof7cJrUW+hAxudxiB/MS5VSvicSusqbYGX8zByXH5xpr + iWZe8Qi90ROv4lV2iRjHhSU2J6hUAwfaaBzsP5J/sI8Qr7cE/cZseT+In64MZpb0z/ESAarfK/yy2P2h + UVfgG35Z+Z7nEL+pguN08taqviVGZVe0r4R8CNK8mVkyMZiugze8ykdKnWVoIjZ5I3ZRWp46sTtFBnZ7 + g6GCWLPtiUTOQLV3jOO1VCU5iU6AAt6MuUger/KmwSU5VfzKgwOlQeyeEA9y8fTLduZfyVOF4G2V/mVz + +1Vm/l/EamAJSXIBvUoKxjMH1URVkA/to4t73S+eZWrOrwLfxOF3KQ5xiBC+AzGoVVdzcRBSra/oyjYd + K6/mXcFLbcEV5Cc3B4nuWt2gS73KrwEzLz8y3ReS5nL/AES7ge2JvpA9HE4S6tv8y5IF5Aj6lMt0lr/i + WISoKvmb93CQW6MWeRyPjxLygvCB2BKInCm8WdEpQGo7l8hDXbhWWHRGZeazD+n0y054AMHW0yE0Utw+ + OluiOQRMOrM1e2O0WNQKaOQyPA8wTSugKYAI3bTvqXIsJsWmLiRLbyvrf/IEpK0Ol74Jc0OwvNbi2AE/ + hO9Ri8YgKALviWhZjKQFVQxauLMw00Wi+70+oqrRqomVOOKszX0GjuwgRuEq3PY7fncA7C4vacjdEEpg + nwc/JEerQWoKVXirCHCy9Uy6sw3pcHzE7lGIdMdbqVnUdokrMr4lM3jiI3UoMF2he2szS+I5MyNeI9n/ + AAZQHFZqOv6lN5Z2RiyN8Q6gQHIqZIyaK1VQP3cJ2EoKJdNXniZF3jtMl0dLr9MvMXxCqxBxdtN9wfuC + WFtWzKB1EQrpQefmHKXuCF59y4mOlvFauu7HTNpFircT0XQCXnNcUqvmItWOQE/mF1KK4BL4ubu+bhIp + +bi6u9tcSleb3MdSa24n/wAiAgANhdThzVWm/mAAgLxQfqKBje9WRp4i3zC0ADx/lxHapvl4lBdN71LV + 8lJUDdN1ZRYwaunbliNmydtywyLXwuYISi3IZlcBk9YHQTPmWYgnDx/UabCrR1ZieEHYTsR9UyziE4tK + gHh95h+YEFsAGv7jOGQ8VceUlmBXo541FcfWcj9zKAc2X8kGo5Qqic6hYKzH10/49SEGR9S+BhW88wr1 + jycM3MZ+IExNLDfCnLbFBat1tFvyRqVMjluO2eOesbDqVsbcLpisywZF0RDpn/aitms0UjBDWpxgS+8E + qg7c5e1bIiRT5BECbCrW+nExQG21wRSU6piW4u1wW1T+4/RAv7YlBgDcAIYG67xDclgSr7XiGpwo0dDn + 8TMcc6qyPzODAvMLVS5vWpYZHt24iX8bbB16x0NxpBeReTxFZNXntBw2LIai7mdLgswHyDux0xSyAa8i + OMxVDUrBWC3cy6YUD4Kx8yuoesL9NkVFj7R9iyd5DGn1Copt8wXlqWNwFY095Z/EvzGrlYiZiZnmHeHb + Mqy6iVq5RDKZ8aiJridEEbiOCOgM8dpQaArGwlcmrgVGMDoG+BLl1at+1/cYtuIPMZNmuvYWv4IfAnFN + MY3AiivFSnSqlslOzqey5WIUpKG4pI0gsnAEbHBQjNCA5uOiUjslS2NdIAseZa5TYlv5iB1NtMoLhTpf + Hibpz01xCG3N6iUEWJpMRdVS9yOc8dSqmL1R/KVM62axFTKVUAGW4q5cxaqhSrsTSuNZjuUeCNRoSOEL + oSWvAKdmK4A+IIChXipo5YbfcUewnghVqHBcsi3g3AKrauP8e3VResp7xrOKk2kC3v8AEThzCCwDfXL7 + hatqctlGL6so4gCRT4Eo7/C16m3NcwcKgM7OYGV6+uWw32jaxhrXZdWfxF0AHCbmryNncI0AHCI9LAq/ + EuCByAIQj1ZBw+U+oVrdI9OaTsjBbdxSD2W/iIW3WJ55PcB+IqnDABXlTGm3GaqzrMP0KOTw566jtRxu + qGI3arYfrUd4WL2dMf7MOxi9VytsU03Vtk5ZIvccFvHmGeUasV9kpVwaX9OpwpbLwve4yVlpbATcA5S3 + HxFXnfSAOuYE93eBxAnJzLeC6WZiZLQDou/wRzQpfxufKur4GPqIItwPnowiQWGFX05xUuFWKlVZeemK + +YN1DhWQN34jGd21h7MrG3yV17ws9RCrDoHCERBRVeXn7uKlulbXJqCnMmpRrMTUMi4CuGzfmuCNXXg5 + GAVOYWo2BQtKlV1N/UfqrW3nwwMtLhvBHVIk+oKIF/mKNv8AEsNkxxXiNQzA568ErrmV2naqnvUvDmEx + UomcTLmDlUGIAuqqYbpgmkEAHlh3cJYNXrGosTO2QHZSv3KfVZfp/wAvOH/ncJD4CA2IwdM94ROqy+F7 + gBS+bOlv6ly6vO62RCFU1dTeO8DCeGqlrIWWruAr35CULVo34ZjhsiKG6Rg7wI0517iqxhszDlQeuJtA + KSvMpAg7DNSr04bO0GOQnWDMubjVgVVwgyd+MN1EjyrtCY7z+0TGFpsvEUCkWY7Tho3fMxLsP9y/lcXG + nBRcY+phlk47y+MGX3LzNgeHY16kgIZ5rYN359VG0ZS4CmOO8bKl3kHXGs5nZwhjNjs47cR8sgQG2dqc + GG43XMFXOtl4T8RELGLF8APivcrx2AC6KP1ki+I6bUbtyZ7lmGFzZDKyr7Lr8wDA3WlaBIl8wkVIyOq7 + y8598Q+H8iv+MKpeVB3W1rvGC7UoOtDBaHnQQTQM2D/2Wypw0/en4fUREM36gbXkjgi6xDuR1qi6vA/m + MLFvE+HTC85KRFbN5c+CJAzLRDQeVM9BiwY5gTnmLUTmbrfgGNAaapHjgjSw2UC79sxYLm2jtHwW1tCN + tregslTeh2ZJiVdVtto7ViCiLpW+0wmwRWuXvBZOUfgjVg06VOJh8UU7P2dnJ1l3ZYLBeWsWUaxON9DI + FWuQBnbC+qoTumrs3fNePxM5RSMnaOL/AN0g7qjhxG1xhXlHZkQBBEdZg+Cb5/k5mPmmRd8Z8w2QEsFs + v9St3LKFB3L97gwDTdqLu+dOrWMRJlcNeHiKjGJx36dvmYMTFU7lV3/G4oJ5LseQbHkp4hepriqdsGAO + 17CwdT+IK81oLfFdZVhfhz86+4cRNAH1CwyXBvNQFvnmCl3F2mKZx1gZhxqV0xK1YwLY3a5ldUSoCHWC + gGQD6FXDVGlUipS4yJN9LLmDKQL5cx1HcNTC3ae1YTvOqKXGMBz7gpLabMe5hBTOuDU5xgDuJz8y50U3 + K9Y6xgtbiilErvEFtb7zDgrsxE2GgrcVPIct5f6mljxAoJlMXBEoWHT/AMiWF3Zb+ZQNU4q5rySlosbw + 3M7RgJa33i73EhbeO9SxU5I4CMsN0hmudSiLRz/c6RnfRlxwQYpLMCzCAZcQauaHfEpYArVDk9ReE2DZ + aPuyN3gFaMPtSqwUEXZ77l8AUoRuyxTLjrHbCpl27ZcBHLyCyrp3UIdIChY10RgJq5hw7pzw8wZVcrB7 + 5l4trOH+EpIij2GIIBQdhZHg1HgMsvEItQIvJXU9SpeM/GFp02QchMkXh0KMG6MjnkxLTB/Fo5CrszXz + F2zKqXfaxxpwk/Gpb8PAqdQKHdc9fDGMBdbzVR9JjMOb15NiGBzBElUNgu9LzvAFRkmLkCGQ4Az5Y13t + NdOcZMR1FB5FvPWBWwKbITAUN0F/5l4XZeS5k1VaCKiqK4KM/wC8XK3C0p+9zmH2xcSgZHiLHlAK3b15 + gALCxqyOwD3vUWw+gUjOADo0/PWOtEKU2RRo++bFJWioIpXmjA+MdI2GM2VjM0gUQXtnzkGqjRSYFa7q + lwTATcszItLemoQw2blK7LoEhgTSw8UOzh3MbouGg6W5XQdfEecFT6Y9jeNsDZCZ73Fm0GxJ3G68NkGd + kFYitG1jZZGq4djjeZYSS1go86lncDybOtQbs/IvqVNBGifF3LMYG9f0/iVPYn5moBRtJJ9QXbC4OYFw + 0wNZgdEAwfmBnctGJXRVzIeJSyUaUxCNFg60JNCOlF5rBzT+UhUdAB6IJmDjzOvSnndA/cDggIuaN1uD + 5jWVjahR3ZlCbV4C91LdaLNBTkhKaK3ldfomTKK64iHKXhVqoWl3n5gMJ0WwHQJQ0NaOmG9LLmVTbeQI + AEU20pChNtPmVSJaao35idlPv7jkO2NlxcI24uNAEBrFeYDneTA9QXfAuwD1A5tVO1zQdMZ7wQNG8tOZ + vGVYW3UdaASqP5RaF6nA5Hy/R5gRjYTlLgfNrCtlxUfsQlLhrMeh/rW1yxgFZSurv4CMQU1KscjG/iL4 + qoovJnH5gou1Xo2H8wpVg2R0F0mcOJbboyMAl+6rvD6kqI5Mada46RAUWQaRQ3xTd/UG8NjsF4I1x9ys + YUweiJQLY1WdkxhATQ7jWLbMO3jszMayVNCFLvIo1qHCcidV0rD1PuPUM0Q1oOG+AYxGkvgi9JnbGMYw + U4MjTA65Fy5KsGYNd4gKs4sBChMUUv8AK8+oJoGbCJ3xzLCcp94cV9IXPy/mdz8XNstpzeWrnXFwvz6S + 6GLobPIZJS4ByrqIOQ+bYrd5Tacw7UEqsMw9/EoBFDBwUYTIwIuyBgTbWrPIQR1HIv6gxK80lpn3ChwI + rUYYNsGgOytMPe+AQe4fqDEBN9Jhfi84c79QYxTIyyv+zCA6lDevMCQSmqauFkFDbU4UDR69e0Y1q1l9 + JeAl9Y7Ssr8xAZL6XECpX+4nXumnD5AwHVlQCUx+CLbyu1l3uUUOx2ZsQWz7OvnUDTVaFrY9u0e2MtwV + Q5KVxM0DOfuAI4TpxE92HRqCAJ5BccF53IcG8WzPiPZugX33KE7GAfDK4seV9tQb1OIfUFMD5gUYljBD + Jk/4HN0mFKgr1I/F+iGjsRYqDYWH0z/wdjH5nYAiEaWfKr6qOGjDYrSkcOCrxB8V2CdV0Q5dSzL8ok9c + AY1/EqCBKptwOfcuAlUKytQQC9rVSphAbKaATK8NWwtfcKg4TW3urmGc6W2GvT2iFAFhG3MKsaaUDWJ1 + N8SulfTuMPaYyGoL5dP6moYG8DkiWKBRwJkTUSsPZOfEQVUXlofBKQC2bI06Pol0pwVDoR1MFUS8oIqu + oaBFL5AtrHXIrzziLXsWxFZSLyNMdC8Cr3MAKVZXW4KWSyFGAt/MqNuQE7fCL4IF0C0ZcfEEIUCU1tf1 + DZytXY52fnrKG34shaKYVl3rRrRBuN2rqRNoG/UEuTrbOJrEQA7OSrl+Y58qxcGpC5W4qI4XnKdJ3gZh + 4cInPfKHVjxGhZZU9A9+8vDqjSQ9rPqoUFOAujdb1ElNdgK1qaOSiN+PSbeW4B2ItcP29SyIVdbjIkU6 + jyJAmxxhM+vot6wCCLofKa9FgLYclY9kWM+dNvc0+4XingPnl6gX02JR1Z6xGpCsNbN7lOywZKRrDe4F + AuUJXI7txKlurg38EMtVHDffrKJDs8D4lXNKN2CX4i3A0a1HyluEY0FUWIYZZCaILRZbXNHE4o3ftUNC + PSxIAFjTDoRMmUBiwULmMSxbEYQ6TVTR4VFMlsSqqaSmTeJilau6vXuBjAPQWKSimsN9vcMtBABTs+pX + pm2ezlahA0EKK7ofrJ0g8xUgEb0icR+IVHraAv719RM8HSUlAifiJzQD0hyufUQmIibmviNmS8nSbwiY + R3BaNM1vEqrurlEAdOH89/cwsZptZ60/zDw1MrR1vT6hNEsENBGXuq7yqoM6pDYX03FisuYdQ+AVb8w6 + jO5C1/4BmaGVnviJYYeP4l263rDimDeMuVrIax3mKkyFviv3D/PVQxU5/bFx9yrKovwSpggqBN5s4FdC + HBShgSot6shxbnJsXcENoVBlbS6p1L88v1McJZS7RYxFppZzKc5byGeuIg6jhfcvazfMa6OKuMJvOrhR + rdp3mI3jL2j9QCuN1M0Sl13lULwUcwtOOjfe4O3DSniYoN4I5z/EShXkFxfqY1OKeVTCxGNIrBd6ZWrs + LC1yrO4Fh65EuqKq/wASoiELxqFBTXqXTEE9oENcPEMyXBu8BrjbH5iIrcQclxXFtX5hSgWYRzMS18m4 + 4VDIz4jau5iqgNQEMCXctQ4avpBTuOYTTGGKrSKQrnOMEfJ5l00OKqXgTK+nhYlwhTWfXRYt4VBAq+7v + de4X4QCO+KfvxCYaJhQO9t/hCDBoXrTYOeMMxp6wnbhoeK9wdOcqjuOSIGjHYM1owj2eKggdAI0/J6bJ + w+K4R0/EZ7Q4Keox9QBwscbIEFTmsxxfGeYdIjKOKcii3ohrFVeEsRFsdIVcWlU3eo44IhRX3mFq1NZv + XY/3WEioa4ExuviIFYaW6GehF0BOj/r5nRoLWoFjYJSbunrmF9KhrMu4WMrWDP3iJfIuPRYisW/9e4sA + QL012HnhjBKaDV+CLa5oVXvM5QBfgmYKXRnUFwtej6v8zHKFHL+UvCPSFdHbJuMYmltWCvZ0gluYq24w + fBCXS8QZo1psTGTpWbiJTTmXhu6qIbxWMy0Uc8O5YA00QUeTr0hKwG1cMV3zpiMNIG+8T6gnA9aYplW2 + pqP0utVoK44tlBQUeuY0C+Yr7RqAEFa2l/VxLiLhvBqe1iEVLeYU81HYg3yIPVD6IsWXGOQS77i/q5jq + rtAuT95hgqx2LLgjQqKXUxWP6gBCUM+Y7K2fLYYPU1IRw3iAyoqmBaGwUZoCqe45gyGSNjVnJutwYDJi + JVDxV2QnAWmOkoickNx8TCX3sGP4muqbYKY7vzMQCyir2Tl5mAwBci+tEulhbWD2T1GEgigk/iHwlo6T + i+k3sSpf6YPbKI6DGC/hiisGmuHY1HrTaKKd1a+J1pIB+UUrZQR2MzDejCXWeEphDfDqRSBZ1wd5YaZJ + Q1v+KgCyovn5IabbGgWhfbvKkulhotbFUfuK1QEAXXQ7wMepcYXzFTgUhmpvryNfuHzVvrNy7ykFU8jU + NoSirJ0ep2cQS2KGF1F59tckaw/BGTwvaUFRpWXByCF5i7lxRxeeYnZJdyVJJ4oMjo5ZTL2aUH0RkISj + 8zrwKlOCtKK+/RXKjtPpryBg7o+DcrLgdXj3DqAUXVdP2idpe7w6JZjU+MMsV+hmWzQUL60NLGi4GCWv + JClxwvv5PcyxTzj/AHPkvTO6WTNTbdgcDAcV4zK1PNEUvIU0UN9ZlWoVrUzljpqo4OiggjkEdNcd5TiB + UUqmOklzqPZMkfRarBTziU0Vi3pBGolK4/qUggvyUGykzfNxkt9pVHrT7jK7Rp7PAWCrKpt5VT0txRfz + EF1qJRjx18kSQSzjT3GFCNkAisAJNeOYA2JTDHyQ1lWBAImTjLQiLV0niXK89KeY4e5CBHNOROo8niCa + oxEKmm77RgB4N+aiAS9Ve+0vmHbUMMAj0SIXKYdnMCnz1nQeZc8DT0j1gN+bDZ+WOoaegXy5PUpD5KPh + /mXgEHrl/EydaCZZxk3ELoWFbaL9rNFZgrKHT2C46E2Vv5/cXDFv/nJSdOon7qUbik+oBf0RlmA9TEmk + LBeM/wBxRU2Xx1P6jOLK+tIyuqos2eGMGtMCZhwMzFaCFahtQ+JUDhQm4aC3nFy2Y3hYneOxphSr1BBN + d0xVrHEIj3AQSDa1pE9yVke8vHWmY3vrpO8VTceNm7bIgLSbrXxmI67Kukpy1yzi4nNfe33OS/ZFFM8U + iGZ3QR4f3V/Uc+x12i734B+pifQJlU8iYFQwSuUOOk4Y9YitH2HMhAff9xJsQeVwkwOhi1ZV9sY7r3Vl + blDk1RcWhDcDavGer/vncIDEBrIjSwjNqYamDg0vrmIh06TJNAU6gZVF7HmIi6v8xYTWkND9pZnSYb6l + PeNhwDIvbk7A8stSS2FShbeEt65lgx6vjw+vZKTM0ldcqu2uq3o8RqUeXWInCcPaAj+A7B80U6yRen59 + XKC24wc+B8UziLeZ6YDn7TrD1tliDBagdFv0a7Q7SSwu+H5phWVGLG+OzERQMEWBsqHzowUhHGEHVX6l + gIOMh5OIZfrRb1iuY3dTmlFu+aXKnAlOEpbEC/Vwi892pF4MHB3hS7g/zv8AUAVWGaFv7/Myyhbcodh/ + bFEGajk4q6fSw4W3gYgrInKFkvuCM0OIIUTPs6rloYWAe329yytXCO+4LriUDflt+c6+pReXs+8r5zDI + h2qjrprpmK5eybvca017FGIGFC9c9fzEccX+YMlhtZslOKlroxSbsYAWxBdHL0jzYGxxCvIW4KvvFouO + OhGQTbUbybhVjPnpC4OGXan8bxMbNl7Mv3MAw6/5fkhNV4AH2xpqXDDrWYo7dk42V+5S6qj+n6nGP+NT + Gm723Y/aa1qBVaPmUhl9xHZQ9ipX1ARDabutjA3AK3Xk/mKWgbxMwJhx/wCKGAKhjCusGlHQL8agiUMV + T+IVGtWX4/cKU9B5+p/qVuanLrwE4I95ToPdMbFPRxdRZmp2YAv/AAiHYd0w618wmk9ToTd0QXMOtgMX + DpQDiFOnxCvocdygFYJcaSIByv8Acai8P3K6NU2F9HzDuBnvRhzNaHDisjBhlmFwHdpbBFMFKW3ctSte + Si3p/HbyGUKaXBKmkLE3AsaEvLjcRLvFdok61trEIrpbaMi6N8xWSrq9OvchO4lkKyU8u0SdwAY6Wjs9 + cDuNB+GNOxgd84/IH0cOTs7M5QQtJzYRZ2ae2pWazMueU/A3GwObaBqkE5yF+IC0lOgnYfhSX8jyOdcs + UOy33m8yldP5O8uvUYXg9zdxuBS91EwG2G7rQ58hJlwuLu8H8TyzIS4DQdkm2D9PzHiNmyv3UsQbc7Kw + ZIDI1lrp/wCwbSqjOXvoodwZZV+zOZnrF2QclUsYaJ1WajlMqrxC70nNR969QG9fIZ+nU+5gyA1WHms+ + xNF73X2St+uCnK7Xr/LADLTcqZMXcrWZhNpS+OjY/wAQVZcP0la1p05jlPIYLZsFMia+swRtEu8xlenk + 3bqhqYus3xWm08tB5EeYmWGBYc8Q80X+YkX+v8SpqVz18xarYxRmu7GRAGq3bFdvLiBtso6RsqquVGtA + GZVJl0TJ+6lumZWIP+VyFqllAXyE6eLcRVFJNDfdv1K/KP5X/VoY7nH5o/bDFxe6nuw7VPuCcFXFBGyG + Jba0y2fSijd3bH4kZK1K6agZfkNQ675WIbfILYNsDsB/LOeDwoZFUWjkq4PEYqFjXMHwD1O1CeCZ1B5u + HQuFmCAOKhNZXHEpUAZUuUhehfBcVVLYhXPdnfhDB9Ra6+8TbvCN85p9zBrnoRRAi0/zKhXVWQtQlSfa + yLQvfrMS1ZOkTeul4llohWrK8QAUWbcF674O3Y6FM3EVfN9L5/uVEIhWdHY9yriCzYVaxQN5z7lKsFrJ + HLQkFPa3z4giqNTIe45Jls1ugythzWMdpTDTSx4zqUL1owe+XpwOuEgHmlMQ4zg+bO5Ai6rIFvyLeSyP + 5srZGAbFt4vN+IkcGiDoIa8QRgdGRdw744Sxh5VVdKGmup8RNb0K3v0Mf7EfOtawzylU/mV8bQcPbtGj + ZspKufXzUCtd4X0PMIWo2/1r6qKO+iqd81fwSEZ2w3jJiM6xMmyBEE4Fv0dkGPUNaFvSrVX3HAEtfAGc + IpwmRmIy9/8AZleWecyzXTVUmoW3vYWmC5pDvR4Odx20uR/kCWVppG51tCn2SrDfRV96mPbc1x8afUoV + p1JUVL00xwiC8nDFZlcvBnUU2mnmv99QtLBZvyOj4nALni/CdbzWklBMgE/UzjFYckDHSuoDKOtcsKKL + vdkGU9HYmQ7zNxNTqMLZVuAxA++cSptX5IxUxi6X/mWpkKw56/p8SowrBMFdCHrUwI7HkpwSXtr1DAdo + mE3BmV0/tCGaAPiO4/UeHUCuqBt0ugg+YABOeAur/Eri3ddKIbvpB4nSg2HQ1nEvOrsvf/ALntiopFtW + bg26XqVspjBCV1hIQEw95+M85WU6XKe5g6ZjgzEDs+Y31V1qE3S/5FmB7XT8LloZTj9VG0s1Yj9iK102 + s/Bjr2B9TpKur7JXyh4oOKjxQqMVwIL8LBXyQb+WFF3YsPxCMaaAR9XUcKs0faIyqjN03bpsfBVXGQHF + FgeSelRDRal+WKRsEPMusrEzY2JkzurlVK3QhpUwDvMToBlndderHyhjNB7lSqQAqV5nIVjPwGIjbq0V + 9RmgLbc7TLfMJlGpDPstnZNdo1GvYCE4Rp5+YA2zhLHVl1x37ynS1a6fZz+ZobGHSKaZZB3UMyhnAjCF + 6C2ilKezmMzWzBJbTkexf3NgJOmK/Jw5hluywJLrMoDToARkoloJbQaFdL1pd470XKPzp7RqM7OQXs/8 + +o/odq2H5Px2hOsNty/VT4cyvwLwR7Xs+YFkGKFL4m7Xwtn0XDzLXXQrU7ux9kA2tgQ+enuLmtaUb8kO + ElIh/uOs2bt9qoSlPAqfqGC1Y55li07qnfplNgTHSENCxxKQa8BQ4hpt0INPRXK/WYFWwlfA4HKKDiuu + GyoLiTuga9kAAw4c1vLJ6fUylvnDp4dQqBjPLsvmABcEBuMUuIoKgg5QL3ZiJPZK+Y/WVbWDHO+Mx2Fv + HjlI0ZWRBwlXC6BrrhhrybpxMFNrCCyvHMWxZjnhmBKWw5QiYhQnVZZWFExaxDfeGKK6dDFQrzRFpr1H + muuJyZLYd/4EZ1JeJbv8YXHLbLXjO/3OYArkxYaPgEcRDy5laVQMcJ1nEqDKuEYGDMTH/atZ1Y6Duk/L + LIzDFz3wS0G+6/alI+ifUT/HaL2dLE/oL8zHC3h/VSaw3n4TKFtFwIHahEHvP2oGe0ufzCuB3r8TICbm + 6w4wTGE8MJVho7BO4gHHEILoxBjRKJn8RwuOkQdYSZxWYNOvV223jns42Qqb2JYOoynxFbMnSOBrRIPB + Y7t4N7Do8wSLZHZLq+jAHLUg1XeBcGM3p5qWYtiWuX/dNQ7K3K0gUs8XDR8VE5abr8xjd1BsKzjmXABo + flHK7ogSV5GLzddYlrPBpKNzDVq7t10iJLBO9ScD3KYmS3PmqstHYs+dzYpRZ4WqVhuCptAakDJ0R6RA + xtyF5Rsu2R1MwbgdpIvCnycxjixSX8Ho/Tce9g7RVj8PuMaVVVd6zKdzPmXdsAAez/RibT6Jv/a8xlFY + QbIWK3gDyNPsghl1hHz/ACPU6/QfUJs9yr9gwx4BBkD8RtKW14XuR+6DqtDqwdiyVIlJ6lekVhbuc08b + haTPbBdvBfuFYnQuGAHQ0c1Bpb5ca+ev+zABECnmFWGjL3YDBU4Mn1iBkFmcA8lz6joqYC31KCoir8Ac + F8V+GNW0zg6i2QeSPB1hu4oiREdWRwCOVayFECg0N4Ns8ksVhCeFhjs0nEa6VcGoi1YX48wcLIxK7LG7 + zsYAK8JQDUODtC4h7KkDdHSB17AlFIQ+E1FlXmZ5OZnJYZ2r/gP3LmdqVjzh+5hilLmpQ733l9briK1h + 8jqZoihrd8p6jK71KuLEJUqBqgqMkNI0KU77jPYUYDKW+jktxGwckEfFCLViztOjfjcA0NQAYyhoCAzn + HiZTQ56w6ui+kodEcPSGHvPx3l73mLwYd9oZLf8Ag97hjVy1tjTGKpGxfU6nU9kCCZKwOkeZSWEBb2ic + SHO/CYLC1lpGaFIqVp/3eCazgTB1TRMj7PxAitjGOjMsV5eIXZxcObhQfmJ1GiKyUblC/uzQ1wvB61ub + TRnxNxC1uBuvENE/4IbQ6ylenWi0ekoCZBnSS3Dt8oFAaXbOSzfTT5mxGQSqt9YPGzk5lzcm6V+Q/wAg + yxCuEMdCwruWRY6zm56b2fcQjFC16IC/VwylUZ4eWhPj43AyVLD4D4x3hrNKs2tzDg10FDtWmBqrQESk + jJAwtdtblEuEoB1l0+kBl5Z+Ws/FkUwQ99zOEC+T+JZpN/7hL6OwmT3A1vAx8mkXZI4YhI0DAWoLQKYc + 1AMgpkMfz82RSuhpbUHBbRiZRwuCjal8ZrGKqJRQVrknqk9Ss5DgvwMh3iLxQfeafslcFYlJYvUc99Z1 + LAWCIDlxTDM4i4qnlbj7mIrDV3SPeM506cvcJRKy8gdIDGkbhf6Z31VW4a4ldBC1wwUtntBFKneOIOnY + S4Ocvx1gmqDDzkvwfcrrEoCYJmITKTcbp3LCvcCuKE+0FLIbQHOscTl6TlrWOwU/BHUf+ZRyYdht/ExH + Vfgl/wDs868yjPTqXKWhbhCADonE64hKnLOJiaIfMzNVHaXN6xvpN7uBNkpoVFMacMsbiZldJWRqV8QO + +J3AdxTqRdlMvNbRNaD3G+0arPMSqc8KuIBD5gUanZLyEQYR5RVa3k7dT4g6mF7B0j0mTEyCYYjTVcjp + iAa8oEuF5FiDAwUxofbMNJde8TmDJ57SuKsHrGAunPMo2YxMFai0V5gtSgAd9EWj/hGNqM7vMtEqMVxw + +oaHoPwTQ5tTMbKzavmXOFNo7zmo9UvZNDs2QOFhRm0B5a2+BqN9CBaDoNPCj0YPNzZEp6Da7MoyEBhB + q8p6Ey5NFBXRdo82OGtHGXDgm+ZYE7eIlZrFrqXeh7moBBcNhe1jnziJBbV26XX7zLmp4FfLbjrLH5gX + LYyeMRASiiJ1Hidexio7DHse4wFGcO9KcejMG4fBNs+bJEYp4z/D7iZqx4U1Y6+meI2AC7OXQvJj1MHw + +iNJ7M53HX5ksy3Th6VQ94uhCXD4bPlgAUCmmGPGWTKhdF3WO1dKgKGBOk5DCL0vcsPIm1qW2FU3d+CU + O8FKV9xTT4viU0oySqXp4onNwzjjiqrmqst9dZ0xFt4T09Li1r8ioRgMtNMbRHp0YAUvcWMYp8ytNfzm + IxtXVikCa+hHvl+KlaYlRghr/wAMPBl5ot+swK4iCI3Y94qIKgB09KFiBW0/L+Y6l5hGzhaHwfuVrgAJ + xMGg4IyJoV4i4A15GK9zj/4WJXFwhNsITG346ZhnIg3TfuZSOHj5jFGMnETANmMy7MS97hnNm5nrEtlV + 0mTu7PEfmJcfiV4lKxAzYXOGpASy0+Y1WMyzpDY0EPEbGypR+2JVp/i+XGZcL89g6jG2ZbVwA2NvXszJ + WPOdncGkhR6VW6i8PaCOAt0PH5j6FJiyvjrL1WG2oNYlGGdbWS+uYSx3aLKzEFYj+yJmU6DYqGreidBY + E+w8bgS3VL9sGVYbs/qNjhFtUL8ryDdkVfJ2gJmVnm1WT0QbOhqM9BwimFLTF8ZrrG6YUxLcoW35v1FC + I3mVoNCAaIuBCG5NLNf1ERlEBg1pKBPcB0ye8o/O4t5UZWla3TvGozwDgaSHuFSkvjnpKg1X1DCwmRup + THXLrB8h4bO01Y+nAuml/PaZWoc9Ri8Ct4s+JnMIoSw7Ds/HaDndw6+hTXQr3H1jY3fcHXL5W4VnDipj + hhz/AORq0OibuNU7QtnWnXqWUANnAu2qxceFjKgwtqOQ2tjidMBRSNmaTq2idYZW4Am4gVdhd2Ad9x3G + GEQZapKb6uOkFnBZRLTyLo8SnIloJ6WY+4GiUyGz4iCy4nXpXEQnG6puzxK5miCaZfVDBAYUBUUFZ5nQ + hO+oRZcCvCAe8/bCOqgTsATXM46UHnA+2VpMhfe3+ovmMvENLC9Zyq19EuEX1+WUB2dCG2V9QCF1ivVP + /h6zf71/x/6UFsDqJTA4sxG8Dh+JUW1WUcj6lHT5lmkOb9SqMy0p/wBqfKJTzBXWJp1CHy0MbdHwxFYF + 9Slf5RNcIr0/1G8Zp1mOlRZp6ztNbWV3mEbv8QeSPDzHCt42189B6mn7gaps7H++pxExxEb34javogPN + dE4i3BKzkYvcdqadFl8Ge0EGK6gYsO2NQ0K6rpBR80azCNOoa7wVutUDbUtg5dPKLVc2am3M4R65mQBQ + e81HNL8Si+m4au6Y9eeTpLpcE/cSiKti48ZTYOPwPJ29xtxMVTJRvg0Vk6cwOb1NsVmlKp63EIJk2fIL + n1maRlTiA96qFJcvJYfHUYdLF0eHh5zKsH4KfjMtgg+V9j+IN7Ti5z3uDK+urle5bug+5beb2JR/JhAg + cYl6SC2a+nL0ZdFxLuXjj7+YKFLER8JhhuAeyMFxkz+ZYU2blvriN+BDQgLaHY4EepkHSUNYuXAuPFYi + YTXAbQeAFAdhz0fZUBZuNA5grNwPPEWrpGzpqwSsVfGZZcQAdXntDdJvAsFqiiU6ynTzmtsag2JkHUcF + 4skGm7iWUGcKbHh40VL1vONnbMynAYByjvOoEBLJapV8PiXMg/cDRV3lExCzARFNVnPTrGpArJKccE67 + J8Rj+qWPFxTvHU0MTGJR9A/NxZcU3h+IaxLQqGesKAKBZ0xEvf8A08zmrd+OsogMu8KPuWd5eYsWLiYD + D2wShvpiq8MprBjvEzlwysyuhqWIxmIfN66R7XfiVRq2UtavURdsaYtjRk+cwQDtGqxUoCa3MMXuI5Js + wZ/1QMdIIOjnpESxh9wghzM7ExHg+YZYjsq5n/k2vDo/nniH71kwjyJwnSZZmH7J+5YVFQdfiPSErJZ5 + TB93x/7d/nrCrogsjyRMFSXcwGnXXmMK9rtjVbhz3do9bWYd4+vnjF70ZV5U5ti4gpjf8E6TMi2vjmXA + QtDODUBFDt32evMSs1haffCeZX4LguH728ylpyhLaDJezedc1MuPqTKdcaY2dIaTsrmLCqo7OvaHpQ2k + SnRp78eYPpcH6IrV9SnvGJLVkn3HhfMNtI1Wvqc+jUGoYHgjJHdUMa3znfiGI3tjF0gxRsuEHJH5CePZ + TCdW83fJv7E1EOCPFnPZzK0p3tyiyvCMz0eaqz4g+ean7kK97AU+peFHg3M7IPRIYBPZAiE0uL0RsXhQ + RK4qvq5i4+7+SgZVRZk6xirWIG9eF94DCwWG+q4mY/3bgdqgg/bA6h0ob9wmCgFEP+hGA+Y0UOvSI44M + GlEPtGNx4mLcQLKvcoH7SgDQV8S45liVQWXXtV1u0y2XaRFOCcFh0ggzXqNUgYOjxPPbFXDC41+Vcp4G + bHR3T5Z+Kha5sMryuZeafQsFbQvBC/lJZmDxQfQxVdMbBnrh9TSMmgB2ur+4a6UpVfBH91qiN21TOwI5 + 2QNWURL544JZVxKHiOA8ONcygIodoy7qOetRLesT1PPVnaKCF5gi236gOqGDgiVv4iZvPmXLZ+YjxAXV + +5vk9SrImAIlVL6GZ2Dr2ejHesw4QNHDn4jkxAJOoFBJazh6Tm44st6jh9nvEk22hz4Hx9yl2l47xFrv + 9qYegO25VNLs7csSuVRzv+4hCi4EzFr6ypgXL8R4HclTBw41iKzvBR1H+Ytt1S68SmZyJrCbp4eYCnb1 + sXjmLZwjkePM5CFYs8PEvirN1wVWDd3yeYCUNEVbHPTbjMwCV8aYrLk1YYf5lg0rC08dPmsy2ge3G/r9 + XBttTSGdvTxxMB6aSUUaLpslpUbvk9RLRaPWHSBk4whXgDzSOmE6QoJfK3/EIMfYMtDSX1h8ClmHf+H4 + mJ/YZH5D2Q8w6TBqydNIwLIwdD3Mm8IOa6f+VOPWSNPhmc1ms7L4IB3BVWvuqlEsegfWWUyL17rzQ+pR + p5Vh9AqVF0FUhrzuAx0JRDbAd2WVLwJc17FEFgfRFWTtD+EszOhogzzKFumrx6Iodg6w89lnSx/ATmtS + 9y/uWFi+fDG3i3dQ33l8QA5uPncyt1D9gmUA+z9RUev7G/qXtHcAwPyuOEGUEl3QxKFtsD7gEHdNEt26 + +oXmkAoK8b+Zlks0pYfxC8KI5pxKtpnSBAFITFxKHaw6kdmwsluMVDLpJXkvvLBM3uGOV8/uKG8QDqUH + vfuX2Zm9B7iNufqW7W8eYBgrGo06wMlQBN5m2ZRXSY18zgNJpi4hMSS84qL4uUNq9zmB8ZlAIlZKgvKm + II8CaTtK/HQtlfremy/DAsxG2LMsOkOhz0LmMUiKf1up1HcFh2mL9irr6WUEbqjuXAUrazL2ctvOYqGj + RzD9towVz+oXLCPJNinD+JwNoJgCwxRDA6esy1FCUDEFaFlRaMhbAXW/Mty204Ri1BO60v8AMwNt4gQY + 5Go0eR3TqfuPVDpfyEFdyRVVrAW4Bc8RWS7WO6H6hoZjsw+Hj8RLCWWlI2qjAdyVhApDjDq8l6HZGU7F + WLGeXLtKWmQFagOfaMuNmnTEuxAyeHv2lBRdd5QLZk4eguCWNi+G4NYnQfuVqPtQOC/5mBQix5h/C95U + dS0+48+yzvMiA6MwRt1MkvU3QYVDtYBfc7CEIfUo6Sp9hDLCxdiKwB5blRoPbERY32HPtmDBu5U+InKn + TFCBsd2LfuABorpURWiXpMMVC2005/JYJQBaChdOy+O8G26ZnWAR7UH8y59f861eTv8ApNPFFi8fcXca + 4K94oZrjmW+/GItTw0WekyTFBs0/DmKVxtD8qfqDXFYoq9qCOgCLwtQiflqU6PiA0sdV4FhUCLBa0OBz + W+sxD0nvdI3jEvJpIBwwAM/1FAkPgNBvPJ4gbsNZtvfmVBFNgPuOrgFAjvKtk6dI5ouIHDmPliZYAgWn + MyGT7lRVEoNWzBsQIlZuDf8AcaziO1l07/mUzFTULf1KzH/GYGS3iNzAugEWEQRTwBvBKXa+pl1b3zKw + qvUc9agCIMtWGWkYNUA8IhnudT9SuYlzYMT+2MqqVhGGfwAYamw0O7j8ahplDdPeYZmWCNaIIuqS9cMa + w3w+V6L+4ZNAqOuDpN5jty+CJDYXMdG2H3u87N4jYAqhtPqzz7zBOQsBp8JAAHY9RuK3HCy+sE5efh/G + ZeqlqsCPNbo0GCXxINCC1lq+e3aJQqwas3mzjzMfBpB4GUpGvr3VFhrJrxCdxS1uXoep5loqN3Q+IdqH + AAeg16iy5WXdy82cb1UroxAMtTDRWzdEzFYaJyTObyMTDY6mT+ppradY7Da6YzMrMjsmSGFpslLtzx1P + cHAQLqs6Drow32jCyjj+piq7uQRW123C489mGeRxdRvfSFHyzon7rfqD7p0xRq+4OX5ZYYjAq4F9QKy+ + 1+UGfir+LhKyAzILriOKVl27aK8Yi3lhtXPQo+0/UHOpeJcwO7uen9ygzSfUtqLmogbV0OIBeTp3jggO + GcRhCg0yue0uUSbwD8/MqeVmr5aIGrUSAqooTa9ian3zIm+tbm4K9sUINuBbkqsStubBpRxpwoohIaGi + qPCuIKAAGYKOKIUaAl8R0YhE23cxZPespyTOeF6lWVxEgY5ihjZmIoeOJgwX4jWaKlXAdE5nPNRIoUZp + S70rieE8zLmnqNLambavjOYNDRFa4al/7mIL0fqXgqHEucZi3UHPbcQkcUpEyZJijjmg9T8jnZ0lWfuV + 10xAT4igtr6MCBVDYOSuSXMAS3y+Ts5hb30BXMXSUsz3nF5iU7vvLawDKbo8QBoKnk0128RvBt4zzL3z + wTOwYwmeDSsZBaxKRuxGJ26YBXjELQx3iOMG2dwa/CKpWYgRraYJtMzRw7dd2W/3kfs5/PeNo0A2LkU3 + jGcneO0xqQlpko1WT4iArbFucjEysdkQuqAmHlZb0z2NJkLeKlDdBNj8ksMKDVOPTx7hN1b0cD9PkjuC + KxsrEojGxizK84zqF14JVCKOmoYtkdDHxBrF40nXmLEyzZnhU0XAWqum37HaEUwp3XsYfdMpIiYweeny + gapN056LfLLcCMp+KMwRXvJe9Qt5dVH8rAltvSWfgZS+3P2kaFZ/pdz4hGfgEvwFOV/cQta9XMQVFWPM + Y86I0rVd81iPoKkFGS9eEir0gY0fACx90pLtx/cNz5g8R4+xl0y/wRu9f8DKyFfG45ctioiFGPmEuoBg + 1mnvDjrAilj0q0LUwDiD3lwcagIJsLtPP/FFQ8zH6wICJYkxhLfw9T/dJeMR8XH0JSnEMiLHB/Mamav8 + ztb1HxeWKzYOpTe0oxjHViA6nUVcHAKvZ0ekp3uU8jiYozF4LqZHtFzHMEbPEKjQ1zFzmX5mXiVKacSv + cfTwr1FACqXAV8H5eZV7lTBfCKAqeGE0jD5loSi/dCvLRk5qKYMAU2DdyjfkZ8CypT4zBV7Tau8xUDB4 + 1NHUc5YqzsHNbJi3dsNhTJcrWIs5IC8CzKYrxFrmYu1e0Fq3VuJe33BqPMuJnnOH1zLhnVOg/UYvFUBm + 1XSvNcQr3g4dMs2jGd3HWCYEaTB27e5YVhDNH5hK4T0yr/3EIgRNJ3/nWc1KuVbDxz6hyuOxU5pat964 + ga2LZ6IWUeu0ymGhfMRHZEXZA9JhrLu6gjQX0IoRScnUj4bUMdi6JfWl5q37lIXYxuAsJjGagu6+C2LU + 92c4yvMuFqDUAwlkB8usqg49RXJi+2I4TxcLNpAM1RLr3C1k3wAfqPHmM+pJ8qv3Bpq/dPyS/E3FT5A9 + kP7l/wDQGjCvFfmexZ0gIbSxJ9IafmUt2B3HzLSOxTt4MsexnTNfiZXSQoLJ9wldN1db8AqMSloDkvcO + ASQ63cHB0qDNEM2rANxLJrG9KIGVUtrryRs6BfXMaKSHYlmEe6h2SLXW4YppjyXis3FQ8fuJjf8AcTnV + xZqorZmNvMtmowvnh/U2ii26dy7gZxUVb1PdzzE9ktQW335gc/ucdIMc1mJuHqKlhqR2h8wpJcEdvR+X + mVcqWa3ERp47QSIXWOrsy2xIpnT4PchlxNuxtkea6S4GyoaDN4FzAKof0gpzUV6NYvBL0YLNFWr3/MFp + uvCJfG4wxU1XgNeZ2dal2LrEYy4SvMqnptcNC0UZg25nN9I1w4p7mbkAwnRWH84g3DS5cdb5D4jFAd+u + hh8b6krsUsUfyfzFMlmaVJ+NvUzMyg7CBtw3QcuMamPycZW3WQjaqDwh/sQlYpdUt8OmGsQo3fPxN4bN + YmlQhWc8TnsQsVFRRhkOIisd0G+TVmGICgHgNkpDUrkZudQVguInnv3mpdl6SDbVlvmGamK4lMQw2x8R + SnAOr3qHWaXwT1LdwZviIlaPUPAQoxapc4KliyLEYF0zsN/qDrqlHicRYio8R3xdca4KfqX1hLi1vLuj + cVH4gbxbMSuxxrHMNUziVyqwA0rVuvMJtnIXQdSqjJjaEr55j0FrH8oWCzY4wdMRX1yG/UsrPqFTVFTG + Cg1TRjKOnEHMrOYyOXJoEsbzFzDPzLxjM30xkS25aZ1NIrjn9z/ai1dXCqAvvDoKrDGfEU0vaE6RD1M5 + LYPaANJmLT+5YYtBuoCd+ekX/mvMvM5/UMognMcKjk5jEcA4E6U46HnzK7VElxEabeiYQ+i8kTF5pZBs + i0qZEw9RjubqumsxMGG19oB8RdB3iVCAOoS+zD3d4ANaHjiWzKtRxGWarFwcTmjmvzO7pwhYO8G4R7NV + mZo6ATdddWMh37ecSmzrdf79fEFfz1T6X3KZTC5eW/Iv8nePdDqz5rnzMK4vhyMKoCJSQunI05F/uAaA + CbLyLoPAfMEwuT+sGqFMCzKAGHk371CcimStnSAJU1RbHkgc2TLxgryQbDc4LFbun5ngOR3AvpeMzCC3 + vEZV/hcr5ATpXk6ljKOshmYtLXbfiBSWdBHr3gv78tV/aL5ZhSnGyYeBWjlcA9luYD2itqUTmwOwB+5g + UGAog4INQH8Gw6DKFq2D9wfEuLiYFPoiWdtblHR5mAYMq5gZzNkFRAEqCcxLSuM1l/ULYhNIEWMoQsVp + cB3bieeTAay47XEiRsHSuFfxLwGsAW3ixcDKa+pQUKtnaLJNzLZH1UC4aFgnEth2lv0HB6Me5mGOdy0O + 8GSqciMbVvMBygRWbPB0nRaKzAHu4jb+pUo9eGWFSkX4gA7NC9kFljY6ahuonrtLNucdYgPVlhXEe0N1 + xACVvmLTXSC81Gjs95X/ABLOh/ERDo+4BTIjpVUxTJFKUpzXh+vTlz1n0xIaeIkxr8x9c87amsXVmVW7 + 4ZTx+4zlpPEptXAZuqiWxRBkLcPqClcpl1Tga4lbY/uZMYYzZwn8yuOOIY03xjiMxwUV3jaC1dGPMtAM + 6xOO3iN5zLN99LZTYcqhfnf4mZwa1n/33mCsoN4W+ePfmnvKIEoum/3/AHT3hkGUID+TxceY1LaIMzix + 3KU9o4YJo7+4rVdSEKvMIyU6qLuz/MuKw1Wn4iimV5pLGdhNU8uzxKoe+NWfyRqUDVh+oKbSlOQxnPNc + ZhGQjN7BmzAX0ZfTAxlvA1vcXlAvoOl++It2BwtfcxRV3GVw40+VR8QmrheFXLnQ7zlgqLPrMsFgdyj7 + lBjDoFy+8qleveabjCxSB8IWmsYxMA6s35So6Kr+j4iismpdQAbNWg/crfuYMvEMsxfSs6g13v1Bb63i + WLO66GSZaneZJC+cg12vTEEQHPo647+Ytk6lyNlVKxXoDVZv5uBuXuRy933BlKUq+kXsbukB6zDKogXd + BqGyIFaqZuMqlYHMvCsvEd+IHaMzBfOJm9NTNPGJnGfiKiUB0cxLi/MCvEreZYOkrNxxjrFc5S6dYmGC + lrsyltZl1/MW0zUFui6hd5l44uaEKWWS2N45qAZKrfS4Dg+Zjx3l5/MHxFcpZBJhQrjtKA+y4Oj9Oi1p + 6jElmJVojhgo06cS8AsP+NkohWjgq7a61HtQjkaI9GWjjD2lWVaB9w3TgPULWcOo5zx2IAr5u3UqbScd + Z4B5mrl4SgcZ825S2b/cybt/UyXruybegd3AYQ4b4/T9w0erMcf7yS06qbvgx9fJHNiyHPH8e7PE0YtN + 1ij/AHk8S9SOdDqDSdnEG+kFAW2ah3MkVjeA+QZrufUepodbw9pRAWDeeRklhqKQmvGznkz2YYLkQtKw + o1ddkX8SuKgch1B5IF5OC2k7jM6e5VPs5lXA4XYfxFsPF/jvDmAbz06ShyDJMr56QS9s5+avTg7eY5tV + WnMINgd6qbODbWah26zrCWO1xcLTXGM/MaspdZ4jLu1O8EhtNC61Yw+Nykap3YFM9MrrcMWFrU5esxea + is80DtQH7i3m4sxY1S7DjoZ/Uw9VJ9f8uP3LYfliLwo85gL88EDzgC43PT+P+WaUHdYhdP3S7lCuK6Gp + VYjXaYuDLizM7M08QaAWrPMLu3e4Zx1g2m6ibs/mVJ0Q5vrEuHK6uBWzPmAISzTHhI6Msxf9xCkeKCCb + YsjxjEeLLua5uPRHuWrvqi42LcrlxBUOcMQtrY98QC7uAF5iZ3OOO8LjAOnoy1Vm/wDYlqdId5XeMrUp + JUKkeekeY3GfET4Dx4g2FOK3wxL7OoIKOL5Eug2UGB5DtiVqB9GH0cb48vR7xOlQGdSnRTQw77Sz4kIO + b34gC607zF5wYmvVJak8RossVbWnvG7+6BWYEVBlxqcFv8xLe1xqc3ao6WCVM/jP+6QI4W1Sbf8Ae4Lc + Xd3vnt/XxKXXls7eP18RVhSmyn8dPXxMgALVlP4/8h0LaWv8+z4lb1VNLzs9wfl/DK9dXgz5n8kyduXZ + zKjr0Yuyxhog8dDsyyDRB1hrCXQxQxihr04hhQ3nB3jHIFPlfCaZdAKhXB71hjIp3AK9EzAk1giHW2Zz + hi+J3fxOYbqwEJEM8hAsoPVwTK05h5u8sMaf+Qym/wA3NFpIWDq4zAKrxImULB2XMwyukXdiA+6uIqG2 + ivG7g3e1ZpFzc5mo8l7NgfuVArAS5m4wyorydoC3ROnSYMYT7liOFeX3LC4yQo8xeIz0iARytR9xZeZc + vmIcWqY5GjDLCEpqDkZjuYIkolHSAIRErcGBd9evENg4GdbDpiUOC2K+ItNaVgXnF9OsAbwd4fQp0zOr + MaDr4hLU4SzUdKmTGIidVGBaIi0w95RNpi3Ayq5fo4nqfzLL1DlCxCCRUviGulCEI0o5SKOrtk8L5+PE + MkIRGxHSPSVcNJqDIKGnNWF+4jLMaZSLHT+cTxYwBOl8kGMamyJvuS05NNHE8JGzTPEzXRUA1169Ig5J + pj/fUPaFYOy8DxDHSgjxiLh346SreF7O55blMmC+YwDoA/7+ZdqsHwf710YXlYwm4WSqv5v+fzmLfUL5 + v/fMVNzdvK/p+PcoOKx4B7dF+4CjefB/Z9kG2sG3Ti8a8mJjK9CF+PlkzMg9xaXg3Ps4lmMzRgcIYDL1 + Cru6lq2cUyGv5FRwAThAXCVY3g6xceuD+Os20fmoq4m88vfMwZV37lWnH7l988XM2r/yMg3nTcSDa7t9 + 2JbM1pmYC66xz5rHzMjiBL01gJQLRKtnVmKCQx9MMKtbVPW6imUHG4tlsE31FihvtEnRwTApgXUHOjqz + Lle2VPHe5kSxGZ5dbnZE1cXi4pLOZSlvENPBqz8wptJwn3CoqqOHB9WwvS6NqfP6JlxXmU9ofZDSa5lJ + hvEs63HNrmbzWZddJvjEQLC8ZZUxg6LiuS8CI+B9zqBvjEqboXu3AoMUQc2t8xMwC2ROekQhbwsDlvxC + BNur6xJcFw7ndXSZ+GYN3nc2xhOYxwOTvBWrlIaz5lrxWenETe18xEKgXlZnCbiBFPxGlvTWqX76zjjk + Q1OI2B0j0Y6xBYrRJ3H+PvAH7iNMVGTh1JZnslgn3KTdsDoobOGOWNP8RGngPECl1F9kIqzPFwUZMQGm + jvp/usVEaOReAMRsAbyZsYU53mIueDTMsnLKYAVCrLO5/UQbeRW/7/2IHQPFcf19RS0xThoK/wB67kFU + w4zeROj/AH6YKzlqZBr5/wDesblCgW8dr/n5mLnIsT8415MRbpxbnX3RryfEcvUemb7435M9pkasfd/p + 90wZ+UVYHa9oxjEHnJQhzcvI99Tq4YFfyMoZUGqXk651cuwOKzzBiy2GOKWUDUM866zhTirKgl5cBxLi + kCGyy3MdYKrrLuAA2A7wfUZgEHS7uuVxBhrMocUUSujC9QXAkQHUCn5qYIoFEQ+AlOFVetQcREvKbtYM + vjH8zA3LtlypmlB5SiCJRjWtwfjNcMBcornMAI2eoFG2iviXR37xBtAG3iM0/wBKL8GZdCTv18tRR0IU + T6ms7Pb7XDKa5cJ4KrEU7pf6/MqwdYyfyuABgK4NQ08q64hClLgo02rJxyw0nN7loeoxKnqRDMcJxDZX + 7FsQPz9fiJ1Bzlc3DRpXaUkV71Fzl7TjzMirqocsEzn+ZTXLrE0FfKDimhZUWcue0BdbrtEhqqgt2D+f + +RRYXcrQYebqFdgr2oikETvllA+HCdIaO4NOx7QKiEqOVVPml5qF13jZHzKx2ttvV1HGyE/8TsHUqbZZ + vOf1xAxLjP8A5DBZIuaE2pY4CUE68JAWIsZnkv8AGKlDdhSJxUyZ4h3zKVKxyTHZmvqCnWTT3B0i3vaJ + cBblv+plzdnvwnmZPGzbqEh1sqcVY5N38/2e4rxUe+n5/wB0Yl3ntfX/AHh8xZFWHHHn/wA9kTkFGr4/ + 3qagayHOP95ha0aAMV+7PsiQYjsOfJX5PZBaNZyYv3j8mTpKU6p3i7/l7lMcDq6pntnD4ckwNZgcp26+ + n1EAUyQs6Xk+GMkMHNv8m5o2X0gUBmu/MMoXXR9TgWHe8MC6Q3DG84xU2BWeIy4azLqtjNOTt/5A1nJB + HLC61Z3hwEaOINYNRhyRg8RlzmzWw13lzuZj47TcaS4zgzBKNL6mnpFnY4vxMIf2R/4pxUUdof7snwMK + W2c8S1qtwT6HEHt71lluwWA09WfmH8rugY8gv3BMebWq/P6lEgXrd+JpkmKSVMgX3zFLoD1CL0RHGzpH + HAY5lGF71DXR5zBbplxlApmAeGu8HOd+J2YuC44X8xbLop2kHGcQflOrZGf7l1iMlxLLxEU84hWqQ7m7 + 1FOXPeWA1mLqjEBCjuS1B37JalJmJhJ7txy0nnBLVdt9WIjQ7BmdzfLAyCl3KDKQywOIlxngeYUglrUH + iG4THFSrIuJkYL4hM24bVolZVc9jr7ENOO2sUKPOYN9oxZhJVpXHBa5DzA7xBnl6glX5NpXDmdZXA0Vy + cbiuFVxhRxDQYwEoFmQ56oROCv5m3TEYA0NHFseQNHDh8QX1law+v6fUAcMUa0fivrxEsHJr/Xj0+mAL + oduW/wCfOe7AVLztxf8AvfaMRQWot/l4+4VWN9l/7w1Mwylmel9TrrjPmDfc581+a7Uxcl9xf8PokGx5 + 0sbvt/amHFQg1SLRWuvpzM7BVrYvvau+YTEA52A3+YLMXw5dwTDvEtWQubGaeI2DjN6nPa+niUWcnebx + q1+o07t1v3OxW4rn/cyhADziMNVypVYKVvnMR+qI9rMvhVYzgL5vZ0mAu0WGPfVdNdCLjgizjxLeN1FZ + ylfuWYUi0Nwq8QiEI47rR/cAF1ZMEX9SrNIi2TtUptWurCj+kM7a8xpWz5qFcr5j1qjsEF633ZubD4uc + Cqyk0Wwi6XxGCVUOpA5ZgVaX/HJ9wCh1rzAFNmqnzCpSiyC8/Ebp3+I2oXfqVyVTmFWdPqUHS4jXaBvK + e+ZUbgrSewJbkh3V9QPRXYlGDPmWYhWP8wJQv3FihnqYlq4O8Xr9RqljvEp4H4gccTQKsiGCbg2fzKDm + k4esADhmV0iBxFfEq0xGxKzjEcnLpl+oLDbhFLsXoFvZtGDZS8BHlGxOR/4L/wCF1YSzNHTBMHUvDGVh + d43ASXo674/p7cfcwg04OsJ4wF1DArA+MwmLnRaw7EGF7TONIbXB3l1oo3rT/uYGHp16dv8AZihns11/ + 38kzl21h294Ts+o7JoUHP++cnFyzReLGcnxn2Rqhe77fw+q9QCq2cPN/z430ZkWAt83/AD4afMby7EBr + P/rzTGl1tTNN9u/hyS4GQmy+NdfnPSEwGzmm3sQfeYTDPho94gWh+5+F+YVise5dtlGMy8uPUus3xcb4 + wQK8B2WIHAwJ0hgdHFc95ki2w2gfzELDAacVAmE/mW4NAE8RYyFRsV2zxUc0W3lSvHEwHNztJ/dsWjiD + LbczcK+x3AqKoWTHEM7xMEQNu+nBbdwxwagnA63LW7igNrh5Bt6xqdQRbcl94mQcvQgWT2cxc1VdiYkp + fOJc2H3GrJU6sCGj1KkClSpaB7hhsc1AHMA9aUw0dY4ibf8AiGRsiq1fggnM56QCN6cJHeqVg7QphMdY + GzwAWTTQOM7hdaesRHCvduYQrHaLyKiHDA7UxExDZLACwhw4zLtcNfUcb6HxE5eASUa2cw2q8QUUGQzB + 9DMFMYfMPdk4dUzFO5nxD4zzEmkX0Fww3XzhF3CDslraXywehBIImRj7Ljpnnu6MulWHxzg4fzxMRK7x + +UQyblFL7hpc1x0ee0MNGR/I8RdzeHgP5RjQD8DiWjGDPm5ncW8Su1YzmYdCwfmAJNUtDKIq8Gdf3B1L + KbLx39fXiVkTusvb/fzCaV18H+/sjJ5QVvsg5PHqI2ayLbH9fFMAkOmc3/uNkWnHF/gz+/mUMZ3bs9M/ + h9Mpw7r57Z/DnvBkUttjGc6z+H5lFKsGLLTOuvrfSUaCOtG/dn4uC7cHI3ePj4mMIVeIA6sLzywLcErn + cChVvpHfNc81M31hkTDzjid5UMG6ge4mLUniYxq7EBGAc8zOJdGLj549CLHBHlaasNxXMjksUBa+fqUX + zDd+hcF1aIPTBX8xl+IOP4jZsozwV+4QDFAg6luo0Js9qXcUVFzVHmZcnqXiOgyd5e+TeCoWrgJWWbn2 + iu/gQRWPN3EVVB2CZ0FRy8DzKyKWEPD7iVgxB1fuZMx0dypeg9QscCQzT9REgszmPfsNNQ3FCxuoJsfB + Fq/lzMhDWKxDVD3My+sca7Rrd4lUKo2aqCeYWW+YUs6ldl3fiWIMu5367iGVZ3q4jfXrMe0aUyQc1jBm + FM4zGhdp3hBa6mEBvtHnA3bxLNRsN1Z0jRgHSiX2KvNwB8dpp1M4xUrr+Y9hjmW5i8Nqa6zfAU1trSH0 + 7NwBRqPSj26OmcRCDklmTEfZfwjgS/PjuR0AFIlidElyCopvmsOjxHZHWjYNneaj9xVVefMOAlYQOa1d + eMRCkwWv/wBPzcRvI8Z7/wC99LlWXgViv9+uxuXUKrGHBz/i/TxMFaaHCYcd/wCpt0K3zWef4fmZjYoM + 3Se6s92S8MFYXRnXj7GWOlUDodM68OHiIF8ab57N/h9My4pOQ59Z34fTMUc4dX9/slctku9/nb8QWycd + VfzDZd1Gh0X+YO7D+52s36hq6q+OkS8XqGV235gLT6ltupzCrUAuDkNByQunW9RKgnDHPinErvqPclFY + yk+qlbVAR0HxMuM3nXKz6TZOYOWtJ5V/Uycd4Jz0nlDaaFi79AezB0MwyBpxbUKtiFWUh0gXq7zAuMHa + odq+ImmRYANnlxFcFHiZOV7uoJ29S1tYIqjtia8BDjLiDogDoRGCYcVGTxSqFDOUcxBFiRaNaW34/wB0 + gLr17jVdpasKJk6wEsvrFziWhs/ELN45mAy9RS8ZNzww9ouDRcQ7kSgcZxAFz7O8DarvpMWUs5IMFOtn + McC4CL0yaSNnCr3W5uM55mGseCbF3iUhEDZUG5wGHXvFXEVahnX1Os5i3G62HiHb3h3gzArE9XlByMw9 + AZhOp1XD85icdInz/wAMStyhbOSZQt7I/wDackGxDRTB6L8MR89GpP6iNaayFxSbUTKgDWHAcJ0/37iK + Gh5w8f714lFrvddx/N/fmYO1N5/38damAVChvGOvTzfxAbBhOlb63+yBc1jqUuPfbXxAUpY66n6Pw81H + C1Za8nH+Uxs7KwmkvinXhxBV6DjpXzrw46MCXW5qm1102fNkqICheEfot9yoeVyYT8wXis46TOTV78Rp + K09Zizx6hpbwQu7qVTlSRxzFcnVUZYHJ2WWgmeCV3Oleo3hfhtqFGYl7kDo3M8kTS6vNR1pzASxdx4gC + RHNe5p3qPqaTmAdHwCOtS69za5lq1B71UPi3uA151VRfb5zAW53viACudbnSP4isnHQuWZR9ys5DPBDd + 0cwA0TAcEp8dpQ6QcdekalGI7QPKwhxBcjBA1u7kVrq7x2JinWZcNVSY/MCjKZ/DHF3s3nmAUarzMXuK + 3KLJ0lO2YTmKWXxKOtS724qDXGKuUTWp4r1NvECgaImg/REnJ53LCU9yrPwmmS/uJwVf7mB47S13qC9O + YsHLKsf9Uq0w4ZQJw8JVYGGPHEcwydY7olTmW94qxFj3R5dR6jyRWR9+E/D22eMxOkSckLB3Bvqv3K0A + 5qBA0Uzw8JgEqH9Pc7RqQPZfVfrZHAAr0yyasoGOUsS3PFfL+Zkq7Her/u/9mUbqIlYbK89PrxMVuxxw + jf8AvfmC6i6FGq8V+pWwFCnHBxWL8fE1YZTZkX1/70jSMliiZzy/7Jzcpoq8XuqP968S0NsANV4vXhw8 + TAoUqzVA9O7s4eIaSrF4pMdKenaJOsBZSpn4JQQrDgg51TLpwY12nGL8zSU+5eruYY/qXp1XMu5QOAZq + VhyVKpXdPffSC2bWyKXYI9cXBCD+1EY6sGiNX9Fe4QuDE/CW+RAo6i/oYVDVDUzjt/cdhii1gQSnKc5v + /hKTiW+wD22/RO2pWLhTr3FdU7R7XHMEba6ksZbrU+Jh0zO5iUYRmUer6gmlM+QJrkxhxr3PaRa+4YRX + X1BfAB1ioC3gfMC6XnTP8zq5gLS+oLAUUxRW+79f7lUYz6iYbLauuZQFhkxuIbbxEOekTxUc9TEaj3lu + musRjGeZRaEMxmBb14uCMAGNw88VBjXDAKNjClMY6y9hjcM5eWbCFwVYc3KTrW5gWj3DK4NExjzh7zA0 + P12gVcp5NxMaI6xgIlNbmNm4lul9RyEo/M2w/RNJ9ih6j+oCUfXET7eX4SvjtAfUF3LzOolgUTU0GiTq + 9aHV5gODzsXCOx7ksCZyaJ1cnxuJiaWEpK48wqpbYf7TEvMVitH++PEy6ytrjr+f35mWrocV16ar66Jq + WvqhQxnO/wA+HEujR8nLWun6ejLNqpbdn8/v5JdVOat6/wC9nFwc23uq+5/PySgOgFFVp/H48TICUUUz + 0CdO3wwscbdke/jxkjUWe6V83/CbLVwG3RUKxk18Ttp4gQKMcE4qtcQ6DXFal5r8cRNlduqnLrcbCGe5 + xGotI2m/US3oxwJdlnmi4WXq7C6t80lV3iouekswknKh8f8AqEK0Ar1F0i9GZ8q8eaqWS13yg11hL30i + ONpVbig/LKLxQIAFVvmVNCvzLl3xAbXmWXGFL9amRm8+pasiq1uoHuyhdNkulOF4+I0xnREeWnWCwNAO + pbk/UdtqEcLCboriFCtsyfkI4hVLU4zXibzxHWddogloanmvG6/qFaHEHDGsdTtLOuGLkVkHaDOM4uoF + nRxXEFUH7gK5LjahmGqahdlLqWUqXHA6f5jSVSXAU5vMTk45YNuUMqc+4NnPaFygVziD1bYM5qt4jC1z + uMXFsCxWtnWU21Md7hhiEWDXxFbQgKXsgBxKPEJS7iLBcVeSGKQaTowjTIJ/R7dPHJGJmYJ7LjqyXUHu + YWfi/wCahFQnDDz2JLCaAZty1TUIdHKquvx/uZkFI2VD7DyfqYZG3OMlY64vxBvAZ4P9/t9YTOUvg1X+ + 7TJKObVVVf8AupAJgVb0PP8AZjqQNXg0E2dP610ZYOFVdZbOOv78wlsC83262fk9kNTCnXX8H09ohWoG + FXfXH+fMBeqV1f5W2+4K4jzAy3f8xut0aOhMYriBvBDWexYvn10g0dkyHK8+Z0POotXRnnEIBZqLVjg5 + YIPMtmrYSjjZ2gAnjPzMgBdBfNRyB6wYUbnrlr9RxbY4g82F3tlPGgwyxcXmH9zC7Ds6K3L5i6wA1mDY + oGcMRgW/cpNzCrfFEOLaQT43mN3qHloC6AGbZc1lAFXjiVRipUgHiPVUmRauOMR1MkqrmXHZTYA5XlhC + oK2rVS1F9Tb6jXM1apH6s9OT9xytVlvmGU6bmanY4lcNQX2vjrFIcC/On9RKOVsLiH2qCg9vjpASzJ/c + Vzrc3RqUYzFLxm4CXdXE6mulyl2r8QA4XiAR+PEAqiDiZVjfogtRs6wS7rtLKoCFbhk6M6VvpF0rJxBv + GbgvBu5g0oujBRXPGJhWCsVgZoU9RrpqA5aikv5mN3dRblyjzBDYDAuTmGivkl4Fj9B0D4ejzznaU5w9 + K/4hU9ky90Z7PsRhik2cf1BBdVgjJseEeRwwAv5St9A3eDjqG4tHaqFfw9TDfEsIocwUwl6p2H9xSk3p + oa/3QvrV6hShRUlP++s9pcwKx5X/AD/skrQ0G6f7/PmHKXzXT50fjxDFpWarp0P6fTBybear/OPk7xir + Uy3ruJ+fkgtH6cHfD+SUtg52PzRiCiFauoClRM3Nb+ZWQrXPMLznqymIGDqfNw6Go0dYxV1Fsa6HTDAN + jN6YmUBPipkCxVX1gr01NBRVPXPP+1HPEXKhaPgrM2UjsZvNzr0rPVxZi56TTOIyKn67+5wfQS4PSLLx + BZ1St4KIfc//2Q== + + + \ No newline at end of file diff --git a/ProjectSellPC/ProjectSellPC/Forms/Products/ProductForm.Designer.cs b/ProjectSellPC/ProjectSellPC/Forms/Products/ProductForm.Designer.cs new file mode 100644 index 0000000..1992879 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Products/ProductForm.Designer.cs @@ -0,0 +1,103 @@ +namespace ProjectSellPC +{ + 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.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"; + StartPosition = FormStartPosition.CenterScreen; + 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/ProjectSellPC/ProjectSellPC/Forms/Products/ProductForm.cs b/ProjectSellPC/ProjectSellPC/Forms/Products/ProductForm.cs new file mode 100644 index 0000000..ee5e8a0 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Products/ProductForm.cs @@ -0,0 +1,101 @@ +using ProjectSellPC.Repos; +using Unity; + +namespace ProjectSellPC +{ + 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/ProjectSellPC/ProjectSellPC/Forms/Products/ProductForm.resx b/ProjectSellPC/ProjectSellPC/Forms/Products/ProductForm.resx new file mode 100644 index 0000000..8b2ff64 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Products/ProductForm.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ProjectSellPC/ProjectSellPC/Forms/Products/ProductSettingsForm.Designer.cs b/ProjectSellPC/ProjectSellPC/Forms/Products/ProductSettingsForm.Designer.cs new file mode 100644 index 0000000..dc51adb --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Products/ProductSettingsForm.Designer.cs @@ -0,0 +1,157 @@ +namespace ProjectSellPC +{ + 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"; + StartPosition = FormStartPosition.CenterScreen; + 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/ProjectSellPC/ProjectSellPC/Forms/Products/ProductSettingsForm.cs b/ProjectSellPC/ProjectSellPC/Forms/Products/ProductSettingsForm.cs new file mode 100644 index 0000000..7dab4b9 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Products/ProductSettingsForm.cs @@ -0,0 +1,104 @@ +using ProjectSellPC.Entites; +using ProjectSellPC.Entites.Enums; +using ProjectSellPC.Repos; + +namespace ProjectSellPC +{ + 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/ProjectSellPC/ProjectSellPC/Forms/Products/ProductSettingsForm.resx b/ProjectSellPC/ProjectSellPC/Forms/Products/ProductSettingsForm.resx new file mode 100644 index 0000000..8b2ff64 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Products/ProductSettingsForm.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseForm.Designer.cs b/ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseForm.Designer.cs new file mode 100644 index 0000000..e1ad4a4 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseForm.Designer.cs @@ -0,0 +1,90 @@ +namespace ProjectSellPC.Forms.ProductsOnWarehouse +{ + partial class ProductsOnWarehouseForm + { + /// + /// 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.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; + // + // ProductsOnWarehouseForm + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(1064, 450); + Controls.Add(editButton); + Controls.Add(addButton); + Controls.Add(productsDataGridView); + Name = "ProductsOnWarehouseForm"; + StartPosition = FormStartPosition.CenterScreen; + Text = "Товары на складе"; + Load += ProductsOnWarehouse_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/ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseForm.cs b/ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseForm.cs new file mode 100644 index 0000000..f7ba94a --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseForm.cs @@ -0,0 +1,80 @@ +using ProjectSellPC.Repos; +using Unity; + +namespace ProjectSellPC.Forms.ProductsOnWarehouse +{ + public partial class ProductsOnWarehouseForm : Form + { + private readonly IUnityContainer _container; + private readonly IProductOnWarehouseRepository _productOnWarehouseRepository; + + public ProductsOnWarehouseForm(IUnityContainer unityContainer, IProductOnWarehouseRepository productOnWarehouseRepository) + { + InitializeComponent(); + + _container = unityContainer ?? throw new ArgumentNullException(nameof(unityContainer)); + _productOnWarehouseRepository = productOnWarehouseRepository ?? throw new ArgumentNullException(nameof(productOnWarehouseRepository)); + } + + private void ProductsOnWarehouse_Load(object sender, EventArgs e) + { + try + { + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void LoadList() => productsDataGridView.DataSource = _productOnWarehouseRepository.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/ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseForm.resx b/ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseForm.resx new file mode 100644 index 0000000..8b2ff64 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseForm.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseSettingsForm.Designer.cs b/ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseSettingsForm.Designer.cs new file mode 100644 index 0000000..d1368d3 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseSettingsForm.Designer.cs @@ -0,0 +1,134 @@ +namespace ProjectSellPC.Forms.ProductsOnWarehouse +{ + partial class ProductsOnWarehouseSettingsForm + { + /// + /// 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(); + WarehouseCombobox = 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; + // + // WarehouseCombobox + // + WarehouseCombobox.FormattingEnabled = true; + WarehouseCombobox.Location = new Point(155, 46); + WarehouseCombobox.Name = "WarehouseCombobox"; + WarehouseCombobox.Size = new Size(151, 28); + WarehouseCombobox.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; + // + // ProductsOnWarehouseSettingsForm + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(411, 216); + Controls.Add(saveButton); + Controls.Add(WarehouseCombobox); + Controls.Add(label1); + Controls.Add(productCombobox); + Controls.Add(label4); + Controls.Add(label3); + Controls.Add(countNumeric); + Name = "ProductsOnWarehouseSettingsForm"; + StartPosition = FormStartPosition.CenterScreen; + Text = "Продукт на складе..."; + Load += ProductsOnWarehouseSettingsForm_Load; + ((System.ComponentModel.ISupportInitialize)countNumeric).EndInit(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private ComboBox productCombobox; + private Label label4; + private Label label3; + private NumericUpDown countNumeric; + private ComboBox WarehouseCombobox; + private Label label1; + private Button saveButton; + } +} \ No newline at end of file diff --git a/ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseSettingsForm.cs b/ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseSettingsForm.cs new file mode 100644 index 0000000..a569bf9 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseSettingsForm.cs @@ -0,0 +1,101 @@ +using ProjectSellPC.Entites; +using ProjectSellPC.Repos; + +namespace ProjectSellPC.Forms.ProductsOnWarehouse +{ + public partial class ProductsOnWarehouseSettingsForm : Form + { + private readonly IProductOnWarehouseRepository _productOnWarehouseRepository; + private readonly IProductRepository _productRepository; + private readonly IWarehouseRepository _WarehouseRepository; + + private int? _recordId; + + public int Id + { + set + { + try + { + var record = _productOnWarehouseRepository.Read(value); + if (record == null) + { + throw new InvalidDataException("Record not found"); + } + + productCombobox.SelectedItem = record.Product; + WarehouseCombobox.SelectedItem = record.Warehouse; + countNumeric.Value = record.Count; + _recordId = value; + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке данных", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + } + + public ProductsOnWarehouseSettingsForm( + IProductOnWarehouseRepository productOnWarehouseRepository, + IProductRepository productRepository, + IWarehouseRepository WarehouseRepository) + { + InitializeComponent(); + + _productOnWarehouseRepository = productOnWarehouseRepository ?? throw new ArgumentNullException(nameof(productOnWarehouseRepository)); + _productRepository = productRepository ?? throw new ArgumentNullException(nameof(productRepository)); + _WarehouseRepository = WarehouseRepository ?? throw new ArgumentNullException(nameof(WarehouseRepository)); + + LoadComboboxes(); + } + private void ProductsOnWarehouseSettingsForm_Load(object sender, EventArgs e) + { + + } + private void LoadComboboxes() + { + productCombobox.DataSource = _productRepository.ReadAll().ToList(); + productCombobox.DisplayMember = "Name"; + productCombobox.ValueMember = "Id"; + + WarehouseCombobox.DataSource = _WarehouseRepository.ReadAll().ToList(); + WarehouseCombobox.DisplayMember = "Name"; + WarehouseCombobox.ValueMember = "Id"; + } + + private void saveButton_Click(object sender, EventArgs e) + { + try + { + if (productCombobox.SelectedItem == null || WarehouseCombobox.SelectedItem == null || countNumeric.Value < 1) + { + throw new Exception("Заполните все поля"); + } + + var selectedProduct = (Product)productCombobox.SelectedItem; + var selectedWarehouse = (Entites.Warehouse)WarehouseCombobox.SelectedItem; + var count = (int)countNumeric.Value; + + if (_recordId.HasValue) + { + _productOnWarehouseRepository.Update(CreateProductOnWarehouse(_recordId.Value, selectedProduct, selectedWarehouse, count)); + } + else + { + _productOnWarehouseRepository.Create(CreateProductOnWarehouse(0, selectedProduct, selectedWarehouse, count)); + } + + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при сохранении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private Entites.ProductsOnWarehouse CreateProductOnWarehouse(int id, Product product, Entites.Warehouse Warehouse, int count) + { + return Entites.ProductsOnWarehouse.CreateEntity(id, product, Warehouse, count); + } + } +} diff --git a/ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseSettingsForm.resx b/ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseSettingsForm.resx new file mode 100644 index 0000000..8b2ff64 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/ProductsOnWarehouse/ProductsOnWarehouseSettingsForm.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseForm.Designer.cs b/ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseForm.Designer.cs new file mode 100644 index 0000000..f646f01 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseForm.Designer.cs @@ -0,0 +1,103 @@ +namespace ProjectSellPC.Forms.Warehouse +{ + partial class WarehouseForm + { + /// + /// 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(); + WarehousesDataGridView = new DataGridView(); + ((System.ComponentModel.ISupportInitialize)WarehousesDataGridView).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; + // + // WarehousesDataGridView + // + WarehousesDataGridView.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left; + WarehousesDataGridView.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + WarehousesDataGridView.Location = new Point(12, 12); + WarehousesDataGridView.Name = "WarehousesDataGridView"; + WarehousesDataGridView.RowHeadersWidth = 51; + WarehousesDataGridView.Size = new Size(851, 416); + WarehousesDataGridView.TabIndex = 8; + // + // WarehouseForm + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(1058, 440); + Controls.Add(deleteButton); + Controls.Add(editButton); + Controls.Add(addButton); + Controls.Add(WarehousesDataGridView); + Name = "WarehouseForm"; + StartPosition = FormStartPosition.CenterScreen; + Text = "Склады"; + Load += WarehouseForm_Load; + ((System.ComponentModel.ISupportInitialize)WarehousesDataGridView).EndInit(); + ResumeLayout(false); + } + + #endregion + + private Button deleteButton; + private Button editButton; + private Button addButton; + private DataGridView WarehousesDataGridView; + } +} \ No newline at end of file diff --git a/ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseForm.cs b/ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseForm.cs new file mode 100644 index 0000000..785dc90 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseForm.cs @@ -0,0 +1,102 @@ + +using ProjectSellPC.Repos; +using Unity; + +namespace ProjectSellPC.Forms.Warehouse +{ + public partial class WarehouseForm : Form + { + private readonly IUnityContainer _container; + private readonly IWarehouseRepository _repository; + + public WarehouseForm(IUnityContainer unityContainer, IWarehouseRepository repository) + { + InitializeComponent(); + + _container = unityContainer ?? throw new ArgumentNullException(nameof(unityContainer)); + _repository = repository ?? throw new ArgumentNullException(nameof(_repository)); + } + + private void WarehouseForm_Load(object sender, EventArgs e) + { + try + { + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + private void LoadList() => WarehousesDataGridView.DataSource = _repository.ReadAll(); + + private bool TryGetIdentifierFromSelectedRow(out int id) + { + id = 0; + if (WarehousesDataGridView.SelectedRows.Count < 1) + { + MessageBox.Show("Нет выбранной записи", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error); + return false; + } + + id = Convert.ToInt32(WarehousesDataGridView.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/ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseForm.resx b/ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseForm.resx new file mode 100644 index 0000000..8b2ff64 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseForm.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseSettingsForm.Designer.cs b/ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseSettingsForm.Designer.cs new file mode 100644 index 0000000..74fef48 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseSettingsForm.Designer.cs @@ -0,0 +1,110 @@ +namespace ProjectSellPC.Forms.Warehouse +{ + partial class WarehouseSettingsForm + { + /// + /// 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; + // + // WarehouseSettingsForm + // + 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 = "WarehouseSettingsForm"; + StartPosition = FormStartPosition.CenterScreen; + Text = "Настройки склада"; + Load += WarehouseFormSettings_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/ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseSettingsForm.cs b/ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseSettingsForm.cs new file mode 100644 index 0000000..3115cdb --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseSettingsForm.cs @@ -0,0 +1,80 @@ +using ProjectSellPC.Repos; + + +namespace ProjectSellPC.Forms.Warehouse +{ + public partial class WarehouseSettingsForm : Form + { + private readonly IWarehouseRepository _repository; + + private int? _WarehouseID; + + public int Id + { + set + { + try + { + var Warehouse = _repository.Read(value); + if (Warehouse != null) + { + throw new InvalidDataException(nameof(Warehouse)); + } + adressTextbox.Text = Warehouse.Adress; + sizeNumeric.Value = Warehouse.Size; + _WarehouseID = value; + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при данных", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + } + } + + public WarehouseSettingsForm(IWarehouseRepository repository) + { + InitializeComponent(); + _repository = repository ?? throw new ArgumentNullException(nameof(repository)); + + } + + private void WarehouseFormSettings_Load(object sender, EventArgs e) + { + + } + + private void saveButton_Click(object sender, EventArgs e) + { + try + { + if (string.IsNullOrWhiteSpace(adressTextbox.Text)) + { + throw new Exception("Имеются незаполненные поля"); + } + + if (_WarehouseID.HasValue) + { + + _repository.Update(CreateWarehouse(_WarehouseID.Value)); + } + else + { + + _repository.Update(CreateWarehouse(0)); + } + + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при сохранении", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + private Entites.Warehouse CreateWarehouse(int id) + { + return Entites.Warehouse.CreateEntity(id, (int)sizeNumeric.Value, adressTextbox.Text); + } + } +} diff --git a/ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseSettingsForm.resx b/ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseSettingsForm.resx new file mode 100644 index 0000000..8b2ff64 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Forms/Warehouse/WarehouseSettingsForm.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ProjectSellPC/ProjectSellPC/Program.cs b/ProjectSellPC/ProjectSellPC/Program.cs index 69f4ab8..bddecaf 100644 --- a/ProjectSellPC/ProjectSellPC/Program.cs +++ b/ProjectSellPC/ProjectSellPC/Program.cs @@ -1,3 +1,8 @@ +using ProjectSellPC.Repos; +using ProjectSellPC.Repos.Impements; +using Unity; +using Unity.Lifetime; + namespace ProjectSellPC { internal static class Program @@ -8,10 +13,20 @@ namespace ProjectSellPC [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/ProjectSellPC/ProjectSellPC/ProjectSellPC.csproj b/ProjectSellPC/ProjectSellPC/ProjectSellPC.csproj index 663fdb8..894afcd 100644 --- a/ProjectSellPC/ProjectSellPC/ProjectSellPC.csproj +++ b/ProjectSellPC/ProjectSellPC/ProjectSellPC.csproj @@ -8,4 +8,8 @@ enable + + + + \ No newline at end of file diff --git a/ProjectSellPC/ProjectSellPC/Properties/Resources.Designer.cs b/ProjectSellPC/ProjectSellPC/Properties/Resources.Designer.cs new file mode 100644 index 0000000..c718db4 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// Этот код создан программой. +// Исполняемая версия:4.0.30319.42000 +// +// Изменения в этом файле могут привести к неправильной работе и будут потеряны в случае +// повторной генерации кода. +// +//------------------------------------------------------------------------------ + +namespace ProjectSellPC.Properties { + using System; + + + /// + /// Класс ресурса со строгой типизацией для поиска локализованных строк и т.д. + /// + // Этот класс создан автоматически классом StronglyTypedResourceBuilder + // с помощью такого средства, как ResGen или Visual Studio. + // Чтобы добавить или удалить член, измените файл .ResX и снова запустите ResGen + // с параметром /str или перестройте свой проект VS. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Возвращает кэшированный экземпляр ResourceManager, использованный этим классом. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("ProjectSellPC.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Перезаписывает свойство CurrentUICulture текущего потока для всех + /// обращений к ресурсу с помощью этого класса ресурса со строгой типизацией. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + } +} diff --git a/ProjectSellPC/ProjectSellPC/Form1.resx b/ProjectSellPC/ProjectSellPC/Properties/Resources.resx similarity index 100% rename from ProjectSellPC/ProjectSellPC/Form1.resx rename to ProjectSellPC/ProjectSellPC/Properties/Resources.resx diff --git a/ProjectSellPC/ProjectSellPC/Repos/IChequeRepository.cs b/ProjectSellPC/ProjectSellPC/Repos/IChequeRepository.cs new file mode 100644 index 0000000..29d6181 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Repos/IChequeRepository.cs @@ -0,0 +1,11 @@ +using ProjectSellPC.Entites; + +namespace ProjectSellPC.Repos +{ + public interface IChequeRepository + { + IEnumerable ReadAll(); + Cheque Read(int id); + void Create(Cheque Cheque); + } +} diff --git a/ProjectSellPC/ProjectSellPC/Repos/IClientRepository.cs b/ProjectSellPC/ProjectSellPC/Repos/IClientRepository.cs new file mode 100644 index 0000000..896c0c6 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Repos/IClientRepository.cs @@ -0,0 +1,13 @@ +using ProjectSellPC.Entites; + +namespace ProjectSellPC.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/ProjectSellPC/ProjectSellPC/Repos/IProductOnWarehouseRepository.cs b/ProjectSellPC/ProjectSellPC/Repos/IProductOnWarehouseRepository.cs new file mode 100644 index 0000000..c59dc63 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Repos/IProductOnWarehouseRepository.cs @@ -0,0 +1,11 @@ +using ProjectSellPC.Entites; +namespace ProjectSellPC.Repos +{ + public interface IProductOnWarehouseRepository + { + IEnumerable ReadAll(); + ProductsOnWarehouse Read(int id); + void Create(ProductsOnWarehouse ps); + ProductsOnWarehouse Update(ProductsOnWarehouse Warehouse); + } +} diff --git a/ProjectSellPC/ProjectSellPC/Repos/IProductRepository.cs b/ProjectSellPC/ProjectSellPC/Repos/IProductRepository.cs new file mode 100644 index 0000000..05246c0 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Repos/IProductRepository.cs @@ -0,0 +1,13 @@ +using ProjectSellPC.Entites; + +namespace ProjectSellPC.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/ProjectSellPC/ProjectSellPC/Repos/IWarehouseRepository.cs b/ProjectSellPC/ProjectSellPC/Repos/IWarehouseRepository.cs new file mode 100644 index 0000000..d027940 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Repos/IWarehouseRepository.cs @@ -0,0 +1,13 @@ +using ProjectSellPC.Entites; + +namespace ProjectSellPC.Repos +{ + public interface IWarehouseRepository + { + IEnumerable ReadAll(); + Warehouse Read(int id); + void Create(Warehouse Warehouse); + Warehouse Update(Warehouse Warehouse); + void Delete(int id); + } +} diff --git a/ProjectSellPC/ProjectSellPC/Repos/Impements/CheckRepo.cs b/ProjectSellPC/ProjectSellPC/Repos/Impements/CheckRepo.cs new file mode 100644 index 0000000..f1b27b1 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Repos/Impements/CheckRepo.cs @@ -0,0 +1,23 @@ +using ProjectSellPC.Entites; + +namespace ProjectSellPC.Repos.Impements +{ + public class ChequeRepo : IChequeRepository + { + + public void Create(Cheque Cheque) + { + + } + + public Cheque Read(int id) + { + return Cheque.CreateEntity(0, new List(), new Client(), DateTime.Now); + } + + public IEnumerable ReadAll() + { + return new List(); + } + } +} diff --git a/ProjectSellPC/ProjectSellPC/Repos/Impements/ClientRepo.cs b/ProjectSellPC/ProjectSellPC/Repos/Impements/ClientRepo.cs new file mode 100644 index 0000000..b574a05 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Repos/Impements/ClientRepo.cs @@ -0,0 +1,33 @@ +using ProjectSellPC.Entites; +using ProjectSellPC.Entites.Enums; + +namespace ProjectSellPC.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/ProjectSellPC/ProjectSellPC/Repos/Impements/ProductRepo.cs b/ProjectSellPC/ProjectSellPC/Repos/Impements/ProductRepo.cs new file mode 100644 index 0000000..20a25c8 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Repos/Impements/ProductRepo.cs @@ -0,0 +1,33 @@ +using ProjectSellPC.Entites; +using ProjectSellPC.Entites.Enums; + +namespace ProjectSellPC.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/ProjectSellPC/ProjectSellPC/Repos/Impements/ProductsOnStorageRepo.cs b/ProjectSellPC/ProjectSellPC/Repos/Impements/ProductsOnStorageRepo.cs new file mode 100644 index 0000000..6fb537d --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Repos/Impements/ProductsOnStorageRepo.cs @@ -0,0 +1,27 @@ +using ProjectSellPC.Entites; + +namespace ProjectSellPC.Repos.Impements +{ + public class ProductsOnWarehouseRepo : IProductOnWarehouseRepository + { + public void Create(ProductsOnWarehouse ps) + { + + } + + public ProductsOnWarehouse Read(int id) + { + return ProductsOnWarehouse.CreateEntity(0, new Product(), new Warehouse(), 0); + } + + public IEnumerable ReadAll() + { + return new List(); + } + + public ProductsOnWarehouse Update(ProductsOnWarehouse Warehouse) + { + return ProductsOnWarehouse.CreateEntity(0, new Product(), new Warehouse(), 0); + } + } +} diff --git a/ProjectSellPC/ProjectSellPC/Repos/Impements/StorageRepo.cs b/ProjectSellPC/ProjectSellPC/Repos/Impements/StorageRepo.cs new file mode 100644 index 0000000..885f569 --- /dev/null +++ b/ProjectSellPC/ProjectSellPC/Repos/Impements/StorageRepo.cs @@ -0,0 +1,32 @@ +using ProjectSellPC.Entites; + +namespace ProjectSellPC.Repos.Impements +{ + public class WarehouseRepo: IWarehouseRepository + { + public void Create(Warehouse Warehouse) + { + + } + + public void Delete(int id) + { + + } + + public Warehouse Read(int id) + { + return Warehouse.CreateEntity(0, 0, string.Empty); + } + + public IEnumerable ReadAll() + { + return new List(); + } + + public Warehouse Update(Warehouse Warehouse) + { + return Warehouse.CreateEntity(0, 0, string.Empty); + } + } +} diff --git a/ProjectSellPC/ProjectSellPC/large_KPq-qORcEv8-1.jpg b/ProjectSellPC/ProjectSellPC/large_KPq-qORcEv8-1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..75f43851b49f6a33830d0fb8915ea04dff7c3eec GIT binary patch literal 103150 zcmb5VWpG?Q&?RhUW{#PeIWaSgnVBiZF*7rcnVFd>G4q(lOo^G}V?|1gLQ_M*U_--VL;o9vBKy!29{N9Z|2JTv zpkY4rMMV0Ll6*-12mf36(HaK!L;7zM3Jn$-3I+=n>*Lk7=Kq{6IO=sL_g zv=5M-E}!4LzB~|9g#B#{2sVVaw#xCkYnV75_ClYQHAxXfTE}pYcWn$WW^y?*V-Z0m zQ>hcqK02daOktowXB?$9P%NM>MOn@R=u5-n`8N1xJO)i9Uhw&u3%2leHorEsRXN$G z=Pe}ltZyFq1Sa<4%@^4grz$PJEZ!D|4sT4fCY&n3!-EW=Sy|$BwIG!)^u9TsqBkBp&KDm!GV)f#JPb_bAJN4=T*k}NU_E1lGhuqmEF#=+SD`)PEWT>>K}4Q zw0LS)!x!eVoZkKhy-4rzB}+M&BnzNhHWTp8ZbO=u`Pt1^lXA(*X=)JpD|Qfs6QQ&f zZE#D-95fh(7~+%Cag<|40Ss0OJh39Fx$e7#xErhM2W%S<*1S_6Rk$Ukj2ssaOxb`( zJ2bb^lQY}L#H9!S&ZiN;=+cD{Mv)`mVL4X4{_Xw&wFbN*;6YQ~Z*0ixxaYhKdC_Nlj57s`3ha^gILZY&=-InU z=YIp80|N%kd_{aCp&oO2jHLWzQ;%2Qu`XW*z<&okUL%__hh9QvmIT?R8*C zaKCIil_iY90dw2R8EmC5qZKCm3nxnj1!%(Ee1)Gxs!Olplq|qcuiu2(yS@4=m>cY#w{_K)fVMMT^PmJ3C#TbnS-&<5 z+c>YsP-6WzkQa}qy;fGSiLP$7d!YD)L?L;*i*S_$EZg0oyFp8lArLz%cxA$103gdl|{fp^Q+g0nZ?R=bnv#>p?Khoy?t3{K*p2)Nk=jMcA%4`N`tMiRxfH z3;OY+wcV}pdy48t z+06bWMq>Z@OeR2BCH*1E&v;kq%N3PtO947Sj@Xa`1Kghv+i|M-FxSUwzB{Qgi<70c z@MmV(#g=i{Il)&E|piM3cp~YT=9B z$CCeeLmFnxb*eTOU-*XXZtmDogp=Os^0|C&u)A}nBZy9aYw6ITVA5yy{04FAo31h$ z;wn&PeqeV^WyG(D5LNbCt!|>ZXXWH#Q7tdu6Mf#^UsM;7DDZQ}JgVqBMI^S|kH6ty z|F7cb7xaau5~nBnPSc!QzRN`}v5rNeZ$0nU3?1kT(pQCi^`m5(XnW6i&NB9mhBMyn2H@dg6xv;YR zav_+sG;4%j-$8K9-r!=sIo7)Kr*F4kul7y2{~uIf++WrHa%py)qg-KkG()$m(}7=PI5;t+nip2e`U`91`PyD zBsWZnXhBw%v^%h7yI}4WMSI~w@M#!eQPKOL3lh_H#ZT%8I`Xylsg8{%%qR5dc$d$t z9V+roqM;fX!TN7<@oz5oVCzUZmTW=)mteJ@tAhe-u(L7;21_21V2*$YzXspkt|<@Pss`NoUWI|}fZmb4#Mt~vTo28h zk-hnw8Ft~(dFA@+Xr5%lEar)wljeXKq3aD1qQam|MCX?mkEddBlY+P#O>*C$aM;>k zFOFg_USmuq6>J+6O?eAcvP<`QL{%6N6K4gT z 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

w+`i)V!?QQ2<7B#Y+>jX8cnd(8 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 z�JewywF91%^y+A-3@l=cG>+9Q838k9lsI>k*7+nMI)t#$a35i-Ir#jl<6s1~tO~ zqhktF80#-#jl(&4X2KT*SaWidt!`jiJ;N)5M8-Vf?=Un!U7%IUc{dXpBdlN|Q(KtX zxR&XCMiKT?3t~|o3TVejw67v;`(f;`HGV3dAj=!JZnU=1H71yS#>!NB} z`k_M^&i?>D9804|$;(>l`g$_Ws+QfK&+p`yRXMAA{{X$5TpZhbs{5bM$tVthQB|k$ z`0+9VQAIP*Cr;lCEOEDFd-(B^H5PlNeBbb!EnEiO6$-{pd`{YUfdY(hPAav;It_7J zmzw->6J>Vlr!Kb}2xqy(YAqvazfmpd#{ylJd7|NE>g+D9^GQ|SDlU3UFp_ei@&5p* zLbL+CMba-uXUe>Js+LP#@`GJrFMT37+Es2SKP;m0K!62S`IR&)^DbTS0k!5?afL6| zrbcf*rK=*VTc{rFp>)|Ul;L>zjWL}O9$IyRz|an*xj#|cY7xT1Zi?a*D{RU62;vn> zQ;gS%yzw1pU7`tSYI(04uj&<{#2hiKbvsKs;fs-32WT^l;_3yR99Ixk2krv7E;gZ< zYMO=FOQ~flTyQ#nn9@}xz*C#dPEI*s+mte=KH%BUXk4IIID^%;4CbqNj4gAx#l^5J zR^z^ThDO}uC1b8H#2dh8 zgZ=*BSWM+FgH`_RGDk@~aKllL60R$Jy7PMevj*y2|WL4B`|u}E+)&Y#puIa>>eeX0r%Z;p@>%%9v> zI^5kFlw&bV#%=;#)x_#+rOI8a@c=kpAQAZS0IDG3Wmw;$3sJMI67IW8Du9J<89Fni zZ=_u-ClGHLxGx6oVA6}D1r^U2m{tnKU}l9qM!ISPmZFmWW;b_HZd{|x5ZDY0lbC3) zl3oRm&~y)nqt7|oQ=C03{vlJ@GWSM%KEz>)O`LyFL3LOoCdY(%954d@Qn%1IcsS}C zi$`jqU&GYHd`k$S%oM_2sn~yUN=@mZulGXw)#?pi8+3dfcI06*-Kv@{#1 z`~3NbDSX#Yoga@7#ieGer$hREFmi3?tNi2S?-;97E$g_SpOOnl>A~L*G#yv761#y(>LjS&N>NOyV*se!KgeA3-h;NV4$-ol>`g Ih<(rh*_Cp6H~;_u literal 0 HcmV?d00001