From d69c564a1004cfa81d0dcb47588739111b4e56d0 Mon Sep 17 00:00:00 2001 From: GuardianY Date: Wed, 24 Apr 2024 13:59:08 +0400 Subject: [PATCH] LabWork1 --- ProjectOOP/ProjectOOP/DirectionType.cs | 28 + ProjectOOP/ProjectOOP/DrawningCruiser.cs | 240 ++++++ ProjectOOP/ProjectOOP/EntityCruiser.cs | 65 ++ ProjectOOP/ProjectOOP/Form1.Designer.cs | 39 - ProjectOOP/ProjectOOP/Form1.cs | 10 - ProjectOOP/ProjectOOP/FormCruiser.Designer.cs | 137 +++ ProjectOOP/ProjectOOP/FormCruiser.cs | 88 ++ ProjectOOP/ProjectOOP/FormCruiser.resx | 814 ++++++++++++++++++ ProjectOOP/ProjectOOP/Program.cs | 2 +- ProjectOOP/ProjectOOP/ProjectOOP.csproj | 15 + .../Properties/Resources.Designer.cs | 63 ++ .../{Form1.resx => Properties/Resources.resx} | 0 12 files changed, 1451 insertions(+), 50 deletions(-) create mode 100644 ProjectOOP/ProjectOOP/DirectionType.cs create mode 100644 ProjectOOP/ProjectOOP/DrawningCruiser.cs create mode 100644 ProjectOOP/ProjectOOP/EntityCruiser.cs delete mode 100644 ProjectOOP/ProjectOOP/Form1.Designer.cs delete mode 100644 ProjectOOP/ProjectOOP/Form1.cs create mode 100644 ProjectOOP/ProjectOOP/FormCruiser.Designer.cs create mode 100644 ProjectOOP/ProjectOOP/FormCruiser.cs create mode 100644 ProjectOOP/ProjectOOP/FormCruiser.resx create mode 100644 ProjectOOP/ProjectOOP/Properties/Resources.Designer.cs rename ProjectOOP/ProjectOOP/{Form1.resx => Properties/Resources.resx} (100%) diff --git a/ProjectOOP/ProjectOOP/DirectionType.cs b/ProjectOOP/ProjectOOP/DirectionType.cs new file mode 100644 index 0000000..8c0838e --- /dev/null +++ b/ProjectOOP/ProjectOOP/DirectionType.cs @@ -0,0 +1,28 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace ProjectOOP +{ + public enum DirectionType + { + /// + /// Вверх + /// + Up = 1, + /// + /// Вниз + /// + Down = 2, + /// + /// Влево + /// + Left = 3, + /// + /// Вправо + /// + Right = 4 + } +} diff --git a/ProjectOOP/ProjectOOP/DrawningCruiser.cs b/ProjectOOP/ProjectOOP/DrawningCruiser.cs new file mode 100644 index 0000000..4113a2c --- /dev/null +++ b/ProjectOOP/ProjectOOP/DrawningCruiser.cs @@ -0,0 +1,240 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace ProjectOOP +{ + public class DrawningCruiser + { + /// + /// Класс-сущность + /// + public EntityCruiser? EntityCruiser { get; private set; } + /// + /// Ширина окна + /// + private int? _pictureWidth; + /// + /// Высота окна + /// + private int? _pictureHeight; + /// + /// Левая координата прорисовки крейсера + /// + private int? _startPosX; + /// + /// Верхняя кооридната прорисовки крейсера + /// + private int? _startPosY; + /// + /// Ширина прорисовки крейсера + /// + private readonly int _drawningCruiserWidth = 410; + /// + /// Высота прорисовки крейсера + /// + private readonly int _drawningCruiserHeight = 110; + /// + /// Инициализация свойств + /// + /// Скорость + /// Вес + /// Основной цвет + /// Дополнительный цвет + /// Признак наличия обвеса + /// Признак наличия антикрыла + /// Признак наличия гоночной полосы + public void Init(int speed, double weight, Color bodyColor, Color + additionalColor, bool towers, bool turrets, bool flag) + { + EntityCruiser = new EntityCruiser(); + EntityCruiser.Init(speed, weight, bodyColor, additionalColor, + towers, turrets, flag); + _pictureWidth = null; + _pictureHeight = null; + _startPosX = null; + _startPosY = null; + } + /// + /// Установка границ поля + /// + /// Ширина поля + /// Высота поля + /// true - границы заданы, false - проверка не пройдена, нельзя + public bool SetPictureSize(int width, int height) + { + if (_drawningCruiserWidth <= width && _drawningCruiserHeight <= height) + { + _pictureWidth = width; + _pictureHeight = height; + if (_startPosX.HasValue && _startPosY.HasValue) + { + if (_startPosX + _drawningCruiserWidth <= _pictureWidth) + { + _startPosX = 0; + } + if (_startPosY + _drawningCruiserHeight <= _pictureHeight) + { + _startPosY = 0; + } + } + return true; + } + return false; + } + /// + /// Установка позиции + /// + /// Координата X + /// Координата Y + public void SetPosition(int x, int y) + { + if (!_pictureHeight.HasValue || !_pictureWidth.HasValue) + { + return; + } + + if (x + _drawningCruiserWidth > _pictureWidth.Value || y + _drawningCruiserHeight > _pictureHeight.Value || x < 0 || y < 0) + { + _startPosX = 0; + _startPosY = 0; + return; + } + _startPosX = x; + _startPosY = y; + } + /// + /// Изменение направления перемещения + /// + /// Направление + /// true - перемещене выполнено, false - перемещение + //невозможно + public bool MoveTransport(DirectionType direction) + { + if (EntityCruiser == null || !_startPosX.HasValue || !_startPosY.HasValue) + { + return false; + } + switch (direction) + { + //влево + case DirectionType.Left: + if (_startPosX.Value - EntityCruiser.Step > 0) + { + _startPosX -= (int)EntityCruiser.Step; + } + return true; + //вверх + case DirectionType.Up: + if (_startPosY.Value - EntityCruiser.Step > 0) + { + _startPosY -= (int)EntityCruiser.Step; + } + return true; + // вправо + case DirectionType.Right: + if (_startPosX.Value + EntityCruiser.Step + _drawningCruiserWidth < _pictureWidth) + { + _startPosX += (int)EntityCruiser.Step; + } + return true; + //вниз + case DirectionType.Down: + if (_startPosY.Value + EntityCruiser.Step + _drawningCruiserHeight < _pictureHeight) + { + _startPosY += (int)EntityCruiser.Step; + } + return true; + default: + return false; + } + } + /// + /// Прорисовка объекта + /// + /// + public void DrawTransport(Graphics g) + { + if (EntityCruiser == null || !_startPosX.HasValue || + !_startPosY.HasValue) + { + return; + } + Pen pen = new(Color.Black); + Brush additionalBrush = new + SolidBrush(EntityCruiser.AdditionalColor); + Brush brRed = new SolidBrush(Color.Red); + Brush br = new SolidBrush(EntityCruiser.BodyColor); + Brush brBlue = new SolidBrush(Color.LightBlue); + Brush brBlack = new SolidBrush(Color.Black); + // корпус корабля + g.DrawLine(pen, _startPosX.Value + 10, _startPosY.Value + 10, _startPosX.Value + 200, _startPosY.Value + 10); + Point point1 = new Point(_startPosX.Value + 10, _startPosY.Value + 10); + Point point2 = new Point(_startPosX.Value + 310, _startPosY.Value + 10); + Point point3 = new Point(_startPosX.Value + 410, _startPosY.Value + 60); + Point point4 = new Point(_startPosX.Value + 310, _startPosY.Value + 110); + Point point5 = new Point(_startPosX.Value + 10, _startPosY.Value + 110); + Point[] points = + { + point1,point2,point3,point4,point5 + }; + + g.FillPolygon(br, points); + g.DrawPolygon(pen, points); + // двигатели + g.FillRectangle(brBlack, _startPosX.Value + 5, _startPosY.Value + 25, 5, 30); + g.FillRectangle(brBlack, _startPosX.Value + 5, _startPosY.Value + 65, 5, 30); + + + //башни с орудиями + if (EntityCruiser.Turerts) + { + Pen pen2 = new(Color.Black, 3); + Pen pen3 = new(Color.Black, 5); + g.FillEllipse(additionalBrush, _startPosX.Value + 140, +_startPosY.Value + 15, 26, 26); + g.DrawEllipse(pen, _startPosX.Value + 140, +_startPosY.Value + 15, 26, 26); + g.FillEllipse(additionalBrush, _startPosX.Value + 190, +_startPosY.Value + 15, 26, 26); + g.DrawEllipse(pen, _startPosX.Value + 190, +_startPosY.Value + 15, 26, 26); + g.FillEllipse(additionalBrush, _startPosX.Value + 140, +_startPosY.Value + 79, 26, 26); + g.DrawEllipse(pen, _startPosX.Value + 140, +_startPosY.Value + 79, 26, 26); + g.FillEllipse(additionalBrush, _startPosX.Value + 190, +_startPosY.Value + 79, 26, 26); + g.DrawEllipse(pen, _startPosX.Value + 190, +_startPosY.Value + 79, 26, 26); + g.DrawLine(pen2, _startPosX.Value + 153, _startPosY.Value + 28, _startPosX.Value + 173, _startPosY.Value + 8); + g.DrawLine(pen2, _startPosX.Value + 203, _startPosY.Value + 28, _startPosX.Value + 223, _startPosY.Value + 8); + g.DrawLine(pen2, _startPosX.Value + 203, _startPosY.Value + 92, _startPosX.Value + 223, _startPosY.Value + 112); + g.DrawLine(pen2, _startPosX.Value + 153, _startPosY.Value + 92, _startPosX.Value + 173, _startPosY.Value + 112); + g.FillEllipse(additionalBrush, _startPosX.Value + 300, +_startPosY.Value + 44, 32, 32); + g.DrawEllipse(pen, _startPosX.Value + 300, +_startPosY.Value + 44, 32, 32); + g.DrawLine(pen3, _startPosX.Value + 316, _startPosY.Value + 60, _startPosX.Value + 356, _startPosY.Value + 60); + } + // флаг + if (EntityCruiser.Flag) + { + + g.DrawLine(pen, _startPosX.Value + 40, _startPosY.Value + 60, _startPosX.Value + 40, _startPosY.Value + 20); + g.FillRectangle(additionalBrush, _startPosX.Value + 20, _startPosY.Value + 20, 20, 20); + g.DrawLine(pen, _startPosX.Value + 20, _startPosY.Value + 30, _startPosX.Value + 40, _startPosY.Value + 30); + g.DrawRectangle(pen, _startPosX.Value + 20, _startPosY.Value + 20, 20, 20); + } + // Надстройки корабля + if (EntityCruiser.Towers) + { + g.FillRectangle(additionalBrush, _startPosX.Value + 230, _startPosY.Value + 30, 30, 60); + g.DrawRectangle(pen, _startPosX.Value + 230, _startPosY.Value + 30, 30, 60); + g.FillRectangle(brBlue, _startPosX.Value + 256, _startPosY.Value + 40, 4, 40); + g.FillRectangle(additionalBrush, _startPosX.Value + 130, _startPosY.Value + 50, 100, 20); + g.DrawRectangle(pen, _startPosX.Value + 130, _startPosY.Value + 50, 100, 20); + g.FillRectangle(additionalBrush, _startPosX.Value + 60, _startPosY.Value + 30, 50, 15); + g.DrawRectangle(pen, _startPosX.Value + 60, _startPosY.Value + 30, 50, 15); + g.FillRectangle(additionalBrush, _startPosX.Value + 60, _startPosY.Value + 75, 50, 15); + g.DrawRectangle(pen, _startPosX.Value + 60, _startPosY.Value + 75, 50, 15); + g.FillEllipse(brBlack, _startPosX.Value + 65, +_startPosY.Value + 30, 15, 15); + g.FillEllipse(brBlack, _startPosX.Value + 90, +_startPosY.Value + 30, 15, 15); + g.FillEllipse(brBlack, _startPosX.Value + 65, +_startPosY.Value + 75, 15, 15); + g.FillEllipse(brBlack, _startPosX.Value + 90, +_startPosY.Value + 75, 15, 15); + } + } + } +} diff --git a/ProjectOOP/ProjectOOP/EntityCruiser.cs b/ProjectOOP/ProjectOOP/EntityCruiser.cs new file mode 100644 index 0000000..82f47e4 --- /dev/null +++ b/ProjectOOP/ProjectOOP/EntityCruiser.cs @@ -0,0 +1,65 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace ProjectOOP +{ + public class EntityCruiser + { + public int Speed { get; private set; } + /// + /// Скорость + /// + public double Weight { get; private set; } + /// + /// Вес + /// + public Color BodyColor { get; private set; } + /// + /// Основной цвет + /// + public Color AdditionalColor { get; private set; } + /// + /// Дополнительный цвет (для опциональных элементов) + /// + public bool Turerts { get; private set; } + /// + /// Признак (опция) боевых башен + /// + public bool Towers { get; private set; } + /// + /// Признак (опция) наличия надстроек + /// + public bool Flag { get; private set; } + /// + /// Наличие флага + /// + public double Step => Speed * 100 / Weight; + /// + /// Шаг перемещения крейсера + /// + /// + /// Инициализация полей объекта-класса крейсера + /// + /// Скорость + /// Вес крейсера + /// Основной цвет + /// Дополнительный цвет + /// Признак наличия боевых башен + /// Признак наличия надстроек + /// Признак наличия флага + public void Init(int speed, double weight, Color bodyColor, Color + additionalColor, bool turrets, bool towers, bool flag) + { + Speed = speed; + Weight = weight; + BodyColor = bodyColor; + AdditionalColor = additionalColor; + Turerts = turrets; + this.Towers = towers; + this.Flag = flag; + } + } +} diff --git a/ProjectOOP/ProjectOOP/Form1.Designer.cs b/ProjectOOP/ProjectOOP/Form1.Designer.cs deleted file mode 100644 index 32fc00e..0000000 --- a/ProjectOOP/ProjectOOP/Form1.Designer.cs +++ /dev/null @@ -1,39 +0,0 @@ -namespace ProjectOOP -{ - partial class Form1 - { - /// - /// Required designer variable. - /// - private System.ComponentModel.IContainer components = null; - - /// - /// Clean up any resources being used. - /// - /// true if managed resources should be disposed; otherwise, false. - protected override void Dispose(bool disposing) - { - if (disposing && (components != null)) - { - components.Dispose(); - } - base.Dispose(disposing); - } - - #region Windows Form Designer generated code - - /// - /// Required method for Designer support - do not modify - /// the contents of this method with the code editor. - /// - private void InitializeComponent() - { - this.components = new System.ComponentModel.Container(); - this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; - this.ClientSize = new System.Drawing.Size(800, 450); - this.Text = "Form1"; - } - - #endregion - } -} diff --git a/ProjectOOP/ProjectOOP/Form1.cs b/ProjectOOP/ProjectOOP/Form1.cs deleted file mode 100644 index 9237891..0000000 --- a/ProjectOOP/ProjectOOP/Form1.cs +++ /dev/null @@ -1,10 +0,0 @@ -namespace ProjectOOP -{ - public partial class Form1 : Form - { - public Form1() - { - InitializeComponent(); - } - } -} diff --git a/ProjectOOP/ProjectOOP/FormCruiser.Designer.cs b/ProjectOOP/ProjectOOP/FormCruiser.Designer.cs new file mode 100644 index 0000000..a36132f --- /dev/null +++ b/ProjectOOP/ProjectOOP/FormCruiser.Designer.cs @@ -0,0 +1,137 @@ +namespace ProjectOOP +{ + partial class FormCruiser + { + /// + /// 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(FormCruiser)); + pictureBoxCruiser = new PictureBox(); + buttonCreateCruiser = new Button(); + buttonLeft = new Button(); + buttonRight = new Button(); + buttonUp = new Button(); + buttonDown = new Button(); + ((System.ComponentModel.ISupportInitialize)pictureBoxCruiser).BeginInit(); + SuspendLayout(); + // + // pictureBoxCruiser + // + pictureBoxCruiser.Dock = DockStyle.Fill; + pictureBoxCruiser.Location = new Point(0, 0); + pictureBoxCruiser.Name = "pictureBoxCruiser"; + pictureBoxCruiser.Size = new Size(912, 535); + pictureBoxCruiser.TabIndex = 0; + pictureBoxCruiser.TabStop = false; + pictureBoxCruiser.Click += pictureBoxCruiser_Click; + // + // buttonCreateCruiser + // + buttonCreateCruiser.Anchor = AnchorStyles.Bottom | AnchorStyles.Left; + buttonCreateCruiser.Location = new Point(0, 501); + buttonCreateCruiser.Name = "buttonCreateCruiser"; + buttonCreateCruiser.Size = new Size(112, 34); + buttonCreateCruiser.TabIndex = 1; + buttonCreateCruiser.Text = "Создать"; + buttonCreateCruiser.UseVisualStyleBackColor = true; + buttonCreateCruiser.Click += buttonCreateCruiser_Click; + // + // buttonLeft + // + buttonLeft.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonLeft.BackgroundImage = (Image)resources.GetObject("buttonLeft.BackgroundImage"); + buttonLeft.BackgroundImageLayout = ImageLayout.Stretch; + buttonLeft.Location = new Point(780, 493); + buttonLeft.Name = "buttonLeft"; + buttonLeft.Size = new Size(30, 30); + buttonLeft.TabIndex = 2; + buttonLeft.UseVisualStyleBackColor = true; + buttonLeft.Click += buttonMove_Click; + // + // buttonRight + // + buttonRight.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonRight.BackgroundImage = (Image)resources.GetObject("buttonRight.BackgroundImage"); + buttonRight.BackgroundImageLayout = ImageLayout.Stretch; + buttonRight.Location = new Point(852, 493); + buttonRight.Name = "buttonRight"; + buttonRight.Size = new Size(30, 30); + buttonRight.TabIndex = 3; + buttonRight.UseVisualStyleBackColor = true; + buttonRight.Click += buttonMove_Click; + // + // buttonUp + // + buttonUp.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonUp.BackgroundImage = (Image)resources.GetObject("buttonUp.BackgroundImage"); + buttonUp.BackgroundImageLayout = ImageLayout.Stretch; + buttonUp.Location = new Point(816, 457); + buttonUp.Name = "buttonUp"; + buttonUp.Size = new Size(30, 30); + buttonUp.TabIndex = 4; + buttonUp.UseVisualStyleBackColor = true; + buttonUp.Click += buttonMove_Click; + // + // buttonDown + // + buttonDown.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonDown.BackgroundImage = (Image)resources.GetObject("buttonDown.BackgroundImage"); + buttonDown.BackgroundImageLayout = ImageLayout.Stretch; + buttonDown.Location = new Point(816, 493); + buttonDown.Name = "buttonDown"; + buttonDown.Size = new Size(30, 30); + buttonDown.TabIndex = 5; + buttonDown.UseVisualStyleBackColor = true; + buttonDown.Click += buttonMove_Click; + // + // FormCruiser + // + AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(912, 535); + Controls.Add(buttonDown); + Controls.Add(buttonUp); + Controls.Add(buttonRight); + Controls.Add(buttonLeft); + Controls.Add(buttonCreateCruiser); + Controls.Add(pictureBoxCruiser); + Name = "FormCruiser"; + Text = "Крейсер"; + Load += FormCruiser_Load; + ((System.ComponentModel.ISupportInitialize)pictureBoxCruiser).EndInit(); + ResumeLayout(false); + } + + #endregion + + private PictureBox pictureBoxCruiser; + private Button buttonCreateCruiser; + private Button buttonLeft; + private Button buttonRight; + private Button buttonUp; + private Button buttonDown; + } +} \ No newline at end of file diff --git a/ProjectOOP/ProjectOOP/FormCruiser.cs b/ProjectOOP/ProjectOOP/FormCruiser.cs new file mode 100644 index 0000000..94fb3d4 --- /dev/null +++ b/ProjectOOP/ProjectOOP/FormCruiser.cs @@ -0,0 +1,88 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace ProjectOOP +{ + public partial class FormCruiser : Form + { + private DrawningCruiser? _drawningCruiser; + public FormCruiser() + { + InitializeComponent(); + } + + private void FormCruiser_Load(object sender, EventArgs e) + { + + } + + private void pictureBoxCruiser_Click(object sender, EventArgs e) + { + + } + + private void Draw() + { + if (_drawningCruiser == null) + { + return; + } + Bitmap bmp = new(pictureBoxCruiser.Width, pictureBoxCruiser.Height); + Graphics gr = Graphics.FromImage(bmp); + _drawningCruiser.DrawTransport(gr); + pictureBoxCruiser.Image = bmp; + } + + private void buttonCreateCruiser_Click(object sender, EventArgs e) + { + Random random = new(); + _drawningCruiser = new DrawningCruiser(); + _drawningCruiser.Init(random.Next(100, 300), random.Next(1000, 3000), + Color.FromArgb(random.Next(0, 256), random.Next(0, 256), random.Next(0, 256)), + Color.FromArgb(random.Next(0, 256), random.Next(0, 256), random.Next(0, 256)), + Convert.ToBoolean(random.Next(0, 2)), Convert.ToBoolean(random.Next(0, 2)), Convert.ToBoolean(random.Next(0, 2))); + _drawningCruiser.SetPictureSize(pictureBoxCruiser.Width, pictureBoxCruiser.Height); + _drawningCruiser.SetPosition(random.Next(10, 100), random.Next(10, 100)); + Bitmap bmp = new(pictureBoxCruiser.Width, pictureBoxCruiser.Height); + Graphics gr = Graphics.FromImage(bmp); + _drawningCruiser.DrawTransport(gr); + pictureBoxCruiser.Image = bmp; + Draw(); + } + private void buttonMove_Click(object sender, EventArgs e) + { + if (_drawningCruiser == null) + { + return; + } + string name = ((Button)sender)?.Name ?? string.Empty; + bool result = false; + switch (name) + { + case "buttonUp": + result = _drawningCruiser.MoveTransport(DirectionType.Up); + break; + case "buttonDown": + result = _drawningCruiser.MoveTransport(DirectionType.Down); + break; + case "buttonLeft": + result = _drawningCruiser.MoveTransport(DirectionType.Left); + break; + case "buttonRight": + result = _drawningCruiser.MoveTransport(DirectionType.Right); + break; + } + if (result) + { + Draw(); + } + } + } +} diff --git a/ProjectOOP/ProjectOOP/FormCruiser.resx b/ProjectOOP/ProjectOOP/FormCruiser.resx new file mode 100644 index 0000000..75aa749 --- /dev/null +++ b/ProjectOOP/ProjectOOP/FormCruiser.resx @@ -0,0 +1,814 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + dgAADnYBFNpwXwAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAACN6SURBVHhe7d17 + uKV3WR5+5pQDQ87EEAyNwSBoKAgKCgoKCgoKraBYhVqwgj+hFmsVf2I90Iq1ghfSilVsxRZoAcUWqGDR + ggULBQoChYKcTBoDMQdDCAk52/u9srLyneSZmX1Y37Xe9a7PfV2fP7iZ2XuttR+eZzOz9+w7/fVf/zUA + sGHKEgCYtrIEAKatLAGAaStLAGDayhIAmLayBACmrSwBgGkrS2CaknvEV1f/HbBZyhKYnuTs+FRcEQ+s + fg2wOcoSmJbknnFBDP9hcHncv/q1wGYoS2A6knvFhXHr8b/VpXFe9XuA6StLYBqS+8Snoz38rYvjPtXv + BaatLIH1l9x3duDbg18ZPkG4V/U2gOkqS2C9JfeP4Y/420N/JMNfEdyzelvANJUlsL6SB8bwRX7tgd+K + 8+Ps6m0C01OWwHpKHhzDt/m1h307hm8TPKt628C0lCWwfpKHxpXRHvSd+HjcvXofwHSUJbBekofHVdEe + 8t34aJxRvS9gGsoSWB/JI+PqaA/4InwoTq/eJ7D+yhJYD8mj45poD/cifSBOq943sN7KEhi/5LFxbbQH + u4f3xcnVYwDWV1kC45Y8Pq6L9lD39O44sXoswHoqS2C8kifG9dEe6GV4R5xQPSZg/ZQlME7J34kboj3M + y/S2OFg9NmC9lCUwPslT4sZoD/IqvCWOrx4jsD7KEhiX5GlxU7SHeJXeHMdVjxVYD2UJjEfyjLg52gM8 + Bm+MY6rHDIxfWQLjkDwrxnj8b/X6OFA9dmDcyhJYveQfzY7s2L029lfPARivsgRWK3nO7Liui1fHvuq5 + AONUlsDqJP9kdlTXzStib/WcgPEpS2A1kufNjum6elnsqZ4bMC5lCSxf8s9nR3TdvTR8EgAjV5bAciUv + nB3PqXhJ9TyB8ShLYHmSFzeHc0p+pXq+wDiUJdBfsif+9exYTtULqucOrF5ZAn0le+PfzI7k1D2/eg2A + 1SpLoJ9kOP7/bnYcN8XPVa8FsDplCfSR7ItXzo7ipnlu9ZoAq1GWwOIl++M1s2O4qX6sem2A5StLYLGS + A/GfZkdw0z27eo2A5SpLYHGSY+MNs+PHLZ5ZvVbA8pQlsBjJcfGm2dHjNsOPOH569ZoBy1GWwO4ld44/ + ivbwcZvhk4CnVq8d0F9ZAruTHIw/jvbgcUc3xZOr1xDoqyyBnUtOiD+J9tBxeDfGk6rXEuinLIGdSU6K + d0Z74Di6G+IJ1WsK9FGWwPYlp8R7oj1sbN318bjqtQUWryyB7UlOiz+N9qCxfdfFY6rXGFissgS2Lvmi + +GC0h4yd+0I8qnqtgcUpS2BrkrvFh6M9YOzeNfGI6jUHFqMsgaNLvjj+LNrDxeJ8Ph5WvfbA7pUlcGTJ + PeIT0R4sFu9z8ZDqYwDsTlkCh5d8Sfx5tIeKfq6MB1UfC2DnyhKoJV8aF0R7oOjvinhA9TEBdqYsgTtK + viz+ItrDxPJcFverPjbA9pUlcKjky+Mz0R4klu+SOK/6GAHbU5bAbZL7xl9Ge4hYnYvj3tXHCti6sgRu + kXxlXBrtAWL1Lopzq48ZsDVlCQw35k5fFZdHe3gYjwvjnOpjBxxdWcKmS74mPhvtwWF8zo+zq48hcGRl + CZss+boYvve8PTSM1yfjrOpjCRxeWcKmSr4hror2wDB+H4szq48pUCtL2ETJN8XV0R4W1sdH4ozqYwvc + UVnCpkm+JYYfQ9seFNbPh+Ku1ccYOFRZwiZJvi2ujfaQsL7eH6dWH2vgNmUJmyL523FdtAeE9ffeOLn6 + mAO3KEvYBMl3xvXRHg6m411xYvWxB/I/kaqEqUu+J26M9mAwPe+Iu1QzAJuuLGHKku8Lx39zvC0OVrMA + m6wsYaqS74+boj0QTN9b4vhqJmBTlSVMUfKDcXO0h4HN8eY4tpoN2ERlCVOT/PDsCLDZfj+OqWYENk1Z + wpQkPzpb/jB4XRyoZgU2SVnCVCQ/MVv60Prd2F/NDGyKsoQpSH56tuyh8qrYV80ObIKyhHWX/NPZkocj + eXnsrWYIpq4sYZ0lvzhb7rAVvxV7qlmCKStLWFfJL8+WOmzHb4RPAtgoZQnrZlje8a+iXeqwHb9azRZM + VVnCOkmG4//rsyUOu/GiasZgisoS1kWyN/7tbHnDIvxSNWswNWUJ6yDZF/9+trRhkX6+mjmYkrKEsUv2 + x3+cLWvo4Weq2YOpKEsYs+RA/M5sSUNPP1TNIExBWcJYJcfEf54tZ+jpo3H3ag5hCsoSxig5Nv5LtEsa + evhw3K2aQ5iKsoSxSY6PP4h2SUMPH4zTqzmEKSlLGJPkzvHfol3S0MP74rRqDmFqyhLGIrlL/PdolzT0 + 8J44pZpDmKKyhDFITow/iXZJQw/vjJOqOYSpKktYteTk+J/RLmno4e1xQjWHMGVlCauUnBr/K9olDT28 + NQ5WcwhTV5awKsld40+jXdLQwx/Gnas5hE1QlrAKyRfF/452SUMPb4rjqjmETVGWsGzJmfF/ol3S0MMb + 4thqDmGTlCUsU/LF8WfRLmno4ffiQDWHsGnKEpYl+RvxiWiXNPTwmthfzSFsorKEZUjOiT+PdklDD6+M + fdUcwqYqS+gtOTf+b7RLGnr47dhbzSFssrKEnpJ7x0XRLmno4TfD8YdCWUIvyVfEZ6Jd0tDDr8Weag6B + /E+kKqGH5G/GJdEuaejhxdUMArcpS1i05AFx2Ww5Q08vrGYQOFRZwiIlXx1/NVvO0NMvVDMI3FFZwqIk + XxufnS1n6Ol51QwCtbKERUi+Pj43W87Q009VMwgcXlnCbiXfGJ+fLWfo6TnVDAJHVpawG8k3x9Wz5Qw9 + /Ug1g8DRlSXsVPKt8YXZcoZebo5nVTMIbE1Zwk4k3x7XRruoYdGG4/+MagaBrStL2K7kO+L6aBc1LNpN + 8bRqBoHtKUvYjuS74oZoFzUs2o3xlGoGge0rS9iq5Htni7ld1LBowyeY313NILAzZQlbkfy9GP5Itl3U + sGjDXy09sZpBYOfKEo4m+YFw/Ontunh8NYPA7pQlHEnyQzF8JXa7qGHRhu8oeWw1g8DulSUcTvIPZ8sZ + eromHl3NILAYZQmV5B/PljP0NPwrko+sZhBYnLKE20t+cracoaer4uHVDAKLVZbQSn5mtpyhpyvjodUM + AotXlnCr5Odnyxl6uiIeXM0g0EdZwiD5F7PlDD1dHg+sZhDopywhedFsOUNPl8b9qxkE+ipLNleyJ341 + 2iUNPVwc51VzCPRXlmymZDj+vxHtkoYePh33qeYQWI6yZPMke+O3ol3S0MOFca9qDoHlKUs2S7IvXh7t + koYeLoh7VnMILFdZsjmS/fGqaJc09PCpOLuaQ2D5ypLNkByI3412SUMPH4+zqjkEVqMsmb7kmHhdtEsa + evho3L2aQ2B1ypJpS46N3492SUMPH4ozqjkEVqssma7k+Piv0S5p6OEDcXo1h8DqlSXTlByMt0S7pKGH + 98Vp1RwC41CWTE9yl3hbtEsaenh3nFLNITAeZcm0JCfG/4h2SUMP74iTqjkExqUsmY7k5HhXtEsaenh7 + nFDNITA+Zck0JKfGe6Nd0tDDW+NgNYfAOJUl6y+5a7w/2iUNPbw5jq/mEBivsmS9JWfE8P3X7ZKGHt4Y + x1VzCIxbWbK+kjPjI9Euaejh9XFMNYfA+JUl6yk5Kz4W7ZKGHl4bB6o5BNZDWbJ+krPjk9Euaejh1bG/ + mkNgfZQl6yU5J86PdklDD6+IfdUcAuulLFkfyblxYbRLGnp4Weyt5hBYP2XJekjuHRdFu6Shh5fGnmoO + gfVUloxfcl5cHO2Shh5eEo4/TExZMm7J/eKSaJc09PAr1QwC668sGa/kAXHZbDlDTy+oZhCYhrJknJIH + xRWz5Qw9Pb+aQWA6ypLxSR4SV86WM/T0c9UMAtNSloxL8rD43Gw5Q0/PrWYQmJ6yZDySR8TnZ8sZevrx + agaBaSpLxiF5VFwzW87Q07OrGQSmqyxZveQx8YXZcoZebo5nVjMITFtZslrJ4+K6aBc1LNpw/J9ezSAw + fWXJ6iRPiOujXdSwaDfFU6sZBDZDWbIayZPihmgXNSzajfHkagaBzVGWLN+wkGeLuV3UsGjDJ5hPqmYQ + 2CxlyXIlT43hj2TbRQ2LNvzV0hOqGQQ2T1myPMnTY/hirHZRw6INX1T6uGoGgc1UlixH8sxw/Olt+HbS + x1QzCGyusqS/5Nmz5Qw9Df+Q1KOqGQQ2W1nSV/Ljs+UMPQ3/hPQjqhkEKEv6SZ47W87Q0/DDox5WzSDA + oCzpI/m52XKGnoYfG/2QagYBblWWLF7y/Nlyhp6uiAdVMwjQKksWK3nBbDlDT5fFA6sZBLi9smRxkl+Z + LWfo6ZK4XzWDAJWyZPeSPfGSaJc09HBxnFfNIcDhlCW7kwzH/6XRLmno4aK4TzWHAEdSluxcsjdeFu2S + hh4ujHOrOQQ4mrJkZ5J98YpolzT0cH6cU80hwFaUJduX7I9XR7ukoYdPxtnVHAJsVVmyPcmBeG20Sxp6 + +FicVc0hwHaUJVuXHBOvj3ZJQw8fiTOrOQTYrrJka5Lj4o3RLmno4UNxRjWHADtRlhxdcny8OdolDT28 + P+5azSHATpUlR5YcjLdGu6Shh/fGqdUcAuxGWXJ4yQnxtmiXNPTwrji5mkOA3SpLaslJ8Y5olzT0MMzZ + idUcAixCWXJHySnx7miXNPQw/AnTXao5BFiUsuRQyWnxvmiXNPTwljhYzSHAIpUlt0lOjw9Eu6Shh+G7 + So6v5hBg0cqSWyRnxPD91+2Shh5+P46r5hCgh7Jk2Md3unt8NNolDT28Lo6p5hCgl7LcdMlZ8fFolzT0 + MPwMiQPVHAL0VJabLDk7PhXtkoYeXhX7qzkE6K0sN1Vyz7gg2iUNPbw89lVzCLAMZbmJknvFhdEuaejh + t2JvNYcAy1KWmya5T3w62iUNPfxG7KnmEGCZynKTJOfFxdEuaehl+Cum8wFWrjqKmyK5f1wat1/SADBt + 1WHcBMkD4/L5CwEAm6Q6jlOXPDiumL8IALBpqgM5ZclD48r5CwAAm6g6klOVPDyumj95ANhU1aGcouSR + cfX8iQPAJquO5dQkj45r5k8aADZddTCnJHlsXDt/wgBAfTSnInl8XDd/sgDALarDOQXJE+P6+RMFAG5T + Hc91l3x33DB/kgDAoaoDus6Sp8SN8ycIANxRdUTXVfK0uGn+5ACAWnVI11HyjLh5/sQAgMOrjum6SZ4V + jj8AbFV1UNdJ8iOHPCEA4Oiqo7oukucc8mQAgK2pDus6SH7qkCcCAGxddVzHLnneIU8CANie6sCOWfIL + hzwBAGD7qiM7VskLD3nwAMDOVId2jJIXH/LAAYCdq47tmCR74tfmDxgA2L3q6I5Fsjd+c/5gAYDFqA7v + GCTD8f/t+QMFABanOr6rluyLV84fJACwWNUBXqVkf7xm/gABgMWrjvCqJAfi9+YPDgDoozrEq5AcG2+Y + PzAAoJ/qGC9bcly8af6gAIC+qoO8TMmd4w/nDwgA6K86ysuSHIy3zh8MALAc1WFehuSEePv8gQAAy1Md + 596Sk+Kd8wcBACxXdaB7Sk6J98wfAACwfNWR7iU5Ld43f+cAwGpUh7qH5PT44PwdAwCrUx3rRUvuFh+e + v1MAYLWqg71Iyd3jo/N3CACsXnW0FyW5R3x8/s4AgHGoDvciJF8Sn5q/IwBgPKrjvVvJl8YF83cCAIxL + dcB3I/my+Iv5OwAAxqc64juVfHl8ev7GAYBxqg75TiT3jb+cv2EAYLyqY75dyVfGpfM3CgCMW3XQtyP5 + qrh8/gYBgPGrjvpWJV8TV8zfGACwHqrDvhXJ18WV8zcEAKyP6rgfTfINcdX8jQAA66U68EeSfFNcPX8D + AMD6qY784STfEtfMfzMAsJ6qQ19Jvi2unf9GAGB9Vcf+9pK/FdfNfxMAsN6qg99KvjOun/8GAGD9VUf/ + Vsn3xA3zXwwATEN1+AfJ340b578QAJiOwxz/74+b5r8IAJiW4vj/YNw8/wUAwPTc7vj/g3D8AWDqmuP/ + o4f8FwDAdM2O/08cUgIAU3enn75dAQBMn08AAGDj+CsAANhAvggQADbQrZ8AzD4JGL4N8I6/CACYlvYT + gNknAf4hIACYutt/AjD7JMA/BQwAU1Z9AjBI/DAgAJiq6vjfKhl+HLBPAgBgaqrD30q+M66f/wYAYP1V + R//2kr8V181/EwCw3qqDX0m+La6d/0YAYH1Vx/5wkm+JL8x/MwCwnqpDfyTJN8XV8zcAAKyf6sgfTfIN + cdX8jQAA66U68FuRfF1cOX9DAMD6qI77ViVfE5+dvzEAYD1Uh307kq+Ky+dvEAAYv+qob1fylXHp/I0C + AONWHfSdSO4bfzl/wwDAeFXHfKeSL4/PzN84ADBO1SHfjeTL4i/m7wAAGJ/qiO9W8qVxwfydAADjUh3w + RUi+JD41f0cAwHhUx3tRknvEJ+bvDAAYh+pwL1Jy9/jo/B0CAKtXHe1FS+4WH56/UwBgtaqD3UNyenxw + /o4BgNWpjnUvyWnxvvk7BwBWozrUPSWnxHvmDwAAWL7qSPeWnBTvnD8IAGC5qgO9DMkJ8fb5AwEAlqc6 + zsuSHIy3zh8MALAc1WFepuTO8YfzBwQA9Fcd5WVLjos3zR8UANBXdZBXITk23jB/YABAP9UxXpXkQPze + /MEBAH1Uh3iVkv3xmvkDBAAWrzrCq5bsi1fOHyQAsFjVAR6DZG/89vyBAgCLUx3fsUiGTwJ+c/5gAYDF + qA7vmCR74tfmDxgA2L3q6I5R8uJDHjgAsHPVsR2r5IWHPHgAYGeqQztmyS8c8gQAgO2rjuzYJc875EkA + ANtTHdh1kPzUIU8EANi66riui+Q5hzwZAGBrqsO6TpIfOeQJQT/XxsUAk1Ad1XWTPCtujtsvbFika+JR + 1QwCrJuyXEfJM8InAfT2hXhMNYMA66Qs11XytLgp2oUNi3ZdPK6aQYB1UZbrLHlK3BjtwoZFuz6eUM0g + wDooy3WXfHfcEO3ChkUbZuxJ1QwCjF1ZTkHyxBj+X1q7sGHRhj9tenI1gwBjVpZTkTw+hr+vbRc2LNrw + dSdPrWYQYKzKckqSx8bw/dvtwoZFG74D5enVDAKMUVlOTfLoGL6Hu13YsGjDJwHPrGYQYGzKcoqSR8bV + 0S5s6OHZ1QwCjElZTlXy8LhqtqShpx+rZhBgLMpyypKHxpWzJQ09PbeaQYAxKMupSx4cV8yWNPT0s9UM + AqxaWW6C5IFx+WxJQ0/Pr2YQYJXKclMk949LZ0saevqlagYBVqUsN0lyXgw/G7ld1tDDi6oZBFiFstw0 + yX3i07MlDT29JPZUcwiwTGW5iZJ7xYXRLmvo4aXhkwBgpcpyUyX3jAuiXdbQw8tibzWHAMtQlpssOTs+ + Fe2yhh5eEfuqOQTorSw3XXJWfDzaZQ09vCr2V3MI0FNZMuzlO909PhrtsoYeXhsHqjkE6KUsuUVyRnwo + 2mUNPbwujqnmEKCHsuQ2yenxgWiXNfTwxjiumkOARStLDpWcFu+LdllDD2+O46s5BFiksuSOklPi3dEu + a+jhLXGwmkOARSlLaslJ8Y5olzX08La4SzWHAItQlhxecsJsObfLGnoYPtk8sZpDgN0qS44sORhvjXZZ + Qw/vipOrOQTYjbLk6JLjY/iCrXZZQw/vjVOrOQTYqbJka5LjYvjWrXZZQw/vj9OrOQTYibJk65Jj4vXR + LmvoYfhHqc6o5hBgu8qS7UkOxPDPubbLGnr4SJxZzSHAdpQl25fsj1dHu6yhh4/FWdUcAmxVWbIzyb4Y + fsRru6yhh0/G2dUcAmxFWbJzyd54WbTLGno4P86p5hDgaMqS3Un2xEujXdbQw4VxbjWHAEdSluxeMnwS + 8JJolzX0cFHcu5pDgMMpSxYn+ZXZkoaeLo7zqhkEqJQli5W8YLakoadL4n7VDALcXlmyeMnzZ0saeros + HlDNIECrLOkj+bnZkoaerogHVTMIcKuypJ/kubMlDT1dGQ+pZhBgUJb0lfz4bElDT5+Lh1UzCFCW9Jc8 + e7akoafPxyOqGQQ2W1myHMkz4+ZoFzYs2jXxqGoGgc1VlixP8vTwSQC9fSEeU80gsJnKkuVKnho3Rbuw + YdGui8dVMwhsnrJk+ZInx43RLmxYtOvjCdUMApulLFmN5ElxQ7QLGxZtmLEnVTMIbI6yZHWSJ8Tw/9La + hQ2LNvxp05OrGQQ2Q1myWsnjYvj72nZhw6INX3fy1GoGgekrS1YveUwMX7ndLmxYtOE7UJ5ezSAwbWXJ + OCSPiuF7uNuFDYs2fBLwzGoGgekqS8YjeUQM/5pbu7Chh2dXMwhMU1kyLsnDYvh33dtlDT38WDWDwPSU + JeOTPCSGn/DWLmvo4bnVDALTUpaMU/KgGH7We7usoYefrWYQmI6yZLySB8RlsyUNPT2/mkFgGsqScUvu + F5fMljT09EvVDALrrywZv+S8uHi2pKGnF1UzCKy3smQ9JPeOi2ZLGnp6Seyp5hBYT2XJ+kjOjQujXdbQ + w0vDJwEwEWXJeknOifOjXdbQw8tibzWHwHopS9ZPcnZ8MtplDT28PPZVcwisj7JkPSVnxceiXdbQw6ti + fzWHwHooS9ZXcmZ8JNplDT28Ng5UcwiMX1my3pIz4kPRLmvo4XVxTDWHwLiVJesvuWu8P9plDT28MY6r + 5hAYr7JkGpJT473RLmvo4c1xfDWHwDiVJdORnBzvinZZQw9viYPVHALjU5ZMS3Ji/I9olzX08La4SzWH + wLiUJdMzLOXZcm6XNfTwjjixmkNgPMqSaUoOxvDHtO2yhh6Gv3Y6uZpDYBzKkulKjo//Gu2yhh6GL0A9 + tZpDYPXKkmlLjo3fj3ZZQw/Dt6LetZpDYLXKkulLjonhH3FplzX0MPyjVGdUcwisTlmyGZID8bvRLmvo + Yfjnqc+s5hBYjbJkcyT7Y/jBLu2yhh6GH1R1VjWHwPKVJZsl2RfDj3htlzX0MPzI6rOrOQSWqyzZPMne + +K1olzX0cH6cU80hsDxlyWZK9sRvRLusoYcL49xqDoHlKEs2VzJ8EvCr0S5r6OGiuHc1h0B/ZQnJi2ZL + Gnq6OM6rZhDoqyxhkPyL2ZKGni6J+1UzCPRTlnCr5OdnSxp6uiweUM0g0EdZQiv5mdmShp7+Kh5UzSCw + eGUJt5f85GxJQ0+fjYdUMwgsVllCJfnHsyUNPX0uHlbNILA4ZQmHk/zD2ZKGnj4f31jNILAYZQlHkvxQ + 3BztwoZFuyYeVc0gsHtlCUeT/EDcFO3ChkX7QjymmkFgd8oStiL5e+GTAHq7Lh5XzSCwc2UJW5V8b9wY + 7cKGRbs+vqOaQWBnyhK2I/muuCHahQ2LNszYk6oZBLavLGG7ku+I4f+ltQsbFm3406YnVzMIbE9Zwk4k + 3x7XRruwYdGGrzt5ajWDwNaVJexU8q0xfOV2u7Bh0YZvQ/2BagaBrSlL2I3km+PqaBc2LNrwScAzqxkE + jq4sYbeSb4zhX3NrFzb08OxqBoEjK0tYhOTrY/h33dtlDT38WDWDwOGVJSxK8rUx/IS3dllDDz9ZzSBQ + K0tYpOSrY/hZ7+2yhh5+tppB4I7KEhYteUBcNlvS0NPzqxkEDlWW0EPyN+OS2ZKGnn6pmkHgNmUJvSRf + EZ+ZLWno6UXVDAK3KEvoKbl3XDRb0tDTS2JPNYew6coSekvOjf8b7bKGHl4aPgmA2ylLWIbknPjzaJc1 + 9PCy2FvNIWyqsoRlSf5GfCLaZQ09vDz2VXMIm6gsYZmSL44/i3ZZQw+viv3VHMKmKUtYtuTM+D/RLmvo + 4bVxoJpD2CRlCauQfFH872iXNfTwujimmkPYFGUJq5LcNf402mUNPbwxjqvmEDZBWcIqJafG/4p2WUMP + b47jqzmEqStLWLXk5Pif0S5r6OEtcbCaQ5iysoQxSE6MP4l2WUMPb4u7VHMIU1WWMBbDUo7/Hu2yhh7e + ESdWcwhTVJYwJsmd479Fu6yhh3fFydUcwtSUJYxNcnz8QbTLGnp4b5xazSFMSVnCGCXHxn+JdllDD++P + u1ZzCFNRljBWyTHxn6Nd1tDDh+KMag5hCsoSxiw5EL8T7bKGHv5BNYMwBWUJY5fsj/84W9LQwy9UswdT + UZawDpJ98e9nyxoW6QXVzMGUlCWsi2Rv/NvZ0oZFeHE1azA1ZQnrJNkTvz5b3rAbv1bNGExRWcK6SYZP + Av7VbInDTvxm7KnmC6aoLGFdJb88W+awHb8djj8bpSxhnSW/OFvqsBWviL3VLMGUlSWsu+SfzpY7HMmr + Y181QzB1ZQlTkPz0bMlD5fdifzU7sAnKEqYi+YnZsofW6+NANTOwKcoSpiT50dnSh8Eb45hqVmCTlCVM + TfLDs+XPZntzHFfNCGyasoQpSn4wbo72ILA53hLHV7MBm6gsYaqS74+boj0MTN/b4mA1E7CpyhKmLPm+ + uDHaA8F0vSNOqGYBNllZwtQl3xM+CZi+d8eJ1QzApitL2ATJd8b10R4MpuO9cXL1sQfyP5GqhE2R/O24 + LtrDwfr7QJxafcyBW5QlbJLk2+LaaA8I6+tDcXr1sQZuU5awaZJviS9Ee0hYPx+JM6qPMXCosoRNlHxT + XB3tQWF9fCzOrD62wB2VJWyq5BviqmgPC+P3yTir+pgCtbKETZZ8XVwZ7YFhvM6Ps6uPJXB4ZQmbLvma + +Gy0h4bxuTDOqT6GwJGVJTDcljt9VVwe7cFhPC6Kc6uPHXB0ZQncIvnKuDTaw8PqXRz3rj5mwNaUJXCb + 5L7xl9EeIFbnkviK6mMFbF1ZAodKvjw+E+0hYvkui/tVHyNge8oSuKPky+Ivoj1ILM9fxQOqjw2wfWUJ + 1JIvjQuiPUz0N3xHxoOqjwmwM2UJHF7yJfHn0R4o+vlcfG31sQB2riyBI0vuEZ+I9lCxeJ+Pr68+BsDu + lCVwdMkXx59Fe7BYnOHnMnxj9doDu1eWwNYkd4sPR3u42L3hJzN+c/WaA4tRlsDWJV8UH4z2gLFz18a3 + Vq81sDhlCWxPclr8abSHjO27Pr69eo2BxSpLYPuSU+I90R40tu6G+I7qtQUWryyBnUlOindGe9g4uhvj + u6rXFOijLIGdS06IP4n2wHF4N8X3Vq8l0E9ZAruTHIw/jvbQcUfD8f++6jUE+ipLYPeSO8cfRXvwuM3N + 8fer1w7oryyBxUiOizdFe/i4xf9XvWbAcpQlsDjJsfGG2dHjFj9cvVbA8pQlsFjJgfhPs+O36X60eo2A + 5SpLYPGS/fGa2RHcVP9/9doAy1eWQB/Jvnjl7Bhump+uXhNgNcoS6CfZG/9udhQ3xT+rXgtgdcoS6CsZ + Pgn4N7PjOHW/WL0GwGqVJdBfsif+9exITtUvV88dWL2yBJYneXFzMKfkX1bPFxiHsgSWK3lhczin4Ner + 5wmMR1kCy5f88+aArrPhaxv2VM8RGI+yBFYjed7siK6r4bsb9lbPDRiXsgRWJ/kns2O6bv5DOP6wJsoS + WK3kObOjui5+J/ZVzwUYp7IEVi/5R7PjOnbDzzjYXz0HYLzKEhiH5Fkx/Nz89uCOyfBTDo+pHjswbmUJ + jEfyjBjjJwF/EMdWjxkYv7IExiV5WtwU7QFepT+K46rHCqyHsgTGJ3lK3BjtIV6FP447V48RWB9lCYxT + 8nfihmgP8jK9PQ5Wjw1YL2UJjFfyxLg+2sO8DO+ME6rHBKyfsgTGLXl8XBftge7pPXFS9ViA9VSWwPgl + j41roz3UPbwvTqkeA7C+yhJYD8mj45poD/YifTBOq943sN7KElgfySPj6mgP9yJ8OE6v3iew/soSWC/J + w+OqaA/4bnw07la9L2AayhJYP8lD48poD/lOfDzuXr0PYDrKElhPyYPjimgP+nZ8Ku5RvW1gWsoSWF/J + A+PyaA/7VlwQZ1dvE5iesgTWW3L/uDTaA38kF8Y9q7cFTFNZAusvuW9cHO2hr3w67lW9DWC6yhKYhuQ+ + swPfHvzW8AnCfarfC0xbWQLTkdwrhj/ibw//YPgrgvOq3wNMX1kC05LcM4Yv8rv1+A9fJHj/6tcCm6Es + gelJzo7h2/yGbxN8YPVrgM1RlsA0JfeIr67+O2CzlCUAMG1lCQBMW1kCANNWlgDAtJUlADBtZQkATFtZ + AgDTVpYAwJT99Z3+H5Sw8Sdg6GykAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + dgAADnYBFNpwXwAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAACN5SURBVHhe7d17 + mF1lffZx5pQDISEkxACGRhAEDQVBQUFBQUFBoRUUq/Ba8BWsUIu1ihXrgVasFbyQt2IVW7EF3gKKLVDB + ogULFgoUBAoFOQmNQORgCJCQs72fK4vmycqdyZ4969l7rWd97+v6/NFbM7MPv/5+Y5LJbPLrX/8aAAC0 + jC0BAEDebAkAAPJmSwAAkDdbAgCAvNkSAADkzZYAACBvtgQAAHmzJYB2UV4t27r/DECebAmgPZQ9ZKE8 + KHPdfwdAfmwJoB2U3eQpCf9H8LBs7/67APJiSwD5U+bJE/LC8X/BfNnR/RoA+bAlgLwpO8sCiQ9/7FHZ + 2f1aAHmwJYB8KTsWBz4++E74AmEX9zEANJ8tAeRJ2V7Cb/HHh3404Y8IdnMfC0Cz2RJAfpS5Ev6SX3zg + OxH+kuAe7mMCaC5bAsiLsq2Eb/OLD/tYhG8T3Mt9bADNZEsA+VC2kfskPujdWCT7uM8BoHlsCSAPylZy + j8SHfDyelf3c5wLQLLYE0HzKLLlL4gNehcVygPucAJrDlgCaTZkpd0h8uKu0RA5ynxtAM9gSQHMpW8it + Eh/sFJbKIe4xAKg/WwJoJmVzuVniQ53SMjnMPRYA9WZLAM2jTJUbJD7QvbBcjnCPCUB92RJAsyhT5DqJ + D3MvrZDfcY8NQD3ZEkBzKJvKjyU+yP2wUo52jxFA/dgSQDMok+RHEh/iflolx7rHCqBebAmg/pSJ8gOJ + D3AdrJbj3WMGUB+2BFBvygS5XOLDWyfhi4AT3WMHUA+2BFBfyrD8g8QHt67+0D0HAP1nSwD1pAzJd4rj + 2hQnu+cCoL9sCaB+lEH5/8VRbZo/cc8JQP/YEkC9KOH4/21xTJvqVPfcAPSHLQHUhzIgf10c0ab7c/cc + AfSeLQHUh/L16IDm4Az3PAH0li0B1IPy/6LDmZOz3PMF0Du2BNB/ypejg5mjv5IB99wBpGdLAP2lfLE4 + krkLf7dh0L0GANKyJYD+Uf6sOI5tEb67gS8CgB6zJYD+UD5dHMW2uUCG3GsCIA1bAug95Y+LY9hWF8uw + e20AVM+WAHpL+WhxBNsu/IyDEfcaAaiWLQH0jvLh4vhhjfBTDie61wpAdWwJoDeU3yuOHtZ1pUxyrxmA + atgSQHrK/5Xwc/Pjw4e1fiSbutcOwPjZEkBayvtklcQHD+v7sUxxryGA8bElgHSU9wrHv3M/kanutQTQ + PVsCSEN5l6yU+MBh426Qzd1rCqA7tgRQPeUdskLiw4bO3SxbuNcWwNjZEkC1lLfLcokPGsbupzLTvcYA + xsaWAKqjvFWWSnzI0L075EXutQbQOVsCqIbyZnle4gOG8btLtnKvOYDO2BLA+ClvlMUSHy5U52fyYvfa + A9g4WwIYH+X18pzEBwvVu1+2de8BgNHZEkD3lNfKMxIfKqTzc3mJey8AbJgtAXRH2VOelvhAIb2H5aXu + PQHg2RLA2Cm7y68kPkzonV/Iy9x7A2B9tgQwNsqu8qTEBwm995i83L1HANZlSwCdU14hj0t8iNA/v5Rd + 3HsFYC1bAuiMspMskPgAof+ekFe69wzAGrYEsHHKDvKIxIcH9fGUvMq9dwD0/yKuBDA6ZTuZL/HBQf2E + 78h4jXsPgbazJYANU+bKQxIfGtTXInmdey+BNrMlAE+ZIw9IfGBQf8/KG9x7CrSVLQGsT9la7pX4sKA5 + ws9leJN7b4E2siWAdSmz5W6JDwqaJ/xkxre49xhoG1sCWEuZJXdKfEjQXEvlbe69BtrElgDWUGbI7RIf + EDTfMvlt954DbWFLAOFGbDJdbpH4cCAfy+Wd7r0H2sCWQNsp0+QmiQ8G8rNS3uNmAMidLYE2U6bK9RIf + CuQrfBHwPjcLQM5sCbSVMkWulfhAIH+r5P1uJoBc2RJoI2WyXC3xYUB7rJYPutkAcmRLoG2USXKVxAcB + 7fRhNyNAbmwJtIkyQa4olj8QfNTNCpATWwJtoYzIZcXSB2KfcDMD5MKWQBsow/K9YtkDzqfd7AA5sCWQ + O2VILiqWPDCaP3UzBDSdLYGcKYNyfrHcgU580c0S0GS2BHKlDMi3i6UOjMWX3UwBTWVLIEdKOP7fLJY5 + 0I2/lAE3X0DT2BLIkfK1YokD4/F14YsANJ4tgdwoZxXLG6jC38igmzWgKWwJ5EQ5vVjaQJX+TobczAFN + YEsgF8oXimUNpPD3MuxmD6g7WwI5UH6/WNJASt+RETeDQJ3ZEsiBMlvulHhZAyn8o0xwcwjUlS2BXChb + ym0SL2sghX+SiW4OgTqyJZATZYbcIvGyBlL4gUx2cwjUjS2B3CjT5UaJlzWQwr/Ipm4OgTqxJZAjZZpc + L/GyBlL4V9nMzSFQF7YEchWWslwr8bIGUviJTHNzCNSBLYGcKVPkaomXNZDCv8t0N4dAv9kSyJ0yWa6S + eFkDKfyHzHBzCPSTLYE2UCbJFRIvayCFn8qWbg6BfrEl0BbKBLlU4mUNpPCf8iI3h0A/2BJoE2VELpF4 + WQMp/Jds7eYQ6DVbAm2jDMuFEi9rIIWfyYvdHAK9ZEugjZQhOU/iZQ2kcL/8hptDoFdsCbSVMijnSrys + gRR+Ltu5OQR6wZZAmykDco7EyxpI4b9lBzeHQGq2BNpOCV8EnC3xsgZSeER2cnMIpGRLAGsoZxZLGkjp + MXmFm0EgFVsCWEv5UrGkgZQel990MwikYEsA61JOK5Y0kNKTsrubQaBqtgSwPuWzxZIGUvqVvNrNIFAl + WwLwlE8WSxpI6Wl5rZtBoCq2BLBhyseKJQ2k9Iy83s0gUAVbAhidclKxpIGUnpM3uhkExsuWADZOOUFW + S7ywgaotlje7GQTGw5YAOqN8QPgiAKk9L291Mwh0y5YAOqccI6skXthA1ZbK290MAt2wJYCxUY6SlRIv + bKBqy+UdbgaBsbIlgLFTjpQVEi9soGphxt7lZhAYC1sC6I7yDgn/Ky1e2EDVwu82vdfNINApWwLonnKo + LJN4YQNVC3/v5HfdDAKdsCWA8VEOlvA3t+OFDVQtfBHwATeDwMbYEsD4KQfKEokXNlC18G2oH3IzCIzG + lgCqobxRwr/mFi9sIIU/cDMIbIgtAVRH2VfCv+seL2sghT9yMwg4tgRQLWVvCT/hLV7WQAqfdDMIlNkS + QPWUPSX8rPd4WQMpfMbNIBCzJYA0lN3lyWJJAyl93s0g8AJbAkhH2VUeL5Y0kNJfuBkEAlsCSEuZJwuK + JQ2kdKabQcCWANJTdpJHiiUNpPRVGXBziPayJYDeUHaQ+RIvayCFbwhfBOB/2RJA7yjbyUMSL2sghW/J + oJtDtI8tAfSWMlcekHhZAymcJ0NuDtEutgTQe8ocuVfiZQ2kcKEMuzlEe9gSQH8oW8vdEi9rIIXvyoib + Q7SDLQH0jzJb7pR4WQMpXCoT3Bwif7YE0F/KlnKbxMsaSOH7MtHNIfJmSwD9p8yQWyRe1kAK/yyT3Rwi + X7YEUA/KdLlR4mUNpHC1THFziDzZEkB9KNPkeomXNZDCtbKZm0Pkx5YA6iUs5WI5x8saSOHfZJqbQ+TF + lgDqR5ki4bdp42UNpBD+2Gm6m0Pkw5YA6kmZLFdJvKyBFMJfQJ3h5hB5sCWA+lImyRUSL2sghfCtqFu6 + OUTz2RJAvSkTJPwjLvGyBlII/yjVbDeHaDZbAqg/ZUQukXhZAymEf556azeHaC5bAmgGZVjCD3aJlzWQ + QvhBVXPcHKKZbAmgOZQhCT/iNV7WQArhR1bPdXOI5rElgGZRBuVciZc1kMJDsp2bQzSLLQE0jzIg50i8 + rIEU5ssObg7RHLYE0ExK+CLgbImXNZDCI7KTm0M0gy0BNJtyZrGkgZQWyDw3g6g/WwJoPuVLxZIGUnpc + dnUziHqzJYA8KKcVSxpI6UnZ3c0g6suWAPKhfLZY0kBKC2VPN4OoJ1sCyItySrGkgZQWyd5uBlE/tgSQ + H+VjxZIGUnpG9nUziHqxJYA8KScVSxpI6TnZ380g6sOWAPKlnCCrJV7YQNWWyIFuBlEPtgSQN+U44YsA + pPa8HOxmEP1nSwD5U46RVRIvbKBqy+RQN4PoL1sCaAflKFkp8cIGqrZcDncziP6xJYD2UI6UFRIvbKBq + YcaOdDOI/rAlgHZRDpfwv9LihQ1ULfxu01FuBtF7tgTQPsqhEv68Nl7YQNXC3zs5xs0gesuWANpJOVjC + 39yOFzZQtfAdKMe5GUTv2BJAeykHSvge7nhhA1ULXwSc4GYQvWFLAO2m7C/hX3OLFzaQwkluBpGeLQFA + 2VfCv+seL2sghY+7GURatgSAQNlbwk94i5c1kMIpbgaRji0B4AXKnhJ+1nu8rIEUPudmEGnYEgBiyu7y + ZLGkgZROczOI6tkSAMqUXeXxYkkDKZ3uZhDVsiUAOMo8WVAsaSClr7gZRHVsCQAbouwkjxRLGkjpbBlw + c4jxsyUAjEbZQeZLvKyBFM4RvghIwJYAsDHKdvKQxMsaSOFcGXRziO7ZEgA6ocyVByRe1kAK58uQm0N0 + x5YA0Clljtwr8bIGUrhIht0cYuxsCQBjoWwtd0u8rIEULpERN4cYG1sCwFgps+VOiZc1kMJlMsHNITpn + SwDohjJLbpN4WQMpXCGT3ByiM7YEgG4pM+QWiZc1kMJVMtnNITbOlgAwHsp0uVHiZQ2kcI1McXOI0dkS + AMZLmSbXS7ysgRSulaluDrFhtgSAKiibFcs5XtZACuGLzc3dHMKzJQBURZkiV0u8rIEUbpIt3BxifbYE + gCopkyX8ha14WQMp3Coz3RxiXbYEgKopkyR861a8rIEUbpdZbg6xli0BIAVlglwq8bIGUgj/KNVsN4dY + w5YAkIoyIuGfc42XNZDCPbKNm0Po5XElAKSkDMuFEi9rIIX7ZI6bw7azJQCkpgxJ+BGv8bIGUnhQ5ro5 + bDNbAkAvKINyrsTLGkjhYdnezWFb2RIAekUZkHMkXtZACvNlRzeHbWRLAOglJXwRcLbEyxpI4VHZ2c1h + 29gSAPpBObNY0kBKC2Sem8E2sSUA9IvypWJJAyk9Ibu5GWwLWwJAPymnFUsaSOkp2cPNYBvYEgD6Tfls + saSBlBbKXm4Gc2dLAKgD5ZRiSQMpLZJ93AzmzJYAUBfKx4olDaT0rOznZjBXtgSAOlFOKpY0kNJiOcDN + YI5sCQB1o5wgqyVe2EDVlshBbgZzY0sAqCPlOOGLAKS2VA5xM5gTWwJAXSnHyCqJFzZQtWVymJvBXNgS + AOpMOUpWSrywgaotlyPcDObAlgBQd8qRskLihQ1ULczYu90MNp0tAaAJlMMl/K+0eGEDVQu/23S0m8Em + syUANIVyqIQ/r40XNlC18PdOjnUz2FS2BIAmUQ6W5yVe2EDVwnegHO9msIlsCQBNoxwo4Xu444UNVC18 + EXCim8GmCQk/FxkAchC+f7u8sIEUPuKOapOElJ8UAADYuJPdYW2KkPITAgAAnfmUO65NEFJ+MgAAoHOn + ugNbdyHlJwIAAMbmC+7I1llI+UkAAICxO8Md2roKKT8BAADQnbPcsa2jkPKDBwAA3fuaDLijWych5QcO + AADG55sy6A5vXYSUHzQAABi/b0ttvwgIKT9gAABQjQtkyB3gfgspP1gAAFCdi2XYHeF+Cik/UAAAUK3v + yYg7xP0SUn6QAACgepfLRHeM+yGk/AABAEAaV8okd5B7LaT84AAAQDo/lE3dUe6lkPIDAwAAaV0jU9xh + 7pWQ8oMCAADpXSdT3XHuhZDyAwIAAL1xg2zuDnRqIeUHAwAAeudm2cId6ZRCyg8EAAD01q0y0x3qVELK + DwIAAPTeHTLLHesUQsoPAAAA9MddspU72FULKX9yAADQP/fINu5oVymk/IkBAEB/3S/busNdlZDyJwUA + AP33oLzEHe8qhJQ/IQAAqIeH5aXugI9XSPmTAQCA+viFvMwd8fEIKX8iAABQL4/Jy90h71ZI+ZMAAID6 + +aXs4o55N0LKnwAAANTTE/JKd9DHKqT8wQEAQH09Ja9yR30sQsofGAAA1NvT8hp32DsVUv6gAACg/hbJ + 69xx70RI+QMCAIBmeFbe4A78xoSUPxgAAGiOxfImd+RHE1L+QAAAoFmel7e4Q78hIeUPAgAAmmepvM0d + eyek/AEAAEAzLZPfcge/LKT8iwEAQHMtl3e6ox8LKf9CAADQbCvlPe7wvyCk/IsAAEDzhS8C/o87/kFI + +RcAAIA8rJL38wUAAADts1o+yBcAAAC00+/zBQAAAO30Ub4AAACgnT7BFwAAALTTp8X+BwAAIF98AQAA + QMvwRwAAALQMfwkQAIAWCf8WAN8GCABAi/APAQEA0DL8U8AAALQMPwwIAICWWSH8OGAAAFpkubzTHf1Y + SPkXAgCAZlomv+UOfllI+RcDAIDmWSpvc8feCSl/AAAA0CxL5C3u0G9ISPmDAACA5lgsb3JHfjQh5Q8E + AACa4Vl5gzvwGxNS/mAAAKD+Fsnr3HHvREj5AwIAgHpbKK9xh71TIeUPCgAA6uspeZU76mMRUv7AAACg + np6QV7qDPlYh5Q8OAADq55eyizvm3QgpfwIAAFAvj8rL3SHvVkj5kwAAgPr4hbzMHfHxCCl/IgAAUA8P + y0vdAR+vkPInAwAA/fegvMQd7yqElD8hAADor/tkW3e4qxJS/qQAAKB/7pFt3NGuUkj5EwMAgP64S7Zy + B7tqIeVPDgAAeu8OmeWOdQoh5QcAAAB661aZ6Q51KiHlBwEAAHrnZtnCHemUQsoPBAAA9MYNsrk70KmF + lB8MAABI7zqZ6o5zL4SUHxAAAEjrGpniDnOvhJQfFAAASOeHsqk7yr0UUn5gAAAgjStlkjvIvRZSfnAA + AKB6l8tEd4z7IaT8AAEAQLW+JyPuEPdLSPlBAgCA6lwsw+4I91NI+YECAIBqXCBD7gD3W0j5wQIAgPH7 + tgy641sHIeUHDAAAxuebUtvjH4SUHzQAAOje12TAHd06CSk/cAAA0J2z3LGto5DygwcAAGN3hju0dRVS + fgIAAGBsvuCObJ2FlJ8EAADo3KnuwNZdSPmJAACAznzKHdcmCCk/GQAAsHEnu8PaFCHlJwQAAEb3EXdU + mySk/KQAAIC3Wk50B7VpQspPDgAArC8c/+PdMW2ikPITBAAA61olx7pD2lQh5ScJAADWWilHuyPaZCHl + JwoAANZYIe92B7TpQspPFgAAbLLJcjnCHc8chJSfMAAAbbdMDnOHMxch5ScNAECbLZVD3NHMSUj5iQMA + 0FZL5CB3MHMTUn7yAAC00WI5wB3LHIWUXwAAANrmWdnPHcpchZRfBAAA2mSR7OOOZM5Cyi8EAABtsVD2 + cgcydyHlFwMAgDZ4SvZwx7ENQsovCAAAuXtCdnOHsS1CHgKAGnhYyksaSGGBzHNHsU1sCQC9pAzINyRe + 0kAKj8rObg7bxpYA0CvKoHxL4iUNpDBfdnRz2Ea2BIBeUIbkPImXNJBC+COm7d0ctpUtASA1ZVgulHhJ + Ayk8KHPdHLaZLQEgJWVELpF4SQMp3Cdz3By2nS0BIBVlglwq8ZIGUrhHtnFzCL08rgSAFJRJ8n2JlzSQ + wp0y280h1rAlAFRNmSxXSbykgRRul1luDrGWLQGgSsoUuVriJQ2kcKvMdHOIddkSAKqibCbXSrykgRRu + ki3cHGJ9tgSAKijT5HqJlzSQQpizzd0cwrMlAIyXMl1ulHhJAymE32Ga6uYQG2ZLABgPZYbcIvGSBlK4 + Rqa4OcTobAkA3VK2lNskXtJACuG7Sia7OcTG2RIAuqHMlvD91/GSBlK4Qia5OURnbAkAY6VsLXdLvKSB + FC6TCW4O0TlbAsBYKHPkXomXNJBC+BkSI24OMTa2BIBOKXPlAYmXNJDCRTLs5hBjZ0sA6ISynTwk8ZIG + Ujhfhtwcoju2BICNUXaQ+RIvaSCFc2XQzSG6Z0sAGI2yszwi8ZIGUjhHBtwcYnxsCQAbosyTBRIvaSCF + s4Xjn4gtAcBRdpXHJV7SQApfcTOI6tgSAMqUPeTJYjkDKZ3uZhDVsiUAxJQ9ZWGxnIGUTnMziOrZEgBe + oOwti4rlDKT0OTeDSMOWABAo+8ozxXIGUjrFzSDSsSUAKPvLc8VyBlL6uJtBpGVLAO2mHChLiuUMpHSS + m0GkZ0sA7aUcLM8XyxlIZbWc4GYQvWFLAO2kHCrLJF7UQNXC8T/OzSB6x5YA2kc5XJZLvKiBqq2SY9wM + ordsCaBdlCNlhcSLGqjaSjnKzSB6z5YA2iMs5GIxx4saqFr4AvNIN4PoD1sCaAflGAm/JRsvaqBq4Y+W + DncziP6xJYD8KcdJ+MtY8aIGqhb+UumhbgbRX7YEkDflBOH4I7Xw7aQHuxlE/9kSQL6Uk4rlDKQU/iGp + A90Moh5sCSBPyseL5QykFP4J6f3dDKI+bAkgP8opxXIGUgo/PGpfN4OoF1sCyIvyuWI5AymFHxu9t5tB + 1I8tAeRDOa1YzkBKC2VPN4OoJ1sCyINyerGcgZSelN3dDKK+bAmg+ZSvFMsZSOlx2dXNIOrNlgCaSxmQ + syVe0kAKC2Sem0PUny0BNJMSjv85Ei9pIIVHZCc3h2gGWwJoHmVQzpV4SQMpzJcd3ByiOWwJoFmUITlf + 4iUNpPCQbOfmEM1iSwDNoQzLRRIvaSCFB2Sum0M0jy0BNIMyIpdIvKSBFO6VOW4O0Uy2BFB/ygS5TOIl + DaRwt2zt5hDNZUsA9aZMkiskXtJACnfKbDeHaDZbAqgvZbJcJfGSBlK4TbZ0c4jmsyWAelKmyDUSL2kg + hVtkhptD5MGWAOpHmSrXSbykgRRulOluDpEPWwKoF2VzuV7iJQ2k8G8yzc0h8mJLAPWhbCE3SbykgRSu + lc3cHCI/tgRQD8pMuVXiJQ2kcLVMcXOIPNkSQP8ps+R2iZc0kMI/y2Q3h8iXLQH0lzJbwvdfx0saSOH7 + MtHNIfJmSwD9o2wj90i8pIEULpUJbg6RP1sC6A9ljtwn8ZIGUviujLg5RDvYEkDvKXPlQYmXNJDChTLs + 5hDtYUsAvaVsLw9LvKSBFM6TITeHaBdbAugdZUeZL/GSBlL4lgy6OUT72BJAbyg7y6MSL2kghW/IgJtD + tJMtAaSnzJMFEi9pIIWvCscf67AlgLSU3eQJiZc0kMKZbgYBWwJIR9lDniqWM5DSX7gZBAJbAkhD2UsW + FssZSOnzbgaBF9gSQPWUfWRRsZyBlD7jZhCI2RJAtZT95NliOQMpfdLNIFBmSwDVUQ6QxcVyBlL6IzeD + gGNLANVQDpIlxXIGUvoDN4PAhtgSwPgph8jSYjkDqayWD7kZBEZjSwDjoxwmyyRe1EDVVskH3AwCG2NL + AN1TjpDlEi9qoGrh+P+um0GgE7YE0B3l3bJC4kUNVG2lvNfNINApWwIYO+XoYjHHixqoWvgC811uBoGx + sCWAsVGOlfBbsvGiBqoW/mjpHW4GgbGyJYDOKcdL+JvY8aIGqha+o+TtbgaBbtgSQGeUE4Xjj9Sel7e6 + GQS6ZUsAG6d8pFjOQErhX5F8s5tBYDxsCWB0ysnFcgZSek7e6GYQGC9bAtgw5VPFcgZSekZe72YQqIIt + AXjKqcVyBlJ6Wl7rZhCoii0BrE/5QrGcgZR+Ja92MwhUyZYA1qWcUSxnIKUnZXc3g0DVbAlgLeWsYjkD + KT0uv+lmEEjBlgDCPt5kQL4m8ZIGUnhMXuHmEEjFlkDbKYPyTYmXNJDCI7KTm0MgJVsCbaaE4/9tiZc0 + kMJ/yw5uDoHUbAm0lTIkF0i8pIEUfi7buTkEesGWQBspw3KxxEsaSOF++Q03h0Cv2BJoG2VEvifxkgZS + +Jm82M0h0Eu2BNpEmSiXS7ykgRT+S7Z2cwj0mi2BtlAmyZUSL2kghf+UF7k5BPrBlkAbKJvKDyVe0kAK + P5Ut3RwC/WJLIHfKFLlG4iUNpPAfMsPNIdBPtgRypkyV6yRe0kAK/y7T3RwC/WZLIFfK5nKDxEsaSOEn + Ms3NIVAHtgRypGwhN0u8pIEU/lU2c3MI1IUtgdwoM+VWiZc0kMK/yKZuDoE6sSWQE2WW3CHxkgZS+IFM + dnMI1I0tgVwoW8ldEi9pIIV/koluDoE6siWQA2UbuUfiJQ2k8I8ywc0hUFe2BHKgfKhYzkBK35ERN4NA + ndkSyIXymWJJAyn8vQy72QPqzpZATpTPF8saqNLfyZCbOaAJbAnkRvlSsbSBKvyNDLpZA5rClkCOlDOL + 5Q2Mx9dlwM0Y0CS2BHKlfLVY4kA3/lI4/siCLYFcheUt35B4qQOd+LKbKaCpbAnkTAlfBHyrWOpAJ77o + ZgloMlsCuVMG5bxiuQOj+VM3Q0DT2RJoA2VILiyWPOB82s0OkANbAm2hDMt3i2UPxD7hZgbIhS2BNlFG + 5NJi6QPBR92sADmxJdA2ygT5frH80W4fdjMC5MaWQBspE+Wq4gigfVbLB91sADmyJdBWymS5WuLDgPyt + kve7mQByZUugzZQpcq3EBwL5Winvc7MA5MyWQNspm8n1Eh8K5Ccc//e4GQByZ0sA4TZsMk1ulPhgIB/L + 5Z3uvQfawJYA1lCmyy0SHw403zL5bfeeA21hSwBrKTPkNokPCJprqbzNvddAm9gSwLqULeVOiQ8Jmud5 + eYt7j4G2sSWA9Smz5W6JDwqaY7G8yb23QBvZEoCnbC33SnxYUH/Pyhvcewq0lS0BbJgyRx6Q+MCgvhbJ + 69x7CbSZLQGMTpkrD0l8aFA/T8tr3HsItJ0tAWycsp3Ml/jgoD6ekle59w6A/l/ElQA6o+wgj0h8eNB/ + T8gr3XsGYA1bAuicspMskPgAoX9+Kbu49wrAWrYEMDbKPHlc4kOE3ntMXu7eIwDrsiWAsVN2lSclPkjo + nV/Iy9x7A2B9tgTQHWV3WSjxYUJ6D8tL3XsCwLMlgO4pe0r43vP4QCGdn8tL3HsBYMNsCWB8lL3lGYkP + Fap3v2zr3gMAo7MlgPFT9pXnJD5YqM7P5MXutQewcbYEUA1lf1ki8eHC+N0lW7nXHEBnbAmgOsqBEn4M + bXzA0L075EXutQbQOVsCqJZysCyT+JBh7H4qM91rDGBsbAmgesqhslzig4bO3SxbuNcWwNjZEkAayuGy + QuLDho27QTZ3rymA7tgSQDrKkbJS4gOHDfuJTHWvJYDu2RJAWspRskriQ4f1/VimuNcQwPjYEkB6yjGy + WuKDh7V+JJu61w7A+NkSQG8oxwlfBKzvSpnkXjMA1bAlgN5RTiiOHta4XCa61wpAdWwJoLeUk4rj13b/ + ICPuNQJQLVsC6D3lY8URbKuLZdi9NgCqZ0sA/aGcUhzDtrlAhtxrAiANWwLoH+VzxVFsi7+VQfdaAEjH + lgD6SzmtOI65+2vh+AN9YEsA/aecXhzJXP2VDLjnDiA9WwKoB+UrxbHMzVnu+QLoHVsCqA/l7Ohw5uAM + 9zwB9JYtAdSHMiDnFMez6f7cPUcAvWdLAPWihC8Czi2OaFOd6p4bgP6wJYD6UQbl/OKYNs2fuOcEoH9s + CaCelCG5qDiqTXGyey4A+suWAOpLGZZLiuNad3/ongOA/rMlgHpTRuSy4sjWUfgRxye6xw6gHmwJoP6U + CXKFxIe3DsLxP949ZgD1YUsAzaBMkqskPsD9tEqOdY8VQL3YEkBzKJPlaokPcT+slKPdYwRQP7YE0CzK + FLlW4oPcSyvkd9xjA1BPtgTQPMpUuV7iw9wLy+UI95gA1JctATSTMk1ukvhAp7RMDnOPBUC92RJAcynT + 5VaJD3UKS+UQ9xgA1J8tATSbMlNul/hgV2mJHOQ+N4BmsCWA5lNmyZ0SH+4qLJYD3OcE0By2BJAHZbbc + I/EBH49nZT/3uQA0iy0B5EPZRu6T+JB3Y5Hs4z4HgOaxJYC8KHPkQYkP+lgslL3cxwbQTLYEkB9lrjwk + 8WHvxFOyh/uYAJrLlgDypGwv8yU+8KN5QnZzHwtAs9kSQL6UHeVRiQ+9s0B2cR8DQPPZEkDelJ2LAx8f + /Fj4AmFn92sB5MGWAPKnzJPwW/zx4Q/CHxHs6H4NgHzYEkA7KLtJ+Et+Lxz/h2V7998FkBdbAmgPZQ8J + 3+YXvk1wrvvvAMiPLQG0i/Jq2db9ZwDyZEsAAJA3WwIAgLzZEgAA5M2WAAAgb7YEAAB5syUAAMibLQEA + QN5sCQAAcvbrTf4H1hvxJ21pcQwAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + dgAADnYBFNpwXwAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAACq6SURBVHhe7d0L + 2G7nfOfx7HN2ds4HO4mkEUKQFHE+n4MgWkGUqIYRRtCoOoyoU0dUHS5MRUs7tIMZtNrBoKMdOnQYDMXE + UKfGqEMdSpDzQX//2WtP7rz79+59P++z1vOs/7q/v+v6XJfrn539Ps9a97rvn539Pu9eP//5zwE0SHl+ + cP8MwPTZIYBpU54j8T/Cc9yvATBtdghgupRnFIf/Ts9wvxbAdNkhgGlSnloc+is91f07AKbJDgFMj/Kk + 4rB3rpEnuX8XwPTYIYBpUR7fHfDlge/Er3m8+z0ATIsdApgO5VflaikP+t2JX/ur7vcCMB12CGAalEfJ + VVIe8DXi33mU+z0BTIMdAshPeXh3kJcH+yyulIe73xtAfnYIIDfll+QKKQ/0tYjf45fc1wCQmx0CyEt5 + kFwu5UE+j/i9HuS+FoC87BBATsr95TIpD/A+xO95f/c1AeRkhwDyUe4jl0p5cPfpErmP+9oA8rFDALko + 95CLpTywhxBf4x7uNQDIxQ4B5KHcRX4q5UE9pPhad3GvBUAedgggB+UOcpGUB/QixNe8g3tNAHKwQwDj + p9xGfizlwbxIP5LbuNcGYPzsEMC4KbeSH0p5IC9DvIZbudcIYNzsEMB4KSfK96U8iJcpXsuJ7rUCGC87 + BDBOys3kn6Q8gMcgXtPN3GsGME52CGB8lJvId6Q8eMfk23IT99oBjI8dAhgX5Ubyj1IeuGMUr/FG7j0A + GBc7BDAeyg3kG1IetGMWr/UG7r0AGA87BDAOytHydSkP2AziNR/t3hOAcbBDAMunHClflfJgzeQrcqR7 + bwCWzw4BLJdyuHxJygM1o3gPh7v3CGC57BDA8iiHyRekPEgzi/dymHuvAJbHDgEsh3KIfF7KA3QK4j0d + 4t4zgOWwQwCLpxwkn5Hy4JySeG8HufcOYPHsEMBiKQfIp6Q8MKco3uMB7hoAWCw7BLA4yn7ycSkPyimL + 97qfuxYAFscOASyGsk0+KuUB2YJ4z9vcNQGwGHYIYHjKPvJhKQ/GlsR738ddGwDDs0MAw1L2lr+S8kBs + UVyDvd01AjAsOwQwHGWLfEDKg7BlcS22uGsFYDh2CGAYyiZ5r5QHIHZck03umgEYhh0C6J+yUf5cyoMP + 14prs9FdOwD9s0MA/VI2yDulPPCwq7hGG9w1BNAvOwTQH2W9vE3Kgw6ri2u13l1LAP2xQwD9iINM/ljK + Aw57FteMEgAMyA4BzE9ZJ38o5cGGenHt1rlrC2B+dghgfsrru4MMa/d6d20BzM8OAcxHeW1xiGE+r3XX + GMB87BDA2imvLA4v9OOV7loDWDs7BLA2ykuLQwv9eqm75gDWxg4BzE55cXFYYRgvdtcewOzsEMBslOcV + hxSG9Tx3DwDMxg4B1FOeXRxOWIxnu3sBoJ4dAqijPL04lLBYT3f3BEAdOwSwZ8pTisMIy/EUd28A7Jkd + Atg95YlyTXcIYXniHjzR3SMAu2eHAFanPK47eMqDCMsT9+Jx7l4BWJ0dAvCUx8jVUh5AWL64J49x9wyA + Z4cAdqU8Uq6S8uDBeMS9eaS7dwB2ZYcArkt5mFwp5YGD8Yl79DB3DwFclx0CuJbyELlCyoMG4xX36iHu + XgK4lh0C2EF5oFwu5QGD8Yt79kB3TwHsYIcA4gzZ635ymZQHC/KIe3c/d28B6BFxQ6B1yr3lEikPFOQT + 9/De7h4DrbNDoGXK3eViKQ8S5BX38u7uXgMts0OgVcqd5adSHiDIL+7pnd09B1plh0CLlNvLRVIeHJiO + uLe3d/ceaJEdAq1Rbi0/kvLAwPTEPb61WwNAa+wQaIlyS/mhlAcFpivu9S3dWgBaYodAK5QT5PtSHhCY + vrjnJ7g1AbTCDoEWKDeV70p5MKAdce9v6tYG0AI7BKZOubF8W8oDAe2JNXBjt0aAqbNDYMqUG8o3pTwI + 0K5YCzd0awWYMjsEpko5Rr4h5QEAxJo4xq0ZYKrsEJgi5Sj5upQbP7BTrI2j3NoBpsgOgalRjpSvSLnh + AyvFGjnSrSFgauwQmBJlu3xJyo0eWE2sle1uLQFTYofAVCiHyQVSbvDAnsSaOcytKWAq7BCYAuUQ+ZyU + GztQK9bOIW5tAVNgh0B2ykHyGSk3dGBWsYYOcmsMyM4OgcyUA+STUm7kwFrFWjrArTUgMzsEslL2k49J + uYED84o1tZ9bc0BWdghkpGyTj0i5cQN9ibW1za09ICM7BLJRtsqHpdywgb7FGtvq1iCQjR0CmSh7ywel + 3KiBocRa29utRSATOwSyUDbL+6XcoIGhxZrb7NYkkIUdAhkom+Q9Um7MwKLE2tvk1iaQgR0CY6dslHdJ + uSEDixZrcKNbo8DY2SEwZsoGeYeUGzGwLLEWN7i1CoyZHQJjpayXt0q5AQPLFmtyvVuzwFjZITBGyjp5 + s5QbLzAWsTbXubULjJEdAmMTG6u8UcoNFxibWKOUAKRgh8DYKOd3Gywwdue7NQyMjR0CY6K8pthcgQxe + 49YyMCZ2CIyF8opiUwUyeYVb08BY2CEwBsp5xWYKZHSeW9vAGNghsGzKi4pNFMjsRW6NA8tmh8AyKecW + mycwBee6tQ4skx0Cy6I8q9g0gSl5llvzwLLYIbAMyjnFZglM0Tlu7QPLYIfAoilnF5skMGVnu2cAWDQ7 + BBZJOUuu6TZHYOpirZ/lngVgkewQWBTlzG5DLDdIYOpizZ/pnglgUewQWATlDLlayo0RaEWs/TPcswEs + gh0CQ1NOl6uk3BCB1sQzcLp7RoCh2SEwJOU0uVLKjRBoVTwLp7lnBRiSHQJDUU6VK6TcAIHWxTNxqntm + gKHYITAE5RS5XMqND8AO8Wyc4p4dYAh2CPRNOVkulXLDA3Bd8Yyc7J4hoG92CPRJuZdcIuVGB8CLZ+Ve + 7lkC+mSHQF+Uu8nPpNzgAOxePDN3c88U0Bc7BPqg3El+IuXGBqBOPDt3cs8W0Ac7BOal3E4uknJDAzCb + eIZu554xYF52CMxDOUl+JOVGBmBt4lk6yT1rwDzsEFgr5RbyAyk3MADziWfqFu6ZA9bKDoG1UE6Q70m5 + cQHoRzxbJ7hnD1gLOwRmpRwv35VywwLQr3jGjnfPIDArOwRmoRwn35JyowIwjHjWjnPPIjALOwRqKcfK + N6XcoAAMK565Y90zCdSyQ6CGcoxcKOXGBGAx4tk7xj2bQA07BPZEOUq+JuWGBGCx4hk8yj2jwJ7YIbA7 + yhHyZSk3IgDLEc/iEe5ZBXbHDoHVKNvli1JuQACWK57J7e6ZBVZjh4CjHCoXSLnxABiHeDYPdc8u4Ngh + sJJysHxWyg0HwLjEM3qwe4aBlewQKCkHyqel3GgAjFM8qwe6Zxko2SGwk7K/fELKDQbAuMUzu797poGd + 7BAIyr7yP6TcWADkEM/uvu7ZBoIdAso2+YiUGwqAXOIZ3uaeccAO0TZlq3xIyo0EQE7xLG91zzraZodo + l7JF/quUGwiA3OKZ3uKeebTLDtEmZbO8T8qNA8A0xLO92T37aJMdoj3KJnm3lBsGgGmJZ3yT2wPQHjtE + W5SN8mdSbhQApime9Y1uL0Bb7BDtUDbI26XcIABMWzzzG9yegHbYIdqgrJe3SLkxAGhDPPvr3d6ANtgh + pk9ZJ2+SckMA0JbYA9a5PQLTZ4eYtnjg5Q1SbgQA2hR7ASWgQXaIaVNe1z34ABBe5/YKTJsdYrqUVxcP + PQDs9Gq3Z2C67BDTpPxu8bADwEq/6/YOTJMdYnqUlxQPOQCs5iVuD8H02CGmRXlB8XADwJ68wO0lmBY7 + xHQozy0eagCo9Vy3p2A67BDToPxm8TADwKx+0+0tmAY7RH7KrxcPMQCs1a+7PQb52SFyU55cPLwAMK8n + u70Gudkh8lKeINd0Dy0A9CH2lCe4PQd52SFyUn5NrpbywQWAPsTe8mtu70FOdoh8lEd3D2j5wAJAn2KP + ebTbg5CPHSIX5RFylZQPKgAMIfaaR7i9CLnYIfJQHipXSvmAAsCQYs95qNuTkIcdIgflwXKFlA8mACxC + 7D0PdnsTcrBDjJ/yALlMygcSABYp9qAHuD0K42eHGDflvnKplA8iACxD7EX3dXsVxs0OMV7KPeViKR9A + AFim2JPu6fYsjJcdYpyUu8rPpHzwAGAMYm+6q9u7ME52iPFR7ig/kfKBA4AxiT3qjm4Pw/jYIcZFua38 + WMoHDQDGKPaq27q9DONihxgP5ST5ZykfMAAYs9izTnJ7GsbDDjEOyi/KD6R8sAAgg9i7ftHtbRgHO8Ty + KTeX70n5QAFAJrGH3dztcVg+O8RyKcfLd6R8kAAgo9jLjnd7HZbLDrE8ynHyLSkfIADILPa049yeh+Wx + QyyHcqz8XykfHACYgtjbjnV7H5bDDrF4yi/IP0j5wADAlMQe9wtuD8Ti2SEWS7m+fFXKBwUApij2uuu7 + vRCLZYdYHOUI+XspHxAAmLLY845weyIWxw6xGMr15P9I+WAAQAti77ue2xuxGHaI4SmHyv+W8oEAgJbE + Hnio2yMxPDvEsJSD5e+kfBAAoEWxFx7s9koMyw4xHOVA+V9SPgAA0LLYEw90eyaGY4cYhrK//E8pFz4A + YMfeuL/bOzEMO0T/lH3lb6Vc8ACAa8Ueua/bQ9E/O0S/lH3kv0u50AEAu4q9ch+3l6Jfdoj+KFvlv0m5 + wAEAq4s9c6vbU9EfO0Q/lC3yl1IubADAnsXeucXtreiHHWJ+ymb5L1IuaABAvdhDN7s9FvOzQ8xH2ST/ + WcqFDACYXeylm9xei/nYIdZO2Sh/KuUCBgCsXeypG92ei7WzQ6yNskH+k5QLFwAwv9hbN7i9F2tjh5id + sl7+g5QLFgDQn9hj17s9GLOzQ8xGWSf/XsqFCgDoX+y169xejNnYIerFQpQ/kHKBAgCGE3suJWBOdoh6 + yu91CxIAsDi/5/Zk1LND1FFeVSxGAMBivcrtzahjh9gz5WXFIgQALMfL3B6NPbND7J7y28XiAwAs12+7 + vRq7Z4dYnfL8YtEBAMbh+W7PxursEJ7ynGKxAQDG5Tlu74Znh9iV8oxikQEAxukZbg/HruwQ16U8rVhc + AIBxe5rby3FddohrKU8qFhUAIIcnuT0d17JD7KA8Xq7pFhMAII/Yux/v9nbsYIeItbPXY+VqKRcUACCP + 2MMf6/Z46PK4YeuUR8lVUi4kAEA+sZc/yu31rbPDlikP7xZMuYAAAHnFnv5wt+e3zA5bpfyyXCHlwgEA + 5Bd7+y+7vb9Vdtgi5UFyuZQLBgAwHbHHP8idAS2yw9Yo95fLpFwoAIDpib3+/u4saI0dtkS5j1wq5QIB + AExX7Pn3cWdCS+ywFco95GIpFwYAYPpi77+HOxtaYYctUO4iP5VyQQAA2hFnwF3cGdECO5w65Q5ykZQL + AQDQnjgL7uDOiqmzwylTbiM/lnIBAADaFWfCbdyZMWV2OFXKreSHUt54AADibLiVOzumyg6nSDlRvi/l + DQcAYKc4I050Z8gU2eHUKDeTf5LyRgMAsFKcFTdzZ8nU2OGUKDeR70h5g4E+XCJ8gBQwPXFm3MSdKVNi + h1Oh3Ej+UcobC/QhPkjkZPluMQMwHXF23MidLVNhh1Og3EC+IeUNBfoQnyd+SrfOKADAdMUZcoOV58tU + 2GF2ytHyD1LeSKAP8RPFTi3WGgUAmLY4S44uz5ipsMPMlOvLV6W8gUAfrpTTVqw3CgAwfXGmXL989qfA + DrNSDpe/l/LGAX24Sk43a44CALQhzpbDV+4BmdlhRsr15AtS3jCgD1fLGausOwoA0I44Y67n9oKM7DAb + 5RD5vJQ3CujDNXKmW3dBoQAAbYmz5hC3H2Rjh5koB8nfSXmDgD7E4X+WW3c7KRQAoD1x5hzk9oRM7DAL + 5QD5lJQ3BujL2W7dlRQKANCmOHsOcPtCFnaYgbKffFzKGwL05Ry37lZSKABAu+IM2s/tDRnY4dgp2+Rv + pbwRQF+e6dado1AAgLbFWbTN7Q9jZ4djpuwjfyPlDQD6cq5bd6tRKAAA4kzax+0RY2aHY6XsLX8t5YUH + +vJCt+52R6EAAAhxNu3t9omxssMxUrbIB6S84EBfznPrbk8UCgCAneKM2uL2ijGyw7FRNsl7pbzQQF9e + 7tZdDYUCAKAUZ9Umt1+MjR2OibJR/kLKCwz05dVu3dVSKAAAVooza6PbM8bEDsdC2SDvlPLCAn053627 + WSgUgLziR72+YcUM6EucXRvcvjEWdjgGynp5m5QXFOjLG2WdW3uzUCgAeV0o6+RNxQzoU5xh693eMQZ2 + uGxxweRPpLyQQF/eLHMf/kGhAOR1YXcPY795SzcD+hZn2ShLgB0ukxKN/I+kvIBAX94qvT2MCgUgr/9X + ALr7GP+58e3dHOhbnGm9/J+OPtnhMim/310woG+xwff63+QUCkBe/78AdPcy/sLxu7p/BvTt98v1NgZ2 + uCzKa4uLBfQpNvbe/1auQgHI6zoFoLuf8S3H7+7+OdC3165cc8tkh8ugvLK4SECfYkMf5PtyFQpAXrsU + gO6ebpb3db8G6Nsr3bpbBjtcNOV3iosD9On9stmtuz4oFIC8bAEISnzs+Ae7Xwf07Xfculs0O1wk5cXF + RQH6FBv4oJ/NrVAA8lq1AARlq3yo+7VA317s1t0i2eGiKL9VXAygT7Fxb3Xrrk8KBSCv3RaAoMSPHv9I + 9+uBvv2WW3eLYoeLoDy7uAhAn2LDXsjP51YoAHntsQAEZV/5WPfvAH17tlt3i2CHQ1N+o3jzQJ9io97X + rbshKBSAvKoKQFD2l090/x7Qt99w625odjgk5SnFmwb6FBv0/m7dDUWhAORVXQCCcqB8uvt3gb49xa27 + IdnhUJQnyjXdmwX6FBvzgW7dDUmhAOQ1UwEIysHy2e7fB/oUZ+MT3bobih0OQXlc9wbLNwz0ITbkg926 + G5pCAchr5gIQlEPlgu73APoUZ+Tj3Lobgh32TXmMXC3lGwX6EBvxYW7dLYJCAchrTQUgKNvli93vA/Qp + zsrHuHXXNzvsk/IrcpWUbxDoQ2zA2926WxSFApDXmgtAUI6QL3e/F9CnODN/xa27PtlhX5SHyZVSvjGg + D7HxHuHW3SIpFIC85ioAQTlKvtb9fkCf4ux8mFt3fbHDPigPkSukfENAH2LDPcqtu0VTKAB5zV0AgnJM + /F7d7wn0Kc7Qh7h11wc7nJfyQLlcyjcC9CE22mPculsGhQKQVy8FICjHyje73xfoU5ylD3Trbl52OA/l + fnKZlG8A6ENssMe6dbcsCgUgr94KQFCOk291vzfQpzhT7+fW3TzscK2Ue8slUr5woA+xsR7n1t0yKRSA + vHotAEG5qbAmMIQ4W+/t1t1a2eFaKHeXi6V8wUAfYkM93q27Zete28rXixx6LwBBOUG+130NoE9xxt7d + rbu1sMNZKXeWn0r5QoE+xEZ6glt3Y6BQAPIapAAE5Rbyg+7rAH2Ks/bObt3Nyg5nodxeLpLyBQJ9iA30 + Fm7djYVCAchrsAIQlFvLj7qvBfQpztzbu3U3CzuspbDAMZRYVye5dTcmCgUgr0ELQFBuJ/wfJAwh9shb + u3VXyw5rKLeUH0r5goA+xIZ5O7fuxkahAOQ1eAEIyp3kJ93XBPoUZ/At3bqrYYd7opwo35fyhQB9iI3y + Tm7djZFCAchrIQUgKHeTn3VfF+hTnMUnunW3J3a4Owrf5oKhxAZ5N7fuxkrhWchrYQUgKPcSvk0aQ4h9 + 6KZu3e2OHa5GubF8W8ovDPQhNsZ7uXU3ZgoFIK+FFoCgnCyXdl8f6FOczTd26241dugoNxQ+6hJDiA3x + ZLfuxk6hAOS18AIQlFOEj0rHEOKMvqFbd44drqTED7v4hpRfCOhDbISnuHWXgUIByGspBSAopwo/LA1D + iLO66uel2GFJOVq+LuUXAPoQG+Cpbt1loVAA8lpaAQjKacKPS8cQ4sw+2q27kh2WlNsK3+uPvsXGd5pb + c5koFIC8lloAgnK6XNW9HqAvcWbf1q25kh2upMQH/vA9/+hLbHinu7WWjUIByGvpBSAoZ8jV3WsC5hVn + ddUHBNmho8QH//C9/5hXbHRnuDWWkUIByGsUBSAoZ8o13esC1irO6OoPBrLD1SjxU67Y8LBWscGd6dZW + VgrPQ16jKQBBOUsoAVir2Itm+sFpdrg7SnwQEJ8FgFnFxnaWW1OZKRSAvEZVAIJydvH6gFpxJg/7QUA7 + KfGBQHwmAGZxtltL2SkUgLxGVwCCck7xGoE9ibN4pg8A2skOayjxwUB8NgBqnOPW0BQoFIC8RlkAgvKs + 4nUCq7lQqj/4ZyU7rKXEBwTxGQHYnWe6tTMVCgUgr9EWgKCcW7xWYKU4e6s+8Gc1djgLJT4o6CtSvjAg + nOvWzJQoFIC8Rl0AgvKi4vUCO8WZe5RbM7Oww1kpR8qXpHyBaNsL3VqZGoUCkNfoC0BQziteMxBn7ZFu + rczKDtdCOVy+IOULRZvOc2tkihQKQF4pCkBQXlG8brTrAtnu1sha2OFaKYfJ56V8wWjLy93amCqFApBX + mgIQlNcUrx3t+Zwc5tbGWtnhPJRD5DNSvnC04dVuTUyZQgHIK1UBCMr5xetHO+JMPcStiXnY4byUg+RT + Ur4BTNv5bi1MnUIByCtjAVgnb+xeP9rwSTnQrYd52WEflAPk41K+EUxTbEjr3DqYOoUCkFe6AhCUKAFv + 7t4Dpu1jsr9bB32ww74o+8lHpXxDmJbYiJo8/INCAcgrZQEIynp5a/c+ME0fkf3c/e+LHfZJ2SZ/I+Ub + wzS8Rda7+94KhQKQV9oCEJQN8o7uvWBaPiTb3H3vkx32TdlH/lrKN4jc3i4b3P1uiUIByCt1AQjKRnlX + 934wDR+Ure5+980Oh6DsLX8p5RtFTrHhbHT3uTUKBSCv9AUgKJvkPd17Qm7vl73dfR6CHQ5F2SLvlfIN + I5d3yyZ3f1ukUADymkQBCMpmicNj5XtEHlHiNrv7OxQ7HFK8QfkLKd84cogNZqELdOwUCkBekykAQYk/ + ZY0/Pl75PjF+8aeqC/8/VnY4NCX+u9WfSnkBMG6xsSzsj6ayUCgAeU2qAARlq3y4e3/IIf4i51L+k6od + LoISf4P1P0p5ITBO8TdSF/KXUrJRKAB5Ta4ABCW+84pvv84hvpVzaX+Z2g4XRYnvZf0TKS8IxiW+F3Xw + b0fJSqEA5DXJAhCU+AyW+BCZle8Z4xGfobLUb6O2w0WKCyB/JOWFwTjEBrKvu2/YQaEA5DXZAhCU+DTW + +BjZle8byzeKT0+1w0WLCyF/IOUFwnJ9Qgb7CMqpUCgAeU26AAQlfi4LP5xtXOIHOo3i01PtcFmUf9dd + ICzXp2WQHz4xNQoFIK/JF4CgxE9ojR8lu/L9Y/Fe4+7RstjhMimvKi4WFu+zcrC7N9iVQgHIq4kCEJTD + 5ILufWM5XuHuzTLZ4bIpLysuGhYnNohD3T2Bp1AA8mqmAARlu3ype+9YrPPcPVk2OxwD5d8WFw/D+6Js + d/cCq1MoAHk1VQCCcqR8pXv/WIwXuXsxBnY4Fsrzi4uI4XxZjnD3ALunUADyaq4ABOUo+Xp3DTCsc909 + GAs7HBPl3xQXE/37mhzlrj32TKEA5NVkAQjKMfKN7jpgGM90135M7HBslGcUFxX9uVCOcdccdRQKQF7N + FoCg3FC+2V0L9Oscd83Hxg7HSHlacXExv3jwj3XXGvUUCkBeTReAoNxYvt1dD8zvGjnbXesxssOxUv51 + d4HLC47ZfUuOc9cYs1EoAHk1XwCCclNhHc8vzqaz3DUeKzscM+VfydVSXnjUiwf9eHdtMbvueq68xsiB + AtBRTpDvd9cFs4sz6Ux3bcfMDsdOeWx3wcsbgD37npzgrinWRqEA5EUBKCi3lB921wb1rpIz3DUdOzvM + QHl0d+HLG4HV/UBu4a4l1k6hAORFAVhBubX8qLs+2LMr5XR3LTOwwyyUR3Q3oLwh2NU/y0nuGmI+CgUg + LwqAodxeLuquEVZ3hZzmrmEWdpiJ8tDuRpQ3Btf6sdzOXTvMT6EA5EUBWIVyZ/lpd52wq8vlVHftMrHD + bJQHy2VS3iDstddP5E7umqEfCgUgLwrAbih3l4u7a4VrXSqnuGuWjR1mpDyguzHljWrZz+Ru7lqhPwoF + IC8KwB4o95ZLuuuFHdfiZHetMrLDrJT7Co11xyK9p7tG6JdCAciLAlBBuZ/wJ6w7/k/Vvdw1ysoOM1Pu + 2d2o8sa1JP4UZDINdewUCkBeFIBKygMl/rv3ymvYivjPqZP7E1U7zE65a3fDyhvYgnhAJ/HfprJQKAB5 + UQBmoDxEWvwL1/EdEZP8u1R2OAXKHSX+Bnx5I6csHsz0fys1G4UCkBcFYEbKw6Slb72Oz0SY7HdR2eFU + xI2T+B748oZOUTyQD3XXAMNSKAB5UQDWQHmktPAhbPHhaZP+/BQ7nJK4gd2NLG/slMSDmPaTqLJTKAB5 + UQDWSHmMTPnj2ONj0yf/yal2ODVxI7sbWt7gKYgHMOVnUE+FQgHIiwIwB+VxMsWfzhrPdBM/M8UOp0i5 + eXdjyxudWTx46X761NQoFIC8KABzUp4oUyoB8aPSm/lpqXY4VXFjuxtc3vCM4oF7gnuPWCyFApAXBaAH + ylOKa5rZN+U49x6nyg6nLG5wd6PLG5/N2e69YfEUCkBeFICeKE8vrmtGF8qx7r1NmR1OXdzo7oaXCyCL + c9x7wnIoFIC8KAA9Up5dXNtMvibHuPc0dXbYgrjh3Y0vF8LYPdO9FyyPQgHIiwLQM+V5xfXN4MtylHsv + LbDDVsSN7xZAuSDG6rnuPWC5FApAXhSAASgvLq7xmH1RjnDvoRV22JJYAN1CKBfG2LzQvXYsn0IByIsC + MBDlpcV1HqMLZLt77S2xw9bEQugWRLlAxuI895oxDgoFIC8KwICUVxbXekw+K4e619waO2yRcph8TsqF + smwvd68V46FQAPKiAAxMeW1xvcfg03Kwe60tssNWxcLoFki5YJbl1e41YlwUCkBeFIAFUF5fXPNl+oQc + 6F5jq+ywZbFA5JNSLpxFO9+9NoyPQgHIiwKwAMo6+cPumi/Lx2R/9/paZoeti4XSLZhyAS3KG2Wde10Y + H4UCkBcFYEGU9fLH3XVftI/Ivu51tc4OEWtmr/26hVMupKG9WTj8E1EoAHlRABZIiRLwtu7aL8qHZJt7 + PdDlcUPsEAunW0DlghrKW2S9ex0YL4UCkBcFYMGUDfLO7voP7YOy1b0O7GCHuFYsoG4hlQurb2+XDe7r + Y9wUCkBeFIAlUDbKn3f3YCjvky3u6+NadojrUvaW90u5wPryLtnovi7GT6EA5EUBWBJlk7y3uw99e7ds + dl8X12WH2FUsKHmPlAttXrFQN7mvhxwUCkBeFIAlUrbIB7p70Zc/E/bUSnYILxaW9PVHV/EnCrTU5BQK + QF4UgCVT4k9X/6q7H/OK/5TKn6bOwA6xulhg8g4pF96s4u8U7O1+f+SiUADyogCMgLKPfLi7J2sVf4ma + v0c1IzvE7sVCk7dKuQBrxXcV8DdTJ0KhAORFARgJJb7j6qPdfZnVm4TvoFoDO8SexYKTWT/YIj5XgO9J + nRCFApAXBWBElPjslY9396bWG4TPTlkjO0SdWHhS+xGX8cmCfBrVxCgUgLwoACOjHCCf6u7PnrxOOPzn + YIeoFwtQ9vTDLuKHUPA51BOkUADyogCMkHKQfKa7R6vhh6X1wA4xO2W1H3sZP12Qn0A1UQoFIC8KwEgp + h8jnu/u0Ej8mvSd2iLVRXlEs0vBZ4WdPT5hCAciLAjBiymHyhe5e7fQS92uxNnaItVNe2i3UC+RQ92sw + HQoFIC8KwMgph8uXuvv1AvdrsHZ2iPkoT5Xt7p9hWhQKQF4UgASUI+XJ7p9hPnYIoI5CAciLAoCm2SGA + OgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSA + vCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCg + aXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGA + OgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSA + vCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCg + aXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGA + OgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSA + vCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCg + aXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGA + OgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSA + vCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCg + aXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGA + OgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSA + vCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCg + aXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGA + OgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSA + vCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCg + aXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGA + OgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSA + vCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCg + aXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGA + OgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSA + vCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCg + aXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGA + OgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSA + vCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCg + aXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGA + OgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSA + vCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCg + aXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGA + OgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSA + vCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCg + aXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGA + OgoFIC8KAJpmhwDqKBSAvCgAaJodAqijUADyogCgaXYIoI5CAciLAoCm2SGAOgoFIC8KAJpmhwDqKBSA + vCgAaNjP9/oXRCHxJ31tKFgAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + dgAADnYBFNpwXwAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAACqbSURBVHhe7d0L + uK7nfOdx+5ydnfNBDpJGCEFSxPl8DoJoBVGiGkYYQaPqMKJOHVF1uDAVLW1pixm02sGgox06dBgMxcRQ + p9YoUocS5HzQ31+e3dxZ+7f2etd7P8/7Pv/n/v6u63Ndvf6Std73ee7nvn/d2etd1/npT38KNEv5R4n/ + A/mc7+4pgNnYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQ + FwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACg + gh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0 + QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQ + FwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACg + gh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0 + QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQ + FwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACg + gh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0 + QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQ + FwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACg + gh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0 + QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQ + FwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACg + gh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0 + QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQ + FwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACg + gh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0 + QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQ + FwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACg + gh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0 + QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQ + FwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACg + gh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0 + QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQ + FwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACg + gh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0 + QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQ + FwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACg + gh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0 + QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQ + FwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACg + gh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0 + QqEA5EUBACrYIdAKhQKQFwUAqGCHQCsUCkBeFACggh0CrVAoAHlRAIAKdgi0QqEA5EUBACrYIdAKhQKQ + FwUAqGCHQCsUCkBeFACggh2ijvIkOdz9bxgXhQKQFwWgAcoh8hT3v6GOHWJ+yvMl/o8vyqHun8F4KBSA + vCgAE6ccJOd19/sl7p/B/OwQ81Fe3C3UnT4vB7t/FuOgUADyogBMmHKAfKa71zu93P2zmI8dYv2UlxWL + tPQ5OdD9O1g+hQKQFwVgopT95FPdfV7pNe7fwfrZIdZHeVWxOJ1Py/7u38VyKRSAvCgAE6TsIx/v7vFq + Xicb3L+P2dkhZhMLUF4r5cJczSdlX/d1sDwKBSAvCsDEKHvJR7v7u5bfF0pABTvE2mLhyeulXJBr+Zjs + 7b4elkOhAORFAZgQZYd8uLu3s/oj2ei+HtZmh9i9WHDyRikX4qw+Ijvc18XiKRSAvCgAE6Fslw9293W9 + 3iKb3NfF7tkhVhcLTd4s5QJcrw/Jnu7rY7EUCkBeFIAJUPaQD3T3dF5vl83u62N1dggvFpi8TcqFN6+/ + kj3c98HiKBSAvCgAySlb5X3d/az157LFfR94dohdxcKSP5NywdV6v2xz3w+LoVAA8qIAJKbEnvqu7l72 + 5d2y1X0/7MoOcW2xoKTvhbrTe4TWuiQKBSAvCkBSSvxp6ju7+9i3+BMF/nR1BnaIayjb5L1SLrC+xR9d + 8d+vlkChAORFAUhIib9H1dd/Sl1N/J2C7e774xp2iKvFAuoWUrmwhvIO4W+yLphCAciLApCMEj9BVfuX + qGcVP1XAT1zthh0i1s7PfiZ13h9LmddbhZ9pXSCFApAXBSARJT475U3dvVuU+FwBPntlFXbYOiU+jWq9 + H0jRFz7YYoEUCkBeFIAklDj839Ddt0WLTxbcx72u1tlhy2KhdAumXECLxkdcLohCAciLApCEcm5x35bh + E7Kfe20ts8NWxQKRtX4JxaK8zr1G9EuhAORFAUhAWeuXpS1K/HbBA9xrbJUdtigWRrdAygWzbPzay4Ep + FIC8KAAjp6z2a9KX5bNysHutLbLD1igHyWekXChj8Qr3mtEPhQKQFwVgxJRzins1JufJIe41t8YOWxIL + oVsQ5QIZm5e41456CgUgLwrASCkvKO7TGH1BDnOvvSV22IpYAN1CKBfGWL3IvQfUUSgAeVEARkh5TnGP + xuxLcoR7D62wwxbEje8WQLkgxu657r1gfgoFIC8KwMgozyjuTwZflaPce2mBHU5d3PDuxpcLIYtnufeE + +SgUgLwoACOinFXcm0xiDzjavaeps8Mpixvd3fByAWTzNPfesH4KBSAvCsBIKGcW9yWjb8gx7r1NmR1O + Vdzg7kaXNz6rJ7v3iPVRKAB5UQBGQHm8XNXdk8y+Kce69zhVdjhFcWO7G1ze8MzigXuCe6+YnUIByIsC + sGTK6TKFw3+n8+Vm7r1OkR1OjXJcd2PLGz0F8eA91r1nzEahAORFAVgi5TS5srsXU/Idubl7z1Njh1MS + N7K7oeUNnpJ4AB/t3jvWplAA8qIALIlyqlzR3Ycp+p6c4N77lNjhVMQN7G5keWOnKB7ER7hrgN1TKAB5 + UQCWQHmIXN7dgyn7F7mtuwZTYYdTEDdOfiDlDZ2yeCAf6q4FVqdQAPKiACyYcrJc1l3/FvxQ7uCuxRTY + YXbKHeUCKW9kC+LBfLC7JvAUCkBeFIAFUk6SS7tr35IfyV3cNcnODjNT7trdsPIGtiQe0Ae4a4NdKRSA + vCgAC6KcKBd3171FP5F7uGuTmR1mpdyzu1HljWvRJXJfd41wbQoFIC8KwAIo95CLumvesgvlPu4aZWWH + GSnRUFmk14hrcS93rXANhQKQFwVgYEr8iSr/T9U14k9B7u+uVUZ2mI0S/22q5T+eWk001ru5a4arKRSA + vCgAA1Li71K1/J9TVxN/wvogd82yscNMlPhbqS3+xZRZ/Vju5K4d4vJQABKjAAxEiZ+iir8Bv/Ka42rx + F64f4q5dJnaYhXJKdyPKG4NdxU9E3M5dw9YpFIC8KAADUOLzU+Jn4Fdeb1xb/Oj1w901zMIOM1Dik6ha + +DCKvsRnItzKXcuWKRSAvCgAPVPik1Nb+PC0vsSHsD3KXcsM7HDslPgM6il/DOVQvi+3cNe0VQoFIC8K + QI+U+J0pU/7Y9KHEx7E/xl3TsbPDMVPit09N8RdQLMp35Th3bVukUADyogD0RInfljrFX5i2KHEm/Tt3 + bcfMDsdKOUOm9KsnlyUe9Ju4a9wahQKQFwWgB8oxMqVflb4scTb9e3eNx8oOx0g5s7vA5QXH/L4lN3LX + uiUKBSAvCkAl5Wj5Rnc90Y+nums9RnY4NspZxcVFf+LBv4G75q1QKAB5UQAqKEcJ638YT3fXfGzscEyU + ZxQXFf37uhzlrn0LFDbAvCgAc1KOkK921xHD+A/u2o+JHY6FcnZxMTGcr8kR7h5MnUIByIsCMAflMPlS + dw0xrOe5ezAWdjgGyguLi4jhfVkOd/diyhQKQF4UgHVSDpEvdNcPi/Ef3b0YAztcNuWc4uJhcb4oh7h7 + MlUKBSAvCsA6KAfJed21w2K91N2TZbPDZVJeXlw0LF5sEAe7ezNFCgUgLwrAjJQD5DPddcNyvNLdm2Wy + w2VRXl1cLCzPZ+VAd4+mRqEA5EUBmIGyn3yqu2ZYrv/k7tGy2OGiKRvk3O4CYRw+Lfu7+zUlCgUgLwrA + GpR95OPd9cI4/J5scPdr0exwkeJCyBukvEAYh0/Ivu6+TYVCAciLArAbyl7y0e5aYVz+QDa6+7ZIdrgo + cQHkTVJeGIxLbCB7u/s3BQoFIC8KwCqUHfLh7jphnP5YlloC7HARlE3yFikvCMbpI7LD3cfsFApAXhQA + Q9kuH+yuEcbtP8smdx8XwQ6HpmyWt0t5ITBuH5Lt7n5mplAA8qIArKDsIR/org9y+FPZ7O7n0OxwSMoW + eaeUFwA5xMayh7uvWSkUgLwoAAVlq7yvuzbI5S9kq7uvQ7LDocQblHdL+caRS2wwC1+oQ1EoAHlRADpK + /D9W7+quC3J6j2xz93codjgEJf5oinY6DVHitrj7nI1CAciLAiBK/CdV/lR1Gv5SFvanrHbYNyX+Ugr/ + XWpaYsNZyn+36pNCAcir+QKgxF+mflt3PTANfy17uvvdNzvskxI/jsLfSJ2m+IucS/sbrH1QKAB5NV0A + lPgx6jd31wLT8jcy+E9e2WFflL2Fn0WdtvhRzqV/oMW8FApAXs0WACU+QI3PUJm2+PHrQT+DxQ77oMRH + UPIpVG2IjWgUH225XgoFIK8mC4DCp6e242My2Kex2mEtJX75RHyMbPlGMG2xIaUrAQoFIK9WCwC/N6Ut + n5RBfi+LHdZQDpT4RTLlG0AbznVrYswUCkBezRUA5VXF+0c74kzt/Te02uG8lIMlfpVs+cLRlle7tTFW + CgUgr6YKgPKy4r2jPZ+Tg93amJcdzkM5RM6T8gWjTS93a2SMFApAXs0UAOWc4n2jXZ+XQ90amYcdrpdy + uHxRyheKtp3j1srYKBSAvJooAMoLivcMxFl7uFsr62WH66EcIV+W8gUC4YVuzYyJQgHIa/IFQDm7eL/A + TnHmHunWzHrY4ayUo+RrUr4woHS2WztjoVAA8pp0AVCeUbxXYKU4e49ya2dWdjgL5QbC5olZPNOtoTFQ + WMN5TbYAKGcV7xNYzdflBm4NzcIO16LcSL4h5QsBducst5aWTaEA5DXJAqCcWbxHYC1xFt/IraW12OHu + KDeRb0n5AoBZnOnW1DIpFIC8JlcAlDPkqu79AbOKM/kmbk3tjh2uRjlOzpfyGwOzio3tDLe2lkWhAOQ1 + qQKgnC4c/phXnM3HubW1Gjt0lFvId6X8hsB6xQZ3ultjy6BQAPKaTAFQTpMru/cFzCvO6Fu4NebY4UrK + reT7Un4jYF6x0Z3m1tqiKRSAvCZRAJRT5YruPQG14qy+lVtrK9lhSbmN/EDKbwDUig3vVLfmFkmhAOSV + vgAop8jl3fsB+hJn9m3cmivZYUk5UvhZfwwhNr5T3LpbFIUCkFfqAqCcLJd17wXoU5zZa35QkB2upMQH + /sTPG5bfAOhDbIAnu3W3CAoFIK+0BUA5SS7t3gfQpzirZ/qAIDt0lPjgH372H0OIjfAkt+6GplAA8kpZ + AJQT5eLuPQB9ijN65g8GssPVKPEBQHwGAIYQG+KJbt0NSaEA5JWuACj3lIu61w/0Kc7mdX0gkB3ujhIf + BMRnAWAIsTHe0627oSgUgLxSFQDlrvKT7rUDfYozedgPAtpJOV74TAAMITbIu7p1NwSFApBXmgKg3FF+ + 1L1uoE9xFh/v1t1a7HAWSnwwEJ8NgCHERnlHt+76plAA8kpRAJTbygXdawb6FGfwzB/8s5IdzkqJDwji + MwIwhNgwb+vWXZ8UCkBeoy8AygnCHokhxLqa6QN/VmOH66HcTmi3GEL1Al+LQgHIa9QFQLm5fK97rUCf + 4sy9nVt362GH66XcSX4s5QsE+hAb6M3duuuDQgHIa7QFQIlfnPad7nUCfYqz9k5u3a2XHc5DuZtcKOUL + BfoQG+m6fsvVrBQKQF6jLADKsfHautcI9CnO2Lu5dTcPO5yXci/hZ1wxhLl+zGUtCgUgr9EVAOUY+Wb3 + +oA+xdl6L7fu5mWHNZT7yiVSvnCgD7GxHuPW3bwUCkBeoyoAytHCp6ViCHGm3tetuxp2WEt5gPA51xhC + bLBHu3U3D4UCkNdoCoASvy+FtYQhxFn6ALfuatlhH5QHC7/pCkOIjXamX3axlu5rrfz6yGEUBUA5Qr7a + vSagT3GGPtituz7YYV+Uhwq/6xpDiA33CLfu1kOhAOS19AKgHCZf6l4P0Kc4Ox/q1l1f7LBPyi/JFVK+ + MaAPsfEe5tbdrBQKQF5LLQDKIfKF7rUAfYoz85fcuuuTHfZNebRcKeUbBPoQG/Ahbt3NQqEA5LW0AqAc + LOd1rwPoU5yVj3brrm92OATlsXKVlG8U6ENsxAe5dbcWhQKQ11IKgHKAfKZ7DUCf4ox8rFt3Q7DDoShP + 6N5g+YaBPsSGfIBbd7ujUADyWngBUPaTT3XfH+hTnI1PcOtuKHY4JOXJ3ZsF+hYb835u3a1GoQDktdAC + oOwjH+++N9C3J7t1NyQ7HJrya8WbBvoUG/Q+bt05CgUgr4UVAGUv+Wj3fYG+/Zpbd0Ozw0VQnlW8eaBP + sVHv5dbdSgoFIK+FFABlh3y4+55A357l1t0i2OGiKL9RXASgT7Fh73DrrqRQAPIavAAo2+WD3fcD+vYb + bt0tih0ukvKi4mIAfYqNe7tbdzspFIC8Bi0Ayh7yge57AX17kVt3i2SHi6b8VnFRgD7FBr6HW3dBoQDk + NVgBULbK+7rvA/Ttt9y6WzQ7XAblFcXFAfr0Xtm6yrqjAOQ1SAFQtsi7uu8B9O0Vbt0tgx0ui/Ka4iIB + fYoNfYtZcxSAvHovAMpmeWf39YG+vcatu2Wxw2VSfre4WECfYmPfvGK9UQDy6rUAKJvkbd3XBvr2u27d + LZMdLpOyQf6gu2BA32KD31SsNwpAXr0VAGWjvKX7ukDf4kzb4NbeMtnhsinxMP6xlBcQ6MubZWO31igA + efVSAJT4fzre1H1NoG9xlv1svxkbOxyDuGDyVikvJNCXN0ps/BSAvKoLgBJr4A3d1wP6FmfYKA//YIdj + ocR/k3uHlBcU6Mvr5esrZsijjwJwbvH1gD7F2fVv/7lxjOxwTJT4W7l/IeWFBYCqAqC8qvhaQJ/izLrW + XzgeIzscGyV+Lvc9Ul5gAG2buwAoLyu+DtCnOKt2+ZHjMbLDMVK2yfulvNAA2jVXAVDOKb4G0Kc4o7a5 + dTdGdjhWSnw2919LecEBtGndBUB5QfHvA32Ks2nVjx0fIzscM2VP+RspLzyA9qyrAChnF/8u0Kc4k/Z0 + 627M7HDslPj93H8r5Q0A0JaZC4DyjOLfA/oUZ9Gav3p8jOwwA2Vv+ZiUNwJAO2YqAMpZxb8D9CnOoL3d + usvADrNQ9pVPSnlDALRhzQKgnFn880Cf4uzZ1627LOwwE2V/+TspbwyA6dttAVDOkKu6fxboU5w5+7t1 + l4kdZqMcKJ+T8gYBmLZVC4ByunD4Ywhx1hzo1l02dpiRcl35vJQ3CsB02QKgnCZXdv8M0Kc4Y67r1l1G + dpiVcqj8vZQ3DMA07VIAlFPliu5/B/oUZ8uhK9dcZnaYmXI9+YqUNw7A9FyrACinyOXd/wb0Kc6U65Xr + bQrsMDvlSPkHKW8ggGn5twKgnCyXdXOgT3GWHFmeMVNhh1OgXF/4Va/AdP2sACgnyaXdDOhTnCHXX3m+ + TIUdToVyQ/knKW8ogGk4X06Ui4sZ0Jc4O27ozpapsMMpUW4s35byxgLI7xK5aMUM6EOcGTd2Z8qU2OHU + KDeVf5byBgMAsFKcFTd1Z8nU2OEUKcfLd6W80QAA7BRnxPHuDJkiO5wq5ZbyfSlvOAAAcTbc0p0dU2WH + U6bcWn4o5Y0HALQrzoRbuzNjyuxw6pTbywVSLgAAQHviLLi9Oyumzg5boNxZfizlQgAAtCPOgDu7M6IF + dtgK5e5yoZQLAgAwfbH3392dDa2ww5Yo9xY+SAQA2hF7/r3dmdASO2yNcj+JDxUpFwgAYHpir7+fOwta + Y4ctUh4ofJ44AExX7PEPdGdAi+ywVcovCr9RDACmJ/b2X3R7f6vssGXKw+QKKRcOACCv2NMf5vb8ltlh + 65RHdgumXEAAgHxiL3+k2+tbZ4eINXOdx8iVUi4kAEAesYc/xu3x0OVxQ1xNeZxcJeWCAgCMX+zdj3N7 + O65mh7iG8sRuMQEA8nii29NxDTvEtSlPLRYVAGDcnur2clybHWJXytOLxQUAGKenuz0cu7JDeMqzi0UG + ABiXZ7u9G54dYnXK84rFBgAYh+e5PRurs0PsnvKbxaIDACzXb7q9Grtnh1ib8tJi8QEAluOlbo/G2uwQ + s1FeWSxCAMBivdLtzZiNHWJ2yu8UixEAsBi/4/ZkzM4OMTtlg/xetyABAMOLPXeD25MxOzvE+sRClD+U + coECAPoXey2Hfw/sEOunbJQ/kXKhAgD6E3vsRrcHY/3sEPNRNsl/kXLBAgDqxd66ye29mI8dYn7KZvlT + KRcuAGB+sadudnsu5meHqKNskf8q5QIGAKxf7KVb3F6LOnaIespW+W9SLmQAwOxiD93q9ljUs0P0Q9km + fynlggYArC32zm1ub0U/7BD9UbbL/5ByYQMAVhd75na3p6I/doh+KXvK/5RygQMAdhV75Z5uL0W/7BD9 + U/aSv5VyoQMArhF75F5uD0X/7BDDUPaR/y3lggcAXL037uP2TgzDDjEcZT/5P1IufABoWeyJ+7k9E8Ox + QwxLOUD+TsoHAABaFHvhAW6vxLDsEMNTDpL/K+WDAAAtiT3wILdHYnh2iMVQriv/T8oHAgBaEHvfdd3e + iMWwQyyOcpj8vZQPBgBMWex5h7k9EYtjh1gs5XryFSkfEACYotjrruf2QiyWHWLxlJ+Tf5DyQQGAKYk9 + 7ufcHojFs0Msh3K0/H8pHxgAmILY2452ex+Www6xPMox8k0pHxwAyCz2tGPcnoflsUMsl3KsfFvKBwgA + Moq97Fi312G57BDLp9xMviPlgwQAmcQedjO3x2H57BDjoPy8fE/KBwoAMoi96+fd3oZxsEOMh3KC/IuU + DxYAjFnsWSe4PQ3jYYcYF+U28kMpHzAAGKPYq27j9jKMix1ifJQ7yI+kfNAAYExij7qD28MwPnaIcVLu + Ij+R8oEDgDGIvekubu/CONkhxku5h1wo5YMHAMsUe9I93J6F8bJDjJtyH7lYygcQAJYh9qL7uL0K42aH + GD/l/nKJlA8iACxS7EH3d3sUxs8OkYPyILlMygcSABYh9p4Hub0JOdgh8lAeIpdL+WACwJBiz3mI25OQ + hx0iF+XhcoWUDygADCH2moe7vQi52CHyUR4lV0r5oAJAn2KPeZTbg5CPHSIn5Ve6B7R8YAGgD7G3/Irb + e5CTHSIv5fFylZQPLgDUiD3l8W7PQV52iNyUJ3UPLQD04Ulur0Fudoj8lF8tHl4AmNevuj0G+dkhpkH5 + 9eIhBoD1+nW3t2Aa7BDToTyneJgBYFbPcXsKpsMOMS3K84uHGgDW8ny3l2Ba7BDTo7y4eLgBYDUvdnsI + pscOMU3KbxcPOQCs9Ntu78A02SGmS3lV8bADwE6vcnsGpssOMW3Ka4uHHgBe6/YKTJsdYtqUDfL67sEH + 0LbYCza4vQLTZoeYvnjg5Y1SbgQA2hJ7AId/o+wQbVA2ypul3BAAtCGe/Y1ub0Ab7BDtUDbJ26TcGABM + Wzzzm9yegHbYIdqibJY/k3KDADBN8axvdnsB2mKHaI+yRd4l5UYBYFriGd/i9gC0xw7RJmWrvFfKDQPA + NMSzvdU9+2iTHaJdyjb571JuHAByi2d6m3vm0S47RNuU7fJBKTcQADnFs7zdPetomx0Cyg75sJQbCYBc + 4hne4Z5xwA6BoOwl/0vKDQVADvHs7uWebSDYIbCTso98XMqNBcC4xTO7j3umgZ3sECgp+8mnpNxgAIxT + PKv7uWcZKNkhsJJygHxGyo0GwLjEM3qAe4aBlewQcJSD5DwpNxwA4xDP5kHu2QUcOwRWoxwiX5By4wGw + XPFMHuKeWWA1dgjsjnKYfEnKDQjAcsSzeJh7VoHdsUNgLcoR8lUpNyIAixXP4BHuGQXWYofALJSj5B+l + 3JAALEY8e0e5ZxOYhR0Cs1KOlm9IuTEBGFY8c0e7ZxKYlR0C66EcI9+UcoMCMIx41o5xzyKwHnYIrJdy + rJwv5UYFoF/xjB3rnkFgvewQmIdynHxHyg0LQD/i2TrOPXvAPOwQmJdyc/melBsXgDrxTN3cPXPAvOwQ + qKGcID+QcgMDMJ94lk5wzxpQww6BWspt5QIpNzIA6xPP0G3dMwbUskOgD8od5UdSbmgAZhPPzh3dswX0 + wQ6Bvih3lZ9IubEB2L14Zu7qnimgL3YI9Em5p1wk5QYHwItn5Z7uWQL6ZIdA35QT5WIpNzoA1xbPyInu + GQL6ZofAEJST5FIpNzwAV4tn4yT37ABDsENgKMrJcpmUGx/QungmTnbPDDAUOwSGpJwil0u5AQKtimfh + FPesAEOyQ2BoyqlyhZQbIdCaeAZOdc8IMDQ7BBZBOU2ulHJDBFoRa/8092wAi2CHwKIop8tVUm6MwNTF + mj/dPRPAotghsEjKGd2GWG6QwFTFWj/DPQvAItkhsGjKmd3mCEzdme4ZABbNDoFlUM4qNklgis5yax9Y + BjsElkV5ZrFZAlPyTLfmgWWxQ2CZlLOLTROYgrPdWgeWyQ6BZVNeWGyeQGYvdGscWDY7BMZAOafYRIGM + znFrGxgDOwTGQnl5sZkCmbzcrWlgLOwQGBPl1cWmCmTwareWgTGxQ2BslHOLzRUYs3PdGgbGxg6BsVE2 + yBu6DRYYq1ijG9waBsbGDoExio1V3iTlhguMRaxNDn+kYYfAWCkb5S1SbrzAssWa3OjWLDBWdgiMmbJJ + 3i7lBgwsS6zFTW6tAmNmh8DYKZvlnVJuxMCixRrc7NYoMHZ2CGSgbJF3S7khA4sSa2+LW5tABnYIZKFs + lfdJuTEDQ4s1t9WtSSALOwQyUfaQD0i5QQNDibW2h1uLQCZ2CGSjbJcPSblRA32LNbbdrUEgGzsEMlJ2 + yIel3LCBvsTa2uHWHpCRHQJZKXvLR6XcuIFasab2dmsOyMoOgcyUfeUTUm7gwLxiLe3r1hqQmR0C2Sn7 + y6el3MiB9Yo1tL9bY0B2dghMgXKgfFbKDR2YVaydA93aAqbADoGpUA6W86Tc2IG1xJo52K0pYCrsEJgS + 5RD5opQbPLCaWCuHuLUETIkdAlOjHC5flnKjB1aKNXK4W0PA1NghMEXKEfI1KTd8YKdYG0e4tQNMkR0C + U6UcJV+XcuMHYk0c5dYMMFV2CEyZcgP5hpQHANoVa+EGbq0AU2aHwNQpN5JvSXkQoD2xBm7k1ggwdXYI + tEC5iZwv5YGAdsS9v4lbG0AL7BBohXKcfFfKgwHTF/f8OLcmgFbYIdAS5RbyfSkPCExX3OtbuLUAtMQO + gdYot5IfSHlQYHriHt/KrQGgNXYItEi5nVwg5YGB6Yh7ezt374EW2SHQKuVO8mMpDw7kF/f0Tu6eA62y + Q6Blyt3kQikPEOQV9/Ju7l4DLbNDoHXKveQiKQ8S5BP38F7uHgOts0MAcXZc575yiZQHCvKIe3dfd28B + 6BFxQwBXUx4gl0p5sGD84p49wN1TAFezQwDXUB4sl0l5wGC84l492N1LANewQwDXpjxULpfyoMH4xD16 + qLuHAK7NDgHsSnmEXCHlgYPxiHvzCHfvAOzKDgF4yqPlSikPHixf3JNHu3sGwLNDAKtTHitXSXkAYXni + XjzW3SsAq7NDALunPKE7eMqDCIsX9+AJ7h4B2D07BLA25cndIYTlebK7NwDWZocAZqM8rTiMsFhPc/cE + wGzsEMDslGcVhxIW41nuXgCYnR0CWB/lucXhhGE9190DAOtjhwDWT3lRcUhhGC9y1x7A+tkhgPkoLykO + K/TrJe6aA5iPHQKYn/KK4tBCP17hrjWA+dkhgDrKa4rDC3Ve464xgDp2CKCe8rriEMN8XueuLYB6dgig + nrJBfr87yLB+ce02uGsLoJ4dAuiHslH+SMqDDWuLa7bRXVMA/bBDAP2Jg0zeKuUBh9XFteLwBwZmhwD6 + pWySd0h50GFXcY02uWsIoF92CKB/ymb5cykPPFwjrs1md+0A9M8OAQxD2SLvkfLgw9XXZIu7ZgCGYYcA + hqNsk/dLeQC2LK7FNnetAAzHDgEMS9lD/krKg7BFcQ32cNcIwLDsEMDwlD3lQ1IeiC2J976nuzYAhmeH + ABZD2SEfkfJgbEG85x3umgBYDDsEsDjK3vIxKQ/IKYv3ure7FgAWxw4BLJayr3xSyoNyiuI97uuuAYDF + skMAi6fsL5+W8sCcknhv+7v3DmDx7BDAcigHyuekPDinIN7Tge49A1gOOwSwPMrB8nkpD9DM4r0c7N4r + gOWxQwDLpRwqX5TyIM0o3sOh7j0CWC47BLB8yuHyZSkP1Ey+Ioe79wZg+ewQwDgoR8rXpDxYM4jXfKR7 + TwDGwQ4BjIdyffm6lAfsmMVrvb57LwDGww4BjItyQ/knKQ/aMYrXeEP3HgCMix0CGB/lxvItKQ/cMfm2 + 3Ni9dgDjY4cAxkm5qfyzlAfvGMRruql7zQDGyQ4BjJdyvHxXygN4meK1HO9eK4DxskMA46bcUr4v5UG8 + DPEabuleI4Bxs0MA46fcWn4g5YG8SD+UW7vXBmD87BBADsrt5QIpD+ZFiO95e/eaAORghwDyUO4sP5by + gB5SfK87u9cCIA87BJCLcne5UMqDegjxPe7uXgOAXOwQQD7KveUiKQ/sPl0s93bfG0A+dgggJ+V+comU + B3cf4mvez31PADnZIYC8lAfKpVIe4DXiaz3QfS8AedkhgNyUX5DLpDzI5xFf4xfc9wCQmx0CyE95mFwu + 5YG+HlfIw9zXBpCfHQKYBuWR3UFeHuyziH/nke5rApgGOwQwHcovy5VSHvC7E//sL7uvBWA67BDAtCiP + k6ukPOid+Gce574GgGmxQwDTozyxO+DLA3+lJ7p/F8D02CGAaVKeUhz2Kz3F/TsApskOAUyX8vTi0N/p + 6e6fBTBddghg2pRnF4f/s90/A2Da7BDA9CnPC+5/AzB1P73OvwImufEndv3fiwAAAABJRU5ErkJggg== + + + \ No newline at end of file diff --git a/ProjectOOP/ProjectOOP/Program.cs b/ProjectOOP/ProjectOOP/Program.cs index bd9209a..8f2a1e8 100644 --- a/ProjectOOP/ProjectOOP/Program.cs +++ b/ProjectOOP/ProjectOOP/Program.cs @@ -11,7 +11,7 @@ namespace ProjectOOP // To customize application configuration such as set high DPI settings or default font, // see https://aka.ms/applicationconfiguration. ApplicationConfiguration.Initialize(); - Application.Run(new Form1()); + Application.Run(new FormCruiser()); } } } \ No newline at end of file diff --git a/ProjectOOP/ProjectOOP/ProjectOOP.csproj b/ProjectOOP/ProjectOOP/ProjectOOP.csproj index 663fdb8..af03d74 100644 --- a/ProjectOOP/ProjectOOP/ProjectOOP.csproj +++ b/ProjectOOP/ProjectOOP/ProjectOOP.csproj @@ -8,4 +8,19 @@ enable + + + True + True + Resources.resx + + + + + + ResXFileCodeGenerator + Resources.Designer.cs + + + \ No newline at end of file diff --git a/ProjectOOP/ProjectOOP/Properties/Resources.Designer.cs b/ProjectOOP/ProjectOOP/Properties/Resources.Designer.cs new file mode 100644 index 0000000..2520dec --- /dev/null +++ b/ProjectOOP/ProjectOOP/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// Этот код создан программой. +// Исполняемая версия:4.0.30319.42000 +// +// Изменения в этом файле могут привести к неправильной работе и будут потеряны в случае +// повторной генерации кода. +// +//------------------------------------------------------------------------------ + +namespace ProjectOOP.Properties { + using System; + + + /// + /// Класс ресурса со строгой типизацией для поиска локализованных строк и т.д. + /// + // Этот класс создан автоматически классом StronglyTypedResourceBuilder + // с помощью такого средства, как ResGen или Visual Studio. + // Чтобы добавить или удалить член, измените файл .ResX и снова запустите ResGen + // с параметром /str или перестройте свой проект VS. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Возвращает кэшированный экземпляр ResourceManager, использованный этим классом. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("ProjectOOP.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Перезаписывает свойство CurrentUICulture текущего потока для всех + /// обращений к ресурсу с помощью этого класса ресурса со строгой типизацией. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + } +} diff --git a/ProjectOOP/ProjectOOP/Form1.resx b/ProjectOOP/ProjectOOP/Properties/Resources.resx similarity index 100% rename from ProjectOOP/ProjectOOP/Form1.resx rename to ProjectOOP/ProjectOOP/Properties/Resources.resx