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 0000000..b8c6153 Binary files /dev/null and b/LibraryDBproject/LDBproj/RscImages/AddImg.png differ diff --git a/LibraryDBproject/LDBproj/RscImages/BookListFrameCover.png b/LibraryDBproject/LDBproj/RscImages/BookListFrameCover.png new file mode 100644 index 0000000..fe7b9ab Binary files /dev/null and b/LibraryDBproject/LDBproj/RscImages/BookListFrameCover.png differ diff --git a/LibraryDBproject/LDBproj/RscImages/DelImg.png b/LibraryDBproject/LDBproj/RscImages/DelImg.png new file mode 100644 index 0000000..525856d Binary files /dev/null and b/LibraryDBproject/LDBproj/RscImages/DelImg.png differ diff --git a/LibraryDBproject/LDBproj/RscImages/EmployeesFrameCover.png b/LibraryDBproject/LDBproj/RscImages/EmployeesFrameCover.png new file mode 100644 index 0000000..5dc03f5 Binary files /dev/null and b/LibraryDBproject/LDBproj/RscImages/EmployeesFrameCover.png differ diff --git a/LibraryDBproject/LDBproj/RscImages/OperationImg.png b/LibraryDBproject/LDBproj/RscImages/OperationImg.png new file mode 100644 index 0000000..f192923 Binary files /dev/null and b/LibraryDBproject/LDBproj/RscImages/OperationImg.png differ diff --git a/LibraryDBproject/LDBproj/RscImages/ReadersFrameCover.png b/LibraryDBproject/LDBproj/RscImages/ReadersFrameCover.png new file mode 100644 index 0000000..a7a1068 Binary files /dev/null and b/LibraryDBproject/LDBproj/RscImages/ReadersFrameCover.png differ diff --git a/LibraryDBproject/LDBproj/RscImages/RegistrationsFrameCover.png b/LibraryDBproject/LDBproj/RscImages/RegistrationsFrameCover.png new file mode 100644 index 0000000..7214cbd Binary files /dev/null and b/LibraryDBproject/LDBproj/RscImages/RegistrationsFrameCover.png differ diff --git a/LibraryDBproject/LDBproj/RscImages/UpdListFrameCover.png b/LibraryDBproject/LDBproj/RscImages/UpdListFrameCover.png new file mode 100644 index 0000000..f59e350 Binary files /dev/null and b/LibraryDBproject/LDBproj/RscImages/UpdListFrameCover.png differ diff --git a/LibraryDBproject/LDBproj/RscImages/WorkFrameCover.png b/LibraryDBproject/LDBproj/RscImages/WorkFrameCover.png new file mode 100644 index 0000000..73e6ea6 Binary files /dev/null and b/LibraryDBproject/LDBproj/RscImages/WorkFrameCover.png differ diff --git a/LibraryDBproject/LibraryDBproject.sln b/LibraryDBproject/LibraryDBproject.sln index 687d1bb..6b6969f 100644 --- a/LibraryDBproject/LibraryDBproject.sln +++ b/LibraryDBproject/LibraryDBproject.sln @@ -3,7 +3,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 17 VisualStudioVersion = 17.8.34525.116 MinimumVisualStudioVersion = 10.0.40219.1 -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LDBproj", "LDBproj\LDBproj.csproj", "{BA5F8F6F-85FF-43E6-A4B0-D8DC7F897FD6}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LDBproject", "LDBproj\LDBproject.csproj", "{BA5F8F6F-85FF-43E6-A4B0-D8DC7F897FD6}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution