From d1ed841a1f65eb78da879a12655a5a6b852875b1 Mon Sep 17 00:00:00 2001 From: maxim24052002 Date: Tue, 19 Dec 2023 00:39:32 +0300 Subject: [PATCH 1/3] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2=D0=BB?= =?UTF-8?q?=D0=B5=D0=BD=D0=B8=D0=B5=20=D0=BE=D1=88=D0=B8=D0=B1=D0=BE=D0=BA?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Sailboat/Sailboat/Direction.cs | 29 + Sailboat/Sailboat/DrawingSailboat.cs | 159 +++ Sailboat/Sailboat/EntitySailboat.cs | 59 + Sailboat/Sailboat/FormSailboat.Designer.cs | 144 ++ Sailboat/Sailboat/FormSailboat.cs | 63 + Sailboat/Sailboat/FormSailboat.resx | 1165 +++++++++++++++++ Sailboat/Sailboat/Program.cs | 2 +- .../Sailboat/Properties/Resources.Designer.cs | 63 + Sailboat/Sailboat/Properties/Resources.resx | 120 ++ Sailboat/Sailboat/Resources/arrowDown.jpg | Bin 0 -> 62022 bytes Sailboat/Sailboat/Resources/arrowLeft.jpg | Bin 0 -> 61872 bytes Sailboat/Sailboat/Resources/arrowRight.jpg | Bin 0 -> 61715 bytes Sailboat/Sailboat/Resources/arrowUp.jpg | Bin 0 -> 62105 bytes Sailboat/Sailboat/Sailboat.csproj | 15 + 14 files changed, 1818 insertions(+), 1 deletion(-) create mode 100644 Sailboat/Sailboat/Direction.cs create mode 100644 Sailboat/Sailboat/DrawingSailboat.cs create mode 100644 Sailboat/Sailboat/EntitySailboat.cs create mode 100644 Sailboat/Sailboat/FormSailboat.Designer.cs create mode 100644 Sailboat/Sailboat/FormSailboat.cs create mode 100644 Sailboat/Sailboat/FormSailboat.resx create mode 100644 Sailboat/Sailboat/Properties/Resources.Designer.cs create mode 100644 Sailboat/Sailboat/Properties/Resources.resx create mode 100644 Sailboat/Sailboat/Resources/arrowDown.jpg create mode 100644 Sailboat/Sailboat/Resources/arrowLeft.jpg create mode 100644 Sailboat/Sailboat/Resources/arrowRight.jpg create mode 100644 Sailboat/Sailboat/Resources/arrowUp.jpg diff --git a/Sailboat/Sailboat/Direction.cs b/Sailboat/Sailboat/Direction.cs new file mode 100644 index 0000000..46e7fda --- /dev/null +++ b/Sailboat/Sailboat/Direction.cs @@ -0,0 +1,29 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Sailboat +{ + public enum DirectionType + { + /// + /// Вверх + /// + Up = 1, + /// + /// Вниз + /// + Down = 2, + /// + /// Влево + /// + Left = 3, + /// + /// Вправо + /// + Right = 4 + + } +} diff --git a/Sailboat/Sailboat/DrawingSailboat.cs b/Sailboat/Sailboat/DrawingSailboat.cs new file mode 100644 index 0000000..1a40654 --- /dev/null +++ b/Sailboat/Sailboat/DrawingSailboat.cs @@ -0,0 +1,159 @@ +using System; +using System.Collections.Generic; +using System.Drawing; +using System.Linq; +using System.Reflection; +using System.Text; +using System.Threading.Tasks; + +namespace Sailboat +{ + public class DrawingSailboat + { + public EntitySailboat? EntitySailboat { get; private set; } + private int _pictureWidth; + private int _pictureHeight; + private int _startPosX; + private int _startPosY; + private readonly int _boatWidth = 160; + private readonly int _boatHeight = 160; + public bool Init(int speed, double weight, Color bodyColor, Color additionalColor, bool hull, bool sail, int width, int height) + { + if (width < _boatWidth || height < _boatHeight) + { + return false; + } + _pictureWidth = width; + _pictureHeight = height; + EntitySailboat = new EntitySailboat(); + EntitySailboat.Init(speed, weight, bodyColor, additionalColor, hull, sail); + return true; + } + public void SetPosition(int x, int y) + { + if (x < 0 || x + _boatWidth > _pictureWidth) + { + x = 0; + } + if (y < 0 || y + _boatHeight > _pictureHeight) + { + y = 0; + } + _startPosX = x; + _startPosY = y; + } + public void MoveTransport(DirectionType direction) + { + if (EntitySailboat == null) + { + return; + } + switch (direction) + { + case DirectionType.Left: + if (_startPosX - EntitySailboat.Step > 0) + { + _startPosX -= (int)EntitySailboat.Step; + } + break; + case DirectionType.Up: + if ((_startPosY - 15) - EntitySailboat.Step > 0) + { + _startPosY-= (int)EntitySailboat.Step; + } + break; + case DirectionType.Right: + if (_startPosX + EntitySailboat.Step + _boatWidth < _pictureWidth) + { + _startPosX += (int)EntitySailboat.Step; + } + break; + case DirectionType.Down: + if (_startPosY + EntitySailboat.Step + _boatHeight < _pictureHeight) + { + _startPosY += (int)EntitySailboat.Step; + } + break; + } + } + public void DrawTransport(Graphics g) + { + if (EntitySailboat == null) + { + return; + } + Pen pen = new(Color.Black, 4); + Brush additionalBrush = new + SolidBrush(EntitySailboat.AdditionalColor); + + //Усиленный корпус парусной лодки + if (EntitySailboat.Hull) + { + Point[] hullCooler = new Point[] + { + new Point(_startPosX, _startPosY + 80), + new Point(_startPosX + 120, _startPosY + 80), + new Point(_startPosX + 160, _startPosY + 120), + new Point(_startPosX + 120, _startPosY + 160), + new Point(_startPosX, _startPosY + 160) + }; + g.FillPolygon(additionalBrush, hullCooler); + g.DrawPolygon(pen, hullCooler); + } + + //Основной корпус парусной лодки + Brush Brush = new + SolidBrush(EntitySailboat.BodyColor); + + Point[] hull = new Point[] + { + new Point(_startPosX + 10, _startPosY + 90), + new Point(_startPosX + 110, _startPosY + 90), + new Point(_startPosX + 140, _startPosY + 120), + new Point(_startPosX + 110, _startPosY + 150), + new Point(_startPosX + 10, _startPosY + 150) + }; + g.FillPolygon(Brush, hull); + g.DrawPolygon(pen, hull); + + Brush addBrush = new + SolidBrush(Color.Aqua); + + //Каюта парусной лодки + g.FillEllipse(addBrush, _startPosX + 20, _startPosY + 100, 90, 40); + g.DrawEllipse(pen, _startPosX + 20, _startPosY + 100, 90, 40); + + //Парус с флагом + if (EntitySailboat.Sail) + { + Brush sailBrush = new + SolidBrush(EntitySailboat.AdditionalColor); + + Point[] sail = new Point[] + { + new Point(_startPosX + 65, _startPosY), + new Point(_startPosX + 130, _startPosY + 120), + new Point(_startPosX + 15, _startPosY + 120) + }; + g.FillPolygon(sailBrush, sail); + g.DrawPolygon(pen, sail); + //Флаг + Brush flagBrush = new + SolidBrush(EntitySailboat.AdditionalColor); + Point[] flag = new Point[] + { + //new Point(_startPosX + 65, _startPosY + 125), + new Point(_startPosX + 65, _startPosY - 15), + new Point(_startPosX + 65, _startPosY + 10), + new Point(_startPosX + 20, _startPosY + 10), + new Point(_startPosX + 20, _startPosY - 15), + }; + g.FillPolygon(addBrush, flag); + g.DrawPolygon(pen, flag); + g.DrawLine(pen, new Point(_startPosX + 65, _startPosY + 130), new Point(_startPosX + 65, _startPosY - 15)); + + + } + } + } +} \ No newline at end of file diff --git a/Sailboat/Sailboat/EntitySailboat.cs b/Sailboat/Sailboat/EntitySailboat.cs new file mode 100644 index 0000000..6514ebd --- /dev/null +++ b/Sailboat/Sailboat/EntitySailboat.cs @@ -0,0 +1,59 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Sailboat +{ + public class EntitySailboat + { + /// + /// Скорость + /// + 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 Hull { get; private set; } + /// + /// Признак (опция) наличия паруса с флагом + /// + public bool Sail { get; private set; } + /// + /// Шаг перемещения парусной лодки + /// + public double Step => (double)Speed * 100 / Weight; + /// + /// Инициализация полей объекта-класса парусной лодки + /// + /// Скорость + /// Вес парусной лодки + /// Основной цвет + /// Дополнительный цвет + /// Признак наличия усиленного корпуса + /// Признак наличия паруса с флагом + public void Init(int speed, double weight, Color bodyColor, Color + additionalColor, bool hull, bool sail) + { + Speed = speed; + Weight = weight; + BodyColor = bodyColor; + AdditionalColor = additionalColor; + Hull = hull; + Sail = sail; + } + } +} diff --git a/Sailboat/Sailboat/FormSailboat.Designer.cs b/Sailboat/Sailboat/FormSailboat.Designer.cs new file mode 100644 index 0000000..8acd590 --- /dev/null +++ b/Sailboat/Sailboat/FormSailboat.Designer.cs @@ -0,0 +1,144 @@ +namespace Sailboat +{ + partial class FormSailboat + { + /// + /// 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(FormSailboat)); + pictureBoxSailboat = new PictureBox(); + buttonCreate = new Button(); + buttonLeft = new Button(); + buttonUp = new Button(); + buttonRight = new Button(); + buttonDown = new Button(); + ((System.ComponentModel.ISupportInitialize)pictureBoxSailboat).BeginInit(); + SuspendLayout(); + // + // pictureBoxSailboat + // + pictureBoxSailboat.Dock = DockStyle.Fill; + pictureBoxSailboat.Location = new Point(0, 0); + pictureBoxSailboat.Margin = new Padding(3, 2, 3, 2); + pictureBoxSailboat.Name = "pictureBoxSailboat"; + pictureBoxSailboat.Size = new Size(884, 461); + pictureBoxSailboat.TabIndex = 0; + pictureBoxSailboat.TabStop = false; + // + // buttonCreate + // + buttonCreate.Anchor = AnchorStyles.Bottom | AnchorStyles.Left; + buttonCreate.Location = new Point(10, 417); + buttonCreate.Margin = new Padding(3, 2, 3, 2); + buttonCreate.Name = "buttonCreate"; + buttonCreate.Size = new Size(111, 30); + buttonCreate.TabIndex = 1; + buttonCreate.Text = "Создать"; + buttonCreate.UseVisualStyleBackColor = true; + buttonCreate.Click += buttonCreate_Click; + // + // buttonLeft + // + buttonLeft.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonLeft.BackgroundImage = (Image)resources.GetObject("buttonLeft.BackgroundImage"); + buttonLeft.BackgroundImageLayout = ImageLayout.Zoom; + buttonLeft.Location = new Point(740, 423); + buttonLeft.Margin = new Padding(3, 2, 3, 2); + buttonLeft.Name = "buttonLeft"; + buttonLeft.Size = new Size(30, 30); + buttonLeft.TabIndex = 2; + buttonLeft.UseVisualStyleBackColor = true; + buttonLeft.Click += buttonMove_Click; + // + // buttonUp + // + buttonUp.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonUp.BackgroundImage = (Image)resources.GetObject("buttonUp.BackgroundImage"); + buttonUp.BackgroundImageLayout = ImageLayout.Zoom; + buttonUp.Location = new Point(776, 389); + buttonUp.Margin = new Padding(3, 2, 3, 2); + buttonUp.Name = "buttonUp"; + buttonUp.Size = new Size(30, 30); + buttonUp.TabIndex = 3; + buttonUp.UseVisualStyleBackColor = true; + buttonUp.Click += buttonMove_Click; + // + // buttonRight + // + buttonRight.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonRight.BackgroundImage = (Image)resources.GetObject("buttonRight.BackgroundImage"); + buttonRight.BackgroundImageLayout = ImageLayout.Zoom; + buttonRight.Location = new Point(812, 423); + buttonRight.Margin = new Padding(3, 2, 3, 2); + buttonRight.Name = "buttonRight"; + buttonRight.Size = new Size(30, 30); + buttonRight.TabIndex = 4; + buttonRight.UseVisualStyleBackColor = true; + buttonRight.Click += buttonMove_Click; + // + // buttonDown + // + buttonDown.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonDown.BackgroundImage = (Image)resources.GetObject("buttonDown.BackgroundImage"); + buttonDown.BackgroundImageLayout = ImageLayout.Zoom; + buttonDown.Location = new Point(776, 423); + buttonDown.Margin = new Padding(3, 2, 3, 2); + buttonDown.Name = "buttonDown"; + buttonDown.Size = new Size(30, 30); + buttonDown.TabIndex = 5; + buttonDown.UseVisualStyleBackColor = true; + buttonDown.Click += buttonMove_Click; + // + // FormSailboat + // + AutoScaleDimensions = new SizeF(7F, 15F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(884, 461); + Controls.Add(buttonDown); + Controls.Add(buttonRight); + Controls.Add(buttonUp); + Controls.Add(buttonLeft); + Controls.Add(buttonCreate); + Controls.Add(pictureBoxSailboat); + Margin = new Padding(3, 2, 3, 2); + Name = "FormSailboat"; + StartPosition = FormStartPosition.CenterParent; + Text = "Sailboat"; + Load += FormSailboat_Load; + ((System.ComponentModel.ISupportInitialize)pictureBoxSailboat).EndInit(); + ResumeLayout(false); + } + + #endregion + + private PictureBox pictureBoxSailboat; + private Button buttonCreate; + private Button buttonLeft; + private Button buttonUp; + private Button buttonRight; + private Button buttonDown; + } +} \ No newline at end of file diff --git a/Sailboat/Sailboat/FormSailboat.cs b/Sailboat/Sailboat/FormSailboat.cs new file mode 100644 index 0000000..50e8592 --- /dev/null +++ b/Sailboat/Sailboat/FormSailboat.cs @@ -0,0 +1,63 @@ +namespace Sailboat +{ + public partial class FormSailboat : Form + { + private DrawingSailboat? _drawingSailboat; + public FormSailboat() + { + InitializeComponent(); + } + private void Draw() + { + if (_drawingSailboat == null) + { + return; + } + Bitmap bmp = new(pictureBoxSailboat.Width, + pictureBoxSailboat.Height); + Graphics gr = Graphics.FromImage(bmp); + _drawingSailboat.DrawTransport(gr); + pictureBoxSailboat.Image = bmp; + } + private void buttonCreate_Click(object sender, EventArgs e) + { + Random random = new(); + _drawingSailboat = new DrawingSailboat(); + _drawingSailboat.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)), pictureBoxSailboat.Width, pictureBoxSailboat.Height); + _drawingSailboat.SetPosition(random.Next(10, 100), random.Next(10, 100)); + Draw(); + } + private void buttonMove_Click(object sender, EventArgs e) + { + if (_drawingSailboat == null) + { + return; + } + string name = ((Button)sender)?.Name ?? string.Empty; + switch (name) + { + case "buttonUp": + _drawingSailboat.MoveTransport(DirectionType.Up); + break; + case "buttonDown": + _drawingSailboat.MoveTransport(DirectionType.Down); + break; + case "buttonLeft": + _drawingSailboat.MoveTransport(DirectionType.Left); + break; + case "buttonRight": + _drawingSailboat.MoveTransport(DirectionType.Right); + break; + } + Draw(); + + } + + private void FormSailboat_Load(object sender, EventArgs e) + { + + } + } +} \ No newline at end of file diff --git a/Sailboat/Sailboat/FormSailboat.resx b/Sailboat/Sailboat/FormSailboat.resx new file mode 100644 index 0000000..c84c464 --- /dev/null +++ b/Sailboat/Sailboat/FormSailboat.resx @@ -0,0 +1,1165 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + /9j/4AAQSkZJRgABAQEASABIAAD/4R0ARXhpZgAATU0AKgAAAAgABQESAAMAAAABAAEAAAExAAIAAAAm + AAAASgEyAAIAAAAUAAAAcIdpAAQAAAABAAAAhIglAAQAAAABAAAA8AAAAShXaW5kb3dzIFBob3RvIEVk + aXRvciAxMC4wLjEwMDExLjE2Mzg0ADIwMjM6MDk6MTIgMjA6MDg6MTgAAAWQAwACAAAAFAAAAMaQBAAC + AAAAFAAAANqSkQACAAAAAzAwAACSkgACAAAAAzAwAACgAQADAAAAAQABAAAAAAAAMjAyMzowOToxMiAx + OToyMjowMgAyMDIzOjA5OjEyIDE5OjIyOjAyAAAAAAEACwACAAAAJgAAAQIAAAAAV2luZG93cyBQaG90 + byBFZGl0b3IgMTAuMC4xMDAxMS4xNjM4NAAABgEDAAMAAAABAAYAAAEaAAUAAAABAAABdgEbAAUAAAAB + AAABfgEoAAMAAAABAAIAAAIBAAQAAAABAAABhgICAAQAAAABAAAbcQAAAAAAAABgAAAAAQAAAGAAAAAB + /9j/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0 + Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIy + MjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAEAAQADASEAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAA + AAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0Kx + wRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4 + eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl + 5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQD + BAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygp + KjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOk + paanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIR + AxEAPwD26igC9F/qk/3RT6AKM/8Ar3/D+VMoAtWv+rb61PQBWu/4PxqvQBLbf638KuUARz/6lqpUAA+8 + PrWjQAVnH7x+tABV2D/UrQBJVO5/134CgCKrFp/H+FAFmoLr/Vr9aAKtPg/16fj/ACoAvUyX/VP/ALpo + Ao0UAFFAF6L/AFSf7op9AFGf/Xv+H8qZQBatf9W3+9U9AFa7/g/Gq9AEtt/rfwNXKAI5/wDUtVKgAH3h + 9a0aACs4/eP1oAKuwf6laAJKp3P+u/AUARVYtP4/woAs1Bdf6tf96gCrT4P9en4/yoAvUyX/AFT/AO6a + AKNFAF7yo/8Anmv5UeVH/wA81/KgCmzMHYBmABIABpN7/wB9v++jQBahRWiDMoZjnJIyaf5Uf/PNfyoA + rz5STCEqMdF4qLe/99v++jQBNb/vC2/5sDjdzU/lR/8APNfyoAjnUJGCgCnPVeKrb3/vt/30aAHRszSK + GYkE8gmrflR/881/KgBGjQKSEXp6VT3v/fb/AL6NABvf++3/AH0auLGhUEovT0oAXyo/+ea/lVSRmWRl + ViADwAcUAN3v/fb/AL6NWYFDxkuAxz1bmgCTyo/+ea/lUFx+7K7PlyOdvFAEO9/77f8AfRqWDLyYclhj + o3NAFjyo/wDnmv5UyZFWIsqhWGMEDBoAq73/AL7f99GlVmLqCzEEgEE0AXPKj/55r+VHlR/881/KgB9F + AGe/+sb/AHj/ADpKALlv/qF/H+dS0AVLr/Wj/dqHtQBPafeb6CrVAENz/qh9aqUAPh/1y/Wr1ACP9xvp + WdQAVop9xfpQAtUZv9c31oAZVu2/1R+tAE1Vbv7y/Q0AQVNa/wCtP+7QBbqK4/1Dfh/OgCnSp/rF/wB4 + fzoA0KKAKXny/wB/9BSefL/f/QUAWEhjdFZlyzDJOTS/Z4v7v6mgCB3eKQojYUdBim+fL/f/AEFAEsSi + dS0nzMDjPSpPs8X939TQBFKPI2+V8u7r3qPz5f7/AOgoAfGzTPtkO5euOlTfZ4v7v6mgBskSRoXQYYdD + moPPl/v/AKCgBfOlJwX4PB4FWPs8X939TQAfZ4v7v6mq/nSg4D8DgcCgBPPl/v8A6Cp44kkQO4yx6nNA + Dvs8X939TUMjNC+2M7V6460AM8+X+/8AoKkiHn7vN+bb07UAS/Z4v7v6mo5VECho/lYnGetAEXny/wB/ + 9BTkd5ZAjtlT1GKAJ/s8X939TSPDGiMyrhlGQcmgCv58v9/9BS+fL/f/AEFAEdFAF6L/AFSf7op9AFGf + /Xv+H8qZQBatf9W3+9U9AFa7/g/Gq9AEtt/rfwq5QBHP/qWrH1LUrPSNPmv9QuI7e1gXdJI54A/qfagD + z63+O/g2bUFtm/tKGPdgXEkC+X9ThiwH4V6xb3EN1BHPBIskMih0dTkMD0IoAlrOP3j9aACrsH+pWgCS + qdz/AK78BQBFVi0/j/CgCzUF1/q1/wB6gCrT4P8AXp+P8qAL1Ml/1T/7poAo0UAWvsqf3mo+yp/eagCP + z3Q7AFwpwM+1H2qT0X8qAHLEJ18xiQzdcdKd9lT+81AEbMbZtiYIIz81H2mT0X8qAFXNyfn429NtP+yp + /eagBrJ9nAdCSc45pv2qT0X8qAKep61a6Vps99qU8dvZwrukkbsP6n2718p/Ej4jXvjbUgkRe30iBj9n + t8/e/wBt/Vv5fnkA4Tcc5r62+DN7PL8K9JZ2DFWmjXPZRIwAoA7z7VJ6L+VSC2VgGLNzzQAv2VP7zVGZ + niJjXBC8DNAB9qk9F/KnKn2gF3JBzjigB32VP7zUxs2x+Tnd13UAJ9pk9F/KhWNy2x8AAZ+WgCT7Kn95 + qa0QgXzFJLL0z0oAb9qk9F/Kjz3c7CFwxwce9AEn2VP7zUfZU/vNQBPRQBnv/rG/3j/OkoAuW/8AqF/H + +dS0AVLr/Wj/AHahoAntOrfQVaoAhuf9UP8AerJ1LUrLR9Pnv9RuUt7WBd0kj9vw9fbvQB8r/Ef4j3nj + i/8ALj32+kwNm3tieSf779i3X6Z+prhKACvq/wCCv/JKdL/66z/+jGoA7+tBPuL9KAFqjN/rm+tADKt2 + 3+qP1oAmqrd9V+hoAgqa1/1p/wB2gC3UVx/qG/D+dAFOlT/WL/vD+dAGhRQBW+1f9M/1o+1/9M/1oAT7 + OZPn3AbucY9aPsp/vj8qAAS+R+627tvfNL9r/wCmf60AJtNyd4O3HGOtH2U/3x+VABzanJ+bd+FL9r/6 + Z/rQBS1fWLLTNLmvtRmW2tYF3ySMeB7e5PbFfKXxH+I95421Lyot0GkQMfs9vnqf77erfoB+dAHB0UAF + fWfwQiMvwo0zDYxLP2/6aNQB6F9kP98flSi52jbszjjrQAfa/wDpn+tJ5Jm/ebsbucYoAPsp/vj8qA5t + spjd3znFAC/a/wDpn+tJzdHI+Xb+NAB9lP8AfH5UbTbHeTuzxjpQAv2v/pn+tIZfP/dbdu7vmgA+yn++ + Pyo+zmP59wO3nGPSgBftf/TP9aPtX/TP9aAK9FAF6L/VJ/uin0AUZ/8AXv8Ah/KmUAWrX/Vt/vVPQBWu + /wCD8azNT1Oz0bTZ9R1C4S3tYELu7n9B6k9MdTmgD5Y+I/xGvfG+oCOIvb6RAx+z2+fvf7b+rH9Pzrgy + SetABRQAV9cfAr/kk+m/9dZ//RjUAej1nH7x+tABV2D/AFK0ASVTuf8AXfgKAIqsWn8f4UAWaguv9Wv+ + 9QBVp8H+vT8f5UAXqZL/AKp/900AUaKAJfs8n+z+dH2aT/Z/OgCRZ0RQhDZUYPFL9qT0b8qAI2jaZjIm + Np6ZNJ9mk/2fzoAeji3BRwcnninfak9G/KgChrOrWOmadLqF9cLb2tupaSR/5D1PtXyl8R/iPeeNtRMU + e+30mBv9Ht8/e/239WP6dPegDg6KACigAr60+B0qx/CjTN2eZZ+n/XRqAPRPtUfo35VF9nkPIxg89aAD + 7NJ/s/nUizLEoRgdy8HFAC/ak9G/Ko2Vp23p06c0AJ9mk/2fzpyH7OT5g+90xQA/7Uno35U13FwAiA5H + PNADPs0n+z+dKsbQsJHxtHXBoAk+1J6N+VI06OpQBssMDigCP7NJ/s/nR9nk/wBn86ALlFAGe/8ArG/3 + j/OkoAuW/wDqF/H+dS0AVLr/AFo/3aztS1K00fTZ9R1Cdbe0t13SSN2/xPTA70AfK/xH+I97431Hy499 + vpELfuLfP3u29/Vv5fnXCE5OaACigAooAK95+GvxV8LeGPAtjpGpzXS3ULyswjg3jDOSOc+hoA6z/hen + gf8A5+b/AP8AAU/41ZHx98DBQPPvuB/z6n/GgBf+F/eBv+e99/4Cn/Gq7/HbwOzlvtF9yf8An1P+NADf + +F6eB/8An5v/APwFP+NTRfHrwNGmPtF91z/x6n/GgCT/AIX94G/5733/AICn/Gopvjx4HkI/0i+GP+nU + /wCNAEX/AAvTwP8A8/N//wCAp/xp8Xx38Dxvu+0Xx4x/x6n/ABoAn/4X94G/5733/gKf8a2NC+KfhLxV + cCw0/Udt45wkFxGY2f8A3c8E+wOaAOnHSlT/AFi/7w/nQBoUUAR+fF/fFHnxf3xQBWaN2YsFJBJINJ5U + n9w0ATxSLHGEc4YdQaf58f8Ae/SgDL1vVrDSLGfUb+5SC0gTMkjHp7Y9T2FfKXxH+I15451HYm+30qBv + 9Hts9evzv6tyfpmgDhaKACigAooAKKACigAooAKKACigAooAKltriW1uoriCRo5onDo6nBVgcg0Afc1o + ZbizgnKHdLErnHqQDU6xurBipABBJoAs+fF/fFHnxf3xQBSooAvRf6pP90U+gCjP/r3/AA/lVDVdUstF + 0yfUdRuFgtIF3PIx/QepPYCgD5Y+IvxIvvG2pGNQ1vpMLH7PbZ6/7berH9O3qeEoAKKACigAooAKKACi + gAooAKKACigAooAKB1oA+89K/wCQRZf9cI//AEEVZl/1T/7poAo0UAGD6H8qMH0P5UAXY2URICw+6O9P + 3r/eH50AY+tapY6NZ3OpajcLBZwLueRvTHQepPTFfKXxG+It7441Laha30mBj9nts9f9t/Vj+nT1yAcN + nNFABRQAUUAFFABRQAUUAFFABRQAUUAFFABQOtAH3lpTKNIsssP9RH3/ANkVZkZTE4DD7p70AUsH0P5U + YPofyoA0aKAM9x+9f/eP86QDJAHegD5V+Kvjy98T+I7nT1cx6XYTtHBCvR2UkF29STnHoK87oAKKACig + AooAKKACigAooAKKACigAooAKKACigD7l0//AJBtp/1wj/8AQRVpB+9T/eH86ANCigAooAz3P71/94/z + pAcEEdqAPlv4tfD298Ma7cavCpl0m+maRJVH+qZiSUb05zg9xXmtABRQAUUAFFABRQAUUAFFABRQAUUA + FFABRQAUUAfcun/8g20/64R/+girSH96n+8P50AaFFAGdk+p/OjJ9T+dAF2NVMSEqPujtT9i/wB0flQB + larYWmpW9xY3tuk9pMuySJxwwxXyx8S/hrd+Cr43NqHuNFnbEM2MmI/3H9/Q9/zoA89II60UAFFABRQA + UUAFFABRQAUUAFFABRQAUUAFA60AfeWlKp0iyyo/1Efb/ZFWZFUROQo+6e1AFLJ9T+dGT6n86ACigC9F + /qk/3RT6AKM/+vf8P5VTv7C11Ownsb6BJ7adCkkcgyGB/r6UAfLnxL+Gd34Kvjd2u+fRZmxDMRzGf7j+ + /oe/14rz2gAooAKKACigAooAKKACigAooAKKACigAoHWgD7z0r/kEWX/AFwj/wDQRVmX/VP/ALpoAo0U + AXfIi/uCjyIv7goArNI6sVDEAEgCk82T++aAJ4o1kjDuMsepNP8AIi/uUAZ2rafaahaTWF5bpNazx7ZI + nGQwP/6v0r5W+Jfw1ufBN+bm1Dz6LO37mc8mM/3H9/Q96APPqKACigAooAKKACigAooAKKACigAooAKm + s7We+vIbW2jaSeZwkaKMlmJwBQB9y2olt7OCEucxxqhx6gAVOsjswUsSCQCKALPkRf3BR5EX9wUASUUA + Z7/6xv8AeP8AOkoAuW/+oX8f51LQBUuv9aP92qN7Y2upWM1lfQJcWs67ZInHDCgD5a+Jfw0vPBV99ptt + 9xo0zfupiMmIn+B/f0Pf68V59QAUUAFFABX0F8MPhp4S8R+ALDVNW0tri7leVXcXMiZCuQOFIHQUAdf/ + AMKY8Af9AN//AANm/wDiqtr8Efh8VB/sNuR/z+T/APxdAC/8KR+H3/QDb/wMn/8Ai6rSfBf4frIwGhvw + f+fyb/4qgBn/AApjwB/0A3/8DZv/AIqrEPwT+H7pk6G/X/n8m/8Ai6AJP+FI/D7/AKAbf+Bk/wD8XUM/ + wV+H6FcaG/P/AE+Tf/F0AQ/8KY8Af9AN/wDwNm/+KqWD4K/D93IOhv0z/wAfk3/xVAE//Ckfh9/0A2/8 + DJ//AIutPSPhv4S8MXH27SdGihul+7M0jyMvbjexx17UAb1Kn+sX/eH86ANCigCn9ok/2fyo+0yf7P5U + ASLAjqHJbLDJ5pfsqerfnQBG0jQsY0xtHTIpPtMn+z+VAD0QXALuTkccU77Knq1AFLVdMs76wlsbyBbi + 1uFKSxSchh/nv9K+VfiX8NLrwVfm6tg9xo07fupupiP9x/Q+h70AefUUAFFABX1p8Dolk+FGmbs8Sz9P + +ujUAeifZY/VvzqL7RIOBjA46UAH2mT/AGfyqRYVlUOxO5uTigBfsqerfnUbM0DbE6deaAE+0yf7P5U5 + B9oJ8w/d6YoAf9lT1b86a6C3AdCcnjmgBn2mT/Z/KlWRpmEb42nrgUASfZU9W/OkaBEUuC2VGRzQBH9p + k/2fyo+0Sf7P5UARUUAXov8AVJ/uin0AUZ/9e/4fyplAFq1/1bf71T0AVrv+D8azr+wtdUsJrG+gS4tZ + 1KSRuMhh/j70AfLnxM+Gt34Kvjc2oefRZ3/czdTEf7j47+h7/XNee0AFFABX1x8Cv+ST6b/11n/9GNQB + 6PWcfvH60AFXYP8AUrQBJVO5/wBd+AoAiqxafx/hQBZqC6/1a/71AFWnwf69Px/lQBepkv8Aqn/3TQBR + ooAsfZf+mn6UfZP+mn6UAJ9oMfybQdvGc+lH2o/3B+dAAIvP/e7tu7til+yf9NP0oATcbY7AN2ec9KPt + R/uD86ADm6OD8u38aX7J/wBNP0oAqanpdrfadNZ30SXNrcL5ckTrwwNfKvxL+Glz4K1D7Vbb59Fnb9zN + 1MR/uP7+h7/XigDz6igAr6z+CEpi+FGmYXOZZ+//AE0agD0L7Wf7g/OlFtuG7fjPPSgA+yf9NP0pPOMP + 7vbnbxnNAB9qP9wfnQENzl87e2MZoAX7J/00/Sk5tTgfNu/CgA+1H+4Pzo3G5OwjbjnPWgBfsn/TT9KQ + xeR+93btvbFAB9qP9wfnR9oMnybQN3Gc+tAC/ZP+mn6UfZf+mn6UAWaKAM9/9Y3+8f50lAFy3/1C/j/O + paAKl1/rR/u1DQBPadW+gq1QBBdf6ofWsy/sbXU7GaxvrdLi1nXZJE4yGFAHy58S/hpdeCb43Vqr3Giz + tiGfBJjJ/gf39D3/ADrz2gAr6v8Agr/ySnS/+us//o1qAO/rQT7i/SgBaozf65vrQAyrdt/qj9aAJqq3 + fVfoaAIKmtf9af8AdoAt1Fcf6hvw/nQBTpU/1i/7w/nQBoUUAQfak/utR9qT+61AEfkO53grhjkZ96Ps + snqv50AOWUQL5bAll646U77Un91qAI2U3Lb0wABj5qPs0nqv50AKubY/Pzu6baf9qT+61ADWf7QAiAg5 + zzTfssnqv50AVdQ0m31DT5rTUIIbi0mXbLE4yGFfK3xM+Gl34Kv/ALVaiS40WdsQzEZMZ/uP7+h7/XNA + Hn+K+tvg1YXEPwr0hZF2M5lkUN3VpGIP5UAd59lk9V/OpBcqoClW44oAX7Un91qjMLykyLgBuRmgA+yy + eq/nTlf7OCjgk5zxQA77Un91qY2bk/Jxt67qAE+zSeq/nQqm2be+CCMfLQBJ9qT+61NaUTr5aghm6Z6U + AN+yyeq/nR5Dod5K4U5OPagCT7Un91qPtSf3WoAq0UAXov8AVJ/uin0AUZ/9e/4fyplAFq1/1bf71T0A + Vrv+D8ar0AS23+t/CrlAEc/+pasm+sbTUrGayvreO4tplKSRSDIYf570AcHb/BDwTBqC3P2W8lUMCLeS + 4Jj/AEGcfjXqUMMdvCkUKKkaKFVFGAoHQCgCSs4/eP1oAKuwf6laAJKp3P8ArvwFAEVWLT+P8KALNQXX + +rX/AHqAKtPg/wBen4/yoAvUyX/VP/umgCjRQBJ5Ev8Ac/UUnkS/3P1FAFhJo0RVZsMowRg0v2iL+9+h + oAgdHlkLouVPQ5pvkS/3P1FAEsTCBSsnysTnHWpPtEX979DQBFKfP2+V823r2qPyJf7n6igB8atC+6Qb + V6Z61N9oi/vfoaAGySpIhRDlj0GKg8iX+5+ooAXyZQclMAc9RVj7RF/e/Q0AH2iL+9+hqv5MpOQnB5HI + oATyJf7n6ip45UjQI5ww6jFADvtEX979DUMitM+6Mbl6Z6UAM8iX+5+oqSI+Ru835d3TvQBL9oi/vfoa + jlYTqFj+Zgc46UAReRL/AHP1FORHikDuuFHU5oAn+0Rf3v0NI80boyq2WYYAwaAK/kS/3P1FL5Ev9z9R + QBdooAz3/wBY3+8f50lAFy3/ANQv4/zqWgCpdf60f7tQ9qAJ7T7zfQVaoAhuf9UPrVSgB8P+uX61eoAR + /uN9KzqACtFPuL9KAFqjN/rm+tADKt23+qP1oAmqrd/eX6GgCCprX/Wn/doAt1Fcf6hvw/nQBTpU/wBY + v+8P50AaFFADPNj/AOei/nR5sf8Az0X86AKbKxdiFYgkkECk2P8A3G/75NAFqF1WIKzBWGcgnBp/mx/8 + 9F/OgCvPl5MoCwx1Xmotj/3G/wC+TQBNbnyy2/5cjjdxU/mx/wDPRfzoAjnYPGAhDHPRearbH/uN/wB8 + mgB0assillIAPJIq35sf99fzoARpEKkB16etU9j/ANxv++TQAbH/ALjf98mriyIFALr09aAF82P++v51 + UkVmkZlUkE8ECgBux/7jf98mrMDBIyHIU56NxQBJ5sf/AD0X86guD5hXZ82Bzt5oAh2P/cb/AL5NSwZS + TLgqMdW4oAsebH/z0X86ZM6tEVVgzHGADk0AVdj/ANxv++TSqrB1JVgAQSSKALnmx/8APRfzo82P/nov + 50AUaKAL0X+qT/dFPoAoz/69/wAP5UygC1a/6tv96p6AK13/AAfjVegCW2/1v4GrlAEc/wDqWqlQAD7w + +taNABWcfvH60AFXYP8AUrQBJVO5/wBd+AoAiqxafx/hQBZqC6/1a/71AFWnwf69Px/lQBepkv8Aqn/3 + TQBRooAKKAL0X+qT/dFPoAoz/wCvf8P5UygC1a/6tvrU9AFa7/g/Gq9AEtt/rfwq5QBHP/qWqlQAD7w+ + taNABWcfvH60AFXYP9StAElU7n/XfgKAIqsWn8f4UAWaguv9Wv1oAq0+D/Xp+P8AKgC9TJf9U/8AumgC + jRQB/9kA/9sAQwADAgIDAgIDAwMDBAMDBAUIBQUEBAUKBwcGCAwKDAwLCgsLDQ4SEA0OEQ4LCxAWEBET + FBUVFQwPFxgWFBgSFBUU/9sAQwEDBAQFBAUJBQUJFA0LDRQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQU + FBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQU/8AAEQgBaAFoAwEiAAIRAQMRAf/EAB8AAAEFAQEBAQEBAAAA + AAAAAAABAgMEBQYHCAkKC//EALUQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGh + CCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0 + dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh + 4uPk5ebn6Onq8fLz9PX29/j5+v/EAB8BAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKC//EALURAAIB + AgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKBCBRCkaGxwQkjM1LwFWJy0QoWJDThJfEXGBka + JicoKSo1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZ + mqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uLj5OXm5+jp6vLz9PX29/j5+v/aAAwD + AQACEQMRAD8A/SWiiigBrfcb6V2Fce33G+ldhQAUUUUAcgv3F+lLSL9xfpS0ANb7jfSuwrj2+430rsKA + CiiigDkF+4v0paRfuL9KWgBrfcb6V2Fce33G+ldhQAUUUUAcgv3F+lLSL9xfpS0ANb7jfSuwrj2+430r + sKACiiigDkF+4v0paRfuL9KWgBrfcb6V2Fce33G+ldhQAUUUUAcgv3F+lLSL9xfpS0ANb7jfSuwrj2+4 + 30rsKACiiigDkF+4v0paRfuL9KWgBrfcb6V2Fce33G+ldhQAUUUUAcgv3F+lLSL9xfpS0AFFFFACeYn9 + 6jzE/vV19FAHHNINjfNXY0VxyxjYvy0AdjRXIeWn92mtGNjfLQALINi/NTvMT+9XX0UAcc0g2N81djRX + HLGNi/LQB2NFch5af3aa0Y2N8tAAsg2L81O8xP71dfRQBxzSDY3zV2NFccsY2L8tAHY0VyHlp/dprRjY + 3y0ACyDYvzU7zE/vV19FAHHNINjfNXY0VxyxjYvy0AdjRXIeWn92mtGNjfLQALINi/NTvMT+9XX0UAcc + 0g2N81djRXHLGNi/LQB2NFch5af3aa0Y2N8tAAsg2L81O8xP71dfRQBxzSDY3zV2NFccsY2L8tAHY0Vy + Hlp/dprRjY3y0ACyDYvzU7zE/vV19FAHHNINjfNXY0VxyxjYvy0AdjRXIeWn92mtGNjfLQALINi/NTvM + T+9XX0UAch5if3qK6+igAooooAK5BfuL9K6+uOWQbF+agB9Nb7jfSl8xP71NaQbG+agDsaKKKACuQX7i + /SuvrjlkGxfmoAfTW+430pfMT+9TWkGxvmoA7GiiigArkF+4v0rr645ZBsX5qAH01vuN9KXzE/vU1pBs + b5qAOxooooAK5BfuL9K6+uOWQbF+agB9Nb7jfSl8xP71NaQbG+agDsaKKKACuQX7i/SuvrjlkGxfmoAf + TW+430pfMT+9TWkGxvmoA7GiiigArkF+4v0rr645ZBsX5qAH01vuN9KXzE/vU1pBsb5qAOxooooAK5Bf + uL9K6+uOWQbF+agB9Nb7jfSl8xP71NaQbG+agDsaKKKACiiigDkPLT+7R5af3aWigBjRjY3y12Nce33G + +ldhQAUUUUAccsY2L8tO8tP7tC/cX6UtADGjGxvlrsa49vuN9K7CgAooooA45YxsX5ad5af3aF+4v0pa + AGNGNjfLXY1x7fcb6V2FABRRRQBxyxjYvy07y0/u0L9xfpRNJHa2s11cTRWlnAC8t1cPsijUfe3M2F20 + ANaMbG+Wuxrynw58VvAnjrUpNL8N+PPC/iLVFBZrDSdZt7qdVH3v3cblq9WoAKKKKAOOWMbF+WneWn92 + hfuL9KWgBjRjY3y12Nce33G+ldhQAUUUUAccsY2L8tO8tP7tC/cX6UtADGjGxvlrsa49vuN9K7CgAooo + oA45YxsX5ad5af3aF+4v0paAGNGNjfLXY1x7fcb6V2FABRRRQBxyxjYvy07y0/u0L9xfpS0AJ5af3aKW + igBPMT+9R5if3q6+igDjmkGxvmrsaK45YxsX5aAOxorkPLT+7TWjGxvloAFkGxfmp3mJ/err6KAOOaQb + G+auxorjljGxfloA7GiuQ8tP7tNaMbG+WgAWQbF+aneYn96uvooA45pBsb5q7GiuOWMbF+WgDsaK5Dy0 + /u1ieOPGfh/4beD9U8T+J9Ut9F0DS4TPd3lx91f93b8zsW+UIvzM3yrQAeNPHHh/4b+DdT8U+J9Vg0bQ + NMh8+6vZ3+6v935fmdi3yhF+Zm+Va/Er9sz9t3xD+1T4klsbRp9F8AWUm7T9F3/67H/La52t80np/Cv/ + AI9S/tr/ALbWv/tYeMGt7YyaT4D06Qtpmjs+Gkxx58/JDSH8lX/vqvlWgC9ZX02n3ENzbTPb3ETB4pYn + 2PGw+6wZeciv3T/4Jl/tNat+0Z8F7+18U3X9oeK/DF0tnc3j8yXUDx7oZn/2ziRT/uV+D1fqT/wRJ/5B + /wAb/wDuCf8At/QB+r9Fch5af3aa0Y2N8tAAsg2L81O8xP71dfRQBxzSDY3zV2NFccsY2L8tAHY0VyHl + p/dprRjY3y0ACyDYvzU7zE/vV19FAHHNINjfNXY0VxyxjYvy0AdjRXIeWn92mtGNjfLQALINi/NTvMT+ + 9XX0UAcc0g2N81djRXHLGNi/LQB2NFch5af3aa0Y2N8tAAsg2L81O8xP71dfRQByHmJ/eorr6KACiiig + ArkF+4v0rr645ZBsX5qAH01vuN9KXzE/vU1pBsb5qAOxooooAK5BfuL9K6+uOWQbF+agB9Nb7jfSl8xP + 71NaQbG+agDsaKKKACuQX7i/SuvrzXxl440H4a+D9S8UeJ9Tg0jQNNi8+6vJ/wCH/vn5mYt8oRfmZqAH + eNvG2g/DbwjqvijxPqkGiaBpkJnuryd/ur/d+X5nYt8oRfmZvlWvxD/bU/bU139qrxV9ntRJpHgTTZS2 + maQ0nzSHG37RP/fkPb+6v/fVH7aX7aWu/tVeKzBb+dpHgXTZSNM0dn+Z2+79pn/vyN/47/6F8t0AFFFF + ABX6k/8ABEn/AJB/xv8A+4J/7f1+W1fqT/wRJ/5B/wAb/wDuCf8At/QB+mNNb7jfSl8xP71NaQbG+agD + saKKKACuQX7i/SuvrjlkGxfmoAfTW+430pfMT+9TWkGxvmoA7GiiigArkF+4v0rr645ZBsX5qAH01vuN + 9KXzE/vU1pBsb5qAOxooooAK5BfuL9K6+uOWQbF+agB9Nb7jfSl8xP71NaQbG+agDsaKKKACiiigDkPL + T+7R5af3aWigBjRjY3y12Nce33G+ldhQAUUUUAccsY2L8tO8tP7tC/cX6UtADGjGxvlrsa49vuN9K7Cg + AooooA45YxsX5ad5af3aF+4v0rG8beNdA+GvhHVfFPifVLfRdA0yHz7q8uH+VV/2dvzOxb5Qi/MzfKtA + DfHHjPw/8NvB+qeJ/E+qW+i6BpcJnu7y4+6v+7t+Z2LfKEX5mb5Vr8S/21/22df/AGsPGDW9sZNI8Cad + ITpmkPJhpMcefPyQ0h/75Vf++qg/bQ/bQ179qvxQLaATaT4E06U/2Zo7Py7fd+0T/wALSnJ/3d9fLlAB + RRRQAUUUUAFfqp/wQz/5rX/3Bf8A2/r8q6/VT/ghn/zWv/uC/wDt/QB+qlFFFAHHLGNi/LTvLT+7Qv3F + +lLQAxoxsb5a7GuPb7jfSuwoAKKKKAOOWMbF+WneWn92hfuL9KWgBjRjY3y12Nce33G+ldhQAUUUUAcc + sY2L8tO8tP7tC/cX6UtADGjGxvlrsa49vuN9K7CgAooooA45YxsX5ad5af3aF+4v0paAE8tP7tFLRQAn + mJ/eo8xP71dfRQBxzSDY3zV2NFccsY2L8tAHY0VyHlp/dprRjY3y0ACyDYvzU7zE/vV19FAHHNINjfNX + Y0VxyxjYvy0AdjRXIeWn92sTxz408P8Aw18H6n4o8UajBpGgabEZbq8n+6v+7t+Z2LfKEX5magA8ZeOP + D/w38Har4p8T6pBomgaZD591eTv91f7vy/M7FvlCL8zN8q1+Iv7an7amu/tVeKvs9qJNI8CabKW0zSGk + +aQ42/aJ/wC/Ie391f8Avqpf21f22df/AGsfGDW8Bk0nwHp0hOmaOz4aTHHnz8lWkP8A3yq/99V8rUAF + FFFABRRRQAUUUUAFfqp/wQz/AOa1/wDcF/8Ab+vyrr9SP+CJX/Hh8b/+4H/7f0AfrBRXIeWn92mtGNjf + LQALINi/NTvMT+9XX0UAcc0g2N81djRXHLGNi/LQB2NFch5af3aa0Y2N8tAAsg2L81O8xP71dfRQBxzS + DY3zV2NFccsY2L8tAHY0VyHlp/dprRjY3y0ACyDYvzU7zE/vV19FAHHNINjfNXY0VxyxjYvy0AdjRXIe + Wn92mtGNjfLQALINi/NTvMT+9XX0UAch5if3qK6+igAooooAK5BfuL9K6+uOWQbF+agB9Nb7jfSl8xP7 + 1NaQbG+agDsaKKKACuQX7i/SuvrzPxx4+8O/DHwbqPivxVqkWj6Bpsfm3N5P/wCOqv8AE7FvlCL8zNQB + J428a6B8NfCOq+KfE+qW+i6BpkPn3V5cP8qr/s7fmdi3yhF+Zm+Va/EH9tH9tDXf2qvFgtrfz9J8CadK + Rpujs+Gl/h+0T9mlOf8AgNN/bO/bN179qvxYFjM+j+BrCQ/2Xou//wAjT/Nh5T/46tfL9ABRRRQAUUUU + AFFFFABRRRQAV9Lfsg/tsaz+x/D4tGj+GtO8RHxEbTzf7RkkQR/Z/P27dv8A13r5pooA/SD/AIfUeM/+ + iY+Gf/Aq4pv/AA+n8Zf9Ey8M/wDgVcV+cNFAH6T/APD7rxz/ANE28Pf+BtxR/wAPufHP/RN/D3/gbcV+ + bFFAH6T/APD7rxz/ANE28Pf+BtxVb/h9P4y/6Jl4Z/8AAq4r84aKAP0g/wCH1HjP/omPhn/wKuKb/wAP + p/GX/RMvDP8A4FXFfnDRQB+k/wDw+68c/wDRNvD3/gbcUf8AD7nxz/0Tfw9/4G3FfmxRQB+k/wDw+68c + /wDRNvD3/gbcVW/4fT+Mv+iZeGf/AAKuK/OGigD9IP8Ah9R4z/6Jj4Z/8Crim/8AD6fxl/0TLwz/AOBV + xX5w0UAfpP8A8PuvHP8A0Tbw9/4G3FH/AA+58c/9E38Pf+BtxX5sUUAfqr8PP+C2Rn1yGDxz8PIrfSJH + xJeaFeM80K/9cZBtf/vsV+hvgzxhonxC8JaP4m8N6lFq+hapbrc2l5B92SM/73zIwb5SjfMrfK1fzO1+ + xH/BHbxLdan+z34v0m6l8220vXw1ruH3Vmt13Kv/AAJKAPvKmt9xvpS+Yn96mtINjfNQB2NFFFABRRRQ + ByHlp/do8tP7tLRQAxoxsb5a7GuPb7jfSuwoAKKKKAOOWMbF+WneWn92hfuL9KxPHnjzw/8ADDwfqfiv + xXqkei6Bpsfm3N1P/wCOqu35nYt8oRfmZqAG+PvHHhz4Y+DNV8U+LNRg0XQNOj825vJP/HVXb8zsW+UI + vzM1fiP+2t+2j4g/aw8XYjabSvA2nykaTojPycfL59x8xVpTn/gK/wDfTVv2zv2zNf8A2rPFxVWn0bwN + pkzf2ToZfr/D50/8LSt/3zGvyr33fMlABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA + BRRRQAUUUUAFFFFABRRRQAUUUUAFfsH/AMESf+SP/Eb/ALDkP/pOK/Hyv2D/AOCJP/JH/iN/2HIf/ScU + AfpLRRRQBxyxjYvy07y0/u0L9xfpS0AJ5af3aKWigBPMT+9R5if3q6+igDjmkGxvmrsaK45YxsX5aAOx + orkPLT+7Wb4o8QaR4K8Max4h168XT9F0q1kvby6b7scKLuZvl/Tb8zNQBU8bePPD3ww8Gaj4p8VanBo2 + gabF5tzeSf8Ajqrt+Z2LfKEX5mavw+/bQ/bN1/8Aaq8YEJ5+j+BdNkf+ydDMntt8+fs0zf8AkNflXuzW + v20/20tf/aw8YYj87SfAunSsdL0bzOWx8vnz9Q0pz/wFf++m+WqACiiigAooooAKKKKACiiigAooooAK + KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACv2D/wCCJP8AyR/4jf8AYch/9JxX + 4+V+uf8AwRh/5Iv8SP8AsOwf+k9AH6a0VyHlp/dprRjY3y0ACyDYvzU7zE/vV19FAHIeYn96iuvooAKK + KKACuQX7i/SuvrjlkGxfmoAfXzJ/wUuhvpf2JfHy2H8Muntd7f4oPtkX/s1fTXmJ/eqnrmk6b4l0HUtH + 1m0g1LSNRt5LO8s5/wDV3ETrtkVv95aAP5kqK+vf27P2FdW/Zb8SNrWhC41f4bahNts9RZN0llIf+Xaf + /wBkf+Ja+QqACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii + gAooooAKKKKACv1z/wCCMP8AyRf4j/8AYfg/9J6/Iyv1z/4Iw/8AJF/iR/2HYP8A0noA/Qemt9xvpS+Y + n96mtINjfNQB2NFFFABRRRQByHlp/do8tP7tLRQAxoxsb5a7GuPb7jfSuwoAKKKKAPPfEPhnR/Gfhu/0 + DxBp0Gr6DqMJgvLC6TfHNGf87vl+ZWr8Uv25P2HtY/Zc8SHWdDW41f4bahLts9ReP95ZSH/l2n/2v7r/ + APLRa/cBfuL9KzvE3hvSPG3h7UtA8QadBq+h6jEYLywuk3xTRn/O75fmVqAP5l6K+uv25P2H9X/Ze8SS + a1oYuNX+G2pS7bPUWTfJYyN/y7Tt/e/uv/y0WvkWgAooooAKKKKACiiigAooooAKKKKACiiigAooooAK + KKKACiiigAooooAKKKKACiiigAooooAKKKKACv2D/wCCJP8AyR/4jf8AYch/9JxX4+V+wf8AwRJ/5I/8 + Rv8AsOQ/+k4oA/SWiiigDjljGxflp3lp/doX7i/SloATy0/u0UtFACeYn96jzE/vV19FAHHNINjfNXY0 + VxyxjYvy0AdjRXIeWn92mtGNjfLQALINi/NTvMT+9XX0UAee+JvD+jeNPDeo6B4g0+DV9B1GEwXlhdfP + HNGf87vl+ZWr8Vf27v2FdX/ZZ8RPrOiifWPhvfzbLPUWH7yykP8Ay7T/APsj/wASiv3srz3xD4Z0fxn4 + Y1Dw/wCINOg1fQ9RgMF7YXSfupoz/nd8vzK1AH8zNFfXP7cn7Dur/sueJTrOh/aNX+G2oylLPUHj/eWU + h/5dp/8Aa/uv/wAtFr5GoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig + AooooAKKKKACv2D/AOCJP/JH/iN/2HIf/ScV+Plfsd/wR78J32i/s7+KNXvIdlprOvbrTd/y0jhhVWYf + 8C/lQB+jVFch5af3aa0Y2N8tAAsg2L81O8xP71dfRQByHmJ/eorr6KACiiigArkF+4v0rr645ZBsX5qA + H01vuN9KXzE/vU1pBsb5qAOxooooAK5BfuL9K6+uOWQbF+agCh4m8N6R428PajoHiLTYNX0PUYjBeWF0 + m+OaM/53fL8ytX4oftyfsPax+y54kOs6Gtxq/wANtQl22eovH+8spD/y7T/7X91/+Wi1+4HmJ/erM8Se + H9H8ZeG9R0DX9Pg1jQ9RiaC8sLr545oz/D/+z8ytQB/MzRX17+3Z+wpq/wCyz4kk1rRBcav8N76bZZ6i + ybpLKQ/8u0//ALI/8SivkKgAooooAKKKKACiiigAr6p/Yn/Yjf8AbGg8aFfGEXhJvDZs/MMun/avO+0e + f/00TbjyP1r5Wr9SP+CJX/Hh8b/+4H/7f0AVf+HJkn/RaLX/AMJxv/kmj/hyZJ/0Wi1/8Jxv/kmv078x + P71NaQbG+agD82P+HG9x/wBFli/8Jn/7qo/4cb3H/RZYv/CZ/wDuqv1YooA/Kf8A4cb3H/RZYv8Awmf/ + ALqrN/4cmSf9Fotf/Ccb/wCSa/WquOWQbF+agD8xv+HJkn/RaLX/AMJxv/kmj/hyZJ/0Wi1/8Jxv/kmv + 078xP71NaQbG+agD82P+HG9x/wBFli/8Jn/7qo/4cb3H/RZYv/CZ/wDuqv1YooA/Kf8A4cb3H/RZYv8A + wmf/ALqrN/4cmSf9Fotf/Ccb/wCSa/WquOWQbF+agD8xv+HJkn/RaLX/AMJxv/kmj/hyZJ/0Wi1/8Jxv + /kmv078xP71NaQbG+agD82P+HG9x/wBFli/8Jn/7qo/4cb3H/RZYv/CZ/wDuqv1YooA/M74f/wDBFHw1 + pGuQXXi34kXniLTEOW0+x0hdPZ/9lpPPl/lX3p4f0PS/Cvh/TtD0Swg0jRtOhW3s7G2TZHDGPuqtd7XH + LINi/NQA+mt9xvpS+Yn96mtINjfNQB2NFFFABRRRQByHlp/do8tP7tLRQAxoxsb5a7GuPb7jfSuwoAKK + KKAOOWMbF+WneWn92hfuL9KWgBjRjY3y12Nce33G+ldhQAUUUUAee+IfDOj+M/Dd/oHiDToNX0HUYTBe + WF0m+OaM/wCd3y/MrV+KX7cn7Dusfsu+JDrWh/aNY+G+oTbLPUXT95ZyH/l2n/2v7r/8tFr9wF+4v0rO + 8TeG9I8beHtS0DxBp0Gr6HqMRgvLC6TfFNGf87vl+ZWoA/mXor65/bj/AGHdX/Zc8RnWdE+0av8ADbUJ + StnqLx/vLKQ/8u0/+1/df/lotfI1ABRRRQAUUUUAFfqp/wAEM/8Amtf/AHBf/b+vyrr9VP8Aghn/AM1r + /wC4L/7f0AfqpRRRQBxyxjYvy07y0/u0L9xfpS0AMaMbG+Wuxrj2+430rsKACiiigDjljGxflp3lp/do + X7i/SloAY0Y2N8tdjXHt9xvpXYUAFFFFAHHLGNi/LTvLT+7Qv3F+lLQAxoxsb5a7GuPb7jfSuwoAKKKK + AOOWMbF+WneWn92hfuL9KWgBPLT+7RS0UAJ5if3qPMT+9XX0UAcc0g2N81djRXHLGNi/LQB2NFch5af3 + aa0Y2N8tAAsg2L81O8xP71dfRQBxzSDY3zV2NFccsY2L8tAHY0VyHlp/dprRjY3y0ACyDYvzU7zE/vV1 + 9FAHnvibw/o3jTw3qOgeINPg1fQdRhMF5YXXzxzRn/O75fmVq/Fb9u39hXVv2WfEja1oa3GrfDbUJdln + qLJukspD/wAu0/8A7I/8S1+9dee+IfDGj+M/DGoeH/EGnQavoepwGC8sLpP3U0Z/zu+X5lagD+Zmivrr + 9uT9h/V/2XvEkmtaGLjV/htqUu2z1Fk3yWMjf8u07f3v7r/8tFr5FoAKKKKACv1U/wCCGf8AzWv/ALgv + /t/X5V1+pP8AwRJ/5B/xv/7gn/t/QB+r9Fch5af3aa0Y2N8tAAsg2L81O8xP71dfRQBxzSDY3zV2NFcc + sY2L8tAHY0VyHlp/dprRjY3y0ACyDYvzU7zE/vV19FAHHNINjfNXY0VxyxjYvy0AdjRXIeWn92mtGNjf + LQALINi/NTvMT+9XX0UAcc0g2N81djRXHLGNi/LQB2NFch5af3aa0Y2N8tAAsg2L81O8xP71dfRQByHm + J/eorr6KACiiigArkF+4v0rr645ZBsX5qAH01vuN9KXzE/vU1pBsb5qAOxooooAK5BfuL9K6+uOWQbF+ + agB9Nb7jfSl8xP71NaQbG+agDsaKKKACuQX7i/SuvrjlkGxfmoAoeJvDekeNvD2peHvEGmwaxoeoxGC8 + sLpN8c0Z/wA7vl+ZWr8UP25P2HdY/Zd8SHWtD+0ax8N9Qm2Weoun7yzkP/LtP/tf3X/5aLX7geYn96sz + xN4f0bxp4b1HQPEGnwavoOowmC8sLr545oz/AJ3fL8ytQB/MzRX17+3d+wrq37LPiRta0MXGr/DfUJdl + nqLLukspD/y7T/8Asj/xKPWvkKgAr9Sf+CJP/IP+N/8A3BP/AG/r8tq/Uj/giV/x4fG//uB/+39AH6ZU + 1vuN9KXzE/vU1pBsb5qAOxooooAK5BfuL9K6+uOWQbF+agB9Nb7jfSl8xP71NaQbG+agDsaKKKACuQX7 + i/SuvrjlkGxfmoAfTW+430pfMT+9TWkGxvmoA7GiiigArkF+4v0rr645ZBsX5qAH01vuN9KXzE/vU1pB + sb5qAOxooooAKKKKAOQ8tP7tHlp/dpaKAGNGNjfLXY1x7fcb6V2FABRRRQBxyxjYvy07y0/u0L9xfpS0 + AMaMbG+Wuxrj2+430rsKACiiigDjljGxflp3lp/doX7i/SloAY0Y2N8tdjXHt9xvpXYUAFFFFAHnviHw + zo/jPwxqHh/xBp0Gr6HqMBgvbC6T91NGf87vl+ZWr8WP22v2CvEP7M+uXGv+Hre81z4aXTF7fUVTzJNP + +b/U3OP0f7rV+3S/cX6VJHcPH91vlYbSr/dZf92gD+ZfRdD1HxFqlvpmkWNzqupXbiK3s7KFpp5pD/Ci + KpZm/wB2v3Y/4Jtfst6j+zP8FbseJIhB4t8R3K31/B3to1TbDAf9pcux/wB+vfdL8O6N4cnubnR9F0vS + rq4B86ews4YZJP8AeZVDPXfUAFFFFAHHLGNi/LTvLT+7Qv3F+lLQAxoxsb5a7GuPb7jfSuwoAKKKKAOO + WMbF+WneWn92hfuL9KWgBjRjY3y12Nce33G+ldhQAUUUUAccsY2L8tO8tP7tC/cX6UtADGjGxvlrsa49 + vuN9K7CgAooooA45YxsX5ad5af3aF+4v0paAE8tP7tFLRQAnmJ/eo8xP71dfRQBxzSDY3zV2NFccsY2L + 8tAHY0VyHlp/dprRjY3y0ACyDYvzU7zE/vV19FAHHNINjfNXY0VxyxjYvy0AdjRXIeWn92mtGNjfLQAL + INi/NTvMT+9XX0UAcc0g2N81djRXHLGNi/LQB2NFch5af3aa0Y2N8tAAsg2L81O8xP71dfRQBxzSDY3z + V2NFccsY2L8tAHY0VyHlp/dprRjY3y0ACyDYvzU7zE/vV19FAHHNINjfNXY0VxyxjYvy0AdjRXIeWn92 + mtGNjfLQALINi/NTvMT+9XX0UAcc0g2N81djRXHLGNi/LQB2NFch5af3aa0Y2N8tAAsg2L81O8xP71df + RQBxzSDY3zV2NFccsY2L8tAHY0VyHlp/dprRjY3y0ACyDYvzU7zE/vV19FAHIeYn96iuvooAKKKKACuQ + X7i/SuvrjlkGxfmoAfTW+430pfMT+9TWkGxvmoA7GiiigArkF+4v0rr645ZBsX5qAH01vuN9KXzE/vU1 + pBsb5qAOxooooAK5BfuL9K6+uOWQbF+agB9Nb7jfSl8xP71NaQbG+agDsaKKKACuQX7i/SuvrjlkGxfm + oAfTW+430pfMT+9TWkGxvmoA7GiiigArkF+4v0rr645ZBsX5qAH01vuN9KXzE/vU1pBsb5qAOxooooAK + 5BfuL9K6+uOWQbF+agB9Nb7jfSl8xP71NaQbG+agDsaKKKACuQX7i/SuvrjlkGxfmoAfTW+430pfMT+9 + TWkGxvmoA7GiiigAooooA5Dy0/u0eWn92looAY0Y2N8tdjXHt9xvpXYUAFFFFAHHLGNi/LTvLT+7Qv3F + +lLQAxoxsb5a7GuPb7jfSuwoAKKKKAOOWMbF+WneWn92hfuL9KWgBjRjY3y12Nce33G+ldhQAUUUUAcc + sY2L8tO8tP7tC/cX6UtADGjGxvlrsa49vuN9K7CgAooooA45YxsX5ad5af3aF+4v0paAGNGNjfLXY1x7 + fcb6V2FABRRRQBxyxjYvy07y0/u0L9xfpS0AMaMbG+Wuxrj2+430rsKACiiigDjljGxflp3lp/doX7i/ + SloAY0Y2N8tdjXHt9xvpXYUAFFFFAHHLGNi/LTvLT+7Qv3F+lLQAnlp/dopaKACiiigBrfcb6V2FFFAB + RRRQByC/cX6UtFFADW+430rsKKKACiiigDkF+4v0paKKAGt9xvpXYUUUAFFFFAHIL9xfpS0UUANb7jfS + uwoooAKKKKAOQX7i/SloooAa33G+ldhRRQAUUUUAcgv3F+lLRRQA1vuN9K7CiigAooooA5BfuL9KWiig + Brfcb6V2FFFABRRRQByC/cX6UtFFABRRRQB//9k= + + + + + /9j/4AAQSkZJRgABAQEASABIAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwg + JC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIy + MjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAFoAWgDASIAAhEBAxEB/8QA + HwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIh + MUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVW + V1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXG + x8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQF + BgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAV + YnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOE + hYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq + 8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD26iiigBD901pVmn7prSoAKKKKAM0fdFLSD7opaAEP3TWlWafu + mtKgAooooAzR90UtIPuiloAQ/dNaVZp+6a0qACiiigDNH3RS0g+6KWgBD901pVmn7prSoAKKKKAM0fdF + LSD7opaAEP3TWlWafumtKgAooooAzR90UtIPuiloAQ/dNaVZp+6a0qACiiigDNH3RS0g+6KWgBD901pV + mn7prSoAKKKKAM0fdFLSD7opaACiiigBMj1FGR6itKigDNJGDzWlRWaAMDigDSorNwPQUEDB4oAARgc0 + ZHqK0qKAM0kYPNaVFZoAwOKANKis3A9BQQMHigABGBzRkeorSooAzSRg81pUVmgDA4oA0qKzcD0FBAwe + KAAEYHNGR6itKigDNJGDzWlRWaAMDigDSorNwPQUEDB4oAARgc0ZHqK0qKAM0kYPNaVFZoAwOKANKis3 + A9BQQMHigABGBzRkeorSooAzSRg81pUVmgDA4oA0qKzcD0FBAweKAAEYHNGR6itKigDNJGDzWlRWaAMD + igDSorNwPQUEDB4oAARgc0ZHqK0qKAM3I9RRWlRQAUUUUAFZo+6K0qzQRgc0ALSH7poyPUUEjB5oA0qK + KKACs0fdFaVZoIwOaAFpD900ZHqKCRg80AaVFFFABWaPuitKs0EYHNAC0h+6aMj1FBIweaANKiiigArN + H3RWlWTPc21naSXd3cRW9tEu6SWZgqovqWPAoAlpD901wzfGXwCLjyDrTnt5otJdg/8AHc12dpe2mpWM + d7Y3UVzayjKTQuGVh04I/LHUGgDYooooAKzR90VpVmgjA5oAWkP3TRkeooJGDzQBpUUUUAFZo+6K0qzQ + Rgc0ALSH7poyPUUEjB5oA0qKKKACs0fdFaVZoIwOaAFpD900ZHqKCRg80AaVFFFABRRRQBm4HoKMD0FL + RQAhAweK0qzT901pUAFFFFAGaAMDijA9BQPuiloAQgYPFaVZp+6a0qACiiigDNAGBxRgegoH3RS0AIQM + HitKs0/dNaVABRRRQBmgDA4owPQUD7oqG8vbbTbGa+vbhLe1gUvLM5wqqP8AOOOSaAEvbu106xmvr2eO + 3tIFLyzOcKqj/OOOSa+YPid8T7rxve/Y7QvBocDkwxHgykfxv/RegpPiX8TLrxtfGztC8GhwOTDEeGlP + 99/f0HQV5zQAV33w5+I194E1Lad8+kzsPtFtnp/trnowA+h/LHA0UAfcWl6lYa1pcGpabOlxZ3C5jkX8 + sEdQQeCDyDVvA9BXyZ8O/iLfeBtTwd1xpM7D7Ta7v/H1z0YD8D0PbH1TpeqWOtaZBqem3C3FncLuSRfy + wR1BB4IPINAFogYPFaVZp+6a0qACiiigDNAGBxRgegoH3RS0AIQMHitKs0/dNaVABRRRQBmgDA4owPQU + D7opaAEIGDxWlWafumtKgAooooAzQBgcUYHoKB90UtACYHoKKWigBMj1FGR6itKigDNJGDzWlRWaAMDi + gDSorNwPQUEDB4oAARgc0ZHqK0qKAM0kYPNaVFZoAwOKANKis3A9BQQMHigABGBzRkeorSooAzSRg81p + UVmgDA4oA0qKzcD0FQXt3aadYzX19PHb2sCl5ZnOFVf88cck0AF3e2unWE19ezx29pAu+WZzhVUf5xxy + TXy/8SviZdeNr77HaM9vocDkwxHhpSOjv7+g6Cl+J3xPuvG999ktC8GiQNmGI8NKf77/ANB0FecUAFFF + FABRRRQAV3Xw7+Il74G1MA77jSp2H2m13f8Aj656MB+DDg+3C0UAfcWmapYa1pUOp6bcrPZ3C5jkX8sE + dQQeCDyDW7Xx98OfiPe+BNTCnfPpUzA3Nrn6fOuejAD6H8sfUml6nY61pcGpabOtxZzrujkX+RHUEHgg + 8g0AbtFZuB6CggYPFAACMDmjI9RWlRQBmkjB5rSorNAGBxQBpUVm4HoKCBg8UAAIwOaMj1FaVFAGaSMH + mtKis0AYHFAGlRWbgegoIGDxQAAjA5oyPUVpUUAZuR6iitKigAooooAKzR90VpVmgjA5oAWkP3TRkeoo + JGDzQBpUUUUAFZo+6K0qzQRgc0ALSH7poyPUUEjB5oA0qKKKACs0fdFaVY11eWunWE17e3CW9rAu+WZz + gKo9f5epNAC3l5babYz317OlvawKXlmc4VVH+ccck18vfEv4mXfja++x2m+DQ4HJhiPDSt/ff39B0FHx + L+Jl142vjZ2heDQ4HJhiPDSn++/v6DoK85oAKKKKACiiigAooooAKKKKACu8+HfxFvPA2pbTun0mdh9p + ts/T519GA/A1wdFAH3JpupWWs6bb6jptylzZ3CBo5U6EdMeoIPBB5B4NWT9018n/AA6+I154G1Ly5N8+ + kzsDcW+fun++mejAfnX1Np2p2Os6ZDqOnXCXFnOu6OVT1HTHqCDwQeQaANyiiigArNH3RWlWaCMDmgBa + Q/dNGR6igkYPNAGlRRRQAVmj7orSrNBGBzQAtIfumjI9RQSMHmgDSooooAKKKKAM3A9BRgegpaKAEIGD + xWlWafumtKgAooooAzQBgcUYHoKB90UtACEDB4rSrNP3TWlQAUUUUAZoAwOKMD0FA+6KhvL2202xmvr2 + 4S3tYFLyzOcKqj/OOOSaAEvbu106xmvr2eO3tIFLyzOcKqj/ADjjkmvmD4nfE+68b332O0Z4dEgcmGI8 + GUj+N/6DoKT4l/Ey68bX32O03waJA5MMJ4aVv77+/oOgrzmgAooooAKKKKACiiigAooooAKKKKACiiig + Ar0D4b/Ee+8CanskLT6TOwNxbA52n++vowA+hH4V5/RQB9x6ZqFjrGmW+o6dcpcWdwoaOVOh7c9wQeCD + yDwatYHoK+UPhz8R7zwPqPlyb7jSZyDcWwPKn++mejD06H8q+ptN1Ky1nTbfUdNuUubO4QNHKnQjpj1B + B4IPIPBoAskDB4rSrNP3TWlQAUUUUAZoAwOKMD0FA+6KWgBCBg8VpVmn7prSoAKKKKAM0AYHFGB6Cgfd + FLQAmB6CilooATI9RRkeorSooAzSRg81pUVmgDA4oA0qKzcD0FBAweKAAEYHNGR6itKigDNJGDzWlRWa + AMDigDSorNwPQVBe3dpp1jNfX08dvawKXlmc4VV/zxxyTQAXd7a6dYTX17PHb2kC75ZnOFVR/nHHJNfL + /wAS/iZdeNr77Hab4NEgcmGI8NK399/f0HQUvxO+J9143vTZ2heDRIHJhiPDSkfxv/QdBXnFABRRRQAU + UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFd78OviLeeBtS2Sb59JnYG4ts8j/AG0z0YD6ZrgqKAPu + TTtSsdY0yDUdOuUubO4TdHKh6jpj1BB4IPIPBrbr5A+G/wASL7wJqfluWuNJnINxbA/dP99fRgB9CPwr + 6j03ULHWdNg1HTrhLiznXdHKnft9QQeCDyDQBuUVm4HoKCBg8UAAIwOaMj1FaVFAGaSMHmtKis0AYHFA + GlRWbgegoIGDxQAAjA5oyPUVpUUAZuR6iitKigAooooAKzR90VpVmgjA5oAWkP3TRkeooJGDzQBpUUUU + AFZo+6K0qxru9tdOsJr69njt7SBd8sznCqo/zjjkmgBby8ttNsZ76+uEgtYFLyzOcKqj/OOOSa+XviV8 + TLrxtffY7Rnt9DgcmGI8NKR0d/f0HQUfEv4mXXja++x2m+DRIHJhhPDSt/ff39B0Fec0AFFFFABRRRQA + UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXffDn4jXngbUfLffcaTOwNxbZ5B/vpnow/X+X + A0UAfcmm6lZaxptvqOnXKXFncKGjlQ8Htz3BB4IPIPBqyfumvlD4c/Ee88D6j5cm+40mcg3FsDyp/vpn + ow9Oh/KvqbTtSsdY0yDUdOuUubO4TdHKh6jpj1BB4IPIPBoA26KKKACs0fdFaVZoIwOaAFpD900ZHqKC + Rg80AaVFFFABRRRQBm4HoKMD0FLRQAhAweK0qzT901pUAFFFFAGaAMDijA9BQPuinIMsBwB1JPQDvQBW + vbu006xmvr6eO3tYFLyzOcKq/wCeOOSa+YPid8T7rxve/Y7QvBokDkwxHhpSP43/AKL0FL8UviTceMtU + exsnMWh28hEMYJ/fEceY39B2Feb0AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFF + FABRRRQAUUUUAFegfDf4kX3gTU/LctPpM7A3FsDnaf76+jAD6EfhXn9FAH3Hpuo2OsaZb6jptwlxZzqG + jlToe3PcEHgg8g8GrWB6CvlL4a/ES68D6oIpmabR7hh9pgHO3oPMX/aHp3H4V9WqyOiyRuHjdQyMDkMp + 5Bz6YNAAQMHitKs0/dNaVABRRRQBmgDA4owPQUD7opaAEwPQUUtFACZHqKMj1FaVFAGaSMHmtKis0AYH + FAGlRWbgegoIGDxQAAjA5qK7ga8sLq1jkCSTQPEr5+6WUgH8Ca16KAPgi5t5rS6ltbhGinhcxyRsMFWU + kEH3BGKr19c+N/g7oPjO6a/82XT9Rb708Khlk92U9T7giuB/4Ztj/wChw/8AKb/9toA8Eor3z/hm2P8A + 6HD/AMpv/wBto/4Ztj/6HD/ym/8A22gDwOivoD/hmX/qbv8Aym//AG2j/hmX/qbv/Kb/APbaAPn+ivoD + /hmX/qbv/Kb/APbai/4Ztj/6HD/ym/8A22gDwSivQPiT8N1+HraaBqx1A3yyHd9n8rbt2/7TZzurz+gA + ooooAKKKKACiiigAooooAKKKKACiu4+G/gBfiBf31qdTNh9lhEu77P5u7JxjG5a9D/4Ztj/6HD/ym/8A + 22gDwSivoD/hmX/qbv8Aym//AG2j/hmX/qbv/Kb/APbaAPn+ivoD/hmX/qbv/Kb/APbaj/4Ztj/6HD/y + m/8A22gDwOivfP8Ahm2P/ocP/Kb/APbaP+GbY/8AocP/ACm//baAPCIo2lkWONSzuQqqoyWJ4AA7nNfb + Wh2cumeHNJsLlgbi1soYJSDkFlRVbn6iuU8GfBjQfCF7HqUk02o6hFzHJKqqkZ9VUdD7kmvS6AM0kYPN + aVFZoAwOKANKis3A9BQQMHigABGBzRkeorSooAzcj1FFaVFABRRRQAVmj7orSrNBGBzQAtIfumjI9RQS + MHmgDSooooAKzR90VpVmgjA5oAWkP3TRkeooJGDzQBpUUUUAFZo+6K0qzQRgc0AeE/tI/f8ADH+5c/zj + rwivd/2kfv8Ahj/cuf5x14RQAUUUUAFFFFABRRRQAUUUUAFFFFAHtn7OX/Ie13/ryX/0OvoE/dNfPv7O + X/Ie13/ryX/0OvoIkYPNAGlRRRQAVmj7orSrNBGBzQAtIfumjI9RQSMHmgDSooooAKzR90VpVmgjA5oA + WkP3TRkeooJGDzQBpUUUUAFFFFAGbgegowPQUtFACEDB4rSrNP3TWlQAUUUUAZoAwOKMD0FA+6KWgBCB + g8VpVmn7prSoAKKKKAM0AYHFGB6CgfdFLQAhAweK0qzT901pUAfP37TH+t8M/wC7df8AtKvAa9+/aY/1 + vhn/AHbr/wBpV4DQAUUUUAFFFFABRRRQAUUUUAFFFFAHt/7Nn/Ixa3/16J/6HX0hXzf+zZ/yMWt/9eif + +h19IUAZoAwOKMD0FA+6KWgBCBg8VpVmn7prSoAKKKKAM0AYHFGB6CgfdFLQAhAweK0qzT901pUAFFFF + AGaAMDijA9BQPuiloATA9BRS0UAJkeooyPUVpUUAZpIwea0qKzQBgcUAaVFZuB6CggYPFAACMDmjI9RW + lRQBmkjB5rSorNAGBxQBpUVm4HoKCBg8UAAIwOaMj1FaVFAGaSMHmtKis0AYHFAHiH7TH+t8M/7t1/7S + rwGvd/2kfv8Ahj/cuf5x14RQAUUUUAFFFFABRRRQAUUUUAFFFFAHt/7Nn/Ixa3/16J/6HX0hXzX+zl/y + Htd/68l/9Dr6CIGDxQAAjA5oyPUVpUUAZpIwea0qKzQBgcUAaVFZuB6CggYPFAACMDmjI9RWlRQBmkjB + 5rSorNAGBxQBpUVm4HoKCBg8UAAIwOaMj1FaVFAGbkeoorSooAKKKKACs0fdFaVZoIwOaAFpD900ZHqK + CRg80AaVFFFABWaPuitKs0EYHNAC0h+6aMj1FBIweaANKiiigArNH3RWlWaCMDmgDwn9pH7/AIY/3Ln+ + cdeEV7v+0j9/wx/uXP8AOOvCKACiiigAooooAKKKKACiiigAooooA9s/Zy/5D2u/9eS/+h19An7pr59/ + Zy/5D2u/9eS/+h19BEjB5oA0qKKKACs0fdFaVZoIwOaAFpD900ZHqKCRg80AaVFFFABWaPuitKs0EYHN + AC0h+6aMj1FBIweaANKiiigAooooAzcD0FGB6ClooAQgYPFaVZp+6a0qACiiigDNAGBxRgegoH3RS0AI + QMHitKs0/dNaVABRRRQBmgDA4owPQUD7opaAEIGDxWlWafumtKgD5+/aY/1vhn/duv8A2lXgNe/ftMf6 + 3wz/ALt1/wC0q8BoAKKKKACiiigAooooAKKKKACiiigD2/8AZs/5GLW/+vRP/Q6+kK+b/wBmz/kYtb/6 + 9E/9Dr6QoAzQBgcUYHoKB90UtACEDB4rSrNP3TWlQAUUUUAZoAwOKMD0FA+6KWgBCBg8VpVmn7prSoAK + KKKAM0AYHFGB6CgfdFLQAmB6CilooATI9RRkeorSooAzSRg81pUVmgDA4oA0qKzcD0FBAweKAAEYHNGR + 6itKigDNJGDzWlRWaAMDigDSorNwPQUEDB4oAARgc0ZHqK0qKAM0kYPNaVFZoAwOKAPEP2mP9b4Z/wB2 + 6/8AaVeA17v+0j9/wx/uXP8AOOvCKACiiigAooooAKKKKACiiigAooooA9v/AGbP+Ri1v/r0T/0OvpCv + mv8AZy/5D2u/9eS/+h19BEDB4oAARgc0ZHqK0qKAM0kYPNaVFZoAwOKANKis3A9BQQMHigABGBzRkeor + SooAzSRg81pUVmgDA4oA0qKzcD0FBAweKAAEYHNGR6itKigDNyPUUVpUUAFFFFABWaPuitKs0EYHNAC0 + h+6aMj1FBIweaANKiiigArNH3RWlWaCMDmgBaQ/dNGR6igkYPNAGlRRRQAVmj7orSrNBGBzQB4T+0j9/ + wx/uXP8AOOvCK93/AGkfv+GP9y5/nHXhFABRRRQAUUUUAFFFFABRRRQAUUUUAe2fs5f8h7Xf+vJf/Q6+ + gT9018+/s5f8h7Xf+vJf/Q6+giRg80AaVFFFABWaPuitKs0EYHNAC0h+6aMj1FBIweaANKiiigArNH3R + WlWaCMDmgBaQ/dNGR6igkYPNAGlRRRQAUUUUAZuB6CjA9BS0UAIQMHitKs0/dNaVABRRRQBmgDA4owPQ + UD7opaAEIGDxWlWafumtKgAooooAzQBgcUYHoKB90UtACEDB4rSrNP3TWlQB8/ftMf63wz/u3X/tKvAa + 9+/aY/1vhn/duv8A2lXgNABRRRQAUUUUAFFFFABRRRQAUUUUAe3/ALNn/Ixa3/16J/6HX0hXzf8As2f8 + jFrf/Xon/odfSFAGaAMDijA9BQPuiloAQgYPFaVZp+6a0qACiiigDNAGBxRgegoH3RS0AIQMHitKs0/d + NaVABRRRQBmgDA4owPQUD7opaAEwPQUUtFACZHqKMj1FaVFAGaSMHmtKis0AYHFAGlRWbgegoIGDxQAA + jA5oyPUVpUUAZpIwea0qKzQBgcUAaVFZuB6CggYPFAACMDmjI9RWlRQBmkjB5rSorNAGBxQB4/8AtH6V + cXGk6JqcaEwWsk0cxHYyBNpP/fBr5yr7oubS2vrOazvII57adSksUi5DKexFeWX37P3hi4uGltdR1G0j + PPlDbIF9gSM0AfNVFfSP/DNuif8AQev/APv2lH/DNuif9B6//wC/aUAfN1FfSP8Awzbon/Qev/8Av2lQ + /wDDOug/9B/UP+/SUAfOlFfRf/DOug/9B/Uf+/SUf8M66D/0H9Q/79JQB86UV9I/8M26J/0Hr/8A79pR + /wAM26J/0Hr/AP79pQB83UV9I/8ADNuif9B6/wD+/aU6z/Z88MwzLJdapqNyi8+WAkYPsTgmgDM/Zv0m + 4X+2dYdCts6pbRsejMCWb8ht/Ovf6xdP06y0nT4LDT7WO2tIF2xxRrhVHX6kk8knknk1YIGDxQAAjA5o + yPUVpUUAZpIwea0qKzQBgcUAaVFZuB6CggYPFAACMDmjI9RWlRQBmkjB5rSorNAGBxQBpUVm4HoKCBg8 + UAAIwOaMj1FaVFAGbkeoorSooAKKKKACs0fdFaVZoIwOaAFpD900ZHqKCRg80AaVFFFABWaPuitKs0EY + HNAC0h+6aMj1FBIweaANKiiigArNH3RWlWaCMDmgBaQ/dNGR6igkYPNAGlRRRQAVmj7orSrNBGBzQAtI + fumjI9RQSMHmgDSooooAKzR90VpVmgjA5oAWkP3TRkeooJGDzQBpUUUUAFZo+6K0qzQRgc0ALSH7poyP + UUEjB5oA0qKKKACs0fdFaVZoIwOaAFpD900ZHqKCRg80AaVFFFABRRRQBm4HoKMD0FLRQAhAweK0qzT9 + 01pUAFFFFAGaAMDijA9BQPuiloAQgYPFaVZp+6a0qACiiigDNAGBxRgegoH3RS0AIQMHitKs0/dNaVAB + RRRQBmgDA4owPQUD7opaAEIGDxWlWafumtKgAooooAzQBgcUYHoKB90UtACEDB4rSrNP3TWlQAUUUUAZ + oAwOKMD0FA+6KWgBCBg8VpVmn7prSoAKKKKAM0AYHFGB6CgfdFLQAhAweK0qzT901pUAFFFFAGaAMDij + A9BQPuiloATA9BRS0UAFFFFACH7prSoooAKKKKAM0fdFLRRQAh+6a0qKKACiiigDNH3RS0UUAIfumtKi + igAooooAzR90UtFFACH7prSoooAKKKKAM0fdFLRRQAh+6a0qKKACiiigDNH3RS0UUAIfumtKiigAoooo + AzR90UtFFACH7prSoooAKKKKAM0fdFLRRQAUUUUAf//Z + + + + + /9j/4AAQSkZJRgABAQEASABIAAD/4RwKRXhpZgAATU0AKgAAAAgABQESAAMAAAABAAEAAAExAAIAAAAm + AAAASgEyAAIAAAAUAAAAcIdpAAQAAAABAAAAhIglAAQAAAABAAAA8AAAAShXaW5kb3dzIFBob3RvIEVk + aXRvciAxMC4wLjEwMDExLjE2Mzg0ADIwMjM6MDk6MTIgMjA6MDY6MDcAAAWQAwACAAAAFAAAAMaQBAAC + AAAAFAAAANqSkQACAAAAAzAwAACSkgACAAAAAzAwAACgAQADAAAAAQABAAAAAAAAMjAyMzowOToxMiAx + OToyMjowMgAyMDIzOjA5OjEyIDE5OjIyOjAyAAAAAAEACwACAAAAJgAAAQIAAAAAV2luZG93cyBQaG90 + byBFZGl0b3IgMTAuMC4xMDAxMS4xNjM4NAAABgEDAAMAAAABAAYAAAEaAAUAAAABAAABdgEbAAUAAAAB + AAABfgEoAAMAAAABAAIAAAIBAAQAAAABAAABhgICAAQAAAABAAAaewAAAAAAAABgAAAAAQAAAGAAAAAB + /9j/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0 + Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIy + MjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAEAAQADASEAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAA + AAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0Kx + wRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4 + eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl + 5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQD + BAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygp + KjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOk + paanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIR + AxEAPwD26kNAGlRQBQk/1r/7xptAFy2/1P4mpaAKt199fpUHagCa1/1h+lW6AIrj/Ut+H86pigBU/wBY + v+8P51oUAFZo6CgBavRf6pP90UAPqlcf65qAI6s2v3W+tAFiq9191frQBWqSD/XL+P8AKgC7TJf9U/8A + umgCjRQAUhoA0qKAKEn+tf8A3jTaALdt/qfxNTUAVbr76/SoKAJrX/WH6VboAiuP9Q34fzqnQAqf6xf9 + 4fzrQoAKzR0FAC1ei/1Kf7ooAfVK4/1zfhQBHVm1+631oAsVXuvur9aAK1SQf69fx/lQBdpkv+qf/dNA + FGigC95Uf/PNfyo8qP8A55r+VAFIO+Pvv/31Rvf++/8A31QBbjjRo1JRSSOSRTvKj/55r+VAFaYlJSEJ + UegOKj3v/ff/AL6oAntwHDF/mx03c1N5Uf8AzzX8qAIrgBFUoNpz1Xiq+9/77/8AfVAD4iXlVWYsp7E5 + FWvKj/55r+VADZI0EbEIoIBIIHSqm9/77/8AfVAAXf8Avv8A99Vd8qP/AJ5r+VAB5Uf/ADzX8qpszB2A + ZgASAAelACb3/vv/AN9VZgVXjyyhjnqRmgCTyo/+ea/lVe4+RwE+UEc7eKAIt7/32/76qWD53If5gB/F + zQBY8qP/AJ5r+VRzIqRFlUK3qBg0AVt7/wB9v++qVWYuoLsQSAQT1oAueVH/AM81/Kjyo/8Anmv5UAPo + oAzR0FLQBei/1KfSn0AUrj/XNUdAFm16N9asUAQXX3F+tVaAJIP9ev4/yq7QAyX/AFT/AO6ao0AIelaV + ABWe/wDrH/3jQAlXLb/Uj6mgCWqt1/rF+lAEHaprX/WH6UAW6iuP9SfqKAKdKn+sT/eFAGhRQBS8+X+/ + +gpDPL/f/QUAWfs0X90/nR9mi/un86AK5lkRiithVOBxR58v9/8AQUASxxrMm+TlietP+zReh/OgCKXM + DARnAIye9M8+X+/+goAdGTO22Q5AGR2qb7NF6H86AGSRLEm9Bhh0Oai8+X+/+goABLI7BWbKscHirH2a + L0P50AH2aL+6fzqsJ5f7/wCgoAXz5f7/AOgqZIEdFdgSzDJ5oAd9mi9D+dQO7QuUQ4UdsUAJ58v9/wDQ + VJEonyZOSOB2oAk+zReh/Oo5VEABj4J4PegCPz5f7/6ClR2mcI5yp6jFAE/2aL0P501oI0RmUEMoyOaA + IfPl/v8A6Cjz5f7/AOgoAjpDQBpUUAUJP9a3+8abQBctv9T+JqWgCrdffX6VB2oAmtf9YfpVugCK4/1L + fh/OqdACp/rF/wB4fzrQoAiuLmG0t5Li4kWKGNSzuxwFA6k15l/wunwML/7J/aM+3OPtAtm8rP16498U + Ad5BPDdW8VxbypNDKoeOSM5VlPQg9xWnF/qU/wB0UAPqlcf65vwoAjqza/db60AWKr3X3V+tAFapIP8A + Xr+P8qALtMl/1T/7poAo0UAWfso/vmj7Iv8AfNADBdP/AHVo+1P/AHVoAcLcSDeWILc4FL9lX++aAGmR + oCY1wQOcmk+1P/dWgBVH2kksdu3jinfZV/vmgBGX7NhlOc8c037U/wDdWgAErTkRsAAe4p/2Vf75oAQ2 + 4QFwxJXn8qb9qf8AurQB5j8edUurb4atHC+wXV7FBLt7ptZ8fmgr5azQB6d8LPilN4TuV0rVXeXRJW68 + lrYn+Jf9n1H4ivqC2v0ntYprZ4pYJEDRyIcqynoQaAJftT/3VpyxeePMY4J7CgBfsq/3zTSTbHavzbue + aAE+1P8A3VpQTcna3y454oAd9lX++aRovIHmKSSOxoAb9qf+6tHns/yEABuM/WgB/wBlX++aPso/vmgC + xRQBmjoKWgC9F/qU+lPoApXH+uNR0AWbXo31qxQBBdfcX61VoAkg/wBev4/yq7QAyX/VP/umqNAHlf7Q + P/JObb/sJxf+i5a+ZaACvUPhb8UpfCU6aXqrvNokrfVrZj/Ev+z6j8fqAfTME8N1bx3FvMksMih0kRsq + wPQg1o23+pH1NAEtVbr/AFi/SgCCprX/AFjfSgC3UVx/qT9RQBTpU/1if7w/nQBoUUAV/tQ/uH86PtY/ + uH86AGC1f+8tH2V/7y0AOFwIxsKkleM0v2of3D+dADTG05MgIAPGDSfZX/vLQAqk2xIYbt3PFO+1D+4f + zoARm+04VRtxzzTfsr/3loAPKaAiQkEL2FP+1D+4fzoAQ3AkBQKQW4zn1pv2V/7y0AeU/tCxGP4c2uSD + nU4un/XOWvmGgAo70AeofC34pS+E7lNK1Rnl0SVuO7WzH+Jf9n1H4j3+oLO+gmtIprd1nhlXfHJGwKup + 5BHtQBP9qH9w/nTSDcncvy7eOaAE+yv/AHlpQDbHc3zZ44oAd9qH9w/nSNL548sDBPc0AN+yv/eWj7Oy + fOWBC84+lAD/ALUP7h/Oj7UP7h/OgCtSGgDSooAoSf61v9402gC5bf6n8TUtAFW6++v0qDtQBNa/6w/S + rdAEVx/qW/D+dU6AFT/WL/vD+daFAHkX7Rf/ACTq0/7Ccf8A6Lkr5doAKKADpXqHwt+KM/hOdNL1V3m0 + SVsDubYk/eX/AGfUfiPcA+mbe4hu7eO4t5UmglUPHIhyrqehB9KvWv3W+tAFiq9191frQBWqSD/Xr+P8 + qALtMl/1T/7poAo0UASeRL/d/Wg28v8Ad/WgCf7TH6n8qX7TH6n8qAK5ikdi6r8rHI5o8iX+7+tAEsci + wrsfIYGn/aY/U/lQBFJmdgYxkAYPameRL/d/WgB0YMDbpBgEYHepvtMfqfyoAZJIsqbEyWPTiovIl/u/ + rQACKRGDMvCnJ5qx9pj9T+VAHkv7REiyfDq12npqcfb/AKZyV8v0AFFABRQB6h8LfilL4TuU0rVZHm0W + V+pyTbE/xL/s+o/Ee/1BYXlvNapcQyrLDMoeORDlWUjgg0AWvtMfqfyqORhOAI+SOT2oAj8iX+7+tKiN + C4dxhR15oAn+0x+p/KmtOjoUUnLDA4oAh8iX+7+tHkS/3f1oAu0UAZo6CloAwtV+JXhDw9c/YdT1uCK5 + QYeNFeQr7HaDg+xqh/wuf4f/APQwL/4DTf8AxFAFeb4w+AXkLDxAnP8A07Tf/E1H/wALf8Bf9DAn/gNN + /wDE0ATwfGTwBGGz4gTn/p2m/wDiKl/4XP8AD/8A6GBP/Aab/wCIoAin+MngB1AHiBOD/wA+03/xFQf8 + Lf8AAX/QwJ/4DTf/ABNAD4vjD4BWVWPiBOP+nab/AOJqz/wuf4f/APQwL/4DTf8AxFACP8ZvADIw/wCE + gTkEf8e03/xFVP8Ahb/gL/oYE/8AAab/AOJoA4D4xePfDHifwVBYaNqq3Vyt9HMyCF1woRwTlgO7CvCK + ACigAooAK9Q+FvxTn8J3C6XqrvLosjcHq1sT/Ev+z6j8R7gH0zBPFdW8VxbyJLBKodJEbKsp6EGrdr/r + D9KALdRXH+pP1FAFOlT/AFif7woA0KKAGebH/fX86PNj/wCei/nQBSCPj7jflWL4vvbnSfButahbbkuL + eylkjYg/KwU4NAHxbJI8srySOzu5LMzHJJPc0ygAooAKKACigAooAKKACigAooAKKACjJ9aAPT/hb8Up + fCM66XqrvLokrduWtmP8S/7PqPxHv9QWFzBcRpcQzRyQSoGjkVsqwPQg96ALvmx/31/Oo5nV4iqMGY9h + zQBW2P8A3G/KlVWDqSjAAgkkUAXPNj/vr+dHmx/31/OgCjSGgDSrlviR/wAk28Rf9eEv/oJoA+KaKACi + gAooAKKACigAooAKKACigAooAKKACvUPhb8U5vCc6aTqrPLokjcd2tmP8S/7PqPxFAH0zb3EN1bxXFvK + k0Mqh45IyCrKehB9Kswf69fx/lQBdpkv+qf/AHTQBRooATI9aCRQBpVy3xI/5Jt4i/68Jf8A0E0AfFNF + ABRQAUUAFFABRQAUUAFFABRQAUUAFFABQDigD1D4W/FGfwncJpequ82iStgdzbEn7y/7PqPxHv8ATthc + Q3awXFvKk0Eq745EOVdSOCD6UAaVMl/1T/7poAoZFGR60AaVFAGaAMVznxA4+HfiL/sHy/8AoNAHxrRQ + AUUAFFABRQAUUAFFABRQAUUAFFABRQAUUAFesfB74j3Wi6va+HL5zNpd7MsUW8827scAr/skkZH4+tAH + 0ttweaVAPNT/AHhQBoUUAFFAGaOlc58Qf+Sd+Iv+wfL/AOg0AfGtFABRQAUUAFFABRQAUUAFFABRQAUU + AFFABRQAV6B8KvBV74l8WWd4sZGm6fOk9zMeB8pDBAe5OPy5oA+ricknuaVP9Yn+8KANCigChvf++3/f + RpC7/wB9v++qALvlR/8APNfyrl/iOiL8N/EWFUf6BL0H+yaAPiuigAooAKKACigAooAKKACigAooAKKA + CigAooA7L4feAL/xxqvlxgw6fCwNzdEcKP7q+rH0/E19YeH9F0/QNPttL023WG1hGAnUk+rHuSe9AG15 + Uf8AzzX8qbJGgjYhFBAJBAoAqb3/AL7f99Uu9/77f99GgBtIaANKuW+JH/JNvEX/AF4S/wDoJoA+KaKA + CigAooAKKACigAooAKKACigAooAKKACuz+H/AMPtR8b6t5cRMGnQnNzdkcKP7o9WPp+JoA+q9F0Ww8P6 + RBpemwCG0hGFXuT3LHuT3NakH+vX8f5UAXaZL/qn/wB00AUaKALn2eL+6fzNH2aL+6fzNAFYTy/3/wBB + XP8Ajtbi78A+III8vI1hNtQDr8pP9KAPi49aKACigAooAKKACigAooAKKACigAooAKKAOz+H/wAPr/xz + qgjjDwafCQbm7K5C/wCyPVj2H519Y+H9D07Q9Mh0vTrcQ2kC/Ko7nuxPcn3oA1vs0X939TTJI1iTegww + 6HNAEXny/wB/9BQJZHYKzZVjg8dqALH2aL+6fzNH2eL+6fzNAEtFAGaOgpe9AHnms/Afwprd819E11p7 + S/M8Vsw8ssepAIOPw49qzf8AhnDw3/0FtT/NP/iaAIpP2d/DUblf7V1Tj3j/APiab/wz14Z/6CmqfnH/ + APE0ASRfs6+GpQcarqgx7x//ABNP/wCGcPDf/QW1P80/+JoAZJ+zp4ajAJ1XVDn3T/4mo/8Ahnrwz/0F + NU/OP/4mgBU/Z48Mu4X+1dU594//AImpv+GcPDf/AEFtT/NP/iaAEb9nHw0qlv7V1PgZ6p/8TUP/AAz1 + 4Z/6CmqfnH/8TQBxnxO+FWj+CPC0Wq2F7ezyvdpAVnK7cFXOeAOflFeQUAFFABRQAoBJwK7P4e/D+/8A + G+qbVDQabCw+03RHCj+6vq38upoA+q9H0ax0DSoNM023SC1hGFVR1Pck9ye5rVtf9Y30oAt1Fcf6k/UU + AU6VP9Yn+8P50AaFFAFT7U/91aPtT/3VoAf9kX+81H2Vf7zUAM894zsABCnAzR9qf+6tADlj88eYxIJ4 + wKX7Kv8AeagBrE2xwvO7nmk+1P8A3VoAVWNydrYGOeKd9lX+81ACNEIB5ikkjsab9qf+6tAB57v8hCgN + wfxp/wBlX+81AHk/7Q0Qj+HVrgk51OLr/wBc5K+YKACigAooA7T4ffD2+8b6sFXdBpkLA3VyR90f3V9W + P6dTX1joOhafoukw6bp0C29rbjaqqOSe5J7k+tAGl9lX+81Iy/ZsMpznjmgBv2p/7q0CRpyI2wAe4oAf + 9lX+81IbcIC4YkryM+1ADftT/wB1aPtT/wB1aAIaQ0AaVFAFCT/Wt/vGm0AXLb/U/ialoAq3X31+lQUA + TWv+sP0q3QBFcf6lvw/nVOgBU/1i/wC8P51oUAeRftF/8k6tP+wnH/6Lkr5doAKKACu0+H3w/v8Axzqe + xA0OnQsPtNyRwB/dX1Y//roA+q9G0ew0DS4NN023WC1gXCqOp9ST3J7mti0+631oAsVXuvur9aAK1SQf + 69fx/lQBdpkv+qf/AHTQBRooAn+yt/eH5Un2Vv7w/KgB32sf3D+dL9rH9w/nQAzyGk+cMAG5xS/ZW/vD + 8qAFEn2ceWRuI5yKX7UP7h/OgBpBuTkfLt45o+yt/eH5UAAU2x3H5s8cU77UP7h/OgBDL548sLgnuaT7 + K394flQAn2do/nLA7ecfSn/ax/cP50AeTftDS+b8ObXjGNTi/wDRclfMNABRQB2nw++H2oeNtW2Lug02 + E5ubrHA/2V9WP6dTX1jomgWOi6RBp2mQrb2cIwiDqT3JPcnrmgDQ+yt/eH5UBvsxKkbt3PFADvtQ/uH8 + 6aW+04UDbjnmgA+yt/eH5UeUYCJCQQOwoAd9qH9w/nSG4Eg2bSN3Gc+tACfZW/vD8qPsrf3h+VAFqigD + NHQUtAF6L/Up9KfQBSuP9c1R0AWbXo31qxQBBdfcX61VoAkg/wBev4/yq7QAyX/VP/umqNAHlf7QP/JO + bb/sJxf+i5a+ZaACu0+H3w9v/HOp7U3QadCR9pusZC99q+rH/wCuaAPqvR9HsNA0uHTdMt1gtYRhUHc9 + yT3J7k1t23+pH1NAEtVbr/WL9KAIO1TWv+sb6UAW6iuP9SfqKAKdKn+sT/eH86ANCigCH7TH7/lR9pj9 + T+VAEAt5f7o/Oj7PL/dH50ATJOiIEbO5eDxS/aY/f8qAInRpnLoMqfWm/Z5f7o/OgCSNvIyJOCeRjmn/ + AGmP1P5UAMkYTgLHkkcnPFR/Z5f7o/OgBURoXEjjCjrg1N9pj9/yoARp0dSi5ywwOKh+zy/3R+dAHlvx + /tJ3+G8bLGSsWoxO5H8K7XXJ/FgPxr5gwc0Adn8PPh9f+ONU2Lug0yFgbm6I4X/ZX1Y/p3r6v0bQLPQt + Jg07S7ZILSEYRV6n/aJ7k9zQBf8As8v90fnUsciwrsfIYUAO+0x+/wCVRyAztmMZAGDnigBn2eX+6Pzp + 8YMDbpBgEYGOaAJPtMfv+VNkkWZNiZLHpxQBF9nl/uj86UQyIwdhwpyeaAJvtMfqfyo+0x+/5UAVKQ0A + aVFAFCT/AFrf7xptAFy2/wBT+JqWgCrdffX6VB2oAmtf9YfpVugCK4/1Dfh/OqdACp/rF/3h/OtCgCjq + +k2euaVc6bqEQltbhNkiHuP6Eda8W/4Z30n+0RKNfuxZZz5H2dS+PTfnH47aAPV9H0ew0HS4NN022WC1 + hGFRep9Sx7k+tbsX+qT/AHRQA+qVx/rm/CgCOrNr91vrQBYqvdfdX60AVqkg/wBev4/yoAu0yX/VP/um + gCjRQA7Y/wDcb8qQxv8A3G/KgC750f8AfX86PNj/AL6/nQBUdWZ2IViCSQQKTy3/ALjflQBYhdUj2uQp + z0NSebH/AH1/OgCvP+8YFPmwOcc1H5b/ANxvyoAkg/duS4KgjvxVjzY/76/nQBHM6vEVRgzHoBVfy3/u + N+VACqrB1JVgAQSSKt+bH/fX86ADzo/76/nVIRyAfcb8qADy3/uN+VW45EWNQWAIGCCaAHebH/fX86qy + gvKzICy+oFADdj/3G/KpoCIwwf5STxnigCbzY/76/nUM5EgUIdxB5xzQBD5b/wBxvyp0QKSqzgqo7kUA + WvNj/vr+dNeRGjYBgSQQADQBV8t/7jflRsf+435UAX6KAM0dKWgC9F/qU+lPoApXH+ub8KjoAs2vRvrV + igCC6+4v1qrQA+D/AF6/j/Kr1ADJf9U/+6ao0AIelaVABWe/+tf/AHjQAlXLb/Uj6mgCWql1/rF+lAEP + aprX/WN9KALdRXH+pP1FAFOlT/WJ/vCgDQooAKKAMwEYpcigC/F/qU+lPoApXB/fN+FRZHrQBZtOj/Wr + NAFe6+4v1qrketAEkB/fr+P8qvUAMl/1L/7pqhkUAISMVp0AFZ8hHmv/ALxoAbketXbb/Uj6mgCWql0f + 3i/SgCDI9antT+8b6UAW6iuf9QfqKAKWRTkI81P94UAaFFAGbgelBAxQBpUUAZ8gHmv/ALxpuB6UAXLb + /U/iamoAqXQ+dfpUGB6UAT2o/eH/AHat0ARXH+ob8P51SwPSgByAeYn+8P51oUAFZoAwKADA9Kvxf6lP + 90UAPqlcD9834UARYHpVq0+631oAsVXu/ur9aAKuB6VJbj9+v4/yoAvUyX/VP/umgChgelGB6UALSGgD + SooAoSf61/8AeNNoAuW3+p/E1LQBVuvvr9Kg7UATWv8ArD9Kt0ARXH+pb8P51TFACp/rF/3h/OtCgArN + HQUALV6L/VJ/uigB9Urj/XNQBHVm1+631oAsVXuvur9aAK1SQf65fx/lQBdpkv8Aqn/3TQBRooA//9kA + /9sAQwADAgIDAgIDAwMDBAMDBAUIBQUEBAUKBwcGCAwKDAwLCgsLDQ4SEA0OEQ4LCxAWEBETFBUVFQwP + FxgWFBgSFBUU/9sAQwEDBAQFBAUJBQUJFA0LDRQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQU + FBQUFBQUFBQUFBQUFBQUFBQU/8AAEQgBZwFnAwEiAAIRAQMRAf/EAB8AAAEFAQEBAQEBAAAAAAAAAAAB + AgMEBQYHCAkKC//EALUQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEV + UtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6 + g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn + 6Onq8fLz9PX29/j5+v/EAB8BAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKC//EALURAAIBAgQEAwQH + BQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKBCBRCkaGxwQkjM1LwFWJy0QoWJDThJfEXGBkaJicoKSo1 + Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZmqKjpKWm + p6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uLj5OXm5+jp6vLz9PX29/j5+v/aAAwDAQACEQMR + AD8A/SWiiigCW2/4+of+uq/zFdTXLW3/AB9Q/wDXVf5iupoAKgvv+PG4/wCubfyNT1Bff8eNx/1zb+Ro + A5j/AOtRR/8AWooAltv+PqH/AK6r/MV1Nctbf8fUP/XVf5iupoAKgvv+PG4/65t/I1PUF9/x43H/AFzb + +RoA5j/61FH/ANaigCW2/wCPqH/rqv8AMV1Nctbf8fUP/XVf5iupoAKgvv8AjxuP+ubfyNT1Bff8eNx/ + 1zb+RoA5j/61FH/1qKAJbb/j6h/66r/MV1Nctbf8fUP/AF1X+YrqaACoL7/jxuP+ubfyNT1Bff8AHjcf + 9c2/kaAOY/8ArUUf/WooAltv+PqH/rqv8xXU1y1t/wAfUP8A11X+YrqaACoL7/jxuP8Arm38jU9QX3/H + jcf9c2/kaAOY/wDrUUf/AFqKAJbb/j6h/wCuq/zFdTXLW3/H1D/11X+YrqaACoL7/jxuP+ubfyNT1Bff + 8eNx/wBc2/kaAOY/+tRR/wDWooAltv8Aj6h/66r/ADFdTXLW3/H1D/11X+YrqaACoL7/AI8bj/rm38jU + 9QX3/Hjcf9c2/kaAOY/+tRR/9aigAooooATzE/vUeYv96uvooA5S1kH2q3+b/lqv8xXV1Bff8eNx/wBc + 2/ka5by14+XtQB2FQX3/AB43H/XNv5GuX8tf7tSWsY+1W/y/8tV/mKAIvMXj5u1L5i/3q6+igDlLWQfa + rf5v+Wq/zFdXUF9/x43H/XNv5GuW8tePl7UAdhUF9/x43H/XNv5GuX8tf7tSWsY+1W/y/wDLVf5igCLz + F4+btS+Yv96uvooA5S1kH2q3+b/lqv8AMV1dQX3/AB43H/XNv5GuW8tePl7UAdhUF9/x43H/AFzb+Rrl + /LX+7UlrGPtVv8v/AC1X+YoAi8xePm7UvmL/AHq6+igDlLWQfarf5v8Alqv8xXV1Bff8eNx/1zb+Rrlv + LXj5e1AHYVBff8eNx/1zb+Rrl/LX+7UlrGPtVv8AL/y1X+YoAi8xePm7UvmL/err6KAOUtZB9qt/m/5a + r/MV1dQX3/Hjcf8AXNv5GuW8tePl7UAdhUF9/wAeNx/1zb+Rrl/LX+7UlrGPtVv8v/LVf5igCLzF4+bt + S+Yv96uvooA5S1kH2q3+b/lqv8xXV1Bff8eNx/1zb+RrlvLXj5e1AHYVBff8eNx/1zb+Rrl/LX+7UlrG + PtVv8v8Ay1X+YoAi8xePm7UvmL/err6KAOUtZB9qt/m/5ar/ADFdXUF9/wAeNx/1zb+RrlvLXj5e1AHY + VBff8eNx/wBc2/ka5fy1/u1Jaxj7Vb/L/wAtV/mKAIvMXj5u1L5if3q6+igDkPMT+9RXX0UAFFFFAEF9 + /wAeNx/1zb+RrmP/AK1dPff8eNx/1zb+RrlvMXj5u1ADqltv+PqH/rqv8xUPmL/eqS1kH2q3+b/lqv8A + MUAdXRRRQBBff8eNx/1zb+RrmP8A61dPff8AHjcf9c2/ka5bzF4+btQA6pbb/j6h/wCuq/zFQ+Yv96pL + WQfarf5v+Wq/zFAHV0UUUAQX3/Hjcf8AXNv5GuY/+tXT33/Hjcf9c2/ka5bzF4+btQA6pbb/AI+of+uq + /wAxUPmL/eqS1kH2q3+b/lqv8xQB1dFFFAEF9/x43H/XNv5GuY/+tXT33/Hjcf8AXNv5GuW8xePm7UAO + qW2/4+of+uq/zFQ+Yv8AeqS1kH2q3+b/AJar/MUAdXRRRQBBff8AHjcf9c2/ka5j/wCtXT33/Hjcf9c2 + /ka5bzF4+btQA6pbb/j6h/66r/MVD5i/3qktZB9qt/m/5ar/ADFAHV0UUUAQX3/Hjcf9c2/ka5j/AOtX + T33/AB43H/XNv5GuW8xePm7UAOqW2/4+of8Arqv8xUPmL/eqS1kH2q3+b/lqv8xQB1dFFFAEF9/x43H/ + AFzb+RrmP/rV099/x43H/XNv5GuW8xePm7UAOqW2/wCPqH/rqv8AMVD5i/3qktZB9qt/m/5ar/MUAdXR + RRQAUUUUAch5af3aPLX+7S0UAPtYx9qt/l/5ar/MV1dctbf8fUP/AF1X+YrqaACoL7/jxuP+ubfyNT1B + ff8AHjcf9c2/kaAOW8tePl7Uvlr/AHaX/wCtRQA+1jH2q3+X/lqv8xXV1y1t/wAfUP8A11X+YrqaACoL + 7/jxuP8Arm38jU9QX3/Hjcf9c2/kaAOW8tePl7Uvlr/dpf8A61FAD7WMfarf5f8Alqv8xXV1y1t/x9Q/ + 9dV/mK6mgAqC+/48bj/rm38jU9QX3/Hjcf8AXNv5GgDlvLXj5e1L5a/3aX/61FAD7WMfarf5f+Wq/wAx + XV1y1t/x9Q/9dV/mK6mgAqC+/wCPG4/65t/I1PUF8rPZ3CqCWMbAAdelAHLeWvHy9qXy1/u1RufEeiWO + sJpF3rmlW2rSEbbCa9hS4bPAxHuDH64rRlgeEssiFWHXjCn0IPegBbWMfarf5f8Alqv8xXV1y1t/x9Q/ + 9dV/mK6mgAqC+/48bj/rm38jU9QX3/Hjcf8AXNv5GgDlvLXj5e1L5a/3aX/61FAD7WMfarf5f+Wq/wAx + XV1y1t/x9Q/9dV/mK6mgAqC+/wCPG4/65t/I1PUF9/x43H/XNv5GgDlvLXj5e1L5a/3aX/61FAD7WMfa + rf5f+Wq/zFdXXLW3/H1D/wBdV/mK6mgAqC+/48bj/rm38jU9QX3/AB43H/XNv5GgDlvLXj5e1L5af3aX + /wCtRQAnlp/dopaKAE8xP71HmL/err6KAOUtZB9qt/m/5ar/ADFdXUF9/wAeNx/1zb+RrlvLXj5e1AHY + VBff8eNx/wBc2/ka5fy1/u1Jaxj7Vb/L/wAtV/mKAIvMXj5u1L5i/wB6uvooA5S1kH2q3+b/AJar/MV1 + dQX3/Hjcf9c2/ka5by14+XtQB2FQX3/Hjcf9c2/ka5fy1/u1Jaxj7Vb/AC/8tV/mKAIvMXj5u1L5i/3q + 6+igDlLWQfarf5v+Wq/zFdXUF9/x43H/AFzb+RrlvLXj5e1AHYVBff8AHjcf9c2/ka5fy1/u1Jaxj7Vb + /L/y1X+YoAi8xePm7UvmL/err6KAOUtZB9qt/m/5ar/MV1dQX3/Hjcf9c2/ka5by14+XtQB17fdP9a/P + r/gq5+1xrvwR8NaF4D8GahNpPiLxFbyXN3qVrK0c9rZg7FEbKQVZ23/MOR5fBr7WMa4PFfkB/wAFnf8A + k5rwj/2JVp/6W3tAHwlcXEl1cPJPI08spLvIzbmZicsxJJyT3Jr7z/YL/wCCid/8KNQsvAHxO1O41HwH + cOsVnqlyxkl0diMAHu0HqOq8la+AKF+8KAP6e9PuYbz7Bc208d1bXBilhuIXBjmjbBVlI+U5+8GHJAIN + dbX4p/8ABPj/AIKDyfBaa2+HXxGvJLr4f3B8qy1CRiz6K7HHzY5a3OckDlTyK/Xm3e3vLWC6t5Y7q1uI + 1lguIcPHNGwyrKR8vOdwYckAg0AdnUF9/wAeNx/1zb+Rrl/LX+7UlrGPtVv8v/LVf5igCLzF4+btS+Yv + 96uvooA5S1kH2q3+b/lqv8xXV1Bff8eNx/1zb+RrlvLXj5e1AHYVBff8eNx/1zb+Rrl/LX+7UlrGPtVv + 8v8Ay1X+YoAi8xePm7UvmL/err6KAOUtZB9qt/m/5ar/ADFdXUF9/wAeNx/1zb+RrlvLXj5e1AHYVBff + 8eNx/wBc2/ka5fy1/u1Jaxj7Vb/L/wAtV/mKAIvMXj5u1L5if3q6+igDkPMT+9RXX0UAFFFFAEF9/wAe + Nx/1zb+RrmP/AK1dPff8eNx/1zb+RrlvMXj5u1ADqltv+PqH/rqv8xUPmL/eqS1kH2q3+b/lqv8AMUAd + XRRRQBBff8eNx/1zb+RrmP8A61dPff8AHjcf9c2/ka5bzF4+btQA6pbb/j6h/wCuq/zFQ+Yv96pLWQfa + rf5v+Wq/zFAHV0UUUAQX3/Hjcf8AXNv5GuY/+tXT33/Hjcf9c2/ka5bzF4+btQA6pbb/AI+of+uq/wAx + UPmL/eqS1kH2q3+b/lqv8xQB1dFFFAEF9/x43H/XNv5GuY/+tXT33/Hjcf8AXNv5GuW8xePm7UAOr8f/ + APgs9/yc14R/7Eq0/wDS29r9f/MX1r8gP+Cz3/JzXhH/ALEq0/8AS29oA+BaKKKAFj/1i/X1x+tffH/B + Pz/goBN8FLqz+HnxFupLr4fzSeXY6hI536K7HuBy0BJyyjlD8wr4GpU++v19cUAf06280N5awXdtPHdW + 1xGssNxC4eOaNhlWUj5efvBhyQCDVm2/4+of+uq/zFfjz/wT9/b9m+Ct5afDz4i3ct18P5m2WOoSMXfR + XY85A5MBzllHKH5hX7A6fcw3n2C4tp47q2uTHNDcQyAxzRtgqykfKc/eDDkgEGgDrqKKKAIL7/jxuP8A + rm38jXMf/Wrp77/jxuP+ubfyNct5i8fN2oAdUtt/x9Q/9dV/mKh8xf71SWsg+1W/zf8ALVf5igDq6KKK + AIL7/jxuP+ubfyNcx/8AWrp77/jxuP8Arm38jXLeYvHzdqAHVLbf8fUP/XVf5iofMX+9UlrIPtVv83/L + Vf5igDq6KKKACiiigDkPLT+7R5a/3aWigB9rGPtVv8v/AC1X+Yrq65a2/wCPqH/rqv8AMV1NABUF9/x4 + 3H/XNv5Gp6gvv+PG4/65t/I0Act5a8fL2pfLX+7S/wD1qKAH2sY+1W/y/wDLVf5iurrlrb/j6h/66r/M + V1NABUF9/wAeNx/1zb+RqeoL7/jxuP8Arm38jQBy3lrx8val8tf7tL/9aigB9rGPtVv8v/LVf5iurrlr + b/j6h/66r/MV1NABUF9/x43H/XNv5Gp6gvv+PG4/65t/I0Act5a8fL2pfLX+7S//AFqKAH2sY+1W/wAv + /LVf5iurrlrb/j6h/wCuq/zFdTQAV+K3/Bar/k6bwt/2Jtr/AOlt9X7U1+K3/Bar/k6bwt/2Jtr/AOlt + 9QB8AUUUUAFFFFACr94fX1xX33/wT5/4KDSfBWa2+HXxGvJLn4f3B8qyv5GLPorscYbHLW5zkgcoeRXw + HSx/fX6+uKAP6dLd7e8tYLq3ljurW4jWWC4hw8c0bDKspHy853BhyQCDUnlr/dr8f/8Agn7/AMFAJvgp + d2nw8+It3JdfD+eQR2OoSOd+iuxHUDloCTllHKH5hX6+288N9awXVtPHdW1xGs0NxC4eOaNhlWUj5efv + BhyQCDQBPaxj7Vb/AC/8tV/mK6uuWtv+PqH/AK6r/MV1NABUF9/x43H/AFzb+RqeoL7/AI8bj/rm38jQ + By3lrx8val8tf7tL/wDWooAfaxj7Vb/L/wAtV/mK6uuWtv8Aj6h/66r/ADFdTQAVBff8eNx/1zb+Rqeo + L7/jxuP+ubfyNAHLeWvHy9qXy0/u0v8A9aigBPLT+7RS0UAJ5if3qPMX+9XX0UAcpayD7Vb/ADf8tV/m + K6uoL7/jxuP+ubfyNct5a8fL2oA7CoL7/jxuP+ubfyNcv5a/3aktYx9qt/l/5ar/ADFAEXmLx83al8xf + 71dfRQBylrIPtVv83/LVf5iurqC+/wCPG4/65t/I1y3lrx8vagDsKgvv+PG4/wCubfyNcv5a/wB2pLWM + farf5f8Alqv8xQBF5i8fN2pfMX+9XX0UAcpayD7Vb/N/y1X+Yrq6gvv+PG4/65t/I1y3lrx8vagDsKgv + v+PG4/65t/I1y/lr/dqS1jH2q3+X/lqv8xQBF5i8fN2pfMX+9XX0UAcpayD7Vb/N/wAtV/mK6uoL7/jx + uP8Arm38jXLeWvHy9qAOwr8Vv+C1X/J03hb/ALE21/8AS2+r9eTGuDxX5Af8Fnf+TmvCP/YlWn/pbe0A + fA1FFFABRRRQAUUUUALH/rF+vrj9a++P+Cfn7f8AN8Fbqz+HnxFupLr4fTyeVZX8jnforsecgctAc5ZR + yh+YV8DUL94UAf09adcw3jWN1bzx3VrcGOWC4hcPHNG2CrKR8vP3gw5IBBrrq/FT/gnz/wAFB5vgvcWv + w7+Il7JcfD+4Pk2OoyMWfRHYgfNjlrc5yQOVPIr9eLd4Ly1t7q2kjuLW4jWWGaHDxvGwyrKR8vIPDDkj + INAHZ1Bff8eNx/1zb+Rrl/LX+7UlrGPtVv8AL/y1X+YoAi8xePm7UvmL/err6KAOUtZB9qt/m/5ar/MV + 1dQX3/Hjcf8AXNv5GuW8tePl7UAdhUF9/wAeNx/1zb+Rrl/LX+7UlrGPtVv8v/LVf5igCLzF4+btS+Yn + 96uvooA5DzE/vUV19FABRRRQBBff8eNx/wBc2/ka5j/61dPff8eNx/1zb+RrlvMXj5u1ADue3Wub+I3x + K8N/BvwTqHjLxZqMekaDpih5JWOWkbqkUa/xOxGAO5Iro96HjdX5i/8ABaTxZfLN8MPDccoGlyW93qck + afdkl3oiE+4Un86AOn8Uf8FutLs9WuIdA+FNxqWmo5EV3ea8trJIPUxC3fAP+9WT/wAPyLj/AKI1F/4U + 3/3LX5X0UAfqbJ/wXGnkjdT8GocMCOfEx/8AkWqH/D7OT/oi9r/4Ubf/ACNX5g0UAfp9/wAPs5P+iL2v + /hRt/wDI1Oj/AOC20sciMPgxa5Ug8eI2/wDkavy/ooA/VD/h+Rcf9Eai/wDCm/8AuWj/AIfkXH/RGov/ + AApv/uWvyvooA/U2T/guNPJG6n4NQ4YEc+Jj/wDItUP+H2cn/RF7X/wo2/8AkavzBooA/T7/AIfZyf8A + RF7X/wAKNv8A5Gp0f/BbaWORGHwYtcqQePEbf/I1fl/RQB+qH/D8i4/6I1F/4U3/ANy0f8PyLj/ojUX/ + AIU3/wBy1+V9FAH6myf8Fxp5I3U/BqHDAjnxMf8A5Fqh/wAPs5P+iL2v/hRt/wDI1fmDRQB+n6/8Fs5M + jPwXtcf9jEx/T7NXyD+2b+1M/wC1x8SNJ8Xt4cTwvLY6PHpH2SO8+0h1SaeXfv2Lj/XYxivn6igAoooo + AKKKKACiiigAooooAWP76/X1xX3x/wAE/f2/pvgpd2nw9+I15JdfD+eQRWOoSOd+iuxAwQOWgOcso5Q/ + MK+BqWP/AFi/X1x+tAH9OtvPFfWsF1azx3VrcRrNDcQuHjmjYZVlI+XkfMGHJAINWbb/AI+of+uq/wAx + X48f8E/f2/5vgpd2vw8+It3Jc/D+eTy7HUJGJfRXY85A5aA5yyDlD8wr9g9PuYbz7Bc208d1bXBilhuI + XBjmjbBVlI+U5+8GHJAINAHW0UUUAQX3/Hjcf9c2/ka5j/61dPff8eNx/wBc2/ka5bzF4+btQA6pbb/j + 6h/66r/MVD5i/wB6pLWQfarf5v8Alqv8xQB1dFFFABRRRQByHlp/do8tf7tLRQA+1jH2q3+X/lqv8xXV + 1y1t/wAfUP8A11X+YrqaAEb7p+lfkP8A8FvP+SjfDH/sFXf/AKOWv14b7p+lfkP/AMFvP+SjfDH/ALBV + 3/6OWgD80KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACi + iigAHUV9+f8ABPn/AIKDy/BWW1+HfxFvJLv4f3B8my1CQkvorscHdjlrc5yQOVbkV8B0qffX6+uKAP6d + Ld7e8tYLq3ljurW4jWWC4hw8c0bDKspHy853BhyQCDUnlr/dr8f/APgn7+35N8Fb2z+HnxFu5br4fzuI + 7HUJHLvorse4HPkHOWUcofmFfr7bzw31rBdW08d1bXEazQ3ELh45o2GVZSPl5+8GHJAINAE9rGPtVv8A + L/y1X+Yrq65a2/4+of8Arqv8xXU0AFQX3/Hjcf8AXNv5Gp6gvv8AjxuP+ubfyNAHLeWvHy9qXy0/u0v/ + ANaigBPLT+7RS0UAJ5if3qPMX+9XX0UAcpayD7Vb/N/y1X+Yrq6gvv8AjxuP+ubfyNct5a8fL2oA69vu + n6V+Q/8AwW8/5KN8Mf8AsFXf/o5a/Ukxrg8V+Vf/AAWs/wCR9+Fv/YHuv/R60Afm3RRRQAUUUUAFFFFA + BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFACx/fX6+uK++P+Cfv + 7f03wVu7T4e/Ea8kuvh9PIIrHUJHO/RXYgYIHLQHOWUcofmFfA1Kv3h9fXFAH9POnXMN41jdW88d1a3B + jlguIXDxzRtgqykfLz94MOSAQa66vxU/4J7/APBQSX4M3Fr8OfiLeSXPgC5byrHUJW3tojsQPm/vW5zk + j+A81+vzQhQuNjrjIK/dbIBJX25BoA62oL7/AI8bj/rm38jXL+Wv92pLWMfarf5f+Wq/zFAEXmLx83al + 8xP71dfRQByHmJ/eorr6KACiiigCC+/48bj/AK5t/I1zH/1q6e+/48bj/rm38jXLeYvHzdqAHV+VP/Ba + r/kffhZ/2B7v/wBHrX6qGRcHmvyr/wCC1n/I+/C3/sD3X/o9aAPzbooooAKKKKACiiigAooooAKKKKAC + iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoop0f8ArF7cigBFO1genNf0W/su + y30v7MPwkfUxi/bwtp4dW67PIXyz/wB81+WP7A/7Bd7+0VqkPjPxhbTWPw106XftKFZdXkQ/6qLAP7rg + h3XnJwMnlf2ZVoo0jjhRYoUQIkahQgUABQo6YAHyqOQMk0ALUtt/x9Q/9dV/mKh8xf71SWsg+1W/zf8A + LVf5igDq6KKKACiiigDkPLT+7R5a/wB2looAfaxj7Vb/AC/8tV/mK6uuWtv+PqH/AK6r/MV1NACN90/S + vyH/AOC3n/JRvhj/ANgq7/8ARy1+vDfdP0r8h/8Agt5/yUb4Y/8AYKu//Ry0AfmhRRRQAUUUUAFFFFAB + RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFKv3h9aAEHUV9r/sFfsG + Xv7Resw+LvF0Fxpvw0sZyCcMkuryKQPJiYciPs8q9/kXLHKp+wX+wbe/tGaxbeL/ABbbXGmfDSxmIPLJ + Lq0i8GGJhyI+zyjv8ifMfl/ZvStKsNB0iy0vSbKHTNKsYFt7SztUVI4olGEVUH3QACABzgkmgCTQdJ0/ + QbPS9L0qzt9N0uyEVvaWNuiokMSkBFVB90AZAA5wSTXZ1y1t/wAfUP8A11X+YrqaACoL7/jxuP8Arm38 + jU9QX3/Hjcf9c2/kaAOW8tePl7Uvlp/dpf8A61FACeWn92ilooATzE/vUeYv96uvooA5S1kH2q3+b/lq + v8xXV1Bff8eNx/1zb+RrlvLXj5e1AHXt90/SvyH/AOC3n/JRvhj/ANgq7/8ARy1+pJRQCcY96/MH/gtP + 4auhqXwu1+OHdpv2S909mQ/LHIskbqD7lXNAH5i0UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF + ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFKn31+tAAhIZSMZz3r7c/YJ/YIvv2jL6Pxh4wtrjT/AIaafJuL + Lujl1aRePKiIUkRcEPIpzngZPKs/YM/YLvf2jNTg8WeMILjTvhvZyg/NuSXVZAQfJiIX/V8YeRefTmv2 + b8P6Rp+g2elaXpNlDp2lWIjgtLK1RUjgiUgIqovCgAEAehJNAEWk6bp2gaRYaVpNrb6bpVnAsFrY26Kk + cMSjCKqD7oABAA5wSTVnzF/vV19FAHKWsg+1W/zf8tV/mK6uoL7/AI8bj/rm38jXLeWvHy9qAOwqC+/4 + 8bj/AK5t/I1y/lr/AHaktYx9qt/l/wCWq/zFAEXmLx83al8xP71dfRQByHmJ/eorr6KACiiigCC+/wCP + G4/65t/I1zH/ANaunvv+PG4/65t/I1y3mLx83agB469/w61xvxc+DvhX49+Ab/wV4x0832jXzIQ0ThJb + aQH93NC4BMcijgHBBHyP8pNdh5i/3qktZB9qt/m/5ar/ADFAH5i+LP8AgiTq/wDa858M/EqwbS2ZjGmq + adIk8SnopZGYP9QFrD/4ci+Of+ikeHv/AACuK/YGigD8fW/4Ij+OI1LH4k+HgFGTmzuKr/8ADljxl/0U + 3wz/AOAtxX7B33/Hjcf9c2/ka5bzF4+btQB+U3/Dlfxn/wBFO8M/+AtxQv8AwRV8ZyMFHxN8NEscDFrc + V+rXmL/eqS1kH2q3+b/lqv8AMUAflT/w5F8c/wDRSfD3/gFcUf8ADkXxz/0Ujw9/4BXFfsDRQB+Prf8A + BEfxxGpY/Enw8Aoyc2dxVf8A4cseMv8Aopvhn/wFuK/YO+/48bj/AK5t/I1y3mLx83agD8pv+HK/jP8A + 6Kd4Z/8AAW4oX/gir4zkYKPib4aJY4GLW4r9WvMX+9UlrIPtVv8AN/y1X+YoA/Kn/hyL45/6KT4e/wDA + K4o/4ci+Of8AopHh7/wCuK/YGigD8fW/4Ij+OI1LH4k+HgFGTmzuKr/8OWPGX/RTfDP/AIC3FfsHff8A + Hjcf9c2/ka5bzF4+btQB+U//AA5X8Z/9FN8Nf+AtxXyl+1r+y7qX7Jnj/TPCWq65Z+ILm+0mPVlubBXW + MI800QGG75hr+gUyLg81+QH/AAWd/wCTmvCP/YlWn/pbe0AfA1FFFABRRRQAUUUUAFFFOj/1idOo64x+ + vH50AJG22RT6HNfbn7BP7A93+0JqVv4x8aW01n8ObOXiIFo5NZdSB5cZXkRDnfIvOM455qb9gn9gK9/a + I1JPG/jS2msPhtZuXEfzRy6u6nHloQCRFwd8g55wvPI/Y7TdPsND0uz03TbaCx06ziW3tLW3RUiijUYV + VQfdCrkADnBJNAC6fp9lo2m2mm6daW+nafZwrb2tnbQrHFFGowiIg4QKoIAHABI6mrtt/wAfUP8A11X+ + YqHzF/vVJayD7Vb/ADf8tV/mKAOrooooAgvv+PG4/wCubfyNcx/9aunvv+PG4/65t/I1y3mLx83agB1S + 23/H1D/11X+YqHzF/vVJayD7Vb/N/wAtV/mKAOrooooAKKKKAOQ8tP7tHlr/AHaWigB9rGPtVv8AL/y1 + X+Yrq65a2/4+of8Arqv8xXU0AFQX3/Hjcf8AXNv5Gp6gvv8AjxuP+ubfyNAHLeWvHy9qXy1/u0v/ANai + gB9rGPtVv8v/AC1X+Yrq65a2/wCPqH/rqv8AMV1NABUF9/x43H/XNv5Gp6gvv+PG4/65t/I0Act5a8fL + 2pfLX+7S/wD1qKAH2sY+1W/y/wDLVf5iurrlrb/j6h/66r/MV1NABUF9/wAeNx/1zb+RqeoL7/jxuP8A + rm38jQBy3lrx8val8tf7tL/9aigB9rGPtVv8v/LVf5iurrlrb/j6h/66r/MV1NABX4rf8Fqv+TpvC3/Y + m2v/AKW31ftTX4rf8Fqv+TpvC3/Ym2v/AKW31AHwBRRRQAUUUUAFFFLG22RT6HNAAudwx1zxX29+wT+w + PdftDahB4z8a28lj8OLWT5YlDRy6xIhAMSFfmEQx80i854GTyE/YM/YIu/2hdRtvGXjO3ns/htZzfLHl + 45NYkU4MURHIiGCHkXnCnHNfspp+n2Wjabaabp1pb6dp9nCtva2dtCscUUajCIiDhAqggAcAEjqaAJNH + 0yy0eHS9O06zt9N0+zWK3trO1hWNII1wERUHCKFyABwASOprsq5a2/4+of8Arqv8xXU0AFQX3/Hjcf8A + XNv5Gp6gvv8AjxuP+ubfyNAHLeWvHy9qXy1/u0v/ANaigB9rGPtVv8v/AC1X+Yrq65a2/wCPqH/rqv8A + MV1NABUF9/x43H/XNv5Gp6gvv+PG4/65t/I0Act5a8fL2pfLT+7S/wD1qKAE8tP7tFLRQAnmJ/eo8xf7 + 1dfRQBylrIPtVv8AN/y1X+Yrq6gvv+PG4/65t/I1y3lrx8vagDsKgvv+PG4/65t/I1y/lr/dqS1jH2q3 + +X/lqv8AMUAReYvHzdqXzF/vV19FAHKWsg+1W/zf8tV/mK6uoL7/AI8bj/rm38jXLeWvHy9qAOwqC+/4 + 8bj/AK5t/I1y/lr/AHaktYx9qt/l/wCWq/zFAEXmLx83al8xf71dfRQBylrIPtVv83/LVf5iurqC+/48 + bj/rm38jXLeWvHy9qAOwqC+/48bj/rm38jXL+Wv92pLWMfarf5f+Wq/zFAEXmLx83al8xf71dfRQBylr + IPtVv83/AC1X+Yrq6gvv+PG4/wCubfyNct5a8fL2oA7CvxW/4LVf8nTeFv8AsTbX/wBLb6v168tfSvyA + /wCCz3/JzXhH/sSrT/0tvaAPgWiiigAoopUzvXHJzxQAsf8ArFxjOR1xj9eK+4v2Cf2Ab39ojUU8a+NL + WWx+G9mxYRfPFLq8iH/VIQCwi4+eQfNzheeRF+wT+wPdftDanb+MvGVvNZfDiyl+RPmSXWZFODEhX5hE + Od0g5xnH+z+y+i6bZaLb6Xpum2kFjp1oIre0tbZFRIo1ICqqD7qquQAOcEk0AR6fY2OjaZZ6fp1pb6dp + 1pEtvaWltGscUUajCoiDhAqggAcAEjqan8xf71dfRQBylrIPtVv83/LVf5iurqC+/wCPG4/65t/I1y3l + rx8vagDsKgvv+PG4/wCubfyNcv5a/wB2pLWMfarf5f8Alqv8xQBF5i8fN2pfMX+9XX0UAcpayD7Vb/N/ + y1X+Yrq6gvv+PG4/65t/I1y3lrx8vagDsKgvv+PG4/65t/I1y/lr/dqS1jH2q3+X/lqv8xQBF5i8fN2p + fMT+9XX0UAch5if3qK6+igAooooAgvv+PG4/65t/I1zH/wBaunvv+PG4/wCubfyNct5i8fN2oAdUtt/x + 9Q/9dV/mKh8xf71SWsg+1W/zf8tV/mKAOrooooAgvv8AjxuP+ubfyNcx/wDWrp77/jxuP+ubfyNct5i8 + fN2oAdUtt/x9Q/8AXVf5iofMX+9UlrIPtVv83/LVf5igDq6KKKAIL7/jxuP+ubfyNcx/9aunvv8AjxuP + +ubfyNct5i8fN2oAdUtt/wAfUP8A11X+YqHzF/vVJayD7Vb/ADf8tV/mKAOrooooAgvv+PG4/wCubfyN + cx/9aunvv+PG4/65t/I1y3mLx83agB1fj/8A8Fnv+TmvCP8A2JVp/wClt7X6/wDmL61+QH/BZ7/k5rwj + /wBiVaf+lt7QB8C0UU6PPmLjGc98Y/XigBFzuGOueK+3v2Cv2B7r9oTUIPGfjW3ksfhxayfLEoaOXWJE + IBiQr8wiGPmkXnPAyeRJ+wT+wDe/tE6injbxrazWPw3s2LiL54pdXkU48pCAWEXB3yD5ucLz8w/Y/T7G + x0bTLPT9OtLfTtOtIlt7S0to1jiijUYVEQcIFUEADgAkdTQAun6bZ6Nptpp2nWdvpun2kS29tZ2sKxpB + GowiKg4RQoIAHABPc1ctv+PqH/rqv8xUPmL/AHqktZB9qt/m/wCWq/zFAHV0UUUAQX3/AB43H/XNv5Gu + Y/8ArV099/x43H/XNv5GuW8xePm7UAOqW2/4+of+uq/zFQ+Yv96pLWQfarf5v+Wq/wAxQB1dFFFAEF9/ + x43H/XNv5GuY/wDrV099/wAeNx/1zb+RrlvMXj5u1ADqltv+PqH/AK6r/MVD5i/3qktZB9qt/m/5ar/M + UAdXRRRQAUUUUAch5af3aPLX+7S0UAPtYx9qt/l/5ar/ADFdXXLW3/H1D/11X+YrqaACoL7/AI8bj/rm + 38jU9QX3/Hjcf9c2/kaAOW8tePl7Uvlr/dpf/rUUAPtYx9qt/l/5ar/MV1dctbf8fUP/AF1X+YrqaACo + L7/jxuP+ubfyNT1Bff8AHjcf9c2/kaAOW8tePl7Uvlr/AHaX/wCtRQA+1jH2q3+X/lqv8xXV1y1t/wAf + UP8A11X+YrqaACoL7/jxuP8Arm38jU9QX3/Hjcf9c2/kaAOW8tePl7Uvlr/dpf8A61FAD7WMfarf5f8A + lqv8xXV1y1t/x9Q/9dV/mK6mgBG4Umvzq/4K2fsta78VvD+h/Ejwlp76tqXh21mtNUsrZS80lnu8xZEA + 6+UwkLAc4ev0WqG8bZZztkjbGxyDgjigD+Wdo9jbTjAPJwB3x0xnrxX21+wp/wAE/b/9oDUrXxr45tZ9 + M+HMDiRI23xy6wwbOyIgbhCejSDnn5eeR+teofB/4e65rx13Uvh54Sv9dZxI+qXWh2z3G8dzKyFs++a6 + x5GcKG+VVGFjwQI8DGMcAcdKAI9F02y0e30zTtOsrfT9PsxFb2tnawLGkEakBEVBwihQQAOACR1NdjXL + W3/H1D/11X+YrqaACoL7/jxuP+ubfyNT1Bff8eNx/wBc2/kaAOW8tePl7Uvlr/dpf/rUUAPtYx9qt/l/ + 5ar/ADFdXXLW3/H1D/11X+YrqaACoL7/AI8bj/rm38jU9QX3/Hjcf9c2/kaAOW8tePl7Uvlr/dpf/rUU + APtYx9qt/l/5ar/MV1dctbf8fUP/AF1X+YrqaACoL7/jxuP+ubfyNT1Bff8AHjcf9c2/kaAOW8tePl7U + vlp/dpf/AK1FACeWn92ilooATzE/vUeYv96uvooA5S1kH2q3+b/lqv8AMV1dQX3/AB43H/XNv5GuW8te + Pl7UAdhUF9/x43H/AFzb+Rrl/LX+7UlrGPtVv8v/AC1X+YoAi8xePm7UvmL/AHq6+igDlLWQfarf5v8A + lqv8xXV1Bff8eNx/1zb+RrlvLXj5e1AHYVBff8eNx/1zb+Rrl/LX+7UlrGPtVv8AL/y1X+YoAi8xePm7 + UvmL/err6KAOUtZB9qt/m/5ar/MV1dQX3/Hjcf8AXNv5GuW8tePl7UAdhUF9/wAeNx/1zb+Rrl/LX+7U + lrGPtVv8v/LVf5igCLzF4+btS+Yv96uvooA5S1kH2q3+b/lqv8xXV1Bff8eNx/1zb+RrlvLXj5e1AHYV + Bff8eNx/1zb+Rrl/LX+7UlrGPtVv8v8Ay1X+YoAi8xePm7UvmL/err6KAOUtZB9qt/m/5ar/ADFdXUF9 + /wAeNx/1zb+RrlvLXj5e1AHYVBff8eNx/wBc2/ka5fy1/u1Jaxj7Vb/L/wAtV/mKAIvMXj5u1L5i/wB6 + uvooA5S1kH2q3+b/AJar/MV1dQX3/Hjcf9c2/ka5by14+XtQB2FQX3/Hjcf9c2/ka5fy1/u1Jaxj7Vb/ + AC/8tV/mKAIvMXj5u1L5i/3q6+igDlLWQfarf5v+Wq/zFdXUF9/x43H/AFzb+RrlvLXj5e1AHYVBff8A + Hjcf9c2/ka5fy1/u1Jaxj7Vb/L/y1X+YoAi8xePm7UvmJ/err6KAOQ8xP71FdfRQAUUUUAQX3/Hjcf8A + XNv5GuY/+tXT33/Hjcf9c2/ka5bzF4+btQA6pbb/AI+of+uq/wAxUPmL/eqS1kH2q3+b/lqv8xQB1dFF + FAEF9/x43H/XNv5GuY/+tXT33/Hjcf8AXNv5GuW8xePm7UAOqW2/4+of+uq/zFQ+Yv8AeqS1kH2q3+b/ + AJar/MUAdXRRRQBBff8AHjcf9c2/ka5j/wCtXT33/Hjcf9c2/ka5bzF4+btQA6pbb/j6h/66r/MVD5i/ + 3qktZB9qt/m/5ar/ADFAHV0UUUAQX3/Hjcf9c2/ka5j/AOtXT33/AB43H/XNv5GuW8xePm7UAOqW2/4+ + of8Arqv8xUPmL/eqS1kH2q3+b/lqv8xQB1dFFFAEF9/x43H/AFzb+RrmP/rV099/x43H/XNv5GuW8xeP + m7UAOqW2/wCPqH/rqv8AMVD5i/3qktZB9qt/m/5ar/MUAdXRRRQBBff8eNx/1zb+RrmP/rV099/x43H/ + AFzb+RrlvMXj5u1ADqltv+PqH/rqv8xUPmL/AHqktZB9qt/m/wCWq/zFAHV0UUUAQX3/AB43H/XNv5Gu + Y/8ArV099/x43H/XNv5GuW8xePm7UAOqW2/4+of+uq/zFQ+Yv96pLWQfarf5v+Wq/wAxQB1dFFFABRRR + QByHlp/do8tf7tLRQA+1jH2q3+X/AJar/MV1dctbf8fUP/XVf5iupoAKgvv+PG4/65t/I1PUF9/x43H/ + AFzb+RoA5by14+XtS+Wv92l/+tRQA+1jH2q3+X/lqv8AMV1dctbf8fUP/XVf5iupoAKgvv8AjxuP+ubf + yNT1Bff8eNx/1zb+RoA5by14+XtS+Wv92l/+tRQA+1jH2q3+X/lqv8xXV1y1t/x9Q/8AXVf5iupoAKgv + v+PG4/65t/I1PUF9/wAeNx/1zb+RoA5by14+XtS+Wv8Adpf/AK1FAD7WMfarf5f+Wq/zFdXXLW3/AB9Q + /wDXVf5iupoAKgvv+PG4/wCubfyNT1Bff8eNx/1zb+RoA5by14+XtS+Wv92l/wDrUUAPtYx9qt/l/wCW + q/zFdXXLW3/H1D/11X+YrqaACoL7/jxuP+ubfyNT1Bff8eNx/wBc2/kaAOW8tePl7Uvlr/dpf/rUUAPt + Yx9qt/l/5ar/ADFdXXLW3/H1D/11X+YrqaACoL7/AI8bj/rm38jU9QX3/Hjcf9c2/kaAOW8tePl7Uvlr + /dpf/rUUAPtYx9qt/l/5ar/MV1dctbf8fUP/AF1X+YrqaACoL7/jxuP+ubfyNT1Bff8AHjcf9c2/kaAO + W8tePl7Uvlp/dpf/AK1FACeWn92ilooAKKKKAJbb/j6h/wCuq/zFdTRRQAVBff8AHjcf9c2/kaKKAOY/ + +tRRRQBLbf8AH1D/ANdV/mK6miigAqC+/wCPG4/65t/I0UUAcx/9aiiigCW2/wCPqH/rqv8AMV1NFFAB + UF9/x43H/XNv5GiigDmP/rUUUUAS23/H1D/11X+YrqaKKACoL7/jxuP+ubfyNFFAHMf/AFqKKKAJbb/j + 6h/66r/MV1NFFABUF9/x43H/AFzb+RoooA5j/wCtRRRQBLbf8fUP/XVf5iupoooAKgvv+PG4/wCubfyN + FFAHMf8A1qKKKAJbb/j6h/66r/MV1NFFABUF9/x43H/XNv5GiigDmP8A61FFFABRRRQB/9k= + + + + + /9j/4AAQSkZJRgABAQEASABIAAD/4Rz6RXhpZgAATU0AKgAAAAgABQESAAMAAAABAAEAAAExAAIAAAAm + AAAASgEyAAIAAAAUAAAAcIdpAAQAAAABAAAAhIglAAQAAAABAAAA8AAAAShXaW5kb3dzIFBob3RvIEVk + aXRvciAxMC4wLjEwMDExLjE2Mzg0ADIwMjM6MDk6MTIgMjA6MDc6MjgAAAWQAwACAAAAFAAAAMaQBAAC + AAAAFAAAANqSkQACAAAAAzAwAACSkgACAAAAAzAwAACgAQADAAAAAQABAAAAAAAAMjAyMzowOToxMiAx + OToyMTowMgAyMDIzOjA5OjEyIDE5OjIxOjAyAAAAAAEACwACAAAAJgAAAQIAAAAAV2luZG93cyBQaG90 + byBFZGl0b3IgMTAuMC4xMDAxMS4xNjM4NAAABgEDAAMAAAABAAYAAAEaAAUAAAABAAABdgEbAAUAAAAB + AAABfgEoAAMAAAABAAIAAAIBAAQAAAABAAABhgICAAQAAAABAAAbawAAAAAAAABgAAAAAQAAAGAAAAAB + /9j/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0 + Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIy + MjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAEAAQADASEAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAA + AAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0Kx + wRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4 + eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl + 5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQD + BAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygp + KjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOk + paanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIR + AxEAPwD26igC9F/qk/3RT6AKU/8Ar3/D+VR0AWrX/Vt/vVPQBWuv4PxqvQBLb/678DVygCOf/UtVKgAH + 3h9a0aACs4/eP1oAKuwf6laAJKp3H+u/AUARVYtf4/woAs1Bdf6tf96gCrUkH+vT8f5UAXaZL/qn/wB0 + 0AUaKACigC9F/qk/3RT6AKM/+vf8P5UygC1a/wCrb/eqegCtd/wfjVegCW2/134GrlAEc/8AqGqlQAD7 + w+taNABWcfvH60AFXYP9QtAElU7n/XfgKAIqsWn8f4UAWaguv9Wv+9QBVp8H+vT8f5UAXqZL/qn/AN00 + AUaKAL3lR/8APNfyo8qP/nmv5UAU2Zg7AMwAJAANJvf++3/fRoAtQorxBmUMxzkkZNP8qP8A55r+VAFe + fKSAJlRjOFOKi3v/AH2/76NAE1v+8Zt/zY6buan8qP8A55r+VAEU6hIwUAU56rxVfe/99v8Avo0APjZm + kVWYkE8gnNWvKj/55r+VACNGgQkIvT0qmHfH32/76NAAXfH32/76NXFjQoCUXp6UAL5Uf/PNfyqrIzLI + yqxAB4AOKAGb3/vt/wB9GrECh4yXAY56tzQBL5Uf/PNfyqC4/dsuz5c9dvFAEO9/77f99GpYMvIQ+WGM + 4Y5oAseVH/zzX8qZMipEWVQrDGCBg0AVd7/32/76NKrMXUFmIJAIJoAueVH/AM81/Kjyo/8Anmv5UAPo + oAz3/wBY/wDvGkoAuW/+oX8f51LQBUuv9cP92oaAJ7X7z/QVaoAguv8AVD/eqrmgBhu7a3nQT3EMTZzt + eQKf1qx/aun/APP/AGv/AH+X/GgBG1XTypH2+16f89l/xql/aFl/z+2v/f5f8aAD+0LL/n9tf+/y/wCN + XV1XTwoH2+16f89l/wAaAF/tXT/+f+1/7/L/AI1X+1W9xOwhuIZCTnCSBj+lAD6tWv8Aqj/vUAT1Vuvv + J9DQBBU1r/rj/u0AW6iuP9Q34fzoAp0qf6xP94UAaFFAFHz5f7/6Cjz5f7/6CgCwkMbIrMuWYZJyaX7P + F/d/U0AQO7xSMiNhR0GKb58v9/8AQUASxKJ1LSfMwOM9Kk+zxf3f1NAEUo8gr5Xy7uveo/Pl/v8A6CgB + 8bNM+yQ7lxnHSuS+KeuzeFfAF/qFgTHeNthhcH7jMcbvqBkj3xQB8e3FzPdXDz3EzyzSHc8jsSzH1JNR + ZNABk0UAFGTQAZNTWl5c2N1Hc2k8kE8Z3JJGxVlPsaAPsr4b6xL4n8AaTq19811NGyyt03Mjsm7j125r + pJGaF9kZ2rjOOtADPPl/v/oKkiHnlvN+bb07UAS/Z4v7v6mo5VECho/lYnGetAEXny/3/wBBTkd5ZFR2 + yp6jFAE/2eL+7+ppHhjVGZVwyjIOTQBX8+X+/wDoKPPl/v8A6CgBlFAF6L/VJ/uin0AUZ/8AXv8Ah/Km + UAWrX/Vt/vVPQBWu/wCD8ar0AS23+u/A1538fv8AkmE3/X3D/M0AfKFFABRQAUUAFFAH178Ef+SSaN/v + T/8Ao567a5/134CgCKrFp/H+FAFmoLr/AFa/71AFWnwf69Px/lQBepkv+qf/AHTQBRooAtfZU/vN+lH2 + VP7zUAR+e6EoAuF4GR6UfapPRfyoAcsQmXzGJDN1x0p32VP7zUARsxtm2JggjPzUfapPRfyoAVc3JIfj + b020/wCyp/eagBrp9nAdCSc45rzH47ytJ8MJ9wHF3D0+poA+V6KACigAooAKKAPrb4Kzsnwl0YAD70/X + /rs9egIn2gF3JBzjigB32VP7zUxs2xATnd13UAJ9qk9F/KhWNy2x8AAZ+WgCT7Kn95qa0QhXzFJLL0z0 + oAb9qk9F/Kjz3chCFw3BwPWgCT7Kn95qPsqf3m/SgCeigDPf/WP/ALxpKALlv/qF/H+dS0AVLn/XD/dq + GgCe1+8/0FWqAILr/VD/AHq8s+On/JMLj/r7h/maAPlqigAooAKKACigD6x+DH/JJ9H/AN6f/wBHPXo9 + r/qj/vUAT1VuvvJ9DQBBU1t/rj/u0AW6iuP9Q34fzoAp0qf6xP8AeFAGhRQBW+1/7H60fa/9j9aAEFuZ + Pn3AbucY9aPsp/vj8qAAS+R+627tvfOKX7X/ALH60AJtNyd+duOMdaPsp/vj8qADm1Ofvbvwpftf+x+t + ACF/tH7vG3vnOa80+PEJj+GE/wA2c3cPb3NAHyrRQAUUAFFABRQB9b/BWAv8JdGO7HzT9v8Aps9d8H+z + /u8bu+c4oAX7X/sfrSc3Rz93b+NAB9lP98flRtNsd+d2eMdKAF+1/wCx+tIZfP8A3W3bu75zQAfZT/fH + 5UG3Mfz7gdvOMelAC/a/9j9aPtf+x+tAFeigC9F/qk/3RT6AKM/+vf8AD+VMoAtWv+rb/eqegCtd/wAH + 41XoAltv9d+Brzv4/f8AJMJv+vuH+ZoA+UKKACigAooAKKAPr34I/wDJJNG/3p//AEc9dtc/678BQBFV + i0/j/CgCzUF1/q1/3qAKtPg/16fj/KgC9TJf9U/+6aAKNFAEv2aT2/Oj7NJ7fnQBKs6ooQhsqMHil+0p + 6N+VAETRtMxkXG09Mmk+zSe350APRhbgo4OSc8U/7Sno35UARuftJGwfd65pv2aT2/OgBVUwNvccdOK8 + 2+PUqyfDCfGf+PuHr9TQB8qUUAFFABRQAUUAfXPwTmVPhLowOfvT9P8Ars9d2ymdt6DjpzQAn2aT2/On + IfsxO8fe6YoAk+0p6N+VMdhcAIgOQc80AM+zSe350qxtCwkbG0dcGgCX7Sno35UjTq6lAGywwOKAIvs0 + nt+dH2aT2/OgC5RQBnv/AKx/940lAFy3/wBQv4/zqWgCpdf64f7tQ0AT2v3n+gq1QBBdf6of71eWfHT/ + AJJhcf8AX3D/ADNAHy1RQAUUAFFABRQB9Y/Bj/kk+j/70/8A6OevR7X/AFR/3qAJ6q3X3k+hoAgqa1/1 + x/3aALdRXH+ob8P50AU6VP8AWJ/vCgDQooAj8+P+9R58X98UAVjG7MzBSQSSDSeTJ/cNAE8UixxhHOGH + UGn+fH/foAgmBlk3RgsAMZFM8mT+4aAJIf3JbzPlz0zU3nx/36AI5mWVAqHc2c4FeX/HZGX4YT7lI/0u + H+ZoA+WKKACigAooAKKAPrT4Lxu3wm0YhSfmn/8ARz16HCyxIVc7WznBoAk8+P8Av1DN++K+X82OuKAI + /Jk/uGnwgxSbpAVBGMmgCfz4/wC/TJZFkjKIcsegFAEHkyf3DSiN1ZWKkAEEmgCz58X98UefH/eoApUU + AXov9Un+6KfQBRn/ANe/4fyplAFq1/1bf71T0AVrv+D8ar0AS23+u/A1538fv+SYTf8AX3D/ADNAHyhR + QAUUAFFABRQB9e/BH/kkmjf70/8A6Oeu2uf9d+AoAiqxafx/hQBZqC6/1a/71AFWnwf69Px/lQBepkv+ + qf8A3TQBRooAMH0P5UYPofyoAuxsoiQFh90d6fvX+8PzoApzZMzEcjjkfSo8H0P5UAWbYhUYMcc96n3r + /eH50AV7k7tm3nGelV8H0P5UAS2/yy5PAx3rzr4+kH4XzYIP+lw/zNAHyjRQAUUAFFABRQB9efBFgPhJ + o2SB80/f/ps9dvcfNLkcjHagCLB9D+VWLY7d+7jOOtAFjev94fnUFyQyKFOee1AFbB9D+VSQ5Eyk8Dnk + /SgC5vX+8PzpkjKYnAYfdPegClg+h/KjB9D+VAGjRQBnv/rH/wB40lAFy3/1C/j/ADqWgCndf64f7tRU + AT2n3n+gq1QBBdf6of71eWfHT/kmNx/19w/zNAHy1RQAUUAFFABRQB9Y/Bj/AJJPo/8Avz/+jnr0e1/1 + R/3qAJ6q3f3k+hoAgqW1/wBcf92gC5UVx/qG/D+dAFOlT/WJ/vCgDQooAKKAM9/9Y/8AvGkoAuW/+oX8 + f50XFxFa27zzyJFDGCzu5wFA7k0AeeXvxm8BxXJRtaZioxujtpGU/Qgc1X/4XV4C/wCgvN/4By//ABNA + EkXxv8AxEn+1pjn/AKc5f/ial/4Xr4A/6Cs//gJL/wDE0ARy/HHwDIm3+1pxzn/jzl/+JrhPir8SvCvi + fwNLpmkahJNdNcRyBWt3QYXOeSMUAeDUUAFFABRQAUUAfQXw0+J/hLw54A07SdU1GSG7gaUui2zuBukZ + hyBjoa7KL44+AY02/wBrTnnP/HnL/wDE0ASf8L18Af8AQVn/APASX/4mopfjf4BlIP8Aa0wx/wBOcv8A + 8TQBH/wurwF/0F5v/AOX/wCJqxYfGXwHNdrGutFGfgNLbSIo+pIwKAPRIZo7iFJopFkjcbldTkMPUGku + P9Q34fzoAp0qf6xP94UAaFFAGdk+p/OjJ9T+dAF2NVMSEqPujtT9i/3R+VAFObiZgOBxwPpXl/x3uLyH + 4c7bZm8uW9jjuCD/AAbWOD7bgtAHy82c80lABRQAUUAFFABRQAUUAFFABRQAUUAFKOtAH1R8ELi8n+Gd + v9pZykdzKkBY/wDLMEH8slq9JhyZlB5HPX6UAXNi/wB0flTJFUROQo+6e1AFLJ9T+dGT6n86ACigC9F/ + qk/3RT6AKM/+vf8AD+VUdS0201fTp9Pv4FntZ02SRsOCP6EdjQB8sfEb4b3vgnUvNQtcaRO58i4xyv8A + sP8A7Q/X9BwdABRQAUUAFFABRQAUUAFFABRQAUUAFeg/DT4Z3fjW/F1db7fRYHAmmHBkP9xPf1Pb68UA + fUljY2um2EFjZQJBbQII440GAoFXIP8AXp+P8qAL1Ml/1T/7poAo0UAXfIj/ALtHkRf3BQBVMjqzKGIA + JAFHnSf3zQBPFGskYdxlj1Jp/kRf3BQBma1pdlqtjNpt9brPZzpiSJ+h/wDr9MelfKXxH+HF34H1HzI9 + 9xpM7Ytrg9Qefkf/AGsD2z+YoA4SigAooAKKACigAooAKKACigAooA9C+Gnw0uvG1+t1ch7fRYGHnTDg + yH+4nv6nt+lfVGk6faafaQ6faQJDaQR7YokGAoH/AOv9aANHyI/7tMljWOMugww6EUAQedJ/fNAkdmVS + xIJAIoAteRF/cFHkR/3aAJKKAM9/9Y/+8aSgC5b/AOoX8f51LQBUuv8AXD/drO1LTbPWNNuNOv7dbi1u + F2yRN39Px9+3FAHyx8R/hxe+CdR82LdcaRMf3Fzjkf7D+jfoR+NcGRg4oAKKACigAooAKKACigAooAK9 + B+Gnw0u/Gt79put9vosLfvpsYMpH8Ce/qe31xQB9SWNha6ZYw2NjAkFrAuyONBgKP896v2v+uP8Au0AW + 6iuP9Q34fzoAp0qf6xP94UAaFFAFP7TJ7flR9pk9vyoAlWBXUOS2WGTzS/Zk9W/OgCJpGhYxrjaOmRSf + aZPb8qAHoouAXcnIOOKf9mT1b86AM/WNIsdT06XTr6BLi1uFKyRyDqPb0PfNfKXxG+HF34I1IyRl7jSJ + 2/0e4x93/Yf0Yfr19qAODooAKKACigAooAKKACigD0L4a/DO68a34urkSW+iwN+9nxzKeuxPf1PbPrxX + 1TpemWdjYx2NnAlta26hI4ohgKP89/rQBd+yp6tTXUW4DoTknHNADPtMnt+VKsjTMI2xtPXAoAl+zJ6t + +dI0CopcFsqMjmgCL7TJ7flR9pk9vyoAiooAvRf6pP8AdFPoAoz/AOvf8P5UygC1a/6tv96p6AK13/B+ + NZmp6ZZazp0+n6jbx3FrOhR43GfxHoR2I6GgD5Y+JHw4vPBOo+ZEHn0mdz5Fxj7v+w/ow/Xt3rgyCOtA + BRQAUUAFFABRQAV6D8NPhpd+Nb77TdB7fRoH/fTdDKf7ie/qe1AH1JYWFppdhBY2MCQWsCBI40GAoH+e + taNp/H+FAFmoLr/Vr/vUAVafB/r0/H+VAF6mS/6p/wDdNAFGigCx9k/2/wBKPsn+3+lACC4MfybQdvGc + +lH2o/3B+dAAIvP/AHu7bu7YzS/ZP9v9KAE3G2OzG7POelH2o/3B+dABzdHH3dv40v2T/b/SgClq2jWe + p6ZPY6hCtzazrseNx+vsR2r5R+I/w4vPBGp+ZHum0idv9HuP7v8AsP8A7Q/X9KAOEooAKKACigAooA9B + +Gnw0uvGmo/abnfBo0DfvpuhlP8AcT39T2+uK+qtM0q0sdOhs7GJLa1gXZFEg4UCgC39k/2/0pObU4+9 + u/CgA+1H+4Pzo3G5OzG3HOetAC/ZP9v9KQxeR+93btvbGKAD7Uf7g/Og3Bk+TaBu4zn1oAX7J/t/pR9k + /wBv9KALNFAGe/8ArH/3jSUAXLf/AFC/j/OpaAKlz/rh/u1DQBPa/ef6CrVAEF1/qh/vVlalptlrGnza + fqNulxaTrtkjfv8A/X9+1AHyt8RvhxeeBtQ3pvn0qdv9HucZx/sNxw3H41wtABRQAUUAFeg/DX4aXXja + 9F1ch7fRYGxNPjBlP9xPf1PagD6lsbK10yxhsbKBILWBdkcSDhRWla/6o/WgCeqt195PoaAIKmtv9cf9 + 2gC3UVx/qG/D+dAFOlT/AFif7woA0KKAIPtSf3W/Sj7Un91qAI/IdyXBXDcjJ9aPssnqv50AOWUQL5bA + ll646U77Un91qAI2U3Lb0wABj5qPssnqv50AKubYkvzu6baf9qT+61ADXf7QAiAg5zzTfssnqv50AUtW + 0O11fSriw1G3juLSZdskZ7+hHoenNfKfxI+HV74J1QNGHn0mdv8AR7nb0/2H9GH69fXABwh4OKKAClAy + cUAegfDP4aXXjW/+1XYeDRYWxNOBzIf7ie/qe31xX1Tp+k2+n6fBZ2EEVvawrtjjQYCj/PegC19lk9V/ + OnI/2cFHBJznigB32pP7rUxs3JBTjb13UAJ9lk9V/OhVNs298EEY+WgCT7Un91qa0onXy1BDN0z0oAb9 + lk9V/OjyHQhyVwvJwfSgCT7Un91qPtSf3W/SgCrRQBei/wBUn+6KfQBRn/17/h/KmUAWrX/Vt/vVPQBW + u/4PxqvQBLbf678DVygCOf8A1LVjappVjrWmz6dqNulxaTrteNh+o9COoNAHyv8AEX4c3vgfUi6759Jn + Y/ZrnHT/AGH9GH69vQcLQAV6D8NfhpdeNdQF1ch4NFgb99MOsp/uJ7+p7fpQB9SWFhaaZYw2Njbx29tA + gSOOMYCj/H3rWg/1K0ASVTuf9d+AoAiqxafx/hQBZqC6/wBWv+9QBVp8H+vT8f5UAXqZL/qn/wB00AUa + KAH+RL/c/UUeRL/c/UUAWEmjVFVmwyjBGDS/aIv736GgCB0eWRnRcqehzTfIl/ufqKAJYmEClZPlYnOO + tSfaIv736GgCKU+eV8r5tvXtUfkS/wBz9RQA+NWhffINq4xnrU32iL+9+hoAbJKkiFEOWPQYqDyJf7n6 + igCpqmi22s6ZPp2pWiz2c67ZI3wR9R6Eeor5d8efCrWfDGpO2n2tzqGlyHdFPFGXZB/dcDoR69DQBN8P + fhLqvifUlm1e1udP0mIgySSoUeX/AGUBGefXoK+nrDSodN0+CysbVILSBQsUSYAUf570AWfIl/ufqKnj + lSNAjnDDqMUAO+0Rf3v0NQyK0z74xuXGM9KAGeRL/c/UVJEfILeb8u7p3oAl+0Rf3v0NRysJ1Cx/MwOc + dKAIvIl/ufqKciPFIruuFHU5oAn+0Rf3v0NI80bIyq2WYYAwaAK/kS/3P1FHkS/3P1FAF6igDPf/AFj/ + AO8aSgC5b/6hfx/nUtAFS6/1w/3ahoAntfvP9BVqgCC6/wBUP96qtAD4v9cn1q9QAj/cb6Vngkcg4oAC + SeSc1oJ9xfpQAtUZf9c/1oAZVq1/1R/3qAJ6q3X3k+hoAgqa1/1x/wB2gC3UVx/qG/D+dAFOlT/WJ/vC + gDQooAZ5sf8Az0X86PNj/vr+dAFNlYuxCsQSSCBSbH/uN/3yaALULqkQVmCsM5BODT/Nj/vr+dAFefLy + AplhjGVGai2P/cb/AL5NAE1v+7Zt/wAuem7ip/Nj/vr+dAEU7B4wEIY56LzVfY/9xv8Avk0APjVlkVmU + gA8kjFWvNj/vr+dACNIhQgOvT1qmEfH3G/75NAAUfH3G/wC+TVxZECAF16etAC+bH/fX86qyKzSMyqSC + eCBmgBmx/wC43/fJqxAwSMhyFOejcUAS+bH/AH1/OoLj94y7Pmx1280AQ7H/ALjf98mpYMpIS+VGMZYY + oAsebH/fX86ZM6vEVVgzHGADk0AVdj/3G/75NKqsHUlWABBJIoAuebH/AH1/OjzY/wDnov50AUaKAL0X + +qT/AHRT6AKM/wDr3/D+VMoAtWv+rb/eqegCtd/wfjVegCW2/wBd+Bq5QBHP/qGqlQAD7w+taNABWcfv + H60AFXYP9QtAElU7n/XfgKAIqsWn8f4UAWaguv8AVr/vUAVafB/r0/H+VAF6mS/6p/8AdNAFGigAooAv + Rf6pP90U+gClP/r3/D+VR0AWrX/Vt/vVPQBWuv4PxqvQBLb/AOu/A1coAjn/ANS1UqAAfeH1rRoAKzj9 + 4/WgAq7B/qVoAkqncf678BQBFVi1/j/CgCzUF1/q1/3qAKtSQf69Px/lQBdpkv8Aqn/3TQBRooA//9kA + /9sAQwADAgIDAgIDAwMDBAMDBAUIBQUEBAUKBwcGCAwKDAwLCgsLDQ4SEA0OEQ4LCxAWEBETFBUVFQwP + FxgWFBgSFBUU/9sAQwEDBAQFBAUJBQUJFA0LDRQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQU + FBQUFBQUFBQUFBQUFBQUFBQU/8AAEQgBaAFoAwEiAAIRAQMRAf/EAB8AAAEFAQEBAQEBAAAAAAAAAAAB + AgMEBQYHCAkKC//EALUQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEV + UtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6 + g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn + 6Onq8fLz9PX29/j5+v/EAB8BAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKC//EALURAAIBAgQEAwQH + BQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKBCBRCkaGxwQkjM1LwFWJy0QoWJDThJfEXGBkaJicoKSo1 + Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZmqKjpKWm + p6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uLj5OXm5+jp6vLz9PX29/j5+v/aAAwDAQACEQMR + AD8A/SWiiigBJP8AVtXX1yEn+rauvoAKKKKAOQj/ANWtLSR/6taWgBJP9W1dfXISf6tq6+gAooooA5CP + /VrS0kf+rWloAST/AFbV19chJ/q2rr6ACiiigDkI/wDVrS0kf+rWloAST/VtXX1yEn+rauvoAKKKKAOQ + j/1a0tJH/q1paAEk/wBW1dfXISf6tq6+gAooooA5CP8A1a0tJH/q1paAEk/1bV19chJ/q2rr6ACiiigD + kI/9WtLSR/6taWgBJP8AVtXX1yEn+rauvoAKKKKAOQj/ANWtLSR/6taWgAooooATcv8AeWjcv95a6+ig + DjpGXa3zV2NFcdGq7V+WgDsaK4/av91aSRV2t8tABGy7V+anbl/vLXX0UAcdIy7W+auxorjo1Xavy0Ad + jRXH7V/urSSKu1vloAI2XavzU7cv95a6+igDjpGXa3zV2NFcdGq7V+WgDsaK4/av91aSRV2t8tABGy7V + +anbl/vLXX0UAcdIy7W+auxorjo1Xavy0AdjRXH7V/urSSKu1vloAI2XavzU7cv95a6+igDjpGXa3zV2 + NFcdGq7V+WgDsaK4/av91aSRV2t8tABGy7V+anbl/vLXX0UAcdIy7W+auxorjo1Xavy0AdjRXH7V/urS + SKu1vloAI2XavzU7cv8AeWuvooA46Rl2t81djRXHRqu1floA7GiuP2r/AHVpJFXa3y0AEbLtX5qduX+8 + tdfRQByG5f7y0V19FABRRRQAVyEf+rWuvrjo2XavzUAPpJP9W1G5f7y02Rl2t81AHY0UUUAFchH/AKta + 6+uOjZdq/NQA+kk/1bUbl/vLTZGXa3zUAdjRRRQAVyEf+rWuvrjo2XavzUAPpJP9W1ZHjDxnoPw98L6l + 4k8Taxa6JoWmx+ddX13JtjjX7v8AvMzN8qqvzM3yrXxL4l/4LE/CfTNQltdJ8IeJtbto/l+2M1vaq3+0 + q7magD9IKK/Nr/h9r8P/APonPiP/AMCbej/h9r8P/wDonPiP/wACbegD9Ja5CP8A1a18E/8AD7X4f/8A + ROfEf/gTb1n/APD574c/9E38Sf8AgZb0AfoPSSf6tq/Pn/h898Ov+iceJv8AwLt6P+Hz3w5/6Jv4k/8A + Ay3oA/TWivza/wCH2vw//wCic+I//Am3o/4fa/D/AP6Jz4j/APAm3oA/SWuQj/1a18E/8Ptfh/8A9E58 + R/8AgTb1b8J/8FhPhLrWqQ2er+F/Evh60b5ftzeTdRx/7TKrbqAPuykk/wBW1UdD8QaV4q0Gw1vQ9Rt9 + W0bUoVns7+1k3RzRt/ErVckZdrfNQB2NFFFABXIR/wCrWuvrjo2XavzUAPpJP9W1G5f7y02Rl2t81AHY + 0UUUAFchH/q1rr646Nl2r81AD6ST/VtRuX+8tNkZdrfNQB2NFFFABRRRQBx+1f7q0bV/urTqKAGSKu1v + lrsa5CT/AFbV19ABRRRQBx0artX5aXav91aWP/VrS0AMkVdrfLXY1yEn+rauvoAKKKKAOOjVdq/LS7V/ + urSx/wCrWloAZIq7W+WuxrkJP9W1dfQB+Vn/AAWy+IepwH4eeBoJni0iaO41e6iUfLNMrLHD/wB8r53/ + AH1X5VV+k/8AwW5/5Kt8N/8AsC3H/pRX5sUAFFFFABRRRQAUUUUAFFFFABRRRQB+u/8AwRR+IGp6v4H+ + JHhK6nMmmaLdWN3ZK38DXK3HmKP/AAHWv0xr8p/+CG//AB+fGX/rno//ALeV+rFAHHRqu1flpdq/3VpY + /wDVrS0AMkVdrfLXY1yEn+rauvoAKKKKAOOjVdq/LS7V/urSx/6taWgBkirtb5a7GuQk/wBW1dfQAUUU + UAcdGq7V+Wl2r/dWlj/1a0tADdq/3Vop1FACbl/vLRuX+8tdfRQBx0jLtb5q7GiuOjVdq/LQB2NFcftX + +6tJIq7W+WgAjZdq/NTty/3lrr6KAOOkZdrfNXY0Vx0artX5aAOxorj9q/3VpJFXa3y0AEbLtX5qduX+ + 8tdfRQBx0jLtb5q7GiuOjVdq/LQB+V//AAW6/wCSrfDb/sC3H/pRX5sV+j3/AAWn/wCSmfDL/sAzf+lF + fnDQAUUUUAFFFFABRRRQAUUUUAFFFFAH6of8EN/+Pz4y/wDXPR//AG8r9WK/JX/giZ/rvjR/176T/wCh + XVfpzIq7W+WgAjZdq/NTty/3lrr6KAOOkZdrfNXY0Vx0artX5aAOxorj9q/3VpJFXa3y0AEbLtX5qduX + +8tdfRQBx0jLtb5q7GiuOjVdq/LQB2NFcftX+6tJIq7W+WgAjZdq/NTty/3lrr6KAOQ3L/eWiuvooAKK + KKACuQj/ANWtdfXHRsu1fmoAfSSf6tqNy/3lpsjLtb5qAOxooooAK5CP/VrXX1x0bLtX5qAH0kn+rajc + v95abIy7W+agDsaKKKACuQj/ANWtdfXHRsu1fmoA/Kj/AILUf8lM+GP/AGAZv/Sivzfr9Hv+C0//ACUz + 4Zf9gGb/ANKK/OGgAooooAKKKKACiiigAooooAKKKKAP0+/4Imf6740f9e+k/wDoV1X6dyf6tq/MT/gi + Z/rvjR/176T/AOhXVfpzIy7W+agDsaKKKACuQj/1a119cdGy7V+agB9JJ/q2o3L/AHlpsjLtb5qAOxoo + ooAK5CP/AFa119cdGy7V+agB9JJ/q2o3L/eWmyMu1vmoA7GiiigAooooA4/av91aNq/3Vp1FADJFXa3y + 12NchJ/q2rr6ACiiigDjo1Xavy0u1f7q0sf+rWloAZIq7W+WuxrkJP8AVtXX0AFFFFAHHRqu1flpdq/3 + VpY/9WtLQAyRV2t8tdjXISf6tq6+gD8fv+C3X/JVvht/2Bbj/wBKK/Niv0n/AOC3P/JVvhv/ANgW4/8A + SivzYoAKKKKACiiigAooooAKKKKACiiigD9UP+CG/wDx+fGX/rno/wD7eV+rFflP/wAEN/8Aj8+Mv/XP + R/8A28r9WKAOOjVdq/LS7V/urSx/6taWgBkirtb5a7GuQk/1bV19ABRRRQBx0artX5aXav8AdWlj/wBW + tLQAyRV2t8tdjXISf6tq6+gAooooA46NV2r8tLtX+6tLH/q1paAG7V/urRTqKAE3L/eWjcv95a6+igDj + pGXa3zV2NFcdGq7V+WgDsaK4/av91aSRV2t8tABGy7V+anbl/vLXX0UAcdIy7W+auxorjo1Xavy0AdjR + XH7V/urSSKu1vloAI2XavzU7cv8AeWuvooA46Rl2t81djRXHRqu1floA/K//AILdf8lW+G3/AGBbj/0o + r82K/R7/AILT/wDJTPhl/wBgGb/0or84aACiiigAooooAKKKKACiiigAooooA/VD/ghv/wAfnxl/656P + /wC3lfqxX5K/8ETP9d8aP+vfSf8A0K6r9OZFXa3y0AEbLtX5qduX+8tdfRQBx0jLtb5q7GiuOjVdq/LQ + B2NFcftX+6tJIq7W+WgAjZdq/NTty/3lrr6KAOOkZdrfNXY0Vx0artX5aAOxorj9q/3VpJFXa3y0AEbL + tX5qduX+8tdfRQByG5f7y0V19FABRRRQAVyEf+rWuvrjo2XavzUAPpJP9W1G5f7y02Rl2t81AHY0UUUA + FchH/q1rr646Nl2r81AD6ST/AFbUbl/vLTZGXa3zUAdjRRRQAVyEf+rWuvrjo2XavzUAflR/wWo/5KZ8 + Mf8AsAzf+lFfm/X6Pf8ABaf/AJKZ8Mv+wDN/6UV+cNABRRRQAUUUUAFFFFABRRRQAUUUUAfp9/wRM/13 + xo/699J/9Cuq/TuT/VtX5if8ETP9d8aP+vfSf/Qrqv05kZdrfNQB2NFFFABXIR/6ta6+uOjZdq/NQA+k + k/1bUbl/vLTZGXa3zUAdjRRRQAVyEf8Aq1rr646Nl2r81AD6ST/VtRuX+8tNkZdrfNQB2NFFFABRRRQB + x+1f7q0bV/urTqKAGSKu1vlrsa5CT/VtXX0AFFFFAHHRqu1flpdq/wB1aWP/AFa0tADJFXa3y12NchJ/ + q2rr6ACiiigDjo1Xavy0u1f7q0sf+rWloAZIq7W+WuxrkJP9W1dfQB+P3/Bbr/kq3w2/7Atx/wClFfmx + X6T/APBbn/kq3w3/AOwLcf8ApRX5sUAFFFFABRRRQAUUUUAFFFFABRRRQB+qH/BDf/j8+Mv/AFz0f/28 + r9WK/Kf/AIIb/wDH58Zf+uej/wDt5X6sUAcdGq7V+Wl2r/dWlj/1a0tADJFXa3y12NchJ/q2rr6ACiii + gDjo1Xavy0u1f7q0sf8Aq1paAGSKu1vlrsa5CT/VtXX0AFFFFAHHRqu1flpdq/3VpY/9WtLQA3av91aK + dRQAm5f7y0bl/vLXX0UAcdIy7W+auxorjo1Xavy0AdjRXH7V/urSSKu1vloAI2XavzU7cv8AeWuvooA4 + 6Rl2t81djRXHRqu1floA7GiuP2r/AHVpJFXa3y0AEbLtX5qduX+8tdfRQBx0jLtb5q7GiuOjVdq/LQB+ + V/8AwW6/5Kt8Nv8AsC3H/pRX5sV+j3/Baf8A5KZ8Mv8AsAzf+lFfnDQAUUUUAFFFFABRRRQAUUUUAFFF + FAH6of8ABDf/AI/PjL/1z0f/ANvK/VivyV/4Imf6740f9e+k/wDoV1X6cyKu1vloAI2XavzU7cv95a6+ + igDjpGXa3zV2NFcdGq7V+WgDsaK4/av91aSRV2t8tABGy7V+anbl/vLXX0UAcdIy7W+auxorjo1Xavy0 + AdjRXH7V/urSSKu1vloAI2XavzU7cv8AeWuvooA5Dcv95aK6+igAooooAK5CP/VrXX1x0bLtX5qAH0kn + +rajcv8AeWmyMu1vmoA7GiiigArkI/8AVrXzP+01/wAFNPh1+zn4huvC1rYXvjTxXZ/JdWdhJHDb2sn/ + ADzmmb7r8fdVWr5n/wCH21r/ANEQ/wDLs/8AuOgD9MaST/VtX5n/APD7a1/6Ih/5dn/3HR/w+2tf+iIf + +XZ/9x0Afq/RX5V/8Pzf+qKf+XV/9xUf8Pzf+qKf+XV/9xUAfqpXIR/6ta/Nr/h+b/1RT/y6v/uKqf8A + w+1tf+iIf+XZ/wDcVAHL/wDBaj/kpnwx/wCwDN/6UV+b9fS37bH7X0f7YHiXw1rA8JN4ROi2LWPkf2l9 + t8zdJu3bvJjr5poAKKKKACiiigAooooAKKKKACiiigD9Pv8AgiZ/rvjR/wBe+k/+hXVfp3J/q2r8L/2I + /wBtiL9jmTxgx8Ft4wbxFHaxmP8AtT7D5Pk+Z/0xk3bvM/Svp/8A4fa2v/REP/Ls/wDuKgD9YKK/Kv8A + 4fm/9UU/8ur/AO4qP+H5v/VFP/Lq/wDuKgD9VK5CP/VrX5tf8Pzf+qKf+XV/9xVU/wCH21r/ANEQ/wDL + s/8AuOgD9MaST/VtX5n/APD7a1/6Ih/5dn/3HSf8PtbX/oiH/l2f/cVAH6wUV8ifst/8FJfhx+0xrUXh + sWl54Q8WzD9zpmpSJJHc/wCzDMv3m/2WVa+u6ACuQj/1a119cdGy7V+agB9JJ/q2o3L/AHlpsjLtb5qA + OxooooAKKKKAOP2r/dWjav8AdWnUUAMkVdrfLXY1yEn+rauvoAKKKKAOOjVdq/LXNfFbxHeeBfhP488S + aXGr6povh/UNSs1ZdytNDbySR/L/ALy108f+rWiWGG6hmt7qFbmzuI2huIZF3LJG3ysu3+7tagD+ZS+v + ZtQuprm5mee4mZpJJpG3NIzfMzM38Ryao19U/tu/sZ6x+yt4xa7sYpdS8AapK39lao3zeT95vss3/TRf + 738S/wDAq+VqACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii + igDV0PWb3w7rNjq+mXElhqWnzx3VtdQtiSGaNlZJF/2lZQ1f0q+HdUl8R+GtF1i5tltbrUNPt7yaDb/q + 5JIVZl/4CzV+Kn7BX7Eup/tMeMbfxDr9u9j8NNKuVa9unVh/aDrz9lh/9mb+Fa/b64k8yRm+VV+6qr91 + V/hoAhkVdrfLXY1yEn+rauvoAKKKKAOOjVdq/LS7V/urSx/6taWgBu1f7q0U6igBNy/3lo3L/eWuvooA + 46Rl2t81djRXHRqu1floA7GiuP2r/dWkkVdrfLQARsu1fmp25f7y119FAHmvjjwX4e+JHg/VfDHinTLf + WdA1KFobqyufut/F8v8AErK3zKy/MrfMtfiX+21+xR4g/ZP8Xm5t1m1bwHqMjLpmsMu7yyc/6PNj7siq + p5+6w/4FX7/V5r4z8D+H/iT4P1Twx4n0uDWtA1SHybqyuV+8v3t395WVvmVl+ZW+ZaAP5oaK+pP21P2K + 9c/ZV8Vi6t/O1fwJqTuNM1h1GY2/5959v3ZF/vfdb/vqvlugAooooAKKKKACiiigAooooAKKKKACiiig + AooooAKKKKACiiigAooooAKKKKACvr39hX9hHWP2pvEQ1zWln0r4b6bMq31+nyyXsg/5d7f/ANmk+6v1 + qP8AYd/Yb1j9qLxJ/bmtC40n4b6bMq3uoINsl5J/z72/+1/eb7sdftb4f8M6P4L8M6f4f0DTrfSNB02L + 7PZ6fbLtjhjX/O75vmZqADwz4e0XwZ4b07w/4f0+30jQ9NhW3s9Ptl2xwx/5+b5vmZq09y/3lrr6KAOO + kZdrfNXY0Vx0artX5aAOxorj9q/3VpJFXa3y0AEbLtX5qduX+8tdfRQByG5f7y0V19FABRRRQAVyEf8A + q1rr646Nl2r81AD6ST/VtRuX+8tNkZdrfNQB2NFFFABXIR/6ta6+uOjZdq/NQBkeNvBOgfEnwjqnhjxR + pUGs6BqkLQ3Vlcr8rfxfL/ErK3zKy/MrfMtfiH+2l+xbrv7Kviv7RAJtY8C6jKw0zWAvzI3/AD73G37s + i/8Aj2P++f3V3L/eWsTxx4N8P/ErwjqfhjxRpsOs6BqMPk3Vlcfxfxf7ysrfMrL8ytQB/NDRX1V+2z+x + R4g/ZP8AF5ubdZdX8Cai7LpmsMufLY5/0ebH3ZFVTz91l/4FXyrQAUUUUAFFFFABRRRQAUUUUAFFFFAB + RRRQAUUUUAFFFFABRRRQAV9dfsP/ALDesftQ+IhrmtRz6R8NtOmVb2/QbJL6RfvW9v8A7X95vux0/wDY + V/YS1j9qbxEuua0s+lfDbT5lW+v0+WS9kH/Lvb/+zSfdWv2p8MeHtF8GeG9O8P8Ah/T7fRtD02Fbez0+ + 3XbHDH/n5vm+ZmoAd4b8M6T4J8O6b4f8PabDpOh6bCtvZ6fbLtjhjX/O75vmZq0ZP9W1G5f7y02Rl2t8 + 1AHY0UUUAFchH/q1rr646Nl2r81AD6ST/VtRuX+8tNkZdrfNQB2NFFFABRRRQBx+1f7q0bV/urTqKAGS + Ku1vlrsa5CT/AFbV19ABRRRQBx0artX5aXav91aWP/VrS0AMkVdrfLXY1yEn+rauvoAKKKKAPNfGfgfw + /wDEnwfqnhjxPpcGtaBqkPk3Vlcr95fvbv7ysrfMrL8yt8y1+In7aH7F+t/sqeLBPbGbVvAmoSsNM1jb + 8yH/AJ959uNsqr/u7ua/daP/AFa1jeNfBOg/ErwjqnhjxTpUGtaBqkLQ3VlcfdZfvbv7ysrfMrL8yt8y + 0AfzP0V9SftqfsV65+yr4rF1b+dq/gTUncaZrDqMxt/z7z7fuyL/AHvut/31Xy3QAUUUUAFFFFABRRRQ + AUUUUAFFFFABRRRQAUUUUAFfXP7Dv7Dmr/tR+I/7b1kTaT8NtOmVb2/QbZL2T/n3t/8Aa/vN92Oj9h39 + hvWP2ovEn9ua0LjSfhvpsyre6gg2yXkn/Pvb/wC1/eb7sdftf4b8M6T4J8O6d4f0DTYdI0PTYlt7PT7Z + dscMa/53fN8zNQA3w/4Z0fwX4Z0/w/oGnW+kaDpsX2ez0+2XbHDGv+d3zfMzV6FXISf6tq6+gAooooA4 + 6NV2r8tLtX+6tLH/AKtaWgBkirtb5a7GuQk/1bV19ABRRRQBx0artX5aXav91aWP/VrS0AN2r/dWinUU + AJuX+8tG5f7y119FAHHSMu1vmrsaK46NV2r8tAHY0Vx+1f7q0kirtb5aACNl2r81O3L/AHlrr6KAOOkZ + drfNXY0Vx0artX5aAOxorj9q/wB1aSRV2t8tABGy7V+anbl/vLXX0UAea+OPBvh74keD9U8MeKdKt9Z0 + DVIWhurK5+638Xy/xKyt8ysvzK3zLX4lfts/sVeIP2TvF5nt1m1bwHqMjLpmsMu7y2Of9Hmx92RVU/7L + L/wKv3/rzXxp4G8P/ErwfqPhfxRpkOsaBqMPlXVlMv3l+9u/vKyt8ysvzK1AH80NFfUX7aH7F2u/sq+L + PtFsZtW8CahKy6ZqwX/VNz/o8+37sqj/AL6r5doAKKKKACiiigAooooAKKKKACiiigAr69/YV/YT1j9q + bxENb1qOfTPhvpsyrfX6fLJeyD/l3t//AGaT7q1H+w9+w3rH7UfiRdc1kTaV8NtOmVb2/QbZL2T/AJ97 + f/a/vN92Ov2t8P8AhvR/BvhvT9A0DTYdI0PTYvs9np9su2OGNf7v/oX95moAPDPh7R/BnhvTtA0Cwt9I + 0HTYlt7PT7ZdscMa/wCd3zfMzVp7l/vLXX0UAcdIy7W+auxorjo1Xavy0AdjRXH7V/urSSKu1vloAI2X + avzU7cv95a6+igDjpGXa3zV2NFcdGq7V+WgDsaK4/av91aSRV2t8tABGy7V+anbl/vLXX0UAchuX+8tF + dfRQAUUUUAFchH/q1rr646Nl2r81AD6ST/VtRuX+8tNkZdrfNQB2NFFFABXIR/6ta6+uOjZdq/NQA+kk + /wBW1G5f7y02Rl2t81AHY0UUUAFchH/q1rr646Nl2r81AGR418E6D8SvCOqeGPFOlQa1oGqQtDdWVx91 + l+9u/vKyt8ysvzK3zLX4f/tm/sY67+yp4uMimXVPA2pTN/ZWs7f97/R5v7sqr/wFq/dncv8AeWsLx94H + 8O/E/wAG6p4V8V6dFrGgalH5N1azf+hK33lZW+ZWX5lagD+aOivqT9tH9inXv2T/ABg0g87VvA2oSsul + a2Fzg/N/o8237sqqv+63/fW35boAKKKKACiiigAooooAK+uf2Hf2G9Z/aj8R/wBuayJtJ+G2nTKt7foN + sl7J/wA+9v8A7X95vux0/wDYV/YR1f8Aam8RDWtZSfS/hvps22+vk+WS9k/597f/ANmk+6tftV4Z8PaL + 4M8N6d4f8P6fb6Roemwrb2en2y7Y4Y/8/N83zM1ADvDfhnSfBPh3TfDugadDpGh6bEtvZ6fbLtjhjX/O + 75vmZq0ZP9W1G5f7y02Rl2t81AHY0UUUAFchH/q1rr646Nl2r81AD6ST/VtRuX+8tNkZdrfNQB2NFFFA + BXIR/wCrWuvrjo2XavzUAPpJP9W1G5f7y02Rl2t81AHY0UUUAFFFFAHH7V/urRtX+6tOooAZIq7W+Wux + rkJP9W1dfQAUUUUAcdGq7V+Wl2r/AHVpY/8AVrS0AMkVdrfLXY1yEn+rauvoAKKKKAOOjVdq/LS7V/ur + Sx/6taWgBkirtb5a7GuQk/1bV19ABRRRQB5n448A+Hfid4L1Hwn4p0qLVtA1OHy7q0m/763K33lZW+ZW + X5lavw+/bM/Yx1/9lPxczKJ9Z8DalMw0nW/L6f8ATvNt+7Kq/wDAZF+ZfRf3ej/1a1iePPAfh/4n+D9T + 8KeK9Mi1jQNUj8q4tJv++tyt95WVvmVl+ZWoA/mhor6b/bN/Yv8AEH7Kvi7eBLrHgXUpWGk635Q/8B5t + v3ZlXv8Adk+8v8QX5koAKKKKACvrr9h/9hvWP2ofEQ1zWo59I+G2nTKt7foNkl9Iv3re3/2v7zfdjpP2 + Hv2G9Y/aj8SLrmsibSvhtp0yre36DbJeyf8APvb/AO1/eb7sdftf4b8M6T4J8O6d4f0DTYdI0PTYlt7P + T7ZdscMa/wCd3zfMzUAN8P8AhnR/BfhnT/D+gadb6RoOmxfZ7PT7ZdscMa/53fN8zNXoVchJ/q2rr6AC + iiigDjo1Xavy0u1f7q0sf+rWloAZIq7W+WuxrkJP9W1dfQAUUUUAcdGq7V+Wl2r/AHVpY/8AVrS0AMkV + drfLXY1yEn+rauvoAKKKKAOOjVdq/LS7V/urSx/6taWgBu1f7q0U6igBNy/3lo3L/eWuvooA46Rl2t81 + djRXHRqu1floA7GiuP2r/dWkkVdrfLQARsu1fmp25f7y119FAHHSMu1vmrsaK46NV2r8tAHY0Vx+1f7q + 0kirtb5aACNl2r81O3L/AHlrr6KAOOkZdrfNXY0Vx0artX5aAOxorj9q/wB1aSRV2t8tABGy7V+anbl/ + vLXX0UAeZ+PPBPh34n+DdT8K+KdOh1nQNTh2XVpN/wB9blb7ysrfMrL8ytX4kftpfsWeIP2T/F3mDztW + 8C6hI39l60UztP8Az7zbfuyqq9fut/31t/oDrz7xB4X0Xxr4dvNB8Q6PZ65ot4u240/UIVmhkX73zK3/ + AH1u+8rUAfzMV9e/sK/sJ6x+1J4gGu60s+lfDbTplW+v0+WS9kH/AC72/wD7NJ91a/SKH/gmj+zdFqv2 + 9fAM7fxfYm1q8+zr/wCRN1fR2k6HpfhrRLTRtG0210jSLKHybawsIVhht4/7qxr8q0AQeGfD2j+DPDen + aBoFhb6RoOmxLb2en2y7Y4Y1/wA7vm+ZmrT3L/eWuvooA46Rl2t81djRXHRqu1floA7GiuP2r/dWkkVd + rfLQARsu1fmp25f7y119FAHHSMu1vmrsaK46NV2r8tAHY0Vx+1f7q0kirtb5aACNl2r81O3L/eWuvooA + 46Rl2t81djRXHRqu1floA7GiuP2r/dWkkVdrfLQARsu1fmp25f7y119FAHIbl/vLRXX0UAFFFFABXIR/ + 6ta6+uOjZdq/NQA+kk/1bUbl/vLTZGXa3zUAdjRRRQAVyEf+rWuvrjo2XavzUAPpJP8AVtRuX+8tNkZd + rfNQB2NFFFABXIR/6ta6+uOjZdq/NQA+kk/1bUbl/vLTZGXa3zUAdjRRRQAVyEf+rWuvrjo2XavzUAPp + JP8AVtRuX+8tNkZdrfNQB2NFFFABXIR/6ta6+uOjZdq/NQA+kk/1bUbl/vLTZGXa3zUAdjRRRQAVyEf+ + rWuvrjo2XavzUAPpJP8AVtRuX+8tNkZdrfNQB2NFFFABXIR/6ta6+uOjZdq/NQA+kk/1bUbl/vLTZGXa + 3zUAdjRRRQAUUUUAcftX+6tG1f7q06igBkirtb5a7GuQk/1bV19ABRRRQBx0artX5aXav91aWP8A1a0t + ADJFXa3y12NchJ/q2rr6ACiiigDjo1Xavy0u1f7q0sf+rWloAZIq7W+WuxrkJP8AVtXX0AFFFFAHHRqu + 1flpdq/3VpY/9WtLQAyRV2t8tdjXISf6tq6+gAooooA46NV2r8tLtX+6tLH/AKtaWgBkirtb5a7GuQk/ + 1bV19ABRRRQBx0artX5aXav91aWP/VrS0AMkVdrfLXY1yEn+rauvoAKKKKAOOjVdq/LS7V/urSx/6taW + gBkirtb5a7GuQk/1bV19ABRRRQBx0artX5aXav8AdWlj/wBWtLQA3av91aKdRQAUUUUAJJ/q2rr6KKAC + iiigDkI/9WtLRRQAkn+rauvoooAKKKKAOQj/ANWtLRRQAkn+rauvoooAKKKKAOQj/wBWtLRRQAkn+rau + voooAKKKKAOQj/1a0tFFACSf6tq6+iigAooooA5CP/VrS0UUAJJ/q2rr6KKACiiigDkI/wDVrS0UUAJJ + /q2rr6KKACiiigDkI/8AVrS0UUAFFFFAH//Z + + + \ No newline at end of file diff --git a/Sailboat/Sailboat/Program.cs b/Sailboat/Sailboat/Program.cs index 62a824b..89c8af2 100644 --- a/Sailboat/Sailboat/Program.cs +++ b/Sailboat/Sailboat/Program.cs @@ -11,7 +11,7 @@ namespace Sailboat // 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 FormSailboat()); } } } \ No newline at end of file diff --git a/Sailboat/Sailboat/Properties/Resources.Designer.cs b/Sailboat/Sailboat/Properties/Resources.Designer.cs new file mode 100644 index 0000000..268d3e7 --- /dev/null +++ b/Sailboat/Sailboat/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// Этот код создан программой. +// Исполняемая версия:4.0.30319.42000 +// +// Изменения в этом файле могут привести к неправильной работе и будут потеряны в случае +// повторной генерации кода. +// +//------------------------------------------------------------------------------ + +namespace Sailboat.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("Sailboat.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/Sailboat/Sailboat/Properties/Resources.resx b/Sailboat/Sailboat/Properties/Resources.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/Sailboat/Sailboat/Properties/Resources.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/Sailboat/Sailboat/Resources/arrowDown.jpg b/Sailboat/Sailboat/Resources/arrowDown.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f21002e9dce74a1a585cf193d689dabca519cdff GIT binary patch literal 62022 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 av7M8J~td~%> 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 OjHZEMlm?jp-vj_Aq!j}I literal 0 HcmV?d00001 diff --git a/Sailboat/Sailboat/Resources/arrowRight.jpg b/Sailboat/Sailboat/Resources/arrowRight.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b440197337637a3901527809017ac3875c61ab4d GIT binary patch literal 61715 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 literal 0 HcmV?d00001 diff --git a/Sailboat/Sailboat/Resources/arrowUp.jpg b/Sailboat/Sailboat/Resources/arrowUp.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e630cea81778990ee584c30bf17b379509fe52d8 GIT binary patch literal 62105 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 a8enable + + + True + True + Resources.resx + + + + + + ResXFileCodeGenerator + Resources.Designer.cs + + + \ No newline at end of file -- 2.25.1 From 58f5deb6409f8dd64f8ac8e8d8b7d84d23d0dad7 Mon Sep 17 00:00:00 2001 From: maxim24052002 Date: Mon, 25 Dec 2023 02:09:37 +0300 Subject: [PATCH 2/3] =?UTF-8?q?=D0=93=D0=BE=D1=82=D0=BE=D0=B2=D0=B0=D1=8F?= =?UTF-8?q?=20=D0=BF=D0=BE=D0=BB=D0=BD=D0=BE=D1=81=D1=82=D1=8C=D1=8E=20Lab?= =?UTF-8?q?=5F2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Sailboat/Sailboat/AbstractStrategy.cs | 132 ++++++++++++++++++ Sailboat/Sailboat/DrawingBoat.cs | 146 ++++++++++++++++++++ Sailboat/Sailboat/DrawingObjectBoat.cs | 37 +++++ Sailboat/Sailboat/DrawingSailboat.cs | 150 +++++---------------- Sailboat/Sailboat/EntityBoat.cs | 22 +++ Sailboat/Sailboat/EntitySailboat.cs | 45 +------ Sailboat/Sailboat/Form1.Designer.cs | 39 ------ Sailboat/Sailboat/Form1.cs | 10 -- Sailboat/Sailboat/Form1.resx | 120 ----------------- Sailboat/Sailboat/FormSailboat.Designer.cs | 89 +++++++++--- Sailboat/Sailboat/FormSailboat.cs | 72 ++++++++-- Sailboat/Sailboat/IMoveableObject.cs | 33 +++++ Sailboat/Sailboat/MoveToBorder.cs | 57 ++++++++ Sailboat/Sailboat/MoveToCenter.cs | 56 ++++++++ Sailboat/Sailboat/ObjectParameters.cs | 54 ++++++++ Sailboat/Sailboat/Status.cs | 18 +++ 16 files changed, 722 insertions(+), 358 deletions(-) create mode 100644 Sailboat/Sailboat/AbstractStrategy.cs create mode 100644 Sailboat/Sailboat/DrawingBoat.cs create mode 100644 Sailboat/Sailboat/DrawingObjectBoat.cs create mode 100644 Sailboat/Sailboat/EntityBoat.cs delete mode 100644 Sailboat/Sailboat/Form1.Designer.cs delete mode 100644 Sailboat/Sailboat/Form1.cs delete mode 100644 Sailboat/Sailboat/Form1.resx create mode 100644 Sailboat/Sailboat/IMoveableObject.cs create mode 100644 Sailboat/Sailboat/MoveToBorder.cs create mode 100644 Sailboat/Sailboat/MoveToCenter.cs create mode 100644 Sailboat/Sailboat/ObjectParameters.cs create mode 100644 Sailboat/Sailboat/Status.cs diff --git a/Sailboat/Sailboat/AbstractStrategy.cs b/Sailboat/Sailboat/AbstractStrategy.cs new file mode 100644 index 0000000..fc58dd3 --- /dev/null +++ b/Sailboat/Sailboat/AbstractStrategy.cs @@ -0,0 +1,132 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +using Sailboat.DrawingObjects; +namespace Sailboat.MovementStrategy +{ + public abstract class AbstractStrategy + { + /// + /// Перемещаемый объект + /// + private IMoveableObject? _moveableObject; + /// + /// Статус перемещения + /// + private Status _state = Status.NotInit; + /// + /// Ширина поля + /// + protected int FieldWidth { get; private set; } + /// + /// Высота поля + /// + protected int FieldHeight { get; private set; } + /// + /// Статус перемещения + /// + public Status GetStatus() { return _state; } + /// + /// Установка данных + /// + /// Перемещаемый объект + /// Ширина поля + /// Высота поля + public void SetData(IMoveableObject moveableObject, int width, int + height) + { + if (moveableObject == null) + { + _state = Status.NotInit; + return; + } + _state = Status.InProgress; + _moveableObject = moveableObject; + FieldWidth = width; + FieldHeight = height; + } + /// + /// Шаг перемещения + /// + public void MakeStep() + { + if (_state != Status.InProgress) + { + return; + } + if (IsTargetDestinaion()) + { + _state = Status.Finish; + return; + } + MoveToTarget(); + } + /// + /// Перемещение влево + /// + /// Результат перемещения (true - удалось переместиться, false - неудача) + protected bool MoveLeft() => MoveTo(DirectionType.Left); + /// + /// Перемещение вправо + /// + /// Результат перемещения (true - удалось переместиться, false - неудача) + protected bool MoveRight() => MoveTo(DirectionType.Right); + /// + /// Перемещение вверх + /// + /// Результат перемещения (true - удалось переместиться, false - неудача) + protected bool MoveUp() => MoveTo(DirectionType.Up); + /// + /// Перемещение вниз + /// + /// Результат перемещения (true - удалось переместиться, false - неудача) + protected bool MoveDown() => MoveTo(DirectionType.Down); + /// + /// Параметры объекта + /// + protected ObjectParameters? GetObjectParameters => + _moveableObject?.GetObjectPosition; + /// + /// Шаг объекта + /// + /// + protected int? GetStep() + { + if (_state != Status.InProgress) + { + return null; + } + return _moveableObject?.GetStep; + } + /// + /// Перемещение к цели + /// + protected abstract void MoveToTarget(); + /// + /// Достигнута ли цель + /// + /// + protected abstract bool IsTargetDestinaion(); + /// + /// Попытка перемещения в требуемом направлении + /// + /// Направление + /// Результат попытки (true - удалось переместиться, false - неудача) + private bool MoveTo(DirectionType directionType) + { + if (_state != Status.InProgress) + { + return false; + } + if (_moveableObject?.CheckCanMove(directionType) ?? false) + { + _moveableObject.MoveObject(directionType); + return true; + } + return false; + } + } +} diff --git a/Sailboat/Sailboat/DrawingBoat.cs b/Sailboat/Sailboat/DrawingBoat.cs new file mode 100644 index 0000000..1319e35 --- /dev/null +++ b/Sailboat/Sailboat/DrawingBoat.cs @@ -0,0 +1,146 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +using Sailboat.Entities; + +namespace Sailboat.DrawingObjects +{ + public class DrawingBoat + { + public EntityBoat? EntityBoat { get; protected set; } + private int _pictureWidth; + private int _pictureHeight; + protected int _startPosX; + protected int _startPosY; + private readonly int _boatWidth = 160; + private readonly int _boatHeight = 160; + public int GetPosX => _startPosX; + public int GetPosY => _startPosY; + public int GetWidth => _boatWidth; + public int GetHeight => _boatHeight; + + + public DrawingBoat(int speed, double weight, Color bodyColor, int width, int height) + { + if (width < _boatWidth || height < _boatHeight) + { + return; + } + _pictureWidth = width; + _pictureHeight = height; + EntityBoat = new EntityBoat(speed, weight, bodyColor); + } + + protected DrawingBoat(int speed, double weight, Color bodyColor, int width, int height, int boatWidth, int boatHeight) + { + if (width < _boatWidth || height < _boatHeight) + { + return; + } + _pictureWidth = width; + _pictureHeight = height; + _boatWidth = boatWidth; + _boatHeight = boatHeight; + EntityBoat = new EntityBoat(speed, weight, bodyColor); + } + public void SetPosition(int x, int y) + { + if (x < 0 || x + _boatWidth > _pictureWidth) + { + x = 0; + } + if (y < 0 || y + _boatHeight > _pictureHeight) + { + y = 0; + } + _startPosX = x; + _startPosY = y; + } + public bool CanMove(DirectionType direction) + { + if (EntityBoat == null) + { + return false; + } + return direction switch + { + //влево + DirectionType.Left => _startPosX - EntityBoat.Step > 0, + //вверх + DirectionType.Up => _startPosY - EntityBoat.Step > 0, + // вправо + DirectionType.Right => _startPosX + EntityBoat.Step < _pictureWidth, + //вниз + DirectionType.Down => _startPosY + EntityBoat.Step < _pictureHeight, + }; + } + public void MoveTransport(DirectionType direction) + { + if (EntityBoat == null) + { + return; + } + switch (direction) + { + case DirectionType.Left: + if (_startPosX - EntityBoat.Step > 0) + { + _startPosX -= (int)EntityBoat.Step; + } + break; + case DirectionType.Up: + if ((_startPosY - 15) - EntityBoat.Step > 0) + { + _startPosY -= (int)EntityBoat.Step; + } + break; + case DirectionType.Right: + if (_startPosX + EntityBoat.Step + _boatWidth < _pictureWidth) + { + _startPosX += (int)EntityBoat.Step; + } + break; + case DirectionType.Down: + if (_startPosY + EntityBoat.Step + _boatHeight < _pictureHeight) + { + _startPosY += (int)EntityBoat.Step; + } + break; + } + } + public virtual void DrawTransport(Graphics g) + { + if (EntityBoat == null) + { + return; + } + Pen pen = new(Color.Black); + + //Основной корпус лодки + Brush Brush = new + SolidBrush(EntityBoat.BodyColor); + + Point[] hull = new Point[] + { + new Point(_startPosX + 10, _startPosY + 90), + new Point(_startPosX + 110, _startPosY + 90), + new Point(_startPosX + 140, _startPosY + 120), + new Point(_startPosX + 110, _startPosY + 150), + new Point(_startPosX + 10, _startPosY + 150) + }; + g.FillPolygon(Brush, hull); + g.DrawPolygon(pen, hull); + + Brush addBrush = new + SolidBrush(Color.Aqua); + + //Каюта лодки + g.FillEllipse(addBrush, _startPosX + 20, _startPosY + 100, 90, 40); + g.DrawEllipse(pen, _startPosX + 20, _startPosY + 100, 90, 40); + } + } +} + diff --git a/Sailboat/Sailboat/DrawingObjectBoat.cs b/Sailboat/Sailboat/DrawingObjectBoat.cs new file mode 100644 index 0000000..6c7f211 --- /dev/null +++ b/Sailboat/Sailboat/DrawingObjectBoat.cs @@ -0,0 +1,37 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +using Sailboat.DrawingObjects; + +namespace Sailboat.MovementStrategy +{ + public class DrawingObjectBoat : IMoveableObject + { + private readonly DrawingBoat? _drawingBoat = null; + public DrawingObjectBoat(DrawingBoat drawingBoat) + { + _drawingBoat = drawingBoat; + } + public ObjectParameters? GetObjectPosition + { + get + { + if (_drawingBoat == null || _drawingBoat.EntityBoat == + null) + { + return null; + } + return new ObjectParameters(_drawingBoat.GetPosX, _drawingBoat.GetPosY, _drawingBoat.GetWidth, _drawingBoat.GetHeight); + } + } + public int GetStep => (int)(_drawingBoat?.EntityBoat?.Step ?? 0); + public bool CheckCanMove(DirectionType direction) => + _drawingBoat?.CanMove(direction) ?? false; + public void MoveObject(DirectionType direction) => + _drawingBoat?.MoveTransport(direction); + + } +} diff --git a/Sailboat/Sailboat/DrawingSailboat.cs b/Sailboat/Sailboat/DrawingSailboat.cs index 1a40654..c25780b 100644 --- a/Sailboat/Sailboat/DrawingSailboat.cs +++ b/Sailboat/Sailboat/DrawingSailboat.cs @@ -2,92 +2,36 @@ using System.Collections.Generic; using System.Drawing; using System.Linq; -using System.Reflection; using System.Text; using System.Threading.Tasks; -namespace Sailboat -{ - public class DrawingSailboat - { - public EntitySailboat? EntitySailboat { get; private set; } - private int _pictureWidth; - private int _pictureHeight; - private int _startPosX; - private int _startPosY; - private readonly int _boatWidth = 160; - private readonly int _boatHeight = 160; - public bool Init(int speed, double weight, Color bodyColor, Color additionalColor, bool hull, bool sail, int width, int height) - { - if (width < _boatWidth || height < _boatHeight) - { - return false; - } - _pictureWidth = width; - _pictureHeight = height; - EntitySailboat = new EntitySailboat(); - EntitySailboat.Init(speed, weight, bodyColor, additionalColor, hull, sail); - return true; - } - public void SetPosition(int x, int y) - { - if (x < 0 || x + _boatWidth > _pictureWidth) - { - x = 0; - } - if (y < 0 || y + _boatHeight > _pictureHeight) - { - y = 0; - } - _startPosX = x; - _startPosY = y; - } - public void MoveTransport(DirectionType direction) - { - if (EntitySailboat == null) - { - return; - } - switch (direction) - { - case DirectionType.Left: - if (_startPosX - EntitySailboat.Step > 0) - { - _startPosX -= (int)EntitySailboat.Step; - } - break; - case DirectionType.Up: - if ((_startPosY - 15) - EntitySailboat.Step > 0) - { - _startPosY-= (int)EntitySailboat.Step; - } - break; - case DirectionType.Right: - if (_startPosX + EntitySailboat.Step + _boatWidth < _pictureWidth) - { - _startPosX += (int)EntitySailboat.Step; - } - break; - case DirectionType.Down: - if (_startPosY + EntitySailboat.Step + _boatHeight < _pictureHeight) - { - _startPosY += (int)EntitySailboat.Step; - } - break; - } - } - public void DrawTransport(Graphics g) - { - if (EntitySailboat == null) - { - return; - } - Pen pen = new(Color.Black, 4); - Brush additionalBrush = new - SolidBrush(EntitySailboat.AdditionalColor); +using Sailboat.Entities; - //Усиленный корпус парусной лодки - if (EntitySailboat.Hull) +namespace Sailboat.DrawingObjects +{ + public class DrawingSailboat : DrawingBoat + { + public DrawingSailboat(int speed, double weight, Color bodyColor, Color additionalColor, bool hull, bool sail, int width, int height) : + base(speed, weight, bodyColor, width, height, 160, 160) + { + if (EntityBoat != null) + { + EntityBoat = new EntitySailboat(speed, weight, bodyColor, + additionalColor, hull, sail); + } + } + public override void DrawTransport(Graphics g) + { + if (EntityBoat is not EntitySailboat sailboat) + { + return; + } + Pen pen = new(Color.Black); + Brush additionalBrush = new + SolidBrush(sailboat.AdditionalColor); + + //усиленный корпус парусной лодки + if (sailboat.Hull) { Point[] hullCooler = new Point[] { @@ -99,35 +43,14 @@ namespace Sailboat }; g.FillPolygon(additionalBrush, hullCooler); g.DrawPolygon(pen, hullCooler); - } - - //Основной корпус парусной лодки - Brush Brush = new - SolidBrush(EntitySailboat.BodyColor); - - Point[] hull = new Point[] - { - new Point(_startPosX + 10, _startPosY + 90), - new Point(_startPosX + 110, _startPosY + 90), - new Point(_startPosX + 140, _startPosY + 120), - new Point(_startPosX + 110, _startPosY + 150), - new Point(_startPosX + 10, _startPosY + 150) - }; - g.FillPolygon(Brush, hull); - g.DrawPolygon(pen, hull); - - Brush addBrush = new - SolidBrush(Color.Aqua); - - //Каюта парусной лодки - g.FillEllipse(addBrush, _startPosX + 20, _startPosY + 100, 90, 40); - g.DrawEllipse(pen, _startPosX + 20, _startPosY + 100, 90, 40); - + } + base.DrawTransport(g); + //Парус с флагом - if (EntitySailboat.Sail) + if (sailboat.Sail) { Brush sailBrush = new - SolidBrush(EntitySailboat.AdditionalColor); + SolidBrush(sailboat.AdditionalColor); Point[] sail = new Point[] { @@ -138,22 +61,21 @@ namespace Sailboat g.FillPolygon(sailBrush, sail); g.DrawPolygon(pen, sail); //Флаг + Brush addBrush = new + SolidBrush(Color.Aqua); Brush flagBrush = new - SolidBrush(EntitySailboat.AdditionalColor); + SolidBrush(sailboat.AdditionalColor); Point[] flag = new Point[] { - //new Point(_startPosX + 65, _startPosY + 125), new Point(_startPosX + 65, _startPosY - 15), new Point(_startPosX + 65, _startPosY + 10), new Point(_startPosX + 20, _startPosY + 10), new Point(_startPosX + 20, _startPosY - 15), - }; + }; g.FillPolygon(addBrush, flag); g.DrawPolygon(pen, flag); g.DrawLine(pen, new Point(_startPosX + 65, _startPosY + 130), new Point(_startPosX + 65, _startPosY - 15)); - - } } } -} \ No newline at end of file +} diff --git a/Sailboat/Sailboat/EntityBoat.cs b/Sailboat/Sailboat/EntityBoat.cs new file mode 100644 index 0000000..6f1da8a --- /dev/null +++ b/Sailboat/Sailboat/EntityBoat.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Sailboat.Entities +{ + public class EntityBoat + { + public int Speed { get; private set; } + public double Weight { get; private set; } + public Color BodyColor { get; private set; } + public double Step => (double)Speed * 100 / Weight; + public EntityBoat(int speed, double weight, Color bodyColor) + { + Speed = speed; + Weight = weight; + BodyColor = bodyColor; + } + } +} diff --git a/Sailboat/Sailboat/EntitySailboat.cs b/Sailboat/Sailboat/EntitySailboat.cs index 6514ebd..aff4b68 100644 --- a/Sailboat/Sailboat/EntitySailboat.cs +++ b/Sailboat/Sailboat/EntitySailboat.cs @@ -4,53 +4,16 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -namespace Sailboat +namespace Sailboat.Entities { - public class EntitySailboat + public class EntitySailboat : EntityBoat { - /// - /// Скорость - /// - 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 Hull { get; private set; } - /// - /// Признак (опция) наличия паруса с флагом - /// public bool Sail { get; private set; } - /// - /// Шаг перемещения парусной лодки - /// - public double Step => (double)Speed * 100 / Weight; - /// - /// Инициализация полей объекта-класса парусной лодки - /// - /// Скорость - /// Вес парусной лодки - /// Основной цвет - /// Дополнительный цвет - /// Признак наличия усиленного корпуса - /// Признак наличия паруса с флагом - public void Init(int speed, double weight, Color bodyColor, Color - additionalColor, bool hull, bool sail) + public EntitySailboat(int speed, double weight, Color bodyColor, Color + additionalColor, bool hull, bool sail) : base (speed, weight, bodyColor) { - Speed = speed; - Weight = weight; - BodyColor = bodyColor; AdditionalColor = additionalColor; Hull = hull; Sail = sail; diff --git a/Sailboat/Sailboat/Form1.Designer.cs b/Sailboat/Sailboat/Form1.Designer.cs deleted file mode 100644 index dede0e6..0000000 --- a/Sailboat/Sailboat/Form1.Designer.cs +++ /dev/null @@ -1,39 +0,0 @@ -namespace Sailboat -{ - 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 - } -} \ No newline at end of file diff --git a/Sailboat/Sailboat/Form1.cs b/Sailboat/Sailboat/Form1.cs deleted file mode 100644 index 224bdaa..0000000 --- a/Sailboat/Sailboat/Form1.cs +++ /dev/null @@ -1,10 +0,0 @@ -namespace Sailboat -{ - public partial class Form1 : Form - { - public Form1() - { - InitializeComponent(); - } - } -} \ No newline at end of file diff --git a/Sailboat/Sailboat/Form1.resx b/Sailboat/Sailboat/Form1.resx deleted file mode 100644 index 1af7de1..0000000 --- a/Sailboat/Sailboat/Form1.resx +++ /dev/null @@ -1,120 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 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/Sailboat/Sailboat/FormSailboat.Designer.cs b/Sailboat/Sailboat/FormSailboat.Designer.cs index 8acd590..1cdf24d 100644 --- a/Sailboat/Sailboat/FormSailboat.Designer.cs +++ b/Sailboat/Sailboat/FormSailboat.Designer.cs @@ -30,11 +30,14 @@ { System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FormSailboat)); pictureBoxSailboat = new PictureBox(); - buttonCreate = new Button(); + buttonCreateBoat = new Button(); buttonLeft = new Button(); buttonUp = new Button(); buttonRight = new Button(); buttonDown = new Button(); + buttonCreateSailboat = new Button(); + comboBoxStrategy = new ComboBox(); + buttonStep = new Button(); ((System.ComponentModel.ISupportInitialize)pictureBoxSailboat).BeginInit(); SuspendLayout(); // @@ -44,28 +47,29 @@ pictureBoxSailboat.Location = new Point(0, 0); pictureBoxSailboat.Margin = new Padding(3, 2, 3, 2); pictureBoxSailboat.Name = "pictureBoxSailboat"; - pictureBoxSailboat.Size = new Size(884, 461); + pictureBoxSailboat.Size = new Size(834, 461); + pictureBoxSailboat.SizeMode = PictureBoxSizeMode.AutoSize; pictureBoxSailboat.TabIndex = 0; pictureBoxSailboat.TabStop = false; // - // buttonCreate + // buttonCreateBoat // - buttonCreate.Anchor = AnchorStyles.Bottom | AnchorStyles.Left; - buttonCreate.Location = new Point(10, 417); - buttonCreate.Margin = new Padding(3, 2, 3, 2); - buttonCreate.Name = "buttonCreate"; - buttonCreate.Size = new Size(111, 30); - buttonCreate.TabIndex = 1; - buttonCreate.Text = "Создать"; - buttonCreate.UseVisualStyleBackColor = true; - buttonCreate.Click += buttonCreate_Click; + buttonCreateBoat.Anchor = AnchorStyles.Bottom | AnchorStyles.Left; + buttonCreateBoat.Location = new Point(12, 408); + buttonCreateBoat.Margin = new Padding(3, 2, 3, 2); + buttonCreateBoat.Name = "buttonCreateBoat"; + buttonCreateBoat.Size = new Size(111, 42); + buttonCreateBoat.TabIndex = 1; + buttonCreateBoat.Text = "Создать лодку"; + buttonCreateBoat.UseVisualStyleBackColor = true; + buttonCreateBoat.Click += buttonCreateBoat_Click; // // buttonLeft // buttonLeft.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; buttonLeft.BackgroundImage = (Image)resources.GetObject("buttonLeft.BackgroundImage"); buttonLeft.BackgroundImageLayout = ImageLayout.Zoom; - buttonLeft.Location = new Point(740, 423); + buttonLeft.Location = new Point(673, 420); buttonLeft.Margin = new Padding(3, 2, 3, 2); buttonLeft.Name = "buttonLeft"; buttonLeft.Size = new Size(30, 30); @@ -78,7 +82,7 @@ buttonUp.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; buttonUp.BackgroundImage = (Image)resources.GetObject("buttonUp.BackgroundImage"); buttonUp.BackgroundImageLayout = ImageLayout.Zoom; - buttonUp.Location = new Point(776, 389); + buttonUp.Location = new Point(716, 386); buttonUp.Margin = new Padding(3, 2, 3, 2); buttonUp.Name = "buttonUp"; buttonUp.Size = new Size(30, 30); @@ -91,7 +95,7 @@ buttonRight.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; buttonRight.BackgroundImage = (Image)resources.GetObject("buttonRight.BackgroundImage"); buttonRight.BackgroundImageLayout = ImageLayout.Zoom; - buttonRight.Location = new Point(812, 423); + buttonRight.Location = new Point(760, 420); buttonRight.Margin = new Padding(3, 2, 3, 2); buttonRight.Name = "buttonRight"; buttonRight.Size = new Size(30, 30); @@ -104,7 +108,7 @@ buttonDown.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; buttonDown.BackgroundImage = (Image)resources.GetObject("buttonDown.BackgroundImage"); buttonDown.BackgroundImageLayout = ImageLayout.Zoom; - buttonDown.Location = new Point(776, 423); + buttonDown.Location = new Point(716, 420); buttonDown.Margin = new Padding(3, 2, 3, 2); buttonDown.Name = "buttonDown"; buttonDown.Size = new Size(30, 30); @@ -112,33 +116,76 @@ buttonDown.UseVisualStyleBackColor = true; buttonDown.Click += buttonMove_Click; // + // buttonCreateSailboat + // + buttonCreateSailboat.Anchor = AnchorStyles.Bottom | AnchorStyles.Left; + buttonCreateSailboat.Location = new Point(145, 408); + buttonCreateSailboat.Margin = new Padding(3, 2, 3, 2); + buttonCreateSailboat.Name = "buttonCreateSailboat"; + buttonCreateSailboat.Size = new Size(111, 42); + buttonCreateSailboat.TabIndex = 6; + buttonCreateSailboat.Text = "Создать парусник"; + buttonCreateSailboat.UseVisualStyleBackColor = true; + buttonCreateSailboat.Click += buttonCreateSailboat_Click; + // + // comboBoxStrategy + // + comboBoxStrategy.Anchor = AnchorStyles.Top | AnchorStyles.Right; + comboBoxStrategy.DropDownStyle = ComboBoxStyle.DropDownList; + comboBoxStrategy.FormattingEnabled = true; + comboBoxStrategy.Items.AddRange(new object[] { "До центра", "До края" }); + comboBoxStrategy.Location = new Point(701, 0); + comboBoxStrategy.Margin = new Padding(3, 2, 3, 2); + comboBoxStrategy.Name = "comboBoxStrategy"; + comboBoxStrategy.Size = new Size(133, 23); + comboBoxStrategy.TabIndex = 7; + // + // buttonStep + // + buttonStep.Anchor = AnchorStyles.Top | AnchorStyles.Right; + buttonStep.Location = new Point(701, 27); + buttonStep.Margin = new Padding(3, 2, 3, 2); + buttonStep.Name = "buttonStep"; + buttonStep.Size = new Size(133, 23); + buttonStep.TabIndex = 8; + buttonStep.Text = "Шаг"; + buttonStep.UseVisualStyleBackColor = true; + buttonStep.Click += buttonStep_Click; + // // FormSailboat // AutoScaleDimensions = new SizeF(7F, 15F); AutoScaleMode = AutoScaleMode.Font; - ClientSize = new Size(884, 461); + ClientSize = new Size(834, 461); + Controls.Add(buttonStep); + Controls.Add(comboBoxStrategy); + Controls.Add(buttonCreateSailboat); Controls.Add(buttonDown); Controls.Add(buttonRight); Controls.Add(buttonUp); Controls.Add(buttonLeft); - Controls.Add(buttonCreate); + Controls.Add(buttonCreateBoat); Controls.Add(pictureBoxSailboat); Margin = new Padding(3, 2, 3, 2); Name = "FormSailboat"; - StartPosition = FormStartPosition.CenterParent; - Text = "Sailboat"; + StartPosition = FormStartPosition.CenterScreen; + Text = "Парусник"; Load += FormSailboat_Load; ((System.ComponentModel.ISupportInitialize)pictureBoxSailboat).EndInit(); ResumeLayout(false); + PerformLayout(); } #endregion private PictureBox pictureBoxSailboat; - private Button buttonCreate; + private Button buttonCreateBoat; private Button buttonLeft; private Button buttonUp; private Button buttonRight; private Button buttonDown; + private Button buttonCreateSailboat; + private ComboBox comboBoxStrategy; + private Button buttonStep; } } \ No newline at end of file diff --git a/Sailboat/Sailboat/FormSailboat.cs b/Sailboat/Sailboat/FormSailboat.cs index 50e8592..691d09b 100644 --- a/Sailboat/Sailboat/FormSailboat.cs +++ b/Sailboat/Sailboat/FormSailboat.cs @@ -1,37 +1,49 @@ +using Sailboat.Entities; +using Sailboat.DrawingObjects; +using Sailboat.MovementStrategy; + namespace Sailboat { public partial class FormSailboat : Form { - private DrawingSailboat? _drawingSailboat; + private DrawingBoat? _drawingBoat; + private AbstractStrategy? _abstractStrategy; public FormSailboat() { InitializeComponent(); } private void Draw() { - if (_drawingSailboat == null) + if (_drawingBoat == null) { return; } Bitmap bmp = new(pictureBoxSailboat.Width, pictureBoxSailboat.Height); Graphics gr = Graphics.FromImage(bmp); - _drawingSailboat.DrawTransport(gr); + _drawingBoat.DrawTransport(gr); pictureBoxSailboat.Image = bmp; } - private void buttonCreate_Click(object sender, EventArgs e) + private void buttonCreateBoat_Click(object sender, EventArgs e) { Random random = new(); - _drawingSailboat = new DrawingSailboat(); - _drawingSailboat.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)), + _drawingBoat = new DrawingBoat(random.Next(100, 300), random.Next(1000, 3000), Color.FromArgb(random.Next(0, 256), random.Next(0, 256), random.Next(0, 256)), pictureBoxSailboat.Width, pictureBoxSailboat.Height); + _drawingBoat.SetPosition(random.Next(10, 100), random.Next(10, + 100)); + Draw(); + } + private void buttonCreateSailboat_Click(object sender, EventArgs e) + { + Random random = new(); + _drawingBoat = new DrawingSailboat(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)), pictureBoxSailboat.Width, pictureBoxSailboat.Height); - _drawingSailboat.SetPosition(random.Next(10, 100), random.Next(10, 100)); + _drawingBoat.SetPosition(random.Next(10, 100), random.Next(10, 100)); Draw(); } private void buttonMove_Click(object sender, EventArgs e) { - if (_drawingSailboat == null) + if (_drawingBoat == null) { return; } @@ -39,20 +51,54 @@ namespace Sailboat switch (name) { case "buttonUp": - _drawingSailboat.MoveTransport(DirectionType.Up); + _drawingBoat.MoveTransport(DirectionType.Up); break; case "buttonDown": - _drawingSailboat.MoveTransport(DirectionType.Down); + _drawingBoat.MoveTransport(DirectionType.Down); break; case "buttonLeft": - _drawingSailboat.MoveTransport(DirectionType.Left); + _drawingBoat.MoveTransport(DirectionType.Left); break; case "buttonRight": - _drawingSailboat.MoveTransport(DirectionType.Right); + _drawingBoat.MoveTransport(DirectionType.Right); break; } Draw(); - + } + private void buttonStep_Click(object sender, EventArgs e) + { + if (_drawingBoat == null) + { + return; + } + if (comboBoxStrategy.Enabled) + { + _abstractStrategy = comboBoxStrategy.SelectedIndex + switch + { + 0 => new MoveToCenter(), + 1 => new MoveToBorder(), + _ => null, + }; + if (_abstractStrategy == null) + { + return; + } + _abstractStrategy.SetData(new DrawingObjectBoat(_drawingBoat), pictureBoxSailboat.Width, + pictureBoxSailboat.Height); + comboBoxStrategy.Enabled = false; + } + if (_abstractStrategy == null) + { + return; + } + _abstractStrategy.MakeStep(); + Draw(); + if (_abstractStrategy.GetStatus() == Status.Finish) + { + comboBoxStrategy.Enabled = true; + _abstractStrategy = null; + } } private void FormSailboat_Load(object sender, EventArgs e) diff --git a/Sailboat/Sailboat/IMoveableObject.cs b/Sailboat/Sailboat/IMoveableObject.cs new file mode 100644 index 0000000..6990729 --- /dev/null +++ b/Sailboat/Sailboat/IMoveableObject.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +using Sailboat.DrawingObjects; + +namespace Sailboat.MovementStrategy +{ + public interface IMoveableObject + { + /// + /// Получение координаты X объекта + /// + ObjectParameters? GetObjectPosition { get; } + /// + /// Шаг объекта + /// + int GetStep { get; } + /// + /// Проверка, можно ли переместиться по нужному направлению + /// + /// + /// + bool CheckCanMove(DirectionType direction); + /// + /// Изменение направления пермещения объекта + /// + /// Направление + void MoveObject(DirectionType direction); + } +} diff --git a/Sailboat/Sailboat/MoveToBorder.cs b/Sailboat/Sailboat/MoveToBorder.cs new file mode 100644 index 0000000..9e83e4a --- /dev/null +++ b/Sailboat/Sailboat/MoveToBorder.cs @@ -0,0 +1,57 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Sailboat.MovementStrategy +{ + public class MoveToBorder : AbstractStrategy + { + protected override bool IsTargetDestinaion() + { + var objParams = GetObjectParameters; + if (objParams == null) + { + return false; + } + return objParams.RightBorder <= FieldWidth && + objParams.RightBorder + GetStep() >= FieldWidth && + objParams.DownBorder <= FieldHeight && + objParams.DownBorder + GetStep() >= FieldHeight; + + } + protected override void MoveToTarget() + { + var objParams = GetObjectParameters; + if (objParams == null) + { + return; + } + var diffX = objParams.RightBorder - FieldWidth; + if (Math.Abs(diffX) > GetStep()) + { + if (diffX > 0) + { + MoveLeft(); + } + else + { + MoveRight(); + } + } + var diffY = objParams.DownBorder - FieldHeight; + if (Math.Abs(diffY) > GetStep()) + { + if (diffY > 0) + { + MoveUp(); + } + else + { + MoveDown(); + } + } + } + } +} diff --git a/Sailboat/Sailboat/MoveToCenter.cs b/Sailboat/Sailboat/MoveToCenter.cs new file mode 100644 index 0000000..a3392ee --- /dev/null +++ b/Sailboat/Sailboat/MoveToCenter.cs @@ -0,0 +1,56 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Sailboat.MovementStrategy +{ + public class MoveToCenter : AbstractStrategy + { + protected override bool IsTargetDestinaion() + { + var objParams = GetObjectParameters; + if (objParams == null) + { + return false; + } + return objParams.ObjectMiddleHorizontal <= FieldWidth / 2 && + objParams.ObjectMiddleHorizontal + GetStep() >= FieldWidth / 2 && + objParams.ObjectMiddleVertical <= FieldHeight / 2 && + objParams.ObjectMiddleVertical + GetStep() >= FieldHeight / 2; + } + protected override void MoveToTarget() + { + var objParams = GetObjectParameters; + if (objParams == null) + { + return; + } + var diffX = objParams.ObjectMiddleHorizontal - FieldWidth / 2; + if (Math.Abs(diffX) > GetStep()) + { + if (diffX > 0) + { + MoveLeft(); + } + else + { + MoveRight(); + } + } + var diffY = objParams.ObjectMiddleVertical - FieldHeight / 2; + if (Math.Abs(diffY) > GetStep()) + { + if (diffY > 0) + { + MoveUp(); + } + else + { + MoveDown(); + } + } + } + } +} diff --git a/Sailboat/Sailboat/ObjectParameters.cs b/Sailboat/Sailboat/ObjectParameters.cs new file mode 100644 index 0000000..f3a5888 --- /dev/null +++ b/Sailboat/Sailboat/ObjectParameters.cs @@ -0,0 +1,54 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Sailboat.MovementStrategy +{ + public class ObjectParameters + { + private readonly int _x; + private readonly int _y; + private readonly int _width; + private readonly int _height; + /// + /// Левая граница + /// + public int LeftBorder => _x; + /// + /// Верхняя граница + /// + public int TopBorder => _y; + /// + /// Правая граница + /// + public int RightBorder => _x + _width; + /// + /// Нижняя граница + /// + public int DownBorder => _y + _height; + /// + /// Середина объекта + /// + public int ObjectMiddleHorizontal => _x + _width / 2; + /// + /// Середина объекта + /// + public int ObjectMiddleVertical => _y + _height / 2; + /// + /// Конструктор + /// + /// Координата X + /// Координата Y + /// Ширина + /// Высота + public ObjectParameters(int x, int y, int width, int height) + { + _x = x; + _y = y; + _width = width; + _height = height; + } + } +} diff --git a/Sailboat/Sailboat/Status.cs b/Sailboat/Sailboat/Status.cs new file mode 100644 index 0000000..3d1bc4d --- /dev/null +++ b/Sailboat/Sailboat/Status.cs @@ -0,0 +1,18 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Sailboat.MovementStrategy +{ + /// + /// Статус выполнения операции перемещения + /// + public enum Status + { + NotInit, + InProgress, + Finish + } +} -- 2.25.1 From 2f57f176937ec33ef2c540c84de2d83831a56683 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D0=BA=D1=81=D0=B8=D0=BC=20=D0=95=D0=B3=D0=BE?= =?UTF-8?q?=D1=80=D0=BE=D0=B2?= Date: Mon, 25 Dec 2023 02:27:14 +0400 Subject: [PATCH 3/3] revert 58f5deb6409f8dd64f8ac8e8d8b7d84d23d0dad7 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit revert Готовая полностью Lab_2 Восстановление Lab_1 --- Sailboat/Sailboat/AbstractStrategy.cs | 132 ------------------- Sailboat/Sailboat/DrawingBoat.cs | 146 --------------------- Sailboat/Sailboat/DrawingObjectBoat.cs | 37 ------ Sailboat/Sailboat/DrawingSailboat.cs | 128 ++++++++++++++---- Sailboat/Sailboat/EntityBoat.cs | 22 ---- Sailboat/Sailboat/EntitySailboat.cs | 45 ++++++- Sailboat/Sailboat/Form1.Designer.cs | 39 ++++++ Sailboat/Sailboat/Form1.cs | 10 ++ Sailboat/Sailboat/Form1.resx | 120 +++++++++++++++++ Sailboat/Sailboat/FormSailboat.Designer.cs | 89 +++---------- Sailboat/Sailboat/FormSailboat.cs | 72 ++-------- Sailboat/Sailboat/IMoveableObject.cs | 33 ----- Sailboat/Sailboat/MoveToBorder.cs | 57 -------- Sailboat/Sailboat/MoveToCenter.cs | 56 -------- Sailboat/Sailboat/ObjectParameters.cs | 54 -------- Sailboat/Sailboat/Status.cs | 18 --- 16 files changed, 347 insertions(+), 711 deletions(-) delete mode 100644 Sailboat/Sailboat/AbstractStrategy.cs delete mode 100644 Sailboat/Sailboat/DrawingBoat.cs delete mode 100644 Sailboat/Sailboat/DrawingObjectBoat.cs delete mode 100644 Sailboat/Sailboat/EntityBoat.cs create mode 100644 Sailboat/Sailboat/Form1.Designer.cs create mode 100644 Sailboat/Sailboat/Form1.cs create mode 100644 Sailboat/Sailboat/Form1.resx delete mode 100644 Sailboat/Sailboat/IMoveableObject.cs delete mode 100644 Sailboat/Sailboat/MoveToBorder.cs delete mode 100644 Sailboat/Sailboat/MoveToCenter.cs delete mode 100644 Sailboat/Sailboat/ObjectParameters.cs delete mode 100644 Sailboat/Sailboat/Status.cs diff --git a/Sailboat/Sailboat/AbstractStrategy.cs b/Sailboat/Sailboat/AbstractStrategy.cs deleted file mode 100644 index fc58dd3..0000000 --- a/Sailboat/Sailboat/AbstractStrategy.cs +++ /dev/null @@ -1,132 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -using Sailboat.DrawingObjects; -namespace Sailboat.MovementStrategy -{ - public abstract class AbstractStrategy - { - /// - /// Перемещаемый объект - /// - private IMoveableObject? _moveableObject; - /// - /// Статус перемещения - /// - private Status _state = Status.NotInit; - /// - /// Ширина поля - /// - protected int FieldWidth { get; private set; } - /// - /// Высота поля - /// - protected int FieldHeight { get; private set; } - /// - /// Статус перемещения - /// - public Status GetStatus() { return _state; } - /// - /// Установка данных - /// - /// Перемещаемый объект - /// Ширина поля - /// Высота поля - public void SetData(IMoveableObject moveableObject, int width, int - height) - { - if (moveableObject == null) - { - _state = Status.NotInit; - return; - } - _state = Status.InProgress; - _moveableObject = moveableObject; - FieldWidth = width; - FieldHeight = height; - } - /// - /// Шаг перемещения - /// - public void MakeStep() - { - if (_state != Status.InProgress) - { - return; - } - if (IsTargetDestinaion()) - { - _state = Status.Finish; - return; - } - MoveToTarget(); - } - /// - /// Перемещение влево - /// - /// Результат перемещения (true - удалось переместиться, false - неудача) - protected bool MoveLeft() => MoveTo(DirectionType.Left); - /// - /// Перемещение вправо - /// - /// Результат перемещения (true - удалось переместиться, false - неудача) - protected bool MoveRight() => MoveTo(DirectionType.Right); - /// - /// Перемещение вверх - /// - /// Результат перемещения (true - удалось переместиться, false - неудача) - protected bool MoveUp() => MoveTo(DirectionType.Up); - /// - /// Перемещение вниз - /// - /// Результат перемещения (true - удалось переместиться, false - неудача) - protected bool MoveDown() => MoveTo(DirectionType.Down); - /// - /// Параметры объекта - /// - protected ObjectParameters? GetObjectParameters => - _moveableObject?.GetObjectPosition; - /// - /// Шаг объекта - /// - /// - protected int? GetStep() - { - if (_state != Status.InProgress) - { - return null; - } - return _moveableObject?.GetStep; - } - /// - /// Перемещение к цели - /// - protected abstract void MoveToTarget(); - /// - /// Достигнута ли цель - /// - /// - protected abstract bool IsTargetDestinaion(); - /// - /// Попытка перемещения в требуемом направлении - /// - /// Направление - /// Результат попытки (true - удалось переместиться, false - неудача) - private bool MoveTo(DirectionType directionType) - { - if (_state != Status.InProgress) - { - return false; - } - if (_moveableObject?.CheckCanMove(directionType) ?? false) - { - _moveableObject.MoveObject(directionType); - return true; - } - return false; - } - } -} diff --git a/Sailboat/Sailboat/DrawingBoat.cs b/Sailboat/Sailboat/DrawingBoat.cs deleted file mode 100644 index 1319e35..0000000 --- a/Sailboat/Sailboat/DrawingBoat.cs +++ /dev/null @@ -1,146 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -using Sailboat.Entities; - -namespace Sailboat.DrawingObjects -{ - public class DrawingBoat - { - public EntityBoat? EntityBoat { get; protected set; } - private int _pictureWidth; - private int _pictureHeight; - protected int _startPosX; - protected int _startPosY; - private readonly int _boatWidth = 160; - private readonly int _boatHeight = 160; - public int GetPosX => _startPosX; - public int GetPosY => _startPosY; - public int GetWidth => _boatWidth; - public int GetHeight => _boatHeight; - - - public DrawingBoat(int speed, double weight, Color bodyColor, int width, int height) - { - if (width < _boatWidth || height < _boatHeight) - { - return; - } - _pictureWidth = width; - _pictureHeight = height; - EntityBoat = new EntityBoat(speed, weight, bodyColor); - } - - protected DrawingBoat(int speed, double weight, Color bodyColor, int width, int height, int boatWidth, int boatHeight) - { - if (width < _boatWidth || height < _boatHeight) - { - return; - } - _pictureWidth = width; - _pictureHeight = height; - _boatWidth = boatWidth; - _boatHeight = boatHeight; - EntityBoat = new EntityBoat(speed, weight, bodyColor); - } - public void SetPosition(int x, int y) - { - if (x < 0 || x + _boatWidth > _pictureWidth) - { - x = 0; - } - if (y < 0 || y + _boatHeight > _pictureHeight) - { - y = 0; - } - _startPosX = x; - _startPosY = y; - } - public bool CanMove(DirectionType direction) - { - if (EntityBoat == null) - { - return false; - } - return direction switch - { - //влево - DirectionType.Left => _startPosX - EntityBoat.Step > 0, - //вверх - DirectionType.Up => _startPosY - EntityBoat.Step > 0, - // вправо - DirectionType.Right => _startPosX + EntityBoat.Step < _pictureWidth, - //вниз - DirectionType.Down => _startPosY + EntityBoat.Step < _pictureHeight, - }; - } - public void MoveTransport(DirectionType direction) - { - if (EntityBoat == null) - { - return; - } - switch (direction) - { - case DirectionType.Left: - if (_startPosX - EntityBoat.Step > 0) - { - _startPosX -= (int)EntityBoat.Step; - } - break; - case DirectionType.Up: - if ((_startPosY - 15) - EntityBoat.Step > 0) - { - _startPosY -= (int)EntityBoat.Step; - } - break; - case DirectionType.Right: - if (_startPosX + EntityBoat.Step + _boatWidth < _pictureWidth) - { - _startPosX += (int)EntityBoat.Step; - } - break; - case DirectionType.Down: - if (_startPosY + EntityBoat.Step + _boatHeight < _pictureHeight) - { - _startPosY += (int)EntityBoat.Step; - } - break; - } - } - public virtual void DrawTransport(Graphics g) - { - if (EntityBoat == null) - { - return; - } - Pen pen = new(Color.Black); - - //Основной корпус лодки - Brush Brush = new - SolidBrush(EntityBoat.BodyColor); - - Point[] hull = new Point[] - { - new Point(_startPosX + 10, _startPosY + 90), - new Point(_startPosX + 110, _startPosY + 90), - new Point(_startPosX + 140, _startPosY + 120), - new Point(_startPosX + 110, _startPosY + 150), - new Point(_startPosX + 10, _startPosY + 150) - }; - g.FillPolygon(Brush, hull); - g.DrawPolygon(pen, hull); - - Brush addBrush = new - SolidBrush(Color.Aqua); - - //Каюта лодки - g.FillEllipse(addBrush, _startPosX + 20, _startPosY + 100, 90, 40); - g.DrawEllipse(pen, _startPosX + 20, _startPosY + 100, 90, 40); - } - } -} - diff --git a/Sailboat/Sailboat/DrawingObjectBoat.cs b/Sailboat/Sailboat/DrawingObjectBoat.cs deleted file mode 100644 index 6c7f211..0000000 --- a/Sailboat/Sailboat/DrawingObjectBoat.cs +++ /dev/null @@ -1,37 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -using Sailboat.DrawingObjects; - -namespace Sailboat.MovementStrategy -{ - public class DrawingObjectBoat : IMoveableObject - { - private readonly DrawingBoat? _drawingBoat = null; - public DrawingObjectBoat(DrawingBoat drawingBoat) - { - _drawingBoat = drawingBoat; - } - public ObjectParameters? GetObjectPosition - { - get - { - if (_drawingBoat == null || _drawingBoat.EntityBoat == - null) - { - return null; - } - return new ObjectParameters(_drawingBoat.GetPosX, _drawingBoat.GetPosY, _drawingBoat.GetWidth, _drawingBoat.GetHeight); - } - } - public int GetStep => (int)(_drawingBoat?.EntityBoat?.Step ?? 0); - public bool CheckCanMove(DirectionType direction) => - _drawingBoat?.CanMove(direction) ?? false; - public void MoveObject(DirectionType direction) => - _drawingBoat?.MoveTransport(direction); - - } -} diff --git a/Sailboat/Sailboat/DrawingSailboat.cs b/Sailboat/Sailboat/DrawingSailboat.cs index c25780b..1a40654 100644 --- a/Sailboat/Sailboat/DrawingSailboat.cs +++ b/Sailboat/Sailboat/DrawingSailboat.cs @@ -2,36 +2,92 @@ using System.Collections.Generic; using System.Drawing; using System.Linq; +using System.Reflection; using System.Text; using System.Threading.Tasks; -using Sailboat.Entities; - -namespace Sailboat.DrawingObjects +namespace Sailboat { - public class DrawingSailboat : DrawingBoat + public class DrawingSailboat { - public DrawingSailboat(int speed, double weight, Color bodyColor, Color additionalColor, bool hull, bool sail, int width, int height) : - base(speed, weight, bodyColor, width, height, 160, 160) + public EntitySailboat? EntitySailboat { get; private set; } + private int _pictureWidth; + private int _pictureHeight; + private int _startPosX; + private int _startPosY; + private readonly int _boatWidth = 160; + private readonly int _boatHeight = 160; + public bool Init(int speed, double weight, Color bodyColor, Color additionalColor, bool hull, bool sail, int width, int height) { - if (EntityBoat != null) + if (width < _boatWidth || height < _boatHeight) { - EntityBoat = new EntitySailboat(speed, weight, bodyColor, - additionalColor, hull, sail); + return false; } + _pictureWidth = width; + _pictureHeight = height; + EntitySailboat = new EntitySailboat(); + EntitySailboat.Init(speed, weight, bodyColor, additionalColor, hull, sail); + return true; } - public override void DrawTransport(Graphics g) + public void SetPosition(int x, int y) { - if (EntityBoat is not EntitySailboat sailboat) + if (x < 0 || x + _boatWidth > _pictureWidth) + { + x = 0; + } + if (y < 0 || y + _boatHeight > _pictureHeight) + { + y = 0; + } + _startPosX = x; + _startPosY = y; + } + public void MoveTransport(DirectionType direction) + { + if (EntitySailboat == null) { return; } - Pen pen = new(Color.Black); + switch (direction) + { + case DirectionType.Left: + if (_startPosX - EntitySailboat.Step > 0) + { + _startPosX -= (int)EntitySailboat.Step; + } + break; + case DirectionType.Up: + if ((_startPosY - 15) - EntitySailboat.Step > 0) + { + _startPosY-= (int)EntitySailboat.Step; + } + break; + case DirectionType.Right: + if (_startPosX + EntitySailboat.Step + _boatWidth < _pictureWidth) + { + _startPosX += (int)EntitySailboat.Step; + } + break; + case DirectionType.Down: + if (_startPosY + EntitySailboat.Step + _boatHeight < _pictureHeight) + { + _startPosY += (int)EntitySailboat.Step; + } + break; + } + } + public void DrawTransport(Graphics g) + { + if (EntitySailboat == null) + { + return; + } + Pen pen = new(Color.Black, 4); Brush additionalBrush = new - SolidBrush(sailboat.AdditionalColor); + SolidBrush(EntitySailboat.AdditionalColor); - //усиленный корпус парусной лодки - if (sailboat.Hull) + //Усиленный корпус парусной лодки + if (EntitySailboat.Hull) { Point[] hullCooler = new Point[] { @@ -43,14 +99,35 @@ namespace Sailboat.DrawingObjects }; g.FillPolygon(additionalBrush, hullCooler); g.DrawPolygon(pen, hullCooler); - } - base.DrawTransport(g); - + } + + //Основной корпус парусной лодки + Brush Brush = new + SolidBrush(EntitySailboat.BodyColor); + + Point[] hull = new Point[] + { + new Point(_startPosX + 10, _startPosY + 90), + new Point(_startPosX + 110, _startPosY + 90), + new Point(_startPosX + 140, _startPosY + 120), + new Point(_startPosX + 110, _startPosY + 150), + new Point(_startPosX + 10, _startPosY + 150) + }; + g.FillPolygon(Brush, hull); + g.DrawPolygon(pen, hull); + + Brush addBrush = new + SolidBrush(Color.Aqua); + + //Каюта парусной лодки + g.FillEllipse(addBrush, _startPosX + 20, _startPosY + 100, 90, 40); + g.DrawEllipse(pen, _startPosX + 20, _startPosY + 100, 90, 40); + //Парус с флагом - if (sailboat.Sail) + if (EntitySailboat.Sail) { Brush sailBrush = new - SolidBrush(sailboat.AdditionalColor); + SolidBrush(EntitySailboat.AdditionalColor); Point[] sail = new Point[] { @@ -61,21 +138,22 @@ namespace Sailboat.DrawingObjects g.FillPolygon(sailBrush, sail); g.DrawPolygon(pen, sail); //Флаг - Brush addBrush = new - SolidBrush(Color.Aqua); Brush flagBrush = new - SolidBrush(sailboat.AdditionalColor); + SolidBrush(EntitySailboat.AdditionalColor); Point[] flag = new Point[] { + //new Point(_startPosX + 65, _startPosY + 125), new Point(_startPosX + 65, _startPosY - 15), new Point(_startPosX + 65, _startPosY + 10), new Point(_startPosX + 20, _startPosY + 10), new Point(_startPosX + 20, _startPosY - 15), - }; + }; g.FillPolygon(addBrush, flag); g.DrawPolygon(pen, flag); g.DrawLine(pen, new Point(_startPosX + 65, _startPosY + 130), new Point(_startPosX + 65, _startPosY - 15)); + + } } } -} +} \ No newline at end of file diff --git a/Sailboat/Sailboat/EntityBoat.cs b/Sailboat/Sailboat/EntityBoat.cs deleted file mode 100644 index 6f1da8a..0000000 --- a/Sailboat/Sailboat/EntityBoat.cs +++ /dev/null @@ -1,22 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace Sailboat.Entities -{ - public class EntityBoat - { - public int Speed { get; private set; } - public double Weight { get; private set; } - public Color BodyColor { get; private set; } - public double Step => (double)Speed * 100 / Weight; - public EntityBoat(int speed, double weight, Color bodyColor) - { - Speed = speed; - Weight = weight; - BodyColor = bodyColor; - } - } -} diff --git a/Sailboat/Sailboat/EntitySailboat.cs b/Sailboat/Sailboat/EntitySailboat.cs index aff4b68..6514ebd 100644 --- a/Sailboat/Sailboat/EntitySailboat.cs +++ b/Sailboat/Sailboat/EntitySailboat.cs @@ -4,16 +4,53 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -namespace Sailboat.Entities +namespace Sailboat { - public class EntitySailboat : EntityBoat + public class EntitySailboat { + /// + /// Скорость + /// + 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 Hull { get; private set; } + /// + /// Признак (опция) наличия паруса с флагом + /// public bool Sail { get; private set; } - public EntitySailboat(int speed, double weight, Color bodyColor, Color - additionalColor, bool hull, bool sail) : base (speed, weight, bodyColor) + /// + /// Шаг перемещения парусной лодки + /// + public double Step => (double)Speed * 100 / Weight; + /// + /// Инициализация полей объекта-класса парусной лодки + /// + /// Скорость + /// Вес парусной лодки + /// Основной цвет + /// Дополнительный цвет + /// Признак наличия усиленного корпуса + /// Признак наличия паруса с флагом + public void Init(int speed, double weight, Color bodyColor, Color + additionalColor, bool hull, bool sail) { + Speed = speed; + Weight = weight; + BodyColor = bodyColor; AdditionalColor = additionalColor; Hull = hull; Sail = sail; diff --git a/Sailboat/Sailboat/Form1.Designer.cs b/Sailboat/Sailboat/Form1.Designer.cs new file mode 100644 index 0000000..dede0e6 --- /dev/null +++ b/Sailboat/Sailboat/Form1.Designer.cs @@ -0,0 +1,39 @@ +namespace Sailboat +{ + 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 + } +} \ No newline at end of file diff --git a/Sailboat/Sailboat/Form1.cs b/Sailboat/Sailboat/Form1.cs new file mode 100644 index 0000000..224bdaa --- /dev/null +++ b/Sailboat/Sailboat/Form1.cs @@ -0,0 +1,10 @@ +namespace Sailboat +{ + public partial class Form1 : Form + { + public Form1() + { + InitializeComponent(); + } + } +} \ No newline at end of file diff --git a/Sailboat/Sailboat/Form1.resx b/Sailboat/Sailboat/Form1.resx new file mode 100644 index 0000000..8b2ff64 --- /dev/null +++ b/Sailboat/Sailboat/Form1.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/Sailboat/Sailboat/FormSailboat.Designer.cs b/Sailboat/Sailboat/FormSailboat.Designer.cs index 1cdf24d..8acd590 100644 --- a/Sailboat/Sailboat/FormSailboat.Designer.cs +++ b/Sailboat/Sailboat/FormSailboat.Designer.cs @@ -30,14 +30,11 @@ { System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FormSailboat)); pictureBoxSailboat = new PictureBox(); - buttonCreateBoat = new Button(); + buttonCreate = new Button(); buttonLeft = new Button(); buttonUp = new Button(); buttonRight = new Button(); buttonDown = new Button(); - buttonCreateSailboat = new Button(); - comboBoxStrategy = new ComboBox(); - buttonStep = new Button(); ((System.ComponentModel.ISupportInitialize)pictureBoxSailboat).BeginInit(); SuspendLayout(); // @@ -47,29 +44,28 @@ pictureBoxSailboat.Location = new Point(0, 0); pictureBoxSailboat.Margin = new Padding(3, 2, 3, 2); pictureBoxSailboat.Name = "pictureBoxSailboat"; - pictureBoxSailboat.Size = new Size(834, 461); - pictureBoxSailboat.SizeMode = PictureBoxSizeMode.AutoSize; + pictureBoxSailboat.Size = new Size(884, 461); pictureBoxSailboat.TabIndex = 0; pictureBoxSailboat.TabStop = false; // - // buttonCreateBoat + // buttonCreate // - buttonCreateBoat.Anchor = AnchorStyles.Bottom | AnchorStyles.Left; - buttonCreateBoat.Location = new Point(12, 408); - buttonCreateBoat.Margin = new Padding(3, 2, 3, 2); - buttonCreateBoat.Name = "buttonCreateBoat"; - buttonCreateBoat.Size = new Size(111, 42); - buttonCreateBoat.TabIndex = 1; - buttonCreateBoat.Text = "Создать лодку"; - buttonCreateBoat.UseVisualStyleBackColor = true; - buttonCreateBoat.Click += buttonCreateBoat_Click; + buttonCreate.Anchor = AnchorStyles.Bottom | AnchorStyles.Left; + buttonCreate.Location = new Point(10, 417); + buttonCreate.Margin = new Padding(3, 2, 3, 2); + buttonCreate.Name = "buttonCreate"; + buttonCreate.Size = new Size(111, 30); + buttonCreate.TabIndex = 1; + buttonCreate.Text = "Создать"; + buttonCreate.UseVisualStyleBackColor = true; + buttonCreate.Click += buttonCreate_Click; // // buttonLeft // buttonLeft.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; buttonLeft.BackgroundImage = (Image)resources.GetObject("buttonLeft.BackgroundImage"); buttonLeft.BackgroundImageLayout = ImageLayout.Zoom; - buttonLeft.Location = new Point(673, 420); + buttonLeft.Location = new Point(740, 423); buttonLeft.Margin = new Padding(3, 2, 3, 2); buttonLeft.Name = "buttonLeft"; buttonLeft.Size = new Size(30, 30); @@ -82,7 +78,7 @@ buttonUp.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; buttonUp.BackgroundImage = (Image)resources.GetObject("buttonUp.BackgroundImage"); buttonUp.BackgroundImageLayout = ImageLayout.Zoom; - buttonUp.Location = new Point(716, 386); + buttonUp.Location = new Point(776, 389); buttonUp.Margin = new Padding(3, 2, 3, 2); buttonUp.Name = "buttonUp"; buttonUp.Size = new Size(30, 30); @@ -95,7 +91,7 @@ buttonRight.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; buttonRight.BackgroundImage = (Image)resources.GetObject("buttonRight.BackgroundImage"); buttonRight.BackgroundImageLayout = ImageLayout.Zoom; - buttonRight.Location = new Point(760, 420); + buttonRight.Location = new Point(812, 423); buttonRight.Margin = new Padding(3, 2, 3, 2); buttonRight.Name = "buttonRight"; buttonRight.Size = new Size(30, 30); @@ -108,7 +104,7 @@ buttonDown.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; buttonDown.BackgroundImage = (Image)resources.GetObject("buttonDown.BackgroundImage"); buttonDown.BackgroundImageLayout = ImageLayout.Zoom; - buttonDown.Location = new Point(716, 420); + buttonDown.Location = new Point(776, 423); buttonDown.Margin = new Padding(3, 2, 3, 2); buttonDown.Name = "buttonDown"; buttonDown.Size = new Size(30, 30); @@ -116,76 +112,33 @@ buttonDown.UseVisualStyleBackColor = true; buttonDown.Click += buttonMove_Click; // - // buttonCreateSailboat - // - buttonCreateSailboat.Anchor = AnchorStyles.Bottom | AnchorStyles.Left; - buttonCreateSailboat.Location = new Point(145, 408); - buttonCreateSailboat.Margin = new Padding(3, 2, 3, 2); - buttonCreateSailboat.Name = "buttonCreateSailboat"; - buttonCreateSailboat.Size = new Size(111, 42); - buttonCreateSailboat.TabIndex = 6; - buttonCreateSailboat.Text = "Создать парусник"; - buttonCreateSailboat.UseVisualStyleBackColor = true; - buttonCreateSailboat.Click += buttonCreateSailboat_Click; - // - // comboBoxStrategy - // - comboBoxStrategy.Anchor = AnchorStyles.Top | AnchorStyles.Right; - comboBoxStrategy.DropDownStyle = ComboBoxStyle.DropDownList; - comboBoxStrategy.FormattingEnabled = true; - comboBoxStrategy.Items.AddRange(new object[] { "До центра", "До края" }); - comboBoxStrategy.Location = new Point(701, 0); - comboBoxStrategy.Margin = new Padding(3, 2, 3, 2); - comboBoxStrategy.Name = "comboBoxStrategy"; - comboBoxStrategy.Size = new Size(133, 23); - comboBoxStrategy.TabIndex = 7; - // - // buttonStep - // - buttonStep.Anchor = AnchorStyles.Top | AnchorStyles.Right; - buttonStep.Location = new Point(701, 27); - buttonStep.Margin = new Padding(3, 2, 3, 2); - buttonStep.Name = "buttonStep"; - buttonStep.Size = new Size(133, 23); - buttonStep.TabIndex = 8; - buttonStep.Text = "Шаг"; - buttonStep.UseVisualStyleBackColor = true; - buttonStep.Click += buttonStep_Click; - // // FormSailboat // AutoScaleDimensions = new SizeF(7F, 15F); AutoScaleMode = AutoScaleMode.Font; - ClientSize = new Size(834, 461); - Controls.Add(buttonStep); - Controls.Add(comboBoxStrategy); - Controls.Add(buttonCreateSailboat); + ClientSize = new Size(884, 461); Controls.Add(buttonDown); Controls.Add(buttonRight); Controls.Add(buttonUp); Controls.Add(buttonLeft); - Controls.Add(buttonCreateBoat); + Controls.Add(buttonCreate); Controls.Add(pictureBoxSailboat); Margin = new Padding(3, 2, 3, 2); Name = "FormSailboat"; - StartPosition = FormStartPosition.CenterScreen; - Text = "Парусник"; + StartPosition = FormStartPosition.CenterParent; + Text = "Sailboat"; Load += FormSailboat_Load; ((System.ComponentModel.ISupportInitialize)pictureBoxSailboat).EndInit(); ResumeLayout(false); - PerformLayout(); } #endregion private PictureBox pictureBoxSailboat; - private Button buttonCreateBoat; + private Button buttonCreate; private Button buttonLeft; private Button buttonUp; private Button buttonRight; private Button buttonDown; - private Button buttonCreateSailboat; - private ComboBox comboBoxStrategy; - private Button buttonStep; } } \ No newline at end of file diff --git a/Sailboat/Sailboat/FormSailboat.cs b/Sailboat/Sailboat/FormSailboat.cs index 691d09b..50e8592 100644 --- a/Sailboat/Sailboat/FormSailboat.cs +++ b/Sailboat/Sailboat/FormSailboat.cs @@ -1,49 +1,37 @@ -using Sailboat.Entities; -using Sailboat.DrawingObjects; -using Sailboat.MovementStrategy; - namespace Sailboat { public partial class FormSailboat : Form { - private DrawingBoat? _drawingBoat; - private AbstractStrategy? _abstractStrategy; + private DrawingSailboat? _drawingSailboat; public FormSailboat() { InitializeComponent(); } private void Draw() { - if (_drawingBoat == null) + if (_drawingSailboat == null) { return; } Bitmap bmp = new(pictureBoxSailboat.Width, pictureBoxSailboat.Height); Graphics gr = Graphics.FromImage(bmp); - _drawingBoat.DrawTransport(gr); + _drawingSailboat.DrawTransport(gr); pictureBoxSailboat.Image = bmp; } - private void buttonCreateBoat_Click(object sender, EventArgs e) + private void buttonCreate_Click(object sender, EventArgs e) { Random random = new(); - _drawingBoat = new DrawingBoat(random.Next(100, 300), random.Next(1000, 3000), Color.FromArgb(random.Next(0, 256), random.Next(0, 256), random.Next(0, 256)), pictureBoxSailboat.Width, pictureBoxSailboat.Height); - _drawingBoat.SetPosition(random.Next(10, 100), random.Next(10, - 100)); - Draw(); - } - private void buttonCreateSailboat_Click(object sender, EventArgs e) - { - Random random = new(); - _drawingBoat = new DrawingSailboat(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)), + _drawingSailboat = new DrawingSailboat(); + _drawingSailboat.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)), pictureBoxSailboat.Width, pictureBoxSailboat.Height); - _drawingBoat.SetPosition(random.Next(10, 100), random.Next(10, 100)); + _drawingSailboat.SetPosition(random.Next(10, 100), random.Next(10, 100)); Draw(); } private void buttonMove_Click(object sender, EventArgs e) { - if (_drawingBoat == null) + if (_drawingSailboat == null) { return; } @@ -51,54 +39,20 @@ namespace Sailboat switch (name) { case "buttonUp": - _drawingBoat.MoveTransport(DirectionType.Up); + _drawingSailboat.MoveTransport(DirectionType.Up); break; case "buttonDown": - _drawingBoat.MoveTransport(DirectionType.Down); + _drawingSailboat.MoveTransport(DirectionType.Down); break; case "buttonLeft": - _drawingBoat.MoveTransport(DirectionType.Left); + _drawingSailboat.MoveTransport(DirectionType.Left); break; case "buttonRight": - _drawingBoat.MoveTransport(DirectionType.Right); + _drawingSailboat.MoveTransport(DirectionType.Right); break; } Draw(); - } - private void buttonStep_Click(object sender, EventArgs e) - { - if (_drawingBoat == null) - { - return; - } - if (comboBoxStrategy.Enabled) - { - _abstractStrategy = comboBoxStrategy.SelectedIndex - switch - { - 0 => new MoveToCenter(), - 1 => new MoveToBorder(), - _ => null, - }; - if (_abstractStrategy == null) - { - return; - } - _abstractStrategy.SetData(new DrawingObjectBoat(_drawingBoat), pictureBoxSailboat.Width, - pictureBoxSailboat.Height); - comboBoxStrategy.Enabled = false; - } - if (_abstractStrategy == null) - { - return; - } - _abstractStrategy.MakeStep(); - Draw(); - if (_abstractStrategy.GetStatus() == Status.Finish) - { - comboBoxStrategy.Enabled = true; - _abstractStrategy = null; - } + } private void FormSailboat_Load(object sender, EventArgs e) diff --git a/Sailboat/Sailboat/IMoveableObject.cs b/Sailboat/Sailboat/IMoveableObject.cs deleted file mode 100644 index 6990729..0000000 --- a/Sailboat/Sailboat/IMoveableObject.cs +++ /dev/null @@ -1,33 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -using Sailboat.DrawingObjects; - -namespace Sailboat.MovementStrategy -{ - public interface IMoveableObject - { - /// - /// Получение координаты X объекта - /// - ObjectParameters? GetObjectPosition { get; } - /// - /// Шаг объекта - /// - int GetStep { get; } - /// - /// Проверка, можно ли переместиться по нужному направлению - /// - /// - /// - bool CheckCanMove(DirectionType direction); - /// - /// Изменение направления пермещения объекта - /// - /// Направление - void MoveObject(DirectionType direction); - } -} diff --git a/Sailboat/Sailboat/MoveToBorder.cs b/Sailboat/Sailboat/MoveToBorder.cs deleted file mode 100644 index 9e83e4a..0000000 --- a/Sailboat/Sailboat/MoveToBorder.cs +++ /dev/null @@ -1,57 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace Sailboat.MovementStrategy -{ - public class MoveToBorder : AbstractStrategy - { - protected override bool IsTargetDestinaion() - { - var objParams = GetObjectParameters; - if (objParams == null) - { - return false; - } - return objParams.RightBorder <= FieldWidth && - objParams.RightBorder + GetStep() >= FieldWidth && - objParams.DownBorder <= FieldHeight && - objParams.DownBorder + GetStep() >= FieldHeight; - - } - protected override void MoveToTarget() - { - var objParams = GetObjectParameters; - if (objParams == null) - { - return; - } - var diffX = objParams.RightBorder - FieldWidth; - if (Math.Abs(diffX) > GetStep()) - { - if (diffX > 0) - { - MoveLeft(); - } - else - { - MoveRight(); - } - } - var diffY = objParams.DownBorder - FieldHeight; - if (Math.Abs(diffY) > GetStep()) - { - if (diffY > 0) - { - MoveUp(); - } - else - { - MoveDown(); - } - } - } - } -} diff --git a/Sailboat/Sailboat/MoveToCenter.cs b/Sailboat/Sailboat/MoveToCenter.cs deleted file mode 100644 index a3392ee..0000000 --- a/Sailboat/Sailboat/MoveToCenter.cs +++ /dev/null @@ -1,56 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace Sailboat.MovementStrategy -{ - public class MoveToCenter : AbstractStrategy - { - protected override bool IsTargetDestinaion() - { - var objParams = GetObjectParameters; - if (objParams == null) - { - return false; - } - return objParams.ObjectMiddleHorizontal <= FieldWidth / 2 && - objParams.ObjectMiddleHorizontal + GetStep() >= FieldWidth / 2 && - objParams.ObjectMiddleVertical <= FieldHeight / 2 && - objParams.ObjectMiddleVertical + GetStep() >= FieldHeight / 2; - } - protected override void MoveToTarget() - { - var objParams = GetObjectParameters; - if (objParams == null) - { - return; - } - var diffX = objParams.ObjectMiddleHorizontal - FieldWidth / 2; - if (Math.Abs(diffX) > GetStep()) - { - if (diffX > 0) - { - MoveLeft(); - } - else - { - MoveRight(); - } - } - var diffY = objParams.ObjectMiddleVertical - FieldHeight / 2; - if (Math.Abs(diffY) > GetStep()) - { - if (diffY > 0) - { - MoveUp(); - } - else - { - MoveDown(); - } - } - } - } -} diff --git a/Sailboat/Sailboat/ObjectParameters.cs b/Sailboat/Sailboat/ObjectParameters.cs deleted file mode 100644 index f3a5888..0000000 --- a/Sailboat/Sailboat/ObjectParameters.cs +++ /dev/null @@ -1,54 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace Sailboat.MovementStrategy -{ - public class ObjectParameters - { - private readonly int _x; - private readonly int _y; - private readonly int _width; - private readonly int _height; - /// - /// Левая граница - /// - public int LeftBorder => _x; - /// - /// Верхняя граница - /// - public int TopBorder => _y; - /// - /// Правая граница - /// - public int RightBorder => _x + _width; - /// - /// Нижняя граница - /// - public int DownBorder => _y + _height; - /// - /// Середина объекта - /// - public int ObjectMiddleHorizontal => _x + _width / 2; - /// - /// Середина объекта - /// - public int ObjectMiddleVertical => _y + _height / 2; - /// - /// Конструктор - /// - /// Координата X - /// Координата Y - /// Ширина - /// Высота - public ObjectParameters(int x, int y, int width, int height) - { - _x = x; - _y = y; - _width = width; - _height = height; - } - } -} diff --git a/Sailboat/Sailboat/Status.cs b/Sailboat/Sailboat/Status.cs deleted file mode 100644 index 3d1bc4d..0000000 --- a/Sailboat/Sailboat/Status.cs +++ /dev/null @@ -1,18 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace Sailboat.MovementStrategy -{ - /// - /// Статус выполнения операции перемещения - /// - public enum Status - { - NotInit, - InProgress, - Finish - } -} -- 2.25.1