From 0bd35aa6c1692fe8eee68b5655f8af4ce6619669 Mon Sep 17 00:00:00 2001 From: DelphyAlmond Date: Fri, 20 Dec 2024 20:09:17 +0400 Subject: [PATCH 1/4] 2(1/1). Forms created, base logic done --- .../LDBproj/AdditionalForms/BookF.Designer.cs | 190 + .../LDBproj/AdditionalForms/BookF.cs | 60 + .../LDBproj/AdditionalForms/BookF.resx | 120 + .../AdditionalForms/BookListF.Designer.cs | 134 + .../LDBproj/AdditionalForms/BookListF.cs | 96 + .../LDBproj/AdditionalForms/BookListF.resx | 120 + .../AdditionalForms/CustomerF.Designer.cs | 131 + .../LDBproj/AdditionalForms/CustomerF.cs | 59 + .../LDBproj/AdditionalForms/CustomerF.resx | 120 + .../AdditionalForms/CustomerListF.Designer.cs | 132 + .../LDBproj/AdditionalForms/CustomerListF.cs | 97 + .../AdditionalForms/CustomerListF.resx | 120 + .../AdditionalForms/EmployeeF.Designer.cs | 129 + .../LDBproj/AdditionalForms/EmployeeF.cs | 59 + .../LDBproj/AdditionalForms/EmployeeF.resx | 120 + .../AdditionalForms/EmployeesF.Designer.cs | 128 + .../LDBproj/AdditionalForms/EmployeesF.cs | 97 + .../LDBproj/AdditionalForms/EmployeesF.resx | 120 + .../OrderRegistrations.Designer.cs | 112 + .../AdditionalForms/OrderRegistrations.cs | 78 + .../AdditionalForms/OrderRegistrations.resx | 120 + .../AdditionalForms/RegOrder.Designer.cs | 188 + .../LDBproj/AdditionalForms/RegOrder.cs | 50 + .../LDBproj/AdditionalForms/RegOrder.resx | 126 + .../AdditionalForms/UpdateF.Designer.cs | 198 ++ .../LDBproj/AdditionalForms/UpdateF.cs | 35 + .../LDBproj/AdditionalForms/UpdateF.resx | 120 + .../AdditionalForms/UpdatesListF.Designer.cs | 112 + .../LDBproj/AdditionalForms/UpdatesListF.cs | 76 + .../LDBproj/AdditionalForms/UpdatesListF.resx | 120 + .../LDBproj/DBScript/TextCommands.txt | 201 ++ LibraryDBproject/LDBproj/Entities/Book.cs | 27 + .../LDBproj/Entities/CustomerCard.cs | 21 + .../LDBproj/Entities/Enums/BookStat.cs | 11 + .../LDBproj/Entities/Enums/Genres.cs | 19 + .../LDBproj/Entities/LibrarianCard.cs | 23 + LibraryDBproject/LDBproj/Entities/Order.cs | 27 + .../LDBproj/Entities/Registration.cs | 23 + LibraryDBproject/LDBproj/Entities/UpdateC.cs | 29 + .../LDBproj/LDBproject - Backup.csproj | 26 + .../{LDBproj.csproj => LDBproject.csproj} | 9 + LibraryDBproject/LDBproj/MainForm.Designer.cs | 147 +- LibraryDBproject/LDBproj/MainForm.cs | 80 +- LibraryDBproject/LDBproj/MainForm.resx | 3103 ++++++++++++++++- LibraryDBproject/LDBproj/Program.cs | 25 +- .../LDBproj/Properties/Resources.Designer.cs | 140 + .../LDBproj/Properties/Resources.resx | 145 + .../LDBproj/Repositories/IBookRep.cs | 16 + .../LDBproj/Repositories/ICustomerCardsRep.cs | 16 + .../LDBproj/Repositories/ILibrarianRep.cs | 16 + .../LDBproj/Repositories/IOrderRep.cs | 13 + .../LDBproj/Repositories/IUpdateRep.cs | 15 + .../Repositories/Implementations/BookR.cs | 33 + .../Implementations/CustomerCardR.cs | 28 + .../Implementations/LibrarianR.cs | 32 + .../Repositories/Implementations/OrderR.cs | 15 + .../Repositories/Implementations/UpdateR.cs | 28 + LibraryDBproject/LDBproj/RscImages/AddImg.png | Bin 0 -> 15037 bytes .../LDBproj/RscImages/BookListFrameCover.png | Bin 0 -> 94320 bytes LibraryDBproject/LDBproj/RscImages/DelImg.png | Bin 0 -> 15003 bytes .../LDBproj/RscImages/EmployeesFrameCover.png | Bin 0 -> 94636 bytes .../LDBproj/RscImages/OperationImg.png | Bin 0 -> 22778 bytes .../LDBproj/RscImages/ReadersFrameCover.png | Bin 0 -> 90140 bytes .../RscImages/RegistrationsFrameCover.png | Bin 0 -> 85848 bytes .../LDBproj/RscImages/UpdListFrameCover.png | Bin 0 -> 91031 bytes .../LDBproj/RscImages/WorkFrameCover.png | Bin 0 -> 131467 bytes LibraryDBproject/LibraryDBproject.sln | 2 +- 67 files changed, 7597 insertions(+), 40 deletions(-) create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/BookF.Designer.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/BookF.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/BookF.resx create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/BookListF.Designer.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/BookListF.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/BookListF.resx create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/CustomerF.Designer.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/CustomerF.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/CustomerF.resx create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/CustomerListF.Designer.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/CustomerListF.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/CustomerListF.resx create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/EmployeeF.Designer.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/EmployeeF.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/EmployeeF.resx create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/EmployeesF.Designer.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/EmployeesF.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/EmployeesF.resx create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.Designer.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.resx create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/RegOrder.Designer.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/RegOrder.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/RegOrder.resx create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/UpdateF.Designer.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/UpdateF.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/UpdateF.resx create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/UpdatesListF.Designer.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/UpdatesListF.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/UpdatesListF.resx create mode 100644 LibraryDBproject/LDBproj/DBScript/TextCommands.txt create mode 100644 LibraryDBproject/LDBproj/Entities/Book.cs create mode 100644 LibraryDBproject/LDBproj/Entities/CustomerCard.cs create mode 100644 LibraryDBproject/LDBproj/Entities/Enums/BookStat.cs create mode 100644 LibraryDBproject/LDBproj/Entities/Enums/Genres.cs create mode 100644 LibraryDBproject/LDBproj/Entities/LibrarianCard.cs create mode 100644 LibraryDBproject/LDBproj/Entities/Order.cs create mode 100644 LibraryDBproject/LDBproj/Entities/Registration.cs create mode 100644 LibraryDBproject/LDBproj/Entities/UpdateC.cs create mode 100644 LibraryDBproject/LDBproj/LDBproject - Backup.csproj rename LibraryDBproject/LDBproj/{LDBproj.csproj => LDBproject.csproj} (55%) create mode 100644 LibraryDBproject/LDBproj/Properties/Resources.Designer.cs create mode 100644 LibraryDBproject/LDBproj/Properties/Resources.resx create mode 100644 LibraryDBproject/LDBproj/Repositories/IBookRep.cs create mode 100644 LibraryDBproject/LDBproj/Repositories/ICustomerCardsRep.cs create mode 100644 LibraryDBproject/LDBproj/Repositories/ILibrarianRep.cs create mode 100644 LibraryDBproject/LDBproj/Repositories/IOrderRep.cs create mode 100644 LibraryDBproject/LDBproj/Repositories/IUpdateRep.cs create mode 100644 LibraryDBproject/LDBproj/Repositories/Implementations/BookR.cs create mode 100644 LibraryDBproject/LDBproj/Repositories/Implementations/CustomerCardR.cs create mode 100644 LibraryDBproject/LDBproj/Repositories/Implementations/LibrarianR.cs create mode 100644 LibraryDBproject/LDBproj/Repositories/Implementations/OrderR.cs create mode 100644 LibraryDBproject/LDBproj/Repositories/Implementations/UpdateR.cs create mode 100644 LibraryDBproject/LDBproj/RscImages/AddImg.png create mode 100644 LibraryDBproject/LDBproj/RscImages/BookListFrameCover.png create mode 100644 LibraryDBproject/LDBproj/RscImages/DelImg.png create mode 100644 LibraryDBproject/LDBproj/RscImages/EmployeesFrameCover.png create mode 100644 LibraryDBproject/LDBproj/RscImages/OperationImg.png create mode 100644 LibraryDBproject/LDBproj/RscImages/ReadersFrameCover.png create mode 100644 LibraryDBproject/LDBproj/RscImages/RegistrationsFrameCover.png create mode 100644 LibraryDBproject/LDBproj/RscImages/UpdListFrameCover.png create mode 100644 LibraryDBproject/LDBproj/RscImages/WorkFrameCover.png diff --git a/LibraryDBproject/LDBproj/AdditionalForms/BookF.Designer.cs b/LibraryDBproject/LDBproj/AdditionalForms/BookF.Designer.cs new file mode 100644 index 0000000..e6fc721 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/BookF.Designer.cs @@ -0,0 +1,190 @@ +namespace LDBproject.AdditionalForms +{ + partial class BookF + { + /// + /// 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() + { + Titlelabel = new Label(); + Authorlabel = new Label(); + PrintYlabel = new Label(); + Genrelabel = new Label(); + Statlabel = new Label(); + TitleTb = new TextBox(); + AuthorTb = new TextBox(); + YearNud = new NumericUpDown(); + SaveBtn = new Button(); + DiscardBtn = new Button(); + StatusCbox = new ComboBox(); + GenresChBoxList = new CheckedListBox(); + ((System.ComponentModel.ISupportInitialize)YearNud).BeginInit(); + SuspendLayout(); + // + // Titlelabel + // + Titlelabel.AutoSize = true; + Titlelabel.Location = new Point(27, 32); + Titlelabel.Name = "Titlelabel"; + Titlelabel.Size = new Size(48, 25); + Titlelabel.TabIndex = 1; + Titlelabel.Text = "Title:"; + // + // Authorlabel + // + Authorlabel.AutoSize = true; + Authorlabel.Location = new Point(27, 68); + Authorlabel.Name = "Authorlabel"; + Authorlabel.Size = new Size(71, 25); + Authorlabel.TabIndex = 2; + Authorlabel.Text = "Author:"; + // + // PrintYlabel + // + PrintYlabel.AutoSize = true; + PrintYlabel.Location = new Point(25, 104); + PrintYlabel.Name = "PrintYlabel"; + PrintYlabel.Size = new Size(112, 25); + PrintYlabel.TabIndex = 3; + PrintYlabel.Text = "Year of print:"; + // + // Genrelabel + // + Genrelabel.AutoSize = true; + Genrelabel.Location = new Point(27, 185); + Genrelabel.Name = "Genrelabel"; + Genrelabel.Size = new Size(70, 25); + Genrelabel.TabIndex = 4; + Genrelabel.Text = "Genres:"; + // + // Statlabel + // + Statlabel.AutoSize = true; + Statlabel.Location = new Point(27, 147); + Statlabel.Name = "Statlabel"; + Statlabel.Size = new Size(126, 25); + Statlabel.TabIndex = 5; + Statlabel.Text = "Current status:"; + // + // TitleTb + // + TitleTb.Location = new Point(163, 29); + TitleTb.Name = "TitleTb"; + TitleTb.Size = new Size(452, 31); + TitleTb.TabIndex = 7; + // + // AuthorTb + // + AuthorTb.Location = new Point(163, 65); + AuthorTb.Name = "AuthorTb"; + AuthorTb.Size = new Size(452, 31); + AuthorTb.TabIndex = 8; + // + // YearNud + // + YearNud.Location = new Point(163, 102); + YearNud.Maximum = new decimal(new int[] { 2025, 0, 0, 0 }); + YearNud.Minimum = new decimal(new int[] { 1980, 0, 0, 0 }); + YearNud.Name = "YearNud"; + YearNud.Size = new Size(127, 31); + YearNud.TabIndex = 9; + YearNud.Value = new decimal(new int[] { 1980, 0, 0, 0 }); + // + // SaveBtn + // + SaveBtn.Location = new Point(27, 241); + SaveBtn.Name = "SaveBtn"; + SaveBtn.Size = new Size(110, 68); + SaveBtn.TabIndex = 13; + SaveBtn.Text = "Save"; + SaveBtn.UseVisualStyleBackColor = true; + SaveBtn.Click += SaveBtn_Click; + // + // DiscardBtn + // + DiscardBtn.Location = new Point(27, 315); + DiscardBtn.Name = "DiscardBtn"; + DiscardBtn.Size = new Size(110, 70); + DiscardBtn.TabIndex = 14; + DiscardBtn.Text = "Discard"; + DiscardBtn.UseVisualStyleBackColor = true; + DiscardBtn.Click += DiscardBtn_Click; + // + // StatusCbox + // + StatusCbox.FormattingEnabled = true; + StatusCbox.Location = new Point(163, 139); + StatusCbox.Name = "StatusCbox"; + StatusCbox.Size = new Size(211, 33); + StatusCbox.TabIndex = 15; + // + // GenresChBoxList + // + GenresChBoxList.FormattingEnabled = true; + GenresChBoxList.Location = new Point(163, 185); + GenresChBoxList.Name = "GenresChBoxList"; + GenresChBoxList.Size = new Size(211, 200); + GenresChBoxList.TabIndex = 16; + // + // BookF + // + AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(647, 412); + Controls.Add(GenresChBoxList); + Controls.Add(StatusCbox); + Controls.Add(DiscardBtn); + Controls.Add(SaveBtn); + Controls.Add(YearNud); + Controls.Add(AuthorTb); + Controls.Add(TitleTb); + Controls.Add(Statlabel); + Controls.Add(Genrelabel); + Controls.Add(PrintYlabel); + Controls.Add(Authorlabel); + Controls.Add(Titlelabel); + Name = "BookF"; + Text = "Book"; + ((System.ComponentModel.ISupportInitialize)YearNud).EndInit(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + private Label Titlelabel; + private Label Authorlabel; + private Label PrintYlabel; + private Label Genrelabel; + private Label Statlabel; + private TextBox IDtb; + private TextBox TitleTb; + private TextBox AuthorTb; + private NumericUpDown YearNud; + private Button SaveBtn; + private Button DiscardBtn; + private ComboBox StatusCbox; + private CheckedListBox GenresChBoxList; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/BookF.cs b/LibraryDBproject/LDBproj/AdditionalForms/BookF.cs new file mode 100644 index 0000000..355d389 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/BookF.cs @@ -0,0 +1,60 @@ +namespace LDBproject.AdditionalForms; + +public partial class BookF : Form +{ + private int? _bookID; + + public BookF() + { + InitializeComponent(); + } + + public int ID + { + set + { + try + { + _bookID = value; + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "BookF [ Error : wrong data ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + } + } + + private void SaveBtn_Click(object sender, EventArgs e) + { + try + { + if (string.IsNullOrWhiteSpace(TitleTb.Text) + || GenresChBoxList.CheckedItems.Count == 0 + || StatusCbox.SelectedIndex < 1) + { + throw new Exception("BookF [ Blank spaces were left, not enough information ]"); + } + + if (_bookID.HasValue) + { + + } + else + { + + } + + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "BookF [ Error : while saving ]", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void DiscardBtn_Click(object sender, EventArgs e) => Close(); + + private object CreateBook(int id) { return null; } +} diff --git a/LibraryDBproject/LDBproj/AdditionalForms/BookF.resx b/LibraryDBproject/LDBproj/AdditionalForms/BookF.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/BookF.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/LibraryDBproject/LDBproj/AdditionalForms/BookListF.Designer.cs b/LibraryDBproject/LDBproj/AdditionalForms/BookListF.Designer.cs new file mode 100644 index 0000000..9629475 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/BookListF.Designer.cs @@ -0,0 +1,134 @@ +namespace LDBproject.AdditionalForms +{ + partial class BookListF + { + /// + /// 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() + { + PanelWithOperations = new Panel(); + DelBtn = new Button(); + AddBtn = new Button(); + UpdBtn = new Button(); + DataGV = new DataGridView(); + PanelWithOperations.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)DataGV).BeginInit(); + SuspendLayout(); + // + // PanelWithOperations + // + PanelWithOperations.BackColor = Color.Transparent; + PanelWithOperations.Controls.Add(DelBtn); + PanelWithOperations.Controls.Add(AddBtn); + PanelWithOperations.Controls.Add(UpdBtn); + PanelWithOperations.Dock = DockStyle.Right; + PanelWithOperations.Location = new Point(623, 0); + PanelWithOperations.Name = "PanelWithOperations"; + PanelWithOperations.Size = new Size(154, 396); + PanelWithOperations.TabIndex = 0; + // + // DelBtn + // + DelBtn.BackColor = Color.DarkSlateBlue; + DelBtn.BackgroundImage = Properties.Resources.DelImg; + DelBtn.BackgroundImageLayout = ImageLayout.Stretch; + DelBtn.ForeColor = Color.Transparent; + DelBtn.Location = new Point(23, 207); + DelBtn.Name = "DelBtn"; + DelBtn.Size = new Size(78, 71); + DelBtn.TabIndex = 4; + DelBtn.UseVisualStyleBackColor = false; + DelBtn.Click += DelBtn_Click; + // + // AddBtn + // + AddBtn.BackColor = Color.DarkSlateBlue; + AddBtn.BackgroundImage = Properties.Resources.AddImg; + AddBtn.BackgroundImageLayout = ImageLayout.Stretch; + AddBtn.ForeColor = Color.Transparent; + AddBtn.Location = new Point(23, 53); + AddBtn.Name = "AddBtn"; + AddBtn.Size = new Size(78, 71); + AddBtn.TabIndex = 3; + AddBtn.UseVisualStyleBackColor = false; + AddBtn.Click += AddBtn_Click; + // + // UpdBtn + // + UpdBtn.BackColor = Color.DarkSlateBlue; + UpdBtn.BackgroundImage = Properties.Resources.OperationImg; + UpdBtn.BackgroundImageLayout = ImageLayout.Stretch; + UpdBtn.ForeColor = Color.Transparent; + UpdBtn.Location = new Point(23, 130); + UpdBtn.Name = "UpdBtn"; + UpdBtn.Size = new Size(78, 71); + UpdBtn.TabIndex = 1; + UpdBtn.UseVisualStyleBackColor = false; + UpdBtn.Click += UpdBtn_Click; + // + // DataGV + // + DataGV.AllowUserToResizeColumns = false; + DataGV.AllowUserToResizeRows = false; + DataGV.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill; + DataGV.BackgroundColor = Color.DarkSlateBlue; + DataGV.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + DataGV.GridColor = Color.GreenYellow; + DataGV.Location = new Point(25, 101); + DataGV.Name = "DataGV"; + DataGV.RowHeadersVisible = false; + DataGV.RowHeadersWidth = 62; + DataGV.SelectionMode = DataGridViewSelectionMode.FullRowSelect; + DataGV.Size = new Size(583, 259); + DataGV.TabIndex = 1; + // + // BookListF + // + AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleMode = AutoScaleMode.Font; + BackgroundImage = Properties.Resources.BookListFrameCover; + BackgroundImageLayout = ImageLayout.Stretch; + ClientSize = new Size(777, 396); + Controls.Add(DataGV); + Controls.Add(PanelWithOperations); + DoubleBuffered = true; + Name = "BookListF"; + StartPosition = FormStartPosition.CenterParent; + Text = "BookListF"; + Load += BookListF_Load; + PanelWithOperations.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)DataGV).EndInit(); + ResumeLayout(false); + } + + #endregion + + private Panel PanelWithOperations; + private Button AddBtn; + private Button UpdBtn; + private Button DelBtn; + private DataGridView DataGV; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/BookListF.cs b/LibraryDBproject/LDBproj/AdditionalForms/BookListF.cs new file mode 100644 index 0000000..a6d9f5f --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/BookListF.cs @@ -0,0 +1,96 @@ +using Unity; + +namespace LDBproject.AdditionalForms; + +public partial class BookListF : Form +{ + private readonly IUnityContainer _container; + + public BookListF(IUnityContainer container) + { + InitializeComponent(); + _container = container ?? throw new ArgumentNullException(nameof(container)); + } + + private void BookListF_Load(object sender, EventArgs e) + { + try + { + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Book List Form [ Error while saving ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void AddBtn_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Book List Form [ Error while adding element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void DelBtn_Click(object sender, EventArgs e) + { + if (!GetIDFromRow(out var foundID)) + { + return; + } + + if (MessageBox.Show("Remove element?", "Deleting", MessageBoxButtons.YesNo) != DialogResult.Yes) + { + return; + } + + try + { + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Book List Form [ Error while removing element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ReloadList() { } + + private bool GetIDFromRow(out int id) + { + id = 0; + if (DataGV.SelectedRows.Count < 1) + { + MessageBox.Show("[ Error : Book doesn't exist ]", "", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + + id = Convert.ToInt32(DataGV.SelectedRows[0].Cells["BookID"].Value); + return true; + } + + private void UpdBtn_Click(object sender, EventArgs e) + { + if (!GetIDFromRow(out var findID)) + { + return; + } + + try + { + var form = _container.Resolve(); + form.ID = findID; + form.ShowDialog(); + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Book List Form [ Error while updating element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } +} diff --git a/LibraryDBproject/LDBproj/AdditionalForms/BookListF.resx b/LibraryDBproject/LDBproj/AdditionalForms/BookListF.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/BookListF.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/LibraryDBproject/LDBproj/AdditionalForms/CustomerF.Designer.cs b/LibraryDBproject/LDBproj/AdditionalForms/CustomerF.Designer.cs new file mode 100644 index 0000000..7119bc6 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/CustomerF.Designer.cs @@ -0,0 +1,131 @@ +namespace LDBproject.AdditionalForms +{ + partial class CustomerF + { + /// + /// 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() + { + CancelBtn = new Button(); + SaveBtn = new Button(); + FIOEnterTb = new TextBox(); + FullNameLabel = new Label(); + BDlabel = new Label(); + BirthdayDTPicker = new DateTimePicker(); + SuspendLayout(); + // + // CancelBtn + // + CancelBtn.Anchor = AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + CancelBtn.ForeColor = Color.DarkSlateBlue; + CancelBtn.Location = new Point(495, 70); + CancelBtn.Name = "CancelBtn"; + CancelBtn.Size = new Size(102, 34); + CancelBtn.TabIndex = 8; + CancelBtn.Text = "Cancel"; + CancelBtn.UseVisualStyleBackColor = true; + CancelBtn.Click += CancelBtn_Click; + // + // SaveBtn + // + SaveBtn.Anchor = AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + SaveBtn.ForeColor = Color.DarkSlateBlue; + SaveBtn.Location = new Point(404, 70); + SaveBtn.Name = "SaveBtn"; + SaveBtn.Size = new Size(81, 34); + SaveBtn.TabIndex = 7; + SaveBtn.Text = "Save"; + SaveBtn.UseVisualStyleBackColor = true; + SaveBtn.Click += SaveBtn_Click; + // + // FIOEnterTb + // + FIOEnterTb.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right; + FIOEnterTb.ForeColor = Color.MidnightBlue; + FIOEnterTb.Location = new Point(173, 27); + FIOEnterTb.Name = "FIOEnterTb"; + FIOEnterTb.Size = new Size(424, 31); + FIOEnterTb.TabIndex = 6; + // + // FullNameLabel + // + FullNameLabel.AutoSize = true; + FullNameLabel.Location = new Point(29, 30); + FullNameLabel.Name = "FullNameLabel"; + FullNameLabel.Size = new Size(138, 25); + FullNameLabel.TabIndex = 9; + FullNameLabel.Text = "Full Name (FIO):"; + // + // BDlabel + // + BDlabel.AutoSize = true; + BDlabel.Location = new Point(29, 75); + BDlabel.Name = "BDlabel"; + BDlabel.Size = new Size(159, 25); + BDlabel.TabIndex = 10; + BDlabel.Text = "Birth day and year:"; + // + // BirthdayDTPicker + // + BirthdayDTPicker.CalendarForeColor = Color.GreenYellow; + BirthdayDTPicker.CalendarMonthBackground = Color.DarkSlateBlue; + BirthdayDTPicker.CalendarTitleBackColor = Color.MidnightBlue; + BirthdayDTPicker.CalendarTitleForeColor = Color.DarkSlateBlue; + BirthdayDTPicker.CalendarTrailingForeColor = Color.GreenYellow; + BirthdayDTPicker.Location = new Point(194, 73); + BirthdayDTPicker.Name = "BirthdayDTPicker"; + BirthdayDTPicker.Size = new Size(193, 31); + BirthdayDTPicker.TabIndex = 12; + BirthdayDTPicker.Value = new DateTime(2024, 11, 15, 12, 40, 0, 0); + // + // CustomerF + // + AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleMode = AutoScaleMode.Font; + BackColor = Color.DarkSlateBlue; + ClientSize = new Size(631, 130); + Controls.Add(BirthdayDTPicker); + Controls.Add(BDlabel); + Controls.Add(FullNameLabel); + Controls.Add(CancelBtn); + Controls.Add(SaveBtn); + Controls.Add(FIOEnterTb); + ForeColor = Color.GreenYellow; + Name = "CustomerF"; + Text = "CustomerF"; + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private Button CancelBtn; + private Button SaveBtn; + private TextBox FIOEnterTb; + private Label FullNameLabel; + private Label BDlabel; + private DateTimePicker BirthdayDTPicker; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/CustomerF.cs b/LibraryDBproject/LDBproj/AdditionalForms/CustomerF.cs new file mode 100644 index 0000000..80b2a3d --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/CustomerF.cs @@ -0,0 +1,59 @@ +namespace LDBproject.AdditionalForms; + +public partial class CustomerF : Form +{ + private int? _custID; + + public CustomerF() + { + InitializeComponent(); + } + + public int ID + { + set + { + try + { + _custID = value; + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "CustomerF [ Error : wrong data ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + } + } + + private void SaveBtn_Click(object sender, EventArgs e) + { + try + { + if (string.IsNullOrWhiteSpace(FIOEnterTb.Text) + || BirthdayDTPicker.Value.Year < 1940) + { + throw new Exception("CustomerF [ Blank spaces were left, not enough information ]"); + } + + if (_custID.HasValue) + { + + } + else + { + + } + + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "CustomerF [ Error : while saving ]", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void CancelBtn_Click(object sender, EventArgs e) => Close(); + + private object CreateCustomer(int id) { return null; } +} diff --git a/LibraryDBproject/LDBproj/AdditionalForms/CustomerF.resx b/LibraryDBproject/LDBproj/AdditionalForms/CustomerF.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/CustomerF.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/LibraryDBproject/LDBproj/AdditionalForms/CustomerListF.Designer.cs b/LibraryDBproject/LDBproj/AdditionalForms/CustomerListF.Designer.cs new file mode 100644 index 0000000..fbb70b5 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/CustomerListF.Designer.cs @@ -0,0 +1,132 @@ +namespace LDBproject.AdditionalForms +{ + partial class CustomerListF + { + /// + /// 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() + { + panel1 = new Panel(); + DelBtn = new Button(); + UpdBtn = new Button(); + AddBtn = new Button(); + DataGV = new DataGridView(); + panel1.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)DataGV).BeginInit(); + SuspendLayout(); + // + // panel1 + // + panel1.BackColor = Color.Transparent; + panel1.Controls.Add(DelBtn); + panel1.Controls.Add(UpdBtn); + panel1.Controls.Add(AddBtn); + panel1.Dock = DockStyle.Right; + panel1.Location = new Point(603, 0); + panel1.Name = "panel1"; + panel1.Size = new Size(163, 404); + panel1.TabIndex = 3; + // + // - + // + + // + // DelBtn + // + DelBtn.BackColor = Color.DarkSlateBlue; + DelBtn.BackgroundImage = Properties.Resources.DelImg; + DelBtn.BackgroundImageLayout = ImageLayout.Stretch; + DelBtn.ForeColor = Color.Transparent; + DelBtn.Location = new Point(27, 218); + DelBtn.Name = "DelBtn"; + DelBtn.Size = new Size(78, 71); + DelBtn.TabIndex = 6; + DelBtn.UseVisualStyleBackColor = false; + DelBtn.Click += DelBtn_Click; + // + // UpdBtn + // + UpdBtn.BackColor = Color.DarkSlateBlue; + UpdBtn.BackgroundImage = Properties.Resources.OperationImg; + UpdBtn.BackgroundImageLayout = ImageLayout.Stretch; + UpdBtn.ForeColor = Color.Transparent; + UpdBtn.Location = new Point(27, 141); + UpdBtn.Name = "UpdBtn"; + UpdBtn.Size = new Size(78, 71); + UpdBtn.TabIndex = 5; + UpdBtn.UseVisualStyleBackColor = false; + UpdBtn.Click += UpdBtn_Click; + // + // AddBtn + // + AddBtn.BackColor = Color.DarkSlateBlue; + AddBtn.BackgroundImage = Properties.Resources.AddImg; + AddBtn.BackgroundImageLayout = ImageLayout.Stretch; + AddBtn.ForeColor = Color.Transparent; + AddBtn.Location = new Point(27, 64); + AddBtn.Name = "AddBtn"; + AddBtn.Size = new Size(78, 71); + AddBtn.TabIndex = 4; + AddBtn.UseVisualStyleBackColor = false; + AddBtn.Click += AddBtn_Click; + // + // DataGV + // + DataGV.BackgroundColor = Color.DarkSlateBlue; + DataGV.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + DataGV.GridColor = Color.GreenYellow; + DataGV.Location = new Point(15, 100); + DataGV.Name = "DataGV"; + DataGV.RowHeadersWidth = 62; + DataGV.Size = new Size(550, 273); + DataGV.TabIndex = 2; + // + // CustomerListF + // + AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleMode = AutoScaleMode.Font; + BackgroundImage = Properties.Resources.ReadersFrameCover; + BackgroundImageLayout = ImageLayout.Stretch; + ClientSize = new Size(766, 404); + Controls.Add(panel1); + Controls.Add(DataGV); + DoubleBuffered = true; + Name = "CustomerListF"; + Text = "CustomerListF"; + Load += CustomerListF_Load; + panel1.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)DataGV).EndInit(); + ResumeLayout(false); + } + + #endregion + + private Panel panel1; + private Button DelBtn; + private Button UpdBtn; + private Button AddBtn; + private DataGridView DataGV; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/CustomerListF.cs b/LibraryDBproject/LDBproj/AdditionalForms/CustomerListF.cs new file mode 100644 index 0000000..3a8cf6c --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/CustomerListF.cs @@ -0,0 +1,97 @@ +using Unity; + +namespace LDBproject.AdditionalForms; + +public partial class CustomerListF : Form +{ + private readonly IUnityContainer _container; + + public CustomerListF(IUnityContainer container) + { + InitializeComponent(); + _container = container ?? throw new ArgumentNullException(nameof(container)); + } + + private void CustomerListF_Load(object sender, EventArgs e) + { + try + { + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Customer List Form [ Error while saving ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void AddBtn_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Customer List Form [ Error while adding element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void DelBtn_Click(object sender, EventArgs e) + { + if (!GetIDFromRow(out var foundID)) + { + return; + } + + if (MessageBox.Show("Remove element?", "Deleting", MessageBoxButtons.YesNo) != DialogResult.Yes) + { + return; + } + + try + { + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Customer List Form [ Error while removing element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ReloadList() { } + + private bool GetIDFromRow(out int id) + { + id = 0; + if (DataGV.SelectedRows.Count < 1) + { + MessageBox.Show("[ Error : Customer doesn't exist ]", "", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + + id = Convert.ToInt32(DataGV.SelectedRows[0].Cells["CardID"].Value); + return true; + } + + private void UpdBtn_Click(object sender, EventArgs e) + { + if (!GetIDFromRow(out var findID)) + { + return; + } + + try + { + var form = _container.Resolve(); + form.ID = findID; + form.ShowDialog(); + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Customer List Form [ Error while updating element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } +} + diff --git a/LibraryDBproject/LDBproj/AdditionalForms/CustomerListF.resx b/LibraryDBproject/LDBproj/AdditionalForms/CustomerListF.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/CustomerListF.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/LibraryDBproject/LDBproj/AdditionalForms/EmployeeF.Designer.cs b/LibraryDBproject/LDBproj/AdditionalForms/EmployeeF.Designer.cs new file mode 100644 index 0000000..6d3b89c --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/EmployeeF.Designer.cs @@ -0,0 +1,129 @@ +namespace LDBproject.AdditionalForms +{ + partial class EmployeeF + { + /// + /// 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() + { + FullNameLabel = new Label(); + FIOEnterTb = new TextBox(); + GenreLabel = new Label(); + SaveBtn = new Button(); + CancelBtn = new Button(); + GenresCheckedBL = new CheckedListBox(); + SuspendLayout(); + // + // FullNameLabel + // + FullNameLabel.AutoSize = true; + FullNameLabel.Location = new Point(23, 25); + FullNameLabel.Name = "FullNameLabel"; + FullNameLabel.Size = new Size(138, 25); + FullNameLabel.TabIndex = 0; + FullNameLabel.Text = "Full Name (FIO):"; + // + // FIOEnterTb + // + FIOEnterTb.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right; + FIOEnterTb.ForeColor = Color.MidnightBlue; + FIOEnterTb.Location = new Point(167, 22); + FIOEnterTb.Name = "FIOEnterTb"; + FIOEnterTb.Size = new Size(456, 31); + FIOEnterTb.TabIndex = 1; + // + // GenreLabel + // + GenreLabel.AutoSize = true; + GenreLabel.Location = new Point(23, 77); + GenreLabel.Name = "GenreLabel"; + GenreLabel.Size = new Size(70, 25); + GenreLabel.TabIndex = 2; + GenreLabel.Text = "Genres:"; + // + // SaveBtn + // + SaveBtn.Anchor = AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + SaveBtn.ForeColor = Color.DarkSlateBlue; + SaveBtn.Location = new Point(379, 131); + SaveBtn.Name = "SaveBtn"; + SaveBtn.Size = new Size(112, 34); + SaveBtn.TabIndex = 4; + SaveBtn.Text = "Save"; + SaveBtn.UseVisualStyleBackColor = true; + SaveBtn.Click += SaveBtn_Click; + // + // CancelBtn + // + CancelBtn.Anchor = AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + CancelBtn.ForeColor = Color.DarkSlateBlue; + CancelBtn.Location = new Point(497, 131); + CancelBtn.Name = "CancelBtn"; + CancelBtn.Size = new Size(126, 34); + CancelBtn.TabIndex = 5; + CancelBtn.Text = "Cancel"; + CancelBtn.UseVisualStyleBackColor = true; + CancelBtn.Click += CancelBtn_Click; + // + // GenresCheckedBL + // + GenresCheckedBL.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + GenresCheckedBL.ForeColor = Color.MidnightBlue; + GenresCheckedBL.FormattingEnabled = true; + GenresCheckedBL.Location = new Point(99, 77); + GenresCheckedBL.Name = "GenresCheckedBL"; + GenresCheckedBL.Size = new Size(251, 88); + GenresCheckedBL.TabIndex = 7; + // + // EmployeeF + // + AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleMode = AutoScaleMode.Font; + BackColor = Color.DarkSlateBlue; + ClientSize = new Size(653, 191); + Controls.Add(GenresCheckedBL); + Controls.Add(CancelBtn); + Controls.Add(SaveBtn); + Controls.Add(GenreLabel); + Controls.Add(FIOEnterTb); + Controls.Add(FullNameLabel); + ForeColor = Color.GreenYellow; + Name = "EmployeeF"; + Text = "EmployeeF"; + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private Label FullNameLabel; + private TextBox FIOEnterTb; + private Label GenreLabel; + private Button SaveBtn; + private Button CancelBtn; + private ComboBox GenreCbox; + private CheckedListBox GenresCheckedBL; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/EmployeeF.cs b/LibraryDBproject/LDBproj/AdditionalForms/EmployeeF.cs new file mode 100644 index 0000000..d505054 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/EmployeeF.cs @@ -0,0 +1,59 @@ +namespace LDBproject.AdditionalForms; + +public partial class EmployeeF : Form +{ + private int? _librarianID; + + public EmployeeF() + { + InitializeComponent(); + } + + public int ID + { + set + { + try + { + _librarianID = value; + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "EmployeeF [ Error : while setting ID ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + } + } + + private void SaveBtn_Click(object sender, EventArgs e) + { + try + { + if (string.IsNullOrWhiteSpace(FIOEnterTb.Text) + || GenresCheckedBL.CheckedItems.Count == 0) + { + throw new Exception("EmployeeF [ Blank spaces were left, not enough information ]"); + } + + if (_librarianID.HasValue) + { + + } + else + { + + } + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "EmployeeF [ Error : while saving data ]", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void CancelBtn_Click(object sender, EventArgs e) => Close(); + + private object CreateWorker(int id) { return null; } +} + diff --git a/LibraryDBproject/LDBproj/AdditionalForms/EmployeeF.resx b/LibraryDBproject/LDBproj/AdditionalForms/EmployeeF.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/EmployeeF.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/LibraryDBproject/LDBproj/AdditionalForms/EmployeesF.Designer.cs b/LibraryDBproject/LDBproj/AdditionalForms/EmployeesF.Designer.cs new file mode 100644 index 0000000..6519ef0 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/EmployeesF.Designer.cs @@ -0,0 +1,128 @@ +namespace LDBproject.AdditionalForms +{ + partial class EmployeesF + { + /// + /// 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() + { + DataGV = new DataGridView(); + panel1 = new Panel(); + DelBtn = new Button(); + UpdBtn = new Button(); + AddBtn = new Button(); + ((System.ComponentModel.ISupportInitialize)DataGV).BeginInit(); + panel1.SuspendLayout(); + SuspendLayout(); + // + // DataGV + // + DataGV.BackgroundColor = Color.DarkSlateBlue; + DataGV.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + DataGV.GridColor = Color.GreenYellow; + DataGV.Location = new Point(30, 100); + DataGV.Name = "DataGV"; + DataGV.RowHeadersWidth = 62; + DataGV.Size = new Size(550, 273); + DataGV.TabIndex = 0; + // + // panel1 + // + panel1.BackColor = Color.Transparent; + panel1.Controls.Add(DelBtn); + panel1.Controls.Add(UpdBtn); + panel1.Controls.Add(AddBtn); + panel1.Dock = DockStyle.Right; + panel1.Location = new Point(586, 0); + panel1.Name = "panel1"; + panel1.Size = new Size(163, 407); + panel1.TabIndex = 1; + // + // DelBtn + // + DelBtn.BackColor = Color.DarkSlateBlue; + DelBtn.BackgroundImage = Properties.Resources.DelImg; + DelBtn.BackgroundImageLayout = ImageLayout.Stretch; + DelBtn.ForeColor = Color.Transparent; + DelBtn.Location = new Point(27, 218); + DelBtn.Name = "DelBtn"; + DelBtn.Size = new Size(78, 71); + DelBtn.TabIndex = 6; + DelBtn.UseVisualStyleBackColor = false; + DelBtn.Click += DelBtn_Click; + // + // UpdBtn + // + UpdBtn.BackColor = Color.DarkSlateBlue; + UpdBtn.BackgroundImage = Properties.Resources.OperationImg; + UpdBtn.BackgroundImageLayout = ImageLayout.Stretch; + UpdBtn.ForeColor = Color.Transparent; + UpdBtn.Location = new Point(27, 141); + UpdBtn.Name = "UpdBtn"; + UpdBtn.Size = new Size(78, 71); + UpdBtn.TabIndex = 5; + UpdBtn.UseVisualStyleBackColor = false; + UpdBtn.Click += UpdBtn_Click; + // + // AddBtn + // + AddBtn.BackColor = Color.DarkSlateBlue; + AddBtn.BackgroundImage = Properties.Resources.AddImg; + AddBtn.BackgroundImageLayout = ImageLayout.Stretch; + AddBtn.ForeColor = Color.Transparent; + AddBtn.Location = new Point(27, 64); + AddBtn.Name = "AddBtn"; + AddBtn.Size = new Size(78, 71); + AddBtn.TabIndex = 4; + AddBtn.UseVisualStyleBackColor = false; + AddBtn.Click += AddBtn_Click; + // + // EmployeesF + // + AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleMode = AutoScaleMode.Font; + BackgroundImage = Properties.Resources.EmployeesFrameCover; + BackgroundImageLayout = ImageLayout.Stretch; + ClientSize = new Size(749, 407); + Controls.Add(panel1); + Controls.Add(DataGV); + DoubleBuffered = true; + Name = "EmployeesF"; + Text = "EmployeesF"; + Load += EmployeesF_Load; + ((System.ComponentModel.ISupportInitialize)DataGV).EndInit(); + panel1.ResumeLayout(false); + ResumeLayout(false); + } + + #endregion + + private DataGridView DataGV; + private Panel panel1; + private Button AddBtn; + private Button UpdBtn; + private Button DelBtn; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/EmployeesF.cs b/LibraryDBproject/LDBproj/AdditionalForms/EmployeesF.cs new file mode 100644 index 0000000..ea47543 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/EmployeesF.cs @@ -0,0 +1,97 @@ +using Unity; + +namespace LDBproject.AdditionalForms; + +public partial class EmployeesF : Form +{ + private readonly IUnityContainer _container; + + public EmployeesF(IUnityContainer container) + { + InitializeComponent(); + _container = container ?? throw new ArgumentNullException(nameof(container)); + } + + private void EmployeesF_Load(object sender, EventArgs e) + { + try + { + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Error while saving ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void AddBtn_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Error while adding element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void UpdBtn_Click(object sender, EventArgs e) + { + if (!GetiDFromRow(out var findID)) + { + return; + } + + try + { + var form = _container.Resolve(); + form.ID = findID; + form.ShowDialog(); + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Error while updating element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void DelBtn_Click(object sender, EventArgs e) + { + if (!GetiDFromRow(out var foundID)) + { + return; + } + + if (MessageBox.Show("Remove element?", "Deleting", MessageBoxButtons.YesNo) != DialogResult.Yes) + { + return; + } + + try + { + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Error while removing element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ReloadList() { } + + private bool GetiDFromRow(out int id) + { + id = 0; + if (DataGV.SelectedRows.Count < 1) + { + MessageBox.Show("[ Error : element doesn't exist ]", "", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + + id = Convert.ToInt32(DataGV.SelectedRows[0].Cells["CardID"].Value); + return true; + } +} + diff --git a/LibraryDBproject/LDBproj/AdditionalForms/EmployeesF.resx b/LibraryDBproject/LDBproj/AdditionalForms/EmployeesF.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/EmployeesF.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/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.Designer.cs b/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.Designer.cs new file mode 100644 index 0000000..1463d2f --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.Designer.cs @@ -0,0 +1,112 @@ +namespace LDBproject.AdditionalForms +{ + partial class OrderRegistrations + { + /// + /// 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() + { + panel1 = new Panel(); + DelBtn = new Button(); + AddBtn = new Button(); + DataGV = new DataGridView(); + panel1.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)DataGV).BeginInit(); + SuspendLayout(); + // + // panel1 + // + panel1.BackColor = Color.Transparent; + panel1.Controls.Add(DelBtn); + panel1.Controls.Add(AddBtn); + panel1.Dock = DockStyle.Right; + panel1.Location = new Point(430, 0); + panel1.Name = "panel1"; + panel1.Size = new Size(246, 364); + panel1.TabIndex = 4; + // + // DelBtn + // + DelBtn.BackColor = Color.DarkSlateBlue; + DelBtn.BackgroundImage = Properties.Resources.DelImg; + DelBtn.BackgroundImageLayout = ImageLayout.Stretch; + DelBtn.ForeColor = Color.Transparent; + DelBtn.Location = new Point(129, 34); + DelBtn.Name = "DelBtn"; + DelBtn.Size = new Size(78, 71); + DelBtn.TabIndex = 6; + DelBtn.UseVisualStyleBackColor = false; + DelBtn.Click += DelBtn_Click; + // + // AddBtn + // + AddBtn.BackColor = Color.DarkSlateBlue; + AddBtn.BackgroundImage = Properties.Resources.AddImg; + AddBtn.BackgroundImageLayout = ImageLayout.Stretch; + AddBtn.ForeColor = Color.Transparent; + AddBtn.Location = new Point(24, 34); + AddBtn.Name = "AddBtn"; + AddBtn.Size = new Size(78, 71); + AddBtn.TabIndex = 4; + AddBtn.UseVisualStyleBackColor = false; + AddBtn.Click += AddBtn_Click; + // + // DataGV + // + DataGV.BackgroundColor = Color.DarkSlateBlue; + DataGV.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + DataGV.GridColor = Color.GreenYellow; + DataGV.Location = new Point(28, 86); + DataGV.Name = "DataGV"; + DataGV.RowHeadersWidth = 62; + DataGV.Size = new Size(357, 245); + DataGV.TabIndex = 5; + // + // OrderRegistrations + // + AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleMode = AutoScaleMode.Font; + BackgroundImage = Properties.Resources.RegistrationsFrameCover; + BackgroundImageLayout = ImageLayout.Stretch; + ClientSize = new Size(676, 364); + Controls.Add(DataGV); + Controls.Add(panel1); + DoubleBuffered = true; + Name = "OrderRegistrations"; + Text = "OrderRegistrations"; + Load += RegistrationsF_Load; + panel1.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)DataGV).EndInit(); + ResumeLayout(false); + } + + #endregion + + private Panel panel1; + private Button DelBtn; + private Button AddBtn; + private DataGridView DataGV; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.cs b/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.cs new file mode 100644 index 0000000..ad9fe83 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.cs @@ -0,0 +1,78 @@ +using Unity; + +namespace LDBproject.AdditionalForms; + +public partial class OrderRegistrations : Form +{ + private readonly IUnityContainer _container; + + public OrderRegistrations(IUnityContainer container) + { + InitializeComponent(); + _container = container ?? throw new ArgumentNullException(nameof(container)); + } + + private void RegistrationsF_Load(object sender, EventArgs e) + { + try + { + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Error while saving ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void AddBtn_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Error while adding element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void DelBtn_Click(object sender, EventArgs e) + { + if (!GetIDFromRow(out var foundID)) + { + return; + } + + if (MessageBox.Show("Remove element?", "Deleting", MessageBoxButtons.YesNo) != DialogResult.Yes) + { + return; + } + + try + { + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Error while removing element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ReloadList() { } + + private bool GetIDFromRow(out int id) + { + id = 0; + if (DataGV.SelectedRows.Count < 1) + { + MessageBox.Show("[ Error : element doesn't exist ]", "", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + + id = Convert.ToInt32(DataGV.SelectedRows[0].Cells["OrderID"].Value); + return true; + } +} + + diff --git a/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.resx b/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.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/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.Designer.cs b/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.Designer.cs new file mode 100644 index 0000000..b24be4d --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.Designer.cs @@ -0,0 +1,188 @@ +namespace LDBproject.AdditionalForms +{ + partial class RegOrder + { + /// + /// 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() + { + LibrarianCBox = new ComboBox(); + LibLabel = new Label(); + DateLabel = new Label(); + ReturnDTPicker = new DateTimePicker(); + groupBox1 = new GroupBox(); + DataGV = new DataGridView(); + BookColumnCBox = new DataGridViewComboBoxColumn(); + AuthorColumn = new DataGridViewTextBoxColumn(); + SaveBtn = new Button(); + BackBtn = new Button(); + ReaderLabel = new Label(); + CardCBox = new ComboBox(); + groupBox1.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)DataGV).BeginInit(); + SuspendLayout(); + // + // LibrarianCBox + // + LibrarianCBox.FormattingEnabled = true; + LibrarianCBox.Location = new Point(119, 21); + LibrarianCBox.Name = "LibrarianCBox"; + LibrarianCBox.Size = new Size(182, 33); + LibrarianCBox.TabIndex = 0; + // + // LibLabel + // + LibLabel.AutoSize = true; + LibLabel.Location = new Point(30, 24); + LibLabel.Name = "LibLabel"; + LibLabel.Size = new Size(83, 25); + LibLabel.TabIndex = 1; + LibLabel.Text = "Librarian:"; + // + // DateLabel + // + DateLabel.AutoSize = true; + DateLabel.Location = new Point(30, 128); + DateLabel.Name = "DateLabel"; + DateLabel.Size = new Size(107, 25); + DateLabel.TabIndex = 2; + DateLabel.Text = "Return date:"; + // + // ReturnDTPicker + // + ReturnDTPicker.Location = new Point(37, 163); + ReturnDTPicker.Name = "ReturnDTPicker"; + ReturnDTPicker.Size = new Size(264, 31); + ReturnDTPicker.TabIndex = 3; + // + // groupBox1 + // + groupBox1.Controls.Add(DataGV); + groupBox1.Location = new Point(334, 24); + groupBox1.Name = "groupBox1"; + groupBox1.Size = new Size(423, 266); + groupBox1.TabIndex = 4; + groupBox1.TabStop = false; + groupBox1.Text = "BookListGBox"; + // + // DataGV + // + DataGV.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + DataGV.Columns.AddRange(new DataGridViewColumn[] { BookColumnCBox, AuthorColumn }); + DataGV.Location = new Point(6, 41); + DataGV.Name = "DataGV"; + DataGV.RowHeadersWidth = 62; + DataGV.Size = new Size(411, 206); + DataGV.TabIndex = 0; + // + // BookColumnCBox + // + BookColumnCBox.HeaderText = "Book's title"; + BookColumnCBox.MinimumWidth = 8; + BookColumnCBox.Name = "BookColumnCBox"; + BookColumnCBox.Width = 150; + // + // AuthorColumn + // + AuthorColumn.HeaderText = "Author"; + AuthorColumn.MinimumWidth = 8; + AuthorColumn.Name = "AuthorColumn"; + AuthorColumn.Width = 150; + // + // SaveBtn + // + SaveBtn.Location = new Point(37, 216); + SaveBtn.Name = "SaveBtn"; + SaveBtn.Size = new Size(264, 34); + SaveBtn.TabIndex = 5; + SaveBtn.Text = "Save and give out"; + SaveBtn.UseVisualStyleBackColor = true; + SaveBtn.Click += SaveBtn_Click; + // + // BackBtn + // + BackBtn.Location = new Point(37, 256); + BackBtn.Name = "BackBtn"; + BackBtn.Size = new Size(264, 34); + BackBtn.TabIndex = 6; + BackBtn.Text = "Go back"; + BackBtn.UseVisualStyleBackColor = true; + BackBtn.Click += BackBtn_Click; + // + // ReaderLabel + // + ReaderLabel.AutoSize = true; + ReaderLabel.Location = new Point(30, 65); + ReaderLabel.Name = "ReaderLabel"; + ReaderLabel.Size = new Size(66, 50); + ReaderLabel.TabIndex = 7; + ReaderLabel.Text = "Reader\r\ncard:"; + // + // CardCBox + // + CardCBox.FormattingEnabled = true; + CardCBox.Location = new Point(119, 82); + CardCBox.Name = "CardCBox"; + CardCBox.Size = new Size(182, 33); + CardCBox.TabIndex = 8; + // + // RegOrder + // + AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(785, 314); + Controls.Add(CardCBox); + Controls.Add(ReaderLabel); + Controls.Add(BackBtn); + Controls.Add(SaveBtn); + Controls.Add(groupBox1); + Controls.Add(ReturnDTPicker); + Controls.Add(DateLabel); + Controls.Add(LibLabel); + Controls.Add(LibrarianCBox); + Name = "RegOrder"; + Text = "RegOrder"; + groupBox1.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)DataGV).EndInit(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private ComboBox LibrarianCBox; + private Label LibLabel; + private Label DateLabel; + private DateTimePicker ReturnDTPicker; + private GroupBox groupBox1; + private DataGridView DataGV; + private Button SaveBtn; + private Button BackBtn; + private Label ReaderLabel; + private ComboBox CardCBox; + private DataGridViewComboBoxColumn BookColumnCBox; + private DataGridViewTextBoxColumn AuthorColumn; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.cs b/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.cs new file mode 100644 index 0000000..a2915a7 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.cs @@ -0,0 +1,50 @@ +namespace LDBproject.AdditionalForms; + +public partial class RegOrder : Form +{ + public RegOrder() + { + InitializeComponent(); + + LibrarianCBox.DisplayMember = "FIO"; + LibrarianCBox.ValueMember = "CardID"; + + CardCBox.DisplayMember = "FIO"; + CardCBox.ValueMember = "CardID"; + + BookColumnCBox.DisplayMember = "Title"; + BookColumnCBox.ValueMember = "BookID"; + } + + private void SaveBtn_Click(object sender, EventArgs e) + { + try + { + if (DataGV.RowCount < 1 || LibrarianCBox.SelectedIndex < 0) + { + throw new Exception("[ Blanck space left ]"); + } + + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Saving error ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void BackBtn_Click(object sender, EventArgs e) => Close(); + + private List CreateBookListFromDG() + { + var list = new List(); + foreach (DataGridViewRow row in DataGV.Rows) + { + if (row.Cells["BookColumn"].Value == null) + { + continue; + } + } + return list; + } +} diff --git a/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.resx b/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.resx new file mode 100644 index 0000000..ccd5dce --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.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/LibraryDBproject/LDBproj/AdditionalForms/UpdateF.Designer.cs b/LibraryDBproject/LDBproj/AdditionalForms/UpdateF.Designer.cs new file mode 100644 index 0000000..23eae94 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/UpdateF.Designer.cs @@ -0,0 +1,198 @@ +namespace LDBproject.AdditionalForms +{ + partial class UpdateF + { + /// + /// 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() + { + LibLabel = new Label(); + LibrarianCBox = new ComboBox(); + LastUpdLabel = new Label(); + NextUpdLabel = new Label(); + UpdDTPicker = new DateTimePicker(); + NextUpdDTPicker = new DateTimePicker(); + ConfirmBtn = new Button(); + CancelBtn = new Button(); + CardCBox = new ComboBox(); + CardLbl = new Label(); + NoteTb = new TextBox(); + NoteLbl = new Label(); + SuspendLayout(); + // + // LibLabel + // + LibLabel.AutoSize = true; + LibLabel.Location = new Point(27, 91); + LibLabel.Margin = new Padding(4, 0, 4, 0); + LibLabel.Name = "LibLabel"; + LibLabel.Size = new Size(118, 32); + LibLabel.TabIndex = 0; + LibLabel.Text = "By whom:"; + // + // LibrarianCBox + // + LibrarianCBox.FormattingEnabled = true; + LibrarianCBox.Location = new Point(152, 87); + LibrarianCBox.Margin = new Padding(4, 4, 4, 4); + LibrarianCBox.Name = "LibrarianCBox"; + LibrarianCBox.Size = new Size(515, 40); + LibrarianCBox.TabIndex = 1; + // + // LastUpdLabel + // + LastUpdLabel.AutoSize = true; + LastUpdLabel.Location = new Point(27, 213); + LastUpdLabel.Margin = new Padding(4, 0, 4, 0); + LastUpdLabel.Name = "LastUpdLabel"; + LastUpdLabel.Size = new Size(74, 32); + LastUpdLabel.TabIndex = 2; + LastUpdLabel.Text = "From:"; + // + // NextUpdLabel + // + NextUpdLabel.AutoSize = true; + NextUpdLabel.Location = new Point(27, 266); + NextUpdLabel.Margin = new Padding(4, 0, 4, 0); + NextUpdLabel.Name = "NextUpdLabel"; + NextUpdLabel.Size = new Size(50, 32); + NextUpdLabel.TabIndex = 3; + NextUpdLabel.Text = "Till:"; + // + // UpdDTPicker + // + UpdDTPicker.Location = new Point(110, 213); + UpdDTPicker.Margin = new Padding(4, 4, 4, 4); + UpdDTPicker.Name = "UpdDTPicker"; + UpdDTPicker.Size = new Size(389, 39); + UpdDTPicker.TabIndex = 4; + // + // NextUpdDTPicker + // + NextUpdDTPicker.Location = new Point(110, 266); + NextUpdDTPicker.Margin = new Padding(4, 4, 4, 4); + NextUpdDTPicker.Name = "NextUpdDTPicker"; + NextUpdDTPicker.Size = new Size(389, 39); + NextUpdDTPicker.TabIndex = 5; + // + // ConfirmBtn + // + ConfirmBtn.Location = new Point(523, 213); + ConfirmBtn.Margin = new Padding(4, 4, 4, 4); + ConfirmBtn.Name = "ConfirmBtn"; + ConfirmBtn.Size = new Size(146, 44); + ConfirmBtn.TabIndex = 6; + ConfirmBtn.Text = "Confirm"; + ConfirmBtn.UseVisualStyleBackColor = true; + ConfirmBtn.Click += ConfirmBtn_Click; + // + // CancelBtn + // + CancelBtn.Location = new Point(523, 266); + CancelBtn.Margin = new Padding(4, 4, 4, 4); + CancelBtn.Name = "CancelBtn"; + CancelBtn.Size = new Size(146, 44); + CancelBtn.TabIndex = 7; + CancelBtn.Text = "Cancel"; + CancelBtn.UseVisualStyleBackColor = true; + CancelBtn.Click += CancelBtn_Click; + // + // CardCBox + // + CardCBox.FormattingEnabled = true; + CardCBox.Location = new Point(222, 26); + CardCBox.Margin = new Padding(4, 4, 4, 4); + CardCBox.Name = "CardCBox"; + CardCBox.Size = new Size(445, 40); + CardCBox.TabIndex = 9; + // + // CardLbl + // + CardLbl.AutoSize = true; + CardLbl.Location = new Point(27, 29); + CardLbl.Margin = new Padding(4, 0, 4, 0); + CardLbl.Name = "CardLbl"; + CardLbl.Size = new Size(188, 32); + CardLbl.TabIndex = 8; + CardLbl.Text = "Card to prolong:"; + // + // NoteTb + // + NoteTb.Location = new Point(110, 150); + NoteTb.Margin = new Padding(4); + NoteTb.Name = "NoteTb"; + NoteTb.Size = new Size(557, 39); + NoteTb.TabIndex = 10; + // + // NoteLbl + // + NoteLbl.AutoSize = true; + NoteLbl.Location = new Point(27, 152); + NoteLbl.Margin = new Padding(4, 0, 4, 0); + NoteLbl.Name = "NoteLbl"; + NoteLbl.Size = new Size(72, 32); + NoteLbl.TabIndex = 11; + NoteLbl.Text = "Note:"; + // + // UpdateF + // + AutoScaleDimensions = new SizeF(13F, 32F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(706, 345); + Controls.Add(NoteLbl); + Controls.Add(NoteTb); + Controls.Add(CardCBox); + Controls.Add(CardLbl); + Controls.Add(CancelBtn); + Controls.Add(ConfirmBtn); + Controls.Add(NextUpdDTPicker); + Controls.Add(UpdDTPicker); + Controls.Add(NextUpdLabel); + Controls.Add(LastUpdLabel); + Controls.Add(LibrarianCBox); + Controls.Add(LibLabel); + Margin = new Padding(4, 4, 4, 4); + Name = "UpdateF"; + Text = "UpdateF"; + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private Label LibLabel; + private ComboBox LibrarianCBox; + private Label LastUpdLabel; + private Label NextUpdLabel; + private DateTimePicker UpdDTPicker; + private DateTimePicker NextUpdDTPicker; + private Button ConfirmBtn; + private Button CancelBtn; + private ComboBox CardCBox; + private Label CardLbl; + private TextBox NoteTb; + private Label NoteLbl; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/UpdateF.cs b/LibraryDBproject/LDBproj/AdditionalForms/UpdateF.cs new file mode 100644 index 0000000..42d289d --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/UpdateF.cs @@ -0,0 +1,35 @@ +namespace LDBproject.AdditionalForms; + +public partial class UpdateF : Form +{ + public UpdateF() + { + InitializeComponent(); + + LibrarianCBox.DisplayMember = "FIO"; + LibrarianCBox.ValueMember = "CardID"; + + CardCBox.DisplayMember = "FIO"; + CardCBox.DisplayMember = "CardID"; + CardCBox.ValueMember = "CardID"; + } + + private void ConfirmBtn_Click(object sender, EventArgs e) + { + try + { + if (LibrarianCBox.SelectedIndex < 0 || CardCBox.SelectedIndex < 0) + { + throw new Exception("[ Blanck space left ]"); + } + + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Saving error ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void CancelBtn_Click(object sender, EventArgs e) => Close(); +} diff --git a/LibraryDBproject/LDBproj/AdditionalForms/UpdateF.resx b/LibraryDBproject/LDBproj/AdditionalForms/UpdateF.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/UpdateF.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/LibraryDBproject/LDBproj/AdditionalForms/UpdatesListF.Designer.cs b/LibraryDBproject/LDBproj/AdditionalForms/UpdatesListF.Designer.cs new file mode 100644 index 0000000..8a3c35c --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/UpdatesListF.Designer.cs @@ -0,0 +1,112 @@ +namespace LDBproject.AdditionalForms +{ + partial class UpdatesListF + { + /// + /// 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() + { + panel1 = new Panel(); + DelBtn = new Button(); + AddBtn = new Button(); + DataGV = new DataGridView(); + panel1.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)DataGV).BeginInit(); + SuspendLayout(); + // + // panel1 + // + panel1.BackColor = Color.Transparent; + panel1.Controls.Add(DelBtn); + panel1.Controls.Add(AddBtn); + panel1.Dock = DockStyle.Right; + panel1.Location = new Point(546, 0); + panel1.Name = "panel1"; + panel1.Size = new Size(163, 360); + panel1.TabIndex = 3; + // + // DelBtn + // + DelBtn.BackColor = Color.DarkSlateBlue; + DelBtn.BackgroundImage = Properties.Resources.DelImg; + DelBtn.BackgroundImageLayout = ImageLayout.Stretch; + DelBtn.ForeColor = Color.Transparent; + DelBtn.Location = new Point(27, 218); + DelBtn.Name = "DelBtn"; + DelBtn.Size = new Size(78, 71); + DelBtn.TabIndex = 6; + DelBtn.UseVisualStyleBackColor = false; + DelBtn.Click += DelBtn_Click; + // + // AddBtn + // + AddBtn.BackColor = Color.DarkSlateBlue; + AddBtn.BackgroundImage = Properties.Resources.AddImg; + AddBtn.BackgroundImageLayout = ImageLayout.Stretch; + AddBtn.ForeColor = Color.Transparent; + AddBtn.Location = new Point(27, 126); + AddBtn.Name = "AddBtn"; + AddBtn.Size = new Size(78, 71); + AddBtn.TabIndex = 4; + AddBtn.UseVisualStyleBackColor = false; + AddBtn.Click += AddBtn_Click; + // + // DataGV + // + DataGV.BackgroundColor = Color.DarkSlateBlue; + DataGV.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + DataGV.GridColor = Color.GreenYellow; + DataGV.Location = new Point(30, 90); + DataGV.Name = "DataGV"; + DataGV.RowHeadersWidth = 62; + DataGV.Size = new Size(489, 245); + DataGV.TabIndex = 2; + // + // CardUpdatesF + // + AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleMode = AutoScaleMode.Font; + BackgroundImage = Properties.Resources.UpdListFrameCover; + BackgroundImageLayout = ImageLayout.Stretch; + ClientSize = new Size(709, 360); + Controls.Add(panel1); + Controls.Add(DataGV); + DoubleBuffered = true; + Name = "CardUpdatesF"; + Text = "CardUpdatesF"; + Load += CardUpdatesF_Load; + panel1.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)DataGV).EndInit(); + ResumeLayout(false); + } + + #endregion + + private Panel panel1; + private Button DelBtn; + private Button AddBtn; + private DataGridView DataGV; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/UpdatesListF.cs b/LibraryDBproject/LDBproj/AdditionalForms/UpdatesListF.cs new file mode 100644 index 0000000..3ed4f3d --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/UpdatesListF.cs @@ -0,0 +1,76 @@ +using Unity; + +namespace LDBproject.AdditionalForms; + +public partial class UpdatesListF : Form +{ + private readonly IUnityContainer _container; + + public UpdatesListF(IUnityContainer container) + { + InitializeComponent(); + _container = container ?? throw new ArgumentNullException(nameof(container)); + } + + private void CardUpdatesF_Load(object sender, EventArgs e) + { + try + { + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Error while saving ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void AddBtn_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Error while adding element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void DelBtn_Click(object sender, EventArgs e) + { + if (!GetIDFromRow(out var foundID)) + { + return; + } + + if (MessageBox.Show("Remove element?", "Deleting", MessageBoxButtons.YesNo) != DialogResult.Yes) + { + return; + } + + try + { + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Error while removing element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ReloadList() { } + + private bool GetIDFromRow(out int id) + { + id = 0; + if (DataGV.SelectedRows.Count < 1) + { + MessageBox.Show("[ Error : element doesn't exist ]", "", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + + id = Convert.ToInt32(DataGV.SelectedRows[0].Cells["ID"].Value); + return true; + } +} diff --git a/LibraryDBproject/LDBproj/AdditionalForms/UpdatesListF.resx b/LibraryDBproject/LDBproj/AdditionalForms/UpdatesListF.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/UpdatesListF.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/LibraryDBproject/LDBproj/DBScript/TextCommands.txt b/LibraryDBproject/LDBproj/DBScript/TextCommands.txt new file mode 100644 index 0000000..c0bc7f7 --- /dev/null +++ b/LibraryDBproject/LDBproj/DBScript/TextCommands.txt @@ -0,0 +1,201 @@ +-- Insert data into Genres +INSERT INTO Genres (GenreName) VALUES +('None'), ('Adventure'), ('Fantasy'), ('Mystery'), ('Fiction'), ('Suspense'), ('Romance'), ('Crime'), ('Talent'), ('Realism'), ('Horror'), ('Historical'); + +-- Insert data into Books (with updated GenreIDs and Status) +INSERT INTO Books (Title, Author, PublishYear, Status, GenreMask) VALUES +('The Hobbit', 'J.R.R. Tolkien', 1937, 3, 1024), -- On Stock, Fantasy +('Pride and Prejudice', 'Jane Austen', 1813, 3, 2 | 128), -- On Stock, Romance | Realism +('The Da Vinci Code', 'Dan Brown', 2003, 4, 4 | 16), -- Borrowed, Mystery | Suspense +('1984', 'George Orwell', 1949, 3, 8 | 128), -- On Stock, Fiction | Realism +('To Kill a Mockingbird', 'Harper Lee', 1960, 4, 8 | 128), -- Borrowed, Fiction | Realism +('The Great Gatsby', 'F. Scott Fitzgerald', 1925, 3, 2 | 128), -- On Stock, Romance | Realism +('The Time Traveler''s Wife', 'Audrey Niffenegger', 2003, 4, 2 | 1024), -- Borrowed, Romance | Fantasy +('The Secret Garden', 'Frances Hodgson Burnett', 1911, 2, 1), -- in IDassignment state, Adventure +('Gone Girl', 'Gillian Flynn', 2012, 1, 4 | 16 | 32), -- Ordered, Mystery | Suspense | Crime +('A Game of Thrones', 'George R.R. Martin', 1996, 3, 1 | 1024 | 8), -- On Stock, Adventure | Fantasy | Fiction +('Harry Potter and the Sorcerer''s Stone', 'J.K. Rowling', 1997, 3, 1 | 8 | 1024), -- On Stock, Adventure | Fiction | Fantasy +('The Martian', 'Andy Weir', 2011, 3, 1 | 8), -- On Stock, Adventure | Fiction +('Little Women', 'Louisa May Alcott', 1868, 5, 2), -- Debited, Romance +('The Seven Husbands of Evelyn Hugo', 'Taylor Jenkins Reid', 2017, 3, 2 | 128); -- On Stock, Romance | Realism +-- ('Where the Crawdads Sing', 'Delia Owens', 2018, ); -- Fiction, Borrowed +-- ('The Lord of the Rings', 'J.R.R. Tolkien', 1954, ), -- Fantasy, Unable +-- ('The Nightingale', 'Kristin Hannah', 2015, ), -- Romance, Borrowed +-- ('The Book Thief', 'Markus Zusak', 2005, ), -- Fiction, On Stock +-- ('The Help', 'Kathryn Stockett', 2009, ), -- Fiction, Borrowed +-- ('The Girl on the Train', 'Paula Hawkins', 2015, ), -- Suspense, On Stock +-- ('The Girl with the Dragon Tattoo', 'Stieg Larsson', 2005, ), -- Suspense, On Stock +-- ('The Catcher in the Rye', 'J.D. Salinger', 1951, ), -- Fiction, Unable +-- ('The Hunger Games', 'Suzanne Collins', 2008, ), -- Suspense, Borrowed +-- ('The Silent Patient', 'Alex Michaelides', 2019, ), -- Mystery, Unable +-- ('And Then There Were None', 'Agatha Christie', 1939, ), -- Mystery, Unable + +-- Insert data into LibrarianCards (reference existing GenreIDs) +INSERT INTO LibrarianCards (FIO, GenreMask) VALUES +('Carla R.E.', 4 | 16 | 32), +('Bonnet D.P.', 2 | 128), +('Gabriel W.T.', 1 | 1024 | 8); + +-- Insert data into CustomerCards +INSERT INTO CustomerCards (FIO, AgeBirthday) VALUES +('Winsent G.P.', '2000-01-15'), +('Quincy P.R.', '2005-05-20'), +('Emily Y.N.', '2009-11-10'), +('Frank A.K.', '2007-07-25'), +('Marinett J.C.', '2004-03-01'), +('Alice B.T.', '2002-08-10'), +('Bob C.L.', '1998-03-25'), +('Charlie D.M.', '2011-06-18'), +('Diana E.S.', '1995-12-05'), +('Eve F.W.', '2007-09-30'); + + +-- Insert more data into Orders +INSERT INTO Orders (CardID, LibrarianID, BorrowDate) VALUES +(6, 1, '2024-05-10 11:00:00'), +(1, 3, '2024-05-15 15:30:00'), +(9, 1, '2024-05-20 09:45:00'), +(3, 2, '2024-05-25 13:15:00'), +(4, 3, '2024-06-01 10:00:00'), +(5, 1, '2024-06-05 16:45:00'), +(10, 2, '2024-06-10 14:15:00'), +(1, 1, '2024-07-15 10:30:00'), +(10, 3, '2024-07-20 12:45:00'), +(7, 1, '2024-07-25 17:00:00'), +(2, 1, '2024-08-20 09:45:00'), +(8, 2, '2024-08-25 13:15:00'), +(4, 3, '2024-09-01 10:00:00'), +(5, 1, '2024-09-12 16:45:00'), +(8, 3, '2024-09-16 10:00:00'), +(6, 1, '2024-09-24 16:45:00'), +(9, 2, '2024-10-10 14:15:00'), +(1, 1, '2024-10-15 10:30:00'), +(7, 3, '2024-12-09 12:45:00'), +(3, 1, '2024-12-25 17:00:00'), +(4, 1, '2024-12-20 09:45:00'); + +-- Insert more data into Registrations +INSERT INTO Registrations (OrderID, BookID, Note) VALUES +(1, 6, '07-10'), +(2, 10, '07-15'), +(3, 2, '07-20'), +(4, 7, '07-25'), +(5, 11, '08-07'), +(5, 9, '08-07'), +(6, 8, '08-10'), +(7, 4, '08-15'), +(7, 5, '08-15'), +(7, 6, '08-15'), +(7, 7, '08-15'), +(8, 11, '08-18'), +(9, 9, '08-27'), +(9, 3, '08-10'), +(10, 4, '08-15'), +(11, 8, '07-25'), +(12, 10, '08-01'), +(13, 12, '08-05'), +(14, 3, '08-10'), +(14, 4, '08-15'), +(14, 5, '08-20'), +(14, 1, '08-25'), +(15, 6, '08-25'), +(16, 7, '07-25'), +(17, 8, '08-01'), +(17, 9, '08-05'), +(18, 11, '08-10'), +(18, 4, '08-15'), +(18, 7, '07-25'), +(18, 1, '08-01'); + +-- Insert more data into Updates – Multiple updates on the same day +INSERT INTO Updates (LastUpdate, UpdBoundary, Note, LibrarianID, CardID) VALUES +('2017-05-10', '2021-03-15', 'Card Received', 3, 1), +('2022-11-22', '2025-08-20', 'Renewed card', 2, 3), +('2016-02-01', '2020-01-10', 'Card Received', 2, 2), +('2020-09-18', '2024-12-05', 'Updated address', 1, 4), +('2018-07-05', '2024-06-25', 'Card Received', 3, 5), +('2023-10-26', '2024-04-15', 'Lost card, reissued', 1, 1), +('2023-10-26', '2024-05-10', 'Payment overdue', 2, 5), +('2024-01-15', '2024-07-15', 'Address change', 3, 2), +('2024-03-01', '2024-09-01', 'Renewed card', 1, 4), +('2024-03-01', '2024-09-01', 'Fee payment', 1, 3), -- Multiple updates on the same day +('2024-03-10', '2025-01-10', 'Card Received', 2, 6), +('2024-04-20', '2025-02-20', 'Renewal', 3, 1), +('2024-05-10', '2025-03-10', 'New Card issued', 1, 5); + +-- Drop the table if it exists ----------------------------- +DROP TABLE IF EXISTS Updates; + +DROP TABLE IF EXISTS Registrations; +DROP TABLE IF EXISTS Orders; + +DROP TABLE IF EXISTS LibrarianCards; +DROP TABLE IF EXISTS CustomerCards; + +DROP TABLE IF EXISTS Books; +DROP TABLE IF EXISTS Genres; + +-- Create the Genres table [ 1 ] +CREATE TABLE Genres ( + GenreID SERIAL PRIMARY KEY, + GenreName VARCHAR(255) NOT NULL UNIQUE +); + +-- Create the Books table [ 2 ] +CREATE TABLE Books ( + BookID SERIAL PRIMARY KEY, + Title VARCHAR(255) NOT NULL, + Author VARCHAR(255) NOT NULL, + PublishYear INTEGER, + Status INTEGER CHECK (Status IN (0, 1, 2, 3, 4, 5)), + GenreMask INTEGER DEFAULT 0 + -- CountOnStock INTEGER CHECK (CountOnStock >= 0), + -- > GenreID INTEGER REFERENCES Genres(GenreID) +); + +-- > ALTER TABLE Books DROP COLUMN GenreID; + +-- Now, add the GenreMask column to the Books table +-- [ ! ] ALTER TABLE Books ADD COLUMN GenreMask INTEGER DEFAULT 0; -- Using INTEGER to store bitmask + + +-- Create the CustomerCards table [ 3 ] +CREATE TABLE CustomerCards ( + CardID SERIAL PRIMARY KEY, + FIO VARCHAR(255) NOT NULL, + AgeBirthday DATE +); + +-- Create the LibrarianCards table [ 4 ] +CREATE TABLE LibrarianCards ( + CardID SERIAL PRIMARY KEY, + FIO VARCHAR(255) NOT NULL, + GenreMask INTEGER DEFAULT 0 + -- GenreID INTEGER REFERENCES Genres(GenreID) +); + +-- Create the Orders table [ 5 ] +CREATE TABLE Orders ( + OrderID SERIAL PRIMARY KEY, + CardID INTEGER REFERENCES CustomerCards(CardID) NOT NULL, + LibrarianID INTEGER REFERENCES LibrarianCards(CardID) NOT NULL, + BorrowDate TIMESTAMP WITH TIME ZONE +); + +-- Create the Registrations table [ 6 ] +CREATE TABLE Registrations ( + ID SERIAL PRIMARY KEY, + OrderID INTEGER REFERENCES Orders(OrderID) NOT NULL, + BookID INTEGER REFERENCES Books(BookID) NOT NULL, + Note TEXT +); + +-- Create the Updates table [ 7 ] +CREATE TABLE Updates ( + ID SERIAL PRIMARY KEY, + LastUpdate DATE NOT NULL, + UpdBoundary DATE, + Note TEXT, + LibrarianID INTEGER REFERENCES LibrarianCards(CardID) NOT NULL, + CardID INTEGER REFERENCES CustomerCards(CardID) NOT NULL +); diff --git a/LibraryDBproject/LDBproj/Entities/Book.cs b/LibraryDBproject/LDBproj/Entities/Book.cs new file mode 100644 index 0000000..75f5354 --- /dev/null +++ b/LibraryDBproject/LDBproj/Entities/Book.cs @@ -0,0 +1,27 @@ +using LDBproject.Entities.Enums; + +namespace LDBproject.Entities; + +public class Book +{ + public int BookID { get; private set; } + public string Title { get; private set; } + public string Author { get; private set; } + public int PublishYear { get; private set; } + public BookStat Status { get; private set; } + public Genres GenreMask { get; private set; } = Genres.None; + + public static Book AddBook( + int bookIndex, string title, string author, int year, Genres genres, BookStat status) + { + return new Book + { + BookID = bookIndex, + Title = title, + Author = author, + PublishYear = year, + GenreMask = genres, + Status = status + }; + } +} diff --git a/LibraryDBproject/LDBproj/Entities/CustomerCard.cs b/LibraryDBproject/LDBproj/Entities/CustomerCard.cs new file mode 100644 index 0000000..c58bae5 --- /dev/null +++ b/LibraryDBproject/LDBproj/Entities/CustomerCard.cs @@ -0,0 +1,21 @@ +namespace LDBproject.Entities; + +public class CustomerCard +{ + public int CardID { get; private set; } + + public string FIO { get; private set; } + + public DateTime AgeBirthday { get; private set; } + + public static CustomerCard AddCustomer( + int cardIndex, string fullName, DateTime year) + { + return new CustomerCard + { + CardID = cardIndex, + FIO = fullName, + AgeBirthday = year + }; + } +} diff --git a/LibraryDBproject/LDBproj/Entities/Enums/BookStat.cs b/LibraryDBproject/LDBproj/Entities/Enums/BookStat.cs new file mode 100644 index 0000000..aae28d0 --- /dev/null +++ b/LibraryDBproject/LDBproj/Entities/Enums/BookStat.cs @@ -0,0 +1,11 @@ +namespace LDBproject.Entities.Enums; + +public enum BookStat +{ + Unable = 0, + Ordered = 1, + IDassignment = 2, + OnStock = 3, + Borrowed = 4, + Debited = 5 +} diff --git a/LibraryDBproject/LDBproj/Entities/Enums/Genres.cs b/LibraryDBproject/LDBproj/Entities/Enums/Genres.cs new file mode 100644 index 0000000..61d9257 --- /dev/null +++ b/LibraryDBproject/LDBproj/Entities/Enums/Genres.cs @@ -0,0 +1,19 @@ +namespace LDBproject.Entities.Enums +{ + [Flags] + public enum Genres + { + None = 0, // 00000000 + Adventure = 1, // 00000001 + Fantasy = 2, // 00000010 + Mystery = 4, // 00000100 + Fiction = 8, // 00001000 + Suspense = 16, // 00010000 + Romance = 32, // 00100000 + Crime = 64, // 01000000 + Talent = 128, // 10000000 + Realism = 256, // 10000001 + Horror = 512, // 10000010 + Historical = 1024, // 10000011 + } +} diff --git a/LibraryDBproject/LDBproj/Entities/LibrarianCard.cs b/LibraryDBproject/LDBproj/Entities/LibrarianCard.cs new file mode 100644 index 0000000..09d2dfb --- /dev/null +++ b/LibraryDBproject/LDBproj/Entities/LibrarianCard.cs @@ -0,0 +1,23 @@ +using LDBproject.Entities.Enums; + +namespace LDBproject.Entities; + +public class LibrarianCard +{ + public int CardID { get; private set; } + + public string FIO { get; private set; } + + public Genres GenreMask { get; private set; } + + public static LibrarianCard AddWorker( + int cardIndex, string fullName, Genres genre) + { + return new LibrarianCard + { + CardID = cardIndex, + FIO = fullName, + GenreMask = genre + }; + } +} diff --git a/LibraryDBproject/LDBproj/Entities/Order.cs b/LibraryDBproject/LDBproj/Entities/Order.cs new file mode 100644 index 0000000..6f67ebc --- /dev/null +++ b/LibraryDBproject/LDBproj/Entities/Order.cs @@ -0,0 +1,27 @@ +namespace LDBproject.Entities; + +public class Order +{ + public int OrderID { get; private set; } + + public int CardID { get; private set; } + + public DateTime BorrowDate { get; private set; } + + public int LibrarianID { get; private set; } + + public IEnumerable BookList { get; set; } = []; + + public static Order NewOrder( + int orderIndex, int ticketIndex, int librarian, IEnumerable list, DateTime borrow) + { + return new Order + { + OrderID = orderIndex, + CardID = ticketIndex, + LibrarianID = librarian, + BookList = list, + BorrowDate = borrow + }; + } +} diff --git a/LibraryDBproject/LDBproj/Entities/Registration.cs b/LibraryDBproject/LDBproj/Entities/Registration.cs new file mode 100644 index 0000000..691d8e9 --- /dev/null +++ b/LibraryDBproject/LDBproj/Entities/Registration.cs @@ -0,0 +1,23 @@ +namespace LDBproject.Entities; + +public class Registration +{ + public int ID { get; private set; } + + public int OrderID { get; private set; } + + public int BookID { get; private set; } + + public string Note { get; private set; } + + public static Registration OrderReg( + int orderIndex, string notes, int bookIndex) + { + return new Registration + { + OrderID = orderIndex, + BookID = bookIndex, + Note = notes + }; + } +} diff --git a/LibraryDBproject/LDBproj/Entities/UpdateC.cs b/LibraryDBproject/LDBproj/Entities/UpdateC.cs new file mode 100644 index 0000000..de2444d --- /dev/null +++ b/LibraryDBproject/LDBproj/Entities/UpdateC.cs @@ -0,0 +1,29 @@ +namespace LDBproject.Entities; + +public class UpdateC +{ + public int ID { get; private set; } + + public int CardID { get; private set; } + + public int LibrarianID { get; private set; } + + public DateTime LastUpdate { get; private set; } + + public DateTime UpdBoundary { get; private set; } + + public string Note { get; private set; } + + public static UpdateC CustomerUpd( + int cardIndex, int librIndex, DateTime updDate, DateTime updToDate, string note) + { + return new UpdateC + { + CardID = cardIndex, + LastUpdate = updDate, + LibrarianID = librIndex, + UpdBoundary = updToDate, + Note = note + }; + } +} diff --git a/LibraryDBproject/LDBproj/LDBproject - Backup.csproj b/LibraryDBproject/LDBproj/LDBproject - Backup.csproj new file mode 100644 index 0000000..cd33eb3 --- /dev/null +++ b/LibraryDBproject/LDBproj/LDBproject - Backup.csproj @@ -0,0 +1,26 @@ + + + + WinExe + net8.0-windows + enable + true + enable + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/LDBproj.csproj b/LibraryDBproject/LDBproj/LDBproject.csproj similarity index 55% rename from LibraryDBproject/LDBproj/LDBproj.csproj rename to LibraryDBproject/LDBproj/LDBproject.csproj index 663fdb8..d013ccd 100644 --- a/LibraryDBproject/LDBproj/LDBproj.csproj +++ b/LibraryDBproject/LDBproj/LDBproject.csproj @@ -8,4 +8,13 @@ enable + + + + + + + + + \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/MainForm.Designer.cs b/LibraryDBproject/LDBproj/MainForm.Designer.cs index 646d899..eca7d93 100644 --- a/LibraryDBproject/LDBproj/MainForm.Designer.cs +++ b/LibraryDBproject/LDBproj/MainForm.Designer.cs @@ -1,4 +1,4 @@ -namespace LDBproj +namespace LDBproject { partial class MainForm { @@ -28,12 +28,149 @@ /// 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"; + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(MainForm)); + menuStrip1 = new MenuStrip(); + toolStripMenuItem1 = new ToolStripMenuItem(); + menuStrip2 = new MenuStrip(); + StaffTSMI = new ToolStripMenuItem(); + EmployeeCard = new ToolStripMenuItem(); + ReaderCard = new ToolStripMenuItem(); + BookReg = new ToolStripMenuItem(); + OperationsTSMI = new ToolStripMenuItem(); + GiveOut = new ToolStripMenuItem(); + Updating = new ToolStripMenuItem(); + LogsTSMI = new ToolStripMenuItem(); + menuStrip1.SuspendLayout(); + menuStrip2.SuspendLayout(); + SuspendLayout(); + // + // menuStrip1 + // + menuStrip1.ImageScalingSize = new Size(24, 24); + menuStrip1.Items.AddRange(new ToolStripItem[] { toolStripMenuItem1 }); + menuStrip1.Location = new Point(0, 33); + menuStrip1.Name = "menuStrip1"; + menuStrip1.Size = new Size(800, 24); + menuStrip1.TabIndex = 0; + menuStrip1.Text = "menuStrip1"; + // + // toolStripMenuItem1 + // + toolStripMenuItem1.Name = "toolStripMenuItem1"; + toolStripMenuItem1.Size = new Size(16, 20); + // + // menuStrip2 + // + menuStrip2.BackColor = Color.GreenYellow; + menuStrip2.ImageScalingSize = new Size(24, 24); + menuStrip2.Items.AddRange(new ToolStripItem[] { StaffTSMI, OperationsTSMI, LogsTSMI }); + menuStrip2.Location = new Point(0, 0); + menuStrip2.Name = "menuStrip2"; + menuStrip2.Size = new Size(800, 33); + menuStrip2.TabIndex = 1; + menuStrip2.Text = "menuStrip2"; + // + // StaffTSMI + // + StaffTSMI.DropDownItems.AddRange(new ToolStripItem[] { EmployeeCard, ReaderCard, BookReg }); + StaffTSMI.ForeColor = Color.DarkSlateBlue; + StaffTSMI.Name = "StaffTSMI"; + StaffTSMI.Size = new Size(256, 29); + StaffTSMI.Text = "Персональная информация"; + // + // EmployeeCard + // + EmployeeCard.BackColor = Color.DarkSlateBlue; + EmployeeCard.ForeColor = Color.GreenYellow; + EmployeeCard.Name = "EmployeeCard"; + EmployeeCard.Size = new Size(273, 34); + EmployeeCard.Text = "Карта сотрудника"; + EmployeeCard.Click += EmployeeCard_Click; + // + // ReaderCard + // + ReaderCard.BackColor = Color.DarkSlateBlue; + ReaderCard.ForeColor = Color.GreenYellow; + ReaderCard.Name = "ReaderCard"; + ReaderCard.Size = new Size(273, 34); + ReaderCard.Text = "Читательский билет"; + ReaderCard.Click += ReaderCard_Click; + // + // BookReg + // + BookReg.BackColor = Color.DarkSlateBlue; + BookReg.ForeColor = Color.GreenYellow; + BookReg.Name = "BookReg"; + BookReg.Size = new Size(273, 34); + BookReg.Text = "Книга"; + BookReg.Click += BookReg_Click; + // + // OperationsTSMI + // + OperationsTSMI.DropDownItems.AddRange(new ToolStripItem[] { GiveOut, Updating }); + OperationsTSMI.ForeColor = Color.DarkSlateBlue; + OperationsTSMI.Name = "OperationsTSMI"; + OperationsTSMI.Size = new Size(112, 29); + OperationsTSMI.Text = "Операции"; + // + // GiveOut + // + GiveOut.BackColor = Color.DarkSlateBlue; + GiveOut.ForeColor = Color.GreenYellow; + GiveOut.Name = "GiveOut"; + GiveOut.Size = new Size(289, 34); + GiveOut.Text = "Оформление выдачи"; + GiveOut.Click += GiveOut_Click; + // + // Updating + // + Updating.BackColor = Color.DarkSlateBlue; + Updating.ForeColor = Color.GreenYellow; + Updating.Name = "Updating"; + Updating.Size = new Size(289, 34); + Updating.Text = "Обновление билета"; + Updating.Click += Updating_Click; + // + // LogsTSMI + // + LogsTSMI.ForeColor = Color.DarkSlateBlue; + LogsTSMI.Name = "LogsTSMI"; + LogsTSMI.Size = new Size(88, 29); + LogsTSMI.Text = "Отчёты"; + // + // MainForm + // + AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleMode = AutoScaleMode.Font; + BackgroundImage = (Image)resources.GetObject("$this.BackgroundImage"); + BackgroundImageLayout = ImageLayout.Stretch; + ClientSize = new Size(800, 450); + Controls.Add(menuStrip1); + Controls.Add(menuStrip2); + DoubleBuffered = true; + MainMenuStrip = menuStrip1; + Name = "MainForm"; + Text = "WorkForm"; + menuStrip1.ResumeLayout(false); + menuStrip1.PerformLayout(); + menuStrip2.ResumeLayout(false); + menuStrip2.PerformLayout(); + ResumeLayout(false); + PerformLayout(); } #endregion + + private MenuStrip menuStrip1; + private ToolStripMenuItem toolStripMenuItem1; + private MenuStrip menuStrip2; + private ToolStripMenuItem StaffTSMI; + private ToolStripMenuItem EmployeeCard; + private ToolStripMenuItem OperationsTSMI; + private ToolStripMenuItem GiveOut; + private ToolStripMenuItem LogsTSMI; + private ToolStripMenuItem ReaderCard; + private ToolStripMenuItem BookReg; + private ToolStripMenuItem Updating; } } diff --git a/LibraryDBproject/LDBproj/MainForm.cs b/LibraryDBproject/LDBproj/MainForm.cs index 9458727..9aaeadd 100644 --- a/LibraryDBproject/LDBproj/MainForm.cs +++ b/LibraryDBproject/LDBproj/MainForm.cs @@ -1,10 +1,82 @@ -namespace LDBproj +using LDBproject.AdditionalForms; +using Unity; + +namespace LDBproject; + +public partial class MainForm : Form { - public partial class MainForm : Form + private readonly IUnityContainer _container; + + public MainForm(IUnityContainer container) { - public MainForm() + InitializeComponent(); + _container = container ?? + throw new ArgumentNullException(nameof(container)); + } + + private void EmployeeCard_Click(object sender, EventArgs e) + { + try { - InitializeComponent(); + _container.Resolve().ShowDialog(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Download : mistake ]", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ReaderCard_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Download : mistake ]", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void BookReg_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Download : mistake ]", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void GiveOut_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Download : mistake ]", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void Updating_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Download : mistake ]", + MessageBoxButtons.OK, MessageBoxIcon.Error); } } } + diff --git a/LibraryDBproject/LDBproj/MainForm.resx b/LibraryDBproject/LDBproj/MainForm.resx index 1af7de1..7a27bf0 100644 --- a/LibraryDBproject/LDBproj/MainForm.resx +++ b/LibraryDBproject/LDBproj/MainForm.resx @@ -1,17 +1,17 @@  - @@ -117,4 +117,3057 @@ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + 17, 17 + + + 175, 17 + + + + + iVBORw0KGgoAAAANSUhEUgAAEoEAAAzNCAYAAACuAAQ5AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAL + DQAACw0B7QfALAAA/7JJREFUeF7s3DFuHFnaqOnZwHWuQYMJNA1doIQcGiygxCYNNVAFXRksQA1SLVx6 + NARaVU7nWLSUFr3hCqQV6N+AVqBeAXfAFcwCcngo8C+V6pNIMeOLE3HiMR4M5m8V+Z3IiBPJC5z3//p/ + /7//uQIAAAAAAAAAAAAAAAAAAAAAAKBfIlAAAAAAAAAAAAAAAAAAAAAAAAAViEABAAAAAAAAAAAAAAAA + AAAAAABUIAIFAAAAAAAAAAAAAAAAAAAAAABQgQgUAAAAAAAAAAAAAAAAAAAAAABABSJQAAAAAAAAAAAA + AAAAAAAAAAAAFYhAAQAAAAAAAAAAAAAAAAAAAAAAVCACBQAAAAAAAAAAAAAAAAAAAAAAUIEIFAAAAAAA + AAAAAAAAAAAAAAAAQAUiUAAAAAAAAAAAAAAAAAAAAAAAABWIQAEAAAAAAAAAAAAAAAAAAAAAAFQgAgUA + AAAAAAAAAAAAAAAAAAAAAFCBCBQAAAAAAAAAAAAAAAAAAAAAAEAFIlAAAAAAAAAAAAAAAAAAAAAAAAAV + iEABAAAAAAAAAAAAAAAAAAAAAABUIAIFAAAAAAAAAAAAAAAAAAAAAABQgQgUAAAAAAAAAAAAAAAAAAAA + AABABSJQAAAAAAAAAAAAAAAAAAAAAAAAFYhAAQAAAAAAAAAAAAAAAAAAAAAAVCACBQAAAAAAAAAAAAAA + AAAAAAAAUIEIFAAAAAAAAAAAAAAAAAAAAAAAQAUiUAAAAAAAAAAAAAAAAAAAAAAAABWIQAEAAAAAAAAA + AAAAAAAAAAAAAFQgAgUAAAAAAAAAAAAAAAAAAAAAAFCBCBQAAAAAAAAAAAAAAAAAAAAAAEAFIlAAAAAA + AAAAAAAAAAAAAAAAAAAViEABAAAAAAAAAAAAAAAAAAAAAABUIAIFAAAAAAAAAAAAAAAAAAAAAABQgQgU + AAAAAAAAAAAAAAAAAAAAAABABSJQAAAAAAAAAAAAAAAAAAAAAAAAFYhAAQAAAAAAAAAAAAAAAAAAAAAA + VCACBQAAAAAAAAAAAAAAAAAAAAAAUIEIFAAAAAAAAAAAAAAAAAAAAAAAQAUiUAAAAAAAAAAAAAAAAAAA + AAAAABWIQAEAAAAAAAAAAAAAAAAAAAAAAFQgAgUAAAAAAAAAAAAAAAAAAAAAAFCBCBQAAAAAAAAAAAAA + AAAAAAAAAEAFIlAAAAAAAAAAAAAAAAAAAAAAAAAViEABAAAAAAAAAAAAAAAAAAAAAABUIAIFAAAAAAAA + AAAAAAAAAAAAAABQgQgUAAAAAAAAAAAAAAAAAAAAAABABSJQAAAAAAAAAAAAAAAAAAAAAAAAFYhAAQAA + AAAAAAAAAAAAAAAAAAAAVCACBQAAAAAAAAAAAAAAAAAAAAAAUIEIFAAAAAAAAAAAAAAAAAAAAAAAQAUi + UAAAAAAAAAAAAAAAAAAAAAAAABWIQAEAAAAAAAAAAAAAAAAAAAAAAFQgAgUAAAAAAAAAAAAAAAAAAAAA + AFCBCBQAAAAAAAAAAAAAAAAAAAAAAEAFIlAAAAAAAAAAAAAAAAAAAAAAAAAViEABAAAAAAAAAAAAAAAA + AAAAAABUIAIFAAAAAAAAAAAAAAAAAAAAAABQgQgUAAAAAAAAAAAAAAAAAAAAAABABSJQAAAAAAAAAAAA + AAAAAAAAAAAAFYhAAQAAAAAAAAAAAAAAAAAAAAAAVCACBQAAAAAAAAAAAAAAAAAAAAAAUIEIFAAAAAAA + AAAAAAAAAAAAAAAAQAUiUAAAAAAAAAAAAAAAAAAAAAAAABWIQAEAAAAAAAAAAAAAAAAAAAAAAFQgAgUA + AAAAAAAAAAAAAAAAAAAAAFCBCBQAAAAAAAAAAAAAAAAAAAAAAEAFIlAAAAAAAAAAAAAAAAAAAAAAAAAV + iEABAAAAAAAAAAAAAAAAAAAAAABUIAIFAAAAAAAAAAAAAAAAAAAAAABQgQgUAAAAAAAAAAAAAAAAAAAA + AABABSJQAAAAAAAAAAAAAAAAAAAAAAAAFYhAAQAAAAAAAAAAAAAAAAAAAAAAVCACBQAAAAAAAAAAAAAA + AAAAAAAAUIEIFAAAAAAAAAAAAAAAAAAAAAAAQAUiUAAAAAAAAAAAAAAAAAAAAAAAABWIQAEAAAAAAAAA + AAAAAAAAAAAAAFQgAgUAAAAAAAAAAAAAAAAAAAAAAFCBCBQAAAAAAAAAAAAAAAAAAAAAAEAFIlAAAAAA + AAAAAAAAAAAAAAAAAAAViEABAAAAAAAAAAAAAAAAAAAAAABUIAIFAAAAAAAAAAAAAAAAAAAAAABQgQgU + AAAAAAAAAAAAAAAAAAAAAABABSJQAAAAAAAAAAAAAAAAAAAAAAAAFYhAAQAAAAAAAAAAAAAAAAAAAAAA + VCACBQAAAAAAAAAAAAAAAAAAAAAAUIEIFAAAAAAAAAAAAAAAAAAAAAAAQAUiUAAAAAAAAAAAAAAAAAAA + AAAAABWIQAEAAAAAAAAAAAAAAAAAAAAAAFQgAgUAAAAAAAAAAAAAAAAAAAAAAFCBCBQAAAAAAAAAAAAA + AAAAAAAAAEAFIlAAAAAAAAAAAAAAAAAAAAAAAAAViEABAAAAAAAAAAAAAAAAAAAAAABUIAIFAAAAAAAA + AAAAAAAAAAAAAABQgQgUwD29udy8sfjwaPXb+8er07fbq5OLndXx8qfV4WJ/dfD66Y1nr35ZPX3+/MbO + /J9/8eh//B8AAAAAAAAAAAAAAAAAAACAyZvPjv67x3DbaijdhtJvKD2HovQdSuvh7OPW6vxqI2xCwJiJ + QAGTVl7ut2Gn26jTbdDpNuJUvjBEXyQAAAAAAAAAAAAAAAAAAAAA6FfpQOzuHdzEoj6PRAlEMVYiUEDz + SuTpt/eP/xR4Ki9zcScAAAAAAAAAAAAAAAAAAACAdpSWxNPnz2/6EqU1cfZxK2xRwJCIQAFN+DL0VGqN + O/N/hi9sAAAAAAAAAAAAAAAAAAAAAKbhNgx1vPxptfjwaHV+tRG2K6AWEShgVMqLtLxQS+zp4PXT1e7e + wc3LNnoJAwAAAAAAAAAAAAAAAAAAAMCXShTqcLF/07CI+hbQJxEoYLBK8Om3949vgk/PXv2y2pn/M3yx + AgAAAAAAAAAAAAAAAAAAAMBDlSjU6bvt1ZvLzbCBAZlEoIBBKMGnUkcUfAIAAAAAAAAAAAAAAAAAAACg + lt29g9XhYv+mgxE1MqBrIlBAFaV8ePp2++alJ/gEAAAAAAAAAAAAAAAAAAAAwNDszF+sDl4/FYQilQgU + 0Iuzj1urk4udmxfbfHYUvvgAAAAAAAAAAAAAAAAAAAAAYIhKEOp4+WT15nIzbGvAQ4lAASnKC6tEn569 + +kX0CQAAAAAAAAAAAAAAAAAAAIBmPH3+fHX6bjtsbsD3EoECOnF+tbE6fbu9Onj9VPQJAAAAAAAAAAAA + AAAAAAAAgObtzF/ctDbeXG6GPQ64DxEo4MEWHx6tjpdPbuqE0YsKAAAAAAAAAAAAAAAAAAAAAKag9DdO + 322HjQ74FhEo4N7OrzZWp2+3bwqE89lR+EICAAAAAAAAAAAAAAAAAAAAgKnamb8Qg+K7iEAB31TCTycX + Oze1wejFAwAAAAAAAAAAAAAAAAAAAAD8WYlBHS+frN5cboZND7glAgX8RXl5lJeI8BMAAAAAAAAAAAAA + AAAAAAAArOfg9VMxKL5KBAq4IfwEAAAAAAAAAAAAAAAAAAAAAHnEoIiIQMGEnV9tCD8BAAAAAAAAAAAA + AAAAAAAAQE925i9ueh9iUNwSgYKJKeGnk4sd4ScAAAAAAAAAAAAAAAAAAAAAqKTEoE7fbYd9EKZFBAom + YvHh0U34aT47Cl8MAAAAAAAAAAAAAAAAAAAAAEC/xKAQgYKGlfDT8fKJ8BMAAAAAAAAAAAAAAAAAAAAA + DNjB66erN5ebYUOEtolAQWPOrzZWJxc7q6fPn4cbPgAAAAAAAAAAAAAAAAAAAAAwTMfLJ2FThHaJQEEj + Fh8erQ4X+6v57Cjc4AEAAAAAAAAAAAAAAAAAAACA4duZv1idvtsOGyO0RwQKRuz8amN1crGzevr8ebih + AwAAAAAAAAAAAAAAAAAAAADjdPD66erN5WbYHaEdIlAwQiX+dLx8sprPjsINHAAAAAAAAAAAAAAAAAAA + AAAYv535i9Xpu+2wQUIbRKBgRBYfHq2ePn8ebtgAAAAAAAAAAAAAAAAAAAAAQJsOXj9dvbncDJskjJsI + FAzc+dXG6vTttvgTAAAAAAAAAAAAAAAAAAAAAEzYzvzF6vTddtgoYbxEoGCgSvzpePlkNZ8dhZsyAAAA + AAAAAAAAAAAAAAAAADA9h//eD3sljJMIFAyM+BMAAAAAAAAAAAAAAAAAAAAA8C078xerN5ebYb+EcRGB + goFYfHi0+vX103DTBQAAAAAAAAAAAAAAAAAAAAD43Hz2cnVy8WPYMmE8RKCgshJ/evr8ebjRAgAAAAAA + AAAAAAAAAAAAAAB8y+G/91fnVxth24ThE4GCSsSfAAAAAAAAAAAAAAAAAAAAAIAu7MxfrN5cboadE4ZN + BAp6Jv4EAAAAAAAAAAAAAAAAAAAAAHSthKBK2yRqnjBcIlDQE/EnAAAAAAAAAAAAAAAAAAAAACDb8fJJ + 2D9hmESgIJn4EwAAAAAAAAAAAAAAAAAAAADQJyGo8RCBgiTLy03xJwAAAAAAAAAAAAAAAAAAAACgitI+ + Ob/aCNsoDIcIFHSsbHyHi/1wYwQAAAAAAAAAAAAAAAAAAAAA6MvO/MXqzeVm2ElhGESgoCMl/nS8fLKa + z47CDREAAAAAAAAAAAAAAAAAAAAAoG9CUMMmAgUdOLnYEX8CAAAAAAAAAAAAAAAAAAAAAAaphKDOPm6F + 7RTqEoGCNSw+PLrZ4KKNDwAAAAAAAAAAAAAAAAAAAABgKOazl0JQAyQCBQ9QNrOnz5+Hmx0AAAAAAAAA + AAAAAAAAAAAAwFCdvtsOmyrUIQIF3+H8amN1uNgPNzcAAAAAAAAAAAAAAAAAAAAAgDEQghoOESi4p5OL + ndV8dhRuagAAAAAAAAAAAAAAAAAAAAAAYyIENQwiUHCHxYdHq6fPn4cbGQAAAAAAAAAAAAAAAAAAAADA + WAlB1ScCBV9xfrWxOlzsh5sXAAAAAAAAAAAAAAAAAAAAAEALhKDqEoGCwMnFzmo+Owo3LQAAAAAAAAAA + AAAAAAAAAACAlpx93Ao7LOQTgYLPLC83V0+fPw83KgAAAAAAAAAAAAAAAAAAAACAFs1nL4WgKhGBgmvn + Vxur4+WT683oKNykAAAAAAAAAAAAAAAAAAAAAABaVkJQby43wz4LeUSgmLzFh0ernfmLcGMCAAAAAAAA + AAAAAAAAAAAAAJiK0mERguqXCBSTdX61sTpc7IebEQAAAAAAAAAAAAAAAAAAAADAFJUQVGmzRM0WuicC + xSQtPjy62WyiTQgAAAAAAAAAAAAAAAAAAAAAYMqePn8edlvonggUk1IKc4eL/XDjAQAAAAAAAAAAAAAA + AAAAAADgk8N/74cNF7olAsVkLD48Wu3MX4QbDgAAAAAAAAAAAAAAAAAAAAAAf3Zy8WPYcqE7IlA07/xq + Y3W42A83GQAAAAAAAAAAAAAAAAAAAAAAvm7x4VHYdaEbIlA07ezj1mpn/iLcXAAAAAAAAAAAAAAAAAAA + AAAA+Lb57OXqzeVm2HdhfSJQNOvkYifcVAAAAAAAAAAAAAAAAAAAAAAAuL/dvYPV+dVG2HlhPSJQNGd5 + ubl6+vx5uJkAAAAAAAAAAAAAAAAAAAAAAPD9Dv+9H/ZeWI8IFE35/f3j1Xx2FG4iAAAAAAAAAAAAAAAA + AAAAAAA83MnFj2H3hYcTgaIJ51cbq8PFfrhxAAAAAAAAAAAAAAAAAAAAAACwvvns5erN5WbYgOFhRKAY + veX1prAzfxFuGgAAAAAAAAAAAAAAAAAAAAAAdKe0Xs6vNsIWDN9PBIpRO7nYWc1nR+FmAQAAAAAAAAAA + AAAAAAAAAABA9w7/vR/2YPh+IlCMUinB/fr6H+EGAQAAAAAAAAAAAAAAAAAAAABArsWHR2Ebhu8jAsXo + LC83VzvzF+HGAAAAAAAAAAAAAAAAAAAAAABAvvns5er8aiNsxHB/IlCMyum77euH/yjcFAAAAAAAAAAA + AAAAAAAAAAAA6M+zV7+EnRjuTwSK0Thc7IcbAQAAAAAAAAAAAAAAAAAAAAAAdfz2/nHYi+F+RKAYvOXl + 5mp37yDcAAAAAAAAAAAAAAAAAAAAAAAAqGc+e7k6v9oI2zHcTQSKQTv7uLXamb8IH34AAAAAAAAAAAAA + AAAAAAAAAOp79uqXsB/D3USgGKyTi53wgQcAAAAAAAAAAAAAAAAAAAAAYFgWHx6FHRm+TQSKQTpc7IcP + OgAAAAAAAAAAAAAAAAAAAAAAw7Mzf7E6v9oIezJ8nQgUg1Ie4qfPn4cPOQAAAAAAAAAAAAAAAAAAAAAA + w3W8/CnsyvB1IlAMxvJy86bmFj3cAAAAAAAAAAAAAAAAAAAAAAAM23z2cvXmcjPsyxATgWIQFh8eXT/A + R+GDDQAAAAAAAAAAAAAAAAAAAADAODx9/jxszBATgaK6k4ud8GEGAAAAAAAAAAAAAAAAAAAAAGB8Fh8e + ha0Z/koEiqqOl0/ChxgAAAAAAAAAAAAAAAAAAAAAgHHamb8IezP8lQgUVZxfbax+ff2P8AEGAAAAAAAA + AAAAAAAAAAAAAGDcTi5+DNsz/JkIFL1bXm6udvcOwgcXAAAAAAAAAAAAAAAAAAAAAIDxm89ers6vNsIG + DX8QgaJXJQC1M38RPrQAAAAAAAAAAAAAAAAAAAAAALTjePlT2KHhDyJQ9Obs45YAFAAAAAAAAAAAAAAA + AAAAAADARMxnL1fnVxthj4ZPRKDoxeLDo+sH8ih8UAEAAAAAAAAAAAAAAAAAAAAAaNPx8qewScMnIlCk + O323HT6cAAAAAAAAAAAAAAAAAAAAAAC0bT57uTq/2gjbNIhAkex4+SR8MAEAAAAAAAAAAAAAAAAAAAAA + mIbj5U9hnwYRKBIJQAEAAAAAAAAAAAAAAAAAAAAAMJ+9XJ1fbYSdmqkTgSKFABQAAAAAAAAAAAAAAAAA + AAAAALeOlz+FrZqpE4Gic4eL/fAhBAAAAAAAAAAAAAAAAAAAAABgmuazl6vzq42wWTNlIlB06tfX/wgf + QAAAAAAAAAAAAAAAAAAAAAAApu14+VPYrZkyESg6IwAFAAAAAAAAAAAAAAAAAAAAAMDX7MxfhO2aKROB + ohMCUAAAAAAAAAAAAAAAAAAAAAAA3GXx4VHYsJkqESjWcn61sXr6/Hn4sAEAAAAAAAAAAAAAAAAAAAAA + wOdKryZq2UyVCBQPVgJQu3sH4YMGAAAAAAAAAAAAAAAAAAAAAACRxYdHYdNmikSgeBABKAAAAAAAAAAA + AAAAAAAAAAAAHuJwsR92baZIBIoHEYACAAAAAAAAAAAAAAAAAAAAAOAh5rOXq/OrjbBtMzUiUHy3X1// + I3ywAAAAAAAAAAAAAAAAAAAAAADgPk4udsK+zdSIQPFdBKAAAAAAAAAAAAAAAAAAAAAAAFjX0+fPw8bN + 1IhAcW8CUAAAAAAAAAAAAAAAAAAAAAAAdOXN5WbYupkSESju5XCxHz5EAAAAAAAAAAAAAAAAAAAAAADw + EMfLn8LezZSIQHGn4+WT8AECAAAAAAAAAAAAAAAAAAAAAICH2pm/CJs3UyICxTcJQAEAAAAAAAAAAAAA + AAAAAAAAkGXx4VHYvpkKESi+SgAKAAAAAAAAAAAAAAAAAAAAAIBMh4v9sH8zFSJQhE7fbYcPDAAAAAAA + AAAAAAAAAAAAAAAAdGU+exk2cKZCBIq/+P394/BhAQAAAAAAAAAAAAAAAAAAAACAri0+PApbOFMgAsWf + nH3cWs1nR+GDAgAAAAAAAAAAAAAAAAAAAAAAXTte/hT2cKZABIr/trzcXO3MX4QPCQAAAAAAAAAAAAAA + AAAAAAAAZCjdm6iJMwUiUNwQgAIAAAAAAAAAAAAAAAAAAAAAoJY3l5thG6d1IlCszq82Vrt7B+GDAQAA + AAAAAAAAAAAAAAAAAAAA2U4udsI+TutEoFg9+9fP4UMBAAAAAAAAAAAAAAAAAAAAAAB9ePr8edjHaZ0I + 1MQdL5+EDwQAAAAAAAAAAAAAAAAAAAAAAPRlPnu5Or/aCDs5LROBmjABKAAAAAAAAAAAAAAAAAAAAAAA + hmLx4VHYymmZCNRE/f7+cfgQAAAAAAAAAAAAAAAAAAAAAABADYeL/bCX0zIRqAlaXm6u5rOj8CEAAAAA + AAAAAAAAAAAAAAAAAIAanj5/HjZzWiYCNTHnVxs3N/rO/MW91QpGRbNki+bIVq5vNEumKX2mUxJdc9ZX + 4xm9Fc2TzZ6UK5ojW817eApq3L8+01y19qTdvYOb7+mtK9c4Wn+2Lz/nPkRzZKuxP9R6ZqJZGLfocwYA + AAAAAAAAAAAAAABgmkojJ2rntEoEijsdL38KH5ZM5QBoNEu2GgdPT9/93+EsmRYfHoWzZItmoRvLy1l4 + zfm6Eix4+vx/rw4X+6uTi53V6dvt1dnHrdWby83BfBmwJ+WKZslWAijRLJkOXj8NZ6EbNb4nlb0rmoVu + lPdBdN2zRbO0yN8Wucp3mmiWTP62oCs1vicBAAAAAAAAAAAAAAAAMEzl/GJ0Fq1VIlDcyUHtXIIrdEEE + 6m63waff3v9wE3qKruPQ2JNyRbNkE4FqjwhUe0SgcvnbIpf3OGMmAgUAAAAAAAAAAAAAAADArXImNTqL + 1ioRKO7koHYuB7XpggjUX81nRzfxmxLzOL/aCK/b0NmTckWzZBOBao8IVHtEoHL52yLX7+8fh7Nk8rcF + XRGBAgAAAAAAAAAAAAAAAODWs1e/hGfRWiUCxZ0c1M4luEIXRKD+UOIoYw4/fc6elCuaJZsIVHtEoNoj + ApXL3xa5yjs1miWTZ4auiEABAAAAAAAAAAAAAAAAcGs+exmeRWuVCBR3clA7l+AKXZh6BGo+O7rZq1oI + P33OnpQrmiWbCFR7RKDaI2iTy98Wud5cboazZPLM0BURKAAAAAAAAAAAAAAAAAA+V+PcZC0iUNzJQe1c + git0YaoRqFbjT7fsSbmiWbKJQLVHBKo9gja5/G2Rp1bRusZnWkSzMG4iUAAAAAAAAAAAAAAAAAB8rkb/ + oBYRKO7koHYuwRW6MLUIVOvxp1v2pFzRLNlEoNojAtUeEahc/rbIU2tvOFzshfNki2Zh3ESgAAAAAAAA + AAAAAAAAAPjc4WI/PI/WIhEo7uSgdi7BFbowpQhUeUm3Hn+6ZU/KFc2STQSqPSJQ7RGByuVvizy1/h8y + nr36OZwnWzQL4yYCBQAAAAAAAAAAAAAAAMDnnr36JTyP1iIRKO7koHYuwRW6MIUIVImelHs3Wn+r7Em5 + olmyiUC1RwSqPSJQufxtkafW96Td/YNwnmzRLIybCBQAAAAAAAAAAAAAAAAAn6t1RrQGESju5KB2LsEV + utB6BOrkYidcd+vsSbmiWbKJQLVHBKo9IlC5/G2Ro9Yai/nsKJwpWzQL4yYCBQAAAAAAAAAAAAAAAMCX + zq82wjNprRGB4k4OaucSXKELrUagyjN59nErXPMU2JNyRbNkE4FqjwhUe0SgcvnbIketvf7sP38L5+lD + NA/jJgIFAAAAAAAAAAAAAAAAwJem0pwQgeJODmrnElyhCy1GoA4X+5MpMn6NPSlXNEs2Eaj2iEC1RwQq + l78tcry5/i4YzZDtt//6IZynD9E8jJsIFAAAAAAAAAAAAAAAAABfqtFAqEEEijs5qJ1LcIUutBaBOrnY + Cdc5NfakXNEs2USg2iMC1R4RqFz+tuhezX2+xud5K5qHcROBAgAAAAAAAAAAAAAAAOBLh4v98Exaa0Sg + uJOD2rkEV+hCKxGo+ezo5v6M1jhF9qRc0SzZRKDaIwLVHhGoXP626N6b6++B0e/vQ81oTzQP4yYCBQAA + AAAAAAAAAAAAAMCXpnJeXgSKOzmonUtwhS60EIEqz1/NiMEQ2ZNyRbNkE4FqjwhUe0Sgcvnbolu19/gS + 8Izm6kM0D+MmAgUAAAAAAAAAAAAAAADAl/6+dxCeSWuNCBR3clA7l+AKXRh7BKo8ewJQf2VPyhXNkk0E + qj0iUO0Rgcrlb4vu1P7+VOv9fSuaiXETgQIAAAAAAAAAAAAAAADgS/PZy/BMWmtEoLiTg9q5BFfowpgj + ULUDBkNmT8oVzZJNBKo9IlDtEYHK5W+L7py+2w5/b19OLnbCufoSzcS4iUABAAAAAAAAAAAAAAAAEDm/ + 2gjPpbVEBIo7OaidS3CFLow1AlWeOQGor7Mn5YpmySYC1R4RqPaIQOXyt0U3Dhf74e/sU+1gTzQT4yYC + BQAAAAAAAAAAAAAAAEDkzeVmeC6tJSJQ3MlB7VyCK3RhjBGo8rwJQH2bPSlXNEs2Eaj2iEC1RwQql78t + 1ld+bu1i9fJyM5ytT9FcjJsIFAAAAAAAAAAAAAAAAACR0iSIzqW1RASKOzmonUtwhS6MLQJVnjUBqLvZ + k3JFs2QTgWqPCFR7RKBy+dtiPUP5DlXrOflcNBfjJgIFAAAAAAAAAAAAAAAAQKRGB6FvIlDcyUHtXIIr + dGFMEaj57EgA6p7sSbmiWbKJQLVHBKo9IlC5/G3xcOXnDeU71BBiPdFcjJsIFAAAAAAAAAAAAAAAAACR + k4ud8FxaS0SguJOD2rkEV+jCmCJQv79/HK6Bv7In5YpmySYC1R4RqPaIQOXyt8XDlJ81lADU8nIznLFv + 0WyMmwgUAAAAAAAAAAAAAAAAAJHDxX54Lq0lIlDcyUHtXIIrdGEsEaiyn0TzE7Mn5YpmySYC1R4RqPaI + QOXyt8X32907GEwAqvj1+r0Szdm3aDbGTQQKAAAAAAAAAAAAAAAAgMgUzsyLQHEnB7VzCa7QhTFEoJ79 + 6+dwdr7OnpQrmiWbCFR7RKDaIwKVy98W36eUqc+vNsKfX0OZpcb3k0g0H+MmAgUAAAAAAAAAAAAAAABA + 5NmrX8JzaS0RgeJODmrnElyhC0OPQJVn6831jNHsfJ09KVc0SzYRqPaIQLVHBCqXvy3uZz47Wv3+/nH4 + c2uq9XxEovkYNxEoAAAAAAAAAAAAAAAAACJTOF8tAsWdHNTOJbhCF4YegSr3XDQ332ZPyhXNkk0Eqj0i + UO0Rgcrlb4u7HS72V+dXG+HPrK3Gd5OvieZj3ESgAAAAAAAAAAAAAAAAAIj8fe8gPJfWEhEo7uSgdi7B + Fbow5AhUCRlEM3M3e1KuaJZsIlDtEYFqjwhULn9bxOazo5vvTG+uv9NFP2sIaj0bXxPNyLiJQAEAAAAA + AAAAAAAAAAAQqXVWtE8iUNzJQe1cgit0YagRqPJMnV9thDNzN3tSrmiWbCJQ7RGBao8IVC5/W/xZeZ5P + LnZG8X2pxveSb4lmZNxEoAAAAAAAAAAAAAAAAACI1Dor2icRKO7koHYuwRW6MNQI1Om77XBe7seelCua + JZsIVHtEoNojApVryn9bzGdHq929g9XhYv/mPhtTKPN4+eRPaxmCaE7GTQQKAAAAAAAAAAAAAAAAgEit + s6J9EoEasGevfrk5BFlbjQjJUA5q90FwJdfJxU54X7emBAWia17TGMMzby43b6IMJVBR5r/dh0usIfr3 + 2exJuaJZspX7KZolU7mPPt8v6FaN53Q+exnOkq3skdF9nanGe7zGZ1pE6892+77rU43vLOUzjdafrbzf + zj5u3Tw7Ywo+fWl5PX90XWuLnl/GrYTSos8aAAAAAAAAAAAAAAAAAKIzkC0RgRqo4+WT8IaciloHtWsc + +hdcyfXr66fhLOR7czkLP5MhKUGGEn0qUYpvHTp/+vx/h/99NntSrmiWbCVwEM0CY1AjAjWl93i0/mxT + 2ZNq/W3RCt+nAQAAAAAAAAAAAAAAAIDaojOQLRGBGqDl5WZ4M06JCFQuESiylahS9HkMRXkGDhf73ww/ + fU4EKpcIFIyDCFSuaP3ZRKC4S4llRtcUAAAAAAAAAAAAAAAAAKBP0TnIlohADdDu3kF4M06JCFQuESiy + vbmchZ9HbSWy95DghQhULhEoGAcRqFzR+rOJQPEt5XtTje8iAAAAAAAAAAAAAAAAAABfis5CtkQEamBO + 326HN+LUiEDlEoEi08H1NY8+i5rOrzZWx8sn4bz3IQKVSwQKxkEEKle0/mwiUHyL79EAAAAAAAAAAAAA + AAAAwFBEZyFbIgI1IMvLzSrBjyESgcolAkWmN5ez8LOo5ezj1trPtghULhEoGAcRqFzR+rOJQPE168Qz + AQAAAAAAAAAAAAAAAAC6Fp2HbIkI1ICI1fxBBCqXCBRZnr36Jfwcajm52Ann/F4iULlEoGAcRKByRevP + JgJFpMSJo+sIAAAAAAAAAAAAAAAAAFBLdCayJSJQA+Gg7Z+JQOUSgSLL7+8fh59DDcfLJ+GMDyEClUsE + CsZBBCpXtP5sIlB8qfxdWuP7BwAAAAAAAAAAAAAAAADAt0TnIlsiAjUQDtr+Wa2D2oIruaJZsolA9WdI + gYXDxX4440OJQOUSgYJxEIHKFa0/mwgUnzu/2ljt7h2E1xAAAAAAAAAAAAAAAAAAoKbobGRLRKAG4PTt + dnjzTZkIVC4RKDIcXF/r6DPoW9cBqEIEKpcIFIyDCFSuaP3ZRKD43K+v/xFePwAAAAAAAAAAAAAAAACA + 2qKzkS0RgapseblZJfIxdCJQuUSgyHD2cSv8DPp0vHwSzrYuEahcIlAwDiJQuaL1ZxOB4lbWdygAAAAA + AAAAAAAAAAAAgC5E5yNbIgJVmUBNTAQqlwgUXRtCXOHkYiecrQsiULlEoGAcRKByRevPJgJFIQAFAAAA + AAAAAAAAAAAAAAxddEayJSJQFS0vN8ObDhGobCJQdO3g+jpH178vZT+dz47C2bogApVLBArGQQQqV7T+ + bCJQCEABAAAAAAAAAAAAAAAAAGMQnZNsiQhURc/+9XN40yEClU0Eiq6Veyq6/n3JfnZFoHKJQME4iEDl + itafTQRq2gSgAAAAAAAAAAAAAAAAAICxiM5KtkQEqpLTt9vhDccnIlC5RKDoWnTt+9JHwEAEKpcIFIyD + CFSuaP3ZRKCm63CxH14rAAAAAAAAAAAAAAAAAIAhis5LtkQEqpIaYY8xEYHKJQJFl2oFkorl5WYvz60I + VC4RKBgHEahc0fqziUBNz/nVxvVz9Y/wOgEAAAAAAAAAAAAAAAAADFV0brIlIlAVnL7dDm82/iAClUsE + ii4dLvbDa9+Hvj5fEahcIlAwDiJQuaL1ZxOBmpYSz9zdOwivEQAAAAAAAAAAAAAAAADAkEVnJ1siAtWz + cvC2RtRjbESgcolA0aXf3z8Or322sp9G82QQgcolAgXjIAKVK1p/NhGo6SjvWn+HAgAAAAAAAAAAAAAA + AABjFZ2fbIkIVM+Ol0/CG40/E4HKJQJFl84+boXXPtvp2+1wngwiULlEoGAcRKByRevPJgI1DScXO+F1 + AQAAAAAAAAAAAAAAAAAYi+gMZUtEoHq0vNwMbzL+SgQqlwgUXYquex/6fF5FoHKJQME4iEDlitafTQSq + beXvT+8dAAAAAAAAAAAAAAAAAKAF0VnKlohA9UiM5v5EoHKJQNGVv+8dhNc929l//hbOk0UEKpcIFIyD + CFSuaP3ZRKDadXKxs5rPjsLrAQAAAAAAAAAAAAAAAAAwNtF5ypaIQPVkebkZ3mDERKByiUDRlVpxpBI2 + iObJIgKVSwQKxkEEKle0/mwiUO05+7jlXQMAAAAAAAAAAAAAAAAANCc6V9kSEaieCNF8HxGoXCJQdOVw + sR9e92x9xw1EoHKJQME4iEDlitafTQSqHedXGzffy6L1AwAAAAAAAAAAAAAAAACMXXS+siUiUD1YXm6G + NxdfJwKVSwSKrhwvfwqve7b57CicJ4sIVC4RKBgHEahc0fqziUCNX4k/HS+f9P7dCAAAAAAAAAAAAAAA + AACgT9E5y5aIQPVAhOb7iUDlEoGiKzXu3xI7iGbJJAKVSwQKxkEEKle0/mwiUOMl/gQAAAAAAAAAAAAA + AAAATEl03rIlIlDJlpeb4Y3Ft4lA5RKBoiu/v38cXvdMNe5fEahcIlAwDiJQuaL1ZxOBGp/yzvQuAQAA + AAAAAAAAAAAAAACmJjp32RIRqGQO6D6MCFQuESi6Uu6l6LpnOn27Hc6SSQQqlwgUjIMIVK5o/dlEoMah + vCePl09W89lRuD4AAAAAAAAAAAAAAAAAgNZFZzBbIgKVqFbUogUiULlEoOhKjQjUycVOOEsmEahcIlAw + DiJQuaL1ZxOBGqbzq43Vb+8frw4X+8JPAAAAAAAAAAAAAAAAAADXojOZLRGBSiT08HAiULlEoOhKjQjU + 8fKncJZMIlC5RKBgHESgckXrzyYCVV95rsp7sEQuD67v9535P8M1AAAAAAAAAAAAAAAAAABMWXROsyUi + UElqBS1aIQKVSwSKrohA5bIn5YpmySYC9Ydyf+/uHdxET4rDxf7N8/258n9/9q+fb65bjeeBPxOByhWt + P9viw/9anb7d7lWNfbDW3xZfU56lEn0q93e5HvPZUTg343T7fivvr9t33JfK5+6zBwAAAAAAAAAAAAAA + AID7i85stkQEKkmNw80tqXVQu0ZgQnAllwhULhGoXPakXNEs2ab6/aDEMErkqQRgzj5urc6vNsLrcx/l + v//t/Q83P6/83Oj3kUMEKle0/hbVeI8PLQIV+Xxv87fkOJSAU/mOePt+W2eP9PkDAAAAAAAAAAAAAAAA + wLdF5/NaIgKVYHm5Gd5M3J8IVC4RKLoiApXLnpQrmiXbVMIOt2GMEsVYJ/h0H8vL2c3vefavn8NZ6I4I + VK5o/S0Sgbq/8n4sUaAa3weIlfdb+UzKZ5P9fiu/o+yBPn8AAAAAAAAAAAAAAAAAEIHiAURn1lfroLbg + Sq5olmyex1zlXoqueyYRqFz2pFytR6DKs3JysZMexvia8ntLEGp37yCcj/WIQOWK1t8iEaiHOfu4JQhU + UXm/1fjee+s2CBXNBgAAAAAAAAAAAAAAAABTEJ2/a4kIVMeWl5vhjcT3EYHKJQJFV0SgctmTckWzZGs1 + AlU7jhERzOieCFSuaP0tEoFa32/vf2j2fTIk89nRzf1aK2wYWV7ObmYSAwMAAAAAAAAAAAAAAABgaqJz + dy0RgeqY2EA3RKByiUDRFRGoXPakXNEs2VqLdgwx/vSlEsx49urncH6+jwhUrmj9LRKB6k7Z33zXzTG0 + +FNEDAoAAAAAAAAAAAAAAACAKYnO2rVEBKpDy8vN8Cbi+4lA5RKBoisiULnsSbmiWbK1EoEq9+bv7x+H + axyq07fbYhlrEoHKFa2/RSJQ3ROD6k75zvfm+npG13mIfPYAAAAAAAAAAAAAAAAATEV0zq4lIlAdcviy + O7UOaguu5Ipmyea5zCUClcuelCuaJVsLEajDxf7q/GojXN/Qlblr7CGtEIHKFa2/RSJQeUoQaHf/ILwG + fNt8djS6uOHnzv6zVeV7IwAAAAAAAAAAAAAAAAD0JTpf1xIRqI4sLzfDG4iHEYHKJQJFV0SgctmTckWz + ZBtzBKoEMmo88xnKOsQyvp8IVK5o/S0Sgcp3+nbbHvcdyve8scYNP1fWcLjYC9cIAAAAAAAAAAAAAAAA + AGMXna1riQhUR04udsIbiIepdVBbcCVXNEs2EahcIlC57Em5olmyjTUCtbt3sHpzOQvXNFbL6/WMOcpV + gwhUrmj9LRKB6kfZ43wPvlv5Oz66fmNW1lTCjdF6AQAAAAAAAAAAAAAAAGCsojN1LRGB6kiNUEfLRKBy + iUDRFRGoXPakXNEs2cYYHTpc7IdraUWNPWWsRKByRetvkQhUv07fbvtbNVAiSTW+x/alRMB87gAAAAAA + AAAAAAAAAAC0JDpP1xIRqA6Ug7XRzcPD1TqoLbiSK5olmwhULhGoXPakXNEs2cYWgSrPW7SO1ghB3Y8I + VK5o/S0SgeqfINCflWvx5vqaRNeqJT53AAAAAAAAAAAAAAAAAFoSnaVriQhUBxys7F6tg9o1PkvBlVwi + ULlEoHLZk3JFs2QbUwRqKgGoW6KedxOByhWtv0UiUPUcLvbC6zMlu3sHkwhA3RKCAgAAAAAAAAAAAAAA + AKAV0Tm6lohAralWuKJ1IlC5RKDoighULntSrmiWbGOJQE0tAHVLCOrbRKByRetvkQhUXTWu/1CUANT5 + 1UZ4XVomBAUAAAAAAAAAAAAAAABAC6IzdC0RgVqTwEwOEahcIlB0RQQqlz0pVzRLtjFEoKYagLolBPV1 + IlC5ovW3SASqvrLPzWdH4bVqVbkHphiAuiUEBQAAAAAAAAAAAAAAAMDYRefnWiICtYbl5WZ407C+Wge1 + BVdyRbNkE4HKJQKVy56UK5ol29AjUFMPQN2qsc+MgQhUrmj9LRKBGoazj1uTCUGVz//N5Sy8DlMiBAUA + AAAAAAAAAAAAAADAmEVn51oiArUGcZk8tQ5qC67kimbJ5jnNJQKVy56UK5ol25AjUIeL/XDmqTpc7IXX + acpEoHJF62+RCNRwTCEKVNYnAPWH8plPJf4FAAAAAAAAAAAAAAAAQFuic3MtEYFaQ+sHZmuqdVC7xmcq + uJJLBCqXCFQue1KuaJZsQ41A1XrvDt2Qo101iEDlitbfIhGoYWk9BFXju+rQ1freBQAAAAAAAAAAAAAA + AADriM7MtUQEag3RDUM3ah3UFlzJFc2STQQqlwhULntSrmiWbEOMCpX77M3lLJx36s6vNpqOo3wvEahc + 0fpbJAI1PGcft1bz2VF47cas3GvRevmfq9O32+E1AwAAAAAAAAAAAAAAAIChis7LtUQEag3RDUM3ah3U + FlzJFc2STQQqlwhULntSrmiWbEOMQJ2+2w5n5ZNa9+cQiUDlitbfIhGoYWotBFXru9uY1HgWAQAAAAAA + AAAAAAAAAOChorNyLRGBWkN0w9ANEahcIlB0RQQqlz0pVzRLtqFFoA6u98hoTv7scLEXXr+pEYHKFa2/ + RSJQw3X6dju8fmNTPu83l7NwjfyZ9xsAAAAAAAAAAAAAAAAAYxGdk2uJCNQaohuGbohA5RKBoisiULns + SbmiWbINKQIlknF/51cbVZ7HoRGByhWtv0UiUMNW4/Pp2snFTrg2Yv5eAgAAAAAAAAAAAAAAAGAMojNy + LRGBWkN0w9CNWge1BVdyRbNkc6g5lwhULntSrmiWbEOKQJ2+2w5nJFbrPh0SEahc0fpbJAI1fGN+7nzW + 36+EDnf3DsLrCQAAAAAAAAAAAAAAAABDEZ2Ra4kI1BqiG4ZuiEDlEoGiKyJQuexJuaJZsg0lAiWS8TBD + injVIAKVK1p/i0Sghq9EgWp8B+lCje+mLRjzZw4AAAAAAAAAAAAAAADANETn41oiArWG6IahG7UOatc4 + +Cq4kksEKpcIVC57Uq5olmxDiQiJZDxMrXt1KESgckXrb5EI1DgsL2er+ewovJ5DVev7WivKZy4EBQAA + AAAAAAAAAAAAAMBQRWfjWiICtYbohqEbIlC5RKDoighULntSrmiWbEOIQIlkrGcoIa8aRKByRetvkQjU + eJxc7ITXc6gEDtd39nFrdPEvAAAAAAAAAAAAAAAAAKYhOhfXEhGoNUQ3DN0QgcolAkVXRKBy2ZNyRbNk + G0JA6Pf3j8PZuJ9a9+sQiEDlitbfIhGocRlL+E7gsDtTfs8BAAAAAAAAAAAAAAAAMFzRmbiWiECtIbph + 6IYIVC4RKLoiApXLnpQrmiVb7ZiGEEo3xhJF6ZoIVK5o/S0SgRqX5eVsNZ8dhdd1SE7fbYfz8zCnb7fD + 6wwAAAAAAAAAAAAAAAAAtUTn4VoiArWG6IahGyJQuUSg6IoIVC57Uq5olmy140EiGd04udgJr2/rRKBy + RetvkQjU+Ax9z/P55qjxrAIAAAAAAAAAAAAAAADA10Rn4VoiArWG6IahGyJQuUSg6IoIVC57Uq5olmy1 + I1BvLmfhXENwfrVxExm6Vf7/o383BGW2+ewovMYtE4HKFa2/RYeL/XD9mWr9bXH47/3VwfU9XL67lJDS + b+8fr84+boX/duh29w7CazsE5RpHMw/J0N9rX3O42AuvOQAAAAAAAAAAAAAAAAD0LToH1xIRqDVENwzd + EIHKJQJFV0SgctmTckWzZKsZgap1H39L+exLvGNn/s9w5vIMlP/99N12+N/XVDvoVYMIVK5o/dmmch8P + 8W+Lcu1LGGosUaha7+r7qPF99FtK7Kl8tuUzjoKBJaj17NUvN++2Gvvq9/L3FAAAAAAAAAAAAAAAAABD + EJ2Ba4kI1BqiG4ZuDPGgdhbBlVwOLeeqceheBCqXPSlXzeDKkEJKp2+3v/v+Lv9+aGuI5myZCFSuaP3Z + RKBy3XefK1GgIcbuvjTE+2U+exnOWsPyeo98yJ5VYodDjkGVqFW5R6PZAQAAAAAAAAAAAAAAAKAv0Rm4 + lohArSG6YejG0A9qd0lwJZcIVC4RqFz2pFzRLNlqBjTeXM7CmfpUAhnrXoPy3w8hllGiGNF8LROByhWt + P5sIVK7vfY+Xf3+8fBL+rCGo9b7+lmevfgln7dvJxc5qPjsKZ7yvIX/25Z1X43spAAAAAAAAAAAAAAAA + ANyKzr+1RARqDdENQzfGclC7C4IruUSgcolA5bIn5YpmyVYruFLrvfq5s49bnd3T5ecMIQS1u38Qztcq + Eahc0fqziUDleuieV/6703fb4c+sbWj3zBCuU4k3RbM9xMH1nhf9jiFYXs46e48DAAAAAAAAAAAAAAAA + wPeKzr61RARqDdENQzfGdlB7HYIruUSgcolA5bIn5YpmyVYrnvHs1S/hPH0pAaj57Cic7aHK81E7BHW4 + 2Atna5UIVK5o/dlEoHKt+x4vQaDzq43wZ9dS6539NeX9Es3Zly4DULeGHILKeJ8DAAAAAAAAAAAAAAAA + wH1E595aIgK1huiGoRtjPaj9EIIruUSgcolA5bIn5YpmyVYruHJysRPO04fl5WbavVx+bs0Q1Onb7XCu + VolA5YrWn00EKlcXe1/tfS4ypPsmmq8vGQGoW4f/3g9/5xAMLQQGAAAAAAAAAAAAAAAAwDREZ95aIgK1 + huiGoRtjPqj9vQRXcolA5RKBymVPyhXNkq1WOKPGs3ore83l50e/tw9n//lbOFOrRKByRevPJgKVq6v3 + +Hz2cnX2cSv8HTWUsGA0Z99qfT8r+vjuUvPdfZeh3AMAAAAAAAAAAAAAAAAATEd03q0lIlBriG4YuiEC + lWtKwRURqFw1DqeLQOWyJ+WqFVw5v9oI58l2+nY7nKdrp++2w9+frVzXaJ5WiUDlitafTQQqV9fv8Vp7 + 3ZfK3jefHYUz9unZq1/C+frQx3e08jtqvb/vo8Z3cgAAAAAAAAAAAAAAAACmKzrr1hIRqDVENwzdaOWg + 9n0IruQSgcolApXLnpQrmiVbjeDKfPYynKUPfd3DU1jjEIhA5YrWn00EKlfG/jCUENQQns3ynTCaLVtf + gcPi5GInnGEoDhd74dwAAAAAAAAAAAAAAAAA0LXonFtLRKDWEN0wdKOlg9p3EVzJJQKVSwQqlz0pVzRL + thrBlb/vHYSzZOv7c62xHxW7+wfhPC0SgcoVrT+bCFSurPf42cet8Pf1qda7+3M1vrMUfT435XdFMwyJ + v7cAAAAAAAAAAAAAAAAA6EN0xq0lIlBriG4YuiEClWtKwRWHknPViK6IQOWyJ+WqEVypdf/2vf8eXP++ + aI5sU3rPiEDlitafTQQqV9Z7fD57WeV5/NJ8dhTO15ca30OX19c9miXTED7rbzm/2ljt7k0niAgAAAAA + AAAAAAAAAABAHdEZt5aIQK0humHohghULhEouiIClcuelCuaJVuN4MqzV7+Es2Tb3e83CFHru4MIVC4R + qFwiULky3+PlZ5f4TvR7+1L7+azxPfS3//ohnCVTje9m32t5OavyvRUAAAAAAAAAAAAAAACA6YjOt7VE + BGoN0Q1DN1o8qP01giu5RKByiUDlsiflimbJViO4cnC9D0azZItmyVYjiHK42AtnaZEIVK5o/dlEoHJl + v8cP/70f/t6+nL7dDufqS409qcb30MNF3c/5voSgAAAAAAAAAAAAAAAAAMgUnW1riQjUGqIbhm60elA7 + IriSSwQqlwhULntSrmiWbFOJQJUQRDRLtqkEQWoRgcoVrT+bCFSuPt7jNb6L3SrhvWimvkxlT6oVc3yI + s49bq/nsKFwHAAAAAAAAAAAAAAAAAKwjOtfWEhGoNUQ3DN0QgcolAkVXRKBy2ZNyRbNkE4HKJQKVSwQq + V7T+bCJQufp4j+/uHYS/uy81vqvcEoEaplrf6wAAAAAAAAAAAAAAAABoW3SmrSUiUGuIbhi60fJB7S8J + ruQSgcolApXLnpQrmiWbCFQuEahcIlC5ovVnE4HK1dd7/PTddvj7+1DzGRWBGq6Ti51wLQAAAAAAAAAA + AAAAAADwUNF5tpaIQK0humHohghULhEouiIClcuelCuaJdtUIlBFNEu286uNcJZMh4u9cJYWiUDlitaf + TQQqV1/v8VrrK2rGfmrsSTX2/PLdN5pl6KYUSQQAAAAAAAAAAAAAAAAgX3SWrSUiUGuIbhi60fpB7c8J + ruQSgcolApXLnpQrmiXblCJQu/sH4TxZan13mNJ7RgQqV7T+bCJQufp8j9f4Tlac/edv4Tx9qLEnnb7d + DmfJ9Pv7x+EsYzClUCIAAAAAAAAAAAAAAAAAuaJzbC0RgVpDdMPQjSkc1L4luJJLBCqXCFQue1KuaJZs + NYIrte7fvsMPtWJXz179HM7TIhGoXNH6s4lA5erzPV4+y2iGbOdXG+E8fajxPXR5OQtnyfTm+ndGs4zF + s39N5z0JAAAAAAAAAAAAAAAAQJ7oDFtLRKDWEN0wdEMEKpcIFF0RgcplT8oVzZKtRnCl1ju178/19/eP + wzmyTSWiU4hA5YrWn00EKlff7/ESZIrmyFbj+0pR4ztL0edz8/e9g3CGMSn35e71OqL1AQAAAAAAAAAA + AAAAAMB9RWfYWiICtYbohqEbUzmoXQiu5BKByiUClcuelCuaJVuN4Mp89jKcpQ993cO1vjcU89lROFOL + RKByRevPJgKVq+/3eK0o0u5+ncDPycVOOE+207fb4TwZTt9thzOMzfJyVuV7LQAAAAAAAAAAAAAAAADt + iM6vtUQEag3RDUM3pnJQuxBcySUClUsEKpc9KVc0S7ZawZUa8Z6ir1BGrUjG+dVGOE+rRKByRevPJgKV + q+/3+MH18xLNka3Wc3q42A/n6UMfn22t+zaLEBQAAAAAAAAAAAAAAAAA64jOrrVEBGoN0Q1DN6ZyULsQ + XMklApVLBCqXPSlXNEu2WsGVGs/qrew113o+i1r3bi0iULmi9WcTgcrV93u81joPF3vhPNnK/RvN04c+ + 9v9agcNMZx+3VvPZUbheAAAAAAAAAAAAAAAAAPiW6NxaS0Sg1hDdMHRjKge1C8GVXCJQuWqEZUSgctmT + ctUKrpxc7ITz9GF5OUsLPpRn5M31z49+bx9O326Hc7VKBCpXtP5sIlC5arzHz682wlkylXdMNEu2+exl + OE9fMr+THi72w9/Zgt/e/xCuGQAAAAAAAAAAAAAAAAC+JTqz1hIRqDVENwzdmNJBbcGVXCJQuUSgctmT + ckWzZKsVXDm43gujefpy9nGr8xBU+Xk1A1DF1N4xIlC5ovVnE4HKVeM9XuM5rRnEq7Hez2XsUbt7B+Hv + akmtcBgAAAAAAAAAAAAAAAAA4xWdV2uJCNQaohuGbohA5RKBoisiULnsSbmiWbLVCq7MZy/DefpUQlBd + 3dPl55SfF/2ePu3uH4TztUoEKle0/mwiULlqvMd/f/84nCVTzQhUje8tXzpc7IWzPUTZ886vNsLf05oa + 3+kBAAAAAAAAAAAAAAAAGK/orFpLRKDWEN0wdGNKB7UFV3KJQOUSgcplT8oVzZKtZnClRsDnS8vL2drX + oDyPb65/TvTz+7S8vp7RfC0TgcoVrT+bCFQu7/F8B9d7RDRT304udlbz2VE4432U/7b8jOhnt6zLgBYA + AAAAAAAAAAAAAAAAbYvOqbVEBGoN0Q1DNxzUziUCRVdEoHLZk3JFs2SrGVwZUlzi9O32d9/f5d+fvtsO + f14NZQ3RnC0TgcoVrT+bCFQu7/F889nLcKYaSujwIXvWUOKGtTz718/hdQEAAAAAAAAAAAAAAACAz0Vn + 1FoiArWG6IahGw5q5xKBoisiULnsSbmiWbLVDK6U3x3NVFP57Ms+vbt3EM5cnoHDxX6VveYuz15NL1oh + ApUrWn82EahcNd7j5XtSNEumWu/xW0N7R5QYVAkFludrPjv6y7zl/1a+W5Y44/nVRvgzpqRcg699DwAA + AAAAAAAAAAAAAACAW9EZtZaIQK0humHKgc5ygPHg9dObA7jl8Odv739YnX3cujk4/6VyYLUo/6b8+xI6 + +Nph0SmZ0kFtwZVcX4tHlM/62b9+vnnmbp/Tcl2i57Q8v7fPaTmsffucOqwsApXNnpQrmiVb7eDK0GMT + Zb7bvTf634dieT1fdH1bV+NzEYHKJQKVq8Z7fIoRqPLdPJprKD5/t4k+xUo4q8bzAgAAAAAAAAAAAAAA + AMB4ROfTWiICtYZyg5RYUwnJlDBMCcVE/+6hys8rcZpy+H1qByKndFD79/ePw1kyTSm4chuPKBGfcii+ + rL3Lw9flZ5WfWQ6fTzEKVdYeXZdMIlC5phKBqvWeqR1cqREHaVH5fhZd39aJQOWK1p9NBCpXjff4FCNQ + 89lLcaUGCEEBAAAAAAAAAAAAAAAA8C3R2bSWiECtoe/4Sfl9UwlCTeWgdq0YR62D2tEs2RYf/levh8LL + 4eUSB5lKEKrvfbAQgco1hQhUua5vrp/VaJZstYMrJZQRzcX3mcJ3sYgIVK5o/dlEoHLV2CumGIEqSpQ5 + mo1xKSHsEtqOPmMAAAAAAAAAAAAAAAAApi06l9YSEaiRaj0yM4WD2rUCUMWUIlA1lUPMrccrRKBy1YhH + tB6BKte0VgCqGEJwpcZz25IhxE5qEYHKFa0/mwhUrhrv8alGoMq9HM3G+Pz2/ofwMwYAAAAAAAAAAAAA + AABg2qIzaS0RgRq5cuC2xcPbrR/UrhmAKmod1I5mmYLl5azZiEWNmIwIVK6WI1DletYMQBVDeGcLZaxn + KtGciAhUrmj92aZyP7f+t8XnphqBKmp8LyXHycVO+BkDAAAAAAAAAAAAAAAAMF3RebSWiEA14vTtdpVD + xllaPqhdOwBViEDV0WIMSgQqV419vdUIVLmWtQNQxVCCK0IZD1Pr/TkUIlC5ovVnE4HKVeM9PuUIlMhh + W2p85wcAAAAAAAAAAAAAAABguKKzaC0RgWpMKwclWz2oPYQAVFHroHY0yxSd/WerShQgQ42QjAhUrhYj + UOU6DiEAVQwluLK7dxDOx7eV6xZdz6kQgcoVrT+bCFSuGu/xKUegihrfTclzuNgLP2cAAAAAAAAAAAAA + AAAApic6h9YSEagGLS9now/MtHhQeygBqEIEahhaiLaJQOWqsZe3FoEq13AoAahiSMGVk4sfwxmJnb7d + Dq/jlIhA5YrWn00EKleN9/jUI1Dlmp9fbYRzEiv7QI39/b6msk8BAAAAAAAAAAAAAAAA8G3RGbSWiEA1 + bMyBmdYOag8pAFWIQA1H+SxqBAK6IgKVq8a90VIEqly/IQWgiiGFDOazl0IZ97S83Bz1Xt0VEahc0fqz + iUDlqrFvTD0CVQztb68huw0c7u4dDPY7QZmrzPfl5wwAAAAAAAAAAAAAAADAtERn0FoiAtW4397/sJrP + jsKbe8haOqg9xEPIIlDDsrycjfZgswhUrhrxiFYiUOXaDS0AVQwtuPLs1S/hnPzZlEJE3yIClStafzYR + qFw13uMiUJ8ihzX2q7H5MnBY9oPo3w1B+XupxvMEAAAAAAAAAAAAAAAAwHBE589aIgI1AWM8MNnKQe0h + BqAKEahhOlzshddtyESgctXYu1uIQJXrNsQAVDHE4MrJxY/hrHxy+nY7vG5TJAKVK1p/NhGoXDXe4yJQ + n5TAajQrf4j218N/74f/trYvg1UAAAAAAAAAAAAAAAAATE90/qwlIlATMbYQVAsHtYcagCpEoIarRuBo + HSJQuWrs22OPQJVrNtQAVDHE4Mp89rJK3GcMRCf+TAQqV7T+bCJQuWrsHyJQfxhq0GgITi52wmtWHC+f + hP9NLd7FAAAAAAAAAAAAAAAAABTRGbSWiEBNSAlB7e4dhDf60Iz9oPaQA1CFCNSwjSkEJQKVq8aB9zFH + oMr1GnIAqhhqcKVcu/OrjXDmKavxDA6ZCFSuaP3ZRKBy1dhDRKD+7Lf3j8OZp6xElaJr9bmTix/D/7Zv + Zx+3VvPZUTgjAAAAAAAAAAAAAAAAANMSnUNriQjUxJTAwxhCUGM+qD30AFQhAjV8YwlBiUDlqhGPGGsE + qlyroQegiiEHVw5ePw1nnqrDxX54naZMBCpXtP5sIlC5arzHRaD+bD57WWXvGqoSgLrvfXn6bjv8GX0p + vz+aCwAAAAAAAAAAAAAAAIBpis6itUQEaoKWl7MqB5K/x1gPao8hAFWIQI3DGEJQIlC5auzVY4xAles0 + hgBUMfTgyvHySTj31JTrEF2fqROByhWtP5sIVK4a73ERqL/69D1BCOp7g9AloHX2cSv8Wdm8hwEAAAAA + AAAAAAAAAAD4UnQerSUiUBM19BDUGA9qjyUAVYhAjcfQ4xciULlq7NNji0B9CjuMIwBVjCG4MvUQlPDE + 14lA5YrWn00EKleN97gIVKzEj0oEKZp/Kp796+fw2nzLp+9Z/e793sMAAAAAAAAAAAAAAAAARKIzaS0R + gZqws49bq/nsKLzxaxvbQe0xBaAKEahxKYfWo+s5BCJQuWrEI8YUgfoUJhhPAKoYS3BlqiEo4YlvE4HK + Fa0/mwhUrhrvcRGor5tyCOrX1/8Ir8l9fPq+lb//l89mnTkBAAAAAAAAAAAAAAAAaFt0Nq0lIlATd3Kx + E974tY3poPbYAlCFCNS4LC9nVSIC9yEClavG5z6WCNSnIMG4AlDFmIIrUwtBCUDdTQQqV7T+bCJQuWq8 + x0Wgvm1qIaiuwkrZ16387CGHbwEAAAAAAAAAAAAAAACoLzqf1hIRKFaHi73w5q9pLAe1xxiAKkSgxmeo + h+tFoHLViEeMIQJVrssYA1DF2IIrUwlBCUDdjwhUrmj92USgctV4j4tA3e3T94j+97O+dR1WKvtF9HvW + tbz+LGo8KwAAAAAAAAAAAAAAAACMS3RGrSUiUNwcDh3aocsxHNQeawCqEIEapyEG20SgctXYm4cegSrX + ZKwBqGKMwZVnr365+a4QrWfsyrp+ff2PcN38lQhUrmj92USgctV4j4tA3c+n7xPthqCywkoH13ty9Pse + SgAKAAAAAAAAAAAAAAAAgPuKzqm1RASKG0M7uDv0g9pjDkAVIlDjNbRD0iJQuWp83kOOQJXrMeYAVDHW + 4Mqna99WLKOEJ3b3DsL1EhOByhWtP5sIVK4a73ERqPubz15ef+/ZDtc0Zr+/f3y9tqNwzV04Xj4Jf+/3 + KvdN5pwAAAAAAAAAAAAAAAAAtCU6q9YSESj+2+FiL3wIahjyQe2xB6AKEajxGtoh+zJPNGcmEahcQ41A + lWsx9gBUMebgSkuxjOxARqtEoHJF688mApWrxntcBOr7Hf57P1zX2JxfbVz/Tb8frrFrJxc/hjPcV/k+ + Ef1cAAAAAAAAAAAAAAAAAPia6LxaS0Sg+G/l0OhQgghDPajdQgCqEIEatyEFMUSgctWIRwwxAlWuQwsB + qKKF4MrB9R5UIwbUhT4DGS0SgcoVrT+bCFSuGu9xEaiH+fRdY5zvtqJ8Bn3fbw8NQx4vn4Q/DwAAAAAA + AAAAAAAAAAC+JTqz1hIRKP6kRlwlMsSD2q0EoAoRqHEbUrBNBCpXjXjE0CJQn6IMbQSgilaCK+VzeWj8 + oZaTi53B7J1jJQKVK1p/NhGoXDXe4yJQ6xlb6LBm3HA+e7k6+7gVzvU1QowAAAAAAAAAAAAAAAAAPFR0 + bq0lIlD8yVDiMkM7qN1SAKoQgRq/oQTbRKBy1YhHDCkCVdbfUgCqaC24Uj6jocegyv01ldBNNhGoXNH6 + s4lA5arxHheBWl/53E4ufgzXOhTl7/bj5ZPqf7uXENR93g1l3l9f/yP8GQAAAAAAAAAAAAAAAABwH9H5 + tZaIQPEXQ4jLDOmgdmsBqEIEavyGEmwTgcpVIx4xlAhUWXtrAaii1eBK+byGFoMSf+qeCFSuaP3ZRKBy + 1XiPi0B15/bdVmPv+5qhxJ8+9+k729ev0fL6f9vdOwj/WwAAAAAAAAAAAAAAAAC4r+gMW0tEoPiLIcRl + hnJQu8UAVCEC1YbDxV54nfskApWrRjxiCBGoTzGB9gJQRevBlfLZnVzsVAtm3MYxajw7UyAClStafzYR + qFw19iIRqBwH13tRje+9t8rvPlzsDyr+9LkSeSrv4C/nLgEo72QAAAAAAAAAAAAAAAAAuvDlGbbWiEAR + qh2XGcJB7VYDUEWtg9rRLDzcEA7c1zgMLwKVq3YEqqy51QBUMZXgSlHWWoJQZx+3wmvRlRImKr9nSte2 + FhGoXNH6s4lA5arxHheBylU+076CUOV3lLDhWJ7TMufn85f3f41nAAAAAAAAAAAAAAAAAIA2fX6GrUUi + UIRqH+StfVC75QBUUevzjWZhPbUPhfdxAP5LIlC5akagynpbDkAVUw0Vlc/22atfbmJN5fM+v9oIr89d + SoSo/Pfl55QIx878n+HvI4cIVK5o/dlEoHLVeI+LQPWrPEPlmv/2/vFa0cPyXrx9v5X35Xx2FP6+oSvv + 5rKespaxrgEAAAAAAAAAAAAAAACAYfrybF5rRKB68PmBzsPF/s3ByPL/vT0sWuNA/X3UPBRe86B26wGo + otZB7WiWISkHt0/fbt/cA+U5Lbo41J2p7CvRte5LuZeiuTKVzySaJZMIVK5yH5W1th6AKqYagfqa3b2D + m2tSghe3++6Xyv9eYk9iEvWJQOWK1p9tKntSzb8tonky1fhbptbfFkP15butfCafu/1/Eyj/e/m3rb3f + yrqi/zsAAAAAAAAAAAAAAAAArCM649gSEahE5TBsOfx5n0Od5d+dvtsOf04t5YBqNGsfah3UrhE/qUEE + 6g8l0na8fHKv57Tcl+XfDincVuaPZu2LCFSuGvGIGvvg8vqZmkIAqphKcIU2iUDlitafTQQqlwgUAAAA + AAAAAAAAAAAAAEA3ojOOLRGBSlBiFg89UF0OCg8lMHP2n7+FM/ah1kHtqRCB+r7405fK/Vn+2+jn1lAz + 4CAClatGPGIqMbxaRKAYMxGoXNH6s4lA5arxHheBAgAAAAAAAAAAAAAAAABaFJ1xbIkIVMdOLnYeFJX5 + 0lACM12s5SFEoHJNPQJVQm1dHMov4YQhRNsOF3vhfH0QgcolAtUeESjGTAQqV7T+bCJQuUSgAAAAAAAA + AAAAAAAAAAC6EZ1xbIkIVIdKuCm6iR5qCCGoWgfvRaByTTkCdfZxq9MD+eVn1Q5B1Tx4LwKVq0Y8QgQq + lwgUYyYClStafzYRqFw13uMiUAAAAAAAAAAAAAAAAABAi6Izji0RgepI1wGoW7VDUCcXO+Fc2Wod1J6K + qUaglpebKYfxy888v9oIf2cfyu+O5uqDCFSuGvEIEahcIlCMmQhUrmj92USgctV4j4tAAQAAAAAAAAAA + AAAAAAAtis44tkQEqgO/v38c3jxdObn4Mfy9fah1oLfWQe2pmGIEqoSSMg/il4hC9Hv7UiMyUIhA5arx + uYpA5RKBYsxEoHJF688mApWrxntcBAoAAAAAAAAAAAAAAAAAaFF0xrElIlBrWl5uph/unc9eVjl0X5Rw + TjRTtloHtadiihGow8V+OFOXagbbnr36OZwpmwhULhGo9ohAMWYiULmi9WcTgcolAgUAAAAAAAAAAAAA + AAAA0I3ojGNLRKDWdLx8Et44XSsHtKPf34cah5dFoHJNLQJVYm3RPF0rwbYSTotmyHa42AtnyiYClUsE + qj0iUIyZCFSuaP3ZRKByiUABAAAAAAAAAAAAAAAAAHQjOuPYEhGoNZTYS58He88+boVzZNvdPwjnySQC + lWtqEag+AxI1Dt4Xp2+3w3myiUDlEoFqjwgUYyYClStafzYRqFwiUAAAAAAAAAAAAAAAAAAA3YjOOLZE + BGoNfUdXasVlahy+F4HKNbUI1Hx2FM6TYT57Gc6Q7bf/+iGcJ5sIVC4RqPaIQDFmIlC5ovVnE4HKJQIF + AAAAAAAAAAAAAAAAANCN6IxjS0Sg1vDs1c/hTZPl73sH4RzZRKDaM6UIVI21nn3cCmfJdPafv4WzZBOB + yiUC1R4RKMZMBCpXtP5sIlC5RKAAAAAAAAAAAAAAAAAAALoRnXFsiQjUGnb3D8KbJtP51UY4S6YawRUR + qFxTikDVuH9rRHSWl7NwlmwiULlEoNojAsWYiUDlitafTQQqlwgUAAAAAAAAAAAAAAAAAEA3ojOOLRGB + WkN0w2SrcfheBKo9U4pA1YhHHC72w1kyiUDlEoGiKyJQjJkIVK5o/dlEoHKJQAEAAAAAAAAAAAAAAAAA + dCM649gSEag1RDdMtqkEV0SgcolA5Tq4/p3RLJlEoHKJQNEVESjGTAQqV7T+bCJQuUSgAAAAAAAAAAAA + AAAAAAC6EZ1xbIkI1BqiGyabCFRblpebq/+nwmcqApVLBCqXCFSuqUSgjpdPwv97NhEoxkwEKle0/mwi + ULlEoAAAAAAAAAAAAAAAAAAAuhGdcWyJCNQaohsm29nHrXCWTCJQOUoAqqyzRnBFBCrX4WI/nCWTCFQu + Eai2lABUWWv0v2UTgWLMRKByRevPJgKVSwQKAAAAAAAAAAAAAAAAAKAb0RnHlohAraHGod7zq41wlkwi + UN27DUCVtU4pAlUjHlHj/j252AlnySQClUsEqh23Aagi+t+ziUAxZiJQuaL1ZxOBylXjPS4CBQAAAAAA + AAAAAAAAAAC0KDrj2BIRqDU8e/VzeNNk+fveQThHtsPFXjhPppYjUJ8HoAoRqFy//dcP4SyZaoSRan2m + IlC5RKC69XkAqoj+TTYRKMZMBCpXtP5sIlC5RKAAAAAAAAAAAAAAAAAAALoRnXFsiQjUGk4udsKbJsvB + 66fhHNn6jl0VrUagvgxAFVOKQJ193ArnyXR+tbGaz47CeTLUundFoHKJQI3flwGoIvp32USgGDMRqFzR + +rOJQOWq8R4XgQIAAAAAAAAAAAAAAAAAWhSdcWyJCNQa+o7L1AjoFDUOh9c6qJ0pCkAVU4pA1YrL9HkP + 14q1nb7dDufJJgKVSwSqG1EAqoj+bTYRKMZMBCpXtP5sIlC5RKAAAAAAAAAAAAAAAAAAALoRnXFsiQjU + mvo6mF4rQFLUOLz8/7Nz/7hyXGcah3fBYG6gZAAPCAZSYI0U2IAGiuhgINEGnDEQGGmSUabIjBhyBfIK + tIJZgXagHXAdHB0a8h/pbYl/7rn11dtP8AAE7+2qU9XVp8ng+x01qL3LpQDUck0RqMfP34/r2e0ur/cv + 39/ENex2RBhpEYHa64j9ty0CdSkAtaTf300EijMTgdorXf9uIlB7HfE9LgIFAAAAAAAAAAAAAAAAADRK + M45NRKDe0dPvb17ev/k8Pjy36aiwzLMX9+J6dmuKQP1SAGq5pgjUwy9+F9dzF+4icvDZVx/Hc9+FT//0 + SVzTbiJQe4lAvZtfCkAt6TW7iUBxZiJQe6Xr300Eai8RKAAAAAAAAAAAAAAAAACA25FmHJuIQN2Cx8/f + jw/PbTlikPdHRw30tkSgfi0AtVxTBOo/P3oY13MXdgfb1vu8omnp3Hfhw48fxnXtJgK11xHxiJYI1K8F + oJb0ut1EoDgzEai90vXvJgK11xHf4yJQAAAAAAAAAAAAAAAAAECjNOPYRATqluwaUP/0j5/E892V3YGr + S44a1L5NrxOAWq4pAnX/5lFcz1358tvfxHW9qxWX+sv3N/Gcd2HFp9K67oII1F4iUG/ndQJQS3rtbiJQ + nJkI1F7p+ncTgdpLBAoAAAAAAAAAAAAAAAAA4HakGccmIlC3aAWb0kP0tj786OGruEs61105avD+7BGo + 1w1ALdcUgVq+/u69uKa7ctthsxWAOvqajnw/RaD2EoF6c68bgFrS63cTgeLMRKD2Ste/mwjUXiJQAAAA + AAAAAAAAAAAAAAC3I804NhGBumWfffVRfJDe1Bp4PzoAtRwxuLwcNah9G94kALVcWwRqRZjSmu7Sl9/+ + 5lae7XWMowNQyxFRpB+JQO11xB585gjUmwSglnSM3USgODMRqL3S9e8mArXXEd/jIlAAAAAAAAAAAAAA + AAAAQKM049hEBGqDJ988eOuB3/s3n4+I5CwrZpTWeBeOGtR+V28agFquLQK1YgNpTXft6fc37xSW+Oyr + j0eE2pYjAw4iUHsdEY84awTqTQNQSzrObiJQnJkI1F7p+ncTgdrriO9xESgAAAAAAAAAAAAAAAAAoFGa + cWwiArXRm8SgVvxpDexOicosa/1prXfhqEHtd/E2Aajl2iJQ928ejXrO17349I+fxLX+1PqcfvqnTw4J + H11yZKxtEYHa64h4xBkjUG8TgFrSsXYTgeLMRKD2Ste/mwjUXkd8j4tAAQAAAAAAAAAAAAAAAACN0oxj + ExGoO/D1d++9Cip99tXHr2Iza9j64Re/e+Xx8/dHBWX+2ZFD4WeLQL1tAGq5tgjUMjEys8JUX377m1eD + 8+uzuZ7/9Xldf15/t342KV71oyNjbYsI1F4iUL/ubQNQSzrebkd8t66A3TovexzxOT2KCNRe6fp3++r/ + /v3VvyXu0vrcpOvf6aj/WxyxP1xTBOqn+zHnt/7Nkt5rAAAAAAAAAAAAAAAAAEgzjk1EoIhW1Ch9IO7K + UYPab+NdAlDLNUag1oBvWhdvbt3LdI/vigjUXkfEI84UgXqXANSSjrnbEZ/ZFbNLa+F2HLEnHUUEaq90 + /Y2O+MyIQO111P8t0lo4t6P/bwMAAAAAAAAAAAAAAADAXGkurYkIFNHRA/dniUC9awBqucYI1PLsxb24 + Nl7f0bG2RQRqLxGoy941ALWk4+4mAtVHBGovEag+IlB7iUBxZiJQAAAAAAAAAAAAAAAAAFyS5tKaiEAR + HTGw/M+OGtR+E7cRgFquNQJ1xIB6mwlhDBGovY7Yi88QgbqNANSSjr2bCFQfEai9RKD6iEDtJQLFmYlA + AQAAAAAAAAAAAAAAAHBJmktrIgLFzzz55kH8MNyl6RGo2wpALdcagbp/8+jlsxf34vr4dbf5DL4LEai9 + jniPp0egbisAtaTj7yYC1UcEai8RqD4iUHuJQHFmIlAAAAAAAAAAAAAAAAAAXJLm0pqIQPEzE8IyRw1q + v47bju9cawRqOWJIvcVthnDehQjUXkfsx5MjULf93Kdz7CYC1UcEai8RqD4iUHuJQHFmIlAAAAAAAAAA + AAAAAAAAXJLm0pqIQPEvnnzzIH4Q7trUCNRtB6CWa45A3b959PLZi3txjVy24zl8WyJQex3xPk+NQO0I + n6Xz7CYC1UcEai8RqD4iUHuJQHFmIlAAAAAAAAAAAAAAAAAAXJLm0pqIQPF3K8YzJSxz1KD2L9kV3rnm + CNRyxKD62U0KYohA7XXEnjwxArUjALWkc+0mAtVHBGovEag+IlB7iUBxZiJQAAAAAAAAAAAAAAAAAFyS + 5tKaiEDxd7siG29jWgRqVwBqufYI1P2bR4dEJc5qPYvpPh5FBGovEai9303pfLuJQPURgdpLBKqPCNRe + IlCcmQgUAAAAAAAAAAAAAAAAAJekubQm9RGoIwIlZzQtLDMpArUzALVcewRqWcO+aZ383BExgV8iArXX + Ee/3pAjU7jhhOuduIlB9RKD2EoHqIwK1lwgUZyYCBQAAAAAAAAAAAAAAAMAlaS6tSX0E6v7No0MG1s9m + WljmqEHtn9odgFpEoP7m8fMP4lr5h91BnLchArXXEXvzlAjUXTzv6by7iUD1EYHaSwSqjwjUXiJQnJkI + FAAAAAAAAAAAAAAAAACXpLm0JvURqPUmrkHC9DP+ZmJYZkIE6i4CUIsI1N8Itv2y9Tym+3Y0Eai9rjUC + dVffS+ncu4lA9RGB2ksEqo8I1F4iUJyZCBQAAAAAAAAAAAAAAAAAl6S5tCZXEYFaVlAi/fza/c+3//Ev + D/wUR0eg7ioAtYhA/cOHHz18+ezFvbjma7buyRERgdchArXXEe/70RGouwwTpvPvJgLVRwRqLxGoPiJQ + e4lAcWYiUAAAAAAAAAAAAAAAAABckubSmlxNBGo5IlYy2V2Gjt7UUYPay13fFxGofyVW8nOf/vGTeK8m + EIHa64g9+sgI1F0GoJa0ht1EoPqIQO0lAtVHBGovESjOTAQKAAAAAAAAAAAAAAAAgEvSXFqTq4pA3b95 + dMjw+kSTA1DLUYPaR9wXEaifWyGYtO5rdNdRnDclArXXEfv0URGoI571tI7dRKD6iEDtJQLVRwRqLxEo + zkwECgAAAAAAAAAAAAAAAIBL0lxak6uKQC1rEPfaQ1DPXtx7+eFHD392byY5alD7w4/v/r6IQGWPn38Q + 135NpgegFhGova4lAnVN8QgRqD4iUHuJQPURgdpLBIozE4ECAAAAAAAAAAAAAAAA4JI0l9bk6iJQy7WH + oKYHoJZrGtQWgbrsyV8fxPVfg8fP34/3ZBoRqL3sSXultewmAtVHBGovEag+IlB7iUBxZiJQAAAAAAAA + AAAAAAAAAFyS5tKaXGUEalkDudcWgnr24t7LP3zx+3g/prmmQW0RqF92jSGoswSgFhGovexJe6W17CYC + 1UcEai8RqD4iUHuJQHFmIlAAAAAAAAAAAAAAAAAAXJLm0ppcbQRqWUO51xKCWgGoDz96GO/DRNc0qC0C + 9eseP/8gXkejPz/9bbwHU4lA7WVP2iutZTcRqD4iUHuJQPURgdpLBIozE4ECAAAAAAAAAAAAAAAA4JI0 + l9bkqiNQyxrMbQ9BPf3h+s4UgFquaVBbBOr1rDhSupYmZwtALSJQe9mT9kpr2U0Eqo8I1F4iUH1EoPYS + geLMRKAAAAAAAAAAAAAAAAAAuCTNpTW5+gjUcv/m0cvHzz+Irz+7r79775Dh43d1TYPaIlCv77P//The + z9k9e3Hv5R+++H285ulEoPayJ+2V1rKbCFQfEai9RKD6iEDtJQLFmYlAAQAAAAAAAAAAAAAAAHBJmktr + IgL1T/789LfxGGf1+Pn78TrPQARqr7NGoJb1Hh0Rodjl6Q/XcsRzd1tEoPayJ+2V1rKbCFQfEai9RKD6 + iEDtJQLFmYlAAQAAAAAAAAAAAAAAAHBJmktrIgL1Ew2BmWcv7r389I+fxOs7i2sa1BaBenP3bx79cN8e + xGs7kxVqu3/zebzGsxCB2suetFday24iUH1EoPYSgeojArWXCBRnJgIFAAAAAAAAAAAAAAAAwCVpLq2J + CNQFf37623i86Z588+D0UZlFBGqvs0egfrTCJmeMtj39Yc0tA84iUHvZk/ZKa9lNBKqPCNReIlB9RKD2 + EoHizESgAAAAAAAAAAAAAAAAALgkzaU1EYH6BWto98lfH8TjTrMGb5sGJq9pUFsE6t2dJdr27MW9V2tt + CLX9SARqL3vSXmktu4lA9RGB2ksEqo8I1F4iUJyZCBQAAAAAAAAAAAAAAAAAl6S5tCYiUK9hDSIeETp5 + HU+//7fK4XgRqL3aIlDLeu+mRtsa408/EoHay560V1rLbiJQfUSg9hKB6iMCtZcIFGcmAgUAAAAAAAAA + AAAAAADAJWkurYkI1BtYA4lTIjNr0LZ5QPKaBrVFoG7Xeg8fP//gkFDFTzXHn34kArWXPWmvtJbdRKD6 + iEDtJQLVRwRqLxEozkwECgAAAAAAAAAAAAAAAIBL0lxaExGot7CGeVdQ4evv3ovn3GUN3q+gzIcfPYzr + anJNg9oiUPt8+qf/evnlt/8R78EuK/z05JsHVzPALAK1lz1pr7SW3USg+ohA7SUC1UcEai8RKM5MBAoA + AAAAAAAAAAAAAACAS9JcWhMRqHe0BntXXGGFZlb8Ja3hba3jrYHaz776+CrCT//smga1RaD2u3/z+asg + 1JO/PtgSb1vHfPz8/VdDy+tcaQ2tRKD2siftldaymwhUHxGovUSg+ohA7SUCxZmJQAEAAAAAAAAAAAAA + AABwSZpLayICdctWrGnFZtbw7ZNvHrwaiF2BmEtD8+vvl/V76/fX61as4f37/x2Pfy1EoPY6alB7ihVq + WgPGK7C24k0r4rbuyfosppjb+rv1s/VZXr+7XrNee43Rp59a9+2n92u3I+IRIlB7HbUnpbXsJgLV54g9 + 6SiX/j27kwhUnyM+MyJQe13T9zh7iUABAAAAAAAAAAAAAAAAcEmaS2siAgUAAAAAAAAAAAAAAAAAAAAA + AIyUukJNRKAAAAAAAAAAAAAAAAAAAAAAAICRUleoiQgUAAAAAAAAAAAAAAAAAAAAAAAwUuoKNRGBAgAA + AAAAAAAAAAAAAAAAAAAARkpdoSYiUAAAAAAAAAAAAAAAAAAAAAAAwEipK9REBAoAAAAAAAAAAAAAAAAA + AAAAABgpdYWaiEABAAAAAAAAAAAAAAAAAAAAAAAjpa5QExEoAAAAAAAAAAAAAAAAAAAAAABgpNQVaiIC + BQAAAAAAAAAAAAAAAAAAAAAAjJS6Qk1EoAAAAAAAAAAAAAAAAAAAAAAAgJFSV6iJCBQAAAAAAAAAAAAA + AAAAAAAAADBS6go1EYECAAAAAAAAAAAAAAAAAAAAAABGSl2hJiJQAAAAAAAAAAAAAAAAAAAAAADASKkr + 1EQECgAAAAAAAAAAAAAAAAAAAAAAGCl1hZqIQAEAAAAAAAAAAAAAAAAAAAAAACOlrlATESgAAAAAAAAA + AAAAAAAAAAAAAGCk1BVqIgIFAAAAAAAAAAAAAAAAAAAAAACMlLpCTUSgAAAAAAAAAAAAAAAAAAAAAACA + kVJXqIkIFAAAAAAAAAAAAAAAAAAAAAAAMFLqCjURgQIAAAAAAAAAAAAAAAAAAAAAAEZKXaEmIlAAAAAA + AAAAAAAAAAAAAAAAAMBIqSvURAQKAAAAAAAAAAAAAAAAAAAAAAAYKXWFmohAAQAAAAAAAAAAAAAAAAAA + AAAAI6WuUBMRKAAAAAAAAAAAAAAAAAAAAAAAYKTUFWoiAgUAAAAAAAAAAAAAAAAAAAAAAIyUukJNRKAA + AAAAAAAAAAAAAAAAAAAAAICRUleoiQgUAAAAAAAAAAAAAAAAAAAAAAAwUuoKNRGBAgAAAAAAAAAAAAAA + AAAAAAAARkpdoSYiUAAAAAAAAAAAAAAAAAAAAAAAwEipK9REBAoAAAAAAAAAAAAAAAAAAAAAABgpdYWa + iEABAAAAAAAAAAAAAAAAAAAAAAAjpa5QExEoAAAAAAAAAAAAAAAAAAAAAABgpNQVaiICBQAAAAAAAAAA + AAAAAAAAAAAAjJS6Qk1EoAAAAAAAAAAAAAAAAAAAAAAAgJFSV6iJCBQAAAAAAAAAAAAAAAAAAAAAADBS + 6go1EYECAAAAAAAAAAAAAAAAAAAAAABGSl2hJiJQAAAAAAAAAAAAAAAAAAAAAADASKkr1EQECgAAAAAA + AAAAAAAAAAAAAAAAGCl1hZqIQAEAAAAAAAAAAAAAAAAAAAAAACOlrlATESgAAAAAAAAAAAAAAAAAAAAA + AGCk1BVqIgIFAAAAAAAAAAAAAAAAAAAAAACMlLpCTUSgAAAAAAAAAAAAAAAAAAAAAACAkVJXqIkIFAAA + AAAAAAAAAAAAAAAAAAAAMFLqCjURgQIAAAAAAAAAAAAAAAAAAAAAAEZKXaEmIlAAAAAAAAAAAAAAAAAA + AAAAAMBIqSvURAQKAAAAAAAAAAAAAAAAAAAAAAAYKXWFmohAAQAAAAAAAAAAAAAAAAAAAAAAI6WuUBMR + KAAAAAAAAAAAAAAAAAAAAAAAYKTUFWoiAgUAAAAAAAAAAAAAAAAAAAAAAIyUukJNRKAAAAAAAAAAAAAA + AAAAAAAAAICRUleoiQgUAAAAAAAAAAAAAAAAAAAAAAAwUuoKNRGBAgAAAAAAAAAAAAAAAAAAAAAARkpd + oSYiUAAAAAAAAAAAAAAAAAAAAAAAwEipK9REBAoAAAAAAAAAAAAAAAAAAAAAABgpdYWaiEABAAAAAAAA + AAAAAAAAAAAAAAAjpa5QExEoAAAAAAAAAAAAAAAAAAAAAABgpNQVaiICBQAAAAAAAAAAAAAAAAAAAAAA + jJS6Qk1EoAAAAAAAAAAAAAAAAAAAAAAAgJFSV6iJCBQAAAAAAAAAAAAAAAAAAAAAADBS6go1EYECAAAA + AAAAAAAAAAAAAAAAAABGSl2hJiJQAAAAAAAAAAAAAAAAAAAAAADASKkr1EQECgAAAAAAAAAAAAAAAAAA + AAAAGCl1hZqIQAEAAAAAAAAAAAAAAAAAAAAAACOlrlATESgAAAAAAAAAAAAAAAAAAAAAAGCk1BVqIgIF + AAAAAAAAAAAAAAAAAAAAAACMlLpCTUSgAAAAAAAAAAAAAAAAAAAAAACAkVJXqIkIFAAAAAAAAAAAAAAA + AAAAAAAAMFLqCjURgQIAAAAAAAAAAAAAAAAAAAAAAEZKXaEmIlAAAAAAAAAAAAAAAAAAAAAAAMBIqSvU + RAQKAAAAAAAAAAAAAAAAAAAAAAAYKXWFmohAAQAAAAAAAAAAAAAAAAAAAAAAI6WuUBMRKAAAAAAAAAAA + AAAAAAAAAAAAYKTUFWoiAgUAAAAAAAAAAAAAAAAAAAAAAIyUukJNRKAAAAAAAAAAAAAAAAAAAAAAAICR + UleoiQgUAAAAAAAAAAAAAAAAAAAAAAAwUuoKNRGBAgAAAAAAAAAAAAAAAAAAAAAARkpdoSYiUAAAAAAA + AAAAAAAAAAAAAAAAwEipK9REBAoAAAAAAAAAAAAAAAAAAAAAABgpdYWaiEABAAAAAAAAAAAAAAAAAAAA + AAAjpa5QExEoAAAAAAAAAAAAAAAAAAAAAABgpNQVaiICBQAAAAAAAAAAAAAAAAAAAAAAjJS6Qk1EoAAA + AAAAAAAAAAAAAAAAAAAAgJFSV6iJCBQAAAAAAAAAAAAAAAAAAAAAADBS6go1EYECAAAAAAAAAAAAAAAA + AAAAAABGSl2hJiJQAAAAAAAAAAAAAAAAAAAAAADASKkr1EQECgAAAAAAAAAAAAAAAAAAAAAAGCl1hZqI + QAEAAAAAAAAAAAAAAAAAAAAAACOlrlATESgAAAAAAAAAAAAAAAAAAAAAAGCk1BVqIgIFAAAAAAAAAAAA + AAAAAAAAAACMlLpCTUSgAAAAAAAAAAAAAAAAAAAAAACAkVJXqIkIFAAAAAAAAAAAAAAAAAAAAAAAMFLq + CjURgQIAAAAAAAAAAAAAAAAAAAAAAEZKXaEmIlAAAAAAAAAAAAAAAAAAAAAAAMBIqSvURAQKAAAAAAAA + AAAAAAAAAAAAAAAYKXWFmohAAQAAAAAAAAAAAAAAAAAAAAAAI6WuUBMRKAAAAAAAAAAAAAAAAAAAAAAA + YKTUFWoiAgUAAAAAAAAAAAAAAAAAAAAAAIyUukJNRKAAAAAAAAAAAAAAAAAAAAAAAICRUleoiQgUAAAA + AAAAAAAAAAAAAAAAAAAwUuoKNRGBAgAAAAAAAAAAAAAAAAAAAAAARkpdoSYiUAAAAAAAAAAAAAAAAAAA + AAAAwEipK9REBAoAAAAAAAAAAAAAAAAAAAAAABgpdYWaiEABAAAAAAAAAAAAAAAAAAAAAAAjpa5QExEo + AAAAAAAAAAAAAAAAAAAAAABgpNQVaiICBQAAAAAAAAAAAAAAAAAAAAAAjJS6Qk1EoAAAAAAAAAAAAAAA + AAAAAAAAgJFSV6iJCBQAAAAAAAAAAAAAAAAAAAAAADBS6go1EYECAAAAAAAAAAAAAAAAAAAAAABGSl2h + JiJQAAAAAAAAAAAAAAAAAAAAAADASKkr1EQECgAAAAAAAAAAAAAAAAAAAAAAGCl1hZqIQAEAAAAAAAAA + AAAAAAAAAAAAACOlrlATESgAAAAAAAAAAAAAAAAAAAAAAGCk1BVqIgIFAAAAAAAAAAAAAAAAAAAAAACM + lLpCTUSgAAAAAAAAAAAAAAAAAAAAAACAkVJXqIkIFAAAAAAAAAAAAAAAAAAAAAAAMFLqCjURgQIAAAAA + AAAAAAAAAAAAAAAAAEZKXaEmIlAAAAAAAAAAAAAAAAAAAAAAAMBIqSvURAQKAAAAAAAAAAAAAAAAAAAA + AAAYKXWFmohAAQAAAAAAAAAAAAAAAAAAAAAAI6WuUBMRKAAAAAAAAAAAAAAAAAAAAAAAYKTUFWoiAgUA + AAAAAAAAAAAAAAAAAAAAAIyUukJNRKAAAAAAAAAAAAAAAAAAAAAAAICRUleoiQgUAAAAAAAAAAAAAAAA + AAAAAAAwUuoKNRGBAgAAAAAAAAAAAAAAAAAAAAAARkpdoSYiUAAAAAAAAAAAAAAAAAAAAAAAwEipK9RE + BAoAAAAAAAAAAAAAAAAAAAAAABgpdYWaiEABAAAAAAAAAAAAAAAAAAAAAAAjpa5QExEoAAAAAAAAAAAA + AAAAAAAAAABgpNQVaiICBQAAAAAAAAAAAAAAAAAAAAAAjJS6Qk1EoAAAAAAAAAAAAAAAAAAAAAAAgJFS + V6iJCBQAAAAAAAAAAAAAAAAAAAAAADBS6go1EYECAAAAAAAAAAAAAAAAAAAAAABGSl2hJiJQAAAAAAAA + AAAAAAAAAAAAAADASKkr1EQECgAAAAAAAAAAAAAAAAAAAAAAGCl1hZqIQAEAAAAAAAAAAAAAAAAAAAAA + ACOlrlATESgAAAAAAAAAAAAAAAAAAAAAAGCk1BVqIgIFAAAAAAAAAAAAAAAAAAAAAACMlLpCTUSgAAAA + AAAAAAAAAAAAAAAAAACAkVJXqIkIFAAAAAAAAAAAAAAAAAAAAAAAMFLqCjURgQIAAAAAAAAAAAAAAAAA + AAAAAEZKXaEmIlAAAAAAAAAAAAAAAAAAAAAAAMBIqSvURAQKAAAAAAAAAAAAAAAAAAAAAAAYKXWFmohA + AQAAAAAAAAAAAAAAAAAAAAAAI6WuUBMRKAAAAAAAAAAAAAAAAAAAAAAAYKTUFWoiAgUAAAAAAAAAAAAA + AAAAAAAAAIyUukJNRKAAAAAAAAAAAAAAAAAAAAAAAICRUleoiQgUAAAAAAAAAAAAAAAAAAAAAAAwUuoK + NRGBAgAAAAAAAAAAAAAAAAAAAAAARkpdoSYiUAAAAAAAAAAAAAAAAAAAAAAAwEipK9REBAoAAAAAAAAA + AAAAAAAAAAAAABgpdYWaiEABAAAAAAAAAAAAAAAAAAAAAAAjpa5QExEoAAAAAAAAAAAAAAAAAAAAAABg + pNQVaiICBQAAAAAAAAAAAAAAAAAAAAAAjJS6Qk1EoAAAAAAAAAAAAAAAAAAAAAAAgJFSV6iJCBQAAAAA + AAAAAAAAAAAAAAAAADBS6go1EYECAAAAAAAAAAAAAAAAAAAAAABGSl2hJiJQAAAAAAAAAAAAAAAAAAAA + AADASKkr1EQECgAAAAAAAAAAAAAAAAAAAAAAGCl1hZqIQAEAAAAAAAAAAAAAAAAAAAAAACOlrlATESgA + AAAAAAAAAAAAAAAAAAAAAGCk1BVqIgIFAAAAAAAAAAAAAAAAAAAAAACMlLpCTUSgAAAAAAAAAAAAAAAA + AAAAAACAkVJXqIkIFAAAAAAAAAAAAAAAAAAAAAAAMFLqCjURgQIAAAAAAAAAAAAAAAAAAAAAAEZKXaEm + IlAAAAAAAAAAAAAAAAAAAAAAAMBIqSvURAQKAAAAAAAAAAAAAAAAAAAAAAAYKXWFmohAAQAAAAAAAAAA + AAAAAAAAAAAAI6WuUBMRKAAAAAAAAAAAAAAAAAAAAAAAYKTUFWoiAgUAAAAAAAAAAAAAAAAAAAAAAIyU + ukJNRKAAAAAAAAAAAAAAAAAAAAAAAICRUleoiQgUAAAAAAAAAAAAAAAAAAAAAAAwUuoKNRGBAgAAAAAA + AAAAAAAAAAAAAAAARkpdoSYiUAAAAAAAAAAAAAAAAAAAAAAAwEipK9REBAoAAAAAAAAAAAAAAAAAAAAA + ABgpdYWaiEABAAAAAAAAAAAAAAAAAAAAAAAjpa5QExEoAAAAAAAAAAAAAAAAAAAAAABgpNQVaiICBQAA + AAAAAAAAAAAAAAAAAAAAjJS6Qk1EoAAAAAAAAAAAAAAAAAAAAAAAgJFSV6iJCBQAAAAAAAAAAAAAAAAA + AAAAADBS6go1EYECAAAAAAAAAAAAAAAAAAAAAABGSl2hJiJQAAAAAAAAAAAAAAAAAAAAAADASKkr1EQE + CgAAAAAAAAAAAAAAAAAAAAAAGCl1hZqIQAEAAAAAAAAAAAAAAAAAAAAAACOlrlATESgAAAAAAAAAAAAA + AAAAAAAAAGCk1BVqIgIFAAAAAAAAAAAAAAAAAAAAAACMlLpCTUSgAAAAAAAAAAAAAAAAAAAAAACAkVJX + qIkIFAAAAAAAAAAAAAAAAAAAAAAAMFLqCjURgQIAAAAAAAAAAAAAAAAAAAAAAEZKXaEmIlAAAAAAAAAA + AAAAAAAAAAAAAMBIqSvURAQKAAAAAAAAAAAAAAAAAAAAAAAYKXWFmohAAQAAAAAAAAAAAAAAAAAAAAAA + I6WuUBMRKAAAAAAAAAAAAAAAAAAAAAAAYKTUFWoiAgUAAAAAAAAAAAAAAAAAAAAAAIyUukJNRKAAAAAA + AAAAAAAAAAAAAAAAAICRUleoiQgUAAAAAAAAAAAAAAAAAAAAAAAwUuoKNRGBAgAAAAAAAAAAAAAAAAAA + AAAARkpdoSYiUAAAAAAAAAAAAAAAAAAAAAAAwEipK9REBAoAAAAAAAAAAAAAAAAAAAAAABgpdYWaiEAB + AAAAAAAAAAAAAAAAAAAAAAAjpa5QExEoAAAAAAAAAAAAAAAAAAAAAABgpNQVaiICBQAAAAAAAAAAAAAA + AAAAAAAAjJS6Qk1EoAAAAAAAAAAAAAAAAAAAAAAAgJFSV6iJCBQAAAAAAAAAAAAAAAAAAAAAADBS6go1 + EYECAAAAAAAAAAAAAAAAAAAAAABGSl2hJiJQAAAAAAAAAAAAAAAAAAAAAADASKkr1EQECgAAAAAAAAAA + AAAAAAAAAAAAGCl1hZqIQAEAAAAAAAAAAAAAAAAAAAAAACOlrlATESgAAAAAAAAAAAAAAAAAAAAAAGCk + 1BVqIgIFAAAAAAAAAAAAAAAAAAAAAACMlLpCTUSgAAAAAAAAAAAAAAAAAAAAAACAkVJXqIkIFAAAAAAA + AAAAAAAAAAAAAAAAMFLqCjURgQIAAAAAAAAAAAAAAAAAAAAAAEZKXaEmIlAAAAAAAAAAAAAAAAAAAAAA + AMBIqSvURAQKAAAAAAAAAAAAAAAAAAAAAAAYKXWFmohAAQAAAAAAAAAAAAAAAAAAAAAAI6WuUBMRKAAA + AAAAAAAAAAAAAAAAAAAAYKTUFWoiAgUAAAAAAAAAAAAAAAAAAAAAAIyUukJNRKAAAAAAAAAAAAAAAAAA + AAAAAICRUleoiQgUAAAAAAAAAAAAAAAAAAAAAAAwUuoKNRGBAgAAAAAAAAAAAAAAAAAAAAAARkpdoSYi + UAAAAAAAAAAAAAAAAAAAAAAAwEipK9REBAoAAAAAAAAAAAAAAAAAAAAAABgpdYWaiEABAAAAAAAAAAAA + AAAAAAAAAAAjpa5QExEoAAAAAAAAAAAAAAAAAAAAAABgpNQVaiICBQAAAAAAAAAAAAAAAAAAAAAAjJS6 + Qk1EoAAAAAAAAAAAAAAAAAAAAAAAgJFSV6iJCBQAAAAAAAAAAAAAAAAAAAAAADBS6go1EYECAAAAAAAA + AAAAAAAAAAAAAABGSl2hJiJQAAAAAAAAAAAAAAAAAAAAAADASKkr1EQECgAAAAAAAAAAAAAAAAAAAAAA + GCl1hZqIQAEAAAAAAAAAAAAAAAAAAAAAACOlrlATESgAAAAAAAAAAAAAAAAAAAAAAGCk1BVqIgIFAAAA + AAAAAAAAAAAAAAAAAACMlLpCTUSgAAAAAAAAAAAAAAAAAAAAAACAkVJXqIkIFAAAAAAAAAAAAAAAAAAA + AAAAMFLqCjURgQIAAAAAAAAAAAAAAAAAAAAAAEZKXaEmIlAAAAAAAAAAAAAAAAAAAAAAAMBIqSvURAQK + AAAAAAAAAAAAAAAAAAAAAAAYKXWFmohAAQAAAAAAAAAAAAAAAAAAAAAAI6WuUBMRKAAAAAAAAAAAAAAA + AAAAAAAAYKTUFWoiAgUAAAAAAAAAAAAAAAAAAAAAAIyUukJNRKAAAAAAAAAAAAAAAAAAAAAAAICRUleo + iQgUAAAAAAAAAAAAAAAAAAAAAAAwUuoKNRGBAgAAAAAAAAAAAAAAAAAAAAAARkpdoSYiUAAAAAAAAAAA + AAAAAAAAAAAAwEipK9REBAoAAAAAAAAAAAAAAAAAAAAAABgpdYWaiEABAAAAAAAAAAAAAAAAAAAAAAAj + pa5QExEoAAAAAAAAAAAAAAAAAAAAAABgpNQVaiICBQAAAAAAAAAAAAAAAAAAAAAAjJS6Qk1EoAAAAAAA + AAAAAAAAAAAAAAAAgJFSV6iJCBQAAAAAAAAAAAAAAAAAAAAAADBS6go1EYECAAAAAAAAAAAAAAAAAAAA + AABGSl2hJiJQAAAAAAAAAAAAAAAAAAAAAADASKkr1EQECgAAAAAAAAAAAAAAAAAAAAAAGCl1hZqIQAEA + AAAAAAAAAAAAAAAAAAAAACOlrlATESgAAAAAAAAAAAAAAAAAAAAAAGCk1BVqIgIFAAAAAAAAAAAAAAAA + AAAAAACMlLpCTUSgAAAAAAAAAAAAAAAAAAAAAACAkVJXqIkIFAAAAAAAAAAAAAAAAAAAAAAAMFLqCjUR + gQIAAAAAAAAAAAAAAAAAAAAAAEZKXaEmIlAAAAAAAAAAAAAAAAAAAAAAAMBIqSvURAQKAAAAAAAAAAAA + AAAAAAAAAAAYKXWFmohAAQAAAAAAAAAAAAAAAAAAAAAAI6WuUBMRKAAAAAAAAAAAAAAAAAAAAAAAYKTU + FWoiAgUAAAAAAAAAAAAAAAAAAAAAAIyUukJNRKAAAAAAAAAAAAAAAAAAAAAAAICRUleoiQgUAAAAAAAA + AAAAAAAAAAAAAAAwUuoKNRGBAgAAAAAAAAAAAAAAAAAAAAAARkpdoSYiUAAAAAAAAAAAAAAAAAAAAAAA + wEipK9REBAoAAAAAAAAAAAAAAAAAAAAAABgpdYWaiEABAAAAAAAAAAAAAAAAAAAAAAAjpa5QExEoAAAA + AAAAAAAAAAAAAAAAAABgpNQVaiICBQAAAAAAAAAAAAAAAAAAAAAAjJS6Qk1EoAAAAAAAAAAAAAAAAAAA + AAAAgJFSV6iJCBQAAAAAAAAAAAAAAAAAAAAAADBS6go1EYECAAAAAAAAAAAAAAAAAAAAAABGSl2hJiJQ + AAAAAAAAAAAAAAAAAAAAAADASKkr1EQECgAAAAAAAAAAAAAAAAAAAAAAGCl1hZqIQAEAAAAAAAAAAAAA + AAAAAAAAACOlrlATESgAAAAAAAAAAAAAAAAAAAAAAGCk1BVqIgIFAAAAAAAAAAAAAAAAAAAAAACMlLpC + TUSgAAAAAAAAAAAAAAAAAAAAAACAkVJXqIkIFAAAAAAAAAAAAAAAAAAAAAAAMFLqCjURgQIAAAAAAAAA + AAAAAAAAAAAAAEZKXaEmIlAAAAAAAAAAAAAAAAAAAAAAAMBIqSvURAQKAAAAAAAAAAAAAAAAAAAAAAAY + KXWFmohAAQAAAAAAAAAAAAAAAAAAAAAAI6WuUBMRKAAAAAAAAAAAAAAAAAAAAAAAYKTUFWoiAgUAAAAA + AAAAAAAAAAAAAAAAAIyUukJNRKAAAAAAAAAAAAAAAAAAAAAAAICRUleoiQgUAAAAAAAAAAAAAAAAAAAA + AAAwUuoKNRGBAgAAAAAAAAAAAAAAAAAAAAAARkpdoSYiUAAAAAAAAAAAAAAAAAAAAAAAwEipK9REBAoA + AAAAAAAAAAAAAAAAAAAAABgpdYWaiEABAAAAAAAAAAAAAAAAAAAAAAAjpa5QExEoAAAAAAAAAAAAAAAA + AAAAAABgpNQVaiICBQAAAAAAAAAAAAAAAAAAAAAAjJS6Qk1EoAAAAAAAAAAAAAAAAAAAAAAAgJFSV6iJ + CBQAAAAAAAAAAAAAAAAAAAAAADBS6go1EYECAAAAAAAAAAAAAAAAAAAAAABGSl2hJiJQAAAAAAAAAAAA + AAAAAAAAAADASKkr1EQECgAAAAAAAAAAAAAAAAAAAAAAGCl1hZqIQAEAAAAAAAAAAAAAAAAAAAAAACOl + rlATESgAAAAAAAAAAAAAAAAAAAAAAGCk1BVqIgIFAAAAAAAAAAAAAAAAAAAAAACMlLpCTUSgAAAAAAAA + AAAAAAAAAAAAAACAkVJXqIkIFAAAAAAAAAAAAAAAAAAAAAAAMFLqCjURgQIAAAAAAAAAAAAAAAAAAAAA + AEZKXaEmIlAAAAAAAAAAAAAAAAAAAAAAAMBIqSvURAQKAAAAAAAAAAAAAAAAAAAAAAAYKXWFmohAAQAA + AAAAAAAAAAAAAAAAAAAAI6WuUBMRKAAAAAAAAAAAAAAAAAAAAAAAYKTUFWoiAgUAAAAAAAAAAAAAAAAA + AAAAAIyUukJNRKAAAAAAAAAAAAAAAAAAAAAAAICRUleoiQgUAAAAAAAAAAAAAAAAAAAAAAAwUuoKNRGB + AgAAAAAAAAAAAAAAAAAAAAAARkpdoSYiUAAAAAAAAAAAAAAAAAAAAAAAwEipK9REBAoAAAAAAAAAAAAA + AAAAAAAAABgpdYWaiEABAAAAAAAAAAAAAAAAAAAAAAAjpa5QExEoAAAAAAAAAAAAAAAAAAAAAABgpNQV + aiICBQAAAAAAAAAAAAAAAAAAAAAAjJS6Qk1EoAAAAAAAAAAAAAAAAAAAAAAAgJFSV6iJCBQAAAAAAAAA + AAAAAAAAAAAAADBS6go1EYECAAAAAAAAAAAAAAAAAAAAAABGSl2hJiJQAAAAAAAAAAAAAAAAAAAAAADA + SKkr1EQECgAAAAAAAAAAAAAAAAAAAAAAGCl1hZqIQAEAAAAAAAAAAAAAAAAAAAAAACOlrlATESgAAAAA + AAAAAAAAAAAAAAAAAGCk1BVqIgIFAAAAAAAAAAAAAAAAAAAAAACMlLpCTUSgAAAAAAAAAAAAAAAAAAAA + AACAkVJXqIkIFAAAAAAAAAAAAAAAAAAAAAAAMFLqCjURgQIAAAAAAAAAAAAAAAAAAAAAAEZKXaEmIlAA + AAAAAAAAAAAAAAAAAAAAAMBIqSvURAQKAAAAAAAAAAAAAAAAAAAAAAAYKXWFmohAAQAAAAAAAAAAAAAA + AAAAAAAAI6WuUBMRKAAAAAAAAAAAAAAAAAAAAAAAYKTUFWoiAgUAAAAAAAAAAAAAAAAAAAAAAIyUukJN + RKAAAAAAAAAAAAAAAAAAAAAAAICRUleoiQgUAAAAAAAAAAAAAAAAAAAAAAAwUuoKNRGBAgAAAAAAAAAA + AAAAAAAAAAAARkpdoSYiUAAAAAAAAAAAAAAAAAAAAAAAwEipK9REBAoAAAAAAAAAAAAAAAAAAAAAABgp + dYWaiEABAAAAAAAAAAAAAAAAAAAAAAAjpa5QExEoAAAAAAAAAAAAAAAAAAAAAABgpNQVaiICBQAAAAAA + AAAAAAAAAAAAAAAAjJS6Qk1EoAAAAAAAAAAAAAAAAAAAAAAAgJFSV6iJCBQAAAAAAAAAAAAAAAAAAAAA + ADBS6go1EYECAAAAAAAAAAAAAAAAAAAAAABGSl2hJiJQAAAAAAAAAAAAAAAAAAAAAADASKkr1EQECgAA + AAAAAAAAAAAAAAAAAAAAGCl1hZqIQAEAAAAAAAAAAAAAAAAAAAAAACOlrlATESgAAAAAAAAAAAAAAAAA + AAAAAGCk1BVqIgIFAAAAAAAAAAAAAAAAAAAAAACMlLpCTUSgAAAAAAAAAAAAAAAAAAAAAACAkVJXqIkI + FAAAAAAAAAAAAAAAAAAAAAAAMFLqCjURgQIAAAAAAAAAAAAAAAAAAAAAAEZKXaEmIlAAAAAAAAAAAAAA + AAAAAAAAAMBIqSvURAQKAAAAAAAAAAAAAAAAAAAAAAAYKXWFmohAAQAAAAAAAAAAAAAAAAAAAAAAI6Wu + UBMRKAAAAAAAAAAAAAAAAAAAAAAAYKTUFWoiAgUAAAAAAAAAAAAAAAAAAAAAAIyUukJNRKAAAAAAAAAA + AAAAAAAAAAAAAICRUleoiQgUAAAAAAAAAAAAAAAAAAAAAAAwUuoKNRGBAgAAAAAAAAAAAAAAAAAAAAAA + RkpdoSYiUAAAAAAAAAAAAAAAAAAAAAAAwEipK9REBAoAAAAAAAAAAAAAAAAAAAAAABgpdYWaiEABAAAA + AAAAAAAAAAAAAAAAAAAjpa5QExEoAAAAAAAAAAAAAAAAAAAAAABgpNQVaiICBQAAAAAAAAAAAAAAAAAA + AAAAjJS6Qk1EoAAAAAAAAAAAAAAAAAAAAAAAgJFSV6iJCBQAAAAAAAAAAAAAAAAAAAAAADBS6go1EYEC + AAAAAAAAAAAAAAAAAAAAAABGSl2hJiJQAAAAAAAAAAAAAAAAAAAAAADASKkr1EQECgAAAAAAAAAAAAAA + AAAAAAAAGCl1hZqIQAEAAAAAAAAAAAAAAAAAAAAAACOlrlATESgAAAAAAAAAAAAAAAAAAAAAAGCk1BVq + IgIFAAAAAAAAAAAAAAAAAAAAAACMlLpCTUSgAAAAAAAAAAAAAAAAAAAAAACAkVJXqIkIFAAAAAAAAAAA + AAAAAAAAAAAAMFLqCjURgQIAAAAAAAAAAAAAAAAAAAAAAEZKXaEmIlAAAAAAAAAAAAAAAAAAAAAAAMBI + qSvURAQKAAAAAAAAAAAAAAAAAAAAAAAYKXWFmohAAQAAAAAAAAAAAAAAAAAAAAAAI6WuUBMRKAAAAAAA + AAAAAAAAAAAAAAAAYKTUFWoiAgUAAAAAAAAAAAAAAAAAAAAAAIyUukJNRKAAAAAAAAAAAAAAAAAAAAAA + AICRUleoiQgUAAAAAAAAAPD/7NwxDQAAAAKg/q0tYADnOKgBAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAA + AAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCp + vUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAA + AAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADA + pPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAA + AAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAA + AJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAA + AAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAA + AABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAA + AAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAA + AAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUA + AAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAA + AAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkU + AAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAA + AAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8k + UAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAA + AAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9 + kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAA + AAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or + 9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAA + AAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExq + r9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAA + AAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAw + qb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAA + AAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAA + wKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAA + AAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAA + AACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAA + AAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAA + AAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEA + AAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAA + AAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIF + AAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAA + AAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJ + FAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAA + AAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJP + JFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAA + AAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYK + PZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAA + AAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPa + K/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAA + AAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABM + aq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAA + AAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAA + MKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAA + AAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAA + AMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAA + AAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAA + AAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAA + AAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAA + AAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUAB + AAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAA + AAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQC + BQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAA + AAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9AT + CRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAA + AAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1C + TyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAA + AAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2 + Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAA + AAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT + 2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAA + AAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAA + TGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAA + AAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAA + ADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAA + AAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAA + AADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAA + AAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAA + AAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAA + AAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAA + AAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFA + AQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAA + AAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/RE + AgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAA + AAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/Q + EwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAA + AAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9 + Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAA + AAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk + 9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAA + AAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAA + k9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAA + AAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAA + AExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAA + AAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAA + AAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAA + AAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAA + AAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQA + AAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAA + AAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQ + AAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAA + AAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2R + QAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAA + AAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0 + RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAA + AAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv + 0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAA + AAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCp + vUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAA + AAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADA + pPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAA + AAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAA + AJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAA + AAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAA + AABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAA + AAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAA + AAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUA + AAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAA + AAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkU + AAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAA + AAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8k + UAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAA + AAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9 + kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAA + AAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or + 9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAA + AAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExq + r9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAA + AAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAw + qb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAA + AAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAA + wKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAA + AAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAA + AACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAA + AAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAA + AAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEA + AAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAA + AAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIF + AAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAA + AAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJ + FAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAA + AAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJP + JFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAA + AAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYK + PZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAA + AAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPa + K/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAA + AAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABM + aq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAA + AAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAA + MKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAA + AAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAA + AMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAA + AAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAA + AAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAA + AAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAA + AAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUAB + AAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAA + AAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQC + BQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAA + AAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9AT + CRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAA + AAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1C + TyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAA + AAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2 + Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAA + AAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT + 2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAA + AAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAA + TGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAA + AAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAA + ADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAA + AAAAAAAAAAAAAAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAA + AADApPYKPZFAAQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAA + AAAAAAAAAAAAAAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAA + AAAAAJPaK/REAgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAA + AAAAAAAAAAAAAAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAA + AAAAAABMaq/QEwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFA + AQAAAAAAAAAAAAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAA + AAAAAAAAMKm9Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/RE + AgUAAAAAAAAAAAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAA + AAAAAAAAAMCk9go9kUABAAAAAAAAAAAAAAAAAAAAAACT2iv0RAIFAAAAAAAAAAAAAAAAAAAAAABMaq/Q + EwkUAAAAAAAAAAAAAAAAAAAAAAAwqb1CTyRQAAAAAAAAAAAAAAAAAAAAAADApPYKPZFAAQAAAAAAAAAA + AAAAAAAAAAAAk9or9EQCBQAAAAAAAAAAAAAAAAAAAAAATGqv0BMJFAAAAAAAAAAAAAAAAAAAAAAAMKm9 + Qk8kUAAAAAAAAAAAAAAAAAAAAAAAwKT2Cj2RQAEAAAAAAAAAAAAAAAAAAAAAAJPaK/REAgUAAAAAAAAA + AAAAAAAAAAAAAExqr9ATCRQAAAAAAAAAAAAAAAAAAAAAADCpvUJPJFAAAAAAAAAAAAAAAAAAAAAAAMCk + 9go9kUABAAAAAACEnTumAQAAQADUv7UFDOAcBzUAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAA + AAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKB + AgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAA + AAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJ + BAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAA + AAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6h + JxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAA + AAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7 + hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAA + AAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ + 7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAA + AAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAA + JrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAA + AAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAA + AJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAA + AAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAA + AABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAA + AAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAA + AAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigA + AAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAA + AAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkig + AAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAA + AAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoi + gQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAA + AAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfo + iQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAA + AAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNRe + oScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAA + AAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBS + e4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAA + AAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACA + Se0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAA + AAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAA + ACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAA + AAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAA + AACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAA + AAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAA + AAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoA + AAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAA + AAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIo + AAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAA + AAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5I + oAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAA + AAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6 + IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAA + AAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX + 6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAA + AAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjU + XqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAA + AAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABg + UnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAA + AAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAA + gEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAA + AAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAA + AAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAA + AAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAA + AAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIA + AAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAA + AAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQK + AAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAA + AAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScS + KAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAA + AAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4We + SKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAA + AAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0V + eiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAA + AAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1 + V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAA + AAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY + 1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAA + AAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAA + YFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAA + AAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAA + AIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAA + AAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAA + AAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAA + AAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAA + AAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoEC + AAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAA + AAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkE + CgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAA + AAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEn + EigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAA + AAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuF + nkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAA + AAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEnt + FXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAA + AAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAm + tVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAA + AAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAA + mNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAA + AAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAA + AGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAA + AAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAA + AACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAA + AAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAA + AAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAA + AAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAA + AAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKB + AgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAA + AAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJ + BAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAA + AAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6h + JxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAA + AAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7 + hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAA + AAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ + 7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAA + AAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAA + JrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAA + AAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAA + AJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAA + AAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAA + AABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAA + AAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAA + AAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigA + AAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAA + AAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkig + AAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAA + AAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoi + gQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAA + AAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfo + iQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAA + AAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNRe + oScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAA + AAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBS + e4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAA + AAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACA + Se0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAA + AAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAA + ACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAA + AAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAA + AACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAA + AAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAA + AAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoA + AAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAA + AAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIo + AAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAA + AAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5I + oAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAA + AAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6 + IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAA + AAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX + 6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAA + AAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjU + XqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAA + AAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABg + UnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAA + AAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAA + gEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAA + AAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAA + AAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAA + AAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAA + AAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIA + AAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAA + AAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQK + AAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAA + AAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScS + KAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAA + AAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4We + SKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAA + AAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0V + eiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAA + AAAAAAAAAAAAYFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1 + V+iJBAoAAAAAAAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAA + AAAAAAAAAAAAAIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY + 1F6hJxIoAAAAAAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAA + AAAAAAAAAAAAAAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAA + YFJ7hZ5IoAAAAAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAA + AAAAAAAAAAAAAAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAA + AIBJ7RV6IoECAAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAA + AAAAAAAAAAAAAAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAA + AAAAJrVX6IkECgAAAAAAAAAAAAAAAAAAAAAAmNReoScSKAAAAAAAAAAAAAAAAAAAAAAAYFJ7hZ5IoAAA + AAAAAAAAAAAAAAAAAAAAgEntFXoigQIAAAAAAAAAAAAAAAAAAAAAACa1V+iJBAoAAAAAAAAAAAAAAAAA + AAAAAJjUXqEnEigAAAAAAAAAAAAAAAAAAAAAAGBSe4WeSKAAAAAAAAAAAAAAAAAAAAAAAIBJ7RV6IoEC + AAAAAAAAAAAAAAAAAAAAAAAmtVfoiQQKAAAAAAAAAAAAAAAAAAAAAACY1F6hJxIoAAAAAAAAAAAAAAAA + AAAAAABgUnuFnkigAAAAAAAAAAAAAAAAAAAAAACASe0VeiKBAgAAAAAAAAAAAAAAAAAAAAAAJrVX6IkE + CgAAAICwd7e9UiV5up+/wR6eeheG7XeUG0NDuXd1lRu85a9haUseUTIaNDVi5BaoR0KyRAurkM6Xxh3U + wQlVf2A/rIy4V6zrxfXinJmeBiIjcmVGxC8BAAAAAAAAAAAAAAAAIFLVFZqJCBQAAAAAAAAAAAAAAAAA + AAAAABCp6grNRAQKAAAAAAAAAAAAAAAAAAAAAACIVHWFZiICBQAAAAAAAAAAAAAAAAAAAAAARKq6QjMR + gQIAAAAAAAAAAAAAAAAAAAAAACJVXaGZiEABAAAAAAAAAAAAAAAAAAAAAACRqq7QTESgAAAAAAAAAAAA + AAAAAAAAAACASFVXaCYiUAAAAAAAAAAAAAAAAAAAAAAAQKSqKzQTESgAAAAAAAAAAAAAAAAAAAAAACBS + 1RWaiQgUAAAAAAAAAAAAAAAAAAAAAAAQqeoKzUQECgAAAAAAAAAAAAAAAAAAAAAAiFR1hWYiAgUAAAAA + AAAAAAAAAAAAAAAAAESqukIzEYECAAAAAAAAAAAAAAAAAAAAAAAiVV2hmYhAAQAAAAAAAAAAAAAAAAAA + AAAAkaqu0ExEoAAAAAAAAAAAAAAAAAAAAAAAgEhVV2gmIlAAAAAAAAAAAAAAAAAAAAAAAECkqis0ExEo + AAAAAAAAAAAAAAAAAAAAAAAgUtUVmokIFAAAAAAAAAAAAAAAAAAAAAAAEKnqCs1EBAoAAAAAAAAAAAAA + AAAAAAAAAIhUdYVmIgIFAAAAAAAAAAAAAAAAAAAAAABEqrpCMxGBAgAAAAAAAAAAAAAAAAAAAAAAIlVd + oZmIQAEAAAAAAAAAAAAAAAAAAAAAAJGqrtBMRKAAAAAAAAAAAAAAAAAAAAAAAIBIVVdoJiJQAAAAAAAA + AAAAAAAAAAAAAABApKorNBMRKAAAAAAAAAAAAAAAAAAAAAAAIFLVFZqJCBQAAAAAAAAAAAAAAAAAAAAA + ABCp6grNRAQKAAAAAAAAAAAAAAAAAAAAAACIVHWFZiICBQAAAAAAAAAAAAAAAAAAAAAARKq6QjMRgQIA + AAAAAAAAAAAAAAAAAAAAACJVXaGZiEABAAAAAAAAAAAAAAAAAAAAAACRqq7QTESgAAAAAAAAAAAAAAAA + AAAAAACASFVXaCYiUAAAAAAAAAAAAAAAAAAAAAAAQKSqKzQTESgAAAAAAAAAAAAAAAAAAAAAACBS1RWa + iQgUAAAAAAAAAAAAAAAAAAAAAAAQqeoKzUQECgAAAAAAAAAAAAAAAAAAAAAAiFR1hWYiAgUAAAAAAAAA + AAAAAAAAAAAAAESqukIzEYECAAAAAAAAAAAAAAAAAAAAAAAiVV2hmYhAAQAAAAAAAAAAAAAAAAAAAAAA + kaqu0ExEoAAAAAAAAAAAAAAAAAAAAAAAgEhVV2gmIlAAAAAAAAAAAAAAAAAAAAAAAECkqis0ExEoAAAA + AAAAAAAAAAAAAAAAAAAgUtUVmokIFAAAAAAAAAAAAAAAAAAAAAAAEKnqCs1EBAoAAAAAAAAAAAAAAAAA + AAAAAIhUdYVmIgIFAAAAAAAAAAAAAAAAAAAAAABEqrpCMxGBAgAAAAAAAAAAAAAAAAAAAAAAIlVdoZmI + QAEAAAAAAAAAAAAAAAAAAAAAAJGqrtBMRKAAAAAAAAAAAAAAAAAAAAAAAIBIVVdoJiJQAAAAAAAAAAAA + AAAAAAAAAABApKorNBMRKAAAAAAAAAAAAAAAAAAAAAAAIFLVFZqJCBQAAAAAAAAAAAAAAAAAAAAAABCp + 6grNRAQKAAAAAAAAAAAAAAAAAAAAAACIVHWFZiICBQAAAAAAAAAAAAAAAAAAAAAARKq6QjMRgQIAAAAA + AAAAAAAAAAAAAAAAACJVXaGZiEABAAAAAAAAAAAAAAAAAAAAAACRqq7QTESgAAAAAAAAAAAAAAAAAAAA + AACASFVXaCYiUAAAAAAAAAAAAAAAAAAAAAAAQKSqKzQTESgAAAAAAAAAAAAAAAAAAAAAACBS1RWaiQgU + AAAAAAAAAAAAAAAAAAAAAAAQqeoKzUQECgAAAAAAAAAAAAAAAAAAAAAAiFR1hWYiAgUAAAAAAAAAAAAA + AAAAAAAAAESqukIzEYECAAAAAAAAAAAAAAAAAAAAAAAiVV2hmYhAAQAAAAAAAAAAAAAAAAAAAAAAkaqu + 0ExEoAAAAAAAAAAAAAAAAAAAAAAAgEhVV2gmIlAAAAAAAAAAAAAAAAAAAAAAAECkqis0ExEoAAAAAAAA + AAAAAAAAAAAAAAAgUtUVmokIFAAAAAAAAAAAAAAAAAAAAAAAEKnqCs1EBAoAAAAAAAAAAAAAAAAAAAAA + AIhUdYVmIgIFAAAAAAAAAAAAAAAAAAAAAABEqrpCMxGBAgAAAAAAAAAAAAAAAAAAAAAAIlVdoZmIQAEA + AACL+Pbg9N1fvvkvghwfvnz3v/zh//7En67/+3v/89X/670/Xnny7s4/x64aU4DLun/tWbk+AYxw7+rT + cq2ir/aMWo0PwAjVOkVfd688KceGvjwnZajGhr4eXP+5HBv6auNQjQ/ACP/Tv/yf5VpFX9XY0JfnpAx/ + /sPfyvGhn/b9djU29NW+x6jGB2CEdi6mWquAsdqZ2PaZvp2PbedkP5yb/e7G80/O037p/MLH/3tNdfbW + 9waQyz40kOThP59BqrUKuJiqKzQTESgAAABgEW0z83//H/8bK/b49pt3j269fve//g//z/svm9vG9f1r + //Z+w1ooCriIto5U6w3ACC4qZfjfbv+/5fgAjFCtU/TVvnOoxoa+PCdlqMaGvtp3otXY0Nf33/y9HB+A + EcQyM1RjQ1+ekzK0ffxqfOinfb9djQ19te8xqvEBGKGdi6nWKmB/2lnWFmD6EHVqIacfbr56f/a1nYGt + 5uq+nRy9/d3Z2w/BKKEoGMM+NJCkPSNUaxVwMVVXaCYiUAAAAMAiRKDm1zaq2xfQbcP8QyCqbaZXrweA + RgQKSCJukEEECkhSrVP05fBtBs9JGaqxoS9xgwwiUEASEagM1djQl+ekDCJQ44lAZRCBApKIQMH+tNhT + O6PaQk/tM0mLLLUzrNVcXIP253f2FvqxDw0kEYGCZVVdoZmIQAEAAACLEIHarg9xqPaLSm1z2i8XAR+I + QAFJxA0yiEABSap1ir4cvs3gOSlDNTb0JW6QQQQKSCIClaEaG/rynJRBBGo8EagMIlBAEhEoWMaH4FM7 + g9pCSWuOPZ3Xh7O37RlHGAqWYx8aSCICBcuqukIzEYECAAAAFiECxcfa4ce2Gd9+hcnGNGyXCBSQRNwg + gwgUkKRap+jL4dsMnpPG+/bgtBwb+hI3yCACBSQRgcpQjQ19eU7KIAI1nghUBhEoIIkIFFxMO2/8p+v/ + /v6zxuPbb8r5tVUffpS1nb1t+2jVvx/wdfahgSQiULCsqis0ExEoAAAAYBEiUHzJhyhUO4zXXivVawiY + jwgUkETcIIMIFJCkWqfoy+HbDJ6TxvPdagZxgwwiUEASEagM1djQl+ekDCJQ44lAZRCBApKIQMHZ3Dk4 + FX26oI+jUH6QFc7OPjSQRAQKllV1hWYiAgUAAAAswkUlzuPRrdfvjg9f+qUimJwIFJBE3CCDCBSQpFqn + 6Mvh2wyek8bz3WoGcYMMIlBAEhGoDNXY0JfnpAwiUOOJQGUQgQKSiEDB57VgUZsjnmOX1Z5J22c0Z2/h + y+xDA0lEoGBZVVdoJiJQAAAAwCJcVOKibErDvESggCTiBhlEoIAk1TpFXw7fZvCcNJ65kOH48EU5PvQl + AgUkEYHKUI0NfYlAZXB5fjwRqAwiUEASESj4VPuuu82Lx7fflHOGZZ0cvX3/ee3+tX8rxwO2zN4bkEQE + CpZVdYVmIgIFAAAALEIEiiUIQsFcRKCAJOIGGUSggCTVOkVfDt9m8Jw0nrmQwaW9DCJQQBIRqAzV2NCX + CFQGEajxRKAyiEABSXyfBP/Hu7tXngg/BRCEgk/ZewOSiEDBsqqu0ExEoAAAAIBFiECxtHaA8rsbz9+/ + tqrXHJBPBApIIm6QQQQKSFKtU/Tl8G0Gz0njucCawaW9DCJQQBIRqAzV2NCXCFQGEajxRKAy+AwNJPF9 + Elt15+D0/dlOz6iZ2nNr+xz3xytPyvGDLbAPDSQRgYJlVV2hmYhAAQAAAIsQgWKf2hffLiTC+ohAAUk8 + S2QQgQKSVOsUfTl8m8Fz0njtskw1NvTl0l4GESggiQhUhmps6EsEKoML9uOJQGUQgQKS+D6JrWn7Oj/e + fPXu5OhtOSfI8+jW6/fPTy3cVY0pzMo+NJBEBAqWVXWFZiICBQAAACxCBIoe2qHKhzeev3+9Va9DIIsI + FJBE3CCDCBSQpFqn6Mvh2wyek8Y7PnxRjg19mQsZRKCAJCJQGaqxoS8RqAwiUOOJQGUQgQKSiECxBS0e + 1H7IwPPourVn2fbZztlbtsI+NJBEBAqWVXWFZiICBQAAACxCBIrebEhDPhEoIIkL3RlEoIAk1TpFXw7f + ZvCcNF775fRqbOjLXMggAgUkEYHKUI0NfYlAZXDpfjwRqAwiUEASEShm1uJP7TV+cvS2fP2zXj/cfPV+ + j64ad5iFfWggiQgULKvqCs1EBAoAAABYhAgUo7QvxW1IQyYRKCCJC90ZRKCAJNU6RV8O32bwnDSey9wZ + hD4yiEABSbw3ZKjGhr5EoDL43DCeCFQGESggiQgUM2p7N+0zQPWaZy7t+dYeEbOyDw0kEYGCZVVdoZmI + QAEAAACLEIFitPbluA1pyCICBSTxnJBBBApIUq1T9OXwbQbPSeP5JfUMQh8ZRKCAJN4bMlRjQ18iUBlE + oMYTgcogAgUkEYFiJm3PxjPnNolBMSP70EASEShYVtUVmokIFAAAALAIEShS2JCGHCJQQBLPBxlEoIAk + 1TpFXw7fZvCcNNa3B6fluNDf3Ss/lWNEXyJQQBIRqAzV2NCXCFQGF/LHE4HKIAIFJBGBYgbiT3zg7C0z + sQ8NJBGBgmVVXaGZiEABAAAAixCBIk37srxt4lWvV6APESggiYNqGUSggCTVOkVfDt9m8Jw01t0rT8px + ob8//sv/WY4RfYlAAUlEoDJUY0NfIlAZXMwfTwQqgwgUkEQEijVrZ349Y1IRg2IG9qGBJCJQsKyqKzQT + ESgAAABgESJQpGqHktvrs3rdAvslAgUkcUAtgwgUkKRap+jL4dsMnpPG+tO1Z+W40F81PvQnAgUkEYHK + UI0NfYlAZXBBfzwRqAwiUEASESjW6M7B6bvjwxflaxo+1p5//RAra2UfGkgiAgXLqrpCMxGBAgAAABYh + AkU6MSjoTwQKSCJukEEECkhSrVP05fBtBs9JY/nsnOHk6G05PvQnAgUkEYHKUI0NfYlAZRCBGk8EKoMI + FJBEBIo1afGn9ppt34VWr2f4HGdvWSP70EASEShYVtUVmokIFAAAALAIESjWoB3KfHjjefkaBpbnIiuQ + RNwggwgUkKRap+jL4dsMnpPGcpE7w19vvS7Hh/5EoIAkIlAZqrGhLxGoDD47jCcClUEECkgiAsVa3L/2 + zF49l3Z8+FIMitWwDw0kEYGCZVVdoZmIQAEAAACLEIFiTdqBhrtXfipfy8ByRKCAJOIGGRwsBZJU6xR9 + OXybwXPSWJ6PMjh4m0MECkgiApWhGhv6EoHKIAI1nghUBhEoIIkIFOnauV7PkSypPRPbV2IN7EMDSexF + w7KqrtBMRKAAAACARYhAsUbtwLJfJoL9EYECkjiElkHkAEhSrVP05fBtBs9J4/hONccPN1+VY0R/IlBA + EhGoDNXY0JcIVAaX98cTgcogAgUkEYEi1Z2DU+e22Kv2+cTZW5LZhwaSiEDBsqqu0ExEoAAAAIBFuLDE + WvllItgfh4mAJN7vM4hAAUmqdYq+HL7N4DlpnD9de1aOCf0dH74ox4j+RKCAJCJQGaqxoS8RqAwiUOOJ + QGUQgQKSiECRqO292JenF+sgqexDA0lEoGBZVVdoJiJQAAAAwCJEoFi7dnjZLxPBskSggCTiBhkcNgWS + VOsUfTl8m8Fz0jgtPFSNCf25qJJDBApIIgKVoRob+hKByiACNZ4IVAYRKCCJ75RIcufg1HfODNGek529 + JY19aCCJCBQsq+oKzUQECgAAAFiECBQzaJvRLj7CckSggCTe4zOIQAFJqnWKvhy+zeA5aRyXuHPcv/as + HCP6E4ECkohAZajGhr5EoDL4/DCeCFQGESggiQgUKdp+i714RrMmksQ+NJBEBAqWVXWFZiICBQAAACxC + BIqZtIPMfpkILk8ECkgibpDBwVMgSbVO0ZfDtxk8J43x7cFpOR6MIfKRQwQKSOL9IUM1NvQlApVBBGo8 + EagMIlBAEsETRrtzcPru+PBF+fqEEdozs7O3JLAPDSQRgYJlVV2hmYhAAQAAAIsQgWI2bTPa4X64HBEo + IIm4QQYRKCBJtU7Rl8O3GTwnjeH1n+WPLqXEEIECktgnylCNDX2JQGUQgRpPBCqDCBSQRASKke5eeWL/ + nVgPbzwvX7fQi304IIkIFCyr6grNRAQKAAAAWIQIFLNyWAcuTgQKSCJukMEhVCBJtU7Rl8O3GTwnjeHX + 2bNUY8QYIlBAEhGoDNXY0JcIVAYRqPFEoDKIQAFJnCtjlO9uPH93cvS2fF1CivZZsp0tr17DsG/2oYEk + IlCwrKorNBMRKAAAAGARIlDMrB3mtBkN5ycCBSQRN8ggAgUkqdYp+nL4NoPnpDEe3Xpdjgf9/fWfY1GN + EWOIQAFJRKAyVGNDXyJQGUSgxhOByiACBSQRgaK3Owen7368+ap8PUKi9gx998pP5esZ9sk+NJBEBAqW + VXWFZiICBQAAACxCBIrZtc3o+9eela9/oCYCBSQRN8ggAgUkqdYp+nL4NoPnpP58l5rFodssIlBAEhGo + DNXY0JcIVAYRqPFEoDKIQAFJRKDo6e6VJ/bbWS3rJb3ZhwaS2I+GZVVdoZmIQAEAAACLcHGJrbAZDWcn + AgUkETfI4FAqkKRap+jL4dsMnpP6++7G83IsGOP48EU5TowhAgUkEYHKUI0NfYlAZRCBGk8EKoMIFJDE + OTJ6ad8pnxy9LV+HsBbts+Wdg9PyNQ5Lsw8NJBGBgmVVXaGZiEABAAAAixCBYkt+uPnq/Wu+mgvAjggU + kETcIIMIFJCkWqfoy+HbDJ6T+nN5O8vDG8/LcWIMESggiQhUhmps6EsEKoPPEeOJQGUQgQKSiEDRQ4vY + V68/WKP2TO3sLT3YhwaSiEDBsqqu0ExEoAAAAIBFiECxNTaj4etEoIAk4gYZRKCAJNU6RV8O32bwnNSX + 71HzCHxkEYECkniPyFCNDX2JQGUQgRpPBCqDCBSQRASKfWrfJXsGZEbtufr+tWfl6x6WYh8aSCICBcuq + ukIzEYECAAAAFuHyElt0cvTWZjR8gQgUkETcIIMIFJCkWqfoy+HbDJ6T+nJZNc/dKz+VY8UYIlBAEhGo + DNXY0JcIVAYBgPFEoDL4XA0kEYFiX9p5XHvrzM4ayj7ZhwaSiEDBsqqu0ExEoAAAAIBFiECxZTajoSYC + BSQRN8jgoCqQpFqn6Mvh2wyek/p6dOt1OQ6MU40T44hAAUlEoDJUY0NfIlAZRKDGE4HKIAIFJHFmjH1o + eyftxymr1xzMxjrKvtiHBpKIQMGyqq7QTESgAAAAgEWIQLF1NqPh90SggCTiBhlEoIAk1TpFXw7fZvCc + 1M/dK0/KMWCcv956XY4V44hAAUlEoDJUY0NfIlAZRKDGE4HKIAIFJHFejKV9d+N5+VqDmf1w89W7Owen + 5ZyAi7IPDSQRgYJlVV2hmYhAAQAAAIsQgQIHoOG3RKCAJOIGGUSggCTVOkVfDt9m8JzUT/vuqBoDxmmX + S6qxYhwRKCCJCFSGamzoyx5oBhGo8USgMohAAUlEoFiSc1ZsWXvWbufQq7kBF2EfGkgiAgXLqrpCMxGB + AgAAABYhAgW/enTrtV8lgv/O4SQgibhBBhEoIEm1TtGXw7cZPCf141koz8Mbz8uxYhwRKCCJCFSGamzo + SwQqgwjUeCJQGUSggCQiUCzFd2IgBMWy7EMDSUSgYFlVV2gmIlAAAADAIkSgYMdmNPxKBApIIm6QQfgA + SFKtU/Tl8G0Gz0l9uKSaSdwjjwtvQBLvExmqsaEvEagMIlDjiUBl8PkaSCICxWW1H5v88ear8vUFW9Se + ue9e+amcL3Ae9qGBJCJQsKyqKzQTESgAAABgESJQ8CkhKBCBArKIG2QQgQKSVOsUfTl8m8FzUh+egzK1 + S1bVeDGOCBSQRAQqQzU29CUClUEEajwRqAwiUEASESguo303+ejWP8rXFmzZydFbISguzT40kEQECpZV + dYVmIgIFAAAALEIECn5PCIqtE4ECkogbZBA/AJJU6xR9OXybwXPS/nmtZ3p8+005XowlAgUkEYHKUI0N + fYlAZRCBGk8EKoMIFJBEBIqLamcKBaDg81oI6v61Z+X8gbOwNwckEYGCZVVdoZmIQAEAAACLEIGCmhAU + WyYCBSQRN8ggAgUkqdYp+nL4NoPnpP1zWTvTDzdflePFWCJQQBIRqAzV2NCXCFQGnyvGE4HKIAIFJBGB + 4iLaWUL75nA29rC4KPvQQBIRKFhW1RWaiQgUAAAAsAgRKPg8ISi2SgQKSOJgWAaHWYEk1TpFXw7fZvCc + tF++N83lkl4mESggiQhUhmps6EsEKoMI1HgiUBlEoIAkvl/ivASg4PzsY3ER9qGBJCJQsKyqKzQTESgA + AABgES4zwZcJQbFFIlBAEofCMjjQCiSp1in6cvg2g+ek/WoX5qt/d8YT9sgkAgUk8V6RoRob+hKByiAC + NZ4IVAYRKCCJCBTnIQAFF2cvi/OyDw0kEYGCZVVdoZmIQAEAAACLEIGCrxOCYmtEoIAkDoRlcKgVSFKt + U/Tl8G0Gz0n74zvTbHcOTstxYywRKCCJCFSGamzoSwQqgwjUeCJQGUSggCQiUJyVABRcnv0szsM+NJBE + BAqWVXWFZiICBQAAACzChSY4GyEotkQECkjiMFgGB1uBJNU6RV8O32bwnLQ/7bJ89W/OeH+99bocM8YT + gQKSiEBlqMaGvkSgMohAjScClUEECkgiAsVZCEDBcuxpcVb2oYEkIlCwrKorNBMRKAAAAGARIlBwdkJQ + bIUIFJDEQbAMDrcCSap1ir4cvs3gOWk/vL6zCRnkEoECkohAZajGhr48O2UQgRpPBCqDCBSQRASKr7lz + cGqPHBbm+xrOwj4dkEQECpZVdYVmIgIFAAAALEIECs5HCIotEIECkogbZHDAFUhSrVP05fBtBs9J++G5 + J5vXfS4RKCCJS4UZqrGhLxGoDCJQ44lAZRCBApKIQPElLQD16NY/ytcOcHEnR2/f3b3yUznv4AP70EAS + EShYVtUVmokIFAAAALAIESg4PyEoZicCBSRxyTuDGAKQpFqn6Mvh2wyek5bnQmo+F0RyiUABSUSgMlRj + Q18iUBlEoMYTgcrgMzeQRASKL/nx5qvydQNcXgtBOXvLl9iHBpKIQMGyqq7QTESgAAAAgEWIQMHFPLr1 + +v2vflXzCtZOBApIIm6QQQQKSFKtU/Tl8G0Gz0nLat/zeObJ9vj2m3LsyCACBSQRgcpQjQ19iUBlEIEa + TwQqgwgUkEQEis85PnxRvmaA5bTncyEoPsc+NJBEBAqWVXWFZiICBQAAACxCBAou7oebr8p5BWsnAgUk + ETfIIIgAJKnWKfpy+DaD56Rl+Sycz3dx2USggCQiUBmqsaEvEagMIlDjiUBlEIECkohAUfEdMfQjBMXn + 2IcGkohAwbKqrtBMRKAAAACARYhAweUcH74s5xasmUNNQBJxgwwiUECSap2iL4dvM3hOWo7vSNfBaz6b + CBSQRAQqQzU29CUClUEEajwRqAwiUEASESh+y1kp6O/Rrdfv7hyclnOS7bIPDSQRgYJlVV2hmYhAAQAA + AItwwQkuz8EgZuNgE5DERe8MIlBAkmqdoi+HbzN4TlqOZ5118Kvg2USggCQiUBmqsaEvEagMIlDjiUBl + EIECkjjrxcfuX3tWvk6A/fO5ld+yDw0kEYGCZVVdoZmIQAEAAACLEIGCZbh4yUxEoIAk3mMzCCMASap1 + ir4cvs3gOWkZPgOvw+Pbb8rxI4cIFJBEBCpDNTb05TJtBhGo8USgMohAAUlEoPignZ89OXpbvk6APqzJ + fMw+NJBEBAqWVXWFZiICBQAAACxCBAqW0Q6D3L3yUznPYG1cgAWSiBtkEIECklTrFH05fJvBc9Ll+W50 + PQQM8olAAUlEoDJUY0Nf7Tu99sxbjQ/9iECNJwKVQQQKSCI4QtOele2DQwZ7XnxgHxpIIgIFy6q6QjMR + gQIAAAAW4aITLMdBamYhAgUkcdArg8OvQJJqnaIvh28zeE66PM8463H/2rNyDMkhAgUkEYHKUI0N/dm/ + HE8Earw2D6qxoS8RKCCJCBTNo1v/KF8fQH9+hJUP7EMDSUSgYFlVV2gmIlAAAADAIkSgYFmPbr0u5xqs + iQgUkETcIINAApCkWqfoy+HbDJ6TLsdn33W5c3BajiM5RKCAJCJQGaqxYQwhqLFEoMYTgcogAgUkEYHi + +PBF+doAxvHZlcY+NJBEBAqWVXWFZiICBQAAACxCBAqWd3z4spxvsBYuwgJJxA0yiEABSap1ir4cvs3g + OenivIbXxeHadRCBApKIQGWoxoZxXKYdRwRqPBGoDCJQQBIRqG1zLgpy+RFW7OEBSexTw7KqrtBMRKAA + AACARYhAwX48vPG8nHOwBg47AUnEDTKIQAFJqnWKvhy+zeA56WLa96GebdbFa30dRKCAJCJQGaqxYSwh + qDFEoMYTgcogAgUkEYHarrtXnpSvCSCHH2HdNvvQQBIRKFhW1RWaiQgUAAAAsAgRKNiPk6O37+5e+amc + d5BOBApI4sJ3BqEEIEm1TtGXw7cZPCddjAvY6yNUsA4iUEASEagM1dgwnhBUfz6DjCcClUEECkgiArVN + fiAA1sMe2HbZhwaSiEDBsqqu0ExEoAAAAIBFiEDB/rRDI3cOTsu5B8lEoIAkDnZlcBgWSFKtU/Tl8G0G + z0nn5/Pu+vz11utyLMkjAgUkEYHKUI0NGYSg+hKBGk8EKoMIFJBEBGqbfrz5qnw9AHnaj7D63LpN9qGB + JCJQsKyqKzQTESgAAABgESJQsF9/+ea/yrkHyVyKBZKIG2QQgQKSVOsUfTl8m8Fz0vl8d+N5+e9ItuPD + F+V4kkcECkgiApWhGhtyCEH1IwI1nghUBhEoIIkI1PY4CwXr8+jWaz/CukH2oYEkIlCwrKorNBMRKAAA + AGARIlCwfw9vPC/nH6Ry8AlIIm6QQQQKSFKtU/Tl8G0Gz0ln174Dbb8aXf07ku3ulZ/KMSWPCBSQRAQq + QzU2ZBGC6kMEajwRqAwiUEASEahtcUYW1uv48GU5r5mXfWggiQgULKvqCs1EBAoAAABYhA1u2L92ydAB + atZEBApIIm6QQQQKSFKtU/Tl8G0Gz0ln076T8SyzTo9vvynHlEwiUEASEagM1diQRwhq/0SgxhOByiAC + BSQRgdqOOwenvh+GlfM9z7bYhwaSiEDBsqqu0ExEoAAAAIBFiEBBHzYBWBMRKCCJuEEGB2OBJNU6RV8O + 32bwnPR1Lvis2/Hhi3JcySQCBSRxOTBDNTZkEoLaLxGo8USgMohAAUlEoLbjL9/8V/kaANaj/Qhr2++p + 5jjzsQ8NJHH/A5ZVdYVmIgIFAAAALEIECvp5eON5OQ8hjQgUkETcIIN4ApCkWqfoy+HbDJ6Tvu7RrX+U + /3asw90rP5XjSiYRKCCJCFSGamzIJQS1PyJQ44lAZRCBApKIQG2D9x6Yxw83X5XznPnYhwaSiEDBsqqu + 0ExEoAAAAIBFiEBBXy6vscMVbOYAAP/0SURBVAYiUEAScYMMIlBAkmqdoi+HbzN4TvoyQZp1++ut1+W4 + ksucA5KIQGWoxoZsQlD7IQI1nghUBiEOIIkI1Pzac609bpiLH2HdBvvQQBIRKFhW1RWaiQgUAAAAsAgR + KOjrkQtsrIAIFJBE3CCDA7JAkmqdoi+HbzN4Tvo8n2vXz+t7fUSggCQiUBmqsSGfENTyRKDGE4HKIAIF + JBGBmt9fvvmvcuyB9To5euvz6gbYhwaSiEDBsqqu0ExEoAAAAIBFiEBBfw4Skc5lWSCJy98ZRKCAJNU6 + RV8O32bwnFTzmXYOLnKsjwgUkEQEKkM1NqyDENSyRKDGE4HKIAIFJHF2a27ec2BeYhzzsw8NJPG+A8uq + ukIzEYECAAAAFiECBf35RSLSuTALJBE3yCACBSSp1in6cvg2g+ek3/N5dg4O066TCBSQRAQqQzU2rIcQ + 1HJEoMYTgcogyAEkEYGaV3uGtbcNc7t/7Vk5/5mDfWggiX1rWFbVFZqJCBQAAACwCBEoGMOmAMlcmgWS + iBtkcFAWSFKtU/Tl8G0Gz0mf8ll2Hl7b6yQCBSQRgcpQjQ3rIgS1DBGo8USgMohAAUlEoOb1l2/+qxxz + YB7tR1jvHJyWawDrZx8aSOK+Byyr6grNRAQKAAAAWIQIFIzz8Mbzcl7CaC7OAklcAM8gAgUkqdYp+nL4 + NoPnpB2fY+fx+PabcozJJwIFJBGBylCNDesjBHV5IlDjiUBlEIECkohAzclZWNiO48OX5TrA+tmHBpKI + QMGyqq7QTESgAAAAgEXY+IZx/CIRqVyeBZKIG2QQgQKSVOsUfTl8m8Fz0q+EZ+bSfqm/GmfymYtAEhGo + DNXYsE5CUJcjAjWeCFQGESggiQjUnOxpw7b4/mdO9qGBJCJQsKyqKzQTESgAAABgESJQMJZfJCKRCBSQ + RNwggwOzQJJqnaIvh28zbP05qYW1RWfmc/fKT+V4k898BJK4BJihGhvWSwjq4kSgxhOByiACBSQRgZqP + 9xnYHmGOOdmHBpJ4r4FlVV2hmYhAAQAAAIsQgYLxXEYgjQgUkEQEKoMIFJCkWqfoy+HbDFt+TmrfaT66 + 9Y/y34X1+uut1+V4sw4iUEAS+y4ZqrFh3YSgLkYEajwRqAziHEASEai5tGdU+9mwTQ9vPC/XBdbLPjSQ + RAQKllV1hWYiAgUAAAAsQgQKxrNBQBoRKCCJCFQGh2aBJNU6RV8O32bY6nOSCz3z8uy/biJQQBIRqAzV + 2LB+QlDnJwI1nghUBhEoIIkI1Fz+8s1/leMMzO/k6O27Owen5drAOtmHBpK44wHLqrpCMxGBAgAAABYh + AgUZXEggiQgUkMRF8AxCC0CSap2iL4dvM2zxOam99tqB/urfg3V7fPtNOeashwgUkMSeS4ZqbJiDENT5 + iECNJwKVQQQKSCICNQ/nXwFr+lzsQwNJRKBgWVVXaCYiUAAAAMAibIJDBgdPSSICBSQRgcogAgUkqdYp + +nL4NsPWnpO+u/G8/HdgDu3X+qtxZz1EoIAkIlAZqrFhHkJQZycCNZ69+AwiUEASwZB5tO8VqzEGtqP9 + eIjPp/OwDw0kEYGCZVVdoZmIQAEAAACLEIGCHA9vPC/nKfQmAgUkEYHKIAIFJKnWKfpy+DbDVp6T7hyc + istsgAsa62eeAklEoDJUY8NchKDORgRqPBGoDCJQQBIRqDnYqwA+8EMT87C2A0lEoGBZVVdoJiJQAAAA + wCJEoCBH+0WidrGxmqvQkwgUkEQEKoMIFJCkWqfoy+HbDFt4Trp75YnnkA1wOWMOIlBAEhGoDNXYMB8h + qK8TgRpPBCqDCBSQRARqDo9uvS7HF9gmn03nYB8aSCICBcuqukIzEYECAAAAFiECBVkcMiKBCBSQRAQq + g/gCkKRap+jL4dsMsz8nfXfj+ftgdvV3Zy5CHXMQgQKSeG/JUI0NcxKC+jIRqPFEoDKIQAFJnM9aP+8r + wG8JdczBPjSQxHsLLKvqCs1EBAoAAABYhAgUZGmXG+8cnJbzFXoRgQKSiEBlEIECklTrFH05fJth1uek + 9n2lS9Lb4eDsPESggCQiUBmqsWFeQlCf5/PNeCJQGcQ6gCQiUOtn/xqo+E5o/exDA0nsZcOyqq7QTESg + AAAAgEWIQEEeB40YTQQKSCIClcEhWiBJtU7Rl8O3GWZ8Trp/7dn7QHb192VOnvfnIQIFJHHhL0M1NsxN + CKomAjWeCFQGESggibNZ6+Y9BfgcsY71sw8NJPG+AsuqukIzEYECAAAAFiECBXnaZcc7B6flnIUeRKCA + JC6FZxCBApJU6xR9OXybYabnpPYdpYvR2/P49pvy9cA6iUABSUSgMlRjw/yEoH7PZ53xRKAyCHYASUSg + 1s3eNfAlvhdaN/vQQBIRKFhW1RWaiQgUAAAAsAgRKMjksBEjiUABSUSgMjhICySp1in6cvg2wyzPSd/d + eP4+iF39HZmbZ/25iEABSVz2y1CNDdsgBPUpEajxRKAyiEABSZzLWi/7E8DX/HDzVbl+sA7WeSCJCBQs + q+oKzUQECgAAAFiECBRkapcf7xyclvMW9k0ECkjiYngGESggSbVO0ZfDtxnW/pzUXkePbv2j/Lsxv8e3 + 35SvC9ZLBApIIgKVoRobtkMIakcEajwRqAwiUEASEaj18mwFnIXPo+tlHxpIIgIFy6q6QjMRgQIAAAAW + IQIFuUQvGEUECkji/TCDCBSQpFqn6Mvh2wxrfU5q30e6qIPn/PmIQAFJRKAyVGPDtghB/crnn/FEoDKI + QAFJRKDW6e6VJ+V4AvzW8eGLch0hn31oIIkIFCyr6grNRAQKAAAAWIQIFOSyccAoIlBAEpfDM4hAAUmq + dYq+HL7NsLbnpDsHp+8P3Vd/F7bl8e035WuEdROBApKIQGWoxobtEYISgUogApVBBApIIgK1Tn/55r/K + 8QT4rZOjt+/3paq1hGz2oYEk7nLAsqqu0ExEoAAAAIBFiEBBNhcVGEEECkgiApVBBApIUq1T9OXwbYa1 + PCe1Q/btc2Y7cF/9Pdgez/hzEoECkthbyVCNDdu09RCUCNR4IlAZRKCAJCJQ6+OcK3Be1vp1sg8NJBGB + gmVVXaGZiEABAAAAi7A5DtlsHjCCCBSQxAXxDCJQQJJqnaIvh28zpD8ntdeJX2bntx7fflO+Xlg/ESgg + iQhUhmps2K4th6BEoMYTgcogAgUkEQZZH981A+fVfpykWk/IZh8aSOIeByyr6grNRAQKAAAAWIQIFOS7 + c3Bazl/YFxEoIIkIVAYRKCBJtU7Rl8O3GVKfk9rrwyVnPsfz/bxEoIAkIlAZqrFh27YagvL5aDwRqAwi + UEASEaj1sV8NXITviNbHPjSQRAQKllV1hWYiAgUAAAAsQgQK8jl4RG8iUEASl8QzOFQLJKnWKfpy+DZD + 0nNSC1i3z5LtV5WrPys0j2+/KV8/zEEECkjigl+GamxgiyEoEajxRKAyiEABSZzFWhfvIcBFiXesj31o + IIn3EVhW1RWaiQgUAAAAsAgRKMjXLlC2y5TVHIZ9EIECkohAZRCBApJU6xR9OXybYfRzUvuu4k/X/92F + Zs7Ms/3cRKCAJCJQGaqxgWZrISifmcYTgcog4AEkEYFaF89TwGXcvfJTubaQyT40kEQECpZVdYVmIgIF + AAAALEIECtbh/rVn5RyGfRCBApK4KJ5BBApIUq1T9OXwbYYRz0kfh59atLr6c0HFAdn5iUABSUSgMlRj + Ax9sKQQlWjCeCFQGESggiQjUejjfClyWNX9d7EMDSexxw7KqrtBMRKAAAACARdgkh3WwiUBPIlBAEhGo + DCJQQJJqnaIvh28z9HpOauPdPie6uMxlbOWC/5aJQAFJRKAyVGMDH9tKCMpnqfFEoDKIQAFJBEHW4y/f + /Fc5hgBn1X7UpFpfyGQfGkji/gYsq+oKzUQECgAAAFiECBSsx52D03Iew9JEoIAkIlAZRKCAJNU6RV8O + 32bYx3NS++6hje93N56/++Hmq/cH46v/bjiPdlGrer0xFxEoIIkIVIZqbOC3thCCEoEaTwQqgwgUkEQE + aj3sUwNL8F3RetiHBpKIQMGyqq7QTESgAAAAgEWIQMF6OIBELyJQQBIRqAwO1wJJqnWKvhy+zXDZ56T2 + veD9a//2PvjUIj2Pb78p/3vgMk6Ofpn+Uj+/EoECkrjYl6EaG6jMHoISgRpPBCqDCBSQxBmsdfjTtWfl + +AGcl4jHetiHBpJ4/4BlVV2hmYhAAQAAAIsQgYL1sJFALyJQQBIRqAwiUECSap2iL4dvM1TPSXcOTt9/ + 39e0cWqRpz9d//f3n/Na6OmHm6/Enujqz3/42+9ep8xJBApIIgKVoRob+JyZQ1AiUOOJQGUQgQKSiECt + Q/tOuxo/gPM6OXr7fg+tWmvIYh8aSOLuBiyr6grNRAQKAAAAWIQIVIbjw5fv/vgv//r/a4fTm+9uPH// + P/vx5qt3j269Lv+zbIuLCwAAAIzm8C1wFi04Vq0hwP5Uc5G+2gXVamxgi6o5Al8yawhKBGo8ESjYsSaN + Z02Cs/n24PR9tKWaR2xH+465nZ1tZ2jbWdo/XXv2/vzkx2dtW9jn4//3h7O3LUDZgm/O3vLBw3++hqr1 + Bvg9PySb4Y+TBtOB7aq6QjMRgQIAAAAWIQKV4ay/LtY2rNsGdfvfdzBrm/wSHQAAAKOJQAFn0S7ZVGsI + sD/VXKQvESjYqeYIfM2MISj7+uMJrsCONWk8axKcTftusZpDzK3FmlrwqcWe2lnZ6rVxGe3sbYtJeT/c + pjbu1esC+D0RqAwiUMBsqq7QTESgAAAAgEWIQGW4aNinjV878GBTejscBgMAAGA0ESjga0RQYIxqPtKX + 9Q92qjkCZzFbCMpe/nj22GHHmjSeNQnO5sebr8o5xHzae1MLM+0j+vQl7b+vxabadznVn4s59X6dwVqJ + QGUQgQJmU3WFZiICBQAAACxCBCrDRSNQH2tj+ec//O3d49tvyv8O5nH3yk/lawAAAAB6EIECvmamS/uw + JtV8pC8RKNip5gic1UwhKMGV8QRXYMeaNJ41Cc7m5OhtOYeYw8nRL+/PuqYEedpnj/ZjrM7ezq+Nc/Ua + AD4lApVBBAqYTdUVmokIFAAAALAIEagMS0SgPmZDem5Lv14AAADgPESggC9pl3eqtQPYv2pO0pcIFOxU + cwTOY5YQlODKeIIrsGNNGs+aBF/3p2vPyvnD+rUzrd/deB4Tf6q015/3y3m1sa3GHfiUCFQGEShgNlVX + aCYiUAAAAMAiRKAy7CvqIwY1JxvRAAAAjCQCBXxO+y6yWjeAPqp5SV8iULBTzRE4rxlCUC6Qjye4AjvW + pPGsSfB17bN1NX9Yr5OjX96fZa3GO5Wzt3M6OXobHSGDFCJQGUSggNlUXaGZiEABAAAAixCByrCvCFTz + 7cHp+1/fr/57WS8b0QAAAIwiAgV8ztov6MPaVfOSvkSgYKeaI3ARaw9BCa6MJ7gCO9ak8axJ8HVtnlTz + h/Vp8ad2dnXNZx3FoOZz7+rTcqyBHRGoDCJQwGyqrtBMRKAAAACARYhAZdhnBOqDNtY2o+extl/GAgAA + YB4iUEClXeap1gygn2pu0pcIFOxUcwQuas0hKMGV8QRXYMeaNJ41Cb7M/sM82nvOLD8a0P4e7Tuf6u/J + +hwfvijHGdgRgcogAgXMpuoKzUQECgAAAFiECFSGHhGoD9plrOrPwLq4SAIAAMAoLmEAv9Xi89V6AfRV + zU/68t097FRzBC5jrSEowZXxBFdgx5o0njUJvuy7G8/LucN6nBz98s9x/M9yfNeu/XDnydHb8u/Nengv + hq8TgcogAgXMpuoKzUQECgAAAFiECFSGnhGo5t7Vp+8vZlV/FtahHSaoxhYAAAD2TQQK+K32fWO1XgB9 + VfOTvkSgYKeaI3BZawxBCa6M55I37FiTxrMmwZdZp9atnUldY7j1PNrfz9nb9RNWgS8TgcpgrQJmU3WF + ZiICBQAAACxCBCpD7whUYzN6/VyuAwAAYAQRKOBjf/7D38q1AuivmqP0JQIFO9UcgSWsLQQlZDCe4Ars + WJPGsybB5317cFrOG9ahfSdy559jWI3tbNpr9fvDl+W/A+vw8MbzcmyBX4lAZRCBAmZTdYVmIgIFAAAA + LEIEKsOICFTTNqPb5nv1ZyKfjWgAAABGEIECPmiR+WqdAMao5il9iUDBTjVHYClrCkEJrownuAI71qTx + rEnwefYe1murPxTQ/t7Vvwf5fIcHXyYClUEECphN1RWaiQgUAAAAsAgRqAyjIlAf2Ixep3Y4rxpPAAAA + 2CcXMYAP1nLxHraimqf05QIZ7FRzBJa0lhCU4Mp4giuwY00az5oEn3d8+KKcN2T77sZ/luO5Fc7ertPJ + 0dtyPIFfiUBlEIECZlN1hWYiAgUAAAAsQgQqw+gIVGMzen1sRAMAADCCCBTQbPXX3SFZNVfpSwQKdqo5 + AktbQwhKcGU8wRXYsSaNZ02Cz7NGrcvJ0S/vHl7/j3Ist+bB9Z/LfyOyiavA54lAZbBOAbOpukIzEYEC + AAAAFiEClSEhAtUIQa3P3Ss/lWMJAAAA+yICBTy69bpcH4CxqvlKXyJQsFPNEdiH9BCUmMF4giuwY00a + z5oEn1fNGTK1ANTdK0/KcdwqIaj1aWNWjSUgApVCBAqYTdUVmokIFAAAALAIEagMKRGoRghqXR7eeF6O + IwAAAOyLCBRs2+Pbb6Iv2cOWVXOWvkSgYKeaI7AvySEowZXxBFdgx5o0njUJavYd1kUAqiYEtS6+x4PP + E4HKIAIFzKbqCs1EBAoAAABYhAhUhqQIVCMEtR42ogEAAOjNZQzYNr+ODbmqOUtfvrOHnWqOwD6lhqAE + V8YTXIEda9J41iSofXfjeTlnyPPw+n+UY8ivhKDWw3syfJ4IVAYRKGA2VVdoJiJQAAAAwCJEoDKkRaCa + dlGh+rOSxUY0AAAAvYlAwXa1eHy1LgAZqnlLXyJQsFPNEdi3xBCU4Mp49tRhx5o0njUJaj/efFXOGbL4 + fvhs/Ajretw5OC3HELZOBCqDCBQwm6orNBMRKAAAAGARIlAZEiNQjcNf62AjGgAAgJ5EoGCbHt9+U64J + QI5q7tKXCBTsVHMEekgLQdlzH09wBXasSeNZk6D26Nbrcs6QQwDqfL4/fFn+O5Ll3tWn5fjB1olAZRCB + AmZTdYVmIgIFAAAALEIEKkNqBOrbg9P3l7uqPzM5bEQDAADQkwgUbE/7jjDpIj1Qq+YvfYlAwU41R6CX + pBCU4Mp4giuwY00az5oEv9fOKFbzhRwt0lWNHV/mfTffwxvPy7GDrROByiACBcym6grNRAQKAAAAWIQI + VIbUCFRz98pP706O3pZ/bjLYiAYAAKAnESjYnvvXnpXrAZClmr/0JQIFO9UcgZ5SQlAufo8nuAI71qTx + rEnwe/YcsvmBgIvzI6z5fJcHNRGoDCJQwGyqrtBMRKAAAACARYhAZUiOQDXf3Xhe/rnJYCMaAACAnlzI + gG358x/+Vq4FQJ5qDtOX7+thp5oj0FtCCEpwZTzBFdixJo1nTYLfczYxmx8IuJz2I6zVvysZ/nrrdTlu + sHUiUBlEoIDZVF2hmYhAAQAAAIsQgcqQHoFqfrz5qvyzM56NaAAAAHoSgYLtaN8JVusAkKmax/QlAgU7 + 1RyBEUaHoARXxhNcgR1r0njWJPi99lm6mi+Md3z4shwzzkfoLNfJ0dtyzGDrRKAyiEABs6m6QjMRgQIA + AAAWIQKVYQ0RqG8PTt9veFZ/fsayEQ0AAEBPIlCwDY9vvxl6WR44v2ou05cIFOxUcwRGGRmCElwZT3AF + dqxJ41mT4PesTZl8P7wsr/NcIivweyJQGaxPwGyqrtBMRKAAAACARYhAZVhDBKrxi0S5bPQAAADQiwgU + zO/k6BcXfGCFqvlMXyJQsFPNERhpVAjKZe/xBFdgx5o0njUJfs8PU2Z6cP3ncry4mLtXfir/nRnv/rVn + 5ZjBlolAZXA3AJhN1RWaiQgUAAAAsAgRqAxriUA1DoRlshENAABALyJQMD/fNcE6VfOZvkSgYKeaIzDa + iBCU/fXxBFdgx5o0njUJPvXtwWk5VxirvV9U48XlfH/4svz3ZqyHN56X4wVbJgKVQQQKmE3VFZqJCBQA + AACwCBGoDGuKQN27+rT8OzCWjWgAAAB6EYGCuf35D38r5z6Qr5rT9CUCBTvVHIEEvUNQgivjCa7AjjVp + PGsSfMp+Q6be4dStaNGzk6O35b854/g+D35PBCqDCBQwm6orNBMRKAAAAGARIlAZ1hSBahwKy3N8+KIc + KwAAAFiaSxkwr+PDl+W8B9ahmtf05dIY7FRzBFL0DEHZWx9PcAV2rEnjWZPgUw+u/1zOFcbx3cZ+Cavk + +eut1+VYwZZZqzKIQAGzqbpCMxGBAgAAABYhApVhbRGoe1efln8Pxvnh5qtyrAAAAGBpIlAwp0cuOsDq + VXObvlyUhJ1qjkCSXiEowZXxBFdgx5o0njUJPiUykefulZ/KsWIZ3x6cvjs5elv+2zOG92b4Pe/PGUSg + gNlUXaGZiEABAAAAixCByrC2CFTjYFgWv0YEAABALyJQMJ/Ht9+8u3NwWs55YD2q+U1fIlCwU80RSNMj + BGVffTyXumHHmjSeNQk+9ePNV+VcYYz2PlGNE8sSV8lTjRNsmXUqgwgUMJuqKzQTESgAAABgESJQGdYY + gbp39Wn5d2GM9utQ1TgBAADA0kSgYC4tALXvi+9AH9Ucpy8RKNip5ggk2ncISnBlPMEV2LEmjWdNgk9Z + l7I8uP5zOU4s69uD0/Lfn3GEVuBTIlAZrE3AbKqu0ExEoAAAAIBFiEBlWGMEqmnhoervwxh3Dk7LcQIA + AIAliUDBPE6OfhGAgolU85y+RKBgp5ojkGqfIShhg/EEV2DHmjSeNQk+1eZENVfor/1YQDVG7If35Czt + R3GrcYKtEoHKIAIFzKbqCs1EBAoAAABYhAhUhrVGoGzyZLHZAwAAQA8iUDCPu1eelPMcWKdqntOXCBTs + VHMEku0rBOVy93iCK7BjTRrPmgSfquYJY/hOo68WHarGgTEeXP+5HCfYKvcDMrgXAMym6grNRAQKAAAA + WIQIVIa1RqC8frL4NSIAAAB6EIGCOTy8/h/lHAfWq5rr9OXCJOxUcwTS7SMEJbgynuAK7FiTxrMmwc63 + B6flPGEMZw/7Ozl6W44F/T288bwcI9gqEagMIlDAbKqu0ExEoAAAAIBFiPhkWGsEqnFALIdfIwIAAKAH + EShYvz//4W/l/AbWrZrv9CUCBTvVHIE1WDoEZT99PMEV2LEmjWdNgp27V56U84T+Ht9+U44R+3V8+KIc + D/prY1GNEWyVCFQGEShgNlVXaCYiUAAAAMAiRKAyrDkCZaMnh18jAgAAoAcRKFg3ASiYVzXn6UsECnaq + OQJrsWQISnBlPMEV2LEmjWdNgh17DTl8nzHGvatPy/GgP3MAPuVuQAYRKGA2VVdoJiJQAAAAwCJEoDKs + OQJlIzrHml9HAAAArIeLGbBeAlAwt2re05cLY7BTzRFYk6VCUIIr4wmuwI41aTxrEuz86dqzcp7Q3/1/ + jkU1RuzXtwen5XjQ3w83X5VjBFslApVBBAqYTdUVmokIFAAAALAIEagMa4/3nBy9Lf9e9OVyCQAAAD2I + QME6CUDB/Kq5T1++p4edao7A2iwRghJcGU9wBXasSeNZk2DnwfWfy3lCf0vET7kY780Z2jhU4wNbJQKV + QQQKmE3VFZqJCBQAAACwCBGoDGuPQNmIzuByCQAAAD2IQMH6CEDBNlTzn758Tw871RyBNbpsCMpe+niC + K7BjTRrPmgQ7AhMZHt9+U44PfRwfvijHhb68P8OnvEdnEIECZlN1hWYiAgUAAAAsQgQqw9ojUDaiM/xw + 81U5PgAAALAkEShYl+PDl+VcBuZTrQH0JQIFO9UcgbW6TAhKcGU8F7phx5o0njUJdgQmMjhzONaD6z+X + 40Jf3p/hU96jM4hAAbOpukIzEYECAAAAFiEClWHtESgb0RnaYb1qfAAAAGBJIlCwHmIksC3VOkBf1l3Y + qeYIrNlFQ1CCK+O50A071qTxrEmw8/03fy/nCX2t/ezq2jnDnaMaH9gqEagMIlDAbKqu0ExEoAAAAIBF + 2EDMsPaN9LtXnpR/L/r6663X5fgAAADAkkSgYB2ESGB7qrWAvqy9sFPNEVi7i4SgBFfGE1yBHWvSeNYk + 2BGBynD/2rNyfOinGhf6q8YGtkoEKoMIFDCbqis0ExEoAAAAYBEiUBnWHoH69uC0/HvRl4NiAAAA9CAC + Bfn+/Ie/lfMXmFu1HtCXCBTsVHMEZnDeEJTgynj20WHHmjSeNQl2frz5qpwn9HXv6tNyfOinvTdUY0Nf + 1djAVolAZRCBAmZTdYVmIgIFAAAALEIEKsPaI1DNydHb8u9GPw6KAQAA0IMIFGQTgILtqtYE+hKBgp1q + jsAszhOCElwZzz467FiTxrMmwY41KYPAxHjmQgZzAXZEoDJYl4DZVF2hmYhAAQAAAIsQgcowQwTKrxGN + 56AYAAAAPYhAQS4BKNi2al2gLxEo2KnmCMzkrCEoF7rHs48OO9ak8axJsGNNylCNDX19/83fy7GhL7EV + 2BGBymBdAmZTdYVmIgIFAAAALEIEKsMMEahHt16Xfzf6OTl6W44NAAAALEkECjIJQAHV2kBfIlCwU80R + mM1ZQlDiBuMJrsCONWk8axLsWJMyVGNDXyJQGcRWYEcEKoN1CZhN1RWaiQgUAAAAsAgRqAwzRKAcyshQ + jQ0AAAAsSQQK8ghAAU21PtCXCBTsVHMEZvS1EJR99PEEV2DHmjSeNQl2rEnjWZMyiK1kEFuBHetSBusS + MJuqKzQTESgAAABgESJQGUSgWEo1NgAAALAkESjI8vD6f5RzFdieao2gLxEo2KnmCMzqSyEo++jjiRvA + jjVpPGsS7FiTxrMmZRBbySC2AjvWpQzWJWA2VVdoJiJQAAAAwCJEoDKIQLGUamwAAABgSSJQkOHk6Jd3 + 964+LecpsE3VWkFfIlCwU80RmNnnQlD20ccTN4Ada9J41iTYsSaNZ03K8N2N5+8e337DYGIrsCMClcG6 + BMym6grNRAQKAAAAWIQIVAYRKJZSjQ0AAAAsSQQKxmsXEu5eeVLOUWC7qvWCvkSgYKeaIzC7KgRlH308 + cQPYsSaNZ02CHWvSeNYkACoiUBlEoIDZVF2hmYhAAQAAAIsQgcogAsVSqrEBAACAJYlAwVgtAPXbi+UA + TbVm0JcIFOxUcwS24LchKPvo44kbwI41aTxrEuxYk8azJgFQEYHKIAIFzKbqCs1EBAoAAABYhAhUBhEo + llKNDQAAACxJBArGeXTr9bs7B6fl3ASo1g36EoGCnWqOwFZ8HIKyjz6euAHsWJPGsybBjjVpPGsSABUR + qAwiUMBsqq7QTESgAAAAgEWIQGWYIQLVLqBVfzf6cSgDAACAHkSgYIzjw5flnAT4oFo76EsECnaqOQJb + 8iEEJW4wnn102LEmjWdNgh1rUoZqbADYNhGoDCJQwGyqrtBMRKAAAACARYhAZZghAtUOKVV/N/pxUAwA + AIAeRKCgvz//4W/lfAT4WLV+0JcIFOxUcwS2pu3f+jGl8eyjw47gynjWJNixJmW4c3Bajg8A2yUClUEE + CphN1RWaiQgUAAAAsAgRqAwzRKCqvxd9OSgGAABADyJQ0M/J0S/vHl7/j3IuAvxWtY7QlwgU7FRzBGAE + ++iwI7gynjUJdqxJGQQmAPgtEagM3qOB2VRdoZmIQAEAAACLEIHKsPYIlNdRBgfFAAAA6EEECvp4fPvN + ++/dqnkIUKnWEvoSgYKdao4AjGAfHXYEV8azJsHO99/8vZwn9HX/2rNyfADYLhGoDCJQwGyqrtBMRKAA + AACARYj3ZFh7BMrlzwztsF41PgAAALAk3wPA/rXvee4cnJZzEOBzqvWEvkSgYKeaIwAjCK7AjgjUeNYk + 2BGByvDg+s/l+ACwXSJQGUSggNlUXaGZiEABAAAAixCByrD2CNR3N56Xfy/6EoECAACgBxEo2K/jw5fl + 3AP4mmpNoS8RKNip5gjACIIrsCMCNZ41CXZEoDIcH74oxweA7RKByiACBcym6grNRAQKAAAAWIQIVIa1 + R6DaQYDq70VfIlAAAAD0IAIF+3Fy9Mu7h9f/o5x3AGdRrS30JQIFO9UcARhBcAV2RKDGsybBjsBEBmcO + Afgt79EZRKCA2VRdoZmIQAEAAACLEIHKsPYIlENiGVwuAQAAoAcRKFjeo1uv339XW805gLOq1hf68j09 + 7FRzBGAEwRXYcb5nPGsS7AhMZDg5eluODwDb5T06gwgUMJuqKzQTESgAAABgESJQGdYcgfr24LT8O9Hf + 8eGLcowAAABgSSJQsKzjw5fv7hyclvMN4DyqNYa+RKBgp5ojACMIrsCOCNR41iTYeXD953Ke0J/IBAAf + E4HK4P0ZmE3VFZqJCBQAAACwCBGoDGuOQLn4mWPNryMAAADWw3cBsIyTo1/ePbz+H+U8A7iIaq2hLxEo + 2KnmCMAIgiuwIwI1njUJdv507Vk5T+jv4Y3n5RgBsE0iUBlEoIDZVF2hmYhAAQAAAIsQgcqw5njP8eGL + 8u9Ef+3X0aoxAgAAgCWJQMHlPbr1+v13s9UcA7ioar2hLxEo2KnmCMAIgiuwIwI1njUJduw15PB9BgAf + E4HKIAIFzKbqCs1EBAoAAABYhAhUhjVHoNrhpOrvRH/3rz0rxwgAAACW5GIGXM7x4ctybgFcVrXm0JdL + k7BTzRGAEQRXYEcEajxrEuw4u5rj5OhtOUYAbJMIVAYRKGA2VVdoJiJQAAAAwCJspGdYawTq7pUn5d+H + Me5dfVqOEwAAACxJBAou5vHtN76/AfaqWnvoSwQKdqo5AjCC4ArsiECNZ02CnW8PTst5whi+uwbgAxGo + DCJQwGyqrtBMRKAAAACARYhAZVhrBKpdZqj+PoxhswcAAIAeRKDg/I4PX767c3BazimApVTrD32JQMFO + NUcARhBcgR0RqPGsSfCpk6O35Vyhv+PDF+UYAbA9IlAZ3AsAZlN1hWYiAgUAAAAsQgQqw1ojUO1gUvX3 + YYxqjAAAAGBpIlBwdo9vv/EL6kA31TpEXyJQsFPNEYARBFdgRwRqPGsSfMr5wxwtyOWHDABoRKAyiEAB + s6m6QjMRgQIAAAAWIQKVYY0RqAfXfy7/LozRDmFU4wQAAABLE4GCszk+fOnSDNBVtRbRlwgU7FRzBGAE + wRXYEYEaz5oEn/rx5qtyrjDGwxvPy3ECYFtEoDKIQAGzqbpCMxGBAgAAABYhApVhjREoB8OytPGoxgkA + AACWJgIFX/b49pt3964+LecPwD5VaxJ9iUDBTjVHAEYQXIEdZ33GsybBp77/5u/lXGEMZxABaESgMohA + AbOpukIzEYECAAAAFiEClWFtESiXPfP8cPNVOVYAAACwNN8LwOf9+Q9/e3fn4LScOwD7Vq1L9CUCBTvV + HAEYQXAFdkSgxrMmwadEJvL4gQMAvD9nEIECZlN1hWYiAgUAAAAsQgQqw9oiUO0SQ/X3YJy1vYYAAABY + LxEo+L12ifLulSflnAHopVqf6EsECnaqOQIwguAK7IhAjWdNgk89uP5zOVcYp71XVGMFwHaIQGUQgQJm + U3WFZiICBQAAACxCBCrDmgI+LnpmagdiqvECAACApfluAHZOjn55992N/yznCkBv1TpFXyJQsFPNEYAR + BFdgRwRqPGsSfKqF9au5wlj3rj4txwuAbRCByiACBcym6grNRAQKAAAAWIQIVIY1RaDaYaTq78BYDl4A + AADQiwgU/Or48OW7Owen5TwBGKFaq+hLBAp2qjkCMILgCuyIQI1nTYJPfXtwWs4VxmrvF9V4AbANIlAZ + RKCA2VRdoZmIQAEAAACLEIHKsJYI1IPrP5d/fsZz4RAAAIBeRKDYunYBpn2vWs0PgJGqNYu+RKBgp5oj + ACMIrsCOCNR41iT4vZOjt+V8Yaz7156V4wXA/ESgMohAAbOpukIzEYECAAAAFiEClWENEaj2WmkHkao/ + P2O1gzDVmAEAAMA+iECxVY9uvX537+rTcl4AJKjWLvoSgYKdao4AjCC4AjsiUONZk+D3rE2Z2nrlhykB + tkkEKoMIFDCbqis0ExEoAAAAYBEiUBnWEIFqFxeqPzvjtYMw1ZgBAADAPohAsTUnR7+8e3D953I+ACSp + 1jD6EoGCnWqOAIwguAI7QivjWZPg944PX5TzhfGOD1+WYwbA3ESgMohAAbOpukIzEYECAAAAFiEClSE9 + AtUuuVV/bjK0gzDVuAEAAMA+iECxFS3+9Oc//M2vnQOrUa1l9CUCBTvVHAEYQXAFdkSgxrMmwe85m5jt + 3tWn5bgBMC8RqAwiUMBsqq7QTESgAAAAgEWIQGVIjkC110g7gFT9ucnQDsJUYwcAAAD7IALF7MSfgLWq + 1jT6EoGCnWqOAIwguAI7IlDjWZPg9+5eeVLOFzK0dct35QDbIgKVQQQKmE3VFZqJCBQAAACwCBGoDMkR + KAGofHev/FSOHQAAAOyDCBSzEn8C1q5a2+hLBAp2qjkCMILgCuyIQI1nTYLf+/bgtJwv5Pjh5qty7ACY + kwhUBhEoYDZVV2gmIlAAAADAIkSgMqRGoI4PX5R/XrJUYwcAAAD7IgLFbMSfgFlUaxx9iUDBTjVHAEYQ + XIEdEajxrElQ80OV+R7eeF6OHQDzEYHKIAIFzKbqCs1EBAoAAABYhAhUhsQIlA2cdWgH9KrxAwAAgH0R + gWIW4k/AbKq1jr5EoGCnmiMAIwiuwI4I1HjWJKh9/83fyzlDlntXn5bjB8Bc3CHIIAIFzKbqCs1EBAoA + AABYhAhUhrQI1Hc3npd/TvIcH74oxxAAAAD2RQSKtWsXHu9fe1a+vgHWrFrz6EsECnaqOQIwguAK7IhA + jWdNgprziutwcvT2/ZnjagwBmIcIVAYRKGA2VVdoJiJQAAAAwCJEoDIkRaAeXP+5/DOSyYVFAAAAehOB + Yq3aRUe/VA7MrFr76EsECnaqOQIwguAK7IhAjWdNgtrdK0/KOUOeto4JQQHMTQQqgwgUMJuqKzQTESgA + AABgESJQGVIiUAJQ6+NABQAAAL2JQLEmJ0e/vPvzH/727s7Bafl6BphJtQ7SlwgU7FRzBGAEwRXYEYEa + z5oEn3dy9LacN+QRggKYmwhUBhEoYDZVV2gmIlAAAADAIkSgMiREoASg1ufx7TflWAIAAMA+iUCxBu1S + 4/1rz8SfgE2p1kP6EoGCnWqOAIwguAI7IlDjWZPg86xR6yIEBTAvEagMIlDAbKqu0ExEoAAAAIBFiEBl + GB2B+u7G8/LPRbYfbr4qxxMAAAD2SQSKVCdHv7z78x/+JvwEbFa1NtKXCBTsVHMEYATBFdgRWBnPmgSf + 5wzj+rQ17e6Vn8rxBGC9RKAyiEABs6m6QjMRgQIAAAAWIQKVYWQEykbNej24/nM5pgAAALBPIlAkaeGn + Fty4d/Vp+XoF2JJqnaQvESjYqeYIwAiCK7AjAjWeNQk+r33HW80bsp0cvX338MbzckwBWCd3CzKIQAGz + qbpCMxGBAgAAABYhApVhRATqzsHpu++/+Xv552Ed2vytxhYAAAD2SQSK0Vr4qV1abIHs9h1X9ToF2KJq + zaQvESjYqeYIwAiCK7AjAjWeNQm+rAWFqrlDvpE/hArAskSgMohAAbOpukIzEYECAAAAFiEClaH3Bvjd + K0/eHyqq/iysw+Pbb8qxBQAAgH0TgWIE4SeAr6vWT/oSgYKdao4AjCC4AjsiUONZk+DLrFPr9ujWaz9s + CTABEagMIlDAbKqu0ExEoAAAAIBFiEBl6BmB+u7Gc7+YNQEXSQAAABhFBIpeWvipfQdy7+pT4SeAM6jW + Uvry3T3sVHMEYATBFdgRVxnPmgRf1s42VnOH9WjrXPsxh2p8AVgHEagMIlDAbKqu0ExEoAAAAIBFiEBl + 6BGBamPtMNc87l97Vo4zAAAA7JsIFPvUvr/68x/+9j78VL3+APi8al2lLxEo2KnmCMAIgiuw49zQeNYk + +DLnWefRviNp41mNMwDZRKAyiEABs6m6QjMRgQIAAAAWYdM8wz4jUHcOTm3GTKiNazXeAAAAsG8iUCzp + 8e03744PX77/ZXDfdwBcTrXO0pcIFOxUcwRgBMEV2BGBGs+aBF/X5kk1f1indnbVd/8A6+LeQQYRKGA2 + VVdoJiJQAAAAwCJEoDLsIwL1If50cvS2/O9kvdqhvGrMAQAAoAcRKC7j4+jTH//lX8vXGAAXU6279CUC + BTvVHAEYQXAFdkSgxrMmwdcdH74o5w/r1da+tidQjTcAeUSgMohAAbOpukIzEYECAAAAFiEClWHJCJT4 + 0/wciAAAAGAkESjO6uTol/eXC1v06U/Xnvm1b4A9q9Zi+hKBgp1qjgCMILgCOyJQ41mT4OvuXX1azh/W + 70MMqp1brsYegAwiUBlEoIDZVF2hmYhAAQAAAIsQgcqwRASqXcBsF+rEn+bnEAQAAAAjiUBReXz7zbsf + b756//1Uu8Txx3/51/L1A8D+VOszfYlAwU41RwBGEFyBHRGo8axJcDbOQM6vfYfS9puq8QdgLBGoDCJQ + wGyqrtBMRKAAAACARYhAZbhoBKptgrf/bLtkV/3fZT7tQF71WgAAAIBeRKC27bexp7tXfnp35+C0fK0A + 0Fe1btOXCBTsVHMEYATBFdgRgRrPmgRnc3z4opxDzKeti4JQAFlEoDKIQAGzqbpCMxGBAgAAABYhApXh + LBGodpmubXR/d+P5ux9uvvJrVxvVLldWrw8AAADoRQRqXidHv7yPPLULge3SRfvOqn0X8adrz9798V/+ + tXw9AJCjWtvpSwQKdqo5AjCC4ArsiECNZ02Cs7l39Wk5h5hbOxPb3qvaGdm2F+UHKADGEIHKIAIFzKbq + Cs1EBAoAAABYhAhUhg+/ZPSn6//+XtvEbhso7f+/BZ/a5bvqP8f2tDlbzWWA3tpBq7YmNX+88uT9+9hZ + tP/dD/85h7UA5vJhfW+q94DP+fi9ofq/C+Rpc7f6zMo6tUsVj279492PN1+9/z6qfS91/9q/vR9nazNw + Hh8/4zFGtc7TV9vTqcaGvu5e+alcp+irmiP01SKv1f8/bI3gSo7z7CmyH49uvS7nCf20NakaG/qr1imy + +JFMmg9hqPady4c9jHbG9sM+xufYgwa4OBGoDCJQwGyqrtBMRKAAAACARbQNzupLYyBPO8xQzWOApbTn + gnYI6kOQ8Pjw5fsgYVt/2oHgFiXcxyG79n+z/d9u/z1N++90+RxgvA/Bv7YWt/eGD6HaD+8Nbe3eV7D2 + 4/eGdqD3w3tD+3N8OLQrJgjjtHlYzV3m1T4PfPys3t4b2lpcvT6AbbLXACRpzy3VWkVf1djQV3t+//Mf + /lb+z2BLRKBytLGoxghghGqdIsvx4Yty7OCivnY+yR40wK/a2lito/QlAgXMpuoKzUQECgAAAFiEixmw + Hg+u/1zOY4DzaIeV2qX9D5GnFtbYV8BjHz5cPm9/9vZ3aH8XB7AALudD6Kmtq+2g64fwX7UOp/ntL7+K + kkAfIlB87ONndOswbJe9BiBJezap1ir6qsaGvtr3PG0shKDYOhGoHCJQQJJqnSLLvatPy7GDfWt70G3v + wx40sFUiUBlEoIDZVF2hmYhAAQAAAItwMQPWQ+QEOK/2Pv+n6//+/jJ2u/jUDilV68sMPkRAPhy+an/3 + 6t8EYMva82Q7nPpx7Gnm94YPB3NFA2F5IlCcRVuH2/vNh3W4ei0B87DXACQRgcpQjQ19fYhANUJQbJkI + VA4RKCBJtU6Rp33PXI0fjGIPGtgCEagMIlDAbKqu0ExEoAAAAIBFuJgB6/DxIW2ASjtU1A4XtUNG7bDR + zFGPs2oHyT8+eFX9uwHMrL03fIgBOiD9qw9BkgfXfxYMhEsQgeKiWpChvS8Jt8J87DUASUSgMlRjQ1+/ + 3V8UgmKrRKByiEABSap1ijwiFKzBx3vQ7UeZqtcywJp4/80gAgXMpuoKzUQECgAAAFiEixmwDveuPi3n + MLBt7fJ923Bvl5pEn76u/Ru1f6sWhXLoCpjRx9Gnx7fflGshn2qXjkSh4PxEoFjKh4sRolCwfvYagCQi + UBmqsaGv30agGiEotkgEKocIFJCkWqfI8+3BaTl+kKw987QfrbMHDayVCFQGEShgNlVXaCYiUAAAAMAi + XMyAfO0CfzV/ge1pcY8WMGoHhUSfLu/j8Ef7t63+zQHSfRwErNY6zqfFSFpEq/27Vv/ewK9EoNgX6zCs + l70GIIkIVIZqbOirikA1QlBsjQhUDhEoIEm1TpHJPihr9+F8kr0PYC1EoDKIQAGzqbpCMxGBAgAAABbh + Ygbka3GSav4C29Deq8U9+mj/xn6FD1iDdji0BTIEAffrw2Hc+9f+rRwH2DIRKHrxjA7rYa8BSCIClaEa + G/r6XASqEYJiS0SgcohAAUmqdYpM964+LccQ1qjt8bcf//ODdUAyEagMIlDAbKqu0ExEoAAAAIBFuJgB + +Vx0hO1ph3yEn8Zy2RxII/w0Vvt3F4SCHREoRnh06/W77248f/fHK0/K1yUwlr0GIIkIVIZqbOjrSxGo + RgiKrRCByiECBSSp1ilyPb79phxHWLsPQajqdQ8wighUBhEoYDZVV2gmIlAAAADAIlzMgGxfO5wNzKOF + n9qFZuGnPB+CUNW4AezT3StP3h+sEn7K0i4qted0ERK2TASK0dpa3OKIoq2Qw14DkEQEKkM1NvR1ln1G + ISi2QAQqhwgUkKRap8glRsHsPvwoUduDq+YAQE/edzOIQAGzqbpCMxGBAgAAABbhYgZkc5kR5tcO77TL + ywIf+T5EP6zNwD6JAq5Le29ooUDvDWyNCBRJHt16/f6901oMY9lrAJKIQGWoxoa+zvpjM0JQzE4EKocI + FJCkWqfI9e3BqXM1bIY9aGA0EagMIlDAbKqu0ExEoAAAAIBFuJgBuVxSgHkJfKxfG7t24KoaX4CLuHvl + iSjgyrWLlX/85zhW4wuzEYEiled0GMdeA5DE/kqGamzo66wRqEYIipmJQOUQgQKSVOsU2QQp2KL2ua7t + y1VzAmBfvOdmEIECZlN1hWYiAgUAAAAswsUMyHXv6tNy3gLr1d532wa5wMc82mH148MXfn0PuLB2YFMU + cC4CJGyBCBTp2mcucT7oy14DkEQEKkM1NvR1nghUIwTFrESgcohAAUmqdYps3x6clmMJW9Ceo+xBA72I + QGUQgQJmU3WFZiICBQAAACzCxQzI9Pj2m3LOAusk8LEN7UKNGBRwFncOTt8f0Hx063W5njCHDwdx23hX + rwNYMxEo1qS937oYAftnrwFIIgKVoRob+jpvBKoRgmJGIlA5RKCAJNU6Rb72jFuNJ2xFe55qcRbnk4B9 + EoHKIAIFzKbqCs1EBAoAAABYhIsZkMnlRJiD+NM2iUEBn9NiQO2g1MnR23L9YE4O4jIjESjWqK3HntVh + f+w1AElEoDJUY0NfF4lANUJQzEYEKocIFJCkWqfId+/q03I8YYvseQD7IgKVQQQKmE3VFZqJCBQAAACw + CBczIM/j22/K+Qqsh/gTjcNWwAfiTzRiUMxEBIq1a8/q7XVcvb6Bi7HXACQRgcpQjQ19XTQC1QhBMRMR + qBwiUECSap1iHZzHgU85nwQsTQQqgwgUMJuqKzQTESgAAABgES5mQJ4H138u5yuQT/yJisNWsF3iT1TE + oJiBCBSzeHTrte9hYCH2GoAkIlAZqrGhr8tEoBohKGYhApVDBApIUq1TrMO9q0/LMYWtcz4JWIoIVAYR + KGA2VVdoJiJQAAAAwCJczIAsj2+/KecqkO3ulSfiT3yVw1awLS0o4UILX9JeH8IjrJUIFLOxJsPl2WsA + kohAZajGhr4uG4FqhKCYgQhUDt+ZA0mqdYr1cEYHau15q8Vb2g9WVXMH4CxEoDKIQAGzqbpCMxGBAgAA + ABbhYgZkceEQ1qUdmDk+fFHOZ/icdkhCDArm1cIoDh1zHsIjrJEIFLOyJsPF2WsAkohAZajGhr6WiEA1 + QlCsnQhUDhEoIEm1TrEe964+LccV+JX9DuAyRKAyiEABs6m6QjMRgQIAAAAW4WIG5Hh8+005T4FMbaP7 + 5OhtOZ/haxy2gvm0z1biT1xGe/2IBLIWIlDMzvM6nJ+9BiCJCFSGamzoa6kIVCMExZqJQOUQgQKSVOsU + 6/LjzVfl2AI77fnr7pWfyjkE8DkiUBlEoIDZVF2hmYhAAQAAAItwMQNyuFwI69AuvDugzFLaa0nwA9bt + zsGpMCCLahc0vTeQTgSKrWjP676vgbOx1wAkEYHKUI0NfS0ZgWqEoFir9tmuek3Tnz1WIEm1TrEuvo+C + s7MHDZyHCFQGEShgNlVXaCYiUAAAAMAibIRDBhcSIF97z/QrguyLw1awTsKA7IvoCOlEoNga6zJ8nb0G + IIk9lwzV2NDX0hGoRgiKNRKByuH7dCBJtU6xPt8fvizHF/i99sNWD288L+cSwMdEoDKIQAGzqbpCMxGB + AgAAABbhYgZkEP6AbN/deP7+IEw1f2EpLpbDetw5OBUGpIsf/vk681mBRCJQbFV7Zr975adyXsDW2WsA + kohAZajGhr72EYFqhKBYGxGoHCJQQJJqnWJ9vj04dZ4Hzqk9k9mDBr5EBCqDCBQwm6orNBMRKAAAAGAR + LmbAePs6gA1cXnufbBeGqrkL+9LeFxy2glzCgPTWXm/tgF31eoRRRKDYOs/s8Hv2GoAkIlAZqrGhr33u + QQpBsSYiUDlEoIAk1TrFOglVwMXYgwY+x3trBhEoYDZVV2gmIlAAAADAIlzMgLFOjn5xaRBCiXwwUjsE + /+D6z+VrExijPbMJAzKSX2QliQgU/KodgL5zcFrOE9gaew1AEhGoDNXY0Ne+f4hGCIq1EIHKIQIFJKnW + Kdbr8e035TgDX2YPGqiIQGUQgQJmU3WFZiICBQAAACzCxQwYqx2OruYmMI7IB0naJR2HrWC8+9eeCQMS + ob0OH954Xr5OoScRKNgRcIVf2WsAkohAZajGhr72HYFqhKBYAxGoHCJQQJJqnWK97l19Wo4zcDYt+FLN + LWCbRKAyiEABs6m6QjMRgQIAAAAW4WIGjNN+gayal8A43914LvJBnHYgvgVoqtcssF93Dk7fHR++KOcm + jPTDzVcigQwlAgW/Z21m6+w1AElEoDJUY0NfPSJQjRAU6USgcohAAUmqdYp184NvcDntWc0+B9CIQGUQ + gQJmU3WFZiICBQAAACzCxQwYp/0CWTUvgf5a5OP7b/5ezlVI4Vf3oK+7V564kEI0kUBGEoGCz/PczlbZ + awCSiEBlqMaGvnpFoBohKJKJQOXwnTuQpFqnWLf2/ZQffoPLaXPo4Y3n5RwDtkMEKoMIFDCbqis0ExEo + AAAAYBEuZsAYPQ9dA18m8sGatNeqX92D/fvuxvNyDkIisRFGEIGCL2vP7eLfbI29BiCJCFSGamzoq/d+ + pBAUqUSgctiTBZJU6xTrZ58XltE+T7YfVazmGTA/EagMIlDAbKqu0ExEoAAAAIBFuJgB/T2+/UbAA0I4 + /MUatV/de3D95/I1DVxOO8T4481X5dyDZI9uvfYZg65EoOBsjg9fuiTBZthrAJKIQGWoxoa+RvwojRAU + iUSgcohAAUmqdYo5tH2zasyB82nPbvagYZtEoDKIQAGzqbpCMxGBAgAAABbhYgb0J9wB47VLuN9/8/dy + jsJatMMW1esbuJi7V564gMKqtdfvvatPy9c3LE0ECs6urc/3rz0r5xLMxF4DkEQEKkM1NvQ1IgLVCEGR + pn0uq16r9Oc7eCBJtU4xh7tXfirHHDi/9kN1D288L+caMC8RqAwiUMBsqq7QTESgAAAAgEW4mAF9jTps + Dey09z4HjJlF+wVLv7oHl/fdjefvDy9W8wzWRiSQHkSg4PyOD1++DxJXcwpmYK8BSCIClaEaG/oauS8p + BEUSEagc9miBJNU6xTzEK2BZ9qBhW7yPZhCBAmZTdYVmIgIFAAAALMLFDOjn8e03Qh0wWLusLvLBbNqB + ee8vcHHHhy/KuQVrJjTCvolAwcW0Z/f2K/TVvIK1s9cAJBGBylCNDX2N/nEaIShSiEDlEIECklTrFHNp + P6pVjT1wMX6oDrZDBCqDCBQwm6orNBMRKAAAAGARLmZAPw+u/1zOQ6CP7248L+cmzKDFzR7+8zVevfaB + WgvktEuh1ZyCGYgEsk8iUHA5fjGbGdlrAJKIQGWoxoa+RkegGiEoEohA5RCBApJU6xRzaUH+auyBi7MH + DdsgApVBBAqYTdUVmokIFAAAALAIFzOgj4RD1rBlx4cvyrkJs3GZHM6mfQ5y2YQtcAiXfRGBgsuzRjMb + ew1AEhGoDNXY0FfK/qQQFKO1z1/Va5P+fC8PJKnWKebjB+Ngee2H6u5fe1bOOWAOIlAZRKCA2VRdoZmI + QAEAAACLcDED9u/x7Tcu9cEgdw5O31/4qeYmzOr48GU5H4Bf3b3y5P2hxGr+wIza6/3B9Z/L+QAXJQIF + y7BGMxN7DUASEagM1djQV9KP1AhBMZIIVA4RKCBJtU4xJ+eGYD/8UB3MSwQqgwgUMJuqKzQTESgAAABg + ES5mwP610EA1/4D9au9xDhKzVY9uvX4fQavmBmxZiywIQLFVDuGyJBEoWFYLuXp+Z+3sNQBJRKAyVGND + X0kRqEYIilFEoHLYuwWSVOsUc2rfW9kjhv2wBw1zEoHKIAIFzKbqCs1EBAoAAABYhIsZsF/tMHM194D9 + EoCCXy81tLlQzRHYIgeUwCFcliMCBcvz/M7a2WsAkohAZajGhr7SIlCNEBQjiEDlsH8LJKnWKeb1p2vP + ytcBcHmJnz2By3HGKoMIFDCbqis0ExEoAAAAYBEuZsD+uGQAY9y98sQv+MF/5yI5/MrhJNg5PnxZzhM4 + DxEo2I/2WfbB9Z/LeQfp7DUASezPZKjGhr5SL+IKQdGbCFQOESggSbVOMbfvD1+WrwXg8h7dev3uzsFp + OfeA9XHOKoMIFDCbqis0ExEoAAAAYBEuZsB+PL79RnQDBmiX0QWg4FNCUGzd8eGLcm7Alv1w85VDuFyK + CBTsVztYXc09SGavAUgiApWhGhv6So1ANUJQ9CQClUMECkhSrVPMr4VqqtcDcHltfjmfBHMQgcogAgXM + puoKzUQECgAAAFiEixmwH3evPCnnHLA/D67/XM5H4L+9j6PdvfJTOXdgZt9/8/dyTgB+jZXLEYGC/Wvx + CpclWBN7DUASEagM1djQV3IEqhGCohcRqBwiUECSap1ifu07LD8uB/vjh+pgDiJQGUSggNlUXaGZiEAB + AAAAi3AxA5bXDixX8w3YHwEo+DohKLZGAAq+TgiKixKBgj5clmBN7DUASUSgMlRjQ1/pEahGCIoeRKBy + iEABSap1im24d/Vp+ZoAlmFvA9ZPBCqDCBQwm6orNBMRKAAAAGARLmbAso4PX5ZzDdif7248L+cj8Hst + BHX/2rNyLsEsWtCmXfas5gDwew7hchEiUNBPe4Z/+M/PvdVchCT2GoAkIlAZqrGhrzVEoBohKPZNBCqH + CBSQpFqn2A5njWC/7EHDuolAZRCBAmZTdYVmIgIFAAAALMLFDFjOo1uvy3kG7I/NZriYB9d/LucUrF0L + QD269Y/ydQ98nkO4nJcIFPTXPv9W8xFS2GsAkohAZajGhr7WEoFqhKDYJxGoHCJQQJJqnWJbvj98Wb42 + gGXYg4b1ci43gwgUMJuqKzQTESgAAABgES5mwDIe335jwxo6s9EMlyMExWwEoOByHMLlPESgYIzjw5fl + nIQE9hqAJCJQGaqxoa81RaAaISj2RQQqhwgUkKRap9iWb9/vL78uXx/AMuxBwzo5m5tBBAqYTdUVmokI + FAAAALAIFzPg8k6OfrFRDZ21eE01H4GzOzl6++7ulZ/KOQZr9OPNV+VrHTi7dtC9BdWqOQYfE4GCcdpa + 7XsoEtlrAJKIQGWoxoa+1haBaoSg2AcRqBwiUECSap1ie9p3Wu3HH6vXCLAMIShYHxGoDCJQwGyqrtBM + RKAAAACARbiYAZd3/9qzcn4B+yEABcsRgmIW33/z9/I1DpyfEBRnIQIFY7kwQSJ7DUASEagM1djQ1xoj + UI0QFEsTgcohAgUkqdYptql9r9XOTlSvE2AZ9jVgXUSgMohAAbOpukIzEYECAAAAFuFiBlxOO4RczS1g + P1p0rZqLwMUJQbF2AlCwPCEovkYECsZrFyY8x5PEXgOQRAQqQzU29LXWCFQjBMWSRKByiEABSap1iu26 + d/Vp+ToBltOeBe1BwzqIQGUQgQJmU3WFZiICBQAAACzCxQy4OAEo6OvulSd+eQ/2xC/usVYOHcH+rPmi + KPsnAgUZ2mfkFkuu5in0Zq8BSCIClaEaG/pa+2d7ISiWIgKVQwQKSFKtU2zbg+s/l68VYDl+jAjWwXms + DCJQwGyqrtBMRKAAAACARbiYARdzfPiynFPAfrT3KwEo2C8hKNbGgSPYP597+BwRKMjy8Mbzcq5CT/Ya + gCQiUBmqsaGvGQLPQlAsQQQqhwgUkKRap8DzJ+yf720gnzNZGUSggNlUXaGZiEABAAAAi3AxA85vhgPT + sCbtvcqBYOijzTW/uMcaOGwE/bT5Vs1Dtk0ECvJYrxnNXgOQxGXCDNXY0Ncse5ou4nNZIlA57PkCSap1 + ChrPn7B/zuBCNueyMohAAbOpukIzEYECAAAAFuFiBpzPo1uvxTGgIwEo6K+911XzEVLcv/asfO0C+/Pw + xvNyPrJdIlCQSQiKkew1AElEoDJUY0NfM12qdRGfyxCBymHfF0hSrVPwwfeHL8vXDbAcexqQSwQqgwgU + MJuqKzQTESgAAABgES5mwNkJQEF/j279o5yPwH75xT1Stc8vJ0dvy9ctsF8twFbNS7ZJBApyuTTBKPYa + gCQiUBmqsaGv2b7nFYLiokSgcohAAUmqdQo+1p6nq9cOsBw/RgSZRKAyiEABs6m6QjMRgQIAAAAW4WIG + nM3j228EoKCz48MX5XwE+nB5nDTts4sLIjBOC7DdvfJTOT/ZHhEoyOZZnhHsNQBJRKAyVGNDXzPG/oWg + uAgRqBy+4weSVOsU/JYQFOzfvatPy/kHjCMClUEECphN1RWaiQgUAAAAsAgXM+DrWgCqzZVqDgH7YRMZ + Mjy4/nM5R6G3FuN0OQTGa/PQZyMaESjIN+OFf7LZawCSiEBlqMaGvmZ9JhSC4rxEoHL4nh9IUq1TUBGC + gv1qP0ZkDxqyOL+bQQQKmE3VFZqJCBQAAACwCBcz4MsEoKC/+9eelfMR6K8dtLp75adyrkJPP958Vb5G + gf4e3Xr9PsxWzVW2QwQK1kEIip7sNQBJRKAyVGNDXzM/DwpBcR4iUDlEoIAk1ToFnyMEBfvVnhPtQUMO + EagMIlDAbKqu0ExEoAAAAIBFuJgBnycABf21OdeiM9WcBMZoB628HzKSg0WQ5/jwZTlf2Q4RKFgPISh6 + sdcAJBGBylCNDX3N/iwoBMVZiUDlEIECklTrFHyJEBTsl+9zIIezWhlEoIDZVF2hmYhAAQAAAItwMQNq + j269FryAztqcc/AXMrX3xWrewr7dv/asfE0C4z288byct2yDCBSsixAUPdhrAJK4NJihGhv62sJzoBAU + ZyEClcNeMJCkWqfga4SgYL/8GBFkEIHKIAIFzKbqCs1EBAoAAABYhIsZ8HstdHHn4LScM8D+/HjzVTkn + gQwOWtGbOCDku3vlp3L+Mj8RKFgfISj2zV4DkEQEKkM1NvS1lWdAISi+RgQqh+/8gSTVOgVnIQQF+/Xg + +s/l3AP6EYHKIAIFzKbqCs1EBAoAAABYhIsZ8Kl2MUAACvqzaQzr4KAVvbTnMZdBIF+bp+17hWoeMzcR + KFin9tm7mtOwBHsNQBIRqAzV2NDXlkKgQlB8iQhUDt/7A0mqdQrOyvMn7M/J0Vt70DCY87wZRKCA2VRd + oZmIQAEAAACLcDEDdrZ0EBqSuEAO6+GgFb0cH74oX4NAHpert8kzPKyXEBT7Yq8BSOJzSoZqbOhra3uf + LuLzOSJQOUSggCTVOgXn4fkT9qc9N/oxVxhHBCqDCBQwm6orNBMRKAAAAGARLmbAr9qhjGqOAPvV3occ + 9oV1cdCKfXtw/efytQfkenjjeTmfmZcIFKybEBT7YK8BSCIClaEaG/ra4g/guIhPRQQqh31hIEm1TsF5 + ef6E/Tk+fFnOO2D/RKAyiEABs6m6QjMRgQIAAAAW4WIGCEDBSD/efFXOSyCbg1bsS/t8cnL0tnzdAdnu + XX1azmvmJAIF6ycExdLsNQBJRKAyVGNDX1uMQDUu4vNbIlA5RKCAJNU6BRfRfuTIHjfsR5tf1bwD9ksE + KoMIFDCbqis0ExEoAAAAYBEuZrBlJ0e/vHt4/T/KuQHsn41iWLf7156VcxsuwwUQWK82f+8cnJZzm/mI + QMEcXJ5gSfYagCQiUBmqsaGvrUagGiEoPiYClcMeAJCkWqfgou5e+end49tvytcacHEtsNa+e67mHbA/ + zvZmEIECZlN1hWYiAgUAAAAswsUMtqodurh75Uk5L4D98/4D6+egFUtzgAjWb8uXS7dGBArmce/q03Ke + w3n5rgdIIgKVoRob+tr653QhKD4QgcohAgUkqdYpuIz2/ZgQFCzP9zzQnzNcGUSggNlUXaGZiEABAAAA + i3Axgy1qhy1EK2AsB3xhDg5asZQW56xeY8D6PLj+cznPmYsIFMyjxV3br9RXcx3Ow14DkMR3VhmqsaEv + sWYhKH4lApXDHjGQpFqn4LK+PTh99+PNV+VrDri4hzeel3MO2A8RqAwiUMBsqq7QTESgAAAAgEW4mMHW + tEMWdw5Oy/kA9GGDGObioBWX1Z7NXPyAebSYiOju/ESgYC7tWczazWXZawCSiEBlqMaGvkSgfiUEhQhU + DnsBQJJqnYKleAaF5flBC+jHGd8MIlDAbKqu0ExEoAAAAIBFuJjBlrTDFdU8APrxvgPzEfvgso4PX5Sv + LWC9XLienwgUzKddxBVO5zJ85wMk8ZkkQzU29CUCteMS/raJQOUQgQKSVOsULOm7G8/fn6eoXn/A+T26 + 9bqca8DyRKAyiEABs6m6QjMRgQIAAAAW4WIGW3By9Mu7+9eelXMA6MvBXpiTi3VclIgIzOvhjeflvGcO + 1m+YkwsUXIa9BiCJ76oyVGNDXyJQnxKC2i4RqBz2ioEk1ToFS2vfmT2+/aZ8DQLn18I01VwDliUClUEE + CphN1RWaiQgUAAAAsAgXM5hdu7zWXufV6x/oy8YwzE3sg4tw4QPm1X7Z+M7BaTn3WT8RKJiXUAAXZa8B + SCIClaEaG/rybPd7QlDbJAKVw54AkKRap2Af2vdmP958Vb4OgfNpe9DOA8P+OeubQQQKmE3VFZqJCBQA + AACwCBczmNnx4UuXjiGE9xuYn9gH5+XAEMzPZdN5iUDB3PySNhfhux8giQhUhmps6Mvn8poQ1PaIQOUQ + gQKSVOsU7JPnUFiG731g/5zpyiACBcym6grNRAQKAAAAWISLGczo5OiXd/evPStf88AYj269LucrMBeX + ijgrn0NgO+5dfVquA6ybCBTM78H1n8v5D5/jGR9I4jJghmps6Mv3tZ/nAv62iEDlEIECklTrFOxb+w7t + 8e035WsSOLuHN56XcwxYhghUBhEoYDZVV2gmIlAAAADAIlzMYDbtYH97XVevd2CMdnG0mq/AnMQ+OAtx + QNiOdrHrzsFpuRawXiJQML+To7e+Y+Nc7DUASUSgMlRjQ18iUF8mBLUdIlA5RKCAJNU6BT18e3D6/lm9 + el0CZ9P2MOxBw/6IQGUQgQJmU3WFZiICBQAAACzCxQxmcXL0y7vvbvxn+ToHxmnvMw7zwra4TMHXiAPC + 9rQDgtV6wHqJQME2CPlxHvYagCQiUBmqsaEvEaivE4LaBvsWOewbA0mqdQp6avvmj2+/KV+fwNcdH74s + 5xZweSJQGUSggNlUXaGZiEABAAAAi3Axgxk8uvX63d0rT8rXODCWX66DbRL74HNaRMAlD9ie9kus7fuH + al1gnUSgYDtENDgrew1AEu9fGaqxoS8RqLMRgpqfCFQO+wNAkmqdgt7ad2rOVsHF3bv6tJxbwOWIQGUQ + gQJmU3WFZiICBQAAACzCxQzW7OTol/eHcqvXNjCe9xjYrhb7aLGfam1g2xwSgu364earcl1gnUSgYFv8 + mjZn4XsgIIkIVIZqbOhLBOrshKDmJgKVQwQKSFKtUzDKg+s/v3t8+035WgU+z3dAsB/Od2UQgQJmU3WF + ZiICBQAAACzCxQzWqm3ettdv9boGMvilOtg2F8X5LZ89AL/EOg8RKNie+9eelesBfOB5H0jiAmCGamzo + SwTqfISg5iUClUMECkhSrVMwUvt+zVkrOD/7F7A8EagMIlDAbKqu0ExEoAAAAIBFuJjB2pwc/fLuuxv/ + Wb6egRztF+qqOQxsy90rP5VrBNvkwCrgIvY8RKBge06O3gqy80X2GoAkPntkqMaGvkSgzk8Iak4iUDlE + oIAk1ToFCdqZq8e335SvW+D32jPmnYPTcj4BFyMClUEECphN1RWaiQgUAAAAsAgXM1iTdlDZZi2sgwO8 + QOPCHR/43AF8cO/q03KdYF1EoGCbHt167bs5PsszP5DEd1IZqrGhLxGoixGCmo8IVA57yECSap2CJJ5L + 4exasKaaR8DFiEBlEIECZlN1hWYiAgXA/8fe3fVocaT5vv4GNbi6XI1wHYIaGbbZLstWY9X3WFIdjIxk + rdJaS7S2BeoDjhhZaqT9pdkOetckmBuogqyIf0ZeB9fJzPS0XZFxPy8Z+XsAAGAVHsxgC9phfQ8Kw3a0 + X6Sr9jKwT17Dadr7uer6APbHQ3dzEIGC/To9fl7OBXCvAUgiApWhWhv6EoH6fB64n4vvo3KIQAFJqjkF + adp3bu19fXUNA4uzk1d+xAJWJAKVQQQKmE3VFZqJCBQAAACwCg9mkOzs5F9vYjLVtQvkcngXeJuH7hAK + Af7M57ztM9th38xxKu41AEl8H5WhWhv6EoH6MkJQ8xCByuE+MpCkmlOQ6uHhxeufv/m9vJaBf2vRmmr/ + ANcnApVBBAqYTdUVmokIFAAAALAKD2aQqMWf2qFav8wD29MeBK32NbBv3371azkz2If24GV1XQD75cG7 + 7ROBgn1rv6jdvleu5gP75V4DkEQEKkO1NvQlAvXlhKDm4LuoHCJQQJJqTkG6di5LDApq7d6FM8ewDhGo + DCJQwGyqrtBMRKAAAACAVXgwgyTiT7B9Du4CFQ/e7ZdICPAh7ZB6NTfYBvMd8B6fP3OvAUjidSpDtTb0 + JQK1DiGo7ROByuFeMpCkmlOwFY+OnopBQaGFa6o9A1yPCFQGEShgNlVXaCYiUAAAAMAqPJhBAvEnmEN7 + kL/a4wDNt1/9Ws4O5tYeuqyuBwAP322bCBTQeJiCt7nXACQRgcpQrQ19iUCtRwhq23wPlUMECkhSzSnY + kvZ9XHufKgYFi7OTV84hwwpEoDKIQAGzqbpCMxGBAgAAAFbhwQxGEn+CuTi0C3yMh+/2RyAE+JQWEa3m + B/nMeOCS2CuX3GsAkvgeKkO1NvQlArUuIajtEoHK4X4ykKSaU7BF7Xu5R0f/EIOC/58fsIAvJwKVQQQK + mE3VFZqJCBQAAACwCg9mMIL4E8ynPcBf7XeAt3lAfF/aA5fVdQBwyQN42yUCBVxqs9x3fDTuNQBJRKAy + VGtDXyJQ6xOC2ibfQeUQgQKSVHMKtq6d3xKDYu/OTl65bwFfSAQqgwgUMJuqKzQTESgAAABgFR7MoKfH + d16+fnT01A1WmJADu8BVeABvP3zOAK5KIHCbRKCAt50ePy9nBfviMwCQxHdQGaq1oS8RqJshBLU9IlA5 + 3FMGklRzCmbRYlB+tIk9awGbam8AVyMClUEECphN1RWaiQgUAAAAsAoPZtBDO1DgwV6YlwfAgeto7z+r + WcJc2gNm1foD/JmHs7fJZwDgz3z3h3sNQBKfMzJUa0NfIlA3RwhqW0SgcohAAUmqOQWzuX/riXv37NLZ + yatyTwBXIwKVQQQKmE3VFZqJCBQAAACwCg9mcFPOTv715vDr3YPz8toD5uGX44DrOD1+Vs4S5uEzBnBd + wiHbIwIF/Fl7kNf3gPvmcwCQRAQqQ7U29CUCdbOEoLZDBCqHCBSQpJpTMKv23d3/9Zf//frnb34v9wPM + 6MHhRbkfgE8TgcogAgXMpuoKzUQECgAAAFiFBzNYUws/tcPEHuCF/fA6AlxX+7U9D4fPzS+JAtf14+0X + 5TwhlwgUUDk9fl7ODPbBd0RAEhGoDNXa0JcI1M0TgtoGEagcIlBAkmpOwR7cv/XkzWcFQShm5/sh+Hwi + UBlEoIDZVF2hmYhAAQAAAKvwYAZraDdL2y9FCTrA/gh9AJ+jHRSpZgpz8BAH8Dl8ntwWESjgQ8Th98u9 + BiCJh/wyVGtDXyJQfQhB5ROByuH+AZCkmlOwNw8PL958bmg//lntE9g69yzg84hAZRCBAmZTdYVmIgIF + AAAArMKDGXyOdtNf+Am498f+d1AX+BweuJhXe39YrTnApwgEbosIFPAh3uvvl3sNQBIRqAzV2tCXCFQ/ + QlDZfE7J4d4ykKSaU7BnglDM6PT4WXm9Ax8nApVBBAqYTdUVmokIFAAAALAKD2ZwVe3m/unx8ze/jCP8 + BDRCH8CX8Gt7c2oPWVbrDfApZyevyrlCJhEo4GOE/fbJvQYgiQhUhmpt6EsEqi8hqFwiUDlEoIAk1ZwC + /q2d52hnRR/feVnuH9iKdg/aeWe4PhGoDCJQwGyqrtBMRKAAAACAVXgwgw9p0ad2SP7R0dPX9289Ka8f + YN8c9AG+hIfx5uOzBfClBAK3QwQK+Jj2UEV7b1jND+bl8wCQxPdOGaq1oS8RqP6EoDKJQOUQgQKSVHMK + eF/73q/9UOBPt1+8/vmb38v9BMm+O3paXtvAh4lAZRCBAmZTdYVmIgIFAAAArMKDGVxq0ad2o170CbgK + rx/Al/Jre/NpD5VVaw1wVR7U3g4RKOBTzPT98V0RkMTrUIZqbehLBGoMIag8IlA5RKCAJNWcAj6tnS29 + jEL5AUG2wPdEcH0iUBlEoIDZVF2hmYhAAQAAAKvwYMY+XQafTo+fv354ePH6b//xn+X1AfAhQh/AGvza + 3lw8vAGsQSBwG0SggKv49qtfyxnCnNxrAJJ4uC9DtTb0JQI1jhBUFhGoHO4jAEmqOQVcX7u3174LbsEQ + YShSuV8B1yMClUEECphN1RWaiQgUAAAAsAoPZszt529+/+/Y06Ojp29uZHqgFliDA7rAGjyQN48WFq3W + GOC6BAK3QQQqQ4t8t+9+mup/D6O17w58F7kf7jUASXznlKFaG/oSgRpLCCqHCFQO95iBJNWcAtZxGYZq + Z1bb2dX2OV0cipFOj5+V1ypQE4HKIAIFzKbqCs1EBAoAAABYhQcztunyIb92Y7xFntoB3nbD5f/6y/9+ + 8wD+3/7jP8v1BliD0AewJr+2N4f2frRaX4Dr8rD2NohAZWjfA1Xr0x6uaN8NtfdZTfu/a98bedCCEdq1 + V12nzMe9BiCJzxUZqrWhLxGo8YSgMohA5RCBApJUcwq4eZf3L9r5s8t7F+0MbPss387EtrOx1Z6FL3F2 + 8qq8HoGaCFQGEShgNlVXaCYiUAAAAMAqPJiRq910bDe2m3ZAt2m/jPTwL//rzcOWzd9u/fJmDf2iPtCT + 0AeXLoOE7Zpoh7Lazf/2WtUeMn9b+5/9+eCWQ1tc8lD49t37471otbbsU3tteDtU2/z5daG5/N+1/7v2 + uiBIwtscZMsnApWhzdNqfa7q/q0n//1L3G12m8XchPYdZ/v+sroGmUv7XPDn93z0V+1D+mqfb6q1oa8H + hxflrKKvao/QV/vepVob+vJZazwRqBwt9lC9dtOPENd47buSam3or5pTQI7LH7y4vJdx6WPvJ6p70M4n + caldP9W1BryvzdJqH9GXszPAbKqu0ExEoAAAAIBViEDN5TLGcRmOajdh2oN8Dw7/55sHNMWigDW0Q4nV + DGJu7VBUe21pryvtUMwarynt/0f7/9Ver4Sh9svDF9vXDlNWa8v82mePFvhr10A7gFtdH9fVDvG2g7vt + /68H5ParvTeorg9yiEBlaPO3Wp8v4T06N0F8APqp9iB9mXmwqPYIfZlJGdpnq2p96Md9CFiYSeOZSQD9 + vX0P2mvhfp0ePyuvD+B9IlAZRKCA2VRdoZmIQAEAAACrEIHanxZvaQ9T/3j7xZub2i3mIRAFXFU7EFPN + FubUDj59//VvXX8Jrf13tQdTWtiw+mdiTj2vMdb30x/vK6t1ZT4tBNJeG1p0pNfnh/aZtf33uc72pV1n + 1fVADhGoDDcRgaq092rifHwp7/mhj2r/0ZfgCiyqPUJfZlIGD5mPJ7gCCzNpPDMJYLx2r7udgWufmfwY + xn60s9PV9QC8TwQqgwgUMJuqKzQTESgAAABgFSJQvK3d5GwHvsShgA9ph1+q+cE82uGmFn5qv4JXXQM9 + XQahqn9O5tIOjlTXAPnu/fFesVpT5tI+I7TPB6M/G7T//hY88ZDKPjjMlk0EKkOvCNTbLuN8ZjHX1a6Z + 6poC1lXtP/oSXIFFtUfoy0zK4PPTeIIrsDCTxjOTAPK477EffrACrkYEKoNzM8Bsqq7QTESgAAAAgFWI + QHEVj++8fP3j7RfCUMCbWFw1J9i+dpipHWpKnPHt/cqjo3+8/vmb38t/drbPYeftar+OWa0pc2ifAVIP + QbZYoVDg3L774/NntfZkEIHKMCIC9bbLIFT73qj654M/83AF3Lxq79GX4Aosqj1CX2ZSBg+Tj+ceBCzM + pPHMJIBc7b6He9BzOz1+Vq498C4RqAwiUMBsqq7QTESgAAAAgFWIQPG52gN+7Yb3g8P/+eY6qq4vYC4e + 9J5TO+i7pQdxW5BQDGpODi1skwOQc2rrupX3+A7izqu9R6nWnAw+G2QYHYF62+U89l6dj2nfJ1bXD7Ce + au/RV3s9rNYG9qjaI/RlJmUQXBlPcAUWZtJ4ZhJAPveg59V+ALNac+BdIlAZnKcEZlN1hWYiAgUAAACs + ot2srL40hutqh5Taje/2AOJWHhgHrsfhlrmcnfwr6qHx63DYak7fHT0t15ts7YBctZ5s09bCgG9rrw3C + I/O5e3BerjfjiUBlSH0/3/65zGQ+ZKufQ2Erqn1HX4IrsKj2CH2ZSRkEV8YTXIGFmTSemQSwHc4nzWmr + ZyKgJxGoDCJQwGyqrtBMRKAAAACAVYhAcVPaL/u3G+DtwdDq2gO2px1GrPY723N6/HyKqILgx1zaofNq + ncklADKPFgZ8cHhRrvPWPDp6Kk42EaGQXF4DMqTvkXaI3oOF/JkHHeFmVfuOvgRXYFHtEfoykzL4XDSe + zyGwMJPGM5MAtsePX8ylxW2qdQYWIlAZRKCA2VRdoZmIQAEAAACrEIGil3aQrN0Mb9dcdS0C2e7f+qXc + 22xLO5A046+Zff/1b+W/L9szQ5xsT06Pn5XryLb8dPvFdHuvfebwIMscPKyaSwQqw1ZCaWJQ/Nl3R0/L + awX4ctWeoy/vYWFR7RH6MpMy+Dw0nuAKLMyk8cwkgG1q96DbZ6xqtrMt7f1QtcbAQgQqgwgUMJuqKzQT + ESgAAABgFSJQjPD4zsvXj46eCkLBhrSHi6v9zHacHj+fOrBz/9YTv7o3gRkjZTNr7+mqdWQbzk7+9cd7 + 8n+UazsLkcDtOzt5Va4t44lAZdhKBOqSGBSX2nwXgIWbUe05+hJcgUW1R+jLTMrgc9B4giuwMJPGM5MA + tq2de63mO9viHgV8nAhUBhEoYDZVV2gmIlAAAADAKkSgGE0QCrbhp9svyj1Mvj1EPi611xJRmm07PX5W + ri157h2cl2vINrRo3l7ef7fgiEjgtrXQY7W2jCUClWFrEahL7Z/bbKYdHq+uD+DLVPuNvgRXYFHtEfoy + kzIIrownuAILM2k8Mwlg+9q9dvc5tu3B4UW5tsC/iUBlEIECZlN1hWYiAgUAAACsQgSKJC3c0R4EFISC + PGcnr8p9S7Z24Oj+rV/KNZ3ZD8fPy78H+Rx63o6HhxflGpKvhR339quWDuFu23dHT8t1ZSwRqAxbjUBd + alFw83m/vPeHm1HtN/oSXIFFtUfoy0zKILgyns8fsDCTxjOTAObQ7kH7obrt8iN18HEiUBlEoIDZVF2h + mYhAAQAAAKsQgSJVO3i29YcZYRYe8N6m9jD1nqN633/9W/l3Id/e4jRb1R4gq9aPbKfHz8v13AOHcLer + fTas1pSxfEbIMMP3Jm0+e1+xX777g/VVe42+BFdgUe0R+jKTMgiujCe4AgszaTwzCWAe9w7O3/wIUzXv + yeb1GD5OBCqDCBQwm6orNBMRKAAAAGAVIlCkazdb2wHlPYdMYLRHR0/L/UmuFrkQ0hGC2ioPgm+DmM72 + tJlYreWetEO4rt3tOTt5Va4nY4lAZZjpfdPDw4s3Idvq35N5ecgC1lftNfoSXIFFtUfoy0zKILgyns8e + sDCTxjOTAObTPntVM59sztbBh4lAZRCBAmZTdYVmIgIFAAAArEIEii1ph9GEIaA/v1i2LQJQ7xKC2p7T + 42flWpKjhXSqtSOXANRCCGqb7t96Uq4n44hAZZjtO5I2o384fl7+uzKvb7/6tbwegM9T7TP6ElyBRbVH + 6MtMyiC4Mp7gCizMpPHMJIA5CUFtz4PDi3ItARGoFCJQwGyqrtBMRKAAAACAVYhAsUXtQFS7ad6u3+q6 + BtZ1dvKq3IvkEYCqCUFty9//uI6rdSSH8Me2CEC9Twhqe747elquJeN4Lcgwayi7RYF+/ub38t+Z+bSH + T6vrAPg81T6jL8EVWFR7hL7MpAyCK+MJrsDCTBrPTAKYlxDUtviROvgwEagMIlDAbKqu0ExEoAAAAIBV + iECxde3G+d9u/VJe38CXu//H/qr2HnkEoD5OCGpbXMvZHPTZDgGoDxOC2hYPreYRgcowawSqad9Zelhi + P1r4q7oOgOur9hh9ee8Ki2qP0JeZlEFwZTzBFViYSeOZSQBzc29jO/xIBXyYs2EZRKCA2VRdoZmIQAEA + AACrEIFiFu2G7MwPP8IoDw8vyj1Hlp+/+f3Na3q1hiyEoLbDQ+DZPCCwDQJQnyYEtR0eiskjApVhD9+D + eA+/Dx60gPVUe4y+BFdgUe0R+jKTMvg+dTzfLcHCTBrPTAKY30+3X5SvAWQ5O3lVrh8gApVCBAqYTdUV + mokIFAAAALAKEShm0w5LiUHBek6Pn5V7jRwCUNfzw/Hz8u9Ilu+OnpbrR4Z2EK5aN3K0Q6XV2vG+9hra + XkurvyNZ7h6cl2vIGCJQGfby/YdZvQ/mPKyj2l/0JbgCi2qP0JeZlEFwZTzBFViYSeOZSQDz82NE23H/ + 1pNyDWHvRKAyiEABs6m6QjMRgQIAAABWIQLFrMSgYB0OgeZ7cHhRrh0f5rrO5+GkXPdv/VKuGTlaJENE + 4Xra52Jxs3zffvVruX6MIQKVYU/fe7RZ7YGJubXD5NXaA9dT7S/68p0GLKo9Ql9mUgb3JMYTXIGFmTSe + mQSwD37gYhucMYaaCFQGEShgNlVXaCYiUAAAAMAqRKCYnRgUfBlBhGzff/1buW58XPvFPQetsjn8nOvh + 4UW5ZmQ4O/nXm8941drxca7tfN8dPS3XjjFEoDLs8fuOH46fl38Ltq99/yBkCV+u2l/0JbgCi2qP0JeZ + lEFwZTz3HGBhJo1nJgHsx/1bT8rXAnKcHj8r1w72TgQqgwgUMJuqKzQTESgAAABgFSJQ7IUYFFzf/Vu/ + lPuJDO2AbrVuXI2DVvk8AJ7JIZ9sj47+Ua4bVyMsks2Dq1lEoDLs9XuOFsOt/h5sn+AffLlqb9GX962w + qPYIfZlJGQRXxhNcgYWZNJ6ZBLAvj46elq8HZHD+DmrOh2UQgQJmU3WFZiICBQAAAKxCBIq9EYOCq3t4 + eFHuI8b7+Zvf37yGV+vG1Tlola2Fuqp1Y6yfbr8o14vxPNS3jsd3XpZ/X8b7+x9rU60ZY4hAZdjz9xvt + 3736m7BtHraAL1ftLfry2QwW1R6hLzMpg+DKeIIrsDCTxjOTAPbH62+us5NX5ZrB3olAZRCBAmZTdYVm + IgIFAAAArEIEir1qN9YFVODj3MjNJWa3HgetcrnOMwnkZBIHXI/PyLkcwM0iApVh7++XWjS0zYbqb8N2 + ffvVr+V6A1dT7Sv6ElyBRbVH6MtMyuA+xHiCK7Awk8YzkwD2p92Ddj8jl8gKvM/Z4QzmEzCbqis0ExEo + AAAAYBUecGXv2uFnD8xD7afbL8p9w1gtwFKtF5/HQatcp8fPyjVjrGqtGE80bV0Os+VywC2HCFQG8//f + 7+dbDLH6+7BNPgfAl6n2FX0JrsCi2iP0ZSZlEFwZT3AFFmbSeGYSwD49Onpavi4w3oPDi3LNYM+cm8ng + jAwwm6orNBMRKAAAAGAVIlDw/76Jf7QbVtUegT1zADSTcN36HFrI5AGlPPdv/VKuFWO18EW1Xny+ewfn + giKhHMDNIQKVQQTq34Sg5tK+p7v7x2txtdbAp1X7ir58nwGLao/Ql5mUwf228QRXYGEmjWcmAeyX1+FM + 3x09LdcL9sx5ygwiUMBsqq7QTESgAAAAgFWIQMGiHbTyACUs2oOX1V5hHA9s3IwW+3C953EAOs/Dw4ty + rRjr269+LdeLL9P+rtXfm7EcwM0hApXBdxgLIai5mPfw+ao9RV++v4NFtUfoy0zK4EHv8dxvgIWZNJ6Z + BLBf7kFnOj1+Vq4X7JkIVAYRKGA2VVdoJiJQAAAAwCpEoOB97UB02xvVnoG9aFGcan8wltl0c9oD9NXf + nHFamKtaK8ZxwCdPe1ijWivW4WGYPB5ezSEClUEE6l1CUPPwHgc+X7Wn6Mt7VlhUe4S+zKQMvmMaT3AF + FmbSeGYSwL61z2nV6wPj/Hj7RblWsGfOiGUQgQJmU3WFZiICBQAAAKxCBAo+rN3EqvYN7IGHuvN4WOPm + eWA8j4MMWdqvH1brxDjtl0KrtWIdfok1jwO4OXxeyCAC9T4hqHncPTgv1xj4uGo/0Zfv8GBR7RH6MpMy + CK6MJ7gCCzNpPDMJYN+c2c7jtRneJwKVwdlJYDZVV2gmIlAAAADAKtxQhI9rN3jbPqn2D8zs4eFFuScY + xyy6eY+OnpZ/e8a5f+tJuVaM4cGALG09qnViXa77LA7g5hCByiACVROCmoM4O3yeaj/Rl+AKLKo9Ql9m + UgbfL43nOyVYmEnjmUkA/HT7RfkawTjVOsGeiUBlEIECZlN1hWYiAgUAAACsQgQKrqbd0Lp7cF7uI5iR + m7hZfrz9olwn1nXvjzl/dvKqXAPGEDbI8vjOy3KdGMP+6OPbr34t//6M0V6nq3WiPxGoDF4LPkwIavse + 3/mvcm2Bj6v2E30JrsCi2iP0ZSZlEFwZT3AFFmbSeGYSAO5B5xFagXc5P5zBbAJmU3WFZiICBQAAAKxC + BAqurh3Eajfgq70Eszk9flbuA8Z4cHhRrhPrc4Ahy3dHT8t1YoxqjRijRS2qNeJmCARmccgtgwhUBhGo + j2vfe5rh2+Z7OLi+ai/Rl+AKLKo9Ql9mUgbBlfEEV2BhJo1nJgHQeE3Ocv/Wk3KdYK+coczgfAwwm6or + NBMRKAAAAGAVIlBwfe3mVrWfYCYOmuQQ+ujr/q1fynVgjBakq9aJ/u4dnJdrxBge4OvL4bYsDuBmEIHK + IAL1aW1mCEFtl+/g4PqqvURfPq/Botoj9GUmZXDPbTzBFViYSeOZSQA0j46elq8TjOGeG7zLOZkMIlDA + bKqu0ExEoAAAAIBViEDB52mHstr+qfYVzMDhzxwe0ujP9Z/D9Z9DIC2LCE5frv8sDw4vynWiLxGoDA6k + X037O1V/P/J5KBKur9pL9OW7DFhUe4S+zKQM7jmM57MFLMyk8cwkAJr2Q1x+xCLHd0dPy3WCvRKByiAC + Bcym6grNRAQKAAAAWIUIFHyZdqOr2luwde3gYXXN09+3X/1arhE3x6/t5WgH0as1oj+xjxw/f/N7uUbc + rMd3XpbrQX+iNxm8LmSwH67u+69/K/+G5POZGK6n2kf0JbgCi2qP0JeZlEFwZTzBFViYSeOZSQBc8rqc + wzlgeJcIVAYRKGA2VVdoJiJQAAAAwCpEoODLtQfC216q9hhsVXWt01/7xbdqfbhZ3h/lcAg6R4tMVGtE + fx7eG8MBtxwO4GYQgcogAnU9Pxw/L/+OZDP34XqqfURfPrPBotoj9GUmZfBg93juNcDCTBrPTALgkh+p + y+HzM7zLGZkMIlDAbKqu0ExEoAAAAIBViBzAOtohLQ9fMot7B+fldU5/P95+Ua4RN6/N9WpN6EsILYfD + hzkeHF6Ua8TN+varX8v1oL/T42flGtGXCFQG30NcXwt5V39Lcv39jzWr1hKoVfuIvjwwBotqj9CXmZRB + cGU8wRVYmEnjmUkAXHJ+O4czevAuEagMIlDAbKqu0ExEoAAAAIBVuIkI6zo9fl7uNdgSrw05vjt6Wq4R + N68FJqo1ob9qfejP4Z4cdw/OyzXi5rUwXbUm9OUB1gwiUBlEoK6vfd79+Zvfy78nuRxwhqur9hB9eb8K + i2qP0JeZlEFwZTzBFViYSeOZSQC8zY/UZWjvkar1gb1yTiyDe6TAbKqu0ExEoAAAAIBVCH3A+tqN+ba3 + qj0HW+CB7hzffvVruUbcvPZAfbUm9OcwQwZhtAx/v/OyXB/68HBMBr/CmsFnhgwiUJ+nfc6q/p7kEkiG + q6v2EH0JrsCi2iP0ZSZl8J3SeIIrsDCTxjOTAHjbD3/9Z/l6QV9en+FdIlAZnJsEZlN1hWYiAgUAAACs + QgQKbka7KexhTLbKA905qvWhD++RcjjMkMHBwwziN2OJoWXwK6wZfGbI4HuHz/fo6Gn5NyWT2Q9XV+0h + +hJcgUW1R+jLTMoguDKeB7phYSaNZyYB8Db3KzJ4fYZ3iUBlcG4SmE3VFZqJCBQAAACwCoEDuFntRli1 + 9yDZw8OL8nqmr7/feVmuD/2cnbwq14a+7t96Uq4PfXkoIMN3R0/L9aGPFlup1oW+HMDNIAKVQQTqy3h/ + sy13D87LdQTeVe0f+hJcgUW1R+jLTMrgs8d4vk+ChZk0npkEwNvu3/qlfL2gr3ZGrFof2CsRqAwiUMBs + qq7QTESgAAAAgFWIQMHNa4fo2l6r9iAkEjjI8OPtF+X60M/jOy/LtaGvb7/6tVwf+vJQQAb7YSwHcDN4 + QCaDCFQGEagvc+/g/PXP3/xe/m3J8+DwolxH4F3V/qEvwRVYVHuEvsykDL5bHc/3SbAwk8YzkwB4W7tX + Ub1e0F+1PrBXIlAZRKCA2VRdoZmIQAEAAACrEIGCPtohLiEotkIEKkO7kV6tD/388Nd/lmtDX6I3GTwU + kOH+rSfl+tCHA7gZPCCTQQQqgwjUl2vvNau/LXlOj5+Vawi8q9o/9CW4Aotqj9CXmZTBd6vj+T4JFmbS + eGYSAH92dvKqfM2gr2ptYK9EoDKIQAGzqbpCMxGBAgAAAFYhAgX9tJv1Dw4vyr0ISdzAzfDd0dNyfein + PWRcrQ19iRtkeHznZbk+9FWtDX05gJuhWhv6EoHK4H3SOn44fl7+fcniAUm4mmr/0JfgCiyqPUJfZlIG + wZXxfJ6AhZk0npkEwJ85j5FBbAUWzhBnMJeA2VRdoZmIQAEAAACrEIGC/trNsWo/Qgo3cDOIxo336Ohp + uTb0JW6QoR1Ir9aHflp8qFob+rIXMlRrQ18iUBm8T1rHvYPz1z9/83v5NyaLg87wadXeoS/BFVhUe4S+ + zKQMgivjCa7Awkwaz0wC4M9+uv2ifM2gL/cgYOEMcQZzCZhN1RWaiQgUAAAAsAoRKBjj9Ph5uSchgRu4 + Gb796tdyfeinPVRfrQ19iRtkEL4Zz0MBGTwgk6FaG/oSgcrgfdJ62uev6m9Mlu+OnpbrByyqvUNfgiuw + qPYIfZlJGXyfNJ7vVmFhJo1nJgHwZz/89Z/lawZ9ia3AwhniDOYSMJuqKzQTESgAAABgFSJQMM7jOy/f + 7MFqb8JIbuBmuH/rSbk+9PPw8KJcG/oSN8ggAjVeezCjWhv6cgA3Q7U29CUClcH7pHX5pe18IgbwadXe + oS+zChbVHqEvMymD4Mp4giuwMJPGM5MA+LPT42flawZ9ia3AwhniDOYSMJuqKzQTESgAAABgFSJQMFY7 + 3CUERRo3cDO4gTueuEEGcYMMIlDjiUBlEIHKUK0NfXmflMH7pHW172fOTl6Vf2sytPWp1g5YVHuHvgRX + YFHtEfoykzIIrownuAILM2k8MwmAP3NWL4OzerAwlzKYS8Bsqq7QTESgAAAAgFWIQMF4QlCkcQM3gxu4 + 44kbZBA3yCACNZ4IVAYRqAzV2tCX90kZvE9an8/D+XxWho+r9g19Ca7Aotoj9GUmZRBcGU9wBRZm0nhm + EgB/5t5EBvcfYGEuZTCXgNlUXaGZiEABAAAAqxCBggxnJ69ePzi8KPcp9OYGbgY3cMcTN8ggbpBBBGo8 + EagMIlAZqrWhL++TMniftL57B+evf/7m9/LvTQbXPXxctW/oS3AFFtUeoS8zKYPgyniCK7Awk8Yzk2Bx + evz8zVxinB9vvyjXhr6c1cvgrB4szKUM5hIwm6orNBMRKAAAAGAVIlCQ5bujp+VehZ7cwM3gBu544gYZ + POSdQQRqvHYIt1ob+hKBylCtDX15n5TB+6Sb8fDwovx7k0HIAD6u2jf0ZU7Botoj9GUmZWjf61XrQz+C + K7Awk8Yzk2BhJo1nJmVwVi+Ds3qwMJcymEvAbKqu0ExEoAAAAIBViEBBnnbzrNqv0IsbuBncwB1P3CCD + uEEGEajxRKAyiEBlqNaGvrxPyuB90s3x8FEuDyXBx1X7hr4EV2BR7RH6MpMy+Hwxns8RsDCTxjOTYGEm + jWcmZXBWL4OzerAwlzKYS8Bsqq7QTESgAAAAgFWIQEEmIShGcgM3w/1bT8r1oZ+Hhxfl2tCXuEEGEajx + HMDN4DB6hmpt6EsEKoP3STfn269+Lf/mZLh7cF6uGyC4kkBwBRbVHqEvMymD75PG890qLMyk8cwkWJhJ + Gaq1oS8/RJRBbAUWzhBnMJeA2VRdoZmIQAEAAACrEIGCXEJQjOIGboYHhxfl+tBPe6i+Whv6EjfIIAI1 + nocCMjiMnqFaG/oSgcrgfdLNMvNz+bwMH1btGfoSXIFFtUfoy0zK4LPFeL5bhYWZNJ6ZBAszKUO1NvT1 + 0+0X5drQl9gKLJwhzmAuAbOpukIzEYECAAAAViECBdmEoBjBDdwMHugez17IYC9kEIHKUK0NfdkLGaq1 + oS8RqAzeJ92sb7/6tfy7M57vy+DDqj1DX4IrsKj2CH2ZSRnEDcYTXIGFmTSemQQLMymDwMR49kIGewEW + zk1mMJeA2VRdoZmIQAEAAACrEIGCfA5o01t7kLi6FunLQ63j/fDXf5ZrQ1/t4ftqfejr8Z2X5frQl8M9 + 41XrQl9nJ6/KtaEvEagMIlA3z4MXmX68/aJcL8D71QS+z4dFtUfoy0zK4HPFeIIrsDCTxjOTYOFMRob7 + t56U60M/zmNkqNYG9koEKoNzYsBsqq7QTESgAAAAgFWIQME2OKRNTyJQGez78RyCziAClcF+yOAA7lg+ + P2fwgEwGEagMIlA3r70Xrf72jCUICB9W7Rn68p0eLKo9Ql9mUgbfrY7n+yRYmEnjmUmwEIHK4F7DeNW6 + 0F+1NrBXIlAZRKCA2VRdoZmIQAEAAACr8BArbIeD2vQiApWhHcCt1od+2oPF1drQlwhUBg8FZHAAdyzR + mwwekMlgP2TwutDHz9/8Xv79GevuwXm5XrB31X6hL9/jw6LaI/RlJmXw3ep4vk+ChZk0npkECxGoDC30 + Ua0Pfdy/9Uu5LvRXrQ/slQhUBhEoYDZVV2gmIlAAAADAKkSgYFsc1qYHD3RnaAGian3o497Bebku9Ocw + QwYHcDOcHj8r14c+Hh09LdeFvoQyM/jMkEEEqg+HnDM9OLwo1wv2rtov9OU7fFhUe4S+zKQMgivjCa7A + wkwaz0yChe9eM/jcMNbDw4tyXejL6zO8y2t0BucmgdlUXaGZiEABAAAAqxCBgu1x8IKb5oHuHG7ijmMf + 5LAPMohAZRC/Geun2y/KdaEv+yCD90oZRKD6aIHYFumt1oBxvjt6Wq4X7F21X+jL9/ewqPYIfZlJGQRX + xvNANyzMpPHMJFgITGQwl8ZqPwRVrQt92QfwLq/RGZybBGZTdYVmIgIFAAAArEIECrap3WCr9jSswWtD + Dg91j+MgQ45qfejPnsjQAhTV+tBHO/hZrQt9/Xj7Rbk+9CUClcHnhX48hJFH0ABq1X6hL/MJFtUeoS8z + KYPgynge6IaFmTSemQSL9h13tU/o7+7BeblG3DyvzRnaOlTrA3vlnFgGEShgNlVXaCYiUAAAAMAqhD5g + u4SguCleG3K0B42rNeLmOWSVo1of+nO4J8f9W0/KNeJmeX+UwwOsGUSgMohA9fPtV7+Wa8A4f7/zslwr + 2Ltqv9CX96uwqPYIfZlJGdxvGE9wBRZm0nhmEixEoHI8OLwo14ibV60H/YlAwbucE8sgAgXMpuoKzUQE + CgAAAFiFB1lh24SguCnV9UZ/Hmod497Bebke9OcQdA4HcHN8d/S0XCNulj2Qw2egDCJQGUSg+nr8x+ez + ah0Y4+zkVblOsHfVfqEvwRVYVHuEvsykDIIr47nXAAszaTwzCRbuNeTwI3Vj2AM5fH6Gd4lAZRCBAmZT + dYVmIgIFAAAArEIECrbPQ9DchPYwZXW90d/dg/Nyjbg5Dw8vyrWgP7+0l8O+yGFfjPHT7RfletCfEFoG + h9IziED15bBzHgef4X3VXqEvD4zBotoj9GUmZRBcGU9wBRZm0nhmEiycXc1hNo3RPrNV60F/QmjwLvdF + M7gXCsym6grNRAQKAAAAWIUb6TAHD36ytna4p7rW6E/ooD+HrHKI3eS4f+uXco0YQyCwv2odGOPB4UW5 + RvQlApXBdwF9+R41j9cEeF+1V+hLcAUW1R6hLzMpg+DKeKIGsDCTxjOTYOE71yzffvVruU7cHOfzcvgh + VniXCFQGEShgNlVXaCYiUAAAAMAq3EiHeXjwjTU5/JlDBKe/s5NX5VrQn4eUcvjckEUgsK8WWanWgTEc + QM8gApVBBKo/n5WzeE8E76v2Cn35LgMW1R6hLzMpg88R4wmuwMJMGs9MgndV+4QxRHD6cq8ti3tu8C4R + qAwiUMBsqq7QTESgAAAAgFV4mBvm0aIl9289Kfc6XNcPf/1neZ0xxt2D83KdWJ/QRxaHDLNUa8QYAoF9 + eSgmi0NuGRxMz+BAen8OPGcRNYD3VXuFvswmWFR7hL7MpAy+WxpPcAUWZtJ4ZhK8q+2Jaq/Qn/nUV/u8 + Vq0DY/ghIniXe6IZnI8BZlN1hWYiAgUAAACsQgQK5tIOY7R9Xe13uA43cbMI4fTj4HMWYYMsDuBmEQjs + w2fmPNU60Z8IVAbvlfrzupDlx9svynWCPav2Cn0JrsCi2iP0ZSZlcN9hPEEDWJhJ45lJ8K7Hd16We4Ux + hHD6uHdw7vxFGD++Cu9yfjiDCBQwm6orNBMRKAAAAGAVHlyC+QhBsYb2MHF1fTHG2cmrcp1Yl/dFeRww + zOIAbhaBwD78AmsW74lyiEBlEIEaw4MZOTw0Ce+r9gp9Ca7Aotoj9GUmZRBcGc9nB1iYSeOZSfCuH/76 + z3KvMIbwfh/O5eWp1gn2TAQqgwgUMJuqKzQTESgAAABgFWIHMKcWabh7cF7ue7iKh4cX5bXFOA/+WJNq + rViP0Ecev7SXxQHcLC2G4/3ezWqfl4U+srQHlKq1oj8RqAwiUGOcHj8r14MxqjWCPav2CX0JrsCi2iP0 + ZSZlEFwZT3AFFmbSeGYSvMv3rXncg7557kFn8UNE8D4RqAwiUMBsqq7QTESgAAAAgFWIQMG8HOzmS3h9 + yCN6cLNc85mqtWIcB3zytDWp1op1uObz+PXhHCJQGUSgxvj2q1/L9WAMh5/hXdU+oS/fy8Oi2iP0ZSZl + EFwZT3AFFmbSeGYSvKt9z13tFcZxD/pmuebzOJMH73NeJoP7oMBsqq7QTESgAAAAgFUIHsDcHMrgS1TX + FGO1h42rteLLtYdhqr854zgAncdhxDztFyn9EuvNaJ+V/QJrHp9vcohAZRCBGuPeH6+91Xowhs/J8K5q + n9CX4Aosqj1CX2ZSBsGV8dxvgIWZNJ6ZBO96eHhR7hXGcQ/6ZrkHnccPEcH7RKAyiEABs6m6QjMRgQIA + AABWIQIF8/NQKJ/LoZM8j++8LNeKL+P9UCa/tJfn/q1fyrViLFGcm+FAW6YHhxfletGfCFQGn/fH8cBk + DvsA3lXtE/oSXIFFtUfoy0zK4PPDeIIrsDCTxjOT4F3Oa2Q6PX5erhdfxg9vZXLmAt7nzEwGEShgNlVX + aCYiUAAAAMAq3ESH+bVf57p/60k5A+Bjfrr9orymGOu7o6flevH5XOuZTo+flevFOPcOzsu1Yiy/xLo+ + n5NzffvVr+Wa0Z8IVAbxm3Hae9VqTejPZ2R4V7VP6EtwBRbVHqEvMymD4Mp4giuwMJPGM5Pgfe1+Z7Vf + GKvdM63Wi8/T/p5+kDGTHyKC94lAZRCBAmZTdYVmIgIFAAAArMLDrbAP7QCBgxlcl4daM4l9rMuv7OXy + MHcmB3Az+SXWdbUHJKu/M+N5D5RDBCqDCNQ4Dw8vyjWhP/FYeFe1T+hLcAUW1R6hLzMpg+DKeIIrsDCT + xjOT4H2P77ws9wtjtdeMar34PO5B5/IDq/A+EagMIlDAbKqu0ExEoAAAAIBViEDBfjiYwXWJ4+QS+1iH + X9nL9u1Xv5brxlgeDshlz6zD+59cf7/zslwzxhCByiACNc69g/NyTehP2ADeVe0T+jKXYFHtEfoykzL4 + TnU8wRVYmEnjmUnwvh/++s9yvzCeH+9ah/tq2ao1g70TgcogAgXMpuoKzUQECgAAAFiFCBTsi3AM13H/ + 1i/ldUQGsY8v51f2st09OC/XjbFOj5+V68V47aEB++bLiANmE7XN4rB6BhGosbxmZPD6AO+q9gl9Ca7A + otoj9GUmZRBcGU9wBRZm0nhmErzv0dHTcr8w3tnJqzf3UKt142raPXz3E3L5ISKoiUBlEIECZlN1hWYi + AgUAAACsQgQK9sdDolzVvYPz8hoiQzsgJPbx+RwizNYOElbrxnjtfUS1ZmQQ/PwyHn7J1g4ZVuvGGCJQ + GXy+H+un2y/KdaEvD07Cu6p9Ql+CK7Co9gh9mUkZfOc0ns8NsDCTxjOT4H0PDy/K/UKG9tpRrRtX4wfq + sv14+0W5brB3IlAZRKCA2VRdoZmIQAEAAACrEIGC/fELXVyHXyLL5iDK52kzsM3C6m9KBocIc92/9Uu5 + ZuR4cHhRrh0f5wBbPtd2FhGoDCJQY50ePyvXhb4EZOFd1T6hL8EVWFR7hL7MpAyCK+MJrsDCTBrPTIL3 + +ZG6fN8dPS3Xjo/zA3X5XNtQc4YmgwgUMJuqKzQTESgAAABgFSJQsE/tUNndg/NyLsDbfvjrP8triBwO + o1xPe+8jbpavHSSp1o/xHMDNJ/h5fS0uVP0tyXL/1pNy/RhDBCqDCNRY7e9frQv9VesDe1XtEfoSXIFF + tUfoy0zKILgynuAKLMyk8cwkqDnHkc+9uuvxA1vb8O1Xv5brB3snApVBBAqYTdUVmokIFAAAALAKESjY + r9Pj5+VcgLf5RbJtcCDl6h7f+a/yb0iWFmSp1o8Mj++8LNeNHIKfV9c+E7dwVvV3JEdbo2r9GEcEKoMI + 1Fge4MjhADQsqj1CX4IrsKj2CH2ZSRkEV8YTXIGFmTSemQS1n26/KPcMOdr88mNEV+MH6rbDuQqoiUBl + cA8UmE3VFZqJCBQAAACwChEo2Lfvjp6WswEutbhQde2QpYURHLT6tNPjZ+Xfjzyu52w//PWf5bqRpT3I + Ua0fC4dvt8P1nEcEKoMI1Fj3Ds7LdaE/B6BhUe0R+hJcgUW1R+jLTMoguDKe4AoszKTxzCSo+ZG6bWg/ + GCWa83Ht7+Me9Db8/Y/ruVpDQAQqhXugwGyqrtBMRKAAAACAVYhAwb4Jx/ApHmrdjnaAyH7+MAcTtuPn + b34v15AcLThRrR15To+fl2uIANTWtNfxah0ZRwQqgwjUeF5LMrSAdbU+sEfVHqEvwRVYVHuEvsykDIIr + 4wmuwMJMGs9MgpofqdsOP97yYS0A9fjOf5V/N/L8ePtFuY6As5YpRKCA2VRdoZmIQAEAAACrEIEC2i90 + VfMBLjkIuh1CUDWHErbFIat8PkNsi3jO+wSgtkfcI48IVAYRqPHadyrV2tDXg8OLcn1gj6o9Ql+CK7Co + 9gh9mUkZ3GcbT3AFFmbSeGYS1PxI3bb4rPE+AajtcZ8NPsx5ywwiUMBsqq7QTESgAAAAgFV4gBtoTo+f + lzMCmtPjZ+V1QyYhqHc5kLA93x09LdeSLGcnr8r1I5MQ1EIAapvaoelqPRlHBCqDw+nj/fDXf5ZrQ1/2 + AiyqPUJfHoKERbVH6MtMyiC4Mp7gCizMpPHMJPgw0f1t8XljIQC1TfdvPSnXE3DmMoUIFDCbqis0ExEo + AAAAYBUiUMClb7/6tZwT8PDworxmyCUE9W8OI2yTQ1bb8NPtF+X6kUv0UwBqq/5+52W5nowlApVB+GY8 + 0eQM9gIsqj1CXx6AhEW1R+jLTMoguDKe4AoszKTxzCT4MN+3bk97Xdn7j7kIQG1T++Gzaj2Bf3PuMoMI + FDCbqis0ExEoAAAAYBUiUMCldtBs74cyqN3747qorhmytT2915hOm2U//PWf5d+FbA5Zbcejo6flGpKt + HcLdayRQAGq72oH/ak0ZSwQqg/DNeN4TZfjuj3Wo1gf2qNoj9CW4Aotqj9CXmZRBcGU8wRVYmEnjmUnw + YX6kbpvaXHMPuv7bkOvH2y/KNQX+TQQqgwgUMJuqKzQTESgAAABgFSJQwNtOj5+XswIe33lZXjPkazfk + qzWdVXtv4xf2tsshq+24f+uXcg3Jt8dDuA8OL95E5qq/B/na+lXrylgiUBlEoMZra1CtDX3t7XMvfEy1 + R+hLcAUW1R6hLzMpg+DKeIIrsDCTxjOT4MP8SN12tdm2tx+qa2cmBKC2y49LwMeJQGUQgQJmU3WFZiIC + BQAAAKxCBAr4s2+/+rWcF+zb6fGz8nphG9qDHncPzsu1nUmLEThgtW1CBtsiqrNdbe32cqjRe5jt28N7 + mC0SgcrgvdN49kIGEShYVHuEvgRXYFHtEfoykzIIrownuAILM2k8Mwk+zpzatr18V/vo6Gn578927C1a + BtclApVBBAqYTdUVmokIFAAAALAKESjgz9qBMw9a82ctDlZdL2xH29vtdb9a3xmIfMxh5mt0Rj/89Z/l + OrId7UHAWfdd+/dySHz72hpW68t4wjcZRKDGa7/0Xa0NfbXPg9X6wB5Ve4S+BFdgUe0R+jKTMviOajzB + FViYSeOZSfBxohPb115rZr0H3c5U/nT7RfnvzXb8/M3v5foCC6/HGUSggNlUXaGZiEABAAAAq2g3W6sv + jYF9Oz1+Xs4M9uvewfnrs5NX5fXCtrT9PVPorT10/fjOf5X/rmyLQ1bb08IT1VqyLe1hg9kiIu2XV71v + mcN3f6xltcaMJwKVQQRqPN+tZhA3gEW1R+jLTIJFtUfoy0zKILgynuAKLMyk8cwk+Dg/UjeHGe9BPzi8 + cA96Ej4rw6eJQGUQgQJmU3WFZiICBQAAAKzCg0rAh7RDNdXcYL8cCJ3HDIetWsjKYYO5OGS1PS0QWK0l + 29T24NZ/kbVFabxfmcv9W0/KtWY8EagMIlDj+W41g88SsKj2CH2ZSbCo9gh9mUkZfF81nuAKLMyk8cwk + +DShnXm0mbf1e9Dtn9/r51xa0Ktaa2DhXGYGEShgNlVXaCYiUAAAAMAqPKgEfEg7hNEiK9XsYJ8eHT0t + rxW26/Gd/3rzAH+13snatejQ33zEB7fJYcf5bDEG1d6ztn/u6t+H7fr5m9/L9SaDCFQGEajxRDEziBvA + otoj9GUmwaLaI/RlJmXwHep4giuwMJPGM5Pg03746z/L/cN2bfUedIugOJ80H2di4dNEoDKIQAGzqbpC + MxGBAgAAAFYhAgV8TLuRV80O9snDrfNqh33TY1DtAE6LP7VDsdW/A9vWDs1V604+h37mtYWDuA7ezs2D + qtlEoDKIQGWo1oa+vGbAotoj9GUmwaLaI/RlJmUQXBlPcAUWZtJ4ZhJ8Wvvuu9o/bJ970IzW3gtV6w68 + y3mwDCJQwGyqrtBMRKAAAACAVYhAAZ9y/9aTcn6wTw6Fzq0dOG2H6ZIOXDlctQ8eRtounyfm1/ZnWiiw + /fN4TzK/b7/6tVx/MohAZRCBylCtDX35PAGLao/Ql5kEi2qP0JeZlMH3WOMJrsDCTBrPTIJPaz9S54zI + 3Nrr0YPD/1mu/yjt3tfp8XPX3uTcW4OrEYHKIAIFzKbqCs1EBAoAAABYhYe2gU9phy6q+cE+PTp6Wl4n + zKc9HNIOXLUIU3Ut3KT239muNYeQ9+PB4UV5LbAN9uo+tIcS2qHXv936pbwOblo7dCsKuB8/f/N7eR2Q + QwQqg4PqGaq1oS9xA1hUe4S+zCRYVHuEvsykDL4/HU9wBRZm0nhmElyNebUPbSa2zy3tvlN1Hdy0dn66 + 3YN2ve1H0g8jQjIRqAwiUMBsqq7QTESgAAAAgFWIQAFX4cFSLrVf26uuEebWDju1KNNNHbpq0afLuIeD + VfvTgi7VdcF2OPizP5eHcdt7xJuKQrXPqg//8r/82upOeUg1nwhUBp/VM1RrQ19eN2BR7RH6MpNgUe0R + +jKTMrjvMZ7gCizMpPHMJLia9v13tYeYV7sn/OPtFzd6D7qdT2o/iNfuQbcfpan+OZhXex9UXRfA+5wF + yyACBcym6grNRAQKAAAAWIUIFHAV7ZBFOwRRzRH2x8FQHt95+ebgVbvZ3w5HtQhAe0/xsTnR/vdN+79t + UY/2n20PoDhUhQeRts9nCtp7xfb+oB2WbdHAq7w2tP95+9+3A7zt/77959p/vr2+iD7x7Ve/ltcNOUSg + MohAZajWhr58poBFtUfoy0yCRbVH6MtMyuC+2niCK7Awk8Yzk+Bq2o/UuWe4b59zD7pp//um/d9f/uhQ + uwftfBLuq8HViUBlEIECZlN1hWYiAgUAAACsot3srL40pq92s+RyTf72H//539qDr83Dw4s3NyDb/127 + Kf3T7RdvAhxnJ/8q///BTXj7OmXf2sGa6hoB+BwP/nifU80atsVDA8Ba2gHsas6QRQQqg8PqGaq1oS9x + gww//PWf5foAjCAsm6FaG/ryPimD707HE1zJ0L7HqNYHYARnoLbB+yhgTe28fDVrgPeJQGUQgQJmU3WF + ZiICBQAAAKxCBCrDlxwsab9q1A6ztyhLC0S1ww/iUNwUN8Jp2q/tVdcHwHUJfczD4R9gLR5Q3QYRqAwi + UBmqtaEvrx0ZRKCAJCJQGaq1oS/vkzKIF4wnApVBBApIIgK1De2zXbV+ANf14+0X5ZwBas6BZRCBAmZT + dYVmIgIFAAAArEIEKsNNHCy5f+vJ64eHF2/CUI/vvCz/e+G62iHl6npjfxxYB9bgIaR5CAQCa/Gw9jaI + QGUQgcpQrQ19+VyRQQQKSOJzRYZqbejL+6QM7qmNJwKVQQQKSCICtQ3tHvTZyatyDQGuwz01uB4RqAwi + UMBsqq7QTESgAAAAgFWIQGXocbDk7sH5myhUO+z78ze/l/8ccBUenqBp86S6PgCuw2vKXDzMBHyp9lm1 + mi/kEYHK4MB6hmpt6EvcIIMIFJDEd04ZqrWhL++TMvjedDwRqAwiUEASEajtOD1+Vq4hwFW5Bw3XJwKV + QQQKmE3VFZqJCBQAAACwChGoDCMOlty/9eT1o6Onrx/feVn+M8GHtIPK1TXFvvi1PeBLOWQ1n/aAZbXW + AFclaLMdIlAZ7JkM1drQl7hBBhEoIIkIVIZqbejL+6QMIlDjiUBlEIECkohAbYd70MCX8tkYrk8EKoMI + FDCbqis0ExEoAAAAYBUiUBlGHyxp18Hp8fM3MYbqnw/+zIOmNG70Al/Ca8mcBAKBL9E+m1azhTwiUBm8 + n8pQrQ19eYAjgwgUkEQEKkO1NvTlfVIGEajxRKAyiEABSUSgtsX7KeBLuAcN1+dscAYRKGA2VVdoJiJQ + AAAAwCpEoDIkHSxpB+PbgeDqnxMutYOydw/Oy2uI/bh/65fy+gC4Coes5uQQEPC5PJi6LSJQGUSgMlRr + Q19eQzKIQAFJRKAyVGtDX94nZRAtGE8EKoMIFJBEBGpbHh09LdcR4FPa57FqrgAf5/xXBhEoYDZVV2gm + IlAAAADAKkSgMiQeLGnXRjuE9/M3v5f/zOBAFI2D68Dn8PDRvO4dnJdrDvApHtLeFhGoDCJQGaq1oS+f + LzKIQAFJfL7IUK0NfXmflMG9tPFEoDKIQAFJnHnalnYP+uzkVbmWAB/jXhp8HhGoDCJQwGyqrtBMRKAA + AACAVYhAZUg/WCIGRaUdrrl7cF5eM+xHe5imuj4APub+rSflTGEOHmoCrqt93qzmCblEoDI4uJ6hWhv6 + EjfIIAIFJBGBylCtDX15n5TB96XjiUBlEIECkohAbc/p8bNyLQE+xD1o+HwiUBlEoIDZVF2hmYhAAQAA + AKsQgcqwlYMlDw8vHFLlHQ5F0fi1PeA62nuJapYwD4FA4LqEbLZHBCqDvZOhWhv6EjfIIAIFJBGBylCt + DX15n5TB/fXxRKAyiEABSZx32h7nXIHrOj1+Xs4T4NNEoDKIQAGzqbpCMxGBAgAAAFbh5niGrR0saYfz + 2q/kVP8u7EuL/9w9OC+vE/bDDV/gOsQK9sGDTcBV+QXWbRKByuB9VYZqbehL3CCDCBSQRAQqQ7U29OV9 + UgbflY4nApVBBApIIgK1Td5XAdfRzsdXswT4NGeCM4hAAbOpukIzEYECAAAAViEClWGrB0vEoGgcjOLe + wfmbIFh1fQC8TehjPzzMAVzV91//Vs4RsolAZRCBylCtDX2JG2QQgQKSiEBlqNaGvrxPyiBWMJ4IVAb3 + DYAkzjptU/usV60nwJ/5PAxfRgQqgwgUMJuqKzQTESgAAABgFSJQGbZ+sKQ9tFv9e7EPLf5z9+C8vDbY + Dzd9gasQKtgPgUDgqvwC6zaJQGXw3ipDtTb05WGODCJQQBIRqAzV2tCX90kZRKDGE4HKIAIFJBGB2i7v + rYCrcA8avozzwBlEoIDZVF2hmYhAAQAAAKsQgcoww8GSdi21g8TVvx/zczgKsQ/gU37+5vdyfjAvB4KA + T/Ew6naJQGUQgcpQrQ19eT3JIAIFJBGBylCtDX15n5RBqGA8EagMIlBAEuectqt93qvWFOCSz8Lw5Zz5 + yiACBcym6grNRAQKAAAAWIUIVIaZDpa0g3st8lD9ezKvFv+5e3BeXhPsx+nxs/L6AGhECvZHIBD4FL/A + ul0iUBm8v8pQrQ19eaAjgwgUkEQEKkO1NvTlfVIGEajxRKAyiEABSUSgtu3xnZflugI0vheCLycClUEE + CphN1RWaiQgUAAAAsAoRqAyzHSxp11U7VFz9uzKv746eltcD++E1BfiQFogU+tgnh4KAD/Eg6raJQGUQ + gcpQrQ19eU3JIAIFJPGwX4ZqbejL+6QMIlDjiUBlEIECkohAbZvXFOBD2uevam4A1+O8VwYRKGA2VVdo + JiJQAAAAwCoEOzLMerCkHbho0Yfq35n5ODxLIwAHVL7/+rdyZjC/ewfnr89OXpXXBbBv4oDbJgKVQQQq + Q7U29CVukEEECkgiApWhWhv68j4pgwjUeO5jZxDsAJKIQG2fM4lAxXdCsA4RqAwiUMBsqq7QTESgAAAA + gFWIQGWY+WBJu8Z+uv2i/PdmPm6i0/a82Afwtnb4Uuhj3xwMAv7MQ6jbJwKVQQQqQ7U29OV1JYMIFJDE + vYoM1drQl/dJGUSgxhOByiACBSQRgdq+h4cX5doC++UzMKzHWa8MIlDAbKqu0ExEoAAAAIBViEBl2MPB + ku+//q38d2cu7RBztf7sixvAwNvECbh3cC4QCLxDHHD7RKAyeJ+VoVob+vJgRwYRKCCJCFSGam3oy/uk + DCJQ44lAZRCBApKIQM3B+yzgbe5Bw3qcAc4gAgXMpuoKzUQECgAAAFiFCFSGvRwsuX/ryeufv/m9/Bsw + Dw9XIPYBXGqv+9WcYH8eHT0trxFgf06Pn5dzgm0RgcogApWhWhv6EjfIIAIFJHGfIkO1NvTlfVIGcYLx + RKAyiEABSUSg5tA++1XrC+yPz7+wLhGoDCJQwGyqrtBMRKAAAACAVYhAZdjTwZJ2zT2+87L8OzCH0+Nn + 5dqzL24CA40wAW8TAwXaHPALrHMQgcrgvVaGam3oy8MdGUSggCQiUBmqtaEv75MyiECNJwKVQQQKSCIC + NQ/vtYDGPWhYl/O/GUSggNlUXaGZiEABAAAAqxCByrDHgyU/HD8v/xZs39nJq9d3D87LdWc/7v1xDbRr + obpGgH1ooY9qPrBffokVeHT0j3I+sD0iUBlEoDJUa0Nf4gYZRKCAJCJQGaq1oS/vkzIIE4wnApVBBApI + IgI1D/egAZ99YX0iUBlEoIDZVF2hmYhAAQAAAKsQgcqw14Ml33/9W/n3YPsclqJ5dPS0vD6AfXhweFHO + BvbNA0+wX+KAcxGByiAClaFaG/rygEcGESggiQhUhmpt6Mv7pAy+Ex1PBCqDCBSQxLmmubT3vdU6A/Nr + 96DbOfhqNgCfTwQqgwgUMJuqKzQTESgAAABgFSJQGfZ8sMRBvzmdnbwq15v9cbAd9snDRXyIX2KF/RKr + mYsIVAb7KkO1NvTl80cGESggiQhUhmpt6Mv7pAzulY0nApXB2RAgiQjUXNoZ2HZWrVprYG6Pjv5RzgXg + y4hAZRCBAmZTdYVmIgIFAAAArEIEKsPeD5bcv/XEQYwJeciCRuwD9smv7PExPxw/L68bYF4/3n5RzgO2 + SwQqgwhUhmpt6EvcIIMIFJDE/YkM1drQl/dJGUSgxhOByiACBSQRgZqPWAXsz8/f/F7OA+DLeV3NIAIF + zKbqCs1EBAoAAABYhQhUBgdL/n0ttpuy1d+HbWoHmqu1Zn/aQwbVNQLM6fuvfytnAVy6d3AuAAo7Iw44 + HxGoDCJQGaq1oS9xgwwiUEASEagM1drQl/dJGUSgxhOByiACBSRxVm8+7R60s4ewLw8OL8p5AHw5EagM + IlDAbKqu0ExEoAAAAIBViEBlcLDk34Sg5nP34Lxca/ZF7AP2w6/scVWPjp6W1xAwH3HAOYlAZRCBylCt + DX2JG2QQgQKSiEBlqNaGvrxPyiACNZ4IVAYRKCCJs3pzap8Fq/UG5uPzLtwsEagMIlDAbKqu0ExEoAAA + AIBViEBlcLBkIQQ1F9c2l8Q+YB+ECLgODz/B/MQB5yUClcF7rwzV2tCXhz0yiEABSUSgMlRrQ1/eJ2Xw + Peh4IlAZRKCAJM4zzeun2y/KNQfm0e5Bt3PG1QwA1iEClUEECphN1RWaiQgUAAAAsAoRqAwOlrxLCGoe + 7VBztcbsk0PuMDcPFHFdPovA/B4cXpT7n+0TgcogApWhWhv68lkkgwgUkEQEKkO1NvTlfVIG98fGE4HK + IAIFJHFWb173Ds5fn528KtcdmIP7Y3DzRKAyiEABs6m6QjMRgQIAAABW4cHrDA6WvE8Iah4etuBS29cO + WsGc/Moen8uhIZiXB03nJgKVwSH3DNXa0JfXnAwiUEAS9yUyVGtDX94nZRCBGk8EKoMIFJDEWb25PTp6 + Wq47sH1+lBT6cJ4rgwgUMJuqKzQTESgAAABgFSJQGRwsqQlBzeH0+Fm5vuyTg1YwJwECvsTjOy/L6wrY + LnHA+YlAZfAeLEO1NvQlbpBBBApIIgKVoVob+vI+KYMI1HgiUBlEoIAkzurNz3swmM/Zyb/cg4ZORKAy + iEABs6m6QjMRgQIAAABWIQKVwcGSDxOC2r6zk1fl2rJfDlrBXDxIxJe6f+tJeW0B2yVMMz8RqAz2WoZq + bejLZ5IMIlBAEhGoDNXa0Jf3SRncFxtPBCqDCBSQxFm9+bUzh+3MWrX+wDY9OvpHud+B9YlAZRCBAmZT + dYVmIgIFAAAArEIEKoODJR/nUMb2eeCCt9nTMI8Wamx7utrrcB0OD8E8PGC6DyJQGUSgMlRrQ19eezKI + QAFJ3JPIUK0NfXmflEEEajwRqAwiUEASZ/X24dHR03L9ge1pn6uqfQ7cDOe4MohAAbOpukIzEYECAAAA + ViEClcHBkk+7f+uJaMyGnR4/K9eV/XLQCuYgPMCaHt95WV5nwHaIA+6HCFQG78UyVGtDX+IGGUSggCQi + UBmqtaEv75MyiECNJwKVQQQKSOKs3n78dPtFeQ0A2+EeNPQnApVBBAqYTdUVmokIFAAAALAKEagMDpZc + jUOB29UCXtWasm8OvcO2nR4/L/c2fK722UT0E7bNg9b7IQKVQQQqQ7U29CVukEEECkjis0mGam3oy/uk + DO6HjScClcF5DyCJs3r7ce/g/E1AproOgG1wPwz6E4HKIAIFzKbqCs1EBAoAAABYhQhUBgdLru77r38r + /4bk89AFfyb2AdvVDknePTgv9zZ8iUdHT8trDsjXPqtV+5o5iUBlcOg9Q7U29CVukEEECkjifkSGam3o + y/ukDCJQ44lAZRCBApI4q7cv7TNidR0A+XyuhTFEoDKIQAGzqbpCMxGBAgAAAFYhApXBwZLr+eH4efl3 + JNvp8bNyPdk3B61gm9p7yGpPwxraIb7qugNyPb7zstzPzEsEKoMIVIZqbejLQyAZRKCAJCJQGaq1oS/v + kzKIQI0nApVBBApI4qze/jhvCNvjB+pgHBGoDCJQwGyqrtBMRKAAAACAVYhAZXCw5Poclt2es5NX5VqC + g1awLY+O/lHuZVjLvYPzN4f5qusPyNP2qzjg/ohAZRCBylCtDX2JG2QQgQKSiEBlqNaGvrxPyuC+9ngi + UBlEoIAkzurtk/dlsC3uQcM4IlAZRKCA2VRdoZmIQAEAAACrEIHK4GDJ9YkDbJMHL/gQB61gGzw0RC/3 + bz15E5CsrkMgy4PDi3IfMzcRqAwiUBmqtaEvn1MyiEABSdyLyFCtDX15n5TBPbDxRKAyiEABSZzV26d2 + VtY9aNgGP1AHY4lAZRCBAmZTdYVmIgIFAAAArEIEKoODJZ9HHGB7To+flWsJ7fVI2A2ytT169+C83MNw + Ex4dPS2vRSDH91//Vu5f5icClUEEKkO1NvQlbpBBBApIIgKVoVob+vI+KYMI1HgiUBlEoIAkzurtV/u8 + WF0TQI7T4+fl/gX6EYHKIAIFzKbqCs1EBAoAAABYhQhUBgdLPp84wLY4YMvHOGgFuc5O/vXmfWO1d+Em + /XD8vLwmgfHaA4zVvmUfRKAyiEBlqNaGvsQNMohAAUlEoDJUa0Nf3idlEIEazz3qDCJQQBJn9fat/chJ + dV0A4/mBOsggApVBBAqYTdUVmokIFAAAALAKEagMDpZ8mZ9uvyj/rmRyU4qPEXaDTAIDjHLv4Pz14zsv + y+sSGKcdvhUH3DcRqAzeo2Wo1oa+xA0yiEABSUSgMlRrQ1/eJ2UQgRpPBCqDCBSQxFk9nDeEPO5BQw4R + qAzO2wOzqbpCMxGBAgAAAFYhApXBwZIv0+IA7QZw9bclz3dHT8t1hEvtoYTq2gHGaL+CWe1V6KV9ZvFe + D3KcnfzL4VtEoEKIQGWo1oa+xA0yiEABSUSgMlRrQ1/eJ2UQgRpPBCqDCBSQxFk9nDeEPA8OL8r9CvQn + ApVBBAqYTdUVmokIFAAAALAKEagMDpZ8uXagv/rbkqcddK7WEC61g1aP77wsrx+gr/brl9U+hd7u33ry + +uzkVXmdAn05fEsjApVBBCpDtTb0JW6QQQQKSCIClaFaG/ryPimDCNR4IlAZRKCAJM7q0bSzs+5BQwY/ + UAdZRKAyiEABs6m6QjMRgQIAAABWIQKVwcGSdfxw/Lz8+5KlHZ6p1g/e1l6f/OIejNX24N2D83KPwgge + EIHxHL7lkghUBhGoDNXa0Je4QQYRKCCJCFSGam3oy/ukDCJQ44lAZfAdP5DEWT0u+eFJGO/0+Hm5P4Fx + RKAyiEABs6m6QjMRgQIAAABWIQKVwcGSddw7OBeN2QgPYHAVfnEPxmmvp20PVnsTRmoBmuqaBW6ew7e8 + TQQqgwhUhmpt6EvcIIMIFJDEPYgM1drQl/dJGUSgxhOByiACBSRxVo+3PTp6Wl4nwM1rn5eqfQmMJQKV + QQQKmE3VFZqJCBQAAACwChGoDA6WrMevc22Da56rsqehv7OTfwlAEa09vFZdu8DNeXznZbkf2S8RqAwi + UBmqtaEvcYMMIlBAEhGoDNXa0Jf3SRlEoMYTgcogAgUkcW6JP/NjRNBf+4G6uwfn5Z4ExhKByiACBcym + 6grNRAQKAAAAWIUIVAYHS9b1w/Hz8u9MDr/gxHX4xT3o68HhRbkXIYkHp6Afh2+piEBlEIHKUK0NfYkb + ZBCBApKIQGWo1oa+vE/K4LvM8USgMohAAUmc1aPix4ign3YP2g/UQS4RqAwiUMBsqq7QTESgAAAAgFWI + QGVwsGRd9w7OX5+dvCr/1mRo6+NBcq7DL+5BH4+O/lHuQUjT3u89vvOyvI6B9Th8y4eIQGUQgcpQrQ19 + iRtkEIECkohAZajWhr68T8ogAjWeCFQGESggibN6fIj3bnDzzk7+5R40hBOByiACBcym6grNRAQKAAAA + WIUIVAYHS9b36Ohp+bcmh4cwuC4hKLhZbY9Vew9Stc8yLVBTXc/AlxOA4mNEoDKIQGWo1oa+xA0yiEAB + Sdx/yFCtDX15n5RBSGA8EagMIlBAEmf1+BA/RgQ3qwWg7t/6pdx/QA4RqAwiUMBsqq7QTESgAAAAgFWI + QGVwsORmOJCRzXXP52gPLFTXE/BlBKDYKiEouBkO3/IpIlAZRKAyVGtDX+IGGUSggCQiUBmqtaEv75My + iECNJwKVQQQKSOLMEh/TQlDuQcPNeHB4Ue47IIsIVAYRKGA2VVdoJiJQAAAAwCpEoDI4WHIz2iH/6u9N + hnbguVo3+BQhKFiXABRbJwQF6xKA4ipEoDKIQGWo1oa+xA0yiEABSUSgMlRrQ1/eJ2UQgRpPBCqDCBSQ + xFk9PsU9aFjfd3/5P+V+A/KIQGUQgQJmU3WFZiICBQAAAKxCBCqDgyU3x6HaXGcnr8o1g6uwt2Edp8fP + yz0GW3P/1pM37y2q6xy4Hr++ylWIQGUQgcpQrQ19iRtkEIECkohAZajWhr68T8rgntZ4IlAZRKCAJM7q + cRVCULCeR0f/KPcZkEkEKoMIFDCbqis0ExEoAAAAYBUiUBkcLLk57aB/9TcngxtUfK57B+evH995WV5X + wNV4AIjZCEHBl/Prq1yVCFQGEagM1drQl882GUSggCQiUBmqtaEv75MyiECNJwKVQQQKSOKsHlclBAVf + 7vuvfyv3F5BLBCqDM/bAbKqu0ExEoAAAAIBViEBlcLDkZjlYm8sDq3wJISj4fB7+YVZCUPD5BKC4DhGo + DD5TZ6jWhr58vskgAgUkEYHKUK0NfXmflMG96vFEoDKIQAFJnNXjOoSg4PMJQME2iUBlEIECZlN1hWYi + AgUAAACsQgQqg4MlN6sd9q/+7ox3evysXDO4KiEouD4P/jA7ISi4PgEorksEKoMIVIZqbejLZ5wMIlBA + EhGoDNXa0Jf3SRlEoMYTgcogAgUkcVaP6xKCgusTgILtEoHKIAIFzKbqCs1EBAoAAABYhQhUBgdLbp7D + tZn+fudluV5wHUJQcHUe+mEvhKDg6gSg+BwiUBlEoDJUa0NfPudkEIECkohAZajWhr68T8rgPvV4IlAZ + RKCAJM7q8TmEoODqBKBg20SgMohAAbOpukIzEYECAAAAViEClcHBkpvXDvxXf3vGu3twXq4ZXFd7mKG6 + xoB/c8CKvXEIFz7u7ORfHozms4lAZRCBylCtDX2JG2QQgQKS+KyToVob+vI+KYMI1HgiUBlEoIAkzurx + udyDhk/zI0SwfSJQGUSggNlUXaGZiEABAAAAqxCByuBgSR8O2Ga6f+tJuV7wOYSgoCYAxV45hAu1FoC6 + f+uXct/AVYhAZRCBylCtDX2JG2QQgQKSiEBlqNaGvrxPyuAe9XgiUBlEoIAkzurxJdyDhg8TgII5iEBl + EIECZlN1hWYiAgUAAACsQgQqg4MlfThUmMlDq6ytxW6qaw32SgCKvXMIF97V9kPbF9V+gasSgcrg83SG + am3oS9wggwgUkEQEKkO1NvTlfVIGEajxRKAyOK8BJHFWjy/V7rU9vvOyvL5gj9qPEPk+BuYhApVBBAqY + TdUVmokIFAAAALAKEagMDpb0ce/g/PXZyatyDRjn9PhZuV7wJYSg4N8eHf2j3COwNw7hwr8JQLEWEagM + IlAZqrWhL3GDDCJQQBIPHWao1oa+vE/KIAI1nghUBhEoIImzeqyhnUX86faL8hqDPWn3oO/f+qXcJ8A2 + iUBlEIECZlN1hWYiAgUAAACsQgQqg4Ml/bgxlacdfK7WCr6UEBR71n5h77u//J9yb8BeOYTL3rUQmgAU + axGByiAClaFaG/oSN8ggAgUkEYHKUK0NfXmflEEEajwRqAwiUEASZ/VY0w/Hz8vrDPbAjxDBnJy1zyAC + Bcym6grNRAQKAAAAWIUIVAYHS/pxzec5O3lVrhWs4eHhxZtrrLr2YFZ+YQ8+ziFc9qgF0O4enJd7Aj6H + CFQGEagM1drQl7hBBhEoIIkIVIZqbejL+6QMIlDjiUBlEIECkjirx9r8UB175EeIYF4iUBlEoIDZVF2h + mYhAAQAAAKsQxMngYElfDtrm8UA6N6m91rUoTnXtwWz8wh5cjUO47Mnp8fNyH8CXEIHKIAKVoVob+hI3 + yCACBSQRgcpQrQ19eZ+Uwb3p8USgMohAAUmc1eMmPDp6Wl5vMKP2edOZT5iXCFQGEShgNlVXaCYiUAAA + AMAqRKAyOFjSlwMXeTyQwU0TgmIP2oMkDljB1T08vHh9dvKq3E8wi0dH/yivf/hSIlAZRKAyVGtDX+IG + GUSggCTuOWSo1oa+vE/KIAI1nghUBhEoIImzetyU+7eeOJ/E9NqPblXXPzAPEagMIlDAbKqu0ExEoAAA + AIBViEBlcLCkr3sH5x74D+PBVXpoe/+H4+flNQhbd/rHtV1d98DHiQQyq7OTf3nomRslApXBZ+kM1drQ + l7hBBhEoIInPQxmqtaEv75MyiECNJwKVQQQKSOKsHjfJPWhm1e5Bf/eX/1Ne98BcRKAyiEABs6m6QjMR + gQIAAABWIQKVwcGS/hy2zXJ6/KxcJ7gJ7dfIqusQtqgdsHp09I/yWgeupn0menznZbnHYIvaofJ2XVfX + O6xFBCqDCFSGam3oS9wggwgUkEQEKkO1NvTlfVIG96XHE4HKIAIFJHFWj5vWfqiuvR+vrj/YonYP+v6t + X8rrHZiPCFQGEShgNlVXaCYiUAAAAMAqRKAyOFjS36Ojp+VaMMaPt1+U6wQ35eHhhV/dY/McsIJ1iQQy + g3aY/O7BeXmNw5pEoDKIQGWo1oa+xA0yiEABSUSgMlRrQ1/eJ2UQgRpPBCqDCBSQxFk9enEPmhm0zzR+ + hAj2RQQqgwgUMJuqKzQTESgAAABgFSJQGRws6a/92la1Fozh4C0jtNdAISi2qh2wEvmA9bWHUM5OXpX7 + DtI9OvpHeV3DTRCByiAClaFaG/oSN8ggAgUkEYHKUK0NfXmflEEEajz3ojOIQAFJnNWjp/YZ1fkktur0 + +Hl5XQNzE4HKIAIFzKbqCs1EBAoAAABYhQhUBgdLxnDgNkeLLVRrBD38cPy8vC4hVfulyOpaBtYhEsjW + tOvVA870JgKVQQQqQ7U29CVukEEECkjiM1KGam3oy/ukDO5JjycClUEECkjirB69tXvQj++8LK9HSHR2 + 8q/XDw4vyusZmJ8IVAYRKGA2VVdoJiJQAAAAwCpEoDI4WDKGm1RZ3KxipHboWPCDdCIf0M+9g3ORQDbh + p9svXt/943qtrmO4SSJQGUSgMlRrQ1/iBhlEoIAkvkPLUK0NfXmflEEEajwRqAwiUEASZ/UYpf3oV3VN + QpL2GaadLa+uYWAfnK/P4Fw9MJuqKzQTESgAAABgFSJQGRwsGaM9BFCtB2Pcv/WkXCfoxa/ukUzkA8YQ + CSRV++XVR0f/KK9b6EEEKoMIVIZqbehL3CCDCBSQRAQqQ7U29OV9UgYRqPFEoDKIQAFJnNVjpPaZ1T1o + Up0ePy+vW2BfRKAyiEABs6m6QjMRgQIAAABWIQKVwcGScc5OXpVrQn8eXiWFX90jicgHjNc+M3lQiyQt + WumXVxlNBCqDz9EZqrWhL3GDDCJQQBIRqAzV2tCX90kZfLc4nghUBhEoIImzeozW7vW19+vV9QkjtDCZ + 71OASyJQGUSggNlUXaGZiEABAAAAqxCByuBgyTg/3X5Rrgn9fXf0tFwjGKG9PvrVPUZrD4aIfECOR3+8 + VxEQZbQWq6yuT+hNBCqDCFSGam3oS9wggwgUkMRDixmqtaEv75MyiECNJwKVQQQKSOKsHina66PzSYx2 + evz89d2D8/IaBfZJBCqDCBQwm6orNBMRKAAAAGAVIlAZHCwZpz3MX60J/Z0ePyvXCEZqoYXqeoWbdHby + rz9en/5RXpPAWO3z0+M7L8u9CzepXXceYiaJCFQGEagM1drQl7hBBhEoIInPTxmqtaEv75MyiECNJwKV + QQQKSOKsHknaPej23r26VuEmtQCZ71CAighUBhEoYDZVV2gmIlAAAADAKkSgMjhYMk67iV2tCf39ePtF + uUYwWnut9Kt79NIeBmnXXHUtAjlaSPTs5FW5j2FtLUpZXYcwkghUBhGoDNXa0Je4QQYRKCCJBxgzVGtD + X94nZRCBGk8EKoMIFJDEWT0StddK55Po5fT4+eu7B+fltQggApVBBAqYTdUVmokIFAAAALAKEagMDpaM + c+/g3AP8If5+52W5RpCiBRjMC27K2cm/Xj86+kd57QGZ/CIrN00YkGQiUBlEoDJUa0Nf4gYZRKCAJCJQ + Gaq1oS/vkzKIQI0nApVBBApI4qweqdyD5qY9vvPS9ybAJ4lAZRCBAmZTdYVmIgIFAAAArEIEKoODJWO1 + G9vVutCXw7dsgcNW3AS/rgfb5hdZWZswIFsgApVBBCpDtTb0JW6QQQQKSOJhxgzV2tCX90kZRKDGcx86 + gwgUkMRZPdLdv/WLe9Csqt2Dbj+AWF1vAH8mApVBBAqYTdUVmokIFAAAALAKEagMDpaM5QGlHNX6QCLB + D9bQHvzwQBrMox2YrPY6XIcwIFshApVBBCpDtTb0JW6QwXesQBLfuWWo1oa+vE/KIAI1nghUBhEoIImz + emzFo6OnzifxxX66/eLNWfHqGgOoiEBlEIECZlN1hWYiAgUAAACsQgQqg4MlY7XDEtW60J8H3tkah634 + HO3X9TywD3Nqn6/aw3XV3oePaQ8Dtl/0ra4rSCQClcF7ygzV2tCXuEEGESggiQhUhmpt6Mv7pAwiUOOJ + QGUQgQKSOKvHlrgHzefy43TA5xKByiACBcym6grNRAQKAAAAWIUIVAYHS8ZqN7qrdaE/N6zYIoetuKoW + f/r+698E72AH2mvD4zsvy1kAb2vXiYO3bJEIVAYRqAzV2tCXuEEGESggic9ZGaq1oS/vkzKIQI0nApVB + BApI4qweW+R8ElfVftDQPSTgS4hAZXCmHphN1RWaiQgUAAAAsAoRqAwOlox17+C8XBf6u3/rSblGsAUO + W/Eh4k+wX+1gZTtgWc0G9s3BW7ZOBCqDOZKhWhv6EjfIIAIFJBGBylCtDX15n5RBBGo8EagMIlBAEmf1 + 2LL2mdd7TCrOJwFrEYHKIAIFzKbqCs1EBAoAAABYhQhUBgdLxjs7eVWuDX15MIMZiEHxtnYttGuiulaA + /RCD4pKDt8xCBCqDCFSGam3oS9wggwgUkMS9hgzV2tCX90kZPKA/nghUBhEoIImzeszAPWguuQcNrE0E + KoMIFDCbqis0ExEoAAAAYBUiUBkcLBnv8Z2X5drQlwdYmYkY1L6JPwEVB3H3y8FbZiMClcFn6AzV2tCX + uEEGESggiQhUhmpt6Mv7pAwiUOOJQGUQgQKSOKvHTNyD3i/3oIGbIgKVQQQKmE3VFZqJCBQAAACwChGo + DA6WjOchpQweYGVGYlD74XAVcFXtPY8I6T60dfYelxmJQGUwXzJUa0Nf4gYZfL8KJBGBylCtDX15n5RB + BGo8EagM7XuMan0ARnBWjxm1z8Lee+6D80nATROByiACBcym6grNRAQKAAAAWIUIVAYHS8Y7PX5Wrg19 + 2QvM7DIG5df35uNwFfC52kFcocA5tQPWHjpmZiJQGUSgMlRrQ1/iBhlEoIAkPo9lqNaGvrxPyuBB/PFE + oDKIQAFJnE9iZn6sbl7ts4V7Q0APIlAZRKCA2VRdoZmIQAEAAACrEIHK4GDJeI+OnpZrQ1/2AnvRDuSI + QW1fO1z14PCiXGOA6xAKnEOLAp4eP/ewMbsgApXBQf8M1drQl7hBBhEoIInPZRmqtaEv75MyiECNJwKV + QQQKSOJ8EnvQ7kH/cPzcPegJ+AEioDcRqAwiUMBsqq7QTESgAAAAgFWIQGVwsGQ8Bw4znB4/K9cHZtUO + 6Pj1vW0R+ABuWntf+vjOy3IGkamt1/df//b67sF5uaYwIxGoDCJQGaq1oS9xgwwiUEAS391lqNaGvrxP + yiACNZ4IVAZnMoAkzuqxN+112PvSbWnnk9yDBkYRgcogAgXMpuoKzUQECgAAAFiFCFQGB0vG8wBrBofR + 2av2eiz6ka0dhnt09NThKqCb+7eevHlv5JdZM4kCsnc+Q2cQgcpQrQ19+T4pgwgUkMRntQzV2tCX90kZ + PGw/nghUBhEoIImzeuxVO5/U7nG6B52p3YP+8fYL32sAw4lAZRCBAmZTdYVmIgIFAAAArEIEKoODJePZ + CxkcRgcHrpK0BzP8qh6Q4OHhxZv3SdWsoq/22tAeVvLawN6JQGUQgcpQrQ19+T4pgwgUkMTDkhmqtaEv + 75MyiECNJwKVQQQKSOKsHvyPN5+d22cG55PG88N0QBoRqAwiUMBsqq7QTESgAAAAgFUI32RwsGQ8eyGD + w+jwLgeu+mt/6xZ+8qAYkKgd+mwPyvx0+8WbXwGt5hjran9nh27hfSJQGUSgMlRrQ1++T8ogAgUk8d1e + hmpt6Mv7pAwiUOOJQGUQgQKSOKsH77r8USL3oPtxDxpIJgKVQQQKmE3VFZqJCBQAAACwCuGbDA6WZKjW + hr7a4YZqbYD/8fr+rSdvXi88LLC+y4NVf/uP/yz/9gCpLg/jigWuqx1ubn/X9lCSQ7dQE4HKIAKVoVob + +hI3yCACBSQRgcpQrQ19eZ+UwX2d8USgMohAAUmc1YMP84N1N6Pdg24/9iT8BGyBCFQGEShgNlVXaCYi + UAAAAMAqRKAyOFiSoVob+hKBgqtpr9/toLRDV5+n/c1Oj5+LewBTabHAdmDUQ2Wfp/3dvv/6Nw8KwxWJ + QGUQgcpQrQ19iRtkEIECkvhsl6FaG/ryPimD7+vGE4HKIAIFJHFWD67m7XvQLWJU7Sc+7PGdl2/OJ7Xv + KZxPArZEBCqDCBQwm6orNBMRKAAAAGAVIlAZHCzJcHbyqlwf+hGBgs/TDl21g9PtF+NEod7X/ibtYZf2 + N/rbf/xn+TcEmE07SNo+ZziQ+77292h/Fwdu4fOJQGUQgcpQrQ19iRtkEIECkohAZajWhr68T8ogAjWe + CFQGESggibN68Hna521RqA+7jD49PLxwDxrYNBGoDCJQwGyqrtBMRKAAAACAVYhAZXCwJEM7/FmtD/2I + QME62ut7O1DUDhbt7eDV22EPh6oAFpcHclswsB0+rWborC5jgO3fX/QJ1iEClUEEKkO1NvQlbpBBBApI + IgKVoVob+vI+KYMI1HgiUBlEoIAkzurBOi5/tK599tjjPeh27909aGBGIlAZRKCA2VRdoZmIQAEAAACr + EIHK4GBJBhGo8USg4Oa0g1ctitRec2YIgLTYU/t3uIx6tH+3v/3Hf5b/7gDU2mHUdij3MhrYDqpWM3cr + 2j//ZQiwvTa01z6HbeFmiEBlEIHKUK0NfYkbZBCBApKIQGWo1oa+vE/KIAI1nghUBhEoIImzenBzLs8n + Xd6Dnu18kuATsAciUBlEoIDZVF2hmYhAAQAAAKsQgcrgYEkGEajxRKCgv3b4qh1QageVLgNRCSGQdojq + MubRDlK1f7Z2OLz9s4o9AdycdmD18mBue21oh3NTXhvaf387YNv+eS4P2bbXBrEn6E8EKoMIVIZqbehL + 3CCDCBSQRAQqQ7U29OV9Uob2vVq1PvQjApVBBApI4qwe9Pf2+aSke9CX55Mu70Ffnk9yDxrYszYLq5lJ + XyJQwGyqrtBMRKAAAACAVYhAZXCwJIMI1HjtYEe1NsA47UBTiy61g1hNO+h0GYxq2sGsdgjqOtp/5vI/ + 3/7/NS020g5Qtf8uh6gAsl2GotrrQpvff35tqGb/p1z+Zy/DTk37/99eF8T/II8IVIY2K6v1oa9qbeir + vZeo1oa+2kz683s8+qv2CH21hwartaGv9pm1mlX0Ve0R+mr7oVob+hKBGk8EKkP7vvfPr9n0d3byqtwn + 9NPWoFob+npweFHOKmCcT92D/pzzSZf/2ebte9CX55Oqfw4ARKBSiEABs6m6QjMRgQIAAABWIQKVod0s + qdaHvkSgxhOBAgAAyCcClUEEKkO1NvTVHuap1gb2qNoj9GUmwaLaI/RlJmUQgRpPBAoWZtJ4ZhIAAOlE + oDKIQAGzqbpCMxGBAgAAAFYhApVBBCqDCNR4IlAAAAD5RKAyiEBlqNaGvsQNYFHtEfoyk2BR7RH6MpMy + CK6MJ7gCCzNpPDMJAIB0IlAZRKCA2VRdoZmIQAEAAACrEIHKIAKVQQRqPBEoAACAfCJQGUSgMlRrQ1/i + BrCo9gh9mUmwqPYIfZlJGQRXxhNcgYWZNJ6ZBABAOhGoDCJQwGyqrtBMRKAAAACAVYhAZRCByiACNZ4I + FAAAQD4RqAwiUBmqtaEvcQNYVHuEvswkWFR7hL7MpAyCK+MJrsDCTBrPTAIAIJ0IVAYRKGA2VVdoJiJQ + AAAAwCpEoDKIQGWo1oa+RKAAAADyiUBlEIHKUK0NfYkbwKLaI/RlJsGi2iP0ZSZlEFwZT3AFFmbSeGYS + AADpRKAyiEABs6m6QjMRgQIAAABWIQKVQQQqQ7U29CUCBQAAkE8EKoMIVIZqbehL3AAW1R6hLzMJFtUe + oS8zKYPgyniCK7Awk8YzkwAASCcClUEECphN1RWaiQgUAAAAsAoRqAwiUOPdOzgv14a+RKAAAADyiUBl + EIHKUK0NfYkbwKLaI/RlJsGi2iP0ZSZlEFwZT3AFFmbSeGYSAADpRKAyiEABs6m6QjMRgQIAAABWIQKV + QQRqPHshg8PoAAAA+USgMohAZajWhr58nwSLao/Ql5kEi2qP0JeZlEFwZTzBFViYSeOZSQAApBOByiAC + Bcym6grNRAQKAAAAWIXwTQYRqPE8wJrBYXQAAIB8PkNnEIHKUK0Nffk+CRbVHqEvMwkW1R6hLzMpg+DK + eIIrsDCTxjOTAABIJwKVQQQKmE3VFZqJCBQAAACwChGoDCJQ43mANYPD6AAAAPl8hs4gApWhWhv68n0S + LKo9Ql9mEiyqPUJfZlIGwZXxBFdgYSaNZyYBAJBOBCqDCBQwm6orNBMRKAAAAGAVIlAZRKDGaw9OVmtD + X/YCAABAPhGoDCJQGaq1oS9xA1hUe4S+zCRYVHuEvsykDIIr4wmuwMJMGs9MAgAgnQhUBhEoYDZVV2gm + IlAAAADAKkSgMgjfjOeGVQZ7AQAAIJ8IVAYRqAzV2tCXuAEsqj1CX2YSLKo9Ql9mUgbBlfEEV2BhJo1n + JgEAkM6Z+gwiUMBsqq7QTESgAAAAgFWIQGUQvhnvh7/+s1wb+vru6Gm5PgAAAOQQgcogApWhWhv6EjeA + RbVH6MtMgkW1R+jLTMoguDKe4AoszKTxzCQAANKJQGUQgQJmU3WFZiICBQAAAKxCBCqDCNR4Drpl8AAr + AABAPhGoDD5DZ6jWhr7EDWBR7RH6MpNgUe0R+jKTMrgPPZ7gCizMpPHMJAAA0olAZRCBAmZTdYVmIgIF + AAAArEIEKoMI1HjtkFW1NvT17Ve/lusDAABADhGoDCJQGaq1oS9xA1hUe4S+zCRYVHuEvsykDIIr4wmu + wMJMGs9MAgAgnQhUBhEoYDZVV2gmIlAAAADAKkSgMohAjVetC/2JQAEAAOQTgcogApWhWhv6EjeARbVH + 6MtMgkW1R+jLTMoguDKe4AoszKTxzCQAANKJQGUQgQJmU3WFZiICBQAAAKxCBCqDCNRY92/9Uq4L/d2/ + 9aRcIwAAAHKIQGUQgcpQrQ19iRvAotoj9GUmwaLaI/RlJmUQXBlPcAUWZtJ4ZhIAAOlEoDKIQAGzqbpC + MxGBAgAAAFYhApVBBGqsh4cX5brQ392D83KNAAAAyCEClUEEKkO1NvQlbgCLao/Ql5kEi2qP0JeZlEFw + ZTzBFViYSeOZSQAApBOByiACBcym6grNRAQKAAAAWIUIVAYRqLHcrMpRrQ8AAABZRKAyiEBlqNaGvsQN + YFHtEfoyk2BR7RH6MpMyCK6MJ7gCCzNpPDMJAIB0ztVnEIECZlN1hWYiAgUAAACsQgQqgwjUWA65ZTg7 + eVWuDwAAAFlEoDKIQGWo1oa+xA1gUe0R+jKTYFHtEfoykzK4Fz2e4AoszKTxzCQAANKJQGUQgQJmU3WF + ZiICBQAAAKxCBCqDCNRYLT5UrQt9/f3Oy3J9AAAAyCIClUEEKkO1NvQlbgCLao/Ql5kEi2qP0JeZlEFw + ZTzBFViYSeOZSQAApBOByiACBcym6grNRAQKAAAAWIUIVAYRqHHsgRztsGG1RgAAAGQRgcogApWhWhv6 + EjeARbVH6MtMgkW1R+jLTMoguDKe4AoszKTxzCQAANKJQGUQgQJmU3WFZiICBQAAAKxCACeDCNQ4Dw8v + yjWhPwfRAQAAtkEEKoMIVIZqbejLd0qwqPYIfZlJsKj2CH2ZSRkEV8YTXIGFmTSemQQAQDoRqAwiUMBs + qq7QTESgAAAAgFWIQGUQgRqnHX6u1oT+7AMAAIBtEIHKIAKVoVob+hI3gEW1R+jLTIJFtUfoy0zKILgy + nuAKLMyk8cwkAADSiUBlEIECZlN1hWYiAgUAAACsQgQqg/jNOI/vvCzXhP48vAoAALANIlAZfI7OUK0N + fYkbwKLaI/RlJsGi2iP0ZSZlEFwZT3AFFmbSeGYSAADpRKAyiEABs6m6QjMRgQIAAABWIQKVQQRqDNd/ + lm+/+rVcJwAAALKIQGUQgcpQrQ19iRvAotoj9GUmwaLaI/RlJmUQXBlPcAUWZtJ4ZhIAAOlEoDKIQAGz + qbpCMxGBAgAAAFYhgpNBBGqM9rBktR6Mcf/Wk3KdAAAAyCIClUEEKkO1NvQlbgCLao/Ql5kEi2qP0JeZ + lEFwZTzBFViYSeOZSQAApBOByiACBcym6grNRAQKAAAAWIUIVAYRqDHawedqPRijWiMAAADyiEBlEIHK + UK0NfYkbwKLaI/RlJsGi2iP0ZSZlEFwZT3AFFmbSeGYSAADpRKAyiEABs6m6QjMRgQIAAABWIQKVQQRq + jHawqloP+nPIDQAAYDtEoDKIQGWo1oa+xA1gUe0R+jKTYFHtEfoykzIIroznXjQszKTxzCQAANKJQGUQ + gQJmU3WFZiICBQAAAKxCBCqDCFR/HljN0g4aVusEAABAHp+pM4hAZajWhr7EDWBR7RH6MpNgUe0R+jKT + MgiujCe4AgszaTwzCQCAdCJQGUSggNlUXaGZiEABAAAAqxCByiAC1V879FytBWOcHj8r1wkAAIA8IlAZ + RKAyVGtDX+IGsKj2CH2ZSbCo9gh9mUkZBFfGE1yBhZk0npkEAEA6EagMIlDAbKqu0ExEoAAAAIBViEBl + EIHqrx2qqtaCMb47elquEwAAAHlEoDKIQGWo1oa+xA1gUe0R+jKTYFHtEfoykzIIrownuAILM2k8MwkA + gHQiUBlEoIDZVF2hmYhAAQAAAKsQgcogAtWXh1XzPDi8KNcKAACAPD5XZxCBylCtDX2JG8Ci2iP0ZSbB + otoj9GUmZRBcGU9wBRZm0nhmEgAA6USgMohAAbOpukIzEYECAAAAViEClUEEqq924LlaB8a5f+tJuVYA + AADkEYHKIAKVoVob+hI3gEW1R+jLTIJFtUfoy0zKILgynuAKLMyk8cwkAADSiUBlEIECZlN1hWYiAgUA + AACsQgQqgwhUX+1AVbUOjFOtEwAAAJlEoDKIQGWo1oa+xA1gUe0R+jKTYFHtEfoykzIIrownuAILM2k8 + MwkAgHQiUBlEoIDZVF2hmYhAAQAAAKsQgcogAtVPe0CyWgPG+fudl+VaAQAAkEkEKoMIVIZqbehL3AAW + 1R6hLzMJFtUeoS8zKYPgyniCK7Awk8YzkwAASCcClUEECphN1RWaiQgUAAAAsAoRqAwiUP040Jbnx9sv + yrUCAAAgkwhUBhGoDNXa0Je4ASyqPUJfZhIsqj1CX2ZSBvenxxNcgYWZNJ6ZBABAOhGoDCJQwGyqrtBM + RKAAAACAVYhAZRCB6sP1num7o6flegEAAJBJBCqDCFSGam3oS9wAFtUeoS8zCRbVHqEvMymD4Mp4giuw + MJPGM5MAAEgnApVBBAqYTdUVmokIFAAAALAKUZwMIlB9tIPO1d+fsb796tdyvQAAAMgkApVBBCpDtTb0 + JW4Ai2qP0JeZBItqj9CXmZRBcGU8wRVYmEnjmUkAAKQTgcogAgXMpuoKzUQECgAAAFiFCFQGEaib1671 + s5NX5d+fse4enJdrBgAAQCYRqAwiUBmqtaEvcQNYVHuEvswkWFR7hL7MpAyCK+MJrsDCTBrPTAIAIJ0I + VAYRKGA2VVdoJiJQAAAAwCpEoDKIQN289mBk9bdnrJ+/+b1cLwAAAHKJQGUQgcpQrQ19iRvAotoj9GUm + waLaI/RlJmUQXBlPcAUWZtJ4ZhIAAOlEoDKIQAGzqbpCMxGBAgAAAFYhApVBBOrmtUNU1d+esX68/aJc + LwAAAHKJQGUQgcpQrQ19iRvAotoj9GUmwaLaI/RlJmUQXBlPcAUWZtJ4ZhIAAOlEoDKIQAGzqbpCMxGB + AgAAAFYhApVBBOpmtYciq78743139LRcMwAAAHKJQGUQgcpQrQ19iRvAotoj9GUmwaLaI/RlJmUQXBlP + cAUWZtJ4ZhIAAOlEoDKIQAGzqbpCMxGBAgAAAFYhApVBBOpmtQNU1d+d8b796tdyzQAAAMglApVBBCpD + tTb0JW4Ai2qP0JeZBItqj9CXmZRBcGU8wRVYmEnjmUkAAKQTgcogAgXMpuoKzUQECgAAAFiFCFQGEaib + 0x6IrP7mZLh7cF6uGwAAALlEoDKIQGWo1oa+xA1gUe0R+jKTYFHtEfoykzIIrownuAILM2k8MwkAgHQi + UBlEoIDZVF2hmYhAAQAAAKsQgcogAnUz2vXdDk9Vf3PG+/udl+W6AQAAkE0EKoMIVIZqbehL3AAW1R6h + LzMJFtUeoS8zKYPgyniCK7Awk8YzkwAASCcClUEECphN1RWaiQgUAAAAsAoRqAwiUDfDTahsp8fPynUD + AAAgmwhUBhGoDNXa0Je4ASyqPUJfZhIsqj1CX2ZSBsGV8QRXYGEmjWcmAQCQzvn7DCJQwGyqrtBMRKAA + AACAVYhAZRCBWp9rO9+Dw4ty7QAAAMgmApVBBCpDtTb0JW4Ai2qP0JeZBItqj9CXmZRBcGU8wRVYmEnj + mUkAAKQTgcogAgXMpuoKzUQECgAAAFiFUE4GEaj1tUPN1d+aHG3+VGsHAABANhGoDCJQGaq1oS9xA1hU + e4S+zCRYVHuEvsykDIIr4wmuwMJMGs9MAgAgnQhUBhEoYDZVV2gmIlAAAADAKkSgMohArcvDqPn+fudl + uXYAAADk87k7gwhUhmpt6EvcABbVHqEvMwkW1R6hLzMpg+DKeIIrsDCTxjOTAABIJwKVQQQKmE3VFZqJ + CBQAAACwChGoDCJQ62oHpqq/MzkcOgcAANguEagMIlAZqrWhL98zwaLaI/RlJsGi2iP0ZSZlEFwZT3AF + FmbSeGYSAADpRKAyiEABs6m6QjMRgQIAAABWIQKVQQRqPW48bcODw4ty/QAAAMgnApVBBCpDtTb0JW4A + i2qP0JeZBItqj9CXmZRBcGU8wRVYmEnjmUkAAKRzFj+DCBQwm6orNBMRKAAAAGAVIlAZRKDW4XrejrsH + 5+UaAgAAkE8EKoMIVIZqbehL3AAW1R6hLzMJFtUeoS8zKYPgyniCK7Awk8YzkwAASCcClUEECphN1RWa + iQgUAAAAsArRnAwiUOtoB6Wqvy9Z/n7nZbl+AAAAbIMIVAYRqAzV2tCXuAEsqj1CX2YSLKo9Ql9mUgbB + lfEEV2BhJo1nJgEAkE4EKoMIFDCbqis0ExEoAAAAYBUiUBlEoL6cG07bcXr8rFxDAAAAtkEEKoMIVIZq + behL3AAW1R6hLzMJFtUeoS8zKYPgyniCK7Awk8YzkwAASOdMfgYRKGA2VVdoJiJQAAAAwCpEoDKIQH0Z + 1/G2fPvVr+U6AgAAsA0iUBlEoDJUa0Nf4gawqPYIfZlJsKj2CH2ZSRkEV8YTXIGFmTSemQQAQDoRqAwi + UMBsqq7QTESgAAAAgFWI52QQgfp8dw/O3xyQqv6u5Dk7eVWuIwAAANshApVBBCpDtTb0JW4Ai2qP0JeZ + BItqj9CXmZRBcGU8wRVYmEnjmUkAAKQTgcogAgXMpuoKzUQECgAAAFiFCFQGEajP1w4vV39TMjlsDgAA + sH0iUBlEoDJUa0Nfvm+CRbVH6MtMgkW1R+jLTMoguDKe4AoszKTxzCQAANKJQGUQgQJmU3WFZiICBQAA + AKxCBCqDCNTneXT0tPx7kssDqgAAANsnApXBZ+wM1drQl7gBLKo9Ql9mEiyqPUJfZlIGwZXxBFdgYSaN + ZyYBAJBOBCqDCBQwm6orNBMRKAAAAGAVIlAZRKCuz7W7TXcPzsv1BAAAYDtEoDKIQGWo1oa+xA1gUe0R + +jKTYFHtEfoykzIIrownuAILM2k8MwkAgHQiUBlEoIDZVF2hmYhAAQAAAKsQ0skgAnU97bpth6KqvyW5 + 2mHCaj0BAADYFhGoDCJQGaq1oS9xA1hUe4S+zCRYVHuEvsykDIIr4wmuwMJMGs9MAgAgnQhUBhEoYDZV + V2gmIlAAAADAKkSgMohAXc/jO/9V/h3J5uFUAACAOYhAZfA5O0O1NvQlbgCLao/Ql5kEi2qP0JeZlEFw + ZTzBFViYSeOZSQAApBOByiACBcym6grNRAQKAAAAWIUIVAYRqKs7PX5W/g3J1+ZNtaYAAABsiwhUBhGo + DNXa0Je4ASyqPUJfZhIsqj1CX2ZSBsGV8QRXYGEmjWcmAQCQTgQqgwgUMJuqKzQTESgAAABgFSJQGUSg + rsZNpe1qBwmrNQUAAGB7RKAyiEBlqNaGvsQNYFHtEfoyk2BR7RH6MpMyCK6MJ7gCCzNpPDMJAIB0zutn + EIECZlN1hWYiAgUAAACsQgQqgwjUpz06elr+7dgGD6YCAADMQwQqg8/aGaq1oS9xA1hUe4S+zCRYVHuE + vsykDIIr4wmuwMJMGs9MAgAgnQhUBhEoYDZVV2gmIlAAAADAKkSgMohAfVx7qLH6u7EdbdZUawsAAMD2 + iEBlEIHKUK0NfYkbwKLaI/RlJsGi2iP0ZSZlEFwZT3AFFmbSeGYSAADpRKAyiEABs6m6QjMRgQIAAABW + IQKVQQTqw+7f+uX12cmr8u/GNvx4+0W5tgAAAGyTCFQGEagM1drQl7gBLKo9Ql9mEiyqPUJfZlIGwZXx + BFdgYSaNZyYBAJBOBCqDCBQwm6orNBMRKAAAAGAVIlAZRKBqAlBz8FAqAADAXESgMvi8naFaG/oSN4BF + tUfoy0yCRbVH6MtMyiC4Mp7gCizMpPHMJAAA0olAZRCBAmZTdYVmIgIFAAAArEIEKoMI1PsEoObw8ze/ + l+sLAADAdolAZRCBylCtDX2JG8Ci2iP0ZSbBotoj9GUmZRBcGU9wBRZm0nhmEgAA6USgMohAAbOpukIz + EYECAAAAViEClUEE6l0CUPNwuBwAAGA+IlAZRKAyVGtDX75/gkW1R+jLTIJFtUfoy0zKILgynuAKLMyk + 8cwkAADSiUBlEIECZlN1hWYiAgUAAACsQgQqgwjUQgBqLt9+9Wu5zgAAAGyXCFQGEagM1drQl7gBLKo9 + Ql9mEiyqPUJfZlIGwZXxBFdgYSaNZyYBAAAAe1R1hWYiAgUAAACsQgQqgwjUv7WHSAWg5vHzN7+X6wwA + AMC2iUBlEIHKUK0NfYkbwKLaI/RlJsGi2iP0ZSZlEFwZT3AFFmbSeGYSAAAAsEdVV2gmIlAAAADAKkSg + MohA/Y83Dy5Wfxu2y8OoAAAAcxKByuBzd4ZqbehL3AAW1R6hLzMJFtUeoS8zKYPgyniCK7Awk8YzkwAA + AIA9qrpCMxGBAgAAAFYhApVh7xGo9u9f/V3YtjZfqvUGAABg20SgMohAZajWhr7EDWBR7RH6MpNgUe0R + +jKTMgiujCe4AgszaTwzCQAAANijqis0ExEoAAAAYBUiUBn2HIESgJqTQ+UAAADzEoHKIAKVoVob+vI9 + FCyqPUJfZhIsqj1CX2ZSBsGV8QRXYGEmjWcmAQAAAHtUdYVmIgIFAAAArEIEKsMeI1B3D85f/3T7Rfn3 + YPvu33pSrjsAAADbJwKVQQQqQ7U29CVuAItqj9CXmQSLao/Ql5mUQXBlPMEVWJhJ45lJAAAAwB5VXaGZ + iEABAAAAqxCByrC3CFS77tqhpupvwfa1Q4PVugMAADAHEagMIlAZqrWhL3EDWFR7hL7MJFhUe4S+zKQM + givjCa7Awkwaz0wCAAAA9qjqCs1EBAoAAABYhQhUhj1FoNqDomcnr8q/A3PwECoAAMDcRKAy+PydoVob + +hI3gEW1R+jLTIJFtUfoy0zKILgynuAKLMyk8cwkAAAAYI+qrtBMRKAAAACAVYhAZdhLBKr9e1b//szj + 529+L9ceAACAeYhAZRCBylCtDX2JG8Ci2iP0ZSbBotoj9GUmZRBcGU9wBRZm0nhmEgAAALBHVVdoJiJQ + AAAAwCpEoDLMHoFq15mDZPvgAVQAAID5iUBl8Bk8Q7U29CVuAItqj9CXmQSLao/Ql5mUwX3y8QRXYGEm + jWcmAQAAAHtUdYVmIgIFAAAArEIEKsPMEagHhxevz05elf/ezKfNlOo6AAAAYB4iUBlEoDJUa0Nf4gaw + qPYIfZlJsKj2CH2ZSRkEV8YTXIGFmTSemQQAAADsUdUVmokIFAAAALAKEagMM0ag7h6cv/7hr/8s/32Z + k4PkAAAA+yAClUEEKkO1NvTlOylYVHuEvswkWFR7hL7MpAyCK+MJrsDCTBrPTAIAAAD2qOoKzUQECgAA + AFiFCFSG2SJQDw4vXp+dvCr/XZlXmyfV9QAAAMBcRKAyiEBlqNaGvsQNYFHtEfoyk2BR7RH6MpMyCK6M + J7gCCzNpPDMJAAAA2KOqKzQTESgAAABgFSJQGWaJQLXryYGxfXKIHAAAYD9EoDKIQGWo1oa+fC8Fi2qP + 0JeZBItqj9CXmZTB/fPxBFdgYSaNZyYBAAAAe1R1hWYiAgUAAACsQgQqw9YjUHcPzt/8O5ydvCr//Zhf + myXVtQEAAMB8RKAyiEBlqNaGvsQNYFHtEfoyk2BR7RH6MpMyCK6MJ7gCCzNpPDMJAAAA2KOqKzQTESgA + AABgFSJQGbYcgXpwePHmgFL178U+OEAOAACwLyJQGUSgMlRrQ1++m4JFtUfoy0yCRbVH6MtMyiC4Mp7g + CizMpPHMJAAAAGCPqq7QTESgAAAAgFWIQGXYYgSqPfDpcBhNmyPVNQIAAMCcRKAyiEBlqNaGvsQNYFHt + Efoyk2BR7RH6MpMyuKc+nuAKLMyk8cwkAAAAYI+qrtBMRKAAAACAVYhAZdhSBEr8ibc5PA4AALA/IlAZ + RKAyVGtDX76fgkW1R+jLTIJFtUfoy0zK4N76eIIrsDCTxjOTAAAAgD2qukIzEYECAAAAViEClWELESjx + JypthlTXCwAAAPMSgcogApWhWhv6EjeARbVH6MtMgkW1R+jLTMrgHvt4giuwMJPGM5MAAACAPaq6QjMR + gQIAAABWIQKVITUCdffg/PWjo6cOgVFycBwAAGCfRKAyiEBlqNaGvnxHBYtqj9CXmQSLao/Ql5mUwb32 + 8QRXYGEmjWcmAQAAAHtUdYVmIgIFAAAArEIEKkNaBOr+rV/e/DOdnbwq/3mhafOjun4AAACYmwhUBhGo + DNXa0Je4ASyqPUJfZhIsqj1CX2ZSBsGV8QRXYGEmjWcmAQAAAHtUdYVmIgIFAAAArEIEKkNCBOruwfnr + R0dPHfjiShwaBwAA2C8RqAwiUBmqtaEv31PBotoj9GUmwaLaI/RlJmVw/308wRVYmEnjmUkAAADAHlVd + oZmIQAEAAACrEIHKMCoC1cJPD//yv94c8jo7eVX+s8Gf/fzN729mR3VNAQAAMD8RqAwiUBmqtaEvcQNY + VHuEvswkWFR7hL7MpAyCK+MJrsDCTBrPTAIAAAD2qOoKzUQECgAAAFiFCFSGnhGotuaPjp462MVn+/7r + 38prCwAAgH0QgcogApWhWhv6EjeARbVH6MtMgkW1R+jLTMrgvvx4giuwMJPGM5MAAACAPaq6QjMRgQIA + AABWIQKV4SYjUJfRp3bI9+zkVfnfD1f18ze/l9cZAAAA+yEClUEEKkO1NvQlbgCLao/Ql5kEi2qP0JeZ + lEFwZTzBFViYSeOZSQAAAMAeVV2hmYhAAQAAAKsQgcqwVgSqrefDv/yv16fHz98c3BJ9Ym0eMAUAAEAE + KoPP6BmqtaEvcQNYVHuEvswkWFR7hL7MpAyCK+MJrsDCTBrPTAIAAAD2qOoKzUQECgAAAFiFCFSGq0ag + 2nr97dYvrx8c/s/Xj46evok9/Xj7xeufv/m9/P8La3p852V5XQIAALAvIlAZRKAyVGtDX+IGsKj2CH2Z + SbCo9gh9mUkZBFfGE1yBhZk0npkEAAAA7FHVFZqJCBQAAACwChGoDI/v/NebQ7hNizq1Q1dNizs1Zyev + yv8c9NTmRTVHmM+Dw4v/nkkAo3371a/lrKKvFh+t1gdghGpO0ZcIVAYRqAzV2tCX14YMbSb9+TWb/qo9 + Ql/tge5qbejL/YwM1R6hr7YfqrWhL8GV8QRXMrT7PX9+zaa/th+qfUI/7QxYtTb01c7FVLMKAAAAuBlV + V2gmIlAAAADAKkSggKtoB6CqGcKc/u+v/5/yOgAYQdwgg4cCgCTVnKIvEagM3idlqNaGvnxvleGHv/6z + XB+AEUTFM1RrQ1/eJ2UQgRpPBCpD+x6jWh+AEdq5mGpWAQAAADej6grNRAQKAAAAWIUIFPApP3/zu1/N + 3hkRKCCJuEEGESggSTWn6EsEKoP3SRmqtaEvcYMMIlBAEhGoDNXa0Jf3SRlEoMYTgcogAgUkEYECAACA + vqqu0ExEoAAAAIBViEABn+Kh0v0RgQKSeB3KIAIFJKnmFH2JQGXwPilDtTb0JW6QQQQKSCIClaFaG/ry + PimDCNR4IlAZRKCAJCJQAAAA0FfVFZqJCBQAAACwChEo4GMe33lZzg7mJgIFJBE3yCACBSSp5hR9iUBl + 8D4pQ7U29CVukEEECkgiApWhWhv68j4pgwjUeCJQGUSggCQiUAAAANBX1RWaiQgUAAAAsAoRKOBj2oyo + ZgdzE4ECkogbZBCBApJUc4q+RKAyeJ+UoVob+hI3yCACBSQRgcpQrQ19eZ+UQQRqPBGoDCJQQBIRKAAA + AOir6grNRAQKAAAAWIUIFPAh33/9Wzk3mJ8IFJBE3CCDCBSQpJpT9CUClcH7pAzV2tCXuEEGESggiQhU + hmpt6Mv7pAwiUOOJQGUQgQKSiEABAABAX1VXaCYiUAAAAMAqRKCAys/f/F7ODPZBBApIIm6QQQQKSFLN + KfoSgcrgfVKGam3oS9wggwgUkEQEKkO1NvTlfVIGEajxRKAyiEABSUSgAAAAoK+qKzQTESgAAADg/2Pv + bnuruNL0b38D89DGBuyXDkEQgfA4oTH+JJYyIhJqNPqLSChIlpCQaBmFj73vKddNTzp9JeFhe62z1j5e + HO96Esy165py7Vq/rIUIFFCZdkO1M9gMIlBAEnGDDCJQQJJqT9GWCFQG90kZqtnQlrhBBhEoIIkIVIZq + NrTlPimDCFR/IlAZRKCAJCJQAAAA0FbVFRqJCBQAAACwFiJQwO89uvGq3BdsDhEoIIm4QQYRKCBJtado + SwQqg/ukDNVsaEvcIIMIFJBEBCpDNRvacp+UQQSqPxGoDCJQQBIRKAAAAGir6gqNRAQKAAAAWAsRKOC3 + jvfOy13BZhGBApKIG2QQgQKSVHuKtkSgMrhPylDNhrbEDTKIQAFJRKAyVLOhLfdJGUSg+hOByiACBSQR + gQIAAIC2qq7QSESgAAAAgLUQgQJ+a9oJ1a5gs4hAAUnEDTKIQAFJqj1FWyJQGdwnZahmQ1viBhlEoIAk + IlAZqtnQlvukDCJQ/YlAZRCBApKIQAEAAEBbVVdoJCJQAAAAwFqIQAEfPbrxqtwTbB4RKCCJuEEGESgg + SbWnaEsEKoP7pAzVbGhL3CCDCBSQRAQqQzUb2nKflEEEqj8RqAwiUEASESgAAABoq+oKjUQECgAAAFgL + EShgcrx3Xu4INpMIFJBE3CCDCBSQpNpTtCUClcF9UoZqNrQlbpBBBApIIgKVoZoNbblPyiAC1Z8IVAYR + KCCJCBQAAAC0VXWFRiICBQAAAKyFCBRwsv/rxS6odgSbSQQKSCJukEEECkhS7SnaEoHK4D4pQzUb2hI3 + yCACBSQRgcpQzYa23CdlEIHqTwQqgwgUkEQECgAAANqqukIjEYECAAAA1kIECni4/XO5H9hcIlBAEnGD + DCJQQJJqT9GWCFQG90kZqtnQlrhBBhEoIIkIVIZqNrTlPimDCFR/IlAZRKCAJCJQAAAA0FbVFRqJCBQA + AACwFiJQsNm8/E1FBApIIm6QQQQKSFLtKdoSgcrgPilDNRva8nwrgwgUkEQEKkM1G9pyn5RBBKo/EagM + IlBAEhEoAAAAaKvqCo1EBAoAAABYCxEo2FzHe+erg63Tcjew2USggCTiBhlEoIAk1Z6iLRGoDO6TMlSz + oS1xgwwiUEASEagM1Wxoy31SBhGo/kSgMohAAUlEoAAAAKCtqis0EhEoAAAAYC1EoGBzTdd/tRdABApI + Im6QQQQKSFLtKdoSgcrgPilDNRvaEjfIIAIFJBGBylDNhrbcJ2UQgepPBCqDCBSQRAQKAAAA2qq6QiMR + gQIAAADWQgQKNtPD7Z/LnQATESggibhBBhEoIEm1p2hLBCqD+6QM1WxoS9wggwgUkEQEKkM1G9pyn5RB + BKo/EagMIlBAEhEoAAAAaKvqCo1EBAoAAABYCxEo2DyHO6/LfQAfiUABScQNMohAAUmqPUVbIlAZ3Cdl + qGZDW+IGGUSggCQiUBmq2dCW+6QMIlD9iUBlEIECkohAAQAAQFtVV2gkIlAAAADAWohAwWY53jtfHWyd + lvsAPhKBApKIG2QQgQKSVHuKtkSgMrhPylDNhrbEDTKIQAFJRKAyVLOhLfdJGUSg+hOByiACBSQRgQIA + AIC2qq7QSESgAAAAgLUQgYLNMQWgpmu+2gXwWyJQQBJxgwwiUECSak/RlghUBvdJGarZ0Ja4QQYRKCCJ + CFSGaja05T4pgwhUfyJQGUSggCQiUAAAANBW1RUaiQgUAAAAsBYiULA57l9/Ue4B+D0RKCCJuEEGESgg + SbWnaEsEKoP7pAzVbGhL3CCDCBSQRAQqQzUb2nKflEEEqj8RqAwiUEASESgAAABoq+oKjUQECgAAAFgL + ESjYDI9uvCp3AFREoIAk4gYZRKCAJNWeoi0RqAzukzJUs6EtcYMMIlBAEhGoDNVsaMt9UgYRqP5EoDKI + QAFJRKAAAACgraorNBIRKAAAAGAtRKBgfIc7r8vrH/6ICBSQRNwggwgUkKTaU7QlApXBfVKGaja0JW6Q + QQQKSCIClaGaDW25T8ogAtWfCFQGESggiQgUAAAAtFV1hUYiAgUAAACshQgUjO3J7XfltQ9/RgQKSCJu + kEEECkhS7SnaEoHK4D4pQzUb2hI3yCACBSQRgcpQzYa23CdlEIHqTwQqgwgUkEQECgAAANqqukIjEYEC + AAAA1kIECsZ1vHd+cY1X1z78GREoIIm4QQYRKCBJtadoSwQqg/ukDNVsaEvcIIMIFJBEBCpDNRvacp+U + QQSqPxGoDCJQQBIRKAAAAGir6gqNRAQKAAAAWAsRKBjTyf6vAlB8MREoIIm4QQYRKCBJtadoSwQqg/uk + DNVsaEvcIIMIFJBEBCpDNRvacp+UQQSqPxGoDCJQQBIRKAAAAGir6gqNRAQKAAAAWAsRKBjT/esvymse + PoUIFJBE3CCDCBSQpNpTtCUClcF9UoZqNrQlbpBBBApIIgKVoZoNbblPyiAC1Z8IVAYRKCCJCBQAAAC0 + VXWFRiICBQAAAKyFCBSM5+H2z+X1Dp9KBApIIm6QQQQKSFLtKdoSgcrgPilDNRvaEjfIIAIFJBGBylDN + hrbcJ2UQgepPBCqDCBSQRAQKAAAA2qq6QiMRgQIAAADWQgQKxvLoxqvyWofPIQIFJBE3yCACBSSp9hRt + iUBlcJ+UoZoNbYkbZBCBApKIQGWoZkNb7pMyiED1JwKVQQQKSCICBQAAAG1VXaGRiEABAAAAayECBeM4 + 3HldXufwuUSggCTiBhlEoIAk1Z6iLRGoDO6TMlSzoS1xgwwiUEASEagM1Wxoy31SBhGo/kSgMohAAUlE + oAAAAKCtqis0EhEoAAAAYC1EoGAMXuJmnUSggCTiBhlEoIAk1Z6iLRGoDO6TMlSzoS3PxTKIQAFJRKAy + VLOhLfdJGUSg+hOByiACBSQRgQIAAIC2qq7QSESgAAAAgLUQgYLle3L73epg67S8xuFLiEABScQNMohA + AUmqPUVbIlAZ3CdlqGZDW+IGGUSggCQiUBmq2dCW+6QMIlD9iUBlEIECkohAAQAAQFtVV2gkIlAAAADA + WohAwbId750LQLF2IlBAEnGDDCJQQJJqT9GWCFQG90kZqtnQlrhBBhEoIIkIVIZqNrTlPimDCFR/IlAZ + RKCAJCJQAAAA0FbVFRqJCBQAAACwFiJQsFxTAGq6hqtrG76GCBSQRNwggwgUkKTaU7QlApXBfVKGaja0 + JW6QQQQKSCIClaGaDW25T8ogAtWfCFQGESggiQgUAAAAtFV1hUYiAgUAAACshQgULJMAFJdJBApIIm6Q + QQQKSFLtKdoSgcrgPilDNRvaEjfIIAIFJBGBylDNhrbcJ2UQgepPBCqDCBSQRAQKAAAA2qq6QiMRgQIA + AADWQgQKlkcAissmAgUkETfIIAIFJKn2FG2JQGVwn5Shmg1tiRtkEIECkohAZahmQ1vukzKIQPUnApVB + BApIIgIFAAAAbVVdoZGIQAEAAABrIQIFyyIARQsiUEAScYMMIlBAkmpP0ZYIVAb3SRmq2dCWuEEGESgg + iQhUhmo2tOU+KYMIVH8iUBlEoIAkIlAAAADQVtUVGokIFAAAALAWIlCwHAJQtCICBSQRN8ggAgUkqfYU + bYlAZXCflKGaDW2JG2QQgQKSiEBlqGZDW+6TMohA9ScClUEECkgiAgUAAABtVV2hkYhAAQAAAGshAgXL + IABFSyJQQBJxgwwiUECSak/RlghUBvdJGarZ0Ja4QQYRKCCJCFSGaja05T4pgwhUfyJQGUSggCQiUAAA + ANBW1RUaiQgUAAAAsBYiUJBPAIrWRKCAJOIGGUSggCTVnqItEagM7pMyVLOhLXGDDCJQQBIRqAzVbGjL + fVIGEaj+RKAyiEABSUSgAAAAoK2qKzQSESgAAABgLUSgIJsAFD2IQAFJxA0yiEABSao9RVsiUBncJ2Wo + ZkNb4gYZRKCAJCJQGarZ0Jb7pAwiUP2JQGUQgQKSiEABAABAW1VXaCQiUAAAAMBaiEBBLgEoehGBApKI + G2QQgQKSVHuKtkSgMrhPylDNhrbEDTKIQAFJRKAyVLOhLfdJGUSg+hOByiACBSQRgQIAAIC2qq7QSESg + AAAAgLUQgYJMAlD0JAIFJBE3yCACBSSp9hRtiUBlcJ+UoZoNbYkbZBCBApKIQGWoZkNb7pMyiED1JwKV + QQQKSCICBQAAAG1VXaGRiEABAAAAayECBXme3H63Otg6La9ZaEEECkgibpBBBApIUu0p2hKByuA+KUM1 + G9oSN8ggAgUkEYHKUM2GttwnZRCB6k8EKoMIFJBEBAoAAADaqrpCIxGBAgAAANZCBAqy/HDzjQAU3YlA + AUnEDTKIQAFJqj1FWyJQGdwnZahmQ1viBhlEoIAkIlAZqtnQlvukDCJQ/YlAZRCBApKIQAEAAEBbVVdo + JCJQAAAAwFqIQEEOL2KTQgQKSCJukEEECkhS7SnaEoHK4D4pQzUb2vJMLYMIFJBEBCpDNRvacp+UQQSq + PxGoDCJQQBIRKAAAAGir6gqNRAQKAAAAWAsRKMjw6Mar8hqFHkSggCTiBhlEoIAk1Z6iLRGoDO6TMlSz + oS1xgwwiUEASEagM1Wxoy31SBhGo/kSgMohAAUlEoAAAAKCtqis0EhEoAAAAYC1EoKC/h9s/l9cn9CIC + BSQRN8ggAgUkqfYUbYlAZXCflKGaDW2JG2QQgQKSiEBlqGZDW+6TMohA9ScClUEECkgiAgUAAABtVV2h + kYhAAQAAAGshAgX9nOz/unrwt/9XXpvQkwgUkETcIIMIFJCk2lO0JQKVwX1Shmo2tCVukEEECkgiApWh + mg1tuU/KIALVnwhUBhEoIIkIFAAAALRVdYVGIgIFAAAArIUIFPRxvHe+unv1WXldQm8iUEAScYMMIlBA + kmpP0ZYIVAb3SRmq2dCWuEEGESggiQhUhmo2tOU+KYMIVH8iUBlEoIAkIlAAAADQVtUVGokIFAAAALAW + IlDQ3pPb7y6uveqahAQiUEAScYMMIlBAkmpP0ZYIVAb3SRmq2dCWuEEGESggiQhUhmo2tOU+KYMIVH8i + UBlEoIAkIlAAAADQVtUVGokIFAAAALAWIlDQ1vSy9cHWaXk9QgoRKCCJuEEGESggSbWnaEsEKoP7pAzV + bGhL3CCDCBSQRAQqQzUb2nKflEEEqj8RqAwiUEASESgAAABoq+oKjUQECgAAAFgLESho59GNV+V1CGlE + oIAk4gYZRKCAJNWeoi0RqAzukzJUs6EtcYMMIlBAEhGoDNVsaMt9UgYRqP5EoDKIQAFJRKAAAACgraor + NBIRKAAAAGAtRKDg8p3s/7p68Lf/V16DkEgECkgibpBBBApIUu0p2hKByuA+KUM1G9oSN8ggAgUkEYHK + UM2GttwnZRCB6k8EKoMIFJBEBAoAAADaqrpCIxGBAgAAANZCBAou1/He+cV1Vl1/kEoECkgibpBBBApI + Uu0p2hKByuA+KUM1G9oSN8ggAgUkEYHKUM2GttwnZRCB6k8EKoMIFJBEBAoAAADaqrpCIxGBAgAAANZC + BAouzw8336wOtk7Law+SiUABScQNMohAAUmqPUVbIlAZ3CdlqGZDW+IGGUSggCQiUBmq2dCW+6QMIlD9 + iUBlEIECkohAAQAAQFtVV2gkIlAAAADAWohAweV4uP1zec3BEohAAUnEDTKIQAFJqj1FWyJQGdwnZahm + Q1viBhlEoIAkIlAZqtnQlvukDCJQ/YlAZRCBApKIQAEAAEBbVVdoJCJQAAAAwFqIQMF6He+dO1zA4olA + AUnEDTKIQAFJqj1FWyJQGdwnZahmQ1viBhlEoIAkvqfJUM2GttwnZRCB6i8xAjW9qzOZnrHcv/6P1Xd/ + +58L0/e0vzVdx5XDndf/9r97uP3yX/+M6Z85mf75B1un5b+/BxEoIMmT2/+M2pHQ0/T/o6v7Ddqyk/q7 + e/VZORva8lwvQzUb+vrtM4DJ758BfPu/O2x6DlDNEyBF1RUaiQgUAAAAsBYiULA+0wu8voxnBNMXhNVn + HKAHcYMMIlBAkmpP0db0EmE1G9pyn5Shmg1tTS8+V7OhLREoIInDYhmq2dCW+6QMIlD9tY5ATe/hfAw7 + Td+7Ttfi9zffXPwHpU72P5R/xss2/bunz+L05/gYkJr+jNMznlbvOIhAAWm+dUgeLniul8FO6s/3nxl8 + /5mhmg3LMT17eHL73cVzgI8BqY/BKKEooKeqKzQSESgAAABgLUSg4Oud7P+6erj9c3mNwRKJQAFJvNyT + QQQKSFLtKdryEnQG90kZqtnQlrhBBofFgCQiUBmq2dCW+6QMIlD9XVYEanrf5rehp56Rp681/bmnz+oU + iHq4/fJS4lAiUEAawRWYea6XwU7qz/efGXz/maGaDWOZIlFTKPpjJPrbq8/KzwLAOlVdoZGIQAEAAABr + IQIFX2d6kfOuLz4YjAgUkMTLPRlEoIAk1Z6iLS9BZ3CflKGaDW2JG2RwWAxIIgKVoZoNbblPyiAC1d86 + IlAfg09TJGk6KLnU2NPn+hiHmr4//towlAgUkEZwBWae62Wwk/rz/WcG339mqGbDZvgYiJ6uRWEoYN2q + rtBIRKAAAACAtRCBgi83fcmx7v/6JSQQgQKSeLkngwgUkKTaU7TlJegM7pMyVLOhLXGDDA6LAUlEoDJU + s6Et90kZRKD6+5II1PTs4+H2y4v5bUrw6VNNEaxpv0zPJaZ3jqq/v8r0v6/+eQC9CK7AzHO9DHZSf77/ + zOD7zwzVbNhMH+PQ0zOSaU9WnxeAT1V1hUYiAgUAAACshQgUfL7jvXMHCBiaCBSQxMs9GUSggCTVnqIt + L0FncJ+UoZoNbYkbZHBYDEjiO5wM1Wxoy31SBhGo/j4lAjW9OyP69GWmv99p39y//o8//Y9oiUABaQRX + YOa5XgY7qT/ff2bw/WeGajYw+W0U6turz8rPD8AfqbpCIxGBAgAAANZCBAo+z+HO6z99cRFGIAIFJPFy + TwYRKCBJtadoy0vQGdwnZahmQ1viBhkcFgOSiEBlqGZDW+6TMohA9VdFoKbv/KfnG9P3/9N/BKr6v+PL + /NFhUBEoII3gCsw818tgJ/Xn+88Mvv/MUM0GKh/D0NMOrT5LAL9VdYVGIgIFAAAArIUIFHya6cVPhwbY + FCJQQBIv92QQgQKSVHuKtrwEncF9UoZqNrQlbpDBYTEgie9zMlSzoS33SRlEoPr7GIH6GH6aro2T/Q/l + /5b1mv7up9DWFIQSgQLSCK7AzHO9DHZSf77/zOD7zwzVbOCvTM9apmcu03XsP7gNVKqu0EhEoAAAAIC1 + EIGCvza9lOjLCDaJCBSQxMs9GUSggCTVnqItL0FncJ+UoZoNbYkbZHBYDEgiApWhmg1tuU/KIALV38dD + iMJPAPyW4ArMPNfLYCf15/vPDL7/zFDNBj7Hx2cx96//o/yMAZup6gqNRAQKAAAAWAsRKPhjT26/c1CA + jSQCBSTxck8GESggSbWnaMtL0BncJ2WoZkNb4gYZHBYDkvhuJ0M1G9pyn5RBBAoAMgmuwMxzvQx2Un++ + /8zg+88M1WzgS03vHU7PKb+9+qz8vAGbo+oKjUQECgAAAFgLESj4Tyf7v64e3XhVXjOwCUSggCRe7skg + AgUkqfYUbXkJOoP7pAzVbGhL3CCDw2JAEhGoDNVsaMt9UgYRKADIJLgCM8/1MthJ/fn+M4PvPzNUs4F1 + mP4D3dN1frB1Wn72gLFVXaGRiEABAAAAayECBf9uegl3ui6q6wU2hQgUkMTLPRlEoIAk1Z6iLS9BZ3Cf + lKGaDW2JG2RwWAxIIgKVoZoNbblPyiACBQCZBFdg5rleBjupP99/ZvD9Z4ZqNrBOJ/sfLp5dOrMBm6Xq + Co1EBAoAAABYCxEomB3vnTsUAP8/ESggiZd7MohAAUmqPUVbXoLO4D4pQzUb2hI3yOCwGJDE9z0ZqtnQ + lvukDCJQAJBJcAVmnutlsJP68/1nBt9/ZqhmA5dlenY27eDqswiMpeoKjUQECgAAAFgLESg23cn+r6uH + 2z+X1wdsKhEoIImXezKIQAFJqj1FW16CzuA+KUM1G9oSN8jgsBiQRAQqQzUb2nKflEEECgAyCa7AzHO9 + DHZSf77/zOD7zwzVbOCyTe8n2gEwtqorNBIRKAAAAGAtRKDYZI9uvFodbJ2W1wZsMhEoIIkv9jOIQAFJ + qj1FW16CzuA+KUM1G9oSN8jgsBiQRAQqQzUb2nKflEEECgAyCa7AzHO9DHZSf77/zOD7zwzVbKAVMSgY + V9UVGokIFAAAALAWIlBsoh9uvrn47FfXBCACBWTxhX4GESggSbWnaMtL0BncJ2WoZkNb4gYZHBYDkohA + ZahmQ1vukzKIQAFAJsEVmHmul8FO6s/3nxl8/5mhmg20JgYF46m6QiMRgQIAAADWQgSKTTK9YOvFf/hr + IlBAEl/kZxCBApJUe4q2vASdwX1Shmo2tCVukMFhMSCJ74IyVLOhLfdJGUSgACCT4ArMPNfLYCf15/vP + DL7/zFDNBnoRg4JxVF2hkYhAAQAAAGshAsUmEH+CzyMCBSTxBX4GESggSbWnaMtL0BncJ2WoZkNb4gYZ + HBYDkvhOKEM1G9pyn5RBBAoAMgmuwMxzvQx2Un++/8zg+88M1Wygt+n9xfvXX5SfWWAZqq7QSESgAAAA + gLUQgWJk4k/wZUSggCRe7skgAgUkqfYUbXkJOoP7pAzVbGhL3CCDw2JAEt8NZahmQ1vukzKIQAFAJsEV + mHmul8FO6s/3nxl8/5mhmg2kmJ55Tmegqs8ukK3qCo1EBAoAAABYCxEoRiT+BF9HBApI4uWeDCJQQJJq + T9GWl6AzuE/KUM2GtsQNMjgsBiTxHVGGaja05T4pgwgUAGQSXIGZ53oZ7KT+fP+ZwfefGarZQJrDnddi + ULAwVVdoJCJQAAAAwFqIQDES8SdYDxEoIImXezKIQAFJqj1FW16CzuA+KUM1G9oSN8jgsBiQxHdFGarZ + 0Jb7pAwiUACQSXAFZp7rZbCT+vP9Zwbff2aoZgOJpnca7Q1YjqorNBIRKAAAAGAtRKBYupP9X/2XHGDN + RKCAJL6kzyACBSSp9hRteQk6g/ukDNVsaEvcIIPDYkASEagM1Wxoy31SBhEoAMgkuAIzz/Uy2En9+f4z + g+8/M1SzgWRPbv/TWRJYgKorNBIRKAAAAGAtRKBYqin+9OjGq9XB1mn52Qa+nAgUkMTLPRlEoIAk1Z6i + LS9BZ3CflKGaDW2JG2RwWAxIIgKVoZoNbblPyiACBQCZBFdg5rleBjupP99/ZvD9Z4ZqNrAE0/vv1Wca + yFB1hUYiAgUAAACshQgUSzO9JOvlfbhcIlBAEi/3ZBCBApJUe4q2vASdwX1Shmo2tCVukMFhMSCJ75Ey + VLOhLfdJGUSgACCT4ArMPNfLYCf15/vPDL7/zFDNBpZies9xOiNVfbaBvqqu0EhEoAAAAIC1EIFiCU72 + f109uvFqdffqT+XnGFgvESggiZd7MohAAUmqPUVbXoLO4D4pQzUb2hI3yOCwGJBEBCpDNRvacp+UQQQK + ADIJrsDMc70MdlJ/vv/M4PvPDNVsYGmmd+GrzzfQT9UVGokIFAAAALAWIlAkm16IvX/9xepg67T8/AKX + QwQKSOLlngwiUECSak/RlpegM7hPylDNhrbEDTI4LAYkEYHKUM2GttwnZRCBAoBMgisw81wvg53Un+8/ + M/j+M0M1G1ii6Z3H6bxU9TkH2qu6QiMRgQIAAADWQgSKNNNLsI9uvBJ+go5EoIAkXu7JIAIFJKn2FG15 + CTqD+6QM1WxoS9wgg8NiQBIRqAzVbGjLfVIGESgAyCS4AjPP9TLYSf35/jOD7z8zVLOBJXuw/bL8rANt + VV2hkYhAAQAAAGshAkWC473zi/CTl/IhgwgUkMTLPRlEoIAk1Z6iLS9BZ3CflKGaDW2JG2RwWAxI4vum + DNVsaMt9UgYRKADIJLgCM8/1MthJ/fn+M4PvPzNUs4Glm56VTmenqs880EbVFRqJCBQAAACwFiJQ9CL8 + BLlEoIAkXu7JIAIFJKn2FG15CTqD+6QM1WxoS9wgg8NiQBLfPWWoZkNb7pMyiEABQCbBFZh5rpfBTurP + 958ZfP+ZoZoNjGB6B/Lu1Z/Kzz1w+aqu0EhEoAAAAIC1EIGipekFV+EnyCcCBSTxck8GESggSbWnaMtL + 0BncJ2WoZkNb4gYZHBYDkvgeKkM1G9pyn5RBBAoAMgmuwMxzvQx2Un++/8zg+88M1WxgJNN78tVnH7hc + VVdoJCJQAAAAwFqIQHGZTvZ/vXi5ePpS7mDrtPwMAnlEoIAkXu7JIAIFJKn2FG15CTqD+6QM1WxoS9wg + g8NiQBIRqAzVbGjLfVIGESgAyCS4AjPP9TLYSf35/jOD7z8zVLOB0UzPTp1vgbaqrtBIRKAAAACAtRCB + Yp2m6NP0EuujG6+8YA8LJgIFJPFyTwYRKCBJtadoy0vQGdwnZahmQ1viBhkcFgOS+I4qQzUb2nKflEEE + CgAyCa7AzHO9DHZSf77/zOD7zwzVbGBE0zuR03mq6joA1q/qCo1EBAoAAABYCxEovsbvo0/+awgwBhEo + IImXezKIQAFJqj1FW16CzuA+KUM1G9oSN8jgsBiQRAQqQzUb2nKflEEECgAyCa7AzHO9DHZSf77/zOD7 + zwzVbGBUJ/sfVvevvyivBWC9qq7QSESgAAAAgLUQgeJzHO+dX7ws/HD75eru1Z/KzxSwfCJQQBIv92QQ + gQKSVHuKtrwEncF9UoZqNrQlbpDBYTEgiQhUhmo2tOU+KYMIFABkElyBmed6Geyk/nz/mcH3nxmq2cDo + pnfnq+sBWJ+qKzQSESgAAABgLUSgqJzs/7p6cvvdv4JP08vyB1un5WcIGI8IFJDEyz0ZRKCAJNWeoi0v + QWdwn5Shmg1tiRtkcFgMSCIClaGaDW25T8ogAgUAmQRXYOa5XgY7qT/ff2bw/WeGajawCQ53XpfXBLAe + VVdoJCJQAAAAwFqIQG2238eevrv+YvXtlf8uPyvA5hCBApJ4uSeDCBSQpNpTtOUl6AzukzJUs6EtcYMM + DosBSUSgMlSzoS33SRlEoAAgk+AKzDzXy2An9ef7zwy+/8xQzQY2xfQsz388HS5H1RUaiQgUAAAAsBYi + UGM73ju/iDz9cPPNxX+ZYAo9TV+Q3b36k4fTwB8SgQLgv6CyAADIrElEQVSSeLkngwgUkKTaU7TlJegM + 7pMyVLOhLXGDDA6LAUlEoDJUs6Et90kZRKAAIJPgCsw818tgJ/Xn+88Mvv/MUM0GNsn0ruR0zqq6PoAv + V3WFRiICBQAAAKyFCFS2KeL0W9MLopPphd3JFHaaYi0f407TS+1T4OnbK/9dzhvgU4hAAUm83JNBBApI + Uu0p2vISdAb3SRmq2dCWuEEGh8WAJCJQGarZ0Jb7pAwiUACQSXAFZp7rZbCT+vP9Zwbff2aoZgObRggK + 1q/qCo1EBAoAAAAAAAAAAAAAAIBLcffqM/+RAPiN72++WR1snZbXC3wq/2GuDIIrMBOBymAn9ScClUEE + KkM1G9hE0zOx6T/QXl0nwOerukIjEYECAAAAAAAAAAAAAABg7aYA1Mn+h/IQHGyyJ7ffCUHxVUSgMgiu + wEwEKoOd1J8IVAYRqAzVbGBTTc/GhKBgPaqu0EhEoAAAAAAAAAAAAAAAAFir6eCtABT8sad771d3xBr4 + QiJQGQRXYCYClcFO6k8EKoMIVIZqNrDp7Cf4elVXaCQiUAAAAAAAAAAAAAAAAKzNdKitOuwG/DshKL6U + CFQGwRWYiUBlsJP6E4HKILKSoZoNYEfB16q6QiMRgQIAAAAAAAAAAAAAAGAtBKDg8whB8SVEoDIIrsBM + BCqDndSfCFQGgZUM1WyAmT0FX67qCo1EBAoAAAAAAAAAAAAAAICvJgAFX0YIis8lApVBcAVmIlAZ7KT+ + RKAyiKtkqGYD/B+7Cr5M1RUaiQgUAAAAAAAAAAAAAAAAX0UACr6OEBSfQwQqg+AKzESgMthJ/YlAZRBW + yVDNBvh39hV8vqorNBIRKAAAAAAAAAAAAAAAAL6YABSshxAUn0oEKoPgCsxEoDLYSf2JQGUQVclQzQb4 + T3YWfJ6qKzQSESgAAAAAAAAAAAAAAAC+iIPOsF5TCOpg67S83uAjEagMgiswE4HKYCf153ejDIIqGarZ + ALX711+U1xHwn6qu0EhEoAAAAAAAAAAAAAAAAPhsd68+W53sfygPsAFf7sntd0JQ/CkRqAyCKzATgcpg + J/UnApVBBCpDNRugNj1bu3v1p/JaAv5d1RUaiQgUAAAAAAAAAAAAAAAAn+XOlR8FoOASPb71trz2YCIC + lUFwBWYiUBnspP5EoDKIQGWoZgP8MSEo+DRVV2gkIlAAAAAAAAAAAAAAAAB8sikA9XTvfXloDVifo92z + 8hoEEagMgiswE4HKYCf1JwKVQQQqQzUb4M9Nz9qmZ27VNQXMqq7QSESgAAAAAAAAAAAAAAAA+CQCUNDW + FPuprkU2mwhUBsEVmIlAZbCT+hOByiAClaGaDfDXhKDgz1VdoZGIQAEAAAAAAAAAAAAAAPCXDrZOV09u + /7M8pAZcHiEofk8EKoPgCsxEoDLYSf2JQGUQgcpQzQb4NE9uv7t4BlddW7Dpqq7QSESgAAAAAAAAAAAA + AAAA+EsO+EM/DrPzWyJQGQRXYOYeMYOd1J8IVAb3zRmq2QCf7mj3rLy2YNNVXaGRiEABAAAAAAAAAAAA + AADwpwRHoK+T/Q+ru1d/Kq9PNo+dnEFwBWYiUBnspP5EoDKIQGWoZgN8nun3vur6gk1WdYVGIgIFAAAA + AAAAAAAAAADAH3q4/bI8jAa09XTv/eqOwAP/SwQqg+AKzESgMthJ/YlAZRCBylDNBvh8D7ZfltcYbKqq + KzQSESgAAAAAAAAAAAAAAABKd68+Kw+hAX08uf1udbB1Wl6vbA4RqAyCKzATgcpgJ/UnApVBBCpDNRvg + y9y9+lN5ncEmqrpCIxGBAgAAAAAAAAAAAAAA4D/cufLj6une+/IAGtDP4c7r8pplc4hAZRBcgZkIVAY7 + qT8RqAwiUBmq2QBfZno2Nz2jq6412DRVV2gkIlAAAAAAAAAAAAAAAAD8hye3/1kePgP6e7D9srxu2Qwi + UBkEV2AmApXBTupPBCqDCFSGajbAl3ty+115rcGmqbpCIxGBAgAAAAAAAAAAAAAA4N8IjEC+u1d/Kq9f + xmdHZxBcgZkIVAY7qT8RqAwiUBmq2QBf53DndXm9wSapukIjEYECAAAAAAAAAAAAAADgX6ZDs9VhMyDL + 0733q4Ot0/I6ZmwiUBkEV2AmApXBTupPBCqDCFSGajbA13uw/bK85mBTVF2hkYhAAQAAAAAAAAAAAAAA + cOHOlR9XJ/sfyoNmQJ7Ht96W1zJjE4HKILgCMxGoDHZSfyJQGUSgMlSzAb7e9MxuenZXXXewCaqu0EhE + oAAAAAAAAAAAAAAAALjwdO99ecgMyPVg+2V5PTMuEagMgiswE4HKYCf1JwKVQQQqQzUbYD2mZ3cHW6fl + tQejq7pCIxGBAgAAAAAAAAAAAAAAYHW480t5uAzId+/a8/K6ZkwiUBkEV2AmApXBTupPBCqDCFSGajbA + +hzuvC6vPRhd1RUaiQgUAAAAAAAAAAAAAADAhpsOylaHyoBleLr3fnWwdVpe34xHBCqD4ArMRKAy2En9 + iUBlEIHKUM0GWK/711+U1x+MrOoKjUQECgAAAAAAAAAAAAAAYIPdufLjRUCmOlAGLMfhzuvyGmc8IlAZ + BFdgJgKVwU7qTwQqgwhUhmo2wHqd7H+4eKZXXYMwqqorNBIRKAAAAAAAAAAAAAAAgA12tHtWHiYDluf+ + 9Rfldc5YRKAyCK7ATAQqg53UnwhUBhGoDNVsgPV7fOtteQ3CqKqu0EhEoAAAAAAAAAAAAAAAADbUdEC2 + OkQGLNPJ/ofVwdZpeb0zDhGoDIIrMBOBymAn9ScClUEEKkM1G+ByPNh+WV6HMKKqKzQSESgAAAAAAAAA + AAAAAIANdOfKj6une+/LA2TAcn1/8015zTMOEagMgiswE4HKYCf1JwKVQQQqQzUb4HJMMejpGV91LcJo + qq7QSESgAAAAAAAAAAAAAAAANtDR7ll5eAxYvvvXX5TXPWMQgcoguAIzEagMdlJ/IlAZRKAyVLMBLs/j + W2/LaxFGU3WFRiICBQAAAAAAAAAAAAAAsGGmg7HVoTFgDE/33q8Otk7L65/lE4HKILgCMxGoDHZSfyJQ + GUSgMlSzAS6XGDSboOoKjUQECgAAAAAAAAAAAAAAYIPcufLjRSCmOjAGjONw53W5A1g+EagMgiswE4HK + YCf1JwKVQQQqQzUb4HKd7H8Qg2Z4VVdoJCJQAAAAAAAAAAAAAAAAG+Ro96w8LAaM59615+UeYNlEoDII + rsBMBCqDndSfCFQGEagM1WyAyycGzeiqrtBIRKAAAAAAAAAAAAAAAAA2xJ0rP5aHxIAxPb71ttwFLJsI + VAbBFZiJQGWwk/oTgcogApWhmg3Qhhg0I6u6QiMRgQIAAAAAAAAAAAAAANgQT/felwfEgHE92H5Z7gOW + SwQqg+AKzESgMthJ/YlAZRCBylDNBmhDDJqRVV2hkYhAAQAAAAAAAAAAAAAAbIDpMGx1OAwY28n+h9XB + 1mm5F1gmEagMgiswE4HKYCf1JwKVQQQqQzUboB0xaEZVdYVGIgIFAAAAAAAAAAAAAAAwuDtXflw93Xtf + HgwDxne487rcDSyTCFQGwRWYiUBlsJP6E4HKIAKVoZoN0I4YNKOqukIjEYECAAAAAAAAAAAAAAAYnGAI + MMXgqv3A8tjpGQRXYCYClcFO6k8EKoMIVIZqNkBb0++N1fUJS1Z1hUYiAgUAAAAAAAAAAAAAADCwKfxS + HQYDNsvjW2/LHcHyiEBlEFyBmQhUBjupPxGoDCJQGarZAG2d7H8Qg2Y4VVdoJCJQAAAAAAAAAAAAAAAA + AzvaPSsPgwGb59615+WeYFlEoDIIrsBMBCqDndSfCFQGEagM1WyA9qZngtU1CktVdYVGIgIFAAAAAAAA + AAAAAAAwqOm/+F8dAgM20+Nbb8tdwbKIQGUQXIGZCFQGO6k/EagMIlAZqtkAfYhBM5KqKzQSESgAAAAA + AAAAAAAAAIBBTf/F/+oAGLC5HABdPhGoDIIrMBOBymAn9ScClUEEKkM1G6APMWhGUnWFRiICBQAAAAAA + AAAAAAAAMKA7V34sD38Bm80B0OUTgcoguAIzEagMdlJ/IlAZRKAyVLMB+hGDZhRVV2gkIlAAAAAAAAAA + AAAAAAADOto9Kw9+ATgAumwiUBkEV2AmApXBTupPBCqDCFSGajZAP2LQjKLqCo1EBAoAAAAAAAAAAAAA + AGAwd678WB76Apg4ALpsIlAZBFdgJgKVwU7qTwQqgwhUhmo2QF9i0Iyg6gqNRAQKAAAAAAAAAAAAAABg + MEe7Z+WBL4CPHABdLhGoDIIrMBOBymAn9ScClUEEKkM1G6AvMWhGUHWFRiICBQAAAAAAAAAAAAAAMJA7 + V34sD3sB/JYDoMslApVBcAVmIlAZ7KT+RKAyiEBlqGYD9Dc9M6yuWViKqis0EhEoAAAAAAAAAAAAAACA + gRztnpUHvQB+79615+UeIZsIVAbBFZiJQGWwk/oTgcogApWhmg3Q3+HOL+U1C0tRdYVGIgIFAAAAAAAA + AAAAAAAwiOm/6F8d8gKoPL71ttwlZBOByiC4AjMRqAx2Un8iUBlEoDJUswH6O9n/sDrYOi2vW1iCqis0 + EhEoAAAAAAAAAAAAAACAQUwHXqtDXgB/xAHQ5RGByiC4AjMRqAx2Un8iUBlEoDJUswEyTL9PVtctLEHV + FRqJCBQAAAAAAAAAAAAAAMAgnu69Lw94AfwRB0CXRwQqg+AKzESgMthJ/YlAZRCBylDNBshwsv+hvG5h + Caqu0EhEoAAAAAAAAAAAAAAAAAYwHXatDncB/JnpAOjB1mm5V8gkApVBcAVmIlAZ7KT+RKAyiEBlqGYD + 5Lh//UV57UK6qis0EhEoAAAAAAAAAAAAAACAATy+9bY82AXwVx5svyz3CplEoDIIrsBMBCqDndSfCFQG + EagM1WyAHNMzxOrahXRVV2gkIlAAAAAAAAAAAAAAAAALd+fKj+WhLoBP4QDosohAZRBcgZkIVAY7qT8R + qAwiUBmq2QBZ7l79qbx+IVnVFRqJCBQAAAAAAAAAAAAAAMDCHe2elQe6AD7VvWvPy/1CHhGoDIIrMBOB + ymAn9ScClUEEKkM1GyDL9Htldf1CsqorNBIRKAAAAAAAAAAAAAAAgIV7uve+PNAF8KkcAF0OEagMgisw + E4HKYCf1JwKVQQQqQzUbIMvJ/ofy+oVkVVdoJCJQAAAAAAAAAAAAAAAAC/bd9RflYS6Az+EA6HKIQGUQ + XIGZCFQGO6k/EagMIlAZqtkAee5de15ew5Cq6gqNRAQKAAAAAAAAAAAAAABgwY52z8qDXACfywHQZRCB + yiC4AjMRqAx2Un8iUBlEoDJUswHyPL71tryGIVXVFRqJCBQAAAAAAAAAAAAAAMBCfbN1Wh7iAvgSU1Su + 2jVkEYHKILgCMxGoDHZSfyJQGUSgMlSzAfKc7H9YHWydltcxJKq6QiMRgQIAAAAAAAAAAAAAAFio6YBr + dYiLzfLk9ruLeM8Uhpk+E99df7G6e/Wn1bdX/vsP3bv2/OJ/93D75epw5/Xq8a23q+O98/Kfz+ZwAHQZ + RKAyCK7ATAQqg53UnwhUBhGoDNVsaGv6Hf/3zwAm0zUy/T7xw803F88Sqv9bNsuD7ZfldQyJqq7QSESg + AAAAAAAAAAAAAAAAFmo61Fcd4GJcJ/u/Xsx9ijdNBzjXHeyZ/nlTHGoKQzkQupkcnM8nApVBcAVmIlAZ + 7KT+RKAyuJfNUM2GtqbnBtVsKtOzhekZg2dMm+lzPivQW9UVGokIFAAAAAAAAAAAAAAAwALdufJjeXiL + 8Uzhp6Pds0uJPv2V6XM2HaQWhNocDoDmE4HKILgCMxGoDHZSfyJQGUSgMlSzoa2v+b1uCkNPzyCqfy5j + av2sCb5U1RUaiQgUAAAAAAAAAAAAAADAAk2HW6uDW4xjOrT5cPtlzGG8KQg1HQQ93jsv/7yM4WT/gwOg + 4USgMgiuwEwEKoOd1J8IVAYRqAzVbGhrHXHf6ffC6ZryDGB8D7Zflp8BSFN1hUYiAgUAAAAAAAAAAAAA + ALBAP9x8Ux7cYvmmw5r3rj0v555gikE5CDq25M8fIlApBFdgJgKVwU7qTwQqgwhUhmo2tLWOCNRvTb8j + Tv/M6t/F8q378wKXpeoKjUQECgAAAAAAAAAAAAAAYIFO9j+UB7dYrvT4U+XRjVdiUAM63PmlnDcZRKAy + CK7ATAQqg53UnwhUBhGoDNVsaOuyoj7fXX/hGcCApmeMB1un5cwhSdUVGokIFAAAAAAAAAAAAAAAwMI4 + YDyW6QDl0uJPv3Xnyo+ro92z8mdjmaYDoNWsySAClUFwBWYiUBnspP78jpZBBCpDNRvauqwI1EfTtSYG + NZYlP5dic1RdoZGIQAEAAAAAAAAAAAAAACyM4M44Ht14tTrYOi3nvDTTgUGHQMfhAGguEagMgiswE4HK + YCf1JwKVQQQqQzUb2rrsCNREEHoshzu/lHOGJFVXaCQiUAAAAAAAAAAAAAAAAAvzdO99eWCL5ZhiSXev + Pivnu2TfbJ06BDqIKTRUzZj+RKAyCK7ATAQqg53UnwhUBhGoDNVsaKtFBOqj6boThF6+6VljNV9IUnWF + RiICBQAAAAAAAAAAAAAAsCB3rvxYHtZiOQ53Xq8Otk7L+Y7i4fbL1cn+h/LnZxlaHhrm84hAZRBcgZkI + VAY7qT8RqAwiUBmq2dBW69/npmdVQlDL536CdFVXaCQiUAAAAAAAAAAAAAAAAAsyHWqtDmqR72T/19XD + 7Z/LuY7IIdDlGz1WtlQiUBkckIaZCFQGO6k/EagMIlAZqtnQVq+o73/tvC7/PCzDg+2X5VwhRdUVGokI + FAAAAAAAAAAAAAAAwIL8cPNNeVCLbFMM6e7VZ+VMRzaFoJ7cflf+nZDv3rXn5VzpSwQqg+AKzESgMthJ + /YlAZRCBylDNhrZ6RaAmj268Kv9M5Pv+5ptyppCi6gqNRAQKAAAAAAAAAAAAAABgQZ7uvS8PapFrCkBN + MaRqnpvgm63TiwOo1d8N2Q53filnSl8iUBkEV2AmApXBTupPBCqDCFSGaja01TMCNXm4/bL8c5HtZP9D + OU9IUXWFRiICBQAAAAAAAAAAAAAAsBB3rz4rD2mR68ntdxsdgPqto92z8u+IXL0PDlMTgcoguAIzEagM + dlJ/IlAZRKAyVLOhrYTf5abrsfqzkc09BcmqrtBIRKAAAAAAAAAAAAAAAAAWwgG6ZZkCUAdbp+UsN5UQ + 1PL4DOcRgcrgcDTMRKAy2En9iUBlEIHKUM2GtlKCvp5jLc+D7ZflLCFB1RUaiQgUAAAAAAAAAAAAAADA + QgjoLMfx3rl4zh/wOV6We9eel3OkHxGoDIIrMBOBymAn9ScClUEEKkM1G9pKiUBNhKCWZXpmU80RElRd + oZGIQAEAAAAAAAAAAAAAACzEk9vvygNaZJkCUHccxP9TP9x8U/7dkefB9styhvQjApVBcAVmIlAZ7KT+ + RKAyiEBlqGZDW0kRqIkQ1HI83XtfzhASVF2hkYhAAQAAAAAAAAAAAAAALMA3W6fl4SyyCEB9munzLGq2 + DEe7Z+UM6UcEKoPgCsxEoDLYSf2JQGUQgcpQzYa20iJQk0c3XpV/VvIcbJ2WM4Teqq7QSESgAAAAAAAA + AAAAAAAAFsCh4mW4e/VZOT/+0xTLmqJZ1d8jOZ7uvS/nRz8iUBkEV2AmApXBTurP72sZRKAyVLOhrcQI + 1EQIahnuXXtezg96q7pCIxGBAgAAAAAAAAAAAAAAWICH2y/Lg1nkeLj9czk7/tgUgjrZ/1D+fZLjYOu0 + nB99iEBlEFyBmQhUBjupPxGoDCJQGarZ0FZqBGoy/dmqPzM5Hmy/LGcHvVVdoZGIQAEAAAAAAAAAAAAA + ACzADzfflAezyHC487qcG3/tu+svyr9Tcty79rycHX2IQGUQXIGZCFQGO6k/EagMIlAZqtnQVnIE6put + 09Xx3nn55ybD0e5ZOTvoreoKjUQECgAAAAAAAAAAAAAAYAGe3H5XHsyiv+nw4sHWaTk3Ps1/7bwu/27J + 8GD7ZTk3+hCByiC4AjMRqAx2Un8iUBlEoDJUs6Gt5AjU5O7Vn8o/Nxme7r0v5wa9VV2hkYhAAQAAAAAA + AAAAAAAALEB1KIsMdxy6/2rfbJ1exLSqv1/6O9o9K+dGHyJQGQRXYCYClcFO6k8EKoMIVIZqNrSVHoGa + PNx+Wf7ZyVDNDHqrukIjEYECAAAAAAAAAAAAAAAId/fqs/JAFv0d7rwuZ8bnu3ftefl3TH9/v/2unBl9 + iEBlEFyBmQhUBjupPxGoDCJQGarZ0NYSIlCT6c9Z/fnpz70Fiaqu0EhEoAAAAAAAAAAAAAAAAMJ9d/1F + eSCLvo73zld3HIpbq//aeV3+XdPXyf6Hcl70IQKVwaFomIlAZbCT+hOByiAClaGaDW0tJQJ19+pP5Z+f + /uxTElVdoZGIQAEAAAAAAAAAAAAAAIQT/MjkQNz6fbN1ehEcqv6+6UtcIof/n5DBNQEzEagMdlJ/IlAZ + /I6WoZoNbS0lAjURg840/d5ZzQt6qrpCIxGBAgAAAAAAAAAAAAAACOdwfZ7jvfNyVny9h9svy79z+rp7 + 9adyXrQnApVBcAVm7lMz2En9iUBlEIHKUM2GtpYUgRKDznS0e1bOC3qqukIjEYECAAAAAAAAAAAAAAAI + Nx3eqw5k0Y/DxZdrimxVf+/04zOfQwQqg+AKzESgMthJ/YlAZXDPmqGaDW0tKQI18TtOnr/fflfOCnqq + ukIjEYECAAAAAAAAAAAAAAAI93TvfXkgiz6mQFE1J9ZnOrxd/d3Tz3Qot5oV7TkgnUFwBWYiUBnspP5E + oDKIQGWoZkNbS4tAfbN1ujrZ/1D+LPQxPYusZgU9VV2hkYhAAQAAAAAAAAAAAAAAhKsOY9GPg8VtOACa + 5Wj3rJwT7YlAZRBcgZkIVAY7qT8RqAx+V8tQzYa2lhaBmvg9J8/B1mk5K+il6gqNRAQKAAAAAAAAAAAA + AAAg2J0rP5YHsejjeO+8nBPr5wBoliUeIh6VayOD4ArMRKAy2En9iUBlEIHKUM2Gtpb4+9s3W6di0GHc + X5Cm6gqNRAQKAAAAAAAAAAAAAAAgmMPEWY52z8o5sX4OgGZ5uve+nBPtiUBlcCAaZiJQGeyk/vzelkEE + KkM1G9paasT3h5tvyp+HPu5de17OCXqpukIjEYECAAAAAAAAAAAAAAAI9t31F+VBLPq4e/Wnck5cDgdA + s1Qzoj0RqAyCKzATgcpgJ/UnApVBBCpDNRvaWmoEaooOVT8PfdippKm6QiMRgQIAAAAAAAAAAAAAAAj2 + cPtleRCL9o73zssZcXkcAM1ysHVazom2RKAyCK7ATAQqg53UnwhUBsGSDNVsaGupEajJyf6H8meivQfb + L8sZQS9VV2gkIlAAAAAAAAAAAAAAAADBxD5yHO78Us6Iy/PN1qkDoEEEJjL4/wsZXA8wE4HKYCf1JwKV + QQQqQzUb2lpyBGp69lL9TLTnORhpqq7QSESgAAAAAAAAAAAAAAAAgjlYn+PetefljLhcP9x8U86D9lwD + GUSgMgiuwMy9agY7qT8RqAwiUBmq2dDWkiNQ0++d1c9Ee0e7Z+WMoJeqKzQSESgAAAAAAAAAAAAAAIBg + 08G96iAWbZ3sfyjnw+V7uP2ynAntOVSfQQQqg+AKzESgMthJ/YlAZXC/mqGaDW0tOQL1zdbpxTOY6uei + rSV/jhhT1RUaiQgUAAAAAAAAAAAAAABAMBGoDA6+9XPnyo/lTGjPofoMIlAZBFdgJgKVwU7qTwQqg/vV + DNVsaGvpzzA8C8vw99vvyvlAL1VXaCQiUAAAAAAAAAAAAAAAAMGe7r0vD2LR1hRdqeZDGyf7H8q50Jbr + IIMIVAbBFZiJQGWwk/oTgcogApWhmg1tLT0CdbjzS/lz0db0TLKaD/RSdYVGIgIFAAAAAAAAAAAAAAAQ + TAQqw/3rL8r50MYPN9+Uc6EtEagMIlAZBFdgJgKVwU7qTwQqgwhUhmo2tLX0CNR0LVc/F22JQJGm6gqN + RAQKAAAAAAAAAAAAAAAgWHUIi/buXv2pnA9tHO78Us6Fto52z8r50JYIVAbBFZiJQGWwk/oTgcogApWh + mg1tLT0Cded///9a9XPRXjUf6KXqCo1EBAoAAAAAAAAAAAAAACBYdQCL9qrZ0M50mLuaC22JQGUQgcog + uAIzEagMdlJ/IlAZRKAyVLOhraVHoCbVz0V71Wygl6orNBIRKAAAAAAAAAAAAAAAgGDVASza+vvtd+Vs + aMeh+gwiUBlEoDIIrsBMBCqDndSf+9UMIlAZqtnQ1ggRqKd778ufjbYOtk7L+UAPVVdoJCJQAAAAAAAA + AAAAAAAAoe5c+bE8gEVbIxyeXDrXQgbXQgYRqAyCKzATgcpgJ/UnApVBBCpDNRvaGuF3t+lnqH422nKP + QZKqKzQSESgAAAAAAAAAAAAAAIBQwjcZvr/5ppwP7XyzdVrOhrZEoDKIQGVwGBpmIlAZ7KT+RKAyiEBl + qGZDWyP87uYeI4N7DJJUXaGRiEABAAAAAAAAAAAAAACEEoHKcLR7Vs6HtqrZ0JYIVAYRqAwOQ8NMoCGD + ndSfCFQGEagM1WxoSwSKdXGPQZKqKzQSESgAAAAAAAAAAAAAAIBQIlAZpuBKNR/aerr3vpwP7YhAZRCB + yuAwNMwEGjLYSf2JQGUQgcpQzYa2Rvjdze89GdxjkKTqCo1EBAoAAAAAAAAAAAAAACCUCFQGEagMIlD9 + iUBlcBg6g8PQMBOBymAn9ScClUEEKkM1G9oSgWJd3GOQpOoKjUQECgAAAAAAAAAAAAAAIJQIVAYRqAzT + IdbjvXM6+v7mm3I2tOUwdAaHoWEmApXBTupPBCqDCFSGaja0JQLFurjHIEnVFRqJCBQAAAAAAAAAAAAA + AEAoEagMIlBAEoehMzgMDTMRqAx2Un8iUBlEoDJUs6EtESjWxT0GSaqu0EhEoAAAAAAAAAAAAAAAAEKJ + QGUQgQKSOAydwWFomIlAZbCT+hOByiAClaGaDW2JQLEu7jFIUnWFRiICBQAAAAAAAAAAAAAAEEoEKoMI + FJDEYegMDkPDTAQqg53UnwhUBhGoDNVsaEsEinVxj0GSqis0EhEoAAAAAAAAAAAAAACAUCJQGUSggCQO + Q2dwGBpmIlAZ7KT+RKAyiEBlqGZDWyNEoNxjZHCPQZKqKzQSESgAAAAAAAAAAAAAAIBQIlAZRKCAJCJQ + GRyGhplAQwY7qT8RqAwiUBmq2dDWCBGoH26+KX822nKPQZKqKzQSESgAAAAAAAAAAAAAAIBQIlAZRKCA + JCJQGRyGhpkIVAY7qT8RqAwiUBmq2dDWCBGo6Weofjbaco9BkqorNBIRKAAAAAAAAAAAAAAAgFAiUBlE + oIAkIlAZHIaGmQhUBjupPxGoDCJQGarZ0NYIEaine+/Ln422DrZOy/lAD1VXaCQiUAAAAAAAAAAAAAAA + AKFEoDKIQAFJRKAyCK7ATAQqg53UnwhUBhGoDNVsaGuECFT1c9FeNRvopeoKjUQECgAAAAAAAAAAAAAA + IJQIVAYRKCCJCFQGwRWYiUBlsJP6E4HKIAKVoZoNbS09AnX36rPy56K9aj7QS9UVGokIFAAAAAAAAAAA + AAAAQCgRqAwiUEASEagMgiswE4HKYCf1JwKVQQQqQzUb2lp6BOq76y/Kn4u2nu69L+cDvVRdoZGIQAEA + AAAAAAAAAAAAAIQSgcogAgUkEYHKILgCMxGoDHZSfyJQGUSgMlSzoa2lR6AOd34pfy7aEoEiTdUVGokI + FAAAAAAAAAAAAAAAQCgRqAwiUEASEagMgiswE4HKYCf1JwKVQQQqQzUb2lp6BOrJ7Xflz0VbS/8cMZ6q + KzQSESgAAAAAAAAAAAAAAIBQIlAZRKCAJCJQGQRXYCYClcFO6k8EKoMIVIZqNrS15HjPN1un5c9EeyJQ + pKm6QiMRgQIAAAAAAAAAAAAAAAglApVBBApIIgKVQXAFZiJQGeyk/kSgMohAZahmQ1tLjvd8d/1F+TPR + 3tHuWTkj6KXqCo1EBAoAAAAAAAAAAAAAACCUCFQGESggiQhUBsEVmIlAZbCT+hOByiAClaGaDW0tOQI1 + hYeqn4n2PA8jTdUVGokIFAAAAAAAAAAAAAAAQCgRqAwOvQFJRKAyCK7ATAQqg53UnwhUBhGoDNVsaGvJ + EaiT/Q/lz0R7D7ZfljOCXqqu0EhEoAAAAAAAAAAAAAAAAEKJQGUQgQKSiEBlEFyBmQhUBjupPxGoDCJQ + GarZ0NZSI1DfXX9R/jz0cf9/51HNCXqpukIjEYECAAAAAAAAAAAAAAAIJQKVQQQKSCIClUFwBWYiUBns + pP5EoDKIQGWoZkNbS41A/XDzTfnz0Me9a8/LOUEvVVdoJCJQAAAAAAAAAAAAAAAAoUSgMohAAUlEoDII + rsBMBCqDndSfCFQGEagM1Wxoa4kRKM/A8ri/IE3VFRqJCBQAAAAAAAAAAAAAAEAoB+AyiEABSUSgMjgQ + DTMRqAx2Un8iUBlEoDJUs6GtJUagjnbPyp+Ffqo5QU9VV2gkIlAAAAAAAAAAAAAAAAChRKAyiEABSUSg + MgiuwEwEKoOd1J8IVAYRqAzVbGhraRGo6fnX07335c9CH9M8qllBT1VXaCQiUAAAAAAAAAAAAAAAAKFE + oDKIQAFJRKAyCK7ATAQqg53UnwhUBhGoDNVsaGtpESi/4+RZ2meIzVB1hUYiAgUAAAAAAAAAAAAAABBK + BCqDCBSQxAHpDIIrMBOBymAn9ScClUEEKkM1G9paUsBnevb1dO99+XPQz+HOL+W8oKeqKzQSESgAAAAA + AAAAAAAAAIBQIlAZRKCAJCJQGQRXYCYClcFO6k8EKoMIVIZqNrS1pAjU0e5Z+TPQ14Ptl+W8oKeqKzQS + ESgAAAAAAAAAAAAAAIBQIlAZRKCAJCJQGQRXYCYClcFO6k8EKoMIVIZqNrS1lAiU51657l17Xs4Meqq6 + QiMRgQIAAAAAAAAAAAAAAAjlMFwGESggiQhUBsEVmIlAZbCT+hOByiAClaGaDW0tJQL1dO99+eenv7tX + fypnBj1VXaGRiEABAAAAAAAAAAAAAACEEoHKIAIFJBGByiC4AjMRqAx2Un8iUBlEoDJUs6GtJUSg/F6T + 62T/Qzkz6K3qCo1EBAoAAAAAAAAAAAAAACCUCFQGESggicPSGQRXYCYClcFO6k8EKoMIVIZqNrSVHoHy + vCvbEiJibKaqKzQSESgAAAAAAAAAAAAAAIBQDsVlEIECkohAZRBcgZkIVAY7qT8RqAwiUBmq2dBWesTn + 6d778s9NhqPds3Ju0FvVFRqJCBQAAAAAAAAAAAAAAEAoEagMIlBAEhGoDIIrMBOBymAn9ScClUEEKkM1 + G9pKjkAd7vxS/pnJ8WD7ZTk76K3qCo1EBAoAAAAAAAAAAAAAACCUCFQGESggiQhUBsEVmIlAZbCT+hOB + yiAClaGaDW2lRqD8LrMM9649L+cHvVVdoZGIQAEAAAAAAAAAAAAAAIQSgcogAgUkcXA6g+AKzESgMthJ + /YlAZRCBylDNhrYSI1D3r78o/6zkqeYHCaqu0EhEoAAAAAAAAAAAAAAAAEKJQGUQgQKSiEBlEFyBmQhU + BjupPxGoDCJQGarZ0FZaBOru1Werk/0P5Z+VLH+//a6cISSoukIjEYECAAAAAAAAAAAAAAAIJQKVQQQK + SCIClUFwBWYiUBnspP5EoDKIQGWoZkNbSRGo6dnW07335Z+TPIc7v5RzhARVV2gkIlAAAAAAAAAAAAAA + AAChRKAyiEABSUSgMgiuwEwEKoOd1J8IVAYRqAzVbGgrJQIlALU896+/KGcJCaqu0EhEoAAAAAAAAAAA + AAAAAEKJQGUQgQKSiEBlEFyBmQhUBjupPxGoDCJQGarZ0FZCBEoAapmmuVXzhARVV2gkIlAAAAAAAAAA + AAAAAAChRKAyiEABSUSgMgiuwEwEKoOd1J8IVAYRqAzVbGirdwTq7tVnq5P9D+WfjVzHe+flPCFF1RUa + iQgUAAAAAAAAAAAAAABAKBGoDCJQQBIRqAyCKzATgcpgJ/UnApVBBCpDNRva6hmBmq5DAahlOto9K2cK + Kaqu0EhEoAAAAAAAAAAAAAAAAEKJQGUQgQKSiEBlEFyBmQhUBjupPxGoDCJQGarZ0FavCJTfVZbNDiVd + 1RUaiQgUAAAAAAAAAAAAAABAKBGoDCJQQBIHqzMIrsBMBCqDndSfCFQGAZMM1Wxoq3UE6mDr9OLfWf1Z + WI7pOWQ1X0hRdYVGIgIFAAAAAAAAAAAAAAAQSgQqgwgUkEQEKoPgCsxEoDLYSf2JQGUQgcpQzYa2Wkag + pv33dO99+edgOf5++105X0hSdYVGIgIFAAAAAAAAAAAAAAAQSgQqgwgUkEQEKoPgCsxEoDLYSf2JQGUQ + gcpQzYa2WkSgDrZOV4c7v5T/fpZnmmU1Z0hSdYVGIgIFAAAAAAAAAAAAAAAQSgQqgwgUkEQEKoPgCsxE + oDLYSf2JQGUQgcpQzYa2LjsC9XD75epk/0P572aZ7l17Xs4aklRdoZGIQAEAAAAAAAAAAAAAAIQSgcog + AgUkEYHKILgCMxGoDHZSfyJQGUSgMlSzoa3LikBNu+7J7X+W/06W63jvvJw3pKm6QiMRgQIAAAAAAAAA + AAAAAAglApVBBApIIgKVQXAFZiJQGeyk/kSgMohAZahmQ1vrjkBN19b0z6z+XSzf0e5ZOXdIU3WFRiIC + BQAAAAAAAAAAAAAAEEoEKoMIFJBEBCqD4ArMRKAy2En9iUBlEIHKUM2GttYRgZqeSU2/e5zsfyj/HYzj + /vUX5WcA0lRdoZGIQAEAAAAAAAAAAAAAAIQSgcogAgUkEYHKILgCMxGoDHZSfyJQGUSgMlSzoa0vjUBN + z6Eebr+8+L+v/rmMZ4p8VZ8FSFR1hUYiAgUAAAAAAAAAAAAAABBKBCqDCBSQRAQqg+AKzESgMthJ/YlA + ZRCBylDNhrY+JQJ1sHW6+vbqs4vo09Hu2ep477z8ZzG2afbV5wMSVV2hkYhAAQAAAAAAAAAAAAAAhBKB + yiACBSQRgcoguAIzEagMdlJ/IlAZRKAyVLOhrb/ffnexl+5f/8fqu7/9z4Xp94gp+PP9zTeCT/zL/esv + yusYElVdoZGIQAEAAAAAAAAAAAAAAIQSgcogAgUkEYHKILgCMxGoDHZSfyJQGUSgMlSzAfJMMbDqGoZU + VVdoJCJQAAAAAAAAAAAAAAAAoUSgMohAAUlEoDIIrsBMBCqDndSfCFQGEagM1WyAPEe7Z+U1DKmqrtBI + RKAAAAAAAAAAAAAAAABCiUBlEIECkohAZRBcgZkIVAY7qT8RqAwiUBmq2QB57l17Xl7DkKrqCo1EBAoA + AAAAAAAAAAAAACCUCFQGESggiQhUBsEVmIlAZbCT+hOByiAClaGaDZDleO+8vH4hWdUVGokIFAAAAAAA + AAAAAAAAQCgRqAwiUEASEagMgiswE4HKYCf1JwKVQQQqQzUbIIt9yRJVXaGRiEABAAAAAAAAAAAAAACE + EoHKIAIFJBGByiC4AjMRqAx2Un8iUBlETTJUswGyTM8cq+sXklVdoZGIQAEAAAAAAAAAAAAAAIQSgcog + AgUkEYHKILgCMxGoDHZSfyJQGUSgMlSzAXIc7Z6V1y6kq7pCIxGBAgAAAAAAAAAAAAAACCUClUEECkgi + ApVBcAVmIlAZ7KT+RKAyiEBlqGYD5Lh37Xl57UK6qis0EhEoAAAAAAAAAAAAAACAUCJQGUSggCQiUBkE + V2AmApXBTupPBCqDCFSGajZAhuO98/K6hSWoukIjEYECAAAAAAAAAAAAAAAIJQKVQQQKSCIClUFwBWYi + UBnspP5EoDKIQGWoZgNksCdZsqorNBIRKAAAAAAAAAAAAAAAgFAiUBlEoIAkIlAZBFdgJgKVwU7qTwQq + g7hJhmo2QH/He+flNQtLUXWFRiICBQAAAAAAAAAAAAAAEEoEKoMIFJBEBCqD4ArMRKAy2En9iUBlEIHK + UM0G6O/RjVflNQtLUXWFRiICBQAAAAAAAAAAAAAAEEoEKoMIFJBEBCqD4ArMRKAy2En9iUBlEIHKUM0G + 6G96zlhds7AUVVdoJCJQAAAAAAAAAAAAAAAAoUSgMohAAUlEoDIIrsBMBCqDndSfCFQGEagM1WyAvo52 + z8rrFZak6gqNRAQKAAAAAAAAAAAAAAAglAhUBhEoIIkIVAbBFZiJQGWwk/oTgcogApWhmg3Q1/SMsbpe + YUmqrtBIRKAAAAAAAAAAAAAAAABCiUBlEIECkohAZRBcgZkIVAY7qT8RqAwiUBmq2QD9HO2eldcqLE3V + FRqJCBQAAAAAAAAAAAAAAEAoEagMIlBAEhGoDIIrMBOBymAn9ScClUEEKkM1G6Cf6flida3C0lRdoZGI + QAEAAAAAAAAAAAAAAIQSgcogAgUkEYHKILgCMxGoDHZSfyJQGUSgMlSzAfo42j0rr1NYoqorNBIRKAAA + AAAAAAAAAAAAgFAiUBlEoIAkIlAZBFdgJgKVwU7qTwQqgwhUhmo2QB/Ts8XqOoUlqrpCIxGBAgAAAAAA + AAAAAAAACCUClUEECkgiApVBcAVmIlAZ7KT+RKAyiEBlqGYDtPfoxqvyGoWlqrpCIxGBAgAAAAAAAAAA + AAAACCUClUEECkgiApVBcAVmIlAZ7KT+RKAyiEBlqGYDtHW8d37xXLG6RmGpqq7QSESgAAAAAAAAAAAA + AAAAQolAZRCBApKIQGUQXIGZCFQGO6k/EagMIlAZqtkAbdmHjKjqCo1EBAoAAAAAAAAAAAAAACCUCFQG + ESggiQhUBsEVmIlAZbCT+hOByiB6kqGaDdDO8d55eW3C0lVdoZGIQAEAAAAAAAAAAAAAAIQSgcogAgUk + EYHKILgCMxGoDHZSfyJQGUSgMlSzAdq5f/1FeW3C0lVdoZGIQAEAAAAAAAAAAAAAAIQSgcogAgUkEYHK + ILgCMxGoDHZSfyJQGUSgMlSzAdo42j0rr0sYQdUVGokIFAAAAAAAAAAAAAAAQCgRqAwiUEASEagMgisw + E4HKYCf1JwKVQQQqQzUboI3pWWJ1XcIIqq7QSESgAAAAAAAAAAAAAAAAQolAZRCBApKIQGUQXIGZCFQG + O6k/EagMIlAZqtkAl+/RjVflNQmjqLpCIxGBAgAAAAAAAAAAAAAACCUClUEECkgiApVBcAVmIlAZ7KT+ + RKAyiEBlqGYDXK7jvfPyeoSRVF2hkYhAAQAAAAAAAAAAAAAAhBKByiACBSQRgcoguAIzEagMdlJ/IlAZ + RKAyVLMBLtf0DLG6HmEkVVdoJCJQAAAAAAAAAAAAAAAAoUSgMohAAUlEoDIIrsBMBCqDndSfCFQGEagM + 1WyAy3O487q8FmE0VVdoJCJQAAAAAAAAAAAAAAAAoUSgMohAAUlEoDIIrsBMBCqDndSfCFQGEagM1WyA + y3G8d7462Dotr0UYTdUVGokIFAAAAAAAAAAAAAAAQCgRqAwiUEASEagMgiswE4HKYCf1JwKVQQQqQzUb + 4HLcu/a8vA5hRFVXaCQiUAAAAAAAAAAAAAAAAKFEoDKIQAFJRKAyCK7ATAQqg53UnwhUBhGoDNVsgPV7 + dONVeQ3CqKqu0EhEoAAAAAAAAAAAAAAAAEKJQGUQgQKSiEBlEFyBmQhUBjupPxGoDCJQGarZAOt1vHde + Xn8wsqorNBIRKAAAAAAAAAAAAAAAgFAiUBlEoIAkIlAZBFdgJgKVwU7qTwQqgwhUhmo2wHpNzwyr6w9G + VnWFRiICBQAAAAAAAAAAAAAAEEoEKoMIFJBEBCqD4ArMRKAy2En9iUBlEIHKUM0GWJ9HN16V1x6MruoK + jUQECgAAAAAAAAAAAAAAIJQIVAYRKCCJCFQGwRWYiUBlsJP6E4HKIAKVoZoNsB5Hu2fldQeboOoKjUQE + CgAAAAAAAAAAAAAAIJQIVAYRKCCJCFQGwRWYiUBlsJP6E4HKIAKVoZoN8PWO984vnhVW1x1sgqorNBIR + KAAAAAAAAAAAAAAAgFAiUBlEoIAkIlAZBFdgJgKVwU7qTwQqgwhUhmo2wNcTgGLTVV2hkYhAAQAAAAAA + AAAAAAAAhBKByiACBSQRgcoguAIzEagMdlJ/IlAZRKAyVLMBvs6jG6/K6w02SdUVGokIFAAAAAAAAAAA + AAAAQCgRqAwiUEASEagMgiswE4HKYCf1JwKVQQQqQzUb4Msd7rwurzXYNFVXaCQiUAAAAAAAAAAAAAAA + AKFEoDKIQAFJRKAyCK7ATAQqg53UnwhUBhGoDNVsgC9zvHe+Otg6La812DRVV2gkIlAAAAAAAAAAAAAA + AAChRKAyiEABSUSgMgiuwEwEKoOd1J8IVAYRqAzVbIDPNwWgpmeD1XUGm6jqCo1EBAoAAAAAAAAAAAAA + ACCUCFQGESggiQhUBsEVmIlAZbCT+hOByiAClaGaDfD57l59Vl5jsKmqrtBIRKAAAAAAAAAAAAAAAABC + iUBlEIECkohAZRBcgZkIVAY7qT8RqAwiUBmq2QCf5+H2z+X1BZus6gqNRAQKAAAAAAAAAAAAAAAglAhU + BhEoIIkIVAbBFZiJQGWwk/oTgcogApWhmg3w6R7deFVeW7Dpqq7QSESgAAAAAAAAAAAAAAAAQolAZRCB + ApKIQGUQXIGZCFQGO6k/EagMIlAZqtkAn+Zw53V5XQEiUItXDRUAAAAAAAAAAAAAAGAJRKAyiEABSUSg + MgiuwEwEKoOd1J8IVAYRqAzVbIC/9vjW2/KaAmZVV2gkIlAAAAAAAAAAAAAAAAChRKAyiEABSUSgMgiu + wEwEKoOd1J8IVAYRqAzVbIA/d7x3vjrYOi2vKWBWdYVGIgIFAAAAAAAAAAAAAAAQSgQqgwgUkEQEKoPg + CsxEoDLYSf2JQGUQgcpQzQb4Y1MAanoGWF1PwP+pukIjEYECAAAAAAAAAAAAAAAIJQKVQQQKSCIClUFw + BWYiUBnspP5EoDKIQGWoZgPUBKDg01VdoZGIQAEAAAAAAAAAAAAAAIQSgcogAgUkEYHKILgCMxGoDHZS + fyJQGUSgMlSzAf6TABR8nqorNBIRKAAAAAAAAAAAAAAAgFAiUBlEoIAkIlAZBFdgJgKVwU7qTwQqgwhU + hmo2wL8TgILPV3WFRiICBQAAAAAAAAAAAAAAEEoEKoMIFJBEBCqD4ArMRKAy2En9iUBlEIHKUM0G+D8C + UPBlqq7QSESgAAAAAAAAAAAAAAAAQolAZRCBApKIQGUQXIGZCFQGO6k/EagMIlAZqtkAMwEo+HJVV2gk + IlAAAAAAAAAAAAAAAAChRKAyiEABSUSgMgiuwEwEKoOd1J8IVAYRqAzVbAABKPhaVVdoJCJQAAAAAAAA + AAAAAAAAoUSgMohAAUlEoDIIrsBMBCqDndSfCFQGEagM1Wxg0wlAwderukIjEYECAAAAAAAAAAAAAAAI + JQKVQQQKSCIClUFwBWYiUBnspP5EoDKIQGWoZgObTAAK1qPqCo1EBAoAAAAAAAAAAAAAACCUCFQGESgg + iQhUBsEVmIlAZbCT+hOByiAClaGaDWwqAShYn6orNBIRKAAAAAAAAAAAAAAAgFAiUBlEoIAkIlAZBFdg + JgKVwU7qTwQqgwhUhmo2sIme3H4nAAVrVHWFRiICBQAAAAAAAAAAAAAAEEoEKoMIFJBEBCqD4ArMRKAy + 2En9iUBlEIHKUM0GNs3jW29XB1un5TUCfJmqKzQSESgAAAAAAAAAAAAAAIBQIlAZRKCAJCJQGQRXYCYC + lcFO6k8EKoMIVIZqNrBJjnbPymsD+DpVV2gkIlAAAAAAAAAAAAAAAAChRKAyiEABSUSgMgiuwEwEKoOd + 1J8IVAYRqAzVbGBTPLrxqrwugK9XdYVGIgIFAAAAAAAAAAAAAAAQSgQqgwgUkEQEKoPgCsxEoDLYSf2J + QGUQgcpQzQY2wcPtn8trAliPqis0EhEoAAAAAAAAAAAAAACAUCJQGUSggCQiUBkEV2AmApXBTupPBCqD + CFSGajYwspP9X1f3rj0vrwdgfaqu0EhEoAAAAAAAAAAAAAAAAEKJQGUQgQKSiEBlEFyBmQhUBjupPxGo + DCJQGarZwKiO984vnt9V1wKwXlVXaCQiUAAAAAAAAAAAAAAAAKFEoDKIQAFJRKAyCK7ATAQqg53UnwhU + BhGoDNVsYERHu2erg63T8joA1q/qCo1EBAoAAAAAAAAAAAAAACCUCFQGESggiQhUBsEVmIlAZbCT+hOB + yiAClaGaDYzm4fbP5ecfuDxVV2gkIlAAAAAAAAAAAAAAAAChRKAyiEABSUSgMgiuwEwEKoOd1J8IVAYR + qAzVbGAUx3vnq3vXnpeffeByVV2hkYhAAQAAAAAAAAAAAAAAhBKByiACBSQRgcoguAIzEagMdlJ/IlAZ + RKAyVLOBETy+9fbiWV31uQcuX9UVGokIFAAAAAAAAAAAAAAAQCgRqAwiUEASEagMgiswE4HKYCf1JwKV + QQQqQzUbWLqH2z+Xn3egnaorNBIRKAAAAAAAAAAAAAAAgFAiUBlEoIAkIlAZBFdgJgKVwU7qTwQqgwhU + hmo2sFTHe+ere9eel591oK2qKzQSESgAAAAAAAAAAAAAAIBQIlAZRKCAJCJQGQRXYCYClcFO6k8EKoMI + VIZqNrBEhzuvVwdbp+XnHGiv6gqNRAQKAAAAAAAAAAAAAAAglAhUBhEoIIkIVAbBFZiJQGWwk/oTgcog + ApWhmg0syfHe+eretefl5xvop+oKjUQECgAAAAAAAAAAAAAAIJQIVAYRKCCJCFQGwRWYiUBlsJP6E4HK + IAKVoZoNLMXhzuvVwdZp+dkG+qq6QiMRgQIAAAAAAAAAAAAAAAglApVBBApIIgKVQXAFZiJQGeyk/kSg + MohAZahmA+mO985X9649Lz/TQIaqKzQSESgAAAAAAAAAAAAAAIBQIlAZRKCAJCJQGQRXYCYClcFO6k8E + KoMIVIZqNpDs0Y1Xq4Ot0/LzDOSoukIjEYECAAAAAAAAAAAAAAAIJQKVQQQKSCIClUFwBWYiUBnspP5E + oDKIQGWoZgOJHt96u7p79Vn5OQbyVF2hkYhAAQAAAAAAAAAAAAAAhBKByiACBSQRgcoguAIzEagMdlJ/ + IlAZRKAyVLOBJMd756v711+Un18gV9UVGokIFAAAAAAAAAAAAAAAQCgRqAwiUEASEagMgiswE4HKYCf1 + JwKVQQQqQzUbSHCy/+vq0Y1Xq4Ot0/KzC2SrukIjEYECAAAAAAAAAAAAAAAIJQKVQQQKSCIClUFwBWYi + UBnspP5EoDKIQGWoZgO9He68Fn+Chau6QiMRgQIAAAAAAAAAAAAAAAglApVBBApIIgKVQXAFZiJQGeyk + /kSgMohAZahmA708vvX24vla9VkFlqXqCo1EBAoAAAAAAAAAAAAAACCUCFQGESggiQhUBsEVmIlAZbCT + +hOByiAClaGaDbQ2xZ/uXXtefkaBZaq6QiMRgQIAAAAAAAAAAAAAAAglApVBBApIIgKVQXAFZiJQGeyk + /kSgMohAZahmA62IP8G4qq7QSESgAAAAAAAAAAAAAAAAQolAZRCBApKIQGUQXIGZCFQGO6k/EagMIlAZ + qtnAZTrZ/3V1uPP64jla9ZkExlB1hUYiAgUAAAAAAAAAAAAAABBKBCqDCBSQRAQqg+AKzESgMthJ/YlA + ZRCBylDNBi7DFH96dOPV6mDrtPwsAmOpukIjEYECAAAAAAAAAAAAAAAIJQKVQQQKSCIClUFwBWYiUBns + pP5EoDKIQGWoZgPr9PjW24vrXfwJNkvVFRqJCBQAAAAAAAAAAAAAAEAoEagMIlBAEhGoDIIrMBOBymAn + 9ScClUEEKkM1G/haJ/u/rg53Xq/uXXtefu6A8VVdoZGIQAEAAAAAAAAAAAAAAIQSgcogAgUkEYHKILgC + MxGoDHZSfyJQGUSgMlSzgS/1+Nbbi2v7YOu0/LwBm6PqCo1EBAoAAAAAAAAAAAAAACCUCFQGESggiQhU + BsEVmIlAZbCT+hOByiAClaGaDXyOKfz0cPul8BPwb6qu0EhEoAAAAAAAAAAAAAAAAEKJQGUQgQKSiEBl + EFyBmQhUBjupPxGoDCJQGarZwF8RfgL+StUVGokIFAAAAAAAAAAAAAAAQCgRqAwiUEASEagMgiswE4HK + YCf1JwKVQQQqQzUb+L2T/V9XR7tnF9et8BPwKaqu0EhEoAAAAAAAAAAAAAAAAEKJQGUQgQKSiEBlEFyB + mQhUBjupPxGoDCJQGarZwBR9enzr7erRjVere9eel58dgD9TdYVGIgIFAAAAAAAAAAAAAAAQSgQqgwgU + kEQEKoPgCsxEoDLYSf2JQGUQgcpQzYbN8/vo08HWafl5AfhUVVdoJCJQAAAAAAAAAAAAAAAAoUSgMohA + AUlEoDIIrsBMBCqDndSfCFQGEagM1WwY28fg0+HO64vr8Nsr/11+NgC+RtUVGokIFAAAAAAAAAAAAAAA + QCgRqAwiUEASEagMgiswE4HKYCf1JwKVQQQqQzUbxnC8d756cvvd6mj3bPVw++Xqu+svBJ+AZqqu0EhE + oAAAAAAAAAAAAAAAAEKJQGUQgQKSiEBlEFyBmQhUBjupPxGoDCJQGarZkO1k/9d/BZ5+uPnmIvI0/d4x + XVMfQ08HW6flvAFaqbpCIxGBAgAAAAAAAAAAAAAACCUClUEECkgiApVBcAVmIlAZ7KT+RKAyiEBlqGZD + fyf7H1aPb7298NvQ03d/+5/V/ev/uNhjk+lZlOATkKjqCo1EBAoAAAAAAAAAAAAAACCUCFQGESggiQhU + BsEVmIlAZbCT+hOByiAClaGaDcs0haOe3H53EY76/uab1eHO69XD7Zf/ikZNz62qzwDAZai6QiMRgQIA + AAAAAAAAAAAAAAglApVBBApIIgKVQXAFZiJQGeyk/kSgMohAZahmw9g+hqI+RqKmnfjt1Wfl5wPgS1Vd + oZGIQAEAAAAAAAAAAAAAAIQSgcogAgUkEYHKILgCMxGoDHZSfyJQGUSgMlSzYXNNgajvb775VxzqYOu0 + /NwA/JWqKzQSESgAAAAAAAAAAAAAAIBQIlAZRKCAJCJQGQRXYCYClcFO6k8EKoMIVIZqNvBbJ/sfVo9v + vb343UYYCvhUVVdoJCJQAAAAAAAAAAAAAAAAoUSgMohAAUlEoDIIrsBMBCqDndSfCFQGEagM1Wzgrzy5 + /W71/c03F9fxt1eflZ8tYLNVXaGRiEABAAAAAAAAAAAAAACEEoHKIAIFJBGByiC4AjMRqAx2Un8iUBlE + oDJUs4HPdbL/4SIK9XD7pSgUcKHqCo1EBAoAAAAAAAAAAAAAACCUCFQGESggiQhUBsEVmIlAZbCT+hOB + yiAClaGaDXytp3vvV0e7ZxfX+fS8rPrsAWOrukIjEYECAAAAAAAAAAAAAAAIJQKVQQQKSCIClUFwBWYi + UBnspP5EoDKIQGWoZgPr9vjW29XD7Zerb68+Kz+HwHiqrtBIRKAAAAAAAAAAAAAAAABCiUBlEIECkohA + ZRBcgZkIVAY7qT8RqAwiUBmq2cBlerr3fnW0e3axi6vPJDCGqis0EhEoAAAAAAAAAAAAAACAUCJQGUSg + gCQiUBkEV2AmApXBTupPBCqDCFSGajbQiiAUjKvqCo1EBAoAAAAAAAAAAAAAACCUCFQGESggiQhUBsEV + mIlAZbCT+hOByiAClaGaDfQwBaEOd15fPF+rPqvAslRdoZGIQAEAAAAAAAAAAAAAAIQSgcogAgUkEYHK + ILgCMxGoDHZSfyJQGUSgMlSzgd6e3H53sSMEoWC5qq7QSESgAAAAAAAAAAAAAAAAQolAZRCBApKIQGUQ + XIGZCFQGO6k/EagMIlAZqtlAkqPds4u9XX1+gVxVV2gkIlAAAAAAAAAAAAAAAAChRKAyiEABSUSgMgiu + wEwEKoOd1J8IVAYRqAzVbCDR0733F3tjev5WfZaBLFVXaCQiUAAAAAAA/x97d7fbV3nu/f4MTJwYO40t + daMJK3UggWBekjgba6qwwUalqalKU5ZYJSKsaDEfVwKiWo1U4UeJsLQ2egYcwXMEPYKeAWcwj8OrI2Pl + AcoVyIs97t+4x2fjs9FKLcn/Gvflv4d0fwEAAAAAAAAIJQKVQQQKSCIClUFwBUYiUBnspPZEoDKIQGWo + ZgPpdjYOxKAgXNUV6okIFAAAAAAAAAAAAAAAQCgRqAwiUEASEagMgiswEoHKYCe1JwKVQQQqQzUbmIv3 + fvVXuwRCVV2hnohAAQAAAAAAAAAAAAAAhBKByiACBSQRgcoguAIjEagMdlJ7IlAZhFsyVLOBubm1+chO + gTBVV6gnIlAAAAAAAAAAAAAAAAChRKAyiEABSUSgMgiuwEgEKoOd1J4IVAbBlgzVbGCunsSghnd01fMO + TKfqCvVEBAoAAAAAAAAAAAAAACCUCFQGESggiQhUBsEVGIlAZbCT2hOByiAClaGaDczdEIMafhcTg4J2 + qq5QT0SgAAAAAAAAAAAAAAAAQolAZRCBApKIQGUQXIGRCFQGO6k9EagMIlAZqtlAL8SgoJ2qK9QTESgA + AAAAAAAAAAAAAIBQIlAZRKCAJCJQGQRXYCQClcFOak8EKoMIVIZqNtCbJzGo6gwAp6PqCvVEBAoAAAAA + AAAAAAAAACCUCFQGl/qAJCJQGQRXYCQClcFOak8EKoMIVIZqNtCrIQZl98A0qq5QT0SgAAAAAAAAAAAA + AAAAQolAZRCBApKIQGUQXIGRCFQGO6k9EagMQiwZqtlA78Sg4PRVXaGeiEABAAAAAAAAAAAAAACEEoHK + IAIFJBGByiC4AiMRqAx2UnsiUBkEWDJUs4GleO9Xf338Pq86G8DLqbpCPRGBAgAAAAAAAAAAAAAACCUC + lUEECkgiApVBcAVGIlAZ7KT2RKAyiEBlqGYDS7OzcSAGBSes6gr1RAQKAAAAAAAAAAAAAAAglAhUBhEo + IIkIVAbBFRiJQGWwk9oTgcogApWhmg0s0a3NR8dX1/bLcwI8v6or1BMRKAAAAAAAAAAAAAAAgFAiUBlE + oIAkIlAZBFdgJAKVwU5qTwQqgwhUhmo2sGRDDGp4x1edF+DZVV2hnohAAQAAAAAAAAAAAAAAhBKByiAC + BSQRgcoguAIjEagMdlJ7IlAZRKAyVLMB/t/jnY0DMSh4CVVXqCciUAAAAAAAAAAAAAAAAKFEoDKIQAFJ + RKAyCK7ASAQqg53UnghUBhGoDNVsgNGtzUd2FbygqivUExEoAAAAAAAAAAAAAACAUCJQGUSggCQiUBkE + V2AkApXBTmpPBCqDsEqGajbAj+1sHDx+71edIaBWdYV6IgIFAAAAAAAAAAAAAAAQSgQqgwgUkEQEKoPg + CoxEoDLYSe2JQGUQgcpQzQb4qVubj+wteA5VV6gnIlAAAAAAAAAAAAAAAAChRKAyiEABSUSgMgiuwEgE + KoOd1J4IVAYxlQzVbICn29k4ePwOsDpPwPeqrlBPRKAAAAAAAAAAAAAAAABCiUBlEIECkohAZRBcgZEI + VAY7qT0RqAwiUBmq2QA/79bmIzsMfkHVFeqJCBQAAAAAAAAAAAAAAEAoEagMIlBAEhGoDIIrMBKBymAn + tScClUFAJUM1G+DZ7GwcPH4fWJ0tWLqqK9QTESgAAAAAAAAAAAAAAIBQIlAZRKCAJCJQGQRXYCQClcFO + ak8EKoMIVIZqNsCzu7X56PjymTvl+YIlq7pCPRGBAgAAAAAAAAAAAAAACCUClUEECkgiApVBcAVGIlAZ + 7KT2RKAyiEBlqGYDPD/vo+DHqq5QT0SgAAAAAAAAAAAAAAAAQolAZXDpDkgiApVBcAVGIlAZ7KT2RKAy + iEBlqGYDvJj3fvXXx+8Hq7MGS1N1hXoiAgUAAAAAAAAAAAAAABBKBCqDCBSQRAQqg+AKjESgMthJ7YlA + ZRCBylDNBnhxtzYfHW+v3i3PGyxJ1RXqiQgUAAAAAAAAAAAAAABAKBGoDCJQQBIRqAyCKzASgcpgJ7Un + ApVBBCpDNRvg5Xk/xdJVXaGeiEABAAAAAAAAAAAAAACEEoHK4JIdkEQEKoPgCoxEoDLYSe2JQGUQgcpQ + zQY4Ge+cf/D4fWF19qB3VVeoJyJQAAAAAAAAAAAAAAAAoUSgMohAAUlEoDIIrsBIBCqDndSeCFQGEagM + 1WyAk3Nr85EQFItUdYV6IgIFAAAAAAAAAAAAAAAQSgQqgwgUkEQEKoPgCoxEoDLYSe2JQGUQgcpQzQY4 + WbtbR8dXzt4rzyD0quoK9UQECgAAAAAAAAAAAAAAIJQIVAYRKCCJCFQGwRUYiUBlsJPaE4HKIAKVoZoN + cDq8s2JJqq5QT0SgAAAAAAAAAAAAAAAAQolAZXChDkgiApVBcAVGIlAZ7KT2RKAyiEBlqGYDnJ7r6/eP + L67slecRelJ1hXoiAgUAAAAAAAAAAAAAABBKBCqDCBSQRAQqg+AKjESgMthJ7YlAZRCBylDNBjhdNy4c + Pn6PWJ1J6EXVFeqJCBQAAAAAAAAAAAAAAEAoEagMIlBAEhGoDIIrMBKBymAntScClUEEKkM1G+D03dp8 + JARF16quUE9EoAAAAAAAAAAAAAAAAEKJQGUQgQKSiEBlEFyBkQhUBjupPRGoDCJQGarZANPY3To6vnzm + Tnk2Ye6qrlBPRKAAAAAAAAAAAAAAAABCiUBlEIECkohAZRBcgZEIVAY7qT0RqAwiUBmq2QDTurq2X55P + mLOqK9QTESgAAAAAAAAAAAAAAIBQIlAZRKCAJCJQGQRXYCQClcFOak8EKoMIVIZqNsD0vM+iN1VXqCci + UAAAAAAAAAAAAAAAAKFEoDK4NAckEYHKILgCIxGoDHZSeyJQGUSgMlSzAdrwToueVF2hnohAAQAAAAAA + AAAAAAAAhBKByuDCHJBEBCqD4AqMRKAy2EntiUBlEIHKUM0GaOf6+v3yrMLcVF2hnohAAQAAAAAAAAAA + AAAAhBKByiACBSQRgcoguAIjEagMdlJ7IlAZRKAyVLMB2trZOCjPK8xJ1RXqiQgUAAAAAAAAAAAAAABA + KBGoDCJQQBIRqAyCKzASgcpgJ7UnApVBBCpDNRugvRsXDo8vruyV5xbmoOoK9UQECgAAAAAAAAAAAAAA + IJQIVAYRKCCJCFQGwRUYiUBlsJPaE4HKIAKVoZoNkEEIijmrukI9EYECAAAAAAAAAAAAAAAIJQKVQQQK + SCIClUFwBUYiUBnspPZEoDKIQGWoZgPkEIJirqquUE9EoAAAAAAAAAAAAAAAAEKJQGUQgQKSiEBlEFyB + kQhUBjupPRGoDCJQGarZAFlubT56/N6xOsOQquoK9UQECgAAAAAAAAAAAAAAIJQIVAYRKCCJCFQGwRUY + iUBlsJPaE4HKIAKVoZoNkEcIirmpukI9EYECAAAAAAAAAAAAAAAIJQKVQQQKSCIClUFwBUYiUBnspPZE + oDKIQGWoZgNkGkJQF1f2yrMMaaquUE9EoAAAAAAAAAAAAAAAAEKJQGUQgQKSiEBlEFyBkQhUBjupPRGo + DCJQGarZALluXDgUgmIWqq5QT0SgAAAAAAAAAAAAAAAAQolAZRCBApKIQGUQXIGRCFQGO6k9EagMIlAZ + qtkA2YSgmIOqK9QTESgAAAAAAAAAAAAAAIBQIlAZRKCAJCJQGQRXYCQClcFOak8EKoMIVIZqNkA+ISjS + VV2hnohAAQAAAAAAAAAAAAAAhBKByiACBSQRgcoguAIjEagMdlJ7IlAZRKAyVLMB5mFn46A815Cg6gr1 + RAQKAAAAAAAAAAAAAAAglAhUBhEoIIkIVAbBFRiJQGWwk9oTgcogApWhmg0wH0JQpKq6Qj0RgQIAAAAA + AAAAAAAAAAglApVBBApIIgKVQXAFRiJQGeyk9kSgMohAZahmA8yLd2EkqrpCPRGBAgAAAAAAAAAAAAAA + CCUClcHFNyCJCFQGwRUYiUBlsJPaE4HKIAKVoZoNMD/eh5Gm6gr1RAQKAAAAAAAAAAAAAAAglAhUBpfe + gCQiUBkEV2AkApXBTmpPBCqDCFSGajbAPF1d2y/PObRQdYV6IgIFAAAAAAAAAAAAAAAQSgQqgwgUkEQE + KoPgCoxEoDLYSe2JQGUQgcpQzQaYrytn75VnHaZWdYV6IgIFAAAAAAAAAAAAAAAQSgQqgwgUkEQEKoPg + CoxEoDLYSe2JQGUQgcpQzQaYr92to+PLZ+6U5x2mVHWFeiICBQAAAAAAAAAAAAAAEEoEKoMIFJBEBCqD + 4AqMRKAy2EntiUBlEIHKUM0GmLdbm48ev6eszjxMpeoK9UQECgAAAAAAAAAAAAAAIJQIVAYRKCCJCFQG + wRUYiUBlsJPaE4HKIAKVoZoNMH9DCOriyl557mEKVVeoJyJQAAAAAAAAAAAAAAAAoUSgMohAAUlEoDII + rsBIBCqDndSeCFQGEagM1WyAPrz3q7+W5x6mUHWFeiICBQAAAAAAAAAAAAAAEEoEKoMIFJBEBCqD4AqM + RKAy2EntiUBlEIHKUM0G6Mf19fvl2YfTVnWFeiICBQAAAAAAAAAAAAAAEEoEKoMIFJBEBCqD4AqMRKAy + 2EntiUBlEIHKUM0G6MvVtf3y/MNpqrpCPRGBAgAAAAAAAAAAAAAACCUClUEECkgiApVBcAVGIlAZ7KT2 + RKAyiEBlqGYD9OfymTvlDoDTUnWFeiICBQAAAAAAAAAAAAAAEEoEKoMIFJBEBCqD4AqMRKAy2EntiUBl + EIHKUM0G6M+tzUeP311WewBOQ9UV6okIFAAAAAAAAAAAAAAAQCgRqAwiUEASEagMgiswEoHKYCe1JwKV + QQQqQzUboE/v/eqv5R6A01B1hXoiAgUAAAAAAAAAAAAAABBKBCqDCBSQRAQqg+AKjESgMthJ7YlAZRCB + ylDNBujX9fX75S6Ak1Z1hXoiAgUAAAAAAAAAAAAAABBKBCqDCBSQRAQqg+AKjESgMthJ7YlAZRCBylDN + Buib/csUqq5QT0SgAAAAAAAAAAAAAAAAQolAZRCBApKIQGUQXIGRCFQGO6k9EagMIiQZqtkAfdvdOnr8 + HrPaCXBSqq5QT0SgAAAAAAAAAAAAAAAAQolAZRCBApKIQGUQXIGRCFQGO6k9EagMIlAZqtkA/btx4fD4 + 4speuRfgJFRdoZ6IQAEAAAAAAAAAAAAAAIQSgcogAgUkEYHKILgCIxGoDHZSeyJQGUSgMlSzAZbh+vr9 + ci/ASai6Qj0RgQIAAAAAAAAAAAAAAAglApVBBApIIgKVQXAFRiJQGeyk9kSgMohAZahmAyzHlbP3yt0A + L6vqCvVEBAoAAAAAAAAAAAAAACCUCFQGESggiQhUBsEVGIlAZbCT2hOByiAClaGaDbAcu1tHj99pVvsB + XkbVFeqJCBQAAAAAAAAAAAAAAEAoEagMIlBAEhGoDIIrMBKBymAntScClUEEKkM1G2BZ3vvVX8v9AC+j + 6gr1RAQKAAAAAAAAAAAAAAAglAhUBhEoIIkIVAbBFRiJQGWwk9oTgcogApWhmg2wPFfX9ssdAS+q6gr1 + RAQKAAAAAAAAAAAAAAAglAhUBhEoIIkIVAbBFRiJQGWwk9oTgcogApWhmg2wTJfP3Cn3BLyIqivUExEo + AAAAAAAAAAAAAACAUCJQGUSggCQiUBkEV2AkApXBTmpPBCqDCFSGajbAMt24cFjuCXgRVVeoJyJQAAAA + AAAAAAAAAAAAoUSgMohAAUlEoDIIrsBIBCqDndSeCFQGEagM1WyA5fJejZNSdYV6IgIFAAAAAAAAAAAA + AAAQSgQqg8tqQBIRqAyCKzASgcpgJ7UnApVBBCpDNRtg2S6fuVPuC3geVVeoJyJQAAAAAAAAAAAAAAAA + oUSgMohAAUlEoDIIrsBIBCqDndSeCFQGEagM1WyAZbtx4bDcF/A8qq5QT0SgAAAAAAAAAAAAAAAAQolA + ZRCBApKIQGUQXIGRCFQGO6k9EagMIlAZqtkAeL/Gy6q6Qj0RgQIAAAAAAAAAAAAAAAglApXBJTUgiQhU + BsEVGIlAZbCT2hOByiAClaGaDcDu1tHjd53V3oBnUXWFeiICBQAAAAAAAAAAAAAAEEoEKoMIFJBEBCqD + 4AqMRKAy2EntiUBlEIHKUM0GYPDer/5a7g14FlVXqCciUAAAAAAAAAAAAAAAAKFEoDKIQAFJRKAyCK7A + SAQqg53UnghUBhGoDNVsAJ64urZf7g74JVVXqCciUAAAAAAAAAAAAAAAAKFEoDKIQAFJRKAyCK7ASAQq + g53UnghUBhGoDNVsAJ7Y3To6vriyV+4P+DlVV6gnIlAAAAAAAAAAAAAAAAChRKAyiEABSUSgMgiuwEgE + KoOd1J4IVAYRqAzVbAB+6Pr6/XJ/wM+pukI9EYECAAAAAAAAAAAAAAAIJQKVQQQKSCIClUFwBUYiUBns + pPZEoDKIQGWoZgPwr7ZX75Y7BJ6m6gr1RAQKAAAAAAAAAAAAAAAglAhUBhEoIIkIVAbBFRiJQGWwk9oT + gcogApWhmg3Teu9Xf/3f87i4svfPnxP/12OXz9x5HN4ZDOdl+N3i+vr943fPP3j8v9nd+qb8/4PT8MPn + FJ5F1RXqiQgUAAAAAAAAAAAAAABAKBGoDCJQQBIRqAyCKzASgcpgJ7UnApVBBCpDNRum9TJxnSEaNcSi + Xj977/HvHsP/183Nh+U/B16Wvc3zqLpCPRGBAgAAAAAAAAAAAAAACCUClUEECkgiApVBcAVGIlAZ7KT2 + RKAyiIlkqGbDtF4mAvU0QxxqCENdX7//+P+/+ufC87q1+ejxs1U9c/Cvqq5QT0SgAAAAAAAAAAAAAAAA + QolAZRCBApKIQGUQXIGRCFQGO6k9EagMIlAZqtkwrdOIQFW2V+8+jkLduHBY/jngWXjvxrOqukI9EYEC + AAAAAAAAAAAAAAAIJQKVwWU0IIkIVAbBFRiJQGWwk9oTgcogApWhmg3TmioC9UPDO6zhDA7/7OrPBE+z + u3V0fHFlr3yu4IeqrlBPRKAAAAAAAAAAAAAAAABCiUBlEIECkohAZRBcgZEIVAY7qT0RqAwiUBmq2TCt + FhGoHxKE4nldX79fPkvwQ1VXqCciUAAAAAAAAAAAAAAAAKFEoDKIQAFJRKAyCK7ASAQqg53UnghUBhGo + DNVsmFbrCNQPDe+2djYOjm9uPiz/rPDE8KxUzxA8UXWFeiICBQAAAAAAAAAAAAAAEEoEKoMIFJBEBCqD + 4AqMRKAy2EntiUBlEIHKUM2GaSVFoH5oOKM3LhyWf2YYYmHVcwNPVF2hnohAAQAAAAAAAAAAAAAAhBKB + yiACBSQRgcoguAIjEagMdlJ7IlAZRKAyVLNhWqkRqCe2V+8+Dv5Uf3aWbXg2qmcGBlVXqCciUAAAAAAA + AAAAAAAAAKFEoDKIQAFJRKAyCK7ASAQqg53UnghUBhGoDNVsmFZ6BOqJ4b2XGBQ/NJdnlzaqrlBPRKAA + AAAAAAAAAAAAAABCiUBlEIECkohAZRBcgZEIVAY7qT0RqAwiUBmq2TCtuYV0xKD4oe3Vu+VzAlVXqCci + UAAAAAAAAAAAAAAAAKFEoDKIQAFJRKAyCK7ASAQqg53UnghUBhGoDNVsmNbcIlBPDPGfm5sPy78TyzHX + 55fTV3WFeiICBQAAAAAAAAAAAAAAEEoEKoMIFJBEBCqD4AqMRKAy2EntiUBlEIHKUM2Gac09ojOcZTGo + ZRuCYNWzwbJVXaGeiEABAAAAAAAAAAAAAACEEoHKIAIFJBGByiC4AiMRqAx2UnsiUBlEoDJUs2Fac49A + DS6t7B2/9eoX5d+P/vXwDHPyqq5QT0SgAAAAAAAAAAAAAAAAQolAZRCBApKIQGUQXIGRCFQGO6k9EagM + IlAZqtkwrZ4COsO7sZubD8u/J30bZl89EyxX1RXqiQgUAAAAAAAAAAAAAABAKBGoDCJQQBIRqAyCKzAS + gcpgJ7UnApVBBCpDNRum1VME6om3Xv2i/LvSr52Ng/JZYLmqrlBPRKAAAAAAAAAAAAAAAABCiUBlEIEC + kohAZRBcgZEIVAY7qT0RqAwiUBmq2TCtHiNQg+E92c3Nh+Xfmf7sbh0dX1zZK58FlqnqCvVEBAoAAAAA + AAAAAAAAACCUCFQGESggiQhUBsEVGIlAZbCT2hOByiAClaGaDdPqNQL1xFuvflH+vemPd3L8UNUV6okI + FAAAAAAAAAAAAAAAQCgRqAwunAFJRKAyCK7ASAQqg53UnghUBhGoDNVsmFbvEajB62fvHd/cfFj+/enH + 7tbR8cWVvfIZYHmqrlBPRKAAAAAAAAAAAAAAAABCiUBlEIECkohAZRBcgZEIVAY7qT0RqAwiUBmq2TCt + JUSgBsN7MyGo/l1d2y/nz/JUXaGeiEABAAAAAAAAAAAAAACEEoHKIAIFJBGByiC4AiMRqAx2UnsiUBlE + oDJUs2FaS4lAPfH2+v3yc6APNy78z3LuLE/VFeqJCBQAAAAAAAAAAAAAAEAoEagMIlBAEhGoDIIrMBKB + ymAntScClUEEKkM1G6a1tAjU4K1Xvyg/C/qwvXq3nDvLUnWFeiICBQAAAAAAAAAAAAAAEEoEKoMIFJBE + BCqD4AqMRKAy2EntiUBlEIHKUM2GaS0xAjV4/ey9492to/IzYd6W+kzzY1VXqCciUAAAAAAAAAAAAAAA + AKFEoDKIQAFJRKAyCK7ASAQqg53UnghUBhGoDNVsmNaSgznDu7Sbmw/Lz4V5u7iyV86c5ai6Qj0RgQIA + AAAAAAAAAAAAAAglApVBBApIIgKVQXAFRiJQGeyk9kSgMohAZahmw7SWHIEaCEH1yfs5qq5QT0SgAAAA + AAAAAAAAAAAAQolAZXDJDEgiApVBcAVGIlAZ7KT2RKAyiEBlqGbDtJYegRoM79RuXDgsPx/maXfrqJw1 + y1F1hXoiAgUAAAAAAAAAAAAAABBKBCqDCBSQRAQqg+AKjESgMthJ7YlAZRCBylDNhmmJQI0urewJQXVm + e/VuOWuWoeoK9UQECgAAAAAAAAAAAAAAIJQIVAYRKCCJCFQGwRUYiUBlsJPaE4HKIAKVoZoN0xKB+p4Q + VF8828tWdYV6IgIFAAAAAAAAAAAAAAAQSgQqgwgUkEQEKoPgCoxEoDLYSe2JQGUQgcpQzYZpCeX8mBBU + P3a3jo4v/nOe1ZzpX9UV6okIFAAAAAAAAAAAAAAAQCgRqAwiUEASEagMgiswEoHKYCe1JwKVQQQqQzUb + piUC9VNCUP24urZfzpj+VV2hnohAAQAAAAAAAAAAAAAAhBKByiACBSQRgcoguAIjEagMdlJ7IlAZRKAy + VLNhWiJQNSGoPni+l6vqCvVEBAoAAAAAAAAAAAAAACCUCFQGESggiQhUBsEVGIlAZbCT2hOByiAClaGa + DdMSyXk6Iag++O6zTFVXqCciUAAAAAAAAAAAAAAAAKFEoDKIQAFJRKAyuHQMIxGoDHZSeyJQGUSgMlSz + YVoiUD9vCEHd3HxYfnbMg3d1y1R1hXoiAgUAAAAAAAAAAAAAABBKBCqDi2VAEhGoDIIrMBKBymAntScC + lUEEKkM1G6YlAvXLhnduQlDz5Rlfpqor1BMRKAAAAAAAAAAAAAAAgFAiUBlEoIAkIlAZBFdgJAKVwU5q + TwQqgwhUhmo2TEsg59kM7912t47Kz5B8vv8sT9UV6okIFAAAAAAAAAAAAAAAQCgRqAwiUEASEagMLhzD + SAQqg53UnghUBhGoDNVsmJYI1LO7fOZO+RmSz/u65am6Qj0RgQIAAAAAAAAAAAAAAAglApXBpTIgiQhU + BsEVGIlAZbCT2hOByiAClaGaDdMSgXo+19b2y8+RbJ7z5am6Qj0RgQIAAAAAAAAAAAAAAAglApVBBApI + IgKVQXAFRiJQGeyk9kSgMohAZahmw7TEcZ7f2+v3y8+SbL4DLUvVFeqJCBQAAAAAAAAAAAAAAEAoEagM + IlBAEhGoDC4bw0gEKoOd1J4IVAYRqAzVbJiWCNSLGT636vMk19W1/XKW9KnqCvVEBAoAAAAAAAAAAAAA + ACCUCFQGESggiQhUBsEVGIlAZbCT2hOByiAClaGaDdMSgXoxl1b2jm9uPiw/UzJ51pel6gr1RAQKAAAA + AAAAAAAAAAAglAhUBhEoIIkIVAbBFRiJQGWwk9oTgcogApWhmg3TEsZ5cZfP3Ck/U3JdXNkrZ0l/qq5Q + T0SgAAAAAAAAAAAAAAAAQolAZRCBApKIQGUQXIGRCFQGO6k9EagMIlAZqtkwLRGol3Ntbb/8XMlk9y9H + 1RXqiQgUAAAAAAAAAAAAAABAKBGoDCJQQBIRqAyCKzASgcpgJ7UnApVBCCRDNRumJQL18obPsPpsybOz + cVDOkP5UXaGeiEABAAAAAAAAAAAAAACEEoHKIAIFJBGByiC4AiMRqAx2UnsiUBlEoDJUs2FaIlAvb3gn + t7t1VH6+ZBnmVM2Q/lRdoZ6IQAEAAAAAAAAAAAAAAIQSgcogAgUkEYHKILgCIxGoDHZSeyJQGUSgMlSz + YVoiUCfj9bP3ys+XPJfP3ClnSF+qrlBPRKAAAAAAAAAAAAAAAABCiUBlEIECkohAZRBcgZEIVAY7qT0R + qAwiUBmq2TAtEaiT8+75B+VnTJara/vl/OhL1RXqiQgUAAAAAAAAAAAAAABAKBGoDCJQQBIRqAyCKzAS + gcpgJ7UnApVBBCpDNRumJQJ1ci6t7B3vbh2VnzM5PPPLUHWFeiICBQAAAAAAAAAAAAAAEEoEKoMIFJBE + BCqD4AqMRKAy2EntiUBlEIHKUM2GaQninKxra/vl50yOIdRVzY6+VF2hnohAAQAAAAAAAAAAAAAAhBKB + yiACBSQRgcoguAIjEagMdlJ7IlAZRKAyVLNhWiJQJ2/4TKvPmhzbq3fL2dGPqivUExEoAAAAAAAAAAAA + AACAUCJQGUSggCQiUBkEV2AkApXBTmpPBCqDCFSGajZMSwTq5A2BoeqzJsfVtf1ydvSj6gr1RAQKAAAA + AAAAAAAAAAAglAhUBhEoIIkIVAbBFRiJQGWwk9oTgcogApWhmg3TEoE6HTsbB+XnTYZ3zj8o50Y/qq5Q + T0SgAAAAAAAAAAAAAAAAQolAZRCBApKIQGUQXIGRCFQGO6k9EagMIlAZqtkwLRGo03FpZe94d+uo/Mxp + b5hNNTf6UXWFeiICBQAAAAAAAAAAAAAAEEoEKoMIFJBEBCqD4AqMRKAy2EntiUBlEIHKUM2GaYlAnR6/ + j2XznahvVVeoJyJQAAAAAAAAAAAAAAAAoUSgMohAAUlcOs7gcjGMRKAy2EntiUBlEIHKUM2GaYlAnZ5L + K3vHu1tH5edOe34O9K3qCvVEBAoAAAAAAAAAAAAAACCUCFQGESggiQhUBsEVGIlAZbCT2hOByiD+kaGa + DdMSgTpdfifLtbNxUM6MPlRdoZ6IQAEAAAAAAAAAAAAAAIQSgcogAgUkceE4g+AKjESgMthJ7YlAZRCB + ylDNhmmJQJ2uSyt7x7tbR+VnT1vvXzgsZ0Yfqq5QT0SgAAAAAAAAAAAAAAAAQolAZRCBApKIQGUQXIGR + CFQGO6k9EagMIlAZqtkwLRGo0+f3slwXV/bKmTF/VVeoJyJQAAAAAAAAAAAAAAAAoUSgMohAAUlcNs4g + uAIjEagMdlJ7IlAZRKAyVLNhWiJQp+/Syt7x7tZR+fnT1uUzd8qZMX9VV6gnIlAAAAAAAAAAAAAAAACh + RKAyiEABSUSgMgiuwEgEKoOd1J4IVAYRqAzVbJiWCNQ0rq9/VX7+tHV1bb+cF/NXdYV6IgIFAAAAAAAA + AAAAAAAQSgQqgwgUkEQEKoPgCoxEoDLYSe2JQGUQgcpQzYZpiUBN4/KZT8rPn7Z2Ng7KeTF/VVeoJyJQ + AAAAAAAAAAAAAAAAoUSgMohAAUlEoDIIrsBIBCqDndSeCFQGEagM1WyYlgjUdIbPupoB7bx/4bCcFfNX + dYV6IgIFAAAAAAAAAAAAAAAQSgQqgwgUkEQEKoPgCoxEoDLYSe2JQGUQgcpQzYZpiUBNZ3v1bjkD2tnd + OipnxfxVXaGeiEABAAAAAAAAAAAAAACEEoHKIAIFJBGByiC4AiMRqAx2UnsiUBlEoDJUs2FaIlDTGqJD + 1Rxox3ejPlVdoZ6IQAEAAAAAAAAAAAAAAIQSgcogAgUkEYHK4FIxjESgMthJ7YlAZRCBylDNhmmJQE3L + 72h5rpy9V86Keau6Qj0RgQIAAAAAAAAAAAAAAAglApVBBApI4oJxBsEVGIlAZbCT2hOByiAClaGaDdMS + gZrW9urdcg60c3Vtv5wV81Z1hXoiAgUAAAAAAAAAAAAAABBKBCqDCBSQRAQqg+AKjESgMthJ7YlAZRCB + ylDNhmmJQE1v+MyrWdDGzsZBOSfmreoK9UQECgAAAAAAAAAAAAAAIJQIVAYRKCCJCFQGwRUYiUBlsJPa + E4HKIAKVoZoN0xKBmp7f07K8f+GwnBPzVnWFeiICBQAAAAAAAAAAAAAAEEoEKoMIFJDE5eIMgiswEoHK + YCe1JwKVQQQqQzUbpiUCNT3v8LLsbh2Vc2Leqq5QT0SgAAAAAAAAAAAAAAAAQrlAlkEECkgiApVBcAVG + IlAZ7KT2RKAyiEBlqGbDtESg2ri1+aicB21cXNkr58R8VV2hnohAAQAAAAAAAAAAAAAAhBKByiACBSQR + gcoguAIjEagMdlJ7IlAZRKAyVLNhWiJQbVxf/6qcB21cPnOnnBPzVXWFeiICBQAAAAAAAAAAAAAAEEoE + KoMIFJBEBCqD4AqMRKAy2EntiUBlEIHKUM2GaYlAtbG9erecB234mdCfqivUExEoAAAAAAAAAAAAAACA + UCJQGUSggCQiUBkEV2AkApXBTmpPBCqD4EeGajZMSwSqjUsre8e7W0flTJje1bX9ck7MV9UV6okIFAAA + AAAAAAAAAAAAQCgRqAwiUEASEagMgiswEoHKYCe1JwKVQQQqQzUbpiUC1c7w2VczYXrX178qZ8R8VV2h + nohAAQAAAAAAAAAAAAAAhBKByiACBSQRgcoguAIjEagMdlJ7IlAZRKAyVLNhWiJQ7Vxb2y9nwvTeOf+g + nBHzVXWFeiICBQAAAAAAAAAAAAAAEEoEKoMIFJBEBCqD4AqMRKAy2EntiUBlEIHKUM2GaYlAtbO9erec + CdN7/8JhOSPmq+oK9UQECgAAAAAAAAAAAAAAIJQIVAYRKCCJCFQGwRUYiUBlsJPaE4HKIAKVoZoN0xKB + aufSyt7x7tZRORemdWvzUTkj5qvqCvVEBAoAAAAAAAAAAAAAACCUCFQGESggiQhUBsEVGIlAZbCT2hOB + yiAClaGaDdMSgWrrxoXDci5Mr5oP81V1hXoiAgUAAAAAAAAAAAAAABBKBCqDCBSQRAQqg+AKjESgMthJ + 7YlAZRCBylDNhmmJQLV1ff2rci5Mz3ekvlRdoZ6IQAEAAAAAAAAAAAAAAIQSgcogAgUkEYHK4DIxjESg + MthJ7YlAZRCBylDNhmmJQLU17KJqLkzv8pk75YyYp6or1BMRKAAAAAAAAAAAAAAAgFAiUBlEoIAkIlAZ + BFdgJAKVwU5qTwQqgwhUhmo2TEsEqq3LZz4p58L0tlfvljNinqquUE9EoAAAAAAAAAAAAAAAAEKJQGUQ + gQKSiEBlEFyBkQhUBjupPRGoDCJQGarZMC0RqLYureyVc2F6fi70peoK9UQECgAAAAAAAAAAAAAAIJQI + VAYRKCCJCFQGwRUYiUBlsJPaE4HKIPaRoZoN0xKBau/W5qNyNkzr6tp+OR/mqeoK9UQECgAAAAAAAAAA + AAAAIJQIVAYRKCCJCFQGwRUYiUBlsJPaE4HKIAKVoZoN0xKBau/d8w/K2TAt7/T6UnWFeiICBQAAAAAA + AAAAAAAAEEoEKoMLY0ASEagMgiswEoHKYCe1JwKVQQQqQzUbpiUC1d719a/K2TCtYQ7VfJinqivUExEo + AAAAAAAAAAAAAACAUCJQGUSggCQiUBkEV2AkApXBTmpPBCqDCFSGajZMSwSqvWtr++VsmNbOxkE5H+ap + 6gr1RAQKAAAAAAAAAAAAAAAglAhUBhEoIIkIVAbBFRiJQGWwk9oTgcogApWhmg3TEoFqb9hH1WyY1jvn + H5TzYZ6qrlBPRKAAAAAAAAAAAAAAAABCiUBlEIECkohAZRBcgZEIVAY7qT0RqAwiUBmq2TAtEaj2Lp/5 + pJwN03IW+lJ1hXoiAgUAAAAAAAAAAAAAABBKBCqDCBSQRAQqg+AKjESgMthJ7YlAZRCBylDNhmkJ37Tn + nV4GZ6EvVVeoJyJQAAAAAAAAAAAAAAAAoVwYyyACBSQRgcoguAIjEagMdlJ7IlAZRKAyVLNhWsI3GarZ + MK1bm4/K2TBPVVeoJyJQAAAAAAAAAAAAAAAAoUSgMohAAUlEoDIIrsBIBCqDndSeCFQGEagM1WyYlghU + ht2to3I+TEcEqi9VV6gnIlAAAAAAAAAAAAAAAAChRKAyiEABSUSgMgiuwEgEKoOd1J4IVAYRqAzVbJiW + CFSGIUBUzYfpiED1peoK9UQECgAAAAAAAAAAAAAAIJQIVAYRKCCJCFQGwRUYiUBlsJPaE4HKIAKVoZoN + 0xKBynDjwmE5H6YjAtWXqivUExEoAAAAAAAAAAAAAACAUCJQGUSggCQiUBkEV2AkApXBTmpPBCqDCFSG + ajZMSwQqwzCHaj5Mq5oN81R1hXoiAgUAAAAAAAAAAAAAABBKBCqDCBSQRAQqg+AKjESgMthJ7YlAZRCB + ylDNhmmJQGUQgcpQzYZ5qrpCPRGBAgAAAAAAAAAAAAAACCUClUEECkgiApVBcAVGIlAZ7KT2RKAyiEBl + qGbDtESgMrx7/kE5H6ZVzYZ5qrpCPRGBAgAAAAAAAAAAAAAACCUClUEECkgiApVBcAVGIlAZ7KT2RKAy + iEBlqGbDtESgMvielKGaDfNUdYV6IgIFAAAAAAAAAAAAAAAQSgQqgwgUkEQEKoPgCozEDTLYSe2JQGUQ + gcpQzYZpiUBl8D0pQzUb5qnqCvVEBAoAAAAAAAAAAAAAACCUCFQGESggiQhUBsEVGIkbZLCT2hOByiAC + laGaDdMSgcrge1KGajbMU9UV6okIFAAAAAAAAAAAAAAAQCgRqAwiUEASEagMgiswEjfIYCe1JwKVQQQq + QzUbpiUClcH3pAzVbJinqivUExEoAAAAAAAAAAAAAACAUCJQGUSggCQiUBkEV2AkbpDBTmpPBCqDCFSG + ajZMSwQqg+9JGarZME9VV6gnIlAAAAAAAAAAAAAAAAChRKAyiEABSUSgMgiuwEjcIIOd1J4IVAYRqAzV + bJiWCFQG35MyVLNhnqquUE9EoAAAAAAAAAAAAAAAAEKJQGUQgQKSiEBlEFyBkbhBBjupPRGoDCJQGarZ + MC0RqAzDHKr5MK1qNsxT1RXqiQgUAAAAAAAAAAAAAABAKBGoDCJQQBIRqAyCKzASgcpgJ7UnApVBBCpD + NRumJQKVQQQqQzUb5qnqCvVEBAoAAAAAAAAAAAAAACCUCFQGESggiQhUBsEVGIlAZbCT2hOByiAClaGa + DdMSgcogAtXe7tZRORvmqeoK9UQECgAAAAAAAAAAAAAAIJQIVAYRKCCJCFQGwRUYiUBlsJPaE4HKIAKV + oZoN0xKBynBr81E5H6YzzKCaDfNUdYV6IgIFAAAAAAAAAAAAAAAQSgQqgwgUkEQEKoPgCoxEoDLYSe2J + QGUQgcpQzYZpiUBl2N06KufDdESg+lJ1hXoiAgUAAAAAAAAAAAAAABBKBCqDCBSQRAQqg+AKjESgMthJ + 7YlAZRCBylDNhmmJQGWoZsO0RKD6UnWFeiICBQAAAAAAAAAAAAAAEEoEKoMIFJBEBCqD4AqMRKAy2Ent + iUBlEIHKUM2GaYlAtXdpZa+cDdNyFvpSdYV6IgIFAAAAAAAAAAAAAAAQSgQqgwgUkEQEKoPgCoxEoDLY + Se2JQGUQgcpQzYZpCd+0d/nMJ+VsmJaz0JeqK9QTESgAAAAAAAAAAAAAAIBQIlAZRKCAJCJQGQRXYCQC + lcFOak8EKoMIVIZqNkxL+KY9PxcyOAt9qbpCPRGBAgAAAAAAAAAAAAAACCUClUEECkgiApVBcAVGIlAZ + 7KT2xD4yiEBlqGbDtIRv2hv2UTUbprWzcVDOh3mqukI9EYECAAAAAAAAAAAAAAAIJQKVQQQKSCIClUFw + BUYiUBnspPZEoDKIQGWoZsO0RKDa83tbBhGovlRdoZ6IQAEAAAAAAAAAAAAAAIQSgcogAgUkcZk4g+AK + jESgMthJ7YlAZRCBylDNhmmJQLX37vkH5WyYlnd6fam6Qj0RgQIAAAAAAAAAAAAAAAglApXBhTEgiQhU + BsEVGIlAZbCT2hOByiAClaGaDdMSgWrvxoXDcjZMyzu9vlRdoZ6IQAEAAAAAAAAAAAAAAIQSgcrgwhiQ + RAQqg+AKjESgMthJ7YlAZRCBylDNhmmJQLW3u3VUzoZp+bnQl6or1BMRKAAAAAAAAAAAAAAAgFAiUBlE + oIAkIlAZBFdgJAKVwU5qTwQqg9hHhmo2TEsEqq3LZz4p58L0tlfvljNinqquUE9EoAAAAAAAAAAAAAAA + AEKJQGUQgQKSiEBlEFyBkQhUBjupPRGoDCJQGarZMC0RqLZeP3uvnAvTE4HqS9UV6okIFAAAAAAAAAAA + AAAAQCgRqAwiUEASEagMgiswEoHKYCe1JwKVQQQqQzUbpiUC1Zbf2XL4jtSXqivUExEoAAAAAAAAAAAA + AACAUCJQGUSggCQuFGdwmRhGIlAZ7KT2RKAyiEBlqGbDtESg2nr3/INyLkyvmg/zVXWFeiICBQAAAAAA + AAAAAAAAEEoEKoMIFJBEBCqD4AqMRKAy2EntiUBlEIHKUM2GaYlAtbW7dVTOhWkNc6jmw3xVXaGeiEAB + AAAAAAAAAAAAAACEEoHKIAIFJBGByiC4AiMRqAx2UnsiUBlEoDJUs2FaIlDteJeX4/0Lh+WMmK+qK9QT + ESgAAAAAAAAAAAAAAIBQLo5lEIECkohAZRBcgZEIVAY7qT0RqAwiUBmq2TAtEah2hj1UzYTpOQf9qbpC + PRGBAgAAAAAAAAAAAAAACCUClUEECkgiApVBcAVGIlAZ7KT2RKAyiEBlqGbDtMRv2tnZOChnwvSGWVQz + Yr6qrlBPRKAAAAAAAAAAAAAAAABCiUBlEIECkohAZRBcgZEIVAY7qT0RqAwiUBmq2TAtEah2bm0+KmfC + 9LzP60/VFeqJCBQAAAAAAAAAAAAAAEAoEagMLo0BSUSgMgiuwEgEKoOd1J4IVAYRqAzVbJiWCFQb3uNl + 8TOhP1VXqCciUAAAAAAAAAAAAAAAAKFcHssgAgUkEYHKILgCIxGoDHZSeyJQGQQ/MlSzYVoiUG0MO6ia + B21sr94t58R8VV2hnohAAQAAAAAAAAAAAAAAhBKByiACBSQRgcoguAIjEagMdlJ7IlAZRKAyVLNhWiJQ + bQyfezUP2vD9qD9VV6gnIlAAAAAAAAAAAAAAAAChRKAyiEABSUSgMrhQDCMRqAx2UnsiUBlEoDJUs2Fa + IlDTu7SyV86Cdqo5MV/bm/9RdoV6IgIFAAAAAAAAAAAAAAAQSgQqgwgUkEQEKoPgCoxEoDLYSe2JQGUQ + gcpQzYZpiUBNb9g/1Sxo4/0Lh+WcmK83t39fdoV6IgIFAAAAAAAAAAAAAAAQSgQqgwgUkEQEKoPgCoxE + oDLYSe2JQGUQgcpQzYZpiUBN793zD8pZ0MY7/5xHNSfmSwSqA9VgAQAAAAAAAAAAAAAA5kAEKoMIFJBE + BCqD4AqMRKAy2EntiUBlEIHKUM2GaYlATevSyl45B9rxLq8/IlAdqAYLAAAAAAAAAAAAAAAwByJQGVwc + A5KIQGUQXIGRCFQGO6k9EagMIlAZqtkwLRGoaQ27p5oD7Vw5e6+cFfP13vsflV2hnohAAQAAAAAAAAAA + AAAAhBKByiACBSQRgcoguAIjEagMdlJ7IlAZRKAyVLNhWiJQ0xo+72oOtLO9erecFfN1+8MPyq5QT0Sg + AAAAAAAAAAAAAAAAQolAZRCBApKIQGUQXIGRCFQGO6k9EagMIlAZqtkwLRGo6Xh3l6maFfMmAtWBarAA + AAAAAAAAAAAAAABz4CJZBhEoIIkIVAbBFRiJQGWwk9oTgcogApWhmg3TEoGazs7GQTkD2nn/wmE5K+ZN + BKoD1WABAAAAAAAAAAAAAADmQAQqgwgUkEQEKoPgCoxEoDLYSe2JQGUQgcpQzYZpiUBN59bmo3IGtPPO + +QflrJi3jz69XXaFeiICBQAAAAAAAAAAAAAAEEoEKoMIFJBEBCqD4AqMRKAy2EntiUBlEIHKUM2GaYlA + TWPYOdXnT1ve4/VJBKoD1WABAAAAAAAAAAAAAADmQAQqg8tjQBIRqAyCKzASgcpgJ7UnApVBBCpDNRum + JQI1jVubj8rPn7a2V++W82Le/v3LG2VXqCciUAAAAAAAAAAAAAAAAKFEoDKIQAFJRKAyCK7ASAQqg53U + nghUBhGoDNVsmJYI1Omz93NdXNkrZ8a8/efhTtkV6okIFAAAAAAAAAAAAAAAQCgRqAwiUEASEagMgisw + EoHKYCe1JwaSQQQqQzUbpiUCdfqGz7j67Gnr5ubDcl7M3x//9mbZFeqJCBQAAAAAAAAAAAAAAEAoEagM + IlBAEhGoDIIrMBKBymAntScClUEEKkM1G6YlAnW6vK/L9c75B+XMmL/Pvr1SdoV6IgIFAAAAAAAAAAAA + AAAQyqWyDCJQQBIRqAyCKzASgcpgJ7UnApVBBCpDNRumJQJ1unY2DsrPnfauru2XM2P+/sf/ulx2hXoi + AgUAAAAAAAAAAAAAABBKBCqDCBSQRAQqg+AKjESgMthJ7YlAZRCBylDNhmmJQJ0e7+qyba/eLefG/H35 + 99+UXaGeiEABAAAAAAAAAAAAAACEcrEsgwgUkEQEKoPgCoxEoDLYSe2JQGUQgcpQzYZpiUCdnuGzrT5z + Mlxc2Svnxvz95R+/LrtCPRGBAgAAAAAAAAAAAAAACCUClUEECkgiApVBcAVGIlAZ7KT2RKAyiEBlqGbD + tESgTsewY6rPmwye+759/d2FsivUExEoAAAAAAAAAAAAAACAUCJQGUSggCQiUBkEV2AkApXBTmpPBCqD + CFSGajZMSwzndNzafFR+3mS4vv5VOTf6UDWFeiMCBQAAAAAAAAAAAAAAEEoEKoMIVIZra/uPZ0E7LtVn + GGZR7SqmJbgCIxGoDHZSeyJQGXxfzVDNhmmJQJ284Z1E9VmT48rZe+XsmL/tzf8om0K9EYECAAAAAAAA + AAAAAAAIJQKVYQiuVPNhWrc2H5XzYTouEmcQgcoguAIjEagMdlJ7IlAZRKAyVLNhWn53O1nD+znvJPJd + XNkr58f8vff+R2VTqDciUAAAAAAAAAAAAAAAAKFEoDKIQGVw4bI9F4kziEBlEFyBkQhUBjupPRGoDCJQ + GarZMC2/u52snY2D8nMmx/sXDsvZ0YfbH35QNoV6IwIFAAAAAAAAAAAAAAAQSgQqw/X1r8r5MK3draNy + PkzHReIMIlAZBFdgZCdlsJPaG+JD1WyYlghUhmo2TMvvbifnytn/u/yMyeLdXd9+94d/K5tCvRGBAgAA + AAAAAAAAAAAACCUClWFn46CcD9OqZsO0XCTOILiSQXAFRnZShu3Vu+V8mM61tf1yNkxLBCpDNRum5Xe3 + k3FxZe/41uaj8jMmi+9Cffv3L2+UTaHeiEABAAAAAAAAAAAAAACEEoHK8M75B+V8mI6zkMFF4gyCKxlE + oGBkJ2W4cvZeOR+m4yxkcBYyVLNhWn53OxnX178qP1/yDMGuaob04T8Pd8qmUG9EoAAAAAAAAAAAAAAA + AEJdWtkrLzYxrfcvHJbzYTq/Xf20nA3TcpE4g8hEBhEoGNlJGd4493k5H6bz9safy9kwre3Vu+V8mFY1 + G6bld7eX5z3EfHje+/fZt1fKplBvRKAAAAAAAAAAAAAAAACCVZebmNbu1lE5G6bz+tl75WyY1s7GQTkf + piW4kkEECkbX1vbLM8K0rq9/Vc6H6QwBimo2TEsEKkM1G6YlivNyXvvnd/1bm4/Kz5Y8V//5fbSaI/34 + 8u+/KZtCvRGBAgAAAAAAAAAAAAAACFZdbmJ6F1f2yvkwDdGbDCJQGZyHDCJQMHrj3OflGWFafka3JxaS + QQQqQzUbpiUC9XKGn6vV50qmy2fulHOkH3/5x6/LplBvRKAAAAAAAAAAAAAAAACC7W4dlRecmJbLxG29 + e/5BORemdX39q3I+TEsEKoMIFIxEoDIMAaJqPkzj0speORem5+dzhmo2TEsE6sX5fWtebm4+LOdIX6qe + UI9EoAAAAAAAAAAAAAAAAIINF7qrS05M6+rafjkfpnHjwmE5F6Y1XIat5sO0XErOIDIBo9+uflqeEaZ3 + cWWvnBGnzznI4edzhmo2TEsE6sW89s8dUn2e5NrZOChnST+2N/+j7An1SAQKAAAAAAAAAAAAAAAgmPhN + BpfK2rm0slfOhOmJoWUQgcogMgGjy2c+Kc8I09tevVvOiNN37Z/fkaqZML1qPkyvmg3TEoF6fkMASoh9 + fnz/6d/tDz8oe0I9EoECAAAAAAAAAAAAAAAINlzcqy45Ma3hImA1H07fb1c/LWfC9N4493k5I6YlApVB + BApGQzChOiNMT6yxnXfPPyhnwvSq+TC9ajZMSwTq+d248D/Lz5JcNzcflrOkL7/7w7+VPaEeiUABAAAA + AAAAAAAAAAAEe3vjz+VFJ6Yn+NHG9fWvynkwve3Vu+WMmJYIVAY/E2B0aWWvPCNMT/Cjnd2to3ImTEu4 + N0c1H6blZ8Lz8TvWPO1sHJTzpC///uWNsifUIxEoAAAAAAAAAAAAAACAYCJQOa6u7Zcz4nTduHBYzoPp + iUBlcEE5gwgUfK86I0xvCBFdXNkrZ8Tp+e3qp+U8mJ7oTY5qPkzLeXh2fr+aL+8oluGPf3uz7An1SAQK + AAAAAAAAAAAAAAAgmMtoOVyinN5rr3xczoI2RG8y+LmQwXmA793afFSeE6YnhjC9nY2DchZMz+9rOar5 + MC3n4dlcOXuv/PzId3PzYTlT+vPl339T9oR6JAIFAAAAAAAAAAAAAAAQ7I1zn5eXnZje7tbR8cWVvXJO + nI5ra/vlLGijmhHTE4HKIAIF37tx4bA8J0zv+vpX5Yw4PSJoOYYgVzUjplfNh2mJQP2yy2c+efyep/r8 + yGfnL8df/vHrsifUIxEoAAAAAAAAAAAAAACAYK+fvVdedqKNq2v75Zw4HS7V5xgux1YzYnoiUBlEoOB7 + 755/UJ4TpidaOq3frn5azoE2hu9I1ZyYXjUfpiUC9fNe++d3ee8b5m179W45W/pTtYR6JQIFAAAAAAAA + AAAAAAAQ7PKZT8rLTrThIuV0XKrP8v6Fw3JOTE8EKoMIFHzv7Y0/l+eENq6cvVfOiZO3s3FQzoA23jj3 + eTknplfNh2l5d/F0AlDzd3PzYTlb+vPe+x+VLaFeiUABAAAAAAAAAAAAAAAEu7SyV154op3LZ+6Us+Jk + uVSf5Z3zD8o5MT0RqAwiUPC9a2v75TmhDeGPaQwRkerzp53t1bvlrJheNR+m5WdBTQCqD8P7omq+9Of2 + hx+ULaFeiUABAAAAAAAAAAAAAACE2906Ki890cb19a/KOXFyXKrP47nPIQKVQQQKvvfGuc/Lc0I7Yjin + z8/jPGK9Oar5MC0RqJ8SgOqHfb8c//7ljbIl1CsRKAAAAAAAAAAAAAAAgHA3LhyWl55oY4hyXVzZK2fF + ydjZOCg/e9q5urZfzorpiU5kEIGC710+80l5Tmhn+C5VzYqTISSSqZoVbVTzYVoiUD9mb/fj/QuH5Yzp + 0x//9mbZEuqVCBQAAAAAAAAAAAAAAEC4tzf+XF58op0hwlLNipc3XM6sPnPa2l69W86L6YlAZRCBgu9d + WtkrzwltDd+pqnnx8vwszjOEeqtZ0UY1I6YlAvU9Aai+vHHu83LO9OnLv/+mbAn1SgQKAAAAAAAAAAAA + AAAg3PX1r8qLT7QzXDK+uLJXzouXs7NxUH7mtHX5zJ1yXkxPeCKDCBT82PDdqDortDN8p6pmxcsRE8kk + eJOlmhHTciZGdnZ/RC6X5Zv/Xi9bQr0SgQIAAAAAAAAAAAAAAAg3/Fvuq4tPtHV9/X45L17ccJmv+qxp + r5oXbYhAZRCBgh+7ceGwPCu0tb16t5wXL06wNNMQTq7mRRvVjJiWCJQAVI8ELpdle/M/yo5Qz0SgAAAA + AAAAAAAAAAAAwl0+80l5+Yn2XKw/WS5oZnr/wmE5L9oQgcogAgU/9vbGn8uzQlsiICdLsDTX1bX9cma0 + Uc2IaS19//929dPj3a2j8rNhvryDW5bbH35QdoR6JgIFAAAAAAAAAAAAAAAQ7tLKXnn5ifZcrD8519b2 + y8+Y9t45/6CcGW2IQGUQgYIf83M8lzjOyREszSUMkqWaEdNa8rsK30n6dHPzYTlv+vXvX94oO0I9E4EC + AAAAAAAAAAAAAACYAReOc7lY//Jee+Xj492to/Lzpb0hOlTNjTZEoDKIQMGPvX72XnlWaG/4jjV816rm + xrPz8zfbxZW9cm60Uc2IaS01AmVX9+uNc5+XM6dff/zbm2VHqGciUAAAAAAAAAAAAAAAADPw7vkH5SUo + 2nOx/uWJnGW7cvZeOTfacLE5gwgU/NjwXag6K2RYagzkpHi+sw2/j1Vzo51qTkxraXt/CMF5b9Yv792W + 6cu//6bsCPVMBAoAAAAAAAAAAAAAAGAGrq9/VV6EIsONC4ePLx1Ws+PnCdrku3zmTjk72nBmMohAwU8N + F/Sr80KGq2v75dz4eUN0QrA0m8hZnmpOTGtJ58Ke7t/OxkE5e/r2zX+vlx2hnolAAQAAAAAAAAAAAAAA + zMAb5z4vL0KR4/r6/XJ2PN2Vs/fKz5IcQ9Cjmh3tiEBlEIGCnxqCE9V5IYew4/N79/yD8rMkxxBMrmZH + O9WcmNZSIlDDuzIRyv4Noa9q/vTrvfc/KhtCvROBAgAAAAAAAAAAAAAAmIHhwlN1EYosV9f2y/nxU8Mz + 7bJmvqVcHp4TEagMIlDwU0OIpTov5Li1+UhI4Tn4mTsPQ1i2mh/tVHNiWr3/HndxZc/3joXY2TgonwH6 + 9rs//FvZEOqdCBQAAAAAAAAAAAAAAMBMCObMw+Uzd8r58b0hPjBECKrPjyzDxdpqhrQjSJFBBAp+6o1z + n5fnhSw3Lhw+jmdUM+R719b2y8+PPH7/ylPNiWn1HIG6fOYT7xMWZHv1bvkc0Lf/PNwpG0K9E4ECAAAA + AAAAAAAAAACYiXfPPygvRJFliHUNkaNqhghAzc2Vs/fKOdKOCFQGESj4qeFnfHVeyLOzcVDOkJGg2XwM + v3tVM6StalZMq9cIlN+FluX9C4flc0D/vvz7b8qGUO9EoAAAAAAAAAAAAAAAAGbi2tp+eSmKPEPkSAjq + py6u7B3fuPA/y8+MTJ7jPC4+ZxCBgprQ43wMP0+qGS7d5TOflJ8Xmd45/6CcI21Vs2JavUWgfrv6qXcJ + CzREGavngf59/d1m2RDqnQgUAAAAAAAAAAAAAADATGyv3i0vRZFJCOrHBKDm5+bmw3KWtCUClUEECmpv + b/y5PDNkEoL6sSEAtbt1VH5WZLq6tl/OkraqWTGtXiJQw3uE6+tflX9H+uZ9xHK9uf37sh+0BCJQAAAA + AAAAAAAAAAAAM3FpZc+l5JkRghoNn4EA1PzsbByU86QtEagMIlBQu7a2X54Zcl1fv1/OcmneOPd5+fmQ + bQglV/OkrWpWTKuHCNSwl4d3KtXfj/4N86+eC/r3uz/8W9kPWgIRKAAAAAAAAAAAAAAAgBkZLvJVl6PI + NVxavHzmTjnPJRgCUC5uzpNLl5lEoDKIQEFt+LlfnRmyvXP+wfHFlb1ypksgXjZPQyC5miftVfNiWnOO + QP129VPvvhbu5ubD8tlgGf7zcKfsBy2BCBQAAAAAAAAAAAAAAMCMiH/M19W1/XKmPbt85hMBqBkbQh7V + XGnLz4EMIlDwdEOYpTo3ZBu+sy3xZ7+fq/M158hN76p5Ma05no/hZ5D4EwNB6mX78u+/KftBSyACBQAA + AAAAAAAAAAAAMCPbq3fLC1LMw/X1+8cXV/bK2fbm2tp++RkwDzc3H5ZzpT2xigwiUPB0b2/8uTw35BtC + UEsJLwzfycVG5m2Jkd25qObFtOYUgRriTzsbB+Xfg+XxLoJv/nu97ActgQgUAAAAAAAAAAAAAADAzOxu + HZUXpZiH4XL9cMmxmm0Phgv14g/zN1zCreZLeyJQGUSg4OmGiFB1bpiP3sOlv1399PF38urvznxcPnOn + nC/tVfNiWnOIQA27WPyJf7WUGCW1997/qGwHLYUIFAAAAAAAAAAAAAAAwMwMl/mqi1LMyxByqeY7Zy7U + 9+PK2XvljGlPBCqDCBQ83aWVvfLcMC/Dd7reIjtD2Or6+lfl35d5ubn5sJwxGaqZMa3kCNTw3sB7LSp2 + Ox99ertsBy2FCBQAAAAAAAAAAAAAAMDMXFvbLy9LMT+9XK53ob4/w0yrWdOeCFQGESj4eTcuHJZnh/nZ + 2Tg4fq2DnSdW2pfhuazmTIZqZkwrLQI1/H45/B6zu3VU/nlh8Ma5z8vnh+X47NvXy3bQUohAAQAAAAAA + AAAAAAAAzMyllb3yshTzNefL9S5y9iftwjA/JgKVQQQKfp5d1ZchnnR1bb+cdbrhO/a75x+Ufy/m68rZ + e+W8yVDNjGkl/E43hJ+GAN/wZ6n+jPBDNzcfls8Ry/KXf/y6bActhQgUAAAAAAAAAAAAAADADLlE16c5 + xaDeOPf54yBA9fdg3obZVjMng7BKBhEo+Hnbq3fLs8O8Dd/95vI9YYiPXF//qvx7MH/DfKu5k6GaGdNq + FYF6En66vn5fLJrnMnx3rJ4pluPN7d+X3aAlEYECAAAAAAAAAAAAAACYIRGQvg0xqOHiZDX7loYLncOz + 5zJn3+YSIlsq+z+DCBT8Mt8X+jXEoIbAUuJ3huE79PBduvpz04dWcRueXTU3pjXlORneE7x+7v85fuf8 + Az/7eSHDz+3q2WJZfveHfyu7QUsiAgUAAAAAAAAAAAAAADBDw78hv7o4RV+GC/bX1vabX7AfLtO/60Ln + Irx/4bB8BsghApVBBAp+2RAJqs4PfRmiH2+c+7x8BqYyBEiG78xD9KT6M9KX1s8bv6yaG9M6zQjU8H5i + iD5dX79/fHPzYfnPh+chRM3gj397s+wGLYkIFAAAAAAAAAAAAAAAwEwNgaDq8hR9unHh8PElyyHIVD0P + J2m4SD9c6tzZOBB+Wpira/vlM0EOEagMIlDwy0RLl+dJEGqKmMPwnXj4mSj8tDxiIfmquTGtk4pADeft + ytn/+3Fob9jxok+ctOG9U/XssTx/+cevy27QkohAAQAAAAAAAAAAAAAAzJQQyLINlzqHKNRwGXO4BD+E + m6rn5Jf88FLncPnOpc5lc6k+n92fQQQKno2Y5HINwdohGDL83Bq+a/4fZz4pn5FfMnzHHf63Q6B0+O47 + fAf2XC3XSYVtOF3V7JjWs56V4fe/J+8EnuzZ4b3AEKG2azltw/sn7yAYbG/+R9kMWhoRKAAAAAAAAAAA + AAAAgJnaXr1bXqJi2YZLdMOFz8Fw8X64wPnE8J+H/3640Cn2xL96/5/PRbVryCICleFf9yvTu7q2X54R + slxf/6o8QyzXEBUZvos+7fvqk/9++K4qQMK/euPc5+WuIUs1O6Y17M8ne/XJe4DBk3cB9isJ7HSe+N0f + /q1sBi2NCBQAAAAAAAAAAAAAAMCMDZf4qotUAM/LBcx5EIGC0fAdqDojZBEtBU7Sa698XO4aslSzA/ih + IUZW7Q+W6bNvXy+bQUsjAgUAAAAAAAAAAAAAADBjYiDASXGpfh7sfRiJQM3Hrc1H5QwBnsfOxkG5Y8hT + zQ/gh7x/4If+8o9fl82gpRGBAgAAAAAAAAAAAAAAmLFLK3vlZSqA5/HO+QfljiGPCBSMRKDmw94CTsKV + s/fKHUOean4AT4j68UNvbv++7AUtkQgUAAAAAAAAAAAAAADAzA0RhOpSFcCzeuPc5+V+IY+YCoxEoOZD + tBR4WTc3H5b7hUzVDAEGwz5/7ZWPy93BMn306e2yF7REIlAAAAAAAAAAAAAAAAAzt716t7xYBfAsXKqf + FxEoGIlAzYtoKfAydjYOyt1CpmqGAAMBav7VZ9++XvaClkgECgAAAAAAAAAAAAAAoAO7W0fl5SqAX+JS + /byIQMFIBGpeREuBl/HaKx+Xu4VM1QwBvHug8vV3m2UvaIlEoAAAAAAAAAAAAAAAADogCgK8KJfq58W+ + h5EI1PyIlgIvwr6fn2qOwLLtbn3j3QM/8d77H5WtoKUSgQIAAAAAAAAAAAAAAOjApZW98pIVwM955/yD + cqeQSwQKRqIg82N/AS/iytl75U4hVzVHYNmurf2p3Bcs279/eaNsBS2VCBQAAAAAAAAAAAAAAEAn3j3/ + oLxoBfA026t3y31CLhEVGIlAzc8QLd3dOirnCVC5ufmw3Cdkq2YJLJfv7TzNl3//TdkKWioRKAAAAAAA + AAAAAAAAgE4MMZfqshVAxaX6eRKBgpHL5PO0s3FQzhOg8sa5z8tdQrZqlsAy7W59c/zaKx+Xu4Jle3P7 + 92UnaMlEoAAAAAAAAAAAAAAAADoyBBGqS1cA/8ql+nkSgYKRCNQ8iZYCz2oIll5c2St3CdmqeQLLdG3t + T+WegI8+vV12gpZMBAoAAAAAAAAAAAAAAKAjLtYDz2K4VF/tEPKJQMFIBGq+REuBZ7GzcVDuEPJV8wSW + 593zD8odAYP/8b8ul52gJROBAgAAAAAAAAAAAAAA6MyNC4fl5SuAJ94493m5P8gnAgUjEaj5Ei0FnsVr + r3xc7hDyVfMElmUIT9vj/Jxv/nu97AQtmQgUAAAAAAAAAAAAAABAZ4a4S3UBC2DgMua8iUDBSARq3ob5 + VXMFGOxsHJS7g3moZgosi/A0P+f2hx+UjaClE4ECAAAAAAAAAAAAAADo0BB5qS5hAbz16hfl3mAeRKBg + JAI1b9urd8u5AgwES+etmimwHNfX75e7AZ747NvXy0bQ0olAAQAAAAAAAAAAAAAAdGj4N+5XF7GAZRsC + cS7Vz5sIFIxEoOZvmGE1W2DZdjYOyp3BfFRzBZZheOdQ7QX4oa+/2ywbQUsnAgUAAAAAAAAAAAAAANCp + 4eJVdSELWK63Xv2i3BfMhwgUjESg5m979W45W2DZBEvnr5or0L/drW/scH7R7Q8/KPtAiEABAAAAAAAA + AAAAAAB0641zn5eXsoBlGsJwLmTOnwgUjESg+jDMsZovsEw7GwflrmBeqtkC/bu29qdyJ8AP/fFvb5Z9 + IESgAAAAAAAAAAAAAAAAuuZiPfCEC5l9EIGCkQhUH7ZX75bzBZZJsLQP1WyBvl1fv1/uA/hXX3+3WfaB + EIECAAAAAAAAAAAAAADomov1wODm5sNyRzA/IlAwEoHqh2gpMHjr1S/KHcH8VPMF+jW8b7i4slfuA/ih + 997/qGwDMRKBAgAAAAAAAAAAAAAA6JyL9cAb5z4v9wPzIwIFIxGoflw+c6ecMbAcQ0DktVc+LncE81PN + GOiT/c3z+OPf3izbQIxEoAAAAAAAAAAAAAAAADq3vXq3vKgFLMNwKbPaDcyTCBSMRKD68vb6/XLOwDII + lvalmjHQpytn75V7ACpff7dZtoEYiUABAAAAAAAAAAAAAAAsgIv1sFyXz9wp9wLzJAIFIxGovlxa2Tve + 3ToqZw30TbC0P9Wcgf689eoX5Q6Aynvvf1R2gfieCBQAAAAAAAAAAAAAAMACuFgPy7SzcVDuBOZLBApG + IlD9uba2X84a6Nv26t1yJzBf1ZyBvrx7/kF5/uFpPvv29bILxPdEoAAAAAAAAAAAAAAAABbCxXpYlt2t + b45fe+Xjch8wXyJQMBKB6tONC4flvIE+CZb2qZo10I+bmw+PL67slecfnubr7zbLLhDfE4ECAAAAAAAA + AAAAAABYEBfrYTneevWLcg8wbyJQMBKB6tP26t1y3kB/BEv7Vc0b6MMQgLK7eV63P/ygbALxYyJQAAAA + AAAAAAAAAAAAC+JiPSzDcDGz2gHMnwgUjESg+vX2+v1y5kBfrq39qdwBzF81b6APl898Up57+Dmffft6 + 2QTix0SgAAAAAAAAAAAAAAAAFsbFeujfa698XJ5/5k8ECkYiUP26tLJ3vLt1VM4d6INgad+qmQPzJ97H + i/r6u82yCcSPiUABAAAAAAAAAAAAAAAszHCxfrh0W13oAubv+vr98uzTBxEoGIlA9e3a2n45d6APgqV9 + q2YOzNtbr35Rnnf4JR99ervsAfFTIlAAAAAAAAAAAAAAAAALtL16t7zUBczbEHi7uLJXnnv6IAIFIxGo + /g0zrmYPzJuQSP+quQPzJTTNy/gf/+ty2QPip0SgAAAAAAAAAAAAAAAAFurt9fvl5S5gvobAW3Xe6YcI + FIxEoPr32isfH+9uHZXzB+ZpCJZW552+VLMH5und8w/Kcw7P4s3t35ctIGoiUAAAAAAAAAAAAAAAAAt1 + aWXv8SXc6pIXMD/X1++XZ52+iEDBSARqGa6t7ZfzB+ZpiLtVZ52+VLMH5ufGhcPjiyt75TmHZ/HRp7fL + FhA1ESgAAAAAAAAAAAAAAIAF2169W170AuZlCLq5nLkMIlAwEoFajnfPPyifAWBe3nr1i/KM059q/sC8 + DO8YhPt4WV9/t1m2gKiJQAEAAAAAAAAAAAAAACzc2+v3ywtfwHy4nLkcIlAwEoFajksre49DBNVzAMzD + cIar802fqmcAmA8BKE7C7Q8/KDtAPJ0IFAAAAAAAAAAAAAAAwMK5WA/z9tarX5Rnmz6JQMFIBGpZtlfv + ls8BkG936xsxkYWpngNgHgSgOCmffft62QHi6USgAAAAAAAAAAAAAAAAOL585s7x7tZReQEMyHXjwmF5 + pumXCBSMRKCW5+31++WzAGR749zn5ZmmX9VzAOQT7eOkbG/+x/E3/71edoB4OhEoAAAAAAAAAAAAAAAA + Hru2tl9eAgMy3dx86ILmAolAwUgEapmG+GH1PACZrq/fL88yfaueBSDbEIC6fOaT8kzD8/ro09tlA4if + JwIFAAAAAAAAAAAAAADA/7azcVBeBgPyXDl7rzzH9E0ECkYiUMs0xA93t47KZwLIMgRLL67slWeZvlXP + A5BLAIqT9pd//LpsAPHzRKAAAAAAAAAAAAAAAAD43y6t7D2+rFtdCgNyvPXqF+UZpn8iUDASgVqu18/e + K58JIMcQFBmibdUZpn/VMwHkEoDiJN3+8IOy/8MvE4ECAAAAAAAAAAAAAADgR4bLurtbR+XFMKA94ZNl + E4GCkV24bEMMsXougAxvnPu8PLssQ/VMAJmunvuv8hzDi/rs29fL/g+/TAQKAAAAAAAAAAAAAACAnxgu + 7VaXw4C2bm4+fBxqq84tyyACBSMRKIZnoHo2gLaGSFt1ZlmO6rkA8ghAcdLe3P592f7h2YhAAQAAAAAA + AAAAAAAAUBou71aXxIA2dre+EYBCBAr+fyJQXFrZexxHrJ4PoI13zz8ozyvLUj0bQI7h3cLlM5+U5xde + xkef3i7bPzwbESgAAAAAAAAAAAAAAACearjEW10YA6b3xrnPy3PKsohAwUgEisEQR9zdOiqfEWBaQ5RN + sJRB9XwAGQSgOE1ff7dZtn94NiJQAAAAAAAAAAAAAAAAPNWllb3Hl3mri2PAdN569YvyjLI8IlAwEoHi + ie3Vu+UzAkxHAIofqp4RoD0BKE7TR5/eLrs/PDsRKAAAAAAAAAAAAAAAAH7WcJlXCAraub5+vzybLJMI + FIxEoPiha2v75XMCTENUhB+qnhGgreG9nl3Nafry778puz88OxEoAAAAAAAAAAAAAAAAftHlM3eOd7eO + yotkwOm5ceGwPJMslwgUjESg+FdvvfpF+awAp+va2p/KM8lyVc8J0M4QgBoC79V5hZPw5vbvy+YPz0cE + CgAAAAAAAAAAAAAAgGfy+tl75WUy4HS4qElFBApGIlBUdjYOyucFOB1DfK06iyxb9awAbXivwBQ++/b1 + svnD8xGBAgAAAAAAAAAAAAAA4JldW9svL5UBJ8tFTZ5GBApGIlBULq3sHd+4cFg+M8DJur5+vzyHUD0v + wPSG70TeK3Da3tz+fdn74fmJQAEAAAAAAAAAAAAAAPBc3nr1i/JyGXAydre+cVGTpxKBgpEIFE8zhKCG + mGL13AAnY2fjoDx/MKieGWBa755/cHzxn9+JqjMKJ+mPf3ur7P3w/ESgAAAAAAAAAAAAAAAAeG5CUHA6 + hgDU5TOflOcOBiJQMBKB4ucMMUUhKDgdNy4cCovws6rnBpjO9fX75dmE0/D1d5tl74fnJwIFAAAAAAAA + AAAAAADAC9nZOCgvmwEv7srZe+V5gydEoGAkAsUvEYKCkycAxbOonh1gGkO0vTqXcBo++vR22frhxYhA + AQAAAAAAAAAAAAAA8MKEoODkXD33X+U5gx8SgYKRCBTPQggKTs5wloYzVZ01+KHq+QFO1+7WN94pMLmv + v9ssWz+8GBEoAAAAAAAAAAAAAAAAXooQFLw8lzV5ViJQMBKB4lkN0ZrdraPyOQKejQAUz6N6hoDTM+zo + y2c+Kc8jnJaPPr1ddn54cSJQAAAAAAAAAAAAAAAAvDQhKHhxAlA8DxEoGIlA8Twun7kjBAUvSACK51U9 + R8DpsKNp5evvNsvODy9OBAoAAAAAAAAAAAAAAIATIQQFz08AiuclAgUjESielxAUPD9xEV5E9SwBJ294 + D3dxZa88h3CaPvr0dtn44eWIQAEAAAAAAAAAAAAAAHBihKDg2QlA8SJEoGAkAsWLGGI2Q9SmeqaAHxOA + 4kVVzxNwst569Yvy/MEUvv5us2z88HJEoAAAAAAAAAAAAAAAADhRQlDwywSgeFEiUDASgeJFCUHBLxOA + 4mVUzxRwMna3vjm+cvZeefZgCrc//KDs+/DyRKAAAAAAAAAAAAAAAAA4cW+v3y8vq8HSDRc2BaB4GSJQ + MBKB4mUIQcHT3bhweHxxZa88O/AsqucKeHnDfhboo7Uv//6bsu/DyxOBAgAAAAAAAAAAAAAA4FS89eoX + 5aU1WKohAHX5zCfleYFnJQIFIxEoXpYQFPzUsFsFoHhZ1bMFvJzr6/ftZ5q7/eEHZduHkyECBQAAAAAA + AAAAAAAAwKkRgoLREJkQgOIkiEDBSASKkzCEoG5cOCyfMVianY2D8pzA86qeL+DFDDHpa2t/Ks8aTO3L + v/+mbPtwMkSgAAAAAAAAAAAAAAAAOFXX1vbLi2ywFEMAaohMVOcDnpcIFIxEoDgpl1b2jt89/6B8zmAp + hnhvdT7gRVTPGPD8vEsgye0PPyi7PpwcESgAAAAAAAAAAAAAAABO3etn7x3vbh2Vl9qgZzcuHLq0yYkS + gYKRCBQn7e31++WzBr0TgOKkVc8Z8Hyu//N7ycWVvfKMQQtff7dZdn04OSJQAAAAAAAAAAAAAAAATGII + 4dzcfFheboMe7WwcuLTJiROBgpEIFKdhiOFUzxv0aHfrm+Or5/6rPAvwMqrnDXg2w26+cvZeebaglY8+ + vV02fThZIlAAAAAAAAAAAAAAAABMRgiKpRgiEtUZgJclAgUjEShOy7W1/fKZg54Mv5NdPvNJeQbgZVXP + HPDLhu+3w3uz6lxBS19/t1k2fThZIlAAAAAAAAAAAAAAAABM6tLK3vHb6/fLC28wd7tb3xxfPfdf5bMP + J0EECkYiUJymy2fuCJfSrRsXDkVGOFXVcwc83fAe4dran8rzBK199OntsufDyROBAgAAAAAAAAAAAAAA + oIm3Xv2ivPwGczXEIi6f+aR83uGkiEDBSASK0zZEcoZYTvX8wVztbBwcX1zZK595OCnVswfUhu+0wnwk + +/q7zbLnw8kTgQIAAAAAAAAAAAAAAKCZ18/eexzOqS7CwZy4uMlURKBgJALFVN5ev18+gzA319b+VD7j + cNKq5w/4sd2tb+xl4n306e2y5cPpEIECAAAAAAAAAAAAAACgqSGcIwTFnF1fv18+23AaRKBgJALFlK6t + 7ZfPIczB8LvW9urd8tmG01A9h8D3RKSZi6+/2yxbPpwOESgAAAAAAAAAAAAAAAAivL1+v7wcB6l2t745 + vnruv8rnGU6LCBSMRKCYmnApcyQ0QgvVswiM7xDeOPd5eW4gzX8e7pQdH06PCBQAAAAAAAAAAAAAAAAx + hstwu1tH5WU5SHLjwqEL9TQhAgUjEShauLSyd7yzcVA+k5Dm+vr98jmG01Y9j7B0w06++M/vEdWZgTRv + bv/++OvvNsuOD6dHBAoAAAAAAAAAAAAAAIAoQ1jn5ubD8tIcJHChnpZEoGAkAkVL19b2hUuJNfwutb16 + t3x2YQrVcwlLNXxntZOZm8++fb1s+HC6RKAAAAAAAAAAAAAAAACI9NarX5QX6KAVF+pJIAIFIxEoWhMu + JdG75x8cX1zZK59ZmEr1bMLS7G59c3xt7U/lGYFkb27/vuz3cPpEoAAAAAAAAAAAAAAAAIh1+cwdl+uJ + 4EI9KUSgYCQCRQrhUhKIjZCkekZhSYbvBt4fMFeffft62e/h9IlAAQAAAAAAAAAAAAAAEO3Syt7x2+v3 + y4t1cNqGC/VXzt4rn01oQQQKRiJQJHntlY+FS2lm2IfDM1g9m9BC9ZzCEtjHzN3v/vB/lu0epiECBQAA + AAAAAAAAAAAAwCxsr951uZ5JvXv+wfHFlb3yeYRWRKBgJAJForde/aJ8XuE0DLHSa2t/Kp9FaKl6XqFn + w/fS4Z1VdR5gTr7+brNs9zANESgAAAAAAAAAAAAAAABmxeV6TtsQG3OBk1QiUDASgSLVa698LFzKqRti + pcOzVj2D0Fr1zEKPblw49O6Abnz06e2y28N0RKAAAAAAAAAAAAAAAACYneHC83DZrrqEBy9jiIxdXNkr + nztIIAIFIxEo0r1x7nMxKE6cWClzUD270JNhFw8/56vnH+boze3fH3/93WbZ7WE6IlAAAPx/7dzfahzp + mcDhO8gkk9mewRXWBwqZoaIwtUtHSEv6wGD3gQwN3UxABBIRFBHIJAtpFgbPiRoW+lBXYF+Br0BX4L2C + voO+jtp8UjrROO/YkiX1V3+eg+dsxvbI3/tVTcH7AwAAAAAAAAAAAGgty/XclxQTSXGx6JxBk4hAwRUR + KNogvVsMP/0mPMNwG7/6yVKslNaIzjB0gfgTXXX6ajds9rBdIlAAAAAAAAAAAAAAAAC0WlquTwvR0YIe + vE9a4ix/9IfwbEETiUDBFREo2iS9rx48WoRnGd5n77NvxUpplegcQ5ul907xJ7qqKidhr4ftE4ECAAAA + AAAAAAAAAACgE9Ji9PDTb8KFPXjbr36yvIyH/fQHvwnPEzSVCBRcEYGijVJAIgUoozMNb0v3nFgpbRSd + Z2gj9zB9cLYqwl4P2ycCBQAAAAAAAAAAAAAAQKekGFRa1IsW+ED8ibYTgYIrIlC0mRgU75LOhugIbRad + a2gT8Sf64vBkFLZ6yEMECgAAAAAAAAAAAAAAgE6yXM/bhp9+cxkJi84LtIUIFFwRgaLt0jtJClN6X2Uj + nYX0/zDReYE2ic43NN0mGO2bAX1RlZP6bFWErR7yEIECAAAAAAAAAAAAAACg08SgEH+iS0Sg4IoIFF0h + BsUmPPLTH/wmPCPQNtE5h6ZK75RffvIXdzC9c/pqN+z0kI8IFAAAAAAAAAAAAAAAAL1Q/ugPl8t90dIf + 3WOZnq4SgYIrIlB0TYpBffnJf4tB9Uj6u07B2ug8QJtF5x2aJH0v+OVn315+J4rOMHTd3v5h2OghLxEo + AAAAAAAAAAAAAAAAeiUt+Q0//SZcBKT9xJ/oOhEouCICRZelMJAYVHel+0t4hC6Lzj00Qbp/v/zkL74X + 0HtnqyJs9JCXCBQAAAAAAAAAAAAAAAC99LOPfnsZg7Jg3w2WOekLESi4IgJFH+x+/MfLsx7NAO3zy8++ + FX+iF6LzD7lsQtHuX7hytBiGfR7yE4ECAAAAAAAAAAAAAACg937x4z/VB48W4cIgzZWWOS3T0zciUHBF + BIo+ES9tr018RKiUPolmAbYp3b3/Ofgf3wrgLVU5Cds8NEPnI1DpAEYHEwAAAAAAAAAAAAAAAN72xQ9/ + b8G+BVL4wzI9fSUCBVdEoOirFC9N5z+aC5ohxUfS35H4CH0VzQU8NOEneL+zVRG2eWgGESgAAAAAAAAA + AAAAAAAIpAX7vc++DZcL2T4LnXBFBAquiEDRdz/76Lf1l5/8Rby0QdK9lP5OhErpu2g+4CGkZ6DvBHAz + 0/lB2OWhOUSgAAAAAAAAAAAAAAAA4B3Sgn0KQqWl7mjpkIcj/AT/SgQKrohAwT998cPfX74zCUJtX7qL + /uPf/lp//tHvwr8b6KNoVuA+pG8Em+CeexduLrV3lutB2OWhOTofgdo7OAwPKAAAAAAAAAAAAAAAANzW + Jgi199m34UIidyf8BO8mAgVXRKAgtglCHTxahLPD3QmQwLtFcwMfKj3PNt8IfvqD34RnDni3+cVO2OSh + WTofgRqNx+EBBQAAAAAAAAAAAAAAgLtKS4jDT7+xZH8HKfq0WaRP0YLo5wz8kwgUXBGBgve7HjBN71zR + LPF+6WeX3vnTz1KABN4vmiO4qfSOl6JPux//0Z0L92A6Pwh7PDRP5yNQT3/9JDykAAAAAAAAAAAAAAAA + cJ82S/ZpQfy/iv8Nlxm5slnqTBEtS51wOyJQcEUECm4vvXul8GaaH1Go75d+NimcJVIKHyaaK4ikbyfp + G0q6b30fgPtXlZN6uR6EPR6ap/MRqOcno/CgAgAAAAAAAAAAAAAAwENKUajdj/94GTtKi/bRwmMfXF+i + t9QJdycCBVdEoODuNlGo9K528GgRzlofXI+QfP7R78KfFXBz0ZzB9bs2fSvxbQAe3vxiJ2zx0Eydj0BN + 5/vhQQUAAAAAAAAAAAAAAIBt++KHv69/8eM//SMMlQJJ0XJkW6WlzhQRSJGatNRpiR7unwgUXBGBgvuX + ghxdDkOld+/037SJkAiUwsOI5o9+uH7Ppv9vSd8/0ncQdy1s39FiGHZ4aK7OR6COz6vwsAIAAAAAAAAA + AAAAAEATbJbt03JkWpJMC/dNDkSl0FP6822W5y11wnaJQMEVESjYnvSut4lDbWKmTQ1EbQIk6Z06/VnT + n1mcFLYrmk26Id2xm/jz26En9yw0R1VOwgYPzdb5CNTpy93wwAIAAAAAAAAAAAAAAEAbpEXKtHSfltfT + EntaskwL7WnhMi3gb5bw0yJmctN41OafT9K/n36dzSJn+vU3y5zp97XQCc0hAgVXRKCgGVIIdBOJ2kRN + k/ROuYmbJtffPW/yvroJjWxsfp30627CI5sgafq907uqKCk0QzTTNMP1e/X63br5FvD2/ep7ALTT2aoI + Gzw0W+cjUPOLnfDAAgAAAAAAAAAAAAAAAAAAAABAFxwthmF/h+brfARqsSrCQwsAAAAAAAAAAAAAAAAA + AAAAAG23t38Ytndoh85HoJbrQXhwAQAAAAAAAAAAAAAAAAAAAACgzapyUp+tirC9Qzt0PgKVlMUsPMAA + AAAAAAAAAAAAAAAAAAAAANBWp692w+YO7dGLCNTewWF4gAEAAAAAAAAAAAAAAAAAAAAAoI2m84Owt0O7 + 9CIC9fxkFB5iAAAAAAAAAAAAAAAAAAAAAABom6qc1Mv1IOzt0C69iEBN5/vhQQYAAAAAAAAAAAAAAAAA + AAAAgLY5WxVha4f26UUE6vTlbniQAQAAAAAAAAAAAAAAAAAAAACgTY7Pq7CzQzv1IgL14v/+PTzMAAAA + AAAAAAAAAAAAAAAAAADQFocno7CxQ3v1IgK1XA/CAw0AAAAAAAAAAAAAAAAAAAAAAG1QlZPLlk7U2KG9 + ehGBStIBjg42AAAAAAAAAAAAAAAAAAAAAAA0WVnM6rNVEbZ1aLfeRKCe/vpJeLgBAAAAAAAAAAAAAAAA + AAAAAKDJjs+rsKtD+/UmAjWd74eHGwAAAAAAAAAAAAAAAAAAAAAAmupoMQybOnRDbyJQpy93wwMOAAAA + AAAAAAAAAAAAAAAAAABNtLd/GPZ06I7eRKAWqyI85AAAAAAAAAAAAAAAAAAAAAAA0DRVOanPVkXY06E7 + ehOBSspiFh52AAAAAAAAAAAAAAAAAAAAAABokhdvHocdHbqlVxGop79+Eh52AAAAAAAAAAAAAAAAAAAA + AABoiuPzKmzo0D29ikAdLYbhgQcAAAAAAAAAAAAAAAAAAAAAgCZInZyon0M39SoCNb/YCQ89AAAAAAAA + AAAAAAAAAAAAAADktrd/GLZz6K5eRaCW60F48AEAAAAAAAAAAAAAAAAAAAAAIKeqnNRnqyJs59BdvYpA + JaPxOBwAAAAAAAAAAAAAAAAAAAAAAADIoSxmAlA91bsI1HS+Hw4BAAAAAAAAAAAAAAAAAAAAAADk8OfX + X4S9HLqvdxGo+cVOOAQAAAAAAAAAAAAAAAAAAAAAALBtR4th2MqhH3oXgVquB3VZzMJhAAAAAAAAAAAA + AAAAAAAAAACAbRGAoncRqGQ0HocDAQAAAAAAAAAAAAAAAAAAAAAA2/D0qydhH4d+6WUE6vi8CocCAAAA + AAAAAAAAAAAAAAAAAAAe2t7+Yb1cD8I+Dv3SywjUYlWEgwEAAAAAAAAAAAAAAAAAAAAAAA+pKif12aoI + 2zj0Ty8jUEkahGhAAAAAAAAAAAAAAAAAAAAAAADgIQhA8bbeRqCOFsNwSAAAAAAAAAAAAAAAAAAAAAAA + 4L6Vxax+8eZx2MOhv3obgZpf7ISDAgAAAAAAAAAAAAAAAAAAAAAA9+3Pr78IWzj0W28jUEkqo0XDAgAA + AAAAAAAAAAAAAAAAAAAA9+X01c/DBg70OgI1ne+HAwMAAAAAAAAAAAAAAAAAAAAAAPfhaDEM+zeQ9DoC + Nb/YCYcGAAAAAAAAAAAAAAAAAAAAAADuSgCK9+l1BCqpykk4PAAAAAAAAAAAAAAAAAAAAAAA8KEEoLiJ + 3keg0qBEAwQAAAAAAAAAAAAAAAAAAAAAAB9iOj8Iezfwtt5HoBarIhwiAAAAAAAAAAAAAAAAAAAAAAC4 + recno7B1A5HeR6CS0XgcDhMAAAAAAAAAAAAAAAAAAAAAANyUABS3JQL1N8fnVThQAAAAAAAAAAAAAAAA + AAAAAABwEwJQfAgRqL9Zrgd1WczCwQIAAAAAAAAAAAAAAAAAAAAAgHfZ2z8M2zbwPiJQfzed74fDBQAA + AAAAAAAAAAAAAAAAAAAA3ycFoJbrQdi1gfcRgfq7+cVOOGAAAAAAAAAAAAAAAAAAAAAAABARgOKuRKCu + GY3H4aABAAAAAAAAAAAAAAAAAAAAAMB1o/EzASjuTATqmvnFTjhsAAAAAAAAAAAAAAAAAAAAAACw8fxk + FDZs4LZEoN5SlZNw6AAAAAAAAAAAAAAAAAAAAAAAQACK+yQC9ZajxTAcPAAAAAAAAAAAAAAAAAAAAAAA + +k0AivsmAvWW5XpQl8UsHEAAAAAAAAAAAAAAAAAAAAAAAPppOj8ImzVwFyJQgaPFMBxCAAAAAAAAAAAA + AAAAAAAAAAD6JzVpolYN3JUIVGC5HtRlMQuHEQAAAAAAAAAAAAAAAAAAAACA/hCA4iGJQH2PNHjRQAIA + AAAAAAAAAAAAAAAAAAAA0A8CUDw0EajvsVwP6rKYhYMJAAAAAAAAAAAAAAAAAAAAAEC3nb76edimgfsk + AvUOqcIWDScAAAAAAAAAAAAAAAAAAAAAAN1UFrN6frETNmngvolAvcNyPbgcyGhQAQAAAAAAAAAAAAAA + AAAAAADolqqc1C/ePA57NPAQRKDe42gxDIcVAAAAAAAAAAAAAAAAAAAAAIDuSAGos1URdmjgoYhAvcdy + PajLYhYOLQAAAAAAAAAAAAAAAAAAAAAA7be3fygARRYiUDdwfF6FgwsAAAAAAAAAAAAAAAAAAAAAQLs9 + PxnVy/UgbM/AQxOBuqGqnIQDDAAAAAAAAAAAAAAAAAAAAABAOx0thmFvBrZFBOqG5hc74RADAAAAAAAA + AAAAAAAAAAAAANA+x+dV2JqBbRKBuoXReBwOMwAAAAAAAAAAAAAAAAAAAAAA7VAWs3p+sRM2ZmDbRKBu + YbEqLgc4GmwAAAAAAAAAAAAAAAAAAAAAAJqtKif12aoI+zKQgwjULR0thuFwAwAAAAAAAAAAAAAAAAAA + AADQXKPxs3q5HoRdGchFBOqW0hCnmls05AAAAAAAAAAAAAAAAAAAAAAANM90fhD2ZCA3EagPML/YCQcd + AAAAAAAAAAAAAAAAAAAAAIBmOT6vwo4MNIEI1Ad6+tWTcOABAAAAAAAAAAAAAAAAAAAAAMivKif1izeP + w34MNIUI1Adargd1WczC4QcAAAAAAAAAAAAAAAAAAAAAIJ+9/cP6bFWE7RhoEhGoO/j69efhBQAAAAAA + AAAAAAAAAAAAAAAAQB7T+UHYi4EmEoG6o6dfPQkvAgAAAAAAAAAAAAAAAAAAAAAAtqcsZvXpq5+HnRho + KhGoO1quB5fDH10KAAAAAAAAAAAAAAAAAAAAAAA8vKqc1GerImzEQJOJQN2D+cVOeDEAAAAAAAAAAAAA + AAAAAAAAAPCwnp+M6uV6ELZhoOlEoO7JdL4fXhAAAAAAAAAAAAAAAAAAAAAAANy/spjVx+dV2IOBthCB + uiepBFeVk/CyAAAAAAAAAAAAAAAAAAAAAADg/qTWy4s3j8MWDLSJCNQ9WqyKyzpcdGkAAAAAAAAAAAAA + AAAAAAAAAHB30/lBvVwPwgYMtI0I1D07Pq/CiwMAAAAAAAAAAAAAAAAAAAAAgA9XFrP6z6+/CLsv0FYi + UA9gOt8PLxEAAAAAAAAAAAAAAAAAAAAAAG5vNH5Wn62KsPcCbSYC9QCW60G9t38YXiYAAAAAAAAAAAAA + AAAAAAAAANzc8XkVdl6gC0SgHshiVdRlMQsvFQAAAAAAAAAAAAAAAAAAAAAA3q0qJ/WLN4/Dvgt0hQjU + A5pf7ISXCwAAAAAAAAAAAAAAAAAAAAAA3286P6iX60HYdYEuEYF6YMfnVXjJAAAAAAAAAAAAAAAAAAAA + AADwXVU5qecXO2HLBbpIBGoLpvP98MIBAAAAAAAAAAAAAAAAAAAAAODKdH5QL9eDsOECXSUCtSWj8Ti8 + eAAAAAAAAAAAAAAAAAAAAAAA+qwqJ/X8YifstkDXiUBtSSrMpcsmuoQAAAAAAAAAAAAAAAAAAAAAAPpo + Oj+4bLNEzRboAxGoLVqsCiEoAAAAAAAAAAAAAAAAAAAAAKD3UodlfrETdlqgT0SgtiyFoMpiFl5MAAAA + AAAAAAAAAAAAAAAAAABdltorR4thvVwPwj4L9I0IVAYv3jwWggIAAAAAAAAAAAAAAAAAAAAAemU0flaf + rYqwyQJ9JQKVSQpBRRcVAAAAAAAAAAAAAAAAAAAAAECXlMWsPj6vwg4L9J0IVEanL3fDSwsAAAAAAAAA + AAAAAAAAAAAAoAum84N6uR6E/RVABCo7ISgAAAAAAAAAAAAAAAAAAAAAoGtG42f1/GInbK4A/yQC1QBC + UAAAAAAAAAAAAAAAAAAAAABAF5TFrD4+r8LOCvCvRKAaQggKAAAAAAAAAAAAAAAAAAAAAGiz6fygXq4H + YV8FiIlANYgQFAAAAAAAAAAAAAAAAAAAAADQNqPxs/rFm8dhUwV4NxGohkmXWVnMwssOAAAAAAAAAAAA + AAAAAAAAAKApqnJSzy92wo4KcDMiUA2UQlDpgosuPgAAAAAAAAAAAAAAAAAAAACAnMpiVh+fV2E7Bbgd + EaiGWqwKISgAAAAAAAAAAAAAAAAAAAAAoDFS/OloMayX60HYTAFuTwSqwYSgAAAAAAAAAAAAAAAAAAAA + AIAmmM4PxJ/gAYhANVy6+EbjcXgxAgAAAAAAAAAAAAAAAAAAAAA8pNH4WX22KsI2CnB3IlAtcbQYhpck + AAAAAAAAAAAAAAAAAAAAAMB9S/Gn+cVO2EIB7o8IVIsIQQEAAAAAAAAAAAAAAAAAAAAAD0n8CbZLBKpl + 0gVZlZPwAgUAAAAAAAAAAAAAAAAAAAAA+BDiT5CHCFQLLVaFEBQAAAAAAAAAAAAAAAAAAAAAcGfiT5CX + CFSLTef74cUKAAAAAAAAAAAAAAAAAAAAAPAu4k/QDCJQLXd8XtVlMQsvWgAAAAAAAAAAAAAAAAAAAACA + 6w5PRuJP0CAiUB2wWBV1VU7CSxcAAAAAAAAAAAAAAAAAAAAA6LeymNVHi2G9XA/CfgmQjwhUh0zn++El + DAAAAAAAAAAAAAAAAAAAAAD0j/gTNJ8IVMecvtytq3ISXsoAAAAAAAAAAAAAAAAAAAAAQPeNxs/q01e7 + 4k/QAiJQHbRYFfXzk1F4QQMAAAAAAAAAAAAAAAAAAAAA3ZTiT/OLnbBJAjSTCFSHnb7cratyEl7YAAAA + AAAAAAAAAAAAAAAAAED7lcWsPloM6+V6EDZIgGYTgeq4xaqon5+MwgscAAAAAAAAAAAAAAAAAAAAAGin + 0fhZfXxeiT9By4lA9cTpy926KifhhQ4AAAAAAAAAAAAAAAAAAAAANF9ZzOrp/KCeX+yEjRGgfUSgeuZo + MQwveAAAAAAAAAAAAAAAAAAAAACgmUbjZ/XxeVUv14OwKQK0lwhUDy1WRf38ZBRe+AAAAAAAAAAAAAAA + AAAAAABAfmUxq48Ww3p+sRM2RIBuEIHqsdOXu3VVTsKHAAAAAAAAAAAAAAAAAAAAAACwXSn8NBo/E36C + HhGBQgwKAAAAAAAAAAAAAAAAAAAAADJK4afj86pergdhHwToLhEoLi1WRX20GIpBAQAAAAAAAAAAAAAA + AAAAAMAWpPBT6n0IP0G/iUDxHSkG9fxkFD44AAAAAAAAAAAAAAAAAAAAAIAPtwk/na0ehe0PoH9EoAht + YlBlMQsfKAAAAAAAAAAAAAAAAAAAAADA+wk/Ae8iAsU7pRhUeohU5SR8yAAAAAAAAAAAAAAAAAAAAAAA + 35XCT8fnVb1cD8KmB8CGCBQ3dvpyVwwKAAAAAAAAAAAAAAAAAAAAAN5SFrP68GR02ecQfgJuQwSKW0sP + m9F4HD6QAAAAAAAAAAAAAAAAAAAAAKAPRuNn9dFiWM8vdsJGB8BNiEDxwRaron5+MqqrchI+qAAAAAAA + AAAAAAAAAAAAAACgK8piVh+ejOrTl7v1cj0IexwAtyUCxb1ID6fReBw+wAAAAAAAAAAAAAAAAAAAAACg + bVL06elXT+rj86o+Wz0KmxsAdyUCxb1arIr6aDGsq3ISPtwAAAAAAAAAAAAAAAAAAAAAoIlS9OnwZHQZ + fXrx5nHY1gC4byJQPJj5xU79/G8PNkEoAAAAAAAAAAAAAAAAAAAAAJomNTGm84P69OVufbZ6FPYzAB6a + CBRbkYJQ6aG3t38YPhQBAAAAAAAAAAAAAAAAAAAA4KGk4NPTr57Ux+fVZQdjuR6EjQyAbROBYusWq+Ky + gDgaj8OHJgAAAAAAAAAAAAAAAAAAAAB8qOvBp69ffy74BDSaCBTZpTridH4gCgUAAAAAAAAAAAAAAAAA + AADAjZXFrN7bP6wPT0aXwafUsBB8AtpGBIpGSQ/S9EA9Wgwvo1DpYRs9hAEAAAAAAAAAAAAAAAAAAADo + h6qc1E+/elJP5weXsaevX39en60ehe0KgLYRgaLxXrx5fPnwTQ9iYSgAAAAAAAAAAAAAAAAAAACAbkkt + ib39w/rwZCT0BPSOCBSttFwP6vnFTn36crc+Wgwva43pYS4QBQAAAAAAAAAAAAAAAAAAANAMqQNRlZN6 + NB5/J/CUehGpG5EiT6khEbUlAPpCBIrOSQ/3F28efycSlaSXgRSLSi8GSXpJSISjAAAAAAAAAAAAAAAA + AAAAAK5segzXbVoNqduQ+g2boFPqOWyiTl+//vwfYackakIA8K9EoAAAAAAAAAAAAAAAAAAAAAAAADIQ + gQIAAAAAAAAAAAAAAAAAAAAAAMhABAoAAAAAAAAAAAAAAAAAAAAAACADESgAAAAAAAAAAAAAAAAAAAAA + AIAMRKAAAAAAAAAAAAAAAAAAAAAAAAAyEIECAAAAAAAAAAAAAAAAAAAAAADIQAQKAAAAAAAAAAAAAAAA + AAAAAAAgAxEoAAAAAAAAAAAAAAAAAAAAAACADESgAAAAAAAAAAAAAAAAAAAAAAAAMhCBAgAAAAAAAAAA + AAAAAAAAAAAAyEAECgAAAAAAAAAAAAAAAAAAAAAAIAMRKAAAAAAAAAAAAAAAAAAAAAAAgAxEoAAAAAAA + AAAAAAAAAAAAAAAAADIQgQIAAAAAAAAAAAAAAAAAAAAAAMhABAoAAAAAAAAAAAAAAAAAAAAAACADESgA + AAAAAAAAAAAAAAAAAAAAAIAMRKAAAAAAAAAAAAAAAAAAAAAAAAAyEIECAAAAAAAAAAAAAAAAAAAAAADI + QAQKAAAAAAAAAAAAAAAAAAAAAAAgAxEoAAAAAAAAAAAAAAAAAAAAAACADESgAAAAAAAAAAAAAAAAAAAA + AAAAMhCBAgAAAAAAAAAAAAAAAAAAAAAAyEAECgAAAAAAAAAAAAAAAAAAAAAAIAMRKAAAAAAAAAAAAAAA + AAAAAAAAgAxEoAAAAAAAAAAAAAAAAAAAAAAAADIQgQIAAAAAAAAAAAAAAAAAAAAAAMhABAoAAAAAAAAA + AAAAAAAAAAAAACADESgAAAAAAAAAAAAAAAAAAAAAAIAMRKAAAAAAAAAAAAAAAAAAAAAAAAAyEIECAAAA + AAAAAAAAAAAAAAAAAADIQAQKAAAAAAAAAAAAAAAAAAAAAAAgAxEoAAAAAAAAAAAAAAAAAAAAAACADESg + AAAAAAAAAAAAAAAAAAAAAAAAMhCBAgAAAAAAAAAAAAAAAAAAAAAAyEAECgAAAAAAAAAAAAAAAAAAAAAA + IAMRKAAAAAAAAAAAAAAAAAAAAAAAgAxEoAAAAAAAAAAAAAAAAAAAAAAAADIQgQIAAAAAAAAAAAAAAAAA + AAAAAMhABAoAAAAAAAAAAAAAAAAAAAAAACADESgAAAAAAAAAAAAAAAAAAAAAAIAMRKAAAAAAAAAAAAAA + AAAAAAAAAAAyEIECAAAAAAAAAAAAAAAAAAAAAADIQAQKAAAAAAAAAAAAAAAAAAAAAAAgAxEoAAAAAAAA + AAAAAAAAAAAAAACADESgAAAAAAAAAAAAAAAAAAAAAAAAMhCBAgAAAAAAAAAAAAAAAAAAAAAAyEAECgAA + AAAAAAAAAAAAAAAAAAAAIAMRKAAAAAAAAAAAAAAAAAAAAAAAgAxEoAAAAAAAAAAAAAAAAAAAAAAAADIQ + gQIAAAAAAAAAAAAAAAAAAAAAAMhABAoAAAAAAAAAAAAAAAAAAAAAACADESgAAAAAAAAAAAAAAAAAAAAA + AIAMRKAAAAAAAAAAAAAAAAAAAAAAAAAyEIECAAAAAAAAAAAAAAAAAAAAAADIQAQKAAAAAAAAAAAAAAAA + AAAAAAAgAxEoAAAAAAAAAAAAAAAAAAAAAACADESgAAAAAAAAAAAAAAAAAAAAAAAAMhCBAgAAAAAAAAAA + AAAAAAAAAAAAyEAECgAAAAAAAAAAAAAAAAAAAAAAIAMRKAAAAAAAAAAAAAAAAAAAAAAAgAxEoAAAAAAA + AAAAAAAAAAAAAAAAADIQgQIAAAAAAAAAAAAAAAAAAAAAAMhABAoAAAAAAAAAAAAAAAAAAAAAACADESgA + AAAAAAAAAAAAAAAAAAAAAIAMRKAAAAAAAAAAAAAAAAAAAAAAAAAyEIECAAAAAAAAAAAAAAAAAAAAAADI + QAQKAAAAAAAAAAAAAAAAAAAAAAAgAxEoAAAAAAAAAAAAAAAAAAAAAACADESgAAAAAAAAAAAAAAAAAAAA + AAAAMhCBAgAAAAAAAAAAAAAAAAAAAAAAyEAECgAAAAAAAAAAAAAAAAAAAAAAIAMRKAAAAAAAAAAAAAAA + AAAAAAAAgAxEoAAAAAAAAAAAAAAAAAAAAAAAADIQgQIAAAAAAAAAAAAAAAAAAAAAAMhABAoAAAAAAAAA + AAAAAAAAAAAAACADESgAAAAAAAAAAAAAAAAAAAAAAIAMRKAAAAAAAAAAAAAAAAAAAAAAAAAyEIECAAAA + AAAAAAAAAAAAAAAAAADIQAQKAAAAAAAAAAAAAAAAAAAAAAAgAxEoAAAAAAAAAAAAAAAAAAAAAACADESg + AAAAAAAAAAAAAAAAAAAAAAAAMhCBAgAAAAAAAAAAAAAAAAAAAAAAyEAECgAAAAAAAAAAAAAAAAAAAAAA + IAMRKAAAAAAAAAAAAAAAAAAAAAAAgAxEoAAAAAAAAAAAAAAAAAAAAAAAADIQgQIAAAAAAAAAAAAAAAAA + AAAAAMhABAoAAAAAAAAAAAAAAAAAAAAAACADESgAAAAAAAAAAAAAAAAAAAAAAICt+7j+f/81R092glAs + AAAAAElFTkSuQmCC + + \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/Program.cs b/LibraryDBproject/LDBproj/Program.cs index b968d92..87ae676 100644 --- a/LibraryDBproject/LDBproj/Program.cs +++ b/LibraryDBproject/LDBproj/Program.cs @@ -1,17 +1,32 @@ -namespace LDBproj +using LDBproject.Repositories.Implementations; +using LDBproject.Repositories; +using Unity; + + +namespace LDBproject { internal static class Program { - /// - /// The main entry point for the application. - /// [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 MainForm()); + Application.Run(CreateContainer().Resolve()); + } + + private static IUnityContainer CreateContainer() + { + var container = new UnityContainer(); + + container.RegisterType(); + container.RegisterType(); + container.RegisterType(); + container.RegisterType(); + container.RegisterType(); + + return container; } } } \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/Properties/Resources.Designer.cs b/LibraryDBproject/LDBproj/Properties/Resources.Designer.cs new file mode 100644 index 0000000..d8ed35f --- /dev/null +++ b/LibraryDBproject/LDBproj/Properties/Resources.Designer.cs @@ -0,0 +1,140 @@ +//------------------------------------------------------------------------------ +// +// Этот код создан программой. +// Исполняемая версия:4.0.30319.42000 +// +// Изменения в этом файле могут привести к неправильной работе и будут потеряны в случае +// повторной генерации кода. +// +//------------------------------------------------------------------------------ + +namespace LDBproject.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("LDBproject.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; + } + } + + /// + /// Поиск локализованного ресурса типа System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap AddImg { + get { + object obj = ResourceManager.GetObject("AddImg", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Поиск локализованного ресурса типа System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap BookListFrameCover { + get { + object obj = ResourceManager.GetObject("BookListFrameCover", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Поиск локализованного ресурса типа System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap DelImg { + get { + object obj = ResourceManager.GetObject("DelImg", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Поиск локализованного ресурса типа System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap EmployeesFrameCover { + get { + object obj = ResourceManager.GetObject("EmployeesFrameCover", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Поиск локализованного ресурса типа System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap OperationImg { + get { + object obj = ResourceManager.GetObject("OperationImg", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Поиск локализованного ресурса типа System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap ReadersFrameCover { + get { + object obj = ResourceManager.GetObject("ReadersFrameCover", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Поиск локализованного ресурса типа System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap RegistrationsFrameCover { + get { + object obj = ResourceManager.GetObject("RegistrationsFrameCover", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Поиск локализованного ресурса типа System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap UpdListFrameCover { + get { + object obj = ResourceManager.GetObject("UpdListFrameCover", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + } +} diff --git a/LibraryDBproject/LDBproj/Properties/Resources.resx b/LibraryDBproject/LDBproj/Properties/Resources.resx new file mode 100644 index 0000000..c08fd88 --- /dev/null +++ b/LibraryDBproject/LDBproj/Properties/Resources.resx @@ -0,0 +1,145 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + ..\RscImages\ReadersFrameCover.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\RscImages\OperationImg.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\RscImages\UpdListFrameCover.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\RscImages\AddImg.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\RscImages\DelImg.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\RscImages\BookListFrameCover.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\RscImages\EmployeesFrameCover.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\RscImages\RegistrationsFrameCover.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/Repositories/IBookRep.cs b/LibraryDBproject/LDBproj/Repositories/IBookRep.cs new file mode 100644 index 0000000..db15683 --- /dev/null +++ b/LibraryDBproject/LDBproj/Repositories/IBookRep.cs @@ -0,0 +1,16 @@ +using LDBproject.Entities; + +namespace LDBproject.Repositories; + +public interface IBookRep +{ + IEnumerable GetBookList(); + + Book GetBookByID(int id); + + void AddBook(Book card); + + void UpdateBook(Book card); + + void DeleteBook(int id); +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/Repositories/ICustomerCardsRep.cs b/LibraryDBproject/LDBproj/Repositories/ICustomerCardsRep.cs new file mode 100644 index 0000000..27ece17 --- /dev/null +++ b/LibraryDBproject/LDBproj/Repositories/ICustomerCardsRep.cs @@ -0,0 +1,16 @@ +using LDBproject.Entities; + +namespace LDBproject.Repositories; + +public interface ICustomerCardsRep +{ + IEnumerable GetCards(); + + CustomerCard GetCardByID(int id); + + void AddCard(CustomerCard card); + + void UpdateCard(CustomerCard card); + + void DeleteCard(int id); +} diff --git a/LibraryDBproject/LDBproj/Repositories/ILibrarianRep.cs b/LibraryDBproject/LDBproj/Repositories/ILibrarianRep.cs new file mode 100644 index 0000000..57b0acb --- /dev/null +++ b/LibraryDBproject/LDBproj/Repositories/ILibrarianRep.cs @@ -0,0 +1,16 @@ +using LDBproject.Entities; + +namespace LDBproject.Repositories; + +public interface ILibrarianRep +{ + IEnumerable GetCards(); + + LibrarianCard GetCardByID(int id); + + void AddCard(LibrarianCard card); + + void ChangeCardInfo(LibrarianCard card); + + void DeleteCard(int id); +} diff --git a/LibraryDBproject/LDBproj/Repositories/IOrderRep.cs b/LibraryDBproject/LDBproj/Repositories/IOrderRep.cs new file mode 100644 index 0000000..ee981f2 --- /dev/null +++ b/LibraryDBproject/LDBproj/Repositories/IOrderRep.cs @@ -0,0 +1,13 @@ +using LDBproject.Entities; + +namespace LDBproject.Repositories; + +public interface IOrderRep +{ + IEnumerable GetOrdersInfo( + int? librarianID = null, int? orderID = null, int? customerID = null); + + void CreateOrder(Order order); + + void DeleteOrderinfo(int orderID); +} diff --git a/LibraryDBproject/LDBproj/Repositories/IUpdateRep.cs b/LibraryDBproject/LDBproj/Repositories/IUpdateRep.cs new file mode 100644 index 0000000..444fc87 --- /dev/null +++ b/LibraryDBproject/LDBproj/Repositories/IUpdateRep.cs @@ -0,0 +1,15 @@ +using LDBproject.Entities; + +namespace LDBproject.Repositories; + +public interface IUpdateRep +{ + IEnumerable GetUpdateList(); + + UpdateC GetUpdateByID(int id); + + void AddUpdate(UpdateC card); + + void RemoveUpd(int cardID); +} + diff --git a/LibraryDBproject/LDBproj/Repositories/Implementations/BookR.cs b/LibraryDBproject/LDBproj/Repositories/Implementations/BookR.cs new file mode 100644 index 0000000..3b3d81a --- /dev/null +++ b/LibraryDBproject/LDBproj/Repositories/Implementations/BookR.cs @@ -0,0 +1,33 @@ +using LDBproject.Entities; + +namespace LDBproject.Repositories.Implementations; + +public class BookR : IBookRep +{ + + public BookR() + { + } + + public Book GetBookByID(int id) + { + return null; + } + + public void AddBook(Book book) + { + } + + public void UpdateBook(Book book) + { + } + + public void DeleteBook(int id) + { + } + + public IEnumerable GetBookList() + { + return []; + } +} diff --git a/LibraryDBproject/LDBproj/Repositories/Implementations/CustomerCardR.cs b/LibraryDBproject/LDBproj/Repositories/Implementations/CustomerCardR.cs new file mode 100644 index 0000000..c2c17d5 --- /dev/null +++ b/LibraryDBproject/LDBproj/Repositories/Implementations/CustomerCardR.cs @@ -0,0 +1,28 @@ +using LDBproject.Entities; + +namespace LDBproject.Repositories.Implementations; + +public class CustomerCardR : ICustomerCardsRep +{ + public CustomerCard GetCardByID(int id) + { + return null; + } + + public void AddCard(CustomerCard card) + { + } + + public void UpdateCard(CustomerCard card) + { + } + + public void DeleteCard(int id) + { + } + + public IEnumerable GetCards() + { + return []; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/Repositories/Implementations/LibrarianR.cs b/LibraryDBproject/LDBproj/Repositories/Implementations/LibrarianR.cs new file mode 100644 index 0000000..bb7c0de --- /dev/null +++ b/LibraryDBproject/LDBproj/Repositories/Implementations/LibrarianR.cs @@ -0,0 +1,32 @@ +using LDBproject.Entities; + +namespace LDBproject.Repositories.Implementations; + +internal class LibrarianR : ILibrarianRep +{ + public LibrarianR() + { + } + + public LibrarianCard GetCardByID(int id) + { + return null; + } + + public void AddCard(LibrarianCard card) + { + } + + public void ChangeCardInfo(LibrarianCard card) + { + } + + public void DeleteCard(int id) + { + } + + public IEnumerable GetCards() + { + return []; + } +} diff --git a/LibraryDBproject/LDBproj/Repositories/Implementations/OrderR.cs b/LibraryDBproject/LDBproj/Repositories/Implementations/OrderR.cs new file mode 100644 index 0000000..7a2dd0a --- /dev/null +++ b/LibraryDBproject/LDBproj/Repositories/Implementations/OrderR.cs @@ -0,0 +1,15 @@ +using LDBproject.Entities; + +namespace LDBproject.Repositories.Implementations; + +public class OrderR : IOrderRep +{ + public void CreateOrder(Order order) {} + + public void DeleteOrderinfo(int orderID) {} + + public IEnumerable GetOrdersInfo(int? librarianID = null, int? orderID = null, int? customerID = null) + { + return []; + } +} diff --git a/LibraryDBproject/LDBproj/Repositories/Implementations/UpdateR.cs b/LibraryDBproject/LDBproj/Repositories/Implementations/UpdateR.cs new file mode 100644 index 0000000..59b60db --- /dev/null +++ b/LibraryDBproject/LDBproj/Repositories/Implementations/UpdateR.cs @@ -0,0 +1,28 @@ +using LDBproject.Entities; + +namespace LDBproject.Repositories.Implementations; + +public class UpdateR : IUpdateRep +{ + public UpdateR() + { + } + + public UpdateC GetUpdateByID(int id) + { + return null; + } + + public void AddUpdate(UpdateC update) + { + } + + public void RemoveUpd(int Id) + { + } + + public IEnumerable GetUpdateList() + { + return []; + } +} diff --git a/LibraryDBproject/LDBproj/RscImages/AddImg.png b/LibraryDBproject/LDBproj/RscImages/AddImg.png new file mode 100644 index 0000000000000000000000000000000000000000..b8c6153c731de5a4b2b71514326c10cf283141bf GIT binary patch literal 15037 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 K&WGFS%>M^kopl-j literal 0 HcmV?d00001 diff --git a/LibraryDBproject/LDBproj/RscImages/BookListFrameCover.png b/LibraryDBproject/LDBproj/RscImages/BookListFrameCover.png new file mode 100644 index 0000000000000000000000000000000000000000..fe7b9abd2135a206683dd25296aa85c79c6b0f4c GIT binary patch literal 94320 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%0DJO-Js+3Q;2bw-m|l`6 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 U@f%e!qApNf_40*`bLM{k2RS}1ng9R* literal 0 HcmV?d00001 diff --git a/LibraryDBproject/LDBproj/RscImages/DelImg.png b/LibraryDBproject/LDBproj/RscImages/DelImg.png new file mode 100644 index 0000000000000000000000000000000000000000..525856d4f161d5292624021f1d2e6245347dec88 GIT binary patch literal 15003 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 ZIvf*{MW@gUeg>mo^mR;*lxa~f{|_Pf_?iF! literal 0 HcmV?d00001 diff --git a/LibraryDBproject/LDBproj/RscImages/EmployeesFrameCover.png b/LibraryDBproject/LDBproj/RscImages/EmployeesFrameCover.png new file mode 100644 index 0000000000000000000000000000000000000000..5dc03f56004d168524775a96bf4257738ccf2b0a GIT binary patch literal 94636 zcmeFZcRZEv|2TfDq%<^)B$Ud?s;q1(35h5|93kr%WpAgULRJ|eBfE@4Hl1UXQIhT0 zC)=^tF^=`UZoS^`>|1>-XR9@p#>jM~|HQzQ*%34Hs2<5HU6sG>LN(c|W)`cR+8FQM_}otzL$ zmfe+~oFSEO>)%xk2~V6d!td8XIA4tJy!1`yU1^0Fe@J~rWLo3_oI}u2f?@wFR-Q)R zLBFdfUw*v)t9&fbTcPLFGuchetkDmt27&|&mL1hu^O|?^Tx8?C#WcDX@jC%*WY5K= z+ho7MpK=HHAgCx_)l&EKQoMkQPkK;OygAAA3{CL@8hSFzK=B53?+|te#hc)LmD&_9 zAUpXL80&u?Ie~wH*~Z4dnEA~V|MJXlJp3z7|0s!n^~`TX{D0KItW@QnZjY9X+am2* zjNg}>!j^R&#%oJ5;%CyfT>3{aFIs12+{>2Qs^dK0bukRlBWBcCSsRP%sD|KA^e4-S++UXJ|RSbj5Tr$?*$F35{Ca4a>nG z*}|30Ww9+!X)AJLf+F5#H(PsetTVl$>-QjzP{ul3m1vetDm-6cmd5Fqe0HNWq$_2M z4WbSY*F~#F43<_Es@$5$CunTcJkcVD&+nWxh?QCKq7;L9DoioE`|WdU|uQz+9T*d4_W zw_c~$QW(kk`wNDd*d53N;iiYNJ0jD5Ix0Lc(!95pN3UJ&u8>8(xM2I_O}*uI!xy|9 zciRJI8O;6iMs$lCS@Aa_2GE0gMu3*&%~9>4938!15H;nq9-(WtG{Szf40o96fmCwFU5rpJ$E?J-_&~;VUG3G=k11>er*Ju1WIUS%{7An3< zZSHLPQY`^1zYk4bITXHC%k#Lz9Ph=tEb37X)AgK)8#s!+ye~3tEbv>1emf;P3rsiii=Lr_?JatV z-#h!>GEW@+Oo7hzauV{wUc{+Xjadni63@9YgopPP^3_1I_U>NG4^DX4i*oPo=N)?W zivmu=2hF4j-Wl%`!<*gmNC3#qA8HOYlXnq6_}D0h$+%&*YBMSMNPOwU8i%<)E0xJP zYV@1ar3rTLB`F%-jRACjC%ak)ce3hja5c6}~ICt3rFuex%62!z+N z(c=ELCmx5fmB(RR7mMvq6fL|!fkSiFnBh|5u=X4hy9aTf0oIkPZ+6}Siio0FUe*;` zwVLUEDHIm#KszqCpuQDI0k@%fNR3eb+5IgO+9r@q((jyy|1YSB|QzH>V|Gi$?*0 zIXjQn)ao66x967f3(^eb_|}n zl?<-W&^#fU=|vQTXc;tME^t$_yJ1yIUne6Fv7FHkrV7$wtcHulup?L*(2x5lP<1zR zfyLDaD{}h!Y4inyg~FN*M|Ye_feqP;|`Vy~|#yO$+q9@fN`+t=@V+ z#c<}&U}5y!SS9HlS6fl;|AY9)6zx#gN@eu@zHNQxHJ1{<;B!%^ooQ=ox$M>7dKN{z zNc>sAy^If(uEFj(UNgY!6U_O(rE;Qp@M!{t07FrLa%R8@dQyED+dL1maEHI(*T0z) zWvY}I$bONesM&1UcPqLZ&Vl@S z8qa0Dvh`i{oi-ePh8}7LYJo_}&bm!NqfAVoGhWSx-BaS4i^MIp<0xe!{!ZJ7sO7Mh z{ED*8KPXDDtMCx|GYj}D)7H|#9j4##QS9q|3rBm2VaxRj4@E2P*WZ1nNiJvVPJ5iy1Qugp{o7y6mmslRZI~@pseLg=xIs$%6D1(= zwLoNz0Wh;BmD*8RqBsUKgKicf<1)%=%xNsHUkp&5cL9w)vSHXdS#YT;lvJ1kB-Kpp zeo}K3+bj&IFy4fWGJ(@i|9wzSLLw!-;}b^#FZux_uK;HJOYrje)6r_29uIo!UlFTl z6qf{Iga6`*uE;hVnBr3wtc`(SPy%t+)AL9_?*yj;u%42Xq+1DT!zqG}0)I_8`%nwP zuDYW9B}P{Kq#K3yLDgiFNDnKukB|4voeC5G??T`|q#n27UVx>Z=W&Z+UQ?j>2C0bx z8D9^b4SRkFL&4JJ-&;pStJkkO&z|n*MZQi6ZTMWEy-4A9L+R(mKk=@F%!b|3^8>b` zb%*{oHWubguLQ}i$k{N(Bb0cQv)5nE7K6XMP`0oA zdo5XDrA~t?oc#=I@3Vv?=q~= zCuKJz7(f2SgtgT_?jqpsjzFo{o6HP!2T<~%30J-sj26X8ZKL;Hhqp+ig};ET^(_lr zz9xADdt`L8u%bvtpOOhqvJ31(SSZ30{r$z%YCRnVe6C@;1(`mwHrYHwTl4)7UayS+ ztWkQ~&*`*>wI&>gQJS}4W56T<@W(6p#aWk}*R?63ABw2brWI5`n*~k={B5M5`E=lv zGJ?r(g2_h^2ydDHWAtmwob)^yumvH&=LU*+!;}&`@pqEja84W^)<=Q9fDIYN+MvwA zE(h^0-`V^FNz8)_Tr?B{1ex=P?e#~~U$@TU{khqKrj&7WX`nOV5VZ6Vma(S{yXgVM zjgqYzqs}pPnGx@-=o-SvB{}d=%#Lbzv@SU@b$LZs{eJ_O39M(A&ul)*(q8{Bl5)R9 zwlrKV9os`Ys#f!2fM7P$PB*=}X{yL~TkLACHCu*)S@Fv97ogbc`E2l7O*+_x!iAie ztPFLN>6T$$BA&KgjS=sy)03(r9b`6_Z~7>%Z|m)~3nq>~^Pcj>;XaT20oB}=fPW)! zTe2%b`zV&NG2MIp(#nTClq66cQ9K)oD~aqI;$0O$KVATuXzCpGPig;}@T$Scsx{1d z&y)+PQxZgL8@2d1u_l&?KKD<>z(X0=W*O{Ce*N+iSMzFj;nuYc8Be#lD!CHx2>UpJ zp2@Vbmuc(>$Ex+ODFtO}2-mH_nm(J1`mN4oBjN7%g(=1pk6D^-2!TkrhvjM04Z@>e z>|1s+QB#P`O~aPK0^rlU^5hbrsS2qQZy9eE$1kMoh8FZ1cug6@;=LWHCIc;*Ihyp^=pyaspm2^F#YMB{9X`}+hN1YwEulJGb=fcf! zVnq8vnm{jB&$Y5lJbOA;jVZ`IWE8XJz;i|==R1)3d(3!^GPSCDC^%;EbJ?Psfc}_K zK6>;IV&glrJV`e;@MVlKvkZpJ8Ye>-=RkZrfi;MX^=J;+{G7+(Hf&|oHKLdbk<^CTzcdthyR<9zrJFOFC+XWZfAFHdP$ zot!8upeG$76m&WdEQIU0tHh0Jw63QPKHUzx$_LvJM=>J&WPW}8EKo7T#5=l?a013! zF!L#^+gc0ojs3J*h3@)$uh*@TNa@Lq?z++_rMNA?|3%nMx6L6r2$IG5F$w%pXsCSM zBAxYF;s?mwm?zYQ7!;Rhwdhtx?{&g!20z|pBH2CH+;(hptik85rwTrf$I@nbjUHkP zjh)$w*c$yjMuwpRP2eypaCuO7Y3S~eTwF@Nt%vU6Eft= z$Xar?_ByScqy&J@U}KPrJZLj_Z$pb-YjWHr7k$^ypw8d6yQ)Gnu5Bl*s&8E-$at>y z`uosD&J^ZZ>a_wqOh?2{&|yTZhyS1f^2&agyP}f@5_tQjj$s6NEV+yG7RP0%QAU=d zINLv>G|P?G27pR4K-64OMNG;dopbe8p8aCUncmd3n;vYC`qgL}9e3AF#=6G*BD z#Q59uYSEr?K7l>H&dr~SS)Z;V9kJmBnYUK$o2wrpwpQ`FGUmG>^3XbX590CV@$Rim zx%tB&4Ci<4PRefaBt7IYmst!~--BvDOYT>OgVvQwkB8nD${t{|21`k_-3l;2Yw@AL zs%K>PRwq+RR5h$J^X>>)q zZ|jUioimy4HS`6U=g=#*-pBb6x*AgeYx8_n#ZTT2cf0+1zQTeEpPesdO6>6_({Ru< zkPcd7!y=B@yFOCr4=HCa9UlD-SZZb$G<3&pqeDl}!Qg&6Bq5 z{BMKf>1z(wU`0M(prM;?Ud}m3{j-968t zq3do2^Xp`ZODW%35gOB*%L*VTfNJaXT%0hR+8wBs08+N|Cv7KkGtcp_+OU13hD`YN zTPvf;q&52lt9%OZ6=2mHsbBy{SM^S_tyYVBa@y-x@pNA==NG3s4PSOPu}};QSB`+Q zR=-pCz;)T28kLO0ut+~`BZ@=Bg>T@yfx9#~zY^}YNaEIJ+;V>%-k`x({7+WcHJBqX;|tEAbciQV?XbOD zhF8zj>&HwQ%{C$;1RThOH-nwp=y`J&QnzD=mY^UK%@ZiKT>Zen>zuMlcu(#U4uZPDk01RmFFC>dLv#dbvRE=i za`?bzWb$D~&dDDw{WPC6Zlwi`yvVvt{gw3+qTEtlEtD50m4!(eCFN(4Com^eR-zu~ zEk#}CHnc97Zm?k%j;RSacqSrgg$VG(!K-)i9t}ScADEFuEL`BijXJ3Xt%BT-f|iC$ zE2zdnjW=BN+*KPE2YBXo8{8xRg!fQXhI^(`O zJtRy>vEA81jK5Abz$Pd|Dwn@B?HFpQwNRGbe-O@|EOhmey2#X1uy-YnGn%>Ea*E-2 zQm%*CClG3<^Nh}cq|Rwx9fjA@PdhW}MUlRenY&U~IQQv!g{g8Mlye8l|7!7;7Le`i zGYV+J4zkRW9P$uW^p@vYyRTim!paTm3s<+P0HOe^AX>%Zn$+*+*gA_ps3MAyM6Y`Gi6~3m0L~H+Cg44;ub%1?N z?^BbFRz*cAyo(f2ez>8r@Z@b|4z~6(q1Z~x17@dH58#4_ zYTIE62#0x?GBK(9W;TCs2IlgkdvRWzQJL*S9ipxhPiIBaI|`yIrq(v<4^Tl0ZO*^C zYn4f*IB&_-x<6}ybhQ<;r{T_gx1-tl+Od|K14zbLFVScQJm2lIu8zgC_&m1#&_t%~ zR$-(-O=_9@gE_YYe+Do=!SF*OcZoLR4xzYPJ_qE8)7c?)Vd*P)1uX#TYAKnp)0b;j zl#p8H-a~$%AO-lyr3jd%fQ%cP_sL_{OtqDgz!9#JL=YIG25OBw^Ucy2>$TQCf*xAu z{Biu>hUp5gTH6@^fdbm@15#Mj>U`2y+RRh(&UfozSs=(Y!XVd#Sn^=W0YTQf>ZFH0 zSG&Rcw@#lIRfRP{Z6$=--vTOEwq~=MroJ2wCn^99|5p#V(i<}@*~GVPFnm6OElzje z$G)H809nUqvM_@CVE=@~b^j}1mZGH-$eXXafWI)t{853C(UO%4%04nYYNNntT21=9 zPxcaRRd^*%V~g~H^+n&N@F%+s4G>dnCA4}=etPIhiX?-|@5)M-p~Y0&z#)1)Q1Lq9 zhLmV;0d-i#V%g}nJmkP($dDmc0Pkz6g4UxH zB$L{zA?WT0jonOBvn6ENFh9kWE;+CqOwYdCvO(9nr0?kz#yb^nx)lI#QMUqEMsmm$ zemCAode9CkV~S?0H#6?|nbTpUS#{P%G^zGN*><4B&}5Y_?oXCXQ5UYn?ao=EokA`* zDew1Qj3DVwScZ~pt3cK7UXXciI9nZGDixFoCxQOVCYQ6KU3tLn!DlhlQrJKnT-a{| z#TEacy>Jn{Kc_4eFfXWP+?$m05ScgfGSY;AU*{7|o`vFO1PHn3VWua?w!YMA<$)i9 zPI_)3;tGyLfq?j1zDjbMR~zw7cgkYV6bVfLgaim53K+KRk_T&(+L-JeTfLLHDas=l z8?mg?PpYgB1O<)^^jzN%+ELOH{$(bO z%~v5F3HA&HP@&AYMr)|q7|S*TL}+5v|5$-|IGY+z7JWgAy<^>gcvN3_L9gx|k9#qt zOyvSGslZQhjUjW*8jawofpa@7U)x z^JFiZ6xN>+ruK8v0#fKM#ineX1JL{+2olB3gAihY8k z>1A(EPP+%GNY<&$lFm!gd27mQq9pjWtIAixvL0=lAhv}ac#dRI2g*u{ zA;Zt-YWyAnY;LbHGynbNhi9M5lI-gg(90@RR;1%_kv#ro^Y@9m8U0sJQ+16)R_`~v zy3Mwl5o={IWHE!>!d`^7g=vN$q^qOr4z>s|f+|pgivNeqHF<^&n-&V zKH$AMCYUog+s6GQZ<92>7S~!P@CUz8l*&p8EiNU_7Zh6{^9LX=dZ0F!{yBDjvj&K1 z#4TZ-k1SvS#W~Ser(zzQ7t}1gg;P zfu3Y463U?KpP;=FI7tiof_*&Ro*S-Byv1!g*p{WHiP!WPY>A6rQunTTPX3r_@udgB zJAO470Y)K1m$?)e;fJ0(weAf+15jrX%TkNjF+W~t>&5AYQS(F4l{sHHsRnX;#AHpc zMUY=GUNGb*@6XpiaZ!Ksp@06>_~d^oc~{Xxy1K!6Q7iU(bUiPhrkd`YKUvj5gJ0ZO ziT^p@3$jb>I9qnIL5?e~l-%%^?q-29L46D`4#VUdBoAZm$yIZ(U}mt(YnRDX*s|;g z#n|1bebXO}zXwblrK`93EiqKrQpp5)n}YoJqM@UqX1zIRTydjY1FUEBTk! z`>M!5Hk<;z45t`sOY?4cl0bnMFq&MSFG0)npIimXRC2N1A=?9>;9)eG9uY>(68CD{ z&;lhP$TbfT4dj$AEDh{~Yq5>ASJ5EKw|gH6BRu#`Sf^*+0QrvWyNQ9naz?mBspZ(f zZiD}9+=#zp#gH4kWj`AoaRplJCU&WzK`GaOxE$*C>4B~zcv+}J6G?(lclz{Mph;(SH24d;T^`2XxM>Jrw z;(%*G-q1Sm*yk2=of8&1OAqYr!d;;~3aWVul1dFixQj0O;g<)Ua)D~C&0WL<$BF?8 zB;HBF?G!9?zaVpIo~23R&zj3G?m@8k15Z|tmlRPZYkrGwCoXk{T4%W?yF6&VU@2;# z_(Rha*gLmT>o`oGw?*e4w~S}SMy1!CeXeYyvcSVQ`W|-`r^7mow4-=A;Y3GV99lqBxtEAkaSK76{arWhx(l69mFnY4s8w|$oy4o#S90X#xXGhd?82oh z?wfV^EwywKX5y6EV~(n(LfJJrY0N=c5YoDxAQg=f`^%h--+{eHh%&TH_Q7Z-piXpx z#>m9cMYwbg{=zKbBzJYc@n$2dc9Pwvc$G(s``Z&h66liyTm%K% z3r6-eCP7P2tAgIh7_cSZ>4Nv6{GkrSb`yAXt~&NRQ5?W|*1mS#AcYf%c1XtCkvtMTO;f)Df1RT=9#7o^xKTgKRac*$5 z$rk^vUg{E=iLE`|Ke2NJq>~%ZgKa(`VPKbmTYQPZ&$#sm8x6I7ZQ93q>YxQ+xen;L zd8(6&;5-CdGHQdpuaw(}O!!=YDx=y~+j7Q>`#qU-#K9(tj6&0O<{*yn#E?(Arm^C^ zg*Lzv0gnJ|9Q2n`9-RXsHsC=9Oi>URgb_g%{|ICuIri1RB)ncU1NPsaFEqB4wQ-My zt1zq1+x0J`%!_!z^aTfTjYSg3s0z7%CQ~c5Ed3Lnz%!0M@(q$J9b^7sI+q_g5g1XE ztK(mINGZ{Th-uA`lP(t3|5(=Eke*lMzJl>5;{vb{t}KtDvk;CadrG1uoaCl=s?qr{Nj9C*lCm%x_jPXP5t~)h~yv zd_7hHvm)Y)-ZyGMy^E|%9zZ$Whz}atl67}JYOL+b>9YQzLGKQ>a5CYBE4PN>!+kAp zsgf$jAOGaz)Sz#U4r~?fydn6SG50M4|BP{tZHl`n=8;71+sl+njEb)m$ zgpr~DddFU$bcSpyoTC+0);GpAAG@s^352X3|G;RrqzYLQd#1Ua>m+`3er%BsCti*pm(O~B6VUs|xv2R{U{ ztLxwXtOrUf>3V@SV~TFlIUESd$!0Lpo5{>0yqTWP*XG(P9_~_kL#6lr<+mT-`epq4JnC_|n8re|0Gne`&B5`1mV?p-R zKIm_Sn>H6n)`#K->)!Ft<|Mmy*)j>qUs63E(~ArAit--VsN6yHS{+#^^IgL(*pMyp z_N}Qe+D&_)MYX6iI-#X;>nE4kU3f`nJtr5%{XWg#d=$jrX1|21=l;IUDmTyyvPmC) z;7Mx;MF!6aZ@wkz<79e@`*P+NT&{op<)zxKcHSj?>(3Y6m=(u#j-OyR zQc#49O;~cxguC8K5g8VT;@kU?O{We*trd~D>6Zzf3#)jCpf`mgw=QlJ5{#1)&C5Jp z1q^wCG!QxWGVv&U)I0p>r|g{9`f!7{&gz(>rrYOclkUvexBLEJR6SJp1$t(qgaJ^Q zL0ZX9Gpd#Jqrsb*PA2z+7}9pROzD(9>6rNWxiGIwoUkHsw1Aj& z!Q%MB^5zWMsKoTBy5`VYYQq-ipV6U@@f|rgsg;jr{=}T}phkJA$l5oYi1vjE=U2d7 zJth0_t{|bx2xRG+CDNw9RRg)|TDsk&bCuc5G;YS%wjB>=(+0Zkt~2PNZ2TBe`5; zo2Z90uNyV$vG~UKds?@2{f61rH=t7e0zLxtACDZiOgKd=^Rj0*{66ZDfXUs^rvFI9taq!Umf4>usJx<^wxlk z`A`?r9;~=I>FJAQuFEMb9YU1@7XcOHx^`Aw7XL}OPpkBp@N16$0}$_WaCs#@U77&S9`8d ziR*Y-r-=EyRZFfJT;#P!teXAgFQ5&2-m)ATw^22SSj#6fhC>MepyDc1kjQrhP#Zt^ zc6-SnzTJ~gg4dX;SV{Axs`=*isCRCOnvt5q?>N6O-d}K6rhP~T%J&4Vex%uh+t+tM z%*wKf6KrKRyDb4_QTLMf*4whh21%%RZza;$3YbXG4Z81^xge(6yd+H~L)?kFK4^&D*Cm6#*));fFy*gzq1LyUFyTQUZ2fX4Bcr-)9(9#-z5%lM@v+p z6STjdt3oS!t&Ej(zGbu);_Ri}c=y(Q-ADS-;;+6x9U<;q0P42uanhS-*M=H|>o>=(tr(2~PH`5;|TgL_2xc0|0>-6!G*E)q+gq`EDiS&6f^&D#NSN6^P4 zryYM|^GKm4K^`y9)fYj%TIYMF zW%>wf#ypTVHpO4gOQpQ||#^qp7194%8QxcR|7)Z(Lw zUrTc+PTt2sJx@4!)qCTc*x+J_okCyqBN9*+Ur#1yZ;b`n*w8L^is@p|ZOddL7w>m1 zk@Lpo9Vp97t}a;TNl#O8*ndc25>O0m9;!Y1VtR^gUoXzOTpp8ja$%TVCThbqD(RPq z>IYRS%Ud_sS7Obr5Hr$R2rgCZW>pZ|tS1@&rDb$IL-Wprnq52r%@XYn7*eBWKOh@g zXi95()w~WB*Pe30Xhnr~zcmO_jNRys*o+hoSQ@K{jy_1H64gcX_aa(ad7yYV(Jv)y zv2JK4T<=zE>8)qX>VcSzKBnr6f%DP>ER*2MHCF1syDVZzL%W74MzxdtbV(w(zX zlz#9O@V{AfhV|s2p!cS(Z~?joW~Vwr9vLHTXvF!VE9s%MWcpXhgJ0jf%eW$d`)j(a zKZc3r{OT3bHf{eREZMiO&T08!P< ziH&6^BR~9kUMpxeUz$8n1TTj&8T%)E3c1J>I(Uov+-5v5@tv&R0uK;e`27VM=wAwKm{K)=4K+xX!A0VLT?~IMV;Kc3-jsQk>oGsNT_$P1`BVxUz{!9Zw zC(Xj*R!T~Y26*L|Ghziz6Q5KsVR{;Rxtrjla=|>E zo#aZM9+KNU$Bx~h&Zc0c)%aVW4*e(Qn%OUNj?DdpP|^95%Ue^5g{AMh zt4tlVs>vaM>;MuSiJxZ~;`u=E*rdZVy|x5m7uGep&kTAz3TW@m7DSc9@`GDieLOa= z1;}UXc?Gxx3ay*ZkxaP0M)$7k(>JvERrEJoL@WhEa)ZMakdF95*A04pRj-Y71Y1Do zi|$A1%{49~qg(e}7Ndq{-;x7W9+2j-QsU+X))DkZ@TcOz=DhZqtu60B+l^kMAF^{5 z2R6h42>AxHB!ri1o|s6%1q_>lWNF8%rDhXy0Ogo(V`--{UQxGxi<9xbsMSEXgx{Eu z#c}~BXGg(hvj@U3_m#$d&gsa*g9yQH=K9>2yMKLO88K{nf-ps25@?GEl3dO=E^r5m zFGgX~EmMq+iRDOY&Dp}5B;|0`g$MhR8q0_Qb@Gl5U5SsT4>Z*O0RUxp@gT#wk7Q&7WFQgvxV$4B&P#zXsNyFXP~+MeM;Q5 z!WFmnJ91R47>`}h9LMs;@j)?XZsxf_{XAhhj3R!;u?@QEEq?&h);fC;RNOw=Tc!wG5-(zMF{Jp?X5|Lu zFyKIYJbm+-mfybfRI=|Sx7o*J%Yaayz#dff<8|ozuW;yxTl1Fn$Y9z{7LY-5o$y3q zu&)LjMi!5uu?oy18xY@+J?hk8J<6lN+aCCl6PZ>jys-pK5;>WmkCy>Xcvx5ajUO!q zkZww-f)iz46k>CS13()JvQBf&EkU@8z}F=oK>ZFp1yaaM+R;Q{{4&KcE4eTj#C-ZP zw$=W`M+1$RTaJKefAzNj28Q7w@FOsLoVFepCRlc<9Gz2ZkUjwxPZsk+(CtWHG<5q~ z)N@j9nTwQGIA_8+SZv~?H;Tyij{{Sp3oaB==ixcz37hKrFAKMvY7iYQYo&Q0#w9}z zG;Syi#T#jGlg91W+*&l2|MAWulhAAb3zuAAq30%s`d9mQbpX9r^|XOcaT=fn!-EC{ zI7&XUIyjO9owK$lP0TS(H;AHCD<%LxItBSmPmnwH5ab9LDxOh>r5w(k+z`AM$dMnx zIZ*$_c^}1j$6v-^Jj(|{DAgsI+@5I2efbUh*Z3qt)<3S8(P}>V4j>4UfyXVl$rd}q z3KY~^@A)r9GasCdN3TqEtUi=1XpS@%0=#mT;&KEO8l+8Z^r8&+K4{lr_HR*~o@7;` zy>A9w7wYU5d{L_>rq>hi_R1FFU%f=^o4{=?CpL-89#0>w8JINU)he|u!+Ay;lw}Jy zt*ww_qa4TL_TICmEiK#o?Uoby7eLesZ@o>|+no<7U(4+VriS7%`9D`cG5*^GVCY}G zz-%J-FEhYs_?H>}Wd;}n+t0tu0Hfhw&G0WXY-8a6m&|bOX~qG%fUis6d`_}!XW2Le z5hwZzy^>qpiyu88zL9-nP}b$SH@l6q+UcvwGE`ep)n?zMV@p$|jN4D>qB=>#esA4c zJtHUNo4KeHb=ABS51o)^=~JWRg_ALK^hiq&(c_7kpxgK1VKuMRYmcPV&c%)@xxS5k z8x+z%7k|mZvuagEMLwsQc)7#|v`fyX8?;-7<}V5hH|s@Yui7oRF4i`h&v-^ZFSYgV zB>B|m7sPq4b>$ao%Nls^8>*Rk|M*>o&AnH$4t)pWLCP{xh3TmcUxZ%C`LZtm2eKu{ z)NIj?-nA)(I8gy#6L^NMvX|wdi{%=wC=RBPSDdR> zjQ&Y;l7%q(ggT>Y!TuEZ#2_fG_DTMFPIJSqe&k&9%&~PV$S$NEw-<3g`?<_PotBb3 z`cHxT#oTOzoPrk10-W${c|q+xPFZ^H(SeJk5vu*+_$xcbnRVEiu$K?)LA-CkPCwa7 zgq8-l1Y2@q1)9akFM#ODqR$k$7L9StG(N4#?vvGvE3>+c3~9y*_iP+5`#$2PhqR@F z;-j9S)wBEi0-gmq1*^U(5%oM?Y2f#hq&$<%`tiRE39X!q4nZ0_l!#$OGBxWjJjAfF zSCwkwGBK(W6H|Rr-Fds6MW}O(KwgX++$3jWDfCiRG4}$_9YKp|QCP8DPFS~Fet6*^ zJRl;&a-Ylg$iM26iX1)in2#p5U?MC&BK57aFui%=FGuFPUa+GpFd+LRw+X=GAXI-f zkpR52v?BaWm1)r8#kr&R;Yjt@=_?@MfS+^cdUwVh>lSdpP~i?HC}kbEf8ae8g!0&n zc>fjrc;j%YPp9lqM7vD(=|7RDoWiTX8%yo}UQP)-VxwJ$ob30g9+z2o(U#lZw*!*9 z2Btm*aED3kd}|MC%mA9qWYt0LzOeL(?KrtSQ>o>iX1utF4Dur~E(y<-R3pY}aoj3u zSM=`2dj^uAI3Wkl7OLOE8NBp2gu9?Pk`yk(@IpOBfZN|5>ptbgFBi3&_X#zGk^&Un zEyGe_Ft(0$Kec&(#u09q#^L`vGTX^?J z{1%u=i04VKOmU-Rv%(4xG0b)t`SA?@^=)ub?*f8E6Wco4JUi_WlE%1$@jBf_$CxB$ zmH@Pv60qS`&KrPG-JE4e0HQTBb=k3#emm27j)VX5dzWdk?ST4Tg9FZvg(cE2@1 zjXC;`u)4ZwpPi5#J2=bQ$5GDuX5Zo7)2iN%hqqDI8F27-KfvlwaHhst?vodL^LJ#$ z?1)Y&151_B!U=--Ia>tWz2_(@SSjZG-tKo#<^wvyq0}ss+rT@D$#lK49+Y%P3VlfV zmcxoU-Fs9GY1?uLq-}pKftdwck6Bm6)MGG^s6MK651iSIzfpZH<#!Um59|UZ_^$T3 z-55Wm`Zy-Ct9NZn9|HM)p--fz33ZIZ%K) z-QX~*P3?%nO6!W%42Or~#x@=00-G^>^ACyRzf-NP6(bTV6}-{AvLWc<1Xz)(l9p90B`#CTEv-IZFafdb>7-eucj3Ny1tDq;*AQ>r$P*MK}#F{sR!Z!_p*TV z_clsV>rn@(wvV+IGqXnS_j4W|zXme~bo&miL3BW|!K_4&CoA?Qt>N!ZAn9bI;)iIV z?{FGjo_q1LbbC$(mF0BqK2q4t-(8!&b_8}@C~n-x+;3`qFs``Kwa|Ut07eKxZiTj| zz+sTHx72^9R}jOIe{&Vb!p)tIF}2LaQkax<8?uecd>8jI+UX? zI7UHh6;*g$cK`)D$SdgyfWEyyCgtGDKzV#X&<$$Wj-uwha97kP7Iy1uR?X#3hY+mt zgw0m(V%bb4#u~AS10PF3Z_k|Koo%KNlI9%Te)lPUISx9IJ%)cg2v7NZQ>}-gzB&sf zucYZy7%=l{S>RpX5+g{;upC6mD7PSH0MRgTUI*pHA~Yw$f@F!HAnbW^im(JIK z=jw5pHz{QWoYP=2X}m`fkFi1**XSF>_;sJ5LEi5DbNOb2++ zpO0=q@XNr1$FpBkUTVK|Ine2bz}FwGHe1)IptJ-1yy`Duu0MEN zpd2PZ$GLzet>71J0lzl|2A9H|*IU3sI>3Rr%zz{@UP&U|A2h{GPA1MkD4E?(|xT*u(kvDkoq`KdDRq1+i<`z zKUA5ljf)`uBRau}Q*ZENZ2Ke3ZM@FIUb_cd6s z|Bs9f83`S9kc~X2yoEI@obqk|st+RuB%nSCNeK_^H~~7KSlX?AP`kpq6#Rl9@nh`P zOS|ooE*<)4CxKI zWjXz%{6fMqC+raY*2(HxfNOPBn0^6|Xj`9Sujl6Q*49;rwQWzwtsCXRyCo zKr@gE;uZ%e#C(|Re2d(8wEsZBHl^;RU+AKpZw5XW+(|CP=|*oi%V#RbumqfBw0jju zVugl-Gxa_>Av~pO+h~u;yC1ctu&RSE`dutmxV}@=6rcd;;GN?(LSCv!uu~!43gF$M z!xI)~6tXi@RxSM>U18V=u2g70cJtNLo?oXe>Zbte2Y}j82I@A{Z)ICdOg!=kY`31b zqa6mu+XA*1b1X@XOYi3HhZvxQ4c5=m(f}O}W+1%WzS8~tl!)4Yk^c{|~F5=WahzSsxkM#qR~Ug&u~w7+h-)LF#HL zm=WYZ+8o;dMC92+Bz)>(do&R-z{?Ocezuq9)3MWt^ndinPQ$5_J#6qy#emI|M|Z;~ z1NLnnnQwc}p{YieX_=?u3}_o}ac z=ffB&GzF6q8jApu(YyAwbjKKavGmwBYCv{7OhmlkG*B+vEI1s-s0~n5R)=KYo}^q$ zr77M0>-kHB<%_x9ORy~fGlu}uBqv*(BvdoO0}qEfF>-mw5Pzp*t&)9nSQE6l%R6ds zPo8(#4WXWZOC!Fkh+%;$fQ18Pr^FJK98>kJ8(2E4dpg^~hRS>m3Qaer4#pp|=*_GU zf*^V&aG!1^h*p4Rgl7r8qT6c1wPkl#zYLh{v5WZ`)W9(* z;N!sH@h7nu0)SVBFMzIcN=XW;pjgZmr!F!*Y0iOa~ zR-6{#aGDR6Gq|!W@+d+<_3UqH6jNIVRF5n4oM!=KWtL;x9}DD)8{k{3IZM-GnFsDN zFATgNpvmJ;Xe_!BVf+7^OJ_gi@fZPhfcm@*-C+RTlrW2ZPNqBDD>x$W;XvSrwI}mM zMQ#ERR3r^E%geq{?P!k6Sa=@8MtD8REG7hwZB^#+ z{SfpNlyxkv!OR6BBd`TV86{C~@HZiO^zV7f0+Z$juW6h^dNiMhBebETHq@R8LScc# zxIVVC6dg&}mcB7?WwE-u z#r0LYjMqWG< z1fluURA9s8Hu7FCes*#*l0jL%J<)w1#)c;_Jw??&TDR+ca$CS7@B<3@={)JmXfJ>^ z8%E%51wR96w2$Q@gPl+#9k>e$ndA#Lft`h?(i7};&Uxd#>e${5Ci&$HD8yX~Y(*c{ z?Yh~<>wx?RVgCYjY5<}5>I0a?%NdViw66FWh-GB}qE#INrvTNp2;v#;U)A-2l7-a- z>{`HmvKL@uQQm$8qg4X}5Gp|7ZDo3^L~&A_@3x+rM8G{dTwx^tYEP>FsZf#aZ2h9e!2!qWh-liCFFkNrp0 zWi5KA3aamc)lLE8dmQ)&s<-vj%fPnF=dV|QqAn@}#&GQ|KoCVAH|5c-Z6#Np39hm7 z2*_Iq{jjYN5Y`|Fw$FUQXY?_i$Q$!pSZkwU>3f$nnyfjPOV!!}s3WWj_E!B81vs)P z|A#++`6v7Avv|Cb9aG9{v2DfF55k;n7m^~qgV=60X$Nd`IX@7G9+X2rrvCS#V;uAG za)@3o>SqCRX zoRn^&Y$`-nX4zZG$~Z>$ilgj(@O@s#{r>!ZuYc~`=e(}#d0p3YKOfKQj6C=3;c5OR zbVBK9Ic?MSHUposwvy@_O#j)zi~N$0rEahvIxm{H_PSBWX(N&Go9Wdhb&Rk$&yS0@ zKFZjouXs>lQZJx=b}q_WI!a~MZa1?JWVUcmg)v^TWgRh&e8)8#rM`i+C|`!XiD2#G z1^nPhO(L)!OTQR!^-Z0=VBL&`SNAyTn!*Pdyx8^J;{LuZ(*`@=i+BF104CsN1HQ35 zkXu46_-+X%OJj$<5lKg9uWeY(`z)MzM^)J^9K2udAz1shkG%r!oiv(vd%MAR%+Q82 z;LW8(F3wzZVIs5cMcZc^>~`G+#8iqbtY_`u=daO)(x>#P)Oi ziiJw#BxU-6yGtC6@6ihSDJ#e~(f^z0!d^bXlm~-5p7Y7X5aoaO>%mJH=dA43^938; z=e8e{%J?tYD>Q8-+mml^@&dVQ~oG!1HK^bK?rwNEP(nz5wk5G)QJrrI@*GED8|f8jTy&v**;duNE!o%O zZo+>ILz(X&noqBW_jvhLo?7_l?OYBFkt;Z}_4xxYO$wb~2<3MCCxaCBy2jY@GeS|qj z&96ED3pXTqOn2=!lA_r%OpQcq#6x3?~Dj zPN~6TwV}JvO821yDg5O6Sl*SbFtCdV{DB$#2ev5Ova3jz5-fkZS)c)XE3N5xAoH}A zC|q*E3QRS4%;BEKMU0Z%wC8K)OR@i(@X#~g53Q;H+oUvBJC>MhTFy6o+da7-bxeKN z(``#T3d}LXfrfa<^bd{0k>xMLrpIFWVPMy|LCNxebx3L741wD6W7Wb7^k4FoJQgy2 z6T20*m>T5O;@&HXYl)-PA@=Djw{oK0Bi1RK98vgXMl}jQ#Yhm^ghnB{R|0 zJrRz|{TI$GG*?<*xz4X+&q>EoG-Ikv8#o>`Xosui2u(Ig$8vSbFqP|;6|VtkWd4E8 zY~iYQhFDH^K9ROtaMJ`QLEO&S*go`KK@|%B!Cq%EX2G+P?H20dH31L$_`D3G)e_X5 z;&Nta9*liK0F#c`Pb!+L7*CszVv88)$QGbT1ZQ-2lJ+hOLr_*x&(%&EV3KSfd z!-pe}{qEmvQ@J<)NLA(HcFuMg$5>GK=#3jJ9Aoa9-uK^_i0?8{sW2||>n4w>ng8VG z^7hginyobpRk_+R_s%CPdQ^k9^-SQCi!sjX5rZI^lVncF5u zg<^haMckW+Hd~D=a%Eoebm~|9jvbz8=EMUq>Y-ud6JD#Msb-!l9vDi4Q z#Xip^h}Ay2?8DaZb7yi%=K2H^gcxkNr<_5Jr8UBzyJ(&p+$!79wY|U0zO>J~Ii@rI zjRROz2zA^a&OZcmOhVilpGNb(^Ug%*Bl#_b1JC2&UbpAlMRhhCHR7E)2lsu+St{@D zjU*V9B*g5Tv>kht*BrG#+#Bt&L&c@}ss(6W5E1>X_;#EMP(c!v?EI0Xkoo8swU)Gi-`OYnTk8w8AG}Lbu>$|u2 zr|W|d0BPEb#T(_U`JBj=BF~S{=#Ee?wJ3Fiw}rt!=Z{wBI1TRGB-aoTq+Pqjx%X7F zrvh6=Wr^=hP)^!anbl{rc1*ZWCvQkc#43A#NzDa(F)8}elXr$O zrcy_+-s$<$!N43)p||#4{0GkQDiX{TEt}y~>8AIm8%RT|ZmI9Eo_%Vo$vFj_+%sYK zW?o}3#RpgS><3QuvygOn`0fMPI9S!s1JUY|oqP~vbRhLM)!%q5YGec22Q;=iZ zv#e=b?PaY;;M5dD_b$xri$N$G!09tG8yOaL=p!Nw!g)TejE_#ha!4Yu90UEP%B#jq zXK)JZ!k`}vIev_9$86N;6Sf^vKlbv1?xOd}49Rw-dbyiUcCe#e$r%}NJbQ^USrfe7 zuM8ks?Jsj2I~LbhlWUpJJl}S(xu15oVF?0B7aEHM>SDaHVI2U?;W^Jv3T*4X3tMmu zNn|?#UONVgZ?pB~q$62f;d*pQ@cjPN+YjHp?&&{7g*oe!X|TUCvx7r+fQyUyR2lvg!5 zEe}q&4BGJ2#{Gp;U4okui|cGamrJz{iwf06Beka`sW2_}u)xc5Zno+wXGa?wln|Aqqi=%=PuxJN zB+=Wp^W^X{`iG{1rO~UJ2ZC4F*V+{KV(^2KMqT&M=m+h(_rLej_SyN#GMB*_hp16r z?EZ!Q@M7Wqb+xD$e&(6j?bVONZ}(se))~O0a{$RvG5T%y&uk~Jo-ZxNA+ILueCA8< z^E>Br1W9rVv(3Of*C{p&0gZEJF~e`khhtzLW;u_@Bsm{=)A?HAzvX_f_?GkNL4F*V z;q#PDs^~5#-XG-ZNf_Qgf5?>uk=tHAe(cNmPx$? zT1Lo%*J9z3Ilje!+I} zl=WJFG&%atM4OKJ*Yl9m-~~6+RxHWwu4kiu@3<5!7o+q@xnGhQRHODyBx$4XO1dwM z9*Q(i&S|Tj*ZsW&V)Kfd3b%8nyg%0?C7$X z7vlpK>6vbK?}6usX*{&LN8$aFf)*DQ+TOwp*j_IUB-+}Bh}f`9&;j#oHYfkl7D;;t z-|J_9U$#Vao+sIv_wd3Iz+3+GC8e;bF;T}@Fxpj=_w4?8_qx9B_u_5qr5CwVcas0a zuwvq~;XsnCzY>2~724Z3aZ^dtAYavyGiTu(n|n;tB_K%t6=DdtFpbfJw4!@TGtNX8 z1uqngz8f>8!L*owy!;a|G7*T&rP-O8IssfE#H?+W1lexGoMvorI_Y{778&ByO3)~CQSyqjRd@lnWQj(-sr8)m1f z1`&w18?2J57&noS*Ln#J?&vsw5oPqlFM_mMx7N5ZJ2%V8TRAF=UXY+{3j6>H zEW}x^Rnb(n0$57oC2U*uH11!Ch@HJ?JcKragu*BEbcn&vB+0d{nts(oU&r82v%_7& z_$A6(z9;pV=L|v)3-cX}IOY42pS9L6qeYxYMi)ID?Ucn~%C9swiBA^1+YYS_MPYB4 z4V%~I(rj5C=o*YMiZ{S)!9Pjj{|$9vUx1~Tn)|;^Np+yYB;pX^jt2rpN`^s;e;T-h zL<%-bfO%Qa-Y>pht0 zZvTm^U=u1thvJ1VZX>erW05iXKchyr&+W*Qfpm62|M}%s__DFxyVqh9ZLk3?I=pcH ze&#SC#`23;j#H1?>ZP5EPD+f)_Iuo)P9gYA{&lS}7E?h~H(`R8Few3Zqe95KH|h02 z<^^8WRa7#C4T}GW*y(GM7aFhp3jd3hpQI6_{NcIwv26-ME_@Ow3fh*P{Z%@SLb1B- z&=;31!25wuRii*NjgcfYUD5=G_p&P1;v#2D5G#x{w)~1 zU*o4Gm%u%l*OjC&X2$~vxe#YgP*w@+r18g$3paV^D;3=xo`LtV@r^X?rr@WIT8%rR zskLucv*sY@Xlc$6={Z=;C2Sykea?Ql<{1_DW$SJCY>=bQGDr;+A%2tgU)*f41#^v#*tSqLC|1yOuc?? zajD8$x0MX~3;(4XmoBf#_VqpPMog~{=m+f)aNYB*zjLp>`GM3vFc+k3xB~`~L5n=4 zoIOS+>rUj$6D#IDtS8YNr(q7;mXat6Wp{S$)n|6;Ob@z&xBpV~+bk6XcOopU#e6m= zVMik0$KXvr*T3Q>;L!wbFac~PHOvlA+)<4<(fQVy>7;ja=5Ul)NKd6CIC#8q{}ZF5 zDNjiah0P3(URUMO(x2$GrM#qh7c|u9!6v`jI)gK?sfS@x{qu`f*xgzw%wrI%Ob>qW zBrbRyi7Y5*H=oS4?r!&x+5pO`k3(G0sMAY|_fYyDStKRkH{Vc;pAZHhmck6qgYi3q zQX(y)VDFAwFl`-tCAgzymQ?v?K0uxzd0_$EX!K>db6U+srWe{r>S)8+-1;uEi@q6w6uLiH390^$%so$O6iLQg1zi^3mkUT-RoqLTL(sKWT zTl_1c>ONssat)<>z%x;KLXjK%QY6UmT2RhAP_BP|p94Zu_+Z$q-pw-ll56;nF7Rax zQGDkXXM-2rI6cM6%%;QRX#?GQy(Jq9&Wi}RU?7ehcC{NUKeJY@irgRhb^@(v{Bx6>bpOWSYwHhI z@2!K;cnYot^uU075B^6?#fXmcjBC)tKE#~JaSSn?N4FL%d=dx z`u=L2H@a|@#`;NE}n zbXtDf&dH?Y&=oim`}?0bPoJ-r8`nc}dW14KS?|YEA!A1s*XxME7N#UTf zL z*v$=dK)jnJ*0+2Vk|aOlJ&XtQ#;u2tu@(|<{iXU=pt&s8_8}4v%%JJ8{jX`<6w|G} z($rbP-?hLP@AE)L`!*$GmSvY&V(53XH>yNu^X+34Qie@#;z`%%CbGpS=Z6Wmezbm) zWY<{pmbhAdy^(q zI=x|zC!MRj37xv-C=CG0aB_4yZ_w_P4&$^4jhf`L$mxZ$?afE)4zo!KQDFFwFqBpv z(z#)mTTpuehrO3eh_@qe=nh_eCn=m1MKvn)SD!$|#Jx>c$v#_R5>~ougGs$Vr@62d zr!_IWDO7nC^NA>Ug6QNFBAW4y&9Q_Bzq|0c$%uav!TDGj7`UNhZZ)QeO>(3vEe^%M86^^*b>w41eVS87hQStRF~)RoWkRvtAGlkCaJ2l0?%BI?j>7&&a}_;m5+9H^R@W5=d(78sD?gb$ zk0pBr-;lqc;>coPmayVqlXUAB2Unvn!NZqo4@QZb zxZb#yrc_(hTxaD&zjkB^TV?n zGtO_3X&(UK-+LzAU&EA$ulal`u*6= z+br(uGW2#VfQp=g$k+1Ri{@pH@~b)_P*X~Buq&dMtFc)uROAks@q!2(-Ki&dkH9DNc_`5%`khIJIbu+Pt0(O zTgRyk<7|4(n@rWGXP5p^ZS11^^W=1pN7c27$8wkiqJW}r)P;T1iuPhv(9;XC*A?H$cUXsPQ+?X&FRtj4MjiBCuzF$ z*I2nMm$+tR33s|`tU^X|jD50TmDZG1HnzITLWSy$kd0uEucoJq<~IR(&@`yz<`3R~ zHinw@Nz$J+k-HpxHzS6uC8z%^PGlKgWa#*`*Qm8dn4bGa=9g%me_8oL2zvGOmcily zx|j=w%H>lf-aOULJRrN2YUGhXstKp0Dou&2^IP#-HEZwRwQ(3-S;YDV+bo8z9bdoY4xTigM2RSm4F9SHBlV}z+$WV# zvW4{t)@Pc0Icqn4s%{GuXqFdR11lphwQ&m*+vC2!{dzYRp6Xc<=RM&kU0&@sDY%qo z@rxU(ZGJZ|a1Cth(m!sc@i^)w49o0^(;|k-*@l7rhq(ZYGje#Me z9PO?JZ4G*b4r9N!2kZIcOw3;B-k~xXe3-aaG|(Mmq4t+s+PS@(%iI!2XcK<}n&M3Q-|05>25(=p>p<1Up+`BXt?=r%#;OWlxq-jswfC1b%|!-X8M= z0UGnD+fG^L7_QYf^u?#Ut}eJ7hs(N@%LKb{G!ptuZ%z1V1BL&I?Esk62+B9rLkOzJ z?a`7wz$Q2m3I=r?5@s0^J?42K+IbAcicuJ;S)R5r>i|A!$4gJc1KWPa+zDJPDX5a9Ni2u>Lmgb$NH+Gdg=}QZ428W zbFNp?sG+H-oCKkI#Z?nae|J-wJ2d8BQfrzoF`aQ$Sg)|8!L!5WV9Lu->O)AWb=4gb z-KeCxYRtW&20r0A@VdZp-0HYPJ$MDEQ2=Vn`qne8tqgv@CYeedt!utQ-k*|z-F|V( zd&Ol-Z1H<=b+i62?%^%Cs>vXO&`gqh0}e){Ol9UWxLEbyw&vPsaHi8PzXsOQG_Vi= z2_`|QoZWg)3>RDd4XG{gWZ!aqyHeA9l|SjFhc-X|&w08I_A1s=9&*55k?26Fh2;Kw%*HiMNHC}!}A ztvE*0_Oa$+#egSdovgbyq=a%wJMQ$%lI2TI-p_{UwFS6_7FRd@oP%s$-B_^s_s`#w zMbeNrU*xWkC$4v1>Z|7nLMG@7K)Nx!ce2YSrl9~zvWKCugKbT!87 ztMYE!wqlOG8+*-<^?q7xUt-s{&;7&2`!{H}!}AgB!R^^8VT;DhMyC`Ah$1183`zq^ zL~rnEZCgNm8w22ys&6TFF7J687;ao4_JE!4cNxFe4ZpwmrQR;=2M9sm!yfbbYjX`x zI2LS6c*}_1^kkl=9I7&!6GJov$LFniHvh&G4xl2cq-|6U*iv;{U4; z801e*Kiayu{*XFDcF)1b8!vxC)R_o(t6`?VQ5n<-?Jn#h@BS{{rPCpmB+2~Mg(C}> z?Zk1S5{n5)eTMJYj45-ErK&$`7CN)H>~QR1ekRE29!A0{(L3ZS8>4rIq42G8#NzAY z&Okd9lFB`-tCYlkP>lup))o1BbK58WYyH*w;DYP(rqmSGmS4?$(hvAy0| z>TKt~D3Lp7I9}&txzTCJI(eGQf4B1ntH?m1&rrU!_V{7PhjP*0E~RCN;qhOA;azQx z@!c@;{nxp-%9=gKlEXP0ySi|EFVUrFJ3{2y=flrV>Q!6P3?0FfrFtwz_CvS96skhu zkJaR0X)K?N9gP9xHqpB0C9lUH&pq$2Ps&}dIsH7IK`*PzmH*L<7-oJL4MQm;8H7U;0m|9z zS?Y4p+kcmd{tLS>28?K+&Bu$Ps2*n`3qy6FWWvCj9UGZ;OUmaE#Q$7;axMGj7QAd` zyI`IET*Tiz<|AtdU|AH`NDA^>@4@m@HE>p~{Q;>paE3wO)zJP$l^zmj0uiaQg?HJi z=_lC8%W4?!XL}>)!|6+Y8Yv1;&2v`Ssh7b^F34P)D zU?^hj<0~w8M=67WCswSO07j8%Za$foM{^#m={}fI@z~yxn~J@=mAt>-dcrPWoF3FKU)@l=0iSMPO|le z9p6jL{vem`H_tN?`2M$0CaB7zbTfX8luJ9=Fr?H3QfL5BG3|r@w}WwS1Xez@NRkP< z4~?XboobtA-qJwWvccx{m_F-~%d4D1`f|A=vAaYdck>1r*W0dci=s#qn3NU_8CR`A z+{0C29PeZux(s!3{8C_xUG6YOkn72;va&4se5lTE=OPbTD#83WUnR+VLXyor>Zl+q zVylOk&Y2)WkjTYcJGd-AeGmBL5IPCSxCiN(T6+4IY@Ez=WPoH4fd5X!+$-L=&h7rR z8U8j_^Uj&05BXTAIS^-&Tre?H0`Hzd2lA;Ga31D@T6*QS$i<@!_)j$a;!TZZY>?yv`|JM-_CoT+OpZ3oHGu+u#VQA_H#Om-uTKyG3=a z3WXR~0bnR!32wFQ%UDrM&*7FC|NPIJn4gMB6LFf zRsEZfyeBf517VRDD2r^H#+mNBsWY@Yix>Sp3Ys&e#Q2@yQ**0ekwxBnuge>urv0;I zNU1Wjz4GtiKpX5Jl@iB_pX|g6?T|4ZS5k6KO%&QIHIT$+U2+=lNr*8b~EoG1qYVzfe9IKGGQwbM}ieC7!fIFP*x}}ap+!+X626n3V8I&~O zV{?b%-Nqv*+m*Zj>f6#!FgD4#WM}zVq&vvNCr;m_49ot!MFrzV(Onc}VUjFS3nu7d z`4mq%)L@xuES{LY`B4kg-a%+lKp9ezY(9&qnC9Z|JLIxwd9kU!9HNH+8J*M)N5+6% zWA%ECoSg&|Igju!IYgX61=`@ zJ==Af?v{`j%R%zj1h@S{9&**E5m7s`7UO4Om8Uqc_hbQ*ll`!)@4$IWgriS=zl5;- z@fsB}E&oS?IwXMSndMmqZAuJhU`!E+&{@e(oz{p`K0&?G0DSCMz;V~5ENd3?_1b!c zB)K9EhjKaAw}G*^*Q|vZ)&KwP1)3I$I4Ern03}sW;IBCnh!$|Le;!XT8k-&x)^Gi5 z{Yu-g(p*t-TycLH73g!8sH(DaDzI$0<~FiLeZ(NBPg!vCLVX) z>`n|o+H@HUpU{UCU};u7_89D)lMz0;EHu0;r+!_F1xk1kC2Vb7=JX|% zJ>VTYf($P8JR;;v-corpuaP!6)|Qnf<%R3Ye_RG$kcoJ6T$XCo4DE-ya_3ORIVj~KR?VQWDrFF-B!gEVE+k;} zTe4j7*1~&C%5MI7WuU?pas9*UTF@Prb)!`r9R#UO%##H94rP{ZwbQ z;|W-Z|1=9Pa5};%p`vz!^No){ktEd8Zyn}}w62&0kQ8;N{y(Bd7BtaPGC3FJSSyff3uB#Ij^vVQq5too|RF^A%SmdGwXLSVR=X&7N z4<&2VhEnoWV=cewmaLrK-tGc_y{LElE#AGb&wKPbOZ-Vif=zbjP3Q+sIkYn%U^Bp; zxY9m7)EhH%f^V2%XSD8TyFZwisK&`21>$^jc{k(Dhh2Jv-5iF)pU@jf@>Wo#ipSP~ z*Ls6V6w)tWDe(5b;r)w%hZ3P@l&XuVD1%b9i6St-BZQZ64c>hy-pnb4D}|d%+#wO1 z39Fejns&lzNBoo&89FGL^%xeHZ30!)yQ*4oV(~bag0f56B@D_= zoU|g^$8}tfm{w4wgu7lM*eL@|2rY!U{cNJeqMxh*9x08P#kAJ_mA`1KAYWmb4uT77 zzX`=eeQkl^EPKc=Xm7%3*I~4W)zvqH2QeKFi?&mEu0hP=Ou@PAPuyH0`p*0W@DfBd zw5~m%2rZHR%7bW_Sf}*?me0+oqb(r6equqVoI$fjn+6;1D!?CE$Y`JfW%0$a*&B3c zfXAc}OMHhSNfKD|pqIXN8Ly_^d%}M;8AiI^mKbepg-Z_EWft^I%ImligdRhycp_d+u)21=sG}C^#q*f&Mm)gjPNwz!E zqVE6v-B8NXyz{+*uk=86E^ta`0-Ep$m%H`w{*Yv>d&lygMy`Mnwe%A{yAzDdt8e0` zz8-fqV}gvwjtz^y*kdu|jsnP91dS|rMx$_WG=VIGHg5XN6E!7?n3omk0}? zWd}6QA%!OhAZtiwVaoGhb;evzh+SvNV~tuDrF?^0m-iGy9|WxkX6E5dOiDg@w*8x+ zRd&d6!sW*yR5F_nCt$hS&=6>YA|A`l^6~|uhpWIT#h$r;rb%mN3qZ{f2e2&mm z$3e-fMnUA}?zHMT7kvc7=#4sf%28M(cxZOdl1MQI7j$Z_@!cQJ)qUxim=10dCUynY zQ7PMaJSK*#`6C-10?1H|lqh@w;Aex9v$8bi30{B~hq!mac4+Q>tw^gt}O6DeZ(kxe>In*#WnjGJ0G6QFh2I{p9EO_6_H>2 zh=e!F=Svv0FcF-m*lGj%IjNxWCL}ug&y9^;n0Pi3GA|S0*o2JP@WGI!l<2%q*H^?4 zDQao~B}!--kuN=Y3XohigpuaV?d`?kS-_>l*ZM`_(~e%v-V*s`Kf+Y_i6 zWT@hTqbAmZ@)Dd7(&%oGWbbd8<6?f)GDHfQS`s+2hMfO6b<302DWiJX6kr(^ zH5m-<5l)HvLv6TaA5s}cjfuMzs|EV5&3%bcRN`MrG9R8kkDI;@3B|+xe)0Z^-GHi= zn%=XQdq`nOY)}q%wyI)NUutsg`#{*7(U{_-Sf9-exS_phHF$%2B z>rR6M3Xm5Nqm(YDWc)2h)XzjSlJWvRw(*Llq@Gym2OPlLg(gV6hXHP(J+VW z5V`psjpOCq2UKRp{20`1)A>!Lg~{600uYl+p9qw(0sh+_sn1E)nDyPA!pN{N%m282%uXG}&GQ(>?oNEWB0_FNs# zp|7m%HwR2u-*VRK5vB_c)9}gcVL%lm(&tulcl+}d z2Fjjg%JJV63jb{H?7#@ZJA1+>GmDzw8=Q?j3Yx+DMTi|)Wh;i(*zz@ye_QTqwr2kL z3N8Nj(S1}hGtfU$rf*ax!5o&W*i%+k0LTdYrtO%jL!S)EzYw4XaOWrkO{pXqdP*=A zvHGeH{JoxgrKl?h+q`{q><#D2yKgfq9|+c$-ADQ=7p=3uE;!8bg02{}tEriB zm6t#H%%f_w&(lioxy{_xgI1B}&QAXr(t{3W8+Nmre-g(x_+a=g?!k~MS;Uj zK*btO;W3C0T0%(w*5ufdWiawrv*U`p%9MMze{cV?uAk^#IPI;jCDkP4Ss$<*&+U8S zZvN`^qi-PX$1<0XA?CWauIK2}?ct(&-(4iuRijl$>@KqW7cb>#=#$yFFQGFuhgiev zUl;A4s>KBvH4!yZPDQTcXR*X6|Pg75ktcQi`G06jU1-}Au9{LSB96fPRo6q zdf4x8U8n2Ol)L(zF#E58l;i%*roVAXzc1gD@NIKlF^%5{- zb~6D$1piEMY{%LgR6+sA7iwkjjEXI5OrIe3A`1!a93b?Nm}zepVJdR{@-kve_qYX) z#wx)p@ztyKH!=D_Pm7h`n;(J@De*}Q^}|iYdz@a%dUV<zDGeQ0c`lnYUQxCOsp5@Z9q$;5HLZCnp}}MlEc4Z?zxa@^ z*UD6Sd;qtYbDhQMKI;pgsq4ArwQ9F$EK4ptxXjP~;2wnygj@&^3;ruVo1;1WiGZ-( zkWz0km{F>%C0O&@w$U1*aP@;Q$HKyX96KTB9%1#YQq-40x@CXXfm(Po5=V$d5-Tw^<5qMr_DX*k%<_TDr zO;LIPp=;{N$zmxPX64g-_ENOfPaX-Ir1;Z+HoSNBzT0Nl>P(QwckbTp%*h~5VvL2| z#jBr~hhEzf!ij);9bXBU_~D_8U~6bxj+u_Ha;XL7pdkY89@ z=PrcihF^!-$AWqbmsO55go4d&u38;YMV+^YNro2(|4~#4FnXctX*HtOQeZTO#rZb>YfC9EjMVmn&&>P54}Hd9v@n%8OMH`j(%iHAbKAnn`&gJtl2S& z8$;s)z!LIa@oW{rY7Y?o6^=T;9t;7@mSh0$B+`&&e{-Vhjvv#^VrkIH0-(If_I z{ybcIUVL%g30C?O`c3^wmpU(&d}2-@vT%5%$7VqDLD<}AeBmWEp`T21_LFOr0r9Eu zVfYJ#P6IGg8QKZ!;b*bevT0x(XHmJvjlsZH}}Szi@TAWC*=c|}4pMWAiCGCgO86C`l?Y)qirRYWNj{W6k2M+i` zWrxb5Q&U7!c#`|0mIo!eeqaRUcn;lg2eNIfAj5cO}lIm$SG<|nh zz#W3!Qh$ZZBzV>-fD4yIK_oowC#UVmj~Bh!-JraI+7cyRW2DUDu9X$*+D)R?D`W0Z zPHCA5>AwTaB@^dnrS8*-mtm>Ol16eotx|v7#qF*Hq=hwxb%}$-()pJ%W(ols`ATAE z>_TKe2tns7Bmr6RPhqtYnOI5B4{!gTmXeuhR*=y5u~|cjOw@`-A{@Q?ORzq4P$P?V z7rvOK1A&Dpqs7ZG*LmoEp>ji5bRe+)y9mbP{;J-b4PbN_=Q;PD;oWp-8h+5PnsMU# zJUJ|x=UM!2oC*S!jDFLm8BF9^&4Sbww9IfU0puE8q5)3|foJ@#)rdyTW@arf+V+1FZi3e2(# zQNLw<^Z04CSKL;k>bhNZ+J0joqzspDe@{9%Tk0C??X+4#dK}F3b>$Nz!r(EG3|P?k z4Lv%q1ZzNw8`1Exk-l)%f)p=c!WfG`bjWJ4+5h}qfMat+eT-Neaaq8-iD*I79!CS` z3e5mfz55Z3rp{`fxphp_IzMGtXG*tUTs}w~{xmSck%P>aA?qQd$!yg2$f@O#Vb%G^ zsL2u<4U|hXy&~%g;mPD&h0;6XVwI75ig-&4+@^ScP~-e&?MfEaP{a+-l<0EYyG49) zF4Ge_3|1a8t`8Egiu72xqEg>*?_!((M`YS|ZEL*F zfMyV~{-k%rey7GAN9}Q#z-Zm4*r&oxuO~2 z^Uv(AIL_erX%imNf>AHZC+N#M>;6xSVyZQ3zjb?w2sY8}!pNht$lbXsMOg0+`4gd7 zTw}u=uEMaFG^I--0T8GDOkJLYB=ohi6Q!={L#JkOC{=_o*^~uNqPl!vu&hCr99Sw6sst&)Snm?JDFu)-UpXAUpYe-A ziFVSEM-2B+5{~CtNCaRBtv#7^>j^O4XK1|6>=l6A4Lm7)6QT3$RnSL+6@wFa3`yAm zhfQP1$eAb%B`v8&3Bb<3(i=*$cm4aV0k9(3nu-S&hTUn*YET~()QpYVz_F!xr}(dc z5|%GKevr?<0yZxkHt&K{muh8ZkHyEdNitg+&xn*rLdv*s5yKhz(>vf}@sdPO6$ z>+k>wGnE+;Ow-+CeB!C^dU@aH=ijFgXIpEzg+q8m)WfO$jtL@fgm8nZ#MQA0CBe{1 zr$m06(v@zHXc3dMG#BlD@HsrJtRo5ZagP!(~ zE5OI-CW)4_Y+fa>M1TW`rbKq0R=ZqkI23tBx6nT6svIL<#<}Z9`;M`kTpRmI8%sw# zXt^Jh^4~PhpLR1m)jOffpRTleUk!RnzwmC}KOmrwKufdvJx$FD38e#iqMB+0=kG52 zYQ0%Dl?l$oEY0_}hRVP4M7VoiwFbnxN!@IHASW>F7+uP(fv8`D=P&m_A7+ zgio)1?DHhOfvl57A3(!W{LMYypcgUmm#i}@kynEnPRq^w%mMi(eb4zZ$LOWAYAjp| z4K9CYgcvi~_RObCT1?&jEN4Xjs z&zBf z2mm~-*QlU1Ibw|C*scd6j&JF_Sujh`K=>XiO*;Kw(%~2z9Ke-nac;`WFzJImTS!-nO zXZ}yg%X!GU!ph>m!7uejjcg}!Q8w~dpsH;#eR7U@={21(%o%kHcjq7e+tkb;p#+7El~bj1mVa9ewuSY4HN=h!8pU@C~dz z@-VMOUg`J+%B@PE>8(&*hjONoeijMcice)Oh~t<>s}&BjK>vQ^DUw|&zy&E>G&tU~ zoN&SB|6ZUKA-h9rvO*Q`S%LEm%CDOTP5_{G9!grG-)-8maew!Y!9@}r<*HcEMq{Y0 zq19;TK_O0OO))n({F2H^0WpMAqOj!Nyrf4ed*fAR zMXiZmDi7}7B^_}b{$(Ho*vLa{Ubk=ZPc{0s-2O5ww3OuAe*Mi?vD+0T!Yqm<-#eV| zH~Em*vK-*bkU%mPF3^IrwxzWC+QAh((C6OlOM)LIhn{$9DJV0_pYfCFO*#^uByC1} ztKPux0Yeu?z71p$z*B+6SYbo}^c#A_k4@#HD2PJ#zq+f=aDkK0Rk;c&!JCAJ57}99 zF9YqaaDgQdS~Zm!*jA^Hqatw;W6XUS|BP9SW+Gj}EyI?8!b@>W|Gapp@XWsdu9t|nhL&_>1G4&UEH;y54%C9ING!z){ z*wK{bLG)#xkBA)^KQ&^fB4TpKN`)ok%-XEWtC!IBYNECB6!#{dF%0s2XHgriAUIzX zo=9zo)z@@ij=x|vqb1l>4KfKju6z#zjCEYk^!o37+Pjb&F_8s>-u3%?fPW1R9I3#i z1<&Sy38Q!^xSJ>tS6!Z%ulN{|lp=K^2fpCKPAY)7x4sHc1duxc3y7#_L?ixxrX0F4NpwO^WJ>3>xad{ zrdG{eBP;5{p^Lcb&%=aU=ZZslrF$OjtK+`u>bBC~+$JQUvip&Bphu`(Nm-srC{x*E z`>&SgARlU#GvI!^@Z;D_5l@Ehn8BzlA%UKBXw@|QqsOi+$dlimO!YctX_rpR`aW>gLW&F1p;+{W=5`DB%{cXm$(gTGIfT1V))@5QeG`QC!{`z+2f;Nl$-e~{!h+;?bwsa&A(OgQq-4jXZL-QQrTBgVwE>vDr8{DrFSNt#&_{*Xg!mX4&QX-qk=Aw8Wl8PwvmW+gZBhtW?L}Zlgk&#XI zUcdL}(&M_%_w_q}7@yA>@AE$I^WNutdONPM=}O)_4zT?af>f|fU_Dm#i@AL9)vatf z0?ILCzbt2CvDM$@az3bE;H|@rZTlN@V5@V4XjE|IThpVHJp6a2Q@Tdv8PFb61l_B$ zg~Ja9h%%XrMDRMkWj3ONtN36|Sjq&ffOgc51oC8BzdEP0!HMAP>JZss)1!om{pY@^ zeMWn7pEfUaT=~=NEeh+A$Y@&A`pd&8L%^Pml8)1Sj-U2s3_s{zRbdyGW3`JN?G3h%TO!m&S03O7jYT@=}mRUaB*k(HNgca>Gr5rQpAf;h;8J#=%~2vfz_e_a5BA~{D;m*=s_vGq+)JI=`q_fi2}d?PXKqS^ ztHIFTV3i%RvKz;F551W-9##PW-!8%Vu^C3pLd+Z5|U-_|3a9jX|ailuKlx?!rlrJ*sSXjPC zItXjf2G|cAe6`rsHq1)rAnf-g3a9TLLmyZs5%#q116{U0O;931Uxa3JshMS8xv6%2 zcJmm(lCZf%)UT4nW--=u;}N27!f!Rs7fd=ex{uTD53_z&2l#XWeA1R4zFoMeAJCyb zn~`I6vSm{4!!#fD6^>nhVbZOn8|QSzPpaE|rkk{|8=^Y<>z(F3>$p)ASlss?dS%li ztv{pRyiHtiFC9M1oZoJCJgX@r@Ph)5#jFQFTN zUFc2Tp^Oo!6Ld9I7sM8y6}Aj_8uz@%d4x7#{>ItGf6>9@HPd-{4;Qy}az53XuCTDH zr{X_v6F-%g#r*F^H9hQo+_7<A|E53-FhZrAifDw9lm zkNYiY`uSg;ZRSdWVVY)--&b&`Oy%`)hl}Qd&JbM1A=L~O(cE8+c1mGq2NvUe6?AVK z$_(Y=w$pWX!aLYtAG`L6HxXxc6m|7)`Zas(X(rQ?zBT#lS@1CHvRS-))$C8v30=7gIQoq`c`=)H{@%Q$ z^Xi6gDFQ~-KY5po#?zA2G8n{L2E4XvhCuH#I+rer^G0o3Y95l!`EXGDO}nns$$%YL z-*PJt;S*r8qL?_O!S*gPQaW0pFr7|RD`Ehm4iMHrI37k3AuECJ!r+T^=GPLY@i(34 z+YFAh>?=yyemBI=Vw=XiFE7XBt-~Le@480}&quZ`wHkG{=jLzxr1^OIsp6LdnOD&6 z5j*Dw?^>>u#6*^!%46X$L=;Ok>C!%G&2ty29h$!ydu-9H^P0Zmp*8MnNf&kQLaMx4 zszqOj5q(YA?kakBg^HikHIwh2EE}L0Hmx3gk9#+kXSe$r8~fMeDa>^G=qQSElE*OC zQqcix($Kl>`!b{cYNk#TFz^O(!_+;3&cDa^y&-a$AoPkte-O2u7ioG_k^SGl`KD^JP}#bF!1uft5O_#Xl8 zq#y#QNWXNlWaEFNd{dl0pgV!fbe?Z&Sk~*~ov87Wo;02TB~%Nxu%;%bRczeSUJ)zN z_84YKfsUHOXZ%rm7eeNjjk-?k=XR0%Aau{t@rUXozk0PtEX7u`?<9VlRBtX<$>V&< zi7mgvz&7QT+VZ0^ydU66?lQ!bfzSD>5xc4N56h;>O`wAa+$m60s36n1QlRjNdjq0gbmFa>lyg)U9~y}@WenJx0dFK(`rYH+@(K~!fv}EFd9lm$vn?-0(YS&< z$`I_QrgrM~_w6d?(1xl5cIX@tEL~}prO1sczjXXU zL-$qtR^y9)kH@1mr#^Bm%m0W&&rR@wlAW9*)Gw6nskFokI?j>geB~+u({G|DE91*P ze>}uk&h0q#db*YCAxCJ`{;131d6%QwERS8Q9v-6mZTnMV*Z6~J|4SRLj4vDc8@wNK zPwW@RoZ;~&2?RtNFB|uq-oQJk?S}l=U`fsRnU}pvJ+seaW{F*RlQ%aNvh`$?ZvGn9 ziiHzl*q5+{EOzQ>p zDBH6)sCc#n6MDiSb7SshBk`U2uz2S8Ub2+De*8{0&q`k1tZ+8FLbQb^mM+AO<-v%TL*h-q2MbJu;g3Evx4>k71&(giHLIQO>% zm725D=}l4N9fM|Zf(Y*LEN>r3CF)3#O1H&0wxu}Z%=Flr_;W#3@k>{4_Q9oc7RrzS zb@wmcW(@DxVtrlQ*sVh~OCEbJ*_SlB}Nwx-gApPFdR{r3uF z#1m8ZCPJ|9U4ZkhreIN3H}I>^<$oTRSmuDeeXq6Gl-T2uHGk5oVWPps&za{rmCebU zDY1|S-NgG369S8Gbfd{ za>Dh@$w$n&k@xBJ1E!hFk8I=P2}JbEfL*UNB=-FJtfgnLRdoejHchS z`CXUc;iV-O|H9n0Qv4>Aoktya^-pt&E{`oE0asD<7PJs~Af&&s6NA=DR8F!U*E1$LX0|o0T*!swq)99uq_Vp-g|miRuG$g-v+ZMt$IHf54hS6o z)c$)~DYMJckhn4D&`%l$iQ`decw&GR={_vjN!fFqSE(f0*ifFC!vd-MA_|(kF-te| zCWGfngYnsUd)hV#{qj^ec<8&8tA=EaG14ma-UDyGizJ&7#QDl*dcu9P&_C_lazV#} zZ4|3;(dd25yi%qq5!Pqd4Y61El_Y2|*bl5OaVuMzXwXGk*lXyO^KU>IUr%<}*7kUp!G|=d|}F zmy{Q^mt|OQ<*`HxpTs8}c%c*@GZD8z-?T$SEXsN%et`&GoQh-l<=RsQ zoSF3*cN(_GD1bMIHku`5Lp1Jb#w)RHeDoeAZClMn@ZKx55iVT0s~hWubFB!-Z-8&S z5M#h#jC)k@IKJBZkbKQK8&6a>++>HnepKy&#up!kp2Bz}GC@IJ+?t2f12&v4*T{P+^SgVA%T_n^VR35SCitKs5Y`MA@ z4*eQ2HDi0Kqdunrc=!!^P);~=$p^`K9jcU54xIylfL(s9)aq5tu6%EX9*KT&|M=qP zR&!<=I0=Ln?Sw%kzG<(GIBti{#l{|>0@*$+U-;EiTVto9~Opm4>ORv8vKF ze*TT6MLhmvkj4T|GGZDUm9^>dQY@{@>Nxr%^hRLw<)z`&iZ#c%nM@p zlKi~;Ah1Yqgb`!l`cB64H8qVE#T8Rmh`umtK(Lq4NgIzz_YIR*{$M65%#2lI68BWx z;oE0)Z4qJyDivW+PoRG)rob``pZMG>q1pFgRNA;k$hs#L+y=A4_-%JXXp*xBm3p3` zC*B|($XMVggZ=mAVd+%=}rp=n>;bAa4^&@0ZVx@F&N%R4ig&9&MZGUpSA{fR59Xvq|5K)@qBt z#dZyMI4wacnCKnN{U3IN-P)z_dl}>@;Vj_odsl!?)a?|r{CPEE0HE9rh_$=GN&8V~ z*|b{&5lPu?gcoHwwh9HNg6G8Kwo)*XrC~P-KG54kyC)?ftL9$JP$8C0K;)#;uLBjC z?c>->kp|)-hB3?23*7v1e-+4#W#ZV37?u!b6b06Rf=8SGPL9p3sH5Tw zE$Zq7G6@42{STL!Lh&7+t*Ph5k5!2BDLw%gqD$xawv~Q39xSHq7-S3+2pAhcsYe~K zaMpC!NB^h&=5OA;@|?wneCZhb$NC}WdFWE8tK!aDVV><$gB$o&#djFNu370t^UM@3 zM&kC^HMT~K7X+-}q8078vUV|iZZG^}D*Uh-UkN>i~zIlFsvcFt`R^F~Rd5yp6O-lrlq=wkV1$cPy z70d2Rv267p>LTKD#dfSLNpi}dTn|o5&Yb@wYuB59xDl)xsGzkbl2XCr?dLIh>h20{ zH?5}qj{dS7xioCAxY1$P30AmmPPK4_$zY{jWU#a6ktio|SrT0aL)5VLfWiV}=_CB= z!d8Ci$oLXSkaAThuWP$gw~Mwf*s$WHGx55)^fJdYwvL*KTITZiz&jXEvgr>I)nHfOK{*h)rhsryU%JDg7AO? zJN1$}Rytqk)Om3pqqia#TZ|VCr@c12C79#gLwcs^jpZ`hXPO!+S9(C4u0eaPDcnu| z<)R{>E#puijjXa0Kfcm;JacNCf0b3kn!^fEcmj2s9F}M0H?Y}I$r47ixUo8estt69 z3*Eko92n<)jp`C%kcy=J9u!m7Sh_9?>#X=Da4v&Cg(?4|MVIBE)r>5Tacr>_r1m(5 zm#{sk>ZSkQl_ga(23W$YKuRV6CdKzi{B`KWqqO&)o9wo7dkqB}(h)qk-8`?FZ{P?G zzHjw6L;lAx)50S>^V{#Ov=>umHLmsZuW@ae-~YK9NJ~)wCKD{xr?9a!E7NnE-9ZX3Qh+O7pB!ov($AOeV%NH|%1xie>4mH9IqJ45!P09==pic#Rdn3T(B$HVP4 z+34R@!qRsFuW8_KWCZ*31J%an7=iaI?Zuu@eI@9>{nYINYAS*ggPn1zi&Lib2XNI} zFL~^M1o?_w8kyRr9NfpwEZ1SBOWaSOiHPks=Nd?kF9ZRQ!etBH#XWezUk{(cFpjtK z6xMSF?k0Y;KCH;JT`MPsIk$W2TJl!-GYWLcj8$XFc4Pj>mTSF}IB7=bwR*IWpW_4g?8FL@4f}1}1%pUH6`-U0fvKeyc?ygF? zx_Ek)xQM4(en9QXTOdbg8@0V@|LbY$aPT~e%NFu&%>90Cd&r2{ted3tqS@V~#g(N% z;L>70UJZAu4_Vtj2*I`5iZ#G-i$Dg6Di~|{!P)f;EAA1P)f*t`+lDt}gH>h>{0+w^ z@8eg|+18D^NJ1FY-t;Q59ZUjxxC9vl?0Zk*%?f*zbfkwCv8G$S68an-cGwSdP0P8c zbZ$1`UE=(MviD_~e~VV~6@i4oy?~1zASeVYstof!?-n1Sq_e?D=Mi&$-aDbgO%vy; zg#t@^;<>06)H@#>D65*b{j*2}&EiEPmY$>s%!ZJ-gIbBtegzD+{}SU@v3$8xFM>_` z&eDwJJ@w@yY}6;VK7P(%lsJ028uYsEr^8HziYv%4?sJe_{$k3vJ#r6M)wT~1_1TFc zP!ua+*{ zDA;{;qHwYky;;THp)u_KNu9u&AA8_~c^YC+zT-Nj-$mEEYjxspc zJ$(lR+v?(6wv`>?uF$YHWt+>HF7v2DPuYTUiiu{=R~*gmC;RvD^hv2nOZcpK2ay4|F($4|3MZ05A7ds6_5!ffelVW-zk|jX z7T?miQ9B}9dKzrRzCg{^XUSGke9da&yvO#LAEtJ?&oZ&#S@CmK;WSO%Vg4JAEMKQ39|q?WCm{7sLCo>?s+^(FF&TO|@fp+`V63Y<1!UM;G15 z!p^)A8ItoJ*l>iLc~59^MrQlB1?T!UQveGzSpExi+mDL<#f@&AfpFTlaPm;FLX^o7 zvtMenSWv028o|T%jp@?K&Ie~-QLQ-bkkX0y?5~E3mw>&FjxC&zo}04J=XWah2}_-_d~5#pjvr z4}^i`hy@1Y6<=liEw**np;Jk@T!b@;f)}1Ki-Xzn3FH7=B0(j!ZMTGQQ{tI3pR3`d zbr329(4wh26`M&PlWWdjbWJ>Z*^m(!NR^m)95lN{4Fv_Brz>Uw<&W;^&~KlBcyQ{89wmt6X{aRo;Qw z40~+hd8B8UNpHOiB4ldd1!cE}Yi93)U5aDZG4@*O&hL2H!q-iET|23H%uRYGLd^^F z*lG&(BtXRK8H7;L7m++f>y>Y%B3QSQG{v z#y|Uu6MM;&R&9B>7QbGec!>J)jd?*!)3Vj+{|FtzTlu0W96^%`UpGgKy}zLn>cYrNme^^S#(mG^Pih)YM|iYroyEP#%8SC++2#MO_14{R7VzH(XB zfTQ@`%kB#GsZ-&4bf$V%-j|H8H=H|v+u|rRKJss4vu}PC^6mL8^HIEFs-bedV3UrI zqyCfO=Z~=+!HK!O40$%u!FWxd`&-Mx@>P=j%o6!e6m|V-@%UwY`-240V4MF697wr% z>{RD$)N-I-jBRIYSK;iw-=Im{L$~-%Tj-Gw?1-W$ea=As!rIGCyS)!x+3aw^xLe#I zu;a|~mj!2rWVWb+w?R96?Hn4ccFbF?Ximtdrl)TgM?ouoV}dT32V6;rkqsy-`_^hv z{MX1M#`DJA2ab-o$u9`22UOl!c$&x=Rd8&>{OV%OM326f;Pb~dtm=~Y;1dP^tAqAS0b4Yl|7ypw>>c58Rt7KhS zN&*lerpVxxK8V&V2a}G-%GCIE%b`YS4k)y^Es2>|UPGw$dX`=boB_b@-}r%AYa{X5 zAK-<8c*WeR(7+Q=*8aPs#i3T+hcwADmJ%cMt>t+KJq8xdXzq$Cn4tnf!FgpctSLlQ zAaLG8Rqv75N`ePQ5U-Kfny`jCZD+sJpmym&**86x{m*9qsnJfxLXpKumT_a&}UJ;6qceuD3}2bWCDyjvBASuezSQsG-un2pDH z<^ro=zl-^(dDra!u_5(iK;dTagaiYdO7Hg*4hoa&ZT}@y5uk#ipKxHyImP|IZXd&{eX+d1 z=ca4M-?Hz7_@iPOfTM0Uu<~gcfS{zPEMfNt#MQQB-pSizuyu8lXr7AIknUTS_Wp%k z8dTu<^ug7C6aejpO^Y;R_l#c$8MD+|GjII?*GwEv_u|V3a=qVv zS+)9c-h!L2(5y`O+=okJl!AI^gY3RM2I3*HpZflK$Ew1-#u_eb;qGzLY^m^986V~<+&reU zbu7do^0!N4oPrql>hdiOUX|+|lw zHN;?dGKhC#55xOyKk~WJgV{?0`=c>oTQe{TYhnD^d ziI3O$v-_VWG3Ru9_cYzN9A2!;eoO7q9H3U>czi=taLK~EQoX`)UP2DvInjLHyr!|V zf>oA9(C1_A*MP84(3Qosv|DKv2RFWjdn$6#1z|TnZ*@=b3YZODZ)&})V65bA zr5D2PbT*hikc2Rm_U$L>UTnmcYn!Ihe)2qUWh)u*7T?=6UfhIN&5;l~k?P7<;{I1_ zU90>wt^O+h#I5Y*Uo1ZvKeK-l$JG<+;6AW0TS_oR8C9}E0erm3x4e*Ge|%v=Wqi+g z?bL^==rJj#Z?iowoMtO^hx78%h1kv7B~4#R8hi~Zj(_8mSmvE*$4ubn8m3MNnlCIC z`uNIq(WrTAdMl4j^<#Zzv7E<0_qMjua2B$rFWm$x7K@B7s_j~Sr2{gx;Ch!?gohkK z=UA39!mnQIhPUy%dJL2To8~6dw_~~eZGMNh4Mg~e8|S9ql<&JK*V`1W@viZz;Y1AA z$#BuuJ1{HsV`cCuGJ@+>6>f)F&8j<- zv)ye9sKco~dhpfES7gKt-S@-;uUBQ#>Sjh5Az9(i-=yD)n<0|8?g>A7pBFc%7weuT zivkwcl|bl9^8{%8>z@8VPiSn^^TjJat~j->V*-3oLvjCWy_R+LajpMz{EeW)8IS+T zTlmu=H4yFmKcGpVk_b`@55IrB8dq6qKtw;G`iKDfw)ilFApZ1%{?^|8r%g=oIusdS z0(<5xc#YP<4j1u&$Q^h+?R)eqnxR8hNYffcgR|WK6WkA=5e3;_>0Ff|D=i5p02iZZ zT%kN_BdCsK1-%uD9S>TYxGf~lk-Z>Ywok2W`R3g>kTg-wlwF!Ym*3uH=W!(F( z*a#l~(j!kO77=aL;rNE_SxY}%*JJc6vSh^)2$#JFGD~qnXv}V{kUXG84QP-50Uz!0 z*`PDuDHO^h=tr-}N-b*KouxApD038Fx4p1Vplk#_h%!Wz05c%vYdz_(0{hWDEcoxzkC1I3B_C8A9a)XN~#6o68K>65Si_V!0WSge(m<|8$~*_2#K z9;dZe2zp$aU=M8Sn~js-*neOW0T0pVhAG|je}dN|2ffFQ$F#|^0jw;t?mz`XJ3PYe zk~Ng2&+V3*L$L|p!6xLnina@dWFxYoeGptpd#&7sf7&@f*o~|VfR$r)yUKDFA~R%< zVJOl~SuI0;^~118$0MgqC}|zN_s(+Kc7Ay;f75?(3M{p@-)?#ywzpEl94TvUt$S@? zBgWQ8N9Ith&4Mbq_6q)5dAsB=GL7?yzadJ>(<7@uumQB`g1M&fbLQ;qDKs!fR(Mdy zxIUdBnskxuUof+e>>YSl(bKIjKu|6~-lNiS*iuJcuYR^{wO&1ZC)PNDcW_Y>dOyD6 z30&)f0QZ;>OLq)<@W7%fIn_gCjI3Cp2XeQ(?V4O_4N=OPuwK8-#ZSZ7@0fF!(4n(_ zW!D9vSCEhcaX$)S2$=k_OlOzIHl0hZ=CJt78Z^{Q1Lqt;+(*Y^Y0ktzf^yhB0!?nfF9^@Pa6JmZ3*45Arlf-F!FMk5tN(gVii!Xq*kz-To%ISl+&`Mo zEDG`x29BrgHgCp_dEKn7v;5|G)YaEf7ETj_@E8a|!^+p?)GZz`_lLZYb7mB?c?9_Z z_l5E06W2!|NI+K3!rHTZw{hz6sRNrAr}HP?zFH*(f&tr&L3x3Yv!Q%mW>?nJ|53vN z0Nh2|c2j4Mp%G`Yq6yByADYhdyHNg3$`Ht0O($5bl#G5^joU{nJ%i#oxQvrG`e@02 z&R(Zc;m$(dz(-g-d;I)iP!=~B&TjpaVX)FAHU+LgVgyff_mw)onBiw&c&sHMkW~pJ zv^c#I#;@&f;4CwZ9;$%tYVF*mdm!_v^*S!ExF2pWxdNWkK_}k&!P2xz6+8uA z4ngo)+-kF9d2l-St*n|y?lSz~-;f#e6HV~OqY7uxp zG>Kn)0HP8kf+~G596ENBCdxEvXBr4fD&=Xtn=xMN81BK}T!bv1$=bBWtv+lAACf1_5n zhvI8$?AbCCTXmJyh~o+_lBFSaI#6b(>@n_jx^yzcqp^%U8t&hC(2G9T3RW8UM=}Az z(d(oPP6W-X?T6GYO1^+PvK497t{1MP@T~QOIDursD4`jZWDn76IAMUtkUL7L#A762 zqjMa6!qQ0!>5w)00p|b};Zm7-^i=0sK^@GvJ&<}tDXHPZzK|hHye57Zas<~i7x>y2 zatHkL9Yz0!16Ml4fEx+9BeQcs@INzz+w~L+fKAzxqEu_+BWl3LG09)7wn5NhJ%@oH z92Mgv8d|4NS>Oge$iMG>zPyie7%|B2QoI6|d_+jkI+&{eMg)18Rg1zV$+&gCuOpJ~V@YtawBM z+<|cCn&h7V*6Pa{;AL125IUm}FQ!y|A*KhDQa(B{cY*@$MnLvuWAuZ|>y;4VBrLbk zlRvKgl|hI@=tH=EnG7I=I0VxW`iJ6S3tH2M@*&i0rfiP7q?##fj-d}9QZ$DT4O2J! zQal`kyN@KmGU<4e8Q0livL0JP=s{{0&<#gZrnT44+?W<-p8i6@jT_?3>j)5A1Dqts zA2#}bI0Nd~ByvSVB!rYyLxu)|E-Z5#7~7wsmX`00e+wde2Z8!Y7)&13dR~sJ9EqJ; zKi(vaH$wy(1?EM`5#TGsaIYcC_wUW;e$BpK*al&_XitFdmCU;fmQl&_I8M8elnGi z{IX~secK!W@wtRe52T-f;_8eQX-ppZ1J{D5NWU;mIybw{ZN2dUHCny=Yoo(60=6`STvrBh zw&HuOp2C|@6|?4{(?6Hpmot~6QmM{ek9W?(zA@4e8CVHx{m@lcbah%XZ=LwVI{HmF zI}BwH7gcoKe4lmk8gVjvEZ@{@-fk(!V)NhSX{xiE{J{*z_Jd!hCnUGRPhnxUBh$N< z+JQg(uu# z4uKe=8VTjtTO>YcXz}FQ}v;bMkJzoR{AarTPUV=r=yTVswwA zW|rnzb#~VlciA`*a)pLC1bIHF1!2EzvfXcV)Z@&PuXKbPu&nz*m`VO#Jj%Atu|tqe zOPiV(COl~=K?cpir4WTWdaNON3{#T#B}R$f4A_gM{T&6arMnFdkMSQ8HOOBEo2 zYB;*9(tK)e%ymD2a1IP%o&rI#(G`!gybI|}_Kd{mCvs?Go3`XpyJxiui7uOVaoMis zXRK6D&Pi?fM|A$@C*1s{54kh>x?8~D#uE*nw@sQ%-DEbyn`G*&^QBEzRov@{(^xug zj=@wbjeR3m1$|e?LeD0y63J-F-XU642T6?PqE}wZs7r+TVi~ElwGdAw?Fe zX$mX#?_VpwH>qVT_))8^_It{J`IPi>v(@E4T!vI9&Sa4zN1$Dh@QD3wMMV6z3d4U4 z$SdT$dO2A){$)JpaV{%XV{;yLoo>3>ktfR!Rq%b}^{`FSa&ywsItr~CM%v!AOFZq6 z-fTj?K*&_WPpKfA0m)WF55AxpNhF=Y$R}UbXTU>h%gQ%^S0_nu*2&x&60*GC$O}b; z;vSDX+x2Y2j~IL?+gtagLzaT9h@R4Ya>17~;rgJSIZnkHMyH1->WVB(YRLWG*b{xu z70;Ta@5QNj2i3Uo!uJNj=JeuwSD|&)cAbwAcOR&fmv8yF*Usfl)kUtz#0XVb^$sh6dbFEPf{?{}xUnab!?hr6FWX75KWNgO*N(YrSh z=j1w@Dw1zx`vW#a3ZtgbTjy~VWFn2DXr^YN$yV_#l z!1BVToW#nB+?vbeqH~_bb)uM$OkW{1+DXtvxI2sOY^vUEQrqPaAVXy z{)=>eAIAs7WlIvzv}W$I=gMdNjarmh_bW<2;n!8mdD+X66ASlJLvGN?1;(0v|N0BD z)LU~uPJKcd1%|IfE19?bUyi^Y*2`g|0XKRh$mDLXI~K4%;7_zDQvGAt{(G$vD_Ns+ zNyj(ke!Qn&gbzN2`hOL(5{_jV&Wm9kwyw4JdA)*A{=?E45;N!p^KIyu`hd&+JEnuR@H3ji^;74Avs<(PWWBwe9p1l6z> zs%BPwwAy`NS@?l+;R&hisJ}GPzlV3wDE}sBaqdBMpKC@Pli(L6tAg2U6gQK}C~8=U84g*l=R})A!MacE&X~W66g?36 zplb}~CD!epGpzUO%{ovMT+*UO+e0F%!N~p=^J5aRb!30n9OaC`HZ+|kl0s8Q9M}y z;&n-fK+y_I_ny#;JuQW!F|^@O1voa0SKVF}$8T|Df7QuhNBxr&9-vbr4kylXhgV!qWM&@wyDDT4d1GqWfWHtO=PegJW`M61eY&*3V z9SGO>0b%+bw?-B=0<=I6H2p~pB@46QE5SyNKqp3Io$R;7V{H9?UnS)Q;po0I5$G-( zwYRQKr;Rf;m-sb8dJo&0r2$- zYYS#o&?q<}AcDq|6g^$2I0qxhW?lmCq*mU^{Xg$W?Z`Hg4Y5(sZtH5h=MhE;$4(kg zug%7e21qQ5umb9lUU}AaFIg<{MDbLVK`Y8l$gsr&xz-D>!K+{BwwDk*ajY-_6+Ov$ z-Ce`WmyNEFcOM+uT8-5EtCE-{o8NCOs=@HJNy*29dX(C*5o`Ti6@MAsiMYA%{g!yo z?Zn??D|YMxxQ)^r`)VrL&~XBQ7a{NWu5BoV`{9P~(>jry;JucjPy@r%$NVa0lBS+z z4b}x86p|e1<&rGg%Vd?M_hzCE*(hubwb=Llujxpv|0k%h$ot)EV`xZP#GR@g+(0zQ zfoyKHz120t=kzjUgrm`$r2%JsSJrk;^0(Z^w%==*9+45ygpE&a%(Wm3Ltx#^%@)n| zV}+@mtN)m3NE@HF`+l9&&k>dT!UuFxYsc%YE=L%7&n)cK$qWss?mK3AD;~JJ(HoKc z#Jum7VUB&1H@%0^8Czv`9j+)=SX!K)m|vFOj%OX_M8oR$NIhxoSzr_JpKltRdn@S za9`$&q1x9{_H((qjPO0^{`a~cs?s!@@;eKT|9&V2#j$&4(w(`NF0`_1QNEqznS zc9Y6q_?ifj*hJI1pxGur14aF`9@h;|V%ZB~Ct^<}9se8jV9kq+(FW+AN=|wiaV170 zwrBI8{qR4>uz{)%GHbMQrDSY7+} zW$w=WJP-(WKGe|PadJ=U%VUV>m6wT*pZPuRG?7CkEy8nI{k&h@&v_SGabY5_)6yA4 z??~XLfev$ID3vexRCsX(af*y2qTnO0_@ftC$|i+i@xqUa zc_?^p<{Fo9MVf%afMq6o*Euu}WmM_sID2M8y_PkY2-Ni!r_Juhqz(gvRbA659l$*D zvpCI!#|JDM_LtqcK{Zu3$~Jm^!hm=5f>+;n%eoXaY8H1mHov?Q`F^m5v;l_5)=t9r z^_Z$p??8KgSI~>7@ca1)eVZ4sAySv_uQehC~=Y`gwl746#vJ(>fx+ zg7D_Ye;ahl8+)g%_ROL->XKLAWXmttrQ==u3Ban`q_qa{9d!<>X2HTe!Ei$RUv-t? zi0+d#i82?7S%HufFEhsGROCP9E_ZiW{*w@Qd_{1LNZnYRteIcl$`xTo6{htD7z7y} z?fOdgzrJvm%3N2GyWCLO;CT?fFMr(RIBV&P&`DG^wCMnY+rK(ONy@c>xB1>00}{!) zW1eu6BUj{dXmZrc8K>+WbY0cJ7@&>a#o;8;4wwK&{-ajT&NTwcs;juS$MTl%*lEio zfrWEa<_2jJFBk9yE=%J4Tu+Os@ zut|)51+s1w;WUv8=lVWg*A;HRbs&gj#s`*>!rt!*t*IRmLCXw*Wo6Ur+N4=qKP9x@ z%?m2O&e3eh7$BU-9+8D=l($S@Z7+WRWgPeTg9lson$W>zH`a18S&F&ud^stb6ZLw= zL4N57{{i^K3W5w?kk)ttb2*ar32%3mZ2m862I-1IInSzOY8BW#XTo!3)+vq7aD#J= zn4TN8z|MX#$!Q0%d~HuA3tI*iiACqVo_co`$Z>2^D=?vT{?V8l>`bBy4=~elmkGlFdG6J2vhHk zoJDQS>o6t!_S)qgu%GPmFPIO0x3s_J#S64fP=R9wxNW+IpXnvmlmT40P#$M7$iN&U z0k;@YpoMGYHUJzkPtslB-t~A6;^dkf_;Eqi{4#?8F?!=+wvR^B9h*8x0E5Fw!LNNJ znu?qvuzqK_M5XS6PY8O$_N#t-dF-)?xmX60zGh*N2KTG^R;ZKKQ)|fhkwp9R2RwxR zQ@=5iW4_H8-HDPn+ex;J@3C#Tb7W9Gyi;Uy`epo%3I{nR)=KK*FyOrS_}I%6b_X_+ ztu(@V9o!oMS4kOr{RL&k*rRJc0fhbtS1xaK5lKO08?`(lwp|B_BLnpo2oA{)u9`6l5u7=B z6K!q*fAD<4bHzz18l?2ZzhsZrg{QmMa%QoOXUpD4l`Xg1f#@Q=n z$5CS$M^{A9ucXddlUbxUxM#QVMXy>@|NFuhwQ#MjDIEcQn4HQ<&606mJwp8Vf{V1^ zk_6Q4@NZEpx>l|}(U_!UpIV#w-*%6|9KdOZ|1UJ0)^#7szUSAW4eqSZl-T|b-ttkw zqF3k?xG6?d21mD2&lQXi>|AUV*(N}N(gdI2i>x|o-Si$RGA2ZV7e{?zq!Bc}qD+0Y z|8`3&yIqzk@J6lB2tN^rUXpkR`hp_+jIL=Bgfzj94hv3*kJ*wv78MvA5TEi=r6!YD3 z`r812y%6f~SXhNzM_TFK?pd9KZt7<$t0dHuwpQ3L%g6)<_?e+(rQj@YZfvk^T3=gGzNSZT;qF49|^BB*c`ydFF)we}dp^$H_e zK~c$3*Ka0iY56XgyQP+S+lwva*o@sNrbnYHh(DNn@JO#0N7&EiM#1LD^(>K)%*s;7YDek>(7e^P2P{)yauJ zwYThKo#B8ac(bL`lwL=+;0*u5+c{HAy7KgSOGcfjh`7FieadNlXMVoP-1|WA?LQ+N zXfTS@)#{HC?wC|Q2)$9uo4t+I@wl_od|gruVs~)7iy!-*f+C4KgCR&yi zxu6DzZNwIexwWx^r9d_4zaI6-Z*Zgxl9>)9m~3vydh>t+h;5zHrhwd76>LYUK?=@_WP`~U zjB?}u)Mo;nlDeMEA-w|S{Vc6|GQao#^AHO)$sAZKHUHN`{i~9m;AQ+xAp;Tlt8ZhA ziWbz6c?uqctt3n_POlk3q^=R~U1_;!%r%E^JrN-@G{XlJXzjcy*!9T98+}giB-z@Q zC}ecoR=6ZFUq*?D{+wu3Cw|L|7>%tvJMzBzhGrQ*!Sx2^|*JfV}y>pmpwN^o?R# zF1II_;t`5TC#SVfn4(YxDy@e~Q5d!e8qY(D$kZydC)};@fhWBjjHf9Y41ItBP{KE% zKnO;#uut`yAbZ&Q?SpLub-WmbH4x&|XwQF&qOefiF=!A?(V$fI+d$Me=T{A>)a0QC zQnN?XWku7kbSr82#VL06qbZxQi$a$}5%Q1-+D6e7#UfZVic*wVc@ArZE(v)Ehct|4 zg_RUIV0x&+f+&DH3&BwcRL&!%l#68wwmqnd;JBj-BXh%|{bA4M1R83AyzN?Zzmvwn zP5gz&uuxF+S+xnq8p_pp4HbncD}r#ZSu?y=dUS+}WD!Bq!?VgzasR)T;z~s^sAx^u zqY_lCTenIGe+~rNZAHP{KT$-%cKBaI%7O|WJVsax3f_y+?woC!aauTuOj2mHxck8I zM!n|tkhFOcEUP~-lCYJF%%=`v-6&~m+d%nIu=+zD3kOjBpv3M8@Q|SHE|kFgDTs_% zfD$-3fzUwuBn1xIaII=yf!_u%ArzD$`8NpAo=!e=^Fc`dkBLo!v#m9uei9sPC>6E^ zQjmxHBv9eq>v-xmGG92US#!`zm*ZJlq|^fPi4&aT8wOm!0|=Nzmex#PQXOpWt1(6^ z3T{F))OMxKrkIX#QtAilHq{a30vIiWp-&72W!UWnBOA>(049P=QSc+8 zSwfqWq~{ZF>cLP7)M{+`Ks~Lto`n#9g8Oh=rT0IuhUn_&XiyOJ7Sp78`kHAiZ-|^oT)pPrIPvdCImQ-w9$IDVi{^k@k>=hg<#asIOCbh2{-8ga}H)z4~fgr|=0uXQC#SLCZx4P0t=%j$TyBy5q(Xr!D@?i3MS=1}Hb2 z;r(3UJ@4f@E2mgPL92|<7xi|`zff*qFA}L6e=Hi{x+$uo9$X8^B?>;u{||dnVo$Q? z-1KrwfK$EwS4cV9Tu5!Y=0+ny%Kz&6-miWlsRE(R}cUf%tuW|nPr)Xi~ zrTW)&GWi~f5h0s6`46o}j$%>5rF!;)#GatCVGsbk9}VUD+_8HobjBa&Y6t&9L$+rE zjgo?HS`vr_6f?9)hb)G;kUC@0Zd;%RTB7G#Xq^P{h%+C)Akf$coIUHgRj3zVfjVc; zk;vTAe7bu2_240OXEzT*RMwmGr9E)1@#ET?g$SzaX#vUpUNJXnx*WAIFuGu^|Mll5 zFdeY(DaN<61S4wcc~{+ZHP>Zh9~lY;ZfB;GInE{shuAoX)Mz5v8Y=-u+C?ov!i~k_ z@NHA7oQ)I^x_`6Y*;5HwHF=02mNvb5-5Cj_K7KXvOd)Q;GH*jv9{mhE$rHQQe{;}F zK%%hDAk#PDqXE`eSm~kE%iVBo(6`CPJ;z({~imgq;dBytpuD zy39i*q$#!^#K9qNzO@wF9BP)eng^o zhO={-eYCSz@$$GYH}Z*DfF^NI{psGx@C1%WzfRLTRyb_w;x}vLIi0Skbzksw`Yx^e zdS8?d@w~r$>B1M)fY-b7use+D#(8D;UP*y87-TRND2HmCgxrcO@?8J~nn9^<><*fRT=&@OaFuh#1GI*e<>>3DC ziMe-xnM-WNAyjrvHWI-N5+(XDs{m;;ZnwM$hA##cy1y6y-@nFB!to#GIXVKivLuxK z2uy1;9rycdf^ZcYK$H68K3Fe5kt6l?#ksy>$WWLVD%){k!p32$1QOlM3H|O&D!sHo z%rA%;CZ=hBX0n%d40Y@v_QSN(^&O+OJe9vbCqSlfOxjG=&zAhSZAU+D4MV@d6Oark z%J<{WvN(!Nf{j(S7bG&{PLG{?4e}PjFqGz42>NN(qRUue(?CJ(ZesQhJhbEbu(1TH zwdU-9$}T~juyK^`l4lNR0D{4d-F^=5@Va@J_Im;h{!Fp22xLn8>&1yiySeUJys}aP zY+n3qfVbYYx9mt4f{k+XP!{&X^8}W;UN%+1?r-cpiMqqN^a3~kGs6Egq}w60ndsR!ytK_-B2G;nRJy z`pfUs-Yn!>7!NC5_zfz!O^Mvq2854&5tlaI$QGazF`sjl@%tau$|Jq3Tq&MJ*;( zIp6|M>zI>t?*|nFNztqJcJ6NG(w=*@Ew(NK$^H0D%b?H4#mZ@cZ4(|dNoo9Ux$U9# zEtWk+{G1(n{?3YOmi`T~aSw9$OTn5-XxuPkVsGj<4nassjlNhZWCOAvS*vbS4yagM z+IQbyPR#Z&%fRNN7pTmcZseaX!e1|lP8cn^Bd3tJsBQ&gg%c+c7tN$S3l|?;F9-wt z4+y|R+-tYC8f+3_E7Ad)m(9~k*hVa*h`Mft?mZsMGecu6(cxQ(0(D5IdfsQgd1%gx zN|G*uJXJo8yVDDu90F`xsYHn}0bSwB2^p3WJ9zqbt zqe^t)mVxt&eTtdD#r3 zmM^KBqjrMH5#mv`rq|N@miLo!Ap*ek?KWL6ES^~=R0lT3IxQE>V*&t`(Kx{(bVN*j z4`I+}_th^z#31*V7^aYy{J?gKcDSRCd5U5K_p(@=J= z94N8*tn3Ny-lcJZX#gVF9MA{wv>)E8qsB+vunG+db$oQ@TkYMbonVnXVphTzbaa!R zr4&D0Nn}^KD1>pn4pv@BZq~1c#r}~t&Tsi~pqvP7mAv=_q$>bM?as@ckpY!Dh8h0P@B{o-@9TP}Bw77XA_F|P<+y%(aAw7idAPk;$Pc6;)w z)0$dY{_Zfo9_(t~5m1~*o(hZ#_?ZKnz9^fv*4dZI!sJ2q86zJP;eKU>KOlj@Gb)@6 zFw<6`rCk4d^>tXfS_2@#20k8lPs{b0{d_#3=*&l3wI4E*0WpQMx1-C1=P5F`AH5Xl zlNaCq_dqcVX73lHf`Rr8&t=V|*la=;7|7wU)P_JG1K(RFFmT=McUe48{YA}2=sFMl zm8C4-XEPbr$;R7x)Ofh}?xr*Syjy>=5lE1~-oF>8o<*YYO2F@g9;4lZ~9E@3+C|7&(OjSv?Dvu+sA%szUD7TwEBoMh7fG?XzXEC0mw{|*eR694nP=i5u2&mUxD(_>=LqpNdkTw zPQ*(EI0EgkPid=cq>8AdU=enu*-Y#ic{m_DKwUlt-m!ORpD=O=CIq5Nf~pARnEwGJ zh@Tk_(EPmr)$P>(=oX5CyUUOvOs@TZ`6OCt>^i$H%q8dd1~%tk3;DadaW$X`h^cT9 zU|Q6&BLu^a<;-qNQiVsVt4)FYN-xs#-~0Ed09oH*&OS2pq3P7|YhnKb^8lpK0WbQr z%W!w=Jw69O5vJt%ZNQoYI>?07Tp}MzQDnbvB}8FBJVWVhzGC>_Z?tSq3v}3uvxGE{ zT-zF3MxFts7!I!XfBhL0nxQ;^i6@|!uNe7Pk6Gb(y;Iy-D35YNx9cM3*0dAqxSb7p zyrFQ#5bj8j#^k@U`s{&hMHOv4xs8F|-z#&z3t$*x#^hclZnBVtM%2m>=$2f{%G z&aIwi)Zs201+oR2+3`tW2rdrXjOyx#RCqznD7r04jR($X5g0--10vLNYpfSydJm!r zlj4Z5K(iS?-@UGIRurmJtL?V2u;4^66Gj?d!P7rCZ#nm9MMZw~+0E`S_FDO`^<>&I zB63gU&l-I!%q)SqAJF@6wt2!>3k&NBjAPLpLd^s|=lcT^icJdw0(x_^azn7fOC?EQ z)he6D)-IlnD;VPWe)KPB1p!I~VVvq(Age=~*DzZZ9)y2eTEN$P>jdAnsS^@3o{bHGu)zO%5QH0o2S`&Z&^=BFnjYE!sr<@=rBsZ@a*4+K(mo{^rdOI z<`KA>R$@LPafK}u9YmT=y9~G7nQo0pTmpt^EbvG&OCpCbg+g0LKpnRl#I%jlEj+6S zwfc*t*@Psx{w+7~t|O4wp6^|1>dyibkxY;9rof?6P6VjU&6$Il1CagC(`|DBKAOKO zPzLR*wli=*f2F>8kII-yAwnf1n{FPahG8c00^H=hOv$H2pL8^=i2i&JY-}m zInD}#8SDVYm5!6-eI+O@+{uSzpxVe~ARM2)UPYgy>=C)QZ4gU3+!PRQ`J1UQj}ujs zEqC>b$mgOwisndj{jija!IRZr*uak`q@J;w7XXfJTcYsUayWr!Bw$*RL<8L<<9X*d zdp8>7P|MGcJRr`?@4#k*HvCbf_`u$u)0M&@V**4Q*v%M41({|YE);&@t&1GGK=0Vz zvKXhls+A@d&^^PV^*UlxEh_C74(CJzzZ!zjzx*&BtJ^1Y4C-l!h0{`E&G#&T6a@IFS7QJuPK3ifl`)iRXAW z6-PRcjfCfIsUqcfM&WMS#S3P;pmE;=fpWHa9|Fu4o>8G>aW}S={#e!2W_dk$IV!m0 zlht<$)C-(7YP2@^cI@i4f2kltCv6Sh=PZnZpsWTZyBNO|TdZ;O#A%ig!s*?rYr|L0 zZBmr=g^N+aWbqz>_UGlS1xNQS41VxdzJpVip?)LxFINxb!43Rsv!Yz?=!)UtLd68u zz;3`84oKk*vPQ+mmJ@^x_KCzs@w1-sf&6TboTxohsBeABNLhS26Vl!>xMXGIogxSL z(tK>SmNEp2xp_mJmGfNa6V5zIpOsu7#E4(^;U2TjWmHXI8omHwj?DNSQD?2WMYh#% ztbLl=(!rrqwJQ1T%po_Fh4{LUKz{$0SS$QI$?>Iu3F^!DCOPO&2=$3y3nP0*okB}L`=Q=)*1o$BU2xQt~3#I!qTUhK8CQD%u3A# zPVUi4+~)bC1TofUvZ-D$H!(-}^z!gxA|t5}0_Fa#qJ@eBmYU^~=im2Wtw!u!XQ`1+ zt#aP=2faknTz-7=&>Q=4;%MpO%2YZv>0nn&|oqh^t4`yv)fY=ZsvgUX^>S#%I0i$7>VjU!a*_{H(R_|V*6?)B!rb3ApjEs{f^XHk$Y(DDOX~?Em4Uy`c(a-q^2Z;R-Ofz~s ze0KMmlPQd%U=(v$y0+HMQVi^)adZaEq-<&dFzpczB0{~Y(Vn?Fr(8+HmeiBoMzqBd z0~pyOmIN=tk`Ew}A4|7)x^7yQs1HX>2Wr%Rht!A`K*%@QDlkDFF$ER>yniy9QYkO> zg&?H}_T&=&DbcHah#_PSuXVKAY$mHwA7V|r>*}@UOft|?m8~|3m4H&T7J0jt&iehl z(!SjW?fHI{zBpt66Oev-O)3>XE)TNlAWfAh{e$?YzSj^5{BUOkP(`fnW_RV zXJHy3kxw(~iZl%AlRc&!^WxuZW`O(HFe-CYSz%Uz{Q!lYv#!-B_5@0RgUvX1TIblp zvya=T#A-`14909bnX^UPNpn27 z$5}4g-zSG@zU%i4d$*5fbr$OBUoEV^=3N(AMJU}&;%M6dE1>$yR1udjcX^%AyTlkp zAwQ`2!lLQBor$+H+D5Cg00mFte63}ZgM4HTF%5~Bq;-z??vCen53rU^;Pn)J^sHnl zaDY$x(8y+eB+@ANP0hZNVI$|w79)R)}TGtNoJ7rD=N0Q zU{=W&BnNuz$5aS|A>N*g0@byvV_7ABn+Z*%5qHBjBmOIc4?sgu?Z=v-Y*q>XLrWM|Ql7=@uIUT>|xO;gs zRf9Cr5c5pwQ=PQ9Kr+*D1S#dY5|k13fg_NpwJZox^;m>x6*E;8eRbQ#`H+DT`k0;wORBu{ohWQ?0jKHU325ZZsw=Z$LOY(TGT!r zxkG*{FI|!f-Q7ynJsA)$TXD|!+OCz(3ctLMn|jdIYZaBW(y7Som(KG?2x>c9dENm+ zj8pY%r|0rw-Gm}uf%hUJG;exHwb=>Ssx*+O`7czg4#?)_ev1Gx*URo!bOfBu!pC1q zt|=s^MTI`4cV2s6D6mZCt`QA^Xd(s+Z@4Jh-hy75Kug}?Ew#`4@H%^S5ggYN8x9nq zsLd&PrkYzIqv&^sl%JtnQmBrg`DU|_oD|uPJ~IR0@GgI4j@c#e+f+G8DLW*fW1Vo*!<^sH;Dg8ZV&1O$lRVSY6*`^i!?I~ znyqCl0}pecq$$i}M64disIbPrqH*!yRLBh%XCx5_K(uk2v(f~G9nbHsT5Y5!94eFuC~%QedTsB9}z)L8ia0_QhtxVC13!N z926Fgct~sx;sXL_Mn{gln+{kh9atmjUev~LEuN)qz5xh3Lv}_!dAgp}#?x!EYREG3 z?RokYTIJwzv8xN8MlQr54UPFmHUQfK$<8M8W~ooT4{#AV_dmQW(qTp0e z{g~K_Aarw1dy5HA;mO_pJV$#f1mayvefx(k)9S)cE4zjXYpBfX41;S9-jCJ<0e#p; zpQOMY9HObEaPI+b^}LP_c+jShEvvH zBRVP|W7VBLPg{Pl{|3Ke|2q=?^XUxBZ7kK@uOjaIGfldVJ#h%2*!fmA$AHKfT%sEO z+Izw6+j*~tu4&$ca+@kfM#$sZp!WsY%&L_$m}F=ch{cSGOKMI1Af@^5Xjv>!ZNMti zoBMwCN+DLbAzMs|7v~&M7v7ffLqa}nvLvZiy`fAlxS9ZL#c5WxPozyi$^3WO_;9{_xp;zhWao;o$g!&%0Z>?Fc$rGs5D|U67**aEI=pC30Nd z&`%Yt7-!`I%?QpLxma2(WXFsQqjS$PeWwwX`TU)Q{?m3Gq}r`ISD$(>0+76Pr6T zyo}CW-Qnuw_tdEHLn_Ixus)S!v)GSsai$^|+2e+XJ!3%(Wkk_~b0x60v$UBaf9%(r zs;~I9jfBs_g$DME1*ZMzT@ttTdW2bMKe}Q{teH!ZRy_}KHFe5<#ND7VPI9S}-NU!d zlUpm%z&Gm+`xU#C2KW8L1up*2S?mpc+;^-@tPFYHi}ACQY<(r<$1g%d?GVeta9-o* z*9B)}@3JA1BqX!@g~IIi1I~QQD?P+I3SK&BHFCt)ltWPmA!xyo=fpvM;^RlYVB<`L z4gOC1vAa!!U^k~?j_kb@438tnU_XLbhr_r5^EWEP<#v3<_R0J;qUX59=AjUN<)Niz zu6N|Ah=nO*BC*9tQWUiyfemR5a-E)0`E!cC>??tn$1OJXs|THiWtr=4%}8JY{Cx1_ z>k~2?_;Da7ouiax*7Y3MrbCU?HxTaE+j}?P?bsoRcwai5&f{8c)sK~9N_5Gjh1#Zb z${iq#HeYviv`b8V!v=-W9SkNQT!!HCWu4?3wggSO|KuSv3>WVYN|_LS?1?buOmmPlMF?hK=z!6Kaioj zc0oDz6<@&_HV<6R*Pa(<)wT|7Dy;;u+?uY=)qZ~_QHr7~F8-S|q6dO#yAMM6Il0z@bC6W4jG!s3kI6w&5m(DK&?1`9Er=Lu*d=mX-HL(8^McACUtCF@X zBUxbe=Hwv=bzTo~mjD!$w&~!riqLNrC}V}y;acL*CMP*Ef=~3pCrYAZ>Iwl}I~fUE zPV~-Cp^Q7$rZ1C4GG+gdLH~1x-gNv&K|{V=a^C>FAMeLC(kIC}c2n$&AU?)vRG3i{ ze}0|k7JEq@#X*mOIxR;yP%k3B1Y0Jd1DytW!n*ZK{dtQi_Wv2*eF~k&wPwU=Q&opI z>l2L^TblQaKz&aVrKCTiUaZfbVwWY6sghRdKma|zzL=Un3#tQnm?t~|Of?Gq6hT=D zIkYHhH8K-;iLRDFk!jOEC+1lYCensx~aV#PgyZO+Dj$YWWJJEh^~YJJ^wx_Xo-|n;Dt1YdhJLR)k|uioK%N z-utCTC0IhKE?LD0B>5q2UaL1tE#n!e;&oUoQgEBdLq?RT)@M+1F3t!EgmS%Bq}OI; zv7!=40;e1P2MsN}DSFeXfwBR(hxV6*0l9>-#ZC5noj;Bo;(oDO1z>)7YPgq~F#0%m z)@y}=Vs=#0YO`A1rGsh&cz)*O9M~2U%VH(N>(2v4pOd}lAe+x_WPvwzpx76heIbMq z7y4OAf+vzyBnQ$q67=FR5D8XyKF_RF0IF6_=b)%FOFFi1T6)G$*xB~&SYub3Nlsr$ zFMGGGt%Bp9rpDHm_yXc7tXl5JW&xH* z5!rrpHMfBE3>r=XDgxdZjX)A05ax79ow$smCJYaGtTmncrnsAK%QOY5oM|TZMXMW` z0lQiiTu8hxoHu*a@b08EFW+Z!M7uhE0P}pE5`R$`ZudO}_taDYn7BS+@d3Jzs#lB$ zH;L;~hgwcYnx;9|qIAthTzxmGDrXxgozNE(pz-8>p%6h<8A=JsG<*^F5p+@cQxB{K zuhLg1f{`*yvMKhn;rT^wr*L%$TPb5d=iZ$WhOB`XX2b(g^^&Rv8Zxwbki|SZ)(&}P z@!OzD6hM){074Kd#1c#$_8VdJk(Co*7ThDYJ_?`0F4fT?im9hqncN?mf1YRy) zdlR^wK#^dk^H5l>dCYl}U*ve&VGD?e#@*d%wE%7;TYM%SbQN$#b=&}E5sa&0gQnXQ zCQ4NGae0+!?H4^0UDkK^K=W@vHbX4);+dB^NKr4kYQh2)-7CV7x(%AoXQ<`!Kbz~- zj&g|0!y2pRlzD0PtBA8g#mcgW4rINiAXn%p{K`cI6&o6z;{##O90fsXMY5Ra9hCFJ)R@?nF7!6G+T5iWFX!8I_2i+v*WZW%D!(N$Xa}W=(2cVN<|zY|45w)x3g%-(fPk03$mqZm-=6$6n-n9rRB|J znEV2m2i5*}2RQf_XfB%1z%M=!-b%V(fPA82vi7wkHap07C8OVe?2nkfnm z3NxFXKc=Y2TOUYcg&!-k3 zHKFRb^|OK2+X}qtnYgiD%NZ+}{xa`CT)=a7JV-}fm`ev?Xx&To zqlPadKp7E>Fg2Krp;3sbyauszInF->`>8Gyvyq<^$oe)da3oN%vZH?NRr~O^@1KA~ z2llJE;NmvqaLQPVV893nG-=a=QWevPRm2M*5+Tp?gkSv?iiWQ(Q{0b-kYQAPt&aa??lB0Tk=f zx@YN{!_m)DRU4*qjzQCL)2CO|S8_e>n2Sj2n=%f#c1mDRXzt`^OD&!})H9awZSQOp zmK8yW-!Mv)7$u%db>l}`c6+VHb?bZK>lTD2OnP)6XyvHpmy1{05kCx=2UG{Ayv=88 z&0cdtg$YFp}UhK2ago%|bZ~*lH z!sYqXCKTV@RK5Zw9Ny+2Jf3s>l=Tiwi>KPp?(#_XPi;CxL=fnnIfXnoW6l zxqL}}%etV3A0PevWtZ#3tn*KMB>ND~Fjd)B{3O-@s zqxjOT33m>tJtn(qrl2vHC|uTz(sxn`5eOT`rY0X{UU*|cc!%jK%n_AkWy`k-X^ z00ceGV^n+XSz#e^)6%}n+0%EHnT?LBaJar*?|c8M^NqT3&9a7;!VKQmPq+d)zRz`$ z7P+4PSunJG+rs`W1CwcMv5B@4;UNQrtg^+Q(W2FZ7S6Mol9&nRbF2m-pNtN6tP-y_ z7A-3HWL>?+eD35g%WWGQBtNEkdP`>G6@>x<>SFY%WkpnJn{pAHz{V~M#94@Rb}r(l z^$RVqx(EZb-{s05kV_;3bD{ByZAcV}^bqYe6iLfZ?xPurgo=zaW}1tbR}8rU8GtEd{67(rwwTF z#`5yBvo|tkou0a5KC8i+MGal5n%0*+Y}fc$lKzD5PL%iae6aK4v;HVgj&LAGElews z)e9k5PM8tf+8^DE3Qd zxZY*;>^U8j8JqV~t<}IBkmHB{xZA_XxsLnJ>pNe!i9jZgN4b)hE(Pf8l}9{$^TT<- ztWi<@A1n+0*9Im%WCy9n+1Y&jN!Qpg1}CoMLP)I(q-G&N_pa8hnYY@XtCuxgc&Ynb z_;w&Ca@3K>B4r1D@4KY?^OW#}H4{}{Ll-fPc|49gH z6dAF)Lv4_l>}siC|F5559`(SkPeK_lb?iO^h=uw^t?Gn~OYCXYT|ba^9hGG#&r=QO zODS@(k4LdTPd+Z|s|G=ZhqEr|T+H=c(Y7^SdpvV2h`l(q@tCgyG>|!a#E?vL@-%u? z1HD1%_`S+&f|~QP12h{uh=t0}inP+AAtifU;i0TcI@b>(Me^Njb(7YPkQo_r(Q18Q zmhEZYH8&waxUN?R% zR=*IsvaD58dF(uEPJO;T6A&NR=rdnkGEH(j?u*F3s`_Ox z%F!sY#F7;HvR%RdmiF6m*W3Cgn|#mnJ@IW!Ik?6pglRIC*SMs)P>>&j)Vn_IxQ4sI zWQ)~tY%Xqpu=w-VCl00H2PR*?{)ZWDmcHlnh3>L{z=^E4=}26;a5d)+vFb;TW1}yx z867l#ry}+gon)4-l)mY^8yZJ&dnK}TOA+&9=FXhRWg?|4igPA3Q*W1aDIQP$N*$RPgQQ`x zRqdi{!qlZ9aHRW<*pG{jWnt&7mG zor6jErA~kH$-3(g(kF%fMB9}MZ8wx)h5>3$37HeNPR!T=H&;jh~t;5370QYHd`+BAjVbd;5+@ z%#othBq{^LP&8(6^`TYvG}x#Sp=HWYli|{3lhPWJRb>D9`-I2_!%Qbm^IIO|spD2G zjx!5j=UVm{MPIl!sEo(2e3VGIGH`4k1XVW$?jLq;$P$sXA0+ISw5xuMAE+}+urA~; zQ@`eupgBj)S?ZRR!e{4A3K@u*3_^dMUD4lkCmPR<%3oJ38Xsz99mCKBvUBF8Ri@54 zg`2gpqC32iu9BlaOGcFSAf!SR-ih^d4mfs#@Dq`gZE~fcRLdm(7JFMnHtyT8dc_@R z$N=jSt~m$c)by)7ze&uFt|Yw_{xJIX%ludaZS)DB_77{;%Y*r+H)Q(&Vx)|C2M_Wi z%C;fQI2qMt=QY>(a4H!iQzbp7ryR$+ny-<$M&OM%cYftT zLZ;P@=lF~fjFq=__*O}4L`EyF&}E{aWKez4vh^itB*_1ZnlKbON9>#) zv9VtAYF)MD>^$hG2=Ph+qpOYYMTk0vL%U{N!j}cM zP{K)BPX#wEV-}BSonUlZN8#4{|CB6~2V7ky&y@8<%aZ$#04CFx4v@`1Dr^I(sh zKAO6Ll=V*xIpJaL205<3%8WQw=G58cOr>#oaojZr|Dda+3HC)MplUuD zww$XetcWKgU;$f(&2c)577iYF{S*;+Euym1p|5|a`B<3~YRL-tgm3gnu>K`uK#}YQ`0DiY0+%Z-n>ecs* z5y7=5L5^?ByvmwdWW+hfd|Y&n0|?T!Dzr(PM}W~+r6cO z@u{=u%u`(?n%RAYyJM_RZh49Pq9LC+5Cin0uM$`o)^^L=ve)5SiIKplq9b>3@ag(h z3!7g=f_>!QzA{r~D9stbb5e0Y;VVBALS*DehHtGMcUdHT4Sj-)t1ht+&}( z74?uPCE$O2klFf;)Hv#;l*WMY zhxZ;`hc}ry;FSe{mvG2uWslVm2^c-=1ONF4dE&=9tfwCi#ANTpiYh-}lpSE+a+sJ> z5;wq5&$)VbmBTN&@1ZqLt#&;7(|-Mbq#tH%ykK`i@yC)gfW-fz#g*iBD=w)r zQH6`9P;-8febrJtu>jQEQap{UV7c>k?@HM#4(_KfC!|GT%R*c!K7gRbPvadV@jJsk zK&ep`?8GXhuwz*kcWoiw#tI#wx%zYKHa4iHTa3oVc`TQlRNm52W8f^0g8sg!gI%N( z0J>j3-2t2Qlzn?5o>#;hbrSTY`!;Ky z?_B-XzIuf)(9n>3(v z8V1N6DDab2jpqhb%LyDOWIbQ*UfD2+*S|}MUHs6wZ%KpfQ=#G*5&Gxfc6Q2my%*@- zGC9;0oncura`uj%=i7G_AN=@cO%d&J{x!C z2oKZbI{12PS2DP$&wy(MjW9r6HICuwGLGp^pG4R_ptO6|S8@G~PLiaor|G!*8wSMb z>z!Q?jm zxLsJc^Lr1k)PH*d6U@AiTXV?*1)!8ees6TlI3^GmbhHW>m0P7C|BS`!C;gh9K}+}0 zJZ|VhE^wC`#S`5QxNIWc930a2l{vMz+_#({y1Ugx3^rQL(H(j}-RF&qr@oPmOseJc z^R0)$Ed>5!7b!XeMIUN`cQ ziODxuG4f^m43t>!JcdUUa^D0937m*5UDf@U!lGPnRALU4>VH^)Y7hF^e z(-Ey(6;5v!U|b+t$&Mh@pf>;f4SUJz1Sl@uI{TZ)zob|mUS|sVk8H&svi_gqGnUWhTg|bnQ?c`8bj)aQZxN-)=KUT)qdT#) zsQEanshTOU~p46);_E-lu$BCkg~#ry0{0@I;5b z$u6_riG6?IA}B%Fe2}ZLX9%;W2#Dd*UCph=5HKQzgpO(Y$uD(fsM6YO?PNN8_ADXJ zy*ZTVdfQzd0`^~w?$k_Deq{k`a1W{H+S#1VjsZprfI0GEq;#)}1K!+YxbPu3IE(=? z_<;S>>IlMAu%1xAeG8NtamX)g7-PJ{dGyN!>*kDG#Y zStP{mDx!^Z)pxwx_d;yzF+clKeZ%=Zs7yTFG-|rmn~dG&X_d8WA!Z~lsgBc~tmaRi z1rhSG*XC4qxB2-`cvJS6V-Rwg&ua|heMP@*zs*D;gI>Jq+~YI&8L^+jPWK$R~YF}(L)f#cvbhZDFjh;fS+Vq zYS0oS`l%lLMdzh^(+7eW*vUUIC?g9A8eu-BS1v)X`}h{YFO*K2hMExc<}t$|jtYWq zJidBa(>xHiGHF$r|8Dg zKe#VnGrrgwUOD_8WnF#a3}rF1PaU1cc-xj`qZpCY02W$nScC%N;RC3+QFF&z1c=vk-K+e)p*qWjr>Tyi`}ou z6U*N56HBa=ZaP8zcjlhzZE^XAT6$zOVneA`))OHWR-^c)yEg*3?MLzfYyJtCkqo3 z-ErCHA_7>v0*aJoi6#DYO+iRC13shSIZfN+dDW@9qt2y(lEJrlmb4v@)h#$AC(J_e zB-(s&Qi1l}mfI#SzYa?sQGfm|TS_X|!AX{5#_HGa7x*Bw1K^5%tM8|k;u}|%C;mEb zgLyd1l@Om6?Ky`vHF?7EEO9VoBFQQ{^PA&!&fZ+6(BHr5TT^|4OJ7=JV^fTzkN#}0 zyo-WC_9zyLO5C|$0sghezwy`~w_rkYS!S=N)_(dddl5w#x}l^<45B5YsCHf>K7G%8 zuUts|+@Tz!_}Lwy&=iU8MA6jan@x(4D`4EqsARuMh4!s{$v$uI+gc|%CAYdiJEghW z&0${tENSiy)IY6(WWI|~{S58-ZE;k@XhH0HbAvxCzKG)qHykozjf1KFafj8%%c%HV z&Mfaaqbyn~NY@3?c0l~e@HNw(o{w(wG7!mcm9~qf<_3jtA_g%4+u_U3)NrQ`R1dFm zW+EgT_u8GXW|qOmj8W9i`PEeWk>BpS_O4Vl_;&t@qQnUBb5kLCZ7P zh|+KO>Xe+3k6%#TB7THcPP0&OxH#}wxVfnF8vbU&+NKqL|0%xoRDu{4wY2`YM}Xq_ zRTQ3bg6S(#(+zatUGy;iYzl5&N1pgL{K-wnsP--bNwtHhIJ?D_Nji5grdt^ji zu+QmK_hE=#goVODw~^ht-=Z#yzSZa~Y}KMOV(!jXL4|wR-c!i-Hy9wRcRJ9q_SlVm zeV8ROVwh-$TMJ_z5j_aNmrx_gG&-s;Qxx3!jRc4e$h($q0Ud!{;Lt?=bjtv{Er@nP z_{L)pzHI^EhI#E+YDI|)->eL0SYU}jI@bh0ws|YMG}q^B=LA*Wi=W4tWS1U&8&EfW_I8vSH}qVlms{EU z=ZI9r1SiD98W-WFl218sm&+5D4t^=ALNnyqQ@7TGIgNM~(e7|rv?3liGHCFwf;dHh z@`8J~Da-&Rb|)ibIEhg}cPCwjnxKiI7IFD1@UA4ZB?}FC+P_Dp!6T4qv^x)AH#psg zS}5r{T5jMUQ`=swzDAJ@Hp0H(;;C@PFFK4#=@>*(*0wXGqX)=|_(4en_eJMC7W+qH zAK)MzLj1)=r_b*`O7FWsNl)ly(QHw~wbz>1z-APp0JcVY2PGkbi;2`9<)ci`AA=W=&@!O!N{~QcEI^+Ta2`i4W0B#K z=f6;vMPU$S2}CrcZ6ZZIf4PsXUvW{Cf-Q6^0%N|Uly(Nw3{TyLvLY~utf!!J zxh=b*7ZY4|O^MhBRX=U&Y)Pl>Xvw6;1zry`JE|o2P*tNM%KPg&;xo|-|u-6YJn=R1dt&Y(wL!zq&eGnUnj~e5tD>V z2>$KKY3@}4i|A+^q*|P@>PZxAS{+XGq|d7|kIRpe?1P7s%)L+CGi|={V&-W(24vg0 z7F&6}tJ)y1Qw()^$<+p0u{W})Ag4EPy_N@nUEX6HGavixnHSRI6eZj_oSC)Su~HI=YvF?>722nm^Y z9!0sV-?Ds_f1lFMIlWr@9^UN8Yq;Yz1nFooC{{m9!8<=)6=)6&7<(d)plFH99=mk^ zM=AFY4vZ_{lx-)wexZ-(A|P<+FAarzr@3a#VfNE`G3T7qW7>*>ejU3h(zXqUKoI+& znyHLZFd+Vo(oQTbSr0;M&n4ssS`zY2cHXH5B>!IvT$V$uS6b2VKB|X-qNO_hTudZB zJti_MgFDoAt*Ge&6yAfFPw@1wKz=&SqIG)k{;y*ZsX^$8qEDv@hZM;qJor&xZ!wQB z4hhMn&Lz;uR5oueO}vKw6J^nw`*T4yKtDUhDV>`-Tn=$*-M~z+ap$YH4I|1GE_=tV zUhUk{0R<#x%zq#?9{D!?bPS?s_NJ`a>gx43qEPsMSn|RB;rfkh<_apNr*QVBe&$ka zsYs6i45N<_Xk@;gc*H9S2GVvsVa+Ur<#oE{#r#e?9bwGb&$I-im;r#&&9#u1Frcw3oA0dT(T)aHCUdNvlnMpU(wQp*i8Q z2HnTg+!ueAu|ZGzB<8YBi zlgLm5BsF9-dil4D>>rO0cz`bIjN`xmQbTI|JtE7-TLZlrU35Ewor{SbuqDFf%n; z4lbMY1dV`_l1&f=!Yu7^wCzyKS=vstD&U`zyl;u%tHGsvbM>no+5yy+IJm5v$$rGp z<@;d}WT4Cb##k)oAxVyrw~{Z$-Uc+a{=|j;D7U)Za4y`BH4c{z7(p={eGMM3z3yAu zs!H2Y$;9OhgU-KkW*7n6smKP{=cDVa1U_I{1fVrzAQn>t2EG6T^C&OLmgQg&rIoIPL6Vbj#z&YFiyP~I{%)ZsWm@X17Z+bdLK2RQ^{6-#v^ej3r z-TyCa^83oWXz05RDkgvhusFh+@QW;AJh-epz-g@ntX6;e`HhgyUu(=u6-A=$@XF9c zhL*Xs>F7Xtei?DMj=nAZg1(<+X%|0uZ1XpqJitmZY_*j8B1_8?41(g{DGucfhC_KP z8DEog?!zn183vgjh}Z!+`gWmcfB%p2`KDnEiYEi?{-lVIk4at>k=Q&x()*5vLRAk% zsM;3H9v{vvXQqNMu~OKh($%jM7x)G=9pe@Y&FW&@Z&E_4ouIvn-_Z#cgZ$ z9*h(aqPNINC_hb_EpG9-Z&Ii@HU`|3;dO|dhZ*1YfBh}v7&r}=os=_M4RA$5KPSP0 zqV(2}!CTrzMil8Oha+NFbs!u^PL`M{9gTiw1blNW6shc7>N z+aims5*FoD@=Knx`Z>nnoRsI4GJhHf;x%8X4a%q;lrvnO2tJ&;cun#99XOO^g5BDg zXl&TA#U#>pRDbe{AKB1ZY=9u!=lArnCyf`Bc9>|YAEe+dr-yVFKVAYVfQ)TOpY0{( z)HpLnq>U`}TO3GzfkViGSz#+9%fVA{*>c->E~ur@d^5%E3zuV@c#g0o1SO9u3^Uq{ z?{5gfsMzDgGstabq*CsK>#LLBt!Txbr{EJ_aH-ySNd=)5eR|7;t)3gA2-d*jrU1=1 zFlK+_YLbUGHh4p6m*D#&zQJlA8=?q7X|F}z-&=i?sFr%|tb7N@{LsXjCj}I4{Wpbp z>=)qnho4C-j$T&#yt@Yy3J>Y&eGp{#Nr=Vlc~Sa)s82ft@tjgCV5H|hprAj)VwR+! zY>o9cgPpoO3W(*G?woh`0=#LGjaMz55K0($;QP4*^9&aigB zYM26CWtcB>G5x+z#3RxqCj+KlUJxSgK~SF8@LMy38NJU6-_HBlE!M#xjH~4TQ`RS} zoOb{DEOoF!kdz!al18#mc_Y%w5LQLKKu@b5n;G2E1q18n7bZe3mZ~D2ugt77OwGja zygk^7dc4@b?EQ=8arSzDX6;*n%-Z*?knrM_lg9D7zf9D3Fenj*lKYNpAJ(2Mp`T=q zhBmt+@7Nr)Pn0|!xAR_G|3MAgu_67qAWQr1BMok6c=j==62FW>dWKH-<{f@-{iwn7 zVD_8ljrVI5AHN?ikG~Gl45ubkBt-AetZ|sh*nV=PkgHTM`(Z=Z-ojBv`Q6^wMitSt z*#9v%^apx^ppj~e>@q&-Kj>&USwDCBJk|VP@7aF1Jet+B#%Pr>O^(x!@aH>lRN{%= zxlG7X4quylAs@#tdF~%o6B`@!hUah?fy1%=cy5~0d!4PT!EfBxg2S&3sv0s;+7Vm= z?Zn+*SnyNp+$kCh{++(l`Nrm!D&qZOzne7?Rh$>Ho+}vde*NvMmk76{5xg9VMIQU( zV(6C$VnQa|mj63XsEs-n=6Lrz&oh~ZZC$9$l5^)r?H*@2$>1TTXUO>l^@s%3&(xgV zHPmkCLNBUp_Pj=_wa*>o^B-YH71*Z{n}e#o3UnO?(H3}HMGJ|Ru#ms@QK+|C%Rc#( zcYbD78_8?KWzF)jr&Kblcb8^0cMS#2XbJaCF`*~(IS=*K{W|`WwoMfwk%GEN2J9!lI@og>j8X$?{r!X z+oSv_z#Xt=?DE!yidH8|;e9NTJeJO`hLN||G zAK2=M+?Os7QNOj#-OtpvZsz@MtDky6UEZ)JZ0%QLIGxF9$20%j9rmpwShd9%eRiKv zQ9@(-J=^P=DY8|*{OA}2=u=L;>izx%uD~~w|dUQojIkx%$%82K3;g( z%xCe~ofu=WFr3&UC@WGVLM^2l)hMV?cw|&-XrLNQ% z$y>l>?fq8Q6L&5TtFd6#V|F6L_Sbh)V=GJ<3AE=D>-~R+%7x1{81~fDbtJvWY&Ut& z@gQt-KyiISD;IRpEiuiK_@HF26)_>=*aH~*(2ElrcWwT`)x39HT&+zyHCB>ua1=V> zcTjtMn<^;+({rQ#JYrUFv$g-Q-3fGXDS2p#jAR2S(J|F2>i9P&o)Ihy=kttc-^ zq!u+%#cO=-x(5>y7LoSUgg-{DC}GWq`Ti$<95R9<#;isK`!HhhKikA>tZ_VaiPb0> zywUE!kC4!>B8*8E^dE8$_Y3~*En2D%Eek9G?_3Ytj1bjNtsjSPqi>>NbBVY{B5}-T zc`j8D@fC_lV>IKBS(Fz=kdo&T&Ct{$Jv<^hwj#C^gXu-Bv6CuPqCwuCl_-FEJJ ztmKkb?;EoyMC>TL&R=PyFTbUZLlT7CAF1!ADl@b{N%x&U;0}I2^Ih4XZz2!lne?>)Ri@fC%& zv$%?yd)vd*zEG54Vo5BJK)g-nazQ>M61OKB_hxA*`ZPZ)%sW*nB$*Rwi=_tJ&|V_v zWP054V;v%RSE;Z*XE9AO$Xsn@rC}7tEA8Gx7 z@6$rf{RV<-2LW3_rQG$y!Rgy&t(GNhKGKeH=Y^`;E4@pG*V9{N!mr6)N4Pqrq*Yxz zJ=X(9Xbo;i;*dxhnQ_|{^Z4_;oOa)}{g5LvQtyKfD^3RAqS5}TN1avPTXms)WP94O zhxMyD7&-YfD@c{46P*?SG~Mrw8bjLI&$YJh8KEbouvHYxrV?OypD%cS@K+lzGoj^d zx#al9I~t3EjOO`{iI5gNrQP?}OIG^KuFq@VAKUde?_lT+I`zcVw@Y`ZygdBORZj=; z%6Gh7%qj5M+;Tg*0hOloN$~H_%~POg@PxpRe?%!%nnM3pG~L%Ut9gPdH>PMyLQd_ z5*GPt1+!HKTkHcID&W0wYr}9&pKeMCOMxoF^~o43X#$O*Gf((cc5ln>LsKJt4BS*$LmIsoia6k5oie@;WdE~A;AFWu3Al7pc~OIR%PXj}PqPHXJ6NJa zT7nNNnvtT9n?)g&s$@~=IGf*l&rA$NvGTYEi&)wYeq1`2WGs$35Gt+OxVQ=2NqA$S zi(Trh3xlg$2rpdWu20aw0wN=0bJx`=f?m zztNEE<{>MFQnU>~~X@Tzx=#(kUUI?6}tb9Lqmg)RHaBliFeuA0g7kHYQe(eISa=euR%A=GRW`>DPkY1?zJvv&t4|6YaZ_K8g;&LH=5K&V-U9-r)pV?0X1qB|S?CNiJRHxJ~`m@DZ ziPY#{XKjM3qOdU_qL>l7Z#+_?6^z{sV7|hRXOF0N;99P{m0_g26EoRN*=5{l?3R;O zn=!03sS5Z0Z0_gYq)@Ir;e4;|ApvR_Y}K+F_S^iHhXr)MNE==+%uI!5&P|G{|24cI z;4I`$au;H$i}S}f{={Qx!q2?@+rd;$s(uDIVU4r8+@#mvM5TOd zaC&Y4(o5OaaLy(eRvXsEVkY1Ru~NLlAsBsp9fer#>TI>XqDCNfE<=JSOC2W6(NR6G z$n6ESGY#OV_hs#(1xws`-qN_V;khEz?_YFz7YBC}Q?shIZz=0=Sz%Dp6L(8v{PAOp zz^~wdsy}wKb9dx>x?~fi0JR8=b^UQq(#l}d7IAM9wx9_#Rygb%k6}U$^)u#BR zho(Bo0w3(|#QTz^H_BDiZ6r@{pr^6WDET$Tvzt z*4B7D9_vPg`VN%Zo;>=@VjiORt_j|Q&$C=jNEJ*5Pi_^z$)i@5E5~sB) zq#C$Y;y$K-P0s>rl%Jx9k{$)pzCnZ!xR>Z14o!~IJSP$*n(osJvv7Ac2#=l3o-pC3 z{<)VMI>95NH+N{7PdNoYUw1i^@1LfgRgDp|Y|dd$5MtqeMa-s5dq)A*SzMGU14* zM;(B=P1zZLDh?w*WccQKRpc4PHzYpqn?Tl*y*;$;9LAu1*hH9Mew5B5^oWWzF3~PD zZ6j!!xy9w^b30si7N4QRT8e^uU+rNwQyIoVBW)k>dUqbxOTxWR_b`*FL0nh%BA1`z zBcJy*%Bf3ff&^c3Q>=unu-p}ErigkDLwP}yN};(H=!PiPPS5^PJs;d#d}-GWlRubw zl$yKdFBracO_-qKH~sA$3)~wvh=|<7>21sOIYO117!Uu^Ip$W&^!EL2*0KhG!?nqt2Ii=QDDnkeZge};saAvUPsIkBT(V}Ctd&OGNA1B%7T0~q;MZc_(T z?iqY4we1jy5{;=i?Ed@#4oFlPT}S$Ie@|f5<)?!|2p|-lUOExI4N;(Lnj@4`J?EDU zOR_BCw$@p;FFA5%H$_?IUo*Aua(pZihCX!Di6r3OSZsrSST2`qsLUc5vbfrMxkyx< z?@5yc@fO&#Z#2(kBUJ3kFHrYxnW zXR{h&uI8MS#IoHW=Vm&8rzqQvi{6f7(C~8Gb)Bv79NX7%8{61Ff3hcP{MM-+EtZ{n z67lUnN4gqOly-M(58aF(oqcUE8Ekj(rS(KDW>x&dCgYL z#rN$LL@l|}w+UP1T1a$t>#5WpJ^~lNA#CoCx@z4f?|3kSrUm5`LW=3VZP^LoEKvMu znENwg>-FQ|eyc67cWjR;4nOtBw*E>F+f5?MmcMk*n7Fkj`gDxI9a%=(ah^CSNRX`6 zCvgdm9o_kjJapOA^2-SO?%kf;ZgWN8y+ls%LWaum-vhXw)3`!|m1UU*+np<@K9gJ5 za~Z`h6BWKm8!no%7`-5Ia5dc#Miy60lVjopS#6S%;h&{+paoiR?;LOoAU5NkOV;R| zeEV@+@1wb!Z5qBCpt08+!)aeW^!)d%D5c%T>|fKIB;s5*H$$iH{H;6%ygoUiL#fN} z4sW4D8qKAQT6YsPYeGmPqZE3{5*<%UC5YK%Rp=>XB=t#MOCalZ;0}l0(^{RdjpfH5 z4w(f_v{hq=)YVUnnGsgq`DYh}SAfq=dB>$5uiBM>$x7E=8RWR^m-ei18zdBDn%Coh z9-7V`_P^hnu2-#j9){t}z6(6HC#7bYgzh*@7B4SBylYd#+avz4+&sGGN`u!jHesv2-_N8+mhYK|!fPCL0&$7pP{vh+LM-Oc8MUtYDyyE_}~ zf=pd63`u*eaq?!v4`tXAY`y6knhrl3Bibv8YYPacL{eC><*V+mpZ0{iu8}-zX>PK{ zZ5B9WoKZU=J*JuwtI@Rq-up+<=5=TEy>`Y)=40En_0DkXMcXsivA4uS9duBAT_E!D zQ8F+~NEIA?rW0y9D~Ck~e0`*5QL?0d(tg4xIGkWaFpulDV84)>yVo6!$x6+JQR%KY zFV3*d+$p+SqJ8h~>;3(LxrFXP5N!K}#=B+z?aAegP!ZCXm%l(k|Fic(!&S~-#^Yx$ za^hd#5ED`UEaM@=*!88SCyBK?iME3WpHT#+^a@MM0<}84V<2fnIdV}qUuE)KOjeqZ z$n_(_7rAU!Frkq&*udtEk!-a>lw**Ez~DQ({IskE$1~TBWM;KdeR0Y9&rvn`LCZ!= z)k||%#6(0b3EeM9`awW~gJ02xF!R{%2y~WAewsC6J}%4wc6QJEp12I$TSr1UPCR@M zM=(V8<(e2s1IHvDBRBL_E}K0B=~xp3rYzdC*8_sL`(rR!@!C6G zVjb&FYSw7}#p-8h>lBUzjlHd0N`u5~?im-6wpVvVz`bEEFaKVw>pM9)MvgLU2WxNb zMcQItefB&o;^r~v-RLi8fZv_w@>U0(6%3~nBY)#B+Mkj>Y*C3=);o((pVmc?HWndNTtN<7^AaYCw`Vook>ikHOp_MsTy-s)hdbD}K`2FaNX z=~2gV36Lab9X-D95*BvR)>Lxjj6PN@#^Dm6J#2n~Le77qgNn;VR<E{Vr*?(ulv+L47k_ew&Uh{>O#54ZR^V|-ajc~=6J>GA`%$l@^W81Yal*9p z?-kEOhk=VFe*4KMi(kUM|HEhSbwfd5X(s7{C~$b>J+9v<9L8Vp2$Yk4Kd0NG@=d|e z<4(95ZAZ{rCuRi9l4a_rLUpEbMep+vQXbqBhKlUp2SKr+4}(>vUh2-MTS`hUA3Te1 zO_7kDzVkPBLcx+y1-ym4c)jSfvZGQ=PueRcpGFOzn0Q&$?P?Fv|AZ+14WHb#LwQyl zeJ>W9&R6YO9OT=J^$*r;3%o(p_8{tAlcWK1%aHJ=zVo|A!;KNCIE?GN6ANZjd3V|W z6c369F6(6kbV8cgo)v%7?n9?K;->-Sl=wKXF;18dY8bS%_-;%3SC!uS-E^&0RCR1*wPIse^rbOgjf zwsuACg@y%=l%gy-YBzJdwewo!Nvb2>F&K>{^9`3RnCp`)ot5M+*!C1PkBg{dk1HTmBPsp_CZ>{l-l#ZnZ5!<2T;oAr~AqIn7fGbIkrO{cmt7h&r+z(-evfr$H;)ah*{nxzf*YYZ`Ti=7oV?`)7 z1R$1AQ4|HwjilUxd(vWQz1wOZ)t@;^p)*TP5ZFdz)EuyrAu1>{QR6^oTi@DSV2AeK z+Pp|(RmGDOc<}oVtMti;A1A+!`dDh6`6<_9VcUzf_uD>m=v)EYZf^NMRDcRxV{^Gt z;eK6ZxO3qZ3q>(|TtwBzK+CJb&GUFJj*)gS;OY*0`WxGTPhj&(GhCc7;LhgZjEH%- zb}9Or>K-xIeWrjY5fS)_((Y&3TWu$E$sxOftlw~3K7juF@aLVNnm{G%D)zMF_f<>=3n6JDkl}CSGa%8DQy+Yf&HJN=q}|KDm&W&I?I0Knt>eF{f@UpnTB%;T01F8X%D%`+z}zTP0nT zqxtcjL@82>6`6gbG+Y5VC{F-Kz23w(z=DD53XS>ao>=+T2N9HAaf*f50*Yw z-D%~kqZOU@aN~T(tKDxpMj3>gv;;k%^%AE5_U$4r=Ar6#sXm2{<_^1;Dp}-CsmK@8 z&G&3tbojzP%(FlRqAbR_^s)o@KIUATv_DEQ4)|u?=WM+TlL?NfqwO#o`Frlii|!GT zVsT`?J;?r(^dGO%hAR5#UR1!UU&T|_{pkXb|G({0rLkS@a|;u^Raz8nO9YDTnvz0k_um}2SA2op0ZSXx zPr=LD-QIw&o@Fuq=GJiu^Pz`D-X$z#$Uv-gGZWM%(0aEwo@F{-t6TVY?*s+f4n0!a z&=^zd4Z^27@*NroDeHd_Ee4m`fA4^&4CARXPrRn@PWqVhUg4*8&R%RkWztwQ(CHrK zI}s(|-1%&*wW!cu$a=ho`+y^H*<)J9LA3MgluyTuelXAUleR~-_`bO=q3euR1l$mq z|J)126AEDCjz0Z{_Q2r!!@1K8$tv=ntC6t^@M?UiENbJ6!b8Lp80ds0U+0%(r`IM> ze_yd}8ZAnuI#?#PM+>giYx{?oI+860sUnp7i7XIdY_+xii?o1yV;Js9Rx=tog~*=Unud$ zq$lBIySJYv>2t6~pc+b44kJJ|lw-nOS(qM`B6b7E_^Vaz#P%eT(xlNH9qO(qOcu;D zwktc9_CvR%YfEm{_@2>7Onk#)kd4WT__rVFB&FW^i#r2~ z?dMG!g`;u9xDUPE!gv2N{&NXLh#z>*Y|P;zuLdrSkJ3y&y&YcYk4Gx64Bjc;_~%-% zAL)%N1daO_#nOFP{YpwzZ69LAJ5HRD5^)&k42^l3O2BhPO44?uziQ*A3IgINbk1Li z0jb*aCl};pxkF7RBYG6_x1`zO-Xa;HTTS6fH;J8vg;Z9LPqw(Dw)NZxEsN5hS0haU z-~c~?>I439yvROTkMJ2+^~y=clkPe74^6RO%T$u9SJ+jvx{Rkk87KiSZ)iA4hW@{R zb;T=ik|qB!nhoUAV*AQ3G$WVG(*n=He;(~q;yNMj?ai{z>cWQ|aBTV@!$YmG zO${1@cHz;n`pjY*4c)NDmddAyGmsMnF8ah70wq2M1P7xO1Y!4_qDRL5cMhht-YL#tu#w_uKtC``y(=782r}H50 z@v*DaDO&5PF}$zR)p2PP*8cBU1vjd@<-B@H+$r)Z( zEkBD$&UBaPm?=rk*^6=mn&W*ho~^Ly(Og{jRn_jlENgm#fjZ|DMgo)&YZV zwJ}ZY9SXuw;CG4F64{c|L6TAgB*-0G-697Q9`|Rvw1uvl9&TfPO<8WwC!Vq-Q%_AZiC3nO)(Ld zZ{Y|S1go|}hLr4H%BNjDVGxz-8rL`e?UjM2G)?rq*RVD;nJX`2unhvK8>^32E_PP* zfB??rr6sLccr26N6Jk34yW)}QH|r*I&f|&`QW)QR>u|QWKaOy64(+}rAwA!8fBap?cHb1osNaQ#q@$aw5@PKRVe88{ec|WMU%B4S>$l6>3BFrT&E})f z)!bEPz9pZLh3mPXC1HmcsdkdeQtdz*GeN24%A9 zY?Q%xA^LEULW8!;e6?1p!j1XAf=gKyL#DEVCgIGCZBg3V)vbEx{PshPu+tom#{K&h zYT}An4ma2@P~t2*#W7_5-h+!l@n|Wx)DlHNh^wfv4+w}O1^14y?VVPOn+N|;DmPqI zj80AtKmR;Q6=JsGtT@tCrdgTUfZgO(8>hJm#D>KV|N1LUr}t!R$kb#&$&k0m@bkIx z6f?2^hoU)Kdw;64>n4%1Si)=H*-F8^ZY6=+a&Xu^gWKL52=78K#CT#1zBt)($<$v`uG=+pJ+RVF4oz zm*RArb50gN#)f^b-rCYchsuJW_tM*)W(}poBZ5@LV>PkjuzqrRuHp!{jH0wTMFv4t zGFn1}&p_%;{{UI!_0$9eSL{r(bMwC@C!8_k3b#_>i;J8yq+7cY_MWvq?*rD>jj1(* z{Fiy>4@a%`EG^YSTQeg@4`tqtf9eZ~oa z_ZJveG?I0`r36qsJ*P$FaecX(82i%qm;X5^=qjgO*Ud0-x3s=AOxBxkp?nB2U6-3p zyQi2%AOle6NH95fch&&aH+~6&lRn7m{GV1m+kA`f;QA=)v^0F6tj8f-V_59o1fh-a zHzyzQf*h7(zQr-+)Wp`b6O8Ix^(>=12}+vmbc_|(Y~GN}Js+XsQ#*L=<>%(Z&j734 zc=*|(Ho5s80oZ~JOjZN11-2O6;4^mesL$Z=#<}MP%Ax`iMcvc-fYoduTTNC&nLM;0 zR+!q>K>c1pt}I7>z{l+zkNzII4u`eq%ihw>*Us@m1*!g6aN{LX&-7m^m!s{VTHyUq zj9HABJrcM9A>aJ1asY`K_}$UK7@0_nb!1~0IuDcL3PZbG51pNdX|Ew{KzS3YO0*=1 zn_0e|rDTT+o`t?9M?o-Q@DaR`g2w>;PTHCaKmppfSQF+MsRUL>&|>+kAAVS8V?)*unU z(*iR-8$vjs4Dt7CkD%WL{ zbliD6y?I6r$aU6>qz$qB2(dH?S*SE$)gZoyITf_^^b8KRhPRQ+A$z+wHRFk4iMix*3q$f;oKQv- zj0%LHKdk`=*W?3rY(g!H&%(VU_K!YgiYCnWYCulYPL$e9*K75;by3pSCN+>IDp)(H z4`eA#6>Ii>vC(x9K^cABqKcK)Lp=mH4zH=`#}^A zJ>!VM0!kzWol^{;3`P90qkZK}-jY3g2$r9TNi6zja(gyg!sQ>IPNa zg&kf`f-^ruEi|^=f4uz>R#aL#hcQu$sHbu~@J8i13`Uke{=Rz|8j!y3@`4~tO#XH3 z#Q^HmdF~mtr_>ehw`j3rtO{2buP;C^sf=p$Whg=6)9U4qinsYM{lMVT=Av?@JgL`5 zO=0xT6vf8lS}2eBZ=oj`3?W9rLq2Bq$kxuX&lVJP;EppV_2%-UU=(YC4Om#H?|F5Go*Td z<;Tf@xJWnx~Vee^bXs99}DqDuX-`#F%DZi0ezMN|AI*6sjn5#{6x*gDHn_q-P0I0f?d_M06L z4_etEa~SJ`au$xLFG?9FWZuSnF7IKdKwmuP({3dB#bUVI#LY$ge?CszVrUA3K!NE< z6xQNvz5c=`jhFBaKn9n-WpDw&K$&3g4qWw2FZ=3OcMnF}!NG~O*+12{-HAm%luwEHAn=arY>+NYB6t z(46H_+KGpKkc!6b#NgjGsv@g1FcbcMC$^Z_LY~^v6QFJ_fw!`24>NfQvrEZGO_3Hr zcm8Zky^Hc-BPpidI&m%5fIcjIYTfw?@}X=4j)n@clL8(Z0Gcv!mXJ8uo*`@nY(a{1 z(4sE)5Y{Jb;2zwYrv9qI_4^yV8a#dVF!ZT*`G6mR3V95~s4dWkT&s`J;Wo!shOSlQ_CkNxIoTw?*AD}|dhNCo$fRXF-|S4!3O zBcrh;oT8EmfAyEcs0QxHxEo32j|Hogsr?1}_ zfOmycOgz$~F6QxzwWaTmovlM2j;BNO$ws4e?Y@s3EVG4J0u0Qym??cHa!-ylI>~uV zs84d`cKyDU2Ghc+&()1r00e243f9{i&ZIw|Mm~dgAJP3p4DNg|7Tndu%-4I}rr+*J z@5Plt@XjK@#Pap<>h&KCw&ytncV#Zg4&XuNT^d1h_wz$9oQ~ckG>Lt%lOBLK^c=Lvm%0>8N*} zBCmHa`xk#xE@Gkj|7mD8&`@t9bZb+Q-nwY>aWdq54u?!RU-JO-uQ~lz=(NmqLdBsP zG^T@$G0U<%Lpjyw6G_+i=aVLiDG8;qJ;i`b+PP>BekZ3l?O zVLn=whxD?mz-1^cHbu;wsku^2W%&;=$)nKQ=5F;k^z2UsiH^7WBn6NES|y4kdJfx9 zg4R&`c94Po*cmBAdjr<5O6Dg&fP@wVKlVIvHy`eUELOTbZ3F@4S`mi6ni{qjzdNHW z!1$BTJoY>Tr(Iv0q-@zR)+S8h_3o#B3R~0Hd?Ecn{)gZ*Kyvo!y+Dr4H>`$9HDbxs+){JFsoDhb-rX+EaH zF=K1p5U<)4mpDHOWOp(c?*OyopT)9 z-yt7m11&#Iak@E1<65ZNBk_u*ik{d}d9B^B(&pqURHkj2;|EZsl8AQIS4>r>Kvpn8 zLN+O;!Opg(hoPMswCRDiXP~X^llA&RMVJ!QCvyKWS_ZLPtlHxO@XRj64z%T5LWKO@ z%&6eQ&!B)7?q|yH$Oyo^HKD^3d@Wst4O8GCM+A4a3{-00Tf3-<1h89vM=8)FIoQ}O z%xw)XFZiz;IYsvIv+-}*yiDo$+q#E)Cws=SRT2fF}+%PuRuV(Z^>D%E^ZpTS`JJIg6@qtHjML?WxUo5FrTfnm$kCwmFKEX-1M zdWWyc+2+>AY?wjPH@mLfo4B;3(2iSmorspg0iDy}p7TGkB^tON+cspSMsHG2Xloy|@%dcgIpg-bA#3-iT+@II>yAL?fy>a=F_hrcm&R6DyTES)s;5oIHvua{6?UsD znKlg?w%}Qbh|aP?wSI=Y`bHOatfX6qNFC-JK;PO7{uct_D&0gnwz%}P)wim3uHdmM z)qq4vwraFJ)}A1YjgmP?bc)?KT-Rs0w$J->UDxOJdSdmoDm7a&z?u}- z_q1IG6k8=Uqs3o9UdmFysT;8OKHfRW;q8v(lPtk=a@Jc+uOb zc&Yf6ipwJg0)MAsR$td`PQWg@KqTe5}z{1$Ek{-+wVO z3(~lGaIH3Vt>gTpQIY22OJky+^}kL=mN?j);=4VDjIHhRExF%4`?O@6%jx(vcc)!i z$e*xPtpXS8APW{8B2V~D+ssB!1h1B8tmhkXkLnh14S_O>s2$@65-e_3Qkh{acwuro z;pi?yis{zTg^Psl3q65j(PzO{747x$L-}DYCva^U#$v#{=YAi%?^nX4RK#fZUwU6p z)jbfq^IR#spM*)ytJ{O@!?+8sT6?I-iNtajcCvEr@3_-x{Ivw4vqh7CO z*M`3IEM46e=IBJaYoA#>P+jv@AOT8z8m=urY^?Kb^vkkeZF;g|tv!#PrhKs^Ho=0t-j647LjY~8mh;q1$TmmhG>*R5YZRnj#k?&((XM0ur0 z+WLHCn*ZD>ST+G?DEx%eu~kw3{@StlOB^6scyX=UL)O0$KHxvg?FfPiyU)ga{(pim zX=-H4)@ZCePhNlJ5Yve{#m|J7_d2t#)?YbZU;G7@x0Y z``Yhi9S}#T>=0<5qr{9xvxJ&kWRfmMJ{%mBhGbpOc!`J?;IDbd-eZKRM*2J$9!vgr zMxm0SYs~!AG(KKmVLr9OfegDy0;-K}zBYa!F^?>_Z9-(X4zSY6dhdj@R`=o;X3y_t3V$SW6)@W1~|OrJSOt|&cd zFC!JC_zLJzv86#iE1rcNamL{Z>6tz(lTOBQ))S-XT4|0GVlNb5AXQxKIZlsxm0d&6W<6dsgxs}2OI0NlXC@X0pq>W z?OPPVBkX_TexF*WRm}0f!K>?h*Zs9FJC$82p232eaxR2dHY#)93FhERuT!%OSXrTm zC$CC)!N>G&cHc(wJQ%44ldj++{pcmw+$x7&b!C@qpVNh_-K`viT_T-!uz}Js5;=t( zd~uNjv3fIz+5vYBUs-KtdU|}(J19kf5}zXRHmcjE8^GtsvVj@Xq?3=`wm$PD#QK)$mi4o3d3sb#vV)da40!Ssy+Q9gkm)f}U+i`1PczEl z9FfjFszz(Y*00?+I8Z>O>)iFYlz2|Eet1ILJGLeyI4e*o&(jT|GpmO_hHtvNGiVAa zg+hY0T;t$Oe;Gz28-vUI|BQMW>%B|GOpC-K6+L6O{*nuGH|jnPZbwLF?8z1fD5FP( z*Nn`Wn|x^U*NJ$_OA@Z1K9YVZv_j7xizqzczrPFaLBC`QF8i?s4*7-HH_l0f;7#eX zS7%}bYn6bakQ&}mI9%+d8F&uqxke3>7MtyY<9tugNa%uUK%0hdJ1QGNUt!Y$ToV-uy@>*daff8$ zBN9<85ivZi)OCga7>ELM$Kvmrk!lc9X!6BdOGeC_%SBLai^ShXLPMZM=Y!M;hc?D$ z>XG;n_f>TsL>UKjc54H%;3mIvL4D2hi6wpNK@sp`8^VI|*9{7r&C@8w*95YOFq*Aa z2)qN`ZfZjDg!Ay<4P_m$wO!4U73b7r&3&d=_@n<8sD}Ml%uP z=p%~2AwVpM!h)W0c1r}U404py@F3Wr;SZSsIzj|8EFeQ0GGhOE=kAaWy4T8$Sb-!H zb}Z?uuJPAk+!g}{MVK>k>JOvgtI3R#N;ZI@rst3SD2_OMERX-^A~W0Y)(qUpi~hMt7c5)=rXM7fVV_NyE=1`ikcP{3a>EM;+xF2H99 z16BjQ_4J~xSQpSxqG) z2#^`#GJXkKi>l^ClLZS(aJ7XTfP4HLdg_)i^xF6A!3}P{5y0GxlYG3~^WNrR(J~Ke z=L0&xIGYZ@#nvIYjA#|N%_M%b5!QOig$UiG8q1^%hx_dJ&@Iu5Yk(JdkB^wP&Eu9l zn~z7mFK*BvY~$`7J*bf1G+yO*MGi4WG9P?Yjcy>0f^FTU1?!0vl1w^o0l7)V4WowQ zavhrnHXmK|Zc9`e+GmcT=p<&nEl!l)q$NMC$yPi67re3MFfpf7- zw-Hi#qkZSHwLqh}&{k)KTYuW4TiafirWymk<bvwHCi)d{sK(c(O}ncvV%WgeTI#5IWj5IhFmcv;TySNq9t; zrk><-p3Ip|c|5sZugi~xGQt@_aKPFZP-XBzgJhIm%2n@{FMDscdbUkjRP=O zPhK<-kX@@6ZAb>hP!3kn9PZN5r3_WTLaA0wfZ4I%N*GW`=4Cq6$Bt_1gSDCdL^O~l z#85pVECdUubDd8C3&(9p9bPB}K1|!8aJz5&Odfa9y)=?k)~a``c^oWV$sdnIr-3)6ag9vWm{HL<|d$#1nNzpQ|p-|7V#8 z=v+@(&6%EG{zY0b1j*E`wHM5{p5SGO0&=V5Y&su9u!JOlR}I1AwTvo|ZS0#J4%ERU zhv`8d4++o?DHBC|b2w}TXI`^@1D&A0$3yJU^|Helm~>+-({4yH#5aBIJ0JaRP&(UY= zQ8R;rb8*vfd{0v6dxi)!Q+#tAq`U}Hrf88w2a}FZ&x(bGYzNd>H`ht*C0dw3b9>x6K$ppjo0uKZ3g9;`i&O@);`RAIHACl{6O4ftp;Au z0F-mr1dLjo`1Pc`s@!Xy2T(w)Rs&@l6mxe!-Pya=^V5FnR&{PlBwqvNFG$U1PnPIl z0Njno-0vXOWaaIcwpqh$!a*1}w?uJ_SP@eS>+IB8x3x%O3V{N(mbW@E?YyxLk9-Z9 z1YXgQjM5NiuY9?|+t=F12+u-+!Umc*Mk&5c^6=W(%2o_xdVD|C-a!v4(-QTf?d^| zP8h)3U5}yQh==xBVWxaNE&cR2QsKZAI8f|s{|9>Y&QJYzc_FG&O#Q=E(m(dg;hj{V zAbiqRHzrn9OR978lJauKF_R?1Yt#w)J>%OKPEN|p;bnz6l_~PaG`w9u2(0BS@jh=q zu!l?CV(s)E)#`~Rz35VfvDbz*=Ul!Gkax?`_k-t*g>zG}GU-u#b6mR{|z z7lhlCnsiE8s2@hO-yfdEJGe$2I92YSQA9Q-=Xz9>5En2a$6FbHbj?fnSyagDPsXi3)Jx{Ac6~D|x2K=T?oHu|QP@aUtTS5dpbc+hoCOwQLe3lS z{k+fUjhnvC8LJvb{Kr{$`-@_T{RrSB#`K96Q;6wF96j>1#W+|U>5yC%AI>@Ge< zQ;Mmz%;kuDVI15lFB=OKNj=}aR$r`m0Dzx7!Kd1iedPy41Cw0G6Rh2kAv~q#Wz`$! zyeFnd9?b+6d3R=yJyluG>d*I?KG87;t*UL1t~Rh-)D8-em3q zr@0CUVY}`5S^mC1sy}T`W!Sbe=EVM$OJYVfmt_PR zen$>)PnK2&+Fu%{`<199tmn6ya0Px1ewIzl;aRh_@~w?|3tENh?&`UU-*49WDK@99 zp5!m984Dg9GuQg@N{g5Ia$_O0>~UU&M)i;4okN`e&%OP(1uPdfFcubj=~cs=^6a#u M2B!K&x=vUA2SR2TjQ{`u literal 0 HcmV?d00001 diff --git a/LibraryDBproject/LDBproj/RscImages/ReadersFrameCover.png b/LibraryDBproject/LDBproj/RscImages/ReadersFrameCover.png new file mode 100644 index 0000000000000000000000000000000000000000..a7a1068831ce8635ea8299d788ee9e68c7c84f58 GIT binary patch literal 90140 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�~8+D5ca# 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%0DfeoMIPT@;Yl`-lD4K%hvf{H!+ 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 D*Aa}# literal 0 HcmV?d00001 diff --git a/LibraryDBproject/LDBproj/RscImages/WorkFrameCover.png b/LibraryDBproject/LDBproj/RscImages/WorkFrameCover.png new file mode 100644 index 0000000000000000000000000000000000000000..73e6ea675c0b82c5a70d668ca22931f2a5c0086e GIT binary patch literal 131467 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 Date: Fri, 20 Dec 2024 23:05:27 +0400 Subject: [PATCH 2/4] 3(2/1). Queries done, tables filled + operations (+ | upd | -) arranged --- .../LDBproj/AdditionalForms/BookF.cs | 66 +++++- .../LDBproj/AdditionalForms/BookListF.cs | 82 +++---- .../LDBproj/AdditionalForms/CustomerF.cs | 28 ++- .../LDBproj/AdditionalForms/CustomerListF.cs | 11 +- .../LDBproj/AdditionalForms/EmployeeF.cs | 54 ++++- .../LDBproj/AdditionalForms/EmployeesF.cs | 10 +- .../AdditionalForms/OrderRegistrations.cs | 11 +- .../AdditionalForms/OrdersF.Designer.cs | 112 ++++++++++ .../LDBproj/AdditionalForms/OrdersF.cs | 83 ++++++++ .../LDBproj/AdditionalForms/OrdersF.resx | 120 +++++++++++ .../AdditionalForms/RegOrder.Designer.cs | 106 ++++++---- .../LDBproj/AdditionalForms/RegOrder.cs | 48 +++-- .../LDBproj/AdditionalForms/RegOrder.resx | 2 +- .../AdditionalForms/RegOrderF.Designer.cs | 200 ++++++++++++++++++ .../LDBproj/AdditionalForms/RegOrderF.cs | 66 ++++++ .../LDBproj/AdditionalForms/RegOrderF.resx | 126 +++++++++++ .../LDBproj/AdditionalForms/UpdateF.cs | 16 +- .../LDBproj/AdditionalForms/UpdatesListF.cs | 11 +- LibraryDBproject/LDBproj/Entities/Order.cs | 8 +- .../LDBproj/Entities/Registration.cs | 2 +- LibraryDBproject/LDBproj/LDBproject.csproj | 18 +- LibraryDBproject/LDBproj/Program.cs | 20 ++ .../LDBproj/Repositories/IConnectionString.cs | 6 + .../LDBproj/Repositories/IOrderRep.cs | 2 + .../Repositories/Implementations/BookR.cs | 90 +++++++- .../Implementations/ConnectionStrR.cs | 7 + .../Implementations/CustomerCardR.cs | 87 +++++++- .../Implementations/LibrarianR.cs | 84 +++++++- .../Repositories/Implementations/OrderR.cs | 153 +++++++++++++- .../Repositories/Implementations/UpdateR.cs | 70 +++++- 30 files changed, 1534 insertions(+), 165 deletions(-) create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/OrdersF.Designer.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/OrdersF.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/OrdersF.resx create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/RegOrderF.Designer.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/RegOrderF.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/RegOrderF.resx create mode 100644 LibraryDBproject/LDBproj/Repositories/IConnectionString.cs create mode 100644 LibraryDBproject/LDBproj/Repositories/Implementations/ConnectionStrR.cs diff --git a/LibraryDBproject/LDBproj/AdditionalForms/BookF.cs b/LibraryDBproject/LDBproj/AdditionalForms/BookF.cs index 355d389..c40236e 100644 --- a/LibraryDBproject/LDBproj/AdditionalForms/BookF.cs +++ b/LibraryDBproject/LDBproj/AdditionalForms/BookF.cs @@ -1,12 +1,26 @@ -namespace LDBproject.AdditionalForms; +using LDBproject.Entities.Enums; +using LDBproject.Entities; +using LDBproject.Repositories; + +namespace LDBproject.AdditionalForms; public partial class BookF : Form { + private readonly IBookRep _bookRepository; private int? _bookID; - public BookF() + public BookF(IBookRep bookR) { InitializeComponent(); + _bookRepository = bookR ?? throw new ArgumentNullException(nameof(bookR)); + + StatusCbox.DataSource = Enum.GetValues(typeof(BookStat)); + + // Populate the checkbox list with enum values as before + foreach (var elem in Enum.GetValues(typeof(Genres))) + { + GenresChBoxList.Items.Add(elem); + } } public int ID @@ -15,6 +29,37 @@ public partial class BookF : Form { try { + var book = _bookRepository.GetBookByID(value); + + if (book == null) + { + throw new InvalidDataException(nameof(book)); + } + + // Clear all checkboxes + for (int i = 0; i < GenresChBoxList.Items.Count; i++) + { + GenresChBoxList.SetItemChecked(i, false); + } + + // Check the checkboxes based on the book's GenreIDs + foreach (Genres genre in Enum.GetValues(typeof(Genres))) + { + if ((genre & book.GenreMask) != 0) + { + int index = GenresChBoxList.Items.IndexOf(genre); + if (index != -1) + { + GenresChBoxList.SetItemChecked(index, true); + } + } + } + + TitleTb.Text = book.Title; + AuthorTb.Text = book.Author; + YearNud.Value = book.PublishYear; + StatusCbox.SelectedItem = book.Status; + _bookID = value; } catch (Exception ex) @@ -38,11 +83,11 @@ public partial class BookF : Form if (_bookID.HasValue) { - + _bookRepository.UpdateBook(CreateBook(_bookID.Value)); } else { - + _bookRepository.AddBook(CreateBook(0)); } Close(); @@ -56,5 +101,16 @@ public partial class BookF : Form private void DiscardBtn_Click(object sender, EventArgs e) => Close(); - private object CreateBook(int id) { return null; } + private Book CreateBook(int id) + { + Genres selectedGenres = Genres.None; + foreach (var item in GenresChBoxList.CheckedItems) + { + if (item is Genres genre) + selectedGenres |= genre; + } + + return Book.AddBook(id, TitleTb.Text, AuthorTb.Text, + (int)YearNud.Value, selectedGenres, (BookStat)StatusCbox.SelectedItem!); + } } diff --git a/LibraryDBproject/LDBproj/AdditionalForms/BookListF.cs b/LibraryDBproject/LDBproj/AdditionalForms/BookListF.cs index a6d9f5f..9d1ca7e 100644 --- a/LibraryDBproject/LDBproj/AdditionalForms/BookListF.cs +++ b/LibraryDBproject/LDBproj/AdditionalForms/BookListF.cs @@ -1,14 +1,17 @@ -using Unity; +using LDBproject.Repositories; +using Unity; namespace LDBproject.AdditionalForms; public partial class BookListF : Form { private readonly IUnityContainer _container; + private readonly IBookRep _bookR; - public BookListF(IUnityContainer container) + public BookListF(IUnityContainer container, IBookRep bookR) { InitializeComponent(); + _bookR = bookR ?? throw new ArgumentNullException(nameof(bookR)); _container = container ?? throw new ArgumentNullException(nameof(container)); } @@ -37,43 +40,6 @@ public partial class BookListF : Form } } - private void DelBtn_Click(object sender, EventArgs e) - { - if (!GetIDFromRow(out var foundID)) - { - return; - } - - if (MessageBox.Show("Remove element?", "Deleting", MessageBoxButtons.YesNo) != DialogResult.Yes) - { - return; - } - - try - { - ReloadList(); - } - catch (Exception ex) - { - MessageBox.Show(ex.Message, "Book List Form [ Error while removing element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); - } - } - - private void ReloadList() { } - - private bool GetIDFromRow(out int id) - { - id = 0; - if (DataGV.SelectedRows.Count < 1) - { - MessageBox.Show("[ Error : Book doesn't exist ]", "", - MessageBoxButtons.OK, MessageBoxIcon.Error); - } - - id = Convert.ToInt32(DataGV.SelectedRows[0].Cells["BookID"].Value); - return true; - } - private void UpdBtn_Click(object sender, EventArgs e) { if (!GetIDFromRow(out var findID)) @@ -93,4 +59,42 @@ public partial class BookListF : Form MessageBox.Show(ex.Message, "Book List Form [ Error while updating element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); } } + + private void ReloadList() => DataGV.DataSource = _bookR.GetBookList(); + + private void DelBtn_Click(object sender, EventArgs e) + { + if (!GetIDFromRow(out var foundID)) + { + return; + } + + if (MessageBox.Show("Remove element?", "Deleting", MessageBoxButtons.YesNo) != DialogResult.Yes) + { + return; + } + + try + { + _bookR.DeleteBook(foundID); + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Book List Form [ Error while removing element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private bool GetIDFromRow(out int id) + { + id = 0; + if (DataGV.SelectedRows.Count < 1) + { + MessageBox.Show("[ Error : Book doesn't exist ]", "", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + + id = Convert.ToInt32(DataGV.SelectedRows[0].Cells["BookID"].Value); + return true; + } } diff --git a/LibraryDBproject/LDBproj/AdditionalForms/CustomerF.cs b/LibraryDBproject/LDBproj/AdditionalForms/CustomerF.cs index 80b2a3d..53f88d0 100644 --- a/LibraryDBproject/LDBproj/AdditionalForms/CustomerF.cs +++ b/LibraryDBproject/LDBproj/AdditionalForms/CustomerF.cs @@ -1,12 +1,17 @@ -namespace LDBproject.AdditionalForms; +using LDBproject.Entities; +using LDBproject.Repositories; + +namespace LDBproject.AdditionalForms; public partial class CustomerF : Form { + private readonly ICustomerCardsRep _customeRepository; private int? _custID; - public CustomerF() + public CustomerF(ICustomerCardsRep customeR) { InitializeComponent(); + _customeRepository = customeR ?? throw new ArgumentNullException(nameof(customeR)); } public int ID @@ -15,6 +20,16 @@ public partial class CustomerF : Form { try { + var reader = _customeRepository.GetCardByID(value); + + if (reader == null) + { + throw new InvalidDataException(nameof(reader)); + } + + FIOEnterTb.Text = reader.FIO; + BirthdayDTPicker.Value = reader.AgeBirthday; + _custID = value; } catch (Exception ex) @@ -37,11 +52,11 @@ public partial class CustomerF : Form if (_custID.HasValue) { - + _customeRepository.UpdateCard(CreateCustomer(_custID.Value)); } else { - + _customeRepository.AddCard(CreateCustomer(0)); } Close(); @@ -55,5 +70,8 @@ public partial class CustomerF : Form private void CancelBtn_Click(object sender, EventArgs e) => Close(); - private object CreateCustomer(int id) { return null; } + private CustomerCard CreateCustomer(int id) + { + return CustomerCard.AddCustomer(id, FIOEnterTb.Text, BirthdayDTPicker.Value); + } } diff --git a/LibraryDBproject/LDBproj/AdditionalForms/CustomerListF.cs b/LibraryDBproject/LDBproj/AdditionalForms/CustomerListF.cs index 3a8cf6c..2315f47 100644 --- a/LibraryDBproject/LDBproj/AdditionalForms/CustomerListF.cs +++ b/LibraryDBproject/LDBproj/AdditionalForms/CustomerListF.cs @@ -1,14 +1,17 @@ -using Unity; +using LDBproject.Repositories; +using Unity; namespace LDBproject.AdditionalForms; public partial class CustomerListF : Form { private readonly IUnityContainer _container; + private readonly ICustomerCardsRep _custR; - public CustomerListF(IUnityContainer container) + public CustomerListF(IUnityContainer container, ICustomerCardsRep customeR) { InitializeComponent(); + _custR = customeR ?? throw new ArgumentNullException(nameof(customeR)); _container = container ?? throw new ArgumentNullException(nameof(container)); } @@ -51,6 +54,7 @@ public partial class CustomerListF : Form try { + _custR.DeleteCard(foundID); ReloadList(); } catch (Exception ex) @@ -59,7 +63,8 @@ public partial class CustomerListF : Form } } - private void ReloadList() { } + private void ReloadList() => + DataGV.DataSource = _custR.GetCards(); private bool GetIDFromRow(out int id) { diff --git a/LibraryDBproject/LDBproj/AdditionalForms/EmployeeF.cs b/LibraryDBproject/LDBproj/AdditionalForms/EmployeeF.cs index d505054..15ea8cb 100644 --- a/LibraryDBproject/LDBproj/AdditionalForms/EmployeeF.cs +++ b/LibraryDBproject/LDBproj/AdditionalForms/EmployeeF.cs @@ -1,12 +1,22 @@ -namespace LDBproject.AdditionalForms; +using LDBproject.Entities.Enums; +using LDBproject.Entities; +using LDBproject.Repositories; + +namespace LDBproject.AdditionalForms; public partial class EmployeeF : Form { + private readonly ILibrarianRep _libRepository; private int? _librarianID; - public EmployeeF() + public EmployeeF(ILibrarianRep librarianR) { InitializeComponent(); + _libRepository = librarianR ?? throw new ArgumentNullException(nameof(librarianR)); + foreach (var elem in Enum.GetValues(typeof(Genres))) + { + GenresCheckedBL.Items.Add(elem); + } } public int ID @@ -15,6 +25,30 @@ public partial class EmployeeF : Form { try { + var librarian = _libRepository.GetCardByID(value); + if (librarian == null) + { + throw new InvalidDataException(nameof(librarian)); + } + + // Uncheck all genres in the checklist box + for (int i = 0; i < GenresCheckedBL.Items.Count; i++) + { + GenresCheckedBL.SetItemChecked(i, false); + } + // Check the genres that are in the bitmask + foreach (Genres genre in Enum.GetValues(typeof(Genres))) + { + if ((genre & librarian.GenreMask) != 0 && genre != Genres.None) + { + int index = GenresCheckedBL.Items.IndexOf(genre); + if (index != -1) + { + GenresCheckedBL.SetItemChecked(index, true); + } + } + } + FIOEnterTb.Text = librarian.FIO; _librarianID = value; } catch (Exception ex) @@ -37,11 +71,11 @@ public partial class EmployeeF : Form if (_librarianID.HasValue) { - + _libRepository.ChangeCardInfo(CreateWorker(_librarianID.Value)); } else { - + _libRepository.AddCard(CreateWorker(0)); } Close(); } @@ -54,6 +88,16 @@ public partial class EmployeeF : Form private void CancelBtn_Click(object sender, EventArgs e) => Close(); - private object CreateWorker(int id) { return null; } + private LibrarianCard CreateWorker(int id) + { + Genres selectedGenres = Genres.None; + foreach (var item in GenresCheckedBL.CheckedItems) + { + if (item is Genres genre) + selectedGenres |= genre; + } + + return LibrarianCard.AddWorker(id, FIOEnterTb.Text, selectedGenres); + } } diff --git a/LibraryDBproject/LDBproj/AdditionalForms/EmployeesF.cs b/LibraryDBproject/LDBproj/AdditionalForms/EmployeesF.cs index ea47543..19a1e97 100644 --- a/LibraryDBproject/LDBproj/AdditionalForms/EmployeesF.cs +++ b/LibraryDBproject/LDBproj/AdditionalForms/EmployeesF.cs @@ -1,14 +1,17 @@ -using Unity; +using LDBproject.Repositories; +using Unity; namespace LDBproject.AdditionalForms; public partial class EmployeesF : Form { private readonly IUnityContainer _container; + private readonly ILibrarianRep _libR; - public EmployeesF(IUnityContainer container) + public EmployeesF(IUnityContainer container, ILibrarianRep libR) { InitializeComponent(); + _libR = libR ?? throw new ArgumentNullException(nameof(libR)); _container = container ?? throw new ArgumentNullException(nameof(container)); } @@ -71,6 +74,7 @@ public partial class EmployeesF : Form try { + _libR.DeleteCard(foundID); ReloadList(); } catch (Exception ex) @@ -79,7 +83,7 @@ public partial class EmployeesF : Form } } - private void ReloadList() { } + private void ReloadList() => DataGV.DataSource = _libR.GetCards(); private bool GetiDFromRow(out int id) { diff --git a/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.cs b/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.cs index ad9fe83..dc808c6 100644 --- a/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.cs +++ b/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.cs @@ -1,14 +1,17 @@ -using Unity; +using LDBproject.Repositories; +using Unity; namespace LDBproject.AdditionalForms; public partial class OrderRegistrations : Form { private readonly IUnityContainer _container; + private readonly IOrderRep _regR; - public OrderRegistrations(IUnityContainer container) + public OrderRegistrations(IUnityContainer container, IOrderRep regR) { InitializeComponent(); + _regR = regR ?? throw new ArgumentNullException(nameof(regR)); _container = container ?? throw new ArgumentNullException(nameof(container)); } @@ -51,6 +54,7 @@ public partial class OrderRegistrations : Form try { + _regR.DeleteOrderinfo(foundID); ReloadList(); } catch (Exception ex) @@ -59,7 +63,8 @@ public partial class OrderRegistrations : Form } } - private void ReloadList() { } + private void ReloadList() => + DataGV.DataSource = _regR.GetOrdersInfo(); private bool GetIDFromRow(out int id) { diff --git a/LibraryDBproject/LDBproj/AdditionalForms/OrdersF.Designer.cs b/LibraryDBproject/LDBproj/AdditionalForms/OrdersF.Designer.cs new file mode 100644 index 0000000..dc0da81 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/OrdersF.Designer.cs @@ -0,0 +1,112 @@ +namespace LDBproject.AdditionalForms +{ + partial class OrdersF + { + /// + /// 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() + { + panel1 = new Panel(); + DelBtn = new Button(); + AddBtn = new Button(); + DataGV = new DataGridView(); + panel1.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)DataGV).BeginInit(); + SuspendLayout(); + // + // panel1 + // + panel1.BackColor = Color.Transparent; + panel1.Controls.Add(DelBtn); + panel1.Controls.Add(AddBtn); + panel1.Dock = DockStyle.Right; + panel1.Location = new Point(430, 0); + panel1.Name = "panel1"; + panel1.Size = new Size(246, 364); + panel1.TabIndex = 4; + // + // DelBtn + // + DelBtn.BackColor = Color.DarkSlateBlue; + DelBtn.BackgroundImage = Properties.Resources.DelImg; + DelBtn.BackgroundImageLayout = ImageLayout.Stretch; + DelBtn.ForeColor = Color.Transparent; + DelBtn.Location = new Point(129, 34); + DelBtn.Name = "DelBtn"; + DelBtn.Size = new Size(78, 71); + DelBtn.TabIndex = 6; + DelBtn.UseVisualStyleBackColor = false; + DelBtn.Click += DelBtn_Click; + // + // AddBtn + // + AddBtn.BackColor = Color.DarkSlateBlue; + AddBtn.BackgroundImage = Properties.Resources.AddImg; + AddBtn.BackgroundImageLayout = ImageLayout.Stretch; + AddBtn.ForeColor = Color.Transparent; + AddBtn.Location = new Point(24, 34); + AddBtn.Name = "AddBtn"; + AddBtn.Size = new Size(78, 71); + AddBtn.TabIndex = 4; + AddBtn.UseVisualStyleBackColor = false; + AddBtn.Click += AddBtn_Click; + // + // DataGV + // + DataGV.BackgroundColor = Color.DarkSlateBlue; + DataGV.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + DataGV.GridColor = Color.GreenYellow; + DataGV.Location = new Point(28, 86); + DataGV.Name = "DataGV"; + DataGV.RowHeadersWidth = 62; + DataGV.Size = new Size(357, 245); + DataGV.TabIndex = 5; + // + // OrderRegistrations + // + AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleMode = AutoScaleMode.Font; + BackgroundImage = Properties.Resources.RegistrationsFrameCover; + BackgroundImageLayout = ImageLayout.Stretch; + ClientSize = new Size(676, 364); + Controls.Add(DataGV); + Controls.Add(panel1); + DoubleBuffered = true; + Name = "OrderRegistrations"; + Text = "OrderRegistrations"; + Load += RegistrationsF_Load; + panel1.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)DataGV).EndInit(); + ResumeLayout(false); + } + + #endregion + + private Panel panel1; + private Button DelBtn; + private Button AddBtn; + private DataGridView DataGV; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/OrdersF.cs b/LibraryDBproject/LDBproj/AdditionalForms/OrdersF.cs new file mode 100644 index 0000000..df97440 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/OrdersF.cs @@ -0,0 +1,83 @@ +using LDBproject.Repositories; +using Unity; + +namespace LDBproject.AdditionalForms; + +public partial class OrdersF : Form +{ + private readonly IUnityContainer _container; + private readonly IOrderRep _regR; + + public OrdersF(IUnityContainer container, IOrderRep regR) + { + InitializeComponent(); + _regR = regR ?? throw new ArgumentNullException(nameof(regR)); + _container = container ?? throw new ArgumentNullException(nameof(container)); + } + + private void RegistrationsF_Load(object sender, EventArgs e) + { + try + { + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Error while saving ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void AddBtn_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Error while adding element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void DelBtn_Click(object sender, EventArgs e) + { + if (!GetIDFromRow(out var foundID)) + { + return; + } + + if (MessageBox.Show("Remove element?", "Deleting", MessageBoxButtons.YesNo) != DialogResult.Yes) + { + return; + } + + try + { + _regR.DeleteOrderinfo(foundID); + ReloadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Error while removing element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ReloadList() => + DataGV.DataSource = _regR.GetOrdersInfo(); + + private bool GetIDFromRow(out int id) + { + id = 0; + if (DataGV.SelectedRows.Count < 1) + { + MessageBox.Show("[ Error : element doesn't exist ]", "", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + + id = Convert.ToInt32(DataGV.SelectedRows[0].Cells["OrderID"].Value); + return true; + } +} + + diff --git a/LibraryDBproject/LDBproj/AdditionalForms/OrdersF.resx b/LibraryDBproject/LDBproj/AdditionalForms/OrdersF.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/OrdersF.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/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.Designer.cs b/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.Designer.cs index b24be4d..8e5b811 100644 --- a/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.Designer.cs +++ b/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.Designer.cs @@ -31,15 +31,15 @@ LibrarianCBox = new ComboBox(); LibLabel = new Label(); DateLabel = new Label(); - ReturnDTPicker = new DateTimePicker(); + BorrowDTPicker = new DateTimePicker(); groupBox1 = new GroupBox(); DataGV = new DataGridView(); - BookColumnCBox = new DataGridViewComboBoxColumn(); - AuthorColumn = new DataGridViewTextBoxColumn(); SaveBtn = new Button(); BackBtn = new Button(); ReaderLabel = new Label(); CardCBox = new ComboBox(); + BookColumnCBox = new DataGridViewComboBoxColumn(); + NoteColumn = new DataGridViewTextBoxColumn(); groupBox1.SuspendLayout(); ((System.ComponentModel.ISupportInitialize)DataGV).BeginInit(); SuspendLayout(); @@ -47,42 +47,48 @@ // LibrarianCBox // LibrarianCBox.FormattingEnabled = true; - LibrarianCBox.Location = new Point(119, 21); + LibrarianCBox.Location = new Point(155, 44); + LibrarianCBox.Margin = new Padding(4); LibrarianCBox.Name = "LibrarianCBox"; - LibrarianCBox.Size = new Size(182, 33); + LibrarianCBox.Size = new Size(235, 40); LibrarianCBox.TabIndex = 0; // // LibLabel // LibLabel.AutoSize = true; - LibLabel.Location = new Point(30, 24); + LibLabel.Location = new Point(39, 47); + LibLabel.Margin = new Padding(4, 0, 4, 0); LibLabel.Name = "LibLabel"; - LibLabel.Size = new Size(83, 25); + LibLabel.Size = new Size(110, 32); LibLabel.TabIndex = 1; LibLabel.Text = "Librarian:"; // // DateLabel // DateLabel.AutoSize = true; - DateLabel.Location = new Point(30, 128); + DateLabel.Location = new Point(39, 164); + DateLabel.Margin = new Padding(4, 0, 4, 0); DateLabel.Name = "DateLabel"; - DateLabel.Size = new Size(107, 25); + DateLabel.Size = new Size(148, 32); DateLabel.TabIndex = 2; - DateLabel.Text = "Return date:"; + DateLabel.Text = "Borrow date:"; // - // ReturnDTPicker + // BorrowDTPicker // - ReturnDTPicker.Location = new Point(37, 163); - ReturnDTPicker.Name = "ReturnDTPicker"; - ReturnDTPicker.Size = new Size(264, 31); - ReturnDTPicker.TabIndex = 3; + BorrowDTPicker.Location = new Point(48, 209); + BorrowDTPicker.Margin = new Padding(4); + BorrowDTPicker.Name = "BorrowDTPicker"; + BorrowDTPicker.Size = new Size(342, 39); + BorrowDTPicker.TabIndex = 3; // // groupBox1 // groupBox1.Controls.Add(DataGV); - groupBox1.Location = new Point(334, 24); + groupBox1.Location = new Point(434, 31); + groupBox1.Margin = new Padding(4); groupBox1.Name = "groupBox1"; - groupBox1.Size = new Size(423, 266); + groupBox1.Padding = new Padding(4); + groupBox1.Size = new Size(550, 340); groupBox1.TabIndex = 4; groupBox1.TabStop = false; groupBox1.Text = "BookListGBox"; @@ -90,32 +96,20 @@ // DataGV // DataGV.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; - DataGV.Columns.AddRange(new DataGridViewColumn[] { BookColumnCBox, AuthorColumn }); - DataGV.Location = new Point(6, 41); + DataGV.Columns.AddRange(new DataGridViewColumn[] { BookColumnCBox, NoteColumn }); + DataGV.Location = new Point(8, 52); + DataGV.Margin = new Padding(4); DataGV.Name = "DataGV"; DataGV.RowHeadersWidth = 62; - DataGV.Size = new Size(411, 206); + DataGV.Size = new Size(534, 264); DataGV.TabIndex = 0; // - // BookColumnCBox - // - BookColumnCBox.HeaderText = "Book's title"; - BookColumnCBox.MinimumWidth = 8; - BookColumnCBox.Name = "BookColumnCBox"; - BookColumnCBox.Width = 150; - // - // AuthorColumn - // - AuthorColumn.HeaderText = "Author"; - AuthorColumn.MinimumWidth = 8; - AuthorColumn.Name = "AuthorColumn"; - AuthorColumn.Width = 150; - // // SaveBtn // - SaveBtn.Location = new Point(37, 216); + SaveBtn.Location = new Point(48, 276); + SaveBtn.Margin = new Padding(4); SaveBtn.Name = "SaveBtn"; - SaveBtn.Size = new Size(264, 34); + SaveBtn.Size = new Size(343, 44); SaveBtn.TabIndex = 5; SaveBtn.Text = "Save and give out"; SaveBtn.UseVisualStyleBackColor = true; @@ -123,9 +117,10 @@ // // BackBtn // - BackBtn.Location = new Point(37, 256); + BackBtn.Location = new Point(48, 328); + BackBtn.Margin = new Padding(4); BackBtn.Name = "BackBtn"; - BackBtn.Size = new Size(264, 34); + BackBtn.Size = new Size(343, 44); BackBtn.TabIndex = 6; BackBtn.Text = "Go back"; BackBtn.UseVisualStyleBackColor = true; @@ -134,34 +129,51 @@ // ReaderLabel // ReaderLabel.AutoSize = true; - ReaderLabel.Location = new Point(30, 65); + ReaderLabel.Location = new Point(39, 90); + ReaderLabel.Margin = new Padding(4, 0, 4, 0); ReaderLabel.Name = "ReaderLabel"; - ReaderLabel.Size = new Size(66, 50); + ReaderLabel.Size = new Size(87, 64); ReaderLabel.TabIndex = 7; ReaderLabel.Text = "Reader\r\ncard:"; // // CardCBox // CardCBox.FormattingEnabled = true; - CardCBox.Location = new Point(119, 82); + CardCBox.Location = new Point(155, 105); + CardCBox.Margin = new Padding(4); CardCBox.Name = "CardCBox"; - CardCBox.Size = new Size(182, 33); + CardCBox.Size = new Size(235, 40); CardCBox.TabIndex = 8; // + // BookColumnCBox + // + BookColumnCBox.HeaderText = "Book's title"; + BookColumnCBox.MinimumWidth = 8; + BookColumnCBox.Name = "BookColumnCBox"; + BookColumnCBox.Width = 150; + // + // NoteColumn + // + NoteColumn.HeaderText = "Note"; + NoteColumn.MinimumWidth = 8; + NoteColumn.Name = "NoteColumn"; + NoteColumn.Width = 150; + // // RegOrder // - AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleDimensions = new SizeF(13F, 32F); AutoScaleMode = AutoScaleMode.Font; - ClientSize = new Size(785, 314); + ClientSize = new Size(1020, 402); Controls.Add(CardCBox); Controls.Add(ReaderLabel); Controls.Add(BackBtn); Controls.Add(SaveBtn); Controls.Add(groupBox1); - Controls.Add(ReturnDTPicker); + Controls.Add(BorrowDTPicker); Controls.Add(DateLabel); Controls.Add(LibLabel); Controls.Add(LibrarianCBox); + Margin = new Padding(4); Name = "RegOrder"; Text = "RegOrder"; groupBox1.ResumeLayout(false); @@ -175,7 +187,7 @@ private ComboBox LibrarianCBox; private Label LibLabel; private Label DateLabel; - private DateTimePicker ReturnDTPicker; + private DateTimePicker BorrowDTPicker; private GroupBox groupBox1; private DataGridView DataGV; private Button SaveBtn; @@ -183,6 +195,6 @@ private Label ReaderLabel; private ComboBox CardCBox; private DataGridViewComboBoxColumn BookColumnCBox; - private DataGridViewTextBoxColumn AuthorColumn; + private DataGridViewTextBoxColumn NoteColumn; } } \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.cs b/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.cs index a2915a7..9520304 100644 --- a/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.cs +++ b/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.cs @@ -1,17 +1,28 @@ -namespace LDBproject.AdditionalForms; +using LDBproject.Entities; +using LDBproject.Repositories; +using LDBproject.Repositories.Implementations; + +namespace LDBproject.AdditionalForms; public partial class RegOrder : Form { - public RegOrder() + private readonly IOrderRep _orderRepository; + + public RegOrder(IOrderRep orderRep, ICustomerCardsRep readerRep, + ILibrarianRep employeeRep, IBookRep bookRep) { InitializeComponent(); + _orderRepository = orderRep ?? throw new ArgumentNullException(nameof(orderRep)); + LibrarianCBox.DataSource = employeeRep.GetCards(); LibrarianCBox.DisplayMember = "FIO"; LibrarianCBox.ValueMember = "CardID"; + CardCBox.DataSource = readerRep.GetCards(); CardCBox.DisplayMember = "FIO"; CardCBox.ValueMember = "CardID"; + BookColumnCBox.DataSource = bookRep.GetBookList(); BookColumnCBox.DisplayMember = "Title"; BookColumnCBox.ValueMember = "BookID"; } @@ -24,27 +35,32 @@ public partial class RegOrder : Form { throw new Exception("[ Blanck space left ]"); } + _orderRepository.CreateOrder(Order.NewOrder(0, (int)CardCBox.SelectedValue, (int)LibrarianCBox.SelectedValue, + CreateBookListFromDG(), BorrowDTPicker.Value)); Close(); } catch (Exception ex) { - MessageBox.Show(ex.Message, "[ Saving error ]", MessageBoxButtons.OK, MessageBoxIcon.Error); + MessageBox.Show(ex.Message, "Order Form [ Error while saving order ]", + MessageBoxButtons.OK, MessageBoxIcon.Error); } } + private List CreateBookListFromDG() + { + List registrations = new List(); + foreach (DataGridViewRow row in DataGV.Rows) + { + if (row.Cells["BookColumnCBox"].Value != null) + { + var bookId = (int)row.Cells["BookColumnCBox"].Value; + var notes = row.Cells["NoteColumn"].Value?.ToString(); + registrations.Add(Registration.OrderReg(0, bookId, notes)); + } + } + return registrations; + } + private void BackBtn_Click(object sender, EventArgs e) => Close(); - - private List CreateBookListFromDG() - { - var list = new List(); - foreach (DataGridViewRow row in DataGV.Rows) - { - if (row.Cells["BookColumn"].Value == null) - { - continue; - } - } - return list; - } } diff --git a/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.resx b/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.resx index ccd5dce..ef527f1 100644 --- a/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.resx +++ b/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.resx @@ -120,7 +120,7 @@ True - + True \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/RegOrderF.Designer.cs b/LibraryDBproject/LDBproj/AdditionalForms/RegOrderF.Designer.cs new file mode 100644 index 0000000..484a6f5 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/RegOrderF.Designer.cs @@ -0,0 +1,200 @@ +namespace LDBproject.AdditionalForms +{ + partial class RegOrderF + { + /// + /// 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() + { + LibrarianCBox = new ComboBox(); + LibLabel = new Label(); + DateLabel = new Label(); + BorrowDTPicker = new DateTimePicker(); + groupBox1 = new GroupBox(); + DataGV = new DataGridView(); + SaveBtn = new Button(); + BackBtn = new Button(); + ReaderLabel = new Label(); + CardCBox = new ComboBox(); + BookColumnCBox = new DataGridViewComboBoxColumn(); + NoteColumn = new DataGridViewTextBoxColumn(); + groupBox1.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)DataGV).BeginInit(); + SuspendLayout(); + // + // LibrarianCBox + // + LibrarianCBox.FormattingEnabled = true; + LibrarianCBox.Location = new Point(155, 44); + LibrarianCBox.Margin = new Padding(4); + LibrarianCBox.Name = "LibrarianCBox"; + LibrarianCBox.Size = new Size(235, 40); + LibrarianCBox.TabIndex = 0; + // + // LibLabel + // + LibLabel.AutoSize = true; + LibLabel.Location = new Point(39, 47); + LibLabel.Margin = new Padding(4, 0, 4, 0); + LibLabel.Name = "LibLabel"; + LibLabel.Size = new Size(110, 32); + LibLabel.TabIndex = 1; + LibLabel.Text = "Librarian:"; + // + // DateLabel + // + DateLabel.AutoSize = true; + DateLabel.Location = new Point(39, 164); + DateLabel.Margin = new Padding(4, 0, 4, 0); + DateLabel.Name = "DateLabel"; + DateLabel.Size = new Size(148, 32); + DateLabel.TabIndex = 2; + DateLabel.Text = "Borrow date:"; + // + // BorrowDTPicker + // + BorrowDTPicker.Location = new Point(48, 209); + BorrowDTPicker.Margin = new Padding(4); + BorrowDTPicker.Name = "BorrowDTPicker"; + BorrowDTPicker.Size = new Size(342, 39); + BorrowDTPicker.TabIndex = 3; + // + // groupBox1 + // + groupBox1.Controls.Add(DataGV); + groupBox1.Location = new Point(434, 31); + groupBox1.Margin = new Padding(4); + groupBox1.Name = "groupBox1"; + groupBox1.Padding = new Padding(4); + groupBox1.Size = new Size(550, 340); + groupBox1.TabIndex = 4; + groupBox1.TabStop = false; + groupBox1.Text = "BookListGBox"; + // + // DataGV + // + DataGV.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + DataGV.Columns.AddRange(new DataGridViewColumn[] { BookColumnCBox, NoteColumn }); + DataGV.Location = new Point(8, 52); + DataGV.Margin = new Padding(4); + DataGV.Name = "DataGV"; + DataGV.RowHeadersWidth = 62; + DataGV.Size = new Size(534, 264); + DataGV.TabIndex = 0; + // + // SaveBtn + // + SaveBtn.Location = new Point(48, 276); + SaveBtn.Margin = new Padding(4); + SaveBtn.Name = "SaveBtn"; + SaveBtn.Size = new Size(343, 44); + SaveBtn.TabIndex = 5; + SaveBtn.Text = "Save and give out"; + SaveBtn.UseVisualStyleBackColor = true; + SaveBtn.Click += SaveBtn_Click; + // + // BackBtn + // + BackBtn.Location = new Point(48, 328); + BackBtn.Margin = new Padding(4); + BackBtn.Name = "BackBtn"; + BackBtn.Size = new Size(343, 44); + BackBtn.TabIndex = 6; + BackBtn.Text = "Go back"; + BackBtn.UseVisualStyleBackColor = true; + BackBtn.Click += BackBtn_Click; + // + // ReaderLabel + // + ReaderLabel.AutoSize = true; + ReaderLabel.Location = new Point(39, 90); + ReaderLabel.Margin = new Padding(4, 0, 4, 0); + ReaderLabel.Name = "ReaderLabel"; + ReaderLabel.Size = new Size(87, 64); + ReaderLabel.TabIndex = 7; + ReaderLabel.Text = "Reader\r\ncard:"; + // + // CardCBox + // + CardCBox.FormattingEnabled = true; + CardCBox.Location = new Point(155, 105); + CardCBox.Margin = new Padding(4); + CardCBox.Name = "CardCBox"; + CardCBox.Size = new Size(235, 40); + CardCBox.TabIndex = 8; + // + // BookColumnCBox + // + BookColumnCBox.HeaderText = "Book's title"; + BookColumnCBox.MinimumWidth = 8; + BookColumnCBox.Name = "BookColumnCBox"; + BookColumnCBox.Width = 150; + // + // NoteColumn + // + NoteColumn.HeaderText = "Note"; + NoteColumn.MinimumWidth = 8; + NoteColumn.Name = "NoteColumn"; + NoteColumn.Width = 150; + // + // RegOrder + // + AutoScaleDimensions = new SizeF(13F, 32F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(1020, 402); + Controls.Add(CardCBox); + Controls.Add(ReaderLabel); + Controls.Add(BackBtn); + Controls.Add(SaveBtn); + Controls.Add(groupBox1); + Controls.Add(BorrowDTPicker); + Controls.Add(DateLabel); + Controls.Add(LibLabel); + Controls.Add(LibrarianCBox); + Margin = new Padding(4); + Name = "RegOrder"; + Text = "RegOrder"; + groupBox1.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)DataGV).EndInit(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private ComboBox LibrarianCBox; + private Label LibLabel; + private Label DateLabel; + private DateTimePicker BorrowDTPicker; + private GroupBox groupBox1; + private DataGridView DataGV; + private Button SaveBtn; + private Button BackBtn; + private Label ReaderLabel; + private ComboBox CardCBox; + private DataGridViewComboBoxColumn BookColumnCBox; + private DataGridViewTextBoxColumn NoteColumn; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/RegOrderF.cs b/LibraryDBproject/LDBproj/AdditionalForms/RegOrderF.cs new file mode 100644 index 0000000..a0bc9b5 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/RegOrderF.cs @@ -0,0 +1,66 @@ +using LDBproject.Entities; +using LDBproject.Repositories; +using LDBproject.Repositories.Implementations; + +namespace LDBproject.AdditionalForms; + +public partial class RegOrderF : Form +{ + private readonly IOrderRep _orderRepository; + + public RegOrderF(IOrderRep orderRep, ICustomerCardsRep readerRep, + ILibrarianRep employeeRep, IBookRep bookRep) + { + InitializeComponent(); + _orderRepository = orderRep ?? throw new ArgumentNullException(nameof(orderRep)); + + LibrarianCBox.DataSource = employeeRep.GetCards(); + LibrarianCBox.DisplayMember = "FIO"; + LibrarianCBox.ValueMember = "CardID"; + + CardCBox.DataSource = readerRep.GetCards(); + CardCBox.DisplayMember = "FIO"; + CardCBox.ValueMember = "CardID"; + + BookColumnCBox.DataSource = bookRep.GetBookList(); + BookColumnCBox.DisplayMember = "Title"; + BookColumnCBox.ValueMember = "BookID"; + } + + private void SaveBtn_Click(object sender, EventArgs e) + { + try + { + if (DataGV.RowCount < 1 || LibrarianCBox.SelectedIndex < 0) + { + throw new Exception("[ Blanck space left ]"); + } + _orderRepository.CreateOrder(Order.NewOrder(0, (int)CardCBox.SelectedValue, (int)LibrarianCBox.SelectedValue, + CreateBookListFromDG(), BorrowDTPicker.Value)); + + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Order Form [ Error while saving order ]", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private List CreateBookListFromDG() + { + List registrations = new List(); + foreach (DataGridViewRow row in DataGV.Rows) + { + if (row.Cells["BookColumnCBox"].Value != null) + { + var bookId = (int)row.Cells["BookColumnCBox"].Value; + var notes = row.Cells["NoteColumn"].Value?.ToString(); + registrations.Add(Registration.OrderReg(0, bookId, notes)); + } + } + return registrations; + } + + private void BackBtn_Click(object sender, EventArgs e) => Close(); +} diff --git a/LibraryDBproject/LDBproj/AdditionalForms/RegOrderF.resx b/LibraryDBproject/LDBproj/AdditionalForms/RegOrderF.resx new file mode 100644 index 0000000..ef527f1 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/RegOrderF.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/LibraryDBproject/LDBproj/AdditionalForms/UpdateF.cs b/LibraryDBproject/LDBproj/AdditionalForms/UpdateF.cs index 42d289d..71fe140 100644 --- a/LibraryDBproject/LDBproj/AdditionalForms/UpdateF.cs +++ b/LibraryDBproject/LDBproj/AdditionalForms/UpdateF.cs @@ -1,14 +1,21 @@ -namespace LDBproject.AdditionalForms; +using LDBproject.Entities; +using LDBproject.Repositories; + +namespace LDBproject.AdditionalForms; public partial class UpdateF : Form { - public UpdateF() + private readonly IUpdateRep _updRep; + + public UpdateF(IUpdateRep updRep, ILibrarianRep libRep, ICustomerCardsRep customersRep) { InitializeComponent(); + _updRep = updRep ?? throw new ArgumentNullException(nameof(updRep)); + LibrarianCBox.DataSource = libRep.GetCards(); LibrarianCBox.DisplayMember = "FIO"; LibrarianCBox.ValueMember = "CardID"; - + CardCBox.DataSource = customersRep.GetCards(); CardCBox.DisplayMember = "FIO"; CardCBox.DisplayMember = "CardID"; CardCBox.ValueMember = "CardID"; @@ -22,7 +29,8 @@ public partial class UpdateF : Form { throw new Exception("[ Blanck space left ]"); } - + _updRep.AddUpdate(UpdateC.CustomerUpd(CardCBox.SelectedIndex, LibrarianCBox.SelectedIndex, + UpdDTPicker.Value, NextUpdDTPicker.Value, NoteTb.Text)); Close(); } catch (Exception ex) diff --git a/LibraryDBproject/LDBproj/AdditionalForms/UpdatesListF.cs b/LibraryDBproject/LDBproj/AdditionalForms/UpdatesListF.cs index 3ed4f3d..6659cde 100644 --- a/LibraryDBproject/LDBproj/AdditionalForms/UpdatesListF.cs +++ b/LibraryDBproject/LDBproj/AdditionalForms/UpdatesListF.cs @@ -1,14 +1,17 @@ -using Unity; +using LDBproject.Repositories; +using Unity; namespace LDBproject.AdditionalForms; public partial class UpdatesListF : Form { private readonly IUnityContainer _container; + private readonly IUpdateRep _updR; - public UpdatesListF(IUnityContainer container) + public UpdatesListF(IUnityContainer container, IUpdateRep updR) { InitializeComponent(); + _updR = updR ?? throw new ArgumentNullException(nameof(updR)); _container = container ?? throw new ArgumentNullException(nameof(container)); } @@ -51,6 +54,7 @@ public partial class UpdatesListF : Form try { + _updR.RemoveUpd(foundID); ReloadList(); } catch (Exception ex) @@ -59,7 +63,8 @@ public partial class UpdatesListF : Form } } - private void ReloadList() { } + private void ReloadList() => + DataGV.DataSource = _updR.GetUpdateList(); private bool GetIDFromRow(out int id) { diff --git a/LibraryDBproject/LDBproj/Entities/Order.cs b/LibraryDBproject/LDBproj/Entities/Order.cs index 6f67ebc..0c25bdd 100644 --- a/LibraryDBproject/LDBproj/Entities/Order.cs +++ b/LibraryDBproject/LDBproj/Entities/Order.cs @@ -6,11 +6,11 @@ public class Order public int CardID { get; private set; } - public DateTime BorrowDate { get; private set; } - public int LibrarianID { get; private set; } - public IEnumerable BookList { get; set; } = []; + public DateTime BorrowDate { get; private set; } + + public IEnumerable Registrations { get; set; } = []; public static Order NewOrder( int orderIndex, int ticketIndex, int librarian, IEnumerable list, DateTime borrow) @@ -20,7 +20,7 @@ public class Order OrderID = orderIndex, CardID = ticketIndex, LibrarianID = librarian, - BookList = list, + Registrations = list, BorrowDate = borrow }; } diff --git a/LibraryDBproject/LDBproj/Entities/Registration.cs b/LibraryDBproject/LDBproj/Entities/Registration.cs index 691d8e9..6890f15 100644 --- a/LibraryDBproject/LDBproj/Entities/Registration.cs +++ b/LibraryDBproject/LDBproj/Entities/Registration.cs @@ -11,7 +11,7 @@ public class Registration public string Note { get; private set; } public static Registration OrderReg( - int orderIndex, string notes, int bookIndex) + int orderIndex, int bookIndex, string notes) { return new Registration { diff --git a/LibraryDBproject/LDBproj/LDBproject.csproj b/LibraryDBproject/LDBproj/LDBproject.csproj index d013ccd..8508f1d 100644 --- a/LibraryDBproject/LDBproj/LDBproject.csproj +++ b/LibraryDBproject/LDBproj/LDBproject.csproj @@ -9,12 +9,20 @@ - - - - - + + + + + + + + + + + + + \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/Program.cs b/LibraryDBproject/LDBproj/Program.cs index 87ae676..6cf5bda 100644 --- a/LibraryDBproject/LDBproj/Program.cs +++ b/LibraryDBproject/LDBproj/Program.cs @@ -1,6 +1,10 @@ using LDBproject.Repositories.Implementations; using LDBproject.Repositories; using Unity; +using Unity.Microsoft.Logging; +using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.Logging; +using Serilog; namespace LDBproject @@ -20,13 +24,29 @@ namespace LDBproject { var container = new UnityContainer(); + container.AddExtension(new LoggingExtension(CreateLoggerFactory())); + container.RegisterType(); container.RegisterType(); container.RegisterType(); container.RegisterType(); container.RegisterType(); + container.RegisterType(); + return container; } + + private static LoggerFactory CreateLoggerFactory() + { + var loggerFactory = new LoggerFactory(); + loggerFactory.AddSerilog(new LoggerConfiguration() + .ReadFrom.Configuration(new ConfigurationBuilder() + .SetBasePath(Directory.GetCurrentDirectory()) + .AddJsonFile("appsettings.json") + .Build()) + .CreateLogger()); + return loggerFactory; + } } } \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/Repositories/IConnectionString.cs b/LibraryDBproject/LDBproj/Repositories/IConnectionString.cs new file mode 100644 index 0000000..7df12aa --- /dev/null +++ b/LibraryDBproject/LDBproj/Repositories/IConnectionString.cs @@ -0,0 +1,6 @@ +namespace LDBproject.Repositories; + +public interface IConnectionString +{ + public string ConnectionString { get; } +} diff --git a/LibraryDBproject/LDBproj/Repositories/IOrderRep.cs b/LibraryDBproject/LDBproj/Repositories/IOrderRep.cs index ee981f2..cde2b59 100644 --- a/LibraryDBproject/LDBproj/Repositories/IOrderRep.cs +++ b/LibraryDBproject/LDBproj/Repositories/IOrderRep.cs @@ -9,5 +9,7 @@ public interface IOrderRep void CreateOrder(Order order); + void UpdateOrderInfo(Order order); + void DeleteOrderinfo(int orderID); } diff --git a/LibraryDBproject/LDBproj/Repositories/Implementations/BookR.cs b/LibraryDBproject/LDBproj/Repositories/Implementations/BookR.cs index 3b3d81a..b831172 100644 --- a/LibraryDBproject/LDBproj/Repositories/Implementations/BookR.cs +++ b/LibraryDBproject/LDBproj/Repositories/Implementations/BookR.cs @@ -1,33 +1,115 @@ -using LDBproject.Entities; +using Microsoft.Extensions.Logging; +using LDBproject.Entities; +using Newtonsoft.Json; +using Npgsql; +using Dapper; namespace LDBproject.Repositories.Implementations; public class BookR : IBookRep { + private readonly IConnectionString _connectionString; + private readonly ILogger _logger; - public BookR() + public BookR(IConnectionString connectionString, ILogger logger) { + _connectionString = connectionString ?? throw new ArgumentNullException(nameof(connectionString)); + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); } public Book GetBookByID(int id) { - return null; + _logger.LogInformation("< Getting BOOK by id >"); + _logger.LogDebug("Object ID: {id}", id); + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + var querySelect = @"SELECT b.*, GenreMask FROM Books b WHERE b.BookID = @BookID"; + return connection.QueryFirstOrDefault(querySelect, new { BookID = id }); + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while reading :') BOOK by ID >"); + throw; + } } public void AddBook(Book book) { + _logger.LogInformation("< New BOOK Added >"); + _logger.LogDebug("Object: {json}", JsonConvert.SerializeObject(book)); + + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + connection.Open(); + var queryInsert = @"INSERT INTO Books (Title, Author, PublishYear, Status, GenreMask) + VALUES (@Title, @Author, @PublishYear, @Status, @GenreMask)"; + connection.Execute(queryInsert, book); + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while adding BOOK >"); + throw; + } } public void UpdateBook(Book book) { + _logger.LogInformation("< BOOK Info Updated >"); + _logger.LogDebug("Object: {json}", JsonConvert.SerializeObject(book)); + + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + connection.Open(); + var queryUpdate = @"UPDATE Books SET Title = @Title, Author = @Author, + PublishYear = @PublishYear, Status = @Status, GenreMask = @GenreMask + WHERE BookID = @BookID"; + connection.Execute(queryUpdate, book); + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while updating BOOK >"); + throw; + } } public void DeleteBook(int id) { + _logger.LogInformation("< Removing BOOK >"); + _logger.LogDebug("Object ID: {id}", id); + + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + var queryDelete = @"DELETE FROM Books WHERE BookID = @BookID"; + connection.Execute(queryDelete, new { BookID = id }); + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while deleting BOOK >"); + throw; + } } public IEnumerable GetBookList() { - return []; + _logger.LogInformation("< Getting all BOOKS >"); + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + connection.Open(); + var querySelectAll = @"SELECT b.*, GenreMask FROM Books b"; + var books = connection.Query(querySelectAll); + + _logger.LogDebug("Aimed objects: {json}", JsonConvert.SerializeObject(books)); + return books; + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while getting BOOKS >"); + throw; + } } } diff --git a/LibraryDBproject/LDBproj/Repositories/Implementations/ConnectionStrR.cs b/LibraryDBproject/LDBproj/Repositories/Implementations/ConnectionStrR.cs new file mode 100644 index 0000000..936e8e2 --- /dev/null +++ b/LibraryDBproject/LDBproj/Repositories/Implementations/ConnectionStrR.cs @@ -0,0 +1,7 @@ +namespace LDBproject.Repositories.Implementations +{ + internal class ConnectionStrR : IConnectionString + { + public string ConnectionString => "Server=127.0.0.7;Port=5472;Database=libraryDB;Uid=Del8a;Pwd=del8almond;"; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/Repositories/Implementations/CustomerCardR.cs b/LibraryDBproject/LDBproj/Repositories/Implementations/CustomerCardR.cs index c2c17d5..9e27d0f 100644 --- a/LibraryDBproject/LDBproj/Repositories/Implementations/CustomerCardR.cs +++ b/LibraryDBproject/LDBproj/Repositories/Implementations/CustomerCardR.cs @@ -1,28 +1,109 @@ -using LDBproject.Entities; +using Microsoft.Extensions.Logging; +using LDBproject.Entities; +using Newtonsoft.Json; +using Npgsql; +using Dapper; + namespace LDBproject.Repositories.Implementations; public class CustomerCardR : ICustomerCardsRep { + private readonly IConnectionString _connectionString; + private readonly ILogger _logger; + + public CustomerCardR(IConnectionString connectionString, ILogger logger) + { + _connectionString = connectionString ?? throw new ArgumentNullException(nameof(connectionString)); + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + public CustomerCard GetCardByID(int id) { - return null; + _logger.LogInformation("< Getting CARD by id >"); + _logger.LogDebug("Object ID: {id}", id); + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + var querySelect = @"SELECT * FROM CustomerCards WHERE CardID = @CardID"; // Assumes you have a CardID column + return connection.QueryFirstOrDefault(querySelect, new { CardID = id }); + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while reading CARD by ID >"); + throw; + } } public void AddCard(CustomerCard card) { + _logger.LogInformation("< New (reader)CARD Added >"); + _logger.LogDebug("Object: {json}", JsonConvert.SerializeObject(card)); + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + connection.Open(); + var queryInsert = @"INSERT INTO CustomerCards (FIO, AgeBirthday) VALUES (@FIO, @AgeBirthday)"; + connection.Execute(queryInsert, card); + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while adding CARD >"); + throw; + } } public void UpdateCard(CustomerCard card) { + _logger.LogInformation("< CARD Info Updated >"); + _logger.LogDebug("Object: {json}", JsonConvert.SerializeObject(card)); + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + connection.Open(); + var queryUpdate = @"UPDATE CustomerCards SET FIO = @FIO, AgeBirthday = @AgeBirthday WHERE CardID = @CardID"; // Assumes you have a CardID column + connection.Execute(queryUpdate, card); + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while updating CARD >"); + throw; + } } public void DeleteCard(int id) { + _logger.LogInformation("< Removing CARD >"); + _logger.LogDebug("Object ID: {id}", id); + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + var queryDelete = @"DELETE FROM CustomerCards WHERE CardID = @CardID"; // Assumes you have a CardID column + connection.Execute(queryDelete, new { CardID = id }); + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while deleting CARD >"); + throw; + } } public IEnumerable GetCards() { - return []; + _logger.LogInformation("< Getting all CARDS >"); + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + connection.Open(); + var querySelectAll = "SELECT * FROM CustomerCards"; + var cards = connection.Query(querySelectAll); + _logger.LogDebug("Aimed objects: {json}", JsonConvert.SerializeObject(cards)); + return cards; + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while getting CARDS >"); + throw; + } } } \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/Repositories/Implementations/LibrarianR.cs b/LibraryDBproject/LDBproj/Repositories/Implementations/LibrarianR.cs index bb7c0de..f9ecb95 100644 --- a/LibraryDBproject/LDBproj/Repositories/Implementations/LibrarianR.cs +++ b/LibraryDBproject/LDBproj/Repositories/Implementations/LibrarianR.cs @@ -1,32 +1,108 @@ -using LDBproject.Entities; +using Microsoft.Extensions.Logging; +using LDBproject.Entities; +using Newtonsoft.Json; +using Npgsql; +using Dapper; namespace LDBproject.Repositories.Implementations; internal class LibrarianR : ILibrarianRep { - public LibrarianR() + private readonly IConnectionString _connectionString; + private readonly ILogger _logger; + + public LibrarianR(IConnectionString connectionString, ILogger logger) { + _connectionString = connectionString ?? throw new ArgumentNullException(nameof(connectionString)); + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); } public LibrarianCard GetCardByID(int id) { - return null; + _logger.LogInformation("< Getting EMPLOYEE by id >"); + _logger.LogDebug("Object ID: {id}", id); + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + var querySelect = @"SELECT * FROM LibrarianCards WHERE CardID = @CardID"; // Assumes you have a CardID column + return connection.QueryFirstOrDefault(querySelect, new { CardID = id }); + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while getting EMPLOYEE by ID >"); + throw; + } } public void AddCard(LibrarianCard card) { + _logger.LogInformation("< New EMPLOYEE Added >"); + _logger.LogDebug("Object: {json}", JsonConvert.SerializeObject(card)); + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + connection.Open(); + var queryInsert = @"INSERT INTO LibrarianCards (FIO, GenreMask) VALUES (@FIO, @GenreMask)"; + connection.Execute(queryInsert, card); + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while adding EMPLOYEE >"); + throw; + } } public void ChangeCardInfo(LibrarianCard card) { + _logger.LogInformation("< EMPLOYEE Info Updated >"); + _logger.LogDebug("Object: {json}", JsonConvert.SerializeObject(card)); + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + connection.Open(); + var queryUpdate = @"UPDATE LibrarianCards SET FIO = @FIO, GenreMask = @GenreMask WHERE CardID = @CardID"; // Assumes you have a CardID column + connection.Execute(queryUpdate, card); + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while updating EMPLOYEE info >"); + throw; + } } public void DeleteCard(int id) { + _logger.LogInformation("< Removing CARD >"); + _logger.LogDebug("Object ID: {id}", id); + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + var queryDelete = @"DELETE FROM LibrarianCards WHERE CardID = @CardID"; // Assumes you have a CardID column + connection.Execute(queryDelete, new { CardID = id }); + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while deleting EMPLOYEE >"); + throw; + } } public IEnumerable GetCards() { - return []; + _logger.LogInformation("< Getting all EMPLOYEE >"); + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + connection.Open(); + var querySelectAll = "SELECT * FROM LibrarianCards"; + var cards = connection.Query(querySelectAll); + _logger.LogDebug("Aimed objects: {json}", JsonConvert.SerializeObject(cards)); + return cards; + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while getting EMPLOYEE >"); + throw; + } } } diff --git a/LibraryDBproject/LDBproj/Repositories/Implementations/OrderR.cs b/LibraryDBproject/LDBproj/Repositories/Implementations/OrderR.cs index 7a2dd0a..f963b72 100644 --- a/LibraryDBproject/LDBproj/Repositories/Implementations/OrderR.cs +++ b/LibraryDBproject/LDBproj/Repositories/Implementations/OrderR.cs @@ -1,15 +1,156 @@ -using LDBproject.Entities; +using Microsoft.Extensions.Logging; +using LDBproject.Entities; +using Newtonsoft.Json; +using Npgsql; +using Dapper; +using System.Data.SqlClient; namespace LDBproject.Repositories.Implementations; public class OrderR : IOrderRep { - public void CreateOrder(Order order) {} + private readonly IConnectionString _connectionString; + private readonly ILogger _logger; - public void DeleteOrderinfo(int orderID) {} - - public IEnumerable GetOrdersInfo(int? librarianID = null, int? orderID = null, int? customerID = null) + public OrderR(IConnectionString connectionString, ILogger logger) { - return []; + _connectionString = connectionString; + _logger = logger; + } + + public void CreateOrder(Order order) + { + _logger.LogInformation("< Adding new ORDER > [!]"); + _logger.LogDebug("Object - {json}", JsonConvert.SerializeObject(order)); + + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + connection.Open(); + using var transaction = connection.BeginTransaction(); + + // 1. Insert the Order without RETURNING + var queryInsert = @"INSERT INTO Orders (CardID, LibrarianID, BorrowDate) VALUES (@CardID, @LibrarianID, @BorrowDate)"; + + connection.Execute(queryInsert, new + { + order.CardID, + order.LibrarianID, + order.BorrowDate + }, transaction); + + // 2. Get the last inserted OrderID + var queryGetLastInsertedId = "SELECT MAX(OrderID) FROM Orders"; + + int orderID = connection.QuerySingle(queryGetLastInsertedId, transaction: transaction); + + + // 3. Insert the Registrations associated with the order + var querySubInsert = @"INSERT INTO Registrations (OrderID, BookID, Note) VALUES (@OrderID, @BookID, @Note)"; + foreach (var elem in order.Registrations) + { + connection.Execute(querySubInsert, new { OrderID = orderID, elem.BookID, elem.Note }, transaction); + } + transaction.Commit(); + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while adding ORDER >"); + throw; + } + } + + public void UpdateOrderInfo(Order order) + { + _logger.LogInformation("< Updating order info >"); + _logger.LogDebug("Object - {json}", JsonConvert.SerializeObject(order)); + + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + using var transaction = connection.BeginTransaction(); + // 1. Update order + var queryUpdate = @" + UPDATE Orders SET + CardID = @CardID, + LibrarianID = @LibrarianID, + BorrowDate = @BorrowDate + WHERE OrderID = @OrderID"; + + connection.Execute(queryUpdate, new + { + order.CardID, + order.LibrarianID, + order.BorrowDate, + order.OrderID + }, transaction); + + //2. Update registrations: + var queryDeleteRegistrations = "DELETE FROM Registrations WHERE OrderID = @OrderID"; + connection.Execute(queryDeleteRegistrations, new { OrderID = order.OrderID }, transaction); + + var querySubInsert = @"INSERT INTO Registrations (OrderID, BookID, Note) VALUES (@OrderID, @BookID, @Note)"; + foreach (var elem in order.Registrations) + { + connection.Execute(querySubInsert, new { OrderID = order.OrderID, elem.BookID, elem.Note }, transaction); + } + + transaction.Commit(); + + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while updating order info >"); + throw; + } + } + + public void DeleteOrderinfo(int orderID) + { + _logger.LogInformation("< Deleting exact order >"); + _logger.LogDebug("Obj: {id}", orderID); + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + connection.Open(); + using var transaction = connection.BeginTransaction(); + + // 1. Delete registrations for the order + var queryDeleteRegistrations = @"DELETE FROM Registrations WHERE OrderID=@OrderID"; + connection.Execute(queryDeleteRegistrations, new { OrderID = orderID }, transaction); + // 2. Delete the order itself + var queryDel = @"DELETE FROM Orders WHERE OrderID=@OrderID"; + connection.Execute(queryDel, new { orderID }, transaction); + + transaction.Commit(); + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while deleting ORDER >"); + throw; + } + } + + // ----------------------------- [ REVIEWED (waits for further editing) ] ------------------------------- + + public IEnumerable GetOrdersInfo(int? orderID = null, int ? librarianID = null, int? customerID = null) + { + _logger.LogInformation("< Getting all ORDERS >"); + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + connection.Open(); + var querySelectAll = @"SELECT * FROM Orders"; + var orders = connection.Query(querySelectAll); + + _logger.LogDebug("Aimed objects: {json}", JsonConvert.SerializeObject(orders)); + + return orders; + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while reading ORDERS >"); + throw; + } } } diff --git a/LibraryDBproject/LDBproj/Repositories/Implementations/UpdateR.cs b/LibraryDBproject/LDBproj/Repositories/Implementations/UpdateR.cs index 59b60db..e13f4ec 100644 --- a/LibraryDBproject/LDBproj/Repositories/Implementations/UpdateR.cs +++ b/LibraryDBproject/LDBproj/Repositories/Implementations/UpdateR.cs @@ -1,28 +1,90 @@ -using LDBproject.Entities; +using Microsoft.Extensions.Logging; +using LDBproject.Entities; +using Newtonsoft.Json; +using Npgsql; +using Dapper; namespace LDBproject.Repositories.Implementations; public class UpdateR : IUpdateRep { - public UpdateR() + private readonly IConnectionString _connectionString; + private readonly ILogger _logger; + + public UpdateR(IConnectionString connectionString, ILogger logger) { + _connectionString = connectionString ?? throw new ArgumentNullException(nameof(connectionString)); + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); } public UpdateC GetUpdateByID(int id) { - return null; + _logger.LogInformation("< Getting UPDATE by id >"); + _logger.LogDebug("Object ID: {id}", id); + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + var querySelect = @"SELECT * FROM Updates WHERE ID = @ID"; + return connection.QueryFirstOrDefault(querySelect, new { ID = id }); + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while getting UPDATE by id >"); + throw; + } } public void AddUpdate(UpdateC update) { + _logger.LogInformation("< New card UPDATE added >"); + _logger.LogDebug("Object: {json}", JsonConvert.SerializeObject(update)); + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + var queryInsert = @"INSERT INTO Updates (CardID, LibrarianID, LastUpdate, UpdBoundary, Note) + VALUES (@CardID, @LibrarianID, @LastUpdate, @UpdBoundary, @Note)"; + connection.Execute(queryInsert, update); + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while adding card UPDATE >"); + throw; + } } public void RemoveUpd(int Id) { + _logger.LogInformation("< Deleting card UPDATE by id >"); + _logger.LogDebug("Object ID: {id}", Id); + + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + var queryDelete = @"DELETE FROM Updates WHERE ID = @ID"; + connection.Execute(queryDelete, new { ID = Id }); + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while deleting card UPDATE >"); + throw; + } } public IEnumerable GetUpdateList() { - return []; + _logger.LogInformation("< Getting all UPDATES >"); + try + { + using var connection = new NpgsqlConnection(_connectionString.ConnectionString); + var querySelectAll = @"SELECT * FROM Updates"; + var upds = connection.Query(querySelectAll); + _logger.LogDebug("Aimed objects: {json}", JsonConvert.SerializeObject(upds)); + return upds; + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while getting all UPDATES >"); + throw; + } } } -- 2.25.1 From df70bb6e56d8b6c3e75508d170f4482495bc7bfe Mon Sep 17 00:00:00 2001 From: DelphyAlmond Date: Sat, 21 Dec 2024 20:20:04 +0400 Subject: [PATCH 3/4] 4(3/1). Only Docx & Pdf reports done, Excel remains --- .../AdditionalForms/FullReportsF.Designer.cs | 104 +++++++ .../LDBproj/AdditionalForms/FullReportsF.cs | 49 +++ ...erRegistrations.resx => FullReportsF.resx} | 0 .../OrderRegistrations.Designer.cs | 112 ------- .../AdditionalForms/OrderRegistrations.cs | 83 ----- .../AdditionalForms/RegOrder.Designer.cs | 200 ------------ .../LDBproj/AdditionalForms/RegOrder.cs | 66 ---- .../AdditionalForms/UpdReportF.Designer.cs | 107 +++++++ .../LDBproj/AdditionalForms/UpdReportF.cs | 55 ++++ .../{RegOrder.resx => UpdReportF.resx} | 6 - .../LDBproj/DBScript/TextCommands.txt | 201 ------------ .../LDBproj/Entities/TemprOrderReg.cs | 20 ++ LibraryDBproject/LDBproj/LDBproject.csproj | 3 + LibraryDBproject/LDBproj/MainForm.Designer.cs | 36 ++- LibraryDBproject/LDBproj/MainForm.cs | 41 ++- .../LDBproj/Reports/ChartReport.cs | 56 ++++ LibraryDBproject/LDBproj/Reports/DocReport.cs | 75 +++++ .../LDBproj/Reports/ExcelBuilder.cs | 285 ++++++++++++++++++ .../LDBproj/Reports/PdfBuilder.cs | 88 ++++++ .../LDBproj/Reports/WordBuilder.cs | 99 ++++++ .../Repositories/Implementations/OrderR.cs | 1 - 21 files changed, 1016 insertions(+), 671 deletions(-) create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/FullReportsF.Designer.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/FullReportsF.cs rename LibraryDBproject/LDBproj/AdditionalForms/{OrderRegistrations.resx => FullReportsF.resx} (100%) delete mode 100644 LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.Designer.cs delete mode 100644 LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.cs delete mode 100644 LibraryDBproject/LDBproj/AdditionalForms/RegOrder.Designer.cs delete mode 100644 LibraryDBproject/LDBproj/AdditionalForms/RegOrder.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/UpdReportF.Designer.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/UpdReportF.cs rename LibraryDBproject/LDBproj/AdditionalForms/{RegOrder.resx => UpdReportF.resx} (93%) delete mode 100644 LibraryDBproject/LDBproj/DBScript/TextCommands.txt create mode 100644 LibraryDBproject/LDBproj/Entities/TemprOrderReg.cs create mode 100644 LibraryDBproject/LDBproj/Reports/ChartReport.cs create mode 100644 LibraryDBproject/LDBproj/Reports/DocReport.cs create mode 100644 LibraryDBproject/LDBproj/Reports/ExcelBuilder.cs create mode 100644 LibraryDBproject/LDBproj/Reports/PdfBuilder.cs create mode 100644 LibraryDBproject/LDBproj/Reports/WordBuilder.cs diff --git a/LibraryDBproject/LDBproj/AdditionalForms/FullReportsF.Designer.cs b/LibraryDBproject/LDBproj/AdditionalForms/FullReportsF.Designer.cs new file mode 100644 index 0000000..f661676 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/FullReportsF.Designer.cs @@ -0,0 +1,104 @@ +namespace LDBproject.AdditionalForms +{ + partial class FullReportsF + { + /// + /// 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() + { + BookChBox = new CheckBox(); + EmployeeChBox = new CheckBox(); + ReadersChBox = new CheckBox(); + ConfBuildBtn = new Button(); + SuspendLayout(); + // + // BookChBox + // + BookChBox.AutoSize = true; + BookChBox.ForeColor = Color.GreenYellow; + BookChBox.Location = new Point(58, 36); + BookChBox.Name = "BookChBox"; + BookChBox.Size = new Size(87, 29); + BookChBox.TabIndex = 0; + BookChBox.Text = "Books"; + BookChBox.UseVisualStyleBackColor = true; + // + // EmployeeChBox + // + EmployeeChBox.AutoSize = true; + EmployeeChBox.ForeColor = Color.GreenYellow; + EmployeeChBox.Location = new Point(239, 36); + EmployeeChBox.Name = "EmployeeChBox"; + EmployeeChBox.Size = new Size(113, 29); + EmployeeChBox.TabIndex = 1; + EmployeeChBox.Text = "Librarians"; + EmployeeChBox.UseVisualStyleBackColor = true; + // + // ReadersChBox + // + ReadersChBox.AutoSize = true; + ReadersChBox.ForeColor = Color.GreenYellow; + ReadersChBox.Location = new Point(455, 36); + ReadersChBox.Name = "ReadersChBox"; + ReadersChBox.Size = new Size(100, 29); + ReadersChBox.TabIndex = 2; + ReadersChBox.Text = "Readers"; + ReadersChBox.UseVisualStyleBackColor = true; + // + // ConfBuildBtn + // + ConfBuildBtn.ForeColor = Color.DarkSlateBlue; + ConfBuildBtn.Location = new Point(58, 86); + ConfBuildBtn.Name = "ConfBuildBtn"; + ConfBuildBtn.Size = new Size(497, 34); + ConfBuildBtn.TabIndex = 3; + ConfBuildBtn.Text = "Make report"; + ConfBuildBtn.UseVisualStyleBackColor = true; + ConfBuildBtn.Click += ConfBuildBtn_Click; + // + // ReportF + // + AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleMode = AutoScaleMode.Font; + BackColor = Color.DarkSlateBlue; + ClientSize = new Size(610, 158); + Controls.Add(ConfBuildBtn); + Controls.Add(ReadersChBox); + Controls.Add(EmployeeChBox); + Controls.Add(BookChBox); + Name = "ReportF"; + Text = "ReportF"; + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private CheckBox BookChBox; + private CheckBox EmployeeChBox; + private CheckBox ReadersChBox; + private Button ConfBuildBtn; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/FullReportsF.cs b/LibraryDBproject/LDBproj/AdditionalForms/FullReportsF.cs new file mode 100644 index 0000000..38ca6fe --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/FullReportsF.cs @@ -0,0 +1,49 @@ +using LDBproject.Reports; +using Unity; +namespace LDBproject.AdditionalForms; + +public partial class FullReportsF : Form +{ + + private readonly IUnityContainer _container; + + public FullReportsF(IUnityContainer container) + { + InitializeComponent(); + _container = container ?? throw new ArgumentNullException(nameof(container)); + } + + private void ConfBuildBtn_Click(object sender, EventArgs e) + { + try + { + if (!BookChBox.Checked && !EmployeeChBox.Checked && !ReadersChBox.Checked) + { + throw new Exception("There are no options chosen [!]"); + } + + var sfd = new SaveFileDialog() + { + Filter = "Docx Files | *.docx" + }; + + if (sfd.ShowDialog() != DialogResult.OK) + { + throw new Exception("No file chosen [!]"); + } + + if (_container.Resolve().CreateDoc(sfd.FileName, BookChBox.Checked, EmployeeChBox.Checked, ReadersChBox.Checked)) + { + MessageBox.Show("The document was formed : Report done", "Process result", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + else + { + MessageBox.Show("< ERROR : see logs >", "Document creation", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "< ERROR : while creating report >", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } +} diff --git a/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.resx b/LibraryDBproject/LDBproj/AdditionalForms/FullReportsF.resx similarity index 100% rename from LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.resx rename to LibraryDBproject/LDBproj/AdditionalForms/FullReportsF.resx diff --git a/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.Designer.cs b/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.Designer.cs deleted file mode 100644 index 1463d2f..0000000 --- a/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.Designer.cs +++ /dev/null @@ -1,112 +0,0 @@ -namespace LDBproject.AdditionalForms -{ - partial class OrderRegistrations - { - /// - /// 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() - { - panel1 = new Panel(); - DelBtn = new Button(); - AddBtn = new Button(); - DataGV = new DataGridView(); - panel1.SuspendLayout(); - ((System.ComponentModel.ISupportInitialize)DataGV).BeginInit(); - SuspendLayout(); - // - // panel1 - // - panel1.BackColor = Color.Transparent; - panel1.Controls.Add(DelBtn); - panel1.Controls.Add(AddBtn); - panel1.Dock = DockStyle.Right; - panel1.Location = new Point(430, 0); - panel1.Name = "panel1"; - panel1.Size = new Size(246, 364); - panel1.TabIndex = 4; - // - // DelBtn - // - DelBtn.BackColor = Color.DarkSlateBlue; - DelBtn.BackgroundImage = Properties.Resources.DelImg; - DelBtn.BackgroundImageLayout = ImageLayout.Stretch; - DelBtn.ForeColor = Color.Transparent; - DelBtn.Location = new Point(129, 34); - DelBtn.Name = "DelBtn"; - DelBtn.Size = new Size(78, 71); - DelBtn.TabIndex = 6; - DelBtn.UseVisualStyleBackColor = false; - DelBtn.Click += DelBtn_Click; - // - // AddBtn - // - AddBtn.BackColor = Color.DarkSlateBlue; - AddBtn.BackgroundImage = Properties.Resources.AddImg; - AddBtn.BackgroundImageLayout = ImageLayout.Stretch; - AddBtn.ForeColor = Color.Transparent; - AddBtn.Location = new Point(24, 34); - AddBtn.Name = "AddBtn"; - AddBtn.Size = new Size(78, 71); - AddBtn.TabIndex = 4; - AddBtn.UseVisualStyleBackColor = false; - AddBtn.Click += AddBtn_Click; - // - // DataGV - // - DataGV.BackgroundColor = Color.DarkSlateBlue; - DataGV.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; - DataGV.GridColor = Color.GreenYellow; - DataGV.Location = new Point(28, 86); - DataGV.Name = "DataGV"; - DataGV.RowHeadersWidth = 62; - DataGV.Size = new Size(357, 245); - DataGV.TabIndex = 5; - // - // OrderRegistrations - // - AutoScaleDimensions = new SizeF(10F, 25F); - AutoScaleMode = AutoScaleMode.Font; - BackgroundImage = Properties.Resources.RegistrationsFrameCover; - BackgroundImageLayout = ImageLayout.Stretch; - ClientSize = new Size(676, 364); - Controls.Add(DataGV); - Controls.Add(panel1); - DoubleBuffered = true; - Name = "OrderRegistrations"; - Text = "OrderRegistrations"; - Load += RegistrationsF_Load; - panel1.ResumeLayout(false); - ((System.ComponentModel.ISupportInitialize)DataGV).EndInit(); - ResumeLayout(false); - } - - #endregion - - private Panel panel1; - private Button DelBtn; - private Button AddBtn; - private DataGridView DataGV; - } -} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.cs b/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.cs deleted file mode 100644 index dc808c6..0000000 --- a/LibraryDBproject/LDBproj/AdditionalForms/OrderRegistrations.cs +++ /dev/null @@ -1,83 +0,0 @@ -using LDBproject.Repositories; -using Unity; - -namespace LDBproject.AdditionalForms; - -public partial class OrderRegistrations : Form -{ - private readonly IUnityContainer _container; - private readonly IOrderRep _regR; - - public OrderRegistrations(IUnityContainer container, IOrderRep regR) - { - InitializeComponent(); - _regR = regR ?? throw new ArgumentNullException(nameof(regR)); - _container = container ?? throw new ArgumentNullException(nameof(container)); - } - - private void RegistrationsF_Load(object sender, EventArgs e) - { - try - { - ReloadList(); - } - catch (Exception ex) - { - MessageBox.Show(ex.Message, "[ Error while saving ]", MessageBoxButtons.OK, MessageBoxIcon.Error); - } - } - - private void AddBtn_Click(object sender, EventArgs e) - { - try - { - _container.Resolve().ShowDialog(); - ReloadList(); - } - catch (Exception ex) - { - MessageBox.Show(ex.Message, "[ Error while adding element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); - } - } - - private void DelBtn_Click(object sender, EventArgs e) - { - if (!GetIDFromRow(out var foundID)) - { - return; - } - - if (MessageBox.Show("Remove element?", "Deleting", MessageBoxButtons.YesNo) != DialogResult.Yes) - { - return; - } - - try - { - _regR.DeleteOrderinfo(foundID); - ReloadList(); - } - catch (Exception ex) - { - MessageBox.Show(ex.Message, "[ Error while removing element ]", MessageBoxButtons.OK, MessageBoxIcon.Error); - } - } - - private void ReloadList() => - DataGV.DataSource = _regR.GetOrdersInfo(); - - private bool GetIDFromRow(out int id) - { - id = 0; - if (DataGV.SelectedRows.Count < 1) - { - MessageBox.Show("[ Error : element doesn't exist ]", "", - MessageBoxButtons.OK, MessageBoxIcon.Error); - } - - id = Convert.ToInt32(DataGV.SelectedRows[0].Cells["OrderID"].Value); - return true; - } -} - - diff --git a/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.Designer.cs b/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.Designer.cs deleted file mode 100644 index 8e5b811..0000000 --- a/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.Designer.cs +++ /dev/null @@ -1,200 +0,0 @@ -namespace LDBproject.AdditionalForms -{ - partial class RegOrder - { - /// - /// 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() - { - LibrarianCBox = new ComboBox(); - LibLabel = new Label(); - DateLabel = new Label(); - BorrowDTPicker = new DateTimePicker(); - groupBox1 = new GroupBox(); - DataGV = new DataGridView(); - SaveBtn = new Button(); - BackBtn = new Button(); - ReaderLabel = new Label(); - CardCBox = new ComboBox(); - BookColumnCBox = new DataGridViewComboBoxColumn(); - NoteColumn = new DataGridViewTextBoxColumn(); - groupBox1.SuspendLayout(); - ((System.ComponentModel.ISupportInitialize)DataGV).BeginInit(); - SuspendLayout(); - // - // LibrarianCBox - // - LibrarianCBox.FormattingEnabled = true; - LibrarianCBox.Location = new Point(155, 44); - LibrarianCBox.Margin = new Padding(4); - LibrarianCBox.Name = "LibrarianCBox"; - LibrarianCBox.Size = new Size(235, 40); - LibrarianCBox.TabIndex = 0; - // - // LibLabel - // - LibLabel.AutoSize = true; - LibLabel.Location = new Point(39, 47); - LibLabel.Margin = new Padding(4, 0, 4, 0); - LibLabel.Name = "LibLabel"; - LibLabel.Size = new Size(110, 32); - LibLabel.TabIndex = 1; - LibLabel.Text = "Librarian:"; - // - // DateLabel - // - DateLabel.AutoSize = true; - DateLabel.Location = new Point(39, 164); - DateLabel.Margin = new Padding(4, 0, 4, 0); - DateLabel.Name = "DateLabel"; - DateLabel.Size = new Size(148, 32); - DateLabel.TabIndex = 2; - DateLabel.Text = "Borrow date:"; - // - // BorrowDTPicker - // - BorrowDTPicker.Location = new Point(48, 209); - BorrowDTPicker.Margin = new Padding(4); - BorrowDTPicker.Name = "BorrowDTPicker"; - BorrowDTPicker.Size = new Size(342, 39); - BorrowDTPicker.TabIndex = 3; - // - // groupBox1 - // - groupBox1.Controls.Add(DataGV); - groupBox1.Location = new Point(434, 31); - groupBox1.Margin = new Padding(4); - groupBox1.Name = "groupBox1"; - groupBox1.Padding = new Padding(4); - groupBox1.Size = new Size(550, 340); - groupBox1.TabIndex = 4; - groupBox1.TabStop = false; - groupBox1.Text = "BookListGBox"; - // - // DataGV - // - DataGV.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; - DataGV.Columns.AddRange(new DataGridViewColumn[] { BookColumnCBox, NoteColumn }); - DataGV.Location = new Point(8, 52); - DataGV.Margin = new Padding(4); - DataGV.Name = "DataGV"; - DataGV.RowHeadersWidth = 62; - DataGV.Size = new Size(534, 264); - DataGV.TabIndex = 0; - // - // SaveBtn - // - SaveBtn.Location = new Point(48, 276); - SaveBtn.Margin = new Padding(4); - SaveBtn.Name = "SaveBtn"; - SaveBtn.Size = new Size(343, 44); - SaveBtn.TabIndex = 5; - SaveBtn.Text = "Save and give out"; - SaveBtn.UseVisualStyleBackColor = true; - SaveBtn.Click += SaveBtn_Click; - // - // BackBtn - // - BackBtn.Location = new Point(48, 328); - BackBtn.Margin = new Padding(4); - BackBtn.Name = "BackBtn"; - BackBtn.Size = new Size(343, 44); - BackBtn.TabIndex = 6; - BackBtn.Text = "Go back"; - BackBtn.UseVisualStyleBackColor = true; - BackBtn.Click += BackBtn_Click; - // - // ReaderLabel - // - ReaderLabel.AutoSize = true; - ReaderLabel.Location = new Point(39, 90); - ReaderLabel.Margin = new Padding(4, 0, 4, 0); - ReaderLabel.Name = "ReaderLabel"; - ReaderLabel.Size = new Size(87, 64); - ReaderLabel.TabIndex = 7; - ReaderLabel.Text = "Reader\r\ncard:"; - // - // CardCBox - // - CardCBox.FormattingEnabled = true; - CardCBox.Location = new Point(155, 105); - CardCBox.Margin = new Padding(4); - CardCBox.Name = "CardCBox"; - CardCBox.Size = new Size(235, 40); - CardCBox.TabIndex = 8; - // - // BookColumnCBox - // - BookColumnCBox.HeaderText = "Book's title"; - BookColumnCBox.MinimumWidth = 8; - BookColumnCBox.Name = "BookColumnCBox"; - BookColumnCBox.Width = 150; - // - // NoteColumn - // - NoteColumn.HeaderText = "Note"; - NoteColumn.MinimumWidth = 8; - NoteColumn.Name = "NoteColumn"; - NoteColumn.Width = 150; - // - // RegOrder - // - AutoScaleDimensions = new SizeF(13F, 32F); - AutoScaleMode = AutoScaleMode.Font; - ClientSize = new Size(1020, 402); - Controls.Add(CardCBox); - Controls.Add(ReaderLabel); - Controls.Add(BackBtn); - Controls.Add(SaveBtn); - Controls.Add(groupBox1); - Controls.Add(BorrowDTPicker); - Controls.Add(DateLabel); - Controls.Add(LibLabel); - Controls.Add(LibrarianCBox); - Margin = new Padding(4); - Name = "RegOrder"; - Text = "RegOrder"; - groupBox1.ResumeLayout(false); - ((System.ComponentModel.ISupportInitialize)DataGV).EndInit(); - ResumeLayout(false); - PerformLayout(); - } - - #endregion - - private ComboBox LibrarianCBox; - private Label LibLabel; - private Label DateLabel; - private DateTimePicker BorrowDTPicker; - private GroupBox groupBox1; - private DataGridView DataGV; - private Button SaveBtn; - private Button BackBtn; - private Label ReaderLabel; - private ComboBox CardCBox; - private DataGridViewComboBoxColumn BookColumnCBox; - private DataGridViewTextBoxColumn NoteColumn; - } -} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.cs b/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.cs deleted file mode 100644 index 9520304..0000000 --- a/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.cs +++ /dev/null @@ -1,66 +0,0 @@ -using LDBproject.Entities; -using LDBproject.Repositories; -using LDBproject.Repositories.Implementations; - -namespace LDBproject.AdditionalForms; - -public partial class RegOrder : Form -{ - private readonly IOrderRep _orderRepository; - - public RegOrder(IOrderRep orderRep, ICustomerCardsRep readerRep, - ILibrarianRep employeeRep, IBookRep bookRep) - { - InitializeComponent(); - _orderRepository = orderRep ?? throw new ArgumentNullException(nameof(orderRep)); - - LibrarianCBox.DataSource = employeeRep.GetCards(); - LibrarianCBox.DisplayMember = "FIO"; - LibrarianCBox.ValueMember = "CardID"; - - CardCBox.DataSource = readerRep.GetCards(); - CardCBox.DisplayMember = "FIO"; - CardCBox.ValueMember = "CardID"; - - BookColumnCBox.DataSource = bookRep.GetBookList(); - BookColumnCBox.DisplayMember = "Title"; - BookColumnCBox.ValueMember = "BookID"; - } - - private void SaveBtn_Click(object sender, EventArgs e) - { - try - { - if (DataGV.RowCount < 1 || LibrarianCBox.SelectedIndex < 0) - { - throw new Exception("[ Blanck space left ]"); - } - _orderRepository.CreateOrder(Order.NewOrder(0, (int)CardCBox.SelectedValue, (int)LibrarianCBox.SelectedValue, - CreateBookListFromDG(), BorrowDTPicker.Value)); - - Close(); - } - catch (Exception ex) - { - MessageBox.Show(ex.Message, "Order Form [ Error while saving order ]", - MessageBoxButtons.OK, MessageBoxIcon.Error); - } - } - - private List CreateBookListFromDG() - { - List registrations = new List(); - foreach (DataGridViewRow row in DataGV.Rows) - { - if (row.Cells["BookColumnCBox"].Value != null) - { - var bookId = (int)row.Cells["BookColumnCBox"].Value; - var notes = row.Cells["NoteColumn"].Value?.ToString(); - registrations.Add(Registration.OrderReg(0, bookId, notes)); - } - } - return registrations; - } - - private void BackBtn_Click(object sender, EventArgs e) => Close(); -} diff --git a/LibraryDBproject/LDBproj/AdditionalForms/UpdReportF.Designer.cs b/LibraryDBproject/LDBproj/AdditionalForms/UpdReportF.Designer.cs new file mode 100644 index 0000000..29e7ad3 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/UpdReportF.Designer.cs @@ -0,0 +1,107 @@ +namespace LDBproject.AdditionalForms +{ + partial class UpdReportF + { + /// + /// 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() + { + button1 = new Button(); + button2 = new Button(); + UpdDTP = new DateTimePicker(); + label = new Label(); + FileNamelabel = new Label(); + SuspendLayout(); + // + // button1 + // + button1.Location = new Point(41, 28); + button1.Name = "button1"; + button1.Size = new Size(453, 46); + button1.TabIndex = 0; + button1.Text = "Choose file path"; + button1.UseVisualStyleBackColor = true; + button1.Click += SelectFileNameBtn_Click; + // + // button2 + // + button2.Location = new Point(41, 247); + button2.Name = "button2"; + button2.Size = new Size(453, 46); + button2.TabIndex = 1; + button2.Text = "Ok"; + button2.UseVisualStyleBackColor = true; + button2.Click += CreateBtn_Click; + // + // UpdDTP + // + UpdDTP.Location = new Point(73, 190); + UpdDTP.Name = "UpdDTP"; + UpdDTP.Size = new Size(400, 39); + UpdDTP.TabIndex = 2; + // + // label + // + label.AutoSize = true; + label.Location = new Point(81, 141); + label.Name = "label"; + label.Size = new Size(383, 32); + label.TabIndex = 3; + label.Text = "Check how much updates was on :"; + // + // FileNamelabel + // + FileNamelabel.AutoSize = true; + FileNamelabel.Location = new Point(44, 79); + FileNamelabel.Name = "FileNamelabel"; + FileNamelabel.Size = new Size(120, 32); + FileNamelabel.TabIndex = 4; + FileNamelabel.Text = "/file path/"; + // + // UpdReport + // + AutoScaleDimensions = new SizeF(13F, 32F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(543, 330); + Controls.Add(FileNamelabel); + Controls.Add(label); + Controls.Add(UpdDTP); + Controls.Add(button2); + Controls.Add(button1); + Name = "UpdReport"; + Text = "UpdReport"; + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private Button button1; + private Button button2; + private DateTimePicker UpdDTP; + private Label label; + private Label FileNamelabel; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/UpdReportF.cs b/LibraryDBproject/LDBproj/AdditionalForms/UpdReportF.cs new file mode 100644 index 0000000..b135030 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/UpdReportF.cs @@ -0,0 +1,55 @@ +using System.Windows.Forms; +using Unity; + +namespace LDBproject.AdditionalForms +{ + public partial class UpdReportF : Form + { + private string _fileName = string.Empty; + private readonly IUnityContainer _container; + public UpdReportF(IUnityContainer container) + { + InitializeComponent(); + _container = container ?? throw new ArgumentNullException(nameof(container)); + } + private void SelectFileNameBtn_Click(object sender, EventArgs e) + { + var sfd = new SaveFileDialog() + { + Filter = "Pdf Files | *.pdf" + }; + if (sfd.ShowDialog() == DialogResult.OK) + { + _fileName = sfd.FileName; + FileNamelabel.Text = Path.GetFileName(_fileName); + } + } + private void CreateBtn_Click(object sender, EventArgs e) + { + try + { + if (string.IsNullOrWhiteSpace(_fileName)) + { + throw new Exception("No file (path) chosen"); + } + if + (_container.Resolve().CreateChart(_fileName, UpdDTP.Value)) + { + MessageBox.Show("< PDF Document was formated >", "Creating chart report (pdf)", + MessageBoxButtons.OK, + MessageBoxIcon.Information); + } + else + { + MessageBox.Show("< ERROR : see logs >", "Pdf. formating", + MessageBoxButtons.OK, MessageBoxIcon.Information); + } + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "< ERROR : while creating pdf document >", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + } +} diff --git a/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.resx b/LibraryDBproject/LDBproj/AdditionalForms/UpdReportF.resx similarity index 93% rename from LibraryDBproject/LDBproj/AdditionalForms/RegOrder.resx rename to LibraryDBproject/LDBproj/AdditionalForms/UpdReportF.resx index ef527f1..af32865 100644 --- a/LibraryDBproject/LDBproj/AdditionalForms/RegOrder.resx +++ b/LibraryDBproject/LDBproj/AdditionalForms/UpdReportF.resx @@ -117,10 +117,4 @@ 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/LibraryDBproject/LDBproj/DBScript/TextCommands.txt b/LibraryDBproject/LDBproj/DBScript/TextCommands.txt deleted file mode 100644 index c0bc7f7..0000000 --- a/LibraryDBproject/LDBproj/DBScript/TextCommands.txt +++ /dev/null @@ -1,201 +0,0 @@ --- Insert data into Genres -INSERT INTO Genres (GenreName) VALUES -('None'), ('Adventure'), ('Fantasy'), ('Mystery'), ('Fiction'), ('Suspense'), ('Romance'), ('Crime'), ('Talent'), ('Realism'), ('Horror'), ('Historical'); - --- Insert data into Books (with updated GenreIDs and Status) -INSERT INTO Books (Title, Author, PublishYear, Status, GenreMask) VALUES -('The Hobbit', 'J.R.R. Tolkien', 1937, 3, 1024), -- On Stock, Fantasy -('Pride and Prejudice', 'Jane Austen', 1813, 3, 2 | 128), -- On Stock, Romance | Realism -('The Da Vinci Code', 'Dan Brown', 2003, 4, 4 | 16), -- Borrowed, Mystery | Suspense -('1984', 'George Orwell', 1949, 3, 8 | 128), -- On Stock, Fiction | Realism -('To Kill a Mockingbird', 'Harper Lee', 1960, 4, 8 | 128), -- Borrowed, Fiction | Realism -('The Great Gatsby', 'F. Scott Fitzgerald', 1925, 3, 2 | 128), -- On Stock, Romance | Realism -('The Time Traveler''s Wife', 'Audrey Niffenegger', 2003, 4, 2 | 1024), -- Borrowed, Romance | Fantasy -('The Secret Garden', 'Frances Hodgson Burnett', 1911, 2, 1), -- in IDassignment state, Adventure -('Gone Girl', 'Gillian Flynn', 2012, 1, 4 | 16 | 32), -- Ordered, Mystery | Suspense | Crime -('A Game of Thrones', 'George R.R. Martin', 1996, 3, 1 | 1024 | 8), -- On Stock, Adventure | Fantasy | Fiction -('Harry Potter and the Sorcerer''s Stone', 'J.K. Rowling', 1997, 3, 1 | 8 | 1024), -- On Stock, Adventure | Fiction | Fantasy -('The Martian', 'Andy Weir', 2011, 3, 1 | 8), -- On Stock, Adventure | Fiction -('Little Women', 'Louisa May Alcott', 1868, 5, 2), -- Debited, Romance -('The Seven Husbands of Evelyn Hugo', 'Taylor Jenkins Reid', 2017, 3, 2 | 128); -- On Stock, Romance | Realism --- ('Where the Crawdads Sing', 'Delia Owens', 2018, ); -- Fiction, Borrowed --- ('The Lord of the Rings', 'J.R.R. Tolkien', 1954, ), -- Fantasy, Unable --- ('The Nightingale', 'Kristin Hannah', 2015, ), -- Romance, Borrowed --- ('The Book Thief', 'Markus Zusak', 2005, ), -- Fiction, On Stock --- ('The Help', 'Kathryn Stockett', 2009, ), -- Fiction, Borrowed --- ('The Girl on the Train', 'Paula Hawkins', 2015, ), -- Suspense, On Stock --- ('The Girl with the Dragon Tattoo', 'Stieg Larsson', 2005, ), -- Suspense, On Stock --- ('The Catcher in the Rye', 'J.D. Salinger', 1951, ), -- Fiction, Unable --- ('The Hunger Games', 'Suzanne Collins', 2008, ), -- Suspense, Borrowed --- ('The Silent Patient', 'Alex Michaelides', 2019, ), -- Mystery, Unable --- ('And Then There Were None', 'Agatha Christie', 1939, ), -- Mystery, Unable - --- Insert data into LibrarianCards (reference existing GenreIDs) -INSERT INTO LibrarianCards (FIO, GenreMask) VALUES -('Carla R.E.', 4 | 16 | 32), -('Bonnet D.P.', 2 | 128), -('Gabriel W.T.', 1 | 1024 | 8); - --- Insert data into CustomerCards -INSERT INTO CustomerCards (FIO, AgeBirthday) VALUES -('Winsent G.P.', '2000-01-15'), -('Quincy P.R.', '2005-05-20'), -('Emily Y.N.', '2009-11-10'), -('Frank A.K.', '2007-07-25'), -('Marinett J.C.', '2004-03-01'), -('Alice B.T.', '2002-08-10'), -('Bob C.L.', '1998-03-25'), -('Charlie D.M.', '2011-06-18'), -('Diana E.S.', '1995-12-05'), -('Eve F.W.', '2007-09-30'); - - --- Insert more data into Orders -INSERT INTO Orders (CardID, LibrarianID, BorrowDate) VALUES -(6, 1, '2024-05-10 11:00:00'), -(1, 3, '2024-05-15 15:30:00'), -(9, 1, '2024-05-20 09:45:00'), -(3, 2, '2024-05-25 13:15:00'), -(4, 3, '2024-06-01 10:00:00'), -(5, 1, '2024-06-05 16:45:00'), -(10, 2, '2024-06-10 14:15:00'), -(1, 1, '2024-07-15 10:30:00'), -(10, 3, '2024-07-20 12:45:00'), -(7, 1, '2024-07-25 17:00:00'), -(2, 1, '2024-08-20 09:45:00'), -(8, 2, '2024-08-25 13:15:00'), -(4, 3, '2024-09-01 10:00:00'), -(5, 1, '2024-09-12 16:45:00'), -(8, 3, '2024-09-16 10:00:00'), -(6, 1, '2024-09-24 16:45:00'), -(9, 2, '2024-10-10 14:15:00'), -(1, 1, '2024-10-15 10:30:00'), -(7, 3, '2024-12-09 12:45:00'), -(3, 1, '2024-12-25 17:00:00'), -(4, 1, '2024-12-20 09:45:00'); - --- Insert more data into Registrations -INSERT INTO Registrations (OrderID, BookID, Note) VALUES -(1, 6, '07-10'), -(2, 10, '07-15'), -(3, 2, '07-20'), -(4, 7, '07-25'), -(5, 11, '08-07'), -(5, 9, '08-07'), -(6, 8, '08-10'), -(7, 4, '08-15'), -(7, 5, '08-15'), -(7, 6, '08-15'), -(7, 7, '08-15'), -(8, 11, '08-18'), -(9, 9, '08-27'), -(9, 3, '08-10'), -(10, 4, '08-15'), -(11, 8, '07-25'), -(12, 10, '08-01'), -(13, 12, '08-05'), -(14, 3, '08-10'), -(14, 4, '08-15'), -(14, 5, '08-20'), -(14, 1, '08-25'), -(15, 6, '08-25'), -(16, 7, '07-25'), -(17, 8, '08-01'), -(17, 9, '08-05'), -(18, 11, '08-10'), -(18, 4, '08-15'), -(18, 7, '07-25'), -(18, 1, '08-01'); - --- Insert more data into Updates – Multiple updates on the same day -INSERT INTO Updates (LastUpdate, UpdBoundary, Note, LibrarianID, CardID) VALUES -('2017-05-10', '2021-03-15', 'Card Received', 3, 1), -('2022-11-22', '2025-08-20', 'Renewed card', 2, 3), -('2016-02-01', '2020-01-10', 'Card Received', 2, 2), -('2020-09-18', '2024-12-05', 'Updated address', 1, 4), -('2018-07-05', '2024-06-25', 'Card Received', 3, 5), -('2023-10-26', '2024-04-15', 'Lost card, reissued', 1, 1), -('2023-10-26', '2024-05-10', 'Payment overdue', 2, 5), -('2024-01-15', '2024-07-15', 'Address change', 3, 2), -('2024-03-01', '2024-09-01', 'Renewed card', 1, 4), -('2024-03-01', '2024-09-01', 'Fee payment', 1, 3), -- Multiple updates on the same day -('2024-03-10', '2025-01-10', 'Card Received', 2, 6), -('2024-04-20', '2025-02-20', 'Renewal', 3, 1), -('2024-05-10', '2025-03-10', 'New Card issued', 1, 5); - --- Drop the table if it exists ----------------------------- -DROP TABLE IF EXISTS Updates; - -DROP TABLE IF EXISTS Registrations; -DROP TABLE IF EXISTS Orders; - -DROP TABLE IF EXISTS LibrarianCards; -DROP TABLE IF EXISTS CustomerCards; - -DROP TABLE IF EXISTS Books; -DROP TABLE IF EXISTS Genres; - --- Create the Genres table [ 1 ] -CREATE TABLE Genres ( - GenreID SERIAL PRIMARY KEY, - GenreName VARCHAR(255) NOT NULL UNIQUE -); - --- Create the Books table [ 2 ] -CREATE TABLE Books ( - BookID SERIAL PRIMARY KEY, - Title VARCHAR(255) NOT NULL, - Author VARCHAR(255) NOT NULL, - PublishYear INTEGER, - Status INTEGER CHECK (Status IN (0, 1, 2, 3, 4, 5)), - GenreMask INTEGER DEFAULT 0 - -- CountOnStock INTEGER CHECK (CountOnStock >= 0), - -- > GenreID INTEGER REFERENCES Genres(GenreID) -); - --- > ALTER TABLE Books DROP COLUMN GenreID; - --- Now, add the GenreMask column to the Books table --- [ ! ] ALTER TABLE Books ADD COLUMN GenreMask INTEGER DEFAULT 0; -- Using INTEGER to store bitmask - - --- Create the CustomerCards table [ 3 ] -CREATE TABLE CustomerCards ( - CardID SERIAL PRIMARY KEY, - FIO VARCHAR(255) NOT NULL, - AgeBirthday DATE -); - --- Create the LibrarianCards table [ 4 ] -CREATE TABLE LibrarianCards ( - CardID SERIAL PRIMARY KEY, - FIO VARCHAR(255) NOT NULL, - GenreMask INTEGER DEFAULT 0 - -- GenreID INTEGER REFERENCES Genres(GenreID) -); - --- Create the Orders table [ 5 ] -CREATE TABLE Orders ( - OrderID SERIAL PRIMARY KEY, - CardID INTEGER REFERENCES CustomerCards(CardID) NOT NULL, - LibrarianID INTEGER REFERENCES LibrarianCards(CardID) NOT NULL, - BorrowDate TIMESTAMP WITH TIME ZONE -); - --- Create the Registrations table [ 6 ] -CREATE TABLE Registrations ( - ID SERIAL PRIMARY KEY, - OrderID INTEGER REFERENCES Orders(OrderID) NOT NULL, - BookID INTEGER REFERENCES Books(BookID) NOT NULL, - Note TEXT -); - --- Create the Updates table [ 7 ] -CREATE TABLE Updates ( - ID SERIAL PRIMARY KEY, - LastUpdate DATE NOT NULL, - UpdBoundary DATE, - Note TEXT, - LibrarianID INTEGER REFERENCES LibrarianCards(CardID) NOT NULL, - CardID INTEGER REFERENCES CustomerCards(CardID) NOT NULL -); diff --git a/LibraryDBproject/LDBproj/Entities/TemprOrderReg.cs b/LibraryDBproject/LDBproj/Entities/TemprOrderReg.cs new file mode 100644 index 0000000..fcadf00 --- /dev/null +++ b/LibraryDBproject/LDBproj/Entities/TemprOrderReg.cs @@ -0,0 +1,20 @@ +namespace LDBproject.Entities; + +internal class TemprOrderReg +{ + // from Order class + public int OrderID { get; private set; } + + public int CardID { get; private set; } + + public int LibrarianID { get; private set; } + + public DateTime BorrowDate { get; private set; } + + // from Registration class + public int ID { get; private set; } + + public int BookID { get; private set; } + + public string Note { get; private set; } +} diff --git a/LibraryDBproject/LDBproj/LDBproject.csproj b/LibraryDBproject/LDBproj/LDBproject.csproj index 8508f1d..30fa452 100644 --- a/LibraryDBproject/LDBproj/LDBproject.csproj +++ b/LibraryDBproject/LDBproj/LDBproject.csproj @@ -10,11 +10,14 @@ + + + diff --git a/LibraryDBproject/LDBproj/MainForm.Designer.cs b/LibraryDBproject/LDBproj/MainForm.Designer.cs index eca7d93..e38a574 100644 --- a/LibraryDBproject/LDBproj/MainForm.Designer.cs +++ b/LibraryDBproject/LDBproj/MainForm.Designer.cs @@ -1,4 +1,6 @@ -namespace LDBproject +using LDBproject.AdditionalForms; + +namespace LDBproject { partial class MainForm { @@ -40,6 +42,11 @@ GiveOut = new ToolStripMenuItem(); Updating = new ToolStripMenuItem(); LogsTSMI = new ToolStripMenuItem(); + + ReportW = new ToolStripMenuItem(); + ReportP = new ToolStripMenuItem(); + ReportC = new ToolStripMenuItem(); + menuStrip1.SuspendLayout(); menuStrip2.SuspendLayout(); SuspendLayout(); @@ -133,10 +140,33 @@ // // LogsTSMI // + LogsTSMI.DropDownItems.AddRange(new ToolStripItem[] { ReportW, ReportP, ReportC }); LogsTSMI.ForeColor = Color.DarkSlateBlue; LogsTSMI.Name = "LogsTSMI"; LogsTSMI.Size = new Size(88, 29); LogsTSMI.Text = "Отчёты"; + + // Reports --- [ ! ] + ReportW.BackColor = Color.DarkSlateBlue; + ReportW.ForeColor = Color.GreenYellow; + ReportW.Name = "ReportW"; + ReportW.Size = new Size(273, 34); + ReportW.Text = "Сформировать документ"; + ReportW.Click += Report_Click; + + ReportP.BackColor = Color.DarkSlateBlue; + ReportP.ForeColor = Color.GreenYellow; + ReportP.Name = "ReportP"; + ReportP.Size = new Size(273, 34); + ReportP.Text = "Отчёт о заказах"; + ReportP.Click += OrderReport_Click; + + ReportC.BackColor = Color.DarkSlateBlue; + ReportC.ForeColor = Color.GreenYellow; + ReportC.Name = "ReportC"; + ReportC.Size = new Size(273, 34); + ReportC.Text = "Отчёт о билетах"; + ReportC.Click += UpdReport_Click; // // MainForm // @@ -172,5 +202,9 @@ private ToolStripMenuItem ReaderCard; private ToolStripMenuItem BookReg; private ToolStripMenuItem Updating; + + private ToolStripMenuItem ReportW; + private ToolStripMenuItem ReportP; + private ToolStripMenuItem ReportC; } } diff --git a/LibraryDBproject/LDBproj/MainForm.cs b/LibraryDBproject/LDBproj/MainForm.cs index 9aaeadd..06e1af7 100644 --- a/LibraryDBproject/LDBproj/MainForm.cs +++ b/LibraryDBproject/LDBproj/MainForm.cs @@ -57,7 +57,7 @@ public partial class MainForm : Form { try { - _container.Resolve().ShowDialog(); + _container.Resolve().ShowDialog(); } catch (Exception ex) { @@ -78,5 +78,44 @@ public partial class MainForm : Form MessageBoxButtons.OK, MessageBoxIcon.Error); } } + + private void Report_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Download : ERROR ]", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void OrderReport_Click(object sender, EventArgs e) + { + try + { + + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Download : ERROR ]", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void UpdReport_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "[ Download : ERROR ]", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } } diff --git a/LibraryDBproject/LDBproj/Reports/ChartReport.cs b/LibraryDBproject/LDBproj/Reports/ChartReport.cs new file mode 100644 index 0000000..10dc074 --- /dev/null +++ b/LibraryDBproject/LDBproj/Reports/ChartReport.cs @@ -0,0 +1,56 @@ +using Microsoft.Extensions.Logging; +using LDBproject.Entities; +using LDBproject.Repositories; +using LDBproject.Reports; + +internal class ChartReport +{ + private readonly IUpdateRep _updR; + private readonly ILogger _logger; + + public ChartReport(IUpdateRep updR, ILogger logger) + { + _updR = updR ?? throw new ArgumentNullException(nameof(updR)); + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + + public bool CreateChart(string filePath, DateTime dateTime) + { + try + { + var updates = _updR.GetUpdateList().ToList(); // Materialize the query + var data = GetData(updates, dateTime); + + System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance); + + new PdfBuilder(filePath).AddHeader("Card Updates") // More descriptive header + .AddPieChart("Number of Times Card Updated", data) // Corrected caption + .Build(); + return true; + } + catch (Exception ex) + { + _logger.LogError(ex, "Error creating chart."); + return false; + } + } + + private List<(string Caption, double Value)> GetData(List updates, DateTime date) + { + var result = new List<(string Caption, double Value)>(); + + var distinctCards = updates.Where(u => u.LastUpdate.Date == date.Date) // Filter by date + .GroupBy(u => u.CardID) + .Select(g => new { CardID = g.Key, Count = g.Count() }) + .ToList(); + + + foreach (var cardData in distinctCards) + { + result.Add(($"Card {cardData.CardID}", cardData.Count)); + } + + return result; + } + +} diff --git a/LibraryDBproject/LDBproj/Reports/DocReport.cs b/LibraryDBproject/LDBproj/Reports/DocReport.cs new file mode 100644 index 0000000..e1f4064 --- /dev/null +++ b/LibraryDBproject/LDBproj/Reports/DocReport.cs @@ -0,0 +1,75 @@ +using Microsoft.Extensions.Logging; +using LDBproject.Repositories; + +namespace LDBproject.Reports; + +internal class DocReport +{ + private readonly IBookRep _bookRep; + private readonly ILibrarianRep _librarianRep; + private readonly ICustomerCardsRep _customerRep; + private readonly ILogger _logger; + + public DocReport(IBookRep bookRep, ILibrarianRep librarianRep, + ICustomerCardsRep customerRep, ILogger logger) + { + _bookRep = bookRep ?? throw new ArgumentNullException(nameof(bookRep)); + _librarianRep = librarianRep ?? throw new ArgumentNullException(nameof(librarianRep)); + _customerRep = customerRep ?? throw new ArgumentNullException(nameof(customerRep)); + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + + public bool CreateDoc(string filePath, bool includeOrders, bool includeLibrarians, bool includeCustomers) + { + try + { + var builder = new WordBuilder(filePath).AddHeader("Reports Document"); + + if (includeOrders) + { + builder.AddParagraph("Книги").AddTable([2400, 2400, 1200], GetBooks()); + } + + if (includeLibrarians) + { + builder.AddParagraph("Работники").AddTable([2400, 1200], GetLibrarians()); + } + + if (includeCustomers) + { + builder.AddParagraph("Читатели").AddTable([2400, 2400], GetCustomers()); + } + + builder.Build(); + + return true; + } + catch (Exception ex) + { + _logger.LogError(ex, "< Error while forming document >"); + return false; + } + } + + private List GetBooks() + { + return [ + ["Title", "Author", "Year of publishing"], + .. _bookRep.GetBookList().Select(x => new string[] + { x.Title, x.Author, x.PublishYear.ToString() }),]; + } + + private List GetLibrarians() + { + return [["FIO", "Genres"], + .. _librarianRep.GetCards().Select(x => new string[] + { x.FIO, x.GenreMask.ToString() ?? "Unknown" }),]; + } + + private List GetCustomers() + { + return [["FIO", "Birthday"], + .. _customerRep.GetCards().Select(x => new string[] + { x.FIO, x.AgeBirthday.ToString() }),]; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/Reports/ExcelBuilder.cs b/LibraryDBproject/LDBproj/Reports/ExcelBuilder.cs new file mode 100644 index 0000000..6788849 --- /dev/null +++ b/LibraryDBproject/LDBproj/Reports/ExcelBuilder.cs @@ -0,0 +1,285 @@ +using DocumentFormat.OpenXml.Packaging; +using DocumentFormat.OpenXml.Spreadsheet; +using DocumentFormat.OpenXml; + +namespace LDBproject.Reports; + +internal class ExcelBuilder +{ + private readonly string _filePath; + private readonly SheetData _sheetData; + private readonly MergeCells _mergeCells; + private readonly Columns _columns; + private uint _rowIndex = 0; + + public ExcelBuilder(string filePath) + { + if (string.IsNullOrWhiteSpace(filePath)) + { + throw new ArgumentNullException(nameof(filePath)); + } + if (File.Exists(filePath)) + { + File.Delete(filePath); + } + + _filePath = filePath; + _sheetData = new SheetData(); + _mergeCells = new MergeCells(); + _columns = new Columns(); + _rowIndex = 1; + } + + public ExcelBuilder AddHeader(string header, int startIndex, int count) + { + CreateCell(startIndex, _rowIndex, header, StyleIndex.BoldCentered); // Changed style + for (int i = startIndex + 1; i < startIndex + count; ++i) + { + CreateCell(i, _rowIndex, "", StyleIndex.BoldCentered); // Changed style + } + + _mergeCells.Append(new MergeCell + { + Reference = new StringValue($"{GetExcelColumnName(startIndex)}{_rowIndex}:{GetExcelColumnName(startIndex + count - 1)}{_rowIndex}") + }); + + _rowIndex++; + return this; + } + + public ExcelBuilder AddParagraph(string text, int columnIndex) + { + CreateCell(columnIndex, _rowIndex++, text, StyleIndex.SimpleTextWithoutBorder); + return this; + } + + public ExcelBuilder AddTable(int[] columnWidths, List data) + { + // Error handling (keep this) + if (columnWidths == null || columnWidths.Length == 0) + { + throw new ArgumentNullException(nameof(columnWidths)); + } + + if (data == null || data.Count == 0) + { + throw new ArgumentNullException(nameof(data)); + } + + if (data.Any(x => x.Length != columnWidths.Length)) + { + throw new InvalidOperationException("Column widths and data row lengths must match."); + } + + if (data.Count > 0) + { + var firstRow = data.First(); + if (firstRow.Length != columnWidths.Length) + { + throw new InvalidOperationException("Column widths and data row lengths must match."); + } + } + + //Column setup - now it's dynamically calculated + uint counter = 1; + int coef = 2; // Consider making this a configurable parameter + _columns.Append(columnWidths.Select(x => new Column + { + Min = counter, + Max = counter++, + Width = x * coef, + CustomWidth = true + })); + for (int i = 0; i < data.Count; i++) + { + for (int j = 0; j < data[i].Length; j++) + { + StyleIndex styleIndex = (i == 0) ? StyleIndex.BoldCentered : StyleIndex.WithThinBorder; // Header row style + CreateCell(j, _rowIndex, data[i][j], styleIndex); + } + _rowIndex++; + } + + return this; + } + + public void Build() + { + using var spreadsheetDocument = SpreadsheetDocument.Create(_filePath, SpreadsheetDocumentType.Workbook); + var workbookpart = spreadsheetDocument.AddWorkbookPart(); + GenerateStyle(workbookpart); + workbookpart.Workbook = new Workbook(); + var worksheetPart = workbookpart.AddNewPart(); + worksheetPart.Worksheet = new Worksheet(); + + if (_columns.HasChildren) + { + worksheetPart.Worksheet.Append(_columns); + } + + worksheetPart.Worksheet.Append(_sheetData); + var sheets = spreadsheetDocument.WorkbookPart!.Workbook.AppendChild(new Sheets()); + var sheet = new Sheet() + { + Id = spreadsheetDocument.WorkbookPart.GetIdOfPart(worksheetPart), + SheetId = 1, + Name = "Page 1" + }; + + sheets.Append(sheet); + if (_mergeCells.HasChildren) + { + worksheetPart.Worksheet.InsertAfter(_mergeCells, + worksheetPart.Worksheet.Elements().First()); + } + } + + private static void GenerateStyle(WorkbookPart workbookPart) + { + var workbookStylesPart = workbookPart.AddNewPart(); + workbookStylesPart.Stylesheet = new Stylesheet(); + + var fonts = new Fonts() + { + Count = 3, // Increased count to accommodate bold font + KnownFonts = BooleanValue.FromBoolean(true) + }; + + fonts.Append(new DocumentFormat.OpenXml.Spreadsheet.Font + { + FontSize = new FontSize() { Val = 11 }, + FontName = new FontName() { Val = "Calibri" }, + FontFamilyNumbering = new FontFamilyNumbering() { Val = 2 }, + FontScheme = new FontScheme() { Val = new EnumValue(FontSchemeValues.Minor) } + }); + + // Added bold font + fonts.Append(new DocumentFormat.OpenXml.Spreadsheet.Font + { + FontSize = new FontSize() { Val = 11 }, + FontName = new FontName() { Val = "Calibri" }, + FontFamilyNumbering = new FontFamilyNumbering() { Val = 2 }, + Bold = new Bold(), // Added Bold element + FontScheme = new FontScheme() { Val = new EnumValue(FontSchemeValues.Minor) } + }); + + workbookStylesPart.Stylesheet.Append(fonts); + + // Default Fill + var fills = new Fills() { Count = 1 }; + fills.Append(new Fill + { + PatternFill = new PatternFill() + { + PatternType = new EnumValue(PatternValues.None) + } + }); + workbookStylesPart.Stylesheet.Append(fills); + + // Default Border & Added a border with lines + var borders = new Borders() { Count = 3 }; // Increased count for the new border + borders.Append(new Border + { + LeftBorder = new LeftBorder(), + RightBorder = new RightBorder(), + TopBorder = new TopBorder(), + BottomBorder = new BottomBorder(), + DiagonalBorder = new DiagonalBorder() + }); + + // Added a border with lines + borders.Append(new Border + { + LeftBorder = new LeftBorder { Style = BorderStyleValues.Thin }, + RightBorder = new RightBorder { Style = BorderStyleValues.Thin }, + TopBorder = new TopBorder { Style = BorderStyleValues.Thin }, + BottomBorder = new BottomBorder { Style = BorderStyleValues.Thin }, + DiagonalBorder = new DiagonalBorder() + }); + + workbookStylesPart.Stylesheet.Append(borders); + + // Default cell format and a few more formats + var cellFormats = new CellFormats() { Count = 4 }; + cellFormats.Append(new CellFormat + { + NumberFormatId = 0, + FormatId = 0, + FontId = 0, + BorderId = 0, + FillId = 0, + Alignment = new Alignment() + { + Horizontal = HorizontalAlignmentValues.Left, + Vertical = VerticalAlignmentValues.Center, + WrapText = true + } + }); + + // Added formats (customize these as needed) + cellFormats.Append(new CellFormat { NumberFormatId = 0, FontId = 1, BorderId = 1, Alignment = new Alignment { Horizontal = HorizontalAlignmentValues.Center } }); //Bold and centered + cellFormats.Append(new CellFormat { NumberFormatId = 0, FontId = 0, BorderId = 1 }); // With thin border + + workbookStylesPart.Stylesheet.Append(cellFormats); + } + + private enum StyleIndex + { + SimpleTextWithoutBorder = 0, + BoldCentered = 1, + WithThinBorder = 2 + } + + private void CreateCell(int columnIndex, uint rowIndex, string text, StyleIndex styleIndex) + { + var columnName = GetExcelColumnName(columnIndex); + var cellReference = columnName + rowIndex; + var row = _sheetData.Elements().FirstOrDefault(r => r.RowIndex! == rowIndex); + + if (row == null) + { + row = new Row() { RowIndex = rowIndex }; + _sheetData.Append(row); + } + + var newCell = row.Elements().FirstOrDefault(c => c.CellReference != null && c.CellReference.Value == columnName + rowIndex); + if (newCell == null) + { + Cell? refCell = null; + foreach (Cell cell in row.Elements()) + { + if (cell.CellReference?.Value != null && cell.CellReference.Value.Length == cellReference.Length) + { + if (string.Compare(cell.CellReference.Value, cellReference, true) > 0) + { + refCell = cell; + break; + } + } + } + newCell = new Cell() { CellReference = cellReference }; + row.InsertBefore(newCell, refCell); + } + + newCell.CellValue = new CellValue(text); + newCell.DataType = CellValues.String; + newCell.StyleIndex = (uint)styleIndex; + } + + private static string GetExcelColumnName(int columnNumber) + { + columnNumber += 1; + int dividend = columnNumber; + string columnName = string.Empty; + int modulo; + + while (dividend > 0) + { + modulo = (dividend - 1) % 26; + columnName = Convert.ToChar(65 + modulo).ToString() + columnName; + dividend = (dividend - modulo) / 26; + } + + return columnName; + } +} diff --git a/LibraryDBproject/LDBproj/Reports/PdfBuilder.cs b/LibraryDBproject/LDBproj/Reports/PdfBuilder.cs new file mode 100644 index 0000000..a3348c8 --- /dev/null +++ b/LibraryDBproject/LDBproj/Reports/PdfBuilder.cs @@ -0,0 +1,88 @@ +using MigraDoc.DocumentObjectModel; +using MigraDoc.DocumentObjectModel.Shapes.Charts; +using MigraDoc.Rendering; + +namespace LDBproject.Reports; + +internal class PdfBuilder +{ + private readonly string _filePath; + private readonly Document _document; + public PdfBuilder(string filePath) + { + if (string.IsNullOrWhiteSpace(filePath)) + { + throw new ArgumentNullException(nameof(filePath)); + } + if (File.Exists(filePath)) + { + File.Delete(filePath); + } + _filePath = filePath; + _document = new Document(); + DefineStyles(); + } + public PdfBuilder AddHeader(string header) + { + _document.AddSection().AddParagraph(header, "HeaderStyle"); // used the defined style + return this; + // _document.AddSection().AddParagraph(header, "NormalBold"); + // return this; + } + public PdfBuilder AddPieChart(string title, List<(string Caption, double + Value)> data) + { + if (data == null || data.Count == 0) + { + return this; + } + var chart = new Chart(ChartType.Pie2D); + var series = chart.SeriesCollection.AddSeries(); + series.Add(data.Select(x => x.Value).ToArray()); + var xseries = chart.XValues.AddXSeries(); + xseries.Add(data.Select(x => x.Caption).ToArray()); + chart.DataLabel.Type = DataLabelType.Percent; + chart.DataLabel.Position = DataLabelPosition.OutsideEnd; + chart.Width = Unit.FromCentimeter(16); + chart.Height = Unit.FromCentimeter(12); + chart.TopArea.AddParagraph(title); + chart.XAxis.MajorTickMark = TickMarkType.Outside; + chart.YAxis.MajorTickMark = TickMarkType.Outside; + chart.YAxis.HasMajorGridlines = true; + chart.PlotArea.LineFormat.Width = 1; + chart.PlotArea.LineFormat.Visible = true; + chart.TopArea.AddLegend(); + _document.LastSection.Add(chart); + return this; + } + public void Build() + { + var renderer = new PdfDocumentRenderer(true) + { + Document = _document + }; + renderer.RenderDocument(); + renderer.PdfDocument.Save(_filePath); + } + private void DefineStyles() + { + // defined the HeaderStyle + string[] fallbackFonts = { "Arial", "Times New Roman", "Calibri" }; //List of fonts to try + + string fontName = "Times New Roman"; + + foreach (var font in fallbackFonts) + { + if (System.Drawing.FontFamily.Families.Any(f => f.Name == font)) + { + fontName = font; + break; + } + } + + var headerStyle = _document.Styles.AddStyle("HeaderStyle", "Normal"); + headerStyle.Font.Name = fontName; + headerStyle.Font.Size = 14; + headerStyle.Font.Bold = true; + } +} diff --git a/LibraryDBproject/LDBproj/Reports/WordBuilder.cs b/LibraryDBproject/LDBproj/Reports/WordBuilder.cs new file mode 100644 index 0000000..b5762e3 --- /dev/null +++ b/LibraryDBproject/LDBproj/Reports/WordBuilder.cs @@ -0,0 +1,99 @@ +using DocumentFormat.OpenXml; +using DocumentFormat.OpenXml.Packaging; +using DocumentFormat.OpenXml.Wordprocessing; + +internal class WordBuilder +{ + private readonly string _filePath; + private readonly Document _doc; + private readonly Body _body; + public WordBuilder(string filepath) + { + if (string.IsNullOrWhiteSpace(filepath)) + { + throw new ArgumentNullException(nameof(filepath)); + } + + if (File.Exists(filepath)) + { + File.Delete(filepath); + } + + _filePath = filepath; + _doc = new Document(); + _body = _doc.AppendChild(new Body()); + } + + public WordBuilder AddHeader(string header) + { + var paragraph = _body.AppendChild(new Paragraph()); + var run = paragraph.AppendChild(new Run()); + + // Set bold text using RunProperties + run.AppendChild(new RunProperties(new Bold())); + run.AppendChild(new Text(header)); // Use Wordprocessing.Text + return this; + } + + public WordBuilder AddTable(int[] widths, List data) + { + if (widths == null || widths.Length == 0) + { + throw new ArgumentNullException(nameof(widths)); + } + + if (data == null || data.Count == 0) + { + throw new ArgumentNullException(nameof(data)); + } + + if (data.Any(x => x.Length != widths.Length)) + { + throw new InvalidOperationException("widths.Length != data.Length"); + } + + var table = new Table(); + table.AppendChild(new TableProperties(new TableBorders(new TopBorder() { Val = new EnumValue(BorderValues.Single), Size = 12 }, + new BottomBorder() { Val = new EnumValue(BorderValues.Single), Size = 12 }, + new LeftBorder() { Val = new EnumValue(BorderValues.Single), Size = 12 }, + new RightBorder() { Val = new EnumValue(BorderValues.Single), Size = 12 }, + new InsideHorizontalBorder() { Val = new EnumValue(BorderValues.Single), Size = 12 }, + new InsideVerticalBorder() { Val = new EnumValue(BorderValues.Single), Size = 12 }))); + + // Заголовок + var tr = new TableRow(); + for (var j = 0; j < widths.Length; ++j) + { + tr.Append(new TableCell( + new TableCellProperties(new TableCellWidth() + { + Width = widths[j].ToString() + }), + new Paragraph(new Run(new RunProperties(new Bold()), new Text(data.First()[j]))))); // Use Wordprocessing.Text + } + table.Append(tr); + + // Данные + table.Append(data.Skip(1).Select(x => new TableRow(x.Select(y => new TableCell(new Paragraph(new Run(new Text(y)))))))); // Use Wordprocessing.Text + + _body.Append(table); + + return this; + } + + public WordBuilder AddParagraph(string text) + { + var paragraph = _body.AppendChild(new Paragraph()); + var run = paragraph.AppendChild(new Run()); + run.AppendChild(new Text(text)); // Use Wordprocessing.Text + + return this; + } + + public void Build() + { + using var wordDocument = WordprocessingDocument.Create(_filePath, WordprocessingDocumentType.Document); + var mainPart = wordDocument.AddMainDocumentPart(); + mainPart.Document = _doc; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/Repositories/Implementations/OrderR.cs b/LibraryDBproject/LDBproj/Repositories/Implementations/OrderR.cs index f963b72..271a0f6 100644 --- a/LibraryDBproject/LDBproj/Repositories/Implementations/OrderR.cs +++ b/LibraryDBproject/LDBproj/Repositories/Implementations/OrderR.cs @@ -3,7 +3,6 @@ using LDBproject.Entities; using Newtonsoft.Json; using Npgsql; using Dapper; -using System.Data.SqlClient; namespace LDBproject.Repositories.Implementations; -- 2.25.1 From fd945d094ed27a7ba70f259b776dc350c9eae919 Mon Sep 17 00:00:00 2001 From: DelphyAlmond Date: Sat, 21 Dec 2024 20:42:47 +0400 Subject: [PATCH 4/4] 5(3/2). Excel added, all reports work syccessfully --- .../LDBproj/AdditionalForms/FullReportsF.cs | 2 +- .../AdditionalForms/OrdersReportF.Designer.cs | 114 +++++++++++++++++ .../LDBproj/AdditionalForms/OrdersReportF.cs | 87 +++++++++++++ .../AdditionalForms/OrdersReportF.resx | 120 ++++++++++++++++++ LibraryDBproject/LDBproj/Entities/Order.cs | 12 ++ .../LDBproj/Entities/TemprOrderReg.cs | 2 +- LibraryDBproject/LDBproj/MainForm.cs | 3 +- .../LDBproj/Reports/TableReport.cs | 61 +++++++++ .../LDBproj/Repositories/IOrderRep.cs | 3 +- .../Repositories/Implementations/OrderR.cs | 15 +-- 10 files changed, 405 insertions(+), 14 deletions(-) create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/OrdersReportF.Designer.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/OrdersReportF.cs create mode 100644 LibraryDBproject/LDBproj/AdditionalForms/OrdersReportF.resx create mode 100644 LibraryDBproject/LDBproj/Reports/TableReport.cs diff --git a/LibraryDBproject/LDBproj/AdditionalForms/FullReportsF.cs b/LibraryDBproject/LDBproj/AdditionalForms/FullReportsF.cs index 38ca6fe..36d1bf7 100644 --- a/LibraryDBproject/LDBproj/AdditionalForms/FullReportsF.cs +++ b/LibraryDBproject/LDBproj/AdditionalForms/FullReportsF.cs @@ -34,7 +34,7 @@ public partial class FullReportsF : Form if (_container.Resolve().CreateDoc(sfd.FileName, BookChBox.Checked, EmployeeChBox.Checked, ReadersChBox.Checked)) { - MessageBox.Show("The document was formed : Report done", "Process result", MessageBoxButtons.OK, MessageBoxIcon.Information); + MessageBox.Show("< The DOCument was made : Report done >", "Process result", MessageBoxButtons.OK, MessageBoxIcon.Information); } else { diff --git a/LibraryDBproject/LDBproj/AdditionalForms/OrdersReportF.Designer.cs b/LibraryDBproject/LDBproj/AdditionalForms/OrdersReportF.Designer.cs new file mode 100644 index 0000000..136c1c1 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/OrdersReportF.Designer.cs @@ -0,0 +1,114 @@ +namespace LDBproject.AdditionalForms +{ + partial class OrdersReportF + { + /// + /// 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() + { + OkBtn = new Button(); + FilePathTb = new TextBox(); + ComboBoxB = new ComboBox(); + BeginDTP = new DateTimePicker(); + FinDTP = new DateTimePicker(); + PathConfirmBtn = new Button(); + SuspendLayout(); + // + // OkBtn + // + OkBtn.Location = new Point(49, 362); + OkBtn.Name = "OkBtn"; + OkBtn.Size = new Size(513, 46); + OkBtn.TabIndex = 0; + OkBtn.Text = "Confirm"; + OkBtn.UseVisualStyleBackColor = true; + OkBtn.Click += MakeReportBtn_Click; + // + // FilePathTb + // + FilePathTb.Location = new Point(49, 56); + FilePathTb.Name = "FilePathTb"; + FilePathTb.Size = new Size(413, 39); + FilePathTb.TabIndex = 1; + // + // ComboBoxB + // + ComboBoxB.FormattingEnabled = true; + ComboBoxB.Location = new Point(49, 142); + ComboBoxB.Name = "ComboBoxB"; + ComboBoxB.Size = new Size(513, 40); + ComboBoxB.TabIndex = 2; + // + // BeginDTP + // + BeginDTP.Location = new Point(49, 215); + BeginDTP.Name = "BeginDTP"; + BeginDTP.Size = new Size(513, 39); + BeginDTP.TabIndex = 3; + // + // FinDTP + // + FinDTP.Location = new Point(49, 279); + FinDTP.Name = "FinDTP"; + FinDTP.Size = new Size(513, 39); + FinDTP.TabIndex = 4; + // + // PathConfirmBtn + // + PathConfirmBtn.Location = new Point(477, 53); + PathConfirmBtn.Name = "PathConfirmBtn"; + PathConfirmBtn.Size = new Size(85, 47); + PathConfirmBtn.TabIndex = 5; + PathConfirmBtn.Text = "../"; + PathConfirmBtn.UseVisualStyleBackColor = true; + PathConfirmBtn.Click += SelectFilePathBtn_Click; + // + // CardsReportF + // + AutoScaleDimensions = new SizeF(13F, 32F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(614, 452); + Controls.Add(PathConfirmBtn); + Controls.Add(FinDTP); + Controls.Add(BeginDTP); + Controls.Add(ComboBoxB); + Controls.Add(FilePathTb); + Controls.Add(OkBtn); + Name = "CardsReportF"; + Text = "CardsReportF"; + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private Button OkBtn; + private TextBox FilePathTb; + private ComboBox ComboBoxB; + private DateTimePicker BeginDTP; + private DateTimePicker FinDTP; + private Button PathConfirmBtn; + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/OrdersReportF.cs b/LibraryDBproject/LDBproj/AdditionalForms/OrdersReportF.cs new file mode 100644 index 0000000..1570c7c --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/OrdersReportF.cs @@ -0,0 +1,87 @@ +using Unity; +using LDBproject.Repositories; +using LDBproject.Reports; +using LDBproject.Entities; + +namespace LDBproject.AdditionalForms +{ + public partial class OrdersReportF : Form + { + private readonly IUnityContainer _container; + private readonly IOrderRep _orderRep; + + public OrdersReportF(IUnityContainer container, IOrderRep orderRep) + { + InitializeComponent(); + _container = container ?? throw new ArgumentNullException(nameof(container)); + _orderRep = orderRep ?? throw new ArgumentNullException(nameof(orderRep)); + + var ordersInfo = _orderRep.GetOrdersInfo().ToList(); + + if (ordersInfo.Any()) + { + ComboBoxB.DataSource = ordersInfo; + ComboBoxB.DisplayMember = "DisplayInfo"; + ComboBoxB.ValueMember = "OrderID"; // Assuming the data model has this property + } + else + { + MessageBox.Show("No Orders Found.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + Close(); + } + } + private void SelectFilePathBtn_Click(object sender, EventArgs e) + { + var sfd = new SaveFileDialog() { Filter = "Excel Files | *.xlsx" }; + if (sfd.ShowDialog() == DialogResult.OK) + { + FilePathTb.Text = sfd.FileName; + } + } + + private void MakeReportBtn_Click(object sender, EventArgs e) + { + try + { + string filePath = FilePathTb.Text; + if (string.IsNullOrWhiteSpace(filePath)) + { + MessageBox.Show("Please select a file path.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + + if (ComboBoxB.SelectedItem == null) + { + MessageBox.Show("Please select an order.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + + DateTime startDate = BeginDTP.Value; + DateTime endDate = FinDTP.Value; + + if (startDate >= endDate) + { + MessageBox.Show("Start date must be before end date.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + // Correctly get the selected OrderInfo object + if (ComboBoxB.SelectedItem is not Order selectedOrderInfo) + { + MessageBox.Show("Invalid order selection.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + // Resolve TableReport and pass the dates + var tableReport = _container.Resolve(); + + if (tableReport.CreateTable(filePath, startDate, endDate)) + { + MessageBox.Show("< Chart PDF report generated successfully >", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + } + catch (Exception ex) + { + MessageBox.Show($"An error occurred while generating the report: {ex.Message}", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + } +} \ No newline at end of file diff --git a/LibraryDBproject/LDBproj/AdditionalForms/OrdersReportF.resx b/LibraryDBproject/LDBproj/AdditionalForms/OrdersReportF.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/LibraryDBproject/LDBproj/AdditionalForms/OrdersReportF.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/LibraryDBproject/LDBproj/Entities/Order.cs b/LibraryDBproject/LDBproj/Entities/Order.cs index 0c25bdd..41602c7 100644 --- a/LibraryDBproject/LDBproj/Entities/Order.cs +++ b/LibraryDBproject/LDBproj/Entities/Order.cs @@ -24,4 +24,16 @@ public class Order BorrowDate = borrow }; } + + public static Order NewOrder(TemprOrderReg order, IEnumerable regs) + { + return new Order + { + OrderID = order.OrderID, + CardID = order.CardID, + LibrarianID = order.LibrarianID, + Registrations = regs, + BorrowDate= order.BorrowDate + }; + } } diff --git a/LibraryDBproject/LDBproj/Entities/TemprOrderReg.cs b/LibraryDBproject/LDBproj/Entities/TemprOrderReg.cs index fcadf00..e46fdb4 100644 --- a/LibraryDBproject/LDBproj/Entities/TemprOrderReg.cs +++ b/LibraryDBproject/LDBproj/Entities/TemprOrderReg.cs @@ -1,6 +1,6 @@ namespace LDBproject.Entities; -internal class TemprOrderReg +public class TemprOrderReg { // from Order class public int OrderID { get; private set; } diff --git a/LibraryDBproject/LDBproj/MainForm.cs b/LibraryDBproject/LDBproj/MainForm.cs index 06e1af7..4e4fc4d 100644 --- a/LibraryDBproject/LDBproj/MainForm.cs +++ b/LibraryDBproject/LDBproj/MainForm.cs @@ -96,7 +96,7 @@ public partial class MainForm : Form { try { - + _container.Resolve().ShowDialog(); } catch (Exception ex) { @@ -118,4 +118,3 @@ public partial class MainForm : Form } } } - diff --git a/LibraryDBproject/LDBproj/Reports/TableReport.cs b/LibraryDBproject/LDBproj/Reports/TableReport.cs new file mode 100644 index 0000000..5ba5b24 --- /dev/null +++ b/LibraryDBproject/LDBproj/Reports/TableReport.cs @@ -0,0 +1,61 @@ +using Microsoft.Extensions.Logging; +using LDBproject.Repositories; + +namespace LDBproject.Reports +{ + internal class TableReport + { + private readonly IOrderRep _orderRep; + private readonly ILogger _logger; + internal static readonly string[] item = { "Librarian ID", "Card ID", "Borrow Date", "Book ID", "Note" }; + + public TableReport(IOrderRep orderRep, ILogger logger) + { + _orderRep = orderRep ?? throw new ArgumentNullException(nameof(orderRep)); + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + + public bool CreateTable(string filePath, DateTime startDate, DateTime endDate) + { + try + { + new ExcelBuilder(filePath) + .AddHeader("Report about borrowed books", 0, 5) // Updated header + .AddParagraph($"Period: {startDate:yyyy-MM-dd} - {endDate:yyyy-MM-dd}", 0) + .AddTable(new[] { 4, 4, 7, 4, 7 }, GetData(startDate, endDate)) // Updated column widths + .Build(); + return true; + } + catch (Exception ex) + { + _logger.LogError(ex, "Error while forming document"); + return false; + } + } + private List GetData(DateTime startDate, DateTime endDate) + { + var result = new List { item }; + var orders = _orderRep.GetOrdersInfo(); + + var flattenedData = orders + .SelectMany(order => order.Registrations + .Select(reg => new { order.LibrarianID, order.CardID, + order.BorrowDate, reg.BookID, reg.Note })) + .Where(x => startDate <= x.BorrowDate && x.BorrowDate <= endDate) + .ToList(); + + result.AddRange(flattenedData.Select(x => new string[] + { + x.LibrarianID.ToString(), + x.CardID.ToString(), + x.BorrowDate.ToString("yyyy-MM-dd"), + x.BookID.ToString(), + x.Note + }).ToList()); + int totalBookCount = flattenedData.Count; + result.Add(new[] { "Total Books:", "", "", totalBookCount.ToString(), "" }); + + return result; + } + } +} diff --git a/LibraryDBproject/LDBproj/Repositories/IOrderRep.cs b/LibraryDBproject/LDBproj/Repositories/IOrderRep.cs index cde2b59..e8d419b 100644 --- a/LibraryDBproject/LDBproj/Repositories/IOrderRep.cs +++ b/LibraryDBproject/LDBproj/Repositories/IOrderRep.cs @@ -4,8 +4,7 @@ namespace LDBproject.Repositories; public interface IOrderRep { - IEnumerable GetOrdersInfo( - int? librarianID = null, int? orderID = null, int? customerID = null); + IEnumerable GetOrdersInfo(); void CreateOrder(Order order); diff --git a/LibraryDBproject/LDBproj/Repositories/Implementations/OrderR.cs b/LibraryDBproject/LDBproj/Repositories/Implementations/OrderR.cs index 271a0f6..13f6ea0 100644 --- a/LibraryDBproject/LDBproj/Repositories/Implementations/OrderR.cs +++ b/LibraryDBproject/LDBproj/Repositories/Implementations/OrderR.cs @@ -130,21 +130,20 @@ public class OrderR : IOrderRep } } - // ----------------------------- [ REVIEWED (waits for further editing) ] ------------------------------- - - public IEnumerable GetOrdersInfo(int? orderID = null, int ? librarianID = null, int? customerID = null) + public IEnumerable GetOrdersInfo() { - _logger.LogInformation("< Getting all ORDERS >"); + _logger.LogInformation("< Getting ORDERS based on a date >"); try { using var connection = new NpgsqlConnection(_connectionString.ConnectionString); connection.Open(); - var querySelectAll = @"SELECT * FROM Orders"; - var orders = connection.Query(querySelectAll); + var querySelectAll = @"SELECT orders.*, regs.BookID, regs.Note FROM Orders orders + INNER JOIN Registrations regs ON regs.OrderID = orders.OrderID"; + var orders = connection.Query(querySelectAll); _logger.LogDebug("Aimed objects: {json}", JsonConvert.SerializeObject(orders)); - - return orders; + return orders.GroupBy(x => x.OrderID, y => y, (key, value) => Order.NewOrder(value.First(), + value.Select(z => Registration.OrderReg(z.OrderID, z.BookID, z.Note)))).ToList(); } catch (Exception ex) { -- 2.25.1

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 NZGQBZ!b5IR{|CAM4tW3o literal 0 HcmV?d00001 diff --git a/LibraryDBproject/LDBproj/RscImages/UpdListFrameCover.png b/LibraryDBproject/LDBproj/RscImages/UpdListFrameCover.png new file mode 100644 index 0000000000000000000000000000000000000000..f59e3500f66e257d89bf5eda7d18d266f85862a6 GIT binary patch literal 91031 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�l~Q>8#@ zLbK$jwIu~=l@x%0>U#I*E3rJA z{~sJu{c()OASeV27iKIsU4PN$(N4aNlmumm%*8rim%nW~ry;yizn{9li)f7ZbT4sV zxIKg5m{jSK8Npcmb4_N@qzIr^bQFsJGXl~5^KIoo`hSN2eg35jDkT3314UK-6^4I> zfg%X#KmQ8DzrygZF#MMS{|^Ym8wOqdYi}wZe!CqQ;90(0FNXaw_lUuBqGQ>!3$uEB zWVyUvAE#`7@@nkyeB@q6maFu}@=+r~!|^jN4oG#WtF-*)!ITTcvv_;KFp)WBXPr^Q zO@l&iobh;u!IX|`zE{yALtDPbR4e}NQTef;!CJSATp=AC7xXPQP6f?scYbi(ABLYU z42-07? z^xu!(s&M4vUgz@+ylt=Of1D;ud9(yg_R0w|6LwGX42KopE*c`zRVyxhFj`Msn*R{U zFsD2fIu^8d`!URj$pe!8N`v_pcX8yy`9-1^UQ~ZG_oGx(j2@G&xo_G8o){;zY&}zt zHyJIB>L}gsYTX#z4fuSYlsXX@)Se-TeaHmwsJ?J(U%%>!I1IH~H;Sn-k1Rsj^uO0P zp>yVGF4l$koC`!bMgygBdDGKGnS=n-yVFPApT{ld&UUXu6eKrcu7BHIwRsb>Mxc67 zzCV_=tlPKL#(b$|)0O`&g8@z!ByFbUmBGcb2`BG60TW`L20Z zx37bn^OCr_eOhu{QJ#|j#`?}4*VS^__m1l!xr`?5VmctKX4lZH^JMeH1;z-j%EnDs z_{vZ;OVSK=Au~M z{)3WAtReB~oUfc*{fkCt2`^dp(?O4Fu^Fykx}lj={g|{%CH?}@A8%;hCEw#s(*^5(i?^!TM?Rl+IlZuyD5UPG9%R&rgfF@}0)S!MeL^pq%9;Cl zDV=a5t_Hq+lc^x7>Pi(!q0g9T=aPpd7hO4xjbIEv`XJv)#h7J_iA90^D zLBQwXL%qXdt(B$b;iS(?vU^Lpw#IztTH<{~VR)EapU`DBA0rVv@hWW>#-8s*vhb}a zC@H8lJX$+oSFH`y8A>Gur}T16&%#gdg$51eDKD) zO#kq{rD4`X%zfy1*7^tPXLM~!xX?ee>}y;^Lc-aqT#pMTY23JlO%R*No)h2t8n}R_ z+Iv&3j8`=l!8vGgS)A+I&ga>4tkAhgNnw1i{fDBX-2uvC@q!sCT|xt^W9xt$62KbL zlZFSX`7&N0W{4K6@8+C|iY3myC@}!#V5}jzN z1;M>jDK*FE$Za!ZQyMQ%Ql?AoI}REJ-{0uHc5x{@vBZkmeFyiJ?yczHu)J);ilwd0 z8z~@bDUMdEq=JC#+yAPip7gT7(^08aWJ3l_-vS*aE7Lwc;ofQe(EeEl`6oroXyFOL zIlmRjh22k}#W4`am)V$mIj$9SPu0$b@98v6eVSC9C)b?n<@BqbUfjJhcdoS>83+?B@|%<&Z9mL=DR{PPrE=0bV6NM$XVn>a)eJm(D?KyjXD3@ntRNjP5BONOCqq!tx2O(tEOGG3Y-i$IN^mZ>kD=sD8`A}T<6 z=tiQJTUjt!nRy-}=wFDB0OvcWx2uK2!5_|-n>0+fx-Y^joC;T7l9|*ZN1zyvAYaS+ zPg@plJjb;S+A!!1rpg!E_ly^yjC197zmVv0rACaU99qjXV*iz+5g71aoX*|IuC(|p z^g%LwCBI1z82n}@^j$8E&@CB{e;Cdap-7_I#iY!gKW+?91E!!ZKp_b>398H#EPm`~I|| zelal1%2qgP%)nPM4bF6EIY7h1>f&@bS4juoU39jMhH2U-#Q^M@aR7|JvFB)9`z3G9 zy#L{ILuTD^k9`ZHUqG;K!6#P+56R+^8XIJAs3zHPadHH`duP%Q_(Nu!X=pBcWH#Mz zPW1E+;k=W^Ij*;4azJf9pC>cj+$W2Z&#`OfrJTAo=|8(txP{pPT?FA#Vw0+UnqH&B zy5*ux*I>JoS!NON=fyM9u4={b&lA}!P3SO*gzTuM91ZR^bq zm;`*M=cGo9>=gt6%>7vUch9*>S{G|w5tOdIAJ5|FCI42dYkMp1w*(2sP0zVnj+jk% zgaQzsPXmM|cV7?Eq3?F!Sco|-o`t_h$0=25g>B(8-A+78KI>n91%pYECH5Jl`mzh6 znLEBJg96tp;iqR}XYYyqz4ihRPA%S(1x)n%WZuytb$mo&-c*)^464`yhgdN8Qxh0S z&11pnOx(bs0XIfpXG zJLlIjkBDdAS}px+qsrX(iQcVml39!7x(fK*>5&*XM5nOtgqcB-CTbB#kL`@YXJVKB zCS8e4JROI*s`iby&PQW@`S-VGGq8aI!0R}yj~bKEEu6v{7pAiRmZ+?d*w*Z-j4qu` zz4x<+W{t-sCxGP-fzV9nme8WALPP3Y>W*7?oJ1d&moK9WAYlmseEJUSoSHyo_7?k; z(IEmL@>&x8l!~L8YfWSKO3~WLgY`n#eAeQ0VFN!9Rgio}6#6F=l};8)+k|2(@46^W zF>azlvpdU1QXTNd7+r|o0N%sfYtPowbPe|de{4o4aT z;l*Vwrrqz*-9F=W$G_vAW%m7zMB>AT;YANbPYJqPHZKCCAE4@ zXRY>HlKt55x>S^2K0EkVkbi#oKGNln6a(|~1z(Zg)TfT9CzL-+SY?}wcKYe@<38y@ zxDCQ?2oVX75KORZ@SFo3pBSNdKUR$1kgk>WhIw|bEymU!{3wJ-V&CbZmv>HHT^Htm zjwP55seVe@C6EAC0DL1#N`;9TJ)*eY&2N;B5n`kVY943buS%z;?INrQd{uz=mK03w z*@f=D&Z6{^Shd@)U2ivE85@WA9KC`J z7|0pc@TvcYwP@!ybOKJJw_59;whX5T7}rf=t}9nDg5%~z3$CE&EswMdwAY0NWRJJ>0w{yZWTwky55En94MYd{?6Wkx_uS*?ZwmX98k6TZ zCt-8Vz_H+HuzVE{^^mC>B=EUY2e9;q_6g(Cgbil;(eq;pr{dMsS<8!xfZ4c4$@c2; z8C7VMzt2hNxrg8KQq*Z9xJF=Q@Uz`z7uRIH8|Wl1wyWCcJtsKvC^EPqxiOT~O;U6} zN-5x-1MpO&><>lCq5M~f3ZF4NoOkkp@%egUU!OZzPH|KX$mgY4Ga)KaFr-j|3n=k( zT924{A|J)6TD4tb;__V9sk^^_cLVXhDWTgRjhg(Wb+$UR6oP@T;iO$};C`@MQyIL-Z)UsS<4b)@8SP^L?YgSAcC{GN|TV zc{b+E>BCsj_{QFCbR8mU4**U!l;^Sep}X83zjJ0a_EPC)6EH25P{l|JRh1V8;k#ds zIo~(_mD7TP4o=V)HY?1|gs9~pOhm#W2 z?gsU4gnq{!Y$cmPk;qEU>F{eozaP0M0qEugGkrj27xVEOT% zm{Zh1sLMo&C>j|P<}l}IYz>F=L^)8he?HLFdL-}UIstEu8x^QPB!Yt>1vZamp*WRH zgV#Y#uRuDQfg(uOLDWtizBv7hu={gGtJoS?PUpkP;o=xnheVxCyDF4dDo#=?NESaj zd^o=*XM+C4m;Tej5TnB=KF|qLm?7~wn=iTxpW3wEHbIvz`8J3U2hX7Dd?CSA$NZy~ zVVaA4yI(M>j3C%Dm7gxba3tuUi*P_>R|ha3i<(}6*lfk$T)RIDj}{r|ya6#*gYUBT z?iu;%mp|H5wqVh94g_|G%br<5-LGl^&X@U{)y(7ncPQ zE7r$u^2J*i0tW|Db;m1QR-GflR8WUUp_xKADwRJDbcH%ZnA2Tu1g^LwqH4Ge;A26{ z8|X~`Q1K)2TW5VW#*QRVGNPD0lxe)`t{almTJwL*vm&_T;EG-;xR4C*O`-{1$^PBD z%`zL@#E;mCdrr3Jdw}8#Y(r@`)si}==1O15kmv(Rwgh|@qhwQp_c;9}Rdlb)wJ45T zwZ`|9^XTtxe<;m>HP%5l{MzVKzVkkF0%La;klJJ)mR{nu-Q?xkCXihOH^KhtT*R=@ zKJ@4`YY?gg&gY-$$F*$5?O*d8N$_nwiH9I*6nZG!O4vHZ=2{EYph0q==x0mOPA&}0 z3`J+^>VsD*Dc74>0cU_~gyiwngSA;#ayW!CyFI!qy_nFmQ!#rffT@Jf{vxnQXcW6i z0;f)R;gO`9l=I(O2bC@vwuYpKPwMR}_q-3E2#z^Rneo6BUlJ6yz=V{TLXT7969tEu zLk;YY1@X<mq zJ3Fc~d2W4g{p`t=eA^EjAa6FJ%nWLRFcudy zEH2`Y2?bJVLU1J!m%XV;Q44m9scxuz;J!F1;goaq$w%HoiEbKkZ`i)6H-5Jg zUi~FX17$`G-M4*~ThQGE!fzL`0mm}$_Bk4(nej~owbYjbP{vHDn14l*`b4iHh(;_I z@=6zs4PV@UasY*~i==SzeFvWxG4{|%HlIWIvOOLXlb%*XcKKdy|2Pa>4?AD!6M z`^qIv^{yi+eN8OHFaB<~y7o9>@Z4)5eq)%3@ByMWdV)X>-|2-baV>rnH-H;JF*UvW zTHGBeE}jFQ3S#}GJkz{gAh6|d?}3fwmW|-F_Mi%Fb8)1*zSOtGIleUqxPiz#fw#HW zxun6-H<%@ATLXo&%;Dh&Sx(kNCcs=JRIpxsgxnSRhGy*@a~@Eiuz_}c$%c5p1k>ct z6ekWQ@r<4;c>VfR`?&e*!)D1sL&1DSK49;iDBe(WKvc1}uz`4O#Pt&;SRhHj5?=9d z@oNT=Z=dBc&1dFrnPM&-oSF{mk{O zg7uS=&z@UII=oWW;24nn>%j2FLHyLReA(u`F&vy~2=h*fppQPBUqa44VHFW!8&zS= zyFont&f$tIv%-0C_AbjOomX<^7SiZDTUNdencDHfX@ipDomhIEXTwtVuQtG*2yV{z zNm_+hivXj~_`o=C9XsAQHU%dXaZhUD9F7jbG4BNB=yh|DV%TJ~E0)gU)w7zRMo5)H zHxbHqy?VN>aisr>fK>3gea7axVQp^G4{rqCNoOQfnxCk5_L=edRF=4Tz0LPp{Av`K z^iB>LLjsR>(D&->){T8nG%tEw-|CETAGZYx$rt_6^UnlPRG6~6am+ZN4q z9Zx&=OAU2yl{*qH#YEWY`ZZ|edq2@B)7?MBeAq&6x%_y!ot$!7T90b8Z+k~eM|g*o zdCY9c&+ucz-K%FJ#huwTH5yjAmZQ&pFjkq2j1<}V(c0EI*%os+(QPB>8Y6ttu;M!A!r9&4xE(&f9p#lrM-5}6 z`sX@Lw}y0qctP5sgs=5b1F>c)1CZ>t(!I_3j(x77R2)B0pVe^s@kFt!!`*Cbg}Z|n z@0_EYwyVDFj^x&C76kWY1Lpdf{yG49U>D~b8L!q>jiK~jRFx22DY;c;1&|T_9UvpX z^+ZeSoSierU-~tS4BPB)G{6r`BH>P}qqAH`JTsa!o35e+wRzbq^diQIkqwuY)OJ}? zL!J`ARV%X|c?s_*mmFdQ9X`>hF~oC0lPu@*bAP4U zL)yeUWHs4}6C+mUfr>!`Aj#LI=@P<)#kUxLE(0+oyn3%7J8hqf28cZStA^w^?MIM| zd*{ev0K1lT*KE`xA^fpXU*E*ZFYV2Tn8}Yx<|nYJW!ZY^x07s7g8w;1+I4KlIg?t$ z)f>7v#hDQch*u%IitRIG6$LXWMM3b4nsI!)@n>R67I(^f`WMO)cAJ z*gfnx22>GXB%Hn-iwKMFQu9d5H^ad?P|`;$0x=YZ%vHLaB}h`r|{ooMoRP_-~-?G)5(bMeUs>r5)H^e_*$=1tsAA+=<0M)`RT!6FC_;2oaENnlL9aDQDZ3!3pNh~ncRnB&s{X@9?Q-b$9h`@SW;QwHXchAESF z9XdzOamgPo0wfS5;ur|GZzDe-evb#8?Pk`SeDE}$tugE4xECfxsf`Q4@sOEz?O)Op zHdy0WTTGkut8bO)6v~E{FlFElxu}j9z1=-+cPW^a2LPm&7iM7Jt0iYLTGBAO#5--) zvmL?h-2_Np4rPCD_ISCkaboIYwC}R5r%Cd@D9*fGy-f)2HVgKlkI%PDai8w;TCd4} zo7X3cY>O}uyAP=Ge#19sJ?|@;wA`2SB)V~ASoE2EV44jkqN%j{g?LH`&yU>QJ~kX_s05Pg21xhC`DBeQ1RN zcO~Mh;>h_^z}{Ubnt>M}tFi<*;+ zLn7WiLT2lbn5z_sS=Mv+pEHbAv;*I#6X`o58tK1{Wq#r*;~I63*MIU|a#|CIUB;{9 zOZ@_1UAj=I|B=x3i+^(J9@)Tn#xQy{?Dmu?uZY1JNUGRTeEIU7UoM14=a%cju87qL z_>RM18FBfjI8-aS7KB!-s<}jdt9;VzTZdW>UXgWV1gSy6z4^=BT~C}2)z9}20j44; z*KknyF$%=J?uX^;_dc7EG+4r_yVa>AOwkOuto>v+$&>n7^Fk)>_IKU zJxj}+o%4JAF$Y@4n=W_#&X#2X*AUVx)O6WyE?n@@m&#dVmO4cq*c53!8lf5Tx^=|j z6#)AL1@`lewli|Er(%1Fx6gK2HuXFY2!T&H#bm<1l^Tk*JLm6gqPTaPt*5~yQj~f3 z9ANC;X4=UtBgIbvmFMH;!)Qh`^PG1! zJ(?ZPs?X)3Tf^+t)&T6V6dKT%RGl53S+lWZZOWY2EyCObpOlTKzKIwfoXjX{)H%1bjxDH#>Rs;zfpG5tN`V&q!8;*-S-x=}2MyG`pU5!wuSZUV!uV@y*vOis zCzCmOuAu7((yfFZN=?@QOKw!Op=NR)PS^iUf!~7uXOrPAh=MJc;Pq`FAi!MgCP*qu zW>Bk?8sM5LqjozE)q|f}t`Q8V{Dp&GW-lps}p)4Qenj*8uezJrwZ`ufu-eZZ*oPZQq)6|UtCTu&38*H@&zxEu(UF+7RM#HS$IT#11pwfWg#2{W4K{q;xMqB6|Gc%AU zxQr5RPbn|VOnWrkxd-Bpn`G^4#b~T_WCIGldV^D@ppd}lHW}2_z@_tA;KBUNv~qq} z6j;a@EJ~9Sbug}>BCyz0E*NjPGIs88adV$cs{>qaCNdURu1)5#egMPK=j+%SuS?0S zRBjN2kn05~I(l99>=iokarUavg(LI<=#3fsV^Y^184gXE0@{-YQ5x-fj{yY2HBkDv zq80>TZibjdaLv}>%mm8t?B~}bfmy0H-%0 z5@)Or4h=&!CMBm?C20NxaR0=!C-^!9?FS(R-x%JDLK) zMQk#i0dgr^LRAFvV)S0#aT*YT!rv0J?#5y{&u9Xo8^NJ$%$R@15OE(J+-wJ_1Y45k z?{V}mB;%-=JQ!*|)a!IW2xI6fe}NFjgi4G;4w`Kdr??xja-bw|smE+G;)-3#D(X^a zDQ1R!?&q>-nS*1t#k!-Bs3WVd?NSa)>xZ`)oF~?Y<;8H5lT4-HGi! zvI*oh8W5!5l;2vY*l~9Nx4yAaQFxa)VljQHz$z!UBf5&h9DIF&oWd(JxG&sI69)eH31!P{d?=Y(TFPUDlc`;R;8TR!%O zARRNr;}DJPzb_t9n=-S+IV(0E!RgJF9VR2lzu+1DZ7!)g#m=>SU5y*o9QT=4^EO&y z&HUuEl<--I+iG!|UQ4Vx8>b|*mm2IYDG8YsN{t;B-s7;0?AbHQlhCi_F*p**^U}B7 zd|;LEup-8CHzKLi(`EtUZ;?>2#+{Da@*D!VUKG@eOQ!?D2pawAN`a#ZkBs_?sOze6MV-8a5M<2yH2Cpni5r81OI&NheTRq^m|n>2 zK7_m^3Reb0Ihvu<`Ay(hD9M;lE<%o$YQhZj#7N?zq}oL!z21#%lZ{hGhVEMgX+lJQ zmk4L!QDs#Fk7F_}dP&U5-s(8(GqFGesxCRCF2|=d*Za9&$|w;MKsW>FqTPoQ6Ueq8 zo&$!bzq22IDfkZj7Z)g>t!ZafjqkHd$q>SWF=q(u@9q+q_uNp`_rZNyv<&Rp+UI_s zL#9C`0?g1+>`K-fMoa%2)>%p=!-4L*ZOruD>`Demv~ zA1^UY=zB!%E9{;$&Uy&hAF2noQKtt%W3b!zIGp}F5aW9U;I-jtc`W0V`sfQK z&8{Q}DQ^CiH%Kx=4>UJu%bT(rCtqOzP{FW!XI`Cs=#H!rf@XN8qvS5`?mygab@x2z zm<};UwgqDRsB`Yi*C5+a_E5%B|T(|97T=oYW13wgHpth zYn}nUVW;-467x*Sp*YdyqhWiQo7rzney+~lOX|o*4k;iyhN`fW<=qyA&nt^dzSM)L zBkt>VARoI`1-GtN!gscO*_Rtnw`qI|%b41j=Zxa!Z zXPrs%z6<7T3dur0@j{!i@=0kF;!1? zWbClR;yYiijS$m2T=WT!MQ#AuAymdFe^x^eEHrnvy`ACxn8XbM_4FJ&5XluqNQa9+ zL$?@`$t2(C4tcshN4~MZTVF8CfQ>inUv=j``PCTB2eS++L0I}e8}gsoJ|@|4cKNqA zVI8iQc22*Fm@feRbs+0iQbi*Ql#|>w<@sxcr~2C&WIT*zL{b^D`3n_>*^GF1yWt>W zQovU=my{T^UdBFtRDGi-yj}x7nnA%;)a9DH*a*3Ttx)gD0$y=&p2L!8+;IqAI-KUI z$3igYa|~M?4+_btJnjKHJZS8z;RomUIuiS9DklUN2>ud1g5oPY6MrVBKg~SzjtJ!Y zGD6&n`r~}S0kfP^f*%@D9WOqzMQR7K>xg{trJic-w>U6#z5)#LK zoK`%~1;wE3$&MnLtKm-;U~I_eOSbRSxCxL~Y!e#W@dGRjk1I{w{Y%|Njr|{O3XuOt z4d3Yb);6Op`czbhz*Ld!Se!-H1POUiFO*m4`?%{1s>G60N9QHVn-zlxCA*)=l z?UU-7N7il1V!7V@DbAlR=_?QZhgDI956ZPTaiaR>4<=uZ+bMpf8{ig{3$D*#D{Wz^i!vM*MOzZ?Pj8rsi1GFd4ISOB2(>*_kGLl?6`D(4C@{RY_WmIba7z|ZSXSp8u z`TEg1J75n?%}R#a<4!6ud#BTa$yRD2Kt7_@o8P5Bjerfd(GOmy^u><$zMFO>c6T{p4 z0j|;(Zj(~e2wsuIpY^a&`T(pdDH}26qvLf0HQLutq-1A*2gDv}a5y!rx@nv2@{ut) zewkhSxc9bsXpqyY6Wk+n5EjKF#9VU&RjNyH|I3Fup#er>I}44oWByF}6)nf%V_(G6 z4$;r9RF}?^IlCob2~!(4CtN#=dG)K%l|vKyRA)@3C-+vY_{ZMFa$!F-09yPEIiWSD zktklYt4Vp~rEW$0xs446s=jj~VC|B}d1|9ljF>NC79-fSOREwpK8#pIT#oA1m;T_< z9Tl{nnf%~2iBzLVcyy`RU0QRzBkRS#bjzuYj0OaT(etCao3ANq8u6w)T^u^O@l5^T z&C8qTkG8fO{k(i*JUpc&Zi4xo!DSK3%7@>>8HMX5c~5<6UEc^4wgw9!QKyfgkFdd_ zZ(u0PrJ9R}MorG9>Pt^~vna33yRxB!uuiA{#L^F*ilOTdOKl&qfQ-@y>k?j{y3Kt3 zEPK8aUQyK!5jo8&CTE2Gv3HFKZN`@ zhXVIbSos(8Bs=P@{05PJ-RSpWhn`g<_WW7(X#y12+ZmGE&`E(6<;?CeSir9*W21tb zIT{Gcq`nBJl@!e@L zE=B$nG$0e0;5mX(<`a`caddwEGQjCDsnoAqCPlyHxc6Y-az#i|KDkcUG#5!iwy~RN z7biOfTeM;miD?YirB+n@%?Z@vwxeK#$3O6%+sJ#aL=w$vbx$zAxZ+i+6`++4Sm6@l zd4w)NIqWt7#TPTmqvW2*buSoETpPK6Ac21MpuWU0T5gHs&*1X#{Q{FDwtPM6+Nhf$ zjd%}3ut*Y*>RVouWFCHV3RSy++p&vU*ZPOF1r$Au3N)_N4-1m(#er$#P6yHP0X*JD z8)x*U^ZtNG5&v-|{lKYm>PI7$k15&4m}O4a;oJY5_Sr}zV%naYjrQ4S#(@-KxU5uH zY2@2O^eqr;P;PY5Q6d2o*7_&wM8A0WlXXfkJnM+C*wG>c1sUf!{!|QAr9V2$lw4mh z?PEgH$0b~7ld2csWi+tp$MwhH)6Omf`+zykpVhfnm2o6U)eT9Q=b4=cEgll3H!`tR~66uLyv z$Y|X#BHu|)c9Ne7rl?YPXGDU z*xHEK`r4APHst%J!MiV(Y$aZErM;>w_HLTF->^fN#{bLFENtSH?lEwPkhpfF$aIUa~1cBv)U#P(#5v?UfV=nE_5Mcp*8(o zlmS;x11_sE7TcMT@N$4i6Xfk zEcF6()PX4CQ{g)OB>wh{-<21P7vdn=+ycoKT+XUWQo!%!S{by*FRcASV4VCx+;{k| z3>AiuTPy#2!gB8ewex_VLCB|q?9bGdB&Kh-r73bW0It`if|YZ18^5j~FfRW=B+Rzb zVu4?X+T~vA707CE7n1D3fcG3lAac2a%#woAY<}X?xOdMW@2>l-pOdAYm%g;cN?N&Q zj81(0YSN9B{X5CEdW(cpg)TUK|;$j=M(Ti6MqPzTQtb0h)D&8UDa-J~0} zTH>4eSzPv98xG)~VXzHWlTWaDxxIb1^``%dpfak2JBI-i>MeAboEL@4FQk_{pWh6t z@yD&EsYl;aRt@-2rgwbWpOgS^&R7KjGl0>TP0(6Q|`Jm-s9RSKeCIcoyGtedpP z$iLQi%pEX&vVF&wQb%9)_(^6>_8P9T+aIxPu+E=tzSX#YC2IaRBUPwk z)`5Jnl5mIy(eVT(;$;*@H^fwpk$^j$6q)$7IAr2Cd-PMDP;@&ko8imwf>od4OIw_D z1KU?=2A90jS2Fu2V0{1bp_?B(Pw(Veq+$AzzU1eSM5m*q>Qz;Y`` zE}YzzLyR>5@OAcZsiqdCM22R2_XvMn191H5iK|c3Nzjl?u&=ayYwYPa_6hLviDO=i?LPp2h=^%{?87d%i_zZ#@@|QB z3(bBp7+L&+cEr~M9<(A48IwJuoTaMQMdGX)1>;Af>LYaC?^K<#$d34+Fv^8mqf%y1 z=j)r{&V@sgCAbT&#*i7XlG@EzM{pFnK~WDPo9%&f@{lX5@-+Hc9CyYs#6cEw6a$qX zKIl~p9pA2~*?(tA@{oNrocK^>KCaQ{&I1CB6rGw~ej5UZ;f}#SYEKdb#w|0utO!g~ z-5~f8f#4@VAzPwJg&>)N=-9D^=U$ZBG|9+(0ZDSN&1M4a@RoP_#U`~Hw+umiIZJbg zK6)0&z>yjP8!=Qe-hsWuBuDPO{pX*LLq3TRJzs`nG5SE<|8*<#!%UFsBUa9)S4&Za z5{(4T>0+)~Ficw1{uTfvP{`26d5DsE`^vIQhk|%w45uzo?8W}9s{1|72DU2)iu0Jq z054BZ2x!XGaph*s6^PG`YSbxoQI>g6S( zs=Fm_Xo{xxvH4YO7taTwUPW5oUJ`(>(jb<$Wy^KP58n}M-CpxWd=a+30I<<$*j_Fw5MhR@;Hv1- z&A_4PnFHeJb#f#g?Rg1)9CzvN2FCksFf3G z{V$s#;nQ^UJ-gus2z5qqp+i;~LkxgKVCz07Cjvo}H)}v;B zMJ2=M@#=Zv0)B-+K^8Yi--0SG*XvT8$6H&Q89l^GLL|~jf*89O^V3jf&VMp<0MmK~ z)2eqqFyF;*(NbLxu85M`uA7uDz??7OqA=&68-NryC(kqenkPY%w)^$t(rd>SF+`}0 zE#&lZ-&XbY^8llir!6u&HqXonTYIWbKVucr%{5Ji0jcf->m=?BhP5!t#m{@K!T-q9 zCS{0wGP^HdLamu2!(7G<)7m_DHHPau>D^T8_JDxx+ikl*StUdU@|X5|4gf1Yx>ZCr z$rihPReJb%QD}$!K#Sn^`9FSDQW1e!5!?G!bq|PRQRlAo%~>1&J_1daq(!!Y_kWt) z8#Qx)*oGWQ7_@5=wGE{TOj}gvB4pjkGb#@}41z6IhOAKj48;7@ywu+B-ZM+#Pw^!6 zmj!^O!PUpO70L3&8NnF#Mhnm7G=PHSf`TyGiAWfqAIC=yRktEx0~?AWL1{pM!Z2fg z(v3=+5U)vNxb%CGy=o40T;WP|8D!w{=iS{CVIa2{F#Brvlb*t^$_HWPE~r_)*|?J} zK2YZ9BLEDUK@nL`h)?f;8Hn!WF{IHZl>K%1v+jai*yKI5%n6lLQM z!~!g3V}4X0ajrScu-a$;C&Eh=-~Fy^oIcJ>WTsF4(J2B)L<50kS5yw$>(<7#cIeqO zx<3C7#HR+Z3>SV2RRUxV^+$ZYWwjk$H;7hqA-T3r5r10+Fr29y#|ERe3y_TDJn7oc z)coY6_8x&VQoB!Y^f=T6Zw=rP9x6OkMjx`t1E2qSNPUVAvl$^wZUv=U9RSNZxe=V1 zov%>Brz%_l>rAM;%bYZC0bSHCY9!uK{rqy1*9b83kw!DSjf= zt7Pgx>DT&YsoY7+pNU8pCgbWJ!2gDdJOBHBoSK7}4fZ2^e&Wc4J`(Vj+sIk9|7kB{ zL{SkD$WZHzi)6ucW^6$K!r&cB9@S~5nn&P>6tv+mTs*kN$4qu4{nwp>#`&6y+K#)6 z16ZS`{^VkVXJ9%vaZ=+_ZZjdPjG*EzJdcb&r3z&0VsTF-c&W8i%DFj5ucxx}QWDDI z0A1tjDS}o6C_jtX_XGs%29hhm?_4cnvo&Z6Wg5%F5K*~89NnYGT=uPwr|?{=p2-}2 zA6q?k`*BUry=S)u$94^oe+be6??sC7Z9Mc5`6##vOo|hs#{o}g1F7`&&4P-ZvV=Mk z>|@W*<~hwddi0!{{BnOQ=6s>IvX%0LelDj14%VvmCac))Hk#1KqgC`8(E`-^( zWo7Ga8tR3+b(a311SFX@iJcB z9^41#+XC{{F%B_KKT}nI9a!7O%S8lGnwYtOIwLVKXv?RF&B7>pak%?~Ax>AsoR09> zwZ03`m&XM}zqv?j>i7I6$rw=>8i-zA>V+61j2-lYY_~$*pM))sOOKn}Wk0PnkADoN zXp-}#xNuNmu_h$9l^KcKpp&DEjNRq58}Fr>P0H}az-bcQx7|+j3~;02pomy{8>2cvenUF5c8eR9HJ%5pn zi<@!V2uAQR3)W-gS(ETD+R?P^iY`mSp(>r;W` zR{NiQdUg_ohKdAD_f-kDB?xoE$`WF&oWLwY?EqeWxgHC8=C{O{2E;KUM3&Se18J}+ z-#mtV<^fbDZAx#mKu<#gGis-aw<;kjPn97#`RhKitN$II;eh%*`x=KA=gGSvLmmM| zy%iCYGxv?iUN7XL%((*<{M@=3p=7G=CM4X;U<9T9jD&MJME@xWqN}dQq>Hqop+vBt zLQ?QTTjr;(pffRT*RD#_T=_mDv`Dv%P2?rhxjo#ij5>?4#YH#;A(XHKZ_AGVHDf9Q zh0ZJP_bIbafx6NnC$!+%q0`^Knb=mqYCh-wGy;)9hPS!fuh|5Th{*aOuG5MaN0_A0 z)XW(Q90$3k1pl|5u-^>x0Qv#6bJ4VTi7^)>lLV5v7ZsB=;4H}^t5G}i>L1cx2E0qj zt@(FElvdJ$7NR*UJ~(Yh71RBj7wkYE_^l>&D0+b3 z%3v1kqRc@fBfz!ERCu;*T*UB`x|)3HfBehK7?_YK=46X(B$={Jp48j~lpcvq#>;V` zuqg}3IsfaopA+W6m(fWW*TgyEO*6Mwx^Q~l?SDCbh4C&M3Yapc%upyv*fuvYfHs_* zi?}_vL8l`H;o;!=C>BVzL{|v_QHIg%zlPnh=WSzPQiX`_X`hm8PQs2V&+}RIl63^C z*qlRLZu4u^00b)nOi)WW;RzMmxKQpb{FxUbIg|gbs;=e|6u(5_M7TqR?VM)}`Na%F zts7^0qA|3kT~N6MA|+`K18p5%E*RR)JSbHB=S5SY@;tFB+YJ~}?cc_){fDU?U{3Ra zTc?>DJ@5Q6a6?TJoP%8XmfA+}AdT~67EZAiE^`GXGlSH$L^9t4KKP&eQ?vRF{HgoJ z(S;mcca09&p@;|i@Pex%>+sWncoaEjhT+Evx(VWpYJ!w9esb!JQFD$R`C~2o3Y=S|nfg{5NTpnEcWK!l#7*lwDJh}^ z1(6jURYKwngGm{_K4;j)3y9ELsJ36r)*SgDM2WI;@qp34(vVCSo({s+UPmH`m7QdF zf0q{+DW#A0Kth!}Bo%kjW#o`^Q~GX%6PM$0*Qa}6E_!gemPN!owuU(%4pbF}vmT#E zEEs}+pgFQCt0ni@rDb;?mCF-M)hWqZr;&))g~JxM(QF6%NG{>)v;%trNk8h57z+nI z3jLVr1_wB@X0gXJteRq$a}$MAe8u%g7EK4i1#qiBlp! zjhBVDLs0Z|cH4&|0*D91**J^H_gJlUYh*AHlcnNq_``76I8Py3a9WgtgEF?}Ch!?y z#M2KSAA8qnnqCjN{E4-$|%6i zB5oe*EDSM(4OI64v*H2?y^MTf2|KHTa6{!rLy|GhrN;>b>2_q4H=(9%I$Z~%385BNTz`s>pl~t(6q*Hl7At3HOevY@H80}K??WR zkgFI|X;e;ux?M&WRC_lMuGSqQZdC6U2gk0S)IWuID+F;bwSn{$?(XxvZL&w;<&IB;8VlRjfG(`^qDa>Nke)}(G8 zaf86rBvqOo6Z#m}hNA|vV7<6Z+3)Ssyh=ZT zF9a$96($tdA=D4W&x138`Z=udomj!mVlNRTl*~6tJWW5)2@efWOlm|WnzRT^0sHw` z)PH;f5rBAO$ zef?4zJzg&F=^Id_|8oeWSrTf0az<%@SMx|}zvXo^@@_j3kL;5sab{K98UR+O3y={x zFr4BkpU7749d`qdoxWN=hExo%|8<`Ep>o-;x^vFDU37Jzw+mmOI1go9usTV#Qy|aW zadSyS^?<|O&9MZNOGR2iToLcF2-pa;lLwPLA~&G4Env*|C6u&6L0GBmrY2t56Zvg< zZ@(jLsOLv||D?hzD;OD7?0AZzXV^dG!n(8Y2S{7Mxj-|hT!s{gF1#Kq2aPPt-wWzHmE z0C&3NQnM=Zlrz9L(IYH@^+SS=A(tYDB6K!N;z0E@fO>AMFCw1J`ZQw7bFbLSc8scjr3-rZWb%*~I2^U% zo_m2w5rvD+2aB$@4W5#8j|k(FQ|r}g)xHjbSf#=5k8?rr15ree-0-4GU5zLLbRjgm zj0OI1(>G}s7V5qKR`md6sneUWZ@OB!73Xb*LLI#T>Vl47uV_%go95=peKY(r-Yi$V zVI4YDj5>kI;#(4tQ^P=pyRA)tNs6!}0&cZiZ|k&8 zqobT6uX1V|$qS$}2P7L6k+JCMy7s7Bp_6{6aGxL`jBH&qo2p|`S1J}g5#;-E6eB)92ppxAShNw4Ii*VJL9tefw9YE3ui+Z~F z@Z)8{G-iQIU(_w%5IF0CP#orS@5(~!SSkHtL>38Zlgh5*=IH-WM31wlbSHHQ%zoQr zhZx^F`Z(?C{u4he4tqJS2%G>VYRgn!#SgzljC@(~`d7`n<*5ao@57*1=5p_{DvRl3 zhJMoF74S1Aw~a2Xeg^ufE3LLkI?HjlF+@}`NcJG7{q@L+;Iu&a>FBHWs$mX%?E;f_ zA}S0K?|84JehGp%RRV=IUtVkApJbx$U!J>uA%?&AcdpSI271sq;_E5vH|`DGGh{;P z$!imoRp?vE9`tD)e&Xh~aVQS(ag4^U4jLb%PST(+k3L2+>79dYI3Q{#udWgxyB~2q z&8eN&;C+=;k+r~4!TyZ>@4sW;$Lg+-S5U^!+5#xfufgi9SY(0mC_9kB|G<7Em8#*t z??&yV{;22 zs{XL%p+$wRf3rRP%kxPd7|FnI?Q$q7hLo8kR?hmJGE^Im)8PNm5Wv+p^0#z*X7yL} z=77PE+`pSL_lZ7d_iYYF7taE<9XgwS3Qb2zKiL+|GA*)f|AA3e+7abC7&t`Z>ySlK46GXiv{}Srv*+q& zN&kz1h@}#u*6|01>mg>zHl_Qu1UXS|M%D#oT>nC475lrfKbA1RfFlZZVPn8ZJ!Djy zZb0*J$*-Si0Fyakz`T}Tnfm$9`BdF#>2~g1`iT6Rfq=7HJn7?hyOZ|ctne_cA*&OQ ztyoD)3(s{m>8unRx^;A*^zVr58iux7bt(&MCS6KG(oWbXU9Cd-uJ;QMMnlY1TIVIY zr|mwI36M78>vt_PAH0q}zj-#~uzyD95OkLSGwo&HCghY9L?si%P8M zT}6DyD`~5fM|IM&kP`#ou(fo~T?B8$%V&$)>;}19vRS9!Q{&Xbr*LY7G)_HzMUwAO zO0>+U<10+RrADI1cGiABpA_n(_egJjYT*M&$=0%&Ifam+Y{;>hsWk58Xi0AmDl5XSw!up9QCTN88l{%_=!Ky-bFleZYDONKQEt z3Nf2!w^QR9_bHoNr^5)8Nzi={;!JlF%{#Q@!F|CaQSQ40mEtp2ouX%H{ZqA}!V7I; zJ#w>uLk5oC)!r98w*_3HA<~art8ycaO5aGDv;{uCVhC(V5!;+(bQAI}@m1D3T$;Ry zx-a13Y5K`T)Fwhx!zG77jo7vNd+hA9gofq#V_6oNK5eOhwA0lJeWT=c-@KVSVwQS$ zg#lW>8UB3?Ob|RxYAHVA!3Cv=YxLNHN-hSvb9!{B!}!iG{eE4O_=7<}{%%fsV$%)3 zA5cKLZcO)HzqxtNSt78L$n7xkkG@(EcJofCCCPGy@6L|tGLKmvW8`}bG_Kimb)90> z%m2>4)D1m$rCjR*QB_}arNePVw@zmK!cBTb*-7R>BshZ9qmxST*M;*d(cuT?9Dn9_ zkVZxt2utP_rIkEI&{lbjoYbzlm*Ng{zjLnaMOczRe3QK%{YFRE#ldrHkF~XVd_THD zWx35e!Yt17A7>O)g z&G<*zA*)V76aXZP+EiPlX9jw#9MH>APqpdPzY_`fT7ELw+)(rR5K8jps6sqHuhj~h zNapXfaPGhr`%2g{qd2Y7dn*tX6B1SeXB@V!tOG*K1$-6o6d?RihS5i%VJ zxR8!AS~>86YH&;&hWiFXP^fJL+qGW3&C6I;n&X19EZCwlJ%ua%YT{s#U9Gx z-ktOOAE^}xPp-}8h^rYuH3SKlHylYGbyf)woH@5J_~-rGfrl~mYZb)Fr@M>5__g|g{!5s@-iLAH-=*-i&L9A{1 zT8dgJTau%5y|uYCCV6ICrXJhNsrjlV5uZOokMHBzZ%G60E-Tyz2GV`Z)?v{4veCLK zhE!6lpA2jl&EiIvd#N0(G10%^A_IXEB;|VF=^mA!g0L;e&fA}~vh2={z1OPvP z^T0rDWXl+TL7;CA#MSCCxY0i|Ft#g&Q)Ic9un>(71jYxL@NRIcw&?{Fk1yULZ5+dc zmb1IG-iK~5!JiJ~KjS?v*;N?pg?BFQBj4$V)`J(2BA2W4P}zimH4nhqLAdd(M(_6b z{|#6~QtMxGT)JVpoHxB)YYXisC7Bv-()azVdgAB%Mw zlv8=BTqwuLkTeG#O=6c47l1CBfI@`p!W@X;4tX+<6(oc#P%j&z`6)gHEcI|?y|WB2 zzG?QG2Bjlaw~pktvNi_2505_go+28XJYs)2ba^p6O`WMw>w4h!iSs}2!o>yo>92&925 zO&UTcVcabcD2zdbTa1au@ug>CbzpB{&UZ*_>)T!}B$Or^?Cl+V|GEkFgydGQ=*7~^ zZ7I^U>AyP%R@${rbAKjpBwld?zWxMsxPHQ;+N9m5+*(2efy#+SI_3;g?4AlJ%A=sg zlJFB7>P){?u1U4I!TjyGc}F1n9OcV<(MYxS17@H4Z`wsi{(2o3KQ@h^Z8>&El-K#( zZ2wudlcgIWJvj~JP0-^7MiMKh7lrx*Wajv>QvvE_Y$k#eO-eOGMdc}_Pei$IFQu>1 zkyESUnZ$s8(0Czv7cZj>^Z9@{sLo}|0IWL=&Y97$f19ZlU^dUh@pA1I*0+6=4b zRi-vl4Tz!2M-f-1zxVfwy6LVp)n+?j*q$(Mm*)QEM_d?59<8hj`=peFJHaS@$Mx{< z$A)N3hRh?$$B-z)(*wy1>$Tu^z56WCHTDJpWto6{4)x315PDo1kA-YC@*q*E)Zk;e zFElGOb!_Qfd&XckC8a!|q8QRE$-;74%cAA=g_VM`^Z;l*^7wL{XoPs{0&eu2mvN2f zHXs9Uimj74X;yqFz(qXrYu8)?4;@qpl<~dkOF?Q}dmoGmQlPU?L)Ge%0OYD1vd{uU zn@8VIAlr|dyUI?nv3Yv?5i@RF4_vdKtOHVjM;bPDuG49aA@>x}>2$kmSywpJ-+F}f zSl+E75l2cyP0^P%c5RY(l2YeL@_7Du@BEs1pC@=`6#4rnzs{M%qDZ;+W>*L$R|Ge2F3sm2Reo{_xuliKux7j_UbJXkCr?VFC z9u&#)a6KSdQ%sT~ol**+}Y z!#E^)?KQiC@wd3RuQS$BPZ`3W)arr-H33@fe>3d4G<`7%nvObE;r#rC4ZyLh*m!Fz zNW~ob8lh>V@n8EhVipa48pc2viEMM3OJrE2c4k3(p@6oar3TFP|Dm?$= z#3*ZCfYIYK2PEsUSv7a`5jCUy*wt)FDn6|Ub42g1Q^(a__}Va|q)i~Z?wcq_Zm2J% z%>rG{Icc8f=Wv)SOtI%?h;gd?EK&(Z+AQ&l&vu)zE*)O_HhbvI@ff zqN?u*A5)f5#TN*-Qtk*Kq*>EzV~yxK)Z|I-yl$Me1%WMpyhCOGSa+ z4Qv&b`oyXh|IX*2Y-a;74q#2|&ya7wCH67l3og{8N4u_>=9=tg6=`Mqa_!eGyZi7Z zKnv^U+Twhih)ajbx&JkEN@}sj6BpkE;|9G)BF1zxNEu*-$CHqll@BldM{KG?ptZ^-_gq}S37obY7ir8;V zte|dzuRrn1m%kq#Wg6lqcy-d@W%whukt^!fCx#eGI$SR&N>dDBmSji)ShHMKw62Ua z_Ml{x3bT9_EalV<8P?eTA=H$084D0Oka<>P{6C#bg@!tSVqO6FKQ4`QI{}N2KU)`7 z8QW>G8}b8_LSi^mw~UvO26Oj4}k|6Fe zB^)HhPy!JM=JO8n$e%de6JbrOtAyJ?BOVfYq*eSq6gdZt1n|fekNlOr1>_H{v_z3T z*ko80(nN~Vr=sOSs!?!}0)I5pLJp7t_nMdAmg3&Sk1C33;G;$8a5KcTM0eW#+17%1 z4ry*ovIl;s1yb1n(h7_Q1pibc=6BGr`s`9DRIyH;e8{6}MZqB|?9jtSDSws94g87a zt|QaiJvfg_nm~g6G=rg$#&uWRoscN!YahpMA%8pBEiu5`2YPtZ%>m`I&Pv>|U9hW0 z&~A7#_z^$|vj+Lg@Y59@k)e`Ki}{e)z?8djYo?Pta&C!xNmz*RaWg5aDsh|pY4Zbe z1*CnsER>{X6zoUgP2jg^$>3$L?XpbOCA|oTD`>dW6~C{QqhC0o)44EeS2smXfP9D3 z>0b1!7@FxJA&1ZIVHc*%GJ(*X@eDT15kxLFrG9)+ zsU?Do53+FtLzs!P53&jTZAfJY(MBFvU)u#kZ5gIkIY(y6_}1cc8D8d-dGAl{MlNmN zmmJ4!`EZhOr|Wx|1I86Ba(=`LPjY6C7^OnObd@J4U@$~{cR!NUEJ2CL)X4p6t4jZjtBw7i*$3uo zEkSmQ=Lt+&r)SfNCxn5TG;$7Z7+5o>K{^ppI?2LwQc7`kz!1%3ZqHc13ep6_0)^H> zB1p8T{6mT65+w~7>-5=F1j&c%^d%;1`yZA|{U9_6q)CBBx~X@6y#T2PJ-^t~^x}I5 zC`k*Lr9!THY<~2UsNJip#mv;aMITd$7qw&#_}8F-d=cH@!OmLo7vBQNrrnM1iMYEa zkTEa|t}}75X~J`N5XX}A&xvEX3&qzy3(MzvXCY-A9JIZNz74*UqGHXg-W=(y{W`N- zKHK1TMKc~UIVG7)Gp!+!N62tFyz)i98_>%x>m2YA`tR)oqEDojT+qnUN4Fb^NH-c0F9STDG|+!9XemTV>67VfMqW4|`5tR2#}w%#61#3y%ea?~BUEaZ*F$(_hL z@!pt9_aUFiw#f8S=_TL0u_xZZRFUIgP;fqo9&RWJZ}v~7pU85MUADg)y=E3CE0Dxt zA3ttqoK-+B7fE2U{dVh&>|PR^e^P%@yUK{AkV~1B5k2`tQraS8)kd zqYYmzNyMfb4PG$R#QItT)z-y{Mb>Fe@Z(v$i;Qq{#@fWmz2vzLa1+7WxS_jSW_x#s zqyWOlzy(DpCORffplkCTw0s~Ho3;Q>sQID&~G7oC|f(q`Edeo7_7-X&n+ zyeR8QtFl~iOm>5k%%fC!r?0?r^0Tt!&sT;J8qpE6kC$oUOw_8z(K8B!_afB;KF&9L z!{{otmjx(T)@jtJhnGJjK*;MdPBJwPp#%rz>0o5l8G{h8K@{ywRE4(?x0Z>9Lk~BF z;N9wk_D7%q1SQirw!}93FVYisLrbn6dTT4Kj; z`m6dGrHk7`Z^MnL#@82~p0d+2HW;cxOfO0&E)u)zLR1Bf5&u6Zf5DBurFwNL3+Cen z73QxCueOr1pQ~F2k)t;R`WD)kOz_q7UMHK6 zGCNK;7qgpmO?_2b8S0{9cT&L0sar;i-Xva;@&sZCh}5>5?wZMht)oEuiY&03I5cb_ z7=cW@=|;%3JLT_Oy44xA+WANM;a<^fff(&H)l(e_oil$Mi+k%Fs#Wy~T;H(YI1fJa zWUmwU-ul9=X7N@z!^85&&tQJ{0#1heVU&E?@EIxEE4t%j+jMed`bf3&-M$c#wdu!k zr6iln5PkKR)~uJ?EWDzvBzA>c(P*Z-sZJvrl&iMhUD%X|el-Y(O6?f(<&2Q3tco<-$s`J)2$-qK;M__E|`k+a0M-gGA8TpIPlDSOC;D%P z80R&c0^SWYEjhv|bYaRjBGv~Ddc`Cg2kLXhNtLrY4R__r@2pjIX3%ao<+f=4Dle4Q z2e-d1X;7{P-h@ANp0Noha$hDO4du5Sr8yp&#Z$xndCtCWISi<&wipxtEAjAO8OM{yLNqh ztaALOOM32Lo5B0Tc`IWer$M@(6T$nHByv?S$h!9hcHSxWXy1I%CXP2)ZCi4Tp!ZFo zAHhh`41KLLCtesk}&$e$(d@--M8Ko7q;kLiynEXFAFo@t1-$?2=u?QM{@8<= z0Pvh){%PffGItqov^08O_kMNB@sR$po0jhf?K0`oFEez?by*9o^=tMr6uAuqKNec+ zNF+qqSQj5km_2^H&z(~es5UM);j6)~XlI8D9We{t!3EWSy81p6SCy`tx-4B`eUDxi zMxhL6zLLrjTHG}imk?Br-Cn!u6lOwrBUiv=Y@b1SK&&CVi?!z8+?Ex`qc0>2{o(bl zn`DGPZP|%0OwIIHexI#+-Ga9P;-0J?U%%y7CWdSigl#Hmx~;;uJ}{EIJ7ro>O8S)6 zY#u#+=hK<6Ki?BP(F(5xR8CXtUZL0Mp-;+?as9P(&Ue1%gj=cxozx-alr1JMM~jV26k%Q{H|_7s5^a9$ z9*wPGK623NY{hqL#v9<}9$S<$qh&SBc>UC$=2ca*>2 zC<<~Fp1N)WO0T`^6}VSE>?_4o!+j-W;FpY{)Uq$vd$HtNoKB*WE_F~&ox5nIv|#ls zxZUk$Ro8lB`PVxSDZK+`7aL{MXN~>lk?IgTSeU3UHOJW1%xyQhmdQ^~Z~9Gh^3b)d1+UcqYQ=Iw5Gew{HnTGtHl2B6jV2B_`i zr<|hUEy7)?vYO)ungOjD+AWzTVQJqPVnTK4l7#0fx<>;{Zs@5x#@ieG+A(kl!nQqC zt0`qFtMMDd{NPz8&m*ayIj$l5@@Q~dwbvozIhyPwXD>ANlDSD)aTH(IUAgwBX?p!; z-kkjG?%R>Z+G(u0)2zRJ>7(G8rdj_uG-YdIGHLEt4+B=WOrXa72S`Yt8zt?;}gl=2DLLDqcI` z5<}bfU%sCQ`gY&>D5B|wemXO^#fv4rr>S zsM2amOG+4s8xrbXAF$~0r3aUf*zHQa`}L`ecW2Q4+TY;DVqSEE0~vt{k5l)++dnCGV?HFq=K@ZW+v%1+0nKdYA6xtuY-mfwH8 zIetuvUR=8;-SU}CdO;SQa9-rG+6NL8CiYoVuw9E{HS7Ma_Ne+h$-Am=TgY$jCML-7 zKIRiEpYF*cEA6!3m1^RvMU}ox_ptZ^t3%v<*)hodDwm0Hp=zKN_oaV8dl zu!pE&J&JoL`k(R3^|xJ`R!dtts?>~I7H)5cnl{t((DX{8g>nV3s59OkTj2zzF} ztqDZSa^OUr?7c`z%IRwSQlYdhaECJQ=;fZdGTA%1Gk+fm_$oVgfNktJCl@Httmb$w zG3%Gm#vqe4B?c0o-1KQp0!*?H^h+TR=G`Bbc~-pARm&YHK#pqz{|eu7-6e(M{P%US z<8uPuvMK=wLgQ}LgZu0y_Ivh~6JN-GqQqWH=xT&e#ysX`h9+S@7Lm9ugiUP+OoiEg@ZF-<3DKN=bF}M^O zSb!FkHvTeaFpIb$Zo?3nLjOKD*>gRUkK$!@E89=~fK__D!;31&yTp9&{x4?{I$#?f zRL@tP99d+53R!<@RR1$+Yos7o4VT2&nx4Zz?_iVJ!%;hjVh2Bq)il#w4ri9#YQa~V z!Fxh51phKPcI5Gmni#D0AitCi!ZCqe7ZplO`5Haifv#Ok`+$8rI_HHld}$N4nJ{75 za0inoWW#{_8m8k_+jsBI+G6o;65wAVw~X?M)t;_3U*ws$ceh{UalTlu);7^`t}M51 zM;G@MRP8M6DgOACwI8>L;IhhbWVPSo@$M?Wvn<+tNmiBgl*ll&gRBh<`ae-9!{%Q* zkQXCQ?d;Sy{re_?d7i?)jNlCDk&ESaFRrFL9VN6GlUpqEH23L`-?sO0IIBpF$-DZ$ zIpzu3GwskImY@K@QAUm$?&_uEPh~;_3Pl5Zw}?{qN<8q=U*q*k!M>W9|KvY;oBm5C zpn>{>WL`rPr(rl;%%|#af#=~kh(S{q?^Hs|?4Uhzr0BX-oU|u0JC!`?27t& zUNt_U+A3-0Iv~rj&;JdJmz|vbddrs&Q+}BxfP_XK%jcgK%!Fn3sgIMc1NIxG0pc^c zl7Zxzbfz(2I9;rTjaVbonx|f2O|9D+53__|Z#c{?a+_tvFuMUqC#!#l*=PWQzgm!J zgPOdLWc%k2552!;-O~drMI^4+=WF8Oe3Ih`NLtokV(vK)O==crT>F_lb?j*23gc(B zul`J;)YGd6#6~(OYy2imJ87+(Li5Ih* z@(KhG#RhT&gQs1K)T?ag^>HYg(Pa2=)VieyPVN+T=U`O(#qJ=K*!NU2$LUbT2ov8o zEY&Z^U@q-)`n7Wozry&Q&Uaw6-+dTD;uI!-ok-lU@7TS7#@&vgEt!`rN%ibYOQkRH zX+dly>)1QiH5iI6_!}SLd}lrD9?@+KJHyih-@f3{DFeyJP+HT~2%;W&C~{Xhc6s?WTea0lv5-HUy!oE~2kFI@J^yw5m+bfp zr~TRf8xB0NesIM=dXmRt5^pF8xAkaQ@pk9zQ!(EiBJZoIM0DKqTePcodOhZ8IzZBE z?}joi$bJY^5o?*vuc;l4pTs0Own>wchi%PZ;I6i+f85nb&1%!>d`p94 z*GY*zer^X-|hd^zq$^D!;kmPSRdS#;-(|yyt0aKQMMF4Of z3eWxA;bxiKz2EK)gA;ZVa21s6lV8<&AUrrVXolgrAq92;hhjc-s0?%*;L$N+Hd}ws z)c@x+%hshX0yo!of7x>33`d(1uL6|DX>5n77qmUs47l^5gEXQ_xzF|dm7^N#8SV^Q zji)7^g^pDe%!e&_vgDe*i|Uw!E8ssgwka2QK@PGcqEEE9GH?A57GL(bt}m3x2}EMs zx}yN}5M_71Bp(mCV4g6v(y#D0J)fLNUhov$ci|2qy^vD8$UE30`}_K8IVWF;Nvw`N zTs6GkU)fgUeomxNT~i4rw_HHc6Bv6De$rLm*LjBg*eb`+D~F*}MuR^?UEh#t>jxt+ z{E6N<&BG@aDlobGltO-hPP8&_WFq+GKZ^BSEmC4!?In}uy*LNlx~hiUjE~rt)*|Ut zIKbJDyuh;6Y}1Fwb`cwDczB#ob3Z?G-S^JcAdX-$#_nkIs$bcccVaa^HBBZjoLU41 z`}8VjwZmbNGvlN+$Z8^c4xi?&sF(_SZdzIAuy$}4@3jGMJPYn|pk23Z&fA}oe0-9H zf>V*K%$nv5GQW9Xw{`v6+$)F`7Xb7Wsl&1r=!K;$T5>X%r?p(YW{$)z+qUmr(AOP? zS6a%d+{6_}7y>4yn^T_O`)3i5i%(NKHjjQ_U1OO2YF2s=PzLN>q-Z^QTZhQAwi**5 zCg;a}uDE;7Ytp(G*5ht(e&FN2j+kF;xhP~v9Q7Rfu3VIBpe3n~C0BEw0dMeWtJ#lP=j4^C?S!=_eP5-pQy6;;d*JvQRYfDDB*S-;ni}KD=lmHrR&0;f z;(NT<#XbmnMGKCMbiHQ1jx5J^h^CfH93}%9l60b?>};x88PuQNvTIV;h;sHqw895r zrGZohr?{1E3=uKxsip@OrPD7amVdvQBF7x#An&CAkM-dpH* zYFaCyVEima^=kAk&pdd)7XpZVIk=thr#!FYe#1pG6;r?7^=?hhubu#4eGKs&kP*L8 z58<<2^$ddy94a95&*;e@*f5>Ha>+WNg#7+L95amb1ICfy$A1@ zG+;g+<>XU@6=#uzU25B*(H^Ge+_;i@&LmM@*Z3yh`Qx2Wca+%QQOc|MW;G$S=jECu zEtiyR$muB6!#Y@QJ^1Mtm`)erd;zX22V_4_-afb*cCY8^<`F{%MZeg}*>4>^*tzNK-v%|PZ0hrIK@$9K;*W6)Q;9yc_k7A*8b_9YCS0~5H zRBlzhHS)ivc|nmseP!cKKJR^+_tM}Lr$uX-C~qreZ+1Y*>*^rzyDdmLuI=epz2DZ6 zHUnFk>FPwYx#yhNd~+dfCF7wDFW#)gza2VWGI})2^Vh`Z%fbjCU`ITQs2_6zJ0n~Axtp?;O-VDHDuzjn+8HJuB^eu3skv0p zbupWd1{g^Po_XDG{c939h`JuDVLhy@tNnZqYgPk!?>1aJnCRI&T&41aw_Ai?gm>`L zg?kaP8w2G6LeB6^+(jI$#V11M<=C2zcL|?ZU5XcM_ZV-6l0(>ND57>xFE;y#EJCso z&&YGW87-Nmvf-X$yKCB6WfE)I`eV1){^vCsxFhIy9Emul$Y^YoGJ_i{%i22>wPz7o50*eIoVC=hc?n==d@Y zjYP5RgKi@sR(5Ae?z?jyk~A-Ho83;Cu+we_?s?C}zZ9_}oldvN>t(%=IqQt*z|5{j zD@cn40e@$%cNRakBwKa_>Tq>h%lrFm2-9W>u-+;XEhoFFDY0LP{U~WY%L%v|#EpUhT!I?(5I5=5&Pl9$3@!Zv0Q&Ry8kI3V$8eA_f z2U+J4ze(dG6w^mnqjgwqEefNs0784#+~DUkZ7G zHsh-n+UoIRq|bY++!guf5)MFp9%fd}W0gp~eYv+lMuk`G(9_*(t(zshnb*qMyoO{_PJS380J%8)l6*_q*~>NJw<}CV7Ers>b5Y(@_s{Q3;WYGN~e5XYWNt zB^;i=@Kvhy4dth5D_17i9GN#(hI0mFeD>OW+tRVfEO63%Ny>k(dG#4wPQiUL2Et%= zIKz%0oWlLQyrO#3tP6ur+0N>>%R%5@dRja=wByh`?tET;Bkye&`vG!HiQ>x1z?{hR zP4`GuOA~hPwC1dy+V;^vPDq@Q%mRJ_1@16o%*^}N?su6WYQf(^+zmaRV$yr%FkEk0 zJD1fQYzbtO-#Gj5+LA$Oc`2z0;3&Aq6vKj@aQMU+(n$c`Ij0bAAmEVB3t_mp z1Cy6^_1l(^4O6oal5bcsyq;)yB6i7LN_t-u#~-Sv&gnlfN`iHV(+zK(e35^w$W(|a zpv>Hs@q-%X*|tG8ogEm@KjW&8l8TVyBWoa&yZf?2Pu62_>+Un@2OLx8o%}B^KkHka zh0DAdF(-54QGKWVPzSg$$Yc2&d@}GqR4~#)?`1k5x!Bkb+Tke)gJa>xzYpbH5gpWb z_&hh^s4{QTN9cz=gYPj;Dbz$J`J0jFk_Ah=n48ubUZES9zL%69JX~n+P!3%u@q@(M ze)Zoq`cI!RRQhGM1%492XkXXF6^Oec-eB$b*HiXZypM65vMXOHxyC0+uKcpJuswDT z*oC70n=vUj@SMrb?7GOom{94o`?C3A{5mb|KH`q(E;5|ZO1wB}dEjePe_K}pEq#7oVe1{yytMtR8rUAdG5y@JSxp%f*tYfdv)gph&4IFz1rzA zTSo+a1{SIwnMr<3RC;b{p>a=RMA2vB!54C>%jT8T3)6uE%qoYSiyQZL_@3-m2EEoc zUY^+!2A3K^$`0oS^n+p6zH_<7da}!#Tctg!PvwPR;6OLnQ!GPK6<|X>&PlbYe)l%KI43 zatl+S^sk+1UzKLAcTW#Lf$Y7S7db2u!j>GZ*syv2STDGe0lo*h8+bAEr#T@~UwP-! zl6YA92g?9S!(~5-K=JLeA22H5OzjS>>s}(wrI%xi*GkYn#jZmXfH8RCwBJByI#MP5 zsloV_u~Um1BYwZW1m_im-+^$Z{%+sGAkv}3KqKsSBcWLLc zU&CRu70Dhcbz!I0=g_^RHu%z4ZjQUx<;+F*0^*5?$!}5fqrxDtW-*Wc`*oxbjPeB( zoc>7rp`|>);ya25qL+~nPk>C2_mbFLd__Ga=ykky5Fp(>Up|p~pUv+cF&cXiLrkDX z&vQ?J_p&uvY}ePPurl}G|Jh|<+=RPSB?>}+fG`qP3-YlfxV`1iIPeGM0|H}pog!QA z9%^ic_L8z2c?B*&-qmtW+Rs237ZGD>`=r+6DrfMl=$;5zKCbt%E}H=9B5)}xYRQ3~ zJZ#7#s<_7xL8NO2=tUZuKq-hwmW|?);js7t@gmZyq)PD-Ou+97d`I6f@)k@j&?(5` z_9w6@=->1puB;K#AphB6Y@jHI7*ji%);9i8+IZO;q^yMJAMUI*~)*;A} z@`ppb=pO3%SO(7V6Nhn7Fb`oNx`ztNmc&%36B{gVTL-;H;>Imsn`qxBTU|Q)PNV|7+^e-?Pkh<3Y$IMB*!MGaL z1R3g3XS_4SrIs}*NA|0x6pUZq3}Uv8uW3J7#b8xTJjq1Ccd2tv{KPgI2^Gw*|K0R2$r zctPEKaUaa@Pmp608!tg*<`8+K4CKwBRP6UF>&qEvQyF}{qu{UEwC`8qUppd}(z=(b}F z_1>gE?L|~YF^aG!E_k}-Ihy)O+hBQx;vskACOf$ci9(E(K*r!tTlfQO0t}*Lk|;Oy z{9C%X;QJ8p>d;(v5*+ebWuuvYk!44ejbk@z-I0?2TN6O;-Vl0N*-elW0y>}{22=p^ zYe<||uqtJO&j}Y0H!auAB5-E(zS{Z%ca=_nm!sQ)8qK72fqf6v39n!`rIp(PzD2Ji zfW-U1CXC#1hfVk*T|x~o)0$&M!0X<391K||y_<>Nx38hF7|w{?o(R!OaQ&UET#WJv zhpVW!c>U?(0+2>20-$~LLW@C-X#UmT$^OMpkZ3XPJXGXNnhxBr1o7^lpRg1iS^R*s z8)kqUtp5}B`$_nH2b12^CX|%e4d*7Y)l{2ir51bxYY{FQ2&qKDgxuWqOU=n`o!vpG z1V%hgZ}h|b7B}Eu=(idz?Y7uYiyK>vBd<3s@HS0@NnBgl2Ya zKUiASe`oHOQ1cW-27dy3a{JK=_LS=G-0Nr{0rQb(@9D_b+%Ga|@C+KC-`cyoGgr5p z14-l19_&T9id`UAA4!=fND3xur|_f?NX%>9(;2y`5eCX0GE%g!;ji%B8F26UToAc| zRef(|a&58ytMbz7>V(fvy__JXZG0~^h?QsH6elBzN!I2v&{Ke|+rqJsW48>x^e?Q( zU^O}9IIn>JanR5-W> z_B0lr7`(*c5C8k6%NdXcogERygvW`Ex7*mz&y4s1q+EDX|KQ7F#%3#|4cKZ{-gVQ@TP!EM|ZwU z7;i;jgHn>eG}l{@pCVW&JVR?NV<~8|rpN1X3wkB@!S$^a7S(HW2LzBx0J;Z!KIv;< zB<95)TSgVg73moMe;1SMXk9`~M4C0)E~x*Gc`x=z7Fzw!qvYE zYIPQ}#RY{%%U)7CkfDx)fBZY8xYSYyh>F4n#sJy`NkW!Re#hcPtG|b_+zY6=d3?E< zkHkC~`XBsGrY(L;=>vS!GN6!z1U!?rqkc>Q_Ox7mXqhjCxe52}Hr_)`u^;M+;Ci2> zr05b*wW)n@FD?{!{m*&VfsL7T55m`aV{Yq~5_L-rH5g!qqM*ZnAQeKtr-=MZF$Lgt zlwry0*+Z6Dc9;l|0E5i$+;W*x3Jjs{x%ktXI0hVH|4!bS`!5p8 z2R`Pra8>k@abMW5m~8vg47s>CjnPXQqzshMpv5BP8W4*YY@qlaF)xXh0vKu7+hhC& zBK?b1MYKLKZODj-+l8d%RpAWe#m7=JrOaUg63|)YnNK0?;5OOdGC5N`>uhJG+OXj2 zIyBQ;HxN5DId^4#V0eIG@Yswz{+NYL@4@vF;LrR3J1JUor+Zetue8~_R3R{mnFGp% z(rxCGF?gX_F2C&~tAu7;G*@W2F5u@mC}jxjPw)wP!3WO~mmnarlH7A?#KFE(c<*@1- z*qqq0zBo?qiunR}rP;Bzn+uW5tvIpE8l+WVp;mWO<>dPxzvW@+_Zpub<=#F8jm=C^ z=d;J;6uBShn%~pCciCt$4pcUAd5ym8TEYQYO{U9PVE30I`E~ivZDVg1dR{;L4H|eN zHu>T^RXLOOGOa~_Dt9zBPq3%8S3QI+2$@$38!chB;SV`k4Rkraa!8soNPlHS(&VKc zNY;`1;B;Z9d!@-h)_g$)QdNgUsq(KHA2=MHCv0|4Uw{a<5^?(T<~ylE>73u>_|v1; zaEBv@cW|3IESXV6Q>}Zt1GZ_JW_Iyqw)+(oF!C<~#W*O4AwFj9u<4Syd%m*9%lK?9 z;`S?8s1as-YJ}w5sLzEnEPCmRlP4-|R}5o%AywgtxZvUB$j@SjqbC~f>a+S*@OZyt zz=6IYeFC8aTB`DQG8MBiPQf0ck8u5)E=NW|dy5KpsJx?KNtG}L@f|J{Kvvi&w1FE* z5YnEcWV?tFMW%pLIZ)iV3DT3Z&fHWdYxnk@9$=z9}t zQube7urC9;eI?XEA%UqY`}!mjzO?^CKWZD?IEEb8UU}day{kYpP1;O6$gA)esf$Bu zEu;4^{-zUZ^D;k%O7JF=D`)-r^$|)%DmnH0mM-628lk(1G-7E5C0{%hHyAV;%K^st zb&J>fE`1UH4$^H`+&VH0W(elDn30NK{VD!AJ(yiE3#uxqJ5nZJL!8!qC<5+Gk)$6i={@U=(ov|X0tEwL z%|jvoq{wCZb;4X~gGhv3qIYv!RVXMi24vgZm*;R|Y~0S}W9CAXc5=KkT~a#T4l2rp z;p$rV{K9uo@GEiXBhWM?7pDf|YL-lTvPR7=+ncDvr^3A?eKh z)OSUub}ggLMlP#`o$tz>c-7O^{Pn|c=BG~kZt=k8V~P78;S1;g;m*^!M|!@+ZZXVP3uI6CY{*jj(K@`3=(s-Z(A}TUOBAeAbsk-r&e}+OLSb9cIcMN z<|IA0pl7=DK#+1->U@ojScl-+DR(Q}KVQ`=L%E{gx^=!K*}9I2eN4maxwr`=PO~mm zATEMrTYh~_3)}-f)Klfwx`qSi@>M;_-TS#Zd7;T+?&a3{e~Ytt(y067Lhw8pLnMUec+N5q2@3;t3mljv>3|T~Gq;r{V=)6k zkKJ;GFiGuhJ2RZfg=yYW1S3|f*+z@0yGp{%&BOa#g%)0<`v{s7DxKED`oQF{dvvqN z76on(@-hz)yG{StUpT&9jxPJ`cR1eV+#KiKJk(fYyzdhN+6U2~hX<48Rv1GB_QNS! ztZh3S4BJseIA6=Upqe~5-8LwH774Rm(2?Vp=bb;OB)a0m3A(R+B!*pz7PLm$LY};? z$l`tippdwWHD69{r2mZhra&sA%m%nM27`5ZfPdwG=Z{Rn>AzO5421KupcLuwEL+(> ze*`h{_WIPXeGieyF-h?|TvPb<&svKJ7m3ye(Hd=`Yt$9T0zLlMGZ|l$jfm6m1e>?z z1R-XeIbC}nJG-@6ob%k2@h{%^^o>-&*1VaF4;ot`BH8qZwz-aYj0mm?RyiNYs{LHz zi=fiv4(O3+ddi64&C=k3fAyViBA5Z5T`J`0Q+4J4;$0AW`yd_^6UL(-wpWJaO#3d{ zsG=ys(>~g1uE2`j=?oP_X(Mx-9u2(8(4%RJLoz&rje-K>!5&l$uoS=4)^b%fvcx*9 z{1Z&q_ZAeK-Ctd$jF}M4B%8p^YRG);%DqF~$&4bLw2Abd&6xTTiEdJA+$2eJS(%_%%1fY(HH?7!sMV73ar-R$}vpKe0K=K_JSh z;%(7xyBt-A2%%39p@F-8Ox?)3FH#5_v+56&je@D(z4P2yt2e93+;Dd!h9p?LI=Yxw z0H;HnbJDS0jsDgAZZtuzLgqoS%}Bb%UCF z*9A9wTMi7D@8Z5^_zlyqoPJ|7!WvxKTFxd*B!7LeZ=3>c*vgp5su*F0?N8>vyrt4p zc-rXeWE*Y_mnW?=yWXKj&3)p>51H6#ANE8fJ#IzUPl=$q{egALujrQJJ}gI>DU;u? zq6~Eh3}OXc(3VR%l?P>nbYC5t4r^GOzU*JK7`=SR3AXon-L)ztfe8CL&JkO zJkqfV-gp0#iV+QB#?0)b;X>eeOrWPV&XpSvACLt7y~Monx8~>;=-HTj*3^m%hm%LE zjjtjEc>#`#dc<1iiy5b5cx}H+dL`AOIDy4}6pO3$K^Vuf;!#*M5Q@0aQEJ) zVL3rK({h)`iVv_#IqJxqh^7Q-DM`xhgX?HG5eRFHZ;<663EoSkMhq^5@aSi_(vaKu zSdcTA87I{Bwa2~x1ayKa>tNQfT%hrvC96r-emJLm%(~Kv&+91SOkm?37`SVdXzWsZ zj!p0UEKBK`*e6rS?ZBA*P0&d?T_>l?^?ufn0NkVk^!fDxc-h8}5n0Fl69fZNT zbe;aSI$D2%21N9hJPykJNCY`p7kfZvFb$c~`h6QGxt=3NGfD6ZX0_cJ+IsRwkFz;@ zoI*q}P6*aAg^t1YYdSG2W`!Y=Hk=h8u3JyTy+6z-q@@^aT&NwN0W1 zKE{0XT%Q)O-|C|yMLuZS6FrTHov}Tg!A#MhJ>hTalXNRyU4O$Rs+1F)4mwr@#A^1O zHWhRI)OD3dre8KuN4|g`>7H6dnR9?O1s)6JwXn97HVaiu(B3XJxdSK&7kjTtM#5VM+t+pz#j&(o@J(1V`DRgO1}H$9S#I3 z#$J;Fl`?PJ(@p3WojZNvxt`L*1mgB)BC!vf*%GC+GwB0(x3}+n$3_ad6wl!+BunK( z(%2fu>Cm~Z=h0ZKPX0)?t+j){TLE{Awu;BD|K|L-4vuSm>(n_|S5Dbp=?|TARv+6F zoQk-Bxjo++W)^zcg}e0T=0o)EJ=MG8m-be#n3p)XvHvKIfQ63dZI;+pe%M2I=W~mZ zO+yK5xwX>&xN<5&L!fKq%p42m9|)aa`Esj7?N65!~8wd`q?p`t`qBefwpY4+>Q6ADDMxWR3UgL zIwrgFmUm?qIxxxi9<*Y?S?#h;m}X0)TL;cJdG{}zXVW|8%QI#44ak){Jh37~g=`o#2w z66s)wweAI>B);OWJrPCe&!?>~YZ2#MX0LovoKf_)-<59D6;HSb8EN8~O@;NXMwl*N z)6RGy7E5`$8MzBb&7KpUHXXH?GUzsqf3W-bP(L};?dDMY*5Xf4w}^4h9Xl0W+_GJx z?dGrft;8BS>HjpcDn}@{$835x-XT>-=SZ2Dy60?hPmL#pr*=u+ItZ<0KI^${On;^= zM=+DMxT8&LjD1j)YxdbctHu*QEE2a{l;A6 z+*k+Onqv%RYBaJ_=g>JM8pcI@%j_51l^5=5Gqiv1W}40;ckAw}NErjsHc)SNGZ^)x zz%OQ;=5!iVz4}mG@#n{Sk~}BM0!M-l7j?} zfYfSxQm%G>@+IT1WUY_fQ+W5GUR9jLAtz`mZ7c1vG2PpZJvXc>`*mCGI_VvM)C+0+ zh;iG0uPg8b!BkffT}MF4DJ`c(Lx`vfOPon=E4ePj9L-B(f%xZJ_vKzr3v4gyF^yk2 z?>QOoEO#3j$Xt0=OR)f>e}lG+2y{%D&tF$mysl6Jai=D6#@*U@>N99Niugl(UgoKZ zWuHd@gx76f4So!*$h793{cO`UX1#~QqmWvyaq~%YMNz8?&RH{dgIC1fk!8E_y zKz7z{-o4XyO{KSOLo*_2{0kzs=PA+ zlQ;Wj(V_I+S$2&_9xuj>CWWw3VPzoEbSqCsY_BZ<#tA%wXU;UF!gXEaBll3vlp9NC zTbt7|6qhF?;4~1IuFP~@tsdKb@ieaI@jNh0LYwuT$B8^jteLH-CS?f;8X86=>Mw9&(7GPga&t1}xPN%Tao?kG{egkQab5XY$D{l`2Y zR<94-=qYkz;+#frF(GEs2>C1%F;nce&&?|Zc;9Z$4qQReqJ!~VxiNF56>woK z=W{(z738uE32y!HWte9y5DEINf!Cdeuq&8-^YjC;m#n8`4 z%Q`3Wz>eqdGUiUciaABjd@|(#79fSg%ZTi5VC=vv6sht@C}G7loy8yLwAD1ahIQIX z3o&Qbv71u6+O5v>@B=Eqx)ML8c-dz<*fHfa z?;A6|L-)&7B?$>?k}W)qD^<>Y*S(|vtZuwUCk1kv341gI>OwNDul0oqN2bE8q6uFs z46^y6Fy=IAgc)zQwp!O)c-kH*$%$`dXA#*zhn}mKV>T6ci_GlBtGUm`Vxd@>@=-N) z_QTr16JH%^=%&=`Nc_l{*KmR*COQrd?;)M0d#U&H2-(SqTF3~21TA(j?ID5p#|aG& zimX~SZUGkt%(Q(a?3sLtpwwlMG14F#Jr2s?xMDya1Z{gRKQHy`Te@O|&!~Nae3zZ>lrqp~F zg-+oU`J7zFU8vu3sr*s9i)~35+H@Cx;kx~Y52!!Dc|zc@=VJem2lZE+m1gKhjG^!! zO&sNc&ygqqpeay`#0fOyNj zwADa5!>Wu`A5-1~JhzMtkyqg&O#~~j8~%Pl0^=Lv9ys>@33E7@)gD(2hc=eeoH(RE zO!$k)D#Ujed7Np@N6AO6(Z(C#5pd->%PwOaq#cp%1c3~}B9X^;;p%5PW}$ZK1Gbqr ze%IqE=#!2Ikaw^F?REug&@ts0;0JmsPJM}62VswLz17BPfz0$m2ziNRenWMiJ&e+l zR_Y%_EijwCf;~4^iFN$num0m7hqw@#>x>83FfGgE1k$fa4A&RI@nDwBZH{;86fyD& za}o)j;B*k2j?vh0@l|(I27V+{-Ggv#XrnX=ts<|$w_yhdDN`D+!xXKETHu_~>SKtr z#RW$gve6q1NYBLeCJ^3LS?D26Uh}lV1kkKN>bQPjSA8FHPlxa_bEZt}I2%7rMlODU z_0SXI3~meY`)1?HO`)?BsIQrKI*PwT0L~y5)Sg&oG}38 z<{#z0@U3r%hgp@viZMv1*Z)ZyT4xW#5OQiqIeHu*6BPhN2H7IP&=ov{08!`?;9b3gGr&q zNvPiwA=Y%4F21zb2?UwGnxnyh=+b4nz!&w)XchuFnoe_4e@x0S9{yS_TDt;;Cg&f{ zvR)%qJsA2p7_~*n<-U#mXf(|q(Q*37Sbw z?Hv;`Xg;h!oS{Y7s6P|EA)RG_=q~1bj|SAz5JEfP=VRytxzrKV)v}Z_!N1dYL(Q$U-gtN`ltN+9(2~mA^Gv=3C~)d8 zpqo_p#15aRJxCkkSB;PDhy(uvj0=)0iuAa?f-w0_m%*r)y>*}k z)FfRWgM*KCL6LK1L?Tc6_o`7t42m%-J;7Q4#~yZOGhum%woB_F<7xX)pxFqtDCuVXlYE|rhxD*%ht!a<>br4w)oG`F< z;KSUck`IygRytlMzr}f)@aV1N6>#Dx(r653SB+i-(ZchEQJWV0q_)==2eN^b`6jT1 zFm@>NpcsWU+U|3B;>OtfA8I0J)_-A~P+cyFDN17MBby3cJs|?9A!fv28G>5>){LI1 zQK;m@{{R_FbV0dSrIj{{9v}mCbb{IRZl$8=yY#fyO#$c|G>IUTAfp|s9g!)FDyX@I zM{}jTHLMt^;*Sx<*)PW^(PLc-qalh9MLxHg3i{?HIt)5mIqbG$K1r7-L9m6B+GPWw z)$eAm&$2#tF@!TNrvq$;%jV<)?kf==vD;Au$JQ!m?XvJ_q|!DmkOfX)`Qv(17hzmD zGtwk}OwLkQ%xJ1&t2(Iwg*a_LZtdq0DuVHEU+i}YGAJJ%v+Ybynyz?5W|%}9Xlukr zAlT{_#8}>wGzNDbOdTtA6iD;XVW1CSAj4MTVxOoa?yv1^i2cc<|8A;d*n59vrcg|; zn~TzFq8tkUweDPb(y{Yi3(0ZYW?avXZ{@sVQT#S`mu(uz3@IEx+At?Pe2GW#f6p%q^{^7 zr_jd?5B*y+C{f(#tN2)7QsNB6`J@*3^m$O2s})g+hScml_^uE+drC&SxQ^;N`U%u9 zNKWHB@ZLri&0uU^8;Qjvi7uZgCb1k!RnBO+y2v<~GjpT;0?bV)yIF{1gwQX8SoAJb zTW#A^#(;ACd8PnCqAdzHl@HAcFOmxC(;; z+sRgdGN0F!eiW)3{?aZYcc8ulig7Tj_oJ4Cgo7@Rxm%2oZ%w1f6L%b`S8-Ea2UG2S zwXALlgVTo^6~T&<&jx4YeF@EyzXulP_TcH!Qb zx`+%4bx#fEHs+#)9d^4eIUUL2wxNP!q))}oJvoB|$QqC)(cRaBd#=Fe9B@AxYlY&P z@Vnsedb1V|pCP?KH7h-;<*b@V{#Ngc@j$r=*uKrLxYVGNHy3vY6&oIn{3V? zrDECsL74uKsJ7;&~82_8~ z43p^u6J*sGyszhnJc}% zvwl_Ma}hi6Lm< z_`n6MkRLc2TEy0vg>HFmmn(2B1#MoFFm-m4=H`8@gX$>3Cz7o;p;mif4%2|5P3$cM z@}qFW1WGhjg9dPBwb=rLUr|;Gj~WA6Cn`?|RxsoFS?wk%#l`^}C68KcHv-@Jq~`48ujVKv;jm zlbo8L$oK)Jx-i>gOI-G9<*Q-KP^cnZMJkVD=Is7{b0@h^uNH_od_8LA{VurOkmU2a z1Y0VWFC*!VzgPKg*SlzI68o^vX5dI--Rkh$cE8z<`tRVmmMURE0hgF*m(U`QOQCZE z>1PN5CnBmeUHsoI=+2B*j5b`4OSrVa-t()*S@g#-cjBiTWy=m`Iq;+y zP}lp>pwf;&h|hh=ST!1waq*;EVuF0ioRn7X!yl?vvNXLf#46 z#nyQibQ!hG2y^SH!wiqUb1Qtt^B{JM%<@$s?mu8`1M5 z;VV$_o&#_#LnMkHc{dfZM4b7L@dwve^P6^28P;3m>ttGto%P3_7NeH->b0~N-z|sj z$JS+7uLJ&{4saSWvr!^FLU%c1!W8ftP94};oo`O@?6n#AUNqU%J;33IqIuG`bJ>$N z_7-C^ahL$cEU$7q%9$|ibngJ0-^1nHLAq0LNk65pe)nxvp##42if__|V0lQV{UNJJ zd$1;9AdQ{o+ol$D?mo7Bn>cj|TZJNo-TG-SR_aeZiDL;=#6kF*)*8YTY!LYq5^z}; zn|UByCW8DIytjYEDl0h8XI*3xB}Pg9j}N}y^UWISYaH1W=)9rSw@f`3#mhJ=&o+hN z5QPWn3JW3Sc!G#HRfM3khNa(~_dL8`xL`aNe-E(C@K>&pw}(6y``JnqA@zO~`uAU* zi`PR$kj(&7D@p+3u9(b?xDSY(yzSX~z=YMjykhF@M37|`|QF&4#kH6%Oq0Y|LLj-2vVy0G< zXrY`6$|RRe{Tu!`s6T)~7Ddg2p5Mu3C1!E2YxdZ37kKf5tR$Q+e!V9Q1k zE%C;>^hFc~igxHr3Lx563~Bx*ba1IEN#i3;yrPIefH)3aJ@K>byN z6qG>qsFSNXE2sU)eYmU4c%hi#Lh#qMQ%QHtswJ1=)Ei5pVMp9|BGKGu?oUAefz_d=I%y-03#F9^ zu$Lnv$6eS05yr1k0!bqvbVwNxCX5G>iZIJM)OtjgHMRx_TlAG*`uo*IEoT8WLDs2H zlPAxjo7Ke@&1r~rC__Y*3l#>ZRD*?PJo|6<`Pd>4yVwoUbbC3d48R859X;(I^SDf% z4P`=;)?UJoly6Kshqk)z#=w2Ob_7xVIus;aKj6||xu`zleOe4XsAVDHptmw}yA|bh zyI>Fyu&>UI$^|O04VRbRfD(iPxurTM&euN{JVUmOwY%^HPA>!9>&9&QUO_}4&E_|un!hJS(7vYNhS zi(((2prTO|AI=E4OczDGy@97gn5V$*V~#{8QF>2zd_$;25X2eWGO*lg%2xA$y8V-a zAejDsSDZ8YZ}wp*Z_!{y(YvO9!7*h)EpEIfDz}V*H}@g#?%o{F*GK#d{xGi80-hF< zJv8J&by>w%$f7J*-K<`Y5@gr}2mt!rKN>1viKe@&aP|$0gR!(0Lj@}8j7B-ogzE%5a#;xd`gU-)JpnaNWxr2Mg6hk&$$0rw@@?lSGSl?D2aj*UX2?0 z|M3ZNeP^HdYjha-D!Hzg<^M6Fo(TwR9dt;miXfAs9P{jJ#aG*z*uPw%Dgwwa+lsC; zp?{CM%lWPrdKvc@5d@)H=6|d_pcH$=Vqx0{ly!zJ=L0NCqZcO%=9GyLQcSXp(OFv* zu0EB6qx+z9{N4X}V{)A}GeGxv=>a7-Qyj9 z_ZVMP?E&(U>&&Fq7qy1PJF5S5%Jueo-^O{}L?zD;Xkw27VVwQV87h>^KAS8*91+7- z0$@745Qq6q&+Pnr%rcXS+s)!&C~DNri*=*f{~5TB`}m_s_J~n&$-<4x7DZjcr*sMA zDh(}Xah-QcUUKMF+TKJ^1Yv-S?9X@no`uHkHs|~-GX&}yAr*86CR+`02D9BWE1GR* zO2W~GQdP{jKTi{32o=l5Dudgn3`1JsBI_;AyhdAJSHr4|HJ$T+{%j^RCC_P=q9Rqq zNHgFN$ckk6+xA{PHCrqqd*5FcfVz zUOhbOAA%G>M>yROL`M~b`D=pegeCI~U0&zujE(nf5L%7W7Kb9L9)jW4YN)^u^s{hj zxk-;9lr_|@9+pBthZ|BtCN-A7$HES;b|ZxJdd7{;@}QQ2EwQf33mB)>&~#}3>O`fu z<&80f5~TCJpolY*=agMuSD-vE>?^rG0Rs7@zs3?FptLSdgg|!i7yl8XQ{Zk;Hy^DR zk%ET6_nBTwpPmmDLF9!R$2nP)f)IHWU*YTpwy%APP-#ygT1IXuuI_<=UUmtrEw{Ow z$nqRAkuU+#Hs!P(BbRZJ=57horRdd*KXr->UP5+>z4QZ!EN~Gf+&j*qA^@23kLjOz zS_!6o2$B>$l1-4!SBp=4JVcnlsun2#?-Fbb_!S%U#%Mjn@UkoHFQqq19h+--{MwvO z{_IZxFY(k{X8yuOm1nyBpy%!m|08aE(}o? z1kVC)>zi-a4nF4h{VM43n=^pDV>IAQjk?0>#O!lo?B}7VTCbqmc&L`#o>BOVa~kLt>k+MArW!@NFKGW{z-U_IP6_&RtlAX_hiSdU#Kq_PMV{kQaGOc7xeL0sK@~f|IgUv9c`Vdxf7+RcbE)0XKt`Sbo26 zy`#xWK~#}JN@Mu+$2ufxX|dsB^{wJG4&7E*Im9se{$;k<>Mp(aMNo%77|V#=|7PHw zN#E1q=yAAoR7k-)nP$Y|PH}U?O}=plOq2=VDwGfv?wY$re9AIiYcqbv`6st8Cg~AZ z>bzq|9Z3hmBFci}imrUNw74MY*_~?+odEJ4G2^zwwM>*VpVjm4JH2h5)MOyd+F8u@ z?RE`Q01b*bN1TaDkpm&L3_eloq@>l^FQda(YF7K)tpu;D^|HD0YGR0`$RWkry&K>C z0;w22rgvaTe0n=5nyrHa>iZR22?v;C>Iz0@darucN|6-&y61e*YEMs(2bGm z?@~9Y;wQuo>|;YFF)lN4dzcp-Er-fEQhgqsWH8M!RaJ~Mj>2nItF8kr=D7-E&oB|; zaD2!x%cZ2cuCtZ{lWQ_ED(l@DA6R^uwM8@aN?zb>JLj3u0vex{{^uhsbSbX@+#JJOzOoklbI@pVtRN*= z#!tghaZhlWeB95RKF-Ji>P9-MzzN?jInciSE)#gYjnk`E4L3uXNgky3g@qs(nK5=M zqZE;b_h&9PUOYmEYqD2~-xvUliO|);sdD zLR96vjGEgHVabmwl)MLe5m&4oqi&`a9s?VuMu_8eKiv|Qe_ySuX#&v!5TZJqh_c8( z#(kQpfbDfbzCXNQj|b*q&g(4Kxz2Sxuj^drI+2ede5^t5Zd_7r zxYtX{#c>tWj#a$KR+4#>$5rb?G8IcY_n)q7nCICq2-QE++K~s|w&%~q!w;}Q6_?Am zb9oxfp95N<7&U4Kv7Pt%mdUQQ7n_~fKR7+AF}$a?W_&)dc3qR;yJogICc2fnzu$mV zBt;qeNatunWqy-Fo@2nvZzUE~Fz6s1!0waW*7M*PXVqqyd`z+PT@y}iam z`qih8JvFBOlgtCFcHXC6AN9EJI*6t(0(10n><~o!j#k0Y+q@KmLdwcr`a+49%Ck&3 z3`)&=zjg7wv|BUddzZCo*mc((B70NQ%wA~^?+%L@)xu=XN`?E4Gtm=yj2*P%G8ba6 zyS~xuR_)XEZG2{!(6&j}H-~#}XXiY3Nhq3&mk1&HGRdY6Aa^1%e$2xyR0E#G+G;5H znlD2h(NvPHlzP2+QFq8rz{1sprOz(8ET|*() zm;;dA?%2sUCdhBVU#g9sTd^6R4PvUT%R`lW=5-tCk^zOiHROfkjS8_rV|}R7b0P6z zMfc9h`~Lfqixy%y-)`I96vqBM7KpaPMLut^>CNhNjdqo%>VQq3_0oO0-eQ>aSt0ci z5{2I57*o(F!zohH<4NXuxmVJby|0X6Y8Sci#e65<^U6gU26a(^U|imml8jbGU6{T) zNpGW2pJ>k#rlQNJb9&P|Lx@`IPSE5zX>*KG|6F6QW$PlRT}vkM^ihjuQ0s?@^F~r) zt&eye`iB5GzTHNCF4)>{#(VwlqQ22LKme~qGl9r9%A2M7<)7Y)SUOYiN#XDnqO-n2 z`nyIEBZ}>t!z&%+be(_=&{HJJx}eO0SMKMjX@0HPm<_#v31qpncAwC2={lC#*S^i2 zBpS}=x4gU(>F6)9Zm*bm0soOKS7y2vnWo8Ya)51U|AoIfPeE3-AAfq9@ydyBt5~rp zH6?jtD-1#AkY`=3cLJVVsF+oJcCYoVtNZ12O;|`AOve5!Q%t!iY*WF{;LLxfE!x(nSgx9KBWr8m;(w3w6J2 zY{EnWtv%G;JQM30UA{4eJY%3G@dgt(22jm+Fd5l7^(kcRtGRgM{E9)u@~(A6#4UyT ziy)#hNnN=FHrpPQ8ss?yqe)pPlbpkl)j3p&>469JFL5 zf{tq!rcG+gc^EhG1Ba#=rUU(}aDKY2Z@BBvcFp_CZh}#5U^5Z`r|IQEZAAzEfV3gS zt=gW1z-U1@TcvJjy6FJeT`=1xcf>I7bSW~sst$!J?j}u#6~BD1cTGDgsLg|~SDV&Iqc-w7c;ayGv-x`G(>PFzPaG3g zCcTtpiwd|c2o+DvWJXK0Q695aAxU5kii!e>@O3eSpCml4~vq|bB1K*f}s<)lM>slu@BxQgSX_oAf7(RJ4y4xW9Du)iV1 zzx|<~A64!w^kik#7@mu2cqtBl!ah}+b-=vdQoV~(UQ&uwsv;eSdzVU{Q#XIQb062eV#80TpPq7FUllYq1ysA6aAkT#A8-htY^yq+>LwNP+8C=p|Odpmv^_@}dOnxBK&v?bkKOk4UK*=G7sAy=-n^fq>~tmJlmKSIUq zUiHQ2uc#W58oNgdZe{tAfiX0t)*7$Au(;&Aa%ZZ3UC>W)*l&`mwjT{V@lt`l(DSVe z7>S<+?Scv}!oNI;O$RSBU?{j`gw zM5Sa3mLz&V=gY+BYL3ReKk48gRFv+Y+vvlG+^ga5L^JPUK=kE<>l3*AetPgUL&#%+ z^Oy*b<*`g(6FAOvIQ237LuPa%bqN@GBC}N@mTjwa!L1$-3(L=Bu|r6y?o36KNn_FE z(-L-DZ#>!+GdXd(V(F8~s;3*a0(*KC5tF~vUa;@6kMVrg3c9^bE#><2$o#6$t%WMq zj%}{0)|fV}B9kPZ;tuD8s~JuCz%y`@A^LhNX!HwAF%^9>IbO4oWuzP3@}wgka|bGf@$%lc%a>U5hw93 z(O^Dfv@fQ5p4^<&Lrm1Q7$sj#RVw|i*LqNL>iQ@iU+_NRsRoyRVWq5*epFG$(J>uhN9jRS5KFf+DM>W+8XN|jec7c51RsT*Z{r++@%)3cP}=ohl??x}?9^Pptf zs-R--7Ild7sC?MMn{%J->+MTNMUn?wor^fk>YjZ~s-D!GemauEvI+Eul2PTQeYA}J@vXeikS+5&ay9~aY{Pr^fIEwU5zOW!4gm5) z3-RR7pmz^|uOO<*cMV+YDD=%!fM1lQ1Xk5-9Z zg(A}%ZD7L`LQ9kI*KhLSQveyzSB`j!0xbf`X1Fvzpm=yPU|dfI@6%%D*Un-Mjs)HW zwoknJG`l<$_-YZhybTec{G-{HTV_0DuW7i|=@jUzj5d2XJZQx@ngx_Te+WF9> zfbb;P@iO+Aofk&(;r{jO7_5?$(UtdI3Q&oY8PC+N4m4XGaM)L;ro#Q4J?GoF7;22A zet@C1E{_Z0pMn>C>KJuzFV68o0I)c?KrH{o?Q@F8*%L(6%Sd(IqkRrdr7#HiFq3oPB3dQY=`_T#f8Q_gxM zlanxZkB2|j2%f?#6V3rSA4=dG@WAmSyg>#jFdO&>6!)X_j8$i?;vMVCs5q^FCNGU& z#5ylufe?+1$dW+9{^xsx3ZSU7Y6X3lvD>5Cz9xB?_So1`7LC&&;Dz~(5(vqbxZJM-7FaU& zjQUW7Fn&gV{z{^9R4;&{StK;m)~D4o!EFFNu|JOyEQH7Y0{INQ)XIv~ayg&#uC)d> zQWHbL0<{~TU1aVdK_sj#qz0j4QNxjJ*t%;FA;}dzGcpnaC5wWEuKrgKPaQm)v;v$- z{w)2B5iV#|+hgX_kqiN_0MqEUt@TY#$%L&?0ndh^KnEQF_M zD4#8mU(ld26=l4}i1c+vbZRJz+B{?ndRc0~r3nI$pqW@+d(R1{z4)IAy2Q4UE6wtG zbETT=i_5|v*kYL?QFqI>n3O+=9KFbJmvcz)2Fhl2OSrRkwr4lO)fzzAfIlOpiX7&bkR{k89q+?JOQHLmWdEAw>-o0GuQO==)W!RvM z(m}047cN8tfkU!Yn;+qG=CLM-5`<=AQpiAlCS$WmIZWByI%G-DZy4~*ys~IC5BUUU zT=M(J>F)Ns{0L2x^q|cBVt5?Ej)%)%>j7F}EVXF@wjZS1g~99LSy}_ z3q;I@>UDsD*w|X%VBgMFtQj)&ss07zv?*i=H>+_-Op?tisUYX4*&aMD;S}G%g(jiv z{oSS#I=;Swf=nC~r=O|$9bBrOf`mLYzz4Lw_LLc*O18_j?zN>$l1b^pE~U~KYSVVz zaU;1KgjOqPRkmZ*mgRxS6N7*`!L|+5fCVW!Dz5U$b`}2Jk`oT z)VP8RSiFF3*q}1aX$7ln>f|F%ZM?ctOn$p^po^IpgR)>olH7UM88<=-lnkZ%jWOUR zgdA4%vF4ubD@+?vp}&b*Nnn?R+mWv|362d(tPWxP)z_y|^6Yn{hXxpAF&Hi51E7j^ zYR0eAW)hP=i;{~=E1&K#N#DO8VEUbPh>#OK{ns;^&^~a~HG)VLov@iIad2s1;FK0S z%*KUveTDe(p6GM{)Nhd_SRuZ7r2w{oM+%VG2OWSY96S20^_h5KWC{{^a+#)X(|t@o z4z!Z%BiCmnl|&Qri5n4;GzAC0#3gz|0iN<({6e?k2e6_^lWFTs_5o-DNO)Qa_0dak zGez)jpFqr9x7y4w7}lq!)=8%6LE0Mh;nfu_zvXojBBzmtK$LnIJ5LJ~n(9JHX{w2gOTQVj!rIXutqv;TO? z5cUAXANXro?$+e8b-|NvyxMjX@fsk76m@%{2ohD}m~Jj3hJ4HhfWcoat6>a0Dakk5 zwd_KRR>7M8vnJkX_sCb!x=M~R^2M$_&tDasc^Ct?3%QMGCk$l)tPZ$B_F(~bff2qu z*4lJ=)K0lY0ipRJ|Lygm^VGUHUz+2pLaBGd#R*1L;|oT=Z>vMh5@@qu-wwC*eq*?R z+0I`A&D4#9n8<-Ir|yaCZ9o0uoVvhn7n^~_QeTspgKwA-xOA45y7xu1B^{&Kr#*; z$1+BW5F?1t#Whz`Rg?^6lnT@(=#xhh)nQO_X{(gTXr*vap_%G;c|0!7j@#bb3uyDH zU0`<#2Q-Lw$vNNYc3>R-`>4cr6tpfnpxS_kkL~D_#1(6A91f`ilFL3UAND;)!?_Ym z!MTlEYuM|ggq6QJ5!0}j zJP5#~S@MOizPn{@Zf1cixrZ;(qjy<&a@L-Jq1);l7KQeGpIlvN0+uA7pL3=zZILq1 zHBAdA{q7g!vyX(3m9-HAyDp-<6*H~!kdssg#xm9gVWcKn`%)5dn*n%tdXIl$i)9#S zKoD-JBMSFB4F6!HxLkYi7&l=-#->5JFoLyM$1ePk{Ly62 zWRFqQ(?qe&z|7i5VQ8h)uSuLk$dIYoxh1fr_wQ4Ng28~q2=Qj05%IFO*EvJjvUcRb1B2M7OEZw`s$icSuOkHc`>64SD0Vk~SXWO<@4eU_Y z-fSeXeYMCUBfSBIbvwsiZUoD2y{x^n0J_09e=$DW@tU0U3f;EZ+Hh;R`OC~|xD&lD z@ppxgc*BPWD6b^i#dFw2_6cclAI58=OQ@$%Opqo0t21t;Itkp7{8eYlP~qH5h1-LJ zB`FeVZ=!bLj2D9_>m2B@Sq@Kkncl6-Tl$jdFYGoJydU{F^qg0TvpeHZze5tn=6A=g!2}Ag@dM5&F`zsu z&@{Lk3cdceBk#O7;NW&7xMg!ZQZ=QxaAu(^sV1p}tLm8>w)4k zwpN;B7lR?ygi#-Mb|_ik#%7y&>O`oFLKDo!=v@F3KmIULM3J~JM?<;TJb>72xO9(F zU4Se_+P@>eoksnssUa49)e4;j;>qIKpYWE3_X$BGI&yexs|yuryR*->-BV)koQPUM zKk`H72_d}VCJf)qZc(bPcTD6fy#VT>@>svfc|X(8^QXpmBDW1W?2u(6s$+`VGyl|K|XkqVf7y7Z3oZ-o#~?puHSIP#OQJuZ%~ z?wOSUrsn#e#a+-_7mL9u$al6a(K|_Qx%9I4Flegbo{~N61}an2(zEfNQk=fS=K^y& zrOQ|1Nj_B2Gu9hJo_OOs{S=?|b7xKsV4h_4I+f}6?U#NNwbN~9s^6j0^_R2f1m3Vi z-!Sp)Z;El*N3iair?bwx&uc3A-OMjINg|b6ER&=-EuaFEODS&HlM#N%d28pk!v%uy z3QtYh*fW8|=&|buW?lQK>l5}G84Q~UvoZF&DVC=IRi;`l%!JVD|##NL`?6XkR4 z%RgL3wg@381g(J>q)5op#CV~DK;g&pgwkz#CW#?q&1cN^5n!0em8!$*B#np*-Fl<- z@rJK&?u6&sgs7U_Fo5T$$D-Jv&iIoXp4|9Wa0S_PHgCX-;H6X{*NRoq&5`r4MqS7c z&Vf)e-41QaeqZe)?-o{R#F`xN{C=Xv!65opAZe9AnO@lm|8pJ=K=tESFUi~QR@B#n z@c>!jx8zV(d)<}?LQuXrw#5`&te@za6tR=~NhdVV&W(LvMD>19gt8x{U+qO#GzsTr z4s*CXZvop)zGEmelf6%ADELWHc<)b;-147C($_tRQ!b#p@YjRRLhxxj7Q`of!-mJd_%#%{)19L-icCksax9@yu&gb0$t8qvIU znJ)bfgwh>L_e3r+&w!dK_Te2lF@+>wx@GXDGgea#C2yo}5=1PK7P$QtH08YDCr{M!|8$yr-xGRER@8`7Up`KQVq1kd>N5!8cvZaOQ1pm6{^%F_aI$_D++(Gyc zcEi8QCz49VCzpTP{3amOow;?px_(ob;nw%*#gYkU1)unJerPf%HAy<0b6DWhEu54J z-B%x;t=i}wcC4i`Ar|TA^*{(pPMf&#ZQHzce!9vv6j8M!J#^N7ApgUT!fDS}akJNV z=UmsPw1y6UNLLt5vJc3?jthEBU8q%h??eriD+s