From 3cc8a5afcf056b9ccaf54d9f918b27a60845c218 Mon Sep 17 00:00:00 2001 From: Kirill <39030726+Kirill3455@users.noreply.github.com> Date: Sun, 22 Dec 2024 22:20:57 +0400 Subject: [PATCH] 1 --- .../ProjectExams.sln => Project/Project.sln | 14 +- Project/Project/Entities/Decree.cs | 15 + Project/Project/Entities/Enums/Course.cs | 11 + Project/Project/Entities/Enums/Mark.cs | 10 + Project/Project/Entities/Statement.cs | 22 + Project/Project/Entities/StatementStudent.cs | 20 + Project/Project/Entities/Student.cs | 21 + Project/Project/Entities/Subject.cs | 20 + Project/Project/Entities/Teacher.cs | 19 + Project/Project/FormMain.Designer.cs | 137 ++ Project/Project/FormMain.cs | 75 + Project/Project/FormMain.resx | 1718 +++++++++++++++++ Project/Project/Forms/DecreeForm.Designer.cs | 141 ++ Project/Project/Forms/DecreeForm.cs | 42 + .../Project/Forms/DecreeForm.resx | 50 +- Project/Project/Forms/DecreesForm.Designer.cs | 99 + Project/Project/Forms/DecreesForm.cs | 46 + Project/Project/Forms/DecreesForm.resx | 120 ++ .../Project/Forms/StatementForm.Designer.cs | 175 ++ Project/Project/Forms/StatementForm.cs | 74 + Project/Project/Forms/StatementForm.resx | 126 ++ .../Forms/StatementListForm.Designer.cs | 97 + Project/Project/Forms/StatementListForm.cs | 44 + Project/Project/Forms/StatementListForm.resx | 120 ++ Project/Project/Forms/StudentForm.Designer.cs | 144 ++ Project/Project/Forms/StudentForm.cs | 77 + Project/Project/Forms/StudentForm.resx | 120 ++ .../Forms/StudentsListForm.Designer.cs | 126 ++ Project/Project/Forms/StudentsListForm.cs | 99 + Project/Project/Forms/StudentsListForm.resx | 120 ++ Project/Project/Forms/SubjectForm.Designer.cs | 118 ++ Project/Project/Forms/SubjectForm.cs | 91 + Project/Project/Forms/SubjectForm.resx | 120 ++ .../Project/Forms/SubjectsForm.Designer.cs | 125 ++ Project/Project/Forms/SubjectsForm.cs | 98 + Project/Project/Forms/SubjectsForm.resx | 120 ++ Project/Project/Forms/TeacherForm.Designer.cs | 116 ++ Project/Project/Forms/TeacherForm.cs | 74 + Project/Project/Forms/TeacherForm.resx | 120 ++ .../Forms/TeachersListForm.Designer.cs | 125 ++ Project/Project/Forms/TeachersListForm.cs | 97 + Project/Project/Forms/TeachersListForm.resx | 120 ++ Project/Project/Program.cs | 37 + Project/Project/Project.csproj | 41 + .../Project/Properties/Resources.Designer.cs | 93 + Project/Project/Properties/Resources.resx | 1231 ++++++++++++ .../Project/Repositories/IDecreeRepository.cs | 9 + .../Repositories/IStatementRepository.cs | 9 + .../Repositories/IStudentRepository.cs | 12 + .../Repositories/ISubjectRepository.cs | 12 + .../Repositories/ITeacherRepository.cs | 12 + .../Implementations/DecreeRepository.cs | 16 + .../Implementations/StatementRepository.cs | 15 + .../Implementations/StudentRepository.cs | 28 + .../Implementations/SubjectRepository.cs | 29 + .../Implementations/TeacherRepository.cs | 28 + Project/Project/Resources/Add.png | Bin 0 -> 14601 bytes Project/Project/Resources/Del.png | Bin 0 -> 16895 bytes Project/Project/Resources/Upd.png | Bin 0 -> 12849 bytes ProjectExams/ProjectExams/Form1.Designer.cs | 39 - ProjectExams/ProjectExams/Form1.cs | 10 - ProjectExams/ProjectExams/Program.cs | 17 - ProjectExams/ProjectExams/ProjectExams.csproj | 11 - 63 files changed, 6766 insertions(+), 109 deletions(-) rename ProjectExams/ProjectExams.sln => Project/Project.sln (55%) create mode 100644 Project/Project/Entities/Decree.cs create mode 100644 Project/Project/Entities/Enums/Course.cs create mode 100644 Project/Project/Entities/Enums/Mark.cs create mode 100644 Project/Project/Entities/Statement.cs create mode 100644 Project/Project/Entities/StatementStudent.cs create mode 100644 Project/Project/Entities/Student.cs create mode 100644 Project/Project/Entities/Subject.cs create mode 100644 Project/Project/Entities/Teacher.cs create mode 100644 Project/Project/FormMain.Designer.cs create mode 100644 Project/Project/FormMain.cs create mode 100644 Project/Project/FormMain.resx create mode 100644 Project/Project/Forms/DecreeForm.Designer.cs create mode 100644 Project/Project/Forms/DecreeForm.cs rename ProjectExams/ProjectExams/Form1.resx => Project/Project/Forms/DecreeForm.resx (93%) create mode 100644 Project/Project/Forms/DecreesForm.Designer.cs create mode 100644 Project/Project/Forms/DecreesForm.cs create mode 100644 Project/Project/Forms/DecreesForm.resx create mode 100644 Project/Project/Forms/StatementForm.Designer.cs create mode 100644 Project/Project/Forms/StatementForm.cs create mode 100644 Project/Project/Forms/StatementForm.resx create mode 100644 Project/Project/Forms/StatementListForm.Designer.cs create mode 100644 Project/Project/Forms/StatementListForm.cs create mode 100644 Project/Project/Forms/StatementListForm.resx create mode 100644 Project/Project/Forms/StudentForm.Designer.cs create mode 100644 Project/Project/Forms/StudentForm.cs create mode 100644 Project/Project/Forms/StudentForm.resx create mode 100644 Project/Project/Forms/StudentsListForm.Designer.cs create mode 100644 Project/Project/Forms/StudentsListForm.cs create mode 100644 Project/Project/Forms/StudentsListForm.resx create mode 100644 Project/Project/Forms/SubjectForm.Designer.cs create mode 100644 Project/Project/Forms/SubjectForm.cs create mode 100644 Project/Project/Forms/SubjectForm.resx create mode 100644 Project/Project/Forms/SubjectsForm.Designer.cs create mode 100644 Project/Project/Forms/SubjectsForm.cs create mode 100644 Project/Project/Forms/SubjectsForm.resx create mode 100644 Project/Project/Forms/TeacherForm.Designer.cs create mode 100644 Project/Project/Forms/TeacherForm.cs create mode 100644 Project/Project/Forms/TeacherForm.resx create mode 100644 Project/Project/Forms/TeachersListForm.Designer.cs create mode 100644 Project/Project/Forms/TeachersListForm.cs create mode 100644 Project/Project/Forms/TeachersListForm.resx create mode 100644 Project/Project/Program.cs create mode 100644 Project/Project/Project.csproj create mode 100644 Project/Project/Properties/Resources.Designer.cs create mode 100644 Project/Project/Properties/Resources.resx create mode 100644 Project/Project/Repositories/IDecreeRepository.cs create mode 100644 Project/Project/Repositories/IStatementRepository.cs create mode 100644 Project/Project/Repositories/IStudentRepository.cs create mode 100644 Project/Project/Repositories/ISubjectRepository.cs create mode 100644 Project/Project/Repositories/ITeacherRepository.cs create mode 100644 Project/Project/Repositories/Implementations/DecreeRepository.cs create mode 100644 Project/Project/Repositories/Implementations/StatementRepository.cs create mode 100644 Project/Project/Repositories/Implementations/StudentRepository.cs create mode 100644 Project/Project/Repositories/Implementations/SubjectRepository.cs create mode 100644 Project/Project/Repositories/Implementations/TeacherRepository.cs create mode 100644 Project/Project/Resources/Add.png create mode 100644 Project/Project/Resources/Del.png create mode 100644 Project/Project/Resources/Upd.png delete mode 100644 ProjectExams/ProjectExams/Form1.Designer.cs delete mode 100644 ProjectExams/ProjectExams/Form1.cs delete mode 100644 ProjectExams/ProjectExams/Program.cs delete mode 100644 ProjectExams/ProjectExams/ProjectExams.csproj diff --git a/ProjectExams/ProjectExams.sln b/Project/Project.sln similarity index 55% rename from ProjectExams/ProjectExams.sln rename to Project/Project.sln index f49141b..7c7469a 100644 --- a/ProjectExams/ProjectExams.sln +++ b/Project/Project.sln @@ -1,9 +1,9 @@  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 17 -VisualStudioVersion = 17.11.35312.102 +VisualStudioVersion = 17.8.34330.188 MinimumVisualStudioVersion = 10.0.40219.1 -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProjectExams", "ProjectExams\ProjectExams.csproj", "{7D39980D-FE2E-4DBA-833B-871F30933617}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Project", "Project\Project.csproj", "{4618FAC2-6164-4984-B1D5-331D9192AEF2}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -11,15 +11,15 @@ Global Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution - {7D39980D-FE2E-4DBA-833B-871F30933617}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {7D39980D-FE2E-4DBA-833B-871F30933617}.Debug|Any CPU.Build.0 = Debug|Any CPU - {7D39980D-FE2E-4DBA-833B-871F30933617}.Release|Any CPU.ActiveCfg = Release|Any CPU - {7D39980D-FE2E-4DBA-833B-871F30933617}.Release|Any CPU.Build.0 = Release|Any CPU + {4618FAC2-6164-4984-B1D5-331D9192AEF2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4618FAC2-6164-4984-B1D5-331D9192AEF2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4618FAC2-6164-4984-B1D5-331D9192AEF2}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4618FAC2-6164-4984-B1D5-331D9192AEF2}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution - SolutionGuid = {6C158487-80FC-494F-AF55-7E8E19014902} + SolutionGuid = {9E9B69A2-5266-43DD-AFC3-5860FEF81206} EndGlobalSection EndGlobal diff --git a/Project/Project/Entities/Decree.cs b/Project/Project/Entities/Decree.cs new file mode 100644 index 0000000..6b20fae --- /dev/null +++ b/Project/Project/Entities/Decree.cs @@ -0,0 +1,15 @@ +namespace Project.Entities; + +public class Decree +{ + public int Id { get; private set; } + public int StudentId { get; private set; } + public string Name { get; private set; } = string.Empty; + public DateTime Date { get; private set; } + public string Info { get; private set; } = string.Empty; + + public static Decree CreateOperation(int id, int studentId, string name, DateTime date, string info) + { + return new Decree { Id = id, StudentId = studentId, Name = name, Date = date, Info = info }; + } +} diff --git a/Project/Project/Entities/Enums/Course.cs b/Project/Project/Entities/Enums/Course.cs new file mode 100644 index 0000000..9e4343d --- /dev/null +++ b/Project/Project/Entities/Enums/Course.cs @@ -0,0 +1,11 @@ +namespace Project.Entities.Enums; + +[Flags] +public enum Course +{ + None, + First = 1, // 1 курс + Second = 2, // 2 курс + Third = 4, // 3 курс + Fourth = 8 // 4 курс +} diff --git a/Project/Project/Entities/Enums/Mark.cs b/Project/Project/Entities/Enums/Mark.cs new file mode 100644 index 0000000..36ce4bd --- /dev/null +++ b/Project/Project/Entities/Enums/Mark.cs @@ -0,0 +1,10 @@ +namespace Project.Entities.Enums; + +public enum Mark +{ + One = 1, + Two = 2, + Three = 3, + Four = 4, + Five = 5 +} diff --git a/Project/Project/Entities/Statement.cs b/Project/Project/Entities/Statement.cs new file mode 100644 index 0000000..ce9a73a --- /dev/null +++ b/Project/Project/Entities/Statement.cs @@ -0,0 +1,22 @@ +namespace Project.Entities; + +public class Statement +{ + public int Id { get; private set; } + public int TeacherId { get; private set; } + public int SubjectId { get; private set; } + public DateTime Date { get; private set; } + public IEnumerable StatementStudents { get; private set; } = []; + + public static Statement CreateOperation(int id, int teacherId, int subjectId, IEnumerable statementStudents) + { + return new Statement + { + Id = id, + TeacherId = teacherId, + SubjectId = subjectId, + Date = DateTime.Now, + StatementStudents = statementStudents + }; + } +} diff --git a/Project/Project/Entities/StatementStudent.cs b/Project/Project/Entities/StatementStudent.cs new file mode 100644 index 0000000..b2ddbc8 --- /dev/null +++ b/Project/Project/Entities/StatementStudent.cs @@ -0,0 +1,20 @@ +using Project.Entities.Enums; + +namespace Project.Entities; + +public class StatementStudent +{ + public int Id { get; private set; } + public int StudentId { get; private set; } + public Mark Mark { get; private set; } + + public static StatementStudent CreateOperation(int id, int studentId, Mark mark) + { + return new StatementStudent + { + Id = id, + StudentId = studentId, + Mark = mark + }; + } +} diff --git a/Project/Project/Entities/Student.cs b/Project/Project/Entities/Student.cs new file mode 100644 index 0000000..196883d --- /dev/null +++ b/Project/Project/Entities/Student.cs @@ -0,0 +1,21 @@ +namespace Project.Entities; + +public class Student +{ + public int Id { get; private set; } + public string FirstName { get; private set; } = string.Empty; + public string LastName { get; private set; } = string.Empty; + public float Score { get; private set; } + //public Hostel HostelType { get; private set; } + public string DisplayName => $"{FirstName} {LastName}"; + + public static Student CreateOperation(int id, string firstName, string lastName, float Score) + { + return new Student + { + Id = id, + FirstName = firstName, + LastName = lastName + }; + } +} diff --git a/Project/Project/Entities/Subject.cs b/Project/Project/Entities/Subject.cs new file mode 100644 index 0000000..0092b3f --- /dev/null +++ b/Project/Project/Entities/Subject.cs @@ -0,0 +1,20 @@ +using Project.Entities.Enums; + +namespace Project.Entities; + +public class Subject +{ + public int Id { get; private set; } + public string Name { get; private set; } = string.Empty; + public Course Courses { get; private set; } + + public static Subject CreateOperation(int id, string name, Course courses) + { + return new Subject + { + Id = id, + Name = name, + Courses = courses + }; + } +} \ No newline at end of file diff --git a/Project/Project/Entities/Teacher.cs b/Project/Project/Entities/Teacher.cs new file mode 100644 index 0000000..e9ada10 --- /dev/null +++ b/Project/Project/Entities/Teacher.cs @@ -0,0 +1,19 @@ +namespace Project.Entities; + +public class Teacher +{ + public int Id { get; private set; } + public string FirstName { get; private set; } = string.Empty; + public string LastName { get; private set; } = string.Empty; + public string DisplayName => $"{LastName} {FirstName}"; + + public static Teacher CreateOperation(int id, string firstName, string lastName) + { + return new Teacher + { + Id = id, + FirstName = firstName, + LastName = lastName + }; + } +} diff --git a/Project/Project/FormMain.Designer.cs b/Project/Project/FormMain.Designer.cs new file mode 100644 index 0000000..a66fb45 --- /dev/null +++ b/Project/Project/FormMain.Designer.cs @@ -0,0 +1,137 @@ +namespace Project +{ + partial class FormMain + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FormMain)); + menuStrip1 = new MenuStrip(); + справочникиToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuItemStudents = new ToolStripMenuItem(); + toolStripMenuItemTeachers = new ToolStripMenuItem(); + toolStripMenuItemSubjects = new ToolStripMenuItem(); + операцииToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuItemStatements = new ToolStripMenuItem(); + toolStripMenuItemDecrees = new ToolStripMenuItem(); + отчетыToolStripMenuItem = new ToolStripMenuItem(); + menuStrip1.SuspendLayout(); + SuspendLayout(); + // + // menuStrip1 + // + menuStrip1.Items.AddRange(new ToolStripItem[] { справочникиToolStripMenuItem, операцииToolStripMenuItem, отчетыToolStripMenuItem }); + menuStrip1.Location = new Point(0, 0); + menuStrip1.Name = "menuStrip1"; + menuStrip1.Size = new Size(800, 24); + menuStrip1.TabIndex = 0; + menuStrip1.Text = "menuStrip1"; + // + // справочникиToolStripMenuItem + // + справочникиToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { toolStripMenuItemStudents, toolStripMenuItemTeachers, toolStripMenuItemSubjects }); + справочникиToolStripMenuItem.Name = "справочникиToolStripMenuItem"; + справочникиToolStripMenuItem.Size = new Size(94, 20); + справочникиToolStripMenuItem.Text = "Справочники"; + // + // toolStripMenuItemStudents + // + toolStripMenuItemStudents.Name = "toolStripMenuItemStudents"; + toolStripMenuItemStudents.Size = new Size(180, 22); + toolStripMenuItemStudents.Text = "Студенты"; + toolStripMenuItemStudents.Click += toolStripMenuItemStudents_Click; + // + // toolStripMenuItemTeachers + // + toolStripMenuItemTeachers.Name = "toolStripMenuItemTeachers"; + toolStripMenuItemTeachers.Size = new Size(180, 22); + toolStripMenuItemTeachers.Text = "Преподаватели"; + toolStripMenuItemTeachers.Click += toolStripMenuItemTeachers_Click; + // + // toolStripMenuItemSubjects + // + toolStripMenuItemSubjects.Name = "toolStripMenuItemSubjects"; + toolStripMenuItemSubjects.Size = new Size(180, 22); + toolStripMenuItemSubjects.Text = "Предметы"; + toolStripMenuItemSubjects.Click += toolStripMenuItemSubjects_Click; + // + // операцииToolStripMenuItem + // + операцииToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { toolStripMenuItemStatements, toolStripMenuItemDecrees }); + операцииToolStripMenuItem.Name = "операцииToolStripMenuItem"; + операцииToolStripMenuItem.Size = new Size(75, 20); + операцииToolStripMenuItem.Text = "Операции"; + // + // toolStripMenuItemStatements + // + toolStripMenuItemStatements.Name = "toolStripMenuItemStatements"; + toolStripMenuItemStatements.Size = new Size(194, 22); + toolStripMenuItemStatements.Text = "Заполнить ведомость"; + toolStripMenuItemStatements.Click += toolStripMenuItemStatements_Click; + // + // toolStripMenuItemDecrees + // + toolStripMenuItemDecrees.Name = "toolStripMenuItemDecrees"; + toolStripMenuItemDecrees.Size = new Size(194, 22); + toolStripMenuItemDecrees.Text = "Выдать указ"; + toolStripMenuItemDecrees.Click += toolStripMenuItemDecrees_Click; + // + // отчетыToolStripMenuItem + // + отчетыToolStripMenuItem.Name = "отчетыToolStripMenuItem"; + отчетыToolStripMenuItem.Size = new Size(60, 20); + отчетыToolStripMenuItem.Text = "Отчеты"; + // + // FormMain + // + AutoScaleDimensions = new SizeF(7F, 15F); + AutoScaleMode = AutoScaleMode.Font; + BackgroundImage = (Image)resources.GetObject("$this.BackgroundImage"); + BackgroundImageLayout = ImageLayout.Stretch; + ClientSize = new Size(800, 450); + Controls.Add(menuStrip1); + MainMenuStrip = menuStrip1; + Name = "FormMain"; + Text = " Результаты сессии"; + menuStrip1.ResumeLayout(false); + menuStrip1.PerformLayout(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private MenuStrip menuStrip1; + private ToolStripMenuItem справочникиToolStripMenuItem; + private ToolStripMenuItem toolStripMenuItemStudents; + private ToolStripMenuItem toolStripMenuItemTeachers; + private ToolStripMenuItem toolStripMenuItemSubjects; + private ToolStripMenuItem операцииToolStripMenuItem; + private ToolStripMenuItem отчетыToolStripMenuItem; + private ToolStripMenuItem toolStripMenuItemStatements; + private ToolStripMenuItem toolStripMenuItemDecrees; + } +} diff --git a/Project/Project/FormMain.cs b/Project/Project/FormMain.cs new file mode 100644 index 0000000..1e79714 --- /dev/null +++ b/Project/Project/FormMain.cs @@ -0,0 +1,75 @@ +using Project.Forms; +using Unity; + +namespace Project +{ + public partial class FormMain : Form + { + private readonly IUnityContainer _container; + public FormMain(IUnityContainer container) + { + InitializeComponent(); + _container = container ?? throw new ArgumentNullException(nameof(container)); + } + + private void toolStripMenuItemStudents_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, " ", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void toolStripMenuItemSubjects_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, " ", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void toolStripMenuItemTeachers_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, " ", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void toolStripMenuItemDecrees_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, " ", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void toolStripMenuItemStatements_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, " ", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + } +} diff --git a/Project/Project/FormMain.resx b/Project/Project/FormMain.resx new file mode 100644 index 0000000..75b3b6d --- /dev/null +++ b/Project/Project/FormMain.resx @@ -0,0 +1,1718 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + + + + /9j/4AAQSkZJRgABAQEAYABgAAD/4QCqRXhpZgAATU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAAZKG + AAcAAAB0AAAALAAAAABDAFIARQBBAFQATwBSADoAIABnAGQALQBqAHAAZQBnACAAdgAxAC4AMAAgACgA + dQBzAGkAbgBnACAASQBKAEcAIABKAFAARQBHACAAdgA4ADAAKQAsACAAcQB1AGEAbABpAHQAeQAgAD0A + IAA4ADUACgAAAAAA/9sAQwAFAwQEBAMFBAQEBQUFBgcMCAcHBwcPCwsJDBEPEhIRDxERExYcFxMUGhUR + ERghGBodHR8fHxMXIiQiHiQcHh8e/9sAQwEFBQUHBgcOCAgOHhQRFB4eHh4eHh4eHh4eHh4eHh4eHh4e + Hh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4e/8AAEQgC9ASwAwEiAAIRAQMRAf/EAB8AAAEFAQEB + AQEBAAAAAAAAAAABAgMEBQYHCAkKC//EALUQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQci + cRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVm + Z2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV + 1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+v/EAB8BAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKC//E + ALURAAIBAgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKBCBRCkaGxwQkjM1LwFWJy0QoWJDTh + JfEXGBkaJicoKSo1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoKDhIWGh4iJipKT + lJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uLj5OXm5+jp6vLz9PX29/j5 + +v/aAAwDAQACEQMRAD8A+y6KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig + AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig + DN1/VLfR9LuNRuziGHbuPP8AEwUdAT1NeO/DS0m+Lstr8Rdem87QG3/2VabQu378M3zpsc5eMH5l9hxz + T/jfd3/j2+h+Hvg6fZdHd/aF7sU/YeI5o/3cm0SbwjL8rfL1PYV7Pp9nb6dapaWy7IFz5aZJxkknk89T + QBZpaKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo + ooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo + ooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigBnBVsj5a8b/AG0iG/Zn8XKVy3+hZXP/AE+w + d69k+UAswxnrXO/EbwhpnjnwVf8AhTWFzY3vl+auW/gkWQfdZT1QdCKANbSklhsoo5fmfnjgY5NXFKnB + znPSvBYvhZ458Bx4+Hmv+Z9v/wCQgPscI3bP9X/rnbH33+7j37Vb0n4t634MvI9C+KGn+Wlpn7Xr3nId + +8F0/wBHgQ4xujj4P+0e9AHt6Hdg+vWmqWOc9V6N6/hWZ4W17SvFGhW2u6Jd/bbC43/Z5/LaPftYo3ys + ARgqRyO1auc4O7IPTjpQA+iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA + KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA + KKKKACiiigAooooAKKKKACiiigAooooAjByVx0Pb1qC+uRaWpnkXITqM+px/WrDHHO3n614p+1l9q1jw + YngXw9/pPiTXM/YLHhPtHkSQyyfvHwibYwzfMwz0GTxQBH+yzYxatba78T7Wby7Pxf8AZ/s9ltJ+zfZD + NA37wkF9xG7lVx05617cpJ6celJGixIEQYHpmnjdk/NnPQY6UAOooooAKKKKACiiigAooooAKKKKACii + igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii + igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii + igAooooAKKKKACiiigCNt21gq88YGaratYWuqWEtjqEPnWs2N6bivQgjkEHqBVraSeRjb0NGWJPG0+vW + gDxvxZ8IXsdau/F/w/vv7L8QLs8j9152PlEbf659n3C/Ud/XFbHw5+K58RazHoPiLQf+EZ1u6z9js/tn + 2zz9qs7/ADogVdqKp5PO7A5FemYPGTgDr71zPxG8D+HvHnh+TRfE1p9rtjj/AJaSJj51b+BlPVF79qAO + lXJOFPPr6UowQTjA9a8V0zXNT+EesRaB4nuPP8K3OfsN7sVfse1S8n7tA8km+SRV+Y/L1HFe1EfPx26H + 0oAfRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF + FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF + FFABRRRQBE5MfzZ+UdFx1rxPToV8d/tNS3hH9mj4b7di587+0f7RsiDz8vleXs/292f4a9sk2xAu5wn8 + X9K8U/Zyhk1zxn48+JtgPO8PeK/7O/su4+7532WOWCX5Th1w4I+ZVz2yOaAPcKKKKACiiigAooooAKKK + KACkIoBoJoDYYd2QwOR6etLjAI6Ad6aR68r/ABGvBfjF+0/4M8CTSWGlQ/8ACQavDjz7LdNa+VkIV/eN + CynKuW46bcdTRce571uG5lBwVxn2pwOAflwB05r84PE37VPxf1HV7ifTPEf9kWD7fKs/sNpP5eFAPztD + k5IJ56Zx2rK+Ev7PvxB+IVvp+s2OmfY/Dt95mzUvPgk27C6n90ZVc5dCvQdc9KdhH6aYJLDbgcYOetNy + d+O/931r45b9h5dhP/C0No/i/wCJD1/8mK25fhF8fPhX4Ut9L+E/xA/tqEbs2X9j2Nv5f7zd9+4dicmS + RuvbHcUgPqtgSME7ge3TNKpbk56dRXx1o/7VfivwPLF4P+J/hD7d4gst327Uf7Sij378yR/uoIWQYR41 + +Unpk85FeneKP2rfhJp+iXN5oWvf2zqEezyrH7JdW/n5YA/vHhwu1SW564x3pJaWA93DE7SO+eaaDuAw + cj0r51/YW1O61jwVqWp358y4m8rzJMAbsSXCjgAAcAdq9l+Iej+LNb02O38J+Nf+EXuVz5lz/ZcV5u+Z + SPlkIA4DD/gWe1U1ZhE6cFWJzwy/pmlTOzGzb7ZzXzd8TvD37TfhrRkv/DHxV/4SiVc+ZD/wj+nWfl/M + gHzOTnO5j/wH3r5k/wCGn/joUBPjj6D+ybLn/wAg0uo/M/SteRweR0NKSSTgY96/NE/tP/HIkP8A8Jx8 + w6/8Sqy/+M10/gH4xftPePNXk0vwn4k/tO6ixmP7Dp0PVWbrJGo6I3ftRbUPM/Qg/SlH0r40x+3V/d/X + RaMft1f3f10WgR9kgMcc5Hf3oJA5PQd6/Pv4ifFv9qP4f6hb2Xi3xB/ZlzNu8mP7Hps2cBS3MaMOjr19 + a5c/tQ/HHcQPG+0H/qFWR/8AaNMD9K1zv6/N/F/SiPlcr0PSvmf9iL4o+OviM/i0eM9e/tP+zvsX2X/Q + 4YfK8zz9/wDq0XOdi9c4xx3r6Yz8yfJ69+lKUeUE7jxQKRaWjcNhgOW2qMf3jnp6U4/N0+U9jScjCk5b + sa82+MPxo8FfDO18rWtQ/wCJjL/x7WfkzfvcFN/zrGyrhZAeevQUrhY9I+YnBbp1460KSR04/lX5+fEP + 9rz4i63fwy+Ej/wiVum7zIP9HvvMyFx80kAIwQx993tXnmieF/ir8ePEms+INOsf+Eh1WLyP7RuPNtrX + blCkXykov3YSPlH8PPJ5Yz9RgcOvH3v0pFY52H5j3HTFfGGnfsRXc9kkt98Q/sU753w/2KJNuCcfMLjB + yMH8a6bwz+zV8RPhjbahqnw7+Ku/U5vK3W//AAj9uPPwSv3ppWVdqyOenP5UhH1RGxZmzw3GV9Pxpxxt + AVsZ6cV8YR/Hn44fB27kg+Mvh3+221HH2BPttnb+R5YzJzbRvu3ebF97GMcdTj1jwv8AtW/CK/0K2vNb + 1/8AsW/l3+bZfY7q48nDED51hw2QA3HTOO1MZ7seeCePpSqcnAO49+1fI/wG+IsnxM/aS1XXoE8iybyf + skWd3lf6HIj8lVLZMeeRx2r65PPbIPvR0FfUcvSihaKXUS2GKWJ/2V7/AN7/AAoDDkA59faq+p31lptj + Ld30vlW8WN7bS2MkAcAE9SK+Wvin+2LoOnzyWfgfTv7bifHl6j5z2+zAQn91LBznLr+Ge4ouM+ruQScd + aU5yf0r8uPG3x3+KfjPw1d+HvEniv7dpt1s8+D+z7aPzNrq6/MkYYYZVPB7V6B8Of2Q/iFrt3NH4uP8A + widsm3y5/wBxe+ZkNn5Y5wRghR77vY0wP0DfbgHf+77jHWnhmIOflPcelfG4/Ydzlh8UNwP/AFAf/uit + bx1of7V3gthZ+D/GP/CQ6PF/y9f2ZplrtztP3JCW+8zD/gOehFID6x+YkAHjuaFJOeMe9fK/w/8A2zPD + Wr6wlp4r8O/8I1ZNnde/bZLvGFYj93HAD1Cr/wACz2qj+0t+0t4K1X4eTeH/AIfap/at9f7d9x9nmh+y + +XNE4+WaIB9wDjqMY+lUM+tTyoZhj1FClioBGD39q4z4KY/4VnpQjOE/fYP/AG2krH8ZeDfixqfiO7vv + D3xo/wCEe0ybZ9n0/wD4Re1uvIwihv3jsGbcwZuem7HalbUlO56WnTGd2O/SnABVBJyB3xXyN8ftR/aQ + +FelR63b/E/+3tKXP2y6/sHT7b7N80aJ8hDM+5pMcDjbk8GvDv8AhqD45pnPjjGP4f7Ksv8A4zS3Vhpa + XP0pPJ4br046UDgnnjsK/NL/AIag+ObA58c4Uf8AUJsv/jNeg/BP4mftJ/FTxHLp+i+NPJtLfH2y7/sv + T2+z7kkKfIyKX3GMjjp1NO3Udz7tbkhcZU9eaB1HHJ615HpvgL42QXcct98fftkAzvg/4Q+zj3cHHzBs + jBwfwrtviDo3i3W9Ojg8JeNP+EWuRnfcf2XFebuVI+WQgDADD/gXtQI6Rip5BwT3pXPI7k/drwLxn4N/ + aQ0zwzeX/h34y/8ACS6lFs+z6b/wjGn2n2jLqG/euxVNqlm567cd6+UpP2nvjopVX8b8jP8AzCrL/wCM + 0krMPM/SpuuB8rHoetGB0A+X1r81B+1B8dCBjxzy3b+ybLj/AMg1d0P9ov8AaC13UodN07xf9ovJ93kJ + /ZtiudoLNyYgOgPWqSvINj9HeQp/g9+tKDnkDJ7e9eEeGPA/7Q99olte638bf7Hvzv8AMsf+EVsJ/K+Y + gfvFbDZADe2cdq9b8DaZ4j0nw/BZeJvFP/CT6lHu82//ALPjs/My7Efu0JUYUqvHXbnvSC50AooNJmgN + xgyXIxynQ565ojwT8q4Xsc9a8U+Nn7SHgj4cNqGkxN/bPiSy8vfpOJrfO/y2H77ymT/Vvv6npjqa8B+I + H7ZfijWdH+zeFfD/APwi19/DefbI7z+JSfkkgA6Bh/wLPahAfdK7s4Ax6j0oUAEkHI7e1fm1p/7Svx7v + 7yO1tfG2+eXPy/2VYjOAT1MWOgr14n9ujb0w3c/8SXmhoD7FeTBIxx/CfX1pzcDDHj1r4h8YeJv2y/B/ + hu68R+Irz7Fpdps8+fytJk2b3VF+VAWOWZRwO9eY/wDDUHx05P8AwnGT6/2VZf8AxmhO40fpZkgZ6+9I + zIB14XrX5qj9qD46E8eOeT/1CbLn/wAg1658B/FX7TPxVvYZYvH39l6J83nan/Y+nTeXxJt/dbVY5ePb + x0znpTt1EtD7QBORkYPYZpV6cdK838D+EPinpHiC2vvE3xh/4SXTYt3n6f8A8I1bWnnZRgv7xGLLhirc + dduO9ejAYOG5Y9/WkBJRRRQAUUUUAFFFFAGb4g0nT9d0qfSNVh+02txt8yLcybtrBhypBHIB615JoOt3 + /wAIdct/Cnie487wxc7v7Mv9irs2qZJf3aB5DmSRV+Y+44r2pupyPlPes3XtG07xDo0+katbfarCfb5s + fmMm/awYcqQRhlHQ9qANHDA5PT+I+tOGc88kdDXinhHV9U+FOuWngrxbdfbNDud/9k6p5ax52q0s37qM + M/35FX5j2yOOK9qU5Uc7s9KAH0UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF + FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF + FFABRRRQAUUUUAFFFFABRRRQBWv9/wBnYRttfjBxnvXkH7FJz+zL4Rxx/wAfv/pbPXrmrKj2EolbanHO + M9xXk37FR/4xl8J7uP8Aj8/9LZ6APZaKKKACiiigAooooAKKKKAI8fwhue3HSori5it7f7RM2yMdeCe+ + O1SDrtz/AMB/+vXxP+3f8Wrm71ST4aaRc+Xaw4/tdNgP2nctvPDyyZTaQfuNz39KljSucx+1F+0XfePD + c+FPCVz5XhZ9vnvsU/2hjypF4kiWSLy5Ebofm+mK+cCQSxzu/wBqgn5cBcHvz1r1n9l3wHD4/wDihZWN + 6udLg8z7QMnjdBKV6MrfeQdKuKuJux7r+yT+ztarY2/jPxpa+ZcS7vslr5hHlYM0T/PFLhsjaeRx0Hc1 + 9g5O0sTgHv6UFfmwDj+77Up5+4cZ7+lK4Dx0pKUdKSgaOL+K3w68PfEbQTpGv2nnRr/qX8yRfLy6M3CO + uc7B1PFfmp8YPh3q3w28XT6Fqv74Jt8q4+VfNzGjn5VZtuN4HJ5r9W8Z2nG0jNeDftrfD+38X/CqTV1j + 8zU9Dx9h+Yj/AF88CyfxBfur/ED7Yqb+/YOhif8ABPzj4aXX/AP/AEdc19L9q+Z/+Cfhz8NLr/gH/o65 + r6YHStKukyUMY4Yk8gfd/rX5MfFWC3t/HmoQ2oxAPK2jnj90hPXnrX6zSHBOOp61+T3xdCj4g6jgYz5W + R6fukqPtFpe5c5Ada+l/+Cfv/JS7r/gH/om5r5pHWvpX9gD/AJKXdf8AAP8A0TcVcdzObtC59/KB0HGK + PmxwOfrSei4yDUN3cRW0Lz3T7IVxk4J68duetSxomz0JGP6V8N/tZ/s7aR4O0GXxn4KtPsWk2uPtdr5j + yeRueGJPnllLNuZmPA4zg8YNfZ/hDxDo3ivw7a6/oF79t0y53+TN5Tx7trsjfK4DDDKRyO1W9VsLTVNP + lsr6HzraXG5NxXOCCOQQeoFK5R8e/wDBNkos3jzcm1h/Z2Ofa6r7NxjHHSvk/wDYS0Cbwt4v+JWiyN5r + 2f8AZWTgL9+O4b1P971r6uUnJBOWHaqk7k7AcNlcZHeheTlm3Y9sYpGyWI3YJ6DHSvDP2wvixd/DbwXb + 2ejSeRreq7vsdxtDeT5UkJf5WRlbKORzjHbJpPQtK5x37VP7SE3hG4k8JeBLvyddTH2q88sN9iyIZE+S + WIpJvRnHB+XqecV8LyO0jGXduf1xTBjIy2AOhxWj4d0q71vWoNLtVzcz7tnI/hUsepA6D1ojETPaf2Vv + gTL8S9TOr67+60C36pw32ncsy9UkV02vGO3P0r9CdF0uw0PS4dN02H7PZwbtke5nxuYseWJPUk9azfAP + hex8G+ELLwzpY/0Sz8zyx838cjSH7xJ6se9b/O4c7vTtimyUySiiipQzO13SdP13Sp9L1O3+0Wc23zI9 + 7JuwwYcqQRyB3r88v2qfga/wz1aPVdFXzPD13ny0zj7PsWFTy0jO255D24+lfoyfmIy2APvLjr6Vz/xG + 8J6d448G3/hbVDm1v/L804b+CRZB91lPVB0IpNjPiX9gHb/ws+453427T0/5YXFffihtnDcnvivg/wDY + b0y60j4vXthfR+VeW/l7k3A/et7gjkEjoRX3gvUAcY6irexC3ERsrkHI9a534g+MtC8BeGLnxF4huvs1 + lb7PMfy3f7zqg4RWPV17V0EjLHmSQ4UdPavzI/aY+Kt58UPHBulmzotj/wAg232j9zviiEvzbFZsvHn5 + s47cVD3LitCh8dvjF4k+LOuRXOrP9m0u1z9gsMRv9m3LGJP3ixoz7mjDfN06CuE0XS7zWNRi03Trfzry + fPlJvC52gseSQOgPWqY24AL7VbqMZxX1z/wT68AQ3Wr33jq9X97Y+X9gbJ/jW5ik6N6Y+8p9vWqSE2e3 + fs4fArRfhhpcN9cL9s8QybvNu8vH0aUD5BIyfckxx6Z617RxywOAOp9aVfQ8kdaU84bHI6UNAmOooooA + 8O/aS+BGkfE3T5dStU+yeIEx5dzl335MSn5TIqDCR4/HPWvzo1nTb3R9Ul0zVIPKuYMb03htu5Qw5Ukd + CO9fsIBg5zgmviT/AIKBeALex1uw8c2EGJdS8z+0m3n/AJZrbRRdW9z91R7+tFxs+qPgj/yTPSv+23/o + 6Su0/iri/gj/AMkz0r/tt/6Okrte9En7xFP4Tyb9rWwj1L4D+IrWU43fZufT/SoT6j0r8xzg8dv5V+of + 7Twz8FNeHc/Z+PX/AEmKvy8YDPXP9aypO85I2elNDFAwc9e1ff8A/wAE/wDTIbX4X3GpL/rr7b5vX+Ce + 4Ud8dPTFfASgZw3av0L/AGDgB8HbdgeTu3f+BFxXXGN6bZjJ2Z9DMacOlRvTx0rn6It7EYBUjcdo7L6f + jX5a/tG6bBpHxm13TomzHF9nwcHjNvE3qfWv0M+PvxEh+Gfw9vfEXk/aryPy/s1ruKedmWNG+fawXAkz + yOcYr8u9Y1G71a+lvtQn8+4fG59gXOAB0AA6AUJ3Y7e6UlH5CvaP2MbGO8/aA8PPP/qYvtOR9bSf0Oeo + rxkDA9q9y/Yjwfj9ozN94+fgf9us9aw0kRV0hc/SAUGgUGs7hYZJj047n0r5Z/bR+Nl94V/4onw9L5Wo + S/8AH1dbVbyMeRKnyPGQ25WYcHjqfSvqY8gKeVPWvyT+IviO58XeMb3xHejZcXfl+YODjZGqDoAOijtR + c0jE5oA7WI5UYzXSfDDwjfePfG2n+EtOfZc33meW2FONkbyHhmUdEPcVzgGQAOpr6m/4J4aRa3njXW9W + kTM+n+R5DZPHmR3KtxnHQdwapIzbsfYvw68DeH/AHh6PQ/DNl9ktUzx5sj9XZ/42Y9Xbv3rpuCCV5NIO + Mkcsad/DyMkdqGCZ49+2Z/ybj4o/7dP/AEsgr8zO9fpj+2Yf+MdPFA/69P8A0sgr8zv4jUU/iZb+FDwp + yPl6ds1+lP7Ftqtt+zt4ZJh2SyfavMO7PS7nx+lfmp/vDmv06/ZKJPwD8PbvmP8ApOe3/L1NWq+FmUna + SR62KKKKgsKKKKACiiigAooooAKKKKAOT+KvhCDx74D1Pwjc3XkR33leZJ5ZbbslSQcBl/uY6iuX+Cfj + EzXF94B1y0+weI9C8v7Xb+Z5uPPEkyfMq7PuYPDHrzg8V6f84AOMt2FeQ/HbRr3w1b3HxQ8Iw/8AE80/ + b51tuH+neYY4F+aQlI9iMx4U7vrg0AewDOQxXHrzRggnJyB0rO8N6tBrWl2+pWj74Z92Dgj7rFe4B6it + JfWgB1FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA + UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB + T1BWktJIo490jY+XdjoR3ryL9jZxZ/A3Q/Dlz8mqaX9o+2QdfJ825ndPmHytlTngnHfFezOAVO88d68U + +CkrS/tGfGeSU5kP9hZb+9/ocnbtQB7dRRRQAUUUUAFFFFABRRRQBxfxh8W2/gXwDqPiid9iWXlbuCfv + ypGOit/f9DX5T6jd3F9ePc3UnmStjLbQM4AHQewr7c/4KIeIH0/w34f0NYPMTU/tPmvvxs8t7ZxxjnOe + xH418OgnjnGfbpU09ZXLa91DQBkgtj1OK+4P+Cd/hprPw9r3iKaDC6h9n+zvv/55vco3APv3Ar4hBIJU + jao7V+k37Ftotv8As8+HpGj2SSfad43Z6Xc+K3j8DM5bHtlFFFZDCiiigBpwCp6YzVe8torqFra6TfE+ + O5HTnt71Pkk5HKmlwQPvY/CgDxj9lj4e698N/Dd/outWfl/6vyJPMQ+b88zNwrNtxvA5PNezHrjuOlHT + 5Sdx/KkIUj5uFHagBWr8mfi//wAlB1P/ALZf+ikr9Zmr8mfjB/yUHU/+2X/opKn7RS+E5Id6+lv+Cf8A + /wAlNuP+A/8Aom5r5qI5NfS3/BP0f8XNuf8AgP8A6Jua06mc43R99DqOMH615p+054ibwt8FNe1tI/Me + H7Phc4zm5iXrg/3vSvSmUE8jOPuj+dfBv7cPxY0zxdqdh4Z8PXPnW2neZ9rm2MvneYsEifK6Argqw4Jz + 3rN6suKsj6f/AGSC/wDwoDw3uP8Az9f+lU1erHqMCvKf2Rs/8KA8N5P/AD9f+lc1erAnIwKqWkjOnrEw + tI8KaBo/iXV/EWnWHk6prPk/bpvOdvO8lCkfyliq4UkfKBnvmttSwySePWhASeefQ+tGR0A5ajqWthJZ + FijeSR/lGO3Svyw+P3jdviB8SdQ8Qxy77Kbyvs42427YY0b+FT1TuK/Qj9pzxBL4X+Cuu6zBF5s8P2fa + u4DObmJTyQR0b0r8uepB6k0l8RS0iG3Jxjce46V73+w/4dk1n4yWmqtb+bb6bv8AMO/bjzLedR3B6j0N + eBjAT72Se2K+xf8Agm9aMW8bXTpgf6BsfPT/AI+geK2j1ZnI+zqbTqSsV3K6jqKKKYBRRRQB4h4e+Gur + aN+0lrXjSGz/AOJJqPkfN5q/uvLszF0Lljlz6DH05r2vndnp6ijCnK+lHJ69R0NC2D7R85/t0ePP+Ec+ + HCeHIbnyLzW87Ts3Y8ma3c9VI6N6j8a/P05DMCPm7V75+3R4hbU/jVf6KUxBpPl+W2fv+bbW7HjAIwR6 + n8K8CwBg44HX2pR+ErqKVGcfd9R1xX6g/sw+HZfDPwZ0XS7u2+z3i+f5ybw+M3ErLyCR0YdDX5g2sbyS + iKD5nP3R0z+dfsJZW6WsKxQpsVc4XOe+eprSStBGT+Isilpo604VBb3FooooAjbJHAyR0Ned/tG+Crr4 + gfCPWPDumRb7+48j7MdwGNtxE7feZR91D1Nei55PHy+uaTgEAnO3qfSk4gcx8L9L1DRPA+mabqkXkXkP + m+bHuVusrsOVJHQg8GunjA4BHzLSMMuR95T19qVQeBnJ7mhbj6Hmn7Tn/JE9d/7d/wD0pir8uB1r9R/2 + nP8Akieu/wDbv/6UxV+XA61nT+KQ/sIB0r9Dv2Df+SN2/wDwL/0ouK/PHsa/Q79gz/kjUH/Av/Si4rpb + tFxRmz6Dz26HuKbM4jDSSP8AKOnFOXoMDA7e1fMn7b/xcbwz4dXwboj51HUM/aJsf8enlvBKvyshV96s + RwRj9KyntZFxVjwT45eNtU+PnxbstD8MD7TZx+Z/ZcXypnNvG83LrGesLH5j9Pfzj4zeGrLwh8SNU8PW + Lbra08nbwR9+FHPUk9WPevsP9hf4WxaD4QHjTU491/qX+pXcR9n8uS4iblXIbcpHUDH618u/tUOf+F9+ + IyeSfsuV/wC3WHvVRiospM8p9a90/Yi/5L9ov/bf/wBJZ68NPSvcv2H/APkv+i/9t/8A0knqov3jGp8J + +kQoIoFLUFIgu4kmiMUi+YrdVzjOOa/ILXNPvNK1GbT9Qj2XUe3euQduQCOQSDwRX7AMN3D9D2r4N/bm + +Fep6T4xuviHY/vtK1DZ9pj+Vfsflx28Kcly0m9ieijb39aRpGVj5gGclcZzX1v/AME5LvyNW8W2Ym4u + vsX7vb9/atyevbFfJIDE4xkmvTP2cfiGfh18S7LWryb/AIlQ8z7bHt+/+5lVOQrMMM46D68VpBXMpao/ + UQ8KRtz+NHIIA6VBZTxXEIubd90T+xHQ471YUcn2qXoikvdPH/2zD/xjl4o/7dP/AEsgr8zG4Nfpp+2W + M/s5eKP+3T/0sgr8yzy2Kzj8RT2AV+nv7JP/ACQHw7/29f8ApVNX5hiv08/ZJ/5ID4d/7ev/AEqmrf7J + hL44nrI6UUDpRWZqFFFFABRRRQAUUUUAFFFFABSNS0UAeK/AzyvAvinVvhQyeXpumeT/AGHPkn7V5qSX + Fx8vzMm1nx87HP8ADjpXtA3EDB/GvGf2rAfD3hGD4q2P/Ia8IbvsB9PtckNvJ1yv3GP3lb2wea9ky3Uj + H9KAJKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigA + ooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigB + hJ6Dlh3rw74vM3hj45eBfGt5H9h8O2n9of2vfZ8zG+2SKH92Mv8AfYL8g75PHNe4n+8RkDpXnH7Rngyb + x38K9V0BdR+xCfyfm8kSfdnifpuX+5696APRxxtUDI5yfSkOM8Ngt1OK5P4Q+NB8Qvh1pfi+PTvsAv8A + zf8ARfO83y/LmeP7+1c52Z6Drj3rrQzHH6e9AD6KKKACiiigAoNFB6UnsB8L/wDBRO6V/Ffh6BY9hh+0 + 5k3Z3Zjtj07Yr5VOA/8Acx2619a/8FG7CGDWfCt5G3728+2bxg87FtgO/pXyUzZQKD9B6UqXwXG73EwB + zux7461+nH7I/PwD8Olm3OftO5sYz/pU2OK/MdQGCjr149K/S79ji/jvP2f/AA+VXY6fad65zjN3PjnH + tWsfhZnJe8j2WigUVBYUUUUAFFFFIAooooAY3QV+TPxg/wCSg6p/2x/9FJX6zN0Ffkz8YP8AkoOqf9sf + /RSUfaKWxyikFhgY969N/Z7PxW/4SWRfhKcaqceb/wAe39yTH/Hx8v3fM6fzxXmPBA4x719LfsAFv+Fn + XYfo2zJ/7Y3FU9yW9Cp8d7j9ptPA9xD8UWzoD7ftHGnfNiWMr/qPnHz+X0/lmvnccZ3cn+Ietfsa2fm4 + 69D618Cftp/B6x8D6zbeJPDFv5OmX2/zYN7N9m2LAg+Z5GZ9zOx4AxSvZgrtH1J+yL/yQHw5/wBvX/pV + NXrdeS/sjD/iwPh3/t6/9Kpq9ZzTm7yM6SaiDUCmmlFLqV3Pn/8AbruUj+Ct9Bs3tL5e1s424ubc9O9f + neg3EKPmPp0r9Gf24LCKf4Faxeu37y08jyzg/LvuoAe/P41+czHJO08Uo/EbS0ghBgvtB696+1v+CcTZ + 0zxcS2R/oXGPu/Nc/nXxS3DcDGO2a+yf+CcN7F5fjKzZcFfsPOT82ftJ/DFbR6oxlsfZVFJ3pKxXYp7j + 6KKKYBRRRQAztSmk7UrULYF8R+Wv7TNwl98bNfuVTyg/2bjO7pbRD+lebk8HjOa9T/avsotN+PPiK2t2 + 3JH9m5wR1tYT3z615YccE/MPyoh8JUty/wCHeNTiY8bc4/75NfsBFhQe3tX49adOLS6S4PITO0euQR/W + v2AsrhLhDNHzE33D644Naz+BGT+IsClpKWsUW9xaKKKYBRRRQAhoWg0LUrcfQ8x/ac/5Inrv/bv/AOlM + Vflv3r9SP2nP+SJ67/27/wDpTFX5b96zp/FIf2EKO9fof+wcf+LNW4/3v/Si4r88QOtfob+wf/yRq3/4 + F/6UXFdcf4bZnLRnrvxK8Y6f4D8HX3ibVjm3s/L8wfNxvkVB91WPVx2NfB/wF8E6r8fvizfa94qf7dZQ + +X/a8uFj6wSJDxG0Z6wqPkHbn32f2s/iDqXxP+JcXg3w5a/abLTs/Zz5ip9o8yGGVvvqpTaY26k5/Svr + 34EfDex+GXga20KA/aLz5/tVz8y+b+9kdPlLsFwJMcHnvWMV1ZUnZHoSKFGBX5eftULj48+Iyf8Ap1/9 + JYa/UNc96/L/APaqOfjx4ix/06/+ksNJt8xcUeWCvc/2If8Akvui/wDbf/0lnrw3vXuf7D4/4v7ov/bf + /wBJZ63TsY1PgP0hBpaSisi1sN4G1ugGahvLaK7ge3uk3wtjIyR0Oe3PUVMOCT1zQdxOA2CO2KAZ8ffG + H9j21mn1HWPh9qX2WIeV9j0HyC+OEV/9Imn/AN+Tkd9o7V8oeO/BviTwPrcmi+KdN+wX8WN8fnxy4yqs + OY2YdHU9e9fpv8aviBp/w38E3XiC+T7Q8WzyrfLL5mZI0PzBWxjeDyK/LrxLrOo+IdZn1jVrr7Vfz7fM + l8tU37VCjhQAMBQOnaiErMpL3TuPhp8b/iJ8P7CLTPD+t/Z9Jjz/AKJ9lt2zks333jZvvOT19ule/f8A + DcJBwfhfhu3/ABP/AP7nr436jcevYete5/sh/CdfiL4zkv8AVIPO0PTMfbIt+3zPMjmCcq6uMOgPGc9+ + Kpe8iU9DpPjJ+1V/wsj4bar4QHgH+zBfeTi6/tjzvK2TJJ9zyV3Z2Y6jGc+1fNDKD0GF9a/S/wDbLGP2 + cfFRJ5/0PJ/7fIK/M/ovJwV7Y9aiPxDew2v08/ZI/wCSA+Hf+3r/ANKpq/MMV+nv7JX/ACQHw5/29f8A + pVNWn2TGf8SJ6yOlFA6UVBqFFFFABRRRQAUUUUAFFFFABRRRQBXuraG6gNtcR74m6jJHfPavJf2T7qex + +F1p4K1p/K8U6Fv/ALWtMA+R5880sPzr+7bdGQflJx0ODxXrxORuLfKO+OteOeEA3hf9pTx22uJ9iPjb + +z/+Ee58z7b9is2+0/dz5ezcP9Zt3Z+XNAHs9FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU + UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU + UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAeE/CMP4P+N3i3Rtd/wBDbxL9j/sKL/Wef9mtna45TO3b + uB+crnPy5r3LDbgM/Q+lea/tHeEP+Eu+Hl1brc+Q8WzH7vdnM0R/vD+7W78IvGI8f+ANN8UCw/s83nm7 + 7XzvN2bJXjHz7VznZnp3xQB2NFFFABRRRQAUUUUAfOf7ePhuTVPhC+vJJ8ukY38dfOuLdB3Hp6H8K/Pf + OQC3fvX7D6pYWmpWUtnew+bbvjem4jdggjkEEcgV+U3xc8F3fw+8d6l4TvH82W08r95gLnfEknQM398d + 6UXyuxW5yLcdO1fff/BP3xG2p/Da80ExY/sfZ8+773nTXL9MDGMep/CvgUEg5zgnvX0Z+wh4ut9B+J1x + oFz+7Gt7fm5O3yYbh+ynPX1H41rHVcpD0P0HpBS0VkMQUtJRTAMUYpaKAuRjp/dI6ijLEsAOR29aq6Xf + Weo2Md9YyedazZ2vgr0JB4Iz1Bq3jODnnsaAuB6V+TXxf/5KFqf/AGy/9FJX6ynoa/Jr4wf8lB1P/tl/ + 6KSpv7xcVdNnJZ619Kf8E/v+Sm3P/Af/AETc181etfS37APHxNuf+A/+ibitEtTKekWz78ccE5zjr715 + l+1D4XHi34Ma3pCNsu38jyZMZ24uYmbjIB4XHJr05Tgc9qjuoIrq2MFwm9G+8uSM4OeoqCk7o8r/AGSc + H9nzwyC3zN9q5x/09zV6uMnLhee3NZXhLw3pHhPw/b+H/D1p9i0223eRB5jybNzl2+ZyWOWZjye9afJc + /Lgnoc9aoSQy8uYrWF55vljXHzcnvjtWV4I8UaD418M2niPwzffb9Ju9/kT+U8W/Y7I3yuAwwysOR29K + 8U/bg+Ig8JfDhfD9u2zUtcz5MmM+X5E0DtwVKnKt3Ix716R+z/pB8P8Awm0XRwNzW/n7u2N08jep9fWo + V27g9DW+KXho+LvAuo+Ht2z7V5WDjP3ZUf1H931r8mCrBsY5HQV+xyjkEnJPTivz2/bj+Hv/AAifxGj8 + R2w26frmfJhzny/Iht0b5ixJyzZ5Ax70k+WRe6Pnhdmcngfzr6U/YD8RtpnxKuNCKZGtbfnz93yYbh+m + Dnr6j8a+ahyCMYH8q7H4QeKIvBvxD03xNKm6O0835Mkbt8Lp1wcfe9K3g7yM5rQ/V8rlSNv60IDwT0FQ + 2lxFdQLNayboznsfXHerIA3HHSo2ZSfu2HUUUUgCiiigCIE7skfKOjev4U5QQvA2/riqlvfWU17d2EEm + 64tNn2hNpGzeMryRg5HpVsdSCcnuKOgup8Jf8FCPDb6Z430rxIJPl1fzto2/d8qK2Q9z6+g/Gvlwce6n + p71+pf7QPgFfiN8Or3w9CfLvpPL+yzddmJo3f5Syg5CY5P0r8tp43hlZJF2uPvDOamm7Mt6jV4GB0Pf1 + r9WPgj4jfxX8MtJ8RSReWbvzsruzt2zSJ1wP7vpX5TLu27QOvSvvD9gDxfa6l4Iu/C27ZPpWzAwTu82W + 4k/ugDAHqfwrZP3LGM1qfURpVoXpQKyRp0FooopgRqfl3AZHYUrFtx28+1DHG7tjvVHV7+y0vTZbzUpf + Js4du99pb7xAHCgnqRRYC+aKUiil1Q+h5j+0z/yRPXf+3f8A9KYq/Lgda/Ub9pv/AJInrv8A27/+lMVf + lyOtY0dJSG/gQ8BRw3T+VfR3g74vyeAf2aLbSNHn8nX9T3fZp9m7yvKvWZ/lZGRso5HJGPc184j7pLfM + B17Yr0T9n34c3HxM+IlpoJPlWDb/ALXPwfK/cyOny71LZMeODx3rpv0JTPof9gX4X7bZ/iTqtrvMuP7H + l8zGMG4gn4V/oPnX6etfYajaAFGMds1W02xtdOso7Cyh8qCPO1Nxbbkk9Sc9SasqNygqMentUt62FEcw + wtfl9+1UM/HnxFn/AKdv/SWGv1BPTBr8wP2q+fjx4ix/06/+ksNLTmRrDWDPK/4q9z/Yg/5OA0L/ALeP + /SSevDP4q9y/Yg/5L/oX/bx/6ST1cdzCr8DP0jXpS0i9KWoKWxG+SOuM/pUN1cw2lvJcTt5UKYy+Cepx + 0HPU1KTgY3ZHc46V8hft4fFuKC3m+GWkT7p32/2xHsI8vBt54OWTByMn5G47+lFy7Hhv7UfxX/4Wh43S + 4sZfN0XTs/YflxjzIohJ1RW+/GfvZ9uK8fydoycAdDSj7xZxn19qMnscjvVcor6Gx4K8N6p4v8R2nh3R + YPPv7nf5Me9V3bUZ25YgDhSeTX6m/CnwRpvw/wDBFj4Y0s77a08zEmGG7fK8nRmYjBc968i/Yw+ETeC/ + B58Q63Ds1vVP9bb7s/ZvKknQfMrlX3IwPAGPc19EYJORx705MlHjv7Zhx+zn4o/7dP8A0sgr8zs/NX6Z + ftmYP7OXij/t0/8ASyCvzOPDVlF+80aW91Aa/Tv9kf8A5ID4d/7ev/SqavzE/hr9Of2R/wDkgXh3/t6/ + 9Kpq2WsWzGfxI9coooqCwooooAKKKKACiiigAooooAKKKKAIwxHJ+b0PrXjnxYAH7S/wULcBP7ex+Nkl + eyAfvMs2f7vHT1rxn9rXOgfDOb4maSPs/irwtt/sW++99k+1TQwT/u2zG++MlfnVsdRg80Ae00UUUAFF + FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF + FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBGeAQwwO + 1eFfE9bn4TeK08Z+GLfzrTUc/wBrWO8L53lxpFD+8feVwZGb5QM9D617tyAMHGOtVtR0+01HTn0+8i86 + 3kxvXcVzggjkHPUCgCeN1YBwfk/hpRubGRhh39K8Ssbu8+COofYNVm+0+CZv+PafaE/s/aMv8q75ZfMl + lA5+7246e2RESRAnpQBLRRRQAUUUUARkkMSx4HQ4rx/9pv4N23xV8N2ywSeTq2nb/sUmC2PMeLzODIq/ + dj759ua9gIyT3B6ig/ewBkDrz0qWrq41ofkD4h0XVPD2r3GlatbfZr212+bHvV9m5Qw5UkHIYdDVXT7u + ayukubWTbKmdrYHGQQeD7Gv1A+Nvwc8K/FTTUi1m38rU7fP2K/3yt5G5o/M/drIqtuWMLz06ivin4r/s + y/EHwXe31zp9r/bugWnl/wDE08yC237wg/1JmLjDsV/4Dnoa0UrO4PU+2fgH8T9N+KHguLVbVtuoR5+3 + WuGPk5kkWP5yihsrHn5Rx0Nei9t4bA78da/I3wP4t8Q+CPEUGv8AhbUPsOp227ypvJjk2bkZD8sispyr + sOR3r7E+HX7ZPh7VNWt7LxfoH/CO2Pzbr/7ZJdY+ViP3ccAPUKv/AALPY0mSfV27PO79KOjDPNeNf8NR + fAxsqfHPTv8A2Te8/wDkGud8eftcfDPSNH+0+E7r/hKL7tZ+XcWefmUffkgI6Fm/4DjvSKPof5ux5718 + iftR/tErIj+Dfh5c+fdSY8+72bfJx5Uq/JNFhsjeODx19BWJq+ufHT9o2wubfQtJ/sbwFqWzzoPtFlce + X5ZBX5nEcpzNATxjr6Dn3z4CfAfwx8KrOOaGX+1ddGfO1LbJD5nMgX90ZGQYSTbx1xnrQJmx+zn4d1rw + p8HdD8P+ILX7Dqdp9o+0QeYkm3fcSuvzISpyrKeD3r0POXGOcUjglSp/A+tcv8QviD4S8A2Ed94u1X+z + bWXPlyfZ5Zt2CoPEasRguv5/WgEjqMYUivyb+Li7vHuqEcqvk5b/ALZJX2z8Rv2svhzpfh6SfwfqP/CR + agMbbbybi1z86g/NJCR90sf+A47ivgLUb24v7trq7k3zv9+TAGcAAcDjoBSt7xadk0V1wUbjPv6V9F/s + G3gi+LK2rHH2jv8A7sFwa+dVztwG5HQYrZ8G+J9c8HeJbPxH4cvvsOp2W/7PceUkmzejI3yuCpyrMOQe + tWnqRJc0Wj9eF47UA818bH9uQj/ml3/lf/8Auek/4bl/6pf/AOV//wC56liitD7HBypIbce3GK4v4t/E + 3wv8M9IhvvEt75D3O77LF5UjebtZA/KI23HmKeevavjb4j/tf/EHXLi1bwfF/wAIgkW/7RHugvvPyF28 + yQDbtwx467vYV8++I9a1HX9Xn1fV5/tN5cbfNl2Km/aoVeFAAwABwKCje+JvjPXPiT4zn1zVTuup9u2L + 5Pl2xoh5VVB4QHpX6qaHp6aVpsdhAuY4c7Oeu4knqT61+V/wWsRqPxJ0uyNv9o83zsxb9u7ELnrnjGM1 + +roXIO7knrVySjBMh6sXjgdj0Fc38S/Bul+O/B974a1gbrO78vzBlh9yRXH3WU9UHeukOc89e1KSCDgb + v0rJ6tFrQ/Kf4yfDPXfhh4lk0fWDuhkx9nn+QedhEZvlV2K4MgHJ5rhxyDxhPWv1w8ceEPD3jjQZtB8U + ad9vsJtvmxedJF0ZXHKMp+8ing9q+K/ip+yH4y0S4s5vAUn/AAk6XG/7TFths/sm0IF5lnPmb8ueOm33 + FVezC12eo/sO/Fy11nw3b/D7VZNmp2W77I20n7VveeZ+FQKm1QOrHPb0r6hBOCOn9K/IHULLUNC1d7O8 + i+z3kON6blbblQRyMjoRX0/8Nf2x9Z07SbXTvGOhf23cpv8AO1L7WlvnLMy/uo4MdCq8eme5qp6yJS96 + x9xE4x29vWkBBfB6jtXjTftPfAzaQfHHP8R/sm9/+M1W1f8Aan+DFvYyy2Hiv7ddLjZb/wBn3ce/JGfm + MOBgZP4VIz2wlSgcNgDvivFP2kPjzo/wx06bSrJvtPiI7fKt8OmOYmPzGNk+5ITyf1ryH/hoT4y/F510 + /wCD/hT+xb20/wCPlv7RtLjfu5Ti4iQDAjk6evsK7H4C/ssaV4Wl/tzxpcf2vqDf6m22NB9kx5iN88Ux + Em9WU8jjGO5oAsfsPWPi+40bxF4v8Uw7j4g+zfZbvdF/pP2dp43+SM/Jt+UcgZ6jPWvpLP8AEBgHqaTY + DnPJPWlXlicYz1obCKGSA8EnHqPWvk79sP4B3HiC9uvH3haPfqcmz7ba7gPOwIYY/nkkCrhQx4XnofWv + rQYB65I601uFKq23b3xmlYEz8cG4AUjB7+9dz8EPH9x8OfiFZeIkh+0Rw+Z5sO4LvzFIg+ba2Mb88Cvt + r44fsyeFPiFqZ1jS73/hHdVl/wCP268qW68/CxrH8jTKq7VQjgc7snpXxX8RPg98Q/h/p6Xvivw9/Z1r + Nna/2yCXoVB4jkY9XX86q+tgsfp94X1zTPE2iQa1o119s0+53eVP5bR7trFT8rAEfMpHI7VpoSeQ+4N7 + dK/Lv4FfGbxN8J9ZM2mP9s0m4/4/tOxHH9o2rII/3rRsybWkLfL1xg8V9a/Dv9rz4fa7aXUnjJP+ESki + 2eVDme+83JbPzRwDbjCnnru9jSa1A+kAcrkcg9KH3YADYPdsdK8bP7UHwN27j42yo6H+yr3n/wAg1wfx + D/bI8H6JfRQ+D9G/4S22fPmTfaZbHy8BSPlkgJOSWHtt9xQB9IeIdY03QNJuNV1Wf7PZwbfOk2M23cwV + eFBJ5IHAr4g+KPxS8SfHj4h2fgvwLZfaNOO/y4vNjX7T+5SU8yojJtaFz15/IHauPhT8cfjxfWMvxL1T + +xtIs/M+wzfZ7O48reMSfLA6M2WhQfN0zxwDn6q+Gfw/8M/D7RTpfhix+y27fe/eyPnDOw++zHq7d+9N + MDqjuKkleT2zSbiH27cf3Tnr6045wCR+FeY+Mfj58JfB/iW68O+I/FX2HVLPZ9og/s+6k2b0V1+ZIypy + rKeD3qPtD6EX7Udxb23wN8QT3XMA+zb25/5+YgOBz1r8wBt49e9fWX7WX7RHhzxp4auvBnhD/iYafdbP + Nv8A95Fna8Mo/dyRA/eVl4PbPoK+T2IJwDk9/eiEdWP7CFXapJkHI7etfe/7AFjpVv8ADS7urWLy7+fZ + 9ufcx37ZrgR8HgYH938a+B1HykZ47+1e/wD7Ivxvsfhjq17pPiODdpOp+Xm93sPsXlrM33EjZpN7SKvU + bevSt4/DYiSP0QcsoBVNx9M4pRgAeleQ2P7SnwV1C9jtbTxl5s7Z2L/Zl4M8ZPJix0BrtviD4/8ACXw/ + 06PUfFuq/wBm2zZ2P9nllzyqniNWPV1/OsU9bDsdNuztB53Zr8v/ANqC4iuvjlr80K4iP2bHJ/59oh3r + 7B8bftY/C3S/DtzeeGdS/wCEl1KPb5Nh5Fzaebl1DfvHhKrhSzc9duO9fn/rOp3GralPqF7N5k8u3L7Q + OigdAAOgFJRtIqLtdGeO+TgHrXt37E9zHD+0FoMbHaZvtG09elpPmvEl4YuRkDqM10Xw28V3XgjxnYeJ + rCPzbiz8zam4L9+NozyVYdHPatVJJkSXMmfrYvGEVsZ6DHSlB45HH868J8M/tWfCK/0O3u9c8Rf2Nfy7 + vMs/sV1P5WGIHzrDhsgA+2cdqs6/+1H8IbDRGv8ATvEX9oTv/wAe9v8AYrqLzsMA3zNDhcAk89cVnIaO + l/aG+KNh8K/A0uryD7TqcmPsNn8yfaMSxrJ8+xlXasm75hz0FfmJrep3usalLqWoT/aLqbHmS7Au7ACj + gAAcADiuw+N3xO1f4peLJda1GL7Jbrj7JZbkfyP3cav84RS24xhuRxnArglPPIzn9aEirhg8sDjHSvoT + 9jP4Rr458Y/8JDrEPm6Hpf8ArLbdt+0+bHOg+ZXV02ugPQ56cCvGvh34U1Lxx4vsPC+jLvvrzzPJTKj7 + kbSNyzKOiHqRX6ofDnwlpvgbwfYeF9IXZZ2fmeWMsfvyNIfvMx6ue9WnoQ2dDnJwBgjtQSxYYGAOnvQR + x93jsM15t42+O3wq8FeJbvw74l8U/YdVs9nnwf2fcybN6K6/MkZU5VlPB7+tQndlGL+2dLGn7OPid5Tu + H+ie2f8ATIK/NQ+p+Yn8MV9NftYftEad48tbvwd4Vt/O0MbM6lvZftfMMv8AqpIldNroy9eevTivmQYA + I25PrmjltqVcUD5WwN2OjdMfhX6X/sc3KXX7PHhqZRgN9q5+l3OK/M9sHBC4X0z0r6g/ZO/aJ0jwNYWn + g3xZF9k0Vd+3Udzv9m5mlP7qOJmfc7qvXjOenFavTQytfU+8BksCD8vcUi5yARjd29K848DfHT4WeNvE + Vt4f8L+KPt+pXW/yYfsFzFu2ozt8zxqo+VGPJ7V6OyAg8ZU9vWsyiSiiigAooooAKKKKACiiigAooooA + Q42141+2zj/hmLxd/wBuX/pbBXs3PpXjP7bBP/DMvi0Y/wCfL/0tgoA9mooooAKKKKACiiigAooooAKK + KKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKK + KKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAp6jYW2oWklnex+bA2M + ruK9CD1Bz1ArxjT7y8+CGpR6bq83neCJs+VebQv9nYBY/Iu+WXzJZQOfu9enT3Dhc4HTr7VV1KwtNTsn + sb+PzonxuXJXOCD2I7gUAWVO7Yd3Bz260oJLYB6frXhzeDPEXwmvG8Q+EG/tbTn/AOQnpmI4PtWBsi/e + yM7JtaRm+Uc4weorvfhd49tPHFjcwvaf2drOn7P7S03zDL9m8wuYv3u1VfcqbvlzjODzQB29FFFABRRR + QAUUUUAYfjTwxonjPwxd+G/Edn9u0m72efB5rx79jq6/MhDDDKp4Pb0rzU/swfAouAfBGG9P7Vvf/j1e + xYYSFs5z0HpSkZwD930oA8a/4Zd+BfP/ABRG31H9q3p/9rV2Xwy+GHgT4c/2gfBOif2V/aXl/a/9Kmm8 + zy9+z/Wu2Mb36YznnoK7EKQBhMEdBnpTj1OD1/SgB9FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR + RRQAUUUUARjG7IbHrx1rx1v2YPgbJJufwR9f+Jre8/8AkavYwAOn3e/vSgnOM8/zoA8a/wCGX/gZ8v8A + xQ/ToP7Vvf8A49Wx4J+A/wAKPB3iWy8SeGvCn2HVLLf9muf7QupNm9GRvleQqcqzDkHrXpZByQTk/TpS + 9CR+ZoAfRRRQAUUUUAFFFFABRRRQBxnxJ+GPgj4jR2UfjLRf7T+w+Z9m/wBKmh8vft3f6t1znYvXPT61 + xZ/Zf+BeAjeB8gdP+Jte8f8AkavYlQ87vvHqfWndeC2QegxQB40P2XvgUSR/wg/Pcf2re/8Ax6vS/BPh + bQPBnhm28N+GrP7DpVpu8iDzXk2b3Z2+ZyWOWZjye/pW0Bjg8D0pMMzq3T1HrQBJRRRQAUUUUAFFFFAB + RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAB + RRRQBG+dvI4/u145+2Pi/wDgbrPhi0/favq3kfY7f7vm+VcwSP8AMflXCgnkjPbJr2TPAyc+9eN/Fcj/ + AIaa+CWB8v8AxPuf+3JKAPZ6KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii + gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii + gAooooAKKKKACiiigAooooAKKKKACiiigCPBUlguWPXnrXn/AMUfhJ4U+IVxaza5Bvltd/zb5Ru3BB/C + 6/3BXoOPlADYbscUDjgH5f5UAeHw/E7xX4AmNl8T9Izo9l/x/wDi/wC0xc7+Y/8AQoEZvvPHD8uf754z + XrfhDxDo3inw/ba94fvPtmmXW/yJvKePdtdkb5XAYYZSOR2rRuYIrqB7eVMxNjIyecHNeX+KPgxpUvia + 48Z+Db3/AIRfxhJtxq/lNebMIIv9TJJ5ZzFuTp/FnqAaAPV6KKKACiiigAooooAKKKKACiiigAooooAK + KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK + KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK + KKKACiiigAooooAKKKKAIsggj7w79sV47oB/4S79pnxL/bB8z/hXn2X+x26bP7Qsj5/3cZztH39/ttr2 + M7iTlsZ6DHSvHf2SseIfhtD8TNUTz/FPird/bN9nb9q+yzTQQfu1xGm2NQvyKuepyeaAPZqKKKACiiig + AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig + AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig + AooooAiOdw2rk9znpXi/xEYfEv4sWHw9tk/tXwppXmf8JvaZ8nyvNgWaw+c7ZGzJHn9yxxjD4BxXpvjz + xTovgrwxd+KPENz9l0yx2eZNsd9u91jHyoCx+ZlHQ9a5L9n3wlq2heGZNc8ZWuzx3rWP7eufMU+f5LyJ + b/JGxiXbCVHyAZ6tk5oA9NooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA + CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA + CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA8Y/a0 + Y638NJfhxpX77xb4ox/Ylj937T9mmhnn/eNiNNsYLfOy56DJ4r1+3RURYlPAzx61458NHHxK+I998RJZ + P7V8J2Hl/wDCFXG3yfJ8yFob/wCX5ZGzImP3ynGPk45r2hcgEM27HfFAD6KKKACiiigAooooAKKKKACi + iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACi + iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA8Y/aUV/ + FV14b+Djf6LB43+1edqH3/sv2IRXK/u+C+4rt4dcZzz0r2IKVbcDu9B0rx34sAn9pz4KcdP7e+b/ALck + 7V7Iv3uG6deOtAD6KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK + KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK + KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAjyflDcE5+X1ry74/e + JtXh8Pr4S8F3/keNdZ/5BS+SrZ8l45JuZR5X+q3feI9snFdj8RPFuk+BfB9/4p1yTy7Cx8vzTtY43yLG + Puqx6uOgNcP8FfC+ovr2s/EvWl+yar4l8j7RaZV/I+zLJAvzqdrblweFXGcc9aAO48BeFtK8JaHb6To9 + n9ggj3Zh81pOrM33mJPVieveuhTG3gbfbNL64OaMAABRkDtQA6iiigAooooAKKKKACiiigAooooAKKKK + ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK + ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAPF/jSGsPjh8KvFV + 4/l6PpH9sfbbnGfI822SOP5R8zbmIHAOOpwK9lBOBlcevPSuC/aD8F33xC+EuteEbC6+zTX3kbW8tX+5 + PHJ0LKOiHuK1PhT4ytPiB4D03xfYweTb6h5uyPeW2+XK8Z5KqTyhPQUAdZRRRQAUUUUAFFFFABRRRQAU + UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU + UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU + UUUAFFFFABRRRQAUUUUAR8twF+U989Kh1C9trCzkuruXZEmNzbSepAHA9yKTUb20sLJ728l8q3jxubaT + 1IA4HPUivFbS3v8A42Xou7weR4KX/Ux/K327Iw3I2SxbJYgefvfTqAO0+PUPjTrMGoXqeV4Jh3eXBlW+ + 25Ug/MNkseyWIH/a+nX2q1ijhjVIU2xfXOfzqRY1iUInyqOnfFOb5jjOR3FAD6KKKACiiigAooooAKKK + KACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKK + KACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKK + KAGE/Mc8Dsa8Y0ct4A/aJn0pz51p4/2/YE+79i+wWhaTn5jJvL/xFNvbdXsmMKBs5/hXNc38SfB+m+Nf + Ctzomp23nxSbcfOy9HV/4WX+4O9AHUcZAPJ7UgOTkDj+9XmvwC8Yap4i8IvpviqfPjHSsf21abF/0fzZ + JGg+eNRG+6JVPyE46HBr0rb8zEjrjmgB9FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUA + FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUA + FFFFABRRRQAUUUUARE9MnAP8P/16fyW/mKw/G/ijQ/Bfhm68S+Jbz7BpFps+0XPlvJ5e91RflQFjlmUc + DjPpXmE3wuufiz/xPPjDo/kIP+Qb4b+0hv7I/gl/0q2dPP8AN8uKT5h8n3R3oA9q5yeMj09KQ8MATubs + MYr558VfsnfD6/0qW28Mn/hHdUOPLvsT3Xl/MCf3bzbTlQy+27Paup+EnwB8I+A9MiST/iaalz9ovv3s + Pn/M+3935rKu1X28dcZoA9cxzjqW+83/ANanZYfw4H1rxGLTvG/wgAntdU/t/wAFQ/dsPs8Nr9hzx/rC + Xll3yybv9nbjoePS/h9428MeOdHXWPCmpf2jYNnEvkSRdGZekiqeqMOnagDpqKKKACiiigAooooAKKKK + ACiiigAooooAiLbQXUbienbNYnjbxZoHgzQLnxD4l1D7Dplts82byXkxudUHyopb7zKOB3rkPHXxg0XS + fEN94L8ORf2/45t/L2aHue28zciyn/SHQxDEJZ+v8O3qcVF4O+GWsp4gtte+Ifir/hMdV03f/Zd1/Z6W + H2fzEZJvkhfa25dg+YHGzI5JoAwxa3vxr1VLm9j+z+BIM+THkN/au5cNyNksHlTRDr9/6dfabeJIIhHG + vyj3pyDYpHp0PrSg/MMc56GgCSiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo + oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo + oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAPNfil4Duda1Cz8U+F7r+yvF + 2nb/ALJd+WJtvmBI3+R2EZ/dBhyD1yOa1PhV4/tfG+n3IktP7N1qw2/2jpnmGb7L5hfyv3u1Vfcibvlz + jODzXYsMjaRlD+lcF8RfhwfEepQ6/oGtf8I54ott32bVfsv2vy9yqj/uXcRnMalORxuz1FAHeksBndgD + +LHWn845ryDQfim/hXVLfwn8TE/s3UZd32K8z532/CmST5IEKxbFaMcn5s5HevXIyCp2jK9jnrQBLRRR + QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR + QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFADRyMjijr/Dn8aDgfN1qG7uoLWPzLmTYv0J/l + QA852k42Mep64rj/AImeOv8AhFFsNK0vSv7d8U6x5n9i6N9o+zfbvJ2NP+/ZTHHsjYv85G7GBkmuPm+J + N78Rb6Xw38LLnZJb4/tfWdgP9lbhvh/cTovn+bskT5D8nU9q6/4beBT4Ve71XVtU/t3xTquz+2dZ+z/Z + vtvlblg/cKxjj2RsE+QDdtyck0AYvgvwxrniLxLafEb4jWP2HVLLf/Yeh+akn9hb0aG4/wBIhIW589VR + /nU+Xnavc16ZuGSPukdfalOdxA5Pc+lIAF6Dg9TmgCSiiigCMjKkdj2rz/x18KfDnifWh4mjj+xeI4f+ + PPVN0kn2fKqj/ud4R9yLt5HGcjmvQWIYBScbulH8RJGD2PrQB43/AGx8dPB3/EqPhH/haGzrrP8AaNlo + +/Pzf6jBxjds6/8ALPP8VavhD48/C/xT4ktfDeleJPN1u53+TafYblc7UZ2+dowv3FJ5Pt1r0/qvJzjv + WR4u8OaL4s8OXWg+IrP7Zpl1s8+HzXj37XV1+ZCGGGVTwe1AGo0nOQ25e4xindBktjb3xXjf/DOvgbQB + /anw1tv+EP8AFVv/AMeGteZNf/Zd3yyfuJpTG+6MunzDjfuHIFKvw5+Nqnb/AMNB/uuy/wDCG2f89/rQ + B7P+FH4V4j/wnnx+/wCiA/8Al4WP/wATR/wnnx+/6ID/AOXhY/8AxNAHtY3A/Mc+/pShVIHfHSvEx49+ + PgOT8Ad2O3/CYWIx/wCO1Ktx8c/Gitp76b/wqww4zqHn2Ws/ad3P+r42bdu338zP8NAHs0n3c43D0zis + jxf4n0TwjoN54g8Q3v2LTLPZ58/lPJs3uqL8qAscsyjgd68xg+E3xA1Kc2Xjr4u/8JT4fuf+P/S/+Ecg + s/tW0Zj/AHsTh02uEb5eu3B4JrY8GfAX4T+EPEtn4j8N+FfsOpWW/wAif+0LqTbvRkb5XkKn5WYcg9aA + Mg/HKPxWD/wpjw1/wsV7b/kJr9u/sr7Hu/1XNzGPM37Zfu/d8vn7wo/4Qbx18SXNx8S9T/snwrqX/H/4 + C8iGfZ5fEf8AxMYGWQ5kSOf5cddh4Br2PBOCTgD+H/69LgKAqnGaAMTwV4Y0LwX4ctPDXhqx+w6Zab/s + 9t5rybN7s7fM5LHLMx5PettRyccDsaRl3YHYdRQMlg7D6D0oAkooooAKKKKACiiigAooooAKKKKACiii + gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii + gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii + gAooooAKKKKAMvxHo2m+IdIuNH1i3+0WM+3zot7Lu2sGXlSCMFQeDXkp8K/Ez4etcnwZe/8ACV2M2zyd + J8q3svsm37376RmMm8uz89NuO4r2t8bTxnHagEkEfdI/GgDzXwZ8Y/CviG8vLKS5+w3lts8yHZLJjcGI + +bywOi5/GvSyM5/zmuX8e+BPCfjiyitfFWl/b4Ic+X/pEsWMlSf9Wynqi/lXmTeD/ir4BMreEdQ/4StL + 7HnQ+TbWX2bZ935pGbfu3seMY2+4oA9zQ7sqD93o1NUKW+Q8L0/2f8a8a0L9oPw7qOtwaZf2f2CKTd5l + x5skvl4UsPlEXOcAdeM16f4Y8U6H4ojlbRb37WsOPN/dOm3OcfeAz909PSgDcooooAKKKKACiiigAooo + oAKKKKACiiigAooooAKKKKAGc7fkXcPrjNGeN4bg+1VNVvrXS7OW/vpvKtkxvfaTsyQBwMk5JFeG/ED9 + oOKO/v8Aw98PtL/4SDWIPL3N9oNrs3BXH+ui2nK7+/8AD6kUAe26zrOn6Tse/ufJBzgbGbd09AfUV5Hf + /tOfDK2v7izi1bz5INuR9nuFzuGf+eNYnhH4Iaj4v8SXniv40r/at82z7LaZWH7NhGjf57aQB9wWI8jj + GB1Ne3eD/CuheEtLGl6BZfZLRekfmu+PmZursT1Y9+9AHl+iftK/DXU9Wt9PbVfsrXG7yn+z3D7tqknj + yhjp39a9oA2YAX5R79KwvGfhHw/4y03+zfEVl9vtf4ovNkjz8ysOUYHqqnr2rxnXfhj8U/CutWeseA/F + v9pRx79+n/2dbQ4yoUfvJXP9526dselAHvcN2kt1c20XzS2+zd/wIZH6VY43KQ3AzxjrXl/xJ+En/CU6 + zJrug67/AMIzqt1j7fcfZPtn2naqpH8ruFTaqkfKOd3PIrl5fG/xh8Kn+3PGvhbyPD1p/wAfcn9oWjff + +ROIlL/fZRwPrxmgD3k5yMjn19KQg/8AAB1968q8G/HLwf4ggnN7J/ZoTbsXbLN5mS2eRGMYwPrmvS9I + 1Kx1fTo9QsJ/PtZ8+W+xl3bSQeCARyDQBeooooAKKKKACiiigAooooAKKKKACiiigAooooAiy2ST/wB8 + +n40/Bzk9/0pjsFYOWyo68dK838S/GfwTo2hyX9pqP2+448q38maPzPmAPzGMgYBJ564oA9JOfXYze2a + ranqFpp8RlvZvLjHfaT6eg9xXif/AAs7x541SOf4ceG/NtrXP2tvt0A37uE4mRSMFH6fj2rT074S3/im + 5l1T4man/aS3WPO0ryFi8vaCq/voHGc7Y34HGMetADta+L19rF7d6P8ADPRf+Ej1a02ebD9qW0xvAYfN + OgX7okPB/h9SKbH8Gm8VvPL8VtX/AOEntptv2fT/ALN9j+y4+9+8gkBfcVjbnptx3NetadY2mm2UdlYx + eXBHnam4nqSTyST1Jq0DkfK3XpxQBFDGkUQhhGFH/wCvvUxxkUZOOlHQYHWgBaKKKACiiigAooooAKKK + KAEpaKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo + ooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo + ooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo + ooAKKKKAMrxNoWk+J9AuNF1q2+16fdbfOi8xk3bXDLypBGGUHg9q8x8U/Abw9erD/wAIpd/8I8Pm+0jy + 5Lr7R02f6yT5duG6dd3PSvXiBktuwx6HHSnY+Ye/WgDwe58P/G/w4X0bwxq327TbXH2a5+z2ce/d8zfK + 5LDDMw5Paprn4z+JfDl1Jo3iLwZu1O1x57f2pGM7huXhIyv3WXoa9xPcnt94etGzHAHA+77UAeZW/wAc + fh2bdJb/AFv7Lcc7ofstw/l88fMI8HIwfxrp/CHjzwp4subi10HVft89tt80fZ5Y8bgxH31A6KenpTdY + +H/hLV9Qk1K/0rz7iTG9vtEq5wAo6MB0ArmvFvwS8G61ZrBa2f2GVM4l82aTqQehkHpj8aAPTEIbqc+/ + rS/Nk7h9BXhH/DNPh/eGbVPm7H7O/H/kWnW/wl8ZeBUZfhp4o+wreY+2/wCgQyb9n+r/ANe7Yxvk6evP + agD3jJ9KMn0rwf8Asj9oz/ocP/Kbp/8AjR/ZH7Rn/Q4f+U3T/wDGgD3jJ9KMn0rwf+yP2jP+hw/8pun/ + AONH9kftGf8AQ4f+U3T/APGgD3U8Lk8D0pVIIJ7evrXgy6P+0UN5bxhg8c/2ZYf41Jdfs/wa3cT6nr2v + +ff3W3zZfsZXO0bRwkoHQAcCgD3XnsMGuAu/jR8NrW5+z3HiPa56D7FcHtntHXDf8M0+HduxtT/df3fI + k/n5tehf8Kq8BLJ5v9gYPc/bJ/8A4ugDlvEnx48NRLBH4Utv+Elkbd5qb5LTysYxzJHzn5unTb71ynib + xR8Sfi3pE+keC7H/AIR+GDb9uuPNt7rduYNH8soQjmNh8p/i56CvcPDXhjRPDa3P9jWf2ZLjb5g8133b + c4+8Tj7xraHyn73yjtjpQB8t+Hf2dvFHiK3uYfiX4m+2W/y+RbfYY488kt80EoPVYzz6fWvefhd4F0L4 + eeGIPD2hQ7IE3c7nO7Lu/wDGzEYLnvXVEtggDcfTOMUrEjvknoKAH0UUUAFFFFABRRRQBzXjPwR4a8Yf + ZG8RaX9vaz3+R/pEkWzft3fcYZztXrnpXmuufs/2Fxqcs+i69/Y+nceRZ/Y2n8r5QG+dpdzZbJ56Zx2r + 2v8AiJAye/tQT8xXH/16APDLnRvjnoF3caVoGr/2hpdtt+zT/ZrKLzNw3P8AK5LDDEjk84p138avEHh6 + 5l0fWfBXm6na4+0D+1Ix94bl+7GV+6w6Gvcuj5C8n73NJtAIB5/u0AeQeHfj3oFy8q+JrT/hH9mMfvHu + s5z/AHI/93/vr2rYHxw+GLTRqvijhs/L9guef/Iddvr+h6Xrll9l1S2+0w+nmMncH+Eg9QK54/CzwIQu + dC3Fc4/0ucf+z0AXvBfjfwx4z+2Dw1qn9ofY9nn/AOjyReXv3bfvqM52t0z0rpMD6g9a8s8ZfA3wdrsN + rFbwf2eId/8AHLLuyV9ZBjp+tcy37NPh/L/8TXLNjn7O/b/trQB75+FH4V4J/wAMz6B/0F//ACWf/wCO + 0f8ADM+gf9Bf/wAln/8AjtAHvGR1HPvWT4p8TaL4Y0xtS1u9+yWoxmTynf8AiC9FBPVgPxrxwfs06Bvy + msYHb/Rn/wDjtbfg/wCAXhTRLtri9P8Aab8Y/wBbD2YdpT6j8qANg/HH4W4BbxPw3T/QLn/43WX4j+O/ + hWC0WTw0P7fuv+eH722xyP4njx03H/gPvXTt8LfAjR7f7Cyvcfa5/wD4utvw14Y0Lw6102jWP2Y3Wzzj + 5rvv252/eJxjcelAHjh/aFvTKFbwJgj+L+1hx+HlVJO37RRlPkxbUH8O6wOPzr3c8BRvwfp1oHDYHHp7 + 0AeDR/s9XK3qzjxryPvD+yxxxj/nrXpHhf4ZeCPDGqQ6nomh/Y72Hd5T/a5pNuVKnhnIPDHqO9diFwx9 + +vvRj/Z69eaAH0UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU + UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU + UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU + UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU + UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU + UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU + UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU + UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU + UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU + UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU + UAMBAI5z6cUA/MueD3FNJbd0wO3+1/hXCfEf4hjw+9jonh/T/wC3fFOq+Z/ZWled9m+1+Vtab986mOPZ + GWf5iM7cDJNAHd+YAPm+Ujr3xXFfET4seAPh1LYxeMPEH9mm+8z7OPsc8u/Zt3f6tGxjevXHX61xtv8A + Cpvigp8QfGzRN8x/5Bnh77Vj+xv4Jf8ASbZ1Fx5wjik+YfJ90d67n4afDLwP8OVv4/Bmi/2Yl/5f2kfa + ppt+zds/1jtjG9umOvPagDiz+1F8DFA/4rf5T0P9lXv/AMZrofAnxt+GHjnWBpPhbxP/AGjfHpH9guYv + 4WbrJGo6Ix69q9DC4YkD5j1Nc74/8D+F/HmjHSPFmmf2jYnrH58kX8St1jZT1RT17UAdCnzr13A9/WlL + HdjGR3PpXic3gHX/AIVu8/wi0P8AtLS5seZ4e+1pFvxwP9JuGZhhpJJPw2+ld58O/iBo/jawM1i2y5h/ + 4+YMOfLyWC/MVUHIQnjpQB2dFIpzS0AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAR + HG0AfcHUU5QR/tEdBSk5JJ4A71z/AMRPFek+B/B994n1ybytOsvL899rNjfIsa8KrN95x0BoA474++Jd + Yi0RfB3gu78jxprOf7MHlo3+paOWX/Wjyv8AVbvvEe2TgVv/AAz+G3hD4ejUJPC+jf2fcal5f2xvtUsv + m+Xv2ffdguA7dMZzzXO/Brwtq0es638QtcX7Lq/iX7P9ts8q+z7Mrwx/Op2nK4PCr1wcnmvUyMsPQ9fe + gB1LRRQAUUUUAMzkDAyDXkfxn+GEuuaxYeNfD0W/xRpfmeSu4D7V5qpE3LuI02xhuoOfY8164ccn7rDr + 7UbedoPyjqtAHJfDHxzpnjnQ/wC0bZPIuo/+Pq3yzeTlnVPmKqGyEzx0711g3cAHP+16fhXiPjeBPh78 + c7XxnFbedaeKN/8Aas2/b9m+zWqxQ/L8xfcXx8oXHfPWvb1KsCycg96AH0UUUAFFFFABRRRQAUUUUAFF + FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF + FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF + FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF + FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF + FFABRRRQAUUUUAFFFFABRRRQBFwdw+8eM9s14/8AtTaot54Qtvh9bS+Xqfijd9jk25x9mkimfgjb90d2 + X2z0r2IhjkHkGvCP2k3R/ib8MQ/zxP8A2tlOm7EMXftQB7L4X0+XTNGtrGeTzJIt/O0DqxPYn1rTHXB6 + ikHGFxjNLjHB5zQA6iiigAooooAKKKKAPP8A9oDwbe/EH4Ra54QsJvKur/7P5cm0NjZcRyHgso6IR1FT + /BHxfpvjj4e2OvaTa/ZrSfzPLj8xnxtlkQ8sqnqhPSu2x93jBHavEf2I1Kfs/aDl92ftHOMf8vc9AHuN + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUARMy7SxHH8VeI/tL2lxD4q8E+K54tuj6H9 + v/tG83A/ZfPSKOL5B8z7m4+UHHU4Fe4gDd0yfWuO+Mvgl/iH8ONX8ILq39lPqHk4uvs/neV5cySfc3Lu + zsx1GM57YoA6q3nhuoBJE3mRv93gjODzUv8AEQDgjpXnXwb8YJf29x4T1bT/AOxfEmkbft2med9o8jzS + 8kf71V2NujAb5ScZwcEV6LyeGH1HrQBJRRRQAUUUUAFFFFAHH/F/xpb/AA9+H+peMLm0+1Q6d5W6PzCn + +slSMchWPV/Q9PxrI/Z28F3HgT4XaZoFzf8A22WDzf3vkiP708r9Azf38de1c18e7sfESHUvgv4f+e9u + fK/tW76f2Zt8u6h+R9om8wIw+V/l6n0r2DS7VrOzjgkm81lz8+3bnJJ6fjQBcooooAKKKKACiiigAooo + oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooo + oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooo + oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooo + oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooo + oAKKKKACiiigAooooAKKKKACiiigAooooA8T+OVhN8PG1H4yeGuLqPyv7d0/j/ic58u2t/3jlhb+SHZv + kT5+jetekfDvxjovjrwxb+ItAuPtNnPu2NsdM7XZDw6qeqHtXQRrtxn5R2XrivMPHfg7WNF8S3HxG+H1 + l9o12fb/AGxpHmov9tbUWGD99MxS38lC7/Ivz9Dzg0Aeo5xgt+NIMk4PzD8sV5T4L+Muk3niWz8EeLbX + /hH/AB0d/wBs0bzGuvs3yNKn7+OPyn3QhX4bjdg8jFenWl5b3e7yH3umM8EYz9fpQBZXg5796TnABGc0 + D7w7561UvtQtLOWJbqXZ5+dnyk/d69B70AWpCoXD8L3rk/i34xPgP4fat4sbTP7S+w+Tm08/yt2+VI/v + 7WxjfnoemK5rxt8Ubu31eTw38P8AQP8AhLfEMePtFn9sFj5eVV1+eZNhym88HjbjqRR4U+E1jL4gt/Gn + jf8A4nPiyHd5d580Hk5QxH5In8tsx7B04xnqSaAJvgv4Pe2+0+Ntd1L+1/Emr7ftd95Hkb/K3xJ+7Rtg + xHheAOmTknNelKHzlurfpSsMKwzt6c9aUjndjLdqAH0UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFAGD428L6L4z8L3nhvxJY/2hpN3s+0W3mvF5mx1dfmQhhhlU8HtjpXmF/8A9P0 + eOCH4Va9/wAIHCd39oL9kbUvtnQx8zyEx7CZPu/e389BXtL8AkDd60pLbhxigDwyD4O/EzeWb43+Zu/1 + h/4RW3GcdP8AlpVzTf2f/D+pwxy/Eu9/4TW+gz9muvKk0/ytxO75IJQDkBBz02Z7mvZvmxhmz+HWlBOA + T8ue1AHOeCPBXhfwPo39j+GdM/s6yPSPz5Jf4mbq7MerseveujYhT6E9KFGAABux36UbdoAz070APooo + oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooo + oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooo + oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooABRSZpaAExRilooAbiloApD7UkC0Amk + Lml4o4qhJoNopOlAU5pcgdaWg7JCE5GSKQA9AMA0F13D5uD7VBc3MUELzTtiNcdj9O1F0OzZPuO0Mw24 + 60Yz7Fehqppt5a39sl5ZSedbS52ttK9CR356g1b8xeeelGgmuw4gijOaNwNHSi4eobqBTc+1OFLUSTQt + FGQKNwp2ByQwE04GgketH0piXqKKGFIppTSHsKKKKKBhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQ + AUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBGpDD5WxjocUBiBk + rt9ec4rH8aeJtG8IeHLvxB4jvfselWmz7RceU8nl73VF+VAWOWZRwOM+lcA37RnwdH/M34bv/wAS274/ + 8hUAesEnqo3EdulIGyy45VuntWd4c1vTPEejW+r6Pefa7K53eTL5TJnaxVuGAPVSOR2rSB3AEnAPagB9 + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRmigBKUUCigBgycHrSdGyW49MU + p965Xxf4/wDCfhFlTxBq/wBizn/l2lk/u/3FP95fzoKUW9jqNpJKsdx/Kg7tuMY968w1v45eBbOyL2V/ + 9tuR92DyZo93Iz8xjwOCT+FccP2jblYi83gjypP4Y/7VBz68+VU850Qwlep8MT6AZsMEPzA9T6V5/N8Z + /h3HcNbSeIdsy4yPsVwccZ/5546V8+eMfih4h8Vxyw3N1t0yXGyy8uM4xtJ/eBA33l3fpXIzTQQhhNHu + 2Y3HJ4z06VnKskehQyiT/iaHuvir49+fPNpXhfTt0jbfKv8Az8bcAMf3bx8/xLyfevJfFmu+KvFf2X/h + KNU+1pZ7/J/0eJNu/G77gGfur1z0rn7rV/nES/eHf1/Si31KAPgpukPVskZ/SsXUZ69HKqVHVK5Jb2tv + 5mCu5h0bJGfwq0luXO/y+V/i3dM+1VF1YSAw2sGZH+7Jv6Y56EVFLe3Ej7Y5/s+77nyB9nr9c1LmzreH + i9FE0vJ3uouHywzg46/lUqW8Cyq/l+eozgZK4rKjuZBtd7jee3yYxVmK4V0URy+X6HbnNRzSQnQh1R2/ + hTx34m0GMW2n32y2HS38qM56n7xUnqSa1ZPiJ8SluY4LPxV9sznaP7Pt488ZPVfr+VebC8kBCxx7d33z + uzt9KtPqy2UzJcHJfG0/3cDnoOetbQrW3PPxOVwq7Gj4i8TeIr28uDq93mZtvnjy4+wG37ox0A6Vzu22 + V8Kck/cHPPrUmoeNtJsIZLKRtqDGUwx7g9dvvVTRbqz8RIV0C0+2XMH+si8wx53Zxy+B0Un8K0ji4vQ+ + dxWSVqSuSiVFAXftB7YzUM0q+WADxVFlvbaa7t9Y0r+z54tmF+0CXrz/AA8dMfnU6LGqkKuGHfNdkGpH + z9WLpuzGQy+XcOrcJx5I/u8fN9fxrY0Ge3KNaPNgt/q4dp+bGSfm7Y61iXC52xscypnbJj19vpS2lxJE + 0NxEvkyDdvbO72FEokU5Wluffum3tpfWqXlrL5kMudr7SN2CQeDyORVnJ+YnjGMNXiH7N/j21vLWLwfN + N+9iz9ik2n/SMmWSTgL8u3GOTz29K9v5znGcdPesz2Iu8bklFFFIoKKKKACiiigAooooAKKKKACiiigA + ooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAjPXdtzjoc15 + h8RvGeuah4im8AfD6bbrabf7S1Lah/sfKLNF+6mXbcecgdflb5Op5wK7nxj4k0Twf4cu/EXiK8+w6Xab + PtE/lPJs3uqL8qAscsyjgd64T9nbw3rlpoFz4u8cWXleN9e2f21N5qN5vkPLHB8sR8pcRFB8gGe+TmgC + h4V+C1k2u2/jbxxd/wBveKzu+13vlm2835TEn7uKTy1xHsXgc7cnkk16K3hPw88oP2D506HzpOM/8Crc + 25YnGD60iEktlsnjjHSgDyDxd8JH0vV7vxl8On/s3xNJs5x5vm4VYv8Als5RcRl+3OfXBrrvhX49tPHG + lvItt9g1W1x/aFhvMn2fcz+V+82qr7lTd8vTODzXYngE44PWvBNXUfCr40Q6sqf2R4R17d/aj58/zPIt + gsPHzSDEsn8IGc85AoA9+5xSjpSBgTil70AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU + UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU + UUAFFFFABRRRQAz8KARTsmk59KTv2C6HYpCBRTc0K49RcU4cUlHWhX7k2SAZpaQUE0WsPcWiiimAUUUU + AFFFFABRRRQAUUUUAFFFFADRQQSaFOaR320avYVuYReeQvPpmgccg8HvWH4t8V6J4Ut0vNcvfslu+cN5 + TvnBA6KpPVh+dcu/xn+H2wtHrO9/4V+yzjP4+XRdLc1VOo/hR6KAfXj0pc44xgntXhepftBRQ6hJBY+G + fttuMYn+3GPPAP3TFnrkfhVdP2h2dAG8IYbsn9pdfx8qsvax7m6wNfflPdzuPAk5Xqdtcz4v8feFfCYH + 9u6l9kDfd/cSv/dz9xT/AHh+deS6v8eNRvLfbZ6B9hkXrJ9sWTHI7GP2P5180fE69l8S+ObvV7zVM6ve + 7PMk8gfLsiRRwMKflUdh+dTKtHudWHyutVfvRPpS9/aYjiuzDB4Q+0Rj/lp/aW3PGehhqP8A4aZcsdvg + nPqf7V/+018oXU+oaUonL/bLNP8AWnCx4zwPU9T29Kt6V4qhkIWSLY6/dXcTu65528VksQz1oZVhk7SR + 7H40+KXivxbcXFhNeeXpsu3/AEHy4jtwFP8ArAgY/Mu79K4u3hMiNk/vD0/2ay7C8SeF40+VuMJ1xye9 + WvtZMYlWbeqdTtxjNRKq2d8MFSpL92i8UVYsCTLr0Tb0/GoZ5444vtQXzWH3mztx26VTD5faJuv3fl/O + muisfKlTeT15xUuUn1OqlQi9WWm1RdpjWDzIn6nfjGPwqjLdtKA80X3f9YN3X06U9Y9oaGGPyl43HO7Z + 3H1zVlYS4XaNuc4HXFS2mbWitGVIo52mBK8P15HYU94sOXRtv4VNHF5MgeU4U9Kp3ms2mm74hB5jLj+M + jr+B9ajmaBqVtEWooOPlbeo6pjH61aWykUI7txzxj73+Fc3aeJr29ndNNsN7cY/fAY4/2h7Gur034d+J + 9XtfO1DVPsZj/wBc/wBnjk8vJIXgMM5wOnTNZzxCjuzRUXy89yhd31pYENLccN/rjsPGPu/z7Vj3ni+G + zuWtkj84R/d5K9Rk/wAPvXo8Xwm0aO2S0kl/tS8XO262vDjnJ+Tfjpx+Ga6jS/Bek2cE1lYaX5GnPt/0 + b7QzdCT94tu+8Sf0rmqY5Iyk4rqeQaffeIdTVnfSvIs0x50n2iNtuc7eMAnkdq1L34aanq1qDca/s8n7 + 6fY1OMnjkOPSvbv7HEpEVzL5jt96Pbjb+IPNZnifX/CvhZUt9U1L7I9znyB5Er+ZtwW+6DjG4dfWsXip + 1Je4c7xKlDljucnofw50fSUhKx5t13faH3P/AKV128byU2k9utdpY6BeRgWUNz5tsv3V2Abe/c5PNedT + fHKxsGMK+GPtMS/6qT7eyb+548vjBOOa5/W/i74ou2ii0VP7FhXPmPmO483pjhkyuCD9c+1OOHrznc8n + F5iqUfZzYeMIZofFd5GW/fx7M8DvGv4dKonYBIwXg4zzWcdZ1LVtUnvtauvtU0+35vLVPurj+EAdAPyq + 28jPiPftJ7YzX1VCLjBcx+eYqV6zY8z4VPJG1DnC9cfiaYGkjlLEfum6H0/yahcr5X71uvU4qqGBYoI9 + 7N1TOP1rW6Zzx5+h3Hwy8SyeD/Gth4jFp9vW28zMPmeX5u6N0+9g7cbs9OcV7XcftGSxKp/4Qrf6D+1A + P/aVfMNnerE4dVwF+62en4VtW9uupazpReT7FG3nZbHmbcL6cen61hNpHtZXUpSfs6x9e/Bb4lt8SrS+ + uRon9lfY/L2j7V52/eXH9xcY2e/WvRdylsgbtv4VyXwg0q00b4faZplhbfZIIvN8qHeX25ldj8xJJyST + ye9dcxIOSPw9KSdzpquEZvlWg8CjOKQnHWgc1Rkl9wooLEUtISKQ7pAM0uKQNSk07jvfYWiiikAUUUUA + FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHhv7SEsureN + PAPw/wBRbd4Z8S/2j/bFjgD7T9mjimg/eLh02yAN8jLnocjivbIo44IlSJdiLnvnFeJfHcD/AIX78Hgg + xN/xO/L9/wDRY8+3Svb14LbeW7igCSiiigBg5wccnpXnP7Qeiabqfw2u7q7s/Nns9n2c+Yw2b5ow3QgH + IA616OPmGD+dcR8bgF+GGsEcKPIz7/v46AE+COu6p4k+Fuj61rNx9qvbrz/Pn2Kmds8ir8qgDooHA7V2 + /GRz8x6GvN/2Z3WX4IaBIH3BvtPz4xn/AEmXtXpHUgnjHUUAPooooAKKKKACiiigAooooAKKKKACiiig + AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig + AooooAKKKKACiiigAooooAKKQGgmgBOT0OKbls7Sv45ppdeTn5arX+o2tnbme5k2RDvgnvjsPesnVit2 + UoyeyLZAJ5PB7UhABxjg965abx14fTCLefMfufupPx/hqncfECzMgTS7X7dn7n7wx59fvL9fyrGWMw8d + 2arDV3sjtFZW+h6CnAkDJGB6VwUnjq581EfRNrnO0fagfr/DUNx4sv7qOOSAf2cVzv8Auy/Tqv8AnNc0 + 8yw97RZrHAYi12j0MjvnGOhpMMMID/wKsDwp4hXV4bhza/ZvI25TzN/3ie+B6V0IHtjHvXfTqKpG6OVx + cHZj6KKK1JCiiigAooooAKKKKACiiigAooooAjY4JyOtNbHduT1OK534n+Ih4T8E6h4hYf8AHn5XH+/I + ieh/velfmpGURWUPwMYOKiVRQOzCYJ4i7UrH1d+3a00M/gue0l2Xafb/ACjtB6i3B68dM9a8S0e+kvNM + /teSfzoZf9d8m3ycMVX3bJHYcVwGohsMJk2Oe+c56elS6YsF/apC0WJhnyzuPHJJ9ugrknN1dj6HCYae + GsnqelGZGCNjbHzvOc/SpPtG0tuH73jbN6evy/pXKeGbmWe0+xzDN1b/AH2yOdxJHt0rXDu42yTbXk+8 + NuelZJrselGnzammbgCIRg7nPbpXA+Lb5oPEF1NbHEbbN5+iADqK6SSRkXc82zH3W25zXI6+hGpy/Pn7 + uVx1+UVMmux106beiL1trcNyCs0ew/8ALN8k59eMVLe6Vp89xJc3Vt58vHmSb2XtgcA1y/Lbfbv60SRh + wWJ3Efd7fWsoysazwyauaraXfWCCTTZvtKP/AKyPaqbcdOWPOck1o6d4itJ1aW7fbIMbUwT69wPpXOWd + 7cWKO0MnEmN3yj5cfz612ui3ttdxeXBLuK9RtI8vr69c4/CrdQxpUruzdieGdZmKJLlR0G2rHmwopZo8 + H+I5P4VLHzGFifa38S4z9KteF/DPh3UtXFrd6T9pW7/i+0SJ9xSexHoKj2sUrl1IOnqZ63UW5hGPtKR/ + 6xOU69OaxbnxM0W+IT75DjZLsxj14x+FfRfhXw/p2iWr2uj2n2aPjMXmM+zknqxOc5JroUtYxbJBKmH5 + 8s5685NcX15p2SMfrlKWjPlfQ9L8Q+IGW3/1dlfZ/f8A7s42ZP3cg9Vx2ru9F+FKtCz62/nXK4/d42+v + dXx0xXtd3t0yF2mi8kcfPu3Y59Bn1rzTxN8YNGt0hk0CH+2Jfm875ng8rpt++nzZ56dMe9ZurWrfCafW + 3GFonT6P4e07RnimsbLyY4s7B5rNszkHqTnOTWzb6bHBDKC2Ihj95j7vPpnmvnrVPid4uudUe7tr37MW + x5UPlRP5eFAPzFOc9ea5XQ9LvNY1SDT7KP7TcTbtse4JuwpY8kgDgE1Dwst5s4qtSduWTPrqe2gij3LH + 5UR/1b5J+vH1rzfxR8WNHsnFtpMH9qtH1Xe8O3OD/Enufyrxjx74L1DwRcaJJrcf2GTUftH7vKyeX5YX + urNnO8enWtHTtAt9WHnaRqf2sN1/cFPUfxEeh/Ku2nl8eT2jloeFPGyw9TlauaWs/F/xNPfotref2Ugz + iLyo5tnA/iKc56/jXD2EDoGMs2EbGI9v3MZ7989a7i2+Hfi8yKY/Df2yMZwft0Uef/Hv84roLb4aa3fF + UudM/sp0zg+ek2c/R/b9a6qfsKXvRZy4nE4iqvcjZHmENnFHlo48gdfmPy/41MHXOEfcP72MfpXqf/Ck + rgzeZJ4o8mQf8svsAbb+PmfjW5oXwvh0+bc+tfaVP3j9lKdj/t+9afXKO55NTCV60uaoeNW8igbfM2Me + hxmrBkPzJIuZGxtOa+hH8AeFLkOJ9H80nG7/AEmVd35NxiqGn/DXwTax7rfRPL3feb7VMd2M+r8Yqo5h + f4TL+z3KSuzw1TG7psOE53f0pql2EckhyTndX0hY+HtF08MtpZ7G4y/muf0J9zWkr7ZUP3c5y/8A9al/ + aEl0KeWQelz5ZhceeziT93xkY68VpaLLB9qFqY9yP3yRtwCfxr6TuZfMR2aT5+Mtt6/hXNXem+HbmA3t + 0m5V+9JmQbcnA4B59Kf12UuhrDLYx96L1MXwH8XvF3h/xFM9yPt+lnb/AKH+6i8z5G/jCFhhmz74xX0h + 4N+I/hjxTObfSr7zLkfej8qQdmPVkA6Ka+FvFtqkHjvVrsR+Sk3k7I87sYiAPNO+1xlTvbOPvcVSxVj6 + fD5LDEYdSWjP0W3LkBvlz260J9wbW6e1fnUlzIg8mNtp7tjOe9dD4a+J3jPwrZ/Y9A1r7HC3VPssMmeS + eroT1Y/nWscSpHNV4frKLUHdn3ln5uR06H0qYcn3r5s8DftLwzXVrpvibTPs0Y3/AGnUvPL7eGZf3SRc + /wAK8fWvbfBHjXw74xgln8P6j9rjixuPkSJjJYfxqP7rflXRGSZ41XB4ih/ER1ANKaaetKx4qmYJ3Foo + ooAKKKKACiiigAooooAKKKKAEGcevvRnHX86wvFHizQPDMBl1rUfscY/i8h5O47Kp/vD86+bPi3+1zpW + msbXwXF9ukH/AC13NH/cP3ZYD6sPw+lAH1VI6RqXkOB/Fx19Kry6nYruWSbpj+Fv8K+YvgbpWt/GDwg3 + irxX4g2RN/qYvsaHZ+8kjbmMpnPlqeR/9f5N+JGtyx+Kruy0qTbYx7Ng2g5yik/eGeuaAP1TjvbaQZjf + d6cEZpxu4Qw3S4HptNflh8LZPFXibxXZ+G9J1HyJbrfz5MTfdjd/4sf3T3r6k+Dvwyj1KW/8MeJdS8vX + 9P8AL+1r5GfM8zfInKOEGEC9Cc9+aAPrJHVxkHNKSOua8H1b9n24liJ0/wAX/ZpO3/EtD+nrL9a828T/ + AA7+PHhaBj4e13+0E7H7JZRdx/fY/wB5vyoA+v8AOOvytQNv8PTvXwrpv7R3xU8D3C2vjHTvtXXc3nWy + dif+WcTf31/L617j4F/ah+H/AIgRYr67+wzHO4eXPJ/e9IQOgH50Ae9DBGB0o56D5R61naHrem61D5+m + Xf2iL18tk9R/EB6GtAcnKtx9KAH0UUUAFFFFABRRRQAUUUUAea/H3wXf+KPB7XXhmHb4t07/AJA1zuU+ + T5kkYn+R2EbZjVh8+cdRzXRfDLxhp3jvwRYeKdKk32t55mxtrD7krxnhlU9UPYV0jbhgDhe/tXiem3X/ + AAqX4n6pb6mv2bwhrvk/2WM7/sPkQEzfd3ySb5ZB97G3tkUAe2ZK8gZJ6LTgcAHoO9Z+hatYa9pMOp6T + cfaLK43eVLsZc7WKnhgD1BHIq6hBXKrjPTnrQAowdpC9OhzXif7QWtXmuavp/wAM/DV95es6h5m+Pygf + 9Wsc45cBfuhv4h+fFem+L/F+geFIbZte1H7Mbjf5R8h337dufuKcY3DrXnXwI0PWNW1nVfiB4iO433k/ + 2VF8n+ibFkhm5Qjfuwp+ZRjt60Aer6Lpdloumwafp0X2eyt93lpuLfeJJ5JJ6k1eUqTsHalwAckcjvSY + baFJ3epxigB9FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA + BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUGgCFWwwGMN6elY3/CT6QNMf + VBcf6FDjfLsf5cttHGMnnjpXlP7XHjebwr4WsdFtbbdNrXmeXdeYB9m8l4WPyFSH3BsdRjrzXyX4Z8Sz + +HbtiY/tQufvruCY2g47H+9+lebicW6b5II78Ng3VhzyPvRviP4WAz9vyOx8mXn/AMcrIufiY0jM2m6R + 9oh4/e/adufwZM9civKNOuU8yRLPgT42yf3duex6961LWFvtLysPmbG8/wB3jivCnmmIl7qdj1FllGKu + 9Tak8XeMZmYLceWT1XZEcf8AjtUbp7jWG+1Xl/580n3h5IXGOB0wOgFERWIGNUwB/Bn+tXI8iRki+UnG + 3viuVVa8m7s2jSpRty7laSztTaBo7Dex/h84jHNaIUAkxnbEf4Ou78e1RRFhLtRdzHqc43f4VKj5Dh28 + xjjPGKmUKj6Gl5a8oohieEW4G2MfdXk55z1qVYAjBhyq9V9PxpiOfu43bfvL6596nUkrz8obovXH41aj + Lld1sTKbirtjtF1NdGvUntlzBLnzbbPoCB8xBPU54r1uCYSruHIH615FcKPKZ35WPHmfj0rofBGr3Flq + Q0CZfPjb7kmQvl/KzngDnOfWvVy3GRhaM2edj8N7ntInoYozTVOaXGK+hjK+p4trCnrQ3SgUpqtxbBRR + RQMKKKKACiiigAoooNAHg37aXiLTNP8AhTceHLu52X+s7fskWxj5vkzwO/IGBhSDyRntmviaBopGJUYU + 9Dk8V7Z+2b4qu9V+Js3h+5+Wy0Db5D8HPnwwO3AUHqO5P4V4p5o+aQ/uMY3D730rjnK9Ro+kyyny01cZ + NEOBG3zHrxVOXeWMka/vU6HPr/8AWq5IdzHAx6VWbe7YBwO5rLW9kew9NzW8qfV7Xzw++5T75wBnJwPQ + dBWzb61Fck5P71vv9f3vp2+XH61xkDT2uoC7tm2yL04HHGO9es/CLQ/CPijXhFqtpuZ/+WXmSjGFfupH + 90Gsar9luzSnOcTnmuYpIySvzL05NY1xG01wYYl3M33+cdsivrLTvhz4H08iaz07y37nzpju6ju/HU1H + rnizwXoE8mnahrP2aaDG8fZZn27gGHRSDkEV588Xf4TohiZdj5n034e+LtRkD2uj7lT7/wDpMQ65x1b2 + qxD8KvHTlCNIxnOz/SYePX+OvoB/ip8PLJTMNZ3f7P2WcZ7ddnvXLah8fNDilZbTw/8AbIh0b7Y8fp2M + f1/KkqtR9BuvNO0UeZL8HvG8kQeTSuB2+0Q//F04fB/xhMks40H7OY8Zg+2RN52ePvb/AJcdfeu+n+Pl + oLfzY/CvnIOq/wBoFcc/9c65K7+MXjyZ5ZI7v7Ohx/yzgfH/AJDrSm6gVJSmrS0OL0rxA1h/ot43m26f + 6s4xjOSegz1IrtfBPinQLTxLaXE+oeXbDf8AvvJc4+Rh90DPU4rzzxXrM/iC8udS1Z/+Jg+zdPgc4AUf + KoA+6oFc1c2dywkjjfzPMxv4AzjpXVCl7Ve9oclevVpq0Vc+otX+LvhOztGxqm+4ONi/Z5Ru5Gf4MDAN + eTa98YdYvDItprPl2cuN9r9lQ9MY+cpnqCf0rzJdJ2LvNztkP3fk6+verS6bHDvzH5vTbztx+tXDCUab + 7nlp1pO7VjVt9Qt5JRFby/K33htPP5iprnXEZTEEz5n8GfvY98cVjpZxPMqRxbWbOINxO/j+92x1r0fw + D4B0DXtVvbO68Rf2V5Hl+Sv2J5vtG5WLchhs2479c0TjGC5kbRTmrSkY+geJfDtjHJ9t8O/bLk4/ffbZ + I9nX+EDByCB+FbGsfGTxjfX0UkWp+REudkfkRN5fAzz5fOcZ9q980X4K/DmHTYRdaT/aFyN3777TcRbu + T/CJMDA4/CrusfAb4c3lo8Vpov2a4bGy4+1XD+Xggn5TJg5AIrndSE90dHt0mrLY+TvGms6t4okhm1uX + zTBu/e7VXdu2jooH90CvZPgNrWgeHPBEen6jqPlXKZ48lztzLIewIPDCu+P7PXhj+zbaDz9l5Fu33eyQ + +bk5HyebhcDj361iz/su6U8xaDxF5IH3B9iZtnHPWbnNONePJyHnYuMKtZTRbufir4FtAUfW9rR9R9lm + PX/gHvVeT4w+APIUW3iPzAmd8X2KcdTxyY/xqtH+zDbqoDeKtw9f7PP/AMerC1T9nvxDZMi6Zffbhz5g + 8qOP0x96X3P5ViuR+7ubwoUYvRkt98adKW5Is7H7TGOk3msm/j+6Y+Mciq4+MthcoZJNN+zMv8Pns+P/ + ACHWI3wQ+I/nFYtD3R/89PtduO3p5lZOrfC7xrpXGo6dtx0Pnwn0/uufUVfLSitUUsNTqPlUjbvfilq5 + jVbG88lx0by0bH4FPrXKT+P/ABDczx/b9M+1uudn7+NO3PRfp+VYhgu4wI3OC33zxz6V6j8OvhmqW817 + 4ntt9kdv2c78buWDfcfI529ar2lOnHRCrZfSgrJ3Z5nqfiK4uEk36Xtkkxz54PTHtXPah4v1W3aWG2m8 + txj5NqnHQ9Stey/Eb4q28sF3pHh+PzMbPsmpZI7qz/unT6ryfcV4ubOCRgWTd6rkjH410Ua1P7SOdZHV + qvmgY1z4k1u8DJcXe7zMbv3ac4+g9qZHc3E0rMz4zjBwOK6GGwh8yJlhwpzg7jz+tX7a3hhjDQvvZfvD + BG38+tbzr0/snThsiqc15yLOhztJZwSXMmC27aMe5z0rUR5Qh3nYD95eDn05qlCA0TwKuJRjJz97v+GB + XY+Hfh/4k8QHAt/ssL/cbfG+MZzxuB6j9a86rWgnrofSx9nQpqLZzMcqgSyJ87JjdJ0zn2/SkiaW9lMV + u3lyP/yzwDnHufpmvY9G+DFus/manqX2xY/vQ+QY92QcfMsnGOD+Fd9o/gXw/pFrCbHTvIZN2z9/I27J + OerHHU1hUxsUtGc1bG04XlY8C0f4feL9UKPb6V5cBzmb7REfX+EsD1GK9u+CvwK0G/tL+fxzY/2jJ+78 + hPNeLyeZA3MUnzbsJ16Y+tdmETzCFX94OgzWj4E8QadpXiddFknze6znyl2N8vkozHnBB4Pcj8a2wOL5 + qp87mVZ1qPNCOp6uB60oUUjc0hU9q+h3dz5RWtYlooopjCiiigAAoooJoAj6NgjOetPyM+4rjPiD8SvC + fgaMnXtQ8idvux+TK277vdEYdHBr5S8d/tLeMvHOpHQvh3afZ1l6DzIW3YVX/wCW0S/3H7/0oA+ufGXj + nwz4TiV9e1D7KH6DyZHzjb/cU/3h+dfMnjf9pvxH4ou10j4a6L5jS9J/tUYzgK33ZoR/dcdf6VH8PP2W + tW8QltY+Jd9suH6w+Upzjcv3oJgOixnp/WvqTwZ4O0LwlZm00O0+zL3PmO+eWP8AEx/vGgD5f8GfszeI + fF1z/bHxO1Xcw+5F9njGeGU8wTD+7Gen9av/ALRf7NFteaXbal4Et/Kltt++DeW3bmiUfNLLxgBz0/pX + 1iMAEDjFGBkds9R60AfnF8GPip4s+B99caNqmnZtLrbvi8+L5dodhyqOTkyg9f8A63qVz8c/g5rVx/aW + o+GPLuT91ft92d3G08rGAOAK+rPEfg/w54hk36xp32p+58+RPT+6w/uj8qx1+FHgVXZhou0Nj5ftU3H/ + AI/QB4F4c+MngLSrz7Z4R8E/8TV/ut/as/OAQeJIyv3S3+cV3f7O2h+JNV8Y698R/Fdn9nu9W+z+Wvmx + vs8qOWE8xkA5AX+Efj1r2HSvDWj6Vzp1j5J/66u2OvqT6mtgYJJXqetAD6KKKAMfXPD+k60jQ6ja+aDj + /low9D2I9BXmHiv9m/4ca7bND/Zf2aRv+Wn2i4fuD080eleyBcKFA49M0vI6DigD4t1r4N/FD4Rzy6p8 + PL/7bbJjKeTbR9QF6zSOesj9u30rrPhV+1NDNeyaN49t/sd8uP3m8ydQ7dIocdNg69/rX1KMZ2YyB3zX + mXxX+CXg34hoH1O08q6H/LfzJj/c/hWRR0QCgD0HSNUsdWtRdafcedAejbGXPJHQgHqDVzjBG3kds18b + Xnw9+LfwWiku/BVz9v05sboPLtY8dh80rOfvSsfw+mPS/g9+0foHiSRtH8UJ/Y+rRYzHl59+d7dUiCjC + qp69/UUAe/cck8mnDoDUUciyIrw8qf8APen5GCw60APoopGOKAFooooAYQScY4Pes/xBo2n6/pU+lata + fabK52+dF5jJnawZeVIPUA8Gr7jls9DjPtQikfebeR3xigDxLxB8INS8Parc+Jvhre/Y7+LZ9l07ylkx + lRG/72ZyOjO3I74HaoYIf2hjLta/+TtJ5Nh/Kvc8bsr0z19qXO5eOCelAHlfgz4KeGdEjE2ryf23dxf6 + qfElvszuB+VZCDkEDn0969UUEDrlj3x1oByuQev8VBGOAM5oAfRRRQAUUUUAFFFFABRRRQAUUUUAFFFF + ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF + ABRRRQAUUUUAFFFFABRRRQB88/tgaRJqP/CN3hh3RWn2rzG3Y8vf5IHfnJHbpXx54ltruzuLe1vIfJlO + 7A3BuwPb2Ir70/aOghi+H8+rT232o2W3MXmFN2+WJeo6Y69D0r4d1bRZLeMJNd+esn+q/d7d2MZ6Hj8a + 8DE2pYhuTPfwMlKhyo998Parp+teF9O1PT7b7HPJ5vmJvaTbhyo5IAPAPbvXU2slvLK8doMxx4yvPGfc + 15l+z9qekah4aHhyW28i8h+9d73bdl5HHyYwMAY6+9eg6bu2xETcNn93t6de/wCtfP1oqlWfU9amrwOd + t9P1VPijdX0nhXOnSbNmsf2gv7rEGD+4zuOW+T2615DrPwq8X39zrx07wH9iS8+z/YY/7Xik8rYB5nJf + 5s4P3sYzxX0vHI0bLtk3Bu+MdKsxBeFTnH3T6V6mHzGNOnpHU8+phnUqJ30Pn628E/vfhH4K8Z6Xhh/b + X2uz+0f9tU+eNv8AdPB9j3Fe2yadf/8ACYWd7dRfbLZN/kDcsf8AZ+Y8N0OZfMPr93FbMYVpWBj+9jK7 + uv41NHuZd8g3e/pU4nG+2gtNh06Pspv3tzxbwX4L8aaZ8SvDE7WH2bwtoX2v7LD50L/YPPhYP824yS75 + DnnO3tgVH+zX8N9c8K3WrX3iXRvs143k/wBnt9qR8cSiT7jkdGX734V7kh7MMj+9np+FSowEaY5Rc8U6 + mYSlTcGtyY4ZLWTE060trCyjtLA+XbR5xHycZJPU89SafPI9qY5vN8ow58n5c5zw3+TUg3tgKPm/lT4S + IgCDgDo3rXHTtFJp6m3LeNlsej+HNRXUtLguTwW3foxHoPStM7t5bd8vbjpXlPh+/l0e/t55D9nsJd25 + cB84BA5wT1Neo20gdNoPzL9446V9PgMUqsbHz+Lw7pMtdqTNGKWvQ6nKFFFFMAooooAKKKKACg9KKKAP + z8+Nvg3X0+Jt9HqMvnTz+Xh9qLv2wx9g2BgYrOsfhhqrW0YmuPJnXPybFbHPqHx0r7G+JFq1trkVwG2i + 7zxj+4qisP7NOI0USY35x8o7V4GMxLpTcU9T6XBPmppo+bF+D88y7p9a2MP4fsoP8nok+Djum19Y2D1+ + zZ/9qV9K/Z5huYHIGPSka2vAFdI8jn+IV5vt60dbnoSqc+iPmo/BJ2Q58R4Vun+g/wD2ytLRPg5f6ZN9 + qtPEG6Q/6j/Q1GOCG6yH1PWvoVoLzywC+0H2BqNXYYzLuH+7jFOWIqz+IIOoeBXvwh1e/eOP+3squdp+ + yJ/8X7VSm+B1+wj83WvM25yPsqj/ANqV9FFoCFBuNpHQbCaWaa3WUIhz/ePNSq9SOyNFXrR6HznbfA+8 + ikyut7H/AIT9lBx/5EqwPgjfsd6a3uPYfZV4/wDIlfQbzwuxZmy38IweaWC4giy6y/Q7TzT9vUfQpVq8 + feseARfBDUVUMmv7cdB9jU5/8iVYj+B98zAHxFsx3+xA5/8AIle+G6tWjQCTAbOVwecU/wA6zcO2dpOM + tzzSVWoRLESlrI8Dh+ADbkWfxD5qPn5fsWMY9xLVm2+AFukPknW8sf4vsp479PNr3TdETIqy4cY52mms + bcucNlX7YPah4mutjF1Z3umeJJ8A7DaCuo+af4f3DD6/8tKnm+A+lO0jibhcbflb8f8AlpXsJlWJyoPm + GPp261BLEVcxiPA7fNVrEVupbrOS94+J/iroMXh7xdfeH4DiKPy903PeNH+6Se7Y61hWdvcwTg29ztnf + r+7Bzge/HSvYfj1pN03iNJUix52fJbcOyR7u/wDOvNE0XUwpdbPYq9V8xTnP419PguSrh05nzmMr16da + 8DQ8M6/qlpqsdra3flk5zL5an+EnoR74rodJ/aG8dW1zFDPL56Lnem2Fc8EjkRVwpsr1WjRIcu2cfMOa + +mfiD+yAbyGe/wBE8T+beDbttfsGPO5UH52nwuACffpTqYSg3sZRzLESvGWhmaH+07P9m2z+EftIXrJ/ + aITGSewh/CtS3/aXRotsvhDaU6n+0s4z/wBsq8lP7M3xnsgRbeFvtQbt/aFomPzm9/0rmr7RtV0C+Oma + xZ/Yb61/10PmrJjcNy/MpI6EHg964KmEjGV0jtw9bnsrn0C/7TEItzMfCHB6f8TI+uP+eVdP4b+O3hy7 + 85teg/sfy9vknfJP5mc7vuR8YwOvr7V80aZoV3qiebZL5iv3yBnGfUj0NXZvhpPeQCeOH5k6Q7h+9ycf + e38Yxn3rllh0pXvY9OLpSvaJ9jeG/HHhvX7fdpd99phb/plInc/3lB6g1s3LLGMNznvXwUfAvi2FAbK2 + +yeZ0g3xP0/2i31P41jXJ1uwm8m5uszSdIvLTtz1HHQ5qVh6bWstRKkozu9EfbPxE0Rdd0tdON15ETdv + L3Zwyt6juK+YPiJ8UL3xdYrZ29n9htJM/aP3ok+0YKleqArtK9uuawLTxZ4otYpLVbbCy48wb4/mxyP4 + eMVD4Q8Ia3rryLo9l9rljxn96idd395h6H8qpRjRXvHqYKnSdTmk9DES3YqVX52k69t2P5U+UB3POGHS + u5tPhZ4vuiPO0fakX+u/0mI7c/d/j5/CvUfAXwwh0xbO61q38+U79w3lfL+8P4XOc5FY1cVTiexLFUqU + brY8Q8LeGLzWr9bVI9ufvzbgfL4JHy5Gc4xXrNt8DZQSLzxB9nI+6/2MNv8AXgScY4r2Sz02G1ihzF5h + tt37zcRjd7ZqzbxARxlB5qc4HSuP285/AeXUxc370Voee+GvhhpOkwtHNN9rmGMPtZM9ewcjof0rvreI + RfJHzAOo9P69a57WvHfhHRdSuNPvtU+z3se3K/Z5W8vKg9QpByCPpW/dWviS+0H+1fBeif2qZ/8AUSfa + o4cbW2txJ9G6jt7imqNetujza+OUIrnZLcSeTbPPKcRJjPvk4rzTxP8AGO007VHtNO0r+1oOMzfaDB/C + D90x56kj8Pen6f8AB/4m+M/EEEnjmb+z7W33eXPttpcbkOflicHqqD8frX0l4H8IaN4P0tdM0eDyIucj + e7bvmZv4mOPvHvXo4fK19tHHXzGjRj7vvHnOieGPG3iPQL231CD/AIQu5/d/Zpt8Oofxkv8AKCB0UDn+ + /wAdKwNF/ZmW31JLnVPFv9owDPmw/wBneV5nykD5lmyMHB464r6FAP8ACNuep607qc9Qegr1aeEo03dI + 8eeY13s9BEXaMU8H1o6UMM11Ndjh63Y6iiimAUUUUAMJAO0nBbpXzb+0f+0hbeC5ZdE8Lv52rx4y+Cu3 + PlN0eIqflZu/61sftZ/GFfh54fOm6Vcbdbu/9Wdmdux4WP3o2U/I5/8A114h+zN+zvP4ouD4i8dWmNPH + +pj8wfveJUbmKUFcMqdRz+dAHEfDb4UePvjNqA1rUH/0I9bjEHPDL90Oh6xAdP8A6/3H8K/hT4V+HVkI + tEtdsw6zeZLzy/8ACzsOjkV2umWNrptstpZw+VCmdo3E9ST3JPUmpwM7cHnnDUAPpaKKAI3GVOTgdzXk + 3xp1/wCKGiXJuPB+k/a7PuftNsnZB/y0BPUt+X0r1pCwHJz74pTn7u7n6UAfOvwK/aMtvFGrf8I74tj/ + ALO1o/ci3GXd8sjnmOIKPkVT17+tfRJI3A9j3r5X/bK+FCf2TN8R9Bi8vUbPb5y7s7t7QQLy77R8uei/ + 419B/C7UbjVPA1hqF0MTS+ZuXjtK6joAOgoA6iiiigCMgnAPP+1ThncQenakJ2g5bp3xXy7+1B8UPFa+ + M4vhh4Jk8i/nz57bYm+7HFOv+tTH3d/Rv6CgD6K1rxLouiRiTUr3yIx/F5Tt6f3QfUVzNx8Y/hxbIWm8 + SbAvU/Ybg/yjrgvCH7N+hLDDdeLpP7VvTu87h4f7wX/Vy46benp7mq/xJPwN+HkKW2q2GLuLOI/OveM7 + T1XcOjigD0Kz+NPw0upBHB4l3Meg+w3A/nHXZaPrOnarF5mn3Xnj18tl9fUD0NfF8/xP/Z8uZmL+Gtu7 + GG+3Xx/9krvvDnw48I+L9Hm8QfCPX/7IvY9u8fY5Z+rFB/x8OB0WTt39hQB9PkhZV3d+/rXkXxn+AXhH + 4jOl9PF9k1FM/v8AdK+7OwfdEqqPlTH41znw2+LPiLSPGEvgz4qt5eozY8m4xGekbSt8sCFfumMcn+or + 6DHJyOM96APiWz8a/FP4C6oNL8XD7XoMv+rm/wBGTGF3H5Y1d/vzKOvb0zj6u+Gnj3w/8QtGGreH7z7R + CPvr5Ui7fmZRy6qTkoe1a/iTw/pniPT3sdYtvPgfHyb2XoQeqkHqor4h+I3hfxX+zd46XxB4Tn36A+cH + ZEMYiVP+Whkf787dv06AH3kpI/h/DPSuS+JXjfSfA2hDVtTkyf8Aljb7W/efMqt8yq2MbweRzVb4QfEb + RPiR4aTW9IPTPmph/k+d0HLIuc7D0Fee6nK3/DXGkxE7gvndsbf9AH50AWz8OvGXxBjupPiRrGywl2eR + ov2aE/Zcfe/fwspfcUR+enT1plj+zv4Y8O3Sa14Km/sjXbfP2K82yT+TuG2T5JZSjZRnHI4zkcgV7gMj + IPPpSHOQd2fbFAHlngnxhrfh3xNa+BPiRc+fqlxv/sfVvLRf7W2o0s/7mFSsHlKyJ87fP1HcV6oODhjn + PQ+teOftpBB+zZ4quM7HX7HhuuM3kA6V6xozBtPiZX8xTn58Yzye1AF6iiigAooooAKKKKACiiigAooo + oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooo + oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAOZ+IGjWviDwveaXfW/nWs+zem8rv2urDkEEYKjvXw + 94ytbRLnTmE/k2z+bmfaWxgL/D168V9/zRo6fOOR09q+GvjT4Ku7SSyWO8+Q+ZkeUOfuf7XvXi4+krqT + PYyypq4nFfCbX7PRvEVxYS33l6Ve7fPPkk52I5XsW+8e2Pyr6Ilks21W6t7OLdBNsx8xG3C578nnNfI+ + rxH7St0hwkmecfdwAK+mvBmqxXuhaXrdtDtWfzsw7ifL2syfeI5zjPTivHx9JNe0XU9mhO6cDq4JY5Iy + 6Nn8KvREuu7bmTvzVC3eJSIUb/Uff4P8XIq1DgDG3Lj73P5V5sWaMtJ1qwhqqhqaI5rQyauTrgGplPFV + kJqdDVIzJUYmpkqFCBUqnNaIZHdBnRg822BsfNtz5X4dWyfyrq/AGrLGDpV2fLeP/VDrvzuY9Bxjjqa5 + 1N2EK/u3GeOuKbb3K2Grpfk+fPDn9193dlcdegwDmurC4h0Jp9DjxMFWjZHrY+ZQaHB45rN0XVYdUtvN + i6fj6n2HpWl1Gc8V9ZCanFSR4EoSg9R9FFFaEhRRRQAUUUUAFFFFAHzr+1N4b1jTYx4/0u7+XT/9aPLT + 915nlQj7xO7OT0U4/WvB2+JXimCBAfG2wnOY/wCyojjn12V90+KtA0zxRotzoWu2f2rTrnb50HmsnmbW + Dr8ykMMMoPB5xXmd/wDs5/Da6uPMTSfJUfwfaLhu3r5tclXC0arvI7sNjZ0kfLlr8U/El7KlvB4y+2uM + /uP7Mjj3d/vFOOmfwqp/wl3ibWY/tK3H25T/AMtNkcee3TaPTH4V738Vf2ZfDLeAr8eENB+2a+nl/Yo/ + tckecyp5nMk2z7m48+nHOKwvDHgr4u6Fpcel2/w2/dQ52t/blr3Yt3Y+vrXHXwiivcR6lHM4S+I8YiXU + 3ZjPoPnSvjy3+1quMdeB7VZXR/NmWW58PZZc7j9s9uOhr3aLRfjApjK/DPai5yP7dtDjP409vC/xeeOI + R+CvIZc5H9qWrZ/WueOFqP7JUszgtmeEHQLZF3W+jeVJ/F/pRP8AM0w+GH3iSLS/k7/6R/8AXr2a88Ef + HKRd0Gk+SfT7RZN/NqoW3w4+P91Pi7k+wr2OLGTt7P8AT861+pTfQj+15LZnkw8PXaZX7DtPdfOB3fjn + irMOiaspKJBuI6/Oo3frxXuNn8DPiNeSJBqXjz7PA+d4/si3bpyPuyZ6gUXn7LN5fljd/EbzA2Nw/sQD + p06TewprAtkTzebPGH0fxI8CkWvyHO4+ZHzz9ar6lq3ii4CnVGy8GdwxHxux/dH0r2yH9krTxH5cvjHz + c9/7MYZ/8j0x/wBkbTZD/wAjjnHb+zG4/wDI9dMMAluck8ymz58v/FOtQKivJtR887U7fhWbe+OLxJSJ + bza6dB5YPX/gNfVen/ss6NazrLN4h88/xD7E654PpNXYaf8As/fD+2bZLp3nW5+/F5067uuOfNyOea0W + DgY/X6h8Mf8ACbamkgaO7/3v3a/h/DVgazq9z+8juMs33fkXnHXtX3ifgd8LmKh/DG7bnb/p9yMev/LS + rNp8H/hxbFjb+HNmcbv9NuDn83rVYWmJ42qz4x+Gd/caZ440/VdabybODzPOfAbO6J1XhQT1I6CvVtd+ + L2iafHm3H2x5O2Xj6Y9U9/0r6d0Tw1ouktv06z8knofNds9f7xPqa2MAndjDVDwsb6Gf1mUlqfB+v3Wt + +PPE9hqa+HPtNhF5mIvtqJuygXr8pHzJnpX3cxJ+U856D+9/hT29c4pM4GAMH610qMYo5/ebuPPFNKhu + tL1oFD3DY8n+KHwN8K+M1vr5Iv7P1u68v/iYbpZdm3YP9X5gU5Rdv456181ajpHjL4d2ccXi7QPIgu8/ + ZR9shbdsI3/6ssRy69fw7190FTuQEbxzubpj8KXG4DcvJ681lWoKojtw+YVaXofFGmeJ9Nv7pYLF/tMj + Z2DDJjAJPUexrYkktpbd5C3lRtjbwT3r0Dx3+zZpOua+dR0fXP7EgbrbfZGuMfIq/faUHqCfxx2rzjSv + hb8X9Huo7YaB/aNjHn5PtlpF1BPXeT1P6V5FbAzi7xPap42hXp8zlZmf4m8LabrtinmfNMc+W3zDy+Rn + jIByBXtNjBFHbiKKP/R4/wCDcflyfXqcmvH9R1KTwx4hGk6vH/Z+oW337fd5u3cgYfMoIPysD1717Lpd + rqWpeHH1fw9pf9rbseRF9oWDzMOVbl8YxhjyOce9cdWjWqKw44h01zN6EttGZXYl8+X958fcz0475rnN + f8ZeHdA1L+z9V1T7JdTfeP2eR84AI+6pHQj86dcaN8XNbngs7Pwz/wAInE27zb37fa3uMDI+QkdwV4/v + Z7V0Hhz4A6DBcXVz4ovv+EjuZ9mH8p7TbtBHSOXB42/98+9FHLKlR++EszoJXk7+Rxt1rviPxXo93bfD + TR/t80ezF79pji+zZbP+rnAD7gsi+2M+lXPA37NsEU8OoeLNU+1b93naf9nKdAwX95HL/utx6Yr6L24X + 5TgjoaBnsevevboYClSWp5FTMq07qLsjN8N6FpfhvR7bRtHs/s1lbbvJi8xnxuYs3LEnqxPJrTICgjHA + 70hA4KnaT360qrggAcDofWutQSPPbb3HkCiloxViCiiilYAooopgFFFFJMCPJLYHJX9c1zHxO8YWHgbw + pc67qLYWHbgYbnMiJ2Vv747V0wXaBx9F9Pxr4j/bz+Isd/qNt4Ps38yO23+c2MfeFvIvBX2PQ/4VSA5n + 4HeG9S+O3xal17xIPtml2ePtS/LHnfBIicoUb70K9B259/v23hNuVRB+5/hXP+r/AKnJrw/9irw9FpPw + ks7wD97eb8tz/BcTjpk+te7gAkORz2pAPooooAKKKKACiiigClqFjb6lZPZXsfnQTY3rkr0II6EHqBT7 + K3htbaO2tV8qJc7VyW75PX3qf7xBB+hoPXGfvd6AH0UUUAR4PCgcHvXy58a9Bfwd+0No3xGuIdmkS+f5 + 77s5xaRwrwCW+83Zf05r6k2gAjbgfWsTxp4a07xb4cudB1ePzLa52+YuWGdrq4+6QeqjvQBsQypLEHg+ + Ydu386+Kf2rvgH4u1HxRd+LtAg/tCCfZvi3xRbNqQxjl5MnJBPTtXpU118Tvg7cJZrH/AG34VTP2dN1t + b7MjLc/PIcyS9/T0PHUeEf2jfAOvazFpUt19juZM/J5c8m3Cs3XygDwPXvQB+esngvxMtwIG0zEjdE8+ + P0z13V9pfsKeA9f8L6TqmqarB5EGoeV5Sb0b/VtcKeVYnqw6gV9LiztnL5j+9jcMntXDeKPi78P/AAy0 + lvqes+S8WMJ9mnbrg9VQ/wB4UAeS/t+aXEfANlrSHbc2fmYk5/jlt16Zx09jXs3wV8THxZ8OtN1kvuml + 83eMY6TSKOwHRfSvi39qL40R/FS6stF8PW+LWDzMjf8A6zcIm/jjUjBjbvzX2B+zj4ak8K/CfSNJnXy5 + 187eM5/5bysOhI6N60Aeirnbkt5gPfGKwvHvhbTvF3h260bV4PtNvNs+XeydHVuqsD1Ud66DkDJ5IpvO + dxOSO1AHwR8BdS1f4J/Gmbwlr0/lWl1t8xtiHO22kkHCBz1lHf8A+t9mfE3wLpnjrRRZXx8qeP8A49rn + DHycshb5QyhshAOenWvGv21/hrdeINAg8Y6Kv+n6Zu38j5vMeCIfecDop7H+tesfA/xZH4y+HGm67vy8 + 3m7xj7uJpEH8Iz930oA5Ffih4h+H0Yh+Lmn/ANn6bB9zxB50cv2/dyf9Gt0ZotjPHH/tZ3etJF+0b8Pd + Zn/szwVqf/CQ63L/AMeWn+RPa/asDdJ+8liCptQO3J524HJFe0BfvEHDHqaaMlPlfLHocUAeW+FPCniT + xX4mtfHfxGsP7Nu7Pf8A2T4f86Ob+yd6GKb/AEmFgJ/NCpJ8y/JnaO5r1P5iT6/ypTtxtI47+1IwDDBX + nsM9aAJKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii + gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAiYfJj7pP4 + 14P+0jpVo0OmeYmWPm+U+T6xZ4z/ADr3oZzn8vavGP2mdMM9hpF9HJsktfO2vtz94xDpmuDG0va0XY7M + FU5Kp8Zatp64keS48uZMeWmzPmZxnnOBgfnXsPwQvdP/AOFcJpMM+bts+dFsb5MTSMvJ4ORzwa8iv4m1 + S6iuNT/0iSbO0/d24AB+7jPQVr/BjWrzSvGMdmp86CbPHC9I3PoT1NeHKN8PZ6n0kbRlzH0DpUmfs6um + Fbds5+/jOfpitSElk2793qcYxWZdJLFqf9lwN5saf6tcBeq7jyf8avWsyyRp+9z12ybfz4rxFubyRfTO + KkTIqBGNTAmtUYk6c1Khx0qKJtvBqVeDk1aJaJUJLAnvUqEFWyOlRISA2P4akXzBECB96rRJOuGcYX94 + 3Rs9PwpZmTyHkki3jjcN2N3P6YpmQiibdz/E2PwFE5jkiKmXYi9Jtucf8B/SqTXXYXurVF7wZeS6brMd + vIfKilz53APRWK+vr2r0uFt8f3Nv+znNeR3lvJFAiSSb44s7JMY8vJ5475/Sux+H+r3uoi5i1Kfzmi2b + DsC9d2fuj2Fe1leKa9x7HkY/DSv7WOx2VFFFe+eUFFFFABRRRQAUUUUAJSGgUGkkmF2twBpaTFHSnfsD + SewlLilBFBFJiaDHvRim8etJ+NCTDXsPozS5ozS0Q9RBRQKDRa4CZozR+FKDVWEApc0lJiiw1YdSUUYo + skDuIKCaWjrS0YnzCA5oHtSAU4DFPcErbjDilAoK0q8UtQTl1DrRjFIlK9JXW47ooavY2Wo2MltqEPnW + 7YyNxXPIPY56gVbyRz6dfelBJGAcMO3pTskHnof0qkolN6ABjtimtuHfNCovpzVO+1Kx0/m7n2f8AY/y + HuKdl0IvdXuXUwPehgS2MYFcNq/xY8C6Wu271rB/69Zvb0Q+orktT/aQ+GlnMIzqm/8A7d7gdh/0y96p + RbByd7HtHHfijk991fOl3+1x8O4D+5bzh9J1/nBWXfftieEAv+iWG4/9dpR/OCk4MLn1ACMYzmg8Dnmv + jm5/bJj3/uNFyv8A19f4wUyT9sggfJouT/19f/aKXs2DZ9lZozXxv/w2Uv8A0Bf/ACa/+0Uf8NlL/wBA + X/ya/wDtFPkY7n2P+P6Ufj+lfG5/bKX/AKAf/k3/APaKUftlr/0A/wDyb/8AtFHs2Fz7FHAwB8tKOO2B + 9a+Pof2yrUt+80PA/wCvs/8AxitbTf2x/Djvi+0nYv8A18SH19IPpSUGK59Q6peJZWMty4wiYyfqQP61 + +TPxH1htd8Y6hqrDP2jyt3/AY1X0Hp6V91n9o/4feKfD17BDdeTP+7ynlzt/HnqYgOi18CymK4104+aN + u3I6LQ9Ckj9SvghpR0T4ZaTpzctD52T9ZpG9T612ozk+orJ8IiL/AIR+28jmM78Hn++3rWtwRx3pCHUU + UUAFFFFABRRRQAUUUUAFFFFABRRRQBEwbbyuR3GelfM/7Z3w6ik8HR+LdBsvK1HTM+YfNJ3+bJBGPvtt + GFz2P4V9NdGwf/11W1Gyi1Cze1ul+Rsbhk+oI6fSgDkvgv4wt/GvgKx1m2++/mbl54xK6jkqv9z0r5j+ + NPgHTtR/an06yu7Lz9PvfN8xPNZc7LFCOQ2fvD2rrv2X3uvBXxe8T/DudtsP+ieRwDn/AEeWZum49W7t + /hV/9oiaTRvjj4J1R1wsv2/Y2emLaJT6+vpQM9P8OfBb4eeHLlL7SfD2y7iz5T/bZzjIIPDSEdGPWvRA + WJ9CPvLSkgcnt1pEBXapOSO9AEtFFFAijrNhFqmnSWVyf3UmNw57EEdCO4r5+/Yp+0abaeI/C9w3OmfZ + dnA/5aGeQ9M+vqfwr6L4JbI6/eGa8E/Z4jeL4peMyq4ST7Dnn0gkoA9/ooooAKKKKACiiigAooooAKKK + KACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKK + KACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAGYyMHpXLfEjR4tZ0f7PMmV+p/vKexH + pXVYUjA4qG5jVo9sjfL9Kxrq9No0pS5ZqR+cWp6U/wDYdjcRJ+8/eea+evzADjP8qw9L1a50XxZbaraX + PkSQbsSbA23dGV6EHOckdK9g+MkdjpXiS+0qWx+0xw+X9mXzSnVEZuefXua8Z1O4mu7K3mPKPu2Jx82C + Aea+dpLlvFn00JucFJH06y39p5c07fZ7h85fCttxx0HB4Nb0B2zeW6+WU+8mc9feuC+Emp32pfDnToLx + /MZvN+yjCjfiZy/QDGMDr+FdhAq3lrCN+WTduOPU/wD1q8WvH2U+U6lJyNYMoXJ596s5ySfvL6dKpWSz + s8ZMu6Js87QOlMbVIo5Iyjfat2flwU6e+P8AOKItXsNxaNWMAOcxZ9Pm6VJFIGJJO5R17Vz0t/I774/k + T+712fpzmtbSYdVvl3xXO1R0bYp3dfyxiiLlzENMv27iUyKvLRYyPTNNjuYBNM11Ls+7k7Sc/lXHeKPG + 2h6aY5Ptf9qmTPmJ5bw+XjGOdpznP6e9T20ut6+Fms9F/wCEcVM4f7Ul35+eOhxt24P13e1bxpTlIyck + jpY9QRYjbyQ7j2O7Hv6VNE97cxG2hPmRDomAPfqaxfD+marYRNPda59uR8Yb7Isfk4yOgPzZz+GK1dR0 + xPEVxb2VzD9q2bvJi3bN+QC3IIxjbnn0roeFnsYfWIRdjMuPEfhyyYnUNS8pE/6YSHbn6DnqK6zwt4f1 + 7VUa6E39iwDGyTalx9p6g8ZBTaRj3z7UngbwTpHg+6Oq2o8pG/4+ZMuccMqcFj/e7D616pE2FIUcD9a9 + XAYKmtZbnn4zFN+7HYnooor3jyQooooAKKKKACiiigBMUtIAaM0k7gFFFFOwWFzQaSlpaiuM+oxTvpUL + SLEm/HyDqa4zxL8V/Avh1ymp615Ljt9lmb0/uof7wp2KszuQR1BpD6g14FrX7U/w/wBNk2NJ5h+k49P+ + mJ9awLj9sTwdG2LfSvNHr9olX+cFP2cmTdH06R8vPNIvTGMV8vf8NieGX/1Ph7zP+32Qf+0KtWf7XGg3 + DYPh7y/+31z/AO0KpUpdhOpFH0sSfWjdnpxXziP2sPDYOG0Taf8Ar7kP/tGnf8NY+FI+bjTtg/67yn+U + NP2NTsT7amfRhOfagH8a8D0/9qbwJcShJz9mz/12f19Ia7Cx+Onw7u4g8es/h9ln/wDjftR7Gp2D2sD0 + 0EEdc0Hdjrj8K4qP4peB5Bxrn/kpN/8AEVsab4v8Paiv+iah5n/bGQevqvsajlZSkmbv40pPpTFMbfdO + acBilYrRi0tNxTqWoCYoxS0UwuxAKWkzRSsgEAOc5571heNPFGk+EtFbU9Xn8mNcY+Rmz8yr/CD/AHh2 + rcBIODzjrXy3/wAFDrO/m8EaPdQnNpbef9pHy87pbYL156+lOK1EzzD4m/tC+MfHWqtY+CIvskAxtG6J + 8/KhP+tiU9Uf8/pWDp/wh+J3jCEz6jfbc9R5VsfUdnH90V9D/s96VoNv8O7K70q12vJ5nnfvHOcTSBfv + H69K9FHCgfwR/dX0z1r1KWFT3POrYuUND5d0v9lS8Vw2qaxvP/XsB6/3ZvpXSWn7MHhuN83tx5g/3JB/ + Kb6V7/ksoDnmjA3Y8z9K6o4amtzneKktTyO2/Z9+HUUeHst7f9dbgf8AtWnj4B+A8c2m1f8ArpOf/ale + stkdTv8A0pQQeFbb+Ga0VKHYxdeR5QvwF8BRzf8AHjkf9dZ/T/rpU1x8DPAEnypY8/8AXWf/AOOV6crF + XO3mnLtRDIRQ6Mew1WmzycfAHwITzp+COn76f/47QfgD4CHP2HBPX97P/wDHa9YGTsffkDOeKdkAO56H + GKXsole1keSt8APAfa2x/wBtJ/8A47Sp8APAP8Vrn/tpP/8AHa9YEin/AFR3fpSkSH7/AMv60/ZxH7aS + PJZvgJ4DkXbHBz/vz/8Axysq+/Zv8Ezf6uLa/rumP/tWvabiQRvhn8kfTdS7jGN7y+anrtxUujBjhWqP + U+afEH7LFmYmk0rUtuOi+QTnp3ab618sa5p0mlanLp8z5aLG449VB7E+tfqBGwhnWfychc7fm68YNfBn + 7UHheXw78SLt87be62eV0/hhiz3J6t3rixFBLY78PiHPRn3t+z74itvEfwx029tm3H97uGCMfvpB3A/u + 16CuCu5OM96+J/2BviJDY3lz4Lv32C42/Zjgn7ouJX6L7jqf8K+123DlRnHQZ615rR1oeKWkFLUobCii + imAUUUUAFFFFABRRRQAUUUUAFFFFAHyx8X7e68IftL6J4nthiK/+0ZHH/LOySPvnu3oK639sK1jbw/pW + oKM3Nn53k+294Q3t09aqftblU1vwPjjH9oYHr8sNaH7XBMXwxJTlB+n76GnGNyXKx7dZP5tsknrn+dTH + oDVLRTnTIT67v/QjV1Rjg0ihaKKKAK97NFbwPcTPsiXG44J747V4R+yNK+pS+KNddt3237JsbGPuech9 + PT0Fdt+0V4ttvB/wx1HU7gZf915a8/8APaJTyFP970rmf2NPD1/oHwdsG1Bdtxc+ZuGVP3bifHQkdCKA + Pb6KKKACiiigAooooAKKKKACg0ZpDQAGkxRzSYosHKhQKDSikJoFe24A0E0ClxmiwaPYQUuaXNJkUh6h + uozmgYoOPWgAxQaWg0wQmaCaBSk0rAFFFFMAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACi + iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAaeDQRmmEk0/tUSV3YUdz46/bBsnh8eQ3KDJud20 + /wBzbFCPxzXiniW3bzrpnfdN8mFxjsPw6V9gftOeCI/Ekek3sdz9ne187zDs3eZu8oD+IYxtr5g+J8H2 + XU7u+b7q7No/57/Kg/4Dt/WvncSuTE8p9Pl9VfV2mXPgH4rTStSGlXNvgz/6uff/AKjaJGPyhTu3Zx14 + r2i20bVLgmC2tt8Tfc+dRnuep9a8t8F/CK8uNJsvGuneIv8AhH7iTzMWf2IXX2bDNF98vh9wyenG7HbN + esWvgbS7iOOLxQ/9sagM+Ze4aDf6fu0bAwu1ePTPeufE4L2s+YtYpQOdbXNDtGaO/wBV+xh8bv8AR3kx + j6D3H51paVqcF43meGtJ/wCEktovv/6QbTGc4++M9Q3/AHz713XgX4cWulRTWdjYf2Wvy7pPOM2fvEcF + z6n863l8NxJGhiuPKWTPnx7Cd2Pu85/lU08sbdzKeYo8vt18aatBePLd/wDCPWvyYt/Lhuu/97g9Rn/g + XtUVj8NtA2E6/L/ajP8A6q42vD5mOvyo/GOBz1xXt6eH9KW8Fs1nhD/q18xvl4ye/Oaswebb2IjtzhYe + jcfNk+h6V20sFFS1OKeMmcbY6Drq/ahBZ+ZINn7rzUGPxJ/GtGHwos0Nsw1Lcq7/AJ/IxjPturrTBbLM + LZk8y3k9yNuBn6nms291ZLPSm1TUbnyvs/8Ay02btu5tvRRz1A6V1uMKbMPaVZkNrpVhZag15Hb7Lpcf + ud7Htj72cdDmtS3LhLdLc7oRu8t+nmevB5GDXAan8SbFZzDoUH9rWx+8N7QdgR99M9c/l71j+NfigmkW + c9pe/wDEl1NNv73/AI+MZKnoEK/dIH4+1ZvE0YXjuy1RnOzZ3+u6edY0K90+31DyJLjy91x5O7ydrAj5 + SRuzjHtS/C3xWPE1tdLnzGtdm+bpv3F8fLtGMbcV4fYeNvFWuJ/Y/iHTPt2mS/66Pz4o8Y+ZeUUN94L0 + PavTP2fdFuNFk1xpbnzvP+z7fkC42+ZnufWtKVRyrxcdialGNOhJy3PX6KKK9c84KKKKACiiigAooooA + SgCjFLSYIYdyksWyOwxSMSBnoO5rwT46/tG6N4Cu5NK06D7bqC4yu94+ojbvEw+6579q+adV+JPxS+MV + 9/Zdq+yCTpFi2OMAN1KIesWev/19YUHMiU7H2X48+MvgrwhERd6hmYf8s/Jm5+73EZHRga+fPiF+2DJN + CbbwxpH2dx/y1+07s8qejwf7wrn/AA1+y9d3Mn2jxBre3/Y+yg56jqk30r1bwd8EPBGgfvIrDfL3fzph + n73bzD2NdUMHLqc8sZBbHy3rPi34nfEyUebN9rU9ttsnp/sr/wA8/wBK6Hw7+zh4y1tVlv7j7Ih7bIX9 + fSUeg/OvsvTbS0sk229v5H/Ay3r6/WrMm0SbnbzfbGK644WC3OaWNl0PA/Dv7M3huyXdrb+a/wBJF9f7 + s3uK7rR/g54HsE+XTPNX/rvMvr/00969E6DcqZH1pOoz19q6FSicssRIxdO8J+G7D/j20zb/ANt5D6+r + e9X5NI0rvp27/tsw/rVkc/w5/GnqFH3hiq9nEzdeRSfStLY7ms8n/rq3+NV7rQNDul2z6dn/ALbP/Q1p + Abf4efrS/N3HFPkQvaHN3vgPwrdjEuneb/23lX/2b2rmtV+C3gi95Om+Uf8ArvM3p/009q9IHuMU7GOg + zRyIftTwXUv2ZPC8xP2O78r38uRvT1m+tcnN+y9rFpdmTTfE/lJ2/wBAQ9v9qb3NfUyr69KTC9CuR9az + dCBcMWz5NuPgv8UdDHnaTrXnMO32W2X2/ikPqahh1n9oLRW8k/vFHf8A0Ee/ofWvrkKvrml6fdGKl4aB + 0LGM+bdD+Lfxw0kb73RPtUfcfarNPX0Q+o/Kuotv2rL3T12674R8uQdT/aIP/oEPuK9pfBHzp+tQy21t + Mv7xMfiaxeDTKWKZ5P8A8NieGVfbLoO3/t7kP/tCr1r+1/4FkOJbTyj/ANdJj/7QrrdY8EeGdVf/AErT + sj/rtJ7ejD0rmLj4JeA7ibcNPwf+u0/p/wBdKyeCN1jEWov2svhy5wJsf8BuP/jNW0/ak+HjDIuP/HJ/ + /jNc/efALwDLwbHH/bWf/wCO1WX9nr4fL1s//Is//wAdqVgGS8YjqP8AhqT4al1D3+wN1Hk3Bz/5Bryr + 47fEy4+MmkxeEfBmmebuz583nhejRyL8siJ/zyYcH+me80T4IeBNLvZJPsW8tjCebOM8Hv5h9a9D0uxs + 7K0S3tItoTO1NxPUknkn3NawwiTuR9dMX4aaDN4X8D2Wms+1l8zzBgHP71mHc/3q6QsnmLj5llztH061 + G1zbW8vnCfYyfe+QnOeBXlfij45+G9CuRZWMX22QfeXdJH2BHJjPqfyrrvyLU43GVV3PWCGP70Dbnq2c + /pSxOHJQ8eg9a+e/+F5eLtSSSLR/BOMY+b+1Yv5NGPQ1WHxn+JMUas3hbyYVzuH9oW7Zz0/5Z561Ht4F + rDyasfRhC7cpJn/gNPYBT+9GxR1HWvDPB3x+07UbuPS/Eujf2ZdyZ3TfammzgMw+VIsdAo6969A8SfEv + wjobNJeah5cr/eHkynOMeiH1FNVo9yHh5HYqwFuZidxP4d8VFcXNtZWhuJJOvbB9cf1rxXU/2mvBMJ3W + P79x/D++XPTuYfrXj/xK8beO/ipNs0nSvs+mj/ll9ogfPC92VW+9GTUyrx7m9PDSPe9e+N3hGwuWt7O3 + +3Mccb5Y+wPeP3P5VWl+Jfi7VI0/4R7wblef+YnF/wCzoPRq4b4beB/i6ulGy0yx/sxT/wBNrWb+Jj/E + 31/Ourtv2eviTqy/8Tjxx9jJ7f2Vbyf+gyj0H51yTxTR2Rw6Oo0q5+JdxBE91f8AlDnP7m3bufSrlr/w + mLrN/wATfJG3H+jRVR0f9lvR4D/xNNe+3Ht/ojx+v92b6flXd+Hvgl4K0uLy2svPA6/vZl9f+mh9az+t + sHhkeb6l4g+JGkP5jQ/bIe6breP074J6n9Kl0/4uQRD/AIn2kf2Se7/aTP69kT6fn7V7XZeBvDlrH5cd + hgf9dpP/AIqtCHw/pcKbIbfYP99j/WhYuzF9XsrHAaNq2naxbLc21xvgb7vyMM4JB6gHqK4b9oDwLH45 + 8GNaxrnUrf8A1bZ6bpIyeNyr91K0/jt4D8FaNos2veZ/Zt0NuyTbNLn5o0PG4jofTvXlvhn4y+LtV0xN + L8M6P9tvBnbd/aYo8fMW+48YHQMOvbNbPFRkjOFGVN3Pke0udQ0PVBPBJ9nvIPuHarY3Lg9cjoa/T34A + fES0+IngyLUoDiRc7xz3kkUdVX+56V80+Hf2S/EuuX8mo+JdY8jz8bh9mjbO0Ff4Jx6LX1R8I/h3o/w3 + 8PJo2kHKc72+f5vndhwzNj75715stz0EduKWkFLUjYUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB85/He5 + TWfjP4Z0FxuFr9q/8eto39vT1rc/amtzffCXUQnRPK/WeL/CuD0bUT4m/a21KRRmCx8rH/A7A+wPVfev + VviRZtrPgnVtNX70nk4/CVW9vT1ruhT904alS0rHofh/a2kx+hz/AOhGtKuZ+GOoLqfg2yuh/F5n6SOP + QeldN1HFcUtJHZF3iNJPbkdh60Lk4OeB+tIWKkll+X+9mvn79pH9oO08DWLaT4fX7VrFzjyHyU8vaYmb + h4mU5V26njHrSKOG/aB1S5+KXxo0r4eaVJustO877YNoG7zLaOZPvBSOYz0Y+/pX1rYW0Fnapa28fkxR + 5wm4t1JPU+5rwb9j/wCG934T8OXHiLXl36vqe3JyBt8p5k/gcqflYdh+Jr38Z6Zye5oAfRRRQAUUUUAF + FFFABRRRQAlApaMigL3IyR0frTuBXjQ/af8AgbjC+Oc+/wDZN7/8ZroPCXxp+G/iyfyfD3iP7dJ6fYri + Psx/jjH91vypcyRcaUpbI9CZgh3MMj+Jv/rUijf3xjqK+cNY/aZ1qy1CeKy+GP220Tbsuf7eSPzMgZ+U + w5GCSPwzXM+L/j18SPEUUVvodj/wgcsWfMl8231L7RnaRw0Y2bQpHvv9qzdWn3OqGAxMton1qAw6jIbt + 6U4tnleTXwV4z8Q/FLxl4avPDfiX4i/b9MvNn2m1/sW2j3bHV1+dAGGGVTwR0xXK6d4B0CGzSG9svt0/ + O658149/JI+QNgYGB+Gah4imjshkuJnurH6PE8g54HXikLKOGG0np3r884vDGhw2lzaw6fmG52ecnnP+ + 82nK8k5GD6Vs+DfO8FSXF14Luv7KvZtu658sTYxuA+WXI6Mw/HPpULEUzSWRVo9T70bBBBGR35pQSVB+ + +e3avlf4f/GfxdosE6eLbr/hKJjt8qTy4rPZy2eI4yDkFRz/AHfc12ehftCxXeui21nw1/ZOmn7t/wDb + jPu+Uk/u1i3D5gF/HPatVWgzhq4CvT+ye6FWb7p2nseuKUPyFPBb7vvXm2qfHL4W6XYvfah4o8mCPG5v + sFy23JAHAjJPJFa/wz+KHgb4ktfnwVrf9qjTfL+1D7LND5Xmb9n+tRd2djdM4xz1FaJnE1Y7akNLmkNU + SLRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF + ABRRRQAUUUUAIKDS0jUm9LgY/iXT4NQs/KnbYf4GwTjkZ4B9q+DviJo8b+LdN0a8GUj83J/vZjVux4xx + 3r9A5lLJgfL/AEr4q/arsk8M/ES21TT49iPu8uPdnbiGFTyc5+8e1eZjaVqiqHfhavLofQ/hjwravo8E + EcuBHu3xbT82WJHO7jHWutgkiijjvIYsRvnJ3HjHHeuK+GXizTfEXgSw1AL5ayeZ5QyxziVwf4R/d71F + qXxNsvOgm8NWn9t+bu+0N5ht9mAAvDpzn5unp71lGpTirs1cKlTY9CghW2nNtIN6TfdGcbcDP41VW4lk + hE7j5rbtxzuOK8s8ZeM7iyulj1DXP+EZjbPy/ZBeb8Be4XjGR/317Vy8Hxa8Y6jFLbWlpslfGLzzIj9n + xz9wp8+4Ar7daiOLU3aJLwzj8TPbte8Q6V4euxfapeeRBc/d/dM27aAD90EjlhXJjxtc6herZaLof26x + hz5N59rEfm5GW+RlyuCCOeuM15no3hTxhqmuNq13rG+7k+8fs0Q6KV7MB0A7V6JbfDGXVrG3TWZvtccO + 7yBtCbcn5vuuPQdfSoksVL4DRRox+I5Dxx8ZVxBeaDq32K6bd5lp9n8zf90D53jwMDJ/HFcz4TvppXuI + x4V8iX5fIm/tANt67vl78cc17XpPwQ8A6bHKI9J+9jJ+0z9s/wDTQ+tdZaeCfDFrkQabj0/fycfm1a08 + FVn/ABCJYpQ/hngJ8F+L/EP2e01fxD52nR7s232OJevP31YN95Qf0rtvCPwdtrBYxFN5UC58p9pOPvZ4 + 8zPU969httMsbZkaGDa4zt+dj/M1bXa5Vj36e1dMMvhE56mMnI4/TfBNrazKy3Oc/wCwff8A2q6bS9OW + xD7Hzux29M+/vV3gH/doOByR0rshShEwlVlJajqKKK1MwooooAbinCkxR0qdQFopKKqzAaMdOwqC/dor + SWWL7/GPzqc8KaGUcjsaNmJNs/Pv4BeG9A8cfE3V9R8Rr5ht/I2JlxjdDIp5Qr/cWvrjTrS20+NEt/3d + sM4HJ9fXnqa+bP2mtDj+E3xStPGnhyby2u9/mW+3ONkEUQ+Zy/8Az0Y9P8a+iPCOvr4o8PQa2o/4+N25 + M9drso5wP7vpXrYXVHnYp2NIGRY/ll+zN/d27/1p0ZITc4w/97/61II9pzjJpwIJ5G4/XFd9jym7hnHD + yb/wxSAY5SPH40HnocUE8cjNOwrC/jR+NNx70Y96B2FBHakOaXA7Uc9qYWQ7caNxpOaOaLC5Rop4NNoo + sHKJhvWnBT60cetGB60iEhAAKUmmkUlOxqkKCueRS5XdwKAfm5o3fNwKGJsVWCR7VX9aTEYXLL+tO5He + mHk4Y8UrFJiYIOWH60r+WRxH+tOG4pndn8KCZgnyj+VLm5iWHzMPL35Zer4/pVTUr61tYDd3kvkqP4tp + buB0H4VPMu233NFvY/6sbsd+a83/AGkNVsLH4W6paTzeWLzytkO1j9yeIn5gPfPaspzcDenTcjiEn8Wf + H67uNP0KT+yNCg277zbFPu3DI+R/LcfPCR+Oeg59v8IeAvAPwm8MlmHlQp/rJ/35zl2x8u5z1kxXjXwC + 8I/EjxV4Sg8/Vf7D0mHd5KfZ7e48zdJJu5DBhhl7+voK9jsfgjoH2GW21+4/tdHxhtjwbcHPRJOe35e9 + eRWxDkevh6Sij0bQdRsNX0yK80598EmdrYYdGIPUA9Qav4IAfO4/lmvAdU+BGtaSqv4Q8TeQF/5YfYEb + HT+KSQ+rH/IrmrPQ/wBo3Rbn7NHqnnQj7rfZ9PXtk9yeprnTudKikel/tKfDjTfG3gS8acYvotnly5bj + MsWeA6jomK+W/wBlX4E6P8TtFv8AWtcvsJF5flw+U/dplPzLIv8AzzB6V6d4r0T9ofxL4YlsL232x3GN + x32BxtcEdCP7orsNCNj+zf8ABO2Gs/6VOu7evzJnNyccr5g6Tj8vyamw5UdL4Q+APgDw5MHt7DzHj6Hz + px13esp/vV6lbWcFqirbQ4C52puPfrya+cfAfij4xfEmxj8S6X/xKrQ58qP/AESfuyHlgp6oeo7+1b0u + g/HOOFHj1TzXgz5cf2eyX7x55zQ5MOVHvXzAY25A9+tBLFl2jKn+LPSvmfT/AI/eJ/CXieHw98TPDf2c + zbtt79ujbGELn5IIj/ejXr7+tfSVndQXtrHdW0vmRNna20jODg8H3FSBZooooAKKKKAM/VtIsNXtGtNQ + g86A/wAO9l7g9QQeoFO0vTbPTYEt7GHyYUz8u4t1JPUknqTVs5Iwe3elHX5R170AA56U7n1pOD0qN3jT + 75xQCFXDDPY0A4ALH5j3qtJqNpEN0k2Af9k/4VyvjT4haH4Xu9Mivp8QXvm4Ox/4AvopPVh6U+VsHodn + 1+8uB9aUnuORUFrcQ3EIltn3xn2I/nU23DjBwKlpiuyTFJQDRTVxiig0UUAFFFFFgAUUUUANG0c45pSc + DmkHU57VFNIkUJllPA//AFUIGj5W/Z+iQ/F7xddy/wCvP2Ld/wCA8g+nSvc7IoWjZx8r53D6V87fsrXM + 2p/EDxdqb/6p/sWDx2imX27j0r6DibdMZB1/hH4V7NGClC55FT4jm/2aNWMuiX2hzTZuNP8AL3Hb/wA9 + GlcdBjp7mvW7+9ttOtZru7fyoYtu6TBbqQBwOepFfMmifEXw98MfHHja+1MZE/2DA/ec7YiP4Ub/AJ6C + vmf42fGXxJ8TLtY7qTyrKPpDiNs5Ef8AEI1PWPNedUpvnsehRl7p7d+0L+1FJIH0HwQdo4+0XfX/AJ5u + vySw/wC+OD7+lcv+xl8KR4y12TxfrT77KyxsGMeZvWeM/dcEYKjsc/rXK/BX4F3vi1jfa632DTh0OBJn + /WD+GQN95R+deyab8BNQ8Kw/bvC3ir7Ndp91P7PV85yOskhHRmprDzY5V4I+u0XaNqrtX65p2SBjHNfL + lp8V/in4QlEfinw39tt/+e/262jz/wABjQnqyj8K9E8J/H3wdq4CXs39m3P/ADx2yzZ6/wAQiA6AH8ai + VCogjWgz18+rCl5PPUVn6RqllqMPm2MvmR/7pHr6j2NXw2V3ZwKxaaNE0x1HeiiluUNApRSigUARKT5e + 7dv98YzXgPjv483tp8b734P6bof2K7j8vy9b+1iTbm2W5P7ho8HglPv993tXv5+Uknj3rznx38D/AIYe + N9el17xR4X/tDUZ8eZP9vuYs7UVB8scir91FHTtQ2OO58+eLfGvxu0K/ns4/jD9taHbuH/CNWcfUAj+E + +v6VzeoX+oeMMH4pP/wmjWn/ACDuF0/7Nvx5v+oA37tsf3umzjqa9M8efCj44aNpJuPBnjz/AISG5T/V + WP8AZFna7MsoP7yRyDkFm5/u47ivn+P4yeFpInWT4b5L43n+25fmx0/5Z8VzzVZdT3sJPBbSjZl1/Bfh + tZHltdK8puMJ9okbb+JbmurvNTu71QZpOB/FgcfgB7V0t58Ndc0/Qp/7Pvf+Eh1m327LfyktftW5ufmL + 7U2qSffb6mvPNB1hNTtsyp5NxH9+HO7ZknHzYAOQM1xzjUe59HhZYZWjGJpc7FAOeu3jrSr8w3J8qr26 + 4pWjZGLb8Ovt0zXn3i3xrfae0unx6V/Z17HjEv2hZdmcHptwcg4/GsoQlJ2R21sTQoQv1O+2Er+9OE/i + GOtLlWk3Yyp6815V4V8XanqPiG1tdX8T/wBjWbb9939gW48n5CR8irlskAe2c9q9+074QXEmofZvE/in + +3NOT/j5s/7PFtvyCU+dH3DDbTx6YPWqrqjQV5nm/wBtxktInKSSIkMjF9hGO2a4TUfiXaQXhS1sftsK + 9JfOMe7gdimRzx+Fe63PwU+HFubhZdEwse35vtVx39vMrL8WftEeA9Kgig8J+FPt55y39ozx7OQekkRz + nLflU0XGUbwXN+B5+LzKrJpw0OV8AR+J/FNpaX6eGvs+k32/Zffbo2+4WB/d8N95dvb16V6BoHwA8Z6r + aJcS/Ej7HC2fK/4kkMm7kg/8tQRgjv61Q8G/HnxVfWSPBoH9m6Wc+XN9sil28tn5THuPzDH41SsfiF8V + IZfM1Hx3/aMP/LSP+ybaLPpyFz1x+VU/ax95aeRz82IxKUWeiWf7MPg+eyjm8TXv/CQauc/ab3ypbXz+ + cL+7Sbau1dq8dduepruvC3hD4ffCCxvn8L2v9hf2l5f2uTzJ7nzfLJ2cOz4x5jdMZ3c9OPnTxDqmpeJN + OvNL1if7ZbXOz7RBsWPdtIZfmUAjBUHg9q4nW73RvB+n7IbTb5v+ph8xz5uCN3zHO3G7PPWrpyr1FfYh + 5bBP95LQ96sviv4n03xhDf8A/Cdf8JToZ3b9O/smOzx+7wP3uwv987v+A46Gm+O/2lNcFhHpXh/wr9l1 + e9z9kl/tBH27CrPw8W0/LkckdeOa8Z+E9xrXxG1W6ttM0z+z9Ptdn27UPPSX7NuVzH+7baX3MhX5emcm + vTtI+CMg1RH8R+MP7f0s5+06f/Zv2b7R8p2fvEk3Ltba3HXbg9a6aXtb2kZ1aWCS9zcboXx48b+CNE1f + V/GF7/wmu/yfskHlQ6f5GGKv80cbbt29TyONnHU19F/BXxuPiR8N9K8aLpf9l/2j52bX7R53l+XNJF9/ + auc7M9BjOPevhj9obwevwn8Uabq3hK6/s+21bzfIsvL837L5SRq3zyM5fcZGbkDGcc16R+x1r+n+FPjV + r3gS0s90eu/Z/JbzGHk+RbTytwQd2dx6sMe/SuiLaPMrxpy1itj7RApCM08Gmsa03OTfRj6KB0ooAKKK + KACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigBFpDzS0Cp + tdMER/eAI4J6V578ZPBen+K/DMtjdweZbnHmDewz86EdGB6qK9E5zjsaR+Bj9PWoqQVWNi4SsfD9n8CL + CyXyb+X7a8f+sm2tHvzyPlEnGMgfhXb+DPgzZQWMdvI/nG1zg4K7dxY/89Oc19QPYW7S+YY9z9zk8/rV + hlVsKRn1rnWF/mN/rPL8J5ponwwsoIt1w2xj7E+vo9dnpnh/T7QSFY/M347sOmff3rawByRjFKc5x2rS + lho0ndGM6057sQKo6ClzjoKAfalyewrazRne4DiikzS1aB6CYpVFIppRSsCd0BNGaCKaTinZCSbH0UZo + pJjG/wAOAM0ijjAG39aXoMk5rA8Q+MfDegDOr6j9mH/XCR/T+6p9RVJNhc3mxnaGwfpQAcZzk+tfN3jX + 9rTwbpTvDo0H9qvxht8sH90/xQH1P5e9eVaj+0N8VvGUbx+HNI+zRcY/0m1f0/vxD+61aRpSkQ6iPuSW + SNIt7HCetYmpeL/Dmmx5vdQ8lf8ArjI3p6KfUV8OHwt8cvFcm/Vb3YD38qyP/oLD+6Kv6F+zNq9/dfaP + EGr7Qe/2ZD2I/gm9lrpjgpsl1ke7+Nf2ovAXh6cwwP8Ab5D0GJ4uynvCf736V5Frn7W3iHVrs2nhrw/t + U9P9MjPYH+OAejVv6H+zV4RsnD6jL9px22yp6+kvuK9Q8OeCfDehoE0yy2qP+msh9f7zH1NaxwJhLGRR + 8yeHPhn46+KfiBda8ZT7YTnJ2Qn+Ar/yzdT1jXt/WvrHQdKg0PTIdOtk2QQ7v3mSerFuhJPU1emxJ2+g + pQpbC4wB1Ga7qVLkR5tetzsTBalAI6ULkjilXOea2OWwlFFFMoMUozQRikLYpEahRSbqN1MNRaKKKC7h + RRRQFxp3CnRkmnE5FMGRUmSY4cimEYNPY4pCM0zZMbwenFOGO3FIeDiTg0rbVGZOBRchijI5Ix/e5pFB + A2jjPR//AK1MJO6KB/8ASAc/P9336Vi+MPFWjeFrKW71vUfKKY2Q+S7dSoPzKp/vA1nKaRpCDZuDczb0 + H7uszXde0LRYftGo3nle/lOe4H8IPqK8jPjH4j+P3Np4S8P/AGWyPSb7Zbvjv92RVPVGH4/StXwX+zE9 + 7fHVviDrH9p3R6RfZvJxwy9YZsdAh6dvrXNUxcI7HVDBtsoeKvjTPc3bab4F03+0NSONjeeIscBjxLHt + +7v79vpW18NvgDdapqqeIviTcfbJ+dtnsEePlZD88MoHQIenbHrXu/hTwnoHhmDytDsPssZ/h8537nuz + H+8fzrcXgYxgeledVxMp7HpUqCgiG2gighWK3GAmcDJ7n3qbGG3KvLdeaT0YnFOyfXr04rm5rnRawoXF + LmkoBoBjX4GQcba8w/aU8Fjxx8LtR0wNm4XyvL4/6bxMf4lHRPWvTyuTgdO9A3Eghsj0xRcLHy3+wn48 + bUfDE3gy8f8A06w27Tj++9xKei46Adz/AEr6jjKsqkNu64OMV8VLay/Dv9sqKz07mG7zk8fwadn+Lcer + mvtUc4JG4DoaLhY5z4ieDtI8b+GZ9E1ePfC+3DbnGMOr9FZT1Qd68X/ZQ1680PUL/wCF+sH/AE3S/L2d + Pm80TTn7oIGAR/Efw6V9FgMMc/Mepr5T+Ncg8CftUaB44DbY9Q+0+YcZ/wBXYxxD+9/f/uj+tAH1fyeo + oGT1FJ97lW/SkZ0Xhm/SgAPLY7+tKcjjqa5TxD8QPCegxv8Ab9T8orj5fIlb07hT6iuP0P4tzeKdRFl4 + Z0T7Sv8Az0+1BM8E9HQf3WoA9dpDS5ooA+Mv2ovjr468M+L7vwvYw/2dGuzDboZescUnQxn+8e/evm1v + EnjvxSxzf/bHXp+5gj/oP7v6V9Vf8FB/C1tN4d0/xKkWJ4PM807j/E9sg746egr0T4a22n/8IbaX9vF5 + bDf825j/AMtGHQ104ejzsxr11TR8a6Z4B+KGqwskUH7vjPz23v8A7Q9KfefBr4i6gyx3Fn5gh+5+8tx1 + 69JPavvFriRhh/mx97tQofC/NhV9q9B4NJHD9euz4d0rxN8WPhZO0TnbA3VP9FOeD3wx6yV7J4G/bEt5 + GK+JNI2Fur/aSf73ZIP92vctcsLHWrZrbVo/ORsc7mXoQf4SPQV4L8Qv2aNK1GZp/Dtx9mZscbGfoFH8 + cvs1c08HJHTTxake8+EPjr8PvEKbodX8tz2+zTn+96xj+7Xommatp+oxhrK584HodjL6+o9jX5k+Mfgp + 4y8Ot89p56Dv5kS/3f8Apof71cjb6r4k0CTbDcfZmHbZG/8AMH1rmlh5o6VNM/XMY7c0E+pxX5UWPxe+ + IFpIHTXc/wDbpB/8R713OhftQ/EfTIwv2zzf+2Vuvr/0xPrWXs2Ufo8CccCjnua+AbX9sLx1Gf8ASLTz + /wDtpCv8oK01/bL8ShedD5/6+4//AIxRyMD7rzjrRnPQ18KD9s3xL38PY/7fY/8A4xTW/bJ8Ut9zRcf9 + vUX/AMYp+zYI+6ifmABw3p61znxHv4tO8HahdStlU8vAweMyKPT3r4d1z9rTx7qUXkwxfZUPUboHz0Pe + Aen61yn9q/E/4pSDSJLnzrNvvLstlxj5h2U9Y/WtIUGyJyse9fsg2pt/AlzcMP8ASbjZk/7ssw+nSvdG + OyZ9vGzHH1rlPhP4ZTwX4Fg0O4+8m7n6yu/Yn+9611OxsiCbiNeo+vPavXpRdNWPEq1PePlr9oj4WeIf + EXxKmv8ATLbzYLvb8m+MbdkMQ6s4JyVNdj8LP2edI8PSHUvENx9sux91Njx7fvqeUlIPDL+Ve7AtGPnG + fQelALbxzuQfePSr9lG9y1iGlYj8tFiYKfJibHH3s1L8xlb935SNjCZ3Z/GmFsDrgjvigjB27sY74rS1 + jBu4/wAyYj5YvNX+5uC4/Gua8WeCPC3iSPGrab5j/wB/z5Bjp2Vh/dFdIQx6fNSA44RPxzU8txqfKeLX + 3wM+xyGfwpr39nHsn2TzfbrJJ7t+dYtx49+MHwryNTtf7XsezeZaQfoqsesg/L3r6FOSCoG4eucUzZ59 + qbdm3/7OMd81hUw8ZG1PENM8q8Dftb+F9Wu0tde07+y3bOD50k2MBj/BAPQfnX0ToWsabrdiLzTbnz4W + /j2MvcjowB6g182/Ev4E+GfFUL3mmp5WoyYy+ZG6bB0aQL91TXz7ZSfEr4I64fsTeXbp0OLc7sr77yOZ + T/np59TDNbHp0q6kj9JcnOM4Haj1yeO4r58+Af7SGjeOQml65H/ZmqHOwZebzf8AWMfuxKowqDvzmvoG + PJyxG1j1HXFcko2N4u4o+ZeeR60jN8wOOO5/u0SAtuydo4wa8X+PnxG1bSfFGg+AfCusf2Tq+t/aPM1P + 7Ms/9n+Skcw/dSIVl8xSy/eG3OeSMVJSR7OW+bB+Rj+NfDf7AOmXeoN40FrH5qR/YMnIHX7R6n2r1S78 + N+Jdd8N6hpPxM8T/APCaWcnleTD9gj0/ysPub5oCC2SIzyeNnua9e+GXw38CfDuO/PgvRv7N/tDy/tX+ + kzTeZ5e/Z/rXbGN7dMZzz2qVUjLQ3qUJ0oqXc+f/ABf+zv4AuvD09hpGm/2Dqjbdl9589z5fzqT+7aXa + crlfbdntXG2XhH47eAdRTw54aj/tnw5aZ+xnNlb+dvG9/vszrh3bqecccGvtu7tLe9jeO5TejYzyRj8v + pWVfeGLCSNUtf9EkGcN8z/oT/nNNx7GkMVOErx0aPir4ieBvBugaN4Z1bUT/AMKw1W8+17rT99rHnbGV + fvqxVcKQenPmY6rXHfDfU/Gnia6v4NPtv7dji8vzJPMhtvKyGI4IG7O0/Tb719seMPDEbWc9pqEHn2D7 + drbtu7BUngHI5xXiviHwH4B+HM9lrXh/Qv7Du08zdrn2ue5/szICj/R3ZhN5gcp0+XO7tWfs1a51rFyl + O99Dy34iHQNNu30fxWPKu4sbovnOMhWHMeR0KnrXDW2j+Bb3xcrWeo+Zp8mdlh5EwziPn94Tn7wLfpXv + PxA+E/xE1TwzcxHxt/wlcqbdmkf2XBZfaMuuf328bNoG/wB9uO9fM3xD1Tw5d3dvB4f8F/8ACLmLd9pX + +1JLzzshSvLj5cYPTru9qKau9RYjExb2Ow0vUPhxpl2t5YXXkXCZ2SeXcNsyCDwQQcgmt6Lxr4VeMGXU + fLx/D5Epz/47Wf8ACj4BeIPGWn3N/qeof2Bbnb9kfyY7n7Ty4fhZQU2lR167uOle3eDv2cfAVlpUFlrO + nf2/fJu8y886e235ZiPkWXAwCB/wHPeplBJ8zHh8XKGyueBQ/EO61G+Ww0jR/Onk6N9pC78DP8S4GADW + rqnwr+OWr2zQXfh/7QgxuX7ZZJjkHs49BX1T4J8I+GPCdk1l4ZsfslvNjevmyPuwWI5dierN+deUX/7Q + 9tN4tk0bwx4b/wCEktjjyLj7cbTzv3YZvleLK4O4cnnb70Ll3Nb16hz3wo/Zu2SaZrPj6ffGfN+2aFsx + n76p/pEUv+5JwP8AZPevS0k+E3wOj8tl/sGTW/vnN1c+d5PT+/tx5vtnd3xx5r4e+IXxX1z4wR+EofFn + /CMtPnZB/Z1reeXttzIfmKjOcZ68bvavcdL+HHg/RfEq67Z6V5Otc5uvtErZ+Qp9wuV+4SOnv1qnJLQ5 + pU5Qdnub+oXF5ptvJc2dj9ru4sbbTzQm7JAPznIHBJ/DFLbwTRX93IL/ADbTbPItvJH+j4HzfN1bceee + lTgFGMTHYg6d68J8d/tKeHtJuobbw5pn/CQmXdvl8+S18rAUjh4juzlh7bfepcJLWLuatKC5pHJ/toa7 + o99d6ToFtcb9V0/zvtEWxxs8wQOvJG05UZ4JrnP2S4L+2/at8LQamnl3g+1+auVOP9BmI+7x0x0rP/4R + DUfE3iA+JvGl99vu5/8Aj9h8lYvupsj+aJgOiqeB25719DfsV/C7TrrS7L4z6/df2rr+o+Z9hHltD/Z/ + ltPbSfcfZL5iY+8g2445Oa2UlI4KynD4up9T9aaKXpSA5qrHM11Q+iiigAooooAKKKKACiiigAooooAK + KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoooNK4 + WCig0U7C1IxuB+7keuadz0HNNZ9mSTnHWvPPGHxl8A+GCyX2r/6QuP3f2af/AGe4jI6MKIxvsJySPQyD + wC+GPTigkY46nvXy94i/akXUQbHwXon2+7f7jfavL6YJ4lhx0Dfl9KwZ5vjr47jK39z/AGRbt9wbLKfp + 16bT1Qfn7V0Rw02ZSrpH1HrXi/w/opK6pf8Ak4/6YyN6f3VPqK8b8a/tM+H7G4ay8M2P9tTj+HzXt+yn + q8OOhb8vevP9O/Zrs7m683xFqP2oDt5BTsR/BL/u/lXq3g7wF4X8LRCLSLXcR28yQf3v7zH+8a6YYKxz + zxZ5Zd6/8cfiCTAv/Ejsj1T/AEO49+uFPVP19qztO/Zniu7g3XiPWPMY9W+zEdiP4JfZa+j3mVsgNx6Y + piDCnDYH0rthh0kcssWefeFfgz4F8NZe0sfPk9fNmX19ZD/eNd3p9tBYwEWcPkn03Fu59fqalRMHdnaf + Sn7PUYPrWipJGDrtgXkb5Wm2j/dzUagMdhbzB9MU4HYMDrSgnGS3P0q1oZubYchOWz+FMYKUwVz+NAB9 + KUemaZDEPycLS/OvIpOlKjHvVBcM04c004NOAxSuK9xOPSjIoGT2pGJHagqOoZOOOo6D1owORnp29KVA + 8Y3OP3Y6t6/hSRBBFC7H5Bu+b0/CpvYqyQbfek2H1pdo9aOPWqTsZ2lfQM0tAFOAqdEPmEBIpce9MGG7 + 0Fc96d0wsmA2sNxNKWWRdoNIx8r5WX9aSRwiZVf1pNpDjTbEyWb5utOkaRBkmuG8W/FbwX4eBiv9W3T9 + ovs8wz93uEI6MDXEw/FPxx4unNr4D8O+WO0v22E54z0lQf3XH+RWbrRR0RoSPa7meKztTNct9lhH8eC/ + fHQc9T+tcDrPxe8G6ZMYbS5/tKcdRsmh7A90I6E/lVfTPgf4j8YBLr4iav5rrn9x9mjGeo+9DIP7qH/J + r1nwr8LPBPhtVOlaN5LjPzfapmz17M5/vGuGpjbHVDBXPCR4y+K/id5LDwr4c+w2rY2y/bbWTHc8SKD1 + Vh+NdX4L+AMdxqUOv+P7v+07tN26Ly/JxkMnWKXHTYenb6179GoSPah47U7vnOPXiuKWJcjtp0FAgsrW + G0gS2tU2QpnAyT1Oe/PU1P8Ae3E8g0DIPLZJ7YpedwJ4ArE3HUUUUAFFFFABRRRQAwhipA5J70biTkD5 + f50hzgBfvDtXH/Fvxrpvw/8AB934h1CTAt9nlJhud0iIeQrf3x1FAHyl8Zr6G8/a9sfsLcx+Zzg99PT1 + Hsa+3gy7lVuGPQV8Wfsf+CtS8Z+Pp/ilrsXyrt8j5l+b91Nbt9xhjG0dV/xr7Sj/ALqHCr+tDQCqMjg5 + z1NfJ3/BRFIV8P6BcxjE6facnnu9sPp0r6xKgucjOa+NP2xL6fx58XdF+Gumnzbi28/zU4X71vDOOWCj + oh6N/hSuAnw7+JPx/wDEWkwQeHtKzEd3ly/aLH5vmYnh0GPusK7r/hTHxA8YKLjxf4n+yySfeT7BA+zH + A5jkGc7V/P619CaJp0WkaXDYQfLFBu2nk/eYnuT3NXcqWB/75/rRcDxvwZ+zp4E0Gc3F1bf2jMOj+ZPF + 2YdBKR0P6V67Y2kNjAlvaxeXCucJuJ6nPU89TVkcj1zSYx0FHqJ+QAZ4NBPPHzEdulMfIXg5I6j1rwr4 + 7fG2LwpZtoHhiX+0fEUn+rG0xeXgxufvxlDlGbvxj1q40+bYTnZannf7YPjL/hNdbtPhl4bTzZvn+0vn + b/DDOvDqo6K3Rv8ACvbPD2mjRNDh0uF9yQ7ucYxli3cn19a8t+Anw0m8KxyeKPEbb9ZucbxgDO3zIx9x + yv3GXt+tewL8o3heF7Z6V7GGp8kdTycTV9oxMZINBVgSQaMKQHB4pD8oL54rrcrRu3Y5I0pXslcAyxpl + PnT06ZpdqhQ8n3u3tXNeNfHXhbwbLaR+JdR+wnUN/kL5EsnmeXt3copxjcvXHWvLtZ+NGt6p4fmttM0f + +wNVm24uPtKXPkYcH7rRhW3KCPbd7V52JzGhQjeUtT2cDkuLxG0bHum6TbuUecG+9/D9KydV8LaFqZIu + 7Pe7f9NXHp6Eegr5q8Q+J/Emsa1p2ty6xs1jSvN/s+6+zRnyPNUJJ8mArblGPmBx1GDX0R8LfFr+OPA+ + meJ307+y2vPN/wBF87ztuyV4/v7Vz9zPTvisMHmtLGvlidGZZLicDaUtjldV+BXgDUpNptPL/wC2k59P + +mg9Kwrj9mrwOZMRnA+k3/x2vbeRxnJ+lHzYxuwfpXqeyitzxFWkldnhyfsy+BV/5aY/Cb/49Sn9mXwG + 3WfH/AJ//j1e3YYdeaCf9jP40vYQ3QPFzbujxMfsxeCG5Ev/AI7N/wDHqVP2a/AcZxIM/wDf/wD+O17V + jdyFx+NKDjtmmqSH9akzgPDnwd8E6Gh+zWe7/tpMPX1kPrXbaTp1lpVsVsLbZ/wMnufUn1NWeV4C4H1o + UkcZzVqCM51pMcGdhh6aV2nK04ZI5oBzxVWOaUgLSnqf5UEetJgetL2p2E2Mop1FMuIpFJnFA4oPNIGD + KRGAX8v/AGcZpXzkbR5f+11ppHzYY4pcDPHFKwWSEZl3g7vLl7vjOfwqnrOlWWr6VJp95B5sD4z85GcM + D2IPUCrZPy7Cef7v/wBelBLHAO5h26UuU2hVcT4++OXwNuvDMd14l8L/ALzTotmU4HlZ8tOskhZsszdu + K9v/AGM/jC/i/TH8L61c7tUt8eUNmPM3NPIfuoFGFUdTXqMtol9E0U7ZEmN5x1x06fSvh/xNDc/Cf9oV + b3S/lS0z5R4Od9oAfvbv+eh615WKpHrYardH6SOPl+Y5I71i+NPC2g+NPDd74c8SWH23Tb3y/tVt5zx7 + 9jq6fMhDDDKp4I6c1qWtylzbpcR/dbOB684qY54zx7VwM6ktT411r9nz4ieA4bGy8Jt/wndqfM8yPFvp + v2PkEcySsZN5dv8Ad2e9W9Q+KjeEfF1x4Q8R2n/E4stvmyeZ/fjEg4RCv3WXoT+dfXgB3ZC4x0GetfJ/ + 7XHh7Wvif8QNK8MaXYfZ7fw1532q985G/wCPmKGRP3bFT1jK8FvU4rmqcnLzN2PUwmLq3VOKudX4R+Nt + xa+HDoVvN/wn3imDo+0aZ9u3Oz9DH5cWyP3+bZ6mu9+Ivj74bReEJovHV/5WlT7fNTybhs7ZFxzEu772 + zp/LNfMA8PeNfCEc2otqH9pXibfs0Hkww78/K/zZIGA2efSt3w58XpxcWug6tY+Xrw374vNBxwXHKps+ + 5g9f1rClieZb3PSq5XTcU9mfUlvceLNLv/Deiz2X/CRW939q/tbW/Nitfsewbof3AyZN5Oz5T8u3cetX + 9Y8T6DpfinRvDWoX/latrXn/ANm2/ku3neSgeX5gCq4Ug/MRntk184fA3xnqbXGmWWiX/wDZml6R5v8A + a3hjyVm2+aJDD/pbLuPzZl+XPXacV0XxP8d6PrclzonxO+Hvk+AU2/aNc/tl2252Ov8Ao8CiY5mEacH/ + AGuma6Y1ovRHi1cHUpt21R6z8RPAOieNtEu9H1WLfaX2z7UNzjfsZWT7rKRgoOhHvXyj4n/Y/wBX0KC6 + 1LRNQ/4Spotnk6Z5KWX2nJCt+9ac7NuS3PXbjvX0v4NudW8Z+IdO8f8Ahb4lfa/Adx5uzRv7DVPO2o0J + /fyYlXEys/3ecY6c1znxh+LPj34bxanq7/Cb+0PC+neVu1b/AISKCLf5mxR+52NIMSPs6HpnpWqsjlu+ + ZHzt+wjC8qeM3ji3lPsPO7HX7RXceLv2cfA+oacbTRLX/hHb7/n58ya67qfuNLjoCP8AgWe1eN/sq6N4 + t1M+I28MeM/+Eb8n7L5//Esiu/P3edt++Rt24bp13e1djo/jr4b+D9eEfwp8F/2xNcf66X+1LiDbtU7e + J1IPDSDj09xUyXU7MPCd7kfwIso7c6l4Z8YR/wBmy6F5W+Ld5vm+f5kg5j+7j5T1Oc9ua9nMOg+Lppb2 + 3XdOmN0uXGM8dDgdFxXg7y6v4m+MfiXxNa6b9n06L7L/AGhF56P5ebfZHycMcsuflHHevYPh1O8N3cRp + B5qy7fNk37fKwGxx/Fnpx0rzatVe1UNkfcZbhW8N7R7o8V+OOgC+8NrrBn+zR6fnyrfZv8zzHjU/NnjG + M8g5rP8AEi33iLwDpekaxF/wj1ronm77jct19s86UMPlXBj2FQOp3bu2Kh+K3iiCbxWdJi0T/iXRf660 + +1H99mNGX58blw3PB56VWPgfxR4jkZPEl1/ZqWuPIXy45fvfe5Rh/dXr61pGrGlC8noebj6Ma1d8iKWm + 6/4S8K6HcR6Xcf2hdy7fOXZLF9owx28sCF2hj064rM1a91z4gObXSNK8pbf/AFifaEbO7BHLbf7h6V7F + 4L/Z30+3tZJPEd358zY8tfLZfK5bP3JcNkbfpXpXhT4b6DoNr9jEXm24+4m5128knneSck1w1s7oU17m + py08BVq+5U0ieC2nw6+Bmm6tH/a/x1+0xpnfb/8ACJXqb8rx8yucYyDX3z4E8Y+HPHGgw654W1L+0LCX + dsm8iSLOHZD8siqfvIw6dq8Y1PwroGp6Lc6JeWP2qyn2ebbea6b9rBh8wYEYIB4PavN/FHwk+F1rIYo7 + T+yrofdPmXM+emf48dP5+1a0M3p1PiRx4rJ5x+F3Ps08gFhg+lKW4yDkV8fWHjb4ywaisk/xT+2wLn93 + /wAI/aR7uPULkYP8q9D8F/tFf8JH8cbL4ZHwd9k+0+Z/p/8Aae/Zttmn/wBX5Qznbt+93z7V6tKrCfws + 8mrh50/i0PoKiiitTAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooo + oAKKKKACiiigAooooAKKKKACiiigAooooAjXHIJyw6nFOXJGSfpVDWdVs9GsWvtRn8iFPvtsLdSAOFBP + UivlX4t/tRzvqD6F8P4/NumxiXcF7I/SaHHTeOv9KpR5thbH0l408c+G/CFs0uu6h9mH8P7mR88qP4VP + 94V81eP/ANrkyyrZ+CdM82Y5/fefjP3T92WDHTeP8iuD8K/B3xx8Q7+LW/Ht5kLncvlQ88FBzFIv9xO3 + 9a998HfCvwd4UhA0zSst3P2iXn7395z/AHjXZTwjkc1TEqJ4rbL8d/idKw1G/wDsdmeo8myk/wDQdp6x + j866rwj+zV4Vt0abxG39pTHrxLF/eH8EuOm38q943qn3Ys/8CpoCEfMdue3Wu6GGgjhniTF8M+F9F8Ox + eXpen+Tj7knnO2OueGJ/vGtwMSdqv5sY+4MbcetNBGPnOQO1BUEYYYUfw10cttjldZsN7E5K/rSlkPVP + 1pCcHr+lKWIGaqxm5XAEb84oJG/OKNx64o3HriizIauKKMZpM0o5pWYJBRRTsUy0xtFGaM0CAgGm7aBm + g5FMTACnjFNpOaEgpq6Aby5X1+7SiVEzI/3TTLgAQMvXON351leOZJrXw9qdwn3j5Xp/fUVEnY0oq8j5 + /wBS+IXxV8VeMLz/AIQTT/tVjb7PLHnWyY3RjP8ArVB6q/5fSvX/AIOePI/Gujyw3y+Xqtrj7TDnO3cz + lPmChfuqDx/Oux/Z2s7a3+E2jSQQ7PN8/e24nOJ5cda8b8RxJ4J/aeU2H7qHWc7l+9/qbIY5O49XPp+N + efHFXlY9CrQio6HtR3ISyjp3qRQo+VhwPumhgqXTRbvnixvXHqOOajwoZQz/ALw52rj+tehzJo8+0kx2 + XKn5sDtx0pxCkEEfL2pkgjThm3xt1OMYxXL678QPCmiuP7S1L7Nu6jyJXxjH91T6ik5xGqd2dWdwXJG3 + 9ajmeOGHc5/zmvA9b+Ol9rNwLT4eaF/aMjdJvtaxYwAfuzRj0cfh9Kv+Hfgp8R/HM4vviHq3kWr9Ifs1 + u2MAj70MinqiH/JrCeLhA66eEcje8bfGnwpoC/ZdPm/te+b7kO2WD+6T8xjI6En8PeuW0rwd8YfilN9r + 16T+x9Gb7kW20n9QeUZW+9GD+PoK9+8A/CPwb4Ltwuj6bsf+958p7t2Zz/eNd6se1dpOT6VwVMY3sdlP + DJHjHgz9m/4c6DKJ7jTftlyOj+fcR/3h0EpHQ/pXr1hp9pp9uLezTyoh0XJPcnqT7mk1fU7LSbU3N/cf + Z4R1bYW7gdgT1IryfxV+0l8MtBYxvrPnsOo+zXC+n/TI+tcbnKR1KKieyDGSDzjvSjkZ7V8n+J/2utPm + lNv4U0r7ZIfu/wCkNH6H/lpB/vflVK28R/tHfEMpHp1n/ZNq2cN5mnz/AKEKeqH8/ak9S7WPrLUNQstM + gM97L5MQ77S3cDsD6iqui+I9H1nJ02888D/pm6+v94D0NeF+D/2c/OuRfeOta/tiUdE+y+R2YdYpf9z8 + vc17v4e0PS9AsRaaVa/Z4R0XzGbuT1Yk9SaEkhO7NSiiigAooooAKKKKAG8dBS8dKCTtzTJHSNNzmgBZ + H2KWJ+Wvir4j6jN+0F8ZLXwtpTf8SSx3+YcD+O3WQfeEbffhPc/l19b/AGx/iHc+FPhqYdIn2XN/9yTY + Dt8uaAnhlIPDH0pn7FHgax8PfC621wHffalv81/mG3y550HG4jo3YCk4sD23w9pdlomkQadp0flWkG7Y + u4t95ix5JJ6k1oLkKAw+ppRnkk7genakGSeOQetFgPLP2ifivZfDXwk1x5v/ABNLjH2SPaedskQfnYy/ + dfPP4V5N+xx4C1rUdfuPil4sl8zVJdvknagzhJ7dv9W237oXqv8AjXR6f8LF+I/xKu/GnjS28y2i2fZr + XzMdYTE/zxOp6op5Ht6mvoW2hWCLylHyL0/nRYCeiiiiwDQRuYAc96axAAfOFHWqWs6rYaPaG61G48mA + dW2M2OQOwJ6kV8ufFf45634u1FvC/wAJ18++GP8AScouOEk+5cRgdFkHX39K0p0nVZE5qG52v7Q3xwh8 + L250Dwnc+d4kl+7FsK7MGNz80kZQ5jZj1/Wue/Z4+HEnhyxHifX13a3d/wCuOcbNpkjX7jlTlGHQfrVn + 4QfCXTvCsS6pdL9r1t/9fJlkzjeq8Byv3G7Dt616i4UtjdkL91cdfXmvVo4f2e55mIxPNsCI0IEhO8r3 + 6ZpFTkrjC/xL/KnyLuOHXOeoz1rx79rLxBo2mfCm+0G+uPLvtY8v7DDsc+d5M8LyfMAQuAQfmIz2zW1W + oqUG+pjRi69WNJHP/FX46Xlul7YeEbPbu8v7JrHmg5+4X/cSR/7yc/Udq8W8TeMNf8b/AGdvE979vSy3 + fYn8pIvK348zhFXOdi9c4xxTZANR0R3VvKYYwmM/xev4Vz8ZkSZ/lwxxkZ6cV8biMfiK6absj9MwOVYb + D8qtdnQ2E5aYCR9ip1GM9Qa14ZwpaPP1NcxZyqGYFd+7qc46VqQTtsDAfMeteFNS5z6jCuklpobXmAqv + mLuVc/Jn+tdb8L/GkfhTxEJdR1H7DoVx/wAfw8jzPM2o/l9FLjDsPu9c88V59qGr6ZYG3R73y7lt32iH + ymPk9NvzYw2Qc8dKpjUbadTZTR+Vf/8APtuLY7/fAx05/SurL4VMPV9oloc2a+wxlB0m9T7qx1Lrj+6c + 0qgfLs+YnPHpXin7N/jrSTplj4FmX7LeR+Z9jXLP9qy0sr8hcJtHq3OePSvafvcZxv6N9K/QsJiI4mlc + /G8xwUsHXcJbCg4pOtOPNJiuqKSiedzdIijPrTx9ajwPWlx71RNpIXNGBTcUmDRYPeHUtJRTJa1Ciiig + pxCiiigYUUUUAIBTl600GnL1oJVxgyecU4HPGKAWHGKdtbrSNFYjAEkgjQ4A6ivkT9tW2ePxnpdzs8mS + fzstnd92OAV9d7TIwhLbWH3uPxFfK/7VsUesfE3QdEsmzcRfaN/HrDCw64HQHvXJibcp24Ru59m/Dov/ + AMIdYb+v7z/0Y1dAoAXjtVTSLUWenQ2vZN36kn+tXOBwO9eG3qexsjyiy8Z6nc/F3xl4cXVPLstA+w4j + +zqdnn2+/rtycnnqfwrzLw/45t9V+I2qxaxe+Rquq+T9gtPKLeZ5UJ8z51UKMKAfmxnoMmu4/aJ+Atl8 + WZ9LvE1/+wLuy83zJPsZufO3iIDjzEC4EeO+d3tXgHxc8D6J8RfDkHi7wDq2/RrHdhfs7jG90j6ysrfe + R+x/LFXVoQxGH5Opthq7pVFM7n4VeLZvG/h4za2v7u8/1cOR/A7g/Mqr/cBp/if4Q+Edf1N7+Sy8q6fH + 2hvNlPmYUBeN4AwB2rx/wdd3/gnwtbWPiq1/siG33eXN5iz/AGnc7E/LHuKbS6j3z7V7j4X8Y6Ve6Ktx + Nf8AnYzsbyWXf8xB4C8YxXxuPo18HV/dqyPs8LiKeJprn3PCviX4O1mDWIprrT/7XgXObXzkg+zfKo++ + Gy+48+2Md62PAPxL8T3LRX2lXX2+G2z5/h/y44927cF/0lkyMHMnHptr6MUsgGTtI+73xXDeNvhvo2vW + 6r9i3+X9yHzXG7JXPzbxjGM1eEzpfDVXzHUwduZweh598FPEnw7uvGEd9ovh3/hGvFiZ+xH7bPd7sxyC + T7w8sfu89f73HIrsPG+j/FbxVo934H17x7/b+h6vs+06h/ZFrbfYfKZZU/doQ8u91C8MNu3JyDivKZfh + r4r0u1/sRh/blrZ/63TP3Vtu3neP3u8kcndwe2O9cb4gOteAruePT7n+w7652+fpmxLjytoG396dwOQ5 + bjpnHaveo14VNYs8WrTpxjeUdT2nTPgLppsdP0XVNW/tJLXzPIf7O0WzcSzcLJznjqe1cR4++IPgjTbS + yt/DDf2858zzHxNbfZ+VI4dTv3Zb6bfevNv+Fa+NAh8zS8A9/tEP/wAXXoVr4Q0XwHpVxrzp/a97bbfK + ly8GNzbDxuYdHxyO3vUzqUqbSnK7ZdNVZv8AdQsjr/gto+pR/DXVPF+oXHnnxD5PlJsVf+PeZ4zyD9Oo + H49a7mC0ih8FyXscm9rvGWwRnZJiuC+HGoLN8KvD1i8W02P2na27rvnY+n+Nb/xciv8AXvCEOmzJnV23 + eYuV+T94jDkYU5Uev61zVpx5rI+vwtOpSw0db3ucj4d0201HVpvHKfvZbzb9l6jyNimJ+/zbgO68dvWv + WfBXh63uLOW5uIf3b4+z/MecFg3Q/wA6+YfD3xLj0PQLPRzofnfZ9+6b7Xt37nLD5dhxjOOtdJo+tfEj + 4jLKvw/0HyvsmPtv+l27b9+fL/1wXGNj9Px7VzV8BWxE9XaJ4MszpUW5JWkfROreLLCzQSWQ/tCRPvxZ + aLGcY5K+5P4VzPin4if2fYrfmT+zbePO98edjJAHG3PU/rXgV98FPjJql7Jd3vhrzppcbj9utF3YGO0g + AwAK7yx/ZUuJod9342+zy/xJ/ZQbbzxyJueMU6eQ0ou7dziqZzOesYFDXf2hrqO8uLS0tP7Tsvl8ufzB + Du4BPymLI5yPwryxvil4wKbF1XaP4f8AR4jj1/gr6f8ACf7N/gOw0qKz160/t2+53XfmT22/5ifuJLgY + BA/4DnvXz4us/Djw98eV1nSNL/tTwTa/6q18+4h83da7T87AyjErE8jnGOlerRwdClsjyq+NxE3ueueF + /wBmb4p+PPtZ+JWqf8Iw9ns+xDyLa8+078+Z/qZl2bdife67uOhr3v4N/s5+A/h3HpWoyWv9reJtP87O + seZPB5vmb1/1HmsgxG+zvnGeprodd+Nvw00W0e61PxH5EAx832K4buB0WMnqRXWeCfFGheM/DVn4k8OX + 327S7vf9nuPKePfsdkb5XAYYZWHI7V1Ra2RxVJSesjdoooqjIKKKKACiiigAooooAKKKKACiiigAoooo + AKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigCP1GcKegryP4y/HTwp8Po + 3s5Lr7RqnH+j+XKuPuH73lsv3XzSftLfEyTwP4cgstJh83V9Q3fZfm27fLeIv95GU/K5649ua4H4bfBb + RfDjNqXihPt2uy9Xy8ezG5eiSFDlGX8vWuijQ5zCrW5Dy+40b4rfHTUJbjX5vsGjPjC7bWXoMdUKN96I + fn6dfY/hp8IfCfghfPit83g6T75f9ofd3sOj4r0OJH2YHyKv8PXr705flbKjBHevWhhqcNjzKuJlIXMn + l7RNuI/2cUhbzE8xmw49qWNSo/ut+dCna24tn8K6Euxy80mISw+7QNx+9S8jpSEk9aoi3MLQc02nA0BZ + ITFLSA0ooAQHHFLnHNB5oHPFArDaKUjFOXFZydnoXBXtcaqNtJ28n7xzSqp5YJn8eteL/HPxd468Ja7a + f2ZqP2Kyu9/2f9xDJu2LHu+8pIwWPX1rgI/iz8QCu9dfyB3+xwcf+OV51bMqcG4Pc9ShlVWpFOLPqcFS + vC5/2s/0p2VAwTn3r5cT4r/EB1GNe2/7P2SA/rsq1H8UPHZkAfXdvt9kgP8A7JXKs3itGi/7Gmup9MbQ + RzHuJ6c0q87ieAMZX1r5ug+JvjdmAbWt5Xt9lhGf/HKtaP8AEjxomuaZeXur/bbG3837VZfZoY/tm5SE + /eBMx7DhuPvYwaf9t0FuV/ZFXpqfQhOCBu/eduOtHy79jcqv8P8A9evLI/jJuXB8P5Run+mf/a63fDHx + M0S/0WC41U/2Pfnd5tj88/lfMQP3iphsgBuOmcdq6aGaYas7RlqctTK8RT96UdDtggbdF64xWN4+Zn8G + X5fv5eP+/i1uL/rC3dazfEsP2zw9cxN935P/AEMH+ld0tVuckEucm/ZkdX+B3h7L7y32nnGM4uZa8w/a + 6sLfR/GHhjxg3Esf2vcOe8cMfqex9P8AGvR/2Xp1b4VafbI2Rb+bzj+9PKan/aG8J3ninwUbfS4d9xH9 + wbgOskZP3mA6Ka8ObVOoe1Fc1MTU9TsreB724+SIY3tye4A4A9a8D8XftPabZrLb6RbfaUOPLl8xk/uk + 8ND7kV6j8d4Eg8NaF4du48HVPtHmjd18p43HT8OhH4187/FbSbrWLC40r+zNptdv2NvPB8vcUZ+4znHc + 8dq2li3Eqhg41FqdLD4A/aA+IA83U5fsNk3fbYydP91lPVB+ddx4Q/ZJ0KK4afxPdf2mzY+Xy3h7MOqT + /wC7+Vdp+yf8R4/FHwwg/tK4/wBKs93nNs/vzzbeFQDoo6Vq+Nf2hPhv4XQ/aNb86cf8s/stwv8Ad7iI + jo1YvEORfsIo7/wp4Q8PeFrYwaBp/wBkjPbzpH7k/wAbH+8fzqTxN4q0Pw1AJta1D7Mnr5Lv3A/hU/3h + XxJ4x/ab+IXjS7bTPBVr/ZqNj935kE3ZW6ywj+63fv8ASqWjfAD4w+P8XPiWT7LG3/LTFo/qOiSr/cX8 + 6jcex7L48/a88Jaa7QeHYP7UPaTfLD/dPR4D6t+VeOaz+018VfEjtBoB+xx9v+PaT0P8cI/un869x+Hf + 7J3grRZBPr3/ABNZh2/fQ/3h/BMR0I/L3r3Hw74R8P6DEItK0z7Kg7efI/r/AHmPqfzqRn59wfDr45fE + efzrux+3Mf4vNso+2OgZf7g/KvW/hn+x+vled42m/eH/AJY7en3x96Kf/cP+TX2OBg8/nTQuGzt/HNFk + O7OA8BfCHwJ4LijTRdJ8qZM/vPtE567uzOR0Y16BggHLcn2pCOeD17Uq4HygYpaiuOxRS0mKNAuNALc9 + KXnHTJpMD7x5qrqWoWlhH5l3L5a/7pPp6D3FNK+wm0i3kYzjikBGMivNPFHxw+Hvh9D9v1za/wD16Tn0 + 9Iz/AHhXkHjb9qG61Nfs3w8077VL/wA9fOCf3T92aEdg4/D6VqqM3sQ6iR9S3VxDawNNcN5ca4ycE98d + q8x8X/H/AOGnhqTyr3Xcyjqv2S4/2e4iP94V8yr4R+N/xQujL4p1Dy7U9R5Nme3/AEzZT1jWvRPA/wCz + /wCE/D8qz6pD9tfnPzSx/wB4fwyn1H5V0U8G3uYTxSijel+Pet+L82/w90P7QP8An4+1ouO/3Zox/dcf + 5FVm8KfEDxLqMd14u8Q7YRn9z9igOOMfejYHqqn/ACa9JsrK1sk+z28fkx9juLe/f61ZIZx5U0fmoOnO + K644NI4Z41tnzD+2F4Xj0nwjpj6bb4tYvN859/rJDt4Yk9SelfRn7LN9DffBjRvJfzDH5+4YI63M3qPa + qvi3w/aeJ/DM+k3fFvd7cJzxtcN1BB6qO9fO/gjxD8RvgJq9xoV1af2hoJ27B5lvFj5Wc9BI/wB+b17e + nTCvQdtDro4hS3Puc5z14pu8AZBya+ZYv2w/CJB8/SfJfsv2iVv1EFee+NP2wdcuJjH4a077InZvOR/7 + vZ4P97864HRmdvNE+2ZpooI2llfCDHODXG678VvA2icX+t+Ww/h+yzH07hD6ivz01X4gfFP4hXTLPqP2 + 0n+DyLaPsO4Vf7n6V0ng79nbxlr5F1qf/EuB7/uZf7w/hlHoPzranh5SJlUS6n1Rrv7U3wt05SI9W+0S + dk+z3KenfyfevJPGP7Y115pXw7pO1OzfaQf7vZ4P96tLwv8As1eErFfM1eb7VL6bZU9f7svuPyrrtH+B + /wAO9Lm+1SaL53t9qnXsR/z0PrXXHB9zmli4xPnyys/id8dtYF/ql3u0t+svl2w2YXHRdjHLQgf55+p/ + hv4F0XwLoqWGjw4lGd8+5/n+ZiPlZmxgORXQaZZ2umxC2s4dqjr8x9z3z6mrJ8uPIC7nPTnFdcKCgcNb + Ec4g4Y+R8q/xd/508FCRxuPamgnLZ5/vUgLBhxt/u1ucXMP3E/ug2W7HHWvlv9vMBH8DuF8pW/tDac5/ + 59819QthFU42k53DrivnL9unw5rGoeHtC120s/O0/RvtH2+481F8nznt0j+UnLZYEfKDjviuXFK9Jnbg + JpVUzwrwdfzTTEXUm1pek2AduA38IH4VrtpWnzeILOy1nVf7KspN/m3n2dpvJwmR8inLZOBx0zntXB6F + etG8SAYC5wM9etdx4hK3dosuOEzg+uSP8K+HxFNwq+R+p4KaqUtDJvtQtp1tryDSf7Ps33+YftJl83HA + 6jK4P55ptrft9q1LTpn+W88rfHj/AFmwbhzjjHWsR7OJ7kJ53l7/ALvyk9BzU9tp0ksNxDIf+Pbbtb+7 + u5PGea6lCmo3J9pVU+U0bDUXimllu7bEkePtE+/rnO35QPoOKk0u9n/tG8v7Vt8vybGwB2IPB9qjQ3Ml + 3LeXE/2iWfG59gTO0Y6CpVbzEVV6d/euapOKWh004TXvPc2/D+qz+GdVg1XQG+y6hBuxcYD7tylfuuCB + 8rEdO9fVXwD8Yz+KvBUEWr6v/aOv2e7+0T9mEXlb5JPK+6oQ5RR93OMc818h4YZDvtQ/fbGc+nFb/wAP + tYg8MeONL8TSab9sex87EPnmPG+Jo/vYP97PQ9K7Msx06NRKWzPEznL4Yik5dUfbpIwSBwOtLsIOCeR1 + oZssD2H3v6UjDaoDnkfe/pX2cW/vPzeUXGTQtFFFakBRRRQAHPrQQfWkKDPWgqMdaBWQAe9KD7UgUDvT + tx9KB6ifhRRuo3UgE6UdaOtHSmFwGPpShsGlfb/HxTdyj7nNTe4tBVUMcfwr29KGXk9s9DTcHepj/wBc + M7W9PXjp0p7fu2aSfiM482T+XA/pUttFRi2RzERQvLKvy8ZbP4dK+bPgnp0vxX/aTu/HjQbtGtNm75wM + b7OSEd1b78f939Oa1vjZ4+vvEupn4beBx59/P/x9z/Ku3asc6fLKoB+VXHDfXsK+gvgR8PLb4deDYdHi + G6Y7vNbnn95Iw43MOj9jXmYqrfQ9XC0+U9ALfOFbjPQetGcZ3cDtRjLdeW6GvNP2oPC+ueMvgZ4j8N+G + LH7bqt59l8iDzUj37LmJ2+ZyFGFVjye3rXnHo3I/EHxx+Hem+Ip/C0GufafEce3On/ZLhN+UEn+sMZQY + Q7uvt1r45+HMx+FfgHw14xv7n+1dF8cfav7R0/Z5P2f7FK0cX7wbmfc8gb5QuMYORzXuugNc/HT4Bx2t + zef2Xe6lnzLjyhN5Pl3RI+UbA2RFjtjP58/+xbqXg/wP428T+HLbxb/bFjrv2T+wL3+zpYPt/kRzvcfu + yGMWwvt+cjdjK5zXRZ07TTFpbQzPE+gL5N54d1+02CTZ50fmZzjDryh+h4NcBqNr4r8LakzaHYfafDFn + jZaedEnl7wM/O2ZDmRie/p0rth4kl06/PgHxNaf2Z4pg66b5gm8ncPO/1qDy23RlW+9xnHXil0DUbLWN + Ki1LTpfNt5c7X2ld+GKnggEYIPavQq4XD4yn76KpYqpSehN8OPiNLqenQy2zYgj3b7XA+XJbHzlATkjP + 6V2Gv/EKysPDMmpzS/Zngx5sm0v5W5wo4285zjgcV80/ES78A+JNUbU7bxD9hu2x9of7HPJ5/wAqqvBw + F2hew5zUF58QE1n4danpOrNt1UeV5L4z9q/fbm4VQqbVA6nn618ZVyOkqt1sfQ0M55qbVTc+qv2YG1/x + t4OfXvFviH+0rVseXZfYki8jEkqH95HtLbiit04xiuo+IltKIdY0ew0fyFXyMTfaQ32jlW+6fubeR15r + y39k/wCJnhHwx8FLmXV9X8ltE2fax9mlb7P51zNs+6h3btw6Zx3xWv8As3yh/gf4ejaTcx+07htxt/0m + XH1rkzPD1KMJThptYnATeIrrmEi8NzwWMt9qN39gEWMP5Ylxk46Kfp+deM/GTxD/AGVokVjbJ5wv87Zc + 7fK8tkPQg5znHbFd1+1vrMdh4YsNOYbjf+Z5fb/VvCx7e/tXBfCbXNO1P9rLS9W09vMsn87Y2GGcWDqe + CAeoPanleFdSMa02d2PxsKP7uCsztfhzp9tb/BzwnqkK7Lq6+2buSc7bhlHU46e1ZDXPxE1/4gaonhuy + /ty303yftEPmwW+PMi+X5nweoY8Z6e9Vbf4xeGdK8Qan4SsW8/wPL5X9lzYkX7FhPMl+UxmWTfMSPmPy + 9uK7j4La34s0z4KeEh4Z8Df8JMbr7Z53/E2is/J23L7fvg7s5bp02+9eqsMvauT2NJZ1/s0aUHqjX+Dn + w00rQdTsNa1DwT/wj/iOy8zj+1Wuvvq69nKfcI7H73qK9c+RQpJ8qJui9cVwV9YfEDxRpNjdRat/wgV2 + nmfbdP8As0Gp7cthP3mQDwu7j+/g9K3H8SaJoOoyafq2r41Rseefsz/NxuX7oKj5SOldF4xXvHiNOo7p + XOhlbZvkmTzlOO+3+VY/i7Tte1Owlt9A8Sf2Bcrjdc/YUudvKkfK5AOQCP8AgXtXK+K/iXJpdzF/wj/h + 7+3beTd5tz9t+zfZ8AY+V0JbcSRx02+9eDePL+HU9f0y1+KPj3+2YtL83bZf2QbfHmopP7yADuI279Mc + ZNEZ322HODitT6H8f2WgW/w3uofiZf8A27Svk+03fkvHn98pT5IPm+95Y49M+tfPeoJ8J73xBe23gj4T + f8JHpdp5eL//AISK6tPP3oD/AKuX5l2sHX3257iqGpfE7wx4dtIrPwvB/aVumcDfJFtyQf8AlohJyWb8 + qxbhfif460g3OnWOdFuPuJ5tt/C2Dy21vvof/wBVEJTfxI56roLZ3PTPC58R2Vo1zqmr/brx8eWn2aOP + ycEg8rw2QR9MVyx+LFv8OLHUB8Mr37FqOqeX9qm8oybfKPyfLOjKfleQcY6854r0ay/YmuprRLi7+I32 + ads74/7ED7ecDkXGDxX1j4H8JeH/AARoEHh/wxYf2fpdtu8qDzpJdm52c/M7MxyzseT3pQw7pz573IrY + xVIcijY5D9mDxTrfjL4G+HfEnie++26refavPn8pI9+y5lRflRQowqqOAOnrXpYJyCRgt15pwG3ovH1o + A+fOevX3rpOG4op1JilNABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUA + FFFFABRRRQAUUUUAFFFFAAaOlFIaAPgH42+M11P9ppY7+b/Q9N+6dvXzLKPPRQeoHrX1/eKUv5t/7sHb + x17V4L+1D+z/AKtrWuv4s8HR7mbHmQZUY+WKMfNJKPRj0/pXiPh34x+PfAUp0vV4/MUdYt0Ax1bqsbf3 + wetd2HqKJzV6XMj7jaQM/wA3yn86cWdjtKcf3s14B4R/aZ8L3mLXWY/sxP8AFukf+8eiw+wr1zwz4y8O + eIIgum3/AJyn/pjIvr/eUf3TXpxlBnlzws0b5OOMfrSHd1604JO3JTzP9rIFD5AwW8w/3cYrVSSOd05I + QEGkY46ik2lzmOnt5hGCKCVFoaMdS2fwp4IPQ4pBjpGufxpw3ryyfrQTK7G0UpFAFO4rMZTgaVhTRTHZ + i/KwAVtxHQYxSqcjKjA9fSmygbm3JuBxu5xj0rj/AIlQ6p4g1HR/h9Yr9hPiHz/P1jKyf2f9nCzL+4OP + N8zaU4Ybc556VzV6qpwcjqw9Pn5Ys+evjBfWGr/EnVL+wm8y3n8nadrDO2FAeoB6g1f+EGlfC7XNP8ca + r8U7DdpPhf7BtuPOuRs+1F1PywEMcsIx0b8Bmuc8S6haa1rtxqWn6N/YtpPt8uy+1G42bVCn94QCckFv + xx2r2n4b+C9c+K/7J/hTRT4w/smyuftn29P7NSf7Ztv2aPncpj2GP+E8556V8Yq9NuVeZ9ZKk6NKMIsp + fB74V/Crxl4m8V+GvEvwQ/4RTVfDf2P7TD/wlVze7vtCO6/MjhRhVU8E/e7EU/xz8O/hhf8AxE0v4Y+A + /Gf/AAhfiS1877Rp/wDZdzqH2ndCs6/vJW2JtjDtw3O/HUAV1v7W/hnQtN+CHxH8RWFh5Op65/Zf9pT+ + c7ef5FzCkXyklV2qSPlAz3zXE6V8FNS+IGu/Dvxb8SPDX9o6lqH9p/8ACb3H25YvM8tTHYfLDIqjCog/ + cgZx8/et1UhUaqX0Oa7T0IdG+AN3qPiXWvDOn/GrztT0HyP7Rg/4RYL5HnoXi+Yy7W3KCflJx3xSeHPD + nw08Q+Mbbwjo/wATvtGr3O7ybT+wbhd+2MyN87EKMKpPJ9utehfEHwjo3wT+DXi7XPhFpv8AwjurzfYv + 9I897rdi4VPu3DOowssg6fxeoGPbXjVnR9vzJnaM9M15+JqUqlnujpp4istnY+QfGPh1vDHim/0OS++3 + fZfLxP5Xl7tyK/3cnH3sde1Yup3lnpGnTahqM/2ezt9vnPsLbNxAXhck5JHSs/wXpbaN4ZttPkk8+SDd + g4253Ozep9a734dySWvi2wliT7U37zamdmf3bd/89K87DunDFpQZ61Tmlh3zs93w/wAgxjrk5qtqPzaT + dupwDs4/4EKwvD2oanP458T6VeXHm21j9k+zx7FXyt8RZuQMtk46k4rp8puBZdsb9Fz6e9fplJqdNK58 + BWiqVRs87/Zl8b6DZeFLjT7y98iSHbhfKduskp7L7ivbD4n0HiT7dnH/AEyf/CvIp/hj4MuXmH9leVO+ + 3P8ApEzdP+B46VnT/CHw3duCbjy2fouyQ9P+B1xVMG5SudNHFqKsWfjTcWfiz4r+FfDNu2ZbX7Zl8H5N + 0CSdDjOQvrXvFzbRTq0cq5DY+XJ5r5i+CHhCz0H9ofXGjmw8P2f+E85tJP8AaPrX1INxx2rhqJKVj0YS + bjdH5q+E/hd4p8R/ETWfDPhJ/Kjt/I+0yYiP3oTIvEjj+63Q17/8O/2PtBsFaTxVff2m3GI/KeHH3u8c + /up/Cul/Zs8J6jZfEnxf4kuk8uK++xeXyp+5DKh6N7+gr6GYZPrUaFanKeDvh54U8KR40TTfs3/beV/7 + 395j/eNdYfu9M0fMevy/rS4yMNzRcBOCMClxgYozx0pkrpEu5zQtRbCgk/xZH0oOM15L4/8Aj/8AD3wl + K1tc6p5l32j+zzj+6eoiI6NmvJdV/an1bUy0Hhfw3ufs/wBuUZ6HpJCPRq0VGTJ9qkfWgAznoawvEXi7 + QtAj36ne+T7eU7en91T6ivkK4uv2gfiDc7luvsMJ6jy7GTt/wE9U/WnWX7N2o6jMbjxPr3nzHqPsir7f + wS46Ba3hhJPczlXSPYtf/am+GumzmGO+89x/0yuF7A/88T61yj/tP3uuzmHwp4c+0kfxfbQnbPSSEejV + c8IfAvwN4dk8yaw+0S/3vOmX+928w/3q9G0/T7DT4/K0+z2D/rqx9fU+5rqjgV1OWWMSPIdY1n9oPxZb + k2UP9mWZ6/NYzdx6gHqp/OuXPwJ8da7mTXPE+8Hqv2CEfqsg9BX0d5KbsbcAds04rzlDnHaulYaC2OeW + JZ414b/Zz8E6bh9WT7Qw6NmZfX+7KfUV6hovh7RdGthb6fpv2e3HSXz3buT0JJ6kitbahPHzfpSrkN6C + tFTsc8qzYIzbMS/f/u0ijbzH9/8Au0Ddu55/2aUgk8f981aSRnKTY0Ak4dty/TFSKCOEbav0zTcADAGB + SEjGMZFDTZKQoAEZIHmZ6LnGKZNFFMqxTf6RHzu6rjuOlOdMA7lyf4efzpylmKnOH5yKVky4ycTjdV+G + 3gzVZTNeaRvf1+0zD0HZx6Cktfhn4JggIbQt49Ptcw7/AO/XYBWY8tj2xSqCh6cUcsTVVZMzdL0HSdKh + 26ZYfYfbzmk7n+8T6n860W3NDtdsH1x70KCB0xSp7HFNRUdiHUfcX73Wgnb0pi0/p1qmQ5yGgnZtM2f+ + A08AqmUGfxpmARgilQAcBf1pWZN7DkHGaTPNBOOKQjBzT2DRiqN25V4Hc/3f8ay/E/h/SfFfh+50LXLL + 7Zp15s8+HzWj37HDr8ykMMMoPB7VpsTkEHc3ftiiQKdzEbmOMnpWclfcqlLllc/NTxDoGs+EdeuvD/iC + x+y6nb7N0fmo/l7kDjlCVOVZT1712Hg6U39tdxz852fjy3p9K9b/AG1fh+yiz+IGi6Nktv8A7cvvtP8A + 1wht/wB2zfVfkX3b1rwXwXffZbpgo647+ze1fJ5lQ5bn6DkeL5kkWL+1RGHmrlV6nP3On55qO2ijRz5U + flgds5xXTeMbb5beSH51bdjtj7vrWDZI1xcxxKdgfPvnAryYv3bH0U4r2tyWPcy4EfA+7833f8c0+WR7 + SFLgJvM2fLXON+Dg/TGar2t7dWzW81mPJnTdmXht+eOh4GBkVTBiih3L8hX7/U/SqjTTWpm6z5fMsC9u + zcieMeQi9E4bbxjr3q/pupPdXU4vJt0zbfKXbjPBz0GOmOtRaFbLcXEU1xb+bbHO1N+3dwR1HIwa14Ej + FskMA3W8Odi/U5PXnrTlJXsYu3xSPbf2b/HWpwatbeC7mD7XZy7vsbb1T7NhZZX4C5fcfU8Y49K+hQFX + CZ5bp+FfJHwe8JeN9e1DTPEfhO5/sjT/AN7nXtkM/wBm4dP+PeRgX3MGj6cZ3dq+ufm+44wH6p9Pevrc + slUdL3z4LOlSdS1MbRRRXrnhBS5o20baQhAG65oYMe9Ii5HWkQfN1oEk0SElu9MJYdqU72HC4/GmEhPv + t+lBakGSRk8CnAAjJ6UgDeXuU7h/dxill228Pm3K/ZU9c7++O3+ealzSKUbiBir7Vb8MU7pyy8fWuS1r + 4i+D9FnY3+obnP8A0xlHYeiH1FchqP7Qvw70yNlik+0THttuF9P+mRHQ1m6qRqqVz1rqNp6DtSqjkZRN + w9M4r531X9piyu5ha6Dov2lm6f6UU9D/ABxexq/pg+PHjdcW0f8AZ9i3Rd1lL6+u09U/WonioRWg1hXc + 9e8XeKtE8J6fLda3N5Spjy12ud2SoPKqcfeFeQz6x47+MhNh4JtP7K0Vf9ZceZBPnuPllCN9+Jx+PoBn + 0PwP+z1p9vfLqHi/Uf7bmGfk8lrfsw6xy46bfy9zXuGnWVvY2q2tuuyGLO1Mk4ySTyeeprgq4uT2O6lh + 11OE+D/wn8P/AA609I9OTz705828zIu/l8fIXYDAcjj616KN+5vm4ONvHT1oKgcEYHak+YsGxg+nrXBK + TbO2MLElIaWkNBR8N+PrjUP2Z/jFqkuheFfL8D6/5X2O1/tBT9p8i3UP87+ZKm2acnnGegyOmnH4a8A/ + A+efwl8QT/a3g34g7ftc37+D7B9gHmJ8sJeWXfLKg4Kbcc7gTj6f+Jfw28F/EO3tbfxlo/8AaSWe/wAj + /SZodm8qW/1brnOxevp9a+eNBXwl+0l8PLf+1zjxHpO7LYl/0LzZj/d8tJN6QD12+x69NJxlBwC6R6b8 + efhPa6wbvx14T8Of2l43h2eSn20xfac+XE3MjiJNsQbqvOPXmvl7RfH17eaXFrOqaD/Z+iPndqP2sS7M + MV/1SruOXAXp3z0r7q8AeK9I8beD7HxPoU/naZeeZ5L7HXdskaNuHVWGGQ9QK+OfjtKmj/GjXfAmsabv + 8Kaj9n+xfv8AHleXbRyyfdzIcyEdWGO3HFPDVXD4mDR414z0LSPBXj2G71DQP7S8Py7vLsvtjRediJQf + 3gLOuHcN74x0r6o+Efwp+HXi7wTfyaFDs8N6l5fmjdcH7R5cj4++4dNsinpjP0ryqPRdL120XSvFMv8A + bd7p2ftD7Wt9vmHcvEZAPAXoT096oeFdS+NngVF8L+DvE3keHrb/AFE/2CzbO7MjfLIGf77sOT+mKnF4 + SVT3qewlUV7nofxU/ZY8PtZ2d34Yv/7Ihi3/AG5/Jkn8zJQR8PNkYO77vrz0rlPhD4pl8C6pdfDrUl8y + 9s9nkpkD7VvV5m5UME2hx1Y5/StpvEnxp1OzMF58VeG+8v8Awj9n65HQD0FcNf8Aw58QTeKZvElx4287 + VTt33H9lRrn5Ag+UPt+7x0/WuBZfWqU3Cpqd2HxPsaiqRNf9p1Y/FHhfTtZWf7L/AGT5uYNm/f5rxL97 + jGNueh69qzYfgVouv6/OkHib+wbeTb9nt/sD3PRPm+YyA9Rnn+97VneMLbxhpWnrc319/wAJLo3P2638 + qK028qI/mGWOXIPy/wB3ng1xOkfFXxLa6nFcapN/aNuM+Zb7Y4vM+UgfMqZGDg++KzWEr0IKC2R1zxVC + rUcprc998N/CD4PaPpEOneJI/wC2NTi3edfbruDzcsWX92jlRhSq8dcZ7103hLxZBonh6102x8L/ANix + Wu/yrL7ebjytzlm/eFTuzktz0zjtXy7q/wAV/E01/NJpdx/Ztq+3Fvsjm24A/iZMnnJ/GuuuvAPifxXY + 2ieKfEX2W6t9+LX7FG/kbj/fjYBtwVT7ZxVwoV6rtclYujQi+RHVfEv40eHtf0PU9Oe5/tSyuPK2aVsk + h3bWVj++8sEcjf8AhiuW8A+LtQ1K3/s/wp4E86Gz+9F/a6rt3lmHMignJDHvWzpPws8J2+nQwX9n9uuB + u8yfzZY93JI+UPgcYH4VoWPw98LQQvFHpeEmx5qfaJfmweOd3GPauyOXXXvnL/aE7aOxzlp4O+IHibS7 + u28Xax/ZdvFs8tPs0E3nZbJ5jYFcFV69c/WuI8feBtG8K29zDL4w+16pFt8mx/s1083JUt+83FVwrbue + uMV6vefDrwMZ0eTRtztncftUw3cf73GK05Dofg7SZrkj7FpzbfM5eTPzYHq33m/Wrjg3F76HO6kqr95n + hPgXwhpHidUgPib7JfyZzbfYHfGNx+/uA6Ln8cVreF/G3if4eapHo+r2v2rT7PPnab5kaZ3qWX96qsfv + OG4PbFdrrfxY8PWds0mm/wDE0kf/AJZ/vIc4I7snufyrlZPGvg7xTqsK+I/DP2NPm/037fLJ5Py/880U + bs7VX2zmtZ06fJa+pCly6o+kvAHxLjuba4l8I6750R2+efsm3dy23/WJxzu6f4V9E+AdTutX8J2V/fze + ZcSeZvO0DOJGA6ADoBXwP+ykkjx+Jwj7P+PTc2M4/wBdX0z4S8b6toJt4IpvtWnW+7FntVN27J+/tLDD + HP4YritZWkdMoKcOZH0Ac7uvTtSgEZ5zntXMeD/GOleIYVijb7PernzLbDN5fLY+faAchc/pXShmyQRk + /wAJz1pnM42JaKKKCQooooGFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR + QAUUUUAFFFFABRRRQAUUUUrAMDAkLuyfpXJ+Mvh94X8WW7xavpvnMcc+fIvdf7rD+6K60HPXketHsV+X + 1zVJ2A+YPEn7Ifhe8Jl0y/8As7/9cZG9P70/sa4O/wD2Q/Emny+fofiDL+n2OP2H8U/ua+2sd84pfcVa + qyRNrnxUnws+PnhhPtFpqXnqv/LPyLFc9upc/wB40rfGb4h+F0+z+IfDexh/y0+3QHPfokZ/vLX2oTnr + Ve6srS54mi3f8CI/lWqxc0ZyoJnx3p37UmhTJm/0TYfX7U59fSH6VfT9p7wc/Elh8vp50v8A8Zr6UvPh + 94Ru233Gk+Yf+viUfyb2qlffCrwNex7J9D4/6+5v6P7VpHGsz+rQPF9A/aD8BavMIZLjyz3+Sc9if+eQ + 9K9G8O65pGtIr6TdefGf4fLdfXuwHoa4bxl+yV4L1V3m0q5/sxuNo2TTY+6D96ceh/OvmX4o/C/x18HJ + luPtPm2Rztu/LhGOEH3N7nrLj9fp0RxdzKeEifc7E7cqufx600njhdp7c5ryT9nD4kv470KOxvznVLfO + 0Y67mlJ6Iq/dQV67kt5YU7d2cd67adTmPMq03FiDNB5pwYEUg5Na7kN6CMBhUU5Izg/3f8c14h+0R4y8 + NXE114Shh+2avabPP+aSP7DvEci9V2yb19D8uPWvcRn7ytnb046V8h+LLmS+nh1C98W/2zrFzu+32n9n + fZ/se0AR/OPlk3qAfl+7jB5NeFnVZ06HLF7ns5RQjOehhRxMsZCN8w68dK/QkseTngfpX59qpZQuMZ+6 + PWuuT4nfGsgM/wATcZ+6f7Cs+f8Axyvg3SVaDU52Ppq9Gb1SPWf2kvHPxIt/GnhbwZ8INS/4n959s+12 + /kW/zbI4pU+a4XYPk8w8Ee/OBXq2h+MyW8O6V4w0z/hGvE2vfafsmjef9rx5GWf9/Guz/V7X5I+9gZIN + fNvivxp4d8Z+HNNtfiL4I/4TPUtK83yLn+1ZLDf5rgt8kKhRhVQc5+5njJosfiXpcvw+T4bTfA/yPCS5 + 3Wf/AAlbN/y18/74TzP9Zz9726cV34dU6mEUW9VucTw1ZS1ifRvxg8aD4efDfVPGB0r+1Tp3k4tftHk+ + Z5kyR/f2tjG/PQ5xj3rF/aX0Ya/8ENf0f7R9nWf7N+82bsbbmJumR6Y61DeeM/hbrHiDR/EOo3vmarof + n/YJfKuR5Hnpsk4ChW3KAPmBx2wa5bx38Z/hd408L3vhzw54o+26teeX5cX2C5j3bHVzy8YUfKrHqOnr + XBRUvZqVDeN7hGLU9TyuNWV5MHY4xgdc16r8CnKWev2qwf8AHz9myd/+r2mQ/jmvL4U3usm3JOd/PT0r + 174UaHqul+FbjxHpUX9r3Wobfsmmblg8ny3dH/esSGyCW5AxjA608ovLFOTPWx7/ANmUTqtH1ay1mxTU + 9Mn8+1nz5Umwrv2kqeGAIwQeoq5gB9oGQ/Uf3cfzrkfg4dvw40vLdPOw+Ov75+1dZjKqdvy84OetfqNL + 4Uj89xDtVH4UPvP+tHeo7cFniV/vrnn607af4u/ekzj5u3rWttDBv3jyjwRrEdj+1TqlrNHs+2+TtOc4 + 2WLE9B7+1fTQxwRyP5V8r/tA/DjU/Emow+JfDN35d/BuyfLU/eEafxuB0Vu1ee+Gvj58TfBl2IPE9j9u + 3dP3tvHjgn+CM/3l/KvJrYduVz2aFdKJ90okYbKingjnHNfLNp+1lJLyPBvmf7P9p4/Xyafqfxh+KHi6 + 2/4pLw1/ZP8AtfbrafuO0kY/ut+ftXMqEmbSrxR9O3E6QRGWVsIOrYrz/wAVfGjwF4dJS91fMg6r9mn9 + u4jP94V4W/wu+IPi3jxJ4r2Q94/7PgOfxRweqrXU+DPgp4U8OybjD5svd90q5+928w/3q6qeBvuYSxaR + oXHx/vNbAt/C3h/zZD0l+2AY79JIh6MK5rW/BXxE8d3Al8SeIPs8J6RfY4GxwB1RlPVFNevwQ29uNsCe + SfqW/nTnLfxvn8K6qeEhE5KmLkzzfwj8FvBehTG5ltvtkw6Pvmj7MOnmEdD+legWljZ20X7u08qMdP3h + b+tWtzYw3P8As00Kg4J2D+71rpUIo5XXmxSzPHtPFLiQR7Vkx/wGmqCTzSjGfu5/Gmk0ZqpOQR+XEu1F + /WhSAd239aDxxmkI9T+lVdFO4p2jtQQp7UnWlzjtSu+hDSQoCAbj92kGR04/v/0pq/MxLfdFJLMkMJmu + eEH3/wA8DpSfmXFc2wqgscqNjt1HXd/hTsMzv8mF479KueG5NNvGlDDzAMbT8wx1z/KtzwT4X0Hwd4as + vDfhqw+waVZeZ5Fv5zybN7s7fM5LHLMx5J61w4jGewlZRO6hg/arVnK43ZOfl7cdaeVbbvA6/dH867u6 + i8yIhl3Y6c4zXB65oFxps1s+jxbI/m84bgew2/eJ9T0pRxyavYtYDle4dGyxxjqvr+NIQF4HzP2FeO/D + l9c+H3jKD4f3Nl53g+63f2JP5qL9m2xtNP8AKN0j7pXx87cduOK9jZjhRuyozhsf0rspVI1FeJx4mg6L + sICN1LwR0pwByeKaSQDxWiepjbS4mKMULzS1ZKY3mnKcdaUHNBFIGFFGaM0WHYTGKM4ooosFhoyOlPUg + 9aQYFIRu6VLVwTsjmvil4QHjvwFqfg8339nre+VuufK83ytkqSfc3Luzsx1GM59q/OrSJ3STcpyR1Hp1 + r9OyduBH80v93pn8fpXxt+2f4QTQvH9t4q/tDzk8R7v9H8nb9n+zxQR/e3HfuznoMe9eXmNL2kOY97J8 + U6dVHMWMx1OxuTOMPHs2n1yeemPSudlVo5CEffs6cY61f8Ha1JJdyxsNsS48pOu3hs845yfWp/EVkYpB + IX3RjpJjG7p27V8e4uFTlZ+kUpQrUebqZEdtF5IEeofvv+WieSf3fpz0ORWtaQwx3KXEMf2aVc7GyXxk + YPWs5po44Zbh3wiY81sdMnA/yK9g+Enwq1TWfFEdp4l8NfadKmz/AKN9uVPtWEc/eRwybWCn3+laRp1K + jXLscFTE0qMXzbo5LwbYadrnjDTtD1fVf7Mgv/NxdfZ2m2eXGz/cUgnJAHUdc19KeDfgB4Wbw2mieN9E + /tLVkz52ofapYfOy7Ov7uKXauF2LwecZ65rsfhv8M9A8B2K2NuN/9n5+y3mXG3zCxf5C7Z+/jnPqK2vi + V8R/CPw+jhbxfrH9jrf7vsrfZpZ92zbv4jRsffXrjrx0NelSw8Yq8tz5/E42pXl7mxoS6dbadpMi28ew + tjncT/F7n3rMf5XyVxn7qZ/rXiHwz+NvjL4v+PNPbRvDv9ieG9J8z+3V+2xXHnebE/2flo0dcSRn7mc5 + +bAHPt5LI4V+cdT/AHf8a+jwiShc+ZxztLzE/wBo0fMV3fw0LhCd/Smqr+WX/grs3PNFDHOMYA7UAqTg + 9D2pdq7lRm5bPOKcgl3OkSZ24+bIpNpFqEmIVDjcBkinxETvk/KR+NeWfEz40+G/BMzWsx+23Jxtj/eR + 4+4TyI2HR8/hXjWo/Fn4mfEFWsfDGk/ZnP3ZftFu+OhPDov9xhWM6sYHTTwrkfTPiPxFoejZbV7zysdv + LdvT+6D6ivMvEv7RvgzSH8qwX7Sw95k9D3iPqa43wn+yv4s8SXAu/GGsfZAOsf2aJ88EdY5h/dU/j9a+ + gPAP7PngLwmgeGx+0zd382dM/e7GUjo1cVTGu+h3wwiS1PnN/jT8R/F5MfhfQdqnv9stz/6HGP7rVo6f + 8G/jN46i83xBrP2KE/w/ZbST17pIp6oPzr7PsdPs7IFbWLy/bcT/ADPvVnqMdDXLLEzZtGhBHy/o37IH + hpVEmp6t9ob0+zyL6/3Z/pXe+Hf2cvhrpBBfSfPb1+0XC+v/AE1PrXsRUEZ707vzWftpmns4HOaJ4L8M + 6Mc6Zpnkn/rvI3r/AHmPqa6MAKMY4pRkDnmiobuXYWiiipaAKKKKYBRRRQBG/KZJxXyb+0p4S1f4efGG + L9oHTbD+29Oiz/a1t5yW/wBjzbxWcPzMzNJvZyflj+XHPXNfWRGGQ7sAZ4x1rF8Z+FdC8ZeGLvwx4lsf + tukXez7Rb+a8e/a6yL8yMGGGVTwe3pQp+zd0Kx8/6f4AX4ZfGz/hZNrrn2Twe3/IYtfsm/7Ni2MEPzlm + kfdLJn5F4zg8c19Mgbhs3Zx14r5V+B3iTR/jh8Km8K+Nbn+2NWhx/acflvBvzPJJFzEEUYWJT8p7c8k5 + +jfh7b61aeELK28QeI/+Ek1JPM83U/sSWn2jMjEfuk+VdqkLx12571tWjZcyGj4S+L3hyfwLqU+l2fjP + 7drHgnb5s/8AZYj837aEYfKSyrhXI4LZx2NJpfxW8NS6JHe3tx9lved9jskfb8xA/eBMHjDfjivtDxP8 + H/h34n1DXL/W/Dv2u4177P8A2m3224Tz/IAEXCuAu0KPu4zjnNfDHwJ8IeBG8Nal4l+KdnjTZ/K/smTz + Zv3u15Em4gbcMN5f3hz271pSxDghKClsR3fxqt4rlkttB+0xLja/2spu49DHxioR8bFUsh8L8nH/AC// + AP2uu9YfsmbcgZI99U4rT8Ma9+zF4S8RW2t+Hrr7PqFtv8i58vUX8vchVvlcEHKsw5HHWj67O5oqUkcH + 4d+J+r67dSQ6X4P+0zJj/mJIm3IJ/iQA8A1t+IvC37QF3K0+neF/7MtuMxfb7GbHQdSc9QT+NfSHhHxP + 4f8AFMDXGgXv22FcY/dPHt5YfxgE8qfypq6l4hF3Ai6H5kJ3ebP9rjHlccfLjLZPHHSsJ4mU9zVUUfHm + r/BD40arqMt5qHhnzbqfHmN9us13bQAOBIAOAOldvpH7K1ze2EVxe+Nfscsm7Mf9liTGCR1E3sD+NfVD + K7fu/vEfeXpn05pGIZd5bbb/AEzt/qcmslI1VFdj5jH7JoLKo8f7g3T/AIk+M/8Akamp+ycGUM3j7bnr + /wASfOP/ACNX08ATjI3Ede2aFBG3aNoXPvjNW+fuV7Gn2PCvBf7NHhLR0uIvEsv/AAkby7fIfbLaeVjd + u4SU7s5Xr02+9eoeC/h/4P8ABkkp8K6L9g+0Y8w/apZPM27sf6xjjG5vzrpTkl1jHytjH4Up+d8A7gei + 9MfjTjKZSoxI51t5YTBcR70H3hkjHOR0r89fjB4Tj8DfEXU/Csd79rSx8rE3lbN++FJPu7mxjfjqelfo + Jqup2WjWcuoapc/Zra3x5suwvt3EKOFBJ5IHFfI8GmWXxN8X6z481XRfs+mXnkfZIPtRfdsj8p/mUqw+ + aMHlfp60qSlUq8ttDnxHLFWiJpmjarqf7Q99qlkmbew8v7VNlfk8y0Kp8pIJyQRwD717eqkg7lww+6M/ + nXi37Nt5ea1qninVdRm+0Xr/AGTc20LnCyqPu4HQDtXtWFGdseB/Eufy5qKqcp8sS6D5IajUYAhvM2iP + /ZztzXsvwg8N65of9oNqtv8AZFm8vEW9H34391JxjIP407wd4A0Wfw3aSa5pO6/O/wA7/SHH8bbfutjp + jpXoIXgEjLetKMbGM53JRSGlpDVmItFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFF + FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRSYCZo60Yo6UlcYYoozRmqFZiZpc0mKMUXQaDcgt8pz + jqKpaxpNhqtg9lqEPnWz4ym5l6EHqCD1Aq6FwT83zHvigBhwBgetAWR8A67p1x8F/wBoVodNOdNmx5Y4 + 5xaAn7xdvvSn/PT68AhJba2I+NvB/Gvmf9ruWPVfjto9hAuZofP3jPrawkdcDoK+k7VES3RIRhhnv7+9 + exgneJ5mMSRIDmlHFJmk6mu5bnmt3Ketapp+j6TNqWqzeTBDt8y42s23LBR8qgk5JAr5I1nV9Q1zV7nV + NYn+0X1xt82fYqeZtUKPlUADAAHA5r6H+Ml5e6bp9nfy6X/a3hhd/wDa1h9oEH2jJQQ/vOZE2yHd8vXG + Dwa+cI0IY4O1f4B6+tfHcQVk5KKZ9bklBRjzWFhUA/LHgfWrsSKB8smD9KigQDgDircSKOh5r49uSbXc + +ohByVh6ZTaQfuZ7etXIYhHvAb7uMcetQxJyMr9eauwrgDK/Xmuec5RXKmaqk1IWJCFRl6c/NVyJQ+7d + 045qOIYAI6+tWoY/nyevrWUvdfMaqCT2JI0BYMx3D16Zr134o+DLKw+AmteHb+b7daR+R5p2mPzM3SOO + jZGCR0POK8qgjLfMBvb16Zr0/wCNvhSw8R+KfB1k7eXdRfbvJnwx8nKRlvl3ANkLjnpX0GRQTbkeFm8u + Vxj6nS+GtD07wzo1tomiWX2S0tN/kW/ms+N7Fm+ZiT1Ynk96vDK5BbPqcdKdgBRtG3HakbGVAbC/w8V+ + lU+iPga3vSbHEYppOBQaDWpz2FQ5JAf5W9vSoJra3mkEU1v5ij/bIqQNuIXOQKeBklg2B9KlxRpGTRXS + 1tgcw2v/AALzDVhVwMbfN9s4oI3Hk5NLjjB4pWiTzSFZneP5x5o9fu1F8m3CHJ9KeVz7GlIJ4PNPlC7E + bdj942/8MUkZUH5Vx+NIPl7YpevfNPlSJvIdS7RSE0c0tCtRuQpx0z0FLxz8u3HU5oOTk7c+pz97/ChS + enXHQf3f8aWvUWqYjKxHzLgeufu/40o3Lltm09+c5rG8c62/hrwxe67Fp/26S28vbB53l+ZudUPzYOMb + s9OcVJ4b0rVdY1tPE1j4z+3eGZ8/ZtO/sxY9m1TG370kOcyAtyO2OlZTrwhozqp0JzLuj6jp+qa3qWk2 + k2bvSvK+2xbW/c+apZOSAGyBngnHfFb6aIdxjN1uK9R5eOv406NmU+X5ecdPm6VctJuWC8lsYNcs8RP7 + LOinh4x+Mrf8I9uIEd75Weo8rP8AWvL7jwrop8WanrdxpX9meJp/K+1N9oeb7se1OjbP9X6DvzzXtkMp + 8stjLr973qvrGlJqcaMJfJuIc+RNt3bM43fLkA5AxzXJLEVXuzrVKm/hPJLW4udMnAQeZt6PwM8enPrX + deFPErPAttMnI756ck9hXN6/YQvq17YGbzJbLy/MfaRneoI4z/jWGzS2Fw0RfkY2Ngccc/zojHnWoNcr + 909yjZSMB8/hSSxpIMHmuG8MeJ2mu/KdP19j7V3cT+Ym/GK5qkHfU6IzUjifE/hKwvdShu5P9fBu8s/N + /EAD/FjoK+bPGXhW8+D3hdW8AeLf7N1y9/11v/Zwl/tPY67fmlZ0h8tJXPGN+fXGPscopYbhwvT8a5vV + 9HiNttkXJPueeR706c503eISjGWkjyr4NfEnSfiT4ca/sbb7HqNnj7bZb2k+y73cJ+8KKr7lQtxnGcGu + 6KscsH8w9jjG3/GvK/FvgJ9I0fT7/wANWXka1p3m+Tr/AJu77D5jAN/o7sVl3oWj5zt+91rpfBvifT/E + HjDxXHZeMP7YtrT7H5dn/ZrQfYN0bZ+cgGXeVJ/2cY716tDFxno9zzsRguXWB1vO480ZG4UuBuGDRzuN + egnc8xxsMA5qQtxTSKBTsCFooooGFFFFACD5utKOOBSLz0py8dal7EyVmhrgFtw+X9cV4z+2B4d0fVPh + BqGv39lv1PRvL+wz+a48nzriFJPlBCtlQB8wOO2K9kHzEgDdn8MVIuOoPL/ePpioqQ5ocp10Kvs5o/Mn + Qbp4ZS6H95/AMfXNexfDTQbrx/4xtbSR/O0uz3/2pLgL5O+NzFxlWbLJj5enevPvFvw78X+BJrGLxbpH + 9lLqXmfZm+0xTZ8sDdxGzf31646192/Djwxo+k6bap4f0f7PpNrv8i1+0u+NzNu+dyW+8Sefp0r5erh0 + 6rTPtKGMl7JQjucP8Pvh58KNa1S41TRdB82PSNu2T7ZdDPmqy9GYehHQ/hXvek6dpvh2O6bS7by1bZ5q + eYxxjOOWJ/vHpXz98A7rTvhjcfEbU/GEv9l6Vpf9l+ZJtabb5okUcR7mPzSKOh69hmvPfj98X9Y+MfiA + fC34Wf6Xod3/AKyT5E/tTYkdwOJ0R4fKeKT+L58emAShSkopRMMdOKqPmOw/a9+NWs+CPFmm+Gfhz4m/ + s7VLXzf7bt/sCS7N0cMlv800bKcq7n5D357VpeFvhlrXjrRLe++PFx/b+pR7vslhsS2+w5Yh/wB5aOqy + b1SFufu7cDqaP2fPg5o/hHw9oWv694e+y+NIPtH2ib7a77NzyIvypIYjmJgOB39a9mQBw6vyoxsb+dez + QwkYrmqHz+Jxji+WBl+FdD0bwtoFpoug2n2HS7Pf5Nt5jybN7lm+ZyWOWYnk9600V0ADDLH/AMe/wob5 + CSowB1pFxHkA5B6rXelFLTY8p87lzMNyFtxOV9aZcukNuJ7pcwdxn3x2561Dqeo2WlWD6hey+TDxg7S2 + 3kDsCTyRXyp4x8Wa38b/ABpD4N8JnydMm3eZJ8jb8RrKOJFRhhomHX/A51aqgjehh3J6nofjr9ovwrol + xLp9na/bpIsY/eSx4yFPeI+p/KuLHjX4qfGCeLTvD2nf2ZC+cP51tNnA3dHVD1jb8/z+h/hZ8APB3gyx + Hmxf2jOf+Wu6WLHL9vNI6Nj8K9ctbWG1hWK3XZGucDJPfPevOqYxnrQw8Yo+ePhB+zDofht49S8Rz/2p + qAzzseH++v8ABMR91l/KvoHTdOs9NiMdpB5Cem8t6+pPqat/xZXrTuFGe1cbnKW5uoqIoFBpetFRcb1D + FFJ+FL+FF2LQTFGKWii7CyCiiimMKKKKACiiigAooooATNGaXNJU+oHyN+0d4R1z4bfGlP2htPtf7e0u + PP8AaVn5iW32LNtFZxfOWZpN7OW+WP5duD1zXtPw18ZPr1zFrGjah/bPhPVc/YpfJ8j7H5QZX4ZRJJvk + BHIG3HGQa3PjV4Gb4k/DPV/Bf9q/2V/aPkZuvs/neX5c0cv3Ny5zsx1GM57Yrxn9nq+tvBXgeL4eeJJP + sXiXw7n+0rPaZPs/2iWSaL50yjbo2U/KxxnBweK6qC5vckJnHftS/HrwR428Lw+CPC/iLztM1Td/ad19 + imX7N5TxSxfJJGrPuZGHysMdTnpVf4LD4JeExDD4e8Tf8JFrcW7zNR+w3lr5+d5H7p8qu1GZffbnqa3f + GXxO+B9/dt9o8U4vTjzJP7PvOOFxwEx0GK5qDxn8HnEay/FPycZ/ef8ACP3bZ/DbWzw1JbyHGUlsdr4l + +KmsWKCTRvCv9qzD7w/tBIfT+8mOhP5ViH4yeNJ2aRfhFkN94f8ACRw//G64vXviL8PLKQf2X4o/tVT0 + b7BPD6f3l9z+VcPc/GmNJGWLQfPjHRvte39PLqlChH7Rbq1eh7S3xk8cRu5f4U4D4wP+Ehh7f9s61tB+ + K/iO6vPK1jwB/ZCdpf7Yjn7E9FT6D8favDfDvxQ1TXr37HpXg77TKP4P7TVOxPVkHYGurOofERkCn4bY + U/8AUct/8KLYZdR+2qs9hb4h7N4bRtqLjj7TnzP/AB3jFcL4g8Q/EK9aGbR/G39lbd3mQ/2VBNnOAPmY + exP4+1c3Z3fjl54Fm8AfZlg3bpf7YhfG4en6Vua94X8Q3bW7aR4u/soLu3w/2bHPnOMfMx9ifx9qdqD6 + FfvX0NDSfEnjOHT/ALPrPiT+1CP9ZP8AYYYd3JI+VRxjgfhQ+pXjwLC8vyrn5No7nPXFcPrvwv8AEms2 + ckGp+P8A7RGcb1/seNccgjlXHoKxrL4AwpdRyXPiXz4OcxfYSuePUS5681LxFKj8MRKFR7nX6/4k0bw8 + LdtUvfsSXu7yJfKeTzNmN3Cg4xuA5xnNZC/E3wMULtr2SekX2Ob5fx2c+tdr4U8IeG/CxnOj6X9kNzt8 + 0/aJH8zbnH3mOMbj065rK1H4XeDNQv3vrrSd05x5i/aJhu4AHR8DAFZvGupsrF+xl3Ofb4oeCcErrv1X + 7JNz/wCOVDF4wuNZnaHwTp3/AAkHl/8AHwvni18nIyv+tUbs4fp02+4r0fRtDsdGs/sukx+RF2TczZ5J + 6sT6mu00Pwhrmu28V1ZWvm2k2ds3mIuMEg/KWB6gip+uzd3FEyw8oq7OT+D/AMP9WsPClrounRf2hJYb + /Pk3LF/rJHZeGb3I4J6V9DfC/wAPPoWgBLuHZfzf8fXzZ6O+zoSOhHT8a3tE0qDSNMh0+1O2OPdtHPdi + x6k+tXj97jkHtXHFPV9ROpeNiXFFJmjNVcyFoIoBopgFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA + BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRikzQG43IBAPXs + fWsbxl4l0zwpok2ranL5dtDt3Hax6sqj7oJ6sO1cx8T/AIseFfAVnNJqN1uuY9v7jy5fmyU/iVGHRwa+ + D/ir8TvFnxi1pbCGLbbf8s7XdEc/KhPzlEPWLP6fW405SJcrHY/C27n+LX7Rs/ieb5EO3CcHH+hvH1Gz + /nn6V9ceYZJPMK4H93NeV/s6/DNfAGgie7GdVuvvt6bWlA6Oy/dcf/rr1cFkyo+aROvbrXt4aHs42PGx + c+aTFBPLPyB1FLyWIByT29KZkKwk3YH061V17VbHQdIudT1m8+z2Vts85/LZsbmCrwoJ6kdBWs5KnFyM + KcOaSR4z8eNU8XWurTabcXnl+Hb/AG+RD5cR3+WsbN8wG8YfnnH5V5RAMLjOcdOOlRaPrU+r+FtLsk5s + LPzvsMPH7re5MnzYBbJGfm6dquwKrMwHUfd/rX5xm1f2ldyR+gZbRjToq46JflxVyNP3dQxrzirsS8Yr + xJ81+Y9amnf3R8KcVciT5ahhXirsA+WuaW9zohGQ6JcgVbiXBFRRJgVciTJrnTlLSxo0ranQeANMsdU8 + WWem6onm2Tb98OWG7EbMPmUgjkA16Lc6zaeM/GttcWTYt/D27ynwf9L+0R4PBAMewqeuc+1c/wDBLQXv + ddOpR3XlrpvSHy8+b5iyL97PGMZ75p/w78WW3i/xr4t1COL7Lc/6F59tuL+V+7YL8+0A5C546ZxX3HD1 + FpxPjc4rJN2O4604cUh4oHNferY+Lbve/UM0tJilqyOUQBccUo3dqQY7U4EigtBRupMUDFIVhNxpc0ZF + FMmwPxQnNB96B7UFBRRRQMRlABy2Iz7dKyPGeuHw34auNbFl9q8jb/o/m7N+51T72DjG7PStgIA6qBk8 + 7mz938O9eI+OvAd14H8P+JvE/h/xL9n0eT7JnSPsIfbh1j/1zszHLOX6e3SuatKSheO5tQjGc9S78VPh + 94uvV0/+1vFf9uWsfm+dL/Z8Vv8AZ87NvCtl9xAHHTHvWn8PfG/j+x1vUNO8Uf6atj5e+3/cR7d6sw+a + Neeqnv0pngrxJFovjGbwqPD39mRSbd1v9sM32PEbSD5sHzN5Oevy5rnPiLe6z4T8ZG+vbnzluv8AUXex + F8zbGob5BnGNwHPXrXy1SvU5/fPp4UoKGh9K3kLLuwPmX9KrQSbCuORzXk/wJvtb0fQNLsNV1Hdp8Pnb + ofJQeTueQj5lBLZYg+1ev3kSxqAG2E/e4zXfhqqqbnFWw8tyzbSsIwFORWhE6GZsfKTj37VgwuEU7jtI + /GtKKRzKMjIraUbkRlHZjPEejf2zaqLe5+y3sWfJutm/yskbvkJAOQMc9M5rg9QsITqd3pN1P9pvLbZ5 + kmwpncoYcA46cda9NikbaGZ9x7cYzVXVNF0zWJbee/g897fd5Lb2XbuwG4BGc4HWsFKUDaKTR44DcWM6 + kNnGew54/wDr13HhLxDL+/jll3fdx8oGOvtWPrem3dtrB0nUrXz4Z/8Aj0vPMC+ftUM/yKcrtOByeeor + CmVtPuEjifcZM7hjGcD/AOvW0ZKe5hrB6HuEEqzQiUcK1LKiyIySfMjduleb+G/EtxHaLF99hn0Hc+1e + jI4YkkYYdqwnHlN4y5tjD1KwSB45ov3TrnZ39Ae9eIfFf4M2fjPRvPt9M+33mmf8e9l55j83zWQN85kA + XAXdznOMcV6F4o+Luh2NzBb6NB/bMkm7z/ne38nABX7yfNnJ6dMe9cVe694j165lurS//sqN8Ys/Jjm2 + 4GPvkDPQn8cVhKtbY1jGXUyfC/i34i6D428P/D74g6B9rvNY+0+Trn2y3T7R5MZmb/R4VITaCicsM43c + 8ivViGOdzfP2bHT8K8U/adn0+Hw3Ya542uP7cgtfM26Hsa3/ALS3PEn/AB8Rcw+Wdj9Pmxt7muv+AN/p + mofCPRJtG8K/8I7pQ8/yLb+0Guv+XiQN87Dd94E8/wB7HQV6+BxE5q0jzMbh4fEjuhycmgA7uaUDIyKH + xt4r07WPKcr6IKXFNxRzVCVxTS4puKU0DaQA0g604dKQGkShCKAaUUhoKZ4T+2V4WfUvAtt4xi1L7LL4 + c3/uvI3+f9olgi65G3bjPQ5z261498FP2idS+HWh3Og3mgf25pPyfYbb7Ytt9k+aR5PnETM+5nB+Y8Yw + ODX2wjP8oU7gP+WnTP4Vw3hT4RfDnwnr9tr+g+HfsmpWu/ypvttw+zchQ/K7lTlWI5HevPrYSNWVz1cL + jnThY8D8L+Bfif8AtAeHLPX/ABx4v+y6bZ7/AOxJv7Ntn8/e5S4+WJo2Xa0KD5xznjvn6Q8AfD/wj4DW + 7bwlo39lJfbPtJ+0yzZ2btn+sZv77dMdea6NmyzbhwMZ560oGRu2bmXqc1vTw0aS0MK2MlVFBbJjVsOO + oxRzkcYA6mkViWOFzIepzQRGXEZkyT1GK2t3ONq4Dkse3celZPi/xJp3hDQzquppsjHuxx8yr/CD/eHa + k8XeJ9L8L6ZPe6pc/ZY4dvmfIz43MoH3Qf7w6eteBweC/Gf7QPiltT1I/wBjeGVxgfubjyvk2/wtG7Zk + hHbjPoOca1WMUdWHpNnn2oar4y/aC8Zx6NpUXk2QzhN0LbP3YbqwjJyYT3/+v9pfBL4WaJ8N9Cjs7FfM + uZM+dNlxuw0hX5S7AYDkcVu/DrwPoXgfQ4tJ0a32JFnJ3uc5Zm/iZv75711C7uucj+96149Su5nrQhYc + qhFwKUZxSd6U5JwKxRoxaKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAYwJJK8H+9Xyr + +0R+zDqvj34h6r450rxD+91Hyc6d9jX915cMUX+taZd2Qhb7ox096+qsEYwMe3rQepDd+goA+IfBv7K1 + xEXm1O0/t6A4x+8Ft/eH8M2euP8Avn3rpj+zDpgKg+BuvQf2s3/x6vrhFKjgY9qUDA96LjufIsf7L+ng + qzeCN5Ocr/arDb+Pnc1d0P8AZ4Oh6tb6ppPgr7LeQbtk39qb9u5Sp+VpSDwSOnevqphnBHQ9V9fxp2ee + nPb3oHzngSfDrxWFCnRsj/r5i/8Aiq0rH4X63NOEupPskf8Auo/b2f8Azmva93Oe1ITnhhkUcpftZnlY + +D/3f+Ki+7n/AJcv/s6D8H/vf8VF97H/AC5f/Z16ru9+tG736UWD2tQ8b1r4T38OmTSadqn227Xb5UP2 + dY9/zDPzF8DAyefSuQ13w/rmitANYtPI+07vK/eI27bjP3ScYyOtfSC8MxxyMbvejaCMMuPXmk4jjWmt + 2fK5IO4q3yHG1sdPwpzEI33dhX7pznb6/WvqDUrK11GzlsrtPMhkxvXJGcEEcjnqBTrSBLaFIII/LiTO + 0bs9TnvU8hbxSW6PF/AvgC91cm+vW+x2p/1LYEnn/eDcBgV2kDr1zXsOh6ZY6NpkWn6bB5FpDnZHvLbc + sSeWJJ5JNWzuOF6n+96fhTsBhkHj+E/zqlGxhKq5klIaM0UybWFooooAKKKKACiiigAooooAKKKKACii + igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii + igDH8UeINK8OaTNqWrXPkWybdzeWzYywX+EE9WHavjL4vftP6t4jnl0rwRDstjj/AErcpzwjfclhB6q4 + 6+/pU/7fHi6/u/FNp4MjucW0O/z08te6W8q87c9R2P8AhXq/wv8Ahv4X8K6JFDpsO+9gzvuN0g27mcj5 + Wcg5DEV0YenzMxq1eRHzH4G+DPjLx9qrarrsn2e3kxuucQtnCso+RJFPVAOnvX1H8L/hj4e8CtH/AGa2 + +RM5kxIM539mdv75ruVY7dpH7s9DSpypI+XH417FOlGKPLqYxsRNyu3lf6zuaUseCP8AWd6It6O23rxm + kZgMEfd71py3ZxSlzRuH/LQFzjPU+leZfH261e+0fTvAug2X/E017zfstx5qfuvIaOV/lf5WyoI5YY7Z + 6V6bjkqv7sj+Hr+tXtMt/thODv2dF6dc/wCFc+Ju6LOjCy/fI+KLZkmh3Ryb8deMZrQjVtu9jmLt/n61 + 9XeLvhx4b8U3mm3mv6X9sm03zfsj/aJI/L8wKH4RwDkKOuenFZf/AAqPwajCRdD2D/lmn2uY/XnfXxNf + LXKTPtaGPSglI+b4FJ5HC9z61bgXK4DZPfjpX0G/wo8IMQkWj43dR9pl7f8AA6q6h8L/AA/LZypbWP2O + 4fHlXHmySbcEZ+Uvg8cc+tef/ZFWSaO6WYU4rQ8PhVShaQ7C/VuuMe1W7dWIyV4P8een4V7F4P8Ahro+ + leGrKx8QWf8AwkWrJ5nn6h5r2vn5div7tHKrtUheOu3PU1n2HwojKP8AaPE3kKcbD9h3b+uej8Yrnr5T + Up6U9QpZpBP95oebwoSfmGMdBVqJCGUlMZzxmuj8Z+A9d0W706Hwzb/8JNbXPm/a5d6Wf2LaFKcOxMm8 + lhx93bz1ot/B3iMyiP8As75j0Hnx/wDxVYTyzEwabR2rH0akfcZ6v8FdKs4vDFpqkdvi+ut/2h9552vI + q8Zx09BXOfC+aGXwNZSxNuB8zacEf8tXzU2qeIH8BfDrTtHub3+zvE135v2EeV5u7ZMGk6BkGI3/AIj3 + 45q94X0DSvC/h+10DQrP7Dptrv8ALg81pNm5y5+ZyWOWYnr3r7rJKPKl5Hw+a1Lb9TRekUYpx60OMCvp + UeBNXegUUUVQrhRRRQMKKKKAuFFFFABRRRQAUUUUANUhTlm2KejYzTwkcpEc0vkxSffk27unTimqOePl + /u/1oVirM2c7v6VnNNrQuLSeh4jqehJ8HvF9xrdxbfYdO1Xbi98zzP7N8qML/qwXabzGl29BtznntvxC + 007S7LwNq2n/AGzSJ/M3XnnGPzNreaPkX5hhiF+92z04rpdK8AiPStR8PQa1t0I+V/YulfZc/YPmLz/v + i2+Xe/z/ADn5eg4rwuw1XTfh9ZR+BvGXhLzdM03P2jVv7RYbvMJlX9zGGYYZ1Thj6+or5/G0HLfc+hwd + dNWZ2fi+81O78VWtjaWX2u703ftk81U3+Yik8HgYAPr0ro/hj4ll8KajqEnis4iv/Lxe4H/LMP8A8s4w + e7Kvb1pk1zpmuxwyWOqedqFtu8m4+zsu3d975TgH5QRzXPaxZyaNcaJb6DF5Nvbeftj3bsbgD1fJ6kmv + Ip1HB6HZOLlofQUM1rexrcW1z58Bzg7Cvt356irEMgEih4/vdBmvMPhT8Q7G40jT9D2boYfN828yRjLO + 4+Tbnr8vB969MeIxgOIsjsN3SvYoVvao8+tQUNTRt5QEJB3EfdPpV+FhnEY3L/EelcvqetWGi6TPqmp3 + nlWtvt8yfymO3cwUfKoJ6kDpXMan8Y/CFpotxfaTcf2teLt8q02Sweb8wB+do8DAJPPXGO9TVqQgKnFy + eh6TqumWmq6fLYahF59tNjMe4r90g9QQeoBrzjWrWLw266fqt9shkz9ml8onzcYL8LkrgsBz17V4prXj + nx74ot20XUL77XpN7/x9L5UCY2EMnIUN95R0I6c8VjyX2h6JdSQ6tffY243J5TydsjlQfUfnXOq7fwnU + 6SitT1PXr+3sbu7toJvPuk2Yt9pXqAfvEY6HNeReLb9PC+gT6jrFr8y7dtn5n3/nVfvqDjG4H9KW48a6 + 3rSWms+CPBH2qz+fybz+1UTP8LfJKoPUOOR2z6Vm/DX4EahpGurDq8m/7ZnyhtUY2KxP3ZD6jrWsaFSs + RGrCiWdC+J+r2ErWOn+Fv+EnYY33f9oLZ7+pHyFOMZI/4DnvUmn/AAY13xxrV74y8Zf8TS51Dy9z/JDs + 8tTEOI5FByEXsOn1NfQXhrwdpmhJLIkm6RsbX2sNuM9txz1retLaOziENtH5aL0G7O3PPfrnNejh8DGP + xHDXx/M/dM7w9o0elQGBbjzpR1fZt28k9MnPBrULfJknafSgMNow3y9uKB8vXhj3/vf4Yr0Y04x2PLnV + nLRjsAUhphzmn9q1tYyT5dRAMUoGKVRkZoBycUhc9xMD059aQkY55p4ZjFvx+69f8+9NhYSDMHK/59aL + iabE7bif0o7YU7f1qC6u9Pgk2Xlz5RH+wx/l+FZtx4t8O2suJNUwB/07yf8AxNT7RG0aTNkq/XGKAD0e + sa38VeGLtAYdVz/27yf1X2qyde0ISAHUc/8AbF/8KPaIbpMvjp8q7j9cU/ouTw1Zn9v6GseE1LH/AGwf + /Cs7UvHPhHS4t02qbn/695R6ein1qXViNUJt2OiVCwznJpWbavLY/CvJvEfx68BaUCReedL2j8udc9O/ + ln1rkLf44eN/FNyYfCPhvZF2k+3QnPGekkY/ut/nFT7ePU0jhpKR9BXMsVlbC5vJfsW7/ZMnfHb6j868 + 28V/FGSDURpHhOw/tK8bv53ldg3/AC0THTd37VP4e+D/AIu8VMLr4ialwP8Alj5EXPUfehcf3UP+TXuP + hXwzpPhnTxY6Rb/Z4x/ts2eSf4if7xrhrYy2x10sLfc8l8D/AAh1HVNXg8QfEW6+138W7Zb+WqbcqyH5 + oXA6BD07fWvb7dFihVEXYB2znHNPU4YALgdjmlyc47jqa4Z1HM74QVMfk0UZFANZNpF3AClNBpuaFqMd + RRRTEFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAJRRS4oHcTNGaMUYoFcPwo/CjFGK + AD8KPwoxRigAFGaBS5oDYSj8aSjFOwXQuaKM0hak2F0KKU0gNBNCC1xaKKKACiiigAooooAKKKKACiii + gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii + gAooooA+KP29/h7fJrK+O7KPdbvn7UcqNmFt4k6tk5Oei/X1rpv2ZPifb+KPD8Wh3Z8vVLPO8YJ83e8r + jogVcKvrzX074i0u11zSJ9KvYvMgm2713EfdYMOQQeoHevh/4nfA3xR8JfEA8U+CX+1Wdv8AcbEabdyJ + GeJZHJyZH7dvpXVhalnqZVqfMj6sQErjv/DTx3YjJryz4SfGLQPHNpawXU/la0N+6DY5zy5HzCNV+4mf + /r16irOSEWbdPD1O3GzP6HIr2FNNaHjVqXKxSc0gFAxSlhWibOVqwhDDPOAasW11Jb+cYZ9pk2/wZ6fW + q6Bh05pST6421M6anuaQlYZdXfiN/Eei3tv4h8vTLXz/ALdpv2KM/btyYj/en5o9jfN8v3uhrMsvHvjl + 7VGn+Fn2WVM7o/8AhIIX25PHIXnjn8a1CTnDPlvTHWlBUBQpyFzhPTPvXHUwUJHXSxk1Ig07xp4kudRg + hv8AwJ9is33edcf2vHJswCV+ULk5OBx61h+JfjDo+keM4PDY037SYd39qTee6fYMxh4fl2Hzd+cfKfl7 + 10QLqu4Hbjp3xTw2eh+U/db19eKTwMFGxccdNVLkL/EfwAw58Q7d3QfYpznH/AK1tJ1jw9rGmW2p6ZqH + n2U+7B8mRd+1iv8AEARgg9qzgQrBlbZ+GcUiNwu6H5f96soZdZF/2kn0Ojg06C5gW6t2zG+ccHscdzTo + 9JfzVVZMbc5fb0/DNcFqnhfQ9Q1CXUbvT/MvHxvk85xnACjgHHQCoT4N8NDDf2blV7efJ3/4FWMsA7m8 + Md5k3xM8RatqS3vhK08O5t7zy/sV/wDbV/fbNkj/ALsgFcEFeSM9RWyfJXGx96r0TBGfxqha6Nplt9k+ + zW+xLPf5Db2Pl7/vdTzn36Vo732INm3Oflzmu3DYZUkcGLr+1YwcGlIyKbjJpx4Fdq3OTZBRSZozVBYW + ikAxTgcUCEozRtxRnFAgoFBNJjNA72FFH0oJ3dKMY60CbsApRSYozQNajVOKcDmkpy8UnuCuJ8wTfuyf + 4uOteY+NPBuna7pWmeDPGXjP+1PGeveb5Uv9mND9u8hllPEbCKPZEFHJG7Hc5FenEsCAp5P61NBM8MiT + 2wwVzx69u9cmJo+0Wh14av7N6ny58NPH+qa/4ytNB8U6hv8AEWm7/ssXkqPt/mRs7/NGoSLYgU8k7u3N + egXeveG70Sait3gafjzX8uTjzPlHGPbtmuU8d2Fjqj3Pjy+8O/8AFQ+G9n9seGvtrfuPtO2GD/SgQjbk + Al+RWx904PNX/hv480TxnYSrpmmf2frAx9psPPeXy+W2fvGUKcqpbj1wea+dxmF5X7p9Dhq3tNi/q2r3 + jol7BY/2ta22fOPmiDbuwF6jJ59PT3rotO+Kdl4Y0iLQLXTf7Ukt85PnmHduYv3Q4+969q4bWrq9hvr9 + M+XPceXsbAP2PaBn2k3j/vmuBtPE2garZzS6FN/bd9Bt2Wm17fduPPzuABwCfwx3rCmqqWhrVUV8R1Hx + V8X6x4xs59VtYvLt4dv2S13IfKyUV/nKgtkrnkcdBXL6prPhqDxOPD2sax9m8v8A4+YPs0j78oHX5lHG + ODwasnwj438cWDaP5/2HTpP9ZbbIZPOwdw+bcrLhkz15zXV6X8Cb3wx4UkvNNt/7a1KLGzS94t/OzIQf + 3rSFVwrFvfGO9dkMLKa1OSdWlS+AxvDeq+K9dtZ7Wxsv+EevZ9v2abzYrr7PtJL/ACkAPuAI56buOldv + 8MPgnfaXdajda54i/tK4l8rym+xLFswHB+7IQcgjr6V6vougWOl3AlU+Zu+8nI7Hvk+tWLG31qLXdcu7 + nW/tWlXf2f7BY/ZUT7HsXEn7wfNJvb5vm+7jA4rup4GzRzVMdFrViWug2llGtp1UZ3dfr6+9aG77rN1G + d1Jk7T33daQZ5ZeS3WvUpUVTR5VXEOoBwOi4/GnLk/xY/Ck5HU0cHtVrcxihF560p46U3GelOHHWr2Ja + DafWgZHagDHQ0ESHpSuwQ1W+YbOp+6KXaQobG1h070hLonng+WH6t13Y46dq474v+NrbwJ4Ql1VhmSbH + k2uT8+JEVvn2tjG/PI9qynU5DalSU2T+PPHnhvwTbvd6vc7QcZTy5OeVHVVb++K8Mv8A4wfEz4gytpvg + HS90T4xJ9otxnGG6Sov9x/8AOK0fhJ8ANb8f6oniv4jJstJ84t8oc7VeP70MqnqiHp/Wvr3QdD07QrNb + TTLfyo1z8u9mzyT1Yn1NefVxd9j1KWFSR8bQfs3/ABK8TRLPr+seXnOf9Gtz7fwSj+6K6rSP2O9MXaNR + 1fzSc5/0Zh6/3Z/pX1nt44OBQR681xyrzOlU0j5f1L9kHw1JEBaa15bf9esh9PWf61zF/wDseXHm/wCj + eI8r/wBeQ/rPX2QM9xSH2bH4UlXmDpo+ONP/AGO5vOxd+IMr/wBeY9/Sf6Vr2n7HGj/aP9I1rKf9er+n + tPX1ieeoo7Y7UnUY1TSPCvBv7MHw80GUSzWn2+QfxeZPF/e7CY+v6V7Ro+kafpFqLXT7fyYh0Xezdye5 + PcmrgBxg/MfypQPapcmy+VDqKKKQBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR + QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR + QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR + QAUUUUAFFFFADeSuKjlRJU2OKk5xxQCfT9aE7rQLHgPxi/Z60zXPP17wi/8AZ2vrt8h8NL/cRuJJQn3A + 3Ud/XFcb8H/iRfnU28A+OH+x6xBja2Fk83crzdIk2rhdn8XOfXIr6tAx8qHAH6V5b8avg3ofxEt/tEg+ + zarF/qrv53xkxg/J5ir91Mc/XrXVhsS4uzOatQ5jRAyv+z2ajBIxjjuM9a8m8FeN9S0TU/8AhEPiA3ka + nb/cusK3m7laQ/JCpUYUoOvPX1FerRzCePzxH8j9U3dccda9iNVS2PKqUbDgB1X7tOAP3s8UjI6fJ/DS + BSv3j8taHM4NC0UUUaXC7QClY0gakBzSum7BruHzetGKQKfWlAX1p2sHO2Kc5252j0xmgDnH3R60EA8f + e96ay/w5yfTFFkO7F5owPSjL96cGPcUWYkhqn2px+lNDN6UuX9Kb0Bh+FJmnAt6UAN6UXJ5hppKUCjbR + cYZ3UoSlIxSg0hRZGoDfw5z70pKnodufxpxBkV3xu2456USZ3OhHm7ccfdouNoblQeRzTt3Yimk7ZNrD + mngsrZYcUCtcTjbtoIKrgUDDruFCE4zQF+UTBHGaXBHOaGUE9aGUEYzRuVzWG9XBoDfOaCuSpoyOaYNk + d1AlxbtbzR+Yr4wN2M4Oe1eNeNPgPJqN/pur6B4k/sjV7HzfNuvsPn/at4VR8jybU2qCOAc5z1Fe0AYQ + gc7u9O4DYC/KerZ6fhWE6EJm9LEVKfwnk3gv4FeHNOe21vxEP7a8Spu8y9/eW/m53IP3aSbBiMqvTnGe + pr0mw0XS7KRDax+U0ecfMxxn6n3q+M5Uk4bnLf8A1qNoITdyBnI9KUKEI9BzxVWe44OfK8pDhY+n40kb + DAkThm6009cdD3pynKkdB2rRQikc8pSXURTg05uaSkY4FXbUd09xaKKKGmCaCjNJ0o3gU7WBig4Ge9J9 + 7rS/web2pqP5g3CluTZsCF24xw1DLIGIxlxTbqXyY3SY+TFxmT736D8q+e/iJ8Vda8W+KH8H/DRN10+M + 3GUHRFk+7OgHRZB1/oKznVUDrpUOY9I8f/FDR/DMzWmnn7VrKf6u1+dMZCk/OUK/dYn8Mdao/Cr4ZeIv + FfipPGvxDizEufstruj4+R4n+eFx/dQ8j2Hc123wR+DOj+B7MX15F9p1yT/Wz7nToZAPlEjL9xwOP516 + 0FwQc59BXkVsRzHoUcNyCqoQYFOHSgUA5rk3O3YOKU0maM0tQDFGaM0Zo1AMUYpaKdwACiigmi4BRRRQ + AUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQ + AUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQ + AUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHC/FT + 4b6D8QdHOnazB5sg+7JvcbfmRuiuuc7AK+R18f8Aj74LeKl8OeLf9O0lc/Z1/cR7fk3tzGrsfmlXqe3p + 0+7XyVIboev+zXEfF34b6H8RdCfTNZg3gY8pt7jHzIx4V1/uDqa1p4hwM5Ukzgvhn8QvDnjWyzpt5mQ9 + R5Unq/8AeVf7prshmJDHIc46CvizxT8KviP8Hta/tXTI/Nt16zZt1z8oX7rO56ykdP8A63uPwo+Ofh7x + XHDZaw/2fUU3blxI2c7yOVjC/dUV6uHxCnuefXw57F91QJPu/wAqcG/2s+nFRQS/aIkuLH96r58ztjHA + 6/jUrRTRkny8Kv3eR+NdSmmee6TQ0BexpQvoKVkk/u4/GkZHx97H4VV7isxOBxTlz1FGwEZojDE4obJS + Y0e1LnH3m/Sho8H5Y8/jTvKkI/498/8AA6XMVyMYVz3owDxmpVR9+Nv60jq6v939aOctQZFg9RSg+opz + FQQrcNTnUiUCT7tPmFyMjUEdU/WnLnsKSWRYv9bP/wCOVVk1GxHBuef9xv8AClzE8vkWnG3kjNKoAG8j + Nc/f+MPDumx4uL3j/rlJ7ein1rCuvi54Btlw+p8/9cJ//iKHI1hSv0O7ZlIwvT1p6iQLg8r614nq37R/ + gW2XyopvNH93bMvp38qvKfiT+0jrGqYs/C8P2FP7+5JP7p6PEPRvzrGVZJG9PDNn054m8d+EvD7p/b2p + +Q7ZyvkSt6f3FPqK5YfHf4ciNHXWNgbOT9muD/7Tr508J/s+fE3xt/pN1afZox/H5ls+Oo6CVf7le0+E + f2O9Igh8zxBrf2lv+ef2V0/vd0n+lcjxlmdccGmjoo/jv8M1PkJq3kt/173De/8AzzrodC+IXg/WY9tl + rP2o+n2aVPX1Ueh/KoNH/Za+F9k2+bSftD/9fFyvr6Te9c98Qv2UfDeoxGTwpcf2TP6bJJ/7v/PSbHQN + +ftSjjLEPApHqcEYklJA4/u//XpehI/5Z/3f/r18sx678SfglrQsfFCfaNK/ikzbr/DkcRh2+9Kv+en0 + P4I8XaL4w0sapolzut/4l2OP4mUfeUHqp7V2UqyqHJVw7RvZyxwd3v0o3ZUhju9sUrDLfIMe1KPMK48v + b75rdM5eSwz7nB4pwGeRzQoxyPm/Shju4Py/rTAASe9BAoIUd6AYzQTzCbSec0q56ZppZRxml+Uc5pju + KuBRuxTQ604stILCYyvT9aXDYwBTSctjd+lOKqp5b9KB8oEHtRzjikwy8GgZXk0XBRExubap6UgBds9c + U4N8uWfdGf4sYqHUryHTrEyahL9mtT/y02l+47DnqRUudi1TuSn5XESybT3G3OaddmNY9lyvl+hzn+Ve + H+Nfj/YpfHS/BsH9qXC997Q5yFb/AJaRY6bu/b6Vza+Ffjn8UOZI/wCytJf74zZTdOn8St96P9fQVzVa + 6idVKhdjvj18RbzxPq4+Gvgh/tU8n+sfATosc44lQDor/wAXb6Cvef2cfhJafDfwnbxXa+ZrD7vtEmSM + 4kl28B2X7rgcfzpPgd8DfDnw6s1uWi+16ufv3G6RMcyAfL5jL918fh6166uQx9+gry61dy2PTp0+QfRR + RXObBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAIvSiiikhohnhjuEeGZdyHGRnHv2r5T/ae+G/guyX+0LXRvLuT + 1f7VMf8AnkvQvjoaKK6aHxHNX2Plyw8ceKNAu5BpGqfZhx/y7xv2P95T6mvSvB/xY+IE9ujS6/uPP/Ln + AO7f7FFFerA4qmx0EPxN8bvJhtbz/wBusP8A8RXS6V8QfF7x/Nq+f+3aL3/2aKK6EczNi38c+Kcf8hT/ + AMl4v/iaS/8AHPinyv8AkKf+S8X/AMTRRUmaPPrr4o+O0Vtuu46f8ukP/wARXNap8XfiGjDb4hx/25we + 3+xRRUm8djlp/jH8R5Th/EeR/wBeVv8A/G6o3HxG8Z3LZm1ncf8Ar2hH8kooqUbNaFifxr4mFiMan/5A + j9f92qh8c+KQBjVP/JeL/wCJoopma3KV/wCNPE1xkTaluH/XCMenotY8mp3075ln3H/cUf0oorzG3c6I + pWKco3P83NSwWlu/3o8/iaKKTbOqmeieEfCHh2/1NIbvT/MjOcjzpB/Cx7N7Cvq/wH8FfhnDZpPH4a2y + HOT9uuD3Yf8APSiim9ion0HABtqWiiuOW5sFHaiipYdDI8Q6Pp2uafPp2qW32i1bblN7L3DdVIPUCvzp + 8bXlz8OfindQeDJP7Lj+TjaJv+WCn/lpu/vt+f0oorvwZyVT7A+FupXuv+HVk1ab7S/PO0J/G/8AdA9B + XXzxoGWML8vPGaKK9RbnkyK4J9aUE+tFFbGLF70+iikxIZB3pD0NFFHUaEXpQvWiigpB2prdKKKYydok + x939adHDHj7v60UVk9hxOR+IWr6ho+nyPp1x5DDGDsVu6/3gfU18pWXiLWPG3i97DxPefb7YYwnlJF/y + zz1QKeqL+VFFTI6In3H8O/Bvhvwvp0SaFpv2ReePPkfu399j/eP512kYBG7HNFFeLW3PQoDhSiiisEdb + FooooEFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQ + AUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQ + AUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAf/2Q== + + + \ No newline at end of file diff --git a/Project/Project/Forms/DecreeForm.Designer.cs b/Project/Project/Forms/DecreeForm.Designer.cs new file mode 100644 index 0000000..8b76eec --- /dev/null +++ b/Project/Project/Forms/DecreeForm.Designer.cs @@ -0,0 +1,141 @@ +namespace Project.Forms +{ + partial class DecreeForm + { + /// + /// 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() + { + label1 = new Label(); + label2 = new Label(); + ButtonSave = new Button(); + ButtonCancel = new Button(); + textBoxName = new TextBox(); + comboBoxStudent = new ComboBox(); + textBoxInfo = new TextBox(); + label3 = new Label(); + SuspendLayout(); + // + // label1 + // + label1.AutoSize = true; + label1.Location = new Point(90, 39); + label1.Name = "label1"; + label1.Size = new Size(59, 15); + label1.TabIndex = 0; + label1.Text = "Название"; + // + // label2 + // + label2.AutoSize = true; + label2.Location = new Point(98, 10); + label2.Name = "label2"; + label2.Size = new Size(50, 15); + label2.TabIndex = 1; + label2.Text = "Студент"; + // + // ButtonSave + // + ButtonSave.Location = new Point(53, 108); + ButtonSave.Name = "ButtonSave"; + ButtonSave.Size = new Size(96, 23); + ButtonSave.TabIndex = 9; + ButtonSave.Text = "Сохранить"; + ButtonSave.UseVisualStyleBackColor = true; + ButtonSave.Click += ButtonSave_Click; + // + // ButtonCancel + // + ButtonCancel.Location = new Point(217, 108); + ButtonCancel.Name = "ButtonCancel"; + ButtonCancel.Size = new Size(96, 23); + ButtonCancel.TabIndex = 10; + ButtonCancel.Text = "Отменить"; + ButtonCancel.UseVisualStyleBackColor = true; + ButtonCancel.Click += ButtonCancel_Click; + // + // textBoxName + // + textBoxName.Location = new Point(154, 36); + textBoxName.Name = "textBoxName"; + textBoxName.Size = new Size(159, 23); + textBoxName.TabIndex = 11; + // + // comboBoxStudent + // + comboBoxStudent.DropDownStyle = ComboBoxStyle.DropDownList; + comboBoxStudent.FormattingEnabled = true; + comboBoxStudent.Location = new Point(154, 7); + comboBoxStudent.Name = "comboBoxStudent"; + comboBoxStudent.Size = new Size(159, 23); + comboBoxStudent.TabIndex = 12; + // + // textBoxInfo + // + textBoxInfo.Location = new Point(154, 68); + textBoxInfo.Name = "textBoxInfo"; + textBoxInfo.Size = new Size(159, 23); + textBoxInfo.TabIndex = 13; + // + // label3 + // + label3.AutoSize = true; + label3.Location = new Point(68, 71); + label3.Name = "label3"; + label3.Size = new Size(81, 15); + label3.TabIndex = 14; + label3.Text = "Информация"; + // + // DecreeForm + // + AutoScaleDimensions = new SizeF(7F, 15F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(360, 157); + Controls.Add(label3); + Controls.Add(textBoxInfo); + Controls.Add(comboBoxStudent); + Controls.Add(textBoxName); + Controls.Add(ButtonCancel); + Controls.Add(ButtonSave); + Controls.Add(label2); + Controls.Add(label1); + Name = "DecreeForm"; + Text = "Указ"; + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private Label label1; + private Label label2; + private Button ButtonSave; + private Button ButtonCancel; + private TextBox textBoxName; + private ComboBox comboBoxStudent; + private TextBox textBoxInfo; + private Label label3; + } +} \ No newline at end of file diff --git a/Project/Project/Forms/DecreeForm.cs b/Project/Project/Forms/DecreeForm.cs new file mode 100644 index 0000000..ea9b739 --- /dev/null +++ b/Project/Project/Forms/DecreeForm.cs @@ -0,0 +1,42 @@ +using Project.Entities; +using Project.Repositories; + +namespace Project.Forms; + +public partial class DecreeForm : Form +{ + private readonly IDecreeRepository _decreeRepository; + + public DecreeForm(IDecreeRepository decreeRepository, IStudentRepository studentRepository) + { + InitializeComponent(); + _decreeRepository = decreeRepository ?? + throw new ArgumentNullException(nameof(decreeRepository)); + + comboBoxStudent.DataSource = studentRepository.GetAllStudents(); + comboBoxStudent.DisplayMember = "DisplayName"; + comboBoxStudent.ValueMember = "Id"; + } + + private void ButtonSave_Click(object sender, EventArgs e) + { + try + { + if (string.IsNullOrWhiteSpace(textBoxName.Text) || comboBoxStudent.SelectedIndex < 0 || string.IsNullOrEmpty(textBoxInfo.Text)) + { + throw new Exception("Имеются незаполненные поля"); + } + _decreeRepository.AddDecree(AddDecree(0)); + + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при сохранении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonCancel_Click(object sender, EventArgs e) => Close(); + + private Decree AddDecree(int id) => Decree.CreateOperation(id, (int)comboBoxStudent.SelectedValue!, textBoxName.Text, DateTime.Now, textBoxInfo.Text); +} diff --git a/ProjectExams/ProjectExams/Form1.resx b/Project/Project/Forms/DecreeForm.resx similarity index 93% rename from ProjectExams/ProjectExams/Form1.resx rename to Project/Project/Forms/DecreeForm.resx index 1af7de1..af32865 100644 --- a/ProjectExams/ProjectExams/Form1.resx +++ b/Project/Project/Forms/DecreeForm.resx @@ -1,17 +1,17 @@  - diff --git a/Project/Project/Forms/DecreesForm.Designer.cs b/Project/Project/Forms/DecreesForm.Designer.cs new file mode 100644 index 0000000..a44b4c3 --- /dev/null +++ b/Project/Project/Forms/DecreesForm.Designer.cs @@ -0,0 +1,99 @@ +namespace Project.Forms +{ + partial class DecreesForm + { + /// + /// 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(); + ButtonAdd = new Button(); + dataGridView = new DataGridView(); + panel1.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)dataGridView).BeginInit(); + SuspendLayout(); + // + // panel1 + // + panel1.Controls.Add(ButtonAdd); + panel1.Dock = DockStyle.Right; + panel1.Location = new Point(828, 0); + panel1.Name = "panel1"; + panel1.Size = new Size(125, 439); + panel1.TabIndex = 0; + // + // ButtonAdd + // + ButtonAdd.BackgroundImage = Properties.Resources.Add; + ButtonAdd.BackgroundImageLayout = ImageLayout.Stretch; + ButtonAdd.Location = new Point(13, 12); + ButtonAdd.Name = "ButtonAdd"; + ButtonAdd.Size = new Size(100, 100); + ButtonAdd.TabIndex = 1; + ButtonAdd.UseVisualStyleBackColor = true; + ButtonAdd.Click += ButtonAdd_Click; + // + // dataGridView + // + dataGridView.AllowUserToAddRows = false; + dataGridView.AllowUserToDeleteRows = false; + dataGridView.AllowUserToResizeColumns = false; + dataGridView.AllowUserToResizeRows = false; + dataGridView.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill; + dataGridView.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + dataGridView.Dock = DockStyle.Fill; + dataGridView.Location = new Point(0, 0); + dataGridView.MultiSelect = false; + dataGridView.Name = "dataGridView"; + dataGridView.ReadOnly = true; + dataGridView.RowHeadersVisible = false; + dataGridView.SelectionMode = DataGridViewSelectionMode.FullRowSelect; + dataGridView.Size = new Size(828, 439); + dataGridView.TabIndex = 2; + // + // DecreesForm + // + AutoScaleDimensions = new SizeF(7F, 15F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(953, 439); + Controls.Add(dataGridView); + Controls.Add(panel1); + Name = "DecreesForm"; + Text = "Указы"; + Load += GroupList_Load; + panel1.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)dataGridView).EndInit(); + ResumeLayout(false); + } + + #endregion + + private Panel panel1; + private Button ButtonAdd; + private Button ButtonUpd; + private Button ButtonDel; + private DataGridView dataGridView; + } +} \ No newline at end of file diff --git a/Project/Project/Forms/DecreesForm.cs b/Project/Project/Forms/DecreesForm.cs new file mode 100644 index 0000000..b6e08ad --- /dev/null +++ b/Project/Project/Forms/DecreesForm.cs @@ -0,0 +1,46 @@ +using Project.Repositories; +using Unity; + +namespace Project.Forms; + +public partial class DecreesForm : Form +{ + + private readonly IUnityContainer _container; + private readonly IDecreeRepository _decreeRepository; + + public DecreesForm(IUnityContainer container, IDecreeRepository decreeRepository) + { + InitializeComponent(); + _container = container ?? throw new ArgumentNullException(nameof(container)); + _decreeRepository = decreeRepository ?? throw new ArgumentNullException(nameof(decreeRepository)); + } + + private void GroupList_Load(object sender, EventArgs e) + { + try + { + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonAdd_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при добавлении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void LoadList() => dataGridView.DataSource = _decreeRepository.GetAllDecrees(); +} diff --git a/Project/Project/Forms/DecreesForm.resx b/Project/Project/Forms/DecreesForm.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/Project/Project/Forms/DecreesForm.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/Project/Project/Forms/StatementForm.Designer.cs b/Project/Project/Forms/StatementForm.Designer.cs new file mode 100644 index 0000000..056a168 --- /dev/null +++ b/Project/Project/Forms/StatementForm.Designer.cs @@ -0,0 +1,175 @@ +using Project.Entities.Enums; + +namespace Project.Forms +{ + partial class StatementForm + { + /// + /// 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() + { + label1 = new Label(); + label2 = new Label(); + ButtonSave = new Button(); + ButtonCancel = new Button(); + comboBoxSubject = new ComboBox(); + comboBoxTeacher = new ComboBox(); + groupBox1 = new GroupBox(); + dataGridView = new DataGridView(); + ColumnStudent = new DataGridViewComboBoxColumn(); + ColumnMark = new DataGridViewComboBoxColumn(); + groupBox1.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)dataGridView).BeginInit(); + SuspendLayout(); + // + // label1 + // + label1.AutoSize = true; + label1.Location = new Point(53, 19); + label1.Name = "label1"; + label1.Size = new Size(55, 15); + label1.TabIndex = 0; + label1.Text = "Предмет"; + // + // label2 + // + label2.AutoSize = true; + label2.Location = new Point(17, 57); + label2.Name = "label2"; + label2.Size = new Size(91, 15); + label2.TabIndex = 1; + label2.Text = "Преподаватель"; + // + // ButtonSave + // + ButtonSave.Location = new Point(12, 307); + ButtonSave.Name = "ButtonSave"; + ButtonSave.Size = new Size(96, 23); + ButtonSave.TabIndex = 10; + ButtonSave.Text = "Сохранить"; + ButtonSave.UseVisualStyleBackColor = true; + ButtonSave.Click += ButtonSave_Click; + // + // ButtonCancel + // + ButtonCancel.Location = new Point(217, 307); + ButtonCancel.Name = "ButtonCancel"; + ButtonCancel.Size = new Size(96, 23); + ButtonCancel.TabIndex = 11; + ButtonCancel.Text = "Отменить"; + ButtonCancel.UseVisualStyleBackColor = true; + ButtonCancel.Click += ButtonCancel_Click; + // + // comboBoxSubject + // + comboBoxSubject.DropDownStyle = ComboBoxStyle.DropDownList; + comboBoxSubject.FormattingEnabled = true; + comboBoxSubject.Location = new Point(114, 16); + comboBoxSubject.Name = "comboBoxSubject"; + comboBoxSubject.Size = new Size(196, 23); + comboBoxSubject.TabIndex = 12; + // + // comboBoxTeacher + // + comboBoxTeacher.DropDownStyle = ComboBoxStyle.DropDownList; + comboBoxTeacher.FormattingEnabled = true; + comboBoxTeacher.Location = new Point(114, 54); + comboBoxTeacher.Name = "comboBoxTeacher"; + comboBoxTeacher.Size = new Size(196, 23); + comboBoxTeacher.TabIndex = 13; + // + // groupBox1 + // + groupBox1.Controls.Add(dataGridView); + groupBox1.Location = new Point(12, 99); + groupBox1.Name = "groupBox1"; + groupBox1.Size = new Size(301, 179); + groupBox1.TabIndex = 15; + groupBox1.TabStop = false; + groupBox1.Text = "Студенты"; + // + // dataGridView + // + dataGridView.AllowUserToResizeColumns = false; + dataGridView.AllowUserToResizeRows = false; + dataGridView.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill; + dataGridView.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + dataGridView.Columns.AddRange(new DataGridViewColumn[] { ColumnStudent, ColumnMark }); + dataGridView.Dock = DockStyle.Fill; + dataGridView.Location = new Point(3, 19); + dataGridView.MultiSelect = false; + dataGridView.Name = "dataGridView"; + dataGridView.RowHeadersVisible = false; + dataGridView.SelectionMode = DataGridViewSelectionMode.FullRowSelect; + dataGridView.Size = new Size(295, 157); + dataGridView.TabIndex = 14; + // + // ColumnStudent + // + ColumnStudent.HeaderText = "Студенты"; + ColumnStudent.Name = "ColumnStudent"; + // + // ColumnMark + // + ColumnMark.DataPropertyName = "Enum.GetValues(typeof(Mark));"; + ColumnMark.DataSource = Enum.GetValues(typeof(Mark)); + ColumnMark.HeaderText = "Оценки"; + ColumnMark.Name = "ColumnMark"; + ColumnMark.Resizable = DataGridViewTriState.True; + // + // StatementForm + // + AutoScaleDimensions = new SizeF(7F, 15F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(324, 342); + Controls.Add(groupBox1); + Controls.Add(comboBoxTeacher); + Controls.Add(comboBoxSubject); + Controls.Add(ButtonCancel); + Controls.Add(ButtonSave); + Controls.Add(label2); + Controls.Add(label1); + Name = "StatementForm"; + Text = "Результат сессии"; + groupBox1.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)dataGridView).EndInit(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private Label label1; + private Label label2; + private Button ButtonSave; + private Button ButtonCancel; + private ComboBox comboBoxSubject; + private ComboBox comboBoxTeacher; + private GroupBox groupBox1; + private DataGridView dataGridView; + private DataGridViewComboBoxColumn ColumnStudent; + private DataGridViewComboBoxColumn ColumnMark; + } +} \ No newline at end of file diff --git a/Project/Project/Forms/StatementForm.cs b/Project/Project/Forms/StatementForm.cs new file mode 100644 index 0000000..86ee65b --- /dev/null +++ b/Project/Project/Forms/StatementForm.cs @@ -0,0 +1,74 @@ +using Project.Entities; +using Project.Entities.Enums; +using Project.Repositories; + +namespace Project.Forms; + +public partial class StatementForm : Form +{ + private readonly IStatementRepository _statementRepository; + private readonly ITeacherRepository _teacherRepository; + private readonly ISubjectRepository _subjectRepository; + + public StatementForm(IStatementRepository statementRepository, ITeacherRepository teacherRepository, ISubjectRepository subjectRepository, IStudentRepository studentRepository) + { + InitializeComponent(); + + _statementRepository = statementRepository ?? throw new ArgumentNullException(nameof(statementRepository)); + _teacherRepository = teacherRepository ?? throw new ArgumentNullException(nameof(teacherRepository)); + _subjectRepository = subjectRepository ?? throw new ArgumentNullException(nameof(subjectRepository)); + + comboBoxTeacher.DataSource = _teacherRepository.GetAllTeachers(); + comboBoxTeacher.DisplayMember = "DisplayName"; + comboBoxTeacher.ValueMember = "Id"; + + comboBoxSubject.DataSource = _subjectRepository.GetAllSubjects(); + comboBoxSubject.DisplayMember = "Name"; + comboBoxSubject.ValueMember = "Id"; + + ColumnStudent.DataSource = studentRepository.GetAllStudents(); + ColumnStudent.DisplayMember = "DisplayName"; + ColumnStudent.ValueMember = "Id"; + } + + private void ButtonSave_Click(object sender, EventArgs e) + { + try + { + if (comboBoxTeacher.SelectedIndex < 0 || comboBoxSubject.SelectedIndex < 0 || dataGridView.RowCount < 1) + { + throw new Exception("Имеются незаполненные поля"); + } + + _statementRepository.CreateStatement(Statement.CreateOperation(0, + (int)comboBoxTeacher.SelectedValue!, + (int)comboBoxSubject.SelectedValue!, + CreateListStatementStudentFromDataGrid())); + + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при сохранении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonCancel_Click(object sender, EventArgs e) => Close(); + + private List CreateListStatementStudentFromDataGrid() + { + var list = new List(); + foreach (DataGridViewRow row in dataGridView.Rows) + { + if (row.Cells["ColumnStudent"].Value == null || + row.Cells["ColumnMark"].Value == null) + { + continue; + } + list.Add(StatementStudent.CreateOperation(0, + Convert.ToInt32(row.Cells["ColumnStudent"].Value), + (Mark)Convert.ToInt32(row.Cells["ColumnMark"].Value))); + } + return list; + } +} diff --git a/Project/Project/Forms/StatementForm.resx b/Project/Project/Forms/StatementForm.resx new file mode 100644 index 0000000..cb09f39 --- /dev/null +++ b/Project/Project/Forms/StatementForm.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/Project/Project/Forms/StatementListForm.Designer.cs b/Project/Project/Forms/StatementListForm.Designer.cs new file mode 100644 index 0000000..05325a6 --- /dev/null +++ b/Project/Project/Forms/StatementListForm.Designer.cs @@ -0,0 +1,97 @@ +namespace Project.Forms +{ + partial class StatementListForm + { + /// + /// 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(); + ButtonAdd = new Button(); + dataGridViewData = new DataGridView(); + panel1.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)dataGridViewData).BeginInit(); + SuspendLayout(); + // + // panel1 + // + panel1.Controls.Add(ButtonAdd); + panel1.Dock = DockStyle.Right; + panel1.Location = new Point(845, 0); + panel1.Name = "panel1"; + panel1.Size = new Size(114, 449); + panel1.TabIndex = 0; + // + // ButtonAdd + // + ButtonAdd.BackgroundImage = Properties.Resources.Add; + ButtonAdd.BackgroundImageLayout = ImageLayout.Stretch; + ButtonAdd.Location = new Point(6, 12); + ButtonAdd.Name = "ButtonAdd"; + ButtonAdd.Size = new Size(100, 100); + ButtonAdd.TabIndex = 3; + ButtonAdd.UseVisualStyleBackColor = true; + ButtonAdd.Click += ButtonAdd_Click; + // + // dataGridViewData + // + dataGridViewData.AllowUserToAddRows = false; + dataGridViewData.AllowUserToDeleteRows = false; + dataGridViewData.AllowUserToResizeColumns = false; + dataGridViewData.AllowUserToResizeRows = false; + dataGridViewData.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill; + dataGridViewData.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + dataGridViewData.Dock = DockStyle.Fill; + dataGridViewData.Location = new Point(0, 0); + dataGridViewData.MultiSelect = false; + dataGridViewData.Name = "dataGridViewData"; + dataGridViewData.ReadOnly = true; + dataGridViewData.RowHeadersVisible = false; + dataGridViewData.SelectionMode = DataGridViewSelectionMode.FullRowSelect; + dataGridViewData.Size = new Size(845, 449); + dataGridViewData.TabIndex = 4; + // + // StatementListForm + // + AutoScaleDimensions = new SizeF(7F, 15F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(959, 449); + Controls.Add(dataGridViewData); + Controls.Add(panel1); + Name = "StatementListForm"; + Text = "Создание результатов сессии"; + Load += StatementListForm_Load; + panel1.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)dataGridViewData).EndInit(); + ResumeLayout(false); + } + + #endregion + + private Panel panel1; + private Button ButtonAdd; + private DataGridView dataGridViewData; + } +} \ No newline at end of file diff --git a/Project/Project/Forms/StatementListForm.cs b/Project/Project/Forms/StatementListForm.cs new file mode 100644 index 0000000..e76e56e --- /dev/null +++ b/Project/Project/Forms/StatementListForm.cs @@ -0,0 +1,44 @@ +using Project.Repositories; +using Unity; + +namespace Project.Forms; + +public partial class StatementListForm : Form +{ + private readonly IUnityContainer _container; + private readonly IStatementRepository _statementRepository; + + public StatementListForm(IUnityContainer container, IStatementRepository statementRepository) + { + InitializeComponent(); + _container = container ?? throw new ArgumentNullException(nameof(container)); + _statementRepository = statementRepository ?? throw new ArgumentNullException(nameof(statementRepository)); + } + + private void ButtonAdd_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при добавлении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void LoadList() => dataGridViewData.DataSource = _statementRepository.GetAllStatements(); + + private void StatementListForm_Load(object sender, EventArgs e) + { + try + { + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } +} diff --git a/Project/Project/Forms/StatementListForm.resx b/Project/Project/Forms/StatementListForm.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/Project/Project/Forms/StatementListForm.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/Project/Project/Forms/StudentForm.Designer.cs b/Project/Project/Forms/StudentForm.Designer.cs new file mode 100644 index 0000000..a28f894 --- /dev/null +++ b/Project/Project/Forms/StudentForm.Designer.cs @@ -0,0 +1,144 @@ +namespace Project.Forms +{ + partial class StudentForm + { + /// + /// 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() + { + lblSurname = new Label(); + lblName = new Label(); + lblMiddleName = new Label(); + textBoxSurname = new TextBox(); + textBoxName = new TextBox(); + ButtonSave = new Button(); + ButtonCancel = new Button(); + numericUpDownScore = new NumericUpDown(); + ((System.ComponentModel.ISupportInitialize)numericUpDownScore).BeginInit(); + SuspendLayout(); + // + // lblSurname + // + lblSurname.AutoSize = true; + lblSurname.Location = new Point(62, 39); + lblSurname.Name = "lblSurname"; + lblSurname.Size = new Size(61, 15); + lblSurname.TabIndex = 0; + lblSurname.Text = "Фамилия "; + // + // lblName + // + lblName.AutoSize = true; + lblName.Location = new Point(92, 69); + lblName.Name = "lblName"; + lblName.Size = new Size(31, 15); + lblName.TabIndex = 1; + lblName.Text = "Имя"; + // + // lblMiddleName + // + lblMiddleName.AutoSize = true; + lblMiddleName.Location = new Point(38, 98); + lblMiddleName.Name = "lblMiddleName"; + lblMiddleName.Size = new Size(85, 15); + lblMiddleName.TabIndex = 2; + lblMiddleName.Text = "Средний балл"; + // + // textBoxSurname + // + textBoxSurname.Location = new Point(149, 36); + textBoxSurname.Name = "textBoxSurname"; + textBoxSurname.Size = new Size(141, 23); + textBoxSurname.TabIndex = 4; + // + // textBoxName + // + textBoxName.Location = new Point(149, 66); + textBoxName.Name = "textBoxName"; + textBoxName.Size = new Size(141, 23); + textBoxName.TabIndex = 5; + // + // ButtonSave + // + ButtonSave.Location = new Point(194, 136); + ButtonSave.Name = "ButtonSave"; + ButtonSave.Size = new Size(96, 23); + ButtonSave.TabIndex = 8; + ButtonSave.Text = "Сохранить"; + ButtonSave.UseVisualStyleBackColor = true; + ButtonSave.Click += ButtonSave_Click; + // + // ButtonCancel + // + ButtonCancel.Location = new Point(38, 136); + ButtonCancel.Name = "ButtonCancel"; + ButtonCancel.Size = new Size(96, 23); + ButtonCancel.TabIndex = 9; + ButtonCancel.Text = "Отменить"; + ButtonCancel.UseVisualStyleBackColor = true; + ButtonCancel.Click += ButtonCancel_Click; + // + // numericUpDownScore + // + numericUpDownScore.DecimalPlaces = 2; + numericUpDownScore.Increment = new decimal(new int[] { 1, 0, 0, 131072 }); + numericUpDownScore.Location = new Point(149, 96); + numericUpDownScore.Maximum = new decimal(new int[] { 5, 0, 0, 0 }); + numericUpDownScore.Name = "numericUpDownScore"; + numericUpDownScore.Size = new Size(141, 23); + numericUpDownScore.TabIndex = 10; + // + // StudentForm + // + AutoScaleDimensions = new SizeF(7F, 15F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(331, 178); + Controls.Add(numericUpDownScore); + Controls.Add(ButtonCancel); + Controls.Add(ButtonSave); + Controls.Add(textBoxName); + Controls.Add(textBoxSurname); + Controls.Add(lblMiddleName); + Controls.Add(lblName); + Controls.Add(lblSurname); + Name = "StudentForm"; + Text = "Студент"; + ((System.ComponentModel.ISupportInitialize)numericUpDownScore).EndInit(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private Label lblSurname; + private Label lblName; + private Label lblMiddleName; + private TextBox textBoxSurname; + private TextBox textBoxName; + private Button ButtonSave; + private Button ButtonCancel; + private NumericUpDown numericUpDownScore; + } +} \ No newline at end of file diff --git a/Project/Project/Forms/StudentForm.cs b/Project/Project/Forms/StudentForm.cs new file mode 100644 index 0000000..5a841ae --- /dev/null +++ b/Project/Project/Forms/StudentForm.cs @@ -0,0 +1,77 @@ +using Project.Entities; +using Project.Repositories; + +namespace Project.Forms; + +public partial class StudentForm : Form +{ + private readonly IStudentRepository _studentRepository; + private int? _studentId; + + public int Id + { + set + { + try + { + var student = _studentRepository.GetStudentById(value); + if (student == null) + { + throw new InvalidDataException(nameof(student)); + } + textBoxSurname.Text = student.LastName; + textBoxName.Text = student.FirstName; + numericUpDownScore.Value = (decimal)student.Score; + _studentId = value; + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при получении данных", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + } + } + + public StudentForm(IStudentRepository studentRepository) + { + InitializeComponent(); + _studentRepository = studentRepository ?? + throw new ArgumentNullException(nameof(studentRepository)); + } + + private void ButtonSave_Click(object sender, EventArgs e) + { + try + { + if (string.IsNullOrWhiteSpace(textBoxSurname.Text) || + string.IsNullOrWhiteSpace(textBoxName.Text) || + numericUpDownScore.Value <= 0) + { + throw new Exception("Имеются незаполненные поля"); + } + + if (_studentId.HasValue) + { + _studentRepository.UpdateStudent(CreateStudent(_studentId.Value)); + } + else + { + _studentRepository.AddStudent(CreateStudent(0)); + } + + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при сохранении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + + } + + private void ButtonCancel_Click(object sender, EventArgs e) => Close(); + + private Student CreateStudent(int id) => Student.CreateOperation( + id, + textBoxName.Text, + textBoxSurname.Text,(float)numericUpDownScore.Value!); +} diff --git a/Project/Project/Forms/StudentForm.resx b/Project/Project/Forms/StudentForm.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/Project/Project/Forms/StudentForm.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/Project/Project/Forms/StudentsListForm.Designer.cs b/Project/Project/Forms/StudentsListForm.Designer.cs new file mode 100644 index 0000000..a9c521c --- /dev/null +++ b/Project/Project/Forms/StudentsListForm.Designer.cs @@ -0,0 +1,126 @@ +namespace Project.Forms +{ + partial class StudentsListForm + { + /// + /// 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(); + ButtonDel = new Button(); + ButtonUpd = new Button(); + ButtonAdd = new Button(); + dataGridViewStudents = new DataGridView(); + panel1.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)dataGridViewStudents).BeginInit(); + SuspendLayout(); + // + // panel1 + // + panel1.Controls.Add(ButtonDel); + panel1.Controls.Add(ButtonUpd); + panel1.Controls.Add(ButtonAdd); + panel1.Dock = DockStyle.Right; + panel1.Location = new Point(840, 0); + panel1.Name = "panel1"; + panel1.Size = new Size(126, 452); + panel1.TabIndex = 0; + // + // ButtonDel + // + ButtonDel.BackgroundImage = Properties.Resources.Del; + ButtonDel.BackgroundImageLayout = ImageLayout.Stretch; + ButtonDel.Location = new Point(12, 266); + ButtonDel.Name = "ButtonDel"; + ButtonDel.Size = new Size(101, 100); + ButtonDel.TabIndex = 2; + ButtonDel.UseVisualStyleBackColor = true; + ButtonDel.Click += ButtonDel_Click; + // + // ButtonUpd + // + ButtonUpd.BackgroundImage = Properties.Resources.Upd; + ButtonUpd.BackgroundImageLayout = ImageLayout.Stretch; + ButtonUpd.Location = new Point(13, 160); + ButtonUpd.Name = "ButtonUpd"; + ButtonUpd.Size = new Size(100, 100); + ButtonUpd.TabIndex = 1; + ButtonUpd.UseVisualStyleBackColor = true; + ButtonUpd.Click += ButtonUpd_Click; + // + // ButtonAdd + // + ButtonAdd.BackgroundImage = Properties.Resources.Add; + ButtonAdd.BackgroundImageLayout = ImageLayout.Stretch; + ButtonAdd.Location = new Point(13, 54); + ButtonAdd.Name = "ButtonAdd"; + ButtonAdd.Size = new Size(100, 100); + ButtonAdd.TabIndex = 0; + ButtonAdd.UseVisualStyleBackColor = true; + ButtonAdd.Click += ButtonAdd_Click; + // + // dataGridViewStudents + // + dataGridViewStudents.AllowUserToAddRows = false; + dataGridViewStudents.AllowUserToDeleteRows = false; + dataGridViewStudents.AllowUserToResizeColumns = false; + dataGridViewStudents.AllowUserToResizeRows = false; + dataGridViewStudents.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill; + dataGridViewStudents.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + dataGridViewStudents.Dock = DockStyle.Fill; + dataGridViewStudents.Location = new Point(0, 0); + dataGridViewStudents.MultiSelect = false; + dataGridViewStudents.Name = "dataGridViewStudents"; + dataGridViewStudents.ReadOnly = true; + dataGridViewStudents.RowHeadersVisible = false; + dataGridViewStudents.SelectionMode = DataGridViewSelectionMode.FullRowSelect; + dataGridViewStudents.Size = new Size(840, 452); + dataGridViewStudents.TabIndex = 1; + // + // StudentsList + // + AutoScaleDimensions = new SizeF(7F, 15F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(966, 452); + Controls.Add(dataGridViewStudents); + Controls.Add(panel1); + Name = "StudentsList"; + StartPosition = FormStartPosition.CenterParent; + Text = "Студенты"; + Load += StudentsList_Load; + panel1.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)dataGridViewStudents).EndInit(); + ResumeLayout(false); + } + + #endregion + + private Panel panel1; + private Button ButtonDel; + private Button ButtonUpd; + private Button ButtonAdd; + private DataGridView dataGridViewStudents; + } +} \ No newline at end of file diff --git a/Project/Project/Forms/StudentsListForm.cs b/Project/Project/Forms/StudentsListForm.cs new file mode 100644 index 0000000..4635dfd --- /dev/null +++ b/Project/Project/Forms/StudentsListForm.cs @@ -0,0 +1,99 @@ +using Project.Repositories; +using Unity; + +namespace Project.Forms; + +public partial class StudentsListForm : Form +{ + private readonly IUnityContainer _container; + private readonly IStudentRepository _studentRepository; + + public StudentsListForm(IUnityContainer container, IStudentRepository studentRepository) + { + InitializeComponent(); + _container = container ?? throw new ArgumentNullException(nameof(container)); + _studentRepository = studentRepository ?? throw new ArgumentNullException(nameof(studentRepository)); + } + + + private void StudentsList_Load(object sender, EventArgs e) + { + try + { + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + + private void ButtonAdd_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при добавлении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonUpd_Click(object sender, EventArgs e) + { + if (!TryGetIdentifierFromSelectedRow(out var findId)) + { + return; + } + try + { + var form = _container.Resolve(); + form.Id = findId; + form.ShowDialog(); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при изменении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonDel_Click(object sender, EventArgs e) + { + if (!TryGetIdentifierFromSelectedRow(out var findId)) + { + return; + } + if (MessageBox.Show("Удалить запись?", "Удаление", MessageBoxButtons.YesNo) != DialogResult.Yes) + { + return; + } + try + { + _studentRepository.DeleteStudent(findId); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при удалении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void LoadList() => dataGridViewStudents.DataSource = _studentRepository.GetAllStudents(); + + private bool TryGetIdentifierFromSelectedRow(out int id) + { + id = 0; + if (dataGridViewStudents.SelectedRows.Count < 1) + { + MessageBox.Show("Нет выбранной записи", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error); + return false; + } + id = Convert.ToInt32(dataGridViewStudents.SelectedRows[0].Cells["ID"].Value); + return true; + } +} diff --git a/Project/Project/Forms/StudentsListForm.resx b/Project/Project/Forms/StudentsListForm.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/Project/Project/Forms/StudentsListForm.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/Project/Project/Forms/SubjectForm.Designer.cs b/Project/Project/Forms/SubjectForm.Designer.cs new file mode 100644 index 0000000..68d883f --- /dev/null +++ b/Project/Project/Forms/SubjectForm.Designer.cs @@ -0,0 +1,118 @@ +namespace Project.Forms +{ + partial class SubjectForm + { + /// + /// 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() + { + labelName = new Label(); + labelDisciplineType = new Label(); + textBoxName = new TextBox(); + checkedListBoxCourse = new CheckedListBox(); + ButtonSave = new Button(); + ButtonCancel = new Button(); + SuspendLayout(); + // + // labelName + // + labelName.AutoSize = true; + labelName.Location = new Point(73, 33); + labelName.Name = "labelName"; + labelName.Size = new Size(59, 15); + labelName.TabIndex = 0; + labelName.Text = "Название"; + // + // labelDisciplineType + // + labelDisciplineType.AutoSize = true; + labelDisciplineType.Location = new Point(54, 79); + labelDisciplineType.Name = "labelDisciplineType"; + labelDisciplineType.Size = new Size(78, 15); + labelDisciplineType.TabIndex = 2; + labelDisciplineType.Text = "Выбор курса"; + // + // textBoxName + // + textBoxName.Location = new Point(147, 33); + textBoxName.Name = "textBoxName"; + textBoxName.Size = new Size(184, 23); + textBoxName.TabIndex = 3; + // + // checkedListBoxCourse + // + checkedListBoxCourse.FormattingEnabled = true; + checkedListBoxCourse.Location = new Point(147, 79); + checkedListBoxCourse.Name = "checkedListBoxCourse"; + checkedListBoxCourse.Size = new Size(184, 94); + checkedListBoxCourse.TabIndex = 5; + // + // ButtonSave + // + ButtonSave.Location = new Point(36, 200); + ButtonSave.Name = "ButtonSave"; + ButtonSave.Size = new Size(96, 23); + ButtonSave.TabIndex = 10; + ButtonSave.Text = "Сохранить"; + ButtonSave.UseVisualStyleBackColor = true; + ButtonSave.Click += ButtonSave_Click; + // + // ButtonCancel + // + ButtonCancel.Location = new Point(235, 200); + ButtonCancel.Name = "ButtonCancel"; + ButtonCancel.Size = new Size(96, 23); + ButtonCancel.TabIndex = 11; + ButtonCancel.Text = "Отменить"; + ButtonCancel.UseVisualStyleBackColor = true; + ButtonCancel.Click += ButtonCancel_Click; + // + // SubjectForm + // + AutoScaleDimensions = new SizeF(7F, 15F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(372, 251); + Controls.Add(ButtonCancel); + Controls.Add(ButtonSave); + Controls.Add(checkedListBoxCourse); + Controls.Add(textBoxName); + Controls.Add(labelDisciplineType); + Controls.Add(labelName); + Name = "SubjectForm"; + Text = "Предмет"; + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private Label labelName; + private Label labelDisciplineType; + private TextBox textBoxName; + private CheckedListBox checkedListBoxCourse; + private Button ButtonSave; + private Button ButtonCancel; + } +} \ No newline at end of file diff --git a/Project/Project/Forms/SubjectForm.cs b/Project/Project/Forms/SubjectForm.cs new file mode 100644 index 0000000..5596fc0 --- /dev/null +++ b/Project/Project/Forms/SubjectForm.cs @@ -0,0 +1,91 @@ +using Project.Repositories; +using Project.Entities.Enums; +using Project.Entities; + +namespace Project.Forms; + +public partial class SubjectForm : Form +{ + private readonly ISubjectRepository _subjectRepository; + private int? _subjectId; + + public int Id + { + set + { + try + { + var subject = _subjectRepository.GetSubjectById(value); + if (subject == null) + { + throw new InvalidDataException(nameof(subject)); + } + foreach (Course elem in Enum.GetValues(typeof(Course))) + { + if ((elem & subject.Courses) != 0) + { + checkedListBoxCourse.SetItemChecked(checkedListBoxCourse.Items.IndexOf(elem), true); + } + } + textBoxName.Text = subject.Name; + _subjectId = value; + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при получении данных", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + } + } + + public SubjectForm(ISubjectRepository subjectRepository) + { + InitializeComponent(); + + _subjectRepository = subjectRepository ?? throw new ArgumentNullException(nameof(subjectRepository)); + + foreach (var elem in Enum.GetValues(typeof(Course))) + { + checkedListBoxCourse.Items.Add(elem); + } + } + + private void ButtonSave_Click(object sender, EventArgs e) + { + try + { + if (string.IsNullOrWhiteSpace(textBoxName.Text) || + checkedListBoxCourse.CheckedItems.Count == 0 ) + { + throw new Exception("Имеются незаполненные поля"); + } + + if (_subjectId.HasValue) + { + _subjectRepository.UpdateSubject(CreateSubject(_subjectId.Value)); + } + else + { + _subjectRepository.AddSubject(CreateSubject(0)); + } + + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при сохранении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonCancel_Click(object sender, EventArgs e) => Close(); + + private Subject CreateSubject(int id) + { + Course course = Course.None; + foreach (var elem in checkedListBoxCourse.CheckedItems) + { + course |= (Course)elem; + } + return Subject.CreateOperation(id, textBoxName.Text, course); + } +} diff --git a/Project/Project/Forms/SubjectForm.resx b/Project/Project/Forms/SubjectForm.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/Project/Project/Forms/SubjectForm.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/Project/Project/Forms/SubjectsForm.Designer.cs b/Project/Project/Forms/SubjectsForm.Designer.cs new file mode 100644 index 0000000..a4775c7 --- /dev/null +++ b/Project/Project/Forms/SubjectsForm.Designer.cs @@ -0,0 +1,125 @@ +namespace Project.Forms +{ + partial class SubjectsForm + { + /// + /// 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(); + ButtonDel = new Button(); + ButtonUpd = new Button(); + ButtonAdd = new Button(); + dataGridView = new DataGridView(); + panel1.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)dataGridView).BeginInit(); + SuspendLayout(); + // + // panel1 + // + panel1.Controls.Add(ButtonDel); + panel1.Controls.Add(ButtonUpd); + panel1.Controls.Add(ButtonAdd); + panel1.Dock = DockStyle.Right; + panel1.Location = new Point(800, 0); + panel1.Name = "panel1"; + panel1.Size = new Size(134, 429); + panel1.TabIndex = 0; + // + // ButtonDel + // + ButtonDel.BackgroundImage = Properties.Resources.Del; + ButtonDel.BackgroundImageLayout = ImageLayout.Stretch; + ButtonDel.Location = new Point(13, 270); + ButtonDel.Name = "ButtonDel"; + ButtonDel.Size = new Size(101, 100); + ButtonDel.TabIndex = 4; + ButtonDel.UseVisualStyleBackColor = true; + ButtonDel.Click += ButtonDel_Click; + // + // ButtonUpd + // + ButtonUpd.BackgroundImage = Properties.Resources.Upd; + ButtonUpd.BackgroundImageLayout = ImageLayout.Stretch; + ButtonUpd.Location = new Point(13, 164); + ButtonUpd.Name = "ButtonUpd"; + ButtonUpd.Size = new Size(100, 100); + ButtonUpd.TabIndex = 3; + ButtonUpd.UseVisualStyleBackColor = true; + ButtonUpd.Click += ButtonUpd_Click; + // + // ButtonAdd + // + ButtonAdd.BackgroundImage = Properties.Resources.Add; + ButtonAdd.BackgroundImageLayout = ImageLayout.Stretch; + ButtonAdd.Location = new Point(13, 58); + ButtonAdd.Name = "ButtonAdd"; + ButtonAdd.Size = new Size(100, 100); + ButtonAdd.TabIndex = 2; + ButtonAdd.UseVisualStyleBackColor = true; + ButtonAdd.Click += ButtonAdd_Click; + // + // dataGridView + // + dataGridView.AllowUserToAddRows = false; + dataGridView.AllowUserToDeleteRows = false; + dataGridView.AllowUserToResizeColumns = false; + dataGridView.AllowUserToResizeRows = false; + dataGridView.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill; + dataGridView.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + dataGridView.Dock = DockStyle.Fill; + dataGridView.Location = new Point(0, 0); + dataGridView.MultiSelect = false; + dataGridView.Name = "dataGridView"; + dataGridView.ReadOnly = true; + dataGridView.RowHeadersVisible = false; + dataGridView.SelectionMode = DataGridViewSelectionMode.FullRowSelect; + dataGridView.Size = new Size(800, 429); + dataGridView.TabIndex = 3; + // + // SubjectsForm + // + AutoScaleDimensions = new SizeF(7F, 15F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(934, 429); + Controls.Add(dataGridView); + Controls.Add(panel1); + Name = "SubjectsForm"; + Text = "Предметы"; + Load += SubjectsForm_Load; + panel1.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)dataGridView).EndInit(); + ResumeLayout(false); + } + + #endregion + + private Panel panel1; + private Button ButtonAdd; + private Button ButtonUpd; + private Button ButtonDel; + private DataGridView dataGridView; + } +} \ No newline at end of file diff --git a/Project/Project/Forms/SubjectsForm.cs b/Project/Project/Forms/SubjectsForm.cs new file mode 100644 index 0000000..cb6fc38 --- /dev/null +++ b/Project/Project/Forms/SubjectsForm.cs @@ -0,0 +1,98 @@ +using Project.Repositories; +using Unity; + +namespace Project.Forms; + +public partial class SubjectsForm : Form +{ + private readonly IUnityContainer _container; + private readonly ISubjectRepository _subjectRepository; + + public SubjectsForm(IUnityContainer container, ISubjectRepository subjectRepository) + { + InitializeComponent(); + + _container = container ?? throw new ArgumentNullException(nameof(container)); + _subjectRepository = subjectRepository ?? throw new ArgumentNullException(nameof(subjectRepository)); + } + + + private void ButtonAdd_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при добавлении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonUpd_Click(object sender, EventArgs e) + { + if (!TryGetIdentifierFromSelectedRow(out var findId)) + { + return; + } + try + { + var form = _container.Resolve(); + form.Id = findId; + form.ShowDialog(); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при изменении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonDel_Click(object sender, EventArgs e) + { + if (!TryGetIdentifierFromSelectedRow(out var findId)) + { + return; + } + if (MessageBox.Show("Удалить запись?", "Удаление", MessageBoxButtons.YesNo) != DialogResult.Yes) + { + return; + } + try + { + _subjectRepository.DeleteSubject(findId); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при удалении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void LoadList() => dataGridView.DataSource = _subjectRepository.GetAllSubjects(); + + private bool TryGetIdentifierFromSelectedRow(out int id) + { + id = 0; + if (dataGridView.SelectedRows.Count < 1) + { + MessageBox.Show("Нет выбранной записи", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error); + return false; + } + id = Convert.ToInt32(dataGridView.SelectedRows[0].Cells["ID"].Value); + return true; + } + + private void SubjectsForm_Load(object sender, EventArgs e) + { + try + { + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } +} diff --git a/Project/Project/Forms/SubjectsForm.resx b/Project/Project/Forms/SubjectsForm.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/Project/Project/Forms/SubjectsForm.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/Project/Project/Forms/TeacherForm.Designer.cs b/Project/Project/Forms/TeacherForm.Designer.cs new file mode 100644 index 0000000..3155ab5 --- /dev/null +++ b/Project/Project/Forms/TeacherForm.Designer.cs @@ -0,0 +1,116 @@ +namespace Project.Forms +{ + partial class TeacherForm + { + /// + /// 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() + { + ButtonSave = new Button(); + ButtonCancel = new Button(); + labelSurname = new Label(); + label2 = new Label(); + textBoxSurname = new TextBox(); + textBoxName = new TextBox(); + SuspendLayout(); + // + // ButtonSave + // + ButtonSave.Location = new Point(169, 131); + ButtonSave.Name = "ButtonSave"; + ButtonSave.Size = new Size(96, 23); + ButtonSave.TabIndex = 9; + ButtonSave.Text = "Сохранить"; + ButtonSave.UseVisualStyleBackColor = true; + ButtonSave.Click += ButtonSave_Click; + // + // ButtonCancel + // + ButtonCancel.Location = new Point(56, 131); + ButtonCancel.Name = "ButtonCancel"; + ButtonCancel.Size = new Size(96, 23); + ButtonCancel.TabIndex = 10; + ButtonCancel.Text = "Отменить"; + ButtonCancel.UseVisualStyleBackColor = true; + // + // labelSurname + // + labelSurname.AutoSize = true; + labelSurname.Location = new Point(56, 38); + labelSurname.Name = "labelSurname"; + labelSurname.Size = new Size(58, 15); + labelSurname.TabIndex = 11; + labelSurname.Text = "Фамилия"; + // + // label2 + // + label2.AutoSize = true; + label2.Location = new Point(83, 83); + label2.Name = "label2"; + label2.Size = new Size(31, 15); + label2.TabIndex = 12; + label2.Text = "Имя"; + // + // textBoxSurname + // + textBoxSurname.Location = new Point(120, 35); + textBoxSurname.Name = "textBoxSurname"; + textBoxSurname.Size = new Size(145, 23); + textBoxSurname.TabIndex = 15; + // + // textBoxName + // + textBoxName.Location = new Point(120, 81); + textBoxName.Name = "textBoxName"; + textBoxName.Size = new Size(145, 23); + textBoxName.TabIndex = 16; + // + // TeacherForm + // + AutoScaleDimensions = new SizeF(7F, 15F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(318, 186); + Controls.Add(textBoxName); + Controls.Add(textBoxSurname); + Controls.Add(label2); + Controls.Add(labelSurname); + Controls.Add(ButtonCancel); + Controls.Add(ButtonSave); + Name = "TeacherForm"; + Text = "Преподаватель"; + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private Button ButtonSave; + private Button ButtonCancel; + private Label labelSurname; + private Label label2; + private TextBox textBoxSurname; + private TextBox textBoxName; + } +} \ No newline at end of file diff --git a/Project/Project/Forms/TeacherForm.cs b/Project/Project/Forms/TeacherForm.cs new file mode 100644 index 0000000..d95d1e6 --- /dev/null +++ b/Project/Project/Forms/TeacherForm.cs @@ -0,0 +1,74 @@ +using Project.Entities; +using Project.Repositories; + +namespace Project.Forms; + +public partial class TeacherForm : Form +{ + + private readonly ITeacherRepository _teacherRepository; + private int? _teacherId; + + public int Id + { + set + { + try + { + var teacher = _teacherRepository.GetTeacherById(value); + if (teacher == null) + { + throw new InvalidDataException(nameof(teacher)); + } + textBoxSurname.Text = teacher.LastName; + textBoxName.Text = teacher.FirstName; + _teacherId = value; + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при получении данных", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + } + } + + public TeacherForm(ITeacherRepository teacherRepository) + { + InitializeComponent(); + _teacherRepository = teacherRepository ?? throw new ArgumentNullException(nameof(teacherRepository)); + } + + private void ButtonSave_Click(object sender, EventArgs e) + { + try + { + if (string.IsNullOrWhiteSpace(textBoxSurname.Text) || + string.IsNullOrWhiteSpace(textBoxName.Text)) + { + throw new Exception("Имеются незаполненные поля"); + } + + if (_teacherId.HasValue) + { + _teacherRepository.UpdateTeacher(CreateTeacher(_teacherId.Value)); + } + else + { + _teacherRepository.AddTeacher(CreateTeacher(0)); + } + + Close(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при сохранении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonCancel_Click(object sender, EventArgs e) => Close(); + + private Teacher CreateTeacher(int id) => Teacher.CreateOperation( + id, + textBoxName.Text, + textBoxSurname.Text); +} diff --git a/Project/Project/Forms/TeacherForm.resx b/Project/Project/Forms/TeacherForm.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/Project/Project/Forms/TeacherForm.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/Project/Project/Forms/TeachersListForm.Designer.cs b/Project/Project/Forms/TeachersListForm.Designer.cs new file mode 100644 index 0000000..89d0cda --- /dev/null +++ b/Project/Project/Forms/TeachersListForm.Designer.cs @@ -0,0 +1,125 @@ +namespace Project.Forms +{ + partial class TeachersListForm + { + /// + /// 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(); + ButtonDel = new Button(); + ButtonUpd = new Button(); + ButtonAdd = new Button(); + dataGridViewTeachers = new DataGridView(); + panel1.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)dataGridViewTeachers).BeginInit(); + SuspendLayout(); + // + // panel1 + // + panel1.Controls.Add(ButtonDel); + panel1.Controls.Add(ButtonUpd); + panel1.Controls.Add(ButtonAdd); + panel1.Dock = DockStyle.Right; + panel1.Location = new Point(836, 0); + panel1.Name = "panel1"; + panel1.Size = new Size(125, 431); + panel1.TabIndex = 0; + // + // ButtonDel + // + ButtonDel.BackgroundImage = Properties.Resources.Del; + ButtonDel.BackgroundImageLayout = ImageLayout.Stretch; + ButtonDel.Location = new Point(13, 266); + ButtonDel.Name = "ButtonDel"; + ButtonDel.Size = new Size(101, 100); + ButtonDel.TabIndex = 4; + ButtonDel.UseVisualStyleBackColor = true; + ButtonDel.Click += ButtonDel_Click; + // + // ButtonUpd + // + ButtonUpd.BackgroundImage = Properties.Resources.Upd; + ButtonUpd.BackgroundImageLayout = ImageLayout.Stretch; + ButtonUpd.Location = new Point(13, 160); + ButtonUpd.Name = "ButtonUpd"; + ButtonUpd.Size = new Size(100, 100); + ButtonUpd.TabIndex = 3; + ButtonUpd.UseVisualStyleBackColor = true; + ButtonUpd.Click += ButtonUpd_Click; + // + // ButtonAdd + // + ButtonAdd.BackgroundImage = Properties.Resources.Add; + ButtonAdd.BackgroundImageLayout = ImageLayout.Stretch; + ButtonAdd.Location = new Point(13, 54); + ButtonAdd.Name = "ButtonAdd"; + ButtonAdd.Size = new Size(100, 100); + ButtonAdd.TabIndex = 2; + ButtonAdd.UseVisualStyleBackColor = true; + ButtonAdd.Click += ButtonAdd_Click; + // + // dataGridViewTeachers + // + dataGridViewTeachers.AllowUserToAddRows = false; + dataGridViewTeachers.AllowUserToDeleteRows = false; + dataGridViewTeachers.AllowUserToResizeColumns = false; + dataGridViewTeachers.AllowUserToResizeRows = false; + dataGridViewTeachers.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill; + dataGridViewTeachers.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; + dataGridViewTeachers.Dock = DockStyle.Fill; + dataGridViewTeachers.Location = new Point(0, 0); + dataGridViewTeachers.MultiSelect = false; + dataGridViewTeachers.Name = "dataGridViewTeachers"; + dataGridViewTeachers.ReadOnly = true; + dataGridViewTeachers.RowHeadersVisible = false; + dataGridViewTeachers.SelectionMode = DataGridViewSelectionMode.FullRowSelect; + dataGridViewTeachers.Size = new Size(836, 431); + dataGridViewTeachers.TabIndex = 3; + // + // TeachersList + // + AutoScaleDimensions = new SizeF(7F, 15F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(961, 431); + Controls.Add(dataGridViewTeachers); + Controls.Add(panel1); + Name = "TeachersList"; + Text = "Преподаватели"; + Load += TeachersList_Load; + panel1.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)dataGridViewTeachers).EndInit(); + ResumeLayout(false); + } + + #endregion + + private Panel panel1; + private Button ButtonAdd; + private Button ButtonUpd; + private Button ButtonDel; + private DataGridView dataGridViewTeachers; + } +} \ No newline at end of file diff --git a/Project/Project/Forms/TeachersListForm.cs b/Project/Project/Forms/TeachersListForm.cs new file mode 100644 index 0000000..af840be --- /dev/null +++ b/Project/Project/Forms/TeachersListForm.cs @@ -0,0 +1,97 @@ +using Project.Repositories; +using Unity; + +namespace Project.Forms; + +public partial class TeachersListForm : Form +{ + private readonly IUnityContainer _container; + private readonly ITeacherRepository _teacherRepository; + + public TeachersListForm(IUnityContainer container, ITeacherRepository teacherRepository) + { + InitializeComponent(); + + _container = container ?? throw new ArgumentNullException(nameof(container)); + _teacherRepository = teacherRepository ?? throw new ArgumentNullException(nameof(teacherRepository)); + } + + private void TeachersList_Load(object sender, EventArgs e) + { + try + { + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при загрузке", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonAdd_Click(object sender, EventArgs e) + { + try + { + _container.Resolve().ShowDialog(); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при добавлении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonUpd_Click(object sender, EventArgs e) + { + if (!TryGetIdentifierFromSelectedRow(out var findId)) + { + return; + } + try + { + var form = _container.Resolve(); + form.Id = findId; + form.ShowDialog(); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при изменении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void ButtonDel_Click(object sender, EventArgs e) + { + if (!TryGetIdentifierFromSelectedRow(out var findId)) + { + return; + } + if (MessageBox.Show("Удалить запись?", "Удаление", MessageBoxButtons.YesNo) != DialogResult.Yes) + { + return; + } + try + { + _teacherRepository.DeleteTeacher(findId); + LoadList(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка при удалении", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void LoadList() => dataGridViewTeachers.DataSource = _teacherRepository.GetAllTeachers(); + + private bool TryGetIdentifierFromSelectedRow(out int id) + { + id = 0; + if (dataGridViewTeachers.SelectedRows.Count < 1) + { + MessageBox.Show("Нет выбранной записи", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error); + return false; + } + id = Convert.ToInt32(dataGridViewTeachers.SelectedRows[0].Cells["ID"].Value); + return true; + } +} diff --git a/Project/Project/Forms/TeachersListForm.resx b/Project/Project/Forms/TeachersListForm.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/Project/Project/Forms/TeachersListForm.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/Project/Project/Program.cs b/Project/Project/Program.cs new file mode 100644 index 0000000..3e2ab0a --- /dev/null +++ b/Project/Project/Program.cs @@ -0,0 +1,37 @@ +using Unity.Lifetime; +using Unity.Microsoft.Logging; +using Unity; +using Project.Repositories.Implementations; +using Project.Repositories; +using Project.Entities; + +namespace Project +{ + 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(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/Project/Project/Project.csproj b/Project/Project/Project.csproj new file mode 100644 index 0000000..0d16185 --- /dev/null +++ b/Project/Project/Project.csproj @@ -0,0 +1,41 @@ + + + + WinExe + net8.0-windows + enable + true + enable + + + + + + + + + + + + + + + + + + + + True + True + Resources.resx + + + + + + PublicResXFileCodeGenerator + Resources.Designer.cs + + + + \ No newline at end of file diff --git a/Project/Project/Properties/Resources.Designer.cs b/Project/Project/Properties/Resources.Designer.cs new file mode 100644 index 0000000..4c412ed --- /dev/null +++ b/Project/Project/Properties/Resources.Designer.cs @@ -0,0 +1,93 @@ +//------------------------------------------------------------------------------ +// +// Этот код создан программой. +// Исполняемая версия:4.0.30319.42000 +// +// Изменения в этом файле могут привести к неправильной работе и будут потеряны в случае +// повторной генерации кода. +// +//------------------------------------------------------------------------------ + +namespace Project.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()] + public 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)] + public static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Project.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Перезаписывает свойство CurrentUICulture текущего потока для всех + /// обращений к ресурсу с помощью этого класса ресурса со строгой типизацией. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + public static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Поиск локализованного ресурса типа System.Drawing.Bitmap. + /// + public static System.Drawing.Bitmap Add { + get { + object obj = ResourceManager.GetObject("Add", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Поиск локализованного ресурса типа System.Drawing.Bitmap. + /// + public static System.Drawing.Bitmap Del { + get { + object obj = ResourceManager.GetObject("Del", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Поиск локализованного ресурса типа System.Drawing.Bitmap. + /// + public static System.Drawing.Bitmap Upd { + get { + object obj = ResourceManager.GetObject("Upd", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + } +} diff --git a/Project/Project/Properties/Resources.resx b/Project/Project/Properties/Resources.resx new file mode 100644 index 0000000..9a48d6b --- /dev/null +++ b/Project/Project/Properties/Resources.resx @@ -0,0 +1,1231 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3YXJlAHd3dy5pbmtzY2FwZS5vcmeb7jwa + AAA2HUlEQVR4Xu3dCZxdZX3w8X/CFgKyBWWztVp2iKDWrS9KwACvIipWCiKLslux8W3VIL7WyGZQXOJS + pcU3NkWr0QqYNJlzzp2MYBJIiAQSkyiUkCBLCNk3kkwy5/0/d/7Qm/M8SWY598695/x+fL4EMpOZO+ee + +zz/mdxFiKjJmyN7SSxHqlPV2ZLI30ok1+h/j9Zfv6q//kD9VN2n/5+omfrfc9QT6im1KmOrSjPc72Xf + b7FyH2NO9WO6j+0+h/tckfyz/nqb+rz+t7ssF+ivZ0mbnKL/faR0yJ526YmIiMhrirxat9U36ab5Af31 + ev11rP56t/7aoRao5Sq7WbcKd9l/r9zX8u/KfW3X66Bwnv73qfq7h9pRICIiKlgTZQ/d8F5f/e44luvU + HboJ3qO/zlebVGjjLBN3DOZVj0kkX9f/vlYqMlKmyl/IGBlsR5GIiKiJcz/6dptXLKN0Q7tTf52uNqjQ + xofd26LcT0Em6nAwRn+9QNrkpOpQRURE1PDc38m7jSiRy3RTGqfcRr9RhTYx5M/dX8ENBhOUG7ZOk0ky + 1K4dIiKiHHLfbSYyXDeaq9Rdap7qVKGNCQOnUyJ5TH/9V/31SnUyf4VAREQ9b4ocoJvI+9StuvFPU+ts + g0HrWasqOgzcot4r98mr7FomIqLS5zaF7r+3H6vcj/JDD5FDMWxTC3Soc/fPuIBHIRARlamZsq9+N3iW + bgJf001grupSoc0CxbddPaJurw6BHTLEzhIiIipE3U9O456wxj2RzUsqtBkA7iGJ7iz5rBpuZw8REbVM + 7ju57h/ru3voL7XFHeitJdW/LnBPXMRPB4iImrSKDNOF+gp1ry7cPPYeeXPn1K/Ux6VNDrGzjoiIBiR3 + Jy73WPxEJunCzJ330CjuzoTuDqOjdBg4ws5GIiKqaxU5TDf8T+vi+1vl7sQVWqCBRnHDwP3qU9XXdSAi + ohxz99x3D9viO300t+6fDLhXR+Q5B4iI+ph7OdlI3q8L6s8VL5qDVuOeGvo/dGg9l9cuICLqSVPlON34 + 3Qu/cO99FMVzapxU5I12lhMRUTX349JErtaNf2Zm4QSKxv0VwZXSIfvb2U9EVMIiOV4XRPcUvKtqFkig + +NxrTLjnGHBPUkVEVIomyt66AF6gm797Vr7w4giUyxy9PVxTvbMrEVHhiuVIXeRu0V+X1yx8AP7HCzoW + 38xzCxBRMWqTN1d/1Mlz8AM9tUVNlIq8025FREQt0hgZrN/tf0QXsRk1ixqA3vutDtAfrt6miIiaNvf3 + ++6peWNZlFnEAPTPk2oUL0pERM2VexifW5xiecYWKwD1sUzc82R0yEF26yMiGoDcq6K5Oy3FsiazSAGo + r9XqKzJZDrZbIxFRA+p+6V33bH1uEQotTgAaY70aWx3GiYjqlnv53e6Nn+/4gebiBgH3dMOH2a2ViCiH + 3NOWxjJasfEDza37JwKJHGi3XiKiPuTu1e+eoczd8Si82ABoTivUaB41QES9y70Ur3txnlj+VLOgAGg9 + S3WIv4KXJCai3VeRkbpozMssIgBa2yIdBN5rt3IiopoqcqIuEv+VWTQAFEkik6Rd/tJu9URU6trlKF0Y + xqvtOywUAIpqs7pdpsgBtgoQUamaI3vpIjBKvyNYV7MwACgPd0fBUdw/gKhMxfIetcAWAQDl9ohE8m5b + HYiokLm/+3MvMxpeBACUmbt/QCSvt9WCiApR94/7b1S8Jj+AXdmkPl99KDARtXixnKrm2I0bAHYvksek + Im+1VYSIWqqZsq/ekMeqbTvcsAGgZzrVOB0G9rNVhYiaPneHnlj+WHNDBoC+erL6BGFE1MR1yEGSyJ16 + g+3K3IABoL8m6iAwzFYbImqaIjlPb6DPZG6wAJCnZfpNxmW26hDRgOaeyc89fCd8YwWA/EVyr7TJEbYK + EVHDi+V85Z7NK3wjBYD6Wa2DwEW2GhFRQ+q+h/+4zI0RAAbCBOmQ/W11IqK6FctfKe7hD6CZLJaKvNNW + KSLKtVQG6Y1slNpSc6MDgGbRKZGM4cWFiPIskT/XG9dvMjc2AGg+kcxUvKYAUb+L5CN6o1rp3cgAoHmt + 0bXrY7aKEVGvmiIH6I1oQuZGBQCtZDx3ECTqTVPlOL3h8Hr9AIrgj9ImJ9nqRkQ7LZYPqDU1Nx4AaG2J + rKv+dSYRBXL3nO1+9T6exx9AEbm1bZx0yJ626hGR3iAO1RuG+yd0owGAIvmNVOQwW/2ISlybvFlvEE9l + biAAUGR/kkjebqsgUQlzr6oVy6bMDQMAymCzroFX22pIVJKmyD46/f5L4AYBAGUzofr6JkSFL5Yj1eya + kx8Ayu4h6ZDDbZUkKmCRnKwn+tLMiQ8AiOUZdaqtlkQFqiIj9eTm8f1omEHxoHT4zOHp1QuuTu9Yckc6 + afmkdNGGRemyLcvS9dvWpy/n/tv9nnube5+vL/l69c+cPPPk6scIfWygLrqfL+C9tmoSFaBEPqEn91bv + ZAdytl/7fuml8y9Nf77s5+kLW16wLb7vuY/xs+d/ll4y/5J0aPvQ4OcEctaprrXVk6hFcy/h614eM3yS + A7l556x3puOfHZ+u61xnW3f+uY/tPsc7Zr0jeBmAnI3Tfw+y1ZSohXL39E/k7sBJDeTmtNmnVX9s3+im + r56enjf3vOBlAnI0UTpkiK2qRC1QmxyiJy6v34+6OWHGCem0ldNsOx64Kisr6fEzjg9eRiAnM6rPlkrU + 9FXkDXrCLsqcwEAu9q3sm962+LZ0y/YttgUPfO6y3Lr41nRIZUjwMgM5eEIdY6ssURPWJm/Tk3R5zUkL + 5ObY6cemj6571Lbd5mvBhgXpSTNPCl52IAfLJJK32GpL1EQlMkJP0LWZExbIxcXzLt7hoXvNmruj4EXz + Lgp+DUAO1us3WmfYqkvUBEVynp6YL2VOVCAXox8fnXbpP62Su6xjnhwT/FqAHGxUZ9vqSzSAxXKJco9b + DZ2oQJ+5J+FxT8rTqn3n6e+kg5PBwa8N6Kct6nxbhYkGoEj+j56EXTUnJZCbby39lm2lrdv3n/5+8GsD + crBV1+ALbTUmamCRfC5wQgK5+NJ/f8m20NbvxiduDH6NQA626Vp8pa3KRA0oltGZkxDIzeW/v9y2zmLk + 7hPgnko49LUCOeiSRD5jqzNRHeOpfVFH7mF0G7dttK2zOG3YtiE9ccaJwa8ZyEUiX7ZVmqgOJXJz8MQD + cuBeyMc9lr6o/X7973lBIdTbWFutiXIsllszJxqQq28v/bZtlcXtG0u+EfzagRzdZKs2UQ7xnT/qzL1u + f2dXp22Txc19jac8eErwGAC5SeQGW72J+lEs/+SdXECO3OP9H1zzoG2Rxc+9kqD7mkPHAsjRP9gqTtSH + YvnHzAkF5O78R8+3rbE88VLCaAD36ICrbTUn6kXuYSXhkwrI1ey1s21bLE+z1swKHgsgZ+55AniyIOpF + sVyqeIY/1N05vzvHtsTyddbvzgoeEyBn7hkDz7PVnWgXJfJBPWF4bn80xL3L77XtsHz98oVfBo8JUAdb + dAh4r63yRIEiOVNPFF7VDw0xrGNYumX7FtsOy5f72t0xCB0boA426hr/blvtiWpqk7fpCbI+c8IAdfPp + RZ+2rbC8fXLhJ4PHBqiTNToEvMVWfSItktfrifFC5kQB6qqysmLbYHlrW9EWPDZAHb2o3/Adbas/lbo2 + OUQS+UPgJAHqZp/KPumm7ZtsGyxv7nUP3LEIHSOgjhbJZDnYdgEqZRNlbz0R2jMnBlB3Z8w5w7ZAetfD + 7woeI6DO7pcpso/tBlSqUhmkJ8CEzAkBNIR7jXzq7obHbwgeI6AB/kP/Pch2BSpNvLgPBtCE5ybY9kfj + nx0fPEZAQ7iXeKcSFckVwRMBaJAyPvvfznKvgxA6RkCDdOmecLntDlToEhmhV/iWzAkANNSqrats+6OV + W1cGjxHQQFulIiNtl6BCVpET9YpenbnigYYanAxOu/Qf6m571/bqMQkdK6CB1uo3iMNtt6BC1SZH6BW8 + NHOFAw13wLQDbOujl9u/ff/gsQIa7CnpkMNt16BC1CFD9IqdnbmigQFx1P1H2bZHL3fE/UcEjxUwAB7k + 4YFFKpa7MlcwMGDe8Ns32LZHL+eOSehYAQPkh7Z7UEsXyTWBKxcYMAwAfgwAaDqRXGm7CLVk3S/ws9m7 + YoEBxADgxwCAJuReGfavbDehlqoiw/TKe6rmygSaAgOAHwMAmtRS6ZBDbVehlmii7KFXXJS5IoGmwADg + xwCAJlap7inUIkXy9cCVCDQFBgA/BgA0uVttd6GmLpIP6ZXVlbnygKbBAODHAIAm554u+CO2y1BTNlWO + 0ytqbeaKA5oKA4AfAwCaXiLrqs8mS03YFDlAr6A/BK84oIkwAPgxAKBFLJAO2d92HWqaeG1/tAgGAD8G + ALSQu2zXoabI/d1M+IoCmg4DgB8DAFpKJBfa7kMD2hR5rV4hK70rCGhSDAB+DABoMaslkT+3XYgGpDEy + WK+EaYErB2haDAB+DABoQffz/AADWSJfDFwpQFNjAPBjAECL+rztRtTQInmLHvwtmSsDaHoMAH4MAGhR + W6uvOUMNLJL9eMgfWhUDgB8DAFrYEzw0sJHx+v5oYQwAfgwAaHE/sN2J6los52cOPNBSGAD8GADQ8hL5 + oO1SVJfa5Sg90Cu8Aw+0EAYAPwYAFMCL0iZH2G5FuRfJvYGDDrQUBgA/BgAUxGTbrSjXIrkocLCBlsMA + 4McAgMJI5GLbtSiX2uQQPbDLvAMNtCAGAD8GABTICqnIYbZ7Ub+L5ceZAwy0LAYAPwYAFIr762rKoTY5 + Qw9ol3eAgRbFAODHAIDCcS9SR/1okgzVg/jfwYMLtCgGAD8GABTQMpksB9tuRr0ulm9kDijQ8hgA/BgA + UFA8QVCfqshb9eBtyxxMoOUxAPgxAKCgtkskf227GvWoDtlTD9wjmQMJFAIDgB8DAApsvsyRvWx3o90W + y42ZAwgUBgOAHwMACm607W60y9rlL/VgvZQ5eEBhMAD4MQCg4Dbq3vY62+Vop8Xy68yBAwqFAcCPAQAl + 8Avb5ShYLGdnDhhQOAwAfgwAKIVEzrHdjnZoouytB+cPwYMGFAgDgB8DAEpiIXcIDBXJFwIHCygcBgA/ + BgCUyD/YrkfVul/nf33mIAGFxADgxwCAElnLiwXVxov9oEQYAPwYAFAqidxpu1/Ja5NT9IBs9w4QUFAM + AH4MACiZbToEDLddsMRFehjCBwgoJAYAPwYAlFC77YIlLZL3Bw4KUGgMAH4MACil0j4ssPv5/hd6BwQo + OAYAPwYAlNR8mSh72K5YoiK5JnAwgMJjAPBjAECJfdx2xZLUIUP0i346cxCAUmAA8GMAQIktkSmyj+2O + JSiRzwYOAlAKDAB+DAAotUj+3nbHgnefvEq/4Be8AwCUBAOAHwMASm55dW8sfIncHPjigdJgAPBjAEDp + RfJ/bZcsaB1yqA4A64JfPFASDAB+DACArJHJcrDtlgUslrGZLxgoHQYAPwYAoOortlsWrIoM47t/gAEg + FAMAULW2mD8FiOW2zBcKlBIDgB8DAGAiGWO7ZkFqk0P47h/oxgDgxwAAvKJg9wWI5JbAFwmUEgOAHwMA + UCORL9vu2eJNkQP0C1rtfYFASTEA+DEAADtYJR2yv+2iLVwiNwS+OKC0GAD8GACAjEQ+bbtoi+ae3ziW + 57wvDCgxBgA/BgDAs7j6qrktWyzXZr4goPQYAPwYAICgC2w3bbHcaxzH8njmiwFKjwHAjwEACJptO2qL + FclHAl8MUHoMAH4MAMBOJHKa7aotVCQzg18MUHIMAH4MAMBOJHKP7aotUiRvCX4hABgAAjEAADvVpUPA + Cba7tkCR/CTwRQBQDAB+DADALv3AdtcmL5Yj1ZaaCw6gBgOAHwMAsEsvSUUOs122iYvl1swFB1CDAcCP + AQDYjaZ/euDuJ/5Z7l1wAK9gAPBjAAB264XqHtu0xXJJ5gIDyGAA8GMAAHrko7bbNmGxzMhcWAAZDAB+ + DABAj9xvu22TVZE3Bi4sgAwGAD8GAKCHIjnZdt0myj1MIXRhAeyAAcCPAQDosXG26zZJ7nWLY1mbuZAA + AhgA/BgAgB5bI5HsZ7tvE5TI1YELCSCAAcCPAQDolY/b7tsExfJg5sIB2AkGAD8GAKBXmuTOgFPlOL0w + XZkLB2AnGAD8GACAXumSNjnaduEBLJGvBS4cgJ1gAPBjAAB6KZJbbBceoDpkT70gz3kXDMBOMQD4MQAA + vfaMTJQ9bDcegCI5L3ChAOwCA4AfAwDQB4mcY7vxABTr/BG6UAB2igHAjwEA6INE7rbduMHdJ6/SC7DJ + u0AAdokBwI8BAOiTDdXn4Wl4kVweuDAAdoMBwI8BAOizAXiBoFhHgPCFAbALDAB+DABAn/3aduUGFclr + 9JN2Zi4EgB5gAPBjAAD6bKtUZJjtzg0okr8PXAgAPcAA4McAAPTLdbY7N6BYpmc+OYAeYgDwYwAA+qXd + duc61yGH6yfbnvnkAHqIAcCPAQDol23Vv5qve5H8XeCTA+ghBgA/BgCg366yXbqOuR81hD85gB5gAPBj + AAD6KZKptkvXKXdPQ+79D/QLA4AfAwDQb1tlshxsu3UdSuQTgU8KoBcYAPwYAIBcXGq7dR2K5b7MJwPQ + SwwAfgwAQC5+Ybt1zk2RffSDr898MgC9xADgxwAA5GJ9da/OvVjel/lEAPqAAcCPAQDISUVG2q6dY5H8 + c/CTAegVBgA/BgAgJ5F8y3btHItlifeJAPQaA4AfAwCQmydt186pirwx8EkA9AEDgB8DAJCjSI633TuH + Yvm89wkA9AkDgB8DAJCjRD5ju3cORfrhQp8EQK8xAPgxAAC5+i/bvftZhwzRD7Yp88EB9BEDgB8DAJCr + Dfk8HDCWszMfGEA/MAD4MQAAOUtkhO3i/SiSrwc/OIA+YQDwYwAAcner7eL9KJZHMx8UQD8wAPgxAAC5 + m227eB9rk0P0g2zPfFAA/cAA4McAAORuu3TIQbab96FIPhT4oAD6gQHAjwEAqINEzrXdvA8l8s3gBwXQ + ZwwAfgwAQF3cbrt5H0rkd4EPCKAfGAD8GACAunjIdvNeNkUO0D+8LfPBAPQTA4AfAwBQF51yn7zKdvVe + xMv/AnXBAODHAADUSSRn2a7ei2K5zftAAPqNAcCPAQCom5tsV+9FiUwLfCAA/cQA4McAANRNZLt6Dxsj + g/UPrc18EAA5YADwYwAA6mZNdU/vcRV5Y+CDAMgBA4AfAwBQRxU50Xb3HpTI1cEPAqDfGAD8GACAOork + Ctvde1Asd3kfAEAuGAD8GACAOkrkTtvde1As87wPACAXDAB+DABAXT1qu/tu6pAh+s6dmT8MICcMAH4M + AEBdba3u7butTd4W+MMAcsIA4McAANRZm7zZdvldFMu13h8EkBsGAD8GAKDOIrnSdvldFMsPvT8IIDcM + AH4MAEDdfc92+V0Uy+zMHwKQIwYAPwYAoO5m2C6/kybKHvpOmzJ/CECOGAD8GACAulu/62cErMixgT8E + IEcMAH4MAEADRPJ62+0DxXK+9wcA5IoBwI8BAGiASN5vu32gRL4Y/EMAcsMA4McAADTE5223DxTJTwJ/ + AECOGAD8GACAhvix7faBYpmbeWcAOWMA8GMAABpitu32mdy9A3kEAFB3DAB+DABAQ6zXfw+yXb8md+/A + 8B8AkCMGAD8GAKBBpshrbdevKZKzgu8MIFcMAH4MAECDJDLCdv2aEvlk8J0B5IoBwI8BAGiYq2zXrymW + OzLvBKAOGAD8GACABonkq7br1xTJvcF3Rq4OmnZQetT9R1UXPJTT6Q+fbtsevZw7JqFjhXJwa+KB0w4M + rpnI3S9s168plt9n3gl9tE9ln3TEwyPSG5+4MZ3w3IR09trZ6erO1bbUERHRzlq1dVU6a82s6trp1lA3 + HLo1NbTWok/m2q5vuYcFxLIx807ohUM7Dk0/vejTaWVlJd20fZOdykRE1N/cmpqsTNLrF12fDusYFlyD + 0UOJrLOd35oirw6+I3brnN+dk967/N50y/YtdqoSEVG9cmvtPS/ck579u7ODazJ6YLIcbLu/1iZvDr4T + ggbFg9Lz5p5X/TEVERENTI+uezS9bP5l6eBkcHCtxk5U5I22+2uJfDD4TvCc8uAp6cw1M+30IyKigW7O + 2jnpWx96a3DNRkAi59ruryVyffCd8Ir92vdLv7302+m2rm12yhERUbPU2dWZfmvpt9Kh7UODazhquOf9 + eaVYbvfeAa84fsbx6bz18+w0IyKiZm3RhkXp8JnDg2s5XnGb7f4aLwO8U5f//vJ047aNdmoREVGzt2Hb + hvTS+ZcG13RU/bvt/losHZk3Qo1+fHTapf8QEVFr5dbuMU+OCa7tkIrt/losCzNvLDV3j9LvPP0dO42I + iKhVG7d0XPWRW6G1vsTm2+6vxbIy88ZS++aSb9qpQ0RErd73nv5ecK0vsRe6N/85spf+T1fmjaX1xSe+ + aKcMEREVJfdXuqE1v6S2S4fsKdIuRwXeWEoXz7uYv/MnIipgbm2/cN6FwbW/lCpymHsOgDcF31gyx0w/ + Jl3budZOFSIiKlrrt62vPqw7tAeUTvXZAGM523tDyexb2Td9bP1jdooQEVFRm7tubjqkMiS4F5TMe9xz + AFwYeEOp3Lb4Njs1iIio6N305E3BvaBUEvkb9xOAa703lMix049NN2/fbKcFEREVPfeKgvxVgFzl7gNw + Q+ANpTFt5TQ7JYiIqCzFK+LgnlAaiXzW/RXAV4NvLIGRc0baqUBERGVrxMMjgntDKSRys/srgB94byiJ + jlUddhoQEVHZSlYmwb2hJL7nBoCfZn6zFN456512ChARUVl7+6y3B/eIwkvkbjcA/Np7QwmMf3a8Xf1E + RFTW7nrmruAeUXiJ3OMGgIr3hoLbr32/dF3nOrv6iYiorLkngBvaPjS4VxRc5AaAGZnfLLxL5l9iVz0R + EZW9j877aHCvKLREHnADwFzvDQX382U/t6udiIjK3k+e/0lwryi4OW4A+GPmNwvNvS70si3L7GonIqKy + 5/YEtzeE9owCW+gGgKczv1low2cOt6uciIiouxNnnBjcMwrsKTcALM/8ZqFdveBqu7qJiIi6u3LBlcE9 + o8CWuQFgVeY3C+2OJXfY1U1ERNTd7U/dHtwzCmyFey2AdYE3FNbkFyfb1U1ERNTdfcvvC+4ZBbba/QRg + Y+Y3C23RhkV2dRMREXW3YMOC4J5RYOvdALA585uFxiMAiIgo23ObnwvuGQW2yQ0AnZnfLLSN2zba1U1E + RNTd+m3rg3tGgW11A0BX5jcLa3AyOO3Sf4iIiGpze8MeyR7BvaOgtjMAEBFR6SvrAMBfARARUakr618B + cCdAIiIqdWW9EyAPAyQiolJXzocBluyJgCYtn2RXNxERUXf3Lr83uGcUWPWJgHgqYCIiKnXlfCrgkr0Y + 0FULrrKrm4iIqLsrFlwR3DMKrPpiQLwcMBERlboTZpwQ3DMKrPpywH/M/GahDYoH8UgAIiJ6JfcIALc3 + hPaMAlvoBoC5md8svJ89/zO72omIqOzd/dzdwb2i4Oa4AWBG5jcL72PzP2ZXOxERlb2L5l0U3CsKLZEH + 3ABQ8d5QcEPbh6brOtfZVU9ERGVtbefa6p4Q2isKLnIDwK8zv1kK458db1c/ERGVtX995l+De0ThJXKP + GwB+6r2hBN4x6x129RMRUVl726y3BfeIwkvkbpFI/jn4xhJoX9lupwAREZWtaEUU3BtKIZLvuJ8A3Oa9 + oSTOnHOmnQZERFS23v3wu4N7Q0nc5AaAz2d+s1QqKyt2KhARUVlqW9EW3BNK5B/dXwFcE3hDaRwz/Zh0 + 8/bNdkoQEVHRc2v+cTOOC+4JpRHJFe7VAP82+MYSuXXxrXZaEBFR0fvKk18J7gWlksiH3U8Azgq+sUSG + VIakj6571E4NIiIqao+se6S65of2gpJ5j7sPwKmZ3yylo6cfXX1CCCIiKmbrt63nR/8vi+RkkTY5IvjG + EnJPB9ml/xARUbFya/sFj10QXPtLKZLXiHTInvo/2703ltQNj99gpwsRERWlzz3+ueCaX1LbZKLsIdVi + eTHzxlL7xpJv2ClDRESt3nef/m5wrS+xZd2bvyuWBZk3lpp7XehxS8fZqUNERK3at5d+u4yv9b9rkTxm + u7+WyLTgO5XcqD+M4j4BREQtmFu7xzw5Jri2l16ku/4rRfKT4DshvWT+JemGbRvslCIiombP3dv/4nkX + B9d0VE2w3V+LZWzmjahx/Izj08fWP2anFhERNWsLNyxMT555cnAth4nkFtv9tVg+5b0DdjC0fWj1zoGd + XZ12mhERUbO0tWtreseSO9J9K/sG13Ds4Frb/bVYPpB5I3bijTPfmE5fPd1OOSIiGugeWPVAOnzm8OCa + jaD32e6vJfKmwDtgF0bOGZk+uOZBO/2IiKjRuaf1dU/uw738e6n6LIAvV5FhwXfCbp31u7PS/3zhP3lF + QSKiBuTW2l++8MvqN2GhNRk9kMiBtvtbsWz03gk9dkjHIeknF36y+hrTPGqAiCi/3Jo6dcXU9LqF16UH + dxwcXIPRY2tt168plvmZd0If7V3ZO333w+9Ov/DEF9IfP/vj9KE1D6Uvbn3RTmUiItpZbq10f706/tnx + 1admf9fD76quqaG1Fn3yiO36NSVyT+AdkbMDph2QHnn/kekbfvsGlNTpD59uSx29nDsmoWOFcnBrolsb + Q2smcjfRdv2aIvl64B0B5MwteLRj7piEjhWA3N1mu35NsVyXeScAdcAA4McAADRIJFfarl9TJGcF3xlA + rhgA/BgAgAZJZITt+jVF8vrgOwPIFQOAHwMA0CBT5LW269c0RgbrGzd57wwgVwwAfgwAQEOs138Psl0/ + k3t4QPgPAcgJA4AfAwDQELNstw+UyN2BPwAgRwwAfgwAQEOMt90+UCw3Zt4ZQM4YAPwYAIAGiORzttsH + iuRDwT8EIDcMAH4MAEADJHKu7faBKnJs8A8ByA0DgB8DANAA7tF+O22i7KHvxIsCAXXEAODHAADU3frq + o/12WSwPZf4QgBwxAPgxAAB191vb5XdRLD/I/CEAOWIA8GMAAOosku/YLr+LIrkm+IcB5IIBwI8BAKiz + SK6wXX4XxfJX3h8EkBsGAD8GAKDOEnmT7fK7aIrso++81fvDAHLBAODHAADU1Zbq3t6jInks8AEA5IAB + wI8BAKiruba796BI/iXwAQDkgAHAjwEAqKsf2O7egyK5MvABAOSAAcCPAQCoq4/b7t6DIjk58AEA5IAB + wI8BAKijSI633b0HuWcLimWN90EA9BsDgB8DAFA3q3f/DIDZYqlkPgiAHDAA+DEAAHUSyVTb1XtRJLcE + PxiAfmEA8GMAAOok0u//e10k7w1+MAD9wgDgxwAA1ElFRtqu3ovuk1fpH+70PhiAfmEA8GMAAOpiq34z + v5/t6r0sloczHwxAPzEA+DEAAHUQyUzbzftQLN/wPiCAfmEA8GMAAOpirO3mfSiRDwY+IIB+YADwYwAA + 6uJ9tpv3oTY5RD/A9swHBNAPDAB+DABA7rZJhxxku3kfi+WRzAcF0A8MAH4MAEDuZtku3o9iuT3zQQH0 + AwOAHwMAkDP3XD79zj2GMPTBAfQJA4AfAwCQu9NtF+9HHTJEP9CmzAcG0EcMAH4MAECuNsgU2cd28X4W + V/8JfRIAvcQA4McAAOQokUm2e+dQJJ8LfhIAvcYA4McAAOQokr+33TuHIjk5+EkA9BoDgB8DAJCjqXKc + 7d45Fcti75MA6DUGAD8GACAnkfy37do5Fst3vU8EoNcYAPwYAIDcfMN27RyryP8OfCIAvcQA4McAAOQk + kjNt184x95CCRNYFPyGAHmMA8GMAAHKxVibK3rZr51wsv8p8MgC9xADgxwAA5OLntlvXoVg+nvlkAHqJ + AcCPAQDIxSW2W9ch98pCsWzJfEIAvcAA4McAAPTbFpksB9tuXad4VkCgXxgA/BgAgH6bbLt0HYvl2swn + BdALDAB+DABAPyXyCdul61hFDtNPts375AB6hAHAjwEA6JdO6ZBDbZeuc7Hcn/nkAHqIAcCPAQDol9h2 + 5waUyPWZTw6ghxgA/BgAgH6I5BrbnRvQFHm1ftJO70IA2C0GAD8GAKDPtkhFhtnu3KAimRq4IAB2gwHA + jwEA6KNI7rVduYHFcql3QQDsFgOAHwMA0EeRXGi7cgOLZD/95Bu8CwNglxgA/BgAgD7ZUN2LB6REfha4 + QAB2gQHAjwEA6JMJthsPQImcG7hAAHaBAcCPAQDog0jOst14AJooe+iF+JN3oQDsFAOAHwMA0Gt/qu7B + A1osYzMXCsAuMAD4MQAAvXaT7cIDWEWO1QvSlblgAHaCAcCPAQDolS5pl7+0XXiAi2VG5sIB2AkGAD8G + AKBXOmz3bYIiuTJwAQEEMAD4MQAAvZDIZbb7NkEdsr9eqLXehQTgYQDwYwAAemy1TJKhtvs2SYl8P3BB + AWQwAPgxAAA99m3bdZuoipyoF4w7AwK7wQDgxwAA9FCbnGS7bpMVy2+9CwtgBwwAfgwAQI800Z3/skXy + scAFBlCDAcCPAQDogQF54Z+eNkX20Qu53LvQAF7BAODHAADs1jKZKHvbbtukuWcnCl94AIoBwI8BANiN + RL5su2wT1yZH6IXd4l14AFUMAH4MAMAubZYOOdx22SYvln/PXHgAhgHAjwEA2KX/Z7trC9Qmbw58AQAU + A4AfAwCwS6fa7toi8ZBAIIgBwI8BANipdttVW6hEPhz4QoDSYwDwYwAAdiKS82xXbaHGyGC98Au8LwYo + OQYAPwYAIGhhdS9tyXiVQMDDAODHAAAENNWr/vW2ObKXfhFPe18UUGIMAH4MAIDnT83/xD+7K5HPBr4w + oLQYAPwYAADPKNtFW7j75FX6hazKfGFAaTEA+DEAADtYKR2yv+2iLV4sX8l8cUBpMQD4MQAAO/iS7Z4F + KJED9QtanfkCgVJiAPBjAABesUa/+z/Ids+ClMjNgS8UKB0GAD8GAOAV/2S7ZoFyEw0/BQAYAAIxAABV + Bfzu/+ViuTXzxQKlwwDgxwAAqJZ4yd++VpFh+kWu9b5ooEQYAPwYAABZVdzv/l/OTTjhLx4oBQYAPwYA + lF4kX7BdssC5xzbGssz74oGSYADwYwBAyb1Qfc6cUpTIZwIHACgFBgA/BgCU3KdsdyxB7vmNY1mcOQBA + KTAA+DEAoMSekimyj+2OJSmSKwIHAig8BgA/BgCUVku/4l9fmyh76BDwWPCAAAXGAODHAICSmlvdC0tZ + m5wROCBAoTEA+DEAoKROt92wpCVyT+CgAIXFAODHAIAS+rntgiWuIm/QA7E5c2CAwmIA8GMAQMm8JFPl + L2wXLHmx3J45OEBhMQD4MQCgVNyL45HlngAhlue8gwQUEAOAHwMASuSZ6hPiUU2RXBk4UEDhMAD4MQCg + RC6xXY9eaYwM1gMzO3OggMJhAPBjAEBJPKT/HmS7Hu1QJH+tB6grc8CAQmEA8GMAQAl0SSKn2W5HwdxD + I8IHDygEBgA/BgCUwATb5Wintcvr9EBtyhw4oDAYAPwYAFBw63VvO8p2OdplsYzOHDygMBgA/BgAUGju + FXCph3XInnrQ5ngHESgABgA/BgAU2OzyPt9/X2uTU/TAbc0cSKDlMQD4MQCgoDr1u/832a5GvYpnCEQB + MQD4MQCgkHjGv340U/bVg/iEd1CBFsYA4McAgAL6o3TIENvNqE8lMkIPJM8NgMJgAPBjAEDBdEkkZ9ou + Rv0qkR8FDjDQkhgA/BgAUDA/sN2L+l0iB+oBfSZzgIGWxADgxwCAAnlOOuQg270ol2K5IHOQgZbEAODH + AIACOd92Lcq1RO4JHGygpTAA+DEAoCB+YbsV5V6bHKEH+MXMAQdaCgOAHwMACuAFqchhtltRXUrkg4ED + D7QMBgA/BgC0OHev//Nsl6K6lsidgSsAaAkMAH4MAGhx37PdiereJBmqB3xR5goAWgIDgB8DAFrYwuqe + RA2sTd6sB35L5ooAmh4DgB8DAFrUZnWq7UrU0BK5IXNlAE2PAcCPAQAt6h9sN6KGN0YG6xXQnrlCgKbG + AODHAIAWFFf3IBrA2uUovRpW1lwpQFNjAPBjAECLWSWR/JntQjSgJfLhwBUENCUGAD8GALSYC2z3oaYo + lvGZKwhoSgwAfgwAaBnuYejUZHXI/nrlLPCuLKDJMAD4MQCgRcyTSPazXYeaqoocq1fQmswVBjQVBgA/ + BgC0gNXSJkfbbkNNWSwfUF01VxrQVBgA/BgA0OTcnsKr/LVEsdxWc8UBTYUBwI8BAE3uK7a7UNPnHpsZ + ydTAlQgMOAYAPwYANLFYJsoetrtQS9Qmh+jVtrjmSgSaAgOAHwMAmtQS6ZBDbVehlso9R3Msm2quTGDA + MQD4MQCgCb0kkbzFdhNqyWK5NHOlAgOKAcCPAQBNJ5FP2C5CLV0sP/SuXGCAMAD4MQCgyXzXdg9q+abI + PnqFPpS5goEBcdT9R9m2Ry93xP1HBI8VMABmyETZ23YPKkQdcrhesUsyVzTQcAdMO8C2PXq5/dv3Dx4r + oMEWS0UOs12DClUiJ+gVvCpzhQMNNTgZnHbpP9Td9q7t6aB4UPBYAQ20RiI52XYLKmSxnK4211zpQMOt + 2rrKtj9asXVF8BgBDbRVvcd2CSp0sXxU8XTBGDCz1syy7Y9mrpkZPEZAg3RJIpfZ7kClyD21Y/hkAOpu + wnMTbPuj8c+ODx4joEG+ZLsClaZUBkkk/xY4GYC6u/GJG237oxsevyF4jIAG+Kn+e5DtClSq5sheegJU + MicEUHcjHh5h2x+dNvu04DEC6uw31YeIU4lL5EA9EeZnTgygrvau7J1u3LbRtsDy5o6BOxahYwTU0QKZ + LAfbLkClbqr8hZ4QyzInCFBXlZUV2wbL29QVU4PHBqibSJ6Xdnmdrf5EmnvRB/c40NAJA9TB9Yuut22w + vF238LrgsQHqZLU61VZ9opoq8k49OdbXnCxA3RzScUi6eftm2wrL15btW9JhHcOCxwaog43SJu+y1Z4o + kHsyCPcykOETCMjVPS/cY9th+frFsl8EjwlQB5t08z/DVnmiXZTIOXrC8GyBqLuzf3e2bYfla+SckcFj + AuRsq0TyflvdiXpQIh/WE6czcyIBuZu9drZtieXpoTUPBY8FkLNtuvlfZKs6US+K5HI9gbZnTiggVx96 + 9EO2LZancx85N3gsgBy5p3u/ylZzoj4Uy6dqTiggd+6V8GasnmFbY/F7YNUDvPof6q1Lv4H7O1vFifpR + Ip8JnGBAbobPHJ5u7dpqW2Rx6+zqTE958JTgMQByNNpWb6IcSuTmwEkG5OZbS79l22Rxu2PJHcGvHchN + JGNs1SbKMTdVhk44IAf7VvZNH133qG2VxWv++vnp0Pahwa8dyMlYW62J6lAsn8+ccEBujp1+bLquc51t + mcVpw7YN6QkzTgh+zUBOeFlfakCxXKd4dADq4tL5l6Zd+k9Rcl/LxfMuDn6tQA7cvf1H2epM1IAi+Zie + dDxPAOrixidutO2z9Rv9+Ojg1wjkYJsk8glblYkaWCJ/qyfg1swJCeTim0u+aVto6/b9p78f/NqAHGzR + b8Q+Yqsx0QCUyLl6Im7KnJhAv7nHyn/tqa/ZVtp6jVs6Lh2cDA5+bUA/bda194O2ChMNYLGcrifjuswJ + CuRi1B9GtdR9AtxlHfPkmODXAuRgg1RkpK2+RE1QRd6qJ+bKzIkK5OLCeRe2xKMD1nauTS947ILg1wDk + YLVE8te26hI1UZG8RU/QZZkTFsjFMdOPSeeum2tbbfP1yLpH0qOnHx287EC/RfK8JPImW22JmrBIXq8n + 60Lv5AVyMKQyJL35yZvTzds327Y78LnLctOTN1UvW+gyAzn4vbTL62yVJWriJsvBOqlOC5zEQC7cEwbF + K2LbggeuthVt1Z9MhC4jkJN26ZCDbHUlaoEmyt4Syb8FTmYgN6fNPi2dtHySbceNa/rq6enIOSODlwnI + 0fjqWkrUcqUySIeAMXoSu2eqCp3cQC7ePuvt6Y+e+VH1Tnj1ak3nmvSuZ+5K3zbrbcHLAOTIvZzvGP2v + QbaaErVokVyuJ/SWzAkO5M69oNBH5300/cnzP0mf3/K8bd1977nNz6V3P3d3etG8i6ofO/Q5gZy5tfJS + Wz2JClAkZ+pJvbrmJAfq7qSZJ6VXLriy+oRC9y2/L124YWF1U699SKH7b/d77m33Lr83vf2p29MrFlyR + njjjxODHBOpolSQywlZNogJVkRP1BH8qc8IDAGJZrJv/CbZaEhWwDjlcT/QHMyc+AJTZDInkNbZKEhW4 + DtlTT/ixmRsAAJRPIndyT38qX7FcojbucGMAgHJ4Sb/rv8JWQ6ISFsupanHNjQIAim5p9fVTiEpfRYbp + DaItcwMBgCKaoqvdIbb6EZHeLAbpDWO02l5zQwGAonBPiDZWxshgW/WIaIcieb/eSHi+AABFsladb6sc + Ee20WI5R8+2GAwCtbBGP7yfqTR2yv95ofhS4MQFAa4jkX9R+tqoRUa9K5MN6Q1rh3bAAoHmt1o3/IlvF + iKjPuWcPjGRq4EYGAM2mIu1ylK1eRNTvuh8lMEptrrmhAUCz2KrfqIzhXv5E9SqSk/WGNi9zwwOAgbRQ + EnmTrVJEVLdmyr56gxun3ONqQzdGAGiUCdzRj6jRJXKO3vCeD9wgAaDeluv6c56tRkTU8NrkCL0h3pe5 + YQJA/UTyS6nIYbYKEdGAFssF6sUdbqQAkCf3E8dIPmKrDhE1TZG8Rm+kE7wbLQD0j7u/0QRexIeo2XMT + OvcNAJCHRP6g68m7bXUhoqYvkQP1xuseKbBthxszAPRMpxorHTLEVhUiaqna5M16I55Tc6MGgN15RL/r + f4utIkTUss2RvfQGPVptrLmBA0DWBknkMzJR9rDVg4gKkXt+bu4kCMDn7uQ3UdeI19lqQUSFrE3O0Bv7 + /JobP4Dyelj9L1sdiKjwdcieeqN3Ly60xhYBAOXyrERyDS/eQ1TW3LN5JXKnLgY8WgAoh5d0479F8fz9 + RKRFcrwuDBMzCwWAIklkkt7WX2+3eiKimioyUheKR72FA0Arcw/r48l8iGg3uYcAJfIJXTSWZBYRAK1l + sd6WL+Pv+Ymod02UvfW7hmsUTysMtBb3wmCjeRY/Iupf7s5C3U8ktNoWFwDNKJF1+utYmSIH2K2XiCiH + 7pNX6eLCIAA0m5c3/slysN1aiYjq0P8MAqteWYAANB4bPxENSB1ykC5AX9YFaOUOixKAeluhvqS3vwPt + 1khENAC5Oxq5exq71w0PL1YA8uDukBvJGDZ+Imqu3EONIjlPF6oZ3sIFoD+eUKNkiuxjtzYioiYtkdPU + Pbpoba9ZxAD0RiLTqkN1KoPslkVE1CJV5A26kI1TG3dY2ADszBY1UTf+t9utiIiohZsir9ZF7Z/UC7bI + AdjRsurf77sX6CIiKlzu2QVjuUAXukR/7apZ/ICymqO3h2tkpuxrtxIiooI3VY7TxW+scg9pCi2MQFGt + 0RH4TjXcbg1ERCWs+6mGP66L4QP6Kz8VQFG5c/s3ep5fJpNkqJ39RERULZI/00XSPcvgYls0gVb3jBor + bXK0neVERLTT3HMKJHKOulsXzw01iynQ/LqfoneCDrRn8VK8RER9zT3TYPcTDE1U7iFS4UUXGFjb9DxN + qj/i75D97ewlIqJcqsgwXWivVe3VBTe8EAON0mmb/tXSJofYWUpERHXNLbjdr0EwSRdifjKARnGD53Q1 + isfsExENdO6VCWO5VL8b+6UOBO7vX0MLN9BXa5X7K6hL9PzihXiIiJqyibKHLtKn6WLtnmNgoQot6MDu + PKnn0Z3V+5+4J7AiIqIWK5LjdSH/jC7o/6V4RAF2Zr2arNyP9o+1s4eIiAqR+04ukRG6yN+mHlbckbC8 + 3HU/WwfEW/TX0/kun4ioTLmHa1VkpG4CY5R7fQLuTFhcbsOfo9yrU17AvfaJiOh/cgNBLGerm1Sk1qjQ + ZoLmt1q1VYe77iFvP7uWiYiIdpN7FreKnCiJfKJ6h7BYHlVbbYNB83DXyVz1Q+VeV+IE/d1Bdi0SERHl + 0BzZS7+vPEk3mct0s3E/TnaPCXd3IAttTMifO9buR/kT1Ci9Hk7jpXSJiGjgiuXI6o+auzcl99OC6for + z0nQd5vVAjWx+mP87r+3P4nn1icioubP/RjavcJhm5yhG9hVaqz+/y/117kMB1XuCXbcj+5/ocflq/rr + VXpcRsgUea2+lR/hExFRQZssB+uGN1w3v/frr5/UDfBW5X60XVHz1TK1XYU2z2bmLrO77O5rcF+L+5rc + 13adfa3Dq8/eSERERDvJPbNhhxxug8KZ6iO6kbrvlD+r/+0ew/49/W/3ssm/0v93D2X8rXJ/R75IPalW + qFU1Nqnshu1+r/Z93J9xf9Z9jDn6UR+wj/0r+1zfq37u7stwpf76N/rrmfqr29gP58f0RM2eyP8HbAuG + Xx5fUDAAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAJcEhZcwAACxIAAAsSAdLdfvwAAAAZdEVYdFNvZnR3YXJlAHd3dy5pbmtzY2FwZS5vcmeb7jwa + AAA2CUlEQVR4Xu3dCZwkZX3/8eaWW6MxoogGMEbXF6I99dTMzqI9VTWzDGYTOcaDQ4ME5EhEMX8Qiboa + MBg1iiAIinIavAKI3GCUAAHBl8ghNwgmCLs7e3RVdffM7lL/5+l9NrtUPzPT3dNHHZ/v6/WOYbunu46n + nt9T1XUUCCHJTlQqbR0uLu4WuPY+0qjviInQs48JXHFy4FpfDB1xbuCJ7/uedbV8/WbfFXfK/7439MTj + 8j1Pyf9/5Uu4YlqKYqYN73tKekz+//fWP1N9tvoO+V3175TfLV8/WU2LmiY1bWoa1bRGExNb6cknhBBC + SDxrFg/9Sb1ouuKvfNc6vl5UPXGJLKy3Bo54QP7vC9KLUrxgJ52a5hfq8+CIW9Q8yUHEGXIAcZyaVzXP + at71YiCEEEKylahQ2KIyZr3ed+2R0LOOlkXxS6Fj/0T+731SIJmKZ27IwYAv//e+0LV+LAcJZ4aO+Dvf + GyypZaaWnV6MhBBCSHITjg6/NvAsT+7dnij35s+Xhf52WdzKmxc8tKQmPRR64oe+J5aqnxn8EWtBtLSw + pV7khBBCSO+ifpNXhUjusX5IFvuzpJtloZrcrHChi9RRAzW4UoMsNdgqe/YiuU5eplcPIYQQMv+ow9Bl + V/xF4NhHhK51jixA90hqz9RYnNA3ap38qr6O5LpaM2q/Sa9CQgghZO5ES4o7+I5wQkd8Tu5dXieLCnv2 + 6bUi8MS1oWt/Vp1XEA0Nba9XMyGEkLwnGttnR/W7vfqNWR/KZ+8+u9bKAcG9G042tJasKu37ct0MCCGE + ZD3q93v1m7HvWp/fcG27LArmYoHsW6vOJVBHe8qOtVC1Dd1MCCGEZCGrneJevmufIAv+VbLTXxMrAsBG + q2UbuVLdj6E6Jv5cNx9CCCFpiboLXThiF+uH9dUhX3NnD8xKDgaerF/l4VleVCxuo5sXIYSQJEX9li/3 + 8g+RHfdl0orNO3KgA2Sbsi9VbUydKKqbHSGEkH5EdcTqZC65l3+JvqOcqeMGOq0qXSPb3YdWesVddXMk + hBDSzSwfHt5ZdbyyA/6ZxBn76DfVBq9R9x5YVirtpJspIYSQTiSaWLAte/pIgfqRAXXLYtVmdfMlhBDS + Sup34FOX6zn2BbLwq0fTmjpcIKkm1a2KyyMDw7pJE0IImS36ufcnBq51v6FTBdLoUXVFStVZ+AbdzAkh + hKiow6X1M/g9ca3sLNfFOk8gK1Tb/pnv2QdzWSEhJNepPz7XEafITvEPm3WSQB48Lwe8Z1ZLg2/UmwMh + hGQ76lnu6sYq6hnvshPkNrzIu/XqGRQbThyc2EpvJoQQkp1Mjtu7yD2eT2y4u5qxIwRyLXTFE74n/kHd + 1EpvNoQQkt7UPGtPdahTdnCr4h0eAKM16hbElZK9u96MCCEkPfFHrXf7nnW17MzWxzo3AM1RNxm60B+x + FujNihBCkhl17b66YY/vijtiHRmAedjw2GJridrG9OZGCCH9j7qkKdhwe96H4h0XgI66T21rXEZICOlr + Nly/bx0vOyUu4wN66xnfs47jlsOEkJ5m4x6/OmvZ0DEB6J1nQs8+JiqVttabJyGEdD7qGn51vbLsdB6L + dUIA+uvp+kCAewkQQjqZjSf3yU7mvlinAyBZflc/R4CBACFkvlF37Qtc69eGjgZAcj1Yv7sgVw0QQlpN + OGIfIPck7jV0LADS41dyAL+/3qwJIWTmhM7gO2WH8Z+GjgRAev08cO199GZOCCGbUnGGXue71vmyo+Bx + vEA2rQ88cYk/tvDVerMnhOQ5y4eHd/Y9cbrsHMJYZwEgmyblYP9jXDpISI6jz+x/NtY5AMiHR0NPvEd3 + B4SQPCQYEW+XG/9tsc4AQC7ZN/PAIUIynlWlfV+uHjMqN/q1jZ0AgBybVn2D6iN0d0EIyULUtcDq5iCB + I5YZNnwA2Oh537U/oLsOQkias9op7hW41k2GDR0AzDxxbdUr7qG7EUJImlJ/YI8jTpEbc7Vh4waAuYWq + D+G2woSkKOWRgeHAsR82bNAA0JLQsW/3vcG36O6FEJLEREND2weeOFNutNzMB0AnTau+JRrfezvd3RBC + kpL6Xr8rHo1ttADQOY54oOLZg7rbIYT0M8tKpZ1C1/6m3DhfbNhYAaDz1qtLBqOxfXbU3RAhpNcJR8WA + 3BjZ6wfQD0+VHWuh7o4IIb1I/bp+1z5RboBTsQ0SAHppre+JpVwpQEgPUhmzXh844heGDREA+sJ3xZ01 + z9pTd1OEkE7Hd+1D5MY2Gd/4ACABVgeudZjurgghnUj9kb0bntVv2ugAIDFCT/yQZwoQ0oFUnAEhN6jH + TRsaACTU02XPXqS7MUJIK4lKpa3VyTVyQ+LJfQDSaG3oWp/hBEFCWki5VHyVeka3YYMCgHSpn7Rs/5nu + 3gghMyV0Bt8pN5qnGzYiAEivP1RGBm3dzRFC4qk/s98VldiGAwBZUAs962jd3RFCVNQDNnzHvsCwwQBA + tnjiEvXgMt39EZLfVEr27nKDuMu4oQBAJlm/rpYG36i7QULyF3/UerfcGJ5v3DgAIPOWB57l6e6QkHxk + s3v5T8c2CADIk3WBI05RfaLuHgnJbqIlxR1CV/zIsCEAQD454gecF0AyHXV9f+jYtxs3AADINftu7hdA + Mpk1o/abZCN/rLHRAwC0p3xv8C262yQk/SmPDAzLhr081tABAHGeWCkHASXdfRKS3viu9X7ZqKsNjRwA + MJOpwLUO190oIemKOqtVP8znxVjDBgDM7UXVh3KFAElVookF28rGe3GsMQMAWmZ/LyoWt9HdKyHJzarS + vi+XjfbnjY0YANAWR9yi+lbdzRKSvFS94h6ysT7U0HgBAPPjiAfUrdN1d0tIcqLua+274kljwwUAdMLv + 15SG9tbdLiH9T3ms+JeyYf5PrKECADrvj/7YwNt090tI/xJ6A+8IHLHM0EgBAN3xQjBq7au7YUJ6n9C1 + LNkQJ2MNEwDQfasqrhjS3TEhvYvvWO+SDbAca5AAgN4JeKQw6WlCZ2BcNrxKrCECAHqvFo4M/rXungnp + XkLHWqIaXKwBAgD6Z8p37UN0N01I5xM44oOyoa2NNTwAQP+tCxzrb3V3TUjnEjj2EbKBrY81OABAcsg+ + mocIkQ4mdMV7ZcNizx8Akm+d71nv0903Ie0ncO1R2aD4zR8A0mMq9MR7dDdOSOspjwwMy4YUxBoWACD5 + Kr43WNLdOSHNpzIyaMsGxHX+AJBeQdmzF+lunZC5E4yIt8uGwx3+ACD9VofO4Dt1907IzCm74i9kg3k+ + 1oAAAGnliGW+a79Vd/OENGa1U9wrcK3/NTYgAECa/U/Ns/bU3T0hm1IZs14vG8jvYw0GAJAdT1VK9u66 + 2yekUJgct3eRe/73GxoLACBbHlpV2vfluvsneU5ULG4TuPbNhkYCAMgk6z+jiQXb6jJA8pioUNhCNoaL + GhsHACDjLtSlgOQxvieWGhoFACAHQkecpssByVN81/6AbAAvxhsEACA3XlQPetNlgeQhvmO9S6547u8P + AJjyHeHo8kCyHN8bfEvgiZWGRgAAyKfJ8sjAm3WZIFlMuVR8VeiJxw0rHwCQb08Frv1nulyQLCUaGtre + d8V/G1Y6AADKr6IlxR102SBZiLrcL3TFjwwrGwCAzVj/rksHyUICR5xiXtEAADQ4SZcPkuaoszvlylwb + W7kAAMxkre8NlnQZIWlM/QE/jlhmWLkAAMzmBR4clNJE43tvJ1fgr2IrFACA5njiLlVLdFkhaYnvim8b + VygAAE3yPXGeLiskDQk9+xjTigQAoFWhK47S5YUkORVnQMgVxm1+AQCdUg1HxYAuMySJKbvilXJFPR1b + cQAAzNcz6m6yutyQJCUqlbaWK+jW2AoDAKAzPHFjNDGxlS47JCnh2f4AgG4LXfFpXXZIEhK6liVXzHR8 + RQEA0GFrK549qMsP6WeWlUo7yRXyWGwFAQDQFaErnlg+PLyzLkOkXwk8cYlpBQEA0EXf0WWI9CO+ax9i + WCkAAHSd71rv1+WI9DLqHs1yBUzGVwgAAD2yquoV99BlifQi0dLClnLB/zy2IgAA6LVfcmlgDxM64jTD + SgAAoB9O1uWJdDPhiF2UC3sqtvABAOiXaXUbel2mSDfCJX8AgIR6JBrbZ0ddrkinEzriXMNCBwCg/xzx + b7pckU7G9wZLcgG/2LDAAQBIhvVlx1qoyxbpRKIlxR1CTzxuWNgAACSIdX80sWBbXb7IfBO49lnmBQ0A + QLKEnvVPunyR+aTiiiG5QNfFFzAAAAlV8137rbqMkXYSje+9XeDYDxsWLgAAiRW64r/UTet0OSOtJnTE + 50wLFgCApPM96zhdzkgrWTNqv0kuwGp8gQIAkBJr1HNrdFkjzSZwxC2GhQkAQJr8TJc10kzkAvtwbAEC + AJBKvme9T5c3MltWL1r0Crn3v8y0EAEASKHnV3rFXXWZIzMldK1zDAsPAID08qyv6TJHTPHHBt4mF9Ta + hgUHAEC6ydpm76PLHdk8UaGwReCIXxgWGgAAWXCbqnW67JGNCVzrcMPCAgAgMzghMJblw8M7ywXzXHxB + AQCQMc+qB9zp8kd8V5xhWEgAAGRO6Nqf1eUv36k4Q6+TCySMLyAAALIodIUfLi7upstgfhO49qWmBQQA + QIZ9R5fBfCb0Bt4hF8L62EIBACDr1ofO4Dt1OcxfuN8/ACDHfq7LYb4SjtgHGBYGAAA5Yu2vy2J+Erj2 + 3eaFAQBAbtwXLS1sqUtj9lNxxIGGhQAAQO74jpjQ5THbqd/yV4544gsAAICcejQqlbbWZTK78V3r/YaZ + BwAgt0JXHKXLZDYTTUxsJWf0d/EZBwAg556NxvfeTpfL7CXwxIcMMw0AQO75rnW8LpfZit77fzQ+wwAA + oC6bRwFCR/ydYWYBAIAma+WxumxmI1GxuI2csafiMwoAAF4iW0cBfNc+wTCTAAAgJnTFR3X5THeiiQXb + yhl6Nj6DAADA6OlM3Bcg9OyPGGYOAADMyDpcl9F0Rt/176HGGQMAADOz7lc1VJfT9IV7/gMA0J7QE+/R + 5TR98V1xp2mmAADAnG7T5TRd8UetdxtmBgAANKnsWAt1WU1PfM+62jQzAACgOaFr/ViX1XRkTWlobznh + 6+MzAgAAWrKu5ll76vKa/ASufZZhJgAAQOu+qstrsrN8eHhnObFrYhMPAADaU54ct3fRZTa5kRN6UmzC + gY4JD14cVU46Nqp85fSoev43ouqlF0bV730rqp739ajy+VOj8NgjomD/Rca/Bdom25RqW5UvnFpva/U2 + p9qebIOVL59eb5PhQYvNfwt0gO9aH9NlNpmJlha29F3xpGnigbZ4dhT+/Uei6o8uj6aefDyanp6em+9H + tXvuiqpnfzkKJ8bNnwvMIZw4IKqe85Wodu/d0XQQmNtajGqj1R9eHoUnHGn8TKBdoSueUDVWl9vkJRyx + DzBNONCyxQujyplLo6nHHzV2tE2r1aLaLddH4TGHm78HiFF7+rVbb6i3HWObatLU449ElS9+tt6WTd8D + tMwTi3W5TV7kBF7TMMFAi9Th1HkX/ripKdmp3xgF7/8r43cC6mhR7fpr6m3F2IbaNPX0k1HllI8ZvxNo + he+KK3W5TVaqXnEPOYHr4hMMNG18Uf1Qv6kT7ZSpVSujytJPmb8fuRWedlI0NbnC2GY6RQ0uggPeZfx+ + oEnrqs7CN+iym5zIkckZhokFmiP3vqYeecjYcXac3MOrXnZh/fwC47QgP2QbqF72XXM76YKphx+sn1tg + nBagCb4nluqym4xExeI2gWv9r2ligbmERxwYTf/hWWOH2U21666OgtFB4zQhB+S6V23A1Da6SrZ11eaN + 0wTM7TlVc3X57X981z7EMJHA3OSefz+K/0b18wLGhszThuxSxf+Ga4xtoiee+x/OR0HbQle8V5ff/idw + 7etMEwnM6oD9enfYfxa1m6/nSECeqOIv17mpLfTS1O8erJ/3YpxGYBbqWTu6/PY3FWfodXKCOPkPLatd + 9SNjx9gPHAnIiX7v+cdUf3KFeTqB2a0NFxd302W4f5F7/6caJg6YVeX/nWDsEPuJIwEZl5A9/zh12atx + eoHZOPY/6jLcv8iJeNg4ccBMFi+Mpp5q8q5+PcYgIKMSWvwVdcMgjj6hDY/oMtyflD17kWGigFlVvrTU + 2BEmBT8HZEzCDvubVM74jHnagVlURgZtXY57H9+xLzBNFDAjz+78Xf66gCMBGZHgPf/NTT32iHn6gVmE + jjhXl+PeJppYsK2cgBXxCQJmox7sY+oAk4gjASmXgj3/zYXHfdg8H8DMJlUt1mW5d1HXIRomBphVt2/1 + 22kcCUiplOz5b656xSXmeQFmEXriPbos9y6BI35gmhhgNlNPPWHs/JKMIwEpk7I9/43qJwOa5geYjSMu + 12W5N1k+PLyz/OKwYUKAWYQHL+74k9Z6hSMBKZHCPf//I7eN8MBR83wBMwuXlUo76fLc/cgv/HBsAoA5 + qeudjR1fSnAkIOFSuue/ucqJR5vnDZiNJw7V5bn74da/aEfly6cbO7004UhAQqV5z38zlS993jx/wCx6 + dmvglV5xV/mFU/EJAOZSveBsY6eXNhwJSJgM7PlvVP3WWeZ5BGZXmxy3d9FlunsJXOtww5cDc6pefIGx + 00sjjgQkREb2/DeqXnS+eT6BOfiu9X5dprsX3xVXmr4cmEv1u98ydnppxZGAPsvQnv9G1QvPM88rMIfQ + Ez/UZbo7iZYUd5BfxNn/aEv13K8ZO70040hAn2Rsz3+j6jlfNc8vMLcwGttnR12uOx/ftQ8xfCnQlMoX + TjV2emnHkYAey+Ce/0aVz51snmegCRVHHKjLdecjv+Cy+BcCzQo/erix08sCjgT0SEb3/DcKjz7UPN9A + cy7S5bqziSYmtpIfzr3/0b7Fw9G0XzZ2fFnAkYAuy/Cef53cNtQ2Ypx3oBmOWKZqtS7bnYvvWO8yfiHQ + gto9d5k7v4zgSECXZHzPX6nddYd53oEWVFwxpMt25yI/+F/jXwS0qnr2l42dX5ZwJKDDsr7nr1W/fqZ5 + /oEW+K44Q5ftziVw7IdNXwa0IpwYj6ZrNWMHmCUcCeiQHOz511WrUXjI/uZlALTmt7psdyY1z9rT8CVA + W2q35KBDlzgSME852fNXajf+zLwMgDZUS4Nv1OV7/vEd8femLwHaUb8aIKVPBWwVRwLalJc9f2WqFoVH + fcC8HIA2hJ59jC7f84960IDpS4B21a7/qbkzzCCOBLQoR3v+Su2a/zAvB6BNoSt+pMv3/BKVSlvLD1wd + /wJgPtS5AFOTK4wdYhZxJKBJedrzl6ZWLI/CgxeblwXQvlUduRyw7NmLDB8OzFvl1I/n5qcAhSMBc8jZ + nr9q++FpJ5mXBTBPlZFBW5fx9uO71udNHw50QvWyC82dY0bVbrqOIwEmqvjLZWNaZllVvfjb5mUBdEDo + Wf+ky3j78V1xp+nDgY7w7Kh23dXGDjKrGATE5LD41669qt72jcsD6Ixf6jLeXpYPD+8sP2Rt7EOBzsrb + oV+JnwM01j3QLVPqCb66nLeewLX2N3wo0HkUgvxhnQPdNWq5upy3HjkA+KLxQ4FuoCDkB+sa6Dp1Dp8u + 563Hd8Udpg8FuobCkH2sY6BHrP/U5by1REND28sPmGr8QKDLKBDZxboFeqkalUov02W9+fiOcAwfBvQG + hSJ7WKdAz5VdsZ8u680ndO3Pmj4M6BkKRnawLoG+CF3xaV3Wm4/8w+vjHwT0HIUj/ViHQN+oZ/nost5c + okJhC/mHK+IfBPQFBSS9WHdAv72gS3tzKY8MvNnwIUD/UEjSh3UGJMJqp7iXLu9zJ/DEh0wfAvQVBSU9 + WFdAgliH6fI+d0LX/qb5Q4A+o7AkH+sISJTQEd/Q5X3uyD+4J/4BQGJQYJKLdQMkkH23Lu+zJ5pYsK38 + g1rjBwAJQqFJHtYJkFTVqFjcRpf5mROMWvsa/hhIHgpOcrAugETzxwbepsv8zAk9+yOmPwYSicLTf6wD + IPkc+whd5mdO6ImzjX8MJBUFqH9Y9kA6OOLfdJmfOaFj3278YyDJKES9xzIHUmSOJwNGSwtbhq7wzX8M + JBwFqXdY1kDarFJ3+dXlvjE1z9rT8EdAelCYuo9lDKRSpWTvrst9Y+Te/1+Z/ghIFQpU97BsgfTyxGJd + 7hsTOOIU4x8BaUOh6jyWKZBunviELveNkW+4qOEPgLSiYHUOyxLIgu/oct8Y+SK3AEa2ULjmj2UIZILv + ijt1uX9p1NmBXAGATKKAtY9lB2TJGuOVAJUx6/WGNwPZQCFrHcsMyJxwdPi1uuxviu8Ix/RmIDMoaM1j + WQGZVHbFfrrsb0ro2ceY3gxkCoVtbiwjILsc+0hd9jdFvvClhjcCWUSBmxnLBsg03xOn67K/KaFj/8T0 + ZiCTKHSNWCZADthX6LK/KfKF3za+EcgwCh7LguKPvPHEvbrsbwqXACKXKHw5XQY3UPyRV6t12d+Qsite + aXgTkA95HgRQ/IHcmRy3d9Hlv1AIRq19TW8CckMVwpuuMxaMrFLzm8d5Vuva2AaAnPDHBt6my786AdBa + YnoTkCs53BvOE/b8gQ1CZ2Bcl/9CwXet401vAnKHQUAmUfyBTdR9f3T5LxQCx/4X05uAXGIQkCkUf+Cl + fMf+Z13+1SWA9qWmNwG5xSAgEyj+gNHFuvzX7wFwa+xFAAwCUo3iD8zEukmX//oA4MHGNwBgEJBOFH9g + Vr/V5b8+AFgeexHARgwCUoXiD8zpj/XiH5VKW8v/WB97EcDmGASkAsUfaMq6aGJiq0K4uLib4UUAcQwC + Eo3iDzTPH3/HnxZCb+AdphcBGDAISCSKP9Ca+t0AA9ceNb0IYAYMAhKF4g+0znftEXUXwPebXgQwCwYB + iUDxB9rje9ZB6jHAHzW9CGAODAL6iuIPtE/W/qMKgSNOMb0IoAkMAvqC4g/Ml/XJgvw/XzS/CKApDAJ6 + iuIPzF/9eQChI841vQigBQwCeoLiD3RG6ImzC4Envm96EUCLGAR0FcUf6KjL1G2Afxr7RwDtYhDQFRR/ + oLN8V1ypTgK8xfQigDYxCOgoij/QBZ64sSBHAXcYXwTQPgYBHUHxB7rmNvUTwG9i/wigExgEzAvFH+gi + T9yrBgCPNLwAoDMYBLSF4g903UNqAPBs7B8BdBKDgJZQ/IGeeFqdBLjM8AKATmIQ0BSKP9Azz6v7AKw0 + vACg0xgEzIriD/TUCvUTQDn2jwC6hUGAEcUf6LlVagAQxv4RQDcxCHgJij/Qe6ErfDUAqMVfANBlDALq + KP5A31TUAGBt7B8B9ELOBwEUf6CvptUA4MXYPwLolZwOAij+QN+tZwAA9FNuBwA3MgAA+qs+AOAnAKAf + cv8TAIMAoI/qPwFwEiDQa5wEWMcgAOib+kmAXAYI9BLF/yUYBAC9t/EyQG4EBPQKxd+IQQDQc6u4FTDQ + KxT/WTEIAHpqBQ8DAnqB4t8UBgFAzzyvfgLgccBAN1H8W8IgAOiJp9UA4JHYPwLoFIp/WxgEAF33kBoA + /Cb2jwA6geI/LwwCgC7yxL0F3xV3GF8E0D6Kf0cwCAC65jZ1EuAthhcAtIvi31EMAoAu8MSN6ieAnza8 + AKA9FP+uYBAAdJbviivVfQC+b3oRQIso/l3FIADoqMsKoWt/0/ACgFZQ/HuCQQDQGaEjvqFOAjzD9CKA + JlH8e4pBADB/vmt/QZ0DcHL8BQBNovj3BYMAYN5OKoSefYzhBQBzofj3FYMAYB4c+8iC71nvM74IYGYU + /0RgEAC0p+KIAwuBa4+aXgQwA4p/ojAIAFrnu/ZIIRgRbze9CMCA4p9IDAKA1vgj1oJCULJeY3oRQAzF + P9EYBADNK5eKrypEExNbyf9YH38RwGYo/qnAIABoytpoaWHLgkrgiGWGNwBQKP6pwiAAmNNz9eKvIgcA + DxjeAIDin0oMAoBZ/UaX//oAgCcCAnEU/1RjEADMQD0JcGMC177U+CYgryj+mcAgADC6SJd/NQCwvmh4 + A5BPFP9MYRAAvFT9OQAb43vWcaY3AblD8c8kBgHAJqFnHa3Lf6EQeuI9pjcBuULxzzQGAcBG1v66/NfP + AdjH/CYgJ1Txv+k6Y+HIKjW/eZxnta6NbQDICd+136rLf6GwetGiV5jeBORCDvf8a7fesGFvOJfzzpEA + 5NvkuL2LLv8bErrCN70RyLQ8F/9cLwMGAcitVbrsb4r8x/tibwKyjeKf82XBIAC5dI8u+5sSutaPDW8E + soni34hBAJAD9hW67G9K4IkzzW8GMobiPzMGAUCm+Z44XZf9TVHXBZreDGQKxX9uDAKA7HLsI3XZ3xTf + tUeMbwayguLfPAYBQCaVXbGfLvubUinZu5veDGQCxb91DAKAzAkXF3fTZX9TokJhC/liOf5mIPUo/u1j + EABkyRpV63XZf2nki7+KvRlIN4r//DEIADLBd8Wdutw3Rr7hovgfAKlF8e8cBgFA6skBwLd1uW+MfMPJ + 8T8AUoni33kMAoB0c+yP63LfGJ4KiEyg+HcPgwAgvRx7TJf7xlTHxJ8b/whIC4p/9zEIAFKp4gy9Tpf7 + xkRLC1vKN3ElANKJ4t87DAKAdPHESl3qZ458420NfwgkHcW/9xgEAGlyqy7zMydw7bMMfwgkF8W/fxgE + AClhf0WX+ZkTONbfmv8YSCCKf/8xCABSwDpMl/mZE4yIt5v/GEgYin9yMAgAEs0fsRboMj9zolJpa/nm + avyPgUSh+CcPgwAgqSqqtusyP3vkm++J/TGQHBT/5GIQACSQfbcu73MndK1zzB8C9BnFP/kYBAAJY31d + l/e5Ezj2EeYPAfqI4p8eDAKA5HDEB3V5nztrRu03GT8E6BeKf/owCAASQd3lV5f3uaOeFyz/aHn8Q4C+ + oPinF4MAoN9e0KW9+QSeuNbwQUBvUfzTj0EA0De+K67UZb35hK71GdOHAT1D8c8OBgFAf3jWp3RZbz6+ + a48YPwzoBYp/9jAIAHquPDIwrMt684mGhraXf1yLfxjQdRT/7GIQAPRSJRrfeztd1ltL6Ni3Gz4Q6B6K + f/YxCAB65ee6nLce3xVnGD4Q6A6Kf34wCAC6zvfEUl3OW0/gicWmDwU6joKQP6xzoKvUuXy6nLeeZaXS + TvJD1sY/FOgoCkF+se6BbpmKlhR30OW8vfiuuMPwwUBneHZUu+5qY0eZVbWbrqsXPuPyyCM1CJDLxLSs + sqp27VX1tm9cHkAnOOIXuoy3H/UbgvHDgQ6oXvZdYweZVRT/GeRwEFC95DvmZQF0QOiI03QZbz/qGkLT + hwPzVfn0J6LpqSlj55hFHPqdQ95+DpBtPzztJPOyAOYpdC1Ll/H2E5VKW8sPWx3/cGA+wokDoqnJSXPH + mEG1m69nz78ZahAgl5VpGWbR1IrlUXjI/uZlAbTLEyujiYmtdBmfX3xXXGX8EqBNedrTY8+/RTk7ElD7 + 2VXm5QC0KfTED3X5nn981z7B9CVAO8Jjj8jNoX/2/NuUpyMB6qeAow81LwegDaFnHa3L9/xTdRa+wfQl + QDvUHrGxI8wY9vznKUdHAuonh5qWAdAGVbN1+e5M5Ic+GP8SoFXqt//pWs3YCWYJe/4dkpcjAdUq5wKg + U36jy3bnEnjiTMMXAS2pnvNVcweYIez5d1hOjgRUz/pX8/wDLfBd+wu6bHcuZc9eZPoyoBW1e+82dn5Z + wZ5/l+TgSEDtV3ea5x1oQWVk0NZlu3NRlxTID18e/zKgafsviqaDwNj5ZQF7/l2W9SMBfjkKFg+b5x1o + zgvR0sKWumx3NoEnLjF8IdCU+tn/po4vA9jz75GMHwkIjz7MPN9AMzzru7pcdz6+Zx9s/FKgCZUvnGrs + 9NKOPf8ey/CRgMrnTjbPM9CE0BXv1eW681FPFpJfEsS/FGhG9dyvGTu9NGPPv08yeiRAnSRrnF9gDrL4 + +9HQ0Pa6XHcnoWP/xPTlwFyq3/2WsdNLK/b8+yyDRwKqF55nnldgTvYVukx3L4EnDjV/OTC76sUXGDu9 + NGLPPyEydiSgetH55vkE5uA7YkKX6e5l+fDwzvLLqvEvB+ZSveBsY6eXNuz5J0yGjgRUz/u6eR6B2VWW + lUo76TLd3cgvuyb25cCcKl8+3djppQl7/gmVkSMBlS993jx/wCx8V/yHLs/dT+DYR5gmAphN5aRjjZ1e + WrDnn3AZOBJQOfFo87wBs/Bd+wO6PHc/0dg+O8ov5WoAtCQ8aHFqnwLInn9KpPlIgHoq4IGj5vkCZhao + mqzLc2+izjg0TAgwq6mnHjd3fgnGnn/KpPRIwNRjj5jnB5iVfakuy71LODL41+aJAWZW/eHlxs4vqdjz + T6kUHgmo/vvF5nkBZhE6A+O6LPcuUbG4jfzyFfGJAWYTnnCksfNLIvb8Uy5lRwLUrbKN8wHMxBHLVC3W + Zbm38V3rfONEATPx7Gjq8UeMHWCSsOefESk5EjD16MPm6QdmEbr2N3U57n3KIwPDpokCZlP5l88ZO8Gk + YM8/Y1JwJKDyz6eZpx2YRcUZELoc9yeBYz9smjBgRosXRlNPPGbsCPuNPf+MSvCRgPrJfww40boHdRnu + XwLP+pRhwoBZVT55vLEz7CeKf8YlcRAwNRVVPvFR8/QCs7I+qctw/xKUrNfIiVnbOHHA7KpX/sDcKfYB + h/1zImE/B1R//H3zdAKzW6tqry7D/U3giWsNEwjMbnxRNPXwg8aOsZfY88+ZhBwJmHrogSjYf5F5GoFZ + +K64Spff/sf37INNEwnMJZw4IJr+wzPGDrIX2PPPqX4fCZBtPpwYN08bMIfQs/9Gl9/+Z8M9Aaz/NU0o + MJfwiANlh/isuaPsotq1V7Hnn2dqEHDd1ca20VWq+Ms2b5wmYG7P9e3a/5nie+J0w4QCTVFHAnr2c8DU + VFS9+Nv1exKYpgU5IttA9dILe/aMCnXYX7V147QATZC1dqkuu8lJZcx6vZy4dfGJBZq2/6Ko+qPLu9oZ + T61YHlU+/Qnz9yO3wtM+UW8bpjbTKbXrr4mCA/Yzfj/QpLWVkr27LrvJipy4n8YmFmhZ5eMfrV8bbepE + 2yYHFaoDDg/Z3/idgHoS34YBaM3chtqkHoBVOfkfjN8JtKKnz/1vNeqhBKaJBlo2NhRVzvjM/AcC1WpU + u+naKPy7D5q/B4gJjz5Utpnr6m3H2KaapG7vW7/DHyeZolMce0yX2+QlWlrYMnTFE8YJB9oUHv+3UfWK + SzY8Q6CZnwfKa6LaXXdE1bO+xB4/2qbaTvWsf41qd99Rb1PGtrY52TbVgFU91S887sPGzwTaFXricVVj + dblNZnxP/INp4oFOCN/rRZWPHxNVzlwaVc//RlS96Pyo+p1zo+o5X40qnzu5vvembjVs+lugbbJNhUcf + Vm9jqq3V25xqe7INqmdbVE48WrZN1/y3QAf4rnW8LrPJTbSkuIOcWB4TDABAZ0xGY/vsqMtsssMlgQAA + dIbc+/+8Lq/Jjz+28NVyoqvxmQAAAC2pJea+/81GTvSFsZkAAAAt8F3xLV1W05PyWPEv5cSvj88MAABo + you+N/gWXVbTFZ4SCABAexL11L9W4zvCMc0UAACYXdkV++lyms4Ern23acYAAMCMfqXLaHoTeOJQw4wB + AIAZ+I6Y0GU0vYlKpa3lzDwTnzkAANDId8WT0cTEVrqMpju+Zx1nmkkAAPBSoWcfo8tn+hMVi9vImXoq + PpMAAOAlnokmFmyry2c2ErriKMOMAgAATdbKj+qymZ2o3zPkzD0Sn1kAAFD3bOb2/jcmcK3DDTMMAEDu + hY44VpfL7EUfBXgoPtMAAOTcM9H43tvpcpnN+J71PsOMAwCQX459pC6T2U1UKGwhZ/Y3DTMPAEA+Paru + maPLZLYTevbfGBYAAAC543v2wbo85iM8IwAAkHueuFcdGdelMR8JXGt/48IAACAvHHtMl8V8Rc78DQ0L + AwCAXLBv1uUwf/Fd+61yIaxtXCgAAGTaWn/EWqDLYT4TutY5hgUDAEB2edbXdBnMb1YvWvQKuTBWNCwc + AACyabLsilfqMpjv+K71McMCAgAgc9Qj8nX5I+oGCIEjHjAtKAAAMuSh3Nz0p9kEo5ZrWFAAAGRHXi/7 + myty4VzTsLAAAMgA3xX/ocsdiWe1U9xLLqRafKEBAJByU2tG7TfpckdMCVz7K4YFBwBAejn2v+gyR2bK + Sq+4q1xYzzcsPAAA0um5yXF7F13myGzxXfsDhgUIAEDq5O5pf/ON74qrTAsSAIAUuUaXNdJswtHh18oF + tzq2IAEASIs1lZK9uy5rpJX4rn2CYYECAJB4oSs+qssZaTXR0sKWcgH+l2nBAgCQYL+MCoUtdDkj7aQ8 + MvBmuSCrsQULAEBS1Xxv8C26jJH5JHTtzxoWMAAAiRO64tO6fJH5JppYsC0PCwIAJJ91f1QsbqPLF+lE + Ks6AkAt3XePCBgAgEdZXXDGkyxbpZALXPsuwwAEASIKv6nJFOp1obJ8d5QJ+JLbAAQDot99FS4o76HJF + upHQGXynXNBTsQUPAEC/TIeuZekyRbqZwLVPNawAAAB6z7H/UZcn0u2oGwTJhX5rw0oAAKCXHPELVZN0 + eSK9iLq/slz4kw0rAwCAXvDEyqpX3EOXJdLL+J51kHGlAADQZbIGvU+XI9KPBK79PdOKAQCgW3zHvkCX + IdKv6EsDH42vHAAAuiH0xOPLh4d31mWI9DPhqBiQK2U6vpIAAOiwtZWRQVuXH5KE8MAgAEDXedandNkh + SUk0MbFV4No3G1cYAADzdz2X/CU0axYP/YlcQU/FVhgAAPP1+3Kp+CpdbkgSE4xa+8oVVYmtOAAA2lUN + R+yiLjMkyQkc+wjDCgQAoHWOfaQuLyQN8V3rfOOKBACgSaEnztZlhaQlUbG4TejYt5tWKAAAc/Fd8d/R + xIJtdVkhaUq4uLibXInPxVcqAABzeL7iDL1OlxOSxviuPSJX5NrYigUAYCZr/VHr3bqMkDRHPavZsIIB + ADCwT9Tlg6Q9UaGwReCIH5hXNAAAmiMu16WDZCXR0ND2vivuNK5wAABc++5oSXEHXTZIlqLu4qSe4mRe + 8QCAvJI7iE/6YwtfrcsFyWLWlIb2lit7eXzlAwBya0V5ZODNukyQLKfsiv3kCq/FGgAAIH+m1NViujyQ + PMR3rffLFf9irCEAAPJD1gDrcF0WSJ4SutZnDA0CAJAHPNs/3/E9cZ6xYQAAsuw7ugyQvEY9MyBwrZsM + jQMAkE03RKXS1roMkDxnctzeRTaI38YaCAAgex5c6RV31d0/IYWCeuiDug7U0FgAABkQuuKJcHT4tbrb + J2RTql5xD9lIfh9vNACA1PtDdUz8ue7uCWnMmlH7TbKh/DHWcAAAaeWIZb43+BbdzRMycwLX3kc2msmG + RgQASJtVoTfwDt29EzJ3KiODtmw45VhDAgCkx5rQtSzdrRPSfMojA8OyAQWxBgUASL6KP2q9W3fnhLSe + wLVHZUPiuQEAkB5T4Yh9gO7GCWk/oSveKxvU2lgDAwAkzzrfERO6+yZk/lEPjJANa32soQEAkkP20dZh + utsmpHPxXfsDsoFNxxocAKD/1kkf1t01IZ1P6FhLZCOrbtboAAD9NeV71kG6myake/FdeyR0hW9ohACA + 3goDTyzW3TMh3U/ZFfvJhrcm1hABAD2idsR8Rzi6WyakdwlH7KJshCvijRIA0GWeWFnx7EHdHRPS+/gj + 1gLZGJ9raJwAgG55PhgRb9fdMCH9S3lk4M2yQf4h1kABAJ33nNrx0t0vIf1P1Vn4htATjxsaKwCgM55e + 7RT30t0uIclJpWTvHjjiAUOjBQDMz2/D0eHX6u6WkORlWam0U+CJaw2NFwDQFuumlV5xV93NEpLcRKXS + 1r4nzjM3ZABACy6MisVtdPdKSDoSuPaJsvHy/AAAaN2Lckdqqe5OCUlffNc+RDZkbh0MAM2rBZ44VHej + hKQ3FVcMBY5YZmjkAICXmvQd6126+yQk/VGXrsiG/WisoQMANN8VT6r7quhuk5DspOyKV8pGflu80QNA + 3sni/9/+2MJX6+6SkOwlGhraPnCtfzdtAACQS464PCqVXqa7SUKyndCzj5ENf7phQwCA/Fgri/8pulsk + JD/RjxT+Y2yDAIDsc8QyHuVLcp2KM/Q63xV3GjcQAMime6pecQ/dDRKS36g7BwaeONOwkQBApviudX40 + sWBb3f0RQlQC1zpcbiBhfIMBgAyohp79Ed3dEULiCUatfeWG8lRswwGANHsmdC1Ld3OEkJmi7xdwQ2wD + AoA0un7N4qE/0d0bIWSuRBMTW4Wu+LTceLhUEEAaTQee9aloaWFL3a0RQlpJOCoG5IbELYQBpMlT6hko + uhsjhLSbDXcPtM8ybGQAkCyeuGRZqbST7r4IIZ2I71kHyQ1sRcMGBwD9t8p37Q/o7ooQ0ukEJes1ckO7 + PrbhAUA/3apuaqa7KUJItxIVClsErn2i3OimYhshAPTStO+JpZzoR0iP448NvC1wrfsNGyUAdJdjPxw6 + g+/U3REhpNeJlhR3CDzra3KDXNewgQJA560LHPFvqu/R3RAhpJ8JvYF3BK71a8PGCgAdYt1fGRm0dbdD + CElK6g8VcsQpckOtNm64ANC2afXAMh7iQ0jCs6Y0tLfcYH8e24ABoGWhY9/ue4Nv0d0LISTpqV8p4IkP + yQ14Mr5BA0ATVqurjTjDn5CUJlxc3C10rR8bNm4AmMk1lTHr9bobIYSkOb5nvU9u1M/HNnIA2Nxzvmsf + orsNQkhWstIr7qpO5JEbOTcQArC5afW8kclxexfdXRBCspjyyMCb5QZ/Q6wDAJBP16x2invp7oEQkoeE + jrVEbvy/j3UGAPKgfie/gXHdHRBC8pb6nQQ33DtgTUMHASCLJutn95dKW+tugBCS56irBXzXOl92DtxS + GMimtWobL5eKr9KbPSGEbIq64UfgiWsNnQeAtHLELerhYXozJ4SQmSMHAYt5tgCQevcEjj2mN2tCCGku + 6m6CG04U5JHDQKo49sO+IybUNqw3Z0IIaT3qZKHQFUfJjuXZho4GQJI8I4v/kdHExFZ68yWEkPlHPQlM + PV/Ad8WTho4HQP/IwXn9zP6X6c2VEEI6n40DgdAVTxg6IgC98wyFnxDS86iBQOiIY2Un9HSsUwLQReoo + XOjZx/B8fkJIX6MeF6rvKnhPvKMC0EnWr9XRN27iQwhJXMqevUh2VNc0dlwA2vRi4No3q0G23swIISS5 + KTvWwtC1fiw7L+4sCLSn6jv2BeWx4l/qzYoQQtKTamnwjcGGRxBPxjo3AGar1aN5w9Hh1+rNiBBC0pvl + w8M7+671sdATjxs6PCD31LYht5Hj1QO69GZDCCHZiTphMPAsT3Z2P5Sd3tp4JwjkzHr1+379rn3cvIcQ + kpeoJxDqRxE/E+sUgax7Tv00VnUWvkFvDoQQkr/oWw2/V3aKP5U4KoCsmvY96+rQs/+Gy/gIISSWoGS9 + Rt3ZTHaW98U6TyCdHPvhDUe67D/TzZwQQshsqXj2YOiIc2UnuryhUwWSzBHLQtf+ZmVk0NbNmRBCSKtR + J0epEwcDT1wiO9dyQ2cLJENFndyqbtgTFYvb6OZLCCGkE4nG9tlRDgQO9V1xlexwq7EOGOi1imyLV8o9 + /g9y+R4hhPQo0dDQ9vVnEHBkAL1Vka6R7e5Dk+P2Lro5EkII6UfUYKDiiANlx3yR+v11s84a6IQXAtf+ + nrpaRbU13ewIIYQkKfWnE47YRd8TS+Ve2r2y834x1pkDzXhItp8z1fknXLZHCCEpTNUr7qGenV5/OJEn + Vho6ekCZrJ/E51lHV8as1+vmQwghJAtRVxSoS7NkJ/9PssP/pTS9WQFAvkwFjvhF6IjTKs6A4Fa8hBCS + o6gzt8uevUjfqOVmWRTUCV6mYoH0m67/JOSJM9XJo5zARwgh5P8Sje+9XdkV+4Wu+LQsGOrWxC9sVkCQ + Ls+rW+/Kgd2papAXTSzYVq9mQgghZO6sdop7Ba51WOiIb8hicrcsLNx/IHkqcs/+Lrl+zpL/e2jNs/bU + q48QQgjpTNQZ4f6ItUA9wrV+pYG6JpxLD3tpTejYt6tir07urO/dj++9nV49hBBCSG+zetGiV6hipIpS + fU9UnVPAwGA+1ujf7C9R52io3+3Vnn1UKGyhFzkhhBCS3ISjw6/1HetdcmDwEd8VZ8hi9oPAtX4tC9zq + WMHLo1X1Iu/aV2xYNvaR9XMwFhd304uPEEIIyV7Umejq54RwxD5AHTnwHfufZVG8WBbFG+Ug4X75//9R + WqeLZZqoaVbT/tsN8yIu9l37C/X7MTgD42qelw8P76wXAyGEEELiUYe8/bGFr/bHBt4mi+iI71kHha44 + Sg4QPqkGDKFrnSML7GWhY/+k/rODK26r71U79sNyr/pJ+d8r5H+v/D/mSx3VSXSbv2dF/W/Vs+zre+jy + M+Vnb/gO+V2eOHvDYMX6ZP3Ihpym+rSpcyPktHKYnpCkp1D4/73pE6RKlTYXAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAZdEVYdFNvZnR3YXJlAEFkb2JlIEltYWdlUmVhZHlxyWU8AACTRklEQVR4Xu293a9t2VneieR/ + wDdpio+kCwfiY7tiAgpXQcIhJsEuR/IFCkJILXPBJVZdRIqEhOSIi06r6biJbbqdYA7E3Tb+gJKwkIzU + doHIDaC4nAAWcRwXrjrlOuX6OFXlKp9TNj67x7PGHmeM8Y7nHXPMOddae308Fz/tc8bZe605nrP3+D1z + 7jXH+o5/9tA7hBDiZHjml3/wtTff9ra3Bd4TeORrDz742NMPPnhxj3e8o+Kpt73t0a+94x0PX37+29hj + CnGK0EEhhDgmIP0g8l/YiDxI3lIVAGBKQEl4jFs33/726yoD4tShg0IIcQwE6d+/kfXb336xIcjdoykB + gBSARCgCm6sDKBbsuYU4duigEEIcMkn8TyXxW4LcGXNLAEhFQFcExKlBB4UQ4lDB7+pxmR7yLxktAWBJ + CbgsAu/FrxvYcQlxbNBBIYQ4NJ76yZ/8B5tL8kHuHk0JAEHwjKYEgEL6jE0RePDBx3As7BiFOCbooBBC + HBL4PfzmrP9tb8NZeCTInTGnBIBFJSCAKxHsWIU4FuigEEIcCpA/hP/Vn/zJLP+JEgBWlQBQSJ9x+SsB + vEjwfnbcQhw6dFAIIQ6BIO7rX4X8L6nknwhy92hKAAhy91hSAi6vTOhOAXF00EEhhLhqgqwr+XdLAAhy + 91hVAoARf0n6lUDgYb1AUBwTdFAIIa6SIPRfwCV/VgASTQEAQe4eTQkAQe6MuSUApKsBul1QHAt0UAgh + roIHHnjgNRDoRv6JIHYPWgJAkLvHaAkAC0sAHve6rgaIQ4cOCiHEVRDkff/jP/ETt6oCsLQIBLl7NCUA + BMEzmhIACukzNkXgwQcf09UAccjQQSGEuAqCMB95Msg+sboEgCB3xpwSABaVgIBuFxSHCh0UQoh9E2T9 + C6X83RIAgtgZjfwTQe4eq0oAKKTPQAkIx/CoNg8ShwYdFEKIfQI5PvnP/lkj/5LREgCaApAIgmc0JQAE + uXssKQEB3S4oDgo6KIQQ+ySI8dFNAZhbAkAQO6MSf0mQu8eqEgCM+C2XvxJ4RC8QFIcAHRRCiH0RpPze + e/IvCXJnzCkBoCkAIMjdoykBIMjdY0kJwNUAvUBQXDV0UAgh9gEkeIPJPxHk7rG6BIAgd489lACgzYPE + lUEHhRBi10B8T7z1rY+hACRoCQBB8IymBIAgdo/VJQAEwTOaEgAK6TM2JUC3C4orgg4KIcSuefytb324 + lP/SEgBWlwAQ5O4xWgLAohIQCMfwXpaTELuCDgohxK5Iu/3d+Kf/9GJDkDtjdQkAQeyMRv6JIHePVSUA + FNJnXJYA3S4o9gYdFEKIXREkt9nt714BmFsCQJC7x2gJAJX8S4LgGU0JAEHuHktKwGUR0O2CYufQQSGE + 2BW4Da6Sf0mQO2N1CQBB7IxG/okgd49VJQAU0rekEoCcwnHczzIUYhvQQSGE2AVBaL/wRBA9oAUABLkz + aAkAQe6MOSUAVPJPBLl7NCUABLl7zCkB4LII6HZBsTPooBBCbBv8bhuX/lMB6JYAEOS+tgSA1SUABLl7 + rCoBwIi/JF0NCOh2QbF16KAQQmybINJHn/iJn7gn/6UlANASAILgGU0JAEHsHk0BAEHuHk0JAEHujLkl + AOhqgNgFdFAIIbZJENd7NvJPBLmvLQK0AIAgd4/VJQAEuXuMlgCwsATgGN6rqwFiG9BBIYTYFjhrreRf + EuS+pgSA1SUABLF7NAUABLl7NCUABMEzmhIACukzLkuAbhcUq6GDQgixDdJuf1T+iSD3tUWAlgAQ5O6x + ugSAIHfGnBIAlpQAgCsrLHchRqCDQgixDYL4rj8eJJ+gBSAR5L6mBIDVJQAEsTNoAQBB7h6rSgAopM+4 + LAG6XVAsgg4KIcQa0m5/j7/1rffkv6QEdItAkDuDlgAQ5O4xWgJAUwASQfCMpgSAIHePJSUgcCscgzYP + ErOgg0IIsQZc+g+yv7UpAKQEAFoAEkHwQyUABLkzDqkEgFUlABjxWy6LgG4XFMPQQSGEWAMuS9+Tf0mQ + +5WXABAEz2hKAAhi91hdAkCQO2NFCdDtgmIIOiiEEEsJEvwFKv9EkPtwEQhyX1sEaAEAQe4eq0sACHL3 + GC0BYGEJwDHodkHRhQ4KIcQS0m5/X2HitwTBD5UAEOS+pgSA1SUABLF7NAUABLl7NCUABMEzmhIACukz + NkXgwQcf0+2CwoMOCiHEEoL0HoX8E1T8JUHuS0vAkiJASwAIcvdYXQJAkDtjTgkAi0pAQLcLCgYdFEKI + uUAyX/kn/+RiQ5D70hIwtwhQ+SeC3BmrSwAIYmfQAgCC3D1WlQBQSJ9x+SuBRwO6XVDcgw4KIcQccJn5 + nvxLguCXFgEq/0SQ+3ARCHJn0BIAgtw9RksAqORfEgTPaEoACHL3WFICArpdUNyDDgohxChptz9aAECQ + +9ISMLcI0AKQCHJnrC4BIIid0cg/EeTusaoEACP+kuJXAo/oBYKCDgohxChBaO+l4i8Jcl9TBKj8E0Hu + w0UgyJ1BSwAIcmfMKQGgKQAgyN2jKQEgyN1jTgkA6WqAbhc8b+igEEJMkXb7++sg+ASVf0mQ+9IS0C0C + Qe7DJQAEua8tAWB1CQBB7h57KAF43Ou6GnCe0EEhhJgC0ghSvlUWgLklYEkRoAUgEeS+pgQAWgJAEDyj + KQEgiN1jdQkAQfCMpgSAQvqMTRF48MHHdDXg/KCDQggxRZDzw3/94z9+sSGIfU0RaKRvCXIfLgJB7muL + AC0AIMjdY3UJAEHuHqMlACwqAQHcycH+r8VpQgeFEKJHkNUv3JN/SRD70hIwWQSC3IdLAAhyX1MCwOoS + AILYPZoCAILcPVaVAFBIn4ESEI7hUW0edB7QQSGE8AiCuD/I9xYtACCIfU0RoPIvCXJfWgKWFAFaAkCQ + u8fqEgCC4BlNCQBB7h5LSkBAtwueAXRQCCE8ghgefYyJ3xLEvq8SMLcIUPkngtwZq0sACGJnVOIvCXL3 + WFUCgBG/5fJXAo+E49DmQScKHRRCCAZ+Rwz5J6j4S4LYl5aAJUWAyj8R5D5cBILcGbQEgCB3xpwSAJoC + AILcPZoSAILcPZaUAFwN0AsETxM6KIQQFvxe+LF//I8vNgS5Ly0Bc4sAFX9JkPtwEQhyHy4BIMh9bQkA + q0sACHL3WFUCgBF/yWUJAA/rdsHTgg4KIUQJFv4goUfvFYAtFAEq/pIg9zVFgBaARJD7mhIAaAkAQfCM + pgSAIHaPpgCAIHePpgSAIHfG3BIANiVAtwueFHRQCHHefPGLX3zt5z73uZ9Lfw/yeS+E/2VbAECQ+9IS + MLcIUPGXBLkPF4Eg97VFgBYAEOTusboEgCB3j9ESABaVgEA4hveW3y/iOKGDQojz5oknnvjM448/foGP + j/2rf/WuRvqWIPc1RYCKvyTIfbgIBLkPlwAQ5L6mBIDVJQAEsXs0BQAEuXs0JQAEwTOaEgAK6TMuS4Bu + Fzxy6KAQ4ny5efPmOyH/xF9/6b9f3PjFX+Rn/5Yg96UlYG4RoPIvCXJfWgKWFAFaAkCQu8fqEgCC3Blz + SgBYUgIui4BuFzxS6KAQ4jz5q0f/6P4g/efKApB46lOfungsiIGKvyTIfU0RoOIvCXJfWgLmFgEq/0SQ + O2N1CQBB7IxG/okgd49VJQAU0rekEqDbBY8TOiiEOE/SpX8PXA14/N3vvvqrAUHua4oAlX8iyH24CAS5 + M2gJAEHuHqMlADQFIBEEz2hKAAhy95hTAsBlEdDmQUcGHRRCnB+f//znf4lJPxHKwb0/37h+fftXA4LY + Z5UAEOS+tATMLQK0ACSC3BmrSwAIYmc08k8EuXusKgHAiN9yWQR0u+CRQAeFEOfFzZs332Qlb8G/lXzt + T//04is/93M7vxpAxV8S5L6mCFD5J4Lch4tAkDuDlgAQ5M6YUwLA6hIAgtw9FpYAbR50BNBBIcT5gPf1 + D0LvXvoHtgDc4/3vP/oXCHaLQJD7cAkAQe5rSwBYXQJAkLvHHkoAjuG9uhpwuNBBIcT5ECT+Pgj+xo0b + VPwljfwD+LrN1YCf/unpIhDkvqYIUPGXBLmvKQK0ACSC3NeUALC6BIAgdo+mAIAgd4+mBIAgeEZTAkAh + fcZlCdDtggcKHRRCnAd/9md/9uNM9B6sACTwAsEnf+VXdLtgSRD8UAkAQe4eq0sACHJnzCkBYEkJAHgf + CfY9KK4OOiiEOH2w21+QOr3lz4OJH1cAEvj7M5/9rG4XLAlyZ6wuASCInUELAAhy91hVAkAhfcZlCdDt + ggcEHRRCnD5B1pO/97eU4i+xJeBgbhcEQfBLiwCVfyLIfbgIBLkzaAkAQe4eoyUANAUgEQTPaEoACHL3 + WFICArpd8ECgg0KI08bu9jcHK39QFoDEk08+efH0Rz+q2wVLgtwZq0sACGJnNPJPBLl7rCoBwIjfclkE + dLvgFUMHhRCnS2+3vxHmFAB8fOYLf76XqwFU/CVB7muKAJV/Ish9uAgEuTNoCQBB7ow5JQCsLgEgyN1j + YQnQ7YJXCB0UQpwu3/72tx+BnJncRxgtACCVgA3Xr+t2wZIg97UlAKwuASDI3WNVCQBG/CWXJQDHoNsF + rwA6KIQ4Te7evftQ4OJv/uZvLp577jkq+ClYAQCl+BMoAAl8zvDmQUHua4oAFX9JkPuaIkALQCLIfU0J + ALQEgCB4RlMCQBC7R1MAQJC7R1MCQJA7Y24JAJsi8OCDj+l2wf1CB4UQpwd2+4P8S1555ZWNqJnoPaz4 + E1b+oCwA4N7YCdwu2C0CQe5riwAtACDI3WN1CQBB7h6jJQAsKgEB3S64P+igEOL0CMJ/1BYAgKsBTz/9 + NJW9x9ICUILbBbF5EBV/SZD7miJAxV8S5D5cBILch0sACHJfUwLA6hIAgtg99loCQCF9xuWvBB4N6HbB + HUMHhRCnRRD9L1vxl3z729++ePHFFzfSZsK3jBYAwOSfwO2CN37xF3W7YEkQ/FAJAEHuHqtLAAiCZzQl + AAS5eywpAQHdLrhj6KAQ4nQIcn8Lk34C8k9885vfvHjqqaeo9EvWFgA8R/XxU5/S5kElQe6M1SUABLEz + Gvkngtw9VpUAYMRfUvxK4BG9QHA30EEhxGkQBP/awGOl8C1lAUi88MILVPwJVgDAaAFgHMzmQUHua4oA + lX8iyH24CAS5M2gJAEHuHqMlAKwuASDI3WNOCQDpaoBuF9w+dFAIcRoEwT9shV/C5J+4ffv2RsysAIBt + FIDySkACtwvOvRpAxV8SxD6rBIAg96UlYG4RoAUgEeR+ECUABLl7rCoBwIi/5N7VgLe//bquBmwPOiiE + OH6w2x+TfoJJP4EXBgL8SsC7XXC0AAArfo9UAoZvFwRB8EuLABV/SZD7miJA5Z8Icl9TAgAtASAIntGU + ABDE7rG6BIAgd8bcEgA2ReDBBx/T1YDtQAeFEMdNEDwu/d8qhV/CpF+SCkDiG9/4xkbk2y4AkL39WPLE + +9+v2wVLgtzXlgCwugSAIHeP0RIAFpWAgG4XXA8dFEIcN0HijzDxJ6zwS6z8E7gaUN4uyAoAmFMAGLYE + bK4G6HbBTJA7Y3UJAEHsHqtLAAiCZzQlABTSZ6AEhGN4VJsHLYcOCiGOlyD4zW5/Hkz6CSb+km9961sX + L7300kbqc64CMNEnIHn70YIXCJ7C5kFU/okg97VFgJYAEOTusboEgCB3xpwSAJaUgMsioNsFF0AHhRDH + S5D8dSv9BJN+CZN+CQoAuHPnzsXNmze3UgAsrADgygOeT7cLGoLcGatLAAhiZzTyTwS5e6wqAaCQPuPy + VwKPhOPQ5kEzoINCiOMmyB5XAZrXADDpJ5jwS5L8S27dujVUAACTPYDg7UcGCgB45itfOozNg4Lc1xQB + Kv9EkPtwEQhyZ9ASAILcPUZLAGgKQCIIntGUABDk7rGkBAR0u+AM6KAQ4vi584kffvgbz3xxZ/JP4AWC + EPRUCSilP4WVP0gFIP396Y9+dPtXA4LYZ5UAEOS+tATMLQK0ACSC3BmrSwAIYmfQAgCC3D1WlQBgxG+5 + LAIP63bBaeigEOK4uf3bb3rnsx/+wYsbH3rg4qX//D4q/QQTvoWJP4EXB6bbBZcWAAjdfrSkAlAWgWe+ + 8Od72TyIir8kyH1NEaDyTwS5DxeBIHcGLQEgyJ0xpwSA1SUABLl7LCoBul1wEjoohDhenv3Q/fd/46Nv + vAX5J7768QcvXnn+6UUFgEk/keSfePnllzcCn1sALFb+wBaABF4foNsFDUHua0sAWF0CQJC7x85LQCAc + w3vZz4lQARDi5Ljz8Tc/8vRvvOGe/BO4IvDSX3xkZ/JPvPrqqxfPPPPMrBIAwduPDK8AgOHNg4Lc1xQB + Kv6SIPc1RYAWgESQ+5oSAGgJAEHwjKYEgCB2j6YAgCB3j6YEgCB4RlMCQCF9BkoAXiCoXwm00EEhxHES + zv4fSpf+PV749P9y8a3bt6jwS5j0S5j8EygBuF0QMh8pAIy5BQDgBYKncLtgtwgEua8tArQAgCB3j9Ul + AAS5e4yWALCkBITnf1QloIYOCiGOj+d+6w3/4NWP//3NmT4Tfwk+5+tf+gMq/gSTfoJJPwH5J3C7IMTc + KwAQu/fRMlUAAMae+exnD27zICr+kiD34RIAgtzXlACwugSAIHZGI/9EkLvHqhIAjPhLVAJa6KAQ4vi4 + 87E3P4oCAG7/9psu2K8BLC/9p1+iVwOY9BNM+olS/iV4d8Ek/FFGCwCwJQAczO2CIAh+aRGg8k8EuQ8X + gSB3Bi0BIMjdY7QEgKYAJILgGU0JAEHuHnNKAAhF4GH283OO0EEhxHFx5xM/9J4k/xJ2NeArH7x27yPA + CwRfvvGnQ/IHTPwJJv8EXiAIWTPZAwjefmRY+QNWABLYPOivw8JPxV8S5L6mCFDxlwS5Ly0Bc4sALQCJ + IHfG6hIAgtgZtACAIHePVSUAGPGX6H0EInRQCHE8PPdb197C5J945SNvnCwBALcL7uLsH+BXAQlsHlSK + v8faAoAXI24+6nbBmiB3Bi0BIMidMacEgNUlAAS5e8wsAWd/iyAdFEIcB/h95u2PvfkxJv4S/EogXQ0o + 5W9LAK4GYPOgbcoflAUA4GoAZM6Ebz9a5hQAy43r12dfDaDiLwliX1MEqPhLgtyHi0CQ+3AJAEHua0sA + WF0CQJC7x6oSAIz8AfYJYD9T5wQdFEIcB7c/+SPXmfBL7nzsgXt8/f95PZW/LQK4XXBU/oBJP2Hln7h9 + +/Zm86CyAFhGCwBgwgf3rgJcftTtgoYgdwYtASAIntGUABDE7rG6BIAgd8ZoCTj3XwXQQSHE4YPd/pjw + S0r5A1wJ+MZH37h5gWApfMv/+LW/t7ldMF0NYNJPMOknmPgTKADgxRdfrIRvPzLmFAALigDQ5kGGIPe1 + JQCsLgEgyN1jtASAqRLwtXe849Y53xVAB4UQhw0WrVc/8YO3mPRLrPwTKAH4lQBk710JQAnA33G7IBM/ + YNIvYeJPpAIA8H4CkHIqAgkmfzCnANgrAOnPGw7wdsHJIhDkPlwCQJD7mhIAVpcAEMTusboEgCB4RlMC + QFECzvkqAB0UQhw2eKMfJvySnvwT5a8EkvTTn0v+x++9++LVl5+bVQCY9BOl/EtwuyAEn+TvlYA5BaCk + LAP3OJHNg6j8E0Hua4sALQEgyN1jdQkAQe6MOSUAeCUAVwHYz9g5QAeFEIcLdvtjwi8ZkT945SNv2MB+ + JYAyUBaCdLvgruSfwAsEIeneVQBWAEAp+5Ik/vLvFt0uaAhyZ6wuASCInUELAAhy91hVAkC8CnCWdwTQ + QSHEYYI3+pm69O/J3xYA3B6YCsDL/++1ixf/Y5Z9Kf5UBBLYPOj2S89Q8QMm/RIm/RL8OgA8//zzW/s1 + QAKiTx8tzz777OFsHhTkvqYIUPkngtyHi0CQO4OWABDk7jFaAsDqEgCC3D3KAoAdAsPnX2c/b6cOHRRC + HCblbn+MUv62AHjyTwUA4FcC6WqAFX9JuhowtwAw4Zck+Se+/vWvb4S9tgBA8GzMghIAltwuOFkEgthn + lQAQ5L60BMwtArQAJILcGXsvASDI3WNFCTjLXwPQQSHE4eHt9lcyIv9YAFr5pwIAbv3m91dXAmwBSGDz + oF3JP/HKK69sbhdcUwAABG8/WlIBwPOd4+ZBVP6JIHcGLQEgCJ7RlAAQxO6xugSAS+lbyhJwjr8GoINC + iMMivdFPj23JP5F+JcDED/7br37f5mPaPIhJv4RJv4TJP4ESgHcXhLh7BQAk4U/RKwAlNz/4Qd0uWBLk + vrYEgNUlAAS5e4yWAHBZAM7ubgA6KIQ4HEZ2+9u2/F/6cDi7vwS/ErDyt/zlB//RZvMgJn7AhF/CpJ+A + /BN4gSBEvaQA4OvsRwYrAWnzICr+kiD3NUWAir8kyH1NEaAFIBHkvqYEgNUlAASxe6wuAcDI/x5n+DoA + OiiEOByeu/4D72XST3jytwXAvujPKwCl/HEV4MX/+AMXL/zWD1RXA9LZf/lx8+ffe/fmBYK7kH8JNg9i + 8gel9KcYLQDghRtP6HZBSxD8UAkAQe4eq0sACHJnNAUAsALwtrc9wn7+Thk6KIQ4DKbe6KeUvy0Anvx7 + Z/+l/MsCkEpAeTWgkX8xhs2D1sofMPkn8CsBCHtOAcDn248WJn+A1wVsXhvw2c/qdsGSIHfG6hIAgtgZ + tACAIHePkRLAfgZPGToohLh6Rnb7G5F/LADzL/1b+b/wW9+/4bnfeN29ElBKPxWBxJc/8282VwOY+BNM + +gkm/QR+FZDAuwtC5qMloGRJAQC4GqDbBQuC3Bm0BIAgd4/REgBoCQBB8IymBAAVACHEoTG1299+5Z8L + AO4QuPWbf3fzK4Eke1YAAF4bgNsFtyl/UBYAkF4gOFUAIHj7kTFVANLfd7J5UBD7rBIAgtyXloC5RYAW + gESQO2N1CQBB7AxaAECQu4dXAtjP4SlDB4UQV8vXPvS6dzHpJ65a/uD563/34plfv7+Sv1cENlcDBuUP + mPQTVv4l2DxozhUAMFoAQFkCEud4u2C3CAS5M2gJAEHujDklAKwuAQH2s3jK0EEhxNUxtdufJ39bANa8 + 6K8uAFz+kdfd+5UAE3/iy//uey/+6sPvvMDtgmvO/pn0E9g0COD9BJjoExC8/Whh8gesAKB0AGwepNsF + C4Lc15YAsLoEgCB3DxUAIcTBcOfjb36EiR+U8rcFwJN/7+y/lL8tACPyTwXgud/4voun//3fofIvQVHA + 5kFM/IBJP8GkX5IKAMCvBCDnUvweawsASCUg3S44WQSC3NcUASr+kiD3NUWAFoBEkPuaEgBoCQBB8Iym + BIAgdo+lJYD9PJ4ydFAIcTVM7fY3Iv9YALZx6b+Uvy0AtfzBsx/6vuZXAom//LexHPyX9/69zZ9xNeCV + 55/eWgEo5V/CrgZA8PYjY0kBwAsS8VGbBxmC3NeWALC6BIBC/Bb2M3nK0EEhxP6Z2u1vv/Lvnf2X8q8L + wLMfun/DE7+WrwYk+eNj+jNAUcDtgruSP8CVAOwZAHmXJcAyWgBArwCU4HbBr/z0T3PxlwS5rykCVPwl + Qe7DRSDIfbgEgCD3NSUArC4BIIidQQsAIPIP44+yn8tThg4KIfbL3bt3u7v9HY78YwHoyR9XAcDND/7t + e7JPpBJQgs2DcDWAiR8w6Zcw8SdQABKQcil8+9HC5A9GCwCuBhzM7YIgCH6oBIAg96UlYEkRoCUABLl7 + jJYA0BSARFEAtBGQEOJK6O3258nfFoB9veiPXfpPBSDJ/5lf/58vvvYfIulqAJP/PT74jzZXA+YWACb9 + RCn/hHc1YBcFAGxKwAsvaPMgS5A7Y3UJAEHsDFoAQC4Aei8AIcR+ufPpn3onEz8o5W8LgCf/3tl/KX9b + ALYp/7IAfO0//J2xEhDA7YK7kn9J2jwIovcKABgtAMArAOl1Afu6GkDFXxLkvqYIUPkngtyHi0CQO4OW + ABDkzphTAgArAZsXAerdAIUQ+2Rqt78R+ccCsI1L//Nf9JfknwtAK3/cHQDwKwHcDsjED/78f/+eDXiB + IDYPYtJPMOmXMOkncBUAbM7Mg+R3eRUgFYCSpz/60dlXA6j4S4LY1xQBKv6SIPfhIhDkPlwCQJD72hIA + 1pYA/Cyyn9FThg4KIfZDb7e//co/FoBp+dsCUP/e35P/0//+b28KAMDVAE/+4L/8b9+9AbcLMvkDJv0E + k34iyb8Eot71rwFKMPbMV740drsgCIJfWgSo+EuC3NcUAVoAEkHua0oAoCUABMEzmhIAgtw9igJwdi8A + BHRQCLF77vz+O36eiR9chfx7l/7Xyb8uADc/+L0XT/3f33vvVwJJ/OWfUwlImwdtQ/6AFQAAMe+rAABc + fQC6XdAQ5L62BIAFJeAX2M/oqUMHhRC75a8e/SN3tz9P/rYAePK3BcCTfy4A233RH+Tvnf0n+SfSrwSS + +EswjhLwX9/3wxcv/cVHJuUPmPQTTPyJJGSIfKQEWPkn5hYAPPdm8yDdLpgJcmesLgHAyD8RCsD97Of0 + 1KGDQojd4u32V8rfFoBa/mNn/6X8bQHYpvxHLv1D/nUB+J6Lr/5f33Px5K99d3P2XxaBdDUAtwu++MyT + VPyAST9hhV+SZJyAtKcKAFhTAEB6vs0x3Hji4slf+RXdLlgSBD9UAkCQu8dUCTjH2/8SdFAIsTt6u/2N + yD8WgGn52wKw7xf9jcg/8t2bEoCrAUn66ezflgDcLnjjLz+7NfmDUv4JCBqS30cBKMHVAN0uWBDkzlhd + AkAuAGf36v8EHRRC7Abs9vfy7/zoAcg/FoBp+ccCwOUfC8C0/GMB6Mk/8fj7vpP+SiAVgIS9GsDEn2DS + TzAJJyBpSJ3JH1j5A1YAgJU/YM+54VA2DwpyX1MEqPwTQe7DRSDInUFLAAhy97Al4GsPPvgY+zk9F+ig + EGL7YLe/Ox9786OHIv/epf9S/rkArHvRXyt/WwC+azOGP3/x335ntwBgDFcDcLsgk36CST9B5XtJKWoI + HHIfKQDAyh+Uj5dgzwvS8T31qU9t/2pAEPusEgCC3JeWgLlFgBaARJA7Y00JOOezf0AHhRDbx9vtz5O/ + LQCe/G0B8OSfC8DVvejPP/v/rs3Hcjz9SqCUflkCwKP/63duNg+aK3/A5JtgwobIR0qAlT9gjwfYc5fH + iNsFH3/3u3W7YCLInUFLALiUvuVS/mf7u/8EHRRCbJfnfuvaW6bkbwtALf+xs/9S/rYAbFP+uQD05T96 + 6T+d/dvxGx/4rnuvB2CgAADcLghZjhYAJt4EE3UCMt9nAUhg8yDdLlgQ5L62BDz1kz/5D9jP6jlBB4UQ + 2wM7jHlv9DMi/1gApuVvC8DIi/5G5Z8LwPZe9JdJ8ucFANirAUn+ZQnAWw1/5c9+e2fyB0noEP2cAgDY + 47FjYMcMnvnCn49tHhTkvqYIUPGXBLmvKQK0ACSC3NeUADBSAsLZ/9nt+8+gg0KI7eHt9rdf+ccCUMo/ + F4Cre9Fffenf/nuUfwIvECxLwD3xmz/jagBeIMgkyoRbwiSdsEJn8k/YzwXsMdkxAHbs6cqGbhc0BMEP + lQCAM/8z3fWPQQeFENshCJ2+0c9VyL936b+Ufy4Au3/Rny//+O9lAXji/fdtwAsEk/RZEcDHdDXASpTJ + NsEEnWBCT+y7AIBD3DyIir8kyH1NEaDyTwS5M2wBCM9561w3/WHQQSHEerzd/jz52wLgyd8WAE/+uQAs + +b1/X/69S/9Z/rYAtHLP/2b/PV/+twUA/PWv/q3N1QBbAkownm4XhECZaBNMziVM6Ik1BQCw47HyB2UB + AJjXQdwuCILglxYBKv9EkPtwEQiCZ5QF4Fy3/PWgg0KI9bDd/kr52wJQy3/s7L+Uvy0Ay+UfC0Ap/1wA + tvOivyj/+uyfFQSvAODXAQBXA0rhlwUgga2EcbsgE22CiTnBZJ5g8gfscwF7fHY8rAAAWwKwB8Izn/2s + bhcsuRS/JTzvw+zn9Jyhg0KIdQSBPmTlbwuAJ/9YAKblbwvANl/0x+UfC8A25I+PU68N8ORfFgCAqwGe + /EtwuyCTLZNygkk8wcRfwr6GPQc7JiZ/YAtAKgG4GnButwt2i4CV/0/8xK1zfLvfKeigEGI52O1vzqX/ + 3cg/FoBS/rkAXO2L/iD0+nPazyvlbwtAKX/wlX/3P1W/EuiBzYNwu2ASLRNyggm8hEk/gTsE2New5ynF + XzKnACRwu+DcqwFU/CVB7GuKABV/SZC7hRYAEOQ+XALAZQE49w1/POigEGI5bLe/q5A/v/Tfyj8XgN2/ + 6A8yx/i2zv4h/5LyVwIeeIFguhrAhJxgAk8w6SfsPgHl17HnAVb+YLQAgLIEoODodsHMU29723vZz6lQ + ARBiq7A3+vHkbwuAJ39bADz55wJw2C/6639e/ty5BQBXARIjvxJItwsyIZfStljhl5Tyn1MCRgsAmCoA + iZsf/ODRv0CwWwSC3KeKwBNvfetjuvTvQweFEPNhu/2V8rcFoJb/2Nl/KX9bAJbLPxaAUv65AGzvRX/4 + 2H6e/dxa/rYAlPLvFQAwejUAtwuWMi5lzbDSL2EFIIF/x9eXz5XYRQF4+eWX4+ZBP31YtwtOFoEg9+ES + ACD6grIAaLe/PnRQCDEPttvfqPxjAZiWvy0Ax/SiP4B/m/rcNZf/bQFIMPFb0u2CkLEVfokVfgmTfkl6 + a2Erf8AKAFhTAABKAOZ1jpsHabe/aeigEGIetz/5I9dL+dsCcBXyzwXg6l/0h39rP7f9/FL+tgCU8rcF + gIm/ZORqAG4XvPGXn6XiB0z6CSt7C+SfwN/xeCMlYLQAAK8AvPLKK/FqwC5uFwRB7PsqAaNFQLv9jUEH + hRDj3Pn0TzW7/e1X/rYAHNaL/vDnOZ+/iwIAyh0Ee+AFgnPkD6zwLWUBSODr9lEASg5m86Ag9zVFgMr/ + kvDvt3Tpfww6KIQYA5f+7S1/nvxtAfDkbwuAJ39+9n9YL/oDY59ff42Vvy0ApfxHC0Bi9HbB8mqAFX4J + E34Jk38JHn9OAQBLC0DiqU996mRvF9Ruf+PQQSHEGPaNfkr52wJQy3/s7L+Uvy0Ay+UfC0Ap/1wAtvei + vyj/dOnffr7/NQlP/rYAMMlPMfIrAYCrAUz6CSb8Eib8kqeffnoDHosVALCmAABWAPBrgRduPHFymwfp + Pf7nQQeFEH0eeOCB19z5/Xf8/C7lbwvAsb3oD38e/Zp9nf1bRm8XxL31Vv6ASb+EST+R5J/+jI/sSsBo + AQBzCkDimV//9ZO4XTCg3f5mQgeFEH2CRJs3+hmRfywAu5F/LgB9+fcu/XP5xwIwR+T4WH/N2NftuwCA + ObcLblP+6aMFvxLYZwHYlADcLvhzP8fFXxLkvqYIUPGXBLkPFwFTALTb33zooBCij93tb7/ytwXgsF70 + B/B541+338v/HqNXA3DpnAm/xAq/xAo/jZX/hj/3CgBYUwCALQHg5vvff3RXA/A5N9/+9uvs51T0oYNC + CB+7258nf1sAPPnbAuDJn5/9H96L/vBvx3L2b5lzuyATfyLJnuFJn5GuBqwpAGC0AHzjG9+4+Nqf/unB + bR7ExJ/Qbn/LoYNCCM7mjX4WyX/s7L+Uvy0Ay+UfC8AS+ftn8bXEk7zxZ/Z1SwtAKX9bAJjAt8Ho7YLY + PAivDZgrf4s3nsBj7rMAgFeef/oobhfEmC79L4cOCiFa7t69+9ry0n8pf1sADln+Y7/3ny9/gM/tf639 + +lr+4KoLQGLO7YKj8vc+joAXCE4VALCmAIBUAsBONg8KYp9VAsCl7G0J0G5/66CDQoiW567/wHtHzv5L + +ccCMC1/WwCO7UV/AP/efu3411v52wJQyn8fBQDMuV0wid6DSX2Emzdv3gMvPpwqAaMFAEwVAICrAYd2 + uyA+X7v9rYcOCiFq7Bv97Ff+vbP/w3jRH/4+/+sP48V/I4xcDdjcLviFP3fl733sUco/gfH0uoDRAgCW + FgBw+/bti6c/+tGD2TwIt/xpt7/10EEhRMbu9ufJ3xYAT/62AHjy52f/h/eiP4CvS1+/pEAkDrUAgDm3 + Cybxj0i+BysACVwN2FcBAHfu3Ll3u+Dk1YAg9zVFgIq/QLv9bQc6KITIlLv9jcs/F4BR+ccCsA35xwKw + O/nb3/unS//zHuPQL/97zNk8yJ7t2489mPQTTz311AZ8HrsSsKYAAFYAcBUAJQAfr3LzIO32tz3ooBAi + Uu72V8rfFgBP/rYA9OVvL/0f/ov+8Pexx+g/DvDkbwsAk/K+mXM1wIp9BCb9klQAAP6OFwguKQBgTgFI + oAhcxe2Cm0v/b3vb/exnVcyHDgoh3vEdf/XoH1W7/Y3IPxaAafnbAnCML/oD/mPMe5xS/rYAlPI/lAKQ + YOK3pNsFIfbRXwlY4ZeU8i/BY6erAbsuAAm8QHCfmwfplr/tQgeFEOHs/+NvfuRq5N87+z+MF/0BfO65 + FwAw53ZBJnsLk36CiT/x5JNPbj4HVwNYAQBrCgBgJWDz2oBd3C4IigLw+Fvf+jD7ORXLoYNCnDtBpA9t + S/62AHjy52f/23nR35j8e9KuhY1/H/8Vgn2s4778z+j9SgCvGfhvv/p9G3C7IJN+wgq/hEm/BAUggT0J + 1hQAMFoAwKuvvrrTzYO0299uoINCnDPY7e/l3/lRveivI2w8ztLHOqWzf4u9GgD5/+W//Tv3CgD+jBcI + elcDmPgTTPoJSN9+xNfgVwJTBQCsLQC4CpDY9u2C+Hdd+t8NdFCIcybt9lfK3xYAT/62APTlby/9H/6L + /gC+vn6s+HjlY815PE/+tgAw4R4i5dUAK/8E3k/AXg2wwi8pZW9JZ/0euF1wnwUA4A2ThjYPuhR8rwg8 + 9ba3vZf9nIr10EEhzpVyt78R+ccCMC1/WwCO9UV/+Jx5ZcI+Zv144NQKQAJFIImffQTpdkEm/QSTfgkk + 731MoGCkqwFrCgAYKQCJNbcL4uu0299uoYNCnCPlbn/7lX/v7P9wXvQHpsuEfczy8drHLOVvC0Ap/2Mr + AJgL/h+e+DV+BaAEVwNwuyCTP0iiZ5SSHwEvEBwtAGC0AABWAPDagLR5EBV/SVECUhHQbn+7hQ4KcW7g + BUa3P/bmx7Yhf1sAPPnzs//9vugvSprJuhY1wNdPF4Dy8exjnv7lf4DjRU7l/0V55l9+LEm3C86Rv/ex + B64G2CsBTP5gbQH45je/ueH2S8/Mvl1Qu/3tHjooxLlx+5M/cr0nf1sAlrzob3vyjwXAk79/6b8UtZW1 + L2rIGZ/jPaZfAL7bPK4vf1sASvkfWwHA3Nn/B64GWOk3XN4uuO0z/5IbN25sPuL9BKZKwNoCgCsAJaOb + B2m3v/1AB4U4J4Lc32nlbwuAJ39bADz52wKwTfmP/d5/+Yv+MMYfMz5ufsz+455DAcA88v9F/P8o/0+Q + S+/XAQlcDWDiT0Dg3scekH8JNg9KVwNGCwAYLQCgLADpaoB3uyDGtNvf/qCDQpwL5Rv9jMg/FoBp+dsC + cKwv+oPQ8mPaxz3ve/8tOFZk5Mm/zPDL/+57qfgrLq8GJOknmNhHsQUA4DHxAkFWAMBoAQBTBaAsAt7m + Qbrlb3/QQSHOhbTb337l3zv7386L/sbkbyXdChpfWz6uLQD5ce1jl4/LH9srAKX8j6kAIIP8/xH/T9oC + kG+hZL8SwD4Cdgy3C1r5pz/bjz2Y/BNPPPHEZvOgfRaAb33rW83tgtrtb7/QQSHOgSDTzW5/+5I/P/s/ + zBf9Qcr49/qxy8dtH3sXBYCJ9hDB/KblHzMsc0RuU78SQCnY3C74hT/fiHxE9hYm/QTkn8BrD/ArgV0X + AJBeIAiweRAu/Wu3v/1CB4U4dbDbHy79e/K3BeC0X/TXyhkfW4HVj10/fvnY/cdPz8Hkf4wFAMcZ/x96 + /y8sw5xluhqQrgCUH9Of07sLQujbOvMHZQEAGMPmQb0CAEYLAJgqALgacPfu3UdDAXkT+3kVu4EOCnHq + YLe/Uv62AHjy7539l/K3BWCb8h/7vf/yF/1ByngM+9jLygVoH98rAKX8j6UAIBcm/7YA8B0UU5bIrrwa + UMo//RngasBff+m/U9kzrPBLrPxLcDUALw5k8gesAIAlBaAsAuHjQ+xnVmwfOijEKXPnEz/0Hr3oz5cz + vqYV2Ojjt89RPn56DiZ/WwCYbA8NzLX+P4n/L638WYYxxzrL7733AkEr/3IMVwPwAkEm/BIm/QSTfuLx + xx/fgD9j86B9FoBQPN7Jfm7F9qGDQpwqm0v/Z/yiv1LM/qX/9vFreenyP8DxtvKP2bH8RgsA8kROTP54 + c6E0hj/jdkHvagCTfomVfkkqAAncLmh/HcDkD0YLALAF4O7du7/Mfm7FbqCDQpwiabe/w5F/7+x/Gy/6 + GxdzEjIer32O8vHtc9jnKZ/Df56EJ/9DLwA4PuSy7bN/myeuBiThe6TbBecUACb9hJV/Ao+J2wWnSgAr + AGCqAIS/PxYKgF4EuEfooBCnCN7oB9JPVwBK+dsCcG4v+gP4mpHnqJ+nfA77PKd7+R9zxf/LWAGYd/Zv + M0VW5dWARLoagI8AtwvuSv4luF1wW1cBygLw7W9/+y3s51bsDjooxKlx59M/9c7yzN8WAE/+vbP/Uv62 + AGxT/rYAzBfztJQxzp9j+fOc6tk/jn1c/jG/tgD4Z/+2AKRc8e6CpfhL+QO8/XC6XZCJHzDplzDhM1Ay + XnrpJSp/MLcA6NL/1UAHhTgl0m5/I/KPBWAbl/6P50V/+IjH5BLrPc/85yo5xgKAY0NOcwtAnWHM0SsA + Oc82V/srgVQGyiKAFwjiasDcAsBE3wNf8/zzz68qACAUAL3l7xVBB4U4Je584ocf3q/8e2f/23jRXysT + TyAjQsZj8Oexz9U7+wflc53m5X/k0JM/y4/9f7VZxjxZpjZX7BmAqwGV9AnpdsFdyL8EexHYXwewAgBI + Abile/+vDjooxKlw5/ff8fOHI/9YANbJP0qllMmYkLmM8TnLnss+X/lc/vMlPPkfcgHAPNL/jVcA6uxs + fjnHNkubZ861zTbmm64GQPbNVYDE5eZBTPolTOxzwGPg3QWnSoAtAOHsX/f8XyF0UIhTIAj1/vLSfyl/ + WwDO8UV/UWijz2Wfz56tls/nP6eVvy0ATLyHAI4NGSX5jxWAdS/+47nW2SLPzb4ATP4BvC4ApNsFrfgB + E/pSnn766XtXA3oFAH/+9re/rbf8vWLooBCnAN7oZ+Ts/xxf9AfweP5zzXk++5z185XPCY6xACCDJWf/ + bQHYztm/zbf8lQCEbwsA+K/v++HN7YK7kn8ivUDQyh8UZ/+3/urRP9Jb/l4xdFCIYwe7/Y3IPxaAbVz6 + 38aL/kblH0XC5VHLwooiSRhfx0Q29nz95+yd/QNP/odaADAnv6DF3LwCUGcYc5xTAOpc22xLcKz2VwGp + DJRFAC8Q3GUBSOB2QVYC8Kp/7fZ3GNBBIY4Z7Pa3X/nHAjAtf1sA9v+Kf4B/a0U27/J/fs72ecvnLJ/X + yt8WACveQwDHuFT+LENP/izTOQWgzJddDbBFIG0exMS9TXA1AO8nUBaA27dv6y1/DwQ6KMSxgp3Eyjf6 + 2Zf8e5f+18k/ymS+iLkgAB6fFYDec/rPa0VVP699bk/+h1oAkMXSApDz83JkeeZcc6Ylbb42Y4AXCNoz + f0u6XZCJe9vg3QUh/1e1299BQQeFOFbSbn9W/rYAePK3BcCTfy4Ax/OiP4Cvm/ecc563/9zgmAoA5teX + P8su5jdeALZ39m9BpviVwEb2nTKQbhdk4t4meHdB7fZ3WNBBIY6R537r2luS/Htn/+f6oj/8W/m8vsRG + n3f8uUEpf1sAmICvEhxvzor9P7HcWH5ejl6eMdO1BaDMOf1KIAmflYF0uyAT97Z44okn3sd+bsXVQQeF + ODbsG/148o8FYFr+tgBc7Yv+1ssf4Dmmn7d9bl9Y9XOfytk/jidn5f1fxdxYduMFYNmtfxabs8065Z2u + BvTY1dWAIP/PfPGLX9Sl/wODDgpxbJS7/e1e/rEATMs/FgAu/yiVUiZcwFEeawWMx/Ced/y5lz8/sEIq + YSK+KjDvnFXMa0z+MT+WYZtjzLItANs9+y9BzvZqAAO3C27zagB2IdRuf4cJHRTimAiiv/dGP/uSf+/S + fyn/XACu7kV/+HcrtNHnXvr89hiYjA5R/jju+v8p5jWnAOT8vBy9PG2mJW2+oMzYy5rlPVUCADYPYkKf + y+c///lfYj+34uqhg0IcC9hMJO32V8rfFgBP/rYAePLPBeC4XvQHosA8mdXPvez5p4/Bk1ES0iGAY6mz + YnnFzNr/N5ZfzJAXgN29+K/Mupc5rgYw8ZesuV3wcq+Bz7CfW3EY0EEhjoVytz9f/mNn/6X8bQHYpvyz + UPryr6VRi6IURE8KeMxl5SMeA3/+/jHY4+jJyEr4Kmmzinl5BSDn5uUXM2zlz/KMma4tADZrm3cJ5jxS + AsDC2wWf025/hw0dFOIYCIv1Q/u79N++6G9U/lkq/bNvXxq1JEo59KSAz7fy959/zjHY46iPwR5HT0hW + wlcF5uHJv84s5sayGy8A+3vxn83by330BYKjVwNw9q9L/4cPHRTi0MFuf+zS/27kHwtAKf9cAA7zRX8A + z+k//5xjWHccPRlZEV0FOC5k4xUAm1kr/5gfy7DN0WaZM51TAGzGNucSm7mX+8jVgNHbBXXp/zigg0Ic + Omm3v33Jv3fpv5R/LgBX96I/LPp4nqljGC8AveM4/sv/yKGVf8xrTgGo84sZtgXg8M7+LSMvEJy4XfA5 + 3fJ3HNBBIQ6Z9EY/pfxtAfDkbwuAJ/9cAJb83n+peFtZRDlYQfRlgK9lx2CPwxdY/1cQc46lJyMmn32D + ObVZsbxiZp78WYFq/z9jlm0BuPqzf8uaqwF6o5/jgQ4KcaiUu/358h87+y/lbwvAcvnHAsBF0pd/T7ql + GHoywNi6EhKPxUrLO5ZjLgA4vpRTnVXMa04BqPOLGXoFIGfpZZqos/UyBmXOXt5LMmfit3zx//s/HsFZ + P+T/hHb7OyrooBCHSLnbnyf/WACm5W8LwDZf9OdLxJPGMvkzGeB5RgqAL7Descw7np6QmGz2CY4BmYzL + P+bGsmMFqs0xZsny5AWgzpXlW2KztnknWBZT9K4GhOd+DD+X2OgH8tel/+OCDgpxiNz+5I9c3+fv/Uv5 + 5wJwmC/6w4KPx/KOwz8WezzlsSw/nnRMnoyYaPYJ5pZyqrNiecXM2txsdjnDNkebZc50bQEoc/byTrAs + RkAJYK8NwItx8bP5wAMPvMb+vIrDhw4KcWjc+fRPbXb725f8+aX/Vv65AIzK30qjJwhfCFYA+JzRIlIf + T3ks9njsMZXHM31MnpCYYPYJjpXnFLMaLwDHfevfEsrbBcPzvIf9rIrjgQ4KcUjgEiNu+SvlbwuAJ39b + ADz55wJwfC/6A/EY8vFYoZXHYyXmi6s8nv4x2ePqCYmJZV/g+ZFL+j+rs2J5xcza3GJ2bQHwz/5ZnnMK + QJmvl3OizDvB8lgCrgY89n/+rUfZz6o4LuigEIdEeqMfX/5jZ/+l/G0BWC7/nnD78vdlWwuhJwEs9niO + XhmpheYdTzwmKy3vmKZKSU9GTCr7AvMsc6qzYnnFzOrcvPxihl4ByFl6mcZc1xYAm/e2Mw+Pdyvkph3+ + TgA6KMQhgN8r3vn9d/y8XvTHJYDFHl9jj8ceky+y8pjicfnCmndcnpCYUPYFjnup/OvcYnYsP0/+LE+v + ANhsbb4lNmub9y5yD7k9xH5exfFBB4U4BMJCs3mjn6uQfy4Ah/uiP3zE8y8rJPa4eqXEHlt9XOzYPCEx + oewDHAcyWVoA6txsdl6GXpY2z5I2W5uvlzMosy5hmSzhxvvve4T9rIrjhA4KcQhgt7/dy98WgON40R/A + c40XEntc5THZ47LHVh5X/9jK42NCYlLZB5i/n1PMqs0rZsb+P8cLwOmc/YfHuoXX47CfVXGc0EEhrhrs + 9gfpl5f/R+RvC4Anf372f/gv+ksLPb6+PqZ1x1UfW3lc9tiO7/I/5mAzqnOKWbUFYHdn/2sLgM3ZZl3C + MllCOPvXDn8nBh0U4irBvcXH9KK/9ZKtRdBb/LHQY3yklNhj8yVWHlf/2I7t7B/Hkf/fWE5eXjEzltt4 + ATiNW//AjQ/cd539rIrjhg4KcVXcvXv3tb1L/6PytwXgVF70B/Dc7LjssfkiK48tHp8Vl3d8x1QA8JyY + v82ozilmNSb/mB3Lr80w5tgWgOO79S8852a3P/bzKo4bOijEVfHc9R94ryf/WAB2I/9cAPry70m2lIQV + RCmFUgY9CbBFH483XUx6x2aPr1dO2mMsj887xsS2RTQXzCfnEzNq/w9jVnMKQM7Oy9DLss0zU+fK8vVy + tllvO3O8/wb7WRXHDx0U4irAQgPpp8v/u5G/LQDH86I/fN7osS07PnuM5fH1j7E8TiYkJpZdguOpCxLL + iWWVM2O5tQUgyp/lyP6/eQGoc/XyTZQ5e3lvK/Pw2Nrt74Shg0LsG7bb34j8bQHw5M/P/o/nRX/4M46l + PbY1x2eP0UqrPMbjOfvHcyIPllGdU8yqLQC7O/tfWwBszjbrEpbNHLTb3+lDB4XYN9jtz5f/2Nl/KX9b + AJbLP8pjvlx7l9ZrAfQW/bTI4/n42X97fPYYfYn1jtEeZy0ne6ylkMA2RTQXzLHOJ2bkyb/OK2bGchsv + AKfx4r/0Rj/idKGDQuwT7PZ3LPL35dqTgi+B3qKfFnh8jT2+fIy9s//eMcbjtOLyjrN3laI8ViYkJpdd + gWNl/4dtTjGrMfnH7Fh+bYY2x5znnAJg87UZl9i8t5F5yEq7/Z0BdFCIfREWmvuD6O9d+i/lHwvAtPxt + ATilF/3hzzimpce47DjbYy2P0zvWxDZFNAc8N7Ko82EZ5azmFIA6u5jfnAJQ5hk5zH3/tdvf+UAHhdgX + dz7+5kd2K//e2f9hv+gP4Hn9Y4zH6Qutf5z+sdqz1fpYe8e7bRnNAfNl+bT/lyyrmJcnf1aePPmz/3ev + ANhcbbYlZc5e3mszD1+vN/o5I+igEPsgLDQPJfnbAuDJ3xYAT/787P94XvQH8Bj+Ma45zjnH2j9ee8zb + lNEccMxtPjmjOqeY1ZwCUGcX8/MKQM7RyzNR5+rlazP2sk6wfEbRbn/nBR0UYtfgBUYv/86POvLPBWBU + /rEAbEP+URrzpdoTQb3w9xb7tLjj33BsuykAvbP//vHaYy6FBLYlojngeVM2dT4so5hTK3+WWcxtvAAc + 99n/jQ/c9zD7WRWnCx0UYteUu/158rcFoC9/e+n/eF/0B3As9XHaY23l7x9re7xWXN7xHsPZP+adsrH/ + l21OLKuYV5uZzS3n12Zoc8x5ri0AZcZe1gmWzwjhebTb3xlCB4XYJeVuf6X8YwGYlr8tAKf0oj+Ax1x7 + rOPHu/yY7XFvQ0RzwfGnbOp8WEY5q7ECcD63/mm3v/OEDgqxK8rd/nYj/97Z/7wz6lIOVgylDEoJ5IXf + Lv7+Ql8u7Pjc6WONx2ulNnq8S4+5d9xgWzIaBcdQZmPzaf9PY05j8o+5tQXAP/tnWc4pAGW2CZtxosx6 + beYo5OxnVZw+dFCIXYBLjLc/9ubH5pz52wLgyZ+f/W/nRX9WCqUMrATiwh8Xf2/B9xZ4/B3H5B1r73j9 + Y7YSGz3m/nHbY9+WjEbBc2DubTZ1RnVOLKuYl1cAcm45P68A5By9PBN1rl6+NmMva8AyGgG7/enS//lC + B4XYBbc/+SPX2aX/JS/62578oyxKQfhiqEXgC6Be8HuLfLmw4/FHj3fZMdvjLo+5f9z22MvjBtuQ0Rww + N//sn2UUc/LkX2cWc2PZ8QJwvC/+025/5w0dFGLbBOm/c0r+tgB48rcFYJvytzIthWBFwEVaL/i9hb5c + 1PF1+ZjL411zzHOO2x57fdy9YwfbkNEoOJYR+c8pAHVmNjcvPy/HmOXaAmAztjmXsJymCI+nN/o5c+ig + ENsElxiD7De7/ZXyjwVgWv62AJzai/5APM61xzznuJcfuz3+bchoFDw+chgpADmjmNN4ATj9F/9ptz8B + 6KAQ2yTt9rcb+ffO/ntn0qPyj0IoJcAFahd9f4G3CzqeOx/zmgLQu/w/5+z/cC//Y572/5PlU2cUcxqT + f8ytLQBXf/YPyqyXZh6+Rrv9iQ10UIhtERaazW5/25Y/P/vf74v+8oIfF31voe8t7Hgc/5inj3vOsfsF + oDz2/vHbOayV0RxwrH35s4y8rGJeXgHIuXn5xQy9AlDn2WZaYvO1GXtZL8075KM3+hEb6KAQ2wAvMAqy + by7960V/EfwdxzjnuJcd+7zjP8QCgOeNedTZsHzqjGJOc+TPsmvzixm2BeCwz/61258ooYNCbIO0258n + /97Zfyl/WwC2KX8r0VIEvgDqBb9c6HsLvF3McTz1scfjHjv2ePz82Occ//I5pHksldEcMN++/GM+2ygA + OTcvPy/HNstMnSnL1svY5rw07/A1t3TLnyihg0Ks5c4nfug9etEfX9SxeONx6+O2x26Pvz32OQXAF9f4 + HNg8Sph0tgGOmeVS/9+yjFhOOS+WGfu/5wXg+G790xv9CAsdFGINuPR/zC/6swIoF/282McF31vkvQUd + Czf+fcmVi97x13Moj7+dw9ICUM4jzWWpjEbBMXjyZ/nUGcWc2gKwu7P/tQXAZmxzLmF5eWi3P8Ggg0Is + Je32t23587P/UYGOy7935pwX+rjYewv81IKOY0rHno+/V17iHHyp9edgC8DoPKbmslRGo+BxMW+vAORs + Yj51RjmnOquYF8tsvAAc14v/wuPqjX4EhQ4KsZT0Rj+1/HMBKOVvC8Bu5B/lUErBF0G98NtFPy7ydqHv + L+p2IcfzjB5/nkNbYOw8+BzmzGP+XJYKaRQce50LyybnU2fEcopZtfKPubHs2vxihm0BONwX/2m3P+FB + B4VYwp1P/9Rmtz9P/r2z/1L+tgBsU/5j4uydNdcLfG9ht4s4Pj8e//w52Hn4QivnEefC57F8Lmk+S2Q0 + Cp6/ziTnUmeT86kzijnNKQB1bjE7rwDUObZZRr5rg80VlNl6Gducl+QdHkO7/QkXOijEXNJuf6X8YwFY + d+m/lb+V53Jx+ou/t9i3C7y3qNtFHB/jcU/Jn8/Dl1o5DzuX47z8j8fE/L1cbDbt/zPLKWbFC8DVn/0D + m7HNOcEyY+CNftjPqhAJOijEXO584ocf3o38e2f/PXGOyn/8RX+9xd1byNOijWNYegWjN496LuU87Fzs + fMq59OfjzSnB5LMGzMn7v62zyfnUGcWcvAJQ/t/z3GJ2XgEovyd4lok6Uy9bm6+Xc4JlZgmfd0uX/sUU + dFCIOXztQ6971/7l3xPnuPztGbO/0PsLe28hx4KNx8pzsPOIc+DzmJ5LPZ96LuPzOZzL/zi2NpOcS50N + yydm1Mqf5RUzGy8A61/8V+ZaYjO2Oc/NO2Si3f7EJHRQiFHCQnN/EH516V8v+ssLOMZw3GPzsHNp5W/n + Y2U2fz7z57RESCPg8TF3L5M6m5xPnRHLKWbV5mUzy9m1+dkMc5ZrC0CZb4nNejRvvdGPGIUOCjEK3ujH + k3/v7L+Uvy0A25S/L8zegl8v8OXC3lvQ2eKNY1ozFzsfX2jlfOKcfHnVczqUAoA5pjxyJjmXOhuWT85p + rACc3q1/4fO0258Yhg4KMQJ2+yvlHwvANi79l8K00hwV5qj844K/VpRs8cZjj8+Fz8eKjc/Hzun4Lv/j + OFMeXi7s/5plNCb/mBn7XmjlHzNkOc4pAGWuXr6JMuc5eWu3PzEHOijEFJdv9HNR3va3Hfn3zv57wuyf + LZeLvl3wy0U+L+7rXvSHz5l3JWN6Pr052QJg5ZXnVc6pPy9vbgkmoCXgeco8WCY5lzqfOiOWU8zKKwD1 + 90LMzisA5fcGzzJRZ+plC8p8vZxHs77xgfuus59VITzooBA97t69+1q80U8S/37kHwUxKksuSrvo9xZ4 + f0HvLeBpwcYx1nOZKgBWcv052QJgJTY2r6s/+8djYX5LC0DOJ2bUyp/lFTNjufECcPi3/oXH0m5/YjZ0 + UIge2O2vln8uAKX8bQHw5J8LwOjZcivLUgL+wl8v9naRjwt7XNy9Bb23gKfFGs/pzSfPiYvOm5Odl5WZ + lRifV39udn7l3Mr5jQhpFBzziPxtNuMFYHdn/2sLgM3XZlzCsit57reuvYX9rArRgw4K4YGFxpN/7+y/ + lL8tANuUvy/K3kJfL+zlgt5byNnCja8ZvZrRm5Odl5WaL7JyXv25LSk3CSahueA5bR45k5xLnQ3LJ2bU + /v/HrNoCcFov/tMb/Yil0EEhGOyNfkbkbwvAsbzor7eIs0Ubf8ZxT89pzrzi3Hyhjc5t+fzKOY4IaQQ8 + Dubuyz/nwrKp84kZjck/ZsZya+XPMow5zikAZa5evoky5wTLL6Hd/sQa6KAQDLvb33bkH2U5Lf8shBFJ + lou9Xej54t5fzL3Fu1yocTzlnPK8evK384pz88VWzs3Or39lo56jP7/eHAET0VwwF5sHy6TOJWZT5+Pl + FLPyCkD9PcGyYxnmLOvvlZjn2gJgcx7JWrv9iTXQQSEst3/7Te/clfx7ouSSHJW/Xex7C3u9mHsLuLdo + 4zHsFY2xAtDKvze3en7l3Oz87BzL+fXnaOdZCgkwEc0Bx5KzyHmw/2+WTZ1PzGiO/FlunvzZ94lXAMo8 + vVwTZb5ezlNZhxy0259YBR0UouSvHv2jarc/T/62AHjyt6JcIsn5gmwX97igx0XdW8h7C3dapPFnzIPP + y87Nym5eAbAy8yVWzs/O8eou/+Px4vy9PHImdS45mzqfmNGcApAz87LzMmxzzNR5sly9fEGZcQnLEGi3 + P7EN6KAQJeVuf3rRX7tg4/jyvObMzc6vlb8/v3aOvrzqOV7l2T/mlbPIebBMci5ePiyjnBXLa7wAHO7Z + f/i3WyGH+9nPqhBzoINCJMJC81CSf+/sv5S/LQBX+6K/3cofjz0+tznzi3P0hVbOMc7TCsyb59ICwGQ0 + BxwTyyLnkTPxsqnziRm1BWB3Z/9rC0CZLcu4hGUI8OZb7GdViLnQQSHA5W5/k5f+58k/SnJa/lEGo3L0 + F3lvUe8v4t6iXS7Q+DzMZbwAcNmVc7Ry43O08+yVHDvXep69udr5MhmNgseu5Z/zYJnUucRs2nxiRmMF + 4DRu/bvxgfseZj+rQiyBDgoByt3+tin/LMj27JjLcVT+caEvF/clUuwt2OUijWOeO788Ryu6do7+PK3M + ynnauZbz7M/VzrecK2BCGgVzY1nUmbBccjZ1PiyjmFP7PcEyi7m12cX82PfLnAJgc7XZlticvazDuN7o + R2wVOihE+UY/nvxtAfDknwU5T46lAMpF31/s68XdLupxIY+LubeA9xbtcoHG8/XnN3+Oy+Zp51rO0871 + al78h2Osc8hZ5DxyJnUuOZs6n5jRnAJQZxZz8wpAnWGbY6bOk+Xq5Wsznspau/2JbUMHxXlT7vZ3uC/6 + 68vfl2K9gPcWbW+hxqI/WnDyPLnspucZ5+rL7LAv/+M52v/vnAfLpM4lZjNH/iwvVpra7GJ+LENeANo8 + QZlpic3XZtzLWrv9iV1AB8X5Ynf7G5G/LQB9+Uc5WhF4UswLf0+K7cLOhVgv4L2F21uk8XfMYcmvN8bm + GedqxcbnGudrBebNd+nVDsCkNAW+DvP0ssh55EzqXHI2dT4xI68A5Ky8zGJubXY2v5zj2gJQZutlnLA5 + Yrc/XfoXu4AOivPl9id/5Pp25R/FWMo/y6CVwJgUe4u7t5j3F29vsbaLM55/+uzfztPOdU4BWHqlo51z + Od/enO28rZBGwfG2OeQs7P99mwvLJuYzXgCO/8V/2u1P7Ao6KM6Tcre/bcqfnxVzAYwI0S7w5aI+JkN/ + we4t0niM+fOcP9c58/XnXM63P2c773LOgElpCjxfyoFlUeeRM8m55GzqfFhGMac2q5hXWwCu/uwf2JxZ + 1uHz3sN+VoXYBnRQnB+4xBjEv7nlz5O/LQCe/LMYl1wS78u/XuTrRd1fzP2Fu7dY28UZ8+IFIM5z/lzX + zHfOnNfN20ppCnwN5tvmkLPIeeRM6lxYNjmjOQWgzizmxrLzCkCdY5tlic3VZutlDGyOeqMfsWvooDg/ + 0hv96EV/7QKNxRjHZufJ52rna4XXm2+ccyk1X2a9OffnbedezpvNfS6YR8qA/b/XeeRMbC68AOzu7J9l + OKcAlJl62SbKjFnW4e/a7U/sHDoozouw0Nzb7W9E/rYA9OUfhbhO/nGRLxf2MRHWC3dvwfYWZyzGeHx/ + rna+vbJj59ye/ftzbudtBebNe59n/ziWlEGdQ86C5VF/H+Rs6nxYRjEnrwDkvHJubXY2Py/HRJ2nl6vN + 1suY5RzmrTf6ETuHDorzISw0997oZ1fyzyJoF3+74JcLPRdhu6DzRby/aHuLtF2YMYa55bnOma+dMz/L + 9eY8Z97bKD52/lZKU+DxMOeUQZ1DzsJ+D7S5sGxiPq38WVYxL5YZLwCHdeufdvsT+4IOivMh7fa3Hflb + Ifblnxf9UfnHhd2TYF684wLuLdq9Bdouyjh+Nl9eAKz4enOO8/bl1p/30rnPnf8cMKcyg5xDzoLlwXJp + vydYRjGnNiubl5ebl1/McG0BsNnafEtShuHP2u1P7A06KM6DtNufJ39bADz592RoBTBX/vXiXi/m/iLu + L9i9BdouyHhOb87ThYfPeWzece6+zEbn3p+/zaCcf8pgFBwXL0F1FjkPlomXTcxnvAAc761/N95/3zvZ + z6oQu4AOitPn8o1+gvTHzv5LEXIZLpF/XOztIs8X9t5C7i/cvUXaW5ixEOPfvfnyOc+ft18AenOP8+dz + 78/fZlDOn2UwCh7LZsByqPPImbBc6mxiPmPyj3mxzFr5x/xYhnMKQJlpwmabKDO2WWu3P7Fv6KA4bXCJ + cbuX/lsRjkrQX+DrBd1fyOuFu1ywewu1tyhjIcZHzKM/ZzvvnvzXzH3e/OsM6vmPZpByGAGfi/n58s9Z + sDzqTGIu2ygAOS8vN5ZfzrH8PkpZri0ANmOQcgxf85gu/Yt9QwfFaYMzDb3ojy/KWIxxLOWc+bznFAB+ + luvNfXz+yzMYyWEEHJ/9v69zyFnY7wUvlzqbmI8n/zqrmBfLzJN/WwCu5sV/eqMfcRXQQXG6pDf62Y78 + exLkC/48+ccFncuvXbi9xbq3MNvFGF/fm3ee+3TxyfPfVgHonf3bDHZ/+R/PweSfc2BZ5DzqTHIudTYx + H68A1N8rNi8vNy+/NsNMnSXL1MvW5luCHMO/a7c/cSXQQXGapN3+PPnbAjBPgnzhnyv/nvz8xdtfqHsL + s12I8bGcM5v7dPGxc5+ev83AF9poBv0cbBZlDimLKfB5cd51BnUOOQuWR87Ey4blk3NiWY0XgPUv/rOZ + JspsvYwBctRuf+IqoYPiNMFuf4f2oj9/Qe8t4P6C3VugvQU5SQ3HOWfuS+e/LIOYg5WYl8OuCwCOO8s/ + Z8ByyFnUmbBc6mxiPm0B2N3Z/9oCUOZaYjO+5Jbe6EdcJXRQnB54o59R+VsJ9uUfF/9R+fkLu7eQL5O/ + XaC9xTgJDY89Nffe/HMGVni9DGIOPIM5Odgs6hx6WXh59MDzs/nX3wc5C5ZHnUnMpc0m5rP9AnAYt/6F + +Wq3P3Gl0EFxWoSFZrPb367kz+XHz/DKhZ2Lr13Ay4XbX6z9xbm3GGMhxjjmaufO528z4Ge9XHZtBr0c + bAGwEluSxUgePfA1mO90Acjyz3mwTHIudTYsn5iRJ3/2vdPmFrNrC8B+z/5vvP++R9jPqhD7hA6K0+LO + x9/8yHbk35MfX+jnyT8u5Fx67YLtLdK9RblchJPUcPxT888Z9AqQzYGLzsvBFgArs7EsdvviPxz/tPxz + Dux7os4k51JnE/OZUwDqvGJmXgGo82szzNRZsky9bG2+BXqjH3EQ0EFxOoSF5iFP/rYAzJPfqPiWSq+3 + aPsLdG9BLhfhJDQ819oMcg69EhSz8OVW5tBmMV4A6jyWZOKBY6nnzzKos2B51JnEXOpsWD45J5YVK0xt + bjE7lh8vAG2WNs8Sm63NN6Hd/sShQAfFaYAXGC1/0d825B8X93JR9xfydvHmwqsX6d7C7C3ESWj4mn4G + OYeYwboc/CxiHjyLmIeVmJdHrxD1MilzYeBr67nn+Xs55CxyHl4udTYxH5ZRK3+WV8yszc1mlzNcWwDK + XL18gd7oRxwSdFCcBtjtb5n8rfi2I39bAPgCvkz+dmH2FuJSapiPl4Mu/2fw75iLN/86g5xDziLnUWfC + conZtN8vLKeY1XgBuNoX/4XP025/4qCgg+L4wW5/I/LviW9aesuFN192/QXaW4ztIpykhmPyMuA52Cx6 + 8rd5tFn4edhM+oWozsXPZDQXBo4nzZ19L7Ac6ixyHux7pM6G5RMzanOKWbHvoVb+Mbu2AOzvxX/a7U8c + GnRQHDdYaLYj/5705glvVHblYp0X6bhQe4uztxjbBTgJDY/Ry4FnYQXYKwDzylCdSZmHzcTmUmbSz2U0 + Gwsep517nn+dQc6BfW/UmbBccj5zCkCdV8zMKwD19xTLMOa4tgDYfPVGP+IQoYPieMElxtsfe/NjTP62 + AHjCs9KbJ7xtyN8u1vXi7C3IvUU4CQ1/xlzLHOZnYfOw0ptXAHqZ1LmUmdhctn/5H/+Guaa5s/nX3xMs + i5wHy6TOJWYzR/6sMHnyZ/l5BcBmafMssdnafLXbnzhU6KA4Xm5/8keuz5V/lN425B8Xdk909SJeL9p2 + sY4LdFyky8W5tyB7C3ApNRz3dBY5j5jFnDxsJq385xSA0Vx2cfaP403zznPP868zyDmwLOrvkZxLnQ3L + J2bkFYCcVc7MKwA5Oy/DRJ2ll6nN1ctXu/2JQ4UOiuMk7vY3fel/Wnjbkb8vut6C7S/QvQXZW4BLoeEx + bRbz85ific3FF1uZS8zGl1idzdorIxY8Zjl3Nv86g5xDziLnUWfCconZtPJnOcWsxgvA1Z39h7/rjX7E + wUIHxfFh3+jHk78V3jzZLRfdmOTqBbq3MHuLcLn4giQ0/Blzn5PH/Ex4Lr7gylxsNnMu/9fZ9PKxGZXS + T+BzMM8073ruef45g5wDy4Jl0n6/sHxiRm1ONisvMy+7mN/aAmBzBWW22u1PHDp0UBwf5W5/y+VvZTcq + ulH524W7t0j7i7K3CJeLLyilhnlM5TE/E5uLlV2bi59NmYvNxuZTZtPPZ05GCRx7Oe889zz/OoOcA/se + yXl4uXj5xIzY99B4AbiyW/+02584eOigOC7CQnNvt79S/lZ4nuiy7OaJzpMcF1xcuMvF2i7UcWG2i7O/ + EHcW30poeF6Wx/xM5uQync14ASizsfls98V/eD4rfzZ/lkGdRc6DZVLnErMZk3/MiuXVfk/F7Fh+cwpA + maeXayJl+7UPve5d7GdViEOCDorjISyk997opxS/ld080c2T3HzBtYt0XJjj4lwuyr2FmC28Vmz4Osyf + ZbLdXKazsflYqfkyK/OxGdWysjmVGfVyAvj8OOc87zz3PP86g5wDy6LOI2aSyNmwfGJGXgHIWXmZednZ + /EraLG2eCZtrma12+xPHAh0Ux0O529+I/K3otil/X3C9hdpfmHsLMVt4mdQwvxH581zWZWPzsXLzhVbm + 08+od4WklxPLCvOw885zz/OvM8g55CxyHnUmLJeYjSf/tgD4Z/8sN1aeeAGoc/TyTJS5mnxvabc/cSzQ + QXEc3PnED71nSv5WdH3550V+neDqBdsu1mvFRhZdKjQcy5Jc5mSzNB8/ozln/9u7/I/jGZV/zoDlkLPw + Mqlzidl4BSBnxLLyMvOyi/mtLQA21zJb7fYnjgk6KA6f+EY/etFfSSk0PE6Zi82mzGV+NvPzWZaRzanM + qJ/TnKzwtWzeee55/nUGOQeWRc7DyyVnU+cTM2I5jReA/b/4T7v9iWODDorDptztzxOcldz0GW5PcNuW + //d2FmV/AWaLLhMa/o45j2Zj8+ESHM1nOqM6pzKjNqddFwD8GfNi8s9zz/NnGeQc6jxYJnUuMZsx+ces + WF5tZja3nN+cAmDztJmWhH/TG/2Io4MOisMmvdFPKTgrOU9u6+QfF/L5YustzvVi3FuAywWXySyBY+xl + Mz8fm5GVXi+jNicrNV9mZU79rGxeZVa9vHBsec553mzu9fdIzoFlUecRM2lzidnMKQA5Ky+zmJtXAMr8 + InWGJWWeXq4pW+32J44ROigOl3K3P09wpdys4LYpf19svQXaX5B7C7BdcJnMAB5/Tjni+czJyObUnv37 + ObVZWZHFnNqstnH2j8ep55znneee588y8LKw3zdtLiybmI8n/7YA+Gf/bQHY3dl/QLv9iaOEDorDpNzt + z5ObFVxf/nlxH5G/FRuXWrtIlwtzuSD3FmJv4WUiS2AMeczPZ05G63Kak1UvrzKrXl5eZvgz5lgXgFH5 + 5wxyDjmLOo+cSZ1LzGZOAaizinl5BSDnxvPL1DmyPL1cgd7oRxwzdFAcJnc+8cMPr5N/XuT78s+L+YjU + yoXaLtD+ouwvwt6iW4qslFkC85g6++9llHNqMxrLKWblC67OqpbanMv/dV69zGxuKSscs/e9kefO5l/n + wLKo84iZjMk/ZsRyYmWpzSzmxrLjBaDN0WZZQnLVbn/iqKGD4vDAzmK7k39e0NfI3wpticwmFtxGZAk8 + P/KZk9G2chrLyuZVZmXzspmVefUzs7mVmaXc8PjenPO889y9DHIOdRY5j5xJnUvMhuXTfk+xrGJebWY2 + t5zf2gJQZpoIc3qI/awKcSzQQXFYhIVms9tfKTYrN09qeZFfIv+4gHOh9S5n9xZlfwHuLbpWYiX4XOQx + twBM5zQ/q2V52czKvGxm6y7/43Mwv3rOed5s7vX8cwY5h5xFnQfLJOYyXgAO89Y/7fYnTgE6KA6L9EY/ + nthKqVmxbVP+VmhcZr1L2fUi3Ft4y8XWSsyCeTL525xsVuvO/tfkNS+zbZSmlB2O35tzPfc8f5aBl4XN + o1cAcjYxnzajmFNbAPyz/7YAbP/sP2Sp3f7ESUAHxeGQdvtbLjW+qI/I3wqNy6xdnMsFuVyIewuwt+Ba + gVlwXEn+c3LiWdm85pWlXl7jmS3PrZcdwPOm+bI5s++Tev45g5xDzqLOI2dS5xKzmVMA6qxiXl4ByLl5 + +SXqHL08babgxvvveyf7WRXi2KCD4jBIu/2NSm2e0PgiPiIzf3H2F+Pe4usttlZgVv74Wk/+c7LKeU2X + pZzZ0sJkc+ud/YMyt+WX//Hv5XzznPO82dzz/L0cchYsjzqTmIsnf5YT+x7z5M+y4wWgzpBlWVJmeuMD + 911nP6tCHCN0UFw9uMSIN/pZIrRp+eeFfLn84wJdLszlYpwX4bgQe4uvt9CCUmBW/hjDvEcLQJnV+rym + M1uWm82uzK2fnc2vzA5/x1zSfNmc87zz3L0MWA45izqTOheWTcynzcjmlPPyCkDOzcsvUefo5WkzDX/X + bn/ipKCD4urBbn+jQps+mx2Vf1y4y8XaX6TrRdlfjP2Ft7fYlgKz8gc41lc+8ka3AJRZ2bxsZm1e8zNb + ltuc7Jbnh+Movz/ynPO82dzr+ecMcg45izoPlknMpZU/yyjmNF4A9vPiP73Rjzg16KC4WrDQ9IQ2T2bL + 5W9FxiXWu4RdL769BbdcaEt5Mfnjcb/xUV/+Ni+b2XRhsrlx6fHcYnY8tznZ2fzq7Hr5lRnicfh885zr + eee5s++bOoechc1jvADs7ux/TgEos3Qy1W5/4uSgg+LqwCVGvNHPEpnNExlftPlC3VuYvYW4v/B6C+2U + /DEepb/Ns3+b23Rpytm1Z/+97GwB8EU2np+XIf6MuaW5enNm3y/1/HMGOQeWhZeJl03MZ10B2P3Zv3b7 + E6cKHRRXB3b7G5XZPJHxxduTmCcwuyBzee3mRX8A87Fn/3MKwPyzf5udFV4/u6X5WYGV+fUyLHPE8fln + /3nebO5s/nUOOQuWR51JzGWO/FlWrfxjbiy7OQWgzJJlqjf6EacKHRRXA97oZ4nI7ILuSWyd/OPCPF9e + /mJbLrJgSv54Xsh/t5f/rQB7xSnm50uun9/SDEdyxHPYueb55jnnebO51xmwHOosYh7t9xTLJubjFYCc + k5eXl5vNrqTN0WZpMw3z0G5/4mShg2L/hIWm2e1vrcTsAj4iMH9xrhdjfxH2F1xvkU3S6skfnw/ZR/lf + 7eV/KzueX8zQl9pohvNzxBjmdZUFIGcSc2mzifm0BcA/+2eZseLEC0CdoZdlAlneeP99j7CfVSFOBToo + 9g92+/NENi2x7cjfFgAur96Za73o9hZbK62e/AHmys7+5xSA6eI0Pz+/APQLlJ/h8hxTljjeOFc23zxn + Nm9v/jmDnIOXR51JzKUtALs7+19bAC5z1Bv9iJOHDor9Ehaah5ZIbFpgo/IalX9cjPkCXC+4vYXWCmtK + /jieJH9bAMrcbHZlbjw7m19P/jbDVv5+hjbH8RI19+wfz2vn6s2Zfd/U888ZsBzq7yeWSc6lzibmwzIa + LwC7ffGfdvsT5wAdFPsDLzAKUrt36b8UmJWYJ7Bp+edF25MXF1e7EK+VlhVWCZM/vr6W/zYv/1sR9gpA + r0C1GY7nuDxLmyf+Pc8zz9V+v7TzznNn86+/j3IWLI86k5jLmPxjTiyrNq+YWVsAtnP2rzf6EecCHRT7 + o9ztrycwT/55EW8Xb7tgz5N/XJC5tNqF11ts7eJaMiV/gLnXBWDs7L+XX86QS5DLrxWeFd1ojuNZjl9J + wd9x7Gyueb55zmzeee5eBjmHOouYR5tJzGVOAcg5eXl5ubXZRb5rg83RZlmg3f7E2UAHxX7AG/14Apsn + L37mNi2u3qJcL8L+4lsvtr0FthTWiPxx3KX85xSAMj+boZXhdIY2x7ZEzSkAY1nOyxPPn+fJvl/qOed5 + 57nX888ZsBxyFjmPOhOWS8ym/V6LGbUFYL9n/0C7/Ylzgg6K3YOFZrm8tiP/vDj35V8vwvWiWy62vUW2 + lNWI/PH4rfyXXf63UmwznJ+jzdIKjmcZ8/RFVufZKwBlnvha9r1SzzfPmc27nnuef84g51BnkfOoM4m5 + eAUg5+PlFLPyCkDOzMsuUWfIsgT4XsT22+xnVYhThQ6K3WJ3+5uW16i4RqXVO2PtLcD+gttbYEtZjcgf + /4Zc2gIwdvbfy5DnaCXIxVdm6UuuzHJOnjbTOk8vU/wZc8rzrOea55vnzL5/8tzrDFgOdRYxjzH5x3xY + RuMFYDdn/1/9te9+VJf+xblBB8Vuuf3JH7k+V1zlIj4t/7hY+wt0vSBzWcUFmMuqv9CWC6sn/14BwBxv + //abjPyXnf33csxZWgG2RSrn2Wa5LM/lmZa54rjqeea5svnmOddzZ/O3309tFjmPOhOWS8ymlT/LKWbV + 5mUzy9mtLQDa7U+cI3RQ7I5yt7+euJZIyy7W8+RvF+LeousvsuWiWsofjMgfz2flHwtAlv+cAsCFyM+C + rQDbLKfzHC8AvUzHrqjgcXpzzfPNc2bzruee58++p+osWB45l7ECcPW3/oUs9UY/4iyhg2I34BJjkBm9 + 5a+3kI/InwtrqazahZcvtpML6z1G5I9/g+ynCkApf5vjdrO0ecZMfcmVebaZjheAOlebLfLEGOZTz5PN + Nc+3nneeO5u/l4PNov0eY7nEbNp8YkZtAfDP/llucwpAmSPQbn/inKGDYjeUb/TjCSsv5mvlHxdovij3 + 5e+Lql5kewvrXPkDzBvyP7TL/1Z4Zaa+4MpMY65WZl6uI8UKx+jN05tvnnOedz33PP+cQc6hziLnUWcS + c5lTAOqcYlZeAciZedkl6gxZluH7Ubv9ibOGDortExaae7v99aTVl39cuOfLqnem2lt4/YW2t7AukT+O + i8k/FoBdnf3HPHOmVn7bKgBzzv6ns8Xjt/Os55rnm+fM5l1/P7EMcg51FiyPmIkn/zqfmBErSm1eMTOW + Gy8AdX4sR/C1D73uXexnVYhzgQ6K7RIWyXtv9DMqrHLx7smqXKRHRVUuwHbx5ZLqL7DlourJv1cA8BgQ + /doCUGbZyzNnagXIxedl6udqsy1zXZ4twOf05unNl30fefNnGdRZ5DzqTFguMZs2H5tRzqrNy2aWs1ta + ALTbnxAqAHsh7fZXysoKa56s5olqvqTahdZbXMtFtZS/LQBM/Alk4ct/m5f/rQx7BYALz8u1zrbM1WZr + 8y2z7ecLcLztHPM86/myOed513PP82ffW3UWLI+YyXgBuLoX/4Xvx1u65U8IFYCdU+7258nKLuB9+eeF + eq78fUm1Cy5fZPmCmlgifxxvkv+as//5mdpce6UqZmtlV2Zr5eYLrczW5tu//I/nLeeY58nmmufrzZt9 + T9UZ5BxsFu33WsxkTP4xo7YA7OnsX2/0I8QGOii2A+4tZrLii/ha+ceFmS/Gffn7gqoXV29BBUvkj+co + 5T+nAJR5jmU6J1ebbVusatHV2dp8fZnV+fYKFr7OztHO05tvnnOedz33PH+WQf09xvLwconZeAUgZ5Sz + Ynl5BaDOrs2vJH2Parc/ITJ0UKyn3O2vJ6u+/OOCzSU1Kv+4CPOFd5n804KaWCJ/fC6k3pf/sgLAz4i5 + CEeztfn6givzjRnzfMczxp8xh3KOeZ5srvWc2bzZ3OsMcg4sizqPmMkc+bOcWvnHzFhucwpA8b2qN/oR + ooAOivXgTGMb8s8Ldbs4jwqqXHjtolsutOUC21tYiwXVlf9UAcBcSvnzAsDlv74AWAly8ZX5+qIr87UZ + 9wqWzbnOuMwZx1LOz5tnnmueL/t+yvOu588yqHOIWbTfbyyXmI1XAOrvQ5aVl5nNraTNsMpRu/0JUUEH + xTrSG/2MSsou2iPyzwvzqPztwttbZP1FNS2moJS/LQBM+gk8952PPdAtAMdx77/NuMzXZmxzLjP2c8bj + 2PnlOeZ5evPNc87zruee58++x+osWB4xkzaXmA37HmQ5JWxe7HuTF4A6P5tj+P7Ubn9CGOigWMfdu3ev + v/Sf3+dKyi7cywXVl78vp3ah5WLii+nlgrpI/vhcyN4WgFL+sQBk+c8pANPZzsl3TcY25zJjmzO//I+P + 5dxKWAEYlT+be55/zsDLos4jZtIWgN2d/c8tAHijH/ZzKsS5QwfFcm7evPmmb3/72xd/8zd/c/HyjT+9 + ePl3ftRZvNfKPy7IfBHuy98XU72o2oW0ZIn8AeY8dfZvC0Apf1sAprOdk++cjGPOvtz6OddZt9ICOE47 + v4SVP5tvnnOedz33PH+WQZ1DzMKTf51LzIblM14AtvPiv/A9eUuX/oXg0EGxHJz9pwIAvnX71sVL/+mX + 6MLdyiku1FxOS8XUW2j9hdUupNuQP44R8p8++9/m5X8rw3kFy+bsC67MOWZtheZlzQoAnoPNL88xzzPP + tZ5vnnOeN5t7nUHOgWVR5xEzqXNh2eSMWE5tVjGvtgDMP/sPx/sQ+zkVQqgAbJUg/9cGbpUFIPH1L/3B + xYu//Q/Ngs0X6bViKhdcu9iWC+wcIU3Jf6oA4Gsh+7ECMHb2bwXJpTid8fqcbda9otXmXWYN8DmYT78A + 5Hnmueb5sjnneXvzzxnUOeQs6jxiJnMKQP39yLLyMmtzy9T53UNv9CNEFzoolhHk/zOQPysAGMPVgBc+ + /b80i3Vf/nlRXislf3H1F1NP/rYAMOmXQFxM/msKQE+M0xnPz3lZ1jbvMmueN463L/+rKwA5D5ZJzIUX + gP2e/YfvSe32J8QEdFAsIxSAR70CUPLSX3xkczVgTEzj8q8X3XqhtQssF1K9iG5L/jj2JP/ps//tX/63 + IpzOeU3Wc/JuM8dzefOzc6znOi1/Nvc8/5xBnUPOos4jZuIVgJyNl1HMySsAOS8vt0Sd3z20258Qk9BB + MZ/04r+RAgC+8cwXL176vX/uLsyelMrFd0xIvcvR9WJaLqCl/G0BmCN/PG4p/+kCMHb2bwVpxThdALj8 + eNZt3r7c5lz+L4QVwOeyudVzXF4A8vdYnj/LoM4hZjEm/5gNy2e8AGzjxX/3XWc/o0KIGjoo5vPNb37z + oTkFIIHbBe2iPCJ/X0i9BdZfUO0iug354/Mhbk/+tgBc9b3/Oe/27L+Xt83cCi3m3WZeCgx/x7F788tz + rAtAX/553mzuef5eDjmLOg+WScyllX/MKOeTc2qzsnnl3EYLQPh+1W5/QgxCB8V8gvQfWVIAQLpd0ArJ + LsLl4uvJyC6yfGHtL6Qj8h8pAJBNKX9bAEr5xwKQ5T+nAHAp8jPhXgEYzXtZ5m3uZeZ4Xja3ksM5+4+Z + bL8ArD/7xyZc7OdTCNFCB8U88Or/Uv5zCwBItwu2QhqVv11o64XVX1DrBXRb8sfzvPrxv+/Kf6oAlPJf + XwCsCLn8Sun5outnviR3PIY3t3qObJ71fKcLQJY/y8Dm0H7/sUxiLp782wLgn/2zzEYLgN7oR4h50EEx + jyD8t6wuAN/61gbcLvjsh3+wWoDLhddfcOsF1i6sUxICnvxtAWDCL8HnQ/BzCsC5bv2LP2MOvfmBqzz7 + r/OImcwpAHVGMSevAOS8vNwS9feudvsTYj50UMzj7t27v7y2AIBUAl59+bkL3C7oi2gb8t/Ni/4AZGXl + bwtAKf9YAHZ19p9luL4A9HOvsy9z97PH8Xhzq+d4dQUgZxHzaOXPson5sJLUZhXzYpnxApC/bxPa7U+I + +dBBMY9QAB7eZgFI4AWCuBrQLrr1IjsmoXoRtQvotuSP44D8d3X5n8uRC3Fa/ll+nvz93JdnnwSGxy7n + xuaX51gXgFH5s7l78s855CzGCsDuzv5HCkA4Ru32J8QC6KCYRxB+9QLAbRUAjKXbBbmE2sWVL6j9BXRE + /iMFAF8Puc8/+9/m5X8rxF4B4NIrZedLrpf9dP4Yx/H35pY4tLP/sQKwp1v/tNufEIuhg2Iedy+3/91F + AcDHb37zm5urAWyRLRdWLh+7kNYL6LbkDyAxdvY/XQDGzv6tJPlZMZdhK/8sv1J6Vnil5HrZj+cfr77g + 2Hpzq+fI5lnLn825LgBM/jkDm0OvAEzLP+bTFgD/7J9lNlUAwtfcCsd4P/uZFEJMQwfFPKz8t1UALLga + gB0EmYDsgsrlMyZ/WwCY7C0QRJK/LQCl/NcUAC5HLsVW/lmCvAC0Z/9zCsBY/vH/AM9XzovNLXE4Z/8s + k5iLVwByPjknrwDkvLzcYnbV97B2+xNiFXRQjGN3ANxlAcCVALxAELcLlouqv5jWC6gnf1sA5sofj+3J + 3xaAVv7LLv/bM+NW/lmGvADws95Sdr7kSqnZ/wN7Nlv/H+Bz7Lzs3Lw51vLP891uAZh/9t8WgH3c+nff + w+znUQgxDh0U4wTZN7cAAib4KZj0PXC74NO/8QazqNaLaLl4lvIH25I/gKy9AlDKnxeAsbN/K0kuxlKG + VoRcfqX4fNm1gvPFVv4f1P8P+DOO087Lzs2bY57nruQfc5hbAOpsbD5eTl5edWY18Xs3fI3e6EeILUAH + xTh3i3cA3GcBSFcDcLtgu5DyhXOO/EcLAARTyn9OATjkrX+t6Hy59YRW/z/gue282Nzy/K6uAEzLP+bC + ytF4AVh29q/d/oTYDnRQjMP2ANhXAUjgBYK4GsDFszv547l68rcFoJR/LABZ/nMKwPTZf5ZhrwD40utJ + rhUbl3/9/4Cvs3NKlHOr58jm6ck/z5nN25M/y2GsAOzu7L9XALTbnxDbgw6KMR544IHXHEIBwN/xAsGv + fvxBs3iOyd8WACZ7C74GEu8VgFL+UwWglP+cAmClOC3/LMBSfL7seoLrXf7PIsPf7XwS5bxKDufsn2US + c2HZjBeA+bf+Ybc/XfoXYnvQQTFOkH2zBwBggp/CSr5HWQBSCcBHXA1IC6cnf1sA5sofQD5W/nMKwHFs + /Tvn7D9KjYkMx2TnlLBzy/OrCwCTf56vVwCy/PP8vQKwnbN/llGbU8yqLQATZ//a7U+IrUIHxThB9gdR + AMCrr766+Yh3F8QOgl4BWCt/LOxT8rcFoJR/LADrz/6zGLkM+RnwtgpA7+w/ygzywtezOSXKuXlzzPOs + C0Bf/mzunvxzDmsLQM7Hy8nLK2fW8l34Xn0P+/kTQiyHDopxmPwBE/wUTPQeVv4l+Pd0u+C25Y+vg9Cn + CkAp/zUFoCdHK8VW/lmCVoCe/G0B8AXXE1oUF8bLuVjs3PL8rq4AjMqfZeOd/bOs5pz9641+hNgNdFCM + w+QPmOCnsJLvwcRvwRUB3C74lQ9e68p/TgGAuKbkbwtAK/9tXv63QuwVACu+pWf/UW5WaqXMIC8cH5tT + ws7Nzq+e57T82bw9+bMc5hSAWv4sn5hRm5PNKmfGCkD4XO32J8SOoINijCB6ugcAYIKfgonegwmfgRJw + +6VnLnC7oFcAmOgZkAKTP5hXAMbO/q0krRxLKVohtvLPAizFZ4VXis4X3PTlfzy2Nyc7r3p+ywtAln+e + u1cAcgYxB0/+YwVgdy/+C8elN/oRYkfQQTFGEP3BFwCAEgDwAkFcDVgifyzIkDmTP/DkP6cATEmyPfvP + UmzlnyXI5dee/fsFwAqulVopMnxOT/7Azi3Pry4ATP55vl4BYPJnGeQc6ixYHjGTVv4sn5hRm5PNKmfG + CoB2+xNit9BBMcbdu3cfYvIHTPBTMNF7MNF7pAIA0u2Cc+QPIDMmflDK3xaAnvznFAAuRi7DXgHwz3p7 + omvl5gvtuzfH583JzqvkcM7+Yx5zCkCdT8yIFaXRs//wedrtT4gdQwfFGN4eAIAJfgomeg8meo+yAACM + 4QWCTPQMSIOJP+HJf6oAlPJnsuzJsS0AVoZcgKX4fNn1BNe//I/n9OaTKOdVz4/NsZ7rdAHI8mfztxnw + ArC7s/+2ADhn/3qjHyF2Dh0UY4QC8DCTP2CCn4KJ3sNKvoctAAncLoirAUz6CSzGTPolowXgOO79j7Ir + BWflZqWWZIav680pYedm5+fNc1r+ed7T8s85rC0AdT4xI68ApKwyrfy1258Q+4EOijGC6OkeAIAJfgom + eg8meg8m/wReIOhdDcCLBSFuJv1EKX9bAEr5xwKQ5T+nAEyf/Wchri8Avcv//tk//o5jXS7/qysA0/Jn + ucRsvLP/tgCMnf0/8f77HtOlfyH2Ax0UY9y9e/cxJn/ABD8FE70HE70HE3/JnTt37t0uWBYACIVJv8ST + /1QBKOVvhckFyaU4Lf8sQE/+tgBYyY0UADy/N58SO7c8v7oAjMqfzduTf84g5zBWAHZ39m8LgN7oR4j9 + QQfFGEz8CSb4KZjoPZjoPZj0S9LnpNsFIX8s5kz4JaX8bQFo5b/Ny/9Wir0CwMVXCs8XXSs3JjV8bTkf + Nic2r8Shnf2PFYDt3/r3uHb7E2Kv0EExTTj7fy0Tf4IJfgomeg8r+R5W+D1u37598dJffOTi5d/5USr9 + knkFYOzs34qSnxlzIXIJtgXASq8UnZWcL7YoMfwZx9ybT6KcVz0/Nsda/my+dQHI885z9wrAds7+WUFq + 5R+zagtAffav3f6E2D90UEwTJO/uAQCY4KdgovdgovdgovfArwMAbhfE1QAm/oQn/zUFgAuSi7GVfxah + FSA/6513+d9KDSLDcfXmU2LnZufnzXNa/nne0/LPOawtALX8Y0ZeAUBWNVn+4d9v6Y1+hNg/dFBMc/Pm + zXcy8SeY4KdgovdgovdgovdIBSD9HZsHTcnfFoBW/ssu/9uz41b+WYi8APAz31J4vuhauZVCA3jMci5s + PolyXt786nnuvgCMyr8tANs9+w/Hot3+hLgC6KCYprcHAGCCn4KJ3oOJ3qMU/BSpAKQSgI+4GvDS7/3z + FQVg7OzfitLKsS0AVoZcgKX4fOG1kvPl9j2bz8HxTs0nUc7Lm1+e47T885yXyX9OAahzsdl4GeWsvlrJ + PxaAJP8b77/vEfbzJYTYPXRQTHMOBaAE/4bbBVkBKOVvC8BV3/ufBdie/fsFoJWblRqOrZyLNyc2rzy3 + 5QUgzznPe04BmJZ/zIQVo/EC0H/xX/g37fYnxBVCB8U0QfLuHgCACX4KJnoPJnoPK/keTP4g/Ts2D8LV + AK8AlPKPBSDLf04BsHJs5Z+F2CsAvvh6omvlVkoNz1HOw5tPopxXPT82R0/+eb5sznne9fxZBmMFYHdn + /6kAaLc/Ia4WOiimCZI/qwJQkjYPmjr7twVgSpitIHsFoCf/LMBSfr7wepKr5YbPtfNI2PnYOZUcztk/ + yyNmsq4A9M/+9UY/Qlw9dFBMw6RfwgQ/BRO9BxO9BxO9BxM+A5+LzYNwu6BXAE5t61/8HcdazsObT8LO + K8+tLgB5jnme0wUgyz/P3SsA2zn7Z/m08gf+i/+0258QhwEdFNMw6ZcwwU/BRO/BRO9hJd+Dyb5H2jxo + v2f/WYj8LHhOAehd/q/lhudjc2HzSZTz8uaX5zhH/mzenvxzBmsLQC3/NqOMlX8sADj7125/QhwGdFD0 + uXnz5puY9EuY4KdgovdgovdgovdgkvfApkGJtHnQkgLQE6QVYyv/LEIrQU/+tgD4kstCw9duT/5XVwBy + DiyLnAnLxTv7bwsAP/t/8te+S2/0I8QBQQdFnyD47iZAgAl+CiZ6DyZ6DyZ6DyZ6j7IAgHS7YJT/Ni// + Wyn2CoCV39Kz/yg4CA1/xnHvqgCMyp/N2ZM/y2CsAOzu7F+7/QlxWNBB0efu3bs/w6RfwgQ/BRO9BxO9 + BxO9BxO9hy0AaRybB3nyZ8JsBWnlyKXYyj9LsJSflV4pO19yWW44Dk/+wM7Hzqnk0M7+xwrAdm79025/ + QhwWdFD0mdoDADDBT8FE78FE78FE71EKfgpbAEpwuyB+JTBVAHqCtGJs5Z9FyAtAe/Y/pwBAaHhMr8jY + uZTYeeW51QWAyT/P1SsATP557nUB2M7Zf1sA/LN/dvk/PL92+xPiwKCDok8oANeZ9EuY4Kdgovdgovdg + ovdgovdg4gfp3199+bnN7YI9YfYE2co/C5EXAC6/Unq+7FrBYRzHPLcAlHMqsfLPc6wLQF/+ec51AWDy + ZxnkLOYUgDqbmI9XAL5ayf97tNufEAcKHRR9guC7ewAAJvgpmOg9mOg9mOg9SsFPweRvwefhasCLv/0P + qTB7gmwLgBUil2ApP194PclFueGY9nP2n+e53QIw/+yf5bLm7D/8/VZ4/vvZz5EQ4mqhg6LP3bt3H2XS + L2GCn4KJ3oOJ3oOJ3sNKvgcTvuUb3/jG5iOuBuB2wZ4o27P/LMZSiFaEXIC9s/8oPC7/KDg8fpL/9gpA + lj+b43blnzOoc4hZeAWglj/LJubjFYCvFvIHX/vQ697FfoaEEFcPHRR9mPAtTPBTMNF7MNF7MNF7MNF7 + WNmPgNsFcTXAinL67D9L0cqwlKCVHy8A/cv/+Lfty//qCsC0/FkmMZfxAtCe/Wu3PyEOGzoofMLZ/2uZ + 8C1M8FMw0Xsw0Xsw0Xsw0XswwffA1YANz3zxAlcDWklyMU7LP0uwlJ8vvVZ0SW74M0S+6wLQl3+eL5uz + J387//ECsP2zf1z6125/Qhw2dFD4BLlP7gEAmOCnYKL3YKL3YKL3YKL3YJLvca8AXILbBWtJLi0AXH6l + 9HzZ1YLDc0zJH4zKHxzO2X/MYqwArDv7125/Qhw+dFD4BLmrAFzCJN+jlD/+jsdI7y7YypFLkYtwXgGw + oktyw+eW8vcKAJM/8OVfFwAmfzbXugDkOed5ewVgO2f/bQEYe/GfdvsT4jigg8JnZA8AwAQ/BRO9BxO9 + BxO9h5V8Dyv4KcoCUBYBfMTtgkyOrfyzDK0EPfmPFAD8GXLfTQHI8vcKQF/+ec7T8s8ZrC0AtfzB9OV/ + vdGPEMcDHRQ+KgAZK/gprPwtafMgT4q8APCz31J6vuyy3CDm3cj/6grAqPzbAuCf/bcFwJz9a7c/IY4G + Oih8QgF4mAnfwgQ/BRO9BxO9BxO9BxO9B5N8Dyb9kldeeWXz7oK4GuAXAC7BUn5WfKXwrOggN3ydlf/2 + CsAy+ef5Tsvfzn9uAagzybmwAlDLPxaAr17K//H3fed72M+MEOIwoYPCJ8h9chMgwAQ/BRO9BxO9BxO9 + BxO9B5N8DyZ9C0oA+PqX/uDi2Q//oCtDfgbcnv37BSCe5WIcYh+RPxiVPzi0s/+xArDwxX96ox8hjg46 + KHzu3r17iwnfwgQ/BRO9BxO9BxO9BxO9B5N8DyZ8j00ReP7pC9wuOFUAfPn1ZBfFBlFb+XsFgMkfWPED + dvmfyX+6ADD557mz+XsFYFr+MZe2APTP/sNH7fYnxBFCB4UPkz2DCX4KJnoPJnoPJnoPJnoPJvkeTPQe + 6UoAwO2CuBrQirAVoC+9VnQQrH3bYk/+YFT+4HDO/lkWMQ+vANTy9wpAPvsPz6k3+hHiCKGDgnPz5s03 + MdkzmOCnYKL3YKL3YKL3YKL3YJLvwUTvURYAgM2DcLtgFiE/+y2lZ4VXSg7//o2PtvL3CgCTP/Dl7539 + zykAWf7TBWD/Z/9Au/0JcbzQQcEJYh/aAwAwwU/BRO/BRO/BRO/BRO/BJN+Did7DFgDw8ssvb64GzC8A + 7eV/yJud/W+vAFzN2f/aAlDLf7IAaLc/IY4YOig4d+/e/RkmewYT/BRM9B5M9B5M9B5M9B5M8j2Y6D1Y + AQAoAendBbMEW/nbAlCKDvKNZ/9jl/+Z+IEv/6srANPyj3m0BWD+i/9uvP++d7KfEyHEcUAHBWd0DwDA + BD8FE70HE70HE70HE70Hk3wPJnoPJv/E5t+ff3pzu6BXADzZ4fMh/6u5/N+Xf10A+vKvC8D+z/5vfOC+ + 6+xnRAhxPNBBwVEBqGGS72El34OJn5FuF7TiK4WXJIe/Q+hzzv7BqPzB4Zz9xxzGCsC8s3/t9ifEaUAH + BSeIfWgPAMAEPwUTvQcTvQcTvQcTvQeTfA8meg8me8bmcy9vF+TSy6KDnA/h7H+6AGT5TxeA7Zz9twXA + P/vXG/0IcRrQQcEJYlcBKGCS72El34PJvsfmBYJ/8ZHN1QAmPAg0y3+XBeBqzv7XFoBa/n4B0G5/QpwO + dFBwmOg9mOCnYKL3YKL3YKL3YKL3YJLvwUTvwSTfY/PiwEC6XTAJD4LDnyH4fZ/977MAjMq/LQDjZ//a + 7U+I04IOCg4TvQcT/BRM9B5M9B5M9B5M9B5M8j2Y6D2Y5HukApDA7YJJdpB2kv9uC8Ay+dcF4FDP/r/n + lt7oR4jTgg6KliD14T0AABP8FEz0Hkz0Hkz0Hkz0HkzyPZjoPZjke9gCsOHGn26uBtTybwsAkz+YJ/9D + Pvv3CsD4i//C82i3PyFODDooWoLUVQAMTPI9mOg9mOR70AJwCW4X3P3Zf10A+vL3CgCTv1cA9nf2f+P9 + 9z3CfiaEEMcNHRQtd+/efYiJ3oMJfgomeg8meg8meg8meg8m+R5M9B5M8j2Y+MG9f7vxpxcv/86PDskf + jMofHM7Z/y4KgN7oR4hThQ6Kljl7AAAm+CmY6D2Y6D2Y6D2Y6D2Y5Hsw0XtYwU9hxc9ImwdNFQAmf+DL + 3zv7n1MAsvynC8B2zv7bAkDP/rXbnxAnCh0ULaEAPMxE78EEPwUTvQcTvQcTvQcTvQeTfA8meg8m+R5M + +Iyvf/3rm82D0tWA7RSAqzn7X1sAavm3BUBv9CPEaUMHRUuQ+vAeAIAJfgomeg8meg8meg8meg8m+R5M + 9B5M8j2Y7D1eeumle5sHrZf/1RWAafl7BcA/+08FQLv9CXH60EHRcvfu3ceY6D2Y4Kdgovdgovdgovdg + ovdgku/BRO/BJN+Did5jcxUggD/jdkG8sdC2CsCo/OsC0Jd/XQD2c/av3f6EOH3ooGgJBYCK3oMJfgom + eg8meg8meg8meg8m+R5M9B5M8j2s5HukApBKQLpd0CsATP7g0M7+xwrA9K1/z13/gfeynwEhxGlBB0VN + kP9rVQBamOR7MNF7MMn3sJLvURaAElwNGC0Ao2f/0wWAyd8rANs5+/cu/0P+2O1Pl/6FOA/ooKgJQn+L + CkALk3wPJnoPJvkeTPQeTP6JdLtgT/7gKs/+1xaAWv51AdBuf0KcD3RQ1Ny8efOdKgAtTPI9mOg9mOR7 + MNF7MPGXpNsFl53976oAzJd/WwD6Z/96ox8hzgs6KGqC/H9ZBaCFSb4HE70Hk3wPJnoPJn3Kl/5g8wJB + XgCWnf3XBeBwzv61258Q5wcdFDUqABwm+R5M9B5M8j2Y6D2o7B1efObJC9wuWMt/eQFYdvafC8C0/L0C + 4L/4T7v9CXGe0EFRE4T+iApAC5N8DyZ6Dyb5Hkz0Hkz0PbBvwEt/8ZHN1YD+5X8mf68A9OVfF4Ddnv1/ + 7UOvexf7vhdCnDZ0UNQEoasAEJjkezDRezDJ92Ci92CS99jI/5JvPPPFC1wNKOU/XQB2dfY/pwD4Z//a + 7U+I84UOihrIXwWghUm+BxO9B5N8DyZ6DyZ6j7IAvPjii/HP2DyoI//pApDlP10AtnP23xaAeOlft/wJ + cb7QQVGjAsBhku/BRO/BJN+Did6Did6jLAAlafOgfZ39ry0AtfxjAdAb/Qhx3tBBkbl58+abVAA4TPI9 + mOg9mOR7MNF7MNF7MPlX/Kdf2ksBGJV/WwD42b92+xNC0EGRCTLfbAKkAtDCJN+Did6DSb4HE70HE70H + lX7B5vMu313Qk39dAPryrwvA9s/+MaY3+hFCADooMkH8D6kAcJjkezDRezDJ92Ci97CS78Gkz0i3C+7r + 7H+sAPAX/2m3PyEEoIMiE8S/2QNABaCFSb4HE70Hk3wPJnoPJnoPJnsGPveFF17YXA149sM/6BQAJn+v + AGzn7N8WAO32J4RI0EGRCeK/rgLAYZLvwUTvwSTfg4new0q+B5O9B+4SAOl2we2f/c8vAKX88UY/7Htc + CHGe0EGRCTLf7AGgAtDCJN+Did6DSb4HE70HE70HE71HKgC4ErC5ZfA/v29zNcDKf7oAbP/sH7f86dK/ + EKKEDopMEP+jKgAcJvkeTPQeTPI9mOg9mOg9mOg9UgEoSbcLjst/ewWgPPsPj/UQ+/4WQpwvdFBkkvxV + AFqY5Hsw0XswyfdgovdgovdgovdgBQBXAwCuBswtANPy9wpAffavN/oRQjDooIgE6b9WBcCHSb4HE70H + k3wPJnoPJnoPJnoPVgAS6QWCeD8BK/+6AGz37F+7/QkhPOigiASR39sDQAWghUm+BxO9B5N8DyZ6DyZ6 + DyZ6Dyb+hmee3GwexOWfC0At/zkFoDn7125/QggKHRSRIHIVgA5M8j2Y6D2Y5Hsw0Xsw0Xsw0XtQ4Tvg + 3QXxAsFdnP2nAnDjA/ddZ9/XQggB6KCIBOnf2wNABaCFSb4HE70Hk3wPJnoPJnoPJnoPJnoGPndzp8Dl + 5kHbLgCQv3b7E0JMQQdFRAWgD5N8DyZ6Dyb5Hkz0Hkz0HlbyPZjsPdKLA9MLBHE1YK782wKQz/6f+61r + b2Hf00IIkaCDIhJEfm8PABWAFib5Hkz0HkzyPZjoPZjoPZjoPZjoPcoCAJ75ypc2twtu4+xfb/QjhBiB + DopIELkKQAcm+R5M9B5M8j2Y6D2Y6D2Y6D2Y6D1sAUjgBYJ9+XsFIJ79a7c/IcQodFBEgvRvqQD4MMn3 + YKL3YJLvwUTvwUTvwUTvwUTvweSfwOZBX/34g04B8M/+gXb7E0KMQgdFpJS/CkALk3wPJnoPJvkeTPQe + TPQeTPQeTPQeTPyJW7du3btdcE4BeFa7/QkhZkAHxTu+4+bNm29SAejDJN+Did6DSb4HE70HE70HE70H + E70HE38JSgBImwf15I8x7fYnhJgLHRTtHgAqAC1M8j2Y6D2Y5Hsw0Xsw0Xsw0Xsw0Xsw6Xuk2wW9AoDd + /sLZ//3s+1gIITzooNhc/v8ZFYA+TPI9mOg9mOR7MNF7MNF7MNF7MNF7MNF7PP/88xdPPvnkxZc/828u + nv6NNzQF4Gsfet272PewEEL0oIOi3QNABaCFSb4HE70Hk3wPJnoPJnoPJnoPJnoPJnqPxx9//OJP/uRP + NvzhZz69eYFgkv+ND9z3MPv+FUKIKejgufPAAw+8RgVgGib5Hkz0HkzyPZjoPZjoPZjoPZjoPZjoLTjz + /8IXvnBP/iW4GqA3+hFCrIEOinYPABWAFib5Hkz0HkzyPZjoPZjoPZjoPZjoPZjwS55++umLz33uc1T+ + 4M/+7M/++Itf/KLkL4RYDB0Um18BPKoC0IdJvgcTvQeTfA8meg8meg8meg8meg8mfYCz/r/+0n+n0k8E + +T+Fu1TY960QQoxCB0W7B4AKQAuTfA8meg8m+R5M9B5M9B5M9B5M9B5M/vhdf++sH0j+QohtQQeFCsAI + TPI9mOg9mOR7MNF7MNF7MNF7MNF7zBU/wGV/yV8IsS3o4LkTBN7sAaAC0MIk34OJ3oNJvgcTvQcTvQcT + vQcTvccc8QP9zl8IsW3o4LkTBK4CMACTfA8meg8m+R5M9B5M9B5M9B5M9Azc0++9up8R5P8bkr8QYtvQ + wXMnyP4hK3/ARO/BBD8FE70HE70HE70HE70Hk3wPJnoPJvkeTPQeTPQeTPQeTPYlTz311Czxg8997nM/ + x75HhRBiLXTw3PnABz7wnl/91V/dLMBYuFUAOEzyPZjoPZjkezDRezDRezDRe1jhJ5aIXy/2E0LsGjp4 + 7ly7du3DDzzwwEXiX/yLf3HxL//lv7z43d/93YsnnniCCt/CBD8FE70HE70HE70HE70Hk3wPJnoPJvke + TPQeTPQeTPQeVvzPPvtsI/4g9urvFoj/85///C+l70VsSlV+bwohxLagg+fOG9/4xj8sC4Dlx37sx+4V + AryYSwVgDCZ6Dyb5Hkz0Hkz0Hkz0Hkz8SfhT4gfhc37jrx79I72pjxBiL9DBc+cNb3jDl5n4PXCF4Dd/ + 8zc3i74KgA8TvQeTfA8meg8meg8meg8rfiZ9Z0ziF0LsHTp47jDJj4KrA3j9AETAJN+Did6Did6Did6D + id6DSb4HE70Hk3wPJnoPJnoPJnoLrgJh974k/VLy6c/lWPFvEr8Q4sqgg+dMOPv/fib2OYTH2HxMVwZw + vzcTvoWJ3oOJ3oOJ3oOJ3oNJvgcTvQeTfA8meg8meg8m/EQSf7qX30qeSf9y/I8DP86+/4QQYl/QwXMm + iPstpcy3AQoBXjOAt3Jl4k8w0Xsw0Xsw0Xsw0Xswyfdgovdgku/BRO/BRO8xIn4iePp3iV8IcUjQwXPm + 2rVrP8skvpZ0VSD9ioBdFWCi92Ci92Ci92Ci92CS78FE78Ek34OJ3oOJ3sPKH3eBWPEXgvfGJX4hxMFB + B8+ZN77xjf/ayntX4KpA+VoBJnoPJnoPJnoPJnoPJvkeTPQeTPI9mOg9mOg9mPg94dux8OentJGPEOJQ + oYPnzD4LQAKvFYAwmOg9mOg9mOg9mOg9mOR7MNF7MMn3YKL3YKL3YOK32EIg8QshjgE6eM5M7QGwS+YU + ASZ6DyZ6DyZ6Dyb5Hkz0HkzyPZjoPZjoLU8//XRzL3/CCr8Yl/iFEEcDHTxnrrIAJEaKABO9BxO9BxO9 + B5N8DyZ6Dyb5Hkz0Hkz4iSR+yN0TvwXix+59esMeIcQxQQfPGSbkq6JXBJjoPZjoPZjoPZjkezDRezDJ + 92Ci9xgRf+JS8KXs730MSPxCiKOFDp4zTMRXDV4siLsGVAB8mOg9SvE///zzzSY+JUn8Rv4SvxDi6KGD + 50qQ7db3ANgW6fZBCEsFoIWJ3mNE/IlS/Jd/1u59QoiTgA6eK0G0B1sAyn0EICImeg8meg8meg8m+R5M + 9B5M8j2Y6Bm3bt0aEn9C4hdCnCp08FwJkn23Fe8hknYWfO6556jwLUz0Hkz0HkzyPZjoPZjkezDZl+Be + fvwaBbf0WclPIPELIU4SOniuXMUeAEtBCcDVALzXAJN+CRO9BxO9B5N8DyZ6Dyb5Hkz6YIX4//jmzZtv + Yt8nQghxCtDBcyRI9TXXrl37sBXtMYC7BSA5Jn/ARO/BRO/BJN+Did6DSb7HiPgHS8C9bXtDtq+x3ydC + CHEq0MFz5RD2AFgKrgb87u/+rgpA4Mknn1wlfiGEOAfo4Lnyhje84ctMrseC99oAJnoPJnoPJvkeTPQe + TPI9RsTvFIGnAhK/EOLsoIPnCpPqsZFeG4BNbc6lAJTitx/tnwvubdsbcnsNsN8PQghxytDBcySI8/tL + kZ4C6QWCTPQeTPQeTPI9mOg9mOgtzzzzzKboOIKfFL8QQpwzdPAcCcI82D0A1oBfCTz77LNU9gwmeg8m + +R5M9B5M+IlS/AnI3X40bHbvC5noTF8IIQJ08By5du3az1p5Hjv4dcDrX//6zV0CECYTvoWJ3oNJvgcT + vccS8Vsux7VtrxBCEOjgOXJMewDMJb0u4A8/82kq/RImeg8m+R5M9B6l+F944YXN7n1M/PbvSf4SvxBC + 9KGD58gpFwCAEgBwqyATf4KJ3oNJvgcTvYcVfyn4JH07XvAbEr8QQvShg+fIMe8BMBe8LoDJHzDRezDJ + 92CiZ7z44ouN+C12PIm/3LY3zFW/7xdCCAc6eI6cUwEA3osDmeg9mOR7MNmX4F7+cvc+K3g2fjmm/fqF + EGImdPAcYZI8dfDiQFsCmOg9mOR7MOmDUvxE7nQchH/7Y4lfCCGWQQfPESbIUwevCbAlgIneg0m+xxzx + l9izf4g/oP36hRBiBXTw3AgiPLlNgOZQlgAmeg8m+R6l/J966qnmlj5LEn7xd+3XL4QQW4IOnhNBgK95 + /etff5KbAI1SXglgovdgku8xKn5Qyj/8Wfv1CyHElqGD50YQ4LuZGM8NlABstsNkz2CS97h58+aQ+Esg + /vBR2/YKIcQOoIPnxqnvATBKuhIwWgKY6C14Z0KJXwghDg86eG5cu3btw0yI58poCWDCTywU/4X26xdC + iP1AB8+Nc9sDYIrRKwHbFr927xNCiP1BB8+NILwvMxGeO9gsiIk/UYr/pZdeavbrn0LiF0KIq4MOnhtM + fucOrgLgY68ELBU/kPiFEOJqoYPnxLVr115r5SdqfvM3f7OR/9e//vVF4g9n/fe27Q2Prd/1CyHEFUEH + z4kgobPeA2AUvIsgxI936btx4waVe49S/EIIIa4eOnhOXLt27WeZ8ETNj/3Yj1384Wc+TeXeI4hf+/UL + IcQBQgfPCe0BMA1eD/D6179+UwL+5E/+hIreAvEHtHufEEIcKHTwnFAB8EniL8HtgUz4CYlfCCGOAzp4 + TmgPgBYm/hLcGSDxCyHEcUMHzwkVgMyU+EtwZ8Cl+O9t2xseQ6/qF0KII4EOnhNWgucKk3yPUBa+nMQv + hBDi+KCD5wST4TnB5N4D4g/g3RN1ti+EEEcMHTwHILAgsu8vZXhOMLlP8AJeMImNk1ieQgghjgs6eC4E + qZ3dJkBG6iNI/EIIcYLQwXPh8lI2FeWpEebK5N5D4hdCiBOGDp4LEByT5SmxQPwXQfofxq9HkFF4DP2u + XwghThA6eC5AdFaYp8Ja8QshhDht6OC5cIp7AEj8QgghRqCD50KQ3peZRI+RJeJHAZL4hRDiPKGD5wIT + 6bGxVPzh41suM3gNsNkIIYQ4bejgOYBXt5ciPTbWil8IIcR5QwfPgSDRo9wDYIn4w9d8OXyU+IUQQtyD + Dp4D165d+1km2ENlqfgxTzZ/IYQQ5w0dPAeOaQ8AJvceEr8QQogp6OA5cAwFgMl9gheC/N/N5iuEEEKU + 0MFzAC+IY9I9BIjYp9C2vUIIIWZBB8+BQywAROxTSPxCCCEWQQfPAciTSfgqWPICP4lfCCHEGujgOcBE + vG+WiD9IX9v2CiGEWA0dPHUgUCbkfSHxCyGEuGro4CkTBPyaINQr2QRI4hdCCHEo0MFTJ0h1r5sALRE/ + XqQYPmr3PiGEEDuBDp46eAEdE/W2kfiFEEIcKnTw1MFldSbsbSHxCyGEOHTo4KkD2TJxr2WJ+MPXaNte + IYQQe4cOnjrbLgASvxBCiGODDp46TOJLYXLvIfELIYQ4BOjgKRPk+1om8rkwuU+w2baXHZMQQgixb+jg + KRPkvWoPACL2KbRfvxBCiIODDp4yQeKLCgAR+xQSvxBCiIOFDp4ykDITvMeSF/gF6X9Y4hdCCHHI0MFT + ZrQALBV/+Dpt2yuEEOLgoYOnTCgA3VsAJX4hhBDnAB08ZVAAIPltiP/ysSR+IYQQRwcdPGWCuF+wIp8L + xB8+atteIYQQRwsdPGWszOcg8QshhDgV6OApY6U+BX41EPhy+LPEL4QQ4mSgg6eMFXwPiP+atu0VQghx + gtDBU+bybJ4KPyHxCyGEOHXo4CkDsTPpX/KCxC+EEOIcoIOnzhvf+MZ/Ddkn8eOMP/DuIH/t3ieEEOIM + eMd3/P/QGEJtlk6SsgAAAABJRU5ErkJggg== + + + \ No newline at end of file diff --git a/Project/Project/Repositories/IDecreeRepository.cs b/Project/Project/Repositories/IDecreeRepository.cs new file mode 100644 index 0000000..4a3071f --- /dev/null +++ b/Project/Project/Repositories/IDecreeRepository.cs @@ -0,0 +1,9 @@ +using Project.Entities; + +namespace Project.Repositories; + +public interface IDecreeRepository +{ + IEnumerable GetAllDecrees(); + void AddDecree(Decree decree); +} \ No newline at end of file diff --git a/Project/Project/Repositories/IStatementRepository.cs b/Project/Project/Repositories/IStatementRepository.cs new file mode 100644 index 0000000..ac4cc50 --- /dev/null +++ b/Project/Project/Repositories/IStatementRepository.cs @@ -0,0 +1,9 @@ +using Project.Entities; + +namespace Project.Repositories; + +public interface IStatementRepository +{ + void CreateStatement(Statement statement); + IEnumerable GetAllStatements(); +} diff --git a/Project/Project/Repositories/IStudentRepository.cs b/Project/Project/Repositories/IStudentRepository.cs new file mode 100644 index 0000000..4c8d257 --- /dev/null +++ b/Project/Project/Repositories/IStudentRepository.cs @@ -0,0 +1,12 @@ +using Project.Entities; + +namespace Project.Repositories; + +public interface IStudentRepository +{ + IEnumerable GetAllStudents(); + Student GetStudentById(int id); + void AddStudent(Student student); + void UpdateStudent(Student student); + void DeleteStudent(int id); +} diff --git a/Project/Project/Repositories/ISubjectRepository.cs b/Project/Project/Repositories/ISubjectRepository.cs new file mode 100644 index 0000000..e415420 --- /dev/null +++ b/Project/Project/Repositories/ISubjectRepository.cs @@ -0,0 +1,12 @@ +using Project.Entities; + +namespace Project.Repositories; + +public interface ISubjectRepository +{ + IEnumerable GetAllSubjects(); + Subject GetSubjectById(int id); + void AddSubject(Subject subject); + void UpdateSubject(Subject subject); + void DeleteSubject(int id); +} diff --git a/Project/Project/Repositories/ITeacherRepository.cs b/Project/Project/Repositories/ITeacherRepository.cs new file mode 100644 index 0000000..5d094cc --- /dev/null +++ b/Project/Project/Repositories/ITeacherRepository.cs @@ -0,0 +1,12 @@ +using Project.Entities; + +namespace Project.Repositories; + +public interface ITeacherRepository +{ + IEnumerable GetAllTeachers(); + Teacher GetTeacherById(int id); + void AddTeacher(Teacher teacher); + void UpdateTeacher(Teacher teacher); + void DeleteTeacher(int id); +} diff --git a/Project/Project/Repositories/Implementations/DecreeRepository.cs b/Project/Project/Repositories/Implementations/DecreeRepository.cs new file mode 100644 index 0000000..a202cba --- /dev/null +++ b/Project/Project/Repositories/Implementations/DecreeRepository.cs @@ -0,0 +1,16 @@ +using Project.Entities; + +namespace Project.Repositories.Implementations; + + +public class DecreeRepository : IDecreeRepository +{ + public void AddDecree(Decree decree) + { + } + + public IEnumerable GetAllDecrees() + { + return []; + } +} diff --git a/Project/Project/Repositories/Implementations/StatementRepository.cs b/Project/Project/Repositories/Implementations/StatementRepository.cs new file mode 100644 index 0000000..765d48d --- /dev/null +++ b/Project/Project/Repositories/Implementations/StatementRepository.cs @@ -0,0 +1,15 @@ +using Project.Entities; + +namespace Project.Repositories.Implementations; + +public class StatementRepository : IStatementRepository +{ + public void CreateStatement(Statement statement) + { + } + + public IEnumerable GetAllStatements() + { + return []; + } +} \ No newline at end of file diff --git a/Project/Project/Repositories/Implementations/StudentRepository.cs b/Project/Project/Repositories/Implementations/StudentRepository.cs new file mode 100644 index 0000000..fdd19cb --- /dev/null +++ b/Project/Project/Repositories/Implementations/StudentRepository.cs @@ -0,0 +1,28 @@ +using Project.Entities; + +namespace Project.Repositories.Implementations; + +public class StudentRepository : IStudentRepository +{ + public void AddStudent(Student student) + { + } + + public void DeleteStudent(int id) + { + } + + public IEnumerable GetAllStudents() + { + return []; + } + + public Student GetStudentById(int id) + { + return Student.CreateOperation(0, "", "", 0); + } + + public void UpdateStudent(Student student) + { + } +} \ No newline at end of file diff --git a/Project/Project/Repositories/Implementations/SubjectRepository.cs b/Project/Project/Repositories/Implementations/SubjectRepository.cs new file mode 100644 index 0000000..067047a --- /dev/null +++ b/Project/Project/Repositories/Implementations/SubjectRepository.cs @@ -0,0 +1,29 @@ +using Project.Entities; + +namespace Project.Repositories.Implementations; + + +public class SubjectRepository : ISubjectRepository +{ + public void AddSubject(Subject subject) + { + } + + public void DeleteSubject(int id) + { + } + + public IEnumerable GetAllSubjects() + { + return []; + } + + public Subject GetSubjectById(int id) + { + return Subject.CreateOperation(0, "", Entities.Enums.Course.Third); + } + + public void UpdateSubject(Subject subject) + { + } +} diff --git a/Project/Project/Repositories/Implementations/TeacherRepository.cs b/Project/Project/Repositories/Implementations/TeacherRepository.cs new file mode 100644 index 0000000..ea77a27 --- /dev/null +++ b/Project/Project/Repositories/Implementations/TeacherRepository.cs @@ -0,0 +1,28 @@ +using Project.Entities; + +namespace Project.Repositories.Implementations; + +public class TeacherRepository : ITeacherRepository +{ + public void AddTeacher(Teacher teacher) + { + } + + public void DeleteTeacher(int id) + { + } + + public IEnumerable GetAllTeachers() + { + return []; + } + + public Teacher GetTeacherById(int id) + { + return Teacher.CreateOperation(0, "", ""); + } + + public void UpdateTeacher(Teacher teacher) + { + } +} \ No newline at end of file diff --git a/Project/Project/Resources/Add.png b/Project/Project/Resources/Add.png new file mode 100644 index 0000000000000000000000000000000000000000..079cda019f1118f5671d84910becfc5dde2479a1 GIT binary patch literal 14601 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 literal 0 HcmV?d00001 diff --git a/Project/Project/Resources/Del.png b/Project/Project/Resources/Del.png new file mode 100644 index 0000000000000000000000000000000000000000..2b4c3568f247b4dfde2a07949312bc9c55bec95d GIT binary patch literal 16895 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 Vy%ao^3KC7wH8pK~uB!FZ{{w8S7&-s| literal 0 HcmV?d00001 diff --git a/Project/Project/Resources/Upd.png b/Project/Project/Resources/Upd.png new file mode 100644 index 0000000000000000000000000000000000000000..79dd85fda304e67d00c86fe621ec827b2d59f7f7 GIT binary patch literal 12849 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 - /// Required designer variable. - /// - private System.ComponentModel.IContainer components = null; - - /// - /// Clean up any resources being used. - /// - /// true if managed resources should be disposed; otherwise, false. - protected override void Dispose(bool disposing) - { - if (disposing && (components != null)) - { - components.Dispose(); - } - base.Dispose(disposing); - } - - #region Windows Form Designer generated code - - /// - /// Required method for Designer support - do not modify - /// the contents of this method with the code editor. - /// - private void InitializeComponent() - { - this.components = new System.ComponentModel.Container(); - this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; - this.ClientSize = new System.Drawing.Size(800, 450); - this.Text = "Form1"; - } - - #endregion - } -} diff --git a/ProjectExams/ProjectExams/Form1.cs b/ProjectExams/ProjectExams/Form1.cs deleted file mode 100644 index 5f3fec5..0000000 --- a/ProjectExams/ProjectExams/Form1.cs +++ /dev/null @@ -1,10 +0,0 @@ -namespace ProjectExams -{ - public partial class Form1 : Form - { - public Form1() - { - InitializeComponent(); - } - } -} diff --git a/ProjectExams/ProjectExams/Program.cs b/ProjectExams/ProjectExams/Program.cs deleted file mode 100644 index 7c7aa66..0000000 --- a/ProjectExams/ProjectExams/Program.cs +++ /dev/null @@ -1,17 +0,0 @@ -namespace ProjectExams -{ - 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 Form1()); - } - } -} \ No newline at end of file diff --git a/ProjectExams/ProjectExams/ProjectExams.csproj b/ProjectExams/ProjectExams/ProjectExams.csproj deleted file mode 100644 index 663fdb8..0000000 --- a/ProjectExams/ProjectExams/ProjectExams.csproj +++ /dev/null @@ -1,11 +0,0 @@ - - - - WinExe - net8.0-windows - enable - true - enable - - - \ No newline at end of file -- 2.25.1